From 12ff3f2006624dc2219cee7ce94d3c382c21023b Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Mon, 8 Jun 2026 19:43:13 -0300 Subject: [PATCH 01/15] android build support --- CMakeLists.txt | 13 ++- code/cfile/cfile.cpp | 7 +- code/ddsutils/ddsutils.cpp | 26 +++++ code/external_dll/externalcode.h | 17 ++++ code/graphics/2d.cpp | 4 + code/graphics/opengl/es_compatibility.h | 1 + code/graphics/opengl/gropengl.cpp | 4 +- code/osapi/osapi.cpp | 130 ++++++++++++++++++++++++ code/osapi/osapi.h | 14 +++ code/sound/openal.h | 2 +- code/windows_stub/stubs.cpp | 4 + freespace2/CMakeLists.txt | 36 ++++++- freespace2/SDLGraphicsOperations.cpp | 5 + freespace2/freespace.cpp | 7 ++ lib/FFmpeg.cmake | 6 +- lib/OpenAL.cmake | 2 +- lib/SDL2.cmake | 4 +- lib/freetype.cmake | 7 +- lib/prebuilt.cmake | 14 +++ 19 files changed, 284 insertions(+), 19 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 27279b799f8..2c1422498fc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -47,6 +47,15 @@ endif() PROJECT(FS2_Open LANGUAGES ${FSO_LANGUAGES}) +if (ANDROID) + message(STATUS "Building for Android (NDK)") + add_definitions(-DPLATFORM_ANDROID) + set(FSO_BUILD_INCLUDED_LIBS ON FORCE) + set(USING_PREBUILT_LIBS ON FORCE) + set(SDL2_USE_PRECOMPILED ON FORCE) + set(OPENAL_USE_PRECOMPILED ON FORCE) +endif() + # Check if the external modules exists IF(NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake/external/rpavlik-cmake-modules/launcher-templates") message(FATAL_ERROR "External submodules could not be found. Please make sure you have updated your submodules.") @@ -96,8 +105,8 @@ OPTION(FSO_DEVELOPMENT_MODE "Generate binaries in development mode, only use if OPTION(FSO_BUILD_QTFRED "Build qtFRED2 binary" OFF) -IF(WIN32 OR APPLE) - # On windows and mac the default should be to always build the included libraries +IF(WIN32 OR APPLE OR ANDROID) + # On windows, mac and android the default should be to always build the included libraries SET(FSO_BUILD_INCLUDED_LIBS_DEFAULT ON) ELSE() SET(FSO_BUILD_INCLUDED_LIBS_DEFAULT OFF) diff --git a/code/cfile/cfile.cpp b/code/cfile/cfile.cpp index c344f1f8e07..c828c093f07 100644 --- a/code/cfile/cfile.cpp +++ b/code/cfile/cfile.cpp @@ -185,7 +185,12 @@ int cfile_init(const char *exe_dir, const char *cdrom_dir) char buf[CFILE_ROOT_DIRECTORY_LEN]; - strncpy(buf, exe_dir, CFILE_ROOT_DIRECTORY_LEN - 1); + #ifndef __ANDROID__ + strncpy(buf, exe_dir, CFILE_ROOT_DIRECTORY_LEN - 1); + #else + (void)exe_dir; + strncpy(buf, os_get_working_folder_path().c_str(), CFILE_ROOT_DIRECTORY_LEN - 1); + #endif buf[CFILE_ROOT_DIRECTORY_LEN - 1] = '\0'; diff --git a/code/ddsutils/ddsutils.cpp b/code/ddsutils/ddsutils.cpp index a843a874495..d8b467af78f 100644 --- a/code/ddsutils/ddsutils.cpp +++ b/code/ddsutils/ddsutils.cpp @@ -74,6 +74,28 @@ static bool conversion_needed(const DDS_HEADER &dds_header) return false; } +#ifdef __ANDROID__ +// Auto-determine max texture size based on avail device ram for software decompression +// 128 for <4GB, 256 for < 8GB, 512 for < 12GB and finally 1024 +static size_t calculate_resize_max_size() +{ + size_t size = 1024; + size_t ram_mib = SDL_GetSystemRAM(); + + if (ram_mib > 0) + { + if (ram_mib < 4 * 1024) // < 4GB + return 128; + if (ram_mib < 8 * 1024) // < 8GB + return 256; + if (ram_mib < 12 * 1024) // < 12GB + return 512; + } + + return size; +} +#endif + // Memory usage for uncompressed textures is quite high. Some MVP assets can // require well over a GB of VRAM for a single ship after conversion. To help // alleviate this we need to resize those textures where possible. At 1024x1024 @@ -85,7 +107,11 @@ static bool conversion_needed(const DDS_HEADER &dds_header) // returns: number of mipmap levels to skip static uint conversion_resize(DDS_HEADER &dds_header) { +#ifdef __ANDROID__ + const size_t MAX_SIZE = calculate_resize_max_size(); +#else const size_t MAX_SIZE = 1024; +#endif uint width, height, depth, offset = 0; if (dds_header.dwMipMapCount <= 1) { diff --git a/code/external_dll/externalcode.h b/code/external_dll/externalcode.h index eebdee4cae2..1b82f340199 100644 --- a/code/external_dll/externalcode.h +++ b/code/external_dll/externalcode.h @@ -29,6 +29,23 @@ class SCP_ExternalCode return FALSE; m_library = SDL_LoadObject(externlib); + +#ifdef __ANDROID__ + if (m_library == NULL) { + auto android_path = SDL_AndroidGetInternalStoragePath(); + if (android_path != nullptr) { + SCP_string android_full_path = android_path; + if (android_full_path.back() != DIR_SEPARATOR_CHAR) { + android_full_path += DIR_SEPARATOR_CHAR; + } + android_full_path += SCP_string("natives") + DIR_SEPARATOR_CHAR + externlib; + #ifndef NDEBUG + mprintf(("Calling SDL_LoadObject with the following path: '%s'\n", android_full_path.c_str())); + #endif + m_library = SDL_LoadObject(android_full_path.c_str()); + } + } +#endif #ifndef NDEBUG if (m_library == NULL) diff --git a/code/graphics/2d.cpp b/code/graphics/2d.cpp index 189227e8912..bda42a19e56 100644 --- a/code/graphics/2d.cpp +++ b/code/graphics/2d.cpp @@ -220,7 +220,11 @@ const auto LightingOption __UNUSED = options::OptionBuilder("Graphics.Light .parser(parse_lighting_func) .finish(); +#ifndef __ANDROID__ os::ViewportState Gr_configured_window_state = os::ViewportState::Fullscreen; +#else +os::ViewportState Gr_configured_window_state = os::ViewportState::Borderless; +#endif static bool mode_change_func(os::ViewportState state, bool initial) { diff --git a/code/graphics/opengl/es_compatibility.h b/code/graphics/opengl/es_compatibility.h index 6b78398cf0a..9ade09b44fb 100644 --- a/code/graphics/opengl/es_compatibility.h +++ b/code/graphics/opengl/es_compatibility.h @@ -353,6 +353,7 @@ static inline void glQueryCounter(GLuint id, GLenum target) #else (void)id; #endif + (void)target; } // glGetCompressedTexImage not present on GLES and no equivalent diff --git a/code/graphics/opengl/gropengl.cpp b/code/graphics/opengl/gropengl.cpp index 79252e7eec3..04191047a1c 100644 --- a/code/graphics/opengl/gropengl.cpp +++ b/code/graphics/opengl/gropengl.cpp @@ -6,7 +6,7 @@ #include #endif -#if !defined __APPLE_CC__ && defined SCP_UNIX +#if !defined __APPLE_CC__ && !defined __ANDROID__ && defined SCP_UNIX #include //Required because X defines none and always, which is used later #undef None @@ -1339,7 +1339,7 @@ bool gr_opengl_init(std::unique_ptr&& graphicsOps) Error(LOCATION, "Failed to load OpenGL!"); } -#if !defined __APPLE_CC__ && defined SCP_UNIX +#if !defined __APPLE_CC__ && !defined __ANDROID__ && defined SCP_UNIX if (!gladLoadGLXLoader(GL_context->getLoaderFunction(), nullptr, 0)) { Error(LOCATION, "Failed to load GLX!"); } diff --git a/code/osapi/osapi.cpp b/code/osapi/osapi.cpp index c80016a3385..65ac2b3489a 100644 --- a/code/osapi/osapi.cpp +++ b/code/osapi/osapi.cpp @@ -28,6 +28,13 @@ #include #endif +#ifdef __ANDROID__ +#include +#include +#include +#include "options/Option.h" +#endif + namespace { const char* ORGANIZATION_NAME = "HardLightProductions"; @@ -840,3 +847,126 @@ SCP_string os_get_config_path(const SCP_string& subpath) return ss.str(); } +/* + Special functions for Android +*/ + +#ifdef __ANDROID__ +// Helper to get a static method from a java class and clear the exception +// if the method is not found. This is needed to avoid crashing on the next JNI request. +static jmethodID android_get_static_method(JNIEnv* e, jclass cls, const char* name, const char* sig) +{ + jmethodID m = e->GetStaticMethodID(cls, name, sig); + if (e->ExceptionCheck()) { + e->ExceptionClear(); + m = nullptr; + mprintf(("OSAPI : Method: %s. Not found on GameActivity! Signature: %s. \n", name, sig)); + } + return m; +} + +SCP_string os_get_working_folder_path() +{ + SCP_string wfp{}; + + //Get the JNI Environment pointer and current Activity instance via SDL + JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + jobject activity = (jobject)SDL_AndroidGetActivity(); + + if (env && activity) { + // Locate the Java class (GameActivity on KnossosNET) + jclass ga = env->GetObjectClass(activity); + if(ga) { + // Get the methodID (activity, methodName, signature); + // "()Ljava/lang/String;" means it takes no paramenters and returns a string + jmethodID methodId = android_get_static_method (env, ga, "getWorkingFolder", "()Ljava/lang/String;"); + if (methodId) { + jstring jString = (jstring)env->CallStaticObjectMethod(ga, methodId); + if (jString) { + const char* workingFolder = env->GetStringUTFChars(jString, 0); + wfp = SCP_string(workingFolder); + env->ReleaseStringUTFChars(jString, workingFolder); + env->DeleteLocalRef(jString); + } else { + mprintf(("os_get_working_folder_path: Couldn't get the jString.\n")); + } + } else { + mprintf(("os_get_working_folder_path: Couldn't get the methodID.\n")); + } + env->DeleteLocalRef(ga); + } else { + mprintf(("os_get_working_folder_path: Couldn't get java class.\n")); + } + } else { + mprintf(("os_get_working_folder_path: Couldn't get JNI enviroment or activity.\n")); + } + + if (wfp.empty()) { + mprintf(("Couldn't get working folder path from Java class, reverting to SDL default.\n")); + // Fallback to app space on internal storage + const char* fallbackPath = SDL_AndroidGetExternalStoragePath(); + if (fallbackPath) { + wfp = SCP_string(fallbackPath); + wfp += "/files/"; + } + } + + // Ensure path ends with a dir separator + if (!wfp.empty() && (wfp.back() != DIR_SEPARATOR_CHAR)) { + wfp += DIR_SEPARATOR_CHAR; + } + mprintf(("Using working folder: %s\n", wfp.c_str())); + return wfp; +} + +void os_touch_overlay_toggle(bool status) +{ + //Get the JNI Environment pointer and current Activity instance via SDL + JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + jobject activity = (jobject)SDL_AndroidGetActivity(); + + if (env && activity) { + // Locate the Java class (GameActivity on KnossosNET) + jclass ga = env->GetObjectClass(activity); + if(ga) { + jmethodID methodId = android_get_static_method (env, ga, status ? "enableOverlay" : "disableOverlay", "()V"); + if (methodId) { + env->CallStaticVoidMethod(ga, methodId); + } else { + mprintf(("os_touch_overlay_toggle: Couldn't get the methodID.\n")); + } + env->DeleteLocalRef(ga); + } else { + mprintf(("os_touch_overlay_toggle: Couldn't get java class.\n")); + } + } else { + mprintf(("os_touch_overlay_toggle: Couldn't get JNI enviroment or activity.\n")); + } +} + +static bool touch_ui_change(bool new_val, bool initial) +{ + if (initial) { + return false; + } + os_touch_overlay_toggle(new_val); + return true; +} + +static auto TouchOverlayOption = options::OptionBuilder("Input.TouchOverlay", + std::pair{"Touch Overlay", -1}, + std::pair{"Enable or disable the Touch Overlay", -1}) + .category(std::make_pair("Input", 1827)) + .level(options::ExpertLevel::Beginner) + .change_listener(touch_ui_change) + .default_val(true) + .importance(0) + .finish(); + +void os_touch_overlay_init() +{ + os_touch_overlay_toggle(TouchOverlayOption->getValue()); +} + +#endif + diff --git a/code/osapi/osapi.h b/code/osapi/osapi.h index 0d23b002ed3..41d29e4ada0 100644 --- a/code/osapi/osapi.h +++ b/code/osapi/osapi.h @@ -91,6 +91,20 @@ bool os_is_legacy_mode(); */ SCP_string os_get_config_path(const SCP_string& subpath = ""); +/* + Special functions for Android +*/ +#ifdef __ANDROID__ +// Get working folder absolute path from Android Java Class +SCP_string os_get_working_folder_path(); + +// Calls to display the touch overlay depending on its last state +void os_touch_overlay_init(); + +// Enable or disable the touch UI overlay +void os_touch_overlay_toggle(bool status); +#endif + namespace os { /** diff --git a/code/sound/openal.h b/code/sound/openal.h index cd77a1bb290..ddf32509e68 100644 --- a/code/sound/openal.h +++ b/code/sound/openal.h @@ -3,7 +3,7 @@ #define _AL_H -#if defined(__APPLE__) +#if defined(__APPLE__) || defined(__ANDROID__) #include "al.h" #include "alc.h" #else diff --git a/code/windows_stub/stubs.cpp b/code/windows_stub/stubs.cpp index 1f45959c7e1..df4ae39b619 100644 --- a/code/windows_stub/stubs.cpp +++ b/code/windows_stub/stubs.cpp @@ -49,6 +49,7 @@ int filelength(int fd) SCP_string dump_stacktrace() { +#ifndef __ANDROID__ #ifdef SCP_HAVE_EXECINFO_H // The following is adapted from here: https://panthema.net/2008/0901-stacktrace-demangled/ const int ADDR_SIZE = 64; @@ -139,6 +140,9 @@ SCP_string dump_stacktrace() #else return "No stacktrace available"; #endif +#else +return "No stacktrace available"; +#endif } // retrieve the current working directory diff --git a/freespace2/CMakeLists.txt b/freespace2/CMakeLists.txt index aeb6afd9eae..580a8e0c708 100644 --- a/freespace2/CMakeLists.txt +++ b/freespace2/CMakeLists.txt @@ -19,7 +19,18 @@ IF(MSVC60) link_directories(${STLPORT_INCLUDE_LIB_DIRS}) ENDIF(MSVC60) -ADD_EXECUTABLE(Freespace2 ${EXE_GUI_TYPE} ${FREESPACE_SRC}) +# For android, build a library not a executable +if (ANDROID) + add_library(Freespace2 SHARED ${FREESPACE_SRC}) + target_compile_definitions(Freespace2 PRIVATE PLATFORM_ANDROID) + + # NDK base libs + find_library(log-lib log) + find_library(android-lib android) + target_link_libraries(Freespace2 PRIVATE ${log-lib} ${android-lib}) +else() + add_executable(Freespace2 ${EXE_GUI_TYPE} ${FREESPACE_SRC}) +endif() target_compile_features(Freespace2 PUBLIC cxx_std_17) @@ -27,9 +38,20 @@ include(resources.cmake) SET_TARGET_PROPERTIES(Freespace2 PROPERTIES OUTPUT_NAME "fs2_open_${FSO_BINARY_SUFFIX}") -TARGET_LINK_LIBRARIES(Freespace2 code) -TARGET_LINK_LIBRARIES(Freespace2 platform) -TARGET_LINK_LIBRARIES(Freespace2 compiler) +if (ANDROID) + # one call + target_link_libraries(Freespace2 + PRIVATE + code + platform + compiler + ${ANDROID_LIBS} + ) +else() + TARGET_LINK_LIBRARIES(Freespace2 code) + TARGET_LINK_LIBRARIES(Freespace2 platform) + TARGET_LINK_LIBRARIES(Freespace2 compiler) +endif() IF(WIN32) # Link sdl main only here as it interferes with fred @@ -51,6 +73,8 @@ IF(USE_STLPORT) INCLUDE_DIRECTORIES(BEFORE SYSTEM ${STLPORT_INCLUDE_DIRS}) ENDIF(USE_STLPORT) +# Do not install when building android +if (NOT ANDROID) # Add install script to copy the executable to the FreeSpace path if possible and wanted INSTALL( TARGETS Freespace2 @@ -64,6 +88,7 @@ if (FSO_INSTALL_DEBUG_FILES) OPTIONAL) endif() endif() +endif(NOT ANDROID) if(FSO_BUILD_APPIMAGE) configure_file("${CMAKE_CURRENT_LIST_DIR}/cmake/AppRun.in" "${CMAKE_CURRENT_BINARY_DIR}/AppRun.gen" @ONLY) @@ -89,6 +114,8 @@ enable_clang_tidy(Freespace2) INCLUDE(util) COPY_FILES_TO_TARGET(Freespace2) +# Do not launch when building android +if (NOT ANDROID) include(CreateLaunchers) create_target_launcher(Freespace2 WORKING_DIRECTORY ${FSO_FREESPACE_PATH} @@ -101,6 +128,7 @@ add_custom_target(launch_fso WORKING_DIRECTORY "${FSO_FREESPACE_PATH}" COMMENT "Launching FreeSpace" VERBATIM) +endif() # Ensure that Xcode generates debug symbols on macOS for Debug builds set_target_properties(Freespace2 PROPERTIES XCODE_ATTRIBUTE_GCC_GENERATE_DEBUGGING_SYMBOLS[variant=Debug] "YES") diff --git a/freespace2/SDLGraphicsOperations.cpp b/freespace2/SDLGraphicsOperations.cpp index 6993b285fa2..4d52111a5cd 100644 --- a/freespace2/SDLGraphicsOperations.cpp +++ b/freespace2/SDLGraphicsOperations.cpp @@ -201,6 +201,11 @@ std::unique_ptr SDLGraphicsOperations::createViewport(const os::Vi windowflags |= SDL_WINDOW_INPUT_GRABBED; } + #ifdef __ANDROID__ + SDL_SetHint(SDL_HINT_ORIENTATIONS, "LandscapeLeft LandscapeRight"); + os_touch_overlay_init(); + #endif + SDL_Rect bounds; if (SDL_GetDisplayBounds(props.display, &bounds) != 0) { mprintf(("Failed to get display bounds: %s\n", SDL_GetError())); diff --git a/freespace2/freespace.cpp b/freespace2/freespace.cpp index cf9d354e695..7361ca1498f 100644 --- a/freespace2/freespace.cpp +++ b/freespace2/freespace.cpp @@ -8169,3 +8169,10 @@ int main(int argc, char *argv[]) return result; } + +#ifdef __ANDROID__ +extern "C" int android_main(int argc, char* argv[]) +{ + return main(argc, argv); +} +#endif \ No newline at end of file diff --git a/lib/FFmpeg.cmake b/lib/FFmpeg.cmake index 740ab4c1c1d..cfbbb367d92 100644 --- a/lib/FFmpeg.cmake +++ b/lib/FFmpeg.cmake @@ -48,7 +48,7 @@ IF(PLATFORM_WINDOWS) target_link_libraries(ffmpeg INTERFACE swscale) target_link_libraries(ffmpeg INTERFACE swresample) ELSE(WIN32) - if (PLATFORM_MAC) + if (PLATFORM_MAC OR ANDROID) option(FFMPEG_USE_PRECOMPILED "Use precompiled version of FFmpeg. If disabled the system libraries will be used." ON) else() option(FFMPEG_USE_PRECOMPILED "Use precompiled version of FFmpeg. If disabled the system libraries will be used." OFF) @@ -97,8 +97,8 @@ ELSE(WIN32) # Use our libraries find_library(${name}_LOCATION ${name} PATHS "${FFMPEG_PATH}/lib" - NO_DEFAULT_PATH) - + NO_DEFAULT_PATH + NO_CMAKE_FIND_ROOT_PATH) file(GLOB ${name}_LIBS "${FFMPEG_PATH}/lib/lib${name}*") get_filename_component(FULL_LIB_PATH "${${name}_LOCATION}" REALPATH) diff --git a/lib/OpenAL.cmake b/lib/OpenAL.cmake index 67adfd8c3a1..ac845fc441c 100644 --- a/lib/OpenAL.cmake +++ b/lib/OpenAL.cmake @@ -58,7 +58,7 @@ ELSE(WIN32) message(STATUS "Using pre-built OpenAL library.") unset(OpenAL_LOCATION CACHE) - find_library(OpenAL_LOCATION openal PATHS "${OpenAL_ROOT_DIR}/lib" NO_DEFAULT_PATH) + find_library(OpenAL_LOCATION openal PATHS "${OpenAL_ROOT_DIR}/lib" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) get_filename_component(FULL_LIB_PATH "${OpenAL_LOCATION}" REALPATH) ADD_IMPORTED_LIB(openal "${OpenAL_ROOT_DIR}/include" "${FULL_LIB_PATH}") diff --git a/lib/SDL2.cmake b/lib/SDL2.cmake index d6d99fb06f4..2ca0c5a053f 100644 --- a/lib/SDL2.cmake +++ b/lib/SDL2.cmake @@ -70,12 +70,12 @@ else() message(STATUS "Using pre-built SDL2 library.") unset(SDL2_LOCATION CACHE) - find_library(SDL2_LOCATION NAMES SDL2 SDL2-2.0 PATHS "${SDL2_ROOT_DIR}/lib" NO_DEFAULT_PATH) + find_library(SDL2_LOCATION NAMES SDL2 SDL2-2.0 PATHS "${SDL2_ROOT_DIR}/lib" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) get_filename_component(FULL_LIB_PATH "${SDL2_LOCATION}" REALPATH) ADD_IMPORTED_LIB(sdl2 "${SDL2_ROOT_DIR}/include" "${FULL_LIB_PATH}") - file(GLOB SDL2_LIBS "${SDL2_ROOT_DIR}/lib/libSDL2-2*") + file(GLOB SDL2_LIBS "${SDL2_ROOT_DIR}/lib/libSDL2*") add_target_copy_files("${SDL2_LIBS}") endif() endif() diff --git a/lib/freetype.cmake b/lib/freetype.cmake index cda855d3f5c..a64e5f85c87 100644 --- a/lib/freetype.cmake +++ b/lib/freetype.cmake @@ -1,5 +1,5 @@ -if(PLATFORM_WINDOWS OR PLATFORM_MAC OR CMAKE_CROSSCOMPILING) +if(PLATFORM_WINDOWS OR PLATFORM_MAC OR CMAKE_CROSSCOMPILING OR ANDROID) add_library(freetype INTERFACE) # We use prebuilt binaries for windows and mac @@ -10,7 +10,7 @@ if(PLATFORM_WINDOWS OR PLATFORM_MAC OR CMAKE_CROSSCOMPILING) set(SEARCH_PATH "${FREETYPE_ROOT_DIR}/lib") - if(PLATFORM_WINDOWS OR CMAKE_CROSSCOMPILING) + if((PLATFORM_WINDOWS OR CMAKE_CROSSCOMPILING) AND NOT ANDROID) set(LIBNAME "freetype*.dll") else() set(LIBNAME "libfreetype*") @@ -21,7 +21,8 @@ if(PLATFORM_WINDOWS OR PLATFORM_MAC OR CMAKE_CROSSCOMPILING) find_library(freetype_LOCATION NAMES freetype freetype281 PATHS "${SEARCH_PATH}" - NO_DEFAULT_PATH) + NO_DEFAULT_PATH + NO_CMAKE_FIND_ROOT_PATH) if (${freetype_LOCATION} STREQUAL "freetype_LOCATION-NOTFOUND" AND CMAKE_CROSSCOMPILING) #Just try the default here and see if we can make it work. diff --git a/lib/prebuilt.cmake b/lib/prebuilt.cmake index c97d3ef95be..2059839905b 100644 --- a/lib/prebuilt.cmake +++ b/lib/prebuilt.cmake @@ -31,6 +31,16 @@ function(get_prebuilt_path OUT_VAR) endif() elseif(PLATFORM_MAC) set(FILENAME "bin-mac.tar.gz") + elseif(ANDROID) + if(ANDROID_ABI STREQUAL "arm64-v8a") + set(FILENAME "bin-android-arm64.tar.gz") + elseif(ANDROID_ABI STREQUAL "x86_64") + set(FILENAME "bin-android-x64.tar.gz") + elseif(ANDROID_ABI STREQUAL "armeabi-v7a") + set(FILENAME "bin-android-arm32.tar.gz") + elseif(ANDROID_ABI STREQUAL "x86") + set(FILENAME "bin-android-x86.tar.gz") + endif() else() # Use Linux binaries... if (IS_ARM64) @@ -39,7 +49,11 @@ function(get_prebuilt_path OUT_VAR) set(FILENAME "bin-linux.tar.gz") endif() endif() + if(ANDROID) # TODO: REMOVE THIS ONCE ANDROID PREBUILTS ARE IN THE SCP-PREBUILT REPO + set(DOWNLOAD_URL "https://github.com/Shivansps/Fso-Android-Prebuilts/releases/download/prebuilts-cmake/${FILENAME}") + else() set(DOWNLOAD_URL "https://github.com/scp-fs2open/scp-prebuilt/releases/download/${TAG_NAME}/${FILENAME}") + endif() set(DOWNLOAD_FILE "${CURRENT_ROOT}/${FILENAME}") set(MAX_RETRIES 5) From 3ea6bbaf6da60023c3c2ba54ff72275378f8bf24 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 4 Jul 2026 22:36:00 -0300 Subject: [PATCH 02/15] Update es_compatibility.h --- code/graphics/opengl/es_compatibility.h | 1 - 1 file changed, 1 deletion(-) diff --git a/code/graphics/opengl/es_compatibility.h b/code/graphics/opengl/es_compatibility.h index 9ade09b44fb..6b78398cf0a 100644 --- a/code/graphics/opengl/es_compatibility.h +++ b/code/graphics/opengl/es_compatibility.h @@ -353,7 +353,6 @@ static inline void glQueryCounter(GLuint id, GLenum target) #else (void)id; #endif - (void)target; } // glGetCompressedTexImage not present on GLES and no equivalent From fda9f4f6410179a7b440d78a311fb716c729178f Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sun, 12 Jul 2026 19:30:24 -0300 Subject: [PATCH 03/15] Support reporting flags in android --- code/cmdline/cmdline.cpp | 111 ++++++++++++++++++++++++--------------- code/osapi/osapi.cpp | 31 +++++++++++ code/osapi/osapi.h | 3 ++ 3 files changed, 103 insertions(+), 42 deletions(-) diff --git a/code/cmdline/cmdline.cpp b/code/cmdline/cmdline.cpp index c68a29bdcd9..0a59743dcb4 100644 --- a/code/cmdline/cmdline.cpp +++ b/code/cmdline/cmdline.cpp @@ -74,6 +74,7 @@ const char *cmdline_arg_types[] = enum class flag_output_type { Binary, Json_V1, + Json_V2, }; // variables @@ -1352,51 +1353,58 @@ static void handle_unix_modlist(char **modlist, size_t *len) // external entry point into this modules -static json_t* json_get_v1() { - auto root = json_object(); +static void json_add_version(json_t* root) { + auto version_obj = json_object(); - { - auto version_obj = json_object(); + json_object_set_new(version_obj, "full", json_string(FS_VERSION_FULL)); + json_object_set_new(version_obj, "major", json_integer(FS_VERSION_MAJOR)); + json_object_set_new(version_obj, "minor", json_integer(FS_VERSION_MINOR)); + json_object_set_new(version_obj, "build", json_integer(FS_VERSION_BUILD)); + + json_object_set_new(version_obj, "has_revision", json_boolean(FS_VERSION_HAS_REVIS)); + json_object_set_new(version_obj, "revision", json_integer(FS_VERSION_REVIS)); + json_object_set_new(version_obj, "revision_str", json_string(FS_VERSION_REVIS_STR)); - json_object_set_new(version_obj, "full", json_string(FS_VERSION_FULL)); - json_object_set_new(version_obj, "major", json_integer(FS_VERSION_MAJOR)); - json_object_set_new(version_obj, "minor", json_integer(FS_VERSION_MINOR)); - json_object_set_new(version_obj, "build", json_integer(FS_VERSION_BUILD)); + json_object_set_new(root, "version", version_obj); +} - json_object_set_new(version_obj, "has_revision", json_boolean(FS_VERSION_HAS_REVIS)); - json_object_set_new(version_obj, "revision", json_integer(FS_VERSION_REVIS)); - json_object_set_new(version_obj, "revision_str", json_string(FS_VERSION_REVIS_STR)); +static void json_add_easy_flags(json_t* root) { + auto easy_array = json_array(); - json_object_set_new(root, "version", version_obj); + for (auto& easy_flag : easy_flags) { + json_array_append_new(easy_array, json_string(easy_flag.name)); } - { - auto easy_array = json_array(); - for (auto& easy_flag : easy_flags) { - json_array_append_new(easy_array, json_string(easy_flag.name)); - } + json_object_set_new(root, "easy_flags", easy_array); +} - json_object_set_new(root, "easy_flags", easy_array); +static void json_add_flags(json_t* root) { + auto flags_array = json_array(); + + for (auto& flag : exe_params) { + auto flag_obj = json_object(); + + json_object_set_new(flag_obj, "name", json_string(flag.name)); + json_object_set_new(flag_obj, "description", json_string(flag.desc)); + json_object_set_new(flag_obj, "fso_only", json_boolean(flag.fso_only)); + json_object_set_new(flag_obj, "on_flags", json_integer(flag.on_flags)); + json_object_set_new(flag_obj, "off_flags", json_integer(flag.off_flags)); + json_object_set_new(flag_obj, "type", json_string(flag.type)); + json_object_set_new(flag_obj, "web_url", json_string(flag.web_url)); + + json_array_append_new(flags_array, flag_obj); } - { - auto flags_array = json_array(); - for (auto& flag : exe_params) { - auto flag_obj = json_object(); + json_object_set_new(root, "flags", flags_array); +} - json_object_set_new(flag_obj, "name", json_string(flag.name)); - json_object_set_new(flag_obj, "description", json_string(flag.desc)); - json_object_set_new(flag_obj, "fso_only", json_boolean(flag.fso_only)); - json_object_set_new(flag_obj, "on_flags", json_integer(flag.on_flags)); - json_object_set_new(flag_obj, "off_flags", json_integer(flag.off_flags)); - json_object_set_new(flag_obj, "type", json_string(flag.type)); - json_object_set_new(flag_obj, "web_url", json_string(flag.web_url)); +static json_t* json_get_v1() { + auto root = json_object(); - json_array_append_new(flags_array, flag_obj); - } + json_add_version(root); + json_add_easy_flags(root); + json_add_flags(root); - json_object_set_new(root, "flags", flags_array); - } { auto caps_array = json_array(); @@ -1507,6 +1515,17 @@ static json_t* json_get_v1() { return root; } +// json_v2 is a minimal json string to report supported flags only +static json_t* json_get_v2() { + auto root = json_object(); + + json_add_version(root); + json_add_easy_flags(root); + json_add_flags(root); + + return root; +} + static void write_flags_file() { FILE *fp = fopen("flags.lch","w"); @@ -1564,6 +1583,8 @@ static flag_output_type get_flags_output_type() { return flag_output_type::Binary; } else if (type == "json_v1") { return flag_output_type::Json_V1; + } else if (type == "json_v2") { + return flag_output_type::Json_V2; } else { // This is supposed to make it easy for the launcher to recognize an unsupported type printf("OUTPUT TYPE NOT SUPPORTED!\n"); @@ -1574,17 +1595,23 @@ static flag_output_type get_flags_output_type() { static void write_flags() { auto type = get_flags_output_type(); - switch(type) { - case flag_output_type::Binary: - write_flags_file(); - break; - case flag_output_type::Json_V1: - json_t* root = json_get_v1(); - json_dumpf(root, stdout, JSON_INDENT(4)); - json_decref(root); - break; + if (type == flag_output_type::Binary) { + write_flags_file(); + return; } + + json_t* root = (type == flag_output_type::Json_V1) ? json_get_v1() : json_get_v2(); + +#ifdef __ANDROID__ + char* dumped = json_dumps(root, JSON_INDENT(4)); + os_set_flags_string(dumped ? dumped : ""); + free(dumped); +#else + json_dumpf(root, stdout, JSON_INDENT(4)); +#endif + + json_decref(root); } bool SetCmdlineParams() diff --git a/code/osapi/osapi.cpp b/code/osapi/osapi.cpp index 65ac2b3489a..a1ae90d2fff 100644 --- a/code/osapi/osapi.cpp +++ b/code/osapi/osapi.cpp @@ -865,6 +865,37 @@ static jmethodID android_get_static_method(JNIEnv* e, jclass cls, const char* na return m; } +void os_set_flags_string(const char* json) +{ + //Get the JNI Environment pointer and current Activity instance via SDL + JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + jobject activity = (jobject)SDL_AndroidGetActivity(); + + if (env && activity) { + // Locate the Java class (FlagsActivity / GameActivity on KnossosNET) + jclass ga = env->GetObjectClass(activity); + if (ga) { + // void setFlagsJson(String) -> "(Ljava/lang/String;)V" + jmethodID methodId = android_get_static_method(env, ga, "setFlagsJson", "(Ljava/lang/String;)V"); + if (methodId) { + jstring jstr = env->NewStringUTF(json ? json : ""); + env->CallStaticVoidMethod(ga, methodId, jstr); + env->DeleteLocalRef(jstr); + } + else { + mprintf(("os_set_flags_string: Couldn't get the methodID.\n")); + } + env->DeleteLocalRef(ga); + } + else { + mprintf(("os_set_flags_string: Couldn't get java class.\n")); + } + } + else { + mprintf(("os_set_flags_string: Couldn't get JNI enviroment or activity.\n")); + } +} + SCP_string os_get_working_folder_path() { SCP_string wfp{}; diff --git a/code/osapi/osapi.h b/code/osapi/osapi.h index 41d29e4ada0..6cb6b579008 100644 --- a/code/osapi/osapi.h +++ b/code/osapi/osapi.h @@ -103,6 +103,9 @@ void os_touch_overlay_init(); // Enable or disable the touch UI overlay void os_touch_overlay_toggle(bool status); + +// Send the JSON flags string to the Android Java layer +void os_set_flags_string(const char* json); #endif namespace os From 40106bd99e4b25d31f1b467be79d29ff83819e38 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Wed, 15 Jul 2026 22:30:53 -0300 Subject: [PATCH 04/15] include pref_path in json v2 --- code/cmdline/cmdline.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/code/cmdline/cmdline.cpp b/code/cmdline/cmdline.cpp index 0a59743dcb4..22b81dc53eb 100644 --- a/code/cmdline/cmdline.cpp +++ b/code/cmdline/cmdline.cpp @@ -1522,6 +1522,7 @@ static json_t* json_get_v2() { json_add_version(root); json_add_easy_flags(root); json_add_flags(root); + json_object_set_new(root, "pref_path", json_string(os_get_config_path().c_str())); return root; } From 19c99df6a335119f7b95047238bff638248cd9ec Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Wed, 22 Jul 2026 20:48:40 -0300 Subject: [PATCH 05/15] add vulkan headers --- .../vk_video/vulkan_video_codec_av1std.h | 394 + .../vulkan_video_codec_av1std_decode.h | 109 + .../vulkan_video_codec_av1std_encode.h | 143 + .../vk_video/vulkan_video_codec_h264std.h | 312 + .../vulkan_video_codec_h264std_decode.h | 77 + .../vulkan_video_codec_h264std_encode.h | 147 + .../vk_video/vulkan_video_codec_h265std.h | 446 + .../vulkan_video_codec_h265std_decode.h | 67 + .../vulkan_video_codec_h265std_encode.h | 157 + .../vk_video/vulkan_video_codec_vp9std.h | 151 + .../vulkan_video_codec_vp9std_decode.h | 68 + .../vk_video/vulkan_video_codecs_common.h | 36 + lib/vulkan-headers/include/vulkan/vk_icd.h | 245 + lib/vulkan-headers/include/vulkan/vk_layer.h | 192 + .../include/vulkan/vk_platform.h | 84 + lib/vulkan-headers/include/vulkan/vulkan.cppm | 10847 + lib/vulkan-headers/include/vulkan/vulkan.h | 103 + lib/vulkan-headers/include/vulkan/vulkan.hpp | 25659 ++ .../include/vulkan/vulkan_android.h | 159 + .../include/vulkan/vulkan_beta.h | 375 + .../include/vulkan/vulkan_core.h | 25278 ++ .../include/vulkan/vulkan_directfb.h | 59 + .../include/vulkan/vulkan_enums.hpp | 9806 + .../vulkan/vulkan_extension_inspection.hpp | 4155 + .../include/vulkan/vulkan_format_traits.hpp | 10576 + .../include/vulkan/vulkan_fuchsia.h | 282 + .../include/vulkan/vulkan_funcs.hpp | 32761 +++ .../include/vulkan/vulkan_ggp.h | 62 + .../include/vulkan/vulkan_handles.hpp | 22749 ++ .../include/vulkan/vulkan_hash.hpp | 21424 ++ .../include/vulkan/vulkan_hpp_macros.hpp | 337 + .../include/vulkan/vulkan_ios.h | 50 + .../include/vulkan/vulkan_macos.h | 50 + .../include/vulkan/vulkan_metal.h | 244 + .../include/vulkan/vulkan_ohos.h | 120 + .../include/vulkan/vulkan_raii.hpp | 28565 ++ .../include/vulkan/vulkan_screen.h | 114 + .../include/vulkan/vulkan_shared.hpp | 1197 + .../vulkan/vulkan_static_assertions.hpp | 9861 + .../include/vulkan/vulkan_structs.hpp | 206351 +++++++++++++++ .../include/vulkan/vulkan_to_string.hpp | 11091 + lib/vulkan-headers/include/vulkan/vulkan_vi.h | 50 + .../include/vulkan/vulkan_video.cppm | 324 + .../include/vulkan/vulkan_video.hpp | 5529 + .../include/vulkan/vulkan_wayland.h | 59 + .../include/vulkan/vulkan_win32.h | 372 + .../include/vulkan/vulkan_xcb.h | 60 + .../include/vulkan/vulkan_xlib.h | 60 + .../include/vulkan/vulkan_xlib_xrandr.h | 50 + 49 files changed, 431407 insertions(+) create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std.h create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_decode.h create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_encode.h create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std.h create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_decode.h create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_encode.h create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std.h create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_decode.h create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_encode.h create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std.h create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std_decode.h create mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codecs_common.h create mode 100644 lib/vulkan-headers/include/vulkan/vk_icd.h create mode 100644 lib/vulkan-headers/include/vulkan/vk_layer.h create mode 100644 lib/vulkan-headers/include/vulkan/vk_platform.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan.cppm create mode 100644 lib/vulkan-headers/include/vulkan/vulkan.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_android.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_beta.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_core.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_directfb.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_enums.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_extension_inspection.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_format_traits.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_fuchsia.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_funcs.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_ggp.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_handles.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_hash.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_hpp_macros.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_ios.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_macos.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_metal.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_ohos.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_raii.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_screen.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_shared.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_static_assertions.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_structs.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_to_string.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_vi.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_video.cppm create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_video.hpp create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_wayland.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_win32.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_xcb.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_xlib.h create mode 100644 lib/vulkan-headers/include/vulkan/vulkan_xlib_xrandr.h diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std.h new file mode 100644 index 00000000000..75cebd74cbf --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std.h @@ -0,0 +1,394 @@ +#ifndef VULKAN_VIDEO_CODEC_AV1STD_H_ +#define VULKAN_VIDEO_CODEC_AV1STD_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_av1std 1 +#include "vulkan_video_codecs_common.h" +#define STD_VIDEO_AV1_NUM_REF_FRAMES 8U +#define STD_VIDEO_AV1_REFS_PER_FRAME 7U +#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8U +#define STD_VIDEO_AV1_MAX_TILE_COLS 64U +#define STD_VIDEO_AV1_MAX_TILE_ROWS 64U +#define STD_VIDEO_AV1_MAX_SEGMENTS 8U +#define STD_VIDEO_AV1_SEG_LVL_MAX 8U +#define STD_VIDEO_AV1_PRIMARY_REF_NONE 7U +#define STD_VIDEO_AV1_SELECT_INTEGER_MV 2U +#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2U +#define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2U +#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4U +#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2U +#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8U +#define STD_VIDEO_AV1_MAX_NUM_PLANES 3U +#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6U +#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14U +#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10U +#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10U +#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24U +#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25U + +typedef enum StdVideoAV1Profile { + STD_VIDEO_AV1_PROFILE_MAIN = 0, + STD_VIDEO_AV1_PROFILE_HIGH = 1, + STD_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, + STD_VIDEO_AV1_PROFILE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_PROFILE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1Profile; + +typedef enum StdVideoAV1Level { + STD_VIDEO_AV1_LEVEL_2_0 = 0, + STD_VIDEO_AV1_LEVEL_2_1 = 1, + STD_VIDEO_AV1_LEVEL_2_2 = 2, + STD_VIDEO_AV1_LEVEL_2_3 = 3, + STD_VIDEO_AV1_LEVEL_3_0 = 4, + STD_VIDEO_AV1_LEVEL_3_1 = 5, + STD_VIDEO_AV1_LEVEL_3_2 = 6, + STD_VIDEO_AV1_LEVEL_3_3 = 7, + STD_VIDEO_AV1_LEVEL_4_0 = 8, + STD_VIDEO_AV1_LEVEL_4_1 = 9, + STD_VIDEO_AV1_LEVEL_4_2 = 10, + STD_VIDEO_AV1_LEVEL_4_3 = 11, + STD_VIDEO_AV1_LEVEL_5_0 = 12, + STD_VIDEO_AV1_LEVEL_5_1 = 13, + STD_VIDEO_AV1_LEVEL_5_2 = 14, + STD_VIDEO_AV1_LEVEL_5_3 = 15, + STD_VIDEO_AV1_LEVEL_6_0 = 16, + STD_VIDEO_AV1_LEVEL_6_1 = 17, + STD_VIDEO_AV1_LEVEL_6_2 = 18, + STD_VIDEO_AV1_LEVEL_6_3 = 19, + STD_VIDEO_AV1_LEVEL_7_0 = 20, + STD_VIDEO_AV1_LEVEL_7_1 = 21, + STD_VIDEO_AV1_LEVEL_7_2 = 22, + STD_VIDEO_AV1_LEVEL_7_3 = 23, + STD_VIDEO_AV1_LEVEL_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_LEVEL_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1Level; + +typedef enum StdVideoAV1FrameType { + STD_VIDEO_AV1_FRAME_TYPE_KEY = 0, + STD_VIDEO_AV1_FRAME_TYPE_INTER = 1, + STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY = 2, + STD_VIDEO_AV1_FRAME_TYPE_SWITCH = 3, + STD_VIDEO_AV1_FRAME_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1FrameType; + +typedef enum StdVideoAV1ReferenceName { + STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME = 0, + STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME = 1, + STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME = 2, + STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME = 3, + STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME = 4, + STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME = 5, + STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME = 6, + STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME = 7, + STD_VIDEO_AV1_REFERENCE_NAME_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ReferenceName; + +typedef enum StdVideoAV1InterpolationFilter { + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, + STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, + STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR = 3, + STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, + STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1InterpolationFilter; + +typedef enum StdVideoAV1TxMode { + STD_VIDEO_AV1_TX_MODE_ONLY_4X4 = 0, + STD_VIDEO_AV1_TX_MODE_LARGEST = 1, + STD_VIDEO_AV1_TX_MODE_SELECT = 2, + STD_VIDEO_AV1_TX_MODE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_TX_MODE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1TxMode; + +typedef enum StdVideoAV1FrameRestorationType { + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE = 0, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER = 1, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ = 2, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE = 3, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1FrameRestorationType; + +typedef enum StdVideoAV1ColorPrimaries { + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1, + STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED = 2, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6, + STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240 = 7, + STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM = 8, + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020 = 9, + STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ = 10, + STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11, + STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12, + STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22, + STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF, + // STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED is a legacy alias + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED, + STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ColorPrimaries; + +typedef enum StdVideoAV1TransferCharacteristics { + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0 = 0, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709 = 1, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3 = 3, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M = 4, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G = 5, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601 = 6, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240 = 7, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR = 8, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100 = 9, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 = 10, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966 = 11, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361 = 12, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB = 13, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT = 14, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT = 15, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084 = 16, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428 = 17, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG = 18, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1TransferCharacteristics; + +typedef enum StdVideoAV1MatrixCoefficients { + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY = 0, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709 = 1, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED = 2, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3 = 3, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC = 4, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G = 5, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601 = 6, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240 = 7, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO = 8, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL = 9, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL = 10, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085 = 11, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL = 12, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL = 13, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP = 14, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_MATRIX_COEFFICIENTS_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1MatrixCoefficients; + +typedef enum StdVideoAV1ChromaSamplePosition { + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN = 0, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL = 1, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED = 2, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED = 3, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID = 0x7FFFFFFF, + STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_MAX_ENUM = 0x7FFFFFFF +} StdVideoAV1ChromaSamplePosition; +typedef struct StdVideoAV1ColorConfigFlags { + uint32_t mono_chrome : 1; + uint32_t color_range : 1; + uint32_t separate_uv_delta_q : 1; + uint32_t color_description_present_flag : 1; + uint32_t reserved : 28; +} StdVideoAV1ColorConfigFlags; + +typedef struct StdVideoAV1ColorConfig { + StdVideoAV1ColorConfigFlags flags; + uint8_t BitDepth; + uint8_t subsampling_x; + uint8_t subsampling_y; + uint8_t reserved1; + StdVideoAV1ColorPrimaries color_primaries; + StdVideoAV1TransferCharacteristics transfer_characteristics; + StdVideoAV1MatrixCoefficients matrix_coefficients; + StdVideoAV1ChromaSamplePosition chroma_sample_position; +} StdVideoAV1ColorConfig; + +typedef struct StdVideoAV1TimingInfoFlags { + uint32_t equal_picture_interval : 1; + uint32_t reserved : 31; +} StdVideoAV1TimingInfoFlags; + +typedef struct StdVideoAV1TimingInfo { + StdVideoAV1TimingInfoFlags flags; + uint32_t num_units_in_display_tick; + uint32_t time_scale; + uint32_t num_ticks_per_picture_minus_1; +} StdVideoAV1TimingInfo; + +typedef struct StdVideoAV1LoopFilterFlags { + uint32_t loop_filter_delta_enabled : 1; + uint32_t loop_filter_delta_update : 1; + uint32_t reserved : 30; +} StdVideoAV1LoopFilterFlags; + +typedef struct StdVideoAV1LoopFilter { + StdVideoAV1LoopFilterFlags flags; + uint8_t loop_filter_level[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS]; + uint8_t loop_filter_sharpness; + uint8_t update_ref_delta; + int8_t loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME]; + uint8_t update_mode_delta; + int8_t loop_filter_mode_deltas[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS]; +} StdVideoAV1LoopFilter; + +typedef struct StdVideoAV1QuantizationFlags { + uint32_t using_qmatrix : 1; + uint32_t diff_uv_delta : 1; + uint32_t reserved : 30; +} StdVideoAV1QuantizationFlags; + +typedef struct StdVideoAV1Quantization { + StdVideoAV1QuantizationFlags flags; + uint8_t base_q_idx; + int8_t DeltaQYDc; + int8_t DeltaQUDc; + int8_t DeltaQUAc; + int8_t DeltaQVDc; + int8_t DeltaQVAc; + uint8_t qm_y; + uint8_t qm_u; + uint8_t qm_v; +} StdVideoAV1Quantization; + +typedef struct StdVideoAV1Segmentation { + uint8_t FeatureEnabled[STD_VIDEO_AV1_MAX_SEGMENTS]; + int16_t FeatureData[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX]; +} StdVideoAV1Segmentation; + +typedef struct StdVideoAV1TileInfoFlags { + uint32_t uniform_tile_spacing_flag : 1; + uint32_t reserved : 31; +} StdVideoAV1TileInfoFlags; + +typedef struct StdVideoAV1TileInfo { + StdVideoAV1TileInfoFlags flags; + uint8_t TileCols; + uint8_t TileRows; + uint16_t context_update_tile_id; + uint8_t tile_size_bytes_minus_1; + uint8_t reserved1[7]; + const uint16_t* pMiColStarts; + const uint16_t* pMiRowStarts; + const uint16_t* pWidthInSbsMinus1; + const uint16_t* pHeightInSbsMinus1; +} StdVideoAV1TileInfo; + +typedef struct StdVideoAV1CDEF { + uint8_t cdef_damping_minus_3; + uint8_t cdef_bits; + uint8_t cdef_y_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_y_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_uv_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; + uint8_t cdef_uv_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; +} StdVideoAV1CDEF; + +typedef struct StdVideoAV1LoopRestoration { + StdVideoAV1FrameRestorationType FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES]; + uint16_t LoopRestorationSize[STD_VIDEO_AV1_MAX_NUM_PLANES]; +} StdVideoAV1LoopRestoration; + +typedef struct StdVideoAV1GlobalMotion { + uint8_t GmType[STD_VIDEO_AV1_NUM_REF_FRAMES]; + int32_t gm_params[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS]; +} StdVideoAV1GlobalMotion; + +typedef struct StdVideoAV1FilmGrainFlags { + uint32_t chroma_scaling_from_luma : 1; + uint32_t overlap_flag : 1; + uint32_t clip_to_restricted_range : 1; + uint32_t update_grain : 1; + uint32_t reserved : 28; +} StdVideoAV1FilmGrainFlags; + +typedef struct StdVideoAV1FilmGrain { + StdVideoAV1FilmGrainFlags flags; + uint8_t grain_scaling_minus_8; + uint8_t ar_coeff_lag; + uint8_t ar_coeff_shift_minus_6; + uint8_t grain_scale_shift; + uint16_t grain_seed; + uint8_t film_grain_params_ref_idx; + uint8_t num_y_points; + uint8_t point_y_value[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; + uint8_t point_y_scaling[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; + uint8_t num_cb_points; + uint8_t point_cb_value[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; + uint8_t point_cb_scaling[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; + uint8_t num_cr_points; + uint8_t point_cr_value[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; + uint8_t point_cr_scaling[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; + int8_t ar_coeffs_y_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_LUMA]; + int8_t ar_coeffs_cb_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; + int8_t ar_coeffs_cr_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; + uint8_t cb_mult; + uint8_t cb_luma_mult; + uint16_t cb_offset; + uint8_t cr_mult; + uint8_t cr_luma_mult; + uint16_t cr_offset; +} StdVideoAV1FilmGrain; + +typedef struct StdVideoAV1SequenceHeaderFlags { + uint32_t still_picture : 1; + uint32_t reduced_still_picture_header : 1; + uint32_t use_128x128_superblock : 1; + uint32_t enable_filter_intra : 1; + uint32_t enable_intra_edge_filter : 1; + uint32_t enable_interintra_compound : 1; + uint32_t enable_masked_compound : 1; + uint32_t enable_warped_motion : 1; + uint32_t enable_dual_filter : 1; + uint32_t enable_order_hint : 1; + uint32_t enable_jnt_comp : 1; + uint32_t enable_ref_frame_mvs : 1; + uint32_t frame_id_numbers_present_flag : 1; + uint32_t enable_superres : 1; + uint32_t enable_cdef : 1; + uint32_t enable_restoration : 1; + uint32_t film_grain_params_present : 1; + uint32_t timing_info_present_flag : 1; + uint32_t initial_display_delay_present_flag : 1; + uint32_t reserved : 13; +} StdVideoAV1SequenceHeaderFlags; + +typedef struct StdVideoAV1SequenceHeader { + StdVideoAV1SequenceHeaderFlags flags; + StdVideoAV1Profile seq_profile; + uint8_t frame_width_bits_minus_1; + uint8_t frame_height_bits_minus_1; + uint16_t max_frame_width_minus_1; + uint16_t max_frame_height_minus_1; + uint8_t delta_frame_id_length_minus_2; + uint8_t additional_frame_id_length_minus_1; + uint8_t order_hint_bits_minus_1; + uint8_t seq_force_integer_mv; + uint8_t seq_force_screen_content_tools; + uint8_t reserved1[5]; + const StdVideoAV1ColorConfig* pColorConfig; + const StdVideoAV1TimingInfo* pTimingInfo; +} StdVideoAV1SequenceHeader; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_decode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_decode.h new file mode 100644 index 00000000000..60bf2c03987 --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_decode.h @@ -0,0 +1,109 @@ +#ifndef VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_av1std_decode is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_av1std_decode 1 +#include "vulkan_video_codec_av1std.h" + +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_decode" +typedef struct StdVideoDecodeAV1PictureInfoFlags { + uint32_t error_resilient_mode : 1; + uint32_t disable_cdf_update : 1; + uint32_t use_superres : 1; + uint32_t render_and_frame_size_different : 1; + uint32_t allow_screen_content_tools : 1; + uint32_t is_filter_switchable : 1; + uint32_t force_integer_mv : 1; + uint32_t frame_size_override_flag : 1; + uint32_t buffer_removal_time_present_flag : 1; + uint32_t allow_intrabc : 1; + uint32_t frame_refs_short_signaling : 1; + uint32_t allow_high_precision_mv : 1; + uint32_t is_motion_mode_switchable : 1; + uint32_t use_ref_frame_mvs : 1; + uint32_t disable_frame_end_update_cdf : 1; + uint32_t allow_warped_motion : 1; + uint32_t reduced_tx_set : 1; + uint32_t reference_select : 1; + uint32_t skip_mode_present : 1; + uint32_t delta_q_present : 1; + uint32_t delta_lf_present : 1; + uint32_t delta_lf_multi : 1; + uint32_t segmentation_enabled : 1; + uint32_t segmentation_update_map : 1; + uint32_t segmentation_temporal_update : 1; + uint32_t segmentation_update_data : 1; + uint32_t UsesLr : 1; + uint32_t usesChromaLr : 1; + uint32_t apply_grain : 1; + uint32_t reserved : 3; +} StdVideoDecodeAV1PictureInfoFlags; + +typedef struct StdVideoDecodeAV1PictureInfo { + StdVideoDecodeAV1PictureInfoFlags flags; + StdVideoAV1FrameType frame_type; + uint32_t current_frame_id; + uint8_t OrderHint; + uint8_t primary_ref_frame; + uint8_t refresh_frame_flags; + uint8_t reserved1; + StdVideoAV1InterpolationFilter interpolation_filter; + StdVideoAV1TxMode TxMode; + uint8_t delta_q_res; + uint8_t delta_lf_res; + uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES]; + uint8_t coded_denom; + uint8_t reserved2[3]; + uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; + uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES]; + const StdVideoAV1TileInfo* pTileInfo; + const StdVideoAV1Quantization* pQuantization; + const StdVideoAV1Segmentation* pSegmentation; + const StdVideoAV1LoopFilter* pLoopFilter; + const StdVideoAV1CDEF* pCDEF; + const StdVideoAV1LoopRestoration* pLoopRestoration; + const StdVideoAV1GlobalMotion* pGlobalMotion; + const StdVideoAV1FilmGrain* pFilmGrain; +} StdVideoDecodeAV1PictureInfo; + +typedef struct StdVideoDecodeAV1ReferenceInfoFlags { + uint32_t disable_frame_end_update_cdf : 1; + uint32_t segmentation_enabled : 1; + uint32_t reserved : 30; +} StdVideoDecodeAV1ReferenceInfoFlags; + +typedef struct StdVideoDecodeAV1ReferenceInfo { + StdVideoDecodeAV1ReferenceInfoFlags flags; + uint8_t frame_type; + uint8_t RefFrameSignBias; + uint8_t OrderHint; + uint8_t SavedOrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; +} StdVideoDecodeAV1ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_encode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_encode.h new file mode 100644 index 00000000000..3602fe12502 --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_encode.h @@ -0,0 +1,143 @@ +#ifndef VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ +#define VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_av1std_encode is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_av1std_encode 1 +#include "vulkan_video_codec_av1std.h" + +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_encode" +typedef struct StdVideoEncodeAV1DecoderModelInfo { + uint8_t buffer_delay_length_minus_1; + uint8_t buffer_removal_time_length_minus_1; + uint8_t frame_presentation_time_length_minus_1; + uint8_t reserved1; + uint32_t num_units_in_decoding_tick; +} StdVideoEncodeAV1DecoderModelInfo; + +typedef struct StdVideoEncodeAV1ExtensionHeader { + uint8_t temporal_id; + uint8_t spatial_id; +} StdVideoEncodeAV1ExtensionHeader; + +typedef struct StdVideoEncodeAV1OperatingPointInfoFlags { + uint32_t decoder_model_present_for_this_op : 1; + uint32_t low_delay_mode_flag : 1; + uint32_t initial_display_delay_present_for_this_op : 1; + uint32_t reserved : 29; +} StdVideoEncodeAV1OperatingPointInfoFlags; + +typedef struct StdVideoEncodeAV1OperatingPointInfo { + StdVideoEncodeAV1OperatingPointInfoFlags flags; + uint16_t operating_point_idc; + uint8_t seq_level_idx; + uint8_t seq_tier; + uint32_t decoder_buffer_delay; + uint32_t encoder_buffer_delay; + uint8_t initial_display_delay_minus_1; +} StdVideoEncodeAV1OperatingPointInfo; + +typedef struct StdVideoEncodeAV1PictureInfoFlags { + uint32_t error_resilient_mode : 1; + uint32_t disable_cdf_update : 1; + uint32_t use_superres : 1; + uint32_t render_and_frame_size_different : 1; + uint32_t allow_screen_content_tools : 1; + uint32_t is_filter_switchable : 1; + uint32_t force_integer_mv : 1; + uint32_t frame_size_override_flag : 1; + uint32_t buffer_removal_time_present_flag : 1; + uint32_t allow_intrabc : 1; + uint32_t frame_refs_short_signaling : 1; + uint32_t allow_high_precision_mv : 1; + uint32_t is_motion_mode_switchable : 1; + uint32_t use_ref_frame_mvs : 1; + uint32_t disable_frame_end_update_cdf : 1; + uint32_t allow_warped_motion : 1; + uint32_t reduced_tx_set : 1; + uint32_t skip_mode_present : 1; + uint32_t delta_q_present : 1; + uint32_t delta_lf_present : 1; + uint32_t delta_lf_multi : 1; + uint32_t segmentation_enabled : 1; + uint32_t segmentation_update_map : 1; + uint32_t segmentation_temporal_update : 1; + uint32_t segmentation_update_data : 1; + uint32_t UsesLr : 1; + uint32_t usesChromaLr : 1; + uint32_t show_frame : 1; + uint32_t showable_frame : 1; + uint32_t reserved : 3; +} StdVideoEncodeAV1PictureInfoFlags; + +typedef struct StdVideoEncodeAV1PictureInfo { + StdVideoEncodeAV1PictureInfoFlags flags; + StdVideoAV1FrameType frame_type; + uint32_t frame_presentation_time; + uint32_t current_frame_id; + uint8_t order_hint; + uint8_t primary_ref_frame; + uint8_t refresh_frame_flags; + uint8_t coded_denom; + uint16_t render_width_minus_1; + uint16_t render_height_minus_1; + StdVideoAV1InterpolationFilter interpolation_filter; + StdVideoAV1TxMode TxMode; + uint8_t delta_q_res; + uint8_t delta_lf_res; + uint8_t ref_order_hint[STD_VIDEO_AV1_NUM_REF_FRAMES]; + int8_t ref_frame_idx[STD_VIDEO_AV1_REFS_PER_FRAME]; + uint8_t reserved1[3]; + uint32_t delta_frame_id_minus_1[STD_VIDEO_AV1_REFS_PER_FRAME]; + const StdVideoAV1TileInfo* pTileInfo; + const StdVideoAV1Quantization* pQuantization; + const StdVideoAV1Segmentation* pSegmentation; + const StdVideoAV1LoopFilter* pLoopFilter; + const StdVideoAV1CDEF* pCDEF; + const StdVideoAV1LoopRestoration* pLoopRestoration; + const StdVideoAV1GlobalMotion* pGlobalMotion; + const StdVideoEncodeAV1ExtensionHeader* pExtensionHeader; + const uint32_t* pBufferRemovalTimes; +} StdVideoEncodeAV1PictureInfo; + +typedef struct StdVideoEncodeAV1ReferenceInfoFlags { + uint32_t disable_frame_end_update_cdf : 1; + uint32_t segmentation_enabled : 1; + uint32_t reserved : 30; +} StdVideoEncodeAV1ReferenceInfoFlags; + +typedef struct StdVideoEncodeAV1ReferenceInfo { + StdVideoEncodeAV1ReferenceInfoFlags flags; + uint32_t RefFrameId; + StdVideoAV1FrameType frame_type; + uint8_t OrderHint; + uint8_t reserved1[3]; + const StdVideoEncodeAV1ExtensionHeader* pExtensionHeader; +} StdVideoEncodeAV1ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std.h new file mode 100644 index 00000000000..48621b6954d --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std.h @@ -0,0 +1,312 @@ +#ifndef VULKAN_VIDEO_CODEC_H264STD_H_ +#define VULKAN_VIDEO_CODEC_H264STD_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_h264std is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_h264std 1 +#include "vulkan_video_codecs_common.h" +#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32U +#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6U +#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16U +#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6U +#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64U +#define STD_VIDEO_H264_MAX_NUM_LIST_REF 32U +#define STD_VIDEO_H264_MAX_CHROMA_PLANES 2U +#define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFFU + +typedef enum StdVideoH264ChromaFormatIdc { + STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_420 = 1, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_422 = 2, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_444 = 3, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ChromaFormatIdc; + +typedef enum StdVideoH264ProfileIdc { + STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66, + STD_VIDEO_H264_PROFILE_IDC_MAIN = 77, + STD_VIDEO_H264_PROFILE_IDC_HIGH = 100, + STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244, + STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ProfileIdc; + +typedef enum StdVideoH264LevelIdc { + STD_VIDEO_H264_LEVEL_IDC_1_0 = 0, + STD_VIDEO_H264_LEVEL_IDC_1_1 = 1, + STD_VIDEO_H264_LEVEL_IDC_1_2 = 2, + STD_VIDEO_H264_LEVEL_IDC_1_3 = 3, + STD_VIDEO_H264_LEVEL_IDC_2_0 = 4, + STD_VIDEO_H264_LEVEL_IDC_2_1 = 5, + STD_VIDEO_H264_LEVEL_IDC_2_2 = 6, + STD_VIDEO_H264_LEVEL_IDC_3_0 = 7, + STD_VIDEO_H264_LEVEL_IDC_3_1 = 8, + STD_VIDEO_H264_LEVEL_IDC_3_2 = 9, + STD_VIDEO_H264_LEVEL_IDC_4_0 = 10, + STD_VIDEO_H264_LEVEL_IDC_4_1 = 11, + STD_VIDEO_H264_LEVEL_IDC_4_2 = 12, + STD_VIDEO_H264_LEVEL_IDC_5_0 = 13, + STD_VIDEO_H264_LEVEL_IDC_5_1 = 14, + STD_VIDEO_H264_LEVEL_IDC_5_2 = 15, + STD_VIDEO_H264_LEVEL_IDC_6_0 = 16, + STD_VIDEO_H264_LEVEL_IDC_6_1 = 17, + STD_VIDEO_H264_LEVEL_IDC_6_2 = 18, + STD_VIDEO_H264_LEVEL_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264LevelIdc; + +typedef enum StdVideoH264PocType { + STD_VIDEO_H264_POC_TYPE_0 = 0, + STD_VIDEO_H264_POC_TYPE_1 = 1, + STD_VIDEO_H264_POC_TYPE_2 = 2, + STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_POC_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264PocType; + +typedef enum StdVideoH264AspectRatioIdc { + STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED = 0, + STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE = 1, + STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11 = 2, + STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11 = 3, + STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11 = 4, + STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33 = 5, + STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11 = 6, + STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11 = 7, + STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11 = 8, + STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33 = 9, + STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11 = 10, + STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11 = 11, + STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33 = 12, + STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99 = 13, + STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3 = 14, + STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2 = 15, + STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1 = 16, + STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, + STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264AspectRatioIdc; + +typedef enum StdVideoH264WeightedBipredIdc { + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT = 0, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT = 1, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT = 2, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264WeightedBipredIdc; + +typedef enum StdVideoH264ModificationOfPicNumsIdc { + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT = 0, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD = 1, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM = 2, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END = 3, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ModificationOfPicNumsIdc; + +typedef enum StdVideoH264MemMgmtControlOp { + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END = 0, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM = 1, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM = 2, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM = 3, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX = 4, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL = 5, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM = 6, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264MemMgmtControlOp; + +typedef enum StdVideoH264CabacInitIdc { + STD_VIDEO_H264_CABAC_INIT_IDC_0 = 0, + STD_VIDEO_H264_CABAC_INIT_IDC_1 = 1, + STD_VIDEO_H264_CABAC_INIT_IDC_2 = 2, + STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_CABAC_INIT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264CabacInitIdc; + +typedef enum StdVideoH264DisableDeblockingFilterIdc { + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED = 0, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED = 1, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL = 2, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264DisableDeblockingFilterIdc; + +typedef enum StdVideoH264SliceType { + STD_VIDEO_H264_SLICE_TYPE_P = 0, + STD_VIDEO_H264_SLICE_TYPE_B = 1, + STD_VIDEO_H264_SLICE_TYPE_I = 2, + STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264SliceType; + +typedef enum StdVideoH264PictureType { + STD_VIDEO_H264_PICTURE_TYPE_P = 0, + STD_VIDEO_H264_PICTURE_TYPE_B = 1, + STD_VIDEO_H264_PICTURE_TYPE_I = 2, + STD_VIDEO_H264_PICTURE_TYPE_IDR = 5, + STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264PictureType; + +typedef enum StdVideoH264NonVclNaluType { + STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS = 0, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS = 1, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD = 2, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX = 3, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE = 4, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM = 5, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED = 6, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264NonVclNaluType; +typedef struct StdVideoH264SpsVuiFlags { + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t color_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t timing_info_present_flag : 1; + uint32_t fixed_frame_rate_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; +} StdVideoH264SpsVuiFlags; + +typedef struct StdVideoH264HrdParameters { + uint8_t cpb_cnt_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint8_t reserved1; + uint32_t bit_rate_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint8_t cbr_flag[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; + uint32_t initial_cpb_removal_delay_length_minus1; + uint32_t cpb_removal_delay_length_minus1; + uint32_t dpb_output_delay_length_minus1; + uint32_t time_offset_length; +} StdVideoH264HrdParameters; + +typedef struct StdVideoH264SequenceParameterSetVui { + StdVideoH264SpsVuiFlags flags; + StdVideoH264AspectRatioIdc aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coefficients; + uint32_t num_units_in_tick; + uint32_t time_scale; + uint8_t max_num_reorder_frames; + uint8_t max_dec_frame_buffering; + uint8_t chroma_sample_loc_type_top_field; + uint8_t chroma_sample_loc_type_bottom_field; + uint32_t reserved1; + const StdVideoH264HrdParameters* pHrdParameters; +} StdVideoH264SequenceParameterSetVui; + +typedef struct StdVideoH264SpsFlags { + uint32_t constraint_set0_flag : 1; + uint32_t constraint_set1_flag : 1; + uint32_t constraint_set2_flag : 1; + uint32_t constraint_set3_flag : 1; + uint32_t constraint_set4_flag : 1; + uint32_t constraint_set5_flag : 1; + uint32_t direct_8x8_inference_flag : 1; + uint32_t mb_adaptive_frame_field_flag : 1; + uint32_t frame_mbs_only_flag : 1; + uint32_t delta_pic_order_always_zero_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t gaps_in_frame_num_value_allowed_flag : 1; + uint32_t qpprime_y_zero_transform_bypass_flag : 1; + uint32_t frame_cropping_flag : 1; + uint32_t seq_scaling_matrix_present_flag : 1; + uint32_t vui_parameters_present_flag : 1; +} StdVideoH264SpsFlags; + +typedef struct StdVideoH264ScalingLists { + uint16_t scaling_list_present_mask; + uint16_t use_default_scaling_matrix_mask; + uint8_t ScalingList4x4[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS]; + uint8_t ScalingList8x8[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS]; +} StdVideoH264ScalingLists; + +typedef struct StdVideoH264SequenceParameterSet { + StdVideoH264SpsFlags flags; + StdVideoH264ProfileIdc profile_idc; + StdVideoH264LevelIdc level_idc; + StdVideoH264ChromaFormatIdc chroma_format_idc; + uint8_t seq_parameter_set_id; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_frame_num_minus4; + StdVideoH264PocType pic_order_cnt_type; + int32_t offset_for_non_ref_pic; + int32_t offset_for_top_to_bottom_field; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + uint8_t num_ref_frames_in_pic_order_cnt_cycle; + uint8_t max_num_ref_frames; + uint8_t reserved1; + uint32_t pic_width_in_mbs_minus1; + uint32_t pic_height_in_map_units_minus1; + uint32_t frame_crop_left_offset; + uint32_t frame_crop_right_offset; + uint32_t frame_crop_top_offset; + uint32_t frame_crop_bottom_offset; + uint32_t reserved2; + const int32_t* pOffsetForRefFrame; + const StdVideoH264ScalingLists* pScalingLists; + const StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; +} StdVideoH264SequenceParameterSet; + +typedef struct StdVideoH264PpsFlags { + uint32_t transform_8x8_mode_flag : 1; + uint32_t redundant_pic_cnt_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t bottom_field_pic_order_in_frame_present_flag : 1; + uint32_t entropy_coding_mode_flag : 1; + uint32_t pic_scaling_matrix_present_flag : 1; +} StdVideoH264PpsFlags; + +typedef struct StdVideoH264PictureParameterSet { + StdVideoH264PpsFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + StdVideoH264WeightedBipredIdc weighted_bipred_idc; + int8_t pic_init_qp_minus26; + int8_t pic_init_qs_minus26; + int8_t chroma_qp_index_offset; + int8_t second_chroma_qp_index_offset; + const StdVideoH264ScalingLists* pScalingLists; +} StdVideoH264PictureParameterSet; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_decode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_decode.h new file mode 100644 index 00000000000..a6bfe9d8228 --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_decode.h @@ -0,0 +1,77 @@ +#ifndef VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_h264std_decode is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_h264std_decode 1 +#include "vulkan_video_codec_h264std.h" + +#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_decode" +#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2U + +typedef enum StdVideoDecodeH264FieldOrderCount { + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM = 1, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID = 0x7FFFFFFF, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_MAX_ENUM = 0x7FFFFFFF +} StdVideoDecodeH264FieldOrderCount; +typedef struct StdVideoDecodeH264PictureInfoFlags { + uint32_t field_pic_flag : 1; + uint32_t is_intra : 1; + uint32_t IdrPicFlag : 1; + uint32_t bottom_field_flag : 1; + uint32_t is_reference : 1; + uint32_t complementary_field_pair : 1; +} StdVideoDecodeH264PictureInfoFlags; + +typedef struct StdVideoDecodeH264PictureInfo { + StdVideoDecodeH264PictureInfoFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint8_t reserved1; + uint8_t reserved2; + uint16_t frame_num; + uint16_t idr_pic_id; + int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; +} StdVideoDecodeH264PictureInfo; + +typedef struct StdVideoDecodeH264ReferenceInfoFlags { + uint32_t top_field_flag : 1; + uint32_t bottom_field_flag : 1; + uint32_t used_for_long_term_reference : 1; + uint32_t is_non_existing : 1; +} StdVideoDecodeH264ReferenceInfoFlags; + +typedef struct StdVideoDecodeH264ReferenceInfo { + StdVideoDecodeH264ReferenceInfoFlags flags; + uint16_t FrameNum; + uint16_t reserved; + int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; +} StdVideoDecodeH264ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_encode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_encode.h new file mode 100644 index 00000000000..2d42ac321b8 --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_encode.h @@ -0,0 +1,147 @@ +#ifndef VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ +#define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_h264std_encode is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_h264std_encode 1 +#include "vulkan_video_codec_h264std.h" + +#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_encode" +typedef struct StdVideoEncodeH264WeightTableFlags { + uint32_t luma_weight_l0_flag; + uint32_t chroma_weight_l0_flag; + uint32_t luma_weight_l1_flag; + uint32_t chroma_weight_l1_flag; +} StdVideoEncodeH264WeightTableFlags; + +typedef struct StdVideoEncodeH264WeightTable { + StdVideoEncodeH264WeightTableFlags flags; + uint8_t luma_log2_weight_denom; + uint8_t chroma_log2_weight_denom; + int8_t luma_weight_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + int8_t luma_offset_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + int8_t chroma_weight_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; + int8_t chroma_offset_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; + int8_t luma_weight_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + int8_t luma_offset_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + int8_t chroma_weight_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; + int8_t chroma_offset_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; +} StdVideoEncodeH264WeightTable; + +typedef struct StdVideoEncodeH264SliceHeaderFlags { + uint32_t direct_spatial_mv_pred_flag : 1; + uint32_t num_ref_idx_active_override_flag : 1; + uint32_t reserved : 30; +} StdVideoEncodeH264SliceHeaderFlags; + +typedef struct StdVideoEncodeH264PictureInfoFlags { + uint32_t IdrPicFlag : 1; + uint32_t is_reference : 1; + uint32_t no_output_of_prior_pics_flag : 1; + uint32_t long_term_reference_flag : 1; + uint32_t adaptive_ref_pic_marking_mode_flag : 1; + uint32_t reserved : 27; +} StdVideoEncodeH264PictureInfoFlags; + +typedef struct StdVideoEncodeH264ReferenceInfoFlags { + uint32_t used_for_long_term_reference : 1; + uint32_t reserved : 31; +} StdVideoEncodeH264ReferenceInfoFlags; + +typedef struct StdVideoEncodeH264ReferenceListsInfoFlags { + uint32_t ref_pic_list_modification_flag_l0 : 1; + uint32_t ref_pic_list_modification_flag_l1 : 1; + uint32_t reserved : 30; +} StdVideoEncodeH264ReferenceListsInfoFlags; + +typedef struct StdVideoEncodeH264RefListModEntry { + StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc; + uint16_t abs_diff_pic_num_minus1; + uint16_t long_term_pic_num; +} StdVideoEncodeH264RefListModEntry; + +typedef struct StdVideoEncodeH264RefPicMarkingEntry { + StdVideoH264MemMgmtControlOp memory_management_control_operation; + uint16_t difference_of_pic_nums_minus1; + uint16_t long_term_pic_num; + uint16_t long_term_frame_idx; + uint16_t max_long_term_frame_idx_plus1; +} StdVideoEncodeH264RefPicMarkingEntry; + +typedef struct StdVideoEncodeH264ReferenceListsInfo { + StdVideoEncodeH264ReferenceListsInfoFlags flags; + uint8_t num_ref_idx_l0_active_minus1; + uint8_t num_ref_idx_l1_active_minus1; + uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + uint8_t refList0ModOpCount; + uint8_t refList1ModOpCount; + uint8_t refPicMarkingOpCount; + uint8_t reserved1[7]; + const StdVideoEncodeH264RefListModEntry* pRefList0ModOperations; + const StdVideoEncodeH264RefListModEntry* pRefList1ModOperations; + const StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations; +} StdVideoEncodeH264ReferenceListsInfo; + +typedef struct StdVideoEncodeH264PictureInfo { + StdVideoEncodeH264PictureInfoFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint16_t idr_pic_id; + StdVideoH264PictureType primary_pic_type; + uint32_t frame_num; + int32_t PicOrderCnt; + uint8_t temporal_id; + uint8_t reserved1[3]; + const StdVideoEncodeH264ReferenceListsInfo* pRefLists; +} StdVideoEncodeH264PictureInfo; + +typedef struct StdVideoEncodeH264ReferenceInfo { + StdVideoEncodeH264ReferenceInfoFlags flags; + StdVideoH264PictureType primary_pic_type; + uint32_t FrameNum; + int32_t PicOrderCnt; + uint16_t long_term_pic_num; + uint16_t long_term_frame_idx; + uint8_t temporal_id; +} StdVideoEncodeH264ReferenceInfo; + +typedef struct StdVideoEncodeH264SliceHeader { + StdVideoEncodeH264SliceHeaderFlags flags; + uint32_t first_mb_in_slice; + StdVideoH264SliceType slice_type; + int8_t slice_alpha_c0_offset_div2; + int8_t slice_beta_offset_div2; + int8_t slice_qp_delta; + uint8_t reserved1; + StdVideoH264CabacInitIdc cabac_init_idc; + StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; + const StdVideoEncodeH264WeightTable* pWeightTable; +} StdVideoEncodeH264SliceHeader; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std.h new file mode 100644 index 00000000000..23617b8f962 --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std.h @@ -0,0 +1,446 @@ +#ifndef VULKAN_VIDEO_CODEC_H265STD_H_ +#define VULKAN_VIDEO_CODEC_H265STD_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_h265std is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_h265std 1 +#include "vulkan_video_codecs_common.h" +#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32U +#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7U +#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6U +#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16U +#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6U +#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64U +#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6U +#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64U +#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2U +#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64U +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6U +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19U +#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21U +#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3U +#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128U +#define STD_VIDEO_H265_MAX_NUM_LIST_REF 15U +#define STD_VIDEO_H265_MAX_CHROMA_PLANES 2U +#define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64U +#define STD_VIDEO_H265_MAX_DPB_SIZE 16U +#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32U +#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16U +#define STD_VIDEO_H265_MAX_DELTA_POC 48U +#define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFFU + +typedef enum StdVideoH265ChromaFormatIdc { + STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_420 = 1, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_422 = 2, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_444 = 3, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265ChromaFormatIdc; + +typedef enum StdVideoH265ProfileIdc { + STD_VIDEO_H265_PROFILE_IDC_MAIN = 1, + STD_VIDEO_H265_PROFILE_IDC_MAIN_10 = 2, + STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE = 3, + STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS = 4, + STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS = 9, + STD_VIDEO_H265_PROFILE_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265ProfileIdc; + +typedef enum StdVideoH265LevelIdc { + STD_VIDEO_H265_LEVEL_IDC_1_0 = 0, + STD_VIDEO_H265_LEVEL_IDC_2_0 = 1, + STD_VIDEO_H265_LEVEL_IDC_2_1 = 2, + STD_VIDEO_H265_LEVEL_IDC_3_0 = 3, + STD_VIDEO_H265_LEVEL_IDC_3_1 = 4, + STD_VIDEO_H265_LEVEL_IDC_4_0 = 5, + STD_VIDEO_H265_LEVEL_IDC_4_1 = 6, + STD_VIDEO_H265_LEVEL_IDC_5_0 = 7, + STD_VIDEO_H265_LEVEL_IDC_5_1 = 8, + STD_VIDEO_H265_LEVEL_IDC_5_2 = 9, + STD_VIDEO_H265_LEVEL_IDC_6_0 = 10, + STD_VIDEO_H265_LEVEL_IDC_6_1 = 11, + STD_VIDEO_H265_LEVEL_IDC_6_2 = 12, + STD_VIDEO_H265_LEVEL_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265LevelIdc; + +typedef enum StdVideoH265SliceType { + STD_VIDEO_H265_SLICE_TYPE_B = 0, + STD_VIDEO_H265_SLICE_TYPE_P = 1, + STD_VIDEO_H265_SLICE_TYPE_I = 2, + STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265SliceType; + +typedef enum StdVideoH265PictureType { + STD_VIDEO_H265_PICTURE_TYPE_P = 0, + STD_VIDEO_H265_PICTURE_TYPE_B = 1, + STD_VIDEO_H265_PICTURE_TYPE_I = 2, + STD_VIDEO_H265_PICTURE_TYPE_IDR = 3, + STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265PictureType; + +typedef enum StdVideoH265AspectRatioIdc { + STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED = 0, + STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE = 1, + STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11 = 2, + STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11 = 3, + STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11 = 4, + STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33 = 5, + STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11 = 6, + STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11 = 7, + STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11 = 8, + STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33 = 9, + STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11 = 10, + STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11 = 11, + STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33 = 12, + STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99 = 13, + STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3 = 14, + STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2 = 15, + STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1 = 16, + STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, + STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265AspectRatioIdc; +typedef struct StdVideoH265DecPicBufMgr { + uint32_t max_latency_increase_plus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint8_t max_dec_pic_buffering_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint8_t max_num_reorder_pics[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; +} StdVideoH265DecPicBufMgr; + +typedef struct StdVideoH265SubLayerHrdParameters { + uint32_t bit_rate_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cpb_size_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t bit_rate_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; + uint32_t cbr_flag; +} StdVideoH265SubLayerHrdParameters; + +typedef struct StdVideoH265HrdFlags { + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; + uint32_t sub_pic_hrd_params_present_flag : 1; + uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; + uint32_t fixed_pic_rate_general_flag : 8; + uint32_t fixed_pic_rate_within_cvs_flag : 8; + uint32_t low_delay_hrd_flag : 8; +} StdVideoH265HrdFlags; + +typedef struct StdVideoH265HrdParameters { + StdVideoH265HrdFlags flags; + uint8_t tick_divisor_minus2; + uint8_t du_cpb_removal_delay_increment_length_minus1; + uint8_t dpb_output_delay_du_length_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint8_t cpb_size_du_scale; + uint8_t initial_cpb_removal_delay_length_minus1; + uint8_t au_cpb_removal_delay_length_minus1; + uint8_t dpb_output_delay_length_minus1; + uint8_t cpb_cnt_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint16_t elemental_duration_in_tc_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; + uint16_t reserved[3]; + const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal; + const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl; +} StdVideoH265HrdParameters; + +typedef struct StdVideoH265VpsFlags { + uint32_t vps_temporal_id_nesting_flag : 1; + uint32_t vps_sub_layer_ordering_info_present_flag : 1; + uint32_t vps_timing_info_present_flag : 1; + uint32_t vps_poc_proportional_to_timing_flag : 1; +} StdVideoH265VpsFlags; + +typedef struct StdVideoH265ProfileTierLevelFlags { + uint32_t general_tier_flag : 1; + uint32_t general_progressive_source_flag : 1; + uint32_t general_interlaced_source_flag : 1; + uint32_t general_non_packed_constraint_flag : 1; + uint32_t general_frame_only_constraint_flag : 1; +} StdVideoH265ProfileTierLevelFlags; + +typedef struct StdVideoH265ProfileTierLevel { + StdVideoH265ProfileTierLevelFlags flags; + StdVideoH265ProfileIdc general_profile_idc; + StdVideoH265LevelIdc general_level_idc; +} StdVideoH265ProfileTierLevel; + +typedef struct StdVideoH265VideoParameterSet { + StdVideoH265VpsFlags flags; + uint8_t vps_video_parameter_set_id; + uint8_t vps_max_sub_layers_minus1; + uint8_t reserved1; + uint8_t reserved2; + uint32_t vps_num_units_in_tick; + uint32_t vps_time_scale; + uint32_t vps_num_ticks_poc_diff_one_minus1; + uint32_t reserved3; + const StdVideoH265DecPicBufMgr* pDecPicBufMgr; + const StdVideoH265HrdParameters* pHrdParameters; + const StdVideoH265ProfileTierLevel* pProfileTierLevel; +} StdVideoH265VideoParameterSet; + +typedef struct StdVideoH265ScalingLists { + uint8_t ScalingList4x4[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS]; + uint8_t ScalingList8x8[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS]; + uint8_t ScalingList16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS]; + uint8_t ScalingList32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS]; + uint8_t ScalingListDCCoef16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS]; + uint8_t ScalingListDCCoef32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS]; +} StdVideoH265ScalingLists; + +typedef struct StdVideoH265SpsVuiFlags { + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t colour_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t neutral_chroma_indication_flag : 1; + uint32_t field_seq_flag : 1; + uint32_t frame_field_info_present_flag : 1; + uint32_t default_display_window_flag : 1; + uint32_t vui_timing_info_present_flag : 1; + uint32_t vui_poc_proportional_to_timing_flag : 1; + uint32_t vui_hrd_parameters_present_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t tiles_fixed_structure_flag : 1; + uint32_t motion_vectors_over_pic_boundaries_flag : 1; + uint32_t restricted_ref_pic_lists_flag : 1; +} StdVideoH265SpsVuiFlags; + +typedef struct StdVideoH265SequenceParameterSetVui { + StdVideoH265SpsVuiFlags flags; + StdVideoH265AspectRatioIdc aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coeffs; + uint8_t chroma_sample_loc_type_top_field; + uint8_t chroma_sample_loc_type_bottom_field; + uint8_t reserved1; + uint8_t reserved2; + uint16_t def_disp_win_left_offset; + uint16_t def_disp_win_right_offset; + uint16_t def_disp_win_top_offset; + uint16_t def_disp_win_bottom_offset; + uint32_t vui_num_units_in_tick; + uint32_t vui_time_scale; + uint32_t vui_num_ticks_poc_diff_one_minus1; + uint16_t min_spatial_segmentation_idc; + uint16_t reserved3; + uint8_t max_bytes_per_pic_denom; + uint8_t max_bits_per_min_cu_denom; + uint8_t log2_max_mv_length_horizontal; + uint8_t log2_max_mv_length_vertical; + const StdVideoH265HrdParameters* pHrdParameters; +} StdVideoH265SequenceParameterSetVui; + +typedef struct StdVideoH265PredictorPaletteEntries { + uint16_t PredictorPaletteEntries[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE]; +} StdVideoH265PredictorPaletteEntries; + +typedef struct StdVideoH265SpsFlags { + uint32_t sps_temporal_id_nesting_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t conformance_window_flag : 1; + uint32_t sps_sub_layer_ordering_info_present_flag : 1; + uint32_t scaling_list_enabled_flag : 1; + uint32_t sps_scaling_list_data_present_flag : 1; + uint32_t amp_enabled_flag : 1; + uint32_t sample_adaptive_offset_enabled_flag : 1; + uint32_t pcm_enabled_flag : 1; + uint32_t pcm_loop_filter_disabled_flag : 1; + uint32_t long_term_ref_pics_present_flag : 1; + uint32_t sps_temporal_mvp_enabled_flag : 1; + uint32_t strong_intra_smoothing_enabled_flag : 1; + uint32_t vui_parameters_present_flag : 1; + uint32_t sps_extension_present_flag : 1; + uint32_t sps_range_extension_flag : 1; + uint32_t transform_skip_rotation_enabled_flag : 1; + uint32_t transform_skip_context_enabled_flag : 1; + uint32_t implicit_rdpcm_enabled_flag : 1; + uint32_t explicit_rdpcm_enabled_flag : 1; + uint32_t extended_precision_processing_flag : 1; + uint32_t intra_smoothing_disabled_flag : 1; + uint32_t high_precision_offsets_enabled_flag : 1; + uint32_t persistent_rice_adaptation_enabled_flag : 1; + uint32_t cabac_bypass_alignment_enabled_flag : 1; + uint32_t sps_scc_extension_flag : 1; + uint32_t sps_curr_pic_ref_enabled_flag : 1; + uint32_t palette_mode_enabled_flag : 1; + uint32_t sps_palette_predictor_initializers_present_flag : 1; + uint32_t intra_boundary_filtering_disabled_flag : 1; +} StdVideoH265SpsFlags; + +typedef struct StdVideoH265ShortTermRefPicSetFlags { + uint32_t inter_ref_pic_set_prediction_flag : 1; + uint32_t delta_rps_sign : 1; +} StdVideoH265ShortTermRefPicSetFlags; + +typedef struct StdVideoH265ShortTermRefPicSet { + StdVideoH265ShortTermRefPicSetFlags flags; + uint32_t delta_idx_minus1; + uint16_t use_delta_flag; + uint16_t abs_delta_rps_minus1; + uint16_t used_by_curr_pic_flag; + uint16_t used_by_curr_pic_s0_flag; + uint16_t used_by_curr_pic_s1_flag; + uint16_t reserved1; + uint8_t reserved2; + uint8_t reserved3; + uint8_t num_negative_pics; + uint8_t num_positive_pics; + uint16_t delta_poc_s0_minus1[STD_VIDEO_H265_MAX_DPB_SIZE]; + uint16_t delta_poc_s1_minus1[STD_VIDEO_H265_MAX_DPB_SIZE]; +} StdVideoH265ShortTermRefPicSet; + +typedef struct StdVideoH265LongTermRefPicsSps { + uint32_t used_by_curr_pic_lt_sps_flag; + uint32_t lt_ref_pic_poc_lsb_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]; +} StdVideoH265LongTermRefPicsSps; + +typedef struct StdVideoH265SequenceParameterSet { + StdVideoH265SpsFlags flags; + StdVideoH265ChromaFormatIdc chroma_format_idc; + uint32_t pic_width_in_luma_samples; + uint32_t pic_height_in_luma_samples; + uint8_t sps_video_parameter_set_id; + uint8_t sps_max_sub_layers_minus1; + uint8_t sps_seq_parameter_set_id; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + uint8_t log2_min_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_luma_coding_block_size; + uint8_t log2_min_luma_transform_block_size_minus2; + uint8_t log2_diff_max_min_luma_transform_block_size; + uint8_t max_transform_hierarchy_depth_inter; + uint8_t max_transform_hierarchy_depth_intra; + uint8_t num_short_term_ref_pic_sets; + uint8_t num_long_term_ref_pics_sps; + uint8_t pcm_sample_bit_depth_luma_minus1; + uint8_t pcm_sample_bit_depth_chroma_minus1; + uint8_t log2_min_pcm_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_pcm_luma_coding_block_size; + uint8_t reserved1; + uint8_t reserved2; + uint8_t palette_max_size; + uint8_t delta_palette_max_predictor_size; + uint8_t motion_vector_resolution_control_idc; + uint8_t sps_num_palette_predictor_initializers_minus1; + uint32_t conf_win_left_offset; + uint32_t conf_win_right_offset; + uint32_t conf_win_top_offset; + uint32_t conf_win_bottom_offset; + const StdVideoH265ProfileTierLevel* pProfileTierLevel; + const StdVideoH265DecPicBufMgr* pDecPicBufMgr; + const StdVideoH265ScalingLists* pScalingLists; + const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; + const StdVideoH265LongTermRefPicsSps* pLongTermRefPicsSps; + const StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; + const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; +} StdVideoH265SequenceParameterSet; + +typedef struct StdVideoH265PpsFlags { + uint32_t dependent_slice_segments_enabled_flag : 1; + uint32_t output_flag_present_flag : 1; + uint32_t sign_data_hiding_enabled_flag : 1; + uint32_t cabac_init_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t transform_skip_enabled_flag : 1; + uint32_t cu_qp_delta_enabled_flag : 1; + uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t weighted_bipred_flag : 1; + uint32_t transquant_bypass_enabled_flag : 1; + uint32_t tiles_enabled_flag : 1; + uint32_t entropy_coding_sync_enabled_flag : 1; + uint32_t uniform_spacing_flag : 1; + uint32_t loop_filter_across_tiles_enabled_flag : 1; + uint32_t pps_loop_filter_across_slices_enabled_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t deblocking_filter_override_enabled_flag : 1; + uint32_t pps_deblocking_filter_disabled_flag : 1; + uint32_t pps_scaling_list_data_present_flag : 1; + uint32_t lists_modification_present_flag : 1; + uint32_t slice_segment_header_extension_present_flag : 1; + uint32_t pps_extension_present_flag : 1; + uint32_t cross_component_prediction_enabled_flag : 1; + uint32_t chroma_qp_offset_list_enabled_flag : 1; + uint32_t pps_curr_pic_ref_enabled_flag : 1; + uint32_t residual_adaptive_colour_transform_enabled_flag : 1; + uint32_t pps_slice_act_qp_offsets_present_flag : 1; + uint32_t pps_palette_predictor_initializers_present_flag : 1; + uint32_t monochrome_palette_flag : 1; + uint32_t pps_range_extension_flag : 1; +} StdVideoH265PpsFlags; + +typedef struct StdVideoH265PictureParameterSet { + StdVideoH265PpsFlags flags; + uint8_t pps_pic_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t sps_video_parameter_set_id; + uint8_t num_extra_slice_header_bits; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + int8_t init_qp_minus26; + uint8_t diff_cu_qp_delta_depth; + int8_t pps_cb_qp_offset; + int8_t pps_cr_qp_offset; + int8_t pps_beta_offset_div2; + int8_t pps_tc_offset_div2; + uint8_t log2_parallel_merge_level_minus2; + uint8_t log2_max_transform_skip_block_size_minus2; + uint8_t diff_cu_chroma_qp_offset_depth; + uint8_t chroma_qp_offset_list_len_minus1; + int8_t cb_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; + int8_t cr_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; + uint8_t log2_sao_offset_scale_luma; + uint8_t log2_sao_offset_scale_chroma; + int8_t pps_act_y_qp_offset_plus5; + int8_t pps_act_cb_qp_offset_plus5; + int8_t pps_act_cr_qp_offset_plus3; + uint8_t pps_num_palette_predictor_initializers; + uint8_t luma_bit_depth_entry_minus8; + uint8_t chroma_bit_depth_entry_minus8; + uint8_t num_tile_columns_minus1; + uint8_t num_tile_rows_minus1; + uint8_t reserved1; + uint8_t reserved2; + uint16_t column_width_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]; + uint16_t row_height_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]; + uint32_t reserved3; + const StdVideoH265ScalingLists* pScalingLists; + const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; +} StdVideoH265PictureParameterSet; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_decode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_decode.h new file mode 100644 index 00000000000..1758d4a88dd --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_decode.h @@ -0,0 +1,67 @@ +#ifndef VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_h265std_decode is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_h265std_decode 1 +#include "vulkan_video_codec_h265std.h" + +#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_decode" +#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8U +typedef struct StdVideoDecodeH265PictureInfoFlags { + uint32_t IrapPicFlag : 1; + uint32_t IdrPicFlag : 1; + uint32_t IsReference : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; +} StdVideoDecodeH265PictureInfoFlags; + +typedef struct StdVideoDecodeH265PictureInfo { + StdVideoDecodeH265PictureInfoFlags flags; + uint8_t sps_video_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t pps_pic_parameter_set_id; + uint8_t NumDeltaPocsOfRefRpsIdx; + int32_t PicOrderCntVal; + uint16_t NumBitsForSTRefPicSetInSlice; + uint16_t reserved; + uint8_t RefPicSetStCurrBefore[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; + uint8_t RefPicSetStCurrAfter[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; + uint8_t RefPicSetLtCurr[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; +} StdVideoDecodeH265PictureInfo; + +typedef struct StdVideoDecodeH265ReferenceInfoFlags { + uint32_t used_for_long_term_reference : 1; + uint32_t unused_for_reference : 1; +} StdVideoDecodeH265ReferenceInfoFlags; + +typedef struct StdVideoDecodeH265ReferenceInfo { + StdVideoDecodeH265ReferenceInfoFlags flags; + int32_t PicOrderCntVal; +} StdVideoDecodeH265ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_encode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_encode.h new file mode 100644 index 00000000000..e584a7262b9 --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_encode.h @@ -0,0 +1,157 @@ +#ifndef VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ +#define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_h265std_encode is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_h265std_encode 1 +#include "vulkan_video_codec_h265std.h" + +#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_encode" +typedef struct StdVideoEncodeH265WeightTableFlags { + uint16_t luma_weight_l0_flag; + uint16_t chroma_weight_l0_flag; + uint16_t luma_weight_l1_flag; + uint16_t chroma_weight_l1_flag; +} StdVideoEncodeH265WeightTableFlags; + +typedef struct StdVideoEncodeH265WeightTable { + StdVideoEncodeH265WeightTableFlags flags; + uint8_t luma_log2_weight_denom; + int8_t delta_chroma_log2_weight_denom; + int8_t delta_luma_weight_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + int8_t luma_offset_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + int8_t delta_chroma_weight_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; + int8_t delta_chroma_offset_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; + int8_t delta_luma_weight_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + int8_t luma_offset_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + int8_t delta_chroma_weight_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; + int8_t delta_chroma_offset_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; +} StdVideoEncodeH265WeightTable; + +typedef struct StdVideoEncodeH265SliceSegmentHeaderFlags { + uint32_t first_slice_segment_in_pic_flag : 1; + uint32_t dependent_slice_segment_flag : 1; + uint32_t slice_sao_luma_flag : 1; + uint32_t slice_sao_chroma_flag : 1; + uint32_t num_ref_idx_active_override_flag : 1; + uint32_t mvd_l1_zero_flag : 1; + uint32_t cabac_init_flag : 1; + uint32_t cu_chroma_qp_offset_enabled_flag : 1; + uint32_t deblocking_filter_override_flag : 1; + uint32_t slice_deblocking_filter_disabled_flag : 1; + uint32_t collocated_from_l0_flag : 1; + uint32_t slice_loop_filter_across_slices_enabled_flag : 1; + uint32_t reserved : 20; +} StdVideoEncodeH265SliceSegmentHeaderFlags; + +typedef struct StdVideoEncodeH265SliceSegmentHeader { + StdVideoEncodeH265SliceSegmentHeaderFlags flags; + StdVideoH265SliceType slice_type; + uint32_t slice_segment_address; + uint8_t collocated_ref_idx; + uint8_t MaxNumMergeCand; + int8_t slice_cb_qp_offset; + int8_t slice_cr_qp_offset; + int8_t slice_beta_offset_div2; + int8_t slice_tc_offset_div2; + int8_t slice_act_y_qp_offset; + int8_t slice_act_cb_qp_offset; + int8_t slice_act_cr_qp_offset; + int8_t slice_qp_delta; + uint16_t reserved1; + const StdVideoEncodeH265WeightTable* pWeightTable; +} StdVideoEncodeH265SliceSegmentHeader; + +typedef struct StdVideoEncodeH265ReferenceListsInfoFlags { + uint32_t ref_pic_list_modification_flag_l0 : 1; + uint32_t ref_pic_list_modification_flag_l1 : 1; + uint32_t reserved : 30; +} StdVideoEncodeH265ReferenceListsInfoFlags; + +typedef struct StdVideoEncodeH265ReferenceListsInfo { + StdVideoEncodeH265ReferenceListsInfoFlags flags; + uint8_t num_ref_idx_l0_active_minus1; + uint8_t num_ref_idx_l1_active_minus1; + uint8_t RefPicList0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + uint8_t RefPicList1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + uint8_t list_entry_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; + uint8_t list_entry_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; +} StdVideoEncodeH265ReferenceListsInfo; + +typedef struct StdVideoEncodeH265PictureInfoFlags { + uint32_t is_reference : 1; + uint32_t IrapPicFlag : 1; + uint32_t used_for_long_term_reference : 1; + uint32_t discardable_flag : 1; + uint32_t cross_layer_bla_flag : 1; + uint32_t pic_output_flag : 1; + uint32_t no_output_of_prior_pics_flag : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; + uint32_t slice_temporal_mvp_enabled_flag : 1; + uint32_t reserved : 23; +} StdVideoEncodeH265PictureInfoFlags; + +typedef struct StdVideoEncodeH265LongTermRefPics { + uint8_t num_long_term_sps; + uint8_t num_long_term_pics; + uint8_t lt_idx_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]; + uint8_t poc_lsb_lt[STD_VIDEO_H265_MAX_LONG_TERM_PICS]; + uint16_t used_by_curr_pic_lt_flag; + uint8_t delta_poc_msb_present_flag[STD_VIDEO_H265_MAX_DELTA_POC]; + uint8_t delta_poc_msb_cycle_lt[STD_VIDEO_H265_MAX_DELTA_POC]; +} StdVideoEncodeH265LongTermRefPics; + +typedef struct StdVideoEncodeH265PictureInfo { + StdVideoEncodeH265PictureInfoFlags flags; + StdVideoH265PictureType pic_type; + uint8_t sps_video_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t pps_pic_parameter_set_id; + uint8_t short_term_ref_pic_set_idx; + int32_t PicOrderCntVal; + uint8_t TemporalId; + uint8_t reserved1[7]; + const StdVideoEncodeH265ReferenceListsInfo* pRefLists; + const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; + const StdVideoEncodeH265LongTermRefPics* pLongTermRefPics; +} StdVideoEncodeH265PictureInfo; + +typedef struct StdVideoEncodeH265ReferenceInfoFlags { + uint32_t used_for_long_term_reference : 1; + uint32_t unused_for_reference : 1; + uint32_t reserved : 30; +} StdVideoEncodeH265ReferenceInfoFlags; + +typedef struct StdVideoEncodeH265ReferenceInfo { + StdVideoEncodeH265ReferenceInfoFlags flags; + StdVideoH265PictureType pic_type; + int32_t PicOrderCntVal; + uint8_t TemporalId; +} StdVideoEncodeH265ReferenceInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std.h new file mode 100644 index 00000000000..3c62f287e76 --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std.h @@ -0,0 +1,151 @@ +#ifndef VULKAN_VIDEO_CODEC_VP9STD_H_ +#define VULKAN_VIDEO_CODEC_VP9STD_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_vp9std is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_vp9std 1 +#include "vulkan_video_codecs_common.h" +#define STD_VIDEO_VP9_NUM_REF_FRAMES 8U +#define STD_VIDEO_VP9_REFS_PER_FRAME 3U +#define STD_VIDEO_VP9_MAX_REF_FRAMES 4U +#define STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS 2U +#define STD_VIDEO_VP9_MAX_SEGMENTS 8U +#define STD_VIDEO_VP9_SEG_LVL_MAX 4U +#define STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS 7U +#define STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB 3U + +typedef enum StdVideoVP9Profile { + STD_VIDEO_VP9_PROFILE_0 = 0, + STD_VIDEO_VP9_PROFILE_1 = 1, + STD_VIDEO_VP9_PROFILE_2 = 2, + STD_VIDEO_VP9_PROFILE_3 = 3, + STD_VIDEO_VP9_PROFILE_INVALID = 0x7FFFFFFF, + STD_VIDEO_VP9_PROFILE_MAX_ENUM = 0x7FFFFFFF +} StdVideoVP9Profile; + +typedef enum StdVideoVP9Level { + STD_VIDEO_VP9_LEVEL_1_0 = 0, + STD_VIDEO_VP9_LEVEL_1_1 = 1, + STD_VIDEO_VP9_LEVEL_2_0 = 2, + STD_VIDEO_VP9_LEVEL_2_1 = 3, + STD_VIDEO_VP9_LEVEL_3_0 = 4, + STD_VIDEO_VP9_LEVEL_3_1 = 5, + STD_VIDEO_VP9_LEVEL_4_0 = 6, + STD_VIDEO_VP9_LEVEL_4_1 = 7, + STD_VIDEO_VP9_LEVEL_5_0 = 8, + STD_VIDEO_VP9_LEVEL_5_1 = 9, + STD_VIDEO_VP9_LEVEL_5_2 = 10, + STD_VIDEO_VP9_LEVEL_6_0 = 11, + STD_VIDEO_VP9_LEVEL_6_1 = 12, + STD_VIDEO_VP9_LEVEL_6_2 = 13, + STD_VIDEO_VP9_LEVEL_INVALID = 0x7FFFFFFF, + STD_VIDEO_VP9_LEVEL_MAX_ENUM = 0x7FFFFFFF +} StdVideoVP9Level; + +typedef enum StdVideoVP9FrameType { + STD_VIDEO_VP9_FRAME_TYPE_KEY = 0, + STD_VIDEO_VP9_FRAME_TYPE_NON_KEY = 1, + STD_VIDEO_VP9_FRAME_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_VP9_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoVP9FrameType; + +typedef enum StdVideoVP9ReferenceName { + STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME = 0, + STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME = 1, + STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME = 2, + STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME = 3, + STD_VIDEO_VP9_REFERENCE_NAME_INVALID = 0x7FFFFFFF, + STD_VIDEO_VP9_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF +} StdVideoVP9ReferenceName; + +typedef enum StdVideoVP9InterpolationFilter { + STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP = 0, + STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, + STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, + STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR = 3, + STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE = 4, + STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF, + STD_VIDEO_VP9_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF +} StdVideoVP9InterpolationFilter; + +typedef enum StdVideoVP9ColorSpace { + STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN = 0, + STD_VIDEO_VP9_COLOR_SPACE_BT_601 = 1, + STD_VIDEO_VP9_COLOR_SPACE_BT_709 = 2, + STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170 = 3, + STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240 = 4, + STD_VIDEO_VP9_COLOR_SPACE_BT_2020 = 5, + STD_VIDEO_VP9_COLOR_SPACE_RESERVED = 6, + STD_VIDEO_VP9_COLOR_SPACE_RGB = 7, + STD_VIDEO_VP9_COLOR_SPACE_INVALID = 0x7FFFFFFF, + STD_VIDEO_VP9_COLOR_SPACE_MAX_ENUM = 0x7FFFFFFF +} StdVideoVP9ColorSpace; +typedef struct StdVideoVP9ColorConfigFlags { + uint32_t color_range : 1; + uint32_t reserved : 31; +} StdVideoVP9ColorConfigFlags; + +typedef struct StdVideoVP9ColorConfig { + StdVideoVP9ColorConfigFlags flags; + uint8_t BitDepth; + uint8_t subsampling_x; + uint8_t subsampling_y; + uint8_t reserved1; + StdVideoVP9ColorSpace color_space; +} StdVideoVP9ColorConfig; + +typedef struct StdVideoVP9LoopFilterFlags { + uint32_t loop_filter_delta_enabled : 1; + uint32_t loop_filter_delta_update : 1; + uint32_t reserved : 30; +} StdVideoVP9LoopFilterFlags; + +typedef struct StdVideoVP9LoopFilter { + StdVideoVP9LoopFilterFlags flags; + uint8_t loop_filter_level; + uint8_t loop_filter_sharpness; + uint8_t update_ref_delta; + int8_t loop_filter_ref_deltas[STD_VIDEO_VP9_MAX_REF_FRAMES]; + uint8_t update_mode_delta; + int8_t loop_filter_mode_deltas[STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS]; +} StdVideoVP9LoopFilter; + +typedef struct StdVideoVP9SegmentationFlags { + uint32_t segmentation_update_map : 1; + uint32_t segmentation_temporal_update : 1; + uint32_t segmentation_update_data : 1; + uint32_t segmentation_abs_or_delta_update : 1; + uint32_t reserved : 28; +} StdVideoVP9SegmentationFlags; + +typedef struct StdVideoVP9Segmentation { + StdVideoVP9SegmentationFlags flags; + uint8_t segmentation_tree_probs[STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS]; + uint8_t segmentation_pred_prob[STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB]; + uint8_t FeatureEnabled[STD_VIDEO_VP9_MAX_SEGMENTS]; + int16_t FeatureData[STD_VIDEO_VP9_MAX_SEGMENTS][STD_VIDEO_VP9_SEG_LVL_MAX]; +} StdVideoVP9Segmentation; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std_decode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std_decode.h new file mode 100644 index 00000000000..ac7fa7be8c6 --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std_decode.h @@ -0,0 +1,68 @@ +#ifndef VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ +#define VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codec_vp9std_decode is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codec_vp9std_decode 1 +#include "vulkan_video_codec_vp9std.h" + +#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) + +#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0 +#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_vp9_decode" +typedef struct StdVideoDecodeVP9PictureInfoFlags { + uint32_t error_resilient_mode : 1; + uint32_t intra_only : 1; + uint32_t allow_high_precision_mv : 1; + uint32_t refresh_frame_context : 1; + uint32_t frame_parallel_decoding_mode : 1; + uint32_t segmentation_enabled : 1; + uint32_t show_frame : 1; + uint32_t UsePrevFrameMvs : 1; + uint32_t reserved : 24; +} StdVideoDecodeVP9PictureInfoFlags; + +typedef struct StdVideoDecodeVP9PictureInfo { + StdVideoDecodeVP9PictureInfoFlags flags; + StdVideoVP9Profile profile; + StdVideoVP9FrameType frame_type; + uint8_t frame_context_idx; + uint8_t reset_frame_context; + uint8_t refresh_frame_flags; + uint8_t ref_frame_sign_bias_mask; + StdVideoVP9InterpolationFilter interpolation_filter; + uint8_t base_q_idx; + int8_t delta_q_y_dc; + int8_t delta_q_uv_dc; + int8_t delta_q_uv_ac; + uint8_t tile_cols_log2; + uint8_t tile_rows_log2; + uint16_t reserved1[3]; + const StdVideoVP9ColorConfig* pColorConfig; + const StdVideoVP9LoopFilter* pLoopFilter; + const StdVideoVP9Segmentation* pSegmentation; +} StdVideoDecodeVP9PictureInfo; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codecs_common.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codecs_common.h new file mode 100644 index 00000000000..3c4d0553d08 --- /dev/null +++ b/lib/vulkan-headers/include/vk_video/vulkan_video_codecs_common.h @@ -0,0 +1,36 @@ +#ifndef VULKAN_VIDEO_CODECS_COMMON_H_ +#define VULKAN_VIDEO_CODECS_COMMON_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// vulkan_video_codecs_common is a preprocessor guard. Do not pass it to API calls. +#define vulkan_video_codecs_common 1 +#if !defined(VK_NO_STDINT_H) + #include +#endif + +#define VK_MAKE_VIDEO_STD_VERSION(major, minor, patch) \ + ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vk_icd.h b/lib/vulkan-headers/include/vulkan/vk_icd.h new file mode 100644 index 00000000000..d71f5682abb --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vk_icd.h @@ -0,0 +1,245 @@ +/* + * Copyright 2015-2023 The Khronos Group Inc. + * Copyright 2015-2023 Valve Corporation + * Copyright 2015-2023 LunarG, Inc. + * + * SPDX-License-Identifier: Apache-2.0 + */ +#pragma once + +#include "vulkan.h" +#include + +// Loader-ICD version negotiation API. Versions add the following features: +// Version 0 - Initial. Doesn't support vk_icdGetInstanceProcAddr +// or vk_icdNegotiateLoaderICDInterfaceVersion. +// Version 1 - Add support for vk_icdGetInstanceProcAddr. +// Version 2 - Add Loader/ICD Interface version negotiation +// via vk_icdNegotiateLoaderICDInterfaceVersion. +// Version 3 - Add ICD creation/destruction of KHR_surface objects. +// Version 4 - Add unknown physical device extension querying via +// vk_icdGetPhysicalDeviceProcAddr. +// Version 5 - Tells ICDs that the loader is now paying attention to the +// application version of Vulkan passed into the ApplicationInfo +// structure during vkCreateInstance. This will tell the ICD +// that if the loader is older, it should automatically fail a +// call for any API version > 1.0. Otherwise, the loader will +// manually determine if it can support the expected version. +// Version 6 - Add support for vk_icdEnumerateAdapterPhysicalDevices. +// Version 7 - If an ICD supports any of the following functions, they must be +// queryable with vk_icdGetInstanceProcAddr: +// vk_icdNegotiateLoaderICDInterfaceVersion +// vk_icdGetPhysicalDeviceProcAddr +// vk_icdEnumerateAdapterPhysicalDevices (Windows only) +// In addition, these functions no longer need to be exported directly. +// This version allows drivers provided through the extension +// VK_LUNARG_direct_driver_loading be able to support the entire +// Driver-Loader interface. + +#define CURRENT_LOADER_ICD_INTERFACE_VERSION 7 +#define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0 +#define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4 + +// Old typedefs that don't follow a proper naming convention but are preserved for compatibility +typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion); +// This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this +// file directly, it won't be found. +#ifndef IS_DEFINED_PFN_GetPhysicalDeviceProcAddr +typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName); +#define IS_DEFINED_PFN_GetPhysicalDeviceProcAddr +#endif + +// Typedefs for loader/ICD interface +typedef VkResult (VKAPI_PTR *PFN_vk_icdNegotiateLoaderICDInterfaceVersion)(uint32_t* pVersion); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); +#if defined(VK_USE_PLATFORM_WIN32_KHR) +typedef VkResult (VKAPI_PTR *PFN_vk_icdEnumerateAdapterPhysicalDevices)(VkInstance instance, LUID adapterLUID, + uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +#endif + +// Prototypes for loader/ICD interface +#if !defined(VK_NO_PROTOTYPES) +#ifdef __cplusplus +extern "C" { +#endif + VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pVersion); + VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName); + VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance instance, const char* pName); +#if defined(VK_USE_PLATFORM_WIN32_KHR) + VKAPI_ATTR VkResult VKAPI_CALL vk_icdEnumerateAdapterPhysicalDevices(VkInstance instance, LUID adapterLUID, + uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +#endif +#ifdef __cplusplus +} +#endif +#endif + +/* + * The ICD must reserve space for a pointer for the loader's dispatch + * table, at the start of . + * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro. + */ + +#define ICD_LOADER_MAGIC 0x01CDC0DE + +typedef union { + uintptr_t loaderMagic; + void *loaderData; +} VK_LOADER_DATA; + +static inline void set_loader_magic_value(void *pNewObject) { + VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; + loader_info->loaderMagic = ICD_LOADER_MAGIC; +} + +static inline bool valid_loader_magic_value(void *pNewObject) { + const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; + return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC; +} + +/* + * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that + * contains the platform-specific connection and surface information. + */ +typedef enum { + VK_ICD_WSI_PLATFORM_MIR, + VK_ICD_WSI_PLATFORM_WAYLAND, + VK_ICD_WSI_PLATFORM_WIN32, + VK_ICD_WSI_PLATFORM_XCB, + VK_ICD_WSI_PLATFORM_XLIB, + VK_ICD_WSI_PLATFORM_ANDROID, + VK_ICD_WSI_PLATFORM_MACOS, + VK_ICD_WSI_PLATFORM_IOS, + VK_ICD_WSI_PLATFORM_DISPLAY, + VK_ICD_WSI_PLATFORM_HEADLESS, + VK_ICD_WSI_PLATFORM_METAL, + VK_ICD_WSI_PLATFORM_DIRECTFB, + VK_ICD_WSI_PLATFORM_VI, + VK_ICD_WSI_PLATFORM_GGP, + VK_ICD_WSI_PLATFORM_SCREEN, + VK_ICD_WSI_PLATFORM_FUCHSIA, +} VkIcdWsiPlatform; + +typedef struct { + VkIcdWsiPlatform platform; +} VkIcdSurfaceBase; + +#ifdef VK_USE_PLATFORM_MIR_KHR +typedef struct { + VkIcdSurfaceBase base; + MirConnection *connection; + MirSurface *mirSurface; +} VkIcdSurfaceMir; +#endif // VK_USE_PLATFORM_MIR_KHR + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +typedef struct { + VkIcdSurfaceBase base; + struct wl_display *display; + struct wl_surface *surface; +} VkIcdSurfaceWayland; +#endif // VK_USE_PLATFORM_WAYLAND_KHR + +#ifdef VK_USE_PLATFORM_WIN32_KHR +typedef struct { + VkIcdSurfaceBase base; + HINSTANCE hinstance; + HWND hwnd; +} VkIcdSurfaceWin32; +#endif // VK_USE_PLATFORM_WIN32_KHR + +#ifdef VK_USE_PLATFORM_XCB_KHR +typedef struct { + VkIcdSurfaceBase base; + xcb_connection_t *connection; + xcb_window_t window; +} VkIcdSurfaceXcb; +#endif // VK_USE_PLATFORM_XCB_KHR + +#ifdef VK_USE_PLATFORM_XLIB_KHR +typedef struct { + VkIcdSurfaceBase base; + Display *dpy; + Window window; +} VkIcdSurfaceXlib; +#endif // VK_USE_PLATFORM_XLIB_KHR + +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT +typedef struct { + VkIcdSurfaceBase base; + IDirectFB *dfb; + IDirectFBSurface *surface; +} VkIcdSurfaceDirectFB; +#endif // VK_USE_PLATFORM_DIRECTFB_EXT + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +typedef struct { + VkIcdSurfaceBase base; + struct ANativeWindow *window; +} VkIcdSurfaceAndroid; +#endif // VK_USE_PLATFORM_ANDROID_KHR + +#ifdef VK_USE_PLATFORM_MACOS_MVK +typedef struct { + VkIcdSurfaceBase base; + const void *pView; +} VkIcdSurfaceMacOS; +#endif // VK_USE_PLATFORM_MACOS_MVK + +#ifdef VK_USE_PLATFORM_IOS_MVK +typedef struct { + VkIcdSurfaceBase base; + const void *pView; +} VkIcdSurfaceIOS; +#endif // VK_USE_PLATFORM_IOS_MVK + +#ifdef VK_USE_PLATFORM_GGP +typedef struct { + VkIcdSurfaceBase base; + GgpStreamDescriptor streamDescriptor; +} VkIcdSurfaceGgp; +#endif // VK_USE_PLATFORM_GGP + +typedef struct { + VkIcdSurfaceBase base; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkIcdSurfaceDisplay; + +typedef struct { + VkIcdSurfaceBase base; +} VkIcdSurfaceHeadless; + +#ifdef VK_USE_PLATFORM_METAL_EXT +typedef struct { + VkIcdSurfaceBase base; + const CAMetalLayer *pLayer; +} VkIcdSurfaceMetal; +#endif // VK_USE_PLATFORM_METAL_EXT + +#ifdef VK_USE_PLATFORM_VI_NN +typedef struct { + VkIcdSurfaceBase base; + void *window; +} VkIcdSurfaceVi; +#endif // VK_USE_PLATFORM_VI_NN + +#ifdef VK_USE_PLATFORM_SCREEN_QNX +typedef struct { + VkIcdSurfaceBase base; + struct _screen_context *context; + struct _screen_window *window; +} VkIcdSurfaceScreen; +#endif // VK_USE_PLATFORM_SCREEN_QNX + +#ifdef VK_USE_PLATFORM_FUCHSIA +typedef struct { + VkIcdSurfaceBase base; +} VkIcdSurfaceImagePipe; +#endif // VK_USE_PLATFORM_FUCHSIA diff --git a/lib/vulkan-headers/include/vulkan/vk_layer.h b/lib/vulkan-headers/include/vulkan/vk_layer.h new file mode 100644 index 00000000000..19cf5880c82 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vk_layer.h @@ -0,0 +1,192 @@ +/* + * Copyright 2015-2023 The Khronos Group Inc. + * Copyright 2015-2023 Valve Corporation + * Copyright 2015-2023 LunarG, Inc. + * + * SPDX-License-Identifier: Apache-2.0 + */ +#pragma once + +/* Need to define dispatch table + * Core struct can then have ptr to dispatch table at the top + * Along with object ptrs for current and next OBJ + */ + +#include "vulkan_core.h" + +#define MAX_NUM_UNKNOWN_EXTS 250 + + // Loader-Layer version negotiation API. Versions add the following features: + // Versions 0/1 - Initial. Doesn't support vk_layerGetPhysicalDeviceProcAddr + // or vk_icdNegotiateLoaderLayerInterfaceVersion. + // Version 2 - Add support for vk_layerGetPhysicalDeviceProcAddr and + // vk_icdNegotiateLoaderLayerInterfaceVersion. +#define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2 +#define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1 + +#define VK_CURRENT_CHAIN_VERSION 1 + +// Typedef for use in the interfaces below +#ifndef IS_DEFINED_PFN_GetPhysicalDeviceProcAddr +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); +#define IS_DEFINED_PFN_GetPhysicalDeviceProcAddr +#endif + +// Version negotiation values +typedef enum VkNegotiateLayerStructType { + LAYER_NEGOTIATE_UNINTIALIZED = 0, + LAYER_NEGOTIATE_INTERFACE_STRUCT = 1, +} VkNegotiateLayerStructType; + +// Version negotiation structures +typedef struct VkNegotiateLayerInterface { + VkNegotiateLayerStructType sType; + void *pNext; + uint32_t loaderLayerInterfaceVersion; + PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr; + PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr; +} VkNegotiateLayerInterface; + +// Version negotiation functions +typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct); + +// Function prototype for unknown physical device extension command +typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device); + +// ------------------------------------------------------------------------------------------------ +// CreateInstance and CreateDevice support structures + +/* Sub type of structure for instance and device loader ext of CreateInfo. + * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO + * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO + * then VkLayerFunction indicates struct type pointed to by pNext + */ +typedef enum VkLayerFunction_ { + VK_LAYER_LINK_INFO = 0, + VK_LOADER_DATA_CALLBACK = 1, + VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2, + VK_LOADER_FEATURES = 3, +} VkLayerFunction; + +typedef struct VkLayerInstanceLink_ { + struct VkLayerInstanceLink_ *pNext; + PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; + PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr; +} VkLayerInstanceLink; + +/* + * When creating the device chain the loader needs to pass + * down information about it's device structure needed at + * the end of the chain. Passing the data via the + * VkLayerDeviceInfo avoids issues with finding the + * exact instance being used. + */ +typedef struct VkLayerDeviceInfo_ { + void *device_info; + PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; +} VkLayerDeviceInfo; + +typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance, + void *object); +typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device, + void *object); +typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA); +typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction); + +typedef enum VkLoaderFeastureFlagBits { + VK_LOADER_FEATURE_PHYSICAL_DEVICE_SORTING = 0x00000001, +} VkLoaderFlagBits; +typedef VkFlags VkLoaderFeatureFlags; + +typedef struct { + VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO + const void *pNext; + VkLayerFunction function; + union { + VkLayerInstanceLink *pLayerInfo; + PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData; + struct { + PFN_vkLayerCreateDevice pfnLayerCreateDevice; + PFN_vkLayerDestroyDevice pfnLayerDestroyDevice; + } layerDevice; + VkLoaderFeatureFlags loaderFeatures; + } u; +} VkLayerInstanceCreateInfo; + +typedef struct VkLayerDeviceLink_ { + struct VkLayerDeviceLink_ *pNext; + PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr; +} VkLayerDeviceLink; + +typedef struct { + VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO + const void *pNext; + VkLayerFunction function; + union { + VkLayerDeviceLink *pLayerInfo; + PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData; + } u; +} VkLayerDeviceCreateInfo; + +#ifdef __cplusplus +extern "C" { +#endif + +VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct); + +typedef enum VkChainType { + VK_CHAIN_TYPE_UNKNOWN = 0, + VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1, + VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2, + VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3, +} VkChainType; + +typedef struct VkChainHeader { + VkChainType type; + uint32_t version; + uint32_t size; +} VkChainHeader; + +typedef struct VkEnumerateInstanceExtensionPropertiesChain { + VkChainHeader header; + VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *, + VkExtensionProperties *); + const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink; + +#if defined(__cplusplus) + inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const { + return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties); + } +#endif +} VkEnumerateInstanceExtensionPropertiesChain; + +typedef struct VkEnumerateInstanceLayerPropertiesChain { + VkChainHeader header; + VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *); + const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink; + +#if defined(__cplusplus) + inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const { + return pfnNextLayer(pNextLink, pPropertyCount, pProperties); + } +#endif +} VkEnumerateInstanceLayerPropertiesChain; + +typedef struct VkEnumerateInstanceVersionChain { + VkChainHeader header; + VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *); + const struct VkEnumerateInstanceVersionChain *pNextLink; + +#if defined(__cplusplus) + inline VkResult CallDown(uint32_t *pApiVersion) const { + return pfnNextLayer(pNextLink, pApiVersion); + } +#endif +} VkEnumerateInstanceVersionChain; + +#ifdef __cplusplus +} +#endif diff --git a/lib/vulkan-headers/include/vulkan/vk_platform.h b/lib/vulkan-headers/include/vulkan/vk_platform.h new file mode 100644 index 00000000000..e431c7631db --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vk_platform.h @@ -0,0 +1,84 @@ +// +// File: vk_platform.h +// +/* +** Copyright 2014-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + + +#ifndef VK_PLATFORM_H_ +#define VK_PLATFORM_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif // __cplusplus + +/* +*************************************************************************************************** +* Platform-specific directives and type declarations +*************************************************************************************************** +*/ + +/* Platform-specific calling convention macros. + * + * Platforms should define these so that Vulkan clients call Vulkan commands + * with the same calling conventions that the Vulkan implementation expects. + * + * VKAPI_ATTR - Placed before the return type in function declarations. + * Useful for C++11 and GCC/Clang-style function attribute syntax. + * VKAPI_CALL - Placed after the return type in function declarations. + * Useful for MSVC-style calling convention syntax. + * VKAPI_PTR - Placed between the '(' and '*' in function pointer types. + * + * Function declaration: VKAPI_ATTR void VKAPI_CALL vkCommand(void); + * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void); + */ +#if defined(_WIN32) + // On Windows, Vulkan commands use the stdcall convention + #define VKAPI_ATTR + #define VKAPI_CALL __stdcall + #define VKAPI_PTR VKAPI_CALL +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7 + #error "Vulkan is not supported for the 'armeabi' NDK ABI" +#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE) + // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat" + // calling convention, i.e. float parameters are passed in registers. This + // is true even if the rest of the application passes floats on the stack, + // as it does by default when compiling for the armeabi-v7a NDK ABI. + #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp"))) + #define VKAPI_CALL + #define VKAPI_PTR VKAPI_ATTR +#else + // On other platforms, use the default calling convention + #define VKAPI_ATTR + #define VKAPI_CALL + #define VKAPI_PTR +#endif + +#if !defined(VK_NO_STDDEF_H) + #include +#endif // !defined(VK_NO_STDDEF_H) + +#if !defined(VK_NO_STDINT_H) + #if defined(_MSC_VER) && (_MSC_VER < 1600) + typedef signed __int8 int8_t; + typedef unsigned __int8 uint8_t; + typedef signed __int16 int16_t; + typedef unsigned __int16 uint16_t; + typedef signed __int32 int32_t; + typedef unsigned __int32 uint32_t; + typedef signed __int64 int64_t; + typedef unsigned __int64 uint64_t; + #else + #include + #endif +#endif // !defined(VK_NO_STDINT_H) + +#ifdef __cplusplus +} // extern "C" +#endif // __cplusplus + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan.cppm b/lib/vulkan-headers/include/vulkan/vulkan.cppm new file mode 100644 index 00000000000..0daf44b5558 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan.cppm @@ -0,0 +1,10847 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +module; + +#define VULKAN_HPP_CXX_MODULE 1 + +#include + +#if !defined( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) +# define VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING \ + "\n\tThe Vulkan-Hpp C++ named module is experimental. It is subject to change without prior notice.\n" \ + "\tTo silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n" \ + "\tFor feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues" + +VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) +#endif + +#include +#include +#include +#include +#include +#include + +export module vulkan; +export import :video; +export import std; + +export namespace VULKAN_HPP_NAMESPACE +{ + //===================================== + //=== HARDCODED TYPEs AND FUNCTIONs === + //===================================== + using VULKAN_HPP_NAMESPACE::ArrayWrapper1D; + using VULKAN_HPP_NAMESPACE::ArrayWrapper2D; + using VULKAN_HPP_NAMESPACE::Flags; + using VULKAN_HPP_NAMESPACE::FlagTraits; + + namespace detail + { + using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase; + using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic; +#if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 + using VULKAN_HPP_NAMESPACE::detail::defaultDispatchLoaderDynamic; +#endif +#if !defined( VK_NO_PROTOTYPES ) + using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic; + using VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic; +#endif /*VK_NO_PROTOTYPES*/ + using VULKAN_HPP_NAMESPACE::detail::createResultValueType; + using VULKAN_HPP_NAMESPACE::detail::resultCheck; + } // namespace detail +#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + namespace VULKAN_HPP_RAII_NAMESPACE + { + using VULKAN_HPP_RAII_NAMESPACE::operator==; + using VULKAN_HPP_RAII_NAMESPACE::operator!=; +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + using VULKAN_HPP_RAII_NAMESPACE::operator<=>; +# else + using VULKAN_HPP_RAII_NAMESPACE::operator<; +# endif + } // namespace VULKAN_HPP_RAII_NAMESPACE +#endif + using VULKAN_HPP_NAMESPACE::operator&; + using VULKAN_HPP_NAMESPACE::operator|; + using VULKAN_HPP_NAMESPACE::operator^; + using VULKAN_HPP_NAMESPACE::operator~; + using VULKAN_HPP_NAMESPACE::operator<; + using VULKAN_HPP_NAMESPACE::operator<=; + 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; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) + namespace detail + { + using VULKAN_HPP_NAMESPACE::detail::ObjectDestroy; + using VULKAN_HPP_NAMESPACE::detail::ObjectDestroyShared; + using VULKAN_HPP_NAMESPACE::detail::ObjectFree; + using VULKAN_HPP_NAMESPACE::detail::ObjectFreeShared; + using VULKAN_HPP_NAMESPACE::detail::ObjectRelease; + using VULKAN_HPP_NAMESPACE::detail::ObjectReleaseShared; + using VULKAN_HPP_NAMESPACE::detail::PoolFree; + using VULKAN_HPP_NAMESPACE::detail::PoolFreeShared; + } // namespace detail + + using VULKAN_HPP_NAMESPACE::SharedHandle; + using VULKAN_HPP_NAMESPACE::UniqueHandle; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + + using VULKAN_HPP_NAMESPACE::exchange; + + //================== + //=== 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::DeviceQueueCreateFlagBits; + using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags; + 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::PipelineCacheCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion; + using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags; + using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags; + 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::CommandPoolTrimFlagsKHR; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlagBits; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlagsKHR; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType; + using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateTypeKHR; + using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags; + using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagsKHR; + using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags; + using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagsKHR; + using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags; + using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsKHR; + using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags; + using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsKHR; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagsKHR; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags; + using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagsKHR; + using VULKAN_HPP_NAMESPACE::FenceImportFlagBits; + using VULKAN_HPP_NAMESPACE::FenceImportFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::FenceImportFlags; + using VULKAN_HPP_NAMESPACE::FenceImportFlagsKHR; + using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagBits; + using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::MemoryAllocateFlags; + using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsKHR; + using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagBits; + using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags; + using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagsKHR; + 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::SemaphoreImportFlagsKHR; + 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::DescriptorBindingFlagsEXT; + 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::ResolveModeFlagsKHR; + 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::SemaphoreWaitFlagsKHR; + 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::AccessFlags2KHR; + using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits2; + using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits2KHR; + using VULKAN_HPP_NAMESPACE::FormatFeatureFlags2; + using VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR; + using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagBits; + using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlags; + using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT; + using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits2; + using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits2KHR; + using VULKAN_HPP_NAMESPACE::PipelineStageFlags2; + using VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR; + using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagBits; + using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlags; + using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagsEXT; + using VULKAN_HPP_NAMESPACE::RenderingFlagBits; + using VULKAN_HPP_NAMESPACE::RenderingFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::RenderingFlags; + using VULKAN_HPP_NAMESPACE::RenderingFlagsKHR; + using VULKAN_HPP_NAMESPACE::SubmitFlagBits; + using VULKAN_HPP_NAMESPACE::SubmitFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::SubmitFlags; + using VULKAN_HPP_NAMESPACE::SubmitFlagsKHR; + using VULKAN_HPP_NAMESPACE::ToolPurposeFlagBits; + using VULKAN_HPP_NAMESPACE::ToolPurposeFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::ToolPurposeFlags; + using VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT; + + //=== VK_VERSION_1_4 === + using VULKAN_HPP_NAMESPACE::BufferUsageFlagBits2; + using VULKAN_HPP_NAMESPACE::BufferUsageFlagBits2KHR; + using VULKAN_HPP_NAMESPACE::BufferUsageFlags2; + using VULKAN_HPP_NAMESPACE::BufferUsageFlags2KHR; + using VULKAN_HPP_NAMESPACE::HostImageCopyFlagBits; + using VULKAN_HPP_NAMESPACE::HostImageCopyFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::HostImageCopyFlags; + using VULKAN_HPP_NAMESPACE::HostImageCopyFlagsEXT; + using VULKAN_HPP_NAMESPACE::LineRasterizationMode; + using VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT; + using VULKAN_HPP_NAMESPACE::LineRasterizationModeKHR; + using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagBits; + using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::MemoryUnmapFlags; + using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagsKHR; + using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits2; + using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits2KHR; + using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2; + using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2KHR; + using VULKAN_HPP_NAMESPACE::PipelineRobustnessBufferBehavior; + using VULKAN_HPP_NAMESPACE::PipelineRobustnessBufferBehaviorEXT; + using VULKAN_HPP_NAMESPACE::PipelineRobustnessImageBehavior; + using VULKAN_HPP_NAMESPACE::PipelineRobustnessImageBehaviorEXT; + using VULKAN_HPP_NAMESPACE::QueueGlobalPriority; + using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT; + using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityKHR; + + //=== 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; + + //=== VK_KHR_video_encode_h264 === + using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagsKHR; + + //=== VK_KHR_video_encode_h265 === + using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsKHR; + + //=== 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_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_descriptor_heap === + using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceEXT; + using VULKAN_HPP_NAMESPACE::SpirvResourceTypeFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::SpirvResourceTypeFlagsEXT; + using VULKAN_HPP_NAMESPACE::TensorViewCreateFlagBitsARM; + using VULKAN_HPP_NAMESPACE::TensorViewCreateFlagsARM; + + //=== 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::BuildAccelerationStructureFlagsNV; + 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::GeometryFlagsNV; + using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagBitsNV; + using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagsKHR; + using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagsNV; + 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_AMD_memory_overallocation_behavior === + using VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD; + + //=== VK_EXT_present_timing === + using VULKAN_HPP_NAMESPACE::PastPresentationTimingFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PastPresentationTimingFlagsEXT; + using VULKAN_HPP_NAMESPACE::PresentStageFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PresentStageFlagsEXT; + using VULKAN_HPP_NAMESPACE::PresentTimingInfoFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PresentTimingInfoFlagsEXT; + + //=== 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_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_KHR_pipeline_executable_properties === + using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR; + + //=== 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_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; + + //=== VK_NV_device_diagnostics_config === + using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagBitsNV; + using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV; + + //=== VK_QCOM_tile_shading === + using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagBitsQCOM; + using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagsQCOM; + +#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; + + //=== 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*/ + + //=== VK_EXT_frame_boundary === + using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT; + +#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_VALVE_video_encode_rgb_conversion === + using VULKAN_HPP_NAMESPACE::VideoEncodeRgbChromaOffsetFlagBitsVALVE; + using VULKAN_HPP_NAMESPACE::VideoEncodeRgbChromaOffsetFlagsVALVE; + using VULKAN_HPP_NAMESPACE::VideoEncodeRgbModelConversionFlagBitsVALVE; + using VULKAN_HPP_NAMESPACE::VideoEncodeRgbModelConversionFlagsVALVE; + using VULKAN_HPP_NAMESPACE::VideoEncodeRgbRangeCompressionFlagBitsVALVE; + using VULKAN_HPP_NAMESPACE::VideoEncodeRgbRangeCompressionFlagsVALVE; + + //=== 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_ARM_scheduling_controls === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFlagBitsARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFlagsARM; + + //=== VK_NV_ray_tracing_linear_swept_spheres === + using VULKAN_HPP_NAMESPACE::RayTracingLssIndexingModeNV; + using VULKAN_HPP_NAMESPACE::RayTracingLssPrimitiveEndCapsModeNV; + + //=== 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_ARM_tensors === + using VULKAN_HPP_NAMESPACE::TensorCreateFlagBitsARM; + using VULKAN_HPP_NAMESPACE::TensorCreateFlagsARM; + using VULKAN_HPP_NAMESPACE::TensorTilingARM; + using VULKAN_HPP_NAMESPACE::TensorUsageFlagBitsARM; + using VULKAN_HPP_NAMESPACE::TensorUsageFlagsARM; + + //=== 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_AMD_anti_lag === + using VULKAN_HPP_NAMESPACE::AntiLagModeAMD; + using VULKAN_HPP_NAMESPACE::AntiLagStageAMD; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_dense_geometry_format === + using VULKAN_HPP_NAMESPACE::CompressedTriangleFormatAMDX; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_shader_object === + using VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT; + using VULKAN_HPP_NAMESPACE::ShaderCreateFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::ShaderCreateFlagsEXT; + + //=== VK_KHR_surface_maintenance1 === + using VULKAN_HPP_NAMESPACE::PresentGravityFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PresentGravityFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::PresentGravityFlagsEXT; + using VULKAN_HPP_NAMESPACE::PresentGravityFlagsKHR; + using VULKAN_HPP_NAMESPACE::PresentScalingFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::PresentScalingFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::PresentScalingFlagsEXT; + using VULKAN_HPP_NAMESPACE::PresentScalingFlagsKHR; + + //=== VK_NV_cooperative_vector === + using VULKAN_HPP_NAMESPACE::ComponentTypeKHR; + using VULKAN_HPP_NAMESPACE::ComponentTypeNV; + using VULKAN_HPP_NAMESPACE::CooperativeVectorMatrixLayoutNV; + + //=== VK_EXT_layer_settings === + using VULKAN_HPP_NAMESPACE::LayerSettingTypeEXT; + + //=== VK_NV_low_latency2 === + using VULKAN_HPP_NAMESPACE::LatencyMarkerNV; + using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV; + + //=== VK_KHR_cooperative_matrix === + using VULKAN_HPP_NAMESPACE::ScopeKHR; + using VULKAN_HPP_NAMESPACE::ScopeNV; + + //=== VK_ARM_data_graph === + using VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchFlagBitsARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchFlagsARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointTypeARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateFlagBitsARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateFlagsARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationTypeARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineTypeARM; + + //=== VK_KHR_video_encode_av1 === + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilityFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilityFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1PredictionModeKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlGroupKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1StdFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1StdFlagsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SuperblockSizeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SuperblockSizeFlagsKHR; + + //=== VK_QCOM_image_processing2 === + using VULKAN_HPP_NAMESPACE::BlockMatchWindowCompareModeQCOM; + + //=== VK_QCOM_filter_cubic_weights === + using VULKAN_HPP_NAMESPACE::CubicFilterWeightsQCOM; + + //=== VK_MSFT_layered_driver === + using VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT; + + //=== VK_KHR_calibrated_timestamps === + using VULKAN_HPP_NAMESPACE::TimeDomainEXT; + using VULKAN_HPP_NAMESPACE::TimeDomainKHR; + + //=== VK_KHR_copy_memory_indirect === + using VULKAN_HPP_NAMESPACE::AddressCopyFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::AddressCopyFlagsKHR; + + //=== VK_EXT_memory_decompression === + using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagBitsNV; + using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagsEXT; + using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagsNV; + + //=== VK_NV_display_stereo === + using VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoTypeNV; + + //=== VK_KHR_video_encode_intra_refresh === + using VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshModeFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshModeFlagsKHR; + + //=== VK_KHR_maintenance7 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiKHR; + + //=== VK_NV_cluster_acceleration_structure === + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureAddressResolutionFlagBitsNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureAddressResolutionFlagsNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClusterFlagBitsNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClusterFlagsNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryFlagBitsNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryFlagsNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureIndexFormatFlagBitsNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureIndexFormatFlagsNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpModeNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpTypeNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTypeNV; + + //=== VK_NV_partitioned_acceleration_structure === + using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstanceFlagBitsNV; + using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstanceFlagsNV; + using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureOpTypeNV; + + //=== VK_EXT_device_generated_commands === + using VULKAN_HPP_NAMESPACE::IndirectCommandsInputModeFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsInputModeFlagsEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagBitsEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeEXT; + using VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoTypeEXT; + + //=== VK_KHR_maintenance8 === + using VULKAN_HPP_NAMESPACE::AccessFlagBits3KHR; + using VULKAN_HPP_NAMESPACE::AccessFlags3KHR; + + //=== VK_EXT_ray_tracing_invocation_reorder === + using VULKAN_HPP_NAMESPACE::RayTracingInvocationReorderModeEXT; + using VULKAN_HPP_NAMESPACE::RayTracingInvocationReorderModeNV; + + //=== VK_EXT_depth_clamp_control === + using VULKAN_HPP_NAMESPACE::DepthClampModeEXT; + + //=== VK_KHR_maintenance9 === + using VULKAN_HPP_NAMESPACE::DefaultVertexAttributeValueKHR; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + using VULKAN_HPP_NAMESPACE::SurfaceCreateFlagBitsOHOS; + using VULKAN_HPP_NAMESPACE::SurfaceCreateFlagsOHOS; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_ARM_performance_counters_by_region === + using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagBitsARM; + using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsARM; + + //=== VK_QCOM_data_graph_model === + using VULKAN_HPP_NAMESPACE::DataGraphModelCacheTypeQCOM; + + //=== VK_KHR_maintenance10 === + using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsKHR; + using VULKAN_HPP_NAMESPACE::ResolveImageFlagBitsKHR; + using VULKAN_HPP_NAMESPACE::ResolveImageFlagsKHR; + + //========================= + //=== 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::NotPermittedError; + using VULKAN_HPP_NAMESPACE::OutOfDateKHRError; + using VULKAN_HPP_NAMESPACE::OutOfDeviceMemoryError; + using VULKAN_HPP_NAMESPACE::OutOfHostMemoryError; + using VULKAN_HPP_NAMESPACE::OutOfPoolMemoryError; + using VULKAN_HPP_NAMESPACE::PresentTimingQueueFullEXTError; + using VULKAN_HPP_NAMESPACE::SurfaceLostKHRError; + using VULKAN_HPP_NAMESPACE::SystemError; + using VULKAN_HPP_NAMESPACE::TooManyObjectsError; + using VULKAN_HPP_NAMESPACE::UnknownError; + using VULKAN_HPP_NAMESPACE::ValidationFailedError; + 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*/ + + using VULKAN_HPP_NAMESPACE::CompressionExhaustedEXTError; + using VULKAN_HPP_NAMESPACE::InvalidVideoStdParametersKHRError; + using VULKAN_HPP_NAMESPACE::NotEnoughSpaceKHRError; +#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + using VULKAN_HPP_NAMESPACE::ResultValue; + using VULKAN_HPP_NAMESPACE::ResultValueType; + + //=========================== + //=== CONSTEXPR CONSTANTs === + //=========================== + + //=== VK_VERSION_1_0 === + using VULKAN_HPP_NAMESPACE::AttachmentUnused; + using VULKAN_HPP_NAMESPACE::False; + using VULKAN_HPP_NAMESPACE::LodClampNone; + using VULKAN_HPP_NAMESPACE::MaxDescriptionSize; + using VULKAN_HPP_NAMESPACE::MaxExtensionNameSize; + using VULKAN_HPP_NAMESPACE::MaxMemoryHeaps; + using VULKAN_HPP_NAMESPACE::MaxMemoryTypes; + using VULKAN_HPP_NAMESPACE::MaxPhysicalDeviceNameSize; + using VULKAN_HPP_NAMESPACE::QueueFamilyIgnored; + using VULKAN_HPP_NAMESPACE::RemainingArrayLayers; + using VULKAN_HPP_NAMESPACE::RemainingMipLevels; + using VULKAN_HPP_NAMESPACE::SubpassExternal; + using VULKAN_HPP_NAMESPACE::True; + using VULKAN_HPP_NAMESPACE::UuidSize; + using VULKAN_HPP_NAMESPACE::WholeSize; + + //=== VK_VERSION_1_1 === + using VULKAN_HPP_NAMESPACE::LuidSize; + using VULKAN_HPP_NAMESPACE::MaxDeviceGroupSize; + using VULKAN_HPP_NAMESPACE::QueueFamilyExternal; + + //=== VK_VERSION_1_2 === + using VULKAN_HPP_NAMESPACE::MaxDriverInfoSize; + using VULKAN_HPP_NAMESPACE::MaxDriverNameSize; + + //=== VK_VERSION_1_4 === + using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySize; + + //=== VK_KHR_surface === + using VULKAN_HPP_NAMESPACE::KHRSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSurfaceSpecVersion; + + //=== VK_KHR_swapchain === + using VULKAN_HPP_NAMESPACE::KHRSwapchainExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSwapchainSpecVersion; + + //=== VK_KHR_display === + using VULKAN_HPP_NAMESPACE::KHRDisplayExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDisplaySpecVersion; + + //=== VK_KHR_display_swapchain === + using VULKAN_HPP_NAMESPACE::KHRDisplaySwapchainExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDisplaySwapchainSpecVersion; + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + using VULKAN_HPP_NAMESPACE::KHRXlibSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::KHRXlibSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + using VULKAN_HPP_NAMESPACE::KHRXcbSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::KHRXcbSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + using VULKAN_HPP_NAMESPACE::KHRWaylandSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::KHRWaylandSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + using VULKAN_HPP_NAMESPACE::KHRAndroidSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::KHRAndroidSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + using VULKAN_HPP_NAMESPACE::KHRWin32SurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::KHRWin32SurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + using VULKAN_HPP_NAMESPACE::EXTDebugReportExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDebugReportSpecVersion; + + //=== VK_NV_glsl_shader === + using VULKAN_HPP_NAMESPACE::NVGlslShaderExtensionName; + using VULKAN_HPP_NAMESPACE::NVGlslShaderSpecVersion; + + //=== VK_EXT_depth_range_unrestricted === + using VULKAN_HPP_NAMESPACE::EXTDepthRangeUnrestrictedExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDepthRangeUnrestrictedSpecVersion; + + //=== VK_KHR_sampler_mirror_clamp_to_edge === + using VULKAN_HPP_NAMESPACE::KHRSamplerMirrorClampToEdgeExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSamplerMirrorClampToEdgeSpecVersion; + + //=== VK_IMG_filter_cubic === + using VULKAN_HPP_NAMESPACE::IMGFilterCubicExtensionName; + using VULKAN_HPP_NAMESPACE::IMGFilterCubicSpecVersion; + + //=== VK_AMD_rasterization_order === + using VULKAN_HPP_NAMESPACE::AMDRasterizationOrderExtensionName; + using VULKAN_HPP_NAMESPACE::AMDRasterizationOrderSpecVersion; + + //=== VK_AMD_shader_trinary_minmax === + using VULKAN_HPP_NAMESPACE::AMDShaderTrinaryMinmaxExtensionName; + using VULKAN_HPP_NAMESPACE::AMDShaderTrinaryMinmaxSpecVersion; + + //=== VK_AMD_shader_explicit_vertex_parameter === + using VULKAN_HPP_NAMESPACE::AMDShaderExplicitVertexParameterExtensionName; + using VULKAN_HPP_NAMESPACE::AMDShaderExplicitVertexParameterSpecVersion; + + //=== VK_EXT_debug_marker === + using VULKAN_HPP_NAMESPACE::EXTDebugMarkerExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDebugMarkerSpecVersion; + + //=== VK_KHR_video_queue === + using VULKAN_HPP_NAMESPACE::KHRVideoQueueExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoQueueSpecVersion; + + //=== VK_KHR_video_decode_queue === + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeQueueExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeQueueSpecVersion; + + //=== VK_AMD_gcn_shader === + using VULKAN_HPP_NAMESPACE::AMDGcnShaderExtensionName; + using VULKAN_HPP_NAMESPACE::AMDGcnShaderSpecVersion; + + //=== VK_NV_dedicated_allocation === + using VULKAN_HPP_NAMESPACE::NVDedicatedAllocationExtensionName; + using VULKAN_HPP_NAMESPACE::NVDedicatedAllocationSpecVersion; + + //=== VK_EXT_transform_feedback === + using VULKAN_HPP_NAMESPACE::EXTTransformFeedbackExtensionName; + using VULKAN_HPP_NAMESPACE::EXTTransformFeedbackSpecVersion; + + //=== VK_NVX_binary_import === + using VULKAN_HPP_NAMESPACE::NVXBinaryImportExtensionName; + using VULKAN_HPP_NAMESPACE::NVXBinaryImportSpecVersion; + + //=== VK_NVX_image_view_handle === + using VULKAN_HPP_NAMESPACE::NVXImageViewHandleExtensionName; + using VULKAN_HPP_NAMESPACE::NVXImageViewHandleSpecVersion; + + //=== VK_AMD_draw_indirect_count === + using VULKAN_HPP_NAMESPACE::AMDDrawIndirectCountExtensionName; + using VULKAN_HPP_NAMESPACE::AMDDrawIndirectCountSpecVersion; + + //=== VK_AMD_negative_viewport_height === + using VULKAN_HPP_NAMESPACE::AMDNegativeViewportHeightExtensionName; + using VULKAN_HPP_NAMESPACE::AMDNegativeViewportHeightSpecVersion; + + //=== VK_AMD_gpu_shader_half_float === + using VULKAN_HPP_NAMESPACE::AMDGpuShaderHalfFloatExtensionName; + using VULKAN_HPP_NAMESPACE::AMDGpuShaderHalfFloatSpecVersion; + + //=== VK_AMD_shader_ballot === + using VULKAN_HPP_NAMESPACE::AMDShaderBallotExtensionName; + using VULKAN_HPP_NAMESPACE::AMDShaderBallotSpecVersion; + + //=== VK_KHR_video_encode_h264 === + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeH264ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeH264SpecVersion; + + //=== VK_KHR_video_encode_h265 === + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeH265ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeH265SpecVersion; + + //=== VK_KHR_video_decode_h264 === + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeH264ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeH264SpecVersion; + + //=== VK_AMD_texture_gather_bias_lod === + using VULKAN_HPP_NAMESPACE::AMDTextureGatherBiasLodExtensionName; + using VULKAN_HPP_NAMESPACE::AMDTextureGatherBiasLodSpecVersion; + + //=== VK_AMD_shader_info === + using VULKAN_HPP_NAMESPACE::AMDShaderInfoExtensionName; + using VULKAN_HPP_NAMESPACE::AMDShaderInfoSpecVersion; + + //=== VK_KHR_dynamic_rendering === + using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingSpecVersion; + + //=== VK_AMD_shader_image_load_store_lod === + using VULKAN_HPP_NAMESPACE::AMDShaderImageLoadStoreLodExtensionName; + using VULKAN_HPP_NAMESPACE::AMDShaderImageLoadStoreLodSpecVersion; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + using VULKAN_HPP_NAMESPACE::GGPStreamDescriptorSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::GGPStreamDescriptorSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_corner_sampled_image === + using VULKAN_HPP_NAMESPACE::NVCornerSampledImageExtensionName; + using VULKAN_HPP_NAMESPACE::NVCornerSampledImageSpecVersion; + + //=== VK_KHR_multiview === + using VULKAN_HPP_NAMESPACE::KHRMultiviewExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMultiviewSpecVersion; + + //=== VK_IMG_format_pvrtc === + using VULKAN_HPP_NAMESPACE::IMGFormatPvrtcExtensionName; + using VULKAN_HPP_NAMESPACE::IMGFormatPvrtcSpecVersion; + + //=== VK_NV_external_memory_capabilities === + using VULKAN_HPP_NAMESPACE::NVExternalMemoryCapabilitiesExtensionName; + using VULKAN_HPP_NAMESPACE::NVExternalMemoryCapabilitiesSpecVersion; + + //=== VK_NV_external_memory === + using VULKAN_HPP_NAMESPACE::NVExternalMemoryExtensionName; + using VULKAN_HPP_NAMESPACE::NVExternalMemorySpecVersion; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + using VULKAN_HPP_NAMESPACE::NVExternalMemoryWin32ExtensionName; + using VULKAN_HPP_NAMESPACE::NVExternalMemoryWin32SpecVersion; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_win32_keyed_mutex === + using VULKAN_HPP_NAMESPACE::NVWin32KeyedMutexExtensionName; + using VULKAN_HPP_NAMESPACE::NVWin32KeyedMutexSpecVersion; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_get_physical_device_properties2 === + using VULKAN_HPP_NAMESPACE::KHRGetPhysicalDeviceProperties2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRGetPhysicalDeviceProperties2SpecVersion; + + //=== VK_KHR_device_group === + using VULKAN_HPP_NAMESPACE::KHRDeviceGroupExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDeviceGroupSpecVersion; + + //=== VK_EXT_validation_flags === + using VULKAN_HPP_NAMESPACE::EXTValidationFlagsExtensionName; + using VULKAN_HPP_NAMESPACE::EXTValidationFlagsSpecVersion; + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + using VULKAN_HPP_NAMESPACE::NNViSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::NNViSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_shader_draw_parameters === + using VULKAN_HPP_NAMESPACE::KHRShaderDrawParametersExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderDrawParametersSpecVersion; + + //=== VK_EXT_shader_subgroup_ballot === + using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupBallotExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupBallotSpecVersion; + + //=== VK_EXT_shader_subgroup_vote === + using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupVoteExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupVoteSpecVersion; + + //=== VK_EXT_texture_compression_astc_hdr === + using VULKAN_HPP_NAMESPACE::EXTTextureCompressionAstcHdrExtensionName; + using VULKAN_HPP_NAMESPACE::EXTTextureCompressionAstcHdrSpecVersion; + + //=== VK_EXT_astc_decode_mode === + using VULKAN_HPP_NAMESPACE::EXTAstcDecodeModeExtensionName; + using VULKAN_HPP_NAMESPACE::EXTAstcDecodeModeSpecVersion; + + //=== VK_EXT_pipeline_robustness === + using VULKAN_HPP_NAMESPACE::EXTPipelineRobustnessExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPipelineRobustnessSpecVersion; + + //=== VK_KHR_maintenance1 === + using VULKAN_HPP_NAMESPACE::KHRMaintenance1ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMaintenance1SpecVersion; + + //=== VK_KHR_device_group_creation === + using VULKAN_HPP_NAMESPACE::KHRDeviceGroupCreationExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDeviceGroupCreationSpecVersion; + using VULKAN_HPP_NAMESPACE::MaxDeviceGroupSizeKHR; + + //=== VK_KHR_external_memory_capabilities === + using VULKAN_HPP_NAMESPACE::KHRExternalMemoryCapabilitiesExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalMemoryCapabilitiesSpecVersion; + using VULKAN_HPP_NAMESPACE::LuidSizeKHR; + + //=== VK_KHR_external_memory === + using VULKAN_HPP_NAMESPACE::KHRExternalMemoryExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalMemorySpecVersion; + using VULKAN_HPP_NAMESPACE::QueueFamilyExternalKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + using VULKAN_HPP_NAMESPACE::KHRExternalMemoryWin32ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalMemoryWin32SpecVersion; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + using VULKAN_HPP_NAMESPACE::KHRExternalMemoryFdExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalMemoryFdSpecVersion; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_keyed_mutex === + using VULKAN_HPP_NAMESPACE::KHRWin32KeyedMutexExtensionName; + using VULKAN_HPP_NAMESPACE::KHRWin32KeyedMutexSpecVersion; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_capabilities === + using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreCapabilitiesExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreCapabilitiesSpecVersion; + + //=== VK_KHR_external_semaphore === + using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreSpecVersion; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreWin32ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreWin32SpecVersion; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreFdExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreFdSpecVersion; + + //=== VK_KHR_push_descriptor === + using VULKAN_HPP_NAMESPACE::KHRPushDescriptorExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPushDescriptorSpecVersion; + + //=== VK_EXT_conditional_rendering === + using VULKAN_HPP_NAMESPACE::EXTConditionalRenderingExtensionName; + using VULKAN_HPP_NAMESPACE::EXTConditionalRenderingSpecVersion; + + //=== VK_KHR_shader_float16_int8 === + using VULKAN_HPP_NAMESPACE::KHRShaderFloat16Int8ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderFloat16Int8SpecVersion; + + //=== VK_KHR_16bit_storage === + using VULKAN_HPP_NAMESPACE::KHR16BitStorageExtensionName; + using VULKAN_HPP_NAMESPACE::KHR16BitStorageSpecVersion; + + //=== VK_KHR_incremental_present === + using VULKAN_HPP_NAMESPACE::KHRIncrementalPresentExtensionName; + using VULKAN_HPP_NAMESPACE::KHRIncrementalPresentSpecVersion; + + //=== VK_KHR_descriptor_update_template === + using VULKAN_HPP_NAMESPACE::KHRDescriptorUpdateTemplateExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDescriptorUpdateTemplateSpecVersion; + + //=== VK_NV_clip_space_w_scaling === + using VULKAN_HPP_NAMESPACE::NVClipSpaceWScalingExtensionName; + using VULKAN_HPP_NAMESPACE::NVClipSpaceWScalingSpecVersion; + + //=== VK_EXT_direct_mode_display === + using VULKAN_HPP_NAMESPACE::EXTDirectModeDisplayExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDirectModeDisplaySpecVersion; + +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + using VULKAN_HPP_NAMESPACE::EXTAcquireXlibDisplayExtensionName; + using VULKAN_HPP_NAMESPACE::EXTAcquireXlibDisplaySpecVersion; +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + using VULKAN_HPP_NAMESPACE::EXTDisplaySurfaceCounterExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDisplaySurfaceCounterSpecVersion; + + //=== VK_EXT_display_control === + using VULKAN_HPP_NAMESPACE::EXTDisplayControlExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDisplayControlSpecVersion; + + //=== VK_GOOGLE_display_timing === + using VULKAN_HPP_NAMESPACE::GOOGLEDisplayTimingExtensionName; + using VULKAN_HPP_NAMESPACE::GOOGLEDisplayTimingSpecVersion; + + //=== VK_NV_sample_mask_override_coverage === + using VULKAN_HPP_NAMESPACE::NVSampleMaskOverrideCoverageExtensionName; + using VULKAN_HPP_NAMESPACE::NVSampleMaskOverrideCoverageSpecVersion; + + //=== VK_NV_geometry_shader_passthrough === + using VULKAN_HPP_NAMESPACE::NVGeometryShaderPassthroughExtensionName; + using VULKAN_HPP_NAMESPACE::NVGeometryShaderPassthroughSpecVersion; + + //=== VK_NV_viewport_array2 === + using VULKAN_HPP_NAMESPACE::NVViewportArray2ExtensionName; + using VULKAN_HPP_NAMESPACE::NVViewportArray2SpecVersion; + + //=== VK_NVX_multiview_per_view_attributes === + using VULKAN_HPP_NAMESPACE::NVXMultiviewPerViewAttributesExtensionName; + using VULKAN_HPP_NAMESPACE::NVXMultiviewPerViewAttributesSpecVersion; + + //=== VK_NV_viewport_swizzle === + using VULKAN_HPP_NAMESPACE::NVViewportSwizzleExtensionName; + using VULKAN_HPP_NAMESPACE::NVViewportSwizzleSpecVersion; + + //=== VK_EXT_discard_rectangles === + using VULKAN_HPP_NAMESPACE::EXTDiscardRectanglesExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDiscardRectanglesSpecVersion; + + //=== VK_EXT_conservative_rasterization === + using VULKAN_HPP_NAMESPACE::EXTConservativeRasterizationExtensionName; + using VULKAN_HPP_NAMESPACE::EXTConservativeRasterizationSpecVersion; + + //=== VK_EXT_depth_clip_enable === + using VULKAN_HPP_NAMESPACE::EXTDepthClipEnableExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDepthClipEnableSpecVersion; + + //=== VK_EXT_swapchain_colorspace === + using VULKAN_HPP_NAMESPACE::EXTSwapchainColorSpaceExtensionName; + using VULKAN_HPP_NAMESPACE::EXTSwapchainColorSpaceSpecVersion; + + //=== VK_EXT_hdr_metadata === + using VULKAN_HPP_NAMESPACE::EXTHdrMetadataExtensionName; + using VULKAN_HPP_NAMESPACE::EXTHdrMetadataSpecVersion; + + //=== VK_KHR_imageless_framebuffer === + using VULKAN_HPP_NAMESPACE::KHRImagelessFramebufferExtensionName; + using VULKAN_HPP_NAMESPACE::KHRImagelessFramebufferSpecVersion; + + //=== VK_KHR_create_renderpass2 === + using VULKAN_HPP_NAMESPACE::KHRCreateRenderpass2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRCreateRenderpass2SpecVersion; + + //=== VK_IMG_relaxed_line_rasterization === + using VULKAN_HPP_NAMESPACE::IMGRelaxedLineRasterizationExtensionName; + using VULKAN_HPP_NAMESPACE::IMGRelaxedLineRasterizationSpecVersion; + + //=== VK_KHR_shared_presentable_image === + using VULKAN_HPP_NAMESPACE::KHRSharedPresentableImageExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSharedPresentableImageSpecVersion; + + //=== VK_KHR_external_fence_capabilities === + using VULKAN_HPP_NAMESPACE::KHRExternalFenceCapabilitiesExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalFenceCapabilitiesSpecVersion; + + //=== VK_KHR_external_fence === + using VULKAN_HPP_NAMESPACE::KHRExternalFenceExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalFenceSpecVersion; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + using VULKAN_HPP_NAMESPACE::KHRExternalFenceWin32ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalFenceWin32SpecVersion; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + using VULKAN_HPP_NAMESPACE::KHRExternalFenceFdExtensionName; + using VULKAN_HPP_NAMESPACE::KHRExternalFenceFdSpecVersion; + + //=== VK_KHR_performance_query === + using VULKAN_HPP_NAMESPACE::KHRPerformanceQueryExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPerformanceQuerySpecVersion; + + //=== VK_KHR_maintenance2 === + using VULKAN_HPP_NAMESPACE::KHRMaintenance2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMaintenance2SpecVersion; + + //=== VK_KHR_get_surface_capabilities2 === + using VULKAN_HPP_NAMESPACE::KHRGetSurfaceCapabilities2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRGetSurfaceCapabilities2SpecVersion; + + //=== VK_KHR_variable_pointers === + using VULKAN_HPP_NAMESPACE::KHRVariablePointersExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVariablePointersSpecVersion; + + //=== VK_KHR_get_display_properties2 === + using VULKAN_HPP_NAMESPACE::KHRGetDisplayProperties2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRGetDisplayProperties2SpecVersion; + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + using VULKAN_HPP_NAMESPACE::MVKIosSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::MVKIosSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + using VULKAN_HPP_NAMESPACE::MVKMacosSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::MVKMacosSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_external_memory_dma_buf === + using VULKAN_HPP_NAMESPACE::EXTExternalMemoryDmaBufExtensionName; + using VULKAN_HPP_NAMESPACE::EXTExternalMemoryDmaBufSpecVersion; + + //=== VK_EXT_queue_family_foreign === + using VULKAN_HPP_NAMESPACE::EXTQueueFamilyForeignExtensionName; + using VULKAN_HPP_NAMESPACE::EXTQueueFamilyForeignSpecVersion; + using VULKAN_HPP_NAMESPACE::QueueFamilyForeignEXT; + + //=== VK_KHR_dedicated_allocation === + using VULKAN_HPP_NAMESPACE::KHRDedicatedAllocationExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDedicatedAllocationSpecVersion; + + //=== VK_EXT_debug_utils === + using VULKAN_HPP_NAMESPACE::EXTDebugUtilsExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDebugUtilsSpecVersion; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + using VULKAN_HPP_NAMESPACE::ANDROIDExternalMemoryAndroidHardwareBufferExtensionName; + using VULKAN_HPP_NAMESPACE::ANDROIDExternalMemoryAndroidHardwareBufferSpecVersion; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + //=== VK_EXT_sampler_filter_minmax === + using VULKAN_HPP_NAMESPACE::EXTSamplerFilterMinmaxExtensionName; + using VULKAN_HPP_NAMESPACE::EXTSamplerFilterMinmaxSpecVersion; + + //=== VK_KHR_storage_buffer_storage_class === + using VULKAN_HPP_NAMESPACE::KHRStorageBufferStorageClassExtensionName; + using VULKAN_HPP_NAMESPACE::KHRStorageBufferStorageClassSpecVersion; + + //=== VK_AMD_gpu_shader_int16 === + using VULKAN_HPP_NAMESPACE::AMDGpuShaderInt16ExtensionName; + using VULKAN_HPP_NAMESPACE::AMDGpuShaderInt16SpecVersion; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + using VULKAN_HPP_NAMESPACE::AMDXShaderEnqueueExtensionName; + using VULKAN_HPP_NAMESPACE::AMDXShaderEnqueueSpecVersion; + using VULKAN_HPP_NAMESPACE::ShaderIndexUnusedAMDX; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + using VULKAN_HPP_NAMESPACE::EXTDescriptorHeapExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDescriptorHeapSpecVersion; + + //=== VK_AMD_mixed_attachment_samples === + using VULKAN_HPP_NAMESPACE::AMDMixedAttachmentSamplesExtensionName; + using VULKAN_HPP_NAMESPACE::AMDMixedAttachmentSamplesSpecVersion; + + //=== VK_AMD_shader_fragment_mask === + using VULKAN_HPP_NAMESPACE::AMDShaderFragmentMaskExtensionName; + using VULKAN_HPP_NAMESPACE::AMDShaderFragmentMaskSpecVersion; + + //=== VK_EXT_inline_uniform_block === + using VULKAN_HPP_NAMESPACE::EXTInlineUniformBlockExtensionName; + using VULKAN_HPP_NAMESPACE::EXTInlineUniformBlockSpecVersion; + + //=== VK_EXT_shader_stencil_export === + using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportSpecVersion; + + //=== VK_KHR_shader_bfloat16 === + using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16SpecVersion; + + //=== VK_EXT_sample_locations === + using VULKAN_HPP_NAMESPACE::EXTSampleLocationsExtensionName; + using VULKAN_HPP_NAMESPACE::EXTSampleLocationsSpecVersion; + + //=== VK_KHR_relaxed_block_layout === + using VULKAN_HPP_NAMESPACE::KHRRelaxedBlockLayoutExtensionName; + using VULKAN_HPP_NAMESPACE::KHRRelaxedBlockLayoutSpecVersion; + + //=== VK_KHR_get_memory_requirements2 === + using VULKAN_HPP_NAMESPACE::KHRGetMemoryRequirements2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRGetMemoryRequirements2SpecVersion; + + //=== VK_KHR_image_format_list === + using VULKAN_HPP_NAMESPACE::KHRImageFormatListExtensionName; + using VULKAN_HPP_NAMESPACE::KHRImageFormatListSpecVersion; + + //=== VK_EXT_blend_operation_advanced === + using VULKAN_HPP_NAMESPACE::EXTBlendOperationAdvancedExtensionName; + using VULKAN_HPP_NAMESPACE::EXTBlendOperationAdvancedSpecVersion; + + //=== VK_NV_fragment_coverage_to_color === + using VULKAN_HPP_NAMESPACE::NVFragmentCoverageToColorExtensionName; + using VULKAN_HPP_NAMESPACE::NVFragmentCoverageToColorSpecVersion; + + //=== VK_KHR_acceleration_structure === + using VULKAN_HPP_NAMESPACE::KHRAccelerationStructureExtensionName; + using VULKAN_HPP_NAMESPACE::KHRAccelerationStructureSpecVersion; + + //=== VK_KHR_ray_tracing_pipeline === + using VULKAN_HPP_NAMESPACE::KHRRayTracingPipelineExtensionName; + using VULKAN_HPP_NAMESPACE::KHRRayTracingPipelineSpecVersion; + using VULKAN_HPP_NAMESPACE::ShaderUnusedKHR; + + //=== VK_KHR_ray_query === + using VULKAN_HPP_NAMESPACE::KHRRayQueryExtensionName; + using VULKAN_HPP_NAMESPACE::KHRRayQuerySpecVersion; + + //=== VK_NV_framebuffer_mixed_samples === + using VULKAN_HPP_NAMESPACE::NVFramebufferMixedSamplesExtensionName; + using VULKAN_HPP_NAMESPACE::NVFramebufferMixedSamplesSpecVersion; + + //=== VK_NV_fill_rectangle === + using VULKAN_HPP_NAMESPACE::NVFillRectangleExtensionName; + using VULKAN_HPP_NAMESPACE::NVFillRectangleSpecVersion; + + //=== VK_NV_shader_sm_builtins === + using VULKAN_HPP_NAMESPACE::NVShaderSmBuiltinsExtensionName; + using VULKAN_HPP_NAMESPACE::NVShaderSmBuiltinsSpecVersion; + + //=== VK_EXT_post_depth_coverage === + using VULKAN_HPP_NAMESPACE::EXTPostDepthCoverageExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPostDepthCoverageSpecVersion; + + //=== VK_KHR_sampler_ycbcr_conversion === + using VULKAN_HPP_NAMESPACE::KHRSamplerYcbcrConversionExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSamplerYcbcrConversionSpecVersion; + + //=== VK_KHR_bind_memory2 === + using VULKAN_HPP_NAMESPACE::KHRBindMemory2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRBindMemory2SpecVersion; + + //=== VK_EXT_image_drm_format_modifier === + using VULKAN_HPP_NAMESPACE::EXTImageDrmFormatModifierExtensionName; + using VULKAN_HPP_NAMESPACE::EXTImageDrmFormatModifierSpecVersion; + + //=== VK_EXT_validation_cache === + using VULKAN_HPP_NAMESPACE::EXTValidationCacheExtensionName; + using VULKAN_HPP_NAMESPACE::EXTValidationCacheSpecVersion; + + //=== VK_EXT_descriptor_indexing === + using VULKAN_HPP_NAMESPACE::EXTDescriptorIndexingExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDescriptorIndexingSpecVersion; + + //=== VK_EXT_shader_viewport_index_layer === + using VULKAN_HPP_NAMESPACE::EXTShaderViewportIndexLayerExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderViewportIndexLayerSpecVersion; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_portability_subset === + using VULKAN_HPP_NAMESPACE::KHRPortabilitySubsetExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPortabilitySubsetSpecVersion; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NV_shading_rate_image === + using VULKAN_HPP_NAMESPACE::NVShadingRateImageExtensionName; + using VULKAN_HPP_NAMESPACE::NVShadingRateImageSpecVersion; + + //=== VK_NV_ray_tracing === + using VULKAN_HPP_NAMESPACE::NVRayTracingExtensionName; + using VULKAN_HPP_NAMESPACE::NVRayTracingSpecVersion; + using VULKAN_HPP_NAMESPACE::ShaderUnusedNV; + + //=== VK_NV_representative_fragment_test === + using VULKAN_HPP_NAMESPACE::NVRepresentativeFragmentTestExtensionName; + using VULKAN_HPP_NAMESPACE::NVRepresentativeFragmentTestSpecVersion; + + //=== VK_KHR_maintenance3 === + using VULKAN_HPP_NAMESPACE::KHRMaintenance3ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMaintenance3SpecVersion; + + //=== VK_KHR_draw_indirect_count === + using VULKAN_HPP_NAMESPACE::KHRDrawIndirectCountExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDrawIndirectCountSpecVersion; + + //=== VK_EXT_filter_cubic === + using VULKAN_HPP_NAMESPACE::EXTFilterCubicExtensionName; + using VULKAN_HPP_NAMESPACE::EXTFilterCubicSpecVersion; + + //=== VK_QCOM_render_pass_shader_resolve === + using VULKAN_HPP_NAMESPACE::QCOMRenderPassShaderResolveExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMRenderPassShaderResolveSpecVersion; + + //=== VK_EXT_global_priority === + using VULKAN_HPP_NAMESPACE::EXTGlobalPriorityExtensionName; + using VULKAN_HPP_NAMESPACE::EXTGlobalPrioritySpecVersion; + + //=== VK_KHR_shader_subgroup_extended_types === + using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupExtendedTypesExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupExtendedTypesSpecVersion; + + //=== VK_KHR_8bit_storage === + using VULKAN_HPP_NAMESPACE::KHR8BitStorageExtensionName; + using VULKAN_HPP_NAMESPACE::KHR8BitStorageSpecVersion; + + //=== VK_EXT_external_memory_host === + using VULKAN_HPP_NAMESPACE::EXTExternalMemoryHostExtensionName; + using VULKAN_HPP_NAMESPACE::EXTExternalMemoryHostSpecVersion; + + //=== VK_AMD_buffer_marker === + using VULKAN_HPP_NAMESPACE::AMDBufferMarkerExtensionName; + using VULKAN_HPP_NAMESPACE::AMDBufferMarkerSpecVersion; + + //=== VK_KHR_shader_atomic_int64 === + using VULKAN_HPP_NAMESPACE::KHRShaderAtomicInt64ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderAtomicInt64SpecVersion; + + //=== VK_KHR_shader_clock === + using VULKAN_HPP_NAMESPACE::KHRShaderClockExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderClockSpecVersion; + + //=== VK_AMD_pipeline_compiler_control === + using VULKAN_HPP_NAMESPACE::AMDPipelineCompilerControlExtensionName; + using VULKAN_HPP_NAMESPACE::AMDPipelineCompilerControlSpecVersion; + + //=== VK_EXT_calibrated_timestamps === + using VULKAN_HPP_NAMESPACE::EXTCalibratedTimestampsExtensionName; + using VULKAN_HPP_NAMESPACE::EXTCalibratedTimestampsSpecVersion; + + //=== VK_AMD_shader_core_properties === + using VULKAN_HPP_NAMESPACE::AMDShaderCorePropertiesExtensionName; + using VULKAN_HPP_NAMESPACE::AMDShaderCorePropertiesSpecVersion; + + //=== VK_KHR_video_decode_h265 === + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeH265ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeH265SpecVersion; + + //=== VK_KHR_global_priority === + using VULKAN_HPP_NAMESPACE::KHRGlobalPriorityExtensionName; + using VULKAN_HPP_NAMESPACE::KHRGlobalPrioritySpecVersion; + using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeKHR; + + //=== VK_AMD_memory_overallocation_behavior === + using VULKAN_HPP_NAMESPACE::AMDMemoryOverallocationBehaviorExtensionName; + using VULKAN_HPP_NAMESPACE::AMDMemoryOverallocationBehaviorSpecVersion; + + //=== VK_EXT_vertex_attribute_divisor === + using VULKAN_HPP_NAMESPACE::EXTVertexAttributeDivisorExtensionName; + using VULKAN_HPP_NAMESPACE::EXTVertexAttributeDivisorSpecVersion; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_frame_token === + using VULKAN_HPP_NAMESPACE::GGPFrameTokenExtensionName; + using VULKAN_HPP_NAMESPACE::GGPFrameTokenSpecVersion; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_EXT_pipeline_creation_feedback === + using VULKAN_HPP_NAMESPACE::EXTPipelineCreationFeedbackExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPipelineCreationFeedbackSpecVersion; + + //=== VK_KHR_driver_properties === + using VULKAN_HPP_NAMESPACE::KHRDriverPropertiesExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDriverPropertiesSpecVersion; + using VULKAN_HPP_NAMESPACE::MaxDriverInfoSizeKHR; + using VULKAN_HPP_NAMESPACE::MaxDriverNameSizeKHR; + + //=== VK_KHR_shader_float_controls === + using VULKAN_HPP_NAMESPACE::KHRShaderFloatControlsExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderFloatControlsSpecVersion; + + //=== VK_NV_shader_subgroup_partitioned === + using VULKAN_HPP_NAMESPACE::NVShaderSubgroupPartitionedExtensionName; + using VULKAN_HPP_NAMESPACE::NVShaderSubgroupPartitionedSpecVersion; + + //=== VK_KHR_depth_stencil_resolve === + using VULKAN_HPP_NAMESPACE::KHRDepthStencilResolveExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDepthStencilResolveSpecVersion; + + //=== VK_KHR_swapchain_mutable_format === + using VULKAN_HPP_NAMESPACE::KHRSwapchainMutableFormatExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSwapchainMutableFormatSpecVersion; + + //=== VK_NV_compute_shader_derivatives === + using VULKAN_HPP_NAMESPACE::NVComputeShaderDerivativesExtensionName; + using VULKAN_HPP_NAMESPACE::NVComputeShaderDerivativesSpecVersion; + + //=== VK_NV_mesh_shader === + using VULKAN_HPP_NAMESPACE::NVMeshShaderExtensionName; + using VULKAN_HPP_NAMESPACE::NVMeshShaderSpecVersion; + + //=== VK_NV_fragment_shader_barycentric === + using VULKAN_HPP_NAMESPACE::NVFragmentShaderBarycentricExtensionName; + using VULKAN_HPP_NAMESPACE::NVFragmentShaderBarycentricSpecVersion; + + //=== VK_NV_shader_image_footprint === + using VULKAN_HPP_NAMESPACE::NVShaderImageFootprintExtensionName; + using VULKAN_HPP_NAMESPACE::NVShaderImageFootprintSpecVersion; + + //=== VK_NV_scissor_exclusive === + using VULKAN_HPP_NAMESPACE::NVScissorExclusiveExtensionName; + using VULKAN_HPP_NAMESPACE::NVScissorExclusiveSpecVersion; + + //=== VK_NV_device_diagnostic_checkpoints === + using VULKAN_HPP_NAMESPACE::NVDeviceDiagnosticCheckpointsExtensionName; + using VULKAN_HPP_NAMESPACE::NVDeviceDiagnosticCheckpointsSpecVersion; + + //=== VK_KHR_timeline_semaphore === + using VULKAN_HPP_NAMESPACE::KHRTimelineSemaphoreExtensionName; + using VULKAN_HPP_NAMESPACE::KHRTimelineSemaphoreSpecVersion; + + //=== VK_EXT_present_timing === + using VULKAN_HPP_NAMESPACE::EXTPresentTimingExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPresentTimingSpecVersion; + + //=== VK_INTEL_shader_integer_functions2 === + using VULKAN_HPP_NAMESPACE::INTELShaderIntegerFunctions2ExtensionName; + using VULKAN_HPP_NAMESPACE::INTELShaderIntegerFunctions2SpecVersion; + + //=== VK_INTEL_performance_query === + using VULKAN_HPP_NAMESPACE::INTELPerformanceQueryExtensionName; + using VULKAN_HPP_NAMESPACE::INTELPerformanceQuerySpecVersion; + + //=== VK_KHR_vulkan_memory_model === + using VULKAN_HPP_NAMESPACE::KHRVulkanMemoryModelExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVulkanMemoryModelSpecVersion; + + //=== VK_EXT_pci_bus_info === + using VULKAN_HPP_NAMESPACE::EXTPciBusInfoExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPciBusInfoSpecVersion; + + //=== VK_AMD_display_native_hdr === + using VULKAN_HPP_NAMESPACE::AMDDisplayNativeHdrExtensionName; + using VULKAN_HPP_NAMESPACE::AMDDisplayNativeHdrSpecVersion; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + using VULKAN_HPP_NAMESPACE::FUCHSIAImagepipeSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::FUCHSIAImagepipeSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_KHR_shader_terminate_invocation === + using VULKAN_HPP_NAMESPACE::KHRShaderTerminateInvocationExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderTerminateInvocationSpecVersion; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + using VULKAN_HPP_NAMESPACE::EXTMetalSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::EXTMetalSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_fragment_density_map === + using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapExtensionName; + using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapSpecVersion; + + //=== VK_EXT_scalar_block_layout === + using VULKAN_HPP_NAMESPACE::EXTScalarBlockLayoutExtensionName; + using VULKAN_HPP_NAMESPACE::EXTScalarBlockLayoutSpecVersion; + + //=== VK_GOOGLE_hlsl_functionality1 === + using VULKAN_HPP_NAMESPACE::GOOGLEHlslFunctionality1ExtensionName; + using VULKAN_HPP_NAMESPACE::GOOGLEHlslFunctionality1SpecVersion; + + //=== VK_GOOGLE_decorate_string === + using VULKAN_HPP_NAMESPACE::GOOGLEDecorateStringExtensionName; + using VULKAN_HPP_NAMESPACE::GOOGLEDecorateStringSpecVersion; + + //=== VK_EXT_subgroup_size_control === + using VULKAN_HPP_NAMESPACE::EXTSubgroupSizeControlExtensionName; + using VULKAN_HPP_NAMESPACE::EXTSubgroupSizeControlSpecVersion; + + //=== VK_KHR_fragment_shading_rate === + using VULKAN_HPP_NAMESPACE::KHRFragmentShadingRateExtensionName; + using VULKAN_HPP_NAMESPACE::KHRFragmentShadingRateSpecVersion; + + //=== VK_AMD_shader_core_properties2 === + using VULKAN_HPP_NAMESPACE::AMDShaderCoreProperties2ExtensionName; + using VULKAN_HPP_NAMESPACE::AMDShaderCoreProperties2SpecVersion; + + //=== VK_AMD_device_coherent_memory === + using VULKAN_HPP_NAMESPACE::AMDDeviceCoherentMemoryExtensionName; + using VULKAN_HPP_NAMESPACE::AMDDeviceCoherentMemorySpecVersion; + + //=== VK_KHR_dynamic_rendering_local_read === + using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingLocalReadExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingLocalReadSpecVersion; + + //=== VK_EXT_shader_image_atomic_int64 === + using VULKAN_HPP_NAMESPACE::EXTShaderImageAtomicInt64ExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderImageAtomicInt64SpecVersion; + + //=== VK_KHR_shader_quad_control === + using VULKAN_HPP_NAMESPACE::KHRShaderQuadControlExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderQuadControlSpecVersion; + + //=== VK_KHR_spirv_1_4 === + using VULKAN_HPP_NAMESPACE::KHRSpirv14ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSpirv14SpecVersion; + + //=== VK_EXT_memory_budget === + using VULKAN_HPP_NAMESPACE::EXTMemoryBudgetExtensionName; + using VULKAN_HPP_NAMESPACE::EXTMemoryBudgetSpecVersion; + + //=== VK_EXT_memory_priority === + using VULKAN_HPP_NAMESPACE::EXTMemoryPriorityExtensionName; + using VULKAN_HPP_NAMESPACE::EXTMemoryPrioritySpecVersion; + + //=== VK_KHR_surface_protected_capabilities === + using VULKAN_HPP_NAMESPACE::KHRSurfaceProtectedCapabilitiesExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSurfaceProtectedCapabilitiesSpecVersion; + + //=== VK_NV_dedicated_allocation_image_aliasing === + using VULKAN_HPP_NAMESPACE::NVDedicatedAllocationImageAliasingExtensionName; + using VULKAN_HPP_NAMESPACE::NVDedicatedAllocationImageAliasingSpecVersion; + + //=== VK_KHR_separate_depth_stencil_layouts === + using VULKAN_HPP_NAMESPACE::KHRSeparateDepthStencilLayoutsExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSeparateDepthStencilLayoutsSpecVersion; + + //=== VK_EXT_buffer_device_address === + using VULKAN_HPP_NAMESPACE::EXTBufferDeviceAddressExtensionName; + using VULKAN_HPP_NAMESPACE::EXTBufferDeviceAddressSpecVersion; + + //=== VK_EXT_tooling_info === + using VULKAN_HPP_NAMESPACE::EXTToolingInfoExtensionName; + using VULKAN_HPP_NAMESPACE::EXTToolingInfoSpecVersion; + + //=== VK_EXT_separate_stencil_usage === + using VULKAN_HPP_NAMESPACE::EXTSeparateStencilUsageExtensionName; + using VULKAN_HPP_NAMESPACE::EXTSeparateStencilUsageSpecVersion; + + //=== VK_EXT_validation_features === + using VULKAN_HPP_NAMESPACE::EXTValidationFeaturesExtensionName; + using VULKAN_HPP_NAMESPACE::EXTValidationFeaturesSpecVersion; + + //=== VK_KHR_present_wait === + using VULKAN_HPP_NAMESPACE::KHRPresentWaitExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPresentWaitSpecVersion; + + //=== VK_NV_cooperative_matrix === + using VULKAN_HPP_NAMESPACE::NVCooperativeMatrixExtensionName; + using VULKAN_HPP_NAMESPACE::NVCooperativeMatrixSpecVersion; + + //=== VK_NV_coverage_reduction_mode === + using VULKAN_HPP_NAMESPACE::NVCoverageReductionModeExtensionName; + using VULKAN_HPP_NAMESPACE::NVCoverageReductionModeSpecVersion; + + //=== VK_EXT_fragment_shader_interlock === + using VULKAN_HPP_NAMESPACE::EXTFragmentShaderInterlockExtensionName; + using VULKAN_HPP_NAMESPACE::EXTFragmentShaderInterlockSpecVersion; + + //=== VK_EXT_ycbcr_image_arrays === + using VULKAN_HPP_NAMESPACE::EXTYcbcrImageArraysExtensionName; + using VULKAN_HPP_NAMESPACE::EXTYcbcrImageArraysSpecVersion; + + //=== VK_KHR_uniform_buffer_standard_layout === + using VULKAN_HPP_NAMESPACE::KHRUniformBufferStandardLayoutExtensionName; + using VULKAN_HPP_NAMESPACE::KHRUniformBufferStandardLayoutSpecVersion; + + //=== VK_EXT_provoking_vertex === + using VULKAN_HPP_NAMESPACE::EXTProvokingVertexExtensionName; + using VULKAN_HPP_NAMESPACE::EXTProvokingVertexSpecVersion; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + using VULKAN_HPP_NAMESPACE::EXTFullScreenExclusiveExtensionName; + using VULKAN_HPP_NAMESPACE::EXTFullScreenExclusiveSpecVersion; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + using VULKAN_HPP_NAMESPACE::EXTHeadlessSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::EXTHeadlessSurfaceSpecVersion; + + //=== VK_KHR_buffer_device_address === + using VULKAN_HPP_NAMESPACE::KHRBufferDeviceAddressExtensionName; + using VULKAN_HPP_NAMESPACE::KHRBufferDeviceAddressSpecVersion; + + //=== VK_EXT_line_rasterization === + using VULKAN_HPP_NAMESPACE::EXTLineRasterizationExtensionName; + using VULKAN_HPP_NAMESPACE::EXTLineRasterizationSpecVersion; + + //=== VK_EXT_shader_atomic_float === + using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloatExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloatSpecVersion; + + //=== VK_EXT_host_query_reset === + using VULKAN_HPP_NAMESPACE::EXTHostQueryResetExtensionName; + using VULKAN_HPP_NAMESPACE::EXTHostQueryResetSpecVersion; + + //=== VK_EXT_index_type_uint8 === + using VULKAN_HPP_NAMESPACE::EXTIndexTypeUint8ExtensionName; + using VULKAN_HPP_NAMESPACE::EXTIndexTypeUint8SpecVersion; + + //=== VK_EXT_extended_dynamic_state === + using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicStateExtensionName; + using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicStateSpecVersion; + + //=== VK_KHR_deferred_host_operations === + using VULKAN_HPP_NAMESPACE::KHRDeferredHostOperationsExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDeferredHostOperationsSpecVersion; + + //=== VK_KHR_pipeline_executable_properties === + using VULKAN_HPP_NAMESPACE::KHRPipelineExecutablePropertiesExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPipelineExecutablePropertiesSpecVersion; + + //=== VK_EXT_host_image_copy === + using VULKAN_HPP_NAMESPACE::EXTHostImageCopyExtensionName; + using VULKAN_HPP_NAMESPACE::EXTHostImageCopySpecVersion; + + //=== VK_KHR_map_memory2 === + using VULKAN_HPP_NAMESPACE::KHRMapMemory2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMapMemory2SpecVersion; + + //=== VK_EXT_map_memory_placed === + using VULKAN_HPP_NAMESPACE::EXTMapMemoryPlacedExtensionName; + using VULKAN_HPP_NAMESPACE::EXTMapMemoryPlacedSpecVersion; + + //=== VK_EXT_shader_atomic_float2 === + using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloat2ExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloat2SpecVersion; + + //=== VK_EXT_surface_maintenance1 === + using VULKAN_HPP_NAMESPACE::EXTSurfaceMaintenance1ExtensionName; + using VULKAN_HPP_NAMESPACE::EXTSurfaceMaintenance1SpecVersion; + + //=== VK_EXT_swapchain_maintenance1 === + using VULKAN_HPP_NAMESPACE::EXTSwapchainMaintenance1ExtensionName; + using VULKAN_HPP_NAMESPACE::EXTSwapchainMaintenance1SpecVersion; + + //=== VK_EXT_shader_demote_to_helper_invocation === + using VULKAN_HPP_NAMESPACE::EXTShaderDemoteToHelperInvocationExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderDemoteToHelperInvocationSpecVersion; + + //=== VK_NV_device_generated_commands === + using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsExtensionName; + using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsSpecVersion; + + //=== VK_NV_inherited_viewport_scissor === + using VULKAN_HPP_NAMESPACE::NVInheritedViewportScissorExtensionName; + using VULKAN_HPP_NAMESPACE::NVInheritedViewportScissorSpecVersion; + + //=== VK_KHR_shader_integer_dot_product === + using VULKAN_HPP_NAMESPACE::KHRShaderIntegerDotProductExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderIntegerDotProductSpecVersion; + + //=== VK_EXT_texel_buffer_alignment === + using VULKAN_HPP_NAMESPACE::EXTTexelBufferAlignmentExtensionName; + using VULKAN_HPP_NAMESPACE::EXTTexelBufferAlignmentSpecVersion; + + //=== VK_QCOM_render_pass_transform === + using VULKAN_HPP_NAMESPACE::QCOMRenderPassTransformExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMRenderPassTransformSpecVersion; + + //=== VK_EXT_depth_bias_control === + using VULKAN_HPP_NAMESPACE::EXTDepthBiasControlExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDepthBiasControlSpecVersion; + + //=== VK_EXT_device_memory_report === + using VULKAN_HPP_NAMESPACE::EXTDeviceMemoryReportExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDeviceMemoryReportSpecVersion; + + //=== VK_EXT_acquire_drm_display === + using VULKAN_HPP_NAMESPACE::EXTAcquireDrmDisplayExtensionName; + using VULKAN_HPP_NAMESPACE::EXTAcquireDrmDisplaySpecVersion; + + //=== VK_EXT_robustness2 === + using VULKAN_HPP_NAMESPACE::EXTRobustness2ExtensionName; + using VULKAN_HPP_NAMESPACE::EXTRobustness2SpecVersion; + + //=== VK_EXT_custom_border_color === + using VULKAN_HPP_NAMESPACE::EXTCustomBorderColorExtensionName; + using VULKAN_HPP_NAMESPACE::EXTCustomBorderColorSpecVersion; + + //=== VK_EXT_texture_compression_astc_3d === + using VULKAN_HPP_NAMESPACE::EXTTextureCompressionAstc3DExtensionName; + using VULKAN_HPP_NAMESPACE::EXTTextureCompressionAstc3DSpecVersion; + + //=== VK_GOOGLE_user_type === + using VULKAN_HPP_NAMESPACE::GOOGLEUserTypeExtensionName; + using VULKAN_HPP_NAMESPACE::GOOGLEUserTypeSpecVersion; + + //=== VK_KHR_pipeline_library === + using VULKAN_HPP_NAMESPACE::KHRPipelineLibraryExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPipelineLibrarySpecVersion; + + //=== VK_NV_present_barrier === + using VULKAN_HPP_NAMESPACE::NVPresentBarrierExtensionName; + using VULKAN_HPP_NAMESPACE::NVPresentBarrierSpecVersion; + + //=== VK_KHR_shader_non_semantic_info === + using VULKAN_HPP_NAMESPACE::KHRShaderNonSemanticInfoExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderNonSemanticInfoSpecVersion; + + //=== VK_KHR_present_id === + using VULKAN_HPP_NAMESPACE::KHRPresentIdExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPresentIdSpecVersion; + + //=== VK_EXT_private_data === + using VULKAN_HPP_NAMESPACE::EXTPrivateDataExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPrivateDataSpecVersion; + + //=== VK_EXT_pipeline_creation_cache_control === + using VULKAN_HPP_NAMESPACE::EXTPipelineCreationCacheControlExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPipelineCreationCacheControlSpecVersion; + + //=== VK_KHR_video_encode_queue === + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeQueueExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeQueueSpecVersion; + + //=== VK_NV_device_diagnostics_config === + using VULKAN_HPP_NAMESPACE::NVDeviceDiagnosticsConfigExtensionName; + using VULKAN_HPP_NAMESPACE::NVDeviceDiagnosticsConfigSpecVersion; + + //=== VK_QCOM_render_pass_store_ops === + using VULKAN_HPP_NAMESPACE::QCOMRenderPassStoreOpsExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMRenderPassStoreOpsSpecVersion; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + using VULKAN_HPP_NAMESPACE::NVCudaKernelLaunchExtensionName; + using VULKAN_HPP_NAMESPACE::NVCudaKernelLaunchSpecVersion; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + using VULKAN_HPP_NAMESPACE::QCOMTileShadingExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMTileShadingSpecVersion; + + //=== VK_NV_low_latency === + using VULKAN_HPP_NAMESPACE::NVLowLatencyExtensionName; + using VULKAN_HPP_NAMESPACE::NVLowLatencySpecVersion; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + using VULKAN_HPP_NAMESPACE::EXTMetalObjectsExtensionName; + using VULKAN_HPP_NAMESPACE::EXTMetalObjectsSpecVersion; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + using VULKAN_HPP_NAMESPACE::KHRSynchronization2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSynchronization2SpecVersion; + + //=== VK_EXT_descriptor_buffer === + using VULKAN_HPP_NAMESPACE::EXTDescriptorBufferExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDescriptorBufferSpecVersion; + + //=== VK_EXT_graphics_pipeline_library === + using VULKAN_HPP_NAMESPACE::EXTGraphicsPipelineLibraryExtensionName; + using VULKAN_HPP_NAMESPACE::EXTGraphicsPipelineLibrarySpecVersion; + + //=== VK_AMD_shader_early_and_late_fragment_tests === + using VULKAN_HPP_NAMESPACE::AMDShaderEarlyAndLateFragmentTestsExtensionName; + using VULKAN_HPP_NAMESPACE::AMDShaderEarlyAndLateFragmentTestsSpecVersion; + + //=== VK_KHR_fragment_shader_barycentric === + using VULKAN_HPP_NAMESPACE::KHRFragmentShaderBarycentricExtensionName; + using VULKAN_HPP_NAMESPACE::KHRFragmentShaderBarycentricSpecVersion; + + //=== VK_KHR_shader_subgroup_uniform_control_flow === + using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupUniformControlFlowExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupUniformControlFlowSpecVersion; + + //=== VK_KHR_zero_initialize_workgroup_memory === + using VULKAN_HPP_NAMESPACE::KHRZeroInitializeWorkgroupMemoryExtensionName; + using VULKAN_HPP_NAMESPACE::KHRZeroInitializeWorkgroupMemorySpecVersion; + + //=== VK_NV_fragment_shading_rate_enums === + using VULKAN_HPP_NAMESPACE::NVFragmentShadingRateEnumsExtensionName; + using VULKAN_HPP_NAMESPACE::NVFragmentShadingRateEnumsSpecVersion; + + //=== VK_NV_ray_tracing_motion_blur === + using VULKAN_HPP_NAMESPACE::NVRayTracingMotionBlurExtensionName; + using VULKAN_HPP_NAMESPACE::NVRayTracingMotionBlurSpecVersion; + + //=== VK_EXT_mesh_shader === + using VULKAN_HPP_NAMESPACE::EXTMeshShaderExtensionName; + using VULKAN_HPP_NAMESPACE::EXTMeshShaderSpecVersion; + + //=== VK_EXT_ycbcr_2plane_444_formats === + using VULKAN_HPP_NAMESPACE::EXTYcbcr2Plane444FormatsExtensionName; + using VULKAN_HPP_NAMESPACE::EXTYcbcr2Plane444FormatsSpecVersion; + + //=== VK_EXT_fragment_density_map2 === + using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMap2ExtensionName; + using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMap2SpecVersion; + + //=== VK_QCOM_rotated_copy_commands === + using VULKAN_HPP_NAMESPACE::QCOMRotatedCopyCommandsExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMRotatedCopyCommandsSpecVersion; + + //=== VK_EXT_image_robustness === + using VULKAN_HPP_NAMESPACE::EXTImageRobustnessExtensionName; + using VULKAN_HPP_NAMESPACE::EXTImageRobustnessSpecVersion; + + //=== VK_KHR_workgroup_memory_explicit_layout === + using VULKAN_HPP_NAMESPACE::KHRWorkgroupMemoryExplicitLayoutExtensionName; + using VULKAN_HPP_NAMESPACE::KHRWorkgroupMemoryExplicitLayoutSpecVersion; + + //=== VK_KHR_copy_commands2 === + using VULKAN_HPP_NAMESPACE::KHRCopyCommands2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRCopyCommands2SpecVersion; + + //=== VK_EXT_image_compression_control === + using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlExtensionName; + using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlSpecVersion; + + //=== VK_EXT_attachment_feedback_loop_layout === + using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopLayoutExtensionName; + using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopLayoutSpecVersion; + + //=== VK_EXT_4444_formats === + using VULKAN_HPP_NAMESPACE::EXT4444FormatsExtensionName; + using VULKAN_HPP_NAMESPACE::EXT4444FormatsSpecVersion; + + //=== VK_EXT_device_fault === + using VULKAN_HPP_NAMESPACE::EXTDeviceFaultExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDeviceFaultSpecVersion; + + //=== VK_ARM_rasterization_order_attachment_access === + using VULKAN_HPP_NAMESPACE::ARMRasterizationOrderAttachmentAccessExtensionName; + using VULKAN_HPP_NAMESPACE::ARMRasterizationOrderAttachmentAccessSpecVersion; + + //=== VK_EXT_rgba10x6_formats === + using VULKAN_HPP_NAMESPACE::EXTRgba10X6FormatsExtensionName; + using VULKAN_HPP_NAMESPACE::EXTRgba10X6FormatsSpecVersion; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + using VULKAN_HPP_NAMESPACE::NVAcquireWinrtDisplayExtensionName; + using VULKAN_HPP_NAMESPACE::NVAcquireWinrtDisplaySpecVersion; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + using VULKAN_HPP_NAMESPACE::EXTDirectfbSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDirectfbSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_VALVE_mutable_descriptor_type === + using VULKAN_HPP_NAMESPACE::VALVEMutableDescriptorTypeExtensionName; + using VULKAN_HPP_NAMESPACE::VALVEMutableDescriptorTypeSpecVersion; + + //=== VK_EXT_vertex_input_dynamic_state === + using VULKAN_HPP_NAMESPACE::EXTVertexInputDynamicStateExtensionName; + using VULKAN_HPP_NAMESPACE::EXTVertexInputDynamicStateSpecVersion; + + //=== VK_EXT_physical_device_drm === + using VULKAN_HPP_NAMESPACE::EXTPhysicalDeviceDrmExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPhysicalDeviceDrmSpecVersion; + + //=== VK_EXT_device_address_binding_report === + using VULKAN_HPP_NAMESPACE::EXTDeviceAddressBindingReportExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDeviceAddressBindingReportSpecVersion; + + //=== VK_EXT_depth_clip_control === + using VULKAN_HPP_NAMESPACE::EXTDepthClipControlExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDepthClipControlSpecVersion; + + //=== VK_EXT_primitive_topology_list_restart === + using VULKAN_HPP_NAMESPACE::EXTPrimitiveTopologyListRestartExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPrimitiveTopologyListRestartSpecVersion; + + //=== VK_KHR_format_feature_flags2 === + using VULKAN_HPP_NAMESPACE::KHRFormatFeatureFlags2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRFormatFeatureFlags2SpecVersion; + + //=== VK_EXT_present_mode_fifo_latest_ready === + using VULKAN_HPP_NAMESPACE::EXTPresentModeFifoLatestReadyExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPresentModeFifoLatestReadySpecVersion; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + using VULKAN_HPP_NAMESPACE::FUCHSIAExternalMemoryExtensionName; + using VULKAN_HPP_NAMESPACE::FUCHSIAExternalMemorySpecVersion; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + using VULKAN_HPP_NAMESPACE::FUCHSIAExternalSemaphoreExtensionName; + using VULKAN_HPP_NAMESPACE::FUCHSIAExternalSemaphoreSpecVersion; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + using VULKAN_HPP_NAMESPACE::FUCHSIABufferCollectionExtensionName; + using VULKAN_HPP_NAMESPACE::FUCHSIABufferCollectionSpecVersion; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + using VULKAN_HPP_NAMESPACE::HUAWEISubpassShadingExtensionName; + using VULKAN_HPP_NAMESPACE::HUAWEISubpassShadingSpecVersion; + + //=== VK_HUAWEI_invocation_mask === + using VULKAN_HPP_NAMESPACE::HUAWEIInvocationMaskExtensionName; + using VULKAN_HPP_NAMESPACE::HUAWEIInvocationMaskSpecVersion; + + //=== VK_NV_external_memory_rdma === + using VULKAN_HPP_NAMESPACE::NVExternalMemoryRdmaExtensionName; + using VULKAN_HPP_NAMESPACE::NVExternalMemoryRdmaSpecVersion; + + //=== VK_EXT_pipeline_properties === + using VULKAN_HPP_NAMESPACE::EXTPipelinePropertiesExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPipelinePropertiesSpecVersion; + + //=== VK_EXT_frame_boundary === + using VULKAN_HPP_NAMESPACE::EXTFrameBoundaryExtensionName; + using VULKAN_HPP_NAMESPACE::EXTFrameBoundarySpecVersion; + + //=== VK_EXT_multisampled_render_to_single_sampled === + using VULKAN_HPP_NAMESPACE::EXTMultisampledRenderToSingleSampledExtensionName; + using VULKAN_HPP_NAMESPACE::EXTMultisampledRenderToSingleSampledSpecVersion; + + //=== VK_EXT_extended_dynamic_state2 === + using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicState2ExtensionName; + using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicState2SpecVersion; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + using VULKAN_HPP_NAMESPACE::QNXScreenSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::QNXScreenSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_color_write_enable === + using VULKAN_HPP_NAMESPACE::EXTColorWriteEnableExtensionName; + using VULKAN_HPP_NAMESPACE::EXTColorWriteEnableSpecVersion; + + //=== VK_EXT_primitives_generated_query === + using VULKAN_HPP_NAMESPACE::EXTPrimitivesGeneratedQueryExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPrimitivesGeneratedQuerySpecVersion; + + //=== VK_KHR_ray_tracing_maintenance1 === + using VULKAN_HPP_NAMESPACE::KHRRayTracingMaintenance1ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRRayTracingMaintenance1SpecVersion; + + //=== VK_KHR_shader_untyped_pointers === + using VULKAN_HPP_NAMESPACE::KHRShaderUntypedPointersExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderUntypedPointersSpecVersion; + + //=== VK_EXT_global_priority_query === + using VULKAN_HPP_NAMESPACE::EXTGlobalPriorityQueryExtensionName; + using VULKAN_HPP_NAMESPACE::EXTGlobalPriorityQuerySpecVersion; + using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeEXT; + + //=== VK_VALVE_video_encode_rgb_conversion === + using VULKAN_HPP_NAMESPACE::VALVEVideoEncodeRgbConversionExtensionName; + using VULKAN_HPP_NAMESPACE::VALVEVideoEncodeRgbConversionSpecVersion; + + //=== VK_EXT_image_view_min_lod === + using VULKAN_HPP_NAMESPACE::EXTImageViewMinLodExtensionName; + using VULKAN_HPP_NAMESPACE::EXTImageViewMinLodSpecVersion; + + //=== VK_EXT_multi_draw === + using VULKAN_HPP_NAMESPACE::EXTMultiDrawExtensionName; + using VULKAN_HPP_NAMESPACE::EXTMultiDrawSpecVersion; + + //=== VK_EXT_image_2d_view_of_3d === + using VULKAN_HPP_NAMESPACE::EXTImage2DViewOf3DExtensionName; + using VULKAN_HPP_NAMESPACE::EXTImage2DViewOf3DSpecVersion; + + //=== VK_KHR_portability_enumeration === + using VULKAN_HPP_NAMESPACE::KHRPortabilityEnumerationExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPortabilityEnumerationSpecVersion; + + //=== VK_EXT_shader_tile_image === + using VULKAN_HPP_NAMESPACE::EXTShaderTileImageExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderTileImageSpecVersion; + + //=== VK_EXT_opacity_micromap === + using VULKAN_HPP_NAMESPACE::EXTOpacityMicromapExtensionName; + using VULKAN_HPP_NAMESPACE::EXTOpacityMicromapSpecVersion; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_displacement_micromap === + using VULKAN_HPP_NAMESPACE::NVDisplacementMicromapExtensionName; + using VULKAN_HPP_NAMESPACE::NVDisplacementMicromapSpecVersion; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_load_store_op_none === + using VULKAN_HPP_NAMESPACE::EXTLoadStoreOpNoneExtensionName; + using VULKAN_HPP_NAMESPACE::EXTLoadStoreOpNoneSpecVersion; + + //=== VK_HUAWEI_cluster_culling_shader === + using VULKAN_HPP_NAMESPACE::HUAWEIClusterCullingShaderExtensionName; + using VULKAN_HPP_NAMESPACE::HUAWEIClusterCullingShaderSpecVersion; + + //=== VK_EXT_border_color_swizzle === + using VULKAN_HPP_NAMESPACE::EXTBorderColorSwizzleExtensionName; + using VULKAN_HPP_NAMESPACE::EXTBorderColorSwizzleSpecVersion; + + //=== VK_EXT_pageable_device_local_memory === + using VULKAN_HPP_NAMESPACE::EXTPageableDeviceLocalMemoryExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPageableDeviceLocalMemorySpecVersion; + + //=== VK_KHR_maintenance4 === + using VULKAN_HPP_NAMESPACE::KHRMaintenance4ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMaintenance4SpecVersion; + + //=== VK_ARM_shader_core_properties === + using VULKAN_HPP_NAMESPACE::ARMShaderCorePropertiesExtensionName; + using VULKAN_HPP_NAMESPACE::ARMShaderCorePropertiesSpecVersion; + + //=== VK_KHR_shader_subgroup_rotate === + using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupRotateExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupRotateSpecVersion; + + //=== VK_ARM_scheduling_controls === + using VULKAN_HPP_NAMESPACE::ARMSchedulingControlsExtensionName; + using VULKAN_HPP_NAMESPACE::ARMSchedulingControlsSpecVersion; + + //=== VK_EXT_image_sliced_view_of_3d === + using VULKAN_HPP_NAMESPACE::EXTImageSlicedViewOf3DExtensionName; + using VULKAN_HPP_NAMESPACE::EXTImageSlicedViewOf3DSpecVersion; + using VULKAN_HPP_NAMESPACE::Remaining3DSlicesEXT; + + //=== VK_VALVE_descriptor_set_host_mapping === + using VULKAN_HPP_NAMESPACE::VALVEDescriptorSetHostMappingExtensionName; + using VULKAN_HPP_NAMESPACE::VALVEDescriptorSetHostMappingSpecVersion; + + //=== VK_EXT_depth_clamp_zero_one === + using VULKAN_HPP_NAMESPACE::EXTDepthClampZeroOneExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDepthClampZeroOneSpecVersion; + + //=== VK_EXT_non_seamless_cube_map === + using VULKAN_HPP_NAMESPACE::EXTNonSeamlessCubeMapExtensionName; + using VULKAN_HPP_NAMESPACE::EXTNonSeamlessCubeMapSpecVersion; + + //=== VK_ARM_render_pass_striped === + using VULKAN_HPP_NAMESPACE::ARMRenderPassStripedExtensionName; + using VULKAN_HPP_NAMESPACE::ARMRenderPassStripedSpecVersion; + + //=== VK_QCOM_fragment_density_map_offset === + using VULKAN_HPP_NAMESPACE::QCOMFragmentDensityMapOffsetExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMFragmentDensityMapOffsetSpecVersion; + + //=== VK_NV_copy_memory_indirect === + using VULKAN_HPP_NAMESPACE::NVCopyMemoryIndirectExtensionName; + using VULKAN_HPP_NAMESPACE::NVCopyMemoryIndirectSpecVersion; + + //=== VK_NV_memory_decompression === + using VULKAN_HPP_NAMESPACE::NVMemoryDecompressionExtensionName; + using VULKAN_HPP_NAMESPACE::NVMemoryDecompressionSpecVersion; + + //=== VK_NV_device_generated_commands_compute === + using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsComputeExtensionName; + using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsComputeSpecVersion; + + //=== VK_NV_ray_tracing_linear_swept_spheres === + using VULKAN_HPP_NAMESPACE::NVRayTracingLinearSweptSpheresExtensionName; + using VULKAN_HPP_NAMESPACE::NVRayTracingLinearSweptSpheresSpecVersion; + + //=== VK_NV_linear_color_attachment === + using VULKAN_HPP_NAMESPACE::NVLinearColorAttachmentExtensionName; + using VULKAN_HPP_NAMESPACE::NVLinearColorAttachmentSpecVersion; + + //=== VK_GOOGLE_surfaceless_query === + using VULKAN_HPP_NAMESPACE::GOOGLESurfacelessQueryExtensionName; + using VULKAN_HPP_NAMESPACE::GOOGLESurfacelessQuerySpecVersion; + + //=== VK_KHR_shader_maximal_reconvergence === + using VULKAN_HPP_NAMESPACE::KHRShaderMaximalReconvergenceExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderMaximalReconvergenceSpecVersion; + + //=== VK_EXT_image_compression_control_swapchain === + using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlSwapchainExtensionName; + using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlSwapchainSpecVersion; + + //=== VK_QCOM_image_processing === + using VULKAN_HPP_NAMESPACE::QCOMImageProcessingExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMImageProcessingSpecVersion; + + //=== VK_EXT_nested_command_buffer === + using VULKAN_HPP_NAMESPACE::EXTNestedCommandBufferExtensionName; + using VULKAN_HPP_NAMESPACE::EXTNestedCommandBufferSpecVersion; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + using VULKAN_HPP_NAMESPACE::OHOSExternalMemoryExtensionName; + using VULKAN_HPP_NAMESPACE::OHOSExternalMemorySpecVersion; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_external_memory_acquire_unmodified === + using VULKAN_HPP_NAMESPACE::EXTExternalMemoryAcquireUnmodifiedExtensionName; + using VULKAN_HPP_NAMESPACE::EXTExternalMemoryAcquireUnmodifiedSpecVersion; + + //=== VK_EXT_extended_dynamic_state3 === + using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicState3ExtensionName; + using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicState3SpecVersion; + + //=== VK_EXT_subpass_merge_feedback === + using VULKAN_HPP_NAMESPACE::EXTSubpassMergeFeedbackExtensionName; + using VULKAN_HPP_NAMESPACE::EXTSubpassMergeFeedbackSpecVersion; + + //=== VK_LUNARG_direct_driver_loading === + using VULKAN_HPP_NAMESPACE::LUNARGDirectDriverLoadingExtensionName; + using VULKAN_HPP_NAMESPACE::LUNARGDirectDriverLoadingSpecVersion; + + //=== VK_ARM_tensors === + using VULKAN_HPP_NAMESPACE::ARMTensorsExtensionName; + using VULKAN_HPP_NAMESPACE::ARMTensorsSpecVersion; + + //=== VK_EXT_shader_module_identifier === + using VULKAN_HPP_NAMESPACE::EXTShaderModuleIdentifierExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderModuleIdentifierSpecVersion; + using VULKAN_HPP_NAMESPACE::MaxShaderModuleIdentifierSizeEXT; + + //=== VK_EXT_rasterization_order_attachment_access === + using VULKAN_HPP_NAMESPACE::EXTRasterizationOrderAttachmentAccessExtensionName; + using VULKAN_HPP_NAMESPACE::EXTRasterizationOrderAttachmentAccessSpecVersion; + + //=== VK_NV_optical_flow === + using VULKAN_HPP_NAMESPACE::NVOpticalFlowExtensionName; + using VULKAN_HPP_NAMESPACE::NVOpticalFlowSpecVersion; + + //=== VK_EXT_legacy_dithering === + using VULKAN_HPP_NAMESPACE::EXTLegacyDitheringExtensionName; + using VULKAN_HPP_NAMESPACE::EXTLegacyDitheringSpecVersion; + + //=== VK_EXT_pipeline_protected_access === + using VULKAN_HPP_NAMESPACE::EXTPipelineProtectedAccessExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPipelineProtectedAccessSpecVersion; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_format_resolve === + using VULKAN_HPP_NAMESPACE::ANDROIDExternalFormatResolveExtensionName; + using VULKAN_HPP_NAMESPACE::ANDROIDExternalFormatResolveSpecVersion; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + //=== VK_KHR_maintenance5 === + using VULKAN_HPP_NAMESPACE::KHRMaintenance5ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMaintenance5SpecVersion; + + //=== VK_AMD_anti_lag === + using VULKAN_HPP_NAMESPACE::AMDAntiLagExtensionName; + using VULKAN_HPP_NAMESPACE::AMDAntiLagSpecVersion; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_dense_geometry_format === + using VULKAN_HPP_NAMESPACE::AMDXDenseGeometryFormatExtensionName; + using VULKAN_HPP_NAMESPACE::AMDXDenseGeometryFormatSpecVersion; + using VULKAN_HPP_NAMESPACE::CompressedTriangleFormatDgf1ByteAlignmentAMDX; + using VULKAN_HPP_NAMESPACE::CompressedTriangleFormatDgf1ByteStrideAMDX; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_present_id2 === + using VULKAN_HPP_NAMESPACE::KHRPresentId2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPresentId2SpecVersion; + + //=== VK_KHR_present_wait2 === + using VULKAN_HPP_NAMESPACE::KHRPresentWait2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPresentWait2SpecVersion; + + //=== VK_KHR_ray_tracing_position_fetch === + using VULKAN_HPP_NAMESPACE::KHRRayTracingPositionFetchExtensionName; + using VULKAN_HPP_NAMESPACE::KHRRayTracingPositionFetchSpecVersion; + + //=== VK_EXT_shader_object === + using VULKAN_HPP_NAMESPACE::EXTShaderObjectExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderObjectSpecVersion; + + //=== VK_KHR_pipeline_binary === + using VULKAN_HPP_NAMESPACE::KHRPipelineBinaryExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPipelineBinarySpecVersion; + using VULKAN_HPP_NAMESPACE::MaxPipelineBinaryKeySizeKHR; + + //=== VK_QCOM_tile_properties === + using VULKAN_HPP_NAMESPACE::QCOMTilePropertiesExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMTilePropertiesSpecVersion; + + //=== VK_SEC_amigo_profiling === + using VULKAN_HPP_NAMESPACE::SECAmigoProfilingExtensionName; + using VULKAN_HPP_NAMESPACE::SECAmigoProfilingSpecVersion; + + //=== VK_KHR_surface_maintenance1 === + using VULKAN_HPP_NAMESPACE::KHRSurfaceMaintenance1ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSurfaceMaintenance1SpecVersion; + + //=== VK_KHR_swapchain_maintenance1 === + using VULKAN_HPP_NAMESPACE::KHRSwapchainMaintenance1ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRSwapchainMaintenance1SpecVersion; + + //=== VK_QCOM_multiview_per_view_viewports === + using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewViewportsExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewViewportsSpecVersion; + + //=== VK_NV_ray_tracing_invocation_reorder === + using VULKAN_HPP_NAMESPACE::NVRayTracingInvocationReorderExtensionName; + using VULKAN_HPP_NAMESPACE::NVRayTracingInvocationReorderSpecVersion; + + //=== VK_NV_cooperative_vector === + using VULKAN_HPP_NAMESPACE::NVCooperativeVectorExtensionName; + using VULKAN_HPP_NAMESPACE::NVCooperativeVectorSpecVersion; + + //=== VK_NV_extended_sparse_address_space === + using VULKAN_HPP_NAMESPACE::NVExtendedSparseAddressSpaceExtensionName; + using VULKAN_HPP_NAMESPACE::NVExtendedSparseAddressSpaceSpecVersion; + + //=== VK_EXT_mutable_descriptor_type === + using VULKAN_HPP_NAMESPACE::EXTMutableDescriptorTypeExtensionName; + using VULKAN_HPP_NAMESPACE::EXTMutableDescriptorTypeSpecVersion; + + //=== VK_EXT_legacy_vertex_attributes === + using VULKAN_HPP_NAMESPACE::EXTLegacyVertexAttributesExtensionName; + using VULKAN_HPP_NAMESPACE::EXTLegacyVertexAttributesSpecVersion; + + //=== VK_EXT_layer_settings === + using VULKAN_HPP_NAMESPACE::EXTLayerSettingsExtensionName; + using VULKAN_HPP_NAMESPACE::EXTLayerSettingsSpecVersion; + + //=== VK_ARM_shader_core_builtins === + using VULKAN_HPP_NAMESPACE::ARMShaderCoreBuiltinsExtensionName; + using VULKAN_HPP_NAMESPACE::ARMShaderCoreBuiltinsSpecVersion; + + //=== VK_EXT_pipeline_library_group_handles === + using VULKAN_HPP_NAMESPACE::EXTPipelineLibraryGroupHandlesExtensionName; + using VULKAN_HPP_NAMESPACE::EXTPipelineLibraryGroupHandlesSpecVersion; + + //=== VK_EXT_dynamic_rendering_unused_attachments === + using VULKAN_HPP_NAMESPACE::EXTDynamicRenderingUnusedAttachmentsExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDynamicRenderingUnusedAttachmentsSpecVersion; + + //=== VK_KHR_internally_synchronized_queues === + using VULKAN_HPP_NAMESPACE::KHRInternallySynchronizedQueuesExtensionName; + using VULKAN_HPP_NAMESPACE::KHRInternallySynchronizedQueuesSpecVersion; + + //=== VK_NV_low_latency2 === + using VULKAN_HPP_NAMESPACE::NVLowLatency2ExtensionName; + using VULKAN_HPP_NAMESPACE::NVLowLatency2SpecVersion; + + //=== VK_KHR_cooperative_matrix === + using VULKAN_HPP_NAMESPACE::KHRCooperativeMatrixExtensionName; + using VULKAN_HPP_NAMESPACE::KHRCooperativeMatrixSpecVersion; + + //=== VK_ARM_data_graph === + using VULKAN_HPP_NAMESPACE::ARMDataGraphExtensionName; + using VULKAN_HPP_NAMESPACE::ARMDataGraphSpecVersion; + using VULKAN_HPP_NAMESPACE::MaxPhysicalDeviceDataGraphOperationSetNameSizeARM; + + //=== VK_QCOM_multiview_per_view_render_areas === + using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasSpecVersion; + + //=== VK_KHR_compute_shader_derivatives === + using VULKAN_HPP_NAMESPACE::KHRComputeShaderDerivativesExtensionName; + using VULKAN_HPP_NAMESPACE::KHRComputeShaderDerivativesSpecVersion; + + //=== VK_KHR_video_decode_av1 === + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1SpecVersion; + using VULKAN_HPP_NAMESPACE::MaxVideoAv1ReferencesPerFrameKHR; + + //=== VK_KHR_video_encode_av1 === + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeAv1ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeAv1SpecVersion; + + //=== VK_KHR_video_decode_vp9 === + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeVp9ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoDecodeVp9SpecVersion; + using VULKAN_HPP_NAMESPACE::MaxVideoVp9ReferencesPerFrameKHR; + + //=== VK_KHR_video_maintenance1 === + using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1SpecVersion; + + //=== VK_NV_per_stage_descriptor_set === + using VULKAN_HPP_NAMESPACE::NVPerStageDescriptorSetExtensionName; + using VULKAN_HPP_NAMESPACE::NVPerStageDescriptorSetSpecVersion; + + //=== VK_QCOM_image_processing2 === + using VULKAN_HPP_NAMESPACE::QCOMImageProcessing2ExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMImageProcessing2SpecVersion; + + //=== VK_QCOM_filter_cubic_weights === + using VULKAN_HPP_NAMESPACE::QCOMFilterCubicWeightsExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMFilterCubicWeightsSpecVersion; + + //=== VK_QCOM_ycbcr_degamma === + using VULKAN_HPP_NAMESPACE::QCOMYcbcrDegammaExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMYcbcrDegammaSpecVersion; + + //=== VK_QCOM_filter_cubic_clamp === + using VULKAN_HPP_NAMESPACE::QCOMFilterCubicClampExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMFilterCubicClampSpecVersion; + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopDynamicStateExtensionName; + using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopDynamicStateSpecVersion; + + //=== VK_KHR_vertex_attribute_divisor === + using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorSpecVersion; + + //=== VK_KHR_load_store_op_none === + using VULKAN_HPP_NAMESPACE::KHRLoadStoreOpNoneExtensionName; + using VULKAN_HPP_NAMESPACE::KHRLoadStoreOpNoneSpecVersion; + + //=== VK_KHR_unified_image_layouts === + using VULKAN_HPP_NAMESPACE::KHRUnifiedImageLayoutsExtensionName; + using VULKAN_HPP_NAMESPACE::KHRUnifiedImageLayoutsSpecVersion; + + //=== VK_KHR_shader_float_controls2 === + using VULKAN_HPP_NAMESPACE::KHRShaderFloatControls2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderFloatControls2SpecVersion; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + using VULKAN_HPP_NAMESPACE::QNXExternalMemoryScreenBufferExtensionName; + using VULKAN_HPP_NAMESPACE::QNXExternalMemoryScreenBufferSpecVersion; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_MSFT_layered_driver === + using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverExtensionName; + using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverSpecVersion; + + //=== VK_KHR_index_type_uint8 === + using VULKAN_HPP_NAMESPACE::KHRIndexTypeUint8ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRIndexTypeUint8SpecVersion; + + //=== VK_KHR_line_rasterization === + using VULKAN_HPP_NAMESPACE::KHRLineRasterizationExtensionName; + using VULKAN_HPP_NAMESPACE::KHRLineRasterizationSpecVersion; + + //=== VK_KHR_calibrated_timestamps === + using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsExtensionName; + using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsSpecVersion; + + //=== VK_KHR_shader_expect_assume === + using VULKAN_HPP_NAMESPACE::KHRShaderExpectAssumeExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderExpectAssumeSpecVersion; + + //=== VK_KHR_maintenance6 === + using VULKAN_HPP_NAMESPACE::KHRMaintenance6ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMaintenance6SpecVersion; + + //=== VK_NV_descriptor_pool_overallocation === + using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName; + using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion; + + //=== VK_QCOM_tile_memory_heap === + using VULKAN_HPP_NAMESPACE::QCOMTileMemoryHeapExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMTileMemoryHeapSpecVersion; + + //=== VK_KHR_copy_memory_indirect === + using VULKAN_HPP_NAMESPACE::KHRCopyMemoryIndirectExtensionName; + using VULKAN_HPP_NAMESPACE::KHRCopyMemoryIndirectSpecVersion; + + //=== VK_EXT_memory_decompression === + using VULKAN_HPP_NAMESPACE::EXTMemoryDecompressionExtensionName; + using VULKAN_HPP_NAMESPACE::EXTMemoryDecompressionSpecVersion; + + //=== VK_NV_display_stereo === + using VULKAN_HPP_NAMESPACE::NVDisplayStereoExtensionName; + using VULKAN_HPP_NAMESPACE::NVDisplayStereoSpecVersion; + + //=== VK_KHR_video_encode_intra_refresh === + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeIntraRefreshExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeIntraRefreshSpecVersion; + + //=== VK_KHR_video_encode_quantization_map === + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeQuantizationMapExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoEncodeQuantizationMapSpecVersion; + + //=== VK_NV_raw_access_chains === + using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName; + using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion; + + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueExtensionName; + using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueSpecVersion; + + //=== VK_KHR_shader_relaxed_extended_instruction === + using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionSpecVersion; + + //=== VK_NV_command_buffer_inheritance === + using VULKAN_HPP_NAMESPACE::NVCommandBufferInheritanceExtensionName; + using VULKAN_HPP_NAMESPACE::NVCommandBufferInheritanceSpecVersion; + + //=== VK_KHR_maintenance7 === + using VULKAN_HPP_NAMESPACE::KHRMaintenance7ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMaintenance7SpecVersion; + + //=== VK_NV_shader_atomic_float16_vector === + using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorExtensionName; + using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorSpecVersion; + + //=== VK_EXT_shader_replicated_composites === + using VULKAN_HPP_NAMESPACE::EXTShaderReplicatedCompositesExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderReplicatedCompositesSpecVersion; + + //=== VK_EXT_shader_float8 === + using VULKAN_HPP_NAMESPACE::EXTShaderFloat8ExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderFloat8SpecVersion; + + //=== VK_NV_ray_tracing_validation === + using VULKAN_HPP_NAMESPACE::NVRayTracingValidationExtensionName; + using VULKAN_HPP_NAMESPACE::NVRayTracingValidationSpecVersion; + + //=== VK_NV_cluster_acceleration_structure === + using VULKAN_HPP_NAMESPACE::NVClusterAccelerationStructureExtensionName; + using VULKAN_HPP_NAMESPACE::NVClusterAccelerationStructureSpecVersion; + + //=== VK_NV_partitioned_acceleration_structure === + using VULKAN_HPP_NAMESPACE::NVPartitionedAccelerationStructureExtensionName; + using VULKAN_HPP_NAMESPACE::NVPartitionedAccelerationStructureSpecVersion; + using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructurePartitionIndexGlobalNV; + + //=== VK_EXT_device_generated_commands === + using VULKAN_HPP_NAMESPACE::EXTDeviceGeneratedCommandsExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDeviceGeneratedCommandsSpecVersion; + + //=== VK_KHR_maintenance8 === + using VULKAN_HPP_NAMESPACE::KHRMaintenance8ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMaintenance8SpecVersion; + + //=== VK_MESA_image_alignment_control === + using VULKAN_HPP_NAMESPACE::MESAImageAlignmentControlExtensionName; + using VULKAN_HPP_NAMESPACE::MESAImageAlignmentControlSpecVersion; + + //=== VK_KHR_shader_fma === + using VULKAN_HPP_NAMESPACE::KHRShaderFmaExtensionName; + using VULKAN_HPP_NAMESPACE::KHRShaderFmaSpecVersion; + + //=== VK_NV_push_constant_bank === + using VULKAN_HPP_NAMESPACE::NVPushConstantBankExtensionName; + using VULKAN_HPP_NAMESPACE::NVPushConstantBankSpecVersion; + + //=== VK_EXT_ray_tracing_invocation_reorder === + using VULKAN_HPP_NAMESPACE::EXTRayTracingInvocationReorderExtensionName; + using VULKAN_HPP_NAMESPACE::EXTRayTracingInvocationReorderSpecVersion; + + //=== VK_EXT_depth_clamp_control === + using VULKAN_HPP_NAMESPACE::EXTDepthClampControlExtensionName; + using VULKAN_HPP_NAMESPACE::EXTDepthClampControlSpecVersion; + + //=== VK_KHR_maintenance9 === + using VULKAN_HPP_NAMESPACE::KHRMaintenance9ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMaintenance9SpecVersion; + + //=== VK_KHR_video_maintenance2 === + using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2SpecVersion; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + using VULKAN_HPP_NAMESPACE::OHOSSurfaceExtensionName; + using VULKAN_HPP_NAMESPACE::OHOSSurfaceSpecVersion; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_HUAWEI_hdr_vivid === + using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividExtensionName; + using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividSpecVersion; + + //=== VK_NV_cooperative_matrix2 === + using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2ExtensionName; + using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2SpecVersion; + + //=== VK_ARM_pipeline_opacity_micromap === + using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapExtensionName; + using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapSpecVersion; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + using VULKAN_HPP_NAMESPACE::EXTExternalMemoryMetalExtensionName; + using VULKAN_HPP_NAMESPACE::EXTExternalMemoryMetalSpecVersion; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_depth_clamp_zero_one === + using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneExtensionName; + using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneSpecVersion; + + //=== VK_ARM_performance_counters_by_region === + using VULKAN_HPP_NAMESPACE::ARMPerformanceCountersByRegionExtensionName; + using VULKAN_HPP_NAMESPACE::ARMPerformanceCountersByRegionSpecVersion; + + //=== VK_EXT_vertex_attribute_robustness === + using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessExtensionName; + using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessSpecVersion; + + //=== VK_ARM_format_pack === + using VULKAN_HPP_NAMESPACE::ARMFormatPackExtensionName; + using VULKAN_HPP_NAMESPACE::ARMFormatPackSpecVersion; + + //=== VK_VALVE_fragment_density_map_layered === + using VULKAN_HPP_NAMESPACE::VALVEFragmentDensityMapLayeredExtensionName; + using VULKAN_HPP_NAMESPACE::VALVEFragmentDensityMapLayeredSpecVersion; + + //=== VK_KHR_robustness2 === + using VULKAN_HPP_NAMESPACE::KHRRobustness2ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRRobustness2SpecVersion; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_present_metering === + using VULKAN_HPP_NAMESPACE::NVPresentMeteringExtensionName; + using VULKAN_HPP_NAMESPACE::NVPresentMeteringSpecVersion; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_fragment_density_map_offset === + using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetExtensionName; + using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetSpecVersion; + + //=== VK_EXT_zero_initialize_device_memory === + using VULKAN_HPP_NAMESPACE::EXTZeroInitializeDeviceMemoryExtensionName; + using VULKAN_HPP_NAMESPACE::EXTZeroInitializeDeviceMemorySpecVersion; + + //=== VK_KHR_present_mode_fifo_latest_ready === + using VULKAN_HPP_NAMESPACE::KHRPresentModeFifoLatestReadyExtensionName; + using VULKAN_HPP_NAMESPACE::KHRPresentModeFifoLatestReadySpecVersion; + + //=== VK_EXT_shader_64bit_indexing === + using VULKAN_HPP_NAMESPACE::EXTShader64BitIndexingExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShader64BitIndexingSpecVersion; + + //=== VK_EXT_custom_resolve === + using VULKAN_HPP_NAMESPACE::EXTCustomResolveExtensionName; + using VULKAN_HPP_NAMESPACE::EXTCustomResolveSpecVersion; + + //=== VK_QCOM_data_graph_model === + using VULKAN_HPP_NAMESPACE::DataGraphModelToolchainVersionLengthQCOM; + using VULKAN_HPP_NAMESPACE::QCOMDataGraphModelExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMDataGraphModelSpecVersion; + + //=== VK_KHR_maintenance10 === + using VULKAN_HPP_NAMESPACE::KHRMaintenance10ExtensionName; + using VULKAN_HPP_NAMESPACE::KHRMaintenance10SpecVersion; + + //=== VK_EXT_shader_long_vector === + using VULKAN_HPP_NAMESPACE::EXTShaderLongVectorExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderLongVectorSpecVersion; + + //=== VK_SEC_pipeline_cache_incremental_mode === + using VULKAN_HPP_NAMESPACE::SECPipelineCacheIncrementalModeExtensionName; + using VULKAN_HPP_NAMESPACE::SECPipelineCacheIncrementalModeSpecVersion; + + //=== VK_EXT_shader_uniform_buffer_unsized_array === + using VULKAN_HPP_NAMESPACE::EXTShaderUniformBufferUnsizedArrayExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderUniformBufferUnsizedArraySpecVersion; + + //=== VK_NV_compute_occupancy_priority === + using VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityHighNV; + using VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityLowNV; + using VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityNormalNV; + using VULKAN_HPP_NAMESPACE::NVComputeOccupancyPriorityExtensionName; + using VULKAN_HPP_NAMESPACE::NVComputeOccupancyPrioritySpecVersion; + + //=== VK_EXT_shader_subgroup_partitioned === + using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupPartitionedExtensionName; + using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupPartitionedSpecVersion; + + //======================== + //=== CONSTEXPR VALUEs === + //======================== + using VULKAN_HPP_NAMESPACE::HeaderVersion; + using VULKAN_HPP_NAMESPACE::Use64BitPtrDefines; + + //========================= + //=== CONSTEXPR CALLEEs === + //========================= + using VULKAN_HPP_NAMESPACE::apiVersionMajor; + using VULKAN_HPP_NAMESPACE::apiVersionMinor; + using VULKAN_HPP_NAMESPACE::apiVersionPatch; + using VULKAN_HPP_NAMESPACE::apiVersionVariant; + using VULKAN_HPP_NAMESPACE::makeApiVersion; + using VULKAN_HPP_NAMESPACE::makeVersion; + using VULKAN_HPP_NAMESPACE::versionMajor; + using VULKAN_HPP_NAMESPACE::versionMinor; + using VULKAN_HPP_NAMESPACE::versionPatch; + + //========================== + //=== CONSTEXPR CALLERs === + //========================== + 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::ApiVersion14; + using VULKAN_HPP_NAMESPACE::HeaderVersionComplete; + + //==================== + //=== FUNCPOINTERs === + //==================== + + //=== VK_VERSION_1_0 === + using VULKAN_HPP_NAMESPACE::PFN_AllocationFunction; + using VULKAN_HPP_NAMESPACE::PFN_FreeFunction; + using VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification; + using VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification; + using VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction; + using VULKAN_HPP_NAMESPACE::PFN_VoidFunction; + + //=== VK_EXT_debug_report === + using VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT; + + //=== VK_EXT_debug_utils === + using VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT; + + //=== VK_EXT_device_memory_report === + using VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT; + + //=== VK_LUNARG_direct_driver_loading === + using VULKAN_HPP_NAMESPACE::PFN_GetInstanceProcAddrLUNARG; + + //=============== + //=== 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_VERSION_1_4 === + using VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo; + using VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR; + using VULKAN_HPP_NAMESPACE::BindMemoryStatus; + using VULKAN_HPP_NAMESPACE::BindMemoryStatusKHR; + using VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfo; + using VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR; + using VULKAN_HPP_NAMESPACE::CopyImageToImageInfo; + using VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT; + using VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo; + using VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT; + using VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo; + using VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT; + using VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo; + using VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR; + using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfo; + using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQuery; + using VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT; + using VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo; + using VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT; + using VULKAN_HPP_NAMESPACE::ImageSubresource2; + using VULKAN_HPP_NAMESPACE::ImageSubresource2EXT; + using VULKAN_HPP_NAMESPACE::ImageSubresource2KHR; + using VULKAN_HPP_NAMESPACE::ImageToMemoryCopy; + using VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT; + using VULKAN_HPP_NAMESPACE::MemoryMapInfo; + using VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR; + using VULKAN_HPP_NAMESPACE::MemoryToImageCopy; + using VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT; + using VULKAN_HPP_NAMESPACE::MemoryUnmapInfo; + using VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Properties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Properties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6PropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeatures; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorProperties; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Features; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Properties; + using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfo; + using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::PushConstantsInfo; + using VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR; + using VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo; + using VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR; + using VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo; + using VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR; + using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityProperties; + using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT; + using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR; + using VULKAN_HPP_NAMESPACE::RenderingAreaInfo; + using VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR; + using VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo; + using VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR; + using VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo; + using VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR; + using VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySize; + using VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT; + using VULKAN_HPP_NAMESPACE::SubresourceLayout2; + using VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT; + using VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR; + using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescription; + using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT; + using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR; + + //=== 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; + using VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX; + + //=== VK_NVX_image_view_handle === + using VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX; + using VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX; + + //=== VK_KHR_video_encode_h264 === + using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR; + + //=== VK_KHR_video_encode_h265 === + using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR; + + //=== 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; + +#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; + +#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_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::MultiviewPerViewAttributesInfoNVX; + 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_IMG_relaxed_line_rasterization === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG; + + //=== 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*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + using VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstAMDX; + using VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX; + using VULKAN_HPP_NAMESPACE::DispatchGraphInfoAMDX; + using VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX; + using VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX; + using VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + using VULKAN_HPP_NAMESPACE::BindHeapInfoEXT; + using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT; + using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT; + using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceDataEXT; + using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT; + using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT; + using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT; + using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT; + using VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT; + using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT; + using VULKAN_HPP_NAMESPACE::DescriptorSetAndBindingMappingEXT; + using VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT; + using VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT; + using VULKAN_HPP_NAMESPACE::HostAddressRangeEXT; + using VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV; + using VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM; + using VULKAN_HPP_NAMESPACE::PushDataInfoEXT; + using VULKAN_HPP_NAMESPACE::ResourceDescriptorDataEXT; + using VULKAN_HPP_NAMESPACE::ResourceDescriptorInfoEXT; + using VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT; + using VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT; + using VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM; + using VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT; + + //=== VK_AMD_mixed_attachment_samples === + using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD; + using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV; + + //=== VK_KHR_shader_bfloat16 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR; + + //=== 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_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_AMD_memory_overallocation_behavior === + using VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD; + + //=== VK_EXT_vertex_attribute_divisor === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_frame_token === + using VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== 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::CheckpointData2NV; + using VULKAN_HPP_NAMESPACE::CheckpointDataNV; + using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV; + using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV; + + //=== VK_EXT_present_timing === + using VULKAN_HPP_NAMESPACE::PastPresentationTimingEXT; + using VULKAN_HPP_NAMESPACE::PastPresentationTimingInfoEXT; + using VULKAN_HPP_NAMESPACE::PastPresentationTimingPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentTimingFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PresentStageTimeEXT; + using VULKAN_HPP_NAMESPACE::PresentTimingInfoEXT; + using VULKAN_HPP_NAMESPACE::PresentTimingsInfoEXT; + using VULKAN_HPP_NAMESPACE::PresentTimingSurfaceCapabilitiesEXT; + using VULKAN_HPP_NAMESPACE::SwapchainCalibratedTimestampInfoEXT; + using VULKAN_HPP_NAMESPACE::SwapchainTimeDomainPropertiesEXT; + using VULKAN_HPP_NAMESPACE::SwapchainTimingPropertiesEXT; + + //=== 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::RenderingFragmentDensityMapAttachmentInfoEXT; + 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; + using VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR; + + //=== 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_KHR_shader_quad_control === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR; + + //=== 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_shader_atomic_float === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT; + + //=== 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_EXT_map_memory_placed === + using VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT; + + //=== VK_EXT_shader_atomic_float2 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT; + + //=== 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_custom_border_color === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT; + using VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorCreateInfoEXT; + + //=== VK_EXT_texture_compression_astc_3d === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT; + + //=== 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; + + //=== 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; + + //=== VK_NV_device_diagnostics_config === + using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + using VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV; + using VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV; + using VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + using VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM; + using VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM; + using VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM; + using VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM; + + //=== 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_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::PhysicalDeviceImageCompressionControlFeaturesEXT; + + //=== 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_frame_boundary === + using VULKAN_HPP_NAMESPACE::FrameBoundaryEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT; + + //=== 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_KHR_shader_untyped_pointers === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR; + + //=== VK_VALVE_video_encode_rgb_conversion === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; + using VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE; + using VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE; + using VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE; + + //=== 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; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; + + //=== 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_ARM_scheduling_controls === + using VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM; + + //=== 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_non_seamless_cube_map === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + + //=== VK_ARM_render_pass_striped === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM; + using VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM; + using VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM; + using VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM; + + //=== VK_NV_copy_memory_indirect === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV; + + //=== VK_NV_memory_decompression === + using VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV; + + //=== VK_NV_device_generated_commands_compute === + using VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV; + using VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; + using VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV; + + //=== VK_NV_ray_tracing_linear_swept_spheres === + using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV; + using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; + + //=== VK_NV_linear_color_attachment === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV; + + //=== VK_KHR_shader_maximal_reconvergence === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; + + //=== 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_nested_command_buffer === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + using VULKAN_HPP_NAMESPACE::ExternalFormatOHOS; + using VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS; + using VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS; + using VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS; + using VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS; + using VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== 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_ARM_tensors === + using VULKAN_HPP_NAMESPACE::BindTensorMemoryInfoARM; + using VULKAN_HPP_NAMESPACE::CopyTensorInfoARM; + using VULKAN_HPP_NAMESPACE::DescriptorGetTensorInfoARM; + using VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM; + using VULKAN_HPP_NAMESPACE::ExternalMemoryTensorCreateInfoARM; + using VULKAN_HPP_NAMESPACE::ExternalTensorPropertiesARM; + using VULKAN_HPP_NAMESPACE::FrameBoundaryTensorsARM; + using VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoTensorARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorFeaturesARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorPropertiesARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalTensorInfoARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorFeaturesARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorPropertiesARM; + using VULKAN_HPP_NAMESPACE::TensorCaptureDescriptorDataInfoARM; + using VULKAN_HPP_NAMESPACE::TensorCopyARM; + using VULKAN_HPP_NAMESPACE::TensorCreateInfoARM; + using VULKAN_HPP_NAMESPACE::TensorDependencyInfoARM; + using VULKAN_HPP_NAMESPACE::TensorDescriptionARM; + using VULKAN_HPP_NAMESPACE::TensorFormatPropertiesARM; + using VULKAN_HPP_NAMESPACE::TensorMemoryBarrierARM; + using VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM; + using VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM; + using VULKAN_HPP_NAMESPACE::WriteDescriptorSetTensorARM; + + //=== 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; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_format_resolve === + using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + //=== VK_AMD_anti_lag === + using VULKAN_HPP_NAMESPACE::AntiLagDataAMD; + using VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_dense_geometry_format === + using VULKAN_HPP_NAMESPACE::AccelerationStructureDenseGeometryFormatTrianglesDataAMDX; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_present_id2 === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentId2FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PresentId2KHR; + using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentId2KHR; + + //=== VK_KHR_present_wait2 === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWait2FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PresentWait2InfoKHR; + using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentWait2KHR; + + //=== 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_KHR_pipeline_binary === + using VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR; + using VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR; + using VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR; + using VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR; + using VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR; + using VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR; + using VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR; + + //=== 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_KHR_surface_maintenance1 === + using VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT; + using VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityKHR; + using VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT; + using VULKAN_HPP_NAMESPACE::SurfacePresentModeKHR; + using VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT; + using VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesKHR; + + //=== VK_KHR_swapchain_maintenance1 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesKHR; + using VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT; + using VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoKHR; + using VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT; + using VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoKHR; + using VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT; + using VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoKHR; + using VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoKHR; + + //=== 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_NV_cooperative_vector === + using VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV; + using VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV; + + //=== VK_NV_extended_sparse_address_space === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV; + + //=== 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_EXT_legacy_vertex_attributes === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT; + + //=== VK_EXT_layer_settings === + using VULKAN_HPP_NAMESPACE::LayerSettingEXT; + using VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT; + + //=== 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_internally_synchronized_queues === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; + + //=== VK_NV_low_latency2 === + using VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV; + using VULKAN_HPP_NAMESPACE::LatencySleepInfoNV; + using VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV; + using VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV; + using VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV; + using VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV; + using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV; + using VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV; + using VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV; + + //=== VK_KHR_cooperative_matrix === + using VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR; + + //=== VK_ARM_data_graph === + using VULKAN_HPP_NAMESPACE::BindDataGraphPipelineSessionMemoryInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineCreateInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineIdentifierCreateInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyQueryResultARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementsInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionMemoryRequirementsInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphPipelineShaderModuleCreateInfoARM; + using VULKAN_HPP_NAMESPACE::DataGraphProcessingEngineCreateInfoARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphFeaturesARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineARM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; + using VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphProcessingEnginePropertiesARM; + using VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphPropertiesARM; + + //=== VK_QCOM_multiview_per_view_render_areas === + using VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + + //=== VK_KHR_compute_shader_derivatives === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesPropertiesKHR; + + //=== VK_KHR_video_decode_av1 === + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR; + + //=== VK_KHR_video_encode_av1 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR; + + //=== VK_KHR_video_decode_vp9 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoDecodeVP9FeaturesKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeVP9CapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeVP9PictureInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeVP9ProfileInfoKHR; + + //=== VK_KHR_video_maintenance1 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR; + using VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR; + + //=== VK_NV_per_stage_descriptor_set === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV; + + //=== VK_QCOM_image_processing2 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM; + using VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM; + + //=== VK_QCOM_filter_cubic_weights === + using VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM; + using VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM; + + //=== VK_QCOM_ycbcr_degamma === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM; + using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; + + //=== VK_QCOM_filter_cubic_clamp === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM; + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + + //=== VK_KHR_unified_image_layouts === + using VULKAN_HPP_NAMESPACE::AttachmentFeedbackLoopInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceUnifiedImageLayoutsFeaturesKHR; + +#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*/ + + //=== VK_MSFT_layered_driver === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT; + + //=== VK_KHR_calibrated_timestamps === + using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT; + using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR; + + //=== VK_KHR_maintenance6 === + using VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT; + using VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT; + + //=== VK_NV_descriptor_pool_overallocation === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + + //=== VK_QCOM_tile_memory_heap === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM; + using VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM; + using VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM; + using VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM; + + //=== VK_KHR_copy_memory_indirect === + using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR; + using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV; + using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR; + using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR; + using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV; + using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV; + using VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR; + + //=== VK_EXT_memory_decompression === + using VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT; + using VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV; + + //=== VK_NV_display_stereo === + using VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV; + using VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV; + + //=== VK_KHR_video_encode_intra_refresh === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshCapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeSessionIntraRefreshCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoReferenceIntraRefreshInfoKHR; + + //=== VK_KHR_video_encode_quantization_map === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR; + using VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR; + using VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR; + + //=== VK_NV_raw_access_chains === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV; + + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV; + using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV; + using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV; + + //=== VK_KHR_shader_relaxed_extended_instruction === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; + + //=== VK_NV_command_buffer_inheritance === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCommandBufferInheritanceFeaturesNV; + + //=== VK_KHR_maintenance7 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR; + + //=== VK_NV_shader_atomic_float16_vector === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + + //=== VK_EXT_shader_replicated_composites === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT; + + //=== VK_EXT_shader_float8 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat8FeaturesEXT; + + //=== VK_NV_ray_tracing_validation === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV; + + //=== VK_NV_cluster_acceleration_structure === + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGetTemplateIndicesInfoNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV; + using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV; + using VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV; + using VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV; + + //=== VK_NV_partitioned_acceleration_structure === + using VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV; + using VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV; + using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV; + using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV; + using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV; + using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV; + using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV; + using VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV; + + //=== VK_EXT_device_generated_commands === + using VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT; + using VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT; + using VULKAN_HPP_NAMESPACE::DrawIndirectCountIndirectCommandEXT; + using VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT; + using VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoEXT; + using VULKAN_HPP_NAMESPACE::GeneratedCommandsPipelineInfoEXT; + using VULKAN_HPP_NAMESPACE::GeneratedCommandsShaderInfoEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsExecutionSetTokenEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsIndexBufferTokenEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsPushConstantTokenEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsTokenDataEXT; + using VULKAN_HPP_NAMESPACE::IndirectCommandsVertexBufferTokenEXT; + using VULKAN_HPP_NAMESPACE::IndirectExecutionSetCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoEXT; + using VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT; + using VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT; + using VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + using VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetPipelineEXT; + using VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT; + + //=== VK_KHR_maintenance8 === + using VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR; + + //=== VK_MESA_image_alignment_control === + using VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA; + + //=== VK_KHR_shader_fma === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR; + + //=== VK_NV_push_constant_bank === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV; + using VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV; + + //=== VK_EXT_ray_tracing_invocation_reorder === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT; + + //=== VK_EXT_depth_clamp_control === + using VULKAN_HPP_NAMESPACE::DepthClampRangeEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT; + + //=== VK_KHR_maintenance9 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9PropertiesKHR; + using VULKAN_HPP_NAMESPACE::QueueFamilyOwnershipTransferPropertiesKHR; + + //=== VK_KHR_video_maintenance2 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR; + using VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + using VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_HUAWEI_hdr_vivid === + using VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI; + + //=== VK_NV_cooperative_matrix2 === + using VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV; + + //=== VK_ARM_pipeline_opacity_micromap === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + using VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT; + using VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT; + using VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_depth_clamp_zero_one === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR; + + //=== VK_ARM_performance_counters_by_region === + using VULKAN_HPP_NAMESPACE::PerformanceCounterARM; + using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM; + using VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM; + + //=== VK_EXT_vertex_attribute_robustness === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT; + + //=== VK_ARM_format_pack === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM; + + //=== VK_VALVE_fragment_density_map_layered === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; + using VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE; + + //=== VK_KHR_robustness2 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_present_metering === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV; + using VULKAN_HPP_NAMESPACE::SetPresentConfigNV; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_fragment_density_map_offset === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + using VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT; + using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM; + + //=== VK_EXT_zero_initialize_device_memory === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + + //=== VK_KHR_present_mode_fifo_latest_ready === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + + //=== VK_EXT_shader_64bit_indexing === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT; + + //=== VK_EXT_custom_resolve === + using VULKAN_HPP_NAMESPACE::BeginCustomResolveInfoEXT; + using VULKAN_HPP_NAMESPACE::CustomResolveCreateInfoEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomResolveFeaturesEXT; + + //=== VK_QCOM_data_graph_model === + using VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM; + using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM; + + //=== VK_KHR_maintenance10 === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR; + using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR; + using VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT; + using VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR; + using VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR; + + //=== VK_EXT_shader_long_vector === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT; + + //=== VK_SEC_pipeline_cache_incremental_mode === + using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; + + //=== VK_EXT_shader_uniform_buffer_unsized_array === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; + + //=== VK_NV_compute_occupancy_priority === + using VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityParametersNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeOccupancyPriorityFeaturesNV; + + //=== VK_EXT_shader_subgroup_partitioned === + using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; + + //=============== + //=== 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_EXT_descriptor_heap === + using VULKAN_HPP_NAMESPACE::TensorARM; + + //=== 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_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + using VULKAN_HPP_NAMESPACE::CudaFunctionNV; + using VULKAN_HPP_NAMESPACE::CudaModuleNV; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#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_ARM_tensors === + using VULKAN_HPP_NAMESPACE::TensorARM; + using VULKAN_HPP_NAMESPACE::TensorViewARM; + + //=== VK_NV_optical_flow === + using VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV; + + //=== VK_EXT_shader_object === + using VULKAN_HPP_NAMESPACE::ShaderEXT; + + //=== VK_KHR_pipeline_binary === + using VULKAN_HPP_NAMESPACE::PipelineBinaryKHR; + + //=== VK_ARM_data_graph === + using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM; + + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV; + + //=== VK_EXT_device_generated_commands === + using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT; + using VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT; + + //====================== + //=== 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_KHR_display === + using VULKAN_HPP_NAMESPACE::UniqueDisplayKHR; + + //=== 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_EXT_descriptor_heap === + using VULKAN_HPP_NAMESPACE::UniqueTensorARM; + + //=== 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_INTEL_performance_query === + using VULKAN_HPP_NAMESPACE::UniquePerformanceConfigurationINTEL; + + //=== VK_KHR_deferred_host_operations === + using VULKAN_HPP_NAMESPACE::UniqueDeferredOperationKHR; + + //=== VK_NV_device_generated_commands === + using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutNV; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + using VULKAN_HPP_NAMESPACE::UniqueCudaFunctionNV; + using VULKAN_HPP_NAMESPACE::UniqueCudaModuleNV; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# 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_ARM_tensors === + using VULKAN_HPP_NAMESPACE::UniqueTensorARM; + using VULKAN_HPP_NAMESPACE::UniqueTensorViewARM; + + //=== VK_NV_optical_flow === + using VULKAN_HPP_NAMESPACE::UniqueOpticalFlowSessionNV; + + //=== VK_EXT_shader_object === + using VULKAN_HPP_NAMESPACE::UniqueShaderEXT; + + //=== VK_KHR_pipeline_binary === + using VULKAN_HPP_NAMESPACE::UniquePipelineBinaryKHR; + + //=== VK_ARM_data_graph === + using VULKAN_HPP_NAMESPACE::UniqueDataGraphPipelineSessionARM; + + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_NAMESPACE::UniqueExternalComputeQueueNV; + + //=== VK_EXT_device_generated_commands === + using VULKAN_HPP_NAMESPACE::UniqueHandleTraits; + using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutEXT; + using VULKAN_HPP_NAMESPACE::UniqueIndirectExecutionSetEXT; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + + //====================== + //=== SHARED HANDLEs === + //====================== + +#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) + + //=== VK_VERSION_1_0 === + using VULKAN_HPP_NAMESPACE::SharedBuffer; + using VULKAN_HPP_NAMESPACE::SharedBufferView; + using VULKAN_HPP_NAMESPACE::SharedCommandBuffer; + using VULKAN_HPP_NAMESPACE::SharedCommandPool; + using VULKAN_HPP_NAMESPACE::SharedDescriptorPool; + using VULKAN_HPP_NAMESPACE::SharedDescriptorSet; + using VULKAN_HPP_NAMESPACE::SharedDescriptorSetLayout; + using VULKAN_HPP_NAMESPACE::SharedDevice; + using VULKAN_HPP_NAMESPACE::SharedDeviceMemory; + using VULKAN_HPP_NAMESPACE::SharedEvent; + using VULKAN_HPP_NAMESPACE::SharedFence; + using VULKAN_HPP_NAMESPACE::SharedFramebuffer; + using VULKAN_HPP_NAMESPACE::SharedImage; + using VULKAN_HPP_NAMESPACE::SharedImageView; + using VULKAN_HPP_NAMESPACE::SharedInstance; + using VULKAN_HPP_NAMESPACE::SharedPhysicalDevice; + using VULKAN_HPP_NAMESPACE::SharedPipeline; + using VULKAN_HPP_NAMESPACE::SharedPipelineCache; + using VULKAN_HPP_NAMESPACE::SharedPipelineLayout; + using VULKAN_HPP_NAMESPACE::SharedQueryPool; + using VULKAN_HPP_NAMESPACE::SharedQueue; + using VULKAN_HPP_NAMESPACE::SharedRenderPass; + using VULKAN_HPP_NAMESPACE::SharedSampler; + using VULKAN_HPP_NAMESPACE::SharedSemaphore; + using VULKAN_HPP_NAMESPACE::SharedShaderModule; + + //=== VK_VERSION_1_1 === + using VULKAN_HPP_NAMESPACE::SharedDescriptorUpdateTemplate; + using VULKAN_HPP_NAMESPACE::SharedSamplerYcbcrConversion; + + //=== VK_VERSION_1_3 === + using VULKAN_HPP_NAMESPACE::SharedPrivateDataSlot; + + //=== VK_KHR_surface === + using VULKAN_HPP_NAMESPACE::SharedSurfaceKHR; + + //=== VK_KHR_swapchain === + using VULKAN_HPP_NAMESPACE::SharedSwapchainKHR; + + //=== VK_KHR_display === + using VULKAN_HPP_NAMESPACE::SharedDisplayKHR; + using VULKAN_HPP_NAMESPACE::SharedDisplayModeKHR; + + //=== VK_EXT_debug_report === + using VULKAN_HPP_NAMESPACE::SharedDebugReportCallbackEXT; + + //=== VK_KHR_video_queue === + using VULKAN_HPP_NAMESPACE::SharedVideoSessionKHR; + using VULKAN_HPP_NAMESPACE::SharedVideoSessionParametersKHR; + + //=== VK_NVX_binary_import === + using VULKAN_HPP_NAMESPACE::SharedCuFunctionNVX; + using VULKAN_HPP_NAMESPACE::SharedCuModuleNVX; + + //=== VK_EXT_debug_utils === + using VULKAN_HPP_NAMESPACE::SharedDebugUtilsMessengerEXT; + + //=== VK_EXT_descriptor_heap === + using VULKAN_HPP_NAMESPACE::SharedTensorARM; + + //=== VK_KHR_acceleration_structure === + using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureKHR; + + //=== VK_EXT_validation_cache === + using VULKAN_HPP_NAMESPACE::SharedValidationCacheEXT; + + //=== VK_NV_ray_tracing === + using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureNV; + + //=== VK_INTEL_performance_query === + using VULKAN_HPP_NAMESPACE::SharedPerformanceConfigurationINTEL; + + //=== VK_KHR_deferred_host_operations === + using VULKAN_HPP_NAMESPACE::SharedDeferredOperationKHR; + + //=== VK_NV_device_generated_commands === + using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutNV; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + using VULKAN_HPP_NAMESPACE::SharedCudaFunctionNV; + using VULKAN_HPP_NAMESPACE::SharedCudaModuleNV; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + using VULKAN_HPP_NAMESPACE::SharedBufferCollectionFUCHSIA; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + using VULKAN_HPP_NAMESPACE::SharedMicromapEXT; + + //=== VK_ARM_tensors === + using VULKAN_HPP_NAMESPACE::SharedTensorARM; + using VULKAN_HPP_NAMESPACE::SharedTensorViewARM; + + //=== VK_NV_optical_flow === + using VULKAN_HPP_NAMESPACE::SharedOpticalFlowSessionNV; + + //=== VK_EXT_shader_object === + using VULKAN_HPP_NAMESPACE::SharedShaderEXT; + + //=== VK_KHR_pipeline_binary === + using VULKAN_HPP_NAMESPACE::SharedPipelineBinaryKHR; + + //=== VK_ARM_data_graph === + using VULKAN_HPP_NAMESPACE::SharedDataGraphPipelineSessionARM; + + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_NAMESPACE::SharedExternalComputeQueueNV; + + //=== VK_EXT_device_generated_commands === + using VULKAN_HPP_NAMESPACE::SharedHandleTraits; + using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutEXT; + using VULKAN_HPP_NAMESPACE::SharedIndirectExecutionSetEXT; + + //=== VK_KHR_swapchain enum === + using VULKAN_HPP_NAMESPACE::SwapchainOwns; +#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 VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL + namespace detail + { + using VULKAN_HPP_NAMESPACE::detail::DynamicLoader; + } // namespace detail +#endif /*VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL*/ + + //===================== + //=== 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::getDepthFormats; + using VULKAN_HPP_NAMESPACE::getDepthStencilFormats; + using VULKAN_HPP_NAMESPACE::getStencilFormats; + using VULKAN_HPP_NAMESPACE::hasDepthComponent; + using VULKAN_HPP_NAMESPACE::hasStencilComponent; + 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; + +#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + namespace VULKAN_HPP_RAII_NAMESPACE + { + //====================== + //=== RAII HARDCODED === + //====================== + + using VULKAN_HPP_RAII_NAMESPACE::Context; + using VULKAN_HPP_RAII_NAMESPACE::isVulkanRAIIHandleType; + + namespace detail + { + using VULKAN_HPP_RAII_NAMESPACE::detail::ContextDispatcher; + using VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher; + using VULKAN_HPP_RAII_NAMESPACE::detail::InstanceDispatcher; + } // namespace detail + + //==================== + //=== 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_EXT_descriptor_heap === + using VULKAN_HPP_RAII_NAMESPACE::TensorARM; + + //=== 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_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + using VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV; + using VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# 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_ARM_tensors === + using VULKAN_HPP_RAII_NAMESPACE::TensorARM; + using VULKAN_HPP_RAII_NAMESPACE::TensorViewARM; + + //=== 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; + + //=== VK_KHR_pipeline_binary === + using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR; + using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHRs; + + //=== VK_ARM_data_graph === + using VULKAN_HPP_RAII_NAMESPACE::DataGraphPipelineSessionARM; + + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_RAII_NAMESPACE::ExternalComputeQueueNV; + + //=== VK_EXT_device_generated_commands === + using VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutEXT; + using VULKAN_HPP_RAII_NAMESPACE::IndirectExecutionSetEXT; + + } // namespace VULKAN_HPP_RAII_NAMESPACE +#endif +} // namespace VULKAN_HPP_NAMESPACE + +export namespace std +{ + + //======================================= + //=== HASH specialization for Flags types === + //======================================= + + template + struct hash>; + + //======================================== + //=== HASH specializations for handles === + //======================================== + + //=== VK_VERSION_1_0 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_VERSION_1_1 === + template <> + struct hash; + template <> + struct hash; + + //=== VK_VERSION_1_3 === + template <> + struct hash; + + //=== VK_KHR_surface === + template <> + struct hash; + + //=== VK_KHR_swapchain === + template <> + struct hash; + + //=== VK_KHR_display === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_debug_report === + template <> + struct hash; + + //=== VK_KHR_video_queue === + template <> + struct hash; + template <> + struct hash; + + //=== VK_NVX_binary_import === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_debug_utils === + template <> + struct hash; + + //=== VK_EXT_descriptor_heap === + template <> + struct hash; + + //=== VK_KHR_acceleration_structure === + template <> + struct hash; + + //=== VK_EXT_validation_cache === + template <> + struct hash; + + //=== VK_NV_ray_tracing === + template <> + struct hash; + + //=== VK_INTEL_performance_query === + template <> + struct hash; + + //=== VK_KHR_deferred_host_operations === + template <> + struct hash; + + //=== VK_NV_device_generated_commands === + template <> + struct hash; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + template <> + struct hash; + template <> + struct hash; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + template <> + struct hash; + + //=== VK_ARM_tensors === + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_optical_flow === + template <> + struct hash; + + //=== VK_EXT_shader_object === + template <> + struct hash; + + //=== VK_KHR_pipeline_binary === + template <> + struct hash; + + //=== VK_ARM_data_graph === + template <> + struct hash; + + //=== VK_NV_external_compute_queue === + template <> + struct hash; + + //=== VK_EXT_device_generated_commands === + template <> + struct hash; + template <> + struct hash; + + //======================================== + //=== HASH specializations for structs === + //======================================== + + //=== VK_VERSION_1_0 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_VERSION_1_1 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_VERSION_1_2 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_VERSION_1_3 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_VERSION_1_4 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_surface === + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_swapchain === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_display === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_display_swapchain === + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + template <> + struct hash; + + //=== VK_AMD_rasterization_order === + template <> + struct hash; + + //=== VK_EXT_debug_marker === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_queue === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_decode_queue === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_dedicated_allocation === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_transform_feedback === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NVX_binary_import === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NVX_image_view_handle === + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_encode_h264 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_encode_h265 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_decode_h264 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_AMD_texture_gather_bias_lod === + template <> + struct hash; + + //=== VK_AMD_shader_info === + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_corner_sampled_image === + template <> + struct hash; + + //=== VK_NV_external_memory_capabilities === + template <> + struct hash; + + //=== VK_NV_external_memory === + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_win32_keyed_mutex === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_device_group === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_validation_flags === + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_EXT_astc_decode_mode === + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_keyed_mutex === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_conditional_rendering === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_incremental_present === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_clip_space_w_scaling === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_display_surface_counter === + template <> + struct hash; + + //=== VK_EXT_display_control === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_GOOGLE_display_timing === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NVX_multiview_per_view_attributes === + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_viewport_swizzle === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_discard_rectangles === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_conservative_rasterization === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_depth_clip_enable === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_hdr_metadata === + template <> + struct hash; + template <> + struct hash; + + //=== VK_IMG_relaxed_line_rasterization === + template <> + struct hash; + + //=== VK_KHR_shared_presentable_image === + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_performance_query === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_get_surface_capabilities2 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_get_display_properties2 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_AMD_mixed_attachment_samples === + template <> + struct hash; + + //=== VK_KHR_shader_bfloat16 === + template <> + struct hash; + + //=== VK_EXT_sample_locations === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_blend_operation_advanced === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_fragment_coverage_to_color === + template <> + struct hash; + + //=== VK_KHR_acceleration_structure === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_ray_tracing_pipeline === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_ray_query === + template <> + struct hash; + + //=== VK_NV_framebuffer_mixed_samples === + template <> + struct hash; + + //=== VK_NV_shader_sm_builtins === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_image_drm_format_modifier === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_validation_cache === + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_portability_subset === + template <> + struct hash; + template <> + struct hash; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NV_shading_rate_image === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_ray_tracing === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_representative_fragment_test === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_filter_cubic === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_external_memory_host === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_shader_clock === + template <> + struct hash; + + //=== VK_AMD_pipeline_compiler_control === + template <> + struct hash; + + //=== VK_AMD_shader_core_properties === + template <> + struct hash; + + //=== VK_KHR_video_decode_h265 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_AMD_memory_overallocation_behavior === + template <> + struct hash; + + //=== VK_EXT_vertex_attribute_divisor === + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_frame_token === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_mesh_shader === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_shader_image_footprint === + template <> + struct hash; + + //=== VK_NV_scissor_exclusive === + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_device_diagnostic_checkpoints === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_present_timing === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_INTEL_shader_integer_functions2 === + template <> + struct hash; + + //=== VK_INTEL_performance_query === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_pci_bus_info === + template <> + struct hash; + + //=== VK_AMD_display_native_hdr === + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_fragment_density_map === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_fragment_shading_rate === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_AMD_shader_core_properties2 === + template <> + struct hash; + + //=== VK_AMD_device_coherent_memory === + template <> + struct hash; + + //=== VK_EXT_shader_image_atomic_int64 === + template <> + struct hash; + + //=== VK_KHR_shader_quad_control === + template <> + struct hash; + + //=== VK_EXT_memory_budget === + template <> + struct hash; + + //=== VK_EXT_memory_priority === + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_surface_protected_capabilities === + template <> + struct hash; + + //=== VK_NV_dedicated_allocation_image_aliasing === + template <> + struct hash; + + //=== VK_EXT_buffer_device_address === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_validation_features === + template <> + struct hash; + + //=== VK_KHR_present_wait === + template <> + struct hash; + + //=== VK_NV_cooperative_matrix === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_coverage_reduction_mode === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_fragment_shader_interlock === + template <> + struct hash; + + //=== VK_EXT_ycbcr_image_arrays === + template <> + struct hash; + + //=== VK_EXT_provoking_vertex === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + template <> + struct hash; + + //=== VK_EXT_shader_atomic_float === + template <> + struct hash; + + //=== VK_EXT_extended_dynamic_state === + template <> + struct hash; + + //=== VK_KHR_pipeline_executable_properties === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_map_memory_placed === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_shader_atomic_float2 === + template <> + struct hash; + + //=== VK_NV_device_generated_commands === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_inherited_viewport_scissor === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_texel_buffer_alignment === + template <> + struct hash; + + //=== VK_QCOM_render_pass_transform === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_depth_bias_control === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_device_memory_report === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_custom_border_color === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_texture_compression_astc_3d === + template <> + struct hash; + + //=== VK_KHR_pipeline_library === + template <> + struct hash; + + //=== VK_NV_present_barrier === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_present_id === + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_encode_queue === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_device_diagnostics_config === + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_low_latency === + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_descriptor_buffer === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_graphics_pipeline_library === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_AMD_shader_early_and_late_fragment_tests === + template <> + struct hash; + + //=== VK_KHR_fragment_shader_barycentric === + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_shader_subgroup_uniform_control_flow === + template <> + struct hash; + + //=== VK_NV_fragment_shading_rate_enums === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_ray_tracing_motion_blur === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_mesh_shader === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_ycbcr_2plane_444_formats === + template <> + struct hash; + + //=== VK_EXT_fragment_density_map2 === + template <> + struct hash; + template <> + struct hash; + + //=== VK_QCOM_rotated_copy_commands === + template <> + struct hash; + + //=== VK_KHR_workgroup_memory_explicit_layout === + template <> + struct hash; + + //=== VK_EXT_image_compression_control === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_attachment_feedback_loop_layout === + template <> + struct hash; + + //=== VK_EXT_4444_formats === + template <> + struct hash; + + //=== VK_EXT_device_fault === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_rgba10x6_formats === + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_vertex_input_dynamic_state === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_physical_device_drm === + template <> + struct hash; + + //=== VK_EXT_device_address_binding_report === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_depth_clip_control === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_primitive_topology_list_restart === + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_HUAWEI_invocation_mask === + template <> + struct hash; + + //=== VK_NV_external_memory_rdma === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_pipeline_properties === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_frame_boundary === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_multisampled_render_to_single_sampled === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_extended_dynamic_state2 === + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_color_write_enable === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_primitives_generated_query === + template <> + struct hash; + + //=== VK_KHR_ray_tracing_maintenance1 === + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_shader_untyped_pointers === + template <> + struct hash; + + //=== VK_VALVE_video_encode_rgb_conversion === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_image_view_min_lod === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_multi_draw === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_image_2d_view_of_3d === + template <> + struct hash; + + //=== VK_EXT_shader_tile_image === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_opacity_micromap === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_displacement_micromap === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_HUAWEI_cluster_culling_shader === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_border_color_swizzle === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_pageable_device_local_memory === + template <> + struct hash; + + //=== VK_ARM_shader_core_properties === + template <> + struct hash; + + //=== VK_ARM_scheduling_controls === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_image_sliced_view_of_3d === + template <> + struct hash; + template <> + struct hash; + + //=== VK_VALVE_descriptor_set_host_mapping === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_non_seamless_cube_map === + template <> + struct hash; + + //=== VK_ARM_render_pass_striped === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_copy_memory_indirect === + template <> + struct hash; + + //=== VK_NV_memory_decompression === + template <> + struct hash; + + //=== VK_NV_device_generated_commands_compute === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_ray_tracing_linear_swept_spheres === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_linear_color_attachment === + template <> + struct hash; + + //=== VK_KHR_shader_maximal_reconvergence === + template <> + struct hash; + + //=== VK_EXT_image_compression_control_swapchain === + template <> + struct hash; + + //=== VK_QCOM_image_processing === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_nested_command_buffer === + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_external_memory_acquire_unmodified === + template <> + struct hash; + + //=== VK_EXT_extended_dynamic_state3 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_subpass_merge_feedback === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_LUNARG_direct_driver_loading === + template <> + struct hash; + template <> + struct hash; + + //=== VK_ARM_tensors === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_shader_module_identifier === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_rasterization_order_attachment_access === + template <> + struct hash; + + //=== VK_NV_optical_flow === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_legacy_dithering === + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_format_resolve === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + //=== VK_AMD_anti_lag === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_dense_geometry_format === + template <> + struct hash; + template <> + struct hash; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_present_id2 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_present_wait2 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_ray_tracing_position_fetch === + template <> + struct hash; + + //=== VK_EXT_shader_object === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_pipeline_binary === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_QCOM_tile_properties === + template <> + struct hash; + template <> + struct hash; + + //=== VK_SEC_amigo_profiling === + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_surface_maintenance1 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_swapchain_maintenance1 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_QCOM_multiview_per_view_viewports === + template <> + struct hash; + + //=== VK_NV_ray_tracing_invocation_reorder === + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_cooperative_vector === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_extended_sparse_address_space === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_mutable_descriptor_type === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_legacy_vertex_attributes === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_layer_settings === + template <> + struct hash; + template <> + struct hash; + + //=== VK_ARM_shader_core_builtins === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_pipeline_library_group_handles === + template <> + struct hash; + + //=== VK_EXT_dynamic_rendering_unused_attachments === + template <> + struct hash; + + //=== VK_KHR_internally_synchronized_queues === + template <> + struct hash; + + //=== VK_NV_low_latency2 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_cooperative_matrix === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_ARM_data_graph === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_QCOM_multiview_per_view_render_areas === + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_compute_shader_derivatives === + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_decode_av1 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_encode_av1 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_decode_vp9 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_maintenance1 === + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_per_stage_descriptor_set === + template <> + struct hash; + + //=== VK_QCOM_image_processing2 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_QCOM_filter_cubic_weights === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_QCOM_ycbcr_degamma === + template <> + struct hash; + template <> + struct hash; + + //=== VK_QCOM_filter_cubic_clamp === + template <> + struct hash; + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + template <> + struct hash; + + //=== VK_KHR_unified_image_layouts === + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_MSFT_layered_driver === + template <> + struct hash; + + //=== VK_KHR_calibrated_timestamps === + template <> + struct hash; + + //=== VK_KHR_maintenance6 === + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_descriptor_pool_overallocation === + template <> + struct hash; + + //=== VK_QCOM_tile_memory_heap === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_copy_memory_indirect === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_memory_decompression === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_display_stereo === + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_encode_intra_refresh === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_encode_quantization_map === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_raw_access_chains === + template <> + struct hash; + + //=== VK_NV_external_compute_queue === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_shader_relaxed_extended_instruction === + template <> + struct hash; + + //=== VK_NV_command_buffer_inheritance === + template <> + struct hash; + + //=== VK_KHR_maintenance7 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_shader_atomic_float16_vector === + template <> + struct hash; + + //=== VK_EXT_shader_replicated_composites === + template <> + struct hash; + + //=== VK_EXT_shader_float8 === + template <> + struct hash; + + //=== VK_NV_ray_tracing_validation === + template <> + struct hash; + + //=== VK_NV_cluster_acceleration_structure === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_partitioned_acceleration_structure === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_device_generated_commands === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_maintenance8 === + template <> + struct hash; + template <> + struct hash; + + //=== VK_MESA_image_alignment_control === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_shader_fma === + template <> + struct hash; + + //=== VK_NV_push_constant_bank === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_ray_tracing_invocation_reorder === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_depth_clamp_control === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_maintenance9 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_video_maintenance2 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + template <> + struct hash; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_HUAWEI_hdr_vivid === + template <> + struct hash; + template <> + struct hash; + + //=== VK_NV_cooperative_matrix2 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_ARM_pipeline_opacity_micromap === + template <> + struct hash; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_depth_clamp_zero_one === + template <> + struct hash; + + //=== VK_ARM_performance_counters_by_region === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_vertex_attribute_robustness === + template <> + struct hash; + + //=== VK_ARM_format_pack === + template <> + struct hash; + + //=== VK_VALVE_fragment_density_map_layered === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_robustness2 === + template <> + struct hash; + template <> + struct hash; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_present_metering === + template <> + struct hash; + template <> + struct hash; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_fragment_density_map_offset === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_zero_initialize_device_memory === + template <> + struct hash; + + //=== VK_KHR_present_mode_fifo_latest_ready === + template <> + struct hash; + + //=== VK_EXT_shader_64bit_indexing === + template <> + struct hash; + + //=== VK_EXT_custom_resolve === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_QCOM_data_graph_model === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_KHR_maintenance10 === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_shader_long_vector === + template <> + struct hash; + template <> + struct hash; + + //=== VK_SEC_pipeline_cache_incremental_mode === + template <> + struct hash; + + //=== VK_EXT_shader_uniform_buffer_unsized_array === + template <> + struct hash; + + //=== VK_NV_compute_occupancy_priority === + template <> + struct hash; + template <> + struct hash; + + //=== VK_EXT_shader_subgroup_partitioned === + template <> + struct hash; + + //================================================================= + //=== Required exports for VULKAN_HPP_NAMESPACE::StructureChain === + //================================================================= + +#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + using std::tuple_element; + using std::tuple_size; +#endif +} // namespace std + +export +{ + // This VkFlags type is used as part of a bitfield in some structures. + // As it can't be mimicked by vk-data types, we need to export just that. + using ::VkGeometryInstanceFlagsKHR; + + //================== + //=== PFN TYPEs === + //================== + + //=== VK_VERSION_1_0 === + using ::PFN_vkAllocateCommandBuffers; + using ::PFN_vkAllocateDescriptorSets; + using ::PFN_vkAllocateMemory; + using ::PFN_vkBeginCommandBuffer; + using ::PFN_vkBindBufferMemory; + using ::PFN_vkBindImageMemory; + using ::PFN_vkCmdBeginQuery; + using ::PFN_vkCmdBeginRenderPass; + using ::PFN_vkCmdBindDescriptorSets; + using ::PFN_vkCmdBindIndexBuffer; + using ::PFN_vkCmdBindPipeline; + using ::PFN_vkCmdBindVertexBuffers; + using ::PFN_vkCmdBlitImage; + using ::PFN_vkCmdClearAttachments; + using ::PFN_vkCmdClearColorImage; + using ::PFN_vkCmdClearDepthStencilImage; + using ::PFN_vkCmdCopyBuffer; + using ::PFN_vkCmdCopyBufferToImage; + using ::PFN_vkCmdCopyImage; + using ::PFN_vkCmdCopyImageToBuffer; + using ::PFN_vkCmdCopyQueryPoolResults; + using ::PFN_vkCmdDispatch; + using ::PFN_vkCmdDispatchIndirect; + using ::PFN_vkCmdDraw; + using ::PFN_vkCmdDrawIndexed; + using ::PFN_vkCmdDrawIndexedIndirect; + using ::PFN_vkCmdDrawIndirect; + using ::PFN_vkCmdEndQuery; + using ::PFN_vkCmdEndRenderPass; + using ::PFN_vkCmdExecuteCommands; + using ::PFN_vkCmdFillBuffer; + using ::PFN_vkCmdNextSubpass; + using ::PFN_vkCmdPipelineBarrier; + using ::PFN_vkCmdPushConstants; + using ::PFN_vkCmdResetEvent; + using ::PFN_vkCmdResetQueryPool; + using ::PFN_vkCmdResolveImage; + using ::PFN_vkCmdSetBlendConstants; + using ::PFN_vkCmdSetDepthBias; + using ::PFN_vkCmdSetDepthBounds; + using ::PFN_vkCmdSetEvent; + using ::PFN_vkCmdSetLineWidth; + using ::PFN_vkCmdSetScissor; + using ::PFN_vkCmdSetStencilCompareMask; + using ::PFN_vkCmdSetStencilReference; + using ::PFN_vkCmdSetStencilWriteMask; + using ::PFN_vkCmdSetViewport; + using ::PFN_vkCmdUpdateBuffer; + using ::PFN_vkCmdWaitEvents; + using ::PFN_vkCmdWriteTimestamp; + using ::PFN_vkCreateBuffer; + using ::PFN_vkCreateBufferView; + using ::PFN_vkCreateCommandPool; + using ::PFN_vkCreateComputePipelines; + using ::PFN_vkCreateDescriptorPool; + using ::PFN_vkCreateDescriptorSetLayout; + using ::PFN_vkCreateDevice; + using ::PFN_vkCreateEvent; + using ::PFN_vkCreateFence; + using ::PFN_vkCreateFramebuffer; + using ::PFN_vkCreateGraphicsPipelines; + using ::PFN_vkCreateImage; + using ::PFN_vkCreateImageView; + using ::PFN_vkCreateInstance; + using ::PFN_vkCreatePipelineCache; + using ::PFN_vkCreatePipelineLayout; + using ::PFN_vkCreateQueryPool; + using ::PFN_vkCreateRenderPass; + using ::PFN_vkCreateSampler; + using ::PFN_vkCreateSemaphore; + using ::PFN_vkCreateShaderModule; + using ::PFN_vkDestroyBuffer; + using ::PFN_vkDestroyBufferView; + using ::PFN_vkDestroyCommandPool; + using ::PFN_vkDestroyDescriptorPool; + using ::PFN_vkDestroyDescriptorSetLayout; + using ::PFN_vkDestroyDevice; + using ::PFN_vkDestroyEvent; + using ::PFN_vkDestroyFence; + using ::PFN_vkDestroyFramebuffer; + using ::PFN_vkDestroyImage; + using ::PFN_vkDestroyImageView; + using ::PFN_vkDestroyInstance; + using ::PFN_vkDestroyPipeline; + using ::PFN_vkDestroyPipelineCache; + using ::PFN_vkDestroyPipelineLayout; + using ::PFN_vkDestroyQueryPool; + using ::PFN_vkDestroyRenderPass; + using ::PFN_vkDestroySampler; + using ::PFN_vkDestroySemaphore; + using ::PFN_vkDestroyShaderModule; + using ::PFN_vkDeviceWaitIdle; + using ::PFN_vkEndCommandBuffer; + using ::PFN_vkEnumerateDeviceExtensionProperties; + using ::PFN_vkEnumerateDeviceLayerProperties; + using ::PFN_vkEnumerateInstanceExtensionProperties; + using ::PFN_vkEnumerateInstanceLayerProperties; + using ::PFN_vkEnumeratePhysicalDevices; + using ::PFN_vkFlushMappedMemoryRanges; + using ::PFN_vkFreeCommandBuffers; + using ::PFN_vkFreeDescriptorSets; + using ::PFN_vkFreeMemory; + using ::PFN_vkGetBufferMemoryRequirements; + using ::PFN_vkGetDeviceMemoryCommitment; + using ::PFN_vkGetDeviceProcAddr; + using ::PFN_vkGetDeviceQueue; + using ::PFN_vkGetEventStatus; + using ::PFN_vkGetFenceStatus; + using ::PFN_vkGetImageMemoryRequirements; + using ::PFN_vkGetImageSparseMemoryRequirements; + using ::PFN_vkGetImageSubresourceLayout; + using ::PFN_vkGetInstanceProcAddr; + using ::PFN_vkGetPhysicalDeviceFeatures; + using ::PFN_vkGetPhysicalDeviceFormatProperties; + using ::PFN_vkGetPhysicalDeviceImageFormatProperties; + using ::PFN_vkGetPhysicalDeviceMemoryProperties; + using ::PFN_vkGetPhysicalDeviceProperties; + using ::PFN_vkGetPhysicalDeviceQueueFamilyProperties; + using ::PFN_vkGetPhysicalDeviceSparseImageFormatProperties; + using ::PFN_vkGetPipelineCacheData; + using ::PFN_vkGetQueryPoolResults; + using ::PFN_vkGetRenderAreaGranularity; + using ::PFN_vkInvalidateMappedMemoryRanges; + using ::PFN_vkMapMemory; + using ::PFN_vkMergePipelineCaches; + using ::PFN_vkQueueBindSparse; + using ::PFN_vkQueueSubmit; + using ::PFN_vkQueueWaitIdle; + using ::PFN_vkResetCommandBuffer; + using ::PFN_vkResetCommandPool; + using ::PFN_vkResetDescriptorPool; + using ::PFN_vkResetEvent; + using ::PFN_vkResetFences; + using ::PFN_vkSetEvent; + using ::PFN_vkUnmapMemory; + using ::PFN_vkUpdateDescriptorSets; + using ::PFN_vkWaitForFences; + + //=== VK_VERSION_1_1 === + using ::PFN_vkBindBufferMemory2; + using ::PFN_vkBindImageMemory2; + using ::PFN_vkCmdDispatchBase; + using ::PFN_vkCmdSetDeviceMask; + using ::PFN_vkCreateDescriptorUpdateTemplate; + using ::PFN_vkCreateSamplerYcbcrConversion; + using ::PFN_vkDestroyDescriptorUpdateTemplate; + using ::PFN_vkDestroySamplerYcbcrConversion; + using ::PFN_vkEnumerateInstanceVersion; + using ::PFN_vkEnumeratePhysicalDeviceGroups; + using ::PFN_vkGetBufferMemoryRequirements2; + using ::PFN_vkGetDescriptorSetLayoutSupport; + using ::PFN_vkGetDeviceGroupPeerMemoryFeatures; + using ::PFN_vkGetDeviceQueue2; + using ::PFN_vkGetImageMemoryRequirements2; + using ::PFN_vkGetImageSparseMemoryRequirements2; + using ::PFN_vkGetPhysicalDeviceExternalBufferProperties; + using ::PFN_vkGetPhysicalDeviceExternalFenceProperties; + using ::PFN_vkGetPhysicalDeviceExternalSemaphoreProperties; + using ::PFN_vkGetPhysicalDeviceFeatures2; + using ::PFN_vkGetPhysicalDeviceFormatProperties2; + using ::PFN_vkGetPhysicalDeviceImageFormatProperties2; + using ::PFN_vkGetPhysicalDeviceMemoryProperties2; + using ::PFN_vkGetPhysicalDeviceProperties2; + using ::PFN_vkGetPhysicalDeviceQueueFamilyProperties2; + using ::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2; + using ::PFN_vkTrimCommandPool; + using ::PFN_vkUpdateDescriptorSetWithTemplate; + + //=== VK_VERSION_1_2 === + using ::PFN_vkCmdBeginRenderPass2; + using ::PFN_vkCmdDrawIndexedIndirectCount; + using ::PFN_vkCmdDrawIndirectCount; + using ::PFN_vkCmdEndRenderPass2; + using ::PFN_vkCmdNextSubpass2; + using ::PFN_vkCreateRenderPass2; + using ::PFN_vkGetBufferDeviceAddress; + using ::PFN_vkGetBufferOpaqueCaptureAddress; + using ::PFN_vkGetDeviceMemoryOpaqueCaptureAddress; + using ::PFN_vkGetSemaphoreCounterValue; + using ::PFN_vkResetQueryPool; + using ::PFN_vkSignalSemaphore; + using ::PFN_vkWaitSemaphores; + + //=== VK_VERSION_1_3 === + using ::PFN_vkCmdBeginRendering; + using ::PFN_vkCmdBindVertexBuffers2; + using ::PFN_vkCmdBlitImage2; + using ::PFN_vkCmdCopyBuffer2; + using ::PFN_vkCmdCopyBufferToImage2; + using ::PFN_vkCmdCopyImage2; + using ::PFN_vkCmdCopyImageToBuffer2; + using ::PFN_vkCmdEndRendering; + using ::PFN_vkCmdPipelineBarrier2; + using ::PFN_vkCmdResetEvent2; + using ::PFN_vkCmdResolveImage2; + using ::PFN_vkCmdSetCullMode; + using ::PFN_vkCmdSetDepthBiasEnable; + using ::PFN_vkCmdSetDepthBoundsTestEnable; + using ::PFN_vkCmdSetDepthCompareOp; + using ::PFN_vkCmdSetDepthTestEnable; + using ::PFN_vkCmdSetDepthWriteEnable; + using ::PFN_vkCmdSetEvent2; + using ::PFN_vkCmdSetFrontFace; + using ::PFN_vkCmdSetPrimitiveRestartEnable; + using ::PFN_vkCmdSetPrimitiveTopology; + using ::PFN_vkCmdSetRasterizerDiscardEnable; + using ::PFN_vkCmdSetScissorWithCount; + using ::PFN_vkCmdSetStencilOp; + using ::PFN_vkCmdSetStencilTestEnable; + using ::PFN_vkCmdSetViewportWithCount; + using ::PFN_vkCmdWaitEvents2; + using ::PFN_vkCmdWriteTimestamp2; + using ::PFN_vkCreatePrivateDataSlot; + using ::PFN_vkDestroyPrivateDataSlot; + using ::PFN_vkGetDeviceBufferMemoryRequirements; + using ::PFN_vkGetDeviceImageMemoryRequirements; + using ::PFN_vkGetDeviceImageSparseMemoryRequirements; + using ::PFN_vkGetPhysicalDeviceToolProperties; + using ::PFN_vkGetPrivateData; + using ::PFN_vkQueueSubmit2; + using ::PFN_vkSetPrivateData; + + //=== VK_VERSION_1_4 === + using ::PFN_vkCmdBindDescriptorSets2; + using ::PFN_vkCmdBindIndexBuffer2; + using ::PFN_vkCmdPushConstants2; + using ::PFN_vkCmdPushDescriptorSet; + using ::PFN_vkCmdPushDescriptorSet2; + using ::PFN_vkCmdPushDescriptorSetWithTemplate; + using ::PFN_vkCmdPushDescriptorSetWithTemplate2; + using ::PFN_vkCmdSetLineStipple; + using ::PFN_vkCmdSetRenderingAttachmentLocations; + using ::PFN_vkCmdSetRenderingInputAttachmentIndices; + using ::PFN_vkCopyImageToImage; + using ::PFN_vkCopyImageToMemory; + using ::PFN_vkCopyMemoryToImage; + using ::PFN_vkGetDeviceImageSubresourceLayout; + using ::PFN_vkGetImageSubresourceLayout2; + using ::PFN_vkGetRenderingAreaGranularity; + using ::PFN_vkMapMemory2; + using ::PFN_vkTransitionImageLayout; + using ::PFN_vkUnmapMemory2; + + //=== VK_KHR_surface === + using ::PFN_vkDestroySurfaceKHR; + using ::PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR; + using ::PFN_vkGetPhysicalDeviceSurfaceFormatsKHR; + using ::PFN_vkGetPhysicalDeviceSurfacePresentModesKHR; + using ::PFN_vkGetPhysicalDeviceSurfaceSupportKHR; + + //=== VK_KHR_swapchain === + using ::PFN_vkAcquireNextImage2KHR; + using ::PFN_vkAcquireNextImageKHR; + using ::PFN_vkCreateSwapchainKHR; + using ::PFN_vkDestroySwapchainKHR; + using ::PFN_vkGetDeviceGroupPresentCapabilitiesKHR; + using ::PFN_vkGetDeviceGroupSurfacePresentModesKHR; + using ::PFN_vkGetPhysicalDevicePresentRectanglesKHR; + using ::PFN_vkGetSwapchainImagesKHR; + using ::PFN_vkQueuePresentKHR; + + //=== VK_KHR_display === + using ::PFN_vkCreateDisplayModeKHR; + using ::PFN_vkCreateDisplayPlaneSurfaceKHR; + using ::PFN_vkGetDisplayModePropertiesKHR; + using ::PFN_vkGetDisplayPlaneCapabilitiesKHR; + using ::PFN_vkGetDisplayPlaneSupportedDisplaysKHR; + using ::PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR; + using ::PFN_vkGetPhysicalDeviceDisplayPropertiesKHR; + + //=== VK_KHR_display_swapchain === + using ::PFN_vkCreateSharedSwapchainsKHR; + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + using ::PFN_vkCreateXlibSurfaceKHR; + using ::PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + using ::PFN_vkCreateXcbSurfaceKHR; + using ::PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + using ::PFN_vkCreateWaylandSurfaceKHR; + using ::PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + using ::PFN_vkCreateAndroidSurfaceKHR; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + using ::PFN_vkCreateWin32SurfaceKHR; + using ::PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + using ::PFN_vkCreateDebugReportCallbackEXT; + using ::PFN_vkDebugReportMessageEXT; + using ::PFN_vkDestroyDebugReportCallbackEXT; + + //=== VK_EXT_debug_marker === + using ::PFN_vkCmdDebugMarkerBeginEXT; + using ::PFN_vkCmdDebugMarkerEndEXT; + using ::PFN_vkCmdDebugMarkerInsertEXT; + using ::PFN_vkDebugMarkerSetObjectNameEXT; + using ::PFN_vkDebugMarkerSetObjectTagEXT; + + //=== VK_KHR_video_queue === + using ::PFN_vkBindVideoSessionMemoryKHR; + using ::PFN_vkCmdBeginVideoCodingKHR; + using ::PFN_vkCmdControlVideoCodingKHR; + using ::PFN_vkCmdEndVideoCodingKHR; + using ::PFN_vkCreateVideoSessionKHR; + using ::PFN_vkCreateVideoSessionParametersKHR; + using ::PFN_vkDestroyVideoSessionKHR; + using ::PFN_vkDestroyVideoSessionParametersKHR; + using ::PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR; + using ::PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR; + using ::PFN_vkGetVideoSessionMemoryRequirementsKHR; + using ::PFN_vkUpdateVideoSessionParametersKHR; + + //=== VK_KHR_video_decode_queue === + using ::PFN_vkCmdDecodeVideoKHR; + + //=== VK_EXT_transform_feedback === + using ::PFN_vkCmdBeginQueryIndexedEXT; + using ::PFN_vkCmdBeginTransformFeedbackEXT; + using ::PFN_vkCmdBindTransformFeedbackBuffersEXT; + using ::PFN_vkCmdDrawIndirectByteCountEXT; + using ::PFN_vkCmdEndQueryIndexedEXT; + using ::PFN_vkCmdEndTransformFeedbackEXT; + + //=== VK_NVX_binary_import === + using ::PFN_vkCmdCuLaunchKernelNVX; + using ::PFN_vkCreateCuFunctionNVX; + using ::PFN_vkCreateCuModuleNVX; + using ::PFN_vkDestroyCuFunctionNVX; + using ::PFN_vkDestroyCuModuleNVX; + + //=== VK_NVX_image_view_handle === + using ::PFN_vkGetDeviceCombinedImageSamplerIndexNVX; + using ::PFN_vkGetImageViewAddressNVX; + using ::PFN_vkGetImageViewHandle64NVX; + using ::PFN_vkGetImageViewHandleNVX; + + //=== VK_AMD_draw_indirect_count === + using ::PFN_vkCmdDrawIndexedIndirectCountAMD; + using ::PFN_vkCmdDrawIndirectCountAMD; + + //=== VK_AMD_shader_info === + using ::PFN_vkGetShaderInfoAMD; + + //=== VK_KHR_dynamic_rendering === + using ::PFN_vkCmdBeginRenderingKHR; + using ::PFN_vkCmdEndRenderingKHR; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + using ::PFN_vkCreateStreamDescriptorSurfaceGGP; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + using ::PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + using ::PFN_vkGetMemoryWin32HandleNV; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_get_physical_device_properties2 === + using ::PFN_vkGetPhysicalDeviceFeatures2KHR; + using ::PFN_vkGetPhysicalDeviceFormatProperties2KHR; + using ::PFN_vkGetPhysicalDeviceImageFormatProperties2KHR; + using ::PFN_vkGetPhysicalDeviceMemoryProperties2KHR; + using ::PFN_vkGetPhysicalDeviceProperties2KHR; + using ::PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR; + using ::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR; + + //=== VK_KHR_device_group === + using ::PFN_vkCmdDispatchBaseKHR; + using ::PFN_vkCmdSetDeviceMaskKHR; + using ::PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR; + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + using ::PFN_vkCreateViSurfaceNN; +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_maintenance1 === + using ::PFN_vkTrimCommandPoolKHR; + + //=== VK_KHR_device_group_creation === + using ::PFN_vkEnumeratePhysicalDeviceGroupsKHR; + + //=== VK_KHR_external_memory_capabilities === + using ::PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + using ::PFN_vkGetMemoryWin32HandleKHR; + using ::PFN_vkGetMemoryWin32HandlePropertiesKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + using ::PFN_vkGetMemoryFdKHR; + using ::PFN_vkGetMemoryFdPropertiesKHR; + + //=== VK_KHR_external_semaphore_capabilities === + using ::PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + using ::PFN_vkGetSemaphoreWin32HandleKHR; + using ::PFN_vkImportSemaphoreWin32HandleKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + using ::PFN_vkGetSemaphoreFdKHR; + using ::PFN_vkImportSemaphoreFdKHR; + + //=== VK_KHR_push_descriptor === + using ::PFN_vkCmdPushDescriptorSetKHR; + using ::PFN_vkCmdPushDescriptorSetWithTemplateKHR; + + //=== VK_EXT_conditional_rendering === + using ::PFN_vkCmdBeginConditionalRenderingEXT; + using ::PFN_vkCmdEndConditionalRenderingEXT; + + //=== VK_KHR_descriptor_update_template === + using ::PFN_vkCreateDescriptorUpdateTemplateKHR; + using ::PFN_vkDestroyDescriptorUpdateTemplateKHR; + using ::PFN_vkUpdateDescriptorSetWithTemplateKHR; + + //=== VK_NV_clip_space_w_scaling === + using ::PFN_vkCmdSetViewportWScalingNV; + + //=== VK_EXT_direct_mode_display === + using ::PFN_vkReleaseDisplayEXT; + +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + using ::PFN_vkAcquireXlibDisplayEXT; + using ::PFN_vkGetRandROutputDisplayEXT; +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + using ::PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT; + + //=== VK_EXT_display_control === + using ::PFN_vkDisplayPowerControlEXT; + using ::PFN_vkGetSwapchainCounterEXT; + using ::PFN_vkRegisterDeviceEventEXT; + using ::PFN_vkRegisterDisplayEventEXT; + + //=== VK_GOOGLE_display_timing === + using ::PFN_vkGetPastPresentationTimingGOOGLE; + using ::PFN_vkGetRefreshCycleDurationGOOGLE; + + //=== VK_EXT_discard_rectangles === + using ::PFN_vkCmdSetDiscardRectangleEnableEXT; + using ::PFN_vkCmdSetDiscardRectangleEXT; + using ::PFN_vkCmdSetDiscardRectangleModeEXT; + + //=== VK_EXT_hdr_metadata === + using ::PFN_vkSetHdrMetadataEXT; + + //=== VK_KHR_create_renderpass2 === + using ::PFN_vkCmdBeginRenderPass2KHR; + using ::PFN_vkCmdEndRenderPass2KHR; + using ::PFN_vkCmdNextSubpass2KHR; + using ::PFN_vkCreateRenderPass2KHR; + + //=== VK_KHR_shared_presentable_image === + using ::PFN_vkGetSwapchainStatusKHR; + + //=== VK_KHR_external_fence_capabilities === + using ::PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + using ::PFN_vkGetFenceWin32HandleKHR; + using ::PFN_vkImportFenceWin32HandleKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + using ::PFN_vkGetFenceFdKHR; + using ::PFN_vkImportFenceFdKHR; + + //=== VK_KHR_performance_query === + using ::PFN_vkAcquireProfilingLockKHR; + using ::PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR; + using ::PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR; + using ::PFN_vkReleaseProfilingLockKHR; + + //=== VK_KHR_get_surface_capabilities2 === + using ::PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR; + using ::PFN_vkGetPhysicalDeviceSurfaceFormats2KHR; + + //=== VK_KHR_get_display_properties2 === + using ::PFN_vkGetDisplayModeProperties2KHR; + using ::PFN_vkGetDisplayPlaneCapabilities2KHR; + using ::PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR; + using ::PFN_vkGetPhysicalDeviceDisplayProperties2KHR; + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + using ::PFN_vkCreateIOSSurfaceMVK; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + using ::PFN_vkCreateMacOSSurfaceMVK; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + using ::PFN_vkCmdBeginDebugUtilsLabelEXT; + using ::PFN_vkCmdEndDebugUtilsLabelEXT; + using ::PFN_vkCmdInsertDebugUtilsLabelEXT; + using ::PFN_vkCreateDebugUtilsMessengerEXT; + using ::PFN_vkDestroyDebugUtilsMessengerEXT; + using ::PFN_vkQueueBeginDebugUtilsLabelEXT; + using ::PFN_vkQueueEndDebugUtilsLabelEXT; + using ::PFN_vkQueueInsertDebugUtilsLabelEXT; + using ::PFN_vkSetDebugUtilsObjectNameEXT; + using ::PFN_vkSetDebugUtilsObjectTagEXT; + using ::PFN_vkSubmitDebugUtilsMessageEXT; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + using ::PFN_vkGetAndroidHardwareBufferPropertiesANDROID; + using ::PFN_vkGetMemoryAndroidHardwareBufferANDROID; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + using ::PFN_vkCmdDispatchGraphAMDX; + using ::PFN_vkCmdDispatchGraphIndirectAMDX; + using ::PFN_vkCmdDispatchGraphIndirectCountAMDX; + using ::PFN_vkCmdInitializeGraphScratchMemoryAMDX; + using ::PFN_vkCreateExecutionGraphPipelinesAMDX; + using ::PFN_vkGetExecutionGraphPipelineNodeIndexAMDX; + using ::PFN_vkGetExecutionGraphPipelineScratchSizeAMDX; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + using ::PFN_vkCmdBindResourceHeapEXT; + using ::PFN_vkCmdBindSamplerHeapEXT; + using ::PFN_vkCmdPushDataEXT; + using ::PFN_vkGetImageOpaqueCaptureDataEXT; + using ::PFN_vkGetPhysicalDeviceDescriptorSizeEXT; + using ::PFN_vkGetTensorOpaqueCaptureDataARM; + using ::PFN_vkRegisterCustomBorderColorEXT; + using ::PFN_vkUnregisterCustomBorderColorEXT; + using ::PFN_vkWriteResourceDescriptorsEXT; + using ::PFN_vkWriteSamplerDescriptorsEXT; + + //=== VK_EXT_sample_locations === + using ::PFN_vkCmdSetSampleLocationsEXT; + using ::PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT; + + //=== VK_KHR_get_memory_requirements2 === + using ::PFN_vkGetBufferMemoryRequirements2KHR; + using ::PFN_vkGetImageMemoryRequirements2KHR; + using ::PFN_vkGetImageSparseMemoryRequirements2KHR; + + //=== VK_KHR_acceleration_structure === + using ::PFN_vkBuildAccelerationStructuresKHR; + using ::PFN_vkCmdBuildAccelerationStructuresIndirectKHR; + using ::PFN_vkCmdBuildAccelerationStructuresKHR; + using ::PFN_vkCmdCopyAccelerationStructureKHR; + using ::PFN_vkCmdCopyAccelerationStructureToMemoryKHR; + using ::PFN_vkCmdCopyMemoryToAccelerationStructureKHR; + using ::PFN_vkCmdWriteAccelerationStructuresPropertiesKHR; + using ::PFN_vkCopyAccelerationStructureKHR; + using ::PFN_vkCopyAccelerationStructureToMemoryKHR; + using ::PFN_vkCopyMemoryToAccelerationStructureKHR; + using ::PFN_vkCreateAccelerationStructureKHR; + using ::PFN_vkDestroyAccelerationStructureKHR; + using ::PFN_vkGetAccelerationStructureBuildSizesKHR; + using ::PFN_vkGetAccelerationStructureDeviceAddressKHR; + using ::PFN_vkGetDeviceAccelerationStructureCompatibilityKHR; + using ::PFN_vkWriteAccelerationStructuresPropertiesKHR; + + //=== VK_KHR_ray_tracing_pipeline === + using ::PFN_vkCmdSetRayTracingPipelineStackSizeKHR; + using ::PFN_vkCmdTraceRaysIndirectKHR; + using ::PFN_vkCmdTraceRaysKHR; + using ::PFN_vkCreateRayTracingPipelinesKHR; + using ::PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR; + using ::PFN_vkGetRayTracingShaderGroupHandlesKHR; + using ::PFN_vkGetRayTracingShaderGroupStackSizeKHR; + + //=== VK_KHR_sampler_ycbcr_conversion === + using ::PFN_vkCreateSamplerYcbcrConversionKHR; + using ::PFN_vkDestroySamplerYcbcrConversionKHR; + + //=== VK_KHR_bind_memory2 === + using ::PFN_vkBindBufferMemory2KHR; + using ::PFN_vkBindImageMemory2KHR; + + //=== VK_EXT_image_drm_format_modifier === + using ::PFN_vkGetImageDrmFormatModifierPropertiesEXT; + + //=== VK_EXT_validation_cache === + using ::PFN_vkCreateValidationCacheEXT; + using ::PFN_vkDestroyValidationCacheEXT; + using ::PFN_vkGetValidationCacheDataEXT; + using ::PFN_vkMergeValidationCachesEXT; + + //=== VK_NV_shading_rate_image === + using ::PFN_vkCmdBindShadingRateImageNV; + using ::PFN_vkCmdSetCoarseSampleOrderNV; + using ::PFN_vkCmdSetViewportShadingRatePaletteNV; + + //=== VK_NV_ray_tracing === + using ::PFN_vkBindAccelerationStructureMemoryNV; + using ::PFN_vkCmdBuildAccelerationStructureNV; + using ::PFN_vkCmdCopyAccelerationStructureNV; + using ::PFN_vkCmdTraceRaysNV; + using ::PFN_vkCmdWriteAccelerationStructuresPropertiesNV; + using ::PFN_vkCompileDeferredNV; + using ::PFN_vkCreateAccelerationStructureNV; + using ::PFN_vkCreateRayTracingPipelinesNV; + using ::PFN_vkDestroyAccelerationStructureNV; + using ::PFN_vkGetAccelerationStructureHandleNV; + using ::PFN_vkGetAccelerationStructureMemoryRequirementsNV; + using ::PFN_vkGetRayTracingShaderGroupHandlesNV; + + //=== VK_KHR_maintenance3 === + using ::PFN_vkGetDescriptorSetLayoutSupportKHR; + + //=== VK_KHR_draw_indirect_count === + using ::PFN_vkCmdDrawIndexedIndirectCountKHR; + using ::PFN_vkCmdDrawIndirectCountKHR; + + //=== VK_EXT_external_memory_host === + using ::PFN_vkGetMemoryHostPointerPropertiesEXT; + + //=== VK_AMD_buffer_marker === + using ::PFN_vkCmdWriteBufferMarker2AMD; + using ::PFN_vkCmdWriteBufferMarkerAMD; + + //=== VK_EXT_calibrated_timestamps === + using ::PFN_vkGetCalibratedTimestampsEXT; + using ::PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; + + //=== VK_NV_mesh_shader === + using ::PFN_vkCmdDrawMeshTasksIndirectCountNV; + using ::PFN_vkCmdDrawMeshTasksIndirectNV; + using ::PFN_vkCmdDrawMeshTasksNV; + + //=== VK_NV_scissor_exclusive === + using ::PFN_vkCmdSetExclusiveScissorEnableNV; + using ::PFN_vkCmdSetExclusiveScissorNV; + + //=== VK_NV_device_diagnostic_checkpoints === + using ::PFN_vkCmdSetCheckpointNV; + using ::PFN_vkGetQueueCheckpointData2NV; + using ::PFN_vkGetQueueCheckpointDataNV; + + //=== VK_KHR_timeline_semaphore === + using ::PFN_vkGetSemaphoreCounterValueKHR; + using ::PFN_vkSignalSemaphoreKHR; + using ::PFN_vkWaitSemaphoresKHR; + + //=== VK_EXT_present_timing === + using ::PFN_vkGetPastPresentationTimingEXT; + using ::PFN_vkGetSwapchainTimeDomainPropertiesEXT; + using ::PFN_vkGetSwapchainTimingPropertiesEXT; + using ::PFN_vkSetSwapchainPresentTimingQueueSizeEXT; + + //=== VK_INTEL_performance_query === + using ::PFN_vkAcquirePerformanceConfigurationINTEL; + using ::PFN_vkCmdSetPerformanceMarkerINTEL; + using ::PFN_vkCmdSetPerformanceOverrideINTEL; + using ::PFN_vkCmdSetPerformanceStreamMarkerINTEL; + using ::PFN_vkGetPerformanceParameterINTEL; + using ::PFN_vkInitializePerformanceApiINTEL; + using ::PFN_vkQueueSetPerformanceConfigurationINTEL; + using ::PFN_vkReleasePerformanceConfigurationINTEL; + using ::PFN_vkUninitializePerformanceApiINTEL; + + //=== VK_AMD_display_native_hdr === + using ::PFN_vkSetLocalDimmingAMD; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + using ::PFN_vkCreateImagePipeSurfaceFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + using ::PFN_vkCreateMetalSurfaceEXT; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + using ::PFN_vkCmdSetFragmentShadingRateKHR; + using ::PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR; + + //=== VK_KHR_dynamic_rendering_local_read === + using ::PFN_vkCmdSetRenderingAttachmentLocationsKHR; + using ::PFN_vkCmdSetRenderingInputAttachmentIndicesKHR; + + //=== VK_EXT_buffer_device_address === + using ::PFN_vkGetBufferDeviceAddressEXT; + + //=== VK_EXT_tooling_info === + using ::PFN_vkGetPhysicalDeviceToolPropertiesEXT; + + //=== VK_KHR_present_wait === + using ::PFN_vkWaitForPresentKHR; + + //=== VK_NV_cooperative_matrix === + using ::PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV; + + //=== VK_NV_coverage_reduction_mode === + using ::PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + using ::PFN_vkAcquireFullScreenExclusiveModeEXT; + using ::PFN_vkGetDeviceGroupSurfacePresentModes2EXT; + using ::PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT; + using ::PFN_vkReleaseFullScreenExclusiveModeEXT; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + using ::PFN_vkCreateHeadlessSurfaceEXT; + + //=== VK_KHR_buffer_device_address === + using ::PFN_vkGetBufferDeviceAddressKHR; + using ::PFN_vkGetBufferOpaqueCaptureAddressKHR; + using ::PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR; + + //=== VK_EXT_line_rasterization === + using ::PFN_vkCmdSetLineStippleEXT; + + //=== VK_EXT_host_query_reset === + using ::PFN_vkResetQueryPoolEXT; + + //=== VK_EXT_extended_dynamic_state === + using ::PFN_vkCmdBindVertexBuffers2EXT; + using ::PFN_vkCmdSetCullModeEXT; + using ::PFN_vkCmdSetDepthBoundsTestEnableEXT; + using ::PFN_vkCmdSetDepthCompareOpEXT; + using ::PFN_vkCmdSetDepthTestEnableEXT; + using ::PFN_vkCmdSetDepthWriteEnableEXT; + using ::PFN_vkCmdSetFrontFaceEXT; + using ::PFN_vkCmdSetPrimitiveTopologyEXT; + using ::PFN_vkCmdSetScissorWithCountEXT; + using ::PFN_vkCmdSetStencilOpEXT; + using ::PFN_vkCmdSetStencilTestEnableEXT; + using ::PFN_vkCmdSetViewportWithCountEXT; + + //=== VK_KHR_deferred_host_operations === + using ::PFN_vkCreateDeferredOperationKHR; + using ::PFN_vkDeferredOperationJoinKHR; + using ::PFN_vkDestroyDeferredOperationKHR; + using ::PFN_vkGetDeferredOperationMaxConcurrencyKHR; + using ::PFN_vkGetDeferredOperationResultKHR; + + //=== VK_KHR_pipeline_executable_properties === + using ::PFN_vkGetPipelineExecutableInternalRepresentationsKHR; + using ::PFN_vkGetPipelineExecutablePropertiesKHR; + using ::PFN_vkGetPipelineExecutableStatisticsKHR; + + //=== VK_EXT_host_image_copy === + using ::PFN_vkCopyImageToImageEXT; + using ::PFN_vkCopyImageToMemoryEXT; + using ::PFN_vkCopyMemoryToImageEXT; + using ::PFN_vkGetImageSubresourceLayout2EXT; + using ::PFN_vkTransitionImageLayoutEXT; + + //=== VK_KHR_map_memory2 === + using ::PFN_vkMapMemory2KHR; + using ::PFN_vkUnmapMemory2KHR; + + //=== VK_EXT_swapchain_maintenance1 === + using ::PFN_vkReleaseSwapchainImagesEXT; + + //=== VK_NV_device_generated_commands === + using ::PFN_vkCmdBindPipelineShaderGroupNV; + using ::PFN_vkCmdExecuteGeneratedCommandsNV; + using ::PFN_vkCmdPreprocessGeneratedCommandsNV; + using ::PFN_vkCreateIndirectCommandsLayoutNV; + using ::PFN_vkDestroyIndirectCommandsLayoutNV; + using ::PFN_vkGetGeneratedCommandsMemoryRequirementsNV; + + //=== VK_EXT_depth_bias_control === + using ::PFN_vkCmdSetDepthBias2EXT; + + //=== VK_EXT_acquire_drm_display === + using ::PFN_vkAcquireDrmDisplayEXT; + using ::PFN_vkGetDrmDisplayEXT; + + //=== VK_EXT_private_data === + using ::PFN_vkCreatePrivateDataSlotEXT; + using ::PFN_vkDestroyPrivateDataSlotEXT; + using ::PFN_vkGetPrivateDataEXT; + using ::PFN_vkSetPrivateDataEXT; + + //=== VK_KHR_video_encode_queue === + using ::PFN_vkCmdEncodeVideoKHR; + using ::PFN_vkGetEncodedVideoSessionParametersKHR; + using ::PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + using ::PFN_vkCmdCudaLaunchKernelNV; + using ::PFN_vkCreateCudaFunctionNV; + using ::PFN_vkCreateCudaModuleNV; + using ::PFN_vkDestroyCudaFunctionNV; + using ::PFN_vkDestroyCudaModuleNV; + using ::PFN_vkGetCudaModuleCacheNV; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + using ::PFN_vkCmdBeginPerTileExecutionQCOM; + using ::PFN_vkCmdDispatchTileQCOM; + using ::PFN_vkCmdEndPerTileExecutionQCOM; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + using ::PFN_vkExportMetalObjectsEXT; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + using ::PFN_vkCmdPipelineBarrier2KHR; + using ::PFN_vkCmdResetEvent2KHR; + using ::PFN_vkCmdSetEvent2KHR; + using ::PFN_vkCmdWaitEvents2KHR; + using ::PFN_vkCmdWriteTimestamp2KHR; + using ::PFN_vkQueueSubmit2KHR; + + //=== VK_EXT_descriptor_buffer === + using ::PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT; + using ::PFN_vkCmdBindDescriptorBuffersEXT; + using ::PFN_vkCmdSetDescriptorBufferOffsetsEXT; + using ::PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT; + using ::PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT; + using ::PFN_vkGetDescriptorEXT; + using ::PFN_vkGetDescriptorSetLayoutBindingOffsetEXT; + using ::PFN_vkGetDescriptorSetLayoutSizeEXT; + using ::PFN_vkGetImageOpaqueCaptureDescriptorDataEXT; + using ::PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT; + using ::PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT; + + //=== VK_NV_fragment_shading_rate_enums === + using ::PFN_vkCmdSetFragmentShadingRateEnumNV; + + //=== VK_EXT_mesh_shader === + using ::PFN_vkCmdDrawMeshTasksEXT; + using ::PFN_vkCmdDrawMeshTasksIndirectCountEXT; + using ::PFN_vkCmdDrawMeshTasksIndirectEXT; + + //=== VK_KHR_copy_commands2 === + using ::PFN_vkCmdBlitImage2KHR; + using ::PFN_vkCmdCopyBuffer2KHR; + using ::PFN_vkCmdCopyBufferToImage2KHR; + using ::PFN_vkCmdCopyImage2KHR; + using ::PFN_vkCmdCopyImageToBuffer2KHR; + using ::PFN_vkCmdResolveImage2KHR; + + //=== VK_EXT_device_fault === + using ::PFN_vkGetDeviceFaultInfoEXT; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + using ::PFN_vkAcquireWinrtDisplayNV; + using ::PFN_vkGetWinrtDisplayNV; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + using ::PFN_vkCreateDirectFBSurfaceEXT; + using ::PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_vertex_input_dynamic_state === + using ::PFN_vkCmdSetVertexInputEXT; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + using ::PFN_vkGetMemoryZirconHandleFUCHSIA; + using ::PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + using ::PFN_vkGetSemaphoreZirconHandleFUCHSIA; + using ::PFN_vkImportSemaphoreZirconHandleFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + using ::PFN_vkCreateBufferCollectionFUCHSIA; + using ::PFN_vkDestroyBufferCollectionFUCHSIA; + using ::PFN_vkGetBufferCollectionPropertiesFUCHSIA; + using ::PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA; + using ::PFN_vkSetBufferCollectionImageConstraintsFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + using ::PFN_vkCmdSubpassShadingHUAWEI; + using ::PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI; + + //=== VK_HUAWEI_invocation_mask === + using ::PFN_vkCmdBindInvocationMaskHUAWEI; + + //=== VK_NV_external_memory_rdma === + using ::PFN_vkGetMemoryRemoteAddressNV; + + //=== VK_EXT_pipeline_properties === + using ::PFN_vkGetPipelinePropertiesEXT; + + //=== VK_EXT_extended_dynamic_state2 === + using ::PFN_vkCmdSetDepthBiasEnableEXT; + using ::PFN_vkCmdSetLogicOpEXT; + using ::PFN_vkCmdSetPatchControlPointsEXT; + using ::PFN_vkCmdSetPrimitiveRestartEnableEXT; + using ::PFN_vkCmdSetRasterizerDiscardEnableEXT; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + using ::PFN_vkCreateScreenSurfaceQNX; + using ::PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_color_write_enable === + using ::PFN_vkCmdSetColorWriteEnableEXT; + + //=== VK_KHR_ray_tracing_maintenance1 === + using ::PFN_vkCmdTraceRaysIndirect2KHR; + + //=== VK_EXT_multi_draw === + using ::PFN_vkCmdDrawMultiEXT; + using ::PFN_vkCmdDrawMultiIndexedEXT; + + //=== VK_EXT_opacity_micromap === + using ::PFN_vkBuildMicromapsEXT; + using ::PFN_vkCmdBuildMicromapsEXT; + using ::PFN_vkCmdCopyMemoryToMicromapEXT; + using ::PFN_vkCmdCopyMicromapEXT; + using ::PFN_vkCmdCopyMicromapToMemoryEXT; + using ::PFN_vkCmdWriteMicromapsPropertiesEXT; + using ::PFN_vkCopyMemoryToMicromapEXT; + using ::PFN_vkCopyMicromapEXT; + using ::PFN_vkCopyMicromapToMemoryEXT; + using ::PFN_vkCreateMicromapEXT; + using ::PFN_vkDestroyMicromapEXT; + using ::PFN_vkGetDeviceMicromapCompatibilityEXT; + using ::PFN_vkGetMicromapBuildSizesEXT; + using ::PFN_vkWriteMicromapsPropertiesEXT; + + //=== VK_HUAWEI_cluster_culling_shader === + using ::PFN_vkCmdDrawClusterHUAWEI; + using ::PFN_vkCmdDrawClusterIndirectHUAWEI; + + //=== VK_EXT_pageable_device_local_memory === + using ::PFN_vkSetDeviceMemoryPriorityEXT; + + //=== VK_KHR_maintenance4 === + using ::PFN_vkGetDeviceBufferMemoryRequirementsKHR; + using ::PFN_vkGetDeviceImageMemoryRequirementsKHR; + using ::PFN_vkGetDeviceImageSparseMemoryRequirementsKHR; + + //=== VK_VALVE_descriptor_set_host_mapping === + using ::PFN_vkGetDescriptorSetHostMappingVALVE; + using ::PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE; + + //=== VK_NV_copy_memory_indirect === + using ::PFN_vkCmdCopyMemoryIndirectNV; + using ::PFN_vkCmdCopyMemoryToImageIndirectNV; + + //=== VK_NV_memory_decompression === + using ::PFN_vkCmdDecompressMemoryIndirectCountNV; + using ::PFN_vkCmdDecompressMemoryNV; + + //=== VK_NV_device_generated_commands_compute === + using ::PFN_vkCmdUpdatePipelineIndirectBufferNV; + using ::PFN_vkGetPipelineIndirectDeviceAddressNV; + using ::PFN_vkGetPipelineIndirectMemoryRequirementsNV; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + using ::PFN_vkGetMemoryNativeBufferOHOS; + using ::PFN_vkGetNativeBufferPropertiesOHOS; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_extended_dynamic_state3 === + using ::PFN_vkCmdSetAlphaToCoverageEnableEXT; + using ::PFN_vkCmdSetAlphaToOneEnableEXT; + using ::PFN_vkCmdSetColorBlendAdvancedEXT; + using ::PFN_vkCmdSetColorBlendEnableEXT; + using ::PFN_vkCmdSetColorBlendEquationEXT; + using ::PFN_vkCmdSetColorWriteMaskEXT; + using ::PFN_vkCmdSetConservativeRasterizationModeEXT; + using ::PFN_vkCmdSetCoverageModulationModeNV; + using ::PFN_vkCmdSetCoverageModulationTableEnableNV; + using ::PFN_vkCmdSetCoverageModulationTableNV; + using ::PFN_vkCmdSetCoverageReductionModeNV; + using ::PFN_vkCmdSetCoverageToColorEnableNV; + using ::PFN_vkCmdSetCoverageToColorLocationNV; + using ::PFN_vkCmdSetDepthClampEnableEXT; + using ::PFN_vkCmdSetDepthClipEnableEXT; + using ::PFN_vkCmdSetDepthClipNegativeOneToOneEXT; + using ::PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT; + using ::PFN_vkCmdSetLineRasterizationModeEXT; + using ::PFN_vkCmdSetLineStippleEnableEXT; + using ::PFN_vkCmdSetLogicOpEnableEXT; + using ::PFN_vkCmdSetPolygonModeEXT; + using ::PFN_vkCmdSetProvokingVertexModeEXT; + using ::PFN_vkCmdSetRasterizationSamplesEXT; + using ::PFN_vkCmdSetRasterizationStreamEXT; + using ::PFN_vkCmdSetRepresentativeFragmentTestEnableNV; + using ::PFN_vkCmdSetSampleLocationsEnableEXT; + using ::PFN_vkCmdSetSampleMaskEXT; + using ::PFN_vkCmdSetShadingRateImageEnableNV; + using ::PFN_vkCmdSetTessellationDomainOriginEXT; + using ::PFN_vkCmdSetViewportSwizzleNV; + using ::PFN_vkCmdSetViewportWScalingEnableNV; + + //=== VK_ARM_tensors === + using ::PFN_vkBindTensorMemoryARM; + using ::PFN_vkCmdCopyTensorARM; + using ::PFN_vkCreateTensorARM; + using ::PFN_vkCreateTensorViewARM; + using ::PFN_vkDestroyTensorARM; + using ::PFN_vkDestroyTensorViewARM; + using ::PFN_vkGetDeviceTensorMemoryRequirementsARM; + using ::PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM; + using ::PFN_vkGetTensorMemoryRequirementsARM; + using ::PFN_vkGetTensorOpaqueCaptureDescriptorDataARM; + using ::PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM; + + //=== VK_EXT_shader_module_identifier === + using ::PFN_vkGetShaderModuleCreateInfoIdentifierEXT; + using ::PFN_vkGetShaderModuleIdentifierEXT; + + //=== VK_NV_optical_flow === + using ::PFN_vkBindOpticalFlowSessionImageNV; + using ::PFN_vkCmdOpticalFlowExecuteNV; + using ::PFN_vkCreateOpticalFlowSessionNV; + using ::PFN_vkDestroyOpticalFlowSessionNV; + using ::PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV; + + //=== VK_KHR_maintenance5 === + using ::PFN_vkCmdBindIndexBuffer2KHR; + using ::PFN_vkGetDeviceImageSubresourceLayoutKHR; + using ::PFN_vkGetImageSubresourceLayout2KHR; + using ::PFN_vkGetRenderingAreaGranularityKHR; + + //=== VK_AMD_anti_lag === + using ::PFN_vkAntiLagUpdateAMD; + + //=== VK_KHR_present_wait2 === + using ::PFN_vkWaitForPresent2KHR; + + //=== VK_EXT_shader_object === + using ::PFN_vkCmdBindShadersEXT; + using ::PFN_vkCmdSetDepthClampRangeEXT; + using ::PFN_vkCreateShadersEXT; + using ::PFN_vkDestroyShaderEXT; + using ::PFN_vkGetShaderBinaryDataEXT; + + //=== VK_KHR_pipeline_binary === + using ::PFN_vkCreatePipelineBinariesKHR; + using ::PFN_vkDestroyPipelineBinaryKHR; + using ::PFN_vkGetPipelineBinaryDataKHR; + using ::PFN_vkGetPipelineKeyKHR; + using ::PFN_vkReleaseCapturedPipelineDataKHR; + + //=== VK_QCOM_tile_properties === + using ::PFN_vkGetDynamicRenderingTilePropertiesQCOM; + using ::PFN_vkGetFramebufferTilePropertiesQCOM; + + //=== VK_KHR_swapchain_maintenance1 === + using ::PFN_vkReleaseSwapchainImagesKHR; + + //=== VK_NV_cooperative_vector === + using ::PFN_vkCmdConvertCooperativeVectorMatrixNV; + using ::PFN_vkConvertCooperativeVectorMatrixNV; + using ::PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV; + + //=== VK_NV_low_latency2 === + using ::PFN_vkGetLatencyTimingsNV; + using ::PFN_vkLatencySleepNV; + using ::PFN_vkQueueNotifyOutOfBandNV; + using ::PFN_vkSetLatencyMarkerNV; + using ::PFN_vkSetLatencySleepModeNV; + + //=== VK_KHR_cooperative_matrix === + using ::PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR; + + //=== VK_ARM_data_graph === + using ::PFN_vkBindDataGraphPipelineSessionMemoryARM; + using ::PFN_vkCmdDispatchDataGraphARM; + using ::PFN_vkCreateDataGraphPipelinesARM; + using ::PFN_vkCreateDataGraphPipelineSessionARM; + using ::PFN_vkDestroyDataGraphPipelineSessionARM; + using ::PFN_vkGetDataGraphPipelineAvailablePropertiesARM; + using ::PFN_vkGetDataGraphPipelinePropertiesARM; + using ::PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM; + using ::PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM; + using ::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM; + using ::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM; + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + using ::PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + using ::PFN_vkGetScreenBufferPropertiesQNX; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_KHR_line_rasterization === + using ::PFN_vkCmdSetLineStippleKHR; + + //=== VK_KHR_calibrated_timestamps === + using ::PFN_vkGetCalibratedTimestampsKHR; + using ::PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR; + + //=== VK_KHR_maintenance6 === + using ::PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT; + using ::PFN_vkCmdBindDescriptorSets2KHR; + using ::PFN_vkCmdPushConstants2KHR; + using ::PFN_vkCmdPushDescriptorSet2KHR; + using ::PFN_vkCmdPushDescriptorSetWithTemplate2KHR; + using ::PFN_vkCmdSetDescriptorBufferOffsets2EXT; + + //=== VK_QCOM_tile_memory_heap === + using ::PFN_vkCmdBindTileMemoryQCOM; + + //=== VK_KHR_copy_memory_indirect === + using ::PFN_vkCmdCopyMemoryIndirectKHR; + using ::PFN_vkCmdCopyMemoryToImageIndirectKHR; + + //=== VK_EXT_memory_decompression === + using ::PFN_vkCmdDecompressMemoryEXT; + using ::PFN_vkCmdDecompressMemoryIndirectCountEXT; + + //=== VK_NV_external_compute_queue === + using ::PFN_vkCreateExternalComputeQueueNV; + using ::PFN_vkDestroyExternalComputeQueueNV; + using ::PFN_vkGetExternalComputeQueueDataNV; + + //=== VK_NV_cluster_acceleration_structure === + using ::PFN_vkCmdBuildClusterAccelerationStructureIndirectNV; + using ::PFN_vkGetClusterAccelerationStructureBuildSizesNV; + + //=== VK_NV_partitioned_acceleration_structure === + using ::PFN_vkCmdBuildPartitionedAccelerationStructuresNV; + using ::PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV; + + //=== VK_EXT_device_generated_commands === + using ::PFN_vkCmdExecuteGeneratedCommandsEXT; + using ::PFN_vkCmdPreprocessGeneratedCommandsEXT; + using ::PFN_vkCreateIndirectCommandsLayoutEXT; + using ::PFN_vkCreateIndirectExecutionSetEXT; + using ::PFN_vkDestroyIndirectCommandsLayoutEXT; + using ::PFN_vkDestroyIndirectExecutionSetEXT; + using ::PFN_vkGetGeneratedCommandsMemoryRequirementsEXT; + using ::PFN_vkUpdateIndirectExecutionSetPipelineEXT; + using ::PFN_vkUpdateIndirectExecutionSetShaderEXT; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + using ::PFN_vkCreateSurfaceOHOS; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_NV_cooperative_matrix2 === + using ::PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + using ::PFN_vkGetMemoryMetalHandleEXT; + using ::PFN_vkGetMemoryMetalHandlePropertiesEXT; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_ARM_performance_counters_by_region === + using ::PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM; + + //=== VK_EXT_fragment_density_map_offset === + using ::PFN_vkCmdEndRendering2EXT; + + //=== VK_EXT_custom_resolve === + using ::PFN_vkCmdBeginCustomResolveEXT; + + //=== VK_KHR_maintenance10 === + using ::PFN_vkCmdEndRendering2KHR; + + //=== VK_NV_compute_occupancy_priority === + using ::PFN_vkCmdSetComputeOccupancyPriorityNV; +} diff --git a/lib/vulkan-headers/include/vulkan/vulkan.h b/lib/vulkan-headers/include/vulkan/vulkan.h new file mode 100644 index 00000000000..2ed8d9c7abb --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan.h @@ -0,0 +1,103 @@ +#ifndef VULKAN_H_ +#define VULKAN_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +#include "vk_platform.h" +#include "vulkan_core.h" + +#ifdef VK_USE_PLATFORM_ANDROID_KHR +#include "vulkan_android.h" +#endif + +#ifdef VK_USE_PLATFORM_FUCHSIA +#include +#include "vulkan_fuchsia.h" +#endif + +#ifdef VK_USE_PLATFORM_IOS_MVK +#include "vulkan_ios.h" +#endif + + +#ifdef VK_USE_PLATFORM_MACOS_MVK +#include "vulkan_macos.h" +#endif + +#ifdef VK_USE_PLATFORM_METAL_EXT +#include "vulkan_metal.h" +#endif + +#ifdef VK_USE_PLATFORM_VI_NN +#include "vulkan_vi.h" +#endif + + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR +#include "vulkan_wayland.h" +#endif + + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#include +#include "vulkan_win32.h" +#endif + + +#ifdef VK_USE_PLATFORM_XCB_KHR +#include +#include "vulkan_xcb.h" +#endif + + +#ifdef VK_USE_PLATFORM_XLIB_KHR +#include +#include "vulkan_xlib.h" +#endif + + +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT +#include +#include "vulkan_directfb.h" +#endif + + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT +#include +#include +#include "vulkan_xlib_xrandr.h" +#endif + + +#ifdef VK_USE_PLATFORM_GGP +#include +#include "vulkan_ggp.h" +#endif + + +#ifdef VK_USE_PLATFORM_SCREEN_QNX +#include +#include "vulkan_screen.h" +#endif + + +#ifdef VK_USE_PLATFORM_SCI +#include +#include +#include "vulkan_sci.h" +#endif + + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#include "vulkan_beta.h" +#endif + +#ifdef VK_USE_PLATFORM_OHOS +#include "vulkan_ohos.h" +#endif + +#endif // VULKAN_H_ diff --git a/lib/vulkan-headers/include/vulkan/vulkan.hpp b/lib/vulkan-headers/include/vulkan/vulkan.hpp new file mode 100644 index 00000000000..4cd278cba29 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan.hpp @@ -0,0 +1,25659 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_HPP +#define VULKAN_HPP + +#include +#if !defined( VULKAN_HPP_CXX_MODULE ) +// clang-format off +# include +// clang-format on +# include +# include // ArrayWrapperND +# include +# include // strnlen +# include // std::string +# include // std::exchange +# if 17 <= VULKAN_HPP_CPP_VERSION +# include +# endif +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) +# include // std::tie +# include // std::vector +# endif +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) +# include +# endif +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# include // std::is_error_code_enum +# endif +# if defined( VULKAN_HPP_SUPPORT_SPAN ) +# include +# endif +#else +# include +# include +import std; +#endif + +#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1 +# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) +# include +# elif defined( _WIN32 ) && !defined( VULKAN_HPP_NO_WIN32_PROTOTYPES ) +using HINSTANCE = struct HINSTANCE__ *; +# if defined( _WIN64 ) +using FARPROC = int64_t( __stdcall * )(); +# else +using FARPROC = int( __stdcall * )(); +# endif +extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName ); +extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule ); +extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, const char * lpProcName ); +# endif +#endif + +VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 341, "Wrong VK_HEADER_VERSION!" ); + +// includes through some other header +// this results in major(x) being resolved to gnu_dev_major(x) +// which is an expression in a constructor initializer list. +#if defined( major ) +# undef major +#endif +#if defined( minor ) +# undef minor +#endif + +// Windows defines MemoryBarrier which is deprecated and collides +// with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct. +#if defined( MemoryBarrier ) +# undef MemoryBarrier +#endif + +// XLib.h defines True/False, which collides with our VULKAN_HPP_NAMESPACE::True/VULKAN_HPP_NAMESPACE::False +// -> undef them and provide some namepace-secure constexpr +#if defined( True ) +# undef True +constexpr int True = 1; +#endif +#if defined( False ) +# undef False +constexpr int False = 0; +#endif + +namespace VULKAN_HPP_NAMESPACE +{ + template + class ArrayWrapper1D : public std::array + { + public: + VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array() {} + + VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array const & data ) VULKAN_HPP_NOEXCEPT : std::array( data ) {} + + template ::value, int>::type = 0> + VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string const & data ) VULKAN_HPP_NOEXCEPT + { + copy( data.data(), data.length() ); + } + +#if 17 <= VULKAN_HPP_CPP_VERSION + template ::value, int>::type = 0> + VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string_view data ) VULKAN_HPP_NOEXCEPT + { + copy( data.data(), data.length() ); + } +#endif + +#if ( VK_USE_64_BIT_PTR_DEFINES == 0 ) + // on 32 bit compiles, needs overloads on index type int to resolve ambiguities + VULKAN_HPP_CONSTEXPR T const & operator[]( int index ) const VULKAN_HPP_NOEXCEPT + { + return std::array::operator[]( index ); + } + + T & operator[]( int index ) VULKAN_HPP_NOEXCEPT + { + return std::array::operator[]( index ); + } +#endif + + operator T const *() const VULKAN_HPP_NOEXCEPT + { + return this->data(); + } + + operator T *() VULKAN_HPP_NOEXCEPT + { + return this->data(); + } + + template ::value, int>::type = 0> + operator std::string() const + { + return std::string( this->data(), strnlen( this->data(), N ) ); + } + +#if 17 <= VULKAN_HPP_CPP_VERSION + template ::value, int>::type = 0> + operator std::string_view() const + { + return std::string_view( this->data(), strnlen( this->data(), N ) ); + } +#endif + + private: + VULKAN_HPP_CONSTEXPR_14 void copy( char const * data, size_t len ) VULKAN_HPP_NOEXCEPT + { + size_t n = ( std::min )( N - 1, len ); + for ( size_t i = 0; i < n; ++i ) + { + ( *this )[i] = data[i]; + } + ( *this )[n] = 0; + } + }; + +// relational operators between ArrayWrapper1D of chars with potentially different sizes +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + template + std::strong_ordering operator<=>( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + int result = strcmp( lhs.data(), rhs.data() ); + return ( result < 0 ) ? std::strong_ordering::less : ( ( result > 0 ) ? std::strong_ordering::greater : std::strong_ordering::equal ); + } +#else + template + bool operator<( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return strcmp( lhs.data(), rhs.data() ) < 0; + } + + template + bool operator<=( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return strcmp( lhs.data(), rhs.data() ) <= 0; + } + + template + bool operator>( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return strcmp( lhs.data(), rhs.data() ) > 0; + } + + template + bool operator>=( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return strcmp( lhs.data(), rhs.data() ) >= 0; + } +#endif + + template + bool operator==( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return strcmp( lhs.data(), rhs.data() ) == 0; + } + + template + bool operator!=( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return strcmp( lhs.data(), rhs.data() ) != 0; + } + +// specialization of relational operators between std::string and arrays of chars +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + template + std::strong_ordering operator<=>( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs <=> rhs.data(); + } +#else + template + bool operator<( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs < rhs.data(); + } + + template + bool operator<=( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs <= rhs.data(); + } + + template + bool operator>( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs > rhs.data(); + } + + template + bool operator>=( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs >= rhs.data(); + } +#endif + + template + bool operator==( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs == rhs.data(); + } + + template + bool operator!=( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs != rhs.data(); + } + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + template + std::strong_ordering operator<=>( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs.data() <=> rhs; + } +#else + template + bool operator<( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs.data() < rhs; + } + + template + bool operator<=( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs.data() <= rhs; + } + + template + bool operator>( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs.data() > rhs; + } + + template + bool operator>=( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs.data() >= rhs; + } +#endif + + template + bool operator==( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs.data() == rhs; + } + + template + bool operator!=( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT + { + return lhs.data() != rhs; + } + + template + class ArrayWrapper2D : public std::array, N> + { + public: + VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT : std::array, N>() {} + + VULKAN_HPP_CONSTEXPR ArrayWrapper2D( std::array, N> const & data ) VULKAN_HPP_NOEXCEPT + : std::array, N>( *reinterpret_cast, N> const *>( &data ) ) + { + } + }; + +#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + class ArrayProxy + { + public: + VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT + : m_count( 0 ) + , m_ptr( nullptr ) + { + } + + VULKAN_HPP_CONSTEXPR ArrayProxy( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + : m_count( 0 ) + , m_ptr( nullptr ) + { + } + + ArrayProxy( T const & value ) VULKAN_HPP_NOEXCEPT + : m_count( 1 ) + , m_ptr( &value ) + { + } + + ArrayProxy( uint32_t count, T const * ptr ) VULKAN_HPP_NOEXCEPT + : m_count( count ) + , m_ptr( ptr ) + { + } + + template + ArrayProxy( T const ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT + : m_count( C ) + , m_ptr( ptr ) + { + } + +# if __GNUC__ >= 9 +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Winit-list-lifetime" +# endif + + ArrayProxy( std::initializer_list const & list ) VULKAN_HPP_NOEXCEPT + : m_count( static_cast( list.size() ) ) + , m_ptr( list.begin() ) + { + } + + template ::value, int>::type = 0> + ArrayProxy( std::initializer_list::type> const & list ) VULKAN_HPP_NOEXCEPT + : m_count( static_cast( list.size() ) ) + , m_ptr( list.begin() ) + { + } + +# if __GNUC__ >= 9 +# pragma GCC diagnostic pop +# endif + + // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly + // convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement. + template ().data() ), T *>::value && + std::is_convertible().size() ), std::size_t>::value>::type * = nullptr> + ArrayProxy( V const & v ) VULKAN_HPP_NOEXCEPT + : m_count( static_cast( v.size() ) ) + , m_ptr( v.data() ) + { + } + + const T * begin() const VULKAN_HPP_NOEXCEPT + { + return m_ptr; + } + + const T * end() const VULKAN_HPP_NOEXCEPT + { + return m_ptr + m_count; + } + + const T & front() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_count && m_ptr ); + return *m_ptr; + } + + const T & back() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_count && m_ptr ); + return *( m_ptr + m_count - 1 ); + } + + bool empty() const VULKAN_HPP_NOEXCEPT + { + return ( m_count == 0 ); + } + + uint32_t size() const VULKAN_HPP_NOEXCEPT + { + return m_count; + } + + T const * data() const VULKAN_HPP_NOEXCEPT + { + return m_ptr; + } + + private: + uint32_t m_count; + T const * m_ptr; + }; + + template + class ArrayProxyNoTemporaries + { + public: + VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT + : m_count( 0 ) + , m_ptr( nullptr ) + { + } + + VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + : m_count( 0 ) + , m_ptr( nullptr ) + { + } + + template ::value && std::is_lvalue_reference::value, int>::type = 0> + ArrayProxyNoTemporaries( B && value ) VULKAN_HPP_NOEXCEPT + : m_count( 1 ) + , m_ptr( &value ) + { + } + + ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT + : m_count( count ) + , m_ptr( ptr ) + { + } + + template + ArrayProxyNoTemporaries( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT + : m_count( C ) + , m_ptr( ptr ) + { + } + + template + ArrayProxyNoTemporaries( T ( &&ptr )[C] ) = delete; + + // Any l-value reference with a .data() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t. + template ().begin() ), T *>::value && + std::is_convertible().data() ), T *>::value && + std::is_convertible().size() ), std::size_t>::value && std::is_lvalue_reference::value, + int>::type = 0> + ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT + : m_count( static_cast( v.size() ) ) + , m_ptr( v.data() ) + { + } + + // Any l-value reference with a .begin() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t. + template ().begin() ), T *>::value && + std::is_convertible().size() ), std::size_t>::value && std::is_lvalue_reference::value, + int>::type = 0> + ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT + : m_count( static_cast( v.size() ) ) + , m_ptr( v.begin() ) + { + } + + const T * begin() const VULKAN_HPP_NOEXCEPT + { + return m_ptr; + } + + const T * end() const VULKAN_HPP_NOEXCEPT + { + return m_ptr + m_count; + } + + const T & front() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_count && m_ptr ); + return *m_ptr; + } + + const T & back() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_count && m_ptr ); + return *( m_ptr + m_count - 1 ); + } + + bool empty() const VULKAN_HPP_NOEXCEPT + { + return ( m_count == 0 ); + } + + uint32_t size() const VULKAN_HPP_NOEXCEPT + { + return m_count; + } + + T * data() const VULKAN_HPP_NOEXCEPT + { + return m_ptr; + } + + private: + uint32_t m_count; + T * m_ptr; + }; + + template + class StridedArrayProxy : protected ArrayProxy + { + public: + using ArrayProxy::ArrayProxy; + + StridedArrayProxy( uint32_t count, T const * ptr, uint32_t stride ) VULKAN_HPP_NOEXCEPT + : ArrayProxy( count, ptr ) + , m_stride( stride ) + { + VULKAN_HPP_ASSERT( sizeof( T ) <= stride ); + } + + using ArrayProxy::begin; + + const T * end() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( static_cast( begin() ) + size() * m_stride ); + } + + using ArrayProxy::front; + + const T & back() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( begin() && size() ); + return *reinterpret_cast( static_cast( begin() ) + ( size() - 1 ) * m_stride ); + } + + using ArrayProxy::empty; + using ArrayProxy::size; + using ArrayProxy::data; + + uint32_t stride() const + { + return m_stride; + } + + private: + uint32_t m_stride = sizeof( T ); + }; + + template + class Optional + { + public: + Optional( RefType & reference ) VULKAN_HPP_NOEXCEPT + { + m_ptr = &reference; + } + + Optional( RefType * ptr ) VULKAN_HPP_NOEXCEPT + { + m_ptr = ptr; + } + + Optional( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_ptr = nullptr; + } + + operator RefType *() const VULKAN_HPP_NOEXCEPT + { + return m_ptr; + } + + RefType const * operator->() const VULKAN_HPP_NOEXCEPT + { + return m_ptr; + } + + RefType const * get() const VULKAN_HPP_NOEXCEPT + { + return m_ptr; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return !!m_ptr; + } + + private: + RefType * m_ptr; + }; + + template + struct StructExtends + { + enum + { + value = false + }; + }; + + template + struct IsPartOfStructureChain + { + static const bool valid = false; + }; + + template + struct IsPartOfStructureChain + { + static const bool valid = std::is_same::value || IsPartOfStructureChain::valid; + }; + + template + struct StructureChainContains + { + static const bool value = std::is_same>::type>::value || + StructureChainContains::value; + }; + + template + struct StructureChainContains<0, T, ChainElements...> + { + static const bool value = std::is_same>::type>::value; + }; + + template + struct StructureChainValidation + { + using TestType = typename std::tuple_element>::type; + static const bool valid = StructExtends>::type>::value && + ( TestType::allowDuplicate || !StructureChainContains::value ) && + StructureChainValidation::valid; + }; + + template + struct StructureChainValidation<0, ChainElements...> + { + static const bool valid = true; + }; + + template + class StructureChain : public std::tuple + { + // Note: StructureChain has no move constructor or move assignment operator, as it is not supposed to contain movable containers. + // In order to get a copy-operation on a move-operations, those functions are neither deleted nor defaulted. + public: + StructureChain() VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_STATIC_ASSERT( StructureChainValidation::valid, "The structure chain is not valid!" ); + link(); + } + + StructureChain( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT : std::tuple( rhs ) + { + VULKAN_HPP_STATIC_ASSERT( StructureChainValidation::valid, "The structure chain is not valid!" ); + link( &std::get<0>( *this ), + &std::get<0>( rhs ), + reinterpret_cast( &std::get<0>( *this ) ), + reinterpret_cast( &std::get<0>( rhs ) ) ); + } + + StructureChain( ChainElements const &... elems ) VULKAN_HPP_NOEXCEPT : std::tuple( elems... ) + { + VULKAN_HPP_STATIC_ASSERT( StructureChainValidation::valid, "The structure chain is not valid!" ); + link(); + } + + StructureChain & operator=( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT + { + std::tuple::operator=( rhs ); + link( &std::get<0>( *this ), + &std::get<0>( rhs ), + reinterpret_cast( &std::get<0>( *this ) ), + reinterpret_cast( &std::get<0>( rhs ) ) ); + return *this; + } + + template >::type, size_t Which = 0> + VULKAN_HPP_NODISCARD T & get() & VULKAN_HPP_NOEXCEPT + { + return std::get::value>( static_cast &>( *this ) ); + } + + template >::type, size_t Which = 0> + VULKAN_HPP_NODISCARD T const & get() const & VULKAN_HPP_NOEXCEPT + { + return std::get::value>( static_cast const &>( *this ) ); + } + + template >::type, size_t Which = 0> + VULKAN_HPP_NODISCARD T && get() && VULKAN_HPP_NOEXCEPT + { + return std::move( std::get::value>( static_cast &>( *this ) ) ); + } + + template + VULKAN_HPP_NODISCARD std::tuple get() & VULKAN_HPP_NOEXCEPT + { + return std::tie( get(), get(), get()... ); + } + + template + VULKAN_HPP_NODISCARD std::tuple get() const & VULKAN_HPP_NOEXCEPT + { + return std::tie( get(), get(), get()... ); + } + + template + VULKAN_HPP_NODISCARD std::tuple get() && VULKAN_HPP_NOEXCEPT + { + return std::forward_as_tuple( std::move( get() ), std::move( get() ), std::move( get() )... ); + } + + template + VULKAN_HPP_NODISCARD std::tuple get() const && VULKAN_HPP_NOEXCEPT + { + return std::forward_as_tuple( std::move( get() ), std::move( get() ), std::move( get() )... ); + } + + // assign a complete structure to the StructureChain without modifying the chaining + template >::type, size_t Which = 0> + StructureChain & assign( const T & rhs ) VULKAN_HPP_NOEXCEPT + { + T & lhs = get(); + auto pNext = lhs.pNext; + lhs = rhs; + lhs.pNext = pNext; + return *this; + } + + template + VULKAN_HPP_NODISCARD + typename std::enable_if>::type>::value && ( Which == 0 ), bool>::type + isLinked() const VULKAN_HPP_NOEXCEPT + { + return true; + } + + template + VULKAN_HPP_NODISCARD + typename std::enable_if>::type>::value || ( Which != 0 ), bool>::type + isLinked() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain::valid, "Can't unlink Structure that's not part of this StructureChain!" ); + return isLinked( reinterpret_cast( &get() ) ); + } + + template + typename std::enable_if>::type>::value || ( Which != 0 ), void>::type + relink() VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain::valid, "Can't relink Structure that's not part of this StructureChain!" ); + auto pNext = reinterpret_cast( &get() ); + VULKAN_HPP_ASSERT( !isLinked( pNext ) ); + auto & headElement = std::get<0>( static_cast &>( *this ) ); + pNext->pNext = reinterpret_cast( headElement.pNext ); + headElement.pNext = pNext; + } + + template + typename std::enable_if>::type>::value || ( Which != 0 ), void>::type + unlink() VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain::valid, "Can't unlink Structure that's not part of this StructureChain!" ); + unlink( reinterpret_cast( &get() ) ); + } + + private: + template + struct ChainElementIndex : ChainElementIndex + { + }; + + template + struct ChainElementIndex::value, void>::type, First, Types...> + : ChainElementIndex + { + }; + + template + struct ChainElementIndex::value, void>::type, First, Types...> + : ChainElementIndex + { + }; + + template + struct ChainElementIndex::value, void>::type, First, Types...> + : std::integral_constant + { + }; + + VULKAN_HPP_NODISCARD bool isLinked( VkBaseInStructure const * pNext ) const VULKAN_HPP_NOEXCEPT + { + VkBaseInStructure const * elementPtr = + reinterpret_cast( &std::get<0>( static_cast const &>( *this ) ) ); + while ( elementPtr ) + { + if ( elementPtr->pNext == pNext ) + { + return true; + } + elementPtr = elementPtr->pNext; + } + return false; + } + + template + typename std::enable_if::type link() VULKAN_HPP_NOEXCEPT + { + auto & x = std::get( static_cast &>( *this ) ); + x.pNext = &std::get( static_cast &>( *this ) ); + link(); + } + + template + typename std::enable_if::type link() VULKAN_HPP_NOEXCEPT + { + } + + void link( void * dstBase, void const * srcBase, VkBaseOutStructure * dst, VkBaseInStructure const * src ) + { + while ( src->pNext ) + { + std::ptrdiff_t offset = reinterpret_cast( src->pNext ) - reinterpret_cast( srcBase ); + dst->pNext = reinterpret_cast( reinterpret_cast( dstBase ) + offset ); + dst = dst->pNext; + src = src->pNext; + } + dst->pNext = nullptr; + } + + void unlink( VkBaseOutStructure const * pNext ) VULKAN_HPP_NOEXCEPT + { + VkBaseOutStructure * elementPtr = reinterpret_cast( &std::get<0>( static_cast &>( *this ) ) ); + while ( elementPtr && ( elementPtr->pNext != pNext ) ) + { + elementPtr = elementPtr->pNext; + } + if ( elementPtr ) + { + elementPtr->pNext = pNext->pNext; + } + else + { + VULKAN_HPP_ASSERT( false ); // fires, if the ClassType member has already been unlinked ! + } + } + }; + + // interupt the VULKAN_HPP_NAMESPACE for a moment to add specializations of std::tuple_size and std::tuple_element for the StructureChain! +} + +namespace std +{ + template + struct tuple_size> + { + static constexpr size_t value = std::tuple_size>::value; + }; + + template + struct tuple_element> + { + using type = typename std::tuple_element>::type; + }; +} // namespace std + +namespace VULKAN_HPP_NAMESPACE +{ + +# if !defined( VULKAN_HPP_NO_SMART_HANDLE ) + template + class UniqueHandleTraits; + + template + class UniqueHandle : public UniqueHandleTraits::deleter + { + private: + using Deleter = typename UniqueHandleTraits::deleter; + + public: + using element_type = Type; + + UniqueHandle() : Deleter(), m_value() {} + + explicit UniqueHandle( Type const & value, Deleter const & deleter = Deleter() ) VULKAN_HPP_NOEXCEPT + : Deleter( deleter ) + , m_value( value ) + { + } + + UniqueHandle( UniqueHandle const & ) = delete; + + UniqueHandle( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT + : Deleter( std::move( static_cast( other ) ) ) + , m_value( other.release() ) + { + } + + ~UniqueHandle() VULKAN_HPP_NOEXCEPT + { + if ( m_value ) + { + this->destroy( m_value ); + } + } + + UniqueHandle & operator=( UniqueHandle const & ) = delete; + + UniqueHandle & operator=( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT + { + reset( other.release() ); + *static_cast( this ) = std::move( static_cast( other ) ); + return *this; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_value.operator bool(); + } + +# if defined( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST ) + operator Type() const VULKAN_HPP_NOEXCEPT + { + return m_value; + } +# endif + + Type const * operator->() const VULKAN_HPP_NOEXCEPT + { + return &m_value; + } + + Type * operator->() VULKAN_HPP_NOEXCEPT + { + return &m_value; + } + + Type const & operator*() const VULKAN_HPP_NOEXCEPT + { + return m_value; + } + + Type & operator*() VULKAN_HPP_NOEXCEPT + { + return m_value; + } + + const Type & get() const VULKAN_HPP_NOEXCEPT + { + return m_value; + } + + Type & get() VULKAN_HPP_NOEXCEPT + { + return m_value; + } + + void reset( Type const & value = Type() ) VULKAN_HPP_NOEXCEPT + { + if ( m_value != value ) + { + if ( m_value ) + { + this->destroy( m_value ); + } + m_value = value; + } + } + + Type release() VULKAN_HPP_NOEXCEPT + { + Type value = m_value; + m_value = nullptr; + return value; + } + + void swap( UniqueHandle & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_value, rhs.m_value ); + std::swap( static_cast( *this ), static_cast( rhs ) ); + } + + private: + Type m_value; + }; + + template + VULKAN_HPP_INLINE std::vector uniqueToRaw( std::vector const & handles ) + { + std::vector newBuffer( handles.size() ); + std::transform( handles.begin(), handles.end(), newBuffer.begin(), []( UniqueType const & handle ) { return handle.get(); } ); + return newBuffer; + } + + template + VULKAN_HPP_INLINE void swap( UniqueHandle & lhs, UniqueHandle & rhs ) VULKAN_HPP_NOEXCEPT + { + lhs.swap( rhs ); + } +# endif +#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE + + namespace detail + { + + //========================== + //=== Is Dispatched List === + //========================== + + // C++11-compatible void_t + template + struct voider + { + typedef void type; + }; + + template + using void_t = typename voider::type; + + // helper macro to declare a SFINAE-friendly has_ trait +#define DECLARE_IS_DISPATCHED( name ) \ + template \ + struct has_##name : std::false_type \ + { \ + }; \ + template \ + struct has_##name> : std::true_type \ + { \ + }; + + DECLARE_IS_DISPATCHED( vkAcquireDrmDisplayEXT ) + DECLARE_IS_DISPATCHED( vkAcquireFullScreenExclusiveModeEXT ) + DECLARE_IS_DISPATCHED( vkAcquireImageANDROID ) + DECLARE_IS_DISPATCHED( vkAcquireImageOHOS ) + DECLARE_IS_DISPATCHED( vkAcquireNextImage2KHR ) + DECLARE_IS_DISPATCHED( vkAcquireNextImageKHR ) + DECLARE_IS_DISPATCHED( vkAcquirePerformanceConfigurationINTEL ) + DECLARE_IS_DISPATCHED( vkAcquireProfilingLockKHR ) + DECLARE_IS_DISPATCHED( vkAcquireWinrtDisplayNV ) + DECLARE_IS_DISPATCHED( vkAcquireXlibDisplayEXT ) + DECLARE_IS_DISPATCHED( vkAllocateCommandBuffers ) + DECLARE_IS_DISPATCHED( vkAllocateDescriptorSets ) + DECLARE_IS_DISPATCHED( vkAllocateMemory ) + DECLARE_IS_DISPATCHED( vkAntiLagUpdateAMD ) + DECLARE_IS_DISPATCHED( vkBeginCommandBuffer ) + DECLARE_IS_DISPATCHED( vkBindAccelerationStructureMemoryNV ) + DECLARE_IS_DISPATCHED( vkBindBufferMemory ) + DECLARE_IS_DISPATCHED( vkBindBufferMemory2 ) + DECLARE_IS_DISPATCHED( vkBindBufferMemory2KHR ) + DECLARE_IS_DISPATCHED( vkBindDataGraphPipelineSessionMemoryARM ) + DECLARE_IS_DISPATCHED( vkBindImageMemory ) + DECLARE_IS_DISPATCHED( vkBindImageMemory2 ) + DECLARE_IS_DISPATCHED( vkBindImageMemory2KHR ) + DECLARE_IS_DISPATCHED( vkBindOpticalFlowSessionImageNV ) + DECLARE_IS_DISPATCHED( vkBindTensorMemoryARM ) + DECLARE_IS_DISPATCHED( vkBindVideoSessionMemoryKHR ) + DECLARE_IS_DISPATCHED( vkBuildAccelerationStructuresKHR ) + DECLARE_IS_DISPATCHED( vkBuildMicromapsEXT ) + DECLARE_IS_DISPATCHED( vkCmdBeginConditionalRenderingEXT ) + DECLARE_IS_DISPATCHED( vkCmdBeginCustomResolveEXT ) + DECLARE_IS_DISPATCHED( vkCmdBeginDebugUtilsLabelEXT ) + DECLARE_IS_DISPATCHED( vkCmdBeginPerTileExecutionQCOM ) + DECLARE_IS_DISPATCHED( vkCmdBeginQuery ) + DECLARE_IS_DISPATCHED( vkCmdBeginQueryIndexedEXT ) + DECLARE_IS_DISPATCHED( vkCmdBeginRenderPass ) + DECLARE_IS_DISPATCHED( vkCmdBeginRenderPass2 ) + DECLARE_IS_DISPATCHED( vkCmdBeginRenderPass2KHR ) + DECLARE_IS_DISPATCHED( vkCmdBeginRendering ) + DECLARE_IS_DISPATCHED( vkCmdBeginRenderingKHR ) + DECLARE_IS_DISPATCHED( vkCmdBeginTransformFeedbackEXT ) + DECLARE_IS_DISPATCHED( vkCmdBeginVideoCodingKHR ) + DECLARE_IS_DISPATCHED( vkCmdBindDescriptorBufferEmbeddedSamplers2EXT ) + DECLARE_IS_DISPATCHED( vkCmdBindDescriptorBufferEmbeddedSamplersEXT ) + DECLARE_IS_DISPATCHED( vkCmdBindDescriptorBuffersEXT ) + DECLARE_IS_DISPATCHED( vkCmdBindDescriptorSets ) + DECLARE_IS_DISPATCHED( vkCmdBindDescriptorSets2 ) + DECLARE_IS_DISPATCHED( vkCmdBindDescriptorSets2KHR ) + DECLARE_IS_DISPATCHED( vkCmdBindIndexBuffer ) + DECLARE_IS_DISPATCHED( vkCmdBindIndexBuffer2 ) + DECLARE_IS_DISPATCHED( vkCmdBindIndexBuffer2KHR ) + DECLARE_IS_DISPATCHED( vkCmdBindInvocationMaskHUAWEI ) + DECLARE_IS_DISPATCHED( vkCmdBindPipeline ) + DECLARE_IS_DISPATCHED( vkCmdBindPipelineShaderGroupNV ) + DECLARE_IS_DISPATCHED( vkCmdBindResourceHeapEXT ) + DECLARE_IS_DISPATCHED( vkCmdBindSamplerHeapEXT ) + DECLARE_IS_DISPATCHED( vkCmdBindShadersEXT ) + DECLARE_IS_DISPATCHED( vkCmdBindShadingRateImageNV ) + DECLARE_IS_DISPATCHED( vkCmdBindTileMemoryQCOM ) + DECLARE_IS_DISPATCHED( vkCmdBindTransformFeedbackBuffersEXT ) + DECLARE_IS_DISPATCHED( vkCmdBindVertexBuffers ) + DECLARE_IS_DISPATCHED( vkCmdBindVertexBuffers2 ) + DECLARE_IS_DISPATCHED( vkCmdBindVertexBuffers2EXT ) + DECLARE_IS_DISPATCHED( vkCmdBlitImage ) + DECLARE_IS_DISPATCHED( vkCmdBlitImage2 ) + DECLARE_IS_DISPATCHED( vkCmdBlitImage2KHR ) + DECLARE_IS_DISPATCHED( vkCmdBuildAccelerationStructureNV ) + DECLARE_IS_DISPATCHED( vkCmdBuildAccelerationStructuresIndirectKHR ) + DECLARE_IS_DISPATCHED( vkCmdBuildAccelerationStructuresKHR ) + DECLARE_IS_DISPATCHED( vkCmdBuildClusterAccelerationStructureIndirectNV ) + DECLARE_IS_DISPATCHED( vkCmdBuildMicromapsEXT ) + DECLARE_IS_DISPATCHED( vkCmdBuildPartitionedAccelerationStructuresNV ) + DECLARE_IS_DISPATCHED( vkCmdClearAttachments ) + DECLARE_IS_DISPATCHED( vkCmdClearColorImage ) + DECLARE_IS_DISPATCHED( vkCmdClearDepthStencilImage ) + DECLARE_IS_DISPATCHED( vkCmdControlVideoCodingKHR ) + DECLARE_IS_DISPATCHED( vkCmdConvertCooperativeVectorMatrixNV ) + DECLARE_IS_DISPATCHED( vkCmdCopyAccelerationStructureKHR ) + DECLARE_IS_DISPATCHED( vkCmdCopyAccelerationStructureNV ) + DECLARE_IS_DISPATCHED( vkCmdCopyAccelerationStructureToMemoryKHR ) + DECLARE_IS_DISPATCHED( vkCmdCopyBuffer ) + DECLARE_IS_DISPATCHED( vkCmdCopyBuffer2 ) + DECLARE_IS_DISPATCHED( vkCmdCopyBuffer2KHR ) + DECLARE_IS_DISPATCHED( vkCmdCopyBufferToImage ) + DECLARE_IS_DISPATCHED( vkCmdCopyBufferToImage2 ) + DECLARE_IS_DISPATCHED( vkCmdCopyBufferToImage2KHR ) + DECLARE_IS_DISPATCHED( vkCmdCopyImage ) + DECLARE_IS_DISPATCHED( vkCmdCopyImage2 ) + DECLARE_IS_DISPATCHED( vkCmdCopyImage2KHR ) + DECLARE_IS_DISPATCHED( vkCmdCopyImageToBuffer ) + DECLARE_IS_DISPATCHED( vkCmdCopyImageToBuffer2 ) + DECLARE_IS_DISPATCHED( vkCmdCopyImageToBuffer2KHR ) + DECLARE_IS_DISPATCHED( vkCmdCopyMemoryIndirectKHR ) + DECLARE_IS_DISPATCHED( vkCmdCopyMemoryIndirectNV ) + DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToAccelerationStructureKHR ) + DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToImageIndirectKHR ) + DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToImageIndirectNV ) + DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToMicromapEXT ) + DECLARE_IS_DISPATCHED( vkCmdCopyMicromapEXT ) + DECLARE_IS_DISPATCHED( vkCmdCopyMicromapToMemoryEXT ) + DECLARE_IS_DISPATCHED( vkCmdCopyQueryPoolResults ) + DECLARE_IS_DISPATCHED( vkCmdCopyTensorARM ) + DECLARE_IS_DISPATCHED( vkCmdCuLaunchKernelNVX ) + DECLARE_IS_DISPATCHED( vkCmdCudaLaunchKernelNV ) + DECLARE_IS_DISPATCHED( vkCmdDebugMarkerBeginEXT ) + DECLARE_IS_DISPATCHED( vkCmdDebugMarkerEndEXT ) + DECLARE_IS_DISPATCHED( vkCmdDebugMarkerInsertEXT ) + DECLARE_IS_DISPATCHED( vkCmdDecodeVideoKHR ) + DECLARE_IS_DISPATCHED( vkCmdDecompressMemoryEXT ) + DECLARE_IS_DISPATCHED( vkCmdDecompressMemoryIndirectCountEXT ) + DECLARE_IS_DISPATCHED( vkCmdDecompressMemoryIndirectCountNV ) + DECLARE_IS_DISPATCHED( vkCmdDecompressMemoryNV ) + DECLARE_IS_DISPATCHED( vkCmdDispatch ) + DECLARE_IS_DISPATCHED( vkCmdDispatchBase ) + DECLARE_IS_DISPATCHED( vkCmdDispatchBaseKHR ) + DECLARE_IS_DISPATCHED( vkCmdDispatchDataGraphARM ) + DECLARE_IS_DISPATCHED( vkCmdDispatchGraphAMDX ) + DECLARE_IS_DISPATCHED( vkCmdDispatchGraphIndirectAMDX ) + DECLARE_IS_DISPATCHED( vkCmdDispatchGraphIndirectCountAMDX ) + DECLARE_IS_DISPATCHED( vkCmdDispatchIndirect ) + DECLARE_IS_DISPATCHED( vkCmdDispatchTileQCOM ) + DECLARE_IS_DISPATCHED( vkCmdDraw ) + DECLARE_IS_DISPATCHED( vkCmdDrawClusterHUAWEI ) + DECLARE_IS_DISPATCHED( vkCmdDrawClusterIndirectHUAWEI ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndexed ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirect ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirectCount ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirectCountAMD ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirectCountKHR ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndirect ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndirectByteCountEXT ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndirectCount ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndirectCountAMD ) + DECLARE_IS_DISPATCHED( vkCmdDrawIndirectCountKHR ) + DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksEXT ) + DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectCountEXT ) + DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectCountNV ) + DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectEXT ) + DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectNV ) + DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksNV ) + DECLARE_IS_DISPATCHED( vkCmdDrawMultiEXT ) + DECLARE_IS_DISPATCHED( vkCmdDrawMultiIndexedEXT ) + DECLARE_IS_DISPATCHED( vkCmdEncodeVideoKHR ) + DECLARE_IS_DISPATCHED( vkCmdEndConditionalRenderingEXT ) + DECLARE_IS_DISPATCHED( vkCmdEndDebugUtilsLabelEXT ) + DECLARE_IS_DISPATCHED( vkCmdEndPerTileExecutionQCOM ) + DECLARE_IS_DISPATCHED( vkCmdEndQuery ) + DECLARE_IS_DISPATCHED( vkCmdEndQueryIndexedEXT ) + DECLARE_IS_DISPATCHED( vkCmdEndRenderPass ) + DECLARE_IS_DISPATCHED( vkCmdEndRenderPass2 ) + DECLARE_IS_DISPATCHED( vkCmdEndRenderPass2KHR ) + DECLARE_IS_DISPATCHED( vkCmdEndRendering ) + DECLARE_IS_DISPATCHED( vkCmdEndRenderingKHR ) + DECLARE_IS_DISPATCHED( vkCmdEndRendering2KHR ) + DECLARE_IS_DISPATCHED( vkCmdEndRendering2EXT ) + DECLARE_IS_DISPATCHED( vkCmdEndTransformFeedbackEXT ) + DECLARE_IS_DISPATCHED( vkCmdEndVideoCodingKHR ) + DECLARE_IS_DISPATCHED( vkCmdExecuteCommands ) + DECLARE_IS_DISPATCHED( vkCmdExecuteGeneratedCommandsEXT ) + DECLARE_IS_DISPATCHED( vkCmdExecuteGeneratedCommandsNV ) + DECLARE_IS_DISPATCHED( vkCmdFillBuffer ) + DECLARE_IS_DISPATCHED( vkCmdInitializeGraphScratchMemoryAMDX ) + DECLARE_IS_DISPATCHED( vkCmdInsertDebugUtilsLabelEXT ) + DECLARE_IS_DISPATCHED( vkCmdNextSubpass ) + DECLARE_IS_DISPATCHED( vkCmdNextSubpass2 ) + DECLARE_IS_DISPATCHED( vkCmdNextSubpass2KHR ) + DECLARE_IS_DISPATCHED( vkCmdOpticalFlowExecuteNV ) + DECLARE_IS_DISPATCHED( vkCmdPipelineBarrier ) + DECLARE_IS_DISPATCHED( vkCmdPipelineBarrier2 ) + DECLARE_IS_DISPATCHED( vkCmdPipelineBarrier2KHR ) + DECLARE_IS_DISPATCHED( vkCmdPreprocessGeneratedCommandsEXT ) + DECLARE_IS_DISPATCHED( vkCmdPreprocessGeneratedCommandsNV ) + DECLARE_IS_DISPATCHED( vkCmdPushConstants ) + DECLARE_IS_DISPATCHED( vkCmdPushConstants2 ) + DECLARE_IS_DISPATCHED( vkCmdPushConstants2KHR ) + DECLARE_IS_DISPATCHED( vkCmdPushDataEXT ) + DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSet ) + DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSetKHR ) + DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSet2 ) + DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSet2KHR ) + DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSetWithTemplate ) + DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSetWithTemplateKHR ) + DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSetWithTemplate2 ) + DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSetWithTemplate2KHR ) + DECLARE_IS_DISPATCHED( vkCmdRefreshObjectsKHR ) + DECLARE_IS_DISPATCHED( vkCmdResetEvent ) + DECLARE_IS_DISPATCHED( vkCmdResetEvent2 ) + DECLARE_IS_DISPATCHED( vkCmdResetEvent2KHR ) + DECLARE_IS_DISPATCHED( vkCmdResetQueryPool ) + DECLARE_IS_DISPATCHED( vkCmdResolveImage ) + DECLARE_IS_DISPATCHED( vkCmdResolveImage2 ) + DECLARE_IS_DISPATCHED( vkCmdResolveImage2KHR ) + DECLARE_IS_DISPATCHED( vkCmdSetAlphaToCoverageEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetAlphaToOneEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetAttachmentFeedbackLoopEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetBlendConstants ) + DECLARE_IS_DISPATCHED( vkCmdSetCheckpointNV ) + DECLARE_IS_DISPATCHED( vkCmdSetCoarseSampleOrderNV ) + DECLARE_IS_DISPATCHED( vkCmdSetColorBlendAdvancedEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetColorBlendEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetColorBlendEquationEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetColorWriteEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetColorWriteMaskEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetComputeOccupancyPriorityNV ) + DECLARE_IS_DISPATCHED( vkCmdSetConservativeRasterizationModeEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetCoverageModulationModeNV ) + DECLARE_IS_DISPATCHED( vkCmdSetCoverageModulationTableEnableNV ) + DECLARE_IS_DISPATCHED( vkCmdSetCoverageModulationTableNV ) + DECLARE_IS_DISPATCHED( vkCmdSetCoverageReductionModeNV ) + DECLARE_IS_DISPATCHED( vkCmdSetCoverageToColorEnableNV ) + DECLARE_IS_DISPATCHED( vkCmdSetCoverageToColorLocationNV ) + DECLARE_IS_DISPATCHED( vkCmdSetCullMode ) + DECLARE_IS_DISPATCHED( vkCmdSetCullModeEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthBias ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthBias2EXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthBiasEnable ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthBiasEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthBounds ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthBoundsTestEnable ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthBoundsTestEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthClampEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthClampRangeEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthClipEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthClipNegativeOneToOneEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthCompareOp ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthCompareOpEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthTestEnable ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthTestEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthWriteEnable ) + DECLARE_IS_DISPATCHED( vkCmdSetDepthWriteEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDescriptorBufferOffsets2EXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDescriptorBufferOffsetsEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDeviceMask ) + DECLARE_IS_DISPATCHED( vkCmdSetDeviceMaskKHR ) + DECLARE_IS_DISPATCHED( vkCmdSetDiscardRectangleEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDiscardRectangleEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetDiscardRectangleModeEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetEvent ) + DECLARE_IS_DISPATCHED( vkCmdSetEvent2 ) + DECLARE_IS_DISPATCHED( vkCmdSetEvent2KHR ) + DECLARE_IS_DISPATCHED( vkCmdSetExclusiveScissorEnableNV ) + DECLARE_IS_DISPATCHED( vkCmdSetExclusiveScissorNV ) + DECLARE_IS_DISPATCHED( vkCmdSetExtraPrimitiveOverestimationSizeEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetFragmentShadingRateEnumNV ) + DECLARE_IS_DISPATCHED( vkCmdSetFragmentShadingRateKHR ) + DECLARE_IS_DISPATCHED( vkCmdSetFrontFace ) + DECLARE_IS_DISPATCHED( vkCmdSetFrontFaceEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetLineRasterizationModeEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetLineStipple ) + DECLARE_IS_DISPATCHED( vkCmdSetLineStippleEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetLineStippleKHR ) + DECLARE_IS_DISPATCHED( vkCmdSetLineStippleEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetLineWidth ) + DECLARE_IS_DISPATCHED( vkCmdSetLogicOpEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetLogicOpEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetPatchControlPointsEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetPerformanceMarkerINTEL ) + DECLARE_IS_DISPATCHED( vkCmdSetPerformanceOverrideINTEL ) + DECLARE_IS_DISPATCHED( vkCmdSetPerformanceStreamMarkerINTEL ) + DECLARE_IS_DISPATCHED( vkCmdSetPolygonModeEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetPrimitiveRestartEnable ) + DECLARE_IS_DISPATCHED( vkCmdSetPrimitiveRestartEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetPrimitiveTopology ) + DECLARE_IS_DISPATCHED( vkCmdSetPrimitiveTopologyEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetProvokingVertexModeEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetRasterizationSamplesEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetRasterizationStreamEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetRasterizerDiscardEnable ) + DECLARE_IS_DISPATCHED( vkCmdSetRasterizerDiscardEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetRayTracingPipelineStackSizeKHR ) + DECLARE_IS_DISPATCHED( vkCmdSetRenderingAttachmentLocations ) + DECLARE_IS_DISPATCHED( vkCmdSetRenderingAttachmentLocationsKHR ) + DECLARE_IS_DISPATCHED( vkCmdSetRenderingInputAttachmentIndices ) + DECLARE_IS_DISPATCHED( vkCmdSetRenderingInputAttachmentIndicesKHR ) + DECLARE_IS_DISPATCHED( vkCmdSetRepresentativeFragmentTestEnableNV ) + DECLARE_IS_DISPATCHED( vkCmdSetSampleLocationsEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetSampleLocationsEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetSampleMaskEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetScissor ) + DECLARE_IS_DISPATCHED( vkCmdSetScissorWithCount ) + DECLARE_IS_DISPATCHED( vkCmdSetScissorWithCountEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetShadingRateImageEnableNV ) + DECLARE_IS_DISPATCHED( vkCmdSetStencilCompareMask ) + DECLARE_IS_DISPATCHED( vkCmdSetStencilOp ) + DECLARE_IS_DISPATCHED( vkCmdSetStencilOpEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetStencilReference ) + DECLARE_IS_DISPATCHED( vkCmdSetStencilTestEnable ) + DECLARE_IS_DISPATCHED( vkCmdSetStencilTestEnableEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetStencilWriteMask ) + DECLARE_IS_DISPATCHED( vkCmdSetTessellationDomainOriginEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetVertexInputEXT ) + DECLARE_IS_DISPATCHED( vkCmdSetViewport ) + DECLARE_IS_DISPATCHED( vkCmdSetViewportShadingRatePaletteNV ) + DECLARE_IS_DISPATCHED( vkCmdSetViewportSwizzleNV ) + DECLARE_IS_DISPATCHED( vkCmdSetViewportWScalingEnableNV ) + DECLARE_IS_DISPATCHED( vkCmdSetViewportWScalingNV ) + DECLARE_IS_DISPATCHED( vkCmdSetViewportWithCount ) + DECLARE_IS_DISPATCHED( vkCmdSetViewportWithCountEXT ) + DECLARE_IS_DISPATCHED( vkCmdSubpassShadingHUAWEI ) + DECLARE_IS_DISPATCHED( vkCmdTraceRaysIndirect2KHR ) + DECLARE_IS_DISPATCHED( vkCmdTraceRaysIndirectKHR ) + DECLARE_IS_DISPATCHED( vkCmdTraceRaysKHR ) + DECLARE_IS_DISPATCHED( vkCmdTraceRaysNV ) + DECLARE_IS_DISPATCHED( vkCmdUpdateBuffer ) + DECLARE_IS_DISPATCHED( vkCmdUpdatePipelineIndirectBufferNV ) + DECLARE_IS_DISPATCHED( vkCmdWaitEvents ) + DECLARE_IS_DISPATCHED( vkCmdWaitEvents2 ) + DECLARE_IS_DISPATCHED( vkCmdWaitEvents2KHR ) + DECLARE_IS_DISPATCHED( vkCmdWriteAccelerationStructuresPropertiesKHR ) + DECLARE_IS_DISPATCHED( vkCmdWriteAccelerationStructuresPropertiesNV ) + DECLARE_IS_DISPATCHED( vkCmdWriteBufferMarker2AMD ) + DECLARE_IS_DISPATCHED( vkCmdWriteBufferMarkerAMD ) + DECLARE_IS_DISPATCHED( vkCmdWriteMicromapsPropertiesEXT ) + DECLARE_IS_DISPATCHED( vkCmdWriteTimestamp ) + DECLARE_IS_DISPATCHED( vkCmdWriteTimestamp2 ) + DECLARE_IS_DISPATCHED( vkCmdWriteTimestamp2KHR ) + DECLARE_IS_DISPATCHED( vkCompileDeferredNV ) + DECLARE_IS_DISPATCHED( vkConvertCooperativeVectorMatrixNV ) + DECLARE_IS_DISPATCHED( vkCopyAccelerationStructureKHR ) + DECLARE_IS_DISPATCHED( vkCopyAccelerationStructureToMemoryKHR ) + DECLARE_IS_DISPATCHED( vkCopyImageToImage ) + DECLARE_IS_DISPATCHED( vkCopyImageToImageEXT ) + DECLARE_IS_DISPATCHED( vkCopyImageToMemory ) + DECLARE_IS_DISPATCHED( vkCopyImageToMemoryEXT ) + DECLARE_IS_DISPATCHED( vkCopyMemoryToAccelerationStructureKHR ) + DECLARE_IS_DISPATCHED( vkCopyMemoryToImage ) + DECLARE_IS_DISPATCHED( vkCopyMemoryToImageEXT ) + DECLARE_IS_DISPATCHED( vkCopyMemoryToMicromapEXT ) + DECLARE_IS_DISPATCHED( vkCopyMicromapEXT ) + DECLARE_IS_DISPATCHED( vkCopyMicromapToMemoryEXT ) + DECLARE_IS_DISPATCHED( vkCreateAccelerationStructureKHR ) + DECLARE_IS_DISPATCHED( vkCreateAccelerationStructureNV ) + DECLARE_IS_DISPATCHED( vkCreateAndroidSurfaceKHR ) + DECLARE_IS_DISPATCHED( vkCreateBuffer ) + DECLARE_IS_DISPATCHED( vkCreateBufferCollectionFUCHSIA ) + DECLARE_IS_DISPATCHED( vkCreateBufferView ) + DECLARE_IS_DISPATCHED( vkCreateCommandPool ) + DECLARE_IS_DISPATCHED( vkCreateComputePipelines ) + DECLARE_IS_DISPATCHED( vkCreateCuFunctionNVX ) + DECLARE_IS_DISPATCHED( vkCreateCuModuleNVX ) + DECLARE_IS_DISPATCHED( vkCreateCudaFunctionNV ) + DECLARE_IS_DISPATCHED( vkCreateCudaModuleNV ) + DECLARE_IS_DISPATCHED( vkCreateDataGraphPipelineSessionARM ) + DECLARE_IS_DISPATCHED( vkCreateDataGraphPipelinesARM ) + DECLARE_IS_DISPATCHED( vkCreateDebugReportCallbackEXT ) + DECLARE_IS_DISPATCHED( vkCreateDebugUtilsMessengerEXT ) + DECLARE_IS_DISPATCHED( vkCreateDeferredOperationKHR ) + DECLARE_IS_DISPATCHED( vkCreateDescriptorPool ) + DECLARE_IS_DISPATCHED( vkCreateDescriptorSetLayout ) + DECLARE_IS_DISPATCHED( vkCreateDescriptorUpdateTemplate ) + DECLARE_IS_DISPATCHED( vkCreateDescriptorUpdateTemplateKHR ) + DECLARE_IS_DISPATCHED( vkCreateDevice ) + DECLARE_IS_DISPATCHED( vkCreateDirectFBSurfaceEXT ) + DECLARE_IS_DISPATCHED( vkCreateDisplayModeKHR ) + DECLARE_IS_DISPATCHED( vkCreateDisplayPlaneSurfaceKHR ) + DECLARE_IS_DISPATCHED( vkCreateEvent ) + DECLARE_IS_DISPATCHED( vkCreateExecutionGraphPipelinesAMDX ) + DECLARE_IS_DISPATCHED( vkCreateExternalComputeQueueNV ) + DECLARE_IS_DISPATCHED( vkCreateFence ) + DECLARE_IS_DISPATCHED( vkCreateFramebuffer ) + DECLARE_IS_DISPATCHED( vkCreateGraphicsPipelines ) + DECLARE_IS_DISPATCHED( vkCreateHeadlessSurfaceEXT ) + DECLARE_IS_DISPATCHED( vkCreateIOSSurfaceMVK ) + DECLARE_IS_DISPATCHED( vkCreateImage ) + DECLARE_IS_DISPATCHED( vkCreateImagePipeSurfaceFUCHSIA ) + DECLARE_IS_DISPATCHED( vkCreateImageView ) + DECLARE_IS_DISPATCHED( vkCreateIndirectCommandsLayoutEXT ) + DECLARE_IS_DISPATCHED( vkCreateIndirectCommandsLayoutNV ) + DECLARE_IS_DISPATCHED( vkCreateIndirectExecutionSetEXT ) + DECLARE_IS_DISPATCHED( vkCreateInstance ) + DECLARE_IS_DISPATCHED( vkCreateMacOSSurfaceMVK ) + DECLARE_IS_DISPATCHED( vkCreateMetalSurfaceEXT ) + DECLARE_IS_DISPATCHED( vkCreateMicromapEXT ) + DECLARE_IS_DISPATCHED( vkCreateOpticalFlowSessionNV ) + DECLARE_IS_DISPATCHED( vkCreatePipelineBinariesKHR ) + DECLARE_IS_DISPATCHED( vkCreatePipelineCache ) + DECLARE_IS_DISPATCHED( vkCreatePipelineLayout ) + DECLARE_IS_DISPATCHED( vkCreatePrivateDataSlot ) + DECLARE_IS_DISPATCHED( vkCreatePrivateDataSlotEXT ) + DECLARE_IS_DISPATCHED( vkCreateQueryPool ) + DECLARE_IS_DISPATCHED( vkCreateRayTracingPipelinesKHR ) + DECLARE_IS_DISPATCHED( vkCreateRayTracingPipelinesNV ) + DECLARE_IS_DISPATCHED( vkCreateRenderPass ) + DECLARE_IS_DISPATCHED( vkCreateRenderPass2 ) + DECLARE_IS_DISPATCHED( vkCreateRenderPass2KHR ) + DECLARE_IS_DISPATCHED( vkCreateSampler ) + DECLARE_IS_DISPATCHED( vkCreateSamplerYcbcrConversion ) + DECLARE_IS_DISPATCHED( vkCreateSamplerYcbcrConversionKHR ) + DECLARE_IS_DISPATCHED( vkCreateScreenSurfaceQNX ) + DECLARE_IS_DISPATCHED( vkCreateSemaphore ) + DECLARE_IS_DISPATCHED( vkCreateSemaphoreSciSyncPoolNV ) + DECLARE_IS_DISPATCHED( vkCreateShaderModule ) + DECLARE_IS_DISPATCHED( vkCreateShadersEXT ) + DECLARE_IS_DISPATCHED( vkCreateSharedSwapchainsKHR ) + DECLARE_IS_DISPATCHED( vkCreateStreamDescriptorSurfaceGGP ) + DECLARE_IS_DISPATCHED( vkCreateSurfaceOHOS ) + DECLARE_IS_DISPATCHED( vkCreateSwapchainKHR ) + DECLARE_IS_DISPATCHED( vkCreateTensorARM ) + DECLARE_IS_DISPATCHED( vkCreateTensorViewARM ) + DECLARE_IS_DISPATCHED( vkCreateValidationCacheEXT ) + DECLARE_IS_DISPATCHED( vkCreateViSurfaceNN ) + DECLARE_IS_DISPATCHED( vkCreateVideoSessionKHR ) + DECLARE_IS_DISPATCHED( vkCreateVideoSessionParametersKHR ) + DECLARE_IS_DISPATCHED( vkCreateWaylandSurfaceKHR ) + DECLARE_IS_DISPATCHED( vkCreateWin32SurfaceKHR ) + DECLARE_IS_DISPATCHED( vkCreateXcbSurfaceKHR ) + DECLARE_IS_DISPATCHED( vkCreateXlibSurfaceKHR ) + DECLARE_IS_DISPATCHED( vkDebugMarkerSetObjectNameEXT ) + DECLARE_IS_DISPATCHED( vkDebugMarkerSetObjectTagEXT ) + DECLARE_IS_DISPATCHED( vkDebugReportMessageEXT ) + DECLARE_IS_DISPATCHED( vkDeferredOperationJoinKHR ) + DECLARE_IS_DISPATCHED( vkDestroyAccelerationStructureKHR ) + DECLARE_IS_DISPATCHED( vkDestroyAccelerationStructureNV ) + DECLARE_IS_DISPATCHED( vkDestroyBuffer ) + DECLARE_IS_DISPATCHED( vkDestroyBufferCollectionFUCHSIA ) + DECLARE_IS_DISPATCHED( vkDestroyBufferView ) + DECLARE_IS_DISPATCHED( vkDestroyCommandPool ) + DECLARE_IS_DISPATCHED( vkDestroyCuFunctionNVX ) + DECLARE_IS_DISPATCHED( vkDestroyCuModuleNVX ) + DECLARE_IS_DISPATCHED( vkDestroyCudaFunctionNV ) + DECLARE_IS_DISPATCHED( vkDestroyCudaModuleNV ) + DECLARE_IS_DISPATCHED( vkDestroyDataGraphPipelineSessionARM ) + DECLARE_IS_DISPATCHED( vkDestroyDebugReportCallbackEXT ) + DECLARE_IS_DISPATCHED( vkDestroyDebugUtilsMessengerEXT ) + DECLARE_IS_DISPATCHED( vkDestroyDeferredOperationKHR ) + DECLARE_IS_DISPATCHED( vkDestroyDescriptorPool ) + DECLARE_IS_DISPATCHED( vkDestroyDescriptorSetLayout ) + DECLARE_IS_DISPATCHED( vkDestroyDescriptorUpdateTemplate ) + DECLARE_IS_DISPATCHED( vkDestroyDescriptorUpdateTemplateKHR ) + DECLARE_IS_DISPATCHED( vkDestroyDevice ) + DECLARE_IS_DISPATCHED( vkDestroyEvent ) + DECLARE_IS_DISPATCHED( vkDestroyExternalComputeQueueNV ) + DECLARE_IS_DISPATCHED( vkDestroyFence ) + DECLARE_IS_DISPATCHED( vkDestroyFramebuffer ) + DECLARE_IS_DISPATCHED( vkDestroyImage ) + DECLARE_IS_DISPATCHED( vkDestroyImageView ) + DECLARE_IS_DISPATCHED( vkDestroyIndirectCommandsLayoutEXT ) + DECLARE_IS_DISPATCHED( vkDestroyIndirectCommandsLayoutNV ) + DECLARE_IS_DISPATCHED( vkDestroyIndirectExecutionSetEXT ) + DECLARE_IS_DISPATCHED( vkDestroyInstance ) + DECLARE_IS_DISPATCHED( vkDestroyMicromapEXT ) + DECLARE_IS_DISPATCHED( vkDestroyOpticalFlowSessionNV ) + DECLARE_IS_DISPATCHED( vkDestroyPipeline ) + DECLARE_IS_DISPATCHED( vkDestroyPipelineBinaryKHR ) + DECLARE_IS_DISPATCHED( vkDestroyPipelineCache ) + DECLARE_IS_DISPATCHED( vkDestroyPipelineLayout ) + DECLARE_IS_DISPATCHED( vkDestroyPrivateDataSlot ) + DECLARE_IS_DISPATCHED( vkDestroyPrivateDataSlotEXT ) + DECLARE_IS_DISPATCHED( vkDestroyQueryPool ) + DECLARE_IS_DISPATCHED( vkDestroyRenderPass ) + DECLARE_IS_DISPATCHED( vkDestroySampler ) + DECLARE_IS_DISPATCHED( vkDestroySamplerYcbcrConversion ) + DECLARE_IS_DISPATCHED( vkDestroySamplerYcbcrConversionKHR ) + DECLARE_IS_DISPATCHED( vkDestroySemaphore ) + DECLARE_IS_DISPATCHED( vkDestroySemaphoreSciSyncPoolNV ) + DECLARE_IS_DISPATCHED( vkDestroyShaderEXT ) + DECLARE_IS_DISPATCHED( vkDestroyShaderModule ) + DECLARE_IS_DISPATCHED( vkDestroySurfaceKHR ) + DECLARE_IS_DISPATCHED( vkDestroySwapchainKHR ) + DECLARE_IS_DISPATCHED( vkDestroyTensorARM ) + DECLARE_IS_DISPATCHED( vkDestroyTensorViewARM ) + DECLARE_IS_DISPATCHED( vkDestroyValidationCacheEXT ) + DECLARE_IS_DISPATCHED( vkDestroyVideoSessionKHR ) + DECLARE_IS_DISPATCHED( vkDestroyVideoSessionParametersKHR ) + DECLARE_IS_DISPATCHED( vkDeviceWaitIdle ) + DECLARE_IS_DISPATCHED( vkDisplayPowerControlEXT ) + DECLARE_IS_DISPATCHED( vkEndCommandBuffer ) + DECLARE_IS_DISPATCHED( vkEnumerateDeviceExtensionProperties ) + DECLARE_IS_DISPATCHED( vkEnumerateDeviceLayerProperties ) + DECLARE_IS_DISPATCHED( vkEnumerateInstanceExtensionProperties ) + DECLARE_IS_DISPATCHED( vkEnumerateInstanceLayerProperties ) + DECLARE_IS_DISPATCHED( vkEnumerateInstanceVersion ) + DECLARE_IS_DISPATCHED( vkEnumeratePhysicalDeviceGroups ) + DECLARE_IS_DISPATCHED( vkEnumeratePhysicalDeviceGroupsKHR ) + DECLARE_IS_DISPATCHED( vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM ) + DECLARE_IS_DISPATCHED( vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR ) + DECLARE_IS_DISPATCHED( vkEnumeratePhysicalDevices ) + DECLARE_IS_DISPATCHED( vkExportMetalObjectsEXT ) + DECLARE_IS_DISPATCHED( vkFlushMappedMemoryRanges ) + DECLARE_IS_DISPATCHED( vkFreeCommandBuffers ) + DECLARE_IS_DISPATCHED( vkFreeDescriptorSets ) + DECLARE_IS_DISPATCHED( vkFreeMemory ) + DECLARE_IS_DISPATCHED( vkGetAccelerationStructureBuildSizesKHR ) + DECLARE_IS_DISPATCHED( vkGetAccelerationStructureDeviceAddressKHR ) + DECLARE_IS_DISPATCHED( vkGetAccelerationStructureHandleNV ) + DECLARE_IS_DISPATCHED( vkGetAccelerationStructureMemoryRequirementsNV ) + DECLARE_IS_DISPATCHED( vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT ) + DECLARE_IS_DISPATCHED( vkGetAndroidHardwareBufferPropertiesANDROID ) + DECLARE_IS_DISPATCHED( vkGetBufferCollectionPropertiesFUCHSIA ) + DECLARE_IS_DISPATCHED( vkGetBufferDeviceAddress ) + DECLARE_IS_DISPATCHED( vkGetBufferDeviceAddressEXT ) + DECLARE_IS_DISPATCHED( vkGetBufferDeviceAddressKHR ) + DECLARE_IS_DISPATCHED( vkGetBufferMemoryRequirements ) + DECLARE_IS_DISPATCHED( vkGetBufferMemoryRequirements2 ) + DECLARE_IS_DISPATCHED( vkGetBufferMemoryRequirements2KHR ) + DECLARE_IS_DISPATCHED( vkGetBufferOpaqueCaptureAddress ) + DECLARE_IS_DISPATCHED( vkGetBufferOpaqueCaptureAddressKHR ) + DECLARE_IS_DISPATCHED( vkGetBufferOpaqueCaptureDescriptorDataEXT ) + DECLARE_IS_DISPATCHED( vkGetCalibratedTimestampsKHR ) + DECLARE_IS_DISPATCHED( vkGetCalibratedTimestampsEXT ) + DECLARE_IS_DISPATCHED( vkGetClusterAccelerationStructureBuildSizesNV ) + DECLARE_IS_DISPATCHED( vkGetCommandPoolMemoryConsumption ) + DECLARE_IS_DISPATCHED( vkGetCudaModuleCacheNV ) + DECLARE_IS_DISPATCHED( vkGetDataGraphPipelineAvailablePropertiesARM ) + DECLARE_IS_DISPATCHED( vkGetDataGraphPipelinePropertiesARM ) + DECLARE_IS_DISPATCHED( vkGetDataGraphPipelineSessionBindPointRequirementsARM ) + DECLARE_IS_DISPATCHED( vkGetDataGraphPipelineSessionMemoryRequirementsARM ) + DECLARE_IS_DISPATCHED( vkGetDeferredOperationMaxConcurrencyKHR ) + DECLARE_IS_DISPATCHED( vkGetDeferredOperationResultKHR ) + DECLARE_IS_DISPATCHED( vkGetDescriptorEXT ) + DECLARE_IS_DISPATCHED( vkGetDescriptorSetHostMappingVALVE ) + DECLARE_IS_DISPATCHED( vkGetDescriptorSetLayoutBindingOffsetEXT ) + DECLARE_IS_DISPATCHED( vkGetDescriptorSetLayoutHostMappingInfoVALVE ) + DECLARE_IS_DISPATCHED( vkGetDescriptorSetLayoutSizeEXT ) + DECLARE_IS_DISPATCHED( vkGetDescriptorSetLayoutSupport ) + DECLARE_IS_DISPATCHED( vkGetDescriptorSetLayoutSupportKHR ) + DECLARE_IS_DISPATCHED( vkGetDeviceAccelerationStructureCompatibilityKHR ) + DECLARE_IS_DISPATCHED( vkGetDeviceBufferMemoryRequirements ) + DECLARE_IS_DISPATCHED( vkGetDeviceBufferMemoryRequirementsKHR ) + DECLARE_IS_DISPATCHED( vkGetDeviceCombinedImageSamplerIndexNVX ) + DECLARE_IS_DISPATCHED( vkGetDeviceFaultInfoEXT ) + DECLARE_IS_DISPATCHED( vkGetDeviceGroupPeerMemoryFeatures ) + DECLARE_IS_DISPATCHED( vkGetDeviceGroupPeerMemoryFeaturesKHR ) + DECLARE_IS_DISPATCHED( vkGetDeviceGroupPresentCapabilitiesKHR ) + DECLARE_IS_DISPATCHED( vkGetDeviceGroupSurfacePresentModes2EXT ) + DECLARE_IS_DISPATCHED( vkGetDeviceGroupSurfacePresentModesKHR ) + DECLARE_IS_DISPATCHED( vkGetDeviceImageMemoryRequirements ) + DECLARE_IS_DISPATCHED( vkGetDeviceImageMemoryRequirementsKHR ) + DECLARE_IS_DISPATCHED( vkGetDeviceImageSparseMemoryRequirements ) + DECLARE_IS_DISPATCHED( vkGetDeviceImageSparseMemoryRequirementsKHR ) + DECLARE_IS_DISPATCHED( vkGetDeviceImageSubresourceLayout ) + DECLARE_IS_DISPATCHED( vkGetDeviceImageSubresourceLayoutKHR ) + DECLARE_IS_DISPATCHED( vkGetDeviceMemoryCommitment ) + DECLARE_IS_DISPATCHED( vkGetDeviceMemoryOpaqueCaptureAddress ) + DECLARE_IS_DISPATCHED( vkGetDeviceMemoryOpaqueCaptureAddressKHR ) + DECLARE_IS_DISPATCHED( vkGetDeviceMicromapCompatibilityEXT ) + DECLARE_IS_DISPATCHED( vkGetDeviceProcAddr ) + DECLARE_IS_DISPATCHED( vkGetDeviceQueue ) + DECLARE_IS_DISPATCHED( vkGetDeviceQueue2 ) + DECLARE_IS_DISPATCHED( vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI ) + DECLARE_IS_DISPATCHED( vkGetDeviceTensorMemoryRequirementsARM ) + DECLARE_IS_DISPATCHED( vkGetDisplayModeProperties2KHR ) + DECLARE_IS_DISPATCHED( vkGetDisplayModePropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetDisplayPlaneCapabilities2KHR ) + DECLARE_IS_DISPATCHED( vkGetDisplayPlaneCapabilitiesKHR ) + DECLARE_IS_DISPATCHED( vkGetDisplayPlaneSupportedDisplaysKHR ) + DECLARE_IS_DISPATCHED( vkGetDrmDisplayEXT ) + DECLARE_IS_DISPATCHED( vkGetDynamicRenderingTilePropertiesQCOM ) + DECLARE_IS_DISPATCHED( vkGetEncodedVideoSessionParametersKHR ) + DECLARE_IS_DISPATCHED( vkGetEventStatus ) + DECLARE_IS_DISPATCHED( vkGetExecutionGraphPipelineNodeIndexAMDX ) + DECLARE_IS_DISPATCHED( vkGetExecutionGraphPipelineScratchSizeAMDX ) + DECLARE_IS_DISPATCHED( vkGetExternalComputeQueueDataNV ) + DECLARE_IS_DISPATCHED( vkGetFaultData ) + DECLARE_IS_DISPATCHED( vkGetFenceFdKHR ) + DECLARE_IS_DISPATCHED( vkGetFenceSciSyncFenceNV ) + DECLARE_IS_DISPATCHED( vkGetFenceSciSyncObjNV ) + DECLARE_IS_DISPATCHED( vkGetFenceStatus ) + DECLARE_IS_DISPATCHED( vkGetFenceWin32HandleKHR ) + DECLARE_IS_DISPATCHED( vkGetFramebufferTilePropertiesQCOM ) + DECLARE_IS_DISPATCHED( vkGetGeneratedCommandsMemoryRequirementsEXT ) + DECLARE_IS_DISPATCHED( vkGetGeneratedCommandsMemoryRequirementsNV ) + DECLARE_IS_DISPATCHED( vkGetImageDrmFormatModifierPropertiesEXT ) + DECLARE_IS_DISPATCHED( vkGetImageMemoryRequirements ) + DECLARE_IS_DISPATCHED( vkGetImageMemoryRequirements2 ) + DECLARE_IS_DISPATCHED( vkGetImageMemoryRequirements2KHR ) + DECLARE_IS_DISPATCHED( vkGetImageOpaqueCaptureDataEXT ) + DECLARE_IS_DISPATCHED( vkGetImageOpaqueCaptureDescriptorDataEXT ) + DECLARE_IS_DISPATCHED( vkGetImageSparseMemoryRequirements ) + DECLARE_IS_DISPATCHED( vkGetImageSparseMemoryRequirements2 ) + DECLARE_IS_DISPATCHED( vkGetImageSparseMemoryRequirements2KHR ) + DECLARE_IS_DISPATCHED( vkGetImageSubresourceLayout ) + DECLARE_IS_DISPATCHED( vkGetImageSubresourceLayout2 ) + DECLARE_IS_DISPATCHED( vkGetImageSubresourceLayout2EXT ) + DECLARE_IS_DISPATCHED( vkGetImageSubresourceLayout2KHR ) + DECLARE_IS_DISPATCHED( vkGetImageViewAddressNVX ) + DECLARE_IS_DISPATCHED( vkGetImageViewHandle64NVX ) + DECLARE_IS_DISPATCHED( vkGetImageViewHandleNVX ) + DECLARE_IS_DISPATCHED( vkGetImageViewOpaqueCaptureDescriptorDataEXT ) + DECLARE_IS_DISPATCHED( vkGetInstanceProcAddr ) + DECLARE_IS_DISPATCHED( vkGetLatencyTimingsNV ) + DECLARE_IS_DISPATCHED( vkGetMemoryAndroidHardwareBufferANDROID ) + DECLARE_IS_DISPATCHED( vkGetMemoryFdKHR ) + DECLARE_IS_DISPATCHED( vkGetMemoryFdPropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetMemoryHostPointerPropertiesEXT ) + DECLARE_IS_DISPATCHED( vkGetMemoryMetalHandleEXT ) + DECLARE_IS_DISPATCHED( vkGetMemoryMetalHandlePropertiesEXT ) + DECLARE_IS_DISPATCHED( vkGetMemoryNativeBufferOHOS ) + DECLARE_IS_DISPATCHED( vkGetMemoryRemoteAddressNV ) + DECLARE_IS_DISPATCHED( vkGetMemorySciBufNV ) + DECLARE_IS_DISPATCHED( vkGetMemoryWin32HandleKHR ) + DECLARE_IS_DISPATCHED( vkGetMemoryWin32HandleNV ) + DECLARE_IS_DISPATCHED( vkGetMemoryWin32HandlePropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetMemoryZirconHandleFUCHSIA ) + DECLARE_IS_DISPATCHED( vkGetMemoryZirconHandlePropertiesFUCHSIA ) + DECLARE_IS_DISPATCHED( vkGetMicromapBuildSizesEXT ) + DECLARE_IS_DISPATCHED( vkGetNativeBufferPropertiesOHOS ) + DECLARE_IS_DISPATCHED( vkGetPartitionedAccelerationStructuresBuildSizesNV ) + DECLARE_IS_DISPATCHED( vkGetPastPresentationTimingEXT ) + DECLARE_IS_DISPATCHED( vkGetPastPresentationTimingGOOGLE ) + DECLARE_IS_DISPATCHED( vkGetPerformanceParameterINTEL ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCalibrateableTimeDomainsKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCalibrateableTimeDomainsEXT ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixPropertiesNV ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeVectorPropertiesNV ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDescriptorSizeEXT ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDirectFBPresentationSupportEXT ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDisplayPlaneProperties2KHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDisplayPlanePropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDisplayProperties2KHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDisplayPropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalBufferProperties ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalBufferPropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalFenceProperties ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalFencePropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalImageFormatPropertiesNV ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalSemaphoreProperties ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalSemaphorePropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalTensorPropertiesARM ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFeatures ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFeatures2 ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFeatures2KHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFormatProperties ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFormatProperties2 ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFormatProperties2KHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFragmentShadingRatesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceImageFormatProperties ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceImageFormatProperties2 ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceImageFormatProperties2KHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceMemoryProperties ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceMemoryProperties2 ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceMemoryProperties2KHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceMultisamplePropertiesEXT ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceOpticalFlowImageFormatsNV ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDevicePresentRectanglesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceProperties ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceProperties2 ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceProperties2KHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyProperties ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyProperties2 ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyProperties2KHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceRefreshableObjectTypesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSciBufAttributesNV ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSciSyncAttributesNV ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceScreenPresentationSupportQNX ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSparseImageFormatProperties ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSparseImageFormatProperties2 ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSparseImageFormatProperties2KHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceCapabilities2EXT ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceCapabilities2KHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceCapabilitiesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceFormats2KHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceFormatsKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfacePresentModes2EXT ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfacePresentModesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceSupportKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceToolProperties ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceToolPropertiesEXT ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceVideoCapabilitiesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceVideoFormatPropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceWaylandPresentationSupportKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceWin32PresentationSupportKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceXcbPresentationSupportKHR ) + DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceXlibPresentationSupportKHR ) + DECLARE_IS_DISPATCHED( vkGetPipelineBinaryDataKHR ) + DECLARE_IS_DISPATCHED( vkGetPipelineCacheData ) + DECLARE_IS_DISPATCHED( vkGetPipelineExecutableInternalRepresentationsKHR ) + DECLARE_IS_DISPATCHED( vkGetPipelineExecutablePropertiesKHR ) + DECLARE_IS_DISPATCHED( vkGetPipelineExecutableStatisticsKHR ) + DECLARE_IS_DISPATCHED( vkGetPipelineIndirectDeviceAddressNV ) + DECLARE_IS_DISPATCHED( vkGetPipelineIndirectMemoryRequirementsNV ) + DECLARE_IS_DISPATCHED( vkGetPipelineKeyKHR ) + DECLARE_IS_DISPATCHED( vkGetPipelinePropertiesEXT ) + DECLARE_IS_DISPATCHED( vkGetPrivateData ) + DECLARE_IS_DISPATCHED( vkGetPrivateDataEXT ) + DECLARE_IS_DISPATCHED( vkGetQueryPoolResults ) + DECLARE_IS_DISPATCHED( vkGetQueueCheckpointData2NV ) + DECLARE_IS_DISPATCHED( vkGetQueueCheckpointDataNV ) + DECLARE_IS_DISPATCHED( vkGetRandROutputDisplayEXT ) + DECLARE_IS_DISPATCHED( vkGetRayTracingCaptureReplayShaderGroupHandlesKHR ) + DECLARE_IS_DISPATCHED( vkGetRayTracingShaderGroupHandlesKHR ) + DECLARE_IS_DISPATCHED( vkGetRayTracingShaderGroupHandlesNV ) + DECLARE_IS_DISPATCHED( vkGetRayTracingShaderGroupStackSizeKHR ) + DECLARE_IS_DISPATCHED( vkGetRefreshCycleDurationGOOGLE ) + DECLARE_IS_DISPATCHED( vkGetRenderAreaGranularity ) + DECLARE_IS_DISPATCHED( vkGetRenderingAreaGranularity ) + DECLARE_IS_DISPATCHED( vkGetRenderingAreaGranularityKHR ) + DECLARE_IS_DISPATCHED( vkGetSamplerOpaqueCaptureDescriptorDataEXT ) + DECLARE_IS_DISPATCHED( vkGetScreenBufferPropertiesQNX ) + DECLARE_IS_DISPATCHED( vkGetSemaphoreCounterValue ) + DECLARE_IS_DISPATCHED( vkGetSemaphoreCounterValueKHR ) + DECLARE_IS_DISPATCHED( vkGetSemaphoreFdKHR ) + DECLARE_IS_DISPATCHED( vkGetSemaphoreSciSyncObjNV ) + DECLARE_IS_DISPATCHED( vkGetSemaphoreWin32HandleKHR ) + DECLARE_IS_DISPATCHED( vkGetSemaphoreZirconHandleFUCHSIA ) + DECLARE_IS_DISPATCHED( vkGetShaderBinaryDataEXT ) + DECLARE_IS_DISPATCHED( vkGetShaderInfoAMD ) + DECLARE_IS_DISPATCHED( vkGetShaderModuleCreateInfoIdentifierEXT ) + DECLARE_IS_DISPATCHED( vkGetShaderModuleIdentifierEXT ) + DECLARE_IS_DISPATCHED( vkGetSwapchainCounterEXT ) + DECLARE_IS_DISPATCHED( vkGetSwapchainGrallocUsage2ANDROID ) + DECLARE_IS_DISPATCHED( vkGetSwapchainGrallocUsageANDROID ) + DECLARE_IS_DISPATCHED( vkGetSwapchainGrallocUsageOHOS ) + DECLARE_IS_DISPATCHED( vkGetSwapchainImagesKHR ) + DECLARE_IS_DISPATCHED( vkGetSwapchainStatusKHR ) + DECLARE_IS_DISPATCHED( vkGetSwapchainTimeDomainPropertiesEXT ) + DECLARE_IS_DISPATCHED( vkGetSwapchainTimingPropertiesEXT ) + DECLARE_IS_DISPATCHED( vkGetTensorMemoryRequirementsARM ) + DECLARE_IS_DISPATCHED( vkGetTensorOpaqueCaptureDataARM ) + DECLARE_IS_DISPATCHED( vkGetTensorOpaqueCaptureDescriptorDataARM ) + DECLARE_IS_DISPATCHED( vkGetTensorViewOpaqueCaptureDescriptorDataARM ) + DECLARE_IS_DISPATCHED( vkGetValidationCacheDataEXT ) + DECLARE_IS_DISPATCHED( vkGetVideoSessionMemoryRequirementsKHR ) + DECLARE_IS_DISPATCHED( vkGetWinrtDisplayNV ) + DECLARE_IS_DISPATCHED( vkImportFenceFdKHR ) + DECLARE_IS_DISPATCHED( vkImportFenceSciSyncFenceNV ) + DECLARE_IS_DISPATCHED( vkImportFenceSciSyncObjNV ) + DECLARE_IS_DISPATCHED( vkImportFenceWin32HandleKHR ) + DECLARE_IS_DISPATCHED( vkImportSemaphoreFdKHR ) + DECLARE_IS_DISPATCHED( vkImportSemaphoreSciSyncObjNV ) + DECLARE_IS_DISPATCHED( vkImportSemaphoreWin32HandleKHR ) + DECLARE_IS_DISPATCHED( vkImportSemaphoreZirconHandleFUCHSIA ) + DECLARE_IS_DISPATCHED( vkInitializePerformanceApiINTEL ) + DECLARE_IS_DISPATCHED( vkInvalidateMappedMemoryRanges ) + DECLARE_IS_DISPATCHED( vkLatencySleepNV ) + DECLARE_IS_DISPATCHED( vkMapMemory ) + DECLARE_IS_DISPATCHED( vkMapMemory2 ) + DECLARE_IS_DISPATCHED( vkMapMemory2KHR ) + DECLARE_IS_DISPATCHED( vkMergePipelineCaches ) + DECLARE_IS_DISPATCHED( vkMergeValidationCachesEXT ) + DECLARE_IS_DISPATCHED( vkQueueBeginDebugUtilsLabelEXT ) + DECLARE_IS_DISPATCHED( vkQueueBindSparse ) + DECLARE_IS_DISPATCHED( vkQueueEndDebugUtilsLabelEXT ) + DECLARE_IS_DISPATCHED( vkQueueInsertDebugUtilsLabelEXT ) + DECLARE_IS_DISPATCHED( vkQueueNotifyOutOfBandNV ) + DECLARE_IS_DISPATCHED( vkQueuePresentKHR ) + DECLARE_IS_DISPATCHED( vkQueueSetPerformanceConfigurationINTEL ) + DECLARE_IS_DISPATCHED( vkQueueSignalReleaseImageANDROID ) + DECLARE_IS_DISPATCHED( vkQueueSignalReleaseImageOHOS ) + DECLARE_IS_DISPATCHED( vkQueueSubmit ) + DECLARE_IS_DISPATCHED( vkQueueSubmit2 ) + DECLARE_IS_DISPATCHED( vkQueueSubmit2KHR ) + DECLARE_IS_DISPATCHED( vkQueueWaitIdle ) + DECLARE_IS_DISPATCHED( vkRegisterCustomBorderColorEXT ) + DECLARE_IS_DISPATCHED( vkRegisterDeviceEventEXT ) + DECLARE_IS_DISPATCHED( vkRegisterDisplayEventEXT ) + DECLARE_IS_DISPATCHED( vkReleaseCapturedPipelineDataKHR ) + DECLARE_IS_DISPATCHED( vkReleaseDisplayEXT ) + DECLARE_IS_DISPATCHED( vkReleaseFullScreenExclusiveModeEXT ) + DECLARE_IS_DISPATCHED( vkReleasePerformanceConfigurationINTEL ) + DECLARE_IS_DISPATCHED( vkReleaseProfilingLockKHR ) + DECLARE_IS_DISPATCHED( vkReleaseSwapchainImagesKHR ) + DECLARE_IS_DISPATCHED( vkReleaseSwapchainImagesEXT ) + DECLARE_IS_DISPATCHED( vkResetCommandBuffer ) + DECLARE_IS_DISPATCHED( vkResetCommandPool ) + DECLARE_IS_DISPATCHED( vkResetDescriptorPool ) + DECLARE_IS_DISPATCHED( vkResetEvent ) + DECLARE_IS_DISPATCHED( vkResetFences ) + DECLARE_IS_DISPATCHED( vkResetQueryPool ) + DECLARE_IS_DISPATCHED( vkResetQueryPoolEXT ) + DECLARE_IS_DISPATCHED( vkSetBufferCollectionBufferConstraintsFUCHSIA ) + DECLARE_IS_DISPATCHED( vkSetBufferCollectionImageConstraintsFUCHSIA ) + DECLARE_IS_DISPATCHED( vkSetDebugUtilsObjectNameEXT ) + DECLARE_IS_DISPATCHED( vkSetDebugUtilsObjectTagEXT ) + DECLARE_IS_DISPATCHED( vkSetDeviceMemoryPriorityEXT ) + DECLARE_IS_DISPATCHED( vkSetEvent ) + DECLARE_IS_DISPATCHED( vkSetHdrMetadataEXT ) + DECLARE_IS_DISPATCHED( vkSetLatencyMarkerNV ) + DECLARE_IS_DISPATCHED( vkSetLatencySleepModeNV ) + DECLARE_IS_DISPATCHED( vkSetLocalDimmingAMD ) + DECLARE_IS_DISPATCHED( vkSetPrivateData ) + DECLARE_IS_DISPATCHED( vkSetPrivateDataEXT ) + DECLARE_IS_DISPATCHED( vkSetSwapchainPresentTimingQueueSizeEXT ) + DECLARE_IS_DISPATCHED( vkSignalSemaphore ) + DECLARE_IS_DISPATCHED( vkSignalSemaphoreKHR ) + DECLARE_IS_DISPATCHED( vkSubmitDebugUtilsMessageEXT ) + DECLARE_IS_DISPATCHED( vkTransitionImageLayout ) + DECLARE_IS_DISPATCHED( vkTransitionImageLayoutEXT ) + DECLARE_IS_DISPATCHED( vkTrimCommandPool ) + DECLARE_IS_DISPATCHED( vkTrimCommandPoolKHR ) + DECLARE_IS_DISPATCHED( vkUninitializePerformanceApiINTEL ) + DECLARE_IS_DISPATCHED( vkUnmapMemory ) + DECLARE_IS_DISPATCHED( vkUnmapMemory2 ) + DECLARE_IS_DISPATCHED( vkUnmapMemory2KHR ) + DECLARE_IS_DISPATCHED( vkUnregisterCustomBorderColorEXT ) + DECLARE_IS_DISPATCHED( vkUpdateDescriptorSetWithTemplate ) + DECLARE_IS_DISPATCHED( vkUpdateDescriptorSetWithTemplateKHR ) + DECLARE_IS_DISPATCHED( vkUpdateDescriptorSets ) + DECLARE_IS_DISPATCHED( vkUpdateIndirectExecutionSetPipelineEXT ) + DECLARE_IS_DISPATCHED( vkUpdateIndirectExecutionSetShaderEXT ) + DECLARE_IS_DISPATCHED( vkUpdateVideoSessionParametersKHR ) + DECLARE_IS_DISPATCHED( vkWaitForFences ) + DECLARE_IS_DISPATCHED( vkWaitForPresent2KHR ) + DECLARE_IS_DISPATCHED( vkWaitForPresentKHR ) + DECLARE_IS_DISPATCHED( vkWaitSemaphores ) + DECLARE_IS_DISPATCHED( vkWaitSemaphoresKHR ) + DECLARE_IS_DISPATCHED( vkWriteAccelerationStructuresPropertiesKHR ) + DECLARE_IS_DISPATCHED( vkWriteMicromapsPropertiesEXT ) + DECLARE_IS_DISPATCHED( vkWriteResourceDescriptorsEXT ) + DECLARE_IS_DISPATCHED( vkWriteSamplerDescriptorsEXT ) + +#undef DECLARE_IS_DISPATCHED + +#define IS_DISPATCHED( name ) ::VULKAN_HPP_NAMESPACE::detail::has_##name::value + + class DispatchLoaderBase + { + public: + DispatchLoaderBase() = default; + DispatchLoaderBase( std::nullptr_t ) +#if !defined( NDEBUG ) + : m_valid( false ) +#endif + { + } + +#if !defined( NDEBUG ) + size_t getVkHeaderVersion() const + { + VULKAN_HPP_ASSERT( m_valid ); + return vkHeaderVersion; + } + + private: + size_t vkHeaderVersion = VK_HEADER_VERSION; + bool m_valid = true; +#endif + }; + +#if !defined( VK_NO_PROTOTYPES ) || ( defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC ) && ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 0 ) ) + class DispatchLoaderStatic : public DispatchLoaderBase + { + public: + //=== VK_VERSION_1_0 === + + VkResult + vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance ); + } + + void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyInstance( instance, pAllocator ); + } + + VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT + { + return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices ); + } + + void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures ); + } + + void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties ); + } + + VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties ); + } + + void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties ); + } + + void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, + uint32_t * pQueueFamilyPropertyCount, + VkQueueFamilyProperties * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); + } + + void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties ); + } + + PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetInstanceProcAddr( instance, pName ); + } + + PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceProcAddr( device, pName ); + } + + VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkDevice * pDevice ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice ); + } + + void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyDevice( device, pAllocator ); + } + + VkResult vkEnumerateInstanceExtensionProperties( const char * pLayerName, + uint32_t * pPropertyCount, + VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties ); + } + + VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, + const char * pLayerName, + uint32_t * pPropertyCount, + VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties ); + } + + VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties ); + } + + VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, + uint32_t * pPropertyCount, + VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties ); + } + + void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue ); + } + + VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT + { + return ::vkQueueSubmit( queue, submitCount, pSubmits, fence ); + } + + VkResult vkQueueWaitIdle( VkQueue queue ) const VULKAN_HPP_NOEXCEPT + { + return ::vkQueueWaitIdle( queue ); + } + + VkResult vkDeviceWaitIdle( VkDevice device ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDeviceWaitIdle( device ); + } + + VkResult vkAllocateMemory( VkDevice device, + const VkMemoryAllocateInfo * pAllocateInfo, + const VkAllocationCallbacks * pAllocator, + VkDeviceMemory * pMemory ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory ); + } + + void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkFreeMemory( device, memory, pAllocator ); + } + + VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkMapMemory( device, memory, offset, size, flags, ppData ); + } + + void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT + { + return ::vkUnmapMemory( device, memory ); + } + + VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT + { + return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges ); + } + + VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT + { + return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges ); + } + + void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes ); + } + + VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBindBufferMemory( device, buffer, memory, memoryOffset ); + } + + VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBindImageMemory( device, image, memory, memoryOffset ); + } + + void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements ); + } + + void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements ); + } + + void vkGetImageSparseMemoryRequirements( VkDevice device, + VkImage image, + uint32_t * pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); + } + + void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t * pPropertyCount, + VkSparseImageFormatProperties * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties ); + } + + VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo * pBindInfo, VkFence fence ) const VULKAN_HPP_NOEXCEPT + { + return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence ); + } + + VkResult vkCreateFence( VkDevice device, + const VkFenceCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkFence * pFence ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence ); + } + + void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyFence( device, fence, pAllocator ); + } + + VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT + { + return ::vkResetFences( device, fenceCount, pFences ); + } + + VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetFenceStatus( device, fence ); + } + + VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences, VkBool32 waitAll, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout ); + } + + VkResult vkCreateSemaphore( VkDevice device, + const VkSemaphoreCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSemaphore * pSemaphore ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore ); + } + + void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroySemaphore( device, semaphore, pAllocator ); + } + + VkResult vkCreateQueryPool( VkDevice device, + const VkQueryPoolCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkQueryPool * pQueryPool ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool ); + } + + void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyQueryPool( device, queryPool, pAllocator ); + } + + VkResult vkGetQueryPoolResults( VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void * pData, + VkDeviceSize stride, + VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags ); + } + + VkResult vkCreateBuffer( VkDevice device, + const VkBufferCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkBuffer * pBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer ); + } + + void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyBuffer( device, buffer, pAllocator ); + } + + VkResult vkCreateImage( VkDevice device, + const VkImageCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkImage * pImage ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage ); + } + + void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyImage( device, image, pAllocator ); + } + + void vkGetImageSubresourceLayout( VkDevice device, + VkImage image, + const VkImageSubresource * pSubresource, + VkSubresourceLayout * pLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout ); + } + + VkResult vkCreateImageView( VkDevice device, + const VkImageViewCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkImageView * pView ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView ); + } + + void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyImageView( device, imageView, pAllocator ); + } + + VkResult vkCreateCommandPool( VkDevice device, + const VkCommandPoolCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkCommandPool * pCommandPool ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool ); + } + + void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyCommandPool( device, commandPool, pAllocator ); + } + + VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT + { + return ::vkResetCommandPool( device, commandPool, flags ); + } + + VkResult vkAllocateCommandBuffers( VkDevice device, + const VkCommandBufferAllocateInfo * pAllocateInfo, + VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers ); + } + + void vkFreeCommandBuffers( VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT + { + return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers ); + } + + VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo ); + } + + VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkEndCommandBuffer( commandBuffer ); + } + + VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT + { + return ::vkResetCommandBuffer( commandBuffer, flags ); + } + + void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy * pRegions ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions ); + } + + void vkCmdCopyImage( VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); + } + + void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions ); + } + + void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions ); + } + + void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void * pData ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData ); + } + + void + vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data ); + } + + void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier * pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier * pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPipelineBarrier( commandBuffer, + srcStageMask, + dstStageMask, + dependencyFlags, + memoryBarrierCount, + pMemoryBarriers, + bufferMemoryBarrierCount, + pBufferMemoryBarriers, + imageMemoryBarrierCount, + pImageMemoryBarriers ); + } + + void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags ); + } + + void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndQuery( commandBuffer, queryPool, query ); + } + + void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount ); + } + + void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query ); + } + + void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags ); + } + + void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers ); + } + + VkResult vkCreateEvent( VkDevice device, + const VkEventCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkEvent * pEvent ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent ); + } + + void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyEvent( device, event, pAllocator ); + } + + VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetEventStatus( device, event ); + } + + VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetEvent( device, event ); + } + + VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT + { + return ::vkResetEvent( device, event ); + } + + VkResult vkCreateBufferView( VkDevice device, + const VkBufferViewCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkBufferView * pView ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView ); + } + + void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyBufferView( device, bufferView, pAllocator ); + } + + VkResult vkCreateShaderModule( VkDevice device, + const VkShaderModuleCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkShaderModule * pShaderModule ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule ); + } + + void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyShaderModule( device, shaderModule, pAllocator ); + } + + VkResult vkCreatePipelineCache( VkDevice device, + const VkPipelineCacheCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkPipelineCache * pPipelineCache ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache ); + } + + void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator ); + } + + VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData ); + } + + VkResult + vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT + { + return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches ); + } + + VkResult vkCreateComputePipelines( VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo * pCreateInfos, + const VkAllocationCallbacks * pAllocator, + VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); + } + + void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyPipeline( device, pipeline, pAllocator ); + } + + VkResult vkCreatePipelineLayout( VkDevice device, + const VkPipelineLayoutCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkPipelineLayout * pPipelineLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout ); + } + + void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator ); + } + + VkResult vkCreateSampler( VkDevice device, + const VkSamplerCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSampler * pSampler ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler ); + } + + void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroySampler( device, sampler, pAllocator ); + } + + VkResult vkCreateDescriptorSetLayout( VkDevice device, + const VkDescriptorSetLayoutCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkDescriptorSetLayout * pSetLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout ); + } + + void vkDestroyDescriptorSetLayout( VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator ); + } + + VkResult vkCreateDescriptorPool( VkDevice device, + const VkDescriptorPoolCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkDescriptorPool * pDescriptorPool ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool ); + } + + void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator ); + } + + VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT + { + return ::vkResetDescriptorPool( device, descriptorPool, flags ); + } + + VkResult vkAllocateDescriptorSets( VkDevice device, + const VkDescriptorSetAllocateInfo * pAllocateInfo, + VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets ); + } + + VkResult vkFreeDescriptorSets( VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT + { + return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets ); + } + + void vkUpdateDescriptorSets( VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet * pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet * pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT + { + return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies ); + } + + void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline ); + } + + void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet * pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t * pDynamicOffsets ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindDescriptorSets( + commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets ); + } + + void vkCmdClearColorImage( VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue * pColor, + uint32_t rangeCount, + const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges ); + } + + void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ ); + } + + void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset ); + } + + void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetEvent( commandBuffer, event, stageMask ); + } + + void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdResetEvent( commandBuffer, event, stageMask ); + } + + void vkCmdWaitEvents( VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent * pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier * pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier * pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWaitEvents( commandBuffer, + eventCount, + pEvents, + srcStageMask, + dstStageMask, + memoryBarrierCount, + pMemoryBarriers, + bufferMemoryBarrierCount, + pBufferMemoryBarriers, + imageMemoryBarrierCount, + pImageMemoryBarriers ); + } + + void vkCmdPushConstants( VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void * pValues ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues ); + } + + VkResult vkCreateGraphicsPipelines( VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo * pCreateInfos, + const VkAllocationCallbacks * pAllocator, + VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); + } + + VkResult vkCreateFramebuffer( VkDevice device, + const VkFramebufferCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkFramebuffer * pFramebuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer ); + } + + void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyFramebuffer( device, framebuffer, pAllocator ); + } + + VkResult vkCreateRenderPass( VkDevice device, + const VkRenderPassCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass ); + } + + void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyRenderPass( device, renderPass, pAllocator ); + } + + void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity ); + } + + void vkCmdSetViewport( VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports ); + } + + void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors ); + } + + void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetLineWidth( commandBuffer, lineWidth ); + } + + void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); + } + + void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetBlendConstants( commandBuffer, blendConstants ); + } + + void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds ); + } + + void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask ); + } + + void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask ); + } + + void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference ); + } + + void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType ); + } + + void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer * pBuffers, + const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets ); + } + + void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance ); + } + + void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); + } + + void + vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride ); + } + + void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride ); + } + + void vkCmdBlitImage( VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit * pRegions, + VkFilter filter ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter ); + } + + void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue * pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges ); + } + + void vkCmdClearAttachments( VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment * pAttachments, + uint32_t rectCount, + const VkClearRect * pRects ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects ); + } + + void vkCmdResolveImage( VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); + } + + void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo * pRenderPassBegin, + VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents ); + } + + void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdNextSubpass( commandBuffer, contents ); + } + + void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndRenderPass( commandBuffer ); + } + + //=== VK_VERSION_1_1 === + + VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT + { + return ::vkEnumerateInstanceVersion( pApiVersion ); + } + + VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos ); + } + + VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos ); + } + + void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures ); + } + + void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDeviceMask( commandBuffer, deviceMask ); + } + + VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, + uint32_t * pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties ); + } + + void vkGetImageMemoryRequirements2( VkDevice device, + const VkImageMemoryRequirementsInfo2 * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements ); + } + + void vkGetBufferMemoryRequirements2( VkDevice device, + const VkBufferMemoryRequirementsInfo2 * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements ); + } + + void vkGetImageSparseMemoryRequirements2( VkDevice device, + const VkImageSparseMemoryRequirementsInfo2 * pInfo, + uint32_t * pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); + } + + void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures ); + } + + void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties ); + } + + void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties ); + } + + VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, + VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties ); + } + + void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, + uint32_t * pQueueFamilyPropertyCount, + VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); + } + + void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties ); + } + + void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, + uint32_t * pPropertyCount, + VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties ); + } + + void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT + { + return ::vkTrimCommandPool( device, commandPool, flags ); + } + + void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue ); + } + + void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, + VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties ); + } + + void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, + VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties ); + } + + void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, + VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties ); + } + + void vkCmdDispatchBase( VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); + } + + VkResult vkCreateDescriptorUpdateTemplate( VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate ); + } + + void vkDestroyDescriptorUpdateTemplate( VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator ); + } + + void vkUpdateDescriptorSetWithTemplate( VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData ); + } + + void vkGetDescriptorSetLayoutSupport( VkDevice device, + const VkDescriptorSetLayoutCreateInfo * pCreateInfo, + VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport ); + } + + VkResult vkCreateSamplerYcbcrConversion( VkDevice device, + const VkSamplerYcbcrConversionCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion ); + } + + void vkDestroySamplerYcbcrConversion( VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator ); + } + + //=== VK_VERSION_1_2 === + + void vkResetQueryPool( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT + { + return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount ); + } + + VkResult vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSemaphoreCounterValue( device, semaphore, pValue ); + } + + VkResult vkWaitSemaphores( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkWaitSemaphores( device, pWaitInfo, timeout ); + } + + VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSignalSemaphore( device, pSignalInfo ); + } + + VkDeviceAddress vkGetBufferDeviceAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetBufferDeviceAddress( device, pInfo ); + } + + uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetBufferOpaqueCaptureAddress( device, pInfo ); + } + + uint64_t vkGetDeviceMemoryOpaqueCaptureAddress( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceMemoryOpaqueCaptureAddress( device, pInfo ); + } + + void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); + } + + void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndexedIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); + } + + VkResult vkCreateRenderPass2( VkDevice device, + const VkRenderPassCreateInfo2 * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass ); + } + + void vkCmdBeginRenderPass2( VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo * pRenderPassBegin, + const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo ); + } + + void vkCmdNextSubpass2( VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo * pSubpassBeginInfo, + const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo ); + } + + void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo ); + } + + //=== VK_VERSION_1_3 === + + VkResult vkGetPhysicalDeviceToolProperties( VkPhysicalDevice physicalDevice, + uint32_t * pToolCount, + VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceToolProperties( physicalDevice, pToolCount, pToolProperties ); + } + + VkResult vkCreatePrivateDataSlot( VkDevice device, + const VkPrivateDataSlotCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreatePrivateDataSlot( device, pCreateInfo, pAllocator, pPrivateDataSlot ); + } + + void vkDestroyPrivateDataSlot( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyPrivateDataSlot( device, privateDataSlot, pAllocator ); + } + + VkResult vkSetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkSetPrivateData( device, objectType, objectHandle, privateDataSlot, data ); + } + + void vkGetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkGetPrivateData( device, objectType, objectHandle, privateDataSlot, pData ); + } + + void vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPipelineBarrier2( commandBuffer, pDependencyInfo ); + } + + void vkCmdWriteTimestamp2( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWriteTimestamp2( commandBuffer, stage, queryPool, query ); + } + + VkResult vkQueueSubmit2( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT + { + return ::vkQueueSubmit2( queue, submitCount, pSubmits, fence ); + } + + void vkCmdCopyBuffer2( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyBuffer2( commandBuffer, pCopyBufferInfo ); + } + + void vkCmdCopyImage2( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyImage2( commandBuffer, pCopyImageInfo ); + } + + void vkCmdCopyBufferToImage2( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyBufferToImage2( commandBuffer, pCopyBufferToImageInfo ); + } + + void vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyImageToBuffer2( commandBuffer, pCopyImageToBufferInfo ); + } + + void vkGetDeviceBufferMemoryRequirements( VkDevice device, + const VkDeviceBufferMemoryRequirements * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceBufferMemoryRequirements( device, pInfo, pMemoryRequirements ); + } + + void vkGetDeviceImageMemoryRequirements( VkDevice device, + const VkDeviceImageMemoryRequirements * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceImageMemoryRequirements( device, pInfo, pMemoryRequirements ); + } + + void vkGetDeviceImageSparseMemoryRequirements( VkDevice device, + const VkDeviceImageMemoryRequirements * pInfo, + uint32_t * pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceImageSparseMemoryRequirements( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); + } + + void vkCmdSetEvent2( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetEvent2( commandBuffer, event, pDependencyInfo ); + } + + void vkCmdResetEvent2( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdResetEvent2( commandBuffer, event, stageMask ); + } + + void vkCmdWaitEvents2( VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent * pEvents, + const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWaitEvents2( commandBuffer, eventCount, pEvents, pDependencyInfos ); + } + + void vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBlitImage2( commandBuffer, pBlitImageInfo ); + } + + void vkCmdResolveImage2( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdResolveImage2( commandBuffer, pResolveImageInfo ); + } + + void vkCmdBeginRendering( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginRendering( commandBuffer, pRenderingInfo ); + } + + void vkCmdEndRendering( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndRendering( commandBuffer ); + } + + void vkCmdSetCullMode( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetCullMode( commandBuffer, cullMode ); + } + + void vkCmdSetFrontFace( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetFrontFace( commandBuffer, frontFace ); + } + + void vkCmdSetPrimitiveTopology( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetPrimitiveTopology( commandBuffer, primitiveTopology ); + } + + void vkCmdSetViewportWithCount( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetViewportWithCount( commandBuffer, viewportCount, pViewports ); + } + + void vkCmdSetScissorWithCount( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetScissorWithCount( commandBuffer, scissorCount, pScissors ); + } + + void vkCmdBindVertexBuffers2( VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer * pBuffers, + const VkDeviceSize * pOffsets, + const VkDeviceSize * pSizes, + const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindVertexBuffers2( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides ); + } + + void vkCmdSetDepthTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthTestEnable( commandBuffer, depthTestEnable ); + } + + void vkCmdSetDepthWriteEnable( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthWriteEnable( commandBuffer, depthWriteEnable ); + } + + void vkCmdSetDepthCompareOp( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthCompareOp( commandBuffer, depthCompareOp ); + } + + void vkCmdSetDepthBoundsTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthBoundsTestEnable( commandBuffer, depthBoundsTestEnable ); + } + + void vkCmdSetStencilTestEnable( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetStencilTestEnable( commandBuffer, stencilTestEnable ); + } + + void vkCmdSetStencilOp( VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetStencilOp( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp ); + } + + void vkCmdSetRasterizerDiscardEnable( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetRasterizerDiscardEnable( commandBuffer, rasterizerDiscardEnable ); + } + + void vkCmdSetDepthBiasEnable( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthBiasEnable( commandBuffer, depthBiasEnable ); + } + + void vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetPrimitiveRestartEnable( commandBuffer, primitiveRestartEnable ); + } + + //=== VK_VERSION_1_4 === + + VkResult vkMapMemory2( VkDevice device, const VkMemoryMapInfo * pMemoryMapInfo, void ** ppData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkMapMemory2( device, pMemoryMapInfo, ppData ); + } + + VkResult vkUnmapMemory2( VkDevice device, const VkMemoryUnmapInfo * pMemoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkUnmapMemory2( device, pMemoryUnmapInfo ); + } + + void vkGetDeviceImageSubresourceLayout( VkDevice device, + const VkDeviceImageSubresourceInfo * pInfo, + VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceImageSubresourceLayout( device, pInfo, pLayout ); + } + + void vkGetImageSubresourceLayout2( VkDevice device, + VkImage image, + const VkImageSubresource2 * pSubresource, + VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageSubresourceLayout2( device, image, pSubresource, pLayout ); + } + + VkResult vkCopyMemoryToImage( VkDevice device, const VkCopyMemoryToImageInfo * pCopyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyMemoryToImage( device, pCopyMemoryToImageInfo ); + } + + VkResult vkCopyImageToMemory( VkDevice device, const VkCopyImageToMemoryInfo * pCopyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyImageToMemory( device, pCopyImageToMemoryInfo ); + } + + VkResult vkCopyImageToImage( VkDevice device, const VkCopyImageToImageInfo * pCopyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyImageToImage( device, pCopyImageToImageInfo ); + } + + VkResult + vkTransitionImageLayout( VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo * pTransitions ) const VULKAN_HPP_NOEXCEPT + { + return ::vkTransitionImageLayout( device, transitionCount, pTransitions ); + } + + void vkCmdPushDescriptorSet( VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushDescriptorSet( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites ); + } + + void vkCmdPushDescriptorSetWithTemplate( VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushDescriptorSetWithTemplate( commandBuffer, descriptorUpdateTemplate, layout, set, pData ); + } + + void vkCmdBindDescriptorSets2( VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo * pBindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindDescriptorSets2( commandBuffer, pBindDescriptorSetsInfo ); + } + + void vkCmdPushConstants2( VkCommandBuffer commandBuffer, const VkPushConstantsInfo * pPushConstantsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushConstants2( commandBuffer, pPushConstantsInfo ); + } + + void vkCmdPushDescriptorSet2( VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo * pPushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushDescriptorSet2( commandBuffer, pPushDescriptorSetInfo ); + } + + void vkCmdPushDescriptorSetWithTemplate2( VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushDescriptorSetWithTemplate2( commandBuffer, pPushDescriptorSetWithTemplateInfo ); + } + + void vkCmdSetLineStipple( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetLineStipple( commandBuffer, lineStippleFactor, lineStipplePattern ); + } + + void vkCmdBindIndexBuffer2( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindIndexBuffer2( commandBuffer, buffer, offset, size, indexType ); + } + + void vkGetRenderingAreaGranularity( VkDevice device, const VkRenderingAreaInfo * pRenderingAreaInfo, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetRenderingAreaGranularity( device, pRenderingAreaInfo, pGranularity ); + } + + void vkCmdSetRenderingAttachmentLocations( VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfo * pLocationInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetRenderingAttachmentLocations( commandBuffer, pLocationInfo ); + } + + void vkCmdSetRenderingInputAttachmentIndices( VkCommandBuffer commandBuffer, + const VkRenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetRenderingInputAttachmentIndices( commandBuffer, pInputAttachmentIndexInfo ); + } + + //=== VK_KHR_surface === + + void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroySurfaceKHR( instance, surface, pAllocator ); + } + + VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32 * pSupported ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported ); + } + + VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities ); + } + + VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t * pSurfaceFormatCount, + VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats ); + } + + VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t * pPresentModeCount, + VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes ); + } + + //=== VK_KHR_swapchain === + + VkResult vkCreateSwapchainKHR( VkDevice device, + const VkSwapchainCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSwapchainKHR * pSwapchain ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain ); + } + + void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroySwapchainKHR( device, swapchain, pAllocator ); + } + + VkResult vkGetSwapchainImagesKHR( VkDevice device, + VkSwapchainKHR swapchain, + uint32_t * pSwapchainImageCount, + VkImage * pSwapchainImages ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages ); + } + + VkResult vkAcquireNextImageKHR( + VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex ); + } + + VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR * pPresentInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkQueuePresentKHR( queue, pPresentInfo ); + } + + VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device, + VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities ); + } + + VkResult + vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes ); + } + + VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t * pRectCount, + VkRect2D * pRects ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects ); + } + + VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex ); + } + + //=== VK_KHR_display === + + VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, + uint32_t * pPropertyCount, + VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties ); + } + + VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, + uint32_t * pPropertyCount, + VkDisplayPlanePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties ); + } + + VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t * pDisplayCount, + VkDisplayKHR * pDisplays ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays ); + } + + VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t * pPropertyCount, + VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties ); + } + + VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkDisplayModeKHR * pMode ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode ); + } + + VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities ); + } + + VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); + } + + //=== VK_KHR_display_swapchain === + + VkResult vkCreateSharedSwapchainsKHR( VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR * pCreateInfos, + const VkAllocationCallbacks * pAllocator, + VkSwapchainKHR * pSwapchains ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains ); + } + +# if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + VkResult vkCreateXlibSurfaceKHR( VkInstance instance, + const VkXlibSurfaceCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); + } + + VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display * dpy, + VisualID visualID ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID ); + } +# endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +# if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + VkResult vkCreateXcbSurfaceKHR( VkInstance instance, + const VkXcbSurfaceCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); + } + + VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t * connection, + xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id ); + } +# endif /*VK_USE_PLATFORM_XCB_KHR*/ + +# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + VkResult vkCreateWaylandSurfaceKHR( VkInstance instance, + const VkWaylandSurfaceCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); + } + + VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display * display ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display ); + } +# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, + const VkAndroidSurfaceCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); + } +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + VkResult vkCreateWin32SurfaceKHR( VkInstance instance, + const VkWin32SurfaceCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); + } + + VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + + VkResult vkCreateDebugReportCallbackEXT( VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkDebugReportCallbackEXT * pCallback ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback ); + } + + void vkDestroyDebugReportCallbackEXT( VkInstance instance, + VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator ); + } + + void vkDebugReportMessageEXT( VkInstance instance, + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char * pLayerPrefix, + const char * pMessage ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage ); + } + + //=== VK_EXT_debug_marker === + + VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo ); + } + + VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo ); + } + + void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo ); + } + + void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDebugMarkerEndEXT( commandBuffer ); + } + + void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo ); + } + + //=== VK_KHR_video_queue === + + VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice physicalDevice, + const VkVideoProfileInfoKHR * pVideoProfile, + VkVideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceVideoCapabilitiesKHR( physicalDevice, pVideoProfile, pCapabilities ); + } + + VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, + uint32_t * pVideoFormatPropertyCount, + VkVideoFormatPropertiesKHR * pVideoFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR( physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties ); + } + + VkResult vkCreateVideoSessionKHR( VkDevice device, + const VkVideoSessionCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkVideoSessionKHR * pVideoSession ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateVideoSessionKHR( device, pCreateInfo, pAllocator, pVideoSession ); + } + + void vkDestroyVideoSessionKHR( VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyVideoSessionKHR( device, videoSession, pAllocator ); + } + + VkResult vkGetVideoSessionMemoryRequirementsKHR( VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t * pMemoryRequirementsCount, + VkVideoSessionMemoryRequirementsKHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetVideoSessionMemoryRequirementsKHR( device, videoSession, pMemoryRequirementsCount, pMemoryRequirements ); + } + + VkResult vkBindVideoSessionMemoryKHR( VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const VkBindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBindVideoSessionMemoryKHR( device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos ); + } + + VkResult vkCreateVideoSessionParametersKHR( VkDevice device, + const VkVideoSessionParametersCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkVideoSessionParametersKHR * pVideoSessionParameters ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateVideoSessionParametersKHR( device, pCreateInfo, pAllocator, pVideoSessionParameters ); + } + + VkResult vkUpdateVideoSessionParametersKHR( VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR * pUpdateInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkUpdateVideoSessionParametersKHR( device, videoSessionParameters, pUpdateInfo ); + } + + void vkDestroyVideoSessionParametersKHR( VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyVideoSessionParametersKHR( device, videoSessionParameters, pAllocator ); + } + + void vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR * pBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo ); + } + + void vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR * pEndCodingInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo ); + } + + void vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR * pCodingControlInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo ); + } + + //=== VK_KHR_video_decode_queue === + + void vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR * pDecodeInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDecodeVideoKHR( commandBuffer, pDecodeInfo ); + } + + //=== VK_EXT_transform_feedback === + + void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer * pBuffers, + const VkDeviceSize * pOffsets, + const VkDeviceSize * pSizes ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes ); + } + + void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer * pCounterBuffers, + const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets ); + } + + void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer * pCounterBuffers, + const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets ); + } + + void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index ); + } + + void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index ); + } + + void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + VkBuffer counterBuffer, + VkDeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride ); + } + + //=== VK_NVX_binary_import === + + VkResult vkCreateCuModuleNVX( VkDevice device, + const VkCuModuleCreateInfoNVX * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkCuModuleNVX * pModule ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateCuModuleNVX( device, pCreateInfo, pAllocator, pModule ); + } + + VkResult vkCreateCuFunctionNVX( VkDevice device, + const VkCuFunctionCreateInfoNVX * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkCuFunctionNVX * pFunction ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateCuFunctionNVX( device, pCreateInfo, pAllocator, pFunction ); + } + + void vkDestroyCuModuleNVX( VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyCuModuleNVX( device, module, pAllocator ); + } + + void vkDestroyCuFunctionNVX( VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyCuFunctionNVX( device, function, pAllocator ); + } + + void vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCuLaunchKernelNVX( commandBuffer, pLaunchInfo ); + } + + //=== VK_NVX_image_view_handle === + + uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageViewHandleNVX( device, pInfo ); + } + + uint64_t vkGetImageViewHandle64NVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageViewHandle64NVX( device, pInfo ); + } + + VkResult vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageViewAddressNVX( device, imageView, pProperties ); + } + + uint64_t vkGetDeviceCombinedImageSamplerIndexNVX( VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceCombinedImageSamplerIndexNVX( device, imageViewIndex, samplerIndex ); + } + + //=== VK_AMD_draw_indirect_count === + + void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); + } + + void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); + } + + //=== VK_AMD_shader_info === + + VkResult vkGetShaderInfoAMD( VkDevice device, + VkPipeline pipeline, + VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, + size_t * pInfoSize, + void * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo ); + } + + //=== VK_KHR_dynamic_rendering === + + void vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginRenderingKHR( commandBuffer, pRenderingInfo ); + } + + void vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndRenderingKHR( commandBuffer ); + } + +# if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance instance, + const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface ); + } +# endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + + VkResult + vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( + physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties ); + } + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + + VkResult vkGetMemoryWin32HandleNV( VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_get_physical_device_properties2 === + + void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures ); + } + + void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties ); + } + + void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties ); + } + + VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, + VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties ); + } + + void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, + uint32_t * pQueueFamilyPropertyCount, + VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); + } + + void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties ); + } + + void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, + uint32_t * pPropertyCount, + VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties ); + } + + //=== VK_KHR_device_group === + + void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures ); + } + + void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask ); + } + + void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); + } + +# if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + VkResult vkCreateViSurfaceNN( VkInstance instance, + const VkViSurfaceCreateInfoNN * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface ); + } +# endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_maintenance1 === + + void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT + { + return ::vkTrimCommandPoolKHR( device, commandPool, flags ); + } + + //=== VK_KHR_device_group_creation === + + VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance, + uint32_t * pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties ); + } + + //=== VK_KHR_external_memory_capabilities === + + void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, + VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties ); + } + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + + VkResult + vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle ); + } + + VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + + VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd ); + } + + VkResult vkGetMemoryFdPropertiesKHR( VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + int fd, + VkMemoryFdPropertiesKHR * pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties ); + } + + //=== VK_KHR_external_semaphore_capabilities === + + void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, + VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties ); + } + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + + VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo ); + } + + VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, + HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + + VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo ); + } + + VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd ); + } + + //=== VK_KHR_push_descriptor === + + void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites ); + } + + void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData ); + } + + //=== VK_EXT_conditional_rendering === + + void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin ); + } + + void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndConditionalRenderingEXT( commandBuffer ); + } + + //=== VK_KHR_descriptor_update_template === + + VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate ); + } + + void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator ); + } + + void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData ); + } + + //=== VK_NV_clip_space_w_scaling === + + void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV * pViewportWScalings ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings ); + } + + //=== VK_EXT_direct_mode_display === + + VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT + { + return ::vkReleaseDisplayEXT( physicalDevice, display ); + } + +# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + + VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display ); + } + + VkResult + vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, RROutput rrOutput, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay ); + } +# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + + VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities ); + } + + //=== VK_EXT_display_control === + + VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo ); + } + + VkResult vkRegisterDeviceEventEXT( VkDevice device, + const VkDeviceEventInfoEXT * pDeviceEventInfo, + const VkAllocationCallbacks * pAllocator, + VkFence * pFence ) const VULKAN_HPP_NOEXCEPT + { + return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence ); + } + + VkResult vkRegisterDisplayEventEXT( VkDevice device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT * pDisplayEventInfo, + const VkAllocationCallbacks * pAllocator, + VkFence * pFence ) const VULKAN_HPP_NOEXCEPT + { + return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence ); + } + + VkResult vkGetSwapchainCounterEXT( VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t * pCounterValue ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue ); + } + + //=== VK_GOOGLE_display_timing === + + VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, + VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties ); + } + + VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device, + VkSwapchainKHR swapchain, + uint32_t * pPresentationTimingCount, + VkPastPresentationTimingGOOGLE * pPresentationTimings ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings ); + } + + //=== VK_EXT_discard_rectangles === + + void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles ); + } + + void vkCmdSetDiscardRectangleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDiscardRectangleEnableEXT( commandBuffer, discardRectangleEnable ); + } + + void vkCmdSetDiscardRectangleModeEXT( VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDiscardRectangleModeEXT( commandBuffer, discardRectangleMode ); + } + + //=== VK_EXT_hdr_metadata === + + void vkSetHdrMetadataEXT( VkDevice device, + uint32_t swapchainCount, + const VkSwapchainKHR * pSwapchains, + const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata ); + } + + //=== VK_KHR_create_renderpass2 === + + VkResult vkCreateRenderPass2KHR( VkDevice device, + const VkRenderPassCreateInfo2 * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass ); + } + + void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo * pRenderPassBegin, + const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo ); + } + + void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo * pSubpassBeginInfo, + const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo ); + } + + void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo ); + } + + //=== VK_KHR_shared_presentable_image === + + VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSwapchainStatusKHR( device, swapchain ); + } + + //=== VK_KHR_external_fence_capabilities === + + void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, + VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties ); + } + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + + VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo ); + } + + VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + + VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkImportFenceFdKHR( device, pImportFenceFdInfo ); + } + + VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd ); + } + + //=== VK_KHR_performance_query === + + VkResult + vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t * pCounterCount, + VkPerformanceCounterKHR * pCounters, + VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT + { + return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions ); + } + + void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice physicalDevice, + const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, + uint32_t * pNumPasses ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses ); + } + + VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAcquireProfilingLockKHR( device, pInfo ); + } + + void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT + { + return ::vkReleaseProfilingLockKHR( device ); + } + + //=== VK_KHR_get_surface_capabilities2 === + + VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + VkSurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities ); + } + + VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + uint32_t * pSurfaceFormatCount, + VkSurfaceFormat2KHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats ); + } + + //=== VK_KHR_get_display_properties2 === + + VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, + uint32_t * pPropertyCount, + VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties ); + } + + VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, + uint32_t * pPropertyCount, + VkDisplayPlaneProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties ); + } + + VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t * pPropertyCount, + VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties ); + } + + VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities ); + } + +# if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + VkResult vkCreateIOSSurfaceMVK( VkInstance instance, + const VkIOSSurfaceCreateInfoMVK * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface ); + } +# endif /*VK_USE_PLATFORM_IOS_MVK*/ + +# if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + VkResult vkCreateMacOSSurfaceMVK( VkInstance instance, + const VkMacOSSurfaceCreateInfoMVK * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface ); + } +# endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + + VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo ); + } + + VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo ); + } + + void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo ); + } + + void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const VULKAN_HPP_NOEXCEPT + { + return ::vkQueueEndDebugUtilsLabelEXT( queue ); + } + + void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo ); + } + + void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo ); + } + + void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer ); + } + + void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo ); + } + + VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkDebugUtilsMessengerEXT * pMessenger ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger ); + } + + void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator ); + } + + void vkSubmitDebugUtilsMessageEXT( VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData ); + } + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + + VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, + const struct AHardwareBuffer * buffer, + VkAndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties ); + } + + VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, + const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo, + struct AHardwareBuffer ** pBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer ); + } +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + + VkResult vkCreateExecutionGraphPipelinesAMDX( VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkExecutionGraphPipelineCreateInfoAMDX * pCreateInfos, + const VkAllocationCallbacks * pAllocator, + VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateExecutionGraphPipelinesAMDX( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); + } + + VkResult vkGetExecutionGraphPipelineScratchSizeAMDX( VkDevice device, + VkPipeline executionGraph, + VkExecutionGraphPipelineScratchSizeAMDX * pSizeInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetExecutionGraphPipelineScratchSizeAMDX( device, executionGraph, pSizeInfo ); + } + + VkResult vkGetExecutionGraphPipelineNodeIndexAMDX( VkDevice device, + VkPipeline executionGraph, + const VkPipelineShaderStageNodeCreateInfoAMDX * pNodeInfo, + uint32_t * pNodeIndex ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetExecutionGraphPipelineNodeIndexAMDX( device, executionGraph, pNodeInfo, pNodeIndex ); + } + + void vkCmdInitializeGraphScratchMemoryAMDX( VkCommandBuffer commandBuffer, + VkPipeline executionGraph, + VkDeviceAddress scratch, + VkDeviceSize scratchSize ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdInitializeGraphScratchMemoryAMDX( commandBuffer, executionGraph, scratch, scratchSize ); + } + + void vkCmdDispatchGraphAMDX( VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + VkDeviceSize scratchSize, + const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDispatchGraphAMDX( commandBuffer, scratch, scratchSize, pCountInfo ); + } + + void vkCmdDispatchGraphIndirectAMDX( VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + VkDeviceSize scratchSize, + const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDispatchGraphIndirectAMDX( commandBuffer, scratch, scratchSize, pCountInfo ); + } + + void vkCmdDispatchGraphIndirectCountAMDX( VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + VkDeviceSize scratchSize, + VkDeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDispatchGraphIndirectCountAMDX( commandBuffer, scratch, scratchSize, countInfo ); + } +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + + VkResult vkWriteSamplerDescriptorsEXT( VkDevice device, + uint32_t samplerCount, + const VkSamplerCreateInfo * pSamplers, + const VkHostAddressRangeEXT * pDescriptors ) const VULKAN_HPP_NOEXCEPT + { + return ::vkWriteSamplerDescriptorsEXT( device, samplerCount, pSamplers, pDescriptors ); + } + + VkResult vkWriteResourceDescriptorsEXT( VkDevice device, + uint32_t resourceCount, + const VkResourceDescriptorInfoEXT * pResources, + const VkHostAddressRangeEXT * pDescriptors ) const VULKAN_HPP_NOEXCEPT + { + return ::vkWriteResourceDescriptorsEXT( device, resourceCount, pResources, pDescriptors ); + } + + void vkCmdBindSamplerHeapEXT( VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT * pBindInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindSamplerHeapEXT( commandBuffer, pBindInfo ); + } + + void vkCmdBindResourceHeapEXT( VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT * pBindInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindResourceHeapEXT( commandBuffer, pBindInfo ); + } + + void vkCmdPushDataEXT( VkCommandBuffer commandBuffer, const VkPushDataInfoEXT * pPushDataInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushDataEXT( commandBuffer, pPushDataInfo ); + } + + VkResult vkGetImageOpaqueCaptureDataEXT( VkDevice device, + uint32_t imageCount, + const VkImage * pImages, + VkHostAddressRangeEXT * pDatas ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageOpaqueCaptureDataEXT( device, imageCount, pImages, pDatas ); + } + + VkDeviceSize vkGetPhysicalDeviceDescriptorSizeEXT( VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceDescriptorSizeEXT( physicalDevice, descriptorType ); + } + + VkResult vkRegisterCustomBorderColorEXT( VkDevice device, + const VkSamplerCustomBorderColorCreateInfoEXT * pBorderColor, + VkBool32 requestIndex, + uint32_t * pIndex ) const VULKAN_HPP_NOEXCEPT + { + return ::vkRegisterCustomBorderColorEXT( device, pBorderColor, requestIndex, pIndex ); + } + + void vkUnregisterCustomBorderColorEXT( VkDevice device, uint32_t index ) const VULKAN_HPP_NOEXCEPT + { + return ::vkUnregisterCustomBorderColorEXT( device, index ); + } + + VkResult vkGetTensorOpaqueCaptureDataARM( VkDevice device, + uint32_t tensorCount, + const VkTensorARM * pTensors, + VkHostAddressRangeEXT * pDatas ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetTensorOpaqueCaptureDataARM( device, tensorCount, pTensors, pDatas ); + } + + //=== VK_EXT_sample_locations === + + void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo ); + } + + void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT * pMultisampleProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties ); + } + + //=== VK_KHR_get_memory_requirements2 === + + void vkGetImageMemoryRequirements2KHR( VkDevice device, + const VkImageMemoryRequirementsInfo2 * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements ); + } + + void vkGetBufferMemoryRequirements2KHR( VkDevice device, + const VkBufferMemoryRequirementsInfo2 * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements ); + } + + void vkGetImageSparseMemoryRequirements2KHR( VkDevice device, + const VkImageSparseMemoryRequirementsInfo2 * pInfo, + uint32_t * pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); + } + + //=== VK_KHR_acceleration_structure === + + VkResult vkCreateAccelerationStructureKHR( VkDevice device, + const VkAccelerationStructureCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkAccelerationStructureKHR * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateAccelerationStructureKHR( device, pCreateInfo, pAllocator, pAccelerationStructure ); + } + + void vkDestroyAccelerationStructureKHR( VkDevice device, + VkAccelerationStructureKHR accelerationStructure, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyAccelerationStructureKHR( device, accelerationStructure, pAllocator ); + } + + void vkCmdBuildAccelerationStructuresKHR( VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, + const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBuildAccelerationStructuresKHR( commandBuffer, infoCount, pInfos, ppBuildRangeInfos ); + } + + void vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, + const VkDeviceAddress * pIndirectDeviceAddresses, + const uint32_t * pIndirectStrides, + const uint32_t * const * ppMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBuildAccelerationStructuresIndirectKHR( + commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts ); + } + + VkResult vkBuildAccelerationStructuresKHR( VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, + const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBuildAccelerationStructuresKHR( device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos ); + } + + VkResult vkCopyAccelerationStructureKHR( VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyAccelerationStructureKHR( device, deferredOperation, pInfo ); + } + + VkResult vkCopyAccelerationStructureToMemoryKHR( VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyAccelerationStructureToMemoryKHR( device, deferredOperation, pInfo ); + } + + VkResult vkCopyMemoryToAccelerationStructureKHR( VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyMemoryToAccelerationStructureKHR( device, deferredOperation, pInfo ); + } + + VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice device, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR * pAccelerationStructures, + VkQueryType queryType, + size_t dataSize, + void * pData, + size_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkWriteAccelerationStructuresPropertiesKHR( device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride ); + } + + void vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyAccelerationStructureKHR( commandBuffer, pInfo ); + } + + void vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyAccelerationStructureToMemoryKHR( commandBuffer, pInfo ); + } + + void vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer commandBuffer, + const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyMemoryToAccelerationStructureKHR( commandBuffer, pInfo ); + } + + VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR( VkDevice device, + const VkAccelerationStructureDeviceAddressInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetAccelerationStructureDeviceAddressKHR( device, pInfo ); + } + + void vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR * pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWriteAccelerationStructuresPropertiesKHR( + commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery ); + } + + void vkGetDeviceAccelerationStructureCompatibilityKHR( VkDevice device, + const VkAccelerationStructureVersionInfoKHR * pVersionInfo, + VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceAccelerationStructureCompatibilityKHR( device, pVersionInfo, pCompatibility ); + } + + void vkGetAccelerationStructureBuildSizesKHR( VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkAccelerationStructureBuildGeometryInfoKHR * pBuildInfo, + const uint32_t * pMaxPrimitiveCounts, + VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetAccelerationStructureBuildSizesKHR( device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo ); + } + + //=== VK_KHR_ray_tracing_pipeline === + + void vkCmdTraceRaysKHR( VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdTraceRaysKHR( + commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth ); + } + + VkResult vkCreateRayTracingPipelinesKHR( VkDevice device, + VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoKHR * pCreateInfos, + const VkAllocationCallbacks * pAllocator, + VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateRayTracingPipelinesKHR( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); + } + + VkResult vkGetRayTracingShaderGroupHandlesKHR( + VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData ); + } + + VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( + VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData ); + } + + void vkCmdTraceRaysIndirectKHR( VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable, + VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdTraceRaysIndirectKHR( + commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress ); + } + + VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR( VkDevice device, + VkPipeline pipeline, + uint32_t group, + VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader ); + } + + void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize ); + } + + //=== VK_KHR_sampler_ycbcr_conversion === + + VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device, + const VkSamplerYcbcrConversionCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion ); + } + + void vkDestroySamplerYcbcrConversionKHR( VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator ); + } + + //=== VK_KHR_bind_memory2 === + + VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos ); + } + + VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos ); + } + + //=== VK_EXT_image_drm_format_modifier === + + VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, + VkImage image, + VkImageDrmFormatModifierPropertiesEXT * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties ); + } + + //=== VK_EXT_validation_cache === + + VkResult vkCreateValidationCacheEXT( VkDevice device, + const VkValidationCacheCreateInfoEXT * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkValidationCacheEXT * pValidationCache ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache ); + } + + void + vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator ); + } + + VkResult vkMergeValidationCachesEXT( VkDevice device, + VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT + { + return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches ); + } + + VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData ); + } + + //=== VK_NV_shading_rate_image === + + void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout ); + } + + void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV * pShadingRatePalettes ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes ); + } + + void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV * pCustomSampleOrders ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders ); + } + + //=== VK_NV_ray_tracing === + + VkResult vkCreateAccelerationStructureNV( VkDevice device, + const VkAccelerationStructureCreateInfoNV * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkAccelerationStructureNV * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure ); + } + + void vkDestroyAccelerationStructureNV( VkDevice device, + VkAccelerationStructureNV accelerationStructure, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator ); + } + + void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, + const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo, + VkMemoryRequirements2KHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements ); + } + + VkResult vkBindAccelerationStructureMemoryNV( VkDevice device, + uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNV * pBindInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos ); + } + + void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, + const VkAccelerationStructureInfoNV * pInfo, + VkBuffer instanceData, + VkDeviceSize instanceOffset, + VkBool32 update, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkBuffer scratch, + VkDeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset ); + } + + void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode ); + } + + void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, + VkBuffer raygenShaderBindingTableBuffer, + VkDeviceSize raygenShaderBindingOffset, + VkBuffer missShaderBindingTableBuffer, + VkDeviceSize missShaderBindingOffset, + VkDeviceSize missShaderBindingStride, + VkBuffer hitShaderBindingTableBuffer, + VkDeviceSize hitShaderBindingOffset, + VkDeviceSize hitShaderBindingStride, + VkBuffer callableShaderBindingTableBuffer, + VkDeviceSize callableShaderBindingOffset, + VkDeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdTraceRaysNV( commandBuffer, + raygenShaderBindingTableBuffer, + raygenShaderBindingOffset, + missShaderBindingTableBuffer, + missShaderBindingOffset, + missShaderBindingStride, + hitShaderBindingTableBuffer, + hitShaderBindingOffset, + hitShaderBindingStride, + callableShaderBindingTableBuffer, + callableShaderBindingOffset, + callableShaderBindingStride, + width, + height, + depth ); + } + + VkResult vkCreateRayTracingPipelinesNV( VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoNV * pCreateInfos, + const VkAllocationCallbacks * pAllocator, + VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); + } + + VkResult vkGetRayTracingShaderGroupHandlesNV( + VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData ); + } + + VkResult vkGetAccelerationStructureHandleNV( VkDevice device, + VkAccelerationStructureNV accelerationStructure, + size_t dataSize, + void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData ); + } + + void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureNV * pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWriteAccelerationStructuresPropertiesNV( + commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery ); + } + + VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCompileDeferredNV( device, pipeline, shader ); + } + + //=== VK_KHR_maintenance3 === + + void vkGetDescriptorSetLayoutSupportKHR( VkDevice device, + const VkDescriptorSetLayoutCreateInfo * pCreateInfo, + VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport ); + } + + //=== VK_KHR_draw_indirect_count === + + void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); + } + + void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); + } + + //=== VK_EXT_external_memory_host === + + VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void * pHostPointer, + VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties ); + } + + //=== VK_AMD_buffer_marker === + + void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker ); + } + + void vkCmdWriteBufferMarker2AMD( + VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker ); + } + + //=== VK_EXT_calibrated_timestamps === + + VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, + uint32_t * pTimeDomainCount, + VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains ); + } + + VkResult vkGetCalibratedTimestampsEXT( VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR * pTimestampInfos, + uint64_t * pTimestamps, + uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation ); + } + + //=== VK_NV_mesh_shader === + + void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask ); + } + + void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride ); + } + + void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); + } + + //=== VK_NV_scissor_exclusive === + + void vkCmdSetExclusiveScissorEnableNV( VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkBool32 * pExclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetExclusiveScissorEnableNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables ); + } + + void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkRect2D * pExclusiveScissors ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors ); + } + + //=== VK_NV_device_diagnostic_checkpoints === + + void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker ); + } + + void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData ); + } + + void vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData ); + } + + //=== VK_KHR_timeline_semaphore === + + VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue ); + } + + VkResult vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout ); + } + + VkResult vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSignalSemaphoreKHR( device, pSignalInfo ); + } + + //=== VK_EXT_present_timing === + + VkResult vkSetSwapchainPresentTimingQueueSizeEXT( VkDevice device, VkSwapchainKHR swapchain, uint32_t size ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetSwapchainPresentTimingQueueSizeEXT( device, swapchain, size ); + } + + VkResult vkGetSwapchainTimingPropertiesEXT( VkDevice device, + VkSwapchainKHR swapchain, + VkSwapchainTimingPropertiesEXT * pSwapchainTimingProperties, + uint64_t * pSwapchainTimingPropertiesCounter ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSwapchainTimingPropertiesEXT( device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter ); + } + + VkResult vkGetSwapchainTimeDomainPropertiesEXT( VkDevice device, + VkSwapchainKHR swapchain, + VkSwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, + uint64_t * pTimeDomainsCounter ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSwapchainTimeDomainPropertiesEXT( device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter ); + } + + VkResult vkGetPastPresentationTimingEXT( VkDevice device, + const VkPastPresentationTimingInfoEXT * pPastPresentationTimingInfo, + VkPastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPastPresentationTimingEXT( device, pPastPresentationTimingInfo, pPastPresentationTimingProperties ); + } + + //=== VK_INTEL_performance_query === + + VkResult vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo ); + } + + void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT + { + return ::vkUninitializePerformanceApiINTEL( device ); + } + + VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo ); + } + + VkResult vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer commandBuffer, + const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo ); + } + + VkResult vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL * pOverrideInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo ); + } + + VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice device, + const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, + VkPerformanceConfigurationINTEL * pConfiguration ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration ); + } + + VkResult vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT + { + return ::vkReleasePerformanceConfigurationINTEL( device, configuration ); + } + + VkResult vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT + { + return ::vkQueueSetPerformanceConfigurationINTEL( queue, configuration ); + } + + VkResult + vkGetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL * pValue ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPerformanceParameterINTEL( device, parameter, pValue ); + } + + //=== VK_AMD_display_native_hdr === + + void vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable ); + } + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, + const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface ); + } +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + VkResult vkCreateMetalSurfaceEXT( VkInstance instance, + const VkMetalSurfaceCreateInfoEXT * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface ); + } +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + + VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice physicalDevice, + uint32_t * pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates ); + } + + void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer commandBuffer, + const VkExtent2D * pFragmentSize, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps ); + } + + //=== VK_KHR_dynamic_rendering_local_read === + + void vkCmdSetRenderingAttachmentLocationsKHR( VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfo * pLocationInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetRenderingAttachmentLocationsKHR( commandBuffer, pLocationInfo ); + } + + void vkCmdSetRenderingInputAttachmentIndicesKHR( VkCommandBuffer commandBuffer, + const VkRenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetRenderingInputAttachmentIndicesKHR( commandBuffer, pInputAttachmentIndexInfo ); + } + + //=== VK_EXT_buffer_device_address === + + VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetBufferDeviceAddressEXT( device, pInfo ); + } + + //=== VK_EXT_tooling_info === + + VkResult vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice physicalDevice, + uint32_t * pToolCount, + VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceToolPropertiesEXT( physicalDevice, pToolCount, pToolProperties ); + } + + //=== VK_KHR_present_wait === + + VkResult vkWaitForPresentKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkWaitForPresentKHR( device, swapchain, presentId, timeout ); + } + + //=== VK_NV_cooperative_matrix === + + VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice physicalDevice, + uint32_t * pPropertyCount, + VkCooperativeMatrixPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties ); + } + + //=== VK_NV_coverage_reduction_mode === + + VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + VkPhysicalDevice physicalDevice, uint32_t * pCombinationCount, VkFramebufferMixedSamplesCombinationNV * pCombinations ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( physicalDevice, pCombinationCount, pCombinations ); + } + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + + VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + uint32_t * pPresentModeCount, + VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes ); + } + + VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain ); + } + + VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT + { + return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain ); + } + + VkResult vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice device, + const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + + VkResult vkCreateHeadlessSurfaceEXT( VkInstance instance, + const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface ); + } + + //=== VK_KHR_buffer_device_address === + + VkDeviceAddress vkGetBufferDeviceAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetBufferDeviceAddressKHR( device, pInfo ); + } + + uint64_t vkGetBufferOpaqueCaptureAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetBufferOpaqueCaptureAddressKHR( device, pInfo ); + } + + uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR( device, pInfo ); + } + + //=== VK_EXT_line_rasterization === + + void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern ); + } + + //=== VK_EXT_host_query_reset === + + void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT + { + return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount ); + } + + //=== VK_EXT_extended_dynamic_state === + + void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetCullModeEXT( commandBuffer, cullMode ); + } + + void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace ); + } + + void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology ); + } + + void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports ); + } + + void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors ); + } + + void vkCmdBindVertexBuffers2EXT( VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer * pBuffers, + const VkDeviceSize * pOffsets, + const VkDeviceSize * pSizes, + const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindVertexBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides ); + } + + void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable ); + } + + void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable ); + } + + void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp ); + } + + void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable ); + } + + void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable ); + } + + void vkCmdSetStencilOpEXT( VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp ); + } + + //=== VK_KHR_deferred_host_operations === + + VkResult vkCreateDeferredOperationKHR( VkDevice device, + const VkAllocationCallbacks * pAllocator, + VkDeferredOperationKHR * pDeferredOperation ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDeferredOperationKHR( device, pAllocator, pDeferredOperation ); + } + + void + vkDestroyDeferredOperationKHR( VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyDeferredOperationKHR( device, operation, pAllocator ); + } + + uint32_t vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeferredOperationMaxConcurrencyKHR( device, operation ); + } + + VkResult vkGetDeferredOperationResultKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeferredOperationResultKHR( device, operation ); + } + + VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDeferredOperationJoinKHR( device, operation ); + } + + //=== VK_KHR_pipeline_executable_properties === + + VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice device, + const VkPipelineInfoKHR * pPipelineInfo, + uint32_t * pExecutableCount, + VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties ); + } + + VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice device, + const VkPipelineExecutableInfoKHR * pExecutableInfo, + uint32_t * pStatisticCount, + VkPipelineExecutableStatisticKHR * pStatistics ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics ); + } + + VkResult + vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice device, + const VkPipelineExecutableInfoKHR * pExecutableInfo, + uint32_t * pInternalRepresentationCount, + VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations ); + } + + //=== VK_EXT_host_image_copy === + + VkResult vkCopyMemoryToImageEXT( VkDevice device, const VkCopyMemoryToImageInfo * pCopyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyMemoryToImageEXT( device, pCopyMemoryToImageInfo ); + } + + VkResult vkCopyImageToMemoryEXT( VkDevice device, const VkCopyImageToMemoryInfo * pCopyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyImageToMemoryEXT( device, pCopyImageToMemoryInfo ); + } + + VkResult vkCopyImageToImageEXT( VkDevice device, const VkCopyImageToImageInfo * pCopyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyImageToImageEXT( device, pCopyImageToImageInfo ); + } + + VkResult + vkTransitionImageLayoutEXT( VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo * pTransitions ) const VULKAN_HPP_NOEXCEPT + { + return ::vkTransitionImageLayoutEXT( device, transitionCount, pTransitions ); + } + + void vkGetImageSubresourceLayout2EXT( VkDevice device, + VkImage image, + const VkImageSubresource2 * pSubresource, + VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageSubresourceLayout2EXT( device, image, pSubresource, pLayout ); + } + + //=== VK_KHR_map_memory2 === + + VkResult vkMapMemory2KHR( VkDevice device, const VkMemoryMapInfo * pMemoryMapInfo, void ** ppData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkMapMemory2KHR( device, pMemoryMapInfo, ppData ); + } + + VkResult vkUnmapMemory2KHR( VkDevice device, const VkMemoryUnmapInfo * pMemoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkUnmapMemory2KHR( device, pMemoryUnmapInfo ); + } + + //=== VK_EXT_swapchain_maintenance1 === + + VkResult vkReleaseSwapchainImagesEXT( VkDevice device, const VkReleaseSwapchainImagesInfoKHR * pReleaseInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkReleaseSwapchainImagesEXT( device, pReleaseInfo ); + } + + //=== VK_NV_device_generated_commands === + + void vkGetGeneratedCommandsMemoryRequirementsNV( VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetGeneratedCommandsMemoryRequirementsNV( device, pInfo, pMemoryRequirements ); + } + + void vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPreprocessGeneratedCommandsNV( commandBuffer, pGeneratedCommandsInfo ); + } + + void vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdExecuteGeneratedCommandsNV( commandBuffer, isPreprocessed, pGeneratedCommandsInfo ); + } + + void vkCmdBindPipelineShaderGroupNV( VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline, + uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindPipelineShaderGroupNV( commandBuffer, pipelineBindPoint, pipeline, groupIndex ); + } + + VkResult vkCreateIndirectCommandsLayoutNV( VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkIndirectCommandsLayoutNV * pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout ); + } + + void vkDestroyIndirectCommandsLayoutNV( VkDevice device, + VkIndirectCommandsLayoutNV indirectCommandsLayout, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator ); + } + + //=== VK_EXT_depth_bias_control === + + void vkCmdSetDepthBias2EXT( VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT * pDepthBiasInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthBias2EXT( commandBuffer, pDepthBiasInfo ); + } + + //=== VK_EXT_acquire_drm_display === + + VkResult vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAcquireDrmDisplayEXT( physicalDevice, drmFd, display ); + } + + VkResult vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR * display ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDrmDisplayEXT( physicalDevice, drmFd, connectorId, display ); + } + + //=== VK_EXT_private_data === + + VkResult vkCreatePrivateDataSlotEXT( VkDevice device, + const VkPrivateDataSlotCreateInfo * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreatePrivateDataSlotEXT( device, pCreateInfo, pAllocator, pPrivateDataSlot ); + } + + void vkDestroyPrivateDataSlotEXT( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyPrivateDataSlotEXT( device, privateDataSlot, pAllocator ); + } + + VkResult vkSetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data ); + } + + void vkGetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData ); + } + + //=== VK_KHR_video_encode_queue === + + VkResult + vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( physicalDevice, pQualityLevelInfo, pQualityLevelProperties ); + } + + VkResult vkGetEncodedVideoSessionParametersKHR( VkDevice device, + const VkVideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, + size_t * pDataSize, + void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetEncodedVideoSessionParametersKHR( device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData ); + } + + void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo ); + } + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + + VkResult vkCreateCudaModuleNV( VkDevice device, + const VkCudaModuleCreateInfoNV * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkCudaModuleNV * pModule ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateCudaModuleNV( device, pCreateInfo, pAllocator, pModule ); + } + + VkResult vkGetCudaModuleCacheNV( VkDevice device, VkCudaModuleNV module, size_t * pCacheSize, void * pCacheData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetCudaModuleCacheNV( device, module, pCacheSize, pCacheData ); + } + + VkResult vkCreateCudaFunctionNV( VkDevice device, + const VkCudaFunctionCreateInfoNV * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkCudaFunctionNV * pFunction ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateCudaFunctionNV( device, pCreateInfo, pAllocator, pFunction ); + } + + void vkDestroyCudaModuleNV( VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyCudaModuleNV( device, module, pAllocator ); + } + + void vkDestroyCudaFunctionNV( VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyCudaFunctionNV( device, function, pAllocator ); + } + + void vkCmdCudaLaunchKernelNV( VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCudaLaunchKernelNV( commandBuffer, pLaunchInfo ); + } +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + + void vkCmdDispatchTileQCOM( VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM * pDispatchTileInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDispatchTileQCOM( commandBuffer, pDispatchTileInfo ); + } + + void vkCmdBeginPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM * pPerTileBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginPerTileExecutionQCOM( commandBuffer, pPerTileBeginInfo ); + } + + void vkCmdEndPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM * pPerTileEndInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndPerTileExecutionQCOM( commandBuffer, pPerTileEndInfo ); + } + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + + void vkExportMetalObjectsEXT( VkDevice device, VkExportMetalObjectsInfoEXT * pMetalObjectsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkExportMetalObjectsEXT( device, pMetalObjectsInfo ); + } +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + + void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo ); + } + + void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask ); + } + + void vkCmdWaitEvents2KHR( VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent * pEvents, + const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos ); + } + + void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo ); + } + + void + vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query ); + } + + VkResult vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT + { + return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence ); + } + + //=== VK_EXT_descriptor_buffer === + + void vkGetDescriptorSetLayoutSizeEXT( VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize * pLayoutSizeInBytes ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDescriptorSetLayoutSizeEXT( device, layout, pLayoutSizeInBytes ); + } + + void vkGetDescriptorSetLayoutBindingOffsetEXT( VkDevice device, + VkDescriptorSetLayout layout, + uint32_t binding, + VkDeviceSize * pOffset ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDescriptorSetLayoutBindingOffsetEXT( device, layout, binding, pOffset ); + } + + void vkGetDescriptorEXT( VkDevice device, const VkDescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDescriptorEXT( device, pDescriptorInfo, dataSize, pDescriptor ); + } + + void vkCmdBindDescriptorBuffersEXT( VkCommandBuffer commandBuffer, + uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT * pBindingInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindDescriptorBuffersEXT( commandBuffer, bufferCount, pBindingInfos ); + } + + void vkCmdSetDescriptorBufferOffsetsEXT( VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const uint32_t * pBufferIndices, + const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDescriptorBufferOffsetsEXT( commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets ); + } + + void vkCmdBindDescriptorBufferEmbeddedSamplersEXT( VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindDescriptorBufferEmbeddedSamplersEXT( commandBuffer, pipelineBindPoint, layout, set ); + } + + VkResult + vkGetBufferOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetBufferOpaqueCaptureDescriptorDataEXT( device, pInfo, pData ); + } + + VkResult + vkGetImageOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkImageCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageOpaqueCaptureDescriptorDataEXT( device, pInfo, pData ); + } + + VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT( VkDevice device, + const VkImageViewCaptureDescriptorDataInfoEXT * pInfo, + void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageViewOpaqueCaptureDescriptorDataEXT( device, pInfo, pData ); + } + + VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT( VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT * pInfo, + void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSamplerOpaqueCaptureDescriptorDataEXT( device, pInfo, pData ); + } + + VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( VkDevice device, + const VkAccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, + void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( device, pInfo, pData ); + } + + //=== VK_NV_fragment_shading_rate_enums === + + void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer commandBuffer, + VkFragmentShadingRateNV shadingRate, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps ); + } + + //=== VK_EXT_mesh_shader === + + void vkCmdDrawMeshTasksEXT( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawMeshTasksEXT( commandBuffer, groupCountX, groupCountY, groupCountZ ); + } + + void vkCmdDrawMeshTasksIndirectEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawMeshTasksIndirectEXT( commandBuffer, buffer, offset, drawCount, stride ); + } + + void vkCmdDrawMeshTasksIndirectCountEXT( VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawMeshTasksIndirectCountEXT( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); + } + + //=== VK_KHR_copy_commands2 === + + void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo ); + } + + void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo ); + } + + void vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo ); + } + + void vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo ); + } + + void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo ); + } + + void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo ); + } + + //=== VK_EXT_device_fault === + + VkResult vkGetDeviceFaultInfoEXT( VkDevice device, VkDeviceFaultCountsEXT * pFaultCounts, VkDeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceFaultInfoEXT( device, pFaultCounts, pFaultInfo ); + } + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + + VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAcquireWinrtDisplayNV( physicalDevice, display ); + } + + VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + VkResult vkCreateDirectFBSurfaceEXT( VkInstance instance, + const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface ); + } + + VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + IDirectFB * dfb ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb ); + } +# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_vertex_input_dynamic_state === + + void vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer, + uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetVertexInputEXT( + commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions ); + } + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + + VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice device, + const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, + zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle ); + } + + VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA( VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + zx_handle_t zirconHandle, + VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( device, handleType, zirconHandle, pMemoryZirconHandleProperties ); + } +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + + VkResult + vkImportSemaphoreZirconHandleFUCHSIA( VkDevice device, + const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo ); + } + + VkResult vkGetSemaphoreZirconHandleFUCHSIA( VkDevice device, + const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, + zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle ); + } +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + VkResult vkCreateBufferCollectionFUCHSIA( VkDevice device, + const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkBufferCollectionFUCHSIA * pCollection ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection ); + } + + VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo ); + } + + VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA( VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo ); + } + + void vkDestroyBufferCollectionFUCHSIA( VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator ); + } + + VkResult vkGetBufferCollectionPropertiesFUCHSIA( VkDevice device, + VkBufferCollectionFUCHSIA collection, + VkBufferCollectionPropertiesFUCHSIA * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties ); + } +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + + VkResult + vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize ); + } + + void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSubpassShadingHUAWEI( commandBuffer ); + } + + //=== VK_HUAWEI_invocation_mask === + + void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout ); + } + + //=== VK_NV_external_memory_rdma === + + VkResult vkGetMemoryRemoteAddressNV( VkDevice device, + const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, + VkRemoteAddressNV * pAddress ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress ); + } + + //=== VK_EXT_pipeline_properties === + + VkResult vkGetPipelinePropertiesEXT( VkDevice device, + const VkPipelineInfoEXT * pPipelineInfo, + VkBaseOutStructure * pPipelineProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPipelinePropertiesEXT( device, pPipelineInfo, pPipelineProperties ); + } + + //=== VK_EXT_extended_dynamic_state2 === + + void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints ); + } + + void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable ); + } + + void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable ); + } + + void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp ); + } + + void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable ); + } + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + VkResult vkCreateScreenSurfaceQNX( VkInstance instance, + const VkScreenSurfaceCreateInfoQNX * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface ); + } + + VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window ); + } +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_color_write_enable === + + void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables ); + } + + //=== VK_KHR_ray_tracing_maintenance1 === + + void vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdTraceRaysIndirect2KHR( commandBuffer, indirectDeviceAddress ); + } + + //=== VK_EXT_multi_draw === + + void vkCmdDrawMultiEXT( VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawInfoEXT * pVertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride ); + } + + void vkCmdDrawMultiIndexedEXT( VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawIndexedInfoEXT * pIndexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + const int32_t * pVertexOffset ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawMultiIndexedEXT( commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset ); + } + + //=== VK_EXT_opacity_micromap === + + VkResult vkCreateMicromapEXT( VkDevice device, + const VkMicromapCreateInfoEXT * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkMicromapEXT * pMicromap ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateMicromapEXT( device, pCreateInfo, pAllocator, pMicromap ); + } + + void vkDestroyMicromapEXT( VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyMicromapEXT( device, micromap, pAllocator ); + } + + void vkCmdBuildMicromapsEXT( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBuildMicromapsEXT( commandBuffer, infoCount, pInfos ); + } + + VkResult vkBuildMicromapsEXT( VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBuildMicromapsEXT( device, deferredOperation, infoCount, pInfos ); + } + + VkResult vkCopyMicromapEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyMicromapEXT( device, deferredOperation, pInfo ); + } + + VkResult vkCopyMicromapToMemoryEXT( VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyMicromapToMemoryEXT( device, deferredOperation, pInfo ); + } + + VkResult vkCopyMemoryToMicromapEXT( VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCopyMemoryToMicromapEXT( device, deferredOperation, pInfo ); + } + + VkResult vkWriteMicromapsPropertiesEXT( VkDevice device, + uint32_t micromapCount, + const VkMicromapEXT * pMicromaps, + VkQueryType queryType, + size_t dataSize, + void * pData, + size_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkWriteMicromapsPropertiesEXT( device, micromapCount, pMicromaps, queryType, dataSize, pData, stride ); + } + + void vkCmdCopyMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyMicromapEXT( commandBuffer, pInfo ); + } + + void vkCmdCopyMicromapToMemoryEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyMicromapToMemoryEXT( commandBuffer, pInfo ); + } + + void vkCmdCopyMemoryToMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyMemoryToMicromapEXT( commandBuffer, pInfo ); + } + + void vkCmdWriteMicromapsPropertiesEXT( VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT * pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdWriteMicromapsPropertiesEXT( commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery ); + } + + void vkGetDeviceMicromapCompatibilityEXT( VkDevice device, + const VkMicromapVersionInfoEXT * pVersionInfo, + VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceMicromapCompatibilityEXT( device, pVersionInfo, pCompatibility ); + } + + void vkGetMicromapBuildSizesEXT( VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT * pBuildInfo, + VkMicromapBuildSizesInfoEXT * pSizeInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMicromapBuildSizesEXT( device, buildType, pBuildInfo, pSizeInfo ); + } + + //=== VK_HUAWEI_cluster_culling_shader === + + void vkCmdDrawClusterHUAWEI( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawClusterHUAWEI( commandBuffer, groupCountX, groupCountY, groupCountZ ); + } + + void vkCmdDrawClusterIndirectHUAWEI( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDrawClusterIndirectHUAWEI( commandBuffer, buffer, offset ); + } + + //=== VK_EXT_pageable_device_local_memory === + + void vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority ); + } + + //=== VK_KHR_maintenance4 === + + void vkGetDeviceBufferMemoryRequirementsKHR( VkDevice device, + const VkDeviceBufferMemoryRequirements * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements ); + } + + void vkGetDeviceImageMemoryRequirementsKHR( VkDevice device, + const VkDeviceImageMemoryRequirements * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements ); + } + + void vkGetDeviceImageSparseMemoryRequirementsKHR( VkDevice device, + const VkDeviceImageMemoryRequirements * pInfo, + uint32_t * pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceImageSparseMemoryRequirementsKHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); + } + + //=== VK_VALVE_descriptor_set_host_mapping === + + void vkGetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice device, + const VkDescriptorSetBindingReferenceVALVE * pBindingReference, + VkDescriptorSetLayoutHostMappingInfoVALVE * pHostMapping ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE( device, pBindingReference, pHostMapping ); + } + + void vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void ** ppData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDescriptorSetHostMappingVALVE( device, descriptorSet, ppData ); + } + + //=== VK_NV_copy_memory_indirect === + + void vkCmdCopyMemoryIndirectNV( VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyMemoryIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride ); + } + + void vkCmdCopyMemoryToImageIndirectNV( VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + VkImage dstImage, + VkImageLayout dstImageLayout, + const VkImageSubresourceLayers * pImageSubresources ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyMemoryToImageIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources ); + } + + //=== VK_NV_memory_decompression === + + void vkCmdDecompressMemoryNV( VkCommandBuffer commandBuffer, + uint32_t decompressRegionCount, + const VkDecompressMemoryRegionNV * pDecompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDecompressMemoryNV( commandBuffer, decompressRegionCount, pDecompressMemoryRegions ); + } + + void vkCmdDecompressMemoryIndirectCountNV( VkCommandBuffer commandBuffer, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDecompressMemoryIndirectCountNV( commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride ); + } + + //=== VK_NV_device_generated_commands_compute === + + void vkGetPipelineIndirectMemoryRequirementsNV( VkDevice device, + const VkComputePipelineCreateInfo * pCreateInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPipelineIndirectMemoryRequirementsNV( device, pCreateInfo, pMemoryRequirements ); + } + + void vkCmdUpdatePipelineIndirectBufferNV( VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdUpdatePipelineIndirectBufferNV( commandBuffer, pipelineBindPoint, pipeline ); + } + + VkDeviceAddress vkGetPipelineIndirectDeviceAddressNV( VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPipelineIndirectDeviceAddressNV( device, pInfo ); + } + +# if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + + VkResult vkGetNativeBufferPropertiesOHOS( VkDevice device, + const struct OH_NativeBuffer * buffer, + VkNativeBufferPropertiesOHOS * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetNativeBufferPropertiesOHOS( device, buffer, pProperties ); + } + + VkResult vkGetMemoryNativeBufferOHOS( VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS * pInfo, + struct OH_NativeBuffer ** pBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryNativeBufferOHOS( device, pInfo, pBuffer ); + } +# endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_extended_dynamic_state3 === + + void vkCmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthClampEnableEXT( commandBuffer, depthClampEnable ); + } + + void vkCmdSetPolygonModeEXT( VkCommandBuffer commandBuffer, VkPolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetPolygonModeEXT( commandBuffer, polygonMode ); + } + + void vkCmdSetRasterizationSamplesEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetRasterizationSamplesEXT( commandBuffer, rasterizationSamples ); + } + + void vkCmdSetSampleMaskEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask * pSampleMask ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetSampleMaskEXT( commandBuffer, samples, pSampleMask ); + } + + void vkCmdSetAlphaToCoverageEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetAlphaToCoverageEnableEXT( commandBuffer, alphaToCoverageEnable ); + } + + void vkCmdSetAlphaToOneEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetAlphaToOneEnableEXT( commandBuffer, alphaToOneEnable ); + } + + void vkCmdSetLogicOpEnableEXT( VkCommandBuffer commandBuffer, VkBool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetLogicOpEnableEXT( commandBuffer, logicOpEnable ); + } + + void vkCmdSetColorBlendEnableEXT( VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32 * pColorBlendEnables ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetColorBlendEnableEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables ); + } + + void vkCmdSetColorBlendEquationEXT( VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT * pColorBlendEquations ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetColorBlendEquationEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations ); + } + + void vkCmdSetColorWriteMaskEXT( VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags * pColorWriteMasks ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetColorWriteMaskEXT( commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks ); + } + + void vkCmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetTessellationDomainOriginEXT( commandBuffer, domainOrigin ); + } + + void vkCmdSetRasterizationStreamEXT( VkCommandBuffer commandBuffer, uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetRasterizationStreamEXT( commandBuffer, rasterizationStream ); + } + + void vkCmdSetConservativeRasterizationModeEXT( VkCommandBuffer commandBuffer, + VkConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetConservativeRasterizationModeEXT( commandBuffer, conservativeRasterizationMode ); + } + + void vkCmdSetExtraPrimitiveOverestimationSizeEXT( VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetExtraPrimitiveOverestimationSizeEXT( commandBuffer, extraPrimitiveOverestimationSize ); + } + + void vkCmdSetDepthClipEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthClipEnableEXT( commandBuffer, depthClipEnable ); + } + + void vkCmdSetSampleLocationsEnableEXT( VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetSampleLocationsEnableEXT( commandBuffer, sampleLocationsEnable ); + } + + void vkCmdSetColorBlendAdvancedEXT( VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT * pColorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetColorBlendAdvancedEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced ); + } + + void vkCmdSetProvokingVertexModeEXT( VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetProvokingVertexModeEXT( commandBuffer, provokingVertexMode ); + } + + void vkCmdSetLineRasterizationModeEXT( VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetLineRasterizationModeEXT( commandBuffer, lineRasterizationMode ); + } + + void vkCmdSetLineStippleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetLineStippleEnableEXT( commandBuffer, stippledLineEnable ); + } + + void vkCmdSetDepthClipNegativeOneToOneEXT( VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthClipNegativeOneToOneEXT( commandBuffer, negativeOneToOne ); + } + + void vkCmdSetViewportWScalingEnableNV( VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetViewportWScalingEnableNV( commandBuffer, viewportWScalingEnable ); + } + + void vkCmdSetViewportSwizzleNV( VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV * pViewportSwizzles ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetViewportSwizzleNV( commandBuffer, firstViewport, viewportCount, pViewportSwizzles ); + } + + void vkCmdSetCoverageToColorEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetCoverageToColorEnableNV( commandBuffer, coverageToColorEnable ); + } + + void vkCmdSetCoverageToColorLocationNV( VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetCoverageToColorLocationNV( commandBuffer, coverageToColorLocation ); + } + + void vkCmdSetCoverageModulationModeNV( VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetCoverageModulationModeNV( commandBuffer, coverageModulationMode ); + } + + void vkCmdSetCoverageModulationTableEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetCoverageModulationTableEnableNV( commandBuffer, coverageModulationTableEnable ); + } + + void vkCmdSetCoverageModulationTableNV( VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float * pCoverageModulationTable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetCoverageModulationTableNV( commandBuffer, coverageModulationTableCount, pCoverageModulationTable ); + } + + void vkCmdSetShadingRateImageEnableNV( VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetShadingRateImageEnableNV( commandBuffer, shadingRateImageEnable ); + } + + void vkCmdSetRepresentativeFragmentTestEnableNV( VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetRepresentativeFragmentTestEnableNV( commandBuffer, representativeFragmentTestEnable ); + } + + void vkCmdSetCoverageReductionModeNV( VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetCoverageReductionModeNV( commandBuffer, coverageReductionMode ); + } + + //=== VK_ARM_tensors === + + VkResult vkCreateTensorARM( VkDevice device, + const VkTensorCreateInfoARM * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkTensorARM * pTensor ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateTensorARM( device, pCreateInfo, pAllocator, pTensor ); + } + + void vkDestroyTensorARM( VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyTensorARM( device, tensor, pAllocator ); + } + + VkResult vkCreateTensorViewARM( VkDevice device, + const VkTensorViewCreateInfoARM * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkTensorViewARM * pView ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateTensorViewARM( device, pCreateInfo, pAllocator, pView ); + } + + void vkDestroyTensorViewARM( VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyTensorViewARM( device, tensorView, pAllocator ); + } + + void vkGetTensorMemoryRequirementsARM( VkDevice device, + const VkTensorMemoryRequirementsInfoARM * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetTensorMemoryRequirementsARM( device, pInfo, pMemoryRequirements ); + } + + VkResult vkBindTensorMemoryARM( VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM * pBindInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBindTensorMemoryARM( device, bindInfoCount, pBindInfos ); + } + + void vkGetDeviceTensorMemoryRequirementsARM( VkDevice device, + const VkDeviceTensorMemoryRequirementsARM * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceTensorMemoryRequirementsARM( device, pInfo, pMemoryRequirements ); + } + + void vkCmdCopyTensorARM( VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM * pCopyTensorInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyTensorARM( commandBuffer, pCopyTensorInfo ); + } + + void vkGetPhysicalDeviceExternalTensorPropertiesARM( VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo, + VkExternalTensorPropertiesARM * pExternalTensorProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceExternalTensorPropertiesARM( physicalDevice, pExternalTensorInfo, pExternalTensorProperties ); + } + + VkResult + vkGetTensorOpaqueCaptureDescriptorDataARM( VkDevice device, const VkTensorCaptureDescriptorDataInfoARM * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetTensorOpaqueCaptureDescriptorDataARM( device, pInfo, pData ); + } + + VkResult vkGetTensorViewOpaqueCaptureDescriptorDataARM( VkDevice device, + const VkTensorViewCaptureDescriptorDataInfoARM * pInfo, + void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetTensorViewOpaqueCaptureDescriptorDataARM( device, pInfo, pData ); + } + + //=== VK_EXT_shader_module_identifier === + + void vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetShaderModuleIdentifierEXT( device, shaderModule, pIdentifier ); + } + + void vkGetShaderModuleCreateInfoIdentifierEXT( VkDevice device, + const VkShaderModuleCreateInfo * pCreateInfo, + VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetShaderModuleCreateInfoIdentifierEXT( device, pCreateInfo, pIdentifier ); + } + + //=== VK_NV_optical_flow === + + VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV( VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo, + uint32_t * pFormatCount, + VkOpticalFlowImageFormatPropertiesNV * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceOpticalFlowImageFormatsNV( physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties ); + } + + VkResult vkCreateOpticalFlowSessionNV( VkDevice device, + const VkOpticalFlowSessionCreateInfoNV * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkOpticalFlowSessionNV * pSession ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateOpticalFlowSessionNV( device, pCreateInfo, pAllocator, pSession ); + } + + void vkDestroyOpticalFlowSessionNV( VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyOpticalFlowSessionNV( device, session, pAllocator ); + } + + VkResult vkBindOpticalFlowSessionImageNV( VkDevice device, + VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBindOpticalFlowSessionImageNV( device, session, bindingPoint, view, layout ); + } + + void vkCmdOpticalFlowExecuteNV( VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV * pExecuteInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdOpticalFlowExecuteNV( commandBuffer, session, pExecuteInfo ); + } + + //=== VK_KHR_maintenance5 === + + void vkCmdBindIndexBuffer2KHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindIndexBuffer2KHR( commandBuffer, buffer, offset, size, indexType ); + } + + void + vkGetRenderingAreaGranularityKHR( VkDevice device, const VkRenderingAreaInfo * pRenderingAreaInfo, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetRenderingAreaGranularityKHR( device, pRenderingAreaInfo, pGranularity ); + } + + void vkGetDeviceImageSubresourceLayoutKHR( VkDevice device, + const VkDeviceImageSubresourceInfo * pInfo, + VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDeviceImageSubresourceLayoutKHR( device, pInfo, pLayout ); + } + + void vkGetImageSubresourceLayout2KHR( VkDevice device, + VkImage image, + const VkImageSubresource2 * pSubresource, + VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetImageSubresourceLayout2KHR( device, image, pSubresource, pLayout ); + } + + //=== VK_AMD_anti_lag === + + void vkAntiLagUpdateAMD( VkDevice device, const VkAntiLagDataAMD * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkAntiLagUpdateAMD( device, pData ); + } + + //=== VK_KHR_present_wait2 === + + VkResult vkWaitForPresent2KHR( VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR * pPresentWait2Info ) const VULKAN_HPP_NOEXCEPT + { + return ::vkWaitForPresent2KHR( device, swapchain, pPresentWait2Info ); + } + + //=== VK_EXT_shader_object === + + VkResult vkCreateShadersEXT( VkDevice device, + uint32_t createInfoCount, + const VkShaderCreateInfoEXT * pCreateInfos, + const VkAllocationCallbacks * pAllocator, + VkShaderEXT * pShaders ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateShadersEXT( device, createInfoCount, pCreateInfos, pAllocator, pShaders ); + } + + void vkDestroyShaderEXT( VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyShaderEXT( device, shader, pAllocator ); + } + + VkResult vkGetShaderBinaryDataEXT( VkDevice device, VkShaderEXT shader, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetShaderBinaryDataEXT( device, shader, pDataSize, pData ); + } + + void vkCmdBindShadersEXT( VkCommandBuffer commandBuffer, + uint32_t stageCount, + const VkShaderStageFlagBits * pStages, + const VkShaderEXT * pShaders ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindShadersEXT( commandBuffer, stageCount, pStages, pShaders ); + } + + void vkCmdSetDepthClampRangeEXT( VkCommandBuffer commandBuffer, + VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT * pDepthClampRange ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDepthClampRangeEXT( commandBuffer, depthClampMode, pDepthClampRange ); + } + + //=== VK_KHR_pipeline_binary === + + VkResult vkCreatePipelineBinariesKHR( VkDevice device, + const VkPipelineBinaryCreateInfoKHR * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkPipelineBinaryHandlesInfoKHR * pBinaries ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreatePipelineBinariesKHR( device, pCreateInfo, pAllocator, pBinaries ); + } + + void vkDestroyPipelineBinaryKHR( VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyPipelineBinaryKHR( device, pipelineBinary, pAllocator ); + } + + VkResult vkGetPipelineKeyKHR( VkDevice device, + const VkPipelineCreateInfoKHR * pPipelineCreateInfo, + VkPipelineBinaryKeyKHR * pPipelineKey ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPipelineKeyKHR( device, pPipelineCreateInfo, pPipelineKey ); + } + + VkResult vkGetPipelineBinaryDataKHR( VkDevice device, + const VkPipelineBinaryDataInfoKHR * pInfo, + VkPipelineBinaryKeyKHR * pPipelineBinaryKey, + size_t * pPipelineBinaryDataSize, + void * pPipelineBinaryData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPipelineBinaryDataKHR( device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData ); + } + + VkResult vkReleaseCapturedPipelineDataKHR( VkDevice device, + const VkReleaseCapturedPipelineDataInfoKHR * pInfo, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkReleaseCapturedPipelineDataKHR( device, pInfo, pAllocator ); + } + + //=== VK_QCOM_tile_properties === + + VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice device, + VkFramebuffer framebuffer, + uint32_t * pPropertiesCount, + VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetFramebufferTilePropertiesQCOM( device, framebuffer, pPropertiesCount, pProperties ); + } + + VkResult vkGetDynamicRenderingTilePropertiesQCOM( VkDevice device, + const VkRenderingInfo * pRenderingInfo, + VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDynamicRenderingTilePropertiesQCOM( device, pRenderingInfo, pProperties ); + } + + //=== VK_KHR_swapchain_maintenance1 === + + VkResult vkReleaseSwapchainImagesKHR( VkDevice device, const VkReleaseSwapchainImagesInfoKHR * pReleaseInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkReleaseSwapchainImagesKHR( device, pReleaseInfo ); + } + + //=== VK_NV_cooperative_vector === + + VkResult vkGetPhysicalDeviceCooperativeVectorPropertiesNV( VkPhysicalDevice physicalDevice, + uint32_t * pPropertyCount, + VkCooperativeVectorPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceCooperativeVectorPropertiesNV( physicalDevice, pPropertyCount, pProperties ); + } + + VkResult vkConvertCooperativeVectorMatrixNV( VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkConvertCooperativeVectorMatrixNV( device, pInfo ); + } + + void vkCmdConvertCooperativeVectorMatrixNV( VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkConvertCooperativeVectorMatrixInfoNV * pInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdConvertCooperativeVectorMatrixNV( commandBuffer, infoCount, pInfos ); + } + + //=== VK_NV_low_latency2 === + + VkResult vkSetLatencySleepModeNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV * pSleepModeInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetLatencySleepModeNV( device, swapchain, pSleepModeInfo ); + } + + VkResult vkLatencySleepNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV * pSleepInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkLatencySleepNV( device, swapchain, pSleepInfo ); + } + + void vkSetLatencyMarkerNV( VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkSetLatencyMarkerNV( device, swapchain, pLatencyMarkerInfo ); + } + + void vkGetLatencyTimingsNV( VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetLatencyTimingsNV( device, swapchain, pLatencyMarkerInfo ); + } + + void vkQueueNotifyOutOfBandNV( VkQueue queue, const VkOutOfBandQueueTypeInfoNV * pQueueTypeInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkQueueNotifyOutOfBandNV( queue, pQueueTypeInfo ); + } + + //=== VK_KHR_cooperative_matrix === + + VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDevice physicalDevice, + uint32_t * pPropertyCount, + VkCooperativeMatrixPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( physicalDevice, pPropertyCount, pProperties ); + } + + //=== VK_ARM_data_graph === + + VkResult vkCreateDataGraphPipelinesARM( VkDevice device, + VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkDataGraphPipelineCreateInfoARM * pCreateInfos, + const VkAllocationCallbacks * pAllocator, + VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDataGraphPipelinesARM( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); + } + + VkResult vkCreateDataGraphPipelineSessionARM( VkDevice device, + const VkDataGraphPipelineSessionCreateInfoARM * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkDataGraphPipelineSessionARM * pSession ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateDataGraphPipelineSessionARM( device, pCreateInfo, pAllocator, pSession ); + } + + VkResult vkGetDataGraphPipelineSessionBindPointRequirementsARM( VkDevice device, + const VkDataGraphPipelineSessionBindPointRequirementsInfoARM * pInfo, + uint32_t * pBindPointRequirementCount, + VkDataGraphPipelineSessionBindPointRequirementARM * pBindPointRequirements ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkGetDataGraphPipelineSessionBindPointRequirementsARM( device, pInfo, pBindPointRequirementCount, pBindPointRequirements ); + } + + void vkGetDataGraphPipelineSessionMemoryRequirementsARM( VkDevice device, + const VkDataGraphPipelineSessionMemoryRequirementsInfoARM * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDataGraphPipelineSessionMemoryRequirementsARM( device, pInfo, pMemoryRequirements ); + } + + VkResult vkBindDataGraphPipelineSessionMemoryARM( VkDevice device, + uint32_t bindInfoCount, + const VkBindDataGraphPipelineSessionMemoryInfoARM * pBindInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkBindDataGraphPipelineSessionMemoryARM( device, bindInfoCount, pBindInfos ); + } + + void vkDestroyDataGraphPipelineSessionARM( VkDevice device, + VkDataGraphPipelineSessionARM session, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyDataGraphPipelineSessionARM( device, session, pAllocator ); + } + + void vkCmdDispatchDataGraphARM( VkCommandBuffer commandBuffer, + VkDataGraphPipelineSessionARM session, + const VkDataGraphPipelineDispatchInfoARM * pInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDispatchDataGraphARM( commandBuffer, session, pInfo ); + } + + VkResult vkGetDataGraphPipelineAvailablePropertiesARM( VkDevice device, + const VkDataGraphPipelineInfoARM * pPipelineInfo, + uint32_t * pPropertiesCount, + VkDataGraphPipelinePropertyARM * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDataGraphPipelineAvailablePropertiesARM( device, pPipelineInfo, pPropertiesCount, pProperties ); + } + + VkResult vkGetDataGraphPipelinePropertiesARM( VkDevice device, + const VkDataGraphPipelineInfoARM * pPipelineInfo, + uint32_t propertiesCount, + VkDataGraphPipelinePropertyQueryResultARM * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetDataGraphPipelinePropertiesARM( device, pPipelineInfo, propertiesCount, pProperties ); + } + + VkResult + vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t * pQueueFamilyDataGraphPropertyCount, + VkQueueFamilyDataGraphPropertiesARM * pQueueFamilyDataGraphProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( + physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties ); + } + + void vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM * pQueueFamilyDataGraphProcessingEngineInfo, + VkQueueFamilyDataGraphProcessingEnginePropertiesARM * pQueueFamilyDataGraphProcessingEngineProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( + physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties ); + } + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + + void vkCmdSetAttachmentFeedbackLoopEnableEXT( VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetAttachmentFeedbackLoopEnableEXT( commandBuffer, aspectMask ); + } + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + + VkResult vkGetScreenBufferPropertiesQNX( VkDevice device, + const struct _screen_buffer * buffer, + VkScreenBufferPropertiesQNX * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetScreenBufferPropertiesQNX( device, buffer, pProperties ); + } +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_KHR_line_rasterization === + + void vkCmdSetLineStippleKHR( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetLineStippleKHR( commandBuffer, lineStippleFactor, lineStipplePattern ); + } + + //=== VK_KHR_calibrated_timestamps === + + VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( VkPhysicalDevice physicalDevice, + uint32_t * pTimeDomainCount, + VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( physicalDevice, pTimeDomainCount, pTimeDomains ); + } + + VkResult vkGetCalibratedTimestampsKHR( VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR * pTimestampInfos, + uint64_t * pTimestamps, + uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetCalibratedTimestampsKHR( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation ); + } + + //=== VK_KHR_maintenance6 === + + void vkCmdBindDescriptorSets2KHR( VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo * pBindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindDescriptorSets2KHR( commandBuffer, pBindDescriptorSetsInfo ); + } + + void vkCmdPushConstants2KHR( VkCommandBuffer commandBuffer, const VkPushConstantsInfo * pPushConstantsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushConstants2KHR( commandBuffer, pPushConstantsInfo ); + } + + void vkCmdPushDescriptorSet2KHR( VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo * pPushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushDescriptorSet2KHR( commandBuffer, pPushDescriptorSetInfo ); + } + + void vkCmdPushDescriptorSetWithTemplate2KHR( VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPushDescriptorSetWithTemplate2KHR( commandBuffer, pPushDescriptorSetWithTemplateInfo ); + } + + void vkCmdSetDescriptorBufferOffsets2EXT( VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetDescriptorBufferOffsets2EXT( commandBuffer, pSetDescriptorBufferOffsetsInfo ); + } + + void vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo ); + } + + //=== VK_QCOM_tile_memory_heap === + + void vkCmdBindTileMemoryQCOM( VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM * pTileMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindTileMemoryQCOM( commandBuffer, pTileMemoryBindInfo ); + } + + //=== VK_KHR_copy_memory_indirect === + + void vkCmdCopyMemoryIndirectKHR( VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyMemoryIndirectKHR( commandBuffer, pCopyMemoryIndirectInfo ); + } + + void vkCmdCopyMemoryToImageIndirectKHR( VkCommandBuffer commandBuffer, + const VkCopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdCopyMemoryToImageIndirectKHR( commandBuffer, pCopyMemoryToImageIndirectInfo ); + } + + //=== VK_EXT_memory_decompression === + + void vkCmdDecompressMemoryEXT( VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT * pDecompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDecompressMemoryEXT( commandBuffer, pDecompressMemoryInfoEXT ); + } + + void vkCmdDecompressMemoryIndirectCountEXT( VkCommandBuffer commandBuffer, + VkMemoryDecompressionMethodFlagsEXT decompressionMethod, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t maxDecompressionCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDecompressMemoryIndirectCountEXT( + commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride ); + } + + //=== VK_NV_external_compute_queue === + + VkResult vkCreateExternalComputeQueueNV( VkDevice device, + const VkExternalComputeQueueCreateInfoNV * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkExternalComputeQueueNV * pExternalQueue ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateExternalComputeQueueNV( device, pCreateInfo, pAllocator, pExternalQueue ); + } + + void vkDestroyExternalComputeQueueNV( VkDevice device, + VkExternalComputeQueueNV externalQueue, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyExternalComputeQueueNV( device, externalQueue, pAllocator ); + } + + void vkGetExternalComputeQueueDataNV( VkExternalComputeQueueNV externalQueue, + VkExternalComputeQueueDataParamsNV * params, + void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetExternalComputeQueueDataNV( externalQueue, params, pData ); + } + + //=== VK_NV_cluster_acceleration_structure === + + void vkGetClusterAccelerationStructureBuildSizesNV( VkDevice device, + const VkClusterAccelerationStructureInputInfoNV * pInfo, + VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetClusterAccelerationStructureBuildSizesNV( device, pInfo, pSizeInfo ); + } + + void vkCmdBuildClusterAccelerationStructureIndirectNV( VkCommandBuffer commandBuffer, + const VkClusterAccelerationStructureCommandsInfoNV * pCommandInfos ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBuildClusterAccelerationStructureIndirectNV( commandBuffer, pCommandInfos ); + } + + //=== VK_NV_partitioned_acceleration_structure === + + void vkGetPartitionedAccelerationStructuresBuildSizesNV( VkDevice device, + const VkPartitionedAccelerationStructureInstancesInputNV * pInfo, + VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPartitionedAccelerationStructuresBuildSizesNV( device, pInfo, pSizeInfo ); + } + + void vkCmdBuildPartitionedAccelerationStructuresNV( VkCommandBuffer commandBuffer, + const VkBuildPartitionedAccelerationStructureInfoNV * pBuildInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBuildPartitionedAccelerationStructuresNV( commandBuffer, pBuildInfo ); + } + + //=== VK_EXT_device_generated_commands === + + void vkGetGeneratedCommandsMemoryRequirementsEXT( VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoEXT * pInfo, + VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetGeneratedCommandsMemoryRequirementsEXT( device, pInfo, pMemoryRequirements ); + } + + void vkCmdPreprocessGeneratedCommandsEXT( VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT * pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdPreprocessGeneratedCommandsEXT( commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer ); + } + + void vkCmdExecuteGeneratedCommandsEXT( VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdExecuteGeneratedCommandsEXT( commandBuffer, isPreprocessed, pGeneratedCommandsInfo ); + } + + VkResult vkCreateIndirectCommandsLayoutEXT( VkDevice device, + const VkIndirectCommandsLayoutCreateInfoEXT * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkIndirectCommandsLayoutEXT * pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateIndirectCommandsLayoutEXT( device, pCreateInfo, pAllocator, pIndirectCommandsLayout ); + } + + void vkDestroyIndirectCommandsLayoutEXT( VkDevice device, + VkIndirectCommandsLayoutEXT indirectCommandsLayout, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyIndirectCommandsLayoutEXT( device, indirectCommandsLayout, pAllocator ); + } + + VkResult vkCreateIndirectExecutionSetEXT( VkDevice device, + const VkIndirectExecutionSetCreateInfoEXT * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkIndirectExecutionSetEXT * pIndirectExecutionSet ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateIndirectExecutionSetEXT( device, pCreateInfo, pAllocator, pIndirectExecutionSet ); + } + + void vkDestroyIndirectExecutionSetEXT( VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyIndirectExecutionSetEXT( device, indirectExecutionSet, pAllocator ); + } + + void vkUpdateIndirectExecutionSetPipelineEXT( VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites ) const VULKAN_HPP_NOEXCEPT + { + return ::vkUpdateIndirectExecutionSetPipelineEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites ); + } + + void vkUpdateIndirectExecutionSetShaderEXT( VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetShaderEXT * pExecutionSetWrites ) const VULKAN_HPP_NOEXCEPT + { + return ::vkUpdateIndirectExecutionSetShaderEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites ); + } + +# if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + + VkResult vkCreateSurfaceOHOS( VkInstance instance, + const VkSurfaceCreateInfoOHOS * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateSurfaceOHOS( instance, pCreateInfo, pAllocator, pSurface ); + } +# endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_NV_cooperative_matrix2 === + + VkResult vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( + VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( physicalDevice, pPropertyCount, pProperties ); + } + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + + VkResult + vkGetMemoryMetalHandleEXT( VkDevice device, const VkMemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo, void ** pHandle ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryMetalHandleEXT( device, pGetMetalHandleInfo, pHandle ); + } + + VkResult vkGetMemoryMetalHandlePropertiesEXT( VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void * pHandle, + VkMemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetMemoryMetalHandlePropertiesEXT( device, handleType, pHandle, pMemoryMetalHandleProperties ); + } +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_ARM_performance_counters_by_region === + + VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t * pCounterCount, + VkPerformanceCounterARM * pCounters, + VkPerformanceCounterDescriptionARM * pCounterDescriptions ) const + VULKAN_HPP_NOEXCEPT + { + return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( + physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions ); + } + + //=== VK_EXT_fragment_density_map_offset === + + void vkCmdEndRendering2EXT( VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR * pRenderingEndInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndRendering2EXT( commandBuffer, pRenderingEndInfo ); + } + + //=== VK_EXT_custom_resolve === + + void vkCmdBeginCustomResolveEXT( VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT * pBeginCustomResolveInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginCustomResolveEXT( commandBuffer, pBeginCustomResolveInfo ); + } + + //=== VK_KHR_maintenance10 === + + void vkCmdEndRendering2KHR( VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR * pRenderingEndInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndRendering2KHR( commandBuffer, pRenderingEndInfo ); + } + + //=== VK_NV_compute_occupancy_priority === + + void vkCmdSetComputeOccupancyPriorityNV( VkCommandBuffer commandBuffer, + const VkComputeOccupancyPriorityParametersNV * pParameters ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdSetComputeOccupancyPriorityNV( commandBuffer, pParameters ); + } + }; + + inline DispatchLoaderStatic & getDispatchLoaderStatic() + { + static DispatchLoaderStatic dls; + return dls; + } +#endif + + } // namespace detail +#if ( 14 <= VULKAN_HPP_CPP_VERSION ) + using std::exchange; +#else + template + VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange( T & obj, U && newValue ) + { + T oldValue = std::move( obj ); + obj = std::forward( newValue ); + return oldValue; + } +#endif + + struct AllocationCallbacks; + +#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) + + namespace detail + { + template + class ObjectDestroy + { + public: + ObjectDestroy() = default; + + ObjectDestroy( OwnerType owner, + Optional allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT + : m_owner( owner ) + , m_allocationCallbacks( allocationCallbacks ) + , m_dispatch( &dispatch ) + { + } + + OwnerType getOwner() const VULKAN_HPP_NOEXCEPT + { + return m_owner; + } + + Optional getAllocator() const VULKAN_HPP_NOEXCEPT + { + return m_allocationCallbacks; + } + + Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT + { + return *m_dispatch; + } + + protected: + template + void destroy( T t ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_owner && m_dispatch ); + m_owner.destroy( t, m_allocationCallbacks, *m_dispatch ); + } + + private: + OwnerType m_owner = {}; + Optional m_allocationCallbacks = nullptr; + Dispatch const * m_dispatch = nullptr; + }; + + class NoParent; + + template + class ObjectDestroy + { + public: + ObjectDestroy() = default; + + ObjectDestroy( Optional allocationCallbacks, + Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT + : m_allocationCallbacks( allocationCallbacks ) + , m_dispatch( &dispatch ) + { + } + + Optional getAllocator() const VULKAN_HPP_NOEXCEPT + { + return m_allocationCallbacks; + } + + Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT + { + return *m_dispatch; + } + + protected: + template + void destroy( T t ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_dispatch ); + t.destroy( m_allocationCallbacks, *m_dispatch ); + } + + private: + Optional m_allocationCallbacks = nullptr; + Dispatch const * m_dispatch = nullptr; + }; + + template + class ObjectFree + { + public: + ObjectFree() = default; + + ObjectFree( OwnerType owner, + Optional allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT + : m_owner( owner ) + , m_allocationCallbacks( allocationCallbacks ) + , m_dispatch( &dispatch ) + { + } + + OwnerType getOwner() const VULKAN_HPP_NOEXCEPT + { + return m_owner; + } + + Optional getAllocator() const VULKAN_HPP_NOEXCEPT + { + return m_allocationCallbacks; + } + + Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT + { + return *m_dispatch; + } + + protected: + template + void destroy( T t ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_owner && m_dispatch ); + ( m_owner.free )( t, m_allocationCallbacks, *m_dispatch ); + } + + private: + OwnerType m_owner = {}; + Optional m_allocationCallbacks = nullptr; + Dispatch const * m_dispatch = nullptr; + }; + + template + class ObjectRelease + { + public: + ObjectRelease() = default; + + ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT + : m_owner( owner ) + , m_dispatch( &dispatch ) + { + } + + OwnerType getOwner() const VULKAN_HPP_NOEXCEPT + { + return m_owner; + } + + Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT + { + return *m_dispatch; + } + + protected: + template + void destroy( T t ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_owner && m_dispatch ); + m_owner.release( t, *m_dispatch ); + } + + private: + OwnerType m_owner = {}; + Dispatch const * m_dispatch = nullptr; + }; + + template + class PoolFree + { + public: + PoolFree() = default; + + PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT + : m_owner( owner ) + , m_pool( pool ) + , m_dispatch( &dispatch ) + { + } + + OwnerType getOwner() const VULKAN_HPP_NOEXCEPT + { + return m_owner; + } + + PoolType getPool() const VULKAN_HPP_NOEXCEPT + { + return m_pool; + } + + Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT + { + return *m_dispatch; + } + + protected: + template + void destroy( T t ) VULKAN_HPP_NOEXCEPT + { + ( m_owner.free )( m_pool, t, *m_dispatch ); + } + + private: + OwnerType m_owner = OwnerType(); + PoolType m_pool = PoolType(); + Dispatch const * m_dispatch = nullptr; + }; + + } // namespace detail +#endif // !VULKAN_HPP_NO_SMART_HANDLE + + //================== + //=== BASE TYPEs === + //================== + + using Bool32 = uint32_t; + using DeviceAddress = uint64_t; + using DeviceSize = uint64_t; + using RemoteAddressNV = void *; + using SampleMask = uint32_t; + + template + struct CppType + { + }; +} // namespace VULKAN_HPP_NAMESPACE + +#include +#if !defined( VULKAN_HPP_NO_TO_STRING ) +# include +#endif + +#ifndef VULKAN_HPP_NO_EXCEPTIONS +namespace std +{ + template <> + struct is_error_code_enum : public true_type + { + }; +} // namespace std +#endif + +namespace VULKAN_HPP_NAMESPACE +{ +#ifndef VULKAN_HPP_NO_EXCEPTIONS + class ErrorCategoryImpl : public std::error_category + { + public: + virtual const char * name() const VULKAN_HPP_NOEXCEPT override + { + return VULKAN_HPP_NAMESPACE_STRING "::Result"; + } + + virtual std::string message( int ev ) const override + { +# if defined( VULKAN_HPP_NO_TO_STRING ) + return std::to_string( ev ); +# else + return to_string( static_cast( ev ) ); +# endif + } + }; + + class Error + { + public: + Error() VULKAN_HPP_NOEXCEPT = default; + Error( const Error & ) VULKAN_HPP_NOEXCEPT = default; + virtual ~Error() VULKAN_HPP_NOEXCEPT = default; + + virtual const char * what() const VULKAN_HPP_NOEXCEPT = 0; + }; + + class LogicError + : public Error + , public std::logic_error + { + public: + explicit LogicError( const std::string & what ) : Error(), std::logic_error( what ) {} + + explicit LogicError( char const * what ) : Error(), std::logic_error( what ) {} + + virtual const char * what() const VULKAN_HPP_NOEXCEPT + { + return std::logic_error::what(); + } + }; + + class SystemError + : public Error + , public std::system_error + { + public: + SystemError( std::error_code ec ) : Error(), std::system_error( ec ) {} + + SystemError( std::error_code ec, std::string const & what ) : Error(), std::system_error( ec, what ) {} + + SystemError( std::error_code ec, char const * what ) : Error(), std::system_error( ec, what ) {} + + SystemError( int ev, std::error_category const & ecat ) : Error(), std::system_error( ev, ecat ) {} + + SystemError( int ev, std::error_category const & ecat, std::string const & what ) : Error(), std::system_error( ev, ecat, what ) {} + + SystemError( int ev, std::error_category const & ecat, char const * what ) : Error(), std::system_error( ev, ecat, what ) {} + + virtual const char * what() const VULKAN_HPP_NOEXCEPT + { + return std::system_error::what(); + } + }; + + VULKAN_HPP_INLINE const std::error_category & errorCategory() VULKAN_HPP_NOEXCEPT + { + static ErrorCategoryImpl instance; + return instance; + } + + VULKAN_HPP_INLINE std::error_code make_error_code( Result e ) VULKAN_HPP_NOEXCEPT + { + return std::error_code( static_cast( e ), errorCategory() ); + } + + VULKAN_HPP_INLINE std::error_condition make_error_condition( Result e ) VULKAN_HPP_NOEXCEPT + { + return std::error_condition( static_cast( e ), errorCategory() ); + } + + class OutOfHostMemoryError : public SystemError + { + public: + OutOfHostMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} + + OutOfHostMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} + }; + + class OutOfDeviceMemoryError : public SystemError + { + public: + OutOfDeviceMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} + + OutOfDeviceMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} + }; + + class InitializationFailedError : public SystemError + { + public: + InitializationFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} + + InitializationFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} + }; + + class DeviceLostError : public SystemError + { + public: + DeviceLostError( std::string const & message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} + + DeviceLostError( char const * message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} + }; + + class MemoryMapFailedError : public SystemError + { + public: + MemoryMapFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} + + MemoryMapFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} + }; + + class LayerNotPresentError : public SystemError + { + public: + LayerNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} + + LayerNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} + }; + + class ExtensionNotPresentError : public SystemError + { + public: + ExtensionNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} + + ExtensionNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} + }; + + class FeatureNotPresentError : public SystemError + { + public: + FeatureNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} + + FeatureNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} + }; + + class IncompatibleDriverError : public SystemError + { + public: + IncompatibleDriverError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} + + IncompatibleDriverError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} + }; + + class TooManyObjectsError : public SystemError + { + public: + TooManyObjectsError( std::string const & message ) : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} + + TooManyObjectsError( char const * message ) : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} + }; + + class FormatNotSupportedError : public SystemError + { + public: + FormatNotSupportedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} + + FormatNotSupportedError( char const * message ) : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} + }; + + class FragmentedPoolError : public SystemError + { + public: + FragmentedPoolError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} + + FragmentedPoolError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} + }; + + class UnknownError : public SystemError + { + public: + UnknownError( std::string const & message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {} + + UnknownError( char const * message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {} + }; + + class ValidationFailedError : public SystemError + { + public: + ValidationFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorValidationFailed ), message ) {} + + ValidationFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorValidationFailed ), message ) {} + }; + + class OutOfPoolMemoryError : public SystemError + { + public: + OutOfPoolMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {} + + OutOfPoolMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {} + }; + + class InvalidExternalHandleError : public SystemError + { + public: + InvalidExternalHandleError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {} + + InvalidExternalHandleError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {} + }; + + class InvalidOpaqueCaptureAddressError : public SystemError + { + public: + InvalidOpaqueCaptureAddressError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {} + + InvalidOpaqueCaptureAddressError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {} + }; + + class FragmentationError : public SystemError + { + public: + FragmentationError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {} + + FragmentationError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {} + }; + + class NotPermittedError : public SystemError + { + public: + NotPermittedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNotPermitted ), message ) {} + + NotPermittedError( char const * message ) : SystemError( make_error_code( Result::eErrorNotPermitted ), message ) {} + }; + + class SurfaceLostKHRError : public SystemError + { + public: + SurfaceLostKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} + + SurfaceLostKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} + }; + + class NativeWindowInUseKHRError : public SystemError + { + public: + NativeWindowInUseKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} + + NativeWindowInUseKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} + }; + + class OutOfDateKHRError : public SystemError + { + public: + OutOfDateKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} + + OutOfDateKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} + }; + + class IncompatibleDisplayKHRError : public SystemError + { + public: + IncompatibleDisplayKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} + + IncompatibleDisplayKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} + }; + + class InvalidShaderNVError : public SystemError + { + public: + InvalidShaderNVError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} + + InvalidShaderNVError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} + }; + + class ImageUsageNotSupportedKHRError : public SystemError + { + public: + ImageUsageNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {} + + ImageUsageNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {} + }; + + class VideoPictureLayoutNotSupportedKHRError : public SystemError + { + public: + VideoPictureLayoutNotSupportedKHRError( std::string const & message ) + : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message ) + { + } + + VideoPictureLayoutNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message ) + { + } + }; + + class VideoProfileOperationNotSupportedKHRError : public SystemError + { + public: + VideoProfileOperationNotSupportedKHRError( std::string const & message ) + : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message ) + { + } + + VideoProfileOperationNotSupportedKHRError( char const * message ) + : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message ) + { + } + }; + + class VideoProfileFormatNotSupportedKHRError : public SystemError + { + public: + VideoProfileFormatNotSupportedKHRError( std::string const & message ) + : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message ) + { + } + + VideoProfileFormatNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message ) + { + } + }; + + class VideoProfileCodecNotSupportedKHRError : public SystemError + { + public: + VideoProfileCodecNotSupportedKHRError( std::string const & message ) + : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message ) + { + } + + VideoProfileCodecNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message ) {} + }; + + class VideoStdVersionNotSupportedKHRError : public SystemError + { + public: + VideoStdVersionNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message ) + { + } + + VideoStdVersionNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message ) {} + }; + + class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError + { + public: + InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const & message ) + : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) + { + } + + InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message ) + : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) + { + } + }; + + class PresentTimingQueueFullEXTError : public SystemError + { + public: + PresentTimingQueueFullEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorPresentTimingQueueFullEXT ), message ) {} + + PresentTimingQueueFullEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorPresentTimingQueueFullEXT ), message ) {} + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + class FullScreenExclusiveModeLostEXTError : public SystemError + { + public: + FullScreenExclusiveModeLostEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) + { + } + + FullScreenExclusiveModeLostEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {} + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + class InvalidVideoStdParametersKHRError : public SystemError + { + public: + InvalidVideoStdParametersKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidVideoStdParametersKHR ), message ) {} + + InvalidVideoStdParametersKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidVideoStdParametersKHR ), message ) {} + }; + + class CompressionExhaustedEXTError : public SystemError + { + public: + CompressionExhaustedEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {} + + CompressionExhaustedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {} + }; + + class NotEnoughSpaceKHRError : public SystemError + { + public: + NotEnoughSpaceKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNotEnoughSpaceKHR ), message ) {} + + NotEnoughSpaceKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNotEnoughSpaceKHR ), message ) {} + }; + + namespace detail + { + [[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) + { + switch ( result ) + { + case Result::eErrorOutOfHostMemory : throw OutOfHostMemoryError( message ); + case Result::eErrorOutOfDeviceMemory : throw OutOfDeviceMemoryError( message ); + case Result::eErrorInitializationFailed : throw InitializationFailedError( message ); + case Result::eErrorDeviceLost : throw DeviceLostError( message ); + case Result::eErrorMemoryMapFailed : throw MemoryMapFailedError( message ); + case Result::eErrorLayerNotPresent : throw LayerNotPresentError( message ); + case Result::eErrorExtensionNotPresent : throw ExtensionNotPresentError( message ); + case Result::eErrorFeatureNotPresent : throw FeatureNotPresentError( message ); + case Result::eErrorIncompatibleDriver : throw IncompatibleDriverError( message ); + case Result::eErrorTooManyObjects : throw TooManyObjectsError( message ); + case Result::eErrorFormatNotSupported : throw FormatNotSupportedError( message ); + case Result::eErrorFragmentedPool : throw FragmentedPoolError( message ); + case Result::eErrorUnknown : throw UnknownError( message ); + case Result::eErrorValidationFailed : throw ValidationFailedError( message ); + case Result::eErrorOutOfPoolMemory : throw OutOfPoolMemoryError( message ); + case Result::eErrorInvalidExternalHandle : throw InvalidExternalHandleError( message ); + case Result::eErrorInvalidOpaqueCaptureAddress : throw InvalidOpaqueCaptureAddressError( message ); + case Result::eErrorFragmentation : throw FragmentationError( message ); + case Result::eErrorNotPermitted : throw NotPermittedError( message ); + case Result::eErrorSurfaceLostKHR : throw SurfaceLostKHRError( message ); + case Result::eErrorNativeWindowInUseKHR : throw NativeWindowInUseKHRError( message ); + case Result::eErrorOutOfDateKHR : throw OutOfDateKHRError( message ); + case Result::eErrorIncompatibleDisplayKHR : throw IncompatibleDisplayKHRError( message ); + case Result::eErrorInvalidShaderNV : throw InvalidShaderNVError( message ); + case Result::eErrorImageUsageNotSupportedKHR : throw ImageUsageNotSupportedKHRError( message ); + case Result::eErrorVideoPictureLayoutNotSupportedKHR : throw VideoPictureLayoutNotSupportedKHRError( message ); + case Result::eErrorVideoProfileOperationNotSupportedKHR : throw VideoProfileOperationNotSupportedKHRError( message ); + case Result::eErrorVideoProfileFormatNotSupportedKHR : throw VideoProfileFormatNotSupportedKHRError( message ); + case Result::eErrorVideoProfileCodecNotSupportedKHR : throw VideoProfileCodecNotSupportedKHRError( message ); + case Result::eErrorVideoStdVersionNotSupportedKHR : throw VideoStdVersionNotSupportedKHRError( message ); + case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message ); + case Result::eErrorPresentTimingQueueFullEXT : throw PresentTimingQueueFullEXTError( message ); +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message ); +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + case Result::eErrorInvalidVideoStdParametersKHR: throw InvalidVideoStdParametersKHRError( message ); + case Result::eErrorCompressionExhaustedEXT : throw CompressionExhaustedEXTError( message ); + case Result::eErrorNotEnoughSpaceKHR : throw NotEnoughSpaceKHRError( message ); + default : throw SystemError( make_error_code( result ), message ); + } + } + } // namespace detail +#endif + + template + struct ResultValue + { +#ifdef VULKAN_HPP_HAS_NOEXCEPT + ResultValue( Result r, T & v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( v ) ) ) +#else + ResultValue( Result r, T & v ) +#endif + : result( r ), value( v ) + { + } + +#ifdef VULKAN_HPP_HAS_NOEXCEPT + ResultValue( Result r, T && v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( std::move( v ) ) ) ) +#else + ResultValue( Result r, T && v ) +#endif + : result( r ), value( std::move( v ) ) + { + } + + Result result; + T value; + + operator std::tuple() VULKAN_HPP_NOEXCEPT + { + return std::tuple( result, value ); + } + + // std::expected-look alike + bool has_value() const VULKAN_HPP_NOEXCEPT + { + return result == vk::Result::eSuccess; + } + + T const * operator->() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( has_value() ); + return &value; + } + + T * operator->() VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( has_value() ); + return &value; + } + + T const & operator*() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( has_value() ); + return value; + } + + T & operator*() VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( has_value() ); + return value; + } + }; + +#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) + template + struct ResultValue> + { +# ifdef VULKAN_HPP_HAS_NOEXCEPT + ResultValue( Result r, UniqueHandle && v ) VULKAN_HPP_NOEXCEPT +# else + ResultValue( Result r, UniqueHandle && v ) +# endif + : result( r ) + , value( std::move( v ) ) + { + } + + VULKAN_HPP_DEPRECATED( + "asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." ) + + std::tuple> asTuple() & + { + return std::make_tuple( result, std::move( value ) ); + } + + std::tuple> asTuple() && + { + return std::make_tuple( result, std::move( value ) ); + } + + Result result; + UniqueHandle value; + }; + + template + struct ResultValue>> + { +# ifdef VULKAN_HPP_HAS_NOEXCEPT + ResultValue( Result r, std::vector> && v ) VULKAN_HPP_NOEXCEPT +# else + ResultValue( Result r, std::vector> && v ) +# endif + : result( r ) + , value( std::move( v ) ) + { + } + + VULKAN_HPP_DEPRECATED( + "asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." ) + + std::tuple>> asTuple() & + { + return std::make_tuple( result, std::move( value ) ); + } + + std::tuple>> asTuple() && + { + return std::make_tuple( result, std::move( value ) ); + } + + Result result; + std::vector> value; + }; +#endif + + template + struct ResultValueType + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS +# ifdef VULKAN_HPP_EXPECTED + using type = VULKAN_HPP_EXPECTED; +# else + using type = ResultValue; +# endif +#else + using type = T; +#endif + }; + + template <> + struct ResultValueType + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS +# ifdef VULKAN_HPP_EXPECTED + using type = VULKAN_HPP_EXPECTED; +# else + using type = Result; +# endif +#else + using type = void; +#endif + }; + + namespace detail + { + template + VULKAN_HPP_CONSTEXPR bool ignore( T const & ) VULKAN_HPP_NOEXCEPT + { + return true; + } + + VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result ) + { +#if defined( VULKAN_HPP_NO_EXCEPTIONS ) +# ifdef VULKAN_HPP_UNEXPECTED + if ( result == Result::eSuccess ) + { + return {}; + } + return VULKAN_HPP_UNEXPECTED( result ); +# else + return result; +# endif +#else + ignore( result ); +#endif + } + + template + VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result, T & data ) + { +#if defined( VULKAN_HPP_NO_EXCEPTIONS ) +# ifdef VULKAN_HPP_EXPECTED + if ( result == Result::eSuccess ) + { + return data; + } + return VULKAN_HPP_UNEXPECTED( data ); +# else + return ResultValue( result, data ); +# endif +#else + ignore( result ); + return data; +#endif + } + + template + VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result, T && data ) + { +#if defined( VULKAN_HPP_NO_EXCEPTIONS ) +# ifdef VULKAN_HPP_EXPECTED + if ( result == Result::eSuccess ) + { + return std::move( data ); + } + return VULKAN_HPP_UNEXPECTED( result ); +# else + return ResultValue( result, std::move( data ) ); +# endif +#else + ignore( result ); + return std::move( data ); +#endif + } + } // namespace detail + + namespace detail + { + VULKAN_HPP_INLINE void resultCheck( Result result, char const * message ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty + ignore( message ); + VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); +#else + if ( result != Result::eSuccess ) + { + throwResultException( result, message ); + } +#endif + } + + VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list successCodes ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty + ignore( message ); + ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty + VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); +#else + if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) + { + throwResultException( result, message ); + } +#endif + } + + template + VULKAN_HPP_INLINE void resultCheck( Result result, + char const * message, + std::initializer_list successCodes, + VkDevice device, + std::vector const & pipelines, + AllocationCallbacks const * pAllocator, + Dispatch const & d ) + { +#ifdef VULKAN_HPP_NO_EXCEPTIONS + ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty + ignore( message ); + ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty + ignore( device ); + ignore( pipelines ); + ignore( pAllocator ); + ignore( d ); + VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); +#else + if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) + { + for ( HandleType pipeline : pipelines ) + { + d.vkDestroyPipeline( device, static_cast( pipeline ), reinterpret_cast( pAllocator ) ); + } + throwResultException( result, message ); + } +#endif + } + } // namespace detail + + //=========================== + //=== CONSTEXPR CONSTANTs === + //=========================== + + //=== VK_VERSION_1_0 === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t False = VK_FALSE; + VULKAN_HPP_CONSTEXPR_INLINE float LodClampNone = VK_LOD_CLAMP_NONE; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyIgnored = VK_QUEUE_FAMILY_IGNORED; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t RemainingArrayLayers = VK_REMAINING_ARRAY_LAYERS; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t RemainingMipLevels = VK_REMAINING_MIP_LEVELS; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t True = VK_TRUE; + VULKAN_HPP_CONSTEXPR_INLINE uint64_t WholeSize = VK_WHOLE_SIZE; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxMemoryTypes = VK_MAX_MEMORY_TYPES; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPhysicalDeviceNameSize = VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t UuidSize = VK_UUID_SIZE; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxExtensionNameSize = VK_MAX_EXTENSION_NAME_SIZE; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDescriptionSize = VK_MAX_DESCRIPTION_SIZE; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxMemoryHeaps = VK_MAX_MEMORY_HEAPS; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t AttachmentUnused = VK_ATTACHMENT_UNUSED; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t SubpassExternal = VK_SUBPASS_EXTERNAL; + + //=== VK_VERSION_1_1 === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDeviceGroupSize = VK_MAX_DEVICE_GROUP_SIZE; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t LuidSize = VK_LUID_SIZE; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyExternal = VK_QUEUE_FAMILY_EXTERNAL; + + //=== VK_VERSION_1_2 === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverNameSize = VK_MAX_DRIVER_NAME_SIZE; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSize = VK_MAX_DRIVER_INFO_SIZE; + + //=== VK_VERSION_1_4 === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySize = VK_MAX_GLOBAL_PRIORITY_SIZE; + + //=== VK_KHR_device_group_creation === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDeviceGroupSizeKHR = VK_MAX_DEVICE_GROUP_SIZE_KHR; + + //=== VK_KHR_external_memory_capabilities === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t LuidSizeKHR = VK_LUID_SIZE_KHR; + + //=== VK_KHR_external_memory === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyExternalKHR = VK_QUEUE_FAMILY_EXTERNAL_KHR; + + //=== VK_EXT_queue_family_foreign === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyForeignEXT = VK_QUEUE_FAMILY_FOREIGN_EXT; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderIndexUnusedAMDX = VK_SHADER_INDEX_UNUSED_AMDX; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_ray_tracing_pipeline === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedKHR = VK_SHADER_UNUSED_KHR; + + //=== VK_NV_ray_tracing === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedNV = VK_SHADER_UNUSED_NV; + + //=== VK_KHR_global_priority === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeKHR = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; + + //=== VK_KHR_driver_properties === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverNameSizeKHR = VK_MAX_DRIVER_NAME_SIZE_KHR; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSizeKHR = VK_MAX_DRIVER_INFO_SIZE_KHR; + + //=== VK_EXT_global_priority_query === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeEXT = VK_MAX_GLOBAL_PRIORITY_SIZE_EXT; + + //=== VK_EXT_image_sliced_view_of_3d === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Remaining3DSlicesEXT = VK_REMAINING_3D_SLICES_EXT; + + //=== VK_EXT_shader_module_identifier === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxShaderModuleIdentifierSizeEXT = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_dense_geometry_format === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t CompressedTriangleFormatDgf1ByteAlignmentAMDX = VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t CompressedTriangleFormatDgf1ByteStrideAMDX = VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_pipeline_binary === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPipelineBinaryKeySizeKHR = VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; + + //=== VK_ARM_data_graph === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPhysicalDeviceDataGraphOperationSetNameSizeARM = VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM; + + //=== VK_KHR_video_decode_av1 === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxVideoAv1ReferencesPerFrameKHR = VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; + + //=== VK_KHR_video_decode_vp9 === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxVideoVp9ReferencesPerFrameKHR = VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; + + //=== VK_NV_partitioned_acceleration_structure === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t PartitionedAccelerationStructurePartitionIndexGlobalNV = VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV; + + //=== VK_QCOM_data_graph_model === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t DataGraphModelToolchainVersionLengthQCOM = VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM; + + //=== VK_NV_compute_occupancy_priority === + VULKAN_HPP_CONSTEXPR_INLINE float ComputeOccupancyPriorityLowNV = VK_COMPUTE_OCCUPANCY_PRIORITY_LOW_NV; + VULKAN_HPP_CONSTEXPR_INLINE float ComputeOccupancyPriorityNormalNV = VK_COMPUTE_OCCUPANCY_PRIORITY_NORMAL_NV; + VULKAN_HPP_CONSTEXPR_INLINE float ComputeOccupancyPriorityHighNV = VK_COMPUTE_OCCUPANCY_PRIORITY_HIGH_NV; + + //======================== + //=== CONSTEXPR VALUEs === + //======================== + VULKAN_HPP_CONSTEXPR_INLINE uint32_t HeaderVersion = VK_HEADER_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Use64BitPtrDefines = VK_USE_64_BIT_PTR_DEFINES; + + //========================= + //=== CONSTEXPR CALLEEs === + //========================= + 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_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_CONSTEXPR uint32_t versionMajor( T const version ) + { + return ( (uint32_t)( version ) >> 22U ); + } + + template ::value>::type> + VULKAN_HPP_CONSTEXPR uint32_t versionMinor( T const version ) + { + return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU ); + } + + template ::value>::type> + VULKAN_HPP_CONSTEXPR uint32_t versionPatch( T const version ) + { + return ( (uint32_t)( version ) & 0xFFFU ); + } + + //========================= + //=== CONSTEXPR CALLERs === + //========================= + VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion = makeApiVersion( 0, 1, 0, 0 ); + VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion10 = makeApiVersion( 0, 1, 0, 0 ); + VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion11 = makeApiVersion( 0, 1, 1, 0 ); + VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion12 = makeApiVersion( 0, 1, 2, 0 ); + VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion13 = makeApiVersion( 0, 1, 3, 0 ); + VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion14 = makeApiVersion( 0, 1, 4, 0 ); + VULKAN_HPP_CONSTEXPR_INLINE auto HeaderVersionComplete = makeApiVersion( 0, 1, 4, VK_HEADER_VERSION ); + + //================================= + //=== CONSTEXPR EXTENSION NAMEs === + //================================= + + //=== VK_KHR_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceSpecVersion = VK_KHR_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceExtensionName = VK_KHR_SURFACE_EXTENSION_NAME; + + //=== VK_KHR_swapchain === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainSpecVersion = VK_KHR_SWAPCHAIN_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainExtensionName = VK_KHR_SWAPCHAIN_EXTENSION_NAME; + + //=== VK_KHR_display === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySpecVersion = VK_KHR_DISPLAY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplayExtensionName = VK_KHR_DISPLAY_EXTENSION_NAME; + + //=== VK_KHR_display_swapchain === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySwapchainSpecVersion = VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySwapchainExtensionName = VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRXlibSurfaceSpecVersion = VK_KHR_XLIB_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRXlibSurfaceExtensionName = VK_KHR_XLIB_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRXcbSurfaceSpecVersion = VK_KHR_XCB_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRXcbSurfaceExtensionName = VK_KHR_XCB_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRWaylandSurfaceSpecVersion = VK_KHR_WAYLAND_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRWaylandSurfaceExtensionName = VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRAndroidSurfaceSpecVersion = VK_KHR_ANDROID_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRAndroidSurfaceExtensionName = VK_KHR_ANDROID_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32SurfaceSpecVersion = VK_KHR_WIN32_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32SurfaceExtensionName = VK_KHR_WIN32_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + VULKAN_HPP_DEPRECATED( "The VK_EXT_debug_report extension has been deprecated by VK_EXT_debug_utils." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugReportSpecVersion = VK_EXT_DEBUG_REPORT_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_EXT_debug_report extension has been deprecated by VK_EXT_debug_utils." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugReportExtensionName = VK_EXT_DEBUG_REPORT_EXTENSION_NAME; + + //=== VK_NV_glsl_shader === + VULKAN_HPP_DEPRECATED( "The VK_NV_glsl_shader extension has been deprecated." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVGlslShaderSpecVersion = VK_NV_GLSL_SHADER_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_NV_glsl_shader extension has been deprecated." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVGlslShaderExtensionName = VK_NV_GLSL_SHADER_EXTENSION_NAME; + + //=== VK_EXT_depth_range_unrestricted === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthRangeUnrestrictedSpecVersion = VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthRangeUnrestrictedExtensionName = VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME; + + //=== VK_KHR_sampler_mirror_clamp_to_edge === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerMirrorClampToEdgeSpecVersion = VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerMirrorClampToEdgeExtensionName = VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME; + + //=== VK_IMG_filter_cubic === + VULKAN_HPP_CONSTEXPR_INLINE auto IMGFilterCubicSpecVersion = VK_IMG_FILTER_CUBIC_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto IMGFilterCubicExtensionName = VK_IMG_FILTER_CUBIC_EXTENSION_NAME; + + //=== VK_AMD_rasterization_order === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDRasterizationOrderSpecVersion = VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDRasterizationOrderExtensionName = VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME; + + //=== VK_AMD_shader_trinary_minmax === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderTrinaryMinmaxSpecVersion = VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderTrinaryMinmaxExtensionName = VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME; + + //=== VK_AMD_shader_explicit_vertex_parameter === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderExplicitVertexParameterSpecVersion = VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderExplicitVertexParameterExtensionName = VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME; + + //=== VK_EXT_debug_marker === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugMarkerSpecVersion = VK_EXT_DEBUG_MARKER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugMarkerExtensionName = VK_EXT_DEBUG_MARKER_EXTENSION_NAME; + + //=== VK_KHR_video_queue === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoQueueSpecVersion = VK_KHR_VIDEO_QUEUE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoQueueExtensionName = VK_KHR_VIDEO_QUEUE_EXTENSION_NAME; + + //=== VK_KHR_video_decode_queue === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeQueueSpecVersion = VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeQueueExtensionName = VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME; + + //=== VK_AMD_gcn_shader === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDGcnShaderSpecVersion = VK_AMD_GCN_SHADER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDGcnShaderExtensionName = VK_AMD_GCN_SHADER_EXTENSION_NAME; + + //=== VK_NV_dedicated_allocation === + VULKAN_HPP_DEPRECATED( "The VK_NV_dedicated_allocation extension has been deprecated by VK_KHR_dedicated_allocation." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationSpecVersion = VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_NV_dedicated_allocation extension has been deprecated by VK_KHR_dedicated_allocation." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationExtensionName = VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME; + + //=== VK_EXT_transform_feedback === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTTransformFeedbackSpecVersion = VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTTransformFeedbackExtensionName = VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME; + + //=== VK_NVX_binary_import === + VULKAN_HPP_CONSTEXPR_INLINE auto NVXBinaryImportSpecVersion = VK_NVX_BINARY_IMPORT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVXBinaryImportExtensionName = VK_NVX_BINARY_IMPORT_EXTENSION_NAME; + + //=== VK_NVX_image_view_handle === + VULKAN_HPP_CONSTEXPR_INLINE auto NVXImageViewHandleSpecVersion = VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVXImageViewHandleExtensionName = VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME; + + //=== VK_AMD_draw_indirect_count === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDDrawIndirectCountSpecVersion = VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDDrawIndirectCountExtensionName = VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME; + + //=== VK_AMD_negative_viewport_height === + VULKAN_HPP_DEPRECATED( "The VK_AMD_negative_viewport_height extension has been obsoleted by VK_KHR_maintenance1." ) + VULKAN_HPP_CONSTEXPR_INLINE auto AMDNegativeViewportHeightSpecVersion = VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_AMD_negative_viewport_height extension has been obsoleted by VK_KHR_maintenance1." ) + VULKAN_HPP_CONSTEXPR_INLINE auto AMDNegativeViewportHeightExtensionName = VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME; + + //=== VK_AMD_gpu_shader_half_float === + VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_half_float extension has been deprecated by VK_KHR_shader_float16_int8." ) + VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderHalfFloatSpecVersion = VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_half_float extension has been deprecated by VK_KHR_shader_float16_int8." ) + VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderHalfFloatExtensionName = VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME; + + //=== VK_AMD_shader_ballot === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderBallotSpecVersion = VK_AMD_SHADER_BALLOT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderBallotExtensionName = VK_AMD_SHADER_BALLOT_EXTENSION_NAME; + + //=== VK_KHR_video_encode_h264 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH264SpecVersion = VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH264ExtensionName = VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME; + + //=== VK_KHR_video_encode_h265 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH265SpecVersion = VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH265ExtensionName = VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME; + + //=== VK_KHR_video_decode_h264 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH264SpecVersion = VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH264ExtensionName = VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME; + + //=== VK_AMD_texture_gather_bias_lod === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDTextureGatherBiasLodSpecVersion = VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDTextureGatherBiasLodExtensionName = VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME; + + //=== VK_AMD_shader_info === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderInfoSpecVersion = VK_AMD_SHADER_INFO_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderInfoExtensionName = VK_AMD_SHADER_INFO_EXTENSION_NAME; + + //=== VK_KHR_dynamic_rendering === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingSpecVersion = VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingExtensionName = VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME; + + //=== VK_AMD_shader_image_load_store_lod === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderImageLoadStoreLodSpecVersion = VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderImageLoadStoreLodExtensionName = VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto GGPStreamDescriptorSurfaceSpecVersion = VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto GGPStreamDescriptorSurfaceExtensionName = VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_corner_sampled_image === + VULKAN_HPP_CONSTEXPR_INLINE auto NVCornerSampledImageSpecVersion = VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVCornerSampledImageExtensionName = VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME; + + //=== VK_KHR_multiview === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMultiviewSpecVersion = VK_KHR_MULTIVIEW_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMultiviewExtensionName = VK_KHR_MULTIVIEW_EXTENSION_NAME; + + //=== VK_IMG_format_pvrtc === + VULKAN_HPP_DEPRECATED( "The VK_IMG_format_pvrtc extension has been deprecated." ) + VULKAN_HPP_CONSTEXPR_INLINE auto IMGFormatPvrtcSpecVersion = VK_IMG_FORMAT_PVRTC_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_IMG_format_pvrtc extension has been deprecated." ) + VULKAN_HPP_CONSTEXPR_INLINE auto IMGFormatPvrtcExtensionName = VK_IMG_FORMAT_PVRTC_EXTENSION_NAME; + + //=== VK_NV_external_memory_capabilities === + VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_capabilities extension has been deprecated by VK_KHR_external_memory_capabilities." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryCapabilitiesSpecVersion = VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_capabilities extension has been deprecated by VK_KHR_external_memory_capabilities." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryCapabilitiesExtensionName = VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME; + + //=== VK_NV_external_memory === + VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory extension has been deprecated by VK_KHR_external_memory." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemorySpecVersion = VK_NV_EXTERNAL_MEMORY_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory extension has been deprecated by VK_KHR_external_memory." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryExtensionName = VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_win32 extension has been deprecated by VK_KHR_external_memory_win32." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryWin32SpecVersion = VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_win32 extension has been deprecated by VK_KHR_external_memory_win32." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryWin32ExtensionName = VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_win32_keyed_mutex === + VULKAN_HPP_CONSTEXPR_INLINE auto NVWin32KeyedMutexSpecVersion = VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVWin32KeyedMutexExtensionName = VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_get_physical_device_properties2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetPhysicalDeviceProperties2SpecVersion = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetPhysicalDeviceProperties2ExtensionName = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME; + + //=== VK_KHR_device_group === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupSpecVersion = VK_KHR_DEVICE_GROUP_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupExtensionName = VK_KHR_DEVICE_GROUP_EXTENSION_NAME; + + //=== VK_EXT_validation_flags === + VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_flags extension has been deprecated by VK_EXT_layer_settings." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFlagsSpecVersion = VK_EXT_VALIDATION_FLAGS_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_flags extension has been deprecated by VK_EXT_layer_settings." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFlagsExtensionName = VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto NNViSurfaceSpecVersion = VK_NN_VI_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NNViSurfaceExtensionName = VK_NN_VI_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_shader_draw_parameters === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderDrawParametersSpecVersion = VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderDrawParametersExtensionName = VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME; + + //=== VK_EXT_shader_subgroup_ballot === + VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_ballot extension has been deprecated by VK_VERSION_1_2." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupBallotSpecVersion = VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_ballot extension has been deprecated by VK_VERSION_1_2." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupBallotExtensionName = VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME; + + //=== VK_EXT_shader_subgroup_vote === + VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_vote extension has been deprecated by VK_VERSION_1_1." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupVoteSpecVersion = VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_vote extension has been deprecated by VK_VERSION_1_1." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupVoteExtensionName = VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME; + + //=== VK_EXT_texture_compression_astc_hdr === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstcHdrSpecVersion = VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstcHdrExtensionName = VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME; + + //=== VK_EXT_astc_decode_mode === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTAstcDecodeModeSpecVersion = VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTAstcDecodeModeExtensionName = VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME; + + //=== VK_EXT_pipeline_robustness === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineRobustnessSpecVersion = VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineRobustnessExtensionName = VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME; + + //=== VK_KHR_maintenance1 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance1SpecVersion = VK_KHR_MAINTENANCE_1_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance1ExtensionName = VK_KHR_MAINTENANCE_1_EXTENSION_NAME; + + //=== VK_KHR_device_group_creation === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupCreationSpecVersion = VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupCreationExtensionName = VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME; + + //=== VK_KHR_external_memory_capabilities === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryCapabilitiesSpecVersion = VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryCapabilitiesExtensionName = VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME; + + //=== VK_KHR_external_memory === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemorySpecVersion = VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryExtensionName = VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryWin32SpecVersion = VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryWin32ExtensionName = VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryFdSpecVersion = VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryFdExtensionName = VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_keyed_mutex === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32KeyedMutexSpecVersion = VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32KeyedMutexExtensionName = VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_capabilities === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreCapabilitiesSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreCapabilitiesExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME; + + //=== VK_KHR_external_semaphore === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreWin32SpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreWin32ExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreFdSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreFdExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME; + + //=== VK_KHR_push_descriptor === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPushDescriptorSpecVersion = VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPushDescriptorExtensionName = VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME; + + //=== VK_EXT_conditional_rendering === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTConditionalRenderingSpecVersion = VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTConditionalRenderingExtensionName = VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME; + + //=== VK_KHR_shader_float16_int8 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloat16Int8SpecVersion = VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloat16Int8ExtensionName = VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME; + + //=== VK_KHR_16bit_storage === + VULKAN_HPP_CONSTEXPR_INLINE auto KHR16BitStorageSpecVersion = VK_KHR_16BIT_STORAGE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHR16BitStorageExtensionName = VK_KHR_16BIT_STORAGE_EXTENSION_NAME; + + //=== VK_KHR_incremental_present === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRIncrementalPresentSpecVersion = VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRIncrementalPresentExtensionName = VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME; + + //=== VK_KHR_descriptor_update_template === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDescriptorUpdateTemplateSpecVersion = VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDescriptorUpdateTemplateExtensionName = VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME; + + //=== VK_NV_clip_space_w_scaling === + VULKAN_HPP_CONSTEXPR_INLINE auto NVClipSpaceWScalingSpecVersion = VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVClipSpaceWScalingExtensionName = VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME; + + //=== VK_EXT_direct_mode_display === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectModeDisplaySpecVersion = VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectModeDisplayExtensionName = VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireXlibDisplaySpecVersion = VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireXlibDisplayExtensionName = VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplaySurfaceCounterSpecVersion = VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplaySurfaceCounterExtensionName = VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME; + + //=== VK_EXT_display_control === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplayControlSpecVersion = VK_EXT_DISPLAY_CONTROL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplayControlExtensionName = VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME; + + //=== VK_GOOGLE_display_timing === + VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDisplayTimingSpecVersion = VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDisplayTimingExtensionName = VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME; + + //=== VK_NV_sample_mask_override_coverage === + VULKAN_HPP_CONSTEXPR_INLINE auto NVSampleMaskOverrideCoverageSpecVersion = VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVSampleMaskOverrideCoverageExtensionName = VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME; + + //=== VK_NV_geometry_shader_passthrough === + VULKAN_HPP_CONSTEXPR_INLINE auto NVGeometryShaderPassthroughSpecVersion = VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVGeometryShaderPassthroughExtensionName = VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME; + + //=== VK_NV_viewport_array2 === + VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportArray2SpecVersion = VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportArray2ExtensionName = VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME; + + //=== VK_NVX_multiview_per_view_attributes === + VULKAN_HPP_CONSTEXPR_INLINE auto NVXMultiviewPerViewAttributesSpecVersion = VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVXMultiviewPerViewAttributesExtensionName = VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME; + + //=== VK_NV_viewport_swizzle === + VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportSwizzleSpecVersion = VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportSwizzleExtensionName = VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME; + + //=== VK_EXT_discard_rectangles === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDiscardRectanglesSpecVersion = VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDiscardRectanglesExtensionName = VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME; + + //=== VK_EXT_conservative_rasterization === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTConservativeRasterizationSpecVersion = VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTConservativeRasterizationExtensionName = VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME; + + //=== VK_EXT_depth_clip_enable === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipEnableSpecVersion = VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipEnableExtensionName = VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME; + + //=== VK_EXT_swapchain_colorspace === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainColorSpaceSpecVersion = VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainColorSpaceExtensionName = VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME; + + //=== VK_EXT_hdr_metadata === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTHdrMetadataSpecVersion = VK_EXT_HDR_METADATA_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTHdrMetadataExtensionName = VK_EXT_HDR_METADATA_EXTENSION_NAME; + + //=== VK_KHR_imageless_framebuffer === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRImagelessFramebufferSpecVersion = VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRImagelessFramebufferExtensionName = VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME; + + //=== VK_KHR_create_renderpass2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRCreateRenderpass2SpecVersion = VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRCreateRenderpass2ExtensionName = VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME; + + //=== VK_IMG_relaxed_line_rasterization === + VULKAN_HPP_CONSTEXPR_INLINE auto IMGRelaxedLineRasterizationSpecVersion = VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto IMGRelaxedLineRasterizationExtensionName = VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME; + + //=== VK_KHR_shared_presentable_image === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSharedPresentableImageSpecVersion = VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSharedPresentableImageExtensionName = VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME; + + //=== VK_KHR_external_fence_capabilities === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceCapabilitiesSpecVersion = VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceCapabilitiesExtensionName = VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME; + + //=== VK_KHR_external_fence === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceSpecVersion = VK_KHR_EXTERNAL_FENCE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceExtensionName = VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceWin32SpecVersion = VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceWin32ExtensionName = VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceFdSpecVersion = VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceFdExtensionName = VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME; + + //=== VK_KHR_performance_query === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPerformanceQuerySpecVersion = VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPerformanceQueryExtensionName = VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME; + + //=== VK_KHR_maintenance2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance2SpecVersion = VK_KHR_MAINTENANCE_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance2ExtensionName = VK_KHR_MAINTENANCE_2_EXTENSION_NAME; + + //=== VK_KHR_get_surface_capabilities2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetSurfaceCapabilities2SpecVersion = VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetSurfaceCapabilities2ExtensionName = VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME; + + //=== VK_KHR_variable_pointers === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVariablePointersSpecVersion = VK_KHR_VARIABLE_POINTERS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVariablePointersExtensionName = VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME; + + //=== VK_KHR_get_display_properties2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetDisplayProperties2SpecVersion = VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetDisplayProperties2ExtensionName = VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + VULKAN_HPP_DEPRECATED( "The VK_MVK_ios_surface extension has been deprecated by VK_EXT_metal_surface." ) + VULKAN_HPP_CONSTEXPR_INLINE auto MVKIosSurfaceSpecVersion = VK_MVK_IOS_SURFACE_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_MVK_ios_surface extension has been deprecated by VK_EXT_metal_surface." ) + VULKAN_HPP_CONSTEXPR_INLINE auto MVKIosSurfaceExtensionName = VK_MVK_IOS_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + VULKAN_HPP_DEPRECATED( "The VK_MVK_macos_surface extension has been deprecated by VK_EXT_metal_surface." ) + VULKAN_HPP_CONSTEXPR_INLINE auto MVKMacosSurfaceSpecVersion = VK_MVK_MACOS_SURFACE_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_MVK_macos_surface extension has been deprecated by VK_EXT_metal_surface." ) + VULKAN_HPP_CONSTEXPR_INLINE auto MVKMacosSurfaceExtensionName = VK_MVK_MACOS_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_external_memory_dma_buf === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryDmaBufSpecVersion = VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryDmaBufExtensionName = VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME; + + //=== VK_EXT_queue_family_foreign === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTQueueFamilyForeignSpecVersion = VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTQueueFamilyForeignExtensionName = VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME; + + //=== VK_KHR_dedicated_allocation === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDedicatedAllocationSpecVersion = VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDedicatedAllocationExtensionName = VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME; + + //=== VK_EXT_debug_utils === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugUtilsSpecVersion = VK_EXT_DEBUG_UTILS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugUtilsExtensionName = VK_EXT_DEBUG_UTILS_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalMemoryAndroidHardwareBufferSpecVersion = VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalMemoryAndroidHardwareBufferExtensionName = VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + //=== VK_EXT_sampler_filter_minmax === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSamplerFilterMinmaxSpecVersion = VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSamplerFilterMinmaxExtensionName = VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME; + + //=== VK_KHR_storage_buffer_storage_class === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRStorageBufferStorageClassSpecVersion = VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRStorageBufferStorageClassExtensionName = VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME; + + //=== VK_AMD_gpu_shader_int16 === + VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_int16 extension has been deprecated by VK_KHR_shader_float16_int8." ) + VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderInt16SpecVersion = VK_AMD_GPU_SHADER_INT16_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_int16 extension has been deprecated by VK_KHR_shader_float16_int8." ) + VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderInt16ExtensionName = VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDXShaderEnqueueSpecVersion = VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDXShaderEnqueueExtensionName = VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorHeapSpecVersion = VK_EXT_DESCRIPTOR_HEAP_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorHeapExtensionName = VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME; + + //=== VK_AMD_mixed_attachment_samples === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDMixedAttachmentSamplesSpecVersion = VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDMixedAttachmentSamplesExtensionName = VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME; + + //=== VK_AMD_shader_fragment_mask === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderFragmentMaskSpecVersion = VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderFragmentMaskExtensionName = VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME; + + //=== VK_EXT_inline_uniform_block === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTInlineUniformBlockSpecVersion = VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTInlineUniformBlockExtensionName = VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME; + + //=== VK_EXT_shader_stencil_export === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportSpecVersion = VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportExtensionName = VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME; + + //=== VK_KHR_shader_bfloat16 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16SpecVersion = VK_KHR_SHADER_BFLOAT16_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16ExtensionName = VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME; + + //=== VK_EXT_sample_locations === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsSpecVersion = VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsExtensionName = VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME; + + //=== VK_KHR_relaxed_block_layout === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRelaxedBlockLayoutSpecVersion = VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRelaxedBlockLayoutExtensionName = VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME; + + //=== VK_KHR_get_memory_requirements2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetMemoryRequirements2SpecVersion = VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetMemoryRequirements2ExtensionName = VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME; + + //=== VK_KHR_image_format_list === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRImageFormatListSpecVersion = VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRImageFormatListExtensionName = VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME; + + //=== VK_EXT_blend_operation_advanced === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTBlendOperationAdvancedSpecVersion = VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTBlendOperationAdvancedExtensionName = VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME; + + //=== VK_NV_fragment_coverage_to_color === + VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentCoverageToColorSpecVersion = VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentCoverageToColorExtensionName = VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME; + + //=== VK_KHR_acceleration_structure === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRAccelerationStructureSpecVersion = VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRAccelerationStructureExtensionName = VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME; + + //=== VK_KHR_ray_tracing_pipeline === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPipelineSpecVersion = VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPipelineExtensionName = VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME; + + //=== VK_KHR_ray_query === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayQuerySpecVersion = VK_KHR_RAY_QUERY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayQueryExtensionName = VK_KHR_RAY_QUERY_EXTENSION_NAME; + + //=== VK_NV_framebuffer_mixed_samples === + VULKAN_HPP_CONSTEXPR_INLINE auto NVFramebufferMixedSamplesSpecVersion = VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVFramebufferMixedSamplesExtensionName = VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME; + + //=== VK_NV_fill_rectangle === + VULKAN_HPP_CONSTEXPR_INLINE auto NVFillRectangleSpecVersion = VK_NV_FILL_RECTANGLE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVFillRectangleExtensionName = VK_NV_FILL_RECTANGLE_EXTENSION_NAME; + + //=== VK_NV_shader_sm_builtins === + VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSmBuiltinsSpecVersion = VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSmBuiltinsExtensionName = VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME; + + //=== VK_EXT_post_depth_coverage === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPostDepthCoverageSpecVersion = VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPostDepthCoverageExtensionName = VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME; + + //=== VK_KHR_sampler_ycbcr_conversion === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerYcbcrConversionSpecVersion = VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerYcbcrConversionExtensionName = VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME; + + //=== VK_KHR_bind_memory2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRBindMemory2SpecVersion = VK_KHR_BIND_MEMORY_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRBindMemory2ExtensionName = VK_KHR_BIND_MEMORY_2_EXTENSION_NAME; + + //=== VK_EXT_image_drm_format_modifier === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageDrmFormatModifierSpecVersion = VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageDrmFormatModifierExtensionName = VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME; + + //=== VK_EXT_validation_cache === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationCacheSpecVersion = VK_EXT_VALIDATION_CACHE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationCacheExtensionName = VK_EXT_VALIDATION_CACHE_EXTENSION_NAME; + + //=== VK_EXT_descriptor_indexing === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorIndexingSpecVersion = VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorIndexingExtensionName = VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME; + + //=== VK_EXT_shader_viewport_index_layer === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderViewportIndexLayerSpecVersion = VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderViewportIndexLayerExtensionName = VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_portability_subset === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilitySubsetSpecVersion = VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilitySubsetExtensionName = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NV_shading_rate_image === + VULKAN_HPP_CONSTEXPR_INLINE auto NVShadingRateImageSpecVersion = VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVShadingRateImageExtensionName = VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME; + + //=== VK_NV_ray_tracing === + VULKAN_HPP_DEPRECATED( "The VK_NV_ray_tracing extension has been deprecated by VK_KHR_ray_tracing_pipeline." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingSpecVersion = VK_NV_RAY_TRACING_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_NV_ray_tracing extension has been deprecated by VK_KHR_ray_tracing_pipeline." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingExtensionName = VK_NV_RAY_TRACING_EXTENSION_NAME; + + //=== VK_NV_representative_fragment_test === + VULKAN_HPP_CONSTEXPR_INLINE auto NVRepresentativeFragmentTestSpecVersion = VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVRepresentativeFragmentTestExtensionName = VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME; + + //=== VK_KHR_maintenance3 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance3SpecVersion = VK_KHR_MAINTENANCE_3_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance3ExtensionName = VK_KHR_MAINTENANCE_3_EXTENSION_NAME; + + //=== VK_KHR_draw_indirect_count === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDrawIndirectCountSpecVersion = VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDrawIndirectCountExtensionName = VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME; + + //=== VK_EXT_filter_cubic === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicSpecVersion = VK_EXT_FILTER_CUBIC_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicExtensionName = VK_EXT_FILTER_CUBIC_EXTENSION_NAME; + + //=== VK_QCOM_render_pass_shader_resolve === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassShaderResolveSpecVersion = VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassShaderResolveExtensionName = VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME; + + //=== VK_EXT_global_priority === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPrioritySpecVersion = VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityExtensionName = VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME; + + //=== VK_KHR_shader_subgroup_extended_types === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupExtendedTypesSpecVersion = VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupExtendedTypesExtensionName = VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME; + + //=== VK_KHR_8bit_storage === + VULKAN_HPP_CONSTEXPR_INLINE auto KHR8BitStorageSpecVersion = VK_KHR_8BIT_STORAGE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHR8BitStorageExtensionName = VK_KHR_8BIT_STORAGE_EXTENSION_NAME; + + //=== VK_EXT_external_memory_host === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostSpecVersion = VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostExtensionName = VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME; + + //=== VK_AMD_buffer_marker === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDBufferMarkerSpecVersion = VK_AMD_BUFFER_MARKER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDBufferMarkerExtensionName = VK_AMD_BUFFER_MARKER_EXTENSION_NAME; + + //=== VK_KHR_shader_atomic_int64 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderAtomicInt64SpecVersion = VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderAtomicInt64ExtensionName = VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME; + + //=== VK_KHR_shader_clock === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockSpecVersion = VK_KHR_SHADER_CLOCK_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockExtensionName = VK_KHR_SHADER_CLOCK_EXTENSION_NAME; + + //=== VK_AMD_pipeline_compiler_control === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDPipelineCompilerControlSpecVersion = VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDPipelineCompilerControlExtensionName = VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME; + + //=== VK_EXT_calibrated_timestamps === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsSpecVersion = VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsExtensionName = VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME; + + //=== VK_AMD_shader_core_properties === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCorePropertiesSpecVersion = VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCorePropertiesExtensionName = VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME; + + //=== VK_KHR_video_decode_h265 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH265SpecVersion = VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH265ExtensionName = VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME; + + //=== VK_KHR_global_priority === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRGlobalPrioritySpecVersion = VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRGlobalPriorityExtensionName = VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME; + + //=== VK_AMD_memory_overallocation_behavior === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDMemoryOverallocationBehaviorSpecVersion = VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDMemoryOverallocationBehaviorExtensionName = VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME; + + //=== VK_EXT_vertex_attribute_divisor === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorExtensionName = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_frame_token === + VULKAN_HPP_CONSTEXPR_INLINE auto GGPFrameTokenSpecVersion = VK_GGP_FRAME_TOKEN_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto GGPFrameTokenExtensionName = VK_GGP_FRAME_TOKEN_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_EXT_pipeline_creation_feedback === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationFeedbackSpecVersion = VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationFeedbackExtensionName = VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME; + + //=== VK_KHR_driver_properties === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDriverPropertiesSpecVersion = VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDriverPropertiesExtensionName = VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME; + + //=== VK_KHR_shader_float_controls === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControlsSpecVersion = VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControlsExtensionName = VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME; + + //=== VK_NV_shader_subgroup_partitioned === + VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSubgroupPartitionedSpecVersion = VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSubgroupPartitionedExtensionName = VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME; + + //=== VK_KHR_depth_stencil_resolve === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthStencilResolveSpecVersion = VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthStencilResolveExtensionName = VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME; + + //=== VK_KHR_swapchain_mutable_format === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMutableFormatSpecVersion = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMutableFormatExtensionName = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME; + + //=== VK_NV_compute_shader_derivatives === + VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeShaderDerivativesSpecVersion = VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeShaderDerivativesExtensionName = VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME; + + //=== VK_NV_mesh_shader === + VULKAN_HPP_CONSTEXPR_INLINE auto NVMeshShaderSpecVersion = VK_NV_MESH_SHADER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVMeshShaderExtensionName = VK_NV_MESH_SHADER_EXTENSION_NAME; + + //=== VK_NV_fragment_shader_barycentric === + VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShaderBarycentricSpecVersion = VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShaderBarycentricExtensionName = VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME; + + //=== VK_NV_shader_image_footprint === + VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderImageFootprintSpecVersion = VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderImageFootprintExtensionName = VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME; + + //=== VK_NV_scissor_exclusive === + VULKAN_HPP_CONSTEXPR_INLINE auto NVScissorExclusiveSpecVersion = VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVScissorExclusiveExtensionName = VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME; + + //=== VK_NV_device_diagnostic_checkpoints === + VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticCheckpointsSpecVersion = VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticCheckpointsExtensionName = VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME; + + //=== VK_KHR_timeline_semaphore === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRTimelineSemaphoreSpecVersion = VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRTimelineSemaphoreExtensionName = VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME; + + //=== VK_EXT_present_timing === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentTimingSpecVersion = VK_EXT_PRESENT_TIMING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentTimingExtensionName = VK_EXT_PRESENT_TIMING_EXTENSION_NAME; + + //=== VK_INTEL_shader_integer_functions2 === + VULKAN_HPP_CONSTEXPR_INLINE auto INTELShaderIntegerFunctions2SpecVersion = VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto INTELShaderIntegerFunctions2ExtensionName = VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME; + + //=== VK_INTEL_performance_query === + VULKAN_HPP_CONSTEXPR_INLINE auto INTELPerformanceQuerySpecVersion = VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto INTELPerformanceQueryExtensionName = VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME; + + //=== VK_KHR_vulkan_memory_model === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVulkanMemoryModelSpecVersion = VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVulkanMemoryModelExtensionName = VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME; + + //=== VK_EXT_pci_bus_info === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPciBusInfoSpecVersion = VK_EXT_PCI_BUS_INFO_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPciBusInfoExtensionName = VK_EXT_PCI_BUS_INFO_EXTENSION_NAME; + + //=== VK_AMD_display_native_hdr === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDDisplayNativeHdrSpecVersion = VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDDisplayNativeHdrExtensionName = VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAImagepipeSurfaceSpecVersion = VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAImagepipeSurfaceExtensionName = VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_KHR_shader_terminate_invocation === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderTerminateInvocationSpecVersion = VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderTerminateInvocationExtensionName = VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalSurfaceSpecVersion = VK_EXT_METAL_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalSurfaceExtensionName = VK_EXT_METAL_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_fragment_density_map === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapSpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME; + + //=== VK_EXT_scalar_block_layout === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTScalarBlockLayoutSpecVersion = VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTScalarBlockLayoutExtensionName = VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME; + + //=== VK_GOOGLE_hlsl_functionality1 === + VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEHlslFunctionality1SpecVersion = VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEHlslFunctionality1ExtensionName = VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME; + + //=== VK_GOOGLE_decorate_string === + VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDecorateStringSpecVersion = VK_GOOGLE_DECORATE_STRING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDecorateStringExtensionName = VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME; + + //=== VK_EXT_subgroup_size_control === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubgroupSizeControlSpecVersion = VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubgroupSizeControlExtensionName = VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME; + + //=== VK_KHR_fragment_shading_rate === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShadingRateSpecVersion = VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShadingRateExtensionName = VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME; + + //=== VK_AMD_shader_core_properties2 === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCoreProperties2SpecVersion = VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCoreProperties2ExtensionName = VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME; + + //=== VK_AMD_device_coherent_memory === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemorySpecVersion = VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemoryExtensionName = VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME; + + //=== VK_KHR_dynamic_rendering_local_read === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadSpecVersion = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadExtensionName = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME; + + //=== VK_EXT_shader_image_atomic_int64 === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64SpecVersion = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64ExtensionName = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME; + + //=== VK_KHR_shader_quad_control === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderQuadControlSpecVersion = VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderQuadControlExtensionName = VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME; + + //=== VK_KHR_spirv_1_4 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSpirv14SpecVersion = VK_KHR_SPIRV_1_4_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSpirv14ExtensionName = VK_KHR_SPIRV_1_4_EXTENSION_NAME; + + //=== VK_EXT_memory_budget === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryBudgetSpecVersion = VK_EXT_MEMORY_BUDGET_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryBudgetExtensionName = VK_EXT_MEMORY_BUDGET_EXTENSION_NAME; + + //=== VK_EXT_memory_priority === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryPrioritySpecVersion = VK_EXT_MEMORY_PRIORITY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryPriorityExtensionName = VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME; + + //=== VK_KHR_surface_protected_capabilities === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceProtectedCapabilitiesSpecVersion = VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceProtectedCapabilitiesExtensionName = VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME; + + //=== VK_NV_dedicated_allocation_image_aliasing === + VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationImageAliasingSpecVersion = VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationImageAliasingExtensionName = VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME; + + //=== VK_KHR_separate_depth_stencil_layouts === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSeparateDepthStencilLayoutsSpecVersion = VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSeparateDepthStencilLayoutsExtensionName = VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME; + + //=== VK_EXT_buffer_device_address === + VULKAN_HPP_DEPRECATED( "The VK_EXT_buffer_device_address extension has been deprecated by VK_KHR_buffer_device_address." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTBufferDeviceAddressSpecVersion = VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_EXT_buffer_device_address extension has been deprecated by VK_KHR_buffer_device_address." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTBufferDeviceAddressExtensionName = VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME; + + //=== VK_EXT_tooling_info === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTToolingInfoSpecVersion = VK_EXT_TOOLING_INFO_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTToolingInfoExtensionName = VK_EXT_TOOLING_INFO_EXTENSION_NAME; + + //=== VK_EXT_separate_stencil_usage === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSeparateStencilUsageSpecVersion = VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSeparateStencilUsageExtensionName = VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME; + + //=== VK_EXT_validation_features === + VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_features extension has been deprecated by VK_EXT_layer_settings." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFeaturesSpecVersion = VK_EXT_VALIDATION_FEATURES_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_features extension has been deprecated by VK_EXT_layer_settings." ) + VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFeaturesExtensionName = VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME; + + //=== VK_KHR_present_wait === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWaitSpecVersion = VK_KHR_PRESENT_WAIT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWaitExtensionName = VK_KHR_PRESENT_WAIT_EXTENSION_NAME; + + //=== VK_NV_cooperative_matrix === + VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixSpecVersion = VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixExtensionName = VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME; + + //=== VK_NV_coverage_reduction_mode === + VULKAN_HPP_CONSTEXPR_INLINE auto NVCoverageReductionModeSpecVersion = VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVCoverageReductionModeExtensionName = VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME; + + //=== VK_EXT_fragment_shader_interlock === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentShaderInterlockSpecVersion = VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentShaderInterlockExtensionName = VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME; + + //=== VK_EXT_ycbcr_image_arrays === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcrImageArraysSpecVersion = VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcrImageArraysExtensionName = VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME; + + //=== VK_KHR_uniform_buffer_standard_layout === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRUniformBufferStandardLayoutSpecVersion = VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRUniformBufferStandardLayoutExtensionName = VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME; + + //=== VK_EXT_provoking_vertex === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTProvokingVertexSpecVersion = VK_EXT_PROVOKING_VERTEX_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTProvokingVertexExtensionName = VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFullScreenExclusiveSpecVersion = VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFullScreenExclusiveExtensionName = VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTHeadlessSurfaceSpecVersion = VK_EXT_HEADLESS_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTHeadlessSurfaceExtensionName = VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME; + + //=== VK_KHR_buffer_device_address === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRBufferDeviceAddressSpecVersion = VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRBufferDeviceAddressExtensionName = VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME; + + //=== VK_EXT_line_rasterization === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationSpecVersion = VK_EXT_LINE_RASTERIZATION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationExtensionName = VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME; + + //=== VK_EXT_shader_atomic_float === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatSpecVersion = VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME; + + //=== VK_EXT_host_query_reset === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostQueryResetSpecVersion = VK_EXT_HOST_QUERY_RESET_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostQueryResetExtensionName = VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME; + + //=== VK_EXT_index_type_uint8 === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8SpecVersion = VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8ExtensionName = VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME; + + //=== VK_EXT_extended_dynamic_state === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicStateSpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicStateExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME; + + //=== VK_KHR_deferred_host_operations === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeferredHostOperationsSpecVersion = VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeferredHostOperationsExtensionName = VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME; + + //=== VK_KHR_pipeline_executable_properties === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineExecutablePropertiesSpecVersion = VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineExecutablePropertiesExtensionName = VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME; + + //=== VK_EXT_host_image_copy === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostImageCopySpecVersion = VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostImageCopyExtensionName = VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME; + + //=== VK_KHR_map_memory2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMapMemory2SpecVersion = VK_KHR_MAP_MEMORY_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMapMemory2ExtensionName = VK_KHR_MAP_MEMORY_2_EXTENSION_NAME; + + //=== VK_EXT_map_memory_placed === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMapMemoryPlacedSpecVersion = VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMapMemoryPlacedExtensionName = VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME; + + //=== VK_EXT_shader_atomic_float2 === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloat2SpecVersion = VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloat2ExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME; + + //=== VK_EXT_surface_maintenance1 === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSurfaceMaintenance1SpecVersion = VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSurfaceMaintenance1ExtensionName = VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME; + + //=== VK_EXT_swapchain_maintenance1 === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainMaintenance1SpecVersion = VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainMaintenance1ExtensionName = VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME; + + //=== VK_EXT_shader_demote_to_helper_invocation === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderDemoteToHelperInvocationSpecVersion = VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderDemoteToHelperInvocationExtensionName = VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME; + + //=== VK_NV_device_generated_commands === + VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsSpecVersion = VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsExtensionName = VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME; + + //=== VK_NV_inherited_viewport_scissor === + VULKAN_HPP_CONSTEXPR_INLINE auto NVInheritedViewportScissorSpecVersion = VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVInheritedViewportScissorExtensionName = VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME; + + //=== VK_KHR_shader_integer_dot_product === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderIntegerDotProductSpecVersion = VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderIntegerDotProductExtensionName = VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME; + + //=== VK_EXT_texel_buffer_alignment === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTTexelBufferAlignmentSpecVersion = VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTTexelBufferAlignmentExtensionName = VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME; + + //=== VK_QCOM_render_pass_transform === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassTransformSpecVersion = VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassTransformExtensionName = VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME; + + //=== VK_EXT_depth_bias_control === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthBiasControlSpecVersion = VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthBiasControlExtensionName = VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME; + + //=== VK_EXT_device_memory_report === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceMemoryReportSpecVersion = VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceMemoryReportExtensionName = VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME; + + //=== VK_EXT_acquire_drm_display === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireDrmDisplaySpecVersion = VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireDrmDisplayExtensionName = VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME; + + //=== VK_EXT_robustness2 === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTRobustness2SpecVersion = VK_EXT_ROBUSTNESS_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTRobustness2ExtensionName = VK_EXT_ROBUSTNESS_2_EXTENSION_NAME; + + //=== VK_EXT_custom_border_color === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorSpecVersion = VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorExtensionName = VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME; + + //=== VK_EXT_texture_compression_astc_3d === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstc3DSpecVersion = VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstc3DExtensionName = VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME; + + //=== VK_GOOGLE_user_type === + VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEUserTypeSpecVersion = VK_GOOGLE_USER_TYPE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEUserTypeExtensionName = VK_GOOGLE_USER_TYPE_EXTENSION_NAME; + + //=== VK_KHR_pipeline_library === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineLibrarySpecVersion = VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineLibraryExtensionName = VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME; + + //=== VK_NV_present_barrier === + VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentBarrierSpecVersion = VK_NV_PRESENT_BARRIER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentBarrierExtensionName = VK_NV_PRESENT_BARRIER_EXTENSION_NAME; + + //=== VK_KHR_shader_non_semantic_info === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderNonSemanticInfoSpecVersion = VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderNonSemanticInfoExtensionName = VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME; + + //=== VK_KHR_present_id === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentIdSpecVersion = VK_KHR_PRESENT_ID_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentIdExtensionName = VK_KHR_PRESENT_ID_EXTENSION_NAME; + + //=== VK_EXT_private_data === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrivateDataSpecVersion = VK_EXT_PRIVATE_DATA_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrivateDataExtensionName = VK_EXT_PRIVATE_DATA_EXTENSION_NAME; + + //=== VK_EXT_pipeline_creation_cache_control === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationCacheControlSpecVersion = VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationCacheControlExtensionName = VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME; + + //=== VK_KHR_video_encode_queue === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQueueSpecVersion = VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQueueExtensionName = VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME; + + //=== VK_NV_device_diagnostics_config === + VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticsConfigSpecVersion = VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticsConfigExtensionName = VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME; + + //=== VK_QCOM_render_pass_store_ops === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassStoreOpsSpecVersion = VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassStoreOpsExtensionName = VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchSpecVersion = VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchExtensionName = VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingSpecVersion = VK_QCOM_TILE_SHADING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingExtensionName = VK_QCOM_TILE_SHADING_EXTENSION_NAME; + + //=== VK_NV_low_latency === + VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencySpecVersion = VK_NV_LOW_LATENCY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencyExtensionName = VK_NV_LOW_LATENCY_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalObjectsSpecVersion = VK_EXT_METAL_OBJECTS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalObjectsExtensionName = VK_EXT_METAL_OBJECTS_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSynchronization2SpecVersion = VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSynchronization2ExtensionName = VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME; + + //=== VK_EXT_descriptor_buffer === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferSpecVersion = VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferExtensionName = VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME; + + //=== VK_EXT_graphics_pipeline_library === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTGraphicsPipelineLibrarySpecVersion = VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTGraphicsPipelineLibraryExtensionName = VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME; + + //=== VK_AMD_shader_early_and_late_fragment_tests === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderEarlyAndLateFragmentTestsSpecVersion = VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderEarlyAndLateFragmentTestsExtensionName = VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME; + + //=== VK_KHR_fragment_shader_barycentric === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShaderBarycentricSpecVersion = VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShaderBarycentricExtensionName = VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME; + + //=== VK_KHR_shader_subgroup_uniform_control_flow === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupUniformControlFlowSpecVersion = VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupUniformControlFlowExtensionName = VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME; + + //=== VK_KHR_zero_initialize_workgroup_memory === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRZeroInitializeWorkgroupMemorySpecVersion = VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRZeroInitializeWorkgroupMemoryExtensionName = VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME; + + //=== VK_NV_fragment_shading_rate_enums === + VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShadingRateEnumsSpecVersion = VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShadingRateEnumsExtensionName = VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME; + + //=== VK_NV_ray_tracing_motion_blur === + VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingMotionBlurSpecVersion = VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingMotionBlurExtensionName = VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME; + + //=== VK_EXT_mesh_shader === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMeshShaderSpecVersion = VK_EXT_MESH_SHADER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMeshShaderExtensionName = VK_EXT_MESH_SHADER_EXTENSION_NAME; + + //=== VK_EXT_ycbcr_2plane_444_formats === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcr2Plane444FormatsSpecVersion = VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcr2Plane444FormatsExtensionName = VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME; + + //=== VK_EXT_fragment_density_map2 === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMap2SpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMap2ExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME; + + //=== VK_QCOM_rotated_copy_commands === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRotatedCopyCommandsSpecVersion = VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRotatedCopyCommandsExtensionName = VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME; + + //=== VK_EXT_image_robustness === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageRobustnessSpecVersion = VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageRobustnessExtensionName = VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME; + + //=== VK_KHR_workgroup_memory_explicit_layout === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRWorkgroupMemoryExplicitLayoutSpecVersion = VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRWorkgroupMemoryExplicitLayoutExtensionName = VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME; + + //=== VK_KHR_copy_commands2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyCommands2SpecVersion = VK_KHR_COPY_COMMANDS_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyCommands2ExtensionName = VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME; + + //=== VK_EXT_image_compression_control === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSpecVersion = VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlExtensionName = VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME; + + //=== VK_EXT_attachment_feedback_loop_layout === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopLayoutSpecVersion = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopLayoutExtensionName = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME; + + //=== VK_EXT_4444_formats === + VULKAN_HPP_CONSTEXPR_INLINE auto EXT4444FormatsSpecVersion = VK_EXT_4444_FORMATS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXT4444FormatsExtensionName = VK_EXT_4444_FORMATS_EXTENSION_NAME; + + //=== VK_EXT_device_fault === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceFaultSpecVersion = VK_EXT_DEVICE_FAULT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceFaultExtensionName = VK_EXT_DEVICE_FAULT_EXTENSION_NAME; + + //=== VK_ARM_rasterization_order_attachment_access === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMRasterizationOrderAttachmentAccessSpecVersion = VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMRasterizationOrderAttachmentAccessExtensionName = VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME; + + //=== VK_EXT_rgba10x6_formats === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTRgba10X6FormatsSpecVersion = VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTRgba10X6FormatsExtensionName = VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + VULKAN_HPP_CONSTEXPR_INLINE auto NVAcquireWinrtDisplaySpecVersion = VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVAcquireWinrtDisplayExtensionName = VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectfbSurfaceSpecVersion = VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectfbSurfaceExtensionName = VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_VALVE_mutable_descriptor_type === + VULKAN_HPP_CONSTEXPR_INLINE auto VALVEMutableDescriptorTypeSpecVersion = VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto VALVEMutableDescriptorTypeExtensionName = VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME; + + //=== VK_EXT_vertex_input_dynamic_state === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateSpecVersion = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateExtensionName = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME; + + //=== VK_EXT_physical_device_drm === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPhysicalDeviceDrmSpecVersion = VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPhysicalDeviceDrmExtensionName = VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME; + + //=== VK_EXT_device_address_binding_report === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceAddressBindingReportSpecVersion = VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceAddressBindingReportExtensionName = VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME; + + //=== VK_EXT_depth_clip_control === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipControlSpecVersion = VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipControlExtensionName = VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME; + + //=== VK_EXT_primitive_topology_list_restart === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitiveTopologyListRestartSpecVersion = VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitiveTopologyListRestartExtensionName = VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME; + + //=== VK_KHR_format_feature_flags2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRFormatFeatureFlags2SpecVersion = VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRFormatFeatureFlags2ExtensionName = VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME; + + //=== VK_EXT_present_mode_fifo_latest_ready === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentModeFifoLatestReadySpecVersion = VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentModeFifoLatestReadyExtensionName = VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalMemorySpecVersion = VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalMemoryExtensionName = VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalSemaphoreSpecVersion = VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalSemaphoreExtensionName = VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIABufferCollectionSpecVersion = VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIABufferCollectionExtensionName = VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEISubpassShadingSpecVersion = VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEISubpassShadingExtensionName = VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME; + + //=== VK_HUAWEI_invocation_mask === + VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIInvocationMaskSpecVersion = VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIInvocationMaskExtensionName = VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME; + + //=== VK_NV_external_memory_rdma === + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryRdmaSpecVersion = VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryRdmaExtensionName = VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME; + + //=== VK_EXT_pipeline_properties === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelinePropertiesSpecVersion = VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelinePropertiesExtensionName = VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME; + + //=== VK_EXT_frame_boundary === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFrameBoundarySpecVersion = VK_EXT_FRAME_BOUNDARY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFrameBoundaryExtensionName = VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME; + + //=== VK_EXT_multisampled_render_to_single_sampled === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultisampledRenderToSingleSampledSpecVersion = VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultisampledRenderToSingleSampledExtensionName = VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME; + + //=== VK_EXT_extended_dynamic_state2 === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState2SpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState2ExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto QNXScreenSurfaceSpecVersion = VK_QNX_SCREEN_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QNXScreenSurfaceExtensionName = VK_QNX_SCREEN_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_color_write_enable === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTColorWriteEnableSpecVersion = VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTColorWriteEnableExtensionName = VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME; + + //=== VK_EXT_primitives_generated_query === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitivesGeneratedQuerySpecVersion = VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitivesGeneratedQueryExtensionName = VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME; + + //=== VK_KHR_ray_tracing_maintenance1 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingMaintenance1SpecVersion = VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingMaintenance1ExtensionName = VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME; + + //=== VK_KHR_shader_untyped_pointers === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderUntypedPointersSpecVersion = VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderUntypedPointersExtensionName = VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME; + + //=== VK_EXT_global_priority_query === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQuerySpecVersion = VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQueryExtensionName = VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME; + + //=== VK_VALVE_video_encode_rgb_conversion === + VULKAN_HPP_CONSTEXPR_INLINE auto VALVEVideoEncodeRgbConversionSpecVersion = VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto VALVEVideoEncodeRgbConversionExtensionName = VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME; + + //=== VK_EXT_image_view_min_lod === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodSpecVersion = VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodExtensionName = VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME; + + //=== VK_EXT_multi_draw === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultiDrawSpecVersion = VK_EXT_MULTI_DRAW_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultiDrawExtensionName = VK_EXT_MULTI_DRAW_EXTENSION_NAME; + + //=== VK_EXT_image_2d_view_of_3d === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImage2DViewOf3DSpecVersion = VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImage2DViewOf3DExtensionName = VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME; + + //=== VK_KHR_portability_enumeration === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilityEnumerationSpecVersion = VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilityEnumerationExtensionName = VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME; + + //=== VK_EXT_shader_tile_image === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderTileImageSpecVersion = VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderTileImageExtensionName = VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME; + + //=== VK_EXT_opacity_micromap === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTOpacityMicromapSpecVersion = VK_EXT_OPACITY_MICROMAP_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTOpacityMicromapExtensionName = VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_displacement_micromap === + VULKAN_HPP_DEPRECATED( "The VK_NV_displacement_micromap extension has been deprecated by VK_NV_cluster_acceleration_structure." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapSpecVersion = VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION; + VULKAN_HPP_DEPRECATED( "The VK_NV_displacement_micromap extension has been deprecated by VK_NV_cluster_acceleration_structure." ) + VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapExtensionName = VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_load_store_op_none === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLoadStoreOpNoneSpecVersion = VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLoadStoreOpNoneExtensionName = VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME; + + //=== VK_HUAWEI_cluster_culling_shader === + VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIClusterCullingShaderSpecVersion = VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIClusterCullingShaderExtensionName = VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME; + + //=== VK_EXT_border_color_swizzle === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTBorderColorSwizzleSpecVersion = VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTBorderColorSwizzleExtensionName = VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME; + + //=== VK_EXT_pageable_device_local_memory === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPageableDeviceLocalMemorySpecVersion = VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPageableDeviceLocalMemoryExtensionName = VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME; + + //=== VK_KHR_maintenance4 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance4SpecVersion = VK_KHR_MAINTENANCE_4_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance4ExtensionName = VK_KHR_MAINTENANCE_4_EXTENSION_NAME; + + //=== VK_ARM_shader_core_properties === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCorePropertiesSpecVersion = VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCorePropertiesExtensionName = VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME; + + //=== VK_KHR_shader_subgroup_rotate === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupRotateSpecVersion = VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupRotateExtensionName = VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME; + + //=== VK_ARM_scheduling_controls === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMSchedulingControlsSpecVersion = VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMSchedulingControlsExtensionName = VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME; + + //=== VK_EXT_image_sliced_view_of_3d === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageSlicedViewOf3DSpecVersion = VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageSlicedViewOf3DExtensionName = VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME; + + //=== VK_VALVE_descriptor_set_host_mapping === + VULKAN_HPP_CONSTEXPR_INLINE auto VALVEDescriptorSetHostMappingSpecVersion = VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto VALVEDescriptorSetHostMappingExtensionName = VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME; + + //=== VK_EXT_depth_clamp_zero_one === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampZeroOneSpecVersion = VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampZeroOneExtensionName = VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME; + + //=== VK_EXT_non_seamless_cube_map === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTNonSeamlessCubeMapSpecVersion = VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTNonSeamlessCubeMapExtensionName = VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME; + + //=== VK_ARM_render_pass_striped === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMRenderPassStripedSpecVersion = VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMRenderPassStripedExtensionName = VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME; + + //=== VK_QCOM_fragment_density_map_offset === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFragmentDensityMapOffsetSpecVersion = VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFragmentDensityMapOffsetExtensionName = VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME; + + //=== VK_NV_copy_memory_indirect === + VULKAN_HPP_CONSTEXPR_INLINE auto NVCopyMemoryIndirectSpecVersion = VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVCopyMemoryIndirectExtensionName = VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME; + + //=== VK_NV_memory_decompression === + VULKAN_HPP_CONSTEXPR_INLINE auto NVMemoryDecompressionSpecVersion = VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVMemoryDecompressionExtensionName = VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME; + + //=== VK_NV_device_generated_commands_compute === + VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsComputeSpecVersion = VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsComputeExtensionName = VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME; + + //=== VK_NV_ray_tracing_linear_swept_spheres === + VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingLinearSweptSpheresSpecVersion = VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingLinearSweptSpheresExtensionName = VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_EXTENSION_NAME; + + //=== VK_NV_linear_color_attachment === + VULKAN_HPP_CONSTEXPR_INLINE auto NVLinearColorAttachmentSpecVersion = VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVLinearColorAttachmentExtensionName = VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME; + + //=== VK_GOOGLE_surfaceless_query === + VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLESurfacelessQuerySpecVersion = VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLESurfacelessQueryExtensionName = VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME; + + //=== VK_KHR_shader_maximal_reconvergence === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderMaximalReconvergenceSpecVersion = VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderMaximalReconvergenceExtensionName = VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME; + + //=== VK_EXT_image_compression_control_swapchain === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSwapchainSpecVersion = VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSwapchainExtensionName = VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME; + + //=== VK_QCOM_image_processing === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessingSpecVersion = VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessingExtensionName = VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME; + + //=== VK_EXT_nested_command_buffer === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTNestedCommandBufferSpecVersion = VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTNestedCommandBufferExtensionName = VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + VULKAN_HPP_CONSTEXPR_INLINE auto OHOSExternalMemorySpecVersion = VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto OHOSExternalMemoryExtensionName = VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_external_memory_acquire_unmodified === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryAcquireUnmodifiedSpecVersion = VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryAcquireUnmodifiedExtensionName = VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME; + + //=== VK_EXT_extended_dynamic_state3 === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState3SpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState3ExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME; + + //=== VK_EXT_subpass_merge_feedback === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubpassMergeFeedbackSpecVersion = VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubpassMergeFeedbackExtensionName = VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME; + + //=== VK_LUNARG_direct_driver_loading === + VULKAN_HPP_CONSTEXPR_INLINE auto LUNARGDirectDriverLoadingSpecVersion = VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto LUNARGDirectDriverLoadingExtensionName = VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME; + + //=== VK_ARM_tensors === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMTensorsSpecVersion = VK_ARM_TENSORS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMTensorsExtensionName = VK_ARM_TENSORS_EXTENSION_NAME; + + //=== VK_EXT_shader_module_identifier === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderModuleIdentifierSpecVersion = VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderModuleIdentifierExtensionName = VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME; + + //=== VK_EXT_rasterization_order_attachment_access === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTRasterizationOrderAttachmentAccessSpecVersion = VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTRasterizationOrderAttachmentAccessExtensionName = VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME; + + //=== VK_NV_optical_flow === + VULKAN_HPP_CONSTEXPR_INLINE auto NVOpticalFlowSpecVersion = VK_NV_OPTICAL_FLOW_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVOpticalFlowExtensionName = VK_NV_OPTICAL_FLOW_EXTENSION_NAME; + + //=== VK_EXT_legacy_dithering === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyDitheringSpecVersion = VK_EXT_LEGACY_DITHERING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyDitheringExtensionName = VK_EXT_LEGACY_DITHERING_EXTENSION_NAME; + + //=== VK_EXT_pipeline_protected_access === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineProtectedAccessSpecVersion = VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineProtectedAccessExtensionName = VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_format_resolve === + VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalFormatResolveSpecVersion = VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalFormatResolveExtensionName = VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + //=== VK_KHR_maintenance5 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance5SpecVersion = VK_KHR_MAINTENANCE_5_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance5ExtensionName = VK_KHR_MAINTENANCE_5_EXTENSION_NAME; + + //=== VK_AMD_anti_lag === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagSpecVersion = VK_AMD_ANTI_LAG_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagExtensionName = VK_AMD_ANTI_LAG_EXTENSION_NAME; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_dense_geometry_format === + VULKAN_HPP_CONSTEXPR_INLINE auto AMDXDenseGeometryFormatSpecVersion = VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto AMDXDenseGeometryFormatExtensionName = VK_AMDX_DENSE_GEOMETRY_FORMAT_EXTENSION_NAME; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_present_id2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentId2SpecVersion = VK_KHR_PRESENT_ID_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentId2ExtensionName = VK_KHR_PRESENT_ID_2_EXTENSION_NAME; + + //=== VK_KHR_present_wait2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWait2SpecVersion = VK_KHR_PRESENT_WAIT_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWait2ExtensionName = VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME; + + //=== VK_KHR_ray_tracing_position_fetch === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPositionFetchSpecVersion = VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPositionFetchExtensionName = VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME; + + //=== VK_EXT_shader_object === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectSpecVersion = VK_EXT_SHADER_OBJECT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectExtensionName = VK_EXT_SHADER_OBJECT_EXTENSION_NAME; + + //=== VK_KHR_pipeline_binary === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineBinarySpecVersion = VK_KHR_PIPELINE_BINARY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineBinaryExtensionName = VK_KHR_PIPELINE_BINARY_EXTENSION_NAME; + + //=== VK_QCOM_tile_properties === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesSpecVersion = VK_QCOM_TILE_PROPERTIES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesExtensionName = VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME; + + //=== VK_SEC_amigo_profiling === + VULKAN_HPP_CONSTEXPR_INLINE auto SECAmigoProfilingSpecVersion = VK_SEC_AMIGO_PROFILING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto SECAmigoProfilingExtensionName = VK_SEC_AMIGO_PROFILING_EXTENSION_NAME; + + //=== VK_KHR_surface_maintenance1 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceMaintenance1SpecVersion = VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceMaintenance1ExtensionName = VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME; + + //=== VK_KHR_swapchain_maintenance1 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMaintenance1SpecVersion = VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMaintenance1ExtensionName = VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME; + + //=== VK_QCOM_multiview_per_view_viewports === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewViewportsSpecVersion = VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewViewportsExtensionName = VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME; + + //=== VK_NV_ray_tracing_invocation_reorder === + VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingInvocationReorderSpecVersion = VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingInvocationReorderExtensionName = VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME; + + //=== VK_NV_cooperative_vector === + VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeVectorSpecVersion = VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeVectorExtensionName = VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME; + + //=== VK_NV_extended_sparse_address_space === + VULKAN_HPP_CONSTEXPR_INLINE auto NVExtendedSparseAddressSpaceSpecVersion = VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVExtendedSparseAddressSpaceExtensionName = VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME; + + //=== VK_EXT_mutable_descriptor_type === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMutableDescriptorTypeSpecVersion = VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMutableDescriptorTypeExtensionName = VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME; + + //=== VK_EXT_legacy_vertex_attributes === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyVertexAttributesSpecVersion = VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyVertexAttributesExtensionName = VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME; + + //=== VK_EXT_layer_settings === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLayerSettingsSpecVersion = VK_EXT_LAYER_SETTINGS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTLayerSettingsExtensionName = VK_EXT_LAYER_SETTINGS_EXTENSION_NAME; + + //=== VK_ARM_shader_core_builtins === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCoreBuiltinsSpecVersion = VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCoreBuiltinsExtensionName = VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME; + + //=== VK_EXT_pipeline_library_group_handles === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineLibraryGroupHandlesSpecVersion = VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineLibraryGroupHandlesExtensionName = VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME; + + //=== VK_EXT_dynamic_rendering_unused_attachments === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDynamicRenderingUnusedAttachmentsSpecVersion = VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDynamicRenderingUnusedAttachmentsExtensionName = VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME; + + //=== VK_KHR_internally_synchronized_queues === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRInternallySynchronizedQueuesSpecVersion = VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRInternallySynchronizedQueuesExtensionName = VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME; + + //=== VK_NV_low_latency2 === + VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatency2SpecVersion = VK_NV_LOW_LATENCY_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatency2ExtensionName = VK_NV_LOW_LATENCY_2_EXTENSION_NAME; + + //=== VK_KHR_cooperative_matrix === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRCooperativeMatrixSpecVersion = VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRCooperativeMatrixExtensionName = VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME; + + //=== VK_ARM_data_graph === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphSpecVersion = VK_ARM_DATA_GRAPH_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphExtensionName = VK_ARM_DATA_GRAPH_EXTENSION_NAME; + + //=== VK_QCOM_multiview_per_view_render_areas === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasSpecVersion = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasExtensionName = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME; + + //=== VK_KHR_compute_shader_derivatives === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRComputeShaderDerivativesSpecVersion = VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRComputeShaderDerivativesExtensionName = VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME; + + //=== VK_KHR_video_decode_av1 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1SpecVersion = VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1ExtensionName = VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME; + + //=== VK_KHR_video_encode_av1 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeAv1SpecVersion = VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeAv1ExtensionName = VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME; + + //=== VK_KHR_video_decode_vp9 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeVp9SpecVersion = VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeVp9ExtensionName = VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME; + + //=== VK_KHR_video_maintenance1 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1SpecVersion = VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1ExtensionName = VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME; + + //=== VK_NV_per_stage_descriptor_set === + VULKAN_HPP_CONSTEXPR_INLINE auto NVPerStageDescriptorSetSpecVersion = VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVPerStageDescriptorSetExtensionName = VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME; + + //=== VK_QCOM_image_processing2 === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessing2SpecVersion = VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessing2ExtensionName = VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME; + + //=== VK_QCOM_filter_cubic_weights === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicWeightsSpecVersion = VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicWeightsExtensionName = VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME; + + //=== VK_QCOM_ycbcr_degamma === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMYcbcrDegammaSpecVersion = VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMYcbcrDegammaExtensionName = VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME; + + //=== VK_QCOM_filter_cubic_clamp === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicClampSpecVersion = VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicClampExtensionName = VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME; + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopDynamicStateSpecVersion = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopDynamicStateExtensionName = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME; + + //=== VK_KHR_vertex_attribute_divisor === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorSpecVersion = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorExtensionName = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME; + + //=== VK_KHR_load_store_op_none === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneSpecVersion = VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneExtensionName = VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME; + + //=== VK_KHR_unified_image_layouts === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRUnifiedImageLayoutsSpecVersion = VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRUnifiedImageLayoutsExtensionName = VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME; + + //=== VK_KHR_shader_float_controls2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2SpecVersion = VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2ExtensionName = VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferSpecVersion = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferExtensionName = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_MSFT_layered_driver === + VULKAN_HPP_CONSTEXPR_INLINE auto MSFTLayeredDriverSpecVersion = VK_MSFT_LAYERED_DRIVER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto MSFTLayeredDriverExtensionName = VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME; + + //=== VK_KHR_index_type_uint8 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8SpecVersion = VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8ExtensionName = VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME; + + //=== VK_KHR_line_rasterization === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationSpecVersion = VK_KHR_LINE_RASTERIZATION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationExtensionName = VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME; + + //=== VK_KHR_calibrated_timestamps === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsSpecVersion = VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsExtensionName = VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME; + + //=== VK_KHR_shader_expect_assume === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderExpectAssumeSpecVersion = VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderExpectAssumeExtensionName = VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME; + + //=== VK_KHR_maintenance6 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance6SpecVersion = VK_KHR_MAINTENANCE_6_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance6ExtensionName = VK_KHR_MAINTENANCE_6_EXTENSION_NAME; + + //=== VK_NV_descriptor_pool_overallocation === + VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationSpecVersion = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationExtensionName = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME; + + //=== VK_QCOM_tile_memory_heap === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapSpecVersion = VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapExtensionName = VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME; + + //=== VK_KHR_copy_memory_indirect === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyMemoryIndirectSpecVersion = VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyMemoryIndirectExtensionName = VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME; + + //=== VK_EXT_memory_decompression === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryDecompressionSpecVersion = VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryDecompressionExtensionName = VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME; + + //=== VK_NV_display_stereo === + VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoSpecVersion = VK_NV_DISPLAY_STEREO_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoExtensionName = VK_NV_DISPLAY_STEREO_EXTENSION_NAME; + + //=== VK_KHR_video_encode_intra_refresh === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeIntraRefreshSpecVersion = VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeIntraRefreshExtensionName = VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME; + + //=== VK_KHR_video_encode_quantization_map === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQuantizationMapSpecVersion = VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQuantizationMapExtensionName = VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME; + + //=== VK_NV_raw_access_chains === + VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsSpecVersion = VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsExtensionName = VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME; + + //=== VK_NV_external_compute_queue === + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueSpecVersion = VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueExtensionName = VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME; + + //=== VK_KHR_shader_relaxed_extended_instruction === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionSpecVersion = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionExtensionName = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME; + + //=== VK_NV_command_buffer_inheritance === + VULKAN_HPP_CONSTEXPR_INLINE auto NVCommandBufferInheritanceSpecVersion = VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVCommandBufferInheritanceExtensionName = VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME; + + //=== VK_KHR_maintenance7 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7SpecVersion = VK_KHR_MAINTENANCE_7_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7ExtensionName = VK_KHR_MAINTENANCE_7_EXTENSION_NAME; + + //=== VK_NV_shader_atomic_float16_vector === + VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorSpecVersion = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorExtensionName = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME; + + //=== VK_EXT_shader_replicated_composites === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderReplicatedCompositesSpecVersion = VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderReplicatedCompositesExtensionName = VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME; + + //=== VK_EXT_shader_float8 === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderFloat8SpecVersion = VK_EXT_SHADER_FLOAT8_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderFloat8ExtensionName = VK_EXT_SHADER_FLOAT8_EXTENSION_NAME; + + //=== VK_NV_ray_tracing_validation === + VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationSpecVersion = VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationExtensionName = VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME; + + //=== VK_NV_cluster_acceleration_structure === + VULKAN_HPP_CONSTEXPR_INLINE auto NVClusterAccelerationStructureSpecVersion = VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVClusterAccelerationStructureExtensionName = VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME; + + //=== VK_NV_partitioned_acceleration_structure === + VULKAN_HPP_CONSTEXPR_INLINE auto NVPartitionedAccelerationStructureSpecVersion = VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVPartitionedAccelerationStructureExtensionName = VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME; + + //=== VK_EXT_device_generated_commands === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceGeneratedCommandsSpecVersion = VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceGeneratedCommandsExtensionName = VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME; + + //=== VK_KHR_maintenance8 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance8SpecVersion = VK_KHR_MAINTENANCE_8_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance8ExtensionName = VK_KHR_MAINTENANCE_8_EXTENSION_NAME; + + //=== VK_MESA_image_alignment_control === + VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlSpecVersion = VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlExtensionName = VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME; + + //=== VK_KHR_shader_fma === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaSpecVersion = VK_KHR_SHADER_FMA_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaExtensionName = VK_KHR_SHADER_FMA_EXTENSION_NAME; + + //=== VK_NV_push_constant_bank === + VULKAN_HPP_CONSTEXPR_INLINE auto NVPushConstantBankSpecVersion = VK_NV_PUSH_CONSTANT_BANK_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVPushConstantBankExtensionName = VK_NV_PUSH_CONSTANT_BANK_EXTENSION_NAME; + + //=== VK_EXT_ray_tracing_invocation_reorder === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTRayTracingInvocationReorderSpecVersion = VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTRayTracingInvocationReorderExtensionName = VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME; + + //=== VK_EXT_depth_clamp_control === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlSpecVersion = VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlExtensionName = VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME; + + //=== VK_KHR_maintenance9 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance9SpecVersion = VK_KHR_MAINTENANCE_9_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance9ExtensionName = VK_KHR_MAINTENANCE_9_EXTENSION_NAME; + + //=== VK_KHR_video_maintenance2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance2SpecVersion = VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance2ExtensionName = VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + VULKAN_HPP_CONSTEXPR_INLINE auto OHOSSurfaceSpecVersion = VK_OHOS_SURFACE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto OHOSSurfaceExtensionName = VK_OHOS_SURFACE_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_HUAWEI_hdr_vivid === + VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividSpecVersion = VK_HUAWEI_HDR_VIVID_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividExtensionName = VK_HUAWEI_HDR_VIVID_EXTENSION_NAME; + + //=== VK_NV_cooperative_matrix2 === + VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2SpecVersion = VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2ExtensionName = VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME; + + //=== VK_ARM_pipeline_opacity_micromap === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMPipelineOpacityMicromapSpecVersion = VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMPipelineOpacityMicromapExtensionName = VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryMetalSpecVersion = VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryMetalExtensionName = VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_depth_clamp_zero_one === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthClampZeroOneSpecVersion = VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthClampZeroOneExtensionName = VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME; + + //=== VK_ARM_performance_counters_by_region === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMPerformanceCountersByRegionSpecVersion = VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMPerformanceCountersByRegionExtensionName = VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_EXTENSION_NAME; + + //=== VK_EXT_vertex_attribute_robustness === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessExtensionName = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME; + + //=== VK_ARM_format_pack === + VULKAN_HPP_CONSTEXPR_INLINE auto ARMFormatPackSpecVersion = VK_ARM_FORMAT_PACK_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto ARMFormatPackExtensionName = VK_ARM_FORMAT_PACK_EXTENSION_NAME; + + //=== VK_VALVE_fragment_density_map_layered === + VULKAN_HPP_CONSTEXPR_INLINE auto VALVEFragmentDensityMapLayeredSpecVersion = VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto VALVEFragmentDensityMapLayeredExtensionName = VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME; + + //=== VK_KHR_robustness2 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2SpecVersion = VK_KHR_ROBUSTNESS_2_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2ExtensionName = VK_KHR_ROBUSTNESS_2_EXTENSION_NAME; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_present_metering === + VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringSpecVersion = VK_NV_PRESENT_METERING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringExtensionName = VK_NV_PRESENT_METERING_EXTENSION_NAME; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_fragment_density_map_offset === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetSpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME; + + //=== VK_EXT_zero_initialize_device_memory === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTZeroInitializeDeviceMemorySpecVersion = VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTZeroInitializeDeviceMemoryExtensionName = VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME; + + //=== VK_KHR_present_mode_fifo_latest_ready === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentModeFifoLatestReadySpecVersion = VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentModeFifoLatestReadyExtensionName = VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME; + + //=== VK_EXT_shader_64bit_indexing === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingSpecVersion = VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingExtensionName = VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME; + + //=== VK_EXT_custom_resolve === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomResolveSpecVersion = VK_EXT_CUSTOM_RESOLVE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomResolveExtensionName = VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME; + + //=== VK_QCOM_data_graph_model === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelSpecVersion = VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelExtensionName = VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME; + + //=== VK_KHR_maintenance10 === + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10SpecVersion = VK_KHR_MAINTENANCE_10_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10ExtensionName = VK_KHR_MAINTENANCE_10_EXTENSION_NAME; + + //=== VK_EXT_shader_long_vector === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderLongVectorSpecVersion = VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderLongVectorExtensionName = VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME; + + //=== VK_SEC_pipeline_cache_incremental_mode === + VULKAN_HPP_CONSTEXPR_INLINE auto SECPipelineCacheIncrementalModeSpecVersion = VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto SECPipelineCacheIncrementalModeExtensionName = VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME; + + //=== VK_EXT_shader_uniform_buffer_unsized_array === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderUniformBufferUnsizedArraySpecVersion = VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderUniformBufferUnsizedArrayExtensionName = VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME; + + //=== VK_NV_compute_occupancy_priority === + VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeOccupancyPrioritySpecVersion = VK_NV_COMPUTE_OCCUPANCY_PRIORITY_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeOccupancyPriorityExtensionName = VK_NV_COMPUTE_OCCUPANCY_PRIORITY_EXTENSION_NAME; + + //=== VK_EXT_shader_subgroup_partitioned === + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupPartitionedSpecVersion = VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION; + VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupPartitionedExtensionName = VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME; + +} // namespace VULKAN_HPP_NAMESPACE + +// clang-format off +#include +#include +#include +// clang-format on + +namespace VULKAN_HPP_NAMESPACE +{ +#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + + //======================= + //=== STRUCTS EXTENDS === + //======================= + + //=== VK_VERSION_1_0 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_VERSION_1_1 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_VERSION_1_2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_VERSION_1_3 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_VERSION_1_4 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_swapchain === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_display_swapchain === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_debug_report === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_AMD_rasterization_order === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_queue === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_decode_queue === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_dedicated_allocation === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_transform_feedback === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NVX_binary_import === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_encode_h264 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_encode_h265 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_decode_h264 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_AMD_texture_gather_bias_lod === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_corner_sampled_image === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_external_memory === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_win32_keyed_mutex === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_validation_flags === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_astc_decode_mode === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_keyed_mutex === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_conditional_rendering === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_incremental_present === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_clip_space_w_scaling === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_display_control === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_GOOGLE_display_timing === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NVX_multiview_per_view_attributes === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_viewport_swizzle === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_discard_rectangles === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_conservative_rasterization === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_depth_clip_enable === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_IMG_relaxed_line_rasterization === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_shared_presentable_image === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_performance_query === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_debug_utils === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_AMD_mixed_attachment_samples === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_shader_bfloat16 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_sample_locations === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_blend_operation_advanced === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_fragment_coverage_to_color === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_acceleration_structure === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_ray_tracing_pipeline === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_ray_query === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_framebuffer_mixed_samples === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_shader_sm_builtins === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_image_drm_format_modifier === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_validation_cache === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_portability_subset === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NV_shading_rate_image === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_ray_tracing === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_representative_fragment_test === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_filter_cubic === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_external_memory_host === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_shader_clock === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_AMD_pipeline_compiler_control === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_AMD_shader_core_properties === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_decode_h265 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_AMD_memory_overallocation_behavior === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_vertex_attribute_divisor === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_frame_token === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_mesh_shader === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_shader_image_footprint === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_scissor_exclusive === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_device_diagnostic_checkpoints === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_present_timing === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_INTEL_shader_integer_functions2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_INTEL_performance_query === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_pci_bus_info === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_AMD_display_native_hdr === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_fragment_density_map === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_fragment_shading_rate === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_AMD_shader_core_properties2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_AMD_device_coherent_memory === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_image_atomic_int64 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_shader_quad_control === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_memory_budget === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_memory_priority === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_surface_protected_capabilities === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_dedicated_allocation_image_aliasing === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_buffer_device_address === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_validation_features === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_present_wait === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_cooperative_matrix === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_coverage_reduction_mode === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_fragment_shader_interlock === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_ycbcr_image_arrays === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_provoking_vertex === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_shader_atomic_float === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_extended_dynamic_state === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_pipeline_executable_properties === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_map_memory_placed === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_atomic_float2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_device_generated_commands === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_inherited_viewport_scissor === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_texel_buffer_alignment === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_render_pass_transform === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_depth_bias_control === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_device_memory_report === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_custom_border_color === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_texture_compression_astc_3d === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_pipeline_library === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_present_barrier === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_present_id === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_encode_queue === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_device_diagnostics_config === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_low_latency === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_descriptor_buffer === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_graphics_pipeline_library === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_AMD_shader_early_and_late_fragment_tests === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_fragment_shader_barycentric === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_shader_subgroup_uniform_control_flow === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_fragment_shading_rate_enums === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_ray_tracing_motion_blur === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_mesh_shader === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_ycbcr_2plane_444_formats === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_fragment_density_map2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_rotated_copy_commands === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_workgroup_memory_explicit_layout === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_image_compression_control === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_attachment_feedback_loop_layout === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_4444_formats === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_device_fault === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_rgba10x6_formats === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_vertex_input_dynamic_state === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_physical_device_drm === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_device_address_binding_report === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_depth_clip_control === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_primitive_topology_list_restart === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_HUAWEI_invocation_mask === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_external_memory_rdma === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_pipeline_properties === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_frame_boundary === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_multisampled_render_to_single_sampled === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_extended_dynamic_state2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_color_write_enable === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_primitives_generated_query === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_ray_tracing_maintenance1 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_shader_untyped_pointers === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_VALVE_video_encode_rgb_conversion === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_image_view_min_lod === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_multi_draw === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_image_2d_view_of_3d === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_tile_image === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_opacity_micromap === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_displacement_micromap === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_HUAWEI_cluster_culling_shader === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_border_color_swizzle === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_pageable_device_local_memory === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_ARM_shader_core_properties === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_ARM_scheduling_controls === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_image_sliced_view_of_3d === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_VALVE_descriptor_set_host_mapping === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_non_seamless_cube_map === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_ARM_render_pass_striped === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_copy_memory_indirect === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_device_generated_commands_compute === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_ray_tracing_linear_swept_spheres === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_linear_color_attachment === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_shader_maximal_reconvergence === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_image_compression_control_swapchain === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_image_processing === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_nested_command_buffer === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_external_memory_acquire_unmodified === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_extended_dynamic_state3 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_subpass_merge_feedback === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_LUNARG_direct_driver_loading === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_ARM_tensors === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_module_identifier === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_rasterization_order_attachment_access === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_optical_flow === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_legacy_dithering === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_format_resolve === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + //=== VK_AMD_anti_lag === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_dense_geometry_format === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_present_id2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_present_wait2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_ray_tracing_position_fetch === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_object === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_pipeline_binary === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_tile_properties === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_SEC_amigo_profiling === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_surface_maintenance1 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_swapchain_maintenance1 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_multiview_per_view_viewports === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_ray_tracing_invocation_reorder === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_cooperative_vector === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_extended_sparse_address_space === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_mutable_descriptor_type === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_legacy_vertex_attributes === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_layer_settings === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_ARM_shader_core_builtins === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_pipeline_library_group_handles === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_dynamic_rendering_unused_attachments === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_internally_synchronized_queues === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_low_latency2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_cooperative_matrix === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_ARM_data_graph === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_multiview_per_view_render_areas === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_compute_shader_derivatives === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_decode_av1 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_encode_av1 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_decode_vp9 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_maintenance1 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_per_stage_descriptor_set === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_image_processing2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_filter_cubic_weights === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_ycbcr_degamma === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_filter_cubic_clamp === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_unified_image_layouts === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_MSFT_layered_driver === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_descriptor_pool_overallocation === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_tile_memory_heap === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_copy_memory_indirect === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_memory_decompression === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_display_stereo === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_encode_intra_refresh === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_encode_quantization_map === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_raw_access_chains === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_external_compute_queue === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_shader_relaxed_extended_instruction === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_command_buffer_inheritance === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_maintenance7 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_shader_atomic_float16_vector === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_replicated_composites === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_float8 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_ray_tracing_validation === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_cluster_acceleration_structure === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_partitioned_acceleration_structure === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_device_generated_commands === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_maintenance8 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_MESA_image_alignment_control === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_shader_fma === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_push_constant_bank === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_ray_tracing_invocation_reorder === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_depth_clamp_control === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_maintenance9 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_video_maintenance2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_HUAWEI_hdr_vivid === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_cooperative_matrix2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_ARM_pipeline_opacity_micromap === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_depth_clamp_zero_one === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_ARM_performance_counters_by_region === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_vertex_attribute_robustness === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_ARM_format_pack === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_VALVE_fragment_density_map_layered === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_robustness2 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_present_metering === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_fragment_density_map_offset === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_zero_initialize_device_memory === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_present_mode_fifo_latest_ready === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_64bit_indexing === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_custom_resolve === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_QCOM_data_graph_model === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_KHR_maintenance10 === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_long_vector === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_SEC_pipeline_cache_incremental_mode === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_uniform_buffer_unsized_array === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_NV_compute_occupancy_priority === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + //=== VK_EXT_shader_subgroup_partitioned === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + +#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE + + namespace detail + { +#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL + class DynamicLoader + { + public: +# ifdef VULKAN_HPP_NO_EXCEPTIONS + DynamicLoader( std::string const & vulkanLibraryName = {} ) VULKAN_HPP_NOEXCEPT +# else + DynamicLoader( std::string const & vulkanLibraryName = {} ) +# endif + { + if ( !vulkanLibraryName.empty() ) + { +# if defined( _WIN32 ) + m_library = ::LoadLibraryA( vulkanLibraryName.c_str() ); +# elif defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) + m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL ); +# else +# error unsupported platform +# endif + } + else + { +# if defined( _WIN32 ) + m_library = ::LoadLibraryA( "vulkan-1.dll" ); +# elif defined( __APPLE__ ) + m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL ); + if ( !m_library ) + { + m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL ); + } + // modern versions of macOS don't search /usr/local/lib automatically contrary to what man dlopen says + // Vulkan SDK uses this as the system-wide installation location, so we're going to fallback to this if all else fails + if ( !m_library && ( std::getenv( "DYLD_FALLBACK_LIBRARY_PATH" ) == NULL ) ) + { + m_library = dlopen( "/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL ); + } + // for Homebrew installations on Apple Silicon + if ( !m_library ) + { + m_library = dlopen( "/opt/homebrew/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL ); + } + if ( !m_library ) + { + m_library = dlopen( "libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL ); + } + // Add support for using Vulkan and MoltenVK in a Framework. App store rules for iOS + // strictly enforce no .dylib's. If they aren't found it just falls through + if ( !m_library ) + { + m_library = dlopen( "vulkan.framework/vulkan", RTLD_NOW | RTLD_LOCAL ); + } + if ( !m_library ) + { + m_library = dlopen( "MoltenVK.framework/MoltenVK", RTLD_NOW | RTLD_LOCAL ); + } +# elif defined( __unix__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) + m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL ); + if ( !m_library ) + { + m_library = dlopen( "libvulkan.so.1", RTLD_NOW | RTLD_LOCAL ); + } +# else +# error unsupported platform +# endif + } + +# ifndef VULKAN_HPP_NO_EXCEPTIONS + if ( !m_library ) + { + // NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function. + throw std::runtime_error( "Failed to load vulkan library!" ); + } +# endif + } + + DynamicLoader( DynamicLoader const & ) = delete; + + DynamicLoader( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT : m_library( other.m_library ) + { + other.m_library = nullptr; + } + + DynamicLoader & operator=( DynamicLoader const & ) = delete; + + DynamicLoader & operator=( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_library, other.m_library ); + return *this; + } + + ~DynamicLoader() VULKAN_HPP_NOEXCEPT + { + if ( m_library ) + { +# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) + dlclose( m_library ); +# elif defined( _WIN32 ) + ::FreeLibrary( m_library ); +# else +# error unsupported platform +# endif + } + } + + template + T getProcAddress( const char * function ) const VULKAN_HPP_NOEXCEPT + { +# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) + return (T)(void *)dlsym( m_library, function ); +# elif defined( _WIN32 ) + return (T)(void *)::GetProcAddress( m_library, function ); +# else +# error unsupported platform +# endif + } + + bool success() const VULKAN_HPP_NOEXCEPT + { + return m_library != nullptr; + } + + private: +# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) + void * m_library; +# elif defined( _WIN32 ) + ::HINSTANCE m_library; +# else +# error unsupported platform +# endif + }; +#endif + + using PFN_dummy = void ( * )(); + + class DispatchLoaderDynamic : public DispatchLoaderBase + { + public: + //=== VK_VERSION_1_0 === + PFN_vkCreateInstance vkCreateInstance = 0; + PFN_vkDestroyInstance vkDestroyInstance = 0; + PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; + PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0; + PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; + PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0; + PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; + PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; + PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; + PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; + PFN_vkCreateDevice vkCreateDevice = 0; + PFN_vkDestroyDevice vkDestroyDevice = 0; + PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; + PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; + PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; + PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; + PFN_vkGetDeviceQueue vkGetDeviceQueue = 0; + PFN_vkQueueSubmit vkQueueSubmit = 0; + PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; + PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; + PFN_vkAllocateMemory vkAllocateMemory = 0; + PFN_vkFreeMemory vkFreeMemory = 0; + PFN_vkMapMemory vkMapMemory = 0; + PFN_vkUnmapMemory vkUnmapMemory = 0; + PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; + PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; + PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; + PFN_vkBindBufferMemory vkBindBufferMemory = 0; + PFN_vkBindImageMemory vkBindImageMemory = 0; + PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; + PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; + PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; + PFN_vkQueueBindSparse vkQueueBindSparse = 0; + PFN_vkCreateFence vkCreateFence = 0; + PFN_vkDestroyFence vkDestroyFence = 0; + PFN_vkResetFences vkResetFences = 0; + PFN_vkGetFenceStatus vkGetFenceStatus = 0; + PFN_vkWaitForFences vkWaitForFences = 0; + PFN_vkCreateSemaphore vkCreateSemaphore = 0; + PFN_vkDestroySemaphore vkDestroySemaphore = 0; + PFN_vkCreateQueryPool vkCreateQueryPool = 0; + PFN_vkDestroyQueryPool vkDestroyQueryPool = 0; + PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; + PFN_vkCreateBuffer vkCreateBuffer = 0; + PFN_vkDestroyBuffer vkDestroyBuffer = 0; + PFN_vkCreateImage vkCreateImage = 0; + PFN_vkDestroyImage vkDestroyImage = 0; + PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0; + PFN_vkCreateImageView vkCreateImageView = 0; + PFN_vkDestroyImageView vkDestroyImageView = 0; + PFN_vkCreateCommandPool vkCreateCommandPool = 0; + PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; + PFN_vkResetCommandPool vkResetCommandPool = 0; + PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; + PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; + PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; + PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; + PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; + PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; + PFN_vkCmdCopyImage vkCmdCopyImage = 0; + PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; + PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0; + PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; + PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; + PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; + PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; + PFN_vkCmdEndQuery vkCmdEndQuery = 0; + PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0; + PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; + PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; + PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; + PFN_vkCreateEvent vkCreateEvent = 0; + PFN_vkDestroyEvent vkDestroyEvent = 0; + PFN_vkGetEventStatus vkGetEventStatus = 0; + PFN_vkSetEvent vkSetEvent = 0; + PFN_vkResetEvent vkResetEvent = 0; + PFN_vkCreateBufferView vkCreateBufferView = 0; + PFN_vkDestroyBufferView vkDestroyBufferView = 0; + PFN_vkCreateShaderModule vkCreateShaderModule = 0; + PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; + PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; + PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0; + PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; + PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; + PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; + PFN_vkDestroyPipeline vkDestroyPipeline = 0; + PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; + PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; + PFN_vkCreateSampler vkCreateSampler = 0; + PFN_vkDestroySampler vkDestroySampler = 0; + PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; + PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; + PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; + PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; + PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; + PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; + PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; + PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; + PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; + PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; + PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; + PFN_vkCmdDispatch vkCmdDispatch = 0; + PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0; + PFN_vkCmdSetEvent vkCmdSetEvent = 0; + PFN_vkCmdResetEvent vkCmdResetEvent = 0; + PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; + PFN_vkCmdPushConstants vkCmdPushConstants = 0; + PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; + PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; + PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; + PFN_vkCreateRenderPass vkCreateRenderPass = 0; + PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; + PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; + PFN_vkCmdSetViewport vkCmdSetViewport = 0; + PFN_vkCmdSetScissor vkCmdSetScissor = 0; + PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; + PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; + PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0; + PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; + PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; + PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0; + PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0; + PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; + PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; + PFN_vkCmdDraw vkCmdDraw = 0; + PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; + PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0; + PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0; + PFN_vkCmdBlitImage vkCmdBlitImage = 0; + PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; + PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; + PFN_vkCmdResolveImage vkCmdResolveImage = 0; + PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; + PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; + PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; + + //=== VK_VERSION_1_1 === + PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; + PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; + PFN_vkBindImageMemory2 vkBindImageMemory2 = 0; + PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; + PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0; + PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; + PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0; + PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; + PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0; + PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0; + PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; + PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0; + PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; + PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; + PFN_vkTrimCommandPool vkTrimCommandPool = 0; + PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0; + PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0; + PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0; + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0; + PFN_vkCmdDispatchBase vkCmdDispatchBase = 0; + PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; + PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0; + PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; + PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0; + PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; + PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0; + + //=== VK_VERSION_1_2 === + PFN_vkResetQueryPool vkResetQueryPool = 0; + PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0; + PFN_vkWaitSemaphores vkWaitSemaphores = 0; + PFN_vkSignalSemaphore vkSignalSemaphore = 0; + PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0; + PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0; + PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0; + PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0; + PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0; + PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0; + PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0; + PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0; + PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0; + + //=== VK_VERSION_1_3 === + PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0; + PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0; + PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0; + PFN_vkSetPrivateData vkSetPrivateData = 0; + PFN_vkGetPrivateData vkGetPrivateData = 0; + PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0; + PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0; + PFN_vkQueueSubmit2 vkQueueSubmit2 = 0; + PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0; + PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0; + PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0; + PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0; + PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0; + PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0; + PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0; + PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0; + PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0; + PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0; + PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0; + PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0; + PFN_vkCmdBeginRendering vkCmdBeginRendering = 0; + PFN_vkCmdEndRendering vkCmdEndRendering = 0; + PFN_vkCmdSetCullMode vkCmdSetCullMode = 0; + PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0; + PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0; + PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0; + PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0; + PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0; + PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0; + PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0; + PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0; + PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0; + PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0; + PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0; + PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0; + PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0; + PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0; + + //=== VK_VERSION_1_4 === + PFN_vkMapMemory2 vkMapMemory2 = 0; + PFN_vkUnmapMemory2 vkUnmapMemory2 = 0; + PFN_vkGetDeviceImageSubresourceLayout vkGetDeviceImageSubresourceLayout = 0; + PFN_vkGetImageSubresourceLayout2 vkGetImageSubresourceLayout2 = 0; + PFN_vkCopyMemoryToImage vkCopyMemoryToImage = 0; + PFN_vkCopyImageToMemory vkCopyImageToMemory = 0; + PFN_vkCopyImageToImage vkCopyImageToImage = 0; + PFN_vkTransitionImageLayout vkTransitionImageLayout = 0; + PFN_vkCmdPushDescriptorSet vkCmdPushDescriptorSet = 0; + PFN_vkCmdPushDescriptorSetWithTemplate vkCmdPushDescriptorSetWithTemplate = 0; + PFN_vkCmdBindDescriptorSets2 vkCmdBindDescriptorSets2 = 0; + PFN_vkCmdPushConstants2 vkCmdPushConstants2 = 0; + PFN_vkCmdPushDescriptorSet2 vkCmdPushDescriptorSet2 = 0; + PFN_vkCmdPushDescriptorSetWithTemplate2 vkCmdPushDescriptorSetWithTemplate2 = 0; + PFN_vkCmdSetLineStipple vkCmdSetLineStipple = 0; + PFN_vkCmdBindIndexBuffer2 vkCmdBindIndexBuffer2 = 0; + PFN_vkGetRenderingAreaGranularity vkGetRenderingAreaGranularity = 0; + PFN_vkCmdSetRenderingAttachmentLocations vkCmdSetRenderingAttachmentLocations = 0; + PFN_vkCmdSetRenderingInputAttachmentIndices vkCmdSetRenderingInputAttachmentIndices = 0; + + //=== VK_KHR_surface === + PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; + PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; + PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; + + //=== VK_KHR_swapchain === + PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0; + PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; + PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; + PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; + PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; + PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; + PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; + PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; + PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; + + //=== VK_KHR_display === + PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0; + PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0; + PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; + PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; + PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; + PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; + PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; + + //=== VK_KHR_display_swapchain === + PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; + PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; +#else + PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; + PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; +#else + PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; + PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; +#else + PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; +#else + PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; + PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; +#else + PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; + PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; + PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; + + //=== VK_EXT_debug_marker === + PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; + PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; + PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; + PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; + PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; + + //=== VK_KHR_video_queue === + PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0; + PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0; + PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0; + PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0; + PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0; + PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0; + PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0; + PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0; + PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0; + PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0; + PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0; + PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0; + + //=== VK_KHR_video_decode_queue === + PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0; + + //=== VK_EXT_transform_feedback === + PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0; + PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0; + PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0; + PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0; + PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0; + PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0; + + //=== VK_NVX_binary_import === + PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0; + PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0; + PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0; + PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0; + PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0; + + //=== VK_NVX_image_view_handle === + PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0; + PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX = 0; + PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0; + PFN_vkGetDeviceCombinedImageSamplerIndexNVX vkGetDeviceCombinedImageSamplerIndexNVX = 0; + + //=== VK_AMD_draw_indirect_count === + PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; + PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0; + + //=== VK_AMD_shader_info === + PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0; + + //=== VK_KHR_dynamic_rendering === + PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0; + PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; +#else + PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; +#else + PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_get_physical_device_properties2 === + PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0; + PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; + PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0; + PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; + PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; + + //=== VK_KHR_device_group === + PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; + PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0; + PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0; + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; +#else + PFN_dummy vkCreateViSurfaceNN_placeholder = 0; +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_maintenance1 === + PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; + + //=== VK_KHR_device_group_creation === + PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; + + //=== VK_KHR_external_memory_capabilities === + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; + PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; +#else + PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0; + PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0; + + //=== VK_KHR_external_semaphore_capabilities === + PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; + PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; +#else + PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0; + PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; + + //=== VK_KHR_push_descriptor === + PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0; + PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0; + + //=== VK_EXT_conditional_rendering === + PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0; + PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0; + + //=== VK_KHR_descriptor_update_template === + PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; + PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0; + PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0; + + //=== VK_NV_clip_space_w_scaling === + PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; + + //=== VK_EXT_direct_mode_display === + PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; + +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; + PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; +#else + PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; + PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; + + //=== VK_EXT_display_control === + PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; + PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; + PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; + PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0; + + //=== VK_GOOGLE_display_timing === + PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; + PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; + + //=== VK_EXT_discard_rectangles === + PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; + PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT = 0; + PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT = 0; + + //=== VK_EXT_hdr_metadata === + PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; + + //=== VK_KHR_create_renderpass2 === + PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0; + PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0; + PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0; + PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0; + + //=== VK_KHR_shared_presentable_image === + PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; + + //=== VK_KHR_external_fence_capabilities === + PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; + PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; +#else + PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; + PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0; + + //=== VK_KHR_performance_query === + PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0; + PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; + PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; + PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0; + + //=== VK_KHR_get_surface_capabilities2 === + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; + PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; + + //=== VK_KHR_get_display_properties2 === + PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0; + PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0; + PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; + PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; +#else + PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; +#else + PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; + PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; + PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0; + PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; + PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; + PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; + PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; + PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; + PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; + PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; + PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; + PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; +#else + PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; + PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX = 0; + PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX = 0; + PFN_vkGetExecutionGraphPipelineNodeIndexAMDX vkGetExecutionGraphPipelineNodeIndexAMDX = 0; + PFN_vkCmdInitializeGraphScratchMemoryAMDX vkCmdInitializeGraphScratchMemoryAMDX = 0; + PFN_vkCmdDispatchGraphAMDX vkCmdDispatchGraphAMDX = 0; + PFN_vkCmdDispatchGraphIndirectAMDX vkCmdDispatchGraphIndirectAMDX = 0; + PFN_vkCmdDispatchGraphIndirectCountAMDX vkCmdDispatchGraphIndirectCountAMDX = 0; +#else + PFN_dummy vkCreateExecutionGraphPipelinesAMDX_placeholder = 0; + PFN_dummy vkGetExecutionGraphPipelineScratchSizeAMDX_placeholder = 0; + PFN_dummy vkGetExecutionGraphPipelineNodeIndexAMDX_placeholder = 0; + PFN_dummy vkCmdInitializeGraphScratchMemoryAMDX_placeholder = 0; + PFN_dummy vkCmdDispatchGraphAMDX_placeholder = 0; + PFN_dummy vkCmdDispatchGraphIndirectAMDX_placeholder = 0; + PFN_dummy vkCmdDispatchGraphIndirectCountAMDX_placeholder = 0; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + PFN_vkWriteSamplerDescriptorsEXT vkWriteSamplerDescriptorsEXT = 0; + PFN_vkWriteResourceDescriptorsEXT vkWriteResourceDescriptorsEXT = 0; + PFN_vkCmdBindSamplerHeapEXT vkCmdBindSamplerHeapEXT = 0; + PFN_vkCmdBindResourceHeapEXT vkCmdBindResourceHeapEXT = 0; + PFN_vkCmdPushDataEXT vkCmdPushDataEXT = 0; + PFN_vkGetImageOpaqueCaptureDataEXT vkGetImageOpaqueCaptureDataEXT = 0; + PFN_vkGetPhysicalDeviceDescriptorSizeEXT vkGetPhysicalDeviceDescriptorSizeEXT = 0; + PFN_vkRegisterCustomBorderColorEXT vkRegisterCustomBorderColorEXT = 0; + PFN_vkUnregisterCustomBorderColorEXT vkUnregisterCustomBorderColorEXT = 0; + PFN_vkGetTensorOpaqueCaptureDataARM vkGetTensorOpaqueCaptureDataARM = 0; + + //=== VK_EXT_sample_locations === + PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; + PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; + + //=== VK_KHR_get_memory_requirements2 === + PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0; + PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; + PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0; + + //=== VK_KHR_acceleration_structure === + PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0; + PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0; + PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0; + PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0; + PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0; + PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0; + PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0; + PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0; + PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0; + PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0; + PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0; + PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0; + PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0; + PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0; + PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0; + PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0; + + //=== VK_KHR_ray_tracing_pipeline === + PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0; + PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0; + PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0; + PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0; + PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0; + PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0; + PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0; + + //=== VK_KHR_sampler_ycbcr_conversion === + PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; + PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0; + + //=== VK_KHR_bind_memory2 === + PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; + PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0; + + //=== VK_EXT_image_drm_format_modifier === + PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0; + + //=== VK_EXT_validation_cache === + PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0; + PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; + PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0; + PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; + + //=== VK_NV_shading_rate_image === + PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0; + PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0; + PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0; + + //=== VK_NV_ray_tracing === + PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0; + PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0; + PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0; + PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0; + PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0; + PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0; + PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0; + PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0; + PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; + PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0; + PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0; + PFN_vkCompileDeferredNV vkCompileDeferredNV = 0; + + //=== VK_KHR_maintenance3 === + PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0; + + //=== VK_KHR_draw_indirect_count === + PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; + PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0; + + //=== VK_EXT_external_memory_host === + PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0; + + //=== VK_AMD_buffer_marker === + PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; + PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0; + + //=== VK_EXT_calibrated_timestamps === + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0; + PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0; + + //=== VK_NV_mesh_shader === + PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0; + PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0; + PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0; + + //=== VK_NV_scissor_exclusive === + PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV = 0; + PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0; + + //=== VK_NV_device_diagnostic_checkpoints === + PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0; + PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0; + PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0; + + //=== VK_KHR_timeline_semaphore === + PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0; + PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0; + PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0; + + //=== VK_EXT_present_timing === + PFN_vkSetSwapchainPresentTimingQueueSizeEXT vkSetSwapchainPresentTimingQueueSizeEXT = 0; + PFN_vkGetSwapchainTimingPropertiesEXT vkGetSwapchainTimingPropertiesEXT = 0; + PFN_vkGetSwapchainTimeDomainPropertiesEXT vkGetSwapchainTimeDomainPropertiesEXT = 0; + PFN_vkGetPastPresentationTimingEXT vkGetPastPresentationTimingEXT = 0; + + //=== VK_INTEL_performance_query === + PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; + PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; + PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; + PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0; + PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; + PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; + PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0; + PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0; + PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0; + + //=== VK_AMD_display_native_hdr === + PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; +#else + PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; +#else + PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0; + PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0; + + //=== VK_KHR_dynamic_rendering_local_read === + PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR = 0; + PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR = 0; + + //=== VK_EXT_buffer_device_address === + PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0; + + //=== VK_EXT_tooling_info === + PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0; + + //=== VK_KHR_present_wait === + PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0; + + //=== VK_NV_cooperative_matrix === + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0; + + //=== VK_NV_coverage_reduction_mode === + PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; + PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0; + PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; + PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; +#else + PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; + PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; + PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; + PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0; + + //=== VK_KHR_buffer_device_address === + PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0; + PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0; + PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0; + + //=== VK_EXT_line_rasterization === + PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0; + + //=== VK_EXT_host_query_reset === + PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0; + + //=== VK_EXT_extended_dynamic_state === + PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0; + PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0; + PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0; + PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0; + PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0; + PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0; + PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0; + PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0; + PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0; + PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0; + PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0; + PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0; + + //=== VK_KHR_deferred_host_operations === + PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0; + PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0; + PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0; + PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0; + PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0; + + //=== VK_KHR_pipeline_executable_properties === + PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0; + PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0; + PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0; + + //=== VK_EXT_host_image_copy === + PFN_vkCopyMemoryToImageEXT vkCopyMemoryToImageEXT = 0; + PFN_vkCopyImageToMemoryEXT vkCopyImageToMemoryEXT = 0; + PFN_vkCopyImageToImageEXT vkCopyImageToImageEXT = 0; + PFN_vkTransitionImageLayoutEXT vkTransitionImageLayoutEXT = 0; + PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT = 0; + + //=== VK_KHR_map_memory2 === + PFN_vkMapMemory2KHR vkMapMemory2KHR = 0; + PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR = 0; + + //=== VK_EXT_swapchain_maintenance1 === + PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT = 0; + + //=== VK_NV_device_generated_commands === + PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0; + PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0; + PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0; + PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0; + PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0; + PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0; + + //=== VK_EXT_depth_bias_control === + PFN_vkCmdSetDepthBias2EXT vkCmdSetDepthBias2EXT = 0; + + //=== VK_EXT_acquire_drm_display === + PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0; + PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0; + + //=== VK_EXT_private_data === + PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0; + PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0; + PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0; + PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0; + + //=== VK_KHR_video_encode_queue === + PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 0; + PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR = 0; + PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + PFN_vkCreateCudaModuleNV vkCreateCudaModuleNV = 0; + PFN_vkGetCudaModuleCacheNV vkGetCudaModuleCacheNV = 0; + PFN_vkCreateCudaFunctionNV vkCreateCudaFunctionNV = 0; + PFN_vkDestroyCudaModuleNV vkDestroyCudaModuleNV = 0; + PFN_vkDestroyCudaFunctionNV vkDestroyCudaFunctionNV = 0; + PFN_vkCmdCudaLaunchKernelNV vkCmdCudaLaunchKernelNV = 0; +#else + PFN_dummy vkCreateCudaModuleNV_placeholder = 0; + PFN_dummy vkGetCudaModuleCacheNV_placeholder = 0; + PFN_dummy vkCreateCudaFunctionNV_placeholder = 0; + PFN_dummy vkDestroyCudaModuleNV_placeholder = 0; + PFN_dummy vkDestroyCudaFunctionNV_placeholder = 0; + PFN_dummy vkCmdCudaLaunchKernelNV_placeholder = 0; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + PFN_vkCmdDispatchTileQCOM vkCmdDispatchTileQCOM = 0; + PFN_vkCmdBeginPerTileExecutionQCOM vkCmdBeginPerTileExecutionQCOM = 0; + PFN_vkCmdEndPerTileExecutionQCOM vkCmdEndPerTileExecutionQCOM = 0; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0; +#else + PFN_dummy vkExportMetalObjectsEXT_placeholder = 0; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0; + PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0; + PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0; + PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0; + PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0; + PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0; + + //=== VK_EXT_descriptor_buffer === + PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT = 0; + PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT = 0; + PFN_vkGetDescriptorEXT vkGetDescriptorEXT = 0; + PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT = 0; + PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT = 0; + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 0; + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT = 0; + PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT = 0; + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT = 0; + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT = 0; + PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 0; + + //=== VK_NV_fragment_shading_rate_enums === + PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0; + + //=== VK_EXT_mesh_shader === + PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT = 0; + PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT = 0; + PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = 0; + + //=== VK_KHR_copy_commands2 === + PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0; + PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0; + PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0; + PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0; + PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0; + PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0; + + //=== VK_EXT_device_fault === + PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT = 0; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; + PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; +#else + PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; + PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0; + PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0; +#else + PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_vertex_input_dynamic_state === + PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0; + PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0; +#else + PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; + PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0; + PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0; +#else + PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; + PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0; + PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0; + PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0; + PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0; + PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0; +#else + PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; + PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; + PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; + PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; + PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0; + PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0; + + //=== VK_HUAWEI_invocation_mask === + PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0; + + //=== VK_NV_external_memory_rdma === + PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0; + + //=== VK_EXT_pipeline_properties === + PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT = 0; + + //=== VK_EXT_extended_dynamic_state2 === + PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0; + PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0; + PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0; + PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0; + PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; + PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; +#else + PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_color_write_enable === + PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0; + + //=== VK_KHR_ray_tracing_maintenance1 === + PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR = 0; + + //=== VK_EXT_multi_draw === + PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0; + PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0; + + //=== VK_EXT_opacity_micromap === + PFN_vkCreateMicromapEXT vkCreateMicromapEXT = 0; + PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT = 0; + PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT = 0; + PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT = 0; + PFN_vkCopyMicromapEXT vkCopyMicromapEXT = 0; + PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT = 0; + PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT = 0; + PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT = 0; + PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT = 0; + PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT = 0; + PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT = 0; + PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT = 0; + PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT = 0; + PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT = 0; + + //=== VK_HUAWEI_cluster_culling_shader === + PFN_vkCmdDrawClusterHUAWEI vkCmdDrawClusterHUAWEI = 0; + PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI = 0; + + //=== VK_EXT_pageable_device_local_memory === + PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0; + + //=== VK_KHR_maintenance4 === + PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0; + PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0; + PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0; + + //=== VK_VALVE_descriptor_set_host_mapping === + PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0; + PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE = 0; + + //=== VK_NV_copy_memory_indirect === + PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV = 0; + PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV = 0; + + //=== VK_NV_memory_decompression === + PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV = 0; + PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV = 0; + + //=== VK_NV_device_generated_commands_compute === + PFN_vkGetPipelineIndirectMemoryRequirementsNV vkGetPipelineIndirectMemoryRequirementsNV = 0; + PFN_vkCmdUpdatePipelineIndirectBufferNV vkCmdUpdatePipelineIndirectBufferNV = 0; + PFN_vkGetPipelineIndirectDeviceAddressNV vkGetPipelineIndirectDeviceAddressNV = 0; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + PFN_vkGetNativeBufferPropertiesOHOS vkGetNativeBufferPropertiesOHOS = 0; + PFN_vkGetMemoryNativeBufferOHOS vkGetMemoryNativeBufferOHOS = 0; +#else + PFN_dummy vkGetNativeBufferPropertiesOHOS_placeholder = 0; + PFN_dummy vkGetMemoryNativeBufferOHOS_placeholder = 0; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_extended_dynamic_state3 === + PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT = 0; + PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT = 0; + PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT = 0; + PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT = 0; + PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT = 0; + PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT = 0; + PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT = 0; + PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT = 0; + PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT = 0; + PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT = 0; + PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT = 0; + PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT = 0; + PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT = 0; + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT = 0; + PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT = 0; + PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT = 0; + PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT = 0; + PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT = 0; + PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT = 0; + PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT = 0; + PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT = 0; + PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV = 0; + PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV = 0; + PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV = 0; + PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV = 0; + PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV = 0; + PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV = 0; + PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV = 0; + PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV = 0; + PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV = 0; + PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV = 0; + + //=== VK_ARM_tensors === + PFN_vkCreateTensorARM vkCreateTensorARM = 0; + PFN_vkDestroyTensorARM vkDestroyTensorARM = 0; + PFN_vkCreateTensorViewARM vkCreateTensorViewARM = 0; + PFN_vkDestroyTensorViewARM vkDestroyTensorViewARM = 0; + PFN_vkGetTensorMemoryRequirementsARM vkGetTensorMemoryRequirementsARM = 0; + PFN_vkBindTensorMemoryARM vkBindTensorMemoryARM = 0; + PFN_vkGetDeviceTensorMemoryRequirementsARM vkGetDeviceTensorMemoryRequirementsARM = 0; + PFN_vkCmdCopyTensorARM vkCmdCopyTensorARM = 0; + PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM vkGetPhysicalDeviceExternalTensorPropertiesARM = 0; + PFN_vkGetTensorOpaqueCaptureDescriptorDataARM vkGetTensorOpaqueCaptureDescriptorDataARM = 0; + PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM vkGetTensorViewOpaqueCaptureDescriptorDataARM = 0; + + //=== VK_EXT_shader_module_identifier === + PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT = 0; + PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT = 0; + + //=== VK_NV_optical_flow === + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 0; + PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV = 0; + PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV = 0; + PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV = 0; + PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV = 0; + + //=== VK_KHR_maintenance5 === + PFN_vkCmdBindIndexBuffer2KHR vkCmdBindIndexBuffer2KHR = 0; + PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR = 0; + PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR = 0; + PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR = 0; + + //=== VK_AMD_anti_lag === + PFN_vkAntiLagUpdateAMD vkAntiLagUpdateAMD = 0; + + //=== VK_KHR_present_wait2 === + PFN_vkWaitForPresent2KHR vkWaitForPresent2KHR = 0; + + //=== VK_EXT_shader_object === + PFN_vkCreateShadersEXT vkCreateShadersEXT = 0; + PFN_vkDestroyShaderEXT vkDestroyShaderEXT = 0; + PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0; + PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 0; + PFN_vkCmdSetDepthClampRangeEXT vkCmdSetDepthClampRangeEXT = 0; + + //=== VK_KHR_pipeline_binary === + PFN_vkCreatePipelineBinariesKHR vkCreatePipelineBinariesKHR = 0; + PFN_vkDestroyPipelineBinaryKHR vkDestroyPipelineBinaryKHR = 0; + PFN_vkGetPipelineKeyKHR vkGetPipelineKeyKHR = 0; + PFN_vkGetPipelineBinaryDataKHR vkGetPipelineBinaryDataKHR = 0; + PFN_vkReleaseCapturedPipelineDataKHR vkReleaseCapturedPipelineDataKHR = 0; + + //=== VK_QCOM_tile_properties === + PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0; + PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0; + + //=== VK_KHR_swapchain_maintenance1 === + PFN_vkReleaseSwapchainImagesKHR vkReleaseSwapchainImagesKHR = 0; + + //=== VK_NV_cooperative_vector === + PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV vkGetPhysicalDeviceCooperativeVectorPropertiesNV = 0; + PFN_vkConvertCooperativeVectorMatrixNV vkConvertCooperativeVectorMatrixNV = 0; + PFN_vkCmdConvertCooperativeVectorMatrixNV vkCmdConvertCooperativeVectorMatrixNV = 0; + + //=== VK_NV_low_latency2 === + PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV = 0; + PFN_vkLatencySleepNV vkLatencySleepNV = 0; + PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV = 0; + PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV = 0; + PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV = 0; + + //=== VK_KHR_cooperative_matrix === + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 0; + + //=== VK_ARM_data_graph === + PFN_vkCreateDataGraphPipelinesARM vkCreateDataGraphPipelinesARM = 0; + PFN_vkCreateDataGraphPipelineSessionARM vkCreateDataGraphPipelineSessionARM = 0; + PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM vkGetDataGraphPipelineSessionBindPointRequirementsARM = 0; + PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM vkGetDataGraphPipelineSessionMemoryRequirementsARM = 0; + PFN_vkBindDataGraphPipelineSessionMemoryARM vkBindDataGraphPipelineSessionMemoryARM = 0; + PFN_vkDestroyDataGraphPipelineSessionARM vkDestroyDataGraphPipelineSessionARM = 0; + PFN_vkCmdDispatchDataGraphARM vkCmdDispatchDataGraphARM = 0; + PFN_vkGetDataGraphPipelineAvailablePropertiesARM vkGetDataGraphPipelineAvailablePropertiesARM = 0; + PFN_vkGetDataGraphPipelinePropertiesARM vkGetDataGraphPipelinePropertiesARM = 0; + PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = 0; + PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = 0; + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT = 0; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX = 0; +#else + PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder = 0; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_KHR_line_rasterization === + PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0; + + //=== VK_KHR_calibrated_timestamps === + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0; + PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR = 0; + + //=== VK_KHR_maintenance6 === + PFN_vkCmdBindDescriptorSets2KHR vkCmdBindDescriptorSets2KHR = 0; + PFN_vkCmdPushConstants2KHR vkCmdPushConstants2KHR = 0; + PFN_vkCmdPushDescriptorSet2KHR vkCmdPushDescriptorSet2KHR = 0; + PFN_vkCmdPushDescriptorSetWithTemplate2KHR vkCmdPushDescriptorSetWithTemplate2KHR = 0; + PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0; + PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0; + + //=== VK_QCOM_tile_memory_heap === + PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM = 0; + + //=== VK_KHR_copy_memory_indirect === + PFN_vkCmdCopyMemoryIndirectKHR vkCmdCopyMemoryIndirectKHR = 0; + PFN_vkCmdCopyMemoryToImageIndirectKHR vkCmdCopyMemoryToImageIndirectKHR = 0; + + //=== VK_EXT_memory_decompression === + PFN_vkCmdDecompressMemoryEXT vkCmdDecompressMemoryEXT = 0; + PFN_vkCmdDecompressMemoryIndirectCountEXT vkCmdDecompressMemoryIndirectCountEXT = 0; + + //=== VK_NV_external_compute_queue === + PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0; + PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0; + PFN_vkGetExternalComputeQueueDataNV vkGetExternalComputeQueueDataNV = 0; + + //=== VK_NV_cluster_acceleration_structure === + PFN_vkGetClusterAccelerationStructureBuildSizesNV vkGetClusterAccelerationStructureBuildSizesNV = 0; + PFN_vkCmdBuildClusterAccelerationStructureIndirectNV vkCmdBuildClusterAccelerationStructureIndirectNV = 0; + + //=== VK_NV_partitioned_acceleration_structure === + PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV vkGetPartitionedAccelerationStructuresBuildSizesNV = 0; + PFN_vkCmdBuildPartitionedAccelerationStructuresNV vkCmdBuildPartitionedAccelerationStructuresNV = 0; + + //=== VK_EXT_device_generated_commands === + PFN_vkGetGeneratedCommandsMemoryRequirementsEXT vkGetGeneratedCommandsMemoryRequirementsEXT = 0; + PFN_vkCmdPreprocessGeneratedCommandsEXT vkCmdPreprocessGeneratedCommandsEXT = 0; + PFN_vkCmdExecuteGeneratedCommandsEXT vkCmdExecuteGeneratedCommandsEXT = 0; + PFN_vkCreateIndirectCommandsLayoutEXT vkCreateIndirectCommandsLayoutEXT = 0; + PFN_vkDestroyIndirectCommandsLayoutEXT vkDestroyIndirectCommandsLayoutEXT = 0; + PFN_vkCreateIndirectExecutionSetEXT vkCreateIndirectExecutionSetEXT = 0; + PFN_vkDestroyIndirectExecutionSetEXT vkDestroyIndirectExecutionSetEXT = 0; + PFN_vkUpdateIndirectExecutionSetPipelineEXT vkUpdateIndirectExecutionSetPipelineEXT = 0; + PFN_vkUpdateIndirectExecutionSetShaderEXT vkUpdateIndirectExecutionSetShaderEXT = 0; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS = 0; +#else + PFN_dummy vkCreateSurfaceOHOS_placeholder = 0; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_NV_cooperative_matrix2 === + PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = 0; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + PFN_vkGetMemoryMetalHandleEXT vkGetMemoryMetalHandleEXT = 0; + PFN_vkGetMemoryMetalHandlePropertiesEXT vkGetMemoryMetalHandlePropertiesEXT = 0; +#else + PFN_dummy vkGetMemoryMetalHandleEXT_placeholder = 0; + PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder = 0; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_ARM_performance_counters_by_region === + PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = 0; + + //=== VK_EXT_fragment_density_map_offset === + PFN_vkCmdEndRendering2EXT vkCmdEndRendering2EXT = 0; + + //=== VK_EXT_custom_resolve === + PFN_vkCmdBeginCustomResolveEXT vkCmdBeginCustomResolveEXT = 0; + + //=== VK_KHR_maintenance10 === + PFN_vkCmdEndRendering2KHR vkCmdEndRendering2KHR = 0; + + //=== VK_NV_compute_occupancy_priority === + PFN_vkCmdSetComputeOccupancyPriorityNV vkCmdSetComputeOccupancyPriorityNV = 0; + + public: + DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default; + DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DispatchLoaderDynamic( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT + { + init( getInstanceProcAddr ); + } + + // This interface does not require a linked vulkan library. + DispatchLoaderDynamic( VkInstance instance, + PFN_vkGetInstanceProcAddr getInstanceProcAddr, + VkDevice device = {}, + PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT + { + init( instance, getInstanceProcAddr, device, getDeviceProcAddr ); + } + + template + void init() + { + static DynamicLoader dl; + init( dl ); + } + + template + void init( DynamicLoader const & dl ) VULKAN_HPP_NOEXCEPT + { + PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress( "vkGetInstanceProcAddr" ); + init( getInstanceProcAddr ); + } + + void init( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getInstanceProcAddr ); + + vkGetInstanceProcAddr = getInstanceProcAddr; + + //=== VK_VERSION_1_0 === + vkCreateInstance = PFN_vkCreateInstance( vkGetInstanceProcAddr( NULL, "vkCreateInstance" ) ); + vkEnumerateInstanceExtensionProperties = + PFN_vkEnumerateInstanceExtensionProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) ); + vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) ); + + //=== VK_VERSION_1_1 === + vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceVersion" ) ); + } + + // This interface does not require a linked vulkan library. + void init( VkInstance instance, + PFN_vkGetInstanceProcAddr getInstanceProcAddr, + VkDevice device = {}, + PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( instance && getInstanceProcAddr ); + vkGetInstanceProcAddr = getInstanceProcAddr; + init( Instance( instance ) ); + if ( device ) + { + init( Device( device ) ); + } + } + + void init( Instance instanceCpp ) VULKAN_HPP_NOEXCEPT + { + VkInstance instance = static_cast( instanceCpp ); + + //=== VK_VERSION_1_0 === + vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) ); + vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) ); + vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) ); + vkGetPhysicalDeviceFormatProperties = + PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) ); + vkGetPhysicalDeviceImageFormatProperties = + PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) ); + vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) ); + vkGetPhysicalDeviceQueueFamilyProperties = + PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) ); + vkGetPhysicalDeviceMemoryProperties = + PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) ); + vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) ); + vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) ); + vkDestroyDevice = PFN_vkDestroyDevice( vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) ); + vkEnumerateDeviceExtensionProperties = + PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) ); + vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) ); + vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) ); + vkQueueSubmit = PFN_vkQueueSubmit( vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) ); + vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) ); + vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) ); + vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) ); + vkFreeMemory = PFN_vkFreeMemory( vkGetInstanceProcAddr( instance, "vkFreeMemory" ) ); + vkMapMemory = PFN_vkMapMemory( vkGetInstanceProcAddr( instance, "vkMapMemory" ) ); + vkUnmapMemory = PFN_vkUnmapMemory( vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) ); + vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) ); + vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) ); + vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) ); + vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) ); + vkBindImageMemory = PFN_vkBindImageMemory( vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) ); + vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) ); + vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) ); + vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements" ) ); + vkGetPhysicalDeviceSparseImageFormatProperties = + PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) ); + vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetInstanceProcAddr( instance, "vkQueueBindSparse" ) ); + vkCreateFence = PFN_vkCreateFence( vkGetInstanceProcAddr( instance, "vkCreateFence" ) ); + vkDestroyFence = PFN_vkDestroyFence( vkGetInstanceProcAddr( instance, "vkDestroyFence" ) ); + vkResetFences = PFN_vkResetFences( vkGetInstanceProcAddr( instance, "vkResetFences" ) ); + vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetInstanceProcAddr( instance, "vkGetFenceStatus" ) ); + vkWaitForFences = PFN_vkWaitForFences( vkGetInstanceProcAddr( instance, "vkWaitForFences" ) ); + vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) ); + vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) ); + vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetInstanceProcAddr( instance, "vkCreateQueryPool" ) ); + vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetInstanceProcAddr( instance, "vkDestroyQueryPool" ) ); + vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) ); + vkCreateBuffer = PFN_vkCreateBuffer( vkGetInstanceProcAddr( instance, "vkCreateBuffer" ) ); + vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) ); + vkCreateImage = PFN_vkCreateImage( vkGetInstanceProcAddr( instance, "vkCreateImage" ) ); + vkDestroyImage = PFN_vkDestroyImage( vkGetInstanceProcAddr( instance, "vkDestroyImage" ) ); + vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) ); + vkCreateImageView = PFN_vkCreateImageView( vkGetInstanceProcAddr( instance, "vkCreateImageView" ) ); + vkDestroyImageView = PFN_vkDestroyImageView( vkGetInstanceProcAddr( instance, "vkDestroyImageView" ) ); + vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetInstanceProcAddr( instance, "vkCreateCommandPool" ) ); + vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetInstanceProcAddr( instance, "vkDestroyCommandPool" ) ); + vkResetCommandPool = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) ); + vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) ); + vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) ); + vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) ); + vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) ); + vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) ); + vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer" ) ); + vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetInstanceProcAddr( instance, "vkCmdCopyImage" ) ); + vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage" ) ); + vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer" ) ); + vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) ); + vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetInstanceProcAddr( instance, "vkCmdFillBuffer" ) ); + vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) ); + vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) ); + vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) ); + vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetInstanceProcAddr( instance, "vkCmdResetQueryPool" ) ); + vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) ); + vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResults" ) ); + vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) ); + vkCreateEvent = PFN_vkCreateEvent( vkGetInstanceProcAddr( instance, "vkCreateEvent" ) ); + vkDestroyEvent = PFN_vkDestroyEvent( vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) ); + vkGetEventStatus = PFN_vkGetEventStatus( vkGetInstanceProcAddr( instance, "vkGetEventStatus" ) ); + vkSetEvent = PFN_vkSetEvent( vkGetInstanceProcAddr( instance, "vkSetEvent" ) ); + vkResetEvent = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) ); + vkCreateBufferView = PFN_vkCreateBufferView( vkGetInstanceProcAddr( instance, "vkCreateBufferView" ) ); + vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) ); + vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetInstanceProcAddr( instance, "vkCreateShaderModule" ) ); + vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetInstanceProcAddr( instance, "vkDestroyShaderModule" ) ); + vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetInstanceProcAddr( instance, "vkCreatePipelineCache" ) ); + vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetInstanceProcAddr( instance, "vkDestroyPipelineCache" ) ); + vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) ); + vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) ); + vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetInstanceProcAddr( instance, "vkCreateComputePipelines" ) ); + vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetInstanceProcAddr( instance, "vkDestroyPipeline" ) ); + vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetInstanceProcAddr( instance, "vkCreatePipelineLayout" ) ); + vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetInstanceProcAddr( instance, "vkDestroyPipelineLayout" ) ); + vkCreateSampler = PFN_vkCreateSampler( vkGetInstanceProcAddr( instance, "vkCreateSampler" ) ); + vkDestroySampler = PFN_vkDestroySampler( vkGetInstanceProcAddr( instance, "vkDestroySampler" ) ); + vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) ); + vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) ); + vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) ); + vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorPool" ) ); + vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) ); + vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) ); + vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetInstanceProcAddr( instance, "vkFreeDescriptorSets" ) ); + vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) ); + vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetInstanceProcAddr( instance, "vkCmdBindPipeline" ) ); + vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets" ) ); + vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetInstanceProcAddr( instance, "vkCmdClearColorImage" ) ); + vkCmdDispatch = PFN_vkCmdDispatch( vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) ); + vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) ); + vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) ); + vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetInstanceProcAddr( instance, "vkCmdResetEvent" ) ); + vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) ); + vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetInstanceProcAddr( instance, "vkCmdPushConstants" ) ); + vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetInstanceProcAddr( instance, "vkCreateGraphicsPipelines" ) ); + vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) ); + vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetInstanceProcAddr( instance, "vkDestroyFramebuffer" ) ); + vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) ); + vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) ); + vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) ); + vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) ); + vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) ); + vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) ); + vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) ); + vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetInstanceProcAddr( instance, "vkCmdSetBlendConstants" ) ); + vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) ); + vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) ); + vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) ); + vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) ); + vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer" ) ); + vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) ); + vkCmdDraw = PFN_vkCmdDraw( vkGetInstanceProcAddr( instance, "vkCmdDraw" ) ); + vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) ); + vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) ); + vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) ); + vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) ); + vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetInstanceProcAddr( instance, "vkCmdClearDepthStencilImage" ) ); + vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetInstanceProcAddr( instance, "vkCmdClearAttachments" ) ); + vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetInstanceProcAddr( instance, "vkCmdResolveImage" ) ); + vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) ); + vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) ); + vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) ); + + //=== VK_VERSION_1_1 === + vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) ); + vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) ); + vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) ); + vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) ); + vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) ); + vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) ); + vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) ); + vkGetImageSparseMemoryRequirements2 = + PFN_vkGetImageSparseMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) ); + vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) ); + vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) ); + vkGetPhysicalDeviceFormatProperties2 = + PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) ); + vkGetPhysicalDeviceImageFormatProperties2 = + PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) ); + vkGetPhysicalDeviceQueueFamilyProperties2 = + PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) ); + vkGetPhysicalDeviceMemoryProperties2 = + PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) ); + vkGetPhysicalDeviceSparseImageFormatProperties2 = + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) ); + vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) ); + vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) ); + vkGetPhysicalDeviceExternalBufferProperties = + PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) ); + vkGetPhysicalDeviceExternalFenceProperties = + PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) ); + vkGetPhysicalDeviceExternalSemaphoreProperties = + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) ); + vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) ); + vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) ); + vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) ); + vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) ); + vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) ); + vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) ); + vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) ); + + //=== VK_VERSION_1_2 === + vkResetQueryPool = PFN_vkResetQueryPool( vkGetInstanceProcAddr( instance, "vkResetQueryPool" ) ); + vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValue" ) ); + vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetInstanceProcAddr( instance, "vkWaitSemaphores" ) ); + vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetInstanceProcAddr( instance, "vkSignalSemaphore" ) ); + vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddress" ) ); + vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddress" ) ); + vkGetDeviceMemoryOpaqueCaptureAddress = + PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddress" ) ); + vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCount" ) ); + vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCount" ) ); + vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2" ) ); + vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2" ) ); + vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2" ) ); + vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2" ) ); + + //=== VK_VERSION_1_3 === + vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) ); + vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlot" ) ); + vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlot" ) ); + vkSetPrivateData = PFN_vkSetPrivateData( vkGetInstanceProcAddr( instance, "vkSetPrivateData" ) ); + vkGetPrivateData = PFN_vkGetPrivateData( vkGetInstanceProcAddr( instance, "vkGetPrivateData" ) ); + vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2" ) ); + vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2" ) ); + vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetInstanceProcAddr( instance, "vkQueueSubmit2" ) ); + vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2" ) ); + vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2" ) ); + vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2" ) ); + vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2" ) ); + vkGetDeviceBufferMemoryRequirements = + PFN_vkGetDeviceBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirements" ) ); + vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirements" ) ); + vkGetDeviceImageSparseMemoryRequirements = + PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirements" ) ); + vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2" ) ); + vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2" ) ); + vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2" ) ); + vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2" ) ); + vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2" ) ); + vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetInstanceProcAddr( instance, "vkCmdBeginRendering" ) ); + vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetInstanceProcAddr( instance, "vkCmdEndRendering" ) ); + vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetInstanceProcAddr( instance, "vkCmdSetCullMode" ) ); + vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFace" ) ); + vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopology" ) ); + vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCount" ) ); + vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCount" ) ); + vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2" ) ); + vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnable" ) ); + vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnable" ) ); + vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOp" ) ); + vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnable" ) ); + vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnable" ) ); + vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOp" ) ); + vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnable" ) ); + vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnable" ) ); + vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnable" ) ); + + //=== VK_VERSION_1_4 === + vkMapMemory2 = PFN_vkMapMemory2( vkGetInstanceProcAddr( instance, "vkMapMemory2" ) ); + vkUnmapMemory2 = PFN_vkUnmapMemory2( vkGetInstanceProcAddr( instance, "vkUnmapMemory2" ) ); + vkGetDeviceImageSubresourceLayout = PFN_vkGetDeviceImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSubresourceLayout" ) ); + vkGetImageSubresourceLayout2 = PFN_vkGetImageSubresourceLayout2( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2" ) ); + vkCopyMemoryToImage = PFN_vkCopyMemoryToImage( vkGetInstanceProcAddr( instance, "vkCopyMemoryToImage" ) ); + vkCopyImageToMemory = PFN_vkCopyImageToMemory( vkGetInstanceProcAddr( instance, "vkCopyImageToMemory" ) ); + vkCopyImageToImage = PFN_vkCopyImageToImage( vkGetInstanceProcAddr( instance, "vkCopyImageToImage" ) ); + vkTransitionImageLayout = PFN_vkTransitionImageLayout( vkGetInstanceProcAddr( instance, "vkTransitionImageLayout" ) ); + vkCmdPushDescriptorSet = PFN_vkCmdPushDescriptorSet( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSet" ) ); + vkCmdPushDescriptorSetWithTemplate = PFN_vkCmdPushDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplate" ) ); + vkCmdBindDescriptorSets2 = PFN_vkCmdBindDescriptorSets2( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets2" ) ); + vkCmdPushConstants2 = PFN_vkCmdPushConstants2( vkGetInstanceProcAddr( instance, "vkCmdPushConstants2" ) ); + vkCmdPushDescriptorSet2 = PFN_vkCmdPushDescriptorSet2( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSet2" ) ); + vkCmdPushDescriptorSetWithTemplate2 = + PFN_vkCmdPushDescriptorSetWithTemplate2( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplate2" ) ); + vkCmdSetLineStipple = PFN_vkCmdSetLineStipple( vkGetInstanceProcAddr( instance, "vkCmdSetLineStipple" ) ); + vkCmdBindIndexBuffer2 = PFN_vkCmdBindIndexBuffer2( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer2" ) ); + vkGetRenderingAreaGranularity = PFN_vkGetRenderingAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderingAreaGranularity" ) ); + vkCmdSetRenderingAttachmentLocations = + PFN_vkCmdSetRenderingAttachmentLocations( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingAttachmentLocations" ) ); + vkCmdSetRenderingInputAttachmentIndices = + PFN_vkCmdSetRenderingInputAttachmentIndices( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingInputAttachmentIndices" ) ); + + //=== VK_KHR_surface === + vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) ); + vkGetPhysicalDeviceSurfaceSupportKHR = + PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) ); + vkGetPhysicalDeviceSurfaceCapabilitiesKHR = + PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) ); + vkGetPhysicalDeviceSurfaceFormatsKHR = + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) ); + vkGetPhysicalDeviceSurfacePresentModesKHR = + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) ); + + //=== VK_KHR_swapchain === + vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetInstanceProcAddr( instance, "vkCreateSwapchainKHR" ) ); + vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetInstanceProcAddr( instance, "vkDestroySwapchainKHR" ) ); + vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainImagesKHR" ) ); + vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) ); + vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) ); + vkGetDeviceGroupPresentCapabilitiesKHR = + PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); + vkGetDeviceGroupSurfacePresentModesKHR = + PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); + vkGetPhysicalDevicePresentRectanglesKHR = + PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) ); + vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) ); + + //=== VK_KHR_display === + vkGetPhysicalDeviceDisplayPropertiesKHR = + PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) ); + vkGetPhysicalDeviceDisplayPlanePropertiesKHR = + PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) ); + vkGetDisplayPlaneSupportedDisplaysKHR = + PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) ); + vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) ); + vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) ); + vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) ); + vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) ); + + //=== VK_KHR_display_swapchain === + vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetInstanceProcAddr( instance, "vkCreateSharedSwapchainsKHR" ) ); + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) ); + vkGetPhysicalDeviceXlibPresentationSupportKHR = + PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) ); +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) ); + vkGetPhysicalDeviceXcbPresentationSupportKHR = + PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) ); +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) ); + vkGetPhysicalDeviceWaylandPresentationSupportKHR = + PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) ); +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) ); +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) ); + vkGetPhysicalDeviceWin32PresentationSupportKHR = + PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) ); + vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) ); + vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) ); + + //=== VK_EXT_debug_marker === + vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectTagEXT" ) ); + vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectNameEXT" ) ); + vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerBeginEXT" ) ); + vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerEndEXT" ) ); + vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerInsertEXT" ) ); + + //=== VK_KHR_video_queue === + vkGetPhysicalDeviceVideoCapabilitiesKHR = + PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) ); + vkGetPhysicalDeviceVideoFormatPropertiesKHR = + PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) ); + vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionKHR" ) ); + vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionKHR" ) ); + vkGetVideoSessionMemoryRequirementsKHR = + PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetVideoSessionMemoryRequirementsKHR" ) ); + vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetInstanceProcAddr( instance, "vkBindVideoSessionMemoryKHR" ) ); + vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionParametersKHR" ) ); + vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkUpdateVideoSessionParametersKHR" ) ); + vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionParametersKHR" ) ); + vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginVideoCodingKHR" ) ); + vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndVideoCodingKHR" ) ); + vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdControlVideoCodingKHR" ) ); + + //=== VK_KHR_video_decode_queue === + vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdDecodeVideoKHR" ) ); + + //=== VK_EXT_transform_feedback === + vkCmdBindTransformFeedbackBuffersEXT = + PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffersEXT" ) ); + vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedbackEXT" ) ); + vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedbackEXT" ) ); + vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginQueryIndexedEXT" ) ); + vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdEndQueryIndexedEXT" ) ); + vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCountEXT" ) ); + + //=== VK_NVX_binary_import === + vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetInstanceProcAddr( instance, "vkCreateCuModuleNVX" ) ); + vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkCreateCuFunctionNVX" ) ); + vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuModuleNVX" ) ); + vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuFunctionNVX" ) ); + vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetInstanceProcAddr( instance, "vkCmdCuLaunchKernelNVX" ) ); + + //=== VK_NVX_image_view_handle === + vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandleNVX" ) ); + vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandle64NVX" ) ); + vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewAddressNVX" ) ); + vkGetDeviceCombinedImageSamplerIndexNVX = + PFN_vkGetDeviceCombinedImageSamplerIndexNVX( vkGetInstanceProcAddr( instance, "vkGetDeviceCombinedImageSamplerIndexNVX" ) ); + + //=== VK_AMD_draw_indirect_count === + vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) ); + if ( !vkCmdDrawIndirectCount ) + vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; + vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountAMD" ) ); + if ( !vkCmdDrawIndexedIndirectCount ) + vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; + + //=== VK_AMD_shader_info === + vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetInstanceProcAddr( instance, "vkGetShaderInfoAMD" ) ); + + //=== VK_KHR_dynamic_rendering === + vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderingKHR" ) ); + if ( !vkCmdBeginRendering ) + vkCmdBeginRendering = vkCmdBeginRenderingKHR; + vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderingKHR" ) ); + if ( !vkCmdEndRendering ) + vkCmdEndRendering = vkCmdEndRenderingKHR; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) ); +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + vkGetPhysicalDeviceExternalImageFormatPropertiesNV = + PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) ); + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_get_physical_device_properties2 === + vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) ); + if ( !vkGetPhysicalDeviceFeatures2 ) + vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR; + vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceProperties2 ) + vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR; + vkGetPhysicalDeviceFormatProperties2KHR = + PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceFormatProperties2 ) + vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR; + vkGetPhysicalDeviceImageFormatProperties2KHR = + PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceImageFormatProperties2 ) + vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR; + vkGetPhysicalDeviceQueueFamilyProperties2KHR = + PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceQueueFamilyProperties2 ) + vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR; + vkGetPhysicalDeviceMemoryProperties2KHR = + PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceMemoryProperties2 ) + vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR; + vkGetPhysicalDeviceSparseImageFormatProperties2KHR = + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceSparseImageFormatProperties2 ) + vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR; + + //=== VK_KHR_device_group === + vkGetDeviceGroupPeerMemoryFeaturesKHR = + PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); + if ( !vkGetDeviceGroupPeerMemoryFeatures ) + vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; + vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) ); + if ( !vkCmdSetDeviceMask ) + vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; + vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) ); + if ( !vkCmdDispatchBase ) + vkCmdDispatchBase = vkCmdDispatchBaseKHR; + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) ); +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_maintenance1 === + vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) ); + if ( !vkTrimCommandPool ) + vkTrimCommandPool = vkTrimCommandPoolKHR; + + //=== VK_KHR_device_group_creation === + vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) ); + if ( !vkEnumeratePhysicalDeviceGroups ) + vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR; + + //=== VK_KHR_external_memory_capabilities === + vkGetPhysicalDeviceExternalBufferPropertiesKHR = + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) ); + if ( !vkGetPhysicalDeviceExternalBufferProperties ) + vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ) ); + vkGetMemoryWin32HandlePropertiesKHR = + PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR" ) ); + vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdPropertiesKHR" ) ); + + //=== VK_KHR_external_semaphore_capabilities === + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = + PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) ); + if ( !vkGetPhysicalDeviceExternalSemaphoreProperties ) + vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ) ); + vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreFdKHR" ) ); + vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) ); + + //=== VK_KHR_push_descriptor === + vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetKHR" ) ); + if ( !vkCmdPushDescriptorSet ) + vkCmdPushDescriptorSet = vkCmdPushDescriptorSetKHR; + vkCmdPushDescriptorSetWithTemplateKHR = + PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplateKHR" ) ); + if ( !vkCmdPushDescriptorSetWithTemplate ) + vkCmdPushDescriptorSetWithTemplate = vkCmdPushDescriptorSetWithTemplateKHR; + + //=== VK_EXT_conditional_rendering === + vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRenderingEXT" ) ); + vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdEndConditionalRenderingEXT" ) ); + + //=== VK_KHR_descriptor_update_template === + vkCreateDescriptorUpdateTemplateKHR = + PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplateKHR" ) ); + if ( !vkCreateDescriptorUpdateTemplate ) + vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; + vkDestroyDescriptorUpdateTemplateKHR = + PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplateKHR" ) ); + if ( !vkDestroyDescriptorUpdateTemplate ) + vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; + vkUpdateDescriptorSetWithTemplateKHR = + PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) ); + if ( !vkUpdateDescriptorSetWithTemplate ) + vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; + + //=== VK_NV_clip_space_w_scaling === + vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingNV" ) ); + + //=== VK_EXT_direct_mode_display === + vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) ); + +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) ); + vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) ); +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + vkGetPhysicalDeviceSurfaceCapabilities2EXT = + PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) ); + + //=== VK_EXT_display_control === + vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) ); + vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) ); + vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) ); + vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainCounterEXT" ) ); + + //=== VK_GOOGLE_display_timing === + vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) ); + vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) ); + + //=== VK_EXT_discard_rectangles === + vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) ); + vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEnableEXT" ) ); + vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleModeEXT" ) ); + + //=== VK_EXT_hdr_metadata === + vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) ); + + //=== VK_KHR_create_renderpass2 === + vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2KHR" ) ); + if ( !vkCreateRenderPass2 ) + vkCreateRenderPass2 = vkCreateRenderPass2KHR; + vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2KHR" ) ); + if ( !vkCmdBeginRenderPass2 ) + vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; + vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2KHR" ) ); + if ( !vkCmdNextSubpass2 ) + vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; + vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2KHR" ) ); + if ( !vkCmdEndRenderPass2 ) + vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; + + //=== VK_KHR_shared_presentable_image === + vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainStatusKHR" ) ); + + //=== VK_KHR_external_fence_capabilities === + vkGetPhysicalDeviceExternalFencePropertiesKHR = + PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) ); + if ( !vkGetPhysicalDeviceExternalFenceProperties ) + vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ) ); + vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetInstanceProcAddr( instance, "vkImportFenceFdKHR" ) ); + vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetInstanceProcAddr( instance, "vkGetFenceFdKHR" ) ); + + //=== VK_KHR_performance_query === + vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) ); + vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) ); + vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) ); + vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) ); + + //=== VK_KHR_get_surface_capabilities2 === + vkGetPhysicalDeviceSurfaceCapabilities2KHR = + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) ); + vkGetPhysicalDeviceSurfaceFormats2KHR = + PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) ); + + //=== VK_KHR_get_display_properties2 === + vkGetPhysicalDeviceDisplayProperties2KHR = + PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) ); + vkGetPhysicalDeviceDisplayPlaneProperties2KHR = + PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) ); + vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) ); + vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) ); + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) ); +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) ); +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) ); + vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) ); + vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) ); + vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) ); + vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) ); + vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginDebugUtilsLabelEXT" ) ); + vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdEndDebugUtilsLabelEXT" ) ); + vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) ); + vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) ); + vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) ); + vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) ); + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + vkGetAndroidHardwareBufferPropertiesANDROID = + PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ) ); + vkGetMemoryAndroidHardwareBufferANDROID = + PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + vkCreateExecutionGraphPipelinesAMDX = + PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetInstanceProcAddr( instance, "vkCreateExecutionGraphPipelinesAMDX" ) ); + vkGetExecutionGraphPipelineScratchSizeAMDX = + PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetInstanceProcAddr( instance, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) ); + vkGetExecutionGraphPipelineNodeIndexAMDX = + PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetInstanceProcAddr( instance, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) ); + vkCmdInitializeGraphScratchMemoryAMDX = + PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetInstanceProcAddr( instance, "vkCmdInitializeGraphScratchMemoryAMDX" ) ); + vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphAMDX" ) ); + vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphIndirectAMDX" ) ); + vkCmdDispatchGraphIndirectCountAMDX = + PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphIndirectCountAMDX" ) ); +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + vkWriteSamplerDescriptorsEXT = PFN_vkWriteSamplerDescriptorsEXT( vkGetInstanceProcAddr( instance, "vkWriteSamplerDescriptorsEXT" ) ); + vkWriteResourceDescriptorsEXT = PFN_vkWriteResourceDescriptorsEXT( vkGetInstanceProcAddr( instance, "vkWriteResourceDescriptorsEXT" ) ); + vkCmdBindSamplerHeapEXT = PFN_vkCmdBindSamplerHeapEXT( vkGetInstanceProcAddr( instance, "vkCmdBindSamplerHeapEXT" ) ); + vkCmdBindResourceHeapEXT = PFN_vkCmdBindResourceHeapEXT( vkGetInstanceProcAddr( instance, "vkCmdBindResourceHeapEXT" ) ); + vkCmdPushDataEXT = PFN_vkCmdPushDataEXT( vkGetInstanceProcAddr( instance, "vkCmdPushDataEXT" ) ); + vkGetImageOpaqueCaptureDataEXT = PFN_vkGetImageOpaqueCaptureDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageOpaqueCaptureDataEXT" ) ); + vkGetPhysicalDeviceDescriptorSizeEXT = + PFN_vkGetPhysicalDeviceDescriptorSizeEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDescriptorSizeEXT" ) ); + vkRegisterCustomBorderColorEXT = PFN_vkRegisterCustomBorderColorEXT( vkGetInstanceProcAddr( instance, "vkRegisterCustomBorderColorEXT" ) ); + vkUnregisterCustomBorderColorEXT = PFN_vkUnregisterCustomBorderColorEXT( vkGetInstanceProcAddr( instance, "vkUnregisterCustomBorderColorEXT" ) ); + vkGetTensorOpaqueCaptureDataARM = PFN_vkGetTensorOpaqueCaptureDataARM( vkGetInstanceProcAddr( instance, "vkGetTensorOpaqueCaptureDataARM" ) ); + + //=== VK_EXT_sample_locations === + vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) ); + vkGetPhysicalDeviceMultisamplePropertiesEXT = + PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) ); + + //=== VK_KHR_get_memory_requirements2 === + vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2KHR" ) ); + if ( !vkGetImageMemoryRequirements2 ) + vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; + vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2KHR" ) ); + if ( !vkGetBufferMemoryRequirements2 ) + vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; + vkGetImageSparseMemoryRequirements2KHR = + PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) ); + if ( !vkGetImageSparseMemoryRequirements2 ) + vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; + + //=== VK_KHR_acceleration_structure === + vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureKHR" ) ); + vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureKHR" ) ); + vkCmdBuildAccelerationStructuresKHR = + PFN_vkCmdBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresKHR" ) ); + vkCmdBuildAccelerationStructuresIndirectKHR = + PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresIndirectKHR" ) ); + vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkBuildAccelerationStructuresKHR" ) ); + vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureKHR" ) ); + vkCopyAccelerationStructureToMemoryKHR = + PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureToMemoryKHR" ) ); + vkCopyMemoryToAccelerationStructureKHR = + PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyMemoryToAccelerationStructureKHR" ) ); + vkWriteAccelerationStructuresPropertiesKHR = + PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkWriteAccelerationStructuresPropertiesKHR" ) ); + vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureKHR" ) ); + vkCmdCopyAccelerationStructureToMemoryKHR = + PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureToMemoryKHR" ) ); + vkCmdCopyMemoryToAccelerationStructureKHR = + PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToAccelerationStructureKHR" ) ); + vkGetAccelerationStructureDeviceAddressKHR = + PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureDeviceAddressKHR" ) ); + vkCmdWriteAccelerationStructuresPropertiesKHR = + PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) ); + vkGetDeviceAccelerationStructureCompatibilityKHR = + PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) ); + vkGetAccelerationStructureBuildSizesKHR = + PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureBuildSizesKHR" ) ); + + //=== VK_KHR_ray_tracing_pipeline === + vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysKHR" ) ); + vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesKHR" ) ); + vkGetRayTracingShaderGroupHandlesKHR = + PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesKHR" ) ); + vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = + PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) ); + vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirectKHR" ) ); + vkGetRayTracingShaderGroupStackSizeKHR = + PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupStackSizeKHR" ) ); + vkCmdSetRayTracingPipelineStackSizeKHR = + PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); + + //=== VK_KHR_sampler_ycbcr_conversion === + vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversionKHR" ) ); + if ( !vkCreateSamplerYcbcrConversion ) + vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; + vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversionKHR" ) ); + if ( !vkDestroySamplerYcbcrConversion ) + vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; + + //=== VK_KHR_bind_memory2 === + vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) ); + if ( !vkBindBufferMemory2 ) + vkBindBufferMemory2 = vkBindBufferMemory2KHR; + vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) ); + if ( !vkBindImageMemory2 ) + vkBindImageMemory2 = vkBindImageMemory2KHR; + + //=== VK_EXT_image_drm_format_modifier === + vkGetImageDrmFormatModifierPropertiesEXT = + PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) ); + + //=== VK_EXT_validation_cache === + vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkCreateValidationCacheEXT" ) ); + vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkDestroyValidationCacheEXT" ) ); + vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetInstanceProcAddr( instance, "vkMergeValidationCachesEXT" ) ); + vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetInstanceProcAddr( instance, "vkGetValidationCacheDataEXT" ) ); + + //=== VK_NV_shading_rate_image === + vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetInstanceProcAddr( instance, "vkCmdBindShadingRateImageNV" ) ); + vkCmdSetViewportShadingRatePaletteNV = + PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportShadingRatePaletteNV" ) ); + vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoarseSampleOrderNV" ) ); + + //=== VK_NV_ray_tracing === + vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureNV" ) ); + vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) ); + vkGetAccelerationStructureMemoryRequirementsNV = + PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureMemoryRequirementsNV" ) ); + vkBindAccelerationStructureMemoryNV = + PFN_vkBindAccelerationStructureMemoryNV( vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) ); + vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructureNV" ) ); + vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureNV" ) ); + vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysNV" ) ); + vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesNV" ) ); + vkGetRayTracingShaderGroupHandlesNV = + PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) ); + if ( !vkGetRayTracingShaderGroupHandlesKHR ) + vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; + vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureHandleNV" ) ); + vkCmdWriteAccelerationStructuresPropertiesNV = + PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) ); + vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetInstanceProcAddr( instance, "vkCompileDeferredNV" ) ); + + //=== VK_KHR_maintenance3 === + vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupportKHR" ) ); + if ( !vkGetDescriptorSetLayoutSupport ) + vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; + + //=== VK_KHR_draw_indirect_count === + vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountKHR" ) ); + if ( !vkCmdDrawIndirectCount ) + vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; + vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountKHR" ) ); + if ( !vkCmdDrawIndexedIndirectCount ) + vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; + + //=== VK_EXT_external_memory_host === + vkGetMemoryHostPointerPropertiesEXT = + PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) ); + + //=== VK_AMD_buffer_marker === + vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarkerAMD" ) ); + vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarker2AMD" ) ); + + //=== VK_EXT_calibrated_timestamps === + vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) ); + if ( !vkGetPhysicalDeviceCalibrateableTimeDomainsKHR ) + vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; + vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) ); + if ( !vkGetCalibratedTimestampsKHR ) + vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT; + + //=== VK_NV_mesh_shader === + vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksNV" ) ); + vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectNV" ) ); + vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) ); + + //=== VK_NV_scissor_exclusive === + vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorEnableNV" ) ); + vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) ); + + //=== VK_NV_device_diagnostic_checkpoints === + vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) ); + vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) ); + vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointData2NV" ) ); + + //=== VK_KHR_timeline_semaphore === + vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValueKHR" ) ); + if ( !vkGetSemaphoreCounterValue ) + vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; + vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetInstanceProcAddr( instance, "vkWaitSemaphoresKHR" ) ); + if ( !vkWaitSemaphores ) + vkWaitSemaphores = vkWaitSemaphoresKHR; + vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetInstanceProcAddr( instance, "vkSignalSemaphoreKHR" ) ); + if ( !vkSignalSemaphore ) + vkSignalSemaphore = vkSignalSemaphoreKHR; + + //=== VK_EXT_present_timing === + vkSetSwapchainPresentTimingQueueSizeEXT = + PFN_vkSetSwapchainPresentTimingQueueSizeEXT( vkGetInstanceProcAddr( instance, "vkSetSwapchainPresentTimingQueueSizeEXT" ) ); + vkGetSwapchainTimingPropertiesEXT = PFN_vkGetSwapchainTimingPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainTimingPropertiesEXT" ) ); + vkGetSwapchainTimeDomainPropertiesEXT = + PFN_vkGetSwapchainTimeDomainPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainTimeDomainPropertiesEXT" ) ); + vkGetPastPresentationTimingEXT = PFN_vkGetPastPresentationTimingEXT( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingEXT" ) ); + + //=== VK_INTEL_performance_query === + vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkInitializePerformanceApiINTEL" ) ); + vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) ); + vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) ); + vkCmdSetPerformanceStreamMarkerINTEL = + PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); + vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) ); + vkAcquirePerformanceConfigurationINTEL = + PFN_vkAcquirePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) ); + vkReleasePerformanceConfigurationINTEL = + PFN_vkReleasePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) ); + vkQueueSetPerformanceConfigurationINTEL = + PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkQueueSetPerformanceConfigurationINTEL" ) ); + vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) ); + + //=== VK_AMD_display_native_hdr === + vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) ); + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) ); +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + vkGetPhysicalDeviceFragmentShadingRatesKHR = + PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) ); + vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateKHR" ) ); + + //=== VK_KHR_dynamic_rendering_local_read === + vkCmdSetRenderingAttachmentLocationsKHR = + PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingAttachmentLocationsKHR" ) ); + if ( !vkCmdSetRenderingAttachmentLocations ) + vkCmdSetRenderingAttachmentLocations = vkCmdSetRenderingAttachmentLocationsKHR; + vkCmdSetRenderingInputAttachmentIndicesKHR = + PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) ); + if ( !vkCmdSetRenderingInputAttachmentIndices ) + vkCmdSetRenderingInputAttachmentIndices = vkCmdSetRenderingInputAttachmentIndicesKHR; + + //=== VK_EXT_buffer_device_address === + vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) ); + if ( !vkGetBufferDeviceAddress ) + vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; + + //=== VK_EXT_tooling_info === + vkGetPhysicalDeviceToolPropertiesEXT = + PFN_vkGetPhysicalDeviceToolPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) ); + if ( !vkGetPhysicalDeviceToolProperties ) + vkGetPhysicalDeviceToolProperties = vkGetPhysicalDeviceToolPropertiesEXT; + + //=== VK_KHR_present_wait === + vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetInstanceProcAddr( instance, "vkWaitForPresentKHR" ) ); + + //=== VK_NV_cooperative_matrix === + vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) ); + + //=== VK_NV_coverage_reduction_mode === + vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) ); + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + vkGetPhysicalDeviceSurfacePresentModes2EXT = + PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) ); + vkAcquireFullScreenExclusiveModeEXT = + PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) ); + vkReleaseFullScreenExclusiveModeEXT = + PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) ); + vkGetDeviceGroupSurfacePresentModes2EXT = + PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) ); + + //=== VK_KHR_buffer_device_address === + vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressKHR" ) ); + if ( !vkGetBufferDeviceAddress ) + vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; + vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddressKHR" ) ); + if ( !vkGetBufferOpaqueCaptureAddress ) + vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; + vkGetDeviceMemoryOpaqueCaptureAddressKHR = + PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) ); + if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) + vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; + + //=== VK_EXT_line_rasterization === + vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) ); + if ( !vkCmdSetLineStipple ) + vkCmdSetLineStipple = vkCmdSetLineStippleEXT; + + //=== VK_EXT_host_query_reset === + vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) ); + if ( !vkResetQueryPool ) + vkResetQueryPool = vkResetQueryPoolEXT; + + //=== VK_EXT_extended_dynamic_state === + vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetCullModeEXT" ) ); + if ( !vkCmdSetCullMode ) + vkCmdSetCullMode = vkCmdSetCullModeEXT; + vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFaceEXT" ) ); + if ( !vkCmdSetFrontFace ) + vkCmdSetFrontFace = vkCmdSetFrontFaceEXT; + vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopologyEXT" ) ); + if ( !vkCmdSetPrimitiveTopology ) + vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT; + vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCountEXT" ) ); + if ( !vkCmdSetViewportWithCount ) + vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT; + vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCountEXT" ) ); + if ( !vkCmdSetScissorWithCount ) + vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT; + vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2EXT" ) ); + if ( !vkCmdBindVertexBuffers2 ) + vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT; + vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnableEXT" ) ); + if ( !vkCmdSetDepthTestEnable ) + vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT; + vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnableEXT" ) ); + if ( !vkCmdSetDepthWriteEnable ) + vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT; + vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOpEXT" ) ); + if ( !vkCmdSetDepthCompareOp ) + vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT; + vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnableEXT" ) ); + if ( !vkCmdSetDepthBoundsTestEnable ) + vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT; + vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnableEXT" ) ); + if ( !vkCmdSetStencilTestEnable ) + vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT; + vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOpEXT" ) ); + if ( !vkCmdSetStencilOp ) + vkCmdSetStencilOp = vkCmdSetStencilOpEXT; + + //=== VK_KHR_deferred_host_operations === + vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkCreateDeferredOperationKHR" ) ); + vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkDestroyDeferredOperationKHR" ) ); + vkGetDeferredOperationMaxConcurrencyKHR = + PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationMaxConcurrencyKHR" ) ); + vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationResultKHR" ) ); + vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetInstanceProcAddr( instance, "vkDeferredOperationJoinKHR" ) ); + + //=== VK_KHR_pipeline_executable_properties === + vkGetPipelineExecutablePropertiesKHR = + PFN_vkGetPipelineExecutablePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutablePropertiesKHR" ) ); + vkGetPipelineExecutableStatisticsKHR = + PFN_vkGetPipelineExecutableStatisticsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableStatisticsKHR" ) ); + vkGetPipelineExecutableInternalRepresentationsKHR = + PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableInternalRepresentationsKHR" ) ); + + //=== VK_EXT_host_image_copy === + vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetInstanceProcAddr( instance, "vkCopyMemoryToImageEXT" ) ); + if ( !vkCopyMemoryToImage ) + vkCopyMemoryToImage = vkCopyMemoryToImageEXT; + vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCopyImageToMemoryEXT" ) ); + if ( !vkCopyImageToMemory ) + vkCopyImageToMemory = vkCopyImageToMemoryEXT; + vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetInstanceProcAddr( instance, "vkCopyImageToImageEXT" ) ); + if ( !vkCopyImageToImage ) + vkCopyImageToImage = vkCopyImageToImageEXT; + vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetInstanceProcAddr( instance, "vkTransitionImageLayoutEXT" ) ); + if ( !vkTransitionImageLayout ) + vkTransitionImageLayout = vkTransitionImageLayoutEXT; + vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2EXT" ) ); + if ( !vkGetImageSubresourceLayout2 ) + vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2EXT; + + //=== VK_KHR_map_memory2 === + vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetInstanceProcAddr( instance, "vkMapMemory2KHR" ) ); + if ( !vkMapMemory2 ) + vkMapMemory2 = vkMapMemory2KHR; + vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetInstanceProcAddr( instance, "vkUnmapMemory2KHR" ) ); + if ( !vkUnmapMemory2 ) + vkUnmapMemory2 = vkUnmapMemory2KHR; + + //=== VK_EXT_swapchain_maintenance1 === + vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetInstanceProcAddr( instance, "vkReleaseSwapchainImagesEXT" ) ); + if ( !vkReleaseSwapchainImagesKHR ) + vkReleaseSwapchainImagesKHR = vkReleaseSwapchainImagesEXT; + + //=== VK_NV_device_generated_commands === + vkGetGeneratedCommandsMemoryRequirementsNV = + PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetGeneratedCommandsMemoryRequirementsNV" ) ); + vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdPreprocessGeneratedCommandsNV" ) ); + vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdExecuteGeneratedCommandsNV" ) ); + vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetInstanceProcAddr( instance, "vkCmdBindPipelineShaderGroupNV" ) ); + vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutNV" ) ); + vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutNV" ) ); + + //=== VK_EXT_depth_bias_control === + vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias2EXT" ) ); + + //=== VK_EXT_acquire_drm_display === + vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) ); + vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) ); + + //=== VK_EXT_private_data === + vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlotEXT" ) ); + if ( !vkCreatePrivateDataSlot ) + vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT; + vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlotEXT" ) ); + if ( !vkDestroyPrivateDataSlot ) + vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT; + vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkSetPrivateDataEXT" ) ); + if ( !vkSetPrivateData ) + vkSetPrivateData = vkSetPrivateDataEXT; + vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkGetPrivateDataEXT" ) ); + if ( !vkGetPrivateData ) + vkGetPrivateData = vkGetPrivateDataEXT; + + //=== VK_KHR_video_encode_queue === + vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR" ) ); + vkGetEncodedVideoSessionParametersKHR = + PFN_vkGetEncodedVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkGetEncodedVideoSessionParametersKHR" ) ); + vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdEncodeVideoKHR" ) ); + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetInstanceProcAddr( instance, "vkCreateCudaModuleNV" ) ); + vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetInstanceProcAddr( instance, "vkGetCudaModuleCacheNV" ) ); + vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetInstanceProcAddr( instance, "vkCreateCudaFunctionNV" ) ); + vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetInstanceProcAddr( instance, "vkDestroyCudaModuleNV" ) ); + vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetInstanceProcAddr( instance, "vkDestroyCudaFunctionNV" ) ); + vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetInstanceProcAddr( instance, "vkCmdCudaLaunchKernelNV" ) ); +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + vkCmdDispatchTileQCOM = PFN_vkCmdDispatchTileQCOM( vkGetInstanceProcAddr( instance, "vkCmdDispatchTileQCOM" ) ); + vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetInstanceProcAddr( instance, "vkCmdBeginPerTileExecutionQCOM" ) ); + vkCmdEndPerTileExecutionQCOM = PFN_vkCmdEndPerTileExecutionQCOM( vkGetInstanceProcAddr( instance, "vkCmdEndPerTileExecutionQCOM" ) ); + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetInstanceProcAddr( instance, "vkExportMetalObjectsEXT" ) ); +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2KHR" ) ); + if ( !vkCmdSetEvent2 ) + vkCmdSetEvent2 = vkCmdSetEvent2KHR; + vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2KHR" ) ); + if ( !vkCmdResetEvent2 ) + vkCmdResetEvent2 = vkCmdResetEvent2KHR; + vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2KHR" ) ); + if ( !vkCmdWaitEvents2 ) + vkCmdWaitEvents2 = vkCmdWaitEvents2KHR; + vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2KHR" ) ); + if ( !vkCmdPipelineBarrier2 ) + vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR; + vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2KHR" ) ); + if ( !vkCmdWriteTimestamp2 ) + vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR; + vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetInstanceProcAddr( instance, "vkQueueSubmit2KHR" ) ); + if ( !vkQueueSubmit2 ) + vkQueueSubmit2 = vkQueueSubmit2KHR; + + //=== VK_EXT_descriptor_buffer === + vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSizeEXT" ) ); + vkGetDescriptorSetLayoutBindingOffsetEXT = + PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) ); + vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorEXT" ) ); + vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBuffersEXT" ) ); + vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDescriptorBufferOffsetsEXT" ) ); + vkCmdBindDescriptorBufferEmbeddedSamplersEXT = + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) ); + vkGetBufferOpaqueCaptureDescriptorDataEXT = + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) ); + vkGetImageOpaqueCaptureDescriptorDataEXT = + PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) ); + vkGetImageViewOpaqueCaptureDescriptorDataEXT = + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) ); + vkGetSamplerOpaqueCaptureDescriptorDataEXT = + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) ); + vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) ); + + //=== VK_NV_fragment_shading_rate_enums === + vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateEnumNV" ) ); + + //=== VK_EXT_mesh_shader === + vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksEXT" ) ); + vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectEXT" ) ); + vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountEXT" ) ); + + //=== VK_KHR_copy_commands2 === + vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2KHR" ) ); + if ( !vkCmdCopyBuffer2 ) + vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR; + vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2KHR" ) ); + if ( !vkCmdCopyImage2 ) + vkCmdCopyImage2 = vkCmdCopyImage2KHR; + vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2KHR" ) ); + if ( !vkCmdCopyBufferToImage2 ) + vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR; + vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2KHR" ) ); + if ( !vkCmdCopyImageToBuffer2 ) + vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR; + vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2KHR" ) ); + if ( !vkCmdBlitImage2 ) + vkCmdBlitImage2 = vkCmdBlitImage2KHR; + vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2KHR" ) ); + if ( !vkCmdResolveImage2 ) + vkCmdResolveImage2 = vkCmdResolveImage2KHR; + + //=== VK_EXT_device_fault === + vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceFaultInfoEXT" ) ); + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) ); + vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) ); + vkGetPhysicalDeviceDirectFBPresentationSupportEXT = + PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) ); +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_vertex_input_dynamic_state === + vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetInstanceProcAddr( instance, "vkCmdSetVertexInputEXT" ) ); + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandleFUCHSIA" ) ); + vkGetMemoryZirconHandlePropertiesFUCHSIA = + PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + vkImportSemaphoreZirconHandleFUCHSIA = + PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkImportSemaphoreZirconHandleFUCHSIA" ) ); + vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetSemaphoreZirconHandleFUCHSIA" ) ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateBufferCollectionFUCHSIA" ) ); + vkSetBufferCollectionImageConstraintsFUCHSIA = + PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) ); + vkSetBufferCollectionBufferConstraintsFUCHSIA = + PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) ); + vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkDestroyBufferCollectionFUCHSIA" ) ); + vkGetBufferCollectionPropertiesFUCHSIA = + PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetBufferCollectionPropertiesFUCHSIA" ) ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = + PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetInstanceProcAddr( instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) ); + vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdSubpassShadingHUAWEI" ) ); + + //=== VK_HUAWEI_invocation_mask === + vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdBindInvocationMaskHUAWEI" ) ); + + //=== VK_NV_external_memory_rdma === + vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetInstanceProcAddr( instance, "vkGetMemoryRemoteAddressNV" ) ); + + //=== VK_EXT_pipeline_properties === + vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPipelinePropertiesEXT" ) ); + + //=== VK_EXT_extended_dynamic_state2 === + vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPatchControlPointsEXT" ) ); + vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnableEXT" ) ); + if ( !vkCmdSetRasterizerDiscardEnable ) + vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT; + vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnableEXT" ) ); + if ( !vkCmdSetDepthBiasEnable ) + vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT; + vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEXT" ) ); + vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnableEXT" ) ); + if ( !vkCmdSetPrimitiveRestartEnable ) + vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) ); + vkGetPhysicalDeviceScreenPresentationSupportQNX = + PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) ); +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_color_write_enable === + vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteEnableEXT" ) ); + + //=== VK_KHR_ray_tracing_maintenance1 === + vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirect2KHR" ) ); + + //=== VK_EXT_multi_draw === + vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiEXT" ) ); + vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiIndexedEXT" ) ); + + //=== VK_EXT_opacity_micromap === + vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetInstanceProcAddr( instance, "vkCreateMicromapEXT" ) ); + vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetInstanceProcAddr( instance, "vkDestroyMicromapEXT" ) ); + vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkCmdBuildMicromapsEXT" ) ); + vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkBuildMicromapsEXT" ) ); + vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapEXT" ) ); + vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapToMemoryEXT" ) ); + vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMemoryToMicromapEXT" ) ); + vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkWriteMicromapsPropertiesEXT" ) ); + vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapEXT" ) ); + vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapToMemoryEXT" ) ); + vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToMicromapEXT" ) ); + vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkCmdWriteMicromapsPropertiesEXT" ) ); + vkGetDeviceMicromapCompatibilityEXT = + PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceMicromapCompatibilityEXT" ) ); + vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetInstanceProcAddr( instance, "vkGetMicromapBuildSizesEXT" ) ); + + //=== VK_HUAWEI_cluster_culling_shader === + vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdDrawClusterHUAWEI" ) ); + vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdDrawClusterIndirectHUAWEI" ) ); + + //=== VK_EXT_pageable_device_local_memory === + vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetInstanceProcAddr( instance, "vkSetDeviceMemoryPriorityEXT" ) ); + + //=== VK_KHR_maintenance4 === + vkGetDeviceBufferMemoryRequirementsKHR = + PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirementsKHR" ) ); + if ( !vkGetDeviceBufferMemoryRequirements ) + vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR; + vkGetDeviceImageMemoryRequirementsKHR = + PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirementsKHR" ) ); + if ( !vkGetDeviceImageMemoryRequirements ) + vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR; + vkGetDeviceImageSparseMemoryRequirementsKHR = + PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) ); + if ( !vkGetDeviceImageSparseMemoryRequirements ) + vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR; + + //=== VK_VALVE_descriptor_set_host_mapping === + vkGetDescriptorSetLayoutHostMappingInfoVALVE = + PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) ); + vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetHostMappingVALVE" ) ); + + //=== VK_NV_copy_memory_indirect === + vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryIndirectNV" ) ); + vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToImageIndirectNV" ) ); + + //=== VK_NV_memory_decompression === + vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryNV" ) ); + vkCmdDecompressMemoryIndirectCountNV = + PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryIndirectCountNV" ) ); + + //=== VK_NV_device_generated_commands_compute === + vkGetPipelineIndirectMemoryRequirementsNV = + PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetPipelineIndirectMemoryRequirementsNV" ) ); + vkCmdUpdatePipelineIndirectBufferNV = + PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetInstanceProcAddr( instance, "vkCmdUpdatePipelineIndirectBufferNV" ) ); + vkGetPipelineIndirectDeviceAddressNV = + PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetInstanceProcAddr( instance, "vkGetPipelineIndirectDeviceAddressNV" ) ); + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + vkGetNativeBufferPropertiesOHOS = PFN_vkGetNativeBufferPropertiesOHOS( vkGetInstanceProcAddr( instance, "vkGetNativeBufferPropertiesOHOS" ) ); + vkGetMemoryNativeBufferOHOS = PFN_vkGetMemoryNativeBufferOHOS( vkGetInstanceProcAddr( instance, "vkGetMemoryNativeBufferOHOS" ) ); +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_extended_dynamic_state3 === + vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClampEnableEXT" ) ); + vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPolygonModeEXT" ) ); + vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationSamplesEXT" ) ); + vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleMaskEXT" ) ); + vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToCoverageEnableEXT" ) ); + vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToOneEnableEXT" ) ); + vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEnableEXT" ) ); + vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEnableEXT" ) ); + vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEquationEXT" ) ); + vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteMaskEXT" ) ); + vkCmdSetTessellationDomainOriginEXT = + PFN_vkCmdSetTessellationDomainOriginEXT( vkGetInstanceProcAddr( instance, "vkCmdSetTessellationDomainOriginEXT" ) ); + vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationStreamEXT" ) ); + vkCmdSetConservativeRasterizationModeEXT = + PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetConservativeRasterizationModeEXT" ) ); + vkCmdSetExtraPrimitiveOverestimationSizeEXT = + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) ); + vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipEnableEXT" ) ); + vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEnableEXT" ) ); + vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendAdvancedEXT" ) ); + vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetProvokingVertexModeEXT" ) ); + vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineRasterizationModeEXT" ) ); + vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEnableEXT" ) ); + vkCmdSetDepthClipNegativeOneToOneEXT = + PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipNegativeOneToOneEXT" ) ); + vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingEnableNV" ) ); + vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportSwizzleNV" ) ); + vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorEnableNV" ) ); + vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorLocationNV" ) ); + vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationModeNV" ) ); + vkCmdSetCoverageModulationTableEnableNV = + PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableEnableNV" ) ); + vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableNV" ) ); + vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetShadingRateImageEnableNV" ) ); + vkCmdSetRepresentativeFragmentTestEnableNV = + PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetRepresentativeFragmentTestEnableNV" ) ); + vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageReductionModeNV" ) ); + + //=== VK_ARM_tensors === + vkCreateTensorARM = PFN_vkCreateTensorARM( vkGetInstanceProcAddr( instance, "vkCreateTensorARM" ) ); + vkDestroyTensorARM = PFN_vkDestroyTensorARM( vkGetInstanceProcAddr( instance, "vkDestroyTensorARM" ) ); + vkCreateTensorViewARM = PFN_vkCreateTensorViewARM( vkGetInstanceProcAddr( instance, "vkCreateTensorViewARM" ) ); + vkDestroyTensorViewARM = PFN_vkDestroyTensorViewARM( vkGetInstanceProcAddr( instance, "vkDestroyTensorViewARM" ) ); + vkGetTensorMemoryRequirementsARM = PFN_vkGetTensorMemoryRequirementsARM( vkGetInstanceProcAddr( instance, "vkGetTensorMemoryRequirementsARM" ) ); + vkBindTensorMemoryARM = PFN_vkBindTensorMemoryARM( vkGetInstanceProcAddr( instance, "vkBindTensorMemoryARM" ) ); + vkGetDeviceTensorMemoryRequirementsARM = + PFN_vkGetDeviceTensorMemoryRequirementsARM( vkGetInstanceProcAddr( instance, "vkGetDeviceTensorMemoryRequirementsARM" ) ); + vkCmdCopyTensorARM = PFN_vkCmdCopyTensorARM( vkGetInstanceProcAddr( instance, "vkCmdCopyTensorARM" ) ); + vkGetPhysicalDeviceExternalTensorPropertiesARM = + PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalTensorPropertiesARM" ) ); + vkGetTensorOpaqueCaptureDescriptorDataARM = + PFN_vkGetTensorOpaqueCaptureDescriptorDataARM( vkGetInstanceProcAddr( instance, "vkGetTensorOpaqueCaptureDescriptorDataARM" ) ); + vkGetTensorViewOpaqueCaptureDescriptorDataARM = + PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM( vkGetInstanceProcAddr( instance, "vkGetTensorViewOpaqueCaptureDescriptorDataARM" ) ); + + //=== VK_EXT_shader_module_identifier === + vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleIdentifierEXT" ) ); + vkGetShaderModuleCreateInfoIdentifierEXT = + PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleCreateInfoIdentifierEXT" ) ); + + //=== VK_NV_optical_flow === + vkGetPhysicalDeviceOpticalFlowImageFormatsNV = + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV" ) ); + vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkCreateOpticalFlowSessionNV" ) ); + vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkDestroyOpticalFlowSessionNV" ) ); + vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetInstanceProcAddr( instance, "vkBindOpticalFlowSessionImageNV" ) ); + vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetInstanceProcAddr( instance, "vkCmdOpticalFlowExecuteNV" ) ); + + //=== VK_KHR_maintenance5 === + vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer2KHR" ) ); + if ( !vkCmdBindIndexBuffer2 ) + vkCmdBindIndexBuffer2 = vkCmdBindIndexBuffer2KHR; + vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetInstanceProcAddr( instance, "vkGetRenderingAreaGranularityKHR" ) ); + if ( !vkGetRenderingAreaGranularity ) + vkGetRenderingAreaGranularity = vkGetRenderingAreaGranularityKHR; + vkGetDeviceImageSubresourceLayoutKHR = + PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSubresourceLayoutKHR" ) ); + if ( !vkGetDeviceImageSubresourceLayout ) + vkGetDeviceImageSubresourceLayout = vkGetDeviceImageSubresourceLayoutKHR; + vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2KHR" ) ); + if ( !vkGetImageSubresourceLayout2 ) + vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2KHR; + + //=== VK_AMD_anti_lag === + vkAntiLagUpdateAMD = PFN_vkAntiLagUpdateAMD( vkGetInstanceProcAddr( instance, "vkAntiLagUpdateAMD" ) ); + + //=== VK_KHR_present_wait2 === + vkWaitForPresent2KHR = PFN_vkWaitForPresent2KHR( vkGetInstanceProcAddr( instance, "vkWaitForPresent2KHR" ) ); + + //=== VK_EXT_shader_object === + vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetInstanceProcAddr( instance, "vkCreateShadersEXT" ) ); + vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetInstanceProcAddr( instance, "vkDestroyShaderEXT" ) ); + vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetInstanceProcAddr( instance, "vkGetShaderBinaryDataEXT" ) ); + vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindShadersEXT" ) ); + vkCmdSetDepthClampRangeEXT = PFN_vkCmdSetDepthClampRangeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClampRangeEXT" ) ); + + //=== VK_KHR_pipeline_binary === + vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetInstanceProcAddr( instance, "vkCreatePipelineBinariesKHR" ) ); + vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetInstanceProcAddr( instance, "vkDestroyPipelineBinaryKHR" ) ); + vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineKeyKHR" ) ); + vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineBinaryDataKHR" ) ); + vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetInstanceProcAddr( instance, "vkReleaseCapturedPipelineDataKHR" ) ); + + //=== VK_QCOM_tile_properties === + vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetFramebufferTilePropertiesQCOM" ) ); + vkGetDynamicRenderingTilePropertiesQCOM = + PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetDynamicRenderingTilePropertiesQCOM" ) ); + + //=== VK_KHR_swapchain_maintenance1 === + vkReleaseSwapchainImagesKHR = PFN_vkReleaseSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkReleaseSwapchainImagesKHR" ) ); + + //=== VK_NV_cooperative_vector === + vkGetPhysicalDeviceCooperativeVectorPropertiesNV = + PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV" ) ); + vkConvertCooperativeVectorMatrixNV = PFN_vkConvertCooperativeVectorMatrixNV( vkGetInstanceProcAddr( instance, "vkConvertCooperativeVectorMatrixNV" ) ); + vkCmdConvertCooperativeVectorMatrixNV = + PFN_vkCmdConvertCooperativeVectorMatrixNV( vkGetInstanceProcAddr( instance, "vkCmdConvertCooperativeVectorMatrixNV" ) ); + + //=== VK_NV_low_latency2 === + vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetInstanceProcAddr( instance, "vkSetLatencySleepModeNV" ) ); + vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetInstanceProcAddr( instance, "vkLatencySleepNV" ) ); + vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetInstanceProcAddr( instance, "vkSetLatencyMarkerNV" ) ); + vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetInstanceProcAddr( instance, "vkGetLatencyTimingsNV" ) ); + vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetInstanceProcAddr( instance, "vkQueueNotifyOutOfBandNV" ) ); + + //=== VK_KHR_cooperative_matrix === + vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR" ) ); + + //=== VK_ARM_data_graph === + vkCreateDataGraphPipelinesARM = PFN_vkCreateDataGraphPipelinesARM( vkGetInstanceProcAddr( instance, "vkCreateDataGraphPipelinesARM" ) ); + vkCreateDataGraphPipelineSessionARM = + PFN_vkCreateDataGraphPipelineSessionARM( vkGetInstanceProcAddr( instance, "vkCreateDataGraphPipelineSessionARM" ) ); + vkGetDataGraphPipelineSessionBindPointRequirementsARM = PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM( + vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelineSessionBindPointRequirementsARM" ) ); + vkGetDataGraphPipelineSessionMemoryRequirementsARM = + PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM( vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelineSessionMemoryRequirementsARM" ) ); + vkBindDataGraphPipelineSessionMemoryARM = + PFN_vkBindDataGraphPipelineSessionMemoryARM( vkGetInstanceProcAddr( instance, "vkBindDataGraphPipelineSessionMemoryARM" ) ); + vkDestroyDataGraphPipelineSessionARM = + PFN_vkDestroyDataGraphPipelineSessionARM( vkGetInstanceProcAddr( instance, "vkDestroyDataGraphPipelineSessionARM" ) ); + vkCmdDispatchDataGraphARM = PFN_vkCmdDispatchDataGraphARM( vkGetInstanceProcAddr( instance, "vkCmdDispatchDataGraphARM" ) ); + vkGetDataGraphPipelineAvailablePropertiesARM = + PFN_vkGetDataGraphPipelineAvailablePropertiesARM( vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelineAvailablePropertiesARM" ) ); + vkGetDataGraphPipelinePropertiesARM = + PFN_vkGetDataGraphPipelinePropertiesARM( vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelinePropertiesARM" ) ); + vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = + PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM" ) ); + vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM" ) ); + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + vkCmdSetAttachmentFeedbackLoopEnableEXT = + PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) ); + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetInstanceProcAddr( instance, "vkGetScreenBufferPropertiesQNX" ) ); +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_KHR_line_rasterization === + vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleKHR" ) ); + if ( !vkCmdSetLineStipple ) + vkCmdSetLineStipple = vkCmdSetLineStippleKHR; + + //=== VK_KHR_calibrated_timestamps === + vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) ); + vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsKHR" ) ); + + //=== VK_KHR_maintenance6 === + vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets2KHR" ) ); + if ( !vkCmdBindDescriptorSets2 ) + vkCmdBindDescriptorSets2 = vkCmdBindDescriptorSets2KHR; + vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushConstants2KHR" ) ); + if ( !vkCmdPushConstants2 ) + vkCmdPushConstants2 = vkCmdPushConstants2KHR; + vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSet2KHR" ) ); + if ( !vkCmdPushDescriptorSet2 ) + vkCmdPushDescriptorSet2 = vkCmdPushDescriptorSet2KHR; + vkCmdPushDescriptorSetWithTemplate2KHR = + PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplate2KHR" ) ); + if ( !vkCmdPushDescriptorSetWithTemplate2 ) + vkCmdPushDescriptorSetWithTemplate2 = vkCmdPushDescriptorSetWithTemplate2KHR; + vkCmdSetDescriptorBufferOffsets2EXT = + PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetInstanceProcAddr( instance, "vkCmdSetDescriptorBufferOffsets2EXT" ) ); + vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = + PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); + + //=== VK_QCOM_tile_memory_heap === + vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetInstanceProcAddr( instance, "vkCmdBindTileMemoryQCOM" ) ); + + //=== VK_KHR_copy_memory_indirect === + vkCmdCopyMemoryIndirectKHR = PFN_vkCmdCopyMemoryIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryIndirectKHR" ) ); + vkCmdCopyMemoryToImageIndirectKHR = PFN_vkCmdCopyMemoryToImageIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToImageIndirectKHR" ) ); + + //=== VK_EXT_memory_decompression === + vkCmdDecompressMemoryEXT = PFN_vkCmdDecompressMemoryEXT( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryEXT" ) ); + vkCmdDecompressMemoryIndirectCountEXT = + PFN_vkCmdDecompressMemoryIndirectCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryIndirectCountEXT" ) ); + + //=== VK_NV_external_compute_queue === + vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkCreateExternalComputeQueueNV" ) ); + vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkDestroyExternalComputeQueueNV" ) ); + vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetInstanceProcAddr( instance, "vkGetExternalComputeQueueDataNV" ) ); + + //=== VK_NV_cluster_acceleration_structure === + vkGetClusterAccelerationStructureBuildSizesNV = + PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetInstanceProcAddr( instance, "vkGetClusterAccelerationStructureBuildSizesNV" ) ); + vkCmdBuildClusterAccelerationStructureIndirectNV = + PFN_vkCmdBuildClusterAccelerationStructureIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdBuildClusterAccelerationStructureIndirectNV" ) ); + + //=== VK_NV_partitioned_acceleration_structure === + vkGetPartitionedAccelerationStructuresBuildSizesNV = + PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV( vkGetInstanceProcAddr( instance, "vkGetPartitionedAccelerationStructuresBuildSizesNV" ) ); + vkCmdBuildPartitionedAccelerationStructuresNV = + PFN_vkCmdBuildPartitionedAccelerationStructuresNV( vkGetInstanceProcAddr( instance, "vkCmdBuildPartitionedAccelerationStructuresNV" ) ); + + //=== VK_EXT_device_generated_commands === + vkGetGeneratedCommandsMemoryRequirementsEXT = + PFN_vkGetGeneratedCommandsMemoryRequirementsEXT( vkGetInstanceProcAddr( instance, "vkGetGeneratedCommandsMemoryRequirementsEXT" ) ); + vkCmdPreprocessGeneratedCommandsEXT = + PFN_vkCmdPreprocessGeneratedCommandsEXT( vkGetInstanceProcAddr( instance, "vkCmdPreprocessGeneratedCommandsEXT" ) ); + vkCmdExecuteGeneratedCommandsEXT = PFN_vkCmdExecuteGeneratedCommandsEXT( vkGetInstanceProcAddr( instance, "vkCmdExecuteGeneratedCommandsEXT" ) ); + vkCreateIndirectCommandsLayoutEXT = PFN_vkCreateIndirectCommandsLayoutEXT( vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutEXT" ) ); + vkDestroyIndirectCommandsLayoutEXT = PFN_vkDestroyIndirectCommandsLayoutEXT( vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutEXT" ) ); + vkCreateIndirectExecutionSetEXT = PFN_vkCreateIndirectExecutionSetEXT( vkGetInstanceProcAddr( instance, "vkCreateIndirectExecutionSetEXT" ) ); + vkDestroyIndirectExecutionSetEXT = PFN_vkDestroyIndirectExecutionSetEXT( vkGetInstanceProcAddr( instance, "vkDestroyIndirectExecutionSetEXT" ) ); + vkUpdateIndirectExecutionSetPipelineEXT = + PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetInstanceProcAddr( instance, "vkUpdateIndirectExecutionSetPipelineEXT" ) ); + vkUpdateIndirectExecutionSetShaderEXT = + PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetInstanceProcAddr( instance, "vkUpdateIndirectExecutionSetShaderEXT" ) ); + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + vkCreateSurfaceOHOS = PFN_vkCreateSurfaceOHOS( vkGetInstanceProcAddr( instance, "vkCreateSurfaceOHOS" ) ); +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_NV_cooperative_matrix2 === + vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV" ) ); + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryMetalHandleEXT" ) ); + vkGetMemoryMetalHandlePropertiesEXT = + PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryMetalHandlePropertiesEXT" ) ); +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_ARM_performance_counters_by_region === + vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( + vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM" ) ); + + //=== VK_EXT_fragment_density_map_offset === + vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetInstanceProcAddr( instance, "vkCmdEndRendering2EXT" ) ); + if ( !vkCmdEndRendering2KHR ) + vkCmdEndRendering2KHR = vkCmdEndRendering2EXT; + + //=== VK_EXT_custom_resolve === + vkCmdBeginCustomResolveEXT = PFN_vkCmdBeginCustomResolveEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginCustomResolveEXT" ) ); + + //=== VK_KHR_maintenance10 === + vkCmdEndRendering2KHR = PFN_vkCmdEndRendering2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRendering2KHR" ) ); + + //=== VK_NV_compute_occupancy_priority === + vkCmdSetComputeOccupancyPriorityNV = PFN_vkCmdSetComputeOccupancyPriorityNV( vkGetInstanceProcAddr( instance, "vkCmdSetComputeOccupancyPriorityNV" ) ); + } + + void init( Device deviceCpp ) VULKAN_HPP_NOEXCEPT + { + VkDevice device = static_cast( deviceCpp ); + + //=== VK_VERSION_1_0 === + vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) ); + vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) ); + vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) ); + vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) ); + vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) ); + vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) ); + vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) ); + vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) ); + vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) ); + vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) ); + vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) ); + vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) ); + vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) ); + vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) ); + vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) ); + vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) ); + vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) ); + vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) ); + vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) ); + vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) ); + vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) ); + vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) ); + vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) ); + vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) ); + vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) ); + vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) ); + vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) ); + vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) ); + vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) ); + vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) ); + vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) ); + vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) ); + vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) ); + vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) ); + vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) ); + vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) ); + vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) ); + vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) ); + vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) ); + vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) ); + vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) ); + vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) ); + vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) ); + vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) ); + vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) ); + vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) ); + vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) ); + vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) ); + vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) ); + vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) ); + vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) ); + vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) ); + vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) ); + vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) ); + vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) ); + vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) ); + vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) ); + vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) ); + vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) ); + vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) ); + vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) ); + vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) ); + vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) ); + vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) ); + vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) ); + vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) ); + vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) ); + vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) ); + vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) ); + vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) ); + vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) ); + vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) ); + vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) ); + vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) ); + vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) ); + vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) ); + vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) ); + vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) ); + vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) ); + vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) ); + vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) ); + vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) ); + vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) ); + vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) ); + vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) ); + vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) ); + vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) ); + vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) ); + vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) ); + vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) ); + vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) ); + vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) ); + vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) ); + vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) ); + vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) ); + vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) ); + vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) ); + vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) ); + vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) ); + vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) ); + vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) ); + vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) ); + vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) ); + vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) ); + vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) ); + vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) ); + vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) ); + vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) ); + vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) ); + vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) ); + vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) ); + vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) ); + vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) ); + vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) ); + vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) ); + vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) ); + vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) ); + vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) ); + vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) ); + vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) ); + vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) ); + + //=== VK_VERSION_1_1 === + vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) ); + vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) ); + vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) ); + vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) ); + vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) ); + vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) ); + vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) ); + vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) ); + vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) ); + vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) ); + vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) ); + vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) ); + vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) ); + vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) ); + vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) ); + vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) ); + + //=== VK_VERSION_1_2 === + vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) ); + vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) ); + vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) ); + vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) ); + vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) ); + vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) ); + vkGetDeviceMemoryOpaqueCaptureAddress = + PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) ); + vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) ); + vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) ); + vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) ); + vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) ); + vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) ); + vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) ); + + //=== VK_VERSION_1_3 === + vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) ); + vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) ); + vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) ); + vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) ); + vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) ); + vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) ); + vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) ); + vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) ); + vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) ); + vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) ); + vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) ); + vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) ); + vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) ); + vkGetDeviceImageSparseMemoryRequirements = + PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) ); + vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) ); + vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) ); + vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) ); + vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) ); + vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) ); + vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) ); + vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) ); + vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) ); + vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) ); + vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) ); + vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) ); + vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) ); + vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) ); + vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) ); + vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) ); + vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) ); + vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) ); + vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) ); + vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) ); + vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) ); + vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) ); + vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) ); + + //=== VK_VERSION_1_4 === + vkMapMemory2 = PFN_vkMapMemory2( vkGetDeviceProcAddr( device, "vkMapMemory2" ) ); + vkUnmapMemory2 = PFN_vkUnmapMemory2( vkGetDeviceProcAddr( device, "vkUnmapMemory2" ) ); + vkGetDeviceImageSubresourceLayout = PFN_vkGetDeviceImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayout" ) ); + vkGetImageSubresourceLayout2 = PFN_vkGetImageSubresourceLayout2( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2" ) ); + vkCopyMemoryToImage = PFN_vkCopyMemoryToImage( vkGetDeviceProcAddr( device, "vkCopyMemoryToImage" ) ); + vkCopyImageToMemory = PFN_vkCopyImageToMemory( vkGetDeviceProcAddr( device, "vkCopyImageToMemory" ) ); + vkCopyImageToImage = PFN_vkCopyImageToImage( vkGetDeviceProcAddr( device, "vkCopyImageToImage" ) ); + vkTransitionImageLayout = PFN_vkTransitionImageLayout( vkGetDeviceProcAddr( device, "vkTransitionImageLayout" ) ); + vkCmdPushDescriptorSet = PFN_vkCmdPushDescriptorSet( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet" ) ); + vkCmdPushDescriptorSetWithTemplate = PFN_vkCmdPushDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate" ) ); + vkCmdBindDescriptorSets2 = PFN_vkCmdBindDescriptorSets2( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2" ) ); + vkCmdPushConstants2 = PFN_vkCmdPushConstants2( vkGetDeviceProcAddr( device, "vkCmdPushConstants2" ) ); + vkCmdPushDescriptorSet2 = PFN_vkCmdPushDescriptorSet2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2" ) ); + vkCmdPushDescriptorSetWithTemplate2 = PFN_vkCmdPushDescriptorSetWithTemplate2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2" ) ); + vkCmdSetLineStipple = PFN_vkCmdSetLineStipple( vkGetDeviceProcAddr( device, "vkCmdSetLineStipple" ) ); + vkCmdBindIndexBuffer2 = PFN_vkCmdBindIndexBuffer2( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2" ) ); + vkGetRenderingAreaGranularity = PFN_vkGetRenderingAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularity" ) ); + vkCmdSetRenderingAttachmentLocations = + PFN_vkCmdSetRenderingAttachmentLocations( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocations" ) ); + vkCmdSetRenderingInputAttachmentIndices = + PFN_vkCmdSetRenderingInputAttachmentIndices( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndices" ) ); + + //=== VK_KHR_swapchain === + vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) ); + vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) ); + vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) ); + vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) ); + vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) ); + vkGetDeviceGroupPresentCapabilitiesKHR = + PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); + vkGetDeviceGroupSurfacePresentModesKHR = + PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); + vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) ); + + //=== VK_KHR_display_swapchain === + vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) ); + + //=== VK_EXT_debug_marker === + vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) ); + vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) ); + vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) ); + vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) ); + vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) ); + + //=== VK_KHR_video_queue === + vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) ); + vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) ); + vkGetVideoSessionMemoryRequirementsKHR = + PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) ); + vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) ); + vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) ); + vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) ); + vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) ); + vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) ); + vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) ); + vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) ); + + //=== VK_KHR_video_decode_queue === + vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) ); + + //=== VK_EXT_transform_feedback === + vkCmdBindTransformFeedbackBuffersEXT = + PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) ); + vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) ); + vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) ); + vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) ); + vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) ); + vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) ); + + //=== VK_NVX_binary_import === + vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) ); + vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) ); + vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) ); + vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) ); + vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) ); + + //=== VK_NVX_image_view_handle === + vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) ); + vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandle64NVX" ) ); + vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) ); + vkGetDeviceCombinedImageSamplerIndexNVX = + PFN_vkGetDeviceCombinedImageSamplerIndexNVX( vkGetDeviceProcAddr( device, "vkGetDeviceCombinedImageSamplerIndexNVX" ) ); + + //=== VK_AMD_draw_indirect_count === + vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) ); + if ( !vkCmdDrawIndirectCount ) + vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; + vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) ); + if ( !vkCmdDrawIndexedIndirectCount ) + vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; + + //=== VK_AMD_shader_info === + vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) ); + + //=== VK_KHR_dynamic_rendering === + vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) ); + if ( !vkCmdBeginRendering ) + vkCmdBeginRendering = vkCmdBeginRenderingKHR; + vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) ); + if ( !vkCmdEndRendering ) + vkCmdEndRendering = vkCmdEndRenderingKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_device_group === + vkGetDeviceGroupPeerMemoryFeaturesKHR = + PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); + if ( !vkGetDeviceGroupPeerMemoryFeatures ) + vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; + vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) ); + if ( !vkCmdSetDeviceMask ) + vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; + vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) ); + if ( !vkCmdDispatchBase ) + vkCmdDispatchBase = vkCmdDispatchBaseKHR; + + //=== VK_KHR_maintenance1 === + vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) ); + if ( !vkTrimCommandPool ) + vkTrimCommandPool = vkTrimCommandPoolKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) ); + vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) ); + vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) ); + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) ); + vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) ); + vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) ); + + //=== VK_KHR_push_descriptor === + vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) ); + if ( !vkCmdPushDescriptorSet ) + vkCmdPushDescriptorSet = vkCmdPushDescriptorSetKHR; + vkCmdPushDescriptorSetWithTemplateKHR = + PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) ); + if ( !vkCmdPushDescriptorSetWithTemplate ) + vkCmdPushDescriptorSetWithTemplate = vkCmdPushDescriptorSetWithTemplateKHR; + + //=== VK_EXT_conditional_rendering === + vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) ); + vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) ); + + //=== VK_KHR_descriptor_update_template === + vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) ); + if ( !vkCreateDescriptorUpdateTemplate ) + vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; + vkDestroyDescriptorUpdateTemplateKHR = + PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) ); + if ( !vkDestroyDescriptorUpdateTemplate ) + vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; + vkUpdateDescriptorSetWithTemplateKHR = + PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) ); + if ( !vkUpdateDescriptorSetWithTemplate ) + vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; + + //=== VK_NV_clip_space_w_scaling === + vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) ); + + //=== VK_EXT_display_control === + vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) ); + vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) ); + vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) ); + vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) ); + + //=== VK_GOOGLE_display_timing === + vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) ); + vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) ); + + //=== VK_EXT_discard_rectangles === + vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) ); + vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEnableEXT" ) ); + vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleModeEXT" ) ); + + //=== VK_EXT_hdr_metadata === + vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) ); + + //=== VK_KHR_create_renderpass2 === + vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) ); + if ( !vkCreateRenderPass2 ) + vkCreateRenderPass2 = vkCreateRenderPass2KHR; + vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) ); + if ( !vkCmdBeginRenderPass2 ) + vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; + vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) ); + if ( !vkCmdNextSubpass2 ) + vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; + vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) ); + if ( !vkCmdEndRenderPass2 ) + vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; + + //=== VK_KHR_shared_presentable_image === + vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) ); + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) ); + vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) ); + vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) ); + + //=== VK_KHR_performance_query === + vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) ); + vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) ); + + //=== VK_EXT_debug_utils === + vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) ); + vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) ); + vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) ); + vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) ); + vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) ); + vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) ); + vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) ); + vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) ); + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + vkGetAndroidHardwareBufferPropertiesANDROID = + PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) ); + vkGetMemoryAndroidHardwareBufferANDROID = + PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + vkCreateExecutionGraphPipelinesAMDX = PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetDeviceProcAddr( device, "vkCreateExecutionGraphPipelinesAMDX" ) ); + vkGetExecutionGraphPipelineScratchSizeAMDX = + PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) ); + vkGetExecutionGraphPipelineNodeIndexAMDX = + PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) ); + vkCmdInitializeGraphScratchMemoryAMDX = + PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetDeviceProcAddr( device, "vkCmdInitializeGraphScratchMemoryAMDX" ) ); + vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphAMDX" ) ); + vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectAMDX" ) ); + vkCmdDispatchGraphIndirectCountAMDX = PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectCountAMDX" ) ); +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + vkWriteSamplerDescriptorsEXT = PFN_vkWriteSamplerDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteSamplerDescriptorsEXT" ) ); + vkWriteResourceDescriptorsEXT = PFN_vkWriteResourceDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteResourceDescriptorsEXT" ) ); + vkCmdBindSamplerHeapEXT = PFN_vkCmdBindSamplerHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindSamplerHeapEXT" ) ); + vkCmdBindResourceHeapEXT = PFN_vkCmdBindResourceHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindResourceHeapEXT" ) ); + vkCmdPushDataEXT = PFN_vkCmdPushDataEXT( vkGetDeviceProcAddr( device, "vkCmdPushDataEXT" ) ); + vkGetImageOpaqueCaptureDataEXT = PFN_vkGetImageOpaqueCaptureDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDataEXT" ) ); + vkRegisterCustomBorderColorEXT = PFN_vkRegisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkRegisterCustomBorderColorEXT" ) ); + vkUnregisterCustomBorderColorEXT = PFN_vkUnregisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkUnregisterCustomBorderColorEXT" ) ); + vkGetTensorOpaqueCaptureDataARM = PFN_vkGetTensorOpaqueCaptureDataARM( vkGetDeviceProcAddr( device, "vkGetTensorOpaqueCaptureDataARM" ) ); + + //=== VK_EXT_sample_locations === + vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) ); + + //=== VK_KHR_get_memory_requirements2 === + vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) ); + if ( !vkGetImageMemoryRequirements2 ) + vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; + vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) ); + if ( !vkGetBufferMemoryRequirements2 ) + vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; + vkGetImageSparseMemoryRequirements2KHR = + PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) ); + if ( !vkGetImageSparseMemoryRequirements2 ) + vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; + + //=== VK_KHR_acceleration_structure === + vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) ); + vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) ); + vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) ); + vkCmdBuildAccelerationStructuresIndirectKHR = + PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) ); + vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) ); + vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) ); + vkCopyAccelerationStructureToMemoryKHR = + PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) ); + vkCopyMemoryToAccelerationStructureKHR = + PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) ); + vkWriteAccelerationStructuresPropertiesKHR = + PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) ); + vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) ); + vkCmdCopyAccelerationStructureToMemoryKHR = + PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) ); + vkCmdCopyMemoryToAccelerationStructureKHR = + PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) ); + vkGetAccelerationStructureDeviceAddressKHR = + PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) ); + vkCmdWriteAccelerationStructuresPropertiesKHR = + PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) ); + vkGetDeviceAccelerationStructureCompatibilityKHR = + PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) ); + vkGetAccelerationStructureBuildSizesKHR = + PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) ); + + //=== VK_KHR_ray_tracing_pipeline === + vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) ); + vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) ); + vkGetRayTracingShaderGroupHandlesKHR = + PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) ); + vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = + PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) ); + vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) ); + vkGetRayTracingShaderGroupStackSizeKHR = + PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) ); + vkCmdSetRayTracingPipelineStackSizeKHR = + PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); + + //=== VK_KHR_sampler_ycbcr_conversion === + vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) ); + if ( !vkCreateSamplerYcbcrConversion ) + vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; + vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) ); + if ( !vkDestroySamplerYcbcrConversion ) + vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; + + //=== VK_KHR_bind_memory2 === + vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) ); + if ( !vkBindBufferMemory2 ) + vkBindBufferMemory2 = vkBindBufferMemory2KHR; + vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) ); + if ( !vkBindImageMemory2 ) + vkBindImageMemory2 = vkBindImageMemory2KHR; + + //=== VK_EXT_image_drm_format_modifier === + vkGetImageDrmFormatModifierPropertiesEXT = + PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) ); + + //=== VK_EXT_validation_cache === + vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) ); + vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) ); + vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) ); + vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) ); + + //=== VK_NV_shading_rate_image === + vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) ); + vkCmdSetViewportShadingRatePaletteNV = + PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) ); + vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) ); + + //=== VK_NV_ray_tracing === + vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) ); + vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) ); + vkGetAccelerationStructureMemoryRequirementsNV = + PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) ); + vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) ); + vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) ); + vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) ); + vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) ); + vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) ); + vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) ); + if ( !vkGetRayTracingShaderGroupHandlesKHR ) + vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; + vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) ); + vkCmdWriteAccelerationStructuresPropertiesNV = + PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) ); + vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) ); + + //=== VK_KHR_maintenance3 === + vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) ); + if ( !vkGetDescriptorSetLayoutSupport ) + vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; + + //=== VK_KHR_draw_indirect_count === + vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) ); + if ( !vkCmdDrawIndirectCount ) + vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; + vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) ); + if ( !vkCmdDrawIndexedIndirectCount ) + vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; + + //=== VK_EXT_external_memory_host === + vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) ); + + //=== VK_AMD_buffer_marker === + vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) ); + vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) ); + + //=== VK_EXT_calibrated_timestamps === + vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) ); + if ( !vkGetCalibratedTimestampsKHR ) + vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT; + + //=== VK_NV_mesh_shader === + vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) ); + vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) ); + vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) ); + + //=== VK_NV_scissor_exclusive === + vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorEnableNV" ) ); + vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) ); + + //=== VK_NV_device_diagnostic_checkpoints === + vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) ); + vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) ); + vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) ); + + //=== VK_KHR_timeline_semaphore === + vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) ); + if ( !vkGetSemaphoreCounterValue ) + vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; + vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) ); + if ( !vkWaitSemaphores ) + vkWaitSemaphores = vkWaitSemaphoresKHR; + vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) ); + if ( !vkSignalSemaphore ) + vkSignalSemaphore = vkSignalSemaphoreKHR; + + //=== VK_EXT_present_timing === + vkSetSwapchainPresentTimingQueueSizeEXT = + PFN_vkSetSwapchainPresentTimingQueueSizeEXT( vkGetDeviceProcAddr( device, "vkSetSwapchainPresentTimingQueueSizeEXT" ) ); + vkGetSwapchainTimingPropertiesEXT = PFN_vkGetSwapchainTimingPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimingPropertiesEXT" ) ); + vkGetSwapchainTimeDomainPropertiesEXT = + PFN_vkGetSwapchainTimeDomainPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimeDomainPropertiesEXT" ) ); + vkGetPastPresentationTimingEXT = PFN_vkGetPastPresentationTimingEXT( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingEXT" ) ); + + //=== VK_INTEL_performance_query === + vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) ); + vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) ); + vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) ); + vkCmdSetPerformanceStreamMarkerINTEL = + PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); + vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) ); + vkAcquirePerformanceConfigurationINTEL = + PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) ); + vkReleasePerformanceConfigurationINTEL = + PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) ); + vkQueueSetPerformanceConfigurationINTEL = + PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) ); + vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) ); + + //=== VK_AMD_display_native_hdr === + vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) ); + + //=== VK_KHR_fragment_shading_rate === + vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) ); + + //=== VK_KHR_dynamic_rendering_local_read === + vkCmdSetRenderingAttachmentLocationsKHR = + PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocationsKHR" ) ); + if ( !vkCmdSetRenderingAttachmentLocations ) + vkCmdSetRenderingAttachmentLocations = vkCmdSetRenderingAttachmentLocationsKHR; + vkCmdSetRenderingInputAttachmentIndicesKHR = + PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) ); + if ( !vkCmdSetRenderingInputAttachmentIndices ) + vkCmdSetRenderingInputAttachmentIndices = vkCmdSetRenderingInputAttachmentIndicesKHR; + + //=== VK_EXT_buffer_device_address === + vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) ); + if ( !vkGetBufferDeviceAddress ) + vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; + + //=== VK_KHR_present_wait === + vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) ); + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) ); + vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) ); + vkGetDeviceGroupSurfacePresentModes2EXT = + PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_buffer_device_address === + vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) ); + if ( !vkGetBufferDeviceAddress ) + vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; + vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) ); + if ( !vkGetBufferOpaqueCaptureAddress ) + vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; + vkGetDeviceMemoryOpaqueCaptureAddressKHR = + PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) ); + if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) + vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; + + //=== VK_EXT_line_rasterization === + vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) ); + if ( !vkCmdSetLineStipple ) + vkCmdSetLineStipple = vkCmdSetLineStippleEXT; + + //=== VK_EXT_host_query_reset === + vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) ); + if ( !vkResetQueryPool ) + vkResetQueryPool = vkResetQueryPoolEXT; + + //=== VK_EXT_extended_dynamic_state === + vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) ); + if ( !vkCmdSetCullMode ) + vkCmdSetCullMode = vkCmdSetCullModeEXT; + vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) ); + if ( !vkCmdSetFrontFace ) + vkCmdSetFrontFace = vkCmdSetFrontFaceEXT; + vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) ); + if ( !vkCmdSetPrimitiveTopology ) + vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT; + vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) ); + if ( !vkCmdSetViewportWithCount ) + vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT; + vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) ); + if ( !vkCmdSetScissorWithCount ) + vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT; + vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) ); + if ( !vkCmdBindVertexBuffers2 ) + vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT; + vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) ); + if ( !vkCmdSetDepthTestEnable ) + vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT; + vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) ); + if ( !vkCmdSetDepthWriteEnable ) + vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT; + vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) ); + if ( !vkCmdSetDepthCompareOp ) + vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT; + vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) ); + if ( !vkCmdSetDepthBoundsTestEnable ) + vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT; + vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) ); + if ( !vkCmdSetStencilTestEnable ) + vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT; + vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) ); + if ( !vkCmdSetStencilOp ) + vkCmdSetStencilOp = vkCmdSetStencilOpEXT; + + //=== VK_KHR_deferred_host_operations === + vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) ); + vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) ); + vkGetDeferredOperationMaxConcurrencyKHR = + PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) ); + vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) ); + vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) ); + + //=== VK_KHR_pipeline_executable_properties === + vkGetPipelineExecutablePropertiesKHR = + PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) ); + vkGetPipelineExecutableStatisticsKHR = + PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) ); + vkGetPipelineExecutableInternalRepresentationsKHR = + PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) ); + + //=== VK_EXT_host_image_copy === + vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToImageEXT" ) ); + if ( !vkCopyMemoryToImage ) + vkCopyMemoryToImage = vkCopyMemoryToImageEXT; + vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyImageToMemoryEXT" ) ); + if ( !vkCopyImageToMemory ) + vkCopyImageToMemory = vkCopyImageToMemoryEXT; + vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetDeviceProcAddr( device, "vkCopyImageToImageEXT" ) ); + if ( !vkCopyImageToImage ) + vkCopyImageToImage = vkCopyImageToImageEXT; + vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetDeviceProcAddr( device, "vkTransitionImageLayoutEXT" ) ); + if ( !vkTransitionImageLayout ) + vkTransitionImageLayout = vkTransitionImageLayoutEXT; + vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) ); + if ( !vkGetImageSubresourceLayout2 ) + vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2EXT; + + //=== VK_KHR_map_memory2 === + vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetDeviceProcAddr( device, "vkMapMemory2KHR" ) ); + if ( !vkMapMemory2 ) + vkMapMemory2 = vkMapMemory2KHR; + vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetDeviceProcAddr( device, "vkUnmapMemory2KHR" ) ); + if ( !vkUnmapMemory2 ) + vkUnmapMemory2 = vkUnmapMemory2KHR; + + //=== VK_EXT_swapchain_maintenance1 === + vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesEXT" ) ); + if ( !vkReleaseSwapchainImagesKHR ) + vkReleaseSwapchainImagesKHR = vkReleaseSwapchainImagesEXT; + + //=== VK_NV_device_generated_commands === + vkGetGeneratedCommandsMemoryRequirementsNV = + PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) ); + vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) ); + vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) ); + vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) ); + vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) ); + vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) ); + + //=== VK_EXT_depth_bias_control === + vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias2EXT" ) ); + + //=== VK_EXT_private_data === + vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) ); + if ( !vkCreatePrivateDataSlot ) + vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT; + vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) ); + if ( !vkDestroyPrivateDataSlot ) + vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT; + vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) ); + if ( !vkSetPrivateData ) + vkSetPrivateData = vkSetPrivateDataEXT; + vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) ); + if ( !vkGetPrivateData ) + vkGetPrivateData = vkGetPrivateDataEXT; + + //=== VK_KHR_video_encode_queue === + vkGetEncodedVideoSessionParametersKHR = + PFN_vkGetEncodedVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkGetEncodedVideoSessionParametersKHR" ) ); + vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) ); + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetDeviceProcAddr( device, "vkCreateCudaModuleNV" ) ); + vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetDeviceProcAddr( device, "vkGetCudaModuleCacheNV" ) ); + vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetDeviceProcAddr( device, "vkCreateCudaFunctionNV" ) ); + vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetDeviceProcAddr( device, "vkDestroyCudaModuleNV" ) ); + vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetDeviceProcAddr( device, "vkDestroyCudaFunctionNV" ) ); + vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetDeviceProcAddr( device, "vkCmdCudaLaunchKernelNV" ) ); +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + vkCmdDispatchTileQCOM = PFN_vkCmdDispatchTileQCOM( vkGetDeviceProcAddr( device, "vkCmdDispatchTileQCOM" ) ); + vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdBeginPerTileExecutionQCOM" ) ); + vkCmdEndPerTileExecutionQCOM = PFN_vkCmdEndPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdEndPerTileExecutionQCOM" ) ); + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) ); +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) ); + if ( !vkCmdSetEvent2 ) + vkCmdSetEvent2 = vkCmdSetEvent2KHR; + vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) ); + if ( !vkCmdResetEvent2 ) + vkCmdResetEvent2 = vkCmdResetEvent2KHR; + vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) ); + if ( !vkCmdWaitEvents2 ) + vkCmdWaitEvents2 = vkCmdWaitEvents2KHR; + vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) ); + if ( !vkCmdPipelineBarrier2 ) + vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR; + vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) ); + if ( !vkCmdWriteTimestamp2 ) + vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR; + vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) ); + if ( !vkQueueSubmit2 ) + vkQueueSubmit2 = vkQueueSubmit2KHR; + + //=== VK_EXT_descriptor_buffer === + vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSizeEXT" ) ); + vkGetDescriptorSetLayoutBindingOffsetEXT = + PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) ); + vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorEXT" ) ); + vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBuffersEXT" ) ); + vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsetsEXT" ) ); + vkCmdBindDescriptorBufferEmbeddedSamplersEXT = + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) ); + vkGetBufferOpaqueCaptureDescriptorDataEXT = + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) ); + vkGetImageOpaqueCaptureDescriptorDataEXT = + PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) ); + vkGetImageViewOpaqueCaptureDescriptorDataEXT = + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) ); + vkGetSamplerOpaqueCaptureDescriptorDataEXT = + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) ); + vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) ); + + //=== VK_NV_fragment_shading_rate_enums === + vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) ); + + //=== VK_EXT_mesh_shader === + vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) ); + vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) ); + vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) ); + + //=== VK_KHR_copy_commands2 === + vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) ); + if ( !vkCmdCopyBuffer2 ) + vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR; + vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) ); + if ( !vkCmdCopyImage2 ) + vkCmdCopyImage2 = vkCmdCopyImage2KHR; + vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) ); + if ( !vkCmdCopyBufferToImage2 ) + vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR; + vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) ); + if ( !vkCmdCopyImageToBuffer2 ) + vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR; + vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) ); + if ( !vkCmdBlitImage2 ) + vkCmdBlitImage2 = vkCmdBlitImage2KHR; + vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) ); + if ( !vkCmdResolveImage2 ) + vkCmdResolveImage2 = vkCmdResolveImage2KHR; + + //=== VK_EXT_device_fault === + vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) ); + + //=== VK_EXT_vertex_input_dynamic_state === + vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) ); + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) ); + vkGetMemoryZirconHandlePropertiesFUCHSIA = + PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + vkImportSemaphoreZirconHandleFUCHSIA = + PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) ); + vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) ); + vkSetBufferCollectionImageConstraintsFUCHSIA = + PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) ); + vkSetBufferCollectionBufferConstraintsFUCHSIA = + PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) ); + vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) ); + vkGetBufferCollectionPropertiesFUCHSIA = + PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = + PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) ); + vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) ); + + //=== VK_HUAWEI_invocation_mask === + vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) ); + + //=== VK_NV_external_memory_rdma === + vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) ); + + //=== VK_EXT_pipeline_properties === + vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) ); + + //=== VK_EXT_extended_dynamic_state2 === + vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) ); + vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) ); + if ( !vkCmdSetRasterizerDiscardEnable ) + vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT; + vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) ); + if ( !vkCmdSetDepthBiasEnable ) + vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT; + vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) ); + vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) ); + if ( !vkCmdSetPrimitiveRestartEnable ) + vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT; + + //=== VK_EXT_color_write_enable === + vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) ); + + //=== VK_KHR_ray_tracing_maintenance1 === + vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) ); + + //=== VK_EXT_multi_draw === + vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) ); + vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) ); + + //=== VK_EXT_opacity_micromap === + vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetDeviceProcAddr( device, "vkCreateMicromapEXT" ) ); + vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetDeviceProcAddr( device, "vkDestroyMicromapEXT" ) ); + vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkCmdBuildMicromapsEXT" ) ); + vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkBuildMicromapsEXT" ) ); + vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapEXT" ) ); + vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapToMemoryEXT" ) ); + vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToMicromapEXT" ) ); + vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkWriteMicromapsPropertiesEXT" ) ); + vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapEXT" ) ); + vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapToMemoryEXT" ) ); + vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToMicromapEXT" ) ); + vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkCmdWriteMicromapsPropertiesEXT" ) ); + vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetDeviceProcAddr( device, "vkGetDeviceMicromapCompatibilityEXT" ) ); + vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetDeviceProcAddr( device, "vkGetMicromapBuildSizesEXT" ) ); + + //=== VK_HUAWEI_cluster_culling_shader === + vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterHUAWEI" ) ); + vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterIndirectHUAWEI" ) ); + + //=== VK_EXT_pageable_device_local_memory === + vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) ); + + //=== VK_KHR_maintenance4 === + vkGetDeviceBufferMemoryRequirementsKHR = + PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) ); + if ( !vkGetDeviceBufferMemoryRequirements ) + vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR; + vkGetDeviceImageMemoryRequirementsKHR = + PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) ); + if ( !vkGetDeviceImageMemoryRequirements ) + vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR; + vkGetDeviceImageSparseMemoryRequirementsKHR = + PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) ); + if ( !vkGetDeviceImageSparseMemoryRequirements ) + vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR; + + //=== VK_VALVE_descriptor_set_host_mapping === + vkGetDescriptorSetLayoutHostMappingInfoVALVE = + PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) ); + vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetHostMappingVALVE" ) ); + + //=== VK_NV_copy_memory_indirect === + vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectNV" ) ); + vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectNV" ) ); + + //=== VK_NV_memory_decompression === + vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryNV" ) ); + vkCmdDecompressMemoryIndirectCountNV = + PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountNV" ) ); + + //=== VK_NV_device_generated_commands_compute === + vkGetPipelineIndirectMemoryRequirementsNV = + PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectMemoryRequirementsNV" ) ); + vkCmdUpdatePipelineIndirectBufferNV = PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetDeviceProcAddr( device, "vkCmdUpdatePipelineIndirectBufferNV" ) ); + vkGetPipelineIndirectDeviceAddressNV = + PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectDeviceAddressNV" ) ); + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + vkGetNativeBufferPropertiesOHOS = PFN_vkGetNativeBufferPropertiesOHOS( vkGetDeviceProcAddr( device, "vkGetNativeBufferPropertiesOHOS" ) ); + vkGetMemoryNativeBufferOHOS = PFN_vkGetMemoryNativeBufferOHOS( vkGetDeviceProcAddr( device, "vkGetMemoryNativeBufferOHOS" ) ); +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_extended_dynamic_state3 === + vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) ); + vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) ); + vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) ); + vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleMaskEXT" ) ); + vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToCoverageEnableEXT" ) ); + vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToOneEnableEXT" ) ); + vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEnableEXT" ) ); + vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) ); + vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) ); + vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) ); + vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) ); + vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) ); + vkCmdSetConservativeRasterizationModeEXT = + PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) ); + vkCmdSetExtraPrimitiveOverestimationSizeEXT = + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetDeviceProcAddr( device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) ); + vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipEnableEXT" ) ); + vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEnableEXT" ) ); + vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendAdvancedEXT" ) ); + vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetProvokingVertexModeEXT" ) ); + vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineRasterizationModeEXT" ) ); + vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEnableEXT" ) ); + vkCmdSetDepthClipNegativeOneToOneEXT = + PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipNegativeOneToOneEXT" ) ); + vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingEnableNV" ) ); + vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportSwizzleNV" ) ); + vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorEnableNV" ) ); + vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorLocationNV" ) ); + vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationModeNV" ) ); + vkCmdSetCoverageModulationTableEnableNV = + PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableEnableNV" ) ); + vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableNV" ) ); + vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetShadingRateImageEnableNV" ) ); + vkCmdSetRepresentativeFragmentTestEnableNV = + PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetRepresentativeFragmentTestEnableNV" ) ); + vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageReductionModeNV" ) ); + + //=== VK_ARM_tensors === + vkCreateTensorARM = PFN_vkCreateTensorARM( vkGetDeviceProcAddr( device, "vkCreateTensorARM" ) ); + vkDestroyTensorARM = PFN_vkDestroyTensorARM( vkGetDeviceProcAddr( device, "vkDestroyTensorARM" ) ); + vkCreateTensorViewARM = PFN_vkCreateTensorViewARM( vkGetDeviceProcAddr( device, "vkCreateTensorViewARM" ) ); + vkDestroyTensorViewARM = PFN_vkDestroyTensorViewARM( vkGetDeviceProcAddr( device, "vkDestroyTensorViewARM" ) ); + vkGetTensorMemoryRequirementsARM = PFN_vkGetTensorMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetTensorMemoryRequirementsARM" ) ); + vkBindTensorMemoryARM = PFN_vkBindTensorMemoryARM( vkGetDeviceProcAddr( device, "vkBindTensorMemoryARM" ) ); + vkGetDeviceTensorMemoryRequirementsARM = + PFN_vkGetDeviceTensorMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDeviceTensorMemoryRequirementsARM" ) ); + vkCmdCopyTensorARM = PFN_vkCmdCopyTensorARM( vkGetDeviceProcAddr( device, "vkCmdCopyTensorARM" ) ); + vkGetTensorOpaqueCaptureDescriptorDataARM = + PFN_vkGetTensorOpaqueCaptureDescriptorDataARM( vkGetDeviceProcAddr( device, "vkGetTensorOpaqueCaptureDescriptorDataARM" ) ); + vkGetTensorViewOpaqueCaptureDescriptorDataARM = + PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM( vkGetDeviceProcAddr( device, "vkGetTensorViewOpaqueCaptureDescriptorDataARM" ) ); + + //=== VK_EXT_shader_module_identifier === + vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleIdentifierEXT" ) ); + vkGetShaderModuleCreateInfoIdentifierEXT = + PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleCreateInfoIdentifierEXT" ) ); + + //=== VK_NV_optical_flow === + vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkCreateOpticalFlowSessionNV" ) ); + vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkDestroyOpticalFlowSessionNV" ) ); + vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) ); + vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) ); + + //=== VK_KHR_maintenance5 === + vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2KHR" ) ); + if ( !vkCmdBindIndexBuffer2 ) + vkCmdBindIndexBuffer2 = vkCmdBindIndexBuffer2KHR; + vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularityKHR" ) ); + if ( !vkGetRenderingAreaGranularity ) + vkGetRenderingAreaGranularity = vkGetRenderingAreaGranularityKHR; + vkGetDeviceImageSubresourceLayoutKHR = + PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayoutKHR" ) ); + if ( !vkGetDeviceImageSubresourceLayout ) + vkGetDeviceImageSubresourceLayout = vkGetDeviceImageSubresourceLayoutKHR; + vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2KHR" ) ); + if ( !vkGetImageSubresourceLayout2 ) + vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2KHR; + + //=== VK_AMD_anti_lag === + vkAntiLagUpdateAMD = PFN_vkAntiLagUpdateAMD( vkGetDeviceProcAddr( device, "vkAntiLagUpdateAMD" ) ); + + //=== VK_KHR_present_wait2 === + vkWaitForPresent2KHR = PFN_vkWaitForPresent2KHR( vkGetDeviceProcAddr( device, "vkWaitForPresent2KHR" ) ); + + //=== VK_EXT_shader_object === + vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetDeviceProcAddr( device, "vkCreateShadersEXT" ) ); + vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetDeviceProcAddr( device, "vkDestroyShaderEXT" ) ); + vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) ); + vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) ); + vkCmdSetDepthClampRangeEXT = PFN_vkCmdSetDepthClampRangeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampRangeEXT" ) ); + + //=== VK_KHR_pipeline_binary === + vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetDeviceProcAddr( device, "vkCreatePipelineBinariesKHR" ) ); + vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetDeviceProcAddr( device, "vkDestroyPipelineBinaryKHR" ) ); + vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetDeviceProcAddr( device, "vkGetPipelineKeyKHR" ) ); + vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetDeviceProcAddr( device, "vkGetPipelineBinaryDataKHR" ) ); + vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetDeviceProcAddr( device, "vkReleaseCapturedPipelineDataKHR" ) ); + + //=== VK_QCOM_tile_properties === + vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) ); + vkGetDynamicRenderingTilePropertiesQCOM = + PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) ); + + //=== VK_KHR_swapchain_maintenance1 === + vkReleaseSwapchainImagesKHR = PFN_vkReleaseSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesKHR" ) ); + + //=== VK_NV_cooperative_vector === + vkConvertCooperativeVectorMatrixNV = PFN_vkConvertCooperativeVectorMatrixNV( vkGetDeviceProcAddr( device, "vkConvertCooperativeVectorMatrixNV" ) ); + vkCmdConvertCooperativeVectorMatrixNV = + PFN_vkCmdConvertCooperativeVectorMatrixNV( vkGetDeviceProcAddr( device, "vkCmdConvertCooperativeVectorMatrixNV" ) ); + + //=== VK_NV_low_latency2 === + vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetDeviceProcAddr( device, "vkSetLatencySleepModeNV" ) ); + vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetDeviceProcAddr( device, "vkLatencySleepNV" ) ); + vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetDeviceProcAddr( device, "vkSetLatencyMarkerNV" ) ); + vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetDeviceProcAddr( device, "vkGetLatencyTimingsNV" ) ); + vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetDeviceProcAddr( device, "vkQueueNotifyOutOfBandNV" ) ); + + //=== VK_ARM_data_graph === + vkCreateDataGraphPipelinesARM = PFN_vkCreateDataGraphPipelinesARM( vkGetDeviceProcAddr( device, "vkCreateDataGraphPipelinesARM" ) ); + vkCreateDataGraphPipelineSessionARM = PFN_vkCreateDataGraphPipelineSessionARM( vkGetDeviceProcAddr( device, "vkCreateDataGraphPipelineSessionARM" ) ); + vkGetDataGraphPipelineSessionBindPointRequirementsARM = + PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineSessionBindPointRequirementsARM" ) ); + vkGetDataGraphPipelineSessionMemoryRequirementsARM = + PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineSessionMemoryRequirementsARM" ) ); + vkBindDataGraphPipelineSessionMemoryARM = + PFN_vkBindDataGraphPipelineSessionMemoryARM( vkGetDeviceProcAddr( device, "vkBindDataGraphPipelineSessionMemoryARM" ) ); + vkDestroyDataGraphPipelineSessionARM = + PFN_vkDestroyDataGraphPipelineSessionARM( vkGetDeviceProcAddr( device, "vkDestroyDataGraphPipelineSessionARM" ) ); + vkCmdDispatchDataGraphARM = PFN_vkCmdDispatchDataGraphARM( vkGetDeviceProcAddr( device, "vkCmdDispatchDataGraphARM" ) ); + vkGetDataGraphPipelineAvailablePropertiesARM = + PFN_vkGetDataGraphPipelineAvailablePropertiesARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineAvailablePropertiesARM" ) ); + vkGetDataGraphPipelinePropertiesARM = PFN_vkGetDataGraphPipelinePropertiesARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelinePropertiesARM" ) ); + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + vkCmdSetAttachmentFeedbackLoopEnableEXT = + PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) ); + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) ); +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_KHR_line_rasterization === + vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleKHR" ) ); + if ( !vkCmdSetLineStipple ) + vkCmdSetLineStipple = vkCmdSetLineStippleKHR; + + //=== VK_KHR_calibrated_timestamps === + vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) ); + + //=== VK_KHR_maintenance6 === + vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2KHR" ) ); + if ( !vkCmdBindDescriptorSets2 ) + vkCmdBindDescriptorSets2 = vkCmdBindDescriptorSets2KHR; + vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetDeviceProcAddr( device, "vkCmdPushConstants2KHR" ) ); + if ( !vkCmdPushConstants2 ) + vkCmdPushConstants2 = vkCmdPushConstants2KHR; + vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2KHR" ) ); + if ( !vkCmdPushDescriptorSet2 ) + vkCmdPushDescriptorSet2 = vkCmdPushDescriptorSet2KHR; + vkCmdPushDescriptorSetWithTemplate2KHR = + PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2KHR" ) ); + if ( !vkCmdPushDescriptorSetWithTemplate2 ) + vkCmdPushDescriptorSetWithTemplate2 = vkCmdPushDescriptorSetWithTemplate2KHR; + vkCmdSetDescriptorBufferOffsets2EXT = PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsets2EXT" ) ); + vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = + PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); + + //=== VK_QCOM_tile_memory_heap === + vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetDeviceProcAddr( device, "vkCmdBindTileMemoryQCOM" ) ); + + //=== VK_KHR_copy_memory_indirect === + vkCmdCopyMemoryIndirectKHR = PFN_vkCmdCopyMemoryIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectKHR" ) ); + vkCmdCopyMemoryToImageIndirectKHR = PFN_vkCmdCopyMemoryToImageIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectKHR" ) ); + + //=== VK_EXT_memory_decompression === + vkCmdDecompressMemoryEXT = PFN_vkCmdDecompressMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryEXT" ) ); + vkCmdDecompressMemoryIndirectCountEXT = + PFN_vkCmdDecompressMemoryIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountEXT" ) ); + + //=== VK_NV_external_compute_queue === + vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) ); + vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) ); + vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetDeviceProcAddr( device, "vkGetExternalComputeQueueDataNV" ) ); + + //=== VK_NV_cluster_acceleration_structure === + vkGetClusterAccelerationStructureBuildSizesNV = + PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetClusterAccelerationStructureBuildSizesNV" ) ); + vkCmdBuildClusterAccelerationStructureIndirectNV = + PFN_vkCmdBuildClusterAccelerationStructureIndirectNV( vkGetDeviceProcAddr( device, "vkCmdBuildClusterAccelerationStructureIndirectNV" ) ); + + //=== VK_NV_partitioned_acceleration_structure === + vkGetPartitionedAccelerationStructuresBuildSizesNV = + PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetPartitionedAccelerationStructuresBuildSizesNV" ) ); + vkCmdBuildPartitionedAccelerationStructuresNV = + PFN_vkCmdBuildPartitionedAccelerationStructuresNV( vkGetDeviceProcAddr( device, "vkCmdBuildPartitionedAccelerationStructuresNV" ) ); + + //=== VK_EXT_device_generated_commands === + vkGetGeneratedCommandsMemoryRequirementsEXT = + PFN_vkGetGeneratedCommandsMemoryRequirementsEXT( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsEXT" ) ); + vkCmdPreprocessGeneratedCommandsEXT = PFN_vkCmdPreprocessGeneratedCommandsEXT( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsEXT" ) ); + vkCmdExecuteGeneratedCommandsEXT = PFN_vkCmdExecuteGeneratedCommandsEXT( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsEXT" ) ); + vkCreateIndirectCommandsLayoutEXT = PFN_vkCreateIndirectCommandsLayoutEXT( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutEXT" ) ); + vkDestroyIndirectCommandsLayoutEXT = PFN_vkDestroyIndirectCommandsLayoutEXT( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutEXT" ) ); + vkCreateIndirectExecutionSetEXT = PFN_vkCreateIndirectExecutionSetEXT( vkGetDeviceProcAddr( device, "vkCreateIndirectExecutionSetEXT" ) ); + vkDestroyIndirectExecutionSetEXT = PFN_vkDestroyIndirectExecutionSetEXT( vkGetDeviceProcAddr( device, "vkDestroyIndirectExecutionSetEXT" ) ); + vkUpdateIndirectExecutionSetPipelineEXT = + PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetPipelineEXT" ) ); + vkUpdateIndirectExecutionSetShaderEXT = + PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetShaderEXT" ) ); + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) ); + vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) ); +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_fragment_density_map_offset === + vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdEndRendering2EXT" ) ); + if ( !vkCmdEndRendering2KHR ) + vkCmdEndRendering2KHR = vkCmdEndRendering2EXT; + + //=== VK_EXT_custom_resolve === + vkCmdBeginCustomResolveEXT = PFN_vkCmdBeginCustomResolveEXT( vkGetDeviceProcAddr( device, "vkCmdBeginCustomResolveEXT" ) ); + + //=== VK_KHR_maintenance10 === + vkCmdEndRendering2KHR = PFN_vkCmdEndRendering2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRendering2KHR" ) ); + + //=== VK_NV_compute_occupancy_priority === + vkCmdSetComputeOccupancyPriorityNV = PFN_vkCmdSetComputeOccupancyPriorityNV( vkGetDeviceProcAddr( device, "vkCmdSetComputeOccupancyPriorityNV" ) ); + } + + template + void init( Instance const & instance, Device const & device, DynamicLoader const & dl ) VULKAN_HPP_NOEXCEPT + { + PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress( "vkGetInstanceProcAddr" ); + PFN_vkGetDeviceProcAddr getDeviceProcAddr = dl.template getProcAddress( "vkGetDeviceProcAddr" ); + init( static_cast( instance ), getInstanceProcAddr, static_cast( device ), device ? getDeviceProcAddr : nullptr ); + } + + template + void init( Instance const & instance, Device const & device ) VULKAN_HPP_NOEXCEPT + { + static DynamicLoader dl; + init( instance, device, dl ); + } + }; + + } // namespace detail +} // namespace VULKAN_HPP_NAMESPACE +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_android.h b/lib/vulkan-headers/include/vulkan/vulkan_android.h new file mode 100644 index 00000000000..1d8265e87e7 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_android.h @@ -0,0 +1,159 @@ +#ifndef VULKAN_ANDROID_H_ +#define VULKAN_ANDROID_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_KHR_android_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_android_surface 1 +struct ANativeWindow; +#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 +#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" +typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; +typedef struct VkAndroidSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkAndroidSurfaceCreateFlagsKHR flags; + struct ANativeWindow* window; +} VkAndroidSurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( + VkInstance instance, + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif + + +// VK_ANDROID_external_memory_android_hardware_buffer is a preprocessor guard. Do not pass it to API calls. +#define VK_ANDROID_external_memory_android_hardware_buffer 1 +struct AHardwareBuffer; +#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 5 +#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer" +typedef struct VkAndroidHardwareBufferUsageANDROID { + VkStructureType sType; + void* pNext; + uint64_t androidHardwareBufferUsage; +} VkAndroidHardwareBufferUsageANDROID; + +typedef struct VkAndroidHardwareBufferPropertiesANDROID { + VkStructureType sType; + void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; +} VkAndroidHardwareBufferPropertiesANDROID; + +typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID { + VkStructureType sType; + void* pNext; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; +} VkAndroidHardwareBufferFormatPropertiesANDROID; + +typedef struct VkImportAndroidHardwareBufferInfoANDROID { + VkStructureType sType; + const void* pNext; + struct AHardwareBuffer* buffer; +} VkImportAndroidHardwareBufferInfoANDROID; + +typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkMemoryGetAndroidHardwareBufferInfoANDROID; + +typedef struct VkExternalFormatANDROID { + VkStructureType sType; + void* pNext; + uint64_t externalFormat; +} VkExternalFormatANDROID; + +typedef struct VkAndroidHardwareBufferFormatProperties2ANDROID { + VkStructureType sType; + void* pNext; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags2 formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; +} VkAndroidHardwareBufferFormatProperties2ANDROID; + +typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID( + VkDevice device, + const struct AHardwareBuffer* buffer, + VkAndroidHardwareBufferPropertiesANDROID* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID( + VkDevice device, + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, + struct AHardwareBuffer** pBuffer); +#endif +#endif + + +// VK_ANDROID_external_format_resolve is a preprocessor guard. Do not pass it to API calls. +#define VK_ANDROID_external_format_resolve 1 +#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION 1 +#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME "VK_ANDROID_external_format_resolve" +typedef struct VkPhysicalDeviceExternalFormatResolveFeaturesANDROID { + VkStructureType sType; + void* pNext; + VkBool32 externalFormatResolve; +} VkPhysicalDeviceExternalFormatResolveFeaturesANDROID; + +typedef struct VkPhysicalDeviceExternalFormatResolvePropertiesANDROID { + VkStructureType sType; + void* pNext; + VkBool32 nullColorAttachmentWithExternalFormatResolve; + VkChromaLocation externalFormatResolveChromaOffsetX; + VkChromaLocation externalFormatResolveChromaOffsetY; +} VkPhysicalDeviceExternalFormatResolvePropertiesANDROID; + +typedef struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID { + VkStructureType sType; + void* pNext; + VkFormat colorAttachmentFormat; +} VkAndroidHardwareBufferFormatResolvePropertiesANDROID; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_beta.h b/lib/vulkan-headers/include/vulkan/vulkan_beta.h new file mode 100644 index 00000000000..147a3f3cc1f --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_beta.h @@ -0,0 +1,375 @@ +#ifndef VULKAN_BETA_H_ +#define VULKAN_BETA_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_KHR_portability_subset is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_portability_subset 1 +#define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1 +#define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset" +typedef struct VkPhysicalDevicePortabilitySubsetFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 constantAlphaColorBlendFactors; + VkBool32 events; + VkBool32 imageViewFormatReinterpretation; + VkBool32 imageViewFormatSwizzle; + VkBool32 imageView2DOn3DImage; + VkBool32 multisampleArrayImage; + VkBool32 mutableComparisonSamplers; + VkBool32 pointPolygons; + VkBool32 samplerMipLodBias; + VkBool32 separateStencilMaskRef; + VkBool32 shaderSampleRateInterpolationFunctions; + VkBool32 tessellationIsolines; + VkBool32 tessellationPointMode; + VkBool32 triangleFans; + VkBool32 vertexAttributeAccessBeyondStride; +} VkPhysicalDevicePortabilitySubsetFeaturesKHR; + +typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t minVertexInputBindingStrideAlignment; +} VkPhysicalDevicePortabilitySubsetPropertiesKHR; + + + +// VK_AMDX_shader_enqueue is a preprocessor guard. Do not pass it to API calls. +#define VK_AMDX_shader_enqueue 1 +#define VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION 2 +#define VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME "VK_AMDX_shader_enqueue" +#define VK_SHADER_INDEX_UNUSED_AMDX (~0U) +typedef struct VkPhysicalDeviceShaderEnqueueFeaturesAMDX { + VkStructureType sType; + void* pNext; + VkBool32 shaderEnqueue; + VkBool32 shaderMeshEnqueue; +} VkPhysicalDeviceShaderEnqueueFeaturesAMDX; + +typedef struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX { + VkStructureType sType; + void* pNext; + uint32_t maxExecutionGraphDepth; + uint32_t maxExecutionGraphShaderOutputNodes; + uint32_t maxExecutionGraphShaderPayloadSize; + uint32_t maxExecutionGraphShaderPayloadCount; + uint32_t executionGraphDispatchAddressAlignment; + uint32_t maxExecutionGraphWorkgroupCount[3]; + uint32_t maxExecutionGraphWorkgroups; +} VkPhysicalDeviceShaderEnqueuePropertiesAMDX; + +typedef struct VkExecutionGraphPipelineScratchSizeAMDX { + VkStructureType sType; + void* pNext; + VkDeviceSize minSize; + VkDeviceSize maxSize; + VkDeviceSize sizeGranularity; +} VkExecutionGraphPipelineScratchSizeAMDX; + +typedef struct VkExecutionGraphPipelineCreateInfoAMDX { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineLibraryCreateInfoKHR* pLibraryInfo; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkExecutionGraphPipelineCreateInfoAMDX; + +typedef union VkDeviceOrHostAddressConstAMDX { + VkDeviceAddress deviceAddress; + const void* hostAddress; +} VkDeviceOrHostAddressConstAMDX; + +typedef struct VkDispatchGraphInfoAMDX { + uint32_t nodeIndex; + uint32_t payloadCount; + VkDeviceOrHostAddressConstAMDX payloads; + uint64_t payloadStride; +} VkDispatchGraphInfoAMDX; + +typedef struct VkDispatchGraphCountInfoAMDX { + uint32_t count; + VkDeviceOrHostAddressConstAMDX infos; + uint64_t stride; +} VkDispatchGraphCountInfoAMDX; + +typedef struct VkPipelineShaderStageNodeCreateInfoAMDX { + VkStructureType sType; + const void* pNext; + const char* pName; + uint32_t index; +} VkPipelineShaderStageNodeCreateInfoAMDX; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateExecutionGraphPipelinesAMDX)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineScratchSizeAMDX)(VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineNodeIndexAMDX)(VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex); +typedef void (VKAPI_PTR *PFN_vkCmdInitializeGraphScratchMemoryAMDX)(VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphAMDX)(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectAMDX)(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectCountAMDX)(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineScratchSizeAMDX( + VkDevice device, + VkPipeline executionGraph, + VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineNodeIndexAMDX( + VkDevice device, + VkPipeline executionGraph, + const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, + uint32_t* pNodeIndex); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdInitializeGraphScratchMemoryAMDX( + VkCommandBuffer commandBuffer, + VkPipeline executionGraph, + VkDeviceAddress scratch, + VkDeviceSize scratchSize); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphAMDX( + VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + VkDeviceSize scratchSize, + const VkDispatchGraphCountInfoAMDX* pCountInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectAMDX( + VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + VkDeviceSize scratchSize, + const VkDispatchGraphCountInfoAMDX* pCountInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX( + VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + VkDeviceSize scratchSize, + VkDeviceAddress countInfo); +#endif +#endif + + +// VK_NV_cuda_kernel_launch is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_cuda_kernel_launch 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaModuleNV) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaFunctionNV) +#define VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION 2 +#define VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME "VK_NV_cuda_kernel_launch" +typedef struct VkCudaModuleCreateInfoNV { + VkStructureType sType; + const void* pNext; + size_t dataSize; + const void* pData; +} VkCudaModuleCreateInfoNV; + +typedef struct VkCudaFunctionCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkCudaModuleNV module; + const char* pName; +} VkCudaFunctionCreateInfoNV; + +typedef struct VkCudaLaunchInfoNV { + VkStructureType sType; + const void* pNext; + VkCudaFunctionNV function; + uint32_t gridDimX; + uint32_t gridDimY; + uint32_t gridDimZ; + uint32_t blockDimX; + uint32_t blockDimY; + uint32_t blockDimZ; + uint32_t sharedMemBytes; + size_t paramCount; + const void* const * pParams; + size_t extraCount; + const void* const * pExtras; +} VkCudaLaunchInfoNV; + +typedef struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cudaKernelLaunchFeatures; +} VkPhysicalDeviceCudaKernelLaunchFeaturesNV; + +typedef struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t computeCapabilityMinor; + uint32_t computeCapabilityMajor; +} VkPhysicalDeviceCudaKernelLaunchPropertiesNV; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaModuleNV)(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule); +typedef VkResult (VKAPI_PTR *PFN_vkGetCudaModuleCacheNV)(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaFunctionNV)(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction); +typedef void (VKAPI_PTR *PFN_vkDestroyCudaModuleNV)(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkDestroyCudaFunctionNV)(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdCudaLaunchKernelNV)(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaModuleNV( + VkDevice device, + const VkCudaModuleCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCudaModuleNV* pModule); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetCudaModuleCacheNV( + VkDevice device, + VkCudaModuleNV module, + size_t* pCacheSize, + void* pCacheData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaFunctionNV( + VkDevice device, + const VkCudaFunctionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCudaFunctionNV* pFunction); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyCudaModuleNV( + VkDevice device, + VkCudaModuleNV module, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyCudaFunctionNV( + VkDevice device, + VkCudaFunctionNV function, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV( + VkCommandBuffer commandBuffer, + const VkCudaLaunchInfoNV* pLaunchInfo); +#endif +#endif + + +// VK_NV_displacement_micromap is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_displacement_micromap 1 +#define VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION 2 +#define VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME "VK_NV_displacement_micromap" + +typedef enum VkDisplacementMicromapFormatNV { + VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV = 1, + VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV = 2, + VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV = 3, + VK_DISPLACEMENT_MICROMAP_FORMAT_MAX_ENUM_NV = 0x7FFFFFFF +} VkDisplacementMicromapFormatNV; +typedef struct VkPhysicalDeviceDisplacementMicromapFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 displacementMicromap; +} VkPhysicalDeviceDisplacementMicromapFeaturesNV; + +typedef struct VkPhysicalDeviceDisplacementMicromapPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxDisplacementMicromapSubdivisionLevel; +} VkPhysicalDeviceDisplacementMicromapPropertiesNV; + +typedef struct VkAccelerationStructureTrianglesDisplacementMicromapNV { + VkStructureType sType; + void* pNext; + VkFormat displacementBiasAndScaleFormat; + VkFormat displacementVectorFormat; + VkDeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer; + VkDeviceSize displacementBiasAndScaleStride; + VkDeviceOrHostAddressConstKHR displacementVectorBuffer; + VkDeviceSize displacementVectorStride; + VkDeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags; + VkDeviceSize displacedMicromapPrimitiveFlagsStride; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts; + const VkMicromapUsageEXT* const* ppUsageCounts; + VkMicromapEXT micromap; +} VkAccelerationStructureTrianglesDisplacementMicromapNV; + + + +// VK_AMDX_dense_geometry_format is a preprocessor guard. Do not pass it to API calls. +#define VK_AMDX_dense_geometry_format 1 +#define VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION 1 +#define VK_AMDX_DENSE_GEOMETRY_FORMAT_EXTENSION_NAME "VK_AMDX_dense_geometry_format" +#define VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX 128U +#define VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX 128U + +typedef enum VkCompressedTriangleFormatAMDX { + VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX = 0, + VK_COMPRESSED_TRIANGLE_FORMAT_MAX_ENUM_AMDX = 0x7FFFFFFF +} VkCompressedTriangleFormatAMDX; +typedef struct VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX { + VkStructureType sType; + void* pNext; + VkBool32 denseGeometryFormat; +} VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX; + +typedef struct VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR compressedData; + VkDeviceSize dataSize; + uint32_t numTriangles; + uint32_t numVertices; + uint32_t maxPrimitiveIndex; + uint32_t maxGeometryIndex; + VkCompressedTriangleFormatAMDX format; +} VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_core.h b/lib/vulkan-headers/include/vulkan/vulkan_core.h new file mode 100644 index 00000000000..32507d29ebc --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_core.h @@ -0,0 +1,25278 @@ +#ifndef VULKAN_CORE_H_ +#define VULKAN_CORE_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_VERSION_1_0 is a preprocessor guard. Do not pass it to API calls. +#define VK_VERSION_1_0 1 +#include "vk_platform.h" + +#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; + + +#ifndef VK_USE_64_BIT_PTR_DEFINES + #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) || (defined(__riscv) && __riscv_xlen == 64) + #define VK_USE_64_BIT_PTR_DEFINES 1 + #else + #define VK_USE_64_BIT_PTR_DEFINES 0 + #endif +#endif + + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L)) + #define VK_NULL_HANDLE nullptr + #else + #define VK_NULL_HANDLE ((void*)0) + #endif + #else + #define VK_NULL_HANDLE 0ULL + #endif +#endif +#ifndef VK_NULL_HANDLE + #define VK_NULL_HANDLE 0 +#endif + + +#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE + #if (VK_USE_64_BIT_PTR_DEFINES==1) + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; + #else + #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; + #endif +#endif + +#define VK_MAKE_API_VERSION(variant, major, minor, patch) \ + ((((uint32_t)(variant)) << 29U) | (((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch))) + + +//#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 + +// Version of this file +#define VK_HEADER_VERSION 341 + +// Complete version of this file +#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) + + +#define VK_MAKE_VERSION(major, minor, patch) \ + ((((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch))) + + +#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22U) + + +#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) + + +#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) + +#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29U) +#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22U) & 0x7FU) +#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) +#define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) +// Vulkan 1.0 version number +#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 + +typedef uint32_t VkBool32; +typedef uint64_t VkDeviceAddress; +typedef uint64_t VkDeviceSize; +typedef uint32_t VkFlags; +typedef uint32_t VkSampleMask; +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) +VK_DEFINE_HANDLE(VkInstance) +VK_DEFINE_HANDLE(VkPhysicalDevice) +VK_DEFINE_HANDLE(VkDevice) +VK_DEFINE_HANDLE(VkQueue) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) +VK_DEFINE_HANDLE(VkCommandBuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) +#define VK_FALSE 0U +#define VK_LOD_CLAMP_NONE 1000.0F +#define VK_QUEUE_FAMILY_IGNORED (~0U) +#define VK_REMAINING_ARRAY_LAYERS (~0U) +#define VK_REMAINING_MIP_LEVELS (~0U) +#define VK_TRUE 1U +#define VK_WHOLE_SIZE (~0ULL) +#define VK_MAX_MEMORY_TYPES 32U +#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256U +#define VK_UUID_SIZE 16U +#define VK_MAX_EXTENSION_NAME_SIZE 256U +#define VK_MAX_DESCRIPTION_SIZE 256U +#define VK_MAX_MEMORY_HEAPS 16U +#define VK_ATTACHMENT_UNUSED (~0U) +#define VK_SUBPASS_EXTERNAL (~0U) + +typedef enum VkResult { + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_FRAGMENTED_POOL = -12, + VK_ERROR_UNKNOWN = -13, + VK_ERROR_VALIDATION_FAILED = -1000011001, + VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, + VK_ERROR_FRAGMENTATION = -1000161000, + VK_PIPELINE_COMPILE_REQUIRED = 1000297000, + VK_ERROR_NOT_PERMITTED = -1000174001, + VK_ERROR_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_INVALID_SHADER_NV = -1000012000, + VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000, + VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001, + VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR = -1000023002, + VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR = -1000023003, + VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004, + VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005, + VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, + VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT = -1000208000, + VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, + VK_THREAD_IDLE_KHR = 1000268000, + VK_THREAD_DONE_KHR = 1000268001, + VK_OPERATION_DEFERRED_KHR = 1000268002, + VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, + VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000, + VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, + VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, + VK_PIPELINE_BINARY_MISSING_KHR = 1000483000, + VK_ERROR_NOT_ENOUGH_SPACE_KHR = -1000483000, + VK_ERROR_VALIDATION_FAILED_EXT = VK_ERROR_VALIDATION_FAILED, + VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, + VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, + VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, + VK_ERROR_NOT_PERMITTED_EXT = VK_ERROR_NOT_PERMITTED, + VK_ERROR_NOT_PERMITTED_KHR = VK_ERROR_NOT_PERMITTED, + VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, + VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, + VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, + // VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT is a legacy alias + VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT, + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum VkStructureType { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, + VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000, + VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001, + VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002, + VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 = 1000314002, + VK_STRUCTURE_TYPE_DEPENDENCY_INFO = 1000314003, + VK_STRUCTURE_TYPE_SUBMIT_INFO_2 = 1000314004, + VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO = 1000314005, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO = 1000314006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007, + VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 = 1000337000, + VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 = 1000337001, + VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003, + VK_STRUCTURE_TYPE_BUFFER_COPY_2 = 1000337006, + VK_STRUCTURE_TYPE_IMAGE_COPY_2 = 1000337007, + VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 = 1000337009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001, + VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, + VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, + VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001, + VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005, + VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008, + VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010, + VK_STRUCTURE_TYPE_RENDERING_INFO = 1000044000, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO = 1000044001, + VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO = 1000044002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES = 55, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES = 56, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO = 1000174000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES = 1000388000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES = 1000388001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES = 1000265000, + VK_STRUCTURE_TYPE_MEMORY_MAP_INFO = 1000271000, + VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO = 1000271001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES = 1000470000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES = 1000470001, + VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO = 1000470004, + VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2 = 1000338002, + VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2 = 1000338003, + VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO = 1000470006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES = 1000545000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES = 1000545001, + VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS = 1000545002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES = 1000270000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES = 1000270001, + VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY = 1000270002, + VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY = 1000270003, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO = 1000270004, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO = 1000270005, + VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO = 1000270006, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO = 1000270007, + VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE = 1000270008, + VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY = 1000270009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES = 1000416000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES = 1000528000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES = 1000544000, + VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO = 1000470005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES = 1000080000, + VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO = 1000545003, + VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO = 1000545004, + VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO = 1000545005, + VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO = 1000545006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES = 1000466000, + VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO = 1000068000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES = 1000068001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES = 1000068002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES = 1000259000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO = 1000259001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES = 1000259002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES = 1000525000, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO = 1000190001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES = 1000190002, + VK_STRUCTURE_TYPE_RENDERING_AREA_INFO = 1000470003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES = 1000232000, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO = 1000232001, + VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO = 1000232002, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, + VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR = 1000023000, + VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001, + VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002, + VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003, + VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004, + VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005, + VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006, + VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007, + VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008, + VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009, + VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010, + VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012, + VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR = 1000023013, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014, + VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016, + VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR = 1000024002, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, + VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000, + VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001, + VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002, + VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX = 1000029004, + VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR = 1000038000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000038001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000038002, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR = 1000038003, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR = 1000038004, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR = 1000038005, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR = 1000038006, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR = 1000038007, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR = 1000038008, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR = 1000038009, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR = 1000038010, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR = 1000038011, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR = 1000038012, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000038013, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR = 1000039000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000039001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000039002, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR = 1000039003, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR = 1000039004, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR = 1000039005, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR = 1000039006, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR = 1000039007, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR = 1000039009, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR = 1000039010, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR = 1000039011, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR = 1000039012, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR = 1000039013, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000039014, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000040004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000040005, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR = 1000040006, + VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, + VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, + VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, + VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, + VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, + VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, + VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG = 1000110000, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, + VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, + VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, + VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, + VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, + VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, + VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, + VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX = 1000134000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX = 1000134001, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX = 1000134002, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX = 1000134003, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX = 1000134004, +#endif + VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT = 1000135000, + VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT = 1000135001, + VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT = 1000135002, + VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT = 1000135003, + VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT = 1000135004, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT = 1000135005, + VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT = 1000135006, + VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT = 1000135007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT = 1000135008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT = 1000135009, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT = 1000135010, + VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT = 1000135011, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV = 1000135012, + VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT = 1000135013, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM = 1000135014, + VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR = 1000141000, + VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009, + VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010, + VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015, + VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, + VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, + VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001, +#endif + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, + VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, + VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, + VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, + VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, + VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, + VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, + VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, + VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000187002, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR = 1000187003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR = 1000187004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR = 1000187005, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, + VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT = 1000208000, + VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT = 1000208001, + VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT = 1000208002, + VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT = 1000208003, + VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT = 1000208004, + VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT = 1000208005, + VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT = 1000208006, + VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT = 1000208007, + VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT = 1000208008, + VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT = 1000208009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, + VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, + VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002, + VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003, + VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004, + VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, + VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000, + VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001, + VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, + VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, + VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, + VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, + VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, + VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR = 1000235000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, + VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, + VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, + VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, + VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001, + VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002, + VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, + VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, + VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, + VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT = 1000272000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT = 1000272001, + VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT = 1000272002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, + VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000, + VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT = 1000283000, + VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT = 1000283001, + VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT = 1000283002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, + VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, + VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT = 1000288000, + VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002, + VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004, + VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR = 1000299005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299006, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR = 1000299007, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299008, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR = 1000299009, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000299010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, + VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV = 1000307000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV = 1000307001, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV = 1000307002, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV = 1000307003, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV = 1000307004, +#endif + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM = 1000309000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM = 1000309001, + VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM = 1000309002, + VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM = 1000309003, + VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM = 1000309004, + VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM = 1000309005, + VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000, + VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000, + VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001, + VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT = 1000311002, + VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT = 1000311003, + VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT = 1000311004, + VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT = 1000311005, + VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT = 1000311006, + VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT = 1000311007, + VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT = 1000311008, + VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT = 1000311009, + VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311010, + VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311011, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002, + VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003, + VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT = 1000316004, + VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005, + VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007, + VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008, + VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010, + VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011, + VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD = 1000321000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR = 1000203000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR = 1000322000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT = 1000328000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT = 1000328001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, + VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT = 1000338000, + VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT = 1000338001, + VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000, + VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT = 1000341001, + VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT = 1000341002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000, + VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, + VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, + VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000, + VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000, + VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001, + VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003, + VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005, + VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007, + VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009, + VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000, + VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001, + VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT = 1000375000, + VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT = 1000375001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000, + VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001, + VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, + VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR = 1000387000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE = 1000390000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE = 1000390001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE = 1000390002, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE = 1000390003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT = 1000395000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT = 1000395001, + VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000, + VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001, + VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002, + VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006, + VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT = 1000396007, + VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV = 1000397000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV = 1000397001, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV = 1000397002, +#endif + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI = 1000404002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, + VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM = 1000424000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM = 1000424001, + VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM = 1000424002, + VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM = 1000424003, + VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM = 1000424004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV = 1000428000, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001, + VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV = 1000429008, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV = 1000429009, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV = 1000429010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR = 1000434000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT = 1000451000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT = 1000451001, + VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS = 1000452000, + VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS = 1000452001, + VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS = 1000452002, + VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS = 1000452003, + VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS = 1000452004, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS = 1000452005, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT = 1000453000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002, + VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003, + VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG = 1000459000, + VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG = 1000459001, + VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM = 1000460000, + VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM = 1000460001, + VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM = 1000460002, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM = 1000460003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM = 1000460004, + VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM = 1000460005, + VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM = 1000460006, + VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM = 1000460007, + VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM = 1000460008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM = 1000460009, + VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM = 1000460010, + VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM = 1000460011, + VK_STRUCTURE_TYPE_TENSOR_COPY_ARM = 1000460012, + VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM = 1000460013, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM = 1000460014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM = 1000460015, + VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM = 1000460016, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM = 1000460017, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM = 1000460018, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM = 1000460019, + VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM = 1000460020, + VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM = 1000460021, + VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM = 1000460022, + VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM = 1000460023, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002, + VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT = 1000462003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID = 1000468000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468001, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD = 1000476000, + VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD = 1000476001, + VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD = 1000476002, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX = 1000478000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX = 1000478001, +#endif + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR = 1000479000, + VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR = 1000479001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR = 1000479002, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR = 1000480000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR = 1000480001, + VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR = 1000480002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR = 1000481000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001, + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT = 1000482002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR = 1000483000, + VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR = 1000483001, + VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR = 1000483002, + VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR = 1000483003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR = 1000483004, + VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR = 1000483005, + VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR = 1000483006, + VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR = 1000483007, + VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR = 1000483008, + VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR = 1000483009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000, + VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000, + VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC = 1000485001, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR = 1000274000, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR = 1000274001, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR = 1000274002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR = 1000275000, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR = 1000275001, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR = 1000275002, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR = 1000275003, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR = 1000275004, + VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR = 1000275005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV = 1000491000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV = 1000491001, + VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV = 1000491002, + VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV = 1000491004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV = 1000492000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV = 1000492001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000, + VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT = 1000495000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT = 1000495001, + VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT = 1000496000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT = 1000499000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR = 1000504000, + VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV = 1000505000, + VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV = 1000505001, + VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV = 1000505002, + VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV = 1000505003, + VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV = 1000505004, + VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV = 1000505005, + VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV = 1000505006, + VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV = 1000505007, + VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV = 1000505008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000, + VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM = 1000507000, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM = 1000507001, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM = 1000507002, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM = 1000507003, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM = 1000507004, + VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM = 1000507005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM = 1000507006, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM = 1000507007, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM = 1000507008, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM = 1000507009, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM = 1000507010, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM = 1000507011, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM = 1000507012, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM = 1000507013, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM = 1000507014, + VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM = 1000507016, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM = 1000507017, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM = 1000507018, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM = 1000507019, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM = 1000507015, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, + VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR = 1000201000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR = 1000511000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR = 1000512000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR = 1000512001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR = 1000512003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000512004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR = 1000512005, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR = 1000513000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000513001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR = 1000513002, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR = 1000513003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR = 1000513004, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR = 1000513005, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR = 1000513006, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR = 1000513007, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR = 1000513008, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR = 1000513009, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR = 1000513010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR = 1000514000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR = 1000514001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR = 1000514002, + VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR = 1000514003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR = 1000515000, + VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR = 1000515001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM = 1000518000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM = 1000518001, + VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM = 1000518002, + VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM = 1000519000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM = 1000519001, + VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM = 1000519002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM = 1000520000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM = 1000520001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR = 1000527000, + VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT = 1000527001, + VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000, + VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001, + VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000, + VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR = 1000184000, + VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007, + VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM = 1000547000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM = 1000547001, + VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM = 1000547002, + VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM = 1000547003, + VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM = 1000547004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR = 1000549000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR = 1000426001, + VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR = 1000549002, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR = 1000549003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT = 1000427000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT = 1000427001, + VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT = 1000550002, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV = 1000551000, + VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV = 1000551001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR = 1000552000, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR = 1000552001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR = 1000552002, + VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR = 1000552003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR = 1000552004, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553000, + VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553001, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR = 1000553002, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000553005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR = 1000553009, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553003, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553004, + VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553006, + VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553007, + VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000, + VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV = 1000556000, + VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV = 1000556001, + VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV = 1000556002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV = 1000556003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR = 1000558000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV = 1000559000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR = 1000562000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR = 1000562001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR = 1000562002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR = 1000562003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR = 1000562004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT = 1000567000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV = 1000569000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV = 1000569001, + VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV = 1000569002, + VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV = 1000569003, + VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV = 1000569004, + VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV = 1000569005, + VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV = 1000569006, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000569007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV = 1000570000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV = 1000570001, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570002, + VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV = 1000570003, + VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV = 1000570004, + VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV = 1000570005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT = 1000572000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT = 1000572001, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT = 1000572002, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT = 1000572003, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT = 1000572004, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT = 1000572006, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT = 1000572007, + VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT = 1000572008, + VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT = 1000572009, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT = 1000572010, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT = 1000572011, + VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT = 1000572012, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT = 1000572013, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT = 1000572014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR = 1000574000, + VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR = 1000574002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001, + VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR = 1000579000, + VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV = 1000580000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV = 1000580001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV = 1000580002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT = 1000581000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT = 1000581001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR = 1000584000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR = 1000584001, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR = 1000584002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR = 1000586000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586002, + VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586003, + VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS = 1000685000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI = 1000590000, + VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI = 1000590001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV = 1000593000, + VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV = 1000593001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV = 1000593002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM = 1000596000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT = 1000602000, + VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT = 1000602001, + VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR = 1000421000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM = 1000605000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM = 1000605001, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM = 1000605002, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM = 1000605003, + VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM = 1000605004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM = 1000609000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE = 1000611000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE = 1000611001, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE = 1000611002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR = 1000286000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV = 1000613000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV = 1000613001, +#endif + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT = 1000425000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT = 1000425001, + VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT = 1000620000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR = 1000361000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT = 1000627000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT = 1000628000, + VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT = 1000628001, + VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT = 1000628002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM = 1000629000, + VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM = 1000629001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR = 1000630000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR = 1000630001, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR = 1000630002, + VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR = 1000619003, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR = 1000630004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT = 1000635000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT = 1000635001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC = 1000637000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT = 1000642000, + VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV = 1000645000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV = 1000645001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT = 1000662000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + // VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a legacy alias + VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + VK_STRUCTURE_TYPE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_INFO, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, + VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, + VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + // VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT is a legacy alias + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, + VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, + VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, + VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, + VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, + // VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL is a legacy alias + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO, + VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES, + VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY, + VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO, + VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO, + VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE, + VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY, + VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO, + VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, + VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, + VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, + VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, + VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, + VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, + VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, + VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, + VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, + VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2, + VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2, + VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, + VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, + VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, + VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2, + VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, + VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, + VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, + VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, + VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES, + VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO, + VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO, + VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2, + VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2, + VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO, + VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO, + VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES, + VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS, + VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO, + VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO, + VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO, + VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO, + VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR, + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum VkImageLayout { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, + VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000, + VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001, + VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ = 1000232000, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000, + VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001, + VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002, + VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, + VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, + VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, + VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000, + VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001, + VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002, + VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, + VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM = 1000460000, + VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR = 1000553000, + VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT = 1000620000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, + VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum VkObjectType { + VK_OBJECT_TYPE_UNKNOWN = 0, + VK_OBJECT_TYPE_INSTANCE = 1, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, + VK_OBJECT_TYPE_DEVICE = 3, + VK_OBJECT_TYPE_QUEUE = 4, + VK_OBJECT_TYPE_SEMAPHORE = 5, + VK_OBJECT_TYPE_COMMAND_BUFFER = 6, + VK_OBJECT_TYPE_FENCE = 7, + VK_OBJECT_TYPE_DEVICE_MEMORY = 8, + VK_OBJECT_TYPE_BUFFER = 9, + VK_OBJECT_TYPE_IMAGE = 10, + VK_OBJECT_TYPE_EVENT = 11, + VK_OBJECT_TYPE_QUERY_POOL = 12, + VK_OBJECT_TYPE_BUFFER_VIEW = 13, + VK_OBJECT_TYPE_IMAGE_VIEW = 14, + VK_OBJECT_TYPE_SHADER_MODULE = 15, + VK_OBJECT_TYPE_PIPELINE_CACHE = 16, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, + VK_OBJECT_TYPE_RENDER_PASS = 18, + VK_OBJECT_TYPE_PIPELINE = 19, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, + VK_OBJECT_TYPE_SAMPLER = 21, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, + VK_OBJECT_TYPE_FRAMEBUFFER = 24, + VK_OBJECT_TYPE_COMMAND_POOL = 25, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000, + VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, + VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, + VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, + VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, + VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000, + VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001, + VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000, + VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, + VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, + VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, + VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000, + VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000, + VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_OBJECT_TYPE_CUDA_MODULE_NV = 1000307000, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_OBJECT_TYPE_CUDA_FUNCTION_NV = 1000307001, +#endif + VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000, + VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, + VK_OBJECT_TYPE_TENSOR_ARM = 1000460000, + VK_OBJECT_TYPE_TENSOR_VIEW_ARM = 1000460001, + VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, + VK_OBJECT_TYPE_SHADER_EXT = 1000482000, + VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000, + VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM = 1000507000, + VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV = 1000556000, + VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000, + VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, + VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkObjectType; + +typedef enum VkVendorId { + VK_VENDOR_ID_KHRONOS = 0x10000, + VK_VENDOR_ID_VIV = 0x10001, + VK_VENDOR_ID_VSI = 0x10002, + VK_VENDOR_ID_KAZAN = 0x10003, + VK_VENDOR_ID_CODEPLAY = 0x10004, + VK_VENDOR_ID_MESA = 0x10005, + VK_VENDOR_ID_POCL = 0x10006, + VK_VENDOR_ID_MOBILEYE = 0x10007, + VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF +} VkVendorId; + +typedef enum VkSystemAllocationScope { + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocationScope; + +typedef enum VkInternalAllocationType { + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkInternalAllocationType; + +typedef enum VkFormat { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, + VK_FORMAT_G8_B8R8_2PLANE_444_UNORM = 1000330000, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002, + VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003, + VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000, + VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001, + VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000, + VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001, + VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002, + VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003, + VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004, + VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005, + VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006, + VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007, + VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008, + VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009, + VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010, + VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011, + VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012, + VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013, + VK_FORMAT_A1B5G5R5_UNORM_PACK16 = 1000470000, + VK_FORMAT_A8_UNORM = 1000470001, + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT = 1000288000, + VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT = 1000288001, + VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT = 1000288002, + VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT = 1000288003, + VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT = 1000288004, + VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT = 1000288005, + VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT = 1000288006, + VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT = 1000288007, + VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT = 1000288008, + VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT = 1000288009, + VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT = 1000288010, + VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT = 1000288011, + VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT = 1000288012, + VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT = 1000288013, + VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT = 1000288014, + VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT = 1000288015, + VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT = 1000288016, + VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT = 1000288017, + VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT = 1000288018, + VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT = 1000288019, + VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT = 1000288020, + VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT = 1000288021, + VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT = 1000288022, + VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT = 1000288023, + VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT = 1000288024, + VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT = 1000288025, + VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT = 1000288026, + VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT = 1000288027, + VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT = 1000288028, + VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT = 1000288029, + VK_FORMAT_R8_BOOL_ARM = 1000460000, + VK_FORMAT_R16G16_SFIXED5_NV = 1000464000, + VK_FORMAT_R10X6_UINT_PACK16_ARM = 1000609000, + VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM = 1000609001, + VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM = 1000609002, + VK_FORMAT_R12X4_UINT_PACK16_ARM = 1000609003, + VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM = 1000609004, + VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM = 1000609005, + VK_FORMAT_R14X2_UINT_PACK16_ARM = 1000609006, + VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM = 1000609007, + VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM = 1000609008, + VK_FORMAT_R14X2_UNORM_PACK16_ARM = 1000609009, + VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM = 1000609010, + VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM = 1000609011, + VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM = 1000609012, + VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM = 1000609013, + VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, + VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, + VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK, + VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK, + VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK, + VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK, + VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, + VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, + VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, + VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, + VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, + VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16, + VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16, + // VK_FORMAT_R16G16_S10_5_NV is a legacy alias + VK_FORMAT_R16G16_S10_5_NV = VK_FORMAT_R16G16_SFIXED5_NV, + VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR = VK_FORMAT_A1B5G5R5_UNORM_PACK16, + VK_FORMAT_A8_UNORM_KHR = VK_FORMAT_A8_UNORM, + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum VkImageTiling { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum VkImageType { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum VkPhysicalDeviceType { + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum VkQueryType { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000, + VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, + VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, + VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, + VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR = 1000299000, + VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000, + VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR = 1000386001, + VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT = 1000396000, + VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT = 1000396001, + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum VkSharingMode { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum VkComponentSwizzle { + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkComponentSwizzle; + +typedef enum VkImageViewType { + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum VkCommandBufferLevel { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferLevel; + +typedef enum VkIndexType { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_UINT8 = 1000265000, + VK_INDEX_TYPE_NONE_KHR = 1000165000, + VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR, + VK_INDEX_TYPE_UINT8_EXT = VK_INDEX_TYPE_UINT8, + VK_INDEX_TYPE_UINT8_KHR = VK_INDEX_TYPE_UINT8, + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM = 1000629000, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheHeaderVersion; + +typedef enum VkBorderColor { + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, + VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_CUBIC_EXT = 1000015000, + VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT, + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkFilter; + +typedef enum VkSamplerAddressMode { + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + // VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR is a legacy alias + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerAddressMode; + +typedef enum VkSamplerMipmapMode { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerMipmapMode; + +typedef enum VkCompareOp { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum VkDescriptorType { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000, + VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, + VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000, + VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001, + VK_DESCRIPTOR_TYPE_TENSOR_ARM = 1000460000, + VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000, + VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570000, + VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, + VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = VK_DESCRIPTOR_TYPE_MUTABLE_EXT, + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum VkPipelineBindPoint { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX = 1000134000, +#endif + VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000, + VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003, + VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM = 1000507000, + VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum VkBlendFactor { + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} VkBlendFactor; + +typedef enum VkBlendOp { + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_ZERO_EXT = 1000148000, + VK_BLEND_OP_SRC_EXT = 1000148001, + VK_BLEND_OP_DST_EXT = 1000148002, + VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + VK_BLEND_OP_DST_OVER_EXT = 1000148004, + VK_BLEND_OP_SRC_IN_EXT = 1000148005, + VK_BLEND_OP_DST_IN_EXT = 1000148006, + VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + VK_BLEND_OP_DST_OUT_EXT = 1000148008, + VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + VK_BLEND_OP_XOR_EXT = 1000148011, + VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + VK_BLEND_OP_SCREEN_EXT = 1000148013, + VK_BLEND_OP_OVERLAY_EXT = 1000148014, + VK_BLEND_OP_DARKEN_EXT = 1000148015, + VK_BLEND_OP_LIGHTEN_EXT = 1000148016, + VK_BLEND_OP_COLORDODGE_EXT = 1000148017, + VK_BLEND_OP_COLORBURN_EXT = 1000148018, + VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, + VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, + VK_BLEND_OP_EXCLUSION_EXT = 1000148022, + VK_BLEND_OP_INVERT_EXT = 1000148023, + VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, + VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, + VK_BLEND_OP_LINEARBURN_EXT = 1000148026, + VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + VK_BLEND_OP_PINLIGHT_EXT = 1000148029, + VK_BLEND_OP_HARDMIX_EXT = 1000148030, + VK_BLEND_OP_HSL_HUE_EXT = 1000148031, + VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, + VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + VK_BLEND_OP_PLUS_EXT = 1000148035, + VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + VK_BLEND_OP_MINUS_EXT = 1000148039, + VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + VK_BLEND_OP_CONTRAST_EXT = 1000148041, + VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, + VK_BLEND_OP_RED_EXT = 1000148043, + VK_BLEND_OP_GREEN_EXT = 1000148044, + VK_BLEND_OP_BLUE_EXT = 1000148045, + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum VkDynamicState { + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_CULL_MODE = 1000267000, + VK_DYNAMIC_STATE_FRONT_FACE = 1000267001, + VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002, + VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT = 1000267003, + VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT = 1000267004, + VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE = 1000267005, + VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE = 1000267006, + VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE = 1000267007, + VK_DYNAMIC_STATE_DEPTH_COMPARE_OP = 1000267008, + VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE = 1000267009, + VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE = 1000267010, + VK_DYNAMIC_STATE_STENCIL_OP = 1000267011, + VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE = 1000377001, + VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE = 1000377002, + VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004, + VK_DYNAMIC_STATE_LINE_STIPPLE = 1000259000, + VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT = 1000099001, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT = 1000099002, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, + VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000, + VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, + VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, + VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000, + VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, + VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, + VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, + VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, + VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, + VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, + VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003, + VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004, + VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005, + VK_DYNAMIC_STATE_SAMPLE_MASK_EXT = 1000455006, + VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007, + VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT = 1000455008, + VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT = 1000455009, + VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010, + VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011, + VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012, + VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002, + VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013, + VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014, + VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015, + VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017, + VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018, + VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019, + VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020, + VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021, + VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022, + VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023, + VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024, + VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025, + VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029, + VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030, + VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031, + VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032, + VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000, + VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT = 1000582000, + VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE, + VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE, + VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE, + VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, + VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, + VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, + VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE, + VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE, + VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE, + VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP, + VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE, + VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE, + VK_DYNAMIC_STATE_STENCIL_OP_EXT = VK_DYNAMIC_STATE_STENCIL_OP, + VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE, + VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE, + VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE, + VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = VK_DYNAMIC_STATE_LINE_STIPPLE, + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + +typedef enum VkFrontFace { + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum VkVertexInputRate { + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputRate; + +typedef enum VkPrimitiveTopology { + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum VkPolygonMode { + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} VkPolygonMode; + +typedef enum VkStencilOp { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum VkLogicOp { + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum VkAttachmentLoadOp { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_NONE = 1000400000, + VK_ATTACHMENT_LOAD_OP_NONE_EXT = VK_ATTACHMENT_LOAD_OP_NONE, + VK_ATTACHMENT_LOAD_OP_NONE_KHR = VK_ATTACHMENT_LOAD_OP_NONE, + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum VkAttachmentStoreOp { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_NONE = 1000301000, + VK_ATTACHMENT_STORE_OP_NONE_KHR = VK_ATTACHMENT_STORE_OP_NONE, + VK_ATTACHMENT_STORE_OP_NONE_QCOM = VK_ATTACHMENT_STORE_OP_NONE, + VK_ATTACHMENT_STORE_OP_NONE_EXT = VK_ATTACHMENT_STORE_OP_NONE, + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum VkSubpassContents { + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR = 1000451000, + VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR, + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassContents; + +typedef enum VkAccessFlagBits { + VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, + VK_ACCESS_INDEX_READ_BIT = 0x00000002, + VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, + VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, + VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, + VK_ACCESS_SHADER_READ_BIT = 0x00000020, + VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, + VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, + VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, + VK_ACCESS_HOST_READ_BIT = 0x00002000, + VK_ACCESS_HOST_WRITE_BIT = 0x00004000, + VK_ACCESS_MEMORY_READ_BIT = 0x00008000, + VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, + VK_ACCESS_NONE = 0, + VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000, + VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000, + VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000, + VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, + VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, + VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000, + VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000, + VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000, + VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000, + VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT = 0x00020000, + VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT = 0x00040000, + VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, + VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, + VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, + VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT, + VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT, + VK_ACCESS_NONE_KHR = VK_ACCESS_NONE, + VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAccessFlagBits; +typedef VkFlags VkAccessFlags; + +typedef enum VkImageAspectFlagBits { + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, + VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, + VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, + VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, + VK_IMAGE_ASPECT_NONE = 0, + VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080, + VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, + VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, + VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, + VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, + VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, + VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, + VK_IMAGE_ASPECT_NONE_KHR = VK_IMAGE_ASPECT_NONE, + VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageAspectFlagBits; +typedef VkFlags VkImageAspectFlags; + +typedef enum VkFormatFeatureFlagBits { + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, + VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, + VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, + VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000, + VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000, + VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000, + VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000, + VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000, + VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000, + VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000, + VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, + VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFormatFeatureFlagBits; +typedef VkFlags VkFormatFeatureFlags; + +typedef enum VkImageCreateFlagBits { + VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, + VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, + VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, + VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, + VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, + VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT = 0x00010000, + VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, + VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, + VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000, + VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000, + VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000, + VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT = 0x00008000, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, + VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, + VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, + VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT, + VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT, + VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageCreateFlagBits; +typedef VkFlags VkImageCreateFlags; + +typedef enum VkSampleCountFlagBits { + VK_SAMPLE_COUNT_1_BIT = 0x00000001, + VK_SAMPLE_COUNT_2_BIT = 0x00000002, + VK_SAMPLE_COUNT_4_BIT = 0x00000004, + VK_SAMPLE_COUNT_8_BIT = 0x00000008, + VK_SAMPLE_COUNT_16_BIT = 0x00000010, + VK_SAMPLE_COUNT_32_BIT = 0x00000020, + VK_SAMPLE_COUNT_64_BIT = 0x00000040, + VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSampleCountFlagBits; +typedef VkFlags VkSampleCountFlags; + +typedef enum VkImageUsageFlagBits { + VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, + VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, + VK_IMAGE_USAGE_HOST_TRANSFER_BIT = 0x00400000, + VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400, + VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800, + VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000, + VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, + VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100, + VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000, + VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000, + VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000, + VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000, + VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, + VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, + VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, + VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM = 0x00800000, + VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM = 0x08000000, + VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x02000000, + VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x04000000, + VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = VK_IMAGE_USAGE_HOST_TRANSFER_BIT, + VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageUsageFlagBits; +typedef VkFlags VkImageUsageFlags; + +typedef enum VkInstanceCreateFlagBits { + VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR = 0x00000001, + VK_INSTANCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkInstanceCreateFlagBits; +typedef VkFlags VkInstanceCreateFlags; + +typedef enum VkMemoryHeapFlagBits { + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, + VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM = 0x00000008, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryHeapFlagBits; +typedef VkFlags VkMemoryHeapFlags; + +typedef enum VkMemoryPropertyFlagBits { + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, + VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, + VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, + VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040, + VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080, + VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0x00000100, + VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryPropertyFlagBits; +typedef VkFlags VkMemoryPropertyFlags; + +typedef enum VkQueueFlagBits { + VK_QUEUE_GRAPHICS_BIT = 0x00000001, + VK_QUEUE_COMPUTE_BIT = 0x00000002, + VK_QUEUE_TRANSFER_BIT = 0x00000004, + VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, + VK_QUEUE_PROTECTED_BIT = 0x00000010, + VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020, + VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040, + VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100, + VK_QUEUE_DATA_GRAPH_BIT_ARM = 0x00000400, + VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueueFlagBits; +typedef VkFlags VkQueueFlags; +typedef VkFlags VkDeviceCreateFlags; + +typedef enum VkDeviceQueueCreateFlagBits { + VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, + VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR = 0x00000004, + VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDeviceQueueCreateFlagBits; +typedef VkFlags VkDeviceQueueCreateFlags; + +typedef enum VkPipelineStageFlagBits { + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, + VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, + VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, + VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, + VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, + VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, + VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, + VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, + VK_PIPELINE_STAGE_NONE = 0, + VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000, + VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, + VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000, + VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000, + VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, + VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT = 0x00080000, + VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT = 0x00100000, + VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT = 0x00020000, + VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, + VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, + VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, + VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT, + VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE, + VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineStageFlagBits; +typedef VkFlags VkPipelineStageFlags; + +typedef enum VkMemoryMapFlagBits { + VK_MEMORY_MAP_PLACED_BIT_EXT = 0x00000001, + VK_MEMORY_MAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryMapFlagBits; +typedef VkFlags VkMemoryMapFlags; + +typedef enum VkSparseMemoryBindFlagBits { + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseMemoryBindFlagBits; +typedef VkFlags VkSparseMemoryBindFlags; + +typedef enum VkSparseImageFormatFlagBits { + VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, + VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, + VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, + VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseImageFormatFlagBits; +typedef VkFlags VkSparseImageFormatFlags; + +typedef enum VkFenceCreateFlagBits { + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFenceCreateFlagBits; +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; + +typedef enum VkQueryPoolCreateFlagBits { + VK_QUERY_POOL_CREATE_RESET_BIT_KHR = 0x00000001, + VK_QUERY_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryPoolCreateFlagBits; +typedef VkFlags VkQueryPoolCreateFlags; + +typedef enum VkQueryPipelineStatisticFlagBits { + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, + VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, + VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, + VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, + VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT = 0x00000800, + VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT = 0x00001000, + VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI = 0x00002000, + VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryPipelineStatisticFlagBits; +typedef VkFlags VkQueryPipelineStatisticFlags; + +typedef enum VkQueryResultFlagBits { + VK_QUERY_RESULT_64_BIT = 0x00000001, + VK_QUERY_RESULT_WAIT_BIT = 0x00000002, + VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, + VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, + VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010, + VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryResultFlagBits; +typedef VkFlags VkQueryResultFlags; + +typedef enum VkBufferCreateFlagBits { + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010, + VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000020, + VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00000040, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferCreateFlagBits; +typedef VkFlags VkBufferCreateFlags; + +typedef enum VkBufferUsageFlagBits { + VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, + VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, + VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000, + VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000, + VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000, + VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800, + VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, + VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX = 0x02000000, +#endif + VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT = 0x10000000, + VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000, + VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000, + VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400, + VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000, + VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000, + VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000, + VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000, + VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000, + VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000, + VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000, + VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM = 0x08000000, + VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferUsageFlagBits; +typedef VkFlags VkBufferUsageFlags; + +typedef enum VkImageViewCreateFlagBits { + VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, + VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000004, + VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002, + VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageViewCreateFlagBits; +typedef VkFlags VkImageViewCreateFlags; + +typedef enum VkDependencyFlagBits { + VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, + VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, + VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, + VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0x00000008, + VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR = 0x00000020, + VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR = 0x00000040, + VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, + VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDependencyFlagBits; +typedef VkFlags VkDependencyFlags; + +typedef enum VkCommandPoolCreateFlagBits { + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolCreateFlagBits; +typedef VkFlags VkCommandPoolCreateFlags; + +typedef enum VkCommandPoolResetFlagBits { + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolResetFlagBits; +typedef VkFlags VkCommandPoolResetFlags; + +typedef enum VkCommandBufferUsageFlagBits { + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferUsageFlagBits; +typedef VkFlags VkCommandBufferUsageFlags; + +typedef enum VkQueryControlFlagBits { + VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryControlFlagBits; +typedef VkFlags VkQueryControlFlags; + +typedef enum VkCommandBufferResetFlagBits { + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferResetFlagBits; +typedef VkFlags VkCommandBufferResetFlags; + +typedef enum VkEventCreateFlagBits { + VK_EVENT_CREATE_DEVICE_ONLY_BIT = 0x00000001, + VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT, + VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkEventCreateFlagBits; +typedef VkFlags VkEventCreateFlags; +typedef VkFlags VkBufferViewCreateFlags; +typedef VkFlags VkShaderModuleCreateFlags; + +typedef enum VkPipelineCacheCreateFlagBits { + VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001, + VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR = 0x00000008, + VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, + VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheCreateFlagBits; +typedef VkFlags VkPipelineCacheCreateFlags; + +typedef enum VkPipelineCreateFlagBits { + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, + VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, + VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100, + VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200, + VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT = 0x08000000, + VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT = 0x40000000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000, + VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000, + VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000, + VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000, + VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020, + VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000, + VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000, + VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040, + VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080, + VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000, + VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800, + VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000, + VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000, + VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400, + VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000, + VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000, + VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000, + VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000, +#endif + // VK_PIPELINE_CREATE_DISPATCH_BASE is a legacy alias + VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + // VK_PIPELINE_CREATE_DISPATCH_BASE_KHR is a legacy alias + VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + // VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT is a legacy alias + VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, + // VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR is a legacy alias + VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, + VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, + VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, + VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCreateFlagBits; +typedef VkFlags VkPipelineCreateFlags; + +typedef enum VkPipelineShaderStageCreateFlagBits { + VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 0x00000001, + VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 0x00000002, + VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, + VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, + VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineShaderStageCreateFlagBits; +typedef VkFlags VkPipelineShaderStageCreateFlags; + +typedef enum VkShaderStageFlagBits { + VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, + VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, + VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, + VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, + VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, + VK_SHADER_STAGE_ALL = 0x7FFFFFFF, + VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100, + VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200, + VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400, + VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800, + VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000, + VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000, + VK_SHADER_STAGE_TASK_BIT_EXT = 0x00000040, + VK_SHADER_STAGE_MESH_BIT_EXT = 0x00000080, + VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000, + VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI = 0x00080000, + VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR, + VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR, + VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, + VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR, + VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR, + VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR, + VK_SHADER_STAGE_TASK_BIT_NV = VK_SHADER_STAGE_TASK_BIT_EXT, + VK_SHADER_STAGE_MESH_BIT_NV = VK_SHADER_STAGE_MESH_BIT_EXT, + VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkShaderStageFlagBits; + +typedef enum VkPipelineLayoutCreateFlagBits { + VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 0x00000002, + VK_PIPELINE_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineLayoutCreateFlagBits; +typedef VkFlags VkPipelineLayoutCreateFlags; +typedef VkFlags VkShaderStageFlags; + +typedef enum VkSamplerCreateFlagBits { + VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001, + VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002, + VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, + VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT = 0x00000004, + VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM = 0x00000010, + VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSamplerCreateFlagBits; +typedef VkFlags VkSamplerCreateFlags; + +typedef enum VkDescriptorPoolCreateFlagBits { + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, + VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002, + VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT = 0x00000004, + VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV = 0x00000008, + VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV = 0x00000010, + VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, + VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT, + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorPoolCreateFlagBits; +typedef VkFlags VkDescriptorPoolCreateFlags; +typedef VkFlags VkDescriptorPoolResetFlags; + +typedef enum VkDescriptorSetLayoutCreateFlagBits { + VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT = 0x00000001, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00000010, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0x00000020, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00000080, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0x00000004, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV = 0x00000040, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorSetLayoutCreateFlagBits; +typedef VkFlags VkDescriptorSetLayoutCreateFlags; + +typedef enum VkColorComponentFlagBits { + VK_COLOR_COMPONENT_R_BIT = 0x00000001, + VK_COLOR_COMPONENT_G_BIT = 0x00000002, + VK_COLOR_COMPONENT_B_BIT = 0x00000004, + VK_COLOR_COMPONENT_A_BIT = 0x00000008, + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkColorComponentFlagBits; +typedef VkFlags VkColorComponentFlags; + +typedef enum VkCullModeFlagBits { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 0x00000001, + VK_CULL_MODE_BACK_BIT = 0x00000002, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCullModeFlagBits; +typedef VkFlags VkCullModeFlags; +typedef VkFlags VkPipelineVertexInputStateCreateFlags; +typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; +typedef VkFlags VkPipelineTessellationStateCreateFlags; +typedef VkFlags VkPipelineViewportStateCreateFlags; +typedef VkFlags VkPipelineRasterizationStateCreateFlags; +typedef VkFlags VkPipelineMultisampleStateCreateFlags; + +typedef enum VkPipelineDepthStencilStateCreateFlagBits { + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000001, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000002, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineDepthStencilStateCreateFlagBits; +typedef VkFlags VkPipelineDepthStencilStateCreateFlags; + +typedef enum VkPipelineColorBlendStateCreateFlagBits { + VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT = 0x00000001, + VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT, + VK_PIPELINE_COLOR_BLEND_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineColorBlendStateCreateFlagBits; +typedef VkFlags VkPipelineColorBlendStateCreateFlags; +typedef VkFlags VkPipelineDynamicStateCreateFlags; + +typedef enum VkAttachmentDescriptionFlagBits { + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, + VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 0x00000002, + VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 0x00000004, + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentDescriptionFlagBits; +typedef VkFlags VkAttachmentDescriptionFlags; + +typedef enum VkFramebufferCreateFlagBits { + VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001, + VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, + VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFramebufferCreateFlagBits; +typedef VkFlags VkFramebufferCreateFlags; + +typedef enum VkRenderPassCreateFlagBits { + VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002, + VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x00000004, + VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkRenderPassCreateFlagBits; +typedef VkFlags VkRenderPassCreateFlags; + +typedef enum VkSubpassDescriptionFlagBits { + VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, + VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, + VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM = 0x00000100, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT = 0x00000010, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000020, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000040, + VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000080, + VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT = 0x00000004, + VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT = 0x00000008, + VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT, + VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, + VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassDescriptionFlagBits; +typedef VkFlags VkSubpassDescriptionFlags; + +typedef enum VkStencilFaceFlagBits { + VK_STENCIL_FACE_FRONT_BIT = 0x00000001, + VK_STENCIL_FACE_BACK_BIT = 0x00000002, + VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, + // VK_STENCIL_FRONT_AND_BACK is a legacy alias + VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK, + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkStencilFaceFlagBits; +typedef VkFlags VkStencilFaceFlags; +typedef struct VkExtent2D { + uint32_t width; + uint32_t height; +} VkExtent2D; + +typedef struct VkExtent3D { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkExtent3D; + +typedef struct VkOffset2D { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct VkOffset3D { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct VkRect2D { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct VkBaseInStructure { + VkStructureType sType; + const struct VkBaseInStructure* pNext; +} VkBaseInStructure; + +typedef struct VkBaseOutStructure { + VkStructureType sType; + struct VkBaseOutStructure* pNext; +} VkBaseOutStructure; + +typedef struct VkBufferMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct VkImageSubresourceRange { + VkImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceRange; + +typedef struct VkImageMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct VkMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} VkMemoryBarrier; + +typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + +typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); +typedef struct VkAllocationCallbacks { + void* pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} VkAllocationCallbacks; + +typedef struct VkApplicationInfo { + VkStructureType sType; + const void* pNext; + const char* pApplicationName; + uint32_t applicationVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef struct VkFormatProperties { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} VkFormatProperties; + +typedef struct VkImageFormatProperties { + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} VkImageFormatProperties; + +typedef struct VkInstanceCreateInfo { + VkStructureType sType; + const void* pNext; + VkInstanceCreateFlags flags; + const VkApplicationInfo* pApplicationInfo; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef struct VkMemoryHeap { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkMemoryType { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct VkPhysicalDeviceFeatures { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSrcBlend; + VkBool32 logicOp; + VkBool32 multiDrawIndirect; + VkBool32 drawIndirectFirstInstance; + VkBool32 depthClamp; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 alphaToOne; + VkBool32 multiViewport; + VkBool32 samplerAnisotropy; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 occlusionQueryPrecise; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexPipelineStoresAndAtomics; + VkBool32 fragmentStoresAndAtomics; + VkBool32 shaderTessellationAndGeometryPointSize; + VkBool32 shaderImageGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageImageReadWithoutFormat; + VkBool32 shaderStorageImageWriteWithoutFormat; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLod; + VkBool32 sparseBinding; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyAliased; + VkBool32 variableMultisampleRate; + VkBool32 inheritedQueries; +} VkPhysicalDeviceFeatures; + +typedef struct VkPhysicalDeviceLimits { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} VkPhysicalDeviceLimits; + +typedef struct VkPhysicalDeviceMemoryProperties { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties; + +typedef struct VkPhysicalDeviceSparseProperties { + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} VkPhysicalDeviceSparseProperties; + +typedef struct VkPhysicalDeviceProperties { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties; + +typedef struct VkQueueFamilyProperties { + VkQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + VkExtent3D minImageTransferGranularity; +} VkQueueFamilyProperties; + +typedef struct VkDeviceQueueCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities; +} VkDeviceQueueCreateInfo; + +typedef struct VkDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const VkDeviceQueueCreateInfo* pQueueCreateInfos; + // enabledLayerCount is legacy and should not be used + uint32_t enabledLayerCount; + // ppEnabledLayerNames is legacy and should not be used + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures* pEnabledFeatures; +} VkDeviceCreateInfo; + +typedef struct VkExtensionProperties { + char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct VkLayerProperties { + char layerName[VK_MAX_EXTENSION_NAME_SIZE]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkLayerProperties; + +typedef struct VkSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + const VkPipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + const VkCommandBuffer* pCommandBuffers; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkSubmitInfo; + +typedef struct VkMappedMemoryRange { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct VkMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocateInfo; + +typedef struct VkMemoryRequirements { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct VkSparseMemoryBind { + VkDeviceSize resourceOffset; + VkDeviceSize size; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseMemoryBind; + +typedef struct VkSparseBufferMemoryBindInfo { + VkBuffer buffer; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseBufferMemoryBindInfo; + +typedef struct VkSparseImageOpaqueMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseImageOpaqueMemoryBindInfo; + +typedef struct VkImageSubresource { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t arrayLayer; +} VkImageSubresource; + +typedef struct VkSparseImageMemoryBind { + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseImageMemoryBind; + +typedef struct VkSparseImageMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseImageMemoryBind* pBinds; +} VkSparseImageMemoryBindInfo; + +typedef struct VkBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t bufferBindCount; + const VkSparseBufferMemoryBindInfo* pBufferBinds; + uint32_t imageOpaqueBindCount; + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + uint32_t imageBindCount; + const VkSparseImageMemoryBindInfo* pImageBinds; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkBindSparseInfo; + +typedef struct VkSparseImageFormatProperties { + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} VkSparseImageFormatProperties; + +typedef struct VkSparseImageMemoryRequirements { + VkSparseImageFormatProperties formatProperties; + uint32_t imageMipTailFirstLod; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} VkSparseImageMemoryRequirements; + +typedef struct VkFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct VkSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct VkQueryPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct VkBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct VkImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo; + +typedef struct VkSubresourceLayout { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct VkComponentMapping { + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} VkComponentMapping; + +typedef struct VkImageViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; + +typedef struct VkCommandPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo; + +typedef struct VkCommandBufferAllocateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; +} VkCommandBufferAllocateInfo; + +typedef struct VkCommandBufferInheritanceInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo; + +typedef struct VkCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + VkCommandBufferUsageFlags flags; + const VkCommandBufferInheritanceInfo* pInheritanceInfo; +} VkCommandBufferBeginInfo; + +typedef struct VkBufferCopy { + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy; + +typedef struct VkImageSubresourceLayers { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceLayers; + +typedef struct VkBufferImageCopy { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef struct VkImageCopy { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkDispatchIndirectCommand { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCommand; + +typedef struct VkPipelineCacheHeaderVersionOne { + uint32_t headerSize; + VkPipelineCacheHeaderVersion headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; +} VkPipelineCacheHeaderVersionOne; + +typedef struct VkEventCreateInfo { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct VkBufferViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct VkShaderModuleCreateInfo { + VkStructureType sType; + const void* pNext; + VkShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode; +} VkShaderModuleCreateInfo; + +typedef struct VkPipelineCacheCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCacheCreateFlags flags; + size_t initialDataSize; + const void* pInitialData; +} VkPipelineCacheCreateInfo; + +typedef struct VkSpecializationMapEntry { + uint32_t constantID; + uint32_t offset; + size_t size; +} VkSpecializationMapEntry; + +typedef struct VkSpecializationInfo { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMapEntries; + size_t dataSize; + const void* pData; +} VkSpecializationInfo; + +typedef struct VkPipelineShaderStageCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule module; + const char* pName; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct VkComputePipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct VkPushConstantRange { + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; +} VkPushConstantRange; + +typedef struct VkPipelineLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct VkSamplerCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo; + +typedef struct VkCopyDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; +} VkCopyDescriptorSet; + +typedef struct VkDescriptorBufferInfo { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + +typedef struct VkDescriptorImageInfo { + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; + +typedef struct VkDescriptorPoolSize { + VkDescriptorType type; + uint32_t descriptorCount; +} VkDescriptorPoolSize; + +typedef struct VkDescriptorPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const VkDescriptorPoolSize* pPoolSizes; +} VkDescriptorPoolCreateInfo; + +typedef struct VkDescriptorSetAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; +} VkDescriptorSetAllocateInfo; + +typedef struct VkDescriptorSetLayoutBinding { + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct VkDescriptorSetLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const VkDescriptorSetLayoutBinding* pBindings; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct VkWriteDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + const VkDescriptorImageInfo* pImageInfo; + const VkDescriptorBufferInfo* pBufferInfo; + const VkBufferView* pTexelBufferView; +} VkWriteDescriptorSet; + +typedef union VkClearColorValue { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; +} VkClearColorValue; + +typedef struct VkDrawIndexedIndirectCommand { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCommand; + +typedef struct VkDrawIndirectCommand { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCommand; + +typedef struct VkVertexInputBindingDescription { + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; +} VkVertexInputBindingDescription; + +typedef struct VkVertexInputAttributeDescription { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription; + +typedef struct VkPipelineVertexInputStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct VkPipelineInputAssemblyStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct VkPipelineTessellationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct VkViewport { + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct VkPipelineViewportStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const VkViewport* pViewports; + uint32_t scissorCount; + const VkRect2D* pScissors; +} VkPipelineViewportStateCreateInfo; + +typedef struct VkPipelineRasterizationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} VkPipelineRasterizationStateCreateInfo; + +typedef struct VkPipelineMultisampleStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + const VkSampleMask* pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct VkStencilOpState { + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; +} VkStencilOpState; + +typedef struct VkPipelineDepthStencilStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct VkPipelineColorBlendAttachmentState { + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct VkPipelineColorBlendStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct VkPipelineDynamicStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + +typedef struct VkGraphicsPipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; + const VkPipelineViewportStateCreateInfo* pViewportState; + const VkPipelineRasterizationStateCreateInfo* pRasterizationState; + const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct VkAttachmentDescription { + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; + +typedef struct VkAttachmentReference { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct VkFramebufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint32_t attachmentCount; + const VkImageView* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct VkSubpassDescription { + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const VkAttachmentReference* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference* pColorAttachments; + const VkAttachmentReference* pResolveAttachments; + const VkAttachmentReference* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription; + +typedef struct VkSubpassDependency { + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} VkSubpassDependency; + +typedef struct VkRenderPassCreateInfo { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct VkClearDepthStencilValue { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} VkClearValue; + +typedef struct VkClearAttachment { + VkImageAspectFlags aspectMask; + uint32_t colorAttachment; + VkClearValue clearValue; +} VkClearAttachment; + +typedef struct VkClearRect { + VkRect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkClearRect; + +typedef struct VkImageBlit { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit; + +typedef struct VkImageResolve { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef struct VkRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + const VkClearValue* pClearValues; +} VkRenderPassBeginInfo; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); +typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); +typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); +typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); +typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); +typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); +typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); +typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); +typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); +typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); +typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); +typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); +typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); +typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); +typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); +typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); +typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance); + +VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( + VkInstance instance, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( + VkInstance instance, + const char* pName); + +VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( + VkDevice device, + const char* pName); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( + VkDevice device, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( + VkQueue queue); + +VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( + VkDevice device); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory); + +VKAPI_ATTR void VKAPI_CALL vkFreeMemory( + VkDevice device, + VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( + VkDevice device, + VkDeviceMemory memory); + +VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( + VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFence( + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( + VkDevice device, + VkFence fence); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore); + +VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImage( + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent); + +VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( + VkDevice device, + VkEvent event); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView); + +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule); + +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData); + +VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler); + +VKAPI_ATTR void VKAPI_CALL vkDestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); + +VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer); + +VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( + VkCommandBuffer commandBuffer, + const float blendConstants[4]); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +VKAPI_ATTR void VKAPI_CALL vkCmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( + VkCommandBuffer commandBuffer); +#endif + + +// VK_VERSION_1_1 is a preprocessor guard. Do not pass it to API calls. +#define VK_VERSION_1_1 1 +// Vulkan 1.1 version number +#define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0 + +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) +#define VK_MAX_DEVICE_GROUP_SIZE 32U +#define VK_LUID_SIZE 8U +#define VK_QUEUE_FAMILY_EXTERNAL (~1U) + +typedef enum VkDescriptorUpdateTemplateType { + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS = 1, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorUpdateTemplateType; + +typedef enum VkSamplerYcbcrModelConversion { + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrModelConversion; + +typedef enum VkSamplerYcbcrRange { + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, + VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, + VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrRange; + +typedef enum VkChromaLocation { + VK_CHROMA_LOCATION_COSITED_EVEN = 0, + VK_CHROMA_LOCATION_MIDPOINT = 1, + VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN, + VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT, + VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF +} VkChromaLocation; + +typedef enum VkPointClippingBehavior { + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkPointClippingBehavior; + +typedef enum VkTessellationDomainOrigin { + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF +} VkTessellationDomainOrigin; + +typedef enum VkPeerMemoryFeatureFlagBits { + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPeerMemoryFeatureFlagBits; +typedef VkFlags VkPeerMemoryFeatureFlags; + +typedef enum VkMemoryAllocateFlagBits { + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004, + VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT = 0x00000008, + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryAllocateFlagBits; +typedef VkFlags VkMemoryAllocateFlags; +typedef VkFlags VkCommandPoolTrimFlags; + +typedef enum VkExternalMemoryHandleTypeFlagBits { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS = 0x00008000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX = 0x00004000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT = 0x00010000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT = 0x00020000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT = 0x00040000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBits; +typedef VkFlags VkExternalMemoryHandleTypeFlags; + +typedef enum VkExternalMemoryFeatureFlagBits { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBits; +typedef VkFlags VkExternalMemoryFeatureFlags; + +typedef enum VkExternalFenceHandleTypeFlagBits { + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalFenceHandleTypeFlagBits; +typedef VkFlags VkExternalFenceHandleTypeFlags; + +typedef enum VkExternalFenceFeatureFlagBits { + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalFenceFeatureFlagBits; +typedef VkFlags VkExternalFenceFeatureFlags; + +typedef enum VkFenceImportFlagBits { + VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFenceImportFlagBits; +typedef VkFlags VkFenceImportFlags; + +typedef enum VkSemaphoreImportFlagBits { + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreImportFlagBits; +typedef VkFlags VkSemaphoreImportFlags; + +typedef enum VkExternalSemaphoreHandleTypeFlagBits { + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0x00000080, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalSemaphoreHandleTypeFlagBits; +typedef VkFlags VkExternalSemaphoreHandleTypeFlags; + +typedef enum VkExternalSemaphoreFeatureFlagBits { + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalSemaphoreFeatureFlagBits; +typedef VkFlags VkExternalSemaphoreFeatureFlags; + +typedef enum VkSubgroupFeatureFlagBits { + VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, + VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, + VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, + VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, + VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, + VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, + VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, + VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, + VK_SUBGROUP_FEATURE_ROTATE_BIT = 0x00000200, + VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT = 0x00000400, + VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT = 0x00000100, + VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT, + VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_BIT, + VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT, + VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubgroupFeatureFlagBits; +typedef VkFlags VkSubgroupFeatureFlags; +typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; +typedef struct VkBindBufferMemoryInfo { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindBufferMemoryInfo; + +typedef struct VkBindImageMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindImageMemoryInfo; + +typedef struct VkMemoryDedicatedRequirements { + VkStructureType sType; + void* pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirements; + +typedef struct VkMemoryDedicatedAllocateInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkMemoryDedicatedAllocateInfo; + +typedef struct VkMemoryAllocateFlagsInfo { + VkStructureType sType; + const void* pNext; + VkMemoryAllocateFlags flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfo; + +typedef struct VkDeviceGroupCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; +} VkDeviceGroupCommandBufferBeginInfo; + +typedef struct VkDeviceGroupSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + const uint32_t* pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + const uint32_t* pSignalSemaphoreDeviceIndices; +} VkDeviceGroupSubmitInfo; + +typedef struct VkDeviceGroupBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; +} VkDeviceGroupBindSparseInfo; + +typedef struct VkBindBufferMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindBufferMemoryDeviceGroupInfo; + +typedef struct VkBindImageMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + const VkRect2D* pSplitInstanceBindRegions; +} VkBindImageMemoryDeviceGroupInfo; + +typedef struct VkPhysicalDeviceGroupProperties { + VkStructureType sType; + void* pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupProperties; + +typedef struct VkDeviceGroupDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t physicalDeviceCount; + const VkPhysicalDevice* pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfo; + +typedef struct VkBufferMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferMemoryRequirementsInfo2; + +typedef struct VkImageMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageMemoryRequirementsInfo2; + +typedef struct VkImageSparseMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageSparseMemoryRequirementsInfo2; + +typedef struct VkMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkMemoryRequirements memoryRequirements; +} VkMemoryRequirements2; + +typedef struct VkSparseImageMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkSparseImageMemoryRequirements memoryRequirements; +} VkSparseImageMemoryRequirements2; + +typedef struct VkPhysicalDeviceFeatures2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceFeatures features; +} VkPhysicalDeviceFeatures2; + +typedef struct VkPhysicalDeviceProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceProperties properties; +} VkPhysicalDeviceProperties2; + +typedef struct VkFormatProperties2 { + VkStructureType sType; + void* pNext; + VkFormatProperties formatProperties; +} VkFormatProperties2; + +typedef struct VkImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkImageFormatProperties imageFormatProperties; +} VkImageFormatProperties2; + +typedef struct VkPhysicalDeviceImageFormatInfo2 { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} VkPhysicalDeviceImageFormatInfo2; + +typedef struct VkQueueFamilyProperties2 { + VkStructureType sType; + void* pNext; + VkQueueFamilyProperties queueFamilyProperties; +} VkQueueFamilyProperties2; + +typedef struct VkPhysicalDeviceMemoryProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceMemoryProperties memoryProperties; +} VkPhysicalDeviceMemoryProperties2; + +typedef struct VkSparseImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkSparseImageFormatProperties properties; +} VkSparseImageFormatProperties2; + +typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; +} VkPhysicalDeviceSparseImageFormatInfo2; + +typedef struct VkImageViewUsageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfo; + +typedef struct VkPhysicalDeviceProtectedMemoryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 protectedMemory; +} VkPhysicalDeviceProtectedMemoryFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryProperties { + VkStructureType sType; + void* pNext; + VkBool32 protectedNoFault; +} VkPhysicalDeviceProtectedMemoryProperties; + +typedef struct VkDeviceQueueInfo2 { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; +} VkDeviceQueueInfo2; + +typedef struct VkProtectedSubmitInfo { + VkStructureType sType; + const void* pNext; + VkBool32 protectedSubmit; +} VkProtectedSubmitInfo; + +typedef struct VkBindImagePlaneMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkBindImagePlaneMemoryInfo; + +typedef struct VkImagePlaneMemoryRequirementsInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkImagePlaneMemoryRequirementsInfo; + +typedef struct VkExternalMemoryProperties { + VkExternalMemoryFeatureFlags externalMemoryFeatures; + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlags compatibleHandleTypes; +} VkExternalMemoryProperties; + +typedef struct VkPhysicalDeviceExternalImageFormatInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalImageFormatInfo; + +typedef struct VkExternalImageFormatProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalImageFormatProperties; + +typedef struct VkPhysicalDeviceExternalBufferInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalBufferInfo; + +typedef struct VkExternalBufferProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalBufferProperties; + +typedef struct VkPhysicalDeviceIDProperties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDProperties; + +typedef struct VkExternalMemoryImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryImageCreateInfo; + +typedef struct VkExternalMemoryBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryBufferCreateInfo; + +typedef struct VkExportMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExportMemoryAllocateInfo; + +typedef struct VkPhysicalDeviceExternalFenceInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalFenceInfo; + +typedef struct VkExternalFenceProperties { + VkStructureType sType; + void* pNext; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} VkExternalFenceProperties; + +typedef struct VkExportFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlags handleTypes; +} VkExportFenceCreateInfo; + +typedef struct VkExportSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} VkExportSemaphoreCreateInfo; + +typedef struct VkPhysicalDeviceExternalSemaphoreInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalSemaphoreInfo; + +typedef struct VkExternalSemaphoreProperties { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} VkExternalSemaphoreProperties; + +typedef struct VkPhysicalDeviceSubgroupProperties { + VkStructureType sType; + void* pNext; + uint32_t subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} VkPhysicalDeviceSubgroupProperties; + +typedef struct VkPhysicalDevice16BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeatures; + +typedef struct VkPhysicalDeviceVariablePointersFeatures { + VkStructureType sType; + void* pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointersFeatures; + +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; + +typedef struct VkDescriptorUpdateTemplateEntry { + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + size_t offset; + size_t stride; +} VkDescriptorUpdateTemplateEntry; + +typedef struct VkDescriptorUpdateTemplateCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorUpdateTemplateCreateFlags flags; + uint32_t descriptorUpdateEntryCount; + const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateType templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint32_t set; +} VkDescriptorUpdateTemplateCreateInfo; + +typedef struct VkPhysicalDeviceMaintenance3Properties { + VkStructureType sType; + void* pNext; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceMaintenance3Properties; + +typedef struct VkDescriptorSetLayoutSupport { + VkStructureType sType; + void* pNext; + VkBool32 supported; +} VkDescriptorSetLayoutSupport; + +typedef struct VkSamplerYcbcrConversionCreateInfo { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} VkSamplerYcbcrConversionCreateInfo; + +typedef struct VkSamplerYcbcrConversionInfo { + VkStructureType sType; + const void* pNext; + VkSamplerYcbcrConversion conversion; +} VkSamplerYcbcrConversionInfo; + +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { + VkStructureType sType; + void* pNext; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeatures; + +typedef struct VkSamplerYcbcrConversionImageFormatProperties { + VkStructureType sType; + void* pNext; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatProperties; + +typedef struct VkDeviceGroupRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D* pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfo; + +typedef struct VkPhysicalDevicePointClippingProperties { + VkStructureType sType; + void* pNext; + VkPointClippingBehavior pointClippingBehavior; +} VkPhysicalDevicePointClippingProperties; + +typedef struct VkInputAttachmentAspectReference { + uint32_t subpass; + uint32_t inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} VkInputAttachmentAspectReference; + +typedef struct VkRenderPassInputAttachmentAspectCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t aspectReferenceCount; + const VkInputAttachmentAspectReference* pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfo; + +typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkTessellationDomainOrigin domainOrigin; +} VkPipelineTessellationDomainOriginStateCreateInfo; + +typedef struct VkRenderPassMultiviewCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + const int32_t* pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks; +} VkRenderPassMultiviewCreateInfo; + +typedef struct VkPhysicalDeviceMultiviewFeatures { + VkStructureType sType; + void* pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeatures; + +typedef struct VkPhysicalDeviceMultiviewProperties { + VkStructureType sType; + void* pNext; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewProperties; + +typedef struct VkPhysicalDeviceShaderDrawParametersFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceShaderDrawParametersFeatures; + +typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( + uint32_t* pApiVersion); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); + +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( + VkDevice device, + const VkDeviceQueueInfo2* pQueueInfo, + VkQueue* pQueue); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); + +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); + +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); +#endif + + +// VK_VERSION_1_2 is a preprocessor guard. Do not pass it to API calls. +#define VK_VERSION_1_2 1 +// Vulkan 1.2 version number +#define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0 + +#define VK_MAX_DRIVER_NAME_SIZE 256U +#define VK_MAX_DRIVER_INFO_SIZE 256U + +typedef enum VkDriverId { + VK_DRIVER_ID_AMD_PROPRIETARY = 1, + VK_DRIVER_ID_AMD_OPEN_SOURCE = 2, + VK_DRIVER_ID_MESA_RADV = 3, + VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4, + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5, + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6, + VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7, + VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8, + VK_DRIVER_ID_ARM_PROPRIETARY = 9, + VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10, + VK_DRIVER_ID_GGP_PROPRIETARY = 11, + VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12, + VK_DRIVER_ID_MESA_LLVMPIPE = 13, + VK_DRIVER_ID_MOLTENVK = 14, + VK_DRIVER_ID_COREAVI_PROPRIETARY = 15, + VK_DRIVER_ID_JUICE_PROPRIETARY = 16, + VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17, + VK_DRIVER_ID_MESA_TURNIP = 18, + VK_DRIVER_ID_MESA_V3DV = 19, + VK_DRIVER_ID_MESA_PANVK = 20, + VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21, + VK_DRIVER_ID_MESA_VENUS = 22, + VK_DRIVER_ID_MESA_DOZEN = 23, + VK_DRIVER_ID_MESA_NVK = 24, + VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25, + VK_DRIVER_ID_MESA_HONEYKRISP = 26, + VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN = 27, + VK_DRIVER_ID_MESA_KOSMICKRISP = 28, + VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY, + VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE, + VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV, + VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY, + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS, + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA, + VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY, + VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY, + VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY, + VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER, + VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY, + VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY, + VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF +} VkDriverId; + +typedef enum VkShaderFloatControlsIndependence { + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF +} VkShaderFloatControlsIndependence; + +typedef enum VkSemaphoreType { + VK_SEMAPHORE_TYPE_BINARY = 0, + VK_SEMAPHORE_TYPE_TIMELINE = 1, + VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY, + VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE, + VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreType; + +typedef enum VkSamplerReductionMode { + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, + VK_SAMPLER_REDUCTION_MODE_MIN = 1, + VK_SAMPLER_REDUCTION_MODE_MAX = 2, + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM = 1000521000, + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, + VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN, + VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX, + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerReductionMode; + +typedef enum VkResolveModeFlagBits { + VK_RESOLVE_MODE_NONE = 0, + VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001, + VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002, + VK_RESOLVE_MODE_MIN_BIT = 0x00000004, + VK_RESOLVE_MODE_MAX_BIT = 0x00000008, + VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID = 0x00000010, + VK_RESOLVE_MODE_CUSTOM_BIT_EXT = 0x00000020, + VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE, + VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, + VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT, + VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT, + VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT, + // VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID is a legacy alias + VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID = VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID, + VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkResolveModeFlagBits; +typedef VkFlags VkResolveModeFlags; + +typedef enum VkSemaphoreWaitFlagBits { + VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001, + VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT, + VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreWaitFlagBits; +typedef VkFlags VkSemaphoreWaitFlags; + +typedef enum VkDescriptorBindingFlagBits { + VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001, + VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002, + VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004, + VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008, + VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, + VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, + VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, + VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, + VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorBindingFlagBits; +typedef VkFlags VkDescriptorBindingFlags; +typedef struct VkPhysicalDeviceVulkan11Features { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; + VkBool32 protectedMemory; + VkBool32 samplerYcbcrConversion; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceVulkan11Features; + +typedef struct VkPhysicalDeviceVulkan11Properties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; + uint32_t subgroupSize; + VkShaderStageFlags subgroupSupportedStages; + VkSubgroupFeatureFlags subgroupSupportedOperations; + VkBool32 subgroupQuadOperationsInAllStages; + VkPointClippingBehavior pointClippingBehavior; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; + VkBool32 protectedNoFault; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceVulkan11Properties; + +typedef struct VkPhysicalDeviceVulkan12Features { + VkStructureType sType; + void* pNext; + VkBool32 samplerMirrorClampToEdge; + VkBool32 drawIndirectCount; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; + VkBool32 descriptorIndexing; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; + VkBool32 samplerFilterMinmax; + VkBool32 scalarBlockLayout; + VkBool32 imagelessFramebuffer; + VkBool32 uniformBufferStandardLayout; + VkBool32 shaderSubgroupExtendedTypes; + VkBool32 separateDepthStencilLayouts; + VkBool32 hostQueryReset; + VkBool32 timelineSemaphore; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; + VkBool32 shaderOutputViewportIndex; + VkBool32 shaderOutputLayer; + VkBool32 subgroupBroadcastDynamicId; +} VkPhysicalDeviceVulkan12Features; + +typedef struct VkConformanceVersion { + uint8_t major; + uint8_t minor; + uint8_t subminor; + uint8_t patch; +} VkConformanceVersion; + +typedef struct VkPhysicalDeviceVulkan12Properties { + VkStructureType sType; + void* pNext; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; + uint64_t maxTimelineSemaphoreValueDifference; + VkSampleCountFlags framebufferIntegerColorSampleCounts; +} VkPhysicalDeviceVulkan12Properties; + +typedef struct VkImageFormatListCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkImageFormatListCreateInfo; + +typedef struct VkPhysicalDeviceDriverProperties { + VkStructureType sType; + void* pNext; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; +} VkPhysicalDeviceDriverProperties; + +typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures { + VkStructureType sType; + void* pNext; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; +} VkPhysicalDeviceVulkanMemoryModelFeatures; + +typedef struct VkPhysicalDeviceHostQueryResetFeatures { + VkStructureType sType; + void* pNext; + VkBool32 hostQueryReset; +} VkPhysicalDeviceHostQueryResetFeatures; + +typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures { + VkStructureType sType; + void* pNext; + VkBool32 timelineSemaphore; +} VkPhysicalDeviceTimelineSemaphoreFeatures; + +typedef struct VkPhysicalDeviceTimelineSemaphoreProperties { + VkStructureType sType; + void* pNext; + uint64_t maxTimelineSemaphoreValueDifference; +} VkPhysicalDeviceTimelineSemaphoreProperties; + +typedef struct VkSemaphoreTypeCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreType semaphoreType; + uint64_t initialValue; +} VkSemaphoreTypeCreateInfo; + +typedef struct VkTimelineSemaphoreSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValueCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValueCount; + const uint64_t* pSignalSemaphoreValues; +} VkTimelineSemaphoreSubmitInfo; + +typedef struct VkSemaphoreWaitInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreWaitFlags flags; + uint32_t semaphoreCount; + const VkSemaphore* pSemaphores; + const uint64_t* pValues; +} VkSemaphoreWaitInfo; + +typedef struct VkSemaphoreSignalInfo { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + uint64_t value; +} VkSemaphoreSignalInfo; + +typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeatures; + +typedef struct VkBufferDeviceAddressInfo { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferDeviceAddressInfo; + +typedef struct VkBufferOpaqueCaptureAddressCreateInfo { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkBufferOpaqueCaptureAddressCreateInfo; + +typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkMemoryOpaqueCaptureAddressAllocateInfo; + +typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkDeviceMemoryOpaqueCaptureAddressInfo; + +typedef struct VkPhysicalDevice8BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; +} VkPhysicalDevice8BitStorageFeatures; + +typedef struct VkPhysicalDeviceShaderAtomicInt64Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; +} VkPhysicalDeviceShaderAtomicInt64Features; + +typedef struct VkPhysicalDeviceShaderFloat16Int8Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; +} VkPhysicalDeviceShaderFloat16Int8Features; + +typedef struct VkPhysicalDeviceFloatControlsProperties { + VkStructureType sType; + void* pNext; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; +} VkPhysicalDeviceFloatControlsProperties; + +typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t bindingCount; + const VkDescriptorBindingFlags* pBindingFlags; +} VkDescriptorSetLayoutBindingFlagsCreateInfo; + +typedef struct VkPhysicalDeviceDescriptorIndexingFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; +} VkPhysicalDeviceDescriptorIndexingFeatures; + +typedef struct VkPhysicalDeviceDescriptorIndexingProperties { + VkStructureType sType; + void* pNext; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; +} VkPhysicalDeviceDescriptorIndexingProperties; + +typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSetCount; + const uint32_t* pDescriptorCounts; +} VkDescriptorSetVariableDescriptorCountAllocateInfo; + +typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport { + VkStructureType sType; + void* pNext; + uint32_t maxVariableDescriptorCount; +} VkDescriptorSetVariableDescriptorCountLayoutSupport; + +typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures { + VkStructureType sType; + void* pNext; + VkBool32 scalarBlockLayout; +} VkPhysicalDeviceScalarBlockLayoutFeatures; + +typedef struct VkSamplerReductionModeCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerReductionMode reductionMode; +} VkSamplerReductionModeCreateInfo; + +typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties { + VkStructureType sType; + void* pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxProperties; + +typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures { + VkStructureType sType; + void* pNext; + VkBool32 uniformBufferStandardLayout; +} VkPhysicalDeviceUniformBufferStandardLayoutFeatures; + +typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupExtendedTypes; +} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; + +typedef struct VkAttachmentDescription2 { + VkStructureType sType; + const void* pNext; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription2; + +typedef struct VkAttachmentReference2 { + VkStructureType sType; + const void* pNext; + uint32_t attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} VkAttachmentReference2; + +typedef struct VkSubpassDescription2 { + VkStructureType sType; + const void* pNext; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + const VkAttachmentReference2* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference2* pColorAttachments; + const VkAttachmentReference2* pResolveAttachments; + const VkAttachmentReference2* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription2; + +typedef struct VkSubpassDependency2 { + VkStructureType sType; + const void* pNext; + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int32_t viewOffset; +} VkSubpassDependency2; + +typedef struct VkRenderPassCreateInfo2 { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription2* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription2* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency2* pDependencies; + uint32_t correlatedViewMaskCount; + const uint32_t* pCorrelatedViewMasks; +} VkRenderPassCreateInfo2; + +typedef struct VkSubpassBeginInfo { + VkStructureType sType; + const void* pNext; + VkSubpassContents contents; +} VkSubpassBeginInfo; + +typedef struct VkSubpassEndInfo { + VkStructureType sType; + const void* pNext; +} VkSubpassEndInfo; + +typedef struct VkSubpassDescriptionDepthStencilResolve { + VkStructureType sType; + const void* pNext; + VkResolveModeFlagBits depthResolveMode; + VkResolveModeFlagBits stencilResolveMode; + const VkAttachmentReference2* pDepthStencilResolveAttachment; +} VkSubpassDescriptionDepthStencilResolve; + +typedef struct VkPhysicalDeviceDepthStencilResolveProperties { + VkStructureType sType; + void* pNext; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; +} VkPhysicalDeviceDepthStencilResolveProperties; + +typedef struct VkImageStencilUsageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags stencilUsage; +} VkImageStencilUsageCreateInfo; + +typedef struct VkPhysicalDeviceImagelessFramebufferFeatures { + VkStructureType sType; + void* pNext; + VkBool32 imagelessFramebuffer; +} VkPhysicalDeviceImagelessFramebufferFeatures; + +typedef struct VkFramebufferAttachmentImageInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageUsageFlags usage; + uint32_t width; + uint32_t height; + uint32_t layerCount; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkFramebufferAttachmentImageInfo; + +typedef struct VkFramebufferAttachmentsCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t attachmentImageInfoCount; + const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos; +} VkFramebufferAttachmentsCreateInfo; + +typedef struct VkRenderPassAttachmentBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkImageView* pAttachments; +} VkRenderPassAttachmentBeginInfo; + +typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { + VkStructureType sType; + void* pNext; + VkBool32 separateDepthStencilLayouts; +} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; + +typedef struct VkAttachmentReferenceStencilLayout { + VkStructureType sType; + void* pNext; + VkImageLayout stencilLayout; +} VkAttachmentReferenceStencilLayout; + +typedef struct VkAttachmentDescriptionStencilLayout { + VkStructureType sType; + void* pNext; + VkImageLayout stencilInitialLayout; + VkImageLayout stencilFinalLayout; +} VkAttachmentDescriptionStencilLayout; + +typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkResetQueryPool( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); + +VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout); + +VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo); + +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo); +#endif + + +// VK_VERSION_1_3 is a preprocessor guard. Do not pass it to API calls. +#define VK_VERSION_1_3 1 +// Vulkan 1.3 version number +#define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0)// Patch version should always be set to 0 + +typedef uint64_t VkFlags64; +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlot) + +typedef enum VkToolPurposeFlagBits { + VK_TOOL_PURPOSE_VALIDATION_BIT = 0x00000001, + VK_TOOL_PURPOSE_PROFILING_BIT = 0x00000002, + VK_TOOL_PURPOSE_TRACING_BIT = 0x00000004, + VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT = 0x00000008, + VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT = 0x00000010, + VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020, + VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040, + VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = VK_TOOL_PURPOSE_VALIDATION_BIT, + VK_TOOL_PURPOSE_PROFILING_BIT_EXT = VK_TOOL_PURPOSE_PROFILING_BIT, + VK_TOOL_PURPOSE_TRACING_BIT_EXT = VK_TOOL_PURPOSE_TRACING_BIT, + VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, + VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT, + VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkToolPurposeFlagBits; +typedef VkFlags VkToolPurposeFlags; +typedef VkFlags VkPrivateDataSlotCreateFlags; +typedef VkFlags64 VkPipelineStageFlags2; + +// Flag bits for VkPipelineStageFlagBits2 +typedef VkFlags64 VkPipelineStageFlagBits2; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE = 0ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 0x00000001ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 0x00000002ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 0x00000004ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 0x00000008ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 0x00000040ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 0x00000080ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 0x00000100ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 0x00000200ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 0x00000800ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 0x00002000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT = 0x00004000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 0x00008000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 0x00010000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT = 0x100000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT = 0x200000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT = 0x400000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT = 0x800000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 0x1000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 0x2000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT = 0x00020000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 0x00080000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT = 0x00100000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI = 0x8000000000ULL; +// VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI is a legacy alias +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR = 0x10000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 0x40000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0x20000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0x20000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV = 0x100000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM = 0x40000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR = 0x400000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT = 0x200000000000ULL; + +typedef VkFlags64 VkAccessFlags2; + +// Flag bits for VkAccessFlagBits2 +typedef VkFlags64 VkAccessFlagBits2; +static const VkAccessFlagBits2 VK_ACCESS_2_NONE = 0ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 0x00000001ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT = 0x00000002ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT = 0x00000008ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 0x00000010ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT = 0x00000020ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT = 0x00000040ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 0x00000080ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT = 0x00000800ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT = 0x00001000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT = 0x00002000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT = 0x00004000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT = 0x00008000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT = 0x00010000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 0x100000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 0x200000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x400000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT = 0x200000000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT = 0x400000000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM = 0x8000000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM = 0x10000000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_NONE_KHR = 0ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT = 0x00020000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT = 0x00040000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT = 0x20000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 0x10000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0x100000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 0x200000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0x40000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0x80000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM = 0x800000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM = 0x1000000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT = 0x80000000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT = 0x100000000000000ULL; + + +typedef enum VkSubmitFlagBits { + VK_SUBMIT_PROTECTED_BIT = 0x00000001, + VK_SUBMIT_PROTECTED_BIT_KHR = VK_SUBMIT_PROTECTED_BIT, + VK_SUBMIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubmitFlagBits; +typedef VkFlags VkSubmitFlags; +typedef VkFlags64 VkFormatFeatureFlags2; + +// Flag bits for VkFormatFeatureFlagBits2 +typedef VkFlags64 VkFormatFeatureFlagBits2; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 0x00000001ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 0x00000002ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 0x00000010ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 0x00000040ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 0x00000080ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 0x00000400ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 0x00000800ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 0x00004000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 0x00008000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT = 0x00400000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 0x00800000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 0x80000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 0x100000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 0x200000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 0x00002000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT = 0x400000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000010ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 0x00000020ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 0x00000040ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000080ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 0x00000100ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000200ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 0x00000400ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 0x00000800ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 0x00001000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 0x00004000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 0x00008000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 0x00400000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 0x80000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 0x100000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV = 0x8000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0x400000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0x800000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 0x1000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 0x2000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM = 0x8000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM = 0x80000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0x10000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM = 0x1000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR = 0x800000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x2000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x4000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 0x10000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 0x20000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 0x40000000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 0x80000000000000ULL; + + +typedef enum VkPipelineCreationFeedbackFlagBits { + VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0x00000001, + VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0x00000002, + VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0x00000004, + VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, + VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, + VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT, + VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCreationFeedbackFlagBits; +typedef VkFlags VkPipelineCreationFeedbackFlags; + +typedef enum VkRenderingFlagBits { + VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0x00000001, + VK_RENDERING_SUSPENDING_BIT = 0x00000002, + VK_RENDERING_RESUMING_BIT = 0x00000004, + VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008, + VK_RENDERING_CONTENTS_INLINE_BIT_KHR = 0x00000010, + VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x00000020, + VK_RENDERING_FRAGMENT_REGION_BIT_EXT = 0x00000040, + VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT = 0x00000080, + VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR = 0x00000100, + VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, + VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT, + VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT, + VK_RENDERING_CONTENTS_INLINE_BIT_EXT = VK_RENDERING_CONTENTS_INLINE_BIT_KHR, + VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkRenderingFlagBits; +typedef VkFlags VkRenderingFlags; +typedef struct VkPhysicalDeviceVulkan13Features { + VkStructureType sType; + void* pNext; + VkBool32 robustImageAccess; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; + VkBool32 pipelineCreationCacheControl; + VkBool32 privateData; + VkBool32 shaderDemoteToHelperInvocation; + VkBool32 shaderTerminateInvocation; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; + VkBool32 synchronization2; + VkBool32 textureCompressionASTC_HDR; + VkBool32 shaderZeroInitializeWorkgroupMemory; + VkBool32 dynamicRendering; + VkBool32 shaderIntegerDotProduct; + VkBool32 maintenance4; +} VkPhysicalDeviceVulkan13Features; + +typedef struct VkPhysicalDeviceVulkan13Properties { + VkStructureType sType; + void* pNext; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + uint32_t maxInlineUniformTotalSize; + VkBool32 integerDotProduct8BitUnsignedAccelerated; + VkBool32 integerDotProduct8BitSignedAccelerated; + VkBool32 integerDotProduct8BitMixedSignednessAccelerated; + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProduct16BitUnsignedAccelerated; + VkBool32 integerDotProduct16BitSignedAccelerated; + VkBool32 integerDotProduct16BitMixedSignednessAccelerated; + VkBool32 integerDotProduct32BitUnsignedAccelerated; + VkBool32 integerDotProduct32BitSignedAccelerated; + VkBool32 integerDotProduct32BitMixedSignednessAccelerated; + VkBool32 integerDotProduct64BitUnsignedAccelerated; + VkBool32 integerDotProduct64BitSignedAccelerated; + VkBool32 integerDotProduct64BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize maxBufferSize; +} VkPhysicalDeviceVulkan13Properties; + +typedef struct VkPhysicalDeviceToolProperties { + VkStructureType sType; + void* pNext; + char name[VK_MAX_EXTENSION_NAME_SIZE]; + char version[VK_MAX_EXTENSION_NAME_SIZE]; + VkToolPurposeFlags purposes; + char description[VK_MAX_DESCRIPTION_SIZE]; + char layer[VK_MAX_EXTENSION_NAME_SIZE]; +} VkPhysicalDeviceToolProperties; + +typedef struct VkPhysicalDevicePrivateDataFeatures { + VkStructureType sType; + void* pNext; + VkBool32 privateData; +} VkPhysicalDevicePrivateDataFeatures; + +typedef struct VkDevicePrivateDataCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t privateDataSlotRequestCount; +} VkDevicePrivateDataCreateInfo; + +typedef struct VkPrivateDataSlotCreateInfo { + VkStructureType sType; + const void* pNext; + VkPrivateDataSlotCreateFlags flags; +} VkPrivateDataSlotCreateInfo; + +typedef struct VkMemoryBarrier2 { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; +} VkMemoryBarrier2; + +typedef struct VkBufferMemoryBarrier2 { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier2; + +typedef struct VkImageMemoryBarrier2 { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier2; + +typedef struct VkDependencyInfo { + VkStructureType sType; + const void* pNext; + VkDependencyFlags dependencyFlags; + uint32_t memoryBarrierCount; + const VkMemoryBarrier2* pMemoryBarriers; + uint32_t bufferMemoryBarrierCount; + const VkBufferMemoryBarrier2* pBufferMemoryBarriers; + uint32_t imageMemoryBarrierCount; + const VkImageMemoryBarrier2* pImageMemoryBarriers; +} VkDependencyInfo; + +typedef struct VkSemaphoreSubmitInfo { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + uint64_t value; + VkPipelineStageFlags2 stageMask; + uint32_t deviceIndex; +} VkSemaphoreSubmitInfo; + +typedef struct VkCommandBufferSubmitInfo { + VkStructureType sType; + const void* pNext; + VkCommandBuffer commandBuffer; + uint32_t deviceMask; +} VkCommandBufferSubmitInfo; + +typedef struct VkSubmitInfo2 { + VkStructureType sType; + const void* pNext; + VkSubmitFlags flags; + uint32_t waitSemaphoreInfoCount; + const VkSemaphoreSubmitInfo* pWaitSemaphoreInfos; + uint32_t commandBufferInfoCount; + const VkCommandBufferSubmitInfo* pCommandBufferInfos; + uint32_t signalSemaphoreInfoCount; + const VkSemaphoreSubmitInfo* pSignalSemaphoreInfos; +} VkSubmitInfo2; + +typedef struct VkPhysicalDeviceSynchronization2Features { + VkStructureType sType; + void* pNext; + VkBool32 synchronization2; +} VkPhysicalDeviceSynchronization2Features; + +typedef struct VkBufferCopy2 { + VkStructureType sType; + const void* pNext; + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy2; + +typedef struct VkCopyBufferInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer srcBuffer; + VkBuffer dstBuffer; + uint32_t regionCount; + const VkBufferCopy2* pRegions; +} VkCopyBufferInfo2; + +typedef struct VkImageCopy2 { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy2; + +typedef struct VkCopyImageInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageCopy2* pRegions; +} VkCopyImageInfo2; + +typedef struct VkBufferImageCopy2 { + VkStructureType sType; + const void* pNext; + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy2; + +typedef struct VkCopyBufferToImageInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer srcBuffer; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkBufferImageCopy2* pRegions; +} VkCopyBufferToImageInfo2; + +typedef struct VkCopyImageToBufferInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkBuffer dstBuffer; + uint32_t regionCount; + const VkBufferImageCopy2* pRegions; +} VkCopyImageToBufferInfo2; + +typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures { + VkStructureType sType; + void* pNext; + VkBool32 textureCompressionASTC_HDR; +} VkPhysicalDeviceTextureCompressionASTCHDRFeatures; + +typedef struct VkFormatProperties3 { + VkStructureType sType; + void* pNext; + VkFormatFeatureFlags2 linearTilingFeatures; + VkFormatFeatureFlags2 optimalTilingFeatures; + VkFormatFeatureFlags2 bufferFeatures; +} VkFormatProperties3; + +typedef struct VkPhysicalDeviceMaintenance4Features { + VkStructureType sType; + void* pNext; + VkBool32 maintenance4; +} VkPhysicalDeviceMaintenance4Features; + +typedef struct VkPhysicalDeviceMaintenance4Properties { + VkStructureType sType; + void* pNext; + VkDeviceSize maxBufferSize; +} VkPhysicalDeviceMaintenance4Properties; + +typedef struct VkDeviceBufferMemoryRequirements { + VkStructureType sType; + const void* pNext; + const VkBufferCreateInfo* pCreateInfo; +} VkDeviceBufferMemoryRequirements; + +typedef struct VkDeviceImageMemoryRequirements { + VkStructureType sType; + const void* pNext; + const VkImageCreateInfo* pCreateInfo; + VkImageAspectFlagBits planeAspect; +} VkDeviceImageMemoryRequirements; + +typedef struct VkPipelineCreationFeedback { + VkPipelineCreationFeedbackFlags flags; + uint64_t duration; +} VkPipelineCreationFeedback; + +typedef struct VkPipelineCreationFeedbackCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreationFeedback* pPipelineCreationFeedback; + uint32_t pipelineStageCreationFeedbackCount; + VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks; +} VkPipelineCreationFeedbackCreateInfo; + +typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderTerminateInvocation; +} VkPhysicalDeviceShaderTerminateInvocationFeatures; + +typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDemoteToHelperInvocation; +} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures; + +typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures { + VkStructureType sType; + void* pNext; + VkBool32 pipelineCreationCacheControl; +} VkPhysicalDevicePipelineCreationCacheControlFeatures; + +typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderZeroInitializeWorkgroupMemory; +} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + +typedef struct VkPhysicalDeviceImageRobustnessFeatures { + VkStructureType sType; + void* pNext; + VkBool32 robustImageAccess; +} VkPhysicalDeviceImageRobustnessFeatures; + +typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures { + VkStructureType sType; + void* pNext; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; +} VkPhysicalDeviceSubgroupSizeControlFeatures; + +typedef struct VkPhysicalDeviceSubgroupSizeControlProperties { + VkStructureType sType; + void* pNext; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; +} VkPhysicalDeviceSubgroupSizeControlProperties; + +typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t requiredSubgroupSize; +} VkPipelineShaderStageRequiredSubgroupSizeCreateInfo; + +typedef struct VkPhysicalDeviceInlineUniformBlockFeatures { + VkStructureType sType; + void* pNext; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; +} VkPhysicalDeviceInlineUniformBlockFeatures; + +typedef struct VkPhysicalDeviceInlineUniformBlockProperties { + VkStructureType sType; + void* pNext; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; +} VkPhysicalDeviceInlineUniformBlockProperties; + +typedef struct VkWriteDescriptorSetInlineUniformBlock { + VkStructureType sType; + const void* pNext; + uint32_t dataSize; + const void* pData; +} VkWriteDescriptorSetInlineUniformBlock; + +typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t maxInlineUniformBlockBindings; +} VkDescriptorPoolInlineUniformBlockCreateInfo; + +typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderIntegerDotProduct; +} VkPhysicalDeviceShaderIntegerDotProductFeatures; + +typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties { + VkStructureType sType; + void* pNext; + VkBool32 integerDotProduct8BitUnsignedAccelerated; + VkBool32 integerDotProduct8BitSignedAccelerated; + VkBool32 integerDotProduct8BitMixedSignednessAccelerated; + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProduct16BitUnsignedAccelerated; + VkBool32 integerDotProduct16BitSignedAccelerated; + VkBool32 integerDotProduct16BitMixedSignednessAccelerated; + VkBool32 integerDotProduct32BitUnsignedAccelerated; + VkBool32 integerDotProduct32BitSignedAccelerated; + VkBool32 integerDotProduct32BitMixedSignednessAccelerated; + VkBool32 integerDotProduct64BitUnsignedAccelerated; + VkBool32 integerDotProduct64BitSignedAccelerated; + VkBool32 integerDotProduct64BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; +} VkPhysicalDeviceShaderIntegerDotProductProperties; + +typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties { + VkStructureType sType; + void* pNext; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; +} VkPhysicalDeviceTexelBufferAlignmentProperties; + +typedef struct VkImageBlit2 { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit2; + +typedef struct VkBlitImageInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageBlit2* pRegions; + VkFilter filter; +} VkBlitImageInfo2; + +typedef struct VkImageResolve2 { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve2; + +typedef struct VkResolveImageInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageResolve2* pRegions; +} VkResolveImageInfo2; + +typedef struct VkRenderingAttachmentInfo { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkImageLayout imageLayout; + VkResolveModeFlagBits resolveMode; + VkImageView resolveImageView; + VkImageLayout resolveImageLayout; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkClearValue clearValue; +} VkRenderingAttachmentInfo; + +typedef struct VkRenderingInfo { + VkStructureType sType; + const void* pNext; + VkRenderingFlags flags; + VkRect2D renderArea; + uint32_t layerCount; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkRenderingAttachmentInfo* pColorAttachments; + const VkRenderingAttachmentInfo* pDepthAttachment; + const VkRenderingAttachmentInfo* pStencilAttachment; +} VkRenderingInfo; + +typedef struct VkPipelineRenderingCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; +} VkPipelineRenderingCreateInfo; + +typedef struct VkPhysicalDeviceDynamicRenderingFeatures { + VkStructureType sType; + void* pNext; + VkBool32 dynamicRendering; +} VkPhysicalDeviceDynamicRenderingFeatures; + +typedef struct VkCommandBufferInheritanceRenderingInfo { + VkStructureType sType; + const void* pNext; + VkRenderingFlags flags; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; + VkSampleCountFlagBits rasterizationSamples; +} VkCommandBufferInheritanceRenderingInfo; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +typedef void (VKAPI_PTR *PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCount)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCount)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties); + +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlot( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot); + +VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlot( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data); + +VKAPI_ATTR void VKAPI_CALL vkGetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query); + +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask); + +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos); + +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRendering( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetCullMode( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFace( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopology( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCount( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCount( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOp( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOp( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnable( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnable( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable); +#endif + + +// VK_VERSION_1_4 is a preprocessor guard. Do not pass it to API calls. +#define VK_VERSION_1_4 1 +// Vulkan 1.4 version number +#define VK_API_VERSION_1_4 VK_MAKE_API_VERSION(0, 1, 4, 0)// Patch version should always be set to 0 + +#define VK_MAX_GLOBAL_PRIORITY_SIZE 16U + +typedef enum VkPipelineRobustnessBufferBehavior { + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT = 0, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED = 1, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS = 2, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 = 3, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkPipelineRobustnessBufferBehavior; + +typedef enum VkPipelineRobustnessImageBehavior { + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT = 0, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED = 1, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS = 2, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2 = 3, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkPipelineRobustnessImageBehavior; + +typedef enum VkQueueGlobalPriority { + VK_QUEUE_GLOBAL_PRIORITY_LOW = 128, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM = 256, + VK_QUEUE_GLOBAL_PRIORITY_HIGH = 512, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME = 1024, + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = VK_QUEUE_GLOBAL_PRIORITY_HIGH, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, + VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR = VK_QUEUE_GLOBAL_PRIORITY_LOW, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = VK_QUEUE_GLOBAL_PRIORITY_HIGH, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, + VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM = 0x7FFFFFFF +} VkQueueGlobalPriority; + +typedef enum VkLineRasterizationMode { + VK_LINE_RASTERIZATION_MODE_DEFAULT = 0, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR = 1, + VK_LINE_RASTERIZATION_MODE_BRESENHAM = 2, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH = 3, + VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = VK_LINE_RASTERIZATION_MODE_BRESENHAM, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, + VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR = VK_LINE_RASTERIZATION_MODE_DEFAULT, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR = VK_LINE_RASTERIZATION_MODE_BRESENHAM, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, + VK_LINE_RASTERIZATION_MODE_MAX_ENUM = 0x7FFFFFFF +} VkLineRasterizationMode; + +typedef enum VkMemoryUnmapFlagBits { + VK_MEMORY_UNMAP_RESERVE_BIT_EXT = 0x00000001, + VK_MEMORY_UNMAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryUnmapFlagBits; +typedef VkFlags VkMemoryUnmapFlags; +typedef VkFlags64 VkBufferUsageFlags2; + +// Flag bits for VkBufferUsageFlagBits2 +typedef VkFlags64 VkBufferUsageFlagBits2; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT = 0x00000001ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_DST_BIT = 0x00000002ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT = 0x00000008ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT = 0x00000010ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT = 0x00000020ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT = 0x00000040ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT = 0x00000080ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT = 0x00000100ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT = 0x00020000ULL; +#ifdef VK_ENABLE_BETA_EXTENSIONS +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX = 0x02000000ULL; +#endif +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT = 0x10000000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR = 0x00000001ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR = 0x00000002ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000004ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR = 0x00000010ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR = 0x00000020ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR = 0x00000040ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR = 0x00000080ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR = 0x00000100ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV = 0x00000400ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR = 0x00004000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; +#ifdef VK_ENABLE_BETA_EXTENSIONS +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX = 0x200000000ULL; +#endif +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM = 0x20000000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM = 0x08000000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT = 0x100000000ULL; +static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 0x80000000ULL; + + +typedef enum VkHostImageCopyFlagBits { + VK_HOST_IMAGE_COPY_MEMCPY_BIT = 0x00000001, + // VK_HOST_IMAGE_COPY_MEMCPY is a legacy alias + VK_HOST_IMAGE_COPY_MEMCPY = VK_HOST_IMAGE_COPY_MEMCPY_BIT, + VK_HOST_IMAGE_COPY_MEMCPY_BIT_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT, + // VK_HOST_IMAGE_COPY_MEMCPY_EXT is a legacy alias + VK_HOST_IMAGE_COPY_MEMCPY_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT, + VK_HOST_IMAGE_COPY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkHostImageCopyFlagBits; +typedef VkFlags VkHostImageCopyFlags; +typedef VkFlags64 VkPipelineCreateFlags2; + +// Flag bits for VkPipelineCreateFlagBits2 +typedef VkFlags64 VkPipelineCreateFlagBits2; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT = 0x00000001ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT = 0x00000002ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DERIVATIVE_BIT = 0x00000004ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT = 0x00000010ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT = 0x08000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT = 0x40000000ULL; +#ifdef VK_ENABLE_BETA_EXTENSIONS +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX = 0x100000000ULL; +#endif +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT = 0x1000000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR = 0x00001000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV = 0x200000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = 0x00000002ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR = 0x00000004ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR = 0x00000010ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV = 0x00000020ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR = 0x00000040ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR = 0x00000100ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR = 0x00000200ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR = 0x00000800ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV = 0x00040000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM = 0x2000000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x10000000000ULL; +static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT = 0x80000000000ULL; + +typedef struct VkPhysicalDeviceVulkan14Features { + VkStructureType sType; + void* pNext; + VkBool32 globalPriorityQuery; + VkBool32 shaderSubgroupRotate; + VkBool32 shaderSubgroupRotateClustered; + VkBool32 shaderFloatControls2; + VkBool32 shaderExpectAssume; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; + VkBool32 indexTypeUint8; + VkBool32 dynamicRenderingLocalRead; + VkBool32 maintenance5; + VkBool32 maintenance6; + VkBool32 pipelineProtectedAccess; + VkBool32 pipelineRobustness; + VkBool32 hostImageCopy; + VkBool32 pushDescriptor; +} VkPhysicalDeviceVulkan14Features; + +typedef struct VkPhysicalDeviceVulkan14Properties { + VkStructureType sType; + void* pNext; + uint32_t lineSubPixelPrecisionBits; + uint32_t maxVertexAttribDivisor; + VkBool32 supportsNonZeroFirstInstance; + uint32_t maxPushDescriptors; + VkBool32 dynamicRenderingLocalReadDepthStencilAttachments; + VkBool32 dynamicRenderingLocalReadMultisampledAttachments; + VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; + VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; + VkBool32 depthStencilSwizzleOneSupport; + VkBool32 polygonModePointSize; + VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; + VkBool32 nonStrictWideLinesUseParallelogram; + VkBool32 blockTexelViewCompatibleMultipleLayers; + uint32_t maxCombinedImageSamplerDescriptorCount; + VkBool32 fragmentShadingRateClampCombinerInputs; + VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs; + VkPipelineRobustnessImageBehavior defaultRobustnessImages; + uint32_t copySrcLayoutCount; + VkImageLayout* pCopySrcLayouts; + uint32_t copyDstLayoutCount; + VkImageLayout* pCopyDstLayouts; + uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; + VkBool32 identicalMemoryTypeRequirements; +} VkPhysicalDeviceVulkan14Properties; + +typedef struct VkDeviceQueueGlobalPriorityCreateInfo { + VkStructureType sType; + const void* pNext; + VkQueueGlobalPriority globalPriority; +} VkDeviceQueueGlobalPriorityCreateInfo; + +typedef struct VkPhysicalDeviceGlobalPriorityQueryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 globalPriorityQuery; +} VkPhysicalDeviceGlobalPriorityQueryFeatures; + +typedef struct VkQueueFamilyGlobalPriorityProperties { + VkStructureType sType; + void* pNext; + uint32_t priorityCount; + VkQueueGlobalPriority priorities[VK_MAX_GLOBAL_PRIORITY_SIZE]; +} VkQueueFamilyGlobalPriorityProperties; + +typedef struct VkPhysicalDeviceIndexTypeUint8Features { + VkStructureType sType; + void* pNext; + VkBool32 indexTypeUint8; +} VkPhysicalDeviceIndexTypeUint8Features; + +typedef struct VkMemoryMapInfo { + VkStructureType sType; + const void* pNext; + VkMemoryMapFlags flags; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMemoryMapInfo; + +typedef struct VkMemoryUnmapInfo { + VkStructureType sType; + const void* pNext; + VkMemoryUnmapFlags flags; + VkDeviceMemory memory; +} VkMemoryUnmapInfo; + +typedef struct VkPhysicalDeviceMaintenance5Features { + VkStructureType sType; + void* pNext; + VkBool32 maintenance5; +} VkPhysicalDeviceMaintenance5Features; + +typedef struct VkPhysicalDeviceMaintenance5Properties { + VkStructureType sType; + void* pNext; + VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; + VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; + VkBool32 depthStencilSwizzleOneSupport; + VkBool32 polygonModePointSize; + VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; + VkBool32 nonStrictWideLinesUseParallelogram; +} VkPhysicalDeviceMaintenance5Properties; + +typedef struct VkImageSubresource2 { + VkStructureType sType; + void* pNext; + VkImageSubresource imageSubresource; +} VkImageSubresource2; + +typedef struct VkDeviceImageSubresourceInfo { + VkStructureType sType; + const void* pNext; + const VkImageCreateInfo* pCreateInfo; + const VkImageSubresource2* pSubresource; +} VkDeviceImageSubresourceInfo; + +typedef struct VkSubresourceLayout2 { + VkStructureType sType; + void* pNext; + VkSubresourceLayout subresourceLayout; +} VkSubresourceLayout2; + +typedef struct VkBufferUsageFlags2CreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferUsageFlags2 usage; +} VkBufferUsageFlags2CreateInfo; + +typedef struct VkPhysicalDeviceMaintenance6Features { + VkStructureType sType; + void* pNext; + VkBool32 maintenance6; +} VkPhysicalDeviceMaintenance6Features; + +typedef struct VkPhysicalDeviceMaintenance6Properties { + VkStructureType sType; + void* pNext; + VkBool32 blockTexelViewCompatibleMultipleLayers; + uint32_t maxCombinedImageSamplerDescriptorCount; + VkBool32 fragmentShadingRateClampCombinerInputs; +} VkPhysicalDeviceMaintenance6Properties; + +typedef struct VkBindMemoryStatus { + VkStructureType sType; + const void* pNext; + VkResult* pResult; +} VkBindMemoryStatus; + +typedef struct VkPhysicalDeviceHostImageCopyFeatures { + VkStructureType sType; + void* pNext; + VkBool32 hostImageCopy; +} VkPhysicalDeviceHostImageCopyFeatures; + +typedef struct VkPhysicalDeviceHostImageCopyProperties { + VkStructureType sType; + void* pNext; + uint32_t copySrcLayoutCount; + VkImageLayout* pCopySrcLayouts; + uint32_t copyDstLayoutCount; + VkImageLayout* pCopyDstLayouts; + uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; + VkBool32 identicalMemoryTypeRequirements; +} VkPhysicalDeviceHostImageCopyProperties; + +typedef struct VkMemoryToImageCopy { + VkStructureType sType; + const void* pNext; + const void* pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkMemoryToImageCopy; + +typedef struct VkImageToMemoryCopy { + VkStructureType sType; + const void* pNext; + void* pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkImageToMemoryCopy; + +typedef struct VkCopyMemoryToImageInfo { + VkStructureType sType; + const void* pNext; + VkHostImageCopyFlags flags; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkMemoryToImageCopy* pRegions; +} VkCopyMemoryToImageInfo; + +typedef struct VkCopyImageToMemoryInfo { + VkStructureType sType; + const void* pNext; + VkHostImageCopyFlags flags; + VkImage srcImage; + VkImageLayout srcImageLayout; + uint32_t regionCount; + const VkImageToMemoryCopy* pRegions; +} VkCopyImageToMemoryInfo; + +typedef struct VkCopyImageToImageInfo { + VkStructureType sType; + const void* pNext; + VkHostImageCopyFlags flags; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageCopy2* pRegions; +} VkCopyImageToImageInfo; + +typedef struct VkHostImageLayoutTransitionInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkImageLayout oldLayout; + VkImageLayout newLayout; + VkImageSubresourceRange subresourceRange; +} VkHostImageLayoutTransitionInfo; + +typedef struct VkSubresourceHostMemcpySize { + VkStructureType sType; + void* pNext; + VkDeviceSize size; +} VkSubresourceHostMemcpySize; + +typedef struct VkHostImageCopyDevicePerformanceQuery { + VkStructureType sType; + void* pNext; + VkBool32 optimalDeviceAccess; + VkBool32 identicalMemoryLayout; +} VkHostImageCopyDevicePerformanceQuery; + +typedef struct VkPhysicalDeviceShaderSubgroupRotateFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupRotate; + VkBool32 shaderSubgroupRotateClustered; +} VkPhysicalDeviceShaderSubgroupRotateFeatures; + +typedef struct VkPhysicalDeviceShaderFloatControls2Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloatControls2; +} VkPhysicalDeviceShaderFloatControls2Features; + +typedef struct VkPhysicalDeviceShaderExpectAssumeFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderExpectAssume; +} VkPhysicalDeviceShaderExpectAssumeFeatures; + +typedef struct VkPipelineCreateFlags2CreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags2 flags; +} VkPipelineCreateFlags2CreateInfo; + +typedef struct VkPhysicalDevicePushDescriptorProperties { + VkStructureType sType; + void* pNext; + uint32_t maxPushDescriptors; +} VkPhysicalDevicePushDescriptorProperties; + +typedef struct VkBindDescriptorSetsInfo { + VkStructureType sType; + const void* pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t firstSet; + uint32_t descriptorSetCount; + const VkDescriptorSet* pDescriptorSets; + uint32_t dynamicOffsetCount; + const uint32_t* pDynamicOffsets; +} VkBindDescriptorSetsInfo; + +typedef struct VkPushConstantsInfo { + VkStructureType sType; + const void* pNext; + VkPipelineLayout layout; + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + const void* pValues; +} VkPushConstantsInfo; + +typedef struct VkPushDescriptorSetInfo { + VkStructureType sType; + const void* pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t set; + uint32_t descriptorWriteCount; + const VkWriteDescriptorSet* pDescriptorWrites; +} VkPushDescriptorSetInfo; + +typedef struct VkPushDescriptorSetWithTemplateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorUpdateTemplate descriptorUpdateTemplate; + VkPipelineLayout layout; + uint32_t set; + const void* pData; +} VkPushDescriptorSetWithTemplateInfo; + +typedef struct VkPhysicalDevicePipelineProtectedAccessFeatures { + VkStructureType sType; + void* pNext; + VkBool32 pipelineProtectedAccess; +} VkPhysicalDevicePipelineProtectedAccessFeatures; + +typedef struct VkPhysicalDevicePipelineRobustnessFeatures { + VkStructureType sType; + void* pNext; + VkBool32 pipelineRobustness; +} VkPhysicalDevicePipelineRobustnessFeatures; + +typedef struct VkPhysicalDevicePipelineRobustnessProperties { + VkStructureType sType; + void* pNext; + VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs; + VkPipelineRobustnessImageBehavior defaultRobustnessImages; +} VkPhysicalDevicePipelineRobustnessProperties; + +typedef struct VkPipelineRobustnessCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineRobustnessBufferBehavior storageBuffers; + VkPipelineRobustnessBufferBehavior uniformBuffers; + VkPipelineRobustnessBufferBehavior vertexInputs; + VkPipelineRobustnessImageBehavior images; +} VkPipelineRobustnessCreateInfo; + +typedef struct VkPhysicalDeviceLineRasterizationFeatures { + VkStructureType sType; + void* pNext; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; +} VkPhysicalDeviceLineRasterizationFeatures; + +typedef struct VkPhysicalDeviceLineRasterizationProperties { + VkStructureType sType; + void* pNext; + uint32_t lineSubPixelPrecisionBits; +} VkPhysicalDeviceLineRasterizationProperties; + +typedef struct VkPipelineRasterizationLineStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkLineRasterizationMode lineRasterizationMode; + VkBool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; +} VkPipelineRasterizationLineStateCreateInfo; + +typedef struct VkPhysicalDeviceVertexAttributeDivisorProperties { + VkStructureType sType; + void* pNext; + uint32_t maxVertexAttribDivisor; + VkBool32 supportsNonZeroFirstInstance; +} VkPhysicalDeviceVertexAttributeDivisorProperties; + +typedef struct VkVertexInputBindingDivisorDescription { + uint32_t binding; + uint32_t divisor; +} VkVertexInputBindingDivisorDescription; + +typedef struct VkPipelineVertexInputDivisorStateCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescription* pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfo; + +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeatures { + VkStructureType sType; + void* pNext; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; +} VkPhysicalDeviceVertexAttributeDivisorFeatures; + +typedef struct VkRenderingAreaInfo { + VkStructureType sType; + const void* pNext; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; +} VkRenderingAreaInfo; + +typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures { + VkStructureType sType; + void* pNext; + VkBool32 dynamicRenderingLocalRead; +} VkPhysicalDeviceDynamicRenderingLocalReadFeatures; + +typedef struct VkRenderingAttachmentLocationInfo { + VkStructureType sType; + const void* pNext; + uint32_t colorAttachmentCount; + const uint32_t* pColorAttachmentLocations; +} VkRenderingAttachmentLocationInfo; + +typedef struct VkRenderingInputAttachmentIndexInfo { + VkStructureType sType; + const void* pNext; + uint32_t colorAttachmentCount; + const uint32_t* pColorAttachmentInputIndices; + const uint32_t* pDepthInputAttachmentIndex; + const uint32_t* pStencilInputAttachmentIndex; +} VkRenderingInputAttachmentIndexInfo; + +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory2)(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData); +typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2)(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSubresourceLayout)(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout); +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2)(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToImage)(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToMemory)(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToImage)(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo); +typedef VkResult (VKAPI_PTR *PFN_vkTransitionImageLayout)(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSet)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplate)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets2)(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants2)(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSet2)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplate2)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStipple)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer2)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType); +typedef void (VKAPI_PTR *PFN_vkGetRenderingAreaGranularity)(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity); +typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocations)(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo); +typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndices)(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2( + VkDevice device, + const VkMemoryMapInfo* pMemoryMapInfo, + void** ppData); + +VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2( + VkDevice device, + const VkMemoryUnmapInfo* pMemoryUnmapInfo); + +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayout( + VkDevice device, + const VkDeviceImageSubresourceInfo* pInfo, + VkSubresourceLayout2* pLayout); + +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2( + VkDevice device, + VkImage image, + const VkImageSubresource2* pSubresource, + VkSubresourceLayout2* pLayout); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImage( + VkDevice device, + const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemory( + VkDevice device, + const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImage( + VkDevice device, + const VkCopyImageToImageInfo* pCopyImageToImageInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayout( + VkDevice device, + uint32_t transitionCount, + const VkHostImageLayoutTransitionInfo* pTransitions); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2( + VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2( + VkCommandBuffer commandBuffer, + const VkPushConstantsInfo* pPushConstantsInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStipple( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType); + +VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularity( + VkDevice device, + const VkRenderingAreaInfo* pRenderingAreaInfo, + VkExtent2D* pGranularity); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocations( + VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfo* pLocationInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndices( + VkCommandBuffer commandBuffer, + const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); +#endif + + +// VK_KHR_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_surface 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) +#define VK_KHR_SURFACE_SPEC_VERSION 25 +#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" + +typedef enum VkPresentModeKHR { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, + VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, + VK_PRESENT_MODE_FIFO_LATEST_READY_KHR = 1000361000, + VK_PRESENT_MODE_FIFO_LATEST_READY_EXT = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR, + VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentModeKHR; + +typedef enum VkColorSpaceKHR { + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, + VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, + VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003, + VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, + VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, + VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, + VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, + VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, + // VK_COLOR_SPACE_DOLBYVISION_EXT is legacy, but no reason was given in the API XML + VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, + VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, + VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, + VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, + VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, + VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, + VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000, + // VK_COLORSPACE_SRGB_NONLINEAR_KHR is a legacy alias + VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + // VK_COLOR_SPACE_DCI_P3_LINEAR_EXT is a legacy alias + VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, + VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkColorSpaceKHR; + +typedef enum VkSurfaceTransformFlagBitsKHR { + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, + VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSurfaceTransformFlagBitsKHR; + +typedef enum VkCompositeAlphaFlagBitsKHR { + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, + VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkCompositeAlphaFlagBitsKHR; +typedef VkFlags VkCompositeAlphaFlagsKHR; +typedef VkFlags VkSurfaceTransformFlagsKHR; +typedef struct VkSurfaceCapabilitiesKHR { + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; +} VkSurfaceCapabilitiesKHR; + +typedef struct VkSurfaceFormatKHR { + VkFormat format; + VkColorSpaceKHR colorSpace; +} VkSurfaceFormatKHR; + +typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); +#endif +#endif + + +// VK_KHR_swapchain is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_swapchain 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) +#define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 +#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" + +typedef enum VkSwapchainCreateFlagBitsKHR { + VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, + VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, + VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, + VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT = 0x00000200, + VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR = 0x00000040, + VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR = 0x00000080, + VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR = 0x00000008, + VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, + VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSwapchainCreateFlagBitsKHR; +typedef VkFlags VkSwapchainCreateFlagsKHR; + +typedef enum VkDeviceGroupPresentModeFlagBitsKHR { + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, + VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, + VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, + VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDeviceGroupPresentModeFlagBitsKHR; +typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; +typedef struct VkSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR oldSwapchain; +} VkSwapchainCreateInfoKHR; + +typedef struct VkPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t swapchainCount; + const VkSwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + VkResult* pResults; +} VkPresentInfoKHR; + +typedef struct VkImageSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; +} VkImageSwapchainCreateInfoKHR; + +typedef struct VkBindImageMemorySwapchainInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHR; + +typedef struct VkAcquireNextImageInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint64_t timeout; + VkSemaphore semaphore; + VkFence fence; + uint32_t deviceMask; +} VkAcquireNextImageInfoKHR; + +typedef struct VkDeviceGroupPresentCapabilitiesKHR { + VkStructureType sType; + void* pNext; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupPresentCapabilitiesKHR; + +typedef struct VkDeviceGroupPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks; + VkDeviceGroupPresentModeFlagBitsKHR mode; +} VkDeviceGroupPresentInfoKHR; + +typedef struct VkDeviceGroupSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupSwapchainCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); +typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( + VkDevice device, + const VkAcquireNextImageInfoKHR* pAcquireInfo, + uint32_t* pImageIndex); +#endif +#endif + + +// VK_KHR_display is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_display 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) +#define VK_KHR_DISPLAY_SPEC_VERSION 23 +#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" +typedef VkFlags VkDisplayModeCreateFlagsKHR; + +typedef enum VkDisplayPlaneAlphaFlagBitsKHR { + VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, + VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDisplayPlaneAlphaFlagBitsKHR; +typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; +typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; +typedef struct VkDisplayModeParametersKHR { + VkExtent2D visibleRegion; + uint32_t refreshRate; +} VkDisplayModeParametersKHR; + +typedef struct VkDisplayModeCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeCreateFlagsKHR flags; + VkDisplayModeParametersKHR parameters; +} VkDisplayModeCreateInfoKHR; + +typedef struct VkDisplayModePropertiesKHR { + VkDisplayModeKHR displayMode; + VkDisplayModeParametersKHR parameters; +} VkDisplayModePropertiesKHR; + +typedef struct VkDisplayPlaneCapabilitiesKHR { + VkDisplayPlaneAlphaFlagsKHR supportedAlpha; + VkOffset2D minSrcPosition; + VkOffset2D maxSrcPosition; + VkExtent2D minSrcExtent; + VkExtent2D maxSrcExtent; + VkOffset2D minDstPosition; + VkOffset2D maxDstPosition; + VkExtent2D minDstExtent; + VkExtent2D maxDstExtent; +} VkDisplayPlaneCapabilitiesKHR; + +typedef struct VkDisplayPlanePropertiesKHR { + VkDisplayKHR currentDisplay; + uint32_t currentStackIndex; +} VkDisplayPlanePropertiesKHR; + +typedef struct VkDisplayPropertiesKHR { + VkDisplayKHR display; + const char* displayName; + VkExtent2D physicalDimensions; + VkExtent2D physicalResolution; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkBool32 planeReorderPossible; + VkBool32 persistentContent; +} VkDisplayPropertiesKHR; + +typedef struct VkDisplaySurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplaySurfaceCreateFlagsKHR flags; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkDisplaySurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( + VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif + + +// VK_KHR_display_swapchain is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_display_swapchain 1 +#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10 +#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" +typedef struct VkDisplayPresentInfoKHR { + VkStructureType sType; + const void* pNext; + VkRect2D srcRect; + VkRect2D dstRect; + VkBool32 persistent; +} VkDisplayPresentInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains); +#endif +#endif + + +// VK_KHR_sampler_mirror_clamp_to_edge is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_sampler_mirror_clamp_to_edge 1 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3 +#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" + + +// VK_KHR_video_queue is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_queue 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR) +#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION 8 +#define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue" + +typedef enum VkQueryResultStatusKHR { + VK_QUERY_RESULT_STATUS_ERROR_KHR = -1, + VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0, + VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1, + VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR = -1000299000, + VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkQueryResultStatusKHR; + +typedef enum VkVideoCodecOperationFlagBitsKHR { + VK_VIDEO_CODEC_OPERATION_NONE_KHR = 0, + VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR = 0x00010000, + VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR = 0x00020000, + VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001, + VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002, + VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR = 0x00000004, + VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR = 0x00040000, + VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR = 0x00000008, + VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCodecOperationFlagBitsKHR; +typedef VkFlags VkVideoCodecOperationFlagsKHR; + +typedef enum VkVideoChromaSubsamplingFlagBitsKHR { + VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR = 0, + VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001, + VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002, + VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004, + VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008, + VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoChromaSubsamplingFlagBitsKHR; +typedef VkFlags VkVideoChromaSubsamplingFlagsKHR; + +typedef enum VkVideoComponentBitDepthFlagBitsKHR { + VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0, + VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001, + VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004, + VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010, + VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoComponentBitDepthFlagBitsKHR; +typedef VkFlags VkVideoComponentBitDepthFlagsKHR; + +typedef enum VkVideoCapabilityFlagBitsKHR { + VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002, + VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCapabilityFlagBitsKHR; +typedef VkFlags VkVideoCapabilityFlagsKHR; + +typedef enum VkVideoSessionCreateFlagBitsKHR { + VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR = 0x00000002, + VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR = 0x00000004, + VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000008, + VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x00000010, + VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR = 0x00000020, + VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoSessionCreateFlagBitsKHR; +typedef VkFlags VkVideoSessionCreateFlagsKHR; + +typedef enum VkVideoSessionParametersCreateFlagBitsKHR { + VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR = 0x00000001, + VK_VIDEO_SESSION_PARAMETERS_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoSessionParametersCreateFlagBitsKHR; +typedef VkFlags VkVideoSessionParametersCreateFlagsKHR; +typedef VkFlags VkVideoBeginCodingFlagsKHR; +typedef VkFlags VkVideoEndCodingFlagsKHR; + +typedef enum VkVideoCodingControlFlagBitsKHR { + VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001, + VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR = 0x00000002, + VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR = 0x00000004, + VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCodingControlFlagBitsKHR; +typedef VkFlags VkVideoCodingControlFlagsKHR; +typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 queryResultStatusSupport; +} VkQueueFamilyQueryResultStatusPropertiesKHR; + +typedef struct VkQueueFamilyVideoPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoCodecOperationFlagsKHR videoCodecOperations; +} VkQueueFamilyVideoPropertiesKHR; + +typedef struct VkVideoProfileInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoCodecOperationFlagBitsKHR videoCodecOperation; + VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; + VkVideoComponentBitDepthFlagsKHR lumaBitDepth; + VkVideoComponentBitDepthFlagsKHR chromaBitDepth; +} VkVideoProfileInfoKHR; + +typedef struct VkVideoProfileListInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t profileCount; + const VkVideoProfileInfoKHR* pProfiles; +} VkVideoProfileListInfoKHR; + +typedef struct VkVideoCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoCapabilityFlagsKHR flags; + VkDeviceSize minBitstreamBufferOffsetAlignment; + VkDeviceSize minBitstreamBufferSizeAlignment; + VkExtent2D pictureAccessGranularity; + VkExtent2D minCodedExtent; + VkExtent2D maxCodedExtent; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + VkExtensionProperties stdHeaderVersion; +} VkVideoCapabilitiesKHR; + +typedef struct VkPhysicalDeviceVideoFormatInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags imageUsage; +} VkPhysicalDeviceVideoFormatInfoKHR; + +typedef struct VkVideoFormatPropertiesKHR { + VkStructureType sType; + void* pNext; + VkFormat format; + VkComponentMapping componentMapping; + VkImageCreateFlags imageCreateFlags; + VkImageType imageType; + VkImageTiling imageTiling; + VkImageUsageFlags imageUsageFlags; +} VkVideoFormatPropertiesKHR; + +typedef struct VkVideoPictureResourceInfoKHR { + VkStructureType sType; + const void* pNext; + VkOffset2D codedOffset; + VkExtent2D codedExtent; + uint32_t baseArrayLayer; + VkImageView imageViewBinding; +} VkVideoPictureResourceInfoKHR; + +typedef struct VkVideoReferenceSlotInfoKHR { + VkStructureType sType; + const void* pNext; + int32_t slotIndex; + const VkVideoPictureResourceInfoKHR* pPictureResource; +} VkVideoReferenceSlotInfoKHR; + +typedef struct VkVideoSessionMemoryRequirementsKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryBindIndex; + VkMemoryRequirements memoryRequirements; +} VkVideoSessionMemoryRequirementsKHR; + +typedef struct VkBindVideoSessionMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t memoryBindIndex; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkDeviceSize memorySize; +} VkBindVideoSessionMemoryInfoKHR; + +typedef struct VkVideoSessionCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + VkVideoSessionCreateFlagsKHR flags; + const VkVideoProfileInfoKHR* pVideoProfile; + VkFormat pictureFormat; + VkExtent2D maxCodedExtent; + VkFormat referencePictureFormat; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + const VkExtensionProperties* pStdHeaderVersion; +} VkVideoSessionCreateInfoKHR; + +typedef struct VkVideoSessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoSessionParametersCreateFlagsKHR flags; + VkVideoSessionParametersKHR videoSessionParametersTemplate; + VkVideoSessionKHR videoSession; +} VkVideoSessionParametersCreateInfoKHR; + +typedef struct VkVideoSessionParametersUpdateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t updateSequenceCount; +} VkVideoSessionParametersUpdateInfoKHR; + +typedef struct VkVideoBeginCodingInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoBeginCodingFlagsKHR flags; + VkVideoSessionKHR videoSession; + VkVideoSessionParametersKHR videoSessionParameters; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotInfoKHR* pReferenceSlots; +} VkVideoBeginCodingInfoKHR; + +typedef struct VkVideoEndCodingInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEndCodingFlagsKHR flags; +} VkVideoEndCodingInfoKHR; + +typedef struct VkVideoCodingControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoCodingControlFlagsKHR flags; +} VkVideoCodingControlInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession); +typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); +typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters); +typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); +typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); +typedef void (VKAPI_PTR *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + const VkVideoProfileInfoKHR* pVideoProfile, + VkVideoCapabilitiesKHR* pCapabilities); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, + uint32_t* pVideoFormatPropertyCount, + VkVideoFormatPropertiesKHR* pVideoFormatProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR( + VkDevice device, + const VkVideoSessionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionKHR* pVideoSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t* pMemoryRequirementsCount, + VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR( + VkDevice device, + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionParametersKHR* pVideoSessionParameters); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoBeginCodingInfoKHR* pBeginInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoEndCodingInfoKHR* pEndCodingInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoCodingControlInfoKHR* pCodingControlInfo); +#endif +#endif + + +// VK_KHR_video_decode_queue is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_decode_queue 1 +#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 8 +#define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue" + +typedef enum VkVideoDecodeCapabilityFlagBitsKHR { + VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeCapabilityFlagBitsKHR; +typedef VkFlags VkVideoDecodeCapabilityFlagsKHR; + +typedef enum VkVideoDecodeUsageFlagBitsKHR { + VK_VIDEO_DECODE_USAGE_DEFAULT_KHR = 0, + VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR = 0x00000004, + VK_VIDEO_DECODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeUsageFlagBitsKHR; +typedef VkFlags VkVideoDecodeUsageFlagsKHR; +typedef VkFlags VkVideoDecodeFlagsKHR; +typedef struct VkVideoDecodeCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoDecodeCapabilityFlagsKHR flags; +} VkVideoDecodeCapabilitiesKHR; + +typedef struct VkVideoDecodeUsageInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoDecodeUsageFlagsKHR videoUsageHints; +} VkVideoDecodeUsageInfoKHR; + +typedef struct VkVideoDecodeInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoDecodeFlagsKHR flags; + VkBuffer srcBuffer; + VkDeviceSize srcBufferOffset; + VkDeviceSize srcBufferRange; + VkVideoPictureResourceInfoKHR dstPictureResource; + const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotInfoKHR* pReferenceSlots; +} VkVideoDecodeInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoDecodeInfoKHR* pDecodeInfo); +#endif +#endif + + +// VK_KHR_video_encode_h264 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_encode_h264 1 +#include "vk_video/vulkan_video_codec_h264std.h" +#include "vk_video/vulkan_video_codec_h264std_encode.h" +#define VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION 14 +#define VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_KHR_video_encode_h264" + +typedef enum VkVideoEncodeH264CapabilityFlagBitsKHR { + VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR = 0x00000020, + VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 0x00000040, + VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR = 0x00000080, + VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR = 0x00000400, + VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR = 0x00000200, + VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH264CapabilityFlagBitsKHR; +typedef VkFlags VkVideoEncodeH264CapabilityFlagsKHR; + +typedef enum VkVideoEncodeH264StdFlagBitsKHR { + VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR = 0x00000020, + VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR = 0x00000040, + VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR = 0x00000080, + VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR = 0x00000200, + VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR = 0x00000400, + VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR = 0x00000800, + VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR = 0x00001000, + VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR = 0x00002000, + VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR = 0x00004000, + VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR = 0x00008000, + VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR = 0x00010000, + VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR = 0x00020000, + VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR = 0x00080000, + VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR = 0x00100000, + VK_VIDEO_ENCODE_H264_STD_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH264StdFlagBitsKHR; +typedef VkFlags VkVideoEncodeH264StdFlagsKHR; + +typedef enum VkVideoEncodeH264RateControlFlagBitsKHR { + VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H264_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH264RateControlFlagBitsKHR; +typedef VkFlags VkVideoEncodeH264RateControlFlagsKHR; +typedef struct VkVideoEncodeH264CapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeH264CapabilityFlagsKHR flags; + StdVideoH264LevelIdc maxLevelIdc; + uint32_t maxSliceCount; + uint32_t maxPPictureL0ReferenceCount; + uint32_t maxBPictureL0ReferenceCount; + uint32_t maxL1ReferenceCount; + uint32_t maxTemporalLayerCount; + VkBool32 expectDyadicTemporalLayerPattern; + int32_t minQp; + int32_t maxQp; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeH264StdFlagsKHR stdSyntaxFlags; +} VkVideoEncodeH264CapabilitiesKHR; + +typedef struct VkVideoEncodeH264QpKHR { + int32_t qpI; + int32_t qpP; + int32_t qpB; +} VkVideoEncodeH264QpKHR; + +typedef struct VkVideoEncodeH264QualityLevelPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeH264RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredIdrPeriod; + uint32_t preferredConsecutiveBFrameCount; + uint32_t preferredTemporalLayerCount; + VkVideoEncodeH264QpKHR preferredConstantQp; + uint32_t preferredMaxL0ReferenceCount; + uint32_t preferredMaxL1ReferenceCount; + VkBool32 preferredStdEntropyCodingModeFlag; +} VkVideoEncodeH264QualityLevelPropertiesKHR; + +typedef struct VkVideoEncodeH264SessionCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useMaxLevelIdc; + StdVideoH264LevelIdc maxLevelIdc; +} VkVideoEncodeH264SessionCreateInfoKHR; + +typedef struct VkVideoEncodeH264SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdSPSCount; + const StdVideoH264SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH264PictureParameterSet* pStdPPSs; +} VkVideoEncodeH264SessionParametersAddInfoKHR; + +typedef struct VkVideoEncodeH264SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoEncodeH264SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoEncodeH264SessionParametersCreateInfoKHR; + +typedef struct VkVideoEncodeH264SessionParametersGetInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 writeStdSPS; + VkBool32 writeStdPPS; + uint32_t stdSPSId; + uint32_t stdPPSId; +} VkVideoEncodeH264SessionParametersGetInfoKHR; + +typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR { + VkStructureType sType; + void* pNext; + VkBool32 hasStdSPSOverrides; + VkBool32 hasStdPPSOverrides; +} VkVideoEncodeH264SessionParametersFeedbackInfoKHR; + +typedef struct VkVideoEncodeH264NaluSliceInfoKHR { + VkStructureType sType; + const void* pNext; + int32_t constantQp; + const StdVideoEncodeH264SliceHeader* pStdSliceHeader; +} VkVideoEncodeH264NaluSliceInfoKHR; + +typedef struct VkVideoEncodeH264PictureInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t naluSliceEntryCount; + const VkVideoEncodeH264NaluSliceInfoKHR* pNaluSliceEntries; + const StdVideoEncodeH264PictureInfo* pStdPictureInfo; + VkBool32 generatePrefixNalu; +} VkVideoEncodeH264PictureInfoKHR; + +typedef struct VkVideoEncodeH264DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo; +} VkVideoEncodeH264DpbSlotInfoKHR; + +typedef struct VkVideoEncodeH264ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH264ProfileIdc stdProfileIdc; +} VkVideoEncodeH264ProfileInfoKHR; + +typedef struct VkVideoEncodeH264RateControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeH264RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + uint32_t temporalLayerCount; +} VkVideoEncodeH264RateControlInfoKHR; + +typedef struct VkVideoEncodeH264FrameSizeKHR { + uint32_t frameISize; + uint32_t framePSize; + uint32_t frameBSize; +} VkVideoEncodeH264FrameSizeKHR; + +typedef struct VkVideoEncodeH264RateControlLayerInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useMinQp; + VkVideoEncodeH264QpKHR minQp; + VkBool32 useMaxQp; + VkVideoEncodeH264QpKHR maxQp; + VkBool32 useMaxFrameSize; + VkVideoEncodeH264FrameSizeKHR maxFrameSize; +} VkVideoEncodeH264RateControlLayerInfoKHR; + +typedef struct VkVideoEncodeH264GopRemainingFrameInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingI; + uint32_t gopRemainingP; + uint32_t gopRemainingB; +} VkVideoEncodeH264GopRemainingFrameInfoKHR; + + + +// VK_KHR_video_encode_h265 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_encode_h265 1 +#include "vk_video/vulkan_video_codec_h265std.h" +#include "vk_video/vulkan_video_codec_h265std_encode.h" +#define VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION 14 +#define VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_KHR_video_encode_h265" + +typedef enum VkVideoEncodeH265CapabilityFlagBitsKHR { + VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR = 0x00000020, + VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 0x00000040, + VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR = 0x00000080, + VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR = 0x00000200, + VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR = 0x00000800, + VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR = 0x00000400, + VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH265CapabilityFlagBitsKHR; +typedef VkFlags VkVideoEncodeH265CapabilityFlagsKHR; + +typedef enum VkVideoEncodeH265StdFlagBitsKHR { + VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR = 0x00000020, + VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR = 0x00000040, + VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR = 0x00000080, + VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR = 0x00000100, + VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR = 0x00000200, + VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR = 0x00000400, + VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR = 0x00000800, + VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR = 0x00001000, + VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR = 0x00002000, + VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR = 0x00004000, + VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR = 0x00008000, + VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR = 0x00010000, + VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR = 0x00020000, + VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR = 0x00040000, + VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR = 0x00080000, + VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR = 0x00100000, + VK_VIDEO_ENCODE_H265_STD_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH265StdFlagBitsKHR; +typedef VkFlags VkVideoEncodeH265StdFlagsKHR; + +typedef enum VkVideoEncodeH265CtbSizeFlagBitsKHR { + VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH265CtbSizeFlagBitsKHR; +typedef VkFlags VkVideoEncodeH265CtbSizeFlagsKHR; + +typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsKHR { + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH265TransformBlockSizeFlagBitsKHR; +typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsKHR; + +typedef enum VkVideoEncodeH265RateControlFlagBitsKHR { + VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_H265_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeH265RateControlFlagBitsKHR; +typedef VkFlags VkVideoEncodeH265RateControlFlagsKHR; +typedef struct VkVideoEncodeH265CapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeH265CapabilityFlagsKHR flags; + StdVideoH265LevelIdc maxLevelIdc; + uint32_t maxSliceSegmentCount; + VkExtent2D maxTiles; + VkVideoEncodeH265CtbSizeFlagsKHR ctbSizes; + VkVideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes; + uint32_t maxPPictureL0ReferenceCount; + uint32_t maxBPictureL0ReferenceCount; + uint32_t maxL1ReferenceCount; + uint32_t maxSubLayerCount; + VkBool32 expectDyadicTemporalSubLayerPattern; + int32_t minQp; + int32_t maxQp; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeH265StdFlagsKHR stdSyntaxFlags; +} VkVideoEncodeH265CapabilitiesKHR; + +typedef struct VkVideoEncodeH265SessionCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useMaxLevelIdc; + StdVideoH265LevelIdc maxLevelIdc; +} VkVideoEncodeH265SessionCreateInfoKHR; + +typedef struct VkVideoEncodeH265QpKHR { + int32_t qpI; + int32_t qpP; + int32_t qpB; +} VkVideoEncodeH265QpKHR; + +typedef struct VkVideoEncodeH265QualityLevelPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeH265RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredIdrPeriod; + uint32_t preferredConsecutiveBFrameCount; + uint32_t preferredSubLayerCount; + VkVideoEncodeH265QpKHR preferredConstantQp; + uint32_t preferredMaxL0ReferenceCount; + uint32_t preferredMaxL1ReferenceCount; +} VkVideoEncodeH265QualityLevelPropertiesKHR; + +typedef struct VkVideoEncodeH265SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdVPSCount; + const StdVideoH265VideoParameterSet* pStdVPSs; + uint32_t stdSPSCount; + const StdVideoH265SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH265PictureParameterSet* pStdPPSs; +} VkVideoEncodeH265SessionParametersAddInfoKHR; + +typedef struct VkVideoEncodeH265SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdVPSCount; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoEncodeH265SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoEncodeH265SessionParametersCreateInfoKHR; + +typedef struct VkVideoEncodeH265SessionParametersGetInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 writeStdVPS; + VkBool32 writeStdSPS; + VkBool32 writeStdPPS; + uint32_t stdVPSId; + uint32_t stdSPSId; + uint32_t stdPPSId; +} VkVideoEncodeH265SessionParametersGetInfoKHR; + +typedef struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR { + VkStructureType sType; + void* pNext; + VkBool32 hasStdVPSOverrides; + VkBool32 hasStdSPSOverrides; + VkBool32 hasStdPPSOverrides; +} VkVideoEncodeH265SessionParametersFeedbackInfoKHR; + +typedef struct VkVideoEncodeH265NaluSliceSegmentInfoKHR { + VkStructureType sType; + const void* pNext; + int32_t constantQp; + const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader; +} VkVideoEncodeH265NaluSliceSegmentInfoKHR; + +typedef struct VkVideoEncodeH265PictureInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t naluSliceSegmentEntryCount; + const VkVideoEncodeH265NaluSliceSegmentInfoKHR* pNaluSliceSegmentEntries; + const StdVideoEncodeH265PictureInfo* pStdPictureInfo; +} VkVideoEncodeH265PictureInfoKHR; + +typedef struct VkVideoEncodeH265DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo; +} VkVideoEncodeH265DpbSlotInfoKHR; + +typedef struct VkVideoEncodeH265ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH265ProfileIdc stdProfileIdc; +} VkVideoEncodeH265ProfileInfoKHR; + +typedef struct VkVideoEncodeH265RateControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeH265RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + uint32_t subLayerCount; +} VkVideoEncodeH265RateControlInfoKHR; + +typedef struct VkVideoEncodeH265FrameSizeKHR { + uint32_t frameISize; + uint32_t framePSize; + uint32_t frameBSize; +} VkVideoEncodeH265FrameSizeKHR; + +typedef struct VkVideoEncodeH265RateControlLayerInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useMinQp; + VkVideoEncodeH265QpKHR minQp; + VkBool32 useMaxQp; + VkVideoEncodeH265QpKHR maxQp; + VkBool32 useMaxFrameSize; + VkVideoEncodeH265FrameSizeKHR maxFrameSize; +} VkVideoEncodeH265RateControlLayerInfoKHR; + +typedef struct VkVideoEncodeH265GopRemainingFrameInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingI; + uint32_t gopRemainingP; + uint32_t gopRemainingB; +} VkVideoEncodeH265GopRemainingFrameInfoKHR; + + + +// VK_KHR_video_decode_h264 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_decode_h264 1 +#include "vk_video/vulkan_video_codec_h264std_decode.h" +#define VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION 9 +#define VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME "VK_KHR_video_decode_h264" + +typedef enum VkVideoDecodeH264PictureLayoutFlagBitsKHR { + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR = 0, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeH264PictureLayoutFlagBitsKHR; +typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsKHR; +typedef struct VkVideoDecodeH264ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH264ProfileIdc stdProfileIdc; + VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout; +} VkVideoDecodeH264ProfileInfoKHR; + +typedef struct VkVideoDecodeH264CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoH264LevelIdc maxLevelIdc; + VkOffset2D fieldOffsetGranularity; +} VkVideoDecodeH264CapabilitiesKHR; + +typedef struct VkVideoDecodeH264SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdSPSCount; + const StdVideoH264SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH264PictureParameterSet* pStdPPSs; +} VkVideoDecodeH264SessionParametersAddInfoKHR; + +typedef struct VkVideoDecodeH264SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoDecodeH264SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeH264PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264PictureInfo* pStdPictureInfo; + uint32_t sliceCount; + const uint32_t* pSliceOffsets; +} VkVideoDecodeH264PictureInfoKHR; + +typedef struct VkVideoDecodeH264DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeH264DpbSlotInfoKHR; + + + +// VK_KHR_dynamic_rendering is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_dynamic_rendering 1 +#define VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION 1 +#define VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME "VK_KHR_dynamic_rendering" +typedef VkRenderingFlags VkRenderingFlagsKHR; + +typedef VkRenderingFlagBits VkRenderingFlagBitsKHR; + +typedef VkRenderingInfo VkRenderingInfoKHR; + +typedef VkRenderingAttachmentInfo VkRenderingAttachmentInfoKHR; + +typedef VkPipelineRenderingCreateInfo VkPipelineRenderingCreateInfoKHR; + +typedef VkPhysicalDeviceDynamicRenderingFeatures VkPhysicalDeviceDynamicRenderingFeaturesKHR; + +typedef VkCommandBufferInheritanceRenderingInfo VkCommandBufferInheritanceRenderingInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR( + VkCommandBuffer commandBuffer); +#endif +#endif + + +// VK_KHR_multiview is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_multiview 1 +#define VK_KHR_MULTIVIEW_SPEC_VERSION 1 +#define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview" +typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR; + +typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR; + +typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR; + + + +// VK_KHR_get_physical_device_properties2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_get_physical_device_properties2 1 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2 +#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" +typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR; + +typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR; + +typedef VkFormatProperties2 VkFormatProperties2KHR; + +typedef VkImageFormatProperties2 VkImageFormatProperties2KHR; + +typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR; + +typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR; + +typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR; + +typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR; + +typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR; + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); +#endif +#endif + + +// VK_KHR_device_group is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_device_group 1 +#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 4 +#define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group" +typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; + +typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR; + +typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR; + +typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR; + +typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR; + +typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR; + +typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR; + +typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR; + +typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR; + +typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR; + +typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); +#endif +#endif + + +// VK_KHR_shader_draw_parameters is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_draw_parameters 1 +#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 +#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" + + +// VK_KHR_maintenance1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance1 1 +#define VK_KHR_MAINTENANCE_1_SPEC_VERSION 2 +#define VK_KHR_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_maintenance1" +// VK_KHR_MAINTENANCE1_SPEC_VERSION is a legacy alias +#define VK_KHR_MAINTENANCE1_SPEC_VERSION VK_KHR_MAINTENANCE_1_SPEC_VERSION +// VK_KHR_MAINTENANCE1_EXTENSION_NAME is a legacy alias +#define VK_KHR_MAINTENANCE1_EXTENSION_NAME VK_KHR_MAINTENANCE_1_EXTENSION_NAME +typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; + +typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); +#endif +#endif + + +// VK_KHR_device_group_creation is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_device_group_creation 1 +#define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1 +#define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation" +#define VK_MAX_DEVICE_GROUP_SIZE_KHR VK_MAX_DEVICE_GROUP_SIZE +typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR; + +typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +#endif +#endif + + +// VK_KHR_external_memory_capabilities is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_memory_capabilities 1 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" +#define VK_LUID_SIZE_KHR VK_LUID_SIZE +typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR; + +typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR; + +typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR; + +typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR; + +typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR; + +typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR; + +typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR; + +typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR; + +typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR; + +typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR; + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); +#endif +#endif + + +// VK_KHR_external_memory is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_memory 1 +#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" +#define VK_QUEUE_FAMILY_EXTERNAL_KHR VK_QUEUE_FAMILY_EXTERNAL +typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR; + +typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR; + +typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR; + + + +// VK_KHR_external_memory_fd is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_memory_fd 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" +typedef struct VkImportMemoryFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; +} VkImportMemoryFdInfoKHR; + +typedef struct VkMemoryFdPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHR; + +typedef struct VkMemoryGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties); +#endif +#endif + + +// VK_KHR_external_semaphore_capabilities is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_semaphore_capabilities 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" +typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR; + +typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR; + +typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR; + +typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR; + +typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR; + +typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +#endif +#endif + + +// VK_KHR_external_semaphore is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_semaphore 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" +typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR; + +typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR; + +typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR; + + + +// VK_KHR_external_semaphore_fd is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_semaphore_fd 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" +typedef struct VkImportSemaphoreFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + int fd; +} VkImportSemaphoreFdInfoKHR; + +typedef struct VkSemaphoreGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif +#endif + + +// VK_KHR_push_descriptor is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_push_descriptor 1 +#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 +#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" +typedef VkPhysicalDevicePushDescriptorProperties VkPhysicalDevicePushDescriptorPropertiesKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData); +#endif +#endif + + +// VK_KHR_shader_float16_int8 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_float16_int8 1 +#define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1 +#define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8" +typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR; + +typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR; + + + +// VK_KHR_16bit_storage is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_16bit_storage 1 +#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" +typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR; + + + +// VK_KHR_incremental_present is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_incremental_present 1 +#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2 +#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" +typedef struct VkRectLayerKHR { + VkOffset2D offset; + VkExtent2D extent; + uint32_t layer; +} VkRectLayerKHR; + +typedef struct VkPresentRegionKHR { + uint32_t rectangleCount; + const VkRectLayerKHR* pRectangles; +} VkPresentRegionKHR; + +typedef struct VkPresentRegionsKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentRegionKHR* pRegions; +} VkPresentRegionsKHR; + + + +// VK_KHR_descriptor_update_template is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_descriptor_update_template 1 +typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR; + +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 +#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" +typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR; + +typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR; + +typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR; + +typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); +#endif +#endif + + +// VK_KHR_imageless_framebuffer is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_imageless_framebuffer 1 +#define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1 +#define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer" +typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR; + +typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR; + +typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR; + +typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR; + + + +// VK_KHR_create_renderpass2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_create_renderpass2 1 +#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1 +#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2" +typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR; + +typedef VkAttachmentDescription2 VkAttachmentDescription2KHR; + +typedef VkAttachmentReference2 VkAttachmentReference2KHR; + +typedef VkSubpassDescription2 VkSubpassDescription2KHR; + +typedef VkSubpassDependency2 VkSubpassDependency2KHR; + +typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR; + +typedef VkSubpassEndInfo VkSubpassEndInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo); +#endif +#endif + + +// VK_KHR_shared_presentable_image is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shared_presentable_image 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 +#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" +typedef struct VkSharedPresentSurfaceCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilitiesKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain); +#endif +#endif + + +// VK_KHR_external_fence_capabilities is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_fence_capabilities 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" +typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR; + +typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR; + +typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR; + +typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR; + +typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR; + +typedef VkExternalFenceProperties VkExternalFencePropertiesKHR; + +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); +#endif +#endif + + +// VK_KHR_external_fence is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_fence 1 +#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" +typedef VkFenceImportFlags VkFenceImportFlagsKHR; + +typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR; + +typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR; + + + +// VK_KHR_external_fence_fd is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_fence_fd 1 +#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" +typedef struct VkImportFenceFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + int fd; +} VkImportFenceFdInfoKHR; + +typedef struct VkFenceGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetFdInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd); +#endif +#endif + + +// VK_KHR_performance_query is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_performance_query 1 +#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 +#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query" + +typedef enum VkPerformanceCounterUnitKHR { + VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, + VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, + VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, + VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, + VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, + VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, + VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, + VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, + VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, + VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterUnitKHR; + +typedef enum VkPerformanceCounterScopeKHR { + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0, + VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1, + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2, + // VK_QUERY_SCOPE_COMMAND_BUFFER_KHR is a legacy alias + VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, + // VK_QUERY_SCOPE_RENDER_PASS_KHR is a legacy alias + VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, + // VK_QUERY_SCOPE_COMMAND_KHR is a legacy alias + VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, + VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterScopeKHR; + +typedef enum VkPerformanceCounterStorageKHR { + VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, + VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, + VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, + VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, + VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterStorageKHR; + +typedef enum VkPerformanceCounterDescriptionFlagBitsKHR { + VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001, + VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002, + // VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR is a legacy alias + VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, + // VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR is a legacy alias + VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR, + VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterDescriptionFlagBitsKHR; +typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; + +typedef enum VkAcquireProfilingLockFlagBitsKHR { + VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAcquireProfilingLockFlagBitsKHR; +typedef VkFlags VkAcquireProfilingLockFlagsKHR; +typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 performanceCounterQueryPools; + VkBool32 performanceCounterMultipleQueryPools; +} VkPhysicalDevicePerformanceQueryFeaturesKHR; + +typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 allowCommandBufferQueryCopies; +} VkPhysicalDevicePerformanceQueryPropertiesKHR; + +typedef struct VkPerformanceCounterKHR { + VkStructureType sType; + void* pNext; + VkPerformanceCounterUnitKHR unit; + VkPerformanceCounterScopeKHR scope; + VkPerformanceCounterStorageKHR storage; + uint8_t uuid[VK_UUID_SIZE]; +} VkPerformanceCounterKHR; + +typedef struct VkPerformanceCounterDescriptionKHR { + VkStructureType sType; + void* pNext; + VkPerformanceCounterDescriptionFlagsKHR flags; + char name[VK_MAX_DESCRIPTION_SIZE]; + char category[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkPerformanceCounterDescriptionKHR; + +typedef struct VkQueryPoolPerformanceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + uint32_t counterIndexCount; + const uint32_t* pCounterIndices; +} VkQueryPoolPerformanceCreateInfoKHR; + +typedef union VkPerformanceCounterResultKHR { + int32_t int32; + int64_t int64; + uint32_t uint32; + uint64_t uint64; + float float32; + double float64; +} VkPerformanceCounterResultKHR; + +typedef struct VkAcquireProfilingLockInfoKHR { + VkStructureType sType; + const void* pNext; + VkAcquireProfilingLockFlagsKHR flags; + uint64_t timeout; +} VkAcquireProfilingLockInfoKHR; + +typedef struct VkPerformanceQuerySubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t counterPassIndex; +} VkPerformanceQuerySubmitInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + VkPhysicalDevice physicalDevice, + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, + uint32_t* pNumPasses); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR( + VkDevice device, + const VkAcquireProfilingLockInfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR( + VkDevice device); +#endif +#endif + + +// VK_KHR_maintenance2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance2 1 +#define VK_KHR_MAINTENANCE_2_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_maintenance2" +// VK_KHR_MAINTENANCE2_SPEC_VERSION is a legacy alias +#define VK_KHR_MAINTENANCE2_SPEC_VERSION VK_KHR_MAINTENANCE_2_SPEC_VERSION +// VK_KHR_MAINTENANCE2_EXTENSION_NAME is a legacy alias +#define VK_KHR_MAINTENANCE2_EXTENSION_NAME VK_KHR_MAINTENANCE_2_EXTENSION_NAME +typedef VkPointClippingBehavior VkPointClippingBehaviorKHR; + +typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR; + +typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR; + +typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR; + +typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR; + +typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR; + +typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR; + + + +// VK_KHR_get_surface_capabilities2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_get_surface_capabilities2 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" +typedef struct VkPhysicalDeviceSurfaceInfo2KHR { + VkStructureType sType; + const void* pNext; + VkSurfaceKHR surface; +} VkPhysicalDeviceSurfaceInfo2KHR; + +typedef struct VkSurfaceCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceCapabilitiesKHR surfaceCapabilities; +} VkSurfaceCapabilities2KHR; + +typedef struct VkSurfaceFormat2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceFormatKHR surfaceFormat; +} VkSurfaceFormat2KHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); +#endif +#endif + + +// VK_KHR_variable_pointers is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_variable_pointers 1 +#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 +#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; + +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR; + + + +// VK_KHR_get_display_properties2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_get_display_properties2 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 +#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" +typedef struct VkDisplayProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPropertiesKHR displayProperties; +} VkDisplayProperties2KHR; + +typedef struct VkDisplayPlaneProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlanePropertiesKHR displayPlaneProperties; +} VkDisplayPlaneProperties2KHR; + +typedef struct VkDisplayModeProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayModePropertiesKHR displayModeProperties; +} VkDisplayModeProperties2KHR; + +typedef struct VkDisplayPlaneInfo2KHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeKHR mode; + uint32_t planeIndex; +} VkDisplayPlaneInfo2KHR; + +typedef struct VkDisplayPlaneCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlaneCapabilitiesKHR capabilities; +} VkDisplayPlaneCapabilities2KHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities); +#endif +#endif + + +// VK_KHR_dedicated_allocation is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_dedicated_allocation 1 +#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 +#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" +typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR; + +typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR; + + + +// VK_KHR_storage_buffer_storage_class is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_storage_buffer_storage_class 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 +#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" + + +// VK_KHR_shader_bfloat16 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_bfloat16 1 +#define VK_KHR_SHADER_BFLOAT16_SPEC_VERSION 1 +#define VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME "VK_KHR_shader_bfloat16" +typedef struct VkPhysicalDeviceShaderBfloat16FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderBFloat16Type; + VkBool32 shaderBFloat16DotProduct; + VkBool32 shaderBFloat16CooperativeMatrix; +} VkPhysicalDeviceShaderBfloat16FeaturesKHR; + + + +// VK_KHR_relaxed_block_layout is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_relaxed_block_layout 1 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1 +#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout" + + +// VK_KHR_get_memory_requirements2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_get_memory_requirements2 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 +#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" +typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR; + +typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR; + +typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR; + +typedef VkMemoryRequirements2 VkMemoryRequirements2KHR; + +typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR; + +typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +#endif +#endif + + +// VK_KHR_image_format_list is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_image_format_list 1 +#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1 +#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list" +typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR; + + + +// VK_KHR_sampler_ycbcr_conversion is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_sampler_ycbcr_conversion 1 +typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR; + +#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14 +#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" +typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR; + +typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR; + +typedef VkChromaLocation VkChromaLocationKHR; + +typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR; + +typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR; + +typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR; + +typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR; + +typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; + +typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); +#endif +#endif + + +// VK_KHR_bind_memory2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_bind_memory2 1 +#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1 +#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" +typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR; + +typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); +#endif +#endif + + +// VK_KHR_maintenance3 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance3 1 +#define VK_KHR_MAINTENANCE_3_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_3_EXTENSION_NAME "VK_KHR_maintenance3" +// VK_KHR_MAINTENANCE3_SPEC_VERSION is a legacy alias +#define VK_KHR_MAINTENANCE3_SPEC_VERSION VK_KHR_MAINTENANCE_3_SPEC_VERSION +// VK_KHR_MAINTENANCE3_EXTENSION_NAME is a legacy alias +#define VK_KHR_MAINTENANCE3_EXTENSION_NAME VK_KHR_MAINTENANCE_3_EXTENSION_NAME +typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR; + +typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR; + +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); +#endif +#endif + + +// VK_KHR_draw_indirect_count is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_draw_indirect_count 1 +#define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 +#define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count" +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif +#endif + + +// VK_KHR_shader_subgroup_extended_types is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_subgroup_extended_types 1 +#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1 +#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types" +typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; + + + +// VK_KHR_8bit_storage is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_8bit_storage 1 +#define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1 +#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage" +typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR; + + + +// VK_KHR_shader_atomic_int64 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_atomic_int64 1 +#define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1 +#define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64" +typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR; + + + +// VK_KHR_shader_clock is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_clock 1 +#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1 +#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock" +typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupClock; + VkBool32 shaderDeviceClock; +} VkPhysicalDeviceShaderClockFeaturesKHR; + + + +// VK_KHR_video_decode_h265 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_decode_h265 1 +#include "vk_video/vulkan_video_codec_h265std_decode.h" +#define VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION 8 +#define VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME "VK_KHR_video_decode_h265" +typedef struct VkVideoDecodeH265ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH265ProfileIdc stdProfileIdc; +} VkVideoDecodeH265ProfileInfoKHR; + +typedef struct VkVideoDecodeH265CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoH265LevelIdc maxLevelIdc; +} VkVideoDecodeH265CapabilitiesKHR; + +typedef struct VkVideoDecodeH265SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdVPSCount; + const StdVideoH265VideoParameterSet* pStdVPSs; + uint32_t stdSPSCount; + const StdVideoH265SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH265PictureParameterSet* pStdPPSs; +} VkVideoDecodeH265SessionParametersAddInfoKHR; + +typedef struct VkVideoDecodeH265SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdVPSCount; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoDecodeH265SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeH265PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH265PictureInfo* pStdPictureInfo; + uint32_t sliceSegmentCount; + const uint32_t* pSliceSegmentOffsets; +} VkVideoDecodeH265PictureInfoKHR; + +typedef struct VkVideoDecodeH265DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeH265DpbSlotInfoKHR; + + + +// VK_KHR_global_priority is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_global_priority 1 +#define VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION 1 +#define VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME "VK_KHR_global_priority" +#define VK_MAX_GLOBAL_PRIORITY_SIZE_KHR VK_MAX_GLOBAL_PRIORITY_SIZE +typedef VkQueueGlobalPriority VkQueueGlobalPriorityKHR; + +typedef VkDeviceQueueGlobalPriorityCreateInfo VkDeviceQueueGlobalPriorityCreateInfoKHR; + +typedef VkPhysicalDeviceGlobalPriorityQueryFeatures VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR; + +typedef VkQueueFamilyGlobalPriorityProperties VkQueueFamilyGlobalPriorityPropertiesKHR; + + + +// VK_KHR_driver_properties is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_driver_properties 1 +#define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1 +#define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties" +#define VK_MAX_DRIVER_NAME_SIZE_KHR VK_MAX_DRIVER_NAME_SIZE +#define VK_MAX_DRIVER_INFO_SIZE_KHR VK_MAX_DRIVER_INFO_SIZE +typedef VkDriverId VkDriverIdKHR; + +typedef VkConformanceVersion VkConformanceVersionKHR; + +typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR; + + + +// VK_KHR_shader_float_controls is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_float_controls 1 +#define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4 +#define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls" +typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR; + +typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR; + + + +// VK_KHR_depth_stencil_resolve is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_depth_stencil_resolve 1 +#define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1 +#define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve" +typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR; + +typedef VkResolveModeFlags VkResolveModeFlagsKHR; + +typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR; + +typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR; + + + +// VK_KHR_swapchain_mutable_format is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_swapchain_mutable_format 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1 +#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format" + + +// VK_KHR_timeline_semaphore is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_timeline_semaphore 1 +#define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2 +#define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore" +typedef VkSemaphoreType VkSemaphoreTypeKHR; + +typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR; + +typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR; + +typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR; + +typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR; + +typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR; + +typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR; + +typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR; + +typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo); +#endif +#endif + + +// VK_KHR_vulkan_memory_model is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_vulkan_memory_model 1 +#define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3 +#define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model" +typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR; + + + +// VK_KHR_shader_terminate_invocation is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_terminate_invocation 1 +#define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1 +#define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation" +typedef VkPhysicalDeviceShaderTerminateInvocationFeatures VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR; + + + +// VK_KHR_fragment_shading_rate is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_fragment_shading_rate 1 +#define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 2 +#define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate" + +typedef enum VkFragmentShadingRateCombinerOpKHR { + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF +} VkFragmentShadingRateCombinerOpKHR; +typedef struct VkFragmentShadingRateAttachmentInfoKHR { + VkStructureType sType; + const void* pNext; + const VkAttachmentReference2* pFragmentShadingRateAttachment; + VkExtent2D shadingRateAttachmentTexelSize; +} VkFragmentShadingRateAttachmentInfoKHR; + +typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExtent2D fragmentSize; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; +} VkPipelineFragmentShadingRateStateCreateInfoKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 pipelineFragmentShadingRate; + VkBool32 primitiveFragmentShadingRate; + VkBool32 attachmentFragmentShadingRate; +} VkPhysicalDeviceFragmentShadingRateFeaturesKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR { + VkStructureType sType; + void* pNext; + VkExtent2D minFragmentShadingRateAttachmentTexelSize; + VkExtent2D maxFragmentShadingRateAttachmentTexelSize; + uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + VkBool32 primitiveFragmentShadingRateWithMultipleViewports; + VkBool32 layeredShadingRateAttachments; + VkBool32 fragmentShadingRateNonTrivialCombinerOps; + VkExtent2D maxFragmentSize; + uint32_t maxFragmentSizeAspectRatio; + uint32_t maxFragmentShadingRateCoverageSamples; + VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; + VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; + VkBool32 fragmentShadingRateWithSampleMask; + VkBool32 fragmentShadingRateWithShaderSampleMask; + VkBool32 fragmentShadingRateWithConservativeRasterization; + VkBool32 fragmentShadingRateWithFragmentShaderInterlock; + VkBool32 fragmentShadingRateWithCustomSampleLocations; + VkBool32 fragmentShadingRateStrictMultiplyCombiner; +} VkPhysicalDeviceFragmentShadingRatePropertiesKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRateKHR { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleCounts; + VkExtent2D fragmentSize; +} VkPhysicalDeviceFragmentShadingRateKHR; + +typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkImageLayout imageLayout; + VkExtent2D shadingRateAttachmentTexelSize; +} VkRenderingFragmentShadingRateAttachmentInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); +typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR( + VkCommandBuffer commandBuffer, + const VkExtent2D* pFragmentSize, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); +#endif +#endif + + +// VK_KHR_dynamic_rendering_local_read is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_dynamic_rendering_local_read 1 +#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION 1 +#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME "VK_KHR_dynamic_rendering_local_read" +typedef VkPhysicalDeviceDynamicRenderingLocalReadFeatures VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR; + +typedef VkRenderingAttachmentLocationInfo VkRenderingAttachmentLocationInfoKHR; + +typedef VkRenderingInputAttachmentIndexInfo VkRenderingInputAttachmentIndexInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocationsKHR)(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo); +typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR( + VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfo* pLocationInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR( + VkCommandBuffer commandBuffer, + const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); +#endif +#endif + + +// VK_KHR_shader_quad_control is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_quad_control 1 +#define VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION 1 +#define VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME "VK_KHR_shader_quad_control" +typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderQuadControl; +} VkPhysicalDeviceShaderQuadControlFeaturesKHR; + + + +// VK_KHR_spirv_1_4 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_spirv_1_4 1 +#define VK_KHR_SPIRV_1_4_SPEC_VERSION 1 +#define VK_KHR_SPIRV_1_4_EXTENSION_NAME "VK_KHR_spirv_1_4" + + +// VK_KHR_surface_protected_capabilities is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_surface_protected_capabilities 1 +#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1 +#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities" +typedef struct VkSurfaceProtectedCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 supportsProtected; +} VkSurfaceProtectedCapabilitiesKHR; + + + +// VK_KHR_separate_depth_stencil_layouts is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_separate_depth_stencil_layouts 1 +#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1 +#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts" +typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR; + +typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR; + +typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR; + + + +// VK_KHR_present_wait is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_present_wait 1 +#define VK_KHR_PRESENT_WAIT_SPEC_VERSION 1 +#define VK_KHR_PRESENT_WAIT_EXTENSION_NAME "VK_KHR_present_wait" +typedef struct VkPhysicalDevicePresentWaitFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 presentWait; +} VkPhysicalDevicePresentWaitFeaturesKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t presentId, + uint64_t timeout); +#endif +#endif + + +// VK_KHR_uniform_buffer_standard_layout is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_uniform_buffer_standard_layout 1 +#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1 +#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout" +typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; + + + +// VK_KHR_buffer_device_address is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_buffer_device_address 1 +#define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1 +#define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address" +typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR; + +typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR; + +typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR; + +typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR; + +typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR; + +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +#endif +#endif + + +// VK_KHR_deferred_host_operations is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_deferred_host_operations 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR) +#define VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION 4 +#define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations" +typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation); +typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator); +typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation); +typedef VkResult (VKAPI_PTR *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR( + VkDevice device, + const VkAllocationCallbacks* pAllocator, + VkDeferredOperationKHR* pDeferredOperation); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR( + VkDevice device, + VkDeferredOperationKHR operation, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR( + VkDevice device, + VkDeferredOperationKHR operation); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR( + VkDevice device, + VkDeferredOperationKHR operation); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR( + VkDevice device, + VkDeferredOperationKHR operation); +#endif +#endif + + +// VK_KHR_pipeline_executable_properties is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_pipeline_executable_properties 1 +#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1 +#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties" + +typedef enum VkPipelineExecutableStatisticFormatKHR { + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPipelineExecutableStatisticFormatKHR; +typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 pipelineExecutableInfo; +} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + +typedef struct VkPipelineInfoKHR { + VkStructureType sType; + const void* pNext; + VkPipeline pipeline; +} VkPipelineInfoKHR; + +typedef struct VkPipelineExecutablePropertiesKHR { + VkStructureType sType; + void* pNext; + VkShaderStageFlags stages; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + uint32_t subgroupSize; +} VkPipelineExecutablePropertiesKHR; + +typedef struct VkPipelineExecutableInfoKHR { + VkStructureType sType; + const void* pNext; + VkPipeline pipeline; + uint32_t executableIndex; +} VkPipelineExecutableInfoKHR; + +typedef union VkPipelineExecutableStatisticValueKHR { + VkBool32 b32; + int64_t i64; + uint64_t u64; + double f64; +} VkPipelineExecutableStatisticValueKHR; + +typedef struct VkPipelineExecutableStatisticKHR { + VkStructureType sType; + void* pNext; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkPipelineExecutableStatisticFormatKHR format; + VkPipelineExecutableStatisticValueKHR value; +} VkPipelineExecutableStatisticKHR; + +typedef struct VkPipelineExecutableInternalRepresentationKHR { + VkStructureType sType; + void* pNext; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkBool32 isText; + size_t dataSize; + void* pData; +} VkPipelineExecutableInternalRepresentationKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR( + VkDevice device, + const VkPipelineInfoKHR* pPipelineInfo, + uint32_t* pExecutableCount, + VkPipelineExecutablePropertiesKHR* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pStatisticCount, + VkPipelineExecutableStatisticKHR* pStatistics); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pInternalRepresentationCount, + VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); +#endif +#endif + + +// VK_KHR_map_memory2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_map_memory2 1 +#define VK_KHR_MAP_MEMORY_2_SPEC_VERSION 1 +#define VK_KHR_MAP_MEMORY_2_EXTENSION_NAME "VK_KHR_map_memory2" +typedef VkMemoryUnmapFlagBits VkMemoryUnmapFlagBitsKHR; + +typedef VkMemoryUnmapFlags VkMemoryUnmapFlagsKHR; + +typedef VkMemoryMapInfo VkMemoryMapInfoKHR; + +typedef VkMemoryUnmapInfo VkMemoryUnmapInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkMapMemory2KHR)(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData); +typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2KHR)(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2KHR( + VkDevice device, + const VkMemoryMapInfo* pMemoryMapInfo, + void** ppData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2KHR( + VkDevice device, + const VkMemoryUnmapInfo* pMemoryUnmapInfo); +#endif +#endif + + +// VK_KHR_shader_integer_dot_product is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_integer_dot_product 1 +#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION 1 +#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME "VK_KHR_shader_integer_dot_product" +typedef VkPhysicalDeviceShaderIntegerDotProductFeatures VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR; + +typedef VkPhysicalDeviceShaderIntegerDotProductProperties VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR; + + + +// VK_KHR_pipeline_library is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_pipeline_library 1 +#define VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION 1 +#define VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME "VK_KHR_pipeline_library" +typedef struct VkPipelineLibraryCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t libraryCount; + const VkPipeline* pLibraries; +} VkPipelineLibraryCreateInfoKHR; + + + +// VK_KHR_shader_non_semantic_info is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_non_semantic_info 1 +#define VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION 1 +#define VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME "VK_KHR_shader_non_semantic_info" + + +// VK_KHR_present_id is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_present_id 1 +#define VK_KHR_PRESENT_ID_SPEC_VERSION 1 +#define VK_KHR_PRESENT_ID_EXTENSION_NAME "VK_KHR_present_id" +typedef struct VkPresentIdKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint64_t* pPresentIds; +} VkPresentIdKHR; + +typedef struct VkPhysicalDevicePresentIdFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 presentId; +} VkPhysicalDevicePresentIdFeaturesKHR; + + + +// VK_KHR_video_encode_queue is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_encode_queue 1 +#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 12 +#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue" + +typedef enum VkVideoEncodeTuningModeKHR { + VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1, + VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2, + VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3, + VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4, + VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeTuningModeKHR; + +typedef enum VkVideoEncodeFlagBitsKHR { + VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeFlagBitsKHR; +typedef VkFlags VkVideoEncodeFlagsKHR; + +typedef enum VkVideoEncodeCapabilityFlagBitsKHR { + VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeCapabilityFlagBitsKHR; +typedef VkFlags VkVideoEncodeCapabilityFlagsKHR; + +typedef enum VkVideoEncodeRateControlModeFlagBitsKHR { + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeRateControlModeFlagBitsKHR; +typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; + +typedef enum VkVideoEncodeFeedbackFlagBitsKHR { + VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeFeedbackFlagBitsKHR; +typedef VkFlags VkVideoEncodeFeedbackFlagsKHR; + +typedef enum VkVideoEncodeUsageFlagBitsKHR { + VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeUsageFlagBitsKHR; +typedef VkFlags VkVideoEncodeUsageFlagsKHR; + +typedef enum VkVideoEncodeContentFlagBitsKHR { + VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0, + VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeContentFlagBitsKHR; +typedef VkFlags VkVideoEncodeContentFlagsKHR; +typedef VkFlags VkVideoEncodeRateControlFlagsKHR; +typedef struct VkVideoEncodeInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeFlagsKHR flags; + VkBuffer dstBuffer; + VkDeviceSize dstBufferOffset; + VkDeviceSize dstBufferRange; + VkVideoPictureResourceInfoKHR srcPictureResource; + const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotInfoKHR* pReferenceSlots; + uint32_t precedingExternallyEncodedBytes; +} VkVideoEncodeInfoKHR; + +typedef struct VkVideoEncodeCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeCapabilityFlagsKHR flags; + VkVideoEncodeRateControlModeFlagsKHR rateControlModes; + uint32_t maxRateControlLayers; + uint64_t maxBitrate; + uint32_t maxQualityLevels; + VkExtent2D encodeInputPictureGranularity; + VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; +} VkVideoEncodeCapabilitiesKHR; + +typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; +} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR; + +typedef struct VkVideoEncodeUsageInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeUsageFlagsKHR videoUsageHints; + VkVideoEncodeContentFlagsKHR videoContentHints; + VkVideoEncodeTuningModeKHR tuningMode; +} VkVideoEncodeUsageInfoKHR; + +typedef struct VkVideoEncodeRateControlLayerInfoKHR { + VkStructureType sType; + const void* pNext; + uint64_t averageBitrate; + uint64_t maxBitrate; + uint32_t frameRateNumerator; + uint32_t frameRateDenominator; +} VkVideoEncodeRateControlLayerInfoKHR; + +typedef struct VkVideoEncodeRateControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeRateControlFlagsKHR flags; + VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; + uint32_t layerCount; + const VkVideoEncodeRateControlLayerInfoKHR* pLayers; + uint32_t virtualBufferSizeInMs; + uint32_t initialVirtualBufferSizeInMs; +} VkVideoEncodeRateControlInfoKHR; + +typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR { + VkStructureType sType; + const void* pNext; + const VkVideoProfileInfoKHR* pVideoProfile; + uint32_t qualityLevel; +} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR; + +typedef struct VkVideoEncodeQualityLevelPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode; + uint32_t preferredRateControlLayerCount; +} VkVideoEncodeQualityLevelPropertiesKHR; + +typedef struct VkVideoEncodeQualityLevelInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t qualityLevel; +} VkVideoEncodeQualityLevelInfoKHR; + +typedef struct VkVideoEncodeSessionParametersGetInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoSessionParametersKHR videoSessionParameters; +} VkVideoEncodeSessionParametersGetInfoKHR; + +typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR { + VkStructureType sType; + void* pNext; + VkBool32 hasOverrides; +} VkVideoEncodeSessionParametersFeedbackInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR( + VkDevice device, + const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, + size_t* pDataSize, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoEncodeInfoKHR* pEncodeInfo); +#endif +#endif + + +// VK_KHR_synchronization2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_synchronization2 1 +#define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1 +#define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2" +typedef VkPipelineStageFlags2 VkPipelineStageFlags2KHR; + +typedef VkPipelineStageFlagBits2 VkPipelineStageFlagBits2KHR; + +typedef VkAccessFlags2 VkAccessFlags2KHR; + +typedef VkAccessFlagBits2 VkAccessFlagBits2KHR; + +typedef VkSubmitFlagBits VkSubmitFlagBitsKHR; + +typedef VkSubmitFlags VkSubmitFlagsKHR; + +typedef VkMemoryBarrier2 VkMemoryBarrier2KHR; + +typedef VkBufferMemoryBarrier2 VkBufferMemoryBarrier2KHR; + +typedef VkImageMemoryBarrier2 VkImageMemoryBarrier2KHR; + +typedef VkDependencyInfo VkDependencyInfoKHR; + +typedef VkSubmitInfo2 VkSubmitInfo2KHR; + +typedef VkSemaphoreSubmitInfo VkSemaphoreSubmitInfoKHR; + +typedef VkCommandBufferSubmitInfo VkCommandBufferSubmitInfoKHR; + +typedef VkPhysicalDeviceSynchronization2Features VkPhysicalDeviceSynchronization2FeaturesKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence); +#endif +#endif + + +// VK_KHR_fragment_shader_barycentric is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_fragment_shader_barycentric 1 +#define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 +#define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_KHR_fragment_shader_barycentric" +typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShaderBarycentric; +} VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + +typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 triStripVertexOrderIndependentOfProvokingVertex; +} VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + + + +// VK_KHR_shader_subgroup_uniform_control_flow is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_subgroup_uniform_control_flow 1 +#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION 1 +#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME "VK_KHR_shader_subgroup_uniform_control_flow" +typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupUniformControlFlow; +} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + + + +// VK_KHR_zero_initialize_workgroup_memory is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_zero_initialize_workgroup_memory 1 +#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION 1 +#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME "VK_KHR_zero_initialize_workgroup_memory" +typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR; + + + +// VK_KHR_workgroup_memory_explicit_layout is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_workgroup_memory_explicit_layout 1 +#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION 1 +#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME "VK_KHR_workgroup_memory_explicit_layout" +typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 workgroupMemoryExplicitLayout; + VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout; + VkBool32 workgroupMemoryExplicitLayout8BitAccess; + VkBool32 workgroupMemoryExplicitLayout16BitAccess; +} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + + + +// VK_KHR_copy_commands2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_copy_commands2 1 +#define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1 +#define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2" +typedef VkCopyBufferInfo2 VkCopyBufferInfo2KHR; + +typedef VkCopyImageInfo2 VkCopyImageInfo2KHR; + +typedef VkCopyBufferToImageInfo2 VkCopyBufferToImageInfo2KHR; + +typedef VkCopyImageToBufferInfo2 VkCopyImageToBufferInfo2KHR; + +typedef VkBlitImageInfo2 VkBlitImageInfo2KHR; + +typedef VkResolveImageInfo2 VkResolveImageInfo2KHR; + +typedef VkBufferCopy2 VkBufferCopy2KHR; + +typedef VkImageCopy2 VkImageCopy2KHR; + +typedef VkImageBlit2 VkImageBlit2KHR; + +typedef VkBufferImageCopy2 VkBufferImageCopy2KHR; + +typedef VkImageResolve2 VkImageResolve2KHR; + +typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo); +#endif +#endif + + +// VK_KHR_format_feature_flags2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_format_feature_flags2 1 +#define VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION 2 +#define VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME "VK_KHR_format_feature_flags2" +typedef VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR; + +typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR; + +typedef VkFormatProperties3 VkFormatProperties3KHR; + + + +// VK_KHR_ray_tracing_maintenance1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_ray_tracing_maintenance1 1 +#define VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_ray_tracing_maintenance1" +typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingMaintenance1; + VkBool32 rayTracingPipelineTraceRaysIndirect2; +} VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR; + +typedef struct VkTraceRaysIndirectCommand2KHR { + VkDeviceAddress raygenShaderRecordAddress; + VkDeviceSize raygenShaderRecordSize; + VkDeviceAddress missShaderBindingTableAddress; + VkDeviceSize missShaderBindingTableSize; + VkDeviceSize missShaderBindingTableStride; + VkDeviceAddress hitShaderBindingTableAddress; + VkDeviceSize hitShaderBindingTableSize; + VkDeviceSize hitShaderBindingTableStride; + VkDeviceAddress callableShaderBindingTableAddress; + VkDeviceSize callableShaderBindingTableSize; + VkDeviceSize callableShaderBindingTableStride; + uint32_t width; + uint32_t height; + uint32_t depth; +} VkTraceRaysIndirectCommand2KHR; + +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectDeviceAddress); +#endif +#endif + + +// VK_KHR_shader_untyped_pointers is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_untyped_pointers 1 +#define VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION 1 +#define VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME "VK_KHR_shader_untyped_pointers" +typedef struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderUntypedPointers; +} VkPhysicalDeviceShaderUntypedPointersFeaturesKHR; + + + +// VK_KHR_portability_enumeration is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_portability_enumeration 1 +#define VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION 1 +#define VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME "VK_KHR_portability_enumeration" + + +// VK_KHR_maintenance4 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance4 1 +#define VK_KHR_MAINTENANCE_4_SPEC_VERSION 2 +#define VK_KHR_MAINTENANCE_4_EXTENSION_NAME "VK_KHR_maintenance4" +typedef VkPhysicalDeviceMaintenance4Features VkPhysicalDeviceMaintenance4FeaturesKHR; + +typedef VkPhysicalDeviceMaintenance4Properties VkPhysicalDeviceMaintenance4PropertiesKHR; + +typedef VkDeviceBufferMemoryRequirements VkDeviceBufferMemoryRequirementsKHR; + +typedef VkDeviceImageMemoryRequirements VkDeviceImageMemoryRequirementsKHR; + +typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +#endif +#endif + + +// VK_KHR_shader_subgroup_rotate is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_subgroup_rotate 1 +#define VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION 2 +#define VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME "VK_KHR_shader_subgroup_rotate" +typedef VkPhysicalDeviceShaderSubgroupRotateFeatures VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR; + + + +// VK_KHR_shader_maximal_reconvergence is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_maximal_reconvergence 1 +#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION 1 +#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME "VK_KHR_shader_maximal_reconvergence" +typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderMaximalReconvergence; +} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; + + + +// VK_KHR_maintenance5 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance5 1 +#define VK_KHR_MAINTENANCE_5_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_5_EXTENSION_NAME "VK_KHR_maintenance5" +typedef VkPipelineCreateFlags2 VkPipelineCreateFlags2KHR; + +typedef VkPipelineCreateFlagBits2 VkPipelineCreateFlagBits2KHR; + +typedef VkBufferUsageFlags2 VkBufferUsageFlags2KHR; + +typedef VkBufferUsageFlagBits2 VkBufferUsageFlagBits2KHR; + +typedef VkPhysicalDeviceMaintenance5Features VkPhysicalDeviceMaintenance5FeaturesKHR; + +typedef VkPhysicalDeviceMaintenance5Properties VkPhysicalDeviceMaintenance5PropertiesKHR; + +typedef VkRenderingAreaInfo VkRenderingAreaInfoKHR; + +typedef VkDeviceImageSubresourceInfo VkDeviceImageSubresourceInfoKHR; + +typedef VkImageSubresource2 VkImageSubresource2KHR; + +typedef VkSubresourceLayout2 VkSubresourceLayout2KHR; + +typedef VkPipelineCreateFlags2CreateInfo VkPipelineCreateFlags2CreateInfoKHR; + +typedef VkBufferUsageFlags2CreateInfo VkBufferUsageFlags2CreateInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer2KHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType); +typedef void (VKAPI_PTR *PFN_vkGetRenderingAreaGranularityKHR)(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity); +typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSubresourceLayoutKHR)(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout); +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2KHR)(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2KHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularityKHR( + VkDevice device, + const VkRenderingAreaInfo* pRenderingAreaInfo, + VkExtent2D* pGranularity); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayoutKHR( + VkDevice device, + const VkDeviceImageSubresourceInfo* pInfo, + VkSubresourceLayout2* pLayout); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2KHR( + VkDevice device, + VkImage image, + const VkImageSubresource2* pSubresource, + VkSubresourceLayout2* pLayout); +#endif +#endif + + +// VK_KHR_present_id2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_present_id2 1 +#define VK_KHR_PRESENT_ID_2_SPEC_VERSION 1 +#define VK_KHR_PRESENT_ID_2_EXTENSION_NAME "VK_KHR_present_id2" +typedef struct VkSurfaceCapabilitiesPresentId2KHR { + VkStructureType sType; + void* pNext; + VkBool32 presentId2Supported; +} VkSurfaceCapabilitiesPresentId2KHR; + +typedef struct VkPresentId2KHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint64_t* pPresentIds; +} VkPresentId2KHR; + +typedef struct VkPhysicalDevicePresentId2FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 presentId2; +} VkPhysicalDevicePresentId2FeaturesKHR; + + + +// VK_KHR_present_wait2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_present_wait2 1 +#define VK_KHR_PRESENT_WAIT_2_SPEC_VERSION 1 +#define VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME "VK_KHR_present_wait2" +typedef struct VkSurfaceCapabilitiesPresentWait2KHR { + VkStructureType sType; + void* pNext; + VkBool32 presentWait2Supported; +} VkSurfaceCapabilitiesPresentWait2KHR; + +typedef struct VkPhysicalDevicePresentWait2FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 presentWait2; +} VkPhysicalDevicePresentWait2FeaturesKHR; + +typedef struct VkPresentWait2InfoKHR { + VkStructureType sType; + const void* pNext; + uint64_t presentId; + uint64_t timeout; +} VkPresentWait2InfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresent2KHR)(VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR* pPresentWait2Info); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresent2KHR( + VkDevice device, + VkSwapchainKHR swapchain, + const VkPresentWait2InfoKHR* pPresentWait2Info); +#endif +#endif + + +// VK_KHR_ray_tracing_position_fetch is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_ray_tracing_position_fetch 1 +#define VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION 1 +#define VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME "VK_KHR_ray_tracing_position_fetch" +typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingPositionFetch; +} VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR; + + + +// VK_KHR_pipeline_binary is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_pipeline_binary 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineBinaryKHR) +#define VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR 32U +#define VK_KHR_PIPELINE_BINARY_SPEC_VERSION 1 +#define VK_KHR_PIPELINE_BINARY_EXTENSION_NAME "VK_KHR_pipeline_binary" +typedef struct VkPhysicalDevicePipelineBinaryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 pipelineBinaries; +} VkPhysicalDevicePipelineBinaryFeaturesKHR; + +typedef struct VkPhysicalDevicePipelineBinaryPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 pipelineBinaryInternalCache; + VkBool32 pipelineBinaryInternalCacheControl; + VkBool32 pipelineBinaryPrefersInternalCache; + VkBool32 pipelineBinaryPrecompiledInternalCache; + VkBool32 pipelineBinaryCompressedData; +} VkPhysicalDevicePipelineBinaryPropertiesKHR; + +typedef struct VkDevicePipelineBinaryInternalCacheControlKHR { + VkStructureType sType; + const void* pNext; + VkBool32 disableInternalCache; +} VkDevicePipelineBinaryInternalCacheControlKHR; + +typedef struct VkPipelineBinaryKeyKHR { + VkStructureType sType; + void* pNext; + uint32_t keySize; + uint8_t key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR]; +} VkPipelineBinaryKeyKHR; + +typedef struct VkPipelineBinaryDataKHR { + size_t dataSize; + void* pData; +} VkPipelineBinaryDataKHR; + +typedef struct VkPipelineBinaryKeysAndDataKHR { + uint32_t binaryCount; + const VkPipelineBinaryKeyKHR* pPipelineBinaryKeys; + const VkPipelineBinaryDataKHR* pPipelineBinaryData; +} VkPipelineBinaryKeysAndDataKHR; + +typedef struct VkPipelineCreateInfoKHR { + VkStructureType sType; + void* pNext; +} VkPipelineCreateInfoKHR; + +typedef struct VkPipelineBinaryCreateInfoKHR { + VkStructureType sType; + const void* pNext; + const VkPipelineBinaryKeysAndDataKHR* pKeysAndDataInfo; + VkPipeline pipeline; + const VkPipelineCreateInfoKHR* pPipelineCreateInfo; +} VkPipelineBinaryCreateInfoKHR; + +typedef struct VkPipelineBinaryInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t binaryCount; + const VkPipelineBinaryKHR* pPipelineBinaries; +} VkPipelineBinaryInfoKHR; + +typedef struct VkReleaseCapturedPipelineDataInfoKHR { + VkStructureType sType; + void* pNext; + VkPipeline pipeline; +} VkReleaseCapturedPipelineDataInfoKHR; + +typedef struct VkPipelineBinaryDataInfoKHR { + VkStructureType sType; + void* pNext; + VkPipelineBinaryKHR pipelineBinary; +} VkPipelineBinaryDataInfoKHR; + +typedef struct VkPipelineBinaryHandlesInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t pipelineBinaryCount; + VkPipelineBinaryKHR* pPipelineBinaries; +} VkPipelineBinaryHandlesInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineBinariesKHR)(VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries); +typedef void (VKAPI_PTR *PFN_vkDestroyPipelineBinaryKHR)(VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineKeyKHR)(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey); +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineBinaryDataKHR)(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData); +typedef VkResult (VKAPI_PTR *PFN_vkReleaseCapturedPipelineDataKHR)(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineBinariesKHR( + VkDevice device, + const VkPipelineBinaryCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineBinaryHandlesInfoKHR* pBinaries); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineBinaryKHR( + VkDevice device, + VkPipelineBinaryKHR pipelineBinary, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineKeyKHR( + VkDevice device, + const VkPipelineCreateInfoKHR* pPipelineCreateInfo, + VkPipelineBinaryKeyKHR* pPipelineKey); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineBinaryDataKHR( + VkDevice device, + const VkPipelineBinaryDataInfoKHR* pInfo, + VkPipelineBinaryKeyKHR* pPipelineBinaryKey, + size_t* pPipelineBinaryDataSize, + void* pPipelineBinaryData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseCapturedPipelineDataKHR( + VkDevice device, + const VkReleaseCapturedPipelineDataInfoKHR* pInfo, + const VkAllocationCallbacks* pAllocator); +#endif +#endif + + +// VK_KHR_surface_maintenance1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_surface_maintenance1 1 +#define VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_surface_maintenance1" + +typedef enum VkPresentScalingFlagBitsKHR { + VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR = 0x00000001, + VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR = 0x00000002, + VK_PRESENT_SCALING_STRETCH_BIT_KHR = 0x00000004, + VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR, + VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR, + VK_PRESENT_SCALING_STRETCH_BIT_EXT = VK_PRESENT_SCALING_STRETCH_BIT_KHR, + VK_PRESENT_SCALING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentScalingFlagBitsKHR; +typedef VkFlags VkPresentScalingFlagsKHR; + +typedef enum VkPresentGravityFlagBitsKHR { + VK_PRESENT_GRAVITY_MIN_BIT_KHR = 0x00000001, + VK_PRESENT_GRAVITY_MAX_BIT_KHR = 0x00000002, + VK_PRESENT_GRAVITY_CENTERED_BIT_KHR = 0x00000004, + VK_PRESENT_GRAVITY_MIN_BIT_EXT = VK_PRESENT_GRAVITY_MIN_BIT_KHR, + VK_PRESENT_GRAVITY_MAX_BIT_EXT = VK_PRESENT_GRAVITY_MAX_BIT_KHR, + VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR, + VK_PRESENT_GRAVITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentGravityFlagBitsKHR; +typedef VkFlags VkPresentGravityFlagsKHR; +typedef struct VkSurfacePresentModeKHR { + VkStructureType sType; + void* pNext; + VkPresentModeKHR presentMode; +} VkSurfacePresentModeKHR; + +typedef struct VkSurfacePresentScalingCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkPresentScalingFlagsKHR supportedPresentScaling; + VkPresentGravityFlagsKHR supportedPresentGravityX; + VkPresentGravityFlagsKHR supportedPresentGravityY; + VkExtent2D minScaledImageExtent; + VkExtent2D maxScaledImageExtent; +} VkSurfacePresentScalingCapabilitiesKHR; + +typedef struct VkSurfacePresentModeCompatibilityKHR { + VkStructureType sType; + void* pNext; + uint32_t presentModeCount; + VkPresentModeKHR* pPresentModes; +} VkSurfacePresentModeCompatibilityKHR; + + + +// VK_KHR_swapchain_maintenance1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_swapchain_maintenance1 1 +#define VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_swapchain_maintenance1" +typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 swapchainMaintenance1; +} VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR; + +typedef struct VkSwapchainPresentFenceInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkFence* pFences; +} VkSwapchainPresentFenceInfoKHR; + +typedef struct VkSwapchainPresentModesCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t presentModeCount; + const VkPresentModeKHR* pPresentModes; +} VkSwapchainPresentModesCreateInfoKHR; + +typedef struct VkSwapchainPresentModeInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentModeKHR* pPresentModes; +} VkSwapchainPresentModeInfoKHR; + +typedef struct VkSwapchainPresentScalingCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkPresentScalingFlagsKHR scalingBehavior; + VkPresentGravityFlagsKHR presentGravityX; + VkPresentGravityFlagsKHR presentGravityY; +} VkSwapchainPresentScalingCreateInfoKHR; + +typedef struct VkReleaseSwapchainImagesInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndexCount; + const uint32_t* pImageIndices; +} VkReleaseSwapchainImagesInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesKHR)(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesKHR( + VkDevice device, + const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); +#endif +#endif + + +// VK_KHR_internally_synchronized_queues is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_internally_synchronized_queues 1 +#define VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_SPEC_VERSION 1 +#define VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME "VK_KHR_internally_synchronized_queues" +typedef struct VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 internallySynchronizedQueues; +} VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; + + + +// VK_KHR_cooperative_matrix is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_cooperative_matrix 1 +#define VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION 2 +#define VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_KHR_cooperative_matrix" + +typedef enum VkComponentTypeKHR { + VK_COMPONENT_TYPE_FLOAT16_KHR = 0, + VK_COMPONENT_TYPE_FLOAT32_KHR = 1, + VK_COMPONENT_TYPE_FLOAT64_KHR = 2, + VK_COMPONENT_TYPE_SINT8_KHR = 3, + VK_COMPONENT_TYPE_SINT16_KHR = 4, + VK_COMPONENT_TYPE_SINT32_KHR = 5, + VK_COMPONENT_TYPE_SINT64_KHR = 6, + VK_COMPONENT_TYPE_UINT8_KHR = 7, + VK_COMPONENT_TYPE_UINT16_KHR = 8, + VK_COMPONENT_TYPE_UINT32_KHR = 9, + VK_COMPONENT_TYPE_UINT64_KHR = 10, + VK_COMPONENT_TYPE_BFLOAT16_KHR = 1000141000, + VK_COMPONENT_TYPE_SINT8_PACKED_NV = 1000491000, + VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001, + VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT = 1000491002, + VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT = 1000491003, + VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR, + VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR, + VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR, + VK_COMPONENT_TYPE_SINT8_NV = VK_COMPONENT_TYPE_SINT8_KHR, + VK_COMPONENT_TYPE_SINT16_NV = VK_COMPONENT_TYPE_SINT16_KHR, + VK_COMPONENT_TYPE_SINT32_NV = VK_COMPONENT_TYPE_SINT32_KHR, + VK_COMPONENT_TYPE_SINT64_NV = VK_COMPONENT_TYPE_SINT64_KHR, + VK_COMPONENT_TYPE_UINT8_NV = VK_COMPONENT_TYPE_UINT8_KHR, + VK_COMPONENT_TYPE_UINT16_NV = VK_COMPONENT_TYPE_UINT16_KHR, + VK_COMPONENT_TYPE_UINT32_NV = VK_COMPONENT_TYPE_UINT32_KHR, + VK_COMPONENT_TYPE_UINT64_NV = VK_COMPONENT_TYPE_UINT64_KHR, + VK_COMPONENT_TYPE_FLOAT_E4M3_NV = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT, + VK_COMPONENT_TYPE_FLOAT_E5M2_NV = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT, + VK_COMPONENT_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkComponentTypeKHR; + +typedef enum VkScopeKHR { + VK_SCOPE_DEVICE_KHR = 1, + VK_SCOPE_WORKGROUP_KHR = 2, + VK_SCOPE_SUBGROUP_KHR = 3, + VK_SCOPE_QUEUE_FAMILY_KHR = 5, + VK_SCOPE_DEVICE_NV = VK_SCOPE_DEVICE_KHR, + VK_SCOPE_WORKGROUP_NV = VK_SCOPE_WORKGROUP_KHR, + VK_SCOPE_SUBGROUP_NV = VK_SCOPE_SUBGROUP_KHR, + VK_SCOPE_QUEUE_FAMILY_NV = VK_SCOPE_QUEUE_FAMILY_KHR, + VK_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkScopeKHR; +typedef struct VkCooperativeMatrixPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeKHR AType; + VkComponentTypeKHR BType; + VkComponentTypeKHR CType; + VkComponentTypeKHR ResultType; + VkBool32 saturatingAccumulation; + VkScopeKHR scope; +} VkCooperativeMatrixPropertiesKHR; + +typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; +} VkPhysicalDeviceCooperativeMatrixFeaturesKHR; + +typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR { + VkStructureType sType; + void* pNext; + VkShaderStageFlags cooperativeMatrixSupportedStages; +} VkPhysicalDeviceCooperativeMatrixPropertiesKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesKHR* pProperties); +#endif +#endif + + +// VK_KHR_compute_shader_derivatives is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_compute_shader_derivatives 1 +#define VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 +#define VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_KHR_compute_shader_derivatives" +typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 computeDerivativeGroupQuads; + VkBool32 computeDerivativeGroupLinear; +} VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR; + +typedef struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 meshAndTaskShaderDerivatives; +} VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR; + + + +// VK_KHR_video_decode_av1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_decode_av1 1 +#include "vk_video/vulkan_video_codec_av1std.h" +#include "vk_video/vulkan_video_codec_av1std_decode.h" +#define VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR 7U +#define VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION 1 +#define VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME "VK_KHR_video_decode_av1" +typedef struct VkVideoDecodeAV1ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoAV1Profile stdProfile; + VkBool32 filmGrainSupport; +} VkVideoDecodeAV1ProfileInfoKHR; + +typedef struct VkVideoDecodeAV1CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoAV1Level maxLevel; +} VkVideoDecodeAV1CapabilitiesKHR; + +typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoAV1SequenceHeader* pStdSequenceHeader; +} VkVideoDecodeAV1SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeAV1PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeAV1PictureInfo* pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; + uint32_t frameHeaderOffset; + uint32_t tileCount; + const uint32_t* pTileOffsets; + const uint32_t* pTileSizes; +} VkVideoDecodeAV1PictureInfoKHR; + +typedef struct VkVideoDecodeAV1DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeAV1DpbSlotInfoKHR; + + + +// VK_KHR_video_encode_av1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_encode_av1 1 +#include "vk_video/vulkan_video_codec_av1std_encode.h" +#define VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION 1 +#define VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME "VK_KHR_video_encode_av1" + +typedef enum VkVideoEncodeAV1PredictionModeKHR { + VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR = 0, + VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR = 1, + VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR = 2, + VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR = 3, + VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeAV1PredictionModeKHR; + +typedef enum VkVideoEncodeAV1RateControlGroupKHR { + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR = 0, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR = 1, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR = 2, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeAV1RateControlGroupKHR; + +typedef enum VkVideoEncodeAV1CapabilityFlagBitsKHR { + VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR = 0x00000010, + VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR = 0x00000020, + VK_VIDEO_ENCODE_AV1_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeAV1CapabilityFlagBitsKHR; +typedef VkFlags VkVideoEncodeAV1CapabilityFlagsKHR; + +typedef enum VkVideoEncodeAV1StdFlagBitsKHR { + VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_AV1_STD_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeAV1StdFlagBitsKHR; +typedef VkFlags VkVideoEncodeAV1StdFlagsKHR; + +typedef enum VkVideoEncodeAV1SuperblockSizeFlagBitsKHR { + VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeAV1SuperblockSizeFlagBitsKHR; +typedef VkFlags VkVideoEncodeAV1SuperblockSizeFlagsKHR; + +typedef enum VkVideoEncodeAV1RateControlFlagBitsKHR { + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_AV1_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeAV1RateControlFlagBitsKHR; +typedef VkFlags VkVideoEncodeAV1RateControlFlagsKHR; +typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 videoEncodeAV1; +} VkPhysicalDeviceVideoEncodeAV1FeaturesKHR; + +typedef struct VkVideoEncodeAV1CapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeAV1CapabilityFlagsKHR flags; + StdVideoAV1Level maxLevel; + VkExtent2D codedPictureAlignment; + VkExtent2D maxTiles; + VkExtent2D minTileSize; + VkExtent2D maxTileSize; + VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes; + uint32_t maxSingleReferenceCount; + uint32_t singleReferenceNameMask; + uint32_t maxUnidirectionalCompoundReferenceCount; + uint32_t maxUnidirectionalCompoundGroup1ReferenceCount; + uint32_t unidirectionalCompoundReferenceNameMask; + uint32_t maxBidirectionalCompoundReferenceCount; + uint32_t maxBidirectionalCompoundGroup1ReferenceCount; + uint32_t maxBidirectionalCompoundGroup2ReferenceCount; + uint32_t bidirectionalCompoundReferenceNameMask; + uint32_t maxTemporalLayerCount; + uint32_t maxSpatialLayerCount; + uint32_t maxOperatingPoints; + uint32_t minQIndex; + uint32_t maxQIndex; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags; +} VkVideoEncodeAV1CapabilitiesKHR; + +typedef struct VkVideoEncodeAV1QIndexKHR { + uint32_t intraQIndex; + uint32_t predictiveQIndex; + uint32_t bipredictiveQIndex; +} VkVideoEncodeAV1QIndexKHR; + +typedef struct VkVideoEncodeAV1QualityLevelPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredKeyFramePeriod; + uint32_t preferredConsecutiveBipredictiveFrameCount; + uint32_t preferredTemporalLayerCount; + VkVideoEncodeAV1QIndexKHR preferredConstantQIndex; + uint32_t preferredMaxSingleReferenceCount; + uint32_t preferredSingleReferenceNameMask; + uint32_t preferredMaxUnidirectionalCompoundReferenceCount; + uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount; + uint32_t preferredUnidirectionalCompoundReferenceNameMask; + uint32_t preferredMaxBidirectionalCompoundReferenceCount; + uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount; + uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount; + uint32_t preferredBidirectionalCompoundReferenceNameMask; +} VkVideoEncodeAV1QualityLevelPropertiesKHR; + +typedef struct VkVideoEncodeAV1SessionCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useMaxLevel; + StdVideoAV1Level maxLevel; +} VkVideoEncodeAV1SessionCreateInfoKHR; + +typedef struct VkVideoEncodeAV1SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoAV1SequenceHeader* pStdSequenceHeader; + const StdVideoEncodeAV1DecoderModelInfo* pStdDecoderModelInfo; + uint32_t stdOperatingPointCount; + const StdVideoEncodeAV1OperatingPointInfo* pStdOperatingPoints; +} VkVideoEncodeAV1SessionParametersCreateInfoKHR; + +typedef struct VkVideoEncodeAV1PictureInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeAV1PredictionModeKHR predictionMode; + VkVideoEncodeAV1RateControlGroupKHR rateControlGroup; + uint32_t constantQIndex; + const StdVideoEncodeAV1PictureInfo* pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; + VkBool32 primaryReferenceCdfOnly; + VkBool32 generateObuExtensionHeader; +} VkVideoEncodeAV1PictureInfoKHR; + +typedef struct VkVideoEncodeAV1DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoEncodeAV1ReferenceInfo* pStdReferenceInfo; +} VkVideoEncodeAV1DpbSlotInfoKHR; + +typedef struct VkVideoEncodeAV1ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoAV1Profile stdProfile; +} VkVideoEncodeAV1ProfileInfoKHR; + +typedef struct VkVideoEncodeAV1FrameSizeKHR { + uint32_t intraFrameSize; + uint32_t predictiveFrameSize; + uint32_t bipredictiveFrameSize; +} VkVideoEncodeAV1FrameSizeKHR; + +typedef struct VkVideoEncodeAV1GopRemainingFrameInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingIntra; + uint32_t gopRemainingPredictive; + uint32_t gopRemainingBipredictive; +} VkVideoEncodeAV1GopRemainingFrameInfoKHR; + +typedef struct VkVideoEncodeAV1RateControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeAV1RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t keyFramePeriod; + uint32_t consecutiveBipredictiveFrameCount; + uint32_t temporalLayerCount; +} VkVideoEncodeAV1RateControlInfoKHR; + +typedef struct VkVideoEncodeAV1RateControlLayerInfoKHR { + VkStructureType sType; + const void* pNext; + VkBool32 useMinQIndex; + VkVideoEncodeAV1QIndexKHR minQIndex; + VkBool32 useMaxQIndex; + VkVideoEncodeAV1QIndexKHR maxQIndex; + VkBool32 useMaxFrameSize; + VkVideoEncodeAV1FrameSizeKHR maxFrameSize; +} VkVideoEncodeAV1RateControlLayerInfoKHR; + + + +// VK_KHR_video_decode_vp9 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_decode_vp9 1 +#include "vk_video/vulkan_video_codec_vp9std.h" +#include "vk_video/vulkan_video_codec_vp9std_decode.h" +#define VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR 3U +#define VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION 1 +#define VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME "VK_KHR_video_decode_vp9" +typedef struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 videoDecodeVP9; +} VkPhysicalDeviceVideoDecodeVP9FeaturesKHR; + +typedef struct VkVideoDecodeVP9ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoVP9Profile stdProfile; +} VkVideoDecodeVP9ProfileInfoKHR; + +typedef struct VkVideoDecodeVP9CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoVP9Level maxLevel; +} VkVideoDecodeVP9CapabilitiesKHR; + +typedef struct VkVideoDecodeVP9PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeVP9PictureInfo* pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR]; + uint32_t uncompressedHeaderOffset; + uint32_t compressedHeaderOffset; + uint32_t tilesOffset; +} VkVideoDecodeVP9PictureInfoKHR; + + + +// VK_KHR_video_maintenance1 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_maintenance1 1 +#define VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_video_maintenance1" +typedef struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 videoMaintenance1; +} VkPhysicalDeviceVideoMaintenance1FeaturesKHR; + +typedef struct VkVideoInlineQueryInfoKHR { + VkStructureType sType; + const void* pNext; + VkQueryPool queryPool; + uint32_t firstQuery; + uint32_t queryCount; +} VkVideoInlineQueryInfoKHR; + + + +// VK_KHR_vertex_attribute_divisor is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_vertex_attribute_divisor 1 +#define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 1 +#define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_KHR_vertex_attribute_divisor" +typedef VkPhysicalDeviceVertexAttributeDivisorProperties VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR; + +typedef VkVertexInputBindingDivisorDescription VkVertexInputBindingDivisorDescriptionKHR; + +typedef VkPipelineVertexInputDivisorStateCreateInfo VkPipelineVertexInputDivisorStateCreateInfoKHR; + +typedef VkPhysicalDeviceVertexAttributeDivisorFeatures VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR; + + + +// VK_KHR_load_store_op_none is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_load_store_op_none 1 +#define VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION 1 +#define VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_KHR_load_store_op_none" + + +// VK_KHR_unified_image_layouts is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_unified_image_layouts 1 +#define VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION 1 +#define VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME "VK_KHR_unified_image_layouts" +typedef struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 unifiedImageLayouts; + VkBool32 unifiedImageLayoutsVideo; +} VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR; + +typedef struct VkAttachmentFeedbackLoopInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 feedbackLoopEnable; +} VkAttachmentFeedbackLoopInfoEXT; + + + +// VK_KHR_shader_float_controls2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_float_controls2 1 +#define VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION 1 +#define VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME "VK_KHR_shader_float_controls2" +typedef VkPhysicalDeviceShaderFloatControls2Features VkPhysicalDeviceShaderFloatControls2FeaturesKHR; + + + +// VK_KHR_index_type_uint8 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_index_type_uint8 1 +#define VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION 1 +#define VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_KHR_index_type_uint8" +typedef VkPhysicalDeviceIndexTypeUint8Features VkPhysicalDeviceIndexTypeUint8FeaturesKHR; + + + +// VK_KHR_line_rasterization is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_line_rasterization 1 +#define VK_KHR_LINE_RASTERIZATION_SPEC_VERSION 1 +#define VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME "VK_KHR_line_rasterization" +typedef VkLineRasterizationMode VkLineRasterizationModeKHR; + +typedef VkPhysicalDeviceLineRasterizationFeatures VkPhysicalDeviceLineRasterizationFeaturesKHR; + +typedef VkPhysicalDeviceLineRasterizationProperties VkPhysicalDeviceLineRasterizationPropertiesKHR; + +typedef VkPipelineRasterizationLineStateCreateInfo VkPipelineRasterizationLineStateCreateInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleKHR)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleKHR( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern); +#endif +#endif + + +// VK_KHR_calibrated_timestamps is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_calibrated_timestamps 1 +#define VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1 +#define VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_KHR_calibrated_timestamps" + +typedef enum VkTimeDomainKHR { + VK_TIME_DOMAIN_DEVICE_KHR = 0, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR = 1, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR = 2, + VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR = 3, + VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT = 1000208000, + VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT = 1000208001, + VK_TIME_DOMAIN_DEVICE_EXT = VK_TIME_DOMAIN_DEVICE_KHR, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR, + VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR, + VK_TIME_DOMAIN_MAX_ENUM_KHR = 0x7FFFFFFF +} VkTimeDomainKHR; +typedef struct VkCalibratedTimestampInfoKHR { + VkStructureType sType; + const void* pNext; + VkTimeDomainKHR timeDomain; +} VkCalibratedTimestampInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains); +typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsKHR)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation); +#endif +#endif + + +// VK_KHR_shader_expect_assume is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_expect_assume 1 +#define VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION 1 +#define VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME "VK_KHR_shader_expect_assume" +typedef VkPhysicalDeviceShaderExpectAssumeFeatures VkPhysicalDeviceShaderExpectAssumeFeaturesKHR; + + + +// VK_KHR_maintenance6 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance6 1 +#define VK_KHR_MAINTENANCE_6_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_6_EXTENSION_NAME "VK_KHR_maintenance6" +typedef VkPhysicalDeviceMaintenance6Features VkPhysicalDeviceMaintenance6FeaturesKHR; + +typedef VkPhysicalDeviceMaintenance6Properties VkPhysicalDeviceMaintenance6PropertiesKHR; + +typedef VkBindMemoryStatus VkBindMemoryStatusKHR; + +typedef VkBindDescriptorSetsInfo VkBindDescriptorSetsInfoKHR; + +typedef VkPushConstantsInfo VkPushConstantsInfoKHR; + +typedef VkPushDescriptorSetInfo VkPushDescriptorSetInfoKHR; + +typedef VkPushDescriptorSetWithTemplateInfo VkPushDescriptorSetWithTemplateInfoKHR; + +typedef struct VkSetDescriptorBufferOffsetsInfoEXT { + VkStructureType sType; + const void* pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t firstSet; + uint32_t setCount; + const uint32_t* pBufferIndices; + const VkDeviceSize* pOffsets; +} VkSetDescriptorBufferOffsetsInfoEXT; + +typedef struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT { + VkStructureType sType; + const void* pNext; + VkShaderStageFlags stageFlags; + VkPipelineLayout layout; + uint32_t set; +} VkBindDescriptorBufferEmbeddedSamplersInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets2KHR)(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdPushConstants2KHR)(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSet2KHR)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); +typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplate2KHR)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); +typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsets2EXT)(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2KHR( + VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2KHR( + VkCommandBuffer commandBuffer, + const VkPushConstantsInfo* pPushConstantsInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); +#endif +#endif + + +// VK_KHR_copy_memory_indirect is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_copy_memory_indirect 1 +#define VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION 1 +#define VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_KHR_copy_memory_indirect" + +typedef enum VkAddressCopyFlagBitsKHR { + VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR = 0x00000001, + VK_ADDRESS_COPY_SPARSE_BIT_KHR = 0x00000002, + VK_ADDRESS_COPY_PROTECTED_BIT_KHR = 0x00000004, + VK_ADDRESS_COPY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAddressCopyFlagBitsKHR; +typedef VkFlags VkAddressCopyFlagsKHR; +typedef struct VkStridedDeviceAddressRangeKHR { + VkDeviceAddress address; + VkDeviceSize size; + VkDeviceSize stride; +} VkStridedDeviceAddressRangeKHR; + +typedef struct VkCopyMemoryIndirectCommandKHR { + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize size; +} VkCopyMemoryIndirectCommandKHR; + +typedef struct VkCopyMemoryIndirectInfoKHR { + VkStructureType sType; + const void* pNext; + VkAddressCopyFlagsKHR srcCopyFlags; + VkAddressCopyFlagsKHR dstCopyFlags; + uint32_t copyCount; + VkStridedDeviceAddressRangeKHR copyAddressRange; +} VkCopyMemoryIndirectInfoKHR; + +typedef struct VkCopyMemoryToImageIndirectCommandKHR { + VkDeviceAddress srcAddress; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkCopyMemoryToImageIndirectCommandKHR; + +typedef struct VkCopyMemoryToImageIndirectInfoKHR { + VkStructureType sType; + const void* pNext; + VkAddressCopyFlagsKHR srcCopyFlags; + uint32_t copyCount; + VkStridedDeviceAddressRangeKHR copyAddressRange; + VkImage dstImage; + VkImageLayout dstImageLayout; + const VkImageSubresourceLayers* pImageSubresources; +} VkCopyMemoryToImageIndirectInfoKHR; + +typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 indirectMemoryCopy; + VkBool32 indirectMemoryToImageCopy; +} VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR; + +typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR { + VkStructureType sType; + void* pNext; + VkQueueFlags supportedQueues; +} VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectKHR( + VkCommandBuffer commandBuffer, + const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectKHR( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo); +#endif +#endif + + +// VK_KHR_video_encode_intra_refresh is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_encode_intra_refresh 1 +#define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION 1 +#define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME "VK_KHR_video_encode_intra_refresh" + +typedef enum VkVideoEncodeIntraRefreshModeFlagBitsKHR { + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR = 0, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR = 0x00000001, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR = 0x00000002, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR = 0x00000004, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR = 0x00000008, + VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoEncodeIntraRefreshModeFlagBitsKHR; +typedef VkFlags VkVideoEncodeIntraRefreshModeFlagsKHR; +typedef struct VkVideoEncodeIntraRefreshCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes; + uint32_t maxIntraRefreshCycleDuration; + uint32_t maxIntraRefreshActiveReferencePictures; + VkBool32 partitionIndependentIntraRefreshRegions; + VkBool32 nonRectangularIntraRefreshRegions; +} VkVideoEncodeIntraRefreshCapabilitiesKHR; + +typedef struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode; +} VkVideoEncodeSessionIntraRefreshCreateInfoKHR; + +typedef struct VkVideoEncodeIntraRefreshInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t intraRefreshCycleDuration; + uint32_t intraRefreshIndex; +} VkVideoEncodeIntraRefreshInfoKHR; + +typedef struct VkVideoReferenceIntraRefreshInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t dirtyIntraRefreshRegions; +} VkVideoReferenceIntraRefreshInfoKHR; + +typedef struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 videoEncodeIntraRefresh; +} VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; + + + +// VK_KHR_video_encode_quantization_map is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_encode_quantization_map 1 +#define VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION 2 +#define VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME "VK_KHR_video_encode_quantization_map" +typedef struct VkVideoEncodeQuantizationMapCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkExtent2D maxQuantizationMapExtent; +} VkVideoEncodeQuantizationMapCapabilitiesKHR; + +typedef struct VkVideoFormatQuantizationMapPropertiesKHR { + VkStructureType sType; + void* pNext; + VkExtent2D quantizationMapTexelSize; +} VkVideoFormatQuantizationMapPropertiesKHR; + +typedef struct VkVideoEncodeQuantizationMapInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageView quantizationMap; + VkExtent2D quantizationMapExtent; +} VkVideoEncodeQuantizationMapInfoKHR; + +typedef struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExtent2D quantizationMapTexelSize; +} VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR; + +typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 videoEncodeQuantizationMap; +} VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; + +typedef struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR { + VkStructureType sType; + void* pNext; + int32_t minQpDelta; + int32_t maxQpDelta; +} VkVideoEncodeH264QuantizationMapCapabilitiesKHR; + +typedef struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR { + VkStructureType sType; + void* pNext; + int32_t minQpDelta; + int32_t maxQpDelta; +} VkVideoEncodeH265QuantizationMapCapabilitiesKHR; + +typedef struct VkVideoFormatH265QuantizationMapPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes; +} VkVideoFormatH265QuantizationMapPropertiesKHR; + +typedef struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR { + VkStructureType sType; + void* pNext; + int32_t minQIndexDelta; + int32_t maxQIndexDelta; +} VkVideoEncodeAV1QuantizationMapCapabilitiesKHR; + +typedef struct VkVideoFormatAV1QuantizationMapPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes; +} VkVideoFormatAV1QuantizationMapPropertiesKHR; + + + +// VK_KHR_shader_relaxed_extended_instruction is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_relaxed_extended_instruction 1 +#define VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION 1 +#define VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME "VK_KHR_shader_relaxed_extended_instruction" +typedef struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderRelaxedExtendedInstruction; +} VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; + + + +// VK_KHR_maintenance7 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance7 1 +#define VK_KHR_MAINTENANCE_7_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_7_EXTENSION_NAME "VK_KHR_maintenance7" + +typedef enum VkPhysicalDeviceLayeredApiKHR { + VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR = 0, + VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR = 1, + VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR = 2, + VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR = 3, + VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR = 4, + VK_PHYSICAL_DEVICE_LAYERED_API_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPhysicalDeviceLayeredApiKHR; +typedef struct VkPhysicalDeviceMaintenance7FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 maintenance7; +} VkPhysicalDeviceMaintenance7FeaturesKHR; + +typedef struct VkPhysicalDeviceMaintenance7PropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 robustFragmentShadingRateAttachmentAccess; + VkBool32 separateDepthStencilAttachmentAccess; + uint32_t maxDescriptorSetTotalUniformBuffersDynamic; + uint32_t maxDescriptorSetTotalStorageBuffersDynamic; + uint32_t maxDescriptorSetTotalBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindTotalBuffersDynamic; +} VkPhysicalDeviceMaintenance7PropertiesKHR; + +typedef struct VkPhysicalDeviceLayeredApiPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceLayeredApiKHR layeredAPI; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; +} VkPhysicalDeviceLayeredApiPropertiesKHR; + +typedef struct VkPhysicalDeviceLayeredApiPropertiesListKHR { + VkStructureType sType; + void* pNext; + uint32_t layeredApiCount; + VkPhysicalDeviceLayeredApiPropertiesKHR* pLayeredApis; +} VkPhysicalDeviceLayeredApiPropertiesListKHR; + +typedef struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceProperties2 properties; +} VkPhysicalDeviceLayeredApiVulkanPropertiesKHR; + + + +// VK_KHR_maintenance8 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance8 1 +#define VK_KHR_MAINTENANCE_8_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_8_EXTENSION_NAME "VK_KHR_maintenance8" +typedef VkFlags64 VkAccessFlags3KHR; + +// Flag bits for VkAccessFlagBits3KHR +typedef VkFlags64 VkAccessFlagBits3KHR; +static const VkAccessFlagBits3KHR VK_ACCESS_3_NONE_KHR = 0ULL; + +typedef struct VkMemoryBarrierAccessFlags3KHR { + VkStructureType sType; + const void* pNext; + VkAccessFlags3KHR srcAccessMask3; + VkAccessFlags3KHR dstAccessMask3; +} VkMemoryBarrierAccessFlags3KHR; + +typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 maintenance8; +} VkPhysicalDeviceMaintenance8FeaturesKHR; + + + +// VK_KHR_shader_fma is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_shader_fma 1 +#define VK_KHR_SHADER_FMA_SPEC_VERSION 1 +#define VK_KHR_SHADER_FMA_EXTENSION_NAME "VK_KHR_shader_fma" +typedef struct VkPhysicalDeviceShaderFmaFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderFmaFloat16; + VkBool32 shaderFmaFloat32; + VkBool32 shaderFmaFloat64; +} VkPhysicalDeviceShaderFmaFeaturesKHR; + + + +// VK_KHR_maintenance9 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance9 1 +#define VK_KHR_MAINTENANCE_9_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_9_EXTENSION_NAME "VK_KHR_maintenance9" + +typedef enum VkDefaultVertexAttributeValueKHR { + VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR = 0, + VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR = 1, + VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDefaultVertexAttributeValueKHR; +typedef struct VkPhysicalDeviceMaintenance9FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 maintenance9; +} VkPhysicalDeviceMaintenance9FeaturesKHR; + +typedef struct VkPhysicalDeviceMaintenance9PropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 image2DViewOf3DSparse; + VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue; +} VkPhysicalDeviceMaintenance9PropertiesKHR; + +typedef struct VkQueueFamilyOwnershipTransferPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t optimalImageTransferToQueueFamilies; +} VkQueueFamilyOwnershipTransferPropertiesKHR; + + + +// VK_KHR_video_maintenance2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_video_maintenance2 1 +#define VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION 1 +#define VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_video_maintenance2" +typedef struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 videoMaintenance2; +} VkPhysicalDeviceVideoMaintenance2FeaturesKHR; + +typedef struct VkVideoDecodeH264InlineSessionParametersInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoH264SequenceParameterSet* pStdSPS; + const StdVideoH264PictureParameterSet* pStdPPS; +} VkVideoDecodeH264InlineSessionParametersInfoKHR; + +typedef struct VkVideoDecodeH265InlineSessionParametersInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoH265VideoParameterSet* pStdVPS; + const StdVideoH265SequenceParameterSet* pStdSPS; + const StdVideoH265PictureParameterSet* pStdPPS; +} VkVideoDecodeH265InlineSessionParametersInfoKHR; + +typedef struct VkVideoDecodeAV1InlineSessionParametersInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoAV1SequenceHeader* pStdSequenceHeader; +} VkVideoDecodeAV1InlineSessionParametersInfoKHR; + + + +// VK_KHR_depth_clamp_zero_one is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_depth_clamp_zero_one 1 +#define VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1 +#define VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_KHR_depth_clamp_zero_one" +typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 depthClampZeroOne; +} VkPhysicalDeviceDepthClampZeroOneFeaturesKHR; + + + +// VK_KHR_robustness2 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_robustness2 1 +#define VK_KHR_ROBUSTNESS_2_SPEC_VERSION 1 +#define VK_KHR_ROBUSTNESS_2_EXTENSION_NAME "VK_KHR_robustness2" +typedef struct VkPhysicalDeviceRobustness2FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 robustBufferAccess2; + VkBool32 robustImageAccess2; + VkBool32 nullDescriptor; +} VkPhysicalDeviceRobustness2FeaturesKHR; + +typedef struct VkPhysicalDeviceRobustness2PropertiesKHR { + VkStructureType sType; + void* pNext; + VkDeviceSize robustStorageBufferAccessSizeAlignment; + VkDeviceSize robustUniformBufferAccessSizeAlignment; +} VkPhysicalDeviceRobustness2PropertiesKHR; + + + +// VK_KHR_present_mode_fifo_latest_ready is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_present_mode_fifo_latest_ready 1 +#define VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION 1 +#define VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME "VK_KHR_present_mode_fifo_latest_ready" +typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 presentModeFifoLatestReady; +} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + + + +// VK_KHR_maintenance10 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_maintenance10 1 +#define VK_KHR_MAINTENANCE_10_SPEC_VERSION 1 +#define VK_KHR_MAINTENANCE_10_EXTENSION_NAME "VK_KHR_maintenance10" + +typedef enum VkRenderingAttachmentFlagBitsKHR { + VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR = 0x00000001, + VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 0x00000002, + VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 0x00000004, + VK_RENDERING_ATTACHMENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkRenderingAttachmentFlagBitsKHR; +typedef VkFlags VkRenderingAttachmentFlagsKHR; + +typedef enum VkResolveImageFlagBitsKHR { + VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 0x00000001, + VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 0x00000002, + VK_RESOLVE_IMAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkResolveImageFlagBitsKHR; +typedef VkFlags VkResolveImageFlagsKHR; +typedef struct VkPhysicalDeviceMaintenance10FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 maintenance10; +} VkPhysicalDeviceMaintenance10FeaturesKHR; + +typedef struct VkPhysicalDeviceMaintenance10PropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rgba4OpaqueBlackSwizzled; + VkBool32 resolveSrgbFormatAppliesTransferFunction; + VkBool32 resolveSrgbFormatSupportsTransferFunctionControl; +} VkPhysicalDeviceMaintenance10PropertiesKHR; + +typedef struct VkRenderingEndInfoKHR { + VkStructureType sType; + const void* pNext; +} VkRenderingEndInfoKHR; + +typedef struct VkRenderingAttachmentFlagsInfoKHR { + VkStructureType sType; + const void* pNext; + VkRenderingAttachmentFlagsKHR flags; +} VkRenderingAttachmentFlagsInfoKHR; + +typedef struct VkResolveImageModeInfoKHR { + VkStructureType sType; + const void* pNext; + VkResolveImageFlagsKHR flags; + VkResolveModeFlagBits resolveMode; + VkResolveModeFlagBits stencilResolveMode; +} VkResolveImageModeInfoKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdEndRendering2KHR)(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2KHR( + VkCommandBuffer commandBuffer, + const VkRenderingEndInfoKHR* pRenderingEndInfo); +#endif +#endif + + +// VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_debug_report 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) +#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 10 +#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" + +typedef enum VkDebugReportObjectTypeEXT { + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, + VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, + VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, + VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, + VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, + VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, + VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, + VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, + VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, + VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, + VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, + VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, + VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, + VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000, + VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001, + VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000, + VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000, + VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT = 1000307000, + VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT = 1000307001, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1000366000, + // VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT is a legacy alias + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, + // VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT is a legacy alias + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportObjectTypeEXT; + +typedef enum VkDebugReportFlagBitsEXT { + VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, + VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, + VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, + VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, + VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportFlagBitsEXT; +typedef VkFlags VkDebugReportFlagsEXT; +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + +typedef struct VkDebugReportCallbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData; +} VkDebugReportCallbackCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( + VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( + VkInstance instance, + VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( + VkInstance instance, + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage); +#endif +#endif + + +// VK_NV_glsl_shader is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_glsl_shader 1 +#define VK_NV_GLSL_SHADER_SPEC_VERSION 1 +#define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader" + + +// VK_EXT_depth_range_unrestricted is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_depth_range_unrestricted 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 +#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" + + +// VK_IMG_filter_cubic is a preprocessor guard. Do not pass it to API calls. +#define VK_IMG_filter_cubic 1 +#define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 +#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" + + +// VK_AMD_rasterization_order is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_rasterization_order 1 +#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 +#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order" + +typedef enum VkRasterizationOrderAMD { + VK_RASTERIZATION_ORDER_STRICT_AMD = 0, + VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, + VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF +} VkRasterizationOrderAMD; +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { + VkStructureType sType; + const void* pNext; + VkRasterizationOrderAMD rasterizationOrder; +} VkPipelineRasterizationStateRasterizationOrderAMD; + + + +// VK_AMD_shader_trinary_minmax is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_shader_trinary_minmax 1 +#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 +#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" + + +// VK_AMD_shader_explicit_vertex_parameter is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_shader_explicit_vertex_parameter 1 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 +#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" + + +// VK_EXT_debug_marker is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_debug_marker 1 +#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 +#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" +typedef struct VkDebugMarkerObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName; +} VkDebugMarkerObjectNameInfoEXT; + +typedef struct VkDebugMarkerObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugMarkerObjectTagInfoEXT; + +typedef struct VkDebugMarkerMarkerInfoEXT { + VkStructureType sType; + const void* pNext; + const char* pMarkerName; + float color[4]; +} VkDebugMarkerMarkerInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( + VkDevice device, + const VkDebugMarkerObjectTagInfoEXT* pTagInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( + VkDevice device, + const VkDebugMarkerObjectNameInfoEXT* pNameInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( + VkCommandBuffer commandBuffer); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +#endif +#endif + + +// VK_AMD_gcn_shader is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_gcn_shader 1 +#define VK_AMD_GCN_SHADER_SPEC_VERSION 1 +#define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" + + +// VK_NV_dedicated_allocation is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_dedicated_allocation 1 +#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 +#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" +typedef struct VkDedicatedAllocationImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationImageCreateInfoNV; + +typedef struct VkDedicatedAllocationBufferCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationBufferCreateInfoNV; + +typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkDedicatedAllocationMemoryAllocateInfoNV; + + + +// VK_EXT_transform_feedback is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_transform_feedback 1 +#define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1 +#define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback" +typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT; +typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 transformFeedback; + VkBool32 geometryStreams; +} VkPhysicalDeviceTransformFeedbackFeaturesEXT; + +typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxTransformFeedbackStreams; + uint32_t maxTransformFeedbackBuffers; + VkDeviceSize maxTransformFeedbackBufferSize; + uint32_t maxTransformFeedbackStreamDataSize; + uint32_t maxTransformFeedbackBufferDataSize; + uint32_t maxTransformFeedbackBufferDataStride; + VkBool32 transformFeedbackQueries; + VkBool32 transformFeedbackStreamsLinesTriangles; + VkBool32 transformFeedbackRasterizationStreamSelect; + VkBool32 transformFeedbackDraw; +} VkPhysicalDeviceTransformFeedbackPropertiesEXT; + +typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateStreamCreateFlagsEXT flags; + uint32_t rasterizationStream; +} VkPipelineRasterizationStateStreamCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); +typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); +typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags, + uint32_t index); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + uint32_t index); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT( + VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + VkBuffer counterBuffer, + VkDeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride); +#endif +#endif + + +// VK_NVX_binary_import is a preprocessor guard. Do not pass it to API calls. +#define VK_NVX_binary_import 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX) +#define VK_NVX_BINARY_IMPORT_SPEC_VERSION 2 +#define VK_NVX_BINARY_IMPORT_EXTENSION_NAME "VK_NVX_binary_import" +typedef struct VkCuModuleCreateInfoNVX { + VkStructureType sType; + const void* pNext; + size_t dataSize; + const void* pData; +} VkCuModuleCreateInfoNVX; + +typedef struct VkCuModuleTexturingModeCreateInfoNVX { + VkStructureType sType; + const void* pNext; + VkBool32 use64bitTexturing; +} VkCuModuleTexturingModeCreateInfoNVX; + +typedef struct VkCuFunctionCreateInfoNVX { + VkStructureType sType; + const void* pNext; + VkCuModuleNVX module; + const char* pName; +} VkCuFunctionCreateInfoNVX; + +typedef struct VkCuLaunchInfoNVX { + VkStructureType sType; + const void* pNext; + VkCuFunctionNVX function; + uint32_t gridDimX; + uint32_t gridDimY; + uint32_t gridDimZ; + uint32_t blockDimX; + uint32_t blockDimY; + uint32_t blockDimZ; + uint32_t sharedMemBytes; + size_t paramCount; + const void* const * pParams; + size_t extraCount; + const void* const * pExtras; +} VkCuLaunchInfoNVX; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule); +typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction); +typedef void (VKAPI_PTR *PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX( + VkDevice device, + const VkCuModuleCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuModuleNVX* pModule); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX( + VkDevice device, + const VkCuFunctionCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuFunctionNVX* pFunction); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX( + VkDevice device, + VkCuModuleNVX module, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX( + VkDevice device, + VkCuFunctionNVX function, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX( + VkCommandBuffer commandBuffer, + const VkCuLaunchInfoNVX* pLaunchInfo); +#endif +#endif + + +// VK_NVX_image_view_handle is a preprocessor guard. Do not pass it to API calls. +#define VK_NVX_image_view_handle 1 +#define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 4 +#define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle" +typedef struct VkImageViewHandleInfoNVX { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkDescriptorType descriptorType; + VkSampler sampler; +} VkImageViewHandleInfoNVX; + +typedef struct VkImageViewAddressPropertiesNVX { + VkStructureType sType; + void* pNext; + VkDeviceAddress deviceAddress; + VkDeviceSize size; +} VkImageViewAddressPropertiesNVX; + +typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo); +typedef uint64_t (VKAPI_PTR *PFN_vkGetImageViewHandle64NVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties); +typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceCombinedImageSamplerIndexNVX)(VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX( + VkDevice device, + const VkImageViewHandleInfoNVX* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR uint64_t VKAPI_CALL vkGetImageViewHandle64NVX( + VkDevice device, + const VkImageViewHandleInfoNVX* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX( + VkDevice device, + VkImageView imageView, + VkImageViewAddressPropertiesNVX* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceCombinedImageSamplerIndexNVX( + VkDevice device, + uint64_t imageViewIndex, + uint64_t samplerIndex); +#endif +#endif + + +// VK_AMD_draw_indirect_count is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_draw_indirect_count 1 +#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2 +#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif +#endif + + +// VK_AMD_negative_viewport_height is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_negative_viewport_height 1 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 +#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" + + +// VK_AMD_gpu_shader_half_float is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_gpu_shader_half_float 1 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2 +#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" + + +// VK_AMD_shader_ballot is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_shader_ballot 1 +#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 +#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" + + +// VK_AMD_texture_gather_bias_lod is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_texture_gather_bias_lod 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 +#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" +typedef struct VkTextureLODGatherFormatPropertiesAMD { + VkStructureType sType; + void* pNext; + VkBool32 supportsTextureGatherLODBiasAMD; +} VkTextureLODGatherFormatPropertiesAMD; + + + +// VK_AMD_shader_info is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_shader_info 1 +#define VK_AMD_SHADER_INFO_SPEC_VERSION 1 +#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" + +typedef enum VkShaderInfoTypeAMD { + VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, + VK_SHADER_INFO_TYPE_BINARY_AMD = 1, + VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, + VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkShaderInfoTypeAMD; +typedef struct VkShaderResourceUsageAMD { + uint32_t numUsedVgprs; + uint32_t numUsedSgprs; + uint32_t ldsSizePerLocalWorkGroup; + size_t ldsUsageSizeInBytes; + size_t scratchMemUsageInBytes; +} VkShaderResourceUsageAMD; + +typedef struct VkShaderStatisticsInfoAMD { + VkShaderStageFlags shaderStageMask; + VkShaderResourceUsageAMD resourceUsage; + uint32_t numPhysicalVgprs; + uint32_t numPhysicalSgprs; + uint32_t numAvailableVgprs; + uint32_t numAvailableSgprs; + uint32_t computeWorkGroupSize[3]; +} VkShaderStatisticsInfoAMD; + +typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( + VkDevice device, + VkPipeline pipeline, + VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, + size_t* pInfoSize, + void* pInfo); +#endif +#endif + + +// VK_AMD_shader_image_load_store_lod is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_shader_image_load_store_lod 1 +#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 +#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" + + +// VK_NV_corner_sampled_image is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_corner_sampled_image 1 +#define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2 +#define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image" +typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cornerSampledImage; +} VkPhysicalDeviceCornerSampledImageFeaturesNV; + + + +// VK_IMG_format_pvrtc is a preprocessor guard. Do not pass it to API calls. +#define VK_IMG_format_pvrtc 1 +#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 +#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" + + +// VK_NV_external_memory_capabilities is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_external_memory_capabilities 1 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" + +typedef enum VkExternalMemoryHandleTypeFlagBitsNV { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBitsNV; +typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; + +typedef enum VkExternalMemoryFeatureFlagBitsNV { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBitsNV; +typedef VkFlags VkExternalMemoryFeatureFlagsNV; +typedef struct VkExternalImageFormatPropertiesNV { + VkImageFormatProperties imageFormatProperties; + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; +} VkExternalImageFormatPropertiesNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); +#endif +#endif + + +// VK_NV_external_memory is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_external_memory 1 +#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" +typedef struct VkExternalMemoryImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExternalMemoryImageCreateInfoNV; + +typedef struct VkExportMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExportMemoryAllocateInfoNV; + + + +// VK_EXT_validation_flags is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_validation_flags 1 +#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 3 +#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" + +typedef enum VkValidationCheckEXT { + VK_VALIDATION_CHECK_ALL_EXT = 0, + VK_VALIDATION_CHECK_SHADERS_EXT = 1, + VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCheckEXT; +typedef struct VkValidationFlagsEXT { + VkStructureType sType; + const void* pNext; + uint32_t disabledValidationCheckCount; + const VkValidationCheckEXT* pDisabledValidationChecks; +} VkValidationFlagsEXT; + + + +// VK_EXT_shader_subgroup_ballot is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_subgroup_ballot 1 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1 +#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" + + +// VK_EXT_shader_subgroup_vote is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_subgroup_vote 1 +#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 +#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" + + +// VK_EXT_texture_compression_astc_hdr is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_texture_compression_astc_hdr 1 +#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1 +#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr" +typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; + + + +// VK_EXT_astc_decode_mode is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_astc_decode_mode 1 +#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1 +#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode" +typedef struct VkImageViewASTCDecodeModeEXT { + VkStructureType sType; + const void* pNext; + VkFormat decodeMode; +} VkImageViewASTCDecodeModeEXT; + +typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 decodeModeSharedExponent; +} VkPhysicalDeviceASTCDecodeFeaturesEXT; + + + +// VK_EXT_pipeline_robustness is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_pipeline_robustness 1 +#define VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_pipeline_robustness" +typedef VkPipelineRobustnessBufferBehavior VkPipelineRobustnessBufferBehaviorEXT; + +typedef VkPipelineRobustnessImageBehavior VkPipelineRobustnessImageBehaviorEXT; + +typedef VkPhysicalDevicePipelineRobustnessFeatures VkPhysicalDevicePipelineRobustnessFeaturesEXT; + +typedef VkPhysicalDevicePipelineRobustnessProperties VkPhysicalDevicePipelineRobustnessPropertiesEXT; + +typedef VkPipelineRobustnessCreateInfo VkPipelineRobustnessCreateInfoEXT; + + + +// VK_EXT_conditional_rendering is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_conditional_rendering 1 +#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2 +#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" + +typedef enum VkConditionalRenderingFlagBitsEXT { + VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, + VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConditionalRenderingFlagBitsEXT; +typedef VkFlags VkConditionalRenderingFlagsEXT; +typedef struct VkConditionalRenderingBeginInfoEXT { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceSize offset; + VkConditionalRenderingFlagsEXT flags; +} VkConditionalRenderingBeginInfoEXT; + +typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 conditionalRendering; + VkBool32 inheritedConditionalRendering; +} VkPhysicalDeviceConditionalRenderingFeaturesEXT; + +typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 conditionalRenderingEnable; +} VkCommandBufferInheritanceConditionalRenderingInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); +typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT( + VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT( + VkCommandBuffer commandBuffer); +#endif +#endif + + +// VK_NV_clip_space_w_scaling is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_clip_space_w_scaling 1 +#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 +#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" +typedef struct VkViewportWScalingNV { + float xcoeff; + float ycoeff; +} VkViewportWScalingNV; + +typedef struct VkPipelineViewportWScalingStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 viewportWScalingEnable; + uint32_t viewportCount; + const VkViewportWScalingNV* pViewportWScalings; +} VkPipelineViewportWScalingStateCreateInfoNV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV* pViewportWScalings); +#endif +#endif + + +// VK_EXT_direct_mode_display is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_direct_mode_display 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" +typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); +#endif +#endif + + +// VK_EXT_display_surface_counter is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_display_surface_counter 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" + +typedef enum VkSurfaceCounterFlagBitsEXT { + VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001, + // VK_SURFACE_COUNTER_VBLANK_EXT is a legacy alias + VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT, + VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSurfaceCounterFlagBitsEXT; +typedef VkFlags VkSurfaceCounterFlagsEXT; +typedef struct VkSurfaceCapabilities2EXT { + VkStructureType sType; + void* pNext; + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; + VkSurfaceCounterFlagsEXT supportedSurfaceCounters; +} VkSurfaceCapabilities2EXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); +#endif +#endif + + +// VK_EXT_display_control is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_display_control 1 +#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" + +typedef enum VkDisplayPowerStateEXT { + VK_DISPLAY_POWER_STATE_OFF_EXT = 0, + VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, + VK_DISPLAY_POWER_STATE_ON_EXT = 2, + VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayPowerStateEXT; + +typedef enum VkDeviceEventTypeEXT { + VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, + VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceEventTypeEXT; + +typedef enum VkDisplayEventTypeEXT { + VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, + VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayEventTypeEXT; +typedef struct VkDisplayPowerInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayPowerStateEXT powerState; +} VkDisplayPowerInfoEXT; + +typedef struct VkDeviceEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceEventTypeEXT deviceEvent; +} VkDeviceEventInfoEXT; + +typedef struct VkDisplayEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayEventTypeEXT displayEvent; +} VkDisplayEventInfoEXT; + +typedef struct VkSwapchainCounterCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSurfaceCounterFlagsEXT surfaceCounters; +} VkSwapchainCounterCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( + VkDevice device, + const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue); +#endif +#endif + + +// VK_GOOGLE_display_timing is a preprocessor guard. Do not pass it to API calls. +#define VK_GOOGLE_display_timing 1 +#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 +#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" +typedef struct VkRefreshCycleDurationGOOGLE { + uint64_t refreshDuration; +} VkRefreshCycleDurationGOOGLE; + +typedef struct VkPastPresentationTimingGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; + uint64_t actualPresentTime; + uint64_t earliestPresentTime; + uint64_t presentMargin; +} VkPastPresentationTimingGOOGLE; + +typedef struct VkPresentTimeGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; +} VkPresentTimeGOOGLE; + +typedef struct VkPresentTimesInfoGOOGLE { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentTimeGOOGLE* pTimes; +} VkPresentTimesInfoGOOGLE; + +typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings); +#endif +#endif + + +// VK_NV_sample_mask_override_coverage is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_sample_mask_override_coverage 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 +#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" + + +// VK_NV_geometry_shader_passthrough is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_geometry_shader_passthrough 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 +#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" + + +// VK_NV_viewport_array2 is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_viewport_array2 1 +#define VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME "VK_NV_viewport_array2" +// VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION is a legacy alias +#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION +// VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME is a legacy alias +#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME + + +// VK_NVX_multiview_per_view_attributes is a preprocessor guard. Do not pass it to API calls. +#define VK_NVX_multiview_per_view_attributes 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 +#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" +typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + VkStructureType sType; + void* pNext; + VkBool32 perViewPositionAllComponents; +} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + +typedef struct VkMultiviewPerViewAttributesInfoNVX { + VkStructureType sType; + const void* pNext; + VkBool32 perViewAttributes; + VkBool32 perViewAttributesPositionXOnly; +} VkMultiviewPerViewAttributesInfoNVX; + + + +// VK_NV_viewport_swizzle is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_viewport_swizzle 1 +#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 +#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" + +typedef enum VkViewportCoordinateSwizzleNV { + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, + VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF +} VkViewportCoordinateSwizzleNV; +typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; +typedef struct VkViewportSwizzleNV { + VkViewportCoordinateSwizzleNV x; + VkViewportCoordinateSwizzleNV y; + VkViewportCoordinateSwizzleNV z; + VkViewportCoordinateSwizzleNV w; +} VkViewportSwizzleNV; + +typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const VkViewportSwizzleNV* pViewportSwizzles; +} VkPipelineViewportSwizzleStateCreateInfoNV; + + + +// VK_EXT_discard_rectangles is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_discard_rectangles 1 +#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 2 +#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" + +typedef enum VkDiscardRectangleModeEXT { + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDiscardRectangleModeEXT; +typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT; + +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const VkRect2D* pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleModeEXT)(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 discardRectangleEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleModeEXT( + VkCommandBuffer commandBuffer, + VkDiscardRectangleModeEXT discardRectangleMode); +#endif +#endif + + +// VK_EXT_conservative_rasterization is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_conservative_rasterization 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 +#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" + +typedef enum VkConservativeRasterizationModeEXT { + VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, + VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, + VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, + VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConservativeRasterizationModeEXT; +typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; +} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; +} VkPipelineRasterizationConservativeStateCreateInfoEXT; + + + +// VK_EXT_depth_clip_enable is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_depth_clip_enable 1 +#define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable" +typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClipEnable; +} VkPhysicalDeviceDepthClipEnableFeaturesEXT; + +typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; + VkBool32 depthClipEnable; +} VkPipelineRasterizationDepthClipStateCreateInfoEXT; + + + +// VK_EXT_swapchain_colorspace is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_swapchain_colorspace 1 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 5 +#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" + + +// VK_EXT_hdr_metadata is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_hdr_metadata 1 +#define VK_EXT_HDR_METADATA_SPEC_VERSION 3 +#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" +typedef struct VkXYColorEXT { + float x; + float y; +} VkXYColorEXT; + +typedef struct VkHdrMetadataEXT { + VkStructureType sType; + const void* pNext; + VkXYColorEXT displayPrimaryRed; + VkXYColorEXT displayPrimaryGreen; + VkXYColorEXT displayPrimaryBlue; + VkXYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; +} VkHdrMetadataEXT; + +typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata); +#endif +#endif + + +// VK_IMG_relaxed_line_rasterization is a preprocessor guard. Do not pass it to API calls. +#define VK_IMG_relaxed_line_rasterization 1 +#define VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION 1 +#define VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME "VK_IMG_relaxed_line_rasterization" +typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG { + VkStructureType sType; + void* pNext; + VkBool32 relaxedLineRasterization; +} VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG; + + + +// VK_EXT_external_memory_dma_buf is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_external_memory_dma_buf 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" + + +// VK_EXT_queue_family_foreign is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_queue_family_foreign 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 +#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" +#define VK_QUEUE_FAMILY_FOREIGN_EXT (~2U) + + +// VK_EXT_debug_utils is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_debug_utils 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) +#define VK_EXT_DEBUG_UTILS_SPEC_VERSION 2 +#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" +typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; + +typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT { + VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugUtilsMessageSeverityFlagBitsEXT; + +typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { + VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, + VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, + VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT = 0x00000008, + VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugUtilsMessageTypeFlagBitsEXT; +typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; +typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; +typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; +typedef struct VkDebugUtilsLabelEXT { + VkStructureType sType; + const void* pNext; + const char* pLabelName; + float color[4]; +} VkDebugUtilsLabelEXT; + +typedef struct VkDebugUtilsObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + const char* pObjectName; +} VkDebugUtilsObjectNameInfoEXT; + +typedef struct VkDebugUtilsMessengerCallbackDataEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCallbackDataFlagsEXT flags; + const char* pMessageIdName; + int32_t messageIdNumber; + const char* pMessage; + uint32_t queueLabelCount; + const VkDebugUtilsLabelEXT* pQueueLabels; + uint32_t cmdBufLabelCount; + const VkDebugUtilsLabelEXT* pCmdBufLabels; + uint32_t objectCount; + const VkDebugUtilsObjectNameInfoEXT* pObjects; +} VkDebugUtilsMessengerCallbackDataEXT; + +typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + +typedef struct VkDebugUtilsMessengerCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCreateFlagsEXT flags; + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageType; + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; + void* pUserData; +} VkDebugUtilsMessengerCreateInfoEXT; + +typedef struct VkDebugUtilsObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugUtilsObjectTagInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); +typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); +typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( + VkDevice device, + const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( + VkDevice device, + const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( + VkQueue queue); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( + VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( + VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); +#endif +#endif + + +// VK_EXT_sampler_filter_minmax is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_sampler_filter_minmax 1 +#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2 +#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" +typedef VkSamplerReductionMode VkSamplerReductionModeEXT; + +typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT; + +typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; + + + +// VK_AMD_gpu_shader_int16 is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_gpu_shader_int16 1 +#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 2 +#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" + + +// VK_EXT_descriptor_heap is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_descriptor_heap 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkTensorARM) +#define VK_EXT_DESCRIPTOR_HEAP_SPEC_VERSION 1 +#define VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME "VK_EXT_descriptor_heap" + +typedef enum VkDescriptorMappingSourceEXT { + VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT = 0, + VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT = 1, + VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT = 2, + VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT = 3, + VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT = 4, + VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT = 5, + VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT = 6, + VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT = 7, + VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT = 8, + VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT = 9, + VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT = 10, + VK_DESCRIPTOR_MAPPING_SOURCE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDescriptorMappingSourceEXT; +typedef VkFlags64 VkTensorViewCreateFlagsARM; + +// Flag bits for VkTensorViewCreateFlagBitsARM +typedef VkFlags64 VkTensorViewCreateFlagBitsARM; +static const VkTensorViewCreateFlagBitsARM VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM = 0x00000001ULL; + + +typedef enum VkSpirvResourceTypeFlagBitsEXT { + VK_SPIRV_RESOURCE_TYPE_ALL_EXT = 0x7FFFFFFF, + VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT = 0x00000001, + VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT = 0x00000002, + VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT = 0x00000004, + VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT = 0x00000008, + VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT = 0x00000010, + VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT = 0x00000020, + VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT = 0x00000040, + VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT = 0x00000080, + VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT = 0x00000100, + VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM = 0x00000200, + VK_SPIRV_RESOURCE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSpirvResourceTypeFlagBitsEXT; +typedef VkFlags VkSpirvResourceTypeFlagsEXT; +typedef struct VkHostAddressRangeEXT { + void* address; + size_t size; +} VkHostAddressRangeEXT; + +typedef struct VkHostAddressRangeConstEXT { + const void* address; + size_t size; +} VkHostAddressRangeConstEXT; + +typedef struct VkDeviceAddressRangeEXT { + VkDeviceAddress address; + VkDeviceSize size; +} VkDeviceAddressRangeEXT; + +typedef struct VkTexelBufferDescriptorInfoEXT { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkDeviceAddressRangeEXT addressRange; +} VkTexelBufferDescriptorInfoEXT; + +typedef struct VkImageDescriptorInfoEXT { + VkStructureType sType; + const void* pNext; + const VkImageViewCreateInfo* pView; + VkImageLayout layout; +} VkImageDescriptorInfoEXT; + +typedef struct VkTensorViewCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkTensorViewCreateFlagsARM flags; + VkTensorARM tensor; + VkFormat format; +} VkTensorViewCreateInfoARM; + +typedef union VkResourceDescriptorDataEXT { + const VkImageDescriptorInfoEXT* pImage; + const VkTexelBufferDescriptorInfoEXT* pTexelBuffer; + const VkDeviceAddressRangeEXT* pAddressRange; + const VkTensorViewCreateInfoARM* pTensorARM; +} VkResourceDescriptorDataEXT; + +typedef struct VkResourceDescriptorInfoEXT { + VkStructureType sType; + const void* pNext; + VkDescriptorType type; + VkResourceDescriptorDataEXT data; +} VkResourceDescriptorInfoEXT; + +typedef struct VkBindHeapInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceAddressRangeEXT heapRange; + VkDeviceSize reservedRangeOffset; + VkDeviceSize reservedRangeSize; +} VkBindHeapInfoEXT; + +typedef struct VkPushDataInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t offset; + VkHostAddressRangeConstEXT data; +} VkPushDataInfoEXT; + +typedef struct VkDescriptorMappingSourceConstantOffsetEXT { + uint32_t heapOffset; + uint32_t heapArrayStride; + const VkSamplerCreateInfo* pEmbeddedSampler; + uint32_t samplerHeapOffset; + uint32_t samplerHeapArrayStride; +} VkDescriptorMappingSourceConstantOffsetEXT; + +typedef struct VkDescriptorMappingSourcePushIndexEXT { + uint32_t heapOffset; + uint32_t pushOffset; + uint32_t heapIndexStride; + uint32_t heapArrayStride; + const VkSamplerCreateInfo* pEmbeddedSampler; + VkBool32 useCombinedImageSamplerIndex; + uint32_t samplerHeapOffset; + uint32_t samplerPushOffset; + uint32_t samplerHeapIndexStride; + uint32_t samplerHeapArrayStride; +} VkDescriptorMappingSourcePushIndexEXT; + +typedef struct VkDescriptorMappingSourceIndirectIndexEXT { + uint32_t heapOffset; + uint32_t pushOffset; + uint32_t addressOffset; + uint32_t heapIndexStride; + uint32_t heapArrayStride; + const VkSamplerCreateInfo* pEmbeddedSampler; + VkBool32 useCombinedImageSamplerIndex; + uint32_t samplerHeapOffset; + uint32_t samplerPushOffset; + uint32_t samplerAddressOffset; + uint32_t samplerHeapIndexStride; + uint32_t samplerHeapArrayStride; +} VkDescriptorMappingSourceIndirectIndexEXT; + +typedef struct VkDescriptorMappingSourceHeapDataEXT { + uint32_t heapOffset; + uint32_t pushOffset; +} VkDescriptorMappingSourceHeapDataEXT; + +typedef struct VkDescriptorMappingSourceIndirectAddressEXT { + uint32_t pushOffset; + uint32_t addressOffset; +} VkDescriptorMappingSourceIndirectAddressEXT; + +typedef struct VkDescriptorMappingSourceShaderRecordIndexEXT { + uint32_t heapOffset; + uint32_t shaderRecordOffset; + uint32_t heapIndexStride; + uint32_t heapArrayStride; + const VkSamplerCreateInfo* pEmbeddedSampler; + VkBool32 useCombinedImageSamplerIndex; + uint32_t samplerHeapOffset; + uint32_t samplerShaderRecordOffset; + uint32_t samplerHeapIndexStride; + uint32_t samplerHeapArrayStride; +} VkDescriptorMappingSourceShaderRecordIndexEXT; + +typedef struct VkDescriptorMappingSourceIndirectIndexArrayEXT { + uint32_t heapOffset; + uint32_t pushOffset; + uint32_t addressOffset; + uint32_t heapIndexStride; + const VkSamplerCreateInfo* pEmbeddedSampler; + VkBool32 useCombinedImageSamplerIndex; + uint32_t samplerHeapOffset; + uint32_t samplerPushOffset; + uint32_t samplerAddressOffset; + uint32_t samplerHeapIndexStride; +} VkDescriptorMappingSourceIndirectIndexArrayEXT; + +typedef union VkDescriptorMappingSourceDataEXT { + VkDescriptorMappingSourceConstantOffsetEXT constantOffset; + VkDescriptorMappingSourcePushIndexEXT pushIndex; + VkDescriptorMappingSourceIndirectIndexEXT indirectIndex; + VkDescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray; + VkDescriptorMappingSourceHeapDataEXT heapData; + uint32_t pushDataOffset; + uint32_t pushAddressOffset; + VkDescriptorMappingSourceIndirectAddressEXT indirectAddress; + VkDescriptorMappingSourceShaderRecordIndexEXT shaderRecordIndex; + uint32_t shaderRecordDataOffset; + uint32_t shaderRecordAddressOffset; +} VkDescriptorMappingSourceDataEXT; + +typedef struct VkDescriptorSetAndBindingMappingEXT { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSet; + uint32_t firstBinding; + uint32_t bindingCount; + VkSpirvResourceTypeFlagsEXT resourceMask; + VkDescriptorMappingSourceEXT source; + VkDescriptorMappingSourceDataEXT sourceData; +} VkDescriptorSetAndBindingMappingEXT; + +typedef struct VkShaderDescriptorSetAndBindingMappingInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t mappingCount; + const VkDescriptorSetAndBindingMappingEXT* pMappings; +} VkShaderDescriptorSetAndBindingMappingInfoEXT; + +typedef struct VkOpaqueCaptureDataCreateInfoEXT { + VkStructureType sType; + const void* pNext; + const VkHostAddressRangeConstEXT* pData; +} VkOpaqueCaptureDataCreateInfoEXT; + +typedef struct VkPhysicalDeviceDescriptorHeapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 descriptorHeap; + VkBool32 descriptorHeapCaptureReplay; +} VkPhysicalDeviceDescriptorHeapFeaturesEXT; + +typedef struct VkPhysicalDeviceDescriptorHeapPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize samplerHeapAlignment; + VkDeviceSize resourceHeapAlignment; + VkDeviceSize maxSamplerHeapSize; + VkDeviceSize maxResourceHeapSize; + VkDeviceSize minSamplerHeapReservedRange; + VkDeviceSize minSamplerHeapReservedRangeWithEmbedded; + VkDeviceSize minResourceHeapReservedRange; + VkDeviceSize samplerDescriptorSize; + VkDeviceSize imageDescriptorSize; + VkDeviceSize bufferDescriptorSize; + VkDeviceSize samplerDescriptorAlignment; + VkDeviceSize imageDescriptorAlignment; + VkDeviceSize bufferDescriptorAlignment; + VkDeviceSize maxPushDataSize; + size_t imageCaptureReplayOpaqueDataSize; + uint32_t maxDescriptorHeapEmbeddedSamplers; + uint32_t samplerYcbcrConversionCount; + VkBool32 sparseDescriptorHeaps; + VkBool32 protectedDescriptorHeaps; +} VkPhysicalDeviceDescriptorHeapPropertiesEXT; + +typedef struct VkCommandBufferInheritanceDescriptorHeapInfoEXT { + VkStructureType sType; + const void* pNext; + const VkBindHeapInfoEXT* pSamplerHeapBindInfo; + const VkBindHeapInfoEXT* pResourceHeapBindInfo; +} VkCommandBufferInheritanceDescriptorHeapInfoEXT; + +typedef struct VkSamplerCustomBorderColorIndexCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t index; +} VkSamplerCustomBorderColorIndexCreateInfoEXT; + +typedef struct VkSamplerCustomBorderColorCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkClearColorValue customBorderColor; + VkFormat format; +} VkSamplerCustomBorderColorCreateInfoEXT; + +typedef struct VkIndirectCommandsLayoutPushDataTokenNV { + VkStructureType sType; + const void* pNext; + uint32_t pushDataOffset; + uint32_t pushDataSize; +} VkIndirectCommandsLayoutPushDataTokenNV; + +typedef struct VkSubsampledImageFormatPropertiesEXT { + VkStructureType sType; + const void* pNext; + uint32_t subsampledImageDescriptorCount; +} VkSubsampledImageFormatPropertiesEXT; + +typedef struct VkPhysicalDeviceDescriptorHeapTensorPropertiesARM { + VkStructureType sType; + void* pNext; + VkDeviceSize tensorDescriptorSize; + VkDeviceSize tensorDescriptorAlignment; + size_t tensorCaptureReplayOpaqueDataSize; +} VkPhysicalDeviceDescriptorHeapTensorPropertiesARM; + +typedef VkResult (VKAPI_PTR *PFN_vkWriteSamplerDescriptorsEXT)(VkDevice device, uint32_t samplerCount, const VkSamplerCreateInfo* pSamplers, const VkHostAddressRangeEXT* pDescriptors); +typedef VkResult (VKAPI_PTR *PFN_vkWriteResourceDescriptorsEXT)(VkDevice device, uint32_t resourceCount, const VkResourceDescriptorInfoEXT* pResources, const VkHostAddressRangeEXT* pDescriptors); +typedef void (VKAPI_PTR *PFN_vkCmdBindSamplerHeapEXT)(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBindResourceHeapEXT)(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo); +typedef void (VKAPI_PTR *PFN_vkCmdPushDataEXT)(VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageOpaqueCaptureDataEXT)(VkDevice device, uint32_t imageCount, const VkImage* pImages, VkHostAddressRangeEXT* pDatas); +typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetPhysicalDeviceDescriptorSizeEXT)(VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType); +typedef VkResult (VKAPI_PTR *PFN_vkRegisterCustomBorderColorEXT)(VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, VkBool32 requestIndex, uint32_t* pIndex); +typedef void (VKAPI_PTR *PFN_vkUnregisterCustomBorderColorEXT)(VkDevice device, uint32_t index); +typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDataARM)(VkDevice device, uint32_t tensorCount, const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT( + VkDevice device, + uint32_t samplerCount, + const VkSamplerCreateInfo* pSamplers, + const VkHostAddressRangeEXT* pDescriptors); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkWriteResourceDescriptorsEXT( + VkDevice device, + uint32_t resourceCount, + const VkResourceDescriptorInfoEXT* pResources, + const VkHostAddressRangeEXT* pDescriptors); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindSamplerHeapEXT( + VkCommandBuffer commandBuffer, + const VkBindHeapInfoEXT* pBindInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindResourceHeapEXT( + VkCommandBuffer commandBuffer, + const VkBindHeapInfoEXT* pBindInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPushDataEXT( + VkCommandBuffer commandBuffer, + const VkPushDataInfoEXT* pPushDataInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDataEXT( + VkDevice device, + uint32_t imageCount, + const VkImage* pImages, + VkHostAddressRangeEXT* pDatas); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetPhysicalDeviceDescriptorSizeEXT( + VkPhysicalDevice physicalDevice, + VkDescriptorType descriptorType); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkRegisterCustomBorderColorEXT( + VkDevice device, + const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, + VkBool32 requestIndex, + uint32_t* pIndex); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkUnregisterCustomBorderColorEXT( + VkDevice device, + uint32_t index); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDataARM( + VkDevice device, + uint32_t tensorCount, + const VkTensorARM* pTensors, + VkHostAddressRangeEXT* pDatas); +#endif +#endif + + +// VK_AMD_mixed_attachment_samples is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_mixed_attachment_samples 1 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1 +#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" +typedef struct VkAttachmentSampleCountInfoAMD { + VkStructureType sType; + const void* pNext; + uint32_t colorAttachmentCount; + const VkSampleCountFlagBits* pColorAttachmentSamples; + VkSampleCountFlagBits depthStencilAttachmentSamples; +} VkAttachmentSampleCountInfoAMD; + + + +// VK_AMD_shader_fragment_mask is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_shader_fragment_mask 1 +#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 +#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" + + +// VK_EXT_inline_uniform_block is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_inline_uniform_block 1 +#define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1 +#define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block" +typedef VkPhysicalDeviceInlineUniformBlockFeatures VkPhysicalDeviceInlineUniformBlockFeaturesEXT; + +typedef VkPhysicalDeviceInlineUniformBlockProperties VkPhysicalDeviceInlineUniformBlockPropertiesEXT; + +typedef VkWriteDescriptorSetInlineUniformBlock VkWriteDescriptorSetInlineUniformBlockEXT; + +typedef VkDescriptorPoolInlineUniformBlockCreateInfo VkDescriptorPoolInlineUniformBlockCreateInfoEXT; + + + +// VK_EXT_shader_stencil_export is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_stencil_export 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 +#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" + + +// VK_EXT_sample_locations is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_sample_locations 1 +#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 +#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" +typedef struct VkSampleLocationEXT { + float x; + float y; +} VkSampleLocationEXT; + +typedef struct VkSampleLocationsInfoEXT { + VkStructureType sType; + const void* pNext; + VkSampleCountFlagBits sampleLocationsPerPixel; + VkExtent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const VkSampleLocationEXT* pSampleLocations; +} VkSampleLocationsInfoEXT; + +typedef struct VkAttachmentSampleLocationsEXT { + uint32_t attachmentIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkAttachmentSampleLocationsEXT; + +typedef struct VkSubpassSampleLocationsEXT { + uint32_t subpassIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkSubpassSampleLocationsEXT; + +typedef struct VkRenderPassSampleLocationsBeginInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t attachmentInitialSampleLocationsCount; + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; +} VkRenderPassSampleLocationsBeginInfoEXT; + +typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 sampleLocationsEnable; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkPipelineSampleLocationsStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; +} VkPhysicalDeviceSampleLocationsPropertiesEXT; + +typedef struct VkMultisamplePropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D maxSampleLocationGridSize; +} VkMultisamplePropertiesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( + VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( + VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties); +#endif +#endif + + +// VK_EXT_blend_operation_advanced is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_blend_operation_advanced 1 +#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 +#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" + +typedef enum VkBlendOverlapEXT { + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBlendOverlapEXT; +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + + + +// VK_NV_fragment_coverage_to_color is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_fragment_coverage_to_color 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" +typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; +typedef struct VkPipelineCoverageToColorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; +} VkPipelineCoverageToColorStateCreateInfoNV; + + + +// VK_NV_framebuffer_mixed_samples is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_framebuffer_mixed_samples 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 +#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" + +typedef enum VkCoverageModulationModeNV { + VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, + VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, + VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, + VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, + VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoverageModulationModeNV; +typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; +typedef struct VkPipelineCoverageModulationStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageModulationStateCreateFlagsNV flags; + VkCoverageModulationModeNV coverageModulationMode; + VkBool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable; +} VkPipelineCoverageModulationStateCreateInfoNV; + +typedef VkAttachmentSampleCountInfoAMD VkAttachmentSampleCountInfoNV; + + + +// VK_NV_fill_rectangle is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_fill_rectangle 1 +#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 +#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" + + +// VK_NV_shader_sm_builtins is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_shader_sm_builtins 1 +#define VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION 1 +#define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins" +typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t shaderSMCount; + uint32_t shaderWarpsPerSM; +} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV; + +typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shaderSMBuiltins; +} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV; + + + +// VK_EXT_post_depth_coverage is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_post_depth_coverage 1 +#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 +#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" + + +// VK_EXT_image_drm_format_modifier is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_image_drm_format_modifier 1 +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 2 +#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier" +typedef struct VkDrmFormatModifierPropertiesEXT { + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags drmFormatModifierTilingFeatures; +} VkDrmFormatModifierPropertiesEXT; + +typedef struct VkDrmFormatModifierPropertiesListEXT { + VkStructureType sType; + void* pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesListEXT; + +typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT { + VkStructureType sType; + const void* pNext; + uint64_t drmFormatModifier; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkPhysicalDeviceImageDrmFormatModifierInfoEXT; + +typedef struct VkImageDrmFormatModifierListCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t drmFormatModifierCount; + const uint64_t* pDrmFormatModifiers; +} VkImageDrmFormatModifierListCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + const VkSubresourceLayout* pPlaneLayouts; +} VkImageDrmFormatModifierExplicitCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint64_t drmFormatModifier; +} VkImageDrmFormatModifierPropertiesEXT; + +typedef struct VkDrmFormatModifierProperties2EXT { + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags2 drmFormatModifierTilingFeatures; +} VkDrmFormatModifierProperties2EXT; + +typedef struct VkDrmFormatModifierPropertiesList2EXT { + VkStructureType sType; + void* pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesList2EXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT( + VkDevice device, + VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties); +#endif +#endif + + +// VK_EXT_validation_cache is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_validation_cache 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) +#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 +#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" + +typedef enum VkValidationCacheHeaderVersionEXT { + VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, + VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCacheHeaderVersionEXT; +typedef VkFlags VkValidationCacheCreateFlagsEXT; +typedef struct VkValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheCreateFlagsEXT flags; + size_t initialDataSize; + const void* pInitialData; +} VkValidationCacheCreateInfoEXT; + +typedef struct VkShaderModuleValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheEXT validationCache; +} VkShaderModuleValidationCacheCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); +typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); +typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( + VkDevice device, + const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( + VkDevice device, + VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const VkValidationCacheEXT* pSrcCaches); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + size_t* pDataSize, + void* pData); +#endif +#endif + + +// VK_EXT_descriptor_indexing is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_descriptor_indexing 1 +#define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2 +#define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing" +typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT; + +typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT; + +typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; + +typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT; + +typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT; + +typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; + +typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; + + + +// VK_EXT_shader_viewport_index_layer is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_viewport_index_layer 1 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 +#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" + + +// VK_NV_shading_rate_image is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_shading_rate_image 1 +#define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3 +#define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image" + +typedef enum VkShadingRatePaletteEntryNV { + VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0, + VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1, + VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2, + VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3, + VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11, + VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF +} VkShadingRatePaletteEntryNV; + +typedef enum VkCoarseSampleOrderTypeNV { + VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0, + VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1, + VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2, + VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3, + VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoarseSampleOrderTypeNV; +typedef struct VkShadingRatePaletteNV { + uint32_t shadingRatePaletteEntryCount; + const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries; +} VkShadingRatePaletteNV; + +typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 shadingRateImageEnable; + uint32_t viewportCount; + const VkShadingRatePaletteNV* pShadingRatePalettes; +} VkPipelineViewportShadingRateImageStateCreateInfoNV; + +typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shadingRateImage; + VkBool32 shadingRateCoarseSampleOrder; +} VkPhysicalDeviceShadingRateImageFeaturesNV; + +typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV { + VkStructureType sType; + void* pNext; + VkExtent2D shadingRateTexelSize; + uint32_t shadingRatePaletteSize; + uint32_t shadingRateMaxCoarseSamples; +} VkPhysicalDeviceShadingRateImagePropertiesNV; + +typedef struct VkCoarseSampleLocationNV { + uint32_t pixelX; + uint32_t pixelY; + uint32_t sample; +} VkCoarseSampleLocationNV; + +typedef struct VkCoarseSampleOrderCustomNV { + VkShadingRatePaletteEntryNV shadingRate; + uint32_t sampleCount; + uint32_t sampleLocationCount; + const VkCoarseSampleLocationNV* pSampleLocations; +} VkCoarseSampleOrderCustomNV; + +typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkCoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders; +} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; + +typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV* pShadingRatePalettes); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV( + VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); +#endif +#endif + + +// VK_NV_ray_tracing is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_ray_tracing 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV) +#define VK_NV_RAY_TRACING_SPEC_VERSION 3 +#define VK_NV_RAY_TRACING_EXTENSION_NAME "VK_NV_ray_tracing" +#define VK_SHADER_UNUSED_KHR (~0U) +#define VK_SHADER_UNUSED_NV VK_SHADER_UNUSED_KHR + +typedef enum VkRayTracingShaderGroupTypeKHR { + VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0, + VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1, + VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2, + VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR, + VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR, + VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR, + VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkRayTracingShaderGroupTypeKHR; +typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV; + + +typedef enum VkGeometryTypeKHR { + VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0, + VK_GEOMETRY_TYPE_AABBS_KHR = 1, + VK_GEOMETRY_TYPE_INSTANCES_KHR = 2, + VK_GEOMETRY_TYPE_SPHERES_NV = 1000429004, + VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV = 1000429005, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX = 1000478000, +#endif + VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR, + VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR, + VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkGeometryTypeKHR; +typedef VkGeometryTypeKHR VkGeometryTypeNV; + + +typedef enum VkAccelerationStructureTypeKHR { + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, + VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, + VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureTypeKHR; +typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV; + + +typedef enum VkCopyAccelerationStructureModeKHR { + VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0, + VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1, + VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2, + VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3, + VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR, + VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, + VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkCopyAccelerationStructureModeKHR; +typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV; + + +typedef enum VkAccelerationStructureMemoryRequirementsTypeNV { + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkAccelerationStructureMemoryRequirementsTypeNV; + +typedef enum VkGeometryFlagBitsKHR { + VK_GEOMETRY_OPAQUE_BIT_KHR = 0x00000001, + VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0x00000002, + VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR, + VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR, + VK_GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkGeometryFlagBitsKHR; +typedef VkFlags VkGeometryFlagsKHR; +typedef VkGeometryFlagsKHR VkGeometryFlagsNV; + +typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV; + + +typedef enum VkGeometryInstanceFlagBitsKHR { + VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0x00000001, + VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002, + VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004, + VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT = 0x00000010, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000020, + VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, + VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, + VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, + // VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT is a legacy alias + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, + // VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT is a legacy alias + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT, + VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkGeometryInstanceFlagBitsKHR; +typedef VkFlags VkGeometryInstanceFlagsKHR; +typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV; + +typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV; + + +typedef enum VkBuildAccelerationStructureFlagBitsKHR { + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0x00000001, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0x00000002, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0x00000004, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008, + VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010, + VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT = 0x00000040, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000080, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT = 0x00000100, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV = 0x00000200, +#endif + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR = 0x00000800, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV = 0x00001000, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, + // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT is a legacy alias + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, + // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT is a legacy alias + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, + // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT is a legacy alias + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT, +#ifdef VK_ENABLE_BETA_EXTENSIONS + // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV is a legacy alias + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV, +#endif + // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR is a legacy alias + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkBuildAccelerationStructureFlagBitsKHR; +typedef VkFlags VkBuildAccelerationStructureFlagsKHR; +typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV; + +typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV; + +typedef struct VkRayTracingShaderGroupCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkRayTracingShaderGroupTypeKHR type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; +} VkRayTracingShaderGroupCreateInfoNV; + +typedef struct VkRayTracingPipelineCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const VkRayTracingShaderGroupCreateInfoNV* pGroups; + uint32_t maxRecursionDepth; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkRayTracingPipelineCreateInfoNV; + +typedef struct VkGeometryTrianglesNV { + VkStructureType sType; + const void* pNext; + VkBuffer vertexData; + VkDeviceSize vertexOffset; + uint32_t vertexCount; + VkDeviceSize vertexStride; + VkFormat vertexFormat; + VkBuffer indexData; + VkDeviceSize indexOffset; + uint32_t indexCount; + VkIndexType indexType; + VkBuffer transformData; + VkDeviceSize transformOffset; +} VkGeometryTrianglesNV; + +typedef struct VkGeometryAABBNV { + VkStructureType sType; + const void* pNext; + VkBuffer aabbData; + uint32_t numAABBs; + uint32_t stride; + VkDeviceSize offset; +} VkGeometryAABBNV; + +typedef struct VkGeometryDataNV { + VkGeometryTrianglesNV triangles; + VkGeometryAABBNV aabbs; +} VkGeometryDataNV; + +typedef struct VkGeometryNV { + VkStructureType sType; + const void* pNext; + VkGeometryTypeKHR geometryType; + VkGeometryDataNV geometry; + VkGeometryFlagsKHR flags; +} VkGeometryNV; + +typedef struct VkAccelerationStructureInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureTypeNV type; + VkBuildAccelerationStructureFlagsNV flags; + uint32_t instanceCount; + uint32_t geometryCount; + const VkGeometryNV* pGeometries; +} VkAccelerationStructureInfoNV; + +typedef struct VkAccelerationStructureCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceSize compactedSize; + VkAccelerationStructureInfoNV info; +} VkAccelerationStructureCreateInfoNV; + +typedef struct VkBindAccelerationStructureMemoryInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureNV accelerationStructure; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindAccelerationStructureMemoryInfoNV; + +typedef struct VkWriteDescriptorSetAccelerationStructureNV { + VkStructureType sType; + const void* pNext; + uint32_t accelerationStructureCount; + const VkAccelerationStructureNV* pAccelerationStructures; +} VkWriteDescriptorSetAccelerationStructureNV; + +typedef struct VkAccelerationStructureMemoryRequirementsInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureMemoryRequirementsTypeNV type; + VkAccelerationStructureNV accelerationStructure; +} VkAccelerationStructureMemoryRequirementsInfoNV; + +typedef struct VkPhysicalDeviceRayTracingPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t shaderGroupHandleSize; + uint32_t maxRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxTriangleCount; + uint32_t maxDescriptorSetAccelerationStructures; +} VkPhysicalDeviceRayTracingPropertiesNV; + +typedef struct VkTransformMatrixKHR { + float matrix[3][4]; +} VkTransformMatrixKHR; + +typedef VkTransformMatrixKHR VkTransformMatrixNV; + +typedef struct VkAabbPositionsKHR { + float minX; + float minY; + float minZ; + float maxX; + float maxY; + float maxZ; +} VkAabbPositionsKHR; + +typedef VkAabbPositionsKHR VkAabbPositionsNV; + +typedef struct VkAccelerationStructureInstanceKHR { + VkTransformMatrixKHR transform; + uint32_t instanceCustomIndex:24; + uint32_t mask:8; + uint32_t instanceShaderBindingTableRecordOffset:24; + VkGeometryInstanceFlagsKHR flags:8; + uint64_t accelerationStructureReference; +} VkAccelerationStructureInstanceKHR; + +typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure); +typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); +typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode); +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV( + VkDevice device, + const VkAccelerationStructureCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureNV* pAccelerationStructure); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV( + VkDevice device, + const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV( + VkDevice device, + uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV( + VkCommandBuffer commandBuffer, + const VkAccelerationStructureInfoNV* pInfo, + VkBuffer instanceData, + VkDeviceSize instanceOffset, + VkBool32 update, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkBuffer scratch, + VkDeviceSize scratchOffset); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV( + VkCommandBuffer commandBuffer, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeKHR mode); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV( + VkCommandBuffer commandBuffer, + VkBuffer raygenShaderBindingTableBuffer, + VkDeviceSize raygenShaderBindingOffset, + VkBuffer missShaderBindingTableBuffer, + VkDeviceSize missShaderBindingOffset, + VkDeviceSize missShaderBindingStride, + VkBuffer hitShaderBindingTableBuffer, + VkDeviceSize hitShaderBindingOffset, + VkDeviceSize hitShaderBindingStride, + VkBuffer callableShaderBindingTableBuffer, + VkDeviceSize callableShaderBindingOffset, + VkDeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoNV* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + size_t dataSize, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureNV* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV( + VkDevice device, + VkPipeline pipeline, + uint32_t shader); +#endif +#endif + + +// VK_NV_representative_fragment_test is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_representative_fragment_test 1 +#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2 +#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test" +typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 representativeFragmentTest; +} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; + +typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 representativeFragmentTestEnable; +} VkPipelineRepresentativeFragmentTestStateCreateInfoNV; + + + +// VK_EXT_filter_cubic is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_filter_cubic 1 +#define VK_EXT_FILTER_CUBIC_SPEC_VERSION 3 +#define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic" +typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT { + VkStructureType sType; + void* pNext; + VkImageViewType imageViewType; +} VkPhysicalDeviceImageViewImageFormatInfoEXT; + +typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 filterCubic; + VkBool32 filterCubicMinmax; +} VkFilterCubicImageViewImageFormatPropertiesEXT; + + + +// VK_QCOM_render_pass_shader_resolve is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_render_pass_shader_resolve 1 +#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION 4 +#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME "VK_QCOM_render_pass_shader_resolve" + + +// VK_EXT_global_priority is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_global_priority 1 +#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 +#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" +typedef VkQueueGlobalPriority VkQueueGlobalPriorityEXT; + +typedef VkDeviceQueueGlobalPriorityCreateInfo VkDeviceQueueGlobalPriorityCreateInfoEXT; + + + +// VK_EXT_external_memory_host is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_external_memory_host 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" +typedef struct VkImportMemoryHostPointerInfoEXT { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + void* pHostPointer; +} VkImportMemoryHostPointerInfoEXT; + +typedef struct VkMemoryHostPointerPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryHostPointerPropertiesEXT; + +typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize minImportedHostPointerAlignment; +} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); +#endif +#endif + + +// VK_AMD_buffer_marker is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_buffer_marker 1 +#define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1 +#define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker" +typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); +#endif +#endif + + +// VK_AMD_pipeline_compiler_control is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_pipeline_compiler_control 1 +#define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1 +#define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control" + +typedef enum VkPipelineCompilerControlFlagBitsAMD { + VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF +} VkPipelineCompilerControlFlagBitsAMD; +typedef VkFlags VkPipelineCompilerControlFlagsAMD; +typedef struct VkPipelineCompilerControlCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkPipelineCompilerControlFlagsAMD compilerControlFlags; +} VkPipelineCompilerControlCreateInfoAMD; + + + +// VK_EXT_calibrated_timestamps is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_calibrated_timestamps 1 +#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2 +#define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps" +typedef VkTimeDomainKHR VkTimeDomainEXT; + +typedef VkCalibratedTimestampInfoKHR VkCalibratedTimestampInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains); +typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainKHR* pTimeDomains); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoKHR* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation); +#endif +#endif + + +// VK_AMD_shader_core_properties is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_shader_core_properties 1 +#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2 +#define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties" +typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { + VkStructureType sType; + void* pNext; + uint32_t shaderEngineCount; + uint32_t shaderArraysPerEngineCount; + uint32_t computeUnitsPerShaderArray; + uint32_t simdPerComputeUnit; + uint32_t wavefrontsPerSimd; + uint32_t wavefrontSize; + uint32_t sgprsPerSimd; + uint32_t minSgprAllocation; + uint32_t maxSgprAllocation; + uint32_t sgprAllocationGranularity; + uint32_t vgprsPerSimd; + uint32_t minVgprAllocation; + uint32_t maxVgprAllocation; + uint32_t vgprAllocationGranularity; +} VkPhysicalDeviceShaderCorePropertiesAMD; + + + +// VK_AMD_memory_overallocation_behavior is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_memory_overallocation_behavior 1 +#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1 +#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior" + +typedef enum VkMemoryOverallocationBehaviorAMD { + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF +} VkMemoryOverallocationBehaviorAMD; +typedef struct VkDeviceMemoryOverallocationCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkMemoryOverallocationBehaviorAMD overallocationBehavior; +} VkDeviceMemoryOverallocationCreateInfoAMD; + + + +// VK_EXT_vertex_attribute_divisor is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_vertex_attribute_divisor 1 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3 +#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxVertexAttribDivisor; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; + +typedef VkVertexInputBindingDivisorDescription VkVertexInputBindingDivisorDescriptionEXT; + +typedef VkPipelineVertexInputDivisorStateCreateInfo VkPipelineVertexInputDivisorStateCreateInfoEXT; + +typedef VkPhysicalDeviceVertexAttributeDivisorFeatures VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; + + + +// VK_EXT_pipeline_creation_feedback is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_pipeline_creation_feedback 1 +#define VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME "VK_EXT_pipeline_creation_feedback" +typedef VkPipelineCreationFeedbackFlagBits VkPipelineCreationFeedbackFlagBitsEXT; + +typedef VkPipelineCreationFeedbackFlags VkPipelineCreationFeedbackFlagsEXT; + +typedef VkPipelineCreationFeedbackCreateInfo VkPipelineCreationFeedbackCreateInfoEXT; + +typedef VkPipelineCreationFeedback VkPipelineCreationFeedbackEXT; + + + +// VK_NV_shader_subgroup_partitioned is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_shader_subgroup_partitioned 1 +#define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1 +#define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned" + + +// VK_NV_compute_shader_derivatives is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_compute_shader_derivatives 1 +#define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 +#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives" +typedef VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; + + + +// VK_NV_mesh_shader is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_mesh_shader 1 +#define VK_NV_MESH_SHADER_SPEC_VERSION 1 +#define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader" +typedef struct VkPhysicalDeviceMeshShaderFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 taskShader; + VkBool32 meshShader; +} VkPhysicalDeviceMeshShaderFeaturesNV; + +typedef struct VkPhysicalDeviceMeshShaderPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxDrawMeshTasksCount; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskTotalMemorySize; + uint32_t maxTaskOutputCount; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshTotalMemorySize; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; +} VkPhysicalDeviceMeshShaderPropertiesNV; + +typedef struct VkDrawMeshTasksIndirectCommandNV { + uint32_t taskCount; + uint32_t firstTask; +} VkDrawMeshTasksIndirectCommandNV; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV( + VkCommandBuffer commandBuffer, + uint32_t taskCount, + uint32_t firstTask); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif +#endif + + +// VK_NV_fragment_shader_barycentric is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_fragment_shader_barycentric 1 +#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric" +typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; + + + +// VK_NV_shader_image_footprint is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_shader_image_footprint 1 +#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2 +#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint" +typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 imageFootprint; +} VkPhysicalDeviceShaderImageFootprintFeaturesNV; + + + +// VK_NV_scissor_exclusive is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_scissor_exclusive 1 +#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 2 +#define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive" +typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t exclusiveScissorCount; + const VkRect2D* pExclusiveScissors; +} VkPipelineViewportExclusiveScissorStateCreateInfoNV; + +typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 exclusiveScissor; +} VkPhysicalDeviceExclusiveScissorFeaturesNV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorEnableNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables); +typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorEnableNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkBool32* pExclusiveScissorEnables); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkRect2D* pExclusiveScissors); +#endif +#endif + + +// VK_NV_device_diagnostic_checkpoints is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_device_diagnostic_checkpoints 1 +#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2 +#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints" +typedef struct VkQueueFamilyCheckpointPropertiesNV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags checkpointExecutionStageMask; +} VkQueueFamilyCheckpointPropertiesNV; + +typedef struct VkCheckpointDataNV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlagBits stage; + void* pCheckpointMarker; +} VkCheckpointDataNV; + +typedef struct VkQueueFamilyCheckpointProperties2NV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags2 checkpointExecutionStageMask; +} VkQueueFamilyCheckpointProperties2NV; + +typedef struct VkCheckpointData2NV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags2 stage; + void* pCheckpointMarker; +} VkCheckpointData2NV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker); +typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData); +typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV( + VkCommandBuffer commandBuffer, + const void* pCheckpointMarker); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointDataNV* pCheckpointData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointData2NV* pCheckpointData); +#endif +#endif + + +// VK_EXT_present_timing is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_present_timing 1 +#define VK_EXT_PRESENT_TIMING_SPEC_VERSION 3 +#define VK_EXT_PRESENT_TIMING_EXTENSION_NAME "VK_EXT_present_timing" + +typedef enum VkPresentStageFlagBitsEXT { + VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT = 0x00000001, + VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT = 0x00000002, + VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT = 0x00000004, + VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT = 0x00000008, + VK_PRESENT_STAGE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPresentStageFlagBitsEXT; +typedef VkFlags VkPresentStageFlagsEXT; + +typedef enum VkPastPresentationTimingFlagBitsEXT { + VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT = 0x00000001, + VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT = 0x00000002, + VK_PAST_PRESENTATION_TIMING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPastPresentationTimingFlagBitsEXT; +typedef VkFlags VkPastPresentationTimingFlagsEXT; + +typedef enum VkPresentTimingInfoFlagBitsEXT { + VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT = 0x00000001, + VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT = 0x00000002, + VK_PRESENT_TIMING_INFO_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPresentTimingInfoFlagBitsEXT; +typedef VkFlags VkPresentTimingInfoFlagsEXT; +typedef struct VkPhysicalDevicePresentTimingFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 presentTiming; + VkBool32 presentAtAbsoluteTime; + VkBool32 presentAtRelativeTime; +} VkPhysicalDevicePresentTimingFeaturesEXT; + +typedef struct VkPresentTimingSurfaceCapabilitiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 presentTimingSupported; + VkBool32 presentAtAbsoluteTimeSupported; + VkBool32 presentAtRelativeTimeSupported; + VkPresentStageFlagsEXT presentStageQueries; +} VkPresentTimingSurfaceCapabilitiesEXT; + +typedef struct VkSwapchainCalibratedTimestampInfoEXT { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + VkPresentStageFlagsEXT presentStage; + uint64_t timeDomainId; +} VkSwapchainCalibratedTimestampInfoEXT; + +typedef struct VkSwapchainTimingPropertiesEXT { + VkStructureType sType; + void* pNext; + uint64_t refreshDuration; + uint64_t refreshInterval; +} VkSwapchainTimingPropertiesEXT; + +typedef struct VkSwapchainTimeDomainPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t timeDomainCount; + VkTimeDomainKHR* pTimeDomains; + uint64_t* pTimeDomainIds; +} VkSwapchainTimeDomainPropertiesEXT; + +typedef struct VkPastPresentationTimingInfoEXT { + VkStructureType sType; + const void* pNext; + VkPastPresentationTimingFlagsEXT flags; + VkSwapchainKHR swapchain; +} VkPastPresentationTimingInfoEXT; + +typedef struct VkPresentStageTimeEXT { + VkPresentStageFlagsEXT stage; + uint64_t time; +} VkPresentStageTimeEXT; + +typedef struct VkPastPresentationTimingEXT { + VkStructureType sType; + void* pNext; + uint64_t presentId; + uint64_t targetTime; + uint32_t presentStageCount; + VkPresentStageTimeEXT* pPresentStages; + VkTimeDomainKHR timeDomain; + uint64_t timeDomainId; + VkBool32 reportComplete; +} VkPastPresentationTimingEXT; + +typedef struct VkPastPresentationTimingPropertiesEXT { + VkStructureType sType; + void* pNext; + uint64_t timingPropertiesCounter; + uint64_t timeDomainsCounter; + uint32_t presentationTimingCount; + VkPastPresentationTimingEXT* pPresentationTimings; +} VkPastPresentationTimingPropertiesEXT; + +typedef struct VkPresentTimingInfoEXT { + VkStructureType sType; + const void* pNext; + VkPresentTimingInfoFlagsEXT flags; + uint64_t targetTime; + uint64_t timeDomainId; + VkPresentStageFlagsEXT presentStageQueries; + VkPresentStageFlagsEXT targetTimeDomainPresentStage; +} VkPresentTimingInfoEXT; + +typedef struct VkPresentTimingsInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentTimingInfoEXT* pTimingInfos; +} VkPresentTimingsInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkSetSwapchainPresentTimingQueueSizeEXT)(VkDevice device, VkSwapchainKHR swapchain, uint32_t size); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainTimingPropertiesEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, uint64_t* pSwapchainTimingPropertiesCounter); +typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainTimeDomainPropertiesEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, uint64_t* pTimeDomainsCounter); +typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingEXT)(VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetSwapchainPresentTimingQueueSizeEXT( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t size); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimingPropertiesEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, + uint64_t* pSwapchainTimingPropertiesCounter); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimeDomainPropertiesEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, + uint64_t* pTimeDomainsCounter); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingEXT( + VkDevice device, + const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, + VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties); +#endif +#endif + + +// VK_INTEL_shader_integer_functions2 is a preprocessor guard. Do not pass it to API calls. +#define VK_INTEL_shader_integer_functions2 1 +#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1 +#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2" +typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + VkStructureType sType; + void* pNext; + VkBool32 shaderIntegerFunctions2; +} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + + + +// VK_INTEL_performance_query is a preprocessor guard. Do not pass it to API calls. +#define VK_INTEL_performance_query 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL) +#define VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION 2 +#define VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME "VK_INTEL_performance_query" + +typedef enum VkPerformanceConfigurationTypeINTEL { + VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0, + VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceConfigurationTypeINTEL; + +typedef enum VkQueryPoolSamplingModeINTEL { + VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0, + VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkQueryPoolSamplingModeINTEL; + +typedef enum VkPerformanceOverrideTypeINTEL { + VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0, + VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1, + VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceOverrideTypeINTEL; + +typedef enum VkPerformanceParameterTypeINTEL { + VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0, + VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1, + VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceParameterTypeINTEL; + +typedef enum VkPerformanceValueTypeINTEL { + VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0, + VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1, + VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2, + VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3, + VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4, + VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceValueTypeINTEL; +typedef union VkPerformanceValueDataINTEL { + uint32_t value32; + uint64_t value64; + float valueFloat; + VkBool32 valueBool; + const char* valueString; +} VkPerformanceValueDataINTEL; + +typedef struct VkPerformanceValueINTEL { + VkPerformanceValueTypeINTEL type; + VkPerformanceValueDataINTEL data; +} VkPerformanceValueINTEL; + +typedef struct VkInitializePerformanceApiInfoINTEL { + VkStructureType sType; + const void* pNext; + void* pUserData; +} VkInitializePerformanceApiInfoINTEL; + +typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL { + VkStructureType sType; + const void* pNext; + VkQueryPoolSamplingModeINTEL performanceCountersSampling; +} VkQueryPoolPerformanceQueryCreateInfoINTEL; + +typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL; + +typedef struct VkPerformanceMarkerInfoINTEL { + VkStructureType sType; + const void* pNext; + uint64_t marker; +} VkPerformanceMarkerInfoINTEL; + +typedef struct VkPerformanceStreamMarkerInfoINTEL { + VkStructureType sType; + const void* pNext; + uint32_t marker; +} VkPerformanceStreamMarkerInfoINTEL; + +typedef struct VkPerformanceOverrideInfoINTEL { + VkStructureType sType; + const void* pNext; + VkPerformanceOverrideTypeINTEL type; + VkBool32 enable; + uint64_t parameter; +} VkPerformanceOverrideInfoINTEL; + +typedef struct VkPerformanceConfigurationAcquireInfoINTEL { + VkStructureType sType; + const void* pNext; + VkPerformanceConfigurationTypeINTEL type; +} VkPerformanceConfigurationAcquireInfoINTEL; + +typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); +typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device); +typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo); +typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration); +typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration); +typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration); +typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL( + VkDevice device, + const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL( + VkDevice device); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceMarkerInfoINTEL* pMarkerInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceOverrideInfoINTEL* pOverrideInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL( + VkDevice device, + const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, + VkPerformanceConfigurationINTEL* pConfiguration); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL( + VkDevice device, + VkPerformanceConfigurationINTEL configuration); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL( + VkQueue queue, + VkPerformanceConfigurationINTEL configuration); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL( + VkDevice device, + VkPerformanceParameterTypeINTEL parameter, + VkPerformanceValueINTEL* pValue); +#endif +#endif + + +// VK_EXT_pci_bus_info is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_pci_bus_info 1 +#define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2 +#define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info" +typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; +} VkPhysicalDevicePCIBusInfoPropertiesEXT; + + + +// VK_AMD_display_native_hdr is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_display_native_hdr 1 +#define VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION 1 +#define VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME "VK_AMD_display_native_hdr" +typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD { + VkStructureType sType; + void* pNext; + VkBool32 localDimmingSupport; +} VkDisplayNativeHdrSurfaceCapabilitiesAMD; + +typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkBool32 localDimmingEnable; +} VkSwapchainDisplayNativeHdrCreateInfoAMD; + +typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD( + VkDevice device, + VkSwapchainKHR swapChain, + VkBool32 localDimmingEnable); +#endif +#endif + + +// VK_EXT_fragment_density_map is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_fragment_density_map 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 3 +#define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map" +typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMap; + VkBool32 fragmentDensityMapDynamic; + VkBool32 fragmentDensityMapNonSubsampledImages; +} VkPhysicalDeviceFragmentDensityMapFeaturesEXT; + +typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D minFragmentDensityTexelSize; + VkExtent2D maxFragmentDensityTexelSize; + VkBool32 fragmentDensityInvocations; +} VkPhysicalDeviceFragmentDensityMapPropertiesEXT; + +typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkAttachmentReference fragmentDensityMapAttachment; +} VkRenderPassFragmentDensityMapCreateInfoEXT; + +typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkImageLayout imageLayout; +} VkRenderingFragmentDensityMapAttachmentInfoEXT; + + + +// VK_EXT_scalar_block_layout is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_scalar_block_layout 1 +#define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1 +#define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout" +typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT; + + + +// VK_GOOGLE_hlsl_functionality1 is a preprocessor guard. Do not pass it to API calls. +#define VK_GOOGLE_hlsl_functionality1 1 +#define VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION 1 +#define VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1" +// VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION is a legacy alias +#define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION +// VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME is a legacy alias +#define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME + + +// VK_GOOGLE_decorate_string is a preprocessor guard. Do not pass it to API calls. +#define VK_GOOGLE_decorate_string 1 +#define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1 +#define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string" + + +// VK_EXT_subgroup_size_control is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_subgroup_size_control 1 +#define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2 +#define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control" +typedef VkPhysicalDeviceSubgroupSizeControlFeatures VkPhysicalDeviceSubgroupSizeControlFeaturesEXT; + +typedef VkPhysicalDeviceSubgroupSizeControlProperties VkPhysicalDeviceSubgroupSizeControlPropertiesEXT; + +typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; + + + +// VK_AMD_shader_core_properties2 is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_shader_core_properties2 1 +#define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1 +#define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2" + +typedef enum VkShaderCorePropertiesFlagBitsAMD { + VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF +} VkShaderCorePropertiesFlagBitsAMD; +typedef VkFlags VkShaderCorePropertiesFlagsAMD; +typedef struct VkPhysicalDeviceShaderCoreProperties2AMD { + VkStructureType sType; + void* pNext; + VkShaderCorePropertiesFlagsAMD shaderCoreFeatures; + uint32_t activeComputeUnitCount; +} VkPhysicalDeviceShaderCoreProperties2AMD; + + + +// VK_AMD_device_coherent_memory is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_device_coherent_memory 1 +#define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1 +#define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory" +typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD { + VkStructureType sType; + void* pNext; + VkBool32 deviceCoherentMemory; +} VkPhysicalDeviceCoherentMemoryFeaturesAMD; + + + +// VK_EXT_shader_image_atomic_int64 is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_image_atomic_int64 1 +#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1 +#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64" +typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderImageInt64Atomics; + VkBool32 sparseImageInt64Atomics; +} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + + + +// VK_EXT_memory_budget is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_memory_budget 1 +#define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1 +#define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget" +typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; + VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryBudgetPropertiesEXT; + + + +// VK_EXT_memory_priority is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_memory_priority 1 +#define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1 +#define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority" +typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 memoryPriority; +} VkPhysicalDeviceMemoryPriorityFeaturesEXT; + +typedef struct VkMemoryPriorityAllocateInfoEXT { + VkStructureType sType; + const void* pNext; + float priority; +} VkMemoryPriorityAllocateInfoEXT; + + + +// VK_NV_dedicated_allocation_image_aliasing is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_dedicated_allocation_image_aliasing 1 +#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1 +#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing" +typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 dedicatedAllocationImageAliasing; +} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + + + +// VK_EXT_buffer_device_address is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_buffer_device_address 1 +#define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2 +#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address" +typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT; + +typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT; + +typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT; + +typedef struct VkBufferDeviceAddressCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceAddress deviceAddress; +} VkBufferDeviceAddressCreateInfoEXT; + +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); +#endif +#endif + + +// VK_EXT_tooling_info is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_tooling_info 1 +#define VK_EXT_TOOLING_INFO_SPEC_VERSION 1 +#define VK_EXT_TOOLING_INFO_EXTENSION_NAME "VK_EXT_tooling_info" +typedef VkToolPurposeFlagBits VkToolPurposeFlagBitsEXT; + +typedef VkToolPurposeFlags VkToolPurposeFlagsEXT; + +typedef VkPhysicalDeviceToolProperties VkPhysicalDeviceToolPropertiesEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties); +#endif +#endif + + +// VK_EXT_separate_stencil_usage is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_separate_stencil_usage 1 +#define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1 +#define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage" +typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT; + + + +// VK_EXT_validation_features is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_validation_features 1 +#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 6 +#define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features" + +typedef enum VkValidationFeatureEnableEXT { + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0, + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1, + VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2, + VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3, + VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4, + VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureEnableEXT; + +typedef enum VkValidationFeatureDisableEXT { + VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0, + VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1, + VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2, + VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3, + VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4, + VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5, + VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6, + VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7, + VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureDisableEXT; +typedef struct VkValidationFeaturesEXT { + VkStructureType sType; + const void* pNext; + uint32_t enabledValidationFeatureCount; + const VkValidationFeatureEnableEXT* pEnabledValidationFeatures; + uint32_t disabledValidationFeatureCount; + const VkValidationFeatureDisableEXT* pDisabledValidationFeatures; +} VkValidationFeaturesEXT; + + + +// VK_NV_cooperative_matrix is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_cooperative_matrix 1 +#define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1 +#define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix" +typedef VkComponentTypeKHR VkComponentTypeNV; + +typedef VkScopeKHR VkScopeNV; + +typedef struct VkCooperativeMatrixPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeNV AType; + VkComponentTypeNV BType; + VkComponentTypeNV CType; + VkComponentTypeNV DType; + VkScopeNV scope; +} VkCooperativeMatrixPropertiesNV; + +typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; +} VkPhysicalDeviceCooperativeMatrixFeaturesNV; + +typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV { + VkStructureType sType; + void* pNext; + VkShaderStageFlags cooperativeMatrixSupportedStages; +} VkPhysicalDeviceCooperativeMatrixPropertiesNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesNV* pProperties); +#endif +#endif + + +// VK_NV_coverage_reduction_mode is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_coverage_reduction_mode 1 +#define VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION 1 +#define VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME "VK_NV_coverage_reduction_mode" + +typedef enum VkCoverageReductionModeNV { + VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0, + VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1, + VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoverageReductionModeNV; +typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV; +typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 coverageReductionMode; +} VkPhysicalDeviceCoverageReductionModeFeaturesNV; + +typedef struct VkPipelineCoverageReductionStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageReductionStateCreateFlagsNV flags; + VkCoverageReductionModeNV coverageReductionMode; +} VkPipelineCoverageReductionStateCreateInfoNV; + +typedef struct VkFramebufferMixedSamplesCombinationNV { + VkStructureType sType; + void* pNext; + VkCoverageReductionModeNV coverageReductionMode; + VkSampleCountFlagBits rasterizationSamples; + VkSampleCountFlags depthStencilSamples; + VkSampleCountFlags colorSamples; +} VkFramebufferMixedSamplesCombinationNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + VkPhysicalDevice physicalDevice, + uint32_t* pCombinationCount, + VkFramebufferMixedSamplesCombinationNV* pCombinations); +#endif +#endif + + +// VK_EXT_fragment_shader_interlock is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_fragment_shader_interlock 1 +#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1 +#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock" +typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShaderSampleInterlock; + VkBool32 fragmentShaderPixelInterlock; + VkBool32 fragmentShaderShadingRateInterlock; +} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; + + + +// VK_EXT_ycbcr_image_arrays is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_ycbcr_image_arrays 1 +#define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1 +#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays" +typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 ycbcrImageArrays; +} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; + + + +// VK_EXT_provoking_vertex is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_provoking_vertex 1 +#define VK_EXT_PROVOKING_VERTEX_SPEC_VERSION 1 +#define VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME "VK_EXT_provoking_vertex" + +typedef enum VkProvokingVertexModeEXT { + VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0, + VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1, + VK_PROVOKING_VERTEX_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkProvokingVertexModeEXT; +typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 provokingVertexLast; + VkBool32 transformFeedbackPreservesProvokingVertex; +} VkPhysicalDeviceProvokingVertexFeaturesEXT; + +typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 provokingVertexModePerPipeline; + VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex; +} VkPhysicalDeviceProvokingVertexPropertiesEXT; + +typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkProvokingVertexModeEXT provokingVertexMode; +} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT; + + + +// VK_EXT_headless_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_headless_surface 1 +#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1 +#define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface" +typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; +typedef struct VkHeadlessSurfaceCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkHeadlessSurfaceCreateFlagsEXT flags; +} VkHeadlessSurfaceCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT( + VkInstance instance, + const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif + + +// VK_EXT_line_rasterization is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_line_rasterization 1 +#define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1 +#define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization" +typedef VkLineRasterizationMode VkLineRasterizationModeEXT; + +typedef VkPhysicalDeviceLineRasterizationFeatures VkPhysicalDeviceLineRasterizationFeaturesEXT; + +typedef VkPhysicalDeviceLineRasterizationProperties VkPhysicalDeviceLineRasterizationPropertiesEXT; + +typedef VkPipelineRasterizationLineStateCreateInfo VkPipelineRasterizationLineStateCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern); +#endif +#endif + + +// VK_EXT_shader_atomic_float is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_atomic_float 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float" +typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferFloat32Atomics; + VkBool32 shaderBufferFloat32AtomicAdd; + VkBool32 shaderBufferFloat64Atomics; + VkBool32 shaderBufferFloat64AtomicAdd; + VkBool32 shaderSharedFloat32Atomics; + VkBool32 shaderSharedFloat32AtomicAdd; + VkBool32 shaderSharedFloat64Atomics; + VkBool32 shaderSharedFloat64AtomicAdd; + VkBool32 shaderImageFloat32Atomics; + VkBool32 shaderImageFloat32AtomicAdd; + VkBool32 sparseImageFloat32Atomics; + VkBool32 sparseImageFloat32AtomicAdd; +} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; + + + +// VK_EXT_host_query_reset is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_host_query_reset 1 +#define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1 +#define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset" +typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); +#endif +#endif + + +// VK_EXT_index_type_uint8 is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_index_type_uint8 1 +#define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1 +#define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8" +typedef VkPhysicalDeviceIndexTypeUint8Features VkPhysicalDeviceIndexTypeUint8FeaturesEXT; + + + +// VK_EXT_extended_dynamic_state is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_extended_dynamic_state 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state" +typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState; +} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp); +#endif +#endif + + +// VK_EXT_host_image_copy is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_host_image_copy 1 +#define VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION 1 +#define VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME "VK_EXT_host_image_copy" +typedef VkHostImageCopyFlagBits VkHostImageCopyFlagBitsEXT; + +typedef VkHostImageCopyFlags VkHostImageCopyFlagsEXT; + +typedef VkPhysicalDeviceHostImageCopyFeatures VkPhysicalDeviceHostImageCopyFeaturesEXT; + +typedef VkPhysicalDeviceHostImageCopyProperties VkPhysicalDeviceHostImageCopyPropertiesEXT; + +typedef VkMemoryToImageCopy VkMemoryToImageCopyEXT; + +typedef VkImageToMemoryCopy VkImageToMemoryCopyEXT; + +typedef VkCopyMemoryToImageInfo VkCopyMemoryToImageInfoEXT; + +typedef VkCopyImageToMemoryInfo VkCopyImageToMemoryInfoEXT; + +typedef VkCopyImageToImageInfo VkCopyImageToImageInfoEXT; + +typedef VkHostImageLayoutTransitionInfo VkHostImageLayoutTransitionInfoEXT; + +typedef VkSubresourceHostMemcpySize VkSubresourceHostMemcpySizeEXT; + +typedef VkHostImageCopyDevicePerformanceQuery VkHostImageCopyDevicePerformanceQueryEXT; + +typedef VkSubresourceLayout2 VkSubresourceLayout2EXT; + +typedef VkImageSubresource2 VkImageSubresource2EXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToImageEXT)(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToMemoryEXT)(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToImageEXT)(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo); +typedef VkResult (VKAPI_PTR *PFN_vkTransitionImageLayoutEXT)(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions); +typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImageEXT( + VkDevice device, + const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemoryEXT( + VkDevice device, + const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImageEXT( + VkDevice device, + const VkCopyImageToImageInfo* pCopyImageToImageInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayoutEXT( + VkDevice device, + uint32_t transitionCount, + const VkHostImageLayoutTransitionInfo* pTransitions); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT( + VkDevice device, + VkImage image, + const VkImageSubresource2* pSubresource, + VkSubresourceLayout2* pLayout); +#endif +#endif + + +// VK_EXT_map_memory_placed is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_map_memory_placed 1 +#define VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION 1 +#define VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME "VK_EXT_map_memory_placed" +typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 memoryMapPlaced; + VkBool32 memoryMapRangePlaced; + VkBool32 memoryUnmapReserve; +} VkPhysicalDeviceMapMemoryPlacedFeaturesEXT; + +typedef struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize minPlacedMemoryMapAlignment; +} VkPhysicalDeviceMapMemoryPlacedPropertiesEXT; + +typedef struct VkMemoryMapPlacedInfoEXT { + VkStructureType sType; + const void* pNext; + void* pPlacedAddress; +} VkMemoryMapPlacedInfoEXT; + + + +// VK_EXT_shader_atomic_float2 is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_atomic_float2 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1 +#define VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME "VK_EXT_shader_atomic_float2" +typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferFloat16Atomics; + VkBool32 shaderBufferFloat16AtomicAdd; + VkBool32 shaderBufferFloat16AtomicMinMax; + VkBool32 shaderBufferFloat32AtomicMinMax; + VkBool32 shaderBufferFloat64AtomicMinMax; + VkBool32 shaderSharedFloat16Atomics; + VkBool32 shaderSharedFloat16AtomicAdd; + VkBool32 shaderSharedFloat16AtomicMinMax; + VkBool32 shaderSharedFloat32AtomicMinMax; + VkBool32 shaderSharedFloat64AtomicMinMax; + VkBool32 shaderImageFloat32AtomicMinMax; + VkBool32 sparseImageFloat32AtomicMinMax; +} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; + + + +// VK_EXT_surface_maintenance1 is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_surface_maintenance1 1 +#define VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME "VK_EXT_surface_maintenance1" +typedef VkPresentScalingFlagBitsKHR VkPresentScalingFlagBitsEXT; + +typedef VkPresentScalingFlagsKHR VkPresentScalingFlagsEXT; + +typedef VkPresentGravityFlagBitsKHR VkPresentGravityFlagBitsEXT; + +typedef VkPresentGravityFlagsKHR VkPresentGravityFlagsEXT; + +typedef VkSurfacePresentModeKHR VkSurfacePresentModeEXT; + +typedef VkSurfacePresentScalingCapabilitiesKHR VkSurfacePresentScalingCapabilitiesEXT; + +typedef VkSurfacePresentModeCompatibilityKHR VkSurfacePresentModeCompatibilityEXT; + + + +// VK_EXT_swapchain_maintenance1 is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_swapchain_maintenance1 1 +#define VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION 1 +#define VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME "VK_EXT_swapchain_maintenance1" +typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT; + +typedef VkSwapchainPresentFenceInfoKHR VkSwapchainPresentFenceInfoEXT; + +typedef VkSwapchainPresentModesCreateInfoKHR VkSwapchainPresentModesCreateInfoEXT; + +typedef VkSwapchainPresentModeInfoKHR VkSwapchainPresentModeInfoEXT; + +typedef VkSwapchainPresentScalingCreateInfoKHR VkSwapchainPresentScalingCreateInfoEXT; + +typedef VkReleaseSwapchainImagesInfoKHR VkReleaseSwapchainImagesInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesEXT)(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT( + VkDevice device, + const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); +#endif +#endif + + +// VK_EXT_shader_demote_to_helper_invocation is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_demote_to_helper_invocation 1 +#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1 +#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation" +typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + + + +// VK_NV_device_generated_commands is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_device_generated_commands 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV) +#define VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3 +#define VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NV_device_generated_commands" + +typedef enum VkIndirectCommandsTokenTypeNV { + VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV = 1000135000, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV = 1000328000, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV = 1000428003, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV = 1000428004, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkIndirectCommandsTokenTypeNV; + +typedef enum VkIndirectStateFlagBitsNV { + VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001, + VK_INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkIndirectStateFlagBitsNV; +typedef VkFlags VkIndirectStateFlagsNV; + +typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV { + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0x00000002, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0x00000004, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkIndirectCommandsLayoutUsageFlagBitsNV; +typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV; +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxGraphicsShaderGroupCount; + uint32_t maxIndirectSequenceCount; + uint32_t maxIndirectCommandsTokenCount; + uint32_t maxIndirectCommandsStreamCount; + uint32_t maxIndirectCommandsTokenOffset; + uint32_t maxIndirectCommandsStreamStride; + uint32_t minSequencesCountBufferOffsetAlignment; + uint32_t minSequencesIndexBufferOffsetAlignment; + uint32_t minIndirectCommandsBufferOffsetAlignment; +} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 deviceGeneratedCommands; +} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + +typedef struct VkGraphicsShaderGroupCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; +} VkGraphicsShaderGroupCreateInfoNV; + +typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t groupCount; + const VkGraphicsShaderGroupCreateInfoNV* pGroups; + uint32_t pipelineCount; + const VkPipeline* pPipelines; +} VkGraphicsPipelineShaderGroupsCreateInfoNV; + +typedef struct VkBindShaderGroupIndirectCommandNV { + uint32_t groupIndex; +} VkBindShaderGroupIndirectCommandNV; + +typedef struct VkBindIndexBufferIndirectCommandNV { + VkDeviceAddress bufferAddress; + uint32_t size; + VkIndexType indexType; +} VkBindIndexBufferIndirectCommandNV; + +typedef struct VkBindVertexBufferIndirectCommandNV { + VkDeviceAddress bufferAddress; + uint32_t size; + uint32_t stride; +} VkBindVertexBufferIndirectCommandNV; + +typedef struct VkSetStateFlagsIndirectCommandNV { + uint32_t data; +} VkSetStateFlagsIndirectCommandNV; + +typedef struct VkIndirectCommandsStreamNV { + VkBuffer buffer; + VkDeviceSize offset; +} VkIndirectCommandsStreamNV; + +typedef struct VkIndirectCommandsLayoutTokenNV { + VkStructureType sType; + const void* pNext; + VkIndirectCommandsTokenTypeNV tokenType; + uint32_t stream; + uint32_t offset; + uint32_t vertexBindingUnit; + VkBool32 vertexDynamicStride; + VkPipelineLayout pushconstantPipelineLayout; + VkShaderStageFlags pushconstantShaderStageFlags; + uint32_t pushconstantOffset; + uint32_t pushconstantSize; + VkIndirectStateFlagsNV indirectStateFlags; + uint32_t indexTypeCount; + const VkIndexType* pIndexTypes; + const uint32_t* pIndexTypeValues; +} VkIndirectCommandsLayoutTokenNV; + +typedef struct VkIndirectCommandsLayoutCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkIndirectCommandsLayoutUsageFlagsNV flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t tokenCount; + const VkIndirectCommandsLayoutTokenNV* pTokens; + uint32_t streamCount; + const uint32_t* pStreamStrides; +} VkIndirectCommandsLayoutCreateInfoNV; + +typedef struct VkGeneratedCommandsInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline pipeline; + VkIndirectCommandsLayoutNV indirectCommandsLayout; + uint32_t streamCount; + const VkIndirectCommandsStreamNV* pStreams; + uint32_t sequencesCount; + VkBuffer preprocessBuffer; + VkDeviceSize preprocessOffset; + VkDeviceSize preprocessSize; + VkBuffer sequencesCountBuffer; + VkDeviceSize sequencesCountOffset; + VkBuffer sequencesIndexBuffer; + VkDeviceSize sequencesIndexOffset; +} VkGeneratedCommandsInfoNV; + +typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline pipeline; + VkIndirectCommandsLayoutNV indirectCommandsLayout; + uint32_t maxSequencesCount; +} VkGeneratedCommandsMemoryRequirementsInfoNV; + +typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex); +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline, + uint32_t groupIndex); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV( + VkDevice device, + VkIndirectCommandsLayoutNV indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); +#endif +#endif + + +// VK_NV_inherited_viewport_scissor is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_inherited_viewport_scissor 1 +#define VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION 1 +#define VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME "VK_NV_inherited_viewport_scissor" +typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 inheritedViewportScissor2D; +} VkPhysicalDeviceInheritedViewportScissorFeaturesNV; + +typedef struct VkCommandBufferInheritanceViewportScissorInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 viewportScissor2D; + uint32_t viewportDepthCount; + const VkViewport* pViewportDepths; +} VkCommandBufferInheritanceViewportScissorInfoNV; + + + +// VK_EXT_texel_buffer_alignment is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_texel_buffer_alignment 1 +#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1 +#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment" +typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 texelBufferAlignment; +} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; + +typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT; + + + +// VK_QCOM_render_pass_transform is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_render_pass_transform 1 +#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 5 +#define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform" +typedef struct VkRenderPassTransformBeginInfoQCOM { + VkStructureType sType; + const void* pNext; + VkSurfaceTransformFlagBitsKHR transform; +} VkRenderPassTransformBeginInfoQCOM; + +typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM { + VkStructureType sType; + const void* pNext; + VkSurfaceTransformFlagBitsKHR transform; + VkRect2D renderArea; +} VkCommandBufferInheritanceRenderPassTransformInfoQCOM; + + + +// VK_EXT_depth_bias_control is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_depth_bias_control 1 +#define VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME "VK_EXT_depth_bias_control" + +typedef enum VkDepthBiasRepresentationEXT { + VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT = 0, + VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT = 1, + VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT = 2, + VK_DEPTH_BIAS_REPRESENTATION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDepthBiasRepresentationEXT; +typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthBiasControl; + VkBool32 leastRepresentableValueForceUnormRepresentation; + VkBool32 floatRepresentation; + VkBool32 depthBiasExact; +} VkPhysicalDeviceDepthBiasControlFeaturesEXT; + +typedef struct VkDepthBiasInfoEXT { + VkStructureType sType; + const void* pNext; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; +} VkDepthBiasInfoEXT; + +typedef struct VkDepthBiasRepresentationInfoEXT { + VkStructureType sType; + const void* pNext; + VkDepthBiasRepresentationEXT depthBiasRepresentation; + VkBool32 depthBiasExact; +} VkDepthBiasRepresentationInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias2EXT)(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias2EXT( + VkCommandBuffer commandBuffer, + const VkDepthBiasInfoEXT* pDepthBiasInfo); +#endif +#endif + + +// VK_EXT_device_memory_report is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_device_memory_report 1 +#define VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION 2 +#define VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME "VK_EXT_device_memory_report" + +typedef enum VkDeviceMemoryReportEventTypeEXT { + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceMemoryReportEventTypeEXT; +typedef VkFlags VkDeviceMemoryReportFlagsEXT; +typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 deviceMemoryReport; +} VkPhysicalDeviceDeviceMemoryReportFeaturesEXT; + +typedef struct VkDeviceMemoryReportCallbackDataEXT { + VkStructureType sType; + void* pNext; + VkDeviceMemoryReportFlagsEXT flags; + VkDeviceMemoryReportEventTypeEXT type; + uint64_t memoryObjectId; + VkDeviceSize size; + VkObjectType objectType; + uint64_t objectHandle; + uint32_t heapIndex; +} VkDeviceMemoryReportCallbackDataEXT; + +typedef void (VKAPI_PTR *PFN_vkDeviceMemoryReportCallbackEXT)( + const VkDeviceMemoryReportCallbackDataEXT* pCallbackData, + void* pUserData); + +typedef struct VkDeviceDeviceMemoryReportCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceMemoryReportFlagsEXT flags; + PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback; + void* pUserData; +} VkDeviceDeviceMemoryReportCreateInfoEXT; + + + +// VK_EXT_acquire_drm_display is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_acquire_drm_display 1 +#define VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_drm_display" +typedef VkResult (VKAPI_PTR *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display); +typedef VkResult (VKAPI_PTR *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + VkDisplayKHR display); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + uint32_t connectorId, + VkDisplayKHR* display); +#endif +#endif + + +// VK_EXT_robustness2 is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_robustness2 1 +#define VK_EXT_ROBUSTNESS_2_SPEC_VERSION 1 +#define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2" +typedef VkPhysicalDeviceRobustness2FeaturesKHR VkPhysicalDeviceRobustness2FeaturesEXT; + +typedef VkPhysicalDeviceRobustness2PropertiesKHR VkPhysicalDeviceRobustness2PropertiesEXT; + + + +// VK_EXT_custom_border_color is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_custom_border_color 1 +#define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12 +#define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color" +typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxCustomBorderColorSamplers; +} VkPhysicalDeviceCustomBorderColorPropertiesEXT; + +typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 customBorderColors; + VkBool32 customBorderColorWithoutFormat; +} VkPhysicalDeviceCustomBorderColorFeaturesEXT; + + + +// VK_EXT_texture_compression_astc_3d is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_texture_compression_astc_3d 1 +#define VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_SPEC_VERSION 1 +#define VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME "VK_EXT_texture_compression_astc_3d" +typedef struct VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 textureCompressionASTC_3D; +} VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT; + + + +// VK_GOOGLE_user_type is a preprocessor guard. Do not pass it to API calls. +#define VK_GOOGLE_user_type 1 +#define VK_GOOGLE_USER_TYPE_SPEC_VERSION 1 +#define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type" + + +// VK_NV_present_barrier is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_present_barrier 1 +#define VK_NV_PRESENT_BARRIER_SPEC_VERSION 1 +#define VK_NV_PRESENT_BARRIER_EXTENSION_NAME "VK_NV_present_barrier" +typedef struct VkPhysicalDevicePresentBarrierFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrier; +} VkPhysicalDevicePresentBarrierFeaturesNV; + +typedef struct VkSurfaceCapabilitiesPresentBarrierNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrierSupported; +} VkSurfaceCapabilitiesPresentBarrierNV; + +typedef struct VkSwapchainPresentBarrierCreateInfoNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrierEnable; +} VkSwapchainPresentBarrierCreateInfoNV; + + + +// VK_EXT_private_data is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_private_data 1 +typedef VkPrivateDataSlot VkPrivateDataSlotEXT; + +#define VK_EXT_PRIVATE_DATA_SPEC_VERSION 1 +#define VK_EXT_PRIVATE_DATA_EXTENSION_NAME "VK_EXT_private_data" +typedef VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT; + +typedef VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataFeaturesEXT; + +typedef VkDevicePrivateDataCreateInfo VkDevicePrivateDataCreateInfoEXT; + +typedef VkPrivateDataSlotCreateInfo VkPrivateDataSlotCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +typedef void (VKAPI_PTR *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData); +#endif +#endif + + +// VK_EXT_pipeline_creation_cache_control is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_pipeline_creation_cache_control 1 +#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION 3 +#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME "VK_EXT_pipeline_creation_cache_control" +typedef VkPhysicalDevicePipelineCreationCacheControlFeatures VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT; + + + +// VK_NV_device_diagnostics_config is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_device_diagnostics_config 1 +#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION 2 +#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config" + +typedef enum VkDeviceDiagnosticsConfigFlagBitsNV { + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001, + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0x00000002, + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0x00000004, + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV = 0x00000008, + VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkDeviceDiagnosticsConfigFlagBitsNV; +typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV; +typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 diagnosticsConfig; +} VkPhysicalDeviceDiagnosticsConfigFeaturesNV; + +typedef struct VkDeviceDiagnosticsConfigCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceDiagnosticsConfigFlagsNV flags; +} VkDeviceDiagnosticsConfigCreateInfoNV; + + + +// VK_QCOM_render_pass_store_ops is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_render_pass_store_ops 1 +#define VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION 2 +#define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops" + + +// VK_QCOM_tile_shading is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_tile_shading 1 +#define VK_QCOM_TILE_SHADING_SPEC_VERSION 2 +#define VK_QCOM_TILE_SHADING_EXTENSION_NAME "VK_QCOM_tile_shading" + +typedef enum VkTileShadingRenderPassFlagBitsQCOM { + VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM = 0x00000001, + VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM = 0x00000002, + VK_TILE_SHADING_RENDER_PASS_FLAG_BITS_MAX_ENUM_QCOM = 0x7FFFFFFF +} VkTileShadingRenderPassFlagBitsQCOM; +typedef VkFlags VkTileShadingRenderPassFlagsQCOM; +typedef struct VkPhysicalDeviceTileShadingFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 tileShading; + VkBool32 tileShadingFragmentStage; + VkBool32 tileShadingColorAttachments; + VkBool32 tileShadingDepthAttachments; + VkBool32 tileShadingStencilAttachments; + VkBool32 tileShadingInputAttachments; + VkBool32 tileShadingSampledAttachments; + VkBool32 tileShadingPerTileDraw; + VkBool32 tileShadingPerTileDispatch; + VkBool32 tileShadingDispatchTile; + VkBool32 tileShadingApron; + VkBool32 tileShadingAnisotropicApron; + VkBool32 tileShadingAtomicOps; + VkBool32 tileShadingImageProcessing; +} VkPhysicalDeviceTileShadingFeaturesQCOM; + +typedef struct VkPhysicalDeviceTileShadingPropertiesQCOM { + VkStructureType sType; + void* pNext; + uint32_t maxApronSize; + VkBool32 preferNonCoherent; + VkExtent2D tileGranularity; + VkExtent2D maxTileShadingRate; +} VkPhysicalDeviceTileShadingPropertiesQCOM; + +typedef struct VkRenderPassTileShadingCreateInfoQCOM { + VkStructureType sType; + const void* pNext; + VkTileShadingRenderPassFlagsQCOM flags; + VkExtent2D tileApronSize; +} VkRenderPassTileShadingCreateInfoQCOM; + +typedef struct VkPerTileBeginInfoQCOM { + VkStructureType sType; + const void* pNext; +} VkPerTileBeginInfoQCOM; + +typedef struct VkPerTileEndInfoQCOM { + VkStructureType sType; + const void* pNext; +} VkPerTileEndInfoQCOM; + +typedef struct VkDispatchTileInfoQCOM { + VkStructureType sType; + const void* pNext; +} VkDispatchTileInfoQCOM; + +typedef void (VKAPI_PTR *PFN_vkCmdDispatchTileQCOM)(VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM* pDispatchTileInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBeginPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM( + VkCommandBuffer commandBuffer, + const VkDispatchTileInfoQCOM* pDispatchTileInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM( + VkCommandBuffer commandBuffer, + const VkPerTileBeginInfoQCOM* pPerTileBeginInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndPerTileExecutionQCOM( + VkCommandBuffer commandBuffer, + const VkPerTileEndInfoQCOM* pPerTileEndInfo); +#endif +#endif + + +// VK_NV_low_latency is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_low_latency 1 +#define VK_NV_LOW_LATENCY_SPEC_VERSION 1 +#define VK_NV_LOW_LATENCY_EXTENSION_NAME "VK_NV_low_latency" +typedef struct VkQueryLowLatencySupportNV { + VkStructureType sType; + const void* pNext; + void* pQueriedLowLatencyData; +} VkQueryLowLatencySupportNV; + + + +// VK_EXT_descriptor_buffer is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_descriptor_buffer 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) +#define VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION 1 +#define VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME "VK_EXT_descriptor_buffer" +typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 combinedImageSamplerDescriptorSingleArray; + VkBool32 bufferlessPushDescriptors; + VkBool32 allowSamplerImageViewPostSubmitCreation; + VkDeviceSize descriptorBufferOffsetAlignment; + uint32_t maxDescriptorBufferBindings; + uint32_t maxResourceDescriptorBufferBindings; + uint32_t maxSamplerDescriptorBufferBindings; + uint32_t maxEmbeddedImmutableSamplerBindings; + uint32_t maxEmbeddedImmutableSamplers; + size_t bufferCaptureReplayDescriptorDataSize; + size_t imageCaptureReplayDescriptorDataSize; + size_t imageViewCaptureReplayDescriptorDataSize; + size_t samplerCaptureReplayDescriptorDataSize; + size_t accelerationStructureCaptureReplayDescriptorDataSize; + size_t samplerDescriptorSize; + size_t combinedImageSamplerDescriptorSize; + size_t sampledImageDescriptorSize; + size_t storageImageDescriptorSize; + size_t uniformTexelBufferDescriptorSize; + size_t robustUniformTexelBufferDescriptorSize; + size_t storageTexelBufferDescriptorSize; + size_t robustStorageTexelBufferDescriptorSize; + size_t uniformBufferDescriptorSize; + size_t robustUniformBufferDescriptorSize; + size_t storageBufferDescriptorSize; + size_t robustStorageBufferDescriptorSize; + size_t inputAttachmentDescriptorSize; + size_t accelerationStructureDescriptorSize; + VkDeviceSize maxSamplerDescriptorBufferRange; + VkDeviceSize maxResourceDescriptorBufferRange; + VkDeviceSize samplerDescriptorBufferAddressSpaceSize; + VkDeviceSize resourceDescriptorBufferAddressSpaceSize; + VkDeviceSize descriptorBufferAddressSpaceSize; +} VkPhysicalDeviceDescriptorBufferPropertiesEXT; + +typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext; + size_t combinedImageSamplerDensityMapDescriptorSize; +} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + +typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 descriptorBuffer; + VkBool32 descriptorBufferCaptureReplay; + VkBool32 descriptorBufferImageLayoutIgnored; + VkBool32 descriptorBufferPushDescriptors; +} VkPhysicalDeviceDescriptorBufferFeaturesEXT; + +typedef struct VkDescriptorAddressInfoEXT { + VkStructureType sType; + void* pNext; + VkDeviceAddress address; + VkDeviceSize range; + VkFormat format; +} VkDescriptorAddressInfoEXT; + +typedef struct VkDescriptorBufferBindingInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceAddress address; + VkBufferUsageFlags usage; +} VkDescriptorBufferBindingInfoEXT; + +typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT; + +typedef union VkDescriptorDataEXT { + const VkSampler* pSampler; + const VkDescriptorImageInfo* pCombinedImageSampler; + const VkDescriptorImageInfo* pInputAttachmentImage; + const VkDescriptorImageInfo* pSampledImage; + const VkDescriptorImageInfo* pStorageImage; + const VkDescriptorAddressInfoEXT* pUniformTexelBuffer; + const VkDescriptorAddressInfoEXT* pStorageTexelBuffer; + const VkDescriptorAddressInfoEXT* pUniformBuffer; + const VkDescriptorAddressInfoEXT* pStorageBuffer; + VkDeviceAddress accelerationStructure; +} VkDescriptorDataEXT; + +typedef struct VkDescriptorGetInfoEXT { + VkStructureType sType; + const void* pNext; + VkDescriptorType type; + VkDescriptorDataEXT data; +} VkDescriptorGetInfoEXT; + +typedef struct VkBufferCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferCaptureDescriptorDataInfoEXT; + +typedef struct VkImageCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageCaptureDescriptorDataInfoEXT; + +typedef struct VkImageViewCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageView imageView; +} VkImageViewCaptureDescriptorDataInfoEXT; + +typedef struct VkSamplerCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkSampler sampler; +} VkSamplerCaptureDescriptorDataInfoEXT; + +typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT { + VkStructureType sType; + const void* pNext; + const void* opaqueCaptureDescriptorData; +} VkOpaqueCaptureDescriptorDataCreateInfoEXT; + +typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR accelerationStructure; + VkAccelerationStructureNV accelerationStructureNV; +} VkAccelerationStructureCaptureDescriptorDataInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos); +typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets); +typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set); +typedef VkResult (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT( + VkDevice device, + VkDescriptorSetLayout layout, + VkDeviceSize* pLayoutSizeInBytes); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT( + VkDevice device, + VkDescriptorSetLayout layout, + uint32_t binding, + VkDeviceSize* pOffset); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT( + VkDevice device, + const VkDescriptorGetInfoEXT* pDescriptorInfo, + size_t dataSize, + void* pDescriptor); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const uint32_t* pBufferIndices, + const VkDeviceSize* pOffsets); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkBufferCaptureDescriptorDataInfoEXT* pInfo, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageCaptureDescriptorDataInfoEXT* pInfo, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, + void* pData); +#endif +#endif + + +// VK_EXT_graphics_pipeline_library is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_graphics_pipeline_library 1 +#define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION 1 +#define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME "VK_EXT_graphics_pipeline_library" + +typedef enum VkGraphicsPipelineLibraryFlagBitsEXT { + VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT = 0x00000001, + VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT = 0x00000002, + VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT = 0x00000004, + VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT = 0x00000008, + VK_GRAPHICS_PIPELINE_LIBRARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkGraphicsPipelineLibraryFlagBitsEXT; +typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT; +typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 graphicsPipelineLibrary; +} VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + +typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 graphicsPipelineLibraryFastLinking; + VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration; +} VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + +typedef struct VkGraphicsPipelineLibraryCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkGraphicsPipelineLibraryFlagsEXT flags; +} VkGraphicsPipelineLibraryCreateInfoEXT; + + + +// VK_AMD_shader_early_and_late_fragment_tests is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_shader_early_and_late_fragment_tests 1 +#define VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION 1 +#define VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME "VK_AMD_shader_early_and_late_fragment_tests" +typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + VkStructureType sType; + void* pNext; + VkBool32 shaderEarlyAndLateFragmentTests; +} VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + + + +// VK_NV_fragment_shading_rate_enums is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_fragment_shading_rate_enums 1 +#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION 1 +#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME "VK_NV_fragment_shading_rate_enums" + +typedef enum VkFragmentShadingRateTypeNV { + VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0, + VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1, + VK_FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkFragmentShadingRateTypeNV; + +typedef enum VkFragmentShadingRateNV { + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10, + VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11, + VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12, + VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13, + VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14, + VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15, + VK_FRAGMENT_SHADING_RATE_MAX_ENUM_NV = 0x7FFFFFFF +} VkFragmentShadingRateNV; +typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShadingRateEnums; + VkBool32 supersampleFragmentShadingRates; + VkBool32 noInvocationFragmentShadingRates; +} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + +typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + VkStructureType sType; + void* pNext; + VkSampleCountFlagBits maxFragmentShadingRateInvocationCount; +} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + +typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkFragmentShadingRateTypeNV shadingRateType; + VkFragmentShadingRateNV shadingRate; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; +} VkPipelineFragmentShadingRateEnumStateCreateInfoNV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV( + VkCommandBuffer commandBuffer, + VkFragmentShadingRateNV shadingRate, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); +#endif +#endif + + +// VK_NV_ray_tracing_motion_blur is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_ray_tracing_motion_blur 1 +#define VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION 1 +#define VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME "VK_NV_ray_tracing_motion_blur" + +typedef enum VkAccelerationStructureMotionInstanceTypeNV { + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0, + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1, + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2, + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkAccelerationStructureMotionInstanceTypeNV; +typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV; +typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV; +typedef union VkDeviceOrHostAddressConstKHR { + VkDeviceAddress deviceAddress; + const void* hostAddress; +} VkDeviceOrHostAddressConstKHR; + +typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR vertexData; +} VkAccelerationStructureGeometryMotionTrianglesDataNV; + +typedef struct VkAccelerationStructureMotionInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t maxInstances; + VkAccelerationStructureMotionInfoFlagsNV flags; +} VkAccelerationStructureMotionInfoNV; + +typedef struct VkAccelerationStructureMatrixMotionInstanceNV { + VkTransformMatrixKHR transformT0; + VkTransformMatrixKHR transformT1; + uint32_t instanceCustomIndex:24; + uint32_t mask:8; + uint32_t instanceShaderBindingTableRecordOffset:24; + VkGeometryInstanceFlagsKHR flags:8; + uint64_t accelerationStructureReference; +} VkAccelerationStructureMatrixMotionInstanceNV; + +typedef struct VkSRTDataNV { + float sx; + float a; + float b; + float pvx; + float sy; + float c; + float pvy; + float sz; + float pvz; + float qx; + float qy; + float qz; + float qw; + float tx; + float ty; + float tz; +} VkSRTDataNV; + +typedef struct VkAccelerationStructureSRTMotionInstanceNV { + VkSRTDataNV transformT0; + VkSRTDataNV transformT1; + uint32_t instanceCustomIndex:24; + uint32_t mask:8; + uint32_t instanceShaderBindingTableRecordOffset:24; + VkGeometryInstanceFlagsKHR flags:8; + uint64_t accelerationStructureReference; +} VkAccelerationStructureSRTMotionInstanceNV; + +typedef union VkAccelerationStructureMotionInstanceDataNV { + VkAccelerationStructureInstanceKHR staticInstance; + VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance; + VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance; +} VkAccelerationStructureMotionInstanceDataNV; + +typedef struct VkAccelerationStructureMotionInstanceNV { + VkAccelerationStructureMotionInstanceTypeNV type; + VkAccelerationStructureMotionInstanceFlagsNV flags; + VkAccelerationStructureMotionInstanceDataNV data; +} VkAccelerationStructureMotionInstanceNV; + +typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingMotionBlur; + VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect; +} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV; + + + +// VK_EXT_ycbcr_2plane_444_formats is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_ycbcr_2plane_444_formats 1 +#define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1 +#define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats" +typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 ycbcr2plane444Formats; +} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + + + +// VK_EXT_fragment_density_map2 is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_fragment_density_map2 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME "VK_EXT_fragment_density_map2" +typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMapDeferred; +} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT; + +typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 subsampledLoads; + VkBool32 subsampledCoarseReconstructionEarlyAccess; + uint32_t maxSubsampledArrayLayers; + uint32_t maxDescriptorSetSubsampledSamplers; +} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT; + + + +// VK_QCOM_rotated_copy_commands is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_rotated_copy_commands 1 +#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 2 +#define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands" +typedef struct VkCopyCommandTransformInfoQCOM { + VkStructureType sType; + const void* pNext; + VkSurfaceTransformFlagBitsKHR transform; +} VkCopyCommandTransformInfoQCOM; + + + +// VK_EXT_image_robustness is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_image_robustness 1 +#define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1 +#define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness" +typedef VkPhysicalDeviceImageRobustnessFeatures VkPhysicalDeviceImageRobustnessFeaturesEXT; + + + +// VK_EXT_image_compression_control is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_image_compression_control 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME "VK_EXT_image_compression_control" + +typedef enum VkImageCompressionFlagBitsEXT { + VK_IMAGE_COMPRESSION_DEFAULT_EXT = 0, + VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT = 0x00000001, + VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT = 0x00000002, + VK_IMAGE_COMPRESSION_DISABLED_EXT = 0x00000004, + VK_IMAGE_COMPRESSION_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkImageCompressionFlagBitsEXT; +typedef VkFlags VkImageCompressionFlagsEXT; + +typedef enum VkImageCompressionFixedRateFlagBitsEXT { + VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT = 0, + VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT = 0x00000001, + VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT = 0x00000002, + VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT = 0x00000004, + VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT = 0x00000008, + VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT = 0x00000010, + VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT = 0x00000020, + VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT = 0x00000040, + VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT = 0x00000080, + VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT = 0x00000100, + VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT = 0x00000200, + VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT = 0x00000400, + VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT = 0x00000800, + VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT = 0x00001000, + VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT = 0x00002000, + VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT = 0x00004000, + VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT = 0x00008000, + VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT = 0x00010000, + VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT = 0x00020000, + VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT = 0x00040000, + VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT = 0x00080000, + VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT = 0x00100000, + VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT = 0x00200000, + VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT = 0x00400000, + VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT = 0x00800000, + VK_IMAGE_COMPRESSION_FIXED_RATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkImageCompressionFixedRateFlagBitsEXT; +typedef VkFlags VkImageCompressionFixedRateFlagsEXT; +typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageCompressionControl; +} VkPhysicalDeviceImageCompressionControlFeaturesEXT; + +typedef struct VkImageCompressionControlEXT { + VkStructureType sType; + const void* pNext; + VkImageCompressionFlagsEXT flags; + uint32_t compressionControlPlaneCount; + VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags; +} VkImageCompressionControlEXT; + +typedef struct VkImageCompressionPropertiesEXT { + VkStructureType sType; + void* pNext; + VkImageCompressionFlagsEXT imageCompressionFlags; + VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags; +} VkImageCompressionPropertiesEXT; + + + +// VK_EXT_attachment_feedback_loop_layout is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_attachment_feedback_loop_layout 1 +#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION 2 +#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME "VK_EXT_attachment_feedback_loop_layout" +typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 attachmentFeedbackLoopLayout; +} VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + + + +// VK_EXT_4444_formats is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_4444_formats 1 +#define VK_EXT_4444_FORMATS_SPEC_VERSION 1 +#define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats" +typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 formatA4R4G4B4; + VkBool32 formatA4B4G4R4; +} VkPhysicalDevice4444FormatsFeaturesEXT; + + + +// VK_EXT_device_fault is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_device_fault 1 +#define VK_EXT_DEVICE_FAULT_SPEC_VERSION 2 +#define VK_EXT_DEVICE_FAULT_EXTENSION_NAME "VK_EXT_device_fault" + +typedef enum VkDeviceFaultAddressTypeEXT { + VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0, + VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1, + VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2, + VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6, + VK_DEVICE_FAULT_ADDRESS_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceFaultAddressTypeEXT; + +typedef enum VkDeviceFaultVendorBinaryHeaderVersionEXT { + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = 1, + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceFaultVendorBinaryHeaderVersionEXT; +typedef struct VkPhysicalDeviceFaultFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 deviceFault; + VkBool32 deviceFaultVendorBinary; +} VkPhysicalDeviceFaultFeaturesEXT; + +typedef struct VkDeviceFaultCountsEXT { + VkStructureType sType; + void* pNext; + uint32_t addressInfoCount; + uint32_t vendorInfoCount; + VkDeviceSize vendorBinarySize; +} VkDeviceFaultCountsEXT; + +typedef struct VkDeviceFaultAddressInfoEXT { + VkDeviceFaultAddressTypeEXT addressType; + VkDeviceAddress reportedAddress; + VkDeviceSize addressPrecision; +} VkDeviceFaultAddressInfoEXT; + +typedef struct VkDeviceFaultVendorInfoEXT { + char description[VK_MAX_DESCRIPTION_SIZE]; + uint64_t vendorFaultCode; + uint64_t vendorFaultData; +} VkDeviceFaultVendorInfoEXT; + +typedef struct VkDeviceFaultInfoEXT { + VkStructureType sType; + void* pNext; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkDeviceFaultAddressInfoEXT* pAddressInfos; + VkDeviceFaultVendorInfoEXT* pVendorInfos; + void* pVendorBinaryData; +} VkDeviceFaultInfoEXT; + +typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT { + uint32_t headerSize; + VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint32_t driverVersion; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + uint32_t applicationNameOffset; + uint32_t applicationVersion; + uint32_t engineNameOffset; + uint32_t engineVersion; + uint32_t apiVersion; +} VkDeviceFaultVendorBinaryHeaderVersionOneEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT( + VkDevice device, + VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo); +#endif +#endif + + +// VK_ARM_rasterization_order_attachment_access is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_rasterization_order_attachment_access 1 +#define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1 +#define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_ARM_rasterization_order_attachment_access" +typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 rasterizationOrderColorAttachmentAccess; + VkBool32 rasterizationOrderDepthAttachmentAccess; + VkBool32 rasterizationOrderStencilAttachmentAccess; +} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + +typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; + + + +// VK_EXT_rgba10x6_formats is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_rgba10x6_formats 1 +#define VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION 1 +#define VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME "VK_EXT_rgba10x6_formats" +typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 formatRgba10x6WithoutYCbCrSampler; +} VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT; + + + +// VK_VALVE_mutable_descriptor_type is a preprocessor guard. Do not pass it to API calls. +#define VK_VALVE_mutable_descriptor_type 1 +#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1 +#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type" +typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 mutableDescriptorType; +} VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT; + +typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + +typedef struct VkMutableDescriptorTypeListEXT { + uint32_t descriptorTypeCount; + const VkDescriptorType* pDescriptorTypes; +} VkMutableDescriptorTypeListEXT; + +typedef VkMutableDescriptorTypeListEXT VkMutableDescriptorTypeListVALVE; + +typedef struct VkMutableDescriptorTypeCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t mutableDescriptorTypeListCount; + const VkMutableDescriptorTypeListEXT* pMutableDescriptorTypeLists; +} VkMutableDescriptorTypeCreateInfoEXT; + +typedef VkMutableDescriptorTypeCreateInfoEXT VkMutableDescriptorTypeCreateInfoVALVE; + + + +// VK_EXT_vertex_input_dynamic_state is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_vertex_input_dynamic_state 1 +#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2 +#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state" +typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexInputDynamicState; +} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; + +typedef struct VkVertexInputBindingDescription2EXT { + VkStructureType sType; + void* pNext; + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; + uint32_t divisor; +} VkVertexInputBindingDescription2EXT; + +typedef struct VkVertexInputAttributeDescription2EXT { + VkStructureType sType; + void* pNext; + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription2EXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT( + VkCommandBuffer commandBuffer, + uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); +#endif +#endif + + +// VK_EXT_physical_device_drm is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_physical_device_drm 1 +#define VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION 1 +#define VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME "VK_EXT_physical_device_drm" +typedef struct VkPhysicalDeviceDrmPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 hasPrimary; + VkBool32 hasRender; + int64_t primaryMajor; + int64_t primaryMinor; + int64_t renderMajor; + int64_t renderMinor; +} VkPhysicalDeviceDrmPropertiesEXT; + + + +// VK_EXT_device_address_binding_report is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_device_address_binding_report 1 +#define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION 1 +#define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME "VK_EXT_device_address_binding_report" + +typedef enum VkDeviceAddressBindingTypeEXT { + VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT = 0, + VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT = 1, + VK_DEVICE_ADDRESS_BINDING_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceAddressBindingTypeEXT; + +typedef enum VkDeviceAddressBindingFlagBitsEXT { + VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT = 0x00000001, + VK_DEVICE_ADDRESS_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceAddressBindingFlagBitsEXT; +typedef VkFlags VkDeviceAddressBindingFlagsEXT; +typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 reportAddressBinding; +} VkPhysicalDeviceAddressBindingReportFeaturesEXT; + +typedef struct VkDeviceAddressBindingCallbackDataEXT { + VkStructureType sType; + void* pNext; + VkDeviceAddressBindingFlagsEXT flags; + VkDeviceAddress baseAddress; + VkDeviceSize size; + VkDeviceAddressBindingTypeEXT bindingType; +} VkDeviceAddressBindingCallbackDataEXT; + + + +// VK_EXT_depth_clip_control is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_depth_clip_control 1 +#define VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clip_control" +typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClipControl; +} VkPhysicalDeviceDepthClipControlFeaturesEXT; + +typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 negativeOneToOne; +} VkPipelineViewportDepthClipControlCreateInfoEXT; + + + +// VK_EXT_primitive_topology_list_restart is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_primitive_topology_list_restart 1 +#define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION 1 +#define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME "VK_EXT_primitive_topology_list_restart" +typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 primitiveTopologyListRestart; + VkBool32 primitiveTopologyPatchListRestart; +} VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + + + +// VK_EXT_present_mode_fifo_latest_ready is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_present_mode_fifo_latest_ready 1 +#define VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION 1 +#define VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME "VK_EXT_present_mode_fifo_latest_ready" +typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT; + + + +// VK_HUAWEI_subpass_shading is a preprocessor guard. Do not pass it to API calls. +#define VK_HUAWEI_subpass_shading 1 +#define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 3 +#define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading" +typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI { + VkStructureType sType; + void* pNext; + VkRenderPass renderPass; + uint32_t subpass; +} VkSubpassShadingPipelineCreateInfoHUAWEI; + +typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 subpassShading; +} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI; + +typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI { + VkStructureType sType; + void* pNext; + uint32_t maxSubpassShadingWorkgroupSizeAspectRatio; +} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI; + +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize); +typedef void (VKAPI_PTR *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( + VkDevice device, + VkRenderPass renderpass, + VkExtent2D* pMaxWorkgroupSize); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI( + VkCommandBuffer commandBuffer); +#endif +#endif + + +// VK_HUAWEI_invocation_mask is a preprocessor guard. Do not pass it to API calls. +#define VK_HUAWEI_invocation_mask 1 +#define VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION 1 +#define VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME "VK_HUAWEI_invocation_mask" +typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 invocationMask; +} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI; + +typedef void (VKAPI_PTR *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout); +#endif +#endif + + +// VK_NV_external_memory_rdma is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_external_memory_rdma 1 +typedef void* VkRemoteAddressNV; +#define VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME "VK_NV_external_memory_rdma" +typedef struct VkMemoryGetRemoteAddressInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetRemoteAddressInfoNV; + +typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 externalMemoryRDMA; +} VkPhysicalDeviceExternalMemoryRDMAFeaturesNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV( + VkDevice device, + const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, + VkRemoteAddressNV* pAddress); +#endif +#endif + + +// VK_EXT_pipeline_properties is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_pipeline_properties 1 +#define VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME "VK_EXT_pipeline_properties" +typedef VkPipelineInfoKHR VkPipelineInfoEXT; + +typedef struct VkPipelinePropertiesIdentifierEXT { + VkStructureType sType; + void* pNext; + uint8_t pipelineIdentifier[VK_UUID_SIZE]; +} VkPipelinePropertiesIdentifierEXT; + +typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelinePropertiesIdentifier; +} VkPhysicalDevicePipelinePropertiesFeaturesEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT( + VkDevice device, + const VkPipelineInfoEXT* pPipelineInfo, + VkBaseOutStructure* pPipelineProperties); +#endif +#endif + + +// VK_EXT_frame_boundary is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_frame_boundary 1 +#define VK_EXT_FRAME_BOUNDARY_SPEC_VERSION 1 +#define VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME "VK_EXT_frame_boundary" + +typedef enum VkFrameBoundaryFlagBitsEXT { + VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT = 0x00000001, + VK_FRAME_BOUNDARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkFrameBoundaryFlagBitsEXT; +typedef VkFlags VkFrameBoundaryFlagsEXT; +typedef struct VkPhysicalDeviceFrameBoundaryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 frameBoundary; +} VkPhysicalDeviceFrameBoundaryFeaturesEXT; + +typedef struct VkFrameBoundaryEXT { + VkStructureType sType; + const void* pNext; + VkFrameBoundaryFlagsEXT flags; + uint64_t frameID; + uint32_t imageCount; + const VkImage* pImages; + uint32_t bufferCount; + const VkBuffer* pBuffers; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkFrameBoundaryEXT; + + + +// VK_EXT_multisampled_render_to_single_sampled is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_multisampled_render_to_single_sampled 1 +#define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION 1 +#define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME "VK_EXT_multisampled_render_to_single_sampled" +typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 multisampledRenderToSingleSampled; +} VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + +typedef struct VkSubpassResolvePerformanceQueryEXT { + VkStructureType sType; + void* pNext; + VkBool32 optimal; +} VkSubpassResolvePerformanceQueryEXT; + +typedef struct VkMultisampledRenderToSingleSampledInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 multisampledRenderToSingleSampledEnable; + VkSampleCountFlagBits rasterizationSamples; +} VkMultisampledRenderToSingleSampledInfoEXT; + + + +// VK_EXT_extended_dynamic_state2 is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_extended_dynamic_state2 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2" +typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState2; + VkBool32 extendedDynamicState2LogicOp; + VkBool32 extendedDynamicState2PatchControlPoints; +} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp); +typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT( + VkCommandBuffer commandBuffer, + uint32_t patchControlPoints); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT( + VkCommandBuffer commandBuffer, + VkLogicOp logicOp); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable); +#endif +#endif + + +// VK_EXT_color_write_enable is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_color_write_enable 1 +#define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1 +#define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable" +typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 colorWriteEnable; +} VkPhysicalDeviceColorWriteEnableFeaturesEXT; + +typedef struct VkPipelineColorWriteCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkBool32* pColorWriteEnables; +} VkPipelineColorWriteCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkBool32* pColorWriteEnables); +#endif +#endif + + +// VK_EXT_primitives_generated_query is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_primitives_generated_query 1 +#define VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION 1 +#define VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME "VK_EXT_primitives_generated_query" +typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 primitivesGeneratedQuery; + VkBool32 primitivesGeneratedQueryWithRasterizerDiscard; + VkBool32 primitivesGeneratedQueryWithNonZeroStreams; +} VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; + + + +// VK_EXT_global_priority_query is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_global_priority_query 1 +#define VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION 1 +#define VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME "VK_EXT_global_priority_query" +#define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT VK_MAX_GLOBAL_PRIORITY_SIZE +typedef VkPhysicalDeviceGlobalPriorityQueryFeatures VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT; + +typedef VkQueueFamilyGlobalPriorityProperties VkQueueFamilyGlobalPriorityPropertiesEXT; + + + +// VK_VALVE_video_encode_rgb_conversion is a preprocessor guard. Do not pass it to API calls. +#define VK_VALVE_video_encode_rgb_conversion 1 +#define VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION 1 +#define VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME "VK_VALVE_video_encode_rgb_conversion" + +typedef enum VkVideoEncodeRgbModelConversionFlagBitsVALVE { + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE = 0x00000001, + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE = 0x00000002, + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE = 0x00000004, + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE = 0x00000008, + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE = 0x00000010, + VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF +} VkVideoEncodeRgbModelConversionFlagBitsVALVE; +typedef VkFlags VkVideoEncodeRgbModelConversionFlagsVALVE; + +typedef enum VkVideoEncodeRgbRangeCompressionFlagBitsVALVE { + VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE = 0x00000001, + VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE = 0x00000002, + VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF +} VkVideoEncodeRgbRangeCompressionFlagBitsVALVE; +typedef VkFlags VkVideoEncodeRgbRangeCompressionFlagsVALVE; + +typedef enum VkVideoEncodeRgbChromaOffsetFlagBitsVALVE { + VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE = 0x00000001, + VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE = 0x00000002, + VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF +} VkVideoEncodeRgbChromaOffsetFlagBitsVALVE; +typedef VkFlags VkVideoEncodeRgbChromaOffsetFlagsVALVE; +typedef struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE { + VkStructureType sType; + void* pNext; + VkBool32 videoEncodeRgbConversion; +} VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; + +typedef struct VkVideoEncodeRgbConversionCapabilitiesVALVE { + VkStructureType sType; + void* pNext; + VkVideoEncodeRgbModelConversionFlagsVALVE rgbModels; + VkVideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges; + VkVideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets; + VkVideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets; +} VkVideoEncodeRgbConversionCapabilitiesVALVE; + +typedef struct VkVideoEncodeProfileRgbConversionInfoVALVE { + VkStructureType sType; + const void* pNext; + VkBool32 performEncodeRgbConversion; +} VkVideoEncodeProfileRgbConversionInfoVALVE; + +typedef struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE { + VkStructureType sType; + const void* pNext; + VkVideoEncodeRgbModelConversionFlagBitsVALVE rgbModel; + VkVideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange; + VkVideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset; + VkVideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset; +} VkVideoEncodeSessionRgbConversionCreateInfoVALVE; + + + +// VK_EXT_image_view_min_lod is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_image_view_min_lod 1 +#define VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION 1 +#define VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME "VK_EXT_image_view_min_lod" +typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 minLod; +} VkPhysicalDeviceImageViewMinLodFeaturesEXT; + +typedef struct VkImageViewMinLodCreateInfoEXT { + VkStructureType sType; + const void* pNext; + float minLod; +} VkImageViewMinLodCreateInfoEXT; + + + +// VK_EXT_multi_draw is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_multi_draw 1 +#define VK_EXT_MULTI_DRAW_SPEC_VERSION 1 +#define VK_EXT_MULTI_DRAW_EXTENSION_NAME "VK_EXT_multi_draw" +typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 multiDraw; +} VkPhysicalDeviceMultiDrawFeaturesEXT; + +typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxMultiDrawCount; +} VkPhysicalDeviceMultiDrawPropertiesEXT; + +typedef struct VkMultiDrawInfoEXT { + uint32_t firstVertex; + uint32_t vertexCount; +} VkMultiDrawInfoEXT; + +typedef struct VkMultiDrawIndexedInfoEXT { + uint32_t firstIndex; + uint32_t indexCount; + int32_t vertexOffset; +} VkMultiDrawIndexedInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawInfoEXT* pVertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawIndexedInfoEXT* pIndexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + const int32_t* pVertexOffset); +#endif +#endif + + +// VK_EXT_image_2d_view_of_3d is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_image_2d_view_of_3d 1 +#define VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION 1 +#define VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_2d_view_of_3d" +typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 image2DViewOf3D; + VkBool32 sampler2DViewOf3D; +} VkPhysicalDeviceImage2DViewOf3DFeaturesEXT; + + + +// VK_EXT_shader_tile_image is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_tile_image 1 +#define VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION 1 +#define VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME "VK_EXT_shader_tile_image" +typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderTileImageColorReadAccess; + VkBool32 shaderTileImageDepthReadAccess; + VkBool32 shaderTileImageStencilReadAccess; +} VkPhysicalDeviceShaderTileImageFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderTileImageCoherentReadAccelerated; + VkBool32 shaderTileImageReadSampleFromPixelRateInvocation; + VkBool32 shaderTileImageReadFromHelperInvocation; +} VkPhysicalDeviceShaderTileImagePropertiesEXT; + + + +// VK_EXT_opacity_micromap is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_opacity_micromap 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkMicromapEXT) +#define VK_EXT_OPACITY_MICROMAP_SPEC_VERSION 2 +#define VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME "VK_EXT_opacity_micromap" + +typedef enum VkMicromapTypeEXT { + VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT = 0, +#ifdef VK_ENABLE_BETA_EXTENSIONS + VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV = 1000397000, +#endif + VK_MICROMAP_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkMicromapTypeEXT; + +typedef enum VkBuildMicromapModeEXT { + VK_BUILD_MICROMAP_MODE_BUILD_EXT = 0, + VK_BUILD_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBuildMicromapModeEXT; + +typedef enum VkCopyMicromapModeEXT { + VK_COPY_MICROMAP_MODE_CLONE_EXT = 0, + VK_COPY_MICROMAP_MODE_SERIALIZE_EXT = 1, + VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT = 2, + VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3, + VK_COPY_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkCopyMicromapModeEXT; + +typedef enum VkOpacityMicromapFormatEXT { + VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1, + VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2, + VK_OPACITY_MICROMAP_FORMAT_MAX_ENUM_EXT = 0x7FFFFFFF +} VkOpacityMicromapFormatEXT; + +typedef enum VkOpacityMicromapSpecialIndexEXT { + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV = -5, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_MAX_ENUM_EXT = 0x7FFFFFFF +} VkOpacityMicromapSpecialIndexEXT; + +typedef enum VkAccelerationStructureCompatibilityKHR { + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0, + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1, + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureCompatibilityKHR; + +typedef enum VkAccelerationStructureBuildTypeKHR { + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureBuildTypeKHR; + +typedef enum VkBuildMicromapFlagBitsEXT { + VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT = 0x00000001, + VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT = 0x00000002, + VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT = 0x00000004, + VK_BUILD_MICROMAP_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBuildMicromapFlagBitsEXT; +typedef VkFlags VkBuildMicromapFlagsEXT; + +typedef enum VkMicromapCreateFlagBitsEXT { + VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000001, + VK_MICROMAP_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkMicromapCreateFlagBitsEXT; +typedef VkFlags VkMicromapCreateFlagsEXT; +typedef struct VkMicromapUsageEXT { + uint32_t count; + uint32_t subdivisionLevel; + uint32_t format; +} VkMicromapUsageEXT; + +typedef union VkDeviceOrHostAddressKHR { + VkDeviceAddress deviceAddress; + void* hostAddress; +} VkDeviceOrHostAddressKHR; + +typedef struct VkMicromapBuildInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapTypeEXT type; + VkBuildMicromapFlagsEXT flags; + VkBuildMicromapModeEXT mode; + VkMicromapEXT dstMicromap; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts; + const VkMicromapUsageEXT* const* ppUsageCounts; + VkDeviceOrHostAddressConstKHR data; + VkDeviceOrHostAddressKHR scratchData; + VkDeviceOrHostAddressConstKHR triangleArray; + VkDeviceSize triangleArrayStride; +} VkMicromapBuildInfoEXT; + +typedef struct VkMicromapCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapCreateFlagsEXT createFlags; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; + VkMicromapTypeEXT type; + VkDeviceAddress deviceAddress; +} VkMicromapCreateInfoEXT; + +typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 micromap; + VkBool32 micromapCaptureReplay; + VkBool32 micromapHostCommands; +} VkPhysicalDeviceOpacityMicromapFeaturesEXT; + +typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxOpacity2StateSubdivisionLevel; + uint32_t maxOpacity4StateSubdivisionLevel; +} VkPhysicalDeviceOpacityMicromapPropertiesEXT; + +typedef struct VkMicromapVersionInfoEXT { + VkStructureType sType; + const void* pNext; + const uint8_t* pVersionData; +} VkMicromapVersionInfoEXT; + +typedef struct VkCopyMicromapToMemoryInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapEXT src; + VkDeviceOrHostAddressKHR dst; + VkCopyMicromapModeEXT mode; +} VkCopyMicromapToMemoryInfoEXT; + +typedef struct VkCopyMemoryToMicromapInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR src; + VkMicromapEXT dst; + VkCopyMicromapModeEXT mode; +} VkCopyMemoryToMicromapInfoEXT; + +typedef struct VkCopyMicromapInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapEXT src; + VkMicromapEXT dst; + VkCopyMicromapModeEXT mode; +} VkCopyMicromapInfoEXT; + +typedef struct VkMicromapBuildSizesInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceSize micromapSize; + VkDeviceSize buildScratchSize; + VkBool32 discardable; +} VkMicromapBuildSizesInfoEXT; + +typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT { + VkStructureType sType; + void* pNext; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts; + const VkMicromapUsageEXT* const* ppUsageCounts; + VkMicromapEXT micromap; +} VkAccelerationStructureTrianglesOpacityMicromapEXT; + +typedef struct VkMicromapTriangleEXT { + uint32_t dataOffset; + uint16_t subdivisionLevel; + uint16_t format; +} VkMicromapTriangleEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); +typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult (VKAPI_PTR *PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void (VKAPI_PTR *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMicromapEXT( + VkDevice device, + const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkMicromapEXT* pMicromap); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyMicromapEXT( + VkDevice device, + VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT( + VkDevice device, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapInfoEXT* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT( + VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT( + VkDevice device, + const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo); +#endif +#endif + + +// VK_EXT_load_store_op_none is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_load_store_op_none 1 +#define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1 +#define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none" + + +// VK_HUAWEI_cluster_culling_shader is a preprocessor guard. Do not pass it to API calls. +#define VK_HUAWEI_cluster_culling_shader 1 +#define VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION 3 +#define VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME "VK_HUAWEI_cluster_culling_shader" +typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 clustercullingShader; + VkBool32 multiviewClusterCullingShader; +} VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI; + +typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI { + VkStructureType sType; + void* pNext; + uint32_t maxWorkGroupCount[3]; + uint32_t maxWorkGroupSize[3]; + uint32_t maxOutputClusterCount; + VkDeviceSize indirectBufferOffsetAlignment; +} VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI; + +typedef struct VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 clusterShadingRate; +} VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterHUAWEI)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterIndirectHUAWEI)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterHUAWEI( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterIndirectHUAWEI( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); +#endif +#endif + + +// VK_EXT_border_color_swizzle is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_border_color_swizzle 1 +#define VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION 1 +#define VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME "VK_EXT_border_color_swizzle" +typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 borderColorSwizzle; + VkBool32 borderColorSwizzleFromImage; +} VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; + +typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkComponentMapping components; + VkBool32 srgb; +} VkSamplerBorderColorComponentMappingCreateInfoEXT; + + + +// VK_EXT_pageable_device_local_memory is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_pageable_device_local_memory 1 +#define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION 1 +#define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME "VK_EXT_pageable_device_local_memory" +typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pageableDeviceLocalMemory; +} VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT( + VkDevice device, + VkDeviceMemory memory, + float priority); +#endif +#endif + + +// VK_ARM_shader_core_properties is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_shader_core_properties 1 +#define VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION 1 +#define VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_ARM_shader_core_properties" +typedef struct VkPhysicalDeviceShaderCorePropertiesARM { + VkStructureType sType; + void* pNext; + uint32_t pixelRate; + uint32_t texelRate; + uint32_t fmaRate; +} VkPhysicalDeviceShaderCorePropertiesARM; + + + +// VK_ARM_scheduling_controls is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_scheduling_controls 1 +#define VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION 1 +#define VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME "VK_ARM_scheduling_controls" +typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM; + +// Flag bits for VkPhysicalDeviceSchedulingControlsFlagBitsARM +typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagBitsARM; +static const VkPhysicalDeviceSchedulingControlsFlagBitsARM VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001ULL; + +typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM { + VkStructureType sType; + void* pNext; + uint32_t shaderCoreCount; +} VkDeviceQueueShaderCoreControlCreateInfoARM; + +typedef struct VkPhysicalDeviceSchedulingControlsFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 schedulingControls; +} VkPhysicalDeviceSchedulingControlsFeaturesARM; + +typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags; +} VkPhysicalDeviceSchedulingControlsPropertiesARM; + + + +// VK_EXT_image_sliced_view_of_3d is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_image_sliced_view_of_3d 1 +#define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION 1 +#define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_sliced_view_of_3d" +#define VK_REMAINING_3D_SLICES_EXT (~0U) +typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageSlicedViewOf3D; +} VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT; + +typedef struct VkImageViewSlicedCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t sliceOffset; + uint32_t sliceCount; +} VkImageViewSlicedCreateInfoEXT; + + + +// VK_VALVE_descriptor_set_host_mapping is a preprocessor guard. Do not pass it to API calls. +#define VK_VALVE_descriptor_set_host_mapping 1 +#define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION 1 +#define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME "VK_VALVE_descriptor_set_host_mapping" +typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + VkStructureType sType; + void* pNext; + VkBool32 descriptorSetHostMapping; +} VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + +typedef struct VkDescriptorSetBindingReferenceVALVE { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayout descriptorSetLayout; + uint32_t binding; +} VkDescriptorSetBindingReferenceVALVE; + +typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE { + VkStructureType sType; + void* pNext; + size_t descriptorOffset; + uint32_t descriptorSize; +} VkDescriptorSetLayoutHostMappingInfoVALVE; + +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); +typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void** ppData); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE( + VkDevice device, + const VkDescriptorSetBindingReferenceVALVE* pBindingReference, + VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE( + VkDevice device, + VkDescriptorSet descriptorSet, + void** ppData); +#endif +#endif + + +// VK_EXT_depth_clamp_zero_one is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_depth_clamp_zero_one 1 +#define VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_EXT_depth_clamp_zero_one" +typedef VkPhysicalDeviceDepthClampZeroOneFeaturesKHR VkPhysicalDeviceDepthClampZeroOneFeaturesEXT; + + + +// VK_EXT_non_seamless_cube_map is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_non_seamless_cube_map 1 +#define VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION 1 +#define VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME "VK_EXT_non_seamless_cube_map" +typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 nonSeamlessCubeMap; +} VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + + + +// VK_ARM_render_pass_striped is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_render_pass_striped 1 +#define VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION 1 +#define VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME "VK_ARM_render_pass_striped" +typedef struct VkPhysicalDeviceRenderPassStripedFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 renderPassStriped; +} VkPhysicalDeviceRenderPassStripedFeaturesARM; + +typedef struct VkPhysicalDeviceRenderPassStripedPropertiesARM { + VkStructureType sType; + void* pNext; + VkExtent2D renderPassStripeGranularity; + uint32_t maxRenderPassStripes; +} VkPhysicalDeviceRenderPassStripedPropertiesARM; + +typedef struct VkRenderPassStripeInfoARM { + VkStructureType sType; + const void* pNext; + VkRect2D stripeArea; +} VkRenderPassStripeInfoARM; + +typedef struct VkRenderPassStripeBeginInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t stripeInfoCount; + const VkRenderPassStripeInfoARM* pStripeInfos; +} VkRenderPassStripeBeginInfoARM; + +typedef struct VkRenderPassStripeSubmitInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t stripeSemaphoreInfoCount; + const VkSemaphoreSubmitInfo* pStripeSemaphoreInfos; +} VkRenderPassStripeSubmitInfoARM; + + + +// VK_QCOM_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_fragment_density_map_offset 1 +#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 3 +#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset" +typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMapOffset; +} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; + +typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + +typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D fragmentDensityOffsetGranularity; +} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; + +typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + +typedef struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t fragmentDensityOffsetCount; + const VkOffset2D* pFragmentDensityOffsets; +} VkRenderPassFragmentDensityMapOffsetEndInfoEXT; + +typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT VkSubpassFragmentDensityMapOffsetEndInfoQCOM; + + + +// VK_NV_copy_memory_indirect is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_copy_memory_indirect 1 +#define VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION 1 +#define VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_NV_copy_memory_indirect" +typedef VkCopyMemoryIndirectCommandKHR VkCopyMemoryIndirectCommandNV; + +typedef VkCopyMemoryToImageIndirectCommandKHR VkCopyMemoryToImageIndirectCommandNV; + +typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 indirectCopy; +} VkPhysicalDeviceCopyMemoryIndirectFeaturesNV; + +typedef VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR VkPhysicalDeviceCopyMemoryIndirectPropertiesNV; + +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + VkImage dstImage, + VkImageLayout dstImageLayout, + const VkImageSubresourceLayers* pImageSubresources); +#endif +#endif + + +// VK_NV_memory_decompression is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_memory_decompression 1 +#define VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION 1 +#define VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME "VK_NV_memory_decompression" + +// Flag bits for VkMemoryDecompressionMethodFlagBitsEXT +typedef VkFlags64 VkMemoryDecompressionMethodFlagBitsEXT; +static const VkMemoryDecompressionMethodFlagBitsEXT VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT = 0x00000001ULL; +static const VkMemoryDecompressionMethodFlagBitsEXT VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV = 0x00000001ULL; + +typedef VkMemoryDecompressionMethodFlagBitsEXT VkMemoryDecompressionMethodFlagBitsNV; + +typedef VkFlags64 VkMemoryDecompressionMethodFlagsEXT; +typedef VkMemoryDecompressionMethodFlagsEXT VkMemoryDecompressionMethodFlagsNV; + +typedef struct VkDecompressMemoryRegionNV { + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize compressedSize; + VkDeviceSize decompressedSize; + VkMemoryDecompressionMethodFlagsNV decompressionMethod; +} VkDecompressMemoryRegionNV; + +typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 memoryDecompression; +} VkPhysicalDeviceMemoryDecompressionFeaturesEXT; + +typedef VkPhysicalDeviceMemoryDecompressionFeaturesEXT VkPhysicalDeviceMemoryDecompressionFeaturesNV; + +typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesEXT { + VkStructureType sType; + void* pNext; + VkMemoryDecompressionMethodFlagsEXT decompressionMethods; + uint64_t maxDecompressionIndirectCount; +} VkPhysicalDeviceMemoryDecompressionPropertiesEXT; + +typedef VkPhysicalDeviceMemoryDecompressionPropertiesEXT VkPhysicalDeviceMemoryDecompressionPropertiesNV; + +typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); +typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryIndirectCountNV)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV( + VkCommandBuffer commandBuffer, + uint32_t decompressRegionCount, + const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t stride); +#endif +#endif + + +// VK_NV_device_generated_commands_compute is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_device_generated_commands_compute 1 +#define VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION 2 +#define VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME "VK_NV_device_generated_commands_compute" +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 deviceGeneratedCompute; + VkBool32 deviceGeneratedComputePipelines; + VkBool32 deviceGeneratedComputeCaptureReplay; +} VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; + +typedef struct VkComputePipelineIndirectBufferInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceAddress deviceAddress; + VkDeviceSize size; + VkDeviceAddress pipelineDeviceAddressCaptureReplay; +} VkComputePipelineIndirectBufferInfoNV; + +typedef struct VkPipelineIndirectDeviceAddressInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline pipeline; +} VkPipelineIndirectDeviceAddressInfoNV; + +typedef struct VkBindPipelineIndirectCommandNV { + VkDeviceAddress pipelineAddress; +} VkBindPipelineIndirectCommandNV; + +typedef void (VKAPI_PTR *PFN_vkGetPipelineIndirectMemoryRequirementsNV)(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkCmdUpdatePipelineIndirectBufferNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetPipelineIndirectDeviceAddressNV)(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPipelineIndirectMemoryRequirementsNV( + VkDevice device, + const VkComputePipelineCreateInfo* pCreateInfo, + VkMemoryRequirements2* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdUpdatePipelineIndirectBufferNV( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetPipelineIndirectDeviceAddressNV( + VkDevice device, + const VkPipelineIndirectDeviceAddressInfoNV* pInfo); +#endif +#endif + + +// VK_NV_ray_tracing_linear_swept_spheres is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_ray_tracing_linear_swept_spheres 1 +#define VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION 1 +#define VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_EXTENSION_NAME "VK_NV_ray_tracing_linear_swept_spheres" + +typedef enum VkRayTracingLssIndexingModeNV { + VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV = 0, + VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV = 1, + VK_RAY_TRACING_LSS_INDEXING_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkRayTracingLssIndexingModeNV; + +typedef enum VkRayTracingLssPrimitiveEndCapsModeNV { + VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV = 0, + VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV = 1, + VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkRayTracingLssPrimitiveEndCapsModeNV; +typedef struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 spheres; + VkBool32 linearSweptSpheres; +} VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; + +typedef struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV { + VkStructureType sType; + const void* pNext; + VkFormat vertexFormat; + VkDeviceOrHostAddressConstKHR vertexData; + VkDeviceSize vertexStride; + VkFormat radiusFormat; + VkDeviceOrHostAddressConstKHR radiusData; + VkDeviceSize radiusStride; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexData; + VkDeviceSize indexStride; + VkRayTracingLssIndexingModeNV indexingMode; + VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode; +} VkAccelerationStructureGeometryLinearSweptSpheresDataNV; + +typedef struct VkAccelerationStructureGeometrySpheresDataNV { + VkStructureType sType; + const void* pNext; + VkFormat vertexFormat; + VkDeviceOrHostAddressConstKHR vertexData; + VkDeviceSize vertexStride; + VkFormat radiusFormat; + VkDeviceOrHostAddressConstKHR radiusData; + VkDeviceSize radiusStride; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexData; + VkDeviceSize indexStride; +} VkAccelerationStructureGeometrySpheresDataNV; + + + +// VK_NV_linear_color_attachment is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_linear_color_attachment 1 +#define VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION 1 +#define VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME "VK_NV_linear_color_attachment" +typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 linearColorAttachment; +} VkPhysicalDeviceLinearColorAttachmentFeaturesNV; + + + +// VK_GOOGLE_surfaceless_query is a preprocessor guard. Do not pass it to API calls. +#define VK_GOOGLE_surfaceless_query 1 +#define VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION 2 +#define VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME "VK_GOOGLE_surfaceless_query" + + +// VK_EXT_image_compression_control_swapchain is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_image_compression_control_swapchain 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION 1 +#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME "VK_EXT_image_compression_control_swapchain" +typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageCompressionControlSwapchain; +} VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + + + +// VK_QCOM_image_processing is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_image_processing 1 +#define VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION 1 +#define VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME "VK_QCOM_image_processing" +typedef struct VkImageViewSampleWeightCreateInfoQCOM { + VkStructureType sType; + const void* pNext; + VkOffset2D filterCenter; + VkExtent2D filterSize; + uint32_t numPhases; +} VkImageViewSampleWeightCreateInfoQCOM; + +typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 textureSampleWeighted; + VkBool32 textureBoxFilter; + VkBool32 textureBlockMatch; +} VkPhysicalDeviceImageProcessingFeaturesQCOM; + +typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM { + VkStructureType sType; + void* pNext; + uint32_t maxWeightFilterPhases; + VkExtent2D maxWeightFilterDimension; + VkExtent2D maxBlockMatchRegion; + VkExtent2D maxBoxFilterBlockSize; +} VkPhysicalDeviceImageProcessingPropertiesQCOM; + + + +// VK_EXT_nested_command_buffer is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_nested_command_buffer 1 +#define VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION 1 +#define VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME "VK_EXT_nested_command_buffer" +typedef struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 nestedCommandBuffer; + VkBool32 nestedCommandBufferRendering; + VkBool32 nestedCommandBufferSimultaneousUse; +} VkPhysicalDeviceNestedCommandBufferFeaturesEXT; + +typedef struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxCommandBufferNestingLevel; +} VkPhysicalDeviceNestedCommandBufferPropertiesEXT; + + + +// VK_EXT_external_memory_acquire_unmodified is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_external_memory_acquire_unmodified 1 +#define VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME "VK_EXT_external_memory_acquire_unmodified" +typedef struct VkExternalMemoryAcquireUnmodifiedEXT { + VkStructureType sType; + const void* pNext; + VkBool32 acquireUnmodifiedMemory; +} VkExternalMemoryAcquireUnmodifiedEXT; + + + +// VK_EXT_extended_dynamic_state3 is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_extended_dynamic_state3 1 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION 2 +#define VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME "VK_EXT_extended_dynamic_state3" +typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState3TessellationDomainOrigin; + VkBool32 extendedDynamicState3DepthClampEnable; + VkBool32 extendedDynamicState3PolygonMode; + VkBool32 extendedDynamicState3RasterizationSamples; + VkBool32 extendedDynamicState3SampleMask; + VkBool32 extendedDynamicState3AlphaToCoverageEnable; + VkBool32 extendedDynamicState3AlphaToOneEnable; + VkBool32 extendedDynamicState3LogicOpEnable; + VkBool32 extendedDynamicState3ColorBlendEnable; + VkBool32 extendedDynamicState3ColorBlendEquation; + VkBool32 extendedDynamicState3ColorWriteMask; + VkBool32 extendedDynamicState3RasterizationStream; + VkBool32 extendedDynamicState3ConservativeRasterizationMode; + VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize; + VkBool32 extendedDynamicState3DepthClipEnable; + VkBool32 extendedDynamicState3SampleLocationsEnable; + VkBool32 extendedDynamicState3ColorBlendAdvanced; + VkBool32 extendedDynamicState3ProvokingVertexMode; + VkBool32 extendedDynamicState3LineRasterizationMode; + VkBool32 extendedDynamicState3LineStippleEnable; + VkBool32 extendedDynamicState3DepthClipNegativeOneToOne; + VkBool32 extendedDynamicState3ViewportWScalingEnable; + VkBool32 extendedDynamicState3ViewportSwizzle; + VkBool32 extendedDynamicState3CoverageToColorEnable; + VkBool32 extendedDynamicState3CoverageToColorLocation; + VkBool32 extendedDynamicState3CoverageModulationMode; + VkBool32 extendedDynamicState3CoverageModulationTableEnable; + VkBool32 extendedDynamicState3CoverageModulationTable; + VkBool32 extendedDynamicState3CoverageReductionMode; + VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable; + VkBool32 extendedDynamicState3ShadingRateImageEnable; +} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT; + +typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 dynamicPrimitiveTopologyUnrestricted; +} VkPhysicalDeviceExtendedDynamicState3PropertiesEXT; + +typedef struct VkColorBlendEquationEXT { + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; +} VkColorBlendEquationEXT; + +typedef struct VkColorBlendAdvancedEXT { + VkBlendOp advancedBlendOp; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; + VkBool32 clampResults; +} VkColorBlendAdvancedEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask); +typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); +typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); +typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream); +typedef void (VKAPI_PTR *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced); +typedef void (VKAPI_PTR *PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable); +typedef void (VKAPI_PTR *PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); +typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClampEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT( + VkCommandBuffer commandBuffer, + VkPolygonMode polygonMode); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToCoverageEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToOneEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 logicOpEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32* pColorBlendEnables); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags* pColorWriteMasks); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT( + VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT( + VkCommandBuffer commandBuffer, + uint32_t rasterizationStream); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkConservativeRasterizationModeEXT conservativeRasterizationMode); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT( + VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClipEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 sampleLocationsEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT( + VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stippledLineEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT( + VkCommandBuffer commandBuffer, + VkBool32 negativeOneToOne); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 viewportWScalingEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV* pViewportSwizzles); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageToColorEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV( + VkCommandBuffer commandBuffer, + uint32_t coverageToColorLocation); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV( + VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV( + VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 shadingRateImageEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV( + VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode); +#endif +#endif + + +// VK_EXT_subpass_merge_feedback is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_subpass_merge_feedback 1 +#define VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION 2 +#define VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME "VK_EXT_subpass_merge_feedback" + +typedef enum VkSubpassMergeStatusEXT { + VK_SUBPASS_MERGE_STATUS_MERGED_EXT = 0, + VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT = 1, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT = 2, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT = 3, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT = 4, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT = 5, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT = 6, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT = 7, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT = 8, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT = 9, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT = 10, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT = 11, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT = 12, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT = 13, + VK_SUBPASS_MERGE_STATUS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSubpassMergeStatusEXT; +typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 subpassMergeFeedback; +} VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + +typedef struct VkRenderPassCreationControlEXT { + VkStructureType sType; + const void* pNext; + VkBool32 disallowMerging; +} VkRenderPassCreationControlEXT; + +typedef struct VkRenderPassCreationFeedbackInfoEXT { + uint32_t postMergeSubpassCount; +} VkRenderPassCreationFeedbackInfoEXT; + +typedef struct VkRenderPassCreationFeedbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback; +} VkRenderPassCreationFeedbackCreateInfoEXT; + +typedef struct VkRenderPassSubpassFeedbackInfoEXT { + VkSubpassMergeStatusEXT subpassMergeStatus; + char description[VK_MAX_DESCRIPTION_SIZE]; + uint32_t postMergeIndex; +} VkRenderPassSubpassFeedbackInfoEXT; + +typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback; +} VkRenderPassSubpassFeedbackCreateInfoEXT; + + + +// VK_LUNARG_direct_driver_loading is a preprocessor guard. Do not pass it to API calls. +#define VK_LUNARG_direct_driver_loading 1 +#define VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION 1 +#define VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME "VK_LUNARG_direct_driver_loading" + +typedef enum VkDirectDriverLoadingModeLUNARG { + VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG = 0, + VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG = 1, + VK_DIRECT_DRIVER_LOADING_MODE_MAX_ENUM_LUNARG = 0x7FFFFFFF +} VkDirectDriverLoadingModeLUNARG; +typedef VkFlags VkDirectDriverLoadingFlagsLUNARG; +typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddrLUNARG)( + VkInstance instance, + const char* pName); + +typedef struct VkDirectDriverLoadingInfoLUNARG { + VkStructureType sType; + void* pNext; + VkDirectDriverLoadingFlagsLUNARG flags; + PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr; +} VkDirectDriverLoadingInfoLUNARG; + +typedef struct VkDirectDriverLoadingListLUNARG { + VkStructureType sType; + const void* pNext; + VkDirectDriverLoadingModeLUNARG mode; + uint32_t driverCount; + const VkDirectDriverLoadingInfoLUNARG* pDrivers; +} VkDirectDriverLoadingListLUNARG; + + + +// VK_ARM_tensors is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_tensors 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkTensorViewARM) +#define VK_ARM_TENSORS_SPEC_VERSION 1 +#define VK_ARM_TENSORS_EXTENSION_NAME "VK_ARM_tensors" + +typedef enum VkTensorTilingARM { + VK_TENSOR_TILING_OPTIMAL_ARM = 0, + VK_TENSOR_TILING_LINEAR_ARM = 1, + VK_TENSOR_TILING_MAX_ENUM_ARM = 0x7FFFFFFF +} VkTensorTilingARM; +typedef VkFlags64 VkTensorCreateFlagsARM; + +// Flag bits for VkTensorCreateFlagBitsARM +typedef VkFlags64 VkTensorCreateFlagBitsARM; +static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM = 0x00000001ULL; +static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_PROTECTED_BIT_ARM = 0x00000002ULL; +static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM = 0x00000008ULL; +static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM = 0x00000004ULL; + +typedef VkFlags64 VkTensorUsageFlagsARM; + +// Flag bits for VkTensorUsageFlagBitsARM +typedef VkFlags64 VkTensorUsageFlagBitsARM; +static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_SHADER_BIT_ARM = 0x00000002ULL; +static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM = 0x00000004ULL; +static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM = 0x00000008ULL; +static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM = 0x00000010ULL; +static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM = 0x00000020ULL; + +typedef struct VkTensorDescriptionARM { + VkStructureType sType; + const void* pNext; + VkTensorTilingARM tiling; + VkFormat format; + uint32_t dimensionCount; + const int64_t* pDimensions; + const int64_t* pStrides; + VkTensorUsageFlagsARM usage; +} VkTensorDescriptionARM; + +typedef struct VkTensorCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkTensorCreateFlagsARM flags; + const VkTensorDescriptionARM* pDescription; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkTensorCreateInfoARM; + +typedef struct VkTensorMemoryRequirementsInfoARM { + VkStructureType sType; + const void* pNext; + VkTensorARM tensor; +} VkTensorMemoryRequirementsInfoARM; + +typedef struct VkBindTensorMemoryInfoARM { + VkStructureType sType; + const void* pNext; + VkTensorARM tensor; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindTensorMemoryInfoARM; + +typedef struct VkWriteDescriptorSetTensorARM { + VkStructureType sType; + const void* pNext; + uint32_t tensorViewCount; + const VkTensorViewARM* pTensorViews; +} VkWriteDescriptorSetTensorARM; + +typedef struct VkTensorFormatPropertiesARM { + VkStructureType sType; + void* pNext; + VkFormatFeatureFlags2 optimalTilingTensorFeatures; + VkFormatFeatureFlags2 linearTilingTensorFeatures; +} VkTensorFormatPropertiesARM; + +typedef struct VkPhysicalDeviceTensorPropertiesARM { + VkStructureType sType; + void* pNext; + uint32_t maxTensorDimensionCount; + uint64_t maxTensorElements; + uint64_t maxPerDimensionTensorElements; + int64_t maxTensorStride; + uint64_t maxTensorSize; + uint32_t maxTensorShaderAccessArrayLength; + uint32_t maxTensorShaderAccessSize; + uint32_t maxDescriptorSetStorageTensors; + uint32_t maxPerStageDescriptorSetStorageTensors; + uint32_t maxDescriptorSetUpdateAfterBindStorageTensors; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors; + VkBool32 shaderStorageTensorArrayNonUniformIndexingNative; + VkShaderStageFlags shaderTensorSupportedStages; +} VkPhysicalDeviceTensorPropertiesARM; + +typedef struct VkTensorMemoryBarrierARM { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkTensorARM tensor; +} VkTensorMemoryBarrierARM; + +typedef struct VkTensorDependencyInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t tensorMemoryBarrierCount; + const VkTensorMemoryBarrierARM* pTensorMemoryBarriers; +} VkTensorDependencyInfoARM; + +typedef struct VkPhysicalDeviceTensorFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 tensorNonPacked; + VkBool32 shaderTensorAccess; + VkBool32 shaderStorageTensorArrayDynamicIndexing; + VkBool32 shaderStorageTensorArrayNonUniformIndexing; + VkBool32 descriptorBindingStorageTensorUpdateAfterBind; + VkBool32 tensors; +} VkPhysicalDeviceTensorFeaturesARM; + +typedef struct VkDeviceTensorMemoryRequirementsARM { + VkStructureType sType; + const void* pNext; + const VkTensorCreateInfoARM* pCreateInfo; +} VkDeviceTensorMemoryRequirementsARM; + +typedef struct VkTensorCopyARM { + VkStructureType sType; + const void* pNext; + uint32_t dimensionCount; + const uint64_t* pSrcOffset; + const uint64_t* pDstOffset; + const uint64_t* pExtent; +} VkTensorCopyARM; + +typedef struct VkCopyTensorInfoARM { + VkStructureType sType; + const void* pNext; + VkTensorARM srcTensor; + VkTensorARM dstTensor; + uint32_t regionCount; + const VkTensorCopyARM* pRegions; +} VkCopyTensorInfoARM; + +typedef struct VkMemoryDedicatedAllocateInfoTensorARM { + VkStructureType sType; + const void* pNext; + VkTensorARM tensor; +} VkMemoryDedicatedAllocateInfoTensorARM; + +typedef struct VkPhysicalDeviceExternalTensorInfoARM { + VkStructureType sType; + const void* pNext; + VkTensorCreateFlagsARM flags; + const VkTensorDescriptionARM* pDescription; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalTensorInfoARM; + +typedef struct VkExternalTensorPropertiesARM { + VkStructureType sType; + const void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalTensorPropertiesARM; + +typedef struct VkExternalMemoryTensorCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryTensorCreateInfoARM; + +typedef struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 descriptorBufferTensorDescriptors; +} VkPhysicalDeviceDescriptorBufferTensorFeaturesARM; + +typedef struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM { + VkStructureType sType; + void* pNext; + size_t tensorCaptureReplayDescriptorDataSize; + size_t tensorViewCaptureReplayDescriptorDataSize; + size_t tensorDescriptorSize; +} VkPhysicalDeviceDescriptorBufferTensorPropertiesARM; + +typedef struct VkDescriptorGetTensorInfoARM { + VkStructureType sType; + const void* pNext; + VkTensorViewARM tensorView; +} VkDescriptorGetTensorInfoARM; + +typedef struct VkTensorCaptureDescriptorDataInfoARM { + VkStructureType sType; + const void* pNext; + VkTensorARM tensor; +} VkTensorCaptureDescriptorDataInfoARM; + +typedef struct VkTensorViewCaptureDescriptorDataInfoARM { + VkStructureType sType; + const void* pNext; + VkTensorViewARM tensorView; +} VkTensorViewCaptureDescriptorDataInfoARM; + +typedef struct VkFrameBoundaryTensorsARM { + VkStructureType sType; + const void* pNext; + uint32_t tensorCount; + const VkTensorARM* pTensors; +} VkFrameBoundaryTensorsARM; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateTensorARM)(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor); +typedef void (VKAPI_PTR *PFN_vkDestroyTensorARM)(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateTensorViewARM)(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView); +typedef void (VKAPI_PTR *PFN_vkDestroyTensorViewARM)(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetTensorMemoryRequirementsARM)(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindTensorMemoryARM)(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkGetDeviceTensorMemoryRequirementsARM)(VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkCmdCopyTensorARM)(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDescriptorDataARM)(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM* pInfo, void* pData); +typedef VkResult (VKAPI_PTR *PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM)(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorARM( + VkDevice device, + const VkTensorCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkTensorARM* pTensor); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyTensorARM( + VkDevice device, + VkTensorARM tensor, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorViewARM( + VkDevice device, + const VkTensorViewCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkTensorViewARM* pView); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyTensorViewARM( + VkDevice device, + VkTensorViewARM tensorView, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetTensorMemoryRequirementsARM( + VkDevice device, + const VkTensorMemoryRequirementsInfoARM* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindTensorMemoryARM( + VkDevice device, + uint32_t bindInfoCount, + const VkBindTensorMemoryInfoARM* pBindInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceTensorMemoryRequirementsARM( + VkDevice device, + const VkDeviceTensorMemoryRequirementsARM* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyTensorARM( + VkCommandBuffer commandBuffer, + const VkCopyTensorInfoARM* pCopyTensorInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalTensorPropertiesARM( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, + VkExternalTensorPropertiesARM* pExternalTensorProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDescriptorDataARM( + VkDevice device, + const VkTensorCaptureDescriptorDataInfoARM* pInfo, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorViewOpaqueCaptureDescriptorDataARM( + VkDevice device, + const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, + void* pData); +#endif +#endif + + +// VK_EXT_shader_module_identifier is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_module_identifier 1 +#define VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT 32U +#define VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION 1 +#define VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME "VK_EXT_shader_module_identifier" +typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderModuleIdentifier; +} VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE]; +} VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT; + +typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t identifierSize; + const uint8_t* pIdentifier; +} VkPipelineShaderStageModuleIdentifierCreateInfoEXT; + +typedef struct VkShaderModuleIdentifierEXT { + VkStructureType sType; + void* pNext; + uint32_t identifierSize; + uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]; +} VkShaderModuleIdentifierEXT; + +typedef void (VKAPI_PTR *PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier); +typedef void (VKAPI_PTR *PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT( + VkDevice device, + VkShaderModule shaderModule, + VkShaderModuleIdentifierEXT* pIdentifier); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModuleIdentifierEXT* pIdentifier); +#endif +#endif + + +// VK_EXT_rasterization_order_attachment_access is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_rasterization_order_attachment_access 1 +#define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1 +#define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_EXT_rasterization_order_attachment_access" + + +// VK_NV_optical_flow is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_optical_flow 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkOpticalFlowSessionNV) +#define VK_NV_OPTICAL_FLOW_SPEC_VERSION 1 +#define VK_NV_OPTICAL_FLOW_EXTENSION_NAME "VK_NV_optical_flow" + +typedef enum VkOpticalFlowPerformanceLevelNV { + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV = 1, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV = 2, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV = 3, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowPerformanceLevelNV; + +typedef enum VkOpticalFlowSessionBindingPointNV { + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV = 1, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV = 2, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV = 3, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV = 4, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV = 5, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV = 6, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV = 7, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV = 8, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowSessionBindingPointNV; + +typedef enum VkOpticalFlowGridSizeFlagBitsNV { + VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_GRID_SIZE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowGridSizeFlagBitsNV; +typedef VkFlags VkOpticalFlowGridSizeFlagsNV; + +typedef enum VkOpticalFlowUsageFlagBitsNV { + VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_USAGE_COST_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV = 0x00000010, + VK_OPTICAL_FLOW_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowUsageFlagBitsNV; +typedef VkFlags VkOpticalFlowUsageFlagsNV; + +typedef enum VkOpticalFlowSessionCreateFlagBitsNV { + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV = 0x00000010, + VK_OPTICAL_FLOW_SESSION_CREATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowSessionCreateFlagBitsNV; +typedef VkFlags VkOpticalFlowSessionCreateFlagsNV; + +typedef enum VkOpticalFlowExecuteFlagBitsNV { + VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_EXECUTE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowExecuteFlagBitsNV; +typedef VkFlags VkOpticalFlowExecuteFlagsNV; +typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 opticalFlow; +} VkPhysicalDeviceOpticalFlowFeaturesNV; + +typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV { + VkStructureType sType; + void* pNext; + VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes; + VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes; + VkBool32 hintSupported; + VkBool32 costSupported; + VkBool32 bidirectionalFlowSupported; + VkBool32 globalFlowSupported; + uint32_t minWidth; + uint32_t minHeight; + uint32_t maxWidth; + uint32_t maxHeight; + uint32_t maxNumRegionsOfInterest; +} VkPhysicalDeviceOpticalFlowPropertiesNV; + +typedef struct VkOpticalFlowImageFormatInfoNV { + VkStructureType sType; + const void* pNext; + VkOpticalFlowUsageFlagsNV usage; +} VkOpticalFlowImageFormatInfoNV; + +typedef struct VkOpticalFlowImageFormatPropertiesNV { + VkStructureType sType; + void* pNext; + VkFormat format; +} VkOpticalFlowImageFormatPropertiesNV; + +typedef struct VkOpticalFlowSessionCreateInfoNV { + VkStructureType sType; + void* pNext; + uint32_t width; + uint32_t height; + VkFormat imageFormat; + VkFormat flowVectorFormat; + VkFormat costFormat; + VkOpticalFlowGridSizeFlagsNV outputGridSize; + VkOpticalFlowGridSizeFlagsNV hintGridSize; + VkOpticalFlowPerformanceLevelNV performanceLevel; + VkOpticalFlowSessionCreateFlagsNV flags; +} VkOpticalFlowSessionCreateInfoNV; + +typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV { + VkStructureType sType; + void* pNext; + uint32_t id; + uint32_t size; + const void* pPrivateData; +} VkOpticalFlowSessionCreatePrivateDataInfoNV; + +typedef struct VkOpticalFlowExecuteInfoNV { + VkStructureType sType; + void* pNext; + VkOpticalFlowExecuteFlagsNV flags; + uint32_t regionCount; + const VkRect2D* pRegions; +} VkOpticalFlowExecuteInfoNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); +typedef VkResult (VKAPI_PTR *PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession); +typedef void (VKAPI_PTR *PFN_vkDestroyOpticalFlowSessionNV)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkBindOpticalFlowSessionImageNV)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout); +typedef void (VKAPI_PTR *PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV( + VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyOpticalFlowSessionNV( + VkDevice device, + VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV( + VkDevice device, + VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV( + VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo); +#endif +#endif + + +// VK_EXT_legacy_dithering is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_legacy_dithering 1 +#define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 2 +#define VK_EXT_LEGACY_DITHERING_EXTENSION_NAME "VK_EXT_legacy_dithering" +typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 legacyDithering; +} VkPhysicalDeviceLegacyDitheringFeaturesEXT; + + + +// VK_EXT_pipeline_protected_access is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_pipeline_protected_access 1 +#define VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME "VK_EXT_pipeline_protected_access" +typedef VkPhysicalDevicePipelineProtectedAccessFeatures VkPhysicalDevicePipelineProtectedAccessFeaturesEXT; + + + +// VK_AMD_anti_lag is a preprocessor guard. Do not pass it to API calls. +#define VK_AMD_anti_lag 1 +#define VK_AMD_ANTI_LAG_SPEC_VERSION 1 +#define VK_AMD_ANTI_LAG_EXTENSION_NAME "VK_AMD_anti_lag" + +typedef enum VkAntiLagModeAMD { + VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD = 0, + VK_ANTI_LAG_MODE_ON_AMD = 1, + VK_ANTI_LAG_MODE_OFF_AMD = 2, + VK_ANTI_LAG_MODE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkAntiLagModeAMD; + +typedef enum VkAntiLagStageAMD { + VK_ANTI_LAG_STAGE_INPUT_AMD = 0, + VK_ANTI_LAG_STAGE_PRESENT_AMD = 1, + VK_ANTI_LAG_STAGE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkAntiLagStageAMD; +typedef struct VkPhysicalDeviceAntiLagFeaturesAMD { + VkStructureType sType; + void* pNext; + VkBool32 antiLag; +} VkPhysicalDeviceAntiLagFeaturesAMD; + +typedef struct VkAntiLagPresentationInfoAMD { + VkStructureType sType; + void* pNext; + VkAntiLagStageAMD stage; + uint64_t frameIndex; +} VkAntiLagPresentationInfoAMD; + +typedef struct VkAntiLagDataAMD { + VkStructureType sType; + const void* pNext; + VkAntiLagModeAMD mode; + uint32_t maxFPS; + const VkAntiLagPresentationInfoAMD* pPresentationInfo; +} VkAntiLagDataAMD; + +typedef void (VKAPI_PTR *PFN_vkAntiLagUpdateAMD)(VkDevice device, const VkAntiLagDataAMD* pData); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkAntiLagUpdateAMD( + VkDevice device, + const VkAntiLagDataAMD* pData); +#endif +#endif + + +// VK_EXT_shader_object is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_object 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderEXT) +#define VK_EXT_SHADER_OBJECT_SPEC_VERSION 1 +#define VK_EXT_SHADER_OBJECT_EXTENSION_NAME "VK_EXT_shader_object" + +typedef enum VkShaderCodeTypeEXT { + VK_SHADER_CODE_TYPE_BINARY_EXT = 0, + VK_SHADER_CODE_TYPE_SPIRV_EXT = 1, + VK_SHADER_CODE_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkShaderCodeTypeEXT; + +typedef enum VkDepthClampModeEXT { + VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT = 0, + VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT = 1, + VK_DEPTH_CLAMP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDepthClampModeEXT; + +typedef enum VkShaderCreateFlagBitsEXT { + VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = 0x00000001, + VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT = 0x00000400, + VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000002, + VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000004, + VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT = 0x00000008, + VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = 0x00000010, + VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, + VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, + VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT = 0x00000080, + VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT = 0x00008000, + VK_SHADER_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkShaderCreateFlagBitsEXT; +typedef VkFlags VkShaderCreateFlagsEXT; +typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderObject; +} VkPhysicalDeviceShaderObjectFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT { + VkStructureType sType; + void* pNext; + uint8_t shaderBinaryUUID[VK_UUID_SIZE]; + uint32_t shaderBinaryVersion; +} VkPhysicalDeviceShaderObjectPropertiesEXT; + +typedef struct VkShaderCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkShaderCreateFlagsEXT flags; + VkShaderStageFlagBits stage; + VkShaderStageFlags nextStage; + VkShaderCodeTypeEXT codeType; + size_t codeSize; + const void* pCode; + const char* pName; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; + const VkSpecializationInfo* pSpecializationInfo; +} VkShaderCreateInfoEXT; + +typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkShaderRequiredSubgroupSizeCreateInfoEXT; + +typedef struct VkDepthClampRangeEXT { + float minDepthClamp; + float maxDepthClamp; +} VkDepthClampRangeEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateShadersEXT)(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders); +typedef void (VKAPI_PTR *PFN_vkDestroyShaderEXT)(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetShaderBinaryDataEXT)(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdBindShadersEXT)(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); +typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampRangeEXT)(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT( + VkDevice device, + uint32_t createInfoCount, + const VkShaderCreateInfoEXT* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkShaderEXT* pShaders); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderEXT( + VkDevice device, + VkShaderEXT shader, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderBinaryDataEXT( + VkDevice device, + VkShaderEXT shader, + size_t* pDataSize, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindShadersEXT( + VkCommandBuffer commandBuffer, + uint32_t stageCount, + const VkShaderStageFlagBits* pStages, + const VkShaderEXT* pShaders); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampRangeEXT( + VkCommandBuffer commandBuffer, + VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT* pDepthClampRange); +#endif +#endif + + +// VK_QCOM_tile_properties is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_tile_properties 1 +#define VK_QCOM_TILE_PROPERTIES_SPEC_VERSION 1 +#define VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME "VK_QCOM_tile_properties" +typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 tileProperties; +} VkPhysicalDeviceTilePropertiesFeaturesQCOM; + +typedef struct VkTilePropertiesQCOM { + VkStructureType sType; + void* pNext; + VkExtent3D tileSize; + VkExtent2D apronSize; + VkOffset2D origin; +} VkTilePropertiesQCOM; + +typedef VkResult (VKAPI_PTR *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM( + VkDevice device, + VkFramebuffer framebuffer, + uint32_t* pPropertiesCount, + VkTilePropertiesQCOM* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM( + VkDevice device, + const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties); +#endif +#endif + + +// VK_SEC_amigo_profiling is a preprocessor guard. Do not pass it to API calls. +#define VK_SEC_amigo_profiling 1 +#define VK_SEC_AMIGO_PROFILING_SPEC_VERSION 1 +#define VK_SEC_AMIGO_PROFILING_EXTENSION_NAME "VK_SEC_amigo_profiling" +typedef struct VkPhysicalDeviceAmigoProfilingFeaturesSEC { + VkStructureType sType; + void* pNext; + VkBool32 amigoProfiling; +} VkPhysicalDeviceAmigoProfilingFeaturesSEC; + +typedef struct VkAmigoProfilingSubmitInfoSEC { + VkStructureType sType; + const void* pNext; + uint64_t firstDrawTimestamp; + uint64_t swapBufferTimestamp; +} VkAmigoProfilingSubmitInfoSEC; + + + +// VK_QCOM_multiview_per_view_viewports is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_multiview_per_view_viewports 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME "VK_QCOM_multiview_per_view_viewports" +typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 multiviewPerViewViewports; +} VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + + + +// VK_NV_ray_tracing_invocation_reorder is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_ray_tracing_invocation_reorder 1 +#define VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 1 +#define VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME "VK_NV_ray_tracing_invocation_reorder" + +typedef enum VkRayTracingInvocationReorderModeEXT { + VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT = 0, + VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT = 1, + VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT, + VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT, + VK_RAY_TRACING_INVOCATION_REORDER_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkRayTracingInvocationReorderModeEXT; +typedef VkRayTracingInvocationReorderModeEXT VkRayTracingInvocationReorderModeNV; + +typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV { + VkStructureType sType; + void* pNext; + VkRayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint; +} VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV; + +typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingInvocationReorder; +} VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV; + + + +// VK_NV_cooperative_vector is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_cooperative_vector 1 +#define VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION 4 +#define VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME "VK_NV_cooperative_vector" + +typedef enum VkCooperativeVectorMatrixLayoutNV { + VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV = 0, + VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV = 1, + VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV = 2, + VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV = 3, + VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_MAX_ENUM_NV = 0x7FFFFFFF +} VkCooperativeVectorMatrixLayoutNV; +typedef struct VkPhysicalDeviceCooperativeVectorPropertiesNV { + VkStructureType sType; + void* pNext; + VkShaderStageFlags cooperativeVectorSupportedStages; + VkBool32 cooperativeVectorTrainingFloat16Accumulation; + VkBool32 cooperativeVectorTrainingFloat32Accumulation; + uint32_t maxCooperativeVectorComponents; +} VkPhysicalDeviceCooperativeVectorPropertiesNV; + +typedef struct VkPhysicalDeviceCooperativeVectorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cooperativeVector; + VkBool32 cooperativeVectorTraining; +} VkPhysicalDeviceCooperativeVectorFeaturesNV; + +typedef struct VkCooperativeVectorPropertiesNV { + VkStructureType sType; + void* pNext; + VkComponentTypeKHR inputType; + VkComponentTypeKHR inputInterpretation; + VkComponentTypeKHR matrixInterpretation; + VkComponentTypeKHR biasInterpretation; + VkComponentTypeKHR resultType; + VkBool32 transpose; +} VkCooperativeVectorPropertiesNV; + +typedef struct VkConvertCooperativeVectorMatrixInfoNV { + VkStructureType sType; + const void* pNext; + size_t srcSize; + VkDeviceOrHostAddressConstKHR srcData; + size_t* pDstSize; + VkDeviceOrHostAddressKHR dstData; + VkComponentTypeKHR srcComponentType; + VkComponentTypeKHR dstComponentType; + uint32_t numRows; + uint32_t numColumns; + VkCooperativeVectorMatrixLayoutNV srcLayout; + size_t srcStride; + VkCooperativeVectorMatrixLayoutNV dstLayout; + size_t dstStride; +} VkConvertCooperativeVectorMatrixInfoNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkConvertCooperativeVectorMatrixNV)(VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdConvertCooperativeVectorMatrixNV)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeVectorPropertiesNV( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeVectorPropertiesNV* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkConvertCooperativeVectorMatrixNV( + VkDevice device, + const VkConvertCooperativeVectorMatrixInfoNV* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdConvertCooperativeVectorMatrixNV( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkConvertCooperativeVectorMatrixInfoNV* pInfos); +#endif +#endif + + +// VK_NV_extended_sparse_address_space is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_extended_sparse_address_space 1 +#define VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION 1 +#define VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME "VK_NV_extended_sparse_address_space" +typedef struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 extendedSparseAddressSpace; +} VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; + +typedef struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV { + VkStructureType sType; + void* pNext; + VkDeviceSize extendedSparseAddressSpaceSize; + VkImageUsageFlags extendedSparseImageUsageFlags; + VkBufferUsageFlags extendedSparseBufferUsageFlags; +} VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV; + + + +// VK_EXT_mutable_descriptor_type is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_mutable_descriptor_type 1 +#define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1 +#define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_EXT_mutable_descriptor_type" + + +// VK_EXT_legacy_vertex_attributes is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_legacy_vertex_attributes 1 +#define VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION 1 +#define VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME "VK_EXT_legacy_vertex_attributes" +typedef struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 legacyVertexAttributes; +} VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT; + +typedef struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 nativeUnalignedPerformance; +} VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT; + + + +// VK_EXT_layer_settings is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_layer_settings 1 +#define VK_EXT_LAYER_SETTINGS_SPEC_VERSION 2 +#define VK_EXT_LAYER_SETTINGS_EXTENSION_NAME "VK_EXT_layer_settings" + +typedef enum VkLayerSettingTypeEXT { + VK_LAYER_SETTING_TYPE_BOOL32_EXT = 0, + VK_LAYER_SETTING_TYPE_INT32_EXT = 1, + VK_LAYER_SETTING_TYPE_INT64_EXT = 2, + VK_LAYER_SETTING_TYPE_UINT32_EXT = 3, + VK_LAYER_SETTING_TYPE_UINT64_EXT = 4, + VK_LAYER_SETTING_TYPE_FLOAT32_EXT = 5, + VK_LAYER_SETTING_TYPE_FLOAT64_EXT = 6, + VK_LAYER_SETTING_TYPE_STRING_EXT = 7, + VK_LAYER_SETTING_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkLayerSettingTypeEXT; +typedef struct VkLayerSettingEXT { + const char* pLayerName; + const char* pSettingName; + VkLayerSettingTypeEXT type; + uint32_t valueCount; + const void* pValues; +} VkLayerSettingEXT; + +typedef struct VkLayerSettingsCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t settingCount; + const VkLayerSettingEXT* pSettings; +} VkLayerSettingsCreateInfoEXT; + + + +// VK_ARM_shader_core_builtins is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_shader_core_builtins 1 +#define VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION 2 +#define VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME "VK_ARM_shader_core_builtins" +typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 shaderCoreBuiltins; +} VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM; + +typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM { + VkStructureType sType; + void* pNext; + uint64_t shaderCoreMask; + uint32_t shaderCoreCount; + uint32_t shaderWarpsPerCore; +} VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM; + + + +// VK_EXT_pipeline_library_group_handles is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_pipeline_library_group_handles 1 +#define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION 1 +#define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME "VK_EXT_pipeline_library_group_handles" +typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelineLibraryGroupHandles; +} VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + + + +// VK_EXT_dynamic_rendering_unused_attachments is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_dynamic_rendering_unused_attachments 1 +#define VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION 1 +#define VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME "VK_EXT_dynamic_rendering_unused_attachments" +typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 dynamicRenderingUnusedAttachments; +} VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; + + + +// VK_NV_low_latency2 is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_low_latency2 1 +#define VK_NV_LOW_LATENCY_2_SPEC_VERSION 2 +#define VK_NV_LOW_LATENCY_2_EXTENSION_NAME "VK_NV_low_latency2" + +typedef enum VkLatencyMarkerNV { + VK_LATENCY_MARKER_SIMULATION_START_NV = 0, + VK_LATENCY_MARKER_SIMULATION_END_NV = 1, + VK_LATENCY_MARKER_RENDERSUBMIT_START_NV = 2, + VK_LATENCY_MARKER_RENDERSUBMIT_END_NV = 3, + VK_LATENCY_MARKER_PRESENT_START_NV = 4, + VK_LATENCY_MARKER_PRESENT_END_NV = 5, + VK_LATENCY_MARKER_INPUT_SAMPLE_NV = 6, + VK_LATENCY_MARKER_TRIGGER_FLASH_NV = 7, + VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV = 8, + VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV = 9, + VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV = 10, + VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV = 11, + VK_LATENCY_MARKER_MAX_ENUM_NV = 0x7FFFFFFF +} VkLatencyMarkerNV; + +typedef enum VkOutOfBandQueueTypeNV { + VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV = 0, + VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV = 1, + VK_OUT_OF_BAND_QUEUE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkOutOfBandQueueTypeNV; +typedef struct VkLatencySleepModeInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 lowLatencyMode; + VkBool32 lowLatencyBoost; + uint32_t minimumIntervalUs; +} VkLatencySleepModeInfoNV; + +typedef struct VkLatencySleepInfoNV { + VkStructureType sType; + const void* pNext; + VkSemaphore signalSemaphore; + uint64_t value; +} VkLatencySleepInfoNV; + +typedef struct VkSetLatencyMarkerInfoNV { + VkStructureType sType; + const void* pNext; + uint64_t presentID; + VkLatencyMarkerNV marker; +} VkSetLatencyMarkerInfoNV; + +typedef struct VkLatencyTimingsFrameReportNV { + VkStructureType sType; + void* pNext; + uint64_t presentID; + uint64_t inputSampleTimeUs; + uint64_t simStartTimeUs; + uint64_t simEndTimeUs; + uint64_t renderSubmitStartTimeUs; + uint64_t renderSubmitEndTimeUs; + uint64_t presentStartTimeUs; + uint64_t presentEndTimeUs; + uint64_t driverStartTimeUs; + uint64_t driverEndTimeUs; + uint64_t osRenderQueueStartTimeUs; + uint64_t osRenderQueueEndTimeUs; + uint64_t gpuRenderStartTimeUs; + uint64_t gpuRenderEndTimeUs; +} VkLatencyTimingsFrameReportNV; + +typedef struct VkGetLatencyMarkerInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t timingCount; + VkLatencyTimingsFrameReportNV* pTimings; +} VkGetLatencyMarkerInfoNV; + +typedef struct VkLatencySubmissionPresentIdNV { + VkStructureType sType; + const void* pNext; + uint64_t presentID; +} VkLatencySubmissionPresentIdNV; + +typedef struct VkSwapchainLatencyCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 latencyModeEnable; +} VkSwapchainLatencyCreateInfoNV; + +typedef struct VkOutOfBandQueueTypeInfoNV { + VkStructureType sType; + const void* pNext; + VkOutOfBandQueueTypeNV queueType; +} VkOutOfBandQueueTypeInfoNV; + +typedef struct VkLatencySurfaceCapabilitiesNV { + VkStructureType sType; + const void* pNext; + uint32_t presentModeCount; + VkPresentModeKHR* pPresentModes; +} VkLatencySurfaceCapabilitiesNV; + +typedef VkResult (VKAPI_PTR *PFN_vkSetLatencySleepModeNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo); +typedef VkResult (VKAPI_PTR *PFN_vkLatencySleepNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo); +typedef void (VKAPI_PTR *PFN_vkSetLatencyMarkerNV)(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo); +typedef void (VKAPI_PTR *PFN_vkGetLatencyTimingsNV)(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo); +typedef void (VKAPI_PTR *PFN_vkQueueNotifyOutOfBandNV)(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetLatencySleepModeNV( + VkDevice device, + VkSwapchainKHR swapchain, + const VkLatencySleepModeInfoNV* pSleepModeInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkLatencySleepNV( + VkDevice device, + VkSwapchainKHR swapchain, + const VkLatencySleepInfoNV* pSleepInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkSetLatencyMarkerNV( + VkDevice device, + VkSwapchainKHR swapchain, + const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetLatencyTimingsNV( + VkDevice device, + VkSwapchainKHR swapchain, + VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkQueueNotifyOutOfBandNV( + VkQueue queue, + const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); +#endif +#endif + + +// VK_ARM_data_graph is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_data_graph 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDataGraphPipelineSessionARM) +#define VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM 128U +#define VK_ARM_DATA_GRAPH_SPEC_VERSION 1 +#define VK_ARM_DATA_GRAPH_EXTENSION_NAME "VK_ARM_data_graph" + +typedef enum VkDataGraphPipelineSessionBindPointARM { + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM = 0, + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphPipelineSessionBindPointARM; + +typedef enum VkDataGraphPipelineSessionBindPointTypeARM { + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM = 0, + VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphPipelineSessionBindPointTypeARM; + +typedef enum VkDataGraphPipelinePropertyARM { + VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM = 0, + VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM = 1, + VK_DATA_GRAPH_PIPELINE_PROPERTY_MAX_ENUM_ARM = 0x7FFFFFFF +} VkDataGraphPipelinePropertyARM; + +typedef enum VkPhysicalDeviceDataGraphProcessingEngineTypeARM { + VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM = 0, + VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM = 1000629000, + VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM = 1000629001, + VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkPhysicalDeviceDataGraphProcessingEngineTypeARM; + +typedef enum VkPhysicalDeviceDataGraphOperationTypeARM { + VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM = 0, + VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM = 1000629000, + VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM = 1000629001, + VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF +} VkPhysicalDeviceDataGraphOperationTypeARM; +typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagsARM; + +// Flag bits for VkDataGraphPipelineSessionCreateFlagBitsARM +typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagBitsARM; +static const VkDataGraphPipelineSessionCreateFlagBitsARM VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM = 0x00000001ULL; + +typedef VkFlags64 VkDataGraphPipelineDispatchFlagsARM; + +// Flag bits for VkDataGraphPipelineDispatchFlagBitsARM +typedef VkFlags64 VkDataGraphPipelineDispatchFlagBitsARM; + +typedef struct VkPhysicalDeviceDataGraphFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 dataGraph; + VkBool32 dataGraphUpdateAfterBind; + VkBool32 dataGraphSpecializationConstants; + VkBool32 dataGraphDescriptorBuffer; + VkBool32 dataGraphShaderModule; +} VkPhysicalDeviceDataGraphFeaturesARM; + +typedef struct VkDataGraphPipelineConstantARM { + VkStructureType sType; + const void* pNext; + uint32_t id; + const void* pConstantData; +} VkDataGraphPipelineConstantARM; + +typedef struct VkDataGraphPipelineResourceInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSet; + uint32_t binding; + uint32_t arrayElement; +} VkDataGraphPipelineResourceInfoARM; + +typedef struct VkDataGraphPipelineCompilerControlCreateInfoARM { + VkStructureType sType; + const void* pNext; + const char* pVendorOptions; +} VkDataGraphPipelineCompilerControlCreateInfoARM; + +typedef struct VkDataGraphPipelineCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags2KHR flags; + VkPipelineLayout layout; + uint32_t resourceInfoCount; + const VkDataGraphPipelineResourceInfoARM* pResourceInfos; +} VkDataGraphPipelineCreateInfoARM; + +typedef struct VkDataGraphPipelineShaderModuleCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkShaderModule module; + const char* pName; + const VkSpecializationInfo* pSpecializationInfo; + uint32_t constantCount; + const VkDataGraphPipelineConstantARM* pConstants; +} VkDataGraphPipelineShaderModuleCreateInfoARM; + +typedef struct VkDataGraphPipelineSessionCreateInfoARM { + VkStructureType sType; + const void* pNext; + VkDataGraphPipelineSessionCreateFlagsARM flags; + VkPipeline dataGraphPipeline; +} VkDataGraphPipelineSessionCreateInfoARM; + +typedef struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM { + VkStructureType sType; + const void* pNext; + VkDataGraphPipelineSessionARM session; +} VkDataGraphPipelineSessionBindPointRequirementsInfoARM; + +typedef struct VkDataGraphPipelineSessionBindPointRequirementARM { + VkStructureType sType; + void* pNext; + VkDataGraphPipelineSessionBindPointARM bindPoint; + VkDataGraphPipelineSessionBindPointTypeARM bindPointType; + uint32_t numObjects; +} VkDataGraphPipelineSessionBindPointRequirementARM; + +typedef struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM { + VkStructureType sType; + const void* pNext; + VkDataGraphPipelineSessionARM session; + VkDataGraphPipelineSessionBindPointARM bindPoint; + uint32_t objectIndex; +} VkDataGraphPipelineSessionMemoryRequirementsInfoARM; + +typedef struct VkBindDataGraphPipelineSessionMemoryInfoARM { + VkStructureType sType; + const void* pNext; + VkDataGraphPipelineSessionARM session; + VkDataGraphPipelineSessionBindPointARM bindPoint; + uint32_t objectIndex; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindDataGraphPipelineSessionMemoryInfoARM; + +typedef struct VkDataGraphPipelineInfoARM { + VkStructureType sType; + const void* pNext; + VkPipeline dataGraphPipeline; +} VkDataGraphPipelineInfoARM; + +typedef struct VkDataGraphPipelinePropertyQueryResultARM { + VkStructureType sType; + void* pNext; + VkDataGraphPipelinePropertyARM property; + VkBool32 isText; + size_t dataSize; + void* pData; +} VkDataGraphPipelinePropertyQueryResultARM; + +typedef struct VkDataGraphPipelineIdentifierCreateInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t identifierSize; + const uint8_t* pIdentifier; +} VkDataGraphPipelineIdentifierCreateInfoARM; + +typedef struct VkDataGraphPipelineDispatchInfoARM { + VkStructureType sType; + void* pNext; + VkDataGraphPipelineDispatchFlagsARM flags; +} VkDataGraphPipelineDispatchInfoARM; + +typedef struct VkPhysicalDeviceDataGraphProcessingEngineARM { + VkPhysicalDeviceDataGraphProcessingEngineTypeARM type; + VkBool32 isForeign; +} VkPhysicalDeviceDataGraphProcessingEngineARM; + +typedef struct VkPhysicalDeviceDataGraphOperationSupportARM { + VkPhysicalDeviceDataGraphOperationTypeARM operationType; + char name[VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM]; + uint32_t version; +} VkPhysicalDeviceDataGraphOperationSupportARM; + +typedef struct VkQueueFamilyDataGraphPropertiesARM { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceDataGraphProcessingEngineARM engine; + VkPhysicalDeviceDataGraphOperationSupportARM operation; +} VkQueueFamilyDataGraphPropertiesARM; + +typedef struct VkDataGraphProcessingEngineCreateInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t processingEngineCount; + VkPhysicalDeviceDataGraphProcessingEngineARM* pProcessingEngines; +} VkDataGraphProcessingEngineCreateInfoARM; + +typedef struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + VkPhysicalDeviceDataGraphProcessingEngineTypeARM engineType; +} VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; + +typedef struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes; + VkExternalMemoryHandleTypeFlags foreignMemoryHandleTypes; +} VkQueueFamilyDataGraphProcessingEnginePropertiesARM; + +typedef struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM { + VkStructureType sType; + const void* pNext; + uint32_t dimension; + uint32_t zeroCount; + uint32_t groupSize; +} VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDataGraphPipelinesARM)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDataGraphPipelineSessionARM)(VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDataGraphPipelineSessionARM* pSession); +typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM)(VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements); +typedef void (VKAPI_PTR *PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM)(VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef VkResult (VKAPI_PTR *PFN_vkBindDataGraphPipelineSessionMemoryARM)(VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos); +typedef void (VKAPI_PTR *PFN_vkDestroyDataGraphPipelineSessionARM)(VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdDispatchDataGraphARM)(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelineAvailablePropertiesARM)(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t* pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelinePropertiesARM)(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties); +typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelinesARM( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkDataGraphPipelineCreateInfoARM* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelineSessionARM( + VkDevice device, + const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDataGraphPipelineSessionARM* pSession); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineSessionBindPointRequirementsARM( + VkDevice device, + const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, + uint32_t* pBindPointRequirementCount, + VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDataGraphPipelineSessionMemoryRequirementsARM( + VkDevice device, + const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBindDataGraphPipelineSessionMemoryARM( + VkDevice device, + uint32_t bindInfoCount, + const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyDataGraphPipelineSessionARM( + VkDevice device, + VkDataGraphPipelineSessionARM session, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchDataGraphARM( + VkCommandBuffer commandBuffer, + VkDataGraphPipelineSessionARM session, + const VkDataGraphPipelineDispatchInfoARM* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineAvailablePropertiesARM( + VkDevice device, + const VkDataGraphPipelineInfoARM* pPipelineInfo, + uint32_t* pPropertiesCount, + VkDataGraphPipelinePropertyARM* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelinePropertiesARM( + VkDevice device, + const VkDataGraphPipelineInfoARM* pPipelineInfo, + uint32_t propertiesCount, + VkDataGraphPipelinePropertyQueryResultARM* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pQueueFamilyDataGraphPropertyCount, + VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, + VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties); +#endif +#endif + + +// VK_QCOM_multiview_per_view_render_areas is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_multiview_per_view_render_areas 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1 +#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME "VK_QCOM_multiview_per_view_render_areas" +typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 multiviewPerViewRenderAreas; +} VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + +typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM { + VkStructureType sType; + const void* pNext; + uint32_t perViewRenderAreaCount; + const VkRect2D* pPerViewRenderAreas; +} VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + + + +// VK_NV_per_stage_descriptor_set is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_per_stage_descriptor_set 1 +#define VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION 1 +#define VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME "VK_NV_per_stage_descriptor_set" +typedef struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 perStageDescriptorSet; + VkBool32 dynamicPipelineLayout; +} VkPhysicalDevicePerStageDescriptorSetFeaturesNV; + + + +// VK_QCOM_image_processing2 is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_image_processing2 1 +#define VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION 1 +#define VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME "VK_QCOM_image_processing2" + +typedef enum VkBlockMatchWindowCompareModeQCOM { + VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM = 0, + VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM = 1, + VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_ENUM_QCOM = 0x7FFFFFFF +} VkBlockMatchWindowCompareModeQCOM; +typedef struct VkPhysicalDeviceImageProcessing2FeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 textureBlockMatch2; +} VkPhysicalDeviceImageProcessing2FeaturesQCOM; + +typedef struct VkPhysicalDeviceImageProcessing2PropertiesQCOM { + VkStructureType sType; + void* pNext; + VkExtent2D maxBlockMatchWindow; +} VkPhysicalDeviceImageProcessing2PropertiesQCOM; + +typedef struct VkSamplerBlockMatchWindowCreateInfoQCOM { + VkStructureType sType; + const void* pNext; + VkExtent2D windowExtent; + VkBlockMatchWindowCompareModeQCOM windowCompareMode; +} VkSamplerBlockMatchWindowCreateInfoQCOM; + + + +// VK_QCOM_filter_cubic_weights is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_filter_cubic_weights 1 +#define VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION 1 +#define VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME "VK_QCOM_filter_cubic_weights" + +typedef enum VkCubicFilterWeightsQCOM { + VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM = 0, + VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM = 1, + VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM = 2, + VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM = 3, + VK_CUBIC_FILTER_WEIGHTS_MAX_ENUM_QCOM = 0x7FFFFFFF +} VkCubicFilterWeightsQCOM; +typedef struct VkPhysicalDeviceCubicWeightsFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 selectableCubicWeights; +} VkPhysicalDeviceCubicWeightsFeaturesQCOM; + +typedef struct VkSamplerCubicWeightsCreateInfoQCOM { + VkStructureType sType; + const void* pNext; + VkCubicFilterWeightsQCOM cubicWeights; +} VkSamplerCubicWeightsCreateInfoQCOM; + +typedef struct VkBlitImageCubicWeightsInfoQCOM { + VkStructureType sType; + const void* pNext; + VkCubicFilterWeightsQCOM cubicWeights; +} VkBlitImageCubicWeightsInfoQCOM; + + + +// VK_QCOM_ycbcr_degamma is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_ycbcr_degamma 1 +#define VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION 1 +#define VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME "VK_QCOM_ycbcr_degamma" +typedef struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 ycbcrDegamma; +} VkPhysicalDeviceYcbcrDegammaFeaturesQCOM; + +typedef struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM { + VkStructureType sType; + void* pNext; + VkBool32 enableYDegamma; + VkBool32 enableCbCrDegamma; +} VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; + + + +// VK_QCOM_filter_cubic_clamp is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_filter_cubic_clamp 1 +#define VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION 1 +#define VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME "VK_QCOM_filter_cubic_clamp" +typedef struct VkPhysicalDeviceCubicClampFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 cubicRangeClamp; +} VkPhysicalDeviceCubicClampFeaturesQCOM; + + + +// VK_EXT_attachment_feedback_loop_dynamic_state is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_attachment_feedback_loop_dynamic_state 1 +#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION 1 +#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_attachment_feedback_loop_dynamic_state" +typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 attachmentFeedbackLoopDynamicState; +} VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT)(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetAttachmentFeedbackLoopEnableEXT( + VkCommandBuffer commandBuffer, + VkImageAspectFlags aspectMask); +#endif +#endif + + +// VK_MSFT_layered_driver is a preprocessor guard. Do not pass it to API calls. +#define VK_MSFT_layered_driver 1 +#define VK_MSFT_LAYERED_DRIVER_SPEC_VERSION 1 +#define VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME "VK_MSFT_layered_driver" + +typedef enum VkLayeredDriverUnderlyingApiMSFT { + VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT = 0, + VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT = 1, + VK_LAYERED_DRIVER_UNDERLYING_API_MAX_ENUM_MSFT = 0x7FFFFFFF +} VkLayeredDriverUnderlyingApiMSFT; +typedef struct VkPhysicalDeviceLayeredDriverPropertiesMSFT { + VkStructureType sType; + void* pNext; + VkLayeredDriverUnderlyingApiMSFT underlyingAPI; +} VkPhysicalDeviceLayeredDriverPropertiesMSFT; + + + +// VK_NV_descriptor_pool_overallocation is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_descriptor_pool_overallocation 1 +#define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION 1 +#define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME "VK_NV_descriptor_pool_overallocation" +typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 descriptorPoolOverallocation; +} VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + + + +// VK_QCOM_tile_memory_heap is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_tile_memory_heap 1 +#define VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION 1 +#define VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME "VK_QCOM_tile_memory_heap" +typedef struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 tileMemoryHeap; +} VkPhysicalDeviceTileMemoryHeapFeaturesQCOM; + +typedef struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 queueSubmitBoundary; + VkBool32 tileBufferTransfers; +} VkPhysicalDeviceTileMemoryHeapPropertiesQCOM; + +typedef struct VkTileMemoryRequirementsQCOM { + VkStructureType sType; + void* pNext; + VkDeviceSize size; + VkDeviceSize alignment; +} VkTileMemoryRequirementsQCOM; + +typedef struct VkTileMemoryBindInfoQCOM { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkTileMemoryBindInfoQCOM; + +typedef struct VkTileMemorySizeInfoQCOM { + VkStructureType sType; + const void* pNext; + VkDeviceSize size; +} VkTileMemorySizeInfoQCOM; + +typedef void (VKAPI_PTR *PFN_vkCmdBindTileMemoryQCOM)(VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBindTileMemoryQCOM( + VkCommandBuffer commandBuffer, + const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo); +#endif +#endif + + +// VK_EXT_memory_decompression is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_memory_decompression 1 +#define VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION 1 +#define VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME "VK_EXT_memory_decompression" +typedef struct VkDecompressMemoryRegionEXT { + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize compressedSize; + VkDeviceSize decompressedSize; +} VkDecompressMemoryRegionEXT; + +typedef struct VkDecompressMemoryInfoEXT { + VkStructureType sType; + const void* pNext; + VkMemoryDecompressionMethodFlagsEXT decompressionMethod; + uint32_t regionCount; + const VkDecompressMemoryRegionEXT* pRegions; +} VkDecompressMemoryInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryEXT)(VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT); +typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryIndirectCountEXT)(VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t maxDecompressionCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryEXT( + VkCommandBuffer commandBuffer, + const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountEXT( + VkCommandBuffer commandBuffer, + VkMemoryDecompressionMethodFlagsEXT decompressionMethod, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t maxDecompressionCount, + uint32_t stride); +#endif +#endif + + +// VK_NV_display_stereo is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_display_stereo 1 +#define VK_NV_DISPLAY_STEREO_SPEC_VERSION 1 +#define VK_NV_DISPLAY_STEREO_EXTENSION_NAME "VK_NV_display_stereo" + +typedef enum VkDisplaySurfaceStereoTypeNV { + VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV = 0, + VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV = 1, + VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV = 2, + VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV = 3, + VK_DISPLAY_SURFACE_STEREO_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkDisplaySurfaceStereoTypeNV; +typedef struct VkDisplaySurfaceStereoCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkDisplaySurfaceStereoTypeNV stereoType; +} VkDisplaySurfaceStereoCreateInfoNV; + +typedef struct VkDisplayModeStereoPropertiesNV { + VkStructureType sType; + void* pNext; + VkBool32 hdmi3DSupported; +} VkDisplayModeStereoPropertiesNV; + + + +// VK_NV_raw_access_chains is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_raw_access_chains 1 +#define VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION 1 +#define VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME "VK_NV_raw_access_chains" +typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shaderRawAccessChains; +} VkPhysicalDeviceRawAccessChainsFeaturesNV; + + + +// VK_NV_external_compute_queue is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_external_compute_queue 1 +VK_DEFINE_HANDLE(VkExternalComputeQueueNV) +#define VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME "VK_NV_external_compute_queue" +typedef struct VkExternalComputeQueueDeviceCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t reservedExternalQueues; +} VkExternalComputeQueueDeviceCreateInfoNV; + +typedef struct VkExternalComputeQueueCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkQueue preferredQueue; +} VkExternalComputeQueueCreateInfoNV; + +typedef struct VkExternalComputeQueueDataParamsNV { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndex; +} VkExternalComputeQueueDataParamsNV; + +typedef struct VkPhysicalDeviceExternalComputeQueuePropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t externalDataSize; + uint32_t maxExternalQueues; +} VkPhysicalDeviceExternalComputeQueuePropertiesNV; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateExternalComputeQueueNV)(VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue); +typedef void (VKAPI_PTR *PFN_vkDestroyExternalComputeQueueNV)(VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetExternalComputeQueueDataNV)(VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateExternalComputeQueueNV( + VkDevice device, + const VkExternalComputeQueueCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkExternalComputeQueueNV* pExternalQueue); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyExternalComputeQueueNV( + VkDevice device, + VkExternalComputeQueueNV externalQueue, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetExternalComputeQueueDataNV( + VkExternalComputeQueueNV externalQueue, + VkExternalComputeQueueDataParamsNV* params, + void* pData); +#endif +#endif + + +// VK_NV_command_buffer_inheritance is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_command_buffer_inheritance 1 +#define VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION 1 +#define VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME "VK_NV_command_buffer_inheritance" +typedef struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 commandBufferInheritance; +} VkPhysicalDeviceCommandBufferInheritanceFeaturesNV; + + + +// VK_NV_shader_atomic_float16_vector is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_shader_atomic_float16_vector 1 +#define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION 1 +#define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME "VK_NV_shader_atomic_float16_vector" +typedef struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloat16VectorAtomics; +} VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + + + +// VK_EXT_shader_replicated_composites is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_replicated_composites 1 +#define VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION 1 +#define VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME "VK_EXT_shader_replicated_composites" +typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderReplicatedComposites; +} VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT; + + + +// VK_EXT_shader_float8 is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_float8 1 +#define VK_EXT_SHADER_FLOAT8_SPEC_VERSION 1 +#define VK_EXT_SHADER_FLOAT8_EXTENSION_NAME "VK_EXT_shader_float8" +typedef struct VkPhysicalDeviceShaderFloat8FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloat8; + VkBool32 shaderFloat8CooperativeMatrix; +} VkPhysicalDeviceShaderFloat8FeaturesEXT; + + + +// VK_NV_ray_tracing_validation is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_ray_tracing_validation 1 +#define VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION 1 +#define VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME "VK_NV_ray_tracing_validation" +typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingValidation; +} VkPhysicalDeviceRayTracingValidationFeaturesNV; + + + +// VK_NV_cluster_acceleration_structure is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_cluster_acceleration_structure 1 +#define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION 4 +#define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_NV_cluster_acceleration_structure" + +typedef enum VkClusterAccelerationStructureTypeNV { + VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV = 0, + VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV = 1, + VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV = 2, + VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkClusterAccelerationStructureTypeNV; + +typedef enum VkClusterAccelerationStructureOpTypeNV { + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV = 0, + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV = 1, + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV = 2, + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV = 3, + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV = 4, + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV = 5, + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkClusterAccelerationStructureOpTypeNV; + +typedef enum VkClusterAccelerationStructureOpModeNV { + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV = 0, + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV = 1, + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV = 2, + VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkClusterAccelerationStructureOpModeNV; + +typedef enum VkClusterAccelerationStructureAddressResolutionFlagBitsNV { + VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV = 0, + VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV = 0x00000001, + VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV = 0x00000002, + VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV = 0x00000004, + VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV = 0x00000008, + VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV = 0x00000010, + VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV = 0x00000020, + VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkClusterAccelerationStructureAddressResolutionFlagBitsNV; +typedef VkFlags VkClusterAccelerationStructureAddressResolutionFlagsNV; + +typedef enum VkClusterAccelerationStructureClusterFlagBitsNV { + VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV = 0x00000001, + VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkClusterAccelerationStructureClusterFlagBitsNV; +typedef VkFlags VkClusterAccelerationStructureClusterFlagsNV; + +typedef enum VkClusterAccelerationStructureGeometryFlagBitsNV { + VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV = 0x00000001, + VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV = 0x00000002, + VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV = 0x00000004, + VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkClusterAccelerationStructureGeometryFlagBitsNV; +typedef VkFlags VkClusterAccelerationStructureGeometryFlagsNV; + +typedef enum VkClusterAccelerationStructureIndexFormatFlagBitsNV { + VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV = 0x00000001, + VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV = 0x00000002, + VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV = 0x00000004, + VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkClusterAccelerationStructureIndexFormatFlagBitsNV; +typedef VkFlags VkClusterAccelerationStructureIndexFormatFlagsNV; +typedef struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 clusterAccelerationStructure; +} VkPhysicalDeviceClusterAccelerationStructureFeaturesNV; + +typedef struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxVerticesPerCluster; + uint32_t maxTrianglesPerCluster; + uint32_t clusterScratchByteAlignment; + uint32_t clusterByteAlignment; + uint32_t clusterTemplateByteAlignment; + uint32_t clusterBottomLevelByteAlignment; + uint32_t clusterTemplateBoundsByteAlignment; + uint32_t maxClusterGeometryIndex; +} VkPhysicalDeviceClusterAccelerationStructurePropertiesNV; + +typedef struct VkClusterAccelerationStructureClustersBottomLevelInputNV { + VkStructureType sType; + void* pNext; + uint32_t maxTotalClusterCount; + uint32_t maxClusterCountPerAccelerationStructure; +} VkClusterAccelerationStructureClustersBottomLevelInputNV; + +typedef struct VkClusterAccelerationStructureTriangleClusterInputNV { + VkStructureType sType; + void* pNext; + VkFormat vertexFormat; + uint32_t maxGeometryIndexValue; + uint32_t maxClusterUniqueGeometryCount; + uint32_t maxClusterTriangleCount; + uint32_t maxClusterVertexCount; + uint32_t maxTotalTriangleCount; + uint32_t maxTotalVertexCount; + uint32_t minPositionTruncateBitCount; +} VkClusterAccelerationStructureTriangleClusterInputNV; + +typedef struct VkClusterAccelerationStructureMoveObjectsInputNV { + VkStructureType sType; + void* pNext; + VkClusterAccelerationStructureTypeNV type; + VkBool32 noMoveOverlap; + VkDeviceSize maxMovedBytes; +} VkClusterAccelerationStructureMoveObjectsInputNV; + +typedef union VkClusterAccelerationStructureOpInputNV { + VkClusterAccelerationStructureClustersBottomLevelInputNV* pClustersBottomLevel; + VkClusterAccelerationStructureTriangleClusterInputNV* pTriangleClusters; + VkClusterAccelerationStructureMoveObjectsInputNV* pMoveObjects; +} VkClusterAccelerationStructureOpInputNV; + +typedef struct VkClusterAccelerationStructureInputInfoNV { + VkStructureType sType; + void* pNext; + uint32_t maxAccelerationStructureCount; + VkBuildAccelerationStructureFlagsKHR flags; + VkClusterAccelerationStructureOpTypeNV opType; + VkClusterAccelerationStructureOpModeNV opMode; + VkClusterAccelerationStructureOpInputNV opInput; +} VkClusterAccelerationStructureInputInfoNV; + +typedef struct VkStridedDeviceAddressRegionKHR { + VkDeviceAddress deviceAddress; + VkDeviceSize stride; + VkDeviceSize size; +} VkStridedDeviceAddressRegionKHR; + +typedef struct VkClusterAccelerationStructureCommandsInfoNV { + VkStructureType sType; + void* pNext; + VkClusterAccelerationStructureInputInfoNV input; + VkDeviceAddress dstImplicitData; + VkDeviceAddress scratchData; + VkStridedDeviceAddressRegionKHR dstAddressesArray; + VkStridedDeviceAddressRegionKHR dstSizesArray; + VkStridedDeviceAddressRegionKHR srcInfosArray; + VkDeviceAddress srcInfosCount; + VkClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags; +} VkClusterAccelerationStructureCommandsInfoNV; + +typedef struct VkStridedDeviceAddressNV { + VkDeviceAddress startAddress; + VkDeviceSize strideInBytes; +} VkStridedDeviceAddressNV; + +typedef struct VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV { + uint32_t geometryIndex:24; + uint32_t reserved:5; + uint32_t geometryFlags:3; +} VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV; + +typedef struct VkClusterAccelerationStructureMoveObjectsInfoNV { + VkDeviceAddress srcAccelerationStructure; +} VkClusterAccelerationStructureMoveObjectsInfoNV; + +typedef struct VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV { + uint32_t clusterReferencesCount; + uint32_t clusterReferencesStride; + VkDeviceAddress clusterReferences; +} VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV; + +typedef struct VkClusterAccelerationStructureBuildTriangleClusterInfoNV { + uint32_t clusterID; + VkClusterAccelerationStructureClusterFlagsNV clusterFlags; + uint32_t triangleCount:9; + uint32_t vertexCount:9; + uint32_t positionTruncateBitCount:6; + uint32_t indexType:4; + uint32_t opacityMicromapIndexType:4; + VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags; + uint16_t indexBufferStride; + uint16_t vertexBufferStride; + uint16_t geometryIndexAndFlagsBufferStride; + uint16_t opacityMicromapIndexBufferStride; + VkDeviceAddress indexBuffer; + VkDeviceAddress vertexBuffer; + VkDeviceAddress geometryIndexAndFlagsBuffer; + VkDeviceAddress opacityMicromapArray; + VkDeviceAddress opacityMicromapIndexBuffer; +} VkClusterAccelerationStructureBuildTriangleClusterInfoNV; + +typedef struct VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV { + uint32_t clusterID; + VkClusterAccelerationStructureClusterFlagsNV clusterFlags; + uint32_t triangleCount:9; + uint32_t vertexCount:9; + uint32_t positionTruncateBitCount:6; + uint32_t indexType:4; + uint32_t opacityMicromapIndexType:4; + VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags; + uint16_t indexBufferStride; + uint16_t vertexBufferStride; + uint16_t geometryIndexAndFlagsBufferStride; + uint16_t opacityMicromapIndexBufferStride; + VkDeviceAddress indexBuffer; + VkDeviceAddress vertexBuffer; + VkDeviceAddress geometryIndexAndFlagsBuffer; + VkDeviceAddress opacityMicromapArray; + VkDeviceAddress opacityMicromapIndexBuffer; + VkDeviceAddress instantiationBoundingBoxLimit; +} VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV; + +typedef struct VkClusterAccelerationStructureInstantiateClusterInfoNV { + uint32_t clusterIdOffset; + uint32_t geometryIndexOffset:24; + uint32_t reserved:8; + VkDeviceAddress clusterTemplateAddress; + VkStridedDeviceAddressNV vertexBuffer; +} VkClusterAccelerationStructureInstantiateClusterInfoNV; + +typedef struct VkClusterAccelerationStructureGetTemplateIndicesInfoNV { + VkDeviceAddress clusterTemplateAddress; +} VkClusterAccelerationStructureGetTemplateIndicesInfoNV; + +typedef struct VkAccelerationStructureBuildSizesInfoKHR { + VkStructureType sType; + void* pNext; + VkDeviceSize accelerationStructureSize; + VkDeviceSize updateScratchSize; + VkDeviceSize buildScratchSize; +} VkAccelerationStructureBuildSizesInfoKHR; + +typedef struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV { + VkStructureType sType; + void* pNext; + VkBool32 allowClusterAccelerationStructure; +} VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV; + +typedef void (VKAPI_PTR *PFN_vkGetClusterAccelerationStructureBuildSizesNV)(VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBuildClusterAccelerationStructureIndirectNV)(VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetClusterAccelerationStructureBuildSizesNV( + VkDevice device, + const VkClusterAccelerationStructureInputInfoNV* pInfo, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBuildClusterAccelerationStructureIndirectNV( + VkCommandBuffer commandBuffer, + const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos); +#endif +#endif + + +// VK_NV_partitioned_acceleration_structure is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_partitioned_acceleration_structure 1 +#define VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION 1 +#define VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_NV_partitioned_acceleration_structure" +#define VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV (~0U) + +typedef enum VkPartitionedAccelerationStructureOpTypeNV { + VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV = 0, + VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV = 1, + VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV = 2, + VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkPartitionedAccelerationStructureOpTypeNV; + +typedef enum VkPartitionedAccelerationStructureInstanceFlagBitsNV { + VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV = 0x00000001, + VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV = 0x00000002, + VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV = 0x00000004, + VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV = 0x00000008, + VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV = 0x00000010, + VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkPartitionedAccelerationStructureInstanceFlagBitsNV; +typedef VkFlags VkPartitionedAccelerationStructureInstanceFlagsNV; +typedef struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 partitionedAccelerationStructure; +} VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV; + +typedef struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxPartitionCount; +} VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV; + +typedef struct VkPartitionedAccelerationStructureFlagsNV { + VkStructureType sType; + void* pNext; + VkBool32 enablePartitionTranslation; +} VkPartitionedAccelerationStructureFlagsNV; + +typedef struct VkBuildPartitionedAccelerationStructureIndirectCommandNV { + VkPartitionedAccelerationStructureOpTypeNV opType; + uint32_t argCount; + VkStridedDeviceAddressNV argData; +} VkBuildPartitionedAccelerationStructureIndirectCommandNV; + +typedef struct VkPartitionedAccelerationStructureWriteInstanceDataNV { + VkTransformMatrixKHR transform; + float explicitAABB[6]; + uint32_t instanceID; + uint32_t instanceMask; + uint32_t instanceContributionToHitGroupIndex; + VkPartitionedAccelerationStructureInstanceFlagsNV instanceFlags; + uint32_t instanceIndex; + uint32_t partitionIndex; + VkDeviceAddress accelerationStructure; +} VkPartitionedAccelerationStructureWriteInstanceDataNV; + +typedef struct VkPartitionedAccelerationStructureUpdateInstanceDataNV { + uint32_t instanceIndex; + uint32_t instanceContributionToHitGroupIndex; + VkDeviceAddress accelerationStructure; +} VkPartitionedAccelerationStructureUpdateInstanceDataNV; + +typedef struct VkPartitionedAccelerationStructureWritePartitionTranslationDataNV { + uint32_t partitionIndex; + float partitionTranslation[3]; +} VkPartitionedAccelerationStructureWritePartitionTranslationDataNV; + +typedef struct VkWriteDescriptorSetPartitionedAccelerationStructureNV { + VkStructureType sType; + void* pNext; + uint32_t accelerationStructureCount; + const VkDeviceAddress* pAccelerationStructures; +} VkWriteDescriptorSetPartitionedAccelerationStructureNV; + +typedef struct VkPartitionedAccelerationStructureInstancesInputNV { + VkStructureType sType; + void* pNext; + VkBuildAccelerationStructureFlagsKHR flags; + uint32_t instanceCount; + uint32_t maxInstancePerPartitionCount; + uint32_t partitionCount; + uint32_t maxInstanceInGlobalPartitionCount; +} VkPartitionedAccelerationStructureInstancesInputNV; + +typedef struct VkBuildPartitionedAccelerationStructureInfoNV { + VkStructureType sType; + void* pNext; + VkPartitionedAccelerationStructureInstancesInputNV input; + VkDeviceAddress srcAccelerationStructureData; + VkDeviceAddress dstAccelerationStructureData; + VkDeviceAddress scratchData; + VkDeviceAddress srcInfos; + VkDeviceAddress srcInfosCount; +} VkBuildPartitionedAccelerationStructureInfoNV; + +typedef void (VKAPI_PTR *PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV)(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +typedef void (VKAPI_PTR *PFN_vkCmdBuildPartitionedAccelerationStructuresNV)(VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetPartitionedAccelerationStructuresBuildSizesNV( + VkDevice device, + const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBuildPartitionedAccelerationStructuresNV( + VkCommandBuffer commandBuffer, + const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo); +#endif +#endif + + +// VK_EXT_device_generated_commands is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_device_generated_commands 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectExecutionSetEXT) +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutEXT) +#define VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 1 +#define VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_EXT_device_generated_commands" + +typedef enum VkIndirectExecutionSetInfoTypeEXT { + VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT = 0, + VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT = 1, + VK_INDIRECT_EXECUTION_SET_INFO_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkIndirectExecutionSetInfoTypeEXT; + +typedef enum VkIndirectCommandsTokenTypeEXT { + VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT = 0, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT = 1, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT = 2, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT = 3, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT = 4, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT = 5, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT = 6, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT = 8, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT = 9, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT = 1000135000, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT = 1000135001, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT = 1000202002, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT = 1000202003, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT = 1000328000, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT = 1000328001, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT = 1000386004, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkIndirectCommandsTokenTypeEXT; + +typedef enum VkIndirectCommandsInputModeFlagBitsEXT { + VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT = 0x00000001, + VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT = 0x00000002, + VK_INDIRECT_COMMANDS_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkIndirectCommandsInputModeFlagBitsEXT; +typedef VkFlags VkIndirectCommandsInputModeFlagsEXT; + +typedef enum VkIndirectCommandsLayoutUsageFlagBitsEXT { + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT = 0x00000001, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT = 0x00000002, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkIndirectCommandsLayoutUsageFlagBitsEXT; +typedef VkFlags VkIndirectCommandsLayoutUsageFlagsEXT; +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 deviceGeneratedCommands; + VkBool32 dynamicGeneratedPipelineLayout; +} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxIndirectPipelineCount; + uint32_t maxIndirectShaderObjectCount; + uint32_t maxIndirectSequenceCount; + uint32_t maxIndirectCommandsTokenCount; + uint32_t maxIndirectCommandsTokenOffset; + uint32_t maxIndirectCommandsIndirectStride; + VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes; + VkShaderStageFlags supportedIndirectCommandsShaderStages; + VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding; + VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding; + VkBool32 deviceGeneratedCommandsTransformFeedback; + VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount; +} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + +typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT { + VkStructureType sType; + const void* pNext; + VkIndirectExecutionSetEXT indirectExecutionSet; + VkIndirectCommandsLayoutEXT indirectCommandsLayout; + uint32_t maxSequenceCount; + uint32_t maxDrawCount; +} VkGeneratedCommandsMemoryRequirementsInfoEXT; + +typedef struct VkIndirectExecutionSetPipelineInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipeline initialPipeline; + uint32_t maxPipelineCount; +} VkIndirectExecutionSetPipelineInfoEXT; + +typedef struct VkIndirectExecutionSetShaderLayoutInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; +} VkIndirectExecutionSetShaderLayoutInfoEXT; + +typedef struct VkIndirectExecutionSetShaderInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t shaderCount; + const VkShaderEXT* pInitialShaders; + const VkIndirectExecutionSetShaderLayoutInfoEXT* pSetLayoutInfos; + uint32_t maxShaderCount; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkIndirectExecutionSetShaderInfoEXT; + +typedef union VkIndirectExecutionSetInfoEXT { + const VkIndirectExecutionSetPipelineInfoEXT* pPipelineInfo; + const VkIndirectExecutionSetShaderInfoEXT* pShaderInfo; +} VkIndirectExecutionSetInfoEXT; + +typedef struct VkIndirectExecutionSetCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkIndirectExecutionSetInfoTypeEXT type; + VkIndirectExecutionSetInfoEXT info; +} VkIndirectExecutionSetCreateInfoEXT; + +typedef struct VkGeneratedCommandsInfoEXT { + VkStructureType sType; + const void* pNext; + VkShaderStageFlags shaderStages; + VkIndirectExecutionSetEXT indirectExecutionSet; + VkIndirectCommandsLayoutEXT indirectCommandsLayout; + VkDeviceAddress indirectAddress; + VkDeviceSize indirectAddressSize; + VkDeviceAddress preprocessAddress; + VkDeviceSize preprocessSize; + uint32_t maxSequenceCount; + VkDeviceAddress sequenceCountAddress; + uint32_t maxDrawCount; +} VkGeneratedCommandsInfoEXT; + +typedef struct VkWriteIndirectExecutionSetPipelineEXT { + VkStructureType sType; + const void* pNext; + uint32_t index; + VkPipeline pipeline; +} VkWriteIndirectExecutionSetPipelineEXT; + +typedef struct VkIndirectCommandsPushConstantTokenEXT { + VkPushConstantRange updateRange; +} VkIndirectCommandsPushConstantTokenEXT; + +typedef struct VkIndirectCommandsVertexBufferTokenEXT { + uint32_t vertexBindingUnit; +} VkIndirectCommandsVertexBufferTokenEXT; + +typedef struct VkIndirectCommandsIndexBufferTokenEXT { + VkIndirectCommandsInputModeFlagBitsEXT mode; +} VkIndirectCommandsIndexBufferTokenEXT; + +typedef struct VkIndirectCommandsExecutionSetTokenEXT { + VkIndirectExecutionSetInfoTypeEXT type; + VkShaderStageFlags shaderStages; +} VkIndirectCommandsExecutionSetTokenEXT; + +typedef union VkIndirectCommandsTokenDataEXT { + const VkIndirectCommandsPushConstantTokenEXT* pPushConstant; + const VkIndirectCommandsVertexBufferTokenEXT* pVertexBuffer; + const VkIndirectCommandsIndexBufferTokenEXT* pIndexBuffer; + const VkIndirectCommandsExecutionSetTokenEXT* pExecutionSet; +} VkIndirectCommandsTokenDataEXT; + +typedef struct VkIndirectCommandsLayoutTokenEXT { + VkStructureType sType; + const void* pNext; + VkIndirectCommandsTokenTypeEXT type; + VkIndirectCommandsTokenDataEXT data; + uint32_t offset; +} VkIndirectCommandsLayoutTokenEXT; + +typedef struct VkIndirectCommandsLayoutCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkIndirectCommandsLayoutUsageFlagsEXT flags; + VkShaderStageFlags shaderStages; + uint32_t indirectStride; + VkPipelineLayout pipelineLayout; + uint32_t tokenCount; + const VkIndirectCommandsLayoutTokenEXT* pTokens; +} VkIndirectCommandsLayoutCreateInfoEXT; + +typedef struct VkDrawIndirectCountIndirectCommandEXT { + VkDeviceAddress bufferAddress; + uint32_t stride; + uint32_t commandCount; +} VkDrawIndirectCountIndirectCommandEXT; + +typedef struct VkBindVertexBufferIndirectCommandEXT { + VkDeviceAddress bufferAddress; + uint32_t size; + uint32_t stride; +} VkBindVertexBufferIndirectCommandEXT; + +typedef struct VkBindIndexBufferIndirectCommandEXT { + VkDeviceAddress bufferAddress; + uint32_t size; + VkIndexType indexType; +} VkBindIndexBufferIndirectCommandEXT; + +typedef struct VkGeneratedCommandsPipelineInfoEXT { + VkStructureType sType; + void* pNext; + VkPipeline pipeline; +} VkGeneratedCommandsPipelineInfoEXT; + +typedef struct VkGeneratedCommandsShaderInfoEXT { + VkStructureType sType; + void* pNext; + uint32_t shaderCount; + const VkShaderEXT* pShaders; +} VkGeneratedCommandsShaderInfoEXT; + +typedef struct VkWriteIndirectExecutionSetShaderEXT { + VkStructureType sType; + const void* pNext; + uint32_t index; + VkShaderEXT shader; +} VkWriteIndirectExecutionSetShaderEXT; + +typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsEXT)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsEXT)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutEXT)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout); +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutEXT)(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectExecutionSetEXT)(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet); +typedef void (VKAPI_PTR *PFN_vkDestroyIndirectExecutionSetEXT)(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetPipelineEXT)(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites); +typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetShaderEXT)(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, + VkMemoryRequirements2* pMemoryRequirements); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsEXT( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutEXT( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutEXT( + VkDevice device, + VkIndirectCommandsLayoutEXT indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectExecutionSetEXT( + VkDevice device, + const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectExecutionSetEXT* pIndirectExecutionSet); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectExecutionSetEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetPipelineEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetShaderEXT( + VkDevice device, + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); +#endif +#endif + + +// VK_MESA_image_alignment_control is a preprocessor guard. Do not pass it to API calls. +#define VK_MESA_image_alignment_control 1 +#define VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION 1 +#define VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME "VK_MESA_image_alignment_control" +typedef struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA { + VkStructureType sType; + void* pNext; + VkBool32 imageAlignmentControl; +} VkPhysicalDeviceImageAlignmentControlFeaturesMESA; + +typedef struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA { + VkStructureType sType; + void* pNext; + uint32_t supportedImageAlignmentMask; +} VkPhysicalDeviceImageAlignmentControlPropertiesMESA; + +typedef struct VkImageAlignmentControlCreateInfoMESA { + VkStructureType sType; + const void* pNext; + uint32_t maximumRequestedAlignment; +} VkImageAlignmentControlCreateInfoMESA; + + + +// VK_NV_push_constant_bank is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_push_constant_bank 1 +#define VK_NV_PUSH_CONSTANT_BANK_SPEC_VERSION 1 +#define VK_NV_PUSH_CONSTANT_BANK_EXTENSION_NAME "VK_NV_push_constant_bank" +typedef struct VkPushConstantBankInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t bank; +} VkPushConstantBankInfoNV; + +typedef struct VkPhysicalDevicePushConstantBankFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 pushConstantBank; +} VkPhysicalDevicePushConstantBankFeaturesNV; + +typedef struct VkPhysicalDevicePushConstantBankPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxGraphicsPushConstantBanks; + uint32_t maxComputePushConstantBanks; + uint32_t maxGraphicsPushDataBanks; + uint32_t maxComputePushDataBanks; +} VkPhysicalDevicePushConstantBankPropertiesNV; + + + +// VK_EXT_ray_tracing_invocation_reorder is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_ray_tracing_invocation_reorder 1 +#define VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 1 +#define VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME "VK_EXT_ray_tracing_invocation_reorder" +typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT { + VkStructureType sType; + void* pNext; + VkRayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint; + uint32_t maxShaderBindingTableRecordIndex; +} VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT; + +typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingInvocationReorder; +} VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT; + + + +// VK_EXT_depth_clamp_control is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_depth_clamp_control 1 +#define VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION 1 +#define VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clamp_control" +typedef struct VkPhysicalDeviceDepthClampControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClampControl; +} VkPhysicalDeviceDepthClampControlFeaturesEXT; + +typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDepthClampModeEXT depthClampMode; + const VkDepthClampRangeEXT* pDepthClampRange; +} VkPipelineViewportDepthClampControlCreateInfoEXT; + + + +// VK_HUAWEI_hdr_vivid is a preprocessor guard. Do not pass it to API calls. +#define VK_HUAWEI_hdr_vivid 1 +#define VK_HUAWEI_HDR_VIVID_SPEC_VERSION 1 +#define VK_HUAWEI_HDR_VIVID_EXTENSION_NAME "VK_HUAWEI_hdr_vivid" +typedef struct VkPhysicalDeviceHdrVividFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 hdrVivid; +} VkPhysicalDeviceHdrVividFeaturesHUAWEI; + +typedef struct VkHdrVividDynamicMetadataHUAWEI { + VkStructureType sType; + const void* pNext; + size_t dynamicMetadataSize; + const void* pDynamicMetadata; +} VkHdrVividDynamicMetadataHUAWEI; + + + +// VK_NV_cooperative_matrix2 is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_cooperative_matrix2 1 +#define VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION 1 +#define VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME "VK_NV_cooperative_matrix2" +typedef struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t MGranularity; + uint32_t NGranularity; + uint32_t KGranularity; + VkComponentTypeKHR AType; + VkComponentTypeKHR BType; + VkComponentTypeKHR CType; + VkComponentTypeKHR ResultType; + VkBool32 saturatingAccumulation; + VkScopeKHR scope; + uint32_t workgroupInvocations; +} VkCooperativeMatrixFlexibleDimensionsPropertiesNV; + +typedef struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cooperativeMatrixWorkgroupScope; + VkBool32 cooperativeMatrixFlexibleDimensions; + VkBool32 cooperativeMatrixReductions; + VkBool32 cooperativeMatrixConversions; + VkBool32 cooperativeMatrixPerElementOperations; + VkBool32 cooperativeMatrixTensorAddressing; + VkBool32 cooperativeMatrixBlockLoads; +} VkPhysicalDeviceCooperativeMatrix2FeaturesNV; + +typedef struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize; + uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension; + uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory; +} VkPhysicalDeviceCooperativeMatrix2PropertiesNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties); +#endif +#endif + + +// VK_ARM_pipeline_opacity_micromap is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_pipeline_opacity_micromap 1 +#define VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION 1 +#define VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME "VK_ARM_pipeline_opacity_micromap" +typedef struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 pipelineOpacityMicromap; +} VkPhysicalDevicePipelineOpacityMicromapFeaturesARM; + + + +// VK_ARM_performance_counters_by_region is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_performance_counters_by_region 1 +#define VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION 1 +#define VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_EXTENSION_NAME "VK_ARM_performance_counters_by_region" +typedef VkFlags VkPerformanceCounterDescriptionFlagsARM; +typedef struct VkPhysicalDevicePerformanceCountersByRegionFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 performanceCountersByRegion; +} VkPhysicalDevicePerformanceCountersByRegionFeaturesARM; + +typedef struct VkPhysicalDevicePerformanceCountersByRegionPropertiesARM { + VkStructureType sType; + void* pNext; + uint32_t maxPerRegionPerformanceCounters; + VkExtent2D performanceCounterRegionSize; + uint32_t rowStrideAlignment; + uint32_t regionAlignment; + VkBool32 identityTransformOrder; +} VkPhysicalDevicePerformanceCountersByRegionPropertiesARM; + +typedef struct VkPerformanceCounterARM { + VkStructureType sType; + void* pNext; + uint32_t counterID; +} VkPerformanceCounterARM; + +typedef struct VkPerformanceCounterDescriptionARM { + VkStructureType sType; + void* pNext; + VkPerformanceCounterDescriptionFlagsARM flags; + char name[VK_MAX_DESCRIPTION_SIZE]; +} VkPerformanceCounterDescriptionARM; + +typedef struct VkRenderPassPerformanceCountersByRegionBeginInfoARM { + VkStructureType sType; + void* pNext; + uint32_t counterAddressCount; + const VkDeviceAddress* pCounterAddresses; + VkBool32 serializeRegions; + uint32_t counterIndexCount; + uint32_t* pCounterIndices; +} VkRenderPassPerformanceCountersByRegionBeginInfoARM; + +typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterARM* pCounters, + VkPerformanceCounterDescriptionARM* pCounterDescriptions); +#endif +#endif + + +// VK_EXT_vertex_attribute_robustness is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_vertex_attribute_robustness 1 +#define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION 1 +#define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_vertex_attribute_robustness" +typedef struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexAttributeRobustness; +} VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT; + + + +// VK_ARM_format_pack is a preprocessor guard. Do not pass it to API calls. +#define VK_ARM_format_pack 1 +#define VK_ARM_FORMAT_PACK_SPEC_VERSION 1 +#define VK_ARM_FORMAT_PACK_EXTENSION_NAME "VK_ARM_format_pack" +typedef struct VkPhysicalDeviceFormatPackFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 formatPack; +} VkPhysicalDeviceFormatPackFeaturesARM; + + + +// VK_VALVE_fragment_density_map_layered is a preprocessor guard. Do not pass it to API calls. +#define VK_VALVE_fragment_density_map_layered 1 +#define VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION 1 +#define VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME "VK_VALVE_fragment_density_map_layered" +typedef struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMapLayered; +} VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; + +typedef struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE { + VkStructureType sType; + void* pNext; + uint32_t maxFragmentDensityMapLayers; +} VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; + +typedef struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE { + VkStructureType sType; + const void* pNext; + uint32_t maxFragmentDensityMapLayers; +} VkPipelineFragmentDensityMapLayeredCreateInfoVALVE; + + + +// VK_NV_present_metering is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_present_metering 1 +#define VK_NV_PRESENT_METERING_SPEC_VERSION 1 +#define VK_NV_PRESENT_METERING_EXTENSION_NAME "VK_NV_present_metering" +typedef struct VkSetPresentConfigNV { + VkStructureType sType; + const void* pNext; + uint32_t numFramesPerBatch; + uint32_t presentConfigFeedback; +} VkSetPresentConfigNV; + +typedef struct VkPhysicalDevicePresentMeteringFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 presentMetering; +} VkPhysicalDevicePresentMeteringFeaturesNV; + + + +// VK_EXT_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_fragment_density_map_offset 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1 +#define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_EXT_fragment_density_map_offset" +typedef VkRenderingEndInfoKHR VkRenderingEndInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdEndRendering2EXT)(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2EXT( + VkCommandBuffer commandBuffer, + const VkRenderingEndInfoKHR* pRenderingEndInfo); +#endif +#endif + + +// VK_EXT_zero_initialize_device_memory is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_zero_initialize_device_memory 1 +#define VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION 1 +#define VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME "VK_EXT_zero_initialize_device_memory" +typedef struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 zeroInitializeDeviceMemory; +} VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + + + +// VK_EXT_shader_64bit_indexing is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_64bit_indexing 1 +#define VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION 1 +#define VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME "VK_EXT_shader_64bit_indexing" +typedef struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shader64BitIndexing; +} VkPhysicalDeviceShader64BitIndexingFeaturesEXT; + + + +// VK_EXT_custom_resolve is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_custom_resolve 1 +#define VK_EXT_CUSTOM_RESOLVE_SPEC_VERSION 1 +#define VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME "VK_EXT_custom_resolve" +typedef struct VkPhysicalDeviceCustomResolveFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 customResolve; +} VkPhysicalDeviceCustomResolveFeaturesEXT; + +typedef struct VkBeginCustomResolveInfoEXT { + VkStructureType sType; + void* pNext; +} VkBeginCustomResolveInfoEXT; + +typedef struct VkCustomResolveCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 customResolve; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; +} VkCustomResolveCreateInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdBeginCustomResolveEXT)(VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBeginCustomResolveEXT( + VkCommandBuffer commandBuffer, + const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo); +#endif +#endif + + +// VK_QCOM_data_graph_model is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_data_graph_model 1 +#define VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM 3U +#define VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION 1 +#define VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME "VK_QCOM_data_graph_model" + +typedef enum VkDataGraphModelCacheTypeQCOM { + VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM = 0, + VK_DATA_GRAPH_MODEL_CACHE_TYPE_MAX_ENUM_QCOM = 0x7FFFFFFF +} VkDataGraphModelCacheTypeQCOM; +typedef struct VkPipelineCacheHeaderVersionDataGraphQCOM { + uint32_t headerSize; + VkPipelineCacheHeaderVersion headerVersion; + VkDataGraphModelCacheTypeQCOM cacheType; + uint32_t cacheVersion; + uint32_t toolchainVersion[VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM]; +} VkPipelineCacheHeaderVersionDataGraphQCOM; + +typedef struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM { + VkStructureType sType; + const void* pNext; + const VkPhysicalDeviceDataGraphOperationSupportARM* pOperation; +} VkDataGraphPipelineBuiltinModelCreateInfoQCOM; + +typedef struct VkPhysicalDeviceDataGraphModelFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 dataGraphModel; +} VkPhysicalDeviceDataGraphModelFeaturesQCOM; + + + +// VK_EXT_shader_long_vector is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_long_vector 1 +#define VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION 1 +#define VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME "VK_EXT_shader_long_vector" +typedef struct VkPhysicalDeviceShaderLongVectorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 longVector; +} VkPhysicalDeviceShaderLongVectorFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderLongVectorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxVectorComponents; +} VkPhysicalDeviceShaderLongVectorPropertiesEXT; + + + +// VK_SEC_pipeline_cache_incremental_mode is a preprocessor guard. Do not pass it to API calls. +#define VK_SEC_pipeline_cache_incremental_mode 1 +#define VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION 1 +#define VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME "VK_SEC_pipeline_cache_incremental_mode" +typedef struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC { + VkStructureType sType; + void* pNext; + VkBool32 pipelineCacheIncrementalMode; +} VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; + + + +// VK_EXT_shader_uniform_buffer_unsized_array is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_uniform_buffer_unsized_array 1 +#define VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION 1 +#define VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME "VK_EXT_shader_uniform_buffer_unsized_array" +typedef struct VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderUniformBufferUnsizedArray; +} VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; + + + +// VK_NV_compute_occupancy_priority is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_compute_occupancy_priority 1 +#define VK_NV_COMPUTE_OCCUPANCY_PRIORITY_SPEC_VERSION 1 +#define VK_NV_COMPUTE_OCCUPANCY_PRIORITY_EXTENSION_NAME "VK_NV_compute_occupancy_priority" +#define VK_COMPUTE_OCCUPANCY_PRIORITY_LOW_NV 0.25f +#define VK_COMPUTE_OCCUPANCY_PRIORITY_NORMAL_NV 0.50f +#define VK_COMPUTE_OCCUPANCY_PRIORITY_HIGH_NV 0.75f +typedef struct VkComputeOccupancyPriorityParametersNV { + VkStructureType sType; + const void* pNext; + float occupancyPriority; + float occupancyThrottling; +} VkComputeOccupancyPriorityParametersNV; + +typedef struct VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 computeOccupancyPriority; +} VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV; + +typedef void (VKAPI_PTR *PFN_vkCmdSetComputeOccupancyPriorityNV)(VkCommandBuffer commandBuffer, const VkComputeOccupancyPriorityParametersNV* pParameters); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetComputeOccupancyPriorityNV( + VkCommandBuffer commandBuffer, + const VkComputeOccupancyPriorityParametersNV* pParameters); +#endif +#endif + + +// VK_EXT_shader_subgroup_partitioned is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_shader_subgroup_partitioned 1 +#define VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1 +#define VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_EXT_shader_subgroup_partitioned" +typedef struct VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupPartitioned; +} VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; + + + +// VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_acceleration_structure 1 +#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 +#define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure" + +typedef enum VkBuildAccelerationStructureModeKHR { + VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0, + VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1, + VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkBuildAccelerationStructureModeKHR; + +typedef enum VkAccelerationStructureCreateFlagBitsKHR { + VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, + VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, + VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, + VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureCreateFlagBitsKHR; +typedef VkFlags VkAccelerationStructureCreateFlagsKHR; +typedef struct VkAccelerationStructureBuildRangeInfoKHR { + uint32_t primitiveCount; + uint32_t primitiveOffset; + uint32_t firstVertex; + uint32_t transformOffset; +} VkAccelerationStructureBuildRangeInfoKHR; + +typedef struct VkAccelerationStructureGeometryTrianglesDataKHR { + VkStructureType sType; + const void* pNext; + VkFormat vertexFormat; + VkDeviceOrHostAddressConstKHR vertexData; + VkDeviceSize vertexStride; + uint32_t maxVertex; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexData; + VkDeviceOrHostAddressConstKHR transformData; +} VkAccelerationStructureGeometryTrianglesDataKHR; + +typedef struct VkAccelerationStructureGeometryAabbsDataKHR { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR data; + VkDeviceSize stride; +} VkAccelerationStructureGeometryAabbsDataKHR; + +typedef struct VkAccelerationStructureGeometryInstancesDataKHR { + VkStructureType sType; + const void* pNext; + VkBool32 arrayOfPointers; + VkDeviceOrHostAddressConstKHR data; +} VkAccelerationStructureGeometryInstancesDataKHR; + +typedef union VkAccelerationStructureGeometryDataKHR { + VkAccelerationStructureGeometryTrianglesDataKHR triangles; + VkAccelerationStructureGeometryAabbsDataKHR aabbs; + VkAccelerationStructureGeometryInstancesDataKHR instances; +} VkAccelerationStructureGeometryDataKHR; + +typedef struct VkAccelerationStructureGeometryKHR { + VkStructureType sType; + const void* pNext; + VkGeometryTypeKHR geometryType; + VkAccelerationStructureGeometryDataKHR geometry; + VkGeometryFlagsKHR flags; +} VkAccelerationStructureGeometryKHR; + +typedef struct VkAccelerationStructureBuildGeometryInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureTypeKHR type; + VkBuildAccelerationStructureFlagsKHR flags; + VkBuildAccelerationStructureModeKHR mode; + VkAccelerationStructureKHR srcAccelerationStructure; + VkAccelerationStructureKHR dstAccelerationStructure; + uint32_t geometryCount; + const VkAccelerationStructureGeometryKHR* pGeometries; + const VkAccelerationStructureGeometryKHR* const* ppGeometries; + VkDeviceOrHostAddressKHR scratchData; +} VkAccelerationStructureBuildGeometryInfoKHR; + +typedef struct VkAccelerationStructureCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureCreateFlagsKHR createFlags; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; + VkAccelerationStructureTypeKHR type; + VkDeviceAddress deviceAddress; +} VkAccelerationStructureCreateInfoKHR; + +typedef struct VkWriteDescriptorSetAccelerationStructureKHR { + VkStructureType sType; + const void* pNext; + uint32_t accelerationStructureCount; + const VkAccelerationStructureKHR* pAccelerationStructures; +} VkWriteDescriptorSetAccelerationStructureKHR; + +typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 accelerationStructure; + VkBool32 accelerationStructureCaptureReplay; + VkBool32 accelerationStructureIndirectBuild; + VkBool32 accelerationStructureHostCommands; + VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind; +} VkPhysicalDeviceAccelerationStructureFeaturesKHR; + +typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR { + VkStructureType sType; + void* pNext; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxPrimitiveCount; + uint32_t maxPerStageDescriptorAccelerationStructures; + uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures; + uint32_t maxDescriptorSetAccelerationStructures; + uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures; + uint32_t minAccelerationStructureScratchOffsetAlignment; +} VkPhysicalDeviceAccelerationStructurePropertiesKHR; + +typedef struct VkAccelerationStructureDeviceAddressInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR accelerationStructure; +} VkAccelerationStructureDeviceAddressInfoKHR; + +typedef struct VkAccelerationStructureVersionInfoKHR { + VkStructureType sType; + const void* pNext; + const uint8_t* pVersionData; +} VkAccelerationStructureVersionInfoKHR; + +typedef struct VkCopyAccelerationStructureToMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR src; + VkDeviceOrHostAddressKHR dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyAccelerationStructureToMemoryInfoKHR; + +typedef struct VkCopyMemoryToAccelerationStructureInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR src; + VkAccelerationStructureKHR dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyMemoryToAccelerationStructureInfoKHR; + +typedef struct VkCopyAccelerationStructureInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR src; + VkAccelerationStructureKHR dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyAccelerationStructureInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); +typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts); +typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); +typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR( + VkDevice device, + VkAccelerationStructureKHR accelerationStructure, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkDeviceAddress* pIndirectDeviceAddresses, + const uint32_t* pIndirectStrides, + const uint32_t* const* ppMaxPrimitiveCounts); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureInfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR( + VkDevice device, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureInfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR( + VkDevice device, + const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR( + VkDevice device, + const VkAccelerationStructureVersionInfoKHR* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, + const uint32_t* pMaxPrimitiveCounts, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +#endif +#endif + + +// VK_KHR_ray_tracing_pipeline is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_ray_tracing_pipeline 1 +#define VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION 1 +#define VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME "VK_KHR_ray_tracing_pipeline" + +typedef enum VkShaderGroupShaderKHR { + VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0, + VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1, + VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2, + VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3, + VK_SHADER_GROUP_SHADER_MAX_ENUM_KHR = 0x7FFFFFFF +} VkShaderGroupShaderKHR; +typedef struct VkRayTracingShaderGroupCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkRayTracingShaderGroupTypeKHR type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; + const void* pShaderGroupCaptureReplayHandle; +} VkRayTracingShaderGroupCreateInfoKHR; + +typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxPipelineRayPayloadSize; + uint32_t maxPipelineRayHitAttributeSize; +} VkRayTracingPipelineInterfaceCreateInfoKHR; + +typedef struct VkRayTracingPipelineCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const VkRayTracingShaderGroupCreateInfoKHR* pGroups; + uint32_t maxPipelineRayRecursionDepth; + const VkPipelineLibraryCreateInfoKHR* pLibraryInfo; + const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkRayTracingPipelineCreateInfoKHR; + +typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingPipeline; + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay; + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + VkBool32 rayTracingPipelineTraceRaysIndirect; + VkBool32 rayTraversalPrimitiveCulling; +} VkPhysicalDeviceRayTracingPipelineFeaturesKHR; + +typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t shaderGroupHandleSize; + uint32_t maxRayRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint32_t shaderGroupHandleCaptureReplaySize; + uint32_t maxRayDispatchInvocationCount; + uint32_t shaderGroupHandleAlignment; + uint32_t maxRayHitAttributeSize; +} VkPhysicalDeviceRayTracingPipelinePropertiesKHR; + +typedef struct VkTraceRaysIndirectCommandKHR { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkTraceRaysIndirectCommandKHR; + +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth); +typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress); +typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader); +typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR( + VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR( + VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + VkDeviceAddress indirectDeviceAddress); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t group, + VkShaderGroupShaderKHR groupShader); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR( + VkCommandBuffer commandBuffer, + uint32_t pipelineStackSize); +#endif +#endif + + +// VK_KHR_ray_query is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_ray_query 1 +#define VK_KHR_RAY_QUERY_SPEC_VERSION 1 +#define VK_KHR_RAY_QUERY_EXTENSION_NAME "VK_KHR_ray_query" +typedef struct VkPhysicalDeviceRayQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayQuery; +} VkPhysicalDeviceRayQueryFeaturesKHR; + + + +// VK_EXT_mesh_shader is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_mesh_shader 1 +#define VK_EXT_MESH_SHADER_SPEC_VERSION 1 +#define VK_EXT_MESH_SHADER_EXTENSION_NAME "VK_EXT_mesh_shader" +typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 taskShader; + VkBool32 meshShader; + VkBool32 multiviewMeshShader; + VkBool32 primitiveFragmentShadingRateMeshShader; + VkBool32 meshShaderQueries; +} VkPhysicalDeviceMeshShaderFeaturesEXT; + +typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxTaskWorkGroupTotalCount; + uint32_t maxTaskWorkGroupCount[3]; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskPayloadSize; + uint32_t maxTaskSharedMemorySize; + uint32_t maxTaskPayloadAndSharedMemorySize; + uint32_t maxMeshWorkGroupTotalCount; + uint32_t maxMeshWorkGroupCount[3]; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshSharedMemorySize; + uint32_t maxMeshPayloadAndSharedMemorySize; + uint32_t maxMeshOutputMemorySize; + uint32_t maxMeshPayloadAndOutputMemorySize; + uint32_t maxMeshOutputComponents; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshOutputLayers; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; + uint32_t maxPreferredTaskWorkGroupInvocations; + uint32_t maxPreferredMeshWorkGroupInvocations; + VkBool32 prefersLocalInvocationVertexOutput; + VkBool32 prefersLocalInvocationPrimitiveOutput; + VkBool32 prefersCompactVertexOutput; + VkBool32 prefersCompactPrimitiveOutput; +} VkPhysicalDeviceMeshShaderPropertiesEXT; + +typedef struct VkDrawMeshTasksIndirectCommandEXT { + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; +} VkDrawMeshTasksIndirectCommandEXT; + +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksEXT)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_directfb.h b/lib/vulkan-headers/include/vulkan/vulkan_directfb.h new file mode 100644 index 00000000000..b96e957e14b --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_directfb.h @@ -0,0 +1,59 @@ +#ifndef VULKAN_DIRECTFB_H_ +#define VULKAN_DIRECTFB_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_EXT_directfb_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_directfb_surface 1 +#define VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION 1 +#define VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME "VK_EXT_directfb_surface" +typedef VkFlags VkDirectFBSurfaceCreateFlagsEXT; +typedef struct VkDirectFBSurfaceCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDirectFBSurfaceCreateFlagsEXT flags; + IDirectFB* dfb; + IDirectFBSurface* surface; +} VkDirectFBSurfaceCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateDirectFBSurfaceEXT)(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT( + VkInstance instance, + const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + IDirectFB* dfb); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_enums.hpp b/lib/vulkan-headers/include/vulkan/vulkan_enums.hpp new file mode 100644 index 00000000000..6cb46de1fce --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_enums.hpp @@ -0,0 +1,9806 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_ENUMS_HPP +#define VULKAN_ENUMS_HPP + +// include-what-you-use: make sure, vulkan.hpp is used by code-completers +// IWYU pragma: private, include "vulkan/vulkan.hpp" + +#if !defined( VULKAN_HPP_CXX_MODULE ) +# include // for std::underlying_type +#endif + +namespace VULKAN_HPP_NAMESPACE +{ + template + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false; + }; + + template + class Flags + { + public: + using BitsType = BitType; + using MaskType = typename std::underlying_type::type; + + // constructors + VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {} + + VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast( bit ) ) {} + + VULKAN_HPP_CONSTEXPR Flags( Flags const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {} + + // relational operators +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( Flags const & ) const = default; +#else + VULKAN_HPP_CONSTEXPR bool operator<( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return m_mask < rhs.m_mask; + } + + VULKAN_HPP_CONSTEXPR bool operator<=( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return m_mask <= rhs.m_mask; + } + + VULKAN_HPP_CONSTEXPR bool operator>( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return m_mask > rhs.m_mask; + } + + VULKAN_HPP_CONSTEXPR bool operator>=( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return m_mask >= rhs.m_mask; + } + + VULKAN_HPP_CONSTEXPR bool operator==( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return m_mask == rhs.m_mask; + } + + VULKAN_HPP_CONSTEXPR bool operator!=( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return m_mask != rhs.m_mask; + } +#endif + + // logical operator + VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT + { + return !m_mask; + } + + // bitwise operators + VULKAN_HPP_CONSTEXPR Flags operator&( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return Flags( m_mask & rhs.m_mask ); + } + + VULKAN_HPP_CONSTEXPR Flags operator|( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return Flags( m_mask | rhs.m_mask ); + } + + VULKAN_HPP_CONSTEXPR Flags operator^( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return Flags( m_mask ^ rhs.m_mask ); + } + + VULKAN_HPP_CONSTEXPR Flags operator~() const VULKAN_HPP_NOEXCEPT + { + return Flags( m_mask ^ FlagTraits::allFlags.m_mask ); + } + + // assignment operators + VULKAN_HPP_CONSTEXPR_14 Flags & operator=( Flags const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VULKAN_HPP_CONSTEXPR_14 Flags & operator|=( Flags const & rhs ) VULKAN_HPP_NOEXCEPT + { + m_mask |= rhs.m_mask; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Flags & operator&=( Flags const & rhs ) VULKAN_HPP_NOEXCEPT + { + m_mask &= rhs.m_mask; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Flags & operator^=( Flags const & rhs ) VULKAN_HPP_NOEXCEPT + { + m_mask ^= rhs.m_mask; + return *this; + } + + // cast operators + explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT + { + return !!m_mask; + } + + explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT + { + return m_mask; + } + +#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC ) + public: +#else + private: +#endif + MaskType m_mask; + }; + +#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + // relational operators only needed for pre C++20 + template + VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT + { + return flags.operator>( bit ); + } + + template + VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT + { + return flags.operator>=( bit ); + } + + template + VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT + { + return flags.operator<( bit ); + } + + template + VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT + { + return flags.operator<=( bit ); + } + + template + VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT + { + return flags.operator==( bit ); + } + + template + VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT + { + return flags.operator!=( bit ); + } +#endif + + // bitwise operators + template + VULKAN_HPP_CONSTEXPR Flags operator&( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT + { + return flags.operator&( bit ); + } + + template + VULKAN_HPP_CONSTEXPR Flags operator|( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT + { + return flags.operator|( bit ); + } + + template + VULKAN_HPP_CONSTEXPR Flags operator^( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT + { + return flags.operator^( bit ); + } + + // bitwise operators on BitType + template ::isBitmask, bool>::type = true> + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags operator&( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT + { + return Flags( lhs ) & rhs; + } + + template ::isBitmask, bool>::type = true> + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags operator|( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT + { + return Flags( lhs ) | rhs; + } + + template ::isBitmask, bool>::type = true> + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags operator^( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT + { + return Flags( lhs ) ^ rhs; + } + + template ::isBitmask, bool>::type = true> + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags operator~( BitType bit ) VULKAN_HPP_NOEXCEPT + { + return ~( Flags( bit ) ); + } + + //============= + //=== ENUMs === + //============= + + //=== VK_VERSION_1_0 === + + // wrapper class for enum VkResult, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResult.html + enum class Result + { + eSuccess = VK_SUCCESS, + eNotReady = VK_NOT_READY, + eTimeout = VK_TIMEOUT, + eEventSet = VK_EVENT_SET, + eEventReset = VK_EVENT_RESET, + eIncomplete = VK_INCOMPLETE, + eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY, + eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY, + eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED, + eErrorDeviceLost = VK_ERROR_DEVICE_LOST, + eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED, + eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT, + eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT, + eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT, + eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER, + eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS, + eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED, + eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL, + eErrorUnknown = VK_ERROR_UNKNOWN, + eErrorValidationFailed = VK_ERROR_VALIDATION_FAILED, + eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT, + eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY, + eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR, + eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE, + eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, + eErrorInvalidOpaqueCaptureAddress = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, + eErrorInvalidDeviceAddressEXT = VK_ERROR_INVALID_DEVICE_ADDRESS_EXT, + eErrorInvalidOpaqueCaptureAddressKHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR, + eErrorFragmentation = VK_ERROR_FRAGMENTATION, + eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT, + ePipelineCompileRequired = VK_PIPELINE_COMPILE_REQUIRED, + ePipelineCompileRequiredEXT = VK_PIPELINE_COMPILE_REQUIRED_EXT, + eErrorPipelineCompileRequiredEXT = VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT, + eErrorNotPermitted = VK_ERROR_NOT_PERMITTED, + eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT, + eErrorNotPermittedKHR = VK_ERROR_NOT_PERMITTED_KHR, + eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR, + eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, + eSuboptimalKHR = VK_SUBOPTIMAL_KHR, + eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR, + eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR, + eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV, + eErrorImageUsageNotSupportedKHR = VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR, + eErrorVideoPictureLayoutNotSupportedKHR = VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR, + eErrorVideoProfileOperationNotSupportedKHR = VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR, + eErrorVideoProfileFormatNotSupportedKHR = VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR, + eErrorVideoProfileCodecNotSupportedKHR = VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR, + eErrorVideoStdVersionNotSupportedKHR = VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR, + eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT, + eErrorPresentTimingQueueFullEXT = VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + eErrorFullScreenExclusiveModeLostEXT = VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + eThreadIdleKHR = VK_THREAD_IDLE_KHR, + eThreadDoneKHR = VK_THREAD_DONE_KHR, + eOperationDeferredKHR = VK_OPERATION_DEFERRED_KHR, + eOperationNotDeferredKHR = VK_OPERATION_NOT_DEFERRED_KHR, + eErrorInvalidVideoStdParametersKHR = VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR, + eErrorCompressionExhaustedEXT = VK_ERROR_COMPRESSION_EXHAUSTED_EXT, + eIncompatibleShaderBinaryEXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT, + eErrorIncompatibleShaderBinaryEXT = VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT, + ePipelineBinaryMissingKHR = VK_PIPELINE_BINARY_MISSING_KHR, + eErrorNotEnoughSpaceKHR = VK_ERROR_NOT_ENOUGH_SPACE_KHR + }; + + // wrapper class for enum VkStructureType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStructureType.html + enum class StructureType + { + eApplicationInfo = VK_STRUCTURE_TYPE_APPLICATION_INFO, + eInstanceCreateInfo = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, + eDeviceQueueCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, + eDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, + eSubmitInfo = VK_STRUCTURE_TYPE_SUBMIT_INFO, + eMemoryAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, + eMappedMemoryRange = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, + eBindSparseInfo = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, + eFenceCreateInfo = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, + eSemaphoreCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, + eEventCreateInfo = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, + eQueryPoolCreateInfo = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, + eBufferCreateInfo = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, + eBufferViewCreateInfo = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, + eImageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, + eImageViewCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, + eShaderModuleCreateInfo = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, + ePipelineCacheCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, + ePipelineShaderStageCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, + ePipelineVertexInputStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + ePipelineInputAssemblyStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, + ePipelineTessellationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, + ePipelineViewportStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, + ePipelineRasterizationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, + ePipelineMultisampleStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, + ePipelineDepthStencilStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, + ePipelineColorBlendStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, + ePipelineDynamicStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, + eGraphicsPipelineCreateInfo = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, + eComputePipelineCreateInfo = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, + ePipelineLayoutCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, + eSamplerCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, + eDescriptorSetLayoutCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, + eDescriptorPoolCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, + eDescriptorSetAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, + eWriteDescriptorSet = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, + eCopyDescriptorSet = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, + eFramebufferCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, + eRenderPassCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, + eCommandPoolCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, + eCommandBufferAllocateInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, + eCommandBufferInheritanceInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, + eCommandBufferBeginInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, + eRenderPassBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, + eBufferMemoryBarrier = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, + eImageMemoryBarrier = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, + eMemoryBarrier = VK_STRUCTURE_TYPE_MEMORY_BARRIER, + eLoaderInstanceCreateInfo = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, + eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, + eBindBufferMemoryInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, + eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, + eBindImageMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, + eMemoryDedicatedRequirements = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, + eMemoryDedicatedAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, + eMemoryAllocateFlagsInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + eMemoryAllocateFlagsInfoKHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR, + eDeviceGroupCommandBufferBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + eDeviceGroupCommandBufferBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR, + eDeviceGroupSubmitInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + eDeviceGroupSubmitInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR, + eDeviceGroupBindSparseInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + eDeviceGroupBindSparseInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, + eBindBufferMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR, + eBindImageMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR, + ePhysicalDeviceGroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + ePhysicalDeviceGroupPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR, + eDeviceGroupDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + eDeviceGroupDeviceCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, + eBufferMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, + eImageMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR, + eImageSparseMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR, + eMemoryRequirements2 = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, + eSparseImageMemoryRequirements2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR, + ePhysicalDeviceFeatures2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, + ePhysicalDeviceProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, + eFormatProperties2 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR, + eImageFormatProperties2 = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR, + ePhysicalDeviceImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, + eQueueFamilyProperties2 = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR, + ePhysicalDeviceMemoryProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR, + eSparseImageFormatProperties2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR, + ePhysicalDeviceSparseImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR, + eImageViewUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, + eProtectedSubmitInfo = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO, + ePhysicalDeviceProtectedMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, + ePhysicalDeviceProtectedMemoryProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, + eDeviceQueueInfo2 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, + ePhysicalDeviceExternalImageFormatInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR, + eExternalImageFormatProperties = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR, + ePhysicalDeviceExternalBufferInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR, + eExternalBufferProperties = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR, + ePhysicalDeviceIdProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, + eExternalMemoryBufferCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR, + eExternalMemoryImageCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR, + eExportMemoryAllocateInfo = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR, + ePhysicalDeviceExternalFenceInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR, + eExternalFenceProperties = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR, + eExportFenceCreateInfo = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR, + eExportSemaphoreCreateInfo = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR, + ePhysicalDeviceExternalSemaphoreInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR, + eExternalSemaphoreProperties = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR, + ePhysicalDeviceSubgroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, + ePhysicalDevice16BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, + ePhysicalDeviceVariablePointersFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + ePhysicalDeviceVariablePointerFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, + ePhysicalDeviceVariablePointersFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, + ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR, + eDescriptorUpdateTemplateCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, + ePhysicalDeviceMaintenance3Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + ePhysicalDeviceMaintenance3PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR, + eDescriptorSetLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, + eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR, + eSamplerYcbcrConversionCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR, + eSamplerYcbcrConversionInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR, + eBindImagePlaneMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR, + eImagePlaneMemoryRequirementsInfo = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR, + ePhysicalDeviceSamplerYcbcrConversionFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR, + eSamplerYcbcrConversionImageFormatProperties = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR, + eDeviceGroupRenderPassBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + eDeviceGroupRenderPassBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR, + ePhysicalDevicePointClippingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR, + eRenderPassInputAttachmentAspectCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR, + ePipelineTessellationDomainOriginStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR, + eRenderPassMultiviewCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR, + ePhysicalDeviceMultiviewFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, + ePhysicalDeviceMultiviewProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + ePhysicalDeviceMultiviewPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR, + ePhysicalDeviceShaderDrawParametersFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + ePhysicalDeviceShaderDrawParameterFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES, + ePhysicalDeviceVulkan11Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, + ePhysicalDeviceVulkan11Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, + ePhysicalDeviceVulkan12Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, + ePhysicalDeviceVulkan12Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, + eImageFormatListCreateInfo = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, + eImageFormatListCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR, + ePhysicalDeviceDriverProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, + ePhysicalDeviceDriverPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR, + ePhysicalDeviceVulkanMemoryModelFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, + ePhysicalDeviceVulkanMemoryModelFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR, + ePhysicalDeviceHostQueryResetFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, + ePhysicalDeviceHostQueryResetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, + ePhysicalDeviceTimelineSemaphoreFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, + ePhysicalDeviceTimelineSemaphoreFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR, + ePhysicalDeviceTimelineSemaphoreProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, + ePhysicalDeviceTimelineSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR, + eSemaphoreTypeCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, + eSemaphoreTypeCreateInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR, + eTimelineSemaphoreSubmitInfo = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, + eTimelineSemaphoreSubmitInfoKHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR, + eSemaphoreWaitInfo = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, + eSemaphoreWaitInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR, + eSemaphoreSignalInfo = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, + eSemaphoreSignalInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR, + ePhysicalDeviceBufferDeviceAddressFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, + ePhysicalDeviceBufferDeviceAddressFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR, + eBufferDeviceAddressInfo = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + eBufferDeviceAddressInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, + eBufferDeviceAddressInfoKHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, + eBufferOpaqueCaptureAddressCreateInfo = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, + eBufferOpaqueCaptureAddressCreateInfoKHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR, + eMemoryOpaqueCaptureAddressAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, + eMemoryOpaqueCaptureAddressAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR, + eDeviceMemoryOpaqueCaptureAddressInfo = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, + eDeviceMemoryOpaqueCaptureAddressInfoKHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR, + ePhysicalDevice8BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, + ePhysicalDevice8BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, + ePhysicalDeviceShaderAtomicInt64Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, + ePhysicalDeviceShaderAtomicInt64FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, + ePhysicalDeviceShaderFloat16Int8Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + ePhysicalDeviceShaderFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR, + ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR, + ePhysicalDeviceFloatControlsProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, + ePhysicalDeviceFloatControlsPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR, + eDescriptorSetLayoutBindingFlagsCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, + eDescriptorSetLayoutBindingFlagsCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT, + ePhysicalDeviceDescriptorIndexingFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, + ePhysicalDeviceDescriptorIndexingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, + ePhysicalDeviceDescriptorIndexingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, + ePhysicalDeviceDescriptorIndexingPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT, + eDescriptorSetVariableDescriptorCountAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, + eDescriptorSetVariableDescriptorCountAllocateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT, + eDescriptorSetVariableDescriptorCountLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, + eDescriptorSetVariableDescriptorCountLayoutSupportEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT, + ePhysicalDeviceScalarBlockLayoutFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, + ePhysicalDeviceScalarBlockLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, + ePhysicalDeviceSamplerFilterMinmaxProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, + ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT, + eSamplerReductionModeCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, + eSamplerReductionModeCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT, + ePhysicalDeviceUniformBufferStandardLayoutFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, + ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR, + ePhysicalDeviceShaderSubgroupExtendedTypesFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, + ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR, + eAttachmentDescription2 = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, + eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR, + eAttachmentReference2 = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, + eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR, + eSubpassDescription2 = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, + eSubpassDescription2KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR, + eSubpassDependency2 = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, + eSubpassDependency2KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR, + eRenderPassCreateInfo2 = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, + eRenderPassCreateInfo2KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR, + eSubpassBeginInfo = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, + eSubpassBeginInfoKHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR, + eSubpassEndInfo = VK_STRUCTURE_TYPE_SUBPASS_END_INFO, + eSubpassEndInfoKHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR, + ePhysicalDeviceDepthStencilResolveProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, + ePhysicalDeviceDepthStencilResolvePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, + eSubpassDescriptionDepthStencilResolve = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, + eSubpassDescriptionDepthStencilResolveKHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR, + eImageStencilUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, + eImageStencilUsageCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT, + ePhysicalDeviceImagelessFramebufferFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, + ePhysicalDeviceImagelessFramebufferFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, + eFramebufferAttachmentsCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, + eFramebufferAttachmentsCreateInfoKHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR, + eFramebufferAttachmentImageInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, + eFramebufferAttachmentImageInfoKHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR, + eRenderPassAttachmentBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, + eRenderPassAttachmentBeginInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR, + ePhysicalDeviceSeparateDepthStencilLayoutsFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, + ePhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR, + eAttachmentReferenceStencilLayout = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, + eAttachmentReferenceStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR, + eAttachmentDescriptionStencilLayout = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, + eAttachmentDescriptionStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR, + ePhysicalDeviceVulkan13Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, + ePhysicalDeviceVulkan13Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, + ePhysicalDeviceToolProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES, + ePhysicalDeviceToolPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT, + ePhysicalDevicePrivateDataFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, + ePhysicalDevicePrivateDataFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT, + eDevicePrivateDataCreateInfo = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, + eDevicePrivateDataCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT, + ePrivateDataSlotCreateInfo = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, + ePrivateDataSlotCreateInfoEXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT, + eMemoryBarrier2 = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, + eMemoryBarrier2KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, + eBufferMemoryBarrier2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, + eBufferMemoryBarrier2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR, + eImageMemoryBarrier2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, + eImageMemoryBarrier2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR, + eDependencyInfo = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, + eDependencyInfoKHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR, + eSubmitInfo2 = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, + eSubmitInfo2KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR, + eSemaphoreSubmitInfo = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, + eSemaphoreSubmitInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, + eCommandBufferSubmitInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, + eCommandBufferSubmitInfoKHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR, + ePhysicalDeviceSynchronization2Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, + ePhysicalDeviceSynchronization2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR, + eCopyBufferInfo2 = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, + eCopyBufferInfo2KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR, + eCopyImageInfo2 = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2, + eCopyImageInfo2KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR, + eCopyBufferToImageInfo2 = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, + eCopyBufferToImageInfo2KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR, + eCopyImageToBufferInfo2 = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, + eCopyImageToBufferInfo2KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR, + eBufferCopy2 = VK_STRUCTURE_TYPE_BUFFER_COPY_2, + eBufferCopy2KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR, + eImageCopy2 = VK_STRUCTURE_TYPE_IMAGE_COPY_2, + eImageCopy2KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR, + eBufferImageCopy2 = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, + eBufferImageCopy2KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR, + ePhysicalDeviceTextureCompressionAstcHdrFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, + ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT, + eFormatProperties3 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, + eFormatProperties3KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, + ePhysicalDeviceMaintenance4Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, + ePhysicalDeviceMaintenance4FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR, + ePhysicalDeviceMaintenance4Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, + ePhysicalDeviceMaintenance4PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR, + eDeviceBufferMemoryRequirements = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, + eDeviceBufferMemoryRequirementsKHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR, + eDeviceImageMemoryRequirements = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, + eDeviceImageMemoryRequirementsKHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR, + ePipelineCreationFeedbackCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, + ePipelineCreationFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT, + ePhysicalDeviceShaderTerminateInvocationFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, + ePhysicalDeviceShaderTerminateInvocationFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR, + ePhysicalDeviceShaderDemoteToHelperInvocationFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, + ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, + ePhysicalDevicePipelineCreationCacheControlFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, + ePhysicalDevicePipelineCreationCacheControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT, + ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, + ePhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR, + ePhysicalDeviceImageRobustnessFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, + ePhysicalDeviceImageRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT, + ePhysicalDeviceSubgroupSizeControlProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, + ePhysicalDeviceSubgroupSizeControlPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, + ePipelineShaderStageRequiredSubgroupSizeCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, + ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT, + eShaderRequiredSubgroupSizeCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT, + ePhysicalDeviceSubgroupSizeControlFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, + ePhysicalDeviceSubgroupSizeControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT, + ePhysicalDeviceInlineUniformBlockFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, + ePhysicalDeviceInlineUniformBlockFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, + ePhysicalDeviceInlineUniformBlockProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, + ePhysicalDeviceInlineUniformBlockPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, + eWriteDescriptorSetInlineUniformBlock = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, + eWriteDescriptorSetInlineUniformBlockEXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT, + eDescriptorPoolInlineUniformBlockCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, + eDescriptorPoolInlineUniformBlockCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT, + ePhysicalDeviceShaderIntegerDotProductFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, + ePhysicalDeviceShaderIntegerDotProductFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR, + ePhysicalDeviceShaderIntegerDotProductProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, + ePhysicalDeviceShaderIntegerDotProductPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR, + ePhysicalDeviceTexelBufferAlignmentProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, + ePhysicalDeviceTexelBufferAlignmentPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, + eBlitImageInfo2 = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, + eBlitImageInfo2KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR, + eResolveImageInfo2 = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, + eResolveImageInfo2KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR, + eImageBlit2 = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, + eImageBlit2KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR, + eImageResolve2 = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, + eImageResolve2KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR, + eRenderingInfo = VK_STRUCTURE_TYPE_RENDERING_INFO, + eRenderingInfoKHR = VK_STRUCTURE_TYPE_RENDERING_INFO_KHR, + eRenderingAttachmentInfo = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, + eRenderingAttachmentInfoKHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, + ePipelineRenderingCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, + ePipelineRenderingCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR, + ePhysicalDeviceDynamicRenderingFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, + ePhysicalDeviceDynamicRenderingFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR, + eCommandBufferInheritanceRenderingInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, + eCommandBufferInheritanceRenderingInfoKHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR, + ePhysicalDeviceVulkan14Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES, + ePhysicalDeviceVulkan14Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES, + eDeviceQueueGlobalPriorityCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO, + eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, + eDeviceQueueGlobalPriorityCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR, + ePhysicalDeviceGlobalPriorityQueryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, + ePhysicalDeviceGlobalPriorityQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, + ePhysicalDeviceGlobalPriorityQueryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT, + eQueueFamilyGlobalPriorityProperties = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES, + eQueueFamilyGlobalPriorityPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR, + eQueueFamilyGlobalPriorityPropertiesEXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT, + ePhysicalDeviceIndexTypeUint8Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, + ePhysicalDeviceIndexTypeUint8FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, + ePhysicalDeviceIndexTypeUint8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR, + eMemoryMapInfo = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO, + eMemoryMapInfoKHR = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR, + eMemoryUnmapInfo = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO, + eMemoryUnmapInfoKHR = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR, + ePhysicalDeviceMaintenance5Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, + ePhysicalDeviceMaintenance5FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR, + ePhysicalDeviceMaintenance5Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES, + ePhysicalDeviceMaintenance5PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR, + eDeviceImageSubresourceInfo = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO, + eDeviceImageSubresourceInfoKHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR, + eSubresourceLayout2 = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2, + eSubresourceLayout2EXT = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT, + eSubresourceLayout2KHR = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR, + eImageSubresource2 = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2, + eImageSubresource2EXT = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT, + eImageSubresource2KHR = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR, + eBufferUsageFlags2CreateInfo = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO, + eBufferUsageFlags2CreateInfoKHR = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR, + ePhysicalDeviceMaintenance6Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES, + ePhysicalDeviceMaintenance6FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR, + ePhysicalDeviceMaintenance6Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES, + ePhysicalDeviceMaintenance6PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR, + eBindMemoryStatus = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS, + eBindMemoryStatusKHR = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR, + ePhysicalDeviceHostImageCopyFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES, + ePhysicalDeviceHostImageCopyFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT, + ePhysicalDeviceHostImageCopyProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES, + ePhysicalDeviceHostImageCopyPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT, + eMemoryToImageCopy = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY, + eMemoryToImageCopyEXT = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT, + eImageToMemoryCopy = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY, + eImageToMemoryCopyEXT = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT, + eCopyImageToMemoryInfo = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO, + eCopyImageToMemoryInfoEXT = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT, + eCopyMemoryToImageInfo = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO, + eCopyMemoryToImageInfoEXT = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT, + eHostImageLayoutTransitionInfo = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO, + eHostImageLayoutTransitionInfoEXT = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT, + eCopyImageToImageInfo = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO, + eCopyImageToImageInfoEXT = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT, + eSubresourceHostMemcpySize = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE, + eSubresourceHostMemcpySizeEXT = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT, + eHostImageCopyDevicePerformanceQuery = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY, + eHostImageCopyDevicePerformanceQueryEXT = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT, + ePhysicalDeviceShaderSubgroupRotateFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES, + ePhysicalDeviceShaderSubgroupRotateFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR, + ePhysicalDeviceShaderFloatControls2Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES, + ePhysicalDeviceShaderFloatControls2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR, + ePhysicalDeviceShaderExpectAssumeFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES, + ePhysicalDeviceShaderExpectAssumeFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR, + ePipelineCreateFlags2CreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO, + ePipelineCreateFlags2CreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR, + ePhysicalDevicePushDescriptorProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES, + ePhysicalDevicePushDescriptorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, + eBindDescriptorSetsInfo = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO, + eBindDescriptorSetsInfoKHR = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR, + ePushConstantsInfo = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO, + ePushConstantsInfoKHR = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR, + ePushDescriptorSetInfo = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO, + ePushDescriptorSetInfoKHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR, + ePushDescriptorSetWithTemplateInfo = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO, + ePushDescriptorSetWithTemplateInfoKHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR, + ePhysicalDevicePipelineProtectedAccessFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES, + ePhysicalDevicePipelineProtectedAccessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT, + ePipelineRobustnessCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO, + ePipelineRobustnessCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT, + ePhysicalDevicePipelineRobustnessFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES, + ePhysicalDevicePipelineRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT, + ePhysicalDevicePipelineRobustnessProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES, + ePhysicalDevicePipelineRobustnessPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT, + ePhysicalDeviceLineRasterizationFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, + ePhysicalDeviceLineRasterizationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, + ePhysicalDeviceLineRasterizationFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR, + ePipelineRasterizationLineStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO, + ePipelineRasterizationLineStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, + ePipelineRasterizationLineStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR, + ePhysicalDeviceLineRasterizationProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES, + ePhysicalDeviceLineRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, + ePhysicalDeviceLineRasterizationPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR, + ePhysicalDeviceVertexAttributeDivisorProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES, + ePhysicalDeviceVertexAttributeDivisorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR, + ePipelineVertexInputDivisorStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO, + ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, + ePipelineVertexInputDivisorStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR, + ePhysicalDeviceVertexAttributeDivisorFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, + ePhysicalDeviceVertexAttributeDivisorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, + ePhysicalDeviceVertexAttributeDivisorFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, + eRenderingAreaInfo = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO, + eRenderingAreaInfoKHR = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR, + ePhysicalDeviceDynamicRenderingLocalReadFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES, + ePhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR, + eRenderingAttachmentLocationInfo = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO, + eRenderingAttachmentLocationInfoKHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR, + eRenderingInputAttachmentIndexInfo = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO, + eRenderingInputAttachmentIndexInfoKHR = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR, + eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, + ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, + eDeviceGroupPresentCapabilitiesKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, + eImageSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, + eBindImageMemorySwapchainInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, + eAcquireNextImageInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR, + eDeviceGroupPresentInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR, + eDeviceGroupSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, + eDisplayModeCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR, + eDisplaySurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR, + eDisplayPresentInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ +#if defined( VK_USE_PLATFORM_XCB_KHR ) + eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + eWaylandSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT, + ePipelineRasterizationStateRasterizationOrderAMD = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, + eDebugMarkerObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT, + eDebugMarkerObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, + eDebugMarkerMarkerInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, + eVideoProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, + eVideoCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR, + eVideoPictureResourceInfoKHR = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR, + eVideoSessionMemoryRequirementsKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR, + eBindVideoSessionMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR, + eVideoSessionCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR, + eVideoSessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR, + eVideoSessionParametersUpdateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR, + eVideoBeginCodingInfoKHR = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR, + eVideoEndCodingInfoKHR = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR, + eVideoCodingControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR, + eVideoReferenceSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR, + eQueueFamilyVideoPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR, + eVideoProfileListInfoKHR = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR, + ePhysicalDeviceVideoFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, + eVideoFormatPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR, + eQueueFamilyQueryResultStatusPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR, + eVideoDecodeInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR, + eVideoDecodeCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR, + eVideoDecodeUsageInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR, + eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, + eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, + eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, + ePhysicalDeviceTransformFeedbackFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, + ePhysicalDeviceTransformFeedbackPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT, + ePipelineRasterizationStateStreamCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT, + eCuModuleCreateInfoNVX = VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX, + eCuFunctionCreateInfoNVX = VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX, + eCuLaunchInfoNVX = VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX, + eCuModuleTexturingModeCreateInfoNVX = VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX, + eImageViewHandleInfoNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX, + eImageViewAddressPropertiesNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX, + eVideoEncodeH264CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR, + eVideoEncodeH264SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR, + eVideoEncodeH264SessionParametersAddInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR, + eVideoEncodeH264PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR, + eVideoEncodeH264DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR, + eVideoEncodeH264NaluSliceInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR, + eVideoEncodeH264GopRemainingFrameInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR, + eVideoEncodeH264ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR, + eVideoEncodeH264RateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR, + eVideoEncodeH264RateControlLayerInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR, + eVideoEncodeH264SessionCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR, + eVideoEncodeH264QualityLevelPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR, + eVideoEncodeH264SessionParametersGetInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR, + eVideoEncodeH264SessionParametersFeedbackInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR, + eVideoEncodeH265CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR, + eVideoEncodeH265SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR, + eVideoEncodeH265SessionParametersAddInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR, + eVideoEncodeH265PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR, + eVideoEncodeH265DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR, + eVideoEncodeH265NaluSliceSegmentInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR, + eVideoEncodeH265GopRemainingFrameInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR, + eVideoEncodeH265ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR, + eVideoEncodeH265RateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR, + eVideoEncodeH265RateControlLayerInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR, + eVideoEncodeH265SessionCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR, + eVideoEncodeH265QualityLevelPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR, + eVideoEncodeH265SessionParametersGetInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR, + eVideoEncodeH265SessionParametersFeedbackInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR, + eVideoDecodeH264CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR, + eVideoDecodeH264PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR, + eVideoDecodeH264ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR, + eVideoDecodeH264SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR, + eVideoDecodeH264SessionParametersAddInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR, + eVideoDecodeH264DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR, + eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, +#if defined( VK_USE_PLATFORM_GGP ) + eStreamDescriptorSurfaceCreateInfoGGP = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP, +#endif /*VK_USE_PLATFORM_GGP*/ + ePhysicalDeviceCornerSampledImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, + eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, + eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + eImportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, + eExportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, + eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT, +#if defined( VK_USE_PLATFORM_VI_NN ) + eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN, +#endif /*VK_USE_PLATFORM_VI_NN*/ + eImageViewAstcDecodeModeEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT, + ePhysicalDeviceAstcDecodeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + eExportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, + eMemoryWin32HandlePropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, + eMemoryGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + eImportMemoryFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, + eMemoryFdPropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, + eMemoryGetFdInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + eWin32KeyedMutexAcquireReleaseInfoKHR = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, + eImportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + eExportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, + eD3D12FenceSubmitInfoKHR = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR, + eSemaphoreGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + eImportSemaphoreFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, + eSemaphoreGetFdInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, + eCommandBufferInheritanceConditionalRenderingInfoEXT = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, + ePhysicalDeviceConditionalRenderingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, + eConditionalRenderingBeginInfoEXT = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT, + ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, + ePipelineViewportWScalingStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, + eSurfaceCapabilities2EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, + eDisplayPowerInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT, + eDeviceEventInfoEXT = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT, + eDisplayEventInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT, + eSwapchainCounterCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT, + ePresentTimesInfoGOOGLE = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE, + ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, + eMultiviewPerViewAttributesInfoNVX = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX, + ePipelineViewportSwizzleStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, + ePhysicalDeviceDiscardRectanglePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, + ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, + ePhysicalDeviceConservativeRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, + ePipelineRasterizationConservativeStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, + ePhysicalDeviceDepthClipEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, + ePipelineRasterizationDepthClipStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT, + eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT, + ePhysicalDeviceRelaxedLineRasterizationFeaturesIMG = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, + eSharedPresentSurfaceCapabilitiesKHR = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + eImportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, + eExportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, + eFenceGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, + eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, + ePhysicalDevicePerformanceQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, + ePhysicalDevicePerformanceQueryPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR, + eQueryPoolPerformanceCreateInfoKHR = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR, + ePerformanceQuerySubmitInfoKHR = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR, + eAcquireProfilingLockInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR, + ePerformanceCounterKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR, + ePerformanceCounterDescriptionKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR, + ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, + eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, + eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, + eDisplayProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR, + eDisplayPlaneProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR, + eDisplayModeProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR, + eDisplayPlaneInfo2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR, + eDisplayPlaneCapabilities2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR, +#if defined( VK_USE_PLATFORM_IOS_MVK ) + eIosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK, +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + eDebugUtilsObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, + eDebugUtilsObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT, + eDebugUtilsLabelEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, + eDebugUtilsMessengerCallbackDataEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, + eDebugUtilsMessengerCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + eAndroidHardwareBufferUsageANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, + eAndroidHardwareBufferPropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID, + eAndroidHardwareBufferFormatPropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID, + eImportAndroidHardwareBufferInfoANDROID = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, + eMemoryGetAndroidHardwareBufferInfoANDROID = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, + eExternalFormatANDROID = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, + eAndroidHardwareBufferFormatProperties2ANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + ePhysicalDeviceShaderEnqueueFeaturesAMDX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX, + ePhysicalDeviceShaderEnqueuePropertiesAMDX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX, + eExecutionGraphPipelineScratchSizeAMDX = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX, + eExecutionGraphPipelineCreateInfoAMDX = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX, + ePipelineShaderStageNodeCreateInfoAMDX = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eTexelBufferDescriptorInfoEXT = VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT, + eImageDescriptorInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT, + eResourceDescriptorInfoEXT = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT, + eBindHeapInfoEXT = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT, + ePushDataInfoEXT = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT, + eDescriptorSetAndBindingMappingEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT, + eShaderDescriptorSetAndBindingMappingInfoEXT = VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT, + eOpaqueCaptureDataCreateInfoEXT = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT, + ePhysicalDeviceDescriptorHeapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT, + ePhysicalDeviceDescriptorHeapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT, + eCommandBufferInheritanceDescriptorHeapInfoEXT = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT, + eSamplerCustomBorderColorIndexCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT, + eIndirectCommandsLayoutPushDataTokenNV = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV, + eSubsampledImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT, + ePhysicalDeviceDescriptorHeapTensorPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM, + eAttachmentSampleCountInfoAMD = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, + eAttachmentSampleCountInfoNV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV, + ePhysicalDeviceShaderBfloat16FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR, + eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, + eRenderPassSampleLocationsBeginInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, + ePipelineSampleLocationsStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, + ePhysicalDeviceSampleLocationsPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, + eMultisamplePropertiesEXT = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, + ePhysicalDeviceBlendOperationAdvancedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, + ePhysicalDeviceBlendOperationAdvancedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, + ePipelineColorBlendAdvancedStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, + ePipelineCoverageToColorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, + eWriteDescriptorSetAccelerationStructureKHR = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, + eAccelerationStructureBuildGeometryInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR, + eAccelerationStructureDeviceAddressInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR, + eAccelerationStructureGeometryAabbsDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR, + eAccelerationStructureGeometryInstancesDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR, + eAccelerationStructureGeometryTrianglesDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR, + eAccelerationStructureGeometryKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR, + eAccelerationStructureVersionInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR, + eCopyAccelerationStructureInfoKHR = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR, + eCopyAccelerationStructureToMemoryInfoKHR = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR, + eCopyMemoryToAccelerationStructureInfoKHR = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR, + ePhysicalDeviceAccelerationStructureFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, + ePhysicalDeviceAccelerationStructurePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR, + eAccelerationStructureCreateInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR, + eAccelerationStructureBuildSizesInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR, + ePhysicalDeviceRayTracingPipelineFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, + ePhysicalDeviceRayTracingPipelinePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR, + eRayTracingPipelineCreateInfoKHR = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR, + eRayTracingShaderGroupCreateInfoKHR = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR, + eRayTracingPipelineInterfaceCreateInfoKHR = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR, + ePhysicalDeviceRayQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, + ePipelineCoverageModulationStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV, + ePhysicalDeviceShaderSmBuiltinsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, + ePhysicalDeviceShaderSmBuiltinsPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV, + eDrmFormatModifierPropertiesListEXT = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT, + ePhysicalDeviceImageDrmFormatModifierInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT, + eImageDrmFormatModifierListCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, + eImageDrmFormatModifierExplicitCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, + eImageDrmFormatModifierPropertiesEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT, + eDrmFormatModifierPropertiesList2EXT = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT, + eValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, + eShaderModuleValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + ePhysicalDevicePortabilitySubsetFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR, + ePhysicalDevicePortabilitySubsetPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ePipelineViewportShadingRateImageStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV, + ePhysicalDeviceShadingRateImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, + ePhysicalDeviceShadingRateImagePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV, + ePipelineViewportCoarseSampleOrderStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV, + eRayTracingPipelineCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV, + eAccelerationStructureCreateInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV, + eGeometryNV = VK_STRUCTURE_TYPE_GEOMETRY_NV, + eGeometryTrianglesNV = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV, + eGeometryAabbNV = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV, + eBindAccelerationStructureMemoryInfoNV = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV, + eWriteDescriptorSetAccelerationStructureNV = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV, + eAccelerationStructureMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV, + ePhysicalDeviceRayTracingPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV, + eRayTracingShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV, + eAccelerationStructureInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV, + ePhysicalDeviceRepresentativeFragmentTestFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, + ePipelineRepresentativeFragmentTestStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV, + ePhysicalDeviceImageViewImageFormatInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT, + eFilterCubicImageViewImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, + eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, + eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, + ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, + ePhysicalDeviceShaderClockFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, + ePipelineCompilerControlCreateInfoAMD = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD, + ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, + eVideoDecodeH265CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR, + eVideoDecodeH265SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR, + eVideoDecodeH265SessionParametersAddInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR, + eVideoDecodeH265ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR, + eVideoDecodeH265PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR, + eVideoDecodeH265DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR, + eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD, + ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, +#if defined( VK_USE_PLATFORM_GGP ) + ePresentFrameTokenGGP = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP, +#endif /*VK_USE_PLATFORM_GGP*/ + ePhysicalDeviceMeshShaderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, + ePhysicalDeviceMeshShaderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV, + ePhysicalDeviceShaderImageFootprintFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, + ePipelineViewportExclusiveScissorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV, + ePhysicalDeviceExclusiveScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, + eCheckpointDataNV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV, + eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, + eQueueFamilyCheckpointProperties2NV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV, + eCheckpointData2NV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV, + ePhysicalDevicePresentTimingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT, + eSwapchainTimingPropertiesEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT, + eSwapchainTimeDomainPropertiesEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT, + ePresentTimingsInfoEXT = VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT, + ePresentTimingInfoEXT = VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT, + ePastPresentationTimingInfoEXT = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT, + ePastPresentationTimingPropertiesEXT = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT, + ePastPresentationTimingEXT = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT, + ePresentTimingSurfaceCapabilitiesEXT = VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT, + eSwapchainCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT, + ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, + eQueryPoolPerformanceQueryCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, + eQueryPoolCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL, + eInitializePerformanceApiInfoINTEL = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL, + ePerformanceMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL, + ePerformanceStreamMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL, + ePerformanceOverrideInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL, + ePerformanceConfigurationAcquireInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL, + ePhysicalDevicePciBusInfoPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, + eDisplayNativeHdrSurfaceCapabilitiesAMD = VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD, + eSwapchainDisplayNativeHdrCreateInfoAMD = VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD, +#if defined( VK_USE_PLATFORM_FUCHSIA ) + eImagepipeSurfaceCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ +#if defined( VK_USE_PLATFORM_METAL_EXT ) + eMetalSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT, +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + ePhysicalDeviceFragmentDensityMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, + ePhysicalDeviceFragmentDensityMapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, + eRenderPassFragmentDensityMapCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, + eRenderingFragmentDensityMapAttachmentInfoEXT = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT, + eFragmentShadingRateAttachmentInfoKHR = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, + ePipelineFragmentShadingRateStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, + ePhysicalDeviceFragmentShadingRatePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR, + ePhysicalDeviceFragmentShadingRateFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, + ePhysicalDeviceFragmentShadingRateKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR, + eRenderingFragmentShadingRateAttachmentInfoKHR = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, + ePhysicalDeviceShaderCoreProperties2AMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD, + ePhysicalDeviceCoherentMemoryFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, + ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, + ePhysicalDeviceShaderQuadControlFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR, + ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, + ePhysicalDeviceMemoryPriorityFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, + eMemoryPriorityAllocateInfoEXT = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT, + eSurfaceProtectedCapabilitiesKHR = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR, + ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, + ePhysicalDeviceBufferDeviceAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, + ePhysicalDeviceBufferAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT, + eBufferDeviceAddressCreateInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, + eValidationFeaturesEXT = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT, + ePhysicalDevicePresentWaitFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, + ePhysicalDeviceCooperativeMatrixFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, + eCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV, + ePhysicalDeviceCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV, + ePhysicalDeviceCoverageReductionModeFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, + ePipelineCoverageReductionStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV, + eFramebufferMixedSamplesCombinationNV = VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV, + ePhysicalDeviceFragmentShaderInterlockFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, + ePhysicalDeviceYcbcrImageArraysFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, + ePhysicalDeviceProvokingVertexFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, + ePipelineRasterizationProvokingVertexStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT, + ePhysicalDeviceProvokingVertexPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + eSurfaceFullScreenExclusiveInfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT, + eSurfaceCapabilitiesFullScreenExclusiveEXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT, + eSurfaceFullScreenExclusiveWin32InfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + eHeadlessSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT, + ePhysicalDeviceShaderAtomicFloatFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, + ePhysicalDeviceExtendedDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, + ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, + ePipelineInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, + ePipelineInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT, + ePipelineExecutablePropertiesKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR, + ePipelineExecutableInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR, + ePipelineExecutableStatisticKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR, + ePipelineExecutableInternalRepresentationKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR, + ePhysicalDeviceMapMemoryPlacedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT, + ePhysicalDeviceMapMemoryPlacedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT, + eMemoryMapPlacedInfoEXT = VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT, + ePhysicalDeviceShaderAtomicFloat2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, + ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV, + eGraphicsShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV, + eGraphicsPipelineShaderGroupsCreateInfoNV = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV, + eIndirectCommandsLayoutTokenNV = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV, + eIndirectCommandsLayoutCreateInfoNV = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV, + eGeneratedCommandsInfoNV = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV, + eGeneratedCommandsMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV, + ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV, + ePhysicalDeviceInheritedViewportScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV, + eCommandBufferInheritanceViewportScissorInfoNV = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV, + ePhysicalDeviceTexelBufferAlignmentFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, + eCommandBufferInheritanceRenderPassTransformInfoQCOM = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM, + eRenderPassTransformBeginInfoQCOM = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM, + ePhysicalDeviceDepthBiasControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT, + eDepthBiasInfoEXT = VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT, + eDepthBiasRepresentationInfoEXT = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT, + ePhysicalDeviceDeviceMemoryReportFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, + eDeviceDeviceMemoryReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, + eDeviceMemoryReportCallbackDataEXT = VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT, + eSamplerCustomBorderColorCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT, + ePhysicalDeviceCustomBorderColorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT, + ePhysicalDeviceCustomBorderColorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, + ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT, + ePipelineLibraryCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR, + ePhysicalDevicePresentBarrierFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV, + eSurfaceCapabilitiesPresentBarrierNV = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV, + eSwapchainPresentBarrierCreateInfoNV = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV, + ePresentIdKHR = VK_STRUCTURE_TYPE_PRESENT_ID_KHR, + ePhysicalDevicePresentIdFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, + eVideoEncodeInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR, + eVideoEncodeRateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR, + eVideoEncodeRateControlLayerInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR, + eVideoEncodeCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR, + eVideoEncodeUsageInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR, + eQueryPoolVideoEncodeFeedbackCreateInfoKHR = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR, + ePhysicalDeviceVideoEncodeQualityLevelInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR, + eVideoEncodeQualityLevelPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR, + eVideoEncodeQualityLevelInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR, + eVideoEncodeSessionParametersGetInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR, + eVideoEncodeSessionParametersFeedbackInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR, + ePhysicalDeviceDiagnosticsConfigFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, + eDeviceDiagnosticsConfigCreateInfoNV = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eCudaModuleCreateInfoNV = VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV, + eCudaFunctionCreateInfoNV = VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV, + eCudaLaunchInfoNV = VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV, + ePhysicalDeviceCudaKernelLaunchFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV, + ePhysicalDeviceCudaKernelLaunchPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ePhysicalDeviceTileShadingFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM, + ePhysicalDeviceTileShadingPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM, + eRenderPassTileShadingCreateInfoQCOM = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM, + ePerTileBeginInfoQCOM = VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM, + ePerTileEndInfoQCOM = VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM, + eDispatchTileInfoQCOM = VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM, + eQueryLowLatencySupportNV = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV, +#if defined( VK_USE_PLATFORM_METAL_EXT ) + eExportMetalObjectCreateInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, + eExportMetalObjectsInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT, + eExportMetalDeviceInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT, + eExportMetalCommandQueueInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT, + eExportMetalBufferInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT, + eImportMetalBufferInfoEXT = VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT, + eExportMetalTextureInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT, + eImportMetalTextureInfoEXT = VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, + eExportMetalIoSurfaceInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT, + eImportMetalIoSurfaceInfoEXT = VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, + eExportMetalSharedEventInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT, + eImportMetalSharedEventInfoEXT = VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT, +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + ePhysicalDeviceDescriptorBufferPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT, + ePhysicalDeviceDescriptorBufferDensityMapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT, + ePhysicalDeviceDescriptorBufferFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT, + eDescriptorAddressInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT, + eDescriptorGetInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT, + eBufferCaptureDescriptorDataInfoEXT = VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, + eImageCaptureDescriptorDataInfoEXT = VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, + eImageViewCaptureDescriptorDataInfoEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, + eSamplerCaptureDescriptorDataInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, + eOpaqueCaptureDescriptorDataCreateInfoEXT = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT, + eDescriptorBufferBindingInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT, + eDescriptorBufferBindingPushDescriptorBufferHandleEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT, + eAccelerationStructureCaptureDescriptorDataInfoEXT = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, + ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT, + ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT, + eGraphicsPipelineLibraryCreateInfoEXT = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT, + ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD, + ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, + ePhysicalDeviceFragmentShaderBarycentricFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, + ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR, + ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, + ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV, + ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, + ePipelineFragmentShadingRateEnumStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV, + eAccelerationStructureGeometryMotionTrianglesDataNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV, + ePhysicalDeviceRayTracingMotionBlurFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV, + eAccelerationStructureMotionInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV, + ePhysicalDeviceMeshShaderFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT, + ePhysicalDeviceMeshShaderPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT, + ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, + ePhysicalDeviceFragmentDensityMap2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, + ePhysicalDeviceFragmentDensityMap2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT, + eCopyCommandTransformInfoQCOM = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM, + ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, + ePhysicalDeviceImageCompressionControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT, + eImageCompressionControlEXT = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, + eImageCompressionPropertiesEXT = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, + ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT, + ePhysicalDevice4444FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, + ePhysicalDeviceFaultFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT, + eDeviceFaultCountsEXT = VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT, + eDeviceFaultInfoEXT = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT, + ePhysicalDeviceRgba10X6FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + eDirectfbSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT, +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + ePhysicalDeviceVertexInputDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, + eVertexInputBindingDescription2EXT = VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT, + eVertexInputAttributeDescription2EXT = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT, + ePhysicalDeviceDrmPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT, + ePhysicalDeviceAddressBindingReportFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, + eDeviceAddressBindingCallbackDataEXT = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT, + ePhysicalDeviceDepthClipControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, + ePipelineViewportDepthClipControlCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT, + ePhysicalDevicePrimitiveTopologyListRestartFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, +#if defined( VK_USE_PLATFORM_FUCHSIA ) + eImportMemoryZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA, + eMemoryZirconHandlePropertiesFUCHSIA = VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA, + eMemoryGetZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA, + eImportSemaphoreZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA, + eSemaphoreGetZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA, + eBufferCollectionCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA, + eImportMemoryBufferCollectionFUCHSIA = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA, + eBufferCollectionImageCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, + eBufferCollectionPropertiesFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA, + eBufferConstraintsInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA, + eBufferCollectionBufferCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA, + eImageConstraintsInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA, + eImageFormatConstraintsInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA, + eSysmemColorSpaceFUCHSIA = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA, + eBufferCollectionConstraintsInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + eSubpassShadingPipelineCreateInfoHUAWEI = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI, + ePhysicalDeviceSubpassShadingFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI, + ePhysicalDeviceSubpassShadingPropertiesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI, + ePhysicalDeviceInvocationMaskFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, + eMemoryGetRemoteAddressInfoNV = VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV, + ePhysicalDeviceExternalMemoryRdmaFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV, + ePipelinePropertiesIdentifierEXT = VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT, + ePhysicalDevicePipelinePropertiesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT, + ePhysicalDeviceFrameBoundaryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT, + eFrameBoundaryEXT = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT, + ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT, + eSubpassResolvePerformanceQueryEXT = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT, + eMultisampledRenderToSingleSampledInfoEXT = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT, + ePhysicalDeviceExtendedDynamicState2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + eScreenSurfaceCreateInfoQNX = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX, +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + ePhysicalDeviceColorWriteEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, + ePipelineColorWriteCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT, + ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, + ePhysicalDeviceRayTracingMaintenance1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, + ePhysicalDeviceShaderUntypedPointersFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR, + ePhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE, + eVideoEncodeRgbConversionCapabilitiesVALVE = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE, + eVideoEncodeProfileRgbConversionInfoVALVE = VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE, + eVideoEncodeSessionRgbConversionCreateInfoVALVE = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE, + ePhysicalDeviceImageViewMinLodFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, + eImageViewMinLodCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT, + ePhysicalDeviceMultiDrawFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, + ePhysicalDeviceMultiDrawPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT, + ePhysicalDeviceImage2DViewOf3DFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, + ePhysicalDeviceShaderTileImageFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, + ePhysicalDeviceShaderTileImagePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT, + eMicromapBuildInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT, + eMicromapVersionInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT, + eCopyMicromapInfoEXT = VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT, + eCopyMicromapToMemoryInfoEXT = VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT, + eCopyMemoryToMicromapInfoEXT = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT, + ePhysicalDeviceOpacityMicromapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, + ePhysicalDeviceOpacityMicromapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT, + eMicromapCreateInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT, + eMicromapBuildSizesInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT, + eAccelerationStructureTrianglesOpacityMicromapEXT = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + ePhysicalDeviceDisplacementMicromapFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV, + ePhysicalDeviceDisplacementMicromapPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV, + eAccelerationStructureTrianglesDisplacementMicromapNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ePhysicalDeviceClusterCullingShaderFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI, + ePhysicalDeviceClusterCullingShaderPropertiesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI, + ePhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI, + ePhysicalDeviceBorderColorSwizzleFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, + eSamplerBorderColorComponentMappingCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT, + ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, + ePhysicalDeviceShaderCorePropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM, + eDeviceQueueShaderCoreControlCreateInfoARM = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM, + ePhysicalDeviceSchedulingControlsFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM, + ePhysicalDeviceSchedulingControlsPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM, + ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT, + eImageViewSlicedCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT, + ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, + eDescriptorSetBindingReferenceVALVE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE, + eDescriptorSetLayoutHostMappingInfoVALVE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE, + ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, + ePhysicalDeviceRenderPassStripedFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM, + ePhysicalDeviceRenderPassStripedPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM, + eRenderPassStripeBeginInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM, + eRenderPassStripeInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM, + eRenderPassStripeSubmitInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM, + ePhysicalDeviceCopyMemoryIndirectFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV, + ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV, + eComputePipelineIndirectBufferInfoNV = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV, + ePipelineIndirectDeviceAddressInfoNV = VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV, + ePhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV, + eAccelerationStructureGeometryLinearSweptSpheresDataNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV, + eAccelerationStructureGeometrySpheresDataNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV, + ePhysicalDeviceLinearColorAttachmentFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, + ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR, + ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT, + ePhysicalDeviceImageProcessingFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM, + ePhysicalDeviceImageProcessingPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM, + eImageViewSampleWeightCreateInfoQCOM = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM, + ePhysicalDeviceNestedCommandBufferFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT, + ePhysicalDeviceNestedCommandBufferPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT, +#if defined( VK_USE_PLATFORM_OHOS ) + eNativeBufferUsageOHOS = VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS, + eNativeBufferPropertiesOHOS = VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS, + eNativeBufferFormatPropertiesOHOS = VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS, + eImportNativeBufferInfoOHOS = VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS, + eMemoryGetNativeBufferInfoOHOS = VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS, + eExternalFormatOHOS = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, +#endif /*VK_USE_PLATFORM_OHOS*/ + eExternalMemoryAcquireUnmodifiedEXT = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT, + ePhysicalDeviceExtendedDynamicState3FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT, + ePhysicalDeviceExtendedDynamicState3PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT, + ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, + eRenderPassCreationControlEXT = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT, + eRenderPassCreationFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT, + eRenderPassSubpassFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT, + eDirectDriverLoadingInfoLUNARG = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG, + eDirectDriverLoadingListLUNARG = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG, + eTensorCreateInfoARM = VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM, + eTensorViewCreateInfoARM = VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM, + eBindTensorMemoryInfoARM = VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM, + eWriteDescriptorSetTensorARM = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM, + ePhysicalDeviceTensorPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM, + eTensorFormatPropertiesARM = VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM, + eTensorDescriptionARM = VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM, + eTensorMemoryRequirementsInfoARM = VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM, + eTensorMemoryBarrierARM = VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM, + ePhysicalDeviceTensorFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM, + eDeviceTensorMemoryRequirementsARM = VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM, + eCopyTensorInfoARM = VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM, + eTensorCopyARM = VK_STRUCTURE_TYPE_TENSOR_COPY_ARM, + eTensorDependencyInfoARM = VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM, + eMemoryDedicatedAllocateInfoTensorARM = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM, + ePhysicalDeviceExternalTensorInfoARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM, + eExternalTensorPropertiesARM = VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM, + eExternalMemoryTensorCreateInfoARM = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM, + ePhysicalDeviceDescriptorBufferTensorFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM, + ePhysicalDeviceDescriptorBufferTensorPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM, + eDescriptorGetTensorInfoARM = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM, + eTensorCaptureDescriptorDataInfoARM = VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM, + eTensorViewCaptureDescriptorDataInfoARM = VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM, + eFrameBoundaryTensorsARM = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM, + ePhysicalDeviceShaderModuleIdentifierFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, + ePhysicalDeviceShaderModuleIdentifierPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT, + ePipelineShaderStageModuleIdentifierCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT, + eShaderModuleIdentifierEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT, + ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, + ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM, + ePhysicalDeviceOpticalFlowFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV, + ePhysicalDeviceOpticalFlowPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV, + eOpticalFlowImageFormatInfoNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, + eOpticalFlowImageFormatPropertiesNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV, + eOpticalFlowSessionCreateInfoNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV, + eOpticalFlowExecuteInfoNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV, + eOpticalFlowSessionCreatePrivateDataInfoNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV, + ePhysicalDeviceLegacyDitheringFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT, +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + ePhysicalDeviceExternalFormatResolveFeaturesANDROID = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID, + ePhysicalDeviceExternalFormatResolvePropertiesANDROID = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID, + eAndroidHardwareBufferFormatResolvePropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + ePhysicalDeviceAntiLagFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD, + eAntiLagDataAMD = VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD, + eAntiLagPresentationInfoAMD = VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + ePhysicalDeviceDenseGeometryFormatFeaturesAMDX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX, + eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eSurfaceCapabilitiesPresentId2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR, + ePresentId2KHR = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR, + ePhysicalDevicePresentId2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR, + eSurfaceCapabilitiesPresentWait2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR, + ePhysicalDevicePresentWait2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR, + ePresentWait2InfoKHR = VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR, + ePhysicalDeviceRayTracingPositionFetchFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR, + ePhysicalDeviceShaderObjectFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, + ePhysicalDeviceShaderObjectPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT, + eShaderCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT, + ePhysicalDevicePipelineBinaryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, + ePipelineBinaryCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR, + ePipelineBinaryInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR, + ePipelineBinaryKeyKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR, + ePhysicalDevicePipelineBinaryPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR, + eReleaseCapturedPipelineDataInfoKHR = VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR, + ePipelineBinaryDataInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR, + ePipelineCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR, + eDevicePipelineBinaryInternalCacheControlKHR = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR, + ePipelineBinaryHandlesInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR, + ePhysicalDeviceTilePropertiesFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM, + eTilePropertiesQCOM = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM, + ePhysicalDeviceAmigoProfilingFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, + eAmigoProfilingSubmitInfoSEC = VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC, + eSurfacePresentModeKHR = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR, + eSurfacePresentModeEXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT, + eSurfacePresentScalingCapabilitiesKHR = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR, + eSurfacePresentScalingCapabilitiesEXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT, + eSurfacePresentModeCompatibilityKHR = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR, + eSurfacePresentModeCompatibilityEXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT, + ePhysicalDeviceSwapchainMaintenance1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR, + ePhysicalDeviceSwapchainMaintenance1FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT, + eSwapchainPresentFenceInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR, + eSwapchainPresentFenceInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT, + eSwapchainPresentModesCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR, + eSwapchainPresentModesCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT, + eSwapchainPresentModeInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR, + eSwapchainPresentModeInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT, + eSwapchainPresentScalingCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR, + eSwapchainPresentScalingCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT, + eReleaseSwapchainImagesInfoKHR = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR, + eReleaseSwapchainImagesInfoEXT = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT, + ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM, + ePhysicalDeviceRayTracingInvocationReorderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV, + ePhysicalDeviceRayTracingInvocationReorderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV, + ePhysicalDeviceCooperativeVectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV, + ePhysicalDeviceCooperativeVectorPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV, + eCooperativeVectorPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV, + eConvertCooperativeVectorMatrixInfoNV = VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV, + ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV, + ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV, + ePhysicalDeviceMutableDescriptorTypeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, + ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE, + eMutableDescriptorTypeCreateInfoEXT = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, + eMutableDescriptorTypeCreateInfoVALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE, + ePhysicalDeviceLegacyVertexAttributesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT, + ePhysicalDeviceLegacyVertexAttributesPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT, + eLayerSettingsCreateInfoEXT = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, + ePhysicalDeviceShaderCoreBuiltinsFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM, + ePhysicalDeviceShaderCoreBuiltinsPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM, + ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT, + ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT, + ePhysicalDeviceInternallySynchronizedQueuesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR, + eLatencySleepModeInfoNV = VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV, + eLatencySleepInfoNV = VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV, + eSetLatencyMarkerInfoNV = VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV, + eGetLatencyMarkerInfoNV = VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV, + eLatencyTimingsFrameReportNV = VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV, + eLatencySubmissionPresentIdNV = VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV, + eOutOfBandQueueTypeInfoNV = VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV, + eSwapchainLatencyCreateInfoNV = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV, + eLatencySurfaceCapabilitiesNV = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV, + ePhysicalDeviceCooperativeMatrixFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR, + eCooperativeMatrixPropertiesKHR = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR, + ePhysicalDeviceCooperativeMatrixPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR, + eDataGraphPipelineCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM, + eDataGraphPipelineSessionCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM, + eDataGraphPipelineResourceInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM, + eDataGraphPipelineConstantARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM, + eDataGraphPipelineSessionMemoryRequirementsInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM, + eBindDataGraphPipelineSessionMemoryInfoARM = VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM, + ePhysicalDeviceDataGraphFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM, + eDataGraphPipelineShaderModuleCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM, + eDataGraphPipelinePropertyQueryResultARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM, + eDataGraphPipelineInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM, + eDataGraphPipelineCompilerControlCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM, + eDataGraphPipelineSessionBindPointRequirementsInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM, + eDataGraphPipelineSessionBindPointRequirementARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM, + eDataGraphPipelineIdentifierCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM, + eDataGraphPipelineDispatchInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM, + eDataGraphProcessingEngineCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM, + eQueueFamilyDataGraphProcessingEnginePropertiesARM = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM, + eQueueFamilyDataGraphPropertiesARM = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM, + ePhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM, + eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM, + ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, + eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM, + ePhysicalDeviceComputeShaderDerivativesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, + ePhysicalDeviceComputeShaderDerivativesFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, + ePhysicalDeviceComputeShaderDerivativesPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR, + eVideoDecodeAv1CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR, + eVideoDecodeAv1PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR, + eVideoDecodeAv1ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR, + eVideoDecodeAv1SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR, + eVideoDecodeAv1DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR, + eVideoEncodeAv1CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR, + eVideoEncodeAv1SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR, + eVideoEncodeAv1PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR, + eVideoEncodeAv1DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR, + ePhysicalDeviceVideoEncodeAv1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR, + eVideoEncodeAv1ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR, + eVideoEncodeAv1RateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR, + eVideoEncodeAv1RateControlLayerInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR, + eVideoEncodeAv1QualityLevelPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR, + eVideoEncodeAv1SessionCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR, + eVideoEncodeAv1GopRemainingFrameInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR, + ePhysicalDeviceVideoDecodeVp9FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR, + eVideoDecodeVp9CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR, + eVideoDecodeVp9PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR, + eVideoDecodeVp9ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR, + ePhysicalDeviceVideoMaintenance1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, + eVideoInlineQueryInfoKHR = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR, + ePhysicalDevicePerStageDescriptorSetFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, + ePhysicalDeviceImageProcessing2FeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM, + ePhysicalDeviceImageProcessing2PropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM, + eSamplerBlockMatchWindowCreateInfoQCOM = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM, + eSamplerCubicWeightsCreateInfoQCOM = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM, + ePhysicalDeviceCubicWeightsFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM, + eBlitImageCubicWeightsInfoQCOM = VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM, + ePhysicalDeviceYcbcrDegammaFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM, + eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM, + ePhysicalDeviceCubicClampFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM, + ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT, + ePhysicalDeviceUnifiedImageLayoutsFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR, + eAttachmentFeedbackLoopInfoEXT = VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT, +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + eScreenBufferPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX, + eScreenBufferFormatPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX, + eImportScreenBufferInfoQNX = VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX, + eExternalFormatQNX = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX, + ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX, +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + ePhysicalDeviceLayeredDriverPropertiesMSFT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT, + eCalibratedTimestampInfoKHR = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR, + eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, + eSetDescriptorBufferOffsetsInfoEXT = VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT, + eBindDescriptorBufferEmbeddedSamplersInfoEXT = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT, + ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, + ePhysicalDeviceTileMemoryHeapFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM, + ePhysicalDeviceTileMemoryHeapPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM, + eTileMemoryRequirementsQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM, + eTileMemoryBindInfoQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM, + eTileMemorySizeInfoQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM, + ePhysicalDeviceCopyMemoryIndirectFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR, + ePhysicalDeviceCopyMemoryIndirectPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR, + ePhysicalDeviceCopyMemoryIndirectPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV, + eCopyMemoryIndirectInfoKHR = VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR, + eCopyMemoryToImageIndirectInfoKHR = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR, + ePhysicalDeviceMemoryDecompressionFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT, + ePhysicalDeviceMemoryDecompressionFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV, + ePhysicalDeviceMemoryDecompressionPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT, + ePhysicalDeviceMemoryDecompressionPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV, + eDecompressMemoryInfoEXT = VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT, + eDisplaySurfaceStereoCreateInfoNV = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV, + eDisplayModeStereoPropertiesNV = VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV, + eVideoEncodeIntraRefreshCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR, + eVideoEncodeSessionIntraRefreshCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR, + eVideoEncodeIntraRefreshInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR, + eVideoReferenceIntraRefreshInfoKHR = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR, + ePhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR, + eVideoEncodeQuantizationMapCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR, + eVideoFormatQuantizationMapPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR, + eVideoEncodeQuantizationMapInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR, + eVideoEncodeQuantizationMapSessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR, + ePhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR, + eVideoEncodeH264QuantizationMapCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR, + eVideoEncodeH265QuantizationMapCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR, + eVideoFormatH265QuantizationMapPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR, + eVideoEncodeAv1QuantizationMapCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR, + eVideoFormatAv1QuantizationMapPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR, + ePhysicalDeviceRawAccessChainsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV, + eExternalComputeQueueDeviceCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV, + eExternalComputeQueueCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV, + eExternalComputeQueueDataParamsNV = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV, + ePhysicalDeviceExternalComputeQueuePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV, + ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR, + ePhysicalDeviceCommandBufferInheritanceFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV, + ePhysicalDeviceMaintenance7FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR, + ePhysicalDeviceMaintenance7PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR, + ePhysicalDeviceLayeredApiPropertiesListKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR, + ePhysicalDeviceLayeredApiPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR, + ePhysicalDeviceLayeredApiVulkanPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR, + ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV, + ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT, + ePhysicalDeviceShaderFloat8FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT, + ePhysicalDeviceRayTracingValidationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV, + ePhysicalDeviceClusterAccelerationStructureFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV, + ePhysicalDeviceClusterAccelerationStructurePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV, + eClusterAccelerationStructureClustersBottomLevelInputNV = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV, + eClusterAccelerationStructureTriangleClusterInputNV = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV, + eClusterAccelerationStructureMoveObjectsInputNV = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV, + eClusterAccelerationStructureInputInfoNV = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV, + eClusterAccelerationStructureCommandsInfoNV = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV, + eRayTracingPipelineClusterAccelerationStructureCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV, + ePhysicalDevicePartitionedAccelerationStructureFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV, + ePhysicalDevicePartitionedAccelerationStructurePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV, + eWriteDescriptorSetPartitionedAccelerationStructureNV = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV, + ePartitionedAccelerationStructureInstancesInputNV = VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV, + eBuildPartitionedAccelerationStructureInfoNV = VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV, + ePartitionedAccelerationStructureFlagsNV = VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV, + ePhysicalDeviceDeviceGeneratedCommandsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT, + ePhysicalDeviceDeviceGeneratedCommandsPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT, + eGeneratedCommandsMemoryRequirementsInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT, + eIndirectExecutionSetCreateInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT, + eGeneratedCommandsInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT, + eIndirectCommandsLayoutCreateInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT, + eIndirectCommandsLayoutTokenEXT = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT, + eWriteIndirectExecutionSetPipelineEXT = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT, + eWriteIndirectExecutionSetShaderEXT = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT, + eIndirectExecutionSetPipelineInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT, + eIndirectExecutionSetShaderInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT, + eIndirectExecutionSetShaderLayoutInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT, + eGeneratedCommandsPipelineInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT, + eGeneratedCommandsShaderInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT, + ePhysicalDeviceMaintenance8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR, + eMemoryBarrierAccessFlags3KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR, + ePhysicalDeviceImageAlignmentControlFeaturesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA, + ePhysicalDeviceImageAlignmentControlPropertiesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA, + eImageAlignmentControlCreateInfoMESA = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA, + ePhysicalDeviceShaderFmaFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR, + ePushConstantBankInfoNV = VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV, + ePhysicalDevicePushConstantBankFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV, + ePhysicalDevicePushConstantBankPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV, + ePhysicalDeviceRayTracingInvocationReorderFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT, + ePhysicalDeviceRayTracingInvocationReorderPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT, + ePhysicalDeviceDepthClampControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT, + ePipelineViewportDepthClampControlCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT, + ePhysicalDeviceMaintenance9FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR, + ePhysicalDeviceMaintenance9PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR, + eQueueFamilyOwnershipTransferPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR, + ePhysicalDeviceVideoMaintenance2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR, + eVideoDecodeH264InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR, + eVideoDecodeH265InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR, + eVideoDecodeAv1InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR, +#if defined( VK_USE_PLATFORM_OHOS ) + eSurfaceCreateInfoOHOS = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS, +#endif /*VK_USE_PLATFORM_OHOS*/ + ePhysicalDeviceHdrVividFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI, + eHdrVividDynamicMetadataHUAWEI = VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI, + ePhysicalDeviceCooperativeMatrix2FeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV, + eCooperativeMatrixFlexibleDimensionsPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV, + ePhysicalDeviceCooperativeMatrix2PropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV, + ePhysicalDevicePipelineOpacityMicromapFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM, +#if defined( VK_USE_PLATFORM_METAL_EXT ) + eImportMemoryMetalHandleInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT, + eMemoryMetalHandlePropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT, + eMemoryGetMetalHandleInfoEXT = VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT, +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + ePhysicalDeviceDepthClampZeroOneFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR, + ePhysicalDeviceDepthClampZeroOneFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT, + ePhysicalDevicePerformanceCountersByRegionFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM, + ePhysicalDevicePerformanceCountersByRegionPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM, + ePerformanceCounterARM = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM, + ePerformanceCounterDescriptionARM = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM, + eRenderPassPerformanceCountersByRegionBeginInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM, + ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT, + ePhysicalDeviceFormatPackFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM, + ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE, + ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE, + ePipelineFragmentDensityMapLayeredCreateInfoVALVE = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE, + ePhysicalDeviceRobustness2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, + ePhysicalDeviceRobustness2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, + ePhysicalDeviceRobustness2PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR, + ePhysicalDeviceRobustness2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eSetPresentConfigNV = VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV, + ePhysicalDevicePresentMeteringFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT, + ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM, + ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT, + ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM, + eRenderPassFragmentDensityMapOffsetEndInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT, + eSubpassFragmentDensityMapOffsetEndInfoQCOM = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM, + ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT, + ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, + ePhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT, + ePhysicalDeviceShader64BitIndexingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT, + ePhysicalDeviceCustomResolveFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT, + eBeginCustomResolveInfoEXT = VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT, + eCustomResolveCreateInfoEXT = VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT, + ePhysicalDeviceDataGraphModelFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM, + eDataGraphPipelineBuiltinModelCreateInfoQCOM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM, + ePhysicalDeviceMaintenance10FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR, + ePhysicalDeviceMaintenance10PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR, + eRenderingAttachmentFlagsInfoKHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR, + eRenderingEndInfoKHR = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR, + eRenderingEndInfoEXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT, + eResolveImageModeInfoKHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR, + ePhysicalDeviceShaderLongVectorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT, + ePhysicalDeviceShaderLongVectorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT, + ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC, + ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT, + eComputeOccupancyPriorityParametersNV = VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV, + ePhysicalDeviceComputeOccupancyPriorityFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV, + ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT + }; + + // wrapper class for enum VkObjectType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkObjectType.html + enum class ObjectType + { + eUnknown = VK_OBJECT_TYPE_UNKNOWN, + eInstance = VK_OBJECT_TYPE_INSTANCE, + ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE, + eDevice = VK_OBJECT_TYPE_DEVICE, + eQueue = VK_OBJECT_TYPE_QUEUE, + eSemaphore = VK_OBJECT_TYPE_SEMAPHORE, + eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER, + eFence = VK_OBJECT_TYPE_FENCE, + eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY, + eBuffer = VK_OBJECT_TYPE_BUFFER, + eImage = VK_OBJECT_TYPE_IMAGE, + eEvent = VK_OBJECT_TYPE_EVENT, + eQueryPool = VK_OBJECT_TYPE_QUERY_POOL, + eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW, + eImageView = VK_OBJECT_TYPE_IMAGE_VIEW, + eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE, + ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE, + ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT, + eRenderPass = VK_OBJECT_TYPE_RENDER_PASS, + ePipeline = VK_OBJECT_TYPE_PIPELINE, + eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, + eSampler = VK_OBJECT_TYPE_SAMPLER, + eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL, + eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET, + eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER, + eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL, + eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, + eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, + eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, + eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR, + ePrivateDataSlot = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, + ePrivateDataSlotEXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT, + eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR, + eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR, + eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR, + eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR, + eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, + eVideoSessionKHR = VK_OBJECT_TYPE_VIDEO_SESSION_KHR, + eVideoSessionParametersKHR = VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR, + eCuModuleNVX = VK_OBJECT_TYPE_CU_MODULE_NVX, + eCuFunctionNVX = VK_OBJECT_TYPE_CU_FUNCTION_NVX, + eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, + eAccelerationStructureKHR = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR, + eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT, + eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV, + ePerformanceConfigurationINTEL = VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL, + eDeferredOperationKHR = VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR, + eIndirectCommandsLayoutNV = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eCudaModuleNV = VK_OBJECT_TYPE_CUDA_MODULE_NV, + eCudaFunctionNV = VK_OBJECT_TYPE_CUDA_FUNCTION_NV, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ +#if defined( VK_USE_PLATFORM_FUCHSIA ) + eBufferCollectionFUCHSIA = VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + eMicromapEXT = VK_OBJECT_TYPE_MICROMAP_EXT, + eTensorARM = VK_OBJECT_TYPE_TENSOR_ARM, + eTensorViewARM = VK_OBJECT_TYPE_TENSOR_VIEW_ARM, + eOpticalFlowSessionNV = VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV, + eShaderEXT = VK_OBJECT_TYPE_SHADER_EXT, + ePipelineBinaryKHR = VK_OBJECT_TYPE_PIPELINE_BINARY_KHR, + eDataGraphPipelineSessionARM = VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM, + eExternalComputeQueueNV = VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV, + eIndirectCommandsLayoutEXT = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT, + eIndirectExecutionSetEXT = VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT + }; + + // wrapper class for enum VkVendorId, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVendorId.html + enum class VendorId + { + eKhronos = VK_VENDOR_ID_KHRONOS, + eVIV = VK_VENDOR_ID_VIV, + eVSI = VK_VENDOR_ID_VSI, + eKazan = VK_VENDOR_ID_KAZAN, + eCodeplay = VK_VENDOR_ID_CODEPLAY, + eMESA = VK_VENDOR_ID_MESA, + ePocl = VK_VENDOR_ID_POCL, + eMobileye = VK_VENDOR_ID_MOBILEYE + }; + + // wrapper class for enum VkFormat, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormat.html + enum class Format + { + eUndefined = VK_FORMAT_UNDEFINED, + eR4G4UnormPack8 = VK_FORMAT_R4G4_UNORM_PACK8, + eR4G4B4A4UnormPack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16, + eB4G4R4A4UnormPack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16, + eR5G6B5UnormPack16 = VK_FORMAT_R5G6B5_UNORM_PACK16, + eB5G6R5UnormPack16 = VK_FORMAT_B5G6R5_UNORM_PACK16, + eR5G5B5A1UnormPack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16, + eB5G5R5A1UnormPack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16, + eA1R5G5B5UnormPack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16, + eR8Unorm = VK_FORMAT_R8_UNORM, + eR8Snorm = VK_FORMAT_R8_SNORM, + eR8Uscaled = VK_FORMAT_R8_USCALED, + eR8Sscaled = VK_FORMAT_R8_SSCALED, + eR8Uint = VK_FORMAT_R8_UINT, + eR8Sint = VK_FORMAT_R8_SINT, + eR8Srgb = VK_FORMAT_R8_SRGB, + eR8G8Unorm = VK_FORMAT_R8G8_UNORM, + eR8G8Snorm = VK_FORMAT_R8G8_SNORM, + eR8G8Uscaled = VK_FORMAT_R8G8_USCALED, + eR8G8Sscaled = VK_FORMAT_R8G8_SSCALED, + eR8G8Uint = VK_FORMAT_R8G8_UINT, + eR8G8Sint = VK_FORMAT_R8G8_SINT, + eR8G8Srgb = VK_FORMAT_R8G8_SRGB, + eR8G8B8Unorm = VK_FORMAT_R8G8B8_UNORM, + eR8G8B8Snorm = VK_FORMAT_R8G8B8_SNORM, + eR8G8B8Uscaled = VK_FORMAT_R8G8B8_USCALED, + eR8G8B8Sscaled = VK_FORMAT_R8G8B8_SSCALED, + eR8G8B8Uint = VK_FORMAT_R8G8B8_UINT, + eR8G8B8Sint = VK_FORMAT_R8G8B8_SINT, + eR8G8B8Srgb = VK_FORMAT_R8G8B8_SRGB, + eB8G8R8Unorm = VK_FORMAT_B8G8R8_UNORM, + eB8G8R8Snorm = VK_FORMAT_B8G8R8_SNORM, + eB8G8R8Uscaled = VK_FORMAT_B8G8R8_USCALED, + eB8G8R8Sscaled = VK_FORMAT_B8G8R8_SSCALED, + eB8G8R8Uint = VK_FORMAT_B8G8R8_UINT, + eB8G8R8Sint = VK_FORMAT_B8G8R8_SINT, + eB8G8R8Srgb = VK_FORMAT_B8G8R8_SRGB, + eR8G8B8A8Unorm = VK_FORMAT_R8G8B8A8_UNORM, + eR8G8B8A8Snorm = VK_FORMAT_R8G8B8A8_SNORM, + eR8G8B8A8Uscaled = VK_FORMAT_R8G8B8A8_USCALED, + eR8G8B8A8Sscaled = VK_FORMAT_R8G8B8A8_SSCALED, + eR8G8B8A8Uint = VK_FORMAT_R8G8B8A8_UINT, + eR8G8B8A8Sint = VK_FORMAT_R8G8B8A8_SINT, + eR8G8B8A8Srgb = VK_FORMAT_R8G8B8A8_SRGB, + eB8G8R8A8Unorm = VK_FORMAT_B8G8R8A8_UNORM, + eB8G8R8A8Snorm = VK_FORMAT_B8G8R8A8_SNORM, + eB8G8R8A8Uscaled = VK_FORMAT_B8G8R8A8_USCALED, + eB8G8R8A8Sscaled = VK_FORMAT_B8G8R8A8_SSCALED, + eB8G8R8A8Uint = VK_FORMAT_B8G8R8A8_UINT, + eB8G8R8A8Sint = VK_FORMAT_B8G8R8A8_SINT, + eB8G8R8A8Srgb = VK_FORMAT_B8G8R8A8_SRGB, + eA8B8G8R8UnormPack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32, + eA8B8G8R8SnormPack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32, + eA8B8G8R8UscaledPack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32, + eA8B8G8R8SscaledPack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32, + eA8B8G8R8UintPack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32, + eA8B8G8R8SintPack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32, + eA8B8G8R8SrgbPack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32, + eA2R10G10B10UnormPack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32, + eA2R10G10B10SnormPack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32, + eA2R10G10B10UscaledPack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32, + eA2R10G10B10SscaledPack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32, + eA2R10G10B10UintPack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32, + eA2R10G10B10SintPack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32, + eA2B10G10R10UnormPack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32, + eA2B10G10R10SnormPack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32, + eA2B10G10R10UscaledPack32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32, + eA2B10G10R10SscaledPack32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32, + eA2B10G10R10UintPack32 = VK_FORMAT_A2B10G10R10_UINT_PACK32, + eA2B10G10R10SintPack32 = VK_FORMAT_A2B10G10R10_SINT_PACK32, + eR16Unorm = VK_FORMAT_R16_UNORM, + eR16Snorm = VK_FORMAT_R16_SNORM, + eR16Uscaled = VK_FORMAT_R16_USCALED, + eR16Sscaled = VK_FORMAT_R16_SSCALED, + eR16Uint = VK_FORMAT_R16_UINT, + eR16Sint = VK_FORMAT_R16_SINT, + eR16Sfloat = VK_FORMAT_R16_SFLOAT, + eR16G16Unorm = VK_FORMAT_R16G16_UNORM, + eR16G16Snorm = VK_FORMAT_R16G16_SNORM, + eR16G16Uscaled = VK_FORMAT_R16G16_USCALED, + eR16G16Sscaled = VK_FORMAT_R16G16_SSCALED, + eR16G16Uint = VK_FORMAT_R16G16_UINT, + eR16G16Sint = VK_FORMAT_R16G16_SINT, + eR16G16Sfloat = VK_FORMAT_R16G16_SFLOAT, + eR16G16B16Unorm = VK_FORMAT_R16G16B16_UNORM, + eR16G16B16Snorm = VK_FORMAT_R16G16B16_SNORM, + eR16G16B16Uscaled = VK_FORMAT_R16G16B16_USCALED, + eR16G16B16Sscaled = VK_FORMAT_R16G16B16_SSCALED, + eR16G16B16Uint = VK_FORMAT_R16G16B16_UINT, + eR16G16B16Sint = VK_FORMAT_R16G16B16_SINT, + eR16G16B16Sfloat = VK_FORMAT_R16G16B16_SFLOAT, + eR16G16B16A16Unorm = VK_FORMAT_R16G16B16A16_UNORM, + eR16G16B16A16Snorm = VK_FORMAT_R16G16B16A16_SNORM, + eR16G16B16A16Uscaled = VK_FORMAT_R16G16B16A16_USCALED, + eR16G16B16A16Sscaled = VK_FORMAT_R16G16B16A16_SSCALED, + eR16G16B16A16Uint = VK_FORMAT_R16G16B16A16_UINT, + eR16G16B16A16Sint = VK_FORMAT_R16G16B16A16_SINT, + eR16G16B16A16Sfloat = VK_FORMAT_R16G16B16A16_SFLOAT, + eR32Uint = VK_FORMAT_R32_UINT, + eR32Sint = VK_FORMAT_R32_SINT, + eR32Sfloat = VK_FORMAT_R32_SFLOAT, + eR32G32Uint = VK_FORMAT_R32G32_UINT, + eR32G32Sint = VK_FORMAT_R32G32_SINT, + eR32G32Sfloat = VK_FORMAT_R32G32_SFLOAT, + eR32G32B32Uint = VK_FORMAT_R32G32B32_UINT, + eR32G32B32Sint = VK_FORMAT_R32G32B32_SINT, + eR32G32B32Sfloat = VK_FORMAT_R32G32B32_SFLOAT, + eR32G32B32A32Uint = VK_FORMAT_R32G32B32A32_UINT, + eR32G32B32A32Sint = VK_FORMAT_R32G32B32A32_SINT, + eR32G32B32A32Sfloat = VK_FORMAT_R32G32B32A32_SFLOAT, + eR64Uint = VK_FORMAT_R64_UINT, + eR64Sint = VK_FORMAT_R64_SINT, + eR64Sfloat = VK_FORMAT_R64_SFLOAT, + eR64G64Uint = VK_FORMAT_R64G64_UINT, + eR64G64Sint = VK_FORMAT_R64G64_SINT, + eR64G64Sfloat = VK_FORMAT_R64G64_SFLOAT, + eR64G64B64Uint = VK_FORMAT_R64G64B64_UINT, + eR64G64B64Sint = VK_FORMAT_R64G64B64_SINT, + eR64G64B64Sfloat = VK_FORMAT_R64G64B64_SFLOAT, + eR64G64B64A64Uint = VK_FORMAT_R64G64B64A64_UINT, + eR64G64B64A64Sint = VK_FORMAT_R64G64B64A64_SINT, + eR64G64B64A64Sfloat = VK_FORMAT_R64G64B64A64_SFLOAT, + eB10G11R11UfloatPack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32, + eE5B9G9R9UfloatPack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, + eD16Unorm = VK_FORMAT_D16_UNORM, + eX8D24UnormPack32 = VK_FORMAT_X8_D24_UNORM_PACK32, + eD32Sfloat = VK_FORMAT_D32_SFLOAT, + eS8Uint = VK_FORMAT_S8_UINT, + eD16UnormS8Uint = VK_FORMAT_D16_UNORM_S8_UINT, + eD24UnormS8Uint = VK_FORMAT_D24_UNORM_S8_UINT, + eD32SfloatS8Uint = VK_FORMAT_D32_SFLOAT_S8_UINT, + eBc1RgbUnormBlock = VK_FORMAT_BC1_RGB_UNORM_BLOCK, + eBc1RgbSrgbBlock = VK_FORMAT_BC1_RGB_SRGB_BLOCK, + eBc1RgbaUnormBlock = VK_FORMAT_BC1_RGBA_UNORM_BLOCK, + eBc1RgbaSrgbBlock = VK_FORMAT_BC1_RGBA_SRGB_BLOCK, + eBc2UnormBlock = VK_FORMAT_BC2_UNORM_BLOCK, + eBc2SrgbBlock = VK_FORMAT_BC2_SRGB_BLOCK, + eBc3UnormBlock = VK_FORMAT_BC3_UNORM_BLOCK, + eBc3SrgbBlock = VK_FORMAT_BC3_SRGB_BLOCK, + eBc4UnormBlock = VK_FORMAT_BC4_UNORM_BLOCK, + eBc4SnormBlock = VK_FORMAT_BC4_SNORM_BLOCK, + eBc5UnormBlock = VK_FORMAT_BC5_UNORM_BLOCK, + eBc5SnormBlock = VK_FORMAT_BC5_SNORM_BLOCK, + eBc6HUfloatBlock = VK_FORMAT_BC6H_UFLOAT_BLOCK, + eBc6HSfloatBlock = VK_FORMAT_BC6H_SFLOAT_BLOCK, + eBc7UnormBlock = VK_FORMAT_BC7_UNORM_BLOCK, + eBc7SrgbBlock = VK_FORMAT_BC7_SRGB_BLOCK, + eEtc2R8G8B8UnormBlock = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, + eEtc2R8G8B8SrgbBlock = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, + eEtc2R8G8B8A1UnormBlock = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, + eEtc2R8G8B8A1SrgbBlock = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, + eEtc2R8G8B8A8UnormBlock = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, + eEtc2R8G8B8A8SrgbBlock = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, + eEacR11UnormBlock = VK_FORMAT_EAC_R11_UNORM_BLOCK, + eEacR11SnormBlock = VK_FORMAT_EAC_R11_SNORM_BLOCK, + eEacR11G11UnormBlock = VK_FORMAT_EAC_R11G11_UNORM_BLOCK, + eEacR11G11SnormBlock = VK_FORMAT_EAC_R11G11_SNORM_BLOCK, + eAstc4x4UnormBlock = VK_FORMAT_ASTC_4x4_UNORM_BLOCK, + eAstc4x4SrgbBlock = VK_FORMAT_ASTC_4x4_SRGB_BLOCK, + eAstc5x4UnormBlock = VK_FORMAT_ASTC_5x4_UNORM_BLOCK, + eAstc5x4SrgbBlock = VK_FORMAT_ASTC_5x4_SRGB_BLOCK, + eAstc5x5UnormBlock = VK_FORMAT_ASTC_5x5_UNORM_BLOCK, + eAstc5x5SrgbBlock = VK_FORMAT_ASTC_5x5_SRGB_BLOCK, + eAstc6x5UnormBlock = VK_FORMAT_ASTC_6x5_UNORM_BLOCK, + eAstc6x5SrgbBlock = VK_FORMAT_ASTC_6x5_SRGB_BLOCK, + eAstc6x6UnormBlock = VK_FORMAT_ASTC_6x6_UNORM_BLOCK, + eAstc6x6SrgbBlock = VK_FORMAT_ASTC_6x6_SRGB_BLOCK, + eAstc8x5UnormBlock = VK_FORMAT_ASTC_8x5_UNORM_BLOCK, + eAstc8x5SrgbBlock = VK_FORMAT_ASTC_8x5_SRGB_BLOCK, + eAstc8x6UnormBlock = VK_FORMAT_ASTC_8x6_UNORM_BLOCK, + eAstc8x6SrgbBlock = VK_FORMAT_ASTC_8x6_SRGB_BLOCK, + eAstc8x8UnormBlock = VK_FORMAT_ASTC_8x8_UNORM_BLOCK, + eAstc8x8SrgbBlock = VK_FORMAT_ASTC_8x8_SRGB_BLOCK, + eAstc10x5UnormBlock = VK_FORMAT_ASTC_10x5_UNORM_BLOCK, + eAstc10x5SrgbBlock = VK_FORMAT_ASTC_10x5_SRGB_BLOCK, + eAstc10x6UnormBlock = VK_FORMAT_ASTC_10x6_UNORM_BLOCK, + eAstc10x6SrgbBlock = VK_FORMAT_ASTC_10x6_SRGB_BLOCK, + eAstc10x8UnormBlock = VK_FORMAT_ASTC_10x8_UNORM_BLOCK, + eAstc10x8SrgbBlock = VK_FORMAT_ASTC_10x8_SRGB_BLOCK, + eAstc10x10UnormBlock = VK_FORMAT_ASTC_10x10_UNORM_BLOCK, + eAstc10x10SrgbBlock = VK_FORMAT_ASTC_10x10_SRGB_BLOCK, + eAstc12x10UnormBlock = VK_FORMAT_ASTC_12x10_UNORM_BLOCK, + eAstc12x10SrgbBlock = VK_FORMAT_ASTC_12x10_SRGB_BLOCK, + eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK, + eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, + eG8B8G8R8422Unorm = VK_FORMAT_G8B8G8R8_422_UNORM, + eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR, + eB8G8R8G8422Unorm = VK_FORMAT_B8G8R8G8_422_UNORM, + eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR, + eG8B8R83Plane420Unorm = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR, + eG8B8R82Plane420Unorm = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR, + eG8B8R83Plane422Unorm = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR, + eG8B8R82Plane422Unorm = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR, + eG8B8R83Plane444Unorm = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR, + eR10X6UnormPack16 = VK_FORMAT_R10X6_UNORM_PACK16, + eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16_KHR, + eR10X6G10X6Unorm2Pack16 = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR, + eR10X6G10X6B10X6A10X6Unorm4Pack16 = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + eR10X6G10X6B10X6A10X6Unorm4Pack16KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR, + eG10X6B10X6G10X6R10X6422Unorm4Pack16 = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR, + eB10X6G10X6R10X6G10X6422Unorm4Pack16 = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR, + eG10X6B10X6R10X63Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + eG10X6B10X6R10X63Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR, + eG10X6B10X6R10X62Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + eG10X6B10X6R10X62Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR, + eG10X6B10X6R10X63Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + eG10X6B10X6R10X63Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR, + eG10X6B10X6R10X62Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + eG10X6B10X6R10X62Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR, + eG10X6B10X6R10X63Plane444Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + eG10X6B10X6R10X63Plane444Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR, + eR12X4UnormPack16 = VK_FORMAT_R12X4_UNORM_PACK16, + eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16_KHR, + eR12X4G12X4Unorm2Pack16 = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR, + eR12X4G12X4B12X4A12X4Unorm4Pack16 = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + eR12X4G12X4B12X4A12X4Unorm4Pack16KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR, + eG12X4B12X4G12X4R12X4422Unorm4Pack16 = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR, + eB12X4G12X4R12X4G12X4422Unorm4Pack16 = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR, + eG12X4B12X4R12X43Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + eG12X4B12X4R12X43Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR, + eG12X4B12X4R12X42Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + eG12X4B12X4R12X42Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR, + eG12X4B12X4R12X43Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + eG12X4B12X4R12X43Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR, + eG12X4B12X4R12X42Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + eG12X4B12X4R12X42Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR, + eG12X4B12X4R12X43Plane444Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + eG12X4B12X4R12X43Plane444Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR, + eG16B16G16R16422Unorm = VK_FORMAT_G16B16G16R16_422_UNORM, + eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM_KHR, + eB16G16R16G16422Unorm = VK_FORMAT_B16G16R16G16_422_UNORM, + eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM_KHR, + eG16B16R163Plane420Unorm = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR, + eG16B16R162Plane420Unorm = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR, + eG16B16R163Plane422Unorm = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR, + eG16B16R162Plane422Unorm = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR, + eG16B16R163Plane444Unorm = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR, + eG8B8R82Plane444Unorm = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, + eG8B8R82Plane444UnormEXT = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT, + eG10X6B10X6R10X62Plane444Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, + eG10X6B10X6R10X62Plane444Unorm3Pack16EXT = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT, + eG12X4B12X4R12X42Plane444Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, + eG12X4B12X4R12X42Plane444Unorm3Pack16EXT = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT, + eG16B16R162Plane444Unorm = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, + eG16B16R162Plane444UnormEXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT, + eA4R4G4B4UnormPack16 = VK_FORMAT_A4R4G4B4_UNORM_PACK16, + eA4R4G4B4UnormPack16EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, + eA4B4G4R4UnormPack16 = VK_FORMAT_A4B4G4R4_UNORM_PACK16, + eA4B4G4R4UnormPack16EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT, + eAstc4x4SfloatBlock = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, + eAstc4x4SfloatBlockEXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT, + eAstc5x4SfloatBlock = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, + eAstc5x4SfloatBlockEXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT, + eAstc5x5SfloatBlock = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, + eAstc5x5SfloatBlockEXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT, + eAstc6x5SfloatBlock = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK, + eAstc6x5SfloatBlockEXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT, + eAstc6x6SfloatBlock = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK, + eAstc6x6SfloatBlockEXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT, + eAstc8x5SfloatBlock = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK, + eAstc8x5SfloatBlockEXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT, + eAstc8x6SfloatBlock = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK, + eAstc8x6SfloatBlockEXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT, + eAstc8x8SfloatBlock = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK, + eAstc8x8SfloatBlockEXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT, + eAstc10x5SfloatBlock = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK, + eAstc10x5SfloatBlockEXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT, + eAstc10x6SfloatBlock = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK, + eAstc10x6SfloatBlockEXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT, + eAstc10x8SfloatBlock = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK, + eAstc10x8SfloatBlockEXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT, + eAstc10x10SfloatBlock = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK, + eAstc10x10SfloatBlockEXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT, + eAstc12x10SfloatBlock = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK, + eAstc12x10SfloatBlockEXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT, + eAstc12x12SfloatBlock = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, + eAstc12x12SfloatBlockEXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT, + eA1B5G5R5UnormPack16 = VK_FORMAT_A1B5G5R5_UNORM_PACK16, + eA1B5G5R5UnormPack16KHR = VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR, + eA8Unorm = VK_FORMAT_A8_UNORM, + eA8UnormKHR = VK_FORMAT_A8_UNORM_KHR, + ePvrtc12BppUnormBlockIMG = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, + ePvrtc14BppUnormBlockIMG = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, + ePvrtc22BppUnormBlockIMG = VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, + ePvrtc24BppUnormBlockIMG = VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, + ePvrtc12BppSrgbBlockIMG = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, + ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, + ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, + ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG, + eAstc3x3x3UnormBlockEXT = VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT, + eAstc3x3x3SrgbBlockEXT = VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT, + eAstc3x3x3SfloatBlockEXT = VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT, + eAstc4x3x3UnormBlockEXT = VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT, + eAstc4x3x3SrgbBlockEXT = VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT, + eAstc4x3x3SfloatBlockEXT = VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT, + eAstc4x4x3UnormBlockEXT = VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT, + eAstc4x4x3SrgbBlockEXT = VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT, + eAstc4x4x3SfloatBlockEXT = VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT, + eAstc4x4x4UnormBlockEXT = VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT, + eAstc4x4x4SrgbBlockEXT = VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT, + eAstc4x4x4SfloatBlockEXT = VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT, + eAstc5x4x4UnormBlockEXT = VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT, + eAstc5x4x4SrgbBlockEXT = VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT, + eAstc5x4x4SfloatBlockEXT = VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT, + eAstc5x5x4UnormBlockEXT = VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT, + eAstc5x5x4SrgbBlockEXT = VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT, + eAstc5x5x4SfloatBlockEXT = VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT, + eAstc5x5x5UnormBlockEXT = VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT, + eAstc5x5x5SrgbBlockEXT = VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT, + eAstc5x5x5SfloatBlockEXT = VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT, + eAstc6x5x5UnormBlockEXT = VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT, + eAstc6x5x5SrgbBlockEXT = VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT, + eAstc6x5x5SfloatBlockEXT = VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT, + eAstc6x6x5UnormBlockEXT = VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT, + eAstc6x6x5SrgbBlockEXT = VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT, + eAstc6x6x5SfloatBlockEXT = VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT, + eAstc6x6x6UnormBlockEXT = VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT, + eAstc6x6x6SrgbBlockEXT = VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT, + eAstc6x6x6SfloatBlockEXT = VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT, + eR8BoolARM = VK_FORMAT_R8_BOOL_ARM, + eR16G16Sfixed5NV = VK_FORMAT_R16G16_SFIXED5_NV, + eR16G16S105NV = VK_FORMAT_R16G16_S10_5_NV, + eR10X6UintPack16ARM = VK_FORMAT_R10X6_UINT_PACK16_ARM, + eR10X6G10X6Uint2Pack16ARM = VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM, + eR10X6G10X6B10X6A10X6Uint4Pack16ARM = VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM, + eR12X4UintPack16ARM = VK_FORMAT_R12X4_UINT_PACK16_ARM, + eR12X4G12X4Uint2Pack16ARM = VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM, + eR12X4G12X4B12X4A12X4Uint4Pack16ARM = VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM, + eR14X2UintPack16ARM = VK_FORMAT_R14X2_UINT_PACK16_ARM, + eR14X2G14X2Uint2Pack16ARM = VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM, + eR14X2G14X2B14X2A14X2Uint4Pack16ARM = VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM, + eR14X2UnormPack16ARM = VK_FORMAT_R14X2_UNORM_PACK16_ARM, + eR14X2G14X2Unorm2Pack16ARM = VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM, + eR14X2G14X2B14X2A14X2Unorm4Pack16ARM = VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM, + eG14X2B14X2R14X22Plane420Unorm3Pack16ARM = VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM, + eG14X2B14X2R14X22Plane422Unorm3Pack16ARM = VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM + }; + + // wrapper class for enum VkFormatFeatureFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlagBits.html + enum class FormatFeatureFlagBits : VkFormatFeatureFlags + { + eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, + eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, + eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, + eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, + eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, + eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, + eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, + eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, + eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, + eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, + eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT, + eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT, + eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, + eTransferSrc = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, + eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR, + eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, + eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR, + eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, + eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR, + eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + eSampledImageYcbcrConversionLinearFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR, + eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + eSampledImageYcbcrConversionSeparateReconstructionFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR, + eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + eSampledImageYcbcrConversionChromaReconstructionExplicitKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR, + eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR, + eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT, + eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT_KHR, + eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, + eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR, + eSampledImageFilterMinmax = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, + eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT, + eVideoDecodeOutputKHR = VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR, + eVideoDecodeDpbKHR = VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR, + eAccelerationStructureVertexBufferKHR = VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR, + eSampledImageFilterCubicEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, + eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, + eFragmentDensityMapEXT = VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT, + eFragmentShadingRateAttachmentKHR = VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + eVideoEncodeInputKHR = VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR, + eVideoEncodeDpbKHR = VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR + }; + + // wrapper using for bitmask VkFormatFeatureFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlags.html + using FormatFeatureFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkFormatFeatureFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR FormatFeatureFlags allFlags = + FormatFeatureFlagBits::eSampledImage | FormatFeatureFlagBits::eStorageImage | FormatFeatureFlagBits::eStorageImageAtomic | + FormatFeatureFlagBits::eUniformTexelBuffer | FormatFeatureFlagBits::eStorageTexelBuffer | FormatFeatureFlagBits::eStorageTexelBufferAtomic | + FormatFeatureFlagBits::eVertexBuffer | FormatFeatureFlagBits::eColorAttachment | FormatFeatureFlagBits::eColorAttachmentBlend | + FormatFeatureFlagBits::eDepthStencilAttachment | FormatFeatureFlagBits::eBlitSrc | FormatFeatureFlagBits::eBlitDst | + FormatFeatureFlagBits::eSampledImageFilterLinear | FormatFeatureFlagBits::eTransferSrc | FormatFeatureFlagBits::eTransferDst | + FormatFeatureFlagBits::eMidpointChromaSamples | FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter | + FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter | + FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit | + FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable | FormatFeatureFlagBits::eDisjoint | + FormatFeatureFlagBits::eCositedChromaSamples | FormatFeatureFlagBits::eSampledImageFilterMinmax | FormatFeatureFlagBits::eVideoDecodeOutputKHR | + FormatFeatureFlagBits::eVideoDecodeDpbKHR | FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR | + FormatFeatureFlagBits::eSampledImageFilterCubicEXT | FormatFeatureFlagBits::eFragmentDensityMapEXT | + FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR | FormatFeatureFlagBits::eVideoEncodeInputKHR | FormatFeatureFlagBits::eVideoEncodeDpbKHR; + }; + + // wrapper class for enum VkImageCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateFlagBits.html + enum class ImageCreateFlagBits : VkImageCreateFlags + { + eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT, + eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, + eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, + eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, + eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, + eAlias = VK_IMAGE_CREATE_ALIAS_BIT, + eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT_KHR, + eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, + eSplitInstanceBindRegionsKHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, + e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, + e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR, + eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, + eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, + eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, + eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR, + eProtected = VK_IMAGE_CREATE_PROTECTED_BIT, + eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT, + eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT_KHR, + eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, + eDescriptorHeapCaptureReplayEXT = VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT, + eDescriptorBufferCaptureReplayEXT = VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, + eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT, + eSubsampledEXT = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, + eMultisampledRenderToSingleSampledEXT = VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT, + e2DViewCompatibleEXT = VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT, + eVideoProfileIndependentKHR = VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, + eFragmentDensityMapOffsetEXT = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT, + eFragmentDensityMapOffsetQCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM + }; + + // wrapper using for bitmask VkImageCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateFlags.html + using ImageCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkImageCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCreateFlags allFlags = + ImageCreateFlagBits::eSparseBinding | ImageCreateFlagBits::eSparseResidency | ImageCreateFlagBits::eSparseAliased | ImageCreateFlagBits::eMutableFormat | + ImageCreateFlagBits::eCubeCompatible | ImageCreateFlagBits::eAlias | ImageCreateFlagBits::eSplitInstanceBindRegions | + ImageCreateFlagBits::e2DArrayCompatible | ImageCreateFlagBits::eBlockTexelViewCompatible | ImageCreateFlagBits::eExtendedUsage | + ImageCreateFlagBits::eProtected | ImageCreateFlagBits::eDisjoint | ImageCreateFlagBits::eCornerSampledNV | + ImageCreateFlagBits::eDescriptorHeapCaptureReplayEXT | ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT | ImageCreateFlagBits::eSubsampledEXT | + ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT | ImageCreateFlagBits::e2DViewCompatibleEXT | + ImageCreateFlagBits::eVideoProfileIndependentKHR | ImageCreateFlagBits::eFragmentDensityMapOffsetEXT; + }; + + // wrapper class for enum VkImageTiling, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageTiling.html + enum class ImageTiling + { + eOptimal = VK_IMAGE_TILING_OPTIMAL, + eLinear = VK_IMAGE_TILING_LINEAR, + eDrmFormatModifierEXT = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT + }; + + // wrapper class for enum VkImageType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageType.html + enum class ImageType + { + e1D = VK_IMAGE_TYPE_1D, + e2D = VK_IMAGE_TYPE_2D, + e3D = VK_IMAGE_TYPE_3D + }; + + // wrapper class for enum VkImageUsageFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageUsageFlagBits.html + enum class ImageUsageFlagBits : VkImageUsageFlags + { + eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, + eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT, + eSampled = VK_IMAGE_USAGE_SAMPLED_BIT, + eStorage = VK_IMAGE_USAGE_STORAGE_BIT, + eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, + eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, + eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, + eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, + eHostTransfer = VK_IMAGE_USAGE_HOST_TRANSFER_BIT, + eHostTransferEXT = VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT, + eVideoDecodeDstKHR = VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, + eVideoDecodeSrcKHR = VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR, + eVideoDecodeDpbKHR = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, + eFragmentDensityMapEXT = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, + eFragmentShadingRateAttachmentKHR = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, + eVideoEncodeDstKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR, + eVideoEncodeSrcKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, + eVideoEncodeDpbKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, + eAttachmentFeedbackLoopEXT = VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, + eInvocationMaskHUAWEI = VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI, + eSampleWeightQCOM = VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM, + eSampleBlockMatchQCOM = VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM, + eTensorAliasingARM = VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM, + eTileMemoryQCOM = VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM, + eVideoEncodeQuantizationDeltaMapKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, + eVideoEncodeEmphasisMapKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR + }; + + // wrapper using for bitmask VkImageUsageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageUsageFlags.html + using ImageUsageFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkImageUsageFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageUsageFlags allFlags = + ImageUsageFlagBits::eTransferSrc | ImageUsageFlagBits::eTransferDst | ImageUsageFlagBits::eSampled | ImageUsageFlagBits::eStorage | + ImageUsageFlagBits::eColorAttachment | ImageUsageFlagBits::eDepthStencilAttachment | ImageUsageFlagBits::eTransientAttachment | + ImageUsageFlagBits::eInputAttachment | ImageUsageFlagBits::eHostTransfer | ImageUsageFlagBits::eVideoDecodeDstKHR | + ImageUsageFlagBits::eVideoDecodeSrcKHR | ImageUsageFlagBits::eVideoDecodeDpbKHR | ImageUsageFlagBits::eFragmentDensityMapEXT | + ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR | ImageUsageFlagBits::eVideoEncodeDstKHR | ImageUsageFlagBits::eVideoEncodeSrcKHR | + ImageUsageFlagBits::eVideoEncodeDpbKHR | ImageUsageFlagBits::eAttachmentFeedbackLoopEXT | ImageUsageFlagBits::eInvocationMaskHUAWEI | + ImageUsageFlagBits::eSampleWeightQCOM | ImageUsageFlagBits::eSampleBlockMatchQCOM | ImageUsageFlagBits::eTensorAliasingARM | + ImageUsageFlagBits::eTileMemoryQCOM | ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR | ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR; + }; + + // wrapper class for enum VkInstanceCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstanceCreateFlagBits.html + enum class InstanceCreateFlagBits : VkInstanceCreateFlags + { + eEnumeratePortabilityKHR = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR + }; + + // wrapper using for bitmask VkInstanceCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstanceCreateFlags.html + using InstanceCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkInstanceCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR InstanceCreateFlags allFlags = InstanceCreateFlagBits::eEnumeratePortabilityKHR; + }; + + // wrapper class for enum VkInternalAllocationType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInternalAllocationType.html + enum class InternalAllocationType + { + eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + }; + + // wrapper class for enum VkMemoryHeapFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryHeapFlagBits.html + enum class MemoryHeapFlagBits : VkMemoryHeapFlags + { + eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, + eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, + eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR, + eTileMemoryQCOM = VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM + }; + + // wrapper using for bitmask VkMemoryHeapFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryHeapFlags.html + using MemoryHeapFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkMemoryHeapFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryHeapFlags allFlags = + MemoryHeapFlagBits::eDeviceLocal | MemoryHeapFlagBits::eMultiInstance | MemoryHeapFlagBits::eTileMemoryQCOM; + }; + + // wrapper class for enum VkMemoryPropertyFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryPropertyFlagBits.html + enum class MemoryPropertyFlagBits : VkMemoryPropertyFlags + { + eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, + eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT, + eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, + eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT, + eDeviceCoherentAMD = VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD, + eDeviceUncachedAMD = VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD, + eRdmaCapableNV = VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV + }; + + // wrapper using for bitmask VkMemoryPropertyFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryPropertyFlags.html + using MemoryPropertyFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkMemoryPropertyFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryPropertyFlags allFlags = + MemoryPropertyFlagBits::eDeviceLocal | MemoryPropertyFlagBits::eHostVisible | MemoryPropertyFlagBits::eHostCoherent | + MemoryPropertyFlagBits::eHostCached | MemoryPropertyFlagBits::eLazilyAllocated | MemoryPropertyFlagBits::eProtected | + MemoryPropertyFlagBits::eDeviceCoherentAMD | MemoryPropertyFlagBits::eDeviceUncachedAMD | MemoryPropertyFlagBits::eRdmaCapableNV; + }; + + // wrapper class for enum VkPhysicalDeviceType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceType.html + enum class PhysicalDeviceType + { + eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER, + eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, + eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, + eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU, + eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU + }; + + // wrapper class for enum VkQueueFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFlagBits.html + enum class QueueFlagBits : VkQueueFlags + { + eGraphics = VK_QUEUE_GRAPHICS_BIT, + eCompute = VK_QUEUE_COMPUTE_BIT, + eTransfer = VK_QUEUE_TRANSFER_BIT, + eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT, + eProtected = VK_QUEUE_PROTECTED_BIT, + eVideoDecodeKHR = VK_QUEUE_VIDEO_DECODE_BIT_KHR, + eVideoEncodeKHR = VK_QUEUE_VIDEO_ENCODE_BIT_KHR, + eOpticalFlowNV = VK_QUEUE_OPTICAL_FLOW_BIT_NV, + eDataGraphARM = VK_QUEUE_DATA_GRAPH_BIT_ARM + }; + + // wrapper using for bitmask VkQueueFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFlags.html + using QueueFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkQueueFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR QueueFlags allFlags = QueueFlagBits::eGraphics | QueueFlagBits::eCompute | QueueFlagBits::eTransfer | + QueueFlagBits::eSparseBinding | QueueFlagBits::eProtected | QueueFlagBits::eVideoDecodeKHR | + QueueFlagBits::eVideoEncodeKHR | QueueFlagBits::eOpticalFlowNV | QueueFlagBits::eDataGraphARM; + }; + + // wrapper class for enum VkSampleCountFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleCountFlagBits.html + enum class SampleCountFlagBits : VkSampleCountFlags + { + e1 = VK_SAMPLE_COUNT_1_BIT, + e2 = VK_SAMPLE_COUNT_2_BIT, + e4 = VK_SAMPLE_COUNT_4_BIT, + e8 = VK_SAMPLE_COUNT_8_BIT, + e16 = VK_SAMPLE_COUNT_16_BIT, + e32 = VK_SAMPLE_COUNT_32_BIT, + e64 = VK_SAMPLE_COUNT_64_BIT + }; + + // wrapper using for bitmask VkSampleCountFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleCountFlags.html + using SampleCountFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkSampleCountFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SampleCountFlags allFlags = SampleCountFlagBits::e1 | SampleCountFlagBits::e2 | SampleCountFlagBits::e4 | + SampleCountFlagBits::e8 | SampleCountFlagBits::e16 | SampleCountFlagBits::e32 | + SampleCountFlagBits::e64; + }; + + // wrapper class for enum VkSystemAllocationScope, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSystemAllocationScope.html + enum class SystemAllocationScope + { + eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, + eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, + eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE, + eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE, + eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE + }; + + enum class DeviceCreateFlagBits : VkDeviceCreateFlags + { + }; + + // wrapper using for bitmask VkDeviceCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceCreateFlags.html + using DeviceCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceCreateFlags allFlags = {}; + }; + + // wrapper class for enum VkDeviceQueueCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueCreateFlagBits.html + enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags + { + eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT, + eInternallySynchronizedKHR = VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR + }; + + // wrapper using for bitmask VkDeviceQueueCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueCreateFlags.html + using DeviceQueueCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDeviceQueueCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceQueueCreateFlags allFlags = + DeviceQueueCreateFlagBits::eProtected | DeviceQueueCreateFlagBits::eInternallySynchronizedKHR; + }; + + // wrapper class for enum VkPipelineStageFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlagBits.html + enum class PipelineStageFlagBits : VkPipelineStageFlags + { + eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, + eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, + eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, + eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, + eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, + eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, + eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, + eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, + eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, + eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, + eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT, + eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, + eHost = VK_PIPELINE_STAGE_HOST_BIT, + eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, + eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + eNone = VK_PIPELINE_STAGE_NONE, + eNoneKHR = VK_PIPELINE_STAGE_NONE_KHR, + eTransformFeedbackEXT = VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT, + eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT, + eAccelerationStructureBuildKHR = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, + eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV, + eRayTracingShaderKHR = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, + eRayTracingShaderNV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV, + eFragmentDensityProcessEXT = VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT, + eFragmentShadingRateAttachmentKHR = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV, + eTaskShaderEXT = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, + eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, + eMeshShaderEXT = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, + eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, + eCommandPreprocessEXT = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT, + eCommandPreprocessNV = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV + }; + + // wrapper using for bitmask VkPipelineStageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlags.html + using PipelineStageFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPipelineStageFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineStageFlags allFlags = + PipelineStageFlagBits::eTopOfPipe | PipelineStageFlagBits::eDrawIndirect | PipelineStageFlagBits::eVertexInput | PipelineStageFlagBits::eVertexShader | + PipelineStageFlagBits::eTessellationControlShader | PipelineStageFlagBits::eTessellationEvaluationShader | PipelineStageFlagBits::eGeometryShader | + PipelineStageFlagBits::eFragmentShader | PipelineStageFlagBits::eEarlyFragmentTests | PipelineStageFlagBits::eLateFragmentTests | + PipelineStageFlagBits::eColorAttachmentOutput | PipelineStageFlagBits::eComputeShader | PipelineStageFlagBits::eTransfer | + PipelineStageFlagBits::eBottomOfPipe | PipelineStageFlagBits::eHost | PipelineStageFlagBits::eAllGraphics | PipelineStageFlagBits::eAllCommands | + PipelineStageFlagBits::eNone | PipelineStageFlagBits::eTransformFeedbackEXT | PipelineStageFlagBits::eConditionalRenderingEXT | + PipelineStageFlagBits::eAccelerationStructureBuildKHR | PipelineStageFlagBits::eRayTracingShaderKHR | PipelineStageFlagBits::eFragmentDensityProcessEXT | + PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR | PipelineStageFlagBits::eTaskShaderEXT | PipelineStageFlagBits::eMeshShaderEXT | + PipelineStageFlagBits::eCommandPreprocessEXT; + }; + + // wrapper class for enum VkMemoryMapFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMapFlagBits.html + enum class MemoryMapFlagBits : VkMemoryMapFlags + { + ePlacedEXT = VK_MEMORY_MAP_PLACED_BIT_EXT + }; + + // wrapper using for bitmask VkMemoryMapFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMapFlags.html + using MemoryMapFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkMemoryMapFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryMapFlags allFlags = MemoryMapFlagBits::ePlacedEXT; + }; + + // wrapper class for enum VkImageAspectFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageAspectFlagBits.html + enum class ImageAspectFlagBits : VkImageAspectFlags + { + eColor = VK_IMAGE_ASPECT_COLOR_BIT, + eDepth = VK_IMAGE_ASPECT_DEPTH_BIT, + eStencil = VK_IMAGE_ASPECT_STENCIL_BIT, + eMetadata = VK_IMAGE_ASPECT_METADATA_BIT, + ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT, + ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR, + ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT, + ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR, + ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT, + ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR, + eNone = VK_IMAGE_ASPECT_NONE, + eNoneKHR = VK_IMAGE_ASPECT_NONE_KHR, + eMemoryPlane0EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT, + eMemoryPlane1EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT, + eMemoryPlane2EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT, + eMemoryPlane3EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT + }; + + // wrapper using for bitmask VkImageAspectFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageAspectFlags.html + using ImageAspectFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkImageAspectFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageAspectFlags allFlags = ImageAspectFlagBits::eColor | ImageAspectFlagBits::eDepth | ImageAspectFlagBits::eStencil | + ImageAspectFlagBits::eMetadata | ImageAspectFlagBits::ePlane0 | + ImageAspectFlagBits::ePlane1 | ImageAspectFlagBits::ePlane2 | ImageAspectFlagBits::eNone | + ImageAspectFlagBits::eMemoryPlane0EXT | ImageAspectFlagBits::eMemoryPlane1EXT | + ImageAspectFlagBits::eMemoryPlane2EXT | ImageAspectFlagBits::eMemoryPlane3EXT; + }; + + // wrapper class for enum VkSparseImageFormatFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageFormatFlagBits.html + enum class SparseImageFormatFlagBits : VkSparseImageFormatFlags + { + eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, + eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT, + eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT + }; + + // wrapper using for bitmask VkSparseImageFormatFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageFormatFlags.html + using SparseImageFormatFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkSparseImageFormatFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SparseImageFormatFlags allFlags = + SparseImageFormatFlagBits::eSingleMiptail | SparseImageFormatFlagBits::eAlignedMipSize | SparseImageFormatFlagBits::eNonstandardBlockSize; + }; + + // wrapper class for enum VkSparseMemoryBindFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseMemoryBindFlagBits.html + enum class SparseMemoryBindFlagBits : VkSparseMemoryBindFlags + { + eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT + }; + + // wrapper using for bitmask VkSparseMemoryBindFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseMemoryBindFlags.html + using SparseMemoryBindFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkSparseMemoryBindFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SparseMemoryBindFlags allFlags = SparseMemoryBindFlagBits::eMetadata; + }; + + // wrapper class for enum VkFenceCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceCreateFlagBits.html + enum class FenceCreateFlagBits : VkFenceCreateFlags + { + eSignaled = VK_FENCE_CREATE_SIGNALED_BIT + }; + + // wrapper using for bitmask VkFenceCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceCreateFlags.html + using FenceCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkFenceCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR FenceCreateFlags allFlags = FenceCreateFlagBits::eSignaled; + }; + + enum class SemaphoreCreateFlagBits : VkSemaphoreCreateFlags + { + }; + + // wrapper using for bitmask VkSemaphoreCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreCreateFlags.html + using SemaphoreCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreCreateFlags allFlags = {}; + }; + + // wrapper class for enum VkQueryPoolCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolCreateFlagBits.html + enum class QueryPoolCreateFlagBits : VkQueryPoolCreateFlags + { + eResetKHR = VK_QUERY_POOL_CREATE_RESET_BIT_KHR + }; + + // wrapper using for bitmask VkQueryPoolCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolCreateFlags.html + using QueryPoolCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkQueryPoolCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR QueryPoolCreateFlags allFlags = QueryPoolCreateFlagBits::eResetKHR; + }; + + // wrapper class for enum VkQueryResultFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryResultFlagBits.html + enum class QueryResultFlagBits : VkQueryResultFlags + { + e64 = VK_QUERY_RESULT_64_BIT, + eWait = VK_QUERY_RESULT_WAIT_BIT, + eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, + ePartial = VK_QUERY_RESULT_PARTIAL_BIT, + eWithStatusKHR = VK_QUERY_RESULT_WITH_STATUS_BIT_KHR + }; + + // wrapper using for bitmask VkQueryResultFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryResultFlags.html + using QueryResultFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkQueryResultFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR QueryResultFlags allFlags = QueryResultFlagBits::e64 | QueryResultFlagBits::eWait | + QueryResultFlagBits::eWithAvailability | QueryResultFlagBits::ePartial | + QueryResultFlagBits::eWithStatusKHR; + }; + + // wrapper class for enum VkQueryType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryType.html + enum class QueryType + { + eOcclusion = VK_QUERY_TYPE_OCCLUSION, + ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS, + eTimestamp = VK_QUERY_TYPE_TIMESTAMP, + eResultStatusOnlyKHR = VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR, + eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT, + ePerformanceQueryKHR = VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, + eAccelerationStructureCompactedSizeKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR, + eAccelerationStructureSerializationSizeKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR, + eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV, + ePerformanceQueryINTEL = VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL, + eVideoEncodeFeedbackKHR = VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR, + eMeshPrimitivesGeneratedEXT = VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT, + ePrimitivesGeneratedEXT = VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT, + eAccelerationStructureSerializationBottomLevelPointersKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR, + eAccelerationStructureSizeKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR, + eMicromapSerializationSizeEXT = VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT, + eMicromapCompactedSizeEXT = VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT + }; + + // wrapper class for enum VkBufferCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCreateFlagBits.html + enum class BufferCreateFlagBits : VkBufferCreateFlags + { + eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT, + eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, + eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, + eProtected = VK_BUFFER_CREATE_PROTECTED_BIT, + eDeviceAddressCaptureReplay = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + eDeviceAddressCaptureReplayEXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT, + eDeviceAddressCaptureReplayKHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, + eDescriptorBufferCaptureReplayEXT = VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, + eVideoProfileIndependentKHR = VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR + }; + + // wrapper using for bitmask VkBufferCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCreateFlags.html + using BufferCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkBufferCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR BufferCreateFlags allFlags = + BufferCreateFlagBits::eSparseBinding | BufferCreateFlagBits::eSparseResidency | BufferCreateFlagBits::eSparseAliased | BufferCreateFlagBits::eProtected | + BufferCreateFlagBits::eDeviceAddressCaptureReplay | BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT | + BufferCreateFlagBits::eVideoProfileIndependentKHR; + }; + + // wrapper class for enum VkBufferUsageFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlagBits.html + enum class BufferUsageFlagBits : VkBufferUsageFlags + { + eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT, + eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, + eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, + eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, + eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, + eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT, + eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, + eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, + eShaderDeviceAddress = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + eShaderDeviceAddressEXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT, + eShaderDeviceAddressKHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR, + eVideoDecodeSrcKHR = VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR, + eVideoDecodeDstKHR = VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR, + eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT, + eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, + eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eExecutionGraphScratchAMDX = VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eDescriptorHeapEXT = VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT, + eAccelerationStructureBuildInputReadOnlyKHR = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR, + eAccelerationStructureStorageKHR = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR, + eShaderBindingTableKHR = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, + eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV, + eVideoEncodeDstKHR = VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR, + eVideoEncodeSrcKHR = VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, + eSamplerDescriptorBufferEXT = VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT, + eResourceDescriptorBufferEXT = VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT, + ePushDescriptorsDescriptorBufferEXT = VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, + eMicromapBuildInputReadOnlyEXT = VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, + eMicromapStorageEXT = VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT, + eTileMemoryQCOM = VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM + }; + + // wrapper using for bitmask VkBufferUsageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlags.html + using BufferUsageFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkBufferUsageFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR BufferUsageFlags allFlags = + BufferUsageFlagBits::eTransferSrc | BufferUsageFlagBits::eTransferDst | BufferUsageFlagBits::eUniformTexelBuffer | + BufferUsageFlagBits::eStorageTexelBuffer | BufferUsageFlagBits::eUniformBuffer | BufferUsageFlagBits::eStorageBuffer | BufferUsageFlagBits::eIndexBuffer | + BufferUsageFlagBits::eVertexBuffer | BufferUsageFlagBits::eIndirectBuffer | BufferUsageFlagBits::eShaderDeviceAddress | + BufferUsageFlagBits::eVideoDecodeSrcKHR | BufferUsageFlagBits::eVideoDecodeDstKHR | BufferUsageFlagBits::eTransformFeedbackBufferEXT | + BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT | BufferUsageFlagBits::eConditionalRenderingEXT +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | BufferUsageFlagBits::eExecutionGraphScratchAMDX +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | BufferUsageFlagBits::eDescriptorHeapEXT | BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR | + BufferUsageFlagBits::eAccelerationStructureStorageKHR | BufferUsageFlagBits::eShaderBindingTableKHR | BufferUsageFlagBits::eVideoEncodeDstKHR | + BufferUsageFlagBits::eVideoEncodeSrcKHR | BufferUsageFlagBits::eSamplerDescriptorBufferEXT | BufferUsageFlagBits::eResourceDescriptorBufferEXT | + BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT | BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT | + BufferUsageFlagBits::eMicromapStorageEXT | BufferUsageFlagBits::eTileMemoryQCOM; + }; + + // wrapper class for enum VkSharingMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSharingMode.html + enum class SharingMode + { + eExclusive = VK_SHARING_MODE_EXCLUSIVE, + eConcurrent = VK_SHARING_MODE_CONCURRENT + }; + + // wrapper class for enum VkImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageLayout.html + enum class ImageLayout + { + eUndefined = VK_IMAGE_LAYOUT_UNDEFINED, + eGeneral = VK_IMAGE_LAYOUT_GENERAL, + eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, + eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, + eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED, + eDepthReadOnlyStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, + eDepthReadOnlyStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR, + eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR, + eDepthAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, + eDepthAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR, + eDepthReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, + eDepthReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR, + eStencilAttachmentOptimal = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, + eStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR, + eStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, + eStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR, + eReadOnlyOptimal = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, + eReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR, + eAttachmentOptimal = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, + eAttachmentOptimalKHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR, + eRenderingLocalRead = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ, + eRenderingLocalReadKHR = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR, + ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, + eVideoDecodeDstKHR = VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR, + eVideoDecodeSrcKHR = VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR, + eVideoDecodeDpbKHR = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR, + eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, + eFragmentDensityMapOptimalEXT = VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT, + eFragmentShadingRateAttachmentOptimalKHR = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, + eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV, + eVideoEncodeDstKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR, + eVideoEncodeSrcKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR, + eVideoEncodeDpbKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR, + eAttachmentFeedbackLoopOptimalEXT = VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT, + eTensorAliasingARM = VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM, + eVideoEncodeQuantizationMapKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR, + eZeroInitializedEXT = VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT + }; + + // wrapper class for enum VkComponentSwizzle, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkComponentSwizzle.html + enum class ComponentSwizzle + { + eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY, + eZero = VK_COMPONENT_SWIZZLE_ZERO, + eOne = VK_COMPONENT_SWIZZLE_ONE, + eR = VK_COMPONENT_SWIZZLE_R, + eG = VK_COMPONENT_SWIZZLE_G, + eB = VK_COMPONENT_SWIZZLE_B, + eA = VK_COMPONENT_SWIZZLE_A + }; + + // wrapper class for enum VkImageViewCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewCreateFlagBits.html + enum class ImageViewCreateFlagBits : VkImageViewCreateFlags + { + eFragmentDensityMapDynamicEXT = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT, + eDescriptorBufferCaptureReplayEXT = VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, + eFragmentDensityMapDeferredEXT = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT + }; + + // wrapper using for bitmask VkImageViewCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewCreateFlags.html + using ImageViewCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkImageViewCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageViewCreateFlags allFlags = ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT | + ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT | + ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT; + }; + + // wrapper class for enum VkImageViewType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewType.html + enum class ImageViewType + { + e1D = VK_IMAGE_VIEW_TYPE_1D, + e2D = VK_IMAGE_VIEW_TYPE_2D, + e3D = VK_IMAGE_VIEW_TYPE_3D, + eCube = VK_IMAGE_VIEW_TYPE_CUBE, + e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY, + e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY, + eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY + }; + + // wrapper class for enum VkAccessFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits.html + enum class AccessFlagBits : VkAccessFlags + { + eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, + eIndexRead = VK_ACCESS_INDEX_READ_BIT, + eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, + eUniformRead = VK_ACCESS_UNIFORM_READ_BIT, + eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, + eShaderRead = VK_ACCESS_SHADER_READ_BIT, + eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT, + eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, + eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, + eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, + eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, + eTransferRead = VK_ACCESS_TRANSFER_READ_BIT, + eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT, + eHostRead = VK_ACCESS_HOST_READ_BIT, + eHostWrite = VK_ACCESS_HOST_WRITE_BIT, + eMemoryRead = VK_ACCESS_MEMORY_READ_BIT, + eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT, + eNone = VK_ACCESS_NONE, + eNoneKHR = VK_ACCESS_NONE_KHR, + eTransformFeedbackWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, + eTransformFeedbackCounterReadEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, + eTransformFeedbackCounterWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, + eConditionalRenderingReadEXT = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT, + eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, + eAccelerationStructureReadKHR = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, + eAccelerationStructureReadNV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV, + eAccelerationStructureWriteKHR = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, + eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV, + eFragmentDensityMapReadEXT = VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, + eFragmentShadingRateAttachmentReadKHR = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, + eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV, + eCommandPreprocessReadEXT = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT, + eCommandPreprocessReadNV = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV, + eCommandPreprocessWriteEXT = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT, + eCommandPreprocessWriteNV = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV + }; + + // wrapper using for bitmask VkAccessFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlags.html + using AccessFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkAccessFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags allFlags = + AccessFlagBits::eIndirectCommandRead | AccessFlagBits::eIndexRead | AccessFlagBits::eVertexAttributeRead | AccessFlagBits::eUniformRead | + AccessFlagBits::eInputAttachmentRead | AccessFlagBits::eShaderRead | AccessFlagBits::eShaderWrite | AccessFlagBits::eColorAttachmentRead | + AccessFlagBits::eColorAttachmentWrite | AccessFlagBits::eDepthStencilAttachmentRead | AccessFlagBits::eDepthStencilAttachmentWrite | + AccessFlagBits::eTransferRead | AccessFlagBits::eTransferWrite | AccessFlagBits::eHostRead | AccessFlagBits::eHostWrite | AccessFlagBits::eMemoryRead | + AccessFlagBits::eMemoryWrite | AccessFlagBits::eNone | AccessFlagBits::eTransformFeedbackWriteEXT | AccessFlagBits::eTransformFeedbackCounterReadEXT | + AccessFlagBits::eTransformFeedbackCounterWriteEXT | AccessFlagBits::eConditionalRenderingReadEXT | AccessFlagBits::eColorAttachmentReadNoncoherentEXT | + AccessFlagBits::eAccelerationStructureReadKHR | AccessFlagBits::eAccelerationStructureWriteKHR | AccessFlagBits::eFragmentDensityMapReadEXT | + AccessFlagBits::eFragmentShadingRateAttachmentReadKHR | AccessFlagBits::eCommandPreprocessReadEXT | AccessFlagBits::eCommandPreprocessWriteEXT; + }; + + // wrapper class for enum VkDependencyFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDependencyFlagBits.html + enum class DependencyFlagBits : VkDependencyFlags + { + eByRegion = VK_DEPENDENCY_BY_REGION_BIT, + eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT, + eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR, + eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT, + eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR, + eFeedbackLoopEXT = VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT, + eQueueFamilyOwnershipTransferUseAllStagesKHR = VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR, + eAsymmetricEventKHR = VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR + }; + + // wrapper using for bitmask VkDependencyFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDependencyFlags.html + using DependencyFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDependencyFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DependencyFlags allFlags = + DependencyFlagBits::eByRegion | DependencyFlagBits::eDeviceGroup | DependencyFlagBits::eViewLocal | DependencyFlagBits::eFeedbackLoopEXT | + DependencyFlagBits::eQueueFamilyOwnershipTransferUseAllStagesKHR | DependencyFlagBits::eAsymmetricEventKHR; + }; + + // wrapper class for enum VkCommandPoolCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolCreateFlagBits.html + enum class CommandPoolCreateFlagBits : VkCommandPoolCreateFlags + { + eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, + eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, + eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT + }; + + // wrapper using for bitmask VkCommandPoolCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolCreateFlags.html + using CommandPoolCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkCommandPoolCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolCreateFlags allFlags = + CommandPoolCreateFlagBits::eTransient | CommandPoolCreateFlagBits::eResetCommandBuffer | CommandPoolCreateFlagBits::eProtected; + }; + + // wrapper class for enum VkCommandPoolResetFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolResetFlagBits.html + enum class CommandPoolResetFlagBits : VkCommandPoolResetFlags + { + eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT + }; + + // wrapper using for bitmask VkCommandPoolResetFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolResetFlags.html + using CommandPoolResetFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkCommandPoolResetFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolResetFlags allFlags = CommandPoolResetFlagBits::eReleaseResources; + }; + + // wrapper class for enum VkCommandBufferLevel, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferLevel.html + enum class CommandBufferLevel + { + ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY, + eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY + }; + + // wrapper class for enum VkCommandBufferResetFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferResetFlagBits.html + enum class CommandBufferResetFlagBits : VkCommandBufferResetFlags + { + eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT + }; + + // wrapper using for bitmask VkCommandBufferResetFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferResetFlags.html + using CommandBufferResetFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkCommandBufferResetFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CommandBufferResetFlags allFlags = CommandBufferResetFlagBits::eReleaseResources; + }; + + // wrapper class for enum VkCommandBufferUsageFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferUsageFlagBits.html + enum class CommandBufferUsageFlagBits : VkCommandBufferUsageFlags + { + eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, + eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, + eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT + }; + + // wrapper using for bitmask VkCommandBufferUsageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferUsageFlags.html + using CommandBufferUsageFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkCommandBufferUsageFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CommandBufferUsageFlags allFlags = + CommandBufferUsageFlagBits::eOneTimeSubmit | CommandBufferUsageFlagBits::eRenderPassContinue | CommandBufferUsageFlagBits::eSimultaneousUse; + }; + + // wrapper class for enum VkQueryControlFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryControlFlagBits.html + enum class QueryControlFlagBits : VkQueryControlFlags + { + ePrecise = VK_QUERY_CONTROL_PRECISE_BIT + }; + + // wrapper using for bitmask VkQueryControlFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryControlFlags.html + using QueryControlFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkQueryControlFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR QueryControlFlags allFlags = QueryControlFlagBits::ePrecise; + }; + + // wrapper class for enum VkIndexType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndexType.html + enum class IndexType + { + eUint16 = VK_INDEX_TYPE_UINT16, + eUint32 = VK_INDEX_TYPE_UINT32, + eUint8 = VK_INDEX_TYPE_UINT8, + eUint8EXT = VK_INDEX_TYPE_UINT8_EXT, + eUint8KHR = VK_INDEX_TYPE_UINT8_KHR, + eNoneKHR = VK_INDEX_TYPE_NONE_KHR, + eNoneNV = VK_INDEX_TYPE_NONE_NV + }; + + //========================= + //=== Index Type Traits === + //========================= + + template + struct IndexTypeValue + { + }; + + template <> + struct IndexTypeValue + { + static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint16; + }; + + template <> + struct CppType + { + using Type = uint16_t; + }; + + template <> + struct IndexTypeValue + { + static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint32; + }; + + template <> + struct CppType + { + using Type = uint32_t; + }; + + template <> + struct IndexTypeValue + { + static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint8; + }; + + template <> + struct CppType + { + using Type = uint8_t; + }; + + // wrapper class for enum VkPipelineCacheHeaderVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersion.html + enum class PipelineCacheHeaderVersion + { + eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, + eDataGraphQCOM = VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM + }; + + // wrapper class for enum VkEventCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEventCreateFlagBits.html + enum class EventCreateFlagBits : VkEventCreateFlags + { + eDeviceOnly = VK_EVENT_CREATE_DEVICE_ONLY_BIT, + eDeviceOnlyKHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR + }; + + // wrapper using for bitmask VkEventCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEventCreateFlags.html + using EventCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkEventCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR EventCreateFlags allFlags = EventCreateFlagBits::eDeviceOnly; + }; + + enum class BufferViewCreateFlagBits : VkBufferViewCreateFlags + { + }; + + // wrapper using for bitmask VkBufferViewCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferViewCreateFlags.html + using BufferViewCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR BufferViewCreateFlags allFlags = {}; + }; + + enum class ShaderModuleCreateFlagBits : VkShaderModuleCreateFlags + { + }; + + // wrapper using for bitmask VkShaderModuleCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleCreateFlags.html + using ShaderModuleCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderModuleCreateFlags allFlags = {}; + }; + + // wrapper class for enum VkPipelineCacheCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheCreateFlagBits.html + enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags + { + eExternallySynchronized = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, + eExternallySynchronizedEXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT, + eInternallySynchronizedMergeKHR = VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR + }; + + // wrapper using for bitmask VkPipelineCacheCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheCreateFlags.html + using PipelineCacheCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPipelineCacheCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags = + PipelineCacheCreateFlagBits::eExternallySynchronized | PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR; + }; + + // wrapper class for enum VkPipelineCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlagBits.html + enum class PipelineCreateFlagBits : VkPipelineCreateFlags + { + eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, + eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, + eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT, + eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR, + eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR, + eFailOnPipelineCompileRequired = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, + eFailOnPipelineCompileRequiredEXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT, + eEarlyReturnOnFailure = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, + eEarlyReturnOnFailureEXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT, + eNoProtectedAccess = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, + eNoProtectedAccessEXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT, + eProtectedAccessOnly = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, + eProtectedAccessOnlyEXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT, + eRayTracingNoNullAnyHitShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, + eRayTracingNoNullClosestHitShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, + eRayTracingNoNullMissShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR, + eRayTracingNoNullIntersectionShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, + eRayTracingSkipTrianglesKHR = VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR, + eRayTracingSkipAabbsKHR = VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR, + eRayTracingShaderGroupHandleCaptureReplayKHR = VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR, + eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV, + eRenderingFragmentDensityMapAttachmentEXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, + eVkPipelineRasterizationStateCreateFragmentDensityMapAttachmentEXT = VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, + eRenderingFragmentShadingRateAttachmentKHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + eVkPipelineRasterizationStateCreateFragmentShadingRateAttachmentKHR = VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + eCaptureStatisticsKHR = VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR, + eCaptureInternalRepresentationsKHR = VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, + eIndirectBindableNV = VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV, + eLibraryKHR = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR, + eDescriptorBufferEXT = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, + eRetainLinkTimeOptimizationInfoEXT = VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT, + eLinkTimeOptimizationEXT = VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT, + eRayTracingAllowMotionNV = VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV, + eColorAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, + eDepthStencilAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, + eRayTracingOpacityMicromapEXT = VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eRayTracingDisplacementMicromapNV = VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + }; + + // wrapper using for bitmask VkPipelineCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlags.html + using PipelineCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPipelineCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreateFlags allFlags = + PipelineCreateFlagBits::eDisableOptimization | PipelineCreateFlagBits::eAllowDerivatives | PipelineCreateFlagBits::eDerivative | + PipelineCreateFlagBits::eDispatchBase | PipelineCreateFlagBits::eViewIndexFromDeviceIndex | PipelineCreateFlagBits::eFailOnPipelineCompileRequired | + PipelineCreateFlagBits::eEarlyReturnOnFailure | PipelineCreateFlagBits::eNoProtectedAccess | PipelineCreateFlagBits::eProtectedAccessOnly | + PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR | PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR | + PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR | PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR | + PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR | PipelineCreateFlagBits::eRayTracingSkipAabbsKHR | + PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR | PipelineCreateFlagBits::eDeferCompileNV | + PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT | PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR | + PipelineCreateFlagBits::eCaptureStatisticsKHR | PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR | PipelineCreateFlagBits::eIndirectBindableNV | + PipelineCreateFlagBits::eLibraryKHR | PipelineCreateFlagBits::eDescriptorBufferEXT | PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT | + PipelineCreateFlagBits::eLinkTimeOptimizationEXT | PipelineCreateFlagBits::eRayTracingAllowMotionNV | + PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT | + PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ; + }; + + // wrapper class for enum VkPipelineShaderStageCreateFlagBits, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageCreateFlagBits.html + enum class PipelineShaderStageCreateFlagBits : VkPipelineShaderStageCreateFlags + { + eAllowVaryingSubgroupSize = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, + eAllowVaryingSubgroupSizeEXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, + eRequireFullSubgroups = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, + eRequireFullSubgroupsEXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT + }; + + // wrapper using for bitmask VkPipelineShaderStageCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageCreateFlags.html + using PipelineShaderStageCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPipelineShaderStageCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineShaderStageCreateFlags allFlags = + PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize | PipelineShaderStageCreateFlagBits::eRequireFullSubgroups; + }; + + // wrapper class for enum VkShaderStageFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderStageFlagBits.html + enum class ShaderStageFlagBits : VkShaderStageFlags + { + eVertex = VK_SHADER_STAGE_VERTEX_BIT, + eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, + eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, + eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT, + eFragment = VK_SHADER_STAGE_FRAGMENT_BIT, + eCompute = VK_SHADER_STAGE_COMPUTE_BIT, + eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS, + eAll = VK_SHADER_STAGE_ALL, + eRaygenKHR = VK_SHADER_STAGE_RAYGEN_BIT_KHR, + eRaygenNV = VK_SHADER_STAGE_RAYGEN_BIT_NV, + eAnyHitKHR = VK_SHADER_STAGE_ANY_HIT_BIT_KHR, + eAnyHitNV = VK_SHADER_STAGE_ANY_HIT_BIT_NV, + eClosestHitKHR = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, + eClosestHitNV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV, + eMissKHR = VK_SHADER_STAGE_MISS_BIT_KHR, + eMissNV = VK_SHADER_STAGE_MISS_BIT_NV, + eIntersectionKHR = VK_SHADER_STAGE_INTERSECTION_BIT_KHR, + eIntersectionNV = VK_SHADER_STAGE_INTERSECTION_BIT_NV, + eCallableKHR = VK_SHADER_STAGE_CALLABLE_BIT_KHR, + eCallableNV = VK_SHADER_STAGE_CALLABLE_BIT_NV, + eTaskEXT = VK_SHADER_STAGE_TASK_BIT_EXT, + eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV, + eMeshEXT = VK_SHADER_STAGE_MESH_BIT_EXT, + eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV, + eSubpassShadingHUAWEI = VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI, + eClusterCullingHUAWEI = VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI + }; + + // wrapper using for bitmask VkShaderStageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderStageFlags.html + using ShaderStageFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkShaderStageFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderStageFlags allFlags = + ShaderStageFlagBits::eVertex | ShaderStageFlagBits::eTessellationControl | ShaderStageFlagBits::eTessellationEvaluation | ShaderStageFlagBits::eGeometry | + ShaderStageFlagBits::eFragment | ShaderStageFlagBits::eCompute | ShaderStageFlagBits::eAllGraphics | ShaderStageFlagBits::eAll | + ShaderStageFlagBits::eRaygenKHR | ShaderStageFlagBits::eAnyHitKHR | ShaderStageFlagBits::eClosestHitKHR | ShaderStageFlagBits::eMissKHR | + ShaderStageFlagBits::eIntersectionKHR | ShaderStageFlagBits::eCallableKHR | ShaderStageFlagBits::eTaskEXT | ShaderStageFlagBits::eMeshEXT | + ShaderStageFlagBits::eSubpassShadingHUAWEI | ShaderStageFlagBits::eClusterCullingHUAWEI; + }; + + // wrapper class for enum VkPipelineLayoutCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlagBits.html + enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags + { + eIndependentSetsEXT = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT + }; + + // wrapper using for bitmask VkPipelineLayoutCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlags.html + using PipelineLayoutCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPipelineLayoutCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = PipelineLayoutCreateFlagBits::eIndependentSetsEXT; + }; + + // wrapper class for enum VkBorderColor, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBorderColor.html + enum class BorderColor + { + eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, + eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, + eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK, + eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK, + eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, + eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE, + eFloatCustomEXT = VK_BORDER_COLOR_FLOAT_CUSTOM_EXT, + eIntCustomEXT = VK_BORDER_COLOR_INT_CUSTOM_EXT + }; + + // wrapper class for enum VkFilter, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFilter.html + enum class Filter + { + eNearest = VK_FILTER_NEAREST, + eLinear = VK_FILTER_LINEAR, + eCubicEXT = VK_FILTER_CUBIC_EXT, + eCubicIMG = VK_FILTER_CUBIC_IMG + }; + + // wrapper class for enum VkSamplerAddressMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerAddressMode.html + enum class SamplerAddressMode + { + eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT, + eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, + eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, + eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, + eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, + eMirrorClampToEdgeKHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR + }; + + // wrapper class for enum VkSamplerCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCreateFlagBits.html + enum class SamplerCreateFlagBits : VkSamplerCreateFlags + { + eSubsampledEXT = VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, + eSubsampledCoarseReconstructionEXT = VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT, + eDescriptorBufferCaptureReplayEXT = VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, + eNonSeamlessCubeMapEXT = VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT, + eImageProcessingQCOM = VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM + }; + + // wrapper using for bitmask VkSamplerCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCreateFlags.html + using SamplerCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkSamplerCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SamplerCreateFlags allFlags = + SamplerCreateFlagBits::eSubsampledEXT | SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT | + SamplerCreateFlagBits::eDescriptorBufferCaptureReplayEXT | SamplerCreateFlagBits::eNonSeamlessCubeMapEXT | SamplerCreateFlagBits::eImageProcessingQCOM; + }; + + // wrapper class for enum VkSamplerMipmapMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerMipmapMode.html + enum class SamplerMipmapMode + { + eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST, + eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR + }; + + // wrapper class for enum VkDescriptorPoolCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolCreateFlagBits.html + enum class DescriptorPoolCreateFlagBits : VkDescriptorPoolCreateFlags + { + eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, + eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, + eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT, + eHostOnlyEXT = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT, + eHostOnlyVALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE, + eAllowOverallocationSetsNV = VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV, + eAllowOverallocationPoolsNV = VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV + }; + + // wrapper using for bitmask VkDescriptorPoolCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolCreateFlags.html + using DescriptorPoolCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDescriptorPoolCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorPoolCreateFlags allFlags = + DescriptorPoolCreateFlagBits::eFreeDescriptorSet | DescriptorPoolCreateFlagBits::eUpdateAfterBind | DescriptorPoolCreateFlagBits::eHostOnlyEXT | + DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV | DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV; + }; + + // wrapper class for enum VkDescriptorSetLayoutCreateFlagBits, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutCreateFlagBits.html + enum class DescriptorSetLayoutCreateFlagBits : VkDescriptorSetLayoutCreateFlags + { + eUpdateAfterBindPool = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, + eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT, + ePushDescriptor = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT, + ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, + eDescriptorBufferEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, + eEmbeddedImmutableSamplersEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT, + eIndirectBindableNV = VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV, + eHostOnlyPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, + eHostOnlyPoolVALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE, + ePerStageNV = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV + }; + + // wrapper using for bitmask VkDescriptorSetLayoutCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutCreateFlags.html + using DescriptorSetLayoutCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDescriptorSetLayoutCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorSetLayoutCreateFlags allFlags = + DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool | DescriptorSetLayoutCreateFlagBits::ePushDescriptor | + DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT | DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT | + DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV | DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT | + DescriptorSetLayoutCreateFlagBits::ePerStageNV; + }; + + // wrapper class for enum VkDescriptorType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorType.html + enum class DescriptorType + { + eSampler = VK_DESCRIPTOR_TYPE_SAMPLER, + eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, + eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, + eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, + eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, + eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, + eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, + eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, + eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, + eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, + eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, + eInlineUniformBlock = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, + eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, + eAccelerationStructureKHR = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, + eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, + eSampleWeightImageQCOM = VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, + eBlockMatchImageQCOM = VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, + eTensorARM = VK_DESCRIPTOR_TYPE_TENSOR_ARM, + eMutableEXT = VK_DESCRIPTOR_TYPE_MUTABLE_EXT, + eMutableVALVE = VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, + ePartitionedAccelerationStructureNV = VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV + }; + + enum class DescriptorPoolResetFlagBits : VkDescriptorPoolResetFlags + { + }; + + // wrapper using for bitmask VkDescriptorPoolResetFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolResetFlags.html + using DescriptorPoolResetFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorPoolResetFlags allFlags = {}; + }; + + // wrapper class for enum VkQueryPipelineStatisticFlagBits, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPipelineStatisticFlagBits.html + enum class QueryPipelineStatisticFlagBits : VkQueryPipelineStatisticFlags + { + eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, + eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, + eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, + eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, + eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, + eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, + eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, + eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, + eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, + eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, + eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT, + eTaskShaderInvocationsEXT = VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT, + eMeshShaderInvocationsEXT = VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT, + eClusterCullingShaderInvocationsHUAWEI = VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI + }; + + // wrapper using for bitmask VkQueryPipelineStatisticFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPipelineStatisticFlags.html + using QueryPipelineStatisticFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkQueryPipelineStatisticFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR QueryPipelineStatisticFlags allFlags = + QueryPipelineStatisticFlagBits::eInputAssemblyVertices | QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives | + QueryPipelineStatisticFlagBits::eVertexShaderInvocations | QueryPipelineStatisticFlagBits::eGeometryShaderInvocations | + QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives | QueryPipelineStatisticFlagBits::eClippingInvocations | + QueryPipelineStatisticFlagBits::eClippingPrimitives | QueryPipelineStatisticFlagBits::eFragmentShaderInvocations | + QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches | QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations | + QueryPipelineStatisticFlagBits::eComputeShaderInvocations | QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT | + QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT | QueryPipelineStatisticFlagBits::eClusterCullingShaderInvocationsHUAWEI; + }; + + // wrapper class for enum VkPipelineBindPoint, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBindPoint.html + enum class PipelineBindPoint + { + eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS, + eCompute = VK_PIPELINE_BIND_POINT_COMPUTE, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eExecutionGraphAMDX = VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eRayTracingKHR = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + eRayTracingNV = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, + eSubpassShadingHUAWEI = VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI, + eDataGraphARM = VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM + }; + + // wrapper class for enum VkBlendFactor, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlendFactor.html + enum class BlendFactor + { + eZero = VK_BLEND_FACTOR_ZERO, + eOne = VK_BLEND_FACTOR_ONE, + eSrcColor = VK_BLEND_FACTOR_SRC_COLOR, + eOneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, + eDstColor = VK_BLEND_FACTOR_DST_COLOR, + eOneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, + eSrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA, + eOneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + eDstAlpha = VK_BLEND_FACTOR_DST_ALPHA, + eOneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, + eConstantColor = VK_BLEND_FACTOR_CONSTANT_COLOR, + eOneMinusConstantColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, + eConstantAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA, + eOneMinusConstantAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, + eSrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, + eSrc1Color = VK_BLEND_FACTOR_SRC1_COLOR, + eOneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, + eSrc1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA, + eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA + }; + + // wrapper class for enum VkBlendOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlendOp.html + enum class BlendOp + { + eAdd = VK_BLEND_OP_ADD, + eSubtract = VK_BLEND_OP_SUBTRACT, + eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT, + eMin = VK_BLEND_OP_MIN, + eMax = VK_BLEND_OP_MAX, + eZeroEXT = VK_BLEND_OP_ZERO_EXT, + eSrcEXT = VK_BLEND_OP_SRC_EXT, + eDstEXT = VK_BLEND_OP_DST_EXT, + eSrcOverEXT = VK_BLEND_OP_SRC_OVER_EXT, + eDstOverEXT = VK_BLEND_OP_DST_OVER_EXT, + eSrcInEXT = VK_BLEND_OP_SRC_IN_EXT, + eDstInEXT = VK_BLEND_OP_DST_IN_EXT, + eSrcOutEXT = VK_BLEND_OP_SRC_OUT_EXT, + eDstOutEXT = VK_BLEND_OP_DST_OUT_EXT, + eSrcAtopEXT = VK_BLEND_OP_SRC_ATOP_EXT, + eDstAtopEXT = VK_BLEND_OP_DST_ATOP_EXT, + eXorEXT = VK_BLEND_OP_XOR_EXT, + eMultiplyEXT = VK_BLEND_OP_MULTIPLY_EXT, + eScreenEXT = VK_BLEND_OP_SCREEN_EXT, + eOverlayEXT = VK_BLEND_OP_OVERLAY_EXT, + eDarkenEXT = VK_BLEND_OP_DARKEN_EXT, + eLightenEXT = VK_BLEND_OP_LIGHTEN_EXT, + eColordodgeEXT = VK_BLEND_OP_COLORDODGE_EXT, + eColorburnEXT = VK_BLEND_OP_COLORBURN_EXT, + eHardlightEXT = VK_BLEND_OP_HARDLIGHT_EXT, + eSoftlightEXT = VK_BLEND_OP_SOFTLIGHT_EXT, + eDifferenceEXT = VK_BLEND_OP_DIFFERENCE_EXT, + eExclusionEXT = VK_BLEND_OP_EXCLUSION_EXT, + eInvertEXT = VK_BLEND_OP_INVERT_EXT, + eInvertRgbEXT = VK_BLEND_OP_INVERT_RGB_EXT, + eLineardodgeEXT = VK_BLEND_OP_LINEARDODGE_EXT, + eLinearburnEXT = VK_BLEND_OP_LINEARBURN_EXT, + eVividlightEXT = VK_BLEND_OP_VIVIDLIGHT_EXT, + eLinearlightEXT = VK_BLEND_OP_LINEARLIGHT_EXT, + ePinlightEXT = VK_BLEND_OP_PINLIGHT_EXT, + eHardmixEXT = VK_BLEND_OP_HARDMIX_EXT, + eHslHueEXT = VK_BLEND_OP_HSL_HUE_EXT, + eHslSaturationEXT = VK_BLEND_OP_HSL_SATURATION_EXT, + eHslColorEXT = VK_BLEND_OP_HSL_COLOR_EXT, + eHslLuminosityEXT = VK_BLEND_OP_HSL_LUMINOSITY_EXT, + ePlusEXT = VK_BLEND_OP_PLUS_EXT, + ePlusClampedEXT = VK_BLEND_OP_PLUS_CLAMPED_EXT, + ePlusClampedAlphaEXT = VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, + ePlusDarkerEXT = VK_BLEND_OP_PLUS_DARKER_EXT, + eMinusEXT = VK_BLEND_OP_MINUS_EXT, + eMinusClampedEXT = VK_BLEND_OP_MINUS_CLAMPED_EXT, + eContrastEXT = VK_BLEND_OP_CONTRAST_EXT, + eInvertOvgEXT = VK_BLEND_OP_INVERT_OVG_EXT, + eRedEXT = VK_BLEND_OP_RED_EXT, + eGreenEXT = VK_BLEND_OP_GREEN_EXT, + eBlueEXT = VK_BLEND_OP_BLUE_EXT + }; + + // wrapper class for enum VkColorComponentFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorComponentFlagBits.html + enum class ColorComponentFlagBits : VkColorComponentFlags + { + eR = VK_COLOR_COMPONENT_R_BIT, + eG = VK_COLOR_COMPONENT_G_BIT, + eB = VK_COLOR_COMPONENT_B_BIT, + eA = VK_COLOR_COMPONENT_A_BIT + }; + + // wrapper using for bitmask VkColorComponentFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorComponentFlags.html + using ColorComponentFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkColorComponentFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ColorComponentFlags allFlags = + ColorComponentFlagBits::eR | ColorComponentFlagBits::eG | ColorComponentFlagBits::eB | ColorComponentFlagBits::eA; + }; + + // wrapper class for enum VkCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompareOp.html + enum class CompareOp + { + eNever = VK_COMPARE_OP_NEVER, + eLess = VK_COMPARE_OP_LESS, + eEqual = VK_COMPARE_OP_EQUAL, + eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL, + eGreater = VK_COMPARE_OP_GREATER, + eNotEqual = VK_COMPARE_OP_NOT_EQUAL, + eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL, + eAlways = VK_COMPARE_OP_ALWAYS + }; + + // wrapper class for enum VkCullModeFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCullModeFlagBits.html + enum class CullModeFlagBits : VkCullModeFlags + { + eNone = VK_CULL_MODE_NONE, + eFront = VK_CULL_MODE_FRONT_BIT, + eBack = VK_CULL_MODE_BACK_BIT, + eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK + }; + + // wrapper using for bitmask VkCullModeFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCullModeFlags.html + using CullModeFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkCullModeFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CullModeFlags allFlags = + CullModeFlagBits::eNone | CullModeFlagBits::eFront | CullModeFlagBits::eBack | CullModeFlagBits::eFrontAndBack; + }; + + // wrapper class for enum VkDynamicState, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDynamicState.html + enum class DynamicState + { + eViewport = VK_DYNAMIC_STATE_VIEWPORT, + eScissor = VK_DYNAMIC_STATE_SCISSOR, + eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH, + eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS, + eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS, + eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS, + eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, + eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, + eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE, + eCullMode = VK_DYNAMIC_STATE_CULL_MODE, + eCullModeEXT = VK_DYNAMIC_STATE_CULL_MODE_EXT, + eFrontFace = VK_DYNAMIC_STATE_FRONT_FACE, + eFrontFaceEXT = VK_DYNAMIC_STATE_FRONT_FACE_EXT, + ePrimitiveTopology = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, + ePrimitiveTopologyEXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT, + eViewportWithCount = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, + eViewportWithCountEXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT, + eScissorWithCount = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, + eScissorWithCountEXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT, + eVertexInputBindingStride = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE, + eVertexInputBindingStrideEXT = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT, + eDepthTestEnable = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE, + eDepthTestEnableEXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT, + eDepthWriteEnable = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE, + eDepthWriteEnableEXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT, + eDepthCompareOp = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP, + eDepthCompareOpEXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT, + eDepthBoundsTestEnable = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE, + eDepthBoundsTestEnableEXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT, + eStencilTestEnable = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE, + eStencilTestEnableEXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT, + eStencilOp = VK_DYNAMIC_STATE_STENCIL_OP, + eStencilOpEXT = VK_DYNAMIC_STATE_STENCIL_OP_EXT, + eRasterizerDiscardEnable = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE, + eRasterizerDiscardEnableEXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT, + eDepthBiasEnable = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE, + eDepthBiasEnableEXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT, + ePrimitiveRestartEnable = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE, + ePrimitiveRestartEnableEXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT, + eLineStipple = VK_DYNAMIC_STATE_LINE_STIPPLE, + eLineStippleEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT, + eLineStippleKHR = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR, + eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, + eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, + eDiscardRectangleEnableEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT, + eDiscardRectangleModeEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT, + eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, + eRayTracingPipelineStackSizeKHR = VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR, + eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV, + eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV, + eExclusiveScissorEnableNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV, + eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV, + eFragmentShadingRateKHR = VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR, + eVertexInputEXT = VK_DYNAMIC_STATE_VERTEX_INPUT_EXT, + ePatchControlPointsEXT = VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT, + eLogicOpEXT = VK_DYNAMIC_STATE_LOGIC_OP_EXT, + eColorWriteEnableEXT = VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT, + eDepthClampEnableEXT = VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT, + ePolygonModeEXT = VK_DYNAMIC_STATE_POLYGON_MODE_EXT, + eRasterizationSamplesEXT = VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT, + eSampleMaskEXT = VK_DYNAMIC_STATE_SAMPLE_MASK_EXT, + eAlphaToCoverageEnableEXT = VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT, + eAlphaToOneEnableEXT = VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT, + eLogicOpEnableEXT = VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT, + eColorBlendEnableEXT = VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT, + eColorBlendEquationEXT = VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT, + eColorWriteMaskEXT = VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT, + eTessellationDomainOriginEXT = VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT, + eRasterizationStreamEXT = VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT, + eConservativeRasterizationModeEXT = VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT, + eExtraPrimitiveOverestimationSizeEXT = VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT, + eDepthClipEnableEXT = VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT, + eSampleLocationsEnableEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT, + eColorBlendAdvancedEXT = VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT, + eProvokingVertexModeEXT = VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT, + eLineRasterizationModeEXT = VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT, + eLineStippleEnableEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT, + eDepthClipNegativeOneToOneEXT = VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT, + eViewportWScalingEnableNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV, + eViewportSwizzleNV = VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV, + eCoverageToColorEnableNV = VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV, + eCoverageToColorLocationNV = VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV, + eCoverageModulationModeNV = VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV, + eCoverageModulationTableEnableNV = VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV, + eCoverageModulationTableNV = VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV, + eShadingRateImageEnableNV = VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV, + eRepresentativeFragmentTestEnableNV = VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV, + eCoverageReductionModeNV = VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV, + eAttachmentFeedbackLoopEnableEXT = VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT, + eDepthClampRangeEXT = VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT + }; + + // wrapper class for enum VkFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrontFace.html + enum class FrontFace + { + eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE, + eClockwise = VK_FRONT_FACE_CLOCKWISE + }; + + // wrapper class for enum VkLogicOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLogicOp.html + enum class LogicOp + { + eClear = VK_LOGIC_OP_CLEAR, + eAnd = VK_LOGIC_OP_AND, + eAndReverse = VK_LOGIC_OP_AND_REVERSE, + eCopy = VK_LOGIC_OP_COPY, + eAndInverted = VK_LOGIC_OP_AND_INVERTED, + eNoOp = VK_LOGIC_OP_NO_OP, + eXor = VK_LOGIC_OP_XOR, + eOr = VK_LOGIC_OP_OR, + eNor = VK_LOGIC_OP_NOR, + eEquivalent = VK_LOGIC_OP_EQUIVALENT, + eInvert = VK_LOGIC_OP_INVERT, + eOrReverse = VK_LOGIC_OP_OR_REVERSE, + eCopyInverted = VK_LOGIC_OP_COPY_INVERTED, + eOrInverted = VK_LOGIC_OP_OR_INVERTED, + eNand = VK_LOGIC_OP_NAND, + eSet = VK_LOGIC_OP_SET + }; + + // wrapper class for enum VkPolygonMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPolygonMode.html + enum class PolygonMode + { + eFill = VK_POLYGON_MODE_FILL, + eLine = VK_POLYGON_MODE_LINE, + ePoint = VK_POLYGON_MODE_POINT, + eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV + }; + + // wrapper class for enum VkPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrimitiveTopology.html + enum class PrimitiveTopology + { + ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, + eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST, + eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, + eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, + eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, + eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, + eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, + eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, + eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, + eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, + ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST + }; + + // wrapper class for enum VkStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilOp.html + enum class StencilOp + { + eKeep = VK_STENCIL_OP_KEEP, + eZero = VK_STENCIL_OP_ZERO, + eReplace = VK_STENCIL_OP_REPLACE, + eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP, + eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP, + eInvert = VK_STENCIL_OP_INVERT, + eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP, + eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP + }; + + // wrapper class for enum VkVertexInputRate, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputRate.html + enum class VertexInputRate + { + eVertex = VK_VERTEX_INPUT_RATE_VERTEX, + eInstance = VK_VERTEX_INPUT_RATE_INSTANCE + }; + + // wrapper class for enum VkPipelineColorBlendStateCreateFlagBits, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendStateCreateFlagBits.html + enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags + { + eRasterizationOrderAttachmentAccessEXT = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT, + eRasterizationOrderAttachmentAccessARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM + }; + + // wrapper using for bitmask VkPipelineColorBlendStateCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendStateCreateFlags.html + using PipelineColorBlendStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPipelineColorBlendStateCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineColorBlendStateCreateFlags allFlags = + PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT; + }; + + // wrapper class for enum VkPipelineDepthStencilStateCreateFlagBits, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDepthStencilStateCreateFlagBits.html + enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags + { + eRasterizationOrderAttachmentDepthAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + eRasterizationOrderAttachmentDepthAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM, + eRasterizationOrderAttachmentStencilAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, + eRasterizationOrderAttachmentStencilAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM + }; + + // wrapper using for bitmask VkPipelineDepthStencilStateCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDepthStencilStateCreateFlags.html + using PipelineDepthStencilStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPipelineDepthStencilStateCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDepthStencilStateCreateFlags allFlags = + PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT | + PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT; + }; + + enum class PipelineDynamicStateCreateFlagBits : VkPipelineDynamicStateCreateFlags + { + }; + + // wrapper using for bitmask VkPipelineDynamicStateCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDynamicStateCreateFlags.html + using PipelineDynamicStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDynamicStateCreateFlags allFlags = {}; + }; + + enum class PipelineInputAssemblyStateCreateFlagBits : VkPipelineInputAssemblyStateCreateFlags + { + }; + + // wrapper using for bitmask VkPipelineInputAssemblyStateCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineInputAssemblyStateCreateFlags.html + using PipelineInputAssemblyStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineInputAssemblyStateCreateFlags allFlags = {}; + }; + + enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags + { + }; + + // wrapper using for bitmask VkPipelineMultisampleStateCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineMultisampleStateCreateFlags.html + using PipelineMultisampleStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineMultisampleStateCreateFlags allFlags = {}; + }; + + enum class PipelineRasterizationStateCreateFlagBits : VkPipelineRasterizationStateCreateFlags + { + }; + + // wrapper using for bitmask VkPipelineRasterizationStateCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateCreateFlags.html + using PipelineRasterizationStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationStateCreateFlags allFlags = {}; + }; + + enum class PipelineTessellationStateCreateFlagBits : VkPipelineTessellationStateCreateFlags + { + }; + + // wrapper using for bitmask VkPipelineTessellationStateCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineTessellationStateCreateFlags.html + using PipelineTessellationStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineTessellationStateCreateFlags allFlags = {}; + }; + + enum class PipelineVertexInputStateCreateFlagBits : VkPipelineVertexInputStateCreateFlags + { + }; + + // wrapper using for bitmask VkPipelineVertexInputStateCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineVertexInputStateCreateFlags.html + using PipelineVertexInputStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineVertexInputStateCreateFlags allFlags = {}; + }; + + enum class PipelineViewportStateCreateFlagBits : VkPipelineViewportStateCreateFlags + { + }; + + // wrapper using for bitmask VkPipelineViewportStateCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportStateCreateFlags.html + using PipelineViewportStateCreateFlags = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineViewportStateCreateFlags allFlags = {}; + }; + + // wrapper class for enum VkAttachmentDescriptionFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescriptionFlagBits.html + enum class AttachmentDescriptionFlagBits : VkAttachmentDescriptionFlags + { + eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, + eResolveSkipTransferFunctionKHR = VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR, + eResolveEnableTransferFunctionKHR = VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR + }; + + // wrapper using for bitmask VkAttachmentDescriptionFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescriptionFlags.html + using AttachmentDescriptionFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkAttachmentDescriptionFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AttachmentDescriptionFlags allFlags = AttachmentDescriptionFlagBits::eMayAlias | + AttachmentDescriptionFlagBits::eResolveSkipTransferFunctionKHR | + AttachmentDescriptionFlagBits::eResolveEnableTransferFunctionKHR; + }; + + // wrapper class for enum VkAttachmentLoadOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentLoadOp.html + enum class AttachmentLoadOp + { + eLoad = VK_ATTACHMENT_LOAD_OP_LOAD, + eClear = VK_ATTACHMENT_LOAD_OP_CLEAR, + eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE, + eNone = VK_ATTACHMENT_LOAD_OP_NONE, + eNoneEXT = VK_ATTACHMENT_LOAD_OP_NONE_EXT, + eNoneKHR = VK_ATTACHMENT_LOAD_OP_NONE_KHR + }; + + // wrapper class for enum VkAttachmentStoreOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentStoreOp.html + enum class AttachmentStoreOp + { + eStore = VK_ATTACHMENT_STORE_OP_STORE, + eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE, + eNone = VK_ATTACHMENT_STORE_OP_NONE, + eNoneKHR = VK_ATTACHMENT_STORE_OP_NONE_KHR, + eNoneQCOM = VK_ATTACHMENT_STORE_OP_NONE_QCOM, + eNoneEXT = VK_ATTACHMENT_STORE_OP_NONE_EXT + }; + + // wrapper class for enum VkFramebufferCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferCreateFlagBits.html + enum class FramebufferCreateFlagBits : VkFramebufferCreateFlags + { + eImageless = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, + eImagelessKHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR + }; + + // wrapper using for bitmask VkFramebufferCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferCreateFlags.html + using FramebufferCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkFramebufferCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR FramebufferCreateFlags allFlags = FramebufferCreateFlagBits::eImageless; + }; + + // wrapper class for enum VkRenderPassCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateFlagBits.html + enum class RenderPassCreateFlagBits : VkRenderPassCreateFlags + { + eTransformQCOM = VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM, + ePerLayerFragmentDensityVALVE = VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE + }; + + // wrapper using for bitmask VkRenderPassCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateFlags.html + using RenderPassCreateFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkRenderPassCreateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR RenderPassCreateFlags allFlags = + RenderPassCreateFlagBits::eTransformQCOM | RenderPassCreateFlagBits::ePerLayerFragmentDensityVALVE; + }; + + // wrapper class for enum VkSubpassDescriptionFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescriptionFlagBits.html + enum class SubpassDescriptionFlagBits : VkSubpassDescriptionFlags + { + ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX, + ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, + eTileShadingApronQCOM = VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM, + eRasterizationOrderAttachmentColorAccessEXT = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT, + eRasterizationOrderAttachmentColorAccessARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM, + eRasterizationOrderAttachmentDepthAccessEXT = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + eRasterizationOrderAttachmentDepthAccessARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM, + eRasterizationOrderAttachmentStencilAccessEXT = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, + eRasterizationOrderAttachmentStencilAccessARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM, + eEnableLegacyDitheringEXT = VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT, + eFragmentRegionEXT = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT, + eFragmentRegionQCOM = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, + eCustomResolveEXT = VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT, + eShaderResolveQCOM = VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM + }; + + // wrapper using for bitmask VkSubpassDescriptionFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescriptionFlags.html + using SubpassDescriptionFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkSubpassDescriptionFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SubpassDescriptionFlags allFlags = + SubpassDescriptionFlagBits::ePerViewAttributesNVX | SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX | + SubpassDescriptionFlagBits::eTileShadingApronQCOM | SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT | + SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT | SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT | + SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT | SubpassDescriptionFlagBits::eFragmentRegionEXT | SubpassDescriptionFlagBits::eCustomResolveEXT; + }; + + // wrapper class for enum VkStencilFaceFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilFaceFlagBits.html + enum class StencilFaceFlagBits : VkStencilFaceFlags + { + eFront = VK_STENCIL_FACE_FRONT_BIT, + eBack = VK_STENCIL_FACE_BACK_BIT, + eFrontAndBack = VK_STENCIL_FACE_FRONT_AND_BACK, + eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK + }; + + // wrapper using for bitmask VkStencilFaceFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilFaceFlags.html + using StencilFaceFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkStencilFaceFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StencilFaceFlags allFlags = + StencilFaceFlagBits::eFront | StencilFaceFlagBits::eBack | StencilFaceFlagBits::eFrontAndBack; + }; + + // wrapper class for enum VkSubpassContents, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassContents.html + enum class SubpassContents + { + eInline = VK_SUBPASS_CONTENTS_INLINE, + eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, + eInlineAndSecondaryCommandBuffersKHR = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR, + eInlineAndSecondaryCommandBuffersEXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT + }; + + //=== VK_VERSION_1_1 === + + // wrapper class for enum VkPeerMemoryFeatureFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPeerMemoryFeatureFlagBits.html + enum class PeerMemoryFeatureFlagBits : VkPeerMemoryFeatureFlags + { + eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, + eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, + eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, + eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT + }; + + using PeerMemoryFeatureFlagBitsKHR = PeerMemoryFeatureFlagBits; + + // wrapper using for bitmask VkPeerMemoryFeatureFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPeerMemoryFeatureFlags.html + using PeerMemoryFeatureFlags = Flags; + using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkPeerMemoryFeatureFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PeerMemoryFeatureFlags allFlags = PeerMemoryFeatureFlagBits::eCopySrc | PeerMemoryFeatureFlagBits::eCopyDst | + PeerMemoryFeatureFlagBits::eGenericSrc | PeerMemoryFeatureFlagBits::eGenericDst; + }; + + // wrapper class for enum VkMemoryAllocateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryAllocateFlagBits.html + enum class MemoryAllocateFlagBits : VkMemoryAllocateFlags + { + eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, + eDeviceAddress = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, + eDeviceAddressCaptureReplay = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + eZeroInitializeEXT = VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT + }; + + using MemoryAllocateFlagBitsKHR = MemoryAllocateFlagBits; + + // wrapper using for bitmask VkMemoryAllocateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryAllocateFlags.html + using MemoryAllocateFlags = Flags; + using MemoryAllocateFlagsKHR = MemoryAllocateFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkMemoryAllocateFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryAllocateFlags allFlags = MemoryAllocateFlagBits::eDeviceMask | MemoryAllocateFlagBits::eDeviceAddress | + MemoryAllocateFlagBits::eDeviceAddressCaptureReplay | + MemoryAllocateFlagBits::eZeroInitializeEXT; + }; + + enum class CommandPoolTrimFlagBits : VkCommandPoolTrimFlags + { + }; + + // wrapper using for bitmask VkCommandPoolTrimFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolTrimFlags.html + using CommandPoolTrimFlags = Flags; + using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolTrimFlags allFlags = {}; + }; + + // wrapper class for enum VkExternalMemoryHandleTypeFlagBits, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlagBits.html + enum class ExternalMemoryHandleTypeFlagBits : VkExternalMemoryHandleTypeFlags + { + eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, + eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, + eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, + eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, + eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + eAndroidHardwareBufferANDROID = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, + eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, +#if defined( VK_USE_PLATFORM_FUCHSIA ) + eZirconVmoFUCHSIA = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + eRdmaAddressNV = VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV, +#if defined( VK_USE_PLATFORM_OHOS ) + eOhNativeBufferOHOS = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS, +#endif /*VK_USE_PLATFORM_OHOS*/ +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + eScreenBufferQNX = VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX, +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ +#if defined( VK_USE_PLATFORM_METAL_EXT ) + eMtlbufferEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT, + eMtltextureEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT, + eMtlheapEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + }; + + using ExternalMemoryHandleTypeFlagBitsKHR = ExternalMemoryHandleTypeFlagBits; + + // wrapper using for bitmask VkExternalMemoryHandleTypeFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlags.html + using ExternalMemoryHandleTypeFlags = Flags; + using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkExternalMemoryHandleTypeFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryHandleTypeFlags allFlags = + ExternalMemoryHandleTypeFlagBits::eOpaqueFd | ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 | ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt | + ExternalMemoryHandleTypeFlagBits::eD3D11Texture | ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt | ExternalMemoryHandleTypeFlagBits::eD3D12Heap | + ExternalMemoryHandleTypeFlagBits::eD3D12Resource | ExternalMemoryHandleTypeFlagBits::eDmaBufEXT +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + | ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + | ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT | ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT +#if defined( VK_USE_PLATFORM_FUCHSIA ) + | ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + | ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV +#if defined( VK_USE_PLATFORM_OHOS ) + | ExternalMemoryHandleTypeFlagBits::eOhNativeBufferOHOS +#endif /*VK_USE_PLATFORM_OHOS*/ +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + | ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ +#if defined( VK_USE_PLATFORM_METAL_EXT ) + | ExternalMemoryHandleTypeFlagBits::eMtlbufferEXT | ExternalMemoryHandleTypeFlagBits::eMtltextureEXT | ExternalMemoryHandleTypeFlagBits::eMtlheapEXT +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + ; + }; + + // wrapper class for enum VkExternalMemoryFeatureFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlagBits.html + enum class ExternalMemoryFeatureFlagBits : VkExternalMemoryFeatureFlags + { + eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, + eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, + eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT + }; + + using ExternalMemoryFeatureFlagBitsKHR = ExternalMemoryFeatureFlagBits; + + // wrapper using for bitmask VkExternalMemoryFeatureFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlags.html + using ExternalMemoryFeatureFlags = Flags; + using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkExternalMemoryFeatureFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryFeatureFlags allFlags = + ExternalMemoryFeatureFlagBits::eDedicatedOnly | ExternalMemoryFeatureFlagBits::eExportable | ExternalMemoryFeatureFlagBits::eImportable; + }; + + // wrapper class for enum VkExternalFenceHandleTypeFlagBits, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceHandleTypeFlagBits.html + enum class ExternalFenceHandleTypeFlagBits : VkExternalFenceHandleTypeFlags + { + eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT + }; + + using ExternalFenceHandleTypeFlagBitsKHR = ExternalFenceHandleTypeFlagBits; + + // wrapper using for bitmask VkExternalFenceHandleTypeFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceHandleTypeFlags.html + using ExternalFenceHandleTypeFlags = Flags; + using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkExternalFenceHandleTypeFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalFenceHandleTypeFlags allFlags = + ExternalFenceHandleTypeFlagBits::eOpaqueFd | ExternalFenceHandleTypeFlagBits::eOpaqueWin32 | ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt | + ExternalFenceHandleTypeFlagBits::eSyncFd; + }; + + // wrapper class for enum VkExternalFenceFeatureFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceFeatureFlagBits.html + enum class ExternalFenceFeatureFlagBits : VkExternalFenceFeatureFlags + { + eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, + eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT + }; + + using ExternalFenceFeatureFlagBitsKHR = ExternalFenceFeatureFlagBits; + + // wrapper using for bitmask VkExternalFenceFeatureFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceFeatureFlags.html + using ExternalFenceFeatureFlags = Flags; + using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkExternalFenceFeatureFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalFenceFeatureFlags allFlags = + ExternalFenceFeatureFlagBits::eExportable | ExternalFenceFeatureFlagBits::eImportable; + }; + + // wrapper class for enum VkFenceImportFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceImportFlagBits.html + enum class FenceImportFlagBits : VkFenceImportFlags + { + eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT + }; + + using FenceImportFlagBitsKHR = FenceImportFlagBits; + + // wrapper using for bitmask VkFenceImportFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceImportFlags.html + using FenceImportFlags = Flags; + using FenceImportFlagsKHR = FenceImportFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkFenceImportFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR FenceImportFlags allFlags = FenceImportFlagBits::eTemporary; + }; + + // wrapper class for enum VkSemaphoreImportFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreImportFlagBits.html + enum class SemaphoreImportFlagBits : VkSemaphoreImportFlags + { + eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT + }; + + using SemaphoreImportFlagBitsKHR = SemaphoreImportFlagBits; + + // wrapper using for bitmask VkSemaphoreImportFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreImportFlags.html + using SemaphoreImportFlags = Flags; + using SemaphoreImportFlagsKHR = SemaphoreImportFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkSemaphoreImportFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreImportFlags allFlags = SemaphoreImportFlagBits::eTemporary; + }; + + // wrapper class for enum VkExternalSemaphoreHandleTypeFlagBits, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreHandleTypeFlagBits.html + enum class ExternalSemaphoreHandleTypeFlagBits : VkExternalSemaphoreHandleTypeFlags + { + eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, + eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + eD3D11Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT, + eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, +#if defined( VK_USE_PLATFORM_FUCHSIA ) + eZirconEventFUCHSIA = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + }; + + using ExternalSemaphoreHandleTypeFlagBitsKHR = ExternalSemaphoreHandleTypeFlagBits; + + // wrapper using for bitmask VkExternalSemaphoreHandleTypeFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreHandleTypeFlags.html + using ExternalSemaphoreHandleTypeFlags = Flags; + using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkExternalSemaphoreHandleTypeFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalSemaphoreHandleTypeFlags allFlags = + ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd | ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 | + ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt | ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence | ExternalSemaphoreHandleTypeFlagBits::eSyncFd +#if defined( VK_USE_PLATFORM_FUCHSIA ) + | ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + ; + }; + + // wrapper class for enum VkExternalSemaphoreFeatureFlagBits, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreFeatureFlagBits.html + enum class ExternalSemaphoreFeatureFlagBits : VkExternalSemaphoreFeatureFlags + { + eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, + eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT + }; + + using ExternalSemaphoreFeatureFlagBitsKHR = ExternalSemaphoreFeatureFlagBits; + + // wrapper using for bitmask VkExternalSemaphoreFeatureFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreFeatureFlags.html + using ExternalSemaphoreFeatureFlags = Flags; + using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkExternalSemaphoreFeatureFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalSemaphoreFeatureFlags allFlags = + ExternalSemaphoreFeatureFlagBits::eExportable | ExternalSemaphoreFeatureFlagBits::eImportable; + }; + + // wrapper class for enum VkSubgroupFeatureFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubgroupFeatureFlagBits.html + enum class SubgroupFeatureFlagBits : VkSubgroupFeatureFlags + { + eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT, + eVote = VK_SUBGROUP_FEATURE_VOTE_BIT, + eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, + eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT, + eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT, + eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, + eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT, + eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT, + eRotate = VK_SUBGROUP_FEATURE_ROTATE_BIT, + eRotateKHR = VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR, + eRotateClustered = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT, + eRotateClusteredKHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR, + ePartitionedEXT = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT, + ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV + }; + + // wrapper using for bitmask VkSubgroupFeatureFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubgroupFeatureFlags.html + using SubgroupFeatureFlags = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkSubgroupFeatureFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SubgroupFeatureFlags allFlags = + SubgroupFeatureFlagBits::eBasic | SubgroupFeatureFlagBits::eVote | SubgroupFeatureFlagBits::eArithmetic | SubgroupFeatureFlagBits::eBallot | + SubgroupFeatureFlagBits::eShuffle | SubgroupFeatureFlagBits::eShuffleRelative | SubgroupFeatureFlagBits::eClustered | SubgroupFeatureFlagBits::eQuad | + SubgroupFeatureFlagBits::eRotate | SubgroupFeatureFlagBits::eRotateClustered | SubgroupFeatureFlagBits::ePartitionedEXT; + }; + + // wrapper class for enum VkDescriptorUpdateTemplateType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateType.html + enum class DescriptorUpdateTemplateType + { + eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + ePushDescriptors = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS + }; + + using DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType; + + enum class DescriptorUpdateTemplateCreateFlagBits : VkDescriptorUpdateTemplateCreateFlags + { + }; + + // wrapper using for bitmask VkDescriptorUpdateTemplateCreateFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateCreateFlags.html + using DescriptorUpdateTemplateCreateFlags = Flags; + using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorUpdateTemplateCreateFlags allFlags = {}; + }; + + // wrapper class for enum VkSamplerYcbcrModelConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrModelConversion.html + enum class SamplerYcbcrModelConversion + { + eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, + eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, + eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 + }; + + using SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion; + + // wrapper class for enum VkSamplerYcbcrRange, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrRange.html + enum class SamplerYcbcrRange + { + eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW + }; + + using SamplerYcbcrRangeKHR = SamplerYcbcrRange; + + // wrapper class for enum VkChromaLocation, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkChromaLocation.html + enum class ChromaLocation + { + eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN, + eMidpoint = VK_CHROMA_LOCATION_MIDPOINT + }; + + using ChromaLocationKHR = ChromaLocation; + + // wrapper class for enum VkPointClippingBehavior, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPointClippingBehavior.html + enum class PointClippingBehavior + { + eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY + }; + + using PointClippingBehaviorKHR = PointClippingBehavior; + + // wrapper class for enum VkTessellationDomainOrigin, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTessellationDomainOrigin.html + enum class TessellationDomainOrigin + { + eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT + }; + + using TessellationDomainOriginKHR = TessellationDomainOrigin; + + //=== VK_VERSION_1_2 === + + // wrapper class for enum VkDriverId, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDriverId.html + enum class DriverId + { + eAmdProprietary = VK_DRIVER_ID_AMD_PROPRIETARY, + eAmdOpenSource = VK_DRIVER_ID_AMD_OPEN_SOURCE, + eMesaRadv = VK_DRIVER_ID_MESA_RADV, + eNvidiaProprietary = VK_DRIVER_ID_NVIDIA_PROPRIETARY, + eIntelProprietaryWindows = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS, + eIntelOpenSourceMESA = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA, + eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY, + eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY, + eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY, + eGoogleSwiftshader = VK_DRIVER_ID_GOOGLE_SWIFTSHADER, + eGgpProprietary = VK_DRIVER_ID_GGP_PROPRIETARY, + eBroadcomProprietary = VK_DRIVER_ID_BROADCOM_PROPRIETARY, + eMesaLlvmpipe = VK_DRIVER_ID_MESA_LLVMPIPE, + eMoltenvk = VK_DRIVER_ID_MOLTENVK, + eCoreaviProprietary = VK_DRIVER_ID_COREAVI_PROPRIETARY, + eJuiceProprietary = VK_DRIVER_ID_JUICE_PROPRIETARY, + eVerisiliconProprietary = VK_DRIVER_ID_VERISILICON_PROPRIETARY, + eMesaTurnip = VK_DRIVER_ID_MESA_TURNIP, + eMesaV3Dv = VK_DRIVER_ID_MESA_V3DV, + eMesaPanvk = VK_DRIVER_ID_MESA_PANVK, + eSamsungProprietary = VK_DRIVER_ID_SAMSUNG_PROPRIETARY, + eMesaVenus = VK_DRIVER_ID_MESA_VENUS, + eMesaDozen = VK_DRIVER_ID_MESA_DOZEN, + eMesaNvk = VK_DRIVER_ID_MESA_NVK, + eImaginationOpenSourceMESA = VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA, + eMesaHoneykrisp = VK_DRIVER_ID_MESA_HONEYKRISP, + eVulkanScEmulationOnVulkan = VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN, + eMesaKosmickrisp = VK_DRIVER_ID_MESA_KOSMICKRISP + }; + + using DriverIdKHR = DriverId; + + // wrapper class for enum VkSemaphoreType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreType.html + enum class SemaphoreType + { + eBinary = VK_SEMAPHORE_TYPE_BINARY, + eTimeline = VK_SEMAPHORE_TYPE_TIMELINE + }; + + using SemaphoreTypeKHR = SemaphoreType; + + // wrapper class for enum VkSemaphoreWaitFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreWaitFlagBits.html + enum class SemaphoreWaitFlagBits : VkSemaphoreWaitFlags + { + eAny = VK_SEMAPHORE_WAIT_ANY_BIT + }; + + using SemaphoreWaitFlagBitsKHR = SemaphoreWaitFlagBits; + + // wrapper using for bitmask VkSemaphoreWaitFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreWaitFlags.html + using SemaphoreWaitFlags = Flags; + using SemaphoreWaitFlagsKHR = SemaphoreWaitFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkSemaphoreWaitFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreWaitFlags allFlags = SemaphoreWaitFlagBits::eAny; + }; + + // wrapper class for enum VkShaderFloatControlsIndependence, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderFloatControlsIndependence.html + enum class ShaderFloatControlsIndependence + { + e32BitOnly = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, + eAll = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, + eNone = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE + }; + + using ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence; + + // wrapper class for enum VkDescriptorBindingFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBindingFlagBits.html + enum class DescriptorBindingFlagBits : VkDescriptorBindingFlags + { + eUpdateAfterBind = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, + eUpdateUnusedWhilePending = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, + ePartiallyBound = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, + eVariableDescriptorCount = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT + }; + + using DescriptorBindingFlagBitsEXT = DescriptorBindingFlagBits; + + // wrapper using for bitmask VkDescriptorBindingFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBindingFlags.html + using DescriptorBindingFlags = Flags; + using DescriptorBindingFlagsEXT = DescriptorBindingFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkDescriptorBindingFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorBindingFlags allFlags = + DescriptorBindingFlagBits::eUpdateAfterBind | DescriptorBindingFlagBits::eUpdateUnusedWhilePending | DescriptorBindingFlagBits::ePartiallyBound | + DescriptorBindingFlagBits::eVariableDescriptorCount; + }; + + // wrapper class for enum VkSamplerReductionMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerReductionMode.html + enum class SamplerReductionMode + { + eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, + eMin = VK_SAMPLER_REDUCTION_MODE_MIN, + eMax = VK_SAMPLER_REDUCTION_MODE_MAX, + eWeightedAverageRangeclampQCOM = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM + }; + + using SamplerReductionModeEXT = SamplerReductionMode; + + // wrapper class for enum VkResolveModeFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveModeFlagBits.html + enum class ResolveModeFlagBits : VkResolveModeFlags + { + eNone = VK_RESOLVE_MODE_NONE, + eSampleZero = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, + eAverage = VK_RESOLVE_MODE_AVERAGE_BIT, + eMin = VK_RESOLVE_MODE_MIN_BIT, + eMax = VK_RESOLVE_MODE_MAX_BIT, +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + eExternalFormatDownsampleANDROID = VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + eCustomEXT = VK_RESOLVE_MODE_CUSTOM_BIT_EXT + }; + + using ResolveModeFlagBitsKHR = ResolveModeFlagBits; + + // wrapper using for bitmask VkResolveModeFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveModeFlags.html + using ResolveModeFlags = Flags; + using ResolveModeFlagsKHR = ResolveModeFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkResolveModeFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveModeFlags allFlags = ResolveModeFlagBits::eNone | ResolveModeFlagBits::eSampleZero | + ResolveModeFlagBits::eAverage | ResolveModeFlagBits::eMin | ResolveModeFlagBits::eMax +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + | ResolveModeFlagBits::eExternalFormatDownsampleANDROID +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + | ResolveModeFlagBits::eCustomEXT; + }; + + //=== VK_VERSION_1_3 === + + // wrapper class for enum VkToolPurposeFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkToolPurposeFlagBits.html + enum class ToolPurposeFlagBits : VkToolPurposeFlags + { + eValidation = VK_TOOL_PURPOSE_VALIDATION_BIT, + eProfiling = VK_TOOL_PURPOSE_PROFILING_BIT, + eTracing = VK_TOOL_PURPOSE_TRACING_BIT, + eAdditionalFeatures = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, + eModifyingFeatures = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT, + eDebugReportingEXT = VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT, + eDebugMarkersEXT = VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT + }; + + using ToolPurposeFlagBitsEXT = ToolPurposeFlagBits; + + // wrapper using for bitmask VkToolPurposeFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkToolPurposeFlags.html + using ToolPurposeFlags = Flags; + using ToolPurposeFlagsEXT = ToolPurposeFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkToolPurposeFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ToolPurposeFlags allFlags = + ToolPurposeFlagBits::eValidation | ToolPurposeFlagBits::eProfiling | ToolPurposeFlagBits::eTracing | ToolPurposeFlagBits::eAdditionalFeatures | + ToolPurposeFlagBits::eModifyingFeatures | ToolPurposeFlagBits::eDebugReportingEXT | ToolPurposeFlagBits::eDebugMarkersEXT; + }; + + enum class PrivateDataSlotCreateFlagBits : VkPrivateDataSlotCreateFlags + { + }; + + using PrivateDataSlotCreateFlagBitsEXT = PrivateDataSlotCreateFlagBits; + + // wrapper using for bitmask VkPrivateDataSlotCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlotCreateFlags.html + using PrivateDataSlotCreateFlags = Flags; + using PrivateDataSlotCreateFlagsEXT = PrivateDataSlotCreateFlags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PrivateDataSlotCreateFlags allFlags = {}; + }; + + // wrapper class for enum VkPipelineStageFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlagBits2.html + enum class PipelineStageFlagBits2 : VkPipelineStageFlags2 + { + eNone = VK_PIPELINE_STAGE_2_NONE, + eTopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT, + eDrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT, + eVertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT, + eVertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT, + eTessellationControlShader = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT, + eTessellationEvaluationShader = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT, + eGeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT, + eFragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, + eEarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT, + eLateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT, + eColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, + eComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, + eAllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT, + eTransfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT, + eBottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT, + eHost = VK_PIPELINE_STAGE_2_HOST_BIT, + eAllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, + eAllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, + eCopy = VK_PIPELINE_STAGE_2_COPY_BIT, + eResolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT, + eBlit = VK_PIPELINE_STAGE_2_BLIT_BIT, + eClear = VK_PIPELINE_STAGE_2_CLEAR_BIT, + eIndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT, + eVertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT, + ePreRasterizationShaders = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT, + eVideoDecodeKHR = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR, + eVideoEncodeKHR = VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR, + eTransformFeedbackEXT = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, + eConditionalRenderingEXT = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, + eCommandPreprocessEXT = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT, + eCommandPreprocessNV = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV, + eFragmentShadingRateAttachmentKHR = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + eShadingRateImageNV = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, + eAccelerationStructureBuildKHR = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, + eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV, + eRayTracingShaderKHR = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR, + eRayTracingShaderNV = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV, + eFragmentDensityProcessEXT = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, + eTaskShaderEXT = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT, + eTaskShaderNV = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV, + eMeshShaderEXT = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT, + eMeshShaderNV = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV, + eSubpassShaderHUAWEI = VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI, + eSubpassShadingHUAWEI = VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, + eInvocationMaskHUAWEI = VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI, + eAccelerationStructureCopyKHR = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR, + eMicromapBuildEXT = VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT, + eClusterCullingShaderHUAWEI = VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI, + eOpticalFlowNV = VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV, + eConvertCooperativeVectorMatrixNV = VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV, + eDataGraphARM = VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM, + eCopyIndirectKHR = VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR, + eMemoryDecompressionEXT = VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT + }; + + using PipelineStageFlagBits2KHR = PipelineStageFlagBits2; + + // wrapper using for bitmask VkPipelineStageFlags2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlags2.html + using PipelineStageFlags2 = Flags; + using PipelineStageFlags2KHR = PipelineStageFlags2; + + template <> + struct FlagTraits + { + using WrappedType = VkPipelineStageFlagBits2; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineStageFlags2 allFlags = + PipelineStageFlagBits2::eNone | PipelineStageFlagBits2::eTopOfPipe | PipelineStageFlagBits2::eDrawIndirect | PipelineStageFlagBits2::eVertexInput | + PipelineStageFlagBits2::eVertexShader | PipelineStageFlagBits2::eTessellationControlShader | PipelineStageFlagBits2::eTessellationEvaluationShader | + PipelineStageFlagBits2::eGeometryShader | PipelineStageFlagBits2::eFragmentShader | PipelineStageFlagBits2::eEarlyFragmentTests | + PipelineStageFlagBits2::eLateFragmentTests | PipelineStageFlagBits2::eColorAttachmentOutput | PipelineStageFlagBits2::eComputeShader | + PipelineStageFlagBits2::eAllTransfer | PipelineStageFlagBits2::eBottomOfPipe | PipelineStageFlagBits2::eHost | PipelineStageFlagBits2::eAllGraphics | + PipelineStageFlagBits2::eAllCommands | PipelineStageFlagBits2::eCopy | PipelineStageFlagBits2::eResolve | PipelineStageFlagBits2::eBlit | + PipelineStageFlagBits2::eClear | PipelineStageFlagBits2::eIndexInput | PipelineStageFlagBits2::eVertexAttributeInput | + PipelineStageFlagBits2::ePreRasterizationShaders | PipelineStageFlagBits2::eVideoDecodeKHR | PipelineStageFlagBits2::eVideoEncodeKHR | + PipelineStageFlagBits2::eTransformFeedbackEXT | PipelineStageFlagBits2::eConditionalRenderingEXT | PipelineStageFlagBits2::eCommandPreprocessEXT | + PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR | PipelineStageFlagBits2::eAccelerationStructureBuildKHR | + PipelineStageFlagBits2::eRayTracingShaderKHR | PipelineStageFlagBits2::eFragmentDensityProcessEXT | PipelineStageFlagBits2::eTaskShaderEXT | + PipelineStageFlagBits2::eMeshShaderEXT | PipelineStageFlagBits2::eSubpassShaderHUAWEI | PipelineStageFlagBits2::eInvocationMaskHUAWEI | + PipelineStageFlagBits2::eAccelerationStructureCopyKHR | PipelineStageFlagBits2::eMicromapBuildEXT | PipelineStageFlagBits2::eClusterCullingShaderHUAWEI | + PipelineStageFlagBits2::eOpticalFlowNV | PipelineStageFlagBits2::eConvertCooperativeVectorMatrixNV | PipelineStageFlagBits2::eDataGraphARM | + PipelineStageFlagBits2::eCopyIndirectKHR | PipelineStageFlagBits2::eMemoryDecompressionEXT; + }; + + // wrapper class for enum VkAccessFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits2.html + enum class AccessFlagBits2 : VkAccessFlags2 + { + eNone = VK_ACCESS_2_NONE, + eIndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT, + eIndexRead = VK_ACCESS_2_INDEX_READ_BIT, + eVertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT, + eUniformRead = VK_ACCESS_2_UNIFORM_READ_BIT, + eInputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT, + eShaderRead = VK_ACCESS_2_SHADER_READ_BIT, + eShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT, + eColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT, + eColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, + eDepthStencilAttachmentRead = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT, + eDepthStencilAttachmentWrite = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, + eTransferRead = VK_ACCESS_2_TRANSFER_READ_BIT, + eTransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT, + eHostRead = VK_ACCESS_2_HOST_READ_BIT, + eHostWrite = VK_ACCESS_2_HOST_WRITE_BIT, + eMemoryRead = VK_ACCESS_2_MEMORY_READ_BIT, + eMemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT, + eShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT, + eShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT, + eShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT, + eVideoDecodeReadKHR = VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR, + eVideoDecodeWriteKHR = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR, + eSamplerHeapReadEXT = VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT, + eResourceHeapReadEXT = VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT, + eVideoEncodeReadKHR = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR, + eVideoEncodeWriteKHR = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR, + eShaderTileAttachmentReadQCOM = VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM, + eShaderTileAttachmentWriteQCOM = VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM, + eTransformFeedbackWriteEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, + eTransformFeedbackCounterReadEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, + eTransformFeedbackCounterWriteEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, + eConditionalRenderingReadEXT = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, + eCommandPreprocessReadEXT = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT, + eCommandPreprocessReadNV = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, + eCommandPreprocessWriteEXT = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT, + eCommandPreprocessWriteNV = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, + eFragmentShadingRateAttachmentReadKHR = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, + eShadingRateImageReadNV = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV, + eAccelerationStructureReadKHR = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, + eAccelerationStructureReadNV = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV, + eAccelerationStructureWriteKHR = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, + eAccelerationStructureWriteNV = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV, + eFragmentDensityMapReadEXT = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, + eColorAttachmentReadNoncoherentEXT = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, + eDescriptorBufferReadEXT = VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT, + eInvocationMaskReadHUAWEI = VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI, + eShaderBindingTableReadKHR = VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR, + eMicromapReadEXT = VK_ACCESS_2_MICROMAP_READ_BIT_EXT, + eMicromapWriteEXT = VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT, + eOpticalFlowReadNV = VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV, + eOpticalFlowWriteNV = VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV, + eDataGraphReadARM = VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM, + eDataGraphWriteARM = VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM, + eMemoryDecompressionReadEXT = VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT, + eMemoryDecompressionWriteEXT = VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT + }; + + using AccessFlagBits2KHR = AccessFlagBits2; + + // wrapper using for bitmask VkAccessFlags2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlags2.html + using AccessFlags2 = Flags; + using AccessFlags2KHR = AccessFlags2; + + template <> + struct FlagTraits + { + using WrappedType = VkAccessFlagBits2; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags2 allFlags = + AccessFlagBits2::eNone | AccessFlagBits2::eIndirectCommandRead | AccessFlagBits2::eIndexRead | AccessFlagBits2::eVertexAttributeRead | + AccessFlagBits2::eUniformRead | AccessFlagBits2::eInputAttachmentRead | AccessFlagBits2::eShaderRead | AccessFlagBits2::eShaderWrite | + AccessFlagBits2::eColorAttachmentRead | AccessFlagBits2::eColorAttachmentWrite | AccessFlagBits2::eDepthStencilAttachmentRead | + AccessFlagBits2::eDepthStencilAttachmentWrite | AccessFlagBits2::eTransferRead | AccessFlagBits2::eTransferWrite | AccessFlagBits2::eHostRead | + AccessFlagBits2::eHostWrite | AccessFlagBits2::eMemoryRead | AccessFlagBits2::eMemoryWrite | AccessFlagBits2::eShaderSampledRead | + AccessFlagBits2::eShaderStorageRead | AccessFlagBits2::eShaderStorageWrite | AccessFlagBits2::eVideoDecodeReadKHR | + AccessFlagBits2::eVideoDecodeWriteKHR | AccessFlagBits2::eSamplerHeapReadEXT | AccessFlagBits2::eResourceHeapReadEXT | + AccessFlagBits2::eVideoEncodeReadKHR | AccessFlagBits2::eVideoEncodeWriteKHR | AccessFlagBits2::eShaderTileAttachmentReadQCOM | + AccessFlagBits2::eShaderTileAttachmentWriteQCOM | AccessFlagBits2::eTransformFeedbackWriteEXT | AccessFlagBits2::eTransformFeedbackCounterReadEXT | + AccessFlagBits2::eTransformFeedbackCounterWriteEXT | AccessFlagBits2::eConditionalRenderingReadEXT | AccessFlagBits2::eCommandPreprocessReadEXT | + AccessFlagBits2::eCommandPreprocessWriteEXT | AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR | AccessFlagBits2::eAccelerationStructureReadKHR | + AccessFlagBits2::eAccelerationStructureWriteKHR | AccessFlagBits2::eFragmentDensityMapReadEXT | AccessFlagBits2::eColorAttachmentReadNoncoherentEXT | + AccessFlagBits2::eDescriptorBufferReadEXT | AccessFlagBits2::eInvocationMaskReadHUAWEI | AccessFlagBits2::eShaderBindingTableReadKHR | + AccessFlagBits2::eMicromapReadEXT | AccessFlagBits2::eMicromapWriteEXT | AccessFlagBits2::eOpticalFlowReadNV | AccessFlagBits2::eOpticalFlowWriteNV | + AccessFlagBits2::eDataGraphReadARM | AccessFlagBits2::eDataGraphWriteARM | AccessFlagBits2::eMemoryDecompressionReadEXT | + AccessFlagBits2::eMemoryDecompressionWriteEXT; + }; + + // wrapper class for enum VkSubmitFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitFlagBits.html + enum class SubmitFlagBits : VkSubmitFlags + { + eProtected = VK_SUBMIT_PROTECTED_BIT + }; + + using SubmitFlagBitsKHR = SubmitFlagBits; + + // wrapper using for bitmask VkSubmitFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitFlags.html + using SubmitFlags = Flags; + using SubmitFlagsKHR = SubmitFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkSubmitFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SubmitFlags allFlags = SubmitFlagBits::eProtected; + }; + + // wrapper class for enum VkFormatFeatureFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlagBits2.html + enum class FormatFeatureFlagBits2 : VkFormatFeatureFlags2 + { + eSampledImage = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT, + eStorageImage = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT, + eStorageImageAtomic = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT, + eUniformTexelBuffer = VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT, + eStorageTexelBuffer = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT, + eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, + eVertexBuffer = VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT, + eColorAttachment = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT, + eColorAttachmentBlend = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT, + eDepthStencilAttachment = VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT, + eBlitSrc = VK_FORMAT_FEATURE_2_BLIT_SRC_BIT, + eBlitDst = VK_FORMAT_FEATURE_2_BLIT_DST_BIT, + eSampledImageFilterLinear = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT, + eTransferSrc = VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT, + eTransferDst = VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT, + eSampledImageFilterMinmax = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT, + eMidpointChromaSamples = VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT, + eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = + VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + eDisjoint = VK_FORMAT_FEATURE_2_DISJOINT_BIT, + eCositedChromaSamples = VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT, + eStorageReadWithoutFormat = VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT, + eStorageWriteWithoutFormat = VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT, + eSampledImageDepthComparison = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT, + eSampledImageFilterCubic = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT, + eSampledImageFilterCubicEXT = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, + eHostImageTransfer = VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT, + eHostImageTransferEXT = VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT, + eVideoDecodeOutputKHR = VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR, + eVideoDecodeDpbKHR = VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR, + eAccelerationStructureVertexBufferKHR = VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR, + eFragmentDensityMapEXT = VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT, + eFragmentShadingRateAttachmentKHR = VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + eVideoEncodeInputKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR, + eVideoEncodeDpbKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR, + eAccelerationStructureRadiusBufferNV = VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV, + eLinearColorAttachmentNV = VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV, + eWeightImageQCOM = VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM, + eWeightSampledImageQCOM = VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM, + eBlockMatchingQCOM = VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM, + eBoxFilterSampledQCOM = VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM, + eTensorShaderARM = VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM, + eTensorImageAliasingARM = VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM, + eOpticalFlowImageNV = VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV, + eOpticalFlowVectorNV = VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV, + eOpticalFlowCostNV = VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV, + eTensorDataGraphARM = VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM, + eCopyImageIndirectDstKHR = VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR, + eVideoEncodeQuantizationDeltaMapKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, + eVideoEncodeEmphasisMapKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR, + eDepthCopyOnComputeQueueKHR = VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR, + eDepthCopyOnTransferQueueKHR = VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR, + eStencilCopyOnComputeQueueKHR = VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR, + eStencilCopyOnTransferQueueKHR = VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR + }; + + using FormatFeatureFlagBits2KHR = FormatFeatureFlagBits2; + + // wrapper using for bitmask VkFormatFeatureFlags2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlags2.html + using FormatFeatureFlags2 = Flags; + using FormatFeatureFlags2KHR = FormatFeatureFlags2; + + template <> + struct FlagTraits + { + using WrappedType = VkFormatFeatureFlagBits2; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR FormatFeatureFlags2 allFlags = + FormatFeatureFlagBits2::eSampledImage | FormatFeatureFlagBits2::eStorageImage | FormatFeatureFlagBits2::eStorageImageAtomic | + FormatFeatureFlagBits2::eUniformTexelBuffer | FormatFeatureFlagBits2::eStorageTexelBuffer | FormatFeatureFlagBits2::eStorageTexelBufferAtomic | + FormatFeatureFlagBits2::eVertexBuffer | FormatFeatureFlagBits2::eColorAttachment | FormatFeatureFlagBits2::eColorAttachmentBlend | + FormatFeatureFlagBits2::eDepthStencilAttachment | FormatFeatureFlagBits2::eBlitSrc | FormatFeatureFlagBits2::eBlitDst | + FormatFeatureFlagBits2::eSampledImageFilterLinear | FormatFeatureFlagBits2::eTransferSrc | FormatFeatureFlagBits2::eTransferDst | + FormatFeatureFlagBits2::eSampledImageFilterMinmax | FormatFeatureFlagBits2::eMidpointChromaSamples | + FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter | FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter | + FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit | + FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable | FormatFeatureFlagBits2::eDisjoint | + FormatFeatureFlagBits2::eCositedChromaSamples | FormatFeatureFlagBits2::eStorageReadWithoutFormat | FormatFeatureFlagBits2::eStorageWriteWithoutFormat | + FormatFeatureFlagBits2::eSampledImageDepthComparison | FormatFeatureFlagBits2::eSampledImageFilterCubic | FormatFeatureFlagBits2::eHostImageTransfer | + FormatFeatureFlagBits2::eVideoDecodeOutputKHR | FormatFeatureFlagBits2::eVideoDecodeDpbKHR | + FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR | FormatFeatureFlagBits2::eFragmentDensityMapEXT | + FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR | FormatFeatureFlagBits2::eVideoEncodeInputKHR | FormatFeatureFlagBits2::eVideoEncodeDpbKHR | + FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV | FormatFeatureFlagBits2::eLinearColorAttachmentNV | + FormatFeatureFlagBits2::eWeightImageQCOM | FormatFeatureFlagBits2::eWeightSampledImageQCOM | FormatFeatureFlagBits2::eBlockMatchingQCOM | + FormatFeatureFlagBits2::eBoxFilterSampledQCOM | FormatFeatureFlagBits2::eTensorShaderARM | FormatFeatureFlagBits2::eTensorImageAliasingARM | + FormatFeatureFlagBits2::eOpticalFlowImageNV | FormatFeatureFlagBits2::eOpticalFlowVectorNV | FormatFeatureFlagBits2::eOpticalFlowCostNV | + FormatFeatureFlagBits2::eTensorDataGraphARM | FormatFeatureFlagBits2::eCopyImageIndirectDstKHR | + FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR | FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR | + FormatFeatureFlagBits2::eDepthCopyOnComputeQueueKHR | FormatFeatureFlagBits2::eDepthCopyOnTransferQueueKHR | + FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR | FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR; + }; + + // wrapper class for enum VkPipelineCreationFeedbackFlagBits, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreationFeedbackFlagBits.html + enum class PipelineCreationFeedbackFlagBits : VkPipelineCreationFeedbackFlags + { + eValid = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, + eApplicationPipelineCacheHit = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, + eBasePipelineAcceleration = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT + }; + + using PipelineCreationFeedbackFlagBitsEXT = PipelineCreationFeedbackFlagBits; + + // wrapper using for bitmask VkPipelineCreationFeedbackFlags, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreationFeedbackFlags.html + using PipelineCreationFeedbackFlags = Flags; + using PipelineCreationFeedbackFlagsEXT = PipelineCreationFeedbackFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkPipelineCreationFeedbackFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreationFeedbackFlags allFlags = PipelineCreationFeedbackFlagBits::eValid | + PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit | + PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration; + }; + + // wrapper class for enum VkRenderingFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFlagBits.html + enum class RenderingFlagBits : VkRenderingFlags + { + eContentsSecondaryCommandBuffers = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, + eSuspending = VK_RENDERING_SUSPENDING_BIT, + eResuming = VK_RENDERING_RESUMING_BIT, + eEnableLegacyDitheringEXT = VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT, + eContentsInlineKHR = VK_RENDERING_CONTENTS_INLINE_BIT_KHR, + eContentsInlineEXT = VK_RENDERING_CONTENTS_INLINE_BIT_EXT, + ePerLayerFragmentDensityVALVE = VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE, + eFragmentRegionEXT = VK_RENDERING_FRAGMENT_REGION_BIT_EXT, + eCustomResolveEXT = VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT, + eLocalReadConcurrentAccessControlKHR = VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR + }; + + using RenderingFlagBitsKHR = RenderingFlagBits; + + // wrapper using for bitmask VkRenderingFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFlags.html + using RenderingFlags = Flags; + using RenderingFlagsKHR = RenderingFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkRenderingFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR RenderingFlags allFlags = + RenderingFlagBits::eContentsSecondaryCommandBuffers | RenderingFlagBits::eSuspending | RenderingFlagBits::eResuming | + RenderingFlagBits::eEnableLegacyDitheringEXT | RenderingFlagBits::eContentsInlineKHR | RenderingFlagBits::ePerLayerFragmentDensityVALVE | + RenderingFlagBits::eFragmentRegionEXT | RenderingFlagBits::eCustomResolveEXT | RenderingFlagBits::eLocalReadConcurrentAccessControlKHR; + }; + + //=== VK_VERSION_1_4 === + + // wrapper class for enum VkQueueGlobalPriority, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueGlobalPriority.html + enum class QueueGlobalPriority + { + eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW, + eLowKHR = VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR, + eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, + eMediumKHR = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR, + eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH, + eHighKHR = VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR, + eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, + eRealtimeKHR = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR + }; + + using QueueGlobalPriorityEXT = QueueGlobalPriority; + using QueueGlobalPriorityKHR = QueueGlobalPriority; + + // wrapper class for enum VkMemoryUnmapFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryUnmapFlagBits.html + enum class MemoryUnmapFlagBits : VkMemoryUnmapFlags + { + eReserveEXT = VK_MEMORY_UNMAP_RESERVE_BIT_EXT + }; + + using MemoryUnmapFlagBitsKHR = MemoryUnmapFlagBits; + + // wrapper using for bitmask VkMemoryUnmapFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryUnmapFlags.html + using MemoryUnmapFlags = Flags; + using MemoryUnmapFlagsKHR = MemoryUnmapFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkMemoryUnmapFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryUnmapFlags allFlags = MemoryUnmapFlagBits::eReserveEXT; + }; + + // wrapper class for enum VkBufferUsageFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlagBits2.html + enum class BufferUsageFlagBits2 : VkBufferUsageFlags2 + { + eTransferSrc = VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT, + eTransferDst = VK_BUFFER_USAGE_2_TRANSFER_DST_BIT, + eUniformTexelBuffer = VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT, + eStorageTexelBuffer = VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT, + eUniformBuffer = VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT, + eStorageBuffer = VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT, + eIndexBuffer = VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT, + eVertexBuffer = VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT, + eIndirectBuffer = VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT, + eShaderDeviceAddress = VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eExecutionGraphScratchAMDX = VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eDescriptorHeapEXT = VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT, + eConditionalRenderingEXT = VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT, + eShaderBindingTableKHR = VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR, + eRayTracingNV = VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV, + eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT, + eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, + eVideoDecodeSrcKHR = VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR, + eVideoDecodeDstKHR = VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR, + eVideoEncodeDstKHR = VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR, + eVideoEncodeSrcKHR = VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR, + eAccelerationStructureBuildInputReadOnlyKHR = VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR, + eAccelerationStructureStorageKHR = VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR, + eSamplerDescriptorBufferEXT = VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT, + eResourceDescriptorBufferEXT = VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT, + ePushDescriptorsDescriptorBufferEXT = VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, + eMicromapBuildInputReadOnlyEXT = VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, + eMicromapStorageEXT = VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eCompressedDataDgf1AMDX = VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eDataGraphForeignDescriptorARM = VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM, + eTileMemoryQCOM = VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM, + eMemoryDecompressionEXT = VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT, + ePreprocessBufferEXT = VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT + }; + + using BufferUsageFlagBits2KHR = BufferUsageFlagBits2; + + // wrapper using for bitmask VkBufferUsageFlags2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlags2.html + using BufferUsageFlags2 = Flags; + using BufferUsageFlags2KHR = BufferUsageFlags2; + + template <> + struct FlagTraits + { + using WrappedType = VkBufferUsageFlagBits2; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR BufferUsageFlags2 allFlags = + BufferUsageFlagBits2::eTransferSrc | BufferUsageFlagBits2::eTransferDst | BufferUsageFlagBits2::eUniformTexelBuffer | + BufferUsageFlagBits2::eStorageTexelBuffer | BufferUsageFlagBits2::eUniformBuffer | BufferUsageFlagBits2::eStorageBuffer | + BufferUsageFlagBits2::eIndexBuffer | BufferUsageFlagBits2::eVertexBuffer | BufferUsageFlagBits2::eIndirectBuffer | + BufferUsageFlagBits2::eShaderDeviceAddress +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | BufferUsageFlagBits2::eExecutionGraphScratchAMDX +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | BufferUsageFlagBits2::eDescriptorHeapEXT | BufferUsageFlagBits2::eConditionalRenderingEXT | BufferUsageFlagBits2::eShaderBindingTableKHR | + BufferUsageFlagBits2::eTransformFeedbackBufferEXT | BufferUsageFlagBits2::eTransformFeedbackCounterBufferEXT | BufferUsageFlagBits2::eVideoDecodeSrcKHR | + BufferUsageFlagBits2::eVideoDecodeDstKHR | BufferUsageFlagBits2::eVideoEncodeDstKHR | BufferUsageFlagBits2::eVideoEncodeSrcKHR | + BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR | BufferUsageFlagBits2::eAccelerationStructureStorageKHR | + BufferUsageFlagBits2::eSamplerDescriptorBufferEXT | BufferUsageFlagBits2::eResourceDescriptorBufferEXT | + BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT | BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT | + BufferUsageFlagBits2::eMicromapStorageEXT +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | BufferUsageFlagBits2::eCompressedDataDgf1AMDX +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | BufferUsageFlagBits2::eDataGraphForeignDescriptorARM | BufferUsageFlagBits2::eTileMemoryQCOM | BufferUsageFlagBits2::eMemoryDecompressionEXT | + BufferUsageFlagBits2::ePreprocessBufferEXT; + }; + + // wrapper class for enum VkHostImageCopyFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostImageCopyFlagBits.html + enum class HostImageCopyFlagBits : VkHostImageCopyFlags + { + eMemcpy = VK_HOST_IMAGE_COPY_MEMCPY_BIT + }; + + using HostImageCopyFlagBitsEXT = HostImageCopyFlagBits; + + // wrapper using for bitmask VkHostImageCopyFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostImageCopyFlags.html + using HostImageCopyFlags = Flags; + using HostImageCopyFlagsEXT = HostImageCopyFlags; + + template <> + struct FlagTraits + { + using WrappedType = VkHostImageCopyFlagBits; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR HostImageCopyFlags allFlags = HostImageCopyFlagBits::eMemcpy; + }; + + // wrapper class for enum VkPipelineCreateFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlagBits2.html + enum class PipelineCreateFlagBits2 : VkPipelineCreateFlags2 + { + eDisableOptimization = VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT, + eAllowDerivatives = VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT, + eDerivative = VK_PIPELINE_CREATE_2_DERIVATIVE_BIT, + eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + eDispatchBase = VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT, + eFailOnPipelineCompileRequired = VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, + eEarlyReturnOnFailure = VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT, + eNoProtectedAccess = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT, + eNoProtectedAccessEXT = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT, + eProtectedAccessOnly = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT, + eProtectedAccessOnlyEXT = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eExecutionGraphAMDX = VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eDescriptorHeapEXT = VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, + eRayTracingAllowSpheresAndLinearSweptSpheresNV = VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV, + eEnableLegacyDitheringEXT = VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, + eDeferCompileNV = VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV, + eCaptureStatisticsKHR = VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR, + eCaptureInternalRepresentationsKHR = VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, + eLinkTimeOptimizationEXT = VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT, + eRetainLinkTimeOptimizationInfoEXT = VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT, + eLibraryKHR = VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR, + eRayTracingSkipTrianglesKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR, + eRayTracingSkipBuiltInPrimitives = VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR, + eRayTracingSkipAabbsKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR, + eRayTracingNoNullAnyHitShadersKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, + eRayTracingNoNullClosestHitShadersKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, + eRayTracingNoNullMissShadersKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR, + eRayTracingNoNullIntersectionShadersKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, + eRayTracingShaderGroupHandleCaptureReplayKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR, + eIndirectBindableNV = VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV, + eRayTracingAllowMotionNV = VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV, + eRenderingFragmentShadingRateAttachmentKHR = VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + eRenderingFragmentDensityMapAttachmentEXT = VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, + eRayTracingOpacityMicromapEXT = VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT, + eColorAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, + eDepthStencilAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, + eRayTracingDisplacementMicromapNV = VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV, + eDescriptorBufferEXT = VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT, + eDisallowOpacityMicromapARM = VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM, + eCaptureDataKHR = VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR, + eIndirectBindableEXT = VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT, + ePerLayerFragmentDensityVALVE = VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE, + e64BitIndexingEXT = VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT + }; + + using PipelineCreateFlagBits2KHR = PipelineCreateFlagBits2; + + // wrapper using for bitmask VkPipelineCreateFlags2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlags2.html + using PipelineCreateFlags2 = Flags; + using PipelineCreateFlags2KHR = PipelineCreateFlags2; + + template <> + struct FlagTraits + { + using WrappedType = VkPipelineCreateFlagBits2; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreateFlags2 allFlags = + PipelineCreateFlagBits2::eDisableOptimization | PipelineCreateFlagBits2::eAllowDerivatives | PipelineCreateFlagBits2::eDerivative | + PipelineCreateFlagBits2::eViewIndexFromDeviceIndex | PipelineCreateFlagBits2::eDispatchBase | PipelineCreateFlagBits2::eFailOnPipelineCompileRequired | + PipelineCreateFlagBits2::eEarlyReturnOnFailure | PipelineCreateFlagBits2::eNoProtectedAccess | PipelineCreateFlagBits2::eProtectedAccessOnly +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | PipelineCreateFlagBits2::eExecutionGraphAMDX +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | PipelineCreateFlagBits2::eDescriptorHeapEXT | PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV | + PipelineCreateFlagBits2::eEnableLegacyDitheringEXT | PipelineCreateFlagBits2::eDeferCompileNV | PipelineCreateFlagBits2::eCaptureStatisticsKHR | + PipelineCreateFlagBits2::eCaptureInternalRepresentationsKHR | PipelineCreateFlagBits2::eLinkTimeOptimizationEXT | + PipelineCreateFlagBits2::eRetainLinkTimeOptimizationInfoEXT | PipelineCreateFlagBits2::eLibraryKHR | + PipelineCreateFlagBits2::eRayTracingSkipTrianglesKHR | PipelineCreateFlagBits2::eRayTracingSkipAabbsKHR | + PipelineCreateFlagBits2::eRayTracingNoNullAnyHitShadersKHR | PipelineCreateFlagBits2::eRayTracingNoNullClosestHitShadersKHR | + PipelineCreateFlagBits2::eRayTracingNoNullMissShadersKHR | PipelineCreateFlagBits2::eRayTracingNoNullIntersectionShadersKHR | + PipelineCreateFlagBits2::eRayTracingShaderGroupHandleCaptureReplayKHR | PipelineCreateFlagBits2::eIndirectBindableNV | + PipelineCreateFlagBits2::eRayTracingAllowMotionNV | PipelineCreateFlagBits2::eRenderingFragmentShadingRateAttachmentKHR | + PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT | PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT | + PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT | + PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV | PipelineCreateFlagBits2::eDescriptorBufferEXT | + PipelineCreateFlagBits2::eDisallowOpacityMicromapARM | PipelineCreateFlagBits2::eCaptureDataKHR | PipelineCreateFlagBits2::eIndirectBindableEXT | + PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE | PipelineCreateFlagBits2::e64BitIndexingEXT; + }; + + // wrapper class for enum VkPipelineRobustnessBufferBehavior, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRobustnessBufferBehavior.html + enum class PipelineRobustnessBufferBehavior + { + eDeviceDefault = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT, + eDisabled = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED, + eRobustBufferAccess = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS, + eRobustBufferAccess2 = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 + }; + + using PipelineRobustnessBufferBehaviorEXT = PipelineRobustnessBufferBehavior; + + // wrapper class for enum VkPipelineRobustnessImageBehavior, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRobustnessImageBehavior.html + enum class PipelineRobustnessImageBehavior + { + eDeviceDefault = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT, + eDisabled = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED, + eRobustImageAccess = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS, + eRobustImageAccess2 = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2 + }; + + using PipelineRobustnessImageBehaviorEXT = PipelineRobustnessImageBehavior; + + // wrapper class for enum VkLineRasterizationMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLineRasterizationMode.html + enum class LineRasterizationMode + { + eDefault = VK_LINE_RASTERIZATION_MODE_DEFAULT, + eDefaultKHR = VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR, + eRectangular = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, + eRectangularKHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR, + eBresenham = VK_LINE_RASTERIZATION_MODE_BRESENHAM, + eBresenhamKHR = VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR, + eRectangularSmooth = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, + eRectangularSmoothKHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR + }; + + using LineRasterizationModeEXT = LineRasterizationMode; + using LineRasterizationModeKHR = LineRasterizationMode; + + //=== VK_KHR_surface === + + // wrapper class for enum VkSurfaceTransformFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceTransformFlagBitsKHR.html + enum class SurfaceTransformFlagBitsKHR : VkSurfaceTransformFlagsKHR + { + eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, + eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, + eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, + eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, + eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR, + eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR, + eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR, + eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR, + eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR + }; + + // wrapper using for bitmask VkSurfaceTransformFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceTransformFlagsKHR.html + using SurfaceTransformFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkSurfaceTransformFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceTransformFlagsKHR allFlags = + SurfaceTransformFlagBitsKHR::eIdentity | SurfaceTransformFlagBitsKHR::eRotate90 | SurfaceTransformFlagBitsKHR::eRotate180 | + SurfaceTransformFlagBitsKHR::eRotate270 | SurfaceTransformFlagBitsKHR::eHorizontalMirror | SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 | + SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 | SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 | SurfaceTransformFlagBitsKHR::eInherit; + }; + + // wrapper class for enum VkPresentModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentModeKHR.html + enum class PresentModeKHR + { + eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR, + eMailbox = VK_PRESENT_MODE_MAILBOX_KHR, + eFifo = VK_PRESENT_MODE_FIFO_KHR, + eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR, + eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, + eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, + eFifoLatestReady = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR, + eFifoLatestReadyEXT = VK_PRESENT_MODE_FIFO_LATEST_READY_EXT + }; + + // wrapper class for enum VkColorSpaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorSpaceKHR.html + enum class ColorSpaceKHR + { + eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + eVkColorspaceSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR, + eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, + eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, + eDisplayP3LinearEXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, + eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, + eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, + eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT, + eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT, + eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT, + eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT, + eDolbyvisionEXT VULKAN_HPP_DEPRECATED_17( "eDolbyvisionEXT is deprecated, but no reason was given in the API XML" ) = VK_COLOR_SPACE_DOLBYVISION_EXT, + eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT, + eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, + eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, + ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT, + eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT, + eDisplayNativeAMD = VK_COLOR_SPACE_DISPLAY_NATIVE_AMD + }; + + // wrapper class for enum VkCompositeAlphaFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompositeAlphaFlagBitsKHR.html + enum class CompositeAlphaFlagBitsKHR : VkCompositeAlphaFlagsKHR + { + eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, + ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR, + ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, + eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR + }; + + // wrapper using for bitmask VkCompositeAlphaFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompositeAlphaFlagsKHR.html + using CompositeAlphaFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkCompositeAlphaFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR CompositeAlphaFlagsKHR allFlags = CompositeAlphaFlagBitsKHR::eOpaque | CompositeAlphaFlagBitsKHR::ePreMultiplied | + CompositeAlphaFlagBitsKHR::ePostMultiplied | CompositeAlphaFlagBitsKHR::eInherit; + }; + + //=== VK_KHR_swapchain === + + // wrapper class for enum VkSwapchainCreateFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCreateFlagBitsKHR.html + enum class SwapchainCreateFlagBitsKHR : VkSwapchainCreateFlagsKHR + { + eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, + eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR, + eMutableFormat = VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR, + ePresentTimingEXT = VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT, + ePresentId2 = VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR, + ePresentWait2 = VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR, + eDeferredMemoryAllocation = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, + eDeferredMemoryAllocationEXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT + }; + + // wrapper using for bitmask VkSwapchainCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCreateFlagsKHR.html + using SwapchainCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkSwapchainCreateFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SwapchainCreateFlagsKHR allFlags = + SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions | SwapchainCreateFlagBitsKHR::eProtected | SwapchainCreateFlagBitsKHR::eMutableFormat | + SwapchainCreateFlagBitsKHR::ePresentTimingEXT | SwapchainCreateFlagBitsKHR::ePresentId2 | SwapchainCreateFlagBitsKHR::ePresentWait2 | + SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocation; + }; + + // wrapper class for enum VkDeviceGroupPresentModeFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html + enum class DeviceGroupPresentModeFlagBitsKHR : VkDeviceGroupPresentModeFlagsKHR + { + eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, + eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, + eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, + eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR + }; + + // wrapper using for bitmask VkDeviceGroupPresentModeFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupPresentModeFlagsKHR.html + using DeviceGroupPresentModeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDeviceGroupPresentModeFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceGroupPresentModeFlagsKHR allFlags = + DeviceGroupPresentModeFlagBitsKHR::eLocal | DeviceGroupPresentModeFlagBitsKHR::eRemote | DeviceGroupPresentModeFlagBitsKHR::eSum | + DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice; + }; + + //=== VK_KHR_display === + + // wrapper class for enum VkDisplayPlaneAlphaFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html + enum class DisplayPlaneAlphaFlagBitsKHR : VkDisplayPlaneAlphaFlagsKHR + { + eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR, + eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR, + ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR, + ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR + }; + + // wrapper using for bitmask VkDisplayPlaneAlphaFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneAlphaFlagsKHR.html + using DisplayPlaneAlphaFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDisplayPlaneAlphaFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DisplayPlaneAlphaFlagsKHR allFlags = DisplayPlaneAlphaFlagBitsKHR::eOpaque | DisplayPlaneAlphaFlagBitsKHR::eGlobal | + DisplayPlaneAlphaFlagBitsKHR::ePerPixel | + DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied; + }; + + enum class DisplayModeCreateFlagBitsKHR : VkDisplayModeCreateFlagsKHR + { + }; + + // wrapper using for bitmask VkDisplayModeCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeCreateFlagsKHR.html + using DisplayModeCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DisplayModeCreateFlagsKHR allFlags = {}; + }; + + enum class DisplaySurfaceCreateFlagBitsKHR : VkDisplaySurfaceCreateFlagsKHR + { + }; + + // wrapper using for bitmask VkDisplaySurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplaySurfaceCreateFlagsKHR.html + using DisplaySurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DisplaySurfaceCreateFlagsKHR allFlags = {}; + }; + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + enum class XlibSurfaceCreateFlagBitsKHR : VkXlibSurfaceCreateFlagsKHR + { + }; + + // wrapper using for bitmask VkXlibSurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXlibSurfaceCreateFlagsKHR.html + using XlibSurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR XlibSurfaceCreateFlagsKHR allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + enum class XcbSurfaceCreateFlagBitsKHR : VkXcbSurfaceCreateFlagsKHR + { + }; + + // wrapper using for bitmask VkXcbSurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXcbSurfaceCreateFlagsKHR.html + using XcbSurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR XcbSurfaceCreateFlagsKHR allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + enum class WaylandSurfaceCreateFlagBitsKHR : VkWaylandSurfaceCreateFlagsKHR + { + }; + + // wrapper using for bitmask VkWaylandSurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWaylandSurfaceCreateFlagsKHR.html + using WaylandSurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR WaylandSurfaceCreateFlagsKHR allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + enum class AndroidSurfaceCreateFlagBitsKHR : VkAndroidSurfaceCreateFlagsKHR + { + }; + + // wrapper using for bitmask VkAndroidSurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidSurfaceCreateFlagsKHR.html + using AndroidSurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AndroidSurfaceCreateFlagsKHR allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + enum class Win32SurfaceCreateFlagBitsKHR : VkWin32SurfaceCreateFlagsKHR + { + }; + + // wrapper using for bitmask VkWin32SurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWin32SurfaceCreateFlagsKHR.html + using Win32SurfaceCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR Win32SurfaceCreateFlagsKHR allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + + // wrapper class for enum VkDebugReportFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportFlagBitsEXT.html + enum class DebugReportFlagBitsEXT : VkDebugReportFlagsEXT + { + eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT, + eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT, + ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, + eError = VK_DEBUG_REPORT_ERROR_BIT_EXT, + eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT + }; + + // wrapper using for bitmask VkDebugReportFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportFlagsEXT.html + using DebugReportFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDebugReportFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportFlagsEXT allFlags = DebugReportFlagBitsEXT::eInformation | DebugReportFlagBitsEXT::eWarning | + DebugReportFlagBitsEXT::ePerformanceWarning | DebugReportFlagBitsEXT::eError | + DebugReportFlagBitsEXT::eDebug; + }; + + // wrapper class for enum VkDebugReportObjectTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportObjectTypeEXT.html + enum class DebugReportObjectTypeEXT + { + eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, + eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, + ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, + eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, + eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, + eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, + eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, + eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, + eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, + eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, + eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, + eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, + eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, + eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, + eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, + eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, + ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, + ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, + eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, + ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, + eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, + eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, + eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, + eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, + eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, + eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, + eSurfaceKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, + eSwapchainKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, + eDebugReportCallbackEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, + eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, + eDisplayKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, + eDisplayModeKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, + eValidationCacheEXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, + eValidationCache = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT, + eSamplerYcbcrConversion = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, + eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT, + eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, + eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT, + eCuModuleNVX = VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT, + eCuFunctionNVX = VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT, + eAccelerationStructureKHR = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT, + eAccelerationStructureNV = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eCudaModuleNV = VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT, + eCudaFunctionNV = VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ +#if defined( VK_USE_PLATFORM_FUCHSIA ) + eBufferCollectionFUCHSIA = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + }; + + //=== VK_AMD_rasterization_order === + + // wrapper class for enum VkRasterizationOrderAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRasterizationOrderAMD.html + enum class RasterizationOrderAMD + { + eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD, + eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD + }; + + //=== VK_KHR_video_queue === + + // wrapper class for enum VkVideoCodecOperationFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodecOperationFlagBitsKHR.html + enum class VideoCodecOperationFlagBitsKHR : VkVideoCodecOperationFlagsKHR + { + eNone = VK_VIDEO_CODEC_OPERATION_NONE_KHR, + eEncodeH264 = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, + eEncodeH265 = VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, + eDecodeH264 = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, + eDecodeH265 = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, + eDecodeAv1 = VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, + eEncodeAv1 = VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR, + eDecodeVp9 = VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR + }; + + // wrapper using for bitmask VkVideoCodecOperationFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodecOperationFlagsKHR.html + using VideoCodecOperationFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoCodecOperationFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodecOperationFlagsKHR allFlags = + VideoCodecOperationFlagBitsKHR::eNone | VideoCodecOperationFlagBitsKHR::eEncodeH264 | VideoCodecOperationFlagBitsKHR::eEncodeH265 | + VideoCodecOperationFlagBitsKHR::eDecodeH264 | VideoCodecOperationFlagBitsKHR::eDecodeH265 | VideoCodecOperationFlagBitsKHR::eDecodeAv1 | + VideoCodecOperationFlagBitsKHR::eEncodeAv1 | VideoCodecOperationFlagBitsKHR::eDecodeVp9; + }; + + // wrapper class for enum VkVideoChromaSubsamplingFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html + enum class VideoChromaSubsamplingFlagBitsKHR : VkVideoChromaSubsamplingFlagsKHR + { + eInvalid = VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR, + eMonochrome = VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR, + e420 = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, + e422 = VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR, + e444 = VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR + }; + + // wrapper using for bitmask VkVideoChromaSubsamplingFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoChromaSubsamplingFlagsKHR.html + using VideoChromaSubsamplingFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoChromaSubsamplingFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoChromaSubsamplingFlagsKHR allFlags = + VideoChromaSubsamplingFlagBitsKHR::eInvalid | VideoChromaSubsamplingFlagBitsKHR::eMonochrome | VideoChromaSubsamplingFlagBitsKHR::e420 | + VideoChromaSubsamplingFlagBitsKHR::e422 | VideoChromaSubsamplingFlagBitsKHR::e444; + }; + + // wrapper class for enum VkVideoComponentBitDepthFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoComponentBitDepthFlagBitsKHR.html + enum class VideoComponentBitDepthFlagBitsKHR : VkVideoComponentBitDepthFlagsKHR + { + eInvalid = VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR, + e8 = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, + e10 = VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR, + e12 = VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR + }; + + // wrapper using for bitmask VkVideoComponentBitDepthFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoComponentBitDepthFlagsKHR.html + using VideoComponentBitDepthFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoComponentBitDepthFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoComponentBitDepthFlagsKHR allFlags = + VideoComponentBitDepthFlagBitsKHR::eInvalid | VideoComponentBitDepthFlagBitsKHR::e8 | VideoComponentBitDepthFlagBitsKHR::e10 | + VideoComponentBitDepthFlagBitsKHR::e12; + }; + + // wrapper class for enum VkVideoCapabilityFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCapabilityFlagBitsKHR.html + enum class VideoCapabilityFlagBitsKHR : VkVideoCapabilityFlagsKHR + { + eProtectedContent = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR, + eSeparateReferenceImages = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR + }; + + // wrapper using for bitmask VkVideoCapabilityFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCapabilityFlagsKHR.html + using VideoCapabilityFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoCapabilityFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCapabilityFlagsKHR allFlags = + VideoCapabilityFlagBitsKHR::eProtectedContent | VideoCapabilityFlagBitsKHR::eSeparateReferenceImages; + }; + + // wrapper class for enum VkVideoSessionCreateFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionCreateFlagBitsKHR.html + enum class VideoSessionCreateFlagBitsKHR : VkVideoSessionCreateFlagsKHR + { + eProtectedContent = VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR, + eAllowEncodeParameterOptimizations = VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR, + eInlineQueries = VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, + eAllowEncodeQuantizationDeltaMap = VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, + eAllowEncodeEmphasisMap = VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR, + eInlineSessionParameters = VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR + }; + + // wrapper using for bitmask VkVideoSessionCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionCreateFlagsKHR.html + using VideoSessionCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoSessionCreateFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionCreateFlagsKHR allFlags = + VideoSessionCreateFlagBitsKHR::eProtectedContent | VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations | + VideoSessionCreateFlagBitsKHR::eInlineQueries | VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap | + VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap | VideoSessionCreateFlagBitsKHR::eInlineSessionParameters; + }; + + // wrapper class for enum VkVideoCodingControlFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodingControlFlagBitsKHR.html + enum class VideoCodingControlFlagBitsKHR : VkVideoCodingControlFlagsKHR + { + eReset = VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR, + eEncodeRateControl = VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR, + eEncodeQualityLevel = VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR + }; + + // wrapper using for bitmask VkVideoCodingControlFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodingControlFlagsKHR.html + using VideoCodingControlFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoCodingControlFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodingControlFlagsKHR allFlags = + VideoCodingControlFlagBitsKHR::eReset | VideoCodingControlFlagBitsKHR::eEncodeRateControl | VideoCodingControlFlagBitsKHR::eEncodeQualityLevel; + }; + + // wrapper class for enum VkQueryResultStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryResultStatusKHR.html + enum class QueryResultStatusKHR + { + eError = VK_QUERY_RESULT_STATUS_ERROR_KHR, + eNotReady = VK_QUERY_RESULT_STATUS_NOT_READY_KHR, + eComplete = VK_QUERY_RESULT_STATUS_COMPLETE_KHR, + eInsufficientBitstreamBufferRange = VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR + }; + + // wrapper class for enum VkVideoSessionParametersCreateFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersCreateFlagBitsKHR.html + enum class VideoSessionParametersCreateFlagBitsKHR : VkVideoSessionParametersCreateFlagsKHR + { + eQuantizationMapCompatible = VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR + }; + + // wrapper using for bitmask VkVideoSessionParametersCreateFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersCreateFlagsKHR.html + using VideoSessionParametersCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoSessionParametersCreateFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionParametersCreateFlagsKHR allFlags = VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible; + }; + + enum class VideoBeginCodingFlagBitsKHR : VkVideoBeginCodingFlagsKHR + { + }; + + // wrapper using for bitmask VkVideoBeginCodingFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoBeginCodingFlagsKHR.html + using VideoBeginCodingFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoBeginCodingFlagsKHR allFlags = {}; + }; + + enum class VideoEndCodingFlagBitsKHR : VkVideoEndCodingFlagsKHR + { + }; + + // wrapper using for bitmask VkVideoEndCodingFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEndCodingFlagsKHR.html + using VideoEndCodingFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEndCodingFlagsKHR allFlags = {}; + }; + + //=== VK_KHR_video_decode_queue === + + // wrapper class for enum VkVideoDecodeCapabilityFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeCapabilityFlagBitsKHR.html + enum class VideoDecodeCapabilityFlagBitsKHR : VkVideoDecodeCapabilityFlagsKHR + { + eDpbAndOutputCoincide = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR, + eDpbAndOutputDistinct = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR + }; + + // wrapper using for bitmask VkVideoDecodeCapabilityFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeCapabilityFlagsKHR.html + using VideoDecodeCapabilityFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoDecodeCapabilityFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeCapabilityFlagsKHR allFlags = + VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide | VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct; + }; + + // wrapper class for enum VkVideoDecodeUsageFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeUsageFlagBitsKHR.html + enum class VideoDecodeUsageFlagBitsKHR : VkVideoDecodeUsageFlagsKHR + { + eDefault = VK_VIDEO_DECODE_USAGE_DEFAULT_KHR, + eTranscoding = VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR, + eOffline = VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR, + eStreaming = VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR + }; + + // wrapper using for bitmask VkVideoDecodeUsageFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeUsageFlagsKHR.html + using VideoDecodeUsageFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoDecodeUsageFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeUsageFlagsKHR allFlags = VideoDecodeUsageFlagBitsKHR::eDefault | VideoDecodeUsageFlagBitsKHR::eTranscoding | + VideoDecodeUsageFlagBitsKHR::eOffline | VideoDecodeUsageFlagBitsKHR::eStreaming; + }; + + enum class VideoDecodeFlagBitsKHR : VkVideoDecodeFlagsKHR + { + }; + + // wrapper using for bitmask VkVideoDecodeFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeFlagsKHR.html + using VideoDecodeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeFlagsKHR allFlags = {}; + }; + + //=== VK_EXT_transform_feedback === + + enum class PipelineRasterizationStateStreamCreateFlagBitsEXT : VkPipelineRasterizationStateStreamCreateFlagsEXT + { + }; + + // wrapper using for bitmask VkPipelineRasterizationStateStreamCreateFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html + using PipelineRasterizationStateStreamCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationStateStreamCreateFlagsEXT allFlags = {}; + }; + + //=== VK_KHR_video_encode_h264 === + + // wrapper class for enum VkVideoEncodeH264CapabilityFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264CapabilityFlagBitsKHR.html + enum class VideoEncodeH264CapabilityFlagBitsKHR : VkVideoEncodeH264CapabilityFlagsKHR + { + eHrdCompliance = VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR, + ePredictionWeightTableGenerated = VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR, + eRowUnalignedSlice = VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR, + eDifferentSliceType = VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR, + eBFrameInL0List = VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR, + eBFrameInL1List = VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR, + ePerPictureTypeMinMaxQp = VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR, + ePerSliceConstantQp = VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR, + eGeneratePrefixNalu = VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR, + eBPictureIntraRefresh = VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR, + eMbQpDiffWraparound = VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeH264CapabilityFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264CapabilityFlagsKHR.html + using VideoEncodeH264CapabilityFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeH264CapabilityFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264CapabilityFlagsKHR allFlags = + VideoEncodeH264CapabilityFlagBitsKHR::eHrdCompliance | VideoEncodeH264CapabilityFlagBitsKHR::ePredictionWeightTableGenerated | + VideoEncodeH264CapabilityFlagBitsKHR::eRowUnalignedSlice | VideoEncodeH264CapabilityFlagBitsKHR::eDifferentSliceType | + VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL0List | VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL1List | + VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp | VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp | + VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu | VideoEncodeH264CapabilityFlagBitsKHR::eBPictureIntraRefresh | + VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound; + }; + + // wrapper class for enum VkVideoEncodeH264StdFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264StdFlagBitsKHR.html + enum class VideoEncodeH264StdFlagBitsKHR : VkVideoEncodeH264StdFlagsKHR + { + eSeparateColorPlaneFlagSet = VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR, + eQpprimeYZeroTransformBypassFlagSet = VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR, + eScalingMatrixPresentFlagSet = VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR, + eChromaQpIndexOffset = VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR, + eSecondChromaQpIndexOffset = VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR, + ePicInitQpMinus26 = VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR, + eWeightedPredFlagSet = VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR, + eWeightedBipredIdcExplicit = VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR, + eWeightedBipredIdcImplicit = VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR, + eTransform8X8ModeFlagSet = VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR, + eDirectSpatialMvPredFlagUnset = VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR, + eEntropyCodingModeFlagUnset = VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR, + eEntropyCodingModeFlagSet = VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR, + eDirect8X8InferenceFlagUnset = VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR, + eConstrainedIntraPredFlagSet = VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR, + eDeblockingFilterDisabled = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR, + eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR, + eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR, + eSliceQpDelta = VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR, + eDifferentSliceQpDelta = VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeH264StdFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264StdFlagsKHR.html + using VideoEncodeH264StdFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeH264StdFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264StdFlagsKHR allFlags = + VideoEncodeH264StdFlagBitsKHR::eSeparateColorPlaneFlagSet | VideoEncodeH264StdFlagBitsKHR::eQpprimeYZeroTransformBypassFlagSet | + VideoEncodeH264StdFlagBitsKHR::eScalingMatrixPresentFlagSet | VideoEncodeH264StdFlagBitsKHR::eChromaQpIndexOffset | + VideoEncodeH264StdFlagBitsKHR::eSecondChromaQpIndexOffset | VideoEncodeH264StdFlagBitsKHR::ePicInitQpMinus26 | + VideoEncodeH264StdFlagBitsKHR::eWeightedPredFlagSet | VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcExplicit | + VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcImplicit | VideoEncodeH264StdFlagBitsKHR::eTransform8X8ModeFlagSet | + VideoEncodeH264StdFlagBitsKHR::eDirectSpatialMvPredFlagUnset | VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagUnset | + VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagSet | VideoEncodeH264StdFlagBitsKHR::eDirect8X8InferenceFlagUnset | + VideoEncodeH264StdFlagBitsKHR::eConstrainedIntraPredFlagSet | VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterDisabled | + VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterEnabled | VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterPartial | + VideoEncodeH264StdFlagBitsKHR::eSliceQpDelta | VideoEncodeH264StdFlagBitsKHR::eDifferentSliceQpDelta; + }; + + // wrapper class for enum VkVideoEncodeH264RateControlFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlFlagBitsKHR.html + enum class VideoEncodeH264RateControlFlagBitsKHR : VkVideoEncodeH264RateControlFlagsKHR + { + eAttemptHrdCompliance = VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR, + eRegularGop = VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR, + eReferencePatternFlat = VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR, + eReferencePatternDyadic = VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR, + eTemporalLayerPatternDyadic = VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeH264RateControlFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlFlagsKHR.html + using VideoEncodeH264RateControlFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeH264RateControlFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264RateControlFlagsKHR allFlags = + VideoEncodeH264RateControlFlagBitsKHR::eAttemptHrdCompliance | VideoEncodeH264RateControlFlagBitsKHR::eRegularGop | + VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternFlat | VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternDyadic | + VideoEncodeH264RateControlFlagBitsKHR::eTemporalLayerPatternDyadic; + }; + + //=== VK_KHR_video_encode_h265 === + + // wrapper class for enum VkVideoEncodeH265CapabilityFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilityFlagBitsKHR.html + enum class VideoEncodeH265CapabilityFlagBitsKHR : VkVideoEncodeH265CapabilityFlagsKHR + { + eHrdCompliance = VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR, + ePredictionWeightTableGenerated = VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR, + eRowUnalignedSliceSegment = VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR, + eDifferentSliceSegmentType = VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR, + eBFrameInL0List = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR, + eBFrameInL1List = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR, + ePerPictureTypeMinMaxQp = VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR, + ePerSliceSegmentConstantQp = VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR, + eMultipleTilesPerSliceSegment = VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR, + eMultipleSliceSegmentsPerTile = VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR, + eBPictureIntraRefresh = VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR, + eCuQpDiffWraparound = VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeH265CapabilityFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilityFlagsKHR.html + using VideoEncodeH265CapabilityFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeH265CapabilityFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265CapabilityFlagsKHR allFlags = + VideoEncodeH265CapabilityFlagBitsKHR::eHrdCompliance | VideoEncodeH265CapabilityFlagBitsKHR::ePredictionWeightTableGenerated | + VideoEncodeH265CapabilityFlagBitsKHR::eRowUnalignedSliceSegment | VideoEncodeH265CapabilityFlagBitsKHR::eDifferentSliceSegmentType | + VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL0List | VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL1List | + VideoEncodeH265CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp | VideoEncodeH265CapabilityFlagBitsKHR::ePerSliceSegmentConstantQp | + VideoEncodeH265CapabilityFlagBitsKHR::eMultipleTilesPerSliceSegment | VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile | + VideoEncodeH265CapabilityFlagBitsKHR::eBPictureIntraRefresh | VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound; + }; + + // wrapper class for enum VkVideoEncodeH265StdFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265StdFlagBitsKHR.html + enum class VideoEncodeH265StdFlagBitsKHR : VkVideoEncodeH265StdFlagsKHR + { + eSeparateColorPlaneFlagSet = VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR, + eSampleAdaptiveOffsetEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR, + eScalingListDataPresentFlagSet = VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR, + ePcmEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR, + eSpsTemporalMvpEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR, + eInitQpMinus26 = VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR, + eWeightedPredFlagSet = VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR, + eWeightedBipredFlagSet = VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR, + eLog2ParallelMergeLevelMinus2 = VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR, + eSignDataHidingEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR, + eTransformSkipEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR, + eTransformSkipEnabledFlagUnset = VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR, + ePpsSliceChromaQpOffsetsPresentFlagSet = VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR, + eTransquantBypassEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR, + eConstrainedIntraPredFlagSet = VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR, + eEntropyCodingSyncEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR, + eDeblockingFilterOverrideEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR, + eDependentSliceSegmentsEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR, + eDependentSliceSegmentFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR, + eSliceQpDelta = VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR, + eDifferentSliceQpDelta = VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeH265StdFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265StdFlagsKHR.html + using VideoEncodeH265StdFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeH265StdFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265StdFlagsKHR allFlags = + VideoEncodeH265StdFlagBitsKHR::eSeparateColorPlaneFlagSet | VideoEncodeH265StdFlagBitsKHR::eSampleAdaptiveOffsetEnabledFlagSet | + VideoEncodeH265StdFlagBitsKHR::eScalingListDataPresentFlagSet | VideoEncodeH265StdFlagBitsKHR::ePcmEnabledFlagSet | + VideoEncodeH265StdFlagBitsKHR::eSpsTemporalMvpEnabledFlagSet | VideoEncodeH265StdFlagBitsKHR::eInitQpMinus26 | + VideoEncodeH265StdFlagBitsKHR::eWeightedPredFlagSet | VideoEncodeH265StdFlagBitsKHR::eWeightedBipredFlagSet | + VideoEncodeH265StdFlagBitsKHR::eLog2ParallelMergeLevelMinus2 | VideoEncodeH265StdFlagBitsKHR::eSignDataHidingEnabledFlagSet | + VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagSet | VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagUnset | + VideoEncodeH265StdFlagBitsKHR::ePpsSliceChromaQpOffsetsPresentFlagSet | VideoEncodeH265StdFlagBitsKHR::eTransquantBypassEnabledFlagSet | + VideoEncodeH265StdFlagBitsKHR::eConstrainedIntraPredFlagSet | VideoEncodeH265StdFlagBitsKHR::eEntropyCodingSyncEnabledFlagSet | + VideoEncodeH265StdFlagBitsKHR::eDeblockingFilterOverrideEnabledFlagSet | VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentsEnabledFlagSet | + VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentFlagSet | VideoEncodeH265StdFlagBitsKHR::eSliceQpDelta | + VideoEncodeH265StdFlagBitsKHR::eDifferentSliceQpDelta; + }; + + // wrapper class for enum VkVideoEncodeH265CtbSizeFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CtbSizeFlagBitsKHR.html + enum class VideoEncodeH265CtbSizeFlagBitsKHR : VkVideoEncodeH265CtbSizeFlagsKHR + { + e16 = VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR, + e32 = VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR, + e64 = VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeH265CtbSizeFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CtbSizeFlagsKHR.html + using VideoEncodeH265CtbSizeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeH265CtbSizeFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265CtbSizeFlagsKHR allFlags = + VideoEncodeH265CtbSizeFlagBitsKHR::e16 | VideoEncodeH265CtbSizeFlagBitsKHR::e32 | VideoEncodeH265CtbSizeFlagBitsKHR::e64; + }; + + // wrapper class for enum VkVideoEncodeH265TransformBlockSizeFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265TransformBlockSizeFlagBitsKHR.html + enum class VideoEncodeH265TransformBlockSizeFlagBitsKHR : VkVideoEncodeH265TransformBlockSizeFlagsKHR + { + e4 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR, + e8 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR, + e16 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR, + e32 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeH265TransformBlockSizeFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265TransformBlockSizeFlagsKHR.html + using VideoEncodeH265TransformBlockSizeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeH265TransformBlockSizeFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265TransformBlockSizeFlagsKHR allFlags = + VideoEncodeH265TransformBlockSizeFlagBitsKHR::e4 | VideoEncodeH265TransformBlockSizeFlagBitsKHR::e8 | VideoEncodeH265TransformBlockSizeFlagBitsKHR::e16 | + VideoEncodeH265TransformBlockSizeFlagBitsKHR::e32; + }; + + // wrapper class for enum VkVideoEncodeH265RateControlFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlFlagBitsKHR.html + enum class VideoEncodeH265RateControlFlagBitsKHR : VkVideoEncodeH265RateControlFlagsKHR + { + eAttemptHrdCompliance = VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR, + eRegularGop = VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR, + eReferencePatternFlat = VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR, + eReferencePatternDyadic = VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR, + eTemporalSubLayerPatternDyadic = VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeH265RateControlFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlFlagsKHR.html + using VideoEncodeH265RateControlFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeH265RateControlFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265RateControlFlagsKHR allFlags = + VideoEncodeH265RateControlFlagBitsKHR::eAttemptHrdCompliance | VideoEncodeH265RateControlFlagBitsKHR::eRegularGop | + VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternFlat | VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternDyadic | + VideoEncodeH265RateControlFlagBitsKHR::eTemporalSubLayerPatternDyadic; + }; + + //=== VK_KHR_video_decode_h264 === + + // wrapper class for enum VkVideoDecodeH264PictureLayoutFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264PictureLayoutFlagBitsKHR.html + enum class VideoDecodeH264PictureLayoutFlagBitsKHR : VkVideoDecodeH264PictureLayoutFlagsKHR + { + eProgressive = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR, + eInterlacedInterleavedLines = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR, + eInterlacedSeparatePlanes = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR + }; + + // wrapper using for bitmask VkVideoDecodeH264PictureLayoutFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264PictureLayoutFlagsKHR.html + using VideoDecodeH264PictureLayoutFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoDecodeH264PictureLayoutFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeH264PictureLayoutFlagsKHR allFlags = VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive | + VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines | + VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes; + }; + + //=== VK_AMD_shader_info === + + // wrapper class for enum VkShaderInfoTypeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderInfoTypeAMD.html + enum class ShaderInfoTypeAMD + { + eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD, + eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD, + eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD + }; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + enum class StreamDescriptorSurfaceCreateFlagBitsGGP : VkStreamDescriptorSurfaceCreateFlagsGGP + { + }; + + // wrapper using for bitmask VkStreamDescriptorSurfaceCreateFlagsGGP, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkStreamDescriptorSurfaceCreateFlagsGGP.html + using StreamDescriptorSurfaceCreateFlagsGGP = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StreamDescriptorSurfaceCreateFlagsGGP allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + + // wrapper class for enum VkExternalMemoryHandleTypeFlagBitsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html + enum class ExternalMemoryHandleTypeFlagBitsNV : VkExternalMemoryHandleTypeFlagsNV + { + eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV, + eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, + eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV, + eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV + }; + + // wrapper using for bitmask VkExternalMemoryHandleTypeFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlagsNV.html + using ExternalMemoryHandleTypeFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkExternalMemoryHandleTypeFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryHandleTypeFlagsNV allFlags = + ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 | ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt | ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image | + ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt; + }; + + // wrapper class for enum VkExternalMemoryFeatureFlagBitsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlagBitsNV.html + enum class ExternalMemoryFeatureFlagBitsNV : VkExternalMemoryFeatureFlagsNV + { + eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV, + eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV, + eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV + }; + + // wrapper using for bitmask VkExternalMemoryFeatureFlagsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlagsNV.html + using ExternalMemoryFeatureFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkExternalMemoryFeatureFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryFeatureFlagsNV allFlags = + ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly | ExternalMemoryFeatureFlagBitsNV::eExportable | ExternalMemoryFeatureFlagBitsNV::eImportable; + }; + + //=== VK_EXT_validation_flags === + + // wrapper class for enum VkValidationCheckEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCheckEXT.html + enum class ValidationCheckEXT + { + eAll = VK_VALIDATION_CHECK_ALL_EXT, + eShaders = VK_VALIDATION_CHECK_SHADERS_EXT + }; + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + enum class ViSurfaceCreateFlagBitsNN : VkViSurfaceCreateFlagsNN + { + }; + + // wrapper using for bitmask VkViSurfaceCreateFlagsNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViSurfaceCreateFlagsNN.html + using ViSurfaceCreateFlagsNN = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ViSurfaceCreateFlagsNN allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_EXT_conditional_rendering === + + // wrapper class for enum VkConditionalRenderingFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingFlagBitsEXT.html + enum class ConditionalRenderingFlagBitsEXT : VkConditionalRenderingFlagsEXT + { + eInverted = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT + }; + + // wrapper using for bitmask VkConditionalRenderingFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingFlagsEXT.html + using ConditionalRenderingFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkConditionalRenderingFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ConditionalRenderingFlagsEXT allFlags = ConditionalRenderingFlagBitsEXT::eInverted; + }; + + //=== VK_EXT_display_surface_counter === + + // wrapper class for enum VkSurfaceCounterFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCounterFlagBitsEXT.html + enum class SurfaceCounterFlagBitsEXT : VkSurfaceCounterFlagsEXT + { + eVblank = VK_SURFACE_COUNTER_VBLANK_BIT_EXT + }; + + // wrapper using for bitmask VkSurfaceCounterFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCounterFlagsEXT.html + using SurfaceCounterFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkSurfaceCounterFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceCounterFlagsEXT allFlags = SurfaceCounterFlagBitsEXT::eVblank; + }; + + //=== VK_EXT_display_control === + + // wrapper class for enum VkDisplayPowerStateEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPowerStateEXT.html + enum class DisplayPowerStateEXT + { + eOff = VK_DISPLAY_POWER_STATE_OFF_EXT, + eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT, + eOn = VK_DISPLAY_POWER_STATE_ON_EXT + }; + + // wrapper class for enum VkDeviceEventTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceEventTypeEXT.html + enum class DeviceEventTypeEXT + { + eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT + }; + + // wrapper class for enum VkDisplayEventTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayEventTypeEXT.html + enum class DisplayEventTypeEXT + { + eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT + }; + + //=== VK_NV_viewport_swizzle === + + // wrapper class for enum VkViewportCoordinateSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViewportCoordinateSwizzleNV.html + enum class ViewportCoordinateSwizzleNV + { + ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, + eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV, + ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV, + eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV, + ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV, + eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV, + ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV, + eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV + }; + + enum class PipelineViewportSwizzleStateCreateFlagBitsNV : VkPipelineViewportSwizzleStateCreateFlagsNV + { + }; + + // wrapper using for bitmask VkPipelineViewportSwizzleStateCreateFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html + using PipelineViewportSwizzleStateCreateFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineViewportSwizzleStateCreateFlagsNV allFlags = {}; + }; + + //=== VK_EXT_discard_rectangles === + + // wrapper class for enum VkDiscardRectangleModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDiscardRectangleModeEXT.html + enum class DiscardRectangleModeEXT + { + eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, + eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT + }; + + enum class PipelineDiscardRectangleStateCreateFlagBitsEXT : VkPipelineDiscardRectangleStateCreateFlagsEXT + { + }; + + // wrapper using for bitmask VkPipelineDiscardRectangleStateCreateFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html + using PipelineDiscardRectangleStateCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDiscardRectangleStateCreateFlagsEXT allFlags = {}; + }; + + //=== VK_EXT_conservative_rasterization === + + // wrapper class for enum VkConservativeRasterizationModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConservativeRasterizationModeEXT.html + enum class ConservativeRasterizationModeEXT + { + eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, + eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, + eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT + }; + + enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT : VkPipelineRasterizationConservativeStateCreateFlagsEXT + { + }; + + // wrapper using for bitmask VkPipelineRasterizationConservativeStateCreateFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html + using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationConservativeStateCreateFlagsEXT allFlags = {}; + }; + + //=== VK_EXT_depth_clip_enable === + + enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT : VkPipelineRasterizationDepthClipStateCreateFlagsEXT + { + }; + + // wrapper using for bitmask VkPipelineRasterizationDepthClipStateCreateFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html + using PipelineRasterizationDepthClipStateCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationDepthClipStateCreateFlagsEXT allFlags = {}; + }; + + //=== VK_KHR_performance_query === + + // wrapper class for enum VkPerformanceCounterDescriptionFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html + enum class PerformanceCounterDescriptionFlagBitsKHR : VkPerformanceCounterDescriptionFlagsKHR + { + ePerformanceImpacting = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, + eConcurrentlyImpacted = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR + }; + + // wrapper using for bitmask VkPerformanceCounterDescriptionFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionFlagsKHR.html + using PerformanceCounterDescriptionFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPerformanceCounterDescriptionFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PerformanceCounterDescriptionFlagsKHR allFlags = + PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting | PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted; + }; + + // wrapper class for enum VkPerformanceCounterScopeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterScopeKHR.html + enum class PerformanceCounterScopeKHR + { + eCommandBuffer = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, + eVkQueryScopeCommandBuffer = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR, + eRenderPass = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, + eVkQueryScopeRenderPass = VK_QUERY_SCOPE_RENDER_PASS_KHR, + eCommand = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, + eVkQueryScopeCommand = VK_QUERY_SCOPE_COMMAND_KHR + }; + + // wrapper class for enum VkPerformanceCounterStorageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterStorageKHR.html + enum class PerformanceCounterStorageKHR + { + eInt32 = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR, + eInt64 = VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR, + eUint32 = VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR, + eUint64 = VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR, + eFloat32 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR, + eFloat64 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR + }; + + // wrapper class for enum VkPerformanceCounterUnitKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterUnitKHR.html + enum class PerformanceCounterUnitKHR + { + eGeneric = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR, + ePercentage = VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR, + eNanoseconds = VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR, + eBytes = VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR, + eBytesPerSecond = VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR, + eKelvin = VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR, + eWatts = VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR, + eVolts = VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR, + eAmps = VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR, + eHertz = VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR, + eCycles = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR + }; + + enum class AcquireProfilingLockFlagBitsKHR : VkAcquireProfilingLockFlagsKHR + { + }; + + // wrapper using for bitmask VkAcquireProfilingLockFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAcquireProfilingLockFlagsKHR.html + using AcquireProfilingLockFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AcquireProfilingLockFlagsKHR allFlags = {}; + }; + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + enum class IOSSurfaceCreateFlagBitsMVK : VkIOSSurfaceCreateFlagsMVK + { + }; + + // wrapper using for bitmask VkIOSSurfaceCreateFlagsMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIOSSurfaceCreateFlagsMVK.html + using IOSSurfaceCreateFlagsMVK = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR IOSSurfaceCreateFlagsMVK allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + enum class MacOSSurfaceCreateFlagBitsMVK : VkMacOSSurfaceCreateFlagsMVK + { + }; + + // wrapper using for bitmask VkMacOSSurfaceCreateFlagsMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMacOSSurfaceCreateFlagsMVK.html + using MacOSSurfaceCreateFlagsMVK = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MacOSSurfaceCreateFlagsMVK allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + + // wrapper class for enum VkDebugUtilsMessageSeverityFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html + enum class DebugUtilsMessageSeverityFlagBitsEXT : VkDebugUtilsMessageSeverityFlagsEXT + { + eVerbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT, + eInfo = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT, + eWarning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT, + eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT + }; + + // wrapper using for bitmask VkDebugUtilsMessageSeverityFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageSeverityFlagsEXT.html + using DebugUtilsMessageSeverityFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDebugUtilsMessageSeverityFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT allFlags = + DebugUtilsMessageSeverityFlagBitsEXT::eVerbose | DebugUtilsMessageSeverityFlagBitsEXT::eInfo | DebugUtilsMessageSeverityFlagBitsEXT::eWarning | + DebugUtilsMessageSeverityFlagBitsEXT::eError; + }; + + // wrapper class for enum VkDebugUtilsMessageTypeFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html + enum class DebugUtilsMessageTypeFlagBitsEXT : VkDebugUtilsMessageTypeFlagsEXT + { + eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT, + eValidation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT, + ePerformance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT, + eDeviceAddressBinding = VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT + }; + + // wrapper using for bitmask VkDebugUtilsMessageTypeFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageTypeFlagsEXT.html + using DebugUtilsMessageTypeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDebugUtilsMessageTypeFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessageTypeFlagsEXT allFlags = + DebugUtilsMessageTypeFlagBitsEXT::eGeneral | DebugUtilsMessageTypeFlagBitsEXT::eValidation | DebugUtilsMessageTypeFlagBitsEXT::ePerformance | + DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding; + }; + + enum class DebugUtilsMessengerCallbackDataFlagBitsEXT : VkDebugUtilsMessengerCallbackDataFlagsEXT + { + }; + + // wrapper using for bitmask VkDebugUtilsMessengerCallbackDataFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html + using DebugUtilsMessengerCallbackDataFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessengerCallbackDataFlagsEXT allFlags = {}; + }; + + enum class DebugUtilsMessengerCreateFlagBitsEXT : VkDebugUtilsMessengerCreateFlagsEXT + { + }; + + // wrapper using for bitmask VkDebugUtilsMessengerCreateFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html + using DebugUtilsMessengerCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessengerCreateFlagsEXT allFlags = {}; + }; + + //=== VK_EXT_descriptor_heap === + + // wrapper class for enum VkDescriptorMappingSourceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceEXT.html + enum class DescriptorMappingSourceEXT + { + eHeapWithConstantOffset = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT, + eHeapWithPushIndex = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT, + eHeapWithIndirectIndex = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT, + eHeapWithIndirectIndexArray = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT, + eResourceHeapData = VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT, + ePushData = VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT, + ePushAddress = VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT, + eIndirectAddress = VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT, + eHeapWithShaderRecordIndex = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT, + eShaderRecordData = VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT, + eShaderRecordAddress = VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT + }; + + // wrapper class for enum VkSpirvResourceTypeFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpirvResourceTypeFlagBitsEXT.html + enum class SpirvResourceTypeFlagBitsEXT : VkSpirvResourceTypeFlagsEXT + { + eAll = VK_SPIRV_RESOURCE_TYPE_ALL_EXT, + eSampler = VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT, + eSampledImage = VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT, + eReadOnlyImage = VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT, + eReadWriteImage = VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT, + eCombinedSampledImage = VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT, + eUniformBuffer = VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT, + eReadOnlyStorageBuffer = VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT, + eReadWriteStorageBuffer = VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT, + eAccelerationStructure = VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT, + eTensorARM = VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM + }; + + // wrapper using for bitmask VkSpirvResourceTypeFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpirvResourceTypeFlagsEXT.html + using SpirvResourceTypeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkSpirvResourceTypeFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SpirvResourceTypeFlagsEXT allFlags = + SpirvResourceTypeFlagBitsEXT::eAll | SpirvResourceTypeFlagBitsEXT::eSampler | SpirvResourceTypeFlagBitsEXT::eSampledImage | + SpirvResourceTypeFlagBitsEXT::eReadOnlyImage | SpirvResourceTypeFlagBitsEXT::eReadWriteImage | SpirvResourceTypeFlagBitsEXT::eCombinedSampledImage | + SpirvResourceTypeFlagBitsEXT::eUniformBuffer | SpirvResourceTypeFlagBitsEXT::eReadOnlyStorageBuffer | + SpirvResourceTypeFlagBitsEXT::eReadWriteStorageBuffer | SpirvResourceTypeFlagBitsEXT::eAccelerationStructure | SpirvResourceTypeFlagBitsEXT::eTensorARM; + }; + + // wrapper class for enum VkTensorViewCreateFlagBitsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateFlagBitsARM.html + enum class TensorViewCreateFlagBitsARM : VkTensorViewCreateFlagsARM + { + eDescriptorBufferCaptureReplay = VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM + }; + + // wrapper using for bitmask VkTensorViewCreateFlagsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateFlagsARM.html + using TensorViewCreateFlagsARM = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkTensorViewCreateFlagBitsARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR TensorViewCreateFlagsARM allFlags = TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay; + }; + + //=== VK_EXT_blend_operation_advanced === + + // wrapper class for enum VkBlendOverlapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlendOverlapEXT.html + enum class BlendOverlapEXT + { + eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT, + eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT, + eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT + }; + + //=== VK_NV_fragment_coverage_to_color === + + enum class PipelineCoverageToColorStateCreateFlagBitsNV : VkPipelineCoverageToColorStateCreateFlagsNV + { + }; + + // wrapper using for bitmask VkPipelineCoverageToColorStateCreateFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html + using PipelineCoverageToColorStateCreateFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCoverageToColorStateCreateFlagsNV allFlags = {}; + }; + + //=== VK_KHR_acceleration_structure === + + // wrapper class for enum VkAccelerationStructureTypeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTypeKHR.html + enum class AccelerationStructureTypeKHR + { + eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, + eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, + eGeneric = VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR + }; + + using AccelerationStructureTypeNV = AccelerationStructureTypeKHR; + + // wrapper class for enum VkAccelerationStructureBuildTypeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildTypeKHR.html + enum class AccelerationStructureBuildTypeKHR + { + eHost = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR, + eDevice = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, + eHostOrDevice = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR + }; + + // wrapper class for enum VkGeometryFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryFlagBitsKHR.html + enum class GeometryFlagBitsKHR : VkGeometryFlagsKHR + { + eOpaque = VK_GEOMETRY_OPAQUE_BIT_KHR, + eNoDuplicateAnyHitInvocation = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR + }; + + using GeometryFlagBitsNV = GeometryFlagBitsKHR; + + // wrapper using for bitmask VkGeometryFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryFlagsKHR.html + using GeometryFlagsKHR = Flags; + using GeometryFlagsNV = GeometryFlagsKHR; + + template <> + struct FlagTraits + { + using WrappedType = VkGeometryFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR GeometryFlagsKHR allFlags = GeometryFlagBitsKHR::eOpaque | GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation; + }; + + // wrapper class for enum VkGeometryInstanceFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryInstanceFlagBitsKHR.html + enum class GeometryInstanceFlagBitsKHR : VkGeometryInstanceFlagsKHR + { + eTriangleFacingCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, + eTriangleCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV, + eTriangleFlipFacing = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, + eTriangleFrontCounterclockwise = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, + eForceOpaque = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, + eForceNoOpaque = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, + eForceOpacityMicromap2StateEXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, + eDisableOpacityMicromapsEXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT + }; + + using GeometryInstanceFlagBitsNV = GeometryInstanceFlagBitsKHR; + + // wrapper using for bitmask VkGeometryInstanceFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryInstanceFlagsKHR.html + using GeometryInstanceFlagsKHR = Flags; + using GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR; + + template <> + struct FlagTraits + { + using WrappedType = VkGeometryInstanceFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR GeometryInstanceFlagsKHR allFlags = + GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable | GeometryInstanceFlagBitsKHR::eTriangleFlipFacing | GeometryInstanceFlagBitsKHR::eForceOpaque | + GeometryInstanceFlagBitsKHR::eForceNoOpaque | GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT | + GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT; + }; + + // wrapper class for enum VkBuildAccelerationStructureFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildAccelerationStructureFlagBitsKHR.html + enum class BuildAccelerationStructureFlagBitsKHR : VkBuildAccelerationStructureFlagsKHR + { + eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, + eAllowCompaction = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, + ePreferFastTrace = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, + ePreferFastBuild = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, + eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, + eMotionNV = VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV, + eAllowOpacityMicromapUpdateEXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, + eAllowDisableOpacityMicromapsEXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, + eAllowOpacityMicromapDataUpdateEXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eAllowDisplacementMicromapUpdateNV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV, + eAllowDisplacementMicromapUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + eAllowDataAccess = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR, + eAllowClusterOpacityMicromapsNV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV + }; + + using BuildAccelerationStructureFlagBitsNV = BuildAccelerationStructureFlagBitsKHR; + + // wrapper using for bitmask VkBuildAccelerationStructureFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildAccelerationStructureFlagsKHR.html + using BuildAccelerationStructureFlagsKHR = Flags; + using BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR; + + template <> + struct FlagTraits + { + using WrappedType = VkBuildAccelerationStructureFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR BuildAccelerationStructureFlagsKHR allFlags = + BuildAccelerationStructureFlagBitsKHR::eAllowUpdate | BuildAccelerationStructureFlagBitsKHR::eAllowCompaction | + BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace | BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild | + BuildAccelerationStructureFlagBitsKHR::eLowMemory | BuildAccelerationStructureFlagBitsKHR::eMotionNV | + BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT | BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT | + BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + | BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + | BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess | BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV; + }; + + // wrapper class for enum VkCopyAccelerationStructureModeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyAccelerationStructureModeKHR.html + enum class CopyAccelerationStructureModeKHR + { + eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR, + eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, + eSerialize = VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR, + eDeserialize = VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR + }; + + using CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR; + + // wrapper class for enum VkGeometryTypeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryTypeKHR.html + enum class GeometryTypeKHR + { + eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_KHR, + eAabbs = VK_GEOMETRY_TYPE_AABBS_KHR, + eInstances = VK_GEOMETRY_TYPE_INSTANCES_KHR, + eSpheresNV = VK_GEOMETRY_TYPE_SPHERES_NV, + eLinearSweptSpheresNV = VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eDenseGeometryFormatTrianglesAMDX = VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + }; + + using GeometryTypeNV = GeometryTypeKHR; + + // wrapper class for enum VkAccelerationStructureCompatibilityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCompatibilityKHR.html + enum class AccelerationStructureCompatibilityKHR + { + eCompatible = VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR, + eIncompatible = VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR + }; + + // wrapper class for enum VkAccelerationStructureCreateFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateFlagBitsKHR.html + enum class AccelerationStructureCreateFlagBitsKHR : VkAccelerationStructureCreateFlagsKHR + { + eDeviceAddressCaptureReplay = VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, + eDescriptorBufferCaptureReplayEXT = VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, + eMotionNV = VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV + }; + + // wrapper using for bitmask VkAccelerationStructureCreateFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateFlagsKHR.html + using AccelerationStructureCreateFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkAccelerationStructureCreateFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccelerationStructureCreateFlagsKHR allFlags = + AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay | AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT | + AccelerationStructureCreateFlagBitsKHR::eMotionNV; + }; + + // wrapper class for enum VkBuildAccelerationStructureModeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildAccelerationStructureModeKHR.html + enum class BuildAccelerationStructureModeKHR + { + eBuild = VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR, + eUpdate = VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR + }; + + //=== VK_KHR_ray_tracing_pipeline === + + // wrapper class for enum VkRayTracingShaderGroupTypeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingShaderGroupTypeKHR.html + enum class RayTracingShaderGroupTypeKHR + { + eGeneral = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR, + eTrianglesHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR, + eProceduralHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR + }; + + using RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR; + + // wrapper class for enum VkShaderGroupShaderKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderGroupShaderKHR.html + enum class ShaderGroupShaderKHR + { + eGeneral = VK_SHADER_GROUP_SHADER_GENERAL_KHR, + eClosestHit = VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR, + eAnyHit = VK_SHADER_GROUP_SHADER_ANY_HIT_KHR, + eIntersection = VK_SHADER_GROUP_SHADER_INTERSECTION_KHR + }; + + //=== VK_NV_framebuffer_mixed_samples === + + // wrapper class for enum VkCoverageModulationModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoverageModulationModeNV.html + enum class CoverageModulationModeNV + { + eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV, + eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV, + eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV, + eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV + }; + + enum class PipelineCoverageModulationStateCreateFlagBitsNV : VkPipelineCoverageModulationStateCreateFlagsNV + { + }; + + // wrapper using for bitmask VkPipelineCoverageModulationStateCreateFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html + using PipelineCoverageModulationStateCreateFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCoverageModulationStateCreateFlagsNV allFlags = {}; + }; + + //=== VK_EXT_validation_cache === + + // wrapper class for enum VkValidationCacheHeaderVersionEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheHeaderVersionEXT.html + enum class ValidationCacheHeaderVersionEXT + { + eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT + }; + + enum class ValidationCacheCreateFlagBitsEXT : VkValidationCacheCreateFlagsEXT + { + }; + + // wrapper using for bitmask VkValidationCacheCreateFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheCreateFlagsEXT.html + using ValidationCacheCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ValidationCacheCreateFlagsEXT allFlags = {}; + }; + + //=== VK_NV_shading_rate_image === + + // wrapper class for enum VkShadingRatePaletteEntryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShadingRatePaletteEntryNV.html + enum class ShadingRatePaletteEntryNV + { + eNoInvocations = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV, + e16InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV, + e8InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV, + e4InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV, + e2InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV, + e1InvocationPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV, + e1InvocationPer2X1Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV, + e1InvocationPer1X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV, + e1InvocationPer2X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV, + e1InvocationPer4X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV, + e1InvocationPer2X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV, + e1InvocationPer4X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV + }; + + // wrapper class for enum VkCoarseSampleOrderTypeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoarseSampleOrderTypeNV.html + enum class CoarseSampleOrderTypeNV + { + eDefault = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV, + eCustom = VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, + ePixelMajor = VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV, + eSampleMajor = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV + }; + + //=== VK_NV_ray_tracing === + + // wrapper class for enum VkAccelerationStructureMemoryRequirementsTypeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMemoryRequirementsTypeNV.html + enum class AccelerationStructureMemoryRequirementsTypeNV + { + eObject = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV, + eBuildScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV, + eUpdateScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV + }; + + //=== VK_AMD_pipeline_compiler_control === + + enum class PipelineCompilerControlFlagBitsAMD : VkPipelineCompilerControlFlagsAMD + { + }; + + // wrapper using for bitmask VkPipelineCompilerControlFlagsAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCompilerControlFlagsAMD.html + using PipelineCompilerControlFlagsAMD = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCompilerControlFlagsAMD allFlags = {}; + }; + + //=== VK_AMD_memory_overallocation_behavior === + + // wrapper class for enum VkMemoryOverallocationBehaviorAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryOverallocationBehaviorAMD.html + enum class MemoryOverallocationBehaviorAMD + { + eDefault = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD, + eAllowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD, + eDisallowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD + }; + + //=== VK_EXT_present_timing === + + // wrapper class for enum VkPresentStageFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentStageFlagBitsEXT.html + enum class PresentStageFlagBitsEXT : VkPresentStageFlagsEXT + { + eQueueOperationsEnd = VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT, + eRequestDequeued = VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT, + eImageFirstPixelOut = VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT, + eImageFirstPixelVisible = VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT + }; + + // wrapper using for bitmask VkPresentStageFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentStageFlagsEXT.html + using PresentStageFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPresentStageFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PresentStageFlagsEXT allFlags = + PresentStageFlagBitsEXT::eQueueOperationsEnd | PresentStageFlagBitsEXT::eRequestDequeued | PresentStageFlagBitsEXT::eImageFirstPixelOut | + PresentStageFlagBitsEXT::eImageFirstPixelVisible; + }; + + // wrapper class for enum VkPresentTimingInfoFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingInfoFlagBitsEXT.html + enum class PresentTimingInfoFlagBitsEXT : VkPresentTimingInfoFlagsEXT + { + ePresentAtRelativeTime = VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT, + ePresentAtNearestRefreshCycle = VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT + }; + + // wrapper using for bitmask VkPresentTimingInfoFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingInfoFlagsEXT.html + using PresentTimingInfoFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPresentTimingInfoFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PresentTimingInfoFlagsEXT allFlags = + PresentTimingInfoFlagBitsEXT::ePresentAtRelativeTime | PresentTimingInfoFlagBitsEXT::ePresentAtNearestRefreshCycle; + }; + + // wrapper class for enum VkPastPresentationTimingFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingFlagBitsEXT.html + enum class PastPresentationTimingFlagBitsEXT : VkPastPresentationTimingFlagsEXT + { + eAllowPartialResults = VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT, + eAllowOutOfOrderResults = VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT + }; + + // wrapper using for bitmask VkPastPresentationTimingFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingFlagsEXT.html + using PastPresentationTimingFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPastPresentationTimingFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PastPresentationTimingFlagsEXT allFlags = + PastPresentationTimingFlagBitsEXT::eAllowPartialResults | PastPresentationTimingFlagBitsEXT::eAllowOutOfOrderResults; + }; + + //=== VK_INTEL_performance_query === + + // wrapper class for enum VkPerformanceConfigurationTypeINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationTypeINTEL.html + enum class PerformanceConfigurationTypeINTEL + { + eCommandQueueMetricsDiscoveryActivated = VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL + }; + + // wrapper class for enum VkQueryPoolSamplingModeINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolSamplingModeINTEL.html + enum class QueryPoolSamplingModeINTEL + { + eManual = VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL + }; + + // wrapper class for enum VkPerformanceOverrideTypeINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceOverrideTypeINTEL.html + enum class PerformanceOverrideTypeINTEL + { + eNullHardware = VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL, + eFlushGpuCaches = VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL + }; + + // wrapper class for enum VkPerformanceParameterTypeINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceParameterTypeINTEL.html + enum class PerformanceParameterTypeINTEL + { + eHwCountersSupported = VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL, + eStreamMarkerValidBits = VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL + }; + + // wrapper class for enum VkPerformanceValueTypeINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceValueTypeINTEL.html + enum class PerformanceValueTypeINTEL + { + eUint32 = VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL, + eUint64 = VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL, + eFloat = VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL, + eBool = VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL, + eString = VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL + }; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA : VkImagePipeSurfaceCreateFlagsFUCHSIA + { + }; + + // wrapper using for bitmask VkImagePipeSurfaceCreateFlagsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImagePipeSurfaceCreateFlagsFUCHSIA.html + using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImagePipeSurfaceCreateFlagsFUCHSIA allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + enum class MetalSurfaceCreateFlagBitsEXT : VkMetalSurfaceCreateFlagsEXT + { + }; + + // wrapper using for bitmask VkMetalSurfaceCreateFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMetalSurfaceCreateFlagsEXT.html + using MetalSurfaceCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MetalSurfaceCreateFlagsEXT allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + + // wrapper class for enum VkFragmentShadingRateCombinerOpKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFragmentShadingRateCombinerOpKHR.html + enum class FragmentShadingRateCombinerOpKHR + { + eKeep = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR, + eReplace = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR, + eMin = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR, + eMax = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR, + eMul = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR + }; + + //=== VK_AMD_shader_core_properties2 === + + enum class ShaderCorePropertiesFlagBitsAMD : VkShaderCorePropertiesFlagsAMD + { + }; + + // wrapper using for bitmask VkShaderCorePropertiesFlagsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCorePropertiesFlagsAMD.html + using ShaderCorePropertiesFlagsAMD = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderCorePropertiesFlagsAMD allFlags = {}; + }; + + //=== VK_EXT_validation_features === + + // wrapper class for enum VkValidationFeatureEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationFeatureEnableEXT.html + enum class ValidationFeatureEnableEXT + { + eGpuAssisted = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT, + eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT, + eBestPractices = VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT, + eDebugPrintf = VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT, + eSynchronizationValidation = VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT + }; + + // wrapper class for enum VkValidationFeatureDisableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationFeatureDisableEXT.html + enum class ValidationFeatureDisableEXT + { + eAll = VK_VALIDATION_FEATURE_DISABLE_ALL_EXT, + eShaders = VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT, + eThreadSafety = VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT, + eApiParameters = VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT, + eObjectLifetimes = VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT, + eCoreChecks = VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT, + eUniqueHandles = VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT, + eShaderValidationCache = VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT + }; + + //=== VK_NV_coverage_reduction_mode === + + // wrapper class for enum VkCoverageReductionModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoverageReductionModeNV.html + enum class CoverageReductionModeNV + { + eMerge = VK_COVERAGE_REDUCTION_MODE_MERGE_NV, + eTruncate = VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV + }; + + enum class PipelineCoverageReductionStateCreateFlagBitsNV : VkPipelineCoverageReductionStateCreateFlagsNV + { + }; + + // wrapper using for bitmask VkPipelineCoverageReductionStateCreateFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html + using PipelineCoverageReductionStateCreateFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCoverageReductionStateCreateFlagsNV allFlags = {}; + }; + + //=== VK_EXT_provoking_vertex === + + // wrapper class for enum VkProvokingVertexModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkProvokingVertexModeEXT.html + enum class ProvokingVertexModeEXT + { + eFirstVertex = VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT, + eLastVertex = VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT + }; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + + // wrapper class for enum VkFullScreenExclusiveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFullScreenExclusiveEXT.html + enum class FullScreenExclusiveEXT + { + eDefault = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT, + eAllowed = VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT, + eDisallowed = VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT, + eApplicationControlled = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT + }; + +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + + enum class HeadlessSurfaceCreateFlagBitsEXT : VkHeadlessSurfaceCreateFlagsEXT + { + }; + + // wrapper using for bitmask VkHeadlessSurfaceCreateFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkHeadlessSurfaceCreateFlagsEXT.html + using HeadlessSurfaceCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR HeadlessSurfaceCreateFlagsEXT allFlags = {}; + }; + + //=== VK_KHR_pipeline_executable_properties === + + // wrapper class for enum VkPipelineExecutableStatisticFormatKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineExecutableStatisticFormatKHR.html + enum class PipelineExecutableStatisticFormatKHR + { + eBool32 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR, + eInt64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR, + eUint64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR, + eFloat64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR + }; + + //=== VK_NV_device_generated_commands === + + // wrapper class for enum VkIndirectStateFlagBitsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectStateFlagBitsNV.html + enum class IndirectStateFlagBitsNV : VkIndirectStateFlagsNV + { + eFlagFrontface = VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV + }; + + // wrapper using for bitmask VkIndirectStateFlagsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectStateFlagsNV.html + using IndirectStateFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkIndirectStateFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectStateFlagsNV allFlags = IndirectStateFlagBitsNV::eFlagFrontface; + }; + + // wrapper class for enum VkIndirectCommandsTokenTypeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsTokenTypeNV.html + enum class IndirectCommandsTokenTypeNV + { + eShaderGroup = VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV, + eStateFlags = VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV, + eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV, + eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV, + ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV, + eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV, + eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV, + eDrawTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV, + ePushData = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV, + eDrawMeshTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV, + ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV, + eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV + }; + + // wrapper class for enum VkIndirectCommandsLayoutUsageFlagBitsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html + enum class IndirectCommandsLayoutUsageFlagBitsNV : VkIndirectCommandsLayoutUsageFlagsNV + { + eExplicitPreprocess = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV, + eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV, + eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV + }; + + // wrapper using for bitmask VkIndirectCommandsLayoutUsageFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagsNV.html + using IndirectCommandsLayoutUsageFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkIndirectCommandsLayoutUsageFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV allFlags = IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess | + IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences | + IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences; + }; + + //=== VK_EXT_depth_bias_control === + + // wrapper class for enum VkDepthBiasRepresentationEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthBiasRepresentationEXT.html + enum class DepthBiasRepresentationEXT + { + eLeastRepresentableValueFormat = VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT, + eLeastRepresentableValueForceUnorm = VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT, + eFloat = VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT + }; + + //=== VK_EXT_device_memory_report === + + // wrapper class for enum VkDeviceMemoryReportEventTypeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryReportEventTypeEXT.html + enum class DeviceMemoryReportEventTypeEXT + { + eAllocate = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT, + eFree = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT, + eImport = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT, + eUnimport = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT, + eAllocationFailed = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT + }; + + enum class DeviceMemoryReportFlagBitsEXT : VkDeviceMemoryReportFlagsEXT + { + }; + + // wrapper using for bitmask VkDeviceMemoryReportFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryReportFlagsEXT.html + using DeviceMemoryReportFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceMemoryReportFlagsEXT allFlags = {}; + }; + + //=== VK_KHR_video_encode_queue === + + // wrapper class for enum VkVideoEncodeCapabilityFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeCapabilityFlagBitsKHR.html + enum class VideoEncodeCapabilityFlagBitsKHR : VkVideoEncodeCapabilityFlagsKHR + { + ePrecedingExternallyEncodedBytes = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR, + eInsufficientBitstreamBufferRangeDetection = VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR, + eQuantizationDeltaMap = VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR, + eEmphasisMap = VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeCapabilityFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeCapabilityFlagsKHR.html + using VideoEncodeCapabilityFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeCapabilityFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeCapabilityFlagsKHR allFlags = + VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes | VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection | + VideoEncodeCapabilityFlagBitsKHR::eQuantizationDeltaMap | VideoEncodeCapabilityFlagBitsKHR::eEmphasisMap; + }; + + // wrapper class for enum VkVideoEncodeFeedbackFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFeedbackFlagBitsKHR.html + enum class VideoEncodeFeedbackFlagBitsKHR : VkVideoEncodeFeedbackFlagsKHR + { + eBitstreamBufferOffset = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR, + eBitstreamBytesWritten = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR, + eBitstreamHasOverrides = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeFeedbackFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFeedbackFlagsKHR.html + using VideoEncodeFeedbackFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeFeedbackFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeFeedbackFlagsKHR allFlags = VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset | + VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten | + VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides; + }; + + // wrapper class for enum VkVideoEncodeUsageFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeUsageFlagBitsKHR.html + enum class VideoEncodeUsageFlagBitsKHR : VkVideoEncodeUsageFlagsKHR + { + eDefault = VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR, + eTranscoding = VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR, + eStreaming = VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR, + eRecording = VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR, + eConferencing = VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeUsageFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeUsageFlagsKHR.html + using VideoEncodeUsageFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeUsageFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeUsageFlagsKHR allFlags = VideoEncodeUsageFlagBitsKHR::eDefault | VideoEncodeUsageFlagBitsKHR::eTranscoding | + VideoEncodeUsageFlagBitsKHR::eStreaming | VideoEncodeUsageFlagBitsKHR::eRecording | + VideoEncodeUsageFlagBitsKHR::eConferencing; + }; + + // wrapper class for enum VkVideoEncodeContentFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeContentFlagBitsKHR.html + enum class VideoEncodeContentFlagBitsKHR : VkVideoEncodeContentFlagsKHR + { + eDefault = VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR, + eCamera = VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR, + eDesktop = VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR, + eRendered = VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeContentFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeContentFlagsKHR.html + using VideoEncodeContentFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeContentFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeContentFlagsKHR allFlags = + VideoEncodeContentFlagBitsKHR::eDefault | VideoEncodeContentFlagBitsKHR::eCamera | VideoEncodeContentFlagBitsKHR::eDesktop | + VideoEncodeContentFlagBitsKHR::eRendered; + }; + + // wrapper class for enum VkVideoEncodeTuningModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeTuningModeKHR.html + enum class VideoEncodeTuningModeKHR + { + eDefault = VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR, + eHighQuality = VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR, + eLowLatency = VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR, + eUltraLowLatency = VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR, + eLossless = VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR + }; + + // wrapper class for enum VkVideoEncodeRateControlModeFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html + enum class VideoEncodeRateControlModeFlagBitsKHR : VkVideoEncodeRateControlModeFlagsKHR + { + eDefault = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR, + eDisabled = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, + eCbr = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR, + eVbr = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeRateControlModeFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlModeFlagsKHR.html + using VideoEncodeRateControlModeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeRateControlModeFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRateControlModeFlagsKHR allFlags = + VideoEncodeRateControlModeFlagBitsKHR::eDefault | VideoEncodeRateControlModeFlagBitsKHR::eDisabled | VideoEncodeRateControlModeFlagBitsKHR::eCbr | + VideoEncodeRateControlModeFlagBitsKHR::eVbr; + }; + + // wrapper class for enum VkVideoEncodeFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFlagBitsKHR.html + enum class VideoEncodeFlagBitsKHR : VkVideoEncodeFlagsKHR + { + eIntraRefresh = VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR, + eWithQuantizationDeltaMap = VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR, + eWithEmphasisMap = VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFlagsKHR.html + using VideoEncodeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeFlagsKHR allFlags = + VideoEncodeFlagBitsKHR::eIntraRefresh | VideoEncodeFlagBitsKHR::eWithQuantizationDeltaMap | VideoEncodeFlagBitsKHR::eWithEmphasisMap; + }; + + enum class VideoEncodeRateControlFlagBitsKHR : VkVideoEncodeRateControlFlagsKHR + { + }; + + // wrapper using for bitmask VkVideoEncodeRateControlFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlFlagsKHR.html + using VideoEncodeRateControlFlagsKHR = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRateControlFlagsKHR allFlags = {}; + }; + + //=== VK_NV_device_diagnostics_config === + + // wrapper class for enum VkDeviceDiagnosticsConfigFlagBitsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html + enum class DeviceDiagnosticsConfigFlagBitsNV : VkDeviceDiagnosticsConfigFlagsNV + { + eEnableShaderDebugInfo = VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV, + eEnableResourceTracking = VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV, + eEnableAutomaticCheckpoints = VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV, + eEnableShaderErrorReporting = VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV + }; + + // wrapper using for bitmask VkDeviceDiagnosticsConfigFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceDiagnosticsConfigFlagsNV.html + using DeviceDiagnosticsConfigFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDeviceDiagnosticsConfigFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceDiagnosticsConfigFlagsNV allFlags = + DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo | DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking | + DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints | DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting; + }; + + //=== VK_QCOM_tile_shading === + + // wrapper class for enum VkTileShadingRenderPassFlagBitsQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileShadingRenderPassFlagBitsQCOM.html + enum class TileShadingRenderPassFlagBitsQCOM : VkTileShadingRenderPassFlagsQCOM + { + eEnable = VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM, + ePerTileExecution = VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM + }; + + // wrapper using for bitmask VkTileShadingRenderPassFlagsQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileShadingRenderPassFlagsQCOM.html + using TileShadingRenderPassFlagsQCOM = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkTileShadingRenderPassFlagBitsQCOM; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR TileShadingRenderPassFlagsQCOM allFlags = + TileShadingRenderPassFlagBitsQCOM::eEnable | TileShadingRenderPassFlagBitsQCOM::ePerTileExecution; + }; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + + // wrapper class for enum VkExportMetalObjectTypeFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalObjectTypeFlagBitsEXT.html + enum class ExportMetalObjectTypeFlagBitsEXT : VkExportMetalObjectTypeFlagsEXT + { + eMetalDevice = VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT, + eMetalCommandQueue = VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT, + eMetalBuffer = VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT, + eMetalTexture = VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT, + eMetalIosurface = VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT, + eMetalSharedEvent = VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT + }; + + // wrapper using for bitmask VkExportMetalObjectTypeFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalObjectTypeFlagsEXT.html + using ExportMetalObjectTypeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkExportMetalObjectTypeFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ExportMetalObjectTypeFlagsEXT allFlags = + ExportMetalObjectTypeFlagBitsEXT::eMetalDevice | ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue | ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer | + ExportMetalObjectTypeFlagBitsEXT::eMetalTexture | ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface | ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_graphics_pipeline_library === + + // wrapper class for enum VkGraphicsPipelineLibraryFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineLibraryFlagBitsEXT.html + enum class GraphicsPipelineLibraryFlagBitsEXT : VkGraphicsPipelineLibraryFlagsEXT + { + eVertexInputInterface = VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT, + ePreRasterizationShaders = VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT, + eFragmentShader = VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, + eFragmentOutputInterface = VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT + }; + + // wrapper using for bitmask VkGraphicsPipelineLibraryFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineLibraryFlagsEXT.html + using GraphicsPipelineLibraryFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkGraphicsPipelineLibraryFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR GraphicsPipelineLibraryFlagsEXT allFlags = + GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface | GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders | + GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader | GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface; + }; + + //=== VK_NV_fragment_shading_rate_enums === + + // wrapper class for enum VkFragmentShadingRateNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFragmentShadingRateNV.html + enum class FragmentShadingRateNV + { + e1InvocationPerPixel = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV, + e1InvocationPer1X2Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV, + e1InvocationPer2X1Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV, + e1InvocationPer2X2Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV, + e1InvocationPer2X4Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV, + e1InvocationPer4X2Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV, + e1InvocationPer4X4Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV, + e2InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV, + e4InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV, + e8InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV, + e16InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV, + eNoInvocations = VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV + }; + + // wrapper class for enum VkFragmentShadingRateTypeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFragmentShadingRateTypeNV.html + enum class FragmentShadingRateTypeNV + { + eFragmentSize = VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV, + eEnums = VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV + }; + + //=== VK_NV_ray_tracing_motion_blur === + + // wrapper class for enum VkAccelerationStructureMotionInstanceTypeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceTypeNV.html + enum class AccelerationStructureMotionInstanceTypeNV + { + eStatic = VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV, + eMatrixMotion = VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV, + eSrtMotion = VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV + }; + + enum class AccelerationStructureMotionInfoFlagBitsNV : VkAccelerationStructureMotionInfoFlagsNV + { + }; + + // wrapper using for bitmask VkAccelerationStructureMotionInfoFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInfoFlagsNV.html + using AccelerationStructureMotionInfoFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccelerationStructureMotionInfoFlagsNV allFlags = {}; + }; + + enum class AccelerationStructureMotionInstanceFlagBitsNV : VkAccelerationStructureMotionInstanceFlagsNV + { + }; + + // wrapper using for bitmask VkAccelerationStructureMotionInstanceFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceFlagsNV.html + using AccelerationStructureMotionInstanceFlagsNV = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccelerationStructureMotionInstanceFlagsNV allFlags = {}; + }; + + //=== VK_EXT_image_compression_control === + + // wrapper class for enum VkImageCompressionFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFlagBitsEXT.html + enum class ImageCompressionFlagBitsEXT : VkImageCompressionFlagsEXT + { + eDefault = VK_IMAGE_COMPRESSION_DEFAULT_EXT, + eFixedRateDefault = VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT, + eFixedRateExplicit = VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT, + eDisabled = VK_IMAGE_COMPRESSION_DISABLED_EXT + }; + + // wrapper using for bitmask VkImageCompressionFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFlagsEXT.html + using ImageCompressionFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkImageCompressionFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCompressionFlagsEXT allFlags = + ImageCompressionFlagBitsEXT::eDefault | ImageCompressionFlagBitsEXT::eFixedRateDefault | ImageCompressionFlagBitsEXT::eFixedRateExplicit | + ImageCompressionFlagBitsEXT::eDisabled; + }; + + // wrapper class for enum VkImageCompressionFixedRateFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFixedRateFlagBitsEXT.html + enum class ImageCompressionFixedRateFlagBitsEXT : VkImageCompressionFixedRateFlagsEXT + { + eNone = VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT, + e1Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT, + e2Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT, + e3Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT, + e4Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT, + e5Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT, + e6Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT, + e7Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT, + e8Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT, + e9Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT, + e10Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT, + e11Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT, + e12Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT, + e13Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT, + e14Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT, + e15Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT, + e16Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT, + e17Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT, + e18Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT, + e19Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT, + e20Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT, + e21Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT, + e22Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT, + e23Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT, + e24Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT + }; + + // wrapper using for bitmask VkImageCompressionFixedRateFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFixedRateFlagsEXT.html + using ImageCompressionFixedRateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkImageCompressionFixedRateFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCompressionFixedRateFlagsEXT allFlags = + ImageCompressionFixedRateFlagBitsEXT::eNone | ImageCompressionFixedRateFlagBitsEXT::e1Bpc | ImageCompressionFixedRateFlagBitsEXT::e2Bpc | + ImageCompressionFixedRateFlagBitsEXT::e3Bpc | ImageCompressionFixedRateFlagBitsEXT::e4Bpc | ImageCompressionFixedRateFlagBitsEXT::e5Bpc | + ImageCompressionFixedRateFlagBitsEXT::e6Bpc | ImageCompressionFixedRateFlagBitsEXT::e7Bpc | ImageCompressionFixedRateFlagBitsEXT::e8Bpc | + ImageCompressionFixedRateFlagBitsEXT::e9Bpc | ImageCompressionFixedRateFlagBitsEXT::e10Bpc | ImageCompressionFixedRateFlagBitsEXT::e11Bpc | + ImageCompressionFixedRateFlagBitsEXT::e12Bpc | ImageCompressionFixedRateFlagBitsEXT::e13Bpc | ImageCompressionFixedRateFlagBitsEXT::e14Bpc | + ImageCompressionFixedRateFlagBitsEXT::e15Bpc | ImageCompressionFixedRateFlagBitsEXT::e16Bpc | ImageCompressionFixedRateFlagBitsEXT::e17Bpc | + ImageCompressionFixedRateFlagBitsEXT::e18Bpc | ImageCompressionFixedRateFlagBitsEXT::e19Bpc | ImageCompressionFixedRateFlagBitsEXT::e20Bpc | + ImageCompressionFixedRateFlagBitsEXT::e21Bpc | ImageCompressionFixedRateFlagBitsEXT::e22Bpc | ImageCompressionFixedRateFlagBitsEXT::e23Bpc | + ImageCompressionFixedRateFlagBitsEXT::e24Bpc; + }; + + //=== VK_EXT_device_fault === + + // wrapper class for enum VkDeviceFaultAddressTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultAddressTypeEXT.html + enum class DeviceFaultAddressTypeEXT + { + eNone = VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT, + eReadInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT, + eWriteInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT, + eExecuteInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT, + eInstructionPointerUnknown = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT, + eInstructionPointerInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT, + eInstructionPointerFault = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT + }; + + // wrapper class for enum VkDeviceFaultVendorBinaryHeaderVersionEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorBinaryHeaderVersionEXT.html + enum class DeviceFaultVendorBinaryHeaderVersionEXT + { + eOne = VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT + }; + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + enum class DirectFBSurfaceCreateFlagBitsEXT : VkDirectFBSurfaceCreateFlagsEXT + { + }; + + // wrapper using for bitmask VkDirectFBSurfaceCreateFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectFBSurfaceCreateFlagsEXT.html + using DirectFBSurfaceCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DirectFBSurfaceCreateFlagsEXT allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_device_address_binding_report === + + // wrapper class for enum VkDeviceAddressBindingFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingFlagBitsEXT.html + enum class DeviceAddressBindingFlagBitsEXT : VkDeviceAddressBindingFlagsEXT + { + eInternalObject = VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT + }; + + // wrapper using for bitmask VkDeviceAddressBindingFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingFlagsEXT.html + using DeviceAddressBindingFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDeviceAddressBindingFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceAddressBindingFlagsEXT allFlags = DeviceAddressBindingFlagBitsEXT::eInternalObject; + }; + + // wrapper class for enum VkDeviceAddressBindingTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingTypeEXT.html + enum class DeviceAddressBindingTypeEXT + { + eBind = VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT, + eUnbind = VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT + }; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + // wrapper class for enum VkImageConstraintsInfoFlagBitsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageConstraintsInfoFlagBitsFUCHSIA.html + enum class ImageConstraintsInfoFlagBitsFUCHSIA : VkImageConstraintsInfoFlagsFUCHSIA + { + eCpuReadRarely = VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA, + eCpuReadOften = VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA, + eCpuWriteRarely = VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA, + eCpuWriteOften = VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA, + eProtectedOptional = VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA + }; + + // wrapper using for bitmask VkImageConstraintsInfoFlagsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageConstraintsInfoFlagsFUCHSIA.html + using ImageConstraintsInfoFlagsFUCHSIA = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkImageConstraintsInfoFlagBitsFUCHSIA; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA allFlags = + ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely | ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften | + ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely | ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften | + ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional; + }; + + enum class ImageFormatConstraintsFlagBitsFUCHSIA : VkImageFormatConstraintsFlagsFUCHSIA + { + }; + + // wrapper using for bitmask VkImageFormatConstraintsFlagsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatConstraintsFlagsFUCHSIA.html + using ImageFormatConstraintsFlagsFUCHSIA = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ImageFormatConstraintsFlagsFUCHSIA allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_frame_boundary === + + // wrapper class for enum VkFrameBoundaryFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrameBoundaryFlagBitsEXT.html + enum class FrameBoundaryFlagBitsEXT : VkFrameBoundaryFlagsEXT + { + eFrameEnd = VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT + }; + + // wrapper using for bitmask VkFrameBoundaryFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrameBoundaryFlagsEXT.html + using FrameBoundaryFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkFrameBoundaryFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR FrameBoundaryFlagsEXT allFlags = FrameBoundaryFlagBitsEXT::eFrameEnd; + }; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + enum class ScreenSurfaceCreateFlagBitsQNX : VkScreenSurfaceCreateFlagsQNX + { + }; + + // wrapper using for bitmask VkScreenSurfaceCreateFlagsQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkScreenSurfaceCreateFlagsQNX.html + using ScreenSurfaceCreateFlagsQNX = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ScreenSurfaceCreateFlagsQNX allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_VALVE_video_encode_rgb_conversion === + + // wrapper class for enum VkVideoEncodeRgbModelConversionFlagBitsVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbModelConversionFlagBitsVALVE.html + enum class VideoEncodeRgbModelConversionFlagBitsVALVE : VkVideoEncodeRgbModelConversionFlagsVALVE + { + eRgbIdentity = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE, + eYcbcrIdentity = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE, + eYcbcr709 = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE, + eYcbcr601 = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE, + eYcbcr2020 = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE + }; + + // wrapper using for bitmask VkVideoEncodeRgbModelConversionFlagsVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbModelConversionFlagsVALVE.html + using VideoEncodeRgbModelConversionFlagsVALVE = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeRgbModelConversionFlagBitsVALVE; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRgbModelConversionFlagsVALVE allFlags = + VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity | VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcrIdentity | + VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr709 | VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr601 | + VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr2020; + }; + + // wrapper class for enum VkVideoEncodeRgbRangeCompressionFlagBitsVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbRangeCompressionFlagBitsVALVE.html + enum class VideoEncodeRgbRangeCompressionFlagBitsVALVE : VkVideoEncodeRgbRangeCompressionFlagsVALVE + { + eFullRange = VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE, + eNarrowRange = VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE + }; + + // wrapper using for bitmask VkVideoEncodeRgbRangeCompressionFlagsVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbRangeCompressionFlagsVALVE.html + using VideoEncodeRgbRangeCompressionFlagsVALVE = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeRgbRangeCompressionFlagBitsVALVE; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRgbRangeCompressionFlagsVALVE allFlags = + VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange | VideoEncodeRgbRangeCompressionFlagBitsVALVE::eNarrowRange; + }; + + // wrapper class for enum VkVideoEncodeRgbChromaOffsetFlagBitsVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbChromaOffsetFlagBitsVALVE.html + enum class VideoEncodeRgbChromaOffsetFlagBitsVALVE : VkVideoEncodeRgbChromaOffsetFlagsVALVE + { + eCositedEven = VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE, + eMidpoint = VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE + }; + + // wrapper using for bitmask VkVideoEncodeRgbChromaOffsetFlagsVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbChromaOffsetFlagsVALVE.html + using VideoEncodeRgbChromaOffsetFlagsVALVE = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeRgbChromaOffsetFlagBitsVALVE; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRgbChromaOffsetFlagsVALVE allFlags = + VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven | VideoEncodeRgbChromaOffsetFlagBitsVALVE::eMidpoint; + }; + + //=== VK_EXT_opacity_micromap === + + // wrapper class for enum VkMicromapTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapTypeEXT.html + enum class MicromapTypeEXT + { + eOpacityMicromap = VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + eDisplacementMicromapNV = VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + }; + + // wrapper class for enum VkBuildMicromapFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildMicromapFlagBitsEXT.html + enum class BuildMicromapFlagBitsEXT : VkBuildMicromapFlagsEXT + { + ePreferFastTrace = VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT, + ePreferFastBuild = VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT, + eAllowCompaction = VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT + }; + + // wrapper using for bitmask VkBuildMicromapFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildMicromapFlagsEXT.html + using BuildMicromapFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkBuildMicromapFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR BuildMicromapFlagsEXT allFlags = + BuildMicromapFlagBitsEXT::ePreferFastTrace | BuildMicromapFlagBitsEXT::ePreferFastBuild | BuildMicromapFlagBitsEXT::eAllowCompaction; + }; + + // wrapper class for enum VkCopyMicromapModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMicromapModeEXT.html + enum class CopyMicromapModeEXT + { + eClone = VK_COPY_MICROMAP_MODE_CLONE_EXT, + eSerialize = VK_COPY_MICROMAP_MODE_SERIALIZE_EXT, + eDeserialize = VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT, + eCompact = VK_COPY_MICROMAP_MODE_COMPACT_EXT + }; + + // wrapper class for enum VkMicromapCreateFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapCreateFlagBitsEXT.html + enum class MicromapCreateFlagBitsEXT : VkMicromapCreateFlagsEXT + { + eDeviceAddressCaptureReplay = VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT + }; + + // wrapper using for bitmask VkMicromapCreateFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapCreateFlagsEXT.html + using MicromapCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkMicromapCreateFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MicromapCreateFlagsEXT allFlags = MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay; + }; + + // wrapper class for enum VkBuildMicromapModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildMicromapModeEXT.html + enum class BuildMicromapModeEXT + { + eBuild = VK_BUILD_MICROMAP_MODE_BUILD_EXT + }; + + // wrapper class for enum VkOpacityMicromapFormatEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpacityMicromapFormatEXT.html + enum class OpacityMicromapFormatEXT + { + e2State = VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT, + e4State = VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT + }; + + // wrapper class for enum VkOpacityMicromapSpecialIndexEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpacityMicromapSpecialIndexEXT.html + enum class OpacityMicromapSpecialIndexEXT + { + eFullyTransparent = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT, + eFullyOpaque = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT, + eFullyUnknownTransparent = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT, + eFullyUnknownOpaque = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT, + eClusterGeometryDisableOpacityMicromapNV = VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_displacement_micromap === + + // wrapper class for enum VkDisplacementMicromapFormatNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplacementMicromapFormatNV.html + enum class DisplacementMicromapFormatNV + { + e64Triangles64Bytes = VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV, + e256Triangles128Bytes = VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV, + e1024Triangles128Bytes = VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV + }; + +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_ARM_scheduling_controls === + + // wrapper class for enum VkPhysicalDeviceSchedulingControlsFlagBitsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsFlagBitsARM.html + enum class PhysicalDeviceSchedulingControlsFlagBitsARM : VkPhysicalDeviceSchedulingControlsFlagsARM + { + eShaderCoreCount = VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM + }; + + // wrapper using for bitmask VkPhysicalDeviceSchedulingControlsFlagsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsFlagsARM.html + using PhysicalDeviceSchedulingControlsFlagsARM = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPhysicalDeviceSchedulingControlsFlagBitsARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PhysicalDeviceSchedulingControlsFlagsARM allFlags = PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount; + }; + + //=== VK_NV_ray_tracing_linear_swept_spheres === + + // wrapper class for enum VkRayTracingLssIndexingModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingLssIndexingModeNV.html + enum class RayTracingLssIndexingModeNV + { + eList = VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV, + eSuccessive = VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV + }; + + // wrapper class for enum VkRayTracingLssPrimitiveEndCapsModeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingLssPrimitiveEndCapsModeNV.html + enum class RayTracingLssPrimitiveEndCapsModeNV + { + eNone = VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV, + eChained = VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV + }; + + //=== VK_EXT_subpass_merge_feedback === + + // wrapper class for enum VkSubpassMergeStatusEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassMergeStatusEXT.html + enum class SubpassMergeStatusEXT + { + eMerged = VK_SUBPASS_MERGE_STATUS_MERGED_EXT, + eDisallowed = VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT, + eNotMergedSideEffects = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT, + eNotMergedSamplesMismatch = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT, + eNotMergedViewsMismatch = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT, + eNotMergedAliasing = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT, + eNotMergedDependencies = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT, + eNotMergedIncompatibleInputAttachment = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT, + eNotMergedTooManyAttachments = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT, + eNotMergedInsufficientStorage = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT, + eNotMergedDepthStencilCount = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT, + eNotMergedResolveAttachmentReuse = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT, + eNotMergedSingleSubpass = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT, + eNotMergedUnspecified = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT + }; + + //=== VK_LUNARG_direct_driver_loading === + + // wrapper class for enum VkDirectDriverLoadingModeLUNARG, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectDriverLoadingModeLUNARG.html + enum class DirectDriverLoadingModeLUNARG + { + eExclusive = VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG, + eInclusive = VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG + }; + + enum class DirectDriverLoadingFlagBitsLUNARG : VkDirectDriverLoadingFlagsLUNARG + { + }; + + // wrapper using for bitmask VkDirectDriverLoadingFlagsLUNARG, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectDriverLoadingFlagsLUNARG.html + using DirectDriverLoadingFlagsLUNARG = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DirectDriverLoadingFlagsLUNARG allFlags = {}; + }; + + //=== VK_ARM_tensors === + + // wrapper class for enum VkTensorCreateFlagBitsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCreateFlagBitsARM.html + enum class TensorCreateFlagBitsARM : VkTensorCreateFlagsARM + { + eMutableFormat = VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM, + eProtected = VK_TENSOR_CREATE_PROTECTED_BIT_ARM, + eDescriptorHeapCaptureReplay = VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM, + eDescriptorBufferCaptureReplay = VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM + }; + + // wrapper using for bitmask VkTensorCreateFlagsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCreateFlagsARM.html + using TensorCreateFlagsARM = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkTensorCreateFlagBitsARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR TensorCreateFlagsARM allFlags = TensorCreateFlagBitsARM::eMutableFormat | TensorCreateFlagBitsARM::eProtected | + TensorCreateFlagBitsARM::eDescriptorHeapCaptureReplay | + TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay; + }; + + // wrapper class for enum VkTensorUsageFlagBitsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorUsageFlagBitsARM.html + enum class TensorUsageFlagBitsARM : VkTensorUsageFlagsARM + { + eShader = VK_TENSOR_USAGE_SHADER_BIT_ARM, + eTransferSrc = VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM, + eTransferDst = VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM, + eImageAliasing = VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM, + eDataGraph = VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM + }; + + // wrapper using for bitmask VkTensorUsageFlagsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorUsageFlagsARM.html + using TensorUsageFlagsARM = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkTensorUsageFlagBitsARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR TensorUsageFlagsARM allFlags = TensorUsageFlagBitsARM::eShader | TensorUsageFlagBitsARM::eTransferSrc | + TensorUsageFlagBitsARM::eTransferDst | TensorUsageFlagBitsARM::eImageAliasing | + TensorUsageFlagBitsARM::eDataGraph; + }; + + // wrapper class for enum VkTensorTilingARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorTilingARM.html + enum class TensorTilingARM + { + eOptimal = VK_TENSOR_TILING_OPTIMAL_ARM, + eLinear = VK_TENSOR_TILING_LINEAR_ARM + }; + + //=== VK_NV_optical_flow === + + // wrapper class for enum VkOpticalFlowUsageFlagBitsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowUsageFlagBitsNV.html + enum class OpticalFlowUsageFlagBitsNV : VkOpticalFlowUsageFlagsNV + { + eUnknown = VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV, + eInput = VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV, + eOutput = VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV, + eHint = VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV, + eCost = VK_OPTICAL_FLOW_USAGE_COST_BIT_NV, + eGlobalFlow = VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV + }; + + // wrapper using for bitmask VkOpticalFlowUsageFlagsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowUsageFlagsNV.html + using OpticalFlowUsageFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkOpticalFlowUsageFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowUsageFlagsNV allFlags = OpticalFlowUsageFlagBitsNV::eUnknown | OpticalFlowUsageFlagBitsNV::eInput | + OpticalFlowUsageFlagBitsNV::eOutput | OpticalFlowUsageFlagBitsNV::eHint | + OpticalFlowUsageFlagBitsNV::eCost | OpticalFlowUsageFlagBitsNV::eGlobalFlow; + }; + + // wrapper class for enum VkOpticalFlowGridSizeFlagBitsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowGridSizeFlagBitsNV.html + enum class OpticalFlowGridSizeFlagBitsNV : VkOpticalFlowGridSizeFlagsNV + { + eUnknown = VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV, + e1X1 = VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV, + e2X2 = VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV, + e4X4 = VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV, + e8X8 = VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV + }; + + // wrapper using for bitmask VkOpticalFlowGridSizeFlagsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowGridSizeFlagsNV.html + using OpticalFlowGridSizeFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkOpticalFlowGridSizeFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowGridSizeFlagsNV allFlags = OpticalFlowGridSizeFlagBitsNV::eUnknown | OpticalFlowGridSizeFlagBitsNV::e1X1 | + OpticalFlowGridSizeFlagBitsNV::e2X2 | OpticalFlowGridSizeFlagBitsNV::e4X4 | + OpticalFlowGridSizeFlagBitsNV::e8X8; + }; + + // wrapper class for enum VkOpticalFlowPerformanceLevelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowPerformanceLevelNV.html + enum class OpticalFlowPerformanceLevelNV + { + eUnknown = VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV, + eSlow = VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV, + eMedium = VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV, + eFast = VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV + }; + + // wrapper class for enum VkOpticalFlowSessionBindingPointNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionBindingPointNV.html + enum class OpticalFlowSessionBindingPointNV + { + eUnknown = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV, + eInput = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV, + eReference = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV, + eHint = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV, + eFlowVector = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV, + eBackwardFlowVector = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV, + eCost = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV, + eBackwardCost = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV, + eGlobalFlow = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV + }; + + // wrapper class for enum VkOpticalFlowSessionCreateFlagBitsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreateFlagBitsNV.html + enum class OpticalFlowSessionCreateFlagBitsNV : VkOpticalFlowSessionCreateFlagsNV + { + eEnableHint = VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV, + eEnableCost = VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV, + eEnableGlobalFlow = VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV, + eAllowRegions = VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV, + eBothDirections = VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV + }; + + // wrapper using for bitmask VkOpticalFlowSessionCreateFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreateFlagsNV.html + using OpticalFlowSessionCreateFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkOpticalFlowSessionCreateFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowSessionCreateFlagsNV allFlags = + OpticalFlowSessionCreateFlagBitsNV::eEnableHint | OpticalFlowSessionCreateFlagBitsNV::eEnableCost | + OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow | OpticalFlowSessionCreateFlagBitsNV::eAllowRegions | + OpticalFlowSessionCreateFlagBitsNV::eBothDirections; + }; + + // wrapper class for enum VkOpticalFlowExecuteFlagBitsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowExecuteFlagBitsNV.html + enum class OpticalFlowExecuteFlagBitsNV : VkOpticalFlowExecuteFlagsNV + { + eDisableTemporalHints = VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV + }; + + // wrapper using for bitmask VkOpticalFlowExecuteFlagsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowExecuteFlagsNV.html + using OpticalFlowExecuteFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkOpticalFlowExecuteFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowExecuteFlagsNV allFlags = OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints; + }; + + //=== VK_AMD_anti_lag === + + // wrapper class for enum VkAntiLagModeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagModeAMD.html + enum class AntiLagModeAMD + { + eDriverControl = VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD, + eOn = VK_ANTI_LAG_MODE_ON_AMD, + eOff = VK_ANTI_LAG_MODE_OFF_AMD + }; + + // wrapper class for enum VkAntiLagStageAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagStageAMD.html + enum class AntiLagStageAMD + { + eInput = VK_ANTI_LAG_STAGE_INPUT_AMD, + ePresent = VK_ANTI_LAG_STAGE_PRESENT_AMD + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_dense_geometry_format === + + // wrapper class for enum VkCompressedTriangleFormatAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompressedTriangleFormatAMDX.html + enum class CompressedTriangleFormatAMDX + { + eDgf1 = VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX + }; + +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_shader_object === + + // wrapper class for enum VkShaderCreateFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCreateFlagBitsEXT.html + enum class ShaderCreateFlagBitsEXT : VkShaderCreateFlagsEXT + { + eLinkStage = VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, + eDescriptorHeap = VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT, + eAllowVaryingSubgroupSize = VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, + eRequireFullSubgroups = VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT, + eNoTaskShader = VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT, + eDispatchBase = VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT, + eFragmentShadingRateAttachment = VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT, + eFragmentDensityMapAttachment = VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, + eIndirectBindable = VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT, + e64BitIndexing = VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT + }; + + // wrapper using for bitmask VkShaderCreateFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCreateFlagsEXT.html + using ShaderCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkShaderCreateFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderCreateFlagsEXT allFlags = + ShaderCreateFlagBitsEXT::eLinkStage | ShaderCreateFlagBitsEXT::eDescriptorHeap | ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize | + ShaderCreateFlagBitsEXT::eRequireFullSubgroups | ShaderCreateFlagBitsEXT::eNoTaskShader | ShaderCreateFlagBitsEXT::eDispatchBase | + ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment | ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment | + ShaderCreateFlagBitsEXT::eIndirectBindable | ShaderCreateFlagBitsEXT::e64BitIndexing; + }; + + // wrapper class for enum VkShaderCodeTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCodeTypeEXT.html + enum class ShaderCodeTypeEXT + { + eBinary = VK_SHADER_CODE_TYPE_BINARY_EXT, + eSpirv = VK_SHADER_CODE_TYPE_SPIRV_EXT + }; + + //=== VK_KHR_surface_maintenance1 === + + // wrapper class for enum VkPresentScalingFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentScalingFlagBitsKHR.html + enum class PresentScalingFlagBitsKHR : VkPresentScalingFlagsKHR + { + eOneToOne = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR, + eAspectRatioStretch = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR, + eStretch = VK_PRESENT_SCALING_STRETCH_BIT_KHR + }; + + using PresentScalingFlagBitsEXT = PresentScalingFlagBitsKHR; + + // wrapper using for bitmask VkPresentScalingFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentScalingFlagsKHR.html + using PresentScalingFlagsKHR = Flags; + using PresentScalingFlagsEXT = PresentScalingFlagsKHR; + + template <> + struct FlagTraits + { + using WrappedType = VkPresentScalingFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PresentScalingFlagsKHR allFlags = + PresentScalingFlagBitsKHR::eOneToOne | PresentScalingFlagBitsKHR::eAspectRatioStretch | PresentScalingFlagBitsKHR::eStretch; + }; + + // wrapper class for enum VkPresentGravityFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentGravityFlagBitsKHR.html + enum class PresentGravityFlagBitsKHR : VkPresentGravityFlagsKHR + { + eMin = VK_PRESENT_GRAVITY_MIN_BIT_KHR, + eMax = VK_PRESENT_GRAVITY_MAX_BIT_KHR, + eCentered = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR + }; + + using PresentGravityFlagBitsEXT = PresentGravityFlagBitsKHR; + + // wrapper using for bitmask VkPresentGravityFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentGravityFlagsKHR.html + using PresentGravityFlagsKHR = Flags; + using PresentGravityFlagsEXT = PresentGravityFlagsKHR; + + template <> + struct FlagTraits + { + using WrappedType = VkPresentGravityFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PresentGravityFlagsKHR allFlags = + PresentGravityFlagBitsKHR::eMin | PresentGravityFlagBitsKHR::eMax | PresentGravityFlagBitsKHR::eCentered; + }; + + //=== VK_NV_cooperative_vector === + + // wrapper class for enum VkCooperativeVectorMatrixLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeVectorMatrixLayoutNV.html + enum class CooperativeVectorMatrixLayoutNV + { + eRowMajor = VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV, + eColumnMajor = VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV, + eInferencingOptimal = VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV, + eTrainingOptimal = VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV + }; + + // wrapper class for enum VkComponentTypeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkComponentTypeKHR.html + enum class ComponentTypeKHR + { + eFloat16 = VK_COMPONENT_TYPE_FLOAT16_KHR, + eFloat32 = VK_COMPONENT_TYPE_FLOAT32_KHR, + eFloat64 = VK_COMPONENT_TYPE_FLOAT64_KHR, + eSint8 = VK_COMPONENT_TYPE_SINT8_KHR, + eSint16 = VK_COMPONENT_TYPE_SINT16_KHR, + eSint32 = VK_COMPONENT_TYPE_SINT32_KHR, + eSint64 = VK_COMPONENT_TYPE_SINT64_KHR, + eUint8 = VK_COMPONENT_TYPE_UINT8_KHR, + eUint16 = VK_COMPONENT_TYPE_UINT16_KHR, + eUint32 = VK_COMPONENT_TYPE_UINT32_KHR, + eUint64 = VK_COMPONENT_TYPE_UINT64_KHR, + eBfloat16 = VK_COMPONENT_TYPE_BFLOAT16_KHR, + eSint8PackedNV = VK_COMPONENT_TYPE_SINT8_PACKED_NV, + eUint8PackedNV = VK_COMPONENT_TYPE_UINT8_PACKED_NV, + eFloat8E4M3EXT = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT, + eFloatE4M3 = VK_COMPONENT_TYPE_FLOAT_E4M3_NV, + eFloat8E5M2EXT = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT, + eFloatE5M2 = VK_COMPONENT_TYPE_FLOAT_E5M2_NV + }; + + using ComponentTypeNV = ComponentTypeKHR; + + //=== VK_EXT_layer_settings === + + // wrapper class for enum VkLayerSettingTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayerSettingTypeEXT.html + enum class LayerSettingTypeEXT + { + eBool32 = VK_LAYER_SETTING_TYPE_BOOL32_EXT, + eInt32 = VK_LAYER_SETTING_TYPE_INT32_EXT, + eInt64 = VK_LAYER_SETTING_TYPE_INT64_EXT, + eUint32 = VK_LAYER_SETTING_TYPE_UINT32_EXT, + eUint64 = VK_LAYER_SETTING_TYPE_UINT64_EXT, + eFloat32 = VK_LAYER_SETTING_TYPE_FLOAT32_EXT, + eFloat64 = VK_LAYER_SETTING_TYPE_FLOAT64_EXT, + eString = VK_LAYER_SETTING_TYPE_STRING_EXT + }; + + //================================= + //=== Layer Setting Type Traits === + //================================= + + template <> + struct CppType + { + using Type = Bool32; + }; + + template <> + struct CppType + { + using Type = int32_t; + }; + + template <> + struct CppType + { + using Type = int64_t; + }; + + template <> + struct CppType + { + using Type = uint32_t; + }; + + template <> + struct CppType + { + using Type = uint64_t; + }; + + template <> + struct CppType + { + using Type = float; + }; + + template <> + struct CppType + { + using Type = double; + }; + + template <> + struct CppType + { + using Type = char *; + }; + + template + bool isSameType( LayerSettingTypeEXT layerSettingType ) + { + switch ( layerSettingType ) + { + case LayerSettingTypeEXT::eBool32 : return std::is_same::value; + case LayerSettingTypeEXT::eInt32 : return std::is_same::value; + case LayerSettingTypeEXT::eInt64 : return std::is_same::value; + case LayerSettingTypeEXT::eUint32 : return std::is_same::value; + case LayerSettingTypeEXT::eUint64 : return std::is_same::value; + case LayerSettingTypeEXT::eFloat32: return std::is_same::value; + case LayerSettingTypeEXT::eFloat64: return std::is_same::value; + case LayerSettingTypeEXT::eString : return std::is_same::value; + default : return false; + } + } + + //=== VK_NV_low_latency2 === + + // wrapper class for enum VkLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencyMarkerNV.html + enum class LatencyMarkerNV + { + eSimulationStart = VK_LATENCY_MARKER_SIMULATION_START_NV, + eSimulationEnd = VK_LATENCY_MARKER_SIMULATION_END_NV, + eRendersubmitStart = VK_LATENCY_MARKER_RENDERSUBMIT_START_NV, + eRendersubmitEnd = VK_LATENCY_MARKER_RENDERSUBMIT_END_NV, + ePresentStart = VK_LATENCY_MARKER_PRESENT_START_NV, + ePresentEnd = VK_LATENCY_MARKER_PRESENT_END_NV, + eInputSample = VK_LATENCY_MARKER_INPUT_SAMPLE_NV, + eTriggerFlash = VK_LATENCY_MARKER_TRIGGER_FLASH_NV, + eOutOfBandRendersubmitStart = VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV, + eOutOfBandRendersubmitEnd = VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV, + eOutOfBandPresentStart = VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV, + eOutOfBandPresentEnd = VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV + }; + + // wrapper class for enum VkOutOfBandQueueTypeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOutOfBandQueueTypeNV.html + enum class OutOfBandQueueTypeNV + { + eRender = VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV, + ePresent = VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV + }; + + //=== VK_KHR_cooperative_matrix === + + // wrapper class for enum VkScopeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkScopeKHR.html + enum class ScopeKHR + { + eDevice = VK_SCOPE_DEVICE_KHR, + eWorkgroup = VK_SCOPE_WORKGROUP_KHR, + eSubgroup = VK_SCOPE_SUBGROUP_KHR, + eQueueFamily = VK_SCOPE_QUEUE_FAMILY_KHR + }; + + using ScopeNV = ScopeKHR; + + //=== VK_ARM_data_graph === + + // wrapper class for enum VkDataGraphPipelineSessionBindPointARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointARM.html + enum class DataGraphPipelineSessionBindPointARM + { + eTransient = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM + }; + + // wrapper class for enum VkDataGraphPipelineSessionBindPointTypeARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointTypeARM.html + enum class DataGraphPipelineSessionBindPointTypeARM + { + eMemory = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM + }; + + // wrapper class for enum VkDataGraphPipelineSessionCreateFlagBitsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionCreateFlagBitsARM.html + enum class DataGraphPipelineSessionCreateFlagBitsARM : VkDataGraphPipelineSessionCreateFlagsARM + { + eProtected = VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM + }; + + // wrapper using for bitmask VkDataGraphPipelineSessionCreateFlagsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionCreateFlagsARM.html + using DataGraphPipelineSessionCreateFlagsARM = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkDataGraphPipelineSessionCreateFlagBitsARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DataGraphPipelineSessionCreateFlagsARM allFlags = DataGraphPipelineSessionCreateFlagBitsARM::eProtected; + }; + + // wrapper class for enum VkDataGraphPipelinePropertyARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelinePropertyARM.html + enum class DataGraphPipelinePropertyARM + { + eCreationLog = VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM, + eIdentifier = VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM + }; + + enum class DataGraphPipelineDispatchFlagBitsARM : VkDataGraphPipelineDispatchFlagsARM + { + }; + + // wrapper using for bitmask VkDataGraphPipelineDispatchFlagsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineDispatchFlagsARM.html + using DataGraphPipelineDispatchFlagsARM = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR DataGraphPipelineDispatchFlagsARM allFlags = {}; + }; + + // wrapper class for enum VkPhysicalDeviceDataGraphProcessingEngineTypeARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphProcessingEngineTypeARM.html + enum class PhysicalDeviceDataGraphProcessingEngineTypeARM + { + eDefault = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM, + eNeuralQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM, + eComputeQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM + }; + + // wrapper class for enum VkPhysicalDeviceDataGraphOperationTypeARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationTypeARM.html + enum class PhysicalDeviceDataGraphOperationTypeARM + { + eSpirvExtendedInstructionSet = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM, + eNeuralModelQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM, + eBuiltinModelQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM + }; + + //=== VK_KHR_video_encode_av1 === + + // wrapper class for enum VkVideoEncodeAV1PredictionModeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1PredictionModeKHR.html + enum class VideoEncodeAV1PredictionModeKHR + { + eIntraOnly = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR, + eSingleReference = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR, + eUnidirectionalCompound = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR, + eBidirectionalCompound = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR + }; + + // wrapper class for enum VkVideoEncodeAV1RateControlGroupKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlGroupKHR.html + enum class VideoEncodeAV1RateControlGroupKHR + { + eIntra = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR, + ePredictive = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR, + eBipredictive = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR + }; + + // wrapper class for enum VkVideoEncodeAV1CapabilityFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1CapabilityFlagBitsKHR.html + enum class VideoEncodeAV1CapabilityFlagBitsKHR : VkVideoEncodeAV1CapabilityFlagsKHR + { + ePerRateControlGroupMinMaxQIndex = VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR, + eGenerateObuExtensionHeader = VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR, + ePrimaryReferenceCdfOnly = VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR, + eFrameSizeOverride = VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR, + eMotionVectorScaling = VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR, + eCompoundPredictionIntraRefresh = VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeAV1CapabilityFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1CapabilityFlagsKHR.html + using VideoEncodeAV1CapabilityFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeAV1CapabilityFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1CapabilityFlagsKHR allFlags = + VideoEncodeAV1CapabilityFlagBitsKHR::ePerRateControlGroupMinMaxQIndex | VideoEncodeAV1CapabilityFlagBitsKHR::eGenerateObuExtensionHeader | + VideoEncodeAV1CapabilityFlagBitsKHR::ePrimaryReferenceCdfOnly | VideoEncodeAV1CapabilityFlagBitsKHR::eFrameSizeOverride | + VideoEncodeAV1CapabilityFlagBitsKHR::eMotionVectorScaling | VideoEncodeAV1CapabilityFlagBitsKHR::eCompoundPredictionIntraRefresh; + }; + + // wrapper class for enum VkVideoEncodeAV1StdFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1StdFlagBitsKHR.html + enum class VideoEncodeAV1StdFlagBitsKHR : VkVideoEncodeAV1StdFlagsKHR + { + eUniformTileSpacingFlagSet = VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR, + eSkipModePresentUnset = VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR, + ePrimaryRefFrame = VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR, + eDeltaQ = VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeAV1StdFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1StdFlagsKHR.html + using VideoEncodeAV1StdFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeAV1StdFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1StdFlagsKHR allFlags = + VideoEncodeAV1StdFlagBitsKHR::eUniformTileSpacingFlagSet | VideoEncodeAV1StdFlagBitsKHR::eSkipModePresentUnset | + VideoEncodeAV1StdFlagBitsKHR::ePrimaryRefFrame | VideoEncodeAV1StdFlagBitsKHR::eDeltaQ; + }; + + // wrapper class for enum VkVideoEncodeAV1SuperblockSizeFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1SuperblockSizeFlagBitsKHR.html + enum class VideoEncodeAV1SuperblockSizeFlagBitsKHR : VkVideoEncodeAV1SuperblockSizeFlagsKHR + { + e64 = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR, + e128 = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeAV1SuperblockSizeFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1SuperblockSizeFlagsKHR.html + using VideoEncodeAV1SuperblockSizeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeAV1SuperblockSizeFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1SuperblockSizeFlagsKHR allFlags = + VideoEncodeAV1SuperblockSizeFlagBitsKHR::e64 | VideoEncodeAV1SuperblockSizeFlagBitsKHR::e128; + }; + + // wrapper class for enum VkVideoEncodeAV1RateControlFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlFlagBitsKHR.html + enum class VideoEncodeAV1RateControlFlagBitsKHR : VkVideoEncodeAV1RateControlFlagsKHR + { + eRegularGop = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR, + eTemporalLayerPatternDyadic = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR, + eReferencePatternFlat = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR, + eReferencePatternDyadic = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeAV1RateControlFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlFlagsKHR.html + using VideoEncodeAV1RateControlFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeAV1RateControlFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1RateControlFlagsKHR allFlags = + VideoEncodeAV1RateControlFlagBitsKHR::eRegularGop | VideoEncodeAV1RateControlFlagBitsKHR::eTemporalLayerPatternDyadic | + VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternFlat | VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternDyadic; + }; + + //=== VK_QCOM_image_processing2 === + + // wrapper class for enum VkBlockMatchWindowCompareModeQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlockMatchWindowCompareModeQCOM.html + enum class BlockMatchWindowCompareModeQCOM + { + eMin = VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM, + eMax = VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM + }; + + //=== VK_QCOM_filter_cubic_weights === + + // wrapper class for enum VkCubicFilterWeightsQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCubicFilterWeightsQCOM.html + enum class CubicFilterWeightsQCOM + { + eCatmullRom = VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM, + eZeroTangentCardinal = VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM, + eBSpline = VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM, + eMitchellNetravali = VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM + }; + + //=== VK_MSFT_layered_driver === + + // wrapper class for enum VkLayeredDriverUnderlyingApiMSFT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayeredDriverUnderlyingApiMSFT.html + enum class LayeredDriverUnderlyingApiMSFT + { + eNone = VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT, + eD3D12 = VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT + }; + + //=== VK_KHR_calibrated_timestamps === + + // wrapper class for enum VkTimeDomainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTimeDomainKHR.html + enum class TimeDomainKHR + { + eDevice = VK_TIME_DOMAIN_DEVICE_KHR, + eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR, + eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR, + eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR, + ePresentStageLocalEXT = VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT, + eSwapchainLocalEXT = VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT + }; + + using TimeDomainEXT = TimeDomainKHR; + + //=== VK_KHR_copy_memory_indirect === + + // wrapper class for enum VkAddressCopyFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCopyFlagBitsKHR.html + enum class AddressCopyFlagBitsKHR : VkAddressCopyFlagsKHR + { + eDeviceLocal = VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR, + eSparse = VK_ADDRESS_COPY_SPARSE_BIT_KHR, + eProtected = VK_ADDRESS_COPY_PROTECTED_BIT_KHR + }; + + // wrapper using for bitmask VkAddressCopyFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCopyFlagsKHR.html + using AddressCopyFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkAddressCopyFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AddressCopyFlagsKHR allFlags = + AddressCopyFlagBitsKHR::eDeviceLocal | AddressCopyFlagBitsKHR::eSparse | AddressCopyFlagBitsKHR::eProtected; + }; + + //=== VK_EXT_memory_decompression === + + // wrapper class for enum VkMemoryDecompressionMethodFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDecompressionMethodFlagBitsEXT.html + enum class MemoryDecompressionMethodFlagBitsEXT : VkMemoryDecompressionMethodFlagsEXT + { + eGdeflate10 = VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT + }; + + using MemoryDecompressionMethodFlagBitsNV = MemoryDecompressionMethodFlagBitsEXT; + + // wrapper using for bitmask VkMemoryDecompressionMethodFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDecompressionMethodFlagsEXT.html + using MemoryDecompressionMethodFlagsEXT = Flags; + using MemoryDecompressionMethodFlagsNV = MemoryDecompressionMethodFlagsEXT; + + template <> + struct FlagTraits + { + using WrappedType = VkMemoryDecompressionMethodFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryDecompressionMethodFlagsEXT allFlags = MemoryDecompressionMethodFlagBitsEXT::eGdeflate10; + }; + + //=== VK_NV_display_stereo === + + // wrapper class for enum VkDisplaySurfaceStereoTypeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplaySurfaceStereoTypeNV.html + enum class DisplaySurfaceStereoTypeNV + { + eNone = VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV, + eOnboardDin = VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV, + eHdmi3D = VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV, + eInbandDisplayport = VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV + }; + + //=== VK_KHR_video_encode_intra_refresh === + + // wrapper class for enum VkVideoEncodeIntraRefreshModeFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeIntraRefreshModeFlagBitsKHR.html + enum class VideoEncodeIntraRefreshModeFlagBitsKHR : VkVideoEncodeIntraRefreshModeFlagsKHR + { + eNone = VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR, + ePerPicturePartition = VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR, + eBlockBased = VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR, + eBlockRowBased = VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR, + eBlockColumnBased = VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR + }; + + // wrapper using for bitmask VkVideoEncodeIntraRefreshModeFlagsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeIntraRefreshModeFlagsKHR.html + using VideoEncodeIntraRefreshModeFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkVideoEncodeIntraRefreshModeFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeIntraRefreshModeFlagsKHR allFlags = + VideoEncodeIntraRefreshModeFlagBitsKHR::eNone | VideoEncodeIntraRefreshModeFlagBitsKHR::ePerPicturePartition | + VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockBased | VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockRowBased | + VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockColumnBased; + }; + + //=== VK_KHR_maintenance7 === + + // wrapper class for enum VkPhysicalDeviceLayeredApiKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiKHR.html + enum class PhysicalDeviceLayeredApiKHR + { + eVulkan = VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR, + eD3D12 = VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR, + eMetal = VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR, + eOpengl = VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR, + eOpengles = VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR + }; + + //=== VK_NV_cluster_acceleration_structure === + + // wrapper class for enum VkClusterAccelerationStructureClusterFlagBitsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureClusterFlagBitsNV.html + enum class ClusterAccelerationStructureClusterFlagBitsNV : VkClusterAccelerationStructureClusterFlagsNV + { + eAllowDisableOpacityMicromaps = VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV + }; + + // wrapper using for bitmask VkClusterAccelerationStructureClusterFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureClusterFlagsNV.html + using ClusterAccelerationStructureClusterFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkClusterAccelerationStructureClusterFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureClusterFlagsNV allFlags = + ClusterAccelerationStructureClusterFlagBitsNV::eAllowDisableOpacityMicromaps; + }; + + // wrapper class for enum VkClusterAccelerationStructureGeometryFlagBitsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGeometryFlagBitsNV.html + enum class ClusterAccelerationStructureGeometryFlagBitsNV : VkClusterAccelerationStructureGeometryFlagsNV + { + eCullDisable = VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV, + eNoDuplicateAnyhitInvocation = VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV, + eOpaque = VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV + }; + + // wrapper using for bitmask VkClusterAccelerationStructureGeometryFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGeometryFlagsNV.html + using ClusterAccelerationStructureGeometryFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkClusterAccelerationStructureGeometryFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureGeometryFlagsNV allFlags = + ClusterAccelerationStructureGeometryFlagBitsNV::eCullDisable | ClusterAccelerationStructureGeometryFlagBitsNV::eNoDuplicateAnyhitInvocation | + ClusterAccelerationStructureGeometryFlagBitsNV::eOpaque; + }; + + // wrapper class for enum VkClusterAccelerationStructureAddressResolutionFlagBitsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureAddressResolutionFlagBitsNV.html + enum class ClusterAccelerationStructureAddressResolutionFlagBitsNV : VkClusterAccelerationStructureAddressResolutionFlagsNV + { + eNone = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV, + eIndirectedDstImplicitData = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV, + eIndirectedScratchData = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV, + eIndirectedDstAddressArray = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV, + eIndirectedDstSizesArray = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV, + eIndirectedSrcInfosArray = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV, + eIndirectedSrcInfosCount = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV + }; + + // wrapper using for bitmask VkClusterAccelerationStructureAddressResolutionFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureAddressResolutionFlagsNV.html + using ClusterAccelerationStructureAddressResolutionFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkClusterAccelerationStructureAddressResolutionFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureAddressResolutionFlagsNV allFlags = + ClusterAccelerationStructureAddressResolutionFlagBitsNV::eNone | ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstImplicitData | + ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedScratchData | + ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstAddressArray | + ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstSizesArray | + ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosArray | + ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosCount; + }; + + // wrapper class for enum VkClusterAccelerationStructureIndexFormatFlagBitsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureIndexFormatFlagBitsNV.html + enum class ClusterAccelerationStructureIndexFormatFlagBitsNV : VkClusterAccelerationStructureIndexFormatFlagsNV + { + e8 = VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV, + e16 = VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV, + e32 = VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV + }; + + // wrapper using for bitmask VkClusterAccelerationStructureIndexFormatFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureIndexFormatFlagsNV.html + using ClusterAccelerationStructureIndexFormatFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkClusterAccelerationStructureIndexFormatFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureIndexFormatFlagsNV allFlags = ClusterAccelerationStructureIndexFormatFlagBitsNV::e8 | + ClusterAccelerationStructureIndexFormatFlagBitsNV::e16 | + ClusterAccelerationStructureIndexFormatFlagBitsNV::e32; + }; + + // wrapper class for enum VkClusterAccelerationStructureTypeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureTypeNV.html + enum class ClusterAccelerationStructureTypeNV + { + eClustersBottomLevel = VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV, + eTriangleCluster = VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV, + eTriangleClusterTemplate = VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV + }; + + // wrapper class for enum VkClusterAccelerationStructureOpTypeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureOpTypeNV.html + enum class ClusterAccelerationStructureOpTypeNV + { + eMoveObjects = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV, + eBuildClustersBottomLevel = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV, + eBuildTriangleCluster = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV, + eBuildTriangleClusterTemplate = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV, + eInstantiateTriangleCluster = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV, + eGetClusterTemplateIndices = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV + }; + + // wrapper class for enum VkClusterAccelerationStructureOpModeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureOpModeNV.html + enum class ClusterAccelerationStructureOpModeNV + { + eImplicitDestinations = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV, + eExplicitDestinations = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV, + eComputeSizes = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV + }; + + //=== VK_NV_partitioned_acceleration_structure === + + // wrapper class for enum VkPartitionedAccelerationStructureOpTypeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureOpTypeNV.html + enum class PartitionedAccelerationStructureOpTypeNV + { + eWriteInstance = VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV, + eUpdateInstance = VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV, + eWritePartitionTranslation = VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV + }; + + // wrapper class for enum VkPartitionedAccelerationStructureInstanceFlagBitsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureInstanceFlagBitsNV.html + enum class PartitionedAccelerationStructureInstanceFlagBitsNV : VkPartitionedAccelerationStructureInstanceFlagsNV + { + eFlagTriangleFacingCullDisable = VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV, + eFlagTriangleFlipFacing = VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV, + eFlagForceOpaque = VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV, + eFlagForceNoOpaque = VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV, + eFlagEnableExplicitBoundingBox = VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV + }; + + // wrapper using for bitmask VkPartitionedAccelerationStructureInstanceFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureInstanceFlagsNV.html + using PartitionedAccelerationStructureInstanceFlagsNV = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkPartitionedAccelerationStructureInstanceFlagBitsNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PartitionedAccelerationStructureInstanceFlagsNV allFlags = + PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFacingCullDisable | + PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFlipFacing | PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceOpaque | + PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceNoOpaque | + PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagEnableExplicitBoundingBox; + }; + + //=== VK_EXT_device_generated_commands === + + // wrapper class for enum VkIndirectCommandsTokenTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsTokenTypeEXT.html + enum class IndirectCommandsTokenTypeEXT + { + eExecutionSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT, + ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT, + eSequenceIndex = VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT, + eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT, + eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT, + eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT, + eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT, + eDrawIndexedCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT, + eDrawCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT, + eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT, + ePushData = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT, + ePushDataSequenceIndex = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT, + eDrawMeshTasksNV = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT, + eDrawMeshTasksCountNV = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT, + eDrawMeshTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT, + eDrawMeshTasksCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT, + eTraceRays2 = VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT + }; + + // wrapper class for enum VkIndirectExecutionSetInfoTypeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetInfoTypeEXT.html + enum class IndirectExecutionSetInfoTypeEXT + { + ePipelines = VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT, + eShaderObjects = VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT + }; + + // wrapper class for enum VkIndirectCommandsLayoutUsageFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagBitsEXT.html + enum class IndirectCommandsLayoutUsageFlagBitsEXT : VkIndirectCommandsLayoutUsageFlagsEXT + { + eExplicitPreprocess = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT, + eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT + }; + + // wrapper using for bitmask VkIndirectCommandsLayoutUsageFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagsEXT.html + using IndirectCommandsLayoutUsageFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkIndirectCommandsLayoutUsageFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectCommandsLayoutUsageFlagsEXT allFlags = + IndirectCommandsLayoutUsageFlagBitsEXT::eExplicitPreprocess | IndirectCommandsLayoutUsageFlagBitsEXT::eUnorderedSequences; + }; + + // wrapper class for enum VkIndirectCommandsInputModeFlagBitsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsInputModeFlagBitsEXT.html + enum class IndirectCommandsInputModeFlagBitsEXT : VkIndirectCommandsInputModeFlagsEXT + { + eVulkanIndexBuffer = VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT, + eDxgiIndexBuffer = VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT + }; + + // wrapper using for bitmask VkIndirectCommandsInputModeFlagsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsInputModeFlagsEXT.html + using IndirectCommandsInputModeFlagsEXT = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkIndirectCommandsInputModeFlagBitsEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectCommandsInputModeFlagsEXT allFlags = + IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer | IndirectCommandsInputModeFlagBitsEXT::eDxgiIndexBuffer; + }; + + //=== VK_KHR_maintenance8 === + + // wrapper class for enum VkAccessFlagBits3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits3KHR.html + enum class AccessFlagBits3KHR : VkAccessFlags3KHR + { + eNone = VK_ACCESS_3_NONE_KHR + }; + + // wrapper using for bitmask VkAccessFlags3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlags3KHR.html + using AccessFlags3KHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkAccessFlagBits3KHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags3KHR allFlags = AccessFlagBits3KHR::eNone; + }; + + //=== VK_EXT_ray_tracing_invocation_reorder === + + // wrapper class for enum VkRayTracingInvocationReorderModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingInvocationReorderModeEXT.html + enum class RayTracingInvocationReorderModeEXT + { + eNone = VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT, + eReorder = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT + }; + + using RayTracingInvocationReorderModeNV = RayTracingInvocationReorderModeEXT; + + //=== VK_EXT_depth_clamp_control === + + // wrapper class for enum VkDepthClampModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthClampModeEXT.html + enum class DepthClampModeEXT + { + eViewportRange = VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT, + eUserDefinedRange = VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT + }; + + //=== VK_KHR_maintenance9 === + + // wrapper class for enum VkDefaultVertexAttributeValueKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDefaultVertexAttributeValueKHR.html + enum class DefaultVertexAttributeValueKHR + { + eZeroZeroZeroZero = VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR, + eZeroZeroZeroOne = VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR + }; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + + enum class SurfaceCreateFlagBitsOHOS : VkSurfaceCreateFlagsOHOS + { + }; + + // wrapper using for bitmask VkSurfaceCreateFlagsOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCreateFlagsOHOS.html + using SurfaceCreateFlagsOHOS = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceCreateFlagsOHOS allFlags = {}; + }; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_ARM_performance_counters_by_region === + + enum class PerformanceCounterDescriptionFlagBitsARM : VkPerformanceCounterDescriptionFlagsARM + { + }; + + // wrapper using for bitmask VkPerformanceCounterDescriptionFlagsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionFlagsARM.html + using PerformanceCounterDescriptionFlagsARM = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR PerformanceCounterDescriptionFlagsARM allFlags = {}; + }; + + //=== VK_QCOM_data_graph_model === + + // wrapper class for enum VkDataGraphModelCacheTypeQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphModelCacheTypeQCOM.html + enum class DataGraphModelCacheTypeQCOM + { + eGenericBinary = VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM + }; + + //=== VK_KHR_maintenance10 === + + // wrapper class for enum VkRenderingAttachmentFlagBitsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentFlagBitsKHR.html + enum class RenderingAttachmentFlagBitsKHR : VkRenderingAttachmentFlagsKHR + { + eInputAttachmentFeedback = VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR, + eResolveSkipTransferFunction = VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR, + eResolveEnableTransferFunction = VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR + }; + + // wrapper using for bitmask VkRenderingAttachmentFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentFlagsKHR.html + using RenderingAttachmentFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkRenderingAttachmentFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR RenderingAttachmentFlagsKHR allFlags = RenderingAttachmentFlagBitsKHR::eInputAttachmentFeedback | + RenderingAttachmentFlagBitsKHR::eResolveSkipTransferFunction | + RenderingAttachmentFlagBitsKHR::eResolveEnableTransferFunction; + }; + + // wrapper class for enum VkResolveImageFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveImageFlagBitsKHR.html + enum class ResolveImageFlagBitsKHR : VkResolveImageFlagsKHR + { + eSkipTransferFunction = VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR, + eEnableTransferFunction = VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR + }; + + // wrapper using for bitmask VkResolveImageFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveImageFlagsKHR.html + using ResolveImageFlagsKHR = Flags; + + template <> + struct FlagTraits + { + using WrappedType = VkResolveImageFlagBitsKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveImageFlagsKHR allFlags = + ResolveImageFlagBitsKHR::eSkipTransferFunction | ResolveImageFlagBitsKHR::eEnableTransferFunction; + }; + + //=========================================================== + //=== Mapping from ObjectType to DebugReportObjectTypeEXT === + //=========================================================== + + VULKAN_HPP_INLINE DebugReportObjectTypeEXT debugReportObjectType( ObjectType objectType ) + { + switch ( objectType ) + { + //=== VK_VERSION_1_0 === + case ObjectType::eInstance : return DebugReportObjectTypeEXT::eInstance; + case ObjectType::ePhysicalDevice : return DebugReportObjectTypeEXT::ePhysicalDevice; + case ObjectType::eDevice : return DebugReportObjectTypeEXT::eDevice; + case ObjectType::eQueue : return DebugReportObjectTypeEXT::eQueue; + case ObjectType::eDeviceMemory : return DebugReportObjectTypeEXT::eDeviceMemory; + case ObjectType::eFence : return DebugReportObjectTypeEXT::eFence; + case ObjectType::eSemaphore : return DebugReportObjectTypeEXT::eSemaphore; + case ObjectType::eQueryPool : return DebugReportObjectTypeEXT::eQueryPool; + case ObjectType::eBuffer : return DebugReportObjectTypeEXT::eBuffer; + case ObjectType::eImage : return DebugReportObjectTypeEXT::eImage; + case ObjectType::eImageView : return DebugReportObjectTypeEXT::eImageView; + case ObjectType::eCommandPool : return DebugReportObjectTypeEXT::eCommandPool; + case ObjectType::eCommandBuffer : return DebugReportObjectTypeEXT::eCommandBuffer; + case ObjectType::eEvent : return DebugReportObjectTypeEXT::eEvent; + case ObjectType::eBufferView : return DebugReportObjectTypeEXT::eBufferView; + case ObjectType::eShaderModule : return DebugReportObjectTypeEXT::eShaderModule; + case ObjectType::ePipelineCache : return DebugReportObjectTypeEXT::ePipelineCache; + case ObjectType::ePipeline : return DebugReportObjectTypeEXT::ePipeline; + case ObjectType::ePipelineLayout : return DebugReportObjectTypeEXT::ePipelineLayout; + case ObjectType::eSampler : return DebugReportObjectTypeEXT::eSampler; + case ObjectType::eDescriptorPool : return DebugReportObjectTypeEXT::eDescriptorPool; + case ObjectType::eDescriptorSet : return DebugReportObjectTypeEXT::eDescriptorSet; + case ObjectType::eDescriptorSetLayout: return DebugReportObjectTypeEXT::eDescriptorSetLayout; + case ObjectType::eFramebuffer : return DebugReportObjectTypeEXT::eFramebuffer; + case ObjectType::eRenderPass: + return DebugReportObjectTypeEXT::eRenderPass; + + //=== VK_VERSION_1_1 === + case ObjectType::eDescriptorUpdateTemplate: return DebugReportObjectTypeEXT::eDescriptorUpdateTemplate; + case ObjectType::eSamplerYcbcrConversion: + return DebugReportObjectTypeEXT::eSamplerYcbcrConversion; + + //=== VK_VERSION_1_3 === + case ObjectType::ePrivateDataSlot: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_KHR_surface === + case ObjectType::eSurfaceKHR: + return DebugReportObjectTypeEXT::eSurfaceKHR; + + //=== VK_KHR_swapchain === + case ObjectType::eSwapchainKHR: + return DebugReportObjectTypeEXT::eSwapchainKHR; + + //=== VK_KHR_display === + case ObjectType::eDisplayKHR: return DebugReportObjectTypeEXT::eDisplayKHR; + case ObjectType::eDisplayModeKHR: + return DebugReportObjectTypeEXT::eDisplayModeKHR; + + //=== VK_EXT_debug_report === + case ObjectType::eDebugReportCallbackEXT: + return DebugReportObjectTypeEXT::eDebugReportCallbackEXT; + + //=== VK_KHR_video_queue === + case ObjectType::eVideoSessionKHR: return DebugReportObjectTypeEXT::eUnknown; + case ObjectType::eVideoSessionParametersKHR: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_NVX_binary_import === + case ObjectType::eCuModuleNVX: return DebugReportObjectTypeEXT::eCuModuleNVX; + case ObjectType::eCuFunctionNVX: + return DebugReportObjectTypeEXT::eCuFunctionNVX; + + //=== VK_EXT_debug_utils === + case ObjectType::eDebugUtilsMessengerEXT: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_EXT_descriptor_heap === + case ObjectType::eTensorARM: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_KHR_acceleration_structure === + case ObjectType::eAccelerationStructureKHR: + return DebugReportObjectTypeEXT::eAccelerationStructureKHR; + + //=== VK_EXT_validation_cache === + case ObjectType::eValidationCacheEXT: + return DebugReportObjectTypeEXT::eValidationCacheEXT; + + //=== VK_NV_ray_tracing === + case ObjectType::eAccelerationStructureNV: + return DebugReportObjectTypeEXT::eAccelerationStructureNV; + + //=== VK_INTEL_performance_query === + case ObjectType::ePerformanceConfigurationINTEL: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_KHR_deferred_host_operations === + case ObjectType::eDeferredOperationKHR: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_NV_device_generated_commands === + case ObjectType::eIndirectCommandsLayoutNV: return DebugReportObjectTypeEXT::eUnknown; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + case ObjectType::eCudaModuleNV : return DebugReportObjectTypeEXT::eCudaModuleNV; + case ObjectType::eCudaFunctionNV: return DebugReportObjectTypeEXT::eCudaFunctionNV; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + case ObjectType::eBufferCollectionFUCHSIA: return DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + case ObjectType::eMicromapEXT: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_ARM_tensors === + case ObjectType::eTensorViewARM: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_NV_optical_flow === + case ObjectType::eOpticalFlowSessionNV: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_EXT_shader_object === + case ObjectType::eShaderEXT: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_KHR_pipeline_binary === + case ObjectType::ePipelineBinaryKHR: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_ARM_data_graph === + case ObjectType::eDataGraphPipelineSessionARM: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_NV_external_compute_queue === + case ObjectType::eExternalComputeQueueNV: + return DebugReportObjectTypeEXT::eUnknown; + + //=== VK_EXT_device_generated_commands === + case ObjectType::eIndirectCommandsLayoutEXT: return DebugReportObjectTypeEXT::eUnknown; + case ObjectType::eIndirectExecutionSetEXT : return DebugReportObjectTypeEXT::eUnknown; + + default: VULKAN_HPP_ASSERT( false && "unknown ObjectType" ); return DebugReportObjectTypeEXT::eUnknown; + } + } + +} // namespace VULKAN_HPP_NAMESPACE +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_extension_inspection.hpp b/lib/vulkan-headers/include/vulkan/vulkan_extension_inspection.hpp new file mode 100644 index 00000000000..34c9779f801 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_extension_inspection.hpp @@ -0,0 +1,4155 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_EXTENSION_INSPECTION_HPP +#define VULKAN_EXTENSION_INSPECTION_HPP + +#if !defined( VULKAN_HPP_CXX_MODULE ) +# include +# include +# include +# include +# include +#endif + +namespace VULKAN_HPP_NAMESPACE +{ + //====================================== + //=== Extension inspection functions === + //====================================== + + std::set const & getDeviceExtensions(); + std::set const & getInstanceExtensions(); + std::map const & getDeprecatedExtensions(); + std::map>> const & getExtensionDepends( std::string const & extension ); + std::pair> const &> getExtensionDepends( std::string const & version, std::string const & extension ); + std::map const & getObsoletedExtensions(); + std::map const & getPromotedExtensions(); + VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & extension ); + VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & extension ); + VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & extension ); + VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & extension ); + VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension ); + VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension ); + VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension ); + VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & extension ); + + //===================================================== + //=== Extension inspection function implementations === + //===================================================== + + VULKAN_HPP_INLINE std::map const & getDeprecatedExtensions() + { + static const std::map deprecatedExtensions = { { "VK_EXT_debug_report", "VK_EXT_debug_utils" }, + { "VK_NV_glsl_shader", "" }, + { "VK_NV_dedicated_allocation", "VK_KHR_dedicated_allocation" }, + { "VK_AMD_gpu_shader_half_float", "VK_KHR_shader_float16_int8" }, + { "VK_IMG_format_pvrtc", "" }, + { "VK_NV_external_memory_capabilities", "VK_KHR_external_memory_capabilities" }, + { "VK_NV_external_memory", "VK_KHR_external_memory" }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "VK_NV_external_memory_win32", "VK_KHR_external_memory_win32" }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "VK_EXT_validation_flags", "VK_EXT_layer_settings" }, + { "VK_EXT_shader_subgroup_ballot", "VK_VERSION_1_2" }, + { "VK_EXT_shader_subgroup_vote", "VK_VERSION_1_1" }, +#if defined( VK_USE_PLATFORM_IOS_MVK ) + { "VK_MVK_ios_surface", "VK_EXT_metal_surface" }, +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + { "VK_MVK_macos_surface", "VK_EXT_metal_surface" }, +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + { "VK_AMD_gpu_shader_int16", "VK_KHR_shader_float16_int8" }, + { "VK_NV_ray_tracing", "VK_KHR_ray_tracing_pipeline" }, + { "VK_EXT_buffer_device_address", "VK_KHR_buffer_device_address" }, + { "VK_EXT_validation_features", "VK_EXT_layer_settings" }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VK_NV_displacement_micromap", "VK_NV_cluster_acceleration_structure" } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + }; + return deprecatedExtensions; + } + + VULKAN_HPP_INLINE std::set const & getDeviceExtensions() + { + static const std::set deviceExtensions = { "VK_KHR_swapchain", + "VK_KHR_display_swapchain", + "VK_NV_glsl_shader", + "VK_EXT_depth_range_unrestricted", + "VK_KHR_sampler_mirror_clamp_to_edge", + "VK_IMG_filter_cubic", + "VK_AMD_rasterization_order", + "VK_AMD_shader_trinary_minmax", + "VK_AMD_shader_explicit_vertex_parameter", + "VK_EXT_debug_marker", + "VK_KHR_video_queue", + "VK_KHR_video_decode_queue", + "VK_AMD_gcn_shader", + "VK_NV_dedicated_allocation", + "VK_EXT_transform_feedback", + "VK_NVX_binary_import", + "VK_NVX_image_view_handle", + "VK_AMD_draw_indirect_count", + "VK_AMD_negative_viewport_height", + "VK_AMD_gpu_shader_half_float", + "VK_AMD_shader_ballot", + "VK_KHR_video_encode_h264", + "VK_KHR_video_encode_h265", + "VK_KHR_video_decode_h264", + "VK_AMD_texture_gather_bias_lod", + "VK_AMD_shader_info", + "VK_KHR_dynamic_rendering", + "VK_AMD_shader_image_load_store_lod", + "VK_NV_corner_sampled_image", + "VK_KHR_multiview", + "VK_IMG_format_pvrtc", + "VK_NV_external_memory", +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + "VK_NV_external_memory_win32", + "VK_NV_win32_keyed_mutex", +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + "VK_KHR_device_group", + "VK_KHR_shader_draw_parameters", + "VK_EXT_shader_subgroup_ballot", + "VK_EXT_shader_subgroup_vote", + "VK_EXT_texture_compression_astc_hdr", + "VK_EXT_astc_decode_mode", + "VK_EXT_pipeline_robustness", + "VK_KHR_maintenance1", + "VK_KHR_external_memory", +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + "VK_KHR_external_memory_win32", +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + "VK_KHR_external_memory_fd", +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + "VK_KHR_win32_keyed_mutex", +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + "VK_KHR_external_semaphore", +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + "VK_KHR_external_semaphore_win32", +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + "VK_KHR_external_semaphore_fd", + "VK_KHR_push_descriptor", + "VK_EXT_conditional_rendering", + "VK_KHR_shader_float16_int8", + "VK_KHR_16bit_storage", + "VK_KHR_incremental_present", + "VK_KHR_descriptor_update_template", + "VK_NV_clip_space_w_scaling", + "VK_EXT_display_control", + "VK_GOOGLE_display_timing", + "VK_NV_sample_mask_override_coverage", + "VK_NV_geometry_shader_passthrough", + "VK_NV_viewport_array2", + "VK_NVX_multiview_per_view_attributes", + "VK_NV_viewport_swizzle", + "VK_EXT_discard_rectangles", + "VK_EXT_conservative_rasterization", + "VK_EXT_depth_clip_enable", + "VK_EXT_hdr_metadata", + "VK_KHR_imageless_framebuffer", + "VK_KHR_create_renderpass2", + "VK_IMG_relaxed_line_rasterization", + "VK_KHR_shared_presentable_image", + "VK_KHR_external_fence", +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + "VK_KHR_external_fence_win32", +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + "VK_KHR_external_fence_fd", + "VK_KHR_performance_query", + "VK_KHR_maintenance2", + "VK_KHR_variable_pointers", + "VK_EXT_external_memory_dma_buf", + "VK_EXT_queue_family_foreign", + "VK_KHR_dedicated_allocation", +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + "VK_ANDROID_external_memory_android_hardware_buffer", +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + "VK_EXT_sampler_filter_minmax", + "VK_KHR_storage_buffer_storage_class", + "VK_AMD_gpu_shader_int16", +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + "VK_AMDX_shader_enqueue", +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + "VK_EXT_descriptor_heap", + "VK_AMD_mixed_attachment_samples", + "VK_AMD_shader_fragment_mask", + "VK_EXT_inline_uniform_block", + "VK_EXT_shader_stencil_export", + "VK_KHR_shader_bfloat16", + "VK_EXT_sample_locations", + "VK_KHR_relaxed_block_layout", + "VK_KHR_get_memory_requirements2", + "VK_KHR_image_format_list", + "VK_EXT_blend_operation_advanced", + "VK_NV_fragment_coverage_to_color", + "VK_KHR_acceleration_structure", + "VK_KHR_ray_tracing_pipeline", + "VK_KHR_ray_query", + "VK_NV_framebuffer_mixed_samples", + "VK_NV_fill_rectangle", + "VK_NV_shader_sm_builtins", + "VK_EXT_post_depth_coverage", + "VK_KHR_sampler_ycbcr_conversion", + "VK_KHR_bind_memory2", + "VK_EXT_image_drm_format_modifier", + "VK_EXT_validation_cache", + "VK_EXT_descriptor_indexing", + "VK_EXT_shader_viewport_index_layer", +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + "VK_KHR_portability_subset", +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + "VK_NV_shading_rate_image", + "VK_NV_ray_tracing", + "VK_NV_representative_fragment_test", + "VK_KHR_maintenance3", + "VK_KHR_draw_indirect_count", + "VK_EXT_filter_cubic", + "VK_QCOM_render_pass_shader_resolve", + "VK_EXT_global_priority", + "VK_KHR_shader_subgroup_extended_types", + "VK_KHR_8bit_storage", + "VK_EXT_external_memory_host", + "VK_AMD_buffer_marker", + "VK_KHR_shader_atomic_int64", + "VK_KHR_shader_clock", + "VK_AMD_pipeline_compiler_control", + "VK_EXT_calibrated_timestamps", + "VK_AMD_shader_core_properties", + "VK_KHR_video_decode_h265", + "VK_KHR_global_priority", + "VK_AMD_memory_overallocation_behavior", + "VK_EXT_vertex_attribute_divisor", +#if defined( VK_USE_PLATFORM_GGP ) + "VK_GGP_frame_token", +#endif /*VK_USE_PLATFORM_GGP*/ + "VK_EXT_pipeline_creation_feedback", + "VK_KHR_driver_properties", + "VK_KHR_shader_float_controls", + "VK_NV_shader_subgroup_partitioned", + "VK_KHR_depth_stencil_resolve", + "VK_KHR_swapchain_mutable_format", + "VK_NV_compute_shader_derivatives", + "VK_NV_mesh_shader", + "VK_NV_fragment_shader_barycentric", + "VK_NV_shader_image_footprint", + "VK_NV_scissor_exclusive", + "VK_NV_device_diagnostic_checkpoints", + "VK_KHR_timeline_semaphore", + "VK_EXT_present_timing", + "VK_INTEL_shader_integer_functions2", + "VK_INTEL_performance_query", + "VK_KHR_vulkan_memory_model", + "VK_EXT_pci_bus_info", + "VK_AMD_display_native_hdr", + "VK_KHR_shader_terminate_invocation", + "VK_EXT_fragment_density_map", + "VK_EXT_scalar_block_layout", + "VK_GOOGLE_hlsl_functionality1", + "VK_GOOGLE_decorate_string", + "VK_EXT_subgroup_size_control", + "VK_KHR_fragment_shading_rate", + "VK_AMD_shader_core_properties2", + "VK_AMD_device_coherent_memory", + "VK_KHR_dynamic_rendering_local_read", + "VK_EXT_shader_image_atomic_int64", + "VK_KHR_shader_quad_control", + "VK_KHR_spirv_1_4", + "VK_EXT_memory_budget", + "VK_EXT_memory_priority", + "VK_NV_dedicated_allocation_image_aliasing", + "VK_KHR_separate_depth_stencil_layouts", + "VK_EXT_buffer_device_address", + "VK_EXT_tooling_info", + "VK_EXT_separate_stencil_usage", + "VK_KHR_present_wait", + "VK_NV_cooperative_matrix", + "VK_NV_coverage_reduction_mode", + "VK_EXT_fragment_shader_interlock", + "VK_EXT_ycbcr_image_arrays", + "VK_KHR_uniform_buffer_standard_layout", + "VK_EXT_provoking_vertex", +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + "VK_EXT_full_screen_exclusive", +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + "VK_KHR_buffer_device_address", + "VK_EXT_line_rasterization", + "VK_EXT_shader_atomic_float", + "VK_EXT_host_query_reset", + "VK_EXT_index_type_uint8", + "VK_EXT_extended_dynamic_state", + "VK_KHR_deferred_host_operations", + "VK_KHR_pipeline_executable_properties", + "VK_EXT_host_image_copy", + "VK_KHR_map_memory2", + "VK_EXT_map_memory_placed", + "VK_EXT_shader_atomic_float2", + "VK_EXT_swapchain_maintenance1", + "VK_EXT_shader_demote_to_helper_invocation", + "VK_NV_device_generated_commands", + "VK_NV_inherited_viewport_scissor", + "VK_KHR_shader_integer_dot_product", + "VK_EXT_texel_buffer_alignment", + "VK_QCOM_render_pass_transform", + "VK_EXT_depth_bias_control", + "VK_EXT_device_memory_report", + "VK_EXT_robustness2", + "VK_EXT_custom_border_color", + "VK_EXT_texture_compression_astc_3d", + "VK_GOOGLE_user_type", + "VK_KHR_pipeline_library", + "VK_NV_present_barrier", + "VK_KHR_shader_non_semantic_info", + "VK_KHR_present_id", + "VK_EXT_private_data", + "VK_EXT_pipeline_creation_cache_control", + "VK_KHR_video_encode_queue", + "VK_NV_device_diagnostics_config", + "VK_QCOM_render_pass_store_ops", +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + "VK_NV_cuda_kernel_launch", +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + "VK_QCOM_tile_shading", + "VK_NV_low_latency", +#if defined( VK_USE_PLATFORM_METAL_EXT ) + "VK_EXT_metal_objects", +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + "VK_KHR_synchronization2", + "VK_EXT_descriptor_buffer", + "VK_EXT_graphics_pipeline_library", + "VK_AMD_shader_early_and_late_fragment_tests", + "VK_KHR_fragment_shader_barycentric", + "VK_KHR_shader_subgroup_uniform_control_flow", + "VK_KHR_zero_initialize_workgroup_memory", + "VK_NV_fragment_shading_rate_enums", + "VK_NV_ray_tracing_motion_blur", + "VK_EXT_mesh_shader", + "VK_EXT_ycbcr_2plane_444_formats", + "VK_EXT_fragment_density_map2", + "VK_QCOM_rotated_copy_commands", + "VK_EXT_image_robustness", + "VK_KHR_workgroup_memory_explicit_layout", + "VK_KHR_copy_commands2", + "VK_EXT_image_compression_control", + "VK_EXT_attachment_feedback_loop_layout", + "VK_EXT_4444_formats", + "VK_EXT_device_fault", + "VK_ARM_rasterization_order_attachment_access", + "VK_EXT_rgba10x6_formats", +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + "VK_NV_acquire_winrt_display", +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + "VK_VALVE_mutable_descriptor_type", + "VK_EXT_vertex_input_dynamic_state", + "VK_EXT_physical_device_drm", + "VK_EXT_device_address_binding_report", + "VK_EXT_depth_clip_control", + "VK_EXT_primitive_topology_list_restart", + "VK_KHR_format_feature_flags2", + "VK_EXT_present_mode_fifo_latest_ready", +#if defined( VK_USE_PLATFORM_FUCHSIA ) + "VK_FUCHSIA_external_memory", + "VK_FUCHSIA_external_semaphore", + "VK_FUCHSIA_buffer_collection", +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + "VK_HUAWEI_subpass_shading", + "VK_HUAWEI_invocation_mask", + "VK_NV_external_memory_rdma", + "VK_EXT_pipeline_properties", + "VK_EXT_frame_boundary", + "VK_EXT_multisampled_render_to_single_sampled", + "VK_EXT_extended_dynamic_state2", + "VK_EXT_color_write_enable", + "VK_EXT_primitives_generated_query", + "VK_KHR_ray_tracing_maintenance1", + "VK_KHR_shader_untyped_pointers", + "VK_EXT_global_priority_query", + "VK_VALVE_video_encode_rgb_conversion", + "VK_EXT_image_view_min_lod", + "VK_EXT_multi_draw", + "VK_EXT_image_2d_view_of_3d", + "VK_EXT_shader_tile_image", + "VK_EXT_opacity_micromap", +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + "VK_NV_displacement_micromap", +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + "VK_EXT_load_store_op_none", + "VK_HUAWEI_cluster_culling_shader", + "VK_EXT_border_color_swizzle", + "VK_EXT_pageable_device_local_memory", + "VK_KHR_maintenance4", + "VK_ARM_shader_core_properties", + "VK_KHR_shader_subgroup_rotate", + "VK_ARM_scheduling_controls", + "VK_EXT_image_sliced_view_of_3d", + "VK_VALVE_descriptor_set_host_mapping", + "VK_EXT_depth_clamp_zero_one", + "VK_EXT_non_seamless_cube_map", + "VK_ARM_render_pass_striped", + "VK_QCOM_fragment_density_map_offset", + "VK_NV_copy_memory_indirect", + "VK_NV_memory_decompression", + "VK_NV_device_generated_commands_compute", + "VK_NV_ray_tracing_linear_swept_spheres", + "VK_NV_linear_color_attachment", + "VK_KHR_shader_maximal_reconvergence", + "VK_EXT_image_compression_control_swapchain", + "VK_QCOM_image_processing", + "VK_EXT_nested_command_buffer", +#if defined( VK_USE_PLATFORM_OHOS ) + "VK_OHOS_external_memory", +#endif /*VK_USE_PLATFORM_OHOS*/ + "VK_EXT_external_memory_acquire_unmodified", + "VK_EXT_extended_dynamic_state3", + "VK_EXT_subpass_merge_feedback", + "VK_ARM_tensors", + "VK_EXT_shader_module_identifier", + "VK_EXT_rasterization_order_attachment_access", + "VK_NV_optical_flow", + "VK_EXT_legacy_dithering", + "VK_EXT_pipeline_protected_access", +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + "VK_ANDROID_external_format_resolve", +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + "VK_KHR_maintenance5", + "VK_AMD_anti_lag", +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + "VK_AMDX_dense_geometry_format", +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + "VK_KHR_present_id2", + "VK_KHR_present_wait2", + "VK_KHR_ray_tracing_position_fetch", + "VK_EXT_shader_object", + "VK_KHR_pipeline_binary", + "VK_QCOM_tile_properties", + "VK_SEC_amigo_profiling", + "VK_KHR_swapchain_maintenance1", + "VK_QCOM_multiview_per_view_viewports", + "VK_NV_ray_tracing_invocation_reorder", + "VK_NV_cooperative_vector", + "VK_NV_extended_sparse_address_space", + "VK_EXT_mutable_descriptor_type", + "VK_EXT_legacy_vertex_attributes", + "VK_ARM_shader_core_builtins", + "VK_EXT_pipeline_library_group_handles", + "VK_EXT_dynamic_rendering_unused_attachments", + "VK_KHR_internally_synchronized_queues", + "VK_NV_low_latency2", + "VK_KHR_cooperative_matrix", + "VK_ARM_data_graph", + "VK_QCOM_multiview_per_view_render_areas", + "VK_KHR_compute_shader_derivatives", + "VK_KHR_video_decode_av1", + "VK_KHR_video_encode_av1", + "VK_KHR_video_decode_vp9", + "VK_KHR_video_maintenance1", + "VK_NV_per_stage_descriptor_set", + "VK_QCOM_image_processing2", + "VK_QCOM_filter_cubic_weights", + "VK_QCOM_ycbcr_degamma", + "VK_QCOM_filter_cubic_clamp", + "VK_EXT_attachment_feedback_loop_dynamic_state", + "VK_KHR_vertex_attribute_divisor", + "VK_KHR_load_store_op_none", + "VK_KHR_unified_image_layouts", + "VK_KHR_shader_float_controls2", +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + "VK_QNX_external_memory_screen_buffer", +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + "VK_MSFT_layered_driver", + "VK_KHR_index_type_uint8", + "VK_KHR_line_rasterization", + "VK_KHR_calibrated_timestamps", + "VK_KHR_shader_expect_assume", + "VK_KHR_maintenance6", + "VK_NV_descriptor_pool_overallocation", + "VK_QCOM_tile_memory_heap", + "VK_KHR_copy_memory_indirect", + "VK_EXT_memory_decompression", + "VK_KHR_video_encode_intra_refresh", + "VK_KHR_video_encode_quantization_map", + "VK_NV_raw_access_chains", + "VK_NV_external_compute_queue", + "VK_KHR_shader_relaxed_extended_instruction", + "VK_NV_command_buffer_inheritance", + "VK_KHR_maintenance7", + "VK_NV_shader_atomic_float16_vector", + "VK_EXT_shader_replicated_composites", + "VK_EXT_shader_float8", + "VK_NV_ray_tracing_validation", + "VK_NV_cluster_acceleration_structure", + "VK_NV_partitioned_acceleration_structure", + "VK_EXT_device_generated_commands", + "VK_KHR_maintenance8", + "VK_MESA_image_alignment_control", + "VK_KHR_shader_fma", + "VK_NV_push_constant_bank", + "VK_EXT_ray_tracing_invocation_reorder", + "VK_EXT_depth_clamp_control", + "VK_KHR_maintenance9", + "VK_KHR_video_maintenance2", + "VK_HUAWEI_hdr_vivid", + "VK_NV_cooperative_matrix2", + "VK_ARM_pipeline_opacity_micromap", +#if defined( VK_USE_PLATFORM_METAL_EXT ) + "VK_EXT_external_memory_metal", +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + "VK_KHR_depth_clamp_zero_one", + "VK_ARM_performance_counters_by_region", + "VK_EXT_vertex_attribute_robustness", + "VK_ARM_format_pack", + "VK_VALVE_fragment_density_map_layered", + "VK_KHR_robustness2", +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + "VK_NV_present_metering", +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + "VK_EXT_fragment_density_map_offset", + "VK_EXT_zero_initialize_device_memory", + "VK_KHR_present_mode_fifo_latest_ready", + "VK_EXT_shader_64bit_indexing", + "VK_EXT_custom_resolve", + "VK_QCOM_data_graph_model", + "VK_KHR_maintenance10", + "VK_EXT_shader_long_vector", + "VK_SEC_pipeline_cache_incremental_mode", + "VK_EXT_shader_uniform_buffer_unsized_array", + "VK_NV_compute_occupancy_priority", + "VK_EXT_shader_subgroup_partitioned" }; + return deviceExtensions; + } + + VULKAN_HPP_INLINE std::set const & getInstanceExtensions() + { + static const std::set instanceExtensions = { "VK_KHR_surface", + "VK_KHR_display", +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + "VK_KHR_xlib_surface", +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ +#if defined( VK_USE_PLATFORM_XCB_KHR ) + "VK_KHR_xcb_surface", +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + "VK_KHR_wayland_surface", +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + "VK_KHR_android_surface", +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + "VK_KHR_win32_surface", +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + "VK_EXT_debug_report", +#if defined( VK_USE_PLATFORM_GGP ) + "VK_GGP_stream_descriptor_surface", +#endif /*VK_USE_PLATFORM_GGP*/ + "VK_NV_external_memory_capabilities", + "VK_KHR_get_physical_device_properties2", + "VK_EXT_validation_flags", +#if defined( VK_USE_PLATFORM_VI_NN ) + "VK_NN_vi_surface", +#endif /*VK_USE_PLATFORM_VI_NN*/ + "VK_KHR_device_group_creation", + "VK_KHR_external_memory_capabilities", + "VK_KHR_external_semaphore_capabilities", + "VK_EXT_direct_mode_display", +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + "VK_EXT_acquire_xlib_display", +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + "VK_EXT_display_surface_counter", + "VK_EXT_swapchain_colorspace", + "VK_KHR_external_fence_capabilities", + "VK_KHR_get_surface_capabilities2", + "VK_KHR_get_display_properties2", +#if defined( VK_USE_PLATFORM_IOS_MVK ) + "VK_MVK_ios_surface", +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + "VK_MVK_macos_surface", +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + "VK_EXT_debug_utils", +#if defined( VK_USE_PLATFORM_FUCHSIA ) + "VK_FUCHSIA_imagepipe_surface", +#endif /*VK_USE_PLATFORM_FUCHSIA*/ +#if defined( VK_USE_PLATFORM_METAL_EXT ) + "VK_EXT_metal_surface", +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + "VK_KHR_surface_protected_capabilities", + "VK_EXT_validation_features", + "VK_EXT_headless_surface", + "VK_EXT_surface_maintenance1", + "VK_EXT_acquire_drm_display", +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + "VK_EXT_directfb_surface", +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + "VK_QNX_screen_surface", +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + "VK_KHR_portability_enumeration", + "VK_GOOGLE_surfaceless_query", + "VK_LUNARG_direct_driver_loading", + "VK_KHR_surface_maintenance1", + "VK_EXT_layer_settings", + "VK_NV_display_stereo", +#if defined( VK_USE_PLATFORM_OHOS ) + "VK_OHOS_surface" +#endif /*VK_USE_PLATFORM_OHOS*/ + }; + return instanceExtensions; + } + + VULKAN_HPP_INLINE std::map>> const & getExtensionDepends( std::string const & extension ) + { + static const std::map>> noDependencies; + static const std::map>>> dependencies = { + { "VK_KHR_swapchain", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_KHR_display", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_KHR_display_swapchain", + { { "VK_VERSION_1_0", + { { + "VK_KHR_display", + "VK_KHR_swapchain", + } } } } } +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + , + { "VK_KHR_xlib_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ +#if defined( VK_USE_PLATFORM_XCB_KHR ) + , + { "VK_KHR_xcb_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + , + { "VK_KHR_wayland_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + , + { "VK_KHR_android_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + , + { "VK_KHR_win32_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + , + { "VK_EXT_debug_marker", + { { "VK_VERSION_1_0", + { { + "VK_EXT_debug_report", + } } } } }, + { "VK_KHR_video_queue", + { { "VK_VERSION_1_1", + { { + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_KHR_video_decode_queue", + { { "VK_VERSION_1_0", + { { + "VK_KHR_synchronization2", + "VK_KHR_video_queue", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_video_queue", + } } } } }, + { "VK_EXT_transform_feedback", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_video_encode_h264", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_encode_queue", + } } } } }, + { "VK_KHR_video_encode_h265", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_encode_queue", + } } } } }, + { "VK_KHR_video_decode_h264", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_decode_queue", + } } } } }, + { "VK_AMD_texture_gather_bias_lod", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_dynamic_rendering", + { { "VK_VERSION_1_0", + { { + "VK_KHR_depth_stencil_resolve", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_depth_stencil_resolve", + } } }, + { "VK_VERSION_1_2", { {} } } } } +#if defined( VK_USE_PLATFORM_GGP ) + , + { "VK_GGP_stream_descriptor_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_GGP*/ + , + { "VK_NV_corner_sampled_image", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_multiview", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_external_memory", + { { "VK_VERSION_1_0", + { { + "VK_NV_external_memory_capabilities", + } } } } } +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + , + { "VK_NV_external_memory_win32", + { { "VK_VERSION_1_0", + { { + "VK_NV_external_memory", + } } } } }, + { "VK_NV_win32_keyed_mutex", + { { "VK_VERSION_1_0", + { { + "VK_NV_external_memory_win32", + } } } } } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + , + { "VK_KHR_device_group", + { { "VK_VERSION_1_0", + { { + "VK_KHR_device_group_creation", + } } } } } +#if defined( VK_USE_PLATFORM_VI_NN ) + , + { "VK_NN_vi_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_VI_NN*/ + , + { "VK_EXT_texture_compression_astc_hdr", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_astc_decode_mode", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pipeline_robustness", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_external_memory_capabilities", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_external_memory", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory_capabilities", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + , + { "VK_KHR_external_memory_win32", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + , + { "VK_KHR_external_memory_fd", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + , + { "VK_KHR_win32_keyed_mutex", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory_win32", + } } } } } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + , + { "VK_KHR_external_semaphore_capabilities", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_external_semaphore", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_semaphore_capabilities", + } } } } } +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + , + { "VK_KHR_external_semaphore_win32", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_semaphore", + } } } } } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + , + { "VK_KHR_external_semaphore_fd", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_semaphore", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_push_descriptor", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_conditional_rendering", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_float16_int8", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_16bit_storage", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_storage_buffer_storage_class", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_incremental_present", + { { "VK_VERSION_1_0", + { { + "VK_KHR_swapchain", + } } } } }, + { "VK_EXT_direct_mode_display", + { { "VK_VERSION_1_0", + { { + "VK_KHR_display", + } } } } } +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + , + { "VK_EXT_acquire_xlib_display", + { { "VK_VERSION_1_0", + { { + "VK_EXT_direct_mode_display", + } } } } } +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + , + { "VK_EXT_display_surface_counter", + { { "VK_VERSION_1_0", + { { + "VK_KHR_display", + } } } } }, + { "VK_EXT_display_control", + { { "VK_VERSION_1_0", + { { + "VK_EXT_display_surface_counter", + "VK_KHR_swapchain", + } } } } }, + { "VK_GOOGLE_display_timing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_swapchain", + } } } } }, + { "VK_NVX_multiview_per_view_attributes", + { { "VK_VERSION_1_0", + { { + "VK_KHR_multiview", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_discard_rectangles", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_conservative_rasterization", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_depth_clip_enable", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_swapchain_colorspace", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_EXT_hdr_metadata", + { { "VK_VERSION_1_0", + { { + "VK_KHR_swapchain", + } } } } }, + { "VK_KHR_imageless_framebuffer", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_image_format_list", + "VK_KHR_maintenance2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_image_format_list", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_KHR_create_renderpass2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_maintenance2", + "VK_KHR_multiview", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_IMG_relaxed_line_rasterization", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shared_presentable_image", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_get_surface_capabilities2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_swapchain", + } } } } }, + { "VK_KHR_external_fence_capabilities", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_external_fence", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_fence_capabilities", + } } } } } +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + , + { "VK_KHR_external_fence_win32", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_fence", + } } } } } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + , + { "VK_KHR_external_fence_fd", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_fence", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_performance_query", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_get_surface_capabilities2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_KHR_variable_pointers", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_storage_buffer_storage_class", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_get_display_properties2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_display", + } } } } } +#if defined( VK_USE_PLATFORM_IOS_MVK ) + , + { "VK_MVK_ios_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + , + { "VK_MVK_macos_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + , + { "VK_EXT_external_memory_dma_buf", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory_fd", + } } } } }, + { "VK_EXT_queue_family_foreign", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_dedicated_allocation", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_memory_requirements2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + , + { "VK_ANDROID_external_memory_android_hardware_buffer", + { { "VK_VERSION_1_0", + { { + "VK_EXT_queue_family_foreign", + "VK_KHR_dedicated_allocation", + "VK_KHR_external_memory", + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_queue_family_foreign", + } } } } } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + , + { "VK_EXT_sampler_filter_minmax", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + , + { "VK_AMDX_shader_enqueue", + { { "VK_VERSION_1_0", + { { + "VK_EXT_extended_dynamic_state", + "VK_KHR_maintenance5", + "VK_KHR_pipeline_library", + "VK_KHR_spirv_1_4", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_maintenance5", + "VK_KHR_pipeline_library", + } } } } } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + , + { "VK_EXT_descriptor_heap", + { { "VK_VERSION_1_0", + { { + "VK_KHR_buffer_device_address", + "VK_KHR_maintenance5", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_maintenance5", + } } } } }, + { "VK_EXT_inline_uniform_block", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_maintenance1", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_bfloat16", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_sample_locations", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_blend_operation_advanced", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_acceleration_structure", + { { "VK_VERSION_1_1", + { { + "VK_EXT_descriptor_indexing", + "VK_KHR_buffer_device_address", + "VK_KHR_deferred_host_operations", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_deferred_host_operations", + } } } } }, + { "VK_KHR_ray_tracing_pipeline", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + "VK_KHR_spirv_1_4", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_KHR_ray_query", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + "VK_KHR_spirv_1_4", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_NV_shader_sm_builtins", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_sampler_ycbcr_conversion", + { { "VK_VERSION_1_0", + { { + "VK_KHR_bind_memory2", + "VK_KHR_get_memory_requirements2", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_maintenance1", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_image_drm_format_modifier", + { { "VK_VERSION_1_0", + { { + "VK_KHR_bind_memory2", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_image_format_list", + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_image_format_list", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_EXT_descriptor_indexing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_maintenance3", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + , + { "VK_KHR_portability_subset", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + , + { "VK_NV_shading_rate_image", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_ray_tracing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_memory_requirements2", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_representative_fragment_test", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_maintenance3", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_subgroup_extended_types", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_8bit_storage", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_storage_buffer_storage_class", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_external_memory_host", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_atomic_int64", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_clock", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_calibrated_timestamps", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_AMD_shader_core_properties", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_video_decode_h265", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_decode_queue", + } } } } }, + { "VK_KHR_global_priority", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_vertex_attribute_divisor", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_USE_PLATFORM_GGP ) + , + { "VK_GGP_frame_token", + { { "VK_VERSION_1_0", + { { + "VK_GGP_stream_descriptor_surface", + "VK_KHR_swapchain", + } } } } } +#endif /*VK_USE_PLATFORM_GGP*/ + , + { "VK_KHR_driver_properties", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_float_controls", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_shader_subgroup_partitioned", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_depth_stencil_resolve", + { { "VK_VERSION_1_0", + { { + "VK_KHR_create_renderpass2", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_KHR_swapchain_mutable_format", + { { "VK_VERSION_1_0", + { { + "VK_KHR_image_format_list", + "VK_KHR_maintenance2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_image_format_list", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_swapchain", + } } } } }, + { "VK_NV_compute_shader_derivatives", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_mesh_shader", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_fragment_shader_barycentric", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_shader_image_footprint", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_scissor_exclusive", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_device_diagnostic_checkpoints", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_timeline_semaphore", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_present_timing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_calibrated_timestamps", + "VK_KHR_get_surface_capabilities2", + "VK_KHR_present_id2", + "VK_KHR_swapchain", + } } } } }, + { "VK_INTEL_shader_integer_functions2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_vulkan_memory_model", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pci_bus_info", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_AMD_display_native_hdr", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_get_surface_capabilities2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_swapchain", + } } } } } +#if defined( VK_USE_PLATFORM_FUCHSIA ) + , + { "VK_FUCHSIA_imagepipe_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + , + { "VK_KHR_shader_terminate_invocation", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_USE_PLATFORM_METAL_EXT ) + , + { "VK_EXT_metal_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + , + { "VK_EXT_fragment_density_map", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_scalar_block_layout", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_subgroup_size_control", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_fragment_shading_rate", + { { "VK_VERSION_1_0", + { { + "VK_KHR_create_renderpass2", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_create_renderpass2", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_AMD_shader_core_properties2", + { { "VK_VERSION_1_0", + { { + "VK_AMD_shader_core_properties", + } } } } }, + { "VK_AMD_device_coherent_memory", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_dynamic_rendering_local_read", + { { "VK_VERSION_1_0", + { { + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_shader_image_atomic_int64", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_quad_control", + { { "VK_VERSION_1_1", + { { + "VK_KHR_shader_maximal_reconvergence", + "VK_KHR_vulkan_memory_model", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_shader_maximal_reconvergence", + } } } } }, + { "VK_KHR_spirv_1_4", + { { "VK_VERSION_1_1", + { { + "VK_KHR_shader_float_controls", + } } } } }, + { "VK_EXT_memory_budget", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_memory_priority", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_surface_protected_capabilities", + { { "VK_VERSION_1_1", + { { + "VK_KHR_get_surface_capabilities2", + } } } } }, + { "VK_NV_dedicated_allocation_image_aliasing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_dedicated_allocation", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_separate_depth_stencil_layouts", + { { "VK_VERSION_1_0", + { { + "VK_KHR_create_renderpass2", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_create_renderpass2", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_EXT_buffer_device_address", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_present_wait", + { { "VK_VERSION_1_0", + { { + "VK_KHR_present_id", + "VK_KHR_swapchain", + } } } } }, + { "VK_NV_cooperative_matrix", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_coverage_reduction_mode", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_NV_framebuffer_mixed_samples", + } } }, + { "VK_VERSION_1_1", + { { + "VK_NV_framebuffer_mixed_samples", + } } } } }, + { "VK_EXT_fragment_shader_interlock", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_ycbcr_image_arrays", + { { "VK_VERSION_1_0", + { { + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_uniform_buffer_standard_layout", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_provoking_vertex", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + , + { "VK_EXT_full_screen_exclusive", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + "VK_KHR_swapchain", + } } } } } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + , + { "VK_EXT_headless_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_KHR_buffer_device_address", + { { "VK_VERSION_1_0", + { { + "VK_KHR_device_group", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_line_rasterization", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_shader_atomic_float", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_host_query_reset", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_index_type_uint8", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_extended_dynamic_state", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_pipeline_executable_properties", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_host_image_copy", + { { "VK_VERSION_1_0", + { { + "VK_KHR_copy_commands2", + "VK_KHR_format_feature_flags2", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_copy_commands2", + "VK_KHR_format_feature_flags2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_map_memory_placed", + { { "VK_VERSION_1_0", + { { + "VK_KHR_map_memory2", + } } }, + { "VK_VERSION_1_4", { {} } } } }, + { "VK_EXT_shader_atomic_float2", + { { "VK_VERSION_1_0", + { { + "VK_EXT_shader_atomic_float", + } } } } }, + { "VK_EXT_surface_maintenance1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + } } } } }, + { "VK_EXT_swapchain_maintenance1", + { { "VK_VERSION_1_0", + { { + "VK_EXT_surface_maintenance1", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_surface_maintenance1", + "VK_KHR_swapchain", + } } } } }, + { "VK_EXT_shader_demote_to_helper_invocation", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_device_generated_commands", + { { "VK_VERSION_1_1", + { { + "VK_KHR_buffer_device_address", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_NV_inherited_viewport_scissor", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_integer_dot_product", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_texel_buffer_alignment", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_depth_bias_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_device_memory_report", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_acquire_drm_display", + { { "VK_VERSION_1_0", + { { + "VK_EXT_direct_mode_display", + } } } } }, + { "VK_EXT_robustness2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_custom_border_color", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_texture_compression_astc_3d", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_present_barrier", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + "VK_KHR_swapchain", + } } } } }, + { "VK_KHR_present_id", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_swapchain", + } } } } }, + { "VK_EXT_private_data", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pipeline_creation_cache_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_video_encode_queue", + { { "VK_VERSION_1_0", + { { + "VK_KHR_synchronization2", + "VK_KHR_video_queue", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_video_queue", + } } } } }, + { "VK_NV_device_diagnostics_config", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + , + { "VK_NV_cuda_kernel_launch", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + , + { "VK_QCOM_tile_shading", + { { "VK_VERSION_1_0", + { { + "VK_QCOM_tile_properties", + } } } } }, + { "VK_KHR_synchronization2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_descriptor_buffer", + { { "VK_VERSION_1_0", + { { + "VK_EXT_descriptor_indexing", + "VK_KHR_buffer_device_address", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_descriptor_indexing", + "VK_KHR_buffer_device_address", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_graphics_pipeline_library", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_pipeline_library", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_pipeline_library", + } } } } }, + { "VK_AMD_shader_early_and_late_fragment_tests", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_fragment_shader_barycentric", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_subgroup_uniform_control_flow", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_zero_initialize_workgroup_memory", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_fragment_shading_rate_enums", + { { "VK_VERSION_1_0", + { { + "VK_KHR_fragment_shading_rate", + } } } } }, + { "VK_NV_ray_tracing_motion_blur", + { { "VK_VERSION_1_0", + { { + "VK_KHR_ray_tracing_pipeline", + } } } } }, + { "VK_EXT_mesh_shader", + { { "VK_VERSION_1_0", + { { + "VK_KHR_spirv_1_4", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_EXT_ycbcr_2plane_444_formats", + { { "VK_VERSION_1_0", + { { + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_fragment_density_map2", + { { "VK_VERSION_1_0", + { { + "VK_EXT_fragment_density_map", + } } } } }, + { "VK_QCOM_rotated_copy_commands", + { { "VK_VERSION_1_0", + { { + "VK_KHR_copy_commands2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_image_robustness", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_workgroup_memory_explicit_layout", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_copy_commands2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_image_compression_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_attachment_feedback_loop_layout", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_4444_formats", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_device_fault", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_rasterization_order_attachment_access", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_rgba10x6_formats", + { { "VK_VERSION_1_0", + { { + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + , + { "VK_NV_acquire_winrt_display", + { { "VK_VERSION_1_0", + { { + "VK_EXT_direct_mode_display", + } } } } } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + , + { "VK_EXT_directfb_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + , + { "VK_VALVE_mutable_descriptor_type", + { { "VK_VERSION_1_0", + { { + "VK_KHR_maintenance3", + } } } } }, + { "VK_EXT_vertex_input_dynamic_state", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_physical_device_drm", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_device_address_binding_report", + { { "VK_VERSION_1_0", + { { + "VK_EXT_debug_utils", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_debug_utils", + } } } } }, + { "VK_EXT_depth_clip_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_primitive_topology_list_restart", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_format_feature_flags2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_present_mode_fifo_latest_ready", + { { "VK_VERSION_1_0", + { { + "VK_KHR_swapchain", + } } } } } +#if defined( VK_USE_PLATFORM_FUCHSIA ) + , + { "VK_FUCHSIA_external_memory", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + "VK_KHR_external_memory_capabilities", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_FUCHSIA_external_semaphore", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_semaphore", + "VK_KHR_external_semaphore_capabilities", + } } } } }, + { "VK_FUCHSIA_buffer_collection", + { { "VK_VERSION_1_0", + { { + "VK_FUCHSIA_external_memory", + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", + { { + "VK_FUCHSIA_external_memory", + } } } } } +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + , + { "VK_HUAWEI_subpass_shading", + { { "VK_VERSION_1_0", + { { + "VK_KHR_create_renderpass2", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_HUAWEI_invocation_mask", + { { "VK_VERSION_1_0", + { { + "VK_KHR_ray_tracing_pipeline", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_ray_tracing_pipeline", + } } } } }, + { "VK_NV_external_memory_rdma", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pipeline_properties", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_frame_boundary", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_multisampled_render_to_single_sampled", + { { "VK_VERSION_1_0", + { { + "VK_KHR_create_renderpass2", + "VK_KHR_depth_stencil_resolve", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_EXT_extended_dynamic_state2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + , + { "VK_QNX_screen_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + , + { "VK_EXT_color_write_enable", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_primitives_generated_query", + { { "VK_VERSION_1_0", + { { + "VK_EXT_transform_feedback", + } } } } }, + { "VK_KHR_ray_tracing_maintenance1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_KHR_shader_untyped_pointers", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } } } }, + { "VK_EXT_global_priority_query", + { { "VK_VERSION_1_0", + { { + "VK_EXT_global_priority", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_global_priority", + } } } } }, + { "VK_VALVE_video_encode_rgb_conversion", + { { "VK_VERSION_1_0", + { { + "VK_KHR_sampler_ycbcr_conversion", + "VK_KHR_video_encode_queue", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_video_encode_queue", + } } } } }, + { "VK_EXT_image_view_min_lod", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_multi_draw", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_image_2d_view_of_3d", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_maintenance1", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_shader_tile_image", { { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_opacity_micromap", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_acceleration_structure", + } } } } } +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + , + { "VK_NV_displacement_micromap", + { { "VK_VERSION_1_0", + { { + "VK_EXT_opacity_micromap", + } } } } } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + , + { "VK_HUAWEI_cluster_culling_shader", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_border_color_swizzle", + { { "VK_VERSION_1_0", + { { + "VK_EXT_custom_border_color", + } } } } }, + { "VK_EXT_pageable_device_local_memory", + { { "VK_VERSION_1_0", + { { + "VK_EXT_memory_priority", + } } } } }, + { "VK_KHR_maintenance4", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_shader_core_properties", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_subgroup_rotate", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_scheduling_controls", + { { "VK_VERSION_1_0", + { { + "VK_ARM_shader_core_builtins", + } } } } }, + { "VK_EXT_image_sliced_view_of_3d", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_maintenance1", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_VALVE_descriptor_set_host_mapping", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_depth_clamp_zero_one", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_non_seamless_cube_map", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_render_pass_striped", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_QCOM_fragment_density_map_offset", + { { "VK_VERSION_1_0", + { { + "VK_EXT_fragment_density_map", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_fragment_density_map", + } } } } }, + { "VK_NV_copy_memory_indirect", + { { "VK_VERSION_1_0", + { { + "VK_KHR_buffer_device_address", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_buffer_device_address", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_NV_memory_decompression", + { { "VK_VERSION_1_0", + { { + "VK_KHR_buffer_device_address", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_buffer_device_address", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_NV_device_generated_commands_compute", + { { "VK_VERSION_1_0", + { { + "VK_NV_device_generated_commands", + } } } } }, + { "VK_NV_ray_tracing_linear_swept_spheres", + { { "VK_VERSION_1_0", + { { + "VK_KHR_ray_tracing_pipeline", + } } } } }, + { "VK_NV_linear_color_attachment", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_GOOGLE_surfaceless_query", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_KHR_shader_maximal_reconvergence", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_image_compression_control_swapchain", + { { "VK_VERSION_1_0", + { { + "VK_EXT_image_compression_control", + } } } } }, + { "VK_QCOM_image_processing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_format_feature_flags2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_nested_command_buffer", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_USE_PLATFORM_OHOS ) + , + { "VK_OHOS_external_memory", + { { "VK_VERSION_1_0", + { { + "VK_EXT_queue_family_foreign", + "VK_KHR_dedicated_allocation", + "VK_KHR_external_memory", + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_queue_family_foreign", + } } } } } +#endif /*VK_USE_PLATFORM_OHOS*/ + , + { "VK_EXT_external_memory_acquire_unmodified", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_extended_dynamic_state3", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_subpass_merge_feedback", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_tensors", { { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_shader_module_identifier", + { { "VK_VERSION_1_0", + { { + "VK_EXT_pipeline_creation_cache_control", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_pipeline_creation_cache_control", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_rasterization_order_attachment_access", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_optical_flow", + { { "VK_VERSION_1_0", + { { + "VK_KHR_format_feature_flags2", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_format_feature_flags2", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_legacy_dithering", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pipeline_protected_access", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + , + { "VK_ANDROID_external_format_resolve", + { { "VK_VERSION_1_0", + { { + "VK_ANDROID_external_memory_android_hardware_buffer", + } } } } } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + , + { "VK_KHR_maintenance5", + { { "VK_VERSION_1_1", + { { + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_AMD_anti_lag", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + , + { "VK_AMDX_dense_geometry_format", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + "VK_KHR_maintenance5", + } } }, + { "VK_VERSION_1_4", + { { + "VK_KHR_acceleration_structure", + } } } } } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + , + { "VK_KHR_present_id2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + "VK_KHR_swapchain", + } } } } }, + { "VK_KHR_present_wait2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_present_id2", + "VK_KHR_surface", + "VK_KHR_swapchain", + } } } } }, + { "VK_KHR_ray_tracing_position_fetch", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_EXT_shader_object", + { { "VK_VERSION_1_0", + { { + "VK_KHR_dynamic_rendering", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_KHR_pipeline_binary", + { { "VK_VERSION_1_0", + { { + "VK_KHR_maintenance5", + } } }, + { "VK_VERSION_1_4", { {} } } } }, + { "VK_QCOM_tile_properties", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_SEC_amigo_profiling", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_surface_maintenance1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + } } } } }, + { "VK_KHR_swapchain_maintenance1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_surface_maintenance1", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_surface_maintenance1", + "VK_KHR_swapchain", + } } } } }, + { "VK_QCOM_multiview_per_view_viewports", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_ray_tracing_invocation_reorder", + { { "VK_VERSION_1_0", + { { + "VK_KHR_ray_tracing_pipeline", + } } } } }, + { "VK_NV_cooperative_vector", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_extended_sparse_address_space", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_mutable_descriptor_type", + { { "VK_VERSION_1_0", + { { + "VK_KHR_maintenance3", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_legacy_vertex_attributes", + { { "VK_VERSION_1_0", + { { + "VK_EXT_vertex_input_dynamic_state", + } } } } }, + { "VK_ARM_shader_core_builtins", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pipeline_library_group_handles", + { { "VK_VERSION_1_0", + { { + "VK_KHR_pipeline_library", + "VK_KHR_ray_tracing_pipeline", + } } } } }, + { "VK_EXT_dynamic_rendering_unused_attachments", + { { "VK_VERSION_1_0", + { { + "VK_KHR_dynamic_rendering", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_KHR_internally_synchronized_queues", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_low_latency2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_present_id", + "VK_KHR_timeline_semaphore", + }, + { + "VK_KHR_present_id2", + "VK_KHR_timeline_semaphore", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_present_id", + }, + { + "VK_KHR_present_id2", + } } } } }, + { "VK_KHR_cooperative_matrix", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_data_graph", + { { "VK_VERSION_1_3", + { { + "VK_KHR_deferred_host_operations", + "VK_KHR_maintenance5", + } } } } }, + { "VK_QCOM_multiview_per_view_render_areas", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_compute_shader_derivatives", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_video_decode_av1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_decode_queue", + } } } } }, + { "VK_KHR_video_encode_av1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_encode_queue", + } } } } }, + { "VK_KHR_video_decode_vp9", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_decode_queue", + } } } } }, + { "VK_KHR_video_maintenance1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_queue", + } } } } }, + { "VK_NV_per_stage_descriptor_set", + { { "VK_VERSION_1_0", + { { + "VK_KHR_maintenance6", + } } }, + { "VK_VERSION_1_4", { {} } } } }, + { "VK_QCOM_image_processing2", + { { "VK_VERSION_1_0", + { { + "VK_QCOM_image_processing", + } } } } }, + { "VK_QCOM_filter_cubic_weights", + { { "VK_VERSION_1_0", + { { + "VK_EXT_filter_cubic", + } } } } }, + { "VK_QCOM_ycbcr_degamma", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_QCOM_filter_cubic_clamp", + { { "VK_VERSION_1_0", + { { + "VK_EXT_filter_cubic", + "VK_EXT_sampler_filter_minmax", + } } }, + { "VK_VERSION_1_2", + { { + "VK_EXT_filter_cubic", + } } } } }, + { "VK_EXT_attachment_feedback_loop_dynamic_state", + { { "VK_VERSION_1_0", + { { + "VK_EXT_attachment_feedback_loop_layout", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_attachment_feedback_loop_layout", + } } } } }, + { "VK_KHR_vertex_attribute_divisor", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_unified_image_layouts", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_float_controls2", + { { "VK_VERSION_1_1", + { { + "VK_KHR_shader_float_controls", + } } } } } +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + , + { "VK_QNX_external_memory_screen_buffer", + { { "VK_VERSION_1_0", + { { + "VK_EXT_queue_family_foreign", + "VK_KHR_dedicated_allocation", + "VK_KHR_external_memory", + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_queue_family_foreign", + } } } } } +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + , + { "VK_MSFT_layered_driver", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_index_type_uint8", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_line_rasterization", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_calibrated_timestamps", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_expect_assume", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_QCOM_tile_memory_heap", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_memory_requirements2", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_copy_memory_indirect", + { { "VK_VERSION_1_0", + { { + "VK_KHR_buffer_device_address", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_EXT_memory_decompression", + { { "VK_VERSION_1_0", + { { + "VK_KHR_buffer_device_address", + "VK_KHR_get_physical_device_properties2", + } } } } }, + { "VK_NV_display_stereo", + { { "VK_VERSION_1_0", + { { + "VK_KHR_display", + "VK_KHR_get_display_properties2", + } } } } }, + { "VK_KHR_video_encode_intra_refresh", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_encode_queue", + } } } } }, + { "VK_KHR_video_encode_quantization_map", + { { "VK_VERSION_1_0", + { { + "VK_KHR_format_feature_flags2", + "VK_KHR_video_encode_queue", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_video_encode_queue", + } } } } }, + { "VK_NV_raw_access_chains", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_relaxed_extended_instruction", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_command_buffer_inheritance", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_shader_atomic_float16_vector", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_shader_replicated_composites", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_shader_float8", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_ray_tracing_validation", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_cluster_acceleration_structure", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_NV_partitioned_acceleration_structure", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_EXT_device_generated_commands", + { { "VK_VERSION_1_0", + { { + "VK_KHR_buffer_device_address", + "VK_KHR_maintenance5", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_maintenance5", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_MESA_image_alignment_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_fma", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_ray_tracing_invocation_reorder", + { { "VK_VERSION_1_0", + { { + "VK_KHR_ray_tracing_pipeline", + } } } } }, + { "VK_EXT_depth_clamp_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_maintenance9", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_video_maintenance2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_queue", + } } } } } +#if defined( VK_USE_PLATFORM_OHOS ) + , + { "VK_OHOS_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } } +#endif /*VK_USE_PLATFORM_OHOS*/ + , + { "VK_HUAWEI_hdr_vivid", + { { "VK_VERSION_1_0", + { { + "VK_EXT_hdr_metadata", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_hdr_metadata", + "VK_KHR_swapchain", + } } } } }, + { "VK_NV_cooperative_matrix2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_cooperative_matrix", + } } } } }, + { "VK_ARM_pipeline_opacity_micromap", + { { "VK_VERSION_1_0", + { { + "VK_EXT_opacity_micromap", + } } } } } +#if defined( VK_USE_PLATFORM_METAL_EXT ) + , + { "VK_EXT_external_memory_metal", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + , + { "VK_KHR_depth_clamp_zero_one", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_performance_counters_by_region", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_vertex_attribute_robustness", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_format_pack", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_VALVE_fragment_density_map_layered", + { { "VK_VERSION_1_0", + { { + "VK_EXT_fragment_density_map", + "VK_KHR_maintenance5", + } } }, + { "VK_VERSION_1_4", + { { + "VK_EXT_fragment_density_map", + } } } } }, + { "VK_KHR_robustness2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + , + { "VK_NV_present_metering", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + , + { "VK_EXT_fragment_density_map_offset", + { { "VK_VERSION_1_0", + { { + "VK_EXT_fragment_density_map", + "VK_KHR_create_renderpass2", + "VK_KHR_dynamic_rendering", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_fragment_density_map", + "VK_KHR_create_renderpass2", + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_2", + { { + "VK_EXT_fragment_density_map", + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_3", + { { + "VK_EXT_fragment_density_map", + } } } } }, + { "VK_EXT_zero_initialize_device_memory", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_present_mode_fifo_latest_ready", + { { "VK_VERSION_1_0", + { { + "VK_KHR_swapchain", + } } } } }, + { "VK_EXT_shader_64bit_indexing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_custom_resolve", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_QCOM_data_graph_model", + { { "VK_VERSION_1_0", + { { + "VK_ARM_data_graph", + } } } } }, + { "VK_KHR_maintenance10", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_shader_long_vector", { { "VK_VERSION_1_2", { {} } } } }, + { "VK_SEC_pipeline_cache_incremental_mode", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_shader_uniform_buffer_unsized_array", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_compute_occupancy_priority", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_shader_subgroup_partitioned", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } } + }; + auto depIt = dependencies.find( extension ); + return ( depIt != dependencies.end() ) ? depIt->second : noDependencies; + } + + VULKAN_HPP_INLINE std::pair> const &> getExtensionDepends( std::string const & version, + std::string const & extension ) + { +#if !defined( NDEBUG ) + static std::set versions = { "VK_VERSION_1_0", "VK_VERSION_1_1", "VK_VERSION_1_2", "VK_VERSION_1_3", "VK_VERSION_1_4" }; + VULKAN_HPP_ASSERT( versions.find( version ) != versions.end() ); +#endif + static std::vector> noDependencies; + + std::map>> const & dependencies = getExtensionDepends( extension ); + if ( dependencies.empty() ) + { + return { true, noDependencies }; + } + auto depIt = dependencies.lower_bound( version ); + if ( ( depIt == dependencies.end() ) || ( depIt->first != version ) ) + { + depIt = std::prev( depIt ); + } + if ( depIt == dependencies.end() ) + { + return { false, noDependencies }; + } + else + { + return { true, depIt->second }; + } + } + + VULKAN_HPP_INLINE std::map const & getObsoletedExtensions() + { + static const std::map obsoletedExtensions = { { "VK_AMD_negative_viewport_height", "VK_KHR_maintenance1" } }; + return obsoletedExtensions; + } + + VULKAN_HPP_INLINE std::map const & getPromotedExtensions() + { + static const std::map promotedExtensions = { { "VK_KHR_sampler_mirror_clamp_to_edge", "VK_VERSION_1_2" }, + { "VK_EXT_debug_marker", "VK_EXT_debug_utils" }, + { "VK_AMD_draw_indirect_count", "VK_KHR_draw_indirect_count" }, + { "VK_KHR_dynamic_rendering", "VK_VERSION_1_3" }, + { "VK_KHR_multiview", "VK_VERSION_1_1" }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "VK_NV_win32_keyed_mutex", "VK_KHR_win32_keyed_mutex" }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "VK_KHR_get_physical_device_properties2", "VK_VERSION_1_1" }, + { "VK_KHR_device_group", "VK_VERSION_1_1" }, + { "VK_KHR_shader_draw_parameters", "VK_VERSION_1_1" }, + { "VK_EXT_texture_compression_astc_hdr", "VK_VERSION_1_3" }, + { "VK_EXT_pipeline_robustness", "VK_VERSION_1_4" }, + { "VK_KHR_maintenance1", "VK_VERSION_1_1" }, + { "VK_KHR_device_group_creation", "VK_VERSION_1_1" }, + { "VK_KHR_external_memory_capabilities", "VK_VERSION_1_1" }, + { "VK_KHR_external_memory", "VK_VERSION_1_1" }, + { "VK_KHR_external_semaphore_capabilities", "VK_VERSION_1_1" }, + { "VK_KHR_external_semaphore", "VK_VERSION_1_1" }, + { "VK_KHR_push_descriptor", "VK_VERSION_1_4" }, + { "VK_KHR_shader_float16_int8", "VK_VERSION_1_2" }, + { "VK_KHR_16bit_storage", "VK_VERSION_1_1" }, + { "VK_KHR_descriptor_update_template", "VK_VERSION_1_1" }, + { "VK_KHR_imageless_framebuffer", "VK_VERSION_1_2" }, + { "VK_KHR_create_renderpass2", "VK_VERSION_1_2" }, + { "VK_KHR_external_fence_capabilities", "VK_VERSION_1_1" }, + { "VK_KHR_external_fence", "VK_VERSION_1_1" }, + { "VK_KHR_maintenance2", "VK_VERSION_1_1" }, + { "VK_KHR_variable_pointers", "VK_VERSION_1_1" }, + { "VK_KHR_dedicated_allocation", "VK_VERSION_1_1" }, + { "VK_EXT_sampler_filter_minmax", "VK_VERSION_1_2" }, + { "VK_KHR_storage_buffer_storage_class", "VK_VERSION_1_1" }, + { "VK_EXT_inline_uniform_block", "VK_VERSION_1_3" }, + { "VK_KHR_relaxed_block_layout", "VK_VERSION_1_1" }, + { "VK_KHR_get_memory_requirements2", "VK_VERSION_1_1" }, + { "VK_KHR_image_format_list", "VK_VERSION_1_2" }, + { "VK_KHR_sampler_ycbcr_conversion", "VK_VERSION_1_1" }, + { "VK_KHR_bind_memory2", "VK_VERSION_1_1" }, + { "VK_EXT_descriptor_indexing", "VK_VERSION_1_2" }, + { "VK_EXT_shader_viewport_index_layer", "VK_VERSION_1_2" }, + { "VK_KHR_maintenance3", "VK_VERSION_1_1" }, + { "VK_KHR_draw_indirect_count", "VK_VERSION_1_2" }, + { "VK_QCOM_render_pass_shader_resolve", "VK_EXT_custom_resolve" }, + { "VK_EXT_global_priority", "VK_KHR_global_priority" }, + { "VK_KHR_shader_subgroup_extended_types", "VK_VERSION_1_2" }, + { "VK_KHR_8bit_storage", "VK_VERSION_1_2" }, + { "VK_KHR_shader_atomic_int64", "VK_VERSION_1_2" }, + { "VK_EXT_calibrated_timestamps", "VK_KHR_calibrated_timestamps" }, + { "VK_KHR_global_priority", "VK_VERSION_1_4" }, + { "VK_EXT_vertex_attribute_divisor", "VK_KHR_vertex_attribute_divisor" }, + { "VK_EXT_pipeline_creation_feedback", "VK_VERSION_1_3" }, + { "VK_KHR_driver_properties", "VK_VERSION_1_2" }, + { "VK_KHR_shader_float_controls", "VK_VERSION_1_2" }, + { "VK_NV_shader_subgroup_partitioned", "VK_EXT_shader_subgroup_partitioned" }, + { "VK_KHR_depth_stencil_resolve", "VK_VERSION_1_2" }, + { "VK_NV_compute_shader_derivatives", "VK_KHR_compute_shader_derivatives" }, + { "VK_NV_fragment_shader_barycentric", "VK_KHR_fragment_shader_barycentric" }, + { "VK_KHR_timeline_semaphore", "VK_VERSION_1_2" }, + { "VK_KHR_vulkan_memory_model", "VK_VERSION_1_2" }, + { "VK_KHR_shader_terminate_invocation", "VK_VERSION_1_3" }, + { "VK_EXT_scalar_block_layout", "VK_VERSION_1_2" }, + { "VK_EXT_subgroup_size_control", "VK_VERSION_1_3" }, + { "VK_KHR_dynamic_rendering_local_read", "VK_VERSION_1_4" }, + { "VK_KHR_spirv_1_4", "VK_VERSION_1_2" }, + { "VK_KHR_separate_depth_stencil_layouts", "VK_VERSION_1_2" }, + { "VK_EXT_tooling_info", "VK_VERSION_1_3" }, + { "VK_EXT_separate_stencil_usage", "VK_VERSION_1_2" }, + { "VK_KHR_uniform_buffer_standard_layout", "VK_VERSION_1_2" }, + { "VK_KHR_buffer_device_address", "VK_VERSION_1_2" }, + { "VK_EXT_line_rasterization", "VK_KHR_line_rasterization" }, + { "VK_EXT_host_query_reset", "VK_VERSION_1_2" }, + { "VK_EXT_index_type_uint8", "VK_KHR_index_type_uint8" }, + { "VK_EXT_extended_dynamic_state", "VK_VERSION_1_3" }, + { "VK_EXT_host_image_copy", "VK_VERSION_1_4" }, + { "VK_KHR_map_memory2", "VK_VERSION_1_4" }, + { "VK_EXT_surface_maintenance1", "VK_KHR_surface_maintenance1" }, + { "VK_EXT_swapchain_maintenance1", "VK_KHR_swapchain_maintenance1" }, + { "VK_EXT_shader_demote_to_helper_invocation", "VK_VERSION_1_3" }, + { "VK_KHR_shader_integer_dot_product", "VK_VERSION_1_3" }, + { "VK_EXT_texel_buffer_alignment", "VK_VERSION_1_3" }, + { "VK_EXT_robustness2", "VK_KHR_robustness2" }, + { "VK_KHR_shader_non_semantic_info", "VK_VERSION_1_3" }, + { "VK_EXT_private_data", "VK_VERSION_1_3" }, + { "VK_EXT_pipeline_creation_cache_control", "VK_VERSION_1_3" }, + { "VK_KHR_synchronization2", "VK_VERSION_1_3" }, + { "VK_KHR_zero_initialize_workgroup_memory", "VK_VERSION_1_3" }, + { "VK_EXT_ycbcr_2plane_444_formats", "VK_VERSION_1_3" }, + { "VK_EXT_image_robustness", "VK_VERSION_1_3" }, + { "VK_KHR_copy_commands2", "VK_VERSION_1_3" }, + { "VK_EXT_4444_formats", "VK_VERSION_1_3" }, + { "VK_ARM_rasterization_order_attachment_access", + "VK_EXT_rasterization_order_attachment_access" }, + { "VK_VALVE_mutable_descriptor_type", "VK_EXT_mutable_descriptor_type" }, + { "VK_KHR_format_feature_flags2", "VK_VERSION_1_3" }, + { "VK_EXT_present_mode_fifo_latest_ready", "VK_KHR_present_mode_fifo_latest_ready" }, + { "VK_EXT_extended_dynamic_state2", "VK_VERSION_1_3" }, + { "VK_EXT_global_priority_query", "VK_KHR_global_priority" }, + { "VK_EXT_load_store_op_none", "VK_KHR_load_store_op_none" }, + { "VK_KHR_maintenance4", "VK_VERSION_1_3" }, + { "VK_KHR_shader_subgroup_rotate", "VK_VERSION_1_4" }, + { "VK_EXT_depth_clamp_zero_one", "VK_KHR_depth_clamp_zero_one" }, + { "VK_QCOM_fragment_density_map_offset", "VK_EXT_fragment_density_map_offset" }, + { "VK_NV_copy_memory_indirect", "VK_KHR_copy_memory_indirect" }, + { "VK_NV_memory_decompression", "VK_EXT_memory_decompression" }, + { "VK_EXT_pipeline_protected_access", "VK_VERSION_1_4" }, + { "VK_KHR_maintenance5", "VK_VERSION_1_4" }, + { "VK_NV_ray_tracing_invocation_reorder", "VK_EXT_ray_tracing_invocation_reorder" }, + { "VK_KHR_vertex_attribute_divisor", "VK_VERSION_1_4" }, + { "VK_KHR_load_store_op_none", "VK_VERSION_1_4" }, + { "VK_KHR_shader_float_controls2", "VK_VERSION_1_4" }, + { "VK_KHR_index_type_uint8", "VK_VERSION_1_4" }, + { "VK_KHR_line_rasterization", "VK_VERSION_1_4" }, + { "VK_KHR_shader_expect_assume", "VK_VERSION_1_4" }, + { "VK_KHR_maintenance6", "VK_VERSION_1_4" }, + { "VK_EXT_vertex_attribute_robustness", "VK_KHR_maintenance9" } }; + return promotedExtensions; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & extension ) + { + if ( extension == "VK_EXT_debug_report" ) + { + return "VK_EXT_debug_utils"; + } + if ( extension == "VK_NV_glsl_shader" ) + { + return ""; + } + if ( extension == "VK_NV_dedicated_allocation" ) + { + return "VK_KHR_dedicated_allocation"; + } + if ( extension == "VK_AMD_gpu_shader_half_float" ) + { + return "VK_KHR_shader_float16_int8"; + } + if ( extension == "VK_IMG_format_pvrtc" ) + { + return ""; + } + if ( extension == "VK_NV_external_memory_capabilities" ) + { + return "VK_KHR_external_memory_capabilities"; + } + if ( extension == "VK_NV_external_memory" ) + { + return "VK_KHR_external_memory"; + } +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + if ( extension == "VK_NV_external_memory_win32" ) + { + return "VK_KHR_external_memory_win32"; + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + if ( extension == "VK_EXT_validation_flags" ) + { + return "VK_EXT_layer_settings"; + } + if ( extension == "VK_EXT_shader_subgroup_ballot" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_EXT_shader_subgroup_vote" ) + { + return "VK_VERSION_1_1"; + } +#if defined( VK_USE_PLATFORM_IOS_MVK ) + if ( extension == "VK_MVK_ios_surface" ) + { + return "VK_EXT_metal_surface"; + } +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + if ( extension == "VK_MVK_macos_surface" ) + { + return "VK_EXT_metal_surface"; + } +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + if ( extension == "VK_AMD_gpu_shader_int16" ) + { + return "VK_KHR_shader_float16_int8"; + } + if ( extension == "VK_NV_ray_tracing" ) + { + return "VK_KHR_ray_tracing_pipeline"; + } + if ( extension == "VK_EXT_buffer_device_address" ) + { + return "VK_KHR_buffer_device_address"; + } + if ( extension == "VK_EXT_validation_features" ) + { + return "VK_EXT_layer_settings"; + } +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + if ( extension == "VK_NV_displacement_micromap" ) + { + return "VK_NV_cluster_acceleration_structure"; + } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + return ""; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & extension ) + { + if ( extension == "VK_AMD_negative_viewport_height" ) + { + return "VK_KHR_maintenance1"; + } + return ""; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & extension ) + { + if ( extension == "VK_KHR_sampler_mirror_clamp_to_edge" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_EXT_debug_marker" ) + { + return "VK_EXT_debug_utils"; + } + if ( extension == "VK_AMD_draw_indirect_count" ) + { + return "VK_KHR_draw_indirect_count"; + } + if ( extension == "VK_KHR_dynamic_rendering" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_KHR_multiview" ) + { + return "VK_VERSION_1_1"; + } +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + if ( extension == "VK_NV_win32_keyed_mutex" ) + { + return "VK_KHR_win32_keyed_mutex"; + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + if ( extension == "VK_KHR_get_physical_device_properties2" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_device_group" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_shader_draw_parameters" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_EXT_texture_compression_astc_hdr" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_pipeline_robustness" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_KHR_maintenance1" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_device_group_creation" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_external_memory_capabilities" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_external_memory" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_external_semaphore_capabilities" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_external_semaphore" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_push_descriptor" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_KHR_shader_float16_int8" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_16bit_storage" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_descriptor_update_template" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_imageless_framebuffer" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_create_renderpass2" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_external_fence_capabilities" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_external_fence" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_maintenance2" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_variable_pointers" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_dedicated_allocation" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_EXT_sampler_filter_minmax" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_storage_buffer_storage_class" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_EXT_inline_uniform_block" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_KHR_relaxed_block_layout" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_get_memory_requirements2" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_image_format_list" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_sampler_ycbcr_conversion" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_bind_memory2" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_EXT_descriptor_indexing" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_EXT_shader_viewport_index_layer" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_maintenance3" ) + { + return "VK_VERSION_1_1"; + } + if ( extension == "VK_KHR_draw_indirect_count" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_QCOM_render_pass_shader_resolve" ) + { + return "VK_EXT_custom_resolve"; + } + if ( extension == "VK_EXT_global_priority" ) + { + return "VK_KHR_global_priority"; + } + if ( extension == "VK_KHR_shader_subgroup_extended_types" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_8bit_storage" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_shader_atomic_int64" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_EXT_calibrated_timestamps" ) + { + return "VK_KHR_calibrated_timestamps"; + } + if ( extension == "VK_KHR_global_priority" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_EXT_vertex_attribute_divisor" ) + { + return "VK_KHR_vertex_attribute_divisor"; + } + if ( extension == "VK_EXT_pipeline_creation_feedback" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_KHR_driver_properties" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_shader_float_controls" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_NV_shader_subgroup_partitioned" ) + { + return "VK_EXT_shader_subgroup_partitioned"; + } + if ( extension == "VK_KHR_depth_stencil_resolve" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_NV_compute_shader_derivatives" ) + { + return "VK_KHR_compute_shader_derivatives"; + } + if ( extension == "VK_NV_fragment_shader_barycentric" ) + { + return "VK_KHR_fragment_shader_barycentric"; + } + if ( extension == "VK_KHR_timeline_semaphore" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_vulkan_memory_model" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_shader_terminate_invocation" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_scalar_block_layout" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_EXT_subgroup_size_control" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_KHR_dynamic_rendering_local_read" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_KHR_spirv_1_4" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_separate_depth_stencil_layouts" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_EXT_tooling_info" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_separate_stencil_usage" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_uniform_buffer_standard_layout" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_KHR_buffer_device_address" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_EXT_line_rasterization" ) + { + return "VK_KHR_line_rasterization"; + } + if ( extension == "VK_EXT_host_query_reset" ) + { + return "VK_VERSION_1_2"; + } + if ( extension == "VK_EXT_index_type_uint8" ) + { + return "VK_KHR_index_type_uint8"; + } + if ( extension == "VK_EXT_extended_dynamic_state" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_host_image_copy" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_KHR_map_memory2" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_EXT_surface_maintenance1" ) + { + return "VK_KHR_surface_maintenance1"; + } + if ( extension == "VK_EXT_swapchain_maintenance1" ) + { + return "VK_KHR_swapchain_maintenance1"; + } + if ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_KHR_shader_integer_dot_product" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_texel_buffer_alignment" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_robustness2" ) + { + return "VK_KHR_robustness2"; + } + if ( extension == "VK_KHR_shader_non_semantic_info" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_private_data" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_pipeline_creation_cache_control" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_KHR_synchronization2" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_image_robustness" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_KHR_copy_commands2" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_4444_formats" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_ARM_rasterization_order_attachment_access" ) + { + return "VK_EXT_rasterization_order_attachment_access"; + } + if ( extension == "VK_VALVE_mutable_descriptor_type" ) + { + return "VK_EXT_mutable_descriptor_type"; + } + if ( extension == "VK_KHR_format_feature_flags2" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_present_mode_fifo_latest_ready" ) + { + return "VK_KHR_present_mode_fifo_latest_ready"; + } + if ( extension == "VK_EXT_extended_dynamic_state2" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_EXT_global_priority_query" ) + { + return "VK_KHR_global_priority"; + } + if ( extension == "VK_EXT_load_store_op_none" ) + { + return "VK_KHR_load_store_op_none"; + } + if ( extension == "VK_KHR_maintenance4" ) + { + return "VK_VERSION_1_3"; + } + if ( extension == "VK_KHR_shader_subgroup_rotate" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_EXT_depth_clamp_zero_one" ) + { + return "VK_KHR_depth_clamp_zero_one"; + } + if ( extension == "VK_QCOM_fragment_density_map_offset" ) + { + return "VK_EXT_fragment_density_map_offset"; + } + if ( extension == "VK_NV_copy_memory_indirect" ) + { + return "VK_KHR_copy_memory_indirect"; + } + if ( extension == "VK_NV_memory_decompression" ) + { + return "VK_EXT_memory_decompression"; + } + if ( extension == "VK_EXT_pipeline_protected_access" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_KHR_maintenance5" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_NV_ray_tracing_invocation_reorder" ) + { + return "VK_EXT_ray_tracing_invocation_reorder"; + } + if ( extension == "VK_KHR_vertex_attribute_divisor" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_KHR_load_store_op_none" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_KHR_shader_float_controls2" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_KHR_index_type_uint8" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_KHR_line_rasterization" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_KHR_shader_expect_assume" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_KHR_maintenance6" ) + { + return "VK_VERSION_1_4"; + } + if ( extension == "VK_EXT_vertex_attribute_robustness" ) + { + return "VK_KHR_maintenance9"; + } + return ""; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & extension ) + { + return ( extension == "VK_EXT_debug_report" ) || ( extension == "VK_NV_glsl_shader" ) || ( extension == "VK_NV_dedicated_allocation" ) || + ( extension == "VK_AMD_gpu_shader_half_float" ) || ( extension == "VK_IMG_format_pvrtc" ) || ( extension == "VK_NV_external_memory_capabilities" ) || + ( extension == "VK_NV_external_memory" ) +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + || ( extension == "VK_NV_external_memory_win32" ) +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + || ( extension == "VK_EXT_validation_flags" ) || ( extension == "VK_EXT_shader_subgroup_ballot" ) || ( extension == "VK_EXT_shader_subgroup_vote" ) +#if defined( VK_USE_PLATFORM_IOS_MVK ) + || ( extension == "VK_MVK_ios_surface" ) +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + || ( extension == "VK_MVK_macos_surface" ) +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + || ( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_EXT_buffer_device_address" ) || + ( extension == "VK_EXT_validation_features" ) +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + || ( extension == "VK_NV_displacement_micromap" ) +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + || false; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension ) + { + return ( extension == "VK_KHR_swapchain" ) || ( extension == "VK_KHR_display_swapchain" ) || ( extension == "VK_NV_glsl_shader" ) || + ( extension == "VK_EXT_depth_range_unrestricted" ) || ( extension == "VK_KHR_sampler_mirror_clamp_to_edge" ) || + ( extension == "VK_IMG_filter_cubic" ) || ( extension == "VK_AMD_rasterization_order" ) || ( extension == "VK_AMD_shader_trinary_minmax" ) || + ( extension == "VK_AMD_shader_explicit_vertex_parameter" ) || ( extension == "VK_EXT_debug_marker" ) || ( extension == "VK_KHR_video_queue" ) || + ( extension == "VK_KHR_video_decode_queue" ) || ( extension == "VK_AMD_gcn_shader" ) || ( extension == "VK_NV_dedicated_allocation" ) || + ( extension == "VK_EXT_transform_feedback" ) || ( extension == "VK_NVX_binary_import" ) || ( extension == "VK_NVX_image_view_handle" ) || + ( extension == "VK_AMD_draw_indirect_count" ) || ( extension == "VK_AMD_negative_viewport_height" ) || + ( extension == "VK_AMD_gpu_shader_half_float" ) || ( extension == "VK_AMD_shader_ballot" ) || ( extension == "VK_KHR_video_encode_h264" ) || + ( extension == "VK_KHR_video_encode_h265" ) || ( extension == "VK_KHR_video_decode_h264" ) || ( extension == "VK_AMD_texture_gather_bias_lod" ) || + ( extension == "VK_AMD_shader_info" ) || ( extension == "VK_KHR_dynamic_rendering" ) || ( extension == "VK_AMD_shader_image_load_store_lod" ) || + ( extension == "VK_NV_corner_sampled_image" ) || ( extension == "VK_KHR_multiview" ) || ( extension == "VK_IMG_format_pvrtc" ) || + ( extension == "VK_NV_external_memory" ) +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + || ( extension == "VK_NV_external_memory_win32" ) || ( extension == "VK_NV_win32_keyed_mutex" ) +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + || ( extension == "VK_KHR_device_group" ) || ( extension == "VK_KHR_shader_draw_parameters" ) || ( extension == "VK_EXT_shader_subgroup_ballot" ) || + ( extension == "VK_EXT_shader_subgroup_vote" ) || ( extension == "VK_EXT_texture_compression_astc_hdr" ) || + ( extension == "VK_EXT_astc_decode_mode" ) || ( extension == "VK_EXT_pipeline_robustness" ) || ( extension == "VK_KHR_maintenance1" ) || + ( extension == "VK_KHR_external_memory" ) +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + || ( extension == "VK_KHR_external_memory_win32" ) +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + || ( extension == "VK_KHR_external_memory_fd" ) +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + || ( extension == "VK_KHR_win32_keyed_mutex" ) +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + || ( extension == "VK_KHR_external_semaphore" ) +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + || ( extension == "VK_KHR_external_semaphore_win32" ) +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + || ( extension == "VK_KHR_external_semaphore_fd" ) || ( extension == "VK_KHR_push_descriptor" ) || ( extension == "VK_EXT_conditional_rendering" ) || + ( extension == "VK_KHR_shader_float16_int8" ) || ( extension == "VK_KHR_16bit_storage" ) || ( extension == "VK_KHR_incremental_present" ) || + ( extension == "VK_KHR_descriptor_update_template" ) || ( extension == "VK_NV_clip_space_w_scaling" ) || ( extension == "VK_EXT_display_control" ) || + ( extension == "VK_GOOGLE_display_timing" ) || ( extension == "VK_NV_sample_mask_override_coverage" ) || + ( extension == "VK_NV_geometry_shader_passthrough" ) || ( extension == "VK_NV_viewport_array2" ) || + ( extension == "VK_NVX_multiview_per_view_attributes" ) || ( extension == "VK_NV_viewport_swizzle" ) || + ( extension == "VK_EXT_discard_rectangles" ) || ( extension == "VK_EXT_conservative_rasterization" ) || + ( extension == "VK_EXT_depth_clip_enable" ) || ( extension == "VK_EXT_hdr_metadata" ) || ( extension == "VK_KHR_imageless_framebuffer" ) || + ( extension == "VK_KHR_create_renderpass2" ) || ( extension == "VK_IMG_relaxed_line_rasterization" ) || + ( extension == "VK_KHR_shared_presentable_image" ) || ( extension == "VK_KHR_external_fence" ) +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + || ( extension == "VK_KHR_external_fence_win32" ) +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + || ( extension == "VK_KHR_external_fence_fd" ) || ( extension == "VK_KHR_performance_query" ) || ( extension == "VK_KHR_maintenance2" ) || + ( extension == "VK_KHR_variable_pointers" ) || ( extension == "VK_EXT_external_memory_dma_buf" ) || ( extension == "VK_EXT_queue_family_foreign" ) || + ( extension == "VK_KHR_dedicated_allocation" ) +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + || ( extension == "VK_ANDROID_external_memory_android_hardware_buffer" ) +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + || ( extension == "VK_EXT_sampler_filter_minmax" ) || ( extension == "VK_KHR_storage_buffer_storage_class" ) || + ( extension == "VK_AMD_gpu_shader_int16" ) +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + || ( extension == "VK_AMDX_shader_enqueue" ) +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + || ( extension == "VK_EXT_descriptor_heap" ) || ( extension == "VK_AMD_mixed_attachment_samples" ) || ( extension == "VK_AMD_shader_fragment_mask" ) || + ( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_KHR_shader_bfloat16" ) || + ( extension == "VK_EXT_sample_locations" ) || ( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) || + ( extension == "VK_KHR_image_format_list" ) || ( extension == "VK_EXT_blend_operation_advanced" ) || + ( extension == "VK_NV_fragment_coverage_to_color" ) || ( extension == "VK_KHR_acceleration_structure" ) || + ( extension == "VK_KHR_ray_tracing_pipeline" ) || ( extension == "VK_KHR_ray_query" ) || ( extension == "VK_NV_framebuffer_mixed_samples" ) || + ( extension == "VK_NV_fill_rectangle" ) || ( extension == "VK_NV_shader_sm_builtins" ) || ( extension == "VK_EXT_post_depth_coverage" ) || + ( extension == "VK_KHR_sampler_ycbcr_conversion" ) || ( extension == "VK_KHR_bind_memory2" ) || + ( extension == "VK_EXT_image_drm_format_modifier" ) || ( extension == "VK_EXT_validation_cache" ) || ( extension == "VK_EXT_descriptor_indexing" ) || + ( extension == "VK_EXT_shader_viewport_index_layer" ) +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + || ( extension == "VK_KHR_portability_subset" ) +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + || ( extension == "VK_NV_shading_rate_image" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_NV_representative_fragment_test" ) || + ( extension == "VK_KHR_maintenance3" ) || ( extension == "VK_KHR_draw_indirect_count" ) || ( extension == "VK_EXT_filter_cubic" ) || + ( extension == "VK_QCOM_render_pass_shader_resolve" ) || ( extension == "VK_EXT_global_priority" ) || + ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) || + ( extension == "VK_EXT_external_memory_host" ) || ( extension == "VK_AMD_buffer_marker" ) || ( extension == "VK_KHR_shader_atomic_int64" ) || + ( extension == "VK_KHR_shader_clock" ) || ( extension == "VK_AMD_pipeline_compiler_control" ) || ( extension == "VK_EXT_calibrated_timestamps" ) || + ( extension == "VK_AMD_shader_core_properties" ) || ( extension == "VK_KHR_video_decode_h265" ) || ( extension == "VK_KHR_global_priority" ) || + ( extension == "VK_AMD_memory_overallocation_behavior" ) || ( extension == "VK_EXT_vertex_attribute_divisor" ) +#if defined( VK_USE_PLATFORM_GGP ) + || ( extension == "VK_GGP_frame_token" ) +#endif /*VK_USE_PLATFORM_GGP*/ + || ( extension == "VK_EXT_pipeline_creation_feedback" ) || ( extension == "VK_KHR_driver_properties" ) || + ( extension == "VK_KHR_shader_float_controls" ) || ( extension == "VK_NV_shader_subgroup_partitioned" ) || + ( extension == "VK_KHR_depth_stencil_resolve" ) || ( extension == "VK_KHR_swapchain_mutable_format" ) || + ( extension == "VK_NV_compute_shader_derivatives" ) || ( extension == "VK_NV_mesh_shader" ) || + ( extension == "VK_NV_fragment_shader_barycentric" ) || ( extension == "VK_NV_shader_image_footprint" ) || + ( extension == "VK_NV_scissor_exclusive" ) || ( extension == "VK_NV_device_diagnostic_checkpoints" ) || + ( extension == "VK_KHR_timeline_semaphore" ) || ( extension == "VK_EXT_present_timing" ) || ( extension == "VK_INTEL_shader_integer_functions2" ) || + ( extension == "VK_INTEL_performance_query" ) || ( extension == "VK_KHR_vulkan_memory_model" ) || ( extension == "VK_EXT_pci_bus_info" ) || + ( extension == "VK_AMD_display_native_hdr" ) || ( extension == "VK_KHR_shader_terminate_invocation" ) || + ( extension == "VK_EXT_fragment_density_map" ) || ( extension == "VK_EXT_scalar_block_layout" ) || + ( extension == "VK_GOOGLE_hlsl_functionality1" ) || ( extension == "VK_GOOGLE_decorate_string" ) || + ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_fragment_shading_rate" ) || + ( extension == "VK_AMD_shader_core_properties2" ) || ( extension == "VK_AMD_device_coherent_memory" ) || + ( extension == "VK_KHR_dynamic_rendering_local_read" ) || ( extension == "VK_EXT_shader_image_atomic_int64" ) || + ( extension == "VK_KHR_shader_quad_control" ) || ( extension == "VK_KHR_spirv_1_4" ) || ( extension == "VK_EXT_memory_budget" ) || + ( extension == "VK_EXT_memory_priority" ) || ( extension == "VK_NV_dedicated_allocation_image_aliasing" ) || + ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || ( extension == "VK_EXT_buffer_device_address" ) || + ( extension == "VK_EXT_tooling_info" ) || ( extension == "VK_EXT_separate_stencil_usage" ) || ( extension == "VK_KHR_present_wait" ) || + ( extension == "VK_NV_cooperative_matrix" ) || ( extension == "VK_NV_coverage_reduction_mode" ) || + ( extension == "VK_EXT_fragment_shader_interlock" ) || ( extension == "VK_EXT_ycbcr_image_arrays" ) || + ( extension == "VK_KHR_uniform_buffer_standard_layout" ) || ( extension == "VK_EXT_provoking_vertex" ) +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + || ( extension == "VK_EXT_full_screen_exclusive" ) +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + || ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_shader_atomic_float" ) || + ( extension == "VK_EXT_host_query_reset" ) || ( extension == "VK_EXT_index_type_uint8" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || + ( extension == "VK_KHR_deferred_host_operations" ) || ( extension == "VK_KHR_pipeline_executable_properties" ) || + ( extension == "VK_EXT_host_image_copy" ) || ( extension == "VK_KHR_map_memory2" ) || ( extension == "VK_EXT_map_memory_placed" ) || + ( extension == "VK_EXT_shader_atomic_float2" ) || ( extension == "VK_EXT_swapchain_maintenance1" ) || + ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || ( extension == "VK_NV_device_generated_commands" ) || + ( extension == "VK_NV_inherited_viewport_scissor" ) || ( extension == "VK_KHR_shader_integer_dot_product" ) || + ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_QCOM_render_pass_transform" ) || + ( extension == "VK_EXT_depth_bias_control" ) || ( extension == "VK_EXT_device_memory_report" ) || ( extension == "VK_EXT_robustness2" ) || + ( extension == "VK_EXT_custom_border_color" ) || ( extension == "VK_EXT_texture_compression_astc_3d" ) || ( extension == "VK_GOOGLE_user_type" ) || + ( extension == "VK_KHR_pipeline_library" ) || ( extension == "VK_NV_present_barrier" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || + ( extension == "VK_KHR_present_id" ) || ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || + ( extension == "VK_KHR_video_encode_queue" ) || ( extension == "VK_NV_device_diagnostics_config" ) || + ( extension == "VK_QCOM_render_pass_store_ops" ) +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + || ( extension == "VK_NV_cuda_kernel_launch" ) +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + || ( extension == "VK_QCOM_tile_shading" ) || ( extension == "VK_NV_low_latency" ) +#if defined( VK_USE_PLATFORM_METAL_EXT ) + || ( extension == "VK_EXT_metal_objects" ) +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_EXT_descriptor_buffer" ) || ( extension == "VK_EXT_graphics_pipeline_library" ) || + ( extension == "VK_AMD_shader_early_and_late_fragment_tests" ) || ( extension == "VK_KHR_fragment_shader_barycentric" ) || + ( extension == "VK_KHR_shader_subgroup_uniform_control_flow" ) || ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || + ( extension == "VK_NV_fragment_shading_rate_enums" ) || ( extension == "VK_NV_ray_tracing_motion_blur" ) || ( extension == "VK_EXT_mesh_shader" ) || + ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || ( extension == "VK_EXT_fragment_density_map2" ) || + ( extension == "VK_QCOM_rotated_copy_commands" ) || ( extension == "VK_EXT_image_robustness" ) || + ( extension == "VK_KHR_workgroup_memory_explicit_layout" ) || ( extension == "VK_KHR_copy_commands2" ) || + ( extension == "VK_EXT_image_compression_control" ) || ( extension == "VK_EXT_attachment_feedback_loop_layout" ) || + ( extension == "VK_EXT_4444_formats" ) || ( extension == "VK_EXT_device_fault" ) || + ( extension == "VK_ARM_rasterization_order_attachment_access" ) || ( extension == "VK_EXT_rgba10x6_formats" ) +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + || ( extension == "VK_NV_acquire_winrt_display" ) +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + || ( extension == "VK_VALVE_mutable_descriptor_type" ) || ( extension == "VK_EXT_vertex_input_dynamic_state" ) || + ( extension == "VK_EXT_physical_device_drm" ) || ( extension == "VK_EXT_device_address_binding_report" ) || + ( extension == "VK_EXT_depth_clip_control" ) || ( extension == "VK_EXT_primitive_topology_list_restart" ) || + ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_present_mode_fifo_latest_ready" ) +#if defined( VK_USE_PLATFORM_FUCHSIA ) + || ( extension == "VK_FUCHSIA_external_memory" ) || ( extension == "VK_FUCHSIA_external_semaphore" ) || ( extension == "VK_FUCHSIA_buffer_collection" ) +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + || ( extension == "VK_HUAWEI_subpass_shading" ) || ( extension == "VK_HUAWEI_invocation_mask" ) || ( extension == "VK_NV_external_memory_rdma" ) || + ( extension == "VK_EXT_pipeline_properties" ) || ( extension == "VK_EXT_frame_boundary" ) || + ( extension == "VK_EXT_multisampled_render_to_single_sampled" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) || + ( extension == "VK_EXT_color_write_enable" ) || ( extension == "VK_EXT_primitives_generated_query" ) || + ( extension == "VK_KHR_ray_tracing_maintenance1" ) || ( extension == "VK_KHR_shader_untyped_pointers" ) || + ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_VALVE_video_encode_rgb_conversion" ) || + ( extension == "VK_EXT_image_view_min_lod" ) || ( extension == "VK_EXT_multi_draw" ) || ( extension == "VK_EXT_image_2d_view_of_3d" ) || + ( extension == "VK_EXT_shader_tile_image" ) || ( extension == "VK_EXT_opacity_micromap" ) +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + || ( extension == "VK_NV_displacement_micromap" ) +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + || ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_HUAWEI_cluster_culling_shader" ) || + ( extension == "VK_EXT_border_color_swizzle" ) || ( extension == "VK_EXT_pageable_device_local_memory" ) || ( extension == "VK_KHR_maintenance4" ) || + ( extension == "VK_ARM_shader_core_properties" ) || ( extension == "VK_KHR_shader_subgroup_rotate" ) || + ( extension == "VK_ARM_scheduling_controls" ) || ( extension == "VK_EXT_image_sliced_view_of_3d" ) || + ( extension == "VK_VALVE_descriptor_set_host_mapping" ) || ( extension == "VK_EXT_depth_clamp_zero_one" ) || + ( extension == "VK_EXT_non_seamless_cube_map" ) || ( extension == "VK_ARM_render_pass_striped" ) || + ( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_NV_copy_memory_indirect" ) || + ( extension == "VK_NV_memory_decompression" ) || ( extension == "VK_NV_device_generated_commands_compute" ) || + ( extension == "VK_NV_ray_tracing_linear_swept_spheres" ) || ( extension == "VK_NV_linear_color_attachment" ) || + ( extension == "VK_KHR_shader_maximal_reconvergence" ) || ( extension == "VK_EXT_image_compression_control_swapchain" ) || + ( extension == "VK_QCOM_image_processing" ) || ( extension == "VK_EXT_nested_command_buffer" ) +#if defined( VK_USE_PLATFORM_OHOS ) + || ( extension == "VK_OHOS_external_memory" ) +#endif /*VK_USE_PLATFORM_OHOS*/ + || ( extension == "VK_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) || + ( extension == "VK_EXT_subpass_merge_feedback" ) || ( extension == "VK_ARM_tensors" ) || ( extension == "VK_EXT_shader_module_identifier" ) || + ( extension == "VK_EXT_rasterization_order_attachment_access" ) || ( extension == "VK_NV_optical_flow" ) || + ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" ) +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + || ( extension == "VK_ANDROID_external_format_resolve" ) +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + || ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" ) +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + || ( extension == "VK_AMDX_dense_geometry_format" ) +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + || ( extension == "VK_KHR_present_id2" ) || ( extension == "VK_KHR_present_wait2" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) || + ( extension == "VK_EXT_shader_object" ) || ( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) || + ( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_KHR_swapchain_maintenance1" ) || + ( extension == "VK_QCOM_multiview_per_view_viewports" ) || ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || + ( extension == "VK_NV_cooperative_vector" ) || ( extension == "VK_NV_extended_sparse_address_space" ) || + ( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_EXT_legacy_vertex_attributes" ) || + ( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) || + ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_KHR_internally_synchronized_queues" ) || + ( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_ARM_data_graph" ) || + ( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_compute_shader_derivatives" ) || + ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) || ( extension == "VK_KHR_video_decode_vp9" ) || + ( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) || + ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) || + ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) || + ( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_unified_image_layouts" ) || ( extension == "VK_KHR_shader_float_controls2" ) +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + || ( extension == "VK_QNX_external_memory_screen_buffer" ) +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) || + ( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) || + ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_QCOM_tile_memory_heap" ) || + ( extension == "VK_KHR_copy_memory_indirect" ) || ( extension == "VK_EXT_memory_decompression" ) || + ( extension == "VK_KHR_video_encode_intra_refresh" ) || ( extension == "VK_KHR_video_encode_quantization_map" ) || + ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_NV_external_compute_queue" ) || + ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) || + ( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) || + ( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_EXT_shader_float8" ) || + ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) || + ( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) || + ( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_KHR_shader_fma" ) || + ( extension == "VK_NV_push_constant_bank" ) || ( extension == "VK_EXT_ray_tracing_invocation_reorder" ) || + ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) || + ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" ) +#if defined( VK_USE_PLATFORM_METAL_EXT ) + || ( extension == "VK_EXT_external_memory_metal" ) +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + || ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_ARM_performance_counters_by_region" ) || + ( extension == "VK_EXT_vertex_attribute_robustness" ) || ( extension == "VK_ARM_format_pack" ) || + ( extension == "VK_VALVE_fragment_density_map_layered" ) || ( extension == "VK_KHR_robustness2" ) +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + || ( extension == "VK_NV_present_metering" ) +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + || ( extension == "VK_EXT_fragment_density_map_offset" ) || ( extension == "VK_EXT_zero_initialize_device_memory" ) || + ( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_shader_64bit_indexing" ) || + ( extension == "VK_EXT_custom_resolve" ) || ( extension == "VK_QCOM_data_graph_model" ) || ( extension == "VK_KHR_maintenance10" ) || + ( extension == "VK_EXT_shader_long_vector" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) || + ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" ) || ( extension == "VK_NV_compute_occupancy_priority" ) || + ( extension == "VK_EXT_shader_subgroup_partitioned" ); + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension ) + { + return ( extension == "VK_KHR_surface" ) || ( extension == "VK_KHR_display" ) +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + || ( extension == "VK_KHR_xlib_surface" ) +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ +#if defined( VK_USE_PLATFORM_XCB_KHR ) + || ( extension == "VK_KHR_xcb_surface" ) +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + || ( extension == "VK_KHR_wayland_surface" ) +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + || ( extension == "VK_KHR_android_surface" ) +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + || ( extension == "VK_KHR_win32_surface" ) +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + || ( extension == "VK_EXT_debug_report" ) +#if defined( VK_USE_PLATFORM_GGP ) + || ( extension == "VK_GGP_stream_descriptor_surface" ) +#endif /*VK_USE_PLATFORM_GGP*/ + || ( extension == "VK_NV_external_memory_capabilities" ) || ( extension == "VK_KHR_get_physical_device_properties2" ) || + ( extension == "VK_EXT_validation_flags" ) +#if defined( VK_USE_PLATFORM_VI_NN ) + || ( extension == "VK_NN_vi_surface" ) +#endif /*VK_USE_PLATFORM_VI_NN*/ + || ( extension == "VK_KHR_device_group_creation" ) || ( extension == "VK_KHR_external_memory_capabilities" ) || + ( extension == "VK_KHR_external_semaphore_capabilities" ) || ( extension == "VK_EXT_direct_mode_display" ) +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + || ( extension == "VK_EXT_acquire_xlib_display" ) +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + || ( extension == "VK_EXT_display_surface_counter" ) || ( extension == "VK_EXT_swapchain_colorspace" ) || + ( extension == "VK_KHR_external_fence_capabilities" ) || ( extension == "VK_KHR_get_surface_capabilities2" ) || + ( extension == "VK_KHR_get_display_properties2" ) +#if defined( VK_USE_PLATFORM_IOS_MVK ) + || ( extension == "VK_MVK_ios_surface" ) +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + || ( extension == "VK_MVK_macos_surface" ) +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + || ( extension == "VK_EXT_debug_utils" ) +#if defined( VK_USE_PLATFORM_FUCHSIA ) + || ( extension == "VK_FUCHSIA_imagepipe_surface" ) +#endif /*VK_USE_PLATFORM_FUCHSIA*/ +#if defined( VK_USE_PLATFORM_METAL_EXT ) + || ( extension == "VK_EXT_metal_surface" ) +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + || ( extension == "VK_KHR_surface_protected_capabilities" ) || ( extension == "VK_EXT_validation_features" ) || + ( extension == "VK_EXT_headless_surface" ) || ( extension == "VK_EXT_surface_maintenance1" ) || ( extension == "VK_EXT_acquire_drm_display" ) +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + || ( extension == "VK_EXT_directfb_surface" ) +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + || ( extension == "VK_QNX_screen_surface" ) +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + || ( extension == "VK_KHR_portability_enumeration" ) || ( extension == "VK_GOOGLE_surfaceless_query" ) || + ( extension == "VK_LUNARG_direct_driver_loading" ) || ( extension == "VK_KHR_surface_maintenance1" ) || ( extension == "VK_EXT_layer_settings" ) || + ( extension == "VK_NV_display_stereo" ) +#if defined( VK_USE_PLATFORM_OHOS ) + || ( extension == "VK_OHOS_surface" ) +#endif /*VK_USE_PLATFORM_OHOS*/ + ; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension ) + { + return ( extension == "VK_AMD_negative_viewport_height" ); + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & extension ) + { + return ( extension == "VK_KHR_sampler_mirror_clamp_to_edge" ) || ( extension == "VK_EXT_debug_marker" ) || ( extension == "VK_AMD_draw_indirect_count" ) || + ( extension == "VK_KHR_dynamic_rendering" ) || ( extension == "VK_KHR_multiview" ) +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + || ( extension == "VK_NV_win32_keyed_mutex" ) +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + || ( extension == "VK_KHR_get_physical_device_properties2" ) || ( extension == "VK_KHR_device_group" ) || + ( extension == "VK_KHR_shader_draw_parameters" ) || ( extension == "VK_EXT_texture_compression_astc_hdr" ) || + ( extension == "VK_EXT_pipeline_robustness" ) || ( extension == "VK_KHR_maintenance1" ) || ( extension == "VK_KHR_device_group_creation" ) || + ( extension == "VK_KHR_external_memory_capabilities" ) || ( extension == "VK_KHR_external_memory" ) || + ( extension == "VK_KHR_external_semaphore_capabilities" ) || ( extension == "VK_KHR_external_semaphore" ) || + ( extension == "VK_KHR_push_descriptor" ) || ( extension == "VK_KHR_shader_float16_int8" ) || ( extension == "VK_KHR_16bit_storage" ) || + ( extension == "VK_KHR_descriptor_update_template" ) || ( extension == "VK_KHR_imageless_framebuffer" ) || + ( extension == "VK_KHR_create_renderpass2" ) || ( extension == "VK_KHR_external_fence_capabilities" ) || ( extension == "VK_KHR_external_fence" ) || + ( extension == "VK_KHR_maintenance2" ) || ( extension == "VK_KHR_variable_pointers" ) || ( extension == "VK_KHR_dedicated_allocation" ) || + ( extension == "VK_EXT_sampler_filter_minmax" ) || ( extension == "VK_KHR_storage_buffer_storage_class" ) || + ( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_KHR_relaxed_block_layout" ) || + ( extension == "VK_KHR_get_memory_requirements2" ) || ( extension == "VK_KHR_image_format_list" ) || + ( extension == "VK_KHR_sampler_ycbcr_conversion" ) || ( extension == "VK_KHR_bind_memory2" ) || ( extension == "VK_EXT_descriptor_indexing" ) || + ( extension == "VK_EXT_shader_viewport_index_layer" ) || ( extension == "VK_KHR_maintenance3" ) || ( extension == "VK_KHR_draw_indirect_count" ) || + ( extension == "VK_QCOM_render_pass_shader_resolve" ) || ( extension == "VK_EXT_global_priority" ) || + ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) || + ( extension == "VK_KHR_shader_atomic_int64" ) || ( extension == "VK_EXT_calibrated_timestamps" ) || ( extension == "VK_KHR_global_priority" ) || + ( extension == "VK_EXT_vertex_attribute_divisor" ) || ( extension == "VK_EXT_pipeline_creation_feedback" ) || + ( extension == "VK_KHR_driver_properties" ) || ( extension == "VK_KHR_shader_float_controls" ) || + ( extension == "VK_NV_shader_subgroup_partitioned" ) || ( extension == "VK_KHR_depth_stencil_resolve" ) || + ( extension == "VK_NV_compute_shader_derivatives" ) || ( extension == "VK_NV_fragment_shader_barycentric" ) || + ( extension == "VK_KHR_timeline_semaphore" ) || ( extension == "VK_KHR_vulkan_memory_model" ) || + ( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_scalar_block_layout" ) || + ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_dynamic_rendering_local_read" ) || ( extension == "VK_KHR_spirv_1_4" ) || + ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || ( extension == "VK_EXT_tooling_info" ) || + ( extension == "VK_EXT_separate_stencil_usage" ) || ( extension == "VK_KHR_uniform_buffer_standard_layout" ) || + ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_host_query_reset" ) || + ( extension == "VK_EXT_index_type_uint8" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_host_image_copy" ) || + ( extension == "VK_KHR_map_memory2" ) || ( extension == "VK_EXT_surface_maintenance1" ) || ( extension == "VK_EXT_swapchain_maintenance1" ) || + ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || ( extension == "VK_KHR_shader_integer_dot_product" ) || + ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_EXT_robustness2" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || + ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) || + ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || + ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) || + ( extension == "VK_ARM_rasterization_order_attachment_access" ) || ( extension == "VK_VALVE_mutable_descriptor_type" ) || + ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_present_mode_fifo_latest_ready" ) || + ( extension == "VK_EXT_extended_dynamic_state2" ) || ( extension == "VK_EXT_global_priority_query" ) || + ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" ) || ( extension == "VK_KHR_shader_subgroup_rotate" ) || + ( extension == "VK_EXT_depth_clamp_zero_one" ) || ( extension == "VK_QCOM_fragment_density_map_offset" ) || + ( extension == "VK_NV_copy_memory_indirect" ) || ( extension == "VK_NV_memory_decompression" ) || + ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) || + ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) || + ( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_shader_float_controls2" ) || ( extension == "VK_KHR_index_type_uint8" ) || + ( extension == "VK_KHR_line_rasterization" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) || + ( extension == "VK_EXT_vertex_attribute_robustness" ); + } +} // namespace VULKAN_HPP_NAMESPACE + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_format_traits.hpp b/lib/vulkan-headers/include/vulkan/vulkan_format_traits.hpp new file mode 100644 index 00000000000..54072b79991 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_format_traits.hpp @@ -0,0 +1,10576 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_FORMAT_TRAITS_HPP +#define VULKAN_FORMAT_TRAITS_HPP + +#include + +namespace VULKAN_HPP_NAMESPACE +{ + //===================== + //=== Format Traits === + //===================== + + //=== Function Declarations === + + // The three-dimensional extent of a texel block. + VULKAN_HPP_CONSTEXPR_14 std::array blockExtent( Format format ); + + // The texel block size in bytes. + VULKAN_HPP_CONSTEXPR_14 uint8_t blockSize( Format format ); + + // The class of the format (can't be just named "class"!) + VULKAN_HPP_CONSTEXPR_14 char const * compatibilityClass( Format format ); + + // The number of bits in this component, if not compressed, otherwise 0. + VULKAN_HPP_CONSTEXPR_14 uint8_t componentBits( Format format, uint8_t component ); + + // The number of components of this format. + VULKAN_HPP_CONSTEXPR_14 uint8_t componentCount( Format format ); + + // The name of the component + VULKAN_HPP_CONSTEXPR_14 char const * componentName( Format format, uint8_t component ); + + // The numeric format of the component + VULKAN_HPP_CONSTEXPR_14 char const * componentNumericFormat( Format format, uint8_t component ); + + // The plane this component lies in. + VULKAN_HPP_CONSTEXPR_14 uint8_t componentPlaneIndex( Format format, uint8_t component ); + + // True, if the components of this format are compressed, otherwise false. + VULKAN_HPP_CONSTEXPR_14 bool componentsAreCompressed( Format format ); + + // A textual description of the compression scheme, or an empty string if it is not compressed + VULKAN_HPP_CONSTEXPR_14 char const * compressionScheme( Format format ); + + // Get all formats + std::vector const & getAllFormats(); + + // Get all color with a color component + std::vector const & getColorFormats(); + + // Get all formats with a depth component + std::vector const & getDepthFormats(); + + // Get all formats with a depth and a stencil component + std::vector const & getDepthStencilFormats(); + + // Get all formats with a stencil component + std::vector const & getStencilFormats(); + + // True, if this format has an alpha component + VULKAN_HPP_CONSTEXPR_14 bool hasAlphaComponent( Format format ); + + // True, if this format has a blue component + VULKAN_HPP_CONSTEXPR_14 bool hasBlueComponent( Format format ); + + // True, if this format has a depth component + VULKAN_HPP_CONSTEXPR_14 bool hasDepthComponent( Format format ); + + // True, if this format has a green component + VULKAN_HPP_CONSTEXPR_14 bool hasGreenComponent( Format format ); + + // True, if this format has a red component + VULKAN_HPP_CONSTEXPR_14 bool hasRedComponent( Format format ); + + // True, if this format has a stencil component + VULKAN_HPP_CONSTEXPR_14 bool hasStencilComponent( Format format ); + + // True, if the format is a color + VULKAN_HPP_CONSTEXPR_14 bool isColor( Format format ); + + // True, if this format is a compressed one. + VULKAN_HPP_CONSTEXPR_14 bool isCompressed( Format format ); + + // The number of bits into which the format is packed. A single image element in this format can be stored in the same space as a scalar type of this bit + // width. + VULKAN_HPP_CONSTEXPR_14 uint8_t packed( Format format ); + + // The single-plane format that this plane is compatible with. + VULKAN_HPP_CONSTEXPR_14 Format planeCompatibleFormat( Format format, uint8_t plane ); + + // The number of image planes of this format. + VULKAN_HPP_CONSTEXPR_14 uint8_t planeCount( Format format ); + + // The relative height of this plane. A value of k means that this plane is 1/k the height of the overall format. + VULKAN_HPP_CONSTEXPR_14 uint8_t planeHeightDivisor( Format format, uint8_t plane ); + + // The relative width of this plane. A value of k means that this plane is 1/k the width of the overall format. + VULKAN_HPP_CONSTEXPR_14 uint8_t planeWidthDivisor( Format format, uint8_t plane ); + + // The number of texels in a texel block. + VULKAN_HPP_CONSTEXPR_14 uint8_t texelsPerBlock( Format format ); + + //=== Function Definitions === + + // The three-dimensional extent of a texel block. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 std::array blockExtent( Format format ) + { + switch ( format ) + { + case Format::eBc1RgbUnormBlock : return { { 4, 4, 1 } }; + case Format::eBc1RgbSrgbBlock : return { { 4, 4, 1 } }; + case Format::eBc1RgbaUnormBlock : return { { 4, 4, 1 } }; + case Format::eBc1RgbaSrgbBlock : return { { 4, 4, 1 } }; + case Format::eBc2UnormBlock : return { { 4, 4, 1 } }; + case Format::eBc2SrgbBlock : return { { 4, 4, 1 } }; + case Format::eBc3UnormBlock : return { { 4, 4, 1 } }; + case Format::eBc3SrgbBlock : return { { 4, 4, 1 } }; + case Format::eBc4UnormBlock : return { { 4, 4, 1 } }; + case Format::eBc4SnormBlock : return { { 4, 4, 1 } }; + case Format::eBc5UnormBlock : return { { 4, 4, 1 } }; + case Format::eBc5SnormBlock : return { { 4, 4, 1 } }; + case Format::eBc6HUfloatBlock : return { { 4, 4, 1 } }; + case Format::eBc6HSfloatBlock : return { { 4, 4, 1 } }; + case Format::eBc7UnormBlock : return { { 4, 4, 1 } }; + case Format::eBc7SrgbBlock : return { { 4, 4, 1 } }; + case Format::eEtc2R8G8B8UnormBlock : return { { 4, 4, 1 } }; + case Format::eEtc2R8G8B8SrgbBlock : return { { 4, 4, 1 } }; + case Format::eEtc2R8G8B8A1UnormBlock : return { { 4, 4, 1 } }; + case Format::eEtc2R8G8B8A1SrgbBlock : return { { 4, 4, 1 } }; + case Format::eEtc2R8G8B8A8UnormBlock : return { { 4, 4, 1 } }; + case Format::eEtc2R8G8B8A8SrgbBlock : return { { 4, 4, 1 } }; + case Format::eEacR11UnormBlock : return { { 4, 4, 1 } }; + case Format::eEacR11SnormBlock : return { { 4, 4, 1 } }; + case Format::eEacR11G11UnormBlock : return { { 4, 4, 1 } }; + case Format::eEacR11G11SnormBlock : return { { 4, 4, 1 } }; + case Format::eAstc4x4UnormBlock : return { { 4, 4, 1 } }; + case Format::eAstc4x4SrgbBlock : return { { 4, 4, 1 } }; + case Format::eAstc5x4UnormBlock : return { { 5, 4, 1 } }; + case Format::eAstc5x4SrgbBlock : return { { 5, 4, 1 } }; + case Format::eAstc5x5UnormBlock : return { { 5, 5, 1 } }; + case Format::eAstc5x5SrgbBlock : return { { 5, 5, 1 } }; + case Format::eAstc6x5UnormBlock : return { { 6, 5, 1 } }; + case Format::eAstc6x5SrgbBlock : return { { 6, 5, 1 } }; + case Format::eAstc6x6UnormBlock : return { { 6, 6, 1 } }; + case Format::eAstc6x6SrgbBlock : return { { 6, 6, 1 } }; + case Format::eAstc8x5UnormBlock : return { { 8, 5, 1 } }; + case Format::eAstc8x5SrgbBlock : return { { 8, 5, 1 } }; + case Format::eAstc8x6UnormBlock : return { { 8, 6, 1 } }; + case Format::eAstc8x6SrgbBlock : return { { 8, 6, 1 } }; + case Format::eAstc8x8UnormBlock : return { { 8, 8, 1 } }; + case Format::eAstc8x8SrgbBlock : return { { 8, 8, 1 } }; + case Format::eAstc10x5UnormBlock : return { { 10, 5, 1 } }; + case Format::eAstc10x5SrgbBlock : return { { 10, 5, 1 } }; + case Format::eAstc10x6UnormBlock : return { { 10, 6, 1 } }; + case Format::eAstc10x6SrgbBlock : return { { 10, 6, 1 } }; + case Format::eAstc10x8UnormBlock : return { { 10, 8, 1 } }; + case Format::eAstc10x8SrgbBlock : return { { 10, 8, 1 } }; + case Format::eAstc10x10UnormBlock : return { { 10, 10, 1 } }; + case Format::eAstc10x10SrgbBlock : return { { 10, 10, 1 } }; + case Format::eAstc12x10UnormBlock : return { { 12, 10, 1 } }; + case Format::eAstc12x10SrgbBlock : return { { 12, 10, 1 } }; + case Format::eAstc12x12UnormBlock : return { { 12, 12, 1 } }; + case Format::eAstc12x12SrgbBlock : return { { 12, 12, 1 } }; + case Format::eG8B8G8R8422Unorm : return { { 2, 1, 1 } }; + case Format::eB8G8R8G8422Unorm : return { { 2, 1, 1 } }; + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: return { { 2, 1, 1 } }; + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: return { { 2, 1, 1 } }; + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: return { { 2, 1, 1 } }; + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: return { { 2, 1, 1 } }; + case Format::eG16B16G16R16422Unorm : return { { 2, 1, 1 } }; + case Format::eB16G16R16G16422Unorm : return { { 2, 1, 1 } }; + case Format::eAstc4x4SfloatBlock : return { { 4, 4, 1 } }; + case Format::eAstc5x4SfloatBlock : return { { 5, 4, 1 } }; + case Format::eAstc5x5SfloatBlock : return { { 5, 5, 1 } }; + case Format::eAstc6x5SfloatBlock : return { { 6, 5, 1 } }; + case Format::eAstc6x6SfloatBlock : return { { 6, 6, 1 } }; + case Format::eAstc8x5SfloatBlock : return { { 8, 5, 1 } }; + case Format::eAstc8x6SfloatBlock : return { { 8, 6, 1 } }; + case Format::eAstc8x8SfloatBlock : return { { 8, 8, 1 } }; + case Format::eAstc10x5SfloatBlock : return { { 10, 5, 1 } }; + case Format::eAstc10x6SfloatBlock : return { { 10, 6, 1 } }; + case Format::eAstc10x8SfloatBlock : return { { 10, 8, 1 } }; + case Format::eAstc10x10SfloatBlock : return { { 10, 10, 1 } }; + case Format::eAstc12x10SfloatBlock : return { { 12, 10, 1 } }; + case Format::eAstc12x12SfloatBlock : return { { 12, 12, 1 } }; + case Format::ePvrtc12BppUnormBlockIMG : return { { 8, 4, 1 } }; + case Format::ePvrtc14BppUnormBlockIMG : return { { 4, 4, 1 } }; + case Format::ePvrtc22BppUnormBlockIMG : return { { 8, 4, 1 } }; + case Format::ePvrtc24BppUnormBlockIMG : return { { 4, 4, 1 } }; + case Format::ePvrtc12BppSrgbBlockIMG : return { { 8, 4, 1 } }; + case Format::ePvrtc14BppSrgbBlockIMG : return { { 4, 4, 1 } }; + case Format::ePvrtc22BppSrgbBlockIMG : return { { 8, 4, 1 } }; + case Format::ePvrtc24BppSrgbBlockIMG : return { { 4, 4, 1 } }; + case Format::eAstc3x3x3UnormBlockEXT : return { { 3, 3, 3 } }; + case Format::eAstc3x3x3SrgbBlockEXT : return { { 3, 3, 3 } }; + case Format::eAstc3x3x3SfloatBlockEXT : return { { 3, 3, 3 } }; + case Format::eAstc4x3x3UnormBlockEXT : return { { 4, 3, 3 } }; + case Format::eAstc4x3x3SrgbBlockEXT : return { { 4, 3, 3 } }; + case Format::eAstc4x3x3SfloatBlockEXT : return { { 4, 3, 3 } }; + case Format::eAstc4x4x3UnormBlockEXT : return { { 4, 4, 3 } }; + case Format::eAstc4x4x3SrgbBlockEXT : return { { 4, 4, 3 } }; + case Format::eAstc4x4x3SfloatBlockEXT : return { { 4, 4, 3 } }; + case Format::eAstc4x4x4UnormBlockEXT : return { { 4, 4, 4 } }; + case Format::eAstc4x4x4SrgbBlockEXT : return { { 4, 4, 4 } }; + case Format::eAstc4x4x4SfloatBlockEXT : return { { 4, 4, 4 } }; + case Format::eAstc5x4x4UnormBlockEXT : return { { 5, 4, 4 } }; + case Format::eAstc5x4x4SrgbBlockEXT : return { { 5, 4, 4 } }; + case Format::eAstc5x4x4SfloatBlockEXT : return { { 5, 4, 4 } }; + case Format::eAstc5x5x4UnormBlockEXT : return { { 5, 5, 4 } }; + case Format::eAstc5x5x4SrgbBlockEXT : return { { 5, 5, 4 } }; + case Format::eAstc5x5x4SfloatBlockEXT : return { { 5, 5, 4 } }; + case Format::eAstc5x5x5UnormBlockEXT : return { { 5, 5, 5 } }; + case Format::eAstc5x5x5SrgbBlockEXT : return { { 5, 5, 5 } }; + case Format::eAstc5x5x5SfloatBlockEXT : return { { 5, 5, 5 } }; + case Format::eAstc6x5x5UnormBlockEXT : return { { 6, 5, 5 } }; + case Format::eAstc6x5x5SrgbBlockEXT : return { { 6, 5, 5 } }; + case Format::eAstc6x5x5SfloatBlockEXT : return { { 6, 5, 5 } }; + case Format::eAstc6x6x5UnormBlockEXT : return { { 6, 6, 5 } }; + case Format::eAstc6x6x5SrgbBlockEXT : return { { 6, 6, 5 } }; + case Format::eAstc6x6x5SfloatBlockEXT : return { { 6, 6, 5 } }; + case Format::eAstc6x6x6UnormBlockEXT : return { { 6, 6, 6 } }; + case Format::eAstc6x6x6SrgbBlockEXT : return { { 6, 6, 6 } }; + case Format::eAstc6x6x6SfloatBlockEXT : return { { 6, 6, 6 } }; + + default: return { { 1, 1, 1 } }; + } + } + + // The texel block size in bytes. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t blockSize( Format format ) + { + switch ( format ) + { + case Format::eR4G4UnormPack8 : return 1; + case Format::eR4G4B4A4UnormPack16 : return 2; + case Format::eB4G4R4A4UnormPack16 : return 2; + case Format::eR5G6B5UnormPack16 : return 2; + case Format::eB5G6R5UnormPack16 : return 2; + case Format::eR5G5B5A1UnormPack16 : return 2; + case Format::eB5G5R5A1UnormPack16 : return 2; + case Format::eA1R5G5B5UnormPack16 : return 2; + case Format::eR8Unorm : return 1; + case Format::eR8Snorm : return 1; + case Format::eR8Uscaled : return 1; + case Format::eR8Sscaled : return 1; + case Format::eR8Uint : return 1; + case Format::eR8Sint : return 1; + case Format::eR8Srgb : return 1; + case Format::eR8G8Unorm : return 2; + case Format::eR8G8Snorm : return 2; + case Format::eR8G8Uscaled : return 2; + case Format::eR8G8Sscaled : return 2; + case Format::eR8G8Uint : return 2; + case Format::eR8G8Sint : return 2; + case Format::eR8G8Srgb : return 2; + case Format::eR8G8B8Unorm : return 3; + case Format::eR8G8B8Snorm : return 3; + case Format::eR8G8B8Uscaled : return 3; + case Format::eR8G8B8Sscaled : return 3; + case Format::eR8G8B8Uint : return 3; + case Format::eR8G8B8Sint : return 3; + case Format::eR8G8B8Srgb : return 3; + case Format::eB8G8R8Unorm : return 3; + case Format::eB8G8R8Snorm : return 3; + case Format::eB8G8R8Uscaled : return 3; + case Format::eB8G8R8Sscaled : return 3; + case Format::eB8G8R8Uint : return 3; + case Format::eB8G8R8Sint : return 3; + case Format::eB8G8R8Srgb : return 3; + case Format::eR8G8B8A8Unorm : return 4; + case Format::eR8G8B8A8Snorm : return 4; + case Format::eR8G8B8A8Uscaled : return 4; + case Format::eR8G8B8A8Sscaled : return 4; + case Format::eR8G8B8A8Uint : return 4; + case Format::eR8G8B8A8Sint : return 4; + case Format::eR8G8B8A8Srgb : return 4; + case Format::eB8G8R8A8Unorm : return 4; + case Format::eB8G8R8A8Snorm : return 4; + case Format::eB8G8R8A8Uscaled : return 4; + case Format::eB8G8R8A8Sscaled : return 4; + case Format::eB8G8R8A8Uint : return 4; + case Format::eB8G8R8A8Sint : return 4; + case Format::eB8G8R8A8Srgb : return 4; + case Format::eA8B8G8R8UnormPack32 : return 4; + case Format::eA8B8G8R8SnormPack32 : return 4; + case Format::eA8B8G8R8UscaledPack32 : return 4; + case Format::eA8B8G8R8SscaledPack32 : return 4; + case Format::eA8B8G8R8UintPack32 : return 4; + case Format::eA8B8G8R8SintPack32 : return 4; + case Format::eA8B8G8R8SrgbPack32 : return 4; + case Format::eA2R10G10B10UnormPack32 : return 4; + case Format::eA2R10G10B10SnormPack32 : return 4; + case Format::eA2R10G10B10UscaledPack32 : return 4; + case Format::eA2R10G10B10SscaledPack32 : return 4; + case Format::eA2R10G10B10UintPack32 : return 4; + case Format::eA2R10G10B10SintPack32 : return 4; + case Format::eA2B10G10R10UnormPack32 : return 4; + case Format::eA2B10G10R10SnormPack32 : return 4; + case Format::eA2B10G10R10UscaledPack32 : return 4; + case Format::eA2B10G10R10SscaledPack32 : return 4; + case Format::eA2B10G10R10UintPack32 : return 4; + case Format::eA2B10G10R10SintPack32 : return 4; + case Format::eR16Unorm : return 2; + case Format::eR16Snorm : return 2; + case Format::eR16Uscaled : return 2; + case Format::eR16Sscaled : return 2; + case Format::eR16Uint : return 2; + case Format::eR16Sint : return 2; + case Format::eR16Sfloat : return 2; + case Format::eR16G16Unorm : return 4; + case Format::eR16G16Snorm : return 4; + case Format::eR16G16Uscaled : return 4; + case Format::eR16G16Sscaled : return 4; + case Format::eR16G16Uint : return 4; + case Format::eR16G16Sint : return 4; + case Format::eR16G16Sfloat : return 4; + case Format::eR16G16B16Unorm : return 6; + case Format::eR16G16B16Snorm : return 6; + case Format::eR16G16B16Uscaled : return 6; + case Format::eR16G16B16Sscaled : return 6; + case Format::eR16G16B16Uint : return 6; + case Format::eR16G16B16Sint : return 6; + case Format::eR16G16B16Sfloat : return 6; + case Format::eR16G16B16A16Unorm : return 8; + case Format::eR16G16B16A16Snorm : return 8; + case Format::eR16G16B16A16Uscaled : return 8; + case Format::eR16G16B16A16Sscaled : return 8; + case Format::eR16G16B16A16Uint : return 8; + case Format::eR16G16B16A16Sint : return 8; + case Format::eR16G16B16A16Sfloat : return 8; + case Format::eR32Uint : return 4; + case Format::eR32Sint : return 4; + case Format::eR32Sfloat : return 4; + case Format::eR32G32Uint : return 8; + case Format::eR32G32Sint : return 8; + case Format::eR32G32Sfloat : return 8; + case Format::eR32G32B32Uint : return 12; + case Format::eR32G32B32Sint : return 12; + case Format::eR32G32B32Sfloat : return 12; + case Format::eR32G32B32A32Uint : return 16; + case Format::eR32G32B32A32Sint : return 16; + case Format::eR32G32B32A32Sfloat : return 16; + case Format::eR64Uint : return 8; + case Format::eR64Sint : return 8; + case Format::eR64Sfloat : return 8; + case Format::eR64G64Uint : return 16; + case Format::eR64G64Sint : return 16; + case Format::eR64G64Sfloat : return 16; + case Format::eR64G64B64Uint : return 24; + case Format::eR64G64B64Sint : return 24; + case Format::eR64G64B64Sfloat : return 24; + case Format::eR64G64B64A64Uint : return 32; + case Format::eR64G64B64A64Sint : return 32; + case Format::eR64G64B64A64Sfloat : return 32; + case Format::eB10G11R11UfloatPack32 : return 4; + case Format::eE5B9G9R9UfloatPack32 : return 4; + case Format::eD16Unorm : return 2; + case Format::eX8D24UnormPack32 : return 4; + case Format::eD32Sfloat : return 4; + case Format::eS8Uint : return 1; + case Format::eD16UnormS8Uint : return 3; + case Format::eD24UnormS8Uint : return 4; + case Format::eD32SfloatS8Uint : return 5; + case Format::eBc1RgbUnormBlock : return 8; + case Format::eBc1RgbSrgbBlock : return 8; + case Format::eBc1RgbaUnormBlock : return 8; + case Format::eBc1RgbaSrgbBlock : return 8; + case Format::eBc2UnormBlock : return 16; + case Format::eBc2SrgbBlock : return 16; + case Format::eBc3UnormBlock : return 16; + case Format::eBc3SrgbBlock : return 16; + case Format::eBc4UnormBlock : return 8; + case Format::eBc4SnormBlock : return 8; + case Format::eBc5UnormBlock : return 16; + case Format::eBc5SnormBlock : return 16; + case Format::eBc6HUfloatBlock : return 16; + case Format::eBc6HSfloatBlock : return 16; + case Format::eBc7UnormBlock : return 16; + case Format::eBc7SrgbBlock : return 16; + case Format::eEtc2R8G8B8UnormBlock : return 8; + case Format::eEtc2R8G8B8SrgbBlock : return 8; + case Format::eEtc2R8G8B8A1UnormBlock : return 8; + case Format::eEtc2R8G8B8A1SrgbBlock : return 8; + case Format::eEtc2R8G8B8A8UnormBlock : return 16; + case Format::eEtc2R8G8B8A8SrgbBlock : return 16; + case Format::eEacR11UnormBlock : return 8; + case Format::eEacR11SnormBlock : return 8; + case Format::eEacR11G11UnormBlock : return 16; + case Format::eEacR11G11SnormBlock : return 16; + case Format::eAstc4x4UnormBlock : return 16; + case Format::eAstc4x4SrgbBlock : return 16; + case Format::eAstc5x4UnormBlock : return 16; + case Format::eAstc5x4SrgbBlock : return 16; + case Format::eAstc5x5UnormBlock : return 16; + case Format::eAstc5x5SrgbBlock : return 16; + case Format::eAstc6x5UnormBlock : return 16; + case Format::eAstc6x5SrgbBlock : return 16; + case Format::eAstc6x6UnormBlock : return 16; + case Format::eAstc6x6SrgbBlock : return 16; + case Format::eAstc8x5UnormBlock : return 16; + case Format::eAstc8x5SrgbBlock : return 16; + case Format::eAstc8x6UnormBlock : return 16; + case Format::eAstc8x6SrgbBlock : return 16; + case Format::eAstc8x8UnormBlock : return 16; + case Format::eAstc8x8SrgbBlock : return 16; + case Format::eAstc10x5UnormBlock : return 16; + case Format::eAstc10x5SrgbBlock : return 16; + case Format::eAstc10x6UnormBlock : return 16; + case Format::eAstc10x6SrgbBlock : return 16; + case Format::eAstc10x8UnormBlock : return 16; + case Format::eAstc10x8SrgbBlock : return 16; + case Format::eAstc10x10UnormBlock : return 16; + case Format::eAstc10x10SrgbBlock : return 16; + case Format::eAstc12x10UnormBlock : return 16; + case Format::eAstc12x10SrgbBlock : return 16; + case Format::eAstc12x12UnormBlock : return 16; + case Format::eAstc12x12SrgbBlock : return 16; + case Format::eG8B8G8R8422Unorm : return 4; + case Format::eB8G8R8G8422Unorm : return 4; + case Format::eG8B8R83Plane420Unorm : return 3; + case Format::eG8B8R82Plane420Unorm : return 3; + case Format::eG8B8R83Plane422Unorm : return 3; + case Format::eG8B8R82Plane422Unorm : return 3; + case Format::eG8B8R83Plane444Unorm : return 3; + case Format::eR10X6UnormPack16 : return 2; + case Format::eR10X6G10X6Unorm2Pack16 : return 4; + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return 8; + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return 8; + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return 8; + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return 6; + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return 6; + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return 6; + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return 6; + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return 6; + case Format::eR12X4UnormPack16 : return 2; + case Format::eR12X4G12X4Unorm2Pack16 : return 4; + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return 8; + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return 8; + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return 8; + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return 6; + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return 6; + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return 6; + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return 6; + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return 6; + case Format::eG16B16G16R16422Unorm : return 8; + case Format::eB16G16R16G16422Unorm : return 8; + case Format::eG16B16R163Plane420Unorm : return 6; + case Format::eG16B16R162Plane420Unorm : return 6; + case Format::eG16B16R163Plane422Unorm : return 6; + case Format::eG16B16R162Plane422Unorm : return 6; + case Format::eG16B16R163Plane444Unorm : return 6; + case Format::eG8B8R82Plane444Unorm : return 3; + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return 6; + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return 6; + case Format::eG16B16R162Plane444Unorm : return 6; + case Format::eA4R4G4B4UnormPack16 : return 2; + case Format::eA4B4G4R4UnormPack16 : return 2; + case Format::eAstc4x4SfloatBlock : return 16; + case Format::eAstc5x4SfloatBlock : return 16; + case Format::eAstc5x5SfloatBlock : return 16; + case Format::eAstc6x5SfloatBlock : return 16; + case Format::eAstc6x6SfloatBlock : return 16; + case Format::eAstc8x5SfloatBlock : return 16; + case Format::eAstc8x6SfloatBlock : return 16; + case Format::eAstc8x8SfloatBlock : return 16; + case Format::eAstc10x5SfloatBlock : return 16; + case Format::eAstc10x6SfloatBlock : return 16; + case Format::eAstc10x8SfloatBlock : return 16; + case Format::eAstc10x10SfloatBlock : return 16; + case Format::eAstc12x10SfloatBlock : return 16; + case Format::eAstc12x12SfloatBlock : return 16; + case Format::eA1B5G5R5UnormPack16 : return 2; + case Format::eA8Unorm : return 1; + case Format::ePvrtc12BppUnormBlockIMG : return 8; + case Format::ePvrtc14BppUnormBlockIMG : return 8; + case Format::ePvrtc22BppUnormBlockIMG : return 8; + case Format::ePvrtc24BppUnormBlockIMG : return 8; + case Format::ePvrtc12BppSrgbBlockIMG : return 8; + case Format::ePvrtc14BppSrgbBlockIMG : return 8; + case Format::ePvrtc22BppSrgbBlockIMG : return 8; + case Format::ePvrtc24BppSrgbBlockIMG : return 8; + case Format::eAstc3x3x3UnormBlockEXT : return 16; + case Format::eAstc3x3x3SrgbBlockEXT : return 16; + case Format::eAstc3x3x3SfloatBlockEXT : return 16; + case Format::eAstc4x3x3UnormBlockEXT : return 16; + case Format::eAstc4x3x3SrgbBlockEXT : return 16; + case Format::eAstc4x3x3SfloatBlockEXT : return 16; + case Format::eAstc4x4x3UnormBlockEXT : return 16; + case Format::eAstc4x4x3SrgbBlockEXT : return 16; + case Format::eAstc4x4x3SfloatBlockEXT : return 16; + case Format::eAstc4x4x4UnormBlockEXT : return 16; + case Format::eAstc4x4x4SrgbBlockEXT : return 16; + case Format::eAstc4x4x4SfloatBlockEXT : return 16; + case Format::eAstc5x4x4UnormBlockEXT : return 16; + case Format::eAstc5x4x4SrgbBlockEXT : return 16; + case Format::eAstc5x4x4SfloatBlockEXT : return 16; + case Format::eAstc5x5x4UnormBlockEXT : return 16; + case Format::eAstc5x5x4SrgbBlockEXT : return 16; + case Format::eAstc5x5x4SfloatBlockEXT : return 16; + case Format::eAstc5x5x5UnormBlockEXT : return 16; + case Format::eAstc5x5x5SrgbBlockEXT : return 16; + case Format::eAstc5x5x5SfloatBlockEXT : return 16; + case Format::eAstc6x5x5UnormBlockEXT : return 16; + case Format::eAstc6x5x5SrgbBlockEXT : return 16; + case Format::eAstc6x5x5SfloatBlockEXT : return 16; + case Format::eAstc6x6x5UnormBlockEXT : return 16; + case Format::eAstc6x6x5SrgbBlockEXT : return 16; + case Format::eAstc6x6x5SfloatBlockEXT : return 16; + case Format::eAstc6x6x6UnormBlockEXT : return 16; + case Format::eAstc6x6x6SrgbBlockEXT : return 16; + case Format::eAstc6x6x6SfloatBlockEXT : return 16; + case Format::eR8BoolARM : return 1; + case Format::eR16G16Sfixed5NV : return 4; + case Format::eR10X6UintPack16ARM : return 2; + case Format::eR10X6G10X6Uint2Pack16ARM : return 4; + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return 8; + case Format::eR12X4UintPack16ARM : return 2; + case Format::eR12X4G12X4Uint2Pack16ARM : return 4; + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return 8; + case Format::eR14X2UintPack16ARM : return 2; + case Format::eR14X2G14X2Uint2Pack16ARM : return 4; + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return 8; + case Format::eR14X2UnormPack16ARM : return 2; + case Format::eR14X2G14X2Unorm2Pack16ARM : return 4; + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return 8; + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return 6; + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return 6; + + default: VULKAN_HPP_ASSERT( false ); return 0; + } + } + + // The class of the format (can't be just named "class"!) + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 char const * compatibilityClass( Format format ) + { + switch ( format ) + { + case Format::eR4G4UnormPack8 : return "8-bit"; + case Format::eR4G4B4A4UnormPack16 : return "16-bit"; + case Format::eB4G4R4A4UnormPack16 : return "16-bit"; + case Format::eR5G6B5UnormPack16 : return "16-bit"; + case Format::eB5G6R5UnormPack16 : return "16-bit"; + case Format::eR5G5B5A1UnormPack16 : return "16-bit"; + case Format::eB5G5R5A1UnormPack16 : return "16-bit"; + case Format::eA1R5G5B5UnormPack16 : return "16-bit"; + case Format::eR8Unorm : return "8-bit"; + case Format::eR8Snorm : return "8-bit"; + case Format::eR8Uscaled : return "8-bit"; + case Format::eR8Sscaled : return "8-bit"; + case Format::eR8Uint : return "8-bit"; + case Format::eR8Sint : return "8-bit"; + case Format::eR8Srgb : return "8-bit"; + case Format::eR8G8Unorm : return "16-bit"; + case Format::eR8G8Snorm : return "16-bit"; + case Format::eR8G8Uscaled : return "16-bit"; + case Format::eR8G8Sscaled : return "16-bit"; + case Format::eR8G8Uint : return "16-bit"; + case Format::eR8G8Sint : return "16-bit"; + case Format::eR8G8Srgb : return "16-bit"; + case Format::eR8G8B8Unorm : return "24-bit"; + case Format::eR8G8B8Snorm : return "24-bit"; + case Format::eR8G8B8Uscaled : return "24-bit"; + case Format::eR8G8B8Sscaled : return "24-bit"; + case Format::eR8G8B8Uint : return "24-bit"; + case Format::eR8G8B8Sint : return "24-bit"; + case Format::eR8G8B8Srgb : return "24-bit"; + case Format::eB8G8R8Unorm : return "24-bit"; + case Format::eB8G8R8Snorm : return "24-bit"; + case Format::eB8G8R8Uscaled : return "24-bit"; + case Format::eB8G8R8Sscaled : return "24-bit"; + case Format::eB8G8R8Uint : return "24-bit"; + case Format::eB8G8R8Sint : return "24-bit"; + case Format::eB8G8R8Srgb : return "24-bit"; + case Format::eR8G8B8A8Unorm : return "32-bit"; + case Format::eR8G8B8A8Snorm : return "32-bit"; + case Format::eR8G8B8A8Uscaled : return "32-bit"; + case Format::eR8G8B8A8Sscaled : return "32-bit"; + case Format::eR8G8B8A8Uint : return "32-bit"; + case Format::eR8G8B8A8Sint : return "32-bit"; + case Format::eR8G8B8A8Srgb : return "32-bit"; + case Format::eB8G8R8A8Unorm : return "32-bit"; + case Format::eB8G8R8A8Snorm : return "32-bit"; + case Format::eB8G8R8A8Uscaled : return "32-bit"; + case Format::eB8G8R8A8Sscaled : return "32-bit"; + case Format::eB8G8R8A8Uint : return "32-bit"; + case Format::eB8G8R8A8Sint : return "32-bit"; + case Format::eB8G8R8A8Srgb : return "32-bit"; + case Format::eA8B8G8R8UnormPack32 : return "32-bit"; + case Format::eA8B8G8R8SnormPack32 : return "32-bit"; + case Format::eA8B8G8R8UscaledPack32 : return "32-bit"; + case Format::eA8B8G8R8SscaledPack32 : return "32-bit"; + case Format::eA8B8G8R8UintPack32 : return "32-bit"; + case Format::eA8B8G8R8SintPack32 : return "32-bit"; + case Format::eA8B8G8R8SrgbPack32 : return "32-bit"; + case Format::eA2R10G10B10UnormPack32 : return "32-bit"; + case Format::eA2R10G10B10SnormPack32 : return "32-bit"; + case Format::eA2R10G10B10UscaledPack32 : return "32-bit"; + case Format::eA2R10G10B10SscaledPack32 : return "32-bit"; + case Format::eA2R10G10B10UintPack32 : return "32-bit"; + case Format::eA2R10G10B10SintPack32 : return "32-bit"; + case Format::eA2B10G10R10UnormPack32 : return "32-bit"; + case Format::eA2B10G10R10SnormPack32 : return "32-bit"; + case Format::eA2B10G10R10UscaledPack32 : return "32-bit"; + case Format::eA2B10G10R10SscaledPack32 : return "32-bit"; + case Format::eA2B10G10R10UintPack32 : return "32-bit"; + case Format::eA2B10G10R10SintPack32 : return "32-bit"; + case Format::eR16Unorm : return "16-bit"; + case Format::eR16Snorm : return "16-bit"; + case Format::eR16Uscaled : return "16-bit"; + case Format::eR16Sscaled : return "16-bit"; + case Format::eR16Uint : return "16-bit"; + case Format::eR16Sint : return "16-bit"; + case Format::eR16Sfloat : return "16-bit"; + case Format::eR16G16Unorm : return "32-bit"; + case Format::eR16G16Snorm : return "32-bit"; + case Format::eR16G16Uscaled : return "32-bit"; + case Format::eR16G16Sscaled : return "32-bit"; + case Format::eR16G16Uint : return "32-bit"; + case Format::eR16G16Sint : return "32-bit"; + case Format::eR16G16Sfloat : return "32-bit"; + case Format::eR16G16B16Unorm : return "48-bit"; + case Format::eR16G16B16Snorm : return "48-bit"; + case Format::eR16G16B16Uscaled : return "48-bit"; + case Format::eR16G16B16Sscaled : return "48-bit"; + case Format::eR16G16B16Uint : return "48-bit"; + case Format::eR16G16B16Sint : return "48-bit"; + case Format::eR16G16B16Sfloat : return "48-bit"; + case Format::eR16G16B16A16Unorm : return "64-bit"; + case Format::eR16G16B16A16Snorm : return "64-bit"; + case Format::eR16G16B16A16Uscaled : return "64-bit"; + case Format::eR16G16B16A16Sscaled : return "64-bit"; + case Format::eR16G16B16A16Uint : return "64-bit"; + case Format::eR16G16B16A16Sint : return "64-bit"; + case Format::eR16G16B16A16Sfloat : return "64-bit"; + case Format::eR32Uint : return "32-bit"; + case Format::eR32Sint : return "32-bit"; + case Format::eR32Sfloat : return "32-bit"; + case Format::eR32G32Uint : return "64-bit"; + case Format::eR32G32Sint : return "64-bit"; + case Format::eR32G32Sfloat : return "64-bit"; + case Format::eR32G32B32Uint : return "96-bit"; + case Format::eR32G32B32Sint : return "96-bit"; + case Format::eR32G32B32Sfloat : return "96-bit"; + case Format::eR32G32B32A32Uint : return "128-bit"; + case Format::eR32G32B32A32Sint : return "128-bit"; + case Format::eR32G32B32A32Sfloat : return "128-bit"; + case Format::eR64Uint : return "64-bit"; + case Format::eR64Sint : return "64-bit"; + case Format::eR64Sfloat : return "64-bit"; + case Format::eR64G64Uint : return "128-bit"; + case Format::eR64G64Sint : return "128-bit"; + case Format::eR64G64Sfloat : return "128-bit"; + case Format::eR64G64B64Uint : return "192-bit"; + case Format::eR64G64B64Sint : return "192-bit"; + case Format::eR64G64B64Sfloat : return "192-bit"; + case Format::eR64G64B64A64Uint : return "256-bit"; + case Format::eR64G64B64A64Sint : return "256-bit"; + case Format::eR64G64B64A64Sfloat : return "256-bit"; + case Format::eB10G11R11UfloatPack32 : return "32-bit"; + case Format::eE5B9G9R9UfloatPack32 : return "32-bit"; + case Format::eD16Unorm : return "D16"; + case Format::eX8D24UnormPack32 : return "D24"; + case Format::eD32Sfloat : return "D32"; + case Format::eS8Uint : return "S8"; + case Format::eD16UnormS8Uint : return "D16S8"; + case Format::eD24UnormS8Uint : return "D24S8"; + case Format::eD32SfloatS8Uint : return "D32S8"; + case Format::eBc1RgbUnormBlock : return "BC1_RGB"; + case Format::eBc1RgbSrgbBlock : return "BC1_RGB"; + case Format::eBc1RgbaUnormBlock : return "BC1_RGBA"; + case Format::eBc1RgbaSrgbBlock : return "BC1_RGBA"; + case Format::eBc2UnormBlock : return "BC2"; + case Format::eBc2SrgbBlock : return "BC2"; + case Format::eBc3UnormBlock : return "BC3"; + case Format::eBc3SrgbBlock : return "BC3"; + case Format::eBc4UnormBlock : return "BC4"; + case Format::eBc4SnormBlock : return "BC4"; + case Format::eBc5UnormBlock : return "BC5"; + case Format::eBc5SnormBlock : return "BC5"; + case Format::eBc6HUfloatBlock : return "BC6H"; + case Format::eBc6HSfloatBlock : return "BC6H"; + case Format::eBc7UnormBlock : return "BC7"; + case Format::eBc7SrgbBlock : return "BC7"; + case Format::eEtc2R8G8B8UnormBlock : return "ETC2_RGB"; + case Format::eEtc2R8G8B8SrgbBlock : return "ETC2_RGB"; + case Format::eEtc2R8G8B8A1UnormBlock : return "ETC2_RGBA"; + case Format::eEtc2R8G8B8A1SrgbBlock : return "ETC2_RGBA"; + case Format::eEtc2R8G8B8A8UnormBlock : return "ETC2_EAC_RGBA"; + case Format::eEtc2R8G8B8A8SrgbBlock : return "ETC2_EAC_RGBA"; + case Format::eEacR11UnormBlock : return "EAC_R"; + case Format::eEacR11SnormBlock : return "EAC_R"; + case Format::eEacR11G11UnormBlock : return "EAC_RG"; + case Format::eEacR11G11SnormBlock : return "EAC_RG"; + case Format::eAstc4x4UnormBlock : return "ASTC_4x4"; + case Format::eAstc4x4SrgbBlock : return "ASTC_4x4"; + case Format::eAstc5x4UnormBlock : return "ASTC_5x4"; + case Format::eAstc5x4SrgbBlock : return "ASTC_5x4"; + case Format::eAstc5x5UnormBlock : return "ASTC_5x5"; + case Format::eAstc5x5SrgbBlock : return "ASTC_5x5"; + case Format::eAstc6x5UnormBlock : return "ASTC_6x5"; + case Format::eAstc6x5SrgbBlock : return "ASTC_6x5"; + case Format::eAstc6x6UnormBlock : return "ASTC_6x6"; + case Format::eAstc6x6SrgbBlock : return "ASTC_6x6"; + case Format::eAstc8x5UnormBlock : return "ASTC_8x5"; + case Format::eAstc8x5SrgbBlock : return "ASTC_8x5"; + case Format::eAstc8x6UnormBlock : return "ASTC_8x6"; + case Format::eAstc8x6SrgbBlock : return "ASTC_8x6"; + case Format::eAstc8x8UnormBlock : return "ASTC_8x8"; + case Format::eAstc8x8SrgbBlock : return "ASTC_8x8"; + case Format::eAstc10x5UnormBlock : return "ASTC_10x5"; + case Format::eAstc10x5SrgbBlock : return "ASTC_10x5"; + case Format::eAstc10x6UnormBlock : return "ASTC_10x6"; + case Format::eAstc10x6SrgbBlock : return "ASTC_10x6"; + case Format::eAstc10x8UnormBlock : return "ASTC_10x8"; + case Format::eAstc10x8SrgbBlock : return "ASTC_10x8"; + case Format::eAstc10x10UnormBlock : return "ASTC_10x10"; + case Format::eAstc10x10SrgbBlock : return "ASTC_10x10"; + case Format::eAstc12x10UnormBlock : return "ASTC_12x10"; + case Format::eAstc12x10SrgbBlock : return "ASTC_12x10"; + case Format::eAstc12x12UnormBlock : return "ASTC_12x12"; + case Format::eAstc12x12SrgbBlock : return "ASTC_12x12"; + case Format::eG8B8G8R8422Unorm : return "32-bit G8B8G8R8"; + case Format::eB8G8R8G8422Unorm : return "32-bit B8G8R8G8"; + case Format::eG8B8R83Plane420Unorm : return "8-bit 3-plane 420"; + case Format::eG8B8R82Plane420Unorm : return "8-bit 2-plane 420"; + case Format::eG8B8R83Plane422Unorm : return "8-bit 3-plane 422"; + case Format::eG8B8R82Plane422Unorm : return "8-bit 2-plane 422"; + case Format::eG8B8R83Plane444Unorm : return "8-bit 3-plane 444"; + case Format::eR10X6UnormPack16 : return "16-bit"; + case Format::eR10X6G10X6Unorm2Pack16 : return "32-bit"; + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return "64-bit R10G10B10A10"; + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return "64-bit G10B10G10R10"; + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return "64-bit B10G10R10G10"; + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return "10-bit 3-plane 420"; + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return "10-bit 2-plane 420"; + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return "10-bit 3-plane 422"; + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return "10-bit 2-plane 422"; + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return "10-bit 3-plane 444"; + case Format::eR12X4UnormPack16 : return "16-bit"; + case Format::eR12X4G12X4Unorm2Pack16 : return "32-bit"; + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return "64-bit R12G12B12A12"; + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return "64-bit G12B12G12R12"; + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return "64-bit B12G12R12G12"; + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return "12-bit 3-plane 420"; + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return "12-bit 2-plane 420"; + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return "12-bit 3-plane 422"; + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return "12-bit 2-plane 422"; + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return "12-bit 3-plane 444"; + case Format::eG16B16G16R16422Unorm : return "64-bit G16B16G16R16"; + case Format::eB16G16R16G16422Unorm : return "64-bit B16G16R16G16"; + case Format::eG16B16R163Plane420Unorm : return "16-bit 3-plane 420"; + case Format::eG16B16R162Plane420Unorm : return "16-bit 2-plane 420"; + case Format::eG16B16R163Plane422Unorm : return "16-bit 3-plane 422"; + case Format::eG16B16R162Plane422Unorm : return "16-bit 2-plane 422"; + case Format::eG16B16R163Plane444Unorm : return "16-bit 3-plane 444"; + case Format::eG8B8R82Plane444Unorm : return "8-bit 2-plane 444"; + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return "10-bit 2-plane 444"; + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return "12-bit 2-plane 444"; + case Format::eG16B16R162Plane444Unorm : return "16-bit 2-plane 444"; + case Format::eA4R4G4B4UnormPack16 : return "16-bit"; + case Format::eA4B4G4R4UnormPack16 : return "16-bit"; + case Format::eAstc4x4SfloatBlock : return "ASTC_4x4"; + case Format::eAstc5x4SfloatBlock : return "ASTC_5x4"; + case Format::eAstc5x5SfloatBlock : return "ASTC_5x5"; + case Format::eAstc6x5SfloatBlock : return "ASTC_6x5"; + case Format::eAstc6x6SfloatBlock : return "ASTC_6x6"; + case Format::eAstc8x5SfloatBlock : return "ASTC_8x5"; + case Format::eAstc8x6SfloatBlock : return "ASTC_8x6"; + case Format::eAstc8x8SfloatBlock : return "ASTC_8x8"; + case Format::eAstc10x5SfloatBlock : return "ASTC_10x5"; + case Format::eAstc10x6SfloatBlock : return "ASTC_10x6"; + case Format::eAstc10x8SfloatBlock : return "ASTC_10x8"; + case Format::eAstc10x10SfloatBlock : return "ASTC_10x10"; + case Format::eAstc12x10SfloatBlock : return "ASTC_12x10"; + case Format::eAstc12x12SfloatBlock : return "ASTC_12x12"; + case Format::eA1B5G5R5UnormPack16 : return "16-bit"; + case Format::eA8Unorm : return "8-bit alpha"; + case Format::ePvrtc12BppUnormBlockIMG : return "PVRTC1_2BPP"; + case Format::ePvrtc14BppUnormBlockIMG : return "PVRTC1_4BPP"; + case Format::ePvrtc22BppUnormBlockIMG : return "PVRTC2_2BPP"; + case Format::ePvrtc24BppUnormBlockIMG : return "PVRTC2_4BPP"; + case Format::ePvrtc12BppSrgbBlockIMG : return "PVRTC1_2BPP"; + case Format::ePvrtc14BppSrgbBlockIMG : return "PVRTC1_4BPP"; + case Format::ePvrtc22BppSrgbBlockIMG : return "PVRTC2_2BPP"; + case Format::ePvrtc24BppSrgbBlockIMG : return "PVRTC2_4BPP"; + case Format::eAstc3x3x3UnormBlockEXT : return "ASTC_3x3x3"; + case Format::eAstc3x3x3SrgbBlockEXT : return "ASTC_3x3x3"; + case Format::eAstc3x3x3SfloatBlockEXT : return "ASTC_3x3x3"; + case Format::eAstc4x3x3UnormBlockEXT : return "ASTC_4x3x3"; + case Format::eAstc4x3x3SrgbBlockEXT : return "ASTC_4x3x3"; + case Format::eAstc4x3x3SfloatBlockEXT : return "ASTC_4x3x3"; + case Format::eAstc4x4x3UnormBlockEXT : return "ASTC_4x4x3"; + case Format::eAstc4x4x3SrgbBlockEXT : return "ASTC_4x4x3"; + case Format::eAstc4x4x3SfloatBlockEXT : return "ASTC_4x4x3"; + case Format::eAstc4x4x4UnormBlockEXT : return "ASTC_4x4x4"; + case Format::eAstc4x4x4SrgbBlockEXT : return "ASTC_4x4x4"; + case Format::eAstc4x4x4SfloatBlockEXT : return "ASTC_4x4x4"; + case Format::eAstc5x4x4UnormBlockEXT : return "ASTC_5x4x4"; + case Format::eAstc5x4x4SrgbBlockEXT : return "ASTC_5x4x4"; + case Format::eAstc5x4x4SfloatBlockEXT : return "ASTC_5x4x4"; + case Format::eAstc5x5x4UnormBlockEXT : return "ASTC_5x5x4"; + case Format::eAstc5x5x4SrgbBlockEXT : return "ASTC_5x5x4"; + case Format::eAstc5x5x4SfloatBlockEXT : return "ASTC_5x5x4"; + case Format::eAstc5x5x5UnormBlockEXT : return "ASTC_5x5x5"; + case Format::eAstc5x5x5SrgbBlockEXT : return "ASTC_5x5x5"; + case Format::eAstc5x5x5SfloatBlockEXT : return "ASTC_5x5x5"; + case Format::eAstc6x5x5UnormBlockEXT : return "ASTC_6x5x5"; + case Format::eAstc6x5x5SrgbBlockEXT : return "ASTC_6x5x5"; + case Format::eAstc6x5x5SfloatBlockEXT : return "ASTC_6x5x5"; + case Format::eAstc6x6x5UnormBlockEXT : return "ASTC_6x6x5"; + case Format::eAstc6x6x5SrgbBlockEXT : return "ASTC_6x6x5"; + case Format::eAstc6x6x5SfloatBlockEXT : return "ASTC_6x6x5"; + case Format::eAstc6x6x6UnormBlockEXT : return "ASTC_6x6x6"; + case Format::eAstc6x6x6SrgbBlockEXT : return "ASTC_6x6x6"; + case Format::eAstc6x6x6SfloatBlockEXT : return "ASTC_6x6x6"; + case Format::eR8BoolARM : return "8-bit"; + case Format::eR16G16Sfixed5NV : return "32-bit"; + case Format::eR10X6UintPack16ARM : return "16-bit"; + case Format::eR10X6G10X6Uint2Pack16ARM : return "32-bit"; + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return "64-bit R10G10B10A10"; + case Format::eR12X4UintPack16ARM : return "16-bit"; + case Format::eR12X4G12X4Uint2Pack16ARM : return "32-bit"; + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return "64-bit R12G12B12A12"; + case Format::eR14X2UintPack16ARM : return "16-bit"; + case Format::eR14X2G14X2Uint2Pack16ARM : return "32-bit"; + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return "64-bit R14G14B14A14"; + case Format::eR14X2UnormPack16ARM : return "16-bit"; + case Format::eR14X2G14X2Unorm2Pack16ARM : return "32-bit"; + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return "64-bit R14G14B14A14"; + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return "14-bit 2-plane 420"; + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return "14-bit 2-plane 422"; + + default: VULKAN_HPP_ASSERT( false ); return ""; + } + } + + // The number of bits in this component, if not compressed, otherwise 0. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t componentBits( Format format, uint8_t component ) + { + switch ( format ) + { + case Format::eR4G4UnormPack8: + switch ( component ) + { + case 0 : return 4; + case 1 : return 4; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR4G4B4A4UnormPack16: + switch ( component ) + { + case 0 : return 4; + case 1 : return 4; + case 2 : return 4; + case 3 : return 4; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB4G4R4A4UnormPack16: + switch ( component ) + { + case 0 : return 4; + case 1 : return 4; + case 2 : return 4; + case 3 : return 4; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR5G6B5UnormPack16: + switch ( component ) + { + case 0 : return 5; + case 1 : return 6; + case 2 : return 5; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB5G6R5UnormPack16: + switch ( component ) + { + case 0 : return 5; + case 1 : return 6; + case 2 : return 5; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR5G5B5A1UnormPack16: + switch ( component ) + { + case 0 : return 5; + case 1 : return 5; + case 2 : return 5; + case 3 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB5G5R5A1UnormPack16: + switch ( component ) + { + case 0 : return 5; + case 1 : return 5; + case 2 : return 5; + case 3 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA1R5G5B5UnormPack16: + switch ( component ) + { + case 0 : return 1; + case 1 : return 5; + case 2 : return 5; + case 3 : return 5; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8Unorm: + switch ( component ) + { + case 0 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8Snorm: + switch ( component ) + { + case 0 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8Uscaled: + switch ( component ) + { + case 0 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8Sscaled: + switch ( component ) + { + case 0 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8Uint: + switch ( component ) + { + case 0 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8Sint: + switch ( component ) + { + case 0 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8Srgb: + switch ( component ) + { + case 0 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8Snorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8Uscaled: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8Sscaled: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8Uint: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8Sint: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8Srgb: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8Snorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8Uscaled: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8Sscaled: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8Uint: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8Sint: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8Srgb: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8Snorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8Uscaled: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8Sscaled: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8Uint: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8Sint: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8Srgb: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8A8Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8A8Snorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8A8Uscaled: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8A8Sscaled: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8A8Uint: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8A8Sint: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8G8B8A8Srgb: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8A8Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8A8Snorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8A8Uscaled: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8A8Sscaled: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8A8Uint: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8A8Sint: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8A8Srgb: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA8B8G8R8UnormPack32: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA8B8G8R8SnormPack32: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA8B8G8R8UscaledPack32: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA8B8G8R8SscaledPack32: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA8B8G8R8UintPack32: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA8B8G8R8SintPack32: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA8B8G8R8SrgbPack32: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2R10G10B10UnormPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2R10G10B10SnormPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2R10G10B10UscaledPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2R10G10B10SscaledPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2R10G10B10UintPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2R10G10B10SintPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2B10G10R10UnormPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2B10G10R10SnormPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2B10G10R10UscaledPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2B10G10R10SscaledPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2B10G10R10UintPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA2B10G10R10SintPack32: + switch ( component ) + { + case 0 : return 2; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16Unorm: + switch ( component ) + { + case 0 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16Snorm: + switch ( component ) + { + case 0 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16Uscaled: + switch ( component ) + { + case 0 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16Sscaled: + switch ( component ) + { + case 0 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16Uint: + switch ( component ) + { + case 0 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16Sint: + switch ( component ) + { + case 0 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16Sfloat: + switch ( component ) + { + case 0 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16Unorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16Snorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16Uscaled: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16Sscaled: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16Uint: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16Sint: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16Sfloat: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16Unorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16Snorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16Uscaled: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16Sscaled: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16Uint: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16Sint: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16Sfloat: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16A16Unorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + case 3 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16A16Snorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + case 3 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16A16Uscaled: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + case 3 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16A16Sscaled: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + case 3 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16A16Uint: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + case 3 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16A16Sint: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + case 3 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16B16A16Sfloat: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + case 3 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32Uint: + switch ( component ) + { + case 0 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32Sint: + switch ( component ) + { + case 0 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32Sfloat: + switch ( component ) + { + case 0 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32G32Uint: + switch ( component ) + { + case 0 : return 32; + case 1 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32G32Sint: + switch ( component ) + { + case 0 : return 32; + case 1 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32G32Sfloat: + switch ( component ) + { + case 0 : return 32; + case 1 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32G32B32Uint: + switch ( component ) + { + case 0 : return 32; + case 1 : return 32; + case 2 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32G32B32Sint: + switch ( component ) + { + case 0 : return 32; + case 1 : return 32; + case 2 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32G32B32Sfloat: + switch ( component ) + { + case 0 : return 32; + case 1 : return 32; + case 2 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32G32B32A32Uint: + switch ( component ) + { + case 0 : return 32; + case 1 : return 32; + case 2 : return 32; + case 3 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32G32B32A32Sint: + switch ( component ) + { + case 0 : return 32; + case 1 : return 32; + case 2 : return 32; + case 3 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR32G32B32A32Sfloat: + switch ( component ) + { + case 0 : return 32; + case 1 : return 32; + case 2 : return 32; + case 3 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64Uint: + switch ( component ) + { + case 0 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64Sint: + switch ( component ) + { + case 0 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64Sfloat: + switch ( component ) + { + case 0 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64G64Uint: + switch ( component ) + { + case 0 : return 64; + case 1 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64G64Sint: + switch ( component ) + { + case 0 : return 64; + case 1 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64G64Sfloat: + switch ( component ) + { + case 0 : return 64; + case 1 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64G64B64Uint: + switch ( component ) + { + case 0 : return 64; + case 1 : return 64; + case 2 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64G64B64Sint: + switch ( component ) + { + case 0 : return 64; + case 1 : return 64; + case 2 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64G64B64Sfloat: + switch ( component ) + { + case 0 : return 64; + case 1 : return 64; + case 2 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64G64B64A64Uint: + switch ( component ) + { + case 0 : return 64; + case 1 : return 64; + case 2 : return 64; + case 3 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64G64B64A64Sint: + switch ( component ) + { + case 0 : return 64; + case 1 : return 64; + case 2 : return 64; + case 3 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR64G64B64A64Sfloat: + switch ( component ) + { + case 0 : return 64; + case 1 : return 64; + case 2 : return 64; + case 3 : return 64; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB10G11R11UfloatPack32: + switch ( component ) + { + case 0 : return 10; + case 1 : return 11; + case 2 : return 11; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eE5B9G9R9UfloatPack32: + switch ( component ) + { + case 0 : return 9; + case 1 : return 9; + case 2 : return 9; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eD16Unorm: + switch ( component ) + { + case 0 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eX8D24UnormPack32: + switch ( component ) + { + case 0 : return 24; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eD32Sfloat: + switch ( component ) + { + case 0 : return 32; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eS8Uint: + switch ( component ) + { + case 0 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eD16UnormS8Uint: + switch ( component ) + { + case 0 : return 16; + case 1 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eD24UnormS8Uint: + switch ( component ) + { + case 0 : return 24; + case 1 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eD32SfloatS8Uint: + switch ( component ) + { + case 0 : return 32; + case 1 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eEacR11UnormBlock: + switch ( component ) + { + case 0 : return 11; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eEacR11SnormBlock: + switch ( component ) + { + case 0 : return 11; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eEacR11G11UnormBlock: + switch ( component ) + { + case 0 : return 11; + case 1 : return 11; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eEacR11G11SnormBlock: + switch ( component ) + { + case 0 : return 11; + case 1 : return 11; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8G8R8422Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB8G8R8G8422Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + case 3 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8R83Plane420Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8R82Plane420Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8R83Plane422Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8R82Plane422Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8R83Plane444Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR10X6UnormPack16: + switch ( component ) + { + case 0 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR10X6G10X6Unorm2Pack16: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + case 2 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + case 2 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + case 2 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + case 2 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + case 2 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR12X4UnormPack16: + switch ( component ) + { + case 0 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR12X4G12X4Unorm2Pack16: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + case 2 : return 12; + case 3 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + case 2 : return 12; + case 3 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + case 2 : return 12; + case 3 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + case 2 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + case 2 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + case 2 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + case 2 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + case 2 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16G16R16422Unorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + case 3 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eB16G16R16G16422Unorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + case 3 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R163Plane420Unorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R162Plane420Unorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R163Plane422Unorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R162Plane422Unorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R163Plane444Unorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8R82Plane444Unorm: + switch ( component ) + { + case 0 : return 8; + case 1 : return 8; + case 2 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + case 2 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + case 2 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R162Plane444Unorm: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + case 2 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA4R4G4B4UnormPack16: + switch ( component ) + { + case 0 : return 4; + case 1 : return 4; + case 2 : return 4; + case 3 : return 4; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA4B4G4R4UnormPack16: + switch ( component ) + { + case 0 : return 4; + case 1 : return 4; + case 2 : return 4; + case 3 : return 4; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA1B5G5R5UnormPack16: + switch ( component ) + { + case 0 : return 1; + case 1 : return 5; + case 2 : return 5; + case 3 : return 5; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eA8Unorm: + switch ( component ) + { + case 0 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR8BoolARM: + switch ( component ) + { + case 0 : return 8; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR16G16Sfixed5NV: + switch ( component ) + { + case 0 : return 16; + case 1 : return 16; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR10X6UintPack16ARM: + switch ( component ) + { + case 0 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR10X6G10X6Uint2Pack16ARM: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: + switch ( component ) + { + case 0 : return 10; + case 1 : return 10; + case 2 : return 10; + case 3 : return 10; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR12X4UintPack16ARM: + switch ( component ) + { + case 0 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR12X4G12X4Uint2Pack16ARM: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: + switch ( component ) + { + case 0 : return 12; + case 1 : return 12; + case 2 : return 12; + case 3 : return 12; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR14X2UintPack16ARM: + switch ( component ) + { + case 0 : return 14; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR14X2G14X2Uint2Pack16ARM: + switch ( component ) + { + case 0 : return 14; + case 1 : return 14; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: + switch ( component ) + { + case 0 : return 14; + case 1 : return 14; + case 2 : return 14; + case 3 : return 14; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR14X2UnormPack16ARM: + switch ( component ) + { + case 0 : return 14; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR14X2G14X2Unorm2Pack16ARM: + switch ( component ) + { + case 0 : return 14; + case 1 : return 14; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: + switch ( component ) + { + case 0 : return 14; + case 1 : return 14; + case 2 : return 14; + case 3 : return 14; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: + switch ( component ) + { + case 0 : return 14; + case 1 : return 14; + case 2 : return 14; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: + switch ( component ) + { + case 0 : return 14; + case 1 : return 14; + case 2 : return 14; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + + default: return 0; + } + } + + // The number of components of this format. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t componentCount( Format format ) + { + switch ( format ) + { + case Format::eR4G4UnormPack8 : return 2; + case Format::eR4G4B4A4UnormPack16 : return 4; + case Format::eB4G4R4A4UnormPack16 : return 4; + case Format::eR5G6B5UnormPack16 : return 3; + case Format::eB5G6R5UnormPack16 : return 3; + case Format::eR5G5B5A1UnormPack16 : return 4; + case Format::eB5G5R5A1UnormPack16 : return 4; + case Format::eA1R5G5B5UnormPack16 : return 4; + case Format::eR8Unorm : return 1; + case Format::eR8Snorm : return 1; + case Format::eR8Uscaled : return 1; + case Format::eR8Sscaled : return 1; + case Format::eR8Uint : return 1; + case Format::eR8Sint : return 1; + case Format::eR8Srgb : return 1; + case Format::eR8G8Unorm : return 2; + case Format::eR8G8Snorm : return 2; + case Format::eR8G8Uscaled : return 2; + case Format::eR8G8Sscaled : return 2; + case Format::eR8G8Uint : return 2; + case Format::eR8G8Sint : return 2; + case Format::eR8G8Srgb : return 2; + case Format::eR8G8B8Unorm : return 3; + case Format::eR8G8B8Snorm : return 3; + case Format::eR8G8B8Uscaled : return 3; + case Format::eR8G8B8Sscaled : return 3; + case Format::eR8G8B8Uint : return 3; + case Format::eR8G8B8Sint : return 3; + case Format::eR8G8B8Srgb : return 3; + case Format::eB8G8R8Unorm : return 3; + case Format::eB8G8R8Snorm : return 3; + case Format::eB8G8R8Uscaled : return 3; + case Format::eB8G8R8Sscaled : return 3; + case Format::eB8G8R8Uint : return 3; + case Format::eB8G8R8Sint : return 3; + case Format::eB8G8R8Srgb : return 3; + case Format::eR8G8B8A8Unorm : return 4; + case Format::eR8G8B8A8Snorm : return 4; + case Format::eR8G8B8A8Uscaled : return 4; + case Format::eR8G8B8A8Sscaled : return 4; + case Format::eR8G8B8A8Uint : return 4; + case Format::eR8G8B8A8Sint : return 4; + case Format::eR8G8B8A8Srgb : return 4; + case Format::eB8G8R8A8Unorm : return 4; + case Format::eB8G8R8A8Snorm : return 4; + case Format::eB8G8R8A8Uscaled : return 4; + case Format::eB8G8R8A8Sscaled : return 4; + case Format::eB8G8R8A8Uint : return 4; + case Format::eB8G8R8A8Sint : return 4; + case Format::eB8G8R8A8Srgb : return 4; + case Format::eA8B8G8R8UnormPack32 : return 4; + case Format::eA8B8G8R8SnormPack32 : return 4; + case Format::eA8B8G8R8UscaledPack32 : return 4; + case Format::eA8B8G8R8SscaledPack32 : return 4; + case Format::eA8B8G8R8UintPack32 : return 4; + case Format::eA8B8G8R8SintPack32 : return 4; + case Format::eA8B8G8R8SrgbPack32 : return 4; + case Format::eA2R10G10B10UnormPack32 : return 4; + case Format::eA2R10G10B10SnormPack32 : return 4; + case Format::eA2R10G10B10UscaledPack32 : return 4; + case Format::eA2R10G10B10SscaledPack32 : return 4; + case Format::eA2R10G10B10UintPack32 : return 4; + case Format::eA2R10G10B10SintPack32 : return 4; + case Format::eA2B10G10R10UnormPack32 : return 4; + case Format::eA2B10G10R10SnormPack32 : return 4; + case Format::eA2B10G10R10UscaledPack32 : return 4; + case Format::eA2B10G10R10SscaledPack32 : return 4; + case Format::eA2B10G10R10UintPack32 : return 4; + case Format::eA2B10G10R10SintPack32 : return 4; + case Format::eR16Unorm : return 1; + case Format::eR16Snorm : return 1; + case Format::eR16Uscaled : return 1; + case Format::eR16Sscaled : return 1; + case Format::eR16Uint : return 1; + case Format::eR16Sint : return 1; + case Format::eR16Sfloat : return 1; + case Format::eR16G16Unorm : return 2; + case Format::eR16G16Snorm : return 2; + case Format::eR16G16Uscaled : return 2; + case Format::eR16G16Sscaled : return 2; + case Format::eR16G16Uint : return 2; + case Format::eR16G16Sint : return 2; + case Format::eR16G16Sfloat : return 2; + case Format::eR16G16B16Unorm : return 3; + case Format::eR16G16B16Snorm : return 3; + case Format::eR16G16B16Uscaled : return 3; + case Format::eR16G16B16Sscaled : return 3; + case Format::eR16G16B16Uint : return 3; + case Format::eR16G16B16Sint : return 3; + case Format::eR16G16B16Sfloat : return 3; + case Format::eR16G16B16A16Unorm : return 4; + case Format::eR16G16B16A16Snorm : return 4; + case Format::eR16G16B16A16Uscaled : return 4; + case Format::eR16G16B16A16Sscaled : return 4; + case Format::eR16G16B16A16Uint : return 4; + case Format::eR16G16B16A16Sint : return 4; + case Format::eR16G16B16A16Sfloat : return 4; + case Format::eR32Uint : return 1; + case Format::eR32Sint : return 1; + case Format::eR32Sfloat : return 1; + case Format::eR32G32Uint : return 2; + case Format::eR32G32Sint : return 2; + case Format::eR32G32Sfloat : return 2; + case Format::eR32G32B32Uint : return 3; + case Format::eR32G32B32Sint : return 3; + case Format::eR32G32B32Sfloat : return 3; + case Format::eR32G32B32A32Uint : return 4; + case Format::eR32G32B32A32Sint : return 4; + case Format::eR32G32B32A32Sfloat : return 4; + case Format::eR64Uint : return 1; + case Format::eR64Sint : return 1; + case Format::eR64Sfloat : return 1; + case Format::eR64G64Uint : return 2; + case Format::eR64G64Sint : return 2; + case Format::eR64G64Sfloat : return 2; + case Format::eR64G64B64Uint : return 3; + case Format::eR64G64B64Sint : return 3; + case Format::eR64G64B64Sfloat : return 3; + case Format::eR64G64B64A64Uint : return 4; + case Format::eR64G64B64A64Sint : return 4; + case Format::eR64G64B64A64Sfloat : return 4; + case Format::eB10G11R11UfloatPack32 : return 3; + case Format::eE5B9G9R9UfloatPack32 : return 3; + case Format::eD16Unorm : return 1; + case Format::eX8D24UnormPack32 : return 1; + case Format::eD32Sfloat : return 1; + case Format::eS8Uint : return 1; + case Format::eD16UnormS8Uint : return 2; + case Format::eD24UnormS8Uint : return 2; + case Format::eD32SfloatS8Uint : return 2; + case Format::eBc1RgbUnormBlock : return 3; + case Format::eBc1RgbSrgbBlock : return 3; + case Format::eBc1RgbaUnormBlock : return 4; + case Format::eBc1RgbaSrgbBlock : return 4; + case Format::eBc2UnormBlock : return 4; + case Format::eBc2SrgbBlock : return 4; + case Format::eBc3UnormBlock : return 4; + case Format::eBc3SrgbBlock : return 4; + case Format::eBc4UnormBlock : return 1; + case Format::eBc4SnormBlock : return 1; + case Format::eBc5UnormBlock : return 2; + case Format::eBc5SnormBlock : return 2; + case Format::eBc6HUfloatBlock : return 3; + case Format::eBc6HSfloatBlock : return 3; + case Format::eBc7UnormBlock : return 4; + case Format::eBc7SrgbBlock : return 4; + case Format::eEtc2R8G8B8UnormBlock : return 3; + case Format::eEtc2R8G8B8SrgbBlock : return 3; + case Format::eEtc2R8G8B8A1UnormBlock : return 4; + case Format::eEtc2R8G8B8A1SrgbBlock : return 4; + case Format::eEtc2R8G8B8A8UnormBlock : return 4; + case Format::eEtc2R8G8B8A8SrgbBlock : return 4; + case Format::eEacR11UnormBlock : return 1; + case Format::eEacR11SnormBlock : return 1; + case Format::eEacR11G11UnormBlock : return 2; + case Format::eEacR11G11SnormBlock : return 2; + case Format::eAstc4x4UnormBlock : return 4; + case Format::eAstc4x4SrgbBlock : return 4; + case Format::eAstc5x4UnormBlock : return 4; + case Format::eAstc5x4SrgbBlock : return 4; + case Format::eAstc5x5UnormBlock : return 4; + case Format::eAstc5x5SrgbBlock : return 4; + case Format::eAstc6x5UnormBlock : return 4; + case Format::eAstc6x5SrgbBlock : return 4; + case Format::eAstc6x6UnormBlock : return 4; + case Format::eAstc6x6SrgbBlock : return 4; + case Format::eAstc8x5UnormBlock : return 4; + case Format::eAstc8x5SrgbBlock : return 4; + case Format::eAstc8x6UnormBlock : return 4; + case Format::eAstc8x6SrgbBlock : return 4; + case Format::eAstc8x8UnormBlock : return 4; + case Format::eAstc8x8SrgbBlock : return 4; + case Format::eAstc10x5UnormBlock : return 4; + case Format::eAstc10x5SrgbBlock : return 4; + case Format::eAstc10x6UnormBlock : return 4; + case Format::eAstc10x6SrgbBlock : return 4; + case Format::eAstc10x8UnormBlock : return 4; + case Format::eAstc10x8SrgbBlock : return 4; + case Format::eAstc10x10UnormBlock : return 4; + case Format::eAstc10x10SrgbBlock : return 4; + case Format::eAstc12x10UnormBlock : return 4; + case Format::eAstc12x10SrgbBlock : return 4; + case Format::eAstc12x12UnormBlock : return 4; + case Format::eAstc12x12SrgbBlock : return 4; + case Format::eG8B8G8R8422Unorm : return 4; + case Format::eB8G8R8G8422Unorm : return 4; + case Format::eG8B8R83Plane420Unorm : return 3; + case Format::eG8B8R82Plane420Unorm : return 3; + case Format::eG8B8R83Plane422Unorm : return 3; + case Format::eG8B8R82Plane422Unorm : return 3; + case Format::eG8B8R83Plane444Unorm : return 3; + case Format::eR10X6UnormPack16 : return 1; + case Format::eR10X6G10X6Unorm2Pack16 : return 2; + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return 4; + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return 4; + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return 4; + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return 3; + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return 3; + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return 3; + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return 3; + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return 3; + case Format::eR12X4UnormPack16 : return 1; + case Format::eR12X4G12X4Unorm2Pack16 : return 2; + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return 4; + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return 4; + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return 4; + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return 3; + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return 3; + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return 3; + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return 3; + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return 3; + case Format::eG16B16G16R16422Unorm : return 4; + case Format::eB16G16R16G16422Unorm : return 4; + case Format::eG16B16R163Plane420Unorm : return 3; + case Format::eG16B16R162Plane420Unorm : return 3; + case Format::eG16B16R163Plane422Unorm : return 3; + case Format::eG16B16R162Plane422Unorm : return 3; + case Format::eG16B16R163Plane444Unorm : return 3; + case Format::eG8B8R82Plane444Unorm : return 3; + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return 3; + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return 3; + case Format::eG16B16R162Plane444Unorm : return 3; + case Format::eA4R4G4B4UnormPack16 : return 4; + case Format::eA4B4G4R4UnormPack16 : return 4; + case Format::eAstc4x4SfloatBlock : return 4; + case Format::eAstc5x4SfloatBlock : return 4; + case Format::eAstc5x5SfloatBlock : return 4; + case Format::eAstc6x5SfloatBlock : return 4; + case Format::eAstc6x6SfloatBlock : return 4; + case Format::eAstc8x5SfloatBlock : return 4; + case Format::eAstc8x6SfloatBlock : return 4; + case Format::eAstc8x8SfloatBlock : return 4; + case Format::eAstc10x5SfloatBlock : return 4; + case Format::eAstc10x6SfloatBlock : return 4; + case Format::eAstc10x8SfloatBlock : return 4; + case Format::eAstc10x10SfloatBlock : return 4; + case Format::eAstc12x10SfloatBlock : return 4; + case Format::eAstc12x12SfloatBlock : return 4; + case Format::eA1B5G5R5UnormPack16 : return 4; + case Format::eA8Unorm : return 1; + case Format::ePvrtc12BppUnormBlockIMG : return 4; + case Format::ePvrtc14BppUnormBlockIMG : return 4; + case Format::ePvrtc22BppUnormBlockIMG : return 4; + case Format::ePvrtc24BppUnormBlockIMG : return 4; + case Format::ePvrtc12BppSrgbBlockIMG : return 4; + case Format::ePvrtc14BppSrgbBlockIMG : return 4; + case Format::ePvrtc22BppSrgbBlockIMG : return 4; + case Format::ePvrtc24BppSrgbBlockIMG : return 4; + case Format::eAstc3x3x3UnormBlockEXT : return 4; + case Format::eAstc3x3x3SrgbBlockEXT : return 4; + case Format::eAstc3x3x3SfloatBlockEXT : return 4; + case Format::eAstc4x3x3UnormBlockEXT : return 4; + case Format::eAstc4x3x3SrgbBlockEXT : return 4; + case Format::eAstc4x3x3SfloatBlockEXT : return 4; + case Format::eAstc4x4x3UnormBlockEXT : return 4; + case Format::eAstc4x4x3SrgbBlockEXT : return 4; + case Format::eAstc4x4x3SfloatBlockEXT : return 4; + case Format::eAstc4x4x4UnormBlockEXT : return 4; + case Format::eAstc4x4x4SrgbBlockEXT : return 4; + case Format::eAstc4x4x4SfloatBlockEXT : return 4; + case Format::eAstc5x4x4UnormBlockEXT : return 4; + case Format::eAstc5x4x4SrgbBlockEXT : return 4; + case Format::eAstc5x4x4SfloatBlockEXT : return 4; + case Format::eAstc5x5x4UnormBlockEXT : return 4; + case Format::eAstc5x5x4SrgbBlockEXT : return 4; + case Format::eAstc5x5x4SfloatBlockEXT : return 4; + case Format::eAstc5x5x5UnormBlockEXT : return 4; + case Format::eAstc5x5x5SrgbBlockEXT : return 4; + case Format::eAstc5x5x5SfloatBlockEXT : return 4; + case Format::eAstc6x5x5UnormBlockEXT : return 4; + case Format::eAstc6x5x5SrgbBlockEXT : return 4; + case Format::eAstc6x5x5SfloatBlockEXT : return 4; + case Format::eAstc6x6x5UnormBlockEXT : return 4; + case Format::eAstc6x6x5SrgbBlockEXT : return 4; + case Format::eAstc6x6x5SfloatBlockEXT : return 4; + case Format::eAstc6x6x6UnormBlockEXT : return 4; + case Format::eAstc6x6x6SrgbBlockEXT : return 4; + case Format::eAstc6x6x6SfloatBlockEXT : return 4; + case Format::eR8BoolARM : return 1; + case Format::eR16G16Sfixed5NV : return 2; + case Format::eR10X6UintPack16ARM : return 1; + case Format::eR10X6G10X6Uint2Pack16ARM : return 2; + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return 4; + case Format::eR12X4UintPack16ARM : return 1; + case Format::eR12X4G12X4Uint2Pack16ARM : return 2; + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return 4; + case Format::eR14X2UintPack16ARM : return 1; + case Format::eR14X2G14X2Uint2Pack16ARM : return 2; + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return 4; + case Format::eR14X2UnormPack16ARM : return 1; + case Format::eR14X2G14X2Unorm2Pack16ARM : return 2; + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return 4; + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return 3; + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return 3; + + default: return 0; + } + } + + // The name of the component + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 char const * componentName( Format format, uint8_t component ) + { + switch ( format ) + { + case Format::eR4G4UnormPack8: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR4G4B4A4UnormPack16: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB4G4R4A4UnormPack16: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR5G6B5UnormPack16: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB5G6R5UnormPack16: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR5G5B5A1UnormPack16: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB5G5R5A1UnormPack16: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA1R5G5B5UnormPack16: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "R"; + case 2 : return "G"; + case 3 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Unorm: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Snorm: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Uscaled: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Sscaled: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Uint: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Sint: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Srgb: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Unorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Snorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Uscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Sscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Srgb: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Unorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Snorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Uscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Sscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Srgb: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Unorm: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Snorm: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Uscaled: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Sscaled: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Uint: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Sint: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Srgb: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Unorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Snorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Uscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Sscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Srgb: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Unorm: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Snorm: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Uscaled: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Sscaled: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Uint: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Sint: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Srgb: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8UnormPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8SnormPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8UscaledPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8SscaledPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8UintPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8SintPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8SrgbPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10UnormPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "R"; + case 2 : return "G"; + case 3 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10SnormPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "R"; + case 2 : return "G"; + case 3 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10UscaledPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "R"; + case 2 : return "G"; + case 3 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10SscaledPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "R"; + case 2 : return "G"; + case 3 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10UintPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "R"; + case 2 : return "G"; + case 3 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10SintPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "R"; + case 2 : return "G"; + case 3 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10UnormPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10SnormPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10UscaledPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10SscaledPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10UintPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10SintPack32: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Unorm: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Snorm: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Uscaled: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Sscaled: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Uint: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Sint: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Sfloat: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Unorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Snorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Uscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Sscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Sfloat: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Unorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Snorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Uscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Sscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Sfloat: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Unorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Snorm: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Uscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Sscaled: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Sfloat: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32Uint: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32Sint: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32Sfloat: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32Sfloat: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32Sfloat: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32A32Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32A32Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32A32Sfloat: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64Uint: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64Sint: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64Sfloat: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64Sfloat: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64Sfloat: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64A64Uint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64A64Sint: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64A64Sfloat: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB10G11R11UfloatPack32: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eE5B9G9R9UfloatPack32: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eD16Unorm: + switch ( component ) + { + case 0 : return "D"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eX8D24UnormPack32: + switch ( component ) + { + case 0 : return "D"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eD32Sfloat: + switch ( component ) + { + case 0 : return "D"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eS8Uint: + switch ( component ) + { + case 0 : return "S"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eD16UnormS8Uint: + switch ( component ) + { + case 0 : return "D"; + case 1 : return "S"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eD24UnormS8Uint: + switch ( component ) + { + case 0 : return "D"; + case 1 : return "S"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eD32SfloatS8Uint: + switch ( component ) + { + case 0 : return "D"; + case 1 : return "S"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc1RgbUnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc1RgbSrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc1RgbaUnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc1RgbaSrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc2UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc2SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc3UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc3SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc4UnormBlock: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc4SnormBlock: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc5UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc5SnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc6HUfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc6HSfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc7UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc7SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8A1UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8A1SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8A8UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8A8SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEacR11UnormBlock: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEacR11SnormBlock: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEacR11G11UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEacR11G11SnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x5UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x5SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x6UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x6SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x8UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x8SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x5UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x5SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x6UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x6SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x8UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x8SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x10UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x10SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x10UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x10SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x12UnormBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x12SrgbBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8G8R8422Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8G8422Unorm: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R83Plane420Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R82Plane420Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R83Plane422Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R82Plane422Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R83Plane444Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6UnormPack16: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6G10X6Unorm2Pack16: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4UnormPack16: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4G12X4Unorm2Pack16: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16G16R16422Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB16G16R16G16422Unorm: + switch ( component ) + { + case 0 : return "B"; + case 1 : return "G"; + case 2 : return "R"; + case 3 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R163Plane420Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R162Plane420Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R163Plane422Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R162Plane422Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R163Plane444Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R82Plane444Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R162Plane444Unorm: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA4R4G4B4UnormPack16: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "R"; + case 2 : return "G"; + case 3 : return "B"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA4B4G4R4UnormPack16: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x5SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x6SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x8SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x5SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x6SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x8SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x10SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x10SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x12SfloatBlock: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA1B5G5R5UnormPack16: + switch ( component ) + { + case 0 : return "A"; + case 1 : return "B"; + case 2 : return "G"; + case 3 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8Unorm: + switch ( component ) + { + case 0 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc12BppUnormBlockIMG: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc14BppUnormBlockIMG: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc22BppUnormBlockIMG: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc24BppUnormBlockIMG: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc12BppSrgbBlockIMG: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc14BppSrgbBlockIMG: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc22BppSrgbBlockIMG: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc24BppSrgbBlockIMG: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc3x3x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc3x3x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc3x3x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6UnormBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6SrgbBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6SfloatBlockEXT: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8BoolARM: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Sfixed5NV: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6UintPack16ARM: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6G10X6Uint2Pack16ARM: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4UintPack16ARM: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4G12X4Uint2Pack16ARM: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2UintPack16ARM: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2G14X2Uint2Pack16ARM: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2UnormPack16ARM: + switch ( component ) + { + case 0 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2G14X2Unorm2Pack16ARM: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: + switch ( component ) + { + case 0 : return "R"; + case 1 : return "G"; + case 2 : return "B"; + case 3 : return "A"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: + switch ( component ) + { + case 0 : return "G"; + case 1 : return "B"; + case 2 : return "R"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + + default: return ""; + } + } + + // The numeric format of the component + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 char const * componentNumericFormat( Format format, uint8_t component ) + { + switch ( format ) + { + case Format::eR4G4UnormPack8: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR4G4B4A4UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB4G4R4A4UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR5G6B5UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB5G6R5UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR5G5B5A1UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB5G5R5A1UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA1R5G5B5UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Snorm: + switch ( component ) + { + case 0 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Uscaled: + switch ( component ) + { + case 0 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Sscaled: + switch ( component ) + { + case 0 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Uint: + switch ( component ) + { + case 0 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Sint: + switch ( component ) + { + case 0 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8Srgb: + switch ( component ) + { + case 0 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Snorm: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Uscaled: + switch ( component ) + { + case 0 : return "USCALED"; + case 1 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Sscaled: + switch ( component ) + { + case 0 : return "SSCALED"; + case 1 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8Srgb: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Snorm: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + case 2 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Uscaled: + switch ( component ) + { + case 0 : return "USCALED"; + case 1 : return "USCALED"; + case 2 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Sscaled: + switch ( component ) + { + case 0 : return "SSCALED"; + case 1 : return "SSCALED"; + case 2 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8Srgb: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Snorm: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + case 2 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Uscaled: + switch ( component ) + { + case 0 : return "USCALED"; + case 1 : return "USCALED"; + case 2 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Sscaled: + switch ( component ) + { + case 0 : return "SSCALED"; + case 1 : return "SSCALED"; + case 2 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8Srgb: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Snorm: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + case 2 : return "SNORM"; + case 3 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Uscaled: + switch ( component ) + { + case 0 : return "USCALED"; + case 1 : return "USCALED"; + case 2 : return "USCALED"; + case 3 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Sscaled: + switch ( component ) + { + case 0 : return "SSCALED"; + case 1 : return "SSCALED"; + case 2 : return "SSCALED"; + case 3 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + case 3 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + case 3 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8G8B8A8Srgb: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Snorm: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + case 2 : return "SNORM"; + case 3 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Uscaled: + switch ( component ) + { + case 0 : return "USCALED"; + case 1 : return "USCALED"; + case 2 : return "USCALED"; + case 3 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Sscaled: + switch ( component ) + { + case 0 : return "SSCALED"; + case 1 : return "SSCALED"; + case 2 : return "SSCALED"; + case 3 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + case 3 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + case 3 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8A8Srgb: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8UnormPack32: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8SnormPack32: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + case 2 : return "SNORM"; + case 3 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8UscaledPack32: + switch ( component ) + { + case 0 : return "USCALED"; + case 1 : return "USCALED"; + case 2 : return "USCALED"; + case 3 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8SscaledPack32: + switch ( component ) + { + case 0 : return "SSCALED"; + case 1 : return "SSCALED"; + case 2 : return "SSCALED"; + case 3 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8UintPack32: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + case 3 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8SintPack32: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + case 3 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8B8G8R8SrgbPack32: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10UnormPack32: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10SnormPack32: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + case 2 : return "SNORM"; + case 3 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10UscaledPack32: + switch ( component ) + { + case 0 : return "USCALED"; + case 1 : return "USCALED"; + case 2 : return "USCALED"; + case 3 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10SscaledPack32: + switch ( component ) + { + case 0 : return "SSCALED"; + case 1 : return "SSCALED"; + case 2 : return "SSCALED"; + case 3 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10UintPack32: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + case 3 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2R10G10B10SintPack32: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + case 3 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10UnormPack32: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10SnormPack32: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + case 2 : return "SNORM"; + case 3 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10UscaledPack32: + switch ( component ) + { + case 0 : return "USCALED"; + case 1 : return "USCALED"; + case 2 : return "USCALED"; + case 3 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10SscaledPack32: + switch ( component ) + { + case 0 : return "SSCALED"; + case 1 : return "SSCALED"; + case 2 : return "SSCALED"; + case 3 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10UintPack32: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + case 3 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA2B10G10R10SintPack32: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + case 3 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Snorm: + switch ( component ) + { + case 0 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Uscaled: + switch ( component ) + { + case 0 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Sscaled: + switch ( component ) + { + case 0 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Uint: + switch ( component ) + { + case 0 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Sint: + switch ( component ) + { + case 0 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Snorm: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Uscaled: + switch ( component ) + { + case 0 : return "USCALED"; + case 1 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Sscaled: + switch ( component ) + { + case 0 : return "SSCALED"; + case 1 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Snorm: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + case 2 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Uscaled: + switch ( component ) + { + case 0 : return "USCALED"; + case 1 : return "USCALED"; + case 2 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Sscaled: + switch ( component ) + { + case 0 : return "SSCALED"; + case 1 : return "SSCALED"; + case 2 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Snorm: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + case 2 : return "SNORM"; + case 3 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Uscaled: + switch ( component ) + { + case 0 : return "USCALED"; + case 1 : return "USCALED"; + case 2 : return "USCALED"; + case 3 : return "USCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Sscaled: + switch ( component ) + { + case 0 : return "SSCALED"; + case 1 : return "SSCALED"; + case 2 : return "SSCALED"; + case 3 : return "SSCALED"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + case 3 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + case 3 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16B16A16Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32Uint: + switch ( component ) + { + case 0 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32Sint: + switch ( component ) + { + case 0 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32A32Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + case 3 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32A32Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + case 3 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR32G32B32A32Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64Uint: + switch ( component ) + { + case 0 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64Sint: + switch ( component ) + { + case 0 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64A64Uint: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + case 3 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64A64Sint: + switch ( component ) + { + case 0 : return "SINT"; + case 1 : return "SINT"; + case 2 : return "SINT"; + case 3 : return "SINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR64G64B64A64Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB10G11R11UfloatPack32: + switch ( component ) + { + case 0 : return "UFLOAT"; + case 1 : return "UFLOAT"; + case 2 : return "UFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eE5B9G9R9UfloatPack32: + switch ( component ) + { + case 0 : return "UFLOAT"; + case 1 : return "UFLOAT"; + case 2 : return "UFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eD16Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eX8D24UnormPack32: + switch ( component ) + { + case 0 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eD32Sfloat: + switch ( component ) + { + case 0 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eS8Uint: + switch ( component ) + { + case 0 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eD16UnormS8Uint: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eD24UnormS8Uint: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eD32SfloatS8Uint: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc1RgbUnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc1RgbSrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc1RgbaUnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc1RgbaSrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc2UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc2SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc3UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc3SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc4UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc4SnormBlock: + switch ( component ) + { + case 0 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc5UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc5SnormBlock: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc6HUfloatBlock: + switch ( component ) + { + case 0 : return "UFLOAT"; + case 1 : return "UFLOAT"; + case 2 : return "UFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc6HSfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc7UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eBc7SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8A1UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8A1SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8A8UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEtc2R8G8B8A8SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEacR11UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEacR11SnormBlock: + switch ( component ) + { + case 0 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEacR11G11UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eEacR11G11SnormBlock: + switch ( component ) + { + case 0 : return "SNORM"; + case 1 : return "SNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x5UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x5SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x6UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x6SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x8UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x8SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x5UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x5SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x6UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x6SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x8UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x8SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x10UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x10SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x10UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x10SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x12UnormBlock: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x12SrgbBlock: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8G8R8422Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB8G8R8G8422Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R83Plane420Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R82Plane420Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R83Plane422Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R82Plane422Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R83Plane444Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6G10X6Unorm2Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4G12X4Unorm2Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16G16R16422Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eB16G16R16G16422Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R163Plane420Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R162Plane420Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R163Plane422Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R162Plane422Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R163Plane444Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG8B8R82Plane444Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG16B16R162Plane444Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA4R4G4B4UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA4B4G4R4UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x5SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x6SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc8x8SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x5SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x6SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x8SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc10x10SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x10SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc12x12SfloatBlock: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA1B5G5R5UnormPack16: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eA8Unorm: + switch ( component ) + { + case 0 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc12BppUnormBlockIMG: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc14BppUnormBlockIMG: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc22BppUnormBlockIMG: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc24BppUnormBlockIMG: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc12BppSrgbBlockIMG: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc14BppSrgbBlockIMG: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc22BppSrgbBlockIMG: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::ePvrtc24BppSrgbBlockIMG: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc3x3x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc3x3x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc3x3x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x3x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x3SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc4x4x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x4x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x4SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc5x5x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x5x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x5SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6UnormBlockEXT: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6SrgbBlockEXT: + switch ( component ) + { + case 0 : return "SRGB"; + case 1 : return "SRGB"; + case 2 : return "SRGB"; + case 3 : return "SRGB"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eAstc6x6x6SfloatBlockEXT: + switch ( component ) + { + case 0 : return "SFLOAT"; + case 1 : return "SFLOAT"; + case 2 : return "SFLOAT"; + case 3 : return "SFLOAT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR8BoolARM: + switch ( component ) + { + case 0 : return "BOOL"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR16G16Sfixed5NV: + switch ( component ) + { + case 0 : return "SFIXED5"; + case 1 : return "SFIXED5"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6UintPack16ARM: + switch ( component ) + { + case 0 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6G10X6Uint2Pack16ARM: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + case 3 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4UintPack16ARM: + switch ( component ) + { + case 0 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4G12X4Uint2Pack16ARM: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + case 3 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2UintPack16ARM: + switch ( component ) + { + case 0 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2G14X2Uint2Pack16ARM: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: + switch ( component ) + { + case 0 : return "UINT"; + case 1 : return "UINT"; + case 2 : return "UINT"; + case 3 : return "UINT"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2UnormPack16ARM: + switch ( component ) + { + case 0 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2G14X2Unorm2Pack16ARM: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + case 3 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: + switch ( component ) + { + case 0 : return "UNORM"; + case 1 : return "UNORM"; + case 2 : return "UNORM"; + default: VULKAN_HPP_ASSERT( false ); return ""; + } + + default: return ""; + } + } + + // The plane this component lies in. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t componentPlaneIndex( Format format, uint8_t component ) + { + switch ( format ) + { + case Format::eG8B8R83Plane420Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8R82Plane420Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8R83Plane422Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8R82Plane422Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8R83Plane444Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R163Plane420Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R162Plane420Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R163Plane422Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R162Plane422Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R163Plane444Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG8B8R82Plane444Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG16B16R162Plane444Unorm: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: + switch ( component ) + { + case 0 : return 0; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 0; + } + + default: return 0; + } + } + + // True, if the components of this format are compressed, otherwise false. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool componentsAreCompressed( Format format ) + { + switch ( format ) + { + case Format::eBc1RgbUnormBlock: + case Format::eBc1RgbSrgbBlock: + case Format::eBc1RgbaUnormBlock: + case Format::eBc1RgbaSrgbBlock: + case Format::eBc2UnormBlock: + case Format::eBc2SrgbBlock: + case Format::eBc3UnormBlock: + case Format::eBc3SrgbBlock: + case Format::eBc4UnormBlock: + case Format::eBc4SnormBlock: + case Format::eBc5UnormBlock: + case Format::eBc5SnormBlock: + case Format::eBc6HUfloatBlock: + case Format::eBc6HSfloatBlock: + case Format::eBc7UnormBlock: + case Format::eBc7SrgbBlock: + case Format::eEtc2R8G8B8UnormBlock: + case Format::eEtc2R8G8B8SrgbBlock: + case Format::eEtc2R8G8B8A1UnormBlock: + case Format::eEtc2R8G8B8A1SrgbBlock: + case Format::eEtc2R8G8B8A8UnormBlock: + case Format::eEtc2R8G8B8A8SrgbBlock: + case Format::eAstc4x4UnormBlock: + case Format::eAstc4x4SrgbBlock: + case Format::eAstc5x4UnormBlock: + case Format::eAstc5x4SrgbBlock: + case Format::eAstc5x5UnormBlock: + case Format::eAstc5x5SrgbBlock: + case Format::eAstc6x5UnormBlock: + case Format::eAstc6x5SrgbBlock: + case Format::eAstc6x6UnormBlock: + case Format::eAstc6x6SrgbBlock: + case Format::eAstc8x5UnormBlock: + case Format::eAstc8x5SrgbBlock: + case Format::eAstc8x6UnormBlock: + case Format::eAstc8x6SrgbBlock: + case Format::eAstc8x8UnormBlock: + case Format::eAstc8x8SrgbBlock: + case Format::eAstc10x5UnormBlock: + case Format::eAstc10x5SrgbBlock: + case Format::eAstc10x6UnormBlock: + case Format::eAstc10x6SrgbBlock: + case Format::eAstc10x8UnormBlock: + case Format::eAstc10x8SrgbBlock: + case Format::eAstc10x10UnormBlock: + case Format::eAstc10x10SrgbBlock: + case Format::eAstc12x10UnormBlock: + case Format::eAstc12x10SrgbBlock: + case Format::eAstc12x12UnormBlock: + case Format::eAstc12x12SrgbBlock: + case Format::eAstc4x4SfloatBlock: + case Format::eAstc5x4SfloatBlock: + case Format::eAstc5x5SfloatBlock: + case Format::eAstc6x5SfloatBlock: + case Format::eAstc6x6SfloatBlock: + case Format::eAstc8x5SfloatBlock: + case Format::eAstc8x6SfloatBlock: + case Format::eAstc8x8SfloatBlock: + case Format::eAstc10x5SfloatBlock: + case Format::eAstc10x6SfloatBlock: + case Format::eAstc10x8SfloatBlock: + case Format::eAstc10x10SfloatBlock: + case Format::eAstc12x10SfloatBlock: + case Format::eAstc12x12SfloatBlock: + case Format::ePvrtc12BppUnormBlockIMG: + case Format::ePvrtc14BppUnormBlockIMG: + case Format::ePvrtc22BppUnormBlockIMG: + case Format::ePvrtc24BppUnormBlockIMG: + case Format::ePvrtc12BppSrgbBlockIMG: + case Format::ePvrtc14BppSrgbBlockIMG: + case Format::ePvrtc22BppSrgbBlockIMG: + case Format::ePvrtc24BppSrgbBlockIMG: + case Format::eAstc3x3x3UnormBlockEXT: + case Format::eAstc3x3x3SrgbBlockEXT: + case Format::eAstc3x3x3SfloatBlockEXT: + case Format::eAstc4x3x3UnormBlockEXT: + case Format::eAstc4x3x3SrgbBlockEXT: + case Format::eAstc4x3x3SfloatBlockEXT: + case Format::eAstc4x4x3UnormBlockEXT: + case Format::eAstc4x4x3SrgbBlockEXT: + case Format::eAstc4x4x3SfloatBlockEXT: + case Format::eAstc4x4x4UnormBlockEXT: + case Format::eAstc4x4x4SrgbBlockEXT: + case Format::eAstc4x4x4SfloatBlockEXT: + case Format::eAstc5x4x4UnormBlockEXT: + case Format::eAstc5x4x4SrgbBlockEXT: + case Format::eAstc5x4x4SfloatBlockEXT: + case Format::eAstc5x5x4UnormBlockEXT: + case Format::eAstc5x5x4SrgbBlockEXT: + case Format::eAstc5x5x4SfloatBlockEXT: + case Format::eAstc5x5x5UnormBlockEXT: + case Format::eAstc5x5x5SrgbBlockEXT: + case Format::eAstc5x5x5SfloatBlockEXT: + case Format::eAstc6x5x5UnormBlockEXT: + case Format::eAstc6x5x5SrgbBlockEXT: + case Format::eAstc6x5x5SfloatBlockEXT: + case Format::eAstc6x6x5UnormBlockEXT: + case Format::eAstc6x6x5SrgbBlockEXT: + case Format::eAstc6x6x5SfloatBlockEXT: + case Format::eAstc6x6x6UnormBlockEXT: + case Format::eAstc6x6x6SrgbBlockEXT: + case Format::eAstc6x6x6SfloatBlockEXT: return true; + default : return false; + } + } + + // A textual description of the compression scheme, or an empty string if it is not compressed + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 char const * compressionScheme( Format format ) + { + switch ( format ) + { + case Format::eBc1RgbUnormBlock : return "BC"; + case Format::eBc1RgbSrgbBlock : return "BC"; + case Format::eBc1RgbaUnormBlock : return "BC"; + case Format::eBc1RgbaSrgbBlock : return "BC"; + case Format::eBc2UnormBlock : return "BC"; + case Format::eBc2SrgbBlock : return "BC"; + case Format::eBc3UnormBlock : return "BC"; + case Format::eBc3SrgbBlock : return "BC"; + case Format::eBc4UnormBlock : return "BC"; + case Format::eBc4SnormBlock : return "BC"; + case Format::eBc5UnormBlock : return "BC"; + case Format::eBc5SnormBlock : return "BC"; + case Format::eBc6HUfloatBlock : return "BC"; + case Format::eBc6HSfloatBlock : return "BC"; + case Format::eBc7UnormBlock : return "BC"; + case Format::eBc7SrgbBlock : return "BC"; + case Format::eEtc2R8G8B8UnormBlock : return "ETC2"; + case Format::eEtc2R8G8B8SrgbBlock : return "ETC2"; + case Format::eEtc2R8G8B8A1UnormBlock : return "ETC2"; + case Format::eEtc2R8G8B8A1SrgbBlock : return "ETC2"; + case Format::eEtc2R8G8B8A8UnormBlock : return "ETC2"; + case Format::eEtc2R8G8B8A8SrgbBlock : return "ETC2"; + case Format::eEacR11UnormBlock : return "EAC"; + case Format::eEacR11SnormBlock : return "EAC"; + case Format::eEacR11G11UnormBlock : return "EAC"; + case Format::eEacR11G11SnormBlock : return "EAC"; + case Format::eAstc4x4UnormBlock : return "ASTC LDR"; + case Format::eAstc4x4SrgbBlock : return "ASTC LDR"; + case Format::eAstc5x4UnormBlock : return "ASTC LDR"; + case Format::eAstc5x4SrgbBlock : return "ASTC LDR"; + case Format::eAstc5x5UnormBlock : return "ASTC LDR"; + case Format::eAstc5x5SrgbBlock : return "ASTC LDR"; + case Format::eAstc6x5UnormBlock : return "ASTC LDR"; + case Format::eAstc6x5SrgbBlock : return "ASTC LDR"; + case Format::eAstc6x6UnormBlock : return "ASTC LDR"; + case Format::eAstc6x6SrgbBlock : return "ASTC LDR"; + case Format::eAstc8x5UnormBlock : return "ASTC LDR"; + case Format::eAstc8x5SrgbBlock : return "ASTC LDR"; + case Format::eAstc8x6UnormBlock : return "ASTC LDR"; + case Format::eAstc8x6SrgbBlock : return "ASTC LDR"; + case Format::eAstc8x8UnormBlock : return "ASTC LDR"; + case Format::eAstc8x8SrgbBlock : return "ASTC LDR"; + case Format::eAstc10x5UnormBlock : return "ASTC LDR"; + case Format::eAstc10x5SrgbBlock : return "ASTC LDR"; + case Format::eAstc10x6UnormBlock : return "ASTC LDR"; + case Format::eAstc10x6SrgbBlock : return "ASTC LDR"; + case Format::eAstc10x8UnormBlock : return "ASTC LDR"; + case Format::eAstc10x8SrgbBlock : return "ASTC LDR"; + case Format::eAstc10x10UnormBlock : return "ASTC LDR"; + case Format::eAstc10x10SrgbBlock : return "ASTC LDR"; + case Format::eAstc12x10UnormBlock : return "ASTC LDR"; + case Format::eAstc12x10SrgbBlock : return "ASTC LDR"; + case Format::eAstc12x12UnormBlock : return "ASTC LDR"; + case Format::eAstc12x12SrgbBlock : return "ASTC LDR"; + case Format::eAstc4x4SfloatBlock : return "ASTC HDR"; + case Format::eAstc5x4SfloatBlock : return "ASTC HDR"; + case Format::eAstc5x5SfloatBlock : return "ASTC HDR"; + case Format::eAstc6x5SfloatBlock : return "ASTC HDR"; + case Format::eAstc6x6SfloatBlock : return "ASTC HDR"; + case Format::eAstc8x5SfloatBlock : return "ASTC HDR"; + case Format::eAstc8x6SfloatBlock : return "ASTC HDR"; + case Format::eAstc8x8SfloatBlock : return "ASTC HDR"; + case Format::eAstc10x5SfloatBlock : return "ASTC HDR"; + case Format::eAstc10x6SfloatBlock : return "ASTC HDR"; + case Format::eAstc10x8SfloatBlock : return "ASTC HDR"; + case Format::eAstc10x10SfloatBlock : return "ASTC HDR"; + case Format::eAstc12x10SfloatBlock : return "ASTC HDR"; + case Format::eAstc12x12SfloatBlock : return "ASTC HDR"; + case Format::ePvrtc12BppUnormBlockIMG: return "PVRTC"; + case Format::ePvrtc14BppUnormBlockIMG: return "PVRTC"; + case Format::ePvrtc22BppUnormBlockIMG: return "PVRTC"; + case Format::ePvrtc24BppUnormBlockIMG: return "PVRTC"; + case Format::ePvrtc12BppSrgbBlockIMG : return "PVRTC"; + case Format::ePvrtc14BppSrgbBlockIMG : return "PVRTC"; + case Format::ePvrtc22BppSrgbBlockIMG : return "PVRTC"; + case Format::ePvrtc24BppSrgbBlockIMG : return "PVRTC"; + case Format::eAstc3x3x3UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc3x3x3SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc3x3x3SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc4x3x3UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc4x3x3SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc4x3x3SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc4x4x3UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc4x4x3SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc4x4x3SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc4x4x4UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc4x4x4SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc4x4x4SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc5x4x4UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc5x4x4SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc5x4x4SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc5x5x4UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc5x5x4SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc5x5x4SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc5x5x5UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc5x5x5SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc5x5x5SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc6x5x5UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc6x5x5SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc6x5x5SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc6x6x5UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc6x6x5SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc6x6x5SfloatBlockEXT: return "ASTC HDR"; + case Format::eAstc6x6x6UnormBlockEXT : return "ASTC LDR"; + case Format::eAstc6x6x6SrgbBlockEXT : return "ASTC LDR"; + case Format::eAstc6x6x6SfloatBlockEXT: return "ASTC HDR"; + + default: return ""; + } + } + + // Get all formats + VULKAN_HPP_INLINE std::vector const & getAllFormats() + { + static std::vector allFormats = { Format::eR4G4UnormPack8, + Format::eR4G4B4A4UnormPack16, + Format::eB4G4R4A4UnormPack16, + Format::eR5G6B5UnormPack16, + Format::eB5G6R5UnormPack16, + Format::eR5G5B5A1UnormPack16, + Format::eB5G5R5A1UnormPack16, + Format::eA1R5G5B5UnormPack16, + Format::eR8Unorm, + Format::eR8Snorm, + Format::eR8Uscaled, + Format::eR8Sscaled, + Format::eR8Uint, + Format::eR8Sint, + Format::eR8Srgb, + Format::eR8G8Unorm, + Format::eR8G8Snorm, + Format::eR8G8Uscaled, + Format::eR8G8Sscaled, + Format::eR8G8Uint, + Format::eR8G8Sint, + Format::eR8G8Srgb, + Format::eR8G8B8Unorm, + Format::eR8G8B8Snorm, + Format::eR8G8B8Uscaled, + Format::eR8G8B8Sscaled, + Format::eR8G8B8Uint, + Format::eR8G8B8Sint, + Format::eR8G8B8Srgb, + Format::eB8G8R8Unorm, + Format::eB8G8R8Snorm, + Format::eB8G8R8Uscaled, + Format::eB8G8R8Sscaled, + Format::eB8G8R8Uint, + Format::eB8G8R8Sint, + Format::eB8G8R8Srgb, + Format::eR8G8B8A8Unorm, + Format::eR8G8B8A8Snorm, + Format::eR8G8B8A8Uscaled, + Format::eR8G8B8A8Sscaled, + Format::eR8G8B8A8Uint, + Format::eR8G8B8A8Sint, + Format::eR8G8B8A8Srgb, + Format::eB8G8R8A8Unorm, + Format::eB8G8R8A8Snorm, + Format::eB8G8R8A8Uscaled, + Format::eB8G8R8A8Sscaled, + Format::eB8G8R8A8Uint, + Format::eB8G8R8A8Sint, + Format::eB8G8R8A8Srgb, + Format::eA8B8G8R8UnormPack32, + Format::eA8B8G8R8SnormPack32, + Format::eA8B8G8R8UscaledPack32, + Format::eA8B8G8R8SscaledPack32, + Format::eA8B8G8R8UintPack32, + Format::eA8B8G8R8SintPack32, + Format::eA8B8G8R8SrgbPack32, + Format::eA2R10G10B10UnormPack32, + Format::eA2R10G10B10SnormPack32, + Format::eA2R10G10B10UscaledPack32, + Format::eA2R10G10B10SscaledPack32, + Format::eA2R10G10B10UintPack32, + Format::eA2R10G10B10SintPack32, + Format::eA2B10G10R10UnormPack32, + Format::eA2B10G10R10SnormPack32, + Format::eA2B10G10R10UscaledPack32, + Format::eA2B10G10R10SscaledPack32, + Format::eA2B10G10R10UintPack32, + Format::eA2B10G10R10SintPack32, + Format::eR16Unorm, + Format::eR16Snorm, + Format::eR16Uscaled, + Format::eR16Sscaled, + Format::eR16Uint, + Format::eR16Sint, + Format::eR16Sfloat, + Format::eR16G16Unorm, + Format::eR16G16Snorm, + Format::eR16G16Uscaled, + Format::eR16G16Sscaled, + Format::eR16G16Uint, + Format::eR16G16Sint, + Format::eR16G16Sfloat, + Format::eR16G16B16Unorm, + Format::eR16G16B16Snorm, + Format::eR16G16B16Uscaled, + Format::eR16G16B16Sscaled, + Format::eR16G16B16Uint, + Format::eR16G16B16Sint, + Format::eR16G16B16Sfloat, + Format::eR16G16B16A16Unorm, + Format::eR16G16B16A16Snorm, + Format::eR16G16B16A16Uscaled, + Format::eR16G16B16A16Sscaled, + Format::eR16G16B16A16Uint, + Format::eR16G16B16A16Sint, + Format::eR16G16B16A16Sfloat, + Format::eR32Uint, + Format::eR32Sint, + Format::eR32Sfloat, + Format::eR32G32Uint, + Format::eR32G32Sint, + Format::eR32G32Sfloat, + Format::eR32G32B32Uint, + Format::eR32G32B32Sint, + Format::eR32G32B32Sfloat, + Format::eR32G32B32A32Uint, + Format::eR32G32B32A32Sint, + Format::eR32G32B32A32Sfloat, + Format::eR64Uint, + Format::eR64Sint, + Format::eR64Sfloat, + Format::eR64G64Uint, + Format::eR64G64Sint, + Format::eR64G64Sfloat, + Format::eR64G64B64Uint, + Format::eR64G64B64Sint, + Format::eR64G64B64Sfloat, + Format::eR64G64B64A64Uint, + Format::eR64G64B64A64Sint, + Format::eR64G64B64A64Sfloat, + Format::eB10G11R11UfloatPack32, + Format::eE5B9G9R9UfloatPack32, + Format::eD16Unorm, + Format::eX8D24UnormPack32, + Format::eD32Sfloat, + Format::eS8Uint, + Format::eD16UnormS8Uint, + Format::eD24UnormS8Uint, + Format::eD32SfloatS8Uint, + Format::eBc1RgbUnormBlock, + Format::eBc1RgbSrgbBlock, + Format::eBc1RgbaUnormBlock, + Format::eBc1RgbaSrgbBlock, + Format::eBc2UnormBlock, + Format::eBc2SrgbBlock, + Format::eBc3UnormBlock, + Format::eBc3SrgbBlock, + Format::eBc4UnormBlock, + Format::eBc4SnormBlock, + Format::eBc5UnormBlock, + Format::eBc5SnormBlock, + Format::eBc6HUfloatBlock, + Format::eBc6HSfloatBlock, + Format::eBc7UnormBlock, + Format::eBc7SrgbBlock, + Format::eEtc2R8G8B8UnormBlock, + Format::eEtc2R8G8B8SrgbBlock, + Format::eEtc2R8G8B8A1UnormBlock, + Format::eEtc2R8G8B8A1SrgbBlock, + Format::eEtc2R8G8B8A8UnormBlock, + Format::eEtc2R8G8B8A8SrgbBlock, + Format::eEacR11UnormBlock, + Format::eEacR11SnormBlock, + Format::eEacR11G11UnormBlock, + Format::eEacR11G11SnormBlock, + Format::eAstc4x4UnormBlock, + Format::eAstc4x4SrgbBlock, + Format::eAstc5x4UnormBlock, + Format::eAstc5x4SrgbBlock, + Format::eAstc5x5UnormBlock, + Format::eAstc5x5SrgbBlock, + Format::eAstc6x5UnormBlock, + Format::eAstc6x5SrgbBlock, + Format::eAstc6x6UnormBlock, + Format::eAstc6x6SrgbBlock, + Format::eAstc8x5UnormBlock, + Format::eAstc8x5SrgbBlock, + Format::eAstc8x6UnormBlock, + Format::eAstc8x6SrgbBlock, + Format::eAstc8x8UnormBlock, + Format::eAstc8x8SrgbBlock, + Format::eAstc10x5UnormBlock, + Format::eAstc10x5SrgbBlock, + Format::eAstc10x6UnormBlock, + Format::eAstc10x6SrgbBlock, + Format::eAstc10x8UnormBlock, + Format::eAstc10x8SrgbBlock, + Format::eAstc10x10UnormBlock, + Format::eAstc10x10SrgbBlock, + Format::eAstc12x10UnormBlock, + Format::eAstc12x10SrgbBlock, + Format::eAstc12x12UnormBlock, + Format::eAstc12x12SrgbBlock, + Format::eG8B8G8R8422Unorm, + Format::eB8G8R8G8422Unorm, + Format::eG8B8R83Plane420Unorm, + Format::eG8B8R82Plane420Unorm, + Format::eG8B8R83Plane422Unorm, + Format::eG8B8R82Plane422Unorm, + Format::eG8B8R83Plane444Unorm, + Format::eR10X6UnormPack16, + Format::eR10X6G10X6Unorm2Pack16, + Format::eR10X6G10X6B10X6A10X6Unorm4Pack16, + Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16, + Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16, + Format::eG10X6B10X6R10X63Plane420Unorm3Pack16, + Format::eG10X6B10X6R10X62Plane420Unorm3Pack16, + Format::eG10X6B10X6R10X63Plane422Unorm3Pack16, + Format::eG10X6B10X6R10X62Plane422Unorm3Pack16, + Format::eG10X6B10X6R10X63Plane444Unorm3Pack16, + Format::eR12X4UnormPack16, + Format::eR12X4G12X4Unorm2Pack16, + Format::eR12X4G12X4B12X4A12X4Unorm4Pack16, + Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16, + Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16, + Format::eG12X4B12X4R12X43Plane420Unorm3Pack16, + Format::eG12X4B12X4R12X42Plane420Unorm3Pack16, + Format::eG12X4B12X4R12X43Plane422Unorm3Pack16, + Format::eG12X4B12X4R12X42Plane422Unorm3Pack16, + Format::eG12X4B12X4R12X43Plane444Unorm3Pack16, + Format::eG16B16G16R16422Unorm, + Format::eB16G16R16G16422Unorm, + Format::eG16B16R163Plane420Unorm, + Format::eG16B16R162Plane420Unorm, + Format::eG16B16R163Plane422Unorm, + Format::eG16B16R162Plane422Unorm, + Format::eG16B16R163Plane444Unorm, + Format::eG8B8R82Plane444Unorm, + Format::eG10X6B10X6R10X62Plane444Unorm3Pack16, + Format::eG12X4B12X4R12X42Plane444Unorm3Pack16, + Format::eG16B16R162Plane444Unorm, + Format::eA4R4G4B4UnormPack16, + Format::eA4B4G4R4UnormPack16, + Format::eAstc4x4SfloatBlock, + Format::eAstc5x4SfloatBlock, + Format::eAstc5x5SfloatBlock, + Format::eAstc6x5SfloatBlock, + Format::eAstc6x6SfloatBlock, + Format::eAstc8x5SfloatBlock, + Format::eAstc8x6SfloatBlock, + Format::eAstc8x8SfloatBlock, + Format::eAstc10x5SfloatBlock, + Format::eAstc10x6SfloatBlock, + Format::eAstc10x8SfloatBlock, + Format::eAstc10x10SfloatBlock, + Format::eAstc12x10SfloatBlock, + Format::eAstc12x12SfloatBlock, + Format::eA1B5G5R5UnormPack16, + Format::eA8Unorm, + Format::ePvrtc12BppUnormBlockIMG, + Format::ePvrtc14BppUnormBlockIMG, + Format::ePvrtc22BppUnormBlockIMG, + Format::ePvrtc24BppUnormBlockIMG, + Format::ePvrtc12BppSrgbBlockIMG, + Format::ePvrtc14BppSrgbBlockIMG, + Format::ePvrtc22BppSrgbBlockIMG, + Format::ePvrtc24BppSrgbBlockIMG, + Format::eAstc3x3x3UnormBlockEXT, + Format::eAstc3x3x3SrgbBlockEXT, + Format::eAstc3x3x3SfloatBlockEXT, + Format::eAstc4x3x3UnormBlockEXT, + Format::eAstc4x3x3SrgbBlockEXT, + Format::eAstc4x3x3SfloatBlockEXT, + Format::eAstc4x4x3UnormBlockEXT, + Format::eAstc4x4x3SrgbBlockEXT, + Format::eAstc4x4x3SfloatBlockEXT, + Format::eAstc4x4x4UnormBlockEXT, + Format::eAstc4x4x4SrgbBlockEXT, + Format::eAstc4x4x4SfloatBlockEXT, + Format::eAstc5x4x4UnormBlockEXT, + Format::eAstc5x4x4SrgbBlockEXT, + Format::eAstc5x4x4SfloatBlockEXT, + Format::eAstc5x5x4UnormBlockEXT, + Format::eAstc5x5x4SrgbBlockEXT, + Format::eAstc5x5x4SfloatBlockEXT, + Format::eAstc5x5x5UnormBlockEXT, + Format::eAstc5x5x5SrgbBlockEXT, + Format::eAstc5x5x5SfloatBlockEXT, + Format::eAstc6x5x5UnormBlockEXT, + Format::eAstc6x5x5SrgbBlockEXT, + Format::eAstc6x5x5SfloatBlockEXT, + Format::eAstc6x6x5UnormBlockEXT, + Format::eAstc6x6x5SrgbBlockEXT, + Format::eAstc6x6x5SfloatBlockEXT, + Format::eAstc6x6x6UnormBlockEXT, + Format::eAstc6x6x6SrgbBlockEXT, + Format::eAstc6x6x6SfloatBlockEXT, + Format::eR8BoolARM, + Format::eR16G16Sfixed5NV, + Format::eR10X6UintPack16ARM, + Format::eR10X6G10X6Uint2Pack16ARM, + Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM, + Format::eR12X4UintPack16ARM, + Format::eR12X4G12X4Uint2Pack16ARM, + Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM, + Format::eR14X2UintPack16ARM, + Format::eR14X2G14X2Uint2Pack16ARM, + Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM, + Format::eR14X2UnormPack16ARM, + Format::eR14X2G14X2Unorm2Pack16ARM, + Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM, + Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM, + Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM }; + return allFormats; + } + + // Get all formats with a color component + VULKAN_HPP_INLINE std::vector const & getColorFormats() + { + static std::vector colorFormats = { Format::eR4G4UnormPack8, + Format::eR4G4B4A4UnormPack16, + Format::eB4G4R4A4UnormPack16, + Format::eR5G6B5UnormPack16, + Format::eB5G6R5UnormPack16, + Format::eR5G5B5A1UnormPack16, + Format::eB5G5R5A1UnormPack16, + Format::eA1R5G5B5UnormPack16, + Format::eR8Unorm, + Format::eR8Snorm, + Format::eR8Uscaled, + Format::eR8Sscaled, + Format::eR8Uint, + Format::eR8Sint, + Format::eR8Srgb, + Format::eR8G8Unorm, + Format::eR8G8Snorm, + Format::eR8G8Uscaled, + Format::eR8G8Sscaled, + Format::eR8G8Uint, + Format::eR8G8Sint, + Format::eR8G8Srgb, + Format::eR8G8B8Unorm, + Format::eR8G8B8Snorm, + Format::eR8G8B8Uscaled, + Format::eR8G8B8Sscaled, + Format::eR8G8B8Uint, + Format::eR8G8B8Sint, + Format::eR8G8B8Srgb, + Format::eB8G8R8Unorm, + Format::eB8G8R8Snorm, + Format::eB8G8R8Uscaled, + Format::eB8G8R8Sscaled, + Format::eB8G8R8Uint, + Format::eB8G8R8Sint, + Format::eB8G8R8Srgb, + Format::eR8G8B8A8Unorm, + Format::eR8G8B8A8Snorm, + Format::eR8G8B8A8Uscaled, + Format::eR8G8B8A8Sscaled, + Format::eR8G8B8A8Uint, + Format::eR8G8B8A8Sint, + Format::eR8G8B8A8Srgb, + Format::eB8G8R8A8Unorm, + Format::eB8G8R8A8Snorm, + Format::eB8G8R8A8Uscaled, + Format::eB8G8R8A8Sscaled, + Format::eB8G8R8A8Uint, + Format::eB8G8R8A8Sint, + Format::eB8G8R8A8Srgb, + Format::eA8B8G8R8UnormPack32, + Format::eA8B8G8R8SnormPack32, + Format::eA8B8G8R8UscaledPack32, + Format::eA8B8G8R8SscaledPack32, + Format::eA8B8G8R8UintPack32, + Format::eA8B8G8R8SintPack32, + Format::eA8B8G8R8SrgbPack32, + Format::eA2R10G10B10UnormPack32, + Format::eA2R10G10B10SnormPack32, + Format::eA2R10G10B10UscaledPack32, + Format::eA2R10G10B10SscaledPack32, + Format::eA2R10G10B10UintPack32, + Format::eA2R10G10B10SintPack32, + Format::eA2B10G10R10UnormPack32, + Format::eA2B10G10R10SnormPack32, + Format::eA2B10G10R10UscaledPack32, + Format::eA2B10G10R10SscaledPack32, + Format::eA2B10G10R10UintPack32, + Format::eA2B10G10R10SintPack32, + Format::eR16Unorm, + Format::eR16Snorm, + Format::eR16Uscaled, + Format::eR16Sscaled, + Format::eR16Uint, + Format::eR16Sint, + Format::eR16Sfloat, + Format::eR16G16Unorm, + Format::eR16G16Snorm, + Format::eR16G16Uscaled, + Format::eR16G16Sscaled, + Format::eR16G16Uint, + Format::eR16G16Sint, + Format::eR16G16Sfloat, + Format::eR16G16B16Unorm, + Format::eR16G16B16Snorm, + Format::eR16G16B16Uscaled, + Format::eR16G16B16Sscaled, + Format::eR16G16B16Uint, + Format::eR16G16B16Sint, + Format::eR16G16B16Sfloat, + Format::eR16G16B16A16Unorm, + Format::eR16G16B16A16Snorm, + Format::eR16G16B16A16Uscaled, + Format::eR16G16B16A16Sscaled, + Format::eR16G16B16A16Uint, + Format::eR16G16B16A16Sint, + Format::eR16G16B16A16Sfloat, + Format::eR32Uint, + Format::eR32Sint, + Format::eR32Sfloat, + Format::eR32G32Uint, + Format::eR32G32Sint, + Format::eR32G32Sfloat, + Format::eR32G32B32Uint, + Format::eR32G32B32Sint, + Format::eR32G32B32Sfloat, + Format::eR32G32B32A32Uint, + Format::eR32G32B32A32Sint, + Format::eR32G32B32A32Sfloat, + Format::eR64Uint, + Format::eR64Sint, + Format::eR64Sfloat, + Format::eR64G64Uint, + Format::eR64G64Sint, + Format::eR64G64Sfloat, + Format::eR64G64B64Uint, + Format::eR64G64B64Sint, + Format::eR64G64B64Sfloat, + Format::eR64G64B64A64Uint, + Format::eR64G64B64A64Sint, + Format::eR64G64B64A64Sfloat, + Format::eB10G11R11UfloatPack32, + Format::eE5B9G9R9UfloatPack32, + Format::eBc1RgbUnormBlock, + Format::eBc1RgbSrgbBlock, + Format::eBc1RgbaUnormBlock, + Format::eBc1RgbaSrgbBlock, + Format::eBc2UnormBlock, + Format::eBc2SrgbBlock, + Format::eBc3UnormBlock, + Format::eBc3SrgbBlock, + Format::eBc4UnormBlock, + Format::eBc4SnormBlock, + Format::eBc5UnormBlock, + Format::eBc5SnormBlock, + Format::eBc6HUfloatBlock, + Format::eBc6HSfloatBlock, + Format::eBc7UnormBlock, + Format::eBc7SrgbBlock, + Format::eEtc2R8G8B8UnormBlock, + Format::eEtc2R8G8B8SrgbBlock, + Format::eEtc2R8G8B8A1UnormBlock, + Format::eEtc2R8G8B8A1SrgbBlock, + Format::eEtc2R8G8B8A8UnormBlock, + Format::eEtc2R8G8B8A8SrgbBlock, + Format::eEacR11UnormBlock, + Format::eEacR11SnormBlock, + Format::eEacR11G11UnormBlock, + Format::eEacR11G11SnormBlock, + Format::eAstc4x4UnormBlock, + Format::eAstc4x4SrgbBlock, + Format::eAstc5x4UnormBlock, + Format::eAstc5x4SrgbBlock, + Format::eAstc5x5UnormBlock, + Format::eAstc5x5SrgbBlock, + Format::eAstc6x5UnormBlock, + Format::eAstc6x5SrgbBlock, + Format::eAstc6x6UnormBlock, + Format::eAstc6x6SrgbBlock, + Format::eAstc8x5UnormBlock, + Format::eAstc8x5SrgbBlock, + Format::eAstc8x6UnormBlock, + Format::eAstc8x6SrgbBlock, + Format::eAstc8x8UnormBlock, + Format::eAstc8x8SrgbBlock, + Format::eAstc10x5UnormBlock, + Format::eAstc10x5SrgbBlock, + Format::eAstc10x6UnormBlock, + Format::eAstc10x6SrgbBlock, + Format::eAstc10x8UnormBlock, + Format::eAstc10x8SrgbBlock, + Format::eAstc10x10UnormBlock, + Format::eAstc10x10SrgbBlock, + Format::eAstc12x10UnormBlock, + Format::eAstc12x10SrgbBlock, + Format::eAstc12x12UnormBlock, + Format::eAstc12x12SrgbBlock, + Format::eG8B8G8R8422Unorm, + Format::eB8G8R8G8422Unorm, + Format::eG8B8R83Plane420Unorm, + Format::eG8B8R82Plane420Unorm, + Format::eG8B8R83Plane422Unorm, + Format::eG8B8R82Plane422Unorm, + Format::eG8B8R83Plane444Unorm, + Format::eR10X6UnormPack16, + Format::eR10X6G10X6Unorm2Pack16, + Format::eR10X6G10X6B10X6A10X6Unorm4Pack16, + Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16, + Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16, + Format::eG10X6B10X6R10X63Plane420Unorm3Pack16, + Format::eG10X6B10X6R10X62Plane420Unorm3Pack16, + Format::eG10X6B10X6R10X63Plane422Unorm3Pack16, + Format::eG10X6B10X6R10X62Plane422Unorm3Pack16, + Format::eG10X6B10X6R10X63Plane444Unorm3Pack16, + Format::eR12X4UnormPack16, + Format::eR12X4G12X4Unorm2Pack16, + Format::eR12X4G12X4B12X4A12X4Unorm4Pack16, + Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16, + Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16, + Format::eG12X4B12X4R12X43Plane420Unorm3Pack16, + Format::eG12X4B12X4R12X42Plane420Unorm3Pack16, + Format::eG12X4B12X4R12X43Plane422Unorm3Pack16, + Format::eG12X4B12X4R12X42Plane422Unorm3Pack16, + Format::eG12X4B12X4R12X43Plane444Unorm3Pack16, + Format::eG16B16G16R16422Unorm, + Format::eB16G16R16G16422Unorm, + Format::eG16B16R163Plane420Unorm, + Format::eG16B16R162Plane420Unorm, + Format::eG16B16R163Plane422Unorm, + Format::eG16B16R162Plane422Unorm, + Format::eG16B16R163Plane444Unorm, + Format::eG8B8R82Plane444Unorm, + Format::eG10X6B10X6R10X62Plane444Unorm3Pack16, + Format::eG12X4B12X4R12X42Plane444Unorm3Pack16, + Format::eG16B16R162Plane444Unorm, + Format::eA4R4G4B4UnormPack16, + Format::eA4B4G4R4UnormPack16, + Format::eAstc4x4SfloatBlock, + Format::eAstc5x4SfloatBlock, + Format::eAstc5x5SfloatBlock, + Format::eAstc6x5SfloatBlock, + Format::eAstc6x6SfloatBlock, + Format::eAstc8x5SfloatBlock, + Format::eAstc8x6SfloatBlock, + Format::eAstc8x8SfloatBlock, + Format::eAstc10x5SfloatBlock, + Format::eAstc10x6SfloatBlock, + Format::eAstc10x8SfloatBlock, + Format::eAstc10x10SfloatBlock, + Format::eAstc12x10SfloatBlock, + Format::eAstc12x12SfloatBlock, + Format::eA1B5G5R5UnormPack16, + Format::eA8Unorm, + Format::ePvrtc12BppUnormBlockIMG, + Format::ePvrtc14BppUnormBlockIMG, + Format::ePvrtc22BppUnormBlockIMG, + Format::ePvrtc24BppUnormBlockIMG, + Format::ePvrtc12BppSrgbBlockIMG, + Format::ePvrtc14BppSrgbBlockIMG, + Format::ePvrtc22BppSrgbBlockIMG, + Format::ePvrtc24BppSrgbBlockIMG, + Format::eAstc3x3x3UnormBlockEXT, + Format::eAstc3x3x3SrgbBlockEXT, + Format::eAstc3x3x3SfloatBlockEXT, + Format::eAstc4x3x3UnormBlockEXT, + Format::eAstc4x3x3SrgbBlockEXT, + Format::eAstc4x3x3SfloatBlockEXT, + Format::eAstc4x4x3UnormBlockEXT, + Format::eAstc4x4x3SrgbBlockEXT, + Format::eAstc4x4x3SfloatBlockEXT, + Format::eAstc4x4x4UnormBlockEXT, + Format::eAstc4x4x4SrgbBlockEXT, + Format::eAstc4x4x4SfloatBlockEXT, + Format::eAstc5x4x4UnormBlockEXT, + Format::eAstc5x4x4SrgbBlockEXT, + Format::eAstc5x4x4SfloatBlockEXT, + Format::eAstc5x5x4UnormBlockEXT, + Format::eAstc5x5x4SrgbBlockEXT, + Format::eAstc5x5x4SfloatBlockEXT, + Format::eAstc5x5x5UnormBlockEXT, + Format::eAstc5x5x5SrgbBlockEXT, + Format::eAstc5x5x5SfloatBlockEXT, + Format::eAstc6x5x5UnormBlockEXT, + Format::eAstc6x5x5SrgbBlockEXT, + Format::eAstc6x5x5SfloatBlockEXT, + Format::eAstc6x6x5UnormBlockEXT, + Format::eAstc6x6x5SrgbBlockEXT, + Format::eAstc6x6x5SfloatBlockEXT, + Format::eAstc6x6x6UnormBlockEXT, + Format::eAstc6x6x6SrgbBlockEXT, + Format::eAstc6x6x6SfloatBlockEXT, + Format::eR8BoolARM, + Format::eR16G16Sfixed5NV, + Format::eR10X6UintPack16ARM, + Format::eR10X6G10X6Uint2Pack16ARM, + Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM, + Format::eR12X4UintPack16ARM, + Format::eR12X4G12X4Uint2Pack16ARM, + Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM, + Format::eR14X2UintPack16ARM, + Format::eR14X2G14X2Uint2Pack16ARM, + Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM, + Format::eR14X2UnormPack16ARM, + Format::eR14X2G14X2Unorm2Pack16ARM, + Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM, + Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM, + Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM }; + return colorFormats; + } + + // Get all formats with a depth component + VULKAN_HPP_INLINE std::vector const & getDepthFormats() + { + static std::vector depthFormats = { Format::eD16Unorm, Format::eX8D24UnormPack32, Format::eD32Sfloat, + Format::eD16UnormS8Uint, Format::eD24UnormS8Uint, Format::eD32SfloatS8Uint }; + return depthFormats; + } + + // Get all formats with a depth and a stencil component + VULKAN_HPP_INLINE std::vector const & getDepthStencilFormats() + { + static std::vector depthStencilFormats = { Format::eD16UnormS8Uint, Format::eD24UnormS8Uint, Format::eD32SfloatS8Uint }; + return depthStencilFormats; + } + + // Get all formats with a stencil component + VULKAN_HPP_INLINE std::vector const & getStencilFormats() + { + static std::vector stencilFormats = { Format::eS8Uint, Format::eD16UnormS8Uint, Format::eD24UnormS8Uint, Format::eD32SfloatS8Uint }; + return stencilFormats; + } + + // True, if this format has an alpha component + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasAlphaComponent( Format format ) + { + switch ( format ) + { + case Format::eR4G4B4A4UnormPack16: + case Format::eB4G4R4A4UnormPack16: + case Format::eR5G5B5A1UnormPack16: + case Format::eB5G5R5A1UnormPack16: + case Format::eA1R5G5B5UnormPack16: + case Format::eR8G8B8A8Unorm: + case Format::eR8G8B8A8Snorm: + case Format::eR8G8B8A8Uscaled: + case Format::eR8G8B8A8Sscaled: + case Format::eR8G8B8A8Uint: + case Format::eR8G8B8A8Sint: + case Format::eR8G8B8A8Srgb: + case Format::eB8G8R8A8Unorm: + case Format::eB8G8R8A8Snorm: + case Format::eB8G8R8A8Uscaled: + case Format::eB8G8R8A8Sscaled: + case Format::eB8G8R8A8Uint: + case Format::eB8G8R8A8Sint: + case Format::eB8G8R8A8Srgb: + case Format::eA8B8G8R8UnormPack32: + case Format::eA8B8G8R8SnormPack32: + case Format::eA8B8G8R8UscaledPack32: + case Format::eA8B8G8R8SscaledPack32: + case Format::eA8B8G8R8UintPack32: + case Format::eA8B8G8R8SintPack32: + case Format::eA8B8G8R8SrgbPack32: + case Format::eA2R10G10B10UnormPack32: + case Format::eA2R10G10B10SnormPack32: + case Format::eA2R10G10B10UscaledPack32: + case Format::eA2R10G10B10SscaledPack32: + case Format::eA2R10G10B10UintPack32: + case Format::eA2R10G10B10SintPack32: + case Format::eA2B10G10R10UnormPack32: + case Format::eA2B10G10R10SnormPack32: + case Format::eA2B10G10R10UscaledPack32: + case Format::eA2B10G10R10SscaledPack32: + case Format::eA2B10G10R10UintPack32: + case Format::eA2B10G10R10SintPack32: + case Format::eR16G16B16A16Unorm: + case Format::eR16G16B16A16Snorm: + case Format::eR16G16B16A16Uscaled: + case Format::eR16G16B16A16Sscaled: + case Format::eR16G16B16A16Uint: + case Format::eR16G16B16A16Sint: + case Format::eR16G16B16A16Sfloat: + case Format::eR32G32B32A32Uint: + case Format::eR32G32B32A32Sint: + case Format::eR32G32B32A32Sfloat: + case Format::eR64G64B64A64Uint: + case Format::eR64G64B64A64Sint: + case Format::eR64G64B64A64Sfloat: + case Format::eBc1RgbaUnormBlock: + case Format::eBc1RgbaSrgbBlock: + case Format::eBc2UnormBlock: + case Format::eBc2SrgbBlock: + case Format::eBc3UnormBlock: + case Format::eBc3SrgbBlock: + case Format::eBc7UnormBlock: + case Format::eBc7SrgbBlock: + case Format::eEtc2R8G8B8A1UnormBlock: + case Format::eEtc2R8G8B8A1SrgbBlock: + case Format::eEtc2R8G8B8A8UnormBlock: + case Format::eEtc2R8G8B8A8SrgbBlock: + case Format::eAstc4x4UnormBlock: + case Format::eAstc4x4SrgbBlock: + case Format::eAstc5x4UnormBlock: + case Format::eAstc5x4SrgbBlock: + case Format::eAstc5x5UnormBlock: + case Format::eAstc5x5SrgbBlock: + case Format::eAstc6x5UnormBlock: + case Format::eAstc6x5SrgbBlock: + case Format::eAstc6x6UnormBlock: + case Format::eAstc6x6SrgbBlock: + case Format::eAstc8x5UnormBlock: + case Format::eAstc8x5SrgbBlock: + case Format::eAstc8x6UnormBlock: + case Format::eAstc8x6SrgbBlock: + case Format::eAstc8x8UnormBlock: + case Format::eAstc8x8SrgbBlock: + case Format::eAstc10x5UnormBlock: + case Format::eAstc10x5SrgbBlock: + case Format::eAstc10x6UnormBlock: + case Format::eAstc10x6SrgbBlock: + case Format::eAstc10x8UnormBlock: + case Format::eAstc10x8SrgbBlock: + case Format::eAstc10x10UnormBlock: + case Format::eAstc10x10SrgbBlock: + case Format::eAstc12x10UnormBlock: + case Format::eAstc12x10SrgbBlock: + case Format::eAstc12x12UnormBlock: + case Format::eAstc12x12SrgbBlock: + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: + case Format::eA4R4G4B4UnormPack16: + case Format::eA4B4G4R4UnormPack16: + case Format::eAstc4x4SfloatBlock: + case Format::eAstc5x4SfloatBlock: + case Format::eAstc5x5SfloatBlock: + case Format::eAstc6x5SfloatBlock: + case Format::eAstc6x6SfloatBlock: + case Format::eAstc8x5SfloatBlock: + case Format::eAstc8x6SfloatBlock: + case Format::eAstc8x8SfloatBlock: + case Format::eAstc10x5SfloatBlock: + case Format::eAstc10x6SfloatBlock: + case Format::eAstc10x8SfloatBlock: + case Format::eAstc10x10SfloatBlock: + case Format::eAstc12x10SfloatBlock: + case Format::eAstc12x12SfloatBlock: + case Format::eA1B5G5R5UnormPack16: + case Format::eA8Unorm: + case Format::ePvrtc12BppUnormBlockIMG: + case Format::ePvrtc14BppUnormBlockIMG: + case Format::ePvrtc22BppUnormBlockIMG: + case Format::ePvrtc24BppUnormBlockIMG: + case Format::ePvrtc12BppSrgbBlockIMG: + case Format::ePvrtc14BppSrgbBlockIMG: + case Format::ePvrtc22BppSrgbBlockIMG: + case Format::ePvrtc24BppSrgbBlockIMG: + case Format::eAstc3x3x3UnormBlockEXT: + case Format::eAstc3x3x3SrgbBlockEXT: + case Format::eAstc3x3x3SfloatBlockEXT: + case Format::eAstc4x3x3UnormBlockEXT: + case Format::eAstc4x3x3SrgbBlockEXT: + case Format::eAstc4x3x3SfloatBlockEXT: + case Format::eAstc4x4x3UnormBlockEXT: + case Format::eAstc4x4x3SrgbBlockEXT: + case Format::eAstc4x4x3SfloatBlockEXT: + case Format::eAstc4x4x4UnormBlockEXT: + case Format::eAstc4x4x4SrgbBlockEXT: + case Format::eAstc4x4x4SfloatBlockEXT: + case Format::eAstc5x4x4UnormBlockEXT: + case Format::eAstc5x4x4SrgbBlockEXT: + case Format::eAstc5x4x4SfloatBlockEXT: + case Format::eAstc5x5x4UnormBlockEXT: + case Format::eAstc5x5x4SrgbBlockEXT: + case Format::eAstc5x5x4SfloatBlockEXT: + case Format::eAstc5x5x5UnormBlockEXT: + case Format::eAstc5x5x5SrgbBlockEXT: + case Format::eAstc5x5x5SfloatBlockEXT: + case Format::eAstc6x5x5UnormBlockEXT: + case Format::eAstc6x5x5SrgbBlockEXT: + case Format::eAstc6x5x5SfloatBlockEXT: + case Format::eAstc6x6x5UnormBlockEXT: + case Format::eAstc6x6x5SrgbBlockEXT: + case Format::eAstc6x6x5SfloatBlockEXT: + case Format::eAstc6x6x6UnormBlockEXT: + case Format::eAstc6x6x6SrgbBlockEXT: + case Format::eAstc6x6x6SfloatBlockEXT: + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: return true; + default : return false; + } + } + + // True, if this format has a blue component + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasBlueComponent( Format format ) + { + switch ( format ) + { + case Format::eR4G4B4A4UnormPack16: + case Format::eB4G4R4A4UnormPack16: + case Format::eR5G6B5UnormPack16: + case Format::eB5G6R5UnormPack16: + case Format::eR5G5B5A1UnormPack16: + case Format::eB5G5R5A1UnormPack16: + case Format::eA1R5G5B5UnormPack16: + case Format::eR8G8B8Unorm: + case Format::eR8G8B8Snorm: + case Format::eR8G8B8Uscaled: + case Format::eR8G8B8Sscaled: + case Format::eR8G8B8Uint: + case Format::eR8G8B8Sint: + case Format::eR8G8B8Srgb: + case Format::eB8G8R8Unorm: + case Format::eB8G8R8Snorm: + case Format::eB8G8R8Uscaled: + case Format::eB8G8R8Sscaled: + case Format::eB8G8R8Uint: + case Format::eB8G8R8Sint: + case Format::eB8G8R8Srgb: + case Format::eR8G8B8A8Unorm: + case Format::eR8G8B8A8Snorm: + case Format::eR8G8B8A8Uscaled: + case Format::eR8G8B8A8Sscaled: + case Format::eR8G8B8A8Uint: + case Format::eR8G8B8A8Sint: + case Format::eR8G8B8A8Srgb: + case Format::eB8G8R8A8Unorm: + case Format::eB8G8R8A8Snorm: + case Format::eB8G8R8A8Uscaled: + case Format::eB8G8R8A8Sscaled: + case Format::eB8G8R8A8Uint: + case Format::eB8G8R8A8Sint: + case Format::eB8G8R8A8Srgb: + case Format::eA8B8G8R8UnormPack32: + case Format::eA8B8G8R8SnormPack32: + case Format::eA8B8G8R8UscaledPack32: + case Format::eA8B8G8R8SscaledPack32: + case Format::eA8B8G8R8UintPack32: + case Format::eA8B8G8R8SintPack32: + case Format::eA8B8G8R8SrgbPack32: + case Format::eA2R10G10B10UnormPack32: + case Format::eA2R10G10B10SnormPack32: + case Format::eA2R10G10B10UscaledPack32: + case Format::eA2R10G10B10SscaledPack32: + case Format::eA2R10G10B10UintPack32: + case Format::eA2R10G10B10SintPack32: + case Format::eA2B10G10R10UnormPack32: + case Format::eA2B10G10R10SnormPack32: + case Format::eA2B10G10R10UscaledPack32: + case Format::eA2B10G10R10SscaledPack32: + case Format::eA2B10G10R10UintPack32: + case Format::eA2B10G10R10SintPack32: + case Format::eR16G16B16Unorm: + case Format::eR16G16B16Snorm: + case Format::eR16G16B16Uscaled: + case Format::eR16G16B16Sscaled: + case Format::eR16G16B16Uint: + case Format::eR16G16B16Sint: + case Format::eR16G16B16Sfloat: + case Format::eR16G16B16A16Unorm: + case Format::eR16G16B16A16Snorm: + case Format::eR16G16B16A16Uscaled: + case Format::eR16G16B16A16Sscaled: + case Format::eR16G16B16A16Uint: + case Format::eR16G16B16A16Sint: + case Format::eR16G16B16A16Sfloat: + case Format::eR32G32B32Uint: + case Format::eR32G32B32Sint: + case Format::eR32G32B32Sfloat: + case Format::eR32G32B32A32Uint: + case Format::eR32G32B32A32Sint: + case Format::eR32G32B32A32Sfloat: + case Format::eR64G64B64Uint: + case Format::eR64G64B64Sint: + case Format::eR64G64B64Sfloat: + case Format::eR64G64B64A64Uint: + case Format::eR64G64B64A64Sint: + case Format::eR64G64B64A64Sfloat: + case Format::eB10G11R11UfloatPack32: + case Format::eE5B9G9R9UfloatPack32: + case Format::eBc1RgbUnormBlock: + case Format::eBc1RgbSrgbBlock: + case Format::eBc1RgbaUnormBlock: + case Format::eBc1RgbaSrgbBlock: + case Format::eBc2UnormBlock: + case Format::eBc2SrgbBlock: + case Format::eBc3UnormBlock: + case Format::eBc3SrgbBlock: + case Format::eBc6HUfloatBlock: + case Format::eBc6HSfloatBlock: + case Format::eBc7UnormBlock: + case Format::eBc7SrgbBlock: + case Format::eEtc2R8G8B8UnormBlock: + case Format::eEtc2R8G8B8SrgbBlock: + case Format::eEtc2R8G8B8A1UnormBlock: + case Format::eEtc2R8G8B8A1SrgbBlock: + case Format::eEtc2R8G8B8A8UnormBlock: + case Format::eEtc2R8G8B8A8SrgbBlock: + case Format::eAstc4x4UnormBlock: + case Format::eAstc4x4SrgbBlock: + case Format::eAstc5x4UnormBlock: + case Format::eAstc5x4SrgbBlock: + case Format::eAstc5x5UnormBlock: + case Format::eAstc5x5SrgbBlock: + case Format::eAstc6x5UnormBlock: + case Format::eAstc6x5SrgbBlock: + case Format::eAstc6x6UnormBlock: + case Format::eAstc6x6SrgbBlock: + case Format::eAstc8x5UnormBlock: + case Format::eAstc8x5SrgbBlock: + case Format::eAstc8x6UnormBlock: + case Format::eAstc8x6SrgbBlock: + case Format::eAstc8x8UnormBlock: + case Format::eAstc8x8SrgbBlock: + case Format::eAstc10x5UnormBlock: + case Format::eAstc10x5SrgbBlock: + case Format::eAstc10x6UnormBlock: + case Format::eAstc10x6SrgbBlock: + case Format::eAstc10x8UnormBlock: + case Format::eAstc10x8SrgbBlock: + case Format::eAstc10x10UnormBlock: + case Format::eAstc10x10SrgbBlock: + case Format::eAstc12x10UnormBlock: + case Format::eAstc12x10SrgbBlock: + case Format::eAstc12x12UnormBlock: + case Format::eAstc12x12SrgbBlock: + case Format::eG8B8G8R8422Unorm: + case Format::eB8G8R8G8422Unorm: + case Format::eG8B8R83Plane420Unorm: + case Format::eG8B8R82Plane420Unorm: + case Format::eG8B8R83Plane422Unorm: + case Format::eG8B8R82Plane422Unorm: + case Format::eG8B8R83Plane444Unorm: + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: + case Format::eG16B16G16R16422Unorm: + case Format::eB16G16R16G16422Unorm: + case Format::eG16B16R163Plane420Unorm: + case Format::eG16B16R162Plane420Unorm: + case Format::eG16B16R163Plane422Unorm: + case Format::eG16B16R162Plane422Unorm: + case Format::eG16B16R163Plane444Unorm: + case Format::eG8B8R82Plane444Unorm: + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: + case Format::eG16B16R162Plane444Unorm: + case Format::eA4R4G4B4UnormPack16: + case Format::eA4B4G4R4UnormPack16: + case Format::eAstc4x4SfloatBlock: + case Format::eAstc5x4SfloatBlock: + case Format::eAstc5x5SfloatBlock: + case Format::eAstc6x5SfloatBlock: + case Format::eAstc6x6SfloatBlock: + case Format::eAstc8x5SfloatBlock: + case Format::eAstc8x6SfloatBlock: + case Format::eAstc8x8SfloatBlock: + case Format::eAstc10x5SfloatBlock: + case Format::eAstc10x6SfloatBlock: + case Format::eAstc10x8SfloatBlock: + case Format::eAstc10x10SfloatBlock: + case Format::eAstc12x10SfloatBlock: + case Format::eAstc12x12SfloatBlock: + case Format::eA1B5G5R5UnormPack16: + case Format::ePvrtc12BppUnormBlockIMG: + case Format::ePvrtc14BppUnormBlockIMG: + case Format::ePvrtc22BppUnormBlockIMG: + case Format::ePvrtc24BppUnormBlockIMG: + case Format::ePvrtc12BppSrgbBlockIMG: + case Format::ePvrtc14BppSrgbBlockIMG: + case Format::ePvrtc22BppSrgbBlockIMG: + case Format::ePvrtc24BppSrgbBlockIMG: + case Format::eAstc3x3x3UnormBlockEXT: + case Format::eAstc3x3x3SrgbBlockEXT: + case Format::eAstc3x3x3SfloatBlockEXT: + case Format::eAstc4x3x3UnormBlockEXT: + case Format::eAstc4x3x3SrgbBlockEXT: + case Format::eAstc4x3x3SfloatBlockEXT: + case Format::eAstc4x4x3UnormBlockEXT: + case Format::eAstc4x4x3SrgbBlockEXT: + case Format::eAstc4x4x3SfloatBlockEXT: + case Format::eAstc4x4x4UnormBlockEXT: + case Format::eAstc4x4x4SrgbBlockEXT: + case Format::eAstc4x4x4SfloatBlockEXT: + case Format::eAstc5x4x4UnormBlockEXT: + case Format::eAstc5x4x4SrgbBlockEXT: + case Format::eAstc5x4x4SfloatBlockEXT: + case Format::eAstc5x5x4UnormBlockEXT: + case Format::eAstc5x5x4SrgbBlockEXT: + case Format::eAstc5x5x4SfloatBlockEXT: + case Format::eAstc5x5x5UnormBlockEXT: + case Format::eAstc5x5x5SrgbBlockEXT: + case Format::eAstc5x5x5SfloatBlockEXT: + case Format::eAstc6x5x5UnormBlockEXT: + case Format::eAstc6x5x5SrgbBlockEXT: + case Format::eAstc6x5x5SfloatBlockEXT: + case Format::eAstc6x6x5UnormBlockEXT: + case Format::eAstc6x6x5SrgbBlockEXT: + case Format::eAstc6x6x5SfloatBlockEXT: + case Format::eAstc6x6x6UnormBlockEXT: + case Format::eAstc6x6x6SrgbBlockEXT: + case Format::eAstc6x6x6SfloatBlockEXT: + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return true; + default : return false; + } + } + + // True, if this format has a depth component + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasDepthComponent( Format format ) + { + switch ( format ) + { + case Format::eD16Unorm: + case Format::eX8D24UnormPack32: + case Format::eD32Sfloat: + case Format::eD16UnormS8Uint: + case Format::eD24UnormS8Uint: + case Format::eD32SfloatS8Uint : return true; + default : return false; + } + } + + // True, if this format has a green component + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasGreenComponent( Format format ) + { + switch ( format ) + { + case Format::eR4G4UnormPack8: + case Format::eR4G4B4A4UnormPack16: + case Format::eB4G4R4A4UnormPack16: + case Format::eR5G6B5UnormPack16: + case Format::eB5G6R5UnormPack16: + case Format::eR5G5B5A1UnormPack16: + case Format::eB5G5R5A1UnormPack16: + case Format::eA1R5G5B5UnormPack16: + case Format::eR8G8Unorm: + case Format::eR8G8Snorm: + case Format::eR8G8Uscaled: + case Format::eR8G8Sscaled: + case Format::eR8G8Uint: + case Format::eR8G8Sint: + case Format::eR8G8Srgb: + case Format::eR8G8B8Unorm: + case Format::eR8G8B8Snorm: + case Format::eR8G8B8Uscaled: + case Format::eR8G8B8Sscaled: + case Format::eR8G8B8Uint: + case Format::eR8G8B8Sint: + case Format::eR8G8B8Srgb: + case Format::eB8G8R8Unorm: + case Format::eB8G8R8Snorm: + case Format::eB8G8R8Uscaled: + case Format::eB8G8R8Sscaled: + case Format::eB8G8R8Uint: + case Format::eB8G8R8Sint: + case Format::eB8G8R8Srgb: + case Format::eR8G8B8A8Unorm: + case Format::eR8G8B8A8Snorm: + case Format::eR8G8B8A8Uscaled: + case Format::eR8G8B8A8Sscaled: + case Format::eR8G8B8A8Uint: + case Format::eR8G8B8A8Sint: + case Format::eR8G8B8A8Srgb: + case Format::eB8G8R8A8Unorm: + case Format::eB8G8R8A8Snorm: + case Format::eB8G8R8A8Uscaled: + case Format::eB8G8R8A8Sscaled: + case Format::eB8G8R8A8Uint: + case Format::eB8G8R8A8Sint: + case Format::eB8G8R8A8Srgb: + case Format::eA8B8G8R8UnormPack32: + case Format::eA8B8G8R8SnormPack32: + case Format::eA8B8G8R8UscaledPack32: + case Format::eA8B8G8R8SscaledPack32: + case Format::eA8B8G8R8UintPack32: + case Format::eA8B8G8R8SintPack32: + case Format::eA8B8G8R8SrgbPack32: + case Format::eA2R10G10B10UnormPack32: + case Format::eA2R10G10B10SnormPack32: + case Format::eA2R10G10B10UscaledPack32: + case Format::eA2R10G10B10SscaledPack32: + case Format::eA2R10G10B10UintPack32: + case Format::eA2R10G10B10SintPack32: + case Format::eA2B10G10R10UnormPack32: + case Format::eA2B10G10R10SnormPack32: + case Format::eA2B10G10R10UscaledPack32: + case Format::eA2B10G10R10SscaledPack32: + case Format::eA2B10G10R10UintPack32: + case Format::eA2B10G10R10SintPack32: + case Format::eR16G16Unorm: + case Format::eR16G16Snorm: + case Format::eR16G16Uscaled: + case Format::eR16G16Sscaled: + case Format::eR16G16Uint: + case Format::eR16G16Sint: + case Format::eR16G16Sfloat: + case Format::eR16G16B16Unorm: + case Format::eR16G16B16Snorm: + case Format::eR16G16B16Uscaled: + case Format::eR16G16B16Sscaled: + case Format::eR16G16B16Uint: + case Format::eR16G16B16Sint: + case Format::eR16G16B16Sfloat: + case Format::eR16G16B16A16Unorm: + case Format::eR16G16B16A16Snorm: + case Format::eR16G16B16A16Uscaled: + case Format::eR16G16B16A16Sscaled: + case Format::eR16G16B16A16Uint: + case Format::eR16G16B16A16Sint: + case Format::eR16G16B16A16Sfloat: + case Format::eR32G32Uint: + case Format::eR32G32Sint: + case Format::eR32G32Sfloat: + case Format::eR32G32B32Uint: + case Format::eR32G32B32Sint: + case Format::eR32G32B32Sfloat: + case Format::eR32G32B32A32Uint: + case Format::eR32G32B32A32Sint: + case Format::eR32G32B32A32Sfloat: + case Format::eR64G64Uint: + case Format::eR64G64Sint: + case Format::eR64G64Sfloat: + case Format::eR64G64B64Uint: + case Format::eR64G64B64Sint: + case Format::eR64G64B64Sfloat: + case Format::eR64G64B64A64Uint: + case Format::eR64G64B64A64Sint: + case Format::eR64G64B64A64Sfloat: + case Format::eB10G11R11UfloatPack32: + case Format::eE5B9G9R9UfloatPack32: + case Format::eBc1RgbUnormBlock: + case Format::eBc1RgbSrgbBlock: + case Format::eBc1RgbaUnormBlock: + case Format::eBc1RgbaSrgbBlock: + case Format::eBc2UnormBlock: + case Format::eBc2SrgbBlock: + case Format::eBc3UnormBlock: + case Format::eBc3SrgbBlock: + case Format::eBc5UnormBlock: + case Format::eBc5SnormBlock: + case Format::eBc6HUfloatBlock: + case Format::eBc6HSfloatBlock: + case Format::eBc7UnormBlock: + case Format::eBc7SrgbBlock: + case Format::eEtc2R8G8B8UnormBlock: + case Format::eEtc2R8G8B8SrgbBlock: + case Format::eEtc2R8G8B8A1UnormBlock: + case Format::eEtc2R8G8B8A1SrgbBlock: + case Format::eEtc2R8G8B8A8UnormBlock: + case Format::eEtc2R8G8B8A8SrgbBlock: + case Format::eEacR11G11UnormBlock: + case Format::eEacR11G11SnormBlock: + case Format::eAstc4x4UnormBlock: + case Format::eAstc4x4SrgbBlock: + case Format::eAstc5x4UnormBlock: + case Format::eAstc5x4SrgbBlock: + case Format::eAstc5x5UnormBlock: + case Format::eAstc5x5SrgbBlock: + case Format::eAstc6x5UnormBlock: + case Format::eAstc6x5SrgbBlock: + case Format::eAstc6x6UnormBlock: + case Format::eAstc6x6SrgbBlock: + case Format::eAstc8x5UnormBlock: + case Format::eAstc8x5SrgbBlock: + case Format::eAstc8x6UnormBlock: + case Format::eAstc8x6SrgbBlock: + case Format::eAstc8x8UnormBlock: + case Format::eAstc8x8SrgbBlock: + case Format::eAstc10x5UnormBlock: + case Format::eAstc10x5SrgbBlock: + case Format::eAstc10x6UnormBlock: + case Format::eAstc10x6SrgbBlock: + case Format::eAstc10x8UnormBlock: + case Format::eAstc10x8SrgbBlock: + case Format::eAstc10x10UnormBlock: + case Format::eAstc10x10SrgbBlock: + case Format::eAstc12x10UnormBlock: + case Format::eAstc12x10SrgbBlock: + case Format::eAstc12x12UnormBlock: + case Format::eAstc12x12SrgbBlock: + case Format::eG8B8G8R8422Unorm: + case Format::eB8G8R8G8422Unorm: + case Format::eG8B8R83Plane420Unorm: + case Format::eG8B8R82Plane420Unorm: + case Format::eG8B8R83Plane422Unorm: + case Format::eG8B8R82Plane422Unorm: + case Format::eG8B8R83Plane444Unorm: + case Format::eR10X6G10X6Unorm2Pack16: + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: + case Format::eR12X4G12X4Unorm2Pack16: + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: + case Format::eG16B16G16R16422Unorm: + case Format::eB16G16R16G16422Unorm: + case Format::eG16B16R163Plane420Unorm: + case Format::eG16B16R162Plane420Unorm: + case Format::eG16B16R163Plane422Unorm: + case Format::eG16B16R162Plane422Unorm: + case Format::eG16B16R163Plane444Unorm: + case Format::eG8B8R82Plane444Unorm: + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: + case Format::eG16B16R162Plane444Unorm: + case Format::eA4R4G4B4UnormPack16: + case Format::eA4B4G4R4UnormPack16: + case Format::eAstc4x4SfloatBlock: + case Format::eAstc5x4SfloatBlock: + case Format::eAstc5x5SfloatBlock: + case Format::eAstc6x5SfloatBlock: + case Format::eAstc6x6SfloatBlock: + case Format::eAstc8x5SfloatBlock: + case Format::eAstc8x6SfloatBlock: + case Format::eAstc8x8SfloatBlock: + case Format::eAstc10x5SfloatBlock: + case Format::eAstc10x6SfloatBlock: + case Format::eAstc10x8SfloatBlock: + case Format::eAstc10x10SfloatBlock: + case Format::eAstc12x10SfloatBlock: + case Format::eAstc12x12SfloatBlock: + case Format::eA1B5G5R5UnormPack16: + case Format::ePvrtc12BppUnormBlockIMG: + case Format::ePvrtc14BppUnormBlockIMG: + case Format::ePvrtc22BppUnormBlockIMG: + case Format::ePvrtc24BppUnormBlockIMG: + case Format::ePvrtc12BppSrgbBlockIMG: + case Format::ePvrtc14BppSrgbBlockIMG: + case Format::ePvrtc22BppSrgbBlockIMG: + case Format::ePvrtc24BppSrgbBlockIMG: + case Format::eAstc3x3x3UnormBlockEXT: + case Format::eAstc3x3x3SrgbBlockEXT: + case Format::eAstc3x3x3SfloatBlockEXT: + case Format::eAstc4x3x3UnormBlockEXT: + case Format::eAstc4x3x3SrgbBlockEXT: + case Format::eAstc4x3x3SfloatBlockEXT: + case Format::eAstc4x4x3UnormBlockEXT: + case Format::eAstc4x4x3SrgbBlockEXT: + case Format::eAstc4x4x3SfloatBlockEXT: + case Format::eAstc4x4x4UnormBlockEXT: + case Format::eAstc4x4x4SrgbBlockEXT: + case Format::eAstc4x4x4SfloatBlockEXT: + case Format::eAstc5x4x4UnormBlockEXT: + case Format::eAstc5x4x4SrgbBlockEXT: + case Format::eAstc5x4x4SfloatBlockEXT: + case Format::eAstc5x5x4UnormBlockEXT: + case Format::eAstc5x5x4SrgbBlockEXT: + case Format::eAstc5x5x4SfloatBlockEXT: + case Format::eAstc5x5x5UnormBlockEXT: + case Format::eAstc5x5x5SrgbBlockEXT: + case Format::eAstc5x5x5SfloatBlockEXT: + case Format::eAstc6x5x5UnormBlockEXT: + case Format::eAstc6x5x5SrgbBlockEXT: + case Format::eAstc6x5x5SfloatBlockEXT: + case Format::eAstc6x6x5UnormBlockEXT: + case Format::eAstc6x6x5SrgbBlockEXT: + case Format::eAstc6x6x5SfloatBlockEXT: + case Format::eAstc6x6x6UnormBlockEXT: + case Format::eAstc6x6x6SrgbBlockEXT: + case Format::eAstc6x6x6SfloatBlockEXT: + case Format::eR16G16Sfixed5NV: + case Format::eR10X6G10X6Uint2Pack16ARM: + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: + case Format::eR12X4G12X4Uint2Pack16ARM: + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: + case Format::eR14X2G14X2Uint2Pack16ARM: + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: + case Format::eR14X2G14X2Unorm2Pack16ARM: + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return true; + default : return false; + } + } + + // True, if this format has a red component + VULKAN_HPP_CONSTEXPR_14 bool hasRedComponent( Format format ) + { + switch ( format ) + { + case Format::eR4G4UnormPack8: + case Format::eR4G4B4A4UnormPack16: + case Format::eB4G4R4A4UnormPack16: + case Format::eR5G6B5UnormPack16: + case Format::eB5G6R5UnormPack16: + case Format::eR5G5B5A1UnormPack16: + case Format::eB5G5R5A1UnormPack16: + case Format::eA1R5G5B5UnormPack16: + case Format::eR8Unorm: + case Format::eR8Snorm: + case Format::eR8Uscaled: + case Format::eR8Sscaled: + case Format::eR8Uint: + case Format::eR8Sint: + case Format::eR8Srgb: + case Format::eR8G8Unorm: + case Format::eR8G8Snorm: + case Format::eR8G8Uscaled: + case Format::eR8G8Sscaled: + case Format::eR8G8Uint: + case Format::eR8G8Sint: + case Format::eR8G8Srgb: + case Format::eR8G8B8Unorm: + case Format::eR8G8B8Snorm: + case Format::eR8G8B8Uscaled: + case Format::eR8G8B8Sscaled: + case Format::eR8G8B8Uint: + case Format::eR8G8B8Sint: + case Format::eR8G8B8Srgb: + case Format::eB8G8R8Unorm: + case Format::eB8G8R8Snorm: + case Format::eB8G8R8Uscaled: + case Format::eB8G8R8Sscaled: + case Format::eB8G8R8Uint: + case Format::eB8G8R8Sint: + case Format::eB8G8R8Srgb: + case Format::eR8G8B8A8Unorm: + case Format::eR8G8B8A8Snorm: + case Format::eR8G8B8A8Uscaled: + case Format::eR8G8B8A8Sscaled: + case Format::eR8G8B8A8Uint: + case Format::eR8G8B8A8Sint: + case Format::eR8G8B8A8Srgb: + case Format::eB8G8R8A8Unorm: + case Format::eB8G8R8A8Snorm: + case Format::eB8G8R8A8Uscaled: + case Format::eB8G8R8A8Sscaled: + case Format::eB8G8R8A8Uint: + case Format::eB8G8R8A8Sint: + case Format::eB8G8R8A8Srgb: + case Format::eA8B8G8R8UnormPack32: + case Format::eA8B8G8R8SnormPack32: + case Format::eA8B8G8R8UscaledPack32: + case Format::eA8B8G8R8SscaledPack32: + case Format::eA8B8G8R8UintPack32: + case Format::eA8B8G8R8SintPack32: + case Format::eA8B8G8R8SrgbPack32: + case Format::eA2R10G10B10UnormPack32: + case Format::eA2R10G10B10SnormPack32: + case Format::eA2R10G10B10UscaledPack32: + case Format::eA2R10G10B10SscaledPack32: + case Format::eA2R10G10B10UintPack32: + case Format::eA2R10G10B10SintPack32: + case Format::eA2B10G10R10UnormPack32: + case Format::eA2B10G10R10SnormPack32: + case Format::eA2B10G10R10UscaledPack32: + case Format::eA2B10G10R10SscaledPack32: + case Format::eA2B10G10R10UintPack32: + case Format::eA2B10G10R10SintPack32: + case Format::eR16Unorm: + case Format::eR16Snorm: + case Format::eR16Uscaled: + case Format::eR16Sscaled: + case Format::eR16Uint: + case Format::eR16Sint: + case Format::eR16Sfloat: + case Format::eR16G16Unorm: + case Format::eR16G16Snorm: + case Format::eR16G16Uscaled: + case Format::eR16G16Sscaled: + case Format::eR16G16Uint: + case Format::eR16G16Sint: + case Format::eR16G16Sfloat: + case Format::eR16G16B16Unorm: + case Format::eR16G16B16Snorm: + case Format::eR16G16B16Uscaled: + case Format::eR16G16B16Sscaled: + case Format::eR16G16B16Uint: + case Format::eR16G16B16Sint: + case Format::eR16G16B16Sfloat: + case Format::eR16G16B16A16Unorm: + case Format::eR16G16B16A16Snorm: + case Format::eR16G16B16A16Uscaled: + case Format::eR16G16B16A16Sscaled: + case Format::eR16G16B16A16Uint: + case Format::eR16G16B16A16Sint: + case Format::eR16G16B16A16Sfloat: + case Format::eR32Uint: + case Format::eR32Sint: + case Format::eR32Sfloat: + case Format::eR32G32Uint: + case Format::eR32G32Sint: + case Format::eR32G32Sfloat: + case Format::eR32G32B32Uint: + case Format::eR32G32B32Sint: + case Format::eR32G32B32Sfloat: + case Format::eR32G32B32A32Uint: + case Format::eR32G32B32A32Sint: + case Format::eR32G32B32A32Sfloat: + case Format::eR64Uint: + case Format::eR64Sint: + case Format::eR64Sfloat: + case Format::eR64G64Uint: + case Format::eR64G64Sint: + case Format::eR64G64Sfloat: + case Format::eR64G64B64Uint: + case Format::eR64G64B64Sint: + case Format::eR64G64B64Sfloat: + case Format::eR64G64B64A64Uint: + case Format::eR64G64B64A64Sint: + case Format::eR64G64B64A64Sfloat: + case Format::eB10G11R11UfloatPack32: + case Format::eE5B9G9R9UfloatPack32: + case Format::eBc1RgbUnormBlock: + case Format::eBc1RgbSrgbBlock: + case Format::eBc1RgbaUnormBlock: + case Format::eBc1RgbaSrgbBlock: + case Format::eBc2UnormBlock: + case Format::eBc2SrgbBlock: + case Format::eBc3UnormBlock: + case Format::eBc3SrgbBlock: + case Format::eBc4UnormBlock: + case Format::eBc4SnormBlock: + case Format::eBc5UnormBlock: + case Format::eBc5SnormBlock: + case Format::eBc6HUfloatBlock: + case Format::eBc6HSfloatBlock: + case Format::eBc7UnormBlock: + case Format::eBc7SrgbBlock: + case Format::eEtc2R8G8B8UnormBlock: + case Format::eEtc2R8G8B8SrgbBlock: + case Format::eEtc2R8G8B8A1UnormBlock: + case Format::eEtc2R8G8B8A1SrgbBlock: + case Format::eEtc2R8G8B8A8UnormBlock: + case Format::eEtc2R8G8B8A8SrgbBlock: + case Format::eEacR11UnormBlock: + case Format::eEacR11SnormBlock: + case Format::eEacR11G11UnormBlock: + case Format::eEacR11G11SnormBlock: + case Format::eAstc4x4UnormBlock: + case Format::eAstc4x4SrgbBlock: + case Format::eAstc5x4UnormBlock: + case Format::eAstc5x4SrgbBlock: + case Format::eAstc5x5UnormBlock: + case Format::eAstc5x5SrgbBlock: + case Format::eAstc6x5UnormBlock: + case Format::eAstc6x5SrgbBlock: + case Format::eAstc6x6UnormBlock: + case Format::eAstc6x6SrgbBlock: + case Format::eAstc8x5UnormBlock: + case Format::eAstc8x5SrgbBlock: + case Format::eAstc8x6UnormBlock: + case Format::eAstc8x6SrgbBlock: + case Format::eAstc8x8UnormBlock: + case Format::eAstc8x8SrgbBlock: + case Format::eAstc10x5UnormBlock: + case Format::eAstc10x5SrgbBlock: + case Format::eAstc10x6UnormBlock: + case Format::eAstc10x6SrgbBlock: + case Format::eAstc10x8UnormBlock: + case Format::eAstc10x8SrgbBlock: + case Format::eAstc10x10UnormBlock: + case Format::eAstc10x10SrgbBlock: + case Format::eAstc12x10UnormBlock: + case Format::eAstc12x10SrgbBlock: + case Format::eAstc12x12UnormBlock: + case Format::eAstc12x12SrgbBlock: + case Format::eG8B8G8R8422Unorm: + case Format::eB8G8R8G8422Unorm: + case Format::eG8B8R83Plane420Unorm: + case Format::eG8B8R82Plane420Unorm: + case Format::eG8B8R83Plane422Unorm: + case Format::eG8B8R82Plane422Unorm: + case Format::eG8B8R83Plane444Unorm: + case Format::eR10X6UnormPack16: + case Format::eR10X6G10X6Unorm2Pack16: + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: + case Format::eR12X4UnormPack16: + case Format::eR12X4G12X4Unorm2Pack16: + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: + case Format::eG16B16G16R16422Unorm: + case Format::eB16G16R16G16422Unorm: + case Format::eG16B16R163Plane420Unorm: + case Format::eG16B16R162Plane420Unorm: + case Format::eG16B16R163Plane422Unorm: + case Format::eG16B16R162Plane422Unorm: + case Format::eG16B16R163Plane444Unorm: + case Format::eG8B8R82Plane444Unorm: + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: + case Format::eG16B16R162Plane444Unorm: + case Format::eA4R4G4B4UnormPack16: + case Format::eA4B4G4R4UnormPack16: + case Format::eAstc4x4SfloatBlock: + case Format::eAstc5x4SfloatBlock: + case Format::eAstc5x5SfloatBlock: + case Format::eAstc6x5SfloatBlock: + case Format::eAstc6x6SfloatBlock: + case Format::eAstc8x5SfloatBlock: + case Format::eAstc8x6SfloatBlock: + case Format::eAstc8x8SfloatBlock: + case Format::eAstc10x5SfloatBlock: + case Format::eAstc10x6SfloatBlock: + case Format::eAstc10x8SfloatBlock: + case Format::eAstc10x10SfloatBlock: + case Format::eAstc12x10SfloatBlock: + case Format::eAstc12x12SfloatBlock: + case Format::eA1B5G5R5UnormPack16: + case Format::ePvrtc12BppUnormBlockIMG: + case Format::ePvrtc14BppUnormBlockIMG: + case Format::ePvrtc22BppUnormBlockIMG: + case Format::ePvrtc24BppUnormBlockIMG: + case Format::ePvrtc12BppSrgbBlockIMG: + case Format::ePvrtc14BppSrgbBlockIMG: + case Format::ePvrtc22BppSrgbBlockIMG: + case Format::ePvrtc24BppSrgbBlockIMG: + case Format::eAstc3x3x3UnormBlockEXT: + case Format::eAstc3x3x3SrgbBlockEXT: + case Format::eAstc3x3x3SfloatBlockEXT: + case Format::eAstc4x3x3UnormBlockEXT: + case Format::eAstc4x3x3SrgbBlockEXT: + case Format::eAstc4x3x3SfloatBlockEXT: + case Format::eAstc4x4x3UnormBlockEXT: + case Format::eAstc4x4x3SrgbBlockEXT: + case Format::eAstc4x4x3SfloatBlockEXT: + case Format::eAstc4x4x4UnormBlockEXT: + case Format::eAstc4x4x4SrgbBlockEXT: + case Format::eAstc4x4x4SfloatBlockEXT: + case Format::eAstc5x4x4UnormBlockEXT: + case Format::eAstc5x4x4SrgbBlockEXT: + case Format::eAstc5x4x4SfloatBlockEXT: + case Format::eAstc5x5x4UnormBlockEXT: + case Format::eAstc5x5x4SrgbBlockEXT: + case Format::eAstc5x5x4SfloatBlockEXT: + case Format::eAstc5x5x5UnormBlockEXT: + case Format::eAstc5x5x5SrgbBlockEXT: + case Format::eAstc5x5x5SfloatBlockEXT: + case Format::eAstc6x5x5UnormBlockEXT: + case Format::eAstc6x5x5SrgbBlockEXT: + case Format::eAstc6x5x5SfloatBlockEXT: + case Format::eAstc6x6x5UnormBlockEXT: + case Format::eAstc6x6x5SrgbBlockEXT: + case Format::eAstc6x6x5SfloatBlockEXT: + case Format::eAstc6x6x6UnormBlockEXT: + case Format::eAstc6x6x6SrgbBlockEXT: + case Format::eAstc6x6x6SfloatBlockEXT: + case Format::eR8BoolARM: + case Format::eR16G16Sfixed5NV: + case Format::eR10X6UintPack16ARM: + case Format::eR10X6G10X6Uint2Pack16ARM: + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: + case Format::eR12X4UintPack16ARM: + case Format::eR12X4G12X4Uint2Pack16ARM: + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: + case Format::eR14X2UintPack16ARM: + case Format::eR14X2G14X2Uint2Pack16ARM: + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: + case Format::eR14X2UnormPack16ARM: + case Format::eR14X2G14X2Unorm2Pack16ARM: + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return true; + default : return false; + } + } + + // True, if this format has a stencil component + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasStencilComponent( Format format ) + { + switch ( format ) + { + case Format::eS8Uint: + case Format::eD16UnormS8Uint: + case Format::eD24UnormS8Uint: + case Format::eD32SfloatS8Uint: return true; + default : return false; + } + } + + // True, if this format is a color. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool isColor( Format format ) + { + return hasRedComponent( format ) || hasGreenComponent( format ) || hasBlueComponent( format ) || hasAlphaComponent( format ); + } + + // True, if this format is a compressed one. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool isCompressed( Format format ) + { + return ( *compressionScheme( format ) != 0 ); + } + + // The number of bits into which the format is packed. A single image element in this format + // can be stored in the same space as a scalar type of this bit width. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t packed( Format format ) + { + switch ( format ) + { + case Format::eR4G4UnormPack8 : return 8; + case Format::eR4G4B4A4UnormPack16 : return 16; + case Format::eB4G4R4A4UnormPack16 : return 16; + case Format::eR5G6B5UnormPack16 : return 16; + case Format::eB5G6R5UnormPack16 : return 16; + case Format::eR5G5B5A1UnormPack16 : return 16; + case Format::eB5G5R5A1UnormPack16 : return 16; + case Format::eA1R5G5B5UnormPack16 : return 16; + case Format::eA8B8G8R8UnormPack32 : return 32; + case Format::eA8B8G8R8SnormPack32 : return 32; + case Format::eA8B8G8R8UscaledPack32 : return 32; + case Format::eA8B8G8R8SscaledPack32 : return 32; + case Format::eA8B8G8R8UintPack32 : return 32; + case Format::eA8B8G8R8SintPack32 : return 32; + case Format::eA8B8G8R8SrgbPack32 : return 32; + case Format::eA2R10G10B10UnormPack32 : return 32; + case Format::eA2R10G10B10SnormPack32 : return 32; + case Format::eA2R10G10B10UscaledPack32 : return 32; + case Format::eA2R10G10B10SscaledPack32 : return 32; + case Format::eA2R10G10B10UintPack32 : return 32; + case Format::eA2R10G10B10SintPack32 : return 32; + case Format::eA2B10G10R10UnormPack32 : return 32; + case Format::eA2B10G10R10SnormPack32 : return 32; + case Format::eA2B10G10R10UscaledPack32 : return 32; + case Format::eA2B10G10R10SscaledPack32 : return 32; + case Format::eA2B10G10R10UintPack32 : return 32; + case Format::eA2B10G10R10SintPack32 : return 32; + case Format::eB10G11R11UfloatPack32 : return 32; + case Format::eE5B9G9R9UfloatPack32 : return 32; + case Format::eX8D24UnormPack32 : return 32; + case Format::eR10X6UnormPack16 : return 16; + case Format::eR10X6G10X6Unorm2Pack16 : return 16; + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return 16; + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return 16; + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return 16; + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return 16; + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return 16; + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return 16; + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return 16; + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return 16; + case Format::eR12X4UnormPack16 : return 16; + case Format::eR12X4G12X4Unorm2Pack16 : return 16; + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return 16; + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return 16; + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return 16; + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return 16; + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return 16; + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return 16; + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return 16; + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return 16; + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return 16; + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return 16; + case Format::eA4R4G4B4UnormPack16 : return 16; + case Format::eA4B4G4R4UnormPack16 : return 16; + case Format::eA1B5G5R5UnormPack16 : return 16; + case Format::eR10X6UintPack16ARM : return 16; + case Format::eR10X6G10X6Uint2Pack16ARM : return 16; + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return 16; + case Format::eR12X4UintPack16ARM : return 16; + case Format::eR12X4G12X4Uint2Pack16ARM : return 16; + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return 16; + case Format::eR14X2UintPack16ARM : return 16; + case Format::eR14X2G14X2Uint2Pack16ARM : return 16; + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return 16; + case Format::eR14X2UnormPack16ARM : return 16; + case Format::eR14X2G14X2Unorm2Pack16ARM : return 16; + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return 16; + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return 16; + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return 16; + + default: return 0; + } + } + + // The single-plane format that this plane is compatible with. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 Format planeCompatibleFormat( Format format, uint8_t plane ) + { + switch ( format ) + { + case Format::eG8B8R83Plane420Unorm: + switch ( plane ) + { + case 0 : return Format::eR8Unorm; + case 1 : return Format::eR8Unorm; + case 2 : return Format::eR8Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG8B8R82Plane420Unorm: + switch ( plane ) + { + case 0 : return Format::eR8Unorm; + case 1 : return Format::eR8G8Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG8B8R83Plane422Unorm: + switch ( plane ) + { + case 0 : return Format::eR8Unorm; + case 1 : return Format::eR8Unorm; + case 2 : return Format::eR8Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG8B8R82Plane422Unorm: + switch ( plane ) + { + case 0 : return Format::eR8Unorm; + case 1 : return Format::eR8G8Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG8B8R83Plane444Unorm: + switch ( plane ) + { + case 0 : return Format::eR8Unorm; + case 1 : return Format::eR8Unorm; + case 2 : return Format::eR8Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR10X6UnormPack16; + case 1 : return Format::eR10X6UnormPack16; + case 2 : return Format::eR10X6UnormPack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR10X6UnormPack16; + case 1 : return Format::eR10X6G10X6Unorm2Pack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR10X6UnormPack16; + case 1 : return Format::eR10X6UnormPack16; + case 2 : return Format::eR10X6UnormPack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR10X6UnormPack16; + case 1 : return Format::eR10X6G10X6Unorm2Pack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR10X6UnormPack16; + case 1 : return Format::eR10X6UnormPack16; + case 2 : return Format::eR10X6UnormPack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR12X4UnormPack16; + case 1 : return Format::eR12X4UnormPack16; + case 2 : return Format::eR12X4UnormPack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR12X4UnormPack16; + case 1 : return Format::eR12X4G12X4Unorm2Pack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR12X4UnormPack16; + case 1 : return Format::eR12X4UnormPack16; + case 2 : return Format::eR12X4UnormPack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR12X4UnormPack16; + case 1 : return Format::eR12X4G12X4Unorm2Pack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR12X4UnormPack16; + case 1 : return Format::eR12X4UnormPack16; + case 2 : return Format::eR12X4UnormPack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG16B16R163Plane420Unorm: + switch ( plane ) + { + case 0 : return Format::eR16Unorm; + case 1 : return Format::eR16Unorm; + case 2 : return Format::eR16Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG16B16R162Plane420Unorm: + switch ( plane ) + { + case 0 : return Format::eR16Unorm; + case 1 : return Format::eR16G16Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG16B16R163Plane422Unorm: + switch ( plane ) + { + case 0 : return Format::eR16Unorm; + case 1 : return Format::eR16Unorm; + case 2 : return Format::eR16Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG16B16R162Plane422Unorm: + switch ( plane ) + { + case 0 : return Format::eR16Unorm; + case 1 : return Format::eR16G16Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG16B16R163Plane444Unorm: + switch ( plane ) + { + case 0 : return Format::eR16Unorm; + case 1 : return Format::eR16Unorm; + case 2 : return Format::eR16Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG8B8R82Plane444Unorm: + switch ( plane ) + { + case 0 : return Format::eR8Unorm; + case 1 : return Format::eR8G8Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR10X6UnormPack16; + case 1 : return Format::eR10X6G10X6Unorm2Pack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return Format::eR12X4UnormPack16; + case 1 : return Format::eR12X4G12X4Unorm2Pack16; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG16B16R162Plane444Unorm: + switch ( plane ) + { + case 0 : return Format::eR16Unorm; + case 1 : return Format::eR16G16Unorm; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: + switch ( plane ) + { + case 0 : return Format::eR14X2UnormPack16ARM; + case 1 : return Format::eR14X2G14X2Unorm2Pack16ARM; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: + switch ( plane ) + { + case 0 : return Format::eR14X2UnormPack16ARM; + case 1 : return Format::eR14X2G14X2Unorm2Pack16ARM; + default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; + } + + default: VULKAN_HPP_ASSERT( plane == 0 ); return format; + } + } + + // The number of image planes of this format. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t planeCount( Format format ) + { + switch ( format ) + { + case Format::eG8B8R83Plane420Unorm : return 3; + case Format::eG8B8R82Plane420Unorm : return 2; + case Format::eG8B8R83Plane422Unorm : return 3; + case Format::eG8B8R82Plane422Unorm : return 2; + case Format::eG8B8R83Plane444Unorm : return 3; + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return 3; + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return 2; + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return 3; + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return 2; + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return 3; + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return 3; + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return 2; + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return 3; + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return 2; + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return 3; + case Format::eG16B16R163Plane420Unorm : return 3; + case Format::eG16B16R162Plane420Unorm : return 2; + case Format::eG16B16R163Plane422Unorm : return 3; + case Format::eG16B16R162Plane422Unorm : return 2; + case Format::eG16B16R163Plane444Unorm : return 3; + case Format::eG8B8R82Plane444Unorm : return 2; + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return 2; + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return 2; + case Format::eG16B16R162Plane444Unorm : return 2; + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return 2; + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return 2; + + default: return 1; + } + } + + // The relative height of this plane. A value of k means that this plane is 1/k the height of the overall format. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t planeHeightDivisor( Format format, uint8_t plane ) + { + switch ( format ) + { + case Format::eG8B8R83Plane420Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG8B8R82Plane420Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG8B8R83Plane422Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG8B8R82Plane422Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG8B8R83Plane444Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R163Plane420Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R162Plane420Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R163Plane422Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R162Plane422Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R163Plane444Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG8B8R82Plane444Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R162Plane444Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + + default: VULKAN_HPP_ASSERT( plane == 0 ); return 1; + } + } + + // The relative width of this plane. A value of k means that this plane is 1/k the width of the overall format. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t planeWidthDivisor( Format format, uint8_t plane ) + { + switch ( format ) + { + case Format::eG8B8R83Plane420Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG8B8R82Plane420Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG8B8R83Plane422Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG8B8R82Plane422Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG8B8R83Plane444Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R163Plane420Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R162Plane420Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R163Plane422Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + case 2 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R162Plane422Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R163Plane444Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + case 2 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG8B8R82Plane444Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG16B16R162Plane444Unorm: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 1; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: + switch ( plane ) + { + case 0 : return 1; + case 1 : return 2; + default: VULKAN_HPP_ASSERT( false ); return 1; + } + + default: VULKAN_HPP_ASSERT( plane == 0 ); return 1; + } + } + + // The number of texels in a texel block. + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t texelsPerBlock( Format format ) + { + switch ( format ) + { + case Format::eR4G4UnormPack8 : return 1; + case Format::eR4G4B4A4UnormPack16 : return 1; + case Format::eB4G4R4A4UnormPack16 : return 1; + case Format::eR5G6B5UnormPack16 : return 1; + case Format::eB5G6R5UnormPack16 : return 1; + case Format::eR5G5B5A1UnormPack16 : return 1; + case Format::eB5G5R5A1UnormPack16 : return 1; + case Format::eA1R5G5B5UnormPack16 : return 1; + case Format::eR8Unorm : return 1; + case Format::eR8Snorm : return 1; + case Format::eR8Uscaled : return 1; + case Format::eR8Sscaled : return 1; + case Format::eR8Uint : return 1; + case Format::eR8Sint : return 1; + case Format::eR8Srgb : return 1; + case Format::eR8G8Unorm : return 1; + case Format::eR8G8Snorm : return 1; + case Format::eR8G8Uscaled : return 1; + case Format::eR8G8Sscaled : return 1; + case Format::eR8G8Uint : return 1; + case Format::eR8G8Sint : return 1; + case Format::eR8G8Srgb : return 1; + case Format::eR8G8B8Unorm : return 1; + case Format::eR8G8B8Snorm : return 1; + case Format::eR8G8B8Uscaled : return 1; + case Format::eR8G8B8Sscaled : return 1; + case Format::eR8G8B8Uint : return 1; + case Format::eR8G8B8Sint : return 1; + case Format::eR8G8B8Srgb : return 1; + case Format::eB8G8R8Unorm : return 1; + case Format::eB8G8R8Snorm : return 1; + case Format::eB8G8R8Uscaled : return 1; + case Format::eB8G8R8Sscaled : return 1; + case Format::eB8G8R8Uint : return 1; + case Format::eB8G8R8Sint : return 1; + case Format::eB8G8R8Srgb : return 1; + case Format::eR8G8B8A8Unorm : return 1; + case Format::eR8G8B8A8Snorm : return 1; + case Format::eR8G8B8A8Uscaled : return 1; + case Format::eR8G8B8A8Sscaled : return 1; + case Format::eR8G8B8A8Uint : return 1; + case Format::eR8G8B8A8Sint : return 1; + case Format::eR8G8B8A8Srgb : return 1; + case Format::eB8G8R8A8Unorm : return 1; + case Format::eB8G8R8A8Snorm : return 1; + case Format::eB8G8R8A8Uscaled : return 1; + case Format::eB8G8R8A8Sscaled : return 1; + case Format::eB8G8R8A8Uint : return 1; + case Format::eB8G8R8A8Sint : return 1; + case Format::eB8G8R8A8Srgb : return 1; + case Format::eA8B8G8R8UnormPack32 : return 1; + case Format::eA8B8G8R8SnormPack32 : return 1; + case Format::eA8B8G8R8UscaledPack32 : return 1; + case Format::eA8B8G8R8SscaledPack32 : return 1; + case Format::eA8B8G8R8UintPack32 : return 1; + case Format::eA8B8G8R8SintPack32 : return 1; + case Format::eA8B8G8R8SrgbPack32 : return 1; + case Format::eA2R10G10B10UnormPack32 : return 1; + case Format::eA2R10G10B10SnormPack32 : return 1; + case Format::eA2R10G10B10UscaledPack32 : return 1; + case Format::eA2R10G10B10SscaledPack32 : return 1; + case Format::eA2R10G10B10UintPack32 : return 1; + case Format::eA2R10G10B10SintPack32 : return 1; + case Format::eA2B10G10R10UnormPack32 : return 1; + case Format::eA2B10G10R10SnormPack32 : return 1; + case Format::eA2B10G10R10UscaledPack32 : return 1; + case Format::eA2B10G10R10SscaledPack32 : return 1; + case Format::eA2B10G10R10UintPack32 : return 1; + case Format::eA2B10G10R10SintPack32 : return 1; + case Format::eR16Unorm : return 1; + case Format::eR16Snorm : return 1; + case Format::eR16Uscaled : return 1; + case Format::eR16Sscaled : return 1; + case Format::eR16Uint : return 1; + case Format::eR16Sint : return 1; + case Format::eR16Sfloat : return 1; + case Format::eR16G16Unorm : return 1; + case Format::eR16G16Snorm : return 1; + case Format::eR16G16Uscaled : return 1; + case Format::eR16G16Sscaled : return 1; + case Format::eR16G16Uint : return 1; + case Format::eR16G16Sint : return 1; + case Format::eR16G16Sfloat : return 1; + case Format::eR16G16B16Unorm : return 1; + case Format::eR16G16B16Snorm : return 1; + case Format::eR16G16B16Uscaled : return 1; + case Format::eR16G16B16Sscaled : return 1; + case Format::eR16G16B16Uint : return 1; + case Format::eR16G16B16Sint : return 1; + case Format::eR16G16B16Sfloat : return 1; + case Format::eR16G16B16A16Unorm : return 1; + case Format::eR16G16B16A16Snorm : return 1; + case Format::eR16G16B16A16Uscaled : return 1; + case Format::eR16G16B16A16Sscaled : return 1; + case Format::eR16G16B16A16Uint : return 1; + case Format::eR16G16B16A16Sint : return 1; + case Format::eR16G16B16A16Sfloat : return 1; + case Format::eR32Uint : return 1; + case Format::eR32Sint : return 1; + case Format::eR32Sfloat : return 1; + case Format::eR32G32Uint : return 1; + case Format::eR32G32Sint : return 1; + case Format::eR32G32Sfloat : return 1; + case Format::eR32G32B32Uint : return 1; + case Format::eR32G32B32Sint : return 1; + case Format::eR32G32B32Sfloat : return 1; + case Format::eR32G32B32A32Uint : return 1; + case Format::eR32G32B32A32Sint : return 1; + case Format::eR32G32B32A32Sfloat : return 1; + case Format::eR64Uint : return 1; + case Format::eR64Sint : return 1; + case Format::eR64Sfloat : return 1; + case Format::eR64G64Uint : return 1; + case Format::eR64G64Sint : return 1; + case Format::eR64G64Sfloat : return 1; + case Format::eR64G64B64Uint : return 1; + case Format::eR64G64B64Sint : return 1; + case Format::eR64G64B64Sfloat : return 1; + case Format::eR64G64B64A64Uint : return 1; + case Format::eR64G64B64A64Sint : return 1; + case Format::eR64G64B64A64Sfloat : return 1; + case Format::eB10G11R11UfloatPack32 : return 1; + case Format::eE5B9G9R9UfloatPack32 : return 1; + case Format::eD16Unorm : return 1; + case Format::eX8D24UnormPack32 : return 1; + case Format::eD32Sfloat : return 1; + case Format::eS8Uint : return 1; + case Format::eD16UnormS8Uint : return 1; + case Format::eD24UnormS8Uint : return 1; + case Format::eD32SfloatS8Uint : return 1; + case Format::eBc1RgbUnormBlock : return 16; + case Format::eBc1RgbSrgbBlock : return 16; + case Format::eBc1RgbaUnormBlock : return 16; + case Format::eBc1RgbaSrgbBlock : return 16; + case Format::eBc2UnormBlock : return 16; + case Format::eBc2SrgbBlock : return 16; + case Format::eBc3UnormBlock : return 16; + case Format::eBc3SrgbBlock : return 16; + case Format::eBc4UnormBlock : return 16; + case Format::eBc4SnormBlock : return 16; + case Format::eBc5UnormBlock : return 16; + case Format::eBc5SnormBlock : return 16; + case Format::eBc6HUfloatBlock : return 16; + case Format::eBc6HSfloatBlock : return 16; + case Format::eBc7UnormBlock : return 16; + case Format::eBc7SrgbBlock : return 16; + case Format::eEtc2R8G8B8UnormBlock : return 16; + case Format::eEtc2R8G8B8SrgbBlock : return 16; + case Format::eEtc2R8G8B8A1UnormBlock : return 16; + case Format::eEtc2R8G8B8A1SrgbBlock : return 16; + case Format::eEtc2R8G8B8A8UnormBlock : return 16; + case Format::eEtc2R8G8B8A8SrgbBlock : return 16; + case Format::eEacR11UnormBlock : return 16; + case Format::eEacR11SnormBlock : return 16; + case Format::eEacR11G11UnormBlock : return 16; + case Format::eEacR11G11SnormBlock : return 16; + case Format::eAstc4x4UnormBlock : return 16; + case Format::eAstc4x4SrgbBlock : return 16; + case Format::eAstc5x4UnormBlock : return 20; + case Format::eAstc5x4SrgbBlock : return 20; + case Format::eAstc5x5UnormBlock : return 25; + case Format::eAstc5x5SrgbBlock : return 25; + case Format::eAstc6x5UnormBlock : return 30; + case Format::eAstc6x5SrgbBlock : return 30; + case Format::eAstc6x6UnormBlock : return 36; + case Format::eAstc6x6SrgbBlock : return 36; + case Format::eAstc8x5UnormBlock : return 40; + case Format::eAstc8x5SrgbBlock : return 40; + case Format::eAstc8x6UnormBlock : return 48; + case Format::eAstc8x6SrgbBlock : return 48; + case Format::eAstc8x8UnormBlock : return 64; + case Format::eAstc8x8SrgbBlock : return 64; + case Format::eAstc10x5UnormBlock : return 50; + case Format::eAstc10x5SrgbBlock : return 50; + case Format::eAstc10x6UnormBlock : return 60; + case Format::eAstc10x6SrgbBlock : return 60; + case Format::eAstc10x8UnormBlock : return 80; + case Format::eAstc10x8SrgbBlock : return 80; + case Format::eAstc10x10UnormBlock : return 100; + case Format::eAstc10x10SrgbBlock : return 100; + case Format::eAstc12x10UnormBlock : return 120; + case Format::eAstc12x10SrgbBlock : return 120; + case Format::eAstc12x12UnormBlock : return 144; + case Format::eAstc12x12SrgbBlock : return 144; + case Format::eG8B8G8R8422Unorm : return 1; + case Format::eB8G8R8G8422Unorm : return 1; + case Format::eG8B8R83Plane420Unorm : return 1; + case Format::eG8B8R82Plane420Unorm : return 1; + case Format::eG8B8R83Plane422Unorm : return 1; + case Format::eG8B8R82Plane422Unorm : return 1; + case Format::eG8B8R83Plane444Unorm : return 1; + case Format::eR10X6UnormPack16 : return 1; + case Format::eR10X6G10X6Unorm2Pack16 : return 1; + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return 1; + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return 1; + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return 1; + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return 1; + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return 1; + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return 1; + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return 1; + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return 1; + case Format::eR12X4UnormPack16 : return 1; + case Format::eR12X4G12X4Unorm2Pack16 : return 1; + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return 1; + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return 1; + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return 1; + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return 1; + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return 1; + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return 1; + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return 1; + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return 1; + case Format::eG16B16G16R16422Unorm : return 1; + case Format::eB16G16R16G16422Unorm : return 1; + case Format::eG16B16R163Plane420Unorm : return 1; + case Format::eG16B16R162Plane420Unorm : return 1; + case Format::eG16B16R163Plane422Unorm : return 1; + case Format::eG16B16R162Plane422Unorm : return 1; + case Format::eG16B16R163Plane444Unorm : return 1; + case Format::eG8B8R82Plane444Unorm : return 1; + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return 1; + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return 1; + case Format::eG16B16R162Plane444Unorm : return 1; + case Format::eA4R4G4B4UnormPack16 : return 1; + case Format::eA4B4G4R4UnormPack16 : return 1; + case Format::eAstc4x4SfloatBlock : return 16; + case Format::eAstc5x4SfloatBlock : return 20; + case Format::eAstc5x5SfloatBlock : return 25; + case Format::eAstc6x5SfloatBlock : return 30; + case Format::eAstc6x6SfloatBlock : return 36; + case Format::eAstc8x5SfloatBlock : return 40; + case Format::eAstc8x6SfloatBlock : return 48; + case Format::eAstc8x8SfloatBlock : return 64; + case Format::eAstc10x5SfloatBlock : return 50; + case Format::eAstc10x6SfloatBlock : return 60; + case Format::eAstc10x8SfloatBlock : return 80; + case Format::eAstc10x10SfloatBlock : return 100; + case Format::eAstc12x10SfloatBlock : return 120; + case Format::eAstc12x12SfloatBlock : return 144; + case Format::eA1B5G5R5UnormPack16 : return 1; + case Format::eA8Unorm : return 1; + case Format::ePvrtc12BppUnormBlockIMG : return 1; + case Format::ePvrtc14BppUnormBlockIMG : return 1; + case Format::ePvrtc22BppUnormBlockIMG : return 1; + case Format::ePvrtc24BppUnormBlockIMG : return 1; + case Format::ePvrtc12BppSrgbBlockIMG : return 1; + case Format::ePvrtc14BppSrgbBlockIMG : return 1; + case Format::ePvrtc22BppSrgbBlockIMG : return 1; + case Format::ePvrtc24BppSrgbBlockIMG : return 1; + case Format::eAstc3x3x3UnormBlockEXT : return 27; + case Format::eAstc3x3x3SrgbBlockEXT : return 27; + case Format::eAstc3x3x3SfloatBlockEXT : return 27; + case Format::eAstc4x3x3UnormBlockEXT : return 36; + case Format::eAstc4x3x3SrgbBlockEXT : return 36; + case Format::eAstc4x3x3SfloatBlockEXT : return 36; + case Format::eAstc4x4x3UnormBlockEXT : return 48; + case Format::eAstc4x4x3SrgbBlockEXT : return 48; + case Format::eAstc4x4x3SfloatBlockEXT : return 48; + case Format::eAstc4x4x4UnormBlockEXT : return 64; + case Format::eAstc4x4x4SrgbBlockEXT : return 64; + case Format::eAstc4x4x4SfloatBlockEXT : return 64; + case Format::eAstc5x4x4UnormBlockEXT : return 80; + case Format::eAstc5x4x4SrgbBlockEXT : return 80; + case Format::eAstc5x4x4SfloatBlockEXT : return 80; + case Format::eAstc5x5x4UnormBlockEXT : return 100; + case Format::eAstc5x5x4SrgbBlockEXT : return 100; + case Format::eAstc5x5x4SfloatBlockEXT : return 100; + case Format::eAstc5x5x5UnormBlockEXT : return 125; + case Format::eAstc5x5x5SrgbBlockEXT : return 125; + case Format::eAstc5x5x5SfloatBlockEXT : return 125; + case Format::eAstc6x5x5UnormBlockEXT : return 150; + case Format::eAstc6x5x5SrgbBlockEXT : return 150; + case Format::eAstc6x5x5SfloatBlockEXT : return 150; + case Format::eAstc6x6x5UnormBlockEXT : return 180; + case Format::eAstc6x6x5SrgbBlockEXT : return 180; + case Format::eAstc6x6x5SfloatBlockEXT : return 180; + case Format::eAstc6x6x6UnormBlockEXT : return 216; + case Format::eAstc6x6x6SrgbBlockEXT : return 216; + case Format::eAstc6x6x6SfloatBlockEXT : return 216; + case Format::eR8BoolARM : return 1; + case Format::eR16G16Sfixed5NV : return 1; + case Format::eR10X6UintPack16ARM : return 1; + case Format::eR10X6G10X6Uint2Pack16ARM : return 1; + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return 1; + case Format::eR12X4UintPack16ARM : return 1; + case Format::eR12X4G12X4Uint2Pack16ARM : return 1; + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return 1; + case Format::eR14X2UintPack16ARM : return 1; + case Format::eR14X2G14X2Uint2Pack16ARM : return 1; + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return 1; + case Format::eR14X2UnormPack16ARM : return 1; + case Format::eR14X2G14X2Unorm2Pack16ARM : return 1; + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return 1; + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return 1; + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return 1; + + default: VULKAN_HPP_ASSERT( false ); return 0; + } + } + +} // namespace VULKAN_HPP_NAMESPACE +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_fuchsia.h b/lib/vulkan-headers/include/vulkan/vulkan_fuchsia.h new file mode 100644 index 00000000000..ccca6271f34 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_fuchsia.h @@ -0,0 +1,282 @@ +#ifndef VULKAN_FUCHSIA_H_ +#define VULKAN_FUCHSIA_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_FUCHSIA_imagepipe_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_FUCHSIA_imagepipe_surface 1 +#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1 +#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface" +typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA; +typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkImagePipeSurfaceCreateFlagsFUCHSIA flags; + zx_handle_t imagePipeHandle; +} VkImagePipeSurfaceCreateInfoFUCHSIA; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA( + VkInstance instance, + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif + + +// VK_FUCHSIA_external_memory is a preprocessor guard. Do not pass it to API calls. +#define VK_FUCHSIA_external_memory 1 +#define VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME "VK_FUCHSIA_external_memory" +typedef struct VkImportMemoryZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + zx_handle_t handle; +} VkImportMemoryZirconHandleInfoFUCHSIA; + +typedef struct VkMemoryZirconHandlePropertiesFUCHSIA { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryZirconHandlePropertiesFUCHSIA; + +typedef struct VkMemoryGetZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetZirconHandleInfoFUCHSIA; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA( + VkDevice device, + const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + zx_handle_t zirconHandle, + VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); +#endif +#endif + + +// VK_FUCHSIA_external_semaphore is a preprocessor guard. Do not pass it to API calls. +#define VK_FUCHSIA_external_semaphore 1 +#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 +#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_FUCHSIA_external_semaphore" +typedef struct VkImportSemaphoreZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + zx_handle_t zirconHandle; +} VkImportSemaphoreZirconHandleInfoFUCHSIA; + +typedef struct VkSemaphoreGetZirconHandleInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetZirconHandleInfoFUCHSIA; + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle); +#endif +#endif + + +// VK_FUCHSIA_buffer_collection is a preprocessor guard. Do not pass it to API calls. +#define VK_FUCHSIA_buffer_collection 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferCollectionFUCHSIA) +#define VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION 2 +#define VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME "VK_FUCHSIA_buffer_collection" +typedef VkFlags VkImageFormatConstraintsFlagsFUCHSIA; + +typedef enum VkImageConstraintsInfoFlagBitsFUCHSIA { + VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = 0x00000001, + VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = 0x00000002, + VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = 0x00000004, + VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = 0x00000008, + VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = 0x00000010, + VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIA = 0x7FFFFFFF +} VkImageConstraintsInfoFlagBitsFUCHSIA; +typedef VkFlags VkImageConstraintsInfoFlagsFUCHSIA; +typedef struct VkBufferCollectionCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + zx_handle_t collectionToken; +} VkBufferCollectionCreateInfoFUCHSIA; + +typedef struct VkImportMemoryBufferCollectionFUCHSIA { + VkStructureType sType; + const void* pNext; + VkBufferCollectionFUCHSIA collection; + uint32_t index; +} VkImportMemoryBufferCollectionFUCHSIA; + +typedef struct VkBufferCollectionImageCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkBufferCollectionFUCHSIA collection; + uint32_t index; +} VkBufferCollectionImageCreateInfoFUCHSIA; + +typedef struct VkBufferCollectionConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + uint32_t minBufferCount; + uint32_t maxBufferCount; + uint32_t minBufferCountForCamping; + uint32_t minBufferCountForDedicatedSlack; + uint32_t minBufferCountForSharedSlack; +} VkBufferCollectionConstraintsInfoFUCHSIA; + +typedef struct VkBufferConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkBufferCreateInfo createInfo; + VkFormatFeatureFlags requiredFormatFeatures; + VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; +} VkBufferConstraintsInfoFUCHSIA; + +typedef struct VkBufferCollectionBufferCreateInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkBufferCollectionFUCHSIA collection; + uint32_t index; +} VkBufferCollectionBufferCreateInfoFUCHSIA; + +typedef struct VkSysmemColorSpaceFUCHSIA { + VkStructureType sType; + const void* pNext; + uint32_t colorSpace; +} VkSysmemColorSpaceFUCHSIA; + +typedef struct VkBufferCollectionPropertiesFUCHSIA { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; + uint32_t bufferCount; + uint32_t createInfoIndex; + uint64_t sysmemPixelFormat; + VkFormatFeatureFlags formatFeatures; + VkSysmemColorSpaceFUCHSIA sysmemColorSpaceIndex; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; +} VkBufferCollectionPropertiesFUCHSIA; + +typedef struct VkImageFormatConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + VkImageCreateInfo imageCreateInfo; + VkFormatFeatureFlags requiredFormatFeatures; + VkImageFormatConstraintsFlagsFUCHSIA flags; + uint64_t sysmemPixelFormat; + uint32_t colorSpaceCount; + const VkSysmemColorSpaceFUCHSIA* pColorSpaces; +} VkImageFormatConstraintsInfoFUCHSIA; + +typedef struct VkImageConstraintsInfoFUCHSIA { + VkStructureType sType; + const void* pNext; + uint32_t formatConstraintsCount; + const VkImageFormatConstraintsInfoFUCHSIA* pFormatConstraints; + VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; + VkImageConstraintsInfoFlagsFUCHSIA flags; +} VkImageConstraintsInfoFUCHSIA; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferCollectionFUCHSIA)(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection); +typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionImageConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); +typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); +typedef void (VKAPI_PTR *PFN_vkDestroyBufferCollectionFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetBufferCollectionPropertiesFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA( + VkDevice device, + const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferCollectionFUCHSIA* pCollection); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkAllocationCallbacks* pAllocator); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + VkBufferCollectionPropertiesFUCHSIA* pProperties); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_funcs.hpp b/lib/vulkan-headers/include/vulkan/vulkan_funcs.hpp new file mode 100644 index 00000000000..41f3a2a2e30 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_funcs.hpp @@ -0,0 +1,32761 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_FUNCS_HPP +#define VULKAN_FUNCS_HPP + +// include-what-you-use: make sure, vulkan.hpp is used by code-completers +// IWYU pragma: private, include "vulkan/vulkan.hpp" + +namespace VULKAN_HPP_NAMESPACE +{ + + //=========================== + //=== COMMAND Definitions === + //=========================== + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Instance * pInstance, + Dispatch const & d ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateInstance( reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pInstance ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + createInstance( const InstanceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateInstance && "Function requires " ); +# endif + + Instance instance; + Result result = static_cast( d.vkCreateInstance( reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &instance ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::createInstance" ); + + return detail::createResultValueType( result, std::move( instance ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + createInstanceUnique( const InstanceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateInstance && "Function requires " ); +# endif + + Instance instance; + Result result = static_cast( d.vkCreateInstance( reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &instance ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::createInstanceUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( instance, detail::ObjectDestroy( allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html + template ::type> + VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyInstance( static_cast( m_instance ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html + template ::type> + VULKAN_HPP_INLINE void Instance::destroy( Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyInstance && "Function requires " ); +# endif + + d.vkDestroyInstance( m_instance, reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount, + PhysicalDevice * pPhysicalDevices, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkEnumeratePhysicalDevices( static_cast( m_instance ), pPhysicalDeviceCount, reinterpret_cast( pPhysicalDevices ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::enumeratePhysicalDevices( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDevices && "Function requires " ); +# endif + + std::vector physicalDevices; + uint32_t physicalDeviceCount; + Result result; + do + { + result = static_cast( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceCount ) + { + physicalDevices.resize( physicalDeviceCount ); + result = static_cast( + d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast( physicalDevices.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" ); + VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); + if ( physicalDeviceCount < physicalDevices.size() ) + { + physicalDevices.resize( physicalDeviceCount ); + } + return detail::createResultValueType( result, std::move( physicalDevices ) ); + } + + // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::enumeratePhysicalDevices( PhysicalDeviceAllocator const & physicalDeviceAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDevices && "Function requires " ); +# endif + + std::vector physicalDevices( physicalDeviceAllocator ); + uint32_t physicalDeviceCount; + Result result; + do + { + result = static_cast( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceCount ) + { + physicalDevices.resize( physicalDeviceCount ); + result = static_cast( + d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast( physicalDevices.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" ); + VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); + if ( physicalDeviceCount < physicalDevices.size() ) + { + physicalDevices.resize( physicalDeviceCount ); + } + return detail::createResultValueType( result, std::move( physicalDevices ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( PhysicalDeviceFeatures * pFeatures, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceFeatures( static_cast( m_physicalDevice ), reinterpret_cast( pFeatures ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures && "Function requires " ); +# endif + + PhysicalDeviceFeatures features; + d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast( &features ) ); + + return features; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html + template ::type> + VULKAN_HPP_INLINE void + PhysicalDevice::getFormatProperties( Format format, FormatProperties * pFormatProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceFormatProperties( + static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( pFormatProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties && "Function requires " ); +# endif + + FormatProperties formatProperties; + d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + + return formatProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( Format format, + ImageType type, + ImageTiling tiling, + ImageUsageFlags usage, + ImageCreateFlags flags, + ImageFormatProperties * pImageFormatProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceImageFormatProperties( static_cast( m_physicalDevice ), + static_cast( format ), + static_cast( type ), + static_cast( tiling ), + static_cast( usage ), + static_cast( flags ), + reinterpret_cast( pImageFormatProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::getImageFormatProperties( + Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties && "Function requires " ); +# endif + + ImageFormatProperties imageFormatProperties; + Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, + static_cast( format ), + static_cast( type ), + static_cast( tiling ), + static_cast( usage ), + static_cast( flags ), + reinterpret_cast( &imageFormatProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); + + return detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getProperties( PhysicalDeviceProperties * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceProperties( static_cast( m_physicalDevice ), reinterpret_cast( pProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties && "Function requires " ); +# endif + + PhysicalDeviceProperties properties; + d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast( &properties ) ); + + return properties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount, + QueueFamilyProperties * pQueueFamilyProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceQueueFamilyProperties( + static_cast( m_physicalDevice ), pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties && "Function requires " ); +# endif + + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + d.vkGetPhysicalDeviceQueueFamilyProperties( + m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + queueFamilyProperties.resize( queueFamilyPropertyCount ); + } + return queueFamilyProperties; + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getQueueFamilyProperties( QueueFamilyPropertiesAllocator const & queueFamilyPropertiesAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties && "Function requires " ); +# endif + + std::vector queueFamilyProperties( queueFamilyPropertiesAllocator ); + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + d.vkGetPhysicalDeviceQueueFamilyProperties( + m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + queueFamilyProperties.resize( queueFamilyPropertyCount ); + } + return queueFamilyProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( PhysicalDeviceMemoryProperties * pMemoryProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceMemoryProperties( static_cast( m_physicalDevice ), + reinterpret_cast( pMemoryProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties && "Function requires " ); +# endif + + PhysicalDeviceMemoryProperties memoryProperties; + d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + + return memoryProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html + template ::type> + VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char * pName, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return d.vkGetInstanceProcAddr( static_cast( m_instance ), pName ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html + template ::type> + VULKAN_HPP_INLINE PFN_VoidFunction Instance::getProcAddr( const std::string & name, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetInstanceProcAddr && "Function requires " ); +# endif + + PFN_vkVoidFunction result = d.vkGetInstanceProcAddr( m_instance, name.c_str() ); + + return result; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html + template ::type> + VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char * pName, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return d.vkGetDeviceProcAddr( static_cast( m_device ), pName ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html + template ::type> + VULKAN_HPP_INLINE PFN_VoidFunction Device::getProcAddr( const std::string & name, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceProcAddr && "Function requires " ); +# endif + + PFN_vkVoidFunction result = d.vkGetDeviceProcAddr( m_device, name.c_str() ); + + return result; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Device * pDevice, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDevice( static_cast( m_physicalDevice ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pDevice ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDevice && "Function requires " ); +# endif + + Device device; + Result result = static_cast( d.vkCreateDevice( m_physicalDevice, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &device ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" ); + + return detail::createResultValueType( result, std::move( device ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::createDeviceUnique( const DeviceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDevice && "Function requires " ); +# endif + + Device device; + Result result = static_cast( d.vkCreateDevice( m_physicalDevice, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &device ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique" ); + + return detail::createResultValueType( result, UniqueHandle( device, detail::ObjectDestroy( allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDevice( static_cast( m_device ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDevice && "Function requires " ); +# endif + + d.vkDestroyDevice( m_device, reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkEnumerateInstanceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char * pLayerName, + uint32_t * pPropertyCount, + ExtensionProperties * pProperties, + Dispatch const & d ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumerateInstanceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + enumerateInstanceExtensionProperties( Optional layerName, Dispatch const & d ) + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumerateInstanceExtensionProperties && "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkEnumerateInstanceExtensionProperties( + layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkEnumerateInstanceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + enumerateInstanceExtensionProperties( Optional layerName, + ExtensionPropertiesAllocator const & extensionPropertiesAllocator, + Dispatch const & d ) + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumerateInstanceExtensionProperties && "Function requires " ); +# endif + + std::vector properties( extensionPropertiesAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkEnumerateInstanceExtensionProperties( + layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkEnumerateDeviceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char * pLayerName, + uint32_t * pPropertyCount, + ExtensionProperties * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkEnumerateDeviceExtensionProperties( + static_cast( m_physicalDevice ), pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumerateDeviceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumerateDeviceExtensionProperties && "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = + static_cast( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkEnumerateDeviceExtensionProperties( + m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkEnumerateDeviceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, + ExtensionPropertiesAllocator const & extensionPropertiesAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumerateDeviceExtensionProperties && "Function requires " ); +# endif + + std::vector properties( extensionPropertiesAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = + static_cast( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkEnumerateDeviceExtensionProperties( + m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkEnumerateInstanceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount, + LayerProperties * pProperties, + Dispatch const & d ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumerateInstanceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + enumerateInstanceLayerProperties( Dispatch const & d ) + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumerateInstanceLayerProperties && "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkEnumerateInstanceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + enumerateInstanceLayerProperties( LayerPropertiesAllocator const & layerPropertiesAllocator, Dispatch const & d ) + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumerateInstanceLayerProperties && "Function requires " ); +# endif + + std::vector properties( layerPropertiesAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkEnumerateDeviceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t * pPropertyCount, + LayerProperties * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkEnumerateDeviceLayerProperties( + static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumerateDeviceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::enumerateDeviceLayerProperties( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumerateDeviceLayerProperties && "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( + d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkEnumerateDeviceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::enumerateDeviceLayerProperties( LayerPropertiesAllocator const & layerPropertiesAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumerateDeviceLayerProperties && "Function requires " ); +# endif + + std::vector properties( layerPropertiesAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( + d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html + template ::type> + VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue * pQueue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceQueue( static_cast( m_device ), queueFamilyIndex, queueIndex, reinterpret_cast( pQueue ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceQueue && "Function requires " ); +# endif + + Queue queue; + d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast( &queue ) ); + + return queue; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Queue::submit( uint32_t submitCount, const SubmitInfo * pSubmits, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkQueueSubmit( static_cast( m_queue ), submitCount, reinterpret_cast( pSubmits ), static_cast( fence ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Queue::submit( ArrayProxy const & submits, Fence fence, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkQueueSubmit && "Function requires " ); +# endif + + Result result = static_cast( + d.vkQueueSubmit( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkQueueWaitIdle( static_cast( m_queue ) ) ); + } +#else + // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Queue::waitIdle( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkQueueWaitIdle && "Function requires " ); +# endif + + Result result = static_cast( d.vkQueueWaitIdle( m_queue ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkDeviceWaitIdle( static_cast( m_device ) ) ); + } +#else + // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::waitIdle( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDeviceWaitIdle && "Function requires " ); +# endif + + Result result = static_cast( d.vkDeviceWaitIdle( m_device ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateMemory( const MemoryAllocateInfo * pAllocateInfo, + const AllocationCallbacks * pAllocator, + DeviceMemory * pMemory, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkAllocateMemory( static_cast( m_device ), + reinterpret_cast( pAllocateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pMemory ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAllocateMemory && "Function requires " ); +# endif + + DeviceMemory memory; + Result result = static_cast( d.vkAllocateMemory( m_device, + reinterpret_cast( &allocateInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &memory ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemory" ); + + return detail::createResultValueType( result, std::move( memory ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAllocateMemory && "Function requires " ); +# endif + + DeviceMemory memory; + Result result = static_cast( d.vkAllocateMemory( m_device, + reinterpret_cast( &allocateInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &memory ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemoryUnique" ); + + return detail::createResultValueType( result, UniqueHandle( memory, detail::ObjectFree( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html + template ::type> + VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkFreeMemory( static_cast( m_device ), static_cast( memory ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html + template ::type> + VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkFreeMemory && "Function requires " ); +# endif + + d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html + template ::type> + VULKAN_HPP_INLINE void( Device::free )( DeviceMemory memory, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkFreeMemory( static_cast( m_device ), static_cast( memory ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html + template ::type> + VULKAN_HPP_INLINE void( Device::free )( DeviceMemory memory, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkFreeMemory && "Function requires " ); +# endif + + d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory( + DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void ** ppData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkMapMemory( static_cast( m_device ), + static_cast( memory ), + static_cast( offset ), + static_cast( size ), + static_cast( flags ), + ppData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkMapMemory && "Function requires " ); +# endif + + void * pData; + Result result = static_cast( d.vkMapMemory( m_device, + static_cast( memory ), + static_cast( offset ), + static_cast( size ), + static_cast( flags ), + &pData ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory" ); + + return detail::createResultValueType( result, std::move( pData ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html + template ::type> + VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkUnmapMemory( static_cast( m_device ), static_cast( memory ) ); + } + + // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, + const MappedMemoryRange * pMemoryRanges, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkFlushMappedMemoryRanges( static_cast( m_device ), memoryRangeCount, reinterpret_cast( pMemoryRanges ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::flushMappedMemoryRanges( ArrayProxy const & memoryRanges, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkFlushMappedMemoryRanges && "Function requires " ); +# endif + + Result result = + static_cast( d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkInvalidateMappedMemoryRanges, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, + const MappedMemoryRange * pMemoryRanges, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkInvalidateMappedMemoryRanges( static_cast( m_device ), memoryRangeCount, reinterpret_cast( pMemoryRanges ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkInvalidateMappedMemoryRanges, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::invalidateMappedMemoryRanges( ArrayProxy const & memoryRanges, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkInvalidateMappedMemoryRanges && "Function requires " ); +# endif + + Result result = static_cast( + d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html + template ::type> + VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize * pCommittedMemoryInBytes, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceMemoryCommitment( + static_cast( m_device ), static_cast( memory ), reinterpret_cast( pCommittedMemoryInBytes ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize Device::getMemoryCommitment( DeviceMemory memory, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryCommitment && "Function requires " ); +# endif + + DeviceSize committedMemoryInBytes; + d.vkGetDeviceMemoryCommitment( m_device, static_cast( memory ), reinterpret_cast( &committedMemoryInBytes ) ); + + return committedMemoryInBytes; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkBindBufferMemory( + static_cast( m_device ), static_cast( buffer ), static_cast( memory ), static_cast( memoryOffset ) ) ); + } +#else + // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBindBufferMemory && "Function requires " ); +# endif + + Result result = static_cast( + d.vkBindBufferMemory( m_device, static_cast( buffer ), static_cast( memory ), static_cast( memoryOffset ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkBindImageMemory( + static_cast( m_device ), static_cast( image ), static_cast( memory ), static_cast( memoryOffset ) ) ); + } +#else + // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBindImageMemory && "Function requires " ); +# endif + + Result result = static_cast( + d.vkBindImageMemory( m_device, static_cast( image ), static_cast( memory ), static_cast( memoryOffset ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html + template ::type> + VULKAN_HPP_INLINE void + Device::getBufferMemoryRequirements( Buffer buffer, MemoryRequirements * pMemoryRequirements, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetBufferMemoryRequirements( + static_cast( m_device ), static_cast( buffer ), reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements Device::getBufferMemoryRequirements( Buffer buffer, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements && "Function requires " ); +# endif + + MemoryRequirements memoryRequirements; + d.vkGetBufferMemoryRequirements( m_device, static_cast( buffer ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html + template ::type> + VULKAN_HPP_INLINE void + Device::getImageMemoryRequirements( Image image, MemoryRequirements * pMemoryRequirements, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetImageMemoryRequirements( + static_cast( m_device ), static_cast( image ), reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements Device::getImageMemoryRequirements( Image image, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements && "Function requires " ); +# endif + + MemoryRequirements memoryRequirements; + d.vkGetImageMemoryRequirements( m_device, static_cast( image ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image, + uint32_t * pSparseMemoryRequirementCount, + SparseImageMemoryRequirements * pSparseMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetImageSparseMemoryRequirements( static_cast( m_device ), + static_cast( image ), + pSparseMemoryRequirementCount, + reinterpret_cast( pSparseMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirements( Image image, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements && "Function requires " ); +# endif + + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + d.vkGetImageSparseMemoryRequirements( m_device, static_cast( image ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetImageSparseMemoryRequirements( m_device, + static_cast( image ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } + + // wrapper function for command vkGetImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirements( Image image, + SparseImageMemoryRequirementsAllocator const & sparseImageMemoryRequirementsAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements && "Function requires " ); +# endif + + std::vector sparseMemoryRequirements( sparseImageMemoryRequirementsAllocator ); + uint32_t sparseMemoryRequirementCount; + d.vkGetImageSparseMemoryRequirements( m_device, static_cast( image ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetImageSparseMemoryRequirements( m_device, + static_cast( image ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( Format format, + ImageType type, + SampleCountFlagBits samples, + ImageUsageFlags usage, + ImageTiling tiling, + uint32_t * pPropertyCount, + SparseImageFormatProperties * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceSparseImageFormatProperties( static_cast( m_physicalDevice ), + static_cast( format ), + static_cast( type ), + static_cast( samples ), + static_cast( usage ), + static_cast( tiling ), + pPropertyCount, + reinterpret_cast( pProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getSparseImageFormatProperties( + Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties && + "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, + static_cast( format ), + static_cast( type ), + static_cast( samples ), + static_cast( usage ), + static_cast( tiling ), + &propertyCount, + nullptr ); + properties.resize( propertyCount ); + d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, + static_cast( format ), + static_cast( type ), + static_cast( samples ), + static_cast( usage ), + static_cast( tiling ), + &propertyCount, + reinterpret_cast( properties.data() ) ); + + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return properties; + } + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getSparseImageFormatProperties( Format format, + ImageType type, + SampleCountFlagBits samples, + ImageUsageFlags usage, + ImageTiling tiling, + SparseImageFormatPropertiesAllocator const & sparseImageFormatPropertiesAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties && + "Function requires " ); +# endif + + std::vector properties( sparseImageFormatPropertiesAllocator ); + uint32_t propertyCount; + d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, + static_cast( format ), + static_cast( type ), + static_cast( samples ), + static_cast( usage ), + static_cast( tiling ), + &propertyCount, + nullptr ); + properties.resize( propertyCount ); + d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, + static_cast( format ), + static_cast( type ), + static_cast( samples ), + static_cast( usage ), + static_cast( tiling ), + &propertyCount, + reinterpret_cast( properties.data() ) ); + + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return properties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo * pBindInfo, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkQueueBindSparse( + static_cast( m_queue ), bindInfoCount, reinterpret_cast( pBindInfo ), static_cast( fence ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Queue::bindSparse( ArrayProxy const & bindInfo, Fence fence, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkQueueBindSparse && "Function requires " ); +# endif + + Result result = static_cast( + d.vkQueueBindSparse( m_queue, bindInfo.size(), reinterpret_cast( bindInfo.data() ), static_cast( fence ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Fence * pFence, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateFence( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pFence ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createFence( const FenceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateFence && "Function requires " ); +# endif + + Fence fence; + Result result = static_cast( d.vkCreateFence( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &fence ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" ); + + return detail::createResultValueType( result, std::move( fence ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createFenceUnique( const FenceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateFence && "Function requires " ); +# endif + + Fence fence; + Result result = static_cast( d.vkCreateFence( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &fence ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique" ); + + return detail::createResultValueType( result, UniqueHandle( fence, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyFence( static_cast( m_device ), static_cast( fence ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyFence && "Function requires " ); +# endif + + d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Fence fence, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyFence( static_cast( m_device ), static_cast( fence ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Fence fence, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyFence && "Function requires " ); +# endif + + d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence * pFences, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkResetFences( static_cast( m_device ), fenceCount, reinterpret_cast( pFences ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::resetFences( ArrayProxy const & fences, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkResetFences && "Function requires " ); +# endif + + Result result = static_cast( d.vkResetFences( m_device, fences.size(), reinterpret_cast( fences.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetFenceStatus( static_cast( m_device ), static_cast( fence ) ) ); + } +#else + // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetFenceStatus && "Function requires " ); +# endif + + Result result = static_cast( d.vkGetFenceStatus( m_device, static_cast( fence ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } ); + + return static_cast( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::waitForFences( uint32_t fenceCount, const Fence * pFences, Bool32 waitAll, uint64_t timeout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkWaitForFences( + static_cast( m_device ), fenceCount, reinterpret_cast( pFences ), static_cast( waitAll ), timeout ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::waitForFences( ArrayProxy const & fences, Bool32 waitAll, uint64_t timeout, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkWaitForFences && "Function requires " ); +# endif + + Result result = static_cast( + d.vkWaitForFences( m_device, fences.size(), reinterpret_cast( fences.data() ), static_cast( waitAll ), timeout ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences", { Result::eSuccess, Result::eTimeout } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Semaphore * pSemaphore, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateSemaphore( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSemaphore ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSemaphore && "Function requires " ); +# endif + + Semaphore semaphore; + Result result = static_cast( d.vkCreateSemaphore( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &semaphore ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" ); + + return detail::createResultValueType( result, std::move( semaphore ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSemaphore && "Function requires " ); +# endif + + Semaphore semaphore; + Result result = static_cast( d.vkCreateSemaphore( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &semaphore ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( semaphore, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html + template ::type> + VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroySemaphore( + static_cast( m_device ), static_cast( semaphore ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroySemaphore( Semaphore semaphore, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroySemaphore && "Function requires " ); +# endif + + d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroySemaphore( + static_cast( m_device ), static_cast( semaphore ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroySemaphore && "Function requires " ); +# endif + + d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + QueryPool * pQueryPool, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateQueryPool( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pQueryPool ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateQueryPool && "Function requires " ); +# endif + + QueryPool queryPool; + Result result = static_cast( d.vkCreateQueryPool( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &queryPool ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" ); + + return detail::createResultValueType( result, std::move( queryPool ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateQueryPool && "Function requires " ); +# endif + + QueryPool queryPool; + Result result = static_cast( d.vkCreateQueryPool( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &queryPool ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( queryPool, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyQueryPool( + static_cast( m_device ), static_cast( queryPool ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyQueryPool( QueryPool queryPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyQueryPool && "Function requires " ); +# endif + + d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyQueryPool( + static_cast( m_device ), static_cast( queryPool ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyQueryPool && "Function requires " ); +# endif + + d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void * pData, + DeviceSize stride, + QueryResultFlags flags, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetQueryPoolResults( static_cast( m_device ), + static_cast( queryPool ), + firstQuery, + queryCount, + dataSize, + pData, + static_cast( stride ), + static_cast( flags ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::getQueryPoolResults( + QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, DeviceSize stride, QueryResultFlags flags, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetQueryPoolResults && "Function requires " ); +# endif + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( d.vkGetQueryPoolResults( m_device, + static_cast( queryPool ), + firstQuery, + queryCount, + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ), + static_cast( stride ), + static_cast( flags ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } ); + + return ResultValue>( result, std::move( data ) ); + } + + // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::getQueryPoolResult( + QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, DeviceSize stride, QueryResultFlags flags, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetQueryPoolResults && "Function requires " ); +# endif + + DataType data; + Result result = static_cast( d.vkGetQueryPoolResults( m_device, + static_cast( queryPool ), + firstQuery, + queryCount, + sizeof( DataType ), + reinterpret_cast( &data ), + static_cast( stride ), + static_cast( flags ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult", { Result::eSuccess, Result::eNotReady } ); + + return ResultValue( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Buffer * pBuffer, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateBuffer( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pBuffer ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createBuffer( const BufferCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateBuffer && "Function requires " ); +# endif + + Buffer buffer; + Result result = static_cast( d.vkCreateBuffer( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &buffer ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBuffer" ); + + return detail::createResultValueType( result, std::move( buffer ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createBufferUnique( const BufferCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateBuffer && "Function requires " ); +# endif + + Buffer buffer; + Result result = static_cast( d.vkCreateBuffer( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &buffer ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferUnique" ); + + return detail::createResultValueType( result, UniqueHandle( buffer, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyBuffer( static_cast( m_device ), static_cast( buffer ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyBuffer && "Function requires " ); +# endif + + d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyBuffer( static_cast( m_device ), static_cast( buffer ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyBuffer && "Function requires " ); +# endif + + d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Image * pImage, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateImage( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pImage ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createImage( const ImageCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateImage && "Function requires " ); +# endif + + Image image; + Result result = static_cast( d.vkCreateImage( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &image ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" ); + + return detail::createResultValueType( result, std::move( image ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createImageUnique( const ImageCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateImage && "Function requires " ); +# endif + + Image image; + Result result = static_cast( d.vkCreateImage( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &image ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique" ); + + return detail::createResultValueType( result, UniqueHandle( image, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyImage( static_cast( m_device ), static_cast( image ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyImage( Image image, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyImage && "Function requires " ); +# endif + + d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Image image, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyImage( static_cast( m_device ), static_cast( image ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Image image, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyImage && "Function requires " ); +# endif + + d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image, + const ImageSubresource * pSubresource, + SubresourceLayout * pLayout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetImageSubresourceLayout( static_cast( m_device ), + static_cast( image ), + reinterpret_cast( pSubresource ), + reinterpret_cast( pLayout ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout Device::getImageSubresourceLayout( Image image, + const ImageSubresource & subresource, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageSubresourceLayout && "Function requires " ); +# endif + + SubresourceLayout layout; + d.vkGetImageSubresourceLayout( m_device, + static_cast( image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return layout; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + ImageView * pView, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateImageView( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pView ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createImageView( const ImageViewCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateImageView && "Function requires " ); +# endif + + ImageView view; + Result result = static_cast( d.vkCreateImageView( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &view ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" ); + + return detail::createResultValueType( result, std::move( view ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateImageView && "Function requires " ); +# endif + + ImageView view; + Result result = static_cast( d.vkCreateImageView( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &view ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique" ); + + return detail::createResultValueType( result, UniqueHandle( view, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyImageView( + static_cast( m_device ), static_cast( imageView ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyImageView( ImageView imageView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyImageView && "Function requires " ); +# endif + + d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyImageView( + static_cast( m_device ), static_cast( imageView ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyImageView && "Function requires " ); +# endif + + d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + CommandPool * pCommandPool, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateCommandPool( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pCommandPool ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateCommandPool && "Function requires " ); +# endif + + CommandPool commandPool; + Result result = static_cast( d.vkCreateCommandPool( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &commandPool ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" ); + + return detail::createResultValueType( result, std::move( commandPool ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateCommandPool && "Function requires " ); +# endif + + CommandPool commandPool; + Result result = static_cast( d.vkCreateCommandPool( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &commandPool ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( commandPool, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyCommandPool( + static_cast( m_device ), static_cast( commandPool ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyCommandPool( CommandPool commandPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyCommandPool && "Function requires " ); +# endif + + d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyCommandPool( + static_cast( m_device ), static_cast( commandPool ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyCommandPool && "Function requires " ); +# endif + + d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, + CommandPoolResetFlags flags, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkResetCommandPool( static_cast( m_device ), static_cast( commandPool ), static_cast( flags ) ) ); + } +#else + // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkResetCommandPool && "Function requires " ); +# endif + + Result result = + static_cast( d.vkResetCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetCommandPool" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo * pAllocateInfo, + CommandBuffer * pCommandBuffers, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkAllocateCommandBuffers( static_cast( m_device ), + reinterpret_cast( pAllocateInfo ), + reinterpret_cast( pCommandBuffers ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function requires " ); +# endif + + std::vector commandBuffers( allocateInfo.commandBufferCount ); + Result result = static_cast( d.vkAllocateCommandBuffers( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); + + return detail::createResultValueType( result, std::move( commandBuffers ) ); + } + + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateCommandBuffers( + const CommandBufferAllocateInfo & allocateInfo, CommandBufferAllocator const & commandBufferAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function requires " ); +# endif + + std::vector commandBuffers( allocateInfo.commandBufferCount, {}, commandBufferAllocator ); + Result result = static_cast( d.vkAllocateCommandBuffers( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); + + return detail::createResultValueType( result, std::move( commandBuffers ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, CommandBufferAllocator>>::type + Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function requires " ); +# endif + + std::vector commandBuffers( allocateInfo.commandBufferCount ); + Result result = static_cast( d.vkAllocateCommandBuffers( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); + std::vector, CommandBufferAllocator> uniqueCommandBuffers; + uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); + detail::PoolFree deleter( *this, allocateInfo.commandPool, d ); + for ( auto const & commandBuffer : commandBuffers ) + { + uniqueCommandBuffers.push_back( UniqueHandle( commandBuffer, deleter ) ); + } + return detail::createResultValueType( result, std::move( uniqueCommandBuffers ) ); + } + + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, CommandBufferAllocator>>::type + Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, + CommandBufferAllocator const & commandBufferAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function requires " ); +# endif + + std::vector commandBuffers( allocateInfo.commandBufferCount ); + Result result = static_cast( d.vkAllocateCommandBuffers( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); + std::vector, CommandBufferAllocator> uniqueCommandBuffers( commandBufferAllocator ); + uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); + detail::PoolFree deleter( *this, allocateInfo.commandPool, d ); + for ( auto const & commandBuffer : commandBuffers ) + { + uniqueCommandBuffers.push_back( UniqueHandle( commandBuffer, deleter ) ); + } + return detail::createResultValueType( result, std::move( uniqueCommandBuffers ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html + template ::type> + VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, + uint32_t commandBufferCount, + const CommandBuffer * pCommandBuffers, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkFreeCommandBuffers( static_cast( m_device ), + static_cast( commandPool ), + commandBufferCount, + reinterpret_cast( pCommandBuffers ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html + template ::type> + VULKAN_HPP_INLINE void + Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy const & commandBuffers, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkFreeCommandBuffers && "Function requires " ); +# endif + + d.vkFreeCommandBuffers( + m_device, static_cast( commandPool ), commandBuffers.size(), reinterpret_cast( commandBuffers.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html + template ::type> + VULKAN_HPP_INLINE void( Device::free )( CommandPool commandPool, + uint32_t commandBufferCount, + const CommandBuffer * pCommandBuffers, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkFreeCommandBuffers( static_cast( m_device ), + static_cast( commandPool ), + commandBufferCount, + reinterpret_cast( pCommandBuffers ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html + template ::type> + VULKAN_HPP_INLINE void( Device::free )( CommandPool commandPool, + ArrayProxy const & commandBuffers, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkFreeCommandBuffers && "Function requires " ); +# endif + + d.vkFreeCommandBuffers( + m_device, static_cast( commandPool ), commandBuffers.size(), reinterpret_cast( commandBuffers.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo * pBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkBeginCommandBuffer( static_cast( m_commandBuffer ), reinterpret_cast( pBeginInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBeginCommandBuffer && "Function requires " ); +# endif + + Result result = static_cast( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast( &beginInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::end( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkEndCommandBuffer( static_cast( m_commandBuffer ) ) ); + } +#else + // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::end( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEndCommandBuffer && "Function requires " ); +# endif + + Result result = static_cast( d.vkEndCommandBuffer( m_commandBuffer ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkResetCommandBuffer( static_cast( m_commandBuffer ), static_cast( flags ) ) ); + } +#else + // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::reset( CommandBufferResetFlags flags, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkResetCommandBuffer && "Function requires " ); +# endif + + Result result = static_cast( d.vkResetCommandBuffer( m_commandBuffer, static_cast( flags ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( + Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy * pRegions, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyBuffer( static_cast( m_commandBuffer ), + static_cast( srcBuffer ), + static_cast( dstBuffer ), + regionCount, + reinterpret_cast( pRegions ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy const & regions, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer && "Function requires " ); +# endif + + d.vkCmdCopyBuffer( m_commandBuffer, + static_cast( srcBuffer ), + static_cast( dstBuffer ), + regions.size(), + reinterpret_cast( regions.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + uint32_t regionCount, + const ImageCopy * pRegions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyImage( static_cast( m_commandBuffer ), + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regionCount, + reinterpret_cast( pRegions ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyImage && "Function requires " ); +# endif + + d.vkCmdCopyImage( m_commandBuffer, + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regions.size(), + reinterpret_cast( regions.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, + Image dstImage, + ImageLayout dstImageLayout, + uint32_t regionCount, + const BufferImageCopy * pRegions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyBufferToImage( static_cast( m_commandBuffer ), + static_cast( srcBuffer ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regionCount, + reinterpret_cast( pRegions ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, + Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage && "Function requires " ); +# endif + + d.vkCmdCopyBufferToImage( m_commandBuffer, + static_cast( srcBuffer ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regions.size(), + reinterpret_cast( regions.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, + ImageLayout srcImageLayout, + Buffer dstBuffer, + uint32_t regionCount, + const BufferImageCopy * pRegions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyImageToBuffer( static_cast( m_commandBuffer ), + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstBuffer ), + regionCount, + reinterpret_cast( pRegions ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, + ImageLayout srcImageLayout, + Buffer dstBuffer, + ArrayProxy const & regions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer && "Function requires " ); +# endif + + d.vkCmdCopyImageToBuffer( m_commandBuffer, + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstBuffer ), + regions.size(), + reinterpret_cast( regions.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdUpdateBuffer( static_cast( m_commandBuffer ), + static_cast( dstBuffer ), + static_cast( dstOffset ), + static_cast( dataSize ), + pData ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy const & data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdUpdateBuffer && "Function requires " ); +# endif + + d.vkCmdUpdateBuffer( m_commandBuffer, + static_cast( dstBuffer ), + static_cast( dstOffset ), + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdFillBuffer( static_cast( m_commandBuffer ), + static_cast( dstBuffer ), + static_cast( dstOffset ), + static_cast( size ), + data ); + } + + // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + DependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const MemoryBarrier * pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const BufferMemoryBarrier * pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const ImageMemoryBarrier * pImageMemoryBarriers, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPipelineBarrier( static_cast( m_commandBuffer ), + static_cast( srcStageMask ), + static_cast( dstStageMask ), + static_cast( dependencyFlags ), + memoryBarrierCount, + reinterpret_cast( pMemoryBarriers ), + bufferMemoryBarrierCount, + reinterpret_cast( pBufferMemoryBarriers ), + imageMemoryBarrierCount, + reinterpret_cast( pImageMemoryBarriers ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + DependencyFlags dependencyFlags, + ArrayProxy const & memoryBarriers, + ArrayProxy const & bufferMemoryBarriers, + ArrayProxy const & imageMemoryBarriers, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier && "Function requires " ); +# endif + + d.vkCmdPipelineBarrier( m_commandBuffer, + static_cast( srcStageMask ), + static_cast( dstStageMask ), + static_cast( dependencyFlags ), + memoryBarriers.size(), + reinterpret_cast( memoryBarriers.data() ), + bufferMemoryBarriers.size(), + reinterpret_cast( bufferMemoryBarriers.data() ), + imageMemoryBarriers.size(), + reinterpret_cast( imageMemoryBarriers.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginQuery( + static_cast( m_commandBuffer ), static_cast( queryPool ), query, static_cast( flags ) ); + } + + // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndQuery( static_cast( m_commandBuffer ), static_cast( queryPool ), query ); + } + + // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdResetQueryPool( static_cast( m_commandBuffer ), static_cast( queryPool ), firstQuery, queryCount ); + } + + // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWriteTimestamp( + static_cast( m_commandBuffer ), static_cast( pipelineStage ), static_cast( queryPool ), query ); + } + + // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + Buffer dstBuffer, + DeviceSize dstOffset, + DeviceSize stride, + QueryResultFlags flags, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyQueryPoolResults( static_cast( m_commandBuffer ), + static_cast( queryPool ), + firstQuery, + queryCount, + static_cast( dstBuffer ), + static_cast( dstOffset ), + static_cast( stride ), + static_cast( flags ) ); + } + + // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer * pCommandBuffers, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdExecuteCommands( static_cast( m_commandBuffer ), commandBufferCount, reinterpret_cast( pCommandBuffers ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy const & commandBuffers, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdExecuteCommands && "Function requires " ); +# endif + + d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size(), reinterpret_cast( commandBuffers.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Event * pEvent, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateEvent( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pEvent ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createEvent( const EventCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateEvent && "Function requires " ); +# endif + + Event event; + Result result = static_cast( d.vkCreateEvent( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &event ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" ); + + return detail::createResultValueType( result, std::move( event ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createEventUnique( const EventCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateEvent && "Function requires " ); +# endif + + Event event; + Result result = static_cast( d.vkCreateEvent( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &event ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique" ); + + return detail::createResultValueType( result, UniqueHandle( event, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyEvent( static_cast( m_device ), static_cast( event ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyEvent( Event event, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyEvent && "Function requires " ); +# endif + + d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Event event, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyEvent( static_cast( m_device ), static_cast( event ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Event event, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyEvent && "Function requires " ); +# endif + + d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetEventStatus( static_cast( m_device ), static_cast( event ) ) ); + } +#else + // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetEventStatus && "Function requires " ); +# endif + + Result result = static_cast( d.vkGetEventStatus( m_device, static_cast( event ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } ); + + return static_cast( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setEvent( Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkSetEvent( static_cast( m_device ), static_cast( event ) ) ); + } +#else + // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::setEvent( Event event, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetEvent && "Function requires " ); +# endif + + Result result = static_cast( d.vkSetEvent( m_device, static_cast( event ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setEvent" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetEvent( Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkResetEvent( static_cast( m_device ), static_cast( event ) ) ); + } +#else + // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::resetEvent( Event event, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkResetEvent && "Function requires " ); +# endif + + Result result = static_cast( d.vkResetEvent( m_device, static_cast( event ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetEvent" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + BufferView * pView, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateBufferView( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pView ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateBufferView && "Function requires " ); +# endif + + BufferView view; + Result result = static_cast( d.vkCreateBufferView( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &view ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferView" ); + + return detail::createResultValueType( result, std::move( view ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateBufferView && "Function requires " ); +# endif + + BufferView view; + Result result = static_cast( d.vkCreateBufferView( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &view ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferViewUnique" ); + + return detail::createResultValueType( result, UniqueHandle( view, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyBufferView( + static_cast( m_device ), static_cast( bufferView ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyBufferView( BufferView bufferView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyBufferView && "Function requires " ); +# endif + + d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyBufferView( + static_cast( m_device ), static_cast( bufferView ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyBufferView && "Function requires " ); +# endif + + d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + ShaderModule * pShaderModule, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateShaderModule( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pShaderModule ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateShaderModule && "Function requires " ); +# endif + + ShaderModule shaderModule; + Result result = static_cast( d.vkCreateShaderModule( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &shaderModule ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" ); + + return detail::createResultValueType( result, std::move( shaderModule ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateShaderModule && "Function requires " ); +# endif + + ShaderModule shaderModule; + Result result = static_cast( d.vkCreateShaderModule( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &shaderModule ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModuleUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( shaderModule, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyShaderModule( + static_cast( m_device ), static_cast( shaderModule ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyShaderModule( ShaderModule shaderModule, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyShaderModule && "Function requires " ); +# endif + + d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyShaderModule( + static_cast( m_device ), static_cast( shaderModule ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( ShaderModule shaderModule, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyShaderModule && "Function requires " ); +# endif + + d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + PipelineCache * pPipelineCache, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreatePipelineCache( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pPipelineCache ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePipelineCache && "Function requires " ); +# endif + + PipelineCache pipelineCache; + Result result = static_cast( d.vkCreatePipelineCache( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipelineCache ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" ); + + return detail::createResultValueType( result, std::move( pipelineCache ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePipelineCache && "Function requires " ); +# endif + + PipelineCache pipelineCache; + Result result = static_cast( d.vkCreatePipelineCache( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipelineCache ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( pipelineCache, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyPipelineCache( + static_cast( m_device ), static_cast( pipelineCache ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyPipelineCache( PipelineCache pipelineCache, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyPipelineCache && "Function requires " ); +# endif + + d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyPipelineCache( + static_cast( m_device ), static_cast( pipelineCache ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( PipelineCache pipelineCache, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyPipelineCache && "Function requires " ); +# endif + + d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getPipelineCacheData( PipelineCache pipelineCache, size_t * pDataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPipelineCacheData( static_cast( m_device ), static_cast( pipelineCache ), pDataSize, pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getPipelineCacheData( PipelineCache pipelineCache, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineCacheData && "Function requires " ); +# endif + + std::vector data; + size_t dataSize; + Result result; + do + { + result = static_cast( d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( + d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getPipelineCacheData( PipelineCache pipelineCache, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineCacheData && "Function requires " ); +# endif + + std::vector data( uint8_tAllocator ); + size_t dataSize; + Result result; + do + { + result = static_cast( d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( + d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache, + uint32_t srcCacheCount, + const PipelineCache * pSrcCaches, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkMergePipelineCaches( + static_cast( m_device ), static_cast( dstCache ), srcCacheCount, reinterpret_cast( pSrcCaches ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::mergePipelineCaches( PipelineCache dstCache, ArrayProxy const & srcCaches, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkMergePipelineCaches && "Function requires " ); +# endif + + Result result = static_cast( d.vkMergePipelineCaches( + m_device, static_cast( dstCache ), srcCaches.size(), reinterpret_cast( srcCaches.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergePipelineCaches" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache, + uint32_t createInfoCount, + const ComputePipelineCreateInfo * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateComputePipelines( static_cast( m_device ), + static_cast( pipelineCache ), + createInfoCount, + reinterpret_cast( pCreateInfos ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pPipelines ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createComputePipelines( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateComputePipelines( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createComputePipelines( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); + Result result = static_cast( d.vkCreateComputePipelines( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::createComputePipeline( PipelineCache pipelineCache, + const ComputePipelineCreateInfo & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateComputePipelines( m_device, + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipeline", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue( result, std::move( pipeline ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createComputePipelinesUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateComputePipelines( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines; + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createComputePipelinesUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateComputePipelines( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::createComputePipelineUnique( + PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateComputePipelines( m_device, + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelineUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue>( + result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyPipeline( + static_cast( m_device ), static_cast( pipeline ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyPipeline( Pipeline pipeline, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyPipeline && "Function requires " ); +# endif + + d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyPipeline( + static_cast( m_device ), static_cast( pipeline ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyPipeline && "Function requires " ); +# endif + + d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + PipelineLayout * pPipelineLayout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreatePipelineLayout( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pPipelineLayout ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePipelineLayout && "Function requires " ); +# endif + + PipelineLayout pipelineLayout; + Result result = static_cast( d.vkCreatePipelineLayout( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipelineLayout ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" ); + + return detail::createResultValueType( result, std::move( pipelineLayout ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePipelineLayout && "Function requires " ); +# endif + + PipelineLayout pipelineLayout; + Result result = static_cast( d.vkCreatePipelineLayout( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipelineLayout ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( pipelineLayout, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyPipelineLayout( + static_cast( m_device ), static_cast( pipelineLayout ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyPipelineLayout( PipelineLayout pipelineLayout, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyPipelineLayout && "Function requires " ); +# endif + + d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyPipelineLayout( + static_cast( m_device ), static_cast( pipelineLayout ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( PipelineLayout pipelineLayout, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyPipelineLayout && "Function requires " ); +# endif + + d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Sampler * pSampler, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateSampler( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSampler ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createSampler( const SamplerCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSampler && "Function requires " ); +# endif + + Sampler sampler; + Result result = static_cast( d.vkCreateSampler( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &sampler ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" ); + + return detail::createResultValueType( result, std::move( sampler ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createSamplerUnique( const SamplerCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSampler && "Function requires " ); +# endif + + Sampler sampler; + Result result = static_cast( d.vkCreateSampler( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &sampler ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique" ); + + return detail::createResultValueType( result, UniqueHandle( sampler, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html + template ::type> + VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroySampler( static_cast( m_device ), static_cast( sampler ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html + template ::type> + VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroySampler && "Function requires " ); +# endif + + d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroySampler( static_cast( m_device ), static_cast( sampler ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroySampler && "Function requires " ); +# endif + + d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + DescriptorSetLayout * pSetLayout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDescriptorSetLayout( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSetLayout ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createDescriptorSetLayout( + const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDescriptorSetLayout && "Function requires " ); +# endif + + DescriptorSetLayout setLayout; + Result result = static_cast( d.vkCreateDescriptorSetLayout( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &setLayout ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" ); + + return detail::createResultValueType( result, std::move( setLayout ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::createDescriptorSetLayoutUnique( + const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDescriptorSetLayout && "Function requires " ); +# endif + + DescriptorSetLayout setLayout; + Result result = static_cast( d.vkCreateDescriptorSetLayout( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &setLayout ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( setLayout, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDescriptorSetLayout( static_cast( m_device ), + static_cast( descriptorSetLayout ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDescriptorSetLayout && "Function requires " ); +# endif + + d.vkDestroyDescriptorSetLayout( + m_device, static_cast( descriptorSetLayout ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDescriptorSetLayout( static_cast( m_device ), + static_cast( descriptorSetLayout ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( DescriptorSetLayout descriptorSetLayout, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDescriptorSetLayout && "Function requires " ); +# endif + + d.vkDestroyDescriptorSetLayout( + m_device, static_cast( descriptorSetLayout ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + DescriptorPool * pDescriptorPool, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDescriptorPool( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pDescriptorPool ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDescriptorPool && "Function requires " ); +# endif + + DescriptorPool descriptorPool; + Result result = static_cast( d.vkCreateDescriptorPool( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &descriptorPool ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPool" ); + + return detail::createResultValueType( result, std::move( descriptorPool ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDescriptorPool && "Function requires " ); +# endif + + DescriptorPool descriptorPool; + Result result = static_cast( d.vkCreateDescriptorPool( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &descriptorPool ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPoolUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( descriptorPool, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDescriptorPool( + static_cast( m_device ), static_cast( descriptorPool ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyDescriptorPool( DescriptorPool descriptorPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDescriptorPool && "Function requires " ); +# endif + + d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDescriptorPool( + static_cast( m_device ), static_cast( descriptorPool ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( DescriptorPool descriptorPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDescriptorPool && "Function requires " ); +# endif + + d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool, + DescriptorPoolResetFlags flags, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkResetDescriptorPool( + static_cast( m_device ), static_cast( descriptorPool ), static_cast( flags ) ) ); + } +#else + // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkResetDescriptorPool && "Function requires " ); +# endif + + Result result = static_cast( + d.vkResetDescriptorPool( m_device, static_cast( descriptorPool ), static_cast( flags ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetDescriptorPool" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo * pAllocateInfo, + DescriptorSet * pDescriptorSets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkAllocateDescriptorSets( static_cast( m_device ), + reinterpret_cast( pAllocateInfo ), + reinterpret_cast( pDescriptorSets ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function requires " ); +# endif + + std::vector descriptorSets( allocateInfo.descriptorSetCount ); + Result result = static_cast( d.vkAllocateDescriptorSets( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); + + return detail::createResultValueType( result, std::move( descriptorSets ) ); + } + + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateDescriptorSets( + const DescriptorSetAllocateInfo & allocateInfo, DescriptorSetAllocator const & descriptorSetAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function requires " ); +# endif + + std::vector descriptorSets( allocateInfo.descriptorSetCount, {}, descriptorSetAllocator ); + Result result = static_cast( d.vkAllocateDescriptorSets( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); + + return detail::createResultValueType( result, std::move( descriptorSets ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, DescriptorSetAllocator>>::type + Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function requires " ); +# endif + + std::vector descriptorSets( allocateInfo.descriptorSetCount ); + Result result = static_cast( d.vkAllocateDescriptorSets( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); + std::vector, DescriptorSetAllocator> uniqueDescriptorSets; + uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); + detail::PoolFree deleter( *this, allocateInfo.descriptorPool, d ); + for ( auto const & descriptorSet : descriptorSets ) + { + uniqueDescriptorSets.push_back( UniqueHandle( descriptorSet, deleter ) ); + } + return detail::createResultValueType( result, std::move( uniqueDescriptorSets ) ); + } + + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, DescriptorSetAllocator>>::type + Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, + DescriptorSetAllocator const & descriptorSetAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function requires " ); +# endif + + std::vector descriptorSets( allocateInfo.descriptorSetCount ); + Result result = static_cast( d.vkAllocateDescriptorSets( + m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); + std::vector, DescriptorSetAllocator> uniqueDescriptorSets( descriptorSetAllocator ); + uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); + detail::PoolFree deleter( *this, allocateInfo.descriptorPool, d ); + for ( auto const & descriptorSet : descriptorSets ) + { + uniqueDescriptorSets.push_back( UniqueHandle( descriptorSet, deleter ) ); + } + return detail::createResultValueType( result, std::move( uniqueDescriptorSets ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const DescriptorSet * pDescriptorSets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkFreeDescriptorSets( static_cast( m_device ), + static_cast( descriptorPool ), + descriptorSetCount, + reinterpret_cast( pDescriptorSets ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy const & descriptorSets, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function requires " ); +# endif + + Result result = static_cast( d.vkFreeDescriptorSets( + m_device, static_cast( descriptorPool ), descriptorSets.size(), reinterpret_cast( descriptorSets.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::freeDescriptorSets" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result( Device::free )( DescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const DescriptorSet * pDescriptorSets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkFreeDescriptorSets( static_cast( m_device ), + static_cast( descriptorPool ), + descriptorSetCount, + reinterpret_cast( pDescriptorSets ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE + typename ResultValueType::type( Device::free )( DescriptorPool descriptorPool, + ArrayProxy const & descriptorSets, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function requires " ); +# endif + + Result result = static_cast( d.vkFreeDescriptorSets( + m_device, static_cast( descriptorPool ), descriptorSets.size(), reinterpret_cast( descriptorSets.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::( Device::free )" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html + template ::type> + VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, + const WriteDescriptorSet * pDescriptorWrites, + uint32_t descriptorCopyCount, + const CopyDescriptorSet * pDescriptorCopies, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkUpdateDescriptorSets( static_cast( m_device ), + descriptorWriteCount, + reinterpret_cast( pDescriptorWrites ), + descriptorCopyCount, + reinterpret_cast( pDescriptorCopies ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html + template ::type> + VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy const & descriptorWrites, + ArrayProxy const & descriptorCopies, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSets && "Function requires " ); +# endif + + d.vkUpdateDescriptorSets( m_device, + descriptorWrites.size(), + reinterpret_cast( descriptorWrites.data() ), + descriptorCopies.size(), + reinterpret_cast( descriptorCopies.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindPipeline( + static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( pipeline ) ); + } + + // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const DescriptorSet * pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t * pDynamicOffsets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindDescriptorSets( static_cast( m_commandBuffer ), + static_cast( pipelineBindPoint ), + static_cast( layout ), + firstSet, + descriptorSetCount, + reinterpret_cast( pDescriptorSets ), + dynamicOffsetCount, + pDynamicOffsets ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t firstSet, + ArrayProxy const & descriptorSets, + ArrayProxy const & dynamicOffsets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets && "Function requires " ); +# endif + + d.vkCmdBindDescriptorSets( m_commandBuffer, + static_cast( pipelineBindPoint ), + static_cast( layout ), + firstSet, + descriptorSets.size(), + reinterpret_cast( descriptorSets.data() ), + dynamicOffsets.size(), + dynamicOffsets.data() ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, + ImageLayout imageLayout, + const ClearColorValue * pColor, + uint32_t rangeCount, + const ImageSubresourceRange * pRanges, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdClearColorImage( static_cast( m_commandBuffer ), + static_cast( image ), + static_cast( imageLayout ), + reinterpret_cast( pColor ), + rangeCount, + reinterpret_cast( pRanges ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, + ImageLayout imageLayout, + const ClearColorValue & color, + ArrayProxy const & ranges, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdClearColorImage && "Function requires " ); +# endif + + d.vkCmdClearColorImage( m_commandBuffer, + static_cast( image ), + static_cast( imageLayout ), + reinterpret_cast( &color ), + ranges.size(), + reinterpret_cast( ranges.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDispatch( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); + } + + // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDispatchIndirect( static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ) ); + } + + // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetEvent( static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); + } + + // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdResetEvent( static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); + } + + // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, + const Event * pEvents, + PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const MemoryBarrier * pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const BufferMemoryBarrier * pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const ImageMemoryBarrier * pImageMemoryBarriers, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWaitEvents( static_cast( m_commandBuffer ), + eventCount, + reinterpret_cast( pEvents ), + static_cast( srcStageMask ), + static_cast( dstStageMask ), + memoryBarrierCount, + reinterpret_cast( pMemoryBarriers ), + bufferMemoryBarrierCount, + reinterpret_cast( pBufferMemoryBarriers ), + imageMemoryBarrierCount, + reinterpret_cast( pImageMemoryBarriers ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy const & events, + PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + ArrayProxy const & memoryBarriers, + ArrayProxy const & bufferMemoryBarriers, + ArrayProxy const & imageMemoryBarriers, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdWaitEvents && "Function requires " ); +# endif + + d.vkCmdWaitEvents( m_commandBuffer, + events.size(), + reinterpret_cast( events.data() ), + static_cast( srcStageMask ), + static_cast( dstStageMask ), + memoryBarriers.size(), + reinterpret_cast( memoryBarriers.data() ), + bufferMemoryBarriers.size(), + reinterpret_cast( bufferMemoryBarriers.data() ), + imageMemoryBarriers.size(), + reinterpret_cast( imageMemoryBarriers.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushConstants( + PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void * pValues, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushConstants( static_cast( m_commandBuffer ), + static_cast( layout ), + static_cast( stageFlags ), + offset, + size, + pValues ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, + ShaderStageFlags stageFlags, + uint32_t offset, + ArrayProxy const & values, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPushConstants && "Function requires " ); +# endif + + d.vkCmdPushConstants( m_commandBuffer, + static_cast( layout ), + static_cast( stageFlags ), + offset, + values.size() * sizeof( ValuesType ), + reinterpret_cast( values.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache, + uint32_t createInfoCount, + const GraphicsPipelineCreateInfo * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateGraphicsPipelines( static_cast( m_device ), + static_cast( pipelineCache ), + createInfoCount, + reinterpret_cast( pCreateInfos ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pPipelines ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createGraphicsPipelines( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createGraphicsPipelines( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); + Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::createGraphicsPipeline( PipelineCache pipelineCache, + const GraphicsPipelineCreateInfo & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue( result, std::move( pipeline ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines; + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::createGraphicsPipelineUnique( + PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelineUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue>( + result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Framebuffer * pFramebuffer, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateFramebuffer( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pFramebuffer ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateFramebuffer && "Function requires " ); +# endif + + Framebuffer framebuffer; + Result result = static_cast( d.vkCreateFramebuffer( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &framebuffer ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" ); + + return detail::createResultValueType( result, std::move( framebuffer ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateFramebuffer && "Function requires " ); +# endif + + Framebuffer framebuffer; + Result result = static_cast( d.vkCreateFramebuffer( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &framebuffer ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( framebuffer, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyFramebuffer( + static_cast( m_device ), static_cast( framebuffer ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyFramebuffer( Framebuffer framebuffer, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyFramebuffer && "Function requires " ); +# endif + + d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyFramebuffer( + static_cast( m_device ), static_cast( framebuffer ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyFramebuffer && "Function requires " ); +# endif + + d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + RenderPass * pRenderPass, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateRenderPass( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pRenderPass ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRenderPass && "Function requires " ); +# endif + + RenderPass renderPass; + Result result = static_cast( d.vkCreateRenderPass( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &renderPass ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" ); + + return detail::createResultValueType( result, std::move( renderPass ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRenderPass && "Function requires " ); +# endif + + RenderPass renderPass; + Result result = static_cast( d.vkCreateRenderPass( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &renderPass ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( renderPass, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyRenderPass( + static_cast( m_device ), static_cast( renderPass ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyRenderPass( RenderPass renderPass, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyRenderPass && "Function requires " ); +# endif + + d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyRenderPass( + static_cast( m_device ), static_cast( renderPass ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyRenderPass && "Function requires " ); +# endif + + d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html + template ::type> + VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D * pGranularity, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetRenderAreaGranularity( static_cast( m_device ), static_cast( renderPass ), reinterpret_cast( pGranularity ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D Device::getRenderAreaGranularity( RenderPass renderPass, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRenderAreaGranularity && "Function requires " ); +# endif + + Extent2D granularity; + d.vkGetRenderAreaGranularity( m_device, static_cast( renderPass ), reinterpret_cast( &granularity ) ); + + return granularity; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport * pViewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetViewport( static_cast( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast( pViewports ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy const & viewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetViewport && "Function requires " ); +# endif + + d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size(), reinterpret_cast( viewports.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D * pScissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetScissor( static_cast( m_commandBuffer ), firstScissor, scissorCount, reinterpret_cast( pScissors ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy const & scissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetScissor && "Function requires " ); +# endif + + d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size(), reinterpret_cast( scissors.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetLineWidth( static_cast( m_commandBuffer ), lineWidth ); + } + + // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthBias( static_cast( m_commandBuffer ), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); + } + + // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetBlendConstants( static_cast( m_commandBuffer ), blendConstants ); + } + + // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthBounds( static_cast( m_commandBuffer ), minDepthBounds, maxDepthBounds ); + } + + // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetStencilCompareMask( static_cast( m_commandBuffer ), static_cast( faceMask ), compareMask ); + } + + // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetStencilWriteMask( static_cast( m_commandBuffer ), static_cast( faceMask ), writeMask ); + } + + // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetStencilReference( static_cast( m_commandBuffer ), static_cast( faceMask ), reference ); + } + + // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindIndexBuffer( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( indexType ) ); + } + + // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( + uint32_t firstBinding, uint32_t bindingCount, const Buffer * pBuffers, const DeviceSize * pOffsets, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindVertexBuffers( static_cast( m_commandBuffer ), + firstBinding, + bindingCount, + reinterpret_cast( pBuffers ), + reinterpret_cast( pOffsets ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers && "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); +# else + if ( buffers.size() != offsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdBindVertexBuffers( m_commandBuffer, + firstBinding, + buffers.size(), + reinterpret_cast( buffers.data() ), + reinterpret_cast( offsets.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::draw( + uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDraw( static_cast( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance ); + } + + // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndexed( static_cast( m_commandBuffer ), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); + } + + // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndirect( + static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); + } + + // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndexedIndirect( + static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); + } + + // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + uint32_t regionCount, + const ImageBlit * pRegions, + Filter filter, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBlitImage( static_cast( m_commandBuffer ), + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regionCount, + reinterpret_cast( pRegions ), + static_cast( filter ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions, + Filter filter, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBlitImage && "Function requires " ); +# endif + + d.vkCmdBlitImage( m_commandBuffer, + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regions.size(), + reinterpret_cast( regions.data() ), + static_cast( filter ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, + ImageLayout imageLayout, + const ClearDepthStencilValue * pDepthStencil, + uint32_t rangeCount, + const ImageSubresourceRange * pRanges, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdClearDepthStencilImage( static_cast( m_commandBuffer ), + static_cast( image ), + static_cast( imageLayout ), + reinterpret_cast( pDepthStencil ), + rangeCount, + reinterpret_cast( pRanges ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, + ImageLayout imageLayout, + const ClearDepthStencilValue & depthStencil, + ArrayProxy const & ranges, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdClearDepthStencilImage && "Function requires " ); +# endif + + d.vkCmdClearDepthStencilImage( m_commandBuffer, + static_cast( image ), + static_cast( imageLayout ), + reinterpret_cast( &depthStencil ), + ranges.size(), + reinterpret_cast( ranges.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( + uint32_t attachmentCount, const ClearAttachment * pAttachments, uint32_t rectCount, const ClearRect * pRects, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdClearAttachments( static_cast( m_commandBuffer ), + attachmentCount, + reinterpret_cast( pAttachments ), + rectCount, + reinterpret_cast( pRects ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy const & attachments, + ArrayProxy const & rects, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdClearAttachments && "Function requires " ); +# endif + + d.vkCmdClearAttachments( m_commandBuffer, + attachments.size(), + reinterpret_cast( attachments.data() ), + rects.size(), + reinterpret_cast( rects.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + uint32_t regionCount, + const ImageResolve * pRegions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdResolveImage( static_cast( m_commandBuffer ), + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regionCount, + reinterpret_cast( pRegions ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdResolveImage && "Function requires " ); +# endif + + d.vkCmdResolveImage( m_commandBuffer, + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regions.size(), + reinterpret_cast( regions.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::beginRenderPass( const RenderPassBeginInfo * pRenderPassBegin, SubpassContents contents, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginRenderPass( static_cast( m_commandBuffer ), + reinterpret_cast( pRenderPassBegin ), + static_cast( contents ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass && "Function requires " ); +# endif + + d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast( &renderPassBegin ), static_cast( contents ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdNextSubpass( static_cast( m_commandBuffer ), static_cast( contents ) ); + } + + // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endRenderPass( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndRenderPass( static_cast( m_commandBuffer ) ); + } + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceVersion( uint32_t * pApiVersion, Dispatch const & d ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkEnumerateInstanceVersion( pApiVersion ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type enumerateInstanceVersion( Dispatch const & d ) + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumerateInstanceVersion && "Function requires " ); +# endif + + uint32_t apiVersion; + Result result = static_cast( d.vkEnumerateInstanceVersion( &apiVersion ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceVersion" ); + + return detail::createResultValueType( result, std::move( apiVersion ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount, + const BindBufferMemoryInfo * pBindInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkBindBufferMemory2( static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::bindBufferMemory2( ArrayProxy const & bindInfos, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBindBufferMemory2 && "Function requires or " ); +# endif + + Result result = + static_cast( d.vkBindBufferMemory2( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount, + const BindImageMemoryInfo * pBindInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkBindImageMemory2( static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::bindImageMemory2( ArrayProxy const & bindInfos, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBindImageMemory2 && "Function requires or " ); +# endif + + Result result = + static_cast( d.vkBindImageMemory2( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html + template ::type> + VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + PeerMemoryFeatureFlags * pPeerMemoryFeatures, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceGroupPeerMemoryFeatures( + static_cast( m_device ), heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( pPeerMemoryFeatures ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPeerMemoryFeatures && + "Function requires or " ); +# endif + + PeerMemoryFeatureFlags peerMemoryFeatures; + d.vkGetDeviceGroupPeerMemoryFeatures( + m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( &peerMemoryFeatures ) ); + + return peerMemoryFeatures; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDeviceMask( static_cast( m_commandBuffer ), deviceMask ); + } + + // wrapper function for command vkEnumeratePhysicalDeviceGroups, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount, + PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkEnumeratePhysicalDeviceGroups( static_cast( m_instance ), + pPhysicalDeviceGroupCount, + reinterpret_cast( pPhysicalDeviceGroupProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumeratePhysicalDeviceGroups, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::enumeratePhysicalDeviceGroups( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroups && + "Function requires or " ); +# endif + + std::vector physicalDeviceGroupProperties; + uint32_t physicalDeviceGroupCount; + Result result; + do + { + result = static_cast( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceGroups( + m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); + if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + } + return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); + } + + // wrapper function for command vkEnumeratePhysicalDeviceGroups, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator const & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroups && + "Function requires or " ); +# endif + + std::vector physicalDeviceGroupProperties( physicalDeviceGroupPropertiesAllocator ); + uint32_t physicalDeviceGroupCount; + Result result; + do + { + result = static_cast( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceGroups( + m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); + if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + } + return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetImageMemoryRequirements2( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2 && + "Function requires or " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetImageMemoryRequirements2( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetImageMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2 && + "Function requires or " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetImageMemoryRequirements2( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html + template ::type> + VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetBufferMemoryRequirements2( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2 && + "Function requires or " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetBufferMemoryRequirements2( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetBufferMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2 && + "Function requires or " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetBufferMemoryRequirements2( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSparseMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 * pInfo, + uint32_t * pSparseMemoryRequirementCount, + SparseImageMemoryRequirements2 * pSparseMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetImageSparseMemoryRequirements2( static_cast( m_device ), + reinterpret_cast( pInfo ), + pSparseMemoryRequirementCount, + reinterpret_cast( pSparseMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSparseMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html + template < + typename SparseImageMemoryRequirements2Allocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2 && + "Function requires or " ); +# endif + + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + d.vkGetImageSparseMemoryRequirements2( + m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetImageSparseMemoryRequirements2( m_device, + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } + + // wrapper function for command vkGetImageSparseMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html + template < + typename SparseImageMemoryRequirements2Allocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, + SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2 && + "Function requires or " ); +# endif + + std::vector sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator ); + uint32_t sparseMemoryRequirementCount; + d.vkGetImageSparseMemoryRequirements2( + m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetImageSparseMemoryRequirements2( m_device, + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceFeatures2( static_cast( m_physicalDevice ), reinterpret_cast( pFeatures ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2 && + "Function requires or " ); +# endif + + PhysicalDeviceFeatures2 features; + d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( &features ) ); + + return features; + } + + // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2 && + "Function requires or " ); +# endif + + StructureChain structureChain; + PhysicalDeviceFeatures2 & features = structureChain.template get(); + d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( &features ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( PhysicalDeviceProperties2 * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceProperties2( static_cast( m_physicalDevice ), reinterpret_cast( pProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2 && + "Function requires or " ); +# endif + + PhysicalDeviceProperties2 properties; + d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( &properties ) ); + + return properties; + } + + // wrapper function for command vkGetPhysicalDeviceProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2 && + "Function requires or " ); +# endif + + StructureChain structureChain; + PhysicalDeviceProperties2 & properties = structureChain.template get(); + d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( &properties ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html + template ::type> + VULKAN_HPP_INLINE void + PhysicalDevice::getFormatProperties2( Format format, FormatProperties2 * pFormatProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceFormatProperties2( + static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( pFormatProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2( Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2 && + "Function requires or " ); +# endif + + FormatProperties2 formatProperties; + d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + + return formatProperties; + } + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFormatProperties2( Format format, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2 && + "Function requires or " ); +# endif + + StructureChain structureChain; + FormatProperties2 & formatProperties = structureChain.template get(); + d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, + ImageFormatProperties2 * pImageFormatProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( pImageFormatInfo ), + reinterpret_cast( pImageFormatProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2 && + "Function requires or " ); +# endif + + ImageFormatProperties2 imageFormatProperties; + Result result = + static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, + reinterpret_cast( &imageFormatInfo ), + reinterpret_cast( &imageFormatProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); + + return detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2 && + "Function requires or " ); +# endif + + StructureChain structureChain; + ImageFormatProperties2 & imageFormatProperties = structureChain.template get(); + Result result = + static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, + reinterpret_cast( &imageFormatInfo ), + reinterpret_cast( &imageFormatProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); + + return detail::createResultValueType( result, std::move( structureChain ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount, + QueueFamilyProperties2 * pQueueFamilyProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceQueueFamilyProperties2( + static_cast( m_physicalDevice ), pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && + "Function requires or " ); +# endif + + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + d.vkGetPhysicalDeviceQueueFamilyProperties2( + m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + queueFamilyProperties.resize( queueFamilyPropertyCount ); + } + return queueFamilyProperties; + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getQueueFamilyProperties2( QueueFamilyProperties2Allocator const & queueFamilyProperties2Allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && + "Function requires or " ); +# endif + + std::vector queueFamilyProperties( queueFamilyProperties2Allocator ); + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + d.vkGetPhysicalDeviceQueueFamilyProperties2( + m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + queueFamilyProperties.resize( queueFamilyPropertyCount ); + } + return queueFamilyProperties; + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && + "Function requires or " ); +# endif + + std::vector structureChains; + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + structureChains.resize( queueFamilyPropertyCount ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; + } + d.vkGetPhysicalDeviceQueueFamilyProperties2( + m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + structureChains.resize( queueFamilyPropertyCount ); + } + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + structureChains[i].template get() = queueFamilyProperties[i]; + } + return structureChains; + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && + "Function requires or " ); +# endif + + std::vector structureChains( structureChainAllocator ); + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + structureChains.resize( queueFamilyPropertyCount ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; + } + d.vkGetPhysicalDeviceQueueFamilyProperties2( + m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + structureChains.resize( queueFamilyPropertyCount ); + } + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + structureChains[i].template get() = queueFamilyProperties[i]; + } + return structureChains; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( PhysicalDeviceMemoryProperties2 * pMemoryProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceMemoryProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( pMemoryProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2 && + "Function requires or " ); +# endif + + PhysicalDeviceMemoryProperties2 memoryProperties; + d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + + return memoryProperties; + } + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2 && + "Function requires or " ); +# endif + + StructureChain structureChain; + PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get(); + d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, + uint32_t * pPropertyCount, + SparseImageFormatProperties2 * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( pFormatInfo ), + pPropertyCount, + reinterpret_cast( pProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2 && + "Function requires or " ); +# endif + + std::vector properties; + uint32_t propertyCount; + d.vkGetPhysicalDeviceSparseImageFormatProperties2( + m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); + properties.resize( propertyCount ); + d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, + reinterpret_cast( &formatInfo ), + &propertyCount, + reinterpret_cast( properties.data() ) ); + + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return properties; + } + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, + SparseImageFormatProperties2Allocator const & sparseImageFormatProperties2Allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2 && + "Function requires or " ); +# endif + + std::vector properties( sparseImageFormatProperties2Allocator ); + uint32_t propertyCount; + d.vkGetPhysicalDeviceSparseImageFormatProperties2( + m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); + properties.resize( propertyCount ); + d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, + reinterpret_cast( &formatInfo ), + &propertyCount, + reinterpret_cast( properties.data() ) ); + + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return properties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html + template ::type> + VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkTrimCommandPool( static_cast( m_device ), static_cast( commandPool ), static_cast( flags ) ); + } + + // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html + template ::type> + VULKAN_HPP_INLINE void Device::getQueue2( const DeviceQueueInfo2 * pQueueInfo, Queue * pQueue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceQueue2( static_cast( m_device ), reinterpret_cast( pQueueInfo ), reinterpret_cast( pQueue ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceQueue2 && "Function requires " ); +# endif + + Queue queue; + d.vkGetDeviceQueue2( m_device, reinterpret_cast( &queueInfo ), reinterpret_cast( &queue ) ); + + return queue; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, + ExternalBufferProperties * pExternalBufferProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceExternalBufferProperties( static_cast( m_physicalDevice ), + reinterpret_cast( pExternalBufferInfo ), + reinterpret_cast( pExternalBufferProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalBufferProperties + PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalBufferProperties && + "Function requires or " ); +# endif + + ExternalBufferProperties externalBufferProperties; + d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, + reinterpret_cast( &externalBufferInfo ), + reinterpret_cast( &externalBufferProperties ) ); + + return externalBufferProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, + ExternalFenceProperties * pExternalFenceProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceExternalFenceProperties( static_cast( m_physicalDevice ), + reinterpret_cast( pExternalFenceInfo ), + reinterpret_cast( pExternalFenceProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalFenceProperties + PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalFenceProperties && + "Function requires or " ); +# endif + + ExternalFenceProperties externalFenceProperties; + d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, + reinterpret_cast( &externalFenceInfo ), + reinterpret_cast( &externalFenceProperties ) ); + + return externalFenceProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, + ExternalSemaphoreProperties * pExternalSemaphoreProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceExternalSemaphoreProperties( static_cast( m_physicalDevice ), + reinterpret_cast( pExternalSemaphoreInfo ), + reinterpret_cast( pExternalSemaphoreProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( + const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalSemaphoreProperties && + "Function requires or " ); +# endif + + ExternalSemaphoreProperties externalSemaphoreProperties; + d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, + reinterpret_cast( &externalSemaphoreInfo ), + reinterpret_cast( &externalSemaphoreProperties ) ); + + return externalSemaphoreProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDispatchBase( static_cast( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); + } + + // wrapper function for command vkCreateDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + DescriptorUpdateTemplate * pDescriptorUpdateTemplate, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDescriptorUpdateTemplate( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pDescriptorUpdateTemplate ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createDescriptorUpdateTemplate( + const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplate && + "Function requires or " ); +# endif + + DescriptorUpdateTemplate descriptorUpdateTemplate; + Result result = static_cast( d.vkCreateDescriptorUpdateTemplate( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &descriptorUpdateTemplate ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" ); + + return detail::createResultValueType( result, std::move( descriptorUpdateTemplate ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplate && + "Function requires or " ); +# endif + + DescriptorUpdateTemplate descriptorUpdateTemplate; + Result result = static_cast( d.vkCreateDescriptorUpdateTemplate( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &descriptorUpdateTemplate ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( descriptorUpdateTemplate, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDescriptorUpdateTemplate( static_cast( m_device ), + static_cast( descriptorUpdateTemplate ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplate && + "Function requires or " ); +# endif + + d.vkDestroyDescriptorUpdateTemplate( + m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDescriptorUpdateTemplate( static_cast( m_device ), + static_cast( descriptorUpdateTemplate ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplate && + "Function requires or " ); +# endif + + d.vkDestroyDescriptorUpdateTemplate( + m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html + template ::type> + VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, + DescriptorUpdateTemplate descriptorUpdateTemplate, + const void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkUpdateDescriptorSetWithTemplate( static_cast( m_device ), + static_cast( descriptorSet ), + static_cast( descriptorUpdateTemplate ), + pData ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html + template ::type> + VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, + DescriptorUpdateTemplate descriptorUpdateTemplate, + DataType const & data, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSetWithTemplate && + "Function requires or " ); +# endif + + d.vkUpdateDescriptorSetWithTemplate( m_device, + static_cast( descriptorSet ), + static_cast( descriptorUpdateTemplate ), + reinterpret_cast( &data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDescriptorSetLayoutSupport, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html + template ::type> + VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo * pCreateInfo, + DescriptorSetLayoutSupport * pSupport, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDescriptorSetLayoutSupport( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pSupport ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetLayoutSupport, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupport && "Function requires or " ); +# endif + + DescriptorSetLayoutSupport support; + d.vkGetDescriptorSetLayoutSupport( + m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + + return support; + } + + // wrapper function for command vkGetDescriptorSetLayoutSupport, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupport && "Function requires or " ); +# endif + + StructureChain structureChain; + DescriptorSetLayoutSupport & support = structureChain.template get(); + d.vkGetDescriptorSetLayoutSupport( + m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateSamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + SamplerYcbcrConversion * pYcbcrConversion, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateSamplerYcbcrConversion( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pYcbcrConversion ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createSamplerYcbcrConversion( + const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversion && + "Function requires or " ); +# endif + + SamplerYcbcrConversion ycbcrConversion; + Result result = static_cast( d.vkCreateSamplerYcbcrConversion( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &ycbcrConversion ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" ); + + return detail::createResultValueType( result, std::move( ycbcrConversion ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversion && + "Function requires or " ); +# endif + + SamplerYcbcrConversion ycbcrConversion; + Result result = static_cast( d.vkCreateSamplerYcbcrConversion( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &ycbcrConversion ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( ycbcrConversion, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html + template ::type> + VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroySamplerYcbcrConversion( static_cast( m_device ), + static_cast( ycbcrConversion ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html + template ::type> + VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversion && + "Function requires or " ); +# endif + + d.vkDestroySamplerYcbcrConversion( + m_device, static_cast( ycbcrConversion ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroySamplerYcbcrConversion( static_cast( m_device ), + static_cast( ycbcrConversion ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( SamplerYcbcrConversion ycbcrConversion, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversion && + "Function requires or " ); +# endif + + d.vkDestroySamplerYcbcrConversion( + m_device, static_cast( ycbcrConversion ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_2 === + + // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html + template ::type> + VULKAN_HPP_INLINE void Device::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkResetQueryPool( static_cast( m_device ), static_cast( queryPool ), firstQuery, queryCount ); + } + + // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValue( Semaphore semaphore, + uint64_t * pValue, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetSemaphoreCounterValue( static_cast( m_device ), static_cast( semaphore ), pValue ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getSemaphoreCounterValue( Semaphore semaphore, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSemaphoreCounterValue && "Function requires or " ); +# endif + + uint64_t value; + Result result = static_cast( d.vkGetSemaphoreCounterValue( m_device, static_cast( semaphore ), &value ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValue" ); + + return detail::createResultValueType( result, std::move( value ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const SemaphoreWaitInfo * pWaitInfo, + uint64_t timeout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkWaitSemaphores( static_cast( m_device ), reinterpret_cast( pWaitInfo ), timeout ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkWaitSemaphores && "Function requires or " ); +# endif + + Result result = static_cast( d.vkWaitSemaphores( m_device, reinterpret_cast( &waitInfo ), timeout ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores", { Result::eSuccess, Result::eTimeout } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphore( const SemaphoreSignalInfo * pSignalInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkSignalSemaphore( static_cast( m_device ), reinterpret_cast( pSignalInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::signalSemaphore( const SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSignalSemaphore && "Function requires or " ); +# endif + + Result result = static_cast( d.vkSignalSemaphore( m_device, reinterpret_cast( &signalInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html + template ::type> + VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetBufferDeviceAddress( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html + template ::type> + VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddress && + "Function requires or or " ); +# endif + + VkDeviceAddress result = d.vkGetBufferDeviceAddress( m_device, reinterpret_cast( &info ) ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html + template ::type> + VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return d.vkGetBufferOpaqueCaptureAddress( static_cast( m_device ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html + template ::type> + VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureAddress && + "Function requires or " ); +# endif + + uint64_t result = d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast( &info ) ); + + return result; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html + template ::type> + VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return d.vkGetDeviceMemoryOpaqueCaptureAddress( static_cast( m_device ), + reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html + template ::type> + VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryOpaqueCaptureAddress && + "Function requires or " ); +# endif + + uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddress( m_device, reinterpret_cast( &info ) ); + + return result; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndirectCount( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + // wrapper function for command vkCmdDrawIndexedIndirectCount, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndexedIndirectCount( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass2( const RenderPassCreateInfo2 * pCreateInfo, + const AllocationCallbacks * pAllocator, + RenderPass * pRenderPass, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateRenderPass2( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pRenderPass ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createRenderPass2( const RenderPassCreateInfo2 & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRenderPass2 && "Function requires or " ); +# endif + + RenderPass renderPass; + Result result = static_cast( d.vkCreateRenderPass2( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &renderPass ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" ); + + return detail::createResultValueType( result, std::move( renderPass ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createRenderPass2Unique( const RenderPassCreateInfo2 & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRenderPass2 && "Function requires or " ); +# endif + + RenderPass renderPass; + Result result = static_cast( d.vkCreateRenderPass2( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &renderPass ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique" ); + + return detail::createResultValueType( result, + UniqueHandle( renderPass, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const RenderPassBeginInfo * pRenderPassBegin, + const SubpassBeginInfo * pSubpassBeginInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginRenderPass2( static_cast( m_commandBuffer ), + reinterpret_cast( pRenderPassBegin ), + reinterpret_cast( pSubpassBeginInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const RenderPassBeginInfo & renderPassBegin, + const SubpassBeginInfo & subpassBeginInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass2 && "Function requires or " ); +# endif + + d.vkCmdBeginRenderPass2( + m_commandBuffer, reinterpret_cast( &renderPassBegin ), reinterpret_cast( &subpassBeginInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const SubpassBeginInfo * pSubpassBeginInfo, + const SubpassEndInfo * pSubpassEndInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdNextSubpass2( static_cast( m_commandBuffer ), + reinterpret_cast( pSubpassBeginInfo ), + reinterpret_cast( pSubpassEndInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const SubpassBeginInfo & subpassBeginInfo, + const SubpassEndInfo & subpassEndInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdNextSubpass2 && "Function requires or " ); +# endif + + d.vkCmdNextSubpass2( + m_commandBuffer, reinterpret_cast( &subpassBeginInfo ), reinterpret_cast( &subpassEndInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndRenderPass2( static_cast( m_commandBuffer ), reinterpret_cast( pSubpassEndInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const SubpassEndInfo & subpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdEndRenderPass2 && "Function requires or " ); +# endif + + d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast( &subpassEndInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_3 === + + // wrapper function for command vkGetPhysicalDeviceToolProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getToolProperties( uint32_t * pToolCount, + PhysicalDeviceToolProperties * pToolProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceToolProperties( + static_cast( m_physicalDevice ), pToolCount, reinterpret_cast( pToolProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceToolProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getToolProperties( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolProperties && + "Function requires or " ); +# endif + + std::vector toolProperties; + uint32_t toolCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && toolCount ) + { + toolProperties.resize( toolCount ); + result = static_cast( + d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, reinterpret_cast( toolProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" ); + VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); + if ( toolCount < toolProperties.size() ) + { + toolProperties.resize( toolCount ); + } + return detail::createResultValueType( result, std::move( toolProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceToolProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getToolProperties( PhysicalDeviceToolPropertiesAllocator const & physicalDeviceToolPropertiesAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolProperties && + "Function requires or " ); +# endif + + std::vector toolProperties( physicalDeviceToolPropertiesAllocator ); + uint32_t toolCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && toolCount ) + { + toolProperties.resize( toolCount ); + result = static_cast( + d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, reinterpret_cast( toolProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" ); + VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); + if ( toolCount < toolProperties.size() ) + { + toolProperties.resize( toolCount ); + } + return detail::createResultValueType( result, std::move( toolProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPrivateDataSlot( const PrivateDataSlotCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + PrivateDataSlot * pPrivateDataSlot, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreatePrivateDataSlot( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pPrivateDataSlot ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createPrivateDataSlot( const PrivateDataSlotCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlot && "Function requires or " ); +# endif + + PrivateDataSlot privateDataSlot; + Result result = static_cast( d.vkCreatePrivateDataSlot( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &privateDataSlot ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlot" ); + + return detail::createResultValueType( result, std::move( privateDataSlot ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createPrivateDataSlotUnique( const PrivateDataSlotCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlot && "Function requires or " ); +# endif + + PrivateDataSlot privateDataSlot; + Result result = static_cast( d.vkCreatePrivateDataSlot( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &privateDataSlot ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( privateDataSlot, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyPrivateDataSlot( PrivateDataSlot privateDataSlot, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyPrivateDataSlot( + static_cast( m_device ), static_cast( privateDataSlot ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyPrivateDataSlot( PrivateDataSlot privateDataSlot, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlot && "Function requires or " ); +# endif + + d.vkDestroyPrivateDataSlot( + m_device, static_cast( privateDataSlot ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( PrivateDataSlot privateDataSlot, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyPrivateDataSlot( + static_cast( m_device ), static_cast( privateDataSlot ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( PrivateDataSlot privateDataSlot, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlot && "Function requires or " ); +# endif + + d.vkDestroyPrivateDataSlot( + m_device, static_cast( privateDataSlot ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setPrivateData( + ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkSetPrivateData( + static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); + } +#else + // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::setPrivateData( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetPrivateData && "Function requires or " ); +# endif + + Result result = static_cast( + d.vkSetPrivateData( m_device, static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateData" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html + template ::type> + VULKAN_HPP_INLINE void Device::getPrivateData( + ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPrivateData( + static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), pData ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t + Device::getPrivateData( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPrivateData && "Function requires or " ); +# endif + + uint64_t data; + d.vkGetPrivateData( m_device, static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), &data ); + + return data; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPipelineBarrier2( static_cast( m_commandBuffer ), reinterpret_cast( pDependencyInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier2 && "Function requires or " ); +# endif + + d.vkCmdPipelineBarrier2( m_commandBuffer, reinterpret_cast( &dependencyInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::writeTimestamp2( PipelineStageFlags2 stage, QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWriteTimestamp2( + static_cast( m_commandBuffer ), static_cast( stage ), static_cast( queryPool ), query ); + } + + // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Queue::submit2( uint32_t submitCount, const SubmitInfo2 * pSubmits, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkQueueSubmit2( static_cast( m_queue ), submitCount, reinterpret_cast( pSubmits ), static_cast( fence ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Queue::submit2( ArrayProxy const & submits, Fence fence, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkQueueSubmit2 && "Function requires or " ); +# endif + + Result result = static_cast( + d.vkQueueSubmit2( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyBuffer2( static_cast( m_commandBuffer ), reinterpret_cast( pCopyBufferInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer2 && "Function requires or " ); +# endif + + d.vkCmdCopyBuffer2( m_commandBuffer, reinterpret_cast( ©BufferInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyImage2( static_cast( m_commandBuffer ), reinterpret_cast( pCopyImageInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const CopyImageInfo2 & copyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyImage2 && "Function requires or " ); +# endif + + d.vkCmdCopyImage2( m_commandBuffer, reinterpret_cast( ©ImageInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyBufferToImage2( static_cast( m_commandBuffer ), reinterpret_cast( pCopyBufferToImageInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2( const CopyBufferToImageInfo2 & copyBufferToImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage2 && "Function requires or " ); +# endif + + d.vkCmdCopyBufferToImage2( m_commandBuffer, reinterpret_cast( ©BufferToImageInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyImageToBuffer2( static_cast( m_commandBuffer ), reinterpret_cast( pCopyImageToBufferInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2( const CopyImageToBufferInfo2 & copyImageToBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer2 && "Function requires or " ); +# endif + + d.vkCmdCopyImageToBuffer2( m_commandBuffer, reinterpret_cast( ©ImageToBufferInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html + template ::type> + VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceBufferMemoryRequirements( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirements && + "Function requires or " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetDeviceBufferMemoryRequirements( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDeviceBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirements && + "Function requires or " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetDeviceBufferMemoryRequirements( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceImageMemoryRequirements( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirements && + "Function requires or " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetDeviceImageMemoryRequirements( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDeviceImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirements && + "Function requires or " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetDeviceImageMemoryRequirements( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements * pInfo, + uint32_t * pSparseMemoryRequirementCount, + SparseImageMemoryRequirements2 * pSparseMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceImageSparseMemoryRequirements( static_cast( m_device ), + reinterpret_cast( pInfo ), + pSparseMemoryRequirementCount, + reinterpret_cast( pSparseMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html + template < + typename SparseImageMemoryRequirements2Allocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirements && + "Function requires or " ); +# endif + + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + d.vkGetDeviceImageSparseMemoryRequirements( + m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetDeviceImageSparseMemoryRequirements( m_device, + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } + + // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html + template < + typename SparseImageMemoryRequirements2Allocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info, + SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirements && + "Function requires or " ); +# endif + + std::vector sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator ); + uint32_t sparseMemoryRequirementCount; + d.vkGetDeviceImageSparseMemoryRequirements( + m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetDeviceImageSparseMemoryRequirements( m_device, + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setEvent2( Event event, const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetEvent2( + static_cast( m_commandBuffer ), static_cast( event ), reinterpret_cast( pDependencyInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setEvent2( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetEvent2 && "Function requires or " ); +# endif + + d.vkCmdSetEvent2( m_commandBuffer, static_cast( event ), reinterpret_cast( &dependencyInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::resetEvent2( Event event, PipelineStageFlags2 stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdResetEvent2( static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); + } + + // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::waitEvents2( uint32_t eventCount, + const Event * pEvents, + const DependencyInfo * pDependencyInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWaitEvents2( static_cast( m_commandBuffer ), + eventCount, + reinterpret_cast( pEvents ), + reinterpret_cast( pDependencyInfos ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::waitEvents2( ArrayProxy const & events, + ArrayProxy const & dependencyInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdWaitEvents2 && "Function requires or " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); +# else + if ( events.size() != dependencyInfos.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2: events.size() != dependencyInfos.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdWaitEvents2( m_commandBuffer, + events.size(), + reinterpret_cast( events.data() ), + reinterpret_cast( dependencyInfos.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBlitImage2( static_cast( m_commandBuffer ), reinterpret_cast( pBlitImageInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const BlitImageInfo2 & blitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBlitImage2 && "Function requires or " ); +# endif + + d.vkCmdBlitImage2( m_commandBuffer, reinterpret_cast( &blitImageInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdResolveImage2( static_cast( m_commandBuffer ), reinterpret_cast( pResolveImageInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdResolveImage2 && "Function requires or " ); +# endif + + d.vkCmdResolveImage2( m_commandBuffer, reinterpret_cast( &resolveImageInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const RenderingInfo * pRenderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginRendering( static_cast( m_commandBuffer ), reinterpret_cast( pRenderingInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const RenderingInfo & renderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginRendering && "Function requires or " ); +# endif + + d.vkCmdBeginRendering( m_commandBuffer, reinterpret_cast( &renderingInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endRendering( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndRendering( static_cast( m_commandBuffer ) ); + } + + // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCullMode( CullModeFlags cullMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetCullMode( static_cast( m_commandBuffer ), static_cast( cullMode ) ); + } + + // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setFrontFace( FrontFace frontFace, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetFrontFace( static_cast( m_commandBuffer ), static_cast( frontFace ) ); + } + + // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology( PrimitiveTopology primitiveTopology, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetPrimitiveTopology( static_cast( m_commandBuffer ), static_cast( primitiveTopology ) ); + } + + // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::setViewportWithCount( uint32_t viewportCount, const Viewport * pViewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetViewportWithCount( static_cast( m_commandBuffer ), viewportCount, reinterpret_cast( pViewports ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCount( ArrayProxy const & viewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetViewportWithCount && + "Function requires or or " ); +# endif + + d.vkCmdSetViewportWithCount( m_commandBuffer, viewports.size(), reinterpret_cast( viewports.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCount( uint32_t scissorCount, const Rect2D * pScissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetScissorWithCount( static_cast( m_commandBuffer ), scissorCount, reinterpret_cast( pScissors ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCount( ArrayProxy const & scissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetScissorWithCount && + "Function requires or or " ); +# endif + + d.vkCmdSetScissorWithCount( m_commandBuffer, scissors.size(), reinterpret_cast( scissors.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding, + uint32_t bindingCount, + const Buffer * pBuffers, + const DeviceSize * pOffsets, + const DeviceSize * pSizes, + const DeviceSize * pStrides, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindVertexBuffers2( static_cast( m_commandBuffer ), + firstBinding, + bindingCount, + reinterpret_cast( pBuffers ), + reinterpret_cast( pOffsets ), + reinterpret_cast( pSizes ), + reinterpret_cast( pStrides ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes, + ArrayProxy const & strides, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers2 && + "Function requires or or " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); + VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); + VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); +# else + if ( buffers.size() != offsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != offsets.size()" ); + } + if ( !sizes.empty() && buffers.size() != sizes.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != sizes.size()" ); + } + if ( !strides.empty() && buffers.size() != strides.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != strides.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdBindVertexBuffers2( m_commandBuffer, + firstBinding, + buffers.size(), + reinterpret_cast( buffers.data() ), + reinterpret_cast( offsets.data() ), + reinterpret_cast( sizes.data() ), + reinterpret_cast( strides.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable( Bool32 depthTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthTestEnable( static_cast( m_commandBuffer ), static_cast( depthTestEnable ) ); + } + + // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable( Bool32 depthWriteEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthWriteEnable( static_cast( m_commandBuffer ), static_cast( depthWriteEnable ) ); + } + + // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp( CompareOp depthCompareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthCompareOp( static_cast( m_commandBuffer ), static_cast( depthCompareOp ) ); + } + + // wrapper function for command vkCmdSetDepthBoundsTestEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthBoundsTestEnable( static_cast( m_commandBuffer ), static_cast( depthBoundsTestEnable ) ); + } + + // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable( Bool32 stencilTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetStencilTestEnable( static_cast( m_commandBuffer ), static_cast( stencilTestEnable ) ); + } + + // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setStencilOp( + StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetStencilOp( static_cast( m_commandBuffer ), + static_cast( faceMask ), + static_cast( failOp ), + static_cast( passOp ), + static_cast( depthFailOp ), + static_cast( compareOp ) ); + } + + // wrapper function for command vkCmdSetRasterizerDiscardEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetRasterizerDiscardEnable( static_cast( m_commandBuffer ), static_cast( rasterizerDiscardEnable ) ); + } + + // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable( Bool32 depthBiasEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthBiasEnable( static_cast( m_commandBuffer ), static_cast( depthBiasEnable ) ); + } + + // wrapper function for command vkCmdSetPrimitiveRestartEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable( Bool32 primitiveRestartEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetPrimitiveRestartEnable( static_cast( m_commandBuffer ), static_cast( primitiveRestartEnable ) ); + } + + //=== VK_VERSION_1_4 === + + // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory2( const MemoryMapInfo * pMemoryMapInfo, + void ** ppData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkMapMemory2( static_cast( m_device ), reinterpret_cast( pMemoryMapInfo ), ppData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::mapMemory2( const MemoryMapInfo & memoryMapInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkMapMemory2 && "Function requires or " ); +# endif + + void * pData; + Result result = static_cast( d.vkMapMemory2( m_device, reinterpret_cast( &memoryMapInfo ), &pData ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2" ); + + return detail::createResultValueType( result, std::move( pData ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::unmapMemory2( const MemoryUnmapInfo * pMemoryUnmapInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkUnmapMemory2( static_cast( m_device ), reinterpret_cast( pMemoryUnmapInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkUnmapMemory2 && "Function requires or " ); +# endif + + Result result = static_cast( d.vkUnmapMemory2( m_device, reinterpret_cast( &memoryUnmapInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::unmapMemory2" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageSubresourceLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html + template ::type> + VULKAN_HPP_INLINE void + Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo * pInfo, SubresourceLayout2 * pLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceImageSubresourceLayout( + static_cast( m_device ), reinterpret_cast( pInfo ), reinterpret_cast( pLayout ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageSubresourceLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayout && + "Function requires or " ); +# endif + + SubresourceLayout2 layout; + d.vkGetDeviceImageSubresourceLayout( + m_device, reinterpret_cast( &info ), reinterpret_cast( &layout ) ); + + return layout; + } + + // wrapper function for command vkGetDeviceImageSubresourceLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayout && + "Function requires or " ); +# endif + + StructureChain structureChain; + SubresourceLayout2 & layout = structureChain.template get(); + d.vkGetDeviceImageSubresourceLayout( + m_device, reinterpret_cast( &info ), reinterpret_cast( &layout ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageSubresourceLayout2( Image image, + const ImageSubresource2 * pSubresource, + SubresourceLayout2 * pLayout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetImageSubresourceLayout2( static_cast( m_device ), + static_cast( image ), + reinterpret_cast( pSubresource ), + reinterpret_cast( pLayout ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout2( Image image, + const ImageSubresource2 & subresource, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( + d.vkGetImageSubresourceLayout2 && + "Function requires or or or " ); +# endif + + SubresourceLayout2 layout; + d.vkGetImageSubresourceLayout2( m_device, + static_cast( image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return layout; + } + + // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getImageSubresourceLayout2( Image image, const ImageSubresource2 & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( + d.vkGetImageSubresourceLayout2 && + "Function requires or or or " ); +# endif + + StructureChain structureChain; + SubresourceLayout2 & layout = structureChain.template get(); + d.vkGetImageSubresourceLayout2( m_device, + static_cast( image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToImage( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkCopyMemoryToImage( static_cast( m_device ), reinterpret_cast( pCopyMemoryToImageInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::copyMemoryToImage( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyMemoryToImage && "Function requires or " ); +# endif + + Result result = static_cast( d.vkCopyMemoryToImage( m_device, reinterpret_cast( ©MemoryToImageInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToImage" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToMemory( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkCopyImageToMemory( static_cast( m_device ), reinterpret_cast( pCopyImageToMemoryInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::copyImageToMemory( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyImageToMemory && "Function requires or " ); +# endif + + Result result = static_cast( d.vkCopyImageToMemory( m_device, reinterpret_cast( ©ImageToMemoryInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToMemory" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToImage( const CopyImageToImageInfo * pCopyImageToImageInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkCopyImageToImage( static_cast( m_device ), reinterpret_cast( pCopyImageToImageInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::copyImageToImage( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyImageToImage && "Function requires or " ); +# endif + + Result result = static_cast( d.vkCopyImageToImage( m_device, reinterpret_cast( ©ImageToImageInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToImage" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::transitionImageLayout( uint32_t transitionCount, + const HostImageLayoutTransitionInfo * pTransitions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkTransitionImageLayout( + static_cast( m_device ), transitionCount, reinterpret_cast( pTransitions ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::transitionImageLayout( ArrayProxy const & transitions, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkTransitionImageLayout && "Function requires or " ); +# endif + + Result result = static_cast( + d.vkTransitionImageLayout( m_device, transitions.size(), reinterpret_cast( transitions.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::transitionImageLayout" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const WriteDescriptorSet * pDescriptorWrites, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushDescriptorSet( static_cast( m_commandBuffer ), + static_cast( pipelineBindPoint ), + static_cast( layout ), + set, + descriptorWriteCount, + reinterpret_cast( pDescriptorWrites ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t set, + ArrayProxy const & descriptorWrites, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSet && "Function requires or " ); +# endif + + d.vkCmdPushDescriptorSet( m_commandBuffer, + static_cast( pipelineBindPoint ), + static_cast( layout ), + set, + descriptorWrites.size(), + reinterpret_cast( descriptorWrites.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate( + DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushDescriptorSetWithTemplate( static_cast( m_commandBuffer ), + static_cast( descriptorUpdateTemplate ), + static_cast( layout ), + set, + pData ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, + PipelineLayout layout, + uint32_t set, + DataType const & data, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( + d.vkCmdPushDescriptorSetWithTemplate && + "Function requires or or " ); +# endif + + d.vkCmdPushDescriptorSetWithTemplate( m_commandBuffer, + static_cast( descriptorUpdateTemplate ), + static_cast( layout ), + set, + reinterpret_cast( &data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindDescriptorSets2( static_cast( m_commandBuffer ), + reinterpret_cast( pBindDescriptorSetsInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2( const BindDescriptorSetsInfo & bindDescriptorSetsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets2 && "Function requires or " ); +# endif + + d.vkCmdBindDescriptorSets2( m_commandBuffer, reinterpret_cast( &bindDescriptorSetsInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushConstants2( const PushConstantsInfo * pPushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushConstants2( static_cast( m_commandBuffer ), reinterpret_cast( pPushConstantsInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushConstants2( const PushConstantsInfo & pushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPushConstants2 && "Function requires or " ); +# endif + + d.vkCmdPushConstants2( m_commandBuffer, reinterpret_cast( &pushConstantsInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2( const PushDescriptorSetInfo * pPushDescriptorSetInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushDescriptorSet2( static_cast( m_commandBuffer ), reinterpret_cast( pPushDescriptorSetInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2( const PushDescriptorSetInfo & pushDescriptorSetInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSet2 && "Function requires or " ); +# endif + + d.vkCmdPushDescriptorSet2( m_commandBuffer, reinterpret_cast( &pushDescriptorSetInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushDescriptorSetWithTemplate2( static_cast( m_commandBuffer ), + reinterpret_cast( pPushDescriptorSetWithTemplateInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetWithTemplate2 && + "Function requires or " ); +# endif + + d.vkCmdPushDescriptorSetWithTemplate2( m_commandBuffer, + reinterpret_cast( &pushDescriptorSetWithTemplateInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setLineStipple( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetLineStipple( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); + } + + // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::bindIndexBuffer2( Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindIndexBuffer2( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( size ), + static_cast( indexType ) ); + } + + // wrapper function for command vkGetRenderingAreaGranularity, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html + template ::type> + VULKAN_HPP_INLINE void + Device::getRenderingAreaGranularity( const RenderingAreaInfo * pRenderingAreaInfo, Extent2D * pGranularity, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetRenderingAreaGranularity( + static_cast( m_device ), reinterpret_cast( pRenderingAreaInfo ), reinterpret_cast( pGranularity ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRenderingAreaGranularity, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D Device::getRenderingAreaGranularity( const RenderingAreaInfo & renderingAreaInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRenderingAreaGranularity && "Function requires or " ); +# endif + + Extent2D granularity; + d.vkGetRenderingAreaGranularity( + m_device, reinterpret_cast( &renderingAreaInfo ), reinterpret_cast( &granularity ) ); + + return granularity; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetRenderingAttachmentLocations, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo * pLocationInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetRenderingAttachmentLocations( static_cast( m_commandBuffer ), + reinterpret_cast( pLocationInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetRenderingAttachmentLocations, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo & locationInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetRenderingAttachmentLocations && + "Function requires or " ); +# endif + + d.vkCmdSetRenderingAttachmentLocations( m_commandBuffer, reinterpret_cast( &locationInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetRenderingInputAttachmentIndices( static_cast( m_commandBuffer ), + reinterpret_cast( pInputAttachmentIndexInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetRenderingInputAttachmentIndices && + "Function requires or " ); +# endif + + d.vkCmdSetRenderingInputAttachmentIndices( m_commandBuffer, reinterpret_cast( &inputAttachmentIndexInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_surface === + + // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html + template ::type> + VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroySurfaceKHR( + static_cast( m_instance ), static_cast( surface ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html + template ::type> + VULKAN_HPP_INLINE void + Instance::destroySurfaceKHR( SurfaceKHR surface, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroySurfaceKHR && "Function requires " ); +# endif + + d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html + template ::type> + VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroySurfaceKHR( + static_cast( m_instance ), static_cast( surface ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html + template ::type> + VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroySurfaceKHR && "Function requires " ); +# endif + + d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32 * pSupported, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceSurfaceSupportKHR( + static_cast( m_physicalDevice ), queueFamilyIndex, static_cast( surface ), reinterpret_cast( pSupported ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceSupportKHR && "Function requires " ); +# endif + + Bool32 supported; + Result result = static_cast( d.vkGetPhysicalDeviceSurfaceSupportKHR( + m_physicalDevice, queueFamilyIndex, static_cast( surface ), reinterpret_cast( &supported ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); + + return detail::createResultValueType( result, std::move( supported ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, + SurfaceCapabilitiesKHR * pSurfaceCapabilities, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( static_cast( m_physicalDevice ), + static_cast( surface ), + reinterpret_cast( pSurfaceCapabilities ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR && "Function requires " ); +# endif + + SurfaceCapabilitiesKHR surfaceCapabilities; + Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( + m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); + + return detail::createResultValueType( result, std::move( surfaceCapabilities ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, + uint32_t * pSurfaceFormatCount, + SurfaceFormatKHR * pSurfaceFormats, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast( m_physicalDevice ), + static_cast( surface ), + pSurfaceFormatCount, + reinterpret_cast( pSurfaceFormats ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormatsKHR && "Function requires " ); +# endif + + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; + do + { + result = + static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast( surface ), &surfaceFormatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + surfaceFormats.resize( surfaceFormatCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( + m_physicalDevice, static_cast( surface ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + if ( surfaceFormatCount < surfaceFormats.size() ) + { + surfaceFormats.resize( surfaceFormatCount ); + } + return detail::createResultValueType( result, std::move( surfaceFormats ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, SurfaceFormatKHRAllocator const & surfaceFormatKHRAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormatsKHR && "Function requires " ); +# endif + + std::vector surfaceFormats( surfaceFormatKHRAllocator ); + uint32_t surfaceFormatCount; + Result result; + do + { + result = + static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast( surface ), &surfaceFormatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + surfaceFormats.resize( surfaceFormatCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( + m_physicalDevice, static_cast( surface ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + if ( surfaceFormatCount < surfaceFormats.size() ) + { + surfaceFormats.resize( surfaceFormatCount ); + } + return detail::createResultValueType( result, std::move( surfaceFormats ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, + uint32_t * pPresentModeCount, + PresentModeKHR * pPresentModes, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast( m_physicalDevice ), + static_cast( surface ), + pPresentModeCount, + reinterpret_cast( pPresentModes ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModesKHR && "Function requires " ); +# endif + + std::vector presentModes; + uint32_t presentModeCount; + Result result; + do + { + result = static_cast( + d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast( surface ), &presentModeCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentModeCount ) + { + presentModes.resize( presentModeCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( + m_physicalDevice, static_cast( surface ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + if ( presentModeCount < presentModes.size() ) + { + presentModes.resize( presentModeCount ); + } + return detail::createResultValueType( result, std::move( presentModes ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, PresentModeKHRAllocator const & presentModeKHRAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModesKHR && "Function requires " ); +# endif + + std::vector presentModes( presentModeKHRAllocator ); + uint32_t presentModeCount; + Result result; + do + { + result = static_cast( + d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast( surface ), &presentModeCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentModeCount ) + { + presentModes.resize( presentModeCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( + m_physicalDevice, static_cast( surface ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + if ( presentModeCount < presentModes.size() ) + { + presentModes.resize( presentModeCount ); + } + return detail::createResultValueType( result, std::move( presentModes ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_swapchain === + + // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SwapchainKHR * pSwapchain, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateSwapchainKHR( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSwapchain ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSwapchainKHR && "Function requires " ); +# endif + + SwapchainKHR swapchain; + Result result = static_cast( d.vkCreateSwapchainKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &swapchain ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" ); + + return detail::createResultValueType( result, std::move( swapchain ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSwapchainKHR && "Function requires " ); +# endif + + SwapchainKHR swapchain; + Result result = static_cast( d.vkCreateSwapchainKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &swapchain ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( swapchain, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroySwapchainKHR( + static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroySwapchainKHR( SwapchainKHR swapchain, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroySwapchainKHR && "Function requires " ); +# endif + + d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroySwapchainKHR( + static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroySwapchainKHR && "Function requires " ); +# endif + + d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain, + uint32_t * pSwapchainImageCount, + Image * pSwapchainImages, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetSwapchainImagesKHR( + static_cast( m_device ), static_cast( swapchain ), pSwapchainImageCount, reinterpret_cast( pSwapchainImages ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSwapchainImagesKHR && "Function requires " ); +# endif + + std::vector swapchainImages; + uint32_t swapchainImageCount; + Result result; + do + { + result = static_cast( d.vkGetSwapchainImagesKHR( m_device, static_cast( swapchain ), &swapchainImageCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && swapchainImageCount ) + { + swapchainImages.resize( swapchainImageCount ); + result = static_cast( d.vkGetSwapchainImagesKHR( + m_device, static_cast( swapchain ), &swapchainImageCount, reinterpret_cast( swapchainImages.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" ); + VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); + if ( swapchainImageCount < swapchainImages.size() ) + { + swapchainImages.resize( swapchainImageCount ); + } + return detail::createResultValueType( result, std::move( swapchainImages ) ); + } + + // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getSwapchainImagesKHR( SwapchainKHR swapchain, ImageAllocator const & imageAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSwapchainImagesKHR && "Function requires " ); +# endif + + std::vector swapchainImages( imageAllocator ); + uint32_t swapchainImageCount; + Result result; + do + { + result = static_cast( d.vkGetSwapchainImagesKHR( m_device, static_cast( swapchain ), &swapchainImageCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && swapchainImageCount ) + { + swapchainImages.resize( swapchainImageCount ); + result = static_cast( d.vkGetSwapchainImagesKHR( + m_device, static_cast( swapchain ), &swapchainImageCount, reinterpret_cast( swapchainImages.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" ); + VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); + if ( swapchainImageCount < swapchainImages.size() ) + { + swapchainImages.resize( swapchainImageCount ); + } + return detail::createResultValueType( result, std::move( swapchainImages ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( + SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t * pImageIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkAcquireNextImageKHR( static_cast( m_device ), + static_cast( swapchain ), + timeout, + static_cast( semaphore ), + static_cast( fence ), + pImageIndex ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue + Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAcquireNextImageKHR && "Function requires " ); +# endif + + uint32_t imageIndex; + Result result = static_cast( d.vkAcquireNextImageKHR( + m_device, static_cast( swapchain ), timeout, static_cast( semaphore ), static_cast( fence ), &imageIndex ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR", + { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); +# endif + + return ResultValue( result, std::move( imageIndex ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR * pPresentInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkQueuePresentKHR( static_cast( m_queue ), reinterpret_cast( pPresentInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkQueuePresentKHR && "Function requires " ); +# endif + + Result result = static_cast( d.vkQueuePresentKHR( m_queue, reinterpret_cast( &presentInfo ) ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); +# endif + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDeviceGroupPresentCapabilitiesKHR( + static_cast( m_device ), reinterpret_cast( pDeviceGroupPresentCapabilities ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getGroupPresentCapabilitiesKHR( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPresentCapabilitiesKHR && + "Function requires or " ); +# endif + + DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; + Result result = static_cast( + d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast( &deviceGroupPresentCapabilities ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); + + return detail::createResultValueType( result, std::move( deviceGroupPresentCapabilities ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, + DeviceGroupPresentModeFlagsKHR * pModes, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDeviceGroupSurfacePresentModesKHR( + static_cast( m_device ), static_cast( surface ), reinterpret_cast( pModes ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceGroupSurfacePresentModesKHR && + "Function requires or " ); +# endif + + DeviceGroupPresentModeFlagsKHR modes; + Result result = static_cast( d.vkGetDeviceGroupSurfacePresentModesKHR( + m_device, static_cast( surface ), reinterpret_cast( &modes ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); + + return detail::createResultValueType( result, std::move( modes ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, uint32_t * pRectCount, Rect2D * pRects, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( + static_cast( m_physicalDevice ), static_cast( surface ), pRectCount, reinterpret_cast( pRects ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDevicePresentRectanglesKHR && + "Function requires or " ); +# endif + + std::vector rects; + uint32_t rectCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast( surface ), &rectCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && rectCount ) + { + rects.resize( rectCount ); + result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( + m_physicalDevice, static_cast( surface ), &rectCount, reinterpret_cast( rects.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); + VULKAN_HPP_ASSERT( rectCount <= rects.size() ); + if ( rectCount < rects.size() ) + { + rects.resize( rectCount ); + } + return detail::createResultValueType( result, std::move( rects ) ); + } + + // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Rect2DAllocator const & rect2DAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDevicePresentRectanglesKHR && + "Function requires or " ); +# endif + + std::vector rects( rect2DAllocator ); + uint32_t rectCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast( surface ), &rectCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && rectCount ) + { + rects.resize( rectCount ); + result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( + m_physicalDevice, static_cast( surface ), &rectCount, reinterpret_cast( rects.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); + VULKAN_HPP_ASSERT( rectCount <= rects.size() ); + if ( rectCount < rects.size() ) + { + rects.resize( rectCount ); + } + return detail::createResultValueType( result, std::move( rects ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR * pAcquireInfo, + uint32_t * pImageIndex, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkAcquireNextImage2KHR( static_cast( m_device ), reinterpret_cast( pAcquireInfo ), pImageIndex ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAcquireNextImage2KHR && "Function requires or " ); +# endif + + uint32_t imageIndex; + Result result = + static_cast( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast( &acquireInfo ), &imageIndex ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR", + { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); +# endif + + return ResultValue( result, std::move( imageIndex ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_display === + + // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t * pPropertyCount, + DisplayPropertiesKHR * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( + static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayPropertiesKHR( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPropertiesKHR && "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( + d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator const & displayPropertiesKHRAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPropertiesKHR && "Function requires " ); +# endif + + std::vector properties( displayPropertiesKHRAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( + d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount, + DisplayPlanePropertiesKHR * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayPlanePropertiesKHR( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR && "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator const & displayPlanePropertiesKHRAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR && "Function requires " ); +# endif + + std::vector properties( displayPlanePropertiesKHRAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, + uint32_t * pDisplayCount, + DisplayKHR * pDisplays, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( + static_cast( m_physicalDevice ), planeIndex, pDisplayCount, reinterpret_cast( pDisplays ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneSupportedDisplaysKHR && "Function requires " ); +# endif + + std::vector displays; + uint32_t displayCount; + Result result; + do + { + result = static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && displayCount ) + { + displays.resize( displayCount ); + result = static_cast( + d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast( displays.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); + VULKAN_HPP_ASSERT( displayCount <= displays.size() ); + if ( displayCount < displays.size() ) + { + displays.resize( displayCount ); + } + return detail::createResultValueType( result, std::move( displays ) ); + } + + // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, DisplayKHRAllocator const & displayKHRAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneSupportedDisplaysKHR && "Function requires " ); +# endif + + std::vector displays( displayKHRAllocator ); + uint32_t displayCount; + Result result; + do + { + result = static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && displayCount ) + { + displays.resize( displayCount ); + result = static_cast( + d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast( displays.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); + VULKAN_HPP_ASSERT( displayCount <= displays.size() ); + if ( displayCount < displays.size() ) + { + displays.resize( displayCount ); + } + return detail::createResultValueType( result, std::move( displays ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDisplayModePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, + uint32_t * pPropertyCount, + DisplayModePropertiesKHR * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDisplayModePropertiesKHR( static_cast( m_physicalDevice ), + static_cast( display ), + pPropertyCount, + reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDisplayModePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDisplayModePropertiesKHR && "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetDisplayModePropertiesKHR( + m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetDisplayModePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, + DisplayModePropertiesKHRAllocator const & displayModePropertiesKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDisplayModePropertiesKHR && "Function requires " ); +# endif + + std::vector properties( displayModePropertiesKHRAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetDisplayModePropertiesKHR( + m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display, + const DisplayModeCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + DisplayModeKHR * pMode, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDisplayModeKHR( static_cast( m_physicalDevice ), + static_cast( display ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pMode ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::createDisplayModeKHR( + DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDisplayModeKHR && "Function requires " ); +# endif + + DisplayModeKHR mode; + Result result = static_cast( d.vkCreateDisplayModeKHR( m_physicalDevice, + static_cast( display ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &mode ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" ); + + return detail::createResultValueType( result, std::move( mode ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::createDisplayModeKHRUnique( + DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDisplayModeKHR && "Function requires " ); +# endif + + DisplayModeKHR mode; + Result result = static_cast( d.vkCreateDisplayModeKHR( m_physicalDevice, + static_cast( display ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &mode ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHRUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( mode, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, + uint32_t planeIndex, + DisplayPlaneCapabilitiesKHR * pCapabilities, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDisplayPlaneCapabilitiesKHR( static_cast( m_physicalDevice ), + static_cast( mode ), + planeIndex, + reinterpret_cast( pCapabilities ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneCapabilitiesKHR && "Function requires " ); +# endif + + DisplayPlaneCapabilitiesKHR capabilities; + Result result = static_cast( d.vkGetDisplayPlaneCapabilitiesKHR( + m_physicalDevice, static_cast( mode ), planeIndex, reinterpret_cast( &capabilities ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" ); + + return detail::createResultValueType( result, std::move( capabilities ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDisplayPlaneSurfaceKHR( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createDisplayPlaneSurfaceKHR( + const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDisplayPlaneSurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createDisplayPlaneSurfaceKHRUnique( + const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDisplayPlaneSurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHRUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_display_swapchain === + + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, + const SwapchainCreateInfoKHR * pCreateInfos, + const AllocationCallbacks * pAllocator, + SwapchainKHR * pSwapchains, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateSharedSwapchainsKHR( static_cast( m_device ), + swapchainCount, + reinterpret_cast( pCreateInfos ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSwapchains ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::createSharedSwapchainsKHR( + ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); +# endif + + std::vector swapchains( createInfos.size() ); + Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( swapchains.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); + + return detail::createResultValueType( result, std::move( swapchains ) ); + } + + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createSharedSwapchainsKHR( ArrayProxy const & createInfos, + Optional allocator, + SwapchainKHRAllocator const & swapchainKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); +# endif + + std::vector swapchains( createInfos.size(), {}, swapchainKHRAllocator ); + Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( swapchains.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); + + return detail::createResultValueType( result, std::move( swapchains ) ); + } + + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); +# endif + + SwapchainKHR swapchain; + Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &swapchain ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" ); + + return detail::createResultValueType( result, std::move( swapchain ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, SwapchainKHRAllocator>>::type + Device::createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); +# endif + + std::vector swapchains( createInfos.size() ); + Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( swapchains.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); + std::vector, SwapchainKHRAllocator> uniqueSwapchains; + uniqueSwapchains.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & swapchain : swapchains ) + { + uniqueSwapchains.push_back( UniqueHandle( swapchain, deleter ) ); + } + return detail::createResultValueType( result, std::move( uniqueSwapchains ) ); + } + + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, SwapchainKHRAllocator>>::type + Device::createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, + Optional allocator, + SwapchainKHRAllocator const & swapchainKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); +# endif + + std::vector swapchains( createInfos.size() ); + Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( swapchains.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); + std::vector, SwapchainKHRAllocator> uniqueSwapchains( swapchainKHRAllocator ); + uniqueSwapchains.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & swapchain : swapchains ) + { + uniqueSwapchains.push_back( UniqueHandle( swapchain, deleter ) ); + } + return detail::createResultValueType( result, std::move( uniqueSwapchains ) ); + } + + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); +# endif + + SwapchainKHR swapchain; + Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &swapchain ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHRUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( swapchain, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateXlibSurfaceKHR( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateXlibSurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateXlibSurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateXlibSurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateXlibSurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHRUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html + template ::type> + VULKAN_HPP_INLINE Bool32 + PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display * dpy, VisualID visualID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceXlibPresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex, dpy, visualID ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html + template ::type> + VULKAN_HPP_INLINE Bool32 + PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceXlibPresentationSupportKHR && + "Function requires " ); +# endif + + VkBool32 result = d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID ); + + return static_cast( result ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateXcbSurfaceKHR( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateXcbSurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateXcbSurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateXcbSurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateXcbSurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHRUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html + template ::type> + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, + xcb_connection_t * connection, + xcb_visualid_t visual_id, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceXcbPresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex, connection, visual_id ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html + template ::type> + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, + xcb_connection_t & connection, + xcb_visualid_t visual_id, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceXcbPresentationSupportKHR && + "Function requires " ); +# endif + + VkBool32 result = d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id ); + + return static_cast( result ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateWaylandSurfaceKHR( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateWaylandSurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateWaylandSurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createWaylandSurfaceKHRUnique( + const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateWaylandSurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateWaylandSurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHRUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html + template ::type> + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, + struct wl_display * display, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex, display ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html + template ::type> + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, + struct wl_display & display, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceWaylandPresentationSupportKHR && + "Function requires " ); +# endif + + VkBool32 result = d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display ); + + return static_cast( result ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateAndroidSurfaceKHR( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateAndroidSurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateAndroidSurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createAndroidSurfaceKHRUnique( + const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateAndroidSurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateAndroidSurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHRUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateWin32SurfaceKHR( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateWin32SurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateWin32SurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createWin32SurfaceKHRUnique( + const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateWin32SurfaceKHR && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateWin32SurfaceKHR( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHRUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html + template ::type> + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceWin32PresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex ) ); + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + + // wrapper function for command vkCreateDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + DebugReportCallbackEXT * pCallback, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDebugReportCallbackEXT( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pCallback ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createDebugReportCallbackEXT( + const DebugReportCallbackCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDebugReportCallbackEXT && "Function requires " ); +# endif + + DebugReportCallbackEXT callback; + Result result = static_cast( d.vkCreateDebugReportCallbackEXT( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &callback ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" ); + + return detail::createResultValueType( result, std::move( callback ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDebugReportCallbackEXT && "Function requires " ); +# endif + + DebugReportCallbackEXT callback; + Result result = static_cast( d.vkCreateDebugReportCallbackEXT( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &callback ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXTUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( callback, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html + template ::type> + VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDebugReportCallbackEXT( + static_cast( m_instance ), static_cast( callback ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html + template ::type> + VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDebugReportCallbackEXT && "Function requires " ); +# endif + + d.vkDestroyDebugReportCallbackEXT( + m_instance, static_cast( callback ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html + template ::type> + VULKAN_HPP_INLINE void + Instance::destroy( DebugReportCallbackEXT callback, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDebugReportCallbackEXT( + static_cast( m_instance ), static_cast( callback ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html + template ::type> + VULKAN_HPP_INLINE void + Instance::destroy( DebugReportCallbackEXT callback, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDebugReportCallbackEXT && "Function requires " ); +# endif + + d.vkDestroyDebugReportCallbackEXT( + m_instance, static_cast( callback ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html + template ::type> + VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, + DebugReportObjectTypeEXT objectType_, + uint64_t object, + size_t location, + int32_t messageCode, + const char * pLayerPrefix, + const char * pMessage, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDebugReportMessageEXT( static_cast( m_instance ), + static_cast( flags ), + static_cast( objectType_ ), + object, + location, + messageCode, + pLayerPrefix, + pMessage ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html + template ::type> + VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, + DebugReportObjectTypeEXT objectType_, + uint64_t object, + size_t location, + int32_t messageCode, + const std::string & layerPrefix, + const std::string & message, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDebugReportMessageEXT && "Function requires " ); +# endif + + d.vkDebugReportMessageEXT( m_instance, + static_cast( flags ), + static_cast( objectType_ ), + object, + location, + messageCode, + layerPrefix.c_str(), + message.c_str() ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_debug_marker === + + // wrapper function for command vkDebugMarkerSetObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT * pTagInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkDebugMarkerSetObjectTagEXT( static_cast( m_device ), reinterpret_cast( pTagInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDebugMarkerSetObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDebugMarkerSetObjectTagEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDebugMarkerSetObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT * pNameInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkDebugMarkerSetObjectNameEXT( static_cast( m_device ), reinterpret_cast( pNameInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDebugMarkerSetObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDebugMarkerSetObjectNameEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDebugMarkerBeginEXT( static_cast( m_commandBuffer ), reinterpret_cast( pMarkerInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDebugMarkerBeginEXT && "Function requires " ); +# endif + + d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast( &markerInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDebugMarkerEndEXT( static_cast( m_commandBuffer ) ); + } + + // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDebugMarkerInsertEXT( static_cast( m_commandBuffer ), reinterpret_cast( pMarkerInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDebugMarkerInsertEXT && "Function requires " ); +# endif + + d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast( &markerInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_video_queue === + + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR * pVideoProfile, + VideoCapabilitiesKHR * pCapabilities, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( pVideoProfile ), + reinterpret_cast( pCapabilities ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoCapabilitiesKHR && "Function requires " ); +# endif + + VideoCapabilitiesKHR capabilities; + Result result = static_cast( d.vkGetPhysicalDeviceVideoCapabilitiesKHR( + m_physicalDevice, reinterpret_cast( &videoProfile ), reinterpret_cast( &capabilities ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); + + return detail::createResultValueType( result, std::move( capabilities ) ); + } + + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoCapabilitiesKHR && "Function requires " ); +# endif + + StructureChain structureChain; + VideoCapabilitiesKHR & capabilities = structureChain.template get(); + Result result = static_cast( d.vkGetPhysicalDeviceVideoCapabilitiesKHR( + m_physicalDevice, reinterpret_cast( &videoProfile ), reinterpret_cast( &capabilities ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); + + return detail::createResultValueType( result, std::move( structureChain ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, + uint32_t * pVideoFormatPropertyCount, + VideoFormatPropertiesKHR * pVideoFormatProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( pVideoFormatInfo ), + pVideoFormatPropertyCount, + reinterpret_cast( pVideoFormatProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR && + "Function requires " ); +# endif + + std::vector videoFormatProperties; + uint32_t videoFormatPropertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( + m_physicalDevice, reinterpret_cast( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) + { + videoFormatProperties.resize( videoFormatPropertyCount ); + result = static_cast( + d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice, + reinterpret_cast( &videoFormatInfo ), + &videoFormatPropertyCount, + reinterpret_cast( videoFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); + VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); + if ( videoFormatPropertyCount < videoFormatProperties.size() ) + { + videoFormatProperties.resize( videoFormatPropertyCount ); + } + return detail::createResultValueType( result, std::move( videoFormatProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, + VideoFormatPropertiesKHRAllocator const & videoFormatPropertiesKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR && + "Function requires " ); +# endif + + std::vector videoFormatProperties( videoFormatPropertiesKHRAllocator ); + uint32_t videoFormatPropertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( + m_physicalDevice, reinterpret_cast( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) + { + videoFormatProperties.resize( videoFormatPropertyCount ); + result = static_cast( + d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice, + reinterpret_cast( &videoFormatInfo ), + &videoFormatPropertyCount, + reinterpret_cast( videoFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); + VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); + if ( videoFormatPropertyCount < videoFormatProperties.size() ) + { + videoFormatProperties.resize( videoFormatPropertyCount ); + } + return detail::createResultValueType( result, std::move( videoFormatProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR && + "Function requires " ); +# endif + + std::vector structureChains; + std::vector videoFormatProperties; + uint32_t videoFormatPropertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( + m_physicalDevice, reinterpret_cast( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) + { + structureChains.resize( videoFormatPropertyCount ); + videoFormatProperties.resize( videoFormatPropertyCount ); + for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) + { + videoFormatProperties[i].pNext = structureChains[i].template get().pNext; + } + result = static_cast( + d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice, + reinterpret_cast( &videoFormatInfo ), + &videoFormatPropertyCount, + reinterpret_cast( videoFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); + VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); + if ( videoFormatPropertyCount < videoFormatProperties.size() ) + { + structureChains.resize( videoFormatPropertyCount ); + } + for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) + { + structureChains[i].template get() = videoFormatProperties[i]; + } + return detail::createResultValueType( result, std::move( structureChains ) ); + } + + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, + StructureChainAllocator & structureChainAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR && + "Function requires " ); +# endif + + std::vector structureChains( structureChainAllocator ); + std::vector videoFormatProperties; + uint32_t videoFormatPropertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( + m_physicalDevice, reinterpret_cast( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) + { + structureChains.resize( videoFormatPropertyCount ); + videoFormatProperties.resize( videoFormatPropertyCount ); + for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) + { + videoFormatProperties[i].pNext = structureChains[i].template get().pNext; + } + result = static_cast( + d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice, + reinterpret_cast( &videoFormatInfo ), + &videoFormatPropertyCount, + reinterpret_cast( videoFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); + VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); + if ( videoFormatPropertyCount < videoFormatProperties.size() ) + { + structureChains.resize( videoFormatPropertyCount ); + } + for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) + { + structureChains[i].template get() = videoFormatProperties[i]; + } + return detail::createResultValueType( result, std::move( structureChains ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createVideoSessionKHR( const VideoSessionCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + VideoSessionKHR * pVideoSession, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateVideoSessionKHR( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pVideoSession ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createVideoSessionKHR( const VideoSessionCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateVideoSessionKHR && "Function requires " ); +# endif + + VideoSessionKHR videoSession; + Result result = static_cast( d.vkCreateVideoSessionKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &videoSession ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR" ); + + return detail::createResultValueType( result, std::move( videoSession ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateVideoSessionKHR && "Function requires " ); +# endif + + VideoSessionKHR videoSession; + Result result = static_cast( d.vkCreateVideoSessionKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &videoSession ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHRUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( videoSession, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyVideoSessionKHR( VideoSessionKHR videoSession, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyVideoSessionKHR( + static_cast( m_device ), static_cast( videoSession ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyVideoSessionKHR( VideoSessionKHR videoSession, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionKHR && "Function requires " ); +# endif + + d.vkDestroyVideoSessionKHR( m_device, static_cast( videoSession ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( VideoSessionKHR videoSession, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyVideoSessionKHR( + static_cast( m_device ), static_cast( videoSession ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( VideoSessionKHR videoSession, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionKHR && "Function requires " ); +# endif + + d.vkDestroyVideoSessionKHR( m_device, static_cast( videoSession ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, + uint32_t * pMemoryRequirementsCount, + VideoSessionMemoryRequirementsKHR * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetVideoSessionMemoryRequirementsKHR( static_cast( m_device ), + static_cast( videoSession ), + pMemoryRequirementsCount, + reinterpret_cast( pMemoryRequirements ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html + template < + typename VideoSessionMemoryRequirementsKHRAllocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + Device::getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetVideoSessionMemoryRequirementsKHR && "Function requires " ); +# endif + + std::vector memoryRequirements; + uint32_t memoryRequirementsCount; + Result result; + do + { + result = static_cast( + d.vkGetVideoSessionMemoryRequirementsKHR( m_device, static_cast( videoSession ), &memoryRequirementsCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && memoryRequirementsCount ) + { + memoryRequirements.resize( memoryRequirementsCount ); + result = static_cast( + d.vkGetVideoSessionMemoryRequirementsKHR( m_device, + static_cast( videoSession ), + &memoryRequirementsCount, + reinterpret_cast( memoryRequirements.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" ); + VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() ); + if ( memoryRequirementsCount < memoryRequirements.size() ) + { + memoryRequirements.resize( memoryRequirementsCount ); + } + return detail::createResultValueType( result, std::move( memoryRequirements ) ); + } + + // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html + template < + typename VideoSessionMemoryRequirementsKHRAllocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + Device::getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, + VideoSessionMemoryRequirementsKHRAllocator const & videoSessionMemoryRequirementsKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetVideoSessionMemoryRequirementsKHR && "Function requires " ); +# endif + + std::vector memoryRequirements( videoSessionMemoryRequirementsKHRAllocator ); + uint32_t memoryRequirementsCount; + Result result; + do + { + result = static_cast( + d.vkGetVideoSessionMemoryRequirementsKHR( m_device, static_cast( videoSession ), &memoryRequirementsCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && memoryRequirementsCount ) + { + memoryRequirements.resize( memoryRequirementsCount ); + result = static_cast( + d.vkGetVideoSessionMemoryRequirementsKHR( m_device, + static_cast( videoSession ), + &memoryRequirementsCount, + reinterpret_cast( memoryRequirements.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" ); + VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() ); + if ( memoryRequirementsCount < memoryRequirements.size() ) + { + memoryRequirements.resize( memoryRequirementsCount ); + } + return detail::createResultValueType( result, std::move( memoryRequirements ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindVideoSessionMemoryKHR( VideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkBindVideoSessionMemoryKHR( static_cast( m_device ), + static_cast( videoSession ), + bindSessionMemoryInfoCount, + reinterpret_cast( pBindSessionMemoryInfos ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::bindVideoSessionMemoryKHR( + VideoSessionKHR videoSession, ArrayProxy const & bindSessionMemoryInfos, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBindVideoSessionMemoryKHR && "Function requires " ); +# endif + + Result result = + static_cast( d.vkBindVideoSessionMemoryKHR( m_device, + static_cast( videoSession ), + bindSessionMemoryInfos.size(), + reinterpret_cast( bindSessionMemoryInfos.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindVideoSessionMemoryKHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + VideoSessionParametersKHR * pVideoSessionParameters, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateVideoSessionParametersKHR( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pVideoSessionParameters ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createVideoSessionParametersKHR( + const VideoSessionParametersCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateVideoSessionParametersKHR && "Function requires " ); +# endif + + VideoSessionParametersKHR videoSessionParameters; + Result result = static_cast( d.vkCreateVideoSessionParametersKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &videoSessionParameters ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" ); + + return detail::createResultValueType( result, std::move( videoSessionParameters ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateVideoSessionParametersKHR && "Function requires " ); +# endif + + VideoSessionParametersKHR videoSessionParameters; + Result result = static_cast( d.vkCreateVideoSessionParametersKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &videoSessionParameters ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHRUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( videoSessionParameters, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::updateVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, + const VideoSessionParametersUpdateInfoKHR * pUpdateInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkUpdateVideoSessionParametersKHR( static_cast( m_device ), + static_cast( videoSessionParameters ), + reinterpret_cast( pUpdateInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::updateVideoSessionParametersKHR( + VideoSessionParametersKHR videoSessionParameters, const VideoSessionParametersUpdateInfoKHR & updateInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkUpdateVideoSessionParametersKHR && "Function requires " ); +# endif + + Result result = + static_cast( d.vkUpdateVideoSessionParametersKHR( m_device, + static_cast( videoSessionParameters ), + reinterpret_cast( &updateInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::updateVideoSessionParametersKHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyVideoSessionParametersKHR( static_cast( m_device ), + static_cast( videoSessionParameters ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionParametersKHR && "Function requires " ); +# endif + + d.vkDestroyVideoSessionParametersKHR( + m_device, static_cast( videoSessionParameters ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( VideoSessionParametersKHR videoSessionParameters, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyVideoSessionParametersKHR( static_cast( m_device ), + static_cast( videoSessionParameters ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( VideoSessionParametersKHR videoSessionParameters, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionParametersKHR && "Function requires " ); +# endif + + d.vkDestroyVideoSessionParametersKHR( + m_device, static_cast( videoSessionParameters ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR * pBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginVideoCodingKHR( static_cast( m_commandBuffer ), reinterpret_cast( pBeginInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginVideoCodingKHR && "Function requires " ); +# endif + + d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast( &beginInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR * pEndCodingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndVideoCodingKHR( static_cast( m_commandBuffer ), reinterpret_cast( pEndCodingInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdEndVideoCodingKHR && "Function requires " ); +# endif + + d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast( &endCodingInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VideoCodingControlInfoKHR * pCodingControlInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdControlVideoCodingKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pCodingControlInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdControlVideoCodingKHR && "Function requires " ); +# endif + + d.vkCmdControlVideoCodingKHR( m_commandBuffer, reinterpret_cast( &codingControlInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_video_decode_queue === + + // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR * pDecodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDecodeVideoKHR( static_cast( m_commandBuffer ), reinterpret_cast( pDecodeInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR & decodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDecodeVideoKHR && "Function requires " ); +# endif + + d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast( &decodeInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_transform_feedback === + + // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, + uint32_t bindingCount, + const Buffer * pBuffers, + const DeviceSize * pOffsets, + const DeviceSize * pSizes, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindTransformFeedbackBuffersEXT( static_cast( m_commandBuffer ), + firstBinding, + bindingCount, + reinterpret_cast( pBuffers ), + reinterpret_cast( pOffsets ), + reinterpret_cast( pSizes ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindTransformFeedbackBuffersEXT && "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); + VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); +# else + if ( buffers.size() != offsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); + } + if ( !sizes.empty() && buffers.size() != sizes.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, + firstBinding, + buffers.size(), + reinterpret_cast( buffers.data() ), + reinterpret_cast( offsets.data() ), + reinterpret_cast( sizes.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginTransformFeedbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const Buffer * pCounterBuffers, + const DeviceSize * pCounterBufferOffsets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginTransformFeedbackEXT( static_cast( m_commandBuffer ), + firstCounterBuffer, + counterBufferCount, + reinterpret_cast( pCounterBuffers ), + reinterpret_cast( pCounterBufferOffsets ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginTransformFeedbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, + ArrayProxy const & counterBuffers, + ArrayProxy const & counterBufferOffsets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginTransformFeedbackEXT && "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); +# else + if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, + firstCounterBuffer, + counterBuffers.size(), + reinterpret_cast( counterBuffers.data() ), + reinterpret_cast( counterBufferOffsets.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndTransformFeedbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const Buffer * pCounterBuffers, + const DeviceSize * pCounterBufferOffsets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndTransformFeedbackEXT( static_cast( m_commandBuffer ), + firstCounterBuffer, + counterBufferCount, + reinterpret_cast( pCounterBuffers ), + reinterpret_cast( pCounterBufferOffsets ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndTransformFeedbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, + ArrayProxy const & counterBuffers, + ArrayProxy const & counterBufferOffsets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdEndTransformFeedbackEXT && "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); +# else + if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, + firstCounterBuffer, + counterBuffers.size(), + reinterpret_cast( counterBuffers.data() ), + reinterpret_cast( counterBufferOffsets.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( + QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginQueryIndexedEXT( + static_cast( m_commandBuffer ), static_cast( queryPool ), query, static_cast( flags ), index ); + } + + // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndQueryIndexedEXT( static_cast( m_commandBuffer ), static_cast( queryPool ), query, index ); + } + + // wrapper function for command vkCmdDrawIndirectByteCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, + uint32_t firstInstance, + Buffer counterBuffer, + DeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndirectByteCountEXT( static_cast( m_commandBuffer ), + instanceCount, + firstInstance, + static_cast( counterBuffer ), + static_cast( counterBufferOffset ), + counterOffset, + vertexStride ); + } + + //=== VK_NVX_binary_import === + + // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCuModuleNVX( const CuModuleCreateInfoNVX * pCreateInfo, + const AllocationCallbacks * pAllocator, + CuModuleNVX * pModule, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateCuModuleNVX( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pModule ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createCuModuleNVX( const CuModuleCreateInfoNVX & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateCuModuleNVX && "Function requires " ); +# endif + + CuModuleNVX module; + Result result = static_cast( d.vkCreateCuModuleNVX( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &module ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX" ); + + return detail::createResultValueType( result, std::move( module ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createCuModuleNVXUnique( const CuModuleCreateInfoNVX & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateCuModuleNVX && "Function requires " ); +# endif + + CuModuleNVX module; + Result result = static_cast( d.vkCreateCuModuleNVX( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &module ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVXUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( module, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCuFunctionNVX( const CuFunctionCreateInfoNVX * pCreateInfo, + const AllocationCallbacks * pAllocator, + CuFunctionNVX * pFunction, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateCuFunctionNVX( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pFunction ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createCuFunctionNVX( const CuFunctionCreateInfoNVX & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateCuFunctionNVX && "Function requires " ); +# endif + + CuFunctionNVX function; + Result result = static_cast( d.vkCreateCuFunctionNVX( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &function ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX" ); + + return detail::createResultValueType( result, std::move( function ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateCuFunctionNVX && "Function requires " ); +# endif + + CuFunctionNVX function; + Result result = static_cast( d.vkCreateCuFunctionNVX( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &function ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVXUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( function, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyCuModuleNVX( CuModuleNVX module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyCuModuleNVX( + static_cast( m_device ), static_cast( module ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyCuModuleNVX( CuModuleNVX module, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyCuModuleNVX && "Function requires " ); +# endif + + d.vkDestroyCuModuleNVX( m_device, static_cast( module ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( CuModuleNVX module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyCuModuleNVX( + static_cast( m_device ), static_cast( module ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( CuModuleNVX module, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyCuModuleNVX && "Function requires " ); +# endif + + d.vkDestroyCuModuleNVX( m_device, static_cast( module ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyCuFunctionNVX( CuFunctionNVX function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyCuFunctionNVX( + static_cast( m_device ), static_cast( function ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyCuFunctionNVX( CuFunctionNVX function, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyCuFunctionNVX && "Function requires " ); +# endif + + d.vkDestroyCuFunctionNVX( m_device, static_cast( function ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( CuFunctionNVX function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyCuFunctionNVX( + static_cast( m_device ), static_cast( function ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( CuFunctionNVX function, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyCuFunctionNVX && "Function requires " ); +# endif + + d.vkDestroyCuFunctionNVX( m_device, static_cast( function ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX * pLaunchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCuLaunchKernelNVX( static_cast( m_commandBuffer ), reinterpret_cast( pLaunchInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCuLaunchKernelNVX && "Function requires " ); +# endif + + d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast( &launchInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NVX_image_view_handle === + + // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html + template ::type> + VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return d.vkGetImageViewHandleNVX( static_cast( m_device ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html + template ::type> + VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageViewHandleNVX && "Function requires " ); +# endif + + uint32_t result = d.vkGetImageViewHandleNVX( m_device, reinterpret_cast( &info ) ); + + return result; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html + template ::type> + VULKAN_HPP_INLINE uint64_t Device::getImageViewHandle64NVX( const ImageViewHandleInfoNVX * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return d.vkGetImageViewHandle64NVX( static_cast( m_device ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html + template ::type> + VULKAN_HPP_INLINE uint64_t Device::getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageViewHandle64NVX && "Function requires " ); +# endif + + uint64_t result = d.vkGetImageViewHandle64NVX( m_device, reinterpret_cast( &info ) ); + + return result; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageViewAddressNVX( ImageView imageView, + ImageViewAddressPropertiesNVX * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetImageViewAddressNVX( + static_cast( m_device ), static_cast( imageView ), reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getImageViewAddressNVX( ImageView imageView, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageViewAddressNVX && "Function requires " ); +# endif + + ImageViewAddressPropertiesNVX properties; + Result result = static_cast( + d.vkGetImageViewAddressNVX( m_device, static_cast( imageView ), reinterpret_cast( &properties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewAddressNVX" ); + + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html + template ::type> + VULKAN_HPP_INLINE uint64_t Device::getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex, + uint64_t samplerIndex, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return d.vkGetDeviceCombinedImageSamplerIndexNVX( static_cast( m_device ), imageViewIndex, samplerIndex ); + } + + //=== VK_AMD_draw_indirect_count === + + // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndirectCountAMD( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndexedIndirectCountAMD( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + //=== VK_AMD_shader_info === + + // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline, + ShaderStageFlagBits shaderStage, + ShaderInfoTypeAMD infoType, + size_t * pInfoSize, + void * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetShaderInfoAMD( static_cast( m_device ), + static_cast( pipeline ), + static_cast( shaderStage ), + static_cast( infoType ), + pInfoSize, + pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetShaderInfoAMD && "Function requires " ); +# endif + + std::vector info; + size_t infoSize; + Result result; + do + { + result = static_cast( d.vkGetShaderInfoAMD( m_device, + static_cast( pipeline ), + static_cast( shaderStage ), + static_cast( infoType ), + &infoSize, + nullptr ) ); + if ( ( result == Result::eSuccess ) && infoSize ) + { + info.resize( infoSize ); + result = static_cast( d.vkGetShaderInfoAMD( m_device, + static_cast( pipeline ), + static_cast( shaderStage ), + static_cast( infoType ), + &infoSize, + reinterpret_cast( info.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" ); + VULKAN_HPP_ASSERT( infoSize <= info.size() ); + if ( infoSize < info.size() ) + { + info.resize( infoSize ); + } + return detail::createResultValueType( result, std::move( info ) ); + } + + // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::getShaderInfoAMD( + Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetShaderInfoAMD && "Function requires " ); +# endif + + std::vector info( uint8_tAllocator ); + size_t infoSize; + Result result; + do + { + result = static_cast( d.vkGetShaderInfoAMD( m_device, + static_cast( pipeline ), + static_cast( shaderStage ), + static_cast( infoType ), + &infoSize, + nullptr ) ); + if ( ( result == Result::eSuccess ) && infoSize ) + { + info.resize( infoSize ); + result = static_cast( d.vkGetShaderInfoAMD( m_device, + static_cast( pipeline ), + static_cast( shaderStage ), + static_cast( infoType ), + &infoSize, + reinterpret_cast( info.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" ); + VULKAN_HPP_ASSERT( infoSize <= info.size() ); + if ( infoSize < info.size() ) + { + info.resize( infoSize ); + } + return detail::createResultValueType( result, std::move( info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_dynamic_rendering === + + // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const RenderingInfo * pRenderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginRenderingKHR( static_cast( m_commandBuffer ), reinterpret_cast( pRenderingInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const RenderingInfo & renderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginRenderingKHR && "Function requires or " ); +# endif + + d.vkCmdBeginRenderingKHR( m_commandBuffer, reinterpret_cast( &renderingInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndRenderingKHR( static_cast( m_commandBuffer ) ); + } + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateStreamDescriptorSurfaceGGP( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createStreamDescriptorSurfaceGGP( + const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateStreamDescriptorSurfaceGGP && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createStreamDescriptorSurfaceGGPUnique( + const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateStreamDescriptorSurfaceGGP && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGPUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, + ImageType type, + ImageTiling tiling, + ImageUsageFlags usage, + ImageCreateFlags flags, + ExternalMemoryHandleTypeFlagsNV externalHandleType, + ExternalImageFormatPropertiesNV * pExternalImageFormatProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( static_cast( m_physicalDevice ), + static_cast( format ), + static_cast( type ), + static_cast( tiling ), + static_cast( usage ), + static_cast( flags ), + static_cast( externalHandleType ), + reinterpret_cast( pExternalImageFormatProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, + ImageType type, + ImageTiling tiling, + ImageUsageFlags usage, + ImageCreateFlags flags, + ExternalMemoryHandleTypeFlagsNV externalHandleType, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV && + "Function requires " ); +# endif + + ExternalImageFormatPropertiesNV externalImageFormatProperties; + Result result = static_cast( + d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, + static_cast( format ), + static_cast( type ), + static_cast( tiling ), + static_cast( usage ), + static_cast( flags ), + static_cast( externalHandleType ), + reinterpret_cast( &externalImageFormatProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); + + return detail::createResultValueType( result, std::move( externalImageFormatProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + + // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory, + ExternalMemoryHandleTypeFlagsNV handleType, + HANDLE * pHandle, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetMemoryWin32HandleNV( + static_cast( m_device ), static_cast( memory ), static_cast( handleType ), pHandle ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandleNV && "Function requires " ); +# endif + + HANDLE handle; + Result result = static_cast( + d.vkGetMemoryWin32HandleNV( m_device, static_cast( memory ), static_cast( handleType ), &handle ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleNV" ); + + return detail::createResultValueType( result, std::move( handle ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_get_physical_device_properties2 === + + // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceFeatures2KHR( static_cast( m_physicalDevice ), reinterpret_cast( pFeatures ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2KHR && + "Function requires or " ); +# endif + + PhysicalDeviceFeatures2 features; + d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( &features ) ); + + return features; + } + + // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2KHR && + "Function requires or " ); +# endif + + StructureChain structureChain; + PhysicalDeviceFeatures2 & features = structureChain.template get(); + d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( &features ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2 * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceProperties2KHR( static_cast( m_physicalDevice ), reinterpret_cast( pProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2KHR && + "Function requires or " ); +# endif + + PhysicalDeviceProperties2 properties; + d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( &properties ) ); + + return properties; + } + + // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2KHR && + "Function requires or " ); +# endif + + StructureChain structureChain; + PhysicalDeviceProperties2 & properties = structureChain.template get(); + d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( &properties ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html + template ::type> + VULKAN_HPP_INLINE void + PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2 * pFormatProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceFormatProperties2KHR( + static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( pFormatProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2KHR( Format format, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2KHR && + "Function requires or " ); +# endif + + FormatProperties2 formatProperties; + d.vkGetPhysicalDeviceFormatProperties2KHR( + m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + + return formatProperties; + } + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFormatProperties2KHR( Format format, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2KHR && + "Function requires or " ); +# endif + + StructureChain structureChain; + FormatProperties2 & formatProperties = structureChain.template get(); + d.vkGetPhysicalDeviceFormatProperties2KHR( + m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, + ImageFormatProperties2 * pImageFormatProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( pImageFormatInfo ), + reinterpret_cast( pImageFormatProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2KHR && + "Function requires or " ); +# endif + + ImageFormatProperties2 imageFormatProperties; + Result result = + static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, + reinterpret_cast( &imageFormatInfo ), + reinterpret_cast( &imageFormatProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); + + return detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2KHR && + "Function requires or " ); +# endif + + StructureChain structureChain; + ImageFormatProperties2 & imageFormatProperties = structureChain.template get(); + Result result = + static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, + reinterpret_cast( &imageFormatInfo ), + reinterpret_cast( &imageFormatProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); + + return detail::createResultValueType( result, std::move( structureChain ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount, + QueueFamilyProperties2 * pQueueFamilyProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( + static_cast( m_physicalDevice ), pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && + "Function requires or " ); +# endif + + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( + m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + queueFamilyProperties.resize( queueFamilyPropertyCount ); + } + return queueFamilyProperties; + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator const & queueFamilyProperties2Allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && + "Function requires or " ); +# endif + + std::vector queueFamilyProperties( queueFamilyProperties2Allocator ); + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( + m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + queueFamilyProperties.resize( queueFamilyPropertyCount ); + } + return queueFamilyProperties; + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && + "Function requires or " ); +# endif + + std::vector structureChains; + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + structureChains.resize( queueFamilyPropertyCount ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; + } + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( + m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + structureChains.resize( queueFamilyPropertyCount ); + } + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + structureChains[i].template get() = queueFamilyProperties[i]; + } + return structureChains; + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && + "Function requires or " ); +# endif + + std::vector structureChains( structureChainAllocator ); + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); + structureChains.resize( queueFamilyPropertyCount ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; + } + d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( + m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + structureChains.resize( queueFamilyPropertyCount ); + } + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + structureChains[i].template get() = queueFamilyProperties[i]; + } + return structureChains; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2 * pMemoryProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceMemoryProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( pMemoryProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2KHR && + "Function requires or " ); +# endif + + PhysicalDeviceMemoryProperties2 memoryProperties; + d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + + return memoryProperties; + } + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2KHR && + "Function requires or " ); +# endif + + StructureChain structureChain; + PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get(); + d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, + uint32_t * pPropertyCount, + SparseImageFormatProperties2 * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( pFormatInfo ), + pPropertyCount, + reinterpret_cast( pProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR && + "Function requires or " ); +# endif + + std::vector properties; + uint32_t propertyCount; + d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( + m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); + properties.resize( propertyCount ); + d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, + reinterpret_cast( &formatInfo ), + &propertyCount, + reinterpret_cast( properties.data() ) ); + + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return properties; + } + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, + SparseImageFormatProperties2Allocator const & sparseImageFormatProperties2Allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR && + "Function requires or " ); +# endif + + std::vector properties( sparseImageFormatProperties2Allocator ); + uint32_t propertyCount; + d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( + m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); + properties.resize( propertyCount ); + d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, + reinterpret_cast( &formatInfo ), + &propertyCount, + reinterpret_cast( properties.data() ) ); + + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return properties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_device_group === + + // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + PeerMemoryFeatureFlags * pPeerMemoryFeatures, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceGroupPeerMemoryFeaturesKHR( + static_cast( m_device ), heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( pPeerMemoryFeatures ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPeerMemoryFeaturesKHR && + "Function requires or " ); +# endif + + PeerMemoryFeatureFlags peerMemoryFeatures; + d.vkGetDeviceGroupPeerMemoryFeaturesKHR( + m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( &peerMemoryFeatures ) ); + + return peerMemoryFeatures; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDeviceMaskKHR( static_cast( m_commandBuffer ), deviceMask ); + } + + // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDispatchBaseKHR( static_cast( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); + } + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateViSurfaceNN( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateViSurfaceNN && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateViSurfaceNN( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateViSurfaceNN && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateViSurfaceNN( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNNUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_maintenance1 === + + // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkTrimCommandPoolKHR( static_cast( m_device ), static_cast( commandPool ), static_cast( flags ) ); + } + + //=== VK_KHR_device_group_creation === + + // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount, + PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( static_cast( m_instance ), + pPhysicalDeviceGroupCount, + reinterpret_cast( pPhysicalDeviceGroupProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::enumeratePhysicalDeviceGroupsKHR( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroupsKHR && + "Function requires or " ); +# endif + + std::vector physicalDeviceGroupProperties; + uint32_t physicalDeviceGroupCount; + Result result; + do + { + result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( + m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); + if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + } + return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); + } + + // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator const & physicalDeviceGroupPropertiesAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroupsKHR && + "Function requires or " ); +# endif + + std::vector physicalDeviceGroupProperties( physicalDeviceGroupPropertiesAllocator ); + uint32_t physicalDeviceGroupCount; + Result result; + do + { + result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( + m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); + if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + } + return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_external_memory_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, + ExternalBufferProperties * pExternalBufferProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( pExternalBufferInfo ), + reinterpret_cast( pExternalBufferProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalBufferProperties + PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalBufferPropertiesKHR && + "Function requires or " ); +# endif + + ExternalBufferProperties externalBufferProperties; + d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, + reinterpret_cast( &externalBufferInfo ), + reinterpret_cast( &externalBufferProperties ) ); + + return externalBufferProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + + // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, + HANDLE * pHandle, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetMemoryWin32HandleKHR( + static_cast( m_device ), reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandleKHR && "Function requires " ); +# endif + + HANDLE handle; + Result result = + static_cast( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); + + return detail::createResultValueType( result, std::move( handle ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, + HANDLE handle, + MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetMemoryWin32HandlePropertiesKHR( static_cast( m_device ), + static_cast( handleType ), + handle, + reinterpret_cast( pMemoryWin32HandleProperties ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandlePropertiesKHR && "Function requires " ); +# endif + + MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; + Result result = + static_cast( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, + static_cast( handleType ), + handle, + reinterpret_cast( &memoryWin32HandleProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); + + return detail::createResultValueType( result, std::move( memoryWin32HandleProperties ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + + // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR * pGetFdInfo, + int * pFd, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetMemoryFdKHR( static_cast( m_device ), reinterpret_cast( pGetFdInfo ), pFd ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryFdKHR && "Function requires " ); +# endif + + int fd; + Result result = static_cast( d.vkGetMemoryFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); + + return detail::createResultValueType( result, std::move( fd ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, + int fd, + MemoryFdPropertiesKHR * pMemoryFdProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetMemoryFdPropertiesKHR( static_cast( m_device ), + static_cast( handleType ), + fd, + reinterpret_cast( pMemoryFdProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryFdPropertiesKHR && "Function requires " ); +# endif + + MemoryFdPropertiesKHR memoryFdProperties; + Result result = static_cast( d.vkGetMemoryFdPropertiesKHR( + m_device, static_cast( handleType ), fd, reinterpret_cast( &memoryFdProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); + + return detail::createResultValueType( result, std::move( memoryFdProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_external_semaphore_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, + ExternalSemaphoreProperties * pExternalSemaphoreProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( pExternalSemaphoreInfo ), + reinterpret_cast( pExternalSemaphoreProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( + const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR && + "Function requires or " ); +# endif + + ExternalSemaphoreProperties externalSemaphoreProperties; + d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, + reinterpret_cast( &externalSemaphoreInfo ), + reinterpret_cast( &externalSemaphoreProperties ) ); + + return externalSemaphoreProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + + // wrapper function for command vkImportSemaphoreWin32HandleKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( + const ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkImportSemaphoreWin32HandleKHR( + static_cast( m_device ), reinterpret_cast( pImportSemaphoreWin32HandleInfo ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkImportSemaphoreWin32HandleKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkImportSemaphoreWin32HandleKHR && "Function requires " ); +# endif + + Result result = static_cast( + d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &importSemaphoreWin32HandleInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" ); + + return detail::createResultValueType( result ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSemaphoreWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, + HANDLE * pHandle, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetSemaphoreWin32HandleKHR( + static_cast( m_device ), reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSemaphoreWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSemaphoreWin32HandleKHR && "Function requires " ); +# endif + + HANDLE handle; + Result result = static_cast( + d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); + + return detail::createResultValueType( result, std::move( handle ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + + // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkImportSemaphoreFdKHR( static_cast( m_device ), reinterpret_cast( pImportSemaphoreFdInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkImportSemaphoreFdKHR && "Function requires " ); +# endif + + Result result = static_cast( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast( &importSemaphoreFdInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR * pGetFdInfo, + int * pFd, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetSemaphoreFdKHR( static_cast( m_device ), reinterpret_cast( pGetFdInfo ), pFd ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSemaphoreFdKHR && "Function requires " ); +# endif + + int fd; + Result result = static_cast( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); + + return detail::createResultValueType( result, std::move( fd ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_push_descriptor === + + // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const WriteDescriptorSet * pDescriptorWrites, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushDescriptorSetKHR( static_cast( m_commandBuffer ), + static_cast( pipelineBindPoint ), + static_cast( layout ), + set, + descriptorWriteCount, + reinterpret_cast( pDescriptorWrites ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t set, + ArrayProxy const & descriptorWrites, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetKHR && "Function requires or " ); +# endif + + d.vkCmdPushDescriptorSetKHR( m_commandBuffer, + static_cast( pipelineBindPoint ), + static_cast( layout ), + set, + descriptorWrites.size(), + reinterpret_cast( descriptorWrites.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( + DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushDescriptorSetWithTemplateKHR( static_cast( m_commandBuffer ), + static_cast( descriptorUpdateTemplate ), + static_cast( layout ), + set, + pData ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, + PipelineLayout layout, + uint32_t set, + DataType const & data, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( + d.vkCmdPushDescriptorSetWithTemplateKHR && + "Function requires or or " ); +# endif + + d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, + static_cast( descriptorUpdateTemplate ), + static_cast( layout ), + set, + reinterpret_cast( &data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_conditional_rendering === + + // wrapper function for command vkCmdBeginConditionalRenderingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginConditionalRenderingEXT( static_cast( m_commandBuffer ), + reinterpret_cast( pConditionalRenderingBegin ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginConditionalRenderingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginConditionalRenderingEXT && "Function requires " ); +# endif + + d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast( &conditionalRenderingBegin ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndConditionalRenderingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndConditionalRenderingEXT( static_cast( m_commandBuffer ) ); + } + + //=== VK_KHR_descriptor_update_template === + + // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + DescriptorUpdateTemplate * pDescriptorUpdateTemplate, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDescriptorUpdateTemplateKHR( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pDescriptorUpdateTemplate ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createDescriptorUpdateTemplateKHR( + const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplateKHR && + "Function requires or " ); +# endif + + DescriptorUpdateTemplate descriptorUpdateTemplate; + Result result = static_cast( d.vkCreateDescriptorUpdateTemplateKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &descriptorUpdateTemplate ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR" ); + + return detail::createResultValueType( result, std::move( descriptorUpdateTemplate ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplateKHR && + "Function requires or " ); +# endif + + DescriptorUpdateTemplate descriptorUpdateTemplate; + Result result = static_cast( d.vkCreateDescriptorUpdateTemplateKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &descriptorUpdateTemplate ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHRUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( descriptorUpdateTemplate, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDescriptorUpdateTemplateKHR( static_cast( m_device ), + static_cast( descriptorUpdateTemplate ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplateKHR && + "Function requires or " ); +# endif + + d.vkDestroyDescriptorUpdateTemplateKHR( + m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, + DescriptorUpdateTemplate descriptorUpdateTemplate, + const void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkUpdateDescriptorSetWithTemplateKHR( static_cast( m_device ), + static_cast( descriptorSet ), + static_cast( descriptorUpdateTemplate ), + pData ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, + DescriptorUpdateTemplate descriptorUpdateTemplate, + DataType const & data, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSetWithTemplateKHR && + "Function requires or " ); +# endif + + d.vkUpdateDescriptorSetWithTemplateKHR( m_device, + static_cast( descriptorSet ), + static_cast( descriptorUpdateTemplate ), + reinterpret_cast( &data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_clip_space_w_scaling === + + // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, + uint32_t viewportCount, + const ViewportWScalingNV * pViewportWScalings, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetViewportWScalingNV( + static_cast( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast( pViewportWScalings ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, + ArrayProxy const & viewportWScalings, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetViewportWScalingNV && "Function requires " ); +# endif + + d.vkCmdSetViewportWScalingNV( + m_commandBuffer, firstViewport, viewportWScalings.size(), reinterpret_cast( viewportWScalings.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_direct_mode_display === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkReleaseDisplayEXT( static_cast( m_physicalDevice ), static_cast( display ) ) ); + } +#else + // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkReleaseDisplayEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast( display ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::releaseDisplayEXT" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + + // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display * dpy, + DisplayKHR display, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkAcquireXlibDisplayEXT( static_cast( m_physicalDevice ), dpy, static_cast( display ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, DisplayKHR display, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAcquireXlibDisplayEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast( display ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" ); + + return detail::createResultValueType( result ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::getRandROutputDisplayEXT( Display * dpy, RROutput rrOutput, DisplayKHR * pDisplay, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetRandROutputDisplayEXT( static_cast( m_physicalDevice ), dpy, rrOutput, reinterpret_cast( pDisplay ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRandROutputDisplayEXT && "Function requires " ); +# endif + + DisplayKHR display; + Result result = static_cast( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast( &display ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" ); + + return detail::createResultValueType( result, std::move( display ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRandROutputDisplayEXT && "Function requires " ); +# endif + + DisplayKHR display; + Result result = static_cast( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast( &display ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXTUnique" ); + + return detail::createResultValueType( result, UniqueHandle( display, detail::ObjectRelease( *this, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, + SurfaceCapabilities2EXT * pSurfaceCapabilities, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( static_cast( m_physicalDevice ), + static_cast( surface ), + reinterpret_cast( pSurfaceCapabilities ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT && + "Function requires " ); +# endif + + SurfaceCapabilities2EXT surfaceCapabilities; + Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( + m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); + + return detail::createResultValueType( result, std::move( surfaceCapabilities ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_display_control === + + // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, + const DisplayPowerInfoEXT * pDisplayPowerInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkDisplayPowerControlEXT( + static_cast( m_device ), static_cast( display ), reinterpret_cast( pDisplayPowerInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDisplayPowerControlEXT && "Function requires " ); +# endif + + Result result = static_cast( + d.vkDisplayPowerControlEXT( m_device, static_cast( display ), reinterpret_cast( &displayPowerInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT * pDeviceEventInfo, + const AllocationCallbacks * pAllocator, + Fence * pFence, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkRegisterDeviceEventEXT( static_cast( m_device ), + reinterpret_cast( pDeviceEventInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pFence ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkRegisterDeviceEventEXT && "Function requires " ); +# endif + + Fence fence; + Result result = static_cast( d.vkRegisterDeviceEventEXT( m_device, + reinterpret_cast( &deviceEventInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &fence ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT" ); + + return detail::createResultValueType( result, std::move( fence ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkRegisterDeviceEventEXT && "Function requires " ); +# endif + + Fence fence; + Result result = static_cast( d.vkRegisterDeviceEventEXT( m_device, + reinterpret_cast( &deviceEventInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &fence ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXTUnique" ); + + return detail::createResultValueType( result, UniqueHandle( fence, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, + const DisplayEventInfoEXT * pDisplayEventInfo, + const AllocationCallbacks * pAllocator, + Fence * pFence, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkRegisterDisplayEventEXT( static_cast( m_device ), + static_cast( display ), + reinterpret_cast( pDisplayEventInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pFence ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::registerDisplayEventEXT( DisplayKHR display, + const DisplayEventInfoEXT & displayEventInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkRegisterDisplayEventEXT && "Function requires " ); +# endif + + Fence fence; + Result result = static_cast( d.vkRegisterDisplayEventEXT( m_device, + static_cast( display ), + reinterpret_cast( &displayEventInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &fence ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" ); + + return detail::createResultValueType( result, std::move( fence ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::registerDisplayEventEXTUnique( + DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkRegisterDisplayEventEXT && "Function requires " ); +# endif + + Fence fence; + Result result = static_cast( d.vkRegisterDisplayEventEXT( m_device, + static_cast( display ), + reinterpret_cast( &displayEventInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &fence ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXTUnique" ); + + return detail::createResultValueType( result, UniqueHandle( fence, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, + SurfaceCounterFlagBitsEXT counter, + uint64_t * pCounterValue, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetSwapchainCounterEXT( + static_cast( m_device ), static_cast( swapchain ), static_cast( counter ), pCounterValue ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + ResultValue +# else + typename ResultValueType::type +# endif + Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSwapchainCounterEXT && "Function requires " ); +# endif + + uint64_t counterValue; + Result result = static_cast( + d.vkGetSwapchainCounterEXT( m_device, static_cast( swapchain ), static_cast( counter ), &counterValue ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT", { Result::eSuccess, Result::eErrorOutOfDateKHR } ); +# else + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT" ); +# endif + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + return ResultValue( result, std::move( counterValue ) ); +# else + return detail::createResultValueType( result, std::move( counterValue ) ); +# endif + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_GOOGLE_display_timing === + + // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, + RefreshCycleDurationGOOGLE * pDisplayTimingProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetRefreshCycleDurationGOOGLE( static_cast( m_device ), + static_cast( swapchain ), + reinterpret_cast( pDisplayTimingProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRefreshCycleDurationGOOGLE && "Function requires " ); +# endif + + RefreshCycleDurationGOOGLE displayTimingProperties; + Result result = static_cast( d.vkGetRefreshCycleDurationGOOGLE( + m_device, static_cast( swapchain ), reinterpret_cast( &displayTimingProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRefreshCycleDurationGOOGLE" ); + + return detail::createResultValueType( result, std::move( displayTimingProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPastPresentationTimingGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, + uint32_t * pPresentationTimingCount, + PastPresentationTimingGOOGLE * pPresentationTimings, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPastPresentationTimingGOOGLE( static_cast( m_device ), + static_cast( swapchain ), + pPresentationTimingCount, + reinterpret_cast( pPresentationTimings ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPastPresentationTimingGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + ResultValue> +# else + typename ResultValueType>::type +# endif + Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPastPresentationTimingGOOGLE && "Function requires " ); +# endif + + std::vector presentationTimings; + uint32_t presentationTimingCount; + Result result; + do + { + result = + static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast( swapchain ), &presentationTimingCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentationTimingCount ) + { + presentationTimings.resize( presentationTimingCount ); + result = static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, + static_cast( swapchain ), + &presentationTimingCount, + reinterpret_cast( presentationTimings.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE", { Result::eSuccess, Result::eIncomplete, Result::eErrorOutOfDateKHR } ); +# else + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" ); +# endif + + VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); + if ( presentationTimingCount < presentationTimings.size() ) + { + presentationTimings.resize( presentationTimingCount ); + } + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + return ResultValue>( result, std::move( presentationTimings ) ); +# else + return detail::createResultValueType( result, std::move( presentationTimings ) ); +# endif + } + + // wrapper function for command vkGetPastPresentationTimingGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + ResultValue> +# else + typename ResultValueType>::type +# endif + Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, + PastPresentationTimingGOOGLEAllocator const & pastPresentationTimingGOOGLEAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPastPresentationTimingGOOGLE && "Function requires " ); +# endif + + std::vector presentationTimings( pastPresentationTimingGOOGLEAllocator ); + uint32_t presentationTimingCount; + Result result; + do + { + result = + static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast( swapchain ), &presentationTimingCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentationTimingCount ) + { + presentationTimings.resize( presentationTimingCount ); + result = static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, + static_cast( swapchain ), + &presentationTimingCount, + reinterpret_cast( presentationTimings.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE", { Result::eSuccess, Result::eIncomplete, Result::eErrorOutOfDateKHR } ); +# else + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" ); +# endif + + VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); + if ( presentationTimingCount < presentationTimings.size() ) + { + presentationTimings.resize( presentationTimingCount ); + } + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + return ResultValue>( result, std::move( presentationTimings ) ); +# else + return detail::createResultValueType( result, std::move( presentationTimings ) ); +# endif + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_discard_rectangles === + + // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const Rect2D * pDiscardRectangles, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDiscardRectangleEXT( + static_cast( m_commandBuffer ), firstDiscardRectangle, discardRectangleCount, reinterpret_cast( pDiscardRectangles ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, + ArrayProxy const & discardRectangles, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetDiscardRectangleEXT && "Function requires " ); +# endif + + d.vkCmdSetDiscardRectangleEXT( + m_commandBuffer, firstDiscardRectangle, discardRectangles.size(), reinterpret_cast( discardRectangles.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEnableEXT( Bool32 discardRectangleEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDiscardRectangleEnableEXT( static_cast( m_commandBuffer ), static_cast( discardRectangleEnable ) ); + } + + // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleModeEXT( DiscardRectangleModeEXT discardRectangleMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDiscardRectangleModeEXT( static_cast( m_commandBuffer ), static_cast( discardRectangleMode ) ); + } + + //=== VK_EXT_hdr_metadata === + + // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, + const SwapchainKHR * pSwapchains, + const HdrMetadataEXT * pMetadata, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkSetHdrMetadataEXT( static_cast( m_device ), + swapchainCount, + reinterpret_cast( pSwapchains ), + reinterpret_cast( pMetadata ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy const & swapchains, + ArrayProxy const & metadata, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetHdrMetadataEXT && "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); +# else + if ( swapchains.size() != metadata.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkSetHdrMetadataEXT( m_device, + swapchains.size(), + reinterpret_cast( swapchains.data() ), + reinterpret_cast( metadata.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_create_renderpass2 === + + // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const RenderPassCreateInfo2 * pCreateInfo, + const AllocationCallbacks * pAllocator, + RenderPass * pRenderPass, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateRenderPass2KHR( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pRenderPass ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRenderPass2KHR && "Function requires or " ); +# endif + + RenderPass renderPass; + Result result = static_cast( d.vkCreateRenderPass2KHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &renderPass ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR" ); + + return detail::createResultValueType( result, std::move( renderPass ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRenderPass2KHR && "Function requires or " ); +# endif + + RenderPass renderPass; + Result result = static_cast( d.vkCreateRenderPass2KHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &renderPass ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHRUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( renderPass, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo * pRenderPassBegin, + const SubpassBeginInfo * pSubpassBeginInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginRenderPass2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( pRenderPassBegin ), + reinterpret_cast( pSubpassBeginInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, + const SubpassBeginInfo & subpassBeginInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass2KHR && "Function requires or " ); +# endif + + d.vkCmdBeginRenderPass2KHR( + m_commandBuffer, reinterpret_cast( &renderPassBegin ), reinterpret_cast( &subpassBeginInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo * pSubpassBeginInfo, + const SubpassEndInfo * pSubpassEndInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdNextSubpass2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( pSubpassBeginInfo ), + reinterpret_cast( pSubpassEndInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo, + const SubpassEndInfo & subpassEndInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdNextSubpass2KHR && "Function requires or " ); +# endif + + d.vkCmdNextSubpass2KHR( + m_commandBuffer, reinterpret_cast( &subpassBeginInfo ), reinterpret_cast( &subpassEndInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndRenderPass2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pSubpassEndInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdEndRenderPass2KHR && "Function requires or " ); +# endif + + d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast( &subpassEndInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_shared_presentable_image === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetSwapchainStatusKHR( static_cast( m_device ), static_cast( swapchain ) ) ); + } +#else + // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSwapchainStatusKHR && "Function requires " ); +# endif + + Result result = static_cast( d.vkGetSwapchainStatusKHR( m_device, static_cast( swapchain ) ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); +# endif + + return static_cast( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + //=== VK_KHR_external_fence_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, + ExternalFenceProperties * pExternalFenceProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceExternalFencePropertiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( pExternalFenceInfo ), + reinterpret_cast( pExternalFenceProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalFenceProperties + PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalFencePropertiesKHR && + "Function requires or " ); +# endif + + ExternalFenceProperties externalFenceProperties; + d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, + reinterpret_cast( &externalFenceInfo ), + reinterpret_cast( &externalFenceProperties ) ); + + return externalFenceProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + + // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkImportFenceWin32HandleKHR( static_cast( m_device ), + reinterpret_cast( pImportFenceWin32HandleInfo ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkImportFenceWin32HandleKHR && "Function requires " ); +# endif + + Result result = static_cast( + d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( &importFenceWin32HandleInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" ); + + return detail::createResultValueType( result ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, + HANDLE * pHandle, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetFenceWin32HandleKHR( static_cast( m_device ), reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetFenceWin32HandleKHR && "Function requires " ); +# endif + + HANDLE handle; + Result result = + static_cast( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); + + return detail::createResultValueType( result, std::move( handle ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + + // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR * pImportFenceFdInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkImportFenceFdKHR( static_cast( m_device ), reinterpret_cast( pImportFenceFdInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkImportFenceFdKHR && "Function requires " ); +# endif + + Result result = static_cast( d.vkImportFenceFdKHR( m_device, reinterpret_cast( &importFenceFdInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR * pGetFdInfo, + int * pFd, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetFenceFdKHR( static_cast( m_device ), reinterpret_cast( pGetFdInfo ), pFd ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetFenceFdKHR && "Function requires " ); +# endif + + int fd; + Result result = static_cast( d.vkGetFenceFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" ); + + return detail::createResultValueType( result, std::move( fd ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_performance_query === + + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, + uint32_t * pCounterCount, + PerformanceCounterKHR * pCounters, + PerformanceCounterDescriptionKHR * pCounterDescriptions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( static_cast( m_physicalDevice ), + queueFamilyIndex, + pCounterCount, + reinterpret_cast( pCounters ), + reinterpret_cast( pCounterDescriptions ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html + template ::value && + std::is_same::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, + std::vector>>::type + PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && + "Function requires " ); +# endif + + std::pair, + std::vector> + data_; + std::vector & counters = data_.first; + std::vector & counterDescriptions = data_.second; + uint32_t counterCount; + Result result; + do + { + result = static_cast( + d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); + if ( ( result == Result::eSuccess ) && counterCount ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + m_physicalDevice, + queueFamilyIndex, + &counterCount, + reinterpret_cast( counters.data() ), + reinterpret_cast( counterDescriptions.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); + VULKAN_HPP_ASSERT( counterCount <= counters.size() ); + if ( counterCount < counters.size() ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + } + return detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html + template ::value && + std::is_same::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, + std::vector>>::type + PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( + uint32_t queueFamilyIndex, + PerformanceCounterKHRAllocator const & performanceCounterKHRAllocator, + PerformanceCounterDescriptionKHRAllocator const & performanceCounterDescriptionKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && + "Function requires " ); +# endif + + std::pair, + std::vector> + data_( + std::piecewise_construct, std::forward_as_tuple( performanceCounterKHRAllocator ), std::forward_as_tuple( performanceCounterDescriptionKHRAllocator ) ); + std::vector & counters = data_.first; + std::vector & counterDescriptions = data_.second; + uint32_t counterCount; + Result result; + do + { + result = static_cast( + d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); + if ( ( result == Result::eSuccess ) && counterCount ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + m_physicalDevice, + queueFamilyIndex, + &counterCount, + reinterpret_cast( counters.data() ), + reinterpret_cast( counterDescriptions.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); + VULKAN_HPP_ASSERT( counterCount <= counters.size() ); + if ( counterCount < counters.size() ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + } + return detail::createResultValueType( result, std::move( data_ ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, + uint32_t * pNumPasses, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( pPerformanceQueryCreateInfo ), + pNumPasses ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( + const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR && + "Function requires " ); +# endif + + uint32_t numPasses; + d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + m_physicalDevice, reinterpret_cast( &performanceQueryCreateInfo ), &numPasses ); + + return numPasses; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkAcquireProfilingLockKHR( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAcquireProfilingLockKHR && "Function requires " ); +# endif + + Result result = static_cast( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast( &info ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkReleaseProfilingLockKHR( static_cast( m_device ) ); + } + + //=== VK_KHR_get_surface_capabilities2 === + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + SurfaceCapabilities2KHR * pSurfaceCapabilities, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( pSurfaceInfo ), + reinterpret_cast( pSurfaceCapabilities ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR && + "Function requires " ); +# endif + + SurfaceCapabilities2KHR surfaceCapabilities; + Result result = + static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, + reinterpret_cast( &surfaceInfo ), + reinterpret_cast( &surfaceCapabilities ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); + + return detail::createResultValueType( result, std::move( surfaceCapabilities ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR && + "Function requires " ); +# endif + + StructureChain structureChain; + SurfaceCapabilities2KHR & surfaceCapabilities = structureChain.template get(); + Result result = + static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, + reinterpret_cast( &surfaceInfo ), + reinterpret_cast( &surfaceCapabilities ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); + + return detail::createResultValueType( result, std::move( structureChain ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + uint32_t * pSurfaceFormatCount, + SurfaceFormat2KHR * pSurfaceFormats, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( pSurfaceInfo ), + pSurfaceFormatCount, + reinterpret_cast( pSurfaceFormats ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && + "Function requires " ); +# endif + + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( + m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + surfaceFormats.resize( surfaceFormatCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, + reinterpret_cast( &surfaceInfo ), + &surfaceFormatCount, + reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + if ( surfaceFormatCount < surfaceFormats.size() ) + { + surfaceFormats.resize( surfaceFormatCount ); + } + return detail::createResultValueType( result, std::move( surfaceFormats ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, + SurfaceFormat2KHRAllocator const & surfaceFormat2KHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && + "Function requires " ); +# endif + + std::vector surfaceFormats( surfaceFormat2KHRAllocator ); + uint32_t surfaceFormatCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( + m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + surfaceFormats.resize( surfaceFormatCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, + reinterpret_cast( &surfaceInfo ), + &surfaceFormatCount, + reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + if ( surfaceFormatCount < surfaceFormats.size() ) + { + surfaceFormats.resize( surfaceFormatCount ); + } + return detail::createResultValueType( result, std::move( surfaceFormats ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && + "Function requires " ); +# endif + + std::vector structureChains; + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( + m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + structureChains.resize( surfaceFormatCount ); + surfaceFormats.resize( surfaceFormatCount ); + for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) + { + surfaceFormats[i].pNext = structureChains[i].template get().pNext; + } + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, + reinterpret_cast( &surfaceInfo ), + &surfaceFormatCount, + reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + if ( surfaceFormatCount < surfaceFormats.size() ) + { + structureChains.resize( surfaceFormatCount ); + } + for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) + { + structureChains[i].template get() = surfaceFormats[i]; + } + return detail::createResultValueType( result, std::move( structureChains ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, + StructureChainAllocator & structureChainAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && + "Function requires " ); +# endif + + std::vector structureChains( structureChainAllocator ); + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( + m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + structureChains.resize( surfaceFormatCount ); + surfaceFormats.resize( surfaceFormatCount ); + for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) + { + surfaceFormats[i].pNext = structureChains[i].template get().pNext; + } + result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, + reinterpret_cast( &surfaceInfo ), + &surfaceFormatCount, + reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + if ( surfaceFormatCount < surfaceFormats.size() ) + { + structureChains.resize( surfaceFormatCount ); + } + for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) + { + structureChains[i].template get() = surfaceFormats[i]; + } + return detail::createResultValueType( result, std::move( structureChains ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_get_display_properties2 === + + // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t * pPropertyCount, + DisplayProperties2KHR * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( + static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayProperties2KHR( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayProperties2KHR && + "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( + d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayProperties2KHR( DisplayProperties2KHRAllocator const & displayProperties2KHRAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayProperties2KHR && + "Function requires " ); +# endif + + std::vector properties( displayProperties2KHRAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( + d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount, + DisplayPlaneProperties2KHR * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( + static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayPlaneProperties2KHR( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR && + "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator const & displayPlaneProperties2KHRAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR && + "Function requires " ); +# endif + + std::vector properties( displayPlaneProperties2KHRAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, + uint32_t * pPropertyCount, + DisplayModeProperties2KHR * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDisplayModeProperties2KHR( static_cast( m_physicalDevice ), + static_cast( display ), + pPropertyCount, + reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetDisplayModeProperties2KHR( + m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, + DisplayModeProperties2KHRAllocator const & displayModeProperties2KHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function requires " ); +# endif + + std::vector properties( displayModeProperties2KHRAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetDisplayModeProperties2KHR( + m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function requires " ); +# endif + + std::vector structureChains; + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + structureChains.resize( propertyCount ); + properties.resize( propertyCount ); + for ( uint32_t i = 0; i < propertyCount; i++ ) + { + properties[i].pNext = structureChains[i].template get().pNext; + } + result = static_cast( d.vkGetDisplayModeProperties2KHR( + m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + structureChains.resize( propertyCount ); + } + for ( uint32_t i = 0; i < propertyCount; i++ ) + { + structureChains[i].template get() = properties[i]; + } + return detail::createResultValueType( result, std::move( structureChains ) ); + } + + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function requires " ); +# endif + + std::vector structureChains( structureChainAllocator ); + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + structureChains.resize( propertyCount ); + properties.resize( propertyCount ); + for ( uint32_t i = 0; i < propertyCount; i++ ) + { + properties[i].pNext = structureChains[i].template get().pNext; + } + result = static_cast( d.vkGetDisplayModeProperties2KHR( + m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + structureChains.resize( propertyCount ); + } + for ( uint32_t i = 0; i < propertyCount; i++ ) + { + structureChains[i].template get() = properties[i]; + } + return detail::createResultValueType( result, std::move( structureChains ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR * pDisplayPlaneInfo, + DisplayPlaneCapabilities2KHR * pCapabilities, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDisplayPlaneCapabilities2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( pDisplayPlaneInfo ), + reinterpret_cast( pCapabilities ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneCapabilities2KHR && "Function requires " ); +# endif + + DisplayPlaneCapabilities2KHR capabilities; + Result result = static_cast( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, + reinterpret_cast( &displayPlaneInfo ), + reinterpret_cast( &capabilities ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); + + return detail::createResultValueType( result, std::move( capabilities ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateIOSSurfaceMVK( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateIOSSurfaceMVK && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateIOSSurfaceMVK( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateIOSSurfaceMVK && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateIOSSurfaceMVK( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVKUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateMacOSSurfaceMVK( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateMacOSSurfaceMVK && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateMacOSSurfaceMVK( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createMacOSSurfaceMVKUnique( + const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateMacOSSurfaceMVK && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateMacOSSurfaceMVK( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVKUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + + // wrapper function for command vkSetDebugUtilsObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT * pNameInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkSetDebugUtilsObjectNameEXT( static_cast( m_device ), reinterpret_cast( pNameInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetDebugUtilsObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetDebugUtilsObjectNameEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" ); + + return detail::createResultValueType( result ); + } + + // wrapper function for command vkSetDebugUtilsObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name, Dispatch const & d ) const + { + VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); + // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member + VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo; + nameInfo.objectType = handle.objectType; + nameInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); + nameInfo.pObjectName = name.c_str(); + return setDebugUtilsObjectNameEXT( nameInfo, d ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT * pTagInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkSetDebugUtilsObjectTagEXT( static_cast( m_device ), reinterpret_cast( pTagInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetDebugUtilsObjectTagEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" ); + + return detail::createResultValueType( result ); + } + + // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::setDebugUtilsObjectTagEXT( HandleType const & handle, uint64_t name, TagType const & tag, Dispatch const & d ) const + { + VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); + // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member + VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo; + tagInfo.objectType = handle.objectType; + tagInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); + tagInfo.tagName = name; + tagInfo.tagSize = sizeof( TagType ); + tagInfo.pTag = &tag; + return setDebugUtilsObjectTagEXT( tagInfo, d ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html + template ::type> + VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkQueueBeginDebugUtilsLabelEXT( static_cast( m_queue ), reinterpret_cast( pLabelInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html + template ::type> + VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkQueueBeginDebugUtilsLabelEXT && "Function requires " ); +# endif + + d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast( &labelInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html + template ::type> + VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkQueueEndDebugUtilsLabelEXT( static_cast( m_queue ) ); + } + + // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html + template ::type> + VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkQueueInsertDebugUtilsLabelEXT( static_cast( m_queue ), reinterpret_cast( pLabelInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html + template ::type> + VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkQueueInsertDebugUtilsLabelEXT && "Function requires " ); +# endif + + d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast( &labelInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginDebugUtilsLabelEXT( static_cast( m_commandBuffer ), reinterpret_cast( pLabelInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginDebugUtilsLabelEXT && "Function requires " ); +# endif + + d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( &labelInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndDebugUtilsLabelEXT( static_cast( m_commandBuffer ) ); + } + + // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdInsertDebugUtilsLabelEXT( static_cast( m_commandBuffer ), reinterpret_cast( pLabelInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdInsertDebugUtilsLabelEXT && "Function requires " ); +# endif + + d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( &labelInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + DebugUtilsMessengerEXT * pMessenger, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDebugUtilsMessengerEXT( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pMessenger ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createDebugUtilsMessengerEXT( + const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDebugUtilsMessengerEXT && "Function requires " ); +# endif + + DebugUtilsMessengerEXT messenger; + Result result = static_cast( d.vkCreateDebugUtilsMessengerEXT( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &messenger ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" ); + + return detail::createResultValueType( result, std::move( messenger ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDebugUtilsMessengerEXT && "Function requires " ); +# endif + + DebugUtilsMessengerEXT messenger; + Result result = static_cast( d.vkCreateDebugUtilsMessengerEXT( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &messenger ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXTUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( messenger, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html + template ::type> + VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDebugUtilsMessengerEXT( static_cast( m_instance ), + static_cast( messenger ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html + template ::type> + VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDebugUtilsMessengerEXT && "Function requires " ); +# endif + + d.vkDestroyDebugUtilsMessengerEXT( + m_instance, static_cast( messenger ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html + template ::type> + VULKAN_HPP_INLINE void + Instance::destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDebugUtilsMessengerEXT( static_cast( m_instance ), + static_cast( messenger ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html + template ::type> + VULKAN_HPP_INLINE void + Instance::destroy( DebugUtilsMessengerEXT messenger, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDebugUtilsMessengerEXT && "Function requires " ); +# endif + + d.vkDestroyDebugUtilsMessengerEXT( + m_instance, static_cast( messenger ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSubmitDebugUtilsMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html + template ::type> + VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + DebugUtilsMessageTypeFlagsEXT messageTypes, + const DebugUtilsMessengerCallbackDataEXT * pCallbackData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkSubmitDebugUtilsMessageEXT( static_cast( m_instance ), + static_cast( messageSeverity ), + static_cast( messageTypes ), + reinterpret_cast( pCallbackData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSubmitDebugUtilsMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html + template ::type> + VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + DebugUtilsMessageTypeFlagsEXT messageTypes, + const DebugUtilsMessengerCallbackDataEXT & callbackData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSubmitDebugUtilsMessageEXT && "Function requires " ); +# endif + + d.vkSubmitDebugUtilsMessageEXT( m_instance, + static_cast( messageSeverity ), + static_cast( messageTypes ), + reinterpret_cast( &callbackData ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer, + AndroidHardwareBufferPropertiesANDROID * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetAndroidHardwareBufferPropertiesANDROID( + static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetAndroidHardwareBufferPropertiesANDROID && + "Function requires " ); +# endif + + AndroidHardwareBufferPropertiesANDROID properties; + Result result = static_cast( + d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast( &properties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); + + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetAndroidHardwareBufferPropertiesANDROID && + "Function requires " ); +# endif + + StructureChain structureChain; + AndroidHardwareBufferPropertiesANDROID & properties = structureChain.template get(); + Result result = static_cast( + d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast( &properties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); + + return detail::createResultValueType( result, std::move( structureChain ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID * pInfo, + struct AHardwareBuffer ** pBuffer, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetMemoryAndroidHardwareBufferANDROID( + static_cast( m_device ), reinterpret_cast( pInfo ), pBuffer ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryAndroidHardwareBufferANDROID && + "Function requires " ); +# endif + + struct AHardwareBuffer * buffer; + Result result = static_cast( + d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast( &info ), &buffer ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); + + return detail::createResultValueType( result, std::move( buffer ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, + uint32_t createInfoCount, + const ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateExecutionGraphPipelinesAMDX( static_cast( m_device ), + static_cast( pipelineCache ), + createInfoCount, + reinterpret_cast( pCreateInfos ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pPipelines ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = + static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); + Result result = + static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue + Device::createExecutionGraphPipelineAMDX( PipelineCache pipelineCache, + const ExecutionGraphPipelineCreateInfoAMDX & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDX", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue( result, std::move( pipeline ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = + static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDXUnique", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines; + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = + static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDXUnique", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createExecutionGraphPipelineAMDXUnique( PipelineCache pipelineCache, + const ExecutionGraphPipelineCreateInfoAMDX & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDXUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue>( + result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph, + ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetExecutionGraphPipelineScratchSizeAMDX( static_cast( m_device ), + static_cast( executionGraph ), + reinterpret_cast( pSizeInfo ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetExecutionGraphPipelineScratchSizeAMDX && + "Function requires " ); +# endif + + ExecutionGraphPipelineScratchSizeAMDX sizeInfo; + Result result = static_cast( d.vkGetExecutionGraphPipelineScratchSizeAMDX( + m_device, static_cast( executionGraph ), reinterpret_cast( &sizeInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getExecutionGraphPipelineScratchSizeAMDX" ); + + return detail::createResultValueType( result, std::move( sizeInfo ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getExecutionGraphPipelineNodeIndexAMDX( Pipeline executionGraph, + const PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo, + uint32_t * pNodeIndex, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetExecutionGraphPipelineNodeIndexAMDX( static_cast( m_device ), + static_cast( executionGraph ), + reinterpret_cast( pNodeInfo ), + pNodeIndex ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getExecutionGraphPipelineNodeIndexAMDX( Pipeline executionGraph, const PipelineShaderStageNodeCreateInfoAMDX & nodeInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetExecutionGraphPipelineNodeIndexAMDX && "Function requires " ); +# endif + + uint32_t nodeIndex; + Result result = static_cast( d.vkGetExecutionGraphPipelineNodeIndexAMDX( + m_device, static_cast( executionGraph ), reinterpret_cast( &nodeInfo ), &nodeIndex ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getExecutionGraphPipelineNodeIndexAMDX" ); + + return detail::createResultValueType( result, std::move( nodeIndex ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::initializeGraphScratchMemoryAMDX( Pipeline executionGraph, + DeviceAddress scratch, + DeviceSize scratchSize, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdInitializeGraphScratchMemoryAMDX( static_cast( m_commandBuffer ), + static_cast( executionGraph ), + static_cast( scratch ), + static_cast( scratchSize ) ); + } + + // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphAMDX( DeviceAddress scratch, + DeviceSize scratchSize, + const DispatchGraphCountInfoAMDX * pCountInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDispatchGraphAMDX( static_cast( m_commandBuffer ), + static_cast( scratch ), + static_cast( scratchSize ), + reinterpret_cast( pCountInfo ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphAMDX( DeviceAddress scratch, + DeviceSize scratchSize, + const DispatchGraphCountInfoAMDX & countInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDispatchGraphAMDX && "Function requires " ); +# endif + + d.vkCmdDispatchGraphAMDX( m_commandBuffer, + static_cast( scratch ), + static_cast( scratchSize ), + reinterpret_cast( &countInfo ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectAMDX( DeviceAddress scratch, + DeviceSize scratchSize, + const DispatchGraphCountInfoAMDX * pCountInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDispatchGraphIndirectAMDX( static_cast( m_commandBuffer ), + static_cast( scratch ), + static_cast( scratchSize ), + reinterpret_cast( pCountInfo ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectAMDX( DeviceAddress scratch, + DeviceSize scratchSize, + const DispatchGraphCountInfoAMDX & countInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDispatchGraphIndirectAMDX && "Function requires " ); +# endif + + d.vkCmdDispatchGraphIndirectAMDX( m_commandBuffer, + static_cast( scratch ), + static_cast( scratchSize ), + reinterpret_cast( &countInfo ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectCountAMDX( DeviceAddress scratch, + DeviceSize scratchSize, + DeviceAddress countInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDispatchGraphIndirectCountAMDX( static_cast( m_commandBuffer ), + static_cast( scratch ), + static_cast( scratchSize ), + static_cast( countInfo ) ); + } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + + // wrapper function for command vkWriteSamplerDescriptorsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeSamplerDescriptorsEXT( uint32_t samplerCount, + const SamplerCreateInfo * pSamplers, + const HostAddressRangeEXT * pDescriptors, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkWriteSamplerDescriptorsEXT( static_cast( m_device ), + samplerCount, + reinterpret_cast( pSamplers ), + reinterpret_cast( pDescriptors ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWriteSamplerDescriptorsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::writeSamplerDescriptorsEXT( + ArrayProxy const & samplers, ArrayProxy const & descriptors, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkWriteSamplerDescriptorsEXT && "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( samplers.size() == descriptors.size() ); +# else + if ( samplers.size() != descriptors.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT: samplers.size() != descriptors.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + Result result = static_cast( d.vkWriteSamplerDescriptorsEXT( m_device, + samplers.size(), + reinterpret_cast( samplers.data() ), + reinterpret_cast( descriptors.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkWriteResourceDescriptorsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeResourceDescriptorsEXT( uint32_t resourceCount, + const ResourceDescriptorInfoEXT * pResources, + const HostAddressRangeEXT * pDescriptors, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkWriteResourceDescriptorsEXT( static_cast( m_device ), + resourceCount, + reinterpret_cast( pResources ), + reinterpret_cast( pDescriptors ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWriteResourceDescriptorsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::writeResourceDescriptorsEXT( + ArrayProxy const & resources, ArrayProxy const & descriptors, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkWriteResourceDescriptorsEXT && "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( resources.size() == descriptors.size() ); +# else + if ( resources.size() != descriptors.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT: resources.size() != descriptors.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + Result result = static_cast( d.vkWriteResourceDescriptorsEXT( m_device, + resources.size(), + reinterpret_cast( resources.data() ), + reinterpret_cast( descriptors.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindSamplerHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindSamplerHeapEXT( static_cast( m_commandBuffer ), reinterpret_cast( pBindInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindSamplerHeapEXT && "Function requires " ); +# endif + + d.vkCmdBindSamplerHeapEXT( m_commandBuffer, reinterpret_cast( &bindInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindResourceHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindResourceHeapEXT( static_cast( m_commandBuffer ), reinterpret_cast( pBindInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindResourceHeapEXT && "Function requires " ); +# endif + + d.vkCmdBindResourceHeapEXT( m_commandBuffer, reinterpret_cast( &bindInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDataEXT( const PushDataInfoEXT * pPushDataInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushDataEXT( static_cast( m_commandBuffer ), reinterpret_cast( pPushDataInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDataEXT( const PushDataInfoEXT & pushDataInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPushDataEXT && "Function requires " ); +# endif + + d.vkCmdPushDataEXT( m_commandBuffer, reinterpret_cast( &pushDataInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageOpaqueCaptureDataEXT( uint32_t imageCount, + const Image * pImages, + HostAddressRangeEXT * pDatas, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetImageOpaqueCaptureDataEXT( + static_cast( m_device ), imageCount, reinterpret_cast( pImages ), reinterpret_cast( pDatas ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getImageOpaqueCaptureDataEXT( ArrayProxy const & images, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDataEXT && "Function requires " ); +# endif + + std::vector datas( images.size() ); + Result result = static_cast( d.vkGetImageOpaqueCaptureDataEXT( + m_device, images.size(), reinterpret_cast( images.data() ), reinterpret_cast( datas.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" ); + + return detail::createResultValueType( result, std::move( datas ) ); + } + + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getImageOpaqueCaptureDataEXT( ArrayProxy const & images, + HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDataEXT && "Function requires " ); +# endif + + std::vector datas( images.size(), {}, hostAddressRangeEXTAllocator ); + Result result = static_cast( d.vkGetImageOpaqueCaptureDataEXT( + m_device, images.size(), reinterpret_cast( images.data() ), reinterpret_cast( datas.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" ); + + return detail::createResultValueType( result, std::move( datas ) ); + } + + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getImageOpaqueCaptureDataEXT( const Image & image, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDataEXT && "Function requires " ); +# endif + + HostAddressRangeEXT data; + Result result = static_cast( + d.vkGetImageOpaqueCaptureDataEXT( m_device, 1, reinterpret_cast( &image ), reinterpret_cast( &data ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html + template ::type> + VULKAN_HPP_INLINE DeviceSize PhysicalDevice::getDescriptorSizeEXT( DescriptorType descriptorType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceDescriptorSizeEXT( static_cast( m_physicalDevice ), static_cast( descriptorType ) ) ); + } + + // wrapper function for command vkRegisterCustomBorderColorEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT * pBorderColor, + Bool32 requestIndex, + uint32_t * pIndex, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkRegisterCustomBorderColorEXT( static_cast( m_device ), + reinterpret_cast( pBorderColor ), + static_cast( requestIndex ), + pIndex ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkRegisterCustomBorderColorEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT & borderColor, Bool32 requestIndex, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkRegisterCustomBorderColorEXT && "Function requires " ); +# endif + + uint32_t index; + Result result = static_cast( d.vkRegisterCustomBorderColorEXT( + m_device, reinterpret_cast( &borderColor ), static_cast( requestIndex ), &index ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerCustomBorderColorEXT" ); + + return detail::createResultValueType( result, std::move( index ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUnregisterCustomBorderColorEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::unregisterCustomBorderColorEXT( uint32_t index, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkUnregisterCustomBorderColorEXT( static_cast( m_device ), index ); + } + + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getTensorOpaqueCaptureDataARM( uint32_t tensorCount, + const TensorARM * pTensors, + HostAddressRangeEXT * pDatas, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetTensorOpaqueCaptureDataARM( static_cast( m_device ), + tensorCount, + reinterpret_cast( pTensors ), + reinterpret_cast( pDatas ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDataARM && "Function requires " ); +# endif + + std::vector datas( tensors.size() ); + Result result = static_cast( d.vkGetTensorOpaqueCaptureDataARM( + m_device, tensors.size(), reinterpret_cast( tensors.data() ), reinterpret_cast( datas.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" ); + + return detail::createResultValueType( result, std::move( datas ) ); + } + + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors, + HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDataARM && "Function requires " ); +# endif + + std::vector datas( tensors.size(), {}, hostAddressRangeEXTAllocator ); + Result result = static_cast( d.vkGetTensorOpaqueCaptureDataARM( + m_device, tensors.size(), reinterpret_cast( tensors.data() ), reinterpret_cast( datas.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" ); + + return detail::createResultValueType( result, std::move( datas ) ); + } + + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getTensorOpaqueCaptureDataARM( const TensorARM & tensor, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDataARM && "Function requires " ); +# endif + + HostAddressRangeEXT data; + Result result = static_cast( + d.vkGetTensorOpaqueCaptureDataARM( m_device, 1, reinterpret_cast( &tensor ), reinterpret_cast( &data ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_sample_locations === + + // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT * pSampleLocationsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetSampleLocationsEXT( static_cast( m_commandBuffer ), reinterpret_cast( pSampleLocationsInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetSampleLocationsEXT && "Function requires " ); +# endif + + d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast( &sampleLocationsInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, + MultisamplePropertiesEXT * pMultisampleProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceMultisamplePropertiesEXT( static_cast( m_physicalDevice ), + static_cast( samples ), + reinterpret_cast( pMultisampleProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMultisamplePropertiesEXT && + "Function requires " ); +# endif + + MultisamplePropertiesEXT multisampleProperties; + d.vkGetPhysicalDeviceMultisamplePropertiesEXT( + m_physicalDevice, static_cast( samples ), reinterpret_cast( &multisampleProperties ) ); + + return multisampleProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_get_memory_requirements2 === + + // wrapper function for command vkGetImageMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetImageMemoryRequirements2KHR( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2KHR && + "Function requires or " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetImageMemoryRequirements2KHR( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetImageMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2KHR && + "Function requires or " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetImageMemoryRequirements2KHR( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetBufferMemoryRequirements2KHR( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2KHR && + "Function requires or " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetBufferMemoryRequirements2KHR( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetBufferMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2KHR && + "Function requires or " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetBufferMemoryRequirements2KHR( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 * pInfo, + uint32_t * pSparseMemoryRequirementCount, + SparseImageMemoryRequirements2 * pSparseMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetImageSparseMemoryRequirements2KHR( static_cast( m_device ), + reinterpret_cast( pInfo ), + pSparseMemoryRequirementCount, + reinterpret_cast( pSparseMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html + template < + typename SparseImageMemoryRequirements2Allocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2KHR && + "Function requires or " ); +# endif + + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + d.vkGetImageSparseMemoryRequirements2KHR( + m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetImageSparseMemoryRequirements2KHR( m_device, + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } + + // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html + template < + typename SparseImageMemoryRequirements2Allocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, + SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2KHR && + "Function requires or " ); +# endif + + std::vector sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator ); + uint32_t sparseMemoryRequirementCount; + d.vkGetImageSparseMemoryRequirements2KHR( + m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetImageSparseMemoryRequirements2KHR( m_device, + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_acceleration_structure === + + // wrapper function for command vkCreateAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + AccelerationStructureKHR * pAccelerationStructure, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateAccelerationStructureKHR( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pAccelerationStructure ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createAccelerationStructureKHR( + const AccelerationStructureCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureKHR && "Function requires " ); +# endif + + AccelerationStructureKHR accelerationStructure; + Result result = static_cast( d.vkCreateAccelerationStructureKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &accelerationStructure ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" ); + + return detail::createResultValueType( result, std::move( accelerationStructure ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureKHR && "Function requires " ); +# endif + + AccelerationStructureKHR accelerationStructure; + Result result = static_cast( d.vkCreateAccelerationStructureKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &accelerationStructure ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHRUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( accelerationStructure, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyAccelerationStructureKHR( static_cast( m_device ), + static_cast( accelerationStructure ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureKHR && "Function requires " ); +# endif + + d.vkDestroyAccelerationStructureKHR( + m_device, static_cast( accelerationStructure ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( AccelerationStructureKHR accelerationStructure, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyAccelerationStructureKHR( static_cast( m_device ), + static_cast( accelerationStructure ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureKHR accelerationStructure, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureKHR && "Function requires " ); +# endif + + d.vkDestroyAccelerationStructureKHR( + m_device, static_cast( accelerationStructure ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR( uint32_t infoCount, + const AccelerationStructureBuildGeometryInfoKHR * pInfos, + const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBuildAccelerationStructuresKHR( static_cast( m_commandBuffer ), + infoCount, + reinterpret_cast( pInfos ), + reinterpret_cast( ppBuildRangeInfos ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::buildAccelerationStructuresKHR( ArrayProxy const & infos, + ArrayProxy const & pBuildRangeInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructuresKHR && "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); +# else + if ( infos.size() != pBuildRangeInfos.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdBuildAccelerationStructuresKHR( m_commandBuffer, + infos.size(), + reinterpret_cast( infos.data() ), + reinterpret_cast( pBuildRangeInfos.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( uint32_t infoCount, + const AccelerationStructureBuildGeometryInfoKHR * pInfos, + const DeviceAddress * pIndirectDeviceAddresses, + const uint32_t * pIndirectStrides, + const uint32_t * const * ppMaxPrimitiveCounts, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBuildAccelerationStructuresIndirectKHR( static_cast( m_commandBuffer ), + infoCount, + reinterpret_cast( pInfos ), + reinterpret_cast( pIndirectDeviceAddresses ), + pIndirectStrides, + ppMaxPrimitiveCounts ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( ArrayProxy const & infos, + ArrayProxy const & indirectDeviceAddresses, + ArrayProxy const & indirectStrides, + ArrayProxy const & pMaxPrimitiveCounts, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructuresIndirectKHR && + "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() ); + VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() ); + VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() ); +# else + if ( infos.size() != indirectDeviceAddresses.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" ); + } + if ( infos.size() != indirectStrides.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" ); + } + if ( infos.size() != pMaxPrimitiveCounts.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdBuildAccelerationStructuresIndirectKHR( m_commandBuffer, + infos.size(), + reinterpret_cast( infos.data() ), + reinterpret_cast( indirectDeviceAddresses.data() ), + indirectStrides.data(), + pMaxPrimitiveCounts.data() ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation, + uint32_t infoCount, + const AccelerationStructureBuildGeometryInfoKHR * pInfos, + const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkBuildAccelerationStructuresKHR( static_cast( m_device ), + static_cast( deferredOperation ), + infoCount, + reinterpret_cast( pInfos ), + reinterpret_cast( ppBuildRangeInfos ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation, + ArrayProxy const & infos, + ArrayProxy const & pBuildRangeInfos, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBuildAccelerationStructuresKHR && "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); +# else + if ( infos.size() != pBuildRangeInfos.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + Result result = static_cast( + d.vkBuildAccelerationStructuresKHR( m_device, + static_cast( deferredOperation ), + infos.size(), + reinterpret_cast( infos.data() ), + reinterpret_cast( pBuildRangeInfos.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureInfoKHR * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCopyAccelerationStructureKHR( static_cast( m_device ), + static_cast( deferredOperation ), + reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureInfoKHR & info, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyAccelerationStructureKHR && "Function requires " ); +# endif + + Result result = static_cast( d.vkCopyAccelerationStructureKHR( + m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureToMemoryInfoKHR * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCopyAccelerationStructureToMemoryKHR( static_cast( m_device ), + static_cast( deferredOperation ), + reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureToMemoryInfoKHR & info, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyAccelerationStructureToMemoryKHR && + "Function requires " ); +# endif + + Result result = static_cast( d.vkCopyAccelerationStructureToMemoryKHR( + m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation, + const CopyMemoryToAccelerationStructureInfoKHR * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCopyMemoryToAccelerationStructureKHR( static_cast( m_device ), + static_cast( deferredOperation ), + reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation, + const CopyMemoryToAccelerationStructureInfoKHR & info, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyMemoryToAccelerationStructureKHR && + "Function requires " ); +# endif + + Result result = static_cast( d.vkCopyMemoryToAccelerationStructureKHR( + m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, + const AccelerationStructureKHR * pAccelerationStructures, + QueryType queryType, + size_t dataSize, + void * pData, + size_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkWriteAccelerationStructuresPropertiesKHR( static_cast( m_device ), + accelerationStructureCount, + reinterpret_cast( pAccelerationStructures ), + static_cast( queryType ), + dataSize, + pData, + stride ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::writeAccelerationStructuresPropertiesKHR( + ArrayProxy const & accelerationStructures, QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkWriteAccelerationStructuresPropertiesKHR && + "Function requires " ); +# endif + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = + static_cast( d.vkWriteAccelerationStructuresPropertiesKHR( m_device, + accelerationStructures.size(), + reinterpret_cast( accelerationStructures.data() ), + static_cast( queryType ), + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ), + stride ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); + + return detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::writeAccelerationStructuresPropertyKHR( + ArrayProxy const & accelerationStructures, QueryType queryType, size_t stride, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkWriteAccelerationStructuresPropertiesKHR && + "Function requires " ); +# endif + + DataType data; + Result result = + static_cast( d.vkWriteAccelerationStructuresPropertiesKHR( m_device, + accelerationStructures.size(), + reinterpret_cast( accelerationStructures.data() ), + static_cast( queryType ), + sizeof( DataType ), + reinterpret_cast( &data ), + stride ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyAccelerationStructureKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyAccelerationStructureKHR && "Function requires " ); +# endif + + d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyAccelerationStructureToMemoryKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyAccelerationStructureToMemoryKHR && + "Function requires " ); +# endif + + d.vkCmdCopyAccelerationStructureToMemoryKHR( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyMemoryToAccelerationStructureKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToAccelerationStructureKHR && + "Function requires " ); +# endif + + d.vkCmdCopyMemoryToAccelerationStructureKHR( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html + template ::type> + VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetAccelerationStructureDeviceAddressKHR( + static_cast( m_device ), reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html + template ::type> + VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureDeviceAddressKHR && + "Function requires " ); +# endif + + VkDeviceAddress result = + d.vkGetAccelerationStructureDeviceAddressKHR( m_device, reinterpret_cast( &info ) ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, + const AccelerationStructureKHR * pAccelerationStructures, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWriteAccelerationStructuresPropertiesKHR( static_cast( m_commandBuffer ), + accelerationStructureCount, + reinterpret_cast( pAccelerationStructures ), + static_cast( queryType ), + static_cast( queryPool ), + firstQuery ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdWriteAccelerationStructuresPropertiesKHR && + "Function requires " ); +# endif + + d.vkCmdWriteAccelerationStructuresPropertiesKHR( m_commandBuffer, + accelerationStructures.size(), + reinterpret_cast( accelerationStructures.data() ), + static_cast( queryType ), + static_cast( queryPool ), + firstQuery ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR * pVersionInfo, + AccelerationStructureCompatibilityKHR * pCompatibility, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceAccelerationStructureCompatibilityKHR( static_cast( m_device ), + reinterpret_cast( pVersionInfo ), + reinterpret_cast( pCompatibility ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureCompatibilityKHR + Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceAccelerationStructureCompatibilityKHR && + "Function requires " ); +# endif + + AccelerationStructureCompatibilityKHR compatibility; + d.vkGetDeviceAccelerationStructureCompatibilityKHR( m_device, + reinterpret_cast( &versionInfo ), + reinterpret_cast( &compatibility ) ); + + return compatibility; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, + const AccelerationStructureBuildGeometryInfoKHR * pBuildInfo, + const uint32_t * pMaxPrimitiveCounts, + AccelerationStructureBuildSizesInfoKHR * pSizeInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetAccelerationStructureBuildSizesKHR( static_cast( m_device ), + static_cast( buildType ), + reinterpret_cast( pBuildInfo ), + pMaxPrimitiveCounts, + reinterpret_cast( pSizeInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR + Device::getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, + const AccelerationStructureBuildGeometryInfoKHR & buildInfo, + ArrayProxy const & maxPrimitiveCounts, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureBuildSizesKHR && + "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( maxPrimitiveCounts.size() == buildInfo.geometryCount ); +# else + if ( maxPrimitiveCounts.size() != buildInfo.geometryCount ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + AccelerationStructureBuildSizesInfoKHR sizeInfo; + d.vkGetAccelerationStructureBuildSizesKHR( m_device, + static_cast( buildType ), + reinterpret_cast( &buildInfo ), + maxPrimitiveCounts.data(), + reinterpret_cast( &sizeInfo ) ); + + return sizeInfo; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_ray_tracing_pipeline === + + // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, + const StridedDeviceAddressRegionKHR * pMissShaderBindingTable, + const StridedDeviceAddressRegionKHR * pHitShaderBindingTable, + const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdTraceRaysKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pRaygenShaderBindingTable ), + reinterpret_cast( pMissShaderBindingTable ), + reinterpret_cast( pHitShaderBindingTable ), + reinterpret_cast( pCallableShaderBindingTable ), + width, + height, + depth ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, + const StridedDeviceAddressRegionKHR & missShaderBindingTable, + const StridedDeviceAddressRegionKHR & hitShaderBindingTable, + const StridedDeviceAddressRegionKHR & callableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdTraceRaysKHR && "Function requires " ); +# endif + + d.vkCmdTraceRaysKHR( m_commandBuffer, + reinterpret_cast( &raygenShaderBindingTable ), + reinterpret_cast( &missShaderBindingTable ), + reinterpret_cast( &hitShaderBindingTable ), + reinterpret_cast( &callableShaderBindingTable ), + width, + height, + depth ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + uint32_t createInfoCount, + const RayTracingPipelineCreateInfoKHR * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateRayTracingPipelinesKHR( static_cast( m_device ), + static_cast( deferredOperation ), + static_cast( pipelineCache ), + createInfoCount, + reinterpret_cast( pCreateInfos ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pPipelines ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); + Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::createRayTracingPipelineKHR( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + const RayTracingPipelineCreateInfoKHR & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue( result, std::move( pipeline ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines; + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createRayTracingPipelineKHRUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + const RayTracingPipelineCreateInfoKHR & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHRUnique", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue>( + result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesKHR( + Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetRayTracingShaderGroupHandlesKHR( + static_cast( m_device ), static_cast( pipeline ), firstGroup, groupCount, dataSize, pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getRayTracingShaderGroupHandlesKHR( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesKHR && + "Function requires or " ); +# endif + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesKHR( + m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" ); + + return detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getRayTracingShaderGroupHandleKHR( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesKHR && + "Function requires or " ); +# endif + + DataType data; + Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesKHR( + m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( + Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( + static_cast( m_device ), static_cast( pipeline ), firstGroup, groupCount, dataSize, pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( + Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && + "Function requires " ); +# endif + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( + m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); + + return detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getRayTracingCaptureReplayShaderGroupHandleKHR( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && + "Function requires " ); +# endif + + DataType data; + Result result = static_cast( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( + m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandleKHR" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, + const StridedDeviceAddressRegionKHR * pMissShaderBindingTable, + const StridedDeviceAddressRegionKHR * pHitShaderBindingTable, + const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, + DeviceAddress indirectDeviceAddress, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdTraceRaysIndirectKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pRaygenShaderBindingTable ), + reinterpret_cast( pMissShaderBindingTable ), + reinterpret_cast( pHitShaderBindingTable ), + reinterpret_cast( pCallableShaderBindingTable ), + static_cast( indirectDeviceAddress ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, + const StridedDeviceAddressRegionKHR & missShaderBindingTable, + const StridedDeviceAddressRegionKHR & hitShaderBindingTable, + const StridedDeviceAddressRegionKHR & callableShaderBindingTable, + DeviceAddress indirectDeviceAddress, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdTraceRaysIndirectKHR && "Function requires " ); +# endif + + d.vkCmdTraceRaysIndirectKHR( m_commandBuffer, + reinterpret_cast( &raygenShaderBindingTable ), + reinterpret_cast( &missShaderBindingTable ), + reinterpret_cast( &hitShaderBindingTable ), + reinterpret_cast( &callableShaderBindingTable ), + static_cast( indirectDeviceAddress ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html + template ::type> + VULKAN_HPP_INLINE DeviceSize Device::getRayTracingShaderGroupStackSizeKHR( Pipeline pipeline, + uint32_t group, + ShaderGroupShaderKHR groupShader, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetRayTracingShaderGroupStackSizeKHR( + static_cast( m_device ), static_cast( pipeline ), group, static_cast( groupShader ) ) ); + } + + // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetRayTracingPipelineStackSizeKHR( static_cast( m_commandBuffer ), pipelineStackSize ); + } + + //=== VK_KHR_sampler_ycbcr_conversion === + + // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + SamplerYcbcrConversion * pYcbcrConversion, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateSamplerYcbcrConversionKHR( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pYcbcrConversion ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createSamplerYcbcrConversionKHR( + const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversionKHR && + "Function requires or " ); +# endif + + SamplerYcbcrConversion ycbcrConversion; + Result result = static_cast( d.vkCreateSamplerYcbcrConversionKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &ycbcrConversion ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" ); + + return detail::createResultValueType( result, std::move( ycbcrConversion ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversionKHR && + "Function requires or " ); +# endif + + SamplerYcbcrConversion ycbcrConversion; + Result result = static_cast( d.vkCreateSamplerYcbcrConversionKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &ycbcrConversion ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHRUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( ycbcrConversion, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroySamplerYcbcrConversionKHR( static_cast( m_device ), + static_cast( ycbcrConversion ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversionKHR && + "Function requires or " ); +# endif + + d.vkDestroySamplerYcbcrConversionKHR( + m_device, static_cast( ycbcrConversion ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_bind_memory2 === + + // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, + const BindBufferMemoryInfo * pBindInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkBindBufferMemory2KHR( static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::bindBufferMemory2KHR( ArrayProxy const & bindInfos, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBindBufferMemory2KHR && "Function requires or " ); +# endif + + Result result = + static_cast( d.vkBindBufferMemory2KHR( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, + const BindImageMemoryInfo * pBindInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkBindImageMemory2KHR( static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::bindImageMemory2KHR( ArrayProxy const & bindInfos, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBindImageMemory2KHR && "Function requires or " ); +# endif + + Result result = + static_cast( d.vkBindImageMemory2KHR( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_image_drm_format_modifier === + + // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( Image image, + ImageDrmFormatModifierPropertiesEXT * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetImageDrmFormatModifierPropertiesEXT( + static_cast( m_device ), static_cast( image ), reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageDrmFormatModifierPropertiesEXT && + "Function requires " ); +# endif + + ImageDrmFormatModifierPropertiesEXT properties; + Result result = static_cast( d.vkGetImageDrmFormatModifierPropertiesEXT( + m_device, static_cast( image ), reinterpret_cast( &properties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageDrmFormatModifierPropertiesEXT" ); + + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_validation_cache === + + // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + ValidationCacheEXT * pValidationCache, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateValidationCacheEXT( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pValidationCache ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateValidationCacheEXT && "Function requires " ); +# endif + + ValidationCacheEXT validationCache; + Result result = static_cast( d.vkCreateValidationCacheEXT( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &validationCache ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" ); + + return detail::createResultValueType( result, std::move( validationCache ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::createValidationCacheEXTUnique( + const ValidationCacheCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateValidationCacheEXT && "Function requires " ); +# endif + + ValidationCacheEXT validationCache; + Result result = static_cast( d.vkCreateValidationCacheEXT( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &validationCache ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXTUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( validationCache, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyValidationCacheEXT( + static_cast( m_device ), static_cast( validationCache ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyValidationCacheEXT && "Function requires " ); +# endif + + d.vkDestroyValidationCacheEXT( + m_device, static_cast( validationCache ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( ValidationCacheEXT validationCache, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyValidationCacheEXT( + static_cast( m_device ), static_cast( validationCache ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( ValidationCacheEXT validationCache, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyValidationCacheEXT && "Function requires " ); +# endif + + d.vkDestroyValidationCacheEXT( + m_device, static_cast( validationCache ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const ValidationCacheEXT * pSrcCaches, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkMergeValidationCachesEXT( static_cast( m_device ), + static_cast( dstCache ), + srcCacheCount, + reinterpret_cast( pSrcCaches ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy const & srcCaches, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkMergeValidationCachesEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkMergeValidationCachesEXT( + m_device, static_cast( dstCache ), srcCaches.size(), reinterpret_cast( srcCaches.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergeValidationCachesEXT" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t * pDataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetValidationCacheDataEXT( static_cast( m_device ), static_cast( validationCache ), pDataSize, pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetValidationCacheDataEXT && "Function requires " ); +# endif + + std::vector data; + size_t dataSize; + Result result; + do + { + result = static_cast( d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( + d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetValidationCacheDataEXT && "Function requires " ); +# endif + + std::vector data( uint8_tAllocator ); + size_t dataSize; + Result result; + do + { + result = static_cast( d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( + d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_shading_rate_image === + + // wrapper function for command vkCmdBindShadingRateImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindShadingRateImageNV( + static_cast( m_commandBuffer ), static_cast( imageView ), static_cast( imageLayout ) ); + } + + // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, + uint32_t viewportCount, + const ShadingRatePaletteNV * pShadingRatePalettes, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetViewportShadingRatePaletteNV( + static_cast( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast( pShadingRatePalettes ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, + ArrayProxy const & shadingRatePalettes, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetViewportShadingRatePaletteNV && "Function requires " ); +# endif + + d.vkCmdSetViewportShadingRatePaletteNV( + m_commandBuffer, firstViewport, shadingRatePalettes.size(), reinterpret_cast( shadingRatePalettes.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const CoarseSampleOrderCustomNV * pCustomSampleOrders, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetCoarseSampleOrderNV( static_cast( m_commandBuffer ), + static_cast( sampleOrderType ), + customSampleOrderCount, + reinterpret_cast( pCustomSampleOrders ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, + ArrayProxy const & customSampleOrders, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetCoarseSampleOrderNV && "Function requires " ); +# endif + + d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, + static_cast( sampleOrderType ), + customSampleOrders.size(), + reinterpret_cast( customSampleOrders.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_ray_tracing === + + // wrapper function for command vkCreateAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + AccelerationStructureNV * pAccelerationStructure, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateAccelerationStructureNV( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pAccelerationStructure ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createAccelerationStructureNV( + const AccelerationStructureCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureNV && "Function requires " ); +# endif + + AccelerationStructureNV accelerationStructure; + Result result = static_cast( d.vkCreateAccelerationStructureNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &accelerationStructure ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" ); + + return detail::createResultValueType( result, std::move( accelerationStructure ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureNV && "Function requires " ); +# endif + + AccelerationStructureNV accelerationStructure; + Result result = static_cast( d.vkCreateAccelerationStructureNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &accelerationStructure ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNVUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( accelerationStructure, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyAccelerationStructureNV( static_cast( m_device ), + static_cast( accelerationStructure ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureNV && "Function requires " ); +# endif + + d.vkDestroyAccelerationStructureNV( + m_device, static_cast( accelerationStructure ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyAccelerationStructureNV( static_cast( m_device ), + static_cast( accelerationStructure ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureNV && "Function requires " ); +# endif + + d.vkDestroyAccelerationStructureNV( + m_device, static_cast( accelerationStructure ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html + template ::type> + VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV * pInfo, + MemoryRequirements2KHR * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetAccelerationStructureMemoryRequirementsNV( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( + const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureMemoryRequirementsNV && + "Function requires " ); +# endif + + MemoryRequirements2KHR memoryRequirements; + d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureMemoryRequirementsNV && + "Function requires " ); +# endif + + StructureChain structureChain; + MemoryRequirements2KHR & memoryRequirements = structureChain.template get(); + d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindAccelerationStructureMemoryNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, + const BindAccelerationStructureMemoryInfoNV * pBindInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkBindAccelerationStructureMemoryNV( + static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindAccelerationStructureMemoryNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::bindAccelerationStructureMemoryNV( ArrayProxy const & bindInfos, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBindAccelerationStructureMemoryNV && "Function requires " ); +# endif + + Result result = static_cast( d.vkBindAccelerationStructureMemoryNV( + m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBuildAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV * pInfo, + Buffer instanceData, + DeviceSize instanceOffset, + Bool32 update, + AccelerationStructureNV dst, + AccelerationStructureNV src, + Buffer scratch, + DeviceSize scratchOffset, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBuildAccelerationStructureNV( static_cast( m_commandBuffer ), + reinterpret_cast( pInfo ), + static_cast( instanceData ), + static_cast( instanceOffset ), + static_cast( update ), + static_cast( dst ), + static_cast( src ), + static_cast( scratch ), + static_cast( scratchOffset ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, + Buffer instanceData, + DeviceSize instanceOffset, + Bool32 update, + AccelerationStructureNV dst, + AccelerationStructureNV src, + Buffer scratch, + DeviceSize scratchOffset, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructureNV && "Function requires " ); +# endif + + d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, + reinterpret_cast( &info ), + static_cast( instanceData ), + static_cast( instanceOffset ), + static_cast( update ), + static_cast( dst ), + static_cast( src ), + static_cast( scratch ), + static_cast( scratchOffset ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, + AccelerationStructureNV src, + CopyAccelerationStructureModeKHR mode, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyAccelerationStructureNV( static_cast( m_commandBuffer ), + static_cast( dst ), + static_cast( src ), + static_cast( mode ) ); + } + + // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, + DeviceSize raygenShaderBindingOffset, + Buffer missShaderBindingTableBuffer, + DeviceSize missShaderBindingOffset, + DeviceSize missShaderBindingStride, + Buffer hitShaderBindingTableBuffer, + DeviceSize hitShaderBindingOffset, + DeviceSize hitShaderBindingStride, + Buffer callableShaderBindingTableBuffer, + DeviceSize callableShaderBindingOffset, + DeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdTraceRaysNV( static_cast( m_commandBuffer ), + static_cast( raygenShaderBindingTableBuffer ), + static_cast( raygenShaderBindingOffset ), + static_cast( missShaderBindingTableBuffer ), + static_cast( missShaderBindingOffset ), + static_cast( missShaderBindingStride ), + static_cast( hitShaderBindingTableBuffer ), + static_cast( hitShaderBindingOffset ), + static_cast( hitShaderBindingStride ), + static_cast( callableShaderBindingTableBuffer ), + static_cast( callableShaderBindingOffset ), + static_cast( callableShaderBindingStride ), + width, + height, + depth ); + } + + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, + uint32_t createInfoCount, + const RayTracingPipelineCreateInfoNV * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateRayTracingPipelinesNV( static_cast( m_device ), + static_cast( pipelineCache ), + createInfoCount, + reinterpret_cast( pCreateInfos ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pPipelines ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::createRayTracingPipelineNV( PipelineCache pipelineCache, + const RayTracingPipelineCreateInfoNV & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue( result, std::move( pipeline ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines; + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::createRayTracingPipelineNVUnique( + PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNVUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue>( + result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( + Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetRayTracingShaderGroupHandlesNV( + static_cast( m_device ), static_cast( pipeline ), firstGroup, groupCount, dataSize, pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesNV && + "Function requires or " ); +# endif + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesNV( + m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" ); + + return detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getRayTracingShaderGroupHandleNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesNV && + "Function requires or " ); +# endif + + DataType data; + Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesNV( + m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetAccelerationStructureHandleNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, + size_t dataSize, + void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetAccelerationStructureHandleNV( + static_cast( m_device ), static_cast( accelerationStructure ), dataSize, pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAccelerationStructureHandleNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureHandleNV && "Function requires " ); +# endif + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( d.vkGetAccelerationStructureHandleNV( + m_device, static_cast( accelerationStructure ), data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); + + return detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetAccelerationStructureHandleNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureHandleNV && "Function requires " ); +# endif + + DataType data; + Result result = static_cast( d.vkGetAccelerationStructureHandleNV( + m_device, static_cast( accelerationStructure ), sizeof( DataType ), reinterpret_cast( &data ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, + const AccelerationStructureNV * pAccelerationStructures, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWriteAccelerationStructuresPropertiesNV( static_cast( m_commandBuffer ), + accelerationStructureCount, + reinterpret_cast( pAccelerationStructures ), + static_cast( queryType ), + static_cast( queryPool ), + firstQuery ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy const & accelerationStructures, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdWriteAccelerationStructuresPropertiesNV && + "Function requires " ); +# endif + + d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, + accelerationStructures.size(), + reinterpret_cast( accelerationStructures.data() ), + static_cast( queryType ), + static_cast( queryPool ), + firstQuery ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCompileDeferredNV( static_cast( m_device ), static_cast( pipeline ), shader ) ); + } +#else + // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCompileDeferredNV && "Function requires " ); +# endif + + Result result = static_cast( d.vkCompileDeferredNV( m_device, static_cast( pipeline ), shader ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::compileDeferredNV" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + //=== VK_KHR_maintenance3 === + + // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo * pCreateInfo, + DescriptorSetLayoutSupport * pSupport, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDescriptorSetLayoutSupportKHR( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pSupport ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupportKHR && + "Function requires or " ); +# endif + + DescriptorSetLayoutSupport support; + d.vkGetDescriptorSetLayoutSupportKHR( + m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + + return support; + } + + // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupportKHR && + "Function requires or " ); +# endif + + StructureChain structureChain; + DescriptorSetLayoutSupport & support = structureChain.template get(); + d.vkGetDescriptorSetLayoutSupportKHR( + m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_draw_indirect_count === + + // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndirectCountKHR( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawIndexedIndirectCountKHR( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + //=== VK_EXT_external_memory_host === + + // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, + const void * pHostPointer, + MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetMemoryHostPointerPropertiesEXT( static_cast( m_device ), + static_cast( handleType ), + pHostPointer, + reinterpret_cast( pMemoryHostPointerProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryHostPointerPropertiesEXT && "Function requires " ); +# endif + + MemoryHostPointerPropertiesEXT memoryHostPointerProperties; + Result result = + static_cast( d.vkGetMemoryHostPointerPropertiesEXT( m_device, + static_cast( handleType ), + pHostPointer, + reinterpret_cast( &memoryHostPointerProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); + + return detail::createResultValueType( result, std::move( memoryHostPointerProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_AMD_buffer_marker === + + // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( + PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWriteBufferMarkerAMD( static_cast( m_commandBuffer ), + static_cast( pipelineStage ), + static_cast( dstBuffer ), + static_cast( dstOffset ), + marker ); + } + + // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( + PipelineStageFlags2 stage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWriteBufferMarker2AMD( static_cast( m_commandBuffer ), + static_cast( stage ), + static_cast( dstBuffer ), + static_cast( dstOffset ), + marker ); + } + + //=== VK_EXT_calibrated_timestamps === + + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount, + TimeDomainKHR * pTimeDomains, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( + static_cast( m_physicalDevice ), pTimeDomainCount, reinterpret_cast( pTimeDomains ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT && + "Function requires or " ); +# endif + + std::vector timeDomains; + uint32_t timeDomainCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && timeDomainCount ) + { + timeDomains.resize( timeDomainCount ); + result = static_cast( + d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); + VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); + if ( timeDomainCount < timeDomains.size() ) + { + timeDomains.resize( timeDomainCount ); + } + return detail::createResultValueType( result, std::move( timeDomains ) ); + } + + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator const & timeDomainKHRAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT && + "Function requires or " ); +# endif + + std::vector timeDomains( timeDomainKHRAllocator ); + uint32_t timeDomainCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && timeDomainCount ) + { + timeDomains.resize( timeDomainCount ); + result = static_cast( + d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); + VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); + if ( timeDomainCount < timeDomains.size() ) + { + timeDomains.resize( timeDomainCount ); + } + return detail::createResultValueType( result, std::move( timeDomains ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, + const CalibratedTimestampInfoKHR * pTimestampInfos, + uint64_t * pTimestamps, + uint64_t * pMaxDeviation, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetCalibratedTimestampsEXT( static_cast( m_device ), + timestampCount, + reinterpret_cast( pTimestampInfos ), + pTimestamps, + pMaxDeviation ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type + Device::getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT && + "Function requires or " ); +# endif + + std::pair, uint64_t> data_( + std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); + std::vector & timestamps = data_.first; + uint64_t & maxDeviation = data_.second; + Result result = static_cast( d.vkGetCalibratedTimestampsEXT( + m_device, timestampInfos.size(), reinterpret_cast( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type + Device::getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos, + Uint64_tAllocator const & uint64_tAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT && + "Function requires or " ); +# endif + + std::pair, uint64_t> data_( + std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) ); + std::vector & timestamps = data_.first; + uint64_t & maxDeviation = data_.second; + Result result = static_cast( d.vkGetCalibratedTimestampsEXT( + m_device, timestampInfos.size(), reinterpret_cast( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getCalibratedTimestampEXT( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT && + "Function requires or " ); +# endif + + std::pair data_; + uint64_t & timestamp = data_.first; + uint64_t & maxDeviation = data_.second; + Result result = static_cast( + d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast( ×tampInfo ), ×tamp, &maxDeviation ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_mesh_shader === + + // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawMeshTasksNV( static_cast( m_commandBuffer ), taskCount, firstTask ); + } + + // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( + Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawMeshTasksIndirectNV( + static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); + } + + // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawMeshTasksIndirectCountNV( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + //=== VK_NV_scissor_exclusive === + + // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const Bool32 * pExclusiveScissorEnables, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetExclusiveScissorEnableNV( static_cast( m_commandBuffer ), + firstExclusiveScissor, + exclusiveScissorCount, + reinterpret_cast( pExclusiveScissorEnables ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, + ArrayProxy const & exclusiveScissorEnables, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetExclusiveScissorEnableNV && "Function requires " ); +# endif + + d.vkCmdSetExclusiveScissorEnableNV( + m_commandBuffer, firstExclusiveScissor, exclusiveScissorEnables.size(), reinterpret_cast( exclusiveScissorEnables.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const Rect2D * pExclusiveScissors, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetExclusiveScissorNV( + static_cast( m_commandBuffer ), firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast( pExclusiveScissors ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, + ArrayProxy const & exclusiveScissors, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetExclusiveScissorNV && "Function requires " ); +# endif + + d.vkCmdSetExclusiveScissorNV( + m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size(), reinterpret_cast( exclusiveScissors.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_device_diagnostic_checkpoints === + + // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetCheckpointNV( static_cast( m_commandBuffer ), pCheckpointMarker ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetCheckpointNV && "Function requires " ); +# endif + + d.vkCmdSetCheckpointNV( m_commandBuffer, reinterpret_cast( &checkpointMarker ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html + template ::type> + VULKAN_HPP_INLINE void + Queue::getCheckpointDataNV( uint32_t * pCheckpointDataCount, CheckpointDataNV * pCheckpointData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetQueueCheckpointDataNV( static_cast( m_queue ), pCheckpointDataCount, reinterpret_cast( pCheckpointData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Queue::getCheckpointDataNV( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointDataNV && "Function requires " ); +# endif + + std::vector checkpointData; + uint32_t checkpointDataCount; + d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); + checkpointData.resize( checkpointDataCount ); + d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); + + VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); + if ( checkpointDataCount < checkpointData.size() ) + { + checkpointData.resize( checkpointDataCount ); + } + return checkpointData; + } + + // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Queue::getCheckpointDataNV( CheckpointDataNVAllocator const & checkpointDataNVAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointDataNV && "Function requires " ); +# endif + + std::vector checkpointData( checkpointDataNVAllocator ); + uint32_t checkpointDataCount; + d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); + checkpointData.resize( checkpointDataCount ); + d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); + + VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); + if ( checkpointDataCount < checkpointData.size() ) + { + checkpointData.resize( checkpointDataCount ); + } + return checkpointData; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html + template ::type> + VULKAN_HPP_INLINE void + Queue::getCheckpointData2NV( uint32_t * pCheckpointDataCount, CheckpointData2NV * pCheckpointData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetQueueCheckpointData2NV( static_cast( m_queue ), pCheckpointDataCount, reinterpret_cast( pCheckpointData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Queue::getCheckpointData2NV( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointData2NV && "Function requires " ); +# endif + + std::vector checkpointData; + uint32_t checkpointDataCount; + d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr ); + checkpointData.resize( checkpointDataCount ); + d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); + + VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); + if ( checkpointDataCount < checkpointData.size() ) + { + checkpointData.resize( checkpointDataCount ); + } + return checkpointData; + } + + // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Queue::getCheckpointData2NV( CheckpointData2NVAllocator const & checkpointData2NVAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointData2NV && "Function requires " ); +# endif + + std::vector checkpointData( checkpointData2NVAllocator ); + uint32_t checkpointDataCount; + d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr ); + checkpointData.resize( checkpointDataCount ); + d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); + + VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); + if ( checkpointDataCount < checkpointData.size() ) + { + checkpointData.resize( checkpointDataCount ); + } + return checkpointData; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_timeline_semaphore === + + // wrapper function for command vkGetSemaphoreCounterValueKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValueKHR( Semaphore semaphore, + uint64_t * pValue, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetSemaphoreCounterValueKHR( static_cast( m_device ), static_cast( semaphore ), pValue ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSemaphoreCounterValueKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getSemaphoreCounterValueKHR( Semaphore semaphore, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSemaphoreCounterValueKHR && "Function requires or " ); +# endif + + uint64_t value; + Result result = static_cast( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast( semaphore ), &value ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValueKHR" ); + + return detail::createResultValueType( result, std::move( value ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo * pWaitInfo, + uint64_t timeout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkWaitSemaphoresKHR( static_cast( m_device ), reinterpret_cast( pWaitInfo ), timeout ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkWaitSemaphoresKHR && "Function requires or " ); +# endif + + Result result = static_cast( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast( &waitInfo ), timeout ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR", { Result::eSuccess, Result::eTimeout } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphoreKHR( const SemaphoreSignalInfo * pSignalInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkSignalSemaphoreKHR( static_cast( m_device ), reinterpret_cast( pSignalInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSignalSemaphoreKHR && "Function requires or " ); +# endif + + Result result = static_cast( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast( &signalInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_present_timing === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, + uint32_t size, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkSetSwapchainPresentTimingQueueSizeEXT( static_cast( m_device ), static_cast( swapchain ), size ) ); + } +#else + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, uint32_t size, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetSwapchainPresentTimingQueueSizeEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkSetSwapchainPresentTimingQueueSizeEXT( m_device, static_cast( swapchain ), size ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setSwapchainPresentTimingQueueSizeEXT", { Result::eSuccess, Result::eNotReady } ); + + return static_cast( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, + SwapchainTimingPropertiesEXT * pSwapchainTimingProperties, + uint64_t * pSwapchainTimingPropertiesCounter, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetSwapchainTimingPropertiesEXT( static_cast( m_device ), + static_cast( swapchain ), + reinterpret_cast( pSwapchainTimingProperties ), + pSwapchainTimingPropertiesCounter ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSwapchainTimingPropertiesEXT && "Function requires " ); +# endif + + std::pair data_; + SwapchainTimingPropertiesEXT & swapchainTimingProperties = data_.first; + uint64_t & swapchainTimingPropertiesCounter = data_.second; + Result result = static_cast( d.vkGetSwapchainTimingPropertiesEXT( m_device, + static_cast( swapchain ), + reinterpret_cast( &swapchainTimingProperties ), + &swapchainTimingPropertiesCounter ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainTimingPropertiesEXT", { Result::eSuccess, Result::eNotReady } ); + + return ResultValue>( result, std::move( data_ ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainTimeDomainPropertiesEXT( SwapchainKHR swapchain, + SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, + uint64_t * pTimeDomainsCounter, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetSwapchainTimeDomainPropertiesEXT( static_cast( m_device ), + static_cast( swapchain ), + reinterpret_cast( pSwapchainTimeDomainProperties ), + pTimeDomainsCounter ) ); + } + + // wrapper function for command vkGetPastPresentationTimingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, + PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPastPresentationTimingEXT( static_cast( m_device ), + reinterpret_cast( pPastPresentationTimingInfo ), + reinterpret_cast( pPastPresentationTimingProperties ) ) ); + } + + //=== VK_INTEL_performance_query === + + // wrapper function for command vkInitializePerformanceApiINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL * pInitializeInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkInitializePerformanceApiINTEL( static_cast( m_device ), + reinterpret_cast( pInitializeInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkInitializePerformanceApiINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkInitializePerformanceApiINTEL && "Function requires " ); +# endif + + Result result = + static_cast( d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast( &initializeInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUninitializePerformanceApiINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html + template ::type> + VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkUninitializePerformanceApiINTEL( static_cast( m_device ) ); + } + + // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL * pMarkerInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCmdSetPerformanceMarkerINTEL( static_cast( m_commandBuffer ), + reinterpret_cast( pMarkerInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceMarkerINTEL && "Function requires " ); +# endif + + Result result = + static_cast( d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast( &markerInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL * pMarkerInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCmdSetPerformanceStreamMarkerINTEL( static_cast( m_commandBuffer ), + reinterpret_cast( pMarkerInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceStreamMarkerINTEL && "Function requires " ); +# endif + + Result result = static_cast( + d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast( &markerInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL * pOverrideInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCmdSetPerformanceOverrideINTEL( static_cast( m_commandBuffer ), + reinterpret_cast( pOverrideInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceOverrideINTEL && "Function requires " ); +# endif + + Result result = + static_cast( d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast( &overrideInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, + PerformanceConfigurationINTEL * pConfiguration, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkAcquirePerformanceConfigurationINTEL( static_cast( m_device ), + reinterpret_cast( pAcquireInfo ), + reinterpret_cast( pConfiguration ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAcquirePerformanceConfigurationINTEL && "Function requires " ); +# endif + + PerformanceConfigurationINTEL configuration; + Result result = + static_cast( d.vkAcquirePerformanceConfigurationINTEL( m_device, + reinterpret_cast( &acquireInfo ), + reinterpret_cast( &configuration ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" ); + + return detail::createResultValueType( result, std::move( configuration ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAcquirePerformanceConfigurationINTEL && "Function requires " ); +# endif + + PerformanceConfigurationINTEL configuration; + Result result = + static_cast( d.vkAcquirePerformanceConfigurationINTEL( m_device, + reinterpret_cast( &acquireInfo ), + reinterpret_cast( &configuration ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTELUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( configuration, detail::ObjectRelease( *this, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleasePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkReleasePerformanceConfigurationINTEL( static_cast( m_device ), static_cast( configuration ) ) ); + } +#else + // wrapper function for command vkReleasePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkReleasePerformanceConfigurationINTEL && "Function requires " ); +# endif + + Result result = static_cast( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast( configuration ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releasePerformanceConfigurationINTEL" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleasePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::release( PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkReleasePerformanceConfigurationINTEL( static_cast( m_device ), static_cast( configuration ) ) ); + } +#else + // wrapper function for command vkReleasePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::release( PerformanceConfigurationINTEL configuration, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkReleasePerformanceConfigurationINTEL && "Function requires " ); +# endif + + Result result = static_cast( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast( configuration ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::release" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkQueueSetPerformanceConfigurationINTEL( static_cast( m_queue ), static_cast( configuration ) ) ); + } +#else + // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkQueueSetPerformanceConfigurationINTEL && + "Function requires " ); +# endif + + Result result = static_cast( d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast( configuration ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetPerformanceParameterINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, + PerformanceValueINTEL * pValue, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPerformanceParameterINTEL( + static_cast( m_device ), static_cast( parameter ), reinterpret_cast( pValue ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPerformanceParameterINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPerformanceParameterINTEL && "Function requires " ); +# endif + + PerformanceValueINTEL value; + Result result = static_cast( d.vkGetPerformanceParameterINTEL( + m_device, static_cast( parameter ), reinterpret_cast( &value ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); + + return detail::createResultValueType( result, std::move( value ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_AMD_display_native_hdr === + + // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html + template ::type> + VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkSetLocalDimmingAMD( static_cast( m_device ), static_cast( swapChain ), static_cast( localDimmingEnable ) ); + } + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateImagePipeSurfaceFUCHSIA( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createImagePipeSurfaceFUCHSIA( + const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateImagePipeSurfaceFUCHSIA && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createImagePipeSurfaceFUCHSIAUnique( + const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateImagePipeSurfaceFUCHSIA && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIAUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateMetalSurfaceEXT( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateMetalSurfaceEXT && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateMetalSurfaceEXT( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createMetalSurfaceEXTUnique( + const MetalSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateMetalSurfaceEXT && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateMetalSurfaceEXT( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXTUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + + // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount, + PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceFragmentShadingRatesKHR( static_cast( m_physicalDevice ), + pFragmentShadingRateCount, + reinterpret_cast( pFragmentShadingRates ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html + template < + typename PhysicalDeviceFragmentShadingRateKHRAllocator, + typename Dispatch, + typename std::enable_if::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getFragmentShadingRatesKHR( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFragmentShadingRatesKHR && + "Function requires " ); +# endif + + std::vector fragmentShadingRates; + uint32_t fragmentShadingRateCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && fragmentShadingRateCount ) + { + fragmentShadingRates.resize( fragmentShadingRateCount ); + result = static_cast( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( + m_physicalDevice, &fragmentShadingRateCount, reinterpret_cast( fragmentShadingRates.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); + VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); + if ( fragmentShadingRateCount < fragmentShadingRates.size() ) + { + fragmentShadingRates.resize( fragmentShadingRateCount ); + } + return detail::createResultValueType( result, std::move( fragmentShadingRates ) ); + } + + // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html + template < + typename PhysicalDeviceFragmentShadingRateKHRAllocator, + typename Dispatch, + typename std::enable_if::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator const & physicalDeviceFragmentShadingRateKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFragmentShadingRatesKHR && + "Function requires " ); +# endif + + std::vector fragmentShadingRates( + physicalDeviceFragmentShadingRateKHRAllocator ); + uint32_t fragmentShadingRateCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && fragmentShadingRateCount ) + { + fragmentShadingRates.resize( fragmentShadingRateCount ); + result = static_cast( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( + m_physicalDevice, &fragmentShadingRateCount, reinterpret_cast( fragmentShadingRates.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); + VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); + if ( fragmentShadingRateCount < fragmentShadingRates.size() ) + { + fragmentShadingRates.resize( fragmentShadingRateCount ); + } + return detail::createResultValueType( result, std::move( fragmentShadingRates ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetFragmentShadingRateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( const Extent2D * pFragmentSize, + const FragmentShadingRateCombinerOpKHR combinerOps[2], + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetFragmentShadingRateKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pFragmentSize ), + reinterpret_cast( combinerOps ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetFragmentShadingRateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( const Extent2D & fragmentSize, + const FragmentShadingRateCombinerOpKHR combinerOps[2], + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetFragmentShadingRateKHR && "Function requires " ); +# endif + + d.vkCmdSetFragmentShadingRateKHR( + m_commandBuffer, reinterpret_cast( &fragmentSize ), reinterpret_cast( combinerOps ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_dynamic_rendering_local_read === + + // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo * pLocationInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetRenderingAttachmentLocationsKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pLocationInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo & locationInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetRenderingAttachmentLocationsKHR && + "Function requires or " ); +# endif + + d.vkCmdSetRenderingAttachmentLocationsKHR( m_commandBuffer, reinterpret_cast( &locationInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetRenderingInputAttachmentIndicesKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pInputAttachmentIndexInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetRenderingInputAttachmentIndicesKHR && + "Function requires or " ); +# endif + + d.vkCmdSetRenderingInputAttachmentIndicesKHR( m_commandBuffer, reinterpret_cast( &inputAttachmentIndexInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_buffer_device_address === + + // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html + template ::type> + VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetBufferDeviceAddressEXT( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html + template ::type> + VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddressEXT && + "Function requires or or " ); +# endif + + VkDeviceAddress result = d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast( &info ) ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_tooling_info === + + // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getToolPropertiesEXT( uint32_t * pToolCount, + PhysicalDeviceToolProperties * pToolProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceToolPropertiesEXT( + static_cast( m_physicalDevice ), pToolCount, reinterpret_cast( pToolProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getToolPropertiesEXT( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolPropertiesEXT && + "Function requires or " ); +# endif + + std::vector toolProperties; + uint32_t toolCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && toolCount ) + { + toolProperties.resize( toolCount ); + result = static_cast( + d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, reinterpret_cast( toolProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); + VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); + if ( toolCount < toolProperties.size() ) + { + toolProperties.resize( toolCount ); + } + return detail::createResultValueType( result, std::move( toolProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator const & physicalDeviceToolPropertiesAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolPropertiesEXT && + "Function requires or " ); +# endif + + std::vector toolProperties( physicalDeviceToolPropertiesAllocator ); + uint32_t toolCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && toolCount ) + { + toolProperties.resize( toolCount ); + result = static_cast( + d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, reinterpret_cast( toolProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); + VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); + if ( toolCount < toolProperties.size() ) + { + toolProperties.resize( toolCount ); + } + return detail::createResultValueType( result, std::move( toolProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_present_wait === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::waitForPresentKHR( SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkWaitForPresentKHR( static_cast( m_device ), static_cast( swapchain ), presentId, timeout ) ); + } +#else + // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::waitForPresentKHR( SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkWaitForPresentKHR && "Function requires " ); +# endif + + Result result = static_cast( d.vkWaitForPresentKHR( m_device, static_cast( swapchain ), presentId, timeout ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR", + { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR", { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR } ); +# endif + + return static_cast( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + //=== VK_NV_cooperative_matrix === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount, + CooperativeMatrixPropertiesNV * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( + static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCooperativeMatrixPropertiesNV( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV && + "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator const & cooperativeMatrixPropertiesNVAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV && + "Function requires " ); +# endif + + std::vector properties( cooperativeMatrixPropertiesNVAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_coverage_reduction_mode === + + // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( + uint32_t * pCombinationCount, FramebufferMixedSamplesCombinationNV * pCombinations, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + static_cast( m_physicalDevice ), pCombinationCount, reinterpret_cast( pCombinations ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html + template < + typename FramebufferMixedSamplesCombinationNVAllocator, + typename Dispatch, + typename std::enable_if::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV && + "Function requires " ); +# endif + + std::vector combinations; + uint32_t combinationCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && combinationCount ) + { + combinations.resize( combinationCount ); + result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + m_physicalDevice, &combinationCount, reinterpret_cast( combinations.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); + VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); + if ( combinationCount < combinations.size() ) + { + combinations.resize( combinationCount ); + } + return detail::createResultValueType( result, std::move( combinations ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html + template < + typename FramebufferMixedSamplesCombinationNVAllocator, + typename Dispatch, + typename std::enable_if::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( + FramebufferMixedSamplesCombinationNVAllocator const & framebufferMixedSamplesCombinationNVAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV && + "Function requires " ); +# endif + + std::vector combinations( + framebufferMixedSamplesCombinationNVAllocator ); + uint32_t combinationCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && combinationCount ) + { + combinations.resize( combinationCount ); + result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + m_physicalDevice, &combinationCount, reinterpret_cast( combinations.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); + VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); + if ( combinationCount < combinations.size() ) + { + combinations.resize( combinationCount ); + } + return detail::createResultValueType( result, std::move( combinations ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + uint32_t * pPresentModeCount, + PresentModeKHR * pPresentModes, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast( m_physicalDevice ), + reinterpret_cast( pSurfaceInfo ), + pPresentModeCount, + reinterpret_cast( pPresentModes ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModes2EXT && + "Function requires " ); +# endif + + std::vector presentModes; + uint32_t presentModeCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( + m_physicalDevice, reinterpret_cast( &surfaceInfo ), &presentModeCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentModeCount ) + { + presentModes.resize( presentModeCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, + reinterpret_cast( &surfaceInfo ), + &presentModeCount, + reinterpret_cast( presentModes.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" ); + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + if ( presentModeCount < presentModes.size() ) + { + presentModes.resize( presentModeCount ); + } + return detail::createResultValueType( result, std::move( presentModes ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, + PresentModeKHRAllocator const & presentModeKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModes2EXT && + "Function requires " ); +# endif + + std::vector presentModes( presentModeKHRAllocator ); + uint32_t presentModeCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( + m_physicalDevice, reinterpret_cast( &surfaceInfo ), &presentModeCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentModeCount ) + { + presentModes.resize( presentModeCount ); + result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, + reinterpret_cast( &surfaceInfo ), + &presentModeCount, + reinterpret_cast( presentModes.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" ); + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + if ( presentModeCount < presentModes.size() ) + { + presentModes.resize( presentModeCount ); + } + return detail::createResultValueType( result, std::move( presentModes ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkAcquireFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( swapchain ) ) ); + } +# else + // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAcquireFullScreenExclusiveModeEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireFullScreenExclusiveModeEXT" ); + + return detail::createResultValueType( result ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkReleaseFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( swapchain ) ) ); + } +# else + // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkReleaseFullScreenExclusiveModeEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseFullScreenExclusiveModeEXT" ); + + return detail::createResultValueType( result ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + DeviceGroupPresentModeFlagsKHR * pModes, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDeviceGroupSurfacePresentModes2EXT( static_cast( m_device ), + reinterpret_cast( pSurfaceInfo ), + reinterpret_cast( pModes ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceGroupSurfacePresentModes2EXT && + "Function requires " ); +# endif + + DeviceGroupPresentModeFlagsKHR modes; + Result result = static_cast( d.vkGetDeviceGroupSurfacePresentModes2EXT( + m_device, reinterpret_cast( &surfaceInfo ), reinterpret_cast( &modes ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); + + return detail::createResultValueType( result, std::move( modes ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + + // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateHeadlessSurfaceEXT( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createHeadlessSurfaceEXT( + const HeadlessSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateHeadlessSurfaceEXT && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateHeadlessSurfaceEXT( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createHeadlessSurfaceEXTUnique( + const HeadlessSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateHeadlessSurfaceEXT && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateHeadlessSurfaceEXT( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXTUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_buffer_device_address === + + // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html + template ::type> + VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetBufferDeviceAddressKHR( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html + template ::type> + VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddressKHR && + "Function requires or or " ); +# endif + + VkDeviceAddress result = d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast( &info ) ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html + template ::type> + VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return d.vkGetBufferOpaqueCaptureAddressKHR( static_cast( m_device ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html + template ::type> + VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureAddressKHR && + "Function requires or " ); +# endif + + uint64_t result = d.vkGetBufferOpaqueCaptureAddressKHR( m_device, reinterpret_cast( &info ) ); + + return result; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html + template ::type> + VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( static_cast( m_device ), + reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html + template ::type> + VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryOpaqueCaptureAddressKHR && + "Function requires or " ); +# endif + + uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( m_device, reinterpret_cast( &info ) ); + + return result; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_line_rasterization === + + // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetLineStippleEXT( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); + } + + //=== VK_EXT_host_query_reset === + + // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkResetQueryPoolEXT( static_cast( m_device ), static_cast( queryPool ), firstQuery, queryCount ); + } + + //=== VK_EXT_extended_dynamic_state === + + // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( CullModeFlags cullMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetCullModeEXT( static_cast( m_commandBuffer ), static_cast( cullMode ) ); + } + + // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( FrontFace frontFace, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetFrontFaceEXT( static_cast( m_commandBuffer ), static_cast( frontFace ) ); + } + + // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( PrimitiveTopology primitiveTopology, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetPrimitiveTopologyEXT( static_cast( m_commandBuffer ), static_cast( primitiveTopology ) ); + } + + // wrapper function for command vkCmdSetViewportWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::setViewportWithCountEXT( uint32_t viewportCount, const Viewport * pViewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetViewportWithCountEXT( static_cast( m_commandBuffer ), viewportCount, reinterpret_cast( pViewports ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewportWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( ArrayProxy const & viewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetViewportWithCountEXT && + "Function requires or or " ); +# endif + + d.vkCmdSetViewportWithCountEXT( m_commandBuffer, viewports.size(), reinterpret_cast( viewports.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( uint32_t scissorCount, const Rect2D * pScissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetScissorWithCountEXT( static_cast( m_commandBuffer ), scissorCount, reinterpret_cast( pScissors ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( ArrayProxy const & scissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetScissorWithCountEXT && + "Function requires or or " ); +# endif + + d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissors.size(), reinterpret_cast( scissors.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding, + uint32_t bindingCount, + const Buffer * pBuffers, + const DeviceSize * pOffsets, + const DeviceSize * pSizes, + const DeviceSize * pStrides, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindVertexBuffers2EXT( static_cast( m_commandBuffer ), + firstBinding, + bindingCount, + reinterpret_cast( pBuffers ), + reinterpret_cast( pOffsets ), + reinterpret_cast( pSizes ), + reinterpret_cast( pStrides ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes, + ArrayProxy const & strides, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers2EXT && + "Function requires or or " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); + VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); + VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); +# else + if ( buffers.size() != offsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); + } + if ( !sizes.empty() && buffers.size() != sizes.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" ); + } + if ( !strides.empty() && buffers.size() != strides.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdBindVertexBuffers2EXT( m_commandBuffer, + firstBinding, + buffers.size(), + reinterpret_cast( buffers.data() ), + reinterpret_cast( offsets.data() ), + reinterpret_cast( sizes.data() ), + reinterpret_cast( strides.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( Bool32 depthTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthTestEnableEXT( static_cast( m_commandBuffer ), static_cast( depthTestEnable ) ); + } + + // wrapper function for command vkCmdSetDepthWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( Bool32 depthWriteEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthWriteEnableEXT( static_cast( m_commandBuffer ), static_cast( depthWriteEnable ) ); + } + + // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( CompareOp depthCompareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthCompareOpEXT( static_cast( m_commandBuffer ), static_cast( depthCompareOp ) ); + } + + // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( Bool32 depthBoundsTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthBoundsTestEnableEXT( static_cast( m_commandBuffer ), static_cast( depthBoundsTestEnable ) ); + } + + // wrapper function for command vkCmdSetStencilTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( Bool32 stencilTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetStencilTestEnableEXT( static_cast( m_commandBuffer ), static_cast( stencilTestEnable ) ); + } + + // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( + StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetStencilOpEXT( static_cast( m_commandBuffer ), + static_cast( faceMask ), + static_cast( failOp ), + static_cast( passOp ), + static_cast( depthFailOp ), + static_cast( compareOp ) ); + } + + //=== VK_KHR_deferred_host_operations === + + // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDeferredOperationKHR( const AllocationCallbacks * pAllocator, + DeferredOperationKHR * pDeferredOperation, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDeferredOperationKHR( static_cast( m_device ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pDeferredOperation ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createDeferredOperationKHR( Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDeferredOperationKHR && "Function requires " ); +# endif + + DeferredOperationKHR deferredOperation; + Result result = static_cast( d.vkCreateDeferredOperationKHR( + m_device, reinterpret_cast( allocator.get() ), reinterpret_cast( &deferredOperation ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" ); + + return detail::createResultValueType( result, std::move( deferredOperation ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createDeferredOperationKHRUnique( Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDeferredOperationKHR && "Function requires " ); +# endif + + DeferredOperationKHR deferredOperation; + Result result = static_cast( d.vkCreateDeferredOperationKHR( + m_device, reinterpret_cast( allocator.get() ), reinterpret_cast( &deferredOperation ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHRUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( deferredOperation, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyDeferredOperationKHR( DeferredOperationKHR operation, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDeferredOperationKHR( + static_cast( m_device ), static_cast( operation ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyDeferredOperationKHR( DeferredOperationKHR operation, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDeferredOperationKHR && "Function requires " ); +# endif + + d.vkDestroyDeferredOperationKHR( + m_device, static_cast( operation ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( DeferredOperationKHR operation, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDeferredOperationKHR( + static_cast( m_device ), static_cast( operation ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( DeferredOperationKHR operation, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDeferredOperationKHR && "Function requires " ); +# endif + + d.vkDestroyDeferredOperationKHR( + m_device, static_cast( operation ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html + template ::type> + VULKAN_HPP_INLINE uint32_t Device::getDeferredOperationMaxConcurrencyKHR( DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return d.vkGetDeferredOperationMaxConcurrencyKHR( static_cast( m_device ), static_cast( operation ) ); + } + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeferredOperationResultKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( DeferredOperationKHR operation, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDeferredOperationResultKHR( static_cast( m_device ), static_cast( operation ) ) ); + } +#else + // wrapper function for command vkGetDeferredOperationResultKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( DeferredOperationKHR operation, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeferredOperationResultKHR && "Function requires " ); +# endif + + Result result = static_cast( d.vkGetDeferredOperationResultKHR( m_device, static_cast( operation ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDeferredOperationResultKHR", { Result::eSuccess, Result::eNotReady } ); + + return static_cast( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR( DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkDeferredOperationJoinKHR( static_cast( m_device ), static_cast( operation ) ) ); + } +#else + // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR( DeferredOperationKHR operation, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDeferredOperationJoinKHR && "Function requires " ); +# endif + + Result result = static_cast( d.vkDeferredOperationJoinKHR( m_device, static_cast( operation ) ) ); + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::deferredOperationJoinKHR", { Result::eSuccess, Result::eThreadDoneKHR, Result::eThreadIdleKHR } ); + + return static_cast( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + //=== VK_KHR_pipeline_executable_properties === + + // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR * pPipelineInfo, + uint32_t * pExecutableCount, + PipelineExecutablePropertiesKHR * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPipelineExecutablePropertiesKHR( static_cast( m_device ), + reinterpret_cast( pPipelineInfo ), + pExecutableCount, + reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html + template < + typename PipelineExecutablePropertiesKHRAllocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineExecutablePropertiesKHR && + "Function requires " ); +# endif + + std::vector properties; + uint32_t executableCount; + Result result; + do + { + result = static_cast( + d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast( &pipelineInfo ), &executableCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && executableCount ) + { + properties.resize( executableCount ); + result = static_cast( d.vkGetPipelineExecutablePropertiesKHR( m_device, + reinterpret_cast( &pipelineInfo ), + &executableCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); + VULKAN_HPP_ASSERT( executableCount <= properties.size() ); + if ( executableCount < properties.size() ) + { + properties.resize( executableCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html + template < + typename PipelineExecutablePropertiesKHRAllocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, + PipelineExecutablePropertiesKHRAllocator const & pipelineExecutablePropertiesKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineExecutablePropertiesKHR && + "Function requires " ); +# endif + + std::vector properties( pipelineExecutablePropertiesKHRAllocator ); + uint32_t executableCount; + Result result; + do + { + result = static_cast( + d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast( &pipelineInfo ), &executableCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && executableCount ) + { + properties.resize( executableCount ); + result = static_cast( d.vkGetPipelineExecutablePropertiesKHR( m_device, + reinterpret_cast( &pipelineInfo ), + &executableCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); + VULKAN_HPP_ASSERT( executableCount <= properties.size() ); + if ( executableCount < properties.size() ) + { + properties.resize( executableCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR * pExecutableInfo, + uint32_t * pStatisticCount, + PipelineExecutableStatisticKHR * pStatistics, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPipelineExecutableStatisticsKHR( static_cast( m_device ), + reinterpret_cast( pExecutableInfo ), + pStatisticCount, + reinterpret_cast( pStatistics ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html + template < + typename PipelineExecutableStatisticKHRAllocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableStatisticsKHR && + "Function requires " ); +# endif + + std::vector statistics; + uint32_t statisticCount; + Result result; + do + { + result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( + m_device, reinterpret_cast( &executableInfo ), &statisticCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && statisticCount ) + { + statistics.resize( statisticCount ); + result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( m_device, + reinterpret_cast( &executableInfo ), + &statisticCount, + reinterpret_cast( statistics.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); + VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); + if ( statisticCount < statistics.size() ) + { + statistics.resize( statisticCount ); + } + return detail::createResultValueType( result, std::move( statistics ) ); + } + + // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html + template < + typename PipelineExecutableStatisticKHRAllocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, + PipelineExecutableStatisticKHRAllocator const & pipelineExecutableStatisticKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableStatisticsKHR && + "Function requires " ); +# endif + + std::vector statistics( pipelineExecutableStatisticKHRAllocator ); + uint32_t statisticCount; + Result result; + do + { + result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( + m_device, reinterpret_cast( &executableInfo ), &statisticCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && statisticCount ) + { + statistics.resize( statisticCount ); + result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( m_device, + reinterpret_cast( &executableInfo ), + &statisticCount, + reinterpret_cast( statistics.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); + VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); + if ( statisticCount < statistics.size() ) + { + statistics.resize( statisticCount ); + } + return detail::createResultValueType( result, std::move( statistics ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR * pExecutableInfo, + uint32_t * pInternalRepresentationCount, + PipelineExecutableInternalRepresentationKHR * pInternalRepresentations, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPipelineExecutableInternalRepresentationsKHR( static_cast( m_device ), + reinterpret_cast( pExecutableInfo ), + pInternalRepresentationCount, + reinterpret_cast( pInternalRepresentations ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html + template ::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableInternalRepresentationsKHR && + "Function requires " ); +# endif + + std::vector internalRepresentations; + uint32_t internalRepresentationCount; + Result result; + do + { + result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( + m_device, reinterpret_cast( &executableInfo ), &internalRepresentationCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && internalRepresentationCount ) + { + internalRepresentations.resize( internalRepresentationCount ); + result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( + m_device, + reinterpret_cast( &executableInfo ), + &internalRepresentationCount, + reinterpret_cast( internalRepresentations.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); + VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); + if ( internalRepresentationCount < internalRepresentations.size() ) + { + internalRepresentations.resize( internalRepresentationCount ); + } + return detail::createResultValueType( result, std::move( internalRepresentations ) ); + } + + // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html + template ::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + Device::getPipelineExecutableInternalRepresentationsKHR( + const PipelineExecutableInfoKHR & executableInfo, + PipelineExecutableInternalRepresentationKHRAllocator const & pipelineExecutableInternalRepresentationKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableInternalRepresentationsKHR && + "Function requires " ); +# endif + + std::vector internalRepresentations( + pipelineExecutableInternalRepresentationKHRAllocator ); + uint32_t internalRepresentationCount; + Result result; + do + { + result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( + m_device, reinterpret_cast( &executableInfo ), &internalRepresentationCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && internalRepresentationCount ) + { + internalRepresentations.resize( internalRepresentationCount ); + result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( + m_device, + reinterpret_cast( &executableInfo ), + &internalRepresentationCount, + reinterpret_cast( internalRepresentations.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); + VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); + if ( internalRepresentationCount < internalRepresentations.size() ) + { + internalRepresentations.resize( internalRepresentationCount ); + } + return detail::createResultValueType( result, std::move( internalRepresentations ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_host_image_copy === + + // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToImageEXT( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkCopyMemoryToImageEXT( static_cast( m_device ), reinterpret_cast( pCopyMemoryToImageInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::copyMemoryToImageEXT( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyMemoryToImageEXT && "Function requires or " ); +# endif + + Result result = static_cast( d.vkCopyMemoryToImageEXT( m_device, reinterpret_cast( ©MemoryToImageInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToImageEXT" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToMemoryEXT( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkCopyImageToMemoryEXT( static_cast( m_device ), reinterpret_cast( pCopyImageToMemoryInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::copyImageToMemoryEXT( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyImageToMemoryEXT && "Function requires or " ); +# endif + + Result result = static_cast( d.vkCopyImageToMemoryEXT( m_device, reinterpret_cast( ©ImageToMemoryInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToMemoryEXT" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToImageEXT( const CopyImageToImageInfo * pCopyImageToImageInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkCopyImageToImageEXT( static_cast( m_device ), reinterpret_cast( pCopyImageToImageInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::copyImageToImageEXT( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyImageToImageEXT && "Function requires or " ); +# endif + + Result result = static_cast( d.vkCopyImageToImageEXT( m_device, reinterpret_cast( ©ImageToImageInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToImageEXT" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::transitionImageLayoutEXT( uint32_t transitionCount, + const HostImageLayoutTransitionInfo * pTransitions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkTransitionImageLayoutEXT( + static_cast( m_device ), transitionCount, reinterpret_cast( pTransitions ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::transitionImageLayoutEXT( ArrayProxy const & transitions, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkTransitionImageLayoutEXT && "Function requires or " ); +# endif + + Result result = static_cast( + d.vkTransitionImageLayoutEXT( m_device, transitions.size(), reinterpret_cast( transitions.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::transitionImageLayoutEXT" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSubresourceLayout2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageSubresourceLayout2EXT( Image image, + const ImageSubresource2 * pSubresource, + SubresourceLayout2 * pLayout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetImageSubresourceLayout2EXT( static_cast( m_device ), + static_cast( image ), + reinterpret_cast( pSubresource ), + reinterpret_cast( pLayout ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSubresourceLayout2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout2EXT( Image image, + const ImageSubresource2 & subresource, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( + d.vkGetImageSubresourceLayout2EXT && + "Function requires or or or " ); +# endif + + SubresourceLayout2 layout; + d.vkGetImageSubresourceLayout2EXT( m_device, + static_cast( image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return layout; + } + + // wrapper function for command vkGetImageSubresourceLayout2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getImageSubresourceLayout2EXT( Image image, const ImageSubresource2 & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( + d.vkGetImageSubresourceLayout2EXT && + "Function requires or or or " ); +# endif + + StructureChain structureChain; + SubresourceLayout2 & layout = structureChain.template get(); + d.vkGetImageSubresourceLayout2EXT( m_device, + static_cast( image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_map_memory2 === + + // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory2KHR( const MemoryMapInfo * pMemoryMapInfo, + void ** ppData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkMapMemory2KHR( static_cast( m_device ), reinterpret_cast( pMemoryMapInfo ), ppData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::mapMemory2KHR( const MemoryMapInfo & memoryMapInfo, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkMapMemory2KHR && "Function requires or " ); +# endif + + void * pData; + Result result = static_cast( d.vkMapMemory2KHR( m_device, reinterpret_cast( &memoryMapInfo ), &pData ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2KHR" ); + + return detail::createResultValueType( result, std::move( pData ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::unmapMemory2KHR( const MemoryUnmapInfo * pMemoryUnmapInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkUnmapMemory2KHR( static_cast( m_device ), reinterpret_cast( pMemoryUnmapInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkUnmapMemory2KHR && "Function requires or " ); +# endif + + Result result = static_cast( d.vkUnmapMemory2KHR( m_device, reinterpret_cast( &memoryUnmapInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::unmapMemory2KHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_swapchain_maintenance1 === + + // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkReleaseSwapchainImagesEXT( static_cast( m_device ), reinterpret_cast( pReleaseInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkReleaseSwapchainImagesEXT && + "Function requires or " ); +# endif + + Result result = static_cast( d.vkReleaseSwapchainImagesEXT( m_device, reinterpret_cast( &releaseInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseSwapchainImagesEXT" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_device_generated_commands === + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html + template ::type> + VULKAN_HPP_INLINE void Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetGeneratedCommandsMemoryRequirementsNV( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsNV && + "Function requires " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsNV && + "Function requires " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV * pGeneratedCommandsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPreprocessGeneratedCommandsNV( static_cast( m_commandBuffer ), + reinterpret_cast( pGeneratedCommandsInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPreprocessGeneratedCommandsNV && "Function requires " ); +# endif + + d.vkCmdPreprocessGeneratedCommandsNV( m_commandBuffer, reinterpret_cast( &generatedCommandsInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( Bool32 isPreprocessed, + const GeneratedCommandsInfoNV * pGeneratedCommandsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdExecuteGeneratedCommandsNV( static_cast( m_commandBuffer ), + static_cast( isPreprocessed ), + reinterpret_cast( pGeneratedCommandsInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( Bool32 isPreprocessed, + const GeneratedCommandsInfoNV & generatedCommandsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdExecuteGeneratedCommandsNV && "Function requires " ); +# endif + + d.vkCmdExecuteGeneratedCommandsNV( + m_commandBuffer, static_cast( isPreprocessed ), reinterpret_cast( &generatedCommandsInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindPipelineShaderGroupNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindPipelineShaderGroupNV( PipelineBindPoint pipelineBindPoint, + Pipeline pipeline, + uint32_t groupIndex, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindPipelineShaderGroupNV( + static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( pipeline ), groupIndex ); + } + + // wrapper function for command vkCreateIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + IndirectCommandsLayoutNV * pIndirectCommandsLayout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateIndirectCommandsLayoutNV( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pIndirectCommandsLayout ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createIndirectCommandsLayoutNV( + const IndirectCommandsLayoutCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutNV && "Function requires " ); +# endif + + IndirectCommandsLayoutNV indirectCommandsLayout; + Result result = static_cast( d.vkCreateIndirectCommandsLayoutNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &indirectCommandsLayout ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" ); + + return detail::createResultValueType( result, std::move( indirectCommandsLayout ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutNV && "Function requires " ); +# endif + + IndirectCommandsLayoutNV indirectCommandsLayout; + Result result = static_cast( d.vkCreateIndirectCommandsLayoutNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &indirectCommandsLayout ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNVUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( indirectCommandsLayout, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyIndirectCommandsLayoutNV( static_cast( m_device ), + static_cast( indirectCommandsLayout ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutNV && "Function requires " ); +# endif + + d.vkDestroyIndirectCommandsLayoutNV( + m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( IndirectCommandsLayoutNV indirectCommandsLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyIndirectCommandsLayoutNV( static_cast( m_device ), + static_cast( indirectCommandsLayout ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNV indirectCommandsLayout, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutNV && "Function requires " ); +# endif + + d.vkDestroyIndirectCommandsLayoutNV( + m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_depth_bias_control === + + // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const DepthBiasInfoEXT * pDepthBiasInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthBias2EXT( static_cast( m_commandBuffer ), reinterpret_cast( pDepthBiasInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const DepthBiasInfoEXT & depthBiasInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetDepthBias2EXT && "Function requires " ); +# endif + + d.vkCmdSetDepthBias2EXT( m_commandBuffer, reinterpret_cast( &depthBiasInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_acquire_drm_display === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, + DisplayKHR display, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkAcquireDrmDisplayEXT( static_cast( m_physicalDevice ), drmFd, static_cast( display ) ) ); + } +#else + // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, DisplayKHR display, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAcquireDrmDisplayEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkAcquireDrmDisplayEXT( m_physicalDevice, drmFd, static_cast( display ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, DisplayKHR * display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetDrmDisplayEXT( static_cast( m_physicalDevice ), drmFd, connectorId, reinterpret_cast( display ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDrmDisplayEXT && "Function requires " ); +# endif + + DisplayKHR display; + Result result = static_cast( d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast( &display ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXT" ); + + return detail::createResultValueType( result, std::move( display ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDrmDisplayEXT && "Function requires " ); +# endif + + DisplayKHR display; + Result result = static_cast( d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast( &display ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXTUnique" ); + + return detail::createResultValueType( result, UniqueHandle( display, detail::ObjectRelease( *this, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_private_data === + + // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + PrivateDataSlot * pPrivateDataSlot, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreatePrivateDataSlotEXT( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pPrivateDataSlot ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlotEXT && "Function requires or " ); +# endif + + PrivateDataSlot privateDataSlot; + Result result = static_cast( d.vkCreatePrivateDataSlotEXT( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &privateDataSlot ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" ); + + return detail::createResultValueType( result, std::move( privateDataSlot ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::createPrivateDataSlotEXTUnique( + const PrivateDataSlotCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlotEXT && "Function requires or " ); +# endif + + PrivateDataSlot privateDataSlot; + Result result = static_cast( d.vkCreatePrivateDataSlotEXT( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &privateDataSlot ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXTUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( privateDataSlot, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyPrivateDataSlotEXT( + static_cast( m_device ), static_cast( privateDataSlot ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlotEXT && "Function requires or " ); +# endif + + d.vkDestroyPrivateDataSlotEXT( + m_device, static_cast( privateDataSlot ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setPrivateDataEXT( + ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkSetPrivateDataEXT( + static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); + } +#else + // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::setPrivateDataEXT( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetPrivateDataEXT && "Function requires or " ); +# endif + + Result result = static_cast( + d.vkSetPrivateDataEXT( m_device, static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::getPrivateDataEXT( + ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPrivateDataEXT( + static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), pData ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t + Device::getPrivateDataEXT( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPrivateDataEXT && "Function requires or " ); +# endif + + uint64_t data; + d.vkGetPrivateDataEXT( m_device, static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), &data ); + + return data; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_video_encode_queue === + + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, + VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( pQualityLevelInfo ), + reinterpret_cast( pQualityLevelProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && + "Function requires " ); +# endif + + VideoEncodeQualityLevelPropertiesKHR qualityLevelProperties; + Result result = static_cast( + d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice, + reinterpret_cast( &qualityLevelInfo ), + reinterpret_cast( &qualityLevelProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); + + return detail::createResultValueType( result, std::move( qualityLevelProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && + "Function requires " ); +# endif + + StructureChain structureChain; + VideoEncodeQualityLevelPropertiesKHR & qualityLevelProperties = structureChain.template get(); + Result result = static_cast( + d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice, + reinterpret_cast( &qualityLevelInfo ), + reinterpret_cast( &qualityLevelProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); + + return detail::createResultValueType( result, std::move( structureChain ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, + VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, + size_t * pDataSize, + void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetEncodedVideoSessionParametersKHR( static_cast( m_device ), + reinterpret_cast( pVideoSessionParametersInfo ), + reinterpret_cast( pFeedbackInfo ), + pDataSize, + pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>>::type + Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function requires " ); +# endif + + std::pair> data_; + VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; + std::vector & data = data_.second; + size_t dataSize; + Result result; + do + { + result = static_cast( + d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( + d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>>::type + Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Uint8_tAllocator const & uint8_tAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function requires " ); +# endif + + std::pair> data_( + std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) ); + VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; + std::vector & data = data_.second; + size_t dataSize; + Result result; + do + { + result = static_cast( + d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( + d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, std::vector>>::type + Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function requires " ); +# endif + + std::pair, std::vector> data_; + VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first.template get(); + std::vector & data = data_.second; + size_t dataSize; + Result result; + do + { + result = static_cast( + d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( + d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, std::vector>>::type + Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Uint8_tAllocator const & uint8_tAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function requires " ); +# endif + + std::pair, std::vector> data_( + std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) ); + VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first.template get(); + std::vector & data = data_.second; + size_t dataSize; + Result result; + do + { + result = static_cast( + d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( + d.vkGetEncodedVideoSessionParametersKHR( m_device, + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR * pEncodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEncodeVideoKHR( static_cast( m_commandBuffer ), reinterpret_cast( pEncodeInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdEncodeVideoKHR && "Function requires " ); +# endif + + d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast( &encodeInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + + // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCudaModuleNV( const CudaModuleCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + CudaModuleNV * pModule, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateCudaModuleNV( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pModule ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createCudaModuleNV( const CudaModuleCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateCudaModuleNV && "Function requires " ); +# endif + + CudaModuleNV module; + Result result = static_cast( d.vkCreateCudaModuleNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &module ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaModuleNV" ); + + return detail::createResultValueType( result, std::move( module ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createCudaModuleNVUnique( const CudaModuleCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateCudaModuleNV && "Function requires " ); +# endif + + CudaModuleNV module; + Result result = static_cast( d.vkCreateCudaModuleNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &module ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaModuleNVUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( module, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getCudaModuleCacheNV( CudaModuleNV module, size_t * pCacheSize, void * pCacheData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetCudaModuleCacheNV( static_cast( m_device ), static_cast( module ), pCacheSize, pCacheData ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getCudaModuleCacheNV( CudaModuleNV module, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetCudaModuleCacheNV && "Function requires " ); +# endif + + std::vector cacheData; + size_t cacheSize; + Result result; + do + { + result = static_cast( d.vkGetCudaModuleCacheNV( m_device, static_cast( module ), &cacheSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && cacheSize ) + { + cacheData.resize( cacheSize ); + result = static_cast( + d.vkGetCudaModuleCacheNV( m_device, static_cast( module ), &cacheSize, reinterpret_cast( cacheData.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCudaModuleCacheNV" ); + VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() ); + if ( cacheSize < cacheData.size() ) + { + cacheData.resize( cacheSize ); + } + return detail::createResultValueType( result, std::move( cacheData ) ); + } + + // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getCudaModuleCacheNV( CudaModuleNV module, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetCudaModuleCacheNV && "Function requires " ); +# endif + + std::vector cacheData( uint8_tAllocator ); + size_t cacheSize; + Result result; + do + { + result = static_cast( d.vkGetCudaModuleCacheNV( m_device, static_cast( module ), &cacheSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && cacheSize ) + { + cacheData.resize( cacheSize ); + result = static_cast( + d.vkGetCudaModuleCacheNV( m_device, static_cast( module ), &cacheSize, reinterpret_cast( cacheData.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCudaModuleCacheNV" ); + VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() ); + if ( cacheSize < cacheData.size() ) + { + cacheData.resize( cacheSize ); + } + return detail::createResultValueType( result, std::move( cacheData ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCudaFunctionNV( const CudaFunctionCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + CudaFunctionNV * pFunction, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateCudaFunctionNV( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pFunction ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createCudaFunctionNV( const CudaFunctionCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateCudaFunctionNV && "Function requires " ); +# endif + + CudaFunctionNV function; + Result result = static_cast( d.vkCreateCudaFunctionNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &function ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaFunctionNV" ); + + return detail::createResultValueType( result, std::move( function ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createCudaFunctionNVUnique( const CudaFunctionCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateCudaFunctionNV && "Function requires " ); +# endif + + CudaFunctionNV function; + Result result = static_cast( d.vkCreateCudaFunctionNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &function ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaFunctionNVUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( function, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyCudaModuleNV( CudaModuleNV module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyCudaModuleNV( + static_cast( m_device ), static_cast( module ), reinterpret_cast( pAllocator ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyCudaModuleNV( CudaModuleNV module, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyCudaModuleNV && "Function requires " ); +# endif + + d.vkDestroyCudaModuleNV( m_device, static_cast( module ), reinterpret_cast( allocator.get() ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( CudaModuleNV module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyCudaModuleNV( + static_cast( m_device ), static_cast( module ), reinterpret_cast( pAllocator ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( CudaModuleNV module, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyCudaModuleNV && "Function requires " ); +# endif + + d.vkDestroyCudaModuleNV( m_device, static_cast( module ), reinterpret_cast( allocator.get() ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyCudaFunctionNV( CudaFunctionNV function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyCudaFunctionNV( + static_cast( m_device ), static_cast( function ), reinterpret_cast( pAllocator ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyCudaFunctionNV( CudaFunctionNV function, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyCudaFunctionNV && "Function requires " ); +# endif + + d.vkDestroyCudaFunctionNV( m_device, static_cast( function ), reinterpret_cast( allocator.get() ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( CudaFunctionNV function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyCudaFunctionNV( + static_cast( m_device ), static_cast( function ), reinterpret_cast( pAllocator ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( CudaFunctionNV function, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyCudaFunctionNV && "Function requires " ); +# endif + + d.vkDestroyCudaFunctionNV( m_device, static_cast( function ), reinterpret_cast( allocator.get() ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const CudaLaunchInfoNV * pLaunchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCudaLaunchKernelNV( static_cast( m_commandBuffer ), reinterpret_cast( pLaunchInfo ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const CudaLaunchInfoNV & launchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCudaLaunchKernelNV && "Function requires " ); +# endif + + d.vkCmdCudaLaunchKernelNV( m_commandBuffer, reinterpret_cast( &launchInfo ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + + // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchTileQCOM( const DispatchTileInfoQCOM * pDispatchTileInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDispatchTileQCOM( static_cast( m_commandBuffer ), reinterpret_cast( pDispatchTileInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchTileQCOM( const DispatchTileInfoQCOM & dispatchTileInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDispatchTileQCOM && "Function requires " ); +# endif + + d.vkCmdDispatchTileQCOM( m_commandBuffer, reinterpret_cast( &dispatchTileInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM * pPerTileBeginInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginPerTileExecutionQCOM( static_cast( m_commandBuffer ), reinterpret_cast( pPerTileBeginInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM & perTileBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginPerTileExecutionQCOM && "Function requires " ); +# endif + + d.vkCmdBeginPerTileExecutionQCOM( m_commandBuffer, reinterpret_cast( &perTileBeginInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const PerTileEndInfoQCOM * pPerTileEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndPerTileExecutionQCOM( static_cast( m_commandBuffer ), reinterpret_cast( pPerTileEndInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const PerTileEndInfoQCOM & perTileEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdEndPerTileExecutionQCOM && "Function requires " ); +# endif + + d.vkCmdEndPerTileExecutionQCOM( m_commandBuffer, reinterpret_cast( &perTileEndInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + + // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( ExportMetalObjectsInfoEXT * pMetalObjectsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkExportMetalObjectsEXT( static_cast( m_device ), reinterpret_cast( pMetalObjectsInfo ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( ExportMetalObjectsInfoEXT & metalObjectsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkExportMetalObjectsEXT && "Function requires " ); +# endif + + d.vkExportMetalObjectsEXT( m_device, reinterpret_cast( &metalObjectsInfo ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + + // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( Event event, const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetEvent2KHR( + static_cast( m_commandBuffer ), static_cast( event ), reinterpret_cast( pDependencyInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetEvent2KHR && "Function requires or " ); +# endif + + d.vkCmdSetEvent2KHR( m_commandBuffer, static_cast( event ), reinterpret_cast( &dependencyInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( Event event, PipelineStageFlags2 stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdResetEvent2KHR( static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); + } + + // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR( uint32_t eventCount, + const Event * pEvents, + const DependencyInfo * pDependencyInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWaitEvents2KHR( static_cast( m_commandBuffer ), + eventCount, + reinterpret_cast( pEvents ), + reinterpret_cast( pDependencyInfos ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR( ArrayProxy const & events, + ArrayProxy const & dependencyInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdWaitEvents2KHR && "Function requires or " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); +# else + if ( events.size() != dependencyInfos.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdWaitEvents2KHR( m_commandBuffer, + events.size(), + reinterpret_cast( events.data() ), + reinterpret_cast( dependencyInfos.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPipelineBarrier2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pDependencyInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier2KHR && "Function requires or " ); +# endif + + d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast( &dependencyInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::writeTimestamp2KHR( PipelineStageFlags2 stage, QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWriteTimestamp2KHR( + static_cast( m_commandBuffer ), static_cast( stage ), static_cast( queryPool ), query ); + } + + // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Queue::submit2KHR( uint32_t submitCount, const SubmitInfo2 * pSubmits, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkQueueSubmit2KHR( static_cast( m_queue ), submitCount, reinterpret_cast( pSubmits ), static_cast( fence ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Queue::submit2KHR( ArrayProxy const & submits, Fence fence, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkQueueSubmit2KHR && "Function requires or " ); +# endif + + Result result = static_cast( + d.vkQueueSubmit2KHR( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_descriptor_buffer === + + // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout, DeviceSize * pLayoutSizeInBytes, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDescriptorSetLayoutSizeEXT( + static_cast( m_device ), static_cast( layout ), reinterpret_cast( pLayoutSizeInBytes ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize Device::getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSizeEXT && "Function requires " ); +# endif + + DeviceSize layoutSizeInBytes; + d.vkGetDescriptorSetLayoutSizeEXT( m_device, static_cast( layout ), reinterpret_cast( &layoutSizeInBytes ) ); + + return layoutSizeInBytes; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutBindingOffsetEXT( DescriptorSetLayout layout, + uint32_t binding, + DeviceSize * pOffset, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDescriptorSetLayoutBindingOffsetEXT( + static_cast( m_device ), static_cast( layout ), binding, reinterpret_cast( pOffset ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize Device::getDescriptorSetLayoutBindingOffsetEXT( DescriptorSetLayout layout, + uint32_t binding, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutBindingOffsetEXT && + "Function requires " ); +# endif + + DeviceSize offset; + d.vkGetDescriptorSetLayoutBindingOffsetEXT( m_device, static_cast( layout ), binding, reinterpret_cast( &offset ) ); + + return offset; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::getDescriptorEXT( const DescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDescriptorEXT( static_cast( m_device ), reinterpret_cast( pDescriptorInfo ), dataSize, pDescriptor ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDescriptorEXT && "Function requires " ); +# endif + + d.vkGetDescriptorEXT( m_device, reinterpret_cast( &descriptorInfo ), dataSize, pDescriptor ); + } + + // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorType Device::getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDescriptorEXT && "Function requires " ); +# endif + + DescriptorType descriptor; + d.vkGetDescriptorEXT( + m_device, reinterpret_cast( &descriptorInfo ), sizeof( DescriptorType ), reinterpret_cast( &descriptor ) ); + + return descriptor; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindDescriptorBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBuffersEXT( uint32_t bufferCount, + const DescriptorBufferBindingInfoEXT * pBindingInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindDescriptorBuffersEXT( + static_cast( m_commandBuffer ), bufferCount, reinterpret_cast( pBindingInfos ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindDescriptorBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBuffersEXT( ArrayProxy const & bindingInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorBuffersEXT && "Function requires " ); +# endif + + d.vkCmdBindDescriptorBuffersEXT( m_commandBuffer, bindingInfos.size(), reinterpret_cast( bindingInfos.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const uint32_t * pBufferIndices, + const DeviceSize * pOffsets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDescriptorBufferOffsetsEXT( static_cast( m_commandBuffer ), + static_cast( pipelineBindPoint ), + static_cast( layout ), + firstSet, + setCount, + pBufferIndices, + reinterpret_cast( pOffsets ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t firstSet, + ArrayProxy const & bufferIndices, + ArrayProxy const & offsets, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetDescriptorBufferOffsetsEXT && "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( bufferIndices.size() == offsets.size() ); +# else + if ( bufferIndices.size() != offsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setDescriptorBufferOffsetsEXT: bufferIndices.size() != offsets.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdSetDescriptorBufferOffsetsEXT( m_commandBuffer, + static_cast( pipelineBindPoint ), + static_cast( layout ), + firstSet, + bufferIndices.size(), + bufferIndices.data(), + reinterpret_cast( offsets.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t set, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindDescriptorBufferEmbeddedSamplersEXT( + static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( layout ), set ); + } + + // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT * pInfo, + void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetBufferOpaqueCaptureDescriptorDataEXT( + static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureDescriptorDataEXT && + "Function requires " ); +# endif + + DataType data; + Result result = static_cast( + d.vkGetBufferOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferOpaqueCaptureDescriptorDataEXT" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT * pInfo, + void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetImageOpaqueCaptureDescriptorDataEXT( + static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDescriptorDataEXT && + "Function requires " ); +# endif + + DataType data; + Result result = static_cast( + d.vkGetImageOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDescriptorDataEXT" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT * pInfo, + void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetImageViewOpaqueCaptureDescriptorDataEXT( + static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetImageViewOpaqueCaptureDescriptorDataEXT && + "Function requires " ); +# endif + + DataType data; + Result result = static_cast( + d.vkGetImageViewOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewOpaqueCaptureDescriptorDataEXT" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT * pInfo, + void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetSamplerOpaqueCaptureDescriptorDataEXT( + static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSamplerOpaqueCaptureDescriptorDataEXT && + "Function requires " ); +# endif + + DataType data; + Result result = static_cast( + d.vkGetSamplerOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSamplerOpaqueCaptureDescriptorDataEXT" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT( + const AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT && + "Function requires " ); +# endif + + DataType data; + Result result = static_cast( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + m_device, reinterpret_cast( &info ), &data ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_fragment_shading_rate_enums === + + // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, + const FragmentShadingRateCombinerOpKHR combinerOps[2], + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetFragmentShadingRateEnumNV( static_cast( m_commandBuffer ), + static_cast( shadingRate ), + reinterpret_cast( combinerOps ) ); + } + + //=== VK_EXT_mesh_shader === + + // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawMeshTasksEXT( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); + } + + // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectEXT( + Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawMeshTasksIndirectEXT( + static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); + } + + // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountEXT( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawMeshTasksIndirectCountEXT( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + //=== VK_KHR_copy_commands2 === + + // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyBuffer2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pCopyBufferInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer2KHR && "Function requires or " ); +# endif + + d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast( ©BufferInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyImage2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pCopyImageInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const CopyImageInfo2 & copyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyImage2KHR && "Function requires or " ); +# endif + + d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast( ©ImageInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyBufferToImage2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( pCopyBufferToImageInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const CopyBufferToImageInfo2 & copyBufferToImageInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage2KHR && "Function requires or " ); +# endif + + d.vkCmdCopyBufferToImage2KHR( m_commandBuffer, reinterpret_cast( ©BufferToImageInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyImageToBuffer2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( pCopyImageToBufferInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const CopyImageToBufferInfo2 & copyImageToBufferInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer2KHR && "Function requires or " ); +# endif + + d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer, reinterpret_cast( ©ImageToBufferInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBlitImage2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pBlitImageInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const BlitImageInfo2 & blitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBlitImage2KHR && "Function requires or " ); +# endif + + d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast( &blitImageInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdResolveImage2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pResolveImageInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdResolveImage2KHR && "Function requires or " ); +# endif + + d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast( &resolveImageInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_device_fault === + + // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts, + DeviceFaultInfoEXT * pFaultInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDeviceFaultInfoEXT( + static_cast( m_device ), reinterpret_cast( pFaultCounts ), reinterpret_cast( pFaultInfo ) ) ); + } + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + +# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV( DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkAcquireWinrtDisplayNV( static_cast( m_physicalDevice ), static_cast( display ) ) ); + } +# else + // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::acquireWinrtDisplayNV( DisplayKHR display, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAcquireWinrtDisplayNV && "Function requires " ); +# endif + + Result result = static_cast( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast( display ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" ); + + return detail::createResultValueType( result ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, + DisplayKHR * pDisplay, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetWinrtDisplayNV( static_cast( m_physicalDevice ), deviceRelativeId, reinterpret_cast( pDisplay ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function requires " ); +# endif + + DisplayKHR display; + Result result = static_cast( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); + + return detail::createResultValueType( result, std::move( display ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function requires " ); +# endif + + DisplayKHR display; + Result result = static_cast( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique" ); + + return detail::createResultValueType( result, UniqueHandle( display, detail::ObjectRelease( *this, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDirectFBSurfaceEXT( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createDirectFBSurfaceEXT( + const DirectFBSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDirectFBSurfaceEXT && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateDirectFBSurfaceEXT( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createDirectFBSurfaceEXTUnique( + const DirectFBSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDirectFBSurfaceEXT && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateDirectFBSurfaceEXT( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXTUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html + template ::type> + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, + IDirectFB * dfb, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( static_cast( m_physicalDevice ), queueFamilyIndex, dfb ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html + template ::type> + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, + IDirectFB & dfb, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT && + "Function requires " ); +# endif + + VkBool32 result = d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, &dfb ); + + return static_cast( result ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_vertex_input_dynamic_state === + + // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( uint32_t vertexBindingDescriptionCount, + const VertexInputBindingDescription2EXT * pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetVertexInputEXT( static_cast( m_commandBuffer ), + vertexBindingDescriptionCount, + reinterpret_cast( pVertexBindingDescriptions ), + vertexAttributeDescriptionCount, + reinterpret_cast( pVertexAttributeDescriptions ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( ArrayProxy const & vertexBindingDescriptions, + ArrayProxy const & vertexAttributeDescriptions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetVertexInputEXT && "Function requires or " ); +# endif + + d.vkCmdSetVertexInputEXT( m_commandBuffer, + vertexBindingDescriptions.size(), + reinterpret_cast( vertexBindingDescriptions.data() ), + vertexAttributeDescriptions.size(), + reinterpret_cast( vertexAttributeDescriptions.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + + // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, + zx_handle_t * pZirconHandle, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetMemoryZirconHandleFUCHSIA( + static_cast( m_device ), reinterpret_cast( pGetZirconHandleInfo ), pZirconHandle ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryZirconHandleFUCHSIA && "Function requires " ); +# endif + + zx_handle_t zirconHandle; + Result result = static_cast( + d.vkGetMemoryZirconHandleFUCHSIA( m_device, reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); + + return detail::createResultValueType( result, std::move( zirconHandle ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType, + zx_handle_t zirconHandle, + MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetMemoryZirconHandlePropertiesFUCHSIA( static_cast( m_device ), + static_cast( handleType ), + zirconHandle, + reinterpret_cast( pMemoryZirconHandleProperties ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryZirconHandlePropertiesFUCHSIA && + "Function requires " ); +# endif + + MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties; + Result result = static_cast( + d.vkGetMemoryZirconHandlePropertiesFUCHSIA( m_device, + static_cast( handleType ), + zirconHandle, + reinterpret_cast( &memoryZirconHandleProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); + + return detail::createResultValueType( result, std::move( memoryZirconHandleProperties ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + + // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreZirconHandleFUCHSIA( + const ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkImportSemaphoreZirconHandleFUCHSIA( + static_cast( m_device ), reinterpret_cast( pImportSemaphoreZirconHandleInfo ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkImportSemaphoreZirconHandleFUCHSIA && "Function requires " ); +# endif + + Result result = static_cast( d.vkImportSemaphoreZirconHandleFUCHSIA( + m_device, reinterpret_cast( &importSemaphoreZirconHandleInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" ); + + return detail::createResultValueType( result ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, + zx_handle_t * pZirconHandle, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetSemaphoreZirconHandleFUCHSIA( + static_cast( m_device ), reinterpret_cast( pGetZirconHandleInfo ), pZirconHandle ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetSemaphoreZirconHandleFUCHSIA && "Function requires " ); +# endif + + zx_handle_t zirconHandle; + Result result = static_cast( + d.vkGetSemaphoreZirconHandleFUCHSIA( m_device, reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); + + return detail::createResultValueType( result, std::move( zirconHandle ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + // wrapper function for command vkCreateBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBufferCollectionFUCHSIA( const BufferCollectionCreateInfoFUCHSIA * pCreateInfo, + const AllocationCallbacks * pAllocator, + BufferCollectionFUCHSIA * pCollection, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateBufferCollectionFUCHSIA( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pCollection ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createBufferCollectionFUCHSIA( + const BufferCollectionCreateInfoFUCHSIA & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateBufferCollectionFUCHSIA && "Function requires " ); +# endif + + BufferCollectionFUCHSIA collection; + Result result = static_cast( d.vkCreateBufferCollectionFUCHSIA( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &collection ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIA" ); + + return detail::createResultValueType( result, std::move( collection ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createBufferCollectionFUCHSIAUnique( const BufferCollectionCreateInfoFUCHSIA & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateBufferCollectionFUCHSIA && "Function requires " ); +# endif + + BufferCollectionFUCHSIA collection; + Result result = static_cast( d.vkCreateBufferCollectionFUCHSIA( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &collection ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIAUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( collection, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setBufferCollectionImageConstraintsFUCHSIA( BufferCollectionFUCHSIA collection, + const ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkSetBufferCollectionImageConstraintsFUCHSIA( static_cast( m_device ), + static_cast( collection ), + reinterpret_cast( pImageConstraintsInfo ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::setBufferCollectionImageConstraintsFUCHSIA( + BufferCollectionFUCHSIA collection, const ImageConstraintsInfoFUCHSIA & imageConstraintsInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetBufferCollectionImageConstraintsFUCHSIA && + "Function requires " ); +# endif + + Result result = static_cast( d.vkSetBufferCollectionImageConstraintsFUCHSIA( + m_device, static_cast( collection ), reinterpret_cast( &imageConstraintsInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionImageConstraintsFUCHSIA" ); + + return detail::createResultValueType( result ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setBufferCollectionBufferConstraintsFUCHSIA( + BufferCollectionFUCHSIA collection, const BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkSetBufferCollectionBufferConstraintsFUCHSIA( static_cast( m_device ), + static_cast( collection ), + reinterpret_cast( pBufferConstraintsInfo ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::setBufferCollectionBufferConstraintsFUCHSIA( + BufferCollectionFUCHSIA collection, const BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetBufferCollectionBufferConstraintsFUCHSIA && + "Function requires " ); +# endif + + Result result = static_cast( d.vkSetBufferCollectionBufferConstraintsFUCHSIA( + m_device, static_cast( collection ), reinterpret_cast( &bufferConstraintsInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionBufferConstraintsFUCHSIA" ); + + return detail::createResultValueType( result ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyBufferCollectionFUCHSIA( + static_cast( m_device ), static_cast( collection ), reinterpret_cast( pAllocator ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyBufferCollectionFUCHSIA && "Function requires " ); +# endif + + d.vkDestroyBufferCollectionFUCHSIA( + m_device, static_cast( collection ), reinterpret_cast( allocator.get() ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( BufferCollectionFUCHSIA collection, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyBufferCollectionFUCHSIA( + static_cast( m_device ), static_cast( collection ), reinterpret_cast( pAllocator ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( BufferCollectionFUCHSIA collection, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyBufferCollectionFUCHSIA && "Function requires " ); +# endif + + d.vkDestroyBufferCollectionFUCHSIA( + m_device, static_cast( collection ), reinterpret_cast( allocator.get() ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection, + BufferCollectionPropertiesFUCHSIA * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetBufferCollectionPropertiesFUCHSIA( static_cast( m_device ), + static_cast( collection ), + reinterpret_cast( pProperties ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetBufferCollectionPropertiesFUCHSIA && + "Function requires " ); +# endif + + BufferCollectionPropertiesFUCHSIA properties; + Result result = static_cast( d.vkGetBufferCollectionPropertiesFUCHSIA( + m_device, static_cast( collection ), reinterpret_cast( &properties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferCollectionPropertiesFUCHSIA" ); + + return detail::createResultValueType( result, std::move( properties ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + + // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( RenderPass renderpass, + Extent2D * pMaxWorkgroupSize, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( + static_cast( m_device ), static_cast( renderpass ), reinterpret_cast( pMaxWorkgroupSize ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( RenderPass renderpass, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI && + "Function requires " ); +# endif + + Extent2D maxWorkgroupSize; + Result result = static_cast( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( + m_device, static_cast( renderpass ), reinterpret_cast( &maxWorkgroupSize ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI" ); + + return detail::createResultValueType( result, std::move( maxWorkgroupSize ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSubpassShadingHUAWEI( static_cast( m_commandBuffer ) ); + } + + //=== VK_HUAWEI_invocation_mask === + + // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI( ImageView imageView, ImageLayout imageLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindInvocationMaskHUAWEI( + static_cast( m_commandBuffer ), static_cast( imageView ), static_cast( imageLayout ) ); + } + + //=== VK_NV_external_memory_rdma === + + // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, + RemoteAddressNV * pAddress, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetMemoryRemoteAddressNV( static_cast( m_device ), + reinterpret_cast( pMemoryGetRemoteAddressInfo ), + reinterpret_cast( pAddress ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryRemoteAddressNV && "Function requires " ); +# endif + + RemoteAddressNV address; + Result result = static_cast( d.vkGetMemoryRemoteAddressNV( + m_device, reinterpret_cast( &memoryGetRemoteAddressInfo ), reinterpret_cast( &address ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); + + return detail::createResultValueType( result, std::move( address ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_pipeline_properties === + + // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelinePropertiesEXT( const PipelineInfoEXT * pPipelineInfo, + BaseOutStructure * pPipelineProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPipelinePropertiesEXT( static_cast( m_device ), + reinterpret_cast( pPipelineInfo ), + reinterpret_cast( pPipelineProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getPipelinePropertiesEXT( const PipelineInfoEXT & pipelineInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelinePropertiesEXT && "Function requires " ); +# endif + + BaseOutStructure pipelineProperties; + Result result = static_cast( d.vkGetPipelinePropertiesEXT( + m_device, reinterpret_cast( &pipelineInfo ), reinterpret_cast( &pipelineProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" ); + + return detail::createResultValueType( result, std::move( pipelineProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_extended_dynamic_state2 === + + // wrapper function for command vkCmdSetPatchControlPointsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetPatchControlPointsEXT( static_cast( m_commandBuffer ), patchControlPoints ); + } + + // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT( Bool32 rasterizerDiscardEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetRasterizerDiscardEnableEXT( static_cast( m_commandBuffer ), static_cast( rasterizerDiscardEnable ) ); + } + + // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( Bool32 depthBiasEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthBiasEnableEXT( static_cast( m_commandBuffer ), static_cast( depthBiasEnable ) ); + } + + // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( LogicOp logicOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetLogicOpEXT( static_cast( m_commandBuffer ), static_cast( logicOp ) ); + } + + // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT( Bool32 primitiveRestartEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetPrimitiveRestartEnableEXT( static_cast( m_commandBuffer ), static_cast( primitiveRestartEnable ) ); + } + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateScreenSurfaceQNX( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateScreenSurfaceQNX && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateScreenSurfaceQNX( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createScreenSurfaceQNXUnique( + const ScreenSurfaceCreateInfoQNX & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateScreenSurfaceQNX && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateScreenSurfaceQNX( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNXUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html + template ::type> + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, + struct _screen_window * window, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceScreenPresentationSupportQNX( static_cast( m_physicalDevice ), queueFamilyIndex, window ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html + template ::type> + VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, + struct _screen_window & window, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceScreenPresentationSupportQNX && + "Function requires " ); +# endif + + VkBool32 result = d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, &window ); + + return static_cast( result ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_color_write_enable === + + // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::setColorWriteEnableEXT( uint32_t attachmentCount, const Bool32 * pColorWriteEnables, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetColorWriteEnableEXT( static_cast( m_commandBuffer ), attachmentCount, reinterpret_cast( pColorWriteEnables ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( ArrayProxy const & colorWriteEnables, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetColorWriteEnableEXT && "Function requires " ); +# endif + + d.vkCmdSetColorWriteEnableEXT( m_commandBuffer, colorWriteEnables.size(), reinterpret_cast( colorWriteEnables.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_ray_tracing_maintenance1 === + + // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirect2KHR( DeviceAddress indirectDeviceAddress, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdTraceRaysIndirect2KHR( static_cast( m_commandBuffer ), static_cast( indirectDeviceAddress ) ); + } + + //=== VK_EXT_multi_draw === + + // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT( uint32_t drawCount, + const MultiDrawInfoEXT * pVertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawMultiEXT( static_cast( m_commandBuffer ), + drawCount, + reinterpret_cast( pVertexInfo ), + instanceCount, + firstInstance, + stride ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT( StridedArrayProxy const & vertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDrawMultiEXT && "Function requires " ); +# endif + + d.vkCmdDrawMultiEXT( m_commandBuffer, + vertexInfo.size(), + reinterpret_cast( vertexInfo.data() ), + instanceCount, + firstInstance, + vertexInfo.stride() ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT( uint32_t drawCount, + const MultiDrawIndexedInfoEXT * pIndexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + const int32_t * pVertexOffset, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawMultiIndexedEXT( static_cast( m_commandBuffer ), + drawCount, + reinterpret_cast( pIndexInfo ), + instanceCount, + firstInstance, + stride, + pVertexOffset ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT( StridedArrayProxy const & indexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + Optional vertexOffset, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDrawMultiIndexedEXT && "Function requires " ); +# endif + + d.vkCmdDrawMultiIndexedEXT( m_commandBuffer, + indexInfo.size(), + reinterpret_cast( indexInfo.data() ), + instanceCount, + firstInstance, + indexInfo.stride(), + vertexOffset.get() ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_opacity_micromap === + + // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createMicromapEXT( const MicromapCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + MicromapEXT * pMicromap, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateMicromapEXT( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pMicromap ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createMicromapEXT( const MicromapCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateMicromapEXT && "Function requires " ); +# endif + + MicromapEXT micromap; + Result result = static_cast( d.vkCreateMicromapEXT( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( µmap ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createMicromapEXT" ); + + return detail::createResultValueType( result, std::move( micromap ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createMicromapEXTUnique( const MicromapCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateMicromapEXT && "Function requires " ); +# endif + + MicromapEXT micromap; + Result result = static_cast( d.vkCreateMicromapEXT( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( µmap ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createMicromapEXTUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( micromap, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyMicromapEXT( MicromapEXT micromap, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyMicromapEXT( + static_cast( m_device ), static_cast( micromap ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyMicromapEXT( MicromapEXT micromap, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyMicromapEXT && "Function requires " ); +# endif + + d.vkDestroyMicromapEXT( m_device, static_cast( micromap ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( MicromapEXT micromap, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyMicromapEXT( + static_cast( m_device ), static_cast( micromap ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( MicromapEXT micromap, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyMicromapEXT && "Function requires " ); +# endif + + d.vkDestroyMicromapEXT( m_device, static_cast( micromap ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::buildMicromapsEXT( uint32_t infoCount, const MicromapBuildInfoEXT * pInfos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBuildMicromapsEXT( static_cast( m_commandBuffer ), infoCount, reinterpret_cast( pInfos ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::buildMicromapsEXT( ArrayProxy const & infos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBuildMicromapsEXT && "Function requires " ); +# endif + + d.vkCmdBuildMicromapsEXT( m_commandBuffer, infos.size(), reinterpret_cast( infos.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildMicromapsEXT( DeferredOperationKHR deferredOperation, + uint32_t infoCount, + const MicromapBuildInfoEXT * pInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkBuildMicromapsEXT( static_cast( m_device ), + static_cast( deferredOperation ), + infoCount, + reinterpret_cast( pInfos ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildMicromapsEXT( DeferredOperationKHR deferredOperation, + ArrayProxy const & infos, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBuildMicromapsEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkBuildMicromapsEXT( + m_device, static_cast( deferredOperation ), infos.size(), reinterpret_cast( infos.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::buildMicromapsEXT", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapEXT( DeferredOperationKHR deferredOperation, + const CopyMicromapInfoEXT * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCopyMicromapEXT( + static_cast( m_device ), static_cast( deferredOperation ), reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapEXT( DeferredOperationKHR deferredOperation, + const CopyMicromapInfoEXT & info, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyMicromapEXT && "Function requires " ); +# endif + + Result result = static_cast( + d.vkCopyMicromapEXT( m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapEXT", { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation, + const CopyMicromapToMemoryInfoEXT * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCopyMicromapToMemoryEXT( static_cast( m_device ), + static_cast( deferredOperation ), + reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation, + const CopyMicromapToMemoryInfoEXT & info, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyMicromapToMemoryEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkCopyMicromapToMemoryEXT( + m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapToMemoryEXT", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation, + const CopyMemoryToMicromapInfoEXT * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCopyMemoryToMicromapEXT( static_cast( m_device ), + static_cast( deferredOperation ), + reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation, + const CopyMemoryToMicromapInfoEXT & info, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCopyMemoryToMicromapEXT && "Function requires " ); +# endif + + Result result = static_cast( d.vkCopyMemoryToMicromapEXT( + m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToMicromapEXT", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeMicromapsPropertiesEXT( uint32_t micromapCount, + const MicromapEXT * pMicromaps, + QueryType queryType, + size_t dataSize, + void * pData, + size_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkWriteMicromapsPropertiesEXT( static_cast( m_device ), + micromapCount, + reinterpret_cast( pMicromaps ), + static_cast( queryType ), + dataSize, + pData, + stride ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::writeMicromapsPropertiesEXT( + ArrayProxy const & micromaps, QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkWriteMicromapsPropertiesEXT && "Function requires " ); +# endif + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( d.vkWriteMicromapsPropertiesEXT( m_device, + micromaps.size(), + reinterpret_cast( micromaps.data() ), + static_cast( queryType ), + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ), + stride ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertiesEXT" ); + + return detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::writeMicromapsPropertyEXT( ArrayProxy const & micromaps, QueryType queryType, size_t stride, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkWriteMicromapsPropertiesEXT && "Function requires " ); +# endif + + DataType data; + Result result = static_cast( d.vkWriteMicromapsPropertiesEXT( m_device, + micromaps.size(), + reinterpret_cast( micromaps.data() ), + static_cast( queryType ), + sizeof( DataType ), + reinterpret_cast( &data ), + stride ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertyEXT" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const CopyMicromapInfoEXT * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyMicromapEXT( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const CopyMicromapInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyMicromapEXT && "Function requires " ); +# endif + + d.vkCmdCopyMicromapEXT( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyMicromapToMemoryEXT( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyMicromapToMemoryEXT && "Function requires " ); +# endif + + d.vkCmdCopyMicromapToMemoryEXT( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyMemoryToMicromapEXT( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToMicromapEXT && "Function requires " ); +# endif + + d.vkCmdCopyMemoryToMicromapEXT( m_commandBuffer, reinterpret_cast( &info ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::writeMicromapsPropertiesEXT( uint32_t micromapCount, + const MicromapEXT * pMicromaps, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdWriteMicromapsPropertiesEXT( static_cast( m_commandBuffer ), + micromapCount, + reinterpret_cast( pMicromaps ), + static_cast( queryType ), + static_cast( queryPool ), + firstQuery ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::writeMicromapsPropertiesEXT( ArrayProxy const & micromaps, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdWriteMicromapsPropertiesEXT && "Function requires " ); +# endif + + d.vkCmdWriteMicromapsPropertiesEXT( m_commandBuffer, + micromaps.size(), + reinterpret_cast( micromaps.data() ), + static_cast( queryType ), + static_cast( queryPool ), + firstQuery ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::getMicromapCompatibilityEXT( const MicromapVersionInfoEXT * pVersionInfo, + AccelerationStructureCompatibilityKHR * pCompatibility, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceMicromapCompatibilityEXT( static_cast( m_device ), + reinterpret_cast( pVersionInfo ), + reinterpret_cast( pCompatibility ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureCompatibilityKHR + Device::getMicromapCompatibilityEXT( const MicromapVersionInfoEXT & versionInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceMicromapCompatibilityEXT && "Function requires " ); +# endif + + AccelerationStructureCompatibilityKHR compatibility; + d.vkGetDeviceMicromapCompatibilityEXT( m_device, + reinterpret_cast( &versionInfo ), + reinterpret_cast( &compatibility ) ); + + return compatibility; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, + const MicromapBuildInfoEXT * pBuildInfo, + MicromapBuildSizesInfoEXT * pSizeInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetMicromapBuildSizesEXT( static_cast( m_device ), + static_cast( buildType ), + reinterpret_cast( pBuildInfo ), + reinterpret_cast( pSizeInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MicromapBuildSizesInfoEXT Device::getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, + const MicromapBuildInfoEXT & buildInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMicromapBuildSizesEXT && "Function requires " ); +# endif + + MicromapBuildSizesInfoEXT sizeInfo; + d.vkGetMicromapBuildSizesEXT( m_device, + static_cast( buildType ), + reinterpret_cast( &buildInfo ), + reinterpret_cast( &sizeInfo ) ); + + return sizeInfo; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_HUAWEI_cluster_culling_shader === + + // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawClusterHUAWEI( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); + } + + // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::drawClusterIndirectHUAWEI( Buffer buffer, DeviceSize offset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDrawClusterIndirectHUAWEI( static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ) ); + } + + //=== VK_EXT_pageable_device_local_memory === + + // wrapper function for command vkSetDeviceMemoryPriorityEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::setMemoryPriorityEXT( DeviceMemory memory, float priority, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkSetDeviceMemoryPriorityEXT( static_cast( m_device ), static_cast( memory ), priority ); + } + + //=== VK_KHR_maintenance4 === + + // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceBufferMemoryRequirementsKHR( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirementsKHR && + "Function requires or " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetDeviceBufferMemoryRequirementsKHR( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirementsKHR && + "Function requires or " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetDeviceBufferMemoryRequirementsKHR( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceImageMemoryRequirementsKHR( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirementsKHR && + "Function requires or " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetDeviceImageMemoryRequirementsKHR( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirementsKHR && + "Function requires or " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetDeviceImageMemoryRequirementsKHR( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo, + uint32_t * pSparseMemoryRequirementCount, + SparseImageMemoryRequirements2 * pSparseMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceImageSparseMemoryRequirementsKHR( static_cast( m_device ), + reinterpret_cast( pInfo ), + pSparseMemoryRequirementCount, + reinterpret_cast( pSparseMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html + template < + typename SparseImageMemoryRequirements2Allocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirementsKHR && + "Function requires or " ); +# endif + + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + d.vkGetDeviceImageSparseMemoryRequirementsKHR( + m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetDeviceImageSparseMemoryRequirementsKHR( m_device, + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } + + // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html + template < + typename SparseImageMemoryRequirements2Allocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, + SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirementsKHR && + "Function requires or " ); +# endif + + std::vector sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator ); + uint32_t sparseMemoryRequirementCount; + d.vkGetDeviceImageSparseMemoryRequirementsKHR( + m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + d.vkGetDeviceImageSparseMemoryRequirementsKHR( m_device, + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VALVE_descriptor_set_host_mapping === + + // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html + template ::type> + VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutHostMappingInfoVALVE( const DescriptorSetBindingReferenceVALVE * pBindingReference, + DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDescriptorSetLayoutHostMappingInfoVALVE( static_cast( m_device ), + reinterpret_cast( pBindingReference ), + reinterpret_cast( pHostMapping ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutHostMappingInfoVALVE Device::getDescriptorSetLayoutHostMappingInfoVALVE( + const DescriptorSetBindingReferenceVALVE & bindingReference, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutHostMappingInfoVALVE && + "Function requires " ); +# endif + + DescriptorSetLayoutHostMappingInfoVALVE hostMapping; + d.vkGetDescriptorSetLayoutHostMappingInfoVALVE( m_device, + reinterpret_cast( &bindingReference ), + reinterpret_cast( &hostMapping ) ); + + return hostMapping; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html + template ::type> + VULKAN_HPP_INLINE void Device::getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet, void ** ppData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDescriptorSetHostMappingVALVE( static_cast( m_device ), static_cast( descriptorSet ), ppData ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * Device::getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDescriptorSetHostMappingVALVE && + "Function requires " ); +# endif + + void * pData; + d.vkGetDescriptorSetHostMappingVALVE( m_device, static_cast( descriptorSet ), &pData ); + + return pData; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_copy_memory_indirect === + + // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::copyMemoryIndirectNV( DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyMemoryIndirectNV( static_cast( m_commandBuffer ), static_cast( copyBufferAddress ), copyCount, stride ); + } + + // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + Image dstImage, + ImageLayout dstImageLayout, + const ImageSubresourceLayers * pImageSubresources, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyMemoryToImageIndirectNV( static_cast( m_commandBuffer ), + static_cast( copyBufferAddress ), + copyCount, + stride, + static_cast( dstImage ), + static_cast( dstImageLayout ), + reinterpret_cast( pImageSubresources ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, + uint32_t stride, + Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & imageSubresources, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToImageIndirectNV && "Function requires " ); +# endif + + d.vkCmdCopyMemoryToImageIndirectNV( m_commandBuffer, + static_cast( copyBufferAddress ), + imageSubresources.size(), + stride, + static_cast( dstImage ), + static_cast( dstImageLayout ), + reinterpret_cast( imageSubresources.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_memory_decompression === + + // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryNV( uint32_t decompressRegionCount, + const DecompressMemoryRegionNV * pDecompressMemoryRegions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDecompressMemoryNV( static_cast( m_commandBuffer ), + decompressRegionCount, + reinterpret_cast( pDecompressMemoryRegions ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryNV( ArrayProxy const & decompressMemoryRegions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDecompressMemoryNV && "Function requires " ); +# endif + + d.vkCmdDecompressMemoryNV( + m_commandBuffer, decompressMemoryRegions.size(), reinterpret_cast( decompressMemoryRegions.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountNV( DeviceAddress indirectCommandsAddress, + DeviceAddress indirectCommandsCountAddress, + uint32_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDecompressMemoryIndirectCountNV( static_cast( m_commandBuffer ), + static_cast( indirectCommandsAddress ), + static_cast( indirectCommandsCountAddress ), + stride ); + } + + //=== VK_NV_device_generated_commands_compute === + + // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html + template ::type> + VULKAN_HPP_INLINE void Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo * pCreateInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPipelineIndirectMemoryRequirementsNV( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectMemoryRequirementsNV && + "Function requires " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetPipelineIndirectMemoryRequirementsNV( + m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectMemoryRequirementsNV && + "Function requires " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetPipelineIndirectMemoryRequirementsNV( + m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::updatePipelineIndirectBufferNV( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdUpdatePipelineIndirectBufferNV( + static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( pipeline ) ); + } + + // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html + template ::type> + VULKAN_HPP_INLINE DeviceAddress Device::getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPipelineIndirectDeviceAddressNV( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html + template ::type> + VULKAN_HPP_INLINE DeviceAddress Device::getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectDeviceAddressNV && + "Function requires " ); +# endif + + VkDeviceAddress result = d.vkGetPipelineIndirectDeviceAddressNV( m_device, reinterpret_cast( &info ) ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer * buffer, + NativeBufferPropertiesOHOS * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetNativeBufferPropertiesOHOS( static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetNativeBufferPropertiesOHOS && "Function requires " ); +# endif + + NativeBufferPropertiesOHOS properties; + Result result = + static_cast( d.vkGetNativeBufferPropertiesOHOS( m_device, &buffer, reinterpret_cast( &properties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getNativeBufferPropertiesOHOS" ); + + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetNativeBufferPropertiesOHOS && "Function requires " ); +# endif + + StructureChain structureChain; + NativeBufferPropertiesOHOS & properties = structureChain.template get(); + Result result = + static_cast( d.vkGetNativeBufferPropertiesOHOS( m_device, &buffer, reinterpret_cast( &properties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getNativeBufferPropertiesOHOS" ); + + return detail::createResultValueType( result, std::move( structureChain ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS * pInfo, + struct OH_NativeBuffer ** pBuffer, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetMemoryNativeBufferOHOS( static_cast( m_device ), reinterpret_cast( pInfo ), pBuffer ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryNativeBufferOHOS && "Function requires " ); +# endif + + struct OH_NativeBuffer * buffer; + Result result = + static_cast( d.vkGetMemoryNativeBufferOHOS( m_device, reinterpret_cast( &info ), &buffer ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryNativeBufferOHOS" ); + + return detail::createResultValueType( result, std::move( buffer ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_extended_dynamic_state3 === + + // wrapper function for command vkCmdSetDepthClampEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( Bool32 depthClampEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthClampEnableEXT( static_cast( m_commandBuffer ), static_cast( depthClampEnable ) ); + } + + // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setPolygonModeEXT( PolygonMode polygonMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetPolygonModeEXT( static_cast( m_commandBuffer ), static_cast( polygonMode ) ); + } + + // wrapper function for command vkCmdSetRasterizationSamplesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRasterizationSamplesEXT( SampleCountFlagBits rasterizationSamples, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetRasterizationSamplesEXT( static_cast( m_commandBuffer ), static_cast( rasterizationSamples ) ); + } + + // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::setSampleMaskEXT( SampleCountFlagBits samples, const SampleMask * pSampleMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetSampleMaskEXT( + static_cast( m_commandBuffer ), static_cast( samples ), reinterpret_cast( pSampleMask ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setSampleMaskEXT( SampleCountFlagBits samples, + ArrayProxy const & sampleMask, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetSampleMaskEXT && "Function requires or " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( sampleMask.size() == ( static_cast( samples ) + 31 ) / 32 ); +# else + if ( sampleMask.size() != ( static_cast( samples ) + 31 ) / 32 ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setSampleMaskEXT: sampleMask.size() != ( static_cast( samples ) + 31 ) / 32" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdSetSampleMaskEXT( m_commandBuffer, static_cast( samples ), reinterpret_cast( sampleMask.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setAlphaToCoverageEnableEXT( Bool32 alphaToCoverageEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetAlphaToCoverageEnableEXT( static_cast( m_commandBuffer ), static_cast( alphaToCoverageEnable ) ); + } + + // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setAlphaToOneEnableEXT( Bool32 alphaToOneEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetAlphaToOneEnableEXT( static_cast( m_commandBuffer ), static_cast( alphaToOneEnable ) ); + } + + // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEnableEXT( Bool32 logicOpEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetLogicOpEnableEXT( static_cast( m_commandBuffer ), static_cast( logicOpEnable ) ); + } + + // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( uint32_t firstAttachment, + uint32_t attachmentCount, + const Bool32 * pColorBlendEnables, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetColorBlendEnableEXT( + static_cast( m_commandBuffer ), firstAttachment, attachmentCount, reinterpret_cast( pColorBlendEnables ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( uint32_t firstAttachment, + ArrayProxy const & colorBlendEnables, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendEnableEXT && + "Function requires or " ); +# endif + + d.vkCmdSetColorBlendEnableEXT( m_commandBuffer, firstAttachment, colorBlendEnables.size(), reinterpret_cast( colorBlendEnables.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetColorBlendEquationEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEquationEXT( uint32_t firstAttachment, + uint32_t attachmentCount, + const ColorBlendEquationEXT * pColorBlendEquations, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetColorBlendEquationEXT( static_cast( m_commandBuffer ), + firstAttachment, + attachmentCount, + reinterpret_cast( pColorBlendEquations ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetColorBlendEquationEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEquationEXT( uint32_t firstAttachment, + ArrayProxy const & colorBlendEquations, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendEquationEXT && + "Function requires or " ); +# endif + + d.vkCmdSetColorBlendEquationEXT( + m_commandBuffer, firstAttachment, colorBlendEquations.size(), reinterpret_cast( colorBlendEquations.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT( uint32_t firstAttachment, + uint32_t attachmentCount, + const ColorComponentFlags * pColorWriteMasks, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetColorWriteMaskEXT( + static_cast( m_commandBuffer ), firstAttachment, attachmentCount, reinterpret_cast( pColorWriteMasks ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT( uint32_t firstAttachment, + ArrayProxy const & colorWriteMasks, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetColorWriteMaskEXT && + "Function requires or " ); +# endif + + d.vkCmdSetColorWriteMaskEXT( + m_commandBuffer, firstAttachment, colorWriteMasks.size(), reinterpret_cast( colorWriteMasks.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setTessellationDomainOriginEXT( TessellationDomainOrigin domainOrigin, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetTessellationDomainOriginEXT( static_cast( m_commandBuffer ), static_cast( domainOrigin ) ); + } + + // wrapper function for command vkCmdSetRasterizationStreamEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetRasterizationStreamEXT( static_cast( m_commandBuffer ), rasterizationStream ); + } + + // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setConservativeRasterizationModeEXT( ConservativeRasterizationModeEXT conservativeRasterizationMode, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetConservativeRasterizationModeEXT( static_cast( m_commandBuffer ), + static_cast( conservativeRasterizationMode ) ); + } + + // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetExtraPrimitiveOverestimationSizeEXT( static_cast( m_commandBuffer ), extraPrimitiveOverestimationSize ); + } + + // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthClipEnableEXT( Bool32 depthClipEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthClipEnableEXT( static_cast( m_commandBuffer ), static_cast( depthClipEnable ) ); + } + + // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEnableEXT( Bool32 sampleLocationsEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetSampleLocationsEnableEXT( static_cast( m_commandBuffer ), static_cast( sampleLocationsEnable ) ); + } + + // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setColorBlendAdvancedEXT( uint32_t firstAttachment, + uint32_t attachmentCount, + const ColorBlendAdvancedEXT * pColorBlendAdvanced, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetColorBlendAdvancedEXT( static_cast( m_commandBuffer ), + firstAttachment, + attachmentCount, + reinterpret_cast( pColorBlendAdvanced ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setColorBlendAdvancedEXT( uint32_t firstAttachment, + ArrayProxy const & colorBlendAdvanced, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendAdvancedEXT && + "Function requires or " ); +# endif + + d.vkCmdSetColorBlendAdvancedEXT( + m_commandBuffer, firstAttachment, colorBlendAdvanced.size(), reinterpret_cast( colorBlendAdvanced.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetProvokingVertexModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setProvokingVertexModeEXT( ProvokingVertexModeEXT provokingVertexMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetProvokingVertexModeEXT( static_cast( m_commandBuffer ), static_cast( provokingVertexMode ) ); + } + + // wrapper function for command vkCmdSetLineRasterizationModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setLineRasterizationModeEXT( LineRasterizationModeEXT lineRasterizationMode, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetLineRasterizationModeEXT( static_cast( m_commandBuffer ), static_cast( lineRasterizationMode ) ); + } + + // wrapper function for command vkCmdSetLineStippleEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEnableEXT( Bool32 stippledLineEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetLineStippleEnableEXT( static_cast( m_commandBuffer ), static_cast( stippledLineEnable ) ); + } + + // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthClipNegativeOneToOneEXT( Bool32 negativeOneToOne, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthClipNegativeOneToOneEXT( static_cast( m_commandBuffer ), static_cast( negativeOneToOne ) ); + } + + // wrapper function for command vkCmdSetViewportWScalingEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingEnableNV( Bool32 viewportWScalingEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetViewportWScalingEnableNV( static_cast( m_commandBuffer ), static_cast( viewportWScalingEnable ) ); + } + + // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV( uint32_t firstViewport, + uint32_t viewportCount, + const ViewportSwizzleNV * pViewportSwizzles, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetViewportSwizzleNV( + static_cast( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast( pViewportSwizzles ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV( uint32_t firstViewport, + ArrayProxy const & viewportSwizzles, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetViewportSwizzleNV && + "Function requires or " ); +# endif + + d.vkCmdSetViewportSwizzleNV( + m_commandBuffer, firstViewport, viewportSwizzles.size(), reinterpret_cast( viewportSwizzles.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetCoverageToColorEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorEnableNV( Bool32 coverageToColorEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetCoverageToColorEnableNV( static_cast( m_commandBuffer ), static_cast( coverageToColorEnable ) ); + } + + // wrapper function for command vkCmdSetCoverageToColorLocationNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorLocationNV( uint32_t coverageToColorLocation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetCoverageToColorLocationNV( static_cast( m_commandBuffer ), coverageToColorLocation ); + } + + // wrapper function for command vkCmdSetCoverageModulationModeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationModeNV( CoverageModulationModeNV coverageModulationMode, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetCoverageModulationModeNV( static_cast( m_commandBuffer ), static_cast( coverageModulationMode ) ); + } + + // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableEnableNV( Bool32 coverageModulationTableEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetCoverageModulationTableEnableNV( static_cast( m_commandBuffer ), static_cast( coverageModulationTableEnable ) ); + } + + // wrapper function for command vkCmdSetCoverageModulationTableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableNV( uint32_t coverageModulationTableCount, + const float * pCoverageModulationTable, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetCoverageModulationTableNV( static_cast( m_commandBuffer ), coverageModulationTableCount, pCoverageModulationTable ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetCoverageModulationTableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableNV( ArrayProxy const & coverageModulationTable, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetCoverageModulationTableNV && + "Function requires or " ); +# endif + + d.vkCmdSetCoverageModulationTableNV( m_commandBuffer, coverageModulationTable.size(), coverageModulationTable.data() ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetShadingRateImageEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setShadingRateImageEnableNV( Bool32 shadingRateImageEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetShadingRateImageEnableNV( static_cast( m_commandBuffer ), static_cast( shadingRateImageEnable ) ); + } + + // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setRepresentativeFragmentTestEnableNV( Bool32 representativeFragmentTestEnable, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetRepresentativeFragmentTestEnableNV( static_cast( m_commandBuffer ), static_cast( representativeFragmentTestEnable ) ); + } + + // wrapper function for command vkCmdSetCoverageReductionModeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setCoverageReductionModeNV( CoverageReductionModeNV coverageReductionMode, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetCoverageReductionModeNV( static_cast( m_commandBuffer ), static_cast( coverageReductionMode ) ); + } + + //=== VK_ARM_tensors === + + // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createTensorARM( const TensorCreateInfoARM * pCreateInfo, + const AllocationCallbacks * pAllocator, + TensorARM * pTensor, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateTensorARM( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pTensor ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createTensorARM( const TensorCreateInfoARM & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateTensorARM && "Function requires " ); +# endif + + TensorARM tensor; + Result result = static_cast( d.vkCreateTensorARM( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &tensor ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorARM" ); + + return detail::createResultValueType( result, std::move( tensor ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createTensorARMUnique( const TensorCreateInfoARM & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateTensorARM && "Function requires " ); +# endif + + TensorARM tensor; + Result result = static_cast( d.vkCreateTensorARM( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &tensor ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorARMUnique" ); + + return detail::createResultValueType( result, UniqueHandle( tensor, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyTensorARM( TensorARM tensor, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyTensorARM( + static_cast( m_device ), static_cast( tensor ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyTensorARM( TensorARM tensor, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyTensorARM && "Function requires " ); +# endif + + d.vkDestroyTensorARM( m_device, static_cast( tensor ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( TensorARM tensor, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyTensorARM( + static_cast( m_device ), static_cast( tensor ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( TensorARM tensor, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyTensorARM && "Function requires " ); +# endif + + d.vkDestroyTensorARM( m_device, static_cast( tensor ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createTensorViewARM( const TensorViewCreateInfoARM * pCreateInfo, + const AllocationCallbacks * pAllocator, + TensorViewARM * pView, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateTensorViewARM( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pView ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createTensorViewARM( const TensorViewCreateInfoARM & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateTensorViewARM && "Function requires " ); +# endif + + TensorViewARM view; + Result result = static_cast( d.vkCreateTensorViewARM( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &view ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorViewARM" ); + + return detail::createResultValueType( result, std::move( view ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createTensorViewARMUnique( const TensorViewCreateInfoARM & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateTensorViewARM && "Function requires " ); +# endif + + TensorViewARM view; + Result result = static_cast( d.vkCreateTensorViewARM( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &view ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorViewARMUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( view, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyTensorViewARM( TensorViewARM tensorView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyTensorViewARM( + static_cast( m_device ), static_cast( tensorView ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyTensorViewARM( TensorViewARM tensorView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyTensorViewARM && "Function requires " ); +# endif + + d.vkDestroyTensorViewARM( m_device, static_cast( tensorView ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( TensorViewARM tensorView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyTensorViewARM( + static_cast( m_device ), static_cast( tensorView ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( TensorViewARM tensorView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyTensorViewARM && "Function requires " ); +# endif + + d.vkDestroyTensorViewARM( m_device, static_cast( tensorView ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html + template ::type> + VULKAN_HPP_INLINE void Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetTensorMemoryRequirementsARM( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetTensorMemoryRequirementsARM && "Function requires " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetTensorMemoryRequirementsARM( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetTensorMemoryRequirementsARM && "Function requires " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetTensorMemoryRequirementsARM( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindTensorMemoryARM( uint32_t bindInfoCount, + const BindTensorMemoryInfoARM * pBindInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkBindTensorMemoryARM( static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::bindTensorMemoryARM( ArrayProxy const & bindInfos, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBindTensorMemoryARM && "Function requires " ); +# endif + + Result result = + static_cast( d.vkBindTensorMemoryARM( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindTensorMemoryARM" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html + template ::type> + VULKAN_HPP_INLINE void Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceTensorMemoryRequirementsARM( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceTensorMemoryRequirementsARM && "Function requires " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetDeviceTensorMemoryRequirementsARM( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceTensorMemoryRequirementsARM && "Function requires " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetDeviceTensorMemoryRequirementsARM( + m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyTensorARM( const CopyTensorInfoARM * pCopyTensorInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyTensorARM( static_cast( m_commandBuffer ), reinterpret_cast( pCopyTensorInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyTensorARM( const CopyTensorInfoARM & copyTensorInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyTensorARM && "Function requires " ); +# endif + + d.vkCmdCopyTensorARM( m_commandBuffer, reinterpret_cast( ©TensorInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getExternalTensorPropertiesARM( const PhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo, + ExternalTensorPropertiesARM * pExternalTensorProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceExternalTensorPropertiesARM( static_cast( m_physicalDevice ), + reinterpret_cast( pExternalTensorInfo ), + reinterpret_cast( pExternalTensorProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalTensorPropertiesARM PhysicalDevice::getExternalTensorPropertiesARM( + const PhysicalDeviceExternalTensorInfoARM & externalTensorInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalTensorPropertiesARM && + "Function requires " ); +# endif + + ExternalTensorPropertiesARM externalTensorProperties; + d.vkGetPhysicalDeviceExternalTensorPropertiesARM( m_physicalDevice, + reinterpret_cast( &externalTensorInfo ), + reinterpret_cast( &externalTensorProperties ) ); + + return externalTensorProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM * pInfo, + void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetTensorOpaqueCaptureDescriptorDataARM( + static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDescriptorDataARM && "Function requires " ); +# endif + + DataType data; + Result result = static_cast( + d.vkGetTensorOpaqueCaptureDescriptorDataARM( m_device, reinterpret_cast( &info ), &data ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDescriptorDataARM" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM * pInfo, + void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetTensorViewOpaqueCaptureDescriptorDataARM( + static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetTensorViewOpaqueCaptureDescriptorDataARM && + "Function requires " ); +# endif + + DataType data; + Result result = static_cast( + d.vkGetTensorViewOpaqueCaptureDescriptorDataARM( m_device, reinterpret_cast( &info ), &data ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorViewOpaqueCaptureDescriptorDataARM" ); + + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_shader_module_identifier === + + // wrapper function for command vkGetShaderModuleIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::getShaderModuleIdentifierEXT( ShaderModule shaderModule, ShaderModuleIdentifierEXT * pIdentifier, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetShaderModuleIdentifierEXT( + static_cast( m_device ), static_cast( shaderModule ), reinterpret_cast( pIdentifier ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetShaderModuleIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ShaderModuleIdentifierEXT Device::getShaderModuleIdentifierEXT( ShaderModule shaderModule, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetShaderModuleIdentifierEXT && "Function requires " ); +# endif + + ShaderModuleIdentifierEXT identifier; + d.vkGetShaderModuleIdentifierEXT( m_device, static_cast( shaderModule ), reinterpret_cast( &identifier ) ); + + return identifier; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo * pCreateInfo, + ShaderModuleIdentifierEXT * pIdentifier, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetShaderModuleCreateInfoIdentifierEXT( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pIdentifier ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ShaderModuleIdentifierEXT + Device::getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo & createInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetShaderModuleCreateInfoIdentifierEXT && + "Function requires " ); +# endif + + ShaderModuleIdentifierEXT identifier; + d.vkGetShaderModuleCreateInfoIdentifierEXT( + m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &identifier ) ); + + return identifier; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_optical_flow === + + // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo, + uint32_t * pFormatCount, + OpticalFlowImageFormatPropertiesNV * pImageFormatProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( static_cast( m_physicalDevice ), + reinterpret_cast( pOpticalFlowImageFormatInfo ), + pFormatCount, + reinterpret_cast( pImageFormatProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html + template ::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV && + "Function requires " ); +# endif + + std::vector imageFormatProperties; + uint32_t formatCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( + m_physicalDevice, reinterpret_cast( &opticalFlowImageFormatInfo ), &formatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && formatCount ) + { + imageFormatProperties.resize( formatCount ); + result = static_cast( + d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( m_physicalDevice, + reinterpret_cast( &opticalFlowImageFormatInfo ), + &formatCount, + reinterpret_cast( imageFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" ); + VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); + if ( formatCount < imageFormatProperties.size() ) + { + imageFormatProperties.resize( formatCount ); + } + return detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html + template ::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, + OpticalFlowImageFormatPropertiesNVAllocator const & opticalFlowImageFormatPropertiesNVAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV && + "Function requires " ); +# endif + + std::vector imageFormatProperties( + opticalFlowImageFormatPropertiesNVAllocator ); + uint32_t formatCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( + m_physicalDevice, reinterpret_cast( &opticalFlowImageFormatInfo ), &formatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && formatCount ) + { + imageFormatProperties.resize( formatCount ); + result = static_cast( + d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( m_physicalDevice, + reinterpret_cast( &opticalFlowImageFormatInfo ), + &formatCount, + reinterpret_cast( imageFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" ); + VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); + if ( formatCount < imageFormatProperties.size() ) + { + imageFormatProperties.resize( formatCount ); + } + return detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createOpticalFlowSessionNV( const OpticalFlowSessionCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + OpticalFlowSessionNV * pSession, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateOpticalFlowSessionNV( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSession ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createOpticalFlowSessionNV( + const OpticalFlowSessionCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateOpticalFlowSessionNV && "Function requires " ); +# endif + + OpticalFlowSessionNV session; + Result result = static_cast( d.vkCreateOpticalFlowSessionNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &session ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createOpticalFlowSessionNV" ); + + return detail::createResultValueType( result, std::move( session ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::createOpticalFlowSessionNVUnique( + const OpticalFlowSessionCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateOpticalFlowSessionNV && "Function requires " ); +# endif + + OpticalFlowSessionNV session; + Result result = static_cast( d.vkCreateOpticalFlowSessionNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &session ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createOpticalFlowSessionNVUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( session, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyOpticalFlowSessionNV( OpticalFlowSessionNV session, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyOpticalFlowSessionNV( + static_cast( m_device ), static_cast( session ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyOpticalFlowSessionNV( OpticalFlowSessionNV session, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyOpticalFlowSessionNV && "Function requires " ); +# endif + + d.vkDestroyOpticalFlowSessionNV( + m_device, static_cast( session ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( OpticalFlowSessionNV session, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyOpticalFlowSessionNV( + static_cast( m_device ), static_cast( session ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( OpticalFlowSessionNV session, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyOpticalFlowSessionNV && "Function requires " ); +# endif + + d.vkDestroyOpticalFlowSessionNV( + m_device, static_cast( session ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindOpticalFlowSessionImageNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindOpticalFlowSessionImageNV( OpticalFlowSessionNV session, + OpticalFlowSessionBindingPointNV bindingPoint, + ImageView view, + ImageLayout layout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkBindOpticalFlowSessionImageNV( static_cast( m_device ), + static_cast( session ), + static_cast( bindingPoint ), + static_cast( view ), + static_cast( layout ) ) ); + } +#else + // wrapper function for command vkBindOpticalFlowSessionImageNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::bindOpticalFlowSessionImageNV( + OpticalFlowSessionNV session, OpticalFlowSessionBindingPointNV bindingPoint, ImageView view, ImageLayout layout, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBindOpticalFlowSessionImageNV && "Function requires " ); +# endif + + Result result = static_cast( d.vkBindOpticalFlowSessionImageNV( m_device, + static_cast( session ), + static_cast( bindingPoint ), + static_cast( view ), + static_cast( layout ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindOpticalFlowSessionImageNV" ); + + return detail::createResultValueType( result ); + } +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( OpticalFlowSessionNV session, + const OpticalFlowExecuteInfoNV * pExecuteInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdOpticalFlowExecuteNV( static_cast( m_commandBuffer ), + static_cast( session ), + reinterpret_cast( pExecuteInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( OpticalFlowSessionNV session, + const OpticalFlowExecuteInfoNV & executeInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdOpticalFlowExecuteNV && "Function requires " ); +# endif + + d.vkCmdOpticalFlowExecuteNV( + m_commandBuffer, static_cast( session ), reinterpret_cast( &executeInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_maintenance5 === + + // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::bindIndexBuffer2KHR( Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindIndexBuffer2KHR( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( size ), + static_cast( indexType ) ); + } + + // wrapper function for command vkGetRenderingAreaGranularityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getRenderingAreaGranularityKHR( const RenderingAreaInfo * pRenderingAreaInfo, + Extent2D * pGranularity, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetRenderingAreaGranularityKHR( + static_cast( m_device ), reinterpret_cast( pRenderingAreaInfo ), reinterpret_cast( pGranularity ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRenderingAreaGranularityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D Device::getRenderingAreaGranularityKHR( const RenderingAreaInfo & renderingAreaInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetRenderingAreaGranularityKHR && "Function requires or " ); +# endif + + Extent2D granularity; + d.vkGetRenderingAreaGranularityKHR( + m_device, reinterpret_cast( &renderingAreaInfo ), reinterpret_cast( &granularity ) ); + + return granularity; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo * pInfo, SubresourceLayout2 * pLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDeviceImageSubresourceLayoutKHR( + static_cast( m_device ), reinterpret_cast( pInfo ), reinterpret_cast( pLayout ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayoutKHR && + "Function requires or " ); +# endif + + SubresourceLayout2 layout; + d.vkGetDeviceImageSubresourceLayoutKHR( + m_device, reinterpret_cast( &info ), reinterpret_cast( &layout ) ); + + return layout; + } + + // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayoutKHR && + "Function requires or " ); +# endif + + StructureChain structureChain; + SubresourceLayout2 & layout = structureChain.template get(); + d.vkGetDeviceImageSubresourceLayoutKHR( + m_device, reinterpret_cast( &info ), reinterpret_cast( &layout ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSubresourceLayout2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html + template ::type> + VULKAN_HPP_INLINE void Device::getImageSubresourceLayout2KHR( Image image, + const ImageSubresource2 * pSubresource, + SubresourceLayout2 * pLayout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetImageSubresourceLayout2KHR( static_cast( m_device ), + static_cast( image ), + reinterpret_cast( pSubresource ), + reinterpret_cast( pLayout ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSubresourceLayout2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout2KHR( Image image, + const ImageSubresource2 & subresource, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( + d.vkGetImageSubresourceLayout2KHR && + "Function requires or or or " ); +# endif + + SubresourceLayout2 layout; + d.vkGetImageSubresourceLayout2KHR( m_device, + static_cast( image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return layout; + } + + // wrapper function for command vkGetImageSubresourceLayout2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getImageSubresourceLayout2KHR( Image image, const ImageSubresource2 & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( + d.vkGetImageSubresourceLayout2KHR && + "Function requires or or or " ); +# endif + + StructureChain structureChain; + SubresourceLayout2 & layout = structureChain.template get(); + d.vkGetImageSubresourceLayout2KHR( m_device, + static_cast( image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_AMD_anti_lag === + + // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html + template ::type> + VULKAN_HPP_INLINE void Device::antiLagUpdateAMD( const AntiLagDataAMD * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkAntiLagUpdateAMD( static_cast( m_device ), reinterpret_cast( pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html + template ::type> + VULKAN_HPP_INLINE void Device::antiLagUpdateAMD( const AntiLagDataAMD & data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkAntiLagUpdateAMD && "Function requires " ); +# endif + + d.vkAntiLagUpdateAMD( m_device, reinterpret_cast( &data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_present_wait2 === + + // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForPresent2KHR( SwapchainKHR swapchain, + const PresentWait2InfoKHR * pPresentWait2Info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkWaitForPresent2KHR( + static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pPresentWait2Info ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForPresent2KHR( SwapchainKHR swapchain, + const PresentWait2InfoKHR & presentWait2Info, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkWaitForPresent2KHR && "Function requires " ); +# endif + + Result result = static_cast( + d.vkWaitForPresent2KHR( m_device, static_cast( swapchain ), reinterpret_cast( &presentWait2Info ) ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresent2KHR", + { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresent2KHR", { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR } ); +# endif + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_shader_object === + + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createShadersEXT( uint32_t createInfoCount, + const ShaderCreateInfoEXT * pCreateInfos, + const AllocationCallbacks * pAllocator, + ShaderEXT * pShaders, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateShadersEXT( static_cast( m_device ), + createInfoCount, + reinterpret_cast( pCreateInfos ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pShaders ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::createShadersEXT( + ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); +# endif + + std::vector shaders( createInfos.size() ); + Result result = static_cast( d.vkCreateShadersEXT( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( shaders.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); + + return ResultValue>( result, std::move( shaders ) ); + } + + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createShadersEXT( ArrayProxy const & createInfos, + Optional allocator, + ShaderEXTAllocator const & shaderEXTAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); +# endif + + std::vector shaders( createInfos.size(), {}, shaderEXTAllocator ); + Result result = static_cast( d.vkCreateShadersEXT( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( shaders.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); + + return ResultValue>( result, std::move( shaders ) ); + } + + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue + Device::createShaderEXT( const ShaderCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); +# endif + + ShaderEXT shader; + Result result = static_cast( d.vkCreateShadersEXT( m_device, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &shader ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); + + return ResultValue( result, std::move( shader ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, ShaderEXTAllocator>> Device::createShadersEXTUnique( + ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); +# endif + + std::vector shaders( createInfos.size() ); + Result result = static_cast( d.vkCreateShadersEXT( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( shaders.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); + std::vector, ShaderEXTAllocator> uniqueShaders; + uniqueShaders.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & shader : shaders ) + { + uniqueShaders.push_back( UniqueHandle( shader, deleter ) ); + } + return ResultValue, ShaderEXTAllocator>>( result, std::move( uniqueShaders ) ); + } + + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, ShaderEXTAllocator>> + Device::createShadersEXTUnique( ArrayProxy const & createInfos, + Optional allocator, + ShaderEXTAllocator const & shaderEXTAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); +# endif + + std::vector shaders( createInfos.size() ); + Result result = static_cast( d.vkCreateShadersEXT( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( shaders.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); + std::vector, ShaderEXTAllocator> uniqueShaders( shaderEXTAllocator ); + uniqueShaders.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & shader : shaders ) + { + uniqueShaders.push_back( UniqueHandle( shader, deleter ) ); + } + return ResultValue, ShaderEXTAllocator>>( result, std::move( uniqueShaders ) ); + } + + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createShaderEXTUnique( const ShaderCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); +# endif + + ShaderEXT shader; + Result result = static_cast( d.vkCreateShadersEXT( m_device, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &shader ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXTUnique", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); + + return ResultValue>( + result, UniqueHandle( shader, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyShaderEXT( ShaderEXT shader, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyShaderEXT( + static_cast( m_device ), static_cast( shader ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyShaderEXT( ShaderEXT shader, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyShaderEXT && "Function requires " ); +# endif + + d.vkDestroyShaderEXT( m_device, static_cast( shader ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( ShaderEXT shader, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyShaderEXT( + static_cast( m_device ), static_cast( shader ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( ShaderEXT shader, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyShaderEXT && "Function requires " ); +# endif + + d.vkDestroyShaderEXT( m_device, static_cast( shader ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getShaderBinaryDataEXT( ShaderEXT shader, size_t * pDataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetShaderBinaryDataEXT( static_cast( m_device ), static_cast( shader ), pDataSize, pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getShaderBinaryDataEXT( ShaderEXT shader, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetShaderBinaryDataEXT && "Function requires " ); +# endif + + std::vector data; + size_t dataSize; + Result result; + do + { + result = static_cast( d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = + static_cast( d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderBinaryDataEXT" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getShaderBinaryDataEXT( ShaderEXT shader, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetShaderBinaryDataEXT && "Function requires " ); +# endif + + std::vector data( uint8_tAllocator ); + size_t dataSize; + Result result; + do + { + result = static_cast( d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = + static_cast( d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderBinaryDataEXT" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return detail::createResultValueType( result, std::move( data ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( uint32_t stageCount, + const ShaderStageFlagBits * pStages, + const ShaderEXT * pShaders, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindShadersEXT( static_cast( m_commandBuffer ), + stageCount, + reinterpret_cast( pStages ), + reinterpret_cast( pShaders ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( ArrayProxy const & stages, + ArrayProxy const & shaders, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindShadersEXT && "Function requires " ); +# endif +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( stages.size() == shaders.size() ); +# else + if ( stages.size() != shaders.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindShadersEXT: stages.size() != shaders.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdBindShadersEXT( m_commandBuffer, + stages.size(), + reinterpret_cast( stages.data() ), + reinterpret_cast( shaders.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, + const DepthClampRangeEXT * pDepthClampRange, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDepthClampRangeEXT( static_cast( m_commandBuffer ), + static_cast( depthClampMode ), + reinterpret_cast( pDepthClampRange ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, + Optional depthClampRange, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetDepthClampRangeEXT && + "Function requires or " ); +# endif + + d.vkCmdSetDepthClampRangeEXT( + m_commandBuffer, static_cast( depthClampMode ), reinterpret_cast( depthClampRange.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_pipeline_binary === + + // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + PipelineBinaryHandlesInfoKHR * pBinaries, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreatePipelineBinariesKHR( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pBinaries ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function requires " ); +# endif + + std::vector pipelineBinaries; + PipelineBinaryHandlesInfoKHR binaries; + Result result; + if ( createInfo.pKeysAndDataInfo ) + { + VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo ); + pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount ); + binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount; + binaries.pPipelineBinaries = pipelineBinaries.data(); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + } + else + { + VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo ); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + if ( result == Result::eSuccess ) + { + pipelineBinaries.resize( binaries.pipelineBinaryCount ); + binaries.pPipelineBinaries = pipelineBinaries.data(); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + } + } + + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHR", { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } ); + + return ResultValue>( result, std::move( pipelineBinaries ) ); + } + + // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo, + Optional allocator, + PipelineBinaryKHRAllocator const & pipelineBinaryKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function requires " ); +# endif + + std::vector pipelineBinaries( pipelineBinaryKHRAllocator ); + PipelineBinaryHandlesInfoKHR binaries; + Result result; + if ( createInfo.pKeysAndDataInfo ) + { + VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo ); + pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount ); + binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount; + binaries.pPipelineBinaries = pipelineBinaries.data(); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + } + else + { + VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo ); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + if ( result == Result::eSuccess ) + { + pipelineBinaries.resize( binaries.pipelineBinaryCount ); + binaries.pPipelineBinaries = pipelineBinaries.data(); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + } + } + + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHR", { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } ); + + return ResultValue>( result, std::move( pipelineBinaries ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineBinaryKHRAllocator>> + Device::createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function requires " ); +# endif + + std::vector pipelineBinaries; + PipelineBinaryHandlesInfoKHR binaries; + Result result; + if ( createInfo.pKeysAndDataInfo ) + { + VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo ); + pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount ); + binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount; + binaries.pPipelineBinaries = pipelineBinaries.data(); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + } + else + { + VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo ); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + if ( result == Result::eSuccess ) + { + pipelineBinaries.resize( binaries.pipelineBinaryCount ); + binaries.pPipelineBinaries = pipelineBinaries.data(); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + } + } + + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHRUnique", + { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } ); + std::vector, PipelineBinaryKHRAllocator> uniquePipelineBinaries; + uniquePipelineBinaries.reserve( pipelineBinaries.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipelineBinary : pipelineBinaries ) + { + uniquePipelineBinaries.push_back( UniqueHandle( pipelineBinary, deleter ) ); + } + return ResultValue, PipelineBinaryKHRAllocator>>( result, std::move( uniquePipelineBinaries ) ); + } + + // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineBinaryKHRAllocator>> + Device::createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo, + Optional allocator, + PipelineBinaryKHRAllocator const & pipelineBinaryKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function requires " ); +# endif + + std::vector pipelineBinaries; + PipelineBinaryHandlesInfoKHR binaries; + Result result; + if ( createInfo.pKeysAndDataInfo ) + { + VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo ); + pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount ); + binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount; + binaries.pPipelineBinaries = pipelineBinaries.data(); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + } + else + { + VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo ); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + if ( result == Result::eSuccess ) + { + pipelineBinaries.resize( binaries.pipelineBinaryCount ); + binaries.pPipelineBinaries = pipelineBinaries.data(); + result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + } + } + + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHRUnique", + { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } ); + std::vector, PipelineBinaryKHRAllocator> uniquePipelineBinaries( pipelineBinaryKHRAllocator ); + uniquePipelineBinaries.reserve( pipelineBinaries.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipelineBinary : pipelineBinaries ) + { + uniquePipelineBinaries.push_back( UniqueHandle( pipelineBinary, deleter ) ); + } + return ResultValue, PipelineBinaryKHRAllocator>>( result, std::move( uniquePipelineBinaries ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyPipelineBinaryKHR( + static_cast( m_device ), static_cast( pipelineBinary ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyPipelineBinaryKHR && "Function requires " ); +# endif + + d.vkDestroyPipelineBinaryKHR( + m_device, static_cast( pipelineBinary ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( PipelineBinaryKHR pipelineBinary, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyPipelineBinaryKHR( + static_cast( m_device ), static_cast( pipelineBinary ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( PipelineBinaryKHR pipelineBinary, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyPipelineBinaryKHR && "Function requires " ); +# endif + + d.vkDestroyPipelineBinaryKHR( + m_device, static_cast( pipelineBinary ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineKeyKHR( const PipelineCreateInfoKHR * pPipelineCreateInfo, + PipelineBinaryKeyKHR * pPipelineKey, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPipelineKeyKHR( static_cast( m_device ), + reinterpret_cast( pPipelineCreateInfo ), + reinterpret_cast( pPipelineKey ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getPipelineKeyKHR( Optional pipelineCreateInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineKeyKHR && "Function requires " ); +# endif + + PipelineBinaryKeyKHR pipelineKey; + Result result = static_cast( d.vkGetPipelineKeyKHR( + m_device, reinterpret_cast( pipelineCreateInfo.get() ), reinterpret_cast( &pipelineKey ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineKeyKHR" ); + + return detail::createResultValueType( result, std::move( pipelineKey ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR * pInfo, + PipelineBinaryKeyKHR * pPipelineBinaryKey, + size_t * pPipelineBinaryDataSize, + void * pPipelineBinaryData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPipelineBinaryDataKHR( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pPipelineBinaryKey ), + pPipelineBinaryDataSize, + pPipelineBinaryData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>>::type + Device::getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineBinaryDataKHR && "Function requires " ); +# endif + + std::pair> data_; + PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first; + std::vector & pipelineBinaryData = data_.second; + size_t pipelineBinaryDataSize; + Result result = static_cast( d.vkGetPipelineBinaryDataKHR( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &pipelineBinaryKey ), + &pipelineBinaryDataSize, + nullptr ) ); + if ( result == Result::eSuccess ) + { + pipelineBinaryData.resize( pipelineBinaryDataSize ); + result = static_cast( d.vkGetPipelineBinaryDataKHR( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &pipelineBinaryKey ), + &pipelineBinaryDataSize, + reinterpret_cast( pipelineBinaryData.data() ) ) ); + } + + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>>::type + Device::getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPipelineBinaryDataKHR && "Function requires " ); +# endif + + std::pair> data_( + std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) ); + PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first; + std::vector & pipelineBinaryData = data_.second; + size_t pipelineBinaryDataSize; + Result result = static_cast( d.vkGetPipelineBinaryDataKHR( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &pipelineBinaryKey ), + &pipelineBinaryDataSize, + nullptr ) ); + if ( result == Result::eSuccess ) + { + pipelineBinaryData.resize( pipelineBinaryDataSize ); + result = static_cast( d.vkGetPipelineBinaryDataKHR( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &pipelineBinaryKey ), + &pipelineBinaryDataSize, + reinterpret_cast( pipelineBinaryData.data() ) ) ); + } + + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkReleaseCapturedPipelineDataKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR * pInfo, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkReleaseCapturedPipelineDataKHR( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pAllocator ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleaseCapturedPipelineDataKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::releaseCapturedPipelineDataKHR( + const ReleaseCapturedPipelineDataInfoKHR & info, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkReleaseCapturedPipelineDataKHR && "Function requires " ); +# endif + + Result result = static_cast( d.vkReleaseCapturedPipelineDataKHR( + m_device, reinterpret_cast( &info ), reinterpret_cast( allocator.get() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseCapturedPipelineDataKHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_QCOM_tile_properties === + + // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, + uint32_t * pPropertiesCount, + TilePropertiesQCOM * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetFramebufferTilePropertiesQCOM( static_cast( m_device ), + static_cast( framebuffer ), + pPropertiesCount, + reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetFramebufferTilePropertiesQCOM && "Function requires " ); +# endif + + std::vector properties; + uint32_t propertiesCount; + Result result; + do + { + result = static_cast( d.vkGetFramebufferTilePropertiesQCOM( m_device, static_cast( framebuffer ), &propertiesCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertiesCount ) + { + properties.resize( propertiesCount ); + result = static_cast( d.vkGetFramebufferTilePropertiesQCOM( + m_device, static_cast( framebuffer ), &propertiesCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFramebufferTilePropertiesQCOM" ); + VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); + if ( propertiesCount < properties.size() ) + { + properties.resize( propertiesCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, + TilePropertiesQCOMAllocator const & tilePropertiesQCOMAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetFramebufferTilePropertiesQCOM && "Function requires " ); +# endif + + std::vector properties( tilePropertiesQCOMAllocator ); + uint32_t propertiesCount; + Result result; + do + { + result = static_cast( d.vkGetFramebufferTilePropertiesQCOM( m_device, static_cast( framebuffer ), &propertiesCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertiesCount ) + { + properties.resize( propertiesCount ); + result = static_cast( d.vkGetFramebufferTilePropertiesQCOM( + m_device, static_cast( framebuffer ), &propertiesCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFramebufferTilePropertiesQCOM" ); + VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); + if ( propertiesCount < properties.size() ) + { + properties.resize( propertiesCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo * pRenderingInfo, + TilePropertiesQCOM * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDynamicRenderingTilePropertiesQCOM( static_cast( m_device ), + reinterpret_cast( pRenderingInfo ), + reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDynamicRenderingTilePropertiesQCOM && "Function requires " ); +# endif + + TilePropertiesQCOM properties; + Result result = static_cast( d.vkGetDynamicRenderingTilePropertiesQCOM( + m_device, reinterpret_cast( &renderingInfo ), reinterpret_cast( &properties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDynamicRenderingTilePropertiesQCOM" ); + + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_swapchain_maintenance1 === + + // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkReleaseSwapchainImagesKHR( static_cast( m_device ), reinterpret_cast( pReleaseInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkReleaseSwapchainImagesKHR && + "Function requires or " ); +# endif + + Result result = static_cast( d.vkReleaseSwapchainImagesKHR( m_device, reinterpret_cast( &releaseInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseSwapchainImagesKHR" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_cooperative_vector === + + // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeVectorPropertiesNV( uint32_t * pPropertyCount, + CooperativeVectorPropertiesNV * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( + static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCooperativeVectorPropertiesNV( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV && + "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeVectorPropertiesNV" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCooperativeVectorPropertiesNV( CooperativeVectorPropertiesNVAllocator const & cooperativeVectorPropertiesNVAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV && + "Function requires " ); +# endif + + std::vector properties( cooperativeVectorPropertiesNVAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeVectorPropertiesNV" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkConvertCooperativeVectorMatrixNV( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV & info, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkConvertCooperativeVectorMatrixNV && "Function requires " ); +# endif + + Result result = + static_cast( d.vkConvertCooperativeVectorMatrixNV( m_device, reinterpret_cast( &info ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::convertCooperativeVectorMatrixNV", { Result::eSuccess, Result::eIncomplete } ); + + return static_cast( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::convertCooperativeVectorMatrixNV( uint32_t infoCount, + const ConvertCooperativeVectorMatrixInfoNV * pInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdConvertCooperativeVectorMatrixNV( + static_cast( m_commandBuffer ), infoCount, reinterpret_cast( pInfos ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::convertCooperativeVectorMatrixNV( ArrayProxy const & infos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdConvertCooperativeVectorMatrixNV && "Function requires " ); +# endif + + d.vkCmdConvertCooperativeVectorMatrixNV( m_commandBuffer, infos.size(), reinterpret_cast( infos.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_low_latency2 === + + // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setLatencySleepModeNV( SwapchainKHR swapchain, + const LatencySleepModeInfoNV * pSleepModeInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkSetLatencySleepModeNV( + static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pSleepModeInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::setLatencySleepModeNV( SwapchainKHR swapchain, const LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetLatencySleepModeNV && "Function requires " ); +# endif + + Result result = static_cast( + d.vkSetLatencySleepModeNV( m_device, static_cast( swapchain ), reinterpret_cast( &sleepModeInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setLatencySleepModeNV" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::latencySleepNV( SwapchainKHR swapchain, + const LatencySleepInfoNV * pSleepInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkLatencySleepNV( + static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pSleepInfo ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::latencySleepNV( SwapchainKHR swapchain, const LatencySleepInfoNV & sleepInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkLatencySleepNV && "Function requires " ); +# endif + + Result result = static_cast( + d.vkLatencySleepNV( m_device, static_cast( swapchain ), reinterpret_cast( &sleepInfo ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::latencySleepNV" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::setLatencyMarkerNV( SwapchainKHR swapchain, const SetLatencyMarkerInfoNV * pLatencyMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkSetLatencyMarkerNV( + static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pLatencyMarkerInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::setLatencyMarkerNV( SwapchainKHR swapchain, const SetLatencyMarkerInfoNV & latencyMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkSetLatencyMarkerNV && "Function requires " ); +# endif + + d.vkSetLatencyMarkerNV( m_device, static_cast( swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::getLatencyTimingsNV( SwapchainKHR swapchain, GetLatencyMarkerInfoNV * pLatencyMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetLatencyTimingsNV( + static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pLatencyMarkerInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getLatencyTimingsNV( SwapchainKHR swapchain, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetLatencyTimingsNV && "Function requires " ); +# endif + + std::vector timings; + GetLatencyMarkerInfoNV latencyMarkerInfo; + d.vkGetLatencyTimingsNV( m_device, static_cast( swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); + timings.resize( latencyMarkerInfo.timingCount ); + latencyMarkerInfo.pTimings = timings.data(); + d.vkGetLatencyTimingsNV( m_device, static_cast( swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); + + return timings; + } + + // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Device::getLatencyTimingsNV( + SwapchainKHR swapchain, LatencyTimingsFrameReportNVAllocator const & latencyTimingsFrameReportNVAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetLatencyTimingsNV && "Function requires " ); +# endif + + std::vector timings( latencyTimingsFrameReportNVAllocator ); + GetLatencyMarkerInfoNV latencyMarkerInfo; + d.vkGetLatencyTimingsNV( m_device, static_cast( swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); + timings.resize( latencyMarkerInfo.timingCount ); + latencyMarkerInfo.pTimings = timings.data(); + d.vkGetLatencyTimingsNV( m_device, static_cast( swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); + + return timings; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html + template ::type> + VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV * pQueueTypeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkQueueNotifyOutOfBandNV( static_cast( m_queue ), reinterpret_cast( pQueueTypeInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html + template ::type> + VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkQueueNotifyOutOfBandNV && "Function requires " ); +# endif + + d.vkQueueNotifyOutOfBandNV( m_queue, reinterpret_cast( &queueTypeInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_cooperative_matrix === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesKHR( uint32_t * pPropertyCount, + CooperativeMatrixPropertiesKHR * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( + static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html + template < + typename CooperativeMatrixPropertiesKHRAllocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCooperativeMatrixPropertiesKHR( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR && + "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html + template < + typename CooperativeMatrixPropertiesKHRAllocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator const & cooperativeMatrixPropertiesKHRAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR && + "Function requires " ); +# endif + + std::vector properties( cooperativeMatrixPropertiesKHRAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_ARM_data_graph === + + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + uint32_t createInfoCount, + const DataGraphPipelineCreateInfoARM * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDataGraphPipelinesARM( static_cast( m_device ), + static_cast( deferredOperation ), + static_cast( pipelineCache ), + createInfoCount, + reinterpret_cast( pCreateInfos ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pPipelines ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARM", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); + Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARM", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + + return ResultValue>( result, std::move( pipelines ) ); + } + + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::createDataGraphPipelineARM( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + const DataGraphPipelineCreateInfoARM & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineARM", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue( result, std::move( pipeline ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARMUnique", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines; + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template >::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> + Device::createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); +# endif + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + detail::resultCheck( result, + VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARMUnique", + { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, + m_device, + pipelines, + allocator.get(), + d ); + std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); + uniquePipelines.reserve( createInfos.size() ); + detail::ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & pipeline : pipelines ) + { + uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); + } + return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); + } + + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + Device::createDataGraphPipelineARMUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + const DataGraphPipelineCreateInfoARM & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); +# endif + + Pipeline pipeline; + Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, + static_cast( deferredOperation ), + static_cast( pipelineCache ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + detail::resultCheck( + result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineARMUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + + return ResultValue>( + result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDataGraphPipelineSessionARM( const DataGraphPipelineSessionCreateInfoARM * pCreateInfo, + const AllocationCallbacks * pAllocator, + DataGraphPipelineSessionARM * pSession, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateDataGraphPipelineSessionARM( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSession ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createDataGraphPipelineSessionARM( + const DataGraphPipelineSessionCreateInfoARM & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelineSessionARM && "Function requires " ); +# endif + + DataGraphPipelineSessionARM session; + Result result = + static_cast( d.vkCreateDataGraphPipelineSessionARM( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &session ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineSessionARM" ); + + return detail::createResultValueType( result, std::move( session ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createDataGraphPipelineSessionARMUnique( const DataGraphPipelineSessionCreateInfoARM & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelineSessionARM && "Function requires " ); +# endif + + DataGraphPipelineSessionARM session; + Result result = + static_cast( d.vkCreateDataGraphPipelineSessionARM( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &session ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineSessionARMUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( session, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM * pInfo, + uint32_t * pBindPointRequirementCount, + DataGraphPipelineSessionBindPointRequirementARM * pBindPointRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM( + static_cast( m_device ), + reinterpret_cast( pInfo ), + pBindPointRequirementCount, + reinterpret_cast( pBindPointRequirements ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html + template ::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + Device::getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM & info, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM && + "Function requires " ); +# endif + + std::vector bindPointRequirements; + uint32_t bindPointRequirementCount; + Result result; + do + { + result = static_cast( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM( + m_device, reinterpret_cast( &info ), &bindPointRequirementCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && bindPointRequirementCount ) + { + bindPointRequirements.resize( bindPointRequirementCount ); + result = static_cast( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM( + m_device, + reinterpret_cast( &info ), + &bindPointRequirementCount, + reinterpret_cast( bindPointRequirements.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineSessionBindPointRequirementsARM" ); + VULKAN_HPP_ASSERT( bindPointRequirementCount <= bindPointRequirements.size() ); + if ( bindPointRequirementCount < bindPointRequirements.size() ) + { + bindPointRequirements.resize( bindPointRequirementCount ); + } + return detail::createResultValueType( result, std::move( bindPointRequirements ) ); + } + + // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html + template ::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + Device::getDataGraphPipelineSessionBindPointRequirementsARM( + const DataGraphPipelineSessionBindPointRequirementsInfoARM & info, + DataGraphPipelineSessionBindPointRequirementARMAllocator const & dataGraphPipelineSessionBindPointRequirementARMAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM && + "Function requires " ); +# endif + + std::vector bindPointRequirements( + dataGraphPipelineSessionBindPointRequirementARMAllocator ); + uint32_t bindPointRequirementCount; + Result result; + do + { + result = static_cast( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM( + m_device, reinterpret_cast( &info ), &bindPointRequirementCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && bindPointRequirementCount ) + { + bindPointRequirements.resize( bindPointRequirementCount ); + result = static_cast( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM( + m_device, + reinterpret_cast( &info ), + &bindPointRequirementCount, + reinterpret_cast( bindPointRequirements.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineSessionBindPointRequirementsARM" ); + VULKAN_HPP_ASSERT( bindPointRequirementCount <= bindPointRequirements.size() ); + if ( bindPointRequirementCount < bindPointRequirements.size() ) + { + bindPointRequirements.resize( bindPointRequirementCount ); + } + return detail::createResultValueType( result, std::move( bindPointRequirements ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html + template ::type> + VULKAN_HPP_INLINE void Device::getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetDataGraphPipelineSessionMemoryRequirementsARM( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getDataGraphPipelineSessionMemoryRequirementsARM( + const DataGraphPipelineSessionMemoryRequirementsInfoARM & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionMemoryRequirementsARM && + "Function requires " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetDataGraphPipelineSessionMemoryRequirementsARM( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionMemoryRequirementsARM && + "Function requires " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetDataGraphPipelineSessionMemoryRequirementsARM( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindDataGraphPipelineSessionMemoryARM( uint32_t bindInfoCount, + const BindDataGraphPipelineSessionMemoryInfoARM * pBindInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkBindDataGraphPipelineSessionMemoryARM( + static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html + template ::type> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type + Device::bindDataGraphPipelineSessionMemoryARM( ArrayProxy const & bindInfos, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkBindDataGraphPipelineSessionMemoryARM && "Function requires " ); +# endif + + Result result = static_cast( d.vkBindDataGraphPipelineSessionMemoryARM( + m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindDataGraphPipelineSessionMemoryARM" ); + + return detail::createResultValueType( result ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDataGraphPipelineSessionARM( + static_cast( m_device ), static_cast( session ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDataGraphPipelineSessionARM && "Function requires " ); +# endif + + d.vkDestroyDataGraphPipelineSessionARM( + m_device, static_cast( session ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( DataGraphPipelineSessionARM session, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyDataGraphPipelineSessionARM( + static_cast( m_device ), static_cast( session ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( DataGraphPipelineSessionARM session, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyDataGraphPipelineSessionARM && "Function requires " ); +# endif + + d.vkDestroyDataGraphPipelineSessionARM( + m_device, static_cast( session ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchDataGraphARM( DataGraphPipelineSessionARM session, + const DataGraphPipelineDispatchInfoARM * pInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDispatchDataGraphARM( static_cast( m_commandBuffer ), + static_cast( session ), + reinterpret_cast( pInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::dispatchDataGraphARM( DataGraphPipelineSessionARM session, + Optional info, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDispatchDataGraphARM && "Function requires " ); +# endif + + d.vkCmdDispatchDataGraphARM( + m_commandBuffer, static_cast( session ), reinterpret_cast( info.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, + uint32_t * pPropertiesCount, + DataGraphPipelinePropertyARM * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDataGraphPipelineAvailablePropertiesARM( static_cast( m_device ), + reinterpret_cast( pPipelineInfo ), + pPropertiesCount, + reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineAvailablePropertiesARM && + "Function requires " ); +# endif + + std::vector properties; + uint32_t propertiesCount; + Result result; + do + { + result = static_cast( d.vkGetDataGraphPipelineAvailablePropertiesARM( + m_device, reinterpret_cast( &pipelineInfo ), &propertiesCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertiesCount ) + { + properties.resize( propertiesCount ); + result = + static_cast( d.vkGetDataGraphPipelineAvailablePropertiesARM( m_device, + reinterpret_cast( &pipelineInfo ), + &propertiesCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineAvailablePropertiesARM" ); + VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); + if ( propertiesCount < properties.size() ) + { + properties.resize( propertiesCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo, + DataGraphPipelinePropertyARMAllocator const & dataGraphPipelinePropertyARMAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineAvailablePropertiesARM && + "Function requires " ); +# endif + + std::vector properties( dataGraphPipelinePropertyARMAllocator ); + uint32_t propertiesCount; + Result result; + do + { + result = static_cast( d.vkGetDataGraphPipelineAvailablePropertiesARM( + m_device, reinterpret_cast( &pipelineInfo ), &propertiesCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertiesCount ) + { + properties.resize( propertiesCount ); + result = + static_cast( d.vkGetDataGraphPipelineAvailablePropertiesARM( m_device, + reinterpret_cast( &pipelineInfo ), + &propertiesCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineAvailablePropertiesARM" ); + VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); + if ( propertiesCount < properties.size() ) + { + properties.resize( propertiesCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDataGraphPipelinePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelinePropertiesARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDataGraphPipelinePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, + uint32_t propertiesCount, + DataGraphPipelinePropertyQueryResultARM * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetDataGraphPipelinePropertiesARM( static_cast( m_device ), + reinterpret_cast( pPipelineInfo ), + propertiesCount, + reinterpret_cast( pProperties ) ) ); + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, + uint32_t * pQueueFamilyDataGraphPropertyCount, + QueueFamilyDataGraphPropertiesARM * pQueueFamilyDataGraphProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( static_cast( m_physicalDevice ), + queueFamilyIndex, + pQueueFamilyDataGraphPropertyCount, + reinterpret_cast( pQueueFamilyDataGraphProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html + template < + typename QueueFamilyDataGraphPropertiesARMAllocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM && + "Function requires " ); +# endif + + std::vector queueFamilyDataGraphProperties; + uint32_t queueFamilyDataGraphPropertyCount; + Result result; + do + { + result = static_cast( + d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( m_physicalDevice, queueFamilyIndex, &queueFamilyDataGraphPropertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && queueFamilyDataGraphPropertyCount ) + { + queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); + result = static_cast( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( + m_physicalDevice, + queueFamilyIndex, + &queueFamilyDataGraphPropertyCount, + reinterpret_cast( queueFamilyDataGraphProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getQueueFamilyDataGraphPropertiesARM" ); + VULKAN_HPP_ASSERT( queueFamilyDataGraphPropertyCount <= queueFamilyDataGraphProperties.size() ); + if ( queueFamilyDataGraphPropertyCount < queueFamilyDataGraphProperties.size() ) + { + queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); + } + return detail::createResultValueType( result, std::move( queueFamilyDataGraphProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html + template < + typename QueueFamilyDataGraphPropertiesARMAllocator, + typename Dispatch, + typename std::enable_if::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, + QueueFamilyDataGraphPropertiesARMAllocator const & queueFamilyDataGraphPropertiesARMAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM && + "Function requires " ); +# endif + + std::vector queueFamilyDataGraphProperties( + queueFamilyDataGraphPropertiesARMAllocator ); + uint32_t queueFamilyDataGraphPropertyCount; + Result result; + do + { + result = static_cast( + d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( m_physicalDevice, queueFamilyIndex, &queueFamilyDataGraphPropertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && queueFamilyDataGraphPropertyCount ) + { + queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); + result = static_cast( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( + m_physicalDevice, + queueFamilyIndex, + &queueFamilyDataGraphPropertyCount, + reinterpret_cast( queueFamilyDataGraphProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getQueueFamilyDataGraphPropertiesARM" ); + VULKAN_HPP_ASSERT( queueFamilyDataGraphPropertyCount <= queueFamilyDataGraphProperties.size() ); + if ( queueFamilyDataGraphPropertyCount < queueFamilyDataGraphProperties.size() ) + { + queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); + } + return detail::createResultValueType( result, std::move( queueFamilyDataGraphProperties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html + template ::type> + VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyDataGraphProcessingEnginePropertiesARM( + const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM * pQueueFamilyDataGraphProcessingEngineInfo, + QueueFamilyDataGraphProcessingEnginePropertiesARM * pQueueFamilyDataGraphProcessingEngineProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( + static_cast( m_physicalDevice ), + reinterpret_cast( pQueueFamilyDataGraphProcessingEngineInfo ), + reinterpret_cast( pQueueFamilyDataGraphProcessingEngineProperties ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE QueueFamilyDataGraphProcessingEnginePropertiesARM PhysicalDevice::getQueueFamilyDataGraphProcessingEnginePropertiesARM( + const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & queueFamilyDataGraphProcessingEngineInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM && + "Function requires " ); +# endif + + QueueFamilyDataGraphProcessingEnginePropertiesARM queueFamilyDataGraphProcessingEngineProperties; + d.vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( + m_physicalDevice, + reinterpret_cast( &queueFamilyDataGraphProcessingEngineInfo ), + reinterpret_cast( &queueFamilyDataGraphProcessingEngineProperties ) ); + + return queueFamilyDataGraphProcessingEngineProperties; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + + // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setAttachmentFeedbackLoopEnableEXT( ImageAspectFlags aspectMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetAttachmentFeedbackLoopEnableEXT( static_cast( m_commandBuffer ), static_cast( aspectMask ) ); + } + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer, + ScreenBufferPropertiesQNX * pProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkGetScreenBufferPropertiesQNX( static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetScreenBufferPropertiesQNX && "Function requires " ); +# endif + + ScreenBufferPropertiesQNX properties; + Result result = + static_cast( d.vkGetScreenBufferPropertiesQNX( m_device, &buffer, reinterpret_cast( &properties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); + + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetScreenBufferPropertiesQNX && "Function requires " ); +# endif + + StructureChain structureChain; + ScreenBufferPropertiesQNX & properties = structureChain.template get(); + Result result = + static_cast( d.vkGetScreenBufferPropertiesQNX( m_device, &buffer, reinterpret_cast( &properties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); + + return detail::createResultValueType( result, std::move( structureChain ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_KHR_line_rasterization === + + // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetLineStippleKHR( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); + } + + //=== VK_KHR_calibrated_timestamps === + + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount, + TimeDomainKHR * pTimeDomains, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( + static_cast( m_physicalDevice ), pTimeDomainCount, reinterpret_cast( pTimeDomains ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCalibrateableTimeDomainsKHR( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR && + "Function requires or " ); +# endif + + std::vector timeDomains; + uint32_t timeDomainCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && timeDomainCount ) + { + timeDomains.resize( timeDomainCount ); + result = static_cast( + d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" ); + VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); + if ( timeDomainCount < timeDomains.size() ) + { + timeDomains.resize( timeDomainCount ); + } + return detail::createResultValueType( result, std::move( timeDomains ) ); + } + + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator const & timeDomainKHRAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR && + "Function requires or " ); +# endif + + std::vector timeDomains( timeDomainKHRAllocator ); + uint32_t timeDomainCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && timeDomainCount ) + { + timeDomains.resize( timeDomainCount ); + result = static_cast( + d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" ); + VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); + if ( timeDomainCount < timeDomains.size() ) + { + timeDomains.resize( timeDomainCount ); + } + return detail::createResultValueType( result, std::move( timeDomains ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsKHR( uint32_t timestampCount, + const CalibratedTimestampInfoKHR * pTimestampInfos, + uint64_t * pTimestamps, + uint64_t * pMaxDeviation, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetCalibratedTimestampsKHR( static_cast( m_device ), + timestampCount, + reinterpret_cast( pTimestampInfos ), + pTimestamps, + pMaxDeviation ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type + Device::getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR && + "Function requires or " ); +# endif + + std::pair, uint64_t> data_( + std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); + std::vector & timestamps = data_.first; + uint64_t & maxDeviation = data_.second; + Result result = static_cast( d.vkGetCalibratedTimestampsKHR( + m_device, timestampInfos.size(), reinterpret_cast( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + template ::value, int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type + Device::getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos, + Uint64_tAllocator const & uint64_tAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR && + "Function requires or " ); +# endif + + std::pair, uint64_t> data_( + std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) ); + std::vector & timestamps = data_.first; + uint64_t & maxDeviation = data_.second; + Result result = static_cast( d.vkGetCalibratedTimestampsKHR( + m_device, timestampInfos.size(), reinterpret_cast( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getCalibratedTimestampKHR( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR && + "Function requires or " ); +# endif + + std::pair data_; + uint64_t & timestamp = data_.first; + uint64_t & maxDeviation = data_.second; + Result result = static_cast( + d.vkGetCalibratedTimestampsKHR( m_device, 1, reinterpret_cast( ×tampInfo ), ×tamp, &maxDeviation ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" ); + + return detail::createResultValueType( result, std::move( data_ ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_maintenance6 === + + // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2KHR( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindDescriptorSets2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( pBindDescriptorSetsInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2KHR( const BindDescriptorSetsInfo & bindDescriptorSetsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets2KHR && "Function requires or " ); +# endif + + d.vkCmdBindDescriptorSets2KHR( m_commandBuffer, reinterpret_cast( &bindDescriptorSetsInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const PushConstantsInfo * pPushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushConstants2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pPushConstantsInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const PushConstantsInfo & pushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPushConstants2KHR && "Function requires or " ); +# endif + + d.vkCmdPushConstants2KHR( m_commandBuffer, reinterpret_cast( &pushConstantsInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2KHR( const PushDescriptorSetInfo * pPushDescriptorSetInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushDescriptorSet2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( pPushDescriptorSetInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2KHR( const PushDescriptorSetInfo & pushDescriptorSetInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSet2KHR && "Function requires or " ); +# endif + + d.vkCmdPushDescriptorSet2KHR( m_commandBuffer, reinterpret_cast( &pushDescriptorSetInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPushDescriptorSetWithTemplate2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( pPushDescriptorSetWithTemplateInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetWithTemplate2KHR && + "Function requires or " ); +# endif + + d.vkCmdPushDescriptorSetWithTemplate2KHR( m_commandBuffer, + reinterpret_cast( &pushDescriptorSetWithTemplateInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetDescriptorBufferOffsets2EXT( static_cast( m_commandBuffer ), + reinterpret_cast( pSetDescriptorBufferOffsetsInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetDescriptorBufferOffsets2EXT && "Function requires " ); +# endif + + d.vkCmdSetDescriptorBufferOffsets2EXT( m_commandBuffer, reinterpret_cast( &setDescriptorBufferOffsetsInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + static_cast( m_commandBuffer ), + reinterpret_cast( pBindDescriptorBufferEmbeddedSamplersInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html + template ::type> + VULKAN_HPP_INLINE void + CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT && + "Function requires " ); +# endif + + d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + m_commandBuffer, reinterpret_cast( &bindDescriptorBufferEmbeddedSamplersInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_QCOM_tile_memory_heap === + + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( const TileMemoryBindInfoQCOM * pTileMemoryBindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindTileMemoryQCOM( static_cast( m_commandBuffer ), reinterpret_cast( pTileMemoryBindInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( Optional tileMemoryBindInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBindTileMemoryQCOM && "Function requires " ); +# endif + + d.vkCmdBindTileMemoryQCOM( m_commandBuffer, reinterpret_cast( tileMemoryBindInfo.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_copy_memory_indirect === + + // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyMemoryIndirectKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pCopyMemoryIndirectInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryIndirectKHR && "Function requires " ); +# endif + + d.vkCmdCopyMemoryIndirectKHR( m_commandBuffer, reinterpret_cast( ©MemoryIndirectInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdCopyMemoryToImageIndirectKHR( static_cast( m_commandBuffer ), + reinterpret_cast( pCopyMemoryToImageIndirectInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToImageIndirectKHR && "Function requires " ); +# endif + + d.vkCmdCopyMemoryToImageIndirectKHR( m_commandBuffer, reinterpret_cast( ©MemoryToImageIndirectInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_memory_decompression === + + // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryEXT( const DecompressMemoryInfoEXT * pDecompressMemoryInfoEXT, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDecompressMemoryEXT( static_cast( m_commandBuffer ), + reinterpret_cast( pDecompressMemoryInfoEXT ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryEXT( const DecompressMemoryInfoEXT & decompressMemoryInfoEXT, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdDecompressMemoryEXT && "Function requires " ); +# endif + + d.vkCmdDecompressMemoryEXT( m_commandBuffer, reinterpret_cast( &decompressMemoryInfoEXT ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDecompressMemoryIndirectCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod, + DeviceAddress indirectCommandsAddress, + DeviceAddress indirectCommandsCountAddress, + uint32_t maxDecompressionCount, + uint32_t stride, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDecompressMemoryIndirectCountEXT( static_cast( m_commandBuffer ), + static_cast( decompressionMethod ), + static_cast( indirectCommandsAddress ), + static_cast( indirectCommandsCountAddress ), + maxDecompressionCount, + stride ); + } + + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createExternalComputeQueueNV( const ExternalComputeQueueCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + ExternalComputeQueueNV * pExternalQueue, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateExternalComputeQueueNV( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pExternalQueue ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createExternalComputeQueueNV( + const ExternalComputeQueueCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateExternalComputeQueueNV && "Function requires " ); +# endif + + ExternalComputeQueueNV externalQueue; + Result result = static_cast( d.vkCreateExternalComputeQueueNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &externalQueue ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExternalComputeQueueNV" ); + + return detail::createResultValueType( result, std::move( externalQueue ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createExternalComputeQueueNVUnique( const ExternalComputeQueueCreateInfoNV & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateExternalComputeQueueNV && "Function requires " ); +# endif + + ExternalComputeQueueNV externalQueue; + Result result = static_cast( d.vkCreateExternalComputeQueueNV( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &externalQueue ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExternalComputeQueueNVUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( externalQueue, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyExternalComputeQueueNV( static_cast( m_device ), + static_cast( externalQueue ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyExternalComputeQueueNV && "Function requires " ); +# endif + + d.vkDestroyExternalComputeQueueNV( + m_device, static_cast( externalQueue ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( ExternalComputeQueueNV externalQueue, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyExternalComputeQueueNV( static_cast( m_device ), + static_cast( externalQueue ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( ExternalComputeQueueNV externalQueue, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyExternalComputeQueueNV && "Function requires " ); +# endif + + d.vkDestroyExternalComputeQueueNV( + m_device, static_cast( externalQueue ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template ::type> + VULKAN_HPP_INLINE void + ExternalComputeQueueNV::getData( ExternalComputeQueueDataParamsNV * params, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetExternalComputeQueueDataNV( + static_cast( m_externalComputeQueueNV ), reinterpret_cast( params ), pData ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair + ExternalComputeQueueNV::getData( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetExternalComputeQueueDataNV && "Function requires " ); +# endif + + std::pair data_; + ExternalComputeQueueDataParamsNV & arams = data_.first; + DataType & data = data_.second; + d.vkGetExternalComputeQueueDataNV( m_externalComputeQueueNV, reinterpret_cast( &arams ), &data ); + + return data_; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_cluster_acceleration_structure === + + // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html + template ::type> + VULKAN_HPP_INLINE void Device::getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV * pInfo, + AccelerationStructureBuildSizesInfoKHR * pSizeInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetClusterAccelerationStructureBuildSizesNV( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pSizeInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR + Device::getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetClusterAccelerationStructureBuildSizesNV && + "Function requires " ); +# endif + + AccelerationStructureBuildSizesInfoKHR sizeInfo; + d.vkGetClusterAccelerationStructureBuildSizesNV( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &sizeInfo ) ); + + return sizeInfo; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV * pCommandInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBuildClusterAccelerationStructureIndirectNV( static_cast( m_commandBuffer ), + reinterpret_cast( pCommandInfos ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV & commandInfos, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBuildClusterAccelerationStructureIndirectNV && + "Function requires " ); +# endif + + d.vkCmdBuildClusterAccelerationStructureIndirectNV( m_commandBuffer, + reinterpret_cast( &commandInfos ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_partitioned_acceleration_structure === + + // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html + template ::type> + VULKAN_HPP_INLINE void Device::getPartitionedAccelerationStructuresBuildSizesNV( const PartitionedAccelerationStructureInstancesInputNV * pInfo, + AccelerationStructureBuildSizesInfoKHR * pSizeInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetPartitionedAccelerationStructuresBuildSizesNV( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pSizeInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR Device::getPartitionedAccelerationStructuresBuildSizesNV( + const PartitionedAccelerationStructureInstancesInputNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPartitionedAccelerationStructuresBuildSizesNV && + "Function requires " ); +# endif + + AccelerationStructureBuildSizesInfoKHR sizeInfo; + d.vkGetPartitionedAccelerationStructuresBuildSizesNV( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &sizeInfo ) ); + + return sizeInfo; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV * pBuildInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBuildPartitionedAccelerationStructuresNV( static_cast( m_commandBuffer ), + reinterpret_cast( pBuildInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV & buildInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBuildPartitionedAccelerationStructuresNV && + "Function requires " ); +# endif + + d.vkCmdBuildPartitionedAccelerationStructuresNV( m_commandBuffer, reinterpret_cast( &buildInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_device_generated_commands === + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetGeneratedCommandsMemoryRequirementsEXT( static_cast( m_device ), + reinterpret_cast( pInfo ), + reinterpret_cast( pMemoryRequirements ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsEXT && + "Function requires " ); +# endif + + MemoryRequirements2 memoryRequirements; + d.vkGetGeneratedCommandsMemoryRequirementsEXT( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsEXT && + "Function requires " ); +# endif + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + d.vkGetGeneratedCommandsMemoryRequirementsEXT( m_device, + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo, + CommandBuffer stateCommandBuffer, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdPreprocessGeneratedCommandsEXT( static_cast( m_commandBuffer ), + reinterpret_cast( pGeneratedCommandsInfo ), + static_cast( stateCommandBuffer ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT & generatedCommandsInfo, + CommandBuffer stateCommandBuffer, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdPreprocessGeneratedCommandsEXT && "Function requires " ); +# endif + + d.vkCmdPreprocessGeneratedCommandsEXT( + m_commandBuffer, reinterpret_cast( &generatedCommandsInfo ), static_cast( stateCommandBuffer ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsEXT( Bool32 isPreprocessed, + const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdExecuteGeneratedCommandsEXT( static_cast( m_commandBuffer ), + static_cast( isPreprocessed ), + reinterpret_cast( pGeneratedCommandsInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsEXT( Bool32 isPreprocessed, + const GeneratedCommandsInfoEXT & generatedCommandsInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdExecuteGeneratedCommandsEXT && "Function requires " ); +# endif + + d.vkCmdExecuteGeneratedCommandsEXT( + m_commandBuffer, static_cast( isPreprocessed ), reinterpret_cast( &generatedCommandsInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutEXT( const IndirectCommandsLayoutCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + IndirectCommandsLayoutEXT * pIndirectCommandsLayout, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateIndirectCommandsLayoutEXT( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pIndirectCommandsLayout ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createIndirectCommandsLayoutEXT( + const IndirectCommandsLayoutCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutEXT && "Function requires " ); +# endif + + IndirectCommandsLayoutEXT indirectCommandsLayout; + Result result = static_cast( d.vkCreateIndirectCommandsLayoutEXT( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &indirectCommandsLayout ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutEXT" ); + + return detail::createResultValueType( result, std::move( indirectCommandsLayout ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createIndirectCommandsLayoutEXTUnique( const IndirectCommandsLayoutCreateInfoEXT & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutEXT && "Function requires " ); +# endif + + IndirectCommandsLayoutEXT indirectCommandsLayout; + Result result = static_cast( d.vkCreateIndirectCommandsLayoutEXT( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &indirectCommandsLayout ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutEXTUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( indirectCommandsLayout, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyIndirectCommandsLayoutEXT( static_cast( m_device ), + static_cast( indirectCommandsLayout ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutEXT && "Function requires " ); +# endif + + d.vkDestroyIndirectCommandsLayoutEXT( + m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( IndirectCommandsLayoutEXT indirectCommandsLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyIndirectCommandsLayoutEXT( static_cast( m_device ), + static_cast( indirectCommandsLayout ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutEXT indirectCommandsLayout, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutEXT && "Function requires " ); +# endif + + d.vkDestroyIndirectCommandsLayoutEXT( + m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createIndirectExecutionSetEXT( const IndirectExecutionSetCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + IndirectExecutionSetEXT * pIndirectExecutionSet, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateIndirectExecutionSetEXT( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pIndirectExecutionSet ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createIndirectExecutionSetEXT( + const IndirectExecutionSetCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateIndirectExecutionSetEXT && "Function requires " ); +# endif + + IndirectExecutionSetEXT indirectExecutionSet; + Result result = static_cast( d.vkCreateIndirectExecutionSetEXT( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &indirectExecutionSet ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectExecutionSetEXT" ); + + return detail::createResultValueType( result, std::move( indirectExecutionSet ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createIndirectExecutionSetEXTUnique( const IndirectExecutionSetCreateInfoEXT & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateIndirectExecutionSetEXT && "Function requires " ); +# endif + + IndirectExecutionSetEXT indirectExecutionSet; + Result result = static_cast( d.vkCreateIndirectExecutionSetEXT( m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &indirectExecutionSet ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectExecutionSetEXTUnique" ); + + return detail::createResultValueType( + result, UniqueHandle( indirectExecutionSet, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet, + const AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyIndirectExecutionSetEXT( static_cast( m_device ), + static_cast( indirectExecutionSet ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyIndirectExecutionSetEXT && "Function requires " ); +# endif + + d.vkDestroyIndirectExecutionSetEXT( + m_device, static_cast( indirectExecutionSet ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( IndirectExecutionSetEXT indirectExecutionSet, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyIndirectExecutionSetEXT( static_cast( m_device ), + static_cast( indirectExecutionSet ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html + template ::type> + VULKAN_HPP_INLINE void + Device::destroy( IndirectExecutionSetEXT indirectExecutionSet, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyIndirectExecutionSetEXT && "Function requires " ); +# endif + + d.vkDestroyIndirectExecutionSetEXT( + m_device, static_cast( indirectExecutionSet ), reinterpret_cast( allocator.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const WriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkUpdateIndirectExecutionSetPipelineEXT( static_cast( m_device ), + static_cast( indirectExecutionSet ), + executionSetWriteCount, + reinterpret_cast( pExecutionSetWrites ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet, + ArrayProxy const & executionSetWrites, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkUpdateIndirectExecutionSetPipelineEXT && + "Function requires " ); +# endif + + d.vkUpdateIndirectExecutionSetPipelineEXT( m_device, + static_cast( indirectExecutionSet ), + executionSetWrites.size(), + reinterpret_cast( executionSetWrites.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const WriteIndirectExecutionSetShaderEXT * pExecutionSetWrites, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkUpdateIndirectExecutionSetShaderEXT( static_cast( m_device ), + static_cast( indirectExecutionSet ), + executionSetWriteCount, + reinterpret_cast( pExecutionSetWrites ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html + template ::type> + VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet, + ArrayProxy const & executionSetWrites, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkUpdateIndirectExecutionSetShaderEXT && + "Function requires " ); +# endif + + d.vkUpdateIndirectExecutionSetShaderEXT( m_device, + static_cast( indirectExecutionSet ), + executionSetWrites.size(), + reinterpret_cast( executionSetWrites.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + + // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createSurfaceOHOS( const SurfaceCreateInfoOHOS * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateSurfaceOHOS( static_cast( m_instance ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pSurface ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createSurfaceOHOS( const SurfaceCreateInfoOHOS & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSurfaceOHOS && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateSurfaceOHOS( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createSurfaceOHOS" ); + + return detail::createResultValueType( result, std::move( surface ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::createSurfaceOHOSUnique( const SurfaceCreateInfoOHOS & createInfo, Optional allocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateSurfaceOHOS && "Function requires " ); +# endif + + SurfaceKHR surface; + Result result = static_cast( d.vkCreateSurfaceOHOS( m_instance, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createSurfaceOHOSUnique" ); + + return detail::createResultValueType( result, + UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_NV_cooperative_matrix2 === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV( + uint32_t * pPropertyCount, CooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( + static_cast( m_physicalDevice ), + pPropertyCount, + reinterpret_cast( pProperties ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html + template ::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV( Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV && + "Function requires " ); +# endif + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html + template ::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType>::type + PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV( + CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator const & cooperativeMatrixFlexibleDimensionsPropertiesNVAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV && + "Function requires " ); +# endif + + std::vector properties( + cooperativeMatrixFlexibleDimensionsPropertiesNVAllocator ); + uint32_t propertyCount; + Result result; + do + { + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( + m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return detail::createResultValueType( result, std::move( properties ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + + // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo, + void ** pHandle, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetMemoryMetalHandleEXT( + static_cast( m_device ), reinterpret_cast( pGetMetalHandleInfo ), pHandle ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT & getMetalHandleInfo, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryMetalHandleEXT && "Function requires " ); +# endif + + void * handle; + Result result = + static_cast( d.vkGetMemoryMetalHandleEXT( m_device, reinterpret_cast( &getMetalHandleInfo ), &handle ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryMetalHandleEXT" ); + + return detail::createResultValueType( result, std::move( handle ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, + const void * pHandle, + MemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetMemoryMetalHandlePropertiesEXT( static_cast( m_device ), + static_cast( handleType ), + pHandle, + reinterpret_cast( pMemoryMetalHandleProperties ) ) ); + } + +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetMemoryMetalHandlePropertiesEXT && "Function requires " ); +# endif + + MemoryMetalHandlePropertiesEXT memoryMetalHandleProperties; + Result result = + static_cast( d.vkGetMemoryMetalHandlePropertiesEXT( m_device, + static_cast( handleType ), + reinterpret_cast( &handle ), + reinterpret_cast( &memoryMetalHandleProperties ) ) ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryMetalHandlePropertiesEXT" ); + + return detail::createResultValueType( result, std::move( memoryMetalHandleProperties ) ); + } +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_ARM_performance_counters_by_region === + + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html + template ::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, + uint32_t * pCounterCount, + PerformanceCounterARM * pCounters, + PerformanceCounterDescriptionARM * pCounterDescriptions, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( + d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( static_cast( m_physicalDevice ), + queueFamilyIndex, + pCounterCount, + reinterpret_cast( pCounters ), + reinterpret_cast( pCounterDescriptions ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html + template ::value && + std::is_same::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, + std::vector>>::type + PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM && + "Function requires " ); +# endif + + std::pair, + std::vector> + data_; + std::vector & counters = data_.first; + std::vector & counterDescriptions = data_.second; + uint32_t counterCount; + Result result; + do + { + result = static_cast( + d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); + if ( ( result == Result::eSuccess ) && counterCount ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( + m_physicalDevice, + queueFamilyIndex, + &counterCount, + reinterpret_cast( counters.data() ), + reinterpret_cast( counterDescriptions.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM" ); + VULKAN_HPP_ASSERT( counterCount <= counters.size() ); + if ( counterCount < counters.size() ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + } + return detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html + template ::value && + std::is_same::value, + int>::type, + typename std::enable_if::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, + std::vector>>::type + PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM( + uint32_t queueFamilyIndex, + PerformanceCounterARMAllocator const & performanceCounterARMAllocator, + PerformanceCounterDescriptionARMAllocator const & performanceCounterDescriptionARMAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM && + "Function requires " ); +# endif + + std::pair, + std::vector> + data_( + std::piecewise_construct, std::forward_as_tuple( performanceCounterARMAllocator ), std::forward_as_tuple( performanceCounterDescriptionARMAllocator ) ); + std::vector & counters = data_.first; + std::vector & counterDescriptions = data_.second; + uint32_t counterCount; + Result result; + do + { + result = static_cast( + d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); + if ( ( result == Result::eSuccess ) && counterCount ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( + m_physicalDevice, + queueFamilyIndex, + &counterCount, + reinterpret_cast( counters.data() ), + reinterpret_cast( counterDescriptions.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM" ); + VULKAN_HPP_ASSERT( counterCount <= counters.size() ); + if ( counterCount < counters.size() ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + } + return detail::createResultValueType( result, std::move( data_ ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_fragment_density_map_offset === + + // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( const RenderingEndInfoKHR * pRenderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndRendering2EXT( static_cast( m_commandBuffer ), reinterpret_cast( pRenderingEndInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( Optional renderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdEndRendering2EXT && "Function requires or " ); +# endif + + d.vkCmdEndRendering2EXT( m_commandBuffer, reinterpret_cast( renderingEndInfo.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_custom_resolve === + + // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginCustomResolveEXT( const BeginCustomResolveInfoEXT * pBeginCustomResolveInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginCustomResolveEXT( static_cast( m_commandBuffer ), + reinterpret_cast( pBeginCustomResolveInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::beginCustomResolveEXT( Optional beginCustomResolveInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginCustomResolveEXT && "Function requires " ); +# endif + + d.vkCmdBeginCustomResolveEXT( m_commandBuffer, reinterpret_cast( beginCustomResolveInfo.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_maintenance10 === + + // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endRendering2KHR( const RenderingEndInfoKHR * pRenderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndRendering2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pRenderingEndInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::endRendering2KHR( Optional renderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdEndRendering2KHR && "Function requires or " ); +# endif + + d.vkCmdEndRendering2KHR( m_commandBuffer, reinterpret_cast( renderingEndInfo.get() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_compute_occupancy_priority === + + // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV * pParameters, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdSetComputeOccupancyPriorityNV( static_cast( m_commandBuffer ), + reinterpret_cast( pParameters ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html + template ::type> + VULKAN_HPP_INLINE void CommandBuffer::setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV & parameters, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdSetComputeOccupancyPriorityNV && "Function requires " ); +# endif + + d.vkCmdSetComputeOccupancyPriorityNV( m_commandBuffer, reinterpret_cast( ¶meters ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +} // namespace VULKAN_HPP_NAMESPACE +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_ggp.h b/lib/vulkan-headers/include/vulkan/vulkan_ggp.h new file mode 100644 index 00000000000..f8a48ec8769 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_ggp.h @@ -0,0 +1,62 @@ +#ifndef VULKAN_GGP_H_ +#define VULKAN_GGP_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_GGP_stream_descriptor_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_GGP_stream_descriptor_surface 1 +#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1 +#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME "VK_GGP_stream_descriptor_surface" +typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP; +typedef struct VkStreamDescriptorSurfaceCreateInfoGGP { + VkStructureType sType; + const void* pNext; + VkStreamDescriptorSurfaceCreateFlagsGGP flags; + GgpStreamDescriptor streamDescriptor; +} VkStreamDescriptorSurfaceCreateInfoGGP; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP( + VkInstance instance, + const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif + + +// VK_GGP_frame_token is a preprocessor guard. Do not pass it to API calls. +#define VK_GGP_frame_token 1 +#define VK_GGP_FRAME_TOKEN_SPEC_VERSION 1 +#define VK_GGP_FRAME_TOKEN_EXTENSION_NAME "VK_GGP_frame_token" +typedef struct VkPresentFrameTokenGGP { + VkStructureType sType; + const void* pNext; + GgpFrameToken frameToken; +} VkPresentFrameTokenGGP; + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_handles.hpp b/lib/vulkan-headers/include/vulkan/vulkan_handles.hpp new file mode 100644 index 00000000000..3ca8da889cd --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_handles.hpp @@ -0,0 +1,22749 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_HANDLES_HPP +#define VULKAN_HANDLES_HPP + +// include-what-you-use: make sure, vulkan.hpp is used by code-completers +// IWYU pragma: private, include "vulkan/vulkan.hpp" + +namespace VULKAN_HPP_NAMESPACE +{ + + //=================================== + //=== STRUCT forward declarations === + //=================================== + + //=== VK_VERSION_1_0 === + struct Extent2D; + struct Extent3D; + struct Offset2D; + struct Offset3D; + struct Rect2D; + struct BaseInStructure; + struct BaseOutStructure; + struct BufferMemoryBarrier; + struct ImageMemoryBarrier; + struct MemoryBarrier; + struct AllocationCallbacks; + struct ApplicationInfo; + struct FormatProperties; + struct ImageFormatProperties; + struct InstanceCreateInfo; + struct MemoryHeap; + struct MemoryType; + struct PhysicalDeviceFeatures; + struct PhysicalDeviceLimits; + struct PhysicalDeviceMemoryProperties; + struct PhysicalDeviceProperties; + struct PhysicalDeviceSparseProperties; + struct QueueFamilyProperties; + struct DeviceCreateInfo; + struct DeviceQueueCreateInfo; + struct ExtensionProperties; + struct LayerProperties; + struct SubmitInfo; + struct MappedMemoryRange; + struct MemoryAllocateInfo; + struct MemoryRequirements; + struct BindSparseInfo; + struct ImageSubresource; + struct SparseBufferMemoryBindInfo; + struct SparseImageFormatProperties; + struct SparseImageMemoryBind; + struct SparseImageMemoryBindInfo; + struct SparseImageMemoryRequirements; + struct SparseImageOpaqueMemoryBindInfo; + struct SparseMemoryBind; + struct FenceCreateInfo; + struct SemaphoreCreateInfo; + struct QueryPoolCreateInfo; + struct BufferCreateInfo; + struct ImageCreateInfo; + struct SubresourceLayout; + struct ComponentMapping; + struct ImageSubresourceRange; + struct ImageViewCreateInfo; + struct CommandPoolCreateInfo; + struct CommandBufferAllocateInfo; + struct CommandBufferBeginInfo; + struct CommandBufferInheritanceInfo; + struct BufferCopy; + struct BufferImageCopy; + struct ImageCopy; + struct ImageSubresourceLayers; + struct DispatchIndirectCommand; + struct PipelineCacheHeaderVersionOne; + struct EventCreateInfo; + struct BufferViewCreateInfo; + struct ShaderModuleCreateInfo; + struct PipelineCacheCreateInfo; + struct ComputePipelineCreateInfo; + struct PipelineShaderStageCreateInfo; + struct SpecializationInfo; + struct SpecializationMapEntry; + struct PipelineLayoutCreateInfo; + struct PushConstantRange; + struct SamplerCreateInfo; + struct CopyDescriptorSet; + struct DescriptorBufferInfo; + struct DescriptorImageInfo; + struct DescriptorPoolCreateInfo; + struct DescriptorPoolSize; + struct DescriptorSetAllocateInfo; + struct DescriptorSetLayoutBinding; + struct DescriptorSetLayoutCreateInfo; + struct WriteDescriptorSet; + union ClearColorValue; + struct DrawIndexedIndirectCommand; + struct DrawIndirectCommand; + struct GraphicsPipelineCreateInfo; + struct PipelineColorBlendAttachmentState; + struct PipelineColorBlendStateCreateInfo; + struct PipelineDepthStencilStateCreateInfo; + struct PipelineDynamicStateCreateInfo; + struct PipelineInputAssemblyStateCreateInfo; + struct PipelineMultisampleStateCreateInfo; + struct PipelineRasterizationStateCreateInfo; + struct PipelineTessellationStateCreateInfo; + struct PipelineVertexInputStateCreateInfo; + struct PipelineViewportStateCreateInfo; + struct StencilOpState; + struct VertexInputAttributeDescription; + struct VertexInputBindingDescription; + struct Viewport; + struct AttachmentDescription; + struct AttachmentReference; + struct FramebufferCreateInfo; + struct RenderPassCreateInfo; + struct SubpassDependency; + struct SubpassDescription; + struct ClearAttachment; + struct ClearDepthStencilValue; + struct ClearRect; + union ClearValue; + struct ImageBlit; + struct ImageResolve; + struct RenderPassBeginInfo; + + //=== VK_VERSION_1_1 === + struct BindBufferMemoryInfo; + using BindBufferMemoryInfoKHR = BindBufferMemoryInfo; + struct BindImageMemoryInfo; + using BindImageMemoryInfoKHR = BindImageMemoryInfo; + struct MemoryDedicatedRequirements; + using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements; + struct MemoryDedicatedAllocateInfo; + using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo; + struct MemoryAllocateFlagsInfo; + using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo; + struct DeviceGroupCommandBufferBeginInfo; + using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo; + struct DeviceGroupSubmitInfo; + using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo; + struct DeviceGroupBindSparseInfo; + using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo; + struct BindBufferMemoryDeviceGroupInfo; + using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo; + struct BindImageMemoryDeviceGroupInfo; + using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo; + struct PhysicalDeviceGroupProperties; + using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; + struct DeviceGroupDeviceCreateInfo; + using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo; + struct BufferMemoryRequirementsInfo2; + using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2; + struct ImageMemoryRequirementsInfo2; + using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2; + struct ImageSparseMemoryRequirementsInfo2; + using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; + struct MemoryRequirements2; + using MemoryRequirements2KHR = MemoryRequirements2; + struct SparseImageMemoryRequirements2; + using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; + struct PhysicalDeviceFeatures2; + using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; + struct PhysicalDeviceProperties2; + using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; + struct FormatProperties2; + using FormatProperties2KHR = FormatProperties2; + struct ImageFormatProperties2; + using ImageFormatProperties2KHR = ImageFormatProperties2; + struct PhysicalDeviceImageFormatInfo2; + using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; + struct QueueFamilyProperties2; + using QueueFamilyProperties2KHR = QueueFamilyProperties2; + struct PhysicalDeviceMemoryProperties2; + using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; + struct SparseImageFormatProperties2; + using SparseImageFormatProperties2KHR = SparseImageFormatProperties2; + struct PhysicalDeviceSparseImageFormatInfo2; + using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; + struct ImageViewUsageCreateInfo; + using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; + struct PhysicalDeviceProtectedMemoryFeatures; + struct PhysicalDeviceProtectedMemoryProperties; + struct DeviceQueueInfo2; + struct ProtectedSubmitInfo; + struct BindImagePlaneMemoryInfo; + using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; + struct ImagePlaneMemoryRequirementsInfo; + using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo; + struct ExternalMemoryProperties; + using ExternalMemoryPropertiesKHR = ExternalMemoryProperties; + struct PhysicalDeviceExternalImageFormatInfo; + using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo; + struct ExternalImageFormatProperties; + using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties; + struct PhysicalDeviceExternalBufferInfo; + using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; + struct ExternalBufferProperties; + using ExternalBufferPropertiesKHR = ExternalBufferProperties; + struct PhysicalDeviceIDProperties; + using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; + struct ExternalMemoryImageCreateInfo; + using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo; + struct ExternalMemoryBufferCreateInfo; + using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo; + struct ExportMemoryAllocateInfo; + using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo; + struct PhysicalDeviceExternalFenceInfo; + using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; + struct ExternalFenceProperties; + using ExternalFencePropertiesKHR = ExternalFenceProperties; + struct ExportFenceCreateInfo; + using ExportFenceCreateInfoKHR = ExportFenceCreateInfo; + struct ExportSemaphoreCreateInfo; + using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo; + struct PhysicalDeviceExternalSemaphoreInfo; + using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; + struct ExternalSemaphoreProperties; + using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; + struct PhysicalDeviceSubgroupProperties; + struct PhysicalDevice16BitStorageFeatures; + using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; + struct PhysicalDeviceVariablePointersFeatures; + using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures; + using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures; + using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures; + struct DescriptorUpdateTemplateEntry; + using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry; + struct DescriptorUpdateTemplateCreateInfo; + using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; + struct PhysicalDeviceMaintenance3Properties; + using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; + struct DescriptorSetLayoutSupport; + using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; + struct SamplerYcbcrConversionCreateInfo; + using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; + struct SamplerYcbcrConversionInfo; + using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; + struct PhysicalDeviceSamplerYcbcrConversionFeatures; + using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures; + struct SamplerYcbcrConversionImageFormatProperties; + using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties; + struct DeviceGroupRenderPassBeginInfo; + using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo; + struct PhysicalDevicePointClippingProperties; + using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; + struct RenderPassInputAttachmentAspectCreateInfo; + using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo; + struct InputAttachmentAspectReference; + using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; + struct PipelineTessellationDomainOriginStateCreateInfo; + using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo; + struct RenderPassMultiviewCreateInfo; + using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo; + struct PhysicalDeviceMultiviewFeatures; + using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures; + struct PhysicalDeviceMultiviewProperties; + using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; + struct PhysicalDeviceShaderDrawParametersFeatures; + using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures; + + //=== VK_VERSION_1_2 === + struct PhysicalDeviceVulkan11Features; + struct PhysicalDeviceVulkan11Properties; + struct PhysicalDeviceVulkan12Features; + struct PhysicalDeviceVulkan12Properties; + struct ImageFormatListCreateInfo; + using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo; + struct ConformanceVersion; + using ConformanceVersionKHR = ConformanceVersion; + struct PhysicalDeviceDriverProperties; + using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties; + struct PhysicalDeviceVulkanMemoryModelFeatures; + using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures; + struct PhysicalDeviceHostQueryResetFeatures; + using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures; + struct PhysicalDeviceTimelineSemaphoreFeatures; + using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures; + struct PhysicalDeviceTimelineSemaphoreProperties; + using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties; + struct SemaphoreTypeCreateInfo; + using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo; + struct TimelineSemaphoreSubmitInfo; + using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo; + struct SemaphoreWaitInfo; + using SemaphoreWaitInfoKHR = SemaphoreWaitInfo; + struct SemaphoreSignalInfo; + using SemaphoreSignalInfoKHR = SemaphoreSignalInfo; + struct PhysicalDeviceBufferDeviceAddressFeatures; + using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures; + struct BufferDeviceAddressInfo; + using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo; + using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo; + struct BufferOpaqueCaptureAddressCreateInfo; + using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo; + struct MemoryOpaqueCaptureAddressAllocateInfo; + using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo; + struct DeviceMemoryOpaqueCaptureAddressInfo; + using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo; + struct PhysicalDevice8BitStorageFeatures; + using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures; + struct PhysicalDeviceShaderAtomicInt64Features; + using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features; + struct PhysicalDeviceShaderFloat16Int8Features; + using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; + using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; + struct PhysicalDeviceFloatControlsProperties; + using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties; + struct DescriptorSetLayoutBindingFlagsCreateInfo; + using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo; + struct PhysicalDeviceDescriptorIndexingFeatures; + using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures; + struct PhysicalDeviceDescriptorIndexingProperties; + using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties; + struct DescriptorSetVariableDescriptorCountAllocateInfo; + using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo; + struct DescriptorSetVariableDescriptorCountLayoutSupport; + using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport; + struct PhysicalDeviceScalarBlockLayoutFeatures; + using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures; + struct SamplerReductionModeCreateInfo; + using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo; + struct PhysicalDeviceSamplerFilterMinmaxProperties; + using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties; + struct PhysicalDeviceUniformBufferStandardLayoutFeatures; + using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures; + struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures; + using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; + struct RenderPassCreateInfo2; + using RenderPassCreateInfo2KHR = RenderPassCreateInfo2; + struct AttachmentDescription2; + using AttachmentDescription2KHR = AttachmentDescription2; + struct AttachmentReference2; + using AttachmentReference2KHR = AttachmentReference2; + struct SubpassDescription2; + using SubpassDescription2KHR = SubpassDescription2; + struct SubpassDependency2; + using SubpassDependency2KHR = SubpassDependency2; + struct SubpassBeginInfo; + using SubpassBeginInfoKHR = SubpassBeginInfo; + struct SubpassEndInfo; + using SubpassEndInfoKHR = SubpassEndInfo; + struct SubpassDescriptionDepthStencilResolve; + using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve; + struct PhysicalDeviceDepthStencilResolveProperties; + using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties; + struct ImageStencilUsageCreateInfo; + using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo; + struct PhysicalDeviceImagelessFramebufferFeatures; + using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures; + struct FramebufferAttachmentsCreateInfo; + using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo; + struct FramebufferAttachmentImageInfo; + using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo; + struct RenderPassAttachmentBeginInfo; + using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo; + struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures; + using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; + struct AttachmentReferenceStencilLayout; + using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout; + struct AttachmentDescriptionStencilLayout; + using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout; + + //=== VK_VERSION_1_3 === + struct PhysicalDeviceVulkan13Features; + struct PhysicalDeviceVulkan13Properties; + struct PhysicalDeviceToolProperties; + using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties; + struct PhysicalDevicePrivateDataFeatures; + using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures; + struct DevicePrivateDataCreateInfo; + using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo; + struct PrivateDataSlotCreateInfo; + using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo; + struct MemoryBarrier2; + using MemoryBarrier2KHR = MemoryBarrier2; + struct BufferMemoryBarrier2; + using BufferMemoryBarrier2KHR = BufferMemoryBarrier2; + struct ImageMemoryBarrier2; + using ImageMemoryBarrier2KHR = ImageMemoryBarrier2; + struct DependencyInfo; + using DependencyInfoKHR = DependencyInfo; + struct SubmitInfo2; + using SubmitInfo2KHR = SubmitInfo2; + struct SemaphoreSubmitInfo; + using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo; + struct CommandBufferSubmitInfo; + using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo; + struct PhysicalDeviceSynchronization2Features; + using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features; + struct CopyBufferInfo2; + using CopyBufferInfo2KHR = CopyBufferInfo2; + struct CopyImageInfo2; + using CopyImageInfo2KHR = CopyImageInfo2; + struct CopyBufferToImageInfo2; + using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2; + struct CopyImageToBufferInfo2; + using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2; + struct BufferCopy2; + using BufferCopy2KHR = BufferCopy2; + struct ImageCopy2; + using ImageCopy2KHR = ImageCopy2; + struct BufferImageCopy2; + using BufferImageCopy2KHR = BufferImageCopy2; + struct PhysicalDeviceTextureCompressionASTCHDRFeatures; + using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures; + struct FormatProperties3; + using FormatProperties3KHR = FormatProperties3; + struct PhysicalDeviceMaintenance4Features; + using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features; + struct PhysicalDeviceMaintenance4Properties; + using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties; + struct DeviceBufferMemoryRequirements; + using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements; + struct DeviceImageMemoryRequirements; + using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements; + struct PipelineCreationFeedbackCreateInfo; + using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo; + struct PipelineCreationFeedback; + using PipelineCreationFeedbackEXT = PipelineCreationFeedback; + struct PhysicalDeviceShaderTerminateInvocationFeatures; + using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures; + struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures; + using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; + struct PhysicalDevicePipelineCreationCacheControlFeatures; + using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures; + struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + struct PhysicalDeviceImageRobustnessFeatures; + using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures; + struct PhysicalDeviceSubgroupSizeControlFeatures; + using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures; + struct PhysicalDeviceSubgroupSizeControlProperties; + using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties; + struct PipelineShaderStageRequiredSubgroupSizeCreateInfo; + using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; + using ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; + struct PhysicalDeviceInlineUniformBlockFeatures; + using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures; + struct PhysicalDeviceInlineUniformBlockProperties; + using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties; + struct WriteDescriptorSetInlineUniformBlock; + using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock; + struct DescriptorPoolInlineUniformBlockCreateInfo; + using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo; + struct PhysicalDeviceShaderIntegerDotProductFeatures; + using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures; + struct PhysicalDeviceShaderIntegerDotProductProperties; + using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties; + struct PhysicalDeviceTexelBufferAlignmentProperties; + using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties; + struct BlitImageInfo2; + using BlitImageInfo2KHR = BlitImageInfo2; + struct ImageBlit2; + using ImageBlit2KHR = ImageBlit2; + struct ResolveImageInfo2; + using ResolveImageInfo2KHR = ResolveImageInfo2; + struct ImageResolve2; + using ImageResolve2KHR = ImageResolve2; + struct RenderingInfo; + using RenderingInfoKHR = RenderingInfo; + struct RenderingAttachmentInfo; + using RenderingAttachmentInfoKHR = RenderingAttachmentInfo; + struct PipelineRenderingCreateInfo; + using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo; + struct PhysicalDeviceDynamicRenderingFeatures; + using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures; + struct CommandBufferInheritanceRenderingInfo; + using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo; + + //=== VK_VERSION_1_4 === + struct PhysicalDeviceVulkan14Features; + struct PhysicalDeviceVulkan14Properties; + struct DeviceQueueGlobalPriorityCreateInfo; + using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfo; + using DeviceQueueGlobalPriorityCreateInfoKHR = DeviceQueueGlobalPriorityCreateInfo; + struct PhysicalDeviceGlobalPriorityQueryFeatures; + using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeatures; + using PhysicalDeviceGlobalPriorityQueryFeaturesKHR = PhysicalDeviceGlobalPriorityQueryFeatures; + struct QueueFamilyGlobalPriorityProperties; + using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityProperties; + using QueueFamilyGlobalPriorityPropertiesKHR = QueueFamilyGlobalPriorityProperties; + struct PhysicalDeviceIndexTypeUint8Features; + using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8Features; + using PhysicalDeviceIndexTypeUint8FeaturesKHR = PhysicalDeviceIndexTypeUint8Features; + struct MemoryMapInfo; + using MemoryMapInfoKHR = MemoryMapInfo; + struct MemoryUnmapInfo; + using MemoryUnmapInfoKHR = MemoryUnmapInfo; + struct PhysicalDeviceMaintenance5Features; + using PhysicalDeviceMaintenance5FeaturesKHR = PhysicalDeviceMaintenance5Features; + struct PhysicalDeviceMaintenance5Properties; + using PhysicalDeviceMaintenance5PropertiesKHR = PhysicalDeviceMaintenance5Properties; + struct DeviceImageSubresourceInfo; + using DeviceImageSubresourceInfoKHR = DeviceImageSubresourceInfo; + struct ImageSubresource2; + using ImageSubresource2EXT = ImageSubresource2; + using ImageSubresource2KHR = ImageSubresource2; + struct SubresourceLayout2; + using SubresourceLayout2EXT = SubresourceLayout2; + using SubresourceLayout2KHR = SubresourceLayout2; + struct BufferUsageFlags2CreateInfo; + using BufferUsageFlags2CreateInfoKHR = BufferUsageFlags2CreateInfo; + struct PhysicalDeviceMaintenance6Features; + using PhysicalDeviceMaintenance6FeaturesKHR = PhysicalDeviceMaintenance6Features; + struct PhysicalDeviceMaintenance6Properties; + using PhysicalDeviceMaintenance6PropertiesKHR = PhysicalDeviceMaintenance6Properties; + struct BindMemoryStatus; + using BindMemoryStatusKHR = BindMemoryStatus; + struct PhysicalDeviceHostImageCopyFeatures; + using PhysicalDeviceHostImageCopyFeaturesEXT = PhysicalDeviceHostImageCopyFeatures; + struct PhysicalDeviceHostImageCopyProperties; + using PhysicalDeviceHostImageCopyPropertiesEXT = PhysicalDeviceHostImageCopyProperties; + struct MemoryToImageCopy; + using MemoryToImageCopyEXT = MemoryToImageCopy; + struct ImageToMemoryCopy; + using ImageToMemoryCopyEXT = ImageToMemoryCopy; + struct CopyMemoryToImageInfo; + using CopyMemoryToImageInfoEXT = CopyMemoryToImageInfo; + struct CopyImageToMemoryInfo; + using CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo; + struct CopyImageToImageInfo; + using CopyImageToImageInfoEXT = CopyImageToImageInfo; + struct HostImageLayoutTransitionInfo; + using HostImageLayoutTransitionInfoEXT = HostImageLayoutTransitionInfo; + struct SubresourceHostMemcpySize; + using SubresourceHostMemcpySizeEXT = SubresourceHostMemcpySize; + struct HostImageCopyDevicePerformanceQuery; + using HostImageCopyDevicePerformanceQueryEXT = HostImageCopyDevicePerformanceQuery; + struct PhysicalDeviceShaderSubgroupRotateFeatures; + using PhysicalDeviceShaderSubgroupRotateFeaturesKHR = PhysicalDeviceShaderSubgroupRotateFeatures; + struct PhysicalDeviceShaderFloatControls2Features; + using PhysicalDeviceShaderFloatControls2FeaturesKHR = PhysicalDeviceShaderFloatControls2Features; + struct PhysicalDeviceShaderExpectAssumeFeatures; + using PhysicalDeviceShaderExpectAssumeFeaturesKHR = PhysicalDeviceShaderExpectAssumeFeatures; + struct PipelineCreateFlags2CreateInfo; + using PipelineCreateFlags2CreateInfoKHR = PipelineCreateFlags2CreateInfo; + struct PhysicalDevicePushDescriptorProperties; + using PhysicalDevicePushDescriptorPropertiesKHR = PhysicalDevicePushDescriptorProperties; + struct BindDescriptorSetsInfo; + using BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo; + struct PushConstantsInfo; + using PushConstantsInfoKHR = PushConstantsInfo; + struct PushDescriptorSetInfo; + using PushDescriptorSetInfoKHR = PushDescriptorSetInfo; + struct PushDescriptorSetWithTemplateInfo; + using PushDescriptorSetWithTemplateInfoKHR = PushDescriptorSetWithTemplateInfo; + struct PhysicalDevicePipelineProtectedAccessFeatures; + using PhysicalDevicePipelineProtectedAccessFeaturesEXT = PhysicalDevicePipelineProtectedAccessFeatures; + struct PhysicalDevicePipelineRobustnessFeatures; + using PhysicalDevicePipelineRobustnessFeaturesEXT = PhysicalDevicePipelineRobustnessFeatures; + struct PhysicalDevicePipelineRobustnessProperties; + using PhysicalDevicePipelineRobustnessPropertiesEXT = PhysicalDevicePipelineRobustnessProperties; + struct PipelineRobustnessCreateInfo; + using PipelineRobustnessCreateInfoEXT = PipelineRobustnessCreateInfo; + struct PhysicalDeviceLineRasterizationFeatures; + using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeatures; + using PhysicalDeviceLineRasterizationFeaturesKHR = PhysicalDeviceLineRasterizationFeatures; + struct PhysicalDeviceLineRasterizationProperties; + using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationProperties; + using PhysicalDeviceLineRasterizationPropertiesKHR = PhysicalDeviceLineRasterizationProperties; + struct PipelineRasterizationLineStateCreateInfo; + using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfo; + using PipelineRasterizationLineStateCreateInfoKHR = PipelineRasterizationLineStateCreateInfo; + struct PhysicalDeviceVertexAttributeDivisorProperties; + using PhysicalDeviceVertexAttributeDivisorPropertiesKHR = PhysicalDeviceVertexAttributeDivisorProperties; + struct VertexInputBindingDivisorDescription; + using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescription; + using VertexInputBindingDivisorDescriptionKHR = VertexInputBindingDivisorDescription; + struct PipelineVertexInputDivisorStateCreateInfo; + using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfo; + using PipelineVertexInputDivisorStateCreateInfoKHR = PipelineVertexInputDivisorStateCreateInfo; + struct PhysicalDeviceVertexAttributeDivisorFeatures; + using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeatures; + using PhysicalDeviceVertexAttributeDivisorFeaturesKHR = PhysicalDeviceVertexAttributeDivisorFeatures; + struct RenderingAreaInfo; + using RenderingAreaInfoKHR = RenderingAreaInfo; + struct PhysicalDeviceDynamicRenderingLocalReadFeatures; + using PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = PhysicalDeviceDynamicRenderingLocalReadFeatures; + struct RenderingAttachmentLocationInfo; + using RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo; + struct RenderingInputAttachmentIndexInfo; + using RenderingInputAttachmentIndexInfoKHR = RenderingInputAttachmentIndexInfo; + + //=== VK_KHR_surface === + struct SurfaceCapabilitiesKHR; + struct SurfaceFormatKHR; + + //=== VK_KHR_swapchain === + struct SwapchainCreateInfoKHR; + struct PresentInfoKHR; + struct ImageSwapchainCreateInfoKHR; + struct BindImageMemorySwapchainInfoKHR; + struct AcquireNextImageInfoKHR; + struct DeviceGroupPresentCapabilitiesKHR; + struct DeviceGroupPresentInfoKHR; + struct DeviceGroupSwapchainCreateInfoKHR; + + //=== VK_KHR_display === + struct DisplayModeCreateInfoKHR; + struct DisplayModeParametersKHR; + struct DisplayModePropertiesKHR; + struct DisplayPlaneCapabilitiesKHR; + struct DisplayPlanePropertiesKHR; + struct DisplayPropertiesKHR; + struct DisplaySurfaceCreateInfoKHR; + + //=== VK_KHR_display_swapchain === + struct DisplayPresentInfoKHR; + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + struct XlibSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + struct XcbSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + struct WaylandSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + struct AndroidSurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + struct Win32SurfaceCreateInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + struct DebugReportCallbackCreateInfoEXT; + + //=== VK_AMD_rasterization_order === + struct PipelineRasterizationStateRasterizationOrderAMD; + + //=== VK_EXT_debug_marker === + struct DebugMarkerObjectNameInfoEXT; + struct DebugMarkerObjectTagInfoEXT; + struct DebugMarkerMarkerInfoEXT; + + //=== VK_KHR_video_queue === + struct QueueFamilyQueryResultStatusPropertiesKHR; + struct QueueFamilyVideoPropertiesKHR; + struct VideoProfileInfoKHR; + struct VideoProfileListInfoKHR; + struct VideoCapabilitiesKHR; + struct PhysicalDeviceVideoFormatInfoKHR; + struct VideoFormatPropertiesKHR; + struct VideoPictureResourceInfoKHR; + struct VideoReferenceSlotInfoKHR; + struct VideoSessionMemoryRequirementsKHR; + struct BindVideoSessionMemoryInfoKHR; + struct VideoSessionCreateInfoKHR; + struct VideoSessionParametersCreateInfoKHR; + struct VideoSessionParametersUpdateInfoKHR; + struct VideoBeginCodingInfoKHR; + struct VideoEndCodingInfoKHR; + struct VideoCodingControlInfoKHR; + + //=== VK_KHR_video_decode_queue === + struct VideoDecodeCapabilitiesKHR; + struct VideoDecodeUsageInfoKHR; + struct VideoDecodeInfoKHR; + + //=== VK_NV_dedicated_allocation === + struct DedicatedAllocationImageCreateInfoNV; + struct DedicatedAllocationBufferCreateInfoNV; + struct DedicatedAllocationMemoryAllocateInfoNV; + + //=== VK_EXT_transform_feedback === + struct PhysicalDeviceTransformFeedbackFeaturesEXT; + struct PhysicalDeviceTransformFeedbackPropertiesEXT; + struct PipelineRasterizationStateStreamCreateInfoEXT; + + //=== VK_NVX_binary_import === + struct CuModuleCreateInfoNVX; + struct CuModuleTexturingModeCreateInfoNVX; + struct CuFunctionCreateInfoNVX; + struct CuLaunchInfoNVX; + + //=== VK_NVX_image_view_handle === + struct ImageViewHandleInfoNVX; + struct ImageViewAddressPropertiesNVX; + + //=== VK_KHR_video_encode_h264 === + struct VideoEncodeH264CapabilitiesKHR; + struct VideoEncodeH264QualityLevelPropertiesKHR; + struct VideoEncodeH264SessionCreateInfoKHR; + struct VideoEncodeH264SessionParametersCreateInfoKHR; + struct VideoEncodeH264SessionParametersAddInfoKHR; + struct VideoEncodeH264SessionParametersGetInfoKHR; + struct VideoEncodeH264SessionParametersFeedbackInfoKHR; + struct VideoEncodeH264PictureInfoKHR; + struct VideoEncodeH264DpbSlotInfoKHR; + struct VideoEncodeH264NaluSliceInfoKHR; + struct VideoEncodeH264ProfileInfoKHR; + struct VideoEncodeH264RateControlInfoKHR; + struct VideoEncodeH264RateControlLayerInfoKHR; + struct VideoEncodeH264QpKHR; + struct VideoEncodeH264FrameSizeKHR; + struct VideoEncodeH264GopRemainingFrameInfoKHR; + + //=== VK_KHR_video_encode_h265 === + struct VideoEncodeH265CapabilitiesKHR; + struct VideoEncodeH265SessionCreateInfoKHR; + struct VideoEncodeH265QualityLevelPropertiesKHR; + struct VideoEncodeH265SessionParametersCreateInfoKHR; + struct VideoEncodeH265SessionParametersAddInfoKHR; + struct VideoEncodeH265SessionParametersGetInfoKHR; + struct VideoEncodeH265SessionParametersFeedbackInfoKHR; + struct VideoEncodeH265PictureInfoKHR; + struct VideoEncodeH265DpbSlotInfoKHR; + struct VideoEncodeH265NaluSliceSegmentInfoKHR; + struct VideoEncodeH265ProfileInfoKHR; + struct VideoEncodeH265RateControlInfoKHR; + struct VideoEncodeH265RateControlLayerInfoKHR; + struct VideoEncodeH265QpKHR; + struct VideoEncodeH265FrameSizeKHR; + struct VideoEncodeH265GopRemainingFrameInfoKHR; + + //=== VK_KHR_video_decode_h264 === + struct VideoDecodeH264ProfileInfoKHR; + struct VideoDecodeH264CapabilitiesKHR; + struct VideoDecodeH264SessionParametersCreateInfoKHR; + struct VideoDecodeH264SessionParametersAddInfoKHR; + struct VideoDecodeH264PictureInfoKHR; + struct VideoDecodeH264DpbSlotInfoKHR; + + //=== VK_AMD_texture_gather_bias_lod === + struct TextureLODGatherFormatPropertiesAMD; + + //=== VK_AMD_shader_info === + struct ShaderResourceUsageAMD; + struct ShaderStatisticsInfoAMD; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + struct StreamDescriptorSurfaceCreateInfoGGP; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_corner_sampled_image === + struct PhysicalDeviceCornerSampledImageFeaturesNV; + + //=== VK_NV_external_memory_capabilities === + struct ExternalImageFormatPropertiesNV; + + //=== VK_NV_external_memory === + struct ExternalMemoryImageCreateInfoNV; + struct ExportMemoryAllocateInfoNV; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + struct ImportMemoryWin32HandleInfoNV; + struct ExportMemoryWin32HandleInfoNV; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_win32_keyed_mutex === + struct Win32KeyedMutexAcquireReleaseInfoNV; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_validation_flags === + struct ValidationFlagsEXT; + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + struct ViSurfaceCreateInfoNN; +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_EXT_astc_decode_mode === + struct ImageViewASTCDecodeModeEXT; + struct PhysicalDeviceASTCDecodeFeaturesEXT; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + struct ImportMemoryWin32HandleInfoKHR; + struct ExportMemoryWin32HandleInfoKHR; + struct MemoryWin32HandlePropertiesKHR; + struct MemoryGetWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + struct ImportMemoryFdInfoKHR; + struct MemoryFdPropertiesKHR; + struct MemoryGetFdInfoKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_keyed_mutex === + struct Win32KeyedMutexAcquireReleaseInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + struct ImportSemaphoreWin32HandleInfoKHR; + struct ExportSemaphoreWin32HandleInfoKHR; + struct D3D12FenceSubmitInfoKHR; + struct SemaphoreGetWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + struct ImportSemaphoreFdInfoKHR; + struct SemaphoreGetFdInfoKHR; + + //=== VK_EXT_conditional_rendering === + struct ConditionalRenderingBeginInfoEXT; + struct PhysicalDeviceConditionalRenderingFeaturesEXT; + struct CommandBufferInheritanceConditionalRenderingInfoEXT; + + //=== VK_KHR_incremental_present === + struct PresentRegionsKHR; + struct PresentRegionKHR; + struct RectLayerKHR; + + //=== VK_NV_clip_space_w_scaling === + struct ViewportWScalingNV; + struct PipelineViewportWScalingStateCreateInfoNV; + + //=== VK_EXT_display_surface_counter === + struct SurfaceCapabilities2EXT; + + //=== VK_EXT_display_control === + struct DisplayPowerInfoEXT; + struct DeviceEventInfoEXT; + struct DisplayEventInfoEXT; + struct SwapchainCounterCreateInfoEXT; + + //=== VK_GOOGLE_display_timing === + struct RefreshCycleDurationGOOGLE; + struct PastPresentationTimingGOOGLE; + struct PresentTimesInfoGOOGLE; + struct PresentTimeGOOGLE; + + //=== VK_NVX_multiview_per_view_attributes === + struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + struct MultiviewPerViewAttributesInfoNVX; + + //=== VK_NV_viewport_swizzle === + struct ViewportSwizzleNV; + struct PipelineViewportSwizzleStateCreateInfoNV; + + //=== VK_EXT_discard_rectangles === + struct PhysicalDeviceDiscardRectanglePropertiesEXT; + struct PipelineDiscardRectangleStateCreateInfoEXT; + + //=== VK_EXT_conservative_rasterization === + struct PhysicalDeviceConservativeRasterizationPropertiesEXT; + struct PipelineRasterizationConservativeStateCreateInfoEXT; + + //=== VK_EXT_depth_clip_enable === + struct PhysicalDeviceDepthClipEnableFeaturesEXT; + struct PipelineRasterizationDepthClipStateCreateInfoEXT; + + //=== VK_EXT_hdr_metadata === + struct HdrMetadataEXT; + struct XYColorEXT; + + //=== VK_IMG_relaxed_line_rasterization === + struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG; + + //=== VK_KHR_shared_presentable_image === + struct SharedPresentSurfaceCapabilitiesKHR; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + struct ImportFenceWin32HandleInfoKHR; + struct ExportFenceWin32HandleInfoKHR; + struct FenceGetWin32HandleInfoKHR; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + struct ImportFenceFdInfoKHR; + struct FenceGetFdInfoKHR; + + //=== VK_KHR_performance_query === + struct PhysicalDevicePerformanceQueryFeaturesKHR; + struct PhysicalDevicePerformanceQueryPropertiesKHR; + struct PerformanceCounterKHR; + struct PerformanceCounterDescriptionKHR; + struct QueryPoolPerformanceCreateInfoKHR; + union PerformanceCounterResultKHR; + struct AcquireProfilingLockInfoKHR; + struct PerformanceQuerySubmitInfoKHR; + + //=== VK_KHR_get_surface_capabilities2 === + struct PhysicalDeviceSurfaceInfo2KHR; + struct SurfaceCapabilities2KHR; + struct SurfaceFormat2KHR; + + //=== VK_KHR_get_display_properties2 === + struct DisplayProperties2KHR; + struct DisplayPlaneProperties2KHR; + struct DisplayModeProperties2KHR; + struct DisplayPlaneInfo2KHR; + struct DisplayPlaneCapabilities2KHR; + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + struct IOSSurfaceCreateInfoMVK; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + struct MacOSSurfaceCreateInfoMVK; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + struct DebugUtilsLabelEXT; + struct DebugUtilsMessengerCallbackDataEXT; + struct DebugUtilsMessengerCreateInfoEXT; + struct DebugUtilsObjectNameInfoEXT; + struct DebugUtilsObjectTagInfoEXT; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + struct AndroidHardwareBufferUsageANDROID; + struct AndroidHardwareBufferPropertiesANDROID; + struct AndroidHardwareBufferFormatPropertiesANDROID; + struct ImportAndroidHardwareBufferInfoANDROID; + struct MemoryGetAndroidHardwareBufferInfoANDROID; + struct ExternalFormatANDROID; + struct AndroidHardwareBufferFormatProperties2ANDROID; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + struct PhysicalDeviceShaderEnqueueFeaturesAMDX; + struct PhysicalDeviceShaderEnqueuePropertiesAMDX; + struct ExecutionGraphPipelineScratchSizeAMDX; + struct ExecutionGraphPipelineCreateInfoAMDX; + struct DispatchGraphInfoAMDX; + struct DispatchGraphCountInfoAMDX; + struct PipelineShaderStageNodeCreateInfoAMDX; + union DeviceOrHostAddressConstAMDX; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + struct HostAddressRangeEXT; + struct HostAddressRangeConstEXT; + struct DeviceAddressRangeEXT; + struct TexelBufferDescriptorInfoEXT; + struct ImageDescriptorInfoEXT; + struct ResourceDescriptorInfoEXT; + union ResourceDescriptorDataEXT; + struct BindHeapInfoEXT; + struct PushDataInfoEXT; + struct DescriptorMappingSourceConstantOffsetEXT; + struct DescriptorMappingSourcePushIndexEXT; + struct DescriptorMappingSourceIndirectIndexEXT; + struct DescriptorMappingSourceHeapDataEXT; + struct DescriptorMappingSourceIndirectAddressEXT; + struct DescriptorMappingSourceShaderRecordIndexEXT; + union DescriptorMappingSourceDataEXT; + struct DescriptorMappingSourceIndirectIndexArrayEXT; + struct DescriptorSetAndBindingMappingEXT; + struct ShaderDescriptorSetAndBindingMappingInfoEXT; + struct OpaqueCaptureDataCreateInfoEXT; + struct PhysicalDeviceDescriptorHeapFeaturesEXT; + struct PhysicalDeviceDescriptorHeapPropertiesEXT; + struct CommandBufferInheritanceDescriptorHeapInfoEXT; + struct SamplerCustomBorderColorIndexCreateInfoEXT; + struct IndirectCommandsLayoutPushDataTokenNV; + struct SubsampledImageFormatPropertiesEXT; + struct TensorViewCreateInfoARM; + struct PhysicalDeviceDescriptorHeapTensorPropertiesARM; + + //=== VK_AMD_mixed_attachment_samples === + struct AttachmentSampleCountInfoAMD; + using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD; + + //=== VK_KHR_shader_bfloat16 === + struct PhysicalDeviceShaderBfloat16FeaturesKHR; + + //=== VK_EXT_sample_locations === + struct SampleLocationEXT; + struct SampleLocationsInfoEXT; + struct AttachmentSampleLocationsEXT; + struct SubpassSampleLocationsEXT; + struct RenderPassSampleLocationsBeginInfoEXT; + struct PipelineSampleLocationsStateCreateInfoEXT; + struct PhysicalDeviceSampleLocationsPropertiesEXT; + struct MultisamplePropertiesEXT; + + //=== VK_EXT_blend_operation_advanced === + struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT; + struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT; + struct PipelineColorBlendAdvancedStateCreateInfoEXT; + + //=== VK_NV_fragment_coverage_to_color === + struct PipelineCoverageToColorStateCreateInfoNV; + + //=== VK_KHR_acceleration_structure === + union DeviceOrHostAddressKHR; + union DeviceOrHostAddressConstKHR; + struct AccelerationStructureBuildRangeInfoKHR; + struct AabbPositionsKHR; + using AabbPositionsNV = AabbPositionsKHR; + struct AccelerationStructureGeometryTrianglesDataKHR; + struct TransformMatrixKHR; + using TransformMatrixNV = TransformMatrixKHR; + struct AccelerationStructureBuildGeometryInfoKHR; + struct AccelerationStructureGeometryAabbsDataKHR; + struct AccelerationStructureInstanceKHR; + using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR; + struct AccelerationStructureGeometryInstancesDataKHR; + union AccelerationStructureGeometryDataKHR; + struct AccelerationStructureGeometryKHR; + struct AccelerationStructureCreateInfoKHR; + struct WriteDescriptorSetAccelerationStructureKHR; + struct PhysicalDeviceAccelerationStructureFeaturesKHR; + struct PhysicalDeviceAccelerationStructurePropertiesKHR; + struct AccelerationStructureDeviceAddressInfoKHR; + struct AccelerationStructureVersionInfoKHR; + struct CopyAccelerationStructureToMemoryInfoKHR; + struct CopyMemoryToAccelerationStructureInfoKHR; + struct CopyAccelerationStructureInfoKHR; + struct AccelerationStructureBuildSizesInfoKHR; + + //=== VK_KHR_ray_tracing_pipeline === + struct RayTracingShaderGroupCreateInfoKHR; + struct RayTracingPipelineCreateInfoKHR; + struct PhysicalDeviceRayTracingPipelineFeaturesKHR; + struct PhysicalDeviceRayTracingPipelinePropertiesKHR; + struct StridedDeviceAddressRegionKHR; + struct TraceRaysIndirectCommandKHR; + struct RayTracingPipelineInterfaceCreateInfoKHR; + + //=== VK_KHR_ray_query === + struct PhysicalDeviceRayQueryFeaturesKHR; + + //=== VK_NV_framebuffer_mixed_samples === + struct PipelineCoverageModulationStateCreateInfoNV; + + //=== VK_NV_shader_sm_builtins === + struct PhysicalDeviceShaderSMBuiltinsPropertiesNV; + struct PhysicalDeviceShaderSMBuiltinsFeaturesNV; + + //=== VK_EXT_image_drm_format_modifier === + struct DrmFormatModifierPropertiesListEXT; + struct DrmFormatModifierPropertiesEXT; + struct PhysicalDeviceImageDrmFormatModifierInfoEXT; + struct ImageDrmFormatModifierListCreateInfoEXT; + struct ImageDrmFormatModifierExplicitCreateInfoEXT; + struct ImageDrmFormatModifierPropertiesEXT; + struct DrmFormatModifierPropertiesList2EXT; + struct DrmFormatModifierProperties2EXT; + + //=== VK_EXT_validation_cache === + struct ValidationCacheCreateInfoEXT; + struct ShaderModuleValidationCacheCreateInfoEXT; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_KHR_portability_subset === + struct PhysicalDevicePortabilitySubsetFeaturesKHR; + struct PhysicalDevicePortabilitySubsetPropertiesKHR; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_NV_shading_rate_image === + struct ShadingRatePaletteNV; + struct PipelineViewportShadingRateImageStateCreateInfoNV; + struct PhysicalDeviceShadingRateImageFeaturesNV; + struct PhysicalDeviceShadingRateImagePropertiesNV; + struct CoarseSampleLocationNV; + struct CoarseSampleOrderCustomNV; + struct PipelineViewportCoarseSampleOrderStateCreateInfoNV; + + //=== VK_NV_ray_tracing === + struct RayTracingShaderGroupCreateInfoNV; + struct RayTracingPipelineCreateInfoNV; + struct GeometryTrianglesNV; + struct GeometryAABBNV; + struct GeometryDataNV; + struct GeometryNV; + struct AccelerationStructureInfoNV; + struct AccelerationStructureCreateInfoNV; + struct BindAccelerationStructureMemoryInfoNV; + struct WriteDescriptorSetAccelerationStructureNV; + struct AccelerationStructureMemoryRequirementsInfoNV; + struct PhysicalDeviceRayTracingPropertiesNV; + + //=== VK_NV_representative_fragment_test === + struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV; + struct PipelineRepresentativeFragmentTestStateCreateInfoNV; + + //=== VK_EXT_filter_cubic === + struct PhysicalDeviceImageViewImageFormatInfoEXT; + struct FilterCubicImageViewImageFormatPropertiesEXT; + + //=== VK_EXT_external_memory_host === + struct ImportMemoryHostPointerInfoEXT; + struct MemoryHostPointerPropertiesEXT; + struct PhysicalDeviceExternalMemoryHostPropertiesEXT; + + //=== VK_KHR_shader_clock === + struct PhysicalDeviceShaderClockFeaturesKHR; + + //=== VK_AMD_pipeline_compiler_control === + struct PipelineCompilerControlCreateInfoAMD; + + //=== VK_AMD_shader_core_properties === + struct PhysicalDeviceShaderCorePropertiesAMD; + + //=== VK_KHR_video_decode_h265 === + struct VideoDecodeH265ProfileInfoKHR; + struct VideoDecodeH265CapabilitiesKHR; + struct VideoDecodeH265SessionParametersCreateInfoKHR; + struct VideoDecodeH265SessionParametersAddInfoKHR; + struct VideoDecodeH265PictureInfoKHR; + struct VideoDecodeH265DpbSlotInfoKHR; + + //=== VK_AMD_memory_overallocation_behavior === + struct DeviceMemoryOverallocationCreateInfoAMD; + + //=== VK_EXT_vertex_attribute_divisor === + struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT; + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_frame_token === + struct PresentFrameTokenGGP; +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_mesh_shader === + struct PhysicalDeviceMeshShaderFeaturesNV; + struct PhysicalDeviceMeshShaderPropertiesNV; + struct DrawMeshTasksIndirectCommandNV; + + //=== VK_NV_shader_image_footprint === + struct PhysicalDeviceShaderImageFootprintFeaturesNV; + + //=== VK_NV_scissor_exclusive === + struct PipelineViewportExclusiveScissorStateCreateInfoNV; + struct PhysicalDeviceExclusiveScissorFeaturesNV; + + //=== VK_NV_device_diagnostic_checkpoints === + struct QueueFamilyCheckpointPropertiesNV; + struct CheckpointDataNV; + struct QueueFamilyCheckpointProperties2NV; + struct CheckpointData2NV; + + //=== VK_EXT_present_timing === + struct PhysicalDevicePresentTimingFeaturesEXT; + struct PresentTimingSurfaceCapabilitiesEXT; + struct SwapchainCalibratedTimestampInfoEXT; + struct SwapchainTimingPropertiesEXT; + struct SwapchainTimeDomainPropertiesEXT; + struct PastPresentationTimingInfoEXT; + struct PastPresentationTimingPropertiesEXT; + struct PastPresentationTimingEXT; + struct PresentTimingsInfoEXT; + struct PresentTimingInfoEXT; + struct PresentStageTimeEXT; + + //=== VK_INTEL_shader_integer_functions2 === + struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + + //=== VK_INTEL_performance_query === + union PerformanceValueDataINTEL; + struct PerformanceValueINTEL; + struct InitializePerformanceApiInfoINTEL; + struct QueryPoolPerformanceQueryCreateInfoINTEL; + using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL; + struct PerformanceMarkerInfoINTEL; + struct PerformanceStreamMarkerInfoINTEL; + struct PerformanceOverrideInfoINTEL; + struct PerformanceConfigurationAcquireInfoINTEL; + + //=== VK_EXT_pci_bus_info === + struct PhysicalDevicePCIBusInfoPropertiesEXT; + + //=== VK_AMD_display_native_hdr === + struct DisplayNativeHdrSurfaceCapabilitiesAMD; + struct SwapchainDisplayNativeHdrCreateInfoAMD; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + struct ImagePipeSurfaceCreateInfoFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + struct MetalSurfaceCreateInfoEXT; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_fragment_density_map === + struct PhysicalDeviceFragmentDensityMapFeaturesEXT; + struct PhysicalDeviceFragmentDensityMapPropertiesEXT; + struct RenderPassFragmentDensityMapCreateInfoEXT; + struct RenderingFragmentDensityMapAttachmentInfoEXT; + + //=== VK_KHR_fragment_shading_rate === + struct FragmentShadingRateAttachmentInfoKHR; + struct PipelineFragmentShadingRateStateCreateInfoKHR; + struct PhysicalDeviceFragmentShadingRateFeaturesKHR; + struct PhysicalDeviceFragmentShadingRatePropertiesKHR; + struct PhysicalDeviceFragmentShadingRateKHR; + struct RenderingFragmentShadingRateAttachmentInfoKHR; + + //=== VK_AMD_shader_core_properties2 === + struct PhysicalDeviceShaderCoreProperties2AMD; + + //=== VK_AMD_device_coherent_memory === + struct PhysicalDeviceCoherentMemoryFeaturesAMD; + + //=== VK_EXT_shader_image_atomic_int64 === + struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + + //=== VK_KHR_shader_quad_control === + struct PhysicalDeviceShaderQuadControlFeaturesKHR; + + //=== VK_EXT_memory_budget === + struct PhysicalDeviceMemoryBudgetPropertiesEXT; + + //=== VK_EXT_memory_priority === + struct PhysicalDeviceMemoryPriorityFeaturesEXT; + struct MemoryPriorityAllocateInfoEXT; + + //=== VK_KHR_surface_protected_capabilities === + struct SurfaceProtectedCapabilitiesKHR; + + //=== VK_NV_dedicated_allocation_image_aliasing === + struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + + //=== VK_EXT_buffer_device_address === + struct PhysicalDeviceBufferDeviceAddressFeaturesEXT; + using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT; + struct BufferDeviceAddressCreateInfoEXT; + + //=== VK_EXT_validation_features === + struct ValidationFeaturesEXT; + + //=== VK_KHR_present_wait === + struct PhysicalDevicePresentWaitFeaturesKHR; + + //=== VK_NV_cooperative_matrix === + struct CooperativeMatrixPropertiesNV; + struct PhysicalDeviceCooperativeMatrixFeaturesNV; + struct PhysicalDeviceCooperativeMatrixPropertiesNV; + + //=== VK_NV_coverage_reduction_mode === + struct PhysicalDeviceCoverageReductionModeFeaturesNV; + struct PipelineCoverageReductionStateCreateInfoNV; + struct FramebufferMixedSamplesCombinationNV; + + //=== VK_EXT_fragment_shader_interlock === + struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT; + + //=== VK_EXT_ycbcr_image_arrays === + struct PhysicalDeviceYcbcrImageArraysFeaturesEXT; + + //=== VK_EXT_provoking_vertex === + struct PhysicalDeviceProvokingVertexFeaturesEXT; + struct PhysicalDeviceProvokingVertexPropertiesEXT; + struct PipelineRasterizationProvokingVertexStateCreateInfoEXT; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + struct SurfaceFullScreenExclusiveInfoEXT; + struct SurfaceCapabilitiesFullScreenExclusiveEXT; + struct SurfaceFullScreenExclusiveWin32InfoEXT; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + struct HeadlessSurfaceCreateInfoEXT; + + //=== VK_EXT_shader_atomic_float === + struct PhysicalDeviceShaderAtomicFloatFeaturesEXT; + + //=== VK_EXT_extended_dynamic_state === + struct PhysicalDeviceExtendedDynamicStateFeaturesEXT; + + //=== VK_KHR_pipeline_executable_properties === + struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + struct PipelineInfoKHR; + using PipelineInfoEXT = PipelineInfoKHR; + struct PipelineExecutablePropertiesKHR; + struct PipelineExecutableInfoKHR; + union PipelineExecutableStatisticValueKHR; + struct PipelineExecutableStatisticKHR; + struct PipelineExecutableInternalRepresentationKHR; + + //=== VK_EXT_map_memory_placed === + struct PhysicalDeviceMapMemoryPlacedFeaturesEXT; + struct PhysicalDeviceMapMemoryPlacedPropertiesEXT; + struct MemoryMapPlacedInfoEXT; + + //=== VK_EXT_shader_atomic_float2 === + struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT; + + //=== VK_NV_device_generated_commands === + struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + struct GraphicsShaderGroupCreateInfoNV; + struct GraphicsPipelineShaderGroupsCreateInfoNV; + struct BindShaderGroupIndirectCommandNV; + struct BindIndexBufferIndirectCommandNV; + struct BindVertexBufferIndirectCommandNV; + struct SetStateFlagsIndirectCommandNV; + struct IndirectCommandsStreamNV; + struct IndirectCommandsLayoutTokenNV; + struct IndirectCommandsLayoutCreateInfoNV; + struct GeneratedCommandsInfoNV; + struct GeneratedCommandsMemoryRequirementsInfoNV; + + //=== VK_NV_inherited_viewport_scissor === + struct PhysicalDeviceInheritedViewportScissorFeaturesNV; + struct CommandBufferInheritanceViewportScissorInfoNV; + + //=== VK_EXT_texel_buffer_alignment === + struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT; + + //=== VK_QCOM_render_pass_transform === + struct RenderPassTransformBeginInfoQCOM; + struct CommandBufferInheritanceRenderPassTransformInfoQCOM; + + //=== VK_EXT_depth_bias_control === + struct PhysicalDeviceDepthBiasControlFeaturesEXT; + struct DepthBiasInfoEXT; + struct DepthBiasRepresentationInfoEXT; + + //=== VK_EXT_device_memory_report === + struct PhysicalDeviceDeviceMemoryReportFeaturesEXT; + struct DeviceDeviceMemoryReportCreateInfoEXT; + struct DeviceMemoryReportCallbackDataEXT; + + //=== VK_EXT_custom_border_color === + struct SamplerCustomBorderColorCreateInfoEXT; + struct PhysicalDeviceCustomBorderColorPropertiesEXT; + struct PhysicalDeviceCustomBorderColorFeaturesEXT; + + //=== VK_EXT_texture_compression_astc_3d === + struct PhysicalDeviceTextureCompressionASTC3DFeaturesEXT; + + //=== VK_KHR_pipeline_library === + struct PipelineLibraryCreateInfoKHR; + + //=== VK_NV_present_barrier === + struct PhysicalDevicePresentBarrierFeaturesNV; + struct SurfaceCapabilitiesPresentBarrierNV; + struct SwapchainPresentBarrierCreateInfoNV; + + //=== VK_KHR_present_id === + struct PresentIdKHR; + struct PhysicalDevicePresentIdFeaturesKHR; + + //=== VK_KHR_video_encode_queue === + struct VideoEncodeInfoKHR; + struct VideoEncodeCapabilitiesKHR; + struct QueryPoolVideoEncodeFeedbackCreateInfoKHR; + struct VideoEncodeUsageInfoKHR; + struct VideoEncodeRateControlInfoKHR; + struct VideoEncodeRateControlLayerInfoKHR; + struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR; + struct VideoEncodeQualityLevelPropertiesKHR; + struct VideoEncodeQualityLevelInfoKHR; + struct VideoEncodeSessionParametersGetInfoKHR; + struct VideoEncodeSessionParametersFeedbackInfoKHR; + + //=== VK_NV_device_diagnostics_config === + struct PhysicalDeviceDiagnosticsConfigFeaturesNV; + struct DeviceDiagnosticsConfigCreateInfoNV; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + struct CudaModuleCreateInfoNV; + struct CudaFunctionCreateInfoNV; + struct CudaLaunchInfoNV; + struct PhysicalDeviceCudaKernelLaunchFeaturesNV; + struct PhysicalDeviceCudaKernelLaunchPropertiesNV; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + struct PhysicalDeviceTileShadingFeaturesQCOM; + struct PhysicalDeviceTileShadingPropertiesQCOM; + struct RenderPassTileShadingCreateInfoQCOM; + struct PerTileBeginInfoQCOM; + struct PerTileEndInfoQCOM; + struct DispatchTileInfoQCOM; + + //=== VK_NV_low_latency === + struct QueryLowLatencySupportNV; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + struct ExportMetalObjectCreateInfoEXT; + struct ExportMetalObjectsInfoEXT; + struct ExportMetalDeviceInfoEXT; + struct ExportMetalCommandQueueInfoEXT; + struct ExportMetalBufferInfoEXT; + struct ImportMetalBufferInfoEXT; + struct ExportMetalTextureInfoEXT; + struct ImportMetalTextureInfoEXT; + struct ExportMetalIOSurfaceInfoEXT; + struct ImportMetalIOSurfaceInfoEXT; + struct ExportMetalSharedEventInfoEXT; + struct ImportMetalSharedEventInfoEXT; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_descriptor_buffer === + struct PhysicalDeviceDescriptorBufferPropertiesEXT; + struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + struct PhysicalDeviceDescriptorBufferFeaturesEXT; + struct DescriptorAddressInfoEXT; + struct DescriptorBufferBindingInfoEXT; + struct DescriptorBufferBindingPushDescriptorBufferHandleEXT; + union DescriptorDataEXT; + struct DescriptorGetInfoEXT; + struct BufferCaptureDescriptorDataInfoEXT; + struct ImageCaptureDescriptorDataInfoEXT; + struct ImageViewCaptureDescriptorDataInfoEXT; + struct SamplerCaptureDescriptorDataInfoEXT; + struct OpaqueCaptureDescriptorDataCreateInfoEXT; + struct AccelerationStructureCaptureDescriptorDataInfoEXT; + + //=== VK_EXT_graphics_pipeline_library === + struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + struct GraphicsPipelineLibraryCreateInfoEXT; + + //=== VK_AMD_shader_early_and_late_fragment_tests === + struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + + //=== VK_KHR_fragment_shader_barycentric === + struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + + //=== VK_KHR_shader_subgroup_uniform_control_flow === + struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + + //=== VK_NV_fragment_shading_rate_enums === + struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + struct PipelineFragmentShadingRateEnumStateCreateInfoNV; + + //=== VK_NV_ray_tracing_motion_blur === + struct AccelerationStructureGeometryMotionTrianglesDataNV; + struct AccelerationStructureMotionInfoNV; + struct AccelerationStructureMotionInstanceNV; + union AccelerationStructureMotionInstanceDataNV; + struct AccelerationStructureMatrixMotionInstanceNV; + struct AccelerationStructureSRTMotionInstanceNV; + struct SRTDataNV; + struct PhysicalDeviceRayTracingMotionBlurFeaturesNV; + + //=== VK_EXT_mesh_shader === + struct PhysicalDeviceMeshShaderFeaturesEXT; + struct PhysicalDeviceMeshShaderPropertiesEXT; + struct DrawMeshTasksIndirectCommandEXT; + + //=== VK_EXT_ycbcr_2plane_444_formats === + struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + + //=== VK_EXT_fragment_density_map2 === + struct PhysicalDeviceFragmentDensityMap2FeaturesEXT; + struct PhysicalDeviceFragmentDensityMap2PropertiesEXT; + + //=== VK_QCOM_rotated_copy_commands === + struct CopyCommandTransformInfoQCOM; + + //=== VK_KHR_workgroup_memory_explicit_layout === + struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + + //=== VK_EXT_image_compression_control === + struct PhysicalDeviceImageCompressionControlFeaturesEXT; + struct ImageCompressionControlEXT; + struct ImageCompressionPropertiesEXT; + + //=== VK_EXT_attachment_feedback_loop_layout === + struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + + //=== VK_EXT_4444_formats === + struct PhysicalDevice4444FormatsFeaturesEXT; + + //=== VK_EXT_device_fault === + struct PhysicalDeviceFaultFeaturesEXT; + struct DeviceFaultCountsEXT; + struct DeviceFaultInfoEXT; + struct DeviceFaultAddressInfoEXT; + struct DeviceFaultVendorInfoEXT; + struct DeviceFaultVendorBinaryHeaderVersionOneEXT; + + //=== VK_EXT_rgba10x6_formats === + struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT; + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + struct DirectFBSurfaceCreateInfoEXT; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_vertex_input_dynamic_state === + struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT; + struct VertexInputBindingDescription2EXT; + struct VertexInputAttributeDescription2EXT; + + //=== VK_EXT_physical_device_drm === + struct PhysicalDeviceDrmPropertiesEXT; + + //=== VK_EXT_device_address_binding_report === + struct PhysicalDeviceAddressBindingReportFeaturesEXT; + struct DeviceAddressBindingCallbackDataEXT; + + //=== VK_EXT_depth_clip_control === + struct PhysicalDeviceDepthClipControlFeaturesEXT; + struct PipelineViewportDepthClipControlCreateInfoEXT; + + //=== VK_EXT_primitive_topology_list_restart === + struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + struct ImportMemoryZirconHandleInfoFUCHSIA; + struct MemoryZirconHandlePropertiesFUCHSIA; + struct MemoryGetZirconHandleInfoFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + struct ImportSemaphoreZirconHandleInfoFUCHSIA; + struct SemaphoreGetZirconHandleInfoFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + struct BufferCollectionCreateInfoFUCHSIA; + struct ImportMemoryBufferCollectionFUCHSIA; + struct BufferCollectionImageCreateInfoFUCHSIA; + struct BufferConstraintsInfoFUCHSIA; + struct BufferCollectionBufferCreateInfoFUCHSIA; + struct BufferCollectionPropertiesFUCHSIA; + struct SysmemColorSpaceFUCHSIA; + struct ImageConstraintsInfoFUCHSIA; + struct ImageFormatConstraintsInfoFUCHSIA; + struct BufferCollectionConstraintsInfoFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + struct SubpassShadingPipelineCreateInfoHUAWEI; + struct PhysicalDeviceSubpassShadingFeaturesHUAWEI; + struct PhysicalDeviceSubpassShadingPropertiesHUAWEI; + + //=== VK_HUAWEI_invocation_mask === + struct PhysicalDeviceInvocationMaskFeaturesHUAWEI; + + //=== VK_NV_external_memory_rdma === + struct MemoryGetRemoteAddressInfoNV; + struct PhysicalDeviceExternalMemoryRDMAFeaturesNV; + + //=== VK_EXT_pipeline_properties === + struct PipelinePropertiesIdentifierEXT; + struct PhysicalDevicePipelinePropertiesFeaturesEXT; + + //=== VK_EXT_frame_boundary === + struct PhysicalDeviceFrameBoundaryFeaturesEXT; + struct FrameBoundaryEXT; + + //=== VK_EXT_multisampled_render_to_single_sampled === + struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + struct SubpassResolvePerformanceQueryEXT; + struct MultisampledRenderToSingleSampledInfoEXT; + + //=== VK_EXT_extended_dynamic_state2 === + struct PhysicalDeviceExtendedDynamicState2FeaturesEXT; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + struct ScreenSurfaceCreateInfoQNX; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_color_write_enable === + struct PhysicalDeviceColorWriteEnableFeaturesEXT; + struct PipelineColorWriteCreateInfoEXT; + + //=== VK_EXT_primitives_generated_query === + struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; + + //=== VK_KHR_ray_tracing_maintenance1 === + struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR; + struct TraceRaysIndirectCommand2KHR; + + //=== VK_KHR_shader_untyped_pointers === + struct PhysicalDeviceShaderUntypedPointersFeaturesKHR; + + //=== VK_VALVE_video_encode_rgb_conversion === + struct PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; + struct VideoEncodeRgbConversionCapabilitiesVALVE; + struct VideoEncodeProfileRgbConversionInfoVALVE; + struct VideoEncodeSessionRgbConversionCreateInfoVALVE; + + //=== VK_EXT_image_view_min_lod === + struct PhysicalDeviceImageViewMinLodFeaturesEXT; + struct ImageViewMinLodCreateInfoEXT; + + //=== VK_EXT_multi_draw === + struct PhysicalDeviceMultiDrawFeaturesEXT; + struct PhysicalDeviceMultiDrawPropertiesEXT; + struct MultiDrawInfoEXT; + struct MultiDrawIndexedInfoEXT; + + //=== VK_EXT_image_2d_view_of_3d === + struct PhysicalDeviceImage2DViewOf3DFeaturesEXT; + + //=== VK_EXT_shader_tile_image === + struct PhysicalDeviceShaderTileImageFeaturesEXT; + struct PhysicalDeviceShaderTileImagePropertiesEXT; + + //=== VK_EXT_opacity_micromap === + struct MicromapBuildInfoEXT; + struct MicromapUsageEXT; + struct MicromapCreateInfoEXT; + struct PhysicalDeviceOpacityMicromapFeaturesEXT; + struct PhysicalDeviceOpacityMicromapPropertiesEXT; + struct MicromapVersionInfoEXT; + struct CopyMicromapToMemoryInfoEXT; + struct CopyMemoryToMicromapInfoEXT; + struct CopyMicromapInfoEXT; + struct MicromapBuildSizesInfoEXT; + struct AccelerationStructureTrianglesOpacityMicromapEXT; + struct MicromapTriangleEXT; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_displacement_micromap === + struct PhysicalDeviceDisplacementMicromapFeaturesNV; + struct PhysicalDeviceDisplacementMicromapPropertiesNV; + struct AccelerationStructureTrianglesDisplacementMicromapNV; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_HUAWEI_cluster_culling_shader === + struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI; + struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI; + struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; + + //=== VK_EXT_border_color_swizzle === + struct PhysicalDeviceBorderColorSwizzleFeaturesEXT; + struct SamplerBorderColorComponentMappingCreateInfoEXT; + + //=== VK_EXT_pageable_device_local_memory === + struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + + //=== VK_ARM_shader_core_properties === + struct PhysicalDeviceShaderCorePropertiesARM; + + //=== VK_ARM_scheduling_controls === + struct DeviceQueueShaderCoreControlCreateInfoARM; + struct PhysicalDeviceSchedulingControlsFeaturesARM; + struct PhysicalDeviceSchedulingControlsPropertiesARM; + + //=== VK_EXT_image_sliced_view_of_3d === + struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT; + struct ImageViewSlicedCreateInfoEXT; + + //=== VK_VALVE_descriptor_set_host_mapping === + struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + struct DescriptorSetBindingReferenceVALVE; + struct DescriptorSetLayoutHostMappingInfoVALVE; + + //=== VK_EXT_non_seamless_cube_map === + struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + + //=== VK_ARM_render_pass_striped === + struct PhysicalDeviceRenderPassStripedFeaturesARM; + struct PhysicalDeviceRenderPassStripedPropertiesARM; + struct RenderPassStripeBeginInfoARM; + struct RenderPassStripeInfoARM; + struct RenderPassStripeSubmitInfoARM; + + //=== VK_NV_copy_memory_indirect === + struct PhysicalDeviceCopyMemoryIndirectFeaturesNV; + + //=== VK_NV_memory_decompression === + struct DecompressMemoryRegionNV; + + //=== VK_NV_device_generated_commands_compute === + struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; + struct ComputePipelineIndirectBufferInfoNV; + struct PipelineIndirectDeviceAddressInfoNV; + struct BindPipelineIndirectCommandNV; + + //=== VK_NV_ray_tracing_linear_swept_spheres === + struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; + struct AccelerationStructureGeometryLinearSweptSpheresDataNV; + struct AccelerationStructureGeometrySpheresDataNV; + + //=== VK_NV_linear_color_attachment === + struct PhysicalDeviceLinearColorAttachmentFeaturesNV; + + //=== VK_KHR_shader_maximal_reconvergence === + struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; + + //=== VK_EXT_image_compression_control_swapchain === + struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + + //=== VK_QCOM_image_processing === + struct ImageViewSampleWeightCreateInfoQCOM; + struct PhysicalDeviceImageProcessingFeaturesQCOM; + struct PhysicalDeviceImageProcessingPropertiesQCOM; + + //=== VK_EXT_nested_command_buffer === + struct PhysicalDeviceNestedCommandBufferFeaturesEXT; + struct PhysicalDeviceNestedCommandBufferPropertiesEXT; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + struct NativeBufferUsageOHOS; + struct NativeBufferPropertiesOHOS; + struct NativeBufferFormatPropertiesOHOS; + struct ImportNativeBufferInfoOHOS; + struct MemoryGetNativeBufferInfoOHOS; + struct ExternalFormatOHOS; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_external_memory_acquire_unmodified === + struct ExternalMemoryAcquireUnmodifiedEXT; + + //=== VK_EXT_extended_dynamic_state3 === + struct PhysicalDeviceExtendedDynamicState3FeaturesEXT; + struct PhysicalDeviceExtendedDynamicState3PropertiesEXT; + struct ColorBlendEquationEXT; + struct ColorBlendAdvancedEXT; + + //=== VK_EXT_subpass_merge_feedback === + struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + struct RenderPassCreationControlEXT; + struct RenderPassCreationFeedbackInfoEXT; + struct RenderPassCreationFeedbackCreateInfoEXT; + struct RenderPassSubpassFeedbackInfoEXT; + struct RenderPassSubpassFeedbackCreateInfoEXT; + + //=== VK_LUNARG_direct_driver_loading === + struct DirectDriverLoadingInfoLUNARG; + struct DirectDriverLoadingListLUNARG; + + //=== VK_ARM_tensors === + struct TensorDescriptionARM; + struct TensorCreateInfoARM; + struct TensorMemoryRequirementsInfoARM; + struct BindTensorMemoryInfoARM; + struct WriteDescriptorSetTensorARM; + struct TensorFormatPropertiesARM; + struct PhysicalDeviceTensorPropertiesARM; + struct TensorMemoryBarrierARM; + struct TensorDependencyInfoARM; + struct PhysicalDeviceTensorFeaturesARM; + struct DeviceTensorMemoryRequirementsARM; + struct CopyTensorInfoARM; + struct TensorCopyARM; + struct MemoryDedicatedAllocateInfoTensorARM; + struct PhysicalDeviceExternalTensorInfoARM; + struct ExternalTensorPropertiesARM; + struct ExternalMemoryTensorCreateInfoARM; + struct PhysicalDeviceDescriptorBufferTensorFeaturesARM; + struct PhysicalDeviceDescriptorBufferTensorPropertiesARM; + struct DescriptorGetTensorInfoARM; + struct TensorCaptureDescriptorDataInfoARM; + struct TensorViewCaptureDescriptorDataInfoARM; + struct FrameBoundaryTensorsARM; + + //=== VK_EXT_shader_module_identifier === + struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT; + struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT; + struct PipelineShaderStageModuleIdentifierCreateInfoEXT; + struct ShaderModuleIdentifierEXT; + + //=== VK_EXT_rasterization_order_attachment_access === + struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + + //=== VK_NV_optical_flow === + struct PhysicalDeviceOpticalFlowFeaturesNV; + struct PhysicalDeviceOpticalFlowPropertiesNV; + struct OpticalFlowImageFormatInfoNV; + struct OpticalFlowImageFormatPropertiesNV; + struct OpticalFlowSessionCreateInfoNV; + struct OpticalFlowSessionCreatePrivateDataInfoNV; + struct OpticalFlowExecuteInfoNV; + + //=== VK_EXT_legacy_dithering === + struct PhysicalDeviceLegacyDitheringFeaturesEXT; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_format_resolve === + struct PhysicalDeviceExternalFormatResolveFeaturesANDROID; + struct PhysicalDeviceExternalFormatResolvePropertiesANDROID; + struct AndroidHardwareBufferFormatResolvePropertiesANDROID; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + //=== VK_AMD_anti_lag === + struct PhysicalDeviceAntiLagFeaturesAMD; + struct AntiLagDataAMD; + struct AntiLagPresentationInfoAMD; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_dense_geometry_format === + struct PhysicalDeviceDenseGeometryFormatFeaturesAMDX; + struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_present_id2 === + struct SurfaceCapabilitiesPresentId2KHR; + struct PresentId2KHR; + struct PhysicalDevicePresentId2FeaturesKHR; + + //=== VK_KHR_present_wait2 === + struct SurfaceCapabilitiesPresentWait2KHR; + struct PhysicalDevicePresentWait2FeaturesKHR; + struct PresentWait2InfoKHR; + + //=== VK_KHR_ray_tracing_position_fetch === + struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR; + + //=== VK_EXT_shader_object === + struct PhysicalDeviceShaderObjectFeaturesEXT; + struct PhysicalDeviceShaderObjectPropertiesEXT; + struct ShaderCreateInfoEXT; + + //=== VK_KHR_pipeline_binary === + struct PhysicalDevicePipelineBinaryFeaturesKHR; + struct PhysicalDevicePipelineBinaryPropertiesKHR; + struct DevicePipelineBinaryInternalCacheControlKHR; + struct PipelineBinaryKeyKHR; + struct PipelineBinaryDataKHR; + struct PipelineBinaryKeysAndDataKHR; + struct PipelineBinaryCreateInfoKHR; + struct PipelineBinaryInfoKHR; + struct ReleaseCapturedPipelineDataInfoKHR; + struct PipelineBinaryDataInfoKHR; + struct PipelineCreateInfoKHR; + struct PipelineBinaryHandlesInfoKHR; + + //=== VK_QCOM_tile_properties === + struct PhysicalDeviceTilePropertiesFeaturesQCOM; + struct TilePropertiesQCOM; + + //=== VK_SEC_amigo_profiling === + struct PhysicalDeviceAmigoProfilingFeaturesSEC; + struct AmigoProfilingSubmitInfoSEC; + + //=== VK_KHR_surface_maintenance1 === + struct SurfacePresentModeKHR; + using SurfacePresentModeEXT = SurfacePresentModeKHR; + struct SurfacePresentScalingCapabilitiesKHR; + using SurfacePresentScalingCapabilitiesEXT = SurfacePresentScalingCapabilitiesKHR; + struct SurfacePresentModeCompatibilityKHR; + using SurfacePresentModeCompatibilityEXT = SurfacePresentModeCompatibilityKHR; + + //=== VK_KHR_swapchain_maintenance1 === + struct PhysicalDeviceSwapchainMaintenance1FeaturesKHR; + using PhysicalDeviceSwapchainMaintenance1FeaturesEXT = PhysicalDeviceSwapchainMaintenance1FeaturesKHR; + struct SwapchainPresentFenceInfoKHR; + using SwapchainPresentFenceInfoEXT = SwapchainPresentFenceInfoKHR; + struct SwapchainPresentModesCreateInfoKHR; + using SwapchainPresentModesCreateInfoEXT = SwapchainPresentModesCreateInfoKHR; + struct SwapchainPresentModeInfoKHR; + using SwapchainPresentModeInfoEXT = SwapchainPresentModeInfoKHR; + struct SwapchainPresentScalingCreateInfoKHR; + using SwapchainPresentScalingCreateInfoEXT = SwapchainPresentScalingCreateInfoKHR; + struct ReleaseSwapchainImagesInfoKHR; + using ReleaseSwapchainImagesInfoEXT = ReleaseSwapchainImagesInfoKHR; + + //=== VK_QCOM_multiview_per_view_viewports === + struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + + //=== VK_NV_ray_tracing_invocation_reorder === + struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV; + struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV; + + //=== VK_NV_cooperative_vector === + struct PhysicalDeviceCooperativeVectorPropertiesNV; + struct PhysicalDeviceCooperativeVectorFeaturesNV; + struct CooperativeVectorPropertiesNV; + struct ConvertCooperativeVectorMatrixInfoNV; + + //=== VK_NV_extended_sparse_address_space === + struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; + struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV; + + //=== VK_EXT_mutable_descriptor_type === + struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT; + using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT; + struct MutableDescriptorTypeListEXT; + using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT; + struct MutableDescriptorTypeCreateInfoEXT; + using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT; + + //=== VK_EXT_legacy_vertex_attributes === + struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT; + struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT; + + //=== VK_EXT_layer_settings === + struct LayerSettingsCreateInfoEXT; + struct LayerSettingEXT; + + //=== VK_ARM_shader_core_builtins === + struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM; + struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM; + + //=== VK_EXT_pipeline_library_group_handles === + struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + + //=== VK_EXT_dynamic_rendering_unused_attachments === + struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; + + //=== VK_KHR_internally_synchronized_queues === + struct PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; + + //=== VK_NV_low_latency2 === + struct LatencySleepModeInfoNV; + struct LatencySleepInfoNV; + struct SetLatencyMarkerInfoNV; + struct GetLatencyMarkerInfoNV; + struct LatencyTimingsFrameReportNV; + struct LatencySubmissionPresentIdNV; + struct SwapchainLatencyCreateInfoNV; + struct OutOfBandQueueTypeInfoNV; + struct LatencySurfaceCapabilitiesNV; + + //=== VK_KHR_cooperative_matrix === + struct CooperativeMatrixPropertiesKHR; + struct PhysicalDeviceCooperativeMatrixFeaturesKHR; + struct PhysicalDeviceCooperativeMatrixPropertiesKHR; + + //=== VK_ARM_data_graph === + struct PhysicalDeviceDataGraphFeaturesARM; + struct DataGraphPipelineConstantARM; + struct DataGraphPipelineResourceInfoARM; + struct DataGraphPipelineCompilerControlCreateInfoARM; + struct DataGraphPipelineCreateInfoARM; + struct DataGraphPipelineShaderModuleCreateInfoARM; + struct DataGraphPipelineSessionCreateInfoARM; + struct DataGraphPipelineSessionBindPointRequirementsInfoARM; + struct DataGraphPipelineSessionBindPointRequirementARM; + struct DataGraphPipelineSessionMemoryRequirementsInfoARM; + struct BindDataGraphPipelineSessionMemoryInfoARM; + struct DataGraphPipelineInfoARM; + struct DataGraphPipelinePropertyQueryResultARM; + struct DataGraphPipelineIdentifierCreateInfoARM; + struct DataGraphPipelineDispatchInfoARM; + struct PhysicalDeviceDataGraphProcessingEngineARM; + struct QueueFamilyDataGraphPropertiesARM; + struct DataGraphProcessingEngineCreateInfoARM; + struct PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; + struct QueueFamilyDataGraphProcessingEnginePropertiesARM; + struct PhysicalDeviceDataGraphOperationSupportARM; + struct DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; + + //=== VK_QCOM_multiview_per_view_render_areas === + struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + + //=== VK_KHR_compute_shader_derivatives === + struct PhysicalDeviceComputeShaderDerivativesFeaturesKHR; + using PhysicalDeviceComputeShaderDerivativesFeaturesNV = PhysicalDeviceComputeShaderDerivativesFeaturesKHR; + struct PhysicalDeviceComputeShaderDerivativesPropertiesKHR; + + //=== VK_KHR_video_decode_av1 === + struct VideoDecodeAV1ProfileInfoKHR; + struct VideoDecodeAV1CapabilitiesKHR; + struct VideoDecodeAV1SessionParametersCreateInfoKHR; + struct VideoDecodeAV1PictureInfoKHR; + struct VideoDecodeAV1DpbSlotInfoKHR; + + //=== VK_KHR_video_encode_av1 === + struct PhysicalDeviceVideoEncodeAV1FeaturesKHR; + struct VideoEncodeAV1CapabilitiesKHR; + struct VideoEncodeAV1QualityLevelPropertiesKHR; + struct VideoEncodeAV1SessionCreateInfoKHR; + struct VideoEncodeAV1SessionParametersCreateInfoKHR; + struct VideoEncodeAV1PictureInfoKHR; + struct VideoEncodeAV1DpbSlotInfoKHR; + struct VideoEncodeAV1ProfileInfoKHR; + struct VideoEncodeAV1QIndexKHR; + struct VideoEncodeAV1FrameSizeKHR; + struct VideoEncodeAV1GopRemainingFrameInfoKHR; + struct VideoEncodeAV1RateControlInfoKHR; + struct VideoEncodeAV1RateControlLayerInfoKHR; + + //=== VK_KHR_video_decode_vp9 === + struct PhysicalDeviceVideoDecodeVP9FeaturesKHR; + struct VideoDecodeVP9ProfileInfoKHR; + struct VideoDecodeVP9CapabilitiesKHR; + struct VideoDecodeVP9PictureInfoKHR; + + //=== VK_KHR_video_maintenance1 === + struct PhysicalDeviceVideoMaintenance1FeaturesKHR; + struct VideoInlineQueryInfoKHR; + + //=== VK_NV_per_stage_descriptor_set === + struct PhysicalDevicePerStageDescriptorSetFeaturesNV; + + //=== VK_QCOM_image_processing2 === + struct PhysicalDeviceImageProcessing2FeaturesQCOM; + struct PhysicalDeviceImageProcessing2PropertiesQCOM; + struct SamplerBlockMatchWindowCreateInfoQCOM; + + //=== VK_QCOM_filter_cubic_weights === + struct PhysicalDeviceCubicWeightsFeaturesQCOM; + struct SamplerCubicWeightsCreateInfoQCOM; + struct BlitImageCubicWeightsInfoQCOM; + + //=== VK_QCOM_ycbcr_degamma === + struct PhysicalDeviceYcbcrDegammaFeaturesQCOM; + struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; + + //=== VK_QCOM_filter_cubic_clamp === + struct PhysicalDeviceCubicClampFeaturesQCOM; + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + + //=== VK_KHR_unified_image_layouts === + struct PhysicalDeviceUnifiedImageLayoutsFeaturesKHR; + struct AttachmentFeedbackLoopInfoEXT; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + struct ScreenBufferPropertiesQNX; + struct ScreenBufferFormatPropertiesQNX; + struct ImportScreenBufferInfoQNX; + struct ExternalFormatQNX; + struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_MSFT_layered_driver === + struct PhysicalDeviceLayeredDriverPropertiesMSFT; + + //=== VK_KHR_calibrated_timestamps === + struct CalibratedTimestampInfoKHR; + using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR; + + //=== VK_KHR_maintenance6 === + struct SetDescriptorBufferOffsetsInfoEXT; + struct BindDescriptorBufferEmbeddedSamplersInfoEXT; + + //=== VK_NV_descriptor_pool_overallocation === + struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + + //=== VK_QCOM_tile_memory_heap === + struct PhysicalDeviceTileMemoryHeapFeaturesQCOM; + struct PhysicalDeviceTileMemoryHeapPropertiesQCOM; + struct TileMemoryRequirementsQCOM; + struct TileMemoryBindInfoQCOM; + struct TileMemorySizeInfoQCOM; + + //=== VK_KHR_copy_memory_indirect === + struct StridedDeviceAddressRangeKHR; + struct CopyMemoryIndirectCommandKHR; + using CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR; + struct CopyMemoryIndirectInfoKHR; + struct CopyMemoryToImageIndirectCommandKHR; + using CopyMemoryToImageIndirectCommandNV = CopyMemoryToImageIndirectCommandKHR; + struct CopyMemoryToImageIndirectInfoKHR; + struct PhysicalDeviceCopyMemoryIndirectFeaturesKHR; + struct PhysicalDeviceCopyMemoryIndirectPropertiesKHR; + using PhysicalDeviceCopyMemoryIndirectPropertiesNV = PhysicalDeviceCopyMemoryIndirectPropertiesKHR; + + //=== VK_EXT_memory_decompression === + struct DecompressMemoryInfoEXT; + struct DecompressMemoryRegionEXT; + struct PhysicalDeviceMemoryDecompressionFeaturesEXT; + using PhysicalDeviceMemoryDecompressionFeaturesNV = PhysicalDeviceMemoryDecompressionFeaturesEXT; + struct PhysicalDeviceMemoryDecompressionPropertiesEXT; + using PhysicalDeviceMemoryDecompressionPropertiesNV = PhysicalDeviceMemoryDecompressionPropertiesEXT; + + //=== VK_NV_display_stereo === + struct DisplaySurfaceStereoCreateInfoNV; + struct DisplayModeStereoPropertiesNV; + + //=== VK_KHR_video_encode_intra_refresh === + struct VideoEncodeIntraRefreshCapabilitiesKHR; + struct VideoEncodeSessionIntraRefreshCreateInfoKHR; + struct VideoEncodeIntraRefreshInfoKHR; + struct VideoReferenceIntraRefreshInfoKHR; + struct PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; + + //=== VK_KHR_video_encode_quantization_map === + struct VideoEncodeQuantizationMapCapabilitiesKHR; + struct VideoFormatQuantizationMapPropertiesKHR; + struct VideoEncodeQuantizationMapInfoKHR; + struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR; + struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; + struct VideoEncodeH264QuantizationMapCapabilitiesKHR; + struct VideoEncodeH265QuantizationMapCapabilitiesKHR; + struct VideoFormatH265QuantizationMapPropertiesKHR; + struct VideoEncodeAV1QuantizationMapCapabilitiesKHR; + struct VideoFormatAV1QuantizationMapPropertiesKHR; + + //=== VK_NV_raw_access_chains === + struct PhysicalDeviceRawAccessChainsFeaturesNV; + + //=== VK_NV_external_compute_queue === + struct ExternalComputeQueueDeviceCreateInfoNV; + struct ExternalComputeQueueCreateInfoNV; + struct ExternalComputeQueueDataParamsNV; + struct PhysicalDeviceExternalComputeQueuePropertiesNV; + + //=== VK_KHR_shader_relaxed_extended_instruction === + struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; + + //=== VK_NV_command_buffer_inheritance === + struct PhysicalDeviceCommandBufferInheritanceFeaturesNV; + + //=== VK_KHR_maintenance7 === + struct PhysicalDeviceMaintenance7FeaturesKHR; + struct PhysicalDeviceMaintenance7PropertiesKHR; + struct PhysicalDeviceLayeredApiPropertiesListKHR; + struct PhysicalDeviceLayeredApiPropertiesKHR; + struct PhysicalDeviceLayeredApiVulkanPropertiesKHR; + + //=== VK_NV_shader_atomic_float16_vector === + struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + + //=== VK_EXT_shader_replicated_composites === + struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT; + + //=== VK_EXT_shader_float8 === + struct PhysicalDeviceShaderFloat8FeaturesEXT; + + //=== VK_NV_ray_tracing_validation === + struct PhysicalDeviceRayTracingValidationFeaturesNV; + + //=== VK_NV_cluster_acceleration_structure === + struct PhysicalDeviceClusterAccelerationStructureFeaturesNV; + struct PhysicalDeviceClusterAccelerationStructurePropertiesNV; + struct ClusterAccelerationStructureClustersBottomLevelInputNV; + struct ClusterAccelerationStructureTriangleClusterInputNV; + struct ClusterAccelerationStructureMoveObjectsInputNV; + union ClusterAccelerationStructureOpInputNV; + struct ClusterAccelerationStructureInputInfoNV; + struct ClusterAccelerationStructureCommandsInfoNV; + struct StridedDeviceAddressNV; + struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV; + struct ClusterAccelerationStructureMoveObjectsInfoNV; + struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNV; + struct ClusterAccelerationStructureBuildTriangleClusterInfoNV; + struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV; + struct ClusterAccelerationStructureInstantiateClusterInfoNV; + struct ClusterAccelerationStructureGetTemplateIndicesInfoNV; + struct RayTracingPipelineClusterAccelerationStructureCreateInfoNV; + + //=== VK_NV_partitioned_acceleration_structure === + struct PhysicalDevicePartitionedAccelerationStructureFeaturesNV; + struct PhysicalDevicePartitionedAccelerationStructurePropertiesNV; + struct PartitionedAccelerationStructureFlagsNV; + struct BuildPartitionedAccelerationStructureIndirectCommandNV; + struct PartitionedAccelerationStructureWriteInstanceDataNV; + struct PartitionedAccelerationStructureUpdateInstanceDataNV; + struct PartitionedAccelerationStructureWritePartitionTranslationDataNV; + struct WriteDescriptorSetPartitionedAccelerationStructureNV; + struct PartitionedAccelerationStructureInstancesInputNV; + struct BuildPartitionedAccelerationStructureInfoNV; + + //=== VK_EXT_device_generated_commands === + struct PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + struct PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + struct GeneratedCommandsMemoryRequirementsInfoEXT; + struct IndirectExecutionSetCreateInfoEXT; + union IndirectExecutionSetInfoEXT; + struct IndirectExecutionSetPipelineInfoEXT; + struct IndirectExecutionSetShaderInfoEXT; + struct GeneratedCommandsInfoEXT; + struct WriteIndirectExecutionSetPipelineEXT; + struct IndirectCommandsLayoutCreateInfoEXT; + struct IndirectCommandsLayoutTokenEXT; + struct DrawIndirectCountIndirectCommandEXT; + struct IndirectCommandsVertexBufferTokenEXT; + struct BindVertexBufferIndirectCommandEXT; + struct IndirectCommandsIndexBufferTokenEXT; + struct BindIndexBufferIndirectCommandEXT; + struct IndirectCommandsPushConstantTokenEXT; + struct IndirectCommandsExecutionSetTokenEXT; + union IndirectCommandsTokenDataEXT; + struct IndirectExecutionSetShaderLayoutInfoEXT; + struct GeneratedCommandsPipelineInfoEXT; + struct GeneratedCommandsShaderInfoEXT; + struct WriteIndirectExecutionSetShaderEXT; + + //=== VK_KHR_maintenance8 === + struct MemoryBarrierAccessFlags3KHR; + struct PhysicalDeviceMaintenance8FeaturesKHR; + + //=== VK_MESA_image_alignment_control === + struct PhysicalDeviceImageAlignmentControlFeaturesMESA; + struct PhysicalDeviceImageAlignmentControlPropertiesMESA; + struct ImageAlignmentControlCreateInfoMESA; + + //=== VK_KHR_shader_fma === + struct PhysicalDeviceShaderFmaFeaturesKHR; + + //=== VK_NV_push_constant_bank === + struct PushConstantBankInfoNV; + struct PhysicalDevicePushConstantBankFeaturesNV; + struct PhysicalDevicePushConstantBankPropertiesNV; + + //=== VK_EXT_ray_tracing_invocation_reorder === + struct PhysicalDeviceRayTracingInvocationReorderPropertiesEXT; + struct PhysicalDeviceRayTracingInvocationReorderFeaturesEXT; + + //=== VK_EXT_depth_clamp_control === + struct PhysicalDeviceDepthClampControlFeaturesEXT; + struct PipelineViewportDepthClampControlCreateInfoEXT; + struct DepthClampRangeEXT; + + //=== VK_KHR_maintenance9 === + struct PhysicalDeviceMaintenance9FeaturesKHR; + struct PhysicalDeviceMaintenance9PropertiesKHR; + struct QueueFamilyOwnershipTransferPropertiesKHR; + + //=== VK_KHR_video_maintenance2 === + struct PhysicalDeviceVideoMaintenance2FeaturesKHR; + struct VideoDecodeH264InlineSessionParametersInfoKHR; + struct VideoDecodeH265InlineSessionParametersInfoKHR; + struct VideoDecodeAV1InlineSessionParametersInfoKHR; + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + struct SurfaceCreateInfoOHOS; +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_HUAWEI_hdr_vivid === + struct PhysicalDeviceHdrVividFeaturesHUAWEI; + struct HdrVividDynamicMetadataHUAWEI; + + //=== VK_NV_cooperative_matrix2 === + struct CooperativeMatrixFlexibleDimensionsPropertiesNV; + struct PhysicalDeviceCooperativeMatrix2FeaturesNV; + struct PhysicalDeviceCooperativeMatrix2PropertiesNV; + + //=== VK_ARM_pipeline_opacity_micromap === + struct PhysicalDevicePipelineOpacityMicromapFeaturesARM; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + struct ImportMemoryMetalHandleInfoEXT; + struct MemoryMetalHandlePropertiesEXT; + struct MemoryGetMetalHandleInfoEXT; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_depth_clamp_zero_one === + struct PhysicalDeviceDepthClampZeroOneFeaturesKHR; + using PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR; + + //=== VK_ARM_performance_counters_by_region === + struct PhysicalDevicePerformanceCountersByRegionFeaturesARM; + struct PhysicalDevicePerformanceCountersByRegionPropertiesARM; + struct PerformanceCounterARM; + struct PerformanceCounterDescriptionARM; + struct RenderPassPerformanceCountersByRegionBeginInfoARM; + + //=== VK_EXT_vertex_attribute_robustness === + struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT; + + //=== VK_ARM_format_pack === + struct PhysicalDeviceFormatPackFeaturesARM; + + //=== VK_VALVE_fragment_density_map_layered === + struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; + struct PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; + struct PipelineFragmentDensityMapLayeredCreateInfoVALVE; + + //=== VK_KHR_robustness2 === + struct PhysicalDeviceRobustness2FeaturesKHR; + using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR; + struct PhysicalDeviceRobustness2PropertiesKHR; + using PhysicalDeviceRobustness2PropertiesEXT = PhysicalDeviceRobustness2PropertiesKHR; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_present_metering === + struct SetPresentConfigNV; + struct PhysicalDevicePresentMeteringFeaturesNV; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_fragment_density_map_offset === + struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; + using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; + struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; + using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; + struct RenderPassFragmentDensityMapOffsetEndInfoEXT; + using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT; + + //=== VK_EXT_zero_initialize_device_memory === + struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + + //=== VK_KHR_present_mode_fifo_latest_ready === + struct PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + using PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + + //=== VK_EXT_shader_64bit_indexing === + struct PhysicalDeviceShader64BitIndexingFeaturesEXT; + + //=== VK_EXT_custom_resolve === + struct PhysicalDeviceCustomResolveFeaturesEXT; + struct BeginCustomResolveInfoEXT; + struct CustomResolveCreateInfoEXT; + + //=== VK_QCOM_data_graph_model === + struct PipelineCacheHeaderVersionDataGraphQCOM; + struct DataGraphPipelineBuiltinModelCreateInfoQCOM; + struct PhysicalDeviceDataGraphModelFeaturesQCOM; + + //=== VK_KHR_maintenance10 === + struct PhysicalDeviceMaintenance10FeaturesKHR; + struct PhysicalDeviceMaintenance10PropertiesKHR; + struct RenderingEndInfoKHR; + using RenderingEndInfoEXT = RenderingEndInfoKHR; + struct RenderingAttachmentFlagsInfoKHR; + struct ResolveImageModeInfoKHR; + + //=== VK_EXT_shader_long_vector === + struct PhysicalDeviceShaderLongVectorFeaturesEXT; + struct PhysicalDeviceShaderLongVectorPropertiesEXT; + + //=== VK_SEC_pipeline_cache_incremental_mode === + struct PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; + + //=== VK_EXT_shader_uniform_buffer_unsized_array === + struct PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; + + //=== VK_NV_compute_occupancy_priority === + struct ComputeOccupancyPriorityParametersNV; + struct PhysicalDeviceComputeOccupancyPriorityFeaturesNV; + + //=== VK_EXT_shader_subgroup_partitioned === + struct PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; + + //=================================== + //=== HANDLE forward declarations === + //=================================== + + //=== VK_VERSION_1_0 === + class Instance; + class PhysicalDevice; + class Device; + class Queue; + class DeviceMemory; + class Fence; + class Semaphore; + class QueryPool; + class Buffer; + class Image; + class ImageView; + class CommandPool; + class CommandBuffer; + class Event; + class BufferView; + class ShaderModule; + class PipelineCache; + class Pipeline; + class PipelineLayout; + class Sampler; + class DescriptorPool; + class DescriptorSet; + class DescriptorSetLayout; + class Framebuffer; + class RenderPass; + + //=== VK_VERSION_1_1 === + class DescriptorUpdateTemplate; + class SamplerYcbcrConversion; + + //=== VK_VERSION_1_3 === + class PrivateDataSlot; + + //=== VK_KHR_surface === + class SurfaceKHR; + + //=== VK_KHR_swapchain === + class SwapchainKHR; + + //=== VK_KHR_display === + class DisplayKHR; + class DisplayModeKHR; + + //=== VK_EXT_debug_report === + class DebugReportCallbackEXT; + + //=== VK_KHR_video_queue === + class VideoSessionKHR; + class VideoSessionParametersKHR; + + //=== VK_NVX_binary_import === + class CuModuleNVX; + class CuFunctionNVX; + + //=== VK_EXT_debug_utils === + class DebugUtilsMessengerEXT; + + //=== VK_EXT_descriptor_heap === + class TensorARM; + + //=== VK_KHR_acceleration_structure === + class AccelerationStructureKHR; + + //=== VK_EXT_validation_cache === + class ValidationCacheEXT; + + //=== VK_NV_ray_tracing === + class AccelerationStructureNV; + + //=== VK_INTEL_performance_query === + class PerformanceConfigurationINTEL; + + //=== VK_KHR_deferred_host_operations === + class DeferredOperationKHR; + + //=== VK_NV_device_generated_commands === + class IndirectCommandsLayoutNV; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + class CudaModuleNV; + class CudaFunctionNV; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + class BufferCollectionFUCHSIA; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + class MicromapEXT; + + //=== VK_ARM_tensors === + class TensorARM; + class TensorViewARM; + + //=== VK_NV_optical_flow === + class OpticalFlowSessionNV; + + //=== VK_EXT_shader_object === + class ShaderEXT; + + //=== VK_KHR_pipeline_binary === + class PipelineBinaryKHR; + + //=== VK_ARM_data_graph === + class DataGraphPipelineSessionARM; + + //=== VK_NV_external_compute_queue === + class ExternalComputeQueueNV; + + //=== VK_EXT_device_generated_commands === + class IndirectCommandsLayoutEXT; + class IndirectExecutionSetEXT; + + typedef void( VKAPI_PTR * PFN_VoidFunction )(); + +#ifndef VULKAN_HPP_NO_SMART_HANDLE + //====================== + //=== UNIQUE HANDLEs === + //====================== + + //=== VK_VERSION_1_0 === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueInstance = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueDevice = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectFree; + }; + + using UniqueDeviceMemory = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueFence = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueSemaphore = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueQueryPool = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueBuffer = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueImage = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueImageView = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueCommandPool = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::PoolFree; + }; + + using UniqueCommandBuffer = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueEvent = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueBufferView = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueShaderModule = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniquePipelineCache = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniquePipeline = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniquePipelineLayout = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueSampler = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueDescriptorPool = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::PoolFree; + }; + + using UniqueDescriptorSet = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueDescriptorSetLayout = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueFramebuffer = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueRenderPass = UniqueHandle; + + //=== VK_VERSION_1_1 === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueDescriptorUpdateTemplate = UniqueHandle; + using UniqueDescriptorUpdateTemplateKHR = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueSamplerYcbcrConversion = UniqueHandle; + using UniqueSamplerYcbcrConversionKHR = UniqueHandle; + + //=== VK_VERSION_1_3 === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniquePrivateDataSlot = UniqueHandle; + using UniquePrivateDataSlotEXT = UniqueHandle; + + //=== VK_KHR_surface === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueSurfaceKHR = UniqueHandle; + + //=== VK_KHR_swapchain === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueSwapchainKHR = UniqueHandle; + + //=== VK_KHR_display === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueDisplayKHR = UniqueHandle; + + //=== VK_EXT_debug_report === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueDebugReportCallbackEXT = UniqueHandle; + + //=== VK_KHR_video_queue === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueVideoSessionKHR = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueVideoSessionParametersKHR = UniqueHandle; + + //=== VK_NVX_binary_import === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueCuModuleNVX = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueCuFunctionNVX = UniqueHandle; + + //=== VK_EXT_debug_utils === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueDebugUtilsMessengerEXT = UniqueHandle; + + //=== VK_EXT_descriptor_heap === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueTensorARM = UniqueHandle; + + //=== VK_KHR_acceleration_structure === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueAccelerationStructureKHR = UniqueHandle; + + //=== VK_EXT_validation_cache === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueValidationCacheEXT = UniqueHandle; + + //=== VK_NV_ray_tracing === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueAccelerationStructureNV = UniqueHandle; + + //=== VK_INTEL_performance_query === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniquePerformanceConfigurationINTEL = UniqueHandle; + + //=== VK_KHR_deferred_host_operations === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueDeferredOperationKHR = UniqueHandle; + + //=== VK_NV_device_generated_commands === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueIndirectCommandsLayoutNV = UniqueHandle; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueCudaModuleNV = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueCudaFunctionNV = UniqueHandle; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueBufferCollectionFUCHSIA = UniqueHandle; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueMicromapEXT = UniqueHandle; + + //=== VK_ARM_tensors === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueTensorViewARM = UniqueHandle; + + //=== VK_NV_optical_flow === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueOpticalFlowSessionNV = UniqueHandle; + + //=== VK_EXT_shader_object === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueShaderEXT = UniqueHandle; + + //=== VK_KHR_pipeline_binary === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniquePipelineBinaryKHR = UniqueHandle; + + //=== VK_ARM_data_graph === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueDataGraphPipelineSessionARM = UniqueHandle; + + //=== VK_NV_external_compute_queue === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueExternalComputeQueueNV = UniqueHandle; + + //=== VK_EXT_device_generated_commands === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueIndirectCommandsLayoutEXT = UniqueHandle; + + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueIndirectExecutionSetEXT = UniqueHandle; +#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ + + //=============== + //=== HANDLEs === + //=============== + + template + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false; + }; + + // wrapper class for handle VkSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceKHR.html + class SurfaceKHR + { + public: + using CType = VkSurfaceKHR; + using NativeType = VkSurfaceKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSurfaceKHR; + + public: + SurfaceKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + SurfaceKHR( SurfaceKHR const & rhs ) = default; + SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + SurfaceKHR( SurfaceKHR && rhs ) = default; + SurfaceKHR & operator=( SurfaceKHR && rhs ) = default; +#else + SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( exchange( rhs.m_surfaceKHR, {} ) ) {} + + SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + m_surfaceKHR = exchange( rhs.m_surfaceKHR, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT + { + m_surfaceKHR = surfaceKHR; + return *this; + } +#endif + + SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_surfaceKHR = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT + { + return m_surfaceKHR; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_surfaceKHR != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_surfaceKHR == VK_NULL_HANDLE; + } + + private: + VkSurfaceKHR m_surfaceKHR = {}; + }; + + template <> + struct CppType + { + using Type = SurfaceKHR; + }; + + template <> + struct CppType + { + using Type = SurfaceKHR; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = SurfaceKHR; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportCallbackEXT.html + class DebugReportCallbackEXT + { + public: + using CType = VkDebugReportCallbackEXT; + using NativeType = VkDebugReportCallbackEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDebugReportCallbackEXT; + + public: + DebugReportCallbackEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + DebugReportCallbackEXT( DebugReportCallbackEXT const & rhs ) = default; + DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) = default; + DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) = default; +#else + DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_debugReportCallbackEXT( exchange( rhs.m_debugReportCallbackEXT, {} ) ) {} + + DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + m_debugReportCallbackEXT = exchange( rhs.m_debugReportCallbackEXT, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT + : m_debugReportCallbackEXT( debugReportCallbackEXT ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT + { + m_debugReportCallbackEXT = debugReportCallbackEXT; + return *this; + } +#endif + + DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_debugReportCallbackEXT = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT + { + return m_debugReportCallbackEXT; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_debugReportCallbackEXT != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_debugReportCallbackEXT == VK_NULL_HANDLE; + } + + private: + VkDebugReportCallbackEXT m_debugReportCallbackEXT = {}; + }; + + template <> + struct CppType + { + using Type = DebugReportCallbackEXT; + }; + + template <> + struct CppType + { + using Type = DebugReportCallbackEXT; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = DebugReportCallbackEXT; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerEXT.html + class DebugUtilsMessengerEXT + { + public: + using CType = VkDebugUtilsMessengerEXT; + using NativeType = VkDebugUtilsMessengerEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & rhs ) = default; + DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) = default; + DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) = default; +#else + DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_debugUtilsMessengerEXT( exchange( rhs.m_debugUtilsMessengerEXT, {} ) ) {} + + DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + m_debugUtilsMessengerEXT = exchange( rhs.m_debugUtilsMessengerEXT, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT + : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT + { + m_debugUtilsMessengerEXT = debugUtilsMessengerEXT; + return *this; + } +#endif + + DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_debugUtilsMessengerEXT = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT + { + return m_debugUtilsMessengerEXT; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_debugUtilsMessengerEXT != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_debugUtilsMessengerEXT == VK_NULL_HANDLE; + } + + private: + VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {}; + }; + + template <> + struct CppType + { + using Type = DebugUtilsMessengerEXT; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = DebugUtilsMessengerEXT; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDisplayKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayKHR.html + class DisplayKHR + { + public: + using CType = VkDisplayKHR; + using NativeType = VkDisplayKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayKHR; + + public: + DisplayKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + DisplayKHR( DisplayKHR const & rhs ) = default; + DisplayKHR & operator=( DisplayKHR const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + DisplayKHR( DisplayKHR && rhs ) = default; + DisplayKHR & operator=( DisplayKHR && rhs ) = default; +#else + DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayKHR( exchange( rhs.m_displayKHR, {} ) ) {} + + DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + m_displayKHR = exchange( rhs.m_displayKHR, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT + { + m_displayKHR = displayKHR; + return *this; + } +#endif + + DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_displayKHR = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT + { + return m_displayKHR; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_displayKHR != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_displayKHR == VK_NULL_HANDLE; + } + + private: + VkDisplayKHR m_displayKHR = {}; + }; + + template <> + struct CppType + { + using Type = DisplayKHR; + }; + + template <> + struct CppType + { + using Type = DisplayKHR; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = DisplayKHR; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainKHR.html + class SwapchainKHR + { + public: + using CType = VkSwapchainKHR; + using NativeType = VkSwapchainKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSwapchainKHR; + + public: + SwapchainKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + SwapchainKHR( SwapchainKHR const & rhs ) = default; + SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + SwapchainKHR( SwapchainKHR && rhs ) = default; + SwapchainKHR & operator=( SwapchainKHR && rhs ) = default; +#else + SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( exchange( rhs.m_swapchainKHR, {} ) ) {} + + SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + m_swapchainKHR = exchange( rhs.m_swapchainKHR, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT + { + m_swapchainKHR = swapchainKHR; + return *this; + } +#endif + + SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_swapchainKHR = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT + { + return m_swapchainKHR; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_swapchainKHR != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_swapchainKHR == VK_NULL_HANDLE; + } + + private: + VkSwapchainKHR m_swapchainKHR = {}; + }; + + template <> + struct CppType + { + using Type = SwapchainKHR; + }; + + template <> + struct CppType + { + using Type = SwapchainKHR; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = SwapchainKHR; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphore.html + class Semaphore + { + public: + using CType = VkSemaphore; + using NativeType = VkSemaphore; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSemaphore; + + public: + Semaphore() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + Semaphore( Semaphore const & rhs ) = default; + Semaphore & operator=( Semaphore const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + Semaphore( Semaphore && rhs ) = default; + Semaphore & operator=( Semaphore && rhs ) = default; +#else + Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT : m_semaphore( exchange( rhs.m_semaphore, {} ) ) {} + + Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT + { + m_semaphore = exchange( rhs.m_semaphore, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT + { + m_semaphore = semaphore; + return *this; + } +#endif + + Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_semaphore = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT + { + return m_semaphore; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_semaphore != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_semaphore == VK_NULL_HANDLE; + } + + private: + VkSemaphore m_semaphore = {}; + }; + + template <> + struct CppType + { + using Type = Semaphore; + }; + + template <> + struct CppType + { + using Type = Semaphore; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Semaphore; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFence.html + class Fence + { + public: + using CType = VkFence; + using NativeType = VkFence; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFence; + + public: + Fence() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + Fence( Fence const & rhs ) = default; + Fence & operator=( Fence const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + Fence( Fence && rhs ) = default; + Fence & operator=( Fence && rhs ) = default; +#else + Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT : m_fence( exchange( rhs.m_fence, {} ) ) {} + + Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT + { + m_fence = exchange( rhs.m_fence, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT + { + m_fence = fence; + return *this; + } +#endif + + Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_fence = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT + { + return m_fence; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_fence != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_fence == VK_NULL_HANDLE; + } + + private: + VkFence m_fence = {}; + }; + + template <> + struct CppType + { + using Type = Fence; + }; + + template <> + struct CppType + { + using Type = Fence; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Fence; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationINTEL.html + class PerformanceConfigurationINTEL + { + public: + using CType = VkPerformanceConfigurationINTEL; + using NativeType = VkPerformanceConfigurationINTEL; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePerformanceConfigurationINTEL; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + PerformanceConfigurationINTEL() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & rhs ) = default; + PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) = default; + PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) = default; +#else + PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT + : m_performanceConfigurationINTEL( exchange( rhs.m_performanceConfigurationINTEL, {} ) ) + { + } + + PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT + { + m_performanceConfigurationINTEL = exchange( rhs.m_performanceConfigurationINTEL, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT + : m_performanceConfigurationINTEL( performanceConfigurationINTEL ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT + { + m_performanceConfigurationINTEL = performanceConfigurationINTEL; + return *this; + } +#endif + + PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_performanceConfigurationINTEL = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT + { + return m_performanceConfigurationINTEL; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_performanceConfigurationINTEL != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_performanceConfigurationINTEL == VK_NULL_HANDLE; + } + + private: + VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {}; + }; + + template <> + struct CppType + { + using Type = PerformanceConfigurationINTEL; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = PerformanceConfigurationINTEL; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPool.html + class QueryPool + { + public: + using CType = VkQueryPool; + using NativeType = VkQueryPool; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueryPool; + + public: + QueryPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + QueryPool( QueryPool const & rhs ) = default; + QueryPool & operator=( QueryPool const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + QueryPool( QueryPool && rhs ) = default; + QueryPool & operator=( QueryPool && rhs ) = default; +#else + QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT : m_queryPool( exchange( rhs.m_queryPool, {} ) ) {} + + QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT + { + m_queryPool = exchange( rhs.m_queryPool, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT + { + m_queryPool = queryPool; + return *this; + } +#endif + + QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_queryPool = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT + { + return m_queryPool; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_queryPool != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_queryPool == VK_NULL_HANDLE; + } + + private: + VkQueryPool m_queryPool = {}; + }; + + template <> + struct CppType + { + using Type = QueryPool; + }; + + template <> + struct CppType + { + using Type = QueryPool; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = QueryPool; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuffer.html + class Buffer + { + public: + using CType = VkBuffer; + using NativeType = VkBuffer; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBuffer; + + public: + Buffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + Buffer( Buffer const & rhs ) = default; + Buffer & operator=( Buffer const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + Buffer( Buffer && rhs ) = default; + Buffer & operator=( Buffer && rhs ) = default; +#else + Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT : m_buffer( exchange( rhs.m_buffer, {} ) ) {} + + Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT + { + m_buffer = exchange( rhs.m_buffer, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT + { + m_buffer = buffer; + return *this; + } +#endif + + Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_buffer = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT + { + return m_buffer; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_buffer != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_buffer == VK_NULL_HANDLE; + } + + private: + VkBuffer m_buffer = {}; + }; + + template <> + struct CppType + { + using Type = Buffer; + }; + + template <> + struct CppType + { + using Type = Buffer; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Buffer; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayout.html + class PipelineLayout + { + public: + using CType = VkPipelineLayout; + using NativeType = VkPipelineLayout; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineLayout; + + public: + PipelineLayout() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + PipelineLayout( PipelineLayout const & rhs ) = default; + PipelineLayout & operator=( PipelineLayout const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + PipelineLayout( PipelineLayout && rhs ) = default; + PipelineLayout & operator=( PipelineLayout && rhs ) = default; +#else + PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( exchange( rhs.m_pipelineLayout, {} ) ) {} + + PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT + { + m_pipelineLayout = exchange( rhs.m_pipelineLayout, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT + { + m_pipelineLayout = pipelineLayout; + return *this; + } +#endif + + PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_pipelineLayout = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineLayout; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineLayout != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineLayout == VK_NULL_HANDLE; + } + + private: + VkPipelineLayout m_pipelineLayout = {}; + }; + + template <> + struct CppType + { + using Type = PipelineLayout; + }; + + template <> + struct CppType + { + using Type = PipelineLayout; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = PipelineLayout; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSet.html + class DescriptorSet + { + public: + using CType = VkDescriptorSet; + using NativeType = VkDescriptorSet; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSet; + + public: + DescriptorSet() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + DescriptorSet( DescriptorSet const & rhs ) = default; + DescriptorSet & operator=( DescriptorSet const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + DescriptorSet( DescriptorSet && rhs ) = default; + DescriptorSet & operator=( DescriptorSet && rhs ) = default; +#else + DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( exchange( rhs.m_descriptorSet, {} ) ) {} + + DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT + { + m_descriptorSet = exchange( rhs.m_descriptorSet, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT + { + m_descriptorSet = descriptorSet; + return *this; + } +#endif + + DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_descriptorSet = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorSet; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorSet != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorSet == VK_NULL_HANDLE; + } + + private: + VkDescriptorSet m_descriptorSet = {}; + }; + + template <> + struct CppType + { + using Type = DescriptorSet; + }; + + template <> + struct CppType + { + using Type = DescriptorSet; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = DescriptorSet; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageView.html + class ImageView + { + public: + using CType = VkImageView; + using NativeType = VkImageView; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImageView; + + public: + ImageView() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + ImageView( ImageView const & rhs ) = default; + ImageView & operator=( ImageView const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + ImageView( ImageView && rhs ) = default; + ImageView & operator=( ImageView && rhs ) = default; +#else + ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT : m_imageView( exchange( rhs.m_imageView, {} ) ) {} + + ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT + { + m_imageView = exchange( rhs.m_imageView, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT + { + m_imageView = imageView; + return *this; + } +#endif + + ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_imageView = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT + { + return m_imageView; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_imageView != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_imageView == VK_NULL_HANDLE; + } + + private: + VkImageView m_imageView = {}; + }; + + template <> + struct CppType + { + using Type = ImageView; + }; + + template <> + struct CppType + { + using Type = ImageView; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = ImageView; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipeline.html + class Pipeline + { + public: + using CType = VkPipeline; + using NativeType = VkPipeline; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipeline; + + public: + Pipeline() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + Pipeline( Pipeline const & rhs ) = default; + Pipeline & operator=( Pipeline const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + Pipeline( Pipeline && rhs ) = default; + Pipeline & operator=( Pipeline && rhs ) = default; +#else + Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT : m_pipeline( exchange( rhs.m_pipeline, {} ) ) {} + + Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT + { + m_pipeline = exchange( rhs.m_pipeline, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT + { + m_pipeline = pipeline; + return *this; + } +#endif + + Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_pipeline = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT + { + return m_pipeline; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_pipeline != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_pipeline == VK_NULL_HANDLE; + } + + private: + VkPipeline m_pipeline = {}; + }; + + template <> + struct CppType + { + using Type = Pipeline; + }; + + template <> + struct CppType + { + using Type = Pipeline; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Pipeline; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderEXT.html + class ShaderEXT + { + public: + using CType = VkShaderEXT; + using NativeType = VkShaderEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + ShaderEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + ShaderEXT( ShaderEXT const & rhs ) = default; + ShaderEXT & operator=( ShaderEXT const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + ShaderEXT( ShaderEXT && rhs ) = default; + ShaderEXT & operator=( ShaderEXT && rhs ) = default; +#else + ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( exchange( rhs.m_shaderEXT, {} ) ) {} + + ShaderEXT & operator=( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + m_shaderEXT = exchange( rhs.m_shaderEXT, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( shaderEXT ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + ShaderEXT & operator=( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT + { + m_shaderEXT = shaderEXT; + return *this; + } +#endif + + ShaderEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_shaderEXT = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT + { + return m_shaderEXT; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_shaderEXT != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_shaderEXT == VK_NULL_HANDLE; + } + + private: + VkShaderEXT m_shaderEXT = {}; + }; + + template <> + struct CppType + { + using Type = ShaderEXT; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = ShaderEXT; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImage.html + class Image + { + public: + using CType = VkImage; + using NativeType = VkImage; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImage; + + public: + Image() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + Image( Image const & rhs ) = default; + Image & operator=( Image const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + Image( Image && rhs ) = default; + Image & operator=( Image && rhs ) = default; +#else + Image( Image && rhs ) VULKAN_HPP_NOEXCEPT : m_image( exchange( rhs.m_image, {} ) ) {} + + Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT + { + m_image = exchange( rhs.m_image, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT + { + m_image = image; + return *this; + } +#endif + + Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_image = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT + { + return m_image; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_image != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_image == VK_NULL_HANDLE; + } + + private: + VkImage m_image = {}; + }; + + template <> + struct CppType + { + using Type = Image; + }; + + template <> + struct CppType + { + using Type = Image; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Image; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureNV.html + class AccelerationStructureNV + { + public: + using CType = VkAccelerationStructureNV; + using NativeType = VkAccelerationStructureNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureNV; + + public: + AccelerationStructureNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + AccelerationStructureNV( AccelerationStructureNV const & rhs ) = default; + AccelerationStructureNV & operator=( AccelerationStructureNV const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + AccelerationStructureNV( AccelerationStructureNV && rhs ) = default; + AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) = default; +#else + AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT : m_accelerationStructureNV( exchange( rhs.m_accelerationStructureNV, {} ) ) + { + } + + AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT + { + m_accelerationStructureNV = exchange( rhs.m_accelerationStructureNV, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT + : m_accelerationStructureNV( accelerationStructureNV ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT + { + m_accelerationStructureNV = accelerationStructureNV; + return *this; + } +#endif + + AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_accelerationStructureNV = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT + { + return m_accelerationStructureNV; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_accelerationStructureNV != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_accelerationStructureNV == VK_NULL_HANDLE; + } + + private: + VkAccelerationStructureNV m_accelerationStructureNV = {}; + }; + + template <> + struct CppType + { + using Type = AccelerationStructureNV; + }; + + template <> + struct CppType + { + using Type = AccelerationStructureNV; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = AccelerationStructureNV; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDataGraphPipelineSessionARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionARM.html + class DataGraphPipelineSessionARM + { + public: + using CType = VkDataGraphPipelineSessionARM; + using NativeType = VkDataGraphPipelineSessionARM; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDataGraphPipelineSessionARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + DataGraphPipelineSessionARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + DataGraphPipelineSessionARM( DataGraphPipelineSessionARM const & rhs ) = default; + DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + DataGraphPipelineSessionARM( DataGraphPipelineSessionARM && rhs ) = default; + DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM && rhs ) = default; +#else + DataGraphPipelineSessionARM( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT + : m_dataGraphPipelineSessionARM( exchange( rhs.m_dataGraphPipelineSessionARM, {} ) ) + { + } + + DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT + { + m_dataGraphPipelineSessionARM = exchange( rhs.m_dataGraphPipelineSessionARM, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DataGraphPipelineSessionARM( VkDataGraphPipelineSessionARM dataGraphPipelineSessionARM ) VULKAN_HPP_NOEXCEPT + : m_dataGraphPipelineSessionARM( dataGraphPipelineSessionARM ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + DataGraphPipelineSessionARM & operator=( VkDataGraphPipelineSessionARM dataGraphPipelineSessionARM ) VULKAN_HPP_NOEXCEPT + { + m_dataGraphPipelineSessionARM = dataGraphPipelineSessionARM; + return *this; + } +#endif + + DataGraphPipelineSessionARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_dataGraphPipelineSessionARM = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDataGraphPipelineSessionARM() const VULKAN_HPP_NOEXCEPT + { + return m_dataGraphPipelineSessionARM; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_dataGraphPipelineSessionARM != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_dataGraphPipelineSessionARM == VK_NULL_HANDLE; + } + + private: + VkDataGraphPipelineSessionARM m_dataGraphPipelineSessionARM = {}; + }; + + template <> + struct CppType + { + using Type = DataGraphPipelineSessionARM; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = DataGraphPipelineSessionARM; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionNV.html + class OpticalFlowSessionNV + { + public: + using CType = VkOpticalFlowSessionNV; + using NativeType = VkOpticalFlowSessionNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eOpticalFlowSessionNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + OpticalFlowSessionNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + OpticalFlowSessionNV( OpticalFlowSessionNV const & rhs ) = default; + OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) = default; + OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) = default; +#else + OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_opticalFlowSessionNV( exchange( rhs.m_opticalFlowSessionNV, {} ) ) {} + + OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT + { + m_opticalFlowSessionNV = exchange( rhs.m_opticalFlowSessionNV, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT + : m_opticalFlowSessionNV( opticalFlowSessionNV ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT + { + m_opticalFlowSessionNV = opticalFlowSessionNV; + return *this; + } +#endif + + OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_opticalFlowSessionNV = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT + { + return m_opticalFlowSessionNV; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_opticalFlowSessionNV != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_opticalFlowSessionNV == VK_NULL_HANDLE; + } + + private: + VkOpticalFlowSessionNV m_opticalFlowSessionNV = {}; + }; + + template <> + struct CppType + { + using Type = OpticalFlowSessionNV; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = OpticalFlowSessionNV; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplate.html + class DescriptorUpdateTemplate + { + public: + using CType = VkDescriptorUpdateTemplate; + using NativeType = VkDescriptorUpdateTemplate; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorUpdateTemplate; + + public: + DescriptorUpdateTemplate() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + DescriptorUpdateTemplate( DescriptorUpdateTemplate const & rhs ) = default; + DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) = default; + DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) = default; +#else + DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT + : m_descriptorUpdateTemplate( exchange( rhs.m_descriptorUpdateTemplate, {} ) ) + { + } + + DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT + { + m_descriptorUpdateTemplate = exchange( rhs.m_descriptorUpdateTemplate, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT + : m_descriptorUpdateTemplate( descriptorUpdateTemplate ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT + { + m_descriptorUpdateTemplate = descriptorUpdateTemplate; + return *this; + } +#endif + + DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_descriptorUpdateTemplate = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorUpdateTemplate; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorUpdateTemplate != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorUpdateTemplate == VK_NULL_HANDLE; + } + + private: + VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {}; + }; + + template <> + struct CppType + { + using Type = DescriptorUpdateTemplate; + }; + + template <> + struct CppType + { + using Type = DescriptorUpdateTemplate; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = DescriptorUpdateTemplate; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; + + // wrapper class for handle VkEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEvent.html + class Event + { + public: + using CType = VkEvent; + using NativeType = VkEvent; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eEvent; + + public: + Event() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + Event( Event const & rhs ) = default; + Event & operator=( Event const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + Event( Event && rhs ) = default; + Event & operator=( Event && rhs ) = default; +#else + Event( Event && rhs ) VULKAN_HPP_NOEXCEPT : m_event( exchange( rhs.m_event, {} ) ) {} + + Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT + { + m_event = exchange( rhs.m_event, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT + { + m_event = event; + return *this; + } +#endif + + Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_event = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT + { + return m_event; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_event != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_event == VK_NULL_HANDLE; + } + + private: + VkEvent m_event = {}; + }; + + template <> + struct CppType + { + using Type = Event; + }; + + template <> + struct CppType + { + using Type = Event; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Event; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureKHR.html + class AccelerationStructureKHR + { + public: + using CType = VkAccelerationStructureKHR; + using NativeType = VkAccelerationStructureKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureKHR; + + public: + AccelerationStructureKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + AccelerationStructureKHR( AccelerationStructureKHR const & rhs ) = default; + AccelerationStructureKHR & operator=( AccelerationStructureKHR const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + AccelerationStructureKHR( AccelerationStructureKHR && rhs ) = default; + AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) = default; +#else + AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT + : m_accelerationStructureKHR( exchange( rhs.m_accelerationStructureKHR, {} ) ) + { + } + + AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + m_accelerationStructureKHR = exchange( rhs.m_accelerationStructureKHR, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT + : m_accelerationStructureKHR( accelerationStructureKHR ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT + { + m_accelerationStructureKHR = accelerationStructureKHR; + return *this; + } +#endif + + AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_accelerationStructureKHR = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT + { + return m_accelerationStructureKHR; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_accelerationStructureKHR != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_accelerationStructureKHR == VK_NULL_HANDLE; + } + + private: + VkAccelerationStructureKHR m_accelerationStructureKHR = {}; + }; + + template <> + struct CppType + { + using Type = AccelerationStructureKHR; + }; + + template <> + struct CppType + { + using Type = AccelerationStructureKHR; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = AccelerationStructureKHR; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapEXT.html + class MicromapEXT + { + public: + using CType = VkMicromapEXT; + using NativeType = VkMicromapEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eMicromapEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + MicromapEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + MicromapEXT( MicromapEXT const & rhs ) = default; + MicromapEXT & operator=( MicromapEXT const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + MicromapEXT( MicromapEXT && rhs ) = default; + MicromapEXT & operator=( MicromapEXT && rhs ) = default; +#else + MicromapEXT( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( exchange( rhs.m_micromapEXT, {} ) ) {} + + MicromapEXT & operator=( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + m_micromapEXT = exchange( rhs.m_micromapEXT, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT + { + m_micromapEXT = micromapEXT; + return *this; + } +#endif + + MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_micromapEXT = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT + { + return m_micromapEXT; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_micromapEXT != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_micromapEXT == VK_NULL_HANDLE; + } + + private: + VkMicromapEXT m_micromapEXT = {}; + }; + + template <> + struct CppType + { + using Type = MicromapEXT; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = MicromapEXT; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBuffer.html + class CommandBuffer + { + public: + using CType = VkCommandBuffer; + using NativeType = VkCommandBuffer; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandBuffer; + + public: + CommandBuffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + CommandBuffer( CommandBuffer const & rhs ) = default; + CommandBuffer & operator=( CommandBuffer const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + CommandBuffer( CommandBuffer && rhs ) = default; + CommandBuffer & operator=( CommandBuffer && rhs ) = default; +#else + CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( exchange( rhs.m_commandBuffer, {} ) ) {} + + CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT + { + m_commandBuffer = exchange( rhs.m_commandBuffer, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {} + + CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT + { + m_commandBuffer = commandBuffer; + return *this; + } + + CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_commandBuffer = {}; + return *this; + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD Result begin( const CommandBufferBeginInfo * pBeginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type begin( const CommandBufferBeginInfo & beginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD Result end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD Result reset( CommandBufferResetFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type reset( CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html + template ::type = true> + void copyBuffer( Buffer srcBuffer, + Buffer dstBuffer, + uint32_t regionCount, + const BufferCopy * pRegions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html + template ::type = true> + void copyBuffer( Buffer srcBuffer, + Buffer dstBuffer, + ArrayProxy const & regions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html + template ::type = true> + void copyImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + uint32_t regionCount, + const ImageCopy * pRegions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html + template ::type = true> + void copyImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html + template ::type = true> + void copyBufferToImage( Buffer srcBuffer, + Image dstImage, + ImageLayout dstImageLayout, + uint32_t regionCount, + const BufferImageCopy * pRegions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html + template ::type = true> + void copyBufferToImage( Buffer srcBuffer, + Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html + template ::type = true> + void copyImageToBuffer( Image srcImage, + ImageLayout srcImageLayout, + Buffer dstBuffer, + uint32_t regionCount, + const BufferImageCopy * pRegions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html + template ::type = true> + void copyImageToBuffer( Image srcImage, + ImageLayout srcImageLayout, + Buffer dstBuffer, + ArrayProxy const & regions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html + template ::type = true> + void updateBuffer( Buffer dstBuffer, + DeviceSize dstOffset, + DeviceSize dataSize, + const void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html + template ::type = true> + void updateBuffer( Buffer dstBuffer, + DeviceSize dstOffset, + ArrayProxy const & data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html + template ::type = true> + void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const + VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html + template ::type = true> + void pipelineBarrier( PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + DependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const MemoryBarrier * pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const BufferMemoryBarrier * pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const ImageMemoryBarrier * pImageMemoryBarriers, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html + template ::type = true> + void pipelineBarrier( PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + DependencyFlags dependencyFlags, + ArrayProxy const & memoryBarriers, + ArrayProxy const & bufferMemoryBarriers, + ArrayProxy const & imageMemoryBarriers, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html + template ::type = true> + void beginQuery( QueryPool queryPool, + uint32_t query, + QueryControlFlags flags, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html + template ::type = true> + void endQuery( QueryPool queryPool, uint32_t query, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html + template ::type = true> + void resetQueryPool( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html + template ::type = true> + void writeTimestamp( PipelineStageFlagBits pipelineStage, + QueryPool queryPool, + uint32_t query, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html + template ::type = true> + void copyQueryPoolResults( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + Buffer dstBuffer, + DeviceSize dstOffset, + DeviceSize stride, + QueryResultFlags flags, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html + template ::type = true> + void executeCommands( uint32_t commandBufferCount, + const CommandBuffer * pCommandBuffers, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html + template ::type = true> + void executeCommands( ArrayProxy const & commandBuffers, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html + template ::type = true> + void bindPipeline( PipelineBindPoint pipelineBindPoint, + Pipeline pipeline, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html + template ::type = true> + void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const DescriptorSet * pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t * pDynamicOffsets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html + template ::type = true> + void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t firstSet, + ArrayProxy const & descriptorSets, + ArrayProxy const & dynamicOffsets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html + template ::type = true> + void clearColorImage( Image image, + ImageLayout imageLayout, + const ClearColorValue * pColor, + uint32_t rangeCount, + const ImageSubresourceRange * pRanges, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html + template ::type = true> + void clearColorImage( Image image, + ImageLayout imageLayout, + const ClearColorValue & color, + ArrayProxy const & ranges, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html + template ::type = true> + void dispatch( uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html + template ::type = true> + void dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html + template ::type = true> + void setEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html + template ::type = true> + void resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html + template ::type = true> + void waitEvents( uint32_t eventCount, + const Event * pEvents, + PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const MemoryBarrier * pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const BufferMemoryBarrier * pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const ImageMemoryBarrier * pImageMemoryBarriers, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html + template ::type = true> + void waitEvents( ArrayProxy const & events, + PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + ArrayProxy const & memoryBarriers, + ArrayProxy const & bufferMemoryBarriers, + ArrayProxy const & imageMemoryBarriers, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html + template ::type = true> + void pushConstants( PipelineLayout layout, + ShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void * pValues, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html + template ::type = true> + void pushConstants( PipelineLayout layout, + ShaderStageFlags stageFlags, + uint32_t offset, + ArrayProxy const & values, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html + template ::type = true> + void setViewport( uint32_t firstViewport, + uint32_t viewportCount, + const Viewport * pViewports, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html + template ::type = true> + void setViewport( uint32_t firstViewport, + ArrayProxy const & viewports, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html + template ::type = true> + void setScissor( uint32_t firstScissor, + uint32_t scissorCount, + const Rect2D * pScissors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html + template ::type = true> + void setScissor( uint32_t firstScissor, + ArrayProxy const & scissors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html + template ::type = true> + void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html + template ::type = true> + void setDepthBias( float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html + template ::type = true> + void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html + template ::type = true> + void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html + template ::type = true> + void setStencilCompareMask( StencilFaceFlags faceMask, + uint32_t compareMask, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html + template ::type = true> + void setStencilWriteMask( StencilFaceFlags faceMask, + uint32_t writeMask, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html + template ::type = true> + void setStencilReference( StencilFaceFlags faceMask, + uint32_t reference, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html + template ::type = true> + void bindIndexBuffer( Buffer buffer, + DeviceSize offset, + IndexType indexType, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html + template ::type = true> + void bindVertexBuffers( uint32_t firstBinding, + uint32_t bindingCount, + const Buffer * pBuffers, + const DeviceSize * pOffsets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html + template ::type = true> + void bindVertexBuffers( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html + template ::type = true> + void draw( uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html + template ::type = true> + void drawIndexed( uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html + template ::type = true> + void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) + const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html + template ::type = true> + void drawIndexedIndirect( Buffer buffer, + DeviceSize offset, + uint32_t drawCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html + template ::type = true> + void blitImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + uint32_t regionCount, + const ImageBlit * pRegions, + Filter filter, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html + template ::type = true> + void blitImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions, + Filter filter, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html + template ::type = true> + void clearDepthStencilImage( Image image, + ImageLayout imageLayout, + const ClearDepthStencilValue * pDepthStencil, + uint32_t rangeCount, + const ImageSubresourceRange * pRanges, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html + template ::type = true> + void clearDepthStencilImage( Image image, + ImageLayout imageLayout, + const ClearDepthStencilValue & depthStencil, + ArrayProxy const & ranges, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html + template ::type = true> + void clearAttachments( uint32_t attachmentCount, + const ClearAttachment * pAttachments, + uint32_t rectCount, + const ClearRect * pRects, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html + template ::type = true> + void clearAttachments( ArrayProxy const & attachments, + ArrayProxy const & rects, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html + template ::type = true> + void resolveImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + uint32_t regionCount, + const ImageResolve * pRegions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html + template ::type = true> + void resolveImage( Image srcImage, + ImageLayout srcImageLayout, + Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html + template ::type = true> + void beginRenderPass( const RenderPassBeginInfo * pRenderPassBegin, + SubpassContents contents, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html + template ::type = true> + void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, + SubpassContents contents, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html + template ::type = true> + void nextSubpass( SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html + template ::type = true> + void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html + template ::type = true> + void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html + template ::type = true> + void dispatchBase( uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_VERSION_1_2 === + + // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html + template ::type = true> + void drawIndirectCount( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexedIndirectCount, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html + template ::type = true> + void drawIndexedIndirectCount( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html + template ::type = true> + void beginRenderPass2( const RenderPassBeginInfo * pRenderPassBegin, + const SubpassBeginInfo * pSubpassBeginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html + template ::type = true> + void beginRenderPass2( const RenderPassBeginInfo & renderPassBegin, + const SubpassBeginInfo & subpassBeginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html + template ::type = true> + void nextSubpass2( const SubpassBeginInfo * pSubpassBeginInfo, + const SubpassEndInfo * pSubpassEndInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html + template ::type = true> + void nextSubpass2( const SubpassBeginInfo & subpassBeginInfo, + const SubpassEndInfo & subpassEndInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html + template ::type = true> + void endRenderPass2( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html + template ::type = true> + void endRenderPass2( const SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_3 === + + // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html + template ::type = true> + void pipelineBarrier2( const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html + template ::type = true> + void pipelineBarrier2( const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html + template ::type = true> + void writeTimestamp2( PipelineStageFlags2 stage, + QueryPool queryPool, + uint32_t query, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html + template ::type = true> + void copyBuffer2( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html + template ::type = true> + void copyBuffer2( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html + template ::type = true> + void copyImage2( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html + template ::type = true> + void copyImage2( const CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html + template ::type = true> + void copyBufferToImage2( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html + template ::type = true> + void copyBufferToImage2( const CopyBufferToImageInfo2 & copyBufferToImageInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html + template ::type = true> + void copyImageToBuffer2( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html + template ::type = true> + void copyImageToBuffer2( const CopyImageToBufferInfo2 & copyImageToBufferInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html + template ::type = true> + void + setEvent2( Event event, const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html + template ::type = true> + void setEvent2( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html + template ::type = true> + void resetEvent2( Event event, PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html + template ::type = true> + void waitEvents2( uint32_t eventCount, + const Event * pEvents, + const DependencyInfo * pDependencyInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html + template ::type = true> + void waitEvents2( ArrayProxy const & events, + ArrayProxy const & dependencyInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html + template ::type = true> + void blitImage2( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html + template ::type = true> + void blitImage2( const BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html + template ::type = true> + void resolveImage2( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html + template ::type = true> + void resolveImage2( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html + template ::type = true> + void beginRendering( const RenderingInfo * pRenderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html + template ::type = true> + void beginRendering( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html + template ::type = true> + void endRendering( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html + template ::type = true> + void setCullMode( CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html + template ::type = true> + void setFrontFace( FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html + template ::type = true> + void setPrimitiveTopology( PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html + template ::type = true> + void setViewportWithCount( uint32_t viewportCount, + const Viewport * pViewports, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html + template ::type = true> + void setViewportWithCount( ArrayProxy const & viewports, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html + template ::type = true> + void setScissorWithCount( uint32_t scissorCount, + const Rect2D * pScissors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html + template ::type = true> + void setScissorWithCount( ArrayProxy const & scissors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html + template ::type = true> + void bindVertexBuffers2( uint32_t firstBinding, + uint32_t bindingCount, + const Buffer * pBuffers, + const DeviceSize * pOffsets, + const DeviceSize * pSizes, + const DeviceSize * pStrides, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html + template ::type = true> + void bindVertexBuffers2( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + ArrayProxy const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html + template ::type = true> + void setDepthTestEnable( Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html + template ::type = true> + void setDepthWriteEnable( Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html + template ::type = true> + void setDepthCompareOp( CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBoundsTestEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html + template ::type = true> + void setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html + template ::type = true> + void setStencilTestEnable( Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html + template ::type = true> + void setStencilOp( StencilFaceFlags faceMask, + StencilOp failOp, + StencilOp passOp, + StencilOp depthFailOp, + CompareOp compareOp, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRasterizerDiscardEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html + template ::type = true> + void setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html + template ::type = true> + void setDepthBiasEnable( Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetPrimitiveRestartEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html + template ::type = true> + void setPrimitiveRestartEnable( Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_VERSION_1_4 === + + // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html + template ::type = true> + void pushDescriptorSet( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const WriteDescriptorSet * pDescriptorWrites, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html + template ::type = true> + void pushDescriptorSet( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t set, + ArrayProxy const & descriptorWrites, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html + template ::type = true> + void pushDescriptorSetWithTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, + PipelineLayout layout, + uint32_t set, + const void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html + template ::type = true> + void pushDescriptorSetWithTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, + PipelineLayout layout, + uint32_t set, + DataType const & data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html + template ::type = true> + void bindDescriptorSets2( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html + template ::type = true> + void bindDescriptorSets2( const BindDescriptorSetsInfo & bindDescriptorSetsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html + template ::type = true> + void pushConstants2( const PushConstantsInfo * pPushConstantsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html + template ::type = true> + void pushConstants2( const PushConstantsInfo & pushConstantsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html + template ::type = true> + void pushDescriptorSet2( const PushDescriptorSetInfo * pPushDescriptorSetInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html + template ::type = true> + void pushDescriptorSet2( const PushDescriptorSetInfo & pushDescriptorSetInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html + template ::type = true> + void pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html + template ::type = true> + void pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html + template ::type = true> + void setLineStipple( uint32_t lineStippleFactor, + uint16_t lineStipplePattern, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html + template ::type = true> + void bindIndexBuffer2( Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) + const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRenderingAttachmentLocations, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html + template ::type = true> + void setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo * pLocationInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetRenderingAttachmentLocations, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html + template ::type = true> + void setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo & locationInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html + template ::type = true> + void setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html + template ::type = true> + void setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_debug_marker === + + // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html + template ::type = true> + void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html + template ::type = true> + void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html + template ::type = true> + void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html + template ::type = true> + void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html + template ::type = true> + void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_video_queue === + + // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html + template ::type = true> + void beginVideoCodingKHR( const VideoBeginCodingInfoKHR * pBeginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html + template ::type = true> + void beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html + template ::type = true> + void endVideoCodingKHR( const VideoEndCodingInfoKHR * pEndCodingInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html + template ::type = true> + void endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html + template ::type = true> + void controlVideoCodingKHR( const VideoCodingControlInfoKHR * pCodingControlInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html + template ::type = true> + void controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_video_decode_queue === + + // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html + template ::type = true> + void decodeVideoKHR( const VideoDecodeInfoKHR * pDecodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html + template ::type = true> + void decodeVideoKHR( const VideoDecodeInfoKHR & decodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_transform_feedback === + + // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html + template ::type = true> + void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, + uint32_t bindingCount, + const Buffer * pBuffers, + const DeviceSize * pOffsets, + const DeviceSize * pSizes, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html + template ::type = true> + void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginTransformFeedbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html + template ::type = true> + void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const Buffer * pCounterBuffers, + const DeviceSize * pCounterBufferOffsets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginTransformFeedbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html + template ::type = true> + void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, + ArrayProxy const & counterBuffers, + ArrayProxy const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndTransformFeedbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html + template ::type = true> + void endTransformFeedbackEXT( uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const Buffer * pCounterBuffers, + const DeviceSize * pCounterBufferOffsets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndTransformFeedbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html + template ::type = true> + void endTransformFeedbackEXT( uint32_t firstCounterBuffer, + ArrayProxy const & counterBuffers, + ArrayProxy const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html + template ::type = true> + void beginQueryIndexedEXT( QueryPool queryPool, + uint32_t query, + QueryControlFlags flags, + uint32_t index, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html + template ::type = true> + void endQueryIndexedEXT( QueryPool queryPool, + uint32_t query, + uint32_t index, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndirectByteCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html + template ::type = true> + void drawIndirectByteCountEXT( uint32_t instanceCount, + uint32_t firstInstance, + Buffer counterBuffer, + DeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NVX_binary_import === + + // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html + template ::type = true> + void cuLaunchKernelNVX( const CuLaunchInfoNVX * pLaunchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html + template ::type = true> + void cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_AMD_draw_indirect_count === + + // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html + template ::type = true> + void drawIndirectCountAMD( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html + template ::type = true> + void drawIndexedIndirectCountAMD( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_dynamic_rendering === + + // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html + template ::type = true> + void beginRenderingKHR( const RenderingInfo * pRenderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html + template ::type = true> + void beginRenderingKHR( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html + template ::type = true> + void endRenderingKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_device_group === + + // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html + template ::type = true> + void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html + template ::type = true> + void dispatchBaseKHR( uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_push_descriptor === + + // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html + template ::type = true> + void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const WriteDescriptorSet * pDescriptorWrites, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html + template ::type = true> + void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t set, + ArrayProxy const & descriptorWrites, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html + template ::type = true> + void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, + PipelineLayout layout, + uint32_t set, + const void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html + template ::type = true> + void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, + PipelineLayout layout, + uint32_t set, + DataType const & data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_conditional_rendering === + + // wrapper function for command vkCmdBeginConditionalRenderingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html + template ::type = true> + void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginConditionalRenderingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html + template ::type = true> + void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndConditionalRenderingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html + template ::type = true> + void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_clip_space_w_scaling === + + // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html + template ::type = true> + void setViewportWScalingNV( uint32_t firstViewport, + uint32_t viewportCount, + const ViewportWScalingNV * pViewportWScalings, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html + template ::type = true> + void setViewportWScalingNV( uint32_t firstViewport, + ArrayProxy const & viewportWScalings, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_discard_rectangles === + + // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html + template ::type = true> + void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const Rect2D * pDiscardRectangles, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html + template ::type = true> + void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, + ArrayProxy const & discardRectangles, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html + template ::type = true> + void setDiscardRectangleEnableEXT( Bool32 discardRectangleEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html + template ::type = true> + void setDiscardRectangleModeEXT( DiscardRectangleModeEXT discardRectangleMode, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_create_renderpass2 === + + // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html + template ::type = true> + void beginRenderPass2KHR( const RenderPassBeginInfo * pRenderPassBegin, + const SubpassBeginInfo * pSubpassBeginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html + template ::type = true> + void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, + const SubpassBeginInfo & subpassBeginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html + template ::type = true> + void nextSubpass2KHR( const SubpassBeginInfo * pSubpassBeginInfo, + const SubpassEndInfo * pSubpassEndInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html + template ::type = true> + void nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo, + const SubpassEndInfo & subpassEndInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html + template ::type = true> + void endRenderPass2KHR( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html + template ::type = true> + void endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_debug_utils === + + // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html + template ::type = true> + void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html + template ::type = true> + void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html + template ::type = true> + void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html + template ::type = true> + void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html + template ::type = true> + void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + + // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html + template ::type = true> + void initializeGraphScratchMemoryAMDX( Pipeline executionGraph, + DeviceAddress scratch, + DeviceSize scratchSize, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html + template ::type = true> + void dispatchGraphAMDX( DeviceAddress scratch, + DeviceSize scratchSize, + const DispatchGraphCountInfoAMDX * pCountInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html + template ::type = true> + void dispatchGraphAMDX( DeviceAddress scratch, + DeviceSize scratchSize, + const DispatchGraphCountInfoAMDX & countInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html + template ::type = true> + void dispatchGraphIndirectAMDX( DeviceAddress scratch, + DeviceSize scratchSize, + const DispatchGraphCountInfoAMDX * pCountInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html + template ::type = true> + void dispatchGraphIndirectAMDX( DeviceAddress scratch, + DeviceSize scratchSize, + const DispatchGraphCountInfoAMDX & countInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html + template ::type = true> + void dispatchGraphIndirectCountAMDX( DeviceAddress scratch, + DeviceSize scratchSize, + DeviceAddress countInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + + // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html + template ::type = true> + void bindSamplerHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html + template ::type = true> + void bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html + template ::type = true> + void bindResourceHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html + template ::type = true> + void bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html + template ::type = true> + void pushDataEXT( const PushDataInfoEXT * pPushDataInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html + template ::type = true> + void pushDataEXT( const PushDataInfoEXT & pushDataInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_sample_locations === + + // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html + template ::type = true> + void setSampleLocationsEXT( const SampleLocationsInfoEXT * pSampleLocationsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html + template ::type = true> + void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_acceleration_structure === + + // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html + template ::type = true> + void buildAccelerationStructuresKHR( uint32_t infoCount, + const AccelerationStructureBuildGeometryInfoKHR * pInfos, + const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html + template ::type = true> + void buildAccelerationStructuresKHR( ArrayProxy const & infos, + ArrayProxy const & pBuildRangeInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html + template ::type = true> + void buildAccelerationStructuresIndirectKHR( uint32_t infoCount, + const AccelerationStructureBuildGeometryInfoKHR * pInfos, + const DeviceAddress * pIndirectDeviceAddresses, + const uint32_t * pIndirectStrides, + const uint32_t * const * ppMaxPrimitiveCounts, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html + template ::type = true> + void buildAccelerationStructuresIndirectKHR( ArrayProxy const & infos, + ArrayProxy const & indirectDeviceAddresses, + ArrayProxy const & indirectStrides, + ArrayProxy const & pMaxPrimitiveCounts, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html + template ::type = true> + void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html + template ::type = true> + void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html + template ::type = true> + void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html + template ::type = true> + void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html + template ::type = true> + void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html + template ::type = true> + void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html + template ::type = true> + void writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, + const AccelerationStructureKHR * pAccelerationStructures, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html + template ::type = true> + void writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_ray_tracing_pipeline === + + // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html + template ::type = true> + void traceRaysKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, + const StridedDeviceAddressRegionKHR * pMissShaderBindingTable, + const StridedDeviceAddressRegionKHR * pHitShaderBindingTable, + const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html + template ::type = true> + void traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, + const StridedDeviceAddressRegionKHR & missShaderBindingTable, + const StridedDeviceAddressRegionKHR & hitShaderBindingTable, + const StridedDeviceAddressRegionKHR & callableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html + template ::type = true> + void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, + const StridedDeviceAddressRegionKHR * pMissShaderBindingTable, + const StridedDeviceAddressRegionKHR * pHitShaderBindingTable, + const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, + DeviceAddress indirectDeviceAddress, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html + template ::type = true> + void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, + const StridedDeviceAddressRegionKHR & missShaderBindingTable, + const StridedDeviceAddressRegionKHR & hitShaderBindingTable, + const StridedDeviceAddressRegionKHR & callableShaderBindingTable, + DeviceAddress indirectDeviceAddress, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html + template ::type = true> + void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_shading_rate_image === + + // wrapper function for command vkCmdBindShadingRateImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html + template ::type = true> + void bindShadingRateImageNV( ImageView imageView, + ImageLayout imageLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html + template ::type = true> + void setViewportShadingRatePaletteNV( uint32_t firstViewport, + uint32_t viewportCount, + const ShadingRatePaletteNV * pShadingRatePalettes, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html + template ::type = true> + void setViewportShadingRatePaletteNV( uint32_t firstViewport, + ArrayProxy const & shadingRatePalettes, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html + template ::type = true> + void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const CoarseSampleOrderCustomNV * pCustomSampleOrders, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html + template ::type = true> + void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, + ArrayProxy const & customSampleOrders, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_ray_tracing === + + // wrapper function for command vkCmdBuildAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html + template ::type = true> + void buildAccelerationStructureNV( const AccelerationStructureInfoNV * pInfo, + Buffer instanceData, + DeviceSize instanceOffset, + Bool32 update, + AccelerationStructureNV dst, + AccelerationStructureNV src, + Buffer scratch, + DeviceSize scratchOffset, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html + template ::type = true> + void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, + Buffer instanceData, + DeviceSize instanceOffset, + Bool32 update, + AccelerationStructureNV dst, + AccelerationStructureNV src, + Buffer scratch, + DeviceSize scratchOffset, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html + template ::type = true> + void copyAccelerationStructureNV( AccelerationStructureNV dst, + AccelerationStructureNV src, + CopyAccelerationStructureModeKHR mode, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html + template ::type = true> + void traceRaysNV( Buffer raygenShaderBindingTableBuffer, + DeviceSize raygenShaderBindingOffset, + Buffer missShaderBindingTableBuffer, + DeviceSize missShaderBindingOffset, + DeviceSize missShaderBindingStride, + Buffer hitShaderBindingTableBuffer, + DeviceSize hitShaderBindingOffset, + DeviceSize hitShaderBindingStride, + Buffer callableShaderBindingTableBuffer, + DeviceSize callableShaderBindingOffset, + DeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html + template ::type = true> + void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, + const AccelerationStructureNV * pAccelerationStructures, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html + template ::type = true> + void writeAccelerationStructuresPropertiesNV( ArrayProxy const & accelerationStructures, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_draw_indirect_count === + + // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html + template ::type = true> + void drawIndirectCountKHR( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html + template ::type = true> + void drawIndexedIndirectCountKHR( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_AMD_buffer_marker === + + // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html + template ::type = true> + void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, + Buffer dstBuffer, + DeviceSize dstOffset, + uint32_t marker, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html + template ::type = true> + void writeBufferMarker2AMD( PipelineStageFlags2 stage, + Buffer dstBuffer, + DeviceSize dstOffset, + uint32_t marker, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_mesh_shader === + + // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html + template ::type = true> + void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html + template ::type = true> + void drawMeshTasksIndirectNV( Buffer buffer, + DeviceSize offset, + uint32_t drawCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html + template ::type = true> + void drawMeshTasksIndirectCountNV( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_scissor_exclusive === + + // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html + template ::type = true> + void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const Bool32 * pExclusiveScissorEnables, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html + template ::type = true> + void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, + ArrayProxy const & exclusiveScissorEnables, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html + template ::type = true> + void setExclusiveScissorNV( uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const Rect2D * pExclusiveScissors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html + template ::type = true> + void setExclusiveScissorNV( uint32_t firstExclusiveScissor, + ArrayProxy const & exclusiveScissors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_device_diagnostic_checkpoints === + + // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html + template ::type = true> + void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html + template ::type = true> + void setCheckpointNV( CheckpointMarkerType const & checkpointMarker, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_INTEL_performance_query === + + // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL * pMarkerInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL * pMarkerInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL * pOverrideInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_fragment_shading_rate === + + // wrapper function for command vkCmdSetFragmentShadingRateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html + template ::type = true> + void setFragmentShadingRateKHR( const Extent2D * pFragmentSize, + const FragmentShadingRateCombinerOpKHR combinerOps[2], + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetFragmentShadingRateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html + template ::type = true> + void setFragmentShadingRateKHR( const Extent2D & fragmentSize, + const FragmentShadingRateCombinerOpKHR combinerOps[2], + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_dynamic_rendering_local_read === + + // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html + template ::type = true> + void setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo * pLocationInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html + template ::type = true> + void setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo & locationInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html + template ::type = true> + void setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html + template ::type = true> + void setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_line_rasterization === + + // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html + template ::type = true> + void setLineStippleEXT( uint32_t lineStippleFactor, + uint16_t lineStipplePattern, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_extended_dynamic_state === + + // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html + template ::type = true> + void setCullModeEXT( CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html + template ::type = true> + void setFrontFaceEXT( FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html + template ::type = true> + void setPrimitiveTopologyEXT( PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetViewportWithCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html + template ::type = true> + void setViewportWithCountEXT( uint32_t viewportCount, + const Viewport * pViewports, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewportWithCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html + template ::type = true> + void setViewportWithCountEXT( ArrayProxy const & viewports, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html + template ::type = true> + void setScissorWithCountEXT( uint32_t scissorCount, + const Rect2D * pScissors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html + template ::type = true> + void setScissorWithCountEXT( ArrayProxy const & scissors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html + template ::type = true> + void bindVertexBuffers2EXT( uint32_t firstBinding, + uint32_t bindingCount, + const Buffer * pBuffers, + const DeviceSize * pOffsets, + const DeviceSize * pSizes, + const DeviceSize * pStrides, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html + template ::type = true> + void bindVertexBuffers2EXT( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + ArrayProxy const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html + template ::type = true> + void setDepthTestEnableEXT( Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html + template ::type = true> + void setDepthWriteEnableEXT( Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html + template ::type = true> + void setDepthCompareOpEXT( CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html + template ::type = true> + void setDepthBoundsTestEnableEXT( Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilTestEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html + template ::type = true> + void setStencilTestEnableEXT( Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html + template ::type = true> + void setStencilOpEXT( StencilFaceFlags faceMask, + StencilOp failOp, + StencilOp passOp, + StencilOp depthFailOp, + CompareOp compareOp, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_device_generated_commands === + + // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html + template ::type = true> + void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV * pGeneratedCommandsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html + template ::type = true> + void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html + template ::type = true> + void executeGeneratedCommandsNV( Bool32 isPreprocessed, + const GeneratedCommandsInfoNV * pGeneratedCommandsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html + template ::type = true> + void executeGeneratedCommandsNV( Bool32 isPreprocessed, + const GeneratedCommandsInfoNV & generatedCommandsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindPipelineShaderGroupNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html + template ::type = true> + void bindPipelineShaderGroupNV( PipelineBindPoint pipelineBindPoint, + Pipeline pipeline, + uint32_t groupIndex, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_depth_bias_control === + + // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html + template ::type = true> + void setDepthBias2EXT( const DepthBiasInfoEXT * pDepthBiasInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html + template ::type = true> + void setDepthBias2EXT( const DepthBiasInfoEXT & depthBiasInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_video_encode_queue === + + // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html + template ::type = true> + void encodeVideoKHR( const VideoEncodeInfoKHR * pEncodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html + template ::type = true> + void encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + + // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html + template ::type = true> + void cudaLaunchKernelNV( const CudaLaunchInfoNV * pLaunchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html + template ::type = true> + void cudaLaunchKernelNV( const CudaLaunchInfoNV & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + + // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html + template ::type = true> + void dispatchTileQCOM( const DispatchTileInfoQCOM * pDispatchTileInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html + template ::type = true> + void dispatchTileQCOM( const DispatchTileInfoQCOM & dispatchTileInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + template ::type = true> + void beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM * pPerTileBeginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + template ::type = true> + void beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM & perTileBeginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + template ::type = true> + void endPerTileExecutionQCOM( const PerTileEndInfoQCOM * pPerTileEndInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + template ::type = true> + void endPerTileExecutionQCOM( const PerTileEndInfoQCOM & perTileEndInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_synchronization2 === + + // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html + template ::type = true> + void setEvent2KHR( Event event, + const DependencyInfo * pDependencyInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html + template ::type = true> + void + setEvent2KHR( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html + template ::type = true> + void resetEvent2KHR( Event event, PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html + template ::type = true> + void waitEvents2KHR( uint32_t eventCount, + const Event * pEvents, + const DependencyInfo * pDependencyInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html + template ::type = true> + void waitEvents2KHR( ArrayProxy const & events, + ArrayProxy const & dependencyInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html + template ::type = true> + void pipelineBarrier2KHR( const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html + template ::type = true> + void pipelineBarrier2KHR( const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html + template ::type = true> + void writeTimestamp2KHR( PipelineStageFlags2 stage, + QueryPool queryPool, + uint32_t query, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_descriptor_buffer === + + // wrapper function for command vkCmdBindDescriptorBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html + template ::type = true> + void bindDescriptorBuffersEXT( uint32_t bufferCount, + const DescriptorBufferBindingInfoEXT * pBindingInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindDescriptorBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html + template ::type = true> + void bindDescriptorBuffersEXT( ArrayProxy const & bindingInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html + template ::type = true> + void setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const uint32_t * pBufferIndices, + const DeviceSize * pOffsets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html + template ::type = true> + void setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t firstSet, + ArrayProxy const & bufferIndices, + ArrayProxy const & offsets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html + template ::type = true> + void bindDescriptorBufferEmbeddedSamplersEXT( PipelineBindPoint pipelineBindPoint, + PipelineLayout layout, + uint32_t set, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_fragment_shading_rate_enums === + + // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html + template ::type = true> + void setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, + const FragmentShadingRateCombinerOpKHR combinerOps[2], + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_mesh_shader === + + // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html + template ::type = true> + void drawMeshTasksEXT( uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html + template ::type = true> + void drawMeshTasksIndirectEXT( Buffer buffer, + DeviceSize offset, + uint32_t drawCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html + template ::type = true> + void drawMeshTasksIndirectCountEXT( Buffer buffer, + DeviceSize offset, + Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_copy_commands2 === + + // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html + template ::type = true> + void copyBuffer2KHR( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html + template ::type = true> + void copyBuffer2KHR( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html + template ::type = true> + void copyImage2KHR( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html + template ::type = true> + void copyImage2KHR( const CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html + template ::type = true> + void copyBufferToImage2KHR( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html + template ::type = true> + void copyBufferToImage2KHR( const CopyBufferToImageInfo2 & copyBufferToImageInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html + template ::type = true> + void copyImageToBuffer2KHR( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html + template ::type = true> + void copyImageToBuffer2KHR( const CopyImageToBufferInfo2 & copyImageToBufferInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html + template ::type = true> + void blitImage2KHR( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html + template ::type = true> + void blitImage2KHR( const BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html + template ::type = true> + void resolveImage2KHR( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html + template ::type = true> + void resolveImage2KHR( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_vertex_input_dynamic_state === + + // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html + template ::type = true> + void setVertexInputEXT( uint32_t vertexBindingDescriptionCount, + const VertexInputBindingDescription2EXT * pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html + template ::type = true> + void setVertexInputEXT( ArrayProxy const & vertexBindingDescriptions, + ArrayProxy const & vertexAttributeDescriptions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_HUAWEI_subpass_shading === + + // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html + template ::type = true> + void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_HUAWEI_invocation_mask === + + // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html + template ::type = true> + void bindInvocationMaskHUAWEI( ImageView imageView, + ImageLayout imageLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_extended_dynamic_state2 === + + // wrapper function for command vkCmdSetPatchControlPointsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html + template ::type = true> + void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html + template ::type = true> + void setRasterizerDiscardEnableEXT( Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html + template ::type = true> + void setDepthBiasEnableEXT( Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html + template ::type = true> + void setLogicOpEXT( LogicOp logicOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html + template ::type = true> + void setPrimitiveRestartEnableEXT( Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_color_write_enable === + + // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html + template ::type = true> + void setColorWriteEnableEXT( uint32_t attachmentCount, + const Bool32 * pColorWriteEnables, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html + template ::type = true> + void setColorWriteEnableEXT( ArrayProxy const & colorWriteEnables, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_ray_tracing_maintenance1 === + + // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html + template ::type = true> + void traceRaysIndirect2KHR( DeviceAddress indirectDeviceAddress, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_multi_draw === + + // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html + template ::type = true> + void drawMultiEXT( uint32_t drawCount, + const MultiDrawInfoEXT * pVertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html + template ::type = true> + void drawMultiEXT( StridedArrayProxy const & vertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html + template ::type = true> + void drawMultiIndexedEXT( uint32_t drawCount, + const MultiDrawIndexedInfoEXT * pIndexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + const int32_t * pVertexOffset, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html + template ::type = true> + void drawMultiIndexedEXT( StridedArrayProxy const & indexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + Optional vertexOffset VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_opacity_micromap === + + // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html + template ::type = true> + void buildMicromapsEXT( uint32_t infoCount, + const MicromapBuildInfoEXT * pInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html + template ::type = true> + void buildMicromapsEXT( ArrayProxy const & infos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html + template ::type = true> + void copyMicromapEXT( const CopyMicromapInfoEXT * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html + template ::type = true> + void copyMicromapEXT( const CopyMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html + template ::type = true> + void copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html + template ::type = true> + void copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html + template ::type = true> + void copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html + template ::type = true> + void copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html + template ::type = true> + void writeMicromapsPropertiesEXT( uint32_t micromapCount, + const MicromapEXT * pMicromaps, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html + template ::type = true> + void writeMicromapsPropertiesEXT( ArrayProxy const & micromaps, + QueryType queryType, + QueryPool queryPool, + uint32_t firstQuery, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_HUAWEI_cluster_culling_shader === + + // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html + template ::type = true> + void drawClusterHUAWEI( uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html + template ::type = true> + void drawClusterIndirectHUAWEI( Buffer buffer, DeviceSize offset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_copy_memory_indirect === + + // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html + template ::type = true> + void copyMemoryIndirectNV( DeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html + template ::type = true> + void copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + Image dstImage, + ImageLayout dstImageLayout, + const ImageSubresourceLayers * pImageSubresources, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html + template ::type = true> + void copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, + uint32_t stride, + Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & imageSubresources, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_memory_decompression === + + // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html + template ::type = true> + void decompressMemoryNV( uint32_t decompressRegionCount, + const DecompressMemoryRegionNV * pDecompressMemoryRegions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html + template ::type = true> + void decompressMemoryNV( ArrayProxy const & decompressMemoryRegions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html + template ::type = true> + void decompressMemoryIndirectCountNV( DeviceAddress indirectCommandsAddress, + DeviceAddress indirectCommandsCountAddress, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_device_generated_commands_compute === + + // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html + template ::type = true> + void updatePipelineIndirectBufferNV( PipelineBindPoint pipelineBindPoint, + Pipeline pipeline, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_extended_dynamic_state3 === + + // wrapper function for command vkCmdSetDepthClampEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html + template ::type = true> + void setDepthClampEnableEXT( Bool32 depthClampEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html + template ::type = true> + void setPolygonModeEXT( PolygonMode polygonMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRasterizationSamplesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html + template ::type = true> + void setRasterizationSamplesEXT( SampleCountFlagBits rasterizationSamples, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html + template ::type = true> + void setSampleMaskEXT( SampleCountFlagBits samples, + const SampleMask * pSampleMask, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html + template ::type = true> + void setSampleMaskEXT( SampleCountFlagBits samples, + ArrayProxy const & sampleMask VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html + template ::type = true> + void setAlphaToCoverageEnableEXT( Bool32 alphaToCoverageEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html + template ::type = true> + void setAlphaToOneEnableEXT( Bool32 alphaToOneEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html + template ::type = true> + void setLogicOpEnableEXT( Bool32 logicOpEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html + template ::type = true> + void setColorBlendEnableEXT( uint32_t firstAttachment, + uint32_t attachmentCount, + const Bool32 * pColorBlendEnables, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html + template ::type = true> + void setColorBlendEnableEXT( uint32_t firstAttachment, + ArrayProxy const & colorBlendEnables, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetColorBlendEquationEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html + template ::type = true> + void setColorBlendEquationEXT( uint32_t firstAttachment, + uint32_t attachmentCount, + const ColorBlendEquationEXT * pColorBlendEquations, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetColorBlendEquationEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html + template ::type = true> + void setColorBlendEquationEXT( uint32_t firstAttachment, + ArrayProxy const & colorBlendEquations, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html + template ::type = true> + void setColorWriteMaskEXT( uint32_t firstAttachment, + uint32_t attachmentCount, + const ColorComponentFlags * pColorWriteMasks, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html + template ::type = true> + void setColorWriteMaskEXT( uint32_t firstAttachment, + ArrayProxy const & colorWriteMasks, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html + template ::type = true> + void setTessellationDomainOriginEXT( TessellationDomainOrigin domainOrigin, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRasterizationStreamEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html + template ::type = true> + void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html + template ::type = true> + void setConservativeRasterizationModeEXT( ConservativeRasterizationModeEXT conservativeRasterizationMode, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html + template ::type = true> + void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html + template ::type = true> + void setDepthClipEnableEXT( Bool32 depthClipEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html + template ::type = true> + void setSampleLocationsEnableEXT( Bool32 sampleLocationsEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html + template ::type = true> + void setColorBlendAdvancedEXT( uint32_t firstAttachment, + uint32_t attachmentCount, + const ColorBlendAdvancedEXT * pColorBlendAdvanced, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html + template ::type = true> + void setColorBlendAdvancedEXT( uint32_t firstAttachment, + ArrayProxy const & colorBlendAdvanced, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetProvokingVertexModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html + template ::type = true> + void setProvokingVertexModeEXT( ProvokingVertexModeEXT provokingVertexMode, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetLineRasterizationModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html + template ::type = true> + void setLineRasterizationModeEXT( LineRasterizationModeEXT lineRasterizationMode, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetLineStippleEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html + template ::type = true> + void setLineStippleEnableEXT( Bool32 stippledLineEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html + template ::type = true> + void setDepthClipNegativeOneToOneEXT( Bool32 negativeOneToOne, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetViewportWScalingEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html + template ::type = true> + void setViewportWScalingEnableNV( Bool32 viewportWScalingEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html + template ::type = true> + void setViewportSwizzleNV( uint32_t firstViewport, + uint32_t viewportCount, + const ViewportSwizzleNV * pViewportSwizzles, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html + template ::type = true> + void setViewportSwizzleNV( uint32_t firstViewport, + ArrayProxy const & viewportSwizzles, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetCoverageToColorEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html + template ::type = true> + void setCoverageToColorEnableNV( Bool32 coverageToColorEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoverageToColorLocationNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html + template ::type = true> + void setCoverageToColorLocationNV( uint32_t coverageToColorLocation, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoverageModulationModeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html + template ::type = true> + void setCoverageModulationModeNV( CoverageModulationModeNV coverageModulationMode, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html + template ::type = true> + void setCoverageModulationTableEnableNV( Bool32 coverageModulationTableEnable, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoverageModulationTableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html + template ::type = true> + void setCoverageModulationTableNV( uint32_t coverageModulationTableCount, + const float * pCoverageModulationTable, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetCoverageModulationTableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html + template ::type = true> + void setCoverageModulationTableNV( ArrayProxy const & coverageModulationTable, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetShadingRateImageEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html + template ::type = true> + void setShadingRateImageEnableNV( Bool32 shadingRateImageEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html + template ::type = true> + void setRepresentativeFragmentTestEnableNV( Bool32 representativeFragmentTestEnable, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoverageReductionModeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html + template ::type = true> + void setCoverageReductionModeNV( CoverageReductionModeNV coverageReductionMode, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_ARM_tensors === + + // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html + template ::type = true> + void copyTensorARM( const CopyTensorInfoARM * pCopyTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html + template ::type = true> + void copyTensorARM( const CopyTensorInfoARM & copyTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_optical_flow === + + // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html + template ::type = true> + void opticalFlowExecuteNV( OpticalFlowSessionNV session, + const OpticalFlowExecuteInfoNV * pExecuteInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html + template ::type = true> + void opticalFlowExecuteNV( OpticalFlowSessionNV session, + const OpticalFlowExecuteInfoNV & executeInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_maintenance5 === + + // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html + template ::type = true> + void bindIndexBuffer2KHR( Buffer buffer, + DeviceSize offset, + DeviceSize size, + IndexType indexType, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_shader_object === + + // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html + template ::type = true> + void bindShadersEXT( uint32_t stageCount, + const ShaderStageFlagBits * pStages, + const ShaderEXT * pShaders, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html + template ::type = true> + void bindShadersEXT( ArrayProxy const & stages, + ArrayProxy const & shaders, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html + template ::type = true> + void setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, + const DepthClampRangeEXT * pDepthClampRange, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html + template ::type = true> + void setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, + Optional depthClampRange VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_cooperative_vector === + + // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html + template ::type = true> + void convertCooperativeVectorMatrixNV( uint32_t infoCount, + const ConvertCooperativeVectorMatrixInfoNV * pInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html + template ::type = true> + void convertCooperativeVectorMatrixNV( ArrayProxy const & infos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_ARM_data_graph === + + // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html + template ::type = true> + void dispatchDataGraphARM( DataGraphPipelineSessionARM session, + const DataGraphPipelineDispatchInfoARM * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html + template ::type = true> + void dispatchDataGraphARM( DataGraphPipelineSessionARM session, + Optional info VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + + // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html + template ::type = true> + void setAttachmentFeedbackLoopEnableEXT( ImageAspectFlags aspectMask, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_line_rasterization === + + // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html + template ::type = true> + void setLineStippleKHR( uint32_t lineStippleFactor, + uint16_t lineStipplePattern, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_maintenance6 === + + // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html + template ::type = true> + void bindDescriptorSets2KHR( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html + template ::type = true> + void bindDescriptorSets2KHR( const BindDescriptorSetsInfo & bindDescriptorSetsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html + template ::type = true> + void pushConstants2KHR( const PushConstantsInfo * pPushConstantsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html + template ::type = true> + void pushConstants2KHR( const PushConstantsInfo & pushConstantsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html + template ::type = true> + void pushDescriptorSet2KHR( const PushDescriptorSetInfo * pPushDescriptorSetInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html + template ::type = true> + void pushDescriptorSet2KHR( const PushDescriptorSetInfo & pushDescriptorSetInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html + template ::type = true> + void pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html + template ::type = true> + void pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html + template ::type = true> + void setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html + template ::type = true> + void setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html + template ::type = true> + void bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html + template ::type = true> + void bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_QCOM_tile_memory_heap === + + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + template ::type = true> + void bindTileMemoryQCOM( const TileMemoryBindInfoQCOM * pTileMemoryBindInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + template ::type = true> + void bindTileMemoryQCOM( Optional tileMemoryBindInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_copy_memory_indirect === + + // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html + template ::type = true> + void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html + template ::type = true> + void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html + template ::type = true> + void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html + template ::type = true> + void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_memory_decompression === + + // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html + template ::type = true> + void decompressMemoryEXT( const DecompressMemoryInfoEXT * pDecompressMemoryInfoEXT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html + template ::type = true> + void decompressMemoryEXT( const DecompressMemoryInfoEXT & decompressMemoryInfoEXT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdDecompressMemoryIndirectCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountEXT.html + template ::type = true> + void decompressMemoryIndirectCountEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod, + DeviceAddress indirectCommandsAddress, + DeviceAddress indirectCommandsCountAddress, + uint32_t maxDecompressionCount, + uint32_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_cluster_acceleration_structure === + + // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html + template ::type = true> + void buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV * pCommandInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html + template ::type = true> + void buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV & commandInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_partitioned_acceleration_structure === + + // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html + template ::type = true> + void buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV * pBuildInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html + template ::type = true> + void buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV & buildInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_device_generated_commands === + + // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html + template ::type = true> + void preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo, + CommandBuffer stateCommandBuffer, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html + template ::type = true> + void preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT & generatedCommandsInfo, + CommandBuffer stateCommandBuffer, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html + template ::type = true> + void executeGeneratedCommandsEXT( Bool32 isPreprocessed, + const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html + template ::type = true> + void executeGeneratedCommandsEXT( Bool32 isPreprocessed, + const GeneratedCommandsInfoEXT & generatedCommandsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_fragment_density_map_offset === + + // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html + template ::type = true> + void endRendering2EXT( const RenderingEndInfoKHR * pRenderingEndInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html + template ::type = true> + void endRendering2EXT( Optional renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_custom_resolve === + + // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html + template ::type = true> + void beginCustomResolveEXT( const BeginCustomResolveInfoEXT * pBeginCustomResolveInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html + template ::type = true> + void beginCustomResolveEXT( Optional beginCustomResolveInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_maintenance10 === + + // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html + template ::type = true> + void endRendering2KHR( const RenderingEndInfoKHR * pRenderingEndInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html + template ::type = true> + void endRendering2KHR( Optional renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_compute_occupancy_priority === + + // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html + template ::type = true> + void setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV * pParameters, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html + template ::type = true> + void setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV & parameters, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT + { + return m_commandBuffer; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_commandBuffer != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_commandBuffer == VK_NULL_HANDLE; + } + + private: + VkCommandBuffer m_commandBuffer = {}; + }; + + template <> + struct CppType + { + using Type = CommandBuffer; + }; + + template <> + struct CppType + { + using Type = CommandBuffer; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = CommandBuffer; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDeviceMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemory.html + class DeviceMemory + { + public: + using CType = VkDeviceMemory; + using NativeType = VkDeviceMemory; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDeviceMemory; + + public: + DeviceMemory() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + DeviceMemory( DeviceMemory const & rhs ) = default; + DeviceMemory & operator=( DeviceMemory const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + DeviceMemory( DeviceMemory && rhs ) = default; + DeviceMemory & operator=( DeviceMemory && rhs ) = default; +#else + DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( exchange( rhs.m_deviceMemory, {} ) ) {} + + DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT + { + m_deviceMemory = exchange( rhs.m_deviceMemory, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT + { + m_deviceMemory = deviceMemory; + return *this; + } +#endif + + DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_deviceMemory = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT + { + return m_deviceMemory; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_deviceMemory != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_deviceMemory == VK_NULL_HANDLE; + } + + private: + VkDeviceMemory m_deviceMemory = {}; + }; + + template <> + struct CppType + { + using Type = DeviceMemory; + }; + + template <> + struct CppType + { + using Type = DeviceMemory; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = DeviceMemory; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionKHR.html + class VideoSessionKHR + { + public: + using CType = VkVideoSessionKHR; + using NativeType = VkVideoSessionKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + VideoSessionKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + VideoSessionKHR( VideoSessionKHR const & rhs ) = default; + VideoSessionKHR & operator=( VideoSessionKHR const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + VideoSessionKHR( VideoSessionKHR && rhs ) = default; + VideoSessionKHR & operator=( VideoSessionKHR && rhs ) = default; +#else + VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( exchange( rhs.m_videoSessionKHR, {} ) ) {} + + VideoSessionKHR & operator=( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + m_videoSessionKHR = exchange( rhs.m_videoSessionKHR, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT + { + m_videoSessionKHR = videoSessionKHR; + return *this; + } +#endif + + VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_videoSessionKHR = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT + { + return m_videoSessionKHR; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_videoSessionKHR != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_videoSessionKHR == VK_NULL_HANDLE; + } + + private: + VkVideoSessionKHR m_videoSessionKHR = {}; + }; + + template <> + struct CppType + { + using Type = VideoSessionKHR; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = VideoSessionKHR; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeferredOperationKHR.html + class DeferredOperationKHR + { + public: + using CType = VkDeferredOperationKHR; + using NativeType = VkDeferredOperationKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeferredOperationKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + DeferredOperationKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + DeferredOperationKHR( DeferredOperationKHR const & rhs ) = default; + DeferredOperationKHR & operator=( DeferredOperationKHR const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + DeferredOperationKHR( DeferredOperationKHR && rhs ) = default; + DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) = default; +#else + DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_deferredOperationKHR( exchange( rhs.m_deferredOperationKHR, {} ) ) {} + + DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + m_deferredOperationKHR = exchange( rhs.m_deferredOperationKHR, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT + : m_deferredOperationKHR( deferredOperationKHR ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT + { + m_deferredOperationKHR = deferredOperationKHR; + return *this; + } +#endif + + DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_deferredOperationKHR = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT + { + return m_deferredOperationKHR; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_deferredOperationKHR != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_deferredOperationKHR == VK_NULL_HANDLE; + } + + private: + VkDeferredOperationKHR m_deferredOperationKHR = {}; + }; + + template <> + struct CppType + { + using Type = DeferredOperationKHR; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = DeferredOperationKHR; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionFUCHSIA.html +#if defined( VK_USE_PLATFORM_FUCHSIA ) + class BufferCollectionFUCHSIA + { + public: + using CType = VkBufferCollectionFUCHSIA; + using NativeType = VkBufferCollectionFUCHSIA; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferCollectionFUCHSIA; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA; + + public: + BufferCollectionFUCHSIA() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & rhs ) = default; + BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & rhs ) = default; + +# if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) = default; + BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) = default; +# else + BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT : m_bufferCollectionFUCHSIA( exchange( rhs.m_bufferCollectionFUCHSIA, {} ) ) + { + } + + BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT + { + m_bufferCollectionFUCHSIA = exchange( rhs.m_bufferCollectionFUCHSIA, {} ); + return *this; + } +# endif + + VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT + : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA ) + { + } + +# if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT + { + m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA; + return *this; + } +# endif + + BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_bufferCollectionFUCHSIA = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT + { + return m_bufferCollectionFUCHSIA; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE; + } + + private: + VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {}; + }; + + template <> + struct CppType + { + using Type = BufferCollectionFUCHSIA; + }; + + template <> + struct CppType + { + using Type = BufferCollectionFUCHSIA; + }; + +# if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = BufferCollectionFUCHSIA; + }; +# endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + // wrapper class for handle VkBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferView.html + class BufferView + { + public: + using CType = VkBufferView; + using NativeType = VkBufferView; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferView; + + public: + BufferView() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + BufferView( BufferView const & rhs ) = default; + BufferView & operator=( BufferView const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + BufferView( BufferView && rhs ) = default; + BufferView & operator=( BufferView && rhs ) = default; +#else + BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT : m_bufferView( exchange( rhs.m_bufferView, {} ) ) {} + + BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT + { + m_bufferView = exchange( rhs.m_bufferView, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT + { + m_bufferView = bufferView; + return *this; + } +#endif + + BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_bufferView = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT + { + return m_bufferView; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_bufferView != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_bufferView == VK_NULL_HANDLE; + } + + private: + VkBufferView m_bufferView = {}; + }; + + template <> + struct CppType + { + using Type = BufferView; + }; + + template <> + struct CppType + { + using Type = BufferView; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = BufferView; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPool.html + class CommandPool + { + public: + using CType = VkCommandPool; + using NativeType = VkCommandPool; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandPool; + + public: + CommandPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + CommandPool( CommandPool const & rhs ) = default; + CommandPool & operator=( CommandPool const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + CommandPool( CommandPool && rhs ) = default; + CommandPool & operator=( CommandPool && rhs ) = default; +#else + CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT : m_commandPool( exchange( rhs.m_commandPool, {} ) ) {} + + CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT + { + m_commandPool = exchange( rhs.m_commandPool, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT + { + m_commandPool = commandPool; + return *this; + } +#endif + + CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_commandPool = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT + { + return m_commandPool; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_commandPool != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_commandPool == VK_NULL_HANDLE; + } + + private: + VkCommandPool m_commandPool = {}; + }; + + template <> + struct CppType + { + using Type = CommandPool; + }; + + template <> + struct CppType + { + using Type = CommandPool; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = CommandPool; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCache.html + class PipelineCache + { + public: + using CType = VkPipelineCache; + using NativeType = VkPipelineCache; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineCache; + + public: + PipelineCache() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + PipelineCache( PipelineCache const & rhs ) = default; + PipelineCache & operator=( PipelineCache const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + PipelineCache( PipelineCache && rhs ) = default; + PipelineCache & operator=( PipelineCache && rhs ) = default; +#else + PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( exchange( rhs.m_pipelineCache, {} ) ) {} + + PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT + { + m_pipelineCache = exchange( rhs.m_pipelineCache, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT + { + m_pipelineCache = pipelineCache; + return *this; + } +#endif + + PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_pipelineCache = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineCache; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineCache != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineCache == VK_NULL_HANDLE; + } + + private: + VkPipelineCache m_pipelineCache = {}; + }; + + template <> + struct CppType + { + using Type = PipelineCache; + }; + + template <> + struct CppType + { + using Type = PipelineCache; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = PipelineCache; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuFunctionNVX.html + class CuFunctionNVX + { + public: + using CType = VkCuFunctionNVX; + using NativeType = VkCuFunctionNVX; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuFunctionNVX; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuFunctionNVX; + + public: + CuFunctionNVX() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + CuFunctionNVX( CuFunctionNVX const & rhs ) = default; + CuFunctionNVX & operator=( CuFunctionNVX const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + CuFunctionNVX( CuFunctionNVX && rhs ) = default; + CuFunctionNVX & operator=( CuFunctionNVX && rhs ) = default; +#else + CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( exchange( rhs.m_cuFunctionNVX, {} ) ) {} + + CuFunctionNVX & operator=( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT + { + m_cuFunctionNVX = exchange( rhs.m_cuFunctionNVX, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT + { + m_cuFunctionNVX = cuFunctionNVX; + return *this; + } +#endif + + CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_cuFunctionNVX = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT + { + return m_cuFunctionNVX; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_cuFunctionNVX != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_cuFunctionNVX == VK_NULL_HANDLE; + } + + private: + VkCuFunctionNVX m_cuFunctionNVX = {}; + }; + + template <> + struct CppType + { + using Type = CuFunctionNVX; + }; + + template <> + struct CppType + { + using Type = CuFunctionNVX; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = CuFunctionNVX; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleNVX.html + class CuModuleNVX + { + public: + using CType = VkCuModuleNVX; + using NativeType = VkCuModuleNVX; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuModuleNVX; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuModuleNVX; + + public: + CuModuleNVX() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + CuModuleNVX( CuModuleNVX const & rhs ) = default; + CuModuleNVX & operator=( CuModuleNVX const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + CuModuleNVX( CuModuleNVX && rhs ) = default; + CuModuleNVX & operator=( CuModuleNVX && rhs ) = default; +#else + CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( exchange( rhs.m_cuModuleNVX, {} ) ) {} + + CuModuleNVX & operator=( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT + { + m_cuModuleNVX = exchange( rhs.m_cuModuleNVX, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT + { + m_cuModuleNVX = cuModuleNVX; + return *this; + } +#endif + + CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_cuModuleNVX = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT + { + return m_cuModuleNVX; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_cuModuleNVX != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_cuModuleNVX == VK_NULL_HANDLE; + } + + private: + VkCuModuleNVX m_cuModuleNVX = {}; + }; + + template <> + struct CppType + { + using Type = CuModuleNVX; + }; + + template <> + struct CppType + { + using Type = CuModuleNVX; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = CuModuleNVX; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaFunctionNV.html +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + class CudaFunctionNV + { + public: + using CType = VkCudaFunctionNV; + using NativeType = VkCudaFunctionNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaFunctionNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaFunctionNV; + + public: + CudaFunctionNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + CudaFunctionNV( CudaFunctionNV const & rhs ) = default; + CudaFunctionNV & operator=( CudaFunctionNV const & rhs ) = default; + +# if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + CudaFunctionNV( CudaFunctionNV && rhs ) = default; + CudaFunctionNV & operator=( CudaFunctionNV && rhs ) = default; +# else + CudaFunctionNV( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( exchange( rhs.m_cudaFunctionNV, {} ) ) {} + + CudaFunctionNV & operator=( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT + { + m_cudaFunctionNV = exchange( rhs.m_cudaFunctionNV, {} ); + return *this; + } +# endif + + VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( cudaFunctionNV ) {} + +# if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + CudaFunctionNV & operator=( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT + { + m_cudaFunctionNV = cudaFunctionNV; + return *this; + } +# endif + + CudaFunctionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_cudaFunctionNV = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaFunctionNV() const VULKAN_HPP_NOEXCEPT + { + return m_cudaFunctionNV; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_cudaFunctionNV != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_cudaFunctionNV == VK_NULL_HANDLE; + } + + private: + VkCudaFunctionNV m_cudaFunctionNV = {}; + }; + + template <> + struct CppType + { + using Type = CudaFunctionNV; + }; + + template <> + struct CppType + { + using Type = CudaFunctionNV; + }; + +# if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = CudaFunctionNV; + }; +# endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper class for handle VkCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaModuleNV.html +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + class CudaModuleNV + { + public: + using CType = VkCudaModuleNV; + using NativeType = VkCudaModuleNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaModuleNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaModuleNV; + + public: + CudaModuleNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + CudaModuleNV( CudaModuleNV const & rhs ) = default; + CudaModuleNV & operator=( CudaModuleNV const & rhs ) = default; + +# if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + CudaModuleNV( CudaModuleNV && rhs ) = default; + CudaModuleNV & operator=( CudaModuleNV && rhs ) = default; +# else + CudaModuleNV( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( exchange( rhs.m_cudaModuleNV, {} ) ) {} + + CudaModuleNV & operator=( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT + { + m_cudaModuleNV = exchange( rhs.m_cudaModuleNV, {} ); + return *this; + } +# endif + + VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( cudaModuleNV ) {} + +# if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + CudaModuleNV & operator=( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT + { + m_cudaModuleNV = cudaModuleNV; + return *this; + } +# endif + + CudaModuleNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_cudaModuleNV = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaModuleNV() const VULKAN_HPP_NOEXCEPT + { + return m_cudaModuleNV; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_cudaModuleNV != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_cudaModuleNV == VK_NULL_HANDLE; + } + + private: + VkCudaModuleNV m_cudaModuleNV = {}; + }; + + template <> + struct CppType + { + using Type = CudaModuleNV; + }; + + template <> + struct CppType + { + using Type = CudaModuleNV; + }; + +# if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = CudaModuleNV; + }; +# endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper class for handle VkDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPool.html + class DescriptorPool + { + public: + using CType = VkDescriptorPool; + using NativeType = VkDescriptorPool; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorPool; + + public: + DescriptorPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + DescriptorPool( DescriptorPool const & rhs ) = default; + DescriptorPool & operator=( DescriptorPool const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + DescriptorPool( DescriptorPool && rhs ) = default; + DescriptorPool & operator=( DescriptorPool && rhs ) = default; +#else + DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( exchange( rhs.m_descriptorPool, {} ) ) {} + + DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT + { + m_descriptorPool = exchange( rhs.m_descriptorPool, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT + { + m_descriptorPool = descriptorPool; + return *this; + } +#endif + + DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_descriptorPool = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorPool; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorPool != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorPool == VK_NULL_HANDLE; + } + + private: + VkDescriptorPool m_descriptorPool = {}; + }; + + template <> + struct CppType + { + using Type = DescriptorPool; + }; + + template <> + struct CppType + { + using Type = DescriptorPool; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = DescriptorPool; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayout.html + class DescriptorSetLayout + { + public: + using CType = VkDescriptorSetLayout; + using NativeType = VkDescriptorSetLayout; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSetLayout; + + public: + DescriptorSetLayout() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + DescriptorSetLayout( DescriptorSetLayout const & rhs ) = default; + DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + DescriptorSetLayout( DescriptorSetLayout && rhs ) = default; + DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) = default; +#else + DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorSetLayout( exchange( rhs.m_descriptorSetLayout, {} ) ) {} + + DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT + { + m_descriptorSetLayout = exchange( rhs.m_descriptorSetLayout, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT + : m_descriptorSetLayout( descriptorSetLayout ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT + { + m_descriptorSetLayout = descriptorSetLayout; + return *this; + } +#endif + + DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_descriptorSetLayout = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorSetLayout; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorSetLayout != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorSetLayout == VK_NULL_HANDLE; + } + + private: + VkDescriptorSetLayout m_descriptorSetLayout = {}; + }; + + template <> + struct CppType + { + using Type = DescriptorSetLayout; + }; + + template <> + struct CppType + { + using Type = DescriptorSetLayout; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = DescriptorSetLayout; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueNV.html + class ExternalComputeQueueNV + { + public: + using CType = VkExternalComputeQueueNV; + using NativeType = VkExternalComputeQueueNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eExternalComputeQueueNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + ExternalComputeQueueNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + ExternalComputeQueueNV( ExternalComputeQueueNV const & rhs ) = default; + ExternalComputeQueueNV & operator=( ExternalComputeQueueNV const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) = default; + ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) = default; +#else + ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT : m_externalComputeQueueNV( exchange( rhs.m_externalComputeQueueNV, {} ) ) {} + + ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT + { + m_externalComputeQueueNV = exchange( rhs.m_externalComputeQueueNV, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR ExternalComputeQueueNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + ExternalComputeQueueNV( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT : m_externalComputeQueueNV( externalComputeQueueNV ) {} + + ExternalComputeQueueNV & operator=( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT + { + m_externalComputeQueueNV = externalComputeQueueNV; + return *this; + } + + ExternalComputeQueueNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_externalComputeQueueNV = {}; + return *this; + } + + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template ::type = true> + void + getData( ExternalComputeQueueDataParamsNV * params, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template ::type = true> + VULKAN_HPP_NODISCARD std::pair + getData( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + operator VkExternalComputeQueueNV() const VULKAN_HPP_NOEXCEPT + { + return m_externalComputeQueueNV; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_externalComputeQueueNV != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_externalComputeQueueNV == VK_NULL_HANDLE; + } + + private: + VkExternalComputeQueueNV m_externalComputeQueueNV = {}; + }; + + template <> + struct CppType + { + using Type = ExternalComputeQueueNV; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = ExternalComputeQueueNV; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebuffer.html + class Framebuffer + { + public: + using CType = VkFramebuffer; + using NativeType = VkFramebuffer; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFramebuffer; + + public: + Framebuffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + Framebuffer( Framebuffer const & rhs ) = default; + Framebuffer & operator=( Framebuffer const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + Framebuffer( Framebuffer && rhs ) = default; + Framebuffer & operator=( Framebuffer && rhs ) = default; +#else + Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_framebuffer( exchange( rhs.m_framebuffer, {} ) ) {} + + Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT + { + m_framebuffer = exchange( rhs.m_framebuffer, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT + { + m_framebuffer = framebuffer; + return *this; + } +#endif + + Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_framebuffer = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT + { + return m_framebuffer; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_framebuffer != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_framebuffer == VK_NULL_HANDLE; + } + + private: + VkFramebuffer m_framebuffer = {}; + }; + + template <> + struct CppType + { + using Type = Framebuffer; + }; + + template <> + struct CppType + { + using Type = Framebuffer; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Framebuffer; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutEXT.html + class IndirectCommandsLayoutEXT + { + public: + using CType = VkIndirectCommandsLayoutEXT; + using NativeType = VkIndirectCommandsLayoutEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + IndirectCommandsLayoutEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT const & rhs ) = default; + IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) = default; + IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) = default; +#else + IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT + : m_indirectCommandsLayoutEXT( exchange( rhs.m_indirectCommandsLayoutEXT, {} ) ) + { + } + + IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + m_indirectCommandsLayoutEXT = exchange( rhs.m_indirectCommandsLayoutEXT, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutEXT( VkIndirectCommandsLayoutEXT indirectCommandsLayoutEXT ) VULKAN_HPP_NOEXCEPT + : m_indirectCommandsLayoutEXT( indirectCommandsLayoutEXT ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + IndirectCommandsLayoutEXT & operator=( VkIndirectCommandsLayoutEXT indirectCommandsLayoutEXT ) VULKAN_HPP_NOEXCEPT + { + m_indirectCommandsLayoutEXT = indirectCommandsLayoutEXT; + return *this; + } +#endif + + IndirectCommandsLayoutEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_indirectCommandsLayoutEXT = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutEXT() const VULKAN_HPP_NOEXCEPT + { + return m_indirectCommandsLayoutEXT; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_indirectCommandsLayoutEXT != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_indirectCommandsLayoutEXT == VK_NULL_HANDLE; + } + + private: + VkIndirectCommandsLayoutEXT m_indirectCommandsLayoutEXT = {}; + }; + + template <> + struct CppType + { + using Type = IndirectCommandsLayoutEXT; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = IndirectCommandsLayoutEXT; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutNV.html + class IndirectCommandsLayoutNV + { + public: + using CType = VkIndirectCommandsLayoutNV; + using NativeType = VkIndirectCommandsLayoutNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + IndirectCommandsLayoutNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & rhs ) = default; + IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) = default; + IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) = default; +#else + IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT + : m_indirectCommandsLayoutNV( exchange( rhs.m_indirectCommandsLayoutNV, {} ) ) + { + } + + IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT + { + m_indirectCommandsLayoutNV = exchange( rhs.m_indirectCommandsLayoutNV, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT + : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT + { + m_indirectCommandsLayoutNV = indirectCommandsLayoutNV; + return *this; + } +#endif + + IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_indirectCommandsLayoutNV = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT + { + return m_indirectCommandsLayoutNV; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_indirectCommandsLayoutNV != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_indirectCommandsLayoutNV == VK_NULL_HANDLE; + } + + private: + VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {}; + }; + + template <> + struct CppType + { + using Type = IndirectCommandsLayoutNV; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = IndirectCommandsLayoutNV; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetEXT.html + class IndirectExecutionSetEXT + { + public: + using CType = VkIndirectExecutionSetEXT; + using NativeType = VkIndirectExecutionSetEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectExecutionSetEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + IndirectExecutionSetEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + IndirectExecutionSetEXT( IndirectExecutionSetEXT const & rhs ) = default; + IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) = default; + IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) = default; +#else + IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_indirectExecutionSetEXT( exchange( rhs.m_indirectExecutionSetEXT, {} ) ) + { + } + + IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + m_indirectExecutionSetEXT = exchange( rhs.m_indirectExecutionSetEXT, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR IndirectExecutionSetEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT IndirectExecutionSetEXT( VkIndirectExecutionSetEXT indirectExecutionSetEXT ) VULKAN_HPP_NOEXCEPT + : m_indirectExecutionSetEXT( indirectExecutionSetEXT ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + IndirectExecutionSetEXT & operator=( VkIndirectExecutionSetEXT indirectExecutionSetEXT ) VULKAN_HPP_NOEXCEPT + { + m_indirectExecutionSetEXT = indirectExecutionSetEXT; + return *this; + } +#endif + + IndirectExecutionSetEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_indirectExecutionSetEXT = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectExecutionSetEXT() const VULKAN_HPP_NOEXCEPT + { + return m_indirectExecutionSetEXT; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_indirectExecutionSetEXT != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_indirectExecutionSetEXT == VK_NULL_HANDLE; + } + + private: + VkIndirectExecutionSetEXT m_indirectExecutionSetEXT = {}; + }; + + template <> + struct CppType + { + using Type = IndirectExecutionSetEXT; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = IndirectExecutionSetEXT; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlot.html + class PrivateDataSlot + { + public: + using CType = VkPrivateDataSlot; + using NativeType = VkPrivateDataSlot; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePrivateDataSlot; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + PrivateDataSlot() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + PrivateDataSlot( PrivateDataSlot const & rhs ) = default; + PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + PrivateDataSlot( PrivateDataSlot && rhs ) = default; + PrivateDataSlot & operator=( PrivateDataSlot && rhs ) = default; +#else + PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( exchange( rhs.m_privateDataSlot, {} ) ) {} + + PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT + { + m_privateDataSlot = exchange( rhs.m_privateDataSlot, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT + { + m_privateDataSlot = privateDataSlot; + return *this; + } +#endif + + PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_privateDataSlot = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT + { + return m_privateDataSlot; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_privateDataSlot != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_privateDataSlot == VK_NULL_HANDLE; + } + + private: + VkPrivateDataSlot m_privateDataSlot = {}; + }; + + template <> + struct CppType + { + using Type = PrivateDataSlot; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = PrivateDataSlot; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + using PrivateDataSlotEXT = PrivateDataSlot; + + // wrapper class for handle VkRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPass.html + class RenderPass + { + public: + using CType = VkRenderPass; + using NativeType = VkRenderPass; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eRenderPass; + + public: + RenderPass() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + RenderPass( RenderPass const & rhs ) = default; + RenderPass & operator=( RenderPass const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + RenderPass( RenderPass && rhs ) = default; + RenderPass & operator=( RenderPass && rhs ) = default; +#else + RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT : m_renderPass( exchange( rhs.m_renderPass, {} ) ) {} + + RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT + { + m_renderPass = exchange( rhs.m_renderPass, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT + { + m_renderPass = renderPass; + return *this; + } +#endif + + RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_renderPass = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT + { + return m_renderPass; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_renderPass != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_renderPass == VK_NULL_HANDLE; + } + + private: + VkRenderPass m_renderPass = {}; + }; + + template <> + struct CppType + { + using Type = RenderPass; + }; + + template <> + struct CppType + { + using Type = RenderPass; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = RenderPass; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampler.html + class Sampler + { + public: + using CType = VkSampler; + using NativeType = VkSampler; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSampler; + + public: + Sampler() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + Sampler( Sampler const & rhs ) = default; + Sampler & operator=( Sampler const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + Sampler( Sampler && rhs ) = default; + Sampler & operator=( Sampler && rhs ) = default; +#else + Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT : m_sampler( exchange( rhs.m_sampler, {} ) ) {} + + Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT + { + m_sampler = exchange( rhs.m_sampler, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT + { + m_sampler = sampler; + return *this; + } +#endif + + Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_sampler = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT + { + return m_sampler; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_sampler != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_sampler == VK_NULL_HANDLE; + } + + private: + VkSampler m_sampler = {}; + }; + + template <> + struct CppType + { + using Type = Sampler; + }; + + template <> + struct CppType + { + using Type = Sampler; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Sampler; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkSamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversion.html + class SamplerYcbcrConversion + { + public: + using CType = VkSamplerYcbcrConversion; + using NativeType = VkSamplerYcbcrConversion; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSamplerYcbcrConversion; + + public: + SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs ) = default; + SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) = default; + SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) = default; +#else + SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT : m_samplerYcbcrConversion( exchange( rhs.m_samplerYcbcrConversion, {} ) ) {} + + SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT + { + m_samplerYcbcrConversion = exchange( rhs.m_samplerYcbcrConversion, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT + : m_samplerYcbcrConversion( samplerYcbcrConversion ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT + { + m_samplerYcbcrConversion = samplerYcbcrConversion; + return *this; + } +#endif + + SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_samplerYcbcrConversion = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT + { + return m_samplerYcbcrConversion; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_samplerYcbcrConversion != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_samplerYcbcrConversion == VK_NULL_HANDLE; + } + + private: + VkSamplerYcbcrConversion m_samplerYcbcrConversion = {}; + }; + + template <> + struct CppType + { + using Type = SamplerYcbcrConversion; + }; + + template <> + struct CppType + { + using Type = SamplerYcbcrConversion; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = SamplerYcbcrConversion; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; + + // wrapper class for handle VkShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModule.html + class ShaderModule + { + public: + using CType = VkShaderModule; + using NativeType = VkShaderModule; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eShaderModule; + + public: + ShaderModule() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + ShaderModule( ShaderModule const & rhs ) = default; + ShaderModule & operator=( ShaderModule const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + ShaderModule( ShaderModule && rhs ) = default; + ShaderModule & operator=( ShaderModule && rhs ) = default; +#else + ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderModule( exchange( rhs.m_shaderModule, {} ) ) {} + + ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT + { + m_shaderModule = exchange( rhs.m_shaderModule, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT + { + m_shaderModule = shaderModule; + return *this; + } +#endif + + ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_shaderModule = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT + { + return m_shaderModule; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_shaderModule != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_shaderModule == VK_NULL_HANDLE; + } + + private: + VkShaderModule m_shaderModule = {}; + }; + + template <> + struct CppType + { + using Type = ShaderModule; + }; + + template <> + struct CppType + { + using Type = ShaderModule; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = ShaderModule; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorARM.html + class TensorARM + { + public: + using CType = VkTensorARM; + using NativeType = VkTensorARM; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + TensorARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + TensorARM( TensorARM const & rhs ) = default; + TensorARM & operator=( TensorARM const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + TensorARM( TensorARM && rhs ) = default; + TensorARM & operator=( TensorARM && rhs ) = default; +#else + TensorARM( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT : m_tensorARM( exchange( rhs.m_tensorARM, {} ) ) {} + + TensorARM & operator=( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT + { + m_tensorARM = exchange( rhs.m_tensorARM, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR TensorARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT TensorARM( VkTensorARM tensorARM ) VULKAN_HPP_NOEXCEPT : m_tensorARM( tensorARM ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + TensorARM & operator=( VkTensorARM tensorARM ) VULKAN_HPP_NOEXCEPT + { + m_tensorARM = tensorARM; + return *this; + } +#endif + + TensorARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_tensorARM = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkTensorARM() const VULKAN_HPP_NOEXCEPT + { + return m_tensorARM; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_tensorARM != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_tensorARM == VK_NULL_HANDLE; + } + + private: + VkTensorARM m_tensorARM = {}; + }; + + template <> + struct CppType + { + using Type = TensorARM; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = TensorARM; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewARM.html + class TensorViewARM + { + public: + using CType = VkTensorViewARM; + using NativeType = VkTensorViewARM; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorViewARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + TensorViewARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + TensorViewARM( TensorViewARM const & rhs ) = default; + TensorViewARM & operator=( TensorViewARM const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + TensorViewARM( TensorViewARM && rhs ) = default; + TensorViewARM & operator=( TensorViewARM && rhs ) = default; +#else + TensorViewARM( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT : m_tensorViewARM( exchange( rhs.m_tensorViewARM, {} ) ) {} + + TensorViewARM & operator=( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT + { + m_tensorViewARM = exchange( rhs.m_tensorViewARM, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR TensorViewARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT TensorViewARM( VkTensorViewARM tensorViewARM ) VULKAN_HPP_NOEXCEPT : m_tensorViewARM( tensorViewARM ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + TensorViewARM & operator=( VkTensorViewARM tensorViewARM ) VULKAN_HPP_NOEXCEPT + { + m_tensorViewARM = tensorViewARM; + return *this; + } +#endif + + TensorViewARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_tensorViewARM = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkTensorViewARM() const VULKAN_HPP_NOEXCEPT + { + return m_tensorViewARM; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_tensorViewARM != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_tensorViewARM == VK_NULL_HANDLE; + } + + private: + VkTensorViewARM m_tensorViewARM = {}; + }; + + template <> + struct CppType + { + using Type = TensorViewARM; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = TensorViewARM; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheEXT.html + class ValidationCacheEXT + { + public: + using CType = VkValidationCacheEXT; + using NativeType = VkValidationCacheEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eValidationCacheEXT; + + public: + ValidationCacheEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + ValidationCacheEXT( ValidationCacheEXT const & rhs ) = default; + ValidationCacheEXT & operator=( ValidationCacheEXT const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + ValidationCacheEXT( ValidationCacheEXT && rhs ) = default; + ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) = default; +#else + ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( exchange( rhs.m_validationCacheEXT, {} ) ) {} + + ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + m_validationCacheEXT = exchange( rhs.m_validationCacheEXT, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT + { + m_validationCacheEXT = validationCacheEXT; + return *this; + } +#endif + + ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_validationCacheEXT = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT + { + return m_validationCacheEXT; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_validationCacheEXT != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_validationCacheEXT == VK_NULL_HANDLE; + } + + private: + VkValidationCacheEXT m_validationCacheEXT = {}; + }; + + template <> + struct CppType + { + using Type = ValidationCacheEXT; + }; + + template <> + struct CppType + { + using Type = ValidationCacheEXT; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = ValidationCacheEXT; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersKHR.html + class VideoSessionParametersKHR + { + public: + using CType = VkVideoSessionParametersKHR; + using NativeType = VkVideoSessionParametersKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionParametersKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + VideoSessionParametersKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + VideoSessionParametersKHR( VideoSessionParametersKHR const & rhs ) = default; + VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) = default; + VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) = default; +#else + VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT + : m_videoSessionParametersKHR( exchange( rhs.m_videoSessionParametersKHR, {} ) ) + { + } + + VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + m_videoSessionParametersKHR = exchange( rhs.m_videoSessionParametersKHR, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT + : m_videoSessionParametersKHR( videoSessionParametersKHR ) + { + } + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT + { + m_videoSessionParametersKHR = videoSessionParametersKHR; + return *this; + } +#endif + + VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_videoSessionParametersKHR = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT + { + return m_videoSessionParametersKHR; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_videoSessionParametersKHR != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_videoSessionParametersKHR == VK_NULL_HANDLE; + } + + private: + VkVideoSessionParametersKHR m_videoSessionParametersKHR = {}; + }; + + template <> + struct CppType + { + using Type = VideoSessionParametersKHR; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = VideoSessionParametersKHR; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryKHR.html + class PipelineBinaryKHR + { + public: + using CType = VkPipelineBinaryKHR; + using NativeType = VkPipelineBinaryKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineBinaryKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + PipelineBinaryKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + PipelineBinaryKHR( PipelineBinaryKHR const & rhs ) = default; + PipelineBinaryKHR & operator=( PipelineBinaryKHR const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + PipelineBinaryKHR( PipelineBinaryKHR && rhs ) = default; + PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) = default; +#else + PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( exchange( rhs.m_pipelineBinaryKHR, {} ) ) {} + + PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + m_pipelineBinaryKHR = exchange( rhs.m_pipelineBinaryKHR, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR PipelineBinaryKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT PipelineBinaryKHR( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( pipelineBinaryKHR ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + PipelineBinaryKHR & operator=( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT + { + m_pipelineBinaryKHR = pipelineBinaryKHR; + return *this; + } +#endif + + PipelineBinaryKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_pipelineBinaryKHR = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineBinaryKHR; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineBinaryKHR != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineBinaryKHR == VK_NULL_HANDLE; + } + + private: + VkPipelineBinaryKHR m_pipelineBinaryKHR = {}; + }; + + template <> + struct CppType + { + using Type = PipelineBinaryKHR; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = PipelineBinaryKHR; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueue.html + class Queue + { + public: + using CType = VkQueue; + using NativeType = VkQueue; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueue; + + public: + Queue() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + Queue( Queue const & rhs ) = default; + Queue & operator=( Queue const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + Queue( Queue && rhs ) = default; + Queue & operator=( Queue && rhs ) = default; +#else + Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT : m_queue( exchange( rhs.m_queue, {} ) ) {} + + Queue & operator=( Queue && rhs ) VULKAN_HPP_NOEXCEPT + { + m_queue = exchange( rhs.m_queue, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {} + + Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT + { + m_queue = queue; + return *this; + } + + Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_queue = {}; + return *this; + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html + template ::type = true> + VULKAN_HPP_NODISCARD Result submit( uint32_t submitCount, + const SubmitInfo * pSubmits, + Fence fence, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type submit( ArrayProxy const & submits, + Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html + template ::type = true> + VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindSparse( uint32_t bindInfoCount, + const BindSparseInfo * pBindInfo, + Fence fence, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindSparse( ArrayProxy const & bindInfo, + Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_3 === + + // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html + template ::type = true> + VULKAN_HPP_NODISCARD Result submit2( uint32_t submitCount, + const SubmitInfo2 * pSubmits, + Fence fence, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type submit2( ArrayProxy const & submits, + Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_swapchain === + + // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR * pPresentInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_debug_utils === + + // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html + template ::type = true> + void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html + template ::type = true> + void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html + template ::type = true> + void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html + template ::type = true> + void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html + template ::type = true> + void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_device_diagnostic_checkpoints === + + // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html + template ::type = true> + void getCheckpointDataNV( uint32_t * pCheckpointDataCount, + CheckpointDataNV * pCheckpointData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getCheckpointDataNV( CheckpointDataNVAllocator const & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html + template ::type = true> + void getCheckpointData2NV( uint32_t * pCheckpointDataCount, + CheckpointData2NV * pCheckpointData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getCheckpointData2NV( CheckpointData2NVAllocator const & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_INTEL_performance_query === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + //=== VK_KHR_synchronization2 === + + // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t submitCount, + const SubmitInfo2 * pSubmits, + Fence fence, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + submit2KHR( ArrayProxy const & submits, + Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_low_latency2 === + + // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html + template ::type = true> + void notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV * pQueueTypeInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html + template ::type = true> + void notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + operator VkQueue() const VULKAN_HPP_NOEXCEPT + { + return m_queue; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_queue != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_queue == VK_NULL_HANDLE; + } + + private: + VkQueue m_queue = {}; + }; + + template <> + struct CppType + { + using Type = Queue; + }; + + template <> + struct CppType + { + using Type = Queue; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Queue; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDevice.html + class Device + { + public: + using CType = VkDevice; + using NativeType = VkDevice; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDevice; + + public: + Device() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + Device( Device const & rhs ) = default; + Device & operator=( Device const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + Device( Device && rhs ) = default; + Device & operator=( Device && rhs ) = default; +#else + Device( Device && rhs ) VULKAN_HPP_NOEXCEPT : m_device( exchange( rhs.m_device, {} ) ) {} + + Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT + { + m_device = exchange( rhs.m_device, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {} + + Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT + { + m_device = device; + return *this; + } + + Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_device = {}; + return *this; + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html + template ::type = true> + PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html + template ::type = true> + PFN_VoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html + template ::type = true> + void destroy( const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html + template ::type = true> + void destroy( Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html + template ::type = true> + void getQueue( uint32_t queueFamilyIndex, + uint32_t queueIndex, + Queue * pQueue, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html + template ::type = true> + VULKAN_HPP_NODISCARD Queue getQueue( uint32_t queueFamilyIndex, + uint32_t queueIndex, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html + template ::type = true> + VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html + template ::type = true> + VULKAN_HPP_NODISCARD Result allocateMemory( const MemoryAllocateInfo * pAllocateInfo, + const AllocationCallbacks * pAllocator, + DeviceMemory * pMemory, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + allocateMemory( const MemoryAllocateInfo & allocateInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html + template ::type = true> + void freeMemory( DeviceMemory memory, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html + template ::type = true> + void freeMemory( DeviceMemory memory VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html + template ::type = true> + void( free )( DeviceMemory memory, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html + template ::type = true> + void( free )( DeviceMemory memory, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html + template ::type = true> + VULKAN_HPP_NODISCARD Result mapMemory( DeviceMemory memory, + DeviceSize offset, + DeviceSize size, + MemoryMapFlags flags, + void ** ppData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type mapMemory( DeviceMemory memory, + DeviceSize offset, + DeviceSize size, + MemoryMapFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html + template ::type = true> + void unmapMemory( DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html + template ::type = true> + VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t memoryRangeCount, + const MappedMemoryRange * pMemoryRanges, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + flushMappedMemoryRanges( ArrayProxy const & memoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkInvalidateMappedMemoryRanges, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html + template ::type = true> + VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, + const MappedMemoryRange * pMemoryRanges, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkInvalidateMappedMemoryRanges, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + invalidateMappedMemoryRanges( ArrayProxy const & memoryRanges, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html + template ::type = true> + void getMemoryCommitment( DeviceMemory memory, + DeviceSize * pCommittedMemoryInBytes, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html + template ::type = true> + VULKAN_HPP_NODISCARD DeviceSize getMemoryCommitment( DeviceMemory memory, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindBufferMemory( Buffer buffer, + DeviceMemory memory, + DeviceSize memoryOffset, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindImageMemory( Image image, + DeviceMemory memory, + DeviceSize memoryOffset, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html + template ::type = true> + void getBufferMemoryRequirements( Buffer buffer, + MemoryRequirements * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements + getBufferMemoryRequirements( Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html + template ::type = true> + void getImageMemoryRequirements( Image image, + MemoryRequirements * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements getImageMemoryRequirements( Image image, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html + template ::type = true> + void getImageSparseMemoryRequirements( Image image, + uint32_t * pSparseMemoryRequirementCount, + SparseImageMemoryRequirements * pSparseMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html + template < + typename SparseImageMemoryRequirementsAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirements( Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html + template < + typename SparseImageMemoryRequirementsAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirements( Image image, + SparseImageMemoryRequirementsAllocator const & sparseImageMemoryRequirementsAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createFence( const FenceCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Fence * pFence, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createFence( const FenceCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createFenceUnique( const FenceCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html + template ::type = true> + void destroyFence( Fence fence, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html + template ::type = true> + void destroyFence( Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html + template ::type = true> + void destroy( Fence fence, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html + template ::type = true> + void destroy( Fence fence, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html + template ::type = true> + VULKAN_HPP_NODISCARD Result resetFences( uint32_t fenceCount, + const Fence * pFences, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + resetFences( ArrayProxy const & fences, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getFenceStatus( Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getFenceStatus( Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html + template ::type = true> + VULKAN_HPP_NODISCARD Result waitForFences( uint32_t fenceCount, + const Fence * pFences, + Bool32 waitAll, + uint64_t timeout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html + template ::type = true> + VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy const & fences, + Bool32 waitAll, + uint64_t timeout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createSemaphore( const SemaphoreCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Semaphore * pSemaphore, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSemaphore( const SemaphoreCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html + template ::type = true> + void destroySemaphore( Semaphore semaphore, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html + template ::type = true> + void destroySemaphore( Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html + template ::type = true> + void destroy( Semaphore semaphore, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html + template ::type = true> + void destroy( Semaphore semaphore, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createQueryPool( const QueryPoolCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + QueryPool * pQueryPool, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createQueryPool( const QueryPoolCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html + template ::type = true> + void destroyQueryPool( QueryPool queryPool, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html + template ::type = true> + void destroyQueryPool( QueryPool queryPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html + template ::type = true> + void destroy( QueryPool queryPool, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html + template ::type = true> + void destroy( QueryPool queryPool, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getQueryPoolResults( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void * pData, + DeviceSize stride, + QueryResultFlags flags, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + getQueryPoolResults( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + DeviceSize stride, + QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue getQueryPoolResult( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + DeviceSize stride, + QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createBuffer( const BufferCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Buffer * pBuffer, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createBuffer( const BufferCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createBufferUnique( const BufferCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html + template ::type = true> + void destroyBuffer( Buffer buffer, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html + template ::type = true> + void destroyBuffer( Buffer buffer VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html + template ::type = true> + void + destroy( Buffer buffer, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html + template ::type = true> + void destroy( Buffer buffer, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createImage( const ImageCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Image * pImage, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createImage( const ImageCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createImageUnique( const ImageCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html + template ::type = true> + void destroyImage( Image image, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html + template ::type = true> + void destroyImage( Image image VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html + template ::type = true> + void destroy( Image image, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html + template ::type = true> + void destroy( Image image, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html + template ::type = true> + void getImageSubresourceLayout( Image image, + const ImageSubresource * pSubresource, + SubresourceLayout * pLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html + template ::type = true> + VULKAN_HPP_NODISCARD SubresourceLayout getImageSubresourceLayout( Image image, + const ImageSubresource & subresource, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createImageView( const ImageViewCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + ImageView * pView, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createImageView( const ImageViewCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createImageViewUnique( const ImageViewCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html + template ::type = true> + void destroyImageView( ImageView imageView, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html + template ::type = true> + void destroyImageView( ImageView imageView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html + template ::type = true> + void destroy( ImageView imageView, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html + template ::type = true> + void destroy( ImageView imageView, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createCommandPool( const CommandPoolCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + CommandPool * pCommandPool, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createCommandPool( const CommandPoolCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html + template ::type = true> + void destroyCommandPool( CommandPool commandPool, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html + template ::type = true> + void destroyCommandPool( CommandPool commandPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html + template ::type = true> + void destroy( CommandPool commandPool, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html + template ::type = true> + void destroy( CommandPool commandPool, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html + template ::type = true> + VULKAN_HPP_NODISCARD Result resetCommandPool( CommandPool commandPool, + CommandPoolResetFlags flags, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + resetCommandPool( CommandPool commandPool, + CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + template ::type = true> + VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const CommandBufferAllocateInfo * pAllocateInfo, + CommandBuffer * pCommandBuffers, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, + CommandBufferAllocator const & commandBufferAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, CommandBufferAllocator>>::type + allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, CommandBufferAllocator>>::type + allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, + CommandBufferAllocator const & commandBufferAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html + template ::type = true> + void freeCommandBuffers( CommandPool commandPool, + uint32_t commandBufferCount, + const CommandBuffer * pCommandBuffers, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html + template ::type = true> + void freeCommandBuffers( CommandPool commandPool, + ArrayProxy const & commandBuffers, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html + template ::type = true> + void( free )( CommandPool commandPool, + uint32_t commandBufferCount, + const CommandBuffer * pCommandBuffers, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html + template ::type = true> + void( free )( CommandPool commandPool, + ArrayProxy const & commandBuffers, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createEvent( const EventCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Event * pEvent, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createEvent( const EventCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createEventUnique( const EventCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html + template ::type = true> + void destroyEvent( Event event, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html + template ::type = true> + void destroyEvent( Event event VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html + template ::type = true> + void destroy( Event event, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html + template ::type = true> + void destroy( Event event, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getEventStatus( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getEventStatus( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setEvent( Event event, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html + template ::type = true> + VULKAN_HPP_NODISCARD Result resetEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + resetEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createBufferView( const BufferViewCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + BufferView * pView, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createBufferView( const BufferViewCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createBufferViewUnique( const BufferViewCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html + template ::type = true> + void destroyBufferView( BufferView bufferView, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html + template ::type = true> + void destroyBufferView( BufferView bufferView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html + template ::type = true> + void destroy( BufferView bufferView, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html + template ::type = true> + void destroy( BufferView bufferView, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createShaderModule( const ShaderModuleCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + ShaderModule * pShaderModule, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createShaderModule( const ShaderModuleCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html + template ::type = true> + void destroyShaderModule( ShaderModule shaderModule, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html + template ::type = true> + void destroyShaderModule( ShaderModule shaderModule VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html + template ::type = true> + void destroy( ShaderModule shaderModule, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html + template ::type = true> + void destroy( ShaderModule shaderModule, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createPipelineCache( const PipelineCacheCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + PipelineCache * pPipelineCache, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createPipelineCache( const PipelineCacheCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html + template ::type = true> + void destroyPipelineCache( PipelineCache pipelineCache, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html + template ::type = true> + void destroyPipelineCache( PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html + template ::type = true> + void destroy( PipelineCache pipelineCache, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html + template ::type = true> + void destroy( PipelineCache pipelineCache, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getPipelineCacheData( PipelineCache pipelineCache, + size_t * pDataSize, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getPipelineCacheData( PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getPipelineCacheData( + PipelineCache pipelineCache, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html + template ::type = true> + VULKAN_HPP_NODISCARD Result mergePipelineCaches( PipelineCache dstCache, + uint32_t srcCacheCount, + const PipelineCache * pSrcCaches, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type mergePipelineCaches( + PipelineCache dstCache, ArrayProxy const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createComputePipelines( PipelineCache pipelineCache, + uint32_t createInfoCount, + const ComputePipelineCreateInfo * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createComputePipelines( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createComputePipelines( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue createComputePipeline( PipelineCache pipelineCache, + const ComputePipelineCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createComputePipelinesUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createComputePipelinesUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createComputePipelineUnique( PipelineCache pipelineCache, + const ComputePipelineCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html + template ::type = true> + void destroyPipeline( Pipeline pipeline, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html + template ::type = true> + void destroyPipeline( Pipeline pipeline VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html + template ::type = true> + void destroy( Pipeline pipeline, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html + template ::type = true> + void destroy( Pipeline pipeline, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createPipelineLayout( const PipelineLayoutCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + PipelineLayout * pPipelineLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html + template ::type = true> + void destroyPipelineLayout( PipelineLayout pipelineLayout, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html + template ::type = true> + void destroyPipelineLayout( PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html + template ::type = true> + void destroy( PipelineLayout pipelineLayout, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html + template ::type = true> + void destroy( PipelineLayout pipelineLayout, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createSampler( const SamplerCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Sampler * pSampler, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSampler( const SamplerCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createSamplerUnique( const SamplerCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html + template ::type = true> + void destroySampler( Sampler sampler, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html + template ::type = true> + void destroySampler( Sampler sampler VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html + template ::type = true> + void + destroy( Sampler sampler, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html + template ::type = true> + void destroy( Sampler sampler, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + DescriptorSetLayout * pSetLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorSetLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html + template ::type = true> + void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorSetLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html + template ::type = true> + void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorSetLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html + template ::type = true> + void destroy( DescriptorSetLayout descriptorSetLayout, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorSetLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html + template ::type = true> + void destroy( DescriptorSetLayout descriptorSetLayout, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDescriptorPool( const DescriptorPoolCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + DescriptorPool * pDescriptorPool, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html + template ::type = true> + void destroyDescriptorPool( DescriptorPool descriptorPool, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html + template ::type = true> + void destroyDescriptorPool( DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html + template ::type = true> + void destroy( DescriptorPool descriptorPool, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html + template ::type = true> + void destroy( DescriptorPool descriptorPool, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html + template ::type = true> + VULKAN_HPP_NODISCARD Result resetDescriptorPool( DescriptorPool descriptorPool, + DescriptorPoolResetFlags flags, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + resetDescriptorPool( DescriptorPool descriptorPool, + DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + template ::type = true> + VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const DescriptorSetAllocateInfo * pAllocateInfo, + DescriptorSet * pDescriptorSets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, + DescriptorSetAllocator const & descriptorSetAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, DescriptorSetAllocator>>::type + allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, DescriptorSetAllocator>>::type + allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, + DescriptorSetAllocator const & descriptorSetAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html + template ::type = true> + VULKAN_HPP_NODISCARD Result freeDescriptorSets( DescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const DescriptorSet * pDescriptorSets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + freeDescriptorSets( DescriptorPool descriptorPool, + ArrayProxy const & descriptorSets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html + template ::type = true> + VULKAN_HPP_NODISCARD Result( free )( DescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const DescriptorSet * pDescriptorSets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type( free )( DescriptorPool descriptorPool, + ArrayProxy const & descriptorSets, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html + template ::type = true> + void updateDescriptorSets( uint32_t descriptorWriteCount, + const WriteDescriptorSet * pDescriptorWrites, + uint32_t descriptorCopyCount, + const CopyDescriptorSet * pDescriptorCopies, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html + template ::type = true> + void updateDescriptorSets( ArrayProxy const & descriptorWrites, + ArrayProxy const & descriptorCopies, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createGraphicsPipelines( PipelineCache pipelineCache, + uint32_t createInfoCount, + const GraphicsPipelineCreateInfo * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createGraphicsPipelines( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createGraphicsPipelines( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue createGraphicsPipeline( PipelineCache pipelineCache, + const GraphicsPipelineCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createGraphicsPipelinesUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createGraphicsPipelinesUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createGraphicsPipelineUnique( PipelineCache pipelineCache, + const GraphicsPipelineCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createFramebuffer( const FramebufferCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Framebuffer * pFramebuffer, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createFramebuffer( const FramebufferCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createFramebufferUnique( const FramebufferCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html + template ::type = true> + void destroyFramebuffer( Framebuffer framebuffer, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html + template ::type = true> + void destroyFramebuffer( Framebuffer framebuffer VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html + template ::type = true> + void destroy( Framebuffer framebuffer, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html + template ::type = true> + void destroy( Framebuffer framebuffer, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createRenderPass( const RenderPassCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + RenderPass * pRenderPass, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createRenderPass( const RenderPassCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createRenderPassUnique( const RenderPassCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html + template ::type = true> + void destroyRenderPass( RenderPass renderPass, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html + template ::type = true> + void destroyRenderPass( RenderPass renderPass VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html + template ::type = true> + void destroy( RenderPass renderPass, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html + template ::type = true> + void destroy( RenderPass renderPass, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html + template ::type = true> + void getRenderAreaGranularity( RenderPass renderPass, + Extent2D * pGranularity, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html + template ::type = true> + VULKAN_HPP_NODISCARD Extent2D getRenderAreaGranularity( RenderPass renderPass, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t bindInfoCount, + const BindBufferMemoryInfo * pBindInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindBufferMemory2( ArrayProxy const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t bindInfoCount, + const BindImageMemoryInfo * pBindInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindImageMemory2( ArrayProxy const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html + template ::type = true> + void getGroupPeerMemoryFeatures( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + PeerMemoryFeatureFlags * pPeerMemoryFeatures, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html + template ::type = true> + VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags + getGroupPeerMemoryFeatures( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html + template ::type = true> + void getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2( + const ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetImageMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html + template ::type = true> + void getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2( + const BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetBufferMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSparseMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html + template ::type = true> + void getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 * pInfo, + uint32_t * pSparseMemoryRequirementCount, + SparseImageMemoryRequirements2 * pSparseMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSparseMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html + template < + typename SparseImageMemoryRequirements2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetImageSparseMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html + template < + typename SparseImageMemoryRequirements2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, + SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html + template ::type = true> + void trimCommandPool( CommandPool commandPool, + CommandPoolTrimFlags flags, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html + template ::type = true> + void + getQueue2( const DeviceQueueInfo2 * pQueueInfo, Queue * pQueue, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html + template ::type = true> + VULKAN_HPP_NODISCARD Queue getQueue2( const DeviceQueueInfo2 & queueInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + DescriptorUpdateTemplate * pDescriptorUpdateTemplate, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html + template ::type = true> + void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html + template ::type = true> + void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html + template ::type = true> + void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html + template ::type = true> + void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html + template ::type = true> + void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, + DescriptorUpdateTemplate descriptorUpdateTemplate, + const void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html + template ::type = true> + void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, + DescriptorUpdateTemplate descriptorUpdateTemplate, + DataType const & data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDescriptorSetLayoutSupport, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html + template ::type = true> + void getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo * pCreateInfo, + DescriptorSetLayoutSupport * pSupport, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetLayoutSupport, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html + template ::type = true> + VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( + const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetDescriptorSetLayoutSupport, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateSamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + SamplerYcbcrConversion * pYcbcrConversion, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html + template ::type = true> + void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html + template ::type = true> + void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html + template ::type = true> + void destroy( SamplerYcbcrConversion ycbcrConversion, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html + template ::type = true> + void destroy( SamplerYcbcrConversion ycbcrConversion, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_2 === + + // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html + template ::type = true> + void resetQueryPool( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( Semaphore semaphore, + uint64_t * pValue, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreCounterValue( Semaphore semaphore, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html + template ::type = true> + VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo * pWaitInfo, + uint64_t timeout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html + template ::type = true> + VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo & waitInfo, + uint64_t timeout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html + template ::type = true> + VULKAN_HPP_NODISCARD Result signalSemaphore( const SemaphoreSignalInfo * pSignalInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + signalSemaphore( const SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html + template ::type = true> + DeviceAddress getBufferAddress( const BufferDeviceAddressInfo * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html + template ::type = true> + DeviceAddress getBufferAddress( const BufferDeviceAddressInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html + template ::type = true> + uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html + template ::type = true> + uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html + template ::type = true> + uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html + template ::type = true> + uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createRenderPass2( const RenderPassCreateInfo2 * pCreateInfo, + const AllocationCallbacks * pAllocator, + RenderPass * pRenderPass, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createRenderPass2( const RenderPassCreateInfo2 & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createRenderPass2Unique( const RenderPassCreateInfo2 & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_3 === + + // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const PrivateDataSlotCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + PrivateDataSlot * pPrivateDataSlot, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createPrivateDataSlot( const PrivateDataSlotCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createPrivateDataSlotUnique( const PrivateDataSlotCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html + template ::type = true> + void destroyPrivateDataSlot( PrivateDataSlot privateDataSlot, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html + template ::type = true> + void destroyPrivateDataSlot( PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html + template ::type = true> + void destroy( PrivateDataSlot privateDataSlot, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html + template ::type = true> + void destroy( PrivateDataSlot privateDataSlot, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setPrivateData( ObjectType objectType, + uint64_t objectHandle, + PrivateDataSlot privateDataSlot, + uint64_t data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setPrivateData( ObjectType objectType, + uint64_t objectHandle, + PrivateDataSlot privateDataSlot, + uint64_t data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html + template ::type = true> + void getPrivateData( ObjectType objectType, + uint64_t objectHandle, + PrivateDataSlot privateDataSlot, + uint64_t * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html + template ::type = true> + VULKAN_HPP_NODISCARD uint64_t getPrivateData( ObjectType objectType, + uint64_t objectHandle, + PrivateDataSlot privateDataSlot, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html + template ::type = true> + void getBufferMemoryRequirements( const DeviceBufferMemoryRequirements * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements( + const DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetDeviceBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html + template ::type = true> + void getImageMemoryRequirements( const DeviceImageMemoryRequirements * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements( + const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetDeviceImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getImageMemoryRequirements( const DeviceImageMemoryRequirements & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html + template ::type = true> + void getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements * pInfo, + uint32_t * pSparseMemoryRequirementCount, + SparseImageMemoryRequirements2 * pSparseMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html + template < + typename SparseImageMemoryRequirements2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html + template < + typename SparseImageMemoryRequirements2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info, + SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_4 === + + // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html + template ::type = true> + VULKAN_HPP_NODISCARD Result mapMemory2( const MemoryMapInfo * pMemoryMapInfo, + void ** ppData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type mapMemory2( const MemoryMapInfo & memoryMapInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html + template ::type = true> + VULKAN_HPP_NODISCARD Result unmapMemory2( const MemoryUnmapInfo * pMemoryUnmapInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageSubresourceLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html + template ::type = true> + void getImageSubresourceLayout( const DeviceImageSubresourceInfo * pInfo, + SubresourceLayout2 * pLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageSubresourceLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html + template ::type = true> + VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout( const DeviceImageSubresourceInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetDeviceImageSubresourceLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getImageSubresourceLayout( const DeviceImageSubresourceInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSubresourceLayout2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html + template ::type = true> + void getImageSubresourceLayout2( Image image, + const ImageSubresource2 * pSubresource, + SubresourceLayout2 * pLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSubresourceLayout2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html + template ::type = true> + VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2( Image image, + const ImageSubresource2 & subresource, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetImageSubresourceLayout2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain getImageSubresourceLayout2( + Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyMemoryToImage( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + copyMemoryToImage( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyImageToMemory( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + copyImageToMemory( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyImageToImage( const CopyImageToImageInfo * pCopyImageToImageInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + copyImageToImage( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html + template ::type = true> + VULKAN_HPP_NODISCARD Result transitionImageLayout( uint32_t transitionCount, + const HostImageLayoutTransitionInfo * pTransitions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + transitionImageLayout( ArrayProxy const & transitions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRenderingAreaGranularity, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html + template ::type = true> + void getRenderingAreaGranularity( const RenderingAreaInfo * pRenderingAreaInfo, + Extent2D * pGranularity, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRenderingAreaGranularity, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html + template ::type = true> + VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularity( const RenderingAreaInfo & renderingAreaInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_swapchain === + + // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createSwapchainKHR( const SwapchainCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SwapchainKHR * pSwapchain, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html + template ::type = true> + void destroySwapchainKHR( SwapchainKHR swapchain, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html + template ::type = true> + void destroySwapchainKHR( SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html + template ::type = true> + void destroy( SwapchainKHR swapchain, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html + template ::type = true> + void destroy( SwapchainKHR swapchain, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( SwapchainKHR swapchain, + uint32_t * pSwapchainImageCount, + Image * pSwapchainImages, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSwapchainImagesKHR( SwapchainKHR swapchain, ImageAllocator const & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result acquireNextImageKHR( SwapchainKHR swapchain, + uint64_t timeout, + Semaphore semaphore, + Fence fence, + uint32_t * pImageIndex, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue acquireNextImageKHR( SwapchainKHR swapchain, + uint64_t timeout, + Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( SurfaceKHR surface, + DeviceGroupPresentModeFlagsKHR * pModes, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const AcquireNextImageInfoKHR * pAcquireInfo, + uint32_t * pImageIndex, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_display_swapchain === + + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t swapchainCount, + const SwapchainCreateInfoKHR * pCreateInfos, + const AllocationCallbacks * pAllocator, + SwapchainKHR * pSwapchains, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createSharedSwapchainsKHR( ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createSharedSwapchainsKHR( ArrayProxy const & createInfos, + Optional allocator, + SwapchainKHRAllocator const & swapchainKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, SwapchainKHRAllocator>>::type + createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, SwapchainKHRAllocator>>::type + createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, + Optional allocator, + SwapchainKHRAllocator const & swapchainKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_debug_marker === + + // wrapper function for command vkDebugMarkerSetObjectTagEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT * pTagInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDebugMarkerSetObjectTagEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDebugMarkerSetObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT * pNameInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDebugMarkerSetObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_video_queue === + + // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VideoSessionCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + VideoSessionKHR * pVideoSession, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createVideoSessionKHR( const VideoSessionCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html + template ::type = true> + void destroyVideoSessionKHR( VideoSessionKHR videoSession, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html + template ::type = true> + void destroyVideoSessionKHR( VideoSessionKHR videoSession VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html + template ::type = true> + void destroy( VideoSessionKHR videoSession, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html + template ::type = true> + void destroy( VideoSessionKHR videoSession, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, + uint32_t * pMemoryRequirementsCount, + VideoSessionMemoryRequirementsKHR * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, + VideoSessionMemoryRequirementsKHRAllocator const & videoSessionMemoryRequirementsKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindVideoSessionMemoryKHR( VideoSessionKHR videoSession, + ArrayProxy const & bindSessionMemoryInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + VideoSessionParametersKHR * pVideoSessionParameters, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, + const VideoSessionParametersUpdateInfoKHR * pUpdateInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + updateVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, + const VideoSessionParametersUpdateInfoKHR & updateInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html + template ::type = true> + void destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html + template ::type = true> + void destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html + template ::type = true> + void destroy( VideoSessionParametersKHR videoSessionParameters, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html + template ::type = true> + void destroy( VideoSessionParametersKHR videoSessionParameters, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NVX_binary_import === + + // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createCuModuleNVX( const CuModuleCreateInfoNVX * pCreateInfo, + const AllocationCallbacks * pAllocator, + CuModuleNVX * pModule, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createCuModuleNVX( const CuModuleCreateInfoNVX & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createCuModuleNVXUnique( const CuModuleCreateInfoNVX & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const CuFunctionCreateInfoNVX * pCreateInfo, + const AllocationCallbacks * pAllocator, + CuFunctionNVX * pFunction, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createCuFunctionNVX( const CuFunctionCreateInfoNVX & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html + template ::type = true> + void destroyCuModuleNVX( CuModuleNVX module, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html + template ::type = true> + void destroyCuModuleNVX( CuModuleNVX module, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html + template ::type = true> + void destroy( CuModuleNVX module, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html + template ::type = true> + void destroy( CuModuleNVX module, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html + template ::type = true> + void destroyCuFunctionNVX( CuFunctionNVX function, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html + template ::type = true> + void destroyCuFunctionNVX( CuFunctionNVX function, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html + template ::type = true> + void destroy( CuFunctionNVX function, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html + template ::type = true> + void destroy( CuFunctionNVX function, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NVX_image_view_handle === + + // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html + template ::type = true> + uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html + template ::type = true> + uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html + template ::type = true> + uint64_t getImageViewHandle64NVX( const ImageViewHandleInfoNVX * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html + template ::type = true> + uint64_t getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( ImageView imageView, + ImageViewAddressPropertiesNVX * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageViewAddressNVX( ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html + template ::type = true> + uint64_t getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex, + uint64_t samplerIndex, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_AMD_shader_info === + + // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getShaderInfoAMD( Pipeline pipeline, + ShaderStageFlagBits shaderStage, + ShaderInfoTypeAMD infoType, + size_t * pInfoSize, + void * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getShaderInfoAMD( + Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getShaderInfoAMD( Pipeline pipeline, + ShaderStageFlagBits shaderStage, + ShaderInfoTypeAMD infoType, + Uint8_tAllocator const & uint8_tAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + + // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( DeviceMemory memory, + ExternalMemoryHandleTypeFlagsNV handleType, + HANDLE * pHandle, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryWin32HandleNV( DeviceMemory memory, + ExternalMemoryHandleTypeFlagsNV handleType, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_device_group === + + // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html + template ::type = true> + void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + PeerMemoryFeatureFlags * pPeerMemoryFeatures, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags + getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_maintenance1 === + + // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html + template ::type = true> + void trimCommandPoolKHR( CommandPool commandPool, + CommandPoolTrimFlags flags, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + + // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, + HANDLE * pHandle, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, + HANDLE handle, + MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryWin32HandlePropertiesKHR( + ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + + // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const MemoryGetFdInfoKHR * pGetFdInfo, + int * pFd, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, + int fd, + MemoryFdPropertiesKHR * pMemoryFdProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + + // wrapper function for command vkImportSemaphoreWin32HandleKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkImportSemaphoreWin32HandleKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSemaphoreWin32HandleKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, + HANDLE * pHandle, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSemaphoreWin32HandleKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + + // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR * pGetFdInfo, + int * pFd, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_descriptor_update_template === + + // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + DescriptorUpdateTemplate * pDescriptorUpdateTemplate, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html + template ::type = true> + void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html + template ::type = true> + void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html + template ::type = true> + void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, + DescriptorUpdateTemplate descriptorUpdateTemplate, + const void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html + template ::type = true> + void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, + DescriptorUpdateTemplate descriptorUpdateTemplate, + DataType const & data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_display_control === + + // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result displayPowerControlEXT( DisplayKHR display, + const DisplayPowerInfoEXT * pDisplayPowerInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type displayPowerControlEXT( + DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result registerEventEXT( const DeviceEventInfoEXT * pDeviceEventInfo, + const AllocationCallbacks * pAllocator, + Fence * pFence, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( DisplayKHR display, + const DisplayEventInfoEXT * pDisplayEventInfo, + const AllocationCallbacks * pAllocator, + Fence * pFence, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + registerDisplayEventEXT( DisplayKHR display, + const DisplayEventInfoEXT & displayEventInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + registerDisplayEventEXTUnique( DisplayKHR display, + const DisplayEventInfoEXT & displayEventInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( SwapchainKHR swapchain, + SurfaceCounterFlagBitsEXT counter, + uint64_t * pCounterValue, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + ResultValue +# else + typename ResultValueType::type +# endif + getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_GOOGLE_display_timing === + + // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, + RefreshCycleDurationGOOGLE * pDisplayTimingProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPastPresentationTimingGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, + uint32_t * pPresentationTimingCount, + PastPresentationTimingGOOGLE * pPresentationTimings, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPastPresentationTimingGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html + template < + typename PastPresentationTimingGOOGLEAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + ResultValue> +# else + typename ResultValueType>::type +# endif + getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPastPresentationTimingGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html + template < + typename PastPresentationTimingGOOGLEAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + ResultValue> +# else + typename ResultValueType>::type +# endif + getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, + PastPresentationTimingGOOGLEAllocator const & pastPresentationTimingGOOGLEAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_hdr_metadata === + + // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html + template ::type = true> + void setHdrMetadataEXT( uint32_t swapchainCount, + const SwapchainKHR * pSwapchains, + const HdrMetadataEXT * pMetadata, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html + template ::type = true> + void setHdrMetadataEXT( ArrayProxy const & swapchains, + ArrayProxy const & metadata, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_create_renderpass2 === + + // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const RenderPassCreateInfo2 * pCreateInfo, + const AllocationCallbacks * pAllocator, + RenderPass * pRenderPass, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_shared_presentable_image === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( SwapchainKHR swapchain, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + + // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, + HANDLE * pHandle, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + + // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result importFenceFdKHR( const ImportFenceFdInfoKHR * pImportFenceFdInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getFenceFdKHR( const FenceGetFdInfoKHR * pGetFdInfo, + int * pFd, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_performance_query === + + // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html + template ::type = true> + void releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_debug_utils === + + // wrapper function for command vkSetDebugUtilsObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT * pNameInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetDebugUtilsObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkSetDebugUtilsObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT * pTagInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkSetDebugUtilsObjectTagEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setDebugUtilsObjectTagEXT( + HandleType const & handle, uint64_t name, TagType const & tag, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer, + AndroidHardwareBufferPropertiesANDROID * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID * pInfo, + struct AHardwareBuffer ** pBuffer, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, + uint32_t createInfoCount, + const ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue + createExecutionGraphPipelineAMDX( PipelineCache pipelineCache, + const ExecutionGraphPipelineCreateInfoAMDX & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createExecutionGraphPipelineAMDXUnique( PipelineCache pipelineCache, + const ExecutionGraphPipelineCreateInfoAMDX & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph, + ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX( Pipeline executionGraph, + const PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo, + uint32_t * pNodeIndex, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getExecutionGraphPipelineNodeIndexAMDX( + Pipeline executionGraph, const PipelineShaderStageNodeCreateInfoAMDX & nodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + + // wrapper function for command vkWriteSamplerDescriptorsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result writeSamplerDescriptorsEXT( uint32_t samplerCount, + const SamplerCreateInfo * pSamplers, + const HostAddressRangeEXT * pDescriptors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWriteSamplerDescriptorsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + writeSamplerDescriptorsEXT( ArrayProxy const & samplers, + ArrayProxy const & descriptors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkWriteResourceDescriptorsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result writeResourceDescriptorsEXT( uint32_t resourceCount, + const ResourceDescriptorInfoEXT * pResources, + const HostAddressRangeEXT * pDescriptors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWriteResourceDescriptorsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + writeResourceDescriptorsEXT( ArrayProxy const & resources, + ArrayProxy const & descriptors, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDataEXT( uint32_t imageCount, + const Image * pImages, + HostAddressRangeEXT * pDatas, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getImageOpaqueCaptureDataEXT( ArrayProxy const & images, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getImageOpaqueCaptureDataEXT( ArrayProxy const & images, + HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageOpaqueCaptureDataEXT( const Image & image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkRegisterCustomBorderColorEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT * pBorderColor, + Bool32 requestIndex, + uint32_t * pIndex, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkRegisterCustomBorderColorEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type registerCustomBorderColorEXT( + const SamplerCustomBorderColorCreateInfoEXT & borderColor, Bool32 requestIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUnregisterCustomBorderColorEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html + template ::type = true> + void unregisterCustomBorderColorEXT( uint32_t index, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getTensorOpaqueCaptureDataARM( uint32_t tensorCount, + const TensorARM * pTensors, + HostAddressRangeEXT * pDatas, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors, + HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getTensorOpaqueCaptureDataARM( const TensorARM & tensor, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_get_memory_requirements2 === + + // wrapper function for command vkGetImageMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html + template ::type = true> + void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2KHR( + const ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetImageMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html + template ::type = true> + void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2KHR( + const BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetBufferMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html + template ::type = true> + void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 * pInfo, + uint32_t * pSparseMemoryRequirementCount, + SparseImageMemoryRequirements2 * pSparseMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html + template < + typename SparseImageMemoryRequirements2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html + template < + typename SparseImageMemoryRequirements2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, + SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_acceleration_structure === + + // wrapper function for command vkCreateAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + AccelerationStructureKHR * pAccelerationStructure, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html + template ::type = true> + void destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html + template ::type = true> + void destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html + template ::type = true> + void destroy( AccelerationStructureKHR accelerationStructure, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html + template ::type = true> + void destroy( AccelerationStructureKHR accelerationStructure, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation, + uint32_t infoCount, + const AccelerationStructureBuildGeometryInfoKHR * pInfos, + const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation, + ArrayProxy const & infos, + ArrayProxy const & pBuildRangeInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureInfoKHR * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureInfoKHR & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureToMemoryInfoKHR * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureToMemoryInfoKHR & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation, + const CopyMemoryToAccelerationStructureInfoKHR * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation, + const CopyMemoryToAccelerationStructureInfoKHR & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, + const AccelerationStructureKHR * pAccelerationStructures, + QueryType queryType, + size_t dataSize, + void * pData, + size_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, + QueryType queryType, + size_t dataSize, + size_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + writeAccelerationStructuresPropertyKHR( ArrayProxy const & accelerationStructures, + QueryType queryType, + size_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html + template ::type = true> + DeviceAddress getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html + template ::type = true> + DeviceAddress getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html + template ::type = true> + void getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR * pVersionInfo, + AccelerationStructureCompatibilityKHR * pCompatibility, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR getAccelerationStructureCompatibilityKHR( + const AccelerationStructureVersionInfoKHR & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html + template ::type = true> + void getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, + const AccelerationStructureBuildGeometryInfoKHR * pBuildInfo, + const uint32_t * pMaxPrimitiveCounts, + AccelerationStructureBuildSizesInfoKHR * pSizeInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR + getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, + const AccelerationStructureBuildGeometryInfoKHR & buildInfo, + ArrayProxy const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_ray_tracing_pipeline === + + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + uint32_t createInfoCount, + const RayTracingPipelineCreateInfoKHR * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue + createRayTracingPipelineKHR( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + const RayTracingPipelineCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createRayTracingPipelineKHRUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + const RayTracingPipelineCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( Pipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getRayTracingShaderGroupHandlesKHR( + Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingShaderGroupHandleKHR( + Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR( + Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) + const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getRayTracingCaptureReplayShaderGroupHandlesKHR( + Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingCaptureReplayShaderGroupHandleKHR( + Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html + template ::type = true> + DeviceSize getRayTracingShaderGroupStackSizeKHR( Pipeline pipeline, + uint32_t group, + ShaderGroupShaderKHR groupShader, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_sampler_ycbcr_conversion === + + // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + SamplerYcbcrConversion * pYcbcrConversion, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html + template ::type = true> + void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html + template ::type = true> + void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_bind_memory2 === + + // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t bindInfoCount, + const BindBufferMemoryInfo * pBindInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindBufferMemory2KHR( ArrayProxy const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t bindInfoCount, + const BindImageMemoryInfo * pBindInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindImageMemory2KHR( ArrayProxy const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_image_drm_format_modifier === + + // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT( Image image, + ImageDrmFormatModifierPropertiesEXT * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_validation_cache === + + // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + ValidationCacheEXT * pValidationCache, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html + template ::type = true> + void destroyValidationCacheEXT( ValidationCacheEXT validationCache, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html + template ::type = true> + void destroyValidationCacheEXT( ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html + template ::type = true> + void destroy( ValidationCacheEXT validationCache, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html + template ::type = true> + void destroy( ValidationCacheEXT validationCache, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const ValidationCacheEXT * pSrcCaches, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type mergeValidationCachesEXT( + ValidationCacheEXT dstCache, ArrayProxy const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, + size_t * pDataSize, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getValidationCacheDataEXT( + ValidationCacheEXT validationCache, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_ray_tracing === + + // wrapper function for command vkCreateAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + AccelerationStructureNV * pAccelerationStructure, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html + template ::type = true> + void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html + template ::type = true> + void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html + template ::type = true> + void destroy( AccelerationStructureNV accelerationStructure, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html + template ::type = true> + void destroy( AccelerationStructureNV accelerationStructure, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html + template ::type = true> + void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV * pInfo, + MemoryRequirements2KHR * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( + const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindAccelerationStructureMemoryNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, + const BindAccelerationStructureMemoryInfoNV * pBindInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindAccelerationStructureMemoryNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindAccelerationStructureMemoryNV( ArrayProxy const & bindInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( PipelineCache pipelineCache, + uint32_t createInfoCount, + const RayTracingPipelineCreateInfoNV * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createRayTracingPipelinesNV( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createRayTracingPipelinesNV( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue + createRayTracingPipelineNV( PipelineCache pipelineCache, + const RayTracingPipelineCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createRayTracingPipelineNVUnique( PipelineCache pipelineCache, + const RayTracingPipelineCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( Pipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getRayTracingShaderGroupHandlesNV( + Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingShaderGroupHandleNV( + Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetAccelerationStructureHandleNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, + size_t dataSize, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAccelerationStructureHandleNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getAccelerationStructureHandleNV( + AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetAccelerationStructureHandleNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result compileDeferredNV( Pipeline pipeline, + uint32_t shader, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + //=== VK_KHR_maintenance3 === + + // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html + template ::type = true> + void getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo * pCreateInfo, + DescriptorSetLayoutSupport * pSupport, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( + const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_external_memory_host === + + // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, + const void * pHostPointer, + MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryHostPointerPropertiesEXT( + ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_calibrated_timestamps === + + // wrapper function for command vkGetCalibratedTimestampsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t timestampCount, + const CalibratedTimestampInfoKHR * pTimestampInfos, + uint64_t * pTimestamps, + uint64_t * pMaxDeviation, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetCalibratedTimestampsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type + getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetCalibratedTimestampsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type + getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos, + Uint64_tAllocator const & uint64_tAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetCalibratedTimestampsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCalibratedTimestampEXT( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_timeline_semaphore === + + // wrapper function for command vkGetSemaphoreCounterValueKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( Semaphore semaphore, + uint64_t * pValue, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSemaphoreCounterValueKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getSemaphoreCounterValueKHR( Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo * pWaitInfo, + uint64_t timeout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, + uint64_t timeout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const SemaphoreSignalInfo * pSignalInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_present_timing === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, + uint32_t size, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, + uint32_t size, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, + SwapchainTimingPropertiesEXT * pSwapchainTimingProperties, + uint64_t * pSwapchainTimingPropertiesCounter, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue> + getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSwapchainTimeDomainPropertiesEXT( SwapchainKHR swapchain, + SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, + uint64_t * pTimeDomainsCounter, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPastPresentationTimingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, + PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_INTEL_performance_query === + + // wrapper function for command vkInitializePerformanceApiINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL * pInitializeInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkInitializePerformanceApiINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUninitializePerformanceApiINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html + template ::type = true> + void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, + PerformanceConfigurationINTEL * pConfiguration, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleasePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkReleasePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleasePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD Result release( PerformanceConfigurationINTEL configuration, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkReleasePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type release( PerformanceConfigurationINTEL configuration, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetPerformanceParameterINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, + PerformanceValueINTEL * pValue, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPerformanceParameterINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_AMD_display_native_hdr === + + // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html + template ::type = true> + void setLocalDimmingAMD( SwapchainKHR swapChain, + Bool32 localDimmingEnable, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_buffer_device_address === + + // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html + template ::type = true> + DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfo * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html + template ::type = true> + DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_present_wait === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result waitForPresentKHR( SwapchainKHR swapchain, + uint64_t presentId, + uint64_t timeout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + waitForPresentKHR( SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + +# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# else + // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# else + // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + DeviceGroupPresentModeFlagsKHR * pModes, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_buffer_device_address === + + // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html + template ::type = true> + DeviceAddress getBufferAddressKHR( const BufferDeviceAddressInfo * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html + template ::type = true> + DeviceAddress getBufferAddressKHR( const BufferDeviceAddressInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html + template ::type = true> + uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html + template ::type = true> + uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html + template ::type = true> + uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html + template ::type = true> + uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_host_query_reset === + + // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html + template ::type = true> + void resetQueryPoolEXT( QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_deferred_host_operations === + + // wrapper function for command vkCreateDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const AllocationCallbacks * pAllocator, + DeferredOperationKHR * pDeferredOperation, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDeferredOperationKHR( Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDeferredOperationKHRUnique( Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html + template ::type = true> + void destroyDeferredOperationKHR( DeferredOperationKHR operation, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html + template ::type = true> + void destroyDeferredOperationKHR( DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html + template ::type = true> + void destroy( DeferredOperationKHR operation, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html + template ::type = true> + void destroy( DeferredOperationKHR operation, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html + template ::type = true> + uint32_t getDeferredOperationMaxConcurrencyKHR( DeferredOperationKHR operation, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeferredOperationResultKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( DeferredOperationKHR operation, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkGetDeferredOperationResultKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( DeferredOperationKHR operation, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( DeferredOperationKHR operation, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + //=== VK_KHR_pipeline_executable_properties === + + // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const PipelineInfoKHR * pPipelineInfo, + uint32_t * pExecutableCount, + PipelineExecutablePropertiesKHR * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, + PipelineExecutablePropertiesKHRAllocator const & pipelineExecutablePropertiesKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR * pExecutableInfo, + uint32_t * pStatisticCount, + PipelineExecutableStatisticKHR * pStatistics, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html + template < + typename PipelineExecutableStatisticKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html + template < + typename PipelineExecutableStatisticKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, + PipelineExecutableStatisticKHRAllocator const & pipelineExecutableStatisticKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR * pExecutableInfo, + uint32_t * pInternalRepresentationCount, + PipelineExecutableInternalRepresentationKHR * pInternalRepresentations, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if< + std::is_same::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if< + std::is_same::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getPipelineExecutableInternalRepresentationsKHR( + const PipelineExecutableInfoKHR & executableInfo, + PipelineExecutableInternalRepresentationKHRAllocator const & pipelineExecutableInternalRepresentationKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_host_image_copy === + + // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + copyMemoryToImageEXT( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + copyImageToMemoryEXT( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyImageToImageEXT( const CopyImageToImageInfo * pCopyImageToImageInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + copyImageToImageEXT( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT( uint32_t transitionCount, + const HostImageLayoutTransitionInfo * pTransitions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + transitionImageLayoutEXT( ArrayProxy const & transitions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSubresourceLayout2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html + template ::type = true> + void getImageSubresourceLayout2EXT( Image image, + const ImageSubresource2 * pSubresource, + SubresourceLayout2 * pLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSubresourceLayout2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html + template ::type = true> + VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2EXT( + Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetImageSubresourceLayout2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain getImageSubresourceLayout2EXT( + Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_map_memory2 === + + // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result mapMemory2KHR( const MemoryMapInfo * pMemoryMapInfo, + void ** ppData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type mapMemory2KHR( const MemoryMapInfo & memoryMapInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result unmapMemory2KHR( const MemoryUnmapInfo * pMemoryUnmapInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_swapchain_maintenance1 === + + // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_device_generated_commands === + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html + template ::type = true> + void getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV( + const GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + IndirectCommandsLayoutNV * pIndirectCommandsLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html + template ::type = true> + void destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html + template ::type = true> + void destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html + template ::type = true> + void destroy( IndirectCommandsLayoutNV indirectCommandsLayout, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html + template ::type = true> + void destroy( IndirectCommandsLayoutNV indirectCommandsLayout, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_private_data === + + // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + PrivateDataSlot * pPrivateDataSlot, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createPrivateDataSlotEXTUnique( const PrivateDataSlotCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html + template ::type = true> + void destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html + template ::type = true> + void destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setPrivateDataEXT( ObjectType objectType, + uint64_t objectHandle, + PrivateDataSlot privateDataSlot, + uint64_t data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setPrivateDataEXT( ObjectType objectType, + uint64_t objectHandle, + PrivateDataSlot privateDataSlot, + uint64_t data, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html + template ::type = true> + void getPrivateDataEXT( ObjectType objectType, + uint64_t objectHandle, + PrivateDataSlot privateDataSlot, + uint64_t * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( ObjectType objectType, + uint64_t objectHandle, + PrivateDataSlot privateDataSlot, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_video_encode_queue === + + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, + VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, + size_t * pDataSize, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>>::type + getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>>::type + getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Uint8_tAllocator const & uint8_tAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type + getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type + getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, + Uint8_tAllocator const & uint8_tAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + + // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createCudaModuleNV( const CudaModuleCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + CudaModuleNV * pModule, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createCudaModuleNV( const CudaModuleCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createCudaModuleNVUnique( const CudaModuleCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getCudaModuleCacheNV( CudaModuleNV module, + size_t * pCacheSize, + void * pCacheData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCudaModuleCacheNV( CudaModuleNV module, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCudaModuleCacheNV( CudaModuleNV module, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createCudaFunctionNV( const CudaFunctionCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + CudaFunctionNV * pFunction, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createCudaFunctionNV( const CudaFunctionCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createCudaFunctionNVUnique( const CudaFunctionCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html + template ::type = true> + void destroyCudaModuleNV( CudaModuleNV module, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html + template ::type = true> + void destroyCudaModuleNV( CudaModuleNV module, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html + template ::type = true> + void destroy( CudaModuleNV module, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html + template ::type = true> + void destroy( CudaModuleNV module, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html + template ::type = true> + void destroyCudaFunctionNV( CudaFunctionNV function, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html + template ::type = true> + void destroyCudaFunctionNV( CudaFunctionNV function, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html + template ::type = true> + void destroy( CudaFunctionNV function, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html + template ::type = true> + void destroy( CudaFunctionNV function, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + + // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html + template ::type = true> + void exportMetalObjectsEXT( ExportMetalObjectsInfoEXT * pMetalObjectsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html + template ::type = true> + void exportMetalObjectsEXT( ExportMetalObjectsInfoEXT & metalObjectsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_descriptor_buffer === + + // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html + template ::type = true> + void getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout, + DeviceSize * pLayoutSizeInBytes, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD DeviceSize getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html + template ::type = true> + void getDescriptorSetLayoutBindingOffsetEXT( DescriptorSetLayout layout, + uint32_t binding, + DeviceSize * pOffset, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD DeviceSize getDescriptorSetLayoutBindingOffsetEXT( + DescriptorSetLayout layout, uint32_t binding, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html + template ::type = true> + void getDescriptorEXT( const DescriptorGetInfoEXT * pDescriptorInfo, + size_t dataSize, + void * pDescriptor, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html + template ::type = true> + void getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, + size_t dataSize, + void * pDescriptor, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getBufferOpaqueCaptureDescriptorDataEXT( + const BufferCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT * pInfo, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT * pInfo, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSamplerOpaqueCaptureDescriptorDataEXT( + const SamplerCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_device_fault === + + // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts, + DeviceFaultInfoEXT * pFaultInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + + // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, + zx_handle_t * pZirconHandle, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType, + zx_handle_t zirconHandle, + MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryZirconHandlePropertiesFUCHSIA( + ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + + // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, + zx_handle_t * pZirconHandle, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + // wrapper function for command vkCreateBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const BufferCollectionCreateInfoFUCHSIA * pCreateInfo, + const AllocationCallbacks * pAllocator, + BufferCollectionFUCHSIA * pCollection, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createBufferCollectionFUCHSIA( const BufferCollectionCreateInfoFUCHSIA & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createBufferCollectionFUCHSIAUnique( const BufferCollectionCreateInfoFUCHSIA & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + setBufferCollectionImageConstraintsFUCHSIA( BufferCollectionFUCHSIA collection, + const ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setBufferCollectionImageConstraintsFUCHSIA( BufferCollectionFUCHSIA collection, + const ImageConstraintsInfoFUCHSIA & imageConstraintsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + setBufferCollectionBufferConstraintsFUCHSIA( BufferCollectionFUCHSIA collection, + const BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setBufferCollectionBufferConstraintsFUCHSIA( BufferCollectionFUCHSIA collection, + const BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html + template ::type = true> + void destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html + template ::type = true> + void destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html + template ::type = true> + void destroy( BufferCollectionFUCHSIA collection, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html + template ::type = true> + void destroy( BufferCollectionFUCHSIA collection, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection, + BufferCollectionPropertiesFUCHSIA * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + + // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI( + RenderPass renderpass, Extent2D * pMaxWorkgroupSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getSubpassShadingMaxWorkgroupSizeHUAWEI( RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_external_memory_rdma === + + // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, + RemoteAddressNV * pAddress, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_pipeline_properties === + + // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const PipelineInfoEXT * pPipelineInfo, + BaseOutStructure * pPipelineProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getPipelinePropertiesEXT( const PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_opacity_micromap === + + // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createMicromapEXT( const MicromapCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + MicromapEXT * pMicromap, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createMicromapEXT( const MicromapCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createMicromapEXTUnique( const MicromapCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html + template ::type = true> + void destroyMicromapEXT( MicromapEXT micromap, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html + template ::type = true> + void destroyMicromapEXT( MicromapEXT micromap VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html + template ::type = true> + void destroy( MicromapEXT micromap, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html + template ::type = true> + void destroy( MicromapEXT micromap, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result buildMicromapsEXT( DeferredOperationKHR deferredOperation, + uint32_t infoCount, + const MicromapBuildInfoEXT * pInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result buildMicromapsEXT( DeferredOperationKHR deferredOperation, + ArrayProxy const & infos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyMicromapEXT( DeferredOperationKHR deferredOperation, + const CopyMicromapInfoEXT * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyMicromapEXT( DeferredOperationKHR deferredOperation, + const CopyMicromapInfoEXT & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation, + const CopyMicromapToMemoryInfoEXT * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation, + const CopyMicromapToMemoryInfoEXT & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation, + const CopyMemoryToMicromapInfoEXT * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation, + const CopyMemoryToMicromapInfoEXT & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t micromapCount, + const MicromapEXT * pMicromaps, + QueryType queryType, + size_t dataSize, + void * pData, + size_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + writeMicromapsPropertiesEXT( ArrayProxy const & micromaps, + QueryType queryType, + size_t dataSize, + size_t stride, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type writeMicromapsPropertyEXT( + ArrayProxy const & micromaps, QueryType queryType, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html + template ::type = true> + void getMicromapCompatibilityEXT( const MicromapVersionInfoEXT * pVersionInfo, + AccelerationStructureCompatibilityKHR * pCompatibility, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR getMicromapCompatibilityEXT( + const MicromapVersionInfoEXT & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html + template ::type = true> + void getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, + const MicromapBuildInfoEXT * pBuildInfo, + MicromapBuildSizesInfoEXT * pSizeInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD MicromapBuildSizesInfoEXT + getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, + const MicromapBuildInfoEXT & buildInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_pageable_device_local_memory === + + // wrapper function for command vkSetDeviceMemoryPriorityEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html + template ::type = true> + void setMemoryPriorityEXT( DeviceMemory memory, float priority, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_maintenance4 === + + // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html + template ::type = true> + void getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirementsKHR( + const DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html + template ::type = true> + void getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirementsKHR( + const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html + template ::type = true> + void getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo, + uint32_t * pSparseMemoryRequirementCount, + SparseImageMemoryRequirements2 * pSparseMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html + template < + typename SparseImageMemoryRequirements2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html + template < + typename SparseImageMemoryRequirements2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, + SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VALVE_descriptor_set_host_mapping === + + // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html + template ::type = true> + void getDescriptorSetLayoutHostMappingInfoVALVE( const DescriptorSetBindingReferenceVALVE * pBindingReference, + DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html + template ::type = true> + VULKAN_HPP_NODISCARD DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE( + const DescriptorSetBindingReferenceVALVE & bindingReference, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html + template ::type = true> + void getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet, + void ** ppData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html + template ::type = true> + VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_device_generated_commands_compute === + + // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html + template ::type = true> + void getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo * pCreateInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getPipelineIndirectMemoryRequirementsNV( + const ComputePipelineCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html + template ::type = true> + DeviceAddress getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html + template ::type = true> + DeviceAddress getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer * buffer, + NativeBufferPropertiesOHOS * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS * pInfo, + struct OH_NativeBuffer ** pBuffer, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_ARM_tensors === + + // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createTensorARM( const TensorCreateInfoARM * pCreateInfo, + const AllocationCallbacks * pAllocator, + TensorARM * pTensor, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createTensorARM( const TensorCreateInfoARM & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createTensorARMUnique( const TensorCreateInfoARM & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html + template ::type = true> + void destroyTensorARM( TensorARM tensor, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html + template ::type = true> + void destroyTensorARM( TensorARM tensor VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html + template ::type = true> + void destroy( TensorARM tensor, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html + template ::type = true> + void destroy( TensorARM tensor, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createTensorViewARM( const TensorViewCreateInfoARM * pCreateInfo, + const AllocationCallbacks * pAllocator, + TensorViewARM * pView, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createTensorViewARM( const TensorViewCreateInfoARM & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createTensorViewARMUnique( const TensorViewCreateInfoARM & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html + template ::type = true> + void destroyTensorViewARM( TensorViewARM tensorView, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html + template ::type = true> + void destroyTensorViewARM( TensorViewARM tensorView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html + template ::type = true> + void destroy( TensorViewARM tensorView, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html + template ::type = true> + void destroy( TensorViewARM tensorView, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html + template ::type = true> + void getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM( + const TensorMemoryRequirementsInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindTensorMemoryARM( uint32_t bindInfoCount, + const BindTensorMemoryInfoARM * pBindInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindTensorMemoryARM( ArrayProxy const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html + template ::type = true> + void getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM( + const DeviceTensorMemoryRequirementsARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getTensorOpaqueCaptureDescriptorDataARM( + const TensorCaptureDescriptorDataInfoARM * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM * pInfo, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_shader_module_identifier === + + // wrapper function for command vkGetShaderModuleIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html + template ::type = true> + void getShaderModuleIdentifierEXT( ShaderModule shaderModule, + ShaderModuleIdentifierEXT * pIdentifier, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetShaderModuleIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT + getShaderModuleIdentifierEXT( ShaderModule shaderModule, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html + template ::type = true> + void getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo * pCreateInfo, + ShaderModuleIdentifierEXT * pIdentifier, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT getShaderModuleCreateInfoIdentifierEXT( + const ShaderModuleCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_optical_flow === + + // wrapper function for command vkCreateOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const OpticalFlowSessionCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + OpticalFlowSessionNV * pSession, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createOpticalFlowSessionNV( const OpticalFlowSessionCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createOpticalFlowSessionNVUnique( const OpticalFlowSessionCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html + template ::type = true> + void destroyOpticalFlowSessionNV( OpticalFlowSessionNV session, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html + template ::type = true> + void destroyOpticalFlowSessionNV( OpticalFlowSessionNV session, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html + template ::type = true> + void destroy( OpticalFlowSessionNV session, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html + template ::type = true> + void destroy( OpticalFlowSessionNV session, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindOpticalFlowSessionImageNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( OpticalFlowSessionNV session, + OpticalFlowSessionBindingPointNV bindingPoint, + ImageView view, + ImageLayout layout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkBindOpticalFlowSessionImageNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindOpticalFlowSessionImageNV( OpticalFlowSessionNV session, + OpticalFlowSessionBindingPointNV bindingPoint, + ImageView view, + ImageLayout layout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + //=== VK_KHR_maintenance5 === + + // wrapper function for command vkGetRenderingAreaGranularityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html + template ::type = true> + void getRenderingAreaGranularityKHR( const RenderingAreaInfo * pRenderingAreaInfo, + Extent2D * pGranularity, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRenderingAreaGranularityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularityKHR( const RenderingAreaInfo & renderingAreaInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html + template ::type = true> + void getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo * pInfo, + SubresourceLayout2 * pLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayoutKHR( + const DeviceImageSubresourceInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetImageSubresourceLayout2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html + template ::type = true> + void getImageSubresourceLayout2KHR( Image image, + const ImageSubresource2 * pSubresource, + SubresourceLayout2 * pLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetImageSubresourceLayout2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2KHR( + Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetImageSubresourceLayout2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain getImageSubresourceLayout2KHR( + Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_AMD_anti_lag === + + // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html + template ::type = true> + void antiLagUpdateAMD( const AntiLagDataAMD * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html + template ::type = true> + void antiLagUpdateAMD( const AntiLagDataAMD & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_present_wait2 === + + // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result waitForPresent2KHR( SwapchainKHR swapchain, + const PresentWait2InfoKHR * pPresentWait2Info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result waitForPresent2KHR( SwapchainKHR swapchain, + const PresentWait2InfoKHR & presentWait2Info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_shader_object === + + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t createInfoCount, + const ShaderCreateInfoEXT * pCreateInfos, + const AllocationCallbacks * pAllocator, + ShaderEXT * pShaders, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createShadersEXT( ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createShadersEXT( ArrayProxy const & createInfos, + Optional allocator, + ShaderEXTAllocator const & shaderEXTAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue createShaderEXT( const ShaderCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, ShaderEXTAllocator>> + createShadersEXTUnique( ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, ShaderEXTAllocator>> + createShadersEXTUnique( ArrayProxy const & createInfos, + Optional allocator, + ShaderEXTAllocator const & shaderEXTAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createShaderEXTUnique( const ShaderCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html + template ::type = true> + void destroyShaderEXT( ShaderEXT shader, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html + template ::type = true> + void destroyShaderEXT( ShaderEXT shader VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html + template ::type = true> + void destroy( ShaderEXT shader, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html + template ::type = true> + void destroy( ShaderEXT shader, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( ShaderEXT shader, + size_t * pDataSize, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getShaderBinaryDataEXT( ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getShaderBinaryDataEXT( ShaderEXT shader, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_pipeline_binary === + + // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + PipelineBinaryHandlesInfoKHR * pBinaries, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo, + Optional allocator, + PipelineBinaryKHRAllocator const & pipelineBinaryKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + template < + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename PipelineBinaryKHRAllocator = std::allocator>, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineBinaryKHRAllocator>> + createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + template < + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename PipelineBinaryKHRAllocator = std::allocator>, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineBinaryKHRAllocator>> + createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo, + Optional allocator, + PipelineBinaryKHRAllocator const & pipelineBinaryKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html + template ::type = true> + void destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html + template ::type = true> + void destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html + template ::type = true> + void destroy( PipelineBinaryKHR pipelineBinary, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html + template ::type = true> + void destroy( PipelineBinaryKHR pipelineBinary, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getPipelineKeyKHR( const PipelineCreateInfoKHR * pPipelineCreateInfo, + PipelineBinaryKeyKHR * pPipelineKey, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getPipelineKeyKHR( Optional pipelineCreateInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR * pInfo, + PipelineBinaryKeyKHR * pPipelineBinaryKey, + size_t * pPipelineBinaryDataSize, + void * pPipelineBinaryData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>>::type + getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>>::type getPipelineBinaryDataKHR( + const PipelineBinaryDataInfoKHR & info, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkReleaseCapturedPipelineDataKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR * pInfo, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleaseCapturedPipelineDataKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR & info, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_QCOM_tile_properties === + + // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, + uint32_t * pPropertiesCount, + TilePropertiesQCOM * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, + TilePropertiesQCOMAllocator const & tilePropertiesQCOMAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDynamicRenderingTilePropertiesQCOM( const RenderingInfo * pRenderingInfo, + TilePropertiesQCOM * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_swapchain_maintenance1 === + + // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_cooperative_vector === + + // wrapper function for command vkConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV * pInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_low_latency2 === + + // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( SwapchainKHR swapchain, + const LatencySleepModeInfoNV * pSleepModeInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setLatencySleepModeNV( + SwapchainKHR swapchain, const LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result latencySleepNV( SwapchainKHR swapchain, + const LatencySleepInfoNV * pSleepInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + latencySleepNV( SwapchainKHR swapchain, const LatencySleepInfoNV & sleepInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html + template ::type = true> + void setLatencyMarkerNV( SwapchainKHR swapchain, + const SetLatencyMarkerInfoNV * pLatencyMarkerInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html + template ::type = true> + void setLatencyMarkerNV( SwapchainKHR swapchain, + const SetLatencyMarkerInfoNV & latencyMarkerInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html + template ::type = true> + void getLatencyTimingsNV( SwapchainKHR swapchain, + GetLatencyMarkerInfoNV * pLatencyMarkerInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html + template < + typename LatencyTimingsFrameReportNVAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getLatencyTimingsNV( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html + template < + typename LatencyTimingsFrameReportNVAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getLatencyTimingsNV( SwapchainKHR swapchain, + LatencyTimingsFrameReportNVAllocator const & latencyTimingsFrameReportNVAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_ARM_data_graph === + + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + uint32_t createInfoCount, + const DataGraphPipelineCreateInfoARM * pCreateInfos, + const AllocationCallbacks * pAllocator, + Pipeline * pPipelines, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue + createDataGraphPipelineARM( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + const DataGraphPipelineCreateInfoARM & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template >, + typename std::enable_if>::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> + createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + ArrayProxy const & createInfos, + Optional allocator, + PipelineAllocator const & pipelineAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + template ::type = true> + VULKAN_HPP_NODISCARD ResultValue> + createDataGraphPipelineARMUnique( DeferredOperationKHR deferredOperation, + PipelineCache pipelineCache, + const DataGraphPipelineCreateInfoARM & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDataGraphPipelineSessionARM( const DataGraphPipelineSessionCreateInfoARM * pCreateInfo, + const AllocationCallbacks * pAllocator, + DataGraphPipelineSessionARM * pSession, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDataGraphPipelineSessionARM( const DataGraphPipelineSessionCreateInfoARM & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDataGraphPipelineSessionARMUnique( const DataGraphPipelineSessionCreateInfoARM & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM * pInfo, + uint32_t * pBindPointRequirementCount, + DataGraphPipelineSessionBindPointRequirementARM * pBindPointRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getDataGraphPipelineSessionBindPointRequirementsARM( + const DataGraphPipelineSessionBindPointRequirementsInfoARM & info, + DataGraphPipelineSessionBindPointRequirementARMAllocator const & dataGraphPipelineSessionBindPointRequirementARMAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html + template ::type = true> + void getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getDataGraphPipelineSessionMemoryRequirementsARM( + const DataGraphPipelineSessionMemoryRequirementsInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result bindDataGraphPipelineSessionMemoryARM( uint32_t bindInfoCount, + const BindDataGraphPipelineSessionMemoryInfoARM * pBindInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + bindDataGraphPipelineSessionMemoryARM( ArrayProxy const & bindInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html + template ::type = true> + void destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html + template ::type = true> + void destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html + template ::type = true> + void destroy( DataGraphPipelineSessionARM session, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html + template ::type = true> + void destroy( DataGraphPipelineSessionARM session, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, + uint32_t * pPropertiesCount, + DataGraphPipelinePropertyARM * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html + template < + typename DataGraphPipelinePropertyARMAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html + template < + typename DataGraphPipelinePropertyARMAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo, + DataGraphPipelinePropertyARMAllocator const & dataGraphPipelinePropertyARMAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDataGraphPipelinePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelinePropertiesARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDataGraphPipelinePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, + uint32_t propertiesCount, + DataGraphPipelinePropertyQueryResultARM * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer, + ScreenBufferPropertiesQNX * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_KHR_calibrated_timestamps === + + // wrapper function for command vkGetCalibratedTimestampsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR( uint32_t timestampCount, + const CalibratedTimestampInfoKHR * pTimestampInfos, + uint64_t * pTimestamps, + uint64_t * pMaxDeviation, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetCalibratedTimestampsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type + getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetCalibratedTimestampsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type + getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos, + Uint64_tAllocator const & uint64_tAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetCalibratedTimestampsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCalibratedTimestampKHR( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createExternalComputeQueueNV( const ExternalComputeQueueCreateInfoNV * pCreateInfo, + const AllocationCallbacks * pAllocator, + ExternalComputeQueueNV * pExternalQueue, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createExternalComputeQueueNV( const ExternalComputeQueueCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createExternalComputeQueueNVUnique( const ExternalComputeQueueCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template ::type = true> + void destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template ::type = true> + void destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template ::type = true> + void destroy( ExternalComputeQueueNV externalQueue, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template ::type = true> + void destroy( ExternalComputeQueueNV externalQueue, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_cluster_acceleration_structure === + + // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html + template ::type = true> + void getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV * pInfo, + AccelerationStructureBuildSizesInfoKHR * pSizeInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR getClusterAccelerationStructureBuildSizesNV( + const ClusterAccelerationStructureInputInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_partitioned_acceleration_structure === + + // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html + template ::type = true> + void getPartitionedAccelerationStructuresBuildSizesNV( const PartitionedAccelerationStructureInstancesInputNV * pInfo, + AccelerationStructureBuildSizesInfoKHR * pSizeInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR getPartitionedAccelerationStructuresBuildSizesNV( + const PartitionedAccelerationStructureInstancesInputNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_device_generated_commands === + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html + template ::type = true> + void getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT * pInfo, + MemoryRequirements2 * pMemoryRequirements, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD MemoryRequirements2 getGeneratedCommandsMemoryRequirementsEXT( + const GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutEXT( const IndirectCommandsLayoutCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + IndirectCommandsLayoutEXT * pIndirectCommandsLayout, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createIndirectCommandsLayoutEXT( const IndirectCommandsLayoutCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createIndirectCommandsLayoutEXTUnique( const IndirectCommandsLayoutCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html + template ::type = true> + void destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html + template ::type = true> + void destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html + template ::type = true> + void destroy( IndirectCommandsLayoutEXT indirectCommandsLayout, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html + template ::type = true> + void destroy( IndirectCommandsLayoutEXT indirectCommandsLayout, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createIndirectExecutionSetEXT( const IndirectExecutionSetCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + IndirectExecutionSetEXT * pIndirectExecutionSet, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createIndirectExecutionSetEXT( const IndirectExecutionSetCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createIndirectExecutionSetEXTUnique( const IndirectExecutionSetCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html + template ::type = true> + void destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html + template ::type = true> + void destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html + template ::type = true> + void destroy( IndirectExecutionSetEXT indirectExecutionSet, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html + template ::type = true> + void destroy( IndirectExecutionSetEXT indirectExecutionSet, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html + template ::type = true> + void updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const WriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html + template ::type = true> + void updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet, + ArrayProxy const & executionSetWrites, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html + template ::type = true> + void updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const WriteIndirectExecutionSetShaderEXT * pExecutionSetWrites, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html + template ::type = true> + void updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet, + ArrayProxy const & executionSetWrites, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + + // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo, + void ** pHandle, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT & getMetalHandleInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, + const void * pHandle, + MemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryMetalHandlePropertiesEXT( + ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + operator VkDevice() const VULKAN_HPP_NOEXCEPT + { + return m_device; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_device != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_device == VK_NULL_HANDLE; + } + + private: + VkDevice m_device = {}; + }; + + template <> + struct CppType + { + using Type = Device; + }; + + template <> + struct CppType + { + using Type = Device; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Device; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeKHR.html + class DisplayModeKHR + { + public: + using CType = VkDisplayModeKHR; + using NativeType = VkDisplayModeKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayModeKHR; + + public: + DisplayModeKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + DisplayModeKHR( DisplayModeKHR const & rhs ) = default; + DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + DisplayModeKHR( DisplayModeKHR && rhs ) = default; + DisplayModeKHR & operator=( DisplayModeKHR && rhs ) = default; +#else + DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( exchange( rhs.m_displayModeKHR, {} ) ) {} + + DisplayModeKHR & operator=( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + m_displayModeKHR = exchange( rhs.m_displayModeKHR, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {} + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) + DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT + { + m_displayModeKHR = displayModeKHR; + return *this; + } +#endif + + DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_displayModeKHR = {}; + return *this; + } + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT + { + return m_displayModeKHR; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_displayModeKHR != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_displayModeKHR == VK_NULL_HANDLE; + } + + private: + VkDisplayModeKHR m_displayModeKHR = {}; + }; + + template <> + struct CppType + { + using Type = DisplayModeKHR; + }; + + template <> + struct CppType + { + using Type = DisplayModeKHR; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = DisplayModeKHR; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPhysicalDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice.html + class PhysicalDevice + { + public: + using CType = VkPhysicalDevice; + using NativeType = VkPhysicalDevice; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePhysicalDevice; + + public: + PhysicalDevice() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + PhysicalDevice( PhysicalDevice const & rhs ) = default; + PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + PhysicalDevice( PhysicalDevice && rhs ) = default; + PhysicalDevice & operator=( PhysicalDevice && rhs ) = default; +#else + PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( exchange( rhs.m_physicalDevice, {} ) ) {} + + PhysicalDevice & operator=( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT + { + m_physicalDevice = exchange( rhs.m_physicalDevice, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {} + + PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT + { + m_physicalDevice = physicalDevice; + return *this; + } + + PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_physicalDevice = {}; + return *this; + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html + template ::type = true> + void getFeatures( PhysicalDeviceFeatures * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html + template ::type = true> + VULKAN_HPP_NODISCARD PhysicalDeviceFeatures getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html + template ::type = true> + void getFormatProperties( Format format, + FormatProperties * pFormatProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD FormatProperties getFormatProperties( Format format, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getImageFormatProperties( Format format, + ImageType type, + ImageTiling tiling, + ImageUsageFlags usage, + ImageCreateFlags flags, + ImageFormatProperties * pImageFormatProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageFormatProperties( Format format, + ImageType type, + ImageTiling tiling, + ImageUsageFlags usage, + ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html + template ::type = true> + void getProperties( PhysicalDeviceProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD PhysicalDeviceProperties getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html + template ::type = true> + void getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount, + QueueFamilyProperties * pQueueFamilyProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getQueueFamilyProperties( QueueFamilyPropertiesAllocator const & queueFamilyPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html + template ::type = true> + void getMemoryProperties( PhysicalDeviceMemoryProperties * pMemoryProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties + getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDevice( const DeviceCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Device * pDevice, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDevice( const DeviceCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDeviceUnique( const DeviceCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkEnumerateDeviceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( const char * pLayerName, + uint32_t * pPropertyCount, + ExtensionProperties * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumerateDeviceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateDeviceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkEnumerateDeviceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateDeviceExtensionProperties( Optional layerName, + ExtensionPropertiesAllocator const & extensionPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkEnumerateDeviceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t * pPropertyCount, + LayerProperties * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumerateDeviceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkEnumerateDeviceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateDeviceLayerProperties( LayerPropertiesAllocator const & layerPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html + template ::type = true> + void getSparseImageFormatProperties( Format format, + ImageType type, + SampleCountFlagBits samples, + ImageUsageFlags usage, + ImageTiling tiling, + uint32_t * pPropertyCount, + SparseImageFormatProperties * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html + template < + typename SparseImageFormatPropertiesAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getSparseImageFormatProperties( Format format, + ImageType type, + SampleCountFlagBits samples, + ImageUsageFlags usage, + ImageTiling tiling, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html + template < + typename SparseImageFormatPropertiesAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getSparseImageFormatProperties( Format format, + ImageType type, + SampleCountFlagBits samples, + ImageUsageFlags usage, + ImageTiling tiling, + SparseImageFormatPropertiesAllocator const & sparseImageFormatPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkGetPhysicalDeviceFeatures2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html + template ::type = true> + void getFeatures2( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFeatures2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html + template ::type = true> + VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetPhysicalDeviceFeatures2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html + template ::type = true> + void getProperties2( PhysicalDeviceProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html + template ::type = true> + VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetPhysicalDeviceProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html + template ::type = true> + void getFormatProperties2( Format format, + FormatProperties2 * pFormatProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html + template ::type = true> + VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2( Format format, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getFormatProperties2( Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, + ImageFormatProperties2 * pImageFormatProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template ::type = true> + void getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount, + QueueFamilyProperties2 * pQueueFamilyProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getQueueFamilyProperties2( QueueFamilyProperties2Allocator const & queueFamilyProperties2Allocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html + template ::type = true> + void getMemoryProperties2( PhysicalDeviceMemoryProperties2 * pMemoryProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html + template ::type = true> + VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2 + getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html + template ::type = true> + void getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, + uint32_t * pPropertyCount, + SparseImageFormatProperties2 * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html + template < + typename SparseImageFormatProperties2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html + template < + typename SparseImageFormatProperties2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, + SparseImageFormatProperties2Allocator const & sparseImageFormatProperties2Allocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html + template ::type = true> + void getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, + ExternalBufferProperties * pExternalBufferProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD ExternalBufferProperties getExternalBufferProperties( + const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html + template ::type = true> + void getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, + ExternalFenceProperties * pExternalFenceProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD ExternalFenceProperties getExternalFenceProperties( + const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html + template ::type = true> + void getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, + ExternalSemaphoreProperties * pExternalSemaphoreProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD ExternalSemaphoreProperties + getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_3 === + + // wrapper function for command vkGetPhysicalDeviceToolProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t * pToolCount, + PhysicalDeviceToolProperties * pToolProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceToolProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html + template < + typename PhysicalDeviceToolPropertiesAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceToolProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html + template < + typename PhysicalDeviceToolPropertiesAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getToolProperties( PhysicalDeviceToolPropertiesAllocator const & physicalDeviceToolPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_surface === + + // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, + SurfaceKHR surface, + Bool32 * pSupported, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, + SurfaceCapabilitiesKHR * pSurfaceCapabilities, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( SurfaceKHR surface, + uint32_t * pSurfaceFormatCount, + SurfaceFormatKHR * pSurfaceFormats, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfaceFormatsKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfaceFormatsKHR( + SurfaceKHR surface, SurfaceFormatKHRAllocator const & surfaceFormatKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( SurfaceKHR surface, + uint32_t * pPresentModeCount, + PresentModeKHR * pPresentModes, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfacePresentModesKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfacePresentModesKHR( + SurfaceKHR surface, PresentModeKHRAllocator const & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_swapchain === + + // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( SurfaceKHR surface, + uint32_t * pRectCount, + Rect2D * pRects, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getPresentRectanglesKHR( SurfaceKHR surface, Rect2DAllocator const & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_display === + + // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t * pPropertyCount, + DisplayPropertiesKHR * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator const & displayPropertiesKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount, + DisplayPlanePropertiesKHR * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator const & displayPlanePropertiesKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, + uint32_t * pDisplayCount, + DisplayKHR * pDisplays, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlaneSupportedDisplaysKHR( + uint32_t planeIndex, DisplayKHRAllocator const & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDisplayModePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( DisplayKHR display, + uint32_t * pPropertyCount, + DisplayModePropertiesKHR * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDisplayModePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetDisplayModePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayModePropertiesKHR( DisplayKHR display, + DisplayModePropertiesKHRAllocator const & displayModePropertiesKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDisplayModeKHR( DisplayKHR display, + const DisplayModeCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + DisplayModeKHR * pMode, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDisplayModeKHR( DisplayKHR display, + const DisplayModeCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDisplayModeKHRUnique( DisplayKHR display, + const DisplayModeCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, + uint32_t planeIndex, + DisplayPlaneCapabilitiesKHR * pCapabilities, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html + template ::type = true> + Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, + Display * dpy, + VisualID visualID, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html + template ::type = true> + Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, + Display & dpy, + VisualID visualID, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html + template ::type = true> + Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, + xcb_connection_t * connection, + xcb_visualid_t visual_id, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html + template ::type = true> + Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, + xcb_connection_t & connection, + xcb_visualid_t visual_id, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html + template ::type = true> + Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, + struct wl_display * display, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html + template ::type = true> + Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, + struct wl_display & display, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html + template ::type = true> + Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_video_queue === + + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VideoProfileInfoKHR * pVideoProfile, + VideoCapabilitiesKHR * pCapabilities, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, + uint32_t * pVideoFormatPropertyCount, + VideoFormatPropertiesKHR * pVideoFormatProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, + VideoFormatPropertiesKHRAllocator const & videoFormatPropertiesKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, + StructureChainAllocator & structureChainAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_external_memory_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( Format format, + ImageType type, + ImageTiling tiling, + ImageUsageFlags usage, + ImageCreateFlags flags, + ExternalMemoryHandleTypeFlagsNV externalHandleType, + ExternalImageFormatPropertiesNV * pExternalImageFormatProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getExternalImageFormatPropertiesNV( Format format, + ImageType type, + ImageTiling tiling, + ImageUsageFlags usage, + ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_get_physical_device_properties2 === + + // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html + template ::type = true> + void getFeatures2KHR( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html + template ::type = true> + void getProperties2KHR( PhysicalDeviceProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html + template ::type = true> + void getFormatProperties2KHR( Format format, + FormatProperties2 * pFormatProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2KHR( Format format, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getFormatProperties2KHR( Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, + ImageFormatProperties2 * pImageFormatProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template ::type = true> + void getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount, + QueueFamilyProperties2 * pQueueFamilyProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator const & queueFamilyProperties2Allocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html + template ::type = true> + void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2 * pMemoryProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2 + getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD StructureChain + getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html + template ::type = true> + void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, + uint32_t * pPropertyCount, + SparseImageFormatProperties2 * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html + template < + typename SparseImageFormatProperties2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html + template < + typename SparseImageFormatProperties2Allocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD std::vector + getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, + SparseImageFormatProperties2Allocator const & sparseImageFormatProperties2Allocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_external_memory_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html + template ::type = true> + void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, + ExternalBufferProperties * pExternalBufferProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD ExternalBufferProperties getExternalBufferPropertiesKHR( + const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_external_semaphore_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html + template ::type = true> + void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, + ExternalSemaphoreProperties * pExternalSemaphoreProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD ExternalSemaphoreProperties + getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_direct_mode_display === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + + // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display * dpy, + DisplayKHR display, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + acquireXlibDisplayEXT( Display & dpy, DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display * dpy, + RROutput rrOutput, + DisplayKHR * pDisplay, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( SurfaceKHR surface, + SurfaceCapabilities2EXT * pSurfaceCapabilities, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_external_fence_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html + template ::type = true> + void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, + ExternalFenceProperties * pExternalFenceProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD ExternalFenceProperties getExternalFencePropertiesKHR( + const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_performance_query === + + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, + uint32_t * pCounterCount, + PerformanceCounterKHR * pCounters, + PerformanceCounterDescriptionKHR * pCounterDescriptions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html + template , + typename PerformanceCounterDescriptionKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value && + std::is_same::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, + std::vector>>::type + enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html + template , + typename PerformanceCounterDescriptionKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value && + std::is_same::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, + std::vector>>::type + enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, + PerformanceCounterKHRAllocator const & performanceCounterKHRAllocator, + PerformanceCounterDescriptionKHRAllocator const & performanceCounterDescriptionKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html + template ::type = true> + void getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, + uint32_t * pNumPasses, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD uint32_t + getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_get_surface_capabilities2 === + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + SurfaceCapabilities2KHR * pSurfaceCapabilities, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + uint32_t * pSurfaceFormatCount, + SurfaceFormat2KHR * pSurfaceFormats, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, + SurfaceFormat2KHRAllocator const & surfaceFormat2KHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, + StructureChainAllocator & structureChainAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_get_display_properties2 === + + // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t * pPropertyCount, + DisplayProperties2KHR * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayProperties2KHR( DisplayProperties2KHRAllocator const & displayProperties2KHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount, + DisplayPlaneProperties2KHR * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator const & displayPlaneProperties2KHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( DisplayKHR display, + uint32_t * pPropertyCount, + DisplayModeProperties2KHR * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayModeProperties2KHR( DisplayKHR display, + DisplayModeProperties2KHRAllocator const & displayModeProperties2KHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayModeProperties2KHR( + DisplayKHR display, StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR * pDisplayPlaneInfo, + DisplayPlaneCapabilities2KHR * pCapabilities, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_descriptor_heap === + + // wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html + template ::type = true> + DeviceSize getDescriptorSizeEXT( DescriptorType descriptorType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_sample_locations === + + // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html + template ::type = true> + void getMultisamplePropertiesEXT( SampleCountFlagBits samples, + MultisamplePropertiesEXT * pMultisampleProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD MultisamplePropertiesEXT + getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_calibrated_timestamps === + + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount, + TimeDomainKHR * pTimeDomains, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator const & timeDomainKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_fragment_shading_rate === + + // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount, + PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html + template < + typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html + template < + typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator const & physicalDeviceFragmentShadingRateKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_EXT_tooling_info === + + // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t * pToolCount, + PhysicalDeviceToolProperties * pToolProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html + template < + typename PhysicalDeviceToolPropertiesAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html + template < + typename PhysicalDeviceToolPropertiesAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator const & physicalDeviceToolPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_cooperative_matrix === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount, + CooperativeMatrixPropertiesNV * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html + template < + typename CooperativeMatrixPropertiesNVAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html + template < + typename CooperativeMatrixPropertiesNVAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator const & cooperativeMatrixPropertiesNVAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_coverage_reduction_mode === + + // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t * pCombinationCount, + FramebufferMixedSamplesCombinationNV * pCombinations, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html + template < + typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html + template < + typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator const & framebufferMixedSamplesCombinationNVAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + uint32_t * pPresentModeCount, + PresentModeKHR * pPresentModes, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, + PresentModeKHRAllocator const & presentModeKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_acquire_drm_display === + +#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t drmFd, + DisplayKHR display, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#else + // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + acquireDrmDisplayEXT( int32_t drmFd, DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t drmFd, + uint32_t connectorId, + DisplayKHR * display, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_video_encode_queue === + + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, + VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + +# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( DisplayKHR display, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# else + // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html + template ::type = true> + VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + acquireWinrtDisplayNV( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId, + DisplayKHR * pDisplay, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type getWinrtDisplayNV( uint32_t deviceRelativeId, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html + template ::type = true> + Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, + IDirectFB * dfb, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html + template ::type = true> + Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, + IDirectFB & dfb, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html + template ::type = true> + Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, + struct _screen_window * window, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html + template ::type = true> + Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, + struct _screen_window & window, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_ARM_tensors === + + // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html + template ::type = true> + void getExternalTensorPropertiesARM( const PhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo, + ExternalTensorPropertiesARM * pExternalTensorProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html + template ::type = true> + VULKAN_HPP_NODISCARD ExternalTensorPropertiesARM getExternalTensorPropertiesARM( + const PhysicalDeviceExternalTensorInfoARM & externalTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_optical_flow === + + // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo, + uint32_t * pFormatCount, + OpticalFlowImageFormatPropertiesNV * pImageFormatProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, + OpticalFlowImageFormatPropertiesNVAllocator const & opticalFlowImageFormatPropertiesNVAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_cooperative_vector === + + // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getCooperativeVectorPropertiesNV( uint32_t * pPropertyCount, + CooperativeVectorPropertiesNV * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html + template < + typename CooperativeVectorPropertiesNVAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCooperativeVectorPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html + template < + typename CooperativeVectorPropertiesNVAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCooperativeVectorPropertiesNV( CooperativeVectorPropertiesNVAllocator const & cooperativeVectorPropertiesNVAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_cooperative_matrix === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR( uint32_t * pPropertyCount, + CooperativeMatrixPropertiesKHR * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html + template < + typename CooperativeMatrixPropertiesKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCooperativeMatrixPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html + template < + typename CooperativeMatrixPropertiesKHRAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator const & cooperativeMatrixPropertiesKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_ARM_data_graph === + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, + uint32_t * pQueueFamilyDataGraphPropertyCount, + QueueFamilyDataGraphPropertiesARM * pQueueFamilyDataGraphProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, + QueueFamilyDataGraphPropertiesARMAllocator const & queueFamilyDataGraphPropertiesARMAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html + template ::type = true> + void getQueueFamilyDataGraphProcessingEnginePropertiesARM( + const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM * pQueueFamilyDataGraphProcessingEngineInfo, + QueueFamilyDataGraphProcessingEnginePropertiesARM * pQueueFamilyDataGraphProcessingEngineProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html + template ::type = true> + VULKAN_HPP_NODISCARD QueueFamilyDataGraphProcessingEnginePropertiesARM getQueueFamilyDataGraphProcessingEnginePropertiesARM( + const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & queueFamilyDataGraphProcessingEngineInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_calibrated_timestamps === + + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount, + TimeDomainKHR * pTimeDomains, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCalibrateableTimeDomainsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator const & timeDomainKHRAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_NV_cooperative_matrix2 === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + getCooperativeMatrixFlexibleDimensionsPropertiesNV( uint32_t * pPropertyCount, + CooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getCooperativeMatrixFlexibleDimensionsPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD + typename ResultValueType>::type + getCooperativeMatrixFlexibleDimensionsPropertiesNV( + CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator const & cooperativeMatrixFlexibleDimensionsPropertiesNVAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_ARM_performance_counters_by_region === + + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html + template ::type = true> + VULKAN_HPP_NODISCARD Result + enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, + uint32_t * pCounterCount, + PerformanceCounterARM * pCounters, + PerformanceCounterDescriptionARM * pCounterDescriptions, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html + template , + typename PerformanceCounterDescriptionARMAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value && + std::is_same::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, + std::vector>>::type + enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html + template , + typename PerformanceCounterDescriptionARMAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value && + std::is_same::value, + int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType, + std::vector>>::type + enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, + PerformanceCounterARMAllocator const & performanceCounterARMAllocator, + PerformanceCounterDescriptionARMAllocator const & performanceCounterDescriptionARMAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT + { + return m_physicalDevice; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_physicalDevice != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_physicalDevice == VK_NULL_HANDLE; + } + + private: + VkPhysicalDevice m_physicalDevice = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDevice; + }; + + template <> + struct CppType + { + using Type = PhysicalDevice; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = PhysicalDevice; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstance.html + class Instance + { + public: + using CType = VkInstance; + using NativeType = VkInstance; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eInstance; + + public: + Instance() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + Instance( Instance const & rhs ) = default; + Instance & operator=( Instance const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + Instance( Instance && rhs ) = default; + Instance & operator=( Instance && rhs ) = default; +#else + Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT : m_instance( exchange( rhs.m_instance, {} ) ) {} + + Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT + { + m_instance = exchange( rhs.m_instance, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {} + + Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT + { + m_instance = instance; + return *this; + } + + Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_instance = {}; + return *this; + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html + template ::type = true> + void destroy( const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html + template ::type = true> + void destroy( Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html + template ::type = true> + VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount, + PhysicalDevice * pPhysicalDevices, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumeratePhysicalDevices( PhysicalDeviceAllocator const & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html + template ::type = true> + PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html + template ::type = true> + PFN_VoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkEnumeratePhysicalDeviceGroups, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html + template ::type = true> + VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount, + PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumeratePhysicalDeviceGroups, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html + template < + typename PhysicalDeviceGroupPropertiesAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkEnumeratePhysicalDeviceGroups, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html + template < + typename PhysicalDeviceGroupPropertiesAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator const & physicalDeviceGroupPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_surface === + + // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html + template ::type = true> + void destroySurfaceKHR( SurfaceKHR surface, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html + template ::type = true> + void destroySurfaceKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html + template ::type = true> + void destroy( SurfaceKHR surface, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html + template ::type = true> + void destroy( SurfaceKHR surface, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_KHR_display === + + // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + + // wrapper function for command vkCreateDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + DebugReportCallbackEXT * pCallback, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html + template ::type = true> + void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html + template ::type = true> + void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html + template ::type = true> + void destroy( DebugReportCallbackEXT callback, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html + template ::type = true> + void destroy( DebugReportCallbackEXT callback, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html + template ::type = true> + void debugReportMessageEXT( DebugReportFlagsEXT flags, + DebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char * pLayerPrefix, + const char * pMessage, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html + template ::type = true> + void debugReportMessageEXT( DebugReportFlagsEXT flags, + DebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const std::string & layerPrefix, + const std::string & message, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_GGP*/ + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createViSurfaceNN( const ViSurfaceCreateInfoNN * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_device_group_creation === + + // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html + template ::type = true> + VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount, + PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html + template < + typename PhysicalDeviceGroupPropertiesAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html + template < + typename PhysicalDeviceGroupPropertiesAllocator = std::allocator, + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator const & physicalDeviceGroupPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + + // wrapper function for command vkCreateDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + DebugUtilsMessengerEXT * pMessenger, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html + template ::type = true> + void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html + template ::type = true> + void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html + template ::type = true> + void destroy( DebugUtilsMessengerEXT messenger, + const AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html + template ::type = true> + void destroy( DebugUtilsMessengerEXT messenger, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkSubmitDebugUtilsMessageEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html + template ::type = true> + void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + DebugUtilsMessageTypeFlagsEXT messageTypes, + const DebugUtilsMessengerCallbackDataEXT * pCallbackData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkSubmitDebugUtilsMessageEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html + template ::type = true> + void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + DebugUtilsMessageTypeFlagsEXT messageTypes, + const DebugUtilsMessengerCallbackDataEXT & callbackData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_headless_surface === + + // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + + // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createSurfaceOHOS( const SurfaceCreateInfoOHOS * pCreateInfo, + const AllocationCallbacks * pAllocator, + SurfaceKHR * pSurface, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSurfaceOHOS( const SurfaceCreateInfoOHOS & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createSurfaceOHOSUnique( const SurfaceCreateInfoOHOS & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ +#endif /*VK_USE_PLATFORM_OHOS*/ + + operator VkInstance() const VULKAN_HPP_NOEXCEPT + { + return m_instance; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_instance != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_instance == VK_NULL_HANDLE; + } + + private: + VkInstance m_instance = {}; + }; + + template <> + struct CppType + { + using Type = Instance; + }; + + template <> + struct CppType + { + using Type = Instance; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = Instance; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html + template ::type = true> + VULKAN_HPP_NODISCARD Result createInstance( const InstanceCreateInfo * pCreateInfo, + const AllocationCallbacks * pAllocator, + Instance * pInstance, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type + createInstance( const InstanceCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createInstanceUnique( const InstanceCreateInfo & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkEnumerateInstanceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( const char * pLayerName, + uint32_t * pPropertyCount, + ExtensionProperties * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumerateInstanceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateInstanceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); + // wrapper function for command vkEnumerateInstanceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateInstanceExtensionProperties( Optional layerName, + ExtensionPropertiesAllocator const & extensionPropertiesAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkEnumerateInstanceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html + template ::type = true> + VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount, + LayerProperties * pProperties, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumerateInstanceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); + // wrapper function for command vkEnumerateInstanceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename std::enable_if::value, int>::type = 0, + typename std::enable_if::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateInstanceLayerProperties( LayerPropertiesAllocator const & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html + template ::type = true> + VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t * pApiVersion, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html + template ::type = true> + VULKAN_HPP_NODISCARD typename ResultValueType::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // operators to compare VULKAN_HPP_NAMESPACE::-handles + template ::value, int>::type = 0> + bool operator==( T const & lhs, T const & rhs ) + { + return static_cast( lhs ) == static_cast( rhs ); + } + + template ::value, int>::type = 0> + bool operator!=( T const & lhs, T const & rhs ) + { + return static_cast( lhs ) != static_cast( rhs ); + } + + template ::value, int>::type = 0> + bool operator<( T const & lhs, T const & rhs ) + { + return static_cast( lhs ) < static_cast( rhs ); + } + + template ::value, int>::type = 0> + bool operator<=( T const & lhs, T const & rhs ) + { + return static_cast( lhs ) <= static_cast( rhs ); + } + + template ::value, int>::type = 0> + bool operator>( T const & lhs, T const & rhs ) + { + return static_cast( lhs ) > static_cast( rhs ); + } + + template ::value, int>::type = 0> + bool operator>=( T const & lhs, T const & rhs ) + { + return static_cast( lhs ) >= static_cast( rhs ); + } + + template ::value, int>::type = 0> + bool operator==( T const & v, std::nullptr_t ) + { + return !v; + } + + template ::value, int>::type = 0> + bool operator==( std::nullptr_t, T const & v ) + { + return !v; + } + + template ::value, int>::type = 0> + bool operator!=( T const & v, std::nullptr_t ) + { + return !!v; + } + + template ::value, int>::type = 0> + bool operator!=( std::nullptr_t, T const & v ) + { + return !!v; + } +} // namespace VULKAN_HPP_NAMESPACE +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_hash.hpp b/lib/vulkan-headers/include/vulkan/vulkan_hash.hpp new file mode 100644 index 00000000000..a0992e7a9dc --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_hash.hpp @@ -0,0 +1,21424 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_HASH_HPP +#define VULKAN_HASH_HPP + +#include + +namespace std +{ + //======================================= + //=== HASH structures for Flags types === + //======================================= + + template + struct hash> + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags const & flags ) const VULKAN_HPP_NOEXCEPT + { + return std::hash::type>{}( static_cast::type>( flags ) ); + } + }; + + //=================================== + //=== HASH structures for handles === + //=================================== + + //=== VK_VERSION_1_0 === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( instance ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( physicalDevice ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( device ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( queue ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( deviceMemory ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( fence ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( semaphore ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( queryPool ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( buffer ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( image ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( imageView ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( commandPool ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( commandBuffer ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( event ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( bufferView ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( shaderModule ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( pipelineCache ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( pipeline ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( pipelineLayout ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( sampler ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( descriptorPool ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( descriptorSet ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( descriptorSetLayout ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( framebuffer ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( renderPass ) ); + } + }; + + //=== VK_VERSION_1_1 === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( descriptorUpdateTemplate ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( samplerYcbcrConversion ) ); + } + }; + + //=== VK_VERSION_1_3 === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlot const & privateDataSlot ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( privateDataSlot ) ); + } + }; + + //=== VK_KHR_surface === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( surfaceKHR ) ); + } + }; + + //=== VK_KHR_swapchain === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( swapchainKHR ) ); + } + }; + + //=== VK_KHR_display === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( displayKHR ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( displayModeKHR ) ); + } + }; + + //=== VK_EXT_debug_report === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( debugReportCallbackEXT ) ); + } + }; + + //=== VK_KHR_video_queue === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( videoSessionKHR ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( videoSessionParametersKHR ) ); + } + }; + + //=== VK_NVX_binary_import === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( cuModuleNVX ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( cuFunctionNVX ) ); + } + }; + + //=== VK_EXT_debug_utils === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( debugUtilsMessengerEXT ) ); + } + }; + + //=== VK_EXT_descriptor_heap === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorARM const & tensorARM ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( tensorARM ) ); + } + }; + + //=== VK_KHR_acceleration_structure === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( accelerationStructureKHR ) ); + } + }; + + //=== VK_EXT_validation_cache === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( validationCacheEXT ) ); + } + }; + + //=== VK_NV_ray_tracing === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( accelerationStructureNV ) ); + } + }; + + //=== VK_INTEL_performance_query === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( performanceConfigurationINTEL ) ); + } + }; + + //=== VK_KHR_deferred_host_operations === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( deferredOperationKHR ) ); + } + }; + + //=== VK_NV_device_generated_commands === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( indirectCommandsLayoutNV ) ); + } + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleNV const & cudaModuleNV ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( cudaModuleNV ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionNV const & cudaFunctionNV ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( cudaFunctionNV ) ); + } + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( bufferCollectionFUCHSIA ) ); + } + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapEXT const & micromapEXT ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( micromapEXT ) ); + } + }; + + //=== VK_ARM_tensors === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorViewARM const & tensorViewARM ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( tensorViewARM ) ); + } + }; + + //=== VK_NV_optical_flow === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & opticalFlowSessionNV ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( opticalFlowSessionNV ) ); + } + }; + + //=== VK_EXT_shader_object === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderEXT const & shaderEXT ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( shaderEXT ) ); + } + }; + + //=== VK_KHR_pipeline_binary === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const & pipelineBinaryKHR ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( pipelineBinaryKHR ) ); + } + }; + + //=== VK_ARM_data_graph === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM const & dataGraphPipelineSessionARM ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( dataGraphPipelineSessionARM ) ); + } + }; + + //=== VK_NV_external_compute_queue === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV const & externalComputeQueueNV ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( externalComputeQueueNV ) ); + } + }; + + //=== VK_EXT_device_generated_commands === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT const & indirectCommandsLayoutEXT ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( indirectCommandsLayoutEXT ) ); + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT const & indirectExecutionSetEXT ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( indirectExecutionSetEXT ) ); + } + }; + +#if 14 <= VULKAN_HPP_CPP_VERSION + //====================================== + //=== HASH structures for structures === + //====================================== + +# if !defined( VULKAN_HPP_HASH_COMBINE ) +# define VULKAN_HPP_HASH_COMBINE( seed, value ) \ + seed ^= std::hash::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) +# endif + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minX ); + VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minY ); + VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minZ ); + VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxX ); + VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxY ); + VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxZ ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const & accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveCount ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.firstVertex ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.transformOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const & accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT const & accelerationStructureCaptureDescriptorDataInfoEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructure ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructureNV ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.createFlags ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.buffer ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.offset ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.size ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.type ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.deviceAddress ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexData ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexOffset ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexCount ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexStride ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexFormat ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexData ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexOffset ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexCount ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexType ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformData ); + VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.aabbData ); + VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.numAABBs ); + VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.stride ); + VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.offset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.triangles ); + VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.aabbs ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, geometryNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, geometryNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometryType ); + VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometry ); + VULKAN_HPP_HASH_COMBINE( seed, geometryNV.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.type ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.flags ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.instanceCount ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.geometryCount ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pGeometries ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.compactedSize ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.info ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const & accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.accelerationStructure ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + for ( size_t i = 0; i < 3; ++i ) + { + for ( size_t j = 0; j < 4; ++j ) + { + VULKAN_HPP_HASH_COMBINE( seed, transformMatrixKHR.matrix[i][j] ); + } + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.transform ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceCustomIndex ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.mask ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.accelerationStructureReference ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const & accelerationStructureMatrixMotionInstanceNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT0 ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT1 ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.mask ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.flags ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const & accelerationStructureMemoryRequirementsInfoNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.type ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.accelerationStructure ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const & accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.maxInstances ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sx ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.a ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.b ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvx ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sy ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.c ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvy ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sz ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvz ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qx ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qy ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qz ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qw ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tx ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.ty ); + VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tz ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const & accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT0 ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT1 ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.mask ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.flags ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapUsageEXT const & micromapUsageEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.count ); + VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.subdivisionLevel ); + VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.format ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const & accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pVersionData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.swapchain ); + VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.timeout ); + VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.semaphore ); + VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.fence ); + VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.deviceMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.timeout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pUserData ); + VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnAllocation ); + VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnReallocation ); + VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnFree ); + VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalAllocation ); + VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalFree ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC const & amigoProfilingSubmitInfoSEC ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.sType ); + VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.firstDrawTimestamp ); + VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.swapBufferTimestamp ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, componentMapping.r ); + VULKAN_HPP_HASH_COMBINE( seed, componentMapping.g ); + VULKAN_HPP_HASH_COMBINE( seed, componentMapping.b ); + VULKAN_HPP_HASH_COMBINE( seed, componentMapping.a ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const & androidHardwareBufferFormatProperties2ANDROID ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.sType ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.format ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.formatFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const & androidHardwareBufferFormatPropertiesANDROID ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.sType ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.format ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const & androidHardwareBufferFormatResolvePropertiesANDROID ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.sType ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.colorAttachmentFormat ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const & androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.sType ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.allocationSize ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const & androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.sType ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.window ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD const & antiLagPresentationInfoAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.stage ); + VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.frameIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AntiLagDataAMD const & antiLagDataAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.mode ); + VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.maxFPS ); + VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.pPresentationInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext ); + for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion ); + for ( const char * p = applicationInfo.pEngineName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.engineVersion ); + VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.apiVersion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.flags ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.format ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.samples ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.loadOp ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.storeOp ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilLoadOp ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilStoreOp ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.initialLayout ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.finalLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.flags ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.format ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.samples ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.loadOp ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.storeOp ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilLoadOp ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilStoreOp ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.initialLayout ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.finalLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const & attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.sType ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilInitialLayout ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilFinalLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentFeedbackLoopInfoEXT const & attachmentFeedbackLoopInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, attachmentFeedbackLoopInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentFeedbackLoopInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentFeedbackLoopInfoEXT.feedbackLoopEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.attachment ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.layout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.attachment ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.layout ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.aspectMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.sType ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.stencilLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.colorAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, extent2D.width ); + VULKAN_HPP_HASH_COMBINE( seed, extent2D.height ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.x ); + VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.y ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsPerPixel ); + VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationGridSize ); + VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsCount ); + VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pSampleLocations ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.attachmentIndex ); + VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.sampleLocationsInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.sType ); + VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.pNext ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.sType ); + VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.pNext ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BeginCustomResolveInfoEXT const & beginCustomResolveInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, beginCustomResolveInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, beginCustomResolveInfoEXT.pNext ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const & bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.accelerationStructure ); + VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memory ); + VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memoryOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount ); + VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount ); + VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.buffer ); + VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memory ); + VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memoryOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::BindDataGraphPipelineSessionMemoryInfoARM const & bindDataGraphPipelineSessionMemoryInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.session ); + VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.bindPoint ); + VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.objectIndex ); + VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.memory ); + VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.memoryOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT const & bindDescriptorBufferEmbeddedSamplersInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.stageFlags ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.layout ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.set ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo const & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.stageFlags ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.layout ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.firstSet ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.descriptorSetCount ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pDescriptorSets ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.dynamicOffsetCount ); + VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pDynamicOffsets ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT const & deviceAddressRangeEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceAddressRangeEXT.address ); + VULKAN_HPP_HASH_COMBINE( seed, deviceAddressRangeEXT.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindHeapInfoEXT const & bindHeapInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.heapRange ); + VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.reservedRangeOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.reservedRangeSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, offset2D.x ); + VULKAN_HPP_HASH_COMBINE( seed, offset2D.y ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, rect2D.offset ); + VULKAN_HPP_HASH_COMBINE( seed, rect2D.extent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.image ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memory ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memoryOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.swapchain ); + VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.imageIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.planeAspect ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT const & bindIndexBufferIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.bufferAddress ); + VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.size ); + VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.indexType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.bufferAddress ); + VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.size ); + VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.indexType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindMemoryStatus const & bindMemoryStatus ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.pResult ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV const & bindPipelineIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindPipelineIndirectCommandNV.pipelineAddress ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindShaderGroupIndirectCommandNV.groupIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.resourceOffset ); + VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.size ); + VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memory ); + VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memoryOffset ); + VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.buffer ); + VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.bindCount ); + VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.pBinds ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.image ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.bindCount ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.pBinds ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.aspectMask ); + VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.mipLevel ); + VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.arrayLayer ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, offset3D.x ); + VULKAN_HPP_HASH_COMBINE( seed, offset3D.y ); + VULKAN_HPP_HASH_COMBINE( seed, offset3D.z ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, extent3D.width ); + VULKAN_HPP_HASH_COMBINE( seed, extent3D.height ); + VULKAN_HPP_HASH_COMBINE( seed, extent3D.depth ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.subresource ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.offset ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.extent ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memory ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memoryOffset ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.image ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.bindCount ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.pBinds ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.waitSemaphoreCount ); + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pWaitSemaphores ); + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.bufferBindCount ); + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pBufferBinds ); + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageOpaqueBindCount ); + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageOpaqueBinds ); + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageBindCount ); + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageBinds ); + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.signalSemaphoreCount ); + VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pSignalSemaphores ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindTensorMemoryInfoARM const & bindTensorMemoryInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.tensor ); + VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.memory ); + VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.memoryOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT const & bindVertexBufferIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.bufferAddress ); + VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.size ); + VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.stride ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const & bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.bufferAddress ); + VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.size ); + VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.stride ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR const & bindVideoSessionMemoryInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryBindIndex ); + VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memory ); + VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memorySize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM const & blitImageCubicWeightsInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.cubicWeights ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.aspectMask ); + VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.mipLevel ); + VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.baseArrayLayer ); + VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.layerCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2 const & imageBlit2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcSubresource ); + for ( size_t i = 0; i < 2; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcOffsets[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstSubresource ); + for ( size_t i = 0; i < 2; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstOffsets[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2 const & blitImageInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImage ); + VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImage ); + VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pRegions ); + VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.filter ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT const & bufferCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.buffer ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const & bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.collection ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.index ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.collectionToken ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const & bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.collection ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.index ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.colorSpace ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const & bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.bufferCount ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.formatFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.size ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.usage ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sharingMode ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.queueFamilyIndexCount ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pQueueFamilyIndices ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.createInfo ); + VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.srcOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.dstOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2 const & bufferCopy2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.srcOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.dstOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.deviceAddress ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.buffer ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferRowLength ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferImageHeight ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2 const & bufferImageCopy2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferRowLength ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferImageHeight ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageOffset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.buffer ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.offset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 const & bufferMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.buffer ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.offset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.buffer ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const & bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfo const & bufferUsageFlags2CreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.usage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.buffer ); + VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.format ); + VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.offset ); + VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.range ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV const & stridedDeviceAddressNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressNV.startAddress ); + VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressNV.strideInBytes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV const & + buildPartitionedAccelerationStructureIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureIndirectCommandNV.opType ); + VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureIndirectCommandNV.argCount ); + VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureIndirectCommandNV.argData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV const & partitionedAccelerationStructureInstancesInputNV ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.flags ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.instanceCount ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.maxInstancePerPartitionCount ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.partitionCount ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.maxInstanceInGlobalPartitionCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV const & buildPartitionedAccelerationStructureInfoNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.input ); + VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.srcAccelerationStructureData ); + VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.dstAccelerationStructureData ); + VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.scratchData ); + VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.srcInfos ); + VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.srcInfosCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR const & calibratedTimestampInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.timeDomain ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.stage ); + VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pCheckpointMarker ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.stage ); + VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pCheckpointMarker ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.depth ); + VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.stencil ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clearRect.rect ); + VULKAN_HPP_HASH_COMBINE( seed, clearRect.baseArrayLayer ); + VULKAN_HPP_HASH_COMBINE( seed, clearRect.layerCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & + clusterAccelerationStructureBuildClustersBottomLevelInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildClustersBottomLevelInfoNV.clusterReferencesCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildClustersBottomLevelInfoNV.clusterReferencesStride ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildClustersBottomLevelInfoNV.clusterReferences ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & + clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.geometryIndex ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.reserved ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.geometryFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV const & + clusterAccelerationStructureBuildTriangleClusterInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterID ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterFlags ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.triangleCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.positionTruncateBitCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.indexType ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexType ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.baseGeometryIndexAndGeometryFlags ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBufferStride ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBufferStride ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBufferStride ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBufferStride ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapArray ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBuffer ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & + clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.clusterID ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.clusterFlags ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.triangleCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.vertexCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.positionTruncateBitCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.indexType ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapIndexType ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.baseGeometryIndexAndGeometryFlags ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.indexBufferStride ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.vertexBufferStride ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.geometryIndexAndFlagsBufferStride ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapIndexBufferStride ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.indexBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.vertexBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.geometryIndexAndFlagsBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapArray ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapIndexBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.instantiationBoundingBoxLimit ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV const & + clusterAccelerationStructureClustersBottomLevelInputNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.maxTotalClusterCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.maxClusterCountPerAccelerationStructure ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV const & clusterAccelerationStructureTriangleClusterInputNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.vertexFormat ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxGeometryIndexValue ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxClusterUniqueGeometryCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxClusterTriangleCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxClusterVertexCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxTotalTriangleCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxTotalVertexCount ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.minPositionTruncateBitCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV const & clusterAccelerationStructureMoveObjectsInputNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.type ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.noMoveOverlap ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.maxMovedBytes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.deviceAddress ); + VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.stride ); + VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGetTemplateIndicesInfoNV const & + clusterAccelerationStructureGetTemplateIndicesInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGetTemplateIndicesInfoNV.clusterTemplateAddress ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV const & + clusterAccelerationStructureInstantiateClusterInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.clusterIdOffset ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.geometryIndexOffset ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.reserved ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.clusterTemplateAddress ); + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.vertexBuffer ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV const & clusterAccelerationStructureMoveObjectsInfoNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInfoNV.srcAccelerationStructure ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelX ); + VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelY ); + VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.sample ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.shadingRate ); + VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleCount ); + VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleLocationCount ); + VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.pSampleLocations ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT const & colorBlendAdvancedEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.advancedBlendOp ); + VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.srcPremultiplied ); + VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.dstPremultiplied ); + VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.blendOverlap ); + VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.clampResults ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT const & colorBlendEquationEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcColorBlendFactor ); + VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstColorBlendFactor ); + VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.colorBlendOp ); + VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcAlphaBlendFactor ); + VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstAlphaBlendFactor ); + VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.alphaBlendOp ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandPool ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.level ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandBufferCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.renderPass ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.subpass ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.framebuffer ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.occlusionQueryEnable ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.queryFlags ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pipelineStatistics ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pInheritanceInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const & commandBufferInheritanceConditionalRenderingInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT const & commandBufferInheritanceDescriptorHeapInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.pSamplerHeapBindInfo ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.pResourceHeapBindInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const & commandBufferInheritanceRenderPassTransformInfoQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.transform ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo const & commandBufferInheritanceRenderingInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.viewMask ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.colorAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pColorAttachmentFormats ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.depthAttachmentFormat ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.stencilAttachmentFormat ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.rasterizationSamples ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, viewport.x ); + VULKAN_HPP_HASH_COMBINE( seed, viewport.y ); + VULKAN_HPP_HASH_COMBINE( seed, viewport.width ); + VULKAN_HPP_HASH_COMBINE( seed, viewport.height ); + VULKAN_HPP_HASH_COMBINE( seed, viewport.minDepth ); + VULKAN_HPP_HASH_COMBINE( seed, viewport.maxDepth ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const & commandBufferInheritanceViewportScissorInfoNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo const & commandBufferSubmitInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.commandBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.deviceMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.queueFamilyIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityParametersNV const & computeOccupancyPriorityParametersNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, computeOccupancyPriorityParametersNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, computeOccupancyPriorityParametersNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, computeOccupancyPriorityParametersNV.occupancyPriority ); + VULKAN_HPP_HASH_COMBINE( seed, computeOccupancyPriorityParametersNV.occupancyThrottling ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.constantID ); + VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.offset ); + VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.mapEntryCount ); + VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pMapEntries ); + VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.dataSize ); + VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module ); + for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.stage ); + VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.layout ); + VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineHandle ); + VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV const & computePipelineIndirectBufferInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.deviceAddress ); + VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.size ); + VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pipelineDeviceAddressCaptureReplay ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.buffer ); + VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.offset ); + VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.major ); + VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.minor ); + VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.subminor ); + VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.patch ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV const & cooperativeMatrixFlexibleDimensionsPropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.MGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.NGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.KGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.AType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.BType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.CType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.ResultType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.saturatingAccumulation ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.scope ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.workgroupInvocations ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR const & cooperativeMatrixPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.MSize ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.NSize ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.KSize ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.AType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.BType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.CType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.ResultType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.saturatingAccumulation ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.scope ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.MSize ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.NSize ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.KSize ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.AType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.BType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.CType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.DType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.scope ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV const & cooperativeVectorPropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.inputType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.inputInterpretation ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.matrixInterpretation ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.biasInterpretation ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.resultType ); + VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.transpose ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.src ); + VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.dst ); + VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.mode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 const & copyBufferInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.srcBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.dstBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 const & copyBufferToImageInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.srcBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImage ); + VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.transform ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcSet ); + VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcBinding ); + VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcArrayElement ); + VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstSet ); + VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstBinding ); + VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstArrayElement ); + VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.descriptorCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2 const & imageCopy2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcOffset ); + VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstOffset ); + VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.extent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2 const & copyImageInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImage ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImage ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 const & copyImageToBufferInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImage ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.dstBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToImageInfo const & copyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.srcImage ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.srcImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.dstImage ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.dstImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageToMemoryCopy const & imageToMemoryCopy ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.pHostPointer ); + VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.memoryRowLength ); + VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.memoryImageHeight ); + VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageOffset ); + VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo const & copyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.srcImage ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.srcImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR const & copyMemoryIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.srcAddress ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.dstAddress ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR const & stridedDeviceAddressRangeKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.address ); + VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.size ); + VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.stride ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR const & copyMemoryIndirectInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.srcCopyFlags ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.dstCopyFlags ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.copyCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.copyAddressRange ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR const & copyMemoryToImageIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.srcAddress ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.bufferRowLength ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.bufferImageHeight ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageOffset ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR const & copyMemoryToImageIndirectInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.srcCopyFlags ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.copyCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.copyAddressRange ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.dstImage ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.dstImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.pImageSubresources ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryToImageCopy const & memoryToImageCopy ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.pHostPointer ); + VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.memoryRowLength ); + VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.memoryImageHeight ); + VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageOffset ); + VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo const & copyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.dstImage ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.dstImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT const & copyMicromapInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.src ); + VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.dst ); + VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.mode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorCopyARM const & tensorCopyARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.dimensionCount ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pSrcOffset ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pDstOffset ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyTensorInfoARM const & copyTensorInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.srcTensor ); + VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.dstTensor ); + VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module ); + for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.function ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimX ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimY ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimZ ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimX ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimY ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimZ ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sharedMemBytes ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.paramCount ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pParams ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.extraCount ); + VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pExtras ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.dataSize ); + VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX const & cuModuleTexturingModeCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.use64bitTexturing ); + return seed; + } + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & cudaFunctionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.module ); + for ( const char * p = cudaFunctionCreateInfoNV.pName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV const & cudaLaunchInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.function ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimX ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimY ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimZ ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimX ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimY ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimZ ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sharedMemBytes ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.paramCount ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pParams ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.extraCount ); + VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pExtras ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & cudaModuleCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.dataSize ); + VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pData ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::CustomResolveCreateInfoEXT const & customResolveCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.customResolve ); + VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.colorAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.pColorAttachmentFormats ); + VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.depthAttachmentFormat ); + VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.stencilAttachmentFormat ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount ); + VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues ); + VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount ); + VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM const & physicalDeviceDataGraphOperationSupportARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.operationType ); + for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.name[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.version ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM const & dataGraphPipelineBuiltinModelCreateInfoQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pOperation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM const & dataGraphPipelineCompilerControlCreateInfoARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCompilerControlCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCompilerControlCreateInfoARM.pNext ); + for ( const char * p = dataGraphPipelineCompilerControlCreateInfoARM.pVendorOptions; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantARM const & dataGraphPipelineConstantARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.id ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.pConstantData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & + dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.dimension ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.zeroCount ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.groupSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoARM const & dataGraphPipelineResourceInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.descriptorSet ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.binding ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.arrayElement ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineCreateInfoARM const & dataGraphPipelineCreateInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.flags ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.layout ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.resourceInfoCount ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.pResourceInfos ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchInfoARM const & dataGraphPipelineDispatchInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineDispatchInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineDispatchInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineDispatchInfoARM.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineIdentifierCreateInfoARM const & dataGraphPipelineIdentifierCreateInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.identifierSize ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.pIdentifier ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineInfoARM const & dataGraphPipelineInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineInfoARM.dataGraphPipeline ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyQueryResultARM const & dataGraphPipelinePropertyQueryResultARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.property ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.isText ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.dataSize ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.pData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementARM const & dataGraphPipelineSessionBindPointRequirementARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.bindPoint ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.bindPointType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.numObjects ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementsInfoARM const & + dataGraphPipelineSessionBindPointRequirementsInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementsInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementsInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementsInfoARM.session ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateInfoARM const & dataGraphPipelineSessionCreateInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.flags ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.dataGraphPipeline ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionMemoryRequirementsInfoARM const & dataGraphPipelineSessionMemoryRequirementsInfoARM ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.session ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.bindPoint ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.objectIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineShaderModuleCreateInfoARM const & dataGraphPipelineShaderModuleCreateInfoARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.module ); + for ( const char * p = dataGraphPipelineShaderModuleCreateInfoARM.pName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.pSpecializationInfo ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.constantCount ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.pConstants ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineARM const & physicalDeviceDataGraphProcessingEngineARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphProcessingEngineARM.type ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphProcessingEngineARM.isForeign ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DataGraphProcessingEngineCreateInfoARM const & dataGraphProcessingEngineCreateInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.processingEngineCount ); + VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.pProcessingEngines ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext ); + for ( const char * p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + for ( size_t i = 0; i < 4; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.color[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType ); + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object ); + for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.objectType ); + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.object ); + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagName ); + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagSize ); + VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pTag ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pfnCallback ); + VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pUserData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext ); + for ( const char * p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + for ( size_t i = 0; i < 4; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.color[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle ); + for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const & debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.flags ); + for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber ); + for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.objectCount ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pObjects ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageSeverity ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageType ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pUserData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectType ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectHandle ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagName ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagSize ); + VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pTag ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT const & decompressMemoryRegionEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.srcAddress ); + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.dstAddress ); + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.compressedSize ); + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.decompressedSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT const & decompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.decompressionMethod ); + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV const & decompressMemoryRegionNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.srcAddress ); + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.dstAddress ); + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.compressedSize ); + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressedSize ); + VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressionMethod ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const & dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const & dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const & dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.image ); + VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.buffer ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2 const & memoryBarrier2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstAccessMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.aspectMask ); + VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseMipLevel ); + VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.levelCount ); + VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseArrayLayer ); + VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.layerCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 const & imageMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.oldLayout ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.newLayout ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.image ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.subresourceRange ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfo const & dependencyInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.dependencyFlags ); + VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.memoryBarrierCount ); + VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pMemoryBarriers ); + VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.bufferMemoryBarrierCount ); + VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pBufferMemoryBarriers ); + VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.imageMemoryBarrierCount ); + VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pImageMemoryBarriers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT const & depthBiasInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasConstantFactor ); + VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasClamp ); + VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasSlopeFactor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT const & depthBiasRepresentationInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasRepresentation ); + VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasExact ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthClampRangeEXT const & depthClampRangeEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, depthClampRangeEXT.minDepthClamp ); + VULKAN_HPP_HASH_COMBINE( seed, depthClampRangeEXT.maxDepthClamp ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT const & descriptorAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.address ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.range ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.format ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT const & descriptorBufferBindingInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.address ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.usage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT const & + descriptorBufferBindingPushDescriptorBufferHandleEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.buffer ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.buffer ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.offset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.range ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.sampler ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageView ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorGetTensorInfoARM const & descriptorGetTensorInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorGetTensorInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorGetTensorInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorGetTensorInfoARM.tensorView ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.magFilter ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minFilter ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipmapMode ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeU ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeV ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeW ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipLodBias ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.anisotropyEnable ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxAnisotropy ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareEnable ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareOp ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minLod ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxLod ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.borderColor ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.unnormalizedCoordinates ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT const & descriptorMappingSourceConstantOffsetEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.heapOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.heapArrayStride ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.pEmbeddedSampler ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.samplerHeapOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.samplerHeapArrayStride ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT const & descriptorMappingSourcePushIndexEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.heapOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.pushOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.heapIndexStride ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.heapArrayStride ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.pEmbeddedSampler ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.useCombinedImageSamplerIndex ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerHeapOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerPushOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerHeapIndexStride ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerHeapArrayStride ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT const & descriptorMappingSourceIndirectIndexEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.heapOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.pushOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.addressOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.heapIndexStride ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.heapArrayStride ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.pEmbeddedSampler ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.useCombinedImageSamplerIndex ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerHeapOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerPushOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerAddressOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerHeapIndexStride ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerHeapArrayStride ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT const & descriptorMappingSourceIndirectIndexArrayEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.heapOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.pushOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.addressOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.heapIndexStride ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.pEmbeddedSampler ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.useCombinedImageSamplerIndex ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerHeapOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerPushOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerAddressOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerHeapIndexStride ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT const & descriptorMappingSourceHeapDataEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceHeapDataEXT.heapOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceHeapDataEXT.pushOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT const & descriptorMappingSourceIndirectAddressEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectAddressEXT.pushOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectAddressEXT.addressOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT const & descriptorMappingSourceShaderRecordIndexEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.heapOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.shaderRecordOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.heapIndexStride ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.heapArrayStride ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.pEmbeddedSampler ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.useCombinedImageSamplerIndex ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerHeapOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerShaderRecordOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerHeapIndexStride ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerHeapArrayStride ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.type ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.descriptorCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.maxSets ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.poolSizeCount ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pPoolSizes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo const & descriptorPoolInlineUniformBlockCreateInfo ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.maxInlineUniformBlockBindings ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorPool ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorSetCount ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pSetLayouts ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE const & descriptorSetBindingReferenceVALVE ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.descriptorSetLayout ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.binding ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.binding ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorCount ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.stageFlags ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.pImmutableSamplers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const & descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.bindingCount ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pBindings ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE const & descriptorSetLayoutHostMappingInfoVALVE ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorOffset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.supported ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const & descriptorSetVariableDescriptorCountAllocateInfo ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const & descriptorSetVariableDescriptorCountLayoutSupport ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstBinding ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstArrayElement ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorCount ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.offset ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.stride ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.templateType ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineLayout ); + VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.set ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT const & deviceAddressBindingCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.baseAddress ); + VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.size ); + VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.bindingType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements const & deviceBufferMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pCreateInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueCount ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pQueuePriorities ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.robustBufferAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fullDrawIndexUint32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.imageCubeArray ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.independentBlend ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.geometryShader ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.tessellationShader ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sampleRateShading ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.dualSrcBlend ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.logicOp ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiDrawIndirect ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.drawIndirectFirstInstance ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthClamp ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBiasClamp ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fillModeNonSolid ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBounds ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.wideLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.largePoints ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.alphaToOne ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiViewport ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.samplerAnisotropy ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionETC2 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionASTC_LDR ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionBC ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.occlusionQueryPrecise ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.pipelineStatisticsQuery ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fragmentStoresAndAtomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderImageGatherExtended ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageMultisample ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderClipDistance ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderCullDistance ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderFloat64 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt64 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceResidency ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceMinLod ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseBinding ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage2D ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage3D ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency2Samples ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency4Samples ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency8Samples ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency16Samples ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyAliased ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.variableMultisampleRate ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.inheritedQueries ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount ); + VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos ); + VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount ); + for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i ) + { + for ( const char * p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + } + VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pEnabledFeatures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const & deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback ); + VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const & deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.deviceEvent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT const & deviceFaultAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.reportedAddress ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressPrecision ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT const & deviceFaultCountsEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.addressInfoCount ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorInfoCount ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorBinarySize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT const & deviceFaultVendorInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.description[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultCode ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT const & deviceFaultInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pNext ); + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.description[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pAddressInfos ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorInfos ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorBinaryData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT const & deviceFaultVendorBinaryHeaderVersionOneEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerSize ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerVersion ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.vendorID ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.deviceID ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.driverVersion ); + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.pipelineCacheUUID[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationNameOffset ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationVersion ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineNameOffset ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineVersion ); + VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.apiVersion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.resourceDeviceIndex ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.memoryDeviceIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const & deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.deviceMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.physicalDeviceCount ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pPhysicalDevices ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const & deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.pNext ); + for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.modes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.swapchainCount ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pDeviceMasks ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.mode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceMask ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.waitSemaphoreCount ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.commandBufferCount ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.signalSemaphoreCount ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const & deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.modes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.imageType ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.format ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.extent ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.mipLevels ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.arrayLayers ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.samples ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.tiling ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.usage ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sharingMode ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.queueFamilyIndexCount ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pQueueFamilyIndices ); + VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.initialLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements const & deviceImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pCreateInfo ); + VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.planeAspect ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource2 const & imageSubresource2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.imageSubresource ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo const & deviceImageSubresourceInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pCreateInfo ); + VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pSubresource ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const & deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.memory ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const & deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const & deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.type ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.memoryObjectId ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.size ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectHandle ); + VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.heapIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR const & devicePipelineBinaryInternalCacheControlKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.disableInternalCache ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo const & devicePrivateDataCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.privateDataSlotRequestCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfo const & deviceQueueGlobalPriorityCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.globalPriority ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.flags ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM const & deviceQueueShaderCoreControlCreateInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.shaderCoreCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorDescriptionARM const & tensorDescriptionARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.tiling ); + VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.format ); + VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.dimensionCount ); + VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.pDimensions ); + VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.pStrides ); + VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.usage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorCreateInfoARM const & tensorCreateInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.flags ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.pDescription ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.sharingMode ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.queueFamilyIndexCount ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.pQueueFamilyIndices ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM const & deviceTensorMemoryRequirementsARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, deviceTensorMemoryRequirementsARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, deviceTensorMemoryRequirementsARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, deviceTensorMemoryRequirementsARM.pCreateInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG const & directDriverLoadingInfoLUNARG ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.sType ); + VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.flags ); + VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pfnGetInstanceProcAddr ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG const & directDriverLoadingListLUNARG ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.sType ); + VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.mode ); + VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.driverCount ); + VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pDrivers ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.dfb ); + VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.surface ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.x ); + VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.y ); + VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.z ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM const & dispatchTileInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dispatchTileInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dispatchTileInfoQCOM.pNext ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.displayEvent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.visibleRegion ); + VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.refreshRate ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.parameters ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.displayMode ); + VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.parameters ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.displayModeProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV const & displayModeStereoPropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.hdmi3DSupported ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const & displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.supportedAlpha ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcPosition ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcPosition ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcExtent ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcExtent ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstPosition ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstPosition ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstExtent ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.capabilities ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.mode ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.planeIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentDisplay ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentStackIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.displayPlaneProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.powerState ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.srcRect ); + VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.dstRect ); + VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.persistent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.display ); + for ( const char * p = displayPropertiesKHR.displayName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalDimensions ); + VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalResolution ); + VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.supportedTransforms ); + VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.planeReorderPossible ); + VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.persistentContent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.displayProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.displayMode ); + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeIndex ); + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeStackIndex ); + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.transform ); + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.globalAlpha ); + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.alphaMode ); + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.imageExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV const & displaySurfaceStereoCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.stereoType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.indexCount ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.instanceCount ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstIndex ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.vertexOffset ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstInstance ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.vertexCount ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.instanceCount ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstVertex ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstInstance ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCountIndirectCommandEXT const & drawIndirectCountIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCountIndirectCommandEXT.bufferAddress ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCountIndirectCommandEXT.stride ); + VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCountIndirectCommandEXT.commandCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT const & drawMeshTasksIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountX ); + VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountY ); + VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountZ ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.taskCount ); + VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.firstTask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifier ); + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount ); + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifier ); + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount ); + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const & drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount ); + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const & drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount ); + VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.libraryCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pLibraries ); + return seed; + } + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & executionGraphPipelineCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.flags ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.stageCount ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pStages ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pLibraryInfo ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.layout ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineHandle ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineIndex ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX const & executionGraphPipelineScratchSizeAMDX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.minSize ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.maxSize ); + VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.sizeGranularity ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.handleTypes ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pAttributes ); + VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.dwAccess ); + VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.name ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.handleTypes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.handleTypes ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pAttributes ); + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.dwAccess ); + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.name ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pAttributes ); + VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.dwAccess ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT const & exportMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.memory ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.mtlBuffer ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT const & exportMetalCommandQueueInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.queue ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.mtlCommandQueue ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT const & exportMetalDeviceInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.mtlDevice ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT const & exportMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.image ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.ioSurface ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT const & exportMetalObjectCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.exportObjectType ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT const & exportMetalObjectsInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.pNext ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT const & exportMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.semaphore ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.event ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.mtlSharedEvent ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT const & exportMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.image ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.imageView ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.bufferView ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.plane ); + VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.mtlTexture ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.handleTypes ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const & exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pAttributes ); + VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.dwAccess ); + VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.name ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.extensionName[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.specVersion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.externalMemoryFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.exportFromImportedHandleTypes ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.compatibleHandleTypes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.externalMemoryProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV const & externalComputeQueueCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.preferredQueue ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV const & externalComputeQueueDataParamsNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.deviceIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV const & externalComputeQueueDeviceCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.reservedExternalQueues ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.exportFromImportedHandleTypes ); + VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.compatibleHandleTypes ); + VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.externalFenceFeatures ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.externalFormat ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_OHOS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatOHOS const & externalFormatOHOS ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.externalFormat ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_OHOS*/ + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatQNX const & externalFormatQNX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.externalFormat ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.externalMemoryProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxExtent ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxMipLevels ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxArrayLayers ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.sampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxResourceSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.imageFormatProperties ); + VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.externalMemoryFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.exportFromImportedHandleTypes ); + VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.compatibleHandleTypes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT const & externalMemoryAcquireUnmodifiedEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.acquireUnmodifiedMemory ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.handleTypes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.handleTypes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.handleTypes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryTensorCreateInfoARM const & externalMemoryTensorCreateInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryTensorCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryTensorCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalMemoryTensorCreateInfoARM.handleTypes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.exportFromImportedHandleTypes ); + VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.compatibleHandleTypes ); + VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.externalSemaphoreFeatures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalTensorPropertiesARM const & externalTensorPropertiesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalTensorPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalTensorPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalTensorPropertiesARM.externalMemoryProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.fence ); + VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.handleType ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.fence ); + VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.handleType ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const & filterCubicImageViewImageFormatPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic ); + VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, formatProperties.linearTilingFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, formatProperties.optimalTilingFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, formatProperties.bufferFeatures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.formatProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties3 const & formatProperties3 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.sType ); + VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.linearTilingFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.optimalTilingFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.bufferFeatures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const & fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment ); + VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const & frameBoundaryEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.frameID ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.imageCount ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pImages ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.bufferCount ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagName ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagSize ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pTag ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryTensorsARM const & frameBoundaryTensorsARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.tensorCount ); + VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.pTensors ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.usage ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.width ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.height ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.layerCount ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.viewFormatCount ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pViewFormats ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pAttachmentImageInfos ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.renderPass ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.attachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.width ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.height ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.layers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const & framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.coverageReductionMode ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.rasterizationSamples ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.depthStencilSamples ); + VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.colorSamples ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT const & generatedCommandsInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.shaderStages ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectExecutionSet ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectCommandsLayout ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectAddress ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectAddressSize ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.preprocessAddress ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.preprocessSize ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.maxSequenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.sequenceCountAddress ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.maxDrawCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.buffer ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.offset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipelineBindPoint ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipeline ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.indirectCommandsLayout ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.streamCount ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pStreams ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCount ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessOffset ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessSize ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountOffset ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoEXT const & generatedCommandsMemoryRequirementsInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.indirectExecutionSet ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.indirectCommandsLayout ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.maxSequenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.maxDrawCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const & generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipeline ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsPipelineInfoEXT const & generatedCommandsPipelineInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsPipelineInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsPipelineInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsPipelineInfoEXT.pipeline ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsShaderInfoEXT const & generatedCommandsShaderInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.shaderCount ); + VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.pShaders ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV const & latencyTimingsFrameReportNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentID ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.inputSampleTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simStartTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simEndTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitStartTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitEndTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentStartTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentEndTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverStartTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverEndTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueStartTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueEndTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderStartTimeUs ); + VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderEndTimeUs ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV const & getLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.timingCount ); + VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pTimings ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.binding ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.stride ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.inputRate ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.location ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.binding ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.format ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.offset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const & pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const & pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.topology ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const & pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.patchControlPoints ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.viewportCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pViewports ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.scissorCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pScissors ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const & pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthClampEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.polygonMode ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.cullMode ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.frontFace ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasClamp ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.lineWidth ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const & pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.rasterizationSamples ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.minSampleShading ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pSampleMask ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.failOp ); + VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.passOp ); + VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.depthFailOp ); + VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareOp ); + VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareMask ); + VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.writeMask ); + VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.reference ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const & pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthTestEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthCompareOp ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.front ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.back ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.minDepthBounds ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const & pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.blendEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcColorBlendFactor ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstColorBlendFactor ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorBlendOp ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.alphaBlendOp ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorWriteMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const & pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOpEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOp ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.attachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pAttachments ); + for ( size_t i = 0; i < 4; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.blendConstants[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.dynamicStateCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pDynamicStates ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.stageCount ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pStages ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pVertexInputState ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pInputAssemblyState ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pTessellationState ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pViewportState ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pRasterizationState ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pMultisampleState ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDepthStencilState ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pColorBlendState ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDynamicState ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.layout ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.renderPass ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.subpass ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineHandle ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT const & graphicsPipelineLibraryCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.stageCount ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pStages ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pVertexInputState ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pTessellationState ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const & graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pGroups ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount ); + VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.x ); + VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.y ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryRed ); + VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryGreen ); + VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryBlue ); + VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.whitePoint ); + VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxLuminance ); + VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.minLuminance ); + VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxContentLightLevel ); + VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxFrameAverageLightLevel ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI const & hdrVividDynamicMetadataHUAWEI ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.sType ); + VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.dynamicMetadataSize ); + VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.pDynamicMetadata ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT const & hostAddressRangeConstEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeConstEXT.address ); + VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeConstEXT.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::HostAddressRangeEXT const & hostAddressRangeEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeEXT.address ); + VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeEXT.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQuery const & hostImageCopyDevicePerformanceQuery ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.sType ); + VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.optimalDeviceAccess ); + VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.identicalMemoryLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo const & hostImageLayoutTransitionInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.image ); + VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.oldLayout ); + VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.newLayout ); + VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.subresourceRange ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_IOS_MVK ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.sType ); + VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.flags ); + VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pView ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_IOS_MVK*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA const & imageAlignmentControlCreateInfoMESA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.maximumRequestedAlignment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcSubresource ); + for ( size_t i = 0; i < 2; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcOffsets[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstSubresource ); + for ( size_t i = 0; i < 2; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstOffsets[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT const & imageCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.image ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT const & imageCompressionControlEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.compressionControlPlaneCount ); + VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pFixedRateFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT const & imageCompressionPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFlags ); + VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFixedRateFlags ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const & imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.flags ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount ); + VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pFormatConstraints ); + VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.bufferCollectionConstraints ); + VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.flags ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcOffset ); + VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstOffset ); + VULKAN_HPP_HASH_COMBINE( seed, imageCopy.extent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.image ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.viewType ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.format ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.components ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.subresourceRange ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT const & imageDescriptorInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.pView ); + VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.layout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.offset ); + VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.size ); + VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.rowPitch ); + VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.arrayPitch ); + VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.depthPitch ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const & imageDrmFormatModifierExplicitCreateInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier ); + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount ); + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const & imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount ); + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const & imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.viewFormatCount ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pViewFormats ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.imageFormatProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.oldLayout ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.newLayout ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.image ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.subresourceRange ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.image ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.flags ); + VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.planeAspect ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcOffset ); + VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstOffset ); + VULKAN_HPP_HASH_COMBINE( seed, imageResolve.extent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2 const & imageResolve2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcOffset ); + VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstSubresource ); + VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstOffset ); + VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.extent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const & imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.image ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.stencilUsage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.swapchain ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.decodeMode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.deviceAddress ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT const & imageViewCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.imageView ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.imageView ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.descriptorType ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sampler ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.minLod ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM const & imageViewSampleWeightCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterCenter ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterSize ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.numPhases ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT const & imageViewSlicedCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceOffset ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.usage ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const & importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.buffer ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fence ); + VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.handleType ); + VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fd ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.fence ); + VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handleType ); + VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handle ); + VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.name ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const & importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.collection ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.index ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.handleType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.fd ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.handleType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pHostPointer ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT const & importMemoryMetalHandleInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.handleType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.handle ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handleType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handle ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.name ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handleType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handle ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const & importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handleType ); + VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handle ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT const & importMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.mtlBuffer ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT const & importMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.ioSurface ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT const & importMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.mtlSharedEvent ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT const & importMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.plane ); + VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.mtlTexture ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_OHOS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS const & importNativeBufferInfoOHOS ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.buffer ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_OHOS*/ + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX const & importScreenBufferInfoQNX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.buffer ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.semaphore ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.handleType ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.fd ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const & importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.semaphore ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handleType ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handle ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.name ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const & importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.flags ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.handleType ); + VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsExecutionSetTokenEXT const & indirectCommandsExecutionSetTokenEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsExecutionSetTokenEXT.type ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsExecutionSetTokenEXT.shaderStages ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsIndexBufferTokenEXT const & indirectCommandsIndexBufferTokenEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsIndexBufferTokenEXT.mode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.stageFlags ); + VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.offset ); + VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsPushConstantTokenEXT const & indirectCommandsPushConstantTokenEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsPushConstantTokenEXT.updateRange ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsVertexBufferTokenEXT const & indirectCommandsVertexBufferTokenEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsVertexBufferTokenEXT.vertexBindingUnit ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoEXT const & indirectCommandsLayoutCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.shaderStages ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.indirectStride ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.pipelineLayout ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.tokenCount ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.pTokens ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.tokenType ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.stream ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.offset ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexBindingUnit ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexDynamicStride ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantOffset ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantSize ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indirectStateFlags ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indexTypeCount ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypes ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypeValues ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.flags ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.tokenCount ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pTokens ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.streamCount ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV const & indirectCommandsLayoutPushDataTokenNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.pushDataOffset ); + VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.pushDataSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT const & indirectExecutionSetPipelineInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.initialPipeline ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.maxPipelineCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT const & indirectExecutionSetShaderLayoutInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.setLayoutCount ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.pSetLayouts ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT const & indirectExecutionSetShaderInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.shaderCount ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pInitialShaders ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pSetLayoutInfos ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.maxShaderCount ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pushConstantRangeCount ); + VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pPushConstantRanges ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const & initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.sType ); + VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pUserData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.subpass ); + VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.inputAttachmentIndex ); + VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.aspectMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pApplicationInfo ); + VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledLayerCount ); + for ( size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i ) + { + for ( const char * p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + } + VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledExtensionCount ); + for ( size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i ) + { + for ( const char * p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV const & latencySleepInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.signalSemaphore ); + VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.value ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV const & latencySleepModeInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyMode ); + VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyBoost ); + VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.minimumIntervalUs ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV const & latencySubmissionPresentIdNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.presentID ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV const & latencySurfaceCapabilitiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.presentModeCount ); + VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pPresentModes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, layerProperties.layerName[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, layerProperties.specVersion ); + VULKAN_HPP_HASH_COMBINE( seed, layerProperties.implementationVersion ); + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, layerProperties.description[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingEXT const & layerSettingEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + for ( const char * p = layerSettingEXT.pLayerName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + for ( const char * p = layerSettingEXT.pSettingName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.type ); + VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.valueCount ); + VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.pValues ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT const & layerSettingsCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.settingCount ); + VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pSettings ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_MACOS_MVK ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.sType ); + VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.flags ); + VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pView ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.sType ); + VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.memory ); + VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.offset ); + VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.deviceMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.allocationSize ); + VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.memoryTypeIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.srcAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.dstAccessMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR const & memoryBarrierAccessFlags3KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.srcAccessMask3 ); + VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.dstAccessMask3 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.image ); + VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.buffer ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoTensorARM const & memoryDedicatedAllocateInfoTensorARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfoTensorARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfoTensorARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfoTensorARM.tensor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.prefersDedicatedAllocation ); + VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.requiresDedicatedAllocation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.memoryTypeBits ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const & memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.memory ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.memory ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.handleType ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT const & memoryGetMetalHandleInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.memory ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.handleType ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + +# if defined( VK_USE_PLATFORM_OHOS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS const & memoryGetNativeBufferInfoOHOS ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.memory ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_OHOS*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.memory ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.handleType ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.memory ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.handleType ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.memory ); + VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.handleType ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.size ); + VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.memoryTypeBits ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapInfo const & memoryMapInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.memory ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.offset ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT const & memoryMapPlacedInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pPlacedAddress ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT const & memoryMetalHandlePropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.memoryTypeBits ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const & memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.priority ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.size ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.alignment ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.memoryTypeBits ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.memoryRequirements ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryType.propertyFlags ); + VULKAN_HPP_HASH_COMBINE( seed, memoryType.heapIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryUnmapInfo const & memoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.memory ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.memoryTypeBits ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const & memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pLayer ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT const & micromapBuildSizesInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.micromapSize ); + VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.buildScratchSize ); + VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.discardable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & micromapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.createFlags ); + VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.buffer ); + VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.offset ); + VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.size ); + VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.type ); + VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.deviceAddress ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT const & micromapTriangleEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.dataOffset ); + VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.subdivisionLevel ); + VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.format ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT const & micromapVersionInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pVersionData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.firstIndex ); + VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.indexCount ); + VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.vertexOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.firstVertex ); + VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.vertexCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.maxSampleLocationGridSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT const & multisampledRenderToSingleSampledInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.multisampledRenderToSingleSampledEnable ); + VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.rasterizationSamples ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const & multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributes ); + VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & multiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.perViewRenderAreaCount ); + VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pPerViewRenderAreas ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT const & mutableDescriptorTypeListEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.descriptorTypeCount ); + VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.pDescriptorTypes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT const & mutableDescriptorTypeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.mutableDescriptorTypeListCount ); + VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pMutableDescriptorTypeLists ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_OHOS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS const & nativeBufferFormatPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.sType ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.format ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.externalFormat ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.formatFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.samplerYcbcrConversionComponents ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYcbcrModel ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYcbcrRange ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedXChromaOffset ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYChromaOffset ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_OHOS*/ + +# if defined( VK_USE_PLATFORM_OHOS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS const & nativeBufferPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.sType ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.allocationSize ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.memoryTypeBits ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_OHOS*/ + +# if defined( VK_USE_PLATFORM_OHOS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS const & nativeBufferUsageOHOS ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.sType ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.OHOSNativeBufferUsage ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_OHOS*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT const & opaqueCaptureDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDataCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDataCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDataCreateInfoEXT.pData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT const & opaqueCaptureDescriptorDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.opaqueCaptureDescriptorData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV const & opticalFlowExecuteInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.flags ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV const & opticalFlowImageFormatInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.usage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV const & opticalFlowImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.format ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & opticalFlowSessionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.width ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.height ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.imageFormat ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flowVectorFormat ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.costFormat ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.outputGridSize ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.hintGridSize ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.performanceLevel ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV const & opticalFlowSessionCreatePrivateDataInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.id ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.size ); + VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pPrivateData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV const & outOfBandQueueTypeInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.queueType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV const & partitionedAccelerationStructureFlagsNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureFlagsNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureFlagsNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureFlagsNV.enablePartitionTranslation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV const & + partitionedAccelerationStructureUpdateInstanceDataNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureUpdateInstanceDataNV.instanceIndex ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureUpdateInstanceDataNV.instanceContributionToHitGroupIndex ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureUpdateInstanceDataNV.accelerationStructure ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV const & partitionedAccelerationStructureWriteInstanceDataNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.transform ); + for ( size_t i = 0; i < 6; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.explicitAABB[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceID ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceMask ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceContributionToHitGroupIndex ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceFlags ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceIndex ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.partitionIndex ); + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.accelerationStructure ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV const & + partitionedAccelerationStructureWritePartitionTranslationDataNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWritePartitionTranslationDataNV.partitionIndex ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWritePartitionTranslationDataNV.partitionTranslation[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentStageTimeEXT const & presentStageTimeEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentStageTimeEXT.stage ); + VULKAN_HPP_HASH_COMBINE( seed, presentStageTimeEXT.time ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingEXT const & pastPresentationTimingEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.presentId ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.targetTime ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.presentStageCount ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.pPresentStages ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.timeDomain ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.timeDomainId ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.reportComplete ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentID ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.desiredPresentTime ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.actualPresentTime ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.earliestPresentTime ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentMargin ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingInfoEXT const & pastPresentationTimingInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.swapchain ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingPropertiesEXT const & pastPresentationTimingPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.timingPropertiesCounter ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.timeDomainsCounter ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.presentationTimingCount ); + VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.pPresentationTimings ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM const & perTileBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, perTileBeginInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, perTileBeginInfoQCOM.pNext ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM const & perTileEndInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, perTileEndInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, perTileEndInfoQCOM.pNext ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.sType ); + VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.type ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterARM const & performanceCounterARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.counterID ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM const & performanceCounterDescriptionARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.flags ); + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.name[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.flags ); + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.name[i] ); + } + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.category[i] ); + } + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.description[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.unit ); + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.scope ); + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.storage ); + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.uuid[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.sType ); + VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.marker ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.sType ); + VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.type ); + VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.enable ); + VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.parameter ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.counterPassIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.sType ); + VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.marker ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const & physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storagePushConstant16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageInputOutput16 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const & physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const & physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storagePushConstant8 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const & physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const & physicalDeviceAccelerationStructureFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const & physicalDeviceAccelerationStructurePropertiesKHR ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT const & physicalDeviceAddressBindingReportFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.reportAddressBinding ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC const & physicalDeviceAmigoProfilingFeaturesSEC ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.amigoProfiling ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD const & physicalDeviceAntiLagFeaturesAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.antiLag ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & + physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.attachmentFeedbackLoopDynamicState ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & + physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.attachmentFeedbackLoopLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & physicalDeviceBlendOperationAdvancedPropertiesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const & physicalDeviceBorderColorSwizzleFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const & physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & physicalDeviceBufferDeviceAddressFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV const & + physicalDeviceClusterAccelerationStructureFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructureFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructureFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructureFeaturesNV.clusterAccelerationStructure ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV const & + physicalDeviceClusterAccelerationStructurePropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.maxVerticesPerCluster ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.maxTrianglesPerCluster ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterScratchByteAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterByteAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterTemplateByteAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterBottomLevelByteAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterTemplateBoundsByteAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.maxClusterGeometryIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & physicalDeviceClusterCullingShaderFeaturesHUAWEI ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.clustercullingShader ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.multiviewClusterCullingShader ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & physicalDeviceClusterCullingShaderPropertiesHUAWEI ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.pNext ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupCount[i] ); + } + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupSize[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxOutputClusterCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.indirectBufferOffsetAlignment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.clusterShadingRate ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const & physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const & physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCommandBufferInheritanceFeaturesNV const & physicalDeviceCommandBufferInheritanceFeaturesNV ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.commandBufferInheritance ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & physicalDeviceComputeOccupancyPriorityFeaturesNV ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeOccupancyPriorityFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeOccupancyPriorityFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeOccupancyPriorityFeaturesNV.computeOccupancyPriority ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & physicalDeviceComputeShaderDerivativesFeaturesKHR ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.computeDerivativeGroupQuads ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.computeDerivativeGroupLinear ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & physicalDeviceComputeShaderDerivativesPropertiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesPropertiesKHR.meshAndTaskShaderDerivatives ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const & physicalDeviceConditionalRenderingFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const & + physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV const & physicalDeviceCooperativeMatrix2FeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixWorkgroupScope ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixFlexibleDimensions ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixReductions ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixConversions ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixPerElementOperations ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixTensorAddressing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixBlockLoads ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV const & physicalDeviceCooperativeMatrix2PropertiesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixFlexibleDimensionsMaxDimension ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixWorkgroupScopeReservedSharedMemory ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR const & physicalDeviceCooperativeMatrixFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrix ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrixRobustBufferAccess ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const & physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR const & physicalDeviceCooperativeMatrixPropertiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.cooperativeMatrixSupportedStages ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const & physicalDeviceCooperativeMatrixPropertiesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV const & physicalDeviceCooperativeVectorFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.cooperativeVector ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.cooperativeVectorTraining ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV const & physicalDeviceCooperativeVectorPropertiesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.cooperativeVectorSupportedStages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.cooperativeVectorTrainingFloat16Accumulation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.cooperativeVectorTrainingFloat32Accumulation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.maxCooperativeVectorComponents ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & physicalDeviceCopyMemoryIndirectFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.indirectMemoryCopy ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.indirectMemoryToImageCopy ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV const & physicalDeviceCopyMemoryIndirectFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.indirectCopy ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & physicalDeviceCopyMemoryIndirectPropertiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.supportedQueues ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const & physicalDeviceCornerSampledImageFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const & physicalDeviceCoverageReductionModeFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM const & physicalDeviceCubicClampFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.cubicRangeClamp ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM const & physicalDeviceCubicWeightsFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.selectableCubicWeights ); + return seed; + } + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV const & physicalDeviceCudaKernelLaunchFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.cudaKernelLaunchFeatures ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV const & physicalDeviceCudaKernelLaunchPropertiesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMinor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMajor ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const & physicalDeviceCustomBorderColorFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const & physicalDeviceCustomBorderColorPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomResolveFeaturesEXT const & physicalDeviceCustomResolveFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.customResolve ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphFeaturesARM const & physicalDeviceDataGraphFeaturesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraph ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphSpecializationConstants ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphDescriptorBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphShaderModule ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM const & physicalDeviceDataGraphModelFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.dataGraphModel ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & + physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing ); + return seed; + } + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & physicalDeviceDenseGeometryFormatFeaturesAMDX ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.denseGeometryFormat ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT const & physicalDeviceDepthBiasControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasControl ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.leastRepresentableValueForceUnormRepresentation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.floatRepresentation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasExact ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT const & physicalDeviceDepthClampControlFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampControlFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampControlFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampControlFeaturesEXT.depthClampControl ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR const & physicalDeviceDepthClampZeroOneFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.depthClampZeroOne ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const & physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const & physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const & physicalDeviceDepthStencilResolveProperties ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolve ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & + physicalDeviceDescriptorBufferDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.combinedImageSamplerDensityMapDescriptorSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT const & physicalDeviceDescriptorBufferFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferCaptureReplay ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferImageLayoutIgnored ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferPushDescriptors ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT const & physicalDeviceDescriptorBufferPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSingleArray ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferlessPushDescriptors ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.allowSamplerImageViewPostSubmitCreation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferOffsetAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxDescriptorBufferBindings ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferBindings ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferBindings ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplerBindings ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferCaptureReplayDescriptorDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageCaptureReplayDescriptorDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageViewCaptureReplayDescriptorDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerCaptureReplayDescriptorDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureCaptureReplayDescriptorDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sampledImageDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageImageDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformTexelBufferDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformTexelBufferDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageTexelBufferDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageTexelBufferDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformBufferDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformBufferDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageBufferDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageBufferDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.inputAttachmentDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferRange ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferRange ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorBufferAddressSpaceSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.resourceDescriptorBufferAddressSpaceSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferAddressSpaceSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorFeaturesARM const & physicalDeviceDescriptorBufferTensorFeaturesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorFeaturesARM.descriptorBufferTensorDescriptors ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorPropertiesARM const & physicalDeviceDescriptorBufferTensorPropertiesARM ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.tensorCaptureReplayDescriptorDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.tensorViewCaptureReplayDescriptorDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.tensorDescriptorSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT const & physicalDeviceDescriptorHeapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.descriptorHeap ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.descriptorHeapCaptureReplay ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT const & physicalDeviceDescriptorHeapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerHeapAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.resourceHeapAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxSamplerHeapSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxResourceHeapSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.minSamplerHeapReservedRange ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.minSamplerHeapReservedRangeWithEmbedded ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.minResourceHeapReservedRange ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.imageDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.bufferDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerDescriptorAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.imageDescriptorAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.bufferDescriptorAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxPushDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.imageCaptureReplayOpaqueDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxDescriptorHeapEmbeddedSamplers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerYcbcrConversionCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.sparseDescriptorHeaps ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.protectedDescriptorHeaps ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM const & physicalDeviceDescriptorHeapTensorPropertiesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.tensorDescriptorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.tensorDescriptorAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.tensorCaptureReplayOpaqueDataSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const & physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const & physicalDeviceDescriptorIndexingProperties ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & + physicalDeviceDescriptorPoolOverallocationFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.descriptorPoolOverallocation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & physicalDeviceDescriptorSetHostMappingFeaturesVALVE ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.descriptorSetHostMapping ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & + physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedCompute ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputePipelines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputeCaptureReplay ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & physicalDeviceDeviceGeneratedCommandsFeaturesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.deviceGeneratedCommands ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.dynamicGeneratedPipelineLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & physicalDeviceDeviceGeneratedCommandsPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectPipelineCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectShaderObjectCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectSequenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectCommandsTokenCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectCommandsTokenOffset ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectCommandsIndirectStride ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsInputModes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsShaderStages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsShaderStagesPipelineBinding ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsShaderStagesShaderBinding ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.deviceGeneratedCommandsTransformFeedback ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.deviceGeneratedCommandsMultiDrawIndirectCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & physicalDeviceDeviceGeneratedCommandsPropertiesNV ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const & physicalDeviceDeviceMemoryReportFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const & physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const & physicalDeviceDiscardRectanglePropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles ); + return seed; + } + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV const & physicalDeviceDisplacementMicromapFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.displacementMicromap ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV const & physicalDeviceDisplacementMicromapPropertiesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.maxDisplacementMicromapSubdivisionLevel ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverID ); + for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverName[i] ); + } + for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverInfo[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.conformanceVersion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasPrimary ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasRender ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMajor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMinor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMajor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMinor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures const & physicalDeviceDynamicRenderingFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.dynamicRendering ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeatures const & physicalDeviceDynamicRenderingLocalReadFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.dynamicRenderingLocalRead ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & + physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.dynamicRenderingUnusedAttachments ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const & physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const & physicalDeviceExtendedDynamicState2FeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT const & physicalDeviceExtendedDynamicState3FeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3TessellationDomainOrigin ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClampEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3PolygonMode ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationSamples ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleMask ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToCoverageEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToOneEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LogicOpEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEquation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorWriteMask ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationStream ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ConservativeRasterizationMode ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ExtraPrimitiveOverestimationSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleLocationsEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendAdvanced ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ProvokingVertexMode ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineRasterizationMode ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineStippleEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipNegativeOneToOne ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportWScalingEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportSwizzle ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorLocation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationMode ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTableEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageReductionMode ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RepresentativeFragmentTestEnable ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ShadingRateImageEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT const & physicalDeviceExtendedDynamicState3PropertiesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.dynamicPrimitiveTopologyUnrestricted ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const & physicalDeviceExtendedDynamicStateFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & physicalDeviceExtendedSparseAddressSpaceFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.extendedSparseAddressSpace ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & + physicalDeviceExtendedSparseAddressSpacePropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseAddressSpaceSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseImageUsageFlags ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseBufferUsageFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.usage ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.handleType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV const & physicalDeviceExternalComputeQueuePropertiesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.externalDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.maxExternalQueues ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.handleType ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID const & physicalDeviceExternalFormatResolveFeaturesANDROID ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.externalFormatResolve ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID const & + physicalDeviceExternalFormatResolvePropertiesANDROID ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.nullColorAttachmentWithExternalFormatResolve ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetX ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetY ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const & physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.handleType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const & physicalDeviceExternalMemoryHostPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const & physicalDeviceExternalMemoryRDMAFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & physicalDeviceExternalMemoryScreenBufferFeaturesQNX ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.screenBufferImport ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const & physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.handleType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalTensorInfoARM const & physicalDeviceExternalTensorInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.flags ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.pDescription ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.handleType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT const & physicalDeviceFaultFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFault ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFaultVendorBinary ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.features ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const & physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.denormBehaviorIndependence ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.roundingModeIndependence ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM const & physicalDeviceFormatPackFeaturesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFormatPackFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFormatPackFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFormatPackFeaturesARM.formatPack ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const & physicalDeviceFragmentDensityMap2FeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const & physicalDeviceFragmentDensityMap2PropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const & physicalDeviceFragmentDensityMapFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & + physicalDeviceFragmentDensityMapLayeredFeaturesVALVE ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.fragmentDensityMapLayered ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & + physicalDeviceFragmentDensityMapLayeredPropertiesVALVE ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.maxFragmentDensityMapLayers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & physicalDeviceFragmentDensityMapOffsetFeaturesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.fragmentDensityMapOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & physicalDeviceFragmentDensityMapOffsetPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.fragmentDensityOffsetGranularity ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const & physicalDeviceFragmentDensityMapPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & physicalDeviceFragmentShaderBarycentricFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.fragmentShaderBarycentric ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & + physicalDeviceFragmentShaderBarycentricPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.triStripVertexOrderIndependentOfProvokingVertex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & physicalDeviceFragmentShaderInterlockFeaturesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & physicalDeviceFragmentShadingRateEnumsFeaturesNV ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const & physicalDeviceFragmentShadingRateFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const & physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.fragmentSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const & physicalDeviceFragmentShadingRatePropertiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const & physicalDeviceFrameBoundaryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.frameBoundary ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeatures const & physicalDeviceGlobalPriorityQueryFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.globalPriorityQuery ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & physicalDeviceGraphicsPipelineLibraryFeaturesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.graphicsPipelineLibrary ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & physicalDeviceGraphicsPipelineLibraryPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryFastLinking ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryIndependentInterpolationDecoration ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDeviceCount ); + for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDevices[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.subsetAllocation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI const & physicalDeviceHdrVividFeaturesHUAWEI ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHdrVividFeaturesHUAWEI.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHdrVividFeaturesHUAWEI.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHdrVividFeaturesHUAWEI.hdrVivid ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeatures const & physicalDeviceHostImageCopyFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.hostImageCopy ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyProperties const & physicalDeviceHostImageCopyProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.copySrcLayoutCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pCopySrcLayouts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.copyDstLayoutCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pCopyDstLayouts ); + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.optimalTilingLayoutUUID[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.identicalMemoryTypeRequirements ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const & physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.hostQueryReset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.pNext ); + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceUUID[i] ); + } + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.driverUUID[i] ); + } + for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUID[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceNodeMask ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUIDValid ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const & physicalDeviceImage2DViewOf3DFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sampler2DViewOf3D ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA const & physicalDeviceImageAlignmentControlFeaturesMESA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.imageAlignmentControl ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA const & physicalDeviceImageAlignmentControlPropertiesMESA ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.supportedImageAlignmentMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT const & physicalDeviceImageCompressionControlFeaturesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.imageCompressionControl ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & + physicalDeviceImageCompressionControlSwapchainFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.imageCompressionControlSwapchain ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const & physicalDeviceImageDrmFormatModifierInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.format ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.type ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.tiling ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.usage ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM const & physicalDeviceImageProcessing2FeaturesQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.textureBlockMatch2 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM const & physicalDeviceImageProcessing2PropertiesQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.maxBlockMatchWindow ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM const & physicalDeviceImageProcessingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureSampleWeighted ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBoxFilter ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBlockMatch ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM const & physicalDeviceImageProcessingPropertiesQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterPhases ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterDimension ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBlockMatchRegion ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBoxFilterBlockSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures const & physicalDeviceImageRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.robustImageAccess ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & physicalDeviceImageSlicedViewOf3DFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.imageSlicedViewOf3D ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const & physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const & physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const & physicalDeviceImagelessFramebufferFeatures ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8Features const & physicalDeviceIndexTypeUint8Features ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.indexTypeUint8 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const & physicalDeviceInheritedViewportScissorFeaturesNV ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures const & physicalDeviceInlineUniformBlockFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.inlineUniformBlock ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties const & physicalDeviceInlineUniformBlockProperties ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxInlineUniformBlockSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & + physicalDeviceInternallySynchronizedQueuesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInternallySynchronizedQueuesFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInternallySynchronizedQueuesFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInternallySynchronizedQueuesFeaturesKHR.internallySynchronizedQueues ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const & physicalDeviceInvocationMaskFeaturesHUAWEI ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR const & physicalDeviceLayeredApiPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.vendorID ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceID ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.layeredAPI ); + for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceName[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR const & physicalDeviceLayeredApiPropertiesListKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.layeredApiCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pLayeredApis ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension1D ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension2D ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension3D ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimensionCube ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageArrayLayers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelBufferElements ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxUniformBufferRange ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxStorageBufferRange ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPushConstantsSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxMemoryAllocationCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAllocationCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.bufferImageGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sparseAddressSpaceSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxBoundDescriptorSets ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSamplers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageResources ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSamplers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSampledImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetInputAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindings ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributeOffset ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindingStride ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexOutputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationGenerationLevel ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationPatchSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryShaderInvocations ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryInputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputVertices ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryTotalOutputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentInputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentOutputAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentDualSrcAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentCombinedOutputResources ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeSharedMemorySize ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupInvocations ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelPrecisionBits ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subTexelPrecisionBits ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.mipmapPrecisionBits ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndexedIndexValue ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndirectCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerLodBias ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAnisotropy ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewports ); + for ( size_t i = 0; i < 2; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewportDimensions[i] ); + } + for ( size_t i = 0; i < 2; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportBoundsRange[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportSubPixelBits ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minMemoryMapAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelBufferOffsetAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minUniformBufferOffsetAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minStorageBufferOffsetAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelOffset ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelOffset ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelGatherOffset ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelGatherOffset ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minInterpolationOffset ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxInterpolationOffset ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelInterpolationOffsetBits ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferWidth ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferHeight ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferLayers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferColorSampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferDepthSampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferStencilSampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxColorAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageColorSampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageIntegerSampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageDepthSampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageStencilSampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.storageImageSampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSampleMaskWords ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampComputeAndGraphics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampPeriod ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxClipDistances ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCullDistances ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCombinedClipAndCullDistances ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.discreteQueuePriorities ); + for ( size_t i = 0; i < 2; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeRange[i] ); + } + for ( size_t i = 0; i < 2; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthRange[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.strictLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.standardSampleLocations ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.nonCoherentAtomSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType ); + for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] ); + } + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR const & physicalDeviceLayeredApiVulkanPropertiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.properties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & physicalDeviceLegacyVertexAttributesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.legacyVertexAttributes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & physicalDeviceLegacyVertexAttributesPropertiesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.nativeUnalignedPerformance ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeatures const & physicalDeviceLineRasterizationFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.rectangularLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.bresenhamLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.smoothLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledRectangularLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledBresenhamLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledSmoothLines ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationProperties const & physicalDeviceLineRasterizationProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.lineSubPixelPrecisionBits ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const & physicalDeviceLinearColorAttachmentFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.linearColorAttachment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR const & physicalDeviceMaintenance10FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.maintenance10 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR const & physicalDeviceMaintenance10PropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.rgba4OpaqueBlackSwizzled ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.resolveSrgbFormatAppliesTransferFunction ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.resolveSrgbFormatSupportsTransferFunctionControl ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const & physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features const & physicalDeviceMaintenance4Features ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.maintenance4 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties const & physicalDeviceMaintenance4Properties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.maxBufferSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Features const & physicalDeviceMaintenance5Features ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.maintenance5 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Properties const & physicalDeviceMaintenance5Properties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.earlyFragmentMultisampleCoverageAfterSampleCounting ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.earlyFragmentSampleMaskTestBeforeSampleCounting ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.depthStencilSwizzleOneSupport ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.polygonModePointSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.nonStrictSinglePixelWideLinesUseParallelogram ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.nonStrictWideLinesUseParallelogram ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Features const & physicalDeviceMaintenance6Features ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.maintenance6 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Properties const & physicalDeviceMaintenance6Properties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.blockTexelViewCompatibleMultipleLayers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.maxCombinedImageSamplerDescriptorCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.fragmentShadingRateClampCombinerInputs ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR const & physicalDeviceMaintenance7FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.maintenance7 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR const & physicalDeviceMaintenance7PropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.robustFragmentShadingRateAttachmentAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.separateDepthStencilAttachmentAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalUniformBuffersDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalStorageBuffersDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalBuffersDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR const & physicalDeviceMaintenance8FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.maintenance8 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9FeaturesKHR const & physicalDeviceMaintenance9FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9FeaturesKHR.maintenance9 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9PropertiesKHR const & physicalDeviceMaintenance9PropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.image2DViewOf3DSparse ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.defaultVertexAttributeValue ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT const & physicalDeviceMapMemoryPlacedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapPlaced ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapRangePlaced ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryUnmapReserve ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT const & physicalDeviceMapMemoryPlacedPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.minPlacedMemoryMapAlignment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const & physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext ); + for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] ); + } + for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT const & physicalDeviceMemoryDecompressionFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.memoryDecompression ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT const & physicalDeviceMemoryDecompressionPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.decompressionMethods ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.maxDecompressionIndirectCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const & physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypeCount ); + for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypes[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeapCount ); + for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeaps[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.memoryProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT const & physicalDeviceMeshShaderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.taskShader ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShader ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.multiviewMeshShader ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShaderQueries ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const & physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.taskShader ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.meshShader ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT const & physicalDeviceMeshShaderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupTotalCount ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupCount[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupInvocations ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupSize[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskSharedMemorySize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadAndSharedMemorySize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupTotalCount ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupCount[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupInvocations ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupSize[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshSharedMemorySize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndSharedMemorySize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputMemorySize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndOutputMemorySize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputComponents ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputVertices ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputPrimitives ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputLayers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshMultiviewViewCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerVertexGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerPrimitiveGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredTaskWorkGroupInvocations ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredMeshWorkGroupInvocations ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationVertexOutput ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationPrimitiveOutput ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactVertexOutput ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactPrimitiveOutput ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const & physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const & physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const & physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & + physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.multisampledRenderToSingleSampled ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiview ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & + physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & + physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.multiviewPerViewRenderAreas ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & physicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.multiviewPerViewViewports ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const & physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & physicalDeviceMutableDescriptorTypeFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.mutableDescriptorType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT const & physicalDeviceNestedCommandBufferFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferRendering ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferSimultaneousUse ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT const & physicalDeviceNestedCommandBufferPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.maxCommandBufferNestingLevel ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & physicalDeviceNonSeamlessCubeMapFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.nonSeamlessCubeMap ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT const & physicalDeviceOpacityMicromapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromap ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapCaptureReplay ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapHostCommands ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT const & physicalDeviceOpacityMicromapPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity2StateSubdivisionLevel ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity4StateSubdivisionLevel ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV const & physicalDeviceOpticalFlowFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.opticalFlow ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV const & physicalDeviceOpticalFlowPropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedOutputGridSizes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedHintGridSizes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.hintSupported ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.costSupported ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.bidirectionalFlowSupported ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.globalFlowSupported ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minWidth ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minHeight ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxWidth ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxHeight ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxNumRegionsOfInterest ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const & physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & + physicalDevicePartitionedAccelerationStructureFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructureFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructureFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructureFeaturesNV.partitionedAccelerationStructure ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & + physicalDevicePartitionedAccelerationStructurePropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructurePropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructurePropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructurePropertiesNV.maxPartitionCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV const & physicalDevicePerStageDescriptorSetFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.perStageDescriptorSet ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.dynamicPipelineLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM const & + physicalDevicePerformanceCountersByRegionFeaturesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.performanceCountersByRegion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM const & + physicalDevicePerformanceCountersByRegionPropertiesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.maxPerRegionPerformanceCounters ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.performanceCounterRegionSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.rowStrideAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.regionAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.identityTransformOrder ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const & physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const & physicalDevicePerformanceQueryPropertiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR const & physicalDevicePipelineBinaryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.pipelineBinaries ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR const & physicalDevicePipelineBinaryPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryInternalCache ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryInternalCacheControl ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryPrefersInternalCache ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryPrecompiledInternalCache ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryCompressedData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & + physicalDevicePipelineCacheIncrementalModeFeaturesSEC ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCacheIncrementalModeFeaturesSEC.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCacheIncrementalModeFeaturesSEC.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCacheIncrementalModeFeaturesSEC.pipelineCacheIncrementalMode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures const & physicalDevicePipelineCreationCacheControlFeatures ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pipelineCreationCacheControl ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & + physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & + physicalDevicePipelineLibraryGroupHandlesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pipelineLibraryGroupHandles ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM const & physicalDevicePipelineOpacityMicromapFeaturesARM ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.pipelineOpacityMicromap ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT const & physicalDevicePipelinePropertiesFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pipelinePropertiesIdentifier ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeatures const & physicalDevicePipelineProtectedAccessFeatures ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.pipelineProtectedAccess ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeatures const & physicalDevicePipelineRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.pipelineRobustness ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessProperties const & physicalDevicePipelineRobustnessProperties ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessStorageBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessUniformBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessVertexInputs ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessImages ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const & physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pointClippingBehavior ); + return seed; + } + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const & physicalDevicePortabilitySubsetFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.events ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const & physicalDevicePortabilitySubsetPropertiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV const & physicalDevicePresentBarrierFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.presentBarrier ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentId2FeaturesKHR const & physicalDevicePresentId2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentId2FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentId2FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentId2FeaturesKHR.presentId2 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const & physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.presentId ); + return seed; + } + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV const & physicalDevicePresentMeteringFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.presentMetering ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & physicalDevicePresentModeFifoLatestReadyFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentModeFifoLatestReadyFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentModeFifoLatestReadyFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentModeFifoLatestReadyFeaturesKHR.presentModeFifoLatestReady ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentTimingFeaturesEXT const & physicalDevicePresentTimingFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.presentTiming ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.presentAtAbsoluteTime ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.presentAtRelativeTime ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWait2FeaturesKHR const & physicalDevicePresentWait2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWait2FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWait2FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWait2FeaturesKHR.presentWait2 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const & physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.presentWait ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & + physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & physicalDevicePrimitivesGeneratedQueryFeaturesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQuery ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithRasterizerDiscard ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithNonZeroStreams ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures const & physicalDevicePrivateDataFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.privateData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const & physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.protectedMemory ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const & physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.protectedNoFault ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const & physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const & physicalDeviceProvokingVertexPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV const & physicalDevicePushConstantBankFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankFeaturesNV.pushConstantBank ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV const & physicalDevicePushConstantBankPropertiesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxGraphicsPushConstantBanks ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxComputePushConstantBanks ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxGraphicsPushDataBanks ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxComputePushDataBanks ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorProperties const & physicalDevicePushDescriptorProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.maxPushDescriptors ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & + physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.queueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.engineType ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & + physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderColorAttachmentAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderDepthAttachmentAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderStencilAttachmentAccess ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV const & physicalDeviceRawAccessChainsFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.shaderRawAccessChains ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const & physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.rayQuery ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & + physicalDeviceRayTracingInvocationReorderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.rayTracingInvocationReorder ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & physicalDeviceRayTracingInvocationReorderFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.rayTracingInvocationReorder ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & + physicalDeviceRayTracingInvocationReorderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.rayTracingInvocationReorderReorderingHint ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.maxShaderBindingTableRecordIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & + physicalDeviceRayTracingInvocationReorderPropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.rayTracingInvocationReorderReorderingHint ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & + physicalDeviceRayTracingLinearSweptSpheresFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.spheres ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.linearSweptSpheres ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & physicalDeviceRayTracingMaintenance1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingMaintenance1 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingPipelineTraceRaysIndirect2 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const & physicalDeviceRayTracingMotionBlurFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const & physicalDeviceRayTracingPipelineFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const & physicalDeviceRayTracingPipelinePropertiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & physicalDeviceRayTracingPositionFetchFeaturesKHR ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.rayTracingPositionFetch ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const & physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV const & physicalDeviceRayTracingValidationFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.rayTracingValidation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & physicalDeviceRelaxedLineRasterizationFeaturesIMG ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.relaxedLineRasterization ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM const & physicalDeviceRenderPassStripedFeaturesARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.renderPassStriped ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM const & physicalDeviceRenderPassStripedPropertiesARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.renderPassStripeGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.maxRenderPassStripes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & physicalDeviceRepresentativeFragmentTestFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR const & physicalDeviceRobustness2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.robustBufferAccess2 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.robustImageAccess2 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.nullDescriptor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR const & physicalDeviceRobustness2PropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.robustStorageBufferAccessSizeAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.robustUniformBufferAccessSizeAlignment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const & physicalDeviceSampleLocationsPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize ); + for ( size_t i = 0; i < 2; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const & physicalDeviceSamplerFilterMinmaxProperties ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const & physicalDeviceSamplerYcbcrConversionFeatures ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const & physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM const & physicalDeviceSchedulingControlsFeaturesARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.schedulingControls ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM const & physicalDeviceSchedulingControlsPropertiesARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.schedulingControlsFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & physicalDeviceSeparateDepthStencilLayoutsFeatures ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT const & physicalDeviceShader64BitIndexingFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.shader64BitIndexing ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & physicalDeviceShaderAtomicFloat16VectorFeaturesNV ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.shaderFloat16VectorAtomics ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & physicalDeviceShaderAtomicFloat2FeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const & physicalDeviceShaderAtomicFloatFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const & physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR const & physicalDeviceShaderBfloat16FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16Type ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16DotProduct ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16CooperativeMatrix ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const & physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & physicalDeviceShaderCoreBuiltinsFeaturesARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.shaderCoreBuiltins ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & physicalDeviceShaderCoreBuiltinsPropertiesARM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreMask ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderWarpsPerCore ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const & physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const & physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM const & physicalDeviceShaderCorePropertiesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pixelRate ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.texelRate ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.fmaRate ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & + physicalDeviceShaderDemoteToHelperInvocationFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const & physicalDeviceShaderDrawParametersFeatures ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & + physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.shaderEarlyAndLateFragmentTests ); + return seed; + } + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX const & physicalDeviceShaderEnqueueFeaturesAMDX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.shaderEnqueue ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.shaderMeshEnqueue ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX const & physicalDeviceShaderEnqueuePropertiesAMDX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphDepth ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderOutputNodes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.executionGraphDispatchAddressAlignment ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphWorkgroupCount[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphWorkgroups ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeatures const & physicalDeviceShaderExpectAssumeFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.shaderExpectAssume ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const & physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat8FeaturesEXT const & physicalDeviceShaderFloat8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.shaderFloat8 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.shaderFloat8CooperativeMatrix ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2Features const & physicalDeviceShaderFloatControls2Features ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.shaderFloatControls2 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR const & physicalDeviceShaderFmaFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat64 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const & physicalDeviceShaderImageFootprintFeaturesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures const & physicalDeviceShaderIntegerDotProductFeatures ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.shaderIntegerDotProduct ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties const & physicalDeviceShaderIntegerDotProductProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, + physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT const & physicalDeviceShaderLongVectorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorFeaturesEXT.longVector ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT const & physicalDeviceShaderLongVectorPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorPropertiesEXT.maxVectorComponents ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & physicalDeviceShaderMaximalReconvergenceFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.shaderMaximalReconvergence ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & physicalDeviceShaderModuleIdentifierFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.shaderModuleIdentifier ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & physicalDeviceShaderModuleIdentifierPropertiesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.pNext ); + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.shaderModuleIdentifierAlgorithmUUID[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT const & physicalDeviceShaderObjectFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.shaderObject ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT const & physicalDeviceShaderObjectPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.pNext ); + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryUUID[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryVersion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR const & physicalDeviceShaderQuadControlFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.shaderQuadControl ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & + physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.shaderRelaxedExtendedInstruction ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & physicalDeviceShaderReplicatedCompositesFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.shaderReplicatedComposites ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & physicalDeviceShaderSMBuiltinsPropertiesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & physicalDeviceShaderSubgroupExtendedTypesFeatures ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & physicalDeviceShaderSubgroupPartitionedFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupPartitionedFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupPartitionedFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupPartitionedFeaturesEXT.shaderSubgroupPartitioned ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeatures const & physicalDeviceShaderSubgroupRotateFeatures ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.shaderSubgroupRotate ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.shaderSubgroupRotateClustered ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & + physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures const & physicalDeviceShaderTerminateInvocationFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.shaderTerminateInvocation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT const & physicalDeviceShaderTileImageFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageColorReadAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageDepthReadAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageStencilReadAccess ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT const & physicalDeviceShaderTileImagePropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageCoherentReadAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadSampleFromPixelRateInvocation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadFromHelperInvocation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & + physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.shaderUniformBufferUnsizedArray ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR const & physicalDeviceShaderUntypedPointersFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUntypedPointersFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUntypedPointersFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUntypedPointersFeaturesKHR.shaderUntypedPointers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const & physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const & physicalDeviceShadingRateImagePropertiesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const & physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.format ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.type ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.samples ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.usage ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.tiling ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.subgroupSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedStages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedOperations ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures const & physicalDeviceSubgroupSizeControlFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.subgroupSizeControl ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.computeFullSubgroups ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties const & physicalDeviceSubgroupSizeControlProperties ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.minSubgroupSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxSubgroupSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxComputeWorkgroupSubgroups ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.requiredSubgroupSizeStages ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & physicalDeviceSubpassMergeFeedbackFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.subpassMergeFeedback ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const & physicalDeviceSubpassShadingFeaturesHUAWEI ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const & physicalDeviceSubpassShadingPropertiesHUAWEI ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.surface ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & physicalDeviceSwapchainMaintenance1FeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesKHR.swapchainMaintenance1 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features const & physicalDeviceSynchronization2Features ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.synchronization2 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorFeaturesARM const & physicalDeviceTensorFeaturesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.tensorNonPacked ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.shaderTensorAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.shaderStorageTensorArrayDynamicIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.shaderStorageTensorArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.descriptorBindingStorageTensorUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.tensors ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorPropertiesARM const & physicalDeviceTensorPropertiesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorDimensionCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorElements ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxPerDimensionTensorElements ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorStride ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorShaderAccessArrayLength ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorShaderAccessSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxDescriptorSetStorageTensors ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxPerStageDescriptorSetStorageTensors ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxDescriptorSetUpdateAfterBindStorageTensors ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxPerStageDescriptorUpdateAfterBindStorageTensors ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.shaderStorageTensorArrayNonUniformIndexingNative ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.shaderTensorSupportedStages ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & physicalDeviceTexelBufferAlignmentFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties const & physicalDeviceTexelBufferAlignmentProperties ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & physicalDeviceTextureCompressionASTC3DFeaturesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTC3DFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTC3DFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTC3DFeaturesEXT.textureCompressionASTC_3D ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures const & physicalDeviceTextureCompressionASTCHDRFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.textureCompressionASTC_HDR ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM const & physicalDeviceTileMemoryHeapFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.tileMemoryHeap ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM const & physicalDeviceTileMemoryHeapPropertiesQCOM ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.queueSubmitBoundary ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.tileBufferTransfers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM const & physicalDeviceTilePropertiesFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.tileProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM const & physicalDeviceTileShadingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShading ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingFragmentStage ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingColorAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingDepthAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingStencilAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingInputAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingSampledAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingPerTileDraw ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingPerTileDispatch ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingDispatchTile ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingApron ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingAnisotropicApron ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingAtomicOps ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingImageProcessing ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM const & physicalDeviceTileShadingPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.maxApronSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.preferNonCoherent ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.tileGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.maxTileShadingRate ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const & physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const & physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties const & physicalDeviceToolProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.pNext ); + for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.name[i] ); + } + for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.version[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.purposes ); + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.description[i] ); + } + for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.layer[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const & physicalDeviceTransformFeedbackFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const & physicalDeviceTransformFeedbackPropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & physicalDeviceUnifiedImageLayoutsFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.unifiedImageLayouts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.unifiedImageLayoutsVideo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const & physicalDeviceUniformBufferStandardLayoutFeatures ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const & physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeatures const & physicalDeviceVertexAttributeDivisorFeatures ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.vertexAttributeInstanceRateDivisor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.vertexAttributeInstanceRateZeroDivisor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorProperties const & physicalDeviceVertexAttributeDivisorProperties ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.maxVertexAttribDivisor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.supportsNonZeroFirstInstance ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & physicalDeviceVertexAttributeDivisorPropertiesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & physicalDeviceVertexAttributeRobustnessFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.vertexAttributeRobustness ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & physicalDeviceVertexInputDynamicStateFeaturesEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoDecodeVP9FeaturesKHR const & physicalDeviceVideoDecodeVP9FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoDecodeVP9FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoDecodeVP9FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoDecodeVP9FeaturesKHR.videoDecodeVP9 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR const & physicalDeviceVideoEncodeAV1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.videoEncodeAV1 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & physicalDeviceVideoEncodeIntraRefreshFeaturesKHR ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeIntraRefreshFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeIntraRefreshFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeIntraRefreshFeaturesKHR.videoEncodeIntraRefresh ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const & videoProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.videoCodecOperation ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaSubsampling ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.lumaBitDepth ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaBitDepth ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & physicalDeviceVideoEncodeQualityLevelInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pVideoProfile ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.qualityLevel ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & physicalDeviceVideoEncodeQuantizationMapFeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.videoEncodeQuantizationMap ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & physicalDeviceVideoEncodeRgbConversionFeaturesVALVE ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.videoEncodeRgbConversion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.imageUsage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR const & physicalDeviceVideoMaintenance1FeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.videoMaintenance1 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR const & physicalDeviceVideoMaintenance2FeaturesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.videoMaintenance2 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storagePushConstant16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageInputOutput16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiview ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewGeometryShader ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewTessellationShader ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.protectedMemory ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.samplerYcbcrConversion ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.shaderDrawParameters ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pNext ); + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceUUID[i] ); + } + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.driverUUID[i] ); + } + for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUID[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceNodeMask ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUIDValid ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedStages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pointClippingBehavior ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.protectedNoFault ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.drawIndirectCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storagePushConstant8 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInt8 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.runtimeDescriptorArray ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerFilterMinmax ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.scalarBlockLayout ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.imagelessFramebuffer ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.hostQueryReset ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.timelineSemaphore ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddress ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModel ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputLayer ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverID ); + for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverName[i] ); + } + for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverInfo[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.conformanceVersion ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.denormBehaviorIndependence ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.roundingModeIndependence ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolveNone ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolve ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features const & physicalDeviceVulkan13Features ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.robustImageAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.inlineUniformBlock ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pipelineCreationCacheControl ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.privateData ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderTerminateInvocation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.subgroupSizeControl ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.computeFullSubgroups ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.synchronization2 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.textureCompressionASTC_HDR ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.dynamicRendering ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderIntegerDotProduct ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.maintenance4 ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties const & physicalDeviceVulkan13Properties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.minSubgroupSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxSubgroupSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxComputeWorkgroupSubgroups ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.requiredSubgroupSizeStages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformBlockSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorInlineUniformBlocks ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetInlineUniformBlocks ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformTotalSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetAlignmentBytes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetAlignmentBytes ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxBufferSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Features const & physicalDeviceVulkan14Features ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.globalPriorityQuery ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderSubgroupRotate ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderSubgroupRotateClustered ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderFloatControls2 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderExpectAssume ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.rectangularLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.bresenhamLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.smoothLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledRectangularLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledBresenhamLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledSmoothLines ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.vertexAttributeInstanceRateDivisor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.vertexAttributeInstanceRateZeroDivisor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.indexTypeUint8 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.dynamicRenderingLocalRead ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.maintenance5 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.maintenance6 ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pipelineProtectedAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pipelineRobustness ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.hostImageCopy ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pushDescriptor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Properties const & physicalDeviceVulkan14Properties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.lineSubPixelPrecisionBits ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxVertexAttribDivisor ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.supportsNonZeroFirstInstance ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxPushDescriptors ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.dynamicRenderingLocalReadDepthStencilAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.dynamicRenderingLocalReadMultisampledAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.earlyFragmentMultisampleCoverageAfterSampleCounting ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.earlyFragmentSampleMaskTestBeforeSampleCounting ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.depthStencilSwizzleOneSupport ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.polygonModePointSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.nonStrictSinglePixelWideLinesUseParallelogram ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.nonStrictWideLinesUseParallelogram ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.blockTexelViewCompatibleMultipleLayers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxCombinedImageSamplerDescriptorCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.fragmentShadingRateClampCombinerInputs ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessStorageBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessUniformBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessVertexInputs ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessImages ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.copySrcLayoutCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pCopySrcLayouts ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.copyDstLayoutCount ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pCopyDstLayouts ); + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.optimalTilingLayoutUUID[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.identicalMemoryTypeRequirements ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const & physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & + physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM const & physicalDeviceYcbcrDegammaFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.ycbcrDegamma ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.zeroInitializeDeviceMemory ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & physicalDeviceZeroInitializeWorkgroupMemoryFeatures ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR const & pipelineBinaryKeyKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.keySize ); + for ( size_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.key[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR const & pipelineBinaryDataKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataKHR.dataSize ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataKHR.pData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR const & pipelineBinaryKeysAndDataKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.binaryCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.pPipelineBinaryKeys ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.pPipelineBinaryData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR const & pipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateInfoKHR.pNext ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & pipelineBinaryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pKeysAndDataInfo ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pipeline ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pPipelineCreateInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR const & pipelineBinaryDataInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.pipelineBinary ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR const & pipelineBinaryHandlesInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pipelineBinaryCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pPipelineBinaries ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR const & pipelineBinaryInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.binaryCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.pPipelineBinaries ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.initialDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pInitialData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM const & pipelineCacheHeaderVersionDataGraphQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerSize ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerVersion ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheVersion ); + for ( size_t i = 0; i < VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.toolchainVersion[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerSize ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerVersion ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.vendorID ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.deviceID ); + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const & pipelineColorBlendAdvancedStateCreateInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.attachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const & pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.compilerControlFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const & pipelineCoverageModulationStateCreateInfoNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const & pipelineCoverageReductionStateCreateInfoNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const & pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfo const & pipelineCreateFlags2CreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedback const & pipelineCreationFeedback ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.duration ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo const & pipelineCreationFeedbackCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineCreationFeedback ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pipelineStageCreationFeedbackCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineStageCreationFeedbacks ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const & pipelineDiscardRectangleStateCreateInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pipeline ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.executableIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const & pipelineExecutableInternalRepresentationKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pNext ); + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.name[i] ); + } + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.description[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.isText ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.dataSize ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.stages ); + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.name[i] ); + } + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.description[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.subgroupSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE const & pipelineFragmentDensityMapLayeredCreateInfoVALVE ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.maxFragmentDensityMapLayers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const & pipelineFragmentShadingRateEnumStateCreateInfoNV ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate ); + for ( size_t i = 0; i < 2; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const & pipelineFragmentShadingRateStateCreateInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize ); + for ( size_t i = 0; i < 2; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV const & pipelineIndirectDeviceAddressInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipelineBindPoint ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipeline ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pipeline ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.setLayoutCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pSetLayouts ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pushConstantRangeCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pPushConstantRanges ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT const & pipelinePropertiesIdentifierEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pNext ); + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pipelineIdentifier[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const & pipelineRasterizationConservativeStateCreateInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const & pipelineRasterizationDepthClipStateCreateInfoEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfo const & pipelineRasterizationLineStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineRasterizationMode ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.stippledLineEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineStippleFactor ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineStipplePattern ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const & + pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const & pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const & pipelineRasterizationStateStreamCreateInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo const & pipelineRenderingCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.viewMask ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.colorAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pColorAttachmentFormats ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.depthAttachmentFormat ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.stencilAttachmentFormat ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const & pipelineRepresentativeFragmentTestStateCreateInfoNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfo const & pipelineRobustnessCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.storageBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.uniformBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.vertexInputs ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.images ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const & pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT const & pipelineShaderStageModuleIdentifierCreateInfoEXT ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.identifierSize ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pIdentifier ); + return seed; + } + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX const & pipelineShaderStageNodeCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.pNext ); + for ( const char * p = pipelineShaderStageNodeCreateInfoAMDX.pName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.index ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo const & pipelineShaderStageRequiredSubgroupSizeCreateInfo ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.requiredSubgroupSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const & pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.domainOrigin ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescription const & vertexInputBindingDivisorDescription ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescription.binding ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescription.divisor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfo const & pipelineVertexInputDivisorStateCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.vertexBindingDivisorCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.pVertexBindingDivisors ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT const & pipelineViewportDepthClampControlCreateInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.depthClampMode ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.pDepthClampRange ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const & pipelineViewportDepthClipControlCreateInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const & pipelineViewportExclusiveScissorStateCreateInfoNV ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.shadingRatePaletteEntryCount ); + VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.pShadingRatePaletteEntries ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const & pipelineViewportShadingRateImageStateCreateInfoNV ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.x ); + VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.y ); + VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.z ); + VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.w ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const & pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.flags ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.xcoeff ); + VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.ycoeff ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const & pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount ); + VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_GGP ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.frameToken ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_GGP*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentId2KHR const & presentId2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.swapchainCount ); + VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.pPresentIds ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.swapchainCount ); + VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pPresentIds ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.waitSemaphoreCount ); + VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pWaitSemaphores ); + VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.swapchainCount ); + VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pSwapchains ); + VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pImageIndices ); + VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pResults ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.offset ); + VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.extent ); + VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.layer ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.rectangleCount ); + VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.pRectangles ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.swapchainCount ); + VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.presentID ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.desiredPresentTime ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.swapchainCount ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pTimes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimingInfoEXT const & presentTimingInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.targetTime ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.timeDomainId ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.presentStageQueries ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.targetTimeDomainPresentStage ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimingSurfaceCapabilitiesEXT const & presentTimingSurfaceCapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentTimingSupported ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentAtAbsoluteTimeSupported ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentAtRelativeTimeSupported ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentStageQueries ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimingsInfoEXT const & presentTimingsInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.swapchainCount ); + VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.pTimingInfos ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentWait2InfoKHR const & presentWait2InfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.presentId ); + VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.timeout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & privateDataSlotCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.protectedSubmit ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV const & pushConstantBankInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pushConstantBankInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pushConstantBankInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pushConstantBankInfoNV.bank ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantsInfo const & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.layout ); + VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.stageFlags ); + VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.offset ); + VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.size ); + VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.pValues ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDataInfoEXT const & pushDataInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.offset ); + VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.data ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.sType ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstSet ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstBinding ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstArrayElement ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorCount ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorType ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pImageInfo ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pBufferInfo ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pTexelBufferView ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo const & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.stageFlags ); + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.layout ); + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.set ); + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.descriptorWriteCount ); + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.pDescriptorWrites ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo const & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.descriptorUpdateTemplate ); + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.layout ); + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.set ); + VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.pData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV const & queryLowLatencySupportNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pQueriedLowLatencyData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryType ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryCount ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pipelineStatistics ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const & queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const & queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR const & queryPoolVideoEncodeFeedbackCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.encodeFeedbackFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const & queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const & queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphProcessingEnginePropertiesARM const & queueFamilyDataGraphProcessingEnginePropertiesARM ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.foreignSemaphoreHandleTypes ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.foreignMemoryHandleTypes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphPropertiesARM const & queueFamilyDataGraphPropertiesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.engine ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.operation ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityProperties const & queueFamilyGlobalPriorityProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.priorityCount ); + for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.priorities[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::QueueFamilyOwnershipTransferPropertiesKHR const & queueFamilyOwnershipTransferPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOwnershipTransferPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOwnershipTransferPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOwnershipTransferPropertiesKHR.optimalImageTransferToQueueFamilies ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueFlags ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueCount ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.timestampValidBits ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.minImageTransferGranularity ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.queueFamilyProperties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR const & queueFamilyQueryResultStatusPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.queryResultStatusSupport ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR const & queueFamilyVideoPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.videoCodecOperations ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & + rayTracingPipelineClusterAccelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineClusterAccelerationStructureCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineClusterAccelerationStructureCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineClusterAccelerationStructureCreateInfoNV.allowClusterAccelerationStructure ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const & rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.type ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.generalShader ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const & rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.stageCount ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pStages ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.groupCount ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pGroups ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInterface ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pDynamicState ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.layout ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const & rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.type ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.generalShader ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.closestHitShader ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.anyHitShader ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.intersectionShader ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.flags ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.stageCount ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pStages ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.groupCount ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pGroups ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.layout ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineHandle ); + VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, refreshCycleDurationGOOGLE.refreshDuration ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR const & releaseCapturedPipelineDataInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.pipeline ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoKHR const & releaseSwapchainImagesInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.swapchain ); + VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.imageIndexCount ); + VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.pImageIndices ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.attachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pAttachments ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderPass ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.framebuffer ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderArea ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.clearValueCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pClearValues ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.flags ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pipelineBindPoint ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.inputAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pInputAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.colorAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pColorAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pResolveAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pDepthStencilAttachment ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.preserveAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pPreserveAttachments ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcSubpass ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstSubpass ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dependencyFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.attachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.subpassCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pSubpasses ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.dependencyCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pDependencies ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.flags ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pipelineBindPoint ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.viewMask ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.inputAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pInputAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.colorAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pColorAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pResolveAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pDepthStencilAttachment ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.preserveAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pPreserveAttachments ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcSubpass ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstSubpass ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dependencyFlags ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.viewOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.flags ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.attachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.subpassCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pSubpasses ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.dependencyCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pDependencies ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.correlatedViewMaskCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pCorrelatedViewMasks ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT const & renderPassCreationControlEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.disallowMerging ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT const & renderPassCreationFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackInfoEXT.postMergeSubpassCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT const & renderPassCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pRenderPassFeedback ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const & renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT const & renderPassFragmentDensityMapOffsetEndInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.fragmentDensityOffsetCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pFragmentDensityOffsets ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const & renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pAspectReferences ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.subpassCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewMasks ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.dependencyCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewOffsets ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.correlationMaskCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pCorrelationMasks ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM const & renderPassPerformanceCountersByRegionBeginInfoARM ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.counterAddressCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pCounterAddresses ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.serializeRegions ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.counterIndexCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pCounterIndices ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.subpassIndex ); + VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.sampleLocationsInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const & renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM const & renderPassStripeInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.stripeArea ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM const & renderPassStripeBeginInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.stripeInfoCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pStripeInfos ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo const & semaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.semaphore ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.value ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.stageMask ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.deviceIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM const & renderPassStripeSubmitInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.stripeSemaphoreInfoCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pStripeSemaphoreInfos ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT const & renderPassSubpassFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.subpassMergeStatus ); + for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.description[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.postMergeIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT const & renderPassSubpassFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pSubpassFeedback ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM const & renderPassTileShadingCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.flags ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.tileApronSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.transform ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAreaInfo const & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.viewMask ); + VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.colorAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.pColorAttachmentFormats ); + VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.depthAttachmentFormat ); + VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.stencilAttachmentFormat ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR const & renderingAttachmentFlagsInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo const & renderingAttachmentLocationInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.colorAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.pColorAttachmentLocations ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR const & renderingEndInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoKHR.pNext ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const & renderingFragmentDensityMapAttachmentInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView ); + VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const & renderingFragmentShadingRateAttachmentInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView ); + VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfo const & renderingInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.renderArea ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.layerCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.viewMask ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.colorAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pColorAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pDepthAttachment ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pStencilAttachment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo const & renderingInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.colorAttachmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pColorAttachmentInputIndices ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pDepthInputAttachmentIndex ); + VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pStencilInputAttachmentIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 const & resolveImageInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImage ); + VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImage ); + VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImageLayout ); + VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.regionCount ); + VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR const & resolveImageModeInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.resolveMode ); + VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.stencilResolveMode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT const & texelBufferDescriptorInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.format ); + VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.addressRange ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM const & tensorViewCreateInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.flags ); + VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.tensor ); + VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.format ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM const & samplerBlockMatchWindowCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowExtent ); + VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowCompareMode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const & samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.components ); + VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT const & samplerCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sampler ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM const & samplerCubicWeightsCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.cubicWeights ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT const & samplerCustomBorderColorIndexCreateInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, samplerCustomBorderColorIndexCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCustomBorderColorIndexCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, samplerCustomBorderColorIndexCreateInfoEXT.index ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.reductionMode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.format ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrModel ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrRange ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.components ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.xChromaOffset ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.yChromaOffset ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.chromaFilter ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const & samplerYcbcrConversionImageFormatProperties ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.sType ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.conversion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ) + const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableYDegamma ); + VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableCbCrDegamma ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX const & screenBufferFormatPropertiesQNX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.format ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.externalFormat ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.screenUsage ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.formatFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.samplerYcbcrConversionComponents ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrModel ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrRange ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedXChromaOffset ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYChromaOffset ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX const & screenBufferPropertiesQNX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.allocationSize ); + VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.memoryTypeBits ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.sType ); + VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.flags ); + VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.context ); + VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.window ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.semaphore ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.handleType ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.semaphore ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.handleType ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const & semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.sType ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.semaphore ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.value ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.semaphoreType ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.initialValue ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.semaphoreCount ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pSemaphores ); + VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pValues ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT const & setDescriptorBufferOffsetsInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.stageFlags ); + VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.layout ); + VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.firstSet ); + VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.setCount ); + VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pBufferIndices ); + VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pOffsets ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV const & setLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.presentID ); + VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.marker ); + return seed; + } + }; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SetPresentConfigNV const & setPresentConfigNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.numFramesPerBatch ); + VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.presentConfigFeedback ); + return seed; + } + }; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, setStateFlagsIndirectCommandNV.data ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & shaderCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.stage ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.nextStage ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeType ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeSize ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pCode ); + for ( const char * p = shaderCreateInfoEXT.pName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.setLayoutCount ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSetLayouts ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pushConstantRangeCount ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pPushConstantRanges ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSpecializationInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT const & shaderDescriptorSetAndBindingMappingInfoEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.mappingCount ); + VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.pMappings ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.flags ); + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.codeSize ); + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pCode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT const & shaderModuleIdentifierEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifierSize ); + for ( size_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifier[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const & shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.validationCache ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedVgprs ); + VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedSgprs ); + VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup ); + VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsUsageSizeInBytes ); + VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.scratchMemUsageInBytes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.shaderStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.resourceUsage ); + VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalVgprs ); + VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalSgprs ); + VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableVgprs ); + VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableSgprs ); + for ( size_t i = 0; i < 3; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] ); + } + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const & sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.aspectMask ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.imageGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.properties ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.formatProperties ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailFirstLod ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailSize ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailOffset ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailStride ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.memoryRequirements ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_GGP ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.sType ); + VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.flags ); + VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_GGP*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, submitInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo.waitSemaphoreCount ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitSemaphores ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitDstStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo.commandBufferCount ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pCommandBuffers ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo.signalSemaphoreCount ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pSignalSemaphores ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2 const & submitInfo2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.flags ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.waitSemaphoreInfoCount ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pWaitSemaphoreInfos ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.commandBufferInfoCount ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pCommandBufferInfos ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.signalSemaphoreInfoCount ); + VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pSignalSemaphoreInfos ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.contents ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const & subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.sType ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.depthResolveMode ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.stencilResolveMode ); + VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.pNext ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT const & subpassResolvePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.optimal ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const & subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.sType ); + VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass ); + VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.subpass ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySize const & subresourceHostMemcpySize ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.sType ); + VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout2 const & subresourceLayout2 ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.sType ); + VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.subresourceLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT const & subsampledImageFormatPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, subsampledImageFormatPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, subsampledImageFormatPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, subsampledImageFormatPropertiesEXT.subsampledImageDescriptorCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageCount ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageCount ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentExtent ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageExtent ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageExtent ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageArrayLayers ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedTransforms ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentTransform ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedCompositeAlpha ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedUsageFlags ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedSurfaceCounters ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageCount ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageCount ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentExtent ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageExtent ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageExtent ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageArrayLayers ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedTransforms ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentTransform ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedCompositeAlpha ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedUsageFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.surfaceCapabilities ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const & surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV const & surfaceCapabilitiesPresentBarrierNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.presentBarrierSupported ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentId2KHR const & surfaceCapabilitiesPresentId2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentId2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentId2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentId2KHR.presentId2Supported ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentWait2KHR const & surfaceCapabilitiesPresentWait2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentWait2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentWait2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentWait2KHR.presentWait2Supported ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_OHOS ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS const & surfaceCreateInfoOHOS ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.flags ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.window ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_OHOS*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.format ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.colorSpace ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.surfaceFormat ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const & surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const & surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityKHR const & surfacePresentModeCompatibilityKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.presentModeCount ); + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.pPresentModes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeKHR const & surfacePresentModeKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeKHR.presentMode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesKHR const & surfacePresentScalingCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.supportedPresentScaling ); + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.supportedPresentGravityX ); + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.supportedPresentGravityY ); + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.minScaledImageExtent ); + VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.maxScaledImageExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.supportsProtected ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCalibratedTimestampInfoEXT const & swapchainCalibratedTimestampInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.swapchain ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.presentStage ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.timeDomainId ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.surfaceCounters ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.surface ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.minImageCount ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageFormat ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageColorSpace ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageExtent ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageArrayLayers ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageUsage ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageSharingMode ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.queueFamilyIndexCount ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pQueueFamilyIndices ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.preTransform ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.compositeAlpha ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.presentMode ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.clipped ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.oldSwapchain ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const & swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV const & swapchainLatencyCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.latencyModeEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV const & swapchainPresentBarrierCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.presentBarrierEnable ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoKHR const & swapchainPresentFenceInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.swapchainCount ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.pFences ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoKHR const & swapchainPresentModeInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.swapchainCount ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.pPresentModes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoKHR const & swapchainPresentModesCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.presentModeCount ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.pPresentModes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoKHR const & swapchainPresentScalingCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.scalingBehavior ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.presentGravityX ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.presentGravityY ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainTimeDomainPropertiesEXT const & swapchainTimeDomainPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.timeDomainCount ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.pTimeDomains ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.pTimeDomainIds ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainTimingPropertiesEXT const & swapchainTimingPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.refreshDuration ); + VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.refreshInterval ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorCaptureDescriptorDataInfoARM const & tensorCaptureDescriptorDataInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tensorCaptureDescriptorDataInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCaptureDescriptorDataInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tensorCaptureDescriptorDataInfoARM.tensor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorMemoryBarrierARM const & tensorMemoryBarrierARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.srcStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.srcAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.dstStageMask ); + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.dstAccessMask ); + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.srcQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.dstQueueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.tensor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorDependencyInfoARM const & tensorDependencyInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.tensorMemoryBarrierCount ); + VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.pTensorMemoryBarriers ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorFormatPropertiesARM const & tensorFormatPropertiesARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.optimalTilingTensorFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.linearTilingTensorFeatures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM const & tensorMemoryRequirementsInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryRequirementsInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryRequirementsInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryRequirementsInfoARM.tensor ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM const & tensorViewCaptureDescriptorDataInfoARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tensorViewCaptureDescriptorDataInfoARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tensorViewCaptureDescriptorDataInfoARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tensorViewCaptureDescriptorDataInfoARM.tensorView ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const & textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.sType ); + VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM const & tileMemoryBindInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.memory ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM const & tileMemoryRequirementsQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.size ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.alignment ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM const & tileMemorySizeInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.size ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TilePropertiesQCOM const & tilePropertiesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.tileSize ); + VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.apronSize ); + VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.origin ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.sType ); + VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount ); + VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues ); + VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount ); + VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR const & traceRaysIndirectCommand2KHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordAddress ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordSize ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableAddress ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableSize ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableStride ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableAddress ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableSize ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableStride ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableAddress ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableSize ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableStride ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.width ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.height ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.depth ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.width ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.height ); + VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.depth ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.initialDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pInitialData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.enabledValidationFeatureCount ); + VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pEnabledValidationFeatures ); + VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.disabledValidationFeatureCount ); + VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pDisabledValidationFeatures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.disabledValidationCheckCount ); + VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pDisabledValidationChecks ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const & vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.location ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.binding ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.format ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.offset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const & vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.binding ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.stride ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.inputRate ); + VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.divisor ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_VI_NN ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.sType ); + VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.flags ); + VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.window ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_VI_NN*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & videoPictureResourceInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedOffset ); + VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedExtent ); + VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.baseArrayLayer ); + VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.imageViewBinding ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR const & videoReferenceSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.slotIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pPictureResource ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSession ); + VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSessionParameters ); + VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.referenceSlotCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pReferenceSlots ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pictureAccessGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minCodedExtent ); + VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxCodedExtent ); + VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxDpbSlots ); + VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxActiveReferencePictures ); + VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.stdHeaderVersion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR const & videoDecodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.maxLevel ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR const & videoDecodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pStdReferenceInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR const & videoDecodeAV1InlineSessionParametersInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.pStdSequenceHeader ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR const & videoDecodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pStdPictureInfo ); + for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.referenceNameSlotIndices[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.frameHeaderOffset ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.tileCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileOffsets ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileSizes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR const & videoDecodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.stdProfile ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.filmGrainSupport ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR const & videoDecodeAV1SessionParametersCreateInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR const & videoDecodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR const & videoDecodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.maxLevelIdc ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.fieldOffsetGranularity ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR const & videoDecodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pStdReferenceInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR const & videoDecodeH264InlineSessionParametersInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pStdSPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pStdPPS ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR const & videoDecodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pStdPictureInfo ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sliceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pSliceOffsets ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR const & videoDecodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.stdProfileIdc ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pictureLayout ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR const & videoDecodeH264SessionParametersAddInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdSPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdSPSs ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdPPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdPPSs ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR const & videoDecodeH264SessionParametersCreateInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdSPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdPPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pParametersAddInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR const & videoDecodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.maxLevelIdc ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR const & videoDecodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pStdReferenceInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR const & videoDecodeH265InlineSessionParametersInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdVPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdSPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdPPS ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR const & videoDecodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pStdPictureInfo ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sliceSegmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pSliceSegmentOffsets ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR const & videoDecodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.stdProfileIdc ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR const & videoDecodeH265SessionParametersAddInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdVPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdVPSs ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdSPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdSPSs ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdPPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdPPSs ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR const & videoDecodeH265SessionParametersCreateInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdVPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdSPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdPPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pParametersAddInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferOffset ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferRange ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.dstPictureResource ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pSetupReferenceSlot ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.referenceSlotCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pReferenceSlots ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR const & videoDecodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.videoUsageHints ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeVP9CapabilitiesKHR const & videoDecodeVP9CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9CapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9CapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9CapabilitiesKHR.maxLevel ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeVP9PictureInfoKHR const & videoDecodeVP9PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.pStdPictureInfo ); + for ( size_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.referenceNameSlotIndices[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.uncompressedHeaderOffset ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.compressedHeaderOffset ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.tilesOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeVP9ProfileInfoKHR const & videoDecodeVP9ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9ProfileInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9ProfileInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9ProfileInfoKHR.stdProfile ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR const & videoEncodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxLevel ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.codedPictureAlignment ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTiles ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.minTileSize ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTileSize ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.superblockSizes ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxSingleReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.singleReferenceNameMask ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxUnidirectionalCompoundReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxUnidirectionalCompoundGroup1ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.unidirectionalCompoundReferenceNameMask ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundGroup1ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundGroup2ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.bidirectionalCompoundReferenceNameMask ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTemporalLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxSpatialLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxOperatingPoints ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.minQIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxQIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.prefersGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.requiresGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.stdSyntaxFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR const & videoEncodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.pStdReferenceInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR const & videoEncodeAV1FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.intraFrameSize ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.predictiveFrameSize ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.bipredictiveFrameSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR const & videoEncodeAV1GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.useGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingIntra ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingPredictive ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingBipredictive ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR const & videoEncodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.predictionMode ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.rateControlGroup ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.constantQIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.pStdPictureInfo ); + for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.referenceNameSlotIndices[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.primaryReferenceCdfOnly ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.generateObuExtensionHeader ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR const & videoEncodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.stdProfile ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR const & videoEncodeAV1QIndexKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.intraQIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.predictiveQIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.bipredictiveQIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR const & videoEncodeAV1QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredRateControlFlags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredGopFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredKeyFramePeriod ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredConsecutiveBipredictiveFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredTemporalLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredConstantQIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxSingleReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredSingleReferenceNameMask ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxUnidirectionalCompoundReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxUnidirectionalCompoundGroup1ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredUnidirectionalCompoundReferenceNameMask ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundGroup1ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundGroup2ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredBidirectionalCompoundReferenceNameMask ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR const & videoEncodeAV1QuantizationMapCapabilitiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.minQIndexDelta ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.maxQIndexDelta ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR const & videoEncodeAV1RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.gopFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.keyFramePeriod ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.consecutiveBipredictiveFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.temporalLayerCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR const & videoEncodeAV1RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMinQIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.minQIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMaxQIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.maxQIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMaxFrameSize ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.maxFrameSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR const & videoEncodeAV1SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.useMaxLevel ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.maxLevel ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR const & videoEncodeAV1SessionParametersCreateInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdDecoderModelInfo ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.stdOperatingPointCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdOperatingPoints ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR const & videoEncodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlModes ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxRateControlLayers ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxBitrate ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxQualityLevels ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.encodeInputPictureGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.supportedEncodeFeedbackFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR const & videoEncodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxLevelIdc ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxSliceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxPPictureL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxBPictureL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxL1ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxTemporalLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.expectDyadicTemporalLayerPattern ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.minQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.prefersGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.requiresGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.stdSyntaxFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR const & videoEncodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pStdReferenceInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR const & videoEncodeH264FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameISize ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.framePSize ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameBSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR const & videoEncodeH264GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.useGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingI ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingP ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingB ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR const & videoEncodeH264NaluSliceInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.constantQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pStdSliceHeader ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR const & videoEncodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.naluSliceEntryCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNaluSliceEntries ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pStdPictureInfo ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.generatePrefixNalu ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR const & videoEncodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.stdProfileIdc ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR const & videoEncodeH264QpKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpI ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpP ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpB ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR const & videoEncodeH264QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredRateControlFlags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredGopFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredIdrPeriod ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredTemporalLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConstantQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredStdEntropyCodingModeFlag ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR const & videoEncodeH264QuantizationMapCapabilitiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.minQpDelta ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.maxQpDelta ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR const & videoEncodeH264RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.gopFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.idrPeriod ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.consecutiveBFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.temporalLayerCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR const & videoEncodeH264RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMinQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.minQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxFrameSize ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxFrameSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR const & videoEncodeH264SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.useMaxLevelIdc ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.maxLevelIdc ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR const & videoEncodeH264SessionParametersAddInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdSPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdSPSs ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdPPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdPPSs ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR const & videoEncodeH264SessionParametersCreateInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdSPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdPPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pParametersAddInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR const & videoEncodeH264SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdSPSOverrides ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdPPSOverrides ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR const & videoEncodeH264SessionParametersGetInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdSPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdPPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdSPSId ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdPPSId ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR const & videoEncodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxLevelIdc ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSliceSegmentCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxTiles ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.ctbSizes ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.transformBlockSizes ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxPPictureL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxBPictureL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxL1ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSubLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.expectDyadicTemporalSubLayerPattern ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.minQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.prefersGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.requiresGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.stdSyntaxFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR const & videoEncodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pStdReferenceInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR const & videoEncodeH265FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameISize ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.framePSize ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameBSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR const & videoEncodeH265GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.useGopRemainingFrames ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingI ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingP ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingB ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR const & videoEncodeH265NaluSliceSegmentInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.constantQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pStdSliceSegmentHeader ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR const & videoEncodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.naluSliceSegmentEntryCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNaluSliceSegmentEntries ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pStdPictureInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR const & videoEncodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.stdProfileIdc ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR const & videoEncodeH265QpKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpI ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpP ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpB ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR const & videoEncodeH265QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredRateControlFlags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredGopFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredIdrPeriod ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredSubLayerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConstantQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR const & videoEncodeH265QuantizationMapCapabilitiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.minQpDelta ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.maxQpDelta ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR const & videoEncodeH265RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.gopFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.idrPeriod ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.consecutiveBFrameCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.subLayerCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR const & videoEncodeH265RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMinQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.minQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxQp ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxFrameSize ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxFrameSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR const & videoEncodeH265SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.useMaxLevelIdc ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.maxLevelIdc ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR const & videoEncodeH265SessionParametersAddInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdVPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdVPSs ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdSPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdSPSs ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdPPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdPPSs ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR const & videoEncodeH265SessionParametersCreateInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdVPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdSPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdPPSCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pParametersAddInfo ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( + VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR const & videoEncodeH265SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdVPSOverrides ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdSPSOverrides ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdPPSOverrides ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR const & videoEncodeH265SessionParametersGetInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdVPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdSPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdPPS ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdVPSId ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdSPSId ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdPPSId ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBuffer ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferOffset ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferRange ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.srcPictureResource ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pSetupReferenceSlot ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.referenceSlotCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pReferenceSlots ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshCapabilitiesKHR const & videoEncodeIntraRefreshCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.intraRefreshModes ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.maxIntraRefreshCycleDuration ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.maxIntraRefreshActiveReferencePictures ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.partitionIndependentIntraRefreshRegions ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.nonRectangularIntraRefreshRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshInfoKHR const & videoEncodeIntraRefreshInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.intraRefreshCycleDuration ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.intraRefreshIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE const & videoEncodeProfileRgbConversionInfoVALVE ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.performEncodeRgbConversion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR const & videoEncodeQualityLevelInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.qualityLevel ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR const & videoEncodeQualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlMode ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlLayerCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR const & videoEncodeQuantizationMapCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.maxQuantizationMapExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR const & videoEncodeQuantizationMapInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.quantizationMap ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.quantizationMapExtent ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & + videoEncodeQuantizationMapSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.quantizationMapTexelSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const & videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.averageBitrate ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.maxBitrate ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.rateControlMode ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.layerCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pLayers ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.virtualBufferSizeInMs ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.initialVirtualBufferSizeInMs ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE const & videoEncodeRgbConversionCapabilitiesVALVE ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.rgbModels ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.rgbRanges ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.xChromaOffsets ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.yChromaOffsets ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionIntraRefreshCreateInfoKHR const & videoEncodeSessionIntraRefreshCreateInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionIntraRefreshCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionIntraRefreshCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionIntraRefreshCreateInfoKHR.intraRefreshMode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR const & videoEncodeSessionParametersFeedbackInfoKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.hasOverrides ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR const & videoEncodeSessionParametersGetInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.videoSessionParameters ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE const & videoEncodeSessionRgbConversionCreateInfoVALVE ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.rgbModel ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.rgbRange ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.xChromaOffset ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.yChromaOffset ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR const & videoEncodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoUsageHints ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoContentHints ); + VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.tuningMode ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.flags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR const & videoFormatAV1QuantizationMapPropertiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.compatibleSuperblockSizes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR const & videoFormatH265QuantizationMapPropertiesKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.compatibleCtbSizes ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.format ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.componentMapping ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageCreateFlags ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageType ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageTiling ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageUsageFlags ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR const & videoFormatQuantizationMapPropertiesKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.quantizationMapTexelSize ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR const & videoInlineQueryInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryPool ); + VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.firstQuery ); + VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryCount ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR const & videoProfileListInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.profileCount ); + VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pProfiles ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceIntraRefreshInfoKHR const & videoReferenceIntraRefreshInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoReferenceIntraRefreshInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoReferenceIntraRefreshInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoReferenceIntraRefreshInfoKHR.dirtyIntraRefreshRegions ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.queueFamilyIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pVideoProfile ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pictureFormat ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxCodedExtent ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.referencePictureFormat ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxDpbSlots ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxActiveReferencePictures ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pStdHeaderVersion ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR const & videoSessionMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryBindIndex ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryRequirements ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSession ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const & videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.display ); + VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.surface ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const & win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const & win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs ); + VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hinstance ); + VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hwnd ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const & writeDescriptorSetAccelerationStructureKHR ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const & writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pAccelerationStructures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock const & writeDescriptorSetInlineUniformBlock ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.sType ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.dataSize ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pData ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV const & + writeDescriptorSetPartitionedAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.accelerationStructureCount ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.pAccelerationStructures ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetTensorARM const & writeDescriptorSetTensorARM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.tensorViewCount ); + VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.pTensorViews ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetPipelineEXT const & writeIndirectExecutionSetPipelineEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.index ); + VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.pipeline ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT const & writeIndirectExecutionSetShaderEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.index ); + VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.shader ); + return seed; + } + }; + +# if defined( VK_USE_PLATFORM_XCB_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.connection ); + VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.window ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_XCB_KHR*/ + +# if defined( VK_USE_PLATFORM_XLIB_KHR ) + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.sType ); + VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.flags ); + VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.dpy ); + VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.window ); + return seed; + } + }; +# endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#endif // 14 <= VULKAN_HPP_CPP_VERSION + +} // namespace std +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_hpp_macros.hpp b/lib/vulkan-headers/include/vulkan/vulkan_hpp_macros.hpp new file mode 100644 index 00000000000..ec96c1d63a0 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_hpp_macros.hpp @@ -0,0 +1,337 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_HPP_MACROS_HPP +#define VULKAN_HPP_MACROS_HPP + +#if defined( _MSVC_LANG ) +# define VULKAN_HPP_CPLUSPLUS _MSVC_LANG +#else +# define VULKAN_HPP_CPLUSPLUS __cplusplus +#endif + +#if 202002L < VULKAN_HPP_CPLUSPLUS +# define VULKAN_HPP_CPP_VERSION 23 +#elif 201703L < VULKAN_HPP_CPLUSPLUS +# define VULKAN_HPP_CPP_VERSION 20 +#elif 201402L < VULKAN_HPP_CPLUSPLUS +# define VULKAN_HPP_CPP_VERSION 17 +#elif 201103L < VULKAN_HPP_CPLUSPLUS +# define VULKAN_HPP_CPP_VERSION 14 +#elif 199711L < VULKAN_HPP_CPLUSPLUS +# define VULKAN_HPP_CPP_VERSION 11 +#else +# error "vulkan.hpp needs at least c++ standard version 11" +#endif + +// include headers holding feature-test macros +#if 20 <= VULKAN_HPP_CPP_VERSION +# include +#else +# include +#endif + +#define VULKAN_HPP_STRINGIFY2( text ) #text +#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text ) +#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE ) + +#if defined( __clang__ ) || defined( __GNUC__ ) || defined( __GNUG__ ) +# define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( GCC warning text ) ) +#elif defined( _MSC_VER ) +# define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( message( __FILE__ "(" VULKAN_HPP_STRINGIFY( __LINE__ ) "): warning: " text ) ) ) +#else +# define VULKAN_HPP_COMPILE_WARNING( text ) +#endif + +#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) +# if !defined( VULKAN_HPP_NO_SMART_HANDLE ) +# define VULKAN_HPP_NO_SMART_HANDLE +# endif +#endif + +#if defined( VULKAN_HPP_NO_CONSTRUCTORS ) +# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) +# define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS +# endif +# if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) +# define VULKAN_HPP_NO_UNION_CONSTRUCTORS +# endif +#endif + +#if defined( VULKAN_HPP_NO_SETTERS ) +# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) +# define VULKAN_HPP_NO_STRUCT_SETTERS +# endif +# if !defined( VULKAN_HPP_NO_UNION_SETTERS ) +# define VULKAN_HPP_NO_UNION_SETTERS +# endif +#endif + +#if !defined( VULKAN_HPP_ASSERT ) +# define VULKAN_HPP_ASSERT assert +#endif + +#if !defined( VULKAN_HPP_ASSERT_ON_RESULT ) +# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT +#endif + +#if !defined( VULKAN_HPP_STATIC_ASSERT ) +# define VULKAN_HPP_STATIC_ASSERT static_assert +#endif + +#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL ) +# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1 +#endif + +#if !defined( __has_include ) +# define __has_include( x ) false +#endif + +#if defined( __cpp_lib_three_way_comparison ) && ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR ) +# define VULKAN_HPP_HAS_SPACESHIP_OPERATOR +#endif + +#if defined( __cpp_lib_span ) && ( 201803 <= __cpp_lib_span ) +# define VULKAN_HPP_SUPPORT_SPAN +#endif + +#if defined( VULKAN_HPP_CXX_MODULE ) && !( defined( __cpp_modules ) && defined( __cpp_lib_modules ) ) +VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ named modules and the standard library module." ) +#endif + +#ifndef VK_USE_64_BIT_PTR_DEFINES +# if defined( __LP64__ ) || defined( _WIN64 ) || ( defined( __x86_64__ ) && !defined( __ILP32__ ) ) || defined( _M_X64 ) || defined( __ia64 ) || \ + defined( _M_IA64 ) || defined( __aarch64__ ) || defined( __powerpc64__ ) || ( defined( __riscv ) && __riscv_xlen == 64 ) +# define VK_USE_64_BIT_PTR_DEFINES 1 +# else +# define VK_USE_64_BIT_PTR_DEFINES 0 +# endif +#endif + +// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default. +// To enable this feature on 32-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 1 +// To disable this feature on 64-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 0 +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) +# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION ) +# define VULKAN_HPP_TYPESAFE_CONVERSION 1 +# endif +#endif + +#if defined( __GNUC__ ) +# define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ ) +#endif + +#if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS ) +# if defined( __clang__ ) +# if __has_feature( cxx_unrestricted_unions ) +# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS +# endif +# elif defined( __GNUC__ ) +# if 40600 <= GCC_VERSION +# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS +# endif +# elif defined( _MSC_VER ) +# if 1900 <= _MSC_VER +# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS +# endif +# endif +#endif + +#if !defined( VULKAN_HPP_INLINE ) +# if defined( __clang__ ) +# if __has_attribute( always_inline ) +# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__ +# else +# define VULKAN_HPP_INLINE inline +# endif +# elif defined( __GNUC__ ) +# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__ +# elif defined( _MSC_VER ) +# define VULKAN_HPP_INLINE inline +# else +# define VULKAN_HPP_INLINE inline +# endif +#endif + +#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) +# define VULKAN_HPP_TYPESAFE_EXPLICIT +#else +# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit +#endif + +#if defined( __cpp_constexpr ) +# define VULKAN_HPP_CONSTEXPR constexpr +# if 201304 <= __cpp_constexpr +# define VULKAN_HPP_CONSTEXPR_14 constexpr +# else +# define VULKAN_HPP_CONSTEXPR_14 +# endif +# if 201603 <= __cpp_constexpr +# define VULKAN_HPP_CONSTEXPR_17 constexpr +# else +# define VULKAN_HPP_CONSTEXPR_17 +# endif +# if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) ) +# define VULKAN_HPP_CONSTEXPR_20 constexpr +# else +# define VULKAN_HPP_CONSTEXPR_20 +# endif +# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr +#else +# define VULKAN_HPP_CONSTEXPR +# define VULKAN_HPP_CONSTEXPR_14 +# define VULKAN_HPP_CONST_OR_CONSTEXPR const +#endif + +#if !defined( VULKAN_HPP_CONSTEXPR_INLINE ) +# if 201606L <= __cpp_inline_variables +# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR inline +# else +# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR +# endif +#endif + +#if !defined( VULKAN_HPP_NOEXCEPT ) +# if defined( _MSC_VER ) && ( _MSC_VER <= 1800 ) +# define VULKAN_HPP_NOEXCEPT +# else +# define VULKAN_HPP_NOEXCEPT noexcept +# define VULKAN_HPP_HAS_NOEXCEPT 1 +# if defined( VULKAN_HPP_NO_EXCEPTIONS ) +# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept +# else +# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS +# endif +# endif +#endif + +#if 14 <= VULKAN_HPP_CPP_VERSION +# define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]] +#else +# define VULKAN_HPP_DEPRECATED( msg ) +#endif + +#if 17 <= VULKAN_HPP_CPP_VERSION +# define VULKAN_HPP_DEPRECATED_17( msg ) [[deprecated( msg )]] +#else +# define VULKAN_HPP_DEPRECATED_17( msg ) +#endif + +#if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS ) +# define VULKAN_HPP_NODISCARD [[nodiscard]] +# if defined( VULKAN_HPP_NO_EXCEPTIONS ) +# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]] +# else +# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS +# endif +#else +# define VULKAN_HPP_NODISCARD +# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS +#endif + +#if !defined( VULKAN_HPP_NAMESPACE ) +# define VULKAN_HPP_NAMESPACE vk +#endif + +#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC ) +# if defined( VK_NO_PROTOTYPES ) +# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1 +# else +# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0 +# endif +#endif + +#if !defined( VULKAN_HPP_STORAGE_API ) +# if defined( VULKAN_HPP_STORAGE_SHARED ) +# if defined( _MSC_VER ) +# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT ) +# define VULKAN_HPP_STORAGE_API __declspec( dllexport ) +# else +# define VULKAN_HPP_STORAGE_API __declspec( dllimport ) +# endif +# elif defined( __clang__ ) || defined( __GNUC__ ) +# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT ) +# define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) ) +# else +# define VULKAN_HPP_STORAGE_API +# endif +# else +# define VULKAN_HPP_STORAGE_API +# pragma warning Unknown import / export semantics +# endif +# else +# define VULKAN_HPP_STORAGE_API +# endif +#endif + +namespace VULKAN_HPP_NAMESPACE +{ + namespace detail + { + class DispatchLoaderDynamic; + +#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER ) +# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 + extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; +# endif +#endif + } // namespace detail +} // namespace VULKAN_HPP_NAMESPACE + +#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC_TYPE ) +# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC_TYPE VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic +#endif +#if !defined( VULKAN_HPP_DISPATCH_LOADER_STATIC_TYPE ) +# define VULKAN_HPP_DISPATCH_LOADER_STATIC_TYPE VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic +#endif + +#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ) +# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 +# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE VULKAN_HPP_DISPATCH_LOADER_DYNAMIC_TYPE +# else +# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE VULKAN_HPP_DISPATCH_LOADER_STATIC_TYPE +# endif +#endif + +#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER ) +# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 +# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::detail::defaultDispatchLoaderDynamic +# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE \ + namespace VULKAN_HPP_NAMESPACE \ + { \ + namespace detail \ + { \ + VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \ + } \ + } +# else +# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic() +# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE +# endif +#endif + +#if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER ) +# define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment ) +#else +# define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment ) = assignment +#endif +#define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT VULKAN_HPP_DEFAULT_ASSIGNMENT( VULKAN_HPP_DEFAULT_DISPATCHER ) + +#if !defined( VULKAN_HPP_EXPECTED ) && ( 23 <= VULKAN_HPP_CPP_VERSION ) && defined( __cpp_lib_expected ) && defined( VULKAN_HPP_USE_STD_EXPECTED ) +# if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) ) +# include +# endif +# define VULKAN_HPP_EXPECTED std::expected +# define VULKAN_HPP_UNEXPECTED std::unexpected +#endif + +#if !defined( VULKAN_HPP_RAII_NAMESPACE ) +# define VULKAN_HPP_RAII_NAMESPACE raii +# define VULKAN_HPP_RAII_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE ) +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_ios.h b/lib/vulkan-headers/include/vulkan/vulkan_ios.h new file mode 100644 index 00000000000..089991a4f60 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_ios.h @@ -0,0 +1,50 @@ +#ifndef VULKAN_IOS_H_ +#define VULKAN_IOS_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_MVK_ios_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_MVK_ios_surface 1 +#define VK_MVK_IOS_SURFACE_SPEC_VERSION 3 +#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" +typedef VkFlags VkIOSSurfaceCreateFlagsMVK; +typedef struct VkIOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkIOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkIOSSurfaceCreateInfoMVK; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( + VkInstance instance, + const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_macos.h b/lib/vulkan-headers/include/vulkan/vulkan_macos.h new file mode 100644 index 00000000000..7d5d8a1b31a --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_macos.h @@ -0,0 +1,50 @@ +#ifndef VULKAN_MACOS_H_ +#define VULKAN_MACOS_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_MVK_macos_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_MVK_macos_surface 1 +#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 3 +#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" +typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; +typedef struct VkMacOSSurfaceCreateInfoMVK { + VkStructureType sType; + const void* pNext; + VkMacOSSurfaceCreateFlagsMVK flags; + const void* pView; +} VkMacOSSurfaceCreateInfoMVK; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( + VkInstance instance, + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_metal.h b/lib/vulkan-headers/include/vulkan/vulkan_metal.h new file mode 100644 index 00000000000..501c3638861 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_metal.h @@ -0,0 +1,244 @@ +#ifndef VULKAN_METAL_H_ +#define VULKAN_METAL_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_EXT_metal_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_metal_surface 1 +#ifdef __OBJC__ +@class CAMetalLayer; +#else +typedef void CAMetalLayer; +#endif + +#define VK_EXT_METAL_SURFACE_SPEC_VERSION 1 +#define VK_EXT_METAL_SURFACE_EXTENSION_NAME "VK_EXT_metal_surface" +typedef VkFlags VkMetalSurfaceCreateFlagsEXT; +typedef struct VkMetalSurfaceCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkMetalSurfaceCreateFlagsEXT flags; + const CAMetalLayer* pLayer; +} VkMetalSurfaceCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT( + VkInstance instance, + const VkMetalSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif + + +// VK_EXT_metal_objects is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_metal_objects 1 +#ifdef __OBJC__ +@protocol MTLDevice; +typedef __unsafe_unretained id MTLDevice_id; +#else +typedef void* MTLDevice_id; +#endif + +#ifdef __OBJC__ +@protocol MTLCommandQueue; +typedef __unsafe_unretained id MTLCommandQueue_id; +#else +typedef void* MTLCommandQueue_id; +#endif + +#ifdef __OBJC__ +@protocol MTLBuffer; +typedef __unsafe_unretained id MTLBuffer_id; +#else +typedef void* MTLBuffer_id; +#endif + +#ifdef __OBJC__ +@protocol MTLTexture; +typedef __unsafe_unretained id MTLTexture_id; +#else +typedef void* MTLTexture_id; +#endif + +typedef struct __IOSurface* IOSurfaceRef; +#ifdef __OBJC__ +@protocol MTLSharedEvent; +typedef __unsafe_unretained id MTLSharedEvent_id; +#else +typedef void* MTLSharedEvent_id; +#endif + +#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 2 +#define VK_EXT_METAL_OBJECTS_EXTENSION_NAME "VK_EXT_metal_objects" + +typedef enum VkExportMetalObjectTypeFlagBitsEXT { + VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT = 0x00000001, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT = 0x00000002, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT = 0x00000004, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT = 0x00000008, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT = 0x00000010, + VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT = 0x00000020, + VK_EXPORT_METAL_OBJECT_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkExportMetalObjectTypeFlagBitsEXT; +typedef VkFlags VkExportMetalObjectTypeFlagsEXT; +typedef struct VkExportMetalObjectCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkExportMetalObjectTypeFlagBitsEXT exportObjectType; +} VkExportMetalObjectCreateInfoEXT; + +typedef struct VkExportMetalObjectsInfoEXT { + VkStructureType sType; + const void* pNext; +} VkExportMetalObjectsInfoEXT; + +typedef struct VkExportMetalDeviceInfoEXT { + VkStructureType sType; + const void* pNext; + MTLDevice_id mtlDevice; +} VkExportMetalDeviceInfoEXT; + +typedef struct VkExportMetalCommandQueueInfoEXT { + VkStructureType sType; + const void* pNext; + VkQueue queue; + MTLCommandQueue_id mtlCommandQueue; +} VkExportMetalCommandQueueInfoEXT; + +typedef struct VkExportMetalBufferInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + MTLBuffer_id mtlBuffer; +} VkExportMetalBufferInfoEXT; + +typedef struct VkImportMetalBufferInfoEXT { + VkStructureType sType; + const void* pNext; + MTLBuffer_id mtlBuffer; +} VkImportMetalBufferInfoEXT; + +typedef struct VkExportMetalTextureInfoEXT { + VkStructureType sType; + const void* pNext; + VkImage image; + VkImageView imageView; + VkBufferView bufferView; + VkImageAspectFlagBits plane; + MTLTexture_id mtlTexture; +} VkExportMetalTextureInfoEXT; + +typedef struct VkImportMetalTextureInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits plane; + MTLTexture_id mtlTexture; +} VkImportMetalTextureInfoEXT; + +typedef struct VkExportMetalIOSurfaceInfoEXT { + VkStructureType sType; + const void* pNext; + VkImage image; + IOSurfaceRef ioSurface; +} VkExportMetalIOSurfaceInfoEXT; + +typedef struct VkImportMetalIOSurfaceInfoEXT { + VkStructureType sType; + const void* pNext; + IOSurfaceRef ioSurface; +} VkImportMetalIOSurfaceInfoEXT; + +typedef struct VkExportMetalSharedEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkEvent event; + MTLSharedEvent_id mtlSharedEvent; +} VkExportMetalSharedEventInfoEXT; + +typedef struct VkImportMetalSharedEventInfoEXT { + VkStructureType sType; + const void* pNext; + MTLSharedEvent_id mtlSharedEvent; +} VkImportMetalSharedEventInfoEXT; + +typedef void (VKAPI_PTR *PFN_vkExportMetalObjectsEXT)(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT( + VkDevice device, + VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); +#endif +#endif + + +// VK_EXT_external_memory_metal is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_external_memory_metal 1 +#define VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION 1 +#define VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME "VK_EXT_external_memory_metal" +typedef struct VkImportMemoryMetalHandleInfoEXT { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + void* handle; +} VkImportMemoryMetalHandleInfoEXT; + +typedef struct VkMemoryMetalHandlePropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryMetalHandlePropertiesEXT; + +typedef struct VkMemoryGetMetalHandleInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetMetalHandleInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandleEXT)(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandlePropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT( + VkDevice device, + const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, + void** pHandle); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void* pHandle, + VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_ohos.h b/lib/vulkan-headers/include/vulkan/vulkan_ohos.h new file mode 100644 index 00000000000..3bde0114f5a --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_ohos.h @@ -0,0 +1,120 @@ +#ifndef VULKAN_OHOS_H_ +#define VULKAN_OHOS_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_OHOS_external_memory is a preprocessor guard. Do not pass it to API calls. +#define VK_OHOS_external_memory 1 +struct OH_NativeBuffer; +#define VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION 1 +#define VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME "VK_OHOS_external_memory" +typedef struct VkNativeBufferUsageOHOS { + VkStructureType sType; + void* pNext; + uint64_t OHOSNativeBufferUsage; +} VkNativeBufferUsageOHOS; + +typedef struct VkNativeBufferPropertiesOHOS { + VkStructureType sType; + void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; +} VkNativeBufferPropertiesOHOS; + +typedef struct VkNativeBufferFormatPropertiesOHOS { + VkStructureType sType; + void* pNext; + VkFormat format; + uint64_t externalFormat; + VkFormatFeatureFlags formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; +} VkNativeBufferFormatPropertiesOHOS; + +typedef struct VkImportNativeBufferInfoOHOS { + VkStructureType sType; + const void* pNext; + struct OH_NativeBuffer* buffer; +} VkImportNativeBufferInfoOHOS; + +typedef struct VkMemoryGetNativeBufferInfoOHOS { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkMemoryGetNativeBufferInfoOHOS; + +typedef struct VkExternalFormatOHOS { + VkStructureType sType; + void* pNext; + uint64_t externalFormat; +} VkExternalFormatOHOS; + +typedef VkResult (VKAPI_PTR *PFN_vkGetNativeBufferPropertiesOHOS)(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryNativeBufferOHOS)(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetNativeBufferPropertiesOHOS( + VkDevice device, + const struct OH_NativeBuffer* buffer, + VkNativeBufferPropertiesOHOS* pProperties); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryNativeBufferOHOS( + VkDevice device, + const VkMemoryGetNativeBufferInfoOHOS* pInfo, + struct OH_NativeBuffer** pBuffer); +#endif +#endif + + +// VK_OHOS_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_OHOS_surface 1 +typedef struct NativeWindow OHNativeWindow; +#define VK_OHOS_SURFACE_SPEC_VERSION 1 +#define VK_OHOS_SURFACE_EXTENSION_NAME "VK_OHOS_surface" +typedef VkFlags VkSurfaceCreateFlagsOHOS; +typedef struct VkSurfaceCreateInfoOHOS { + VkStructureType sType; + const void* pNext; + VkSurfaceCreateFlagsOHOS flags; + OHNativeWindow* window; +} VkSurfaceCreateInfoOHOS; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateSurfaceOHOS)(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateSurfaceOHOS( + VkInstance instance, + const VkSurfaceCreateInfoOHOS* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_raii.hpp b/lib/vulkan-headers/include/vulkan/vulkan_raii.hpp new file mode 100644 index 00000000000..9f18b89ee80 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_raii.hpp @@ -0,0 +1,28565 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_RAII_HPP +#define VULKAN_RAII_HPP + +#include +#if !defined( VULKAN_HPP_CXX_MODULE ) +# include // std::unique_ptr +# include // std::forward +#endif + +#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) +namespace VULKAN_HPP_NAMESPACE +{ + namespace VULKAN_HPP_RAII_NAMESPACE + { + namespace detail + { + using PFN_dummy = void ( * )(); + + class ContextDispatcher : public ::VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase + { + public: + ContextDispatcher( PFN_vkGetInstanceProcAddr getProcAddr ) + : vkGetInstanceProcAddr( getProcAddr ) + //=== VK_VERSION_1_0 === + , vkCreateInstance( PFN_vkCreateInstance( getProcAddr( NULL, "vkCreateInstance" ) ) ) + , vkEnumerateInstanceExtensionProperties( + PFN_vkEnumerateInstanceExtensionProperties( getProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) ) ) + , vkEnumerateInstanceLayerProperties( PFN_vkEnumerateInstanceLayerProperties( getProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) ) ) + //=== VK_VERSION_1_1 === + , vkEnumerateInstanceVersion( PFN_vkEnumerateInstanceVersion( getProcAddr( NULL, "vkEnumerateInstanceVersion" ) ) ) + { + } + + public: + PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; + + //=== VK_VERSION_1_0 === + PFN_vkCreateInstance vkCreateInstance = 0; + PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; + PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; + + //=== VK_VERSION_1_1 === + PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; + }; + + class InstanceDispatcher : public ::VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase + { + public: + InstanceDispatcher( PFN_vkGetInstanceProcAddr getProcAddr, VkInstance instance ) : vkGetInstanceProcAddr( getProcAddr ) + { + //=== VK_VERSION_1_0 === + vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) ); + vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) ); + vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) ); + vkGetPhysicalDeviceFormatProperties = + PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) ); + vkGetPhysicalDeviceImageFormatProperties = + PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) ); + vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) ); + vkGetPhysicalDeviceQueueFamilyProperties = + PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) ); + vkGetPhysicalDeviceMemoryProperties = + PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) ); + vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) ); + vkEnumerateDeviceExtensionProperties = + PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) ); + vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) ); + vkGetPhysicalDeviceSparseImageFormatProperties = + PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) ); + + //=== VK_VERSION_1_1 === + vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) ); + vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) ); + vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) ); + vkGetPhysicalDeviceFormatProperties2 = + PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) ); + vkGetPhysicalDeviceImageFormatProperties2 = + PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) ); + vkGetPhysicalDeviceQueueFamilyProperties2 = + PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) ); + vkGetPhysicalDeviceMemoryProperties2 = + PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) ); + vkGetPhysicalDeviceSparseImageFormatProperties2 = + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) ); + vkGetPhysicalDeviceExternalBufferProperties = + PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) ); + vkGetPhysicalDeviceExternalFenceProperties = + PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) ); + vkGetPhysicalDeviceExternalSemaphoreProperties = + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) ); + + //=== VK_VERSION_1_3 === + vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) ); + + //=== VK_KHR_surface === + vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) ); + vkGetPhysicalDeviceSurfaceSupportKHR = + PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) ); + vkGetPhysicalDeviceSurfaceCapabilitiesKHR = + PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) ); + vkGetPhysicalDeviceSurfaceFormatsKHR = + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) ); + vkGetPhysicalDeviceSurfacePresentModesKHR = + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) ); + + //=== VK_KHR_swapchain === + vkGetPhysicalDevicePresentRectanglesKHR = + PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) ); + + //=== VK_KHR_display === + vkGetPhysicalDeviceDisplayPropertiesKHR = + PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) ); + vkGetPhysicalDeviceDisplayPlanePropertiesKHR = + PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) ); + vkGetDisplayPlaneSupportedDisplaysKHR = + PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) ); + vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) ); + vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) ); + vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) ); + vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) ); + +# if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) ); + vkGetPhysicalDeviceXlibPresentationSupportKHR = + PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) ); +# endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +# if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) ); + vkGetPhysicalDeviceXcbPresentationSupportKHR = + PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) ); +# endif /*VK_USE_PLATFORM_XCB_KHR*/ + +# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) ); + vkGetPhysicalDeviceWaylandPresentationSupportKHR = + PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) ); +# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) ); +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) ); + vkGetPhysicalDeviceWin32PresentationSupportKHR = + PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) ); +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) ); + vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) ); + vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) ); + + //=== VK_KHR_video_queue === + vkGetPhysicalDeviceVideoCapabilitiesKHR = + PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) ); + vkGetPhysicalDeviceVideoFormatPropertiesKHR = + PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) ); + +# if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + vkCreateStreamDescriptorSurfaceGGP = + PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) ); +# endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + vkGetPhysicalDeviceExternalImageFormatPropertiesNV = + PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) ); + + //=== VK_KHR_get_physical_device_properties2 === + vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) ); + if ( !vkGetPhysicalDeviceFeatures2 ) + vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR; + vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceProperties2 ) + vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR; + vkGetPhysicalDeviceFormatProperties2KHR = + PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceFormatProperties2 ) + vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR; + vkGetPhysicalDeviceImageFormatProperties2KHR = + PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceImageFormatProperties2 ) + vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR; + vkGetPhysicalDeviceQueueFamilyProperties2KHR = + PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceQueueFamilyProperties2 ) + vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR; + vkGetPhysicalDeviceMemoryProperties2KHR = + PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceMemoryProperties2 ) + vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR; + vkGetPhysicalDeviceSparseImageFormatProperties2KHR = + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) ); + if ( !vkGetPhysicalDeviceSparseImageFormatProperties2 ) + vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR; + +# if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) ); +# endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_device_group_creation === + vkEnumeratePhysicalDeviceGroupsKHR = + PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) ); + if ( !vkEnumeratePhysicalDeviceGroups ) + vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR; + + //=== VK_KHR_external_memory_capabilities === + vkGetPhysicalDeviceExternalBufferPropertiesKHR = + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) ); + if ( !vkGetPhysicalDeviceExternalBufferProperties ) + vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR; + + //=== VK_KHR_external_semaphore_capabilities === + vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = + PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) ); + if ( !vkGetPhysicalDeviceExternalSemaphoreProperties ) + vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; + + //=== VK_EXT_direct_mode_display === + vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) ); + +# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) ); + vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) ); +# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + vkGetPhysicalDeviceSurfaceCapabilities2EXT = + PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) ); + + //=== VK_KHR_external_fence_capabilities === + vkGetPhysicalDeviceExternalFencePropertiesKHR = + PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) ); + if ( !vkGetPhysicalDeviceExternalFenceProperties ) + vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR; + + //=== VK_KHR_performance_query === + vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) ); + vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) ); + + //=== VK_KHR_get_surface_capabilities2 === + vkGetPhysicalDeviceSurfaceCapabilities2KHR = + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) ); + vkGetPhysicalDeviceSurfaceFormats2KHR = + PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) ); + + //=== VK_KHR_get_display_properties2 === + vkGetPhysicalDeviceDisplayProperties2KHR = + PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) ); + vkGetPhysicalDeviceDisplayPlaneProperties2KHR = + PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) ); + vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) ); + vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) ); + +# if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) ); +# endif /*VK_USE_PLATFORM_IOS_MVK*/ + +# if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) ); +# endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) ); + vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) ); + vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) ); + + //=== VK_EXT_descriptor_heap === + vkGetPhysicalDeviceDescriptorSizeEXT = + PFN_vkGetPhysicalDeviceDescriptorSizeEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDescriptorSizeEXT" ) ); + + //=== VK_EXT_sample_locations === + vkGetPhysicalDeviceMultisamplePropertiesEXT = + PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) ); + + //=== VK_EXT_calibrated_timestamps === + vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) ); + if ( !vkGetPhysicalDeviceCalibrateableTimeDomainsKHR ) + vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) ); +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) ); +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + vkGetPhysicalDeviceFragmentShadingRatesKHR = + PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) ); + + //=== VK_EXT_tooling_info === + vkGetPhysicalDeviceToolPropertiesEXT = + PFN_vkGetPhysicalDeviceToolPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) ); + if ( !vkGetPhysicalDeviceToolProperties ) + vkGetPhysicalDeviceToolProperties = vkGetPhysicalDeviceToolPropertiesEXT; + + //=== VK_NV_cooperative_matrix === + vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) ); + + //=== VK_NV_coverage_reduction_mode === + vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) ); + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + vkGetPhysicalDeviceSurfacePresentModes2EXT = + PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) ); +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) ); + + //=== VK_EXT_acquire_drm_display === + vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) ); + vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) ); + + //=== VK_KHR_video_encode_queue === + vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR" ) ); + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) ); + vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) ); +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) ); + vkGetPhysicalDeviceDirectFBPresentationSupportEXT = + PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) ); +# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) ); + vkGetPhysicalDeviceScreenPresentationSupportQNX = + PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) ); +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_ARM_tensors === + vkGetPhysicalDeviceExternalTensorPropertiesARM = + PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalTensorPropertiesARM" ) ); + + //=== VK_NV_optical_flow === + vkGetPhysicalDeviceOpticalFlowImageFormatsNV = + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV" ) ); + + //=== VK_NV_cooperative_vector === + vkGetPhysicalDeviceCooperativeVectorPropertiesNV = + PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV" ) ); + + //=== VK_KHR_cooperative_matrix === + vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR" ) ); + + //=== VK_ARM_data_graph === + vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM" ) ); + vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM" ) ); + + //=== VK_KHR_calibrated_timestamps === + vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) ); + +# if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + vkCreateSurfaceOHOS = PFN_vkCreateSurfaceOHOS( vkGetInstanceProcAddr( instance, "vkCreateSurfaceOHOS" ) ); +# endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_NV_cooperative_matrix2 === + vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( + vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV" ) ); + + //=== VK_ARM_performance_counters_by_region === + vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( + vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM" ) ); + + vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) ); + } + + public: + //=== VK_VERSION_1_0 === + PFN_vkDestroyInstance vkDestroyInstance = 0; + PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; + PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0; + PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; + PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0; + PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; + PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; + PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; + PFN_vkCreateDevice vkCreateDevice = 0; + PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; + PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; + + //=== VK_VERSION_1_1 === + PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; + PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0; + PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; + PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0; + PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; + PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; + PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0; + PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0; + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0; + + //=== VK_VERSION_1_3 === + PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0; + + //=== VK_KHR_surface === + PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; + PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; + PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; + + //=== VK_KHR_swapchain === + PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; + + //=== VK_KHR_display === + PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0; + PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0; + PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; + PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; + PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; + PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; + PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; + +# if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; + PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; +# else + PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; +# endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +# if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; + PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; +# else + PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; +# endif /*VK_USE_PLATFORM_XCB_KHR*/ + +# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; + PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; +# else + PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; +# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; +# else + PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; + PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; +# else + PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; + PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; + PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; + + //=== VK_KHR_video_queue === + PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0; + PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0; + +# if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; +# else + PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; +# endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0; + + //=== VK_KHR_get_physical_device_properties2 === + PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0; + PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; + PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0; + PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0; + PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; + PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; + +# if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; +# else + PFN_dummy vkCreateViSurfaceNN_placeholder = 0; +# endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_device_group_creation === + PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; + + //=== VK_KHR_external_memory_capabilities === + PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0; + + //=== VK_KHR_external_semaphore_capabilities === + PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0; + + //=== VK_EXT_direct_mode_display === + PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; + +# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; + PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; +# else + PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; + PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; +# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; + + //=== VK_KHR_external_fence_capabilities === + PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0; + + //=== VK_KHR_performance_query === + PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0; + PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; + + //=== VK_KHR_get_surface_capabilities2 === + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; + PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; + + //=== VK_KHR_get_display_properties2 === + PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0; + PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0; + PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; + PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; + +# if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; +# else + PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; +# endif /*VK_USE_PLATFORM_IOS_MVK*/ + +# if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; +# else + PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; +# endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; + PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; + PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; + + //=== VK_EXT_descriptor_heap === + PFN_vkGetPhysicalDeviceDescriptorSizeEXT vkGetPhysicalDeviceDescriptorSizeEXT = 0; + + //=== VK_EXT_sample_locations === + PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; + + //=== VK_EXT_calibrated_timestamps === + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; +# else + PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; +# else + PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0; + + //=== VK_EXT_tooling_info === + PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0; + + //=== VK_NV_cooperative_matrix === + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0; + + //=== VK_NV_coverage_reduction_mode === + PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; +# else + PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0; + + //=== VK_EXT_acquire_drm_display === + PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0; + PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0; + + //=== VK_KHR_video_encode_queue === + PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 0; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; + PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; +# else + PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; + PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0; + PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0; +# else + PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; +# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; + PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; +# else + PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; + PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_ARM_tensors === + PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM vkGetPhysicalDeviceExternalTensorPropertiesARM = 0; + + //=== VK_NV_optical_flow === + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 0; + + //=== VK_NV_cooperative_vector === + PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV vkGetPhysicalDeviceCooperativeVectorPropertiesNV = 0; + + //=== VK_KHR_cooperative_matrix === + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 0; + + //=== VK_ARM_data_graph === + PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = 0; + PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = 0; + + //=== VK_KHR_calibrated_timestamps === + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0; + +# if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS = 0; +# else + PFN_dummy vkCreateSurfaceOHOS_placeholder = 0; +# endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_NV_cooperative_matrix2 === + PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = 0; + + //=== VK_ARM_performance_counters_by_region === + PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = 0; + + PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; + }; + + class DeviceDispatcher : public ::VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase + { + public: + DeviceDispatcher( PFN_vkGetDeviceProcAddr getProcAddr, VkDevice device ) : vkGetDeviceProcAddr( getProcAddr ) + { + //=== VK_VERSION_1_0 === + vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) ); + vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) ); + vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) ); + vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) ); + vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) ); + vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) ); + vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) ); + vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) ); + vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) ); + vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) ); + vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) ); + vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) ); + vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) ); + vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) ); + vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) ); + vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) ); + vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) ); + vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) ); + vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) ); + vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) ); + vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) ); + vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) ); + vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) ); + vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) ); + vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) ); + vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) ); + vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) ); + vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) ); + vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) ); + vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) ); + vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) ); + vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) ); + vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) ); + vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) ); + vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) ); + vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) ); + vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) ); + vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) ); + vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) ); + vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) ); + vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) ); + vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) ); + vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) ); + vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) ); + vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) ); + vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) ); + vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) ); + vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) ); + vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) ); + vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) ); + vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) ); + vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) ); + vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) ); + vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) ); + vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) ); + vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) ); + vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) ); + vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) ); + vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) ); + vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) ); + vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) ); + vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) ); + vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) ); + vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) ); + vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) ); + vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) ); + vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) ); + vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) ); + vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) ); + vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) ); + vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) ); + vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) ); + vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) ); + vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) ); + vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) ); + vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) ); + vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) ); + vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) ); + vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) ); + vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) ); + vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) ); + vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) ); + vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) ); + vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) ); + vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) ); + vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) ); + vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) ); + vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) ); + vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) ); + vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) ); + vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) ); + vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) ); + vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) ); + vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) ); + vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) ); + vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) ); + vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) ); + vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) ); + vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) ); + vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) ); + vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) ); + vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) ); + vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) ); + vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) ); + vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) ); + vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) ); + vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) ); + vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) ); + vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) ); + vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) ); + vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) ); + vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) ); + vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) ); + vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) ); + vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) ); + vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) ); + vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) ); + vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) ); + vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) ); + vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) ); + vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) ); + + //=== VK_VERSION_1_1 === + vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) ); + vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) ); + vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) ); + vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) ); + vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) ); + vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) ); + vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) ); + vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) ); + vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) ); + vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) ); + vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) ); + vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) ); + vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) ); + vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) ); + vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) ); + vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) ); + + //=== VK_VERSION_1_2 === + vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) ); + vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) ); + vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) ); + vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) ); + vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) ); + vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) ); + vkGetDeviceMemoryOpaqueCaptureAddress = + PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) ); + vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) ); + vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) ); + vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) ); + vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) ); + vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) ); + vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) ); + + //=== VK_VERSION_1_3 === + vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) ); + vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) ); + vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) ); + vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) ); + vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) ); + vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) ); + vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) ); + vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) ); + vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) ); + vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) ); + vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) ); + vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) ); + vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) ); + vkGetDeviceImageSparseMemoryRequirements = + PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) ); + vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) ); + vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) ); + vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) ); + vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) ); + vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) ); + vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) ); + vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) ); + vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) ); + vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) ); + vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) ); + vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) ); + vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) ); + vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) ); + vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) ); + vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) ); + vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) ); + vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) ); + vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) ); + vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) ); + vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) ); + vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) ); + vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) ); + + //=== VK_VERSION_1_4 === + vkMapMemory2 = PFN_vkMapMemory2( vkGetDeviceProcAddr( device, "vkMapMemory2" ) ); + vkUnmapMemory2 = PFN_vkUnmapMemory2( vkGetDeviceProcAddr( device, "vkUnmapMemory2" ) ); + vkGetDeviceImageSubresourceLayout = PFN_vkGetDeviceImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayout" ) ); + vkGetImageSubresourceLayout2 = PFN_vkGetImageSubresourceLayout2( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2" ) ); + vkCopyMemoryToImage = PFN_vkCopyMemoryToImage( vkGetDeviceProcAddr( device, "vkCopyMemoryToImage" ) ); + vkCopyImageToMemory = PFN_vkCopyImageToMemory( vkGetDeviceProcAddr( device, "vkCopyImageToMemory" ) ); + vkCopyImageToImage = PFN_vkCopyImageToImage( vkGetDeviceProcAddr( device, "vkCopyImageToImage" ) ); + vkTransitionImageLayout = PFN_vkTransitionImageLayout( vkGetDeviceProcAddr( device, "vkTransitionImageLayout" ) ); + vkCmdPushDescriptorSet = PFN_vkCmdPushDescriptorSet( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet" ) ); + vkCmdPushDescriptorSetWithTemplate = PFN_vkCmdPushDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate" ) ); + vkCmdBindDescriptorSets2 = PFN_vkCmdBindDescriptorSets2( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2" ) ); + vkCmdPushConstants2 = PFN_vkCmdPushConstants2( vkGetDeviceProcAddr( device, "vkCmdPushConstants2" ) ); + vkCmdPushDescriptorSet2 = PFN_vkCmdPushDescriptorSet2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2" ) ); + vkCmdPushDescriptorSetWithTemplate2 = PFN_vkCmdPushDescriptorSetWithTemplate2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2" ) ); + vkCmdSetLineStipple = PFN_vkCmdSetLineStipple( vkGetDeviceProcAddr( device, "vkCmdSetLineStipple" ) ); + vkCmdBindIndexBuffer2 = PFN_vkCmdBindIndexBuffer2( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2" ) ); + vkGetRenderingAreaGranularity = PFN_vkGetRenderingAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularity" ) ); + vkCmdSetRenderingAttachmentLocations = + PFN_vkCmdSetRenderingAttachmentLocations( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocations" ) ); + vkCmdSetRenderingInputAttachmentIndices = + PFN_vkCmdSetRenderingInputAttachmentIndices( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndices" ) ); + + //=== VK_KHR_swapchain === + vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) ); + vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) ); + vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) ); + vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) ); + vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) ); + vkGetDeviceGroupPresentCapabilitiesKHR = + PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); + vkGetDeviceGroupSurfacePresentModesKHR = + PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); + vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) ); + + //=== VK_KHR_display_swapchain === + vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) ); + + //=== VK_EXT_debug_marker === + vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) ); + vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) ); + vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) ); + vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) ); + vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) ); + + //=== VK_KHR_video_queue === + vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) ); + vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) ); + vkGetVideoSessionMemoryRequirementsKHR = + PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) ); + vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) ); + vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) ); + vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) ); + vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) ); + vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) ); + vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) ); + vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) ); + + //=== VK_KHR_video_decode_queue === + vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) ); + + //=== VK_EXT_transform_feedback === + vkCmdBindTransformFeedbackBuffersEXT = + PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) ); + vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) ); + vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) ); + vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) ); + vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) ); + vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) ); + + //=== VK_NVX_binary_import === + vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) ); + vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) ); + vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) ); + vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) ); + vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) ); + + //=== VK_NVX_image_view_handle === + vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) ); + vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandle64NVX" ) ); + vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) ); + vkGetDeviceCombinedImageSamplerIndexNVX = + PFN_vkGetDeviceCombinedImageSamplerIndexNVX( vkGetDeviceProcAddr( device, "vkGetDeviceCombinedImageSamplerIndexNVX" ) ); + + //=== VK_AMD_draw_indirect_count === + vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) ); + if ( !vkCmdDrawIndirectCount ) + vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; + vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) ); + if ( !vkCmdDrawIndexedIndirectCount ) + vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; + + //=== VK_AMD_shader_info === + vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) ); + + //=== VK_KHR_dynamic_rendering === + vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) ); + if ( !vkCmdBeginRendering ) + vkCmdBeginRendering = vkCmdBeginRenderingKHR; + vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) ); + if ( !vkCmdEndRendering ) + vkCmdEndRendering = vkCmdEndRenderingKHR; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) ); +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_device_group === + vkGetDeviceGroupPeerMemoryFeaturesKHR = + PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); + if ( !vkGetDeviceGroupPeerMemoryFeatures ) + vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; + vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) ); + if ( !vkCmdSetDeviceMask ) + vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; + vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) ); + if ( !vkCmdDispatchBase ) + vkCmdDispatchBase = vkCmdDispatchBaseKHR; + + //=== VK_KHR_maintenance1 === + vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) ); + if ( !vkTrimCommandPool ) + vkTrimCommandPool = vkTrimCommandPoolKHR; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) ); + vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) ); +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) ); + vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) ); + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) ); + vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) ); +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) ); + vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) ); + + //=== VK_KHR_push_descriptor === + vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) ); + if ( !vkCmdPushDescriptorSet ) + vkCmdPushDescriptorSet = vkCmdPushDescriptorSetKHR; + vkCmdPushDescriptorSetWithTemplateKHR = + PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) ); + if ( !vkCmdPushDescriptorSetWithTemplate ) + vkCmdPushDescriptorSetWithTemplate = vkCmdPushDescriptorSetWithTemplateKHR; + + //=== VK_EXT_conditional_rendering === + vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) ); + vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) ); + + //=== VK_KHR_descriptor_update_template === + vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) ); + if ( !vkCreateDescriptorUpdateTemplate ) + vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; + vkDestroyDescriptorUpdateTemplateKHR = + PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) ); + if ( !vkDestroyDescriptorUpdateTemplate ) + vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; + vkUpdateDescriptorSetWithTemplateKHR = + PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) ); + if ( !vkUpdateDescriptorSetWithTemplate ) + vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; + + //=== VK_NV_clip_space_w_scaling === + vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) ); + + //=== VK_EXT_display_control === + vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) ); + vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) ); + vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) ); + vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) ); + + //=== VK_GOOGLE_display_timing === + vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) ); + vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) ); + + //=== VK_EXT_discard_rectangles === + vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) ); + vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEnableEXT" ) ); + vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleModeEXT" ) ); + + //=== VK_EXT_hdr_metadata === + vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) ); + + //=== VK_KHR_create_renderpass2 === + vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) ); + if ( !vkCreateRenderPass2 ) + vkCreateRenderPass2 = vkCreateRenderPass2KHR; + vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) ); + if ( !vkCmdBeginRenderPass2 ) + vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; + vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) ); + if ( !vkCmdNextSubpass2 ) + vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; + vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) ); + if ( !vkCmdEndRenderPass2 ) + vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; + + //=== VK_KHR_shared_presentable_image === + vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) ); + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) ); + vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) ); +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) ); + vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) ); + + //=== VK_KHR_performance_query === + vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) ); + vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) ); + + //=== VK_EXT_debug_utils === + vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) ); + vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) ); + vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) ); + vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) ); + vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) ); + vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) ); + vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) ); + vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) ); + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + vkGetAndroidHardwareBufferPropertiesANDROID = + PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) ); + vkGetMemoryAndroidHardwareBufferANDROID = + PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + vkCreateExecutionGraphPipelinesAMDX = PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetDeviceProcAddr( device, "vkCreateExecutionGraphPipelinesAMDX" ) ); + vkGetExecutionGraphPipelineScratchSizeAMDX = + PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) ); + vkGetExecutionGraphPipelineNodeIndexAMDX = + PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) ); + vkCmdInitializeGraphScratchMemoryAMDX = + PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetDeviceProcAddr( device, "vkCmdInitializeGraphScratchMemoryAMDX" ) ); + vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphAMDX" ) ); + vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectAMDX" ) ); + vkCmdDispatchGraphIndirectCountAMDX = PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectCountAMDX" ) ); +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + vkWriteSamplerDescriptorsEXT = PFN_vkWriteSamplerDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteSamplerDescriptorsEXT" ) ); + vkWriteResourceDescriptorsEXT = PFN_vkWriteResourceDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteResourceDescriptorsEXT" ) ); + vkCmdBindSamplerHeapEXT = PFN_vkCmdBindSamplerHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindSamplerHeapEXT" ) ); + vkCmdBindResourceHeapEXT = PFN_vkCmdBindResourceHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindResourceHeapEXT" ) ); + vkCmdPushDataEXT = PFN_vkCmdPushDataEXT( vkGetDeviceProcAddr( device, "vkCmdPushDataEXT" ) ); + vkGetImageOpaqueCaptureDataEXT = PFN_vkGetImageOpaqueCaptureDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDataEXT" ) ); + vkRegisterCustomBorderColorEXT = PFN_vkRegisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkRegisterCustomBorderColorEXT" ) ); + vkUnregisterCustomBorderColorEXT = PFN_vkUnregisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkUnregisterCustomBorderColorEXT" ) ); + vkGetTensorOpaqueCaptureDataARM = PFN_vkGetTensorOpaqueCaptureDataARM( vkGetDeviceProcAddr( device, "vkGetTensorOpaqueCaptureDataARM" ) ); + + //=== VK_EXT_sample_locations === + vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) ); + + //=== VK_KHR_get_memory_requirements2 === + vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) ); + if ( !vkGetImageMemoryRequirements2 ) + vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; + vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) ); + if ( !vkGetBufferMemoryRequirements2 ) + vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; + vkGetImageSparseMemoryRequirements2KHR = + PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) ); + if ( !vkGetImageSparseMemoryRequirements2 ) + vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; + + //=== VK_KHR_acceleration_structure === + vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) ); + vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) ); + vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) ); + vkCmdBuildAccelerationStructuresIndirectKHR = + PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) ); + vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) ); + vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) ); + vkCopyAccelerationStructureToMemoryKHR = + PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) ); + vkCopyMemoryToAccelerationStructureKHR = + PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) ); + vkWriteAccelerationStructuresPropertiesKHR = + PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) ); + vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) ); + vkCmdCopyAccelerationStructureToMemoryKHR = + PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) ); + vkCmdCopyMemoryToAccelerationStructureKHR = + PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) ); + vkGetAccelerationStructureDeviceAddressKHR = + PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) ); + vkCmdWriteAccelerationStructuresPropertiesKHR = + PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) ); + vkGetDeviceAccelerationStructureCompatibilityKHR = + PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) ); + vkGetAccelerationStructureBuildSizesKHR = + PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) ); + + //=== VK_KHR_ray_tracing_pipeline === + vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) ); + vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) ); + vkGetRayTracingShaderGroupHandlesKHR = + PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) ); + vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = + PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) ); + vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) ); + vkGetRayTracingShaderGroupStackSizeKHR = + PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) ); + vkCmdSetRayTracingPipelineStackSizeKHR = + PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); + + //=== VK_KHR_sampler_ycbcr_conversion === + vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) ); + if ( !vkCreateSamplerYcbcrConversion ) + vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; + vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) ); + if ( !vkDestroySamplerYcbcrConversion ) + vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; + + //=== VK_KHR_bind_memory2 === + vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) ); + if ( !vkBindBufferMemory2 ) + vkBindBufferMemory2 = vkBindBufferMemory2KHR; + vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) ); + if ( !vkBindImageMemory2 ) + vkBindImageMemory2 = vkBindImageMemory2KHR; + + //=== VK_EXT_image_drm_format_modifier === + vkGetImageDrmFormatModifierPropertiesEXT = + PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) ); + + //=== VK_EXT_validation_cache === + vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) ); + vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) ); + vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) ); + vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) ); + + //=== VK_NV_shading_rate_image === + vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) ); + vkCmdSetViewportShadingRatePaletteNV = + PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) ); + vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) ); + + //=== VK_NV_ray_tracing === + vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) ); + vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) ); + vkGetAccelerationStructureMemoryRequirementsNV = + PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) ); + vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) ); + vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) ); + vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) ); + vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) ); + vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) ); + vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) ); + if ( !vkGetRayTracingShaderGroupHandlesKHR ) + vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; + vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) ); + vkCmdWriteAccelerationStructuresPropertiesNV = + PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) ); + vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) ); + + //=== VK_KHR_maintenance3 === + vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) ); + if ( !vkGetDescriptorSetLayoutSupport ) + vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; + + //=== VK_KHR_draw_indirect_count === + vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) ); + if ( !vkCmdDrawIndirectCount ) + vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; + vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) ); + if ( !vkCmdDrawIndexedIndirectCount ) + vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; + + //=== VK_EXT_external_memory_host === + vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) ); + + //=== VK_AMD_buffer_marker === + vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) ); + vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) ); + + //=== VK_EXT_calibrated_timestamps === + vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) ); + if ( !vkGetCalibratedTimestampsKHR ) + vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT; + + //=== VK_NV_mesh_shader === + vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) ); + vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) ); + vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) ); + + //=== VK_NV_scissor_exclusive === + vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorEnableNV" ) ); + vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) ); + + //=== VK_NV_device_diagnostic_checkpoints === + vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) ); + vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) ); + vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) ); + + //=== VK_KHR_timeline_semaphore === + vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) ); + if ( !vkGetSemaphoreCounterValue ) + vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; + vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) ); + if ( !vkWaitSemaphores ) + vkWaitSemaphores = vkWaitSemaphoresKHR; + vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) ); + if ( !vkSignalSemaphore ) + vkSignalSemaphore = vkSignalSemaphoreKHR; + + //=== VK_EXT_present_timing === + vkSetSwapchainPresentTimingQueueSizeEXT = + PFN_vkSetSwapchainPresentTimingQueueSizeEXT( vkGetDeviceProcAddr( device, "vkSetSwapchainPresentTimingQueueSizeEXT" ) ); + vkGetSwapchainTimingPropertiesEXT = PFN_vkGetSwapchainTimingPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimingPropertiesEXT" ) ); + vkGetSwapchainTimeDomainPropertiesEXT = + PFN_vkGetSwapchainTimeDomainPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimeDomainPropertiesEXT" ) ); + vkGetPastPresentationTimingEXT = PFN_vkGetPastPresentationTimingEXT( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingEXT" ) ); + + //=== VK_INTEL_performance_query === + vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) ); + vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) ); + vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) ); + vkCmdSetPerformanceStreamMarkerINTEL = + PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); + vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) ); + vkAcquirePerformanceConfigurationINTEL = + PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) ); + vkReleasePerformanceConfigurationINTEL = + PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) ); + vkQueueSetPerformanceConfigurationINTEL = + PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) ); + vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) ); + + //=== VK_AMD_display_native_hdr === + vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) ); + + //=== VK_KHR_fragment_shading_rate === + vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) ); + + //=== VK_KHR_dynamic_rendering_local_read === + vkCmdSetRenderingAttachmentLocationsKHR = + PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocationsKHR" ) ); + if ( !vkCmdSetRenderingAttachmentLocations ) + vkCmdSetRenderingAttachmentLocations = vkCmdSetRenderingAttachmentLocationsKHR; + vkCmdSetRenderingInputAttachmentIndicesKHR = + PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) ); + if ( !vkCmdSetRenderingInputAttachmentIndices ) + vkCmdSetRenderingInputAttachmentIndices = vkCmdSetRenderingInputAttachmentIndicesKHR; + + //=== VK_EXT_buffer_device_address === + vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) ); + if ( !vkGetBufferDeviceAddress ) + vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; + + //=== VK_KHR_present_wait === + vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) ); + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) ); + vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) ); + vkGetDeviceGroupSurfacePresentModes2EXT = + PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_buffer_device_address === + vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) ); + if ( !vkGetBufferDeviceAddress ) + vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; + vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) ); + if ( !vkGetBufferOpaqueCaptureAddress ) + vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; + vkGetDeviceMemoryOpaqueCaptureAddressKHR = + PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) ); + if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) + vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; + + //=== VK_EXT_line_rasterization === + vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) ); + if ( !vkCmdSetLineStipple ) + vkCmdSetLineStipple = vkCmdSetLineStippleEXT; + + //=== VK_EXT_host_query_reset === + vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) ); + if ( !vkResetQueryPool ) + vkResetQueryPool = vkResetQueryPoolEXT; + + //=== VK_EXT_extended_dynamic_state === + vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) ); + if ( !vkCmdSetCullMode ) + vkCmdSetCullMode = vkCmdSetCullModeEXT; + vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) ); + if ( !vkCmdSetFrontFace ) + vkCmdSetFrontFace = vkCmdSetFrontFaceEXT; + vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) ); + if ( !vkCmdSetPrimitiveTopology ) + vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT; + vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) ); + if ( !vkCmdSetViewportWithCount ) + vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT; + vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) ); + if ( !vkCmdSetScissorWithCount ) + vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT; + vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) ); + if ( !vkCmdBindVertexBuffers2 ) + vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT; + vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) ); + if ( !vkCmdSetDepthTestEnable ) + vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT; + vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) ); + if ( !vkCmdSetDepthWriteEnable ) + vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT; + vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) ); + if ( !vkCmdSetDepthCompareOp ) + vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT; + vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) ); + if ( !vkCmdSetDepthBoundsTestEnable ) + vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT; + vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) ); + if ( !vkCmdSetStencilTestEnable ) + vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT; + vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) ); + if ( !vkCmdSetStencilOp ) + vkCmdSetStencilOp = vkCmdSetStencilOpEXT; + + //=== VK_KHR_deferred_host_operations === + vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) ); + vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) ); + vkGetDeferredOperationMaxConcurrencyKHR = + PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) ); + vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) ); + vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) ); + + //=== VK_KHR_pipeline_executable_properties === + vkGetPipelineExecutablePropertiesKHR = + PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) ); + vkGetPipelineExecutableStatisticsKHR = + PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) ); + vkGetPipelineExecutableInternalRepresentationsKHR = + PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) ); + + //=== VK_EXT_host_image_copy === + vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToImageEXT" ) ); + if ( !vkCopyMemoryToImage ) + vkCopyMemoryToImage = vkCopyMemoryToImageEXT; + vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyImageToMemoryEXT" ) ); + if ( !vkCopyImageToMemory ) + vkCopyImageToMemory = vkCopyImageToMemoryEXT; + vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetDeviceProcAddr( device, "vkCopyImageToImageEXT" ) ); + if ( !vkCopyImageToImage ) + vkCopyImageToImage = vkCopyImageToImageEXT; + vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetDeviceProcAddr( device, "vkTransitionImageLayoutEXT" ) ); + if ( !vkTransitionImageLayout ) + vkTransitionImageLayout = vkTransitionImageLayoutEXT; + vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) ); + if ( !vkGetImageSubresourceLayout2 ) + vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2EXT; + + //=== VK_KHR_map_memory2 === + vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetDeviceProcAddr( device, "vkMapMemory2KHR" ) ); + if ( !vkMapMemory2 ) + vkMapMemory2 = vkMapMemory2KHR; + vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetDeviceProcAddr( device, "vkUnmapMemory2KHR" ) ); + if ( !vkUnmapMemory2 ) + vkUnmapMemory2 = vkUnmapMemory2KHR; + + //=== VK_EXT_swapchain_maintenance1 === + vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesEXT" ) ); + if ( !vkReleaseSwapchainImagesKHR ) + vkReleaseSwapchainImagesKHR = vkReleaseSwapchainImagesEXT; + + //=== VK_NV_device_generated_commands === + vkGetGeneratedCommandsMemoryRequirementsNV = + PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) ); + vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) ); + vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) ); + vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) ); + vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) ); + vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) ); + + //=== VK_EXT_depth_bias_control === + vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias2EXT" ) ); + + //=== VK_EXT_private_data === + vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) ); + if ( !vkCreatePrivateDataSlot ) + vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT; + vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) ); + if ( !vkDestroyPrivateDataSlot ) + vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT; + vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) ); + if ( !vkSetPrivateData ) + vkSetPrivateData = vkSetPrivateDataEXT; + vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) ); + if ( !vkGetPrivateData ) + vkGetPrivateData = vkGetPrivateDataEXT; + + //=== VK_KHR_video_encode_queue === + vkGetEncodedVideoSessionParametersKHR = + PFN_vkGetEncodedVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkGetEncodedVideoSessionParametersKHR" ) ); + vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) ); + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetDeviceProcAddr( device, "vkCreateCudaModuleNV" ) ); + vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetDeviceProcAddr( device, "vkGetCudaModuleCacheNV" ) ); + vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetDeviceProcAddr( device, "vkCreateCudaFunctionNV" ) ); + vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetDeviceProcAddr( device, "vkDestroyCudaModuleNV" ) ); + vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetDeviceProcAddr( device, "vkDestroyCudaFunctionNV" ) ); + vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetDeviceProcAddr( device, "vkCmdCudaLaunchKernelNV" ) ); +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + vkCmdDispatchTileQCOM = PFN_vkCmdDispatchTileQCOM( vkGetDeviceProcAddr( device, "vkCmdDispatchTileQCOM" ) ); + vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdBeginPerTileExecutionQCOM" ) ); + vkCmdEndPerTileExecutionQCOM = PFN_vkCmdEndPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdEndPerTileExecutionQCOM" ) ); + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) ); +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) ); + if ( !vkCmdSetEvent2 ) + vkCmdSetEvent2 = vkCmdSetEvent2KHR; + vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) ); + if ( !vkCmdResetEvent2 ) + vkCmdResetEvent2 = vkCmdResetEvent2KHR; + vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) ); + if ( !vkCmdWaitEvents2 ) + vkCmdWaitEvents2 = vkCmdWaitEvents2KHR; + vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) ); + if ( !vkCmdPipelineBarrier2 ) + vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR; + vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) ); + if ( !vkCmdWriteTimestamp2 ) + vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR; + vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) ); + if ( !vkQueueSubmit2 ) + vkQueueSubmit2 = vkQueueSubmit2KHR; + + //=== VK_EXT_descriptor_buffer === + vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSizeEXT" ) ); + vkGetDescriptorSetLayoutBindingOffsetEXT = + PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) ); + vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorEXT" ) ); + vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBuffersEXT" ) ); + vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsetsEXT" ) ); + vkCmdBindDescriptorBufferEmbeddedSamplersEXT = + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) ); + vkGetBufferOpaqueCaptureDescriptorDataEXT = + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) ); + vkGetImageOpaqueCaptureDescriptorDataEXT = + PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) ); + vkGetImageViewOpaqueCaptureDescriptorDataEXT = + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) ); + vkGetSamplerOpaqueCaptureDescriptorDataEXT = + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) ); + vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) ); + + //=== VK_NV_fragment_shading_rate_enums === + vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) ); + + //=== VK_EXT_mesh_shader === + vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) ); + vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) ); + vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) ); + + //=== VK_KHR_copy_commands2 === + vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) ); + if ( !vkCmdCopyBuffer2 ) + vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR; + vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) ); + if ( !vkCmdCopyImage2 ) + vkCmdCopyImage2 = vkCmdCopyImage2KHR; + vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) ); + if ( !vkCmdCopyBufferToImage2 ) + vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR; + vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) ); + if ( !vkCmdCopyImageToBuffer2 ) + vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR; + vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) ); + if ( !vkCmdBlitImage2 ) + vkCmdBlitImage2 = vkCmdBlitImage2KHR; + vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) ); + if ( !vkCmdResolveImage2 ) + vkCmdResolveImage2 = vkCmdResolveImage2KHR; + + //=== VK_EXT_device_fault === + vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) ); + + //=== VK_EXT_vertex_input_dynamic_state === + vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) ); + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) ); + vkGetMemoryZirconHandlePropertiesFUCHSIA = + PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) ); +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + vkImportSemaphoreZirconHandleFUCHSIA = + PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) ); + vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) ); +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) ); + vkSetBufferCollectionImageConstraintsFUCHSIA = + PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) ); + vkSetBufferCollectionBufferConstraintsFUCHSIA = + PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) ); + vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) ); + vkGetBufferCollectionPropertiesFUCHSIA = + PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) ); +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = + PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) ); + vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) ); + + //=== VK_HUAWEI_invocation_mask === + vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) ); + + //=== VK_NV_external_memory_rdma === + vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) ); + + //=== VK_EXT_pipeline_properties === + vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) ); + + //=== VK_EXT_extended_dynamic_state2 === + vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) ); + vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) ); + if ( !vkCmdSetRasterizerDiscardEnable ) + vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT; + vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) ); + if ( !vkCmdSetDepthBiasEnable ) + vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT; + vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) ); + vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) ); + if ( !vkCmdSetPrimitiveRestartEnable ) + vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT; + + //=== VK_EXT_color_write_enable === + vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) ); + + //=== VK_KHR_ray_tracing_maintenance1 === + vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) ); + + //=== VK_EXT_multi_draw === + vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) ); + vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) ); + + //=== VK_EXT_opacity_micromap === + vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetDeviceProcAddr( device, "vkCreateMicromapEXT" ) ); + vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetDeviceProcAddr( device, "vkDestroyMicromapEXT" ) ); + vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkCmdBuildMicromapsEXT" ) ); + vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkBuildMicromapsEXT" ) ); + vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapEXT" ) ); + vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapToMemoryEXT" ) ); + vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToMicromapEXT" ) ); + vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkWriteMicromapsPropertiesEXT" ) ); + vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapEXT" ) ); + vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapToMemoryEXT" ) ); + vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToMicromapEXT" ) ); + vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkCmdWriteMicromapsPropertiesEXT" ) ); + vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetDeviceProcAddr( device, "vkGetDeviceMicromapCompatibilityEXT" ) ); + vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetDeviceProcAddr( device, "vkGetMicromapBuildSizesEXT" ) ); + + //=== VK_HUAWEI_cluster_culling_shader === + vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterHUAWEI" ) ); + vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterIndirectHUAWEI" ) ); + + //=== VK_EXT_pageable_device_local_memory === + vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) ); + + //=== VK_KHR_maintenance4 === + vkGetDeviceBufferMemoryRequirementsKHR = + PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) ); + if ( !vkGetDeviceBufferMemoryRequirements ) + vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR; + vkGetDeviceImageMemoryRequirementsKHR = + PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) ); + if ( !vkGetDeviceImageMemoryRequirements ) + vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR; + vkGetDeviceImageSparseMemoryRequirementsKHR = + PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) ); + if ( !vkGetDeviceImageSparseMemoryRequirements ) + vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR; + + //=== VK_VALVE_descriptor_set_host_mapping === + vkGetDescriptorSetLayoutHostMappingInfoVALVE = + PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) ); + vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetHostMappingVALVE" ) ); + + //=== VK_NV_copy_memory_indirect === + vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectNV" ) ); + vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectNV" ) ); + + //=== VK_NV_memory_decompression === + vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryNV" ) ); + vkCmdDecompressMemoryIndirectCountNV = + PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountNV" ) ); + + //=== VK_NV_device_generated_commands_compute === + vkGetPipelineIndirectMemoryRequirementsNV = + PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectMemoryRequirementsNV" ) ); + vkCmdUpdatePipelineIndirectBufferNV = PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetDeviceProcAddr( device, "vkCmdUpdatePipelineIndirectBufferNV" ) ); + vkGetPipelineIndirectDeviceAddressNV = + PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectDeviceAddressNV" ) ); + +# if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + vkGetNativeBufferPropertiesOHOS = PFN_vkGetNativeBufferPropertiesOHOS( vkGetDeviceProcAddr( device, "vkGetNativeBufferPropertiesOHOS" ) ); + vkGetMemoryNativeBufferOHOS = PFN_vkGetMemoryNativeBufferOHOS( vkGetDeviceProcAddr( device, "vkGetMemoryNativeBufferOHOS" ) ); +# endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_extended_dynamic_state3 === + vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) ); + vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) ); + vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) ); + vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleMaskEXT" ) ); + vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToCoverageEnableEXT" ) ); + vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToOneEnableEXT" ) ); + vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEnableEXT" ) ); + vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) ); + vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) ); + vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) ); + vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) ); + vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) ); + vkCmdSetConservativeRasterizationModeEXT = + PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) ); + vkCmdSetExtraPrimitiveOverestimationSizeEXT = + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetDeviceProcAddr( device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) ); + vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipEnableEXT" ) ); + vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEnableEXT" ) ); + vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendAdvancedEXT" ) ); + vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetProvokingVertexModeEXT" ) ); + vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineRasterizationModeEXT" ) ); + vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEnableEXT" ) ); + vkCmdSetDepthClipNegativeOneToOneEXT = + PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipNegativeOneToOneEXT" ) ); + vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingEnableNV" ) ); + vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportSwizzleNV" ) ); + vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorEnableNV" ) ); + vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorLocationNV" ) ); + vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationModeNV" ) ); + vkCmdSetCoverageModulationTableEnableNV = + PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableEnableNV" ) ); + vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableNV" ) ); + vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetShadingRateImageEnableNV" ) ); + vkCmdSetRepresentativeFragmentTestEnableNV = + PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetRepresentativeFragmentTestEnableNV" ) ); + vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageReductionModeNV" ) ); + + //=== VK_ARM_tensors === + vkCreateTensorARM = PFN_vkCreateTensorARM( vkGetDeviceProcAddr( device, "vkCreateTensorARM" ) ); + vkDestroyTensorARM = PFN_vkDestroyTensorARM( vkGetDeviceProcAddr( device, "vkDestroyTensorARM" ) ); + vkCreateTensorViewARM = PFN_vkCreateTensorViewARM( vkGetDeviceProcAddr( device, "vkCreateTensorViewARM" ) ); + vkDestroyTensorViewARM = PFN_vkDestroyTensorViewARM( vkGetDeviceProcAddr( device, "vkDestroyTensorViewARM" ) ); + vkGetTensorMemoryRequirementsARM = PFN_vkGetTensorMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetTensorMemoryRequirementsARM" ) ); + vkBindTensorMemoryARM = PFN_vkBindTensorMemoryARM( vkGetDeviceProcAddr( device, "vkBindTensorMemoryARM" ) ); + vkGetDeviceTensorMemoryRequirementsARM = + PFN_vkGetDeviceTensorMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDeviceTensorMemoryRequirementsARM" ) ); + vkCmdCopyTensorARM = PFN_vkCmdCopyTensorARM( vkGetDeviceProcAddr( device, "vkCmdCopyTensorARM" ) ); + vkGetTensorOpaqueCaptureDescriptorDataARM = + PFN_vkGetTensorOpaqueCaptureDescriptorDataARM( vkGetDeviceProcAddr( device, "vkGetTensorOpaqueCaptureDescriptorDataARM" ) ); + vkGetTensorViewOpaqueCaptureDescriptorDataARM = + PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM( vkGetDeviceProcAddr( device, "vkGetTensorViewOpaqueCaptureDescriptorDataARM" ) ); + + //=== VK_EXT_shader_module_identifier === + vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleIdentifierEXT" ) ); + vkGetShaderModuleCreateInfoIdentifierEXT = + PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleCreateInfoIdentifierEXT" ) ); + + //=== VK_NV_optical_flow === + vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkCreateOpticalFlowSessionNV" ) ); + vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkDestroyOpticalFlowSessionNV" ) ); + vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) ); + vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) ); + + //=== VK_KHR_maintenance5 === + vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2KHR" ) ); + if ( !vkCmdBindIndexBuffer2 ) + vkCmdBindIndexBuffer2 = vkCmdBindIndexBuffer2KHR; + vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularityKHR" ) ); + if ( !vkGetRenderingAreaGranularity ) + vkGetRenderingAreaGranularity = vkGetRenderingAreaGranularityKHR; + vkGetDeviceImageSubresourceLayoutKHR = + PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayoutKHR" ) ); + if ( !vkGetDeviceImageSubresourceLayout ) + vkGetDeviceImageSubresourceLayout = vkGetDeviceImageSubresourceLayoutKHR; + vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2KHR" ) ); + if ( !vkGetImageSubresourceLayout2 ) + vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2KHR; + + //=== VK_AMD_anti_lag === + vkAntiLagUpdateAMD = PFN_vkAntiLagUpdateAMD( vkGetDeviceProcAddr( device, "vkAntiLagUpdateAMD" ) ); + + //=== VK_KHR_present_wait2 === + vkWaitForPresent2KHR = PFN_vkWaitForPresent2KHR( vkGetDeviceProcAddr( device, "vkWaitForPresent2KHR" ) ); + + //=== VK_EXT_shader_object === + vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetDeviceProcAddr( device, "vkCreateShadersEXT" ) ); + vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetDeviceProcAddr( device, "vkDestroyShaderEXT" ) ); + vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) ); + vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) ); + vkCmdSetDepthClampRangeEXT = PFN_vkCmdSetDepthClampRangeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampRangeEXT" ) ); + + //=== VK_KHR_pipeline_binary === + vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetDeviceProcAddr( device, "vkCreatePipelineBinariesKHR" ) ); + vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetDeviceProcAddr( device, "vkDestroyPipelineBinaryKHR" ) ); + vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetDeviceProcAddr( device, "vkGetPipelineKeyKHR" ) ); + vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetDeviceProcAddr( device, "vkGetPipelineBinaryDataKHR" ) ); + vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetDeviceProcAddr( device, "vkReleaseCapturedPipelineDataKHR" ) ); + + //=== VK_QCOM_tile_properties === + vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) ); + vkGetDynamicRenderingTilePropertiesQCOM = + PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) ); + + //=== VK_KHR_swapchain_maintenance1 === + vkReleaseSwapchainImagesKHR = PFN_vkReleaseSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesKHR" ) ); + + //=== VK_NV_cooperative_vector === + vkConvertCooperativeVectorMatrixNV = PFN_vkConvertCooperativeVectorMatrixNV( vkGetDeviceProcAddr( device, "vkConvertCooperativeVectorMatrixNV" ) ); + vkCmdConvertCooperativeVectorMatrixNV = + PFN_vkCmdConvertCooperativeVectorMatrixNV( vkGetDeviceProcAddr( device, "vkCmdConvertCooperativeVectorMatrixNV" ) ); + + //=== VK_NV_low_latency2 === + vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetDeviceProcAddr( device, "vkSetLatencySleepModeNV" ) ); + vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetDeviceProcAddr( device, "vkLatencySleepNV" ) ); + vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetDeviceProcAddr( device, "vkSetLatencyMarkerNV" ) ); + vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetDeviceProcAddr( device, "vkGetLatencyTimingsNV" ) ); + vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetDeviceProcAddr( device, "vkQueueNotifyOutOfBandNV" ) ); + + //=== VK_ARM_data_graph === + vkCreateDataGraphPipelinesARM = PFN_vkCreateDataGraphPipelinesARM( vkGetDeviceProcAddr( device, "vkCreateDataGraphPipelinesARM" ) ); + vkCreateDataGraphPipelineSessionARM = PFN_vkCreateDataGraphPipelineSessionARM( vkGetDeviceProcAddr( device, "vkCreateDataGraphPipelineSessionARM" ) ); + vkGetDataGraphPipelineSessionBindPointRequirementsARM = + PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineSessionBindPointRequirementsARM" ) ); + vkGetDataGraphPipelineSessionMemoryRequirementsARM = + PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineSessionMemoryRequirementsARM" ) ); + vkBindDataGraphPipelineSessionMemoryARM = + PFN_vkBindDataGraphPipelineSessionMemoryARM( vkGetDeviceProcAddr( device, "vkBindDataGraphPipelineSessionMemoryARM" ) ); + vkDestroyDataGraphPipelineSessionARM = + PFN_vkDestroyDataGraphPipelineSessionARM( vkGetDeviceProcAddr( device, "vkDestroyDataGraphPipelineSessionARM" ) ); + vkCmdDispatchDataGraphARM = PFN_vkCmdDispatchDataGraphARM( vkGetDeviceProcAddr( device, "vkCmdDispatchDataGraphARM" ) ); + vkGetDataGraphPipelineAvailablePropertiesARM = + PFN_vkGetDataGraphPipelineAvailablePropertiesARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineAvailablePropertiesARM" ) ); + vkGetDataGraphPipelinePropertiesARM = PFN_vkGetDataGraphPipelinePropertiesARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelinePropertiesARM" ) ); + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + vkCmdSetAttachmentFeedbackLoopEnableEXT = + PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) ); + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) ); +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_KHR_line_rasterization === + vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleKHR" ) ); + if ( !vkCmdSetLineStipple ) + vkCmdSetLineStipple = vkCmdSetLineStippleKHR; + + //=== VK_KHR_calibrated_timestamps === + vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) ); + + //=== VK_KHR_maintenance6 === + vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2KHR" ) ); + if ( !vkCmdBindDescriptorSets2 ) + vkCmdBindDescriptorSets2 = vkCmdBindDescriptorSets2KHR; + vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetDeviceProcAddr( device, "vkCmdPushConstants2KHR" ) ); + if ( !vkCmdPushConstants2 ) + vkCmdPushConstants2 = vkCmdPushConstants2KHR; + vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2KHR" ) ); + if ( !vkCmdPushDescriptorSet2 ) + vkCmdPushDescriptorSet2 = vkCmdPushDescriptorSet2KHR; + vkCmdPushDescriptorSetWithTemplate2KHR = + PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2KHR" ) ); + if ( !vkCmdPushDescriptorSetWithTemplate2 ) + vkCmdPushDescriptorSetWithTemplate2 = vkCmdPushDescriptorSetWithTemplate2KHR; + vkCmdSetDescriptorBufferOffsets2EXT = PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsets2EXT" ) ); + vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = + PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); + + //=== VK_QCOM_tile_memory_heap === + vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetDeviceProcAddr( device, "vkCmdBindTileMemoryQCOM" ) ); + + //=== VK_KHR_copy_memory_indirect === + vkCmdCopyMemoryIndirectKHR = PFN_vkCmdCopyMemoryIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectKHR" ) ); + vkCmdCopyMemoryToImageIndirectKHR = PFN_vkCmdCopyMemoryToImageIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectKHR" ) ); + + //=== VK_EXT_memory_decompression === + vkCmdDecompressMemoryEXT = PFN_vkCmdDecompressMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryEXT" ) ); + vkCmdDecompressMemoryIndirectCountEXT = + PFN_vkCmdDecompressMemoryIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountEXT" ) ); + + //=== VK_NV_external_compute_queue === + vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) ); + vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) ); + vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetDeviceProcAddr( device, "vkGetExternalComputeQueueDataNV" ) ); + + //=== VK_NV_cluster_acceleration_structure === + vkGetClusterAccelerationStructureBuildSizesNV = + PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetClusterAccelerationStructureBuildSizesNV" ) ); + vkCmdBuildClusterAccelerationStructureIndirectNV = + PFN_vkCmdBuildClusterAccelerationStructureIndirectNV( vkGetDeviceProcAddr( device, "vkCmdBuildClusterAccelerationStructureIndirectNV" ) ); + + //=== VK_NV_partitioned_acceleration_structure === + vkGetPartitionedAccelerationStructuresBuildSizesNV = + PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetPartitionedAccelerationStructuresBuildSizesNV" ) ); + vkCmdBuildPartitionedAccelerationStructuresNV = + PFN_vkCmdBuildPartitionedAccelerationStructuresNV( vkGetDeviceProcAddr( device, "vkCmdBuildPartitionedAccelerationStructuresNV" ) ); + + //=== VK_EXT_device_generated_commands === + vkGetGeneratedCommandsMemoryRequirementsEXT = + PFN_vkGetGeneratedCommandsMemoryRequirementsEXT( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsEXT" ) ); + vkCmdPreprocessGeneratedCommandsEXT = PFN_vkCmdPreprocessGeneratedCommandsEXT( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsEXT" ) ); + vkCmdExecuteGeneratedCommandsEXT = PFN_vkCmdExecuteGeneratedCommandsEXT( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsEXT" ) ); + vkCreateIndirectCommandsLayoutEXT = PFN_vkCreateIndirectCommandsLayoutEXT( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutEXT" ) ); + vkDestroyIndirectCommandsLayoutEXT = PFN_vkDestroyIndirectCommandsLayoutEXT( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutEXT" ) ); + vkCreateIndirectExecutionSetEXT = PFN_vkCreateIndirectExecutionSetEXT( vkGetDeviceProcAddr( device, "vkCreateIndirectExecutionSetEXT" ) ); + vkDestroyIndirectExecutionSetEXT = PFN_vkDestroyIndirectExecutionSetEXT( vkGetDeviceProcAddr( device, "vkDestroyIndirectExecutionSetEXT" ) ); + vkUpdateIndirectExecutionSetPipelineEXT = + PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetPipelineEXT" ) ); + vkUpdateIndirectExecutionSetShaderEXT = + PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetShaderEXT" ) ); + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) ); + vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) ); +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_fragment_density_map_offset === + vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdEndRendering2EXT" ) ); + if ( !vkCmdEndRendering2KHR ) + vkCmdEndRendering2KHR = vkCmdEndRendering2EXT; + + //=== VK_EXT_custom_resolve === + vkCmdBeginCustomResolveEXT = PFN_vkCmdBeginCustomResolveEXT( vkGetDeviceProcAddr( device, "vkCmdBeginCustomResolveEXT" ) ); + + //=== VK_KHR_maintenance10 === + vkCmdEndRendering2KHR = PFN_vkCmdEndRendering2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRendering2KHR" ) ); + + //=== VK_NV_compute_occupancy_priority === + vkCmdSetComputeOccupancyPriorityNV = PFN_vkCmdSetComputeOccupancyPriorityNV( vkGetDeviceProcAddr( device, "vkCmdSetComputeOccupancyPriorityNV" ) ); + } + + public: + //=== VK_VERSION_1_0 === + PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; + PFN_vkDestroyDevice vkDestroyDevice = 0; + PFN_vkGetDeviceQueue vkGetDeviceQueue = 0; + PFN_vkQueueSubmit vkQueueSubmit = 0; + PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; + PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; + PFN_vkAllocateMemory vkAllocateMemory = 0; + PFN_vkFreeMemory vkFreeMemory = 0; + PFN_vkMapMemory vkMapMemory = 0; + PFN_vkUnmapMemory vkUnmapMemory = 0; + PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; + PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; + PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; + PFN_vkBindBufferMemory vkBindBufferMemory = 0; + PFN_vkBindImageMemory vkBindImageMemory = 0; + PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; + PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; + PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0; + PFN_vkQueueBindSparse vkQueueBindSparse = 0; + PFN_vkCreateFence vkCreateFence = 0; + PFN_vkDestroyFence vkDestroyFence = 0; + PFN_vkResetFences vkResetFences = 0; + PFN_vkGetFenceStatus vkGetFenceStatus = 0; + PFN_vkWaitForFences vkWaitForFences = 0; + PFN_vkCreateSemaphore vkCreateSemaphore = 0; + PFN_vkDestroySemaphore vkDestroySemaphore = 0; + PFN_vkCreateQueryPool vkCreateQueryPool = 0; + PFN_vkDestroyQueryPool vkDestroyQueryPool = 0; + PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; + PFN_vkCreateBuffer vkCreateBuffer = 0; + PFN_vkDestroyBuffer vkDestroyBuffer = 0; + PFN_vkCreateImage vkCreateImage = 0; + PFN_vkDestroyImage vkDestroyImage = 0; + PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0; + PFN_vkCreateImageView vkCreateImageView = 0; + PFN_vkDestroyImageView vkDestroyImageView = 0; + PFN_vkCreateCommandPool vkCreateCommandPool = 0; + PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; + PFN_vkResetCommandPool vkResetCommandPool = 0; + PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; + PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; + PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; + PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; + PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; + PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; + PFN_vkCmdCopyImage vkCmdCopyImage = 0; + PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; + PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0; + PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; + PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; + PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; + PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; + PFN_vkCmdEndQuery vkCmdEndQuery = 0; + PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0; + PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; + PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; + PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; + PFN_vkCreateEvent vkCreateEvent = 0; + PFN_vkDestroyEvent vkDestroyEvent = 0; + PFN_vkGetEventStatus vkGetEventStatus = 0; + PFN_vkSetEvent vkSetEvent = 0; + PFN_vkResetEvent vkResetEvent = 0; + PFN_vkCreateBufferView vkCreateBufferView = 0; + PFN_vkDestroyBufferView vkDestroyBufferView = 0; + PFN_vkCreateShaderModule vkCreateShaderModule = 0; + PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; + PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; + PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0; + PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; + PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; + PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; + PFN_vkDestroyPipeline vkDestroyPipeline = 0; + PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; + PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; + PFN_vkCreateSampler vkCreateSampler = 0; + PFN_vkDestroySampler vkDestroySampler = 0; + PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; + PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; + PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; + PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; + PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; + PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; + PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; + PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; + PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; + PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; + PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; + PFN_vkCmdDispatch vkCmdDispatch = 0; + PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0; + PFN_vkCmdSetEvent vkCmdSetEvent = 0; + PFN_vkCmdResetEvent vkCmdResetEvent = 0; + PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; + PFN_vkCmdPushConstants vkCmdPushConstants = 0; + PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; + PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; + PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; + PFN_vkCreateRenderPass vkCreateRenderPass = 0; + PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; + PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; + PFN_vkCmdSetViewport vkCmdSetViewport = 0; + PFN_vkCmdSetScissor vkCmdSetScissor = 0; + PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; + PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; + PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0; + PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; + PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; + PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0; + PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0; + PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; + PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; + PFN_vkCmdDraw vkCmdDraw = 0; + PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; + PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0; + PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0; + PFN_vkCmdBlitImage vkCmdBlitImage = 0; + PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; + PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; + PFN_vkCmdResolveImage vkCmdResolveImage = 0; + PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; + PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; + PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; + + //=== VK_VERSION_1_1 === + PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; + PFN_vkBindImageMemory2 vkBindImageMemory2 = 0; + PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; + PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0; + PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0; + PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; + PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0; + PFN_vkTrimCommandPool vkTrimCommandPool = 0; + PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0; + PFN_vkCmdDispatchBase vkCmdDispatchBase = 0; + PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; + PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0; + PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; + PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0; + PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; + PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0; + + //=== VK_VERSION_1_2 === + PFN_vkResetQueryPool vkResetQueryPool = 0; + PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0; + PFN_vkWaitSemaphores vkWaitSemaphores = 0; + PFN_vkSignalSemaphore vkSignalSemaphore = 0; + PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0; + PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0; + PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0; + PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0; + PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0; + PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0; + PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0; + PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0; + PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0; + + //=== VK_VERSION_1_3 === + PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0; + PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0; + PFN_vkSetPrivateData vkSetPrivateData = 0; + PFN_vkGetPrivateData vkGetPrivateData = 0; + PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0; + PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0; + PFN_vkQueueSubmit2 vkQueueSubmit2 = 0; + PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0; + PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0; + PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0; + PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0; + PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0; + PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0; + PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0; + PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0; + PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0; + PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0; + PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0; + PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0; + PFN_vkCmdBeginRendering vkCmdBeginRendering = 0; + PFN_vkCmdEndRendering vkCmdEndRendering = 0; + PFN_vkCmdSetCullMode vkCmdSetCullMode = 0; + PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0; + PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0; + PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0; + PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0; + PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0; + PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0; + PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0; + PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0; + PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0; + PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0; + PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0; + PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0; + PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0; + PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0; + + //=== VK_VERSION_1_4 === + PFN_vkMapMemory2 vkMapMemory2 = 0; + PFN_vkUnmapMemory2 vkUnmapMemory2 = 0; + PFN_vkGetDeviceImageSubresourceLayout vkGetDeviceImageSubresourceLayout = 0; + PFN_vkGetImageSubresourceLayout2 vkGetImageSubresourceLayout2 = 0; + PFN_vkCopyMemoryToImage vkCopyMemoryToImage = 0; + PFN_vkCopyImageToMemory vkCopyImageToMemory = 0; + PFN_vkCopyImageToImage vkCopyImageToImage = 0; + PFN_vkTransitionImageLayout vkTransitionImageLayout = 0; + PFN_vkCmdPushDescriptorSet vkCmdPushDescriptorSet = 0; + PFN_vkCmdPushDescriptorSetWithTemplate vkCmdPushDescriptorSetWithTemplate = 0; + PFN_vkCmdBindDescriptorSets2 vkCmdBindDescriptorSets2 = 0; + PFN_vkCmdPushConstants2 vkCmdPushConstants2 = 0; + PFN_vkCmdPushDescriptorSet2 vkCmdPushDescriptorSet2 = 0; + PFN_vkCmdPushDescriptorSetWithTemplate2 vkCmdPushDescriptorSetWithTemplate2 = 0; + PFN_vkCmdSetLineStipple vkCmdSetLineStipple = 0; + PFN_vkCmdBindIndexBuffer2 vkCmdBindIndexBuffer2 = 0; + PFN_vkGetRenderingAreaGranularity vkGetRenderingAreaGranularity = 0; + PFN_vkCmdSetRenderingAttachmentLocations vkCmdSetRenderingAttachmentLocations = 0; + PFN_vkCmdSetRenderingInputAttachmentIndices vkCmdSetRenderingInputAttachmentIndices = 0; + + //=== VK_KHR_swapchain === + PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0; + PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; + PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; + PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; + PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; + PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; + PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; + PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; + + //=== VK_KHR_display_swapchain === + PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; + + //=== VK_EXT_debug_marker === + PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; + PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; + PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; + PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; + PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; + + //=== VK_KHR_video_queue === + PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0; + PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0; + PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0; + PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0; + PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0; + PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0; + PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0; + PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0; + PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0; + PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0; + + //=== VK_KHR_video_decode_queue === + PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0; + + //=== VK_EXT_transform_feedback === + PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0; + PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0; + PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0; + PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0; + PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0; + PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0; + + //=== VK_NVX_binary_import === + PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0; + PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0; + PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0; + PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0; + PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0; + + //=== VK_NVX_image_view_handle === + PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0; + PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX = 0; + PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0; + PFN_vkGetDeviceCombinedImageSamplerIndexNVX vkGetDeviceCombinedImageSamplerIndexNVX = 0; + + //=== VK_AMD_draw_indirect_count === + PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; + PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0; + + //=== VK_AMD_shader_info === + PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0; + + //=== VK_KHR_dynamic_rendering === + PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0; + PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; +# else + PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_device_group === + PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; + PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0; + PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0; + + //=== VK_KHR_maintenance1 === + PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; + PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; +# else + PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0; + PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; + PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; +# else + PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0; + PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; + + //=== VK_KHR_push_descriptor === + PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0; + PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0; + + //=== VK_EXT_conditional_rendering === + PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0; + PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0; + + //=== VK_KHR_descriptor_update_template === + PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; + PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0; + PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0; + + //=== VK_NV_clip_space_w_scaling === + PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; + + //=== VK_EXT_display_control === + PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; + PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; + PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; + PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0; + + //=== VK_GOOGLE_display_timing === + PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; + PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; + + //=== VK_EXT_discard_rectangles === + PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; + PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT = 0; + PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT = 0; + + //=== VK_EXT_hdr_metadata === + PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; + + //=== VK_KHR_create_renderpass2 === + PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0; + PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0; + PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0; + PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0; + + //=== VK_KHR_shared_presentable_image === + PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; + PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; +# else + PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; + PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; + PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0; + + //=== VK_KHR_performance_query === + PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; + PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0; + + //=== VK_EXT_debug_utils === + PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; + PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; + PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0; + PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; + PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; + PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; + PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; + PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; + PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; +# else + PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; + PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX = 0; + PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX = 0; + PFN_vkGetExecutionGraphPipelineNodeIndexAMDX vkGetExecutionGraphPipelineNodeIndexAMDX = 0; + PFN_vkCmdInitializeGraphScratchMemoryAMDX vkCmdInitializeGraphScratchMemoryAMDX = 0; + PFN_vkCmdDispatchGraphAMDX vkCmdDispatchGraphAMDX = 0; + PFN_vkCmdDispatchGraphIndirectAMDX vkCmdDispatchGraphIndirectAMDX = 0; + PFN_vkCmdDispatchGraphIndirectCountAMDX vkCmdDispatchGraphIndirectCountAMDX = 0; +# else + PFN_dummy vkCreateExecutionGraphPipelinesAMDX_placeholder = 0; + PFN_dummy vkGetExecutionGraphPipelineScratchSizeAMDX_placeholder = 0; + PFN_dummy vkGetExecutionGraphPipelineNodeIndexAMDX_placeholder = 0; + PFN_dummy vkCmdInitializeGraphScratchMemoryAMDX_placeholder = 0; + PFN_dummy vkCmdDispatchGraphAMDX_placeholder = 0; + PFN_dummy vkCmdDispatchGraphIndirectAMDX_placeholder = 0; + PFN_dummy vkCmdDispatchGraphIndirectCountAMDX_placeholder = 0; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + PFN_vkWriteSamplerDescriptorsEXT vkWriteSamplerDescriptorsEXT = 0; + PFN_vkWriteResourceDescriptorsEXT vkWriteResourceDescriptorsEXT = 0; + PFN_vkCmdBindSamplerHeapEXT vkCmdBindSamplerHeapEXT = 0; + PFN_vkCmdBindResourceHeapEXT vkCmdBindResourceHeapEXT = 0; + PFN_vkCmdPushDataEXT vkCmdPushDataEXT = 0; + PFN_vkGetImageOpaqueCaptureDataEXT vkGetImageOpaqueCaptureDataEXT = 0; + PFN_vkRegisterCustomBorderColorEXT vkRegisterCustomBorderColorEXT = 0; + PFN_vkUnregisterCustomBorderColorEXT vkUnregisterCustomBorderColorEXT = 0; + PFN_vkGetTensorOpaqueCaptureDataARM vkGetTensorOpaqueCaptureDataARM = 0; + + //=== VK_EXT_sample_locations === + PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; + + //=== VK_KHR_get_memory_requirements2 === + PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0; + PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; + PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0; + + //=== VK_KHR_acceleration_structure === + PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0; + PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0; + PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0; + PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0; + PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0; + PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0; + PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0; + PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0; + PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0; + PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0; + PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0; + PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0; + PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0; + PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0; + PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0; + PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0; + + //=== VK_KHR_ray_tracing_pipeline === + PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0; + PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0; + PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0; + PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0; + PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0; + PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0; + PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0; + + //=== VK_KHR_sampler_ycbcr_conversion === + PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; + PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0; + + //=== VK_KHR_bind_memory2 === + PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; + PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0; + + //=== VK_EXT_image_drm_format_modifier === + PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0; + + //=== VK_EXT_validation_cache === + PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0; + PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; + PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0; + PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; + + //=== VK_NV_shading_rate_image === + PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0; + PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0; + PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0; + + //=== VK_NV_ray_tracing === + PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0; + PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0; + PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0; + PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0; + PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0; + PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0; + PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0; + PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0; + PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; + PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0; + PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0; + PFN_vkCompileDeferredNV vkCompileDeferredNV = 0; + + //=== VK_KHR_maintenance3 === + PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0; + + //=== VK_KHR_draw_indirect_count === + PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; + PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0; + + //=== VK_EXT_external_memory_host === + PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0; + + //=== VK_AMD_buffer_marker === + PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; + PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0; + + //=== VK_EXT_calibrated_timestamps === + PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0; + + //=== VK_NV_mesh_shader === + PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0; + PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0; + PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0; + + //=== VK_NV_scissor_exclusive === + PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV = 0; + PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0; + + //=== VK_NV_device_diagnostic_checkpoints === + PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0; + PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0; + PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0; + + //=== VK_KHR_timeline_semaphore === + PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0; + PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0; + PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0; + + //=== VK_EXT_present_timing === + PFN_vkSetSwapchainPresentTimingQueueSizeEXT vkSetSwapchainPresentTimingQueueSizeEXT = 0; + PFN_vkGetSwapchainTimingPropertiesEXT vkGetSwapchainTimingPropertiesEXT = 0; + PFN_vkGetSwapchainTimeDomainPropertiesEXT vkGetSwapchainTimeDomainPropertiesEXT = 0; + PFN_vkGetPastPresentationTimingEXT vkGetPastPresentationTimingEXT = 0; + + //=== VK_INTEL_performance_query === + PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; + PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; + PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; + PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0; + PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; + PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; + PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0; + PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0; + PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0; + + //=== VK_AMD_display_native_hdr === + PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0; + + //=== VK_KHR_fragment_shading_rate === + PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0; + + //=== VK_KHR_dynamic_rendering_local_read === + PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR = 0; + PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR = 0; + + //=== VK_EXT_buffer_device_address === + PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0; + + //=== VK_KHR_present_wait === + PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0; + PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; + PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; +# else + PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; + PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; + PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_buffer_device_address === + PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0; + PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0; + PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0; + + //=== VK_EXT_line_rasterization === + PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0; + + //=== VK_EXT_host_query_reset === + PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0; + + //=== VK_EXT_extended_dynamic_state === + PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0; + PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0; + PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0; + PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0; + PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0; + PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0; + PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0; + PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0; + PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0; + PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0; + PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0; + PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0; + + //=== VK_KHR_deferred_host_operations === + PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0; + PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0; + PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0; + PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0; + PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0; + + //=== VK_KHR_pipeline_executable_properties === + PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0; + PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0; + PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0; + + //=== VK_EXT_host_image_copy === + PFN_vkCopyMemoryToImageEXT vkCopyMemoryToImageEXT = 0; + PFN_vkCopyImageToMemoryEXT vkCopyImageToMemoryEXT = 0; + PFN_vkCopyImageToImageEXT vkCopyImageToImageEXT = 0; + PFN_vkTransitionImageLayoutEXT vkTransitionImageLayoutEXT = 0; + PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT = 0; + + //=== VK_KHR_map_memory2 === + PFN_vkMapMemory2KHR vkMapMemory2KHR = 0; + PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR = 0; + + //=== VK_EXT_swapchain_maintenance1 === + PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT = 0; + + //=== VK_NV_device_generated_commands === + PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0; + PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0; + PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0; + PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0; + PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0; + PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0; + + //=== VK_EXT_depth_bias_control === + PFN_vkCmdSetDepthBias2EXT vkCmdSetDepthBias2EXT = 0; + + //=== VK_EXT_private_data === + PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0; + PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0; + PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0; + PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0; + + //=== VK_KHR_video_encode_queue === + PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR = 0; + PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + PFN_vkCreateCudaModuleNV vkCreateCudaModuleNV = 0; + PFN_vkGetCudaModuleCacheNV vkGetCudaModuleCacheNV = 0; + PFN_vkCreateCudaFunctionNV vkCreateCudaFunctionNV = 0; + PFN_vkDestroyCudaModuleNV vkDestroyCudaModuleNV = 0; + PFN_vkDestroyCudaFunctionNV vkDestroyCudaFunctionNV = 0; + PFN_vkCmdCudaLaunchKernelNV vkCmdCudaLaunchKernelNV = 0; +# else + PFN_dummy vkCreateCudaModuleNV_placeholder = 0; + PFN_dummy vkGetCudaModuleCacheNV_placeholder = 0; + PFN_dummy vkCreateCudaFunctionNV_placeholder = 0; + PFN_dummy vkDestroyCudaModuleNV_placeholder = 0; + PFN_dummy vkDestroyCudaFunctionNV_placeholder = 0; + PFN_dummy vkCmdCudaLaunchKernelNV_placeholder = 0; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + PFN_vkCmdDispatchTileQCOM vkCmdDispatchTileQCOM = 0; + PFN_vkCmdBeginPerTileExecutionQCOM vkCmdBeginPerTileExecutionQCOM = 0; + PFN_vkCmdEndPerTileExecutionQCOM vkCmdEndPerTileExecutionQCOM = 0; + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0; +# else + PFN_dummy vkExportMetalObjectsEXT_placeholder = 0; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0; + PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0; + PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0; + PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0; + PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0; + PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0; + + //=== VK_EXT_descriptor_buffer === + PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT = 0; + PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT = 0; + PFN_vkGetDescriptorEXT vkGetDescriptorEXT = 0; + PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT = 0; + PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT = 0; + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 0; + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT = 0; + PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT = 0; + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT = 0; + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT = 0; + PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 0; + + //=== VK_NV_fragment_shading_rate_enums === + PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0; + + //=== VK_EXT_mesh_shader === + PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT = 0; + PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT = 0; + PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = 0; + + //=== VK_KHR_copy_commands2 === + PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0; + PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0; + PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0; + PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0; + PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0; + PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0; + + //=== VK_EXT_device_fault === + PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT = 0; + + //=== VK_EXT_vertex_input_dynamic_state === + PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0; + PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0; +# else + PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; + PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0; + PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0; +# else + PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; + PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0; + PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0; + PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0; + PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0; + PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0; +# else + PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; + PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; + PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; + PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; + PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0; + PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0; + + //=== VK_HUAWEI_invocation_mask === + PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0; + + //=== VK_NV_external_memory_rdma === + PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0; + + //=== VK_EXT_pipeline_properties === + PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT = 0; + + //=== VK_EXT_extended_dynamic_state2 === + PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0; + PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0; + PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0; + PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0; + PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0; + + //=== VK_EXT_color_write_enable === + PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0; + + //=== VK_KHR_ray_tracing_maintenance1 === + PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR = 0; + + //=== VK_EXT_multi_draw === + PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0; + PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0; + + //=== VK_EXT_opacity_micromap === + PFN_vkCreateMicromapEXT vkCreateMicromapEXT = 0; + PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT = 0; + PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT = 0; + PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT = 0; + PFN_vkCopyMicromapEXT vkCopyMicromapEXT = 0; + PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT = 0; + PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT = 0; + PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT = 0; + PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT = 0; + PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT = 0; + PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT = 0; + PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT = 0; + PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT = 0; + PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT = 0; + + //=== VK_HUAWEI_cluster_culling_shader === + PFN_vkCmdDrawClusterHUAWEI vkCmdDrawClusterHUAWEI = 0; + PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI = 0; + + //=== VK_EXT_pageable_device_local_memory === + PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0; + + //=== VK_KHR_maintenance4 === + PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0; + PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0; + PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0; + + //=== VK_VALVE_descriptor_set_host_mapping === + PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0; + PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE = 0; + + //=== VK_NV_copy_memory_indirect === + PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV = 0; + PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV = 0; + + //=== VK_NV_memory_decompression === + PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV = 0; + PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV = 0; + + //=== VK_NV_device_generated_commands_compute === + PFN_vkGetPipelineIndirectMemoryRequirementsNV vkGetPipelineIndirectMemoryRequirementsNV = 0; + PFN_vkCmdUpdatePipelineIndirectBufferNV vkCmdUpdatePipelineIndirectBufferNV = 0; + PFN_vkGetPipelineIndirectDeviceAddressNV vkGetPipelineIndirectDeviceAddressNV = 0; + +# if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + PFN_vkGetNativeBufferPropertiesOHOS vkGetNativeBufferPropertiesOHOS = 0; + PFN_vkGetMemoryNativeBufferOHOS vkGetMemoryNativeBufferOHOS = 0; +# else + PFN_dummy vkGetNativeBufferPropertiesOHOS_placeholder = 0; + PFN_dummy vkGetMemoryNativeBufferOHOS_placeholder = 0; +# endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_extended_dynamic_state3 === + PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT = 0; + PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT = 0; + PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT = 0; + PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT = 0; + PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT = 0; + PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT = 0; + PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT = 0; + PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT = 0; + PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT = 0; + PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT = 0; + PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT = 0; + PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT = 0; + PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT = 0; + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT = 0; + PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT = 0; + PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT = 0; + PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT = 0; + PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT = 0; + PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT = 0; + PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT = 0; + PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT = 0; + PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV = 0; + PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV = 0; + PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV = 0; + PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV = 0; + PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV = 0; + PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV = 0; + PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV = 0; + PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV = 0; + PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV = 0; + PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV = 0; + + //=== VK_ARM_tensors === + PFN_vkCreateTensorARM vkCreateTensorARM = 0; + PFN_vkDestroyTensorARM vkDestroyTensorARM = 0; + PFN_vkCreateTensorViewARM vkCreateTensorViewARM = 0; + PFN_vkDestroyTensorViewARM vkDestroyTensorViewARM = 0; + PFN_vkGetTensorMemoryRequirementsARM vkGetTensorMemoryRequirementsARM = 0; + PFN_vkBindTensorMemoryARM vkBindTensorMemoryARM = 0; + PFN_vkGetDeviceTensorMemoryRequirementsARM vkGetDeviceTensorMemoryRequirementsARM = 0; + PFN_vkCmdCopyTensorARM vkCmdCopyTensorARM = 0; + PFN_vkGetTensorOpaqueCaptureDescriptorDataARM vkGetTensorOpaqueCaptureDescriptorDataARM = 0; + PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM vkGetTensorViewOpaqueCaptureDescriptorDataARM = 0; + + //=== VK_EXT_shader_module_identifier === + PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT = 0; + PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT = 0; + + //=== VK_NV_optical_flow === + PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV = 0; + PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV = 0; + PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV = 0; + PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV = 0; + + //=== VK_KHR_maintenance5 === + PFN_vkCmdBindIndexBuffer2KHR vkCmdBindIndexBuffer2KHR = 0; + PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR = 0; + PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR = 0; + PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR = 0; + + //=== VK_AMD_anti_lag === + PFN_vkAntiLagUpdateAMD vkAntiLagUpdateAMD = 0; + + //=== VK_KHR_present_wait2 === + PFN_vkWaitForPresent2KHR vkWaitForPresent2KHR = 0; + + //=== VK_EXT_shader_object === + PFN_vkCreateShadersEXT vkCreateShadersEXT = 0; + PFN_vkDestroyShaderEXT vkDestroyShaderEXT = 0; + PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0; + PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 0; + PFN_vkCmdSetDepthClampRangeEXT vkCmdSetDepthClampRangeEXT = 0; + + //=== VK_KHR_pipeline_binary === + PFN_vkCreatePipelineBinariesKHR vkCreatePipelineBinariesKHR = 0; + PFN_vkDestroyPipelineBinaryKHR vkDestroyPipelineBinaryKHR = 0; + PFN_vkGetPipelineKeyKHR vkGetPipelineKeyKHR = 0; + PFN_vkGetPipelineBinaryDataKHR vkGetPipelineBinaryDataKHR = 0; + PFN_vkReleaseCapturedPipelineDataKHR vkReleaseCapturedPipelineDataKHR = 0; + + //=== VK_QCOM_tile_properties === + PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0; + PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0; + + //=== VK_KHR_swapchain_maintenance1 === + PFN_vkReleaseSwapchainImagesKHR vkReleaseSwapchainImagesKHR = 0; + + //=== VK_NV_cooperative_vector === + PFN_vkConvertCooperativeVectorMatrixNV vkConvertCooperativeVectorMatrixNV = 0; + PFN_vkCmdConvertCooperativeVectorMatrixNV vkCmdConvertCooperativeVectorMatrixNV = 0; + + //=== VK_NV_low_latency2 === + PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV = 0; + PFN_vkLatencySleepNV vkLatencySleepNV = 0; + PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV = 0; + PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV = 0; + PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV = 0; + + //=== VK_ARM_data_graph === + PFN_vkCreateDataGraphPipelinesARM vkCreateDataGraphPipelinesARM = 0; + PFN_vkCreateDataGraphPipelineSessionARM vkCreateDataGraphPipelineSessionARM = 0; + PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM vkGetDataGraphPipelineSessionBindPointRequirementsARM = 0; + PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM vkGetDataGraphPipelineSessionMemoryRequirementsARM = 0; + PFN_vkBindDataGraphPipelineSessionMemoryARM vkBindDataGraphPipelineSessionMemoryARM = 0; + PFN_vkDestroyDataGraphPipelineSessionARM vkDestroyDataGraphPipelineSessionARM = 0; + PFN_vkCmdDispatchDataGraphARM vkCmdDispatchDataGraphARM = 0; + PFN_vkGetDataGraphPipelineAvailablePropertiesARM vkGetDataGraphPipelineAvailablePropertiesARM = 0; + PFN_vkGetDataGraphPipelinePropertiesARM vkGetDataGraphPipelinePropertiesARM = 0; + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT = 0; + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX = 0; +# else + PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder = 0; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_KHR_line_rasterization === + PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0; + + //=== VK_KHR_calibrated_timestamps === + PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR = 0; + + //=== VK_KHR_maintenance6 === + PFN_vkCmdBindDescriptorSets2KHR vkCmdBindDescriptorSets2KHR = 0; + PFN_vkCmdPushConstants2KHR vkCmdPushConstants2KHR = 0; + PFN_vkCmdPushDescriptorSet2KHR vkCmdPushDescriptorSet2KHR = 0; + PFN_vkCmdPushDescriptorSetWithTemplate2KHR vkCmdPushDescriptorSetWithTemplate2KHR = 0; + PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0; + PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0; + + //=== VK_QCOM_tile_memory_heap === + PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM = 0; + + //=== VK_KHR_copy_memory_indirect === + PFN_vkCmdCopyMemoryIndirectKHR vkCmdCopyMemoryIndirectKHR = 0; + PFN_vkCmdCopyMemoryToImageIndirectKHR vkCmdCopyMemoryToImageIndirectKHR = 0; + + //=== VK_EXT_memory_decompression === + PFN_vkCmdDecompressMemoryEXT vkCmdDecompressMemoryEXT = 0; + PFN_vkCmdDecompressMemoryIndirectCountEXT vkCmdDecompressMemoryIndirectCountEXT = 0; + + //=== VK_NV_external_compute_queue === + PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0; + PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0; + PFN_vkGetExternalComputeQueueDataNV vkGetExternalComputeQueueDataNV = 0; + + //=== VK_NV_cluster_acceleration_structure === + PFN_vkGetClusterAccelerationStructureBuildSizesNV vkGetClusterAccelerationStructureBuildSizesNV = 0; + PFN_vkCmdBuildClusterAccelerationStructureIndirectNV vkCmdBuildClusterAccelerationStructureIndirectNV = 0; + + //=== VK_NV_partitioned_acceleration_structure === + PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV vkGetPartitionedAccelerationStructuresBuildSizesNV = 0; + PFN_vkCmdBuildPartitionedAccelerationStructuresNV vkCmdBuildPartitionedAccelerationStructuresNV = 0; + + //=== VK_EXT_device_generated_commands === + PFN_vkGetGeneratedCommandsMemoryRequirementsEXT vkGetGeneratedCommandsMemoryRequirementsEXT = 0; + PFN_vkCmdPreprocessGeneratedCommandsEXT vkCmdPreprocessGeneratedCommandsEXT = 0; + PFN_vkCmdExecuteGeneratedCommandsEXT vkCmdExecuteGeneratedCommandsEXT = 0; + PFN_vkCreateIndirectCommandsLayoutEXT vkCreateIndirectCommandsLayoutEXT = 0; + PFN_vkDestroyIndirectCommandsLayoutEXT vkDestroyIndirectCommandsLayoutEXT = 0; + PFN_vkCreateIndirectExecutionSetEXT vkCreateIndirectExecutionSetEXT = 0; + PFN_vkDestroyIndirectExecutionSetEXT vkDestroyIndirectExecutionSetEXT = 0; + PFN_vkUpdateIndirectExecutionSetPipelineEXT vkUpdateIndirectExecutionSetPipelineEXT = 0; + PFN_vkUpdateIndirectExecutionSetShaderEXT vkUpdateIndirectExecutionSetShaderEXT = 0; + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + PFN_vkGetMemoryMetalHandleEXT vkGetMemoryMetalHandleEXT = 0; + PFN_vkGetMemoryMetalHandlePropertiesEXT vkGetMemoryMetalHandlePropertiesEXT = 0; +# else + PFN_dummy vkGetMemoryMetalHandleEXT_placeholder = 0; + PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder = 0; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_fragment_density_map_offset === + PFN_vkCmdEndRendering2EXT vkCmdEndRendering2EXT = 0; + + //=== VK_EXT_custom_resolve === + PFN_vkCmdBeginCustomResolveEXT vkCmdBeginCustomResolveEXT = 0; + + //=== VK_KHR_maintenance10 === + PFN_vkCmdEndRendering2KHR vkCmdEndRendering2KHR = 0; + + //=== VK_NV_compute_occupancy_priority === + PFN_vkCmdSetComputeOccupancyPriorityNV vkCmdSetComputeOccupancyPriorityNV = 0; + }; + + } // namespace detail + + //======================================== + //=== RAII HANDLE forward declarations === + //======================================== + + //=== VK_VERSION_1_0 === + class Instance; + class PhysicalDevice; + class Device; + class Queue; + class DeviceMemory; + class Fence; + class Semaphore; + class QueryPool; + class Buffer; + class Image; + class ImageView; + class CommandPool; + class CommandBuffer; + class Event; + class BufferView; + class ShaderModule; + class PipelineCache; + class Pipeline; + class PipelineLayout; + class Sampler; + class DescriptorPool; + class DescriptorSet; + class DescriptorSetLayout; + class Framebuffer; + class RenderPass; + + //=== VK_VERSION_1_1 === + class DescriptorUpdateTemplate; + class SamplerYcbcrConversion; + + //=== VK_VERSION_1_3 === + class PrivateDataSlot; + + //=== VK_KHR_surface === + class SurfaceKHR; + + //=== VK_KHR_swapchain === + class SwapchainKHR; + + //=== VK_KHR_display === + class DisplayKHR; + class DisplayModeKHR; + + //=== VK_EXT_debug_report === + class DebugReportCallbackEXT; + + //=== VK_KHR_video_queue === + class VideoSessionKHR; + class VideoSessionParametersKHR; + + //=== VK_NVX_binary_import === + class CuModuleNVX; + class CuFunctionNVX; + + //=== VK_KHR_descriptor_update_template === + using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; + + //=== VK_EXT_debug_utils === + class DebugUtilsMessengerEXT; + + //=== VK_EXT_descriptor_heap === + class TensorARM; + + //=== VK_KHR_acceleration_structure === + class AccelerationStructureKHR; + + //=== VK_KHR_sampler_ycbcr_conversion === + using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; + + //=== VK_EXT_validation_cache === + class ValidationCacheEXT; + + //=== VK_NV_ray_tracing === + class AccelerationStructureNV; + + //=== VK_INTEL_performance_query === + class PerformanceConfigurationINTEL; + + //=== VK_KHR_deferred_host_operations === + class DeferredOperationKHR; + + //=== VK_NV_device_generated_commands === + class IndirectCommandsLayoutNV; + + //=== VK_EXT_private_data === + using PrivateDataSlotEXT = PrivateDataSlot; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + class CudaModuleNV; + class CudaFunctionNV; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + class BufferCollectionFUCHSIA; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + class MicromapEXT; + + //=== VK_ARM_tensors === + class TensorARM; + class TensorViewARM; + + //=== VK_NV_optical_flow === + class OpticalFlowSessionNV; + + //=== VK_EXT_shader_object === + class ShaderEXT; + + //=== VK_KHR_pipeline_binary === + class PipelineBinaryKHR; + + //=== VK_ARM_data_graph === + class DataGraphPipelineSessionARM; + + //=== VK_NV_external_compute_queue === + class ExternalComputeQueueNV; + + //=== VK_EXT_device_generated_commands === + class IndirectCommandsLayoutEXT; + class IndirectExecutionSetEXT; + + //==================== + //=== RAII HANDLES === + //==================== + + template + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false; + }; + + class Context + { + public: +# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL + Context() : m_dispatcher( new detail::ContextDispatcher( m_dynamicLoader.getProcAddress( "vkGetInstanceProcAddr" ) ) ) +# else + Context( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) : m_dispatcher( new detail::ContextDispatcher( getInstanceProcAddr ) ) +# endif + { + } + + ~Context() = default; + + Context( Context const & ) = delete; + Context( Context && rhs ) VULKAN_HPP_NOEXCEPT +# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL + : m_dynamicLoader( std::move( rhs.m_dynamicLoader ) ) + , m_dispatcher( rhs.m_dispatcher.release() ) +# else + : m_dispatcher( rhs.m_dispatcher.release() ) +# endif + { + } + Context & operator=( Context const & ) = delete; + + Context & operator=( Context && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { +# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL + m_dynamicLoader = std::move( rhs.m_dynamicLoader ); +# endif + m_dispatcher.reset( rhs.m_dispatcher.release() ); + } + return *this; + } + + detail::ContextDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return &*m_dispatcher; + } + + void swap( Context & rhs ) + { +# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL + std::swap( m_dynamicLoader, rhs.m_dynamicLoader ); +# endif + m_dispatcher.swap( rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createInstance( InstanceCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkEnumerateInstanceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateInstanceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; + + // wrapper function for command vkEnumerateInstanceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateInstanceLayerProperties() const; + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html + VULKAN_HPP_NODISCARD typename ResultValueType::type enumerateInstanceVersion() const; + + private: +# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL + VULKAN_HPP_NAMESPACE::detail::DynamicLoader m_dynamicLoader; +# endif + std::unique_ptr m_dispatcher; + }; + + // wrapper class for handle VkInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstance.html + class Instance + { + public: + using CType = VkInstance; + using CppType = VULKAN_HPP_NAMESPACE::Instance; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eInstance; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Instance( Context const & context, InstanceCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = context.createInstance( createInfo, allocator ); + } +# endif + + Instance( Context const & context, VkInstance instance, Optional allocator = nullptr ) + : m_instance( instance ), m_allocator( static_cast( allocator ) ) + { + m_dispatcher.reset( new detail::InstanceDispatcher( context.getDispatcher()->vkGetInstanceProcAddr, static_cast( m_instance ) ) ); + } + + Instance( std::nullptr_t ) {} + + ~Instance() + { + clear(); + } + + Instance() = delete; + Instance( Instance const & ) = delete; + + Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT + : m_instance( exchange( rhs.m_instance, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( rhs.m_dispatcher.release() ) + { + } + + Instance & operator=( Instance const & ) = delete; + + Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_instance, rhs.m_instance ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::Instance const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_instance; + } + + VULKAN_HPP_NAMESPACE::Instance const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_instance ); + } + + operator VULKAN_HPP_NAMESPACE::Instance() const VULKAN_HPP_NOEXCEPT + { + return m_instance; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_instance ) + { + getDispatcher()->vkDestroyInstance( static_cast( m_instance ), reinterpret_cast( m_allocator ) ); + } + m_instance = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::Instance release() + { + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_instance, nullptr ); + } + + detail::InstanceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return &*m_dispatcher; + } + + void swap( Instance & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_instance, rhs.m_instance ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type enumeratePhysicalDevices() const; + + // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html + VULKAN_HPP_NODISCARD PFN_VoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkEnumeratePhysicalDeviceGroups, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type enumeratePhysicalDeviceGroups() const; + + //=== VK_KHR_display === + + // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDisplayPlaneSurfaceKHR( DisplaySurfaceCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + +# if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createXlibSurfaceKHR( XlibSurfaceCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +# if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createXcbSurfaceKHR( XcbSurfaceCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_XCB_KHR*/ + +# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createWaylandSurfaceKHR( WaylandSurfaceCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createAndroidSurfaceKHR( AndroidSurfaceCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createWin32SurfaceKHR( Win32SurfaceCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + + // wrapper function for command vkCreateDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDebugReportCallbackEXT( DebugReportCallbackCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html + void debugReportMessageEXT( DebugReportFlagsEXT flags, + DebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const std::string & layerPrefix, + const std::string & message ) const VULKAN_HPP_NOEXCEPT; + +# if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createStreamDescriptorSurfaceGGP( StreamDescriptorSurfaceCreateInfoGGP const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_GGP*/ + +# if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createViSurfaceNN( ViSurfaceCreateInfoNN const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_device_group_creation === + + // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type enumeratePhysicalDeviceGroupsKHR() const; + +# if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createIOSSurfaceMVK( IOSSurfaceCreateInfoMVK const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_IOS_MVK*/ + +# if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createMacOSSurfaceMVK( MacOSSurfaceCreateInfoMVK const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + + // wrapper function for command vkCreateDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDebugUtilsMessengerEXT( DebugUtilsMessengerCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkSubmitDebugUtilsMessageEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html + void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + DebugUtilsMessageTypeFlagsEXT messageTypes, + const DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createImagePipeSurfaceFUCHSIA( ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createMetalSurfaceEXT( MetalSurfaceCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_headless_surface === + + // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createHeadlessSurfaceEXT( HeadlessSurfaceCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + +# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDirectFBSurfaceEXT( DirectFBSurfaceCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createScreenSurfaceQNX( ScreenSurfaceCreateInfoQNX const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + +# if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + + // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSurfaceOHOS( SurfaceCreateInfoOHOS const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_OHOS*/ + + private: + VULKAN_HPP_NAMESPACE::Instance m_instance = {}; + const AllocationCallbacks * m_allocator = {}; + std::unique_ptr m_dispatcher; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPhysicalDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice.html + class PhysicalDevice + { + public: + using CType = VkPhysicalDevice; + using CppType = VULKAN_HPP_NAMESPACE::PhysicalDevice; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePhysicalDevice; + + public: + PhysicalDevice( Instance const & instance, VkPhysicalDevice physicalDevice ) + : m_physicalDevice( physicalDevice ), m_dispatcher( instance.getDispatcher() ) + { + } + + PhysicalDevice( std::nullptr_t ) {} + + ~PhysicalDevice() + { + clear(); + } + + PhysicalDevice() = delete; + + PhysicalDevice( PhysicalDevice const & rhs ) : m_physicalDevice( rhs.m_physicalDevice ), m_dispatcher( rhs.m_dispatcher ) {} + + PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT + : m_physicalDevice( exchange( rhs.m_physicalDevice, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + PhysicalDevice & operator=( PhysicalDevice const & rhs ) + { + m_physicalDevice = rhs.m_physicalDevice; + m_dispatcher = rhs.m_dispatcher; + return *this; + } + + PhysicalDevice & operator=( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_physicalDevice, rhs.m_physicalDevice ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::PhysicalDevice const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_physicalDevice; + } + + VULKAN_HPP_NAMESPACE::PhysicalDevice const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_physicalDevice ); + } + + operator VULKAN_HPP_NAMESPACE::PhysicalDevice() const VULKAN_HPP_NOEXCEPT + { + return m_physicalDevice; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + m_physicalDevice = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::PhysicalDevice release() + { + m_dispatcher = nullptr; + return exchange( m_physicalDevice, nullptr ); + } + + detail::InstanceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( PhysicalDevice & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_physicalDevice, rhs.m_physicalDevice ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkGetPhysicalDeviceFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html + VULKAN_HPP_NODISCARD PhysicalDeviceFeatures getFeatures() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html + VULKAN_HPP_NODISCARD FormatProperties getFormatProperties( Format format ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getImageFormatProperties( + Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + // wrapper function for command vkGetPhysicalDeviceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html + VULKAN_HPP_NODISCARD PhysicalDeviceProperties getProperties() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html + VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties() const; + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html + VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties getMemoryProperties() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDevice( DeviceCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkEnumerateDeviceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + enumerateDeviceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; + + // wrapper function for command vkEnumerateDeviceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateDeviceLayerProperties() const; + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html + VULKAN_HPP_NODISCARD std::vector + getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling ) const; + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkGetPhysicalDeviceFeatures2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html + VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceFeatures2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html + template + VULKAN_HPP_NODISCARD StructureChain getFeatures2() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html + VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html + template + VULKAN_HPP_NODISCARD StructureChain getProperties2() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html + VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2( Format format ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html + template + VULKAN_HPP_NODISCARD StructureChain getFormatProperties2( Format format ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, + ImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2() const; + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template + VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2() const; + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html + VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2 getMemoryProperties2() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html + template + VULKAN_HPP_NODISCARD StructureChain getMemoryProperties2() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html + VULKAN_HPP_NODISCARD std::vector + getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const; + + // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html + VULKAN_HPP_NODISCARD ExternalBufferProperties + getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html + VULKAN_HPP_NODISCARD ExternalFenceProperties + getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html + VULKAN_HPP_NODISCARD ExternalSemaphoreProperties + getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_VERSION_1_3 === + + // wrapper function for command vkGetPhysicalDeviceToolProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getToolProperties() const; + + //=== VK_KHR_surface === + + // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, + VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + //=== VK_KHR_swapchain === + + // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; + + //=== VK_KHR_display === + + // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPropertiesKHR() const; + + // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlanePropertiesKHR() const; + + // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const; + +# if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html + VULKAN_HPP_NODISCARD Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT; +# endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +# if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html + VULKAN_HPP_NODISCARD Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, + xcb_connection_t & connection, + xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT; +# endif /*VK_USE_PLATFORM_XCB_KHR*/ + +# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html + VULKAN_HPP_NODISCARD Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const VULKAN_HPP_NOEXCEPT; +# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html + VULKAN_HPP_NODISCARD Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_video_queue === + + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VideoProfileInfoKHR * pVideoProfile, + VideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile ) const; + + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile ) const; + + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const; + + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const; + + //=== VK_NV_external_memory_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getExternalImageFormatPropertiesNV( Format format, + ImageType type, + ImageTiling tiling, + ImageUsageFlags usage, + ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + //=== VK_KHR_get_physical_device_properties2 === + + // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html + VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2KHR() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html + template + VULKAN_HPP_NODISCARD StructureChain getFeatures2KHR() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html + VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2KHR() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html + template + VULKAN_HPP_NODISCARD StructureChain getProperties2KHR() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html + VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2KHR( Format format ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html + template + VULKAN_HPP_NODISCARD StructureChain getFormatProperties2KHR( Format format ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, + ImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2KHR() const; + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template + VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2KHR() const; + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html + VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html + template + VULKAN_HPP_NODISCARD StructureChain getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html + VULKAN_HPP_NODISCARD std::vector + getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const; + + //=== VK_KHR_external_memory_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html + VULKAN_HPP_NODISCARD ExternalBufferProperties + getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_external_semaphore_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html + VULKAN_HPP_NODISCARD ExternalSemaphoreProperties + getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT; + +# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + + // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html + typename ResultValueType::type acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const; + + // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; + + //=== VK_KHR_external_fence_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html + VULKAN_HPP_NODISCARD ExternalFenceProperties + getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_performance_query === + + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type + enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const; + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html + VULKAN_HPP_NODISCARD uint32_t + getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_get_surface_capabilities2 === + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, + SurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; + + //=== VK_KHR_get_display_properties2 === + + // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayProperties2KHR() const; + + // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlaneProperties2KHR() const; + + // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo ) const; + + //=== VK_EXT_descriptor_heap === + + // wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html + VULKAN_HPP_NODISCARD DeviceSize getDescriptorSizeEXT( DescriptorType descriptorType ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_sample_locations === + + // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html + VULKAN_HPP_NODISCARD MultisamplePropertiesEXT getMultisamplePropertiesEXT( SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_calibrated_timestamps === + + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getCalibrateableTimeDomainsEXT() const; + + //=== VK_KHR_fragment_shading_rate === + + // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getFragmentShadingRatesKHR() const; + + //=== VK_EXT_tooling_info === + + // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getToolPropertiesEXT() const; + + //=== VK_NV_cooperative_matrix === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getCooperativeMatrixPropertiesNV() const; + + //=== VK_NV_coverage_reduction_mode === + + // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSupportedFramebufferMixedSamplesCombinationsNV() const; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_acquire_drm_display === + + // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html + typename ResultValueType::type acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const; + + // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getDrmDisplayEXT( int32_t drmFd, + uint32_t connectorId ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_KHR_video_encode_queue === + + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + VULKAN_HPP_NODISCARD Result + getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, + VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const; + + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + + // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getWinrtDisplayNV( uint32_t deviceRelativeId ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html + VULKAN_HPP_NODISCARD Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT; +# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html + VULKAN_HPP_NODISCARD Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_ARM_tensors === + + // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html + VULKAN_HPP_NODISCARD ExternalTensorPropertiesARM + getExternalTensorPropertiesARM( const PhysicalDeviceExternalTensorInfoARM & externalTensorInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_optical_flow === + + // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo ) const; + + //=== VK_NV_cooperative_vector === + + // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getCooperativeVectorPropertiesNV() const; + + //=== VK_KHR_cooperative_matrix === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getCooperativeMatrixPropertiesKHR() const; + + //=== VK_ARM_data_graph === + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex ) const; + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html + VULKAN_HPP_NODISCARD QueueFamilyDataGraphProcessingEnginePropertiesARM getQueueFamilyDataGraphProcessingEnginePropertiesARM( + const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & queueFamilyDataGraphProcessingEngineInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_calibrated_timestamps === + + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getCalibrateableTimeDomainsKHR() const; + + //=== VK_NV_cooperative_matrix2 === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCooperativeMatrixFlexibleDimensionsPropertiesNV() const; + + //=== VK_ARM_performance_counters_by_region === + + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html + VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type + enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex ) const; + + private: + VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; + detail::InstanceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + class PhysicalDevices : public std::vector + { + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + PhysicalDevices( Instance const & instance ) + { + *this = instance.enumeratePhysicalDevices(); + } +# endif + + PhysicalDevices( std::nullptr_t ) {} + + PhysicalDevices() = delete; + PhysicalDevices( PhysicalDevices const & ) = delete; + PhysicalDevices( PhysicalDevices && rhs ) = default; + PhysicalDevices & operator=( PhysicalDevices const & ) = delete; + PhysicalDevices & operator=( PhysicalDevices && rhs ) = default; + + PhysicalDevices( std::vector && rhs ) + { + std::swap( *this, rhs ); + } + }; + + // wrapper class for handle VkDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDevice.html + class Device + { + public: + using CType = VkDevice; + using CppType = VULKAN_HPP_NAMESPACE::Device; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDevice; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Device( PhysicalDevice const & physicalDevice, DeviceCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = physicalDevice.createDevice( createInfo, allocator ); + } +# endif + + Device( PhysicalDevice const & physicalDevice, VkDevice device, Optional allocator = nullptr ) + : m_device( device ), m_allocator( static_cast( allocator ) ) + { + m_dispatcher.reset( new detail::DeviceDispatcher( physicalDevice.getDispatcher()->vkGetDeviceProcAddr, static_cast( m_device ) ) ); + } + + Device( std::nullptr_t ) {} + + ~Device() + { + clear(); + } + + Device() = delete; + Device( Device const & ) = delete; + + Device( Device && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( rhs.m_dispatcher.release() ) + { + } + + Device & operator=( Device const & ) = delete; + + Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::Device const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_device; + } + + VULKAN_HPP_NAMESPACE::Device const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_device ); + } + + operator VULKAN_HPP_NAMESPACE::Device() const VULKAN_HPP_NOEXCEPT + { + return m_device; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_device ) + { + getDispatcher()->vkDestroyDevice( static_cast( m_device ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::Device release() + { + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_device, nullptr ); + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return &*m_dispatcher; + } + + void swap( Device & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html + VULKAN_HPP_NODISCARD PFN_VoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html + VULKAN_HPP_NODISCARD Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html + typename ResultValueType::type waitIdle() const; + + // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + allocateMemory( MemoryAllocateInfo const & allocateInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html + typename ResultValueType::type flushMappedMemoryRanges( ArrayProxy const & memoryRanges ) const; + + // wrapper function for command vkInvalidateMappedMemoryRanges, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html + typename ResultValueType::type invalidateMappedMemoryRanges( ArrayProxy const & memoryRanges ) const; + + // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createFence( FenceCreateInfo const & createInfo, Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html + typename ResultValueType::type resetFences( ArrayProxy const & fences ) const; + + // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html + VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy const & fences, Bool32 waitAll, uint64_t timeout ) const; + + // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSemaphore( SemaphoreCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createQueryPool( QueryPoolCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createBuffer( BufferCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createImage( ImageCreateInfo const & createInfo, Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createImageView( ImageViewCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createCommandPool( CommandPoolCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + allocateCommandBuffers( CommandBufferAllocateInfo const & allocateInfo ) const; + + // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createEvent( EventCreateInfo const & createInfo, Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createBufferView( BufferViewCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createShaderModule( ShaderModuleCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createPipelineCache( PipelineCacheCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createComputePipelines( Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) const; + + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createComputePipeline( Optional const & pipelineCache, + ComputePipelineCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createPipelineLayout( PipelineLayoutCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSampler( SamplerCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateDescriptorSetLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDescriptorSetLayout( DescriptorSetLayoutCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDescriptorPool( DescriptorPoolCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + allocateDescriptorSets( DescriptorSetAllocateInfo const & allocateInfo ) const; + + // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html + void updateDescriptorSets( ArrayProxy const & descriptorWrites, + ArrayProxy const & descriptorCopies ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createGraphicsPipelines( Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) const; + + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createGraphicsPipeline( Optional const & pipelineCache, + GraphicsPipelineCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createFramebuffer( FramebufferCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createRenderPass( RenderPassCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html + typename ResultValueType::type bindBufferMemory2( ArrayProxy const & bindInfos ) const; + + // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html + typename ResultValueType::type bindImageMemory2( ArrayProxy const & bindInfos ) const; + + // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html + VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetImageMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html + VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetImageMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html + template + VULKAN_HPP_NODISCARD StructureChain getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetBufferMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html + VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetBufferMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html + template + VULKAN_HPP_NODISCARD StructureChain getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetImageSparseMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info ) const; + + // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html + VULKAN_HPP_NODISCARD Queue getQueue2( DeviceQueueInfo2 const & queueInfo ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDescriptorUpdateTemplate( DescriptorUpdateTemplateCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkGetDescriptorSetLayoutSupport, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html + VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport + getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDescriptorSetLayoutSupport, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html + template + VULKAN_HPP_NODISCARD StructureChain + getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCreateSamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSamplerYcbcrConversion( SamplerYcbcrConversionCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_VERSION_1_2 === + + // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html + VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const; + + // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html + typename ResultValueType::type signalSemaphore( const SemaphoreSignalInfo & signalInfo ) const; + + // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html + VULKAN_HPP_NODISCARD DeviceAddress getBufferAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetBufferOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html + VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html + VULKAN_HPP_NODISCARD uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createRenderPass2( RenderPassCreateInfo2 const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_VERSION_1_3 === + + // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createPrivateDataSlot( PrivateDataSlotCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html + typename ResultValueType::type + setPrivateData( ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data ) const; + + // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html + VULKAN_HPP_NODISCARD uint64_t getPrivateData( ObjectType objectType, + uint64_t objectHandle, + VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html + VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html + template + VULKAN_HPP_NODISCARD StructureChain getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html + VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html + template + VULKAN_HPP_NODISCARD StructureChain getImageMemoryRequirements( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html + VULKAN_HPP_NODISCARD std::vector getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info ) const; + + //=== VK_VERSION_1_4 === + + // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html + VULKAN_HPP_NODISCARD typename ResultValueType::type mapMemory2( const MemoryMapInfo & memoryMapInfo ) const; + + // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html + typename ResultValueType::type unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo ) const; + + // wrapper function for command vkGetDeviceImageSubresourceLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html + VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceImageSubresourceLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html + template + VULKAN_HPP_NODISCARD StructureChain getImageSubresourceLayout( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html + typename ResultValueType::type copyMemoryToImage( const CopyMemoryToImageInfo & copyMemoryToImageInfo ) const; + + // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html + typename ResultValueType::type copyImageToMemory( const CopyImageToMemoryInfo & copyImageToMemoryInfo ) const; + + // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html + typename ResultValueType::type copyImageToImage( const CopyImageToImageInfo & copyImageToImageInfo ) const; + + // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html + typename ResultValueType::type transitionImageLayout( ArrayProxy const & transitions ) const; + + // wrapper function for command vkGetRenderingAreaGranularity, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html + VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularity( const RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_swapchain === + + // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSwapchainKHR( SwapchainCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getGroupPresentCapabilitiesKHR() const; + + // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; + + // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html + VULKAN_HPP_NODISCARD ResultValue acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo ) const; + + //=== VK_KHR_display_swapchain === + + // wrapper function for command vkCreateSharedSwapchainsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createSharedSwapchainsKHR( ArrayProxy const & createInfos, Optional allocator = nullptr ) const; + + // wrapper function for command vkCreateSharedSwapchainsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSharedSwapchainKHR( SwapchainCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_EXT_debug_marker === + + // wrapper function for command vkDebugMarkerSetObjectTagEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html + typename ResultValueType::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const; + + // wrapper function for command vkDebugMarkerSetObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html + typename ResultValueType::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const; + + //=== VK_KHR_video_queue === + + // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createVideoSessionKHR( VideoSessionCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createVideoSessionParametersKHR( VideoSessionParametersCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_NVX_binary_import === + + // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createCuModuleNVX( CuModuleCreateInfoNVX const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createCuFunctionNVX( CuFunctionCreateInfoNVX const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_NVX_image_view_handle === + + // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html + VULKAN_HPP_NODISCARD uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html + VULKAN_HPP_NODISCARD uint64_t getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html + VULKAN_HPP_NODISCARD uint64_t getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex, uint64_t samplerIndex ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_device_group === + + // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html + VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + + // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const; + + // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle ) const; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + + // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const; + + // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, + int fd ) const; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + + // wrapper function for command vkImportSemaphoreWin32HandleKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html + typename ResultValueType::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const; + + // wrapper function for command vkGetSemaphoreWin32HandleKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + + // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html + typename ResultValueType::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const; + + // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const; + + //=== VK_KHR_descriptor_update_template === + + // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html + void + destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_display_control === + + // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html + typename ResultValueType::type displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, + const DisplayPowerInfoEXT & displayPowerInfo ) const; + + // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + registerEventEXT( DeviceEventInfoEXT const & deviceEventInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + registerDisplayEventEXT( DisplayKHR const & display, + DisplayEventInfoEXT const & displayEventInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_EXT_hdr_metadata === + + // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html + void setHdrMetadataEXT( ArrayProxy const & swapchains, + ArrayProxy const & metadata ) const; + + //=== VK_KHR_create_renderpass2 === + + // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createRenderPass2KHR( RenderPassCreateInfo2 const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + + // wrapper function for command vkImportFenceWin32HandleKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html + typename ResultValueType::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const; + + // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + + // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html + typename ResultValueType::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const; + + // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const; + + //=== VK_KHR_performance_query === + + // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html + typename ResultValueType::type acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info ) const; + + // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html + void releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_debug_utils === + + // wrapper function for command vkSetDebugUtilsObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html + typename ResultValueType::type setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo ) const; + + // wrapper function for command vkSetDebugUtilsObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html + template + typename ResultValueType::type setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name ) const; + + // wrapper function for command vkSetDebugUtilsObjectTagEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html + typename ResultValueType::type setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo ) const; + + // wrapper function for command vkSetDebugUtilsObjectTagEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html + template + typename ResultValueType::type setDebugUtilsObjectTagEXT( HandleType const & handle, uint64_t name, TagType const & tag ) const; + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + VULKAN_HPP_NODISCARD Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer, + AndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const; + + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const; + + // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info ) const; +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createExecutionGraphPipelinesAMDX( Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) const; + + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createExecutionGraphPipelineAMDX( Optional const & pipelineCache, + ExecutionGraphPipelineCreateInfoAMDX const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + + // wrapper function for command vkWriteSamplerDescriptorsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html + typename ResultValueType::type writeSamplerDescriptorsEXT( ArrayProxy const & samplers, + ArrayProxy const & descriptors ) const; + + // wrapper function for command vkWriteResourceDescriptorsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html + typename ResultValueType::type writeResourceDescriptorsEXT( ArrayProxy const & resources, + ArrayProxy const & descriptors ) const; + + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getImageOpaqueCaptureDataEXT( ArrayProxy const & images ) const; + + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getImageOpaqueCaptureDataEXT( const VULKAN_HPP_NAMESPACE::Image & image ) const; + + // wrapper function for command vkRegisterCustomBorderColorEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT & borderColor, + Bool32 requestIndex ) const; + + // wrapper function for command vkUnregisterCustomBorderColorEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html + void unregisterCustomBorderColorEXT( uint32_t index ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors ) const; + + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getTensorOpaqueCaptureDataARM( const VULKAN_HPP_NAMESPACE::TensorARM & tensor ) const; + + //=== VK_KHR_get_memory_requirements2 === + + // wrapper function for command vkGetImageMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html + VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetImageMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html + template + VULKAN_HPP_NODISCARD StructureChain getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetBufferMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html + VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetBufferMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html + template + VULKAN_HPP_NODISCARD StructureChain getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html + VULKAN_HPP_NODISCARD std::vector + getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info ) const; + + //=== VK_KHR_acceleration_structure === + + // wrapper function for command vkCreateAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createAccelerationStructureKHR( AccelerationStructureCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html + VULKAN_HPP_NODISCARD Result + buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + ArrayProxy const & infos, + ArrayProxy const & pBuildRangeInfos ) const; + + // wrapper function for command vkCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html + VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureInfoKHR & info ) const; + + // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html + VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureToMemoryInfoKHR & info ) const; + + // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html + VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const CopyMemoryToAccelerationStructureInfoKHR & info ) const; + + // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, + QueryType queryType, + size_t dataSize, + size_t stride ) const; + + // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type writeAccelerationStructuresPropertyKHR( + ArrayProxy const & accelerationStructures, QueryType queryType, size_t stride ) const; + + // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html + VULKAN_HPP_NODISCARD DeviceAddress getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html + VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR + getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html + VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR + getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, + const AccelerationStructureBuildGeometryInfoKHR & buildInfo, + ArrayProxy const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; + + //=== VK_KHR_ray_tracing_pipeline === + + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createRayTracingPipelinesKHR( Optional const & deferredOperation, + Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) const; + + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createRayTracingPipelineKHR( Optional const & deferredOperation, + Optional const & pipelineCache, + RayTracingPipelineCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_KHR_sampler_ycbcr_conversion === + + // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createSamplerYcbcrConversionKHR( SamplerYcbcrConversionCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html + void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_bind_memory2 === + + // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html + typename ResultValueType::type bindBufferMemory2KHR( ArrayProxy const & bindInfos ) const; + + // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html + typename ResultValueType::type bindImageMemory2KHR( ArrayProxy const & bindInfos ) const; + + //=== VK_EXT_validation_cache === + + // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createValidationCacheEXT( ValidationCacheCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_NV_ray_tracing === + + // wrapper function for command vkCreateAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createAccelerationStructureNV( AccelerationStructureCreateInfoNV const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html + VULKAN_HPP_NODISCARD MemoryRequirements2KHR + getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html + template + VULKAN_HPP_NODISCARD StructureChain + getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkBindAccelerationStructureMemoryNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html + typename ResultValueType::type bindAccelerationStructureMemoryNV( ArrayProxy const & bindInfos ) const; + + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createRayTracingPipelinesNV( Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) const; + + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createRayTracingPipelineNV( Optional const & pipelineCache, + RayTracingPipelineCreateInfoNV const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_KHR_maintenance3 === + + // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html + VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport + getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html + template + VULKAN_HPP_NODISCARD StructureChain + getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_external_memory_host === + + // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer ) const; + + //=== VK_EXT_calibrated_timestamps === + + // wrapper function for command vkGetCalibratedTimestampsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type + getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos ) const; + + // wrapper function for command vkGetCalibratedTimestampsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCalibratedTimestampEXT( const CalibratedTimestampInfoKHR & timestampInfo ) const; + + //=== VK_KHR_timeline_semaphore === + + // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html + VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const; + + // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html + typename ResultValueType::type signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo ) const; + + //=== VK_EXT_present_timing === + + // wrapper function for command vkGetPastPresentationTimingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html + VULKAN_HPP_NODISCARD Result + getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, + PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_INTEL_performance_query === + + // wrapper function for command vkInitializePerformanceApiINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html + typename ResultValueType::type initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo ) const; + + // wrapper function for command vkUninitializePerformanceApiINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html + void uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + acquirePerformanceConfigurationINTEL( PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkGetPerformanceParameterINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter ) const; + + //=== VK_EXT_buffer_device_address === + + // wrapper function for command vkGetBufferDeviceAddressEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html + VULKAN_HPP_NODISCARD DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + + // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_buffer_device_address === + + // wrapper function for command vkGetBufferDeviceAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html + VULKAN_HPP_NODISCARD DeviceAddress getBufferAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html + VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html + VULKAN_HPP_NODISCARD uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_deferred_host_operations === + + // wrapper function for command vkCreateDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDeferredOperationKHR( Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_KHR_pipeline_executable_properties === + + // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo ) const; + + // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo ) const; + + // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo ) const; + + //=== VK_EXT_host_image_copy === + + // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html + typename ResultValueType::type copyMemoryToImageEXT( const CopyMemoryToImageInfo & copyMemoryToImageInfo ) const; + + // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html + typename ResultValueType::type copyImageToMemoryEXT( const CopyImageToMemoryInfo & copyImageToMemoryInfo ) const; + + // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html + typename ResultValueType::type copyImageToImageEXT( const CopyImageToImageInfo & copyImageToImageInfo ) const; + + // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html + typename ResultValueType::type transitionImageLayoutEXT( ArrayProxy const & transitions ) const; + + //=== VK_KHR_map_memory2 === + + // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type mapMemory2KHR( const MemoryMapInfo & memoryMapInfo ) const; + + // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html + typename ResultValueType::type unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo ) const; + + //=== VK_EXT_swapchain_maintenance1 === + + // wrapper function for command vkReleaseSwapchainImagesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html + typename ResultValueType::type releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo ) const; + + //=== VK_NV_device_generated_commands === + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html + VULKAN_HPP_NODISCARD MemoryRequirements2 + getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html + template + VULKAN_HPP_NODISCARD StructureChain + getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCreateIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createIndirectCommandsLayoutNV( IndirectCommandsLayoutCreateInfoNV const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_EXT_private_data === + + // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createPrivateDataSlotEXT( PrivateDataSlotCreateInfo const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkDestroyPrivateDataSlotEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html + void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html + typename ResultValueType::type + setPrivateDataEXT( ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data ) const; + + // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html + VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( ObjectType objectType, + uint64_t objectHandle, + VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_video_encode_queue === + + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>>::type + getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const; + + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type + getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + + // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createCudaModuleNV( CudaModuleCreateInfoNV const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createCudaFunctionNV( CudaFunctionCreateInfoNV const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + + // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html + void exportMetalObjectsEXT( ExportMetalObjectsInfoEXT & metalObjectsInfo ) const VULKAN_HPP_NOEXCEPT; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_descriptor_buffer === + + // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html + void getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html + template + VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT & info ) const; + + // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT & info ) const; + + // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT & info ) const; + + // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT & info ) const; + + // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info ) const; + + //=== VK_EXT_device_fault === + + // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html + VULKAN_HPP_NODISCARD Result getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts, DeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT; + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + + // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const; + + // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle ) const; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + + // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html + typename ResultValueType::type + importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const; + + // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + // wrapper function for command vkCreateBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createBufferCollectionFUCHSIA( BufferCollectionCreateInfoFUCHSIA const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_NV_external_memory_rdma === + + // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const; + + //=== VK_EXT_pipeline_properties === + + // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getPipelinePropertiesEXT( const PipelineInfoEXT & pipelineInfo ) const; + + //=== VK_EXT_opacity_micromap === + + // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createMicromapEXT( MicromapCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html + VULKAN_HPP_NODISCARD Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + ArrayProxy const & infos ) const; + + // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html + VULKAN_HPP_NODISCARD Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const CopyMicromapInfoEXT & info ) const; + + // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html + VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const CopyMicromapToMemoryInfoEXT & info ) const; + + // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html + VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const CopyMemoryToMicromapInfoEXT & info ) const; + + // wrapper function for command vkWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type writeMicromapsPropertiesEXT( + ArrayProxy const & micromaps, QueryType queryType, size_t dataSize, size_t stride ) const; + + // wrapper function for command vkWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + writeMicromapsPropertyEXT( ArrayProxy const & micromaps, QueryType queryType, size_t stride ) const; + + // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html + VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR + getMicromapCompatibilityEXT( const MicromapVersionInfoEXT & versionInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html + VULKAN_HPP_NODISCARD MicromapBuildSizesInfoEXT getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, + const MicromapBuildInfoEXT & buildInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_maintenance4 === + + // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html + VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html + template + VULKAN_HPP_NODISCARD StructureChain getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html + VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html + template + VULKAN_HPP_NODISCARD StructureChain getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html + VULKAN_HPP_NODISCARD std::vector getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const; + + //=== VK_VALVE_descriptor_set_host_mapping === + + // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html + VULKAN_HPP_NODISCARD DescriptorSetLayoutHostMappingInfoVALVE + getDescriptorSetLayoutHostMappingInfoVALVE( const DescriptorSetBindingReferenceVALVE & bindingReference ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_device_generated_commands_compute === + + // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html + VULKAN_HPP_NODISCARD MemoryRequirements2 + getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html + template + VULKAN_HPP_NODISCARD StructureChain + getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html + VULKAN_HPP_NODISCARD DeviceAddress getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV & info ) const VULKAN_HPP_NOEXCEPT; + +# if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + VULKAN_HPP_NODISCARD Result getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer * buffer, + NativeBufferPropertiesOHOS * pProperties ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer ) const; + + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer ) const; + + // wrapper function for command vkGetMemoryNativeBufferOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS & info ) const; +# endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_ARM_tensors === + + // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createTensorARM( TensorCreateInfoARM const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createTensorViewARM( TensorViewCreateInfoARM const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkGetTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html + VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html + template + VULKAN_HPP_NODISCARD StructureChain getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html + typename ResultValueType::type bindTensorMemoryARM( ArrayProxy const & bindInfos ) const; + + // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html + VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html + template + VULKAN_HPP_NODISCARD StructureChain + getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM & info ) const; + + // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM & info ) const; + + //=== VK_EXT_shader_module_identifier === + + // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html + VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT + getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_optical_flow === + + // wrapper function for command vkCreateOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createOpticalFlowSessionNV( OpticalFlowSessionCreateInfoNV const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_KHR_maintenance5 === + + // wrapper function for command vkGetRenderingAreaGranularityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html + VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularityKHR( const RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html + VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html + template + VULKAN_HPP_NODISCARD StructureChain getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_AMD_anti_lag === + + // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html + void antiLagUpdateAMD( const AntiLagDataAMD & data ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_shader_object === + + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createShadersEXT( ArrayProxy const & createInfos, Optional allocator = nullptr ) const; + + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createShaderEXT( ShaderCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_KHR_pipeline_binary === + + // wrapper function for command vkCreatePipelineBinariesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createPipelineBinariesKHR( PipelineBinaryCreateInfoKHR const & createInfo, Optional allocator = nullptr ) const; + + // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getPipelineKeyKHR( Optional pipelineCreateInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; + + // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>>::type + getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info ) const; + + // wrapper function for command vkReleaseCapturedPipelineDataKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html + typename ResultValueType::type + releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR & info, + Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; + + //=== VK_QCOM_tile_properties === + + // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo ) const; + + //=== VK_KHR_swapchain_maintenance1 === + + // wrapper function for command vkReleaseSwapchainImagesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html + typename ResultValueType::type releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo ) const; + + //=== VK_NV_cooperative_vector === + + // wrapper function for command vkConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html + VULKAN_HPP_NODISCARD Result convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV & info ) const; + + //=== VK_ARM_data_graph === + + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createDataGraphPipelinesARM( Optional const & deferredOperation, + Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) const; + + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDataGraphPipelineARM( Optional const & deferredOperation, + Optional const & pipelineCache, + DataGraphPipelineCreateInfoARM const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createDataGraphPipelineSessionARM( DataGraphPipelineSessionCreateInfoARM const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM & info ) const; + + // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html + VULKAN_HPP_NODISCARD MemoryRequirements2 + getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html + template + VULKAN_HPP_NODISCARD StructureChain + getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html + typename ResultValueType::type + bindDataGraphPipelineSessionMemoryARM( ArrayProxy const & bindInfos ) const; + + // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo ) const; + + // wrapper function for command vkGetDataGraphPipelinePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelinePropertiesARM.html + VULKAN_HPP_NODISCARD Result getDataGraphPipelinePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, + uint32_t propertiesCount, + DataGraphPipelinePropertyQueryResultARM * pProperties ) const VULKAN_HPP_NOEXCEPT; + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer, + ScreenBufferPropertiesQNX * pProperties ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const; + + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const; +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_KHR_calibrated_timestamps === + + // wrapper function for command vkGetCalibratedTimestampsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type + getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos ) const; + + // wrapper function for command vkGetCalibratedTimestampsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getCalibratedTimestampKHR( const CalibratedTimestampInfoKHR & timestampInfo ) const; + + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createExternalComputeQueueNV( ExternalComputeQueueCreateInfoNV const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_NV_cluster_acceleration_structure === + + // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html + VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR + getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV & info ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_partitioned_acceleration_structure === + + // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html + VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR + getPartitionedAccelerationStructuresBuildSizesNV( const PartitionedAccelerationStructureInstancesInputNV & info ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_device_generated_commands === + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html + VULKAN_HPP_NODISCARD MemoryRequirements2 + getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html + template + VULKAN_HPP_NODISCARD StructureChain + getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createIndirectCommandsLayoutEXT( IndirectCommandsLayoutCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + // wrapper function for command vkCreateIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createIndirectExecutionSetEXT( IndirectExecutionSetCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + + // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT & getMetalHandleInfo ) const; + + // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle ) const; +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + const AllocationCallbacks * m_allocator = {}; + std::unique_ptr m_dispatcher; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureKHR.html + class AccelerationStructureKHR + { + public: + using CType = VkAccelerationStructureKHR; + using CppType = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureKHR; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + AccelerationStructureKHR( Device const & device, + AccelerationStructureCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createAccelerationStructureKHR( createInfo, allocator ); + } +# endif + + AccelerationStructureKHR( Device const & device, + VkAccelerationStructureKHR accelerationStructure, + Optional allocator = nullptr ) + : m_device( device ) + , m_accelerationStructureKHR( accelerationStructure ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + AccelerationStructureKHR( std::nullptr_t ) {} + + ~AccelerationStructureKHR() + { + clear(); + } + + AccelerationStructureKHR() = delete; + AccelerationStructureKHR( AccelerationStructureKHR const & ) = delete; + + AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_accelerationStructureKHR( exchange( rhs.m_accelerationStructureKHR, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + AccelerationStructureKHR & operator=( AccelerationStructureKHR const & ) = delete; + + AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_accelerationStructureKHR, rhs.m_accelerationStructureKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_accelerationStructureKHR; + } + + VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_accelerationStructureKHR ); + } + + operator VULKAN_HPP_NAMESPACE::AccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT + { + return m_accelerationStructureKHR; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_accelerationStructureKHR ) + { + getDispatcher()->vkDestroyAccelerationStructureKHR( static_cast( m_device ), + static_cast( m_accelerationStructureKHR ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_accelerationStructureKHR = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::AccelerationStructureKHR release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_accelerationStructureKHR, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( AccelerationStructureKHR & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_accelerationStructureKHR, rhs.m_accelerationStructureKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructureKHR = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureNV.html + class AccelerationStructureNV + { + public: + using CType = VkAccelerationStructureNV; + using CppType = VULKAN_HPP_NAMESPACE::AccelerationStructureNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureNV; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + AccelerationStructureNV( Device const & device, + AccelerationStructureCreateInfoNV const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createAccelerationStructureNV( createInfo, allocator ); + } +# endif + + AccelerationStructureNV( Device const & device, VkAccelerationStructureNV accelerationStructure, Optional allocator = nullptr ) + : m_device( device ) + , m_accelerationStructureNV( accelerationStructure ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + AccelerationStructureNV( std::nullptr_t ) {} + + ~AccelerationStructureNV() + { + clear(); + } + + AccelerationStructureNV() = delete; + AccelerationStructureNV( AccelerationStructureNV const & ) = delete; + + AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_accelerationStructureNV( exchange( rhs.m_accelerationStructureNV, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + AccelerationStructureNV & operator=( AccelerationStructureNV const & ) = delete; + + AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_accelerationStructureNV, rhs.m_accelerationStructureNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_accelerationStructureNV; + } + + VULKAN_HPP_NAMESPACE::AccelerationStructureNV const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_accelerationStructureNV ); + } + + operator VULKAN_HPP_NAMESPACE::AccelerationStructureNV() const VULKAN_HPP_NOEXCEPT + { + return m_accelerationStructureNV; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_accelerationStructureNV ) + { + getDispatcher()->vkDestroyAccelerationStructureNV( static_cast( m_device ), + static_cast( m_accelerationStructureNV ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_accelerationStructureNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::AccelerationStructureNV release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_accelerationStructureNV, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( AccelerationStructureNV & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_accelerationStructureNV, rhs.m_accelerationStructureNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_NV_ray_tracing === + + // wrapper function for command vkGetAccelerationStructureHandleNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type getHandle( size_t dataSize ) const; + + // wrapper function for command vkGetAccelerationStructureHandleNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type getHandle() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructureNV = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuffer.html + class Buffer + { + public: + using CType = VkBuffer; + using CppType = VULKAN_HPP_NAMESPACE::Buffer; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBuffer; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Buffer( Device const & device, BufferCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createBuffer( createInfo, allocator ); + } +# endif + + Buffer( Device const & device, VkBuffer buffer, Optional allocator = nullptr ) + : m_device( device ), m_buffer( buffer ), m_allocator( static_cast( allocator ) ), m_dispatcher( device.getDispatcher() ) + { + } + + Buffer( std::nullptr_t ) {} + + ~Buffer() + { + clear(); + } + + Buffer() = delete; + Buffer( Buffer const & ) = delete; + + Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_buffer( exchange( rhs.m_buffer, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + Buffer & operator=( Buffer const & ) = delete; + + Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_buffer, rhs.m_buffer ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::Buffer const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_buffer; + } + + VULKAN_HPP_NAMESPACE::Buffer const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_buffer ); + } + + operator VULKAN_HPP_NAMESPACE::Buffer() const VULKAN_HPP_NOEXCEPT + { + return m_buffer; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_buffer ) + { + getDispatcher()->vkDestroyBuffer( + static_cast( m_device ), static_cast( m_buffer ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_buffer = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::Buffer release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_buffer, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( Buffer & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_buffer, rhs.m_buffer ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html + typename ResultValueType::type bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, DeviceSize memoryOffset ) const; + + // wrapper function for command vkGetBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html + VULKAN_HPP_NODISCARD MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; + + protected: + Buffer( VULKAN_HPP_NAMESPACE::Device device, + VULKAN_HPP_NAMESPACE::Buffer buffer, + const AllocationCallbacks * allocator, + detail::DeviceDispatcher const * dispatcher ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( device, {} ) ) + , m_buffer( exchange( buffer, {} ) ) + , m_allocator( exchange( allocator, {} ) ) + , m_dispatcher( exchange( dispatcher, nullptr ) ) + { + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Buffer m_buffer = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionFUCHSIA.html +# if defined( VK_USE_PLATFORM_FUCHSIA ) + class BufferCollectionFUCHSIA + { + public: + using CType = VkBufferCollectionFUCHSIA; + using CppType = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferCollectionFUCHSIA; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + BufferCollectionFUCHSIA( Device const & device, + BufferCollectionCreateInfoFUCHSIA const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createBufferCollectionFUCHSIA( createInfo, allocator ); + } +# endif + + BufferCollectionFUCHSIA( Device const & device, VkBufferCollectionFUCHSIA collection, Optional allocator = nullptr ) + : m_device( device ) + , m_bufferCollectionFUCHSIA( collection ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + BufferCollectionFUCHSIA( std::nullptr_t ) {} + + ~BufferCollectionFUCHSIA() + { + clear(); + } + + BufferCollectionFUCHSIA() = delete; + BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & ) = delete; + + BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_bufferCollectionFUCHSIA( exchange( rhs.m_bufferCollectionFUCHSIA, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & ) = delete; + + BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_bufferCollectionFUCHSIA, rhs.m_bufferCollectionFUCHSIA ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_bufferCollectionFUCHSIA; + } + + VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_bufferCollectionFUCHSIA ); + } + + operator VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT + { + return m_bufferCollectionFUCHSIA; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_bufferCollectionFUCHSIA ) + { + getDispatcher()->vkDestroyBufferCollectionFUCHSIA( static_cast( m_device ), + static_cast( m_bufferCollectionFUCHSIA ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_bufferCollectionFUCHSIA = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_bufferCollectionFUCHSIA, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( BufferCollectionFUCHSIA & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_bufferCollectionFUCHSIA, rhs.m_bufferCollectionFUCHSIA ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_FUCHSIA_buffer_collection === + + // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html + typename ResultValueType::type setImageConstraints( const ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const; + + // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html + typename ResultValueType::type setBufferConstraints( const BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const; + + // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getProperties() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + // wrapper class for handle VkBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferView.html + class BufferView + { + public: + using CType = VkBufferView; + using CppType = VULKAN_HPP_NAMESPACE::BufferView; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferView; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + BufferView( Device const & device, BufferViewCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createBufferView( createInfo, allocator ); + } +# endif + + BufferView( Device const & device, VkBufferView bufferView, Optional allocator = nullptr ) + : m_device( device ) + , m_bufferView( bufferView ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + BufferView( std::nullptr_t ) {} + + ~BufferView() + { + clear(); + } + + BufferView() = delete; + BufferView( BufferView const & ) = delete; + + BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_bufferView( exchange( rhs.m_bufferView, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + BufferView & operator=( BufferView const & ) = delete; + + BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_bufferView, rhs.m_bufferView ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::BufferView const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_bufferView; + } + + VULKAN_HPP_NAMESPACE::BufferView const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_bufferView ); + } + + operator VULKAN_HPP_NAMESPACE::BufferView() const VULKAN_HPP_NOEXCEPT + { + return m_bufferView; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_bufferView ) + { + getDispatcher()->vkDestroyBufferView( + static_cast( m_device ), static_cast( m_bufferView ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_bufferView = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::BufferView release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_bufferView, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( BufferView & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_bufferView, rhs.m_bufferView ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::BufferView m_bufferView = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPool.html + class CommandPool + { + public: + using CType = VkCommandPool; + using CppType = VULKAN_HPP_NAMESPACE::CommandPool; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandPool; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + CommandPool( Device const & device, CommandPoolCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createCommandPool( createInfo, allocator ); + } +# endif + + CommandPool( Device const & device, VkCommandPool commandPool, Optional allocator = nullptr ) + : m_device( device ) + , m_commandPool( commandPool ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + CommandPool( std::nullptr_t ) {} + + ~CommandPool() + { + clear(); + } + + CommandPool() = delete; + CommandPool( CommandPool const & ) = delete; + + CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_commandPool( exchange( rhs.m_commandPool, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + CommandPool & operator=( CommandPool const & ) = delete; + + CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_commandPool, rhs.m_commandPool ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::CommandPool const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_commandPool; + } + + VULKAN_HPP_NAMESPACE::CommandPool const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_commandPool ); + } + + operator VULKAN_HPP_NAMESPACE::CommandPool() const VULKAN_HPP_NOEXCEPT + { + return m_commandPool; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_commandPool ) + { + getDispatcher()->vkDestroyCommandPool( + static_cast( m_device ), static_cast( m_commandPool ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_commandPool = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::CommandPool release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_commandPool, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( CommandPool & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_commandPool, rhs.m_commandPool ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html + typename ResultValueType::type reset( CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html + void trim( CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_maintenance1 === + + // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html + void trimKHR( CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBuffer.html + class CommandBuffer + { + public: + using CType = VkCommandBuffer; + using CppType = VULKAN_HPP_NAMESPACE::CommandBuffer; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandBuffer; + + public: + CommandBuffer( Device const & device, VkCommandBuffer commandBuffer, VkCommandPool commandPool ) + : m_device( device ), m_commandPool( commandPool ), m_commandBuffer( commandBuffer ), m_dispatcher( device.getDispatcher() ) + { + } + + CommandBuffer( std::nullptr_t ) {} + + ~CommandBuffer() + { + clear(); + } + + CommandBuffer() = delete; + CommandBuffer( CommandBuffer const & ) = delete; + + CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_commandPool( exchange( rhs.m_commandPool, {} ) ) + , m_commandBuffer( exchange( rhs.m_commandBuffer, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + CommandBuffer & operator=( CommandBuffer const & ) = delete; + + CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_commandPool, rhs.m_commandPool ); + std::swap( m_commandBuffer, rhs.m_commandBuffer ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::CommandBuffer const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_commandBuffer; + } + + VULKAN_HPP_NAMESPACE::CommandBuffer const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_commandBuffer ); + } + + operator VULKAN_HPP_NAMESPACE::CommandBuffer() const VULKAN_HPP_NOEXCEPT + { + return m_commandBuffer; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_commandBuffer ) + { + getDispatcher()->vkFreeCommandBuffers( + static_cast( m_device ), static_cast( m_commandPool ), 1, reinterpret_cast( &m_commandBuffer ) ); + } + m_device = nullptr; + m_commandPool = nullptr; + m_commandBuffer = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::CommandBuffer release() + { + m_device = nullptr; + m_commandPool = nullptr; + m_dispatcher = nullptr; + return exchange( m_commandBuffer, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( CommandBuffer & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_commandPool, rhs.m_commandPool ); + std::swap( m_commandBuffer, rhs.m_commandBuffer ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html + typename ResultValueType::type begin( const CommandBufferBeginInfo & beginInfo ) const; + + // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html + typename ResultValueType::type end() const; + + // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html + typename ResultValueType::type reset( CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html + void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer, + ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html + void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, + ImageLayout srcImageLayout, + VULKAN_HPP_NAMESPACE::Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html + void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, + VULKAN_HPP_NAMESPACE::Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html + void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, + ImageLayout srcImageLayout, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer, + ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html + template + void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy const & data ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html + void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html + void pipelineBarrier( PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + DependencyFlags dependencyFlags, + ArrayProxy const & memoryBarriers, + ArrayProxy const & bufferMemoryBarriers, + ArrayProxy const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html + void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t query, + QueryControlFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html + void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html + void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html + void writeTimestamp( PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html + void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer, + DeviceSize dstOffset, + DeviceSize stride, + QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html + void executeCommands( ArrayProxy const & commandBuffers ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html + void bindPipeline( PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html + void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t firstSet, + ArrayProxy const & descriptorSets, + ArrayProxy const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html + void clearColorImage( VULKAN_HPP_NAMESPACE::Image image, + ImageLayout imageLayout, + const ClearColorValue & color, + ArrayProxy const & ranges ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html + void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html + void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html + void setEvent( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags stageMask VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html + void resetEvent( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags stageMask VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html + void waitEvents( ArrayProxy const & events, + PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + ArrayProxy const & memoryBarriers, + ArrayProxy const & bufferMemoryBarriers, + ArrayProxy const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html + template + void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, + ShaderStageFlags stageFlags, + uint32_t offset, + ArrayProxy const & values ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html + void setViewport( uint32_t firstViewport, ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html + void setScissor( uint32_t firstScissor, ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html + void setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html + void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html + void setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html + void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html + void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html + void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html + void setStencilReference( StencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html + void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, IndexType indexType ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html + void bindVertexBuffers( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets ) const; + + // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html + void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html + void + drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html + void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html + void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html + void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, + ImageLayout srcImageLayout, + VULKAN_HPP_NAMESPACE::Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions, + Filter filter ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdClearDepthStencilImage, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html + void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, + ImageLayout imageLayout, + const ClearDepthStencilValue & depthStencil, + ArrayProxy const & ranges ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html + void clearAttachments( ArrayProxy const & attachments, ArrayProxy const & rects ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html + void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, + ImageLayout srcImageLayout, + VULKAN_HPP_NAMESPACE::Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html + void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html + void nextSubpass( SubpassContents contents ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html + void endRenderPass() const VULKAN_HPP_NOEXCEPT; + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html + void setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html + void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const + VULKAN_HPP_NOEXCEPT; + + //=== VK_VERSION_1_2 === + + // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html + void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexedIndirectCount, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html + void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html + void beginRenderPass2( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html + void nextSubpass2( const SubpassBeginInfo & subpassBeginInfo, const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html + void endRenderPass2( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_VERSION_1_3 === + + // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html + void pipelineBarrier2( const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html + void writeTimestamp2( PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html + void copyBuffer2( const CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html + void copyImage2( const CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html + void copyBufferToImage2( const CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html + void copyImageToBuffer2( const CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html + void setEvent2( VULKAN_HPP_NAMESPACE::Event event, const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html + void resetEvent2( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags2 stageMask VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html + void waitEvents2( ArrayProxy const & events, ArrayProxy const & dependencyInfos ) const; + + // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html + void blitImage2( const BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html + void resolveImage2( const ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html + void beginRendering( const RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html + void endRendering() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html + void setCullMode( CullModeFlags cullMode VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html + void setFrontFace( FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html + void setPrimitiveTopology( PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html + void setViewportWithCount( ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html + void setScissorWithCount( ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html + void bindVertexBuffers2( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + ArrayProxy const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; + + // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html + void setDepthTestEnable( Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html + void setDepthWriteEnable( Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html + void setDepthCompareOp( CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBoundsTestEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html + void setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html + void setStencilTestEnable( Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html + void setStencilOp( StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRasterizerDiscardEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html + void setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html + void setDepthBiasEnable( Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetPrimitiveRestartEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html + void setPrimitiveRestartEnable( Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_VERSION_1_4 === + + // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html + void pushDescriptorSet( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t set, + ArrayProxy const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html + template + void pushDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t set, + DataType const & data ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html + void bindDescriptorSets2( const BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html + void pushConstants2( const PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html + void pushDescriptorSet2( const PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html + void pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html + void setLineStipple( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html + void bindIndexBuffer2( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRenderingAttachmentLocations, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html + void setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html + void setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_debug_marker === + + // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html + void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html + void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html + void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_video_queue === + + // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html + void beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html + void endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html + void controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_video_decode_queue === + + // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html + void decodeVideoKHR( const VideoDecodeInfoKHR & decodeInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_transform_feedback === + + // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html + void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; + + // wrapper function for command vkCmdBeginTransformFeedbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html + void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, + ArrayProxy const & counterBuffers, + ArrayProxy const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; + + // wrapper function for command vkCmdEndTransformFeedbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html + void endTransformFeedbackEXT( uint32_t firstCounterBuffer, + ArrayProxy const & counterBuffers, + ArrayProxy const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; + + // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html + void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html + void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndirectByteCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html + void drawIndirectByteCountEXT( uint32_t instanceCount, + uint32_t firstInstance, + VULKAN_HPP_NAMESPACE::Buffer counterBuffer, + DeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NVX_binary_import === + + // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html + void cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_AMD_draw_indirect_count === + + // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html + void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html + void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_dynamic_rendering === + + // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html + void beginRenderingKHR( const RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html + void endRenderingKHR() const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_device_group === + + // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html + void setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html + void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) + const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_push_descriptor === + + // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html + void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t set, + ArrayProxy const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html + template + void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t set, + DataType const & data ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_conditional_rendering === + + // wrapper function for command vkCmdBeginConditionalRenderingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html + void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndConditionalRenderingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html + void endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_clip_space_w_scaling === + + // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html + void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy const & viewportWScalings ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_discard_rectangles === + + // wrapper function for command vkCmdSetDiscardRectangleEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html + void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy const & discardRectangles ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html + void setDiscardRectangleEnableEXT( Bool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html + void setDiscardRectangleModeEXT( DiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_create_renderpass2 === + + // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html + void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html + void nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo, const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html + void endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_debug_utils === + + // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html + void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html + void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html + void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + + // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html + void initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, + DeviceAddress scratch, + DeviceSize scratchSize ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html + void dispatchGraphAMDX( DeviceAddress scratch, DeviceSize scratchSize, const DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html + void dispatchGraphIndirectAMDX( DeviceAddress scratch, DeviceSize scratchSize, const DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html + void dispatchGraphIndirectCountAMDX( DeviceAddress scratch, DeviceSize scratchSize, DeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + + // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html + void bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html + void bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html + void pushDataEXT( const PushDataInfoEXT & pushDataInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_sample_locations === + + // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html + void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_acceleration_structure === + + // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html + void buildAccelerationStructuresKHR( ArrayProxy const & infos, + ArrayProxy const & pBuildRangeInfos ) const; + + // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html + void buildAccelerationStructuresIndirectKHR( ArrayProxy const & infos, + ArrayProxy const & indirectDeviceAddresses, + ArrayProxy const & indirectStrides, + ArrayProxy const & pMaxPrimitiveCounts ) const; + + // wrapper function for command vkCmdCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html + void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html + void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html + void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html + void writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, + QueryType queryType, + VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_ray_tracing_pipeline === + + // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html + void traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, + const StridedDeviceAddressRegionKHR & missShaderBindingTable, + const StridedDeviceAddressRegionKHR & hitShaderBindingTable, + const StridedDeviceAddressRegionKHR & callableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html + void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, + const StridedDeviceAddressRegionKHR & missShaderBindingTable, + const StridedDeviceAddressRegionKHR & hitShaderBindingTable, + const StridedDeviceAddressRegionKHR & callableShaderBindingTable, + DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html + void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_shading_rate_image === + + // wrapper function for command vkCmdBindShadingRateImageNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html + void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html + void setViewportShadingRatePaletteNV( uint32_t firstViewport, + ArrayProxy const & shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoarseSampleOrderNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html + void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, + ArrayProxy const & customSampleOrders ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_ray_tracing === + + // wrapper function for command vkCmdBuildAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html + void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, + VULKAN_HPP_NAMESPACE::Buffer instanceData, + DeviceSize instanceOffset, + Bool32 update, + VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, + VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, + VULKAN_HPP_NAMESPACE::Buffer scratch, + DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html + void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, + VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, + CopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html + void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, + DeviceSize raygenShaderBindingOffset, + VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, + DeviceSize missShaderBindingOffset, + DeviceSize missShaderBindingStride, + VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, + DeviceSize hitShaderBindingOffset, + DeviceSize hitShaderBindingStride, + VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, + DeviceSize callableShaderBindingOffset, + DeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html + void writeAccelerationStructuresPropertiesNV( ArrayProxy const & accelerationStructures, + QueryType queryType, + VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_draw_indirect_count === + + // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html + void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html + void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_AMD_buffer_marker === + + // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html + void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer, + DeviceSize dstOffset, + uint32_t marker ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html + void writeBufferMarker2AMD( PipelineStageFlags2 stage, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer, + DeviceSize dstOffset, + uint32_t marker ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_mesh_shader === + + // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html + void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html + void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html + void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_scissor_exclusive === + + // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html + void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, ArrayProxy const & exclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html + void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_device_diagnostic_checkpoints === + + // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html + template + void setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_INTEL_performance_query === + + // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html + typename ResultValueType::type setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo ) const; + + // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html + typename ResultValueType::type setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo ) const; + + // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html + typename ResultValueType::type setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo ) const; + + //=== VK_KHR_fragment_shading_rate === + + // wrapper function for command vkCmdSetFragmentShadingRateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html + void setFragmentShadingRateKHR( const Extent2D & fragmentSize, const FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_dynamic_rendering_local_read === + + // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html + void setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html + void setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_line_rasterization === + + // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html + void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_extended_dynamic_state === + + // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html + void setCullModeEXT( CullModeFlags cullMode VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html + void setFrontFaceEXT( FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html + void setPrimitiveTopologyEXT( PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetViewportWithCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html + void setViewportWithCountEXT( ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetScissorWithCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html + void setScissorWithCountEXT( ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html + void bindVertexBuffers2EXT( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + ArrayProxy const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; + + // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html + void setDepthTestEnableEXT( Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthWriteEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html + void setDepthWriteEnableEXT( Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html + void setDepthCompareOpEXT( CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html + void setDepthBoundsTestEnableEXT( Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilTestEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html + void setStencilTestEnableEXT( Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html + void + setStencilOpEXT( StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_device_generated_commands === + + // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html + void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html + void executeGeneratedCommandsNV( Bool32 isPreprocessed, const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindPipelineShaderGroupNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html + void bindPipelineShaderGroupNV( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::Pipeline pipeline, + uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_depth_bias_control === + + // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html + void setDepthBias2EXT( const DepthBiasInfoEXT & depthBiasInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_video_encode_queue === + + // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html + void encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + + // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html + void cudaLaunchKernelNV( const CudaLaunchInfoNV & launchInfo ) const VULKAN_HPP_NOEXCEPT; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + + // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html + void dispatchTileQCOM( const DispatchTileInfoQCOM & dispatchTileInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + void beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM & perTileBeginInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + void endPerTileExecutionQCOM( const PerTileEndInfoQCOM & perTileEndInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_synchronization2 === + + // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html + void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html + void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags2 stageMask VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html + void waitEvents2KHR( ArrayProxy const & events, ArrayProxy const & dependencyInfos ) const; + + // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html + void pipelineBarrier2KHR( const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html + void writeTimestamp2KHR( PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_descriptor_buffer === + + // wrapper function for command vkCmdBindDescriptorBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html + void bindDescriptorBuffersEXT( ArrayProxy const & bindingInfos ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html + void setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t firstSet, + ArrayProxy const & bufferIndices, + ArrayProxy const & offsets ) const; + + // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html + void bindDescriptorBufferEmbeddedSamplersEXT( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t set ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_fragment_shading_rate_enums === + + // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html + void setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, const FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_mesh_shader === + + // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html + void drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html + void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html + void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_copy_commands2 === + + // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html + void copyBuffer2KHR( const CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html + void copyImage2KHR( const CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html + void copyBufferToImage2KHR( const CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html + void copyImageToBuffer2KHR( const CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html + void blitImage2KHR( const BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html + void resolveImage2KHR( const ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_vertex_input_dynamic_state === + + // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html + void setVertexInputEXT( ArrayProxy const & vertexBindingDescriptions, + ArrayProxy const & vertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_HUAWEI_subpass_shading === + + // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html + void subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT; + + //=== VK_HUAWEI_invocation_mask === + + // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html + void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_extended_dynamic_state2 === + + // wrapper function for command vkCmdSetPatchControlPointsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html + void setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html + void setRasterizerDiscardEnableEXT( Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html + void setDepthBiasEnableEXT( Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html + void setLogicOpEXT( LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html + void setPrimitiveRestartEnableEXT( Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_color_write_enable === + + // wrapper function for command vkCmdSetColorWriteEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html + void setColorWriteEnableEXT( ArrayProxy const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_ray_tracing_maintenance1 === + + // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html + void traceRaysIndirect2KHR( DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_multi_draw === + + // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html + void + drawMultiEXT( StridedArrayProxy const & vertexInfo, uint32_t instanceCount, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html + void drawMultiIndexedEXT( StridedArrayProxy const & indexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + Optional vertexOffset VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_opacity_micromap === + + // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html + void buildMicromapsEXT( ArrayProxy const & infos ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html + void copyMicromapEXT( const CopyMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html + void copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html + void copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html + void writeMicromapsPropertiesEXT( ArrayProxy const & micromaps, + QueryType queryType, + VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_HUAWEI_cluster_culling_shader === + + // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html + void drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html + void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_copy_memory_indirect === + + // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html + void copyMemoryIndirectNV( DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html + void copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, + uint32_t stride, + VULKAN_HPP_NAMESPACE::Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & imageSubresources ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_memory_decompression === + + // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html + void decompressMemoryNV( ArrayProxy const & decompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html + void decompressMemoryIndirectCountNV( DeviceAddress indirectCommandsAddress, + DeviceAddress indirectCommandsCountAddress, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_device_generated_commands_compute === + + // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html + void updatePipelineIndirectBufferNV( PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_extended_dynamic_state3 === + + // wrapper function for command vkCmdSetDepthClampEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html + void setDepthClampEnableEXT( Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html + void setPolygonModeEXT( PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRasterizationSamplesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html + void setRasterizationSamplesEXT( SampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html + void setSampleMaskEXT( SampleCountFlagBits samples, ArrayProxy const & sampleMask VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; + + // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html + void setAlphaToCoverageEnableEXT( Bool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html + void setAlphaToOneEnableEXT( Bool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html + void setLogicOpEnableEXT( Bool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetColorBlendEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html + void setColorBlendEnableEXT( uint32_t firstAttachment, ArrayProxy const & colorBlendEnables ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetColorBlendEquationEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html + void setColorBlendEquationEXT( uint32_t firstAttachment, ArrayProxy const & colorBlendEquations ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html + void setColorWriteMaskEXT( uint32_t firstAttachment, ArrayProxy const & colorWriteMasks ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html + void setTessellationDomainOriginEXT( TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRasterizationStreamEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html + void setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html + void setConservativeRasterizationModeEXT( ConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html + void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html + void setDepthClipEnableEXT( Bool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html + void setSampleLocationsEnableEXT( Bool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html + void setColorBlendAdvancedEXT( uint32_t firstAttachment, ArrayProxy const & colorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetProvokingVertexModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html + void setProvokingVertexModeEXT( ProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetLineRasterizationModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html + void setLineRasterizationModeEXT( LineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetLineStippleEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html + void setLineStippleEnableEXT( Bool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html + void setDepthClipNegativeOneToOneEXT( Bool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetViewportWScalingEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html + void setViewportWScalingEnableNV( Bool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html + void setViewportSwizzleNV( uint32_t firstViewport, ArrayProxy const & viewportSwizzles ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoverageToColorEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html + void setCoverageToColorEnableNV( Bool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoverageToColorLocationNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html + void setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoverageModulationModeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html + void setCoverageModulationModeNV( CoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html + void setCoverageModulationTableEnableNV( Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoverageModulationTableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html + void setCoverageModulationTableNV( ArrayProxy const & coverageModulationTable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetShadingRateImageEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html + void setShadingRateImageEnableNV( Bool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html + void setRepresentativeFragmentTestEnableNV( Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetCoverageReductionModeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html + void setCoverageReductionModeNV( CoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_ARM_tensors === + + // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html + void copyTensorARM( const CopyTensorInfoARM & copyTensorInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_optical_flow === + + // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html + void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const OpticalFlowExecuteInfoNV & executeInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_maintenance5 === + + // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html + void bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_shader_object === + + // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html + void bindShadersEXT( ArrayProxy const & stages, ArrayProxy const & shaders ) const; + + // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html + void setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, + Optional depthClampRange VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_cooperative_vector === + + // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html + void convertCooperativeVectorMatrixNV( ArrayProxy const & infos ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_ARM_data_graph === + + // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html + void dispatchDataGraphARM( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM session, + Optional info VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + + // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html + void setAttachmentFeedbackLoopEnableEXT( ImageAspectFlags aspectMask VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_line_rasterization === + + // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html + void setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_maintenance6 === + + // wrapper function for command vkCmdBindDescriptorSets2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html + void bindDescriptorSets2KHR( const BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html + void pushConstants2KHR( const PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html + void pushDescriptorSet2KHR( const PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html + void pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html + void setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html + void bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo ) const + VULKAN_HPP_NOEXCEPT; + + //=== VK_QCOM_tile_memory_heap === + + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + void bindTileMemoryQCOM( Optional tileMemoryBindInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_copy_memory_indirect === + + // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html + void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html + void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_memory_decompression === + + // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html + void decompressMemoryEXT( const DecompressMemoryInfoEXT & decompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdDecompressMemoryIndirectCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountEXT.html + void decompressMemoryIndirectCountEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod, + DeviceAddress indirectCommandsAddress, + DeviceAddress indirectCommandsCountAddress, + uint32_t maxDecompressionCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_cluster_acceleration_structure === + + // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html + void buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV & commandInfos ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_partitioned_acceleration_structure === + + // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html + void buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV & buildInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_device_generated_commands === + + // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html + void preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT & generatedCommandsInfo, + VULKAN_HPP_NAMESPACE::CommandBuffer stateCommandBuffer ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html + void executeGeneratedCommandsEXT( Bool32 isPreprocessed, const GeneratedCommandsInfoEXT & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_fragment_density_map_offset === + + // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html + void endRendering2EXT( Optional renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_custom_resolve === + + // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html + void beginCustomResolveEXT( Optional beginCustomResolveInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const + VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_maintenance10 === + + // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html + void endRendering2KHR( Optional renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_compute_occupancy_priority === + + // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html + void setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV & parameters ) const VULKAN_HPP_NOEXCEPT; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; + VULKAN_HPP_NAMESPACE::CommandBuffer m_commandBuffer = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + class CommandBuffers : public std::vector + { + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + CommandBuffers( Device const & device, CommandBufferAllocateInfo const & allocateInfo ) + { + *this = device.allocateCommandBuffers( allocateInfo ); + } +# endif + + CommandBuffers( std::nullptr_t ) {} + + CommandBuffers() = delete; + CommandBuffers( CommandBuffers const & ) = delete; + CommandBuffers( CommandBuffers && rhs ) = default; + CommandBuffers & operator=( CommandBuffers const & ) = delete; + CommandBuffers & operator=( CommandBuffers && rhs ) = default; + + CommandBuffers( std::vector && rhs ) + { + std::swap( *this, rhs ); + } + }; + + // wrapper class for handle VkCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuFunctionNVX.html + class CuFunctionNVX + { + public: + using CType = VkCuFunctionNVX; + using CppType = VULKAN_HPP_NAMESPACE::CuFunctionNVX; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuFunctionNVX; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuFunctionNVX; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + CuFunctionNVX( Device const & device, CuFunctionCreateInfoNVX const & createInfo, Optional allocator = nullptr ) + { + *this = device.createCuFunctionNVX( createInfo, allocator ); + } +# endif + + CuFunctionNVX( Device const & device, VkCuFunctionNVX function, Optional allocator = nullptr ) + : m_device( device ) + , m_cuFunctionNVX( function ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + CuFunctionNVX( std::nullptr_t ) {} + + ~CuFunctionNVX() + { + clear(); + } + + CuFunctionNVX() = delete; + CuFunctionNVX( CuFunctionNVX const & ) = delete; + + CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_cuFunctionNVX( exchange( rhs.m_cuFunctionNVX, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + CuFunctionNVX & operator=( CuFunctionNVX const & ) = delete; + + CuFunctionNVX & operator=( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_cuFunctionNVX, rhs.m_cuFunctionNVX ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::CuFunctionNVX const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_cuFunctionNVX; + } + + VULKAN_HPP_NAMESPACE::CuFunctionNVX const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_cuFunctionNVX ); + } + + operator VULKAN_HPP_NAMESPACE::CuFunctionNVX() const VULKAN_HPP_NOEXCEPT + { + return m_cuFunctionNVX; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_cuFunctionNVX ) + { + getDispatcher()->vkDestroyCuFunctionNVX( static_cast( m_device ), + static_cast( m_cuFunctionNVX ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_cuFunctionNVX = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::CuFunctionNVX release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_cuFunctionNVX, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( CuFunctionNVX & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_cuFunctionNVX, rhs.m_cuFunctionNVX ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CuFunctionNVX m_cuFunctionNVX = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleNVX.html + class CuModuleNVX + { + public: + using CType = VkCuModuleNVX; + using CppType = VULKAN_HPP_NAMESPACE::CuModuleNVX; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuModuleNVX; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuModuleNVX; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + CuModuleNVX( Device const & device, CuModuleCreateInfoNVX const & createInfo, Optional allocator = nullptr ) + { + *this = device.createCuModuleNVX( createInfo, allocator ); + } +# endif + + CuModuleNVX( Device const & device, VkCuModuleNVX module, Optional allocator = nullptr ) + : m_device( device ) + , m_cuModuleNVX( module ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + CuModuleNVX( std::nullptr_t ) {} + + ~CuModuleNVX() + { + clear(); + } + + CuModuleNVX() = delete; + CuModuleNVX( CuModuleNVX const & ) = delete; + + CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_cuModuleNVX( exchange( rhs.m_cuModuleNVX, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + CuModuleNVX & operator=( CuModuleNVX const & ) = delete; + + CuModuleNVX & operator=( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_cuModuleNVX, rhs.m_cuModuleNVX ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::CuModuleNVX const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_cuModuleNVX; + } + + VULKAN_HPP_NAMESPACE::CuModuleNVX const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_cuModuleNVX ); + } + + operator VULKAN_HPP_NAMESPACE::CuModuleNVX() const VULKAN_HPP_NOEXCEPT + { + return m_cuModuleNVX; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_cuModuleNVX ) + { + getDispatcher()->vkDestroyCuModuleNVX( + static_cast( m_device ), static_cast( m_cuModuleNVX ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_cuModuleNVX = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::CuModuleNVX release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_cuModuleNVX, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( CuModuleNVX & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_cuModuleNVX, rhs.m_cuModuleNVX ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CuModuleNVX m_cuModuleNVX = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaFunctionNV.html +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + class CudaFunctionNV + { + public: + using CType = VkCudaFunctionNV; + using CppType = VULKAN_HPP_NAMESPACE::CudaFunctionNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaFunctionNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaFunctionNV; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + CudaFunctionNV( Device const & device, CudaFunctionCreateInfoNV const & createInfo, Optional allocator = nullptr ) + { + *this = device.createCudaFunctionNV( createInfo, allocator ); + } +# endif + + CudaFunctionNV( Device const & device, VkCudaFunctionNV function, Optional allocator = nullptr ) + : m_device( device ) + , m_cudaFunctionNV( function ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + CudaFunctionNV( std::nullptr_t ) {} + + ~CudaFunctionNV() + { + clear(); + } + + CudaFunctionNV() = delete; + CudaFunctionNV( CudaFunctionNV const & ) = delete; + + CudaFunctionNV( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_cudaFunctionNV( exchange( rhs.m_cudaFunctionNV, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + CudaFunctionNV & operator=( CudaFunctionNV const & ) = delete; + + CudaFunctionNV & operator=( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_cudaFunctionNV, rhs.m_cudaFunctionNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::CudaFunctionNV const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_cudaFunctionNV; + } + + VULKAN_HPP_NAMESPACE::CudaFunctionNV const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_cudaFunctionNV ); + } + + operator VULKAN_HPP_NAMESPACE::CudaFunctionNV() const VULKAN_HPP_NOEXCEPT + { + return m_cudaFunctionNV; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_cudaFunctionNV ) + { + getDispatcher()->vkDestroyCudaFunctionNV( static_cast( m_device ), + static_cast( m_cudaFunctionNV ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_cudaFunctionNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::CudaFunctionNV release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_cudaFunctionNV, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( CudaFunctionNV & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_cudaFunctionNV, rhs.m_cudaFunctionNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CudaFunctionNV m_cudaFunctionNV = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper class for handle VkCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaModuleNV.html +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + class CudaModuleNV + { + public: + using CType = VkCudaModuleNV; + using CppType = VULKAN_HPP_NAMESPACE::CudaModuleNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaModuleNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaModuleNV; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + CudaModuleNV( Device const & device, CudaModuleCreateInfoNV const & createInfo, Optional allocator = nullptr ) + { + *this = device.createCudaModuleNV( createInfo, allocator ); + } +# endif + + CudaModuleNV( Device const & device, VkCudaModuleNV module, Optional allocator = nullptr ) + : m_device( device ) + , m_cudaModuleNV( module ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + CudaModuleNV( std::nullptr_t ) {} + + ~CudaModuleNV() + { + clear(); + } + + CudaModuleNV() = delete; + CudaModuleNV( CudaModuleNV const & ) = delete; + + CudaModuleNV( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_cudaModuleNV( exchange( rhs.m_cudaModuleNV, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + CudaModuleNV & operator=( CudaModuleNV const & ) = delete; + + CudaModuleNV & operator=( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_cudaModuleNV, rhs.m_cudaModuleNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::CudaModuleNV const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_cudaModuleNV; + } + + VULKAN_HPP_NAMESPACE::CudaModuleNV const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_cudaModuleNV ); + } + + operator VULKAN_HPP_NAMESPACE::CudaModuleNV() const VULKAN_HPP_NOEXCEPT + { + return m_cudaModuleNV; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_cudaModuleNV ) + { + getDispatcher()->vkDestroyCudaModuleNV( + static_cast( m_device ), static_cast( m_cudaModuleNV ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_cudaModuleNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::CudaModuleNV release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_cudaModuleNV, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( CudaModuleNV & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_cudaModuleNV, rhs.m_cudaModuleNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_NV_cuda_kernel_launch === + + // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getCache() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CudaModuleNV m_cudaModuleNV = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper class for handle VkDataGraphPipelineSessionARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionARM.html + class DataGraphPipelineSessionARM + { + public: + using CType = VkDataGraphPipelineSessionARM; + using CppType = VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDataGraphPipelineSessionARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DataGraphPipelineSessionARM( Device const & device, + DataGraphPipelineSessionCreateInfoARM const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createDataGraphPipelineSessionARM( createInfo, allocator ); + } +# endif + + DataGraphPipelineSessionARM( Device const & device, VkDataGraphPipelineSessionARM session, Optional allocator = nullptr ) + : m_device( device ) + , m_dataGraphPipelineSessionARM( session ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + DataGraphPipelineSessionARM( std::nullptr_t ) {} + + ~DataGraphPipelineSessionARM() + { + clear(); + } + + DataGraphPipelineSessionARM() = delete; + DataGraphPipelineSessionARM( DataGraphPipelineSessionARM const & ) = delete; + + DataGraphPipelineSessionARM( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_dataGraphPipelineSessionARM( exchange( rhs.m_dataGraphPipelineSessionARM, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM const & ) = delete; + + DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_dataGraphPipelineSessionARM, rhs.m_dataGraphPipelineSessionARM ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_dataGraphPipelineSessionARM; + } + + VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_dataGraphPipelineSessionARM ); + } + + operator VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM() const VULKAN_HPP_NOEXCEPT + { + return m_dataGraphPipelineSessionARM; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_dataGraphPipelineSessionARM ) + { + getDispatcher()->vkDestroyDataGraphPipelineSessionARM( static_cast( m_device ), + static_cast( m_dataGraphPipelineSessionARM ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_dataGraphPipelineSessionARM = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_dataGraphPipelineSessionARM, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( DataGraphPipelineSessionARM & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_dataGraphPipelineSessionARM, rhs.m_dataGraphPipelineSessionARM ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM m_dataGraphPipelineSessionARM = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportCallbackEXT.html + class DebugReportCallbackEXT + { + public: + using CType = VkDebugReportCallbackEXT; + using CppType = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDebugReportCallbackEXT; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DebugReportCallbackEXT( Instance const & instance, + DebugReportCallbackCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) + { + *this = instance.createDebugReportCallbackEXT( createInfo, allocator ); + } +# endif + + DebugReportCallbackEXT( Instance const & instance, VkDebugReportCallbackEXT callback, Optional allocator = nullptr ) + : m_instance( instance ) + , m_debugReportCallbackEXT( callback ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( instance.getDispatcher() ) + { + } + + DebugReportCallbackEXT( std::nullptr_t ) {} + + ~DebugReportCallbackEXT() + { + clear(); + } + + DebugReportCallbackEXT() = delete; + DebugReportCallbackEXT( DebugReportCallbackEXT const & ) = delete; + + DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT + : m_instance( exchange( rhs.m_instance, {} ) ) + , m_debugReportCallbackEXT( exchange( rhs.m_debugReportCallbackEXT, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & ) = delete; + + DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_instance, rhs.m_instance ); + std::swap( m_debugReportCallbackEXT, rhs.m_debugReportCallbackEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_debugReportCallbackEXT; + } + + VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_debugReportCallbackEXT ); + } + + operator VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT + { + return m_debugReportCallbackEXT; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_debugReportCallbackEXT ) + { + getDispatcher()->vkDestroyDebugReportCallbackEXT( static_cast( m_instance ), + static_cast( m_debugReportCallbackEXT ), + reinterpret_cast( m_allocator ) ); + } + m_instance = nullptr; + m_debugReportCallbackEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT release() + { + m_instance = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_debugReportCallbackEXT, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Instance getInstance() const + { + return m_instance; + } + + detail::InstanceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( DebugReportCallbackEXT & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_instance, rhs.m_instance ); + std::swap( m_debugReportCallbackEXT, rhs.m_debugReportCallbackEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Instance m_instance = {}; + VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT m_debugReportCallbackEXT = {}; + const AllocationCallbacks * m_allocator = {}; + detail::InstanceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerEXT.html + class DebugUtilsMessengerEXT + { + public: + using CType = VkDebugUtilsMessengerEXT; + using CppType = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DebugUtilsMessengerEXT( Instance const & instance, + DebugUtilsMessengerCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) + { + *this = instance.createDebugUtilsMessengerEXT( createInfo, allocator ); + } +# endif + + DebugUtilsMessengerEXT( Instance const & instance, VkDebugUtilsMessengerEXT messenger, Optional allocator = nullptr ) + : m_instance( instance ) + , m_debugUtilsMessengerEXT( messenger ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( instance.getDispatcher() ) + { + } + + DebugUtilsMessengerEXT( std::nullptr_t ) {} + + ~DebugUtilsMessengerEXT() + { + clear(); + } + + DebugUtilsMessengerEXT() = delete; + DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & ) = delete; + + DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT + : m_instance( exchange( rhs.m_instance, {} ) ) + , m_debugUtilsMessengerEXT( exchange( rhs.m_debugUtilsMessengerEXT, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & ) = delete; + + DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_instance, rhs.m_instance ); + std::swap( m_debugUtilsMessengerEXT, rhs.m_debugUtilsMessengerEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_debugUtilsMessengerEXT; + } + + VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_debugUtilsMessengerEXT ); + } + + operator VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT + { + return m_debugUtilsMessengerEXT; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_debugUtilsMessengerEXT ) + { + getDispatcher()->vkDestroyDebugUtilsMessengerEXT( static_cast( m_instance ), + static_cast( m_debugUtilsMessengerEXT ), + reinterpret_cast( m_allocator ) ); + } + m_instance = nullptr; + m_debugUtilsMessengerEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT release() + { + m_instance = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_debugUtilsMessengerEXT, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Instance getInstance() const + { + return m_instance; + } + + detail::InstanceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( DebugUtilsMessengerEXT & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_instance, rhs.m_instance ); + std::swap( m_debugUtilsMessengerEXT, rhs.m_debugUtilsMessengerEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Instance m_instance = {}; + VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {}; + const AllocationCallbacks * m_allocator = {}; + detail::InstanceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeferredOperationKHR.html + class DeferredOperationKHR + { + public: + using CType = VkDeferredOperationKHR; + using CppType = VULKAN_HPP_NAMESPACE::DeferredOperationKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeferredOperationKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DeferredOperationKHR( Device const & device, Optional allocator = nullptr ) + { + *this = device.createDeferredOperationKHR( allocator ); + } +# endif + + DeferredOperationKHR( Device const & device, VkDeferredOperationKHR operation, Optional allocator = nullptr ) + : m_device( device ) + , m_deferredOperationKHR( operation ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + DeferredOperationKHR( std::nullptr_t ) {} + + ~DeferredOperationKHR() + { + clear(); + } + + DeferredOperationKHR() = delete; + DeferredOperationKHR( DeferredOperationKHR const & ) = delete; + + DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_deferredOperationKHR( exchange( rhs.m_deferredOperationKHR, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + DeferredOperationKHR & operator=( DeferredOperationKHR const & ) = delete; + + DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_deferredOperationKHR, rhs.m_deferredOperationKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_deferredOperationKHR; + } + + VULKAN_HPP_NAMESPACE::DeferredOperationKHR const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_deferredOperationKHR ); + } + + operator VULKAN_HPP_NAMESPACE::DeferredOperationKHR() const VULKAN_HPP_NOEXCEPT + { + return m_deferredOperationKHR; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_deferredOperationKHR ) + { + getDispatcher()->vkDestroyDeferredOperationKHR( static_cast( m_device ), + static_cast( m_deferredOperationKHR ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_deferredOperationKHR = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::DeferredOperationKHR release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_deferredOperationKHR, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( DeferredOperationKHR & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_deferredOperationKHR, rhs.m_deferredOperationKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_KHR_deferred_host_operations === + + // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html + VULKAN_HPP_NODISCARD uint32_t getMaxConcurrency() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeferredOperationResultKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html + VULKAN_HPP_NODISCARD Result getResult() const; + + // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html + VULKAN_HPP_NODISCARD Result join() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DeferredOperationKHR m_deferredOperationKHR = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPool.html + class DescriptorPool + { + public: + using CType = VkDescriptorPool; + using CppType = VULKAN_HPP_NAMESPACE::DescriptorPool; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorPool; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DescriptorPool( Device const & device, DescriptorPoolCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createDescriptorPool( createInfo, allocator ); + } +# endif + + DescriptorPool( Device const & device, VkDescriptorPool descriptorPool, Optional allocator = nullptr ) + : m_device( device ) + , m_descriptorPool( descriptorPool ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + DescriptorPool( std::nullptr_t ) {} + + ~DescriptorPool() + { + clear(); + } + + DescriptorPool() = delete; + DescriptorPool( DescriptorPool const & ) = delete; + + DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_descriptorPool( exchange( rhs.m_descriptorPool, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + DescriptorPool & operator=( DescriptorPool const & ) = delete; + + DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_descriptorPool, rhs.m_descriptorPool ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::DescriptorPool const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_descriptorPool; + } + + VULKAN_HPP_NAMESPACE::DescriptorPool const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_descriptorPool ); + } + + operator VULKAN_HPP_NAMESPACE::DescriptorPool() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorPool; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_descriptorPool ) + { + getDispatcher()->vkDestroyDescriptorPool( static_cast( m_device ), + static_cast( m_descriptorPool ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_descriptorPool = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::DescriptorPool release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_descriptorPool, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( DescriptorPool & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_descriptorPool, rhs.m_descriptorPool ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html + typename ResultValueType::type reset( DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSet.html + class DescriptorSet + { + public: + using CType = VkDescriptorSet; + using CppType = VULKAN_HPP_NAMESPACE::DescriptorSet; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSet; + + public: + DescriptorSet( Device const & device, VkDescriptorSet descriptorSet, VkDescriptorPool descriptorPool ) + : m_device( device ), m_descriptorPool( descriptorPool ), m_descriptorSet( descriptorSet ), m_dispatcher( device.getDispatcher() ) + { + } + + DescriptorSet( std::nullptr_t ) {} + + ~DescriptorSet() + { + clear(); + } + + DescriptorSet() = delete; + DescriptorSet( DescriptorSet const & ) = delete; + + DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_descriptorPool( exchange( rhs.m_descriptorPool, {} ) ) + , m_descriptorSet( exchange( rhs.m_descriptorSet, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + DescriptorSet & operator=( DescriptorSet const & ) = delete; + + DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_descriptorPool, rhs.m_descriptorPool ); + std::swap( m_descriptorSet, rhs.m_descriptorSet ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::DescriptorSet const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_descriptorSet; + } + + VULKAN_HPP_NAMESPACE::DescriptorSet const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_descriptorSet ); + } + + operator VULKAN_HPP_NAMESPACE::DescriptorSet() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorSet; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_descriptorSet ) + { + getDispatcher()->vkFreeDescriptorSets( static_cast( m_device ), + static_cast( m_descriptorPool ), + 1, + reinterpret_cast( &m_descriptorSet ) ); + } + m_device = nullptr; + m_descriptorPool = nullptr; + m_descriptorSet = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::DescriptorSet release() + { + m_device = nullptr; + m_descriptorPool = nullptr; + m_dispatcher = nullptr; + return exchange( m_descriptorSet, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( DescriptorSet & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_descriptorPool, rhs.m_descriptorPool ); + std::swap( m_descriptorSet, rhs.m_descriptorSet ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkUpdateDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html + template + void updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_descriptor_update_template === + + // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html + template + void updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_VALVE_descriptor_set_host_mapping === + + // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html + VULKAN_HPP_NODISCARD void * getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; + VULKAN_HPP_NAMESPACE::DescriptorSet m_descriptorSet = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + class DescriptorSets : public std::vector + { + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DescriptorSets( Device const & device, DescriptorSetAllocateInfo const & allocateInfo ) + { + *this = device.allocateDescriptorSets( allocateInfo ); + } +# endif + + DescriptorSets( std::nullptr_t ) {} + + DescriptorSets() = delete; + DescriptorSets( DescriptorSets const & ) = delete; + DescriptorSets( DescriptorSets && rhs ) = default; + DescriptorSets & operator=( DescriptorSets const & ) = delete; + DescriptorSets & operator=( DescriptorSets && rhs ) = default; + + DescriptorSets( std::vector && rhs ) + { + std::swap( *this, rhs ); + } + }; + + // wrapper class for handle VkDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayout.html + class DescriptorSetLayout + { + public: + using CType = VkDescriptorSetLayout; + using CppType = VULKAN_HPP_NAMESPACE::DescriptorSetLayout; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSetLayout; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DescriptorSetLayout( Device const & device, DescriptorSetLayoutCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createDescriptorSetLayout( createInfo, allocator ); + } +# endif + + DescriptorSetLayout( Device const & device, VkDescriptorSetLayout descriptorSetLayout, Optional allocator = nullptr ) + : m_device( device ) + , m_descriptorSetLayout( descriptorSetLayout ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + DescriptorSetLayout( std::nullptr_t ) {} + + ~DescriptorSetLayout() + { + clear(); + } + + DescriptorSetLayout() = delete; + DescriptorSetLayout( DescriptorSetLayout const & ) = delete; + + DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_descriptorSetLayout( exchange( rhs.m_descriptorSetLayout, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + DescriptorSetLayout & operator=( DescriptorSetLayout const & ) = delete; + + DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_descriptorSetLayout; + } + + VULKAN_HPP_NAMESPACE::DescriptorSetLayout const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_descriptorSetLayout ); + } + + operator VULKAN_HPP_NAMESPACE::DescriptorSetLayout() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorSetLayout; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_descriptorSetLayout ) + { + getDispatcher()->vkDestroyDescriptorSetLayout( static_cast( m_device ), + static_cast( m_descriptorSetLayout ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_descriptorSetLayout = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::DescriptorSetLayout release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_descriptorSetLayout, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( DescriptorSetLayout & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_EXT_descriptor_buffer === + + // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html + VULKAN_HPP_NODISCARD DeviceSize getSizeEXT() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html + VULKAN_HPP_NODISCARD DeviceSize getBindingOffsetEXT( uint32_t binding ) const VULKAN_HPP_NOEXCEPT; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DescriptorSetLayout m_descriptorSetLayout = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplate.html + class DescriptorUpdateTemplate + { + public: + using CType = VkDescriptorUpdateTemplate; + using CppType = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorUpdateTemplate; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DescriptorUpdateTemplate( Device const & device, + DescriptorUpdateTemplateCreateInfo const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createDescriptorUpdateTemplate( createInfo, allocator ); + } +# endif + + DescriptorUpdateTemplate( Device const & device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + Optional allocator = nullptr ) + : m_device( device ) + , m_descriptorUpdateTemplate( descriptorUpdateTemplate ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + DescriptorUpdateTemplate( std::nullptr_t ) {} + + ~DescriptorUpdateTemplate() + { + clear(); + } + + DescriptorUpdateTemplate() = delete; + DescriptorUpdateTemplate( DescriptorUpdateTemplate const & ) = delete; + + DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_descriptorUpdateTemplate( exchange( rhs.m_descriptorUpdateTemplate, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & ) = delete; + + DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_descriptorUpdateTemplate; + } + + VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_descriptorUpdateTemplate ); + } + + operator VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT + { + return m_descriptorUpdateTemplate; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_descriptorUpdateTemplate ) + { + getDispatcher()->vkDestroyDescriptorUpdateTemplate( static_cast( m_device ), + static_cast( m_descriptorUpdateTemplate ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_descriptorUpdateTemplate = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_descriptorUpdateTemplate, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( DescriptorUpdateTemplate & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate m_descriptorUpdateTemplate = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDeviceMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemory.html + class DeviceMemory + { + public: + using CType = VkDeviceMemory; + using CppType = VULKAN_HPP_NAMESPACE::DeviceMemory; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDeviceMemory; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DeviceMemory( Device const & device, MemoryAllocateInfo const & allocateInfo, Optional allocator = nullptr ) + { + *this = device.allocateMemory( allocateInfo, allocator ); + } +# endif + + DeviceMemory( Device const & device, VkDeviceMemory memory, Optional allocator = nullptr ) + : m_device( device ) + , m_deviceMemory( memory ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + DeviceMemory( std::nullptr_t ) {} + + ~DeviceMemory() + { + clear(); + } + + DeviceMemory() = delete; + DeviceMemory( DeviceMemory const & ) = delete; + + DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_deviceMemory( exchange( rhs.m_deviceMemory, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + DeviceMemory & operator=( DeviceMemory const & ) = delete; + + DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_deviceMemory, rhs.m_deviceMemory ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::DeviceMemory const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_deviceMemory; + } + + VULKAN_HPP_NAMESPACE::DeviceMemory const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_deviceMemory ); + } + + operator VULKAN_HPP_NAMESPACE::DeviceMemory() const VULKAN_HPP_NOEXCEPT + { + return m_deviceMemory; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_deviceMemory ) + { + getDispatcher()->vkFreeMemory( + static_cast( m_device ), static_cast( m_deviceMemory ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_deviceMemory = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::DeviceMemory release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_deviceMemory, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( DeviceMemory & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_deviceMemory, rhs.m_deviceMemory ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + mapMemory( DeviceSize offset, DeviceSize size, MemoryMapFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html + void unmapMemory() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetDeviceMemoryCommitment, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html + VULKAN_HPP_NODISCARD DeviceSize getCommitment() const VULKAN_HPP_NOEXCEPT; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + + // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryWin32HandleNV( ExternalMemoryHandleTypeFlagsNV handleType ) const; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_pageable_device_local_memory === + + // wrapper function for command vkSetDeviceMemoryPriorityEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html + void setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DeviceMemory m_deviceMemory = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkDisplayKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayKHR.html + class DisplayKHR + { + public: + using CType = VkDisplayKHR; + using CppType = VULKAN_HPP_NAMESPACE::DisplayKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayKHR; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DisplayKHR( PhysicalDevice const & physicalDevice, int32_t drmFd, uint32_t connectorId ) + { + *this = physicalDevice.getDrmDisplayEXT( drmFd, connectorId ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + DisplayKHR( PhysicalDevice const & physicalDevice, Display & dpy, RROutput rrOutput ) + { + *this = physicalDevice.getRandROutputDisplayEXT( dpy, rrOutput ); + } +# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + DisplayKHR( PhysicalDevice const & physicalDevice, uint32_t deviceRelativeId ) + { + *this = physicalDevice.getWinrtDisplayNV( deviceRelativeId ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ +# endif + + DisplayKHR( PhysicalDevice const & physicalDevice, VkDisplayKHR display ) + : m_physicalDevice( physicalDevice ), m_displayKHR( display ), m_dispatcher( physicalDevice.getDispatcher() ) + { + } + + DisplayKHR( std::nullptr_t ) {} + + ~DisplayKHR() + { + clear(); + } + + DisplayKHR() = delete; + DisplayKHR( DisplayKHR const & ) = delete; + + DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT + : m_physicalDevice( exchange( rhs.m_physicalDevice, {} ) ) + , m_displayKHR( exchange( rhs.m_displayKHR, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + DisplayKHR & operator=( DisplayKHR const & ) = delete; + + DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_physicalDevice, rhs.m_physicalDevice ); + std::swap( m_displayKHR, rhs.m_displayKHR ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::DisplayKHR const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_displayKHR; + } + + VULKAN_HPP_NAMESPACE::DisplayKHR const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_displayKHR ); + } + + operator VULKAN_HPP_NAMESPACE::DisplayKHR() const VULKAN_HPP_NOEXCEPT + { + return m_displayKHR; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_displayKHR ) + { + getDispatcher()->vkReleaseDisplayEXT( static_cast( m_physicalDevice ), static_cast( m_displayKHR ) ); + } + m_physicalDevice = nullptr; + m_displayKHR = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::DisplayKHR release() + { + m_physicalDevice = nullptr; + m_dispatcher = nullptr; + return exchange( m_displayKHR, nullptr ); + } + + VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const + { + return m_physicalDevice; + } + + detail::InstanceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( DisplayKHR & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_physicalDevice, rhs.m_physicalDevice ); + std::swap( m_displayKHR, rhs.m_displayKHR ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_KHR_display === + + // wrapper function for command vkGetDisplayModePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getModeProperties() const; + + // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + createMode( DisplayModeCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; + + //=== VK_KHR_get_display_properties2 === + + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getModeProperties2() const; + + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type getModeProperties2() const; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + + // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html + typename ResultValueType::type acquireWinrtNV() const; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + private: + VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; + VULKAN_HPP_NAMESPACE::DisplayKHR m_displayKHR = {}; + detail::InstanceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + class DisplayKHRs : public std::vector + { + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DisplayKHRs( PhysicalDevice const & physicalDevice, uint32_t planeIndex ) + { + *this = physicalDevice.getDisplayPlaneSupportedDisplaysKHR( planeIndex ); + } +# endif + + DisplayKHRs( std::nullptr_t ) {} + + DisplayKHRs() = delete; + DisplayKHRs( DisplayKHRs const & ) = delete; + DisplayKHRs( DisplayKHRs && rhs ) = default; + DisplayKHRs & operator=( DisplayKHRs const & ) = delete; + DisplayKHRs & operator=( DisplayKHRs && rhs ) = default; + + DisplayKHRs( std::vector && rhs ) + { + std::swap( *this, rhs ); + } + }; + + // wrapper class for handle VkDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeKHR.html + class DisplayModeKHR + { + public: + using CType = VkDisplayModeKHR; + using CppType = VULKAN_HPP_NAMESPACE::DisplayModeKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayModeKHR; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + DisplayModeKHR( DisplayKHR const & display, DisplayModeCreateInfoKHR const & createInfo, Optional allocator = nullptr ) + { + *this = display.createMode( createInfo, allocator ); + } +# endif + + DisplayModeKHR( DisplayKHR const & display, VkDisplayModeKHR displayModeKHR ) + : m_physicalDevice( display.getPhysicalDevice() ), m_displayModeKHR( displayModeKHR ), m_dispatcher( display.getDispatcher() ) + { + } + + DisplayModeKHR( std::nullptr_t ) {} + + ~DisplayModeKHR() + { + clear(); + } + + DisplayModeKHR() = delete; + + DisplayModeKHR( DisplayModeKHR const & rhs ) : m_displayModeKHR( rhs.m_displayModeKHR ), m_dispatcher( rhs.m_dispatcher ) {} + + DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT + : m_physicalDevice( exchange( rhs.m_physicalDevice, {} ) ) + , m_displayModeKHR( exchange( rhs.m_displayModeKHR, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) + { + m_displayModeKHR = rhs.m_displayModeKHR; + m_dispatcher = rhs.m_dispatcher; + return *this; + } + + DisplayModeKHR & operator=( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_physicalDevice, rhs.m_physicalDevice ); + std::swap( m_displayModeKHR, rhs.m_displayModeKHR ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::DisplayModeKHR const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_displayModeKHR; + } + + VULKAN_HPP_NAMESPACE::DisplayModeKHR const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_displayModeKHR ); + } + + operator VULKAN_HPP_NAMESPACE::DisplayModeKHR() const VULKAN_HPP_NOEXCEPT + { + return m_displayModeKHR; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + m_physicalDevice = nullptr; + m_displayModeKHR = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::DisplayModeKHR release() + { + m_physicalDevice = nullptr; + m_dispatcher = nullptr; + return exchange( m_displayModeKHR, nullptr ); + } + + detail::InstanceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( DisplayModeKHR & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_physicalDevice, rhs.m_physicalDevice ); + std::swap( m_displayModeKHR, rhs.m_displayModeKHR ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_KHR_display === + + // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getDisplayPlaneCapabilities( uint32_t planeIndex ) const; + + private: + VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; + VULKAN_HPP_NAMESPACE::DisplayModeKHR m_displayModeKHR = {}; + detail::InstanceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEvent.html + class Event + { + public: + using CType = VkEvent; + using CppType = VULKAN_HPP_NAMESPACE::Event; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eEvent; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Event( Device const & device, EventCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createEvent( createInfo, allocator ); + } +# endif + + Event( Device const & device, VkEvent event, Optional allocator = nullptr ) + : m_device( device ), m_event( event ), m_allocator( static_cast( allocator ) ), m_dispatcher( device.getDispatcher() ) + { + } + + Event( std::nullptr_t ) {} + + ~Event() + { + clear(); + } + + Event() = delete; + Event( Event const & ) = delete; + + Event( Event && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_event( exchange( rhs.m_event, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + Event & operator=( Event const & ) = delete; + + Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_event, rhs.m_event ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::Event const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_event; + } + + VULKAN_HPP_NAMESPACE::Event const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_event ); + } + + operator VULKAN_HPP_NAMESPACE::Event() const VULKAN_HPP_NOEXCEPT + { + return m_event; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_event ) + { + getDispatcher()->vkDestroyEvent( + static_cast( m_device ), static_cast( m_event ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_event = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::Event release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_event, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( Event & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_event, rhs.m_event ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html + VULKAN_HPP_NODISCARD Result getStatus() const; + + // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html + typename ResultValueType::type set() const; + + // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html + typename ResultValueType::type reset() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Event m_event = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueNV.html + class ExternalComputeQueueNV + { + public: + using CType = VkExternalComputeQueueNV; + using CppType = VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eExternalComputeQueueNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + ExternalComputeQueueNV( Device const & device, + ExternalComputeQueueCreateInfoNV const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createExternalComputeQueueNV( createInfo, allocator ); + } +# endif + + ExternalComputeQueueNV( Device const & device, VkExternalComputeQueueNV externalQueue, Optional allocator = nullptr ) + : m_device( device ) + , m_externalComputeQueueNV( externalQueue ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + ExternalComputeQueueNV( std::nullptr_t ) {} + + ~ExternalComputeQueueNV() + { + clear(); + } + + ExternalComputeQueueNV() = delete; + ExternalComputeQueueNV( ExternalComputeQueueNV const & ) = delete; + + ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_externalComputeQueueNV( exchange( rhs.m_externalComputeQueueNV, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + ExternalComputeQueueNV & operator=( ExternalComputeQueueNV const & ) = delete; + + ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_externalComputeQueueNV, rhs.m_externalComputeQueueNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_externalComputeQueueNV; + } + + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_externalComputeQueueNV ); + } + + operator VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV() const VULKAN_HPP_NOEXCEPT + { + return m_externalComputeQueueNV; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_externalComputeQueueNV ) + { + getDispatcher()->vkDestroyExternalComputeQueueNV( static_cast( m_device ), + static_cast( m_externalComputeQueueNV ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_externalComputeQueueNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_externalComputeQueueNV, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( ExternalComputeQueueNV & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_externalComputeQueueNV, rhs.m_externalComputeQueueNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template + VULKAN_HPP_NODISCARD std::pair getData() const VULKAN_HPP_NOEXCEPT; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV m_externalComputeQueueNV = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFence.html + class Fence + { + public: + using CType = VkFence; + using CppType = VULKAN_HPP_NAMESPACE::Fence; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFence; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Fence( Device const & device, FenceCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createFence( createInfo, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Fence( Device const & device, DeviceEventInfoEXT const & deviceEventInfo, Optional allocator = nullptr ) + { + *this = device.registerEventEXT( deviceEventInfo, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Fence( Device const & device, + DisplayKHR const & display, + DisplayEventInfoEXT const & displayEventInfo, + Optional allocator = nullptr ) + { + *this = device.registerDisplayEventEXT( display, displayEventInfo, allocator ); + } +# endif + + Fence( Device const & device, VkFence fence, Optional allocator = nullptr ) + : m_device( device ), m_fence( fence ), m_allocator( static_cast( allocator ) ), m_dispatcher( device.getDispatcher() ) + { + } + + Fence( std::nullptr_t ) {} + + ~Fence() + { + clear(); + } + + Fence() = delete; + Fence( Fence const & ) = delete; + + Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_fence( exchange( rhs.m_fence, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + Fence & operator=( Fence const & ) = delete; + + Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_fence, rhs.m_fence ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::Fence const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_fence; + } + + VULKAN_HPP_NAMESPACE::Fence const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_fence ); + } + + operator VULKAN_HPP_NAMESPACE::Fence() const VULKAN_HPP_NOEXCEPT + { + return m_fence; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_fence ) + { + getDispatcher()->vkDestroyFence( + static_cast( m_device ), static_cast( m_fence ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_fence = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::Fence release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_fence, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( Fence & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_fence, rhs.m_fence ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html + VULKAN_HPP_NODISCARD Result getStatus() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Fence m_fence = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebuffer.html + class Framebuffer + { + public: + using CType = VkFramebuffer; + using CppType = VULKAN_HPP_NAMESPACE::Framebuffer; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFramebuffer; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Framebuffer( Device const & device, FramebufferCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createFramebuffer( createInfo, allocator ); + } +# endif + + Framebuffer( Device const & device, VkFramebuffer framebuffer, Optional allocator = nullptr ) + : m_device( device ) + , m_framebuffer( framebuffer ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + Framebuffer( std::nullptr_t ) {} + + ~Framebuffer() + { + clear(); + } + + Framebuffer() = delete; + Framebuffer( Framebuffer const & ) = delete; + + Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_framebuffer( exchange( rhs.m_framebuffer, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + Framebuffer & operator=( Framebuffer const & ) = delete; + + Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_framebuffer, rhs.m_framebuffer ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::Framebuffer const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_framebuffer; + } + + VULKAN_HPP_NAMESPACE::Framebuffer const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_framebuffer ); + } + + operator VULKAN_HPP_NAMESPACE::Framebuffer() const VULKAN_HPP_NOEXCEPT + { + return m_framebuffer; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_framebuffer ) + { + getDispatcher()->vkDestroyFramebuffer( + static_cast( m_device ), static_cast( m_framebuffer ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_framebuffer = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::Framebuffer release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_framebuffer, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( Framebuffer & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_framebuffer, rhs.m_framebuffer ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_QCOM_tile_properties === + + // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getTilePropertiesQCOM() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Framebuffer m_framebuffer = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImage.html + class Image + { + public: + using CType = VkImage; + using CppType = VULKAN_HPP_NAMESPACE::Image; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImage; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Image( Device const & device, ImageCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createImage( createInfo, allocator ); + } +# endif + + Image( Device const & device, VkImage image, Optional allocator = nullptr ) + : m_device( device ), m_image( image ), m_allocator( static_cast( allocator ) ), m_dispatcher( device.getDispatcher() ) + { + } + + Image( std::nullptr_t ) {} + + ~Image() + { + clear(); + } + + Image() = delete; + Image( Image const & ) = delete; + + Image( Image && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_image( exchange( rhs.m_image, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + Image & operator=( Image const & ) = delete; + + Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_image, rhs.m_image ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::Image const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_image; + } + + VULKAN_HPP_NAMESPACE::Image const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_image ); + } + + operator VULKAN_HPP_NAMESPACE::Image() const VULKAN_HPP_NOEXCEPT + { + return m_image; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_image ) + { + getDispatcher()->vkDestroyImage( + static_cast( m_device ), static_cast( m_image ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_image = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::Image release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_image, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( Image & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_image, rhs.m_image ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html + typename ResultValueType::type bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, DeviceSize memoryOffset ) const; + + // wrapper function for command vkGetImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html + VULKAN_HPP_NODISCARD MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html + VULKAN_HPP_NODISCARD std::vector getSparseMemoryRequirements() const; + + // wrapper function for command vkGetImageSubresourceLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html + VULKAN_HPP_NODISCARD SubresourceLayout getSubresourceLayout( const ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_VERSION_1_4 === + + // wrapper function for command vkGetImageSubresourceLayout2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html + VULKAN_HPP_NODISCARD SubresourceLayout2 getSubresourceLayout2( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetImageSubresourceLayout2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html + template + VULKAN_HPP_NODISCARD StructureChain getSubresourceLayout2( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_image_drm_format_modifier === + + // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getDrmFormatModifierPropertiesEXT() const; + + //=== VK_EXT_host_image_copy === + + // wrapper function for command vkGetImageSubresourceLayout2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html + VULKAN_HPP_NODISCARD SubresourceLayout2 getSubresourceLayout2EXT( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetImageSubresourceLayout2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html + template + VULKAN_HPP_NODISCARD StructureChain getSubresourceLayout2EXT( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_maintenance5 === + + // wrapper function for command vkGetImageSubresourceLayout2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html + VULKAN_HPP_NODISCARD SubresourceLayout2 getSubresourceLayout2KHR( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetImageSubresourceLayout2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html + template + VULKAN_HPP_NODISCARD StructureChain getSubresourceLayout2KHR( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; + + protected: + Image( VULKAN_HPP_NAMESPACE::Device device, + VULKAN_HPP_NAMESPACE::Image image, + const AllocationCallbacks * allocator, + detail::DeviceDispatcher const * dispatcher ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( device, {} ) ) + , m_image( exchange( image, {} ) ) + , m_allocator( exchange( allocator, {} ) ) + , m_dispatcher( exchange( dispatcher, nullptr ) ) + { + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Image m_image = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageView.html + class ImageView + { + public: + using CType = VkImageView; + using CppType = VULKAN_HPP_NAMESPACE::ImageView; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImageView; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + ImageView( Device const & device, ImageViewCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createImageView( createInfo, allocator ); + } +# endif + + ImageView( Device const & device, VkImageView imageView, Optional allocator = nullptr ) + : m_device( device ) + , m_imageView( imageView ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + ImageView( std::nullptr_t ) {} + + ~ImageView() + { + clear(); + } + + ImageView() = delete; + ImageView( ImageView const & ) = delete; + + ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_imageView( exchange( rhs.m_imageView, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + ImageView & operator=( ImageView const & ) = delete; + + ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_imageView, rhs.m_imageView ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::ImageView const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_imageView; + } + + VULKAN_HPP_NAMESPACE::ImageView const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_imageView ); + } + + operator VULKAN_HPP_NAMESPACE::ImageView() const VULKAN_HPP_NOEXCEPT + { + return m_imageView; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_imageView ) + { + getDispatcher()->vkDestroyImageView( + static_cast( m_device ), static_cast( m_imageView ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_imageView = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::ImageView release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_imageView, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( ImageView & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_imageView, rhs.m_imageView ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_NVX_image_view_handle === + + // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getAddressNVX() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ImageView m_imageView = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutEXT.html + class IndirectCommandsLayoutEXT + { + public: + using CType = VkIndirectCommandsLayoutEXT; + using CppType = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + IndirectCommandsLayoutEXT( Device const & device, + IndirectCommandsLayoutCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createIndirectCommandsLayoutEXT( createInfo, allocator ); + } +# endif + + IndirectCommandsLayoutEXT( Device const & device, + VkIndirectCommandsLayoutEXT indirectCommandsLayout, + Optional allocator = nullptr ) + : m_device( device ) + , m_indirectCommandsLayoutEXT( indirectCommandsLayout ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + IndirectCommandsLayoutEXT( std::nullptr_t ) {} + + ~IndirectCommandsLayoutEXT() + { + clear(); + } + + IndirectCommandsLayoutEXT() = delete; + IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT const & ) = delete; + + IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_indirectCommandsLayoutEXT( exchange( rhs.m_indirectCommandsLayoutEXT, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT const & ) = delete; + + IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_indirectCommandsLayoutEXT, rhs.m_indirectCommandsLayoutEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_indirectCommandsLayoutEXT; + } + + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_indirectCommandsLayoutEXT ); + } + + operator VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT() const VULKAN_HPP_NOEXCEPT + { + return m_indirectCommandsLayoutEXT; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_indirectCommandsLayoutEXT ) + { + getDispatcher()->vkDestroyIndirectCommandsLayoutEXT( static_cast( m_device ), + static_cast( m_indirectCommandsLayoutEXT ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_indirectCommandsLayoutEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_indirectCommandsLayoutEXT, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( IndirectCommandsLayoutEXT & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_indirectCommandsLayoutEXT, rhs.m_indirectCommandsLayoutEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT m_indirectCommandsLayoutEXT = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutNV.html + class IndirectCommandsLayoutNV + { + public: + using CType = VkIndirectCommandsLayoutNV; + using CppType = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + IndirectCommandsLayoutNV( Device const & device, + IndirectCommandsLayoutCreateInfoNV const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createIndirectCommandsLayoutNV( createInfo, allocator ); + } +# endif + + IndirectCommandsLayoutNV( Device const & device, + VkIndirectCommandsLayoutNV indirectCommandsLayout, + Optional allocator = nullptr ) + : m_device( device ) + , m_indirectCommandsLayoutNV( indirectCommandsLayout ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + IndirectCommandsLayoutNV( std::nullptr_t ) {} + + ~IndirectCommandsLayoutNV() + { + clear(); + } + + IndirectCommandsLayoutNV() = delete; + IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & ) = delete; + + IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_indirectCommandsLayoutNV( exchange( rhs.m_indirectCommandsLayoutNV, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & ) = delete; + + IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_indirectCommandsLayoutNV, rhs.m_indirectCommandsLayoutNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_indirectCommandsLayoutNV; + } + + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_indirectCommandsLayoutNV ); + } + + operator VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT + { + return m_indirectCommandsLayoutNV; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_indirectCommandsLayoutNV ) + { + getDispatcher()->vkDestroyIndirectCommandsLayoutNV( static_cast( m_device ), + static_cast( m_indirectCommandsLayoutNV ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_indirectCommandsLayoutNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_indirectCommandsLayoutNV, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( IndirectCommandsLayoutNV & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_indirectCommandsLayoutNV, rhs.m_indirectCommandsLayoutNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetEXT.html + class IndirectExecutionSetEXT + { + public: + using CType = VkIndirectExecutionSetEXT; + using CppType = VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectExecutionSetEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + IndirectExecutionSetEXT( Device const & device, + IndirectExecutionSetCreateInfoEXT const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createIndirectExecutionSetEXT( createInfo, allocator ); + } +# endif + + IndirectExecutionSetEXT( Device const & device, VkIndirectExecutionSetEXT indirectExecutionSet, Optional allocator = nullptr ) + : m_device( device ) + , m_indirectExecutionSetEXT( indirectExecutionSet ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + IndirectExecutionSetEXT( std::nullptr_t ) {} + + ~IndirectExecutionSetEXT() + { + clear(); + } + + IndirectExecutionSetEXT() = delete; + IndirectExecutionSetEXT( IndirectExecutionSetEXT const & ) = delete; + + IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_indirectExecutionSetEXT( exchange( rhs.m_indirectExecutionSetEXT, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT const & ) = delete; + + IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_indirectExecutionSetEXT, rhs.m_indirectExecutionSetEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_indirectExecutionSetEXT; + } + + VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_indirectExecutionSetEXT ); + } + + operator VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT() const VULKAN_HPP_NOEXCEPT + { + return m_indirectExecutionSetEXT; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_indirectExecutionSetEXT ) + { + getDispatcher()->vkDestroyIndirectExecutionSetEXT( static_cast( m_device ), + static_cast( m_indirectExecutionSetEXT ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_indirectExecutionSetEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_indirectExecutionSetEXT, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( IndirectExecutionSetEXT & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_indirectExecutionSetEXT, rhs.m_indirectExecutionSetEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_EXT_device_generated_commands === + + // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html + void updatePipeline( ArrayProxy const & executionSetWrites ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html + void updateShader( ArrayProxy const & executionSetWrites ) const VULKAN_HPP_NOEXCEPT; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT m_indirectExecutionSetEXT = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapEXT.html + class MicromapEXT + { + public: + using CType = VkMicromapEXT; + using CppType = VULKAN_HPP_NAMESPACE::MicromapEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eMicromapEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + MicromapEXT( Device const & device, MicromapCreateInfoEXT const & createInfo, Optional allocator = nullptr ) + { + *this = device.createMicromapEXT( createInfo, allocator ); + } +# endif + + MicromapEXT( Device const & device, VkMicromapEXT micromap, Optional allocator = nullptr ) + : m_device( device ) + , m_micromapEXT( micromap ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + MicromapEXT( std::nullptr_t ) {} + + ~MicromapEXT() + { + clear(); + } + + MicromapEXT() = delete; + MicromapEXT( MicromapEXT const & ) = delete; + + MicromapEXT( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_micromapEXT( exchange( rhs.m_micromapEXT, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + MicromapEXT & operator=( MicromapEXT const & ) = delete; + + MicromapEXT & operator=( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_micromapEXT, rhs.m_micromapEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::MicromapEXT const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_micromapEXT; + } + + VULKAN_HPP_NAMESPACE::MicromapEXT const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_micromapEXT ); + } + + operator VULKAN_HPP_NAMESPACE::MicromapEXT() const VULKAN_HPP_NOEXCEPT + { + return m_micromapEXT; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_micromapEXT ) + { + getDispatcher()->vkDestroyMicromapEXT( + static_cast( m_device ), static_cast( m_micromapEXT ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_micromapEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::MicromapEXT release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_micromapEXT, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( MicromapEXT & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_micromapEXT, rhs.m_micromapEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::MicromapEXT m_micromapEXT = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionNV.html + class OpticalFlowSessionNV + { + public: + using CType = VkOpticalFlowSessionNV; + using CppType = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eOpticalFlowSessionNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + OpticalFlowSessionNV( Device const & device, OpticalFlowSessionCreateInfoNV const & createInfo, Optional allocator = nullptr ) + { + *this = device.createOpticalFlowSessionNV( createInfo, allocator ); + } +# endif + + OpticalFlowSessionNV( Device const & device, VkOpticalFlowSessionNV session, Optional allocator = nullptr ) + : m_device( device ) + , m_opticalFlowSessionNV( session ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + OpticalFlowSessionNV( std::nullptr_t ) {} + + ~OpticalFlowSessionNV() + { + clear(); + } + + OpticalFlowSessionNV() = delete; + OpticalFlowSessionNV( OpticalFlowSessionNV const & ) = delete; + + OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_opticalFlowSessionNV( exchange( rhs.m_opticalFlowSessionNV, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & ) = delete; + + OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_opticalFlowSessionNV, rhs.m_opticalFlowSessionNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_opticalFlowSessionNV; + } + + VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_opticalFlowSessionNV ); + } + + operator VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT + { + return m_opticalFlowSessionNV; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_opticalFlowSessionNV ) + { + getDispatcher()->vkDestroyOpticalFlowSessionNV( static_cast( m_device ), + static_cast( m_opticalFlowSessionNV ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_opticalFlowSessionNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_opticalFlowSessionNV, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( OpticalFlowSessionNV & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_opticalFlowSessionNV, rhs.m_opticalFlowSessionNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_NV_optical_flow === + + // wrapper function for command vkBindOpticalFlowSessionImageNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html + typename ResultValueType::type + bindImage( OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, ImageLayout layout ) const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV m_opticalFlowSessionNV = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationINTEL.html + class PerformanceConfigurationINTEL + { + public: + using CType = VkPerformanceConfigurationINTEL; + using CppType = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePerformanceConfigurationINTEL; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + PerformanceConfigurationINTEL( Device const & device, PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) + { + *this = device.acquirePerformanceConfigurationINTEL( acquireInfo ); + } +# endif + + PerformanceConfigurationINTEL( Device const & device, VkPerformanceConfigurationINTEL configuration ) + : m_device( device ), m_performanceConfigurationINTEL( configuration ), m_dispatcher( device.getDispatcher() ) + { + } + + PerformanceConfigurationINTEL( std::nullptr_t ) {} + + ~PerformanceConfigurationINTEL() + { + clear(); + } + + PerformanceConfigurationINTEL() = delete; + PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & ) = delete; + + PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_performanceConfigurationINTEL( exchange( rhs.m_performanceConfigurationINTEL, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & ) = delete; + + PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_performanceConfigurationINTEL, rhs.m_performanceConfigurationINTEL ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_performanceConfigurationINTEL; + } + + VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_performanceConfigurationINTEL ); + } + + operator VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT + { + return m_performanceConfigurationINTEL; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_performanceConfigurationINTEL ) + { + getDispatcher()->vkReleasePerformanceConfigurationINTEL( static_cast( m_device ), + static_cast( m_performanceConfigurationINTEL ) ); + } + m_device = nullptr; + m_performanceConfigurationINTEL = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL release() + { + m_device = nullptr; + m_dispatcher = nullptr; + return exchange( m_performanceConfigurationINTEL, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( PerformanceConfigurationINTEL & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_performanceConfigurationINTEL, rhs.m_performanceConfigurationINTEL ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL m_performanceConfigurationINTEL = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCache.html + class PipelineCache + { + public: + using CType = VkPipelineCache; + using CppType = VULKAN_HPP_NAMESPACE::PipelineCache; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineCache; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + PipelineCache( Device const & device, PipelineCacheCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createPipelineCache( createInfo, allocator ); + } +# endif + + PipelineCache( Device const & device, VkPipelineCache pipelineCache, Optional allocator = nullptr ) + : m_device( device ) + , m_pipelineCache( pipelineCache ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + PipelineCache( std::nullptr_t ) {} + + ~PipelineCache() + { + clear(); + } + + PipelineCache() = delete; + PipelineCache( PipelineCache const & ) = delete; + + PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_pipelineCache( exchange( rhs.m_pipelineCache, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + PipelineCache & operator=( PipelineCache const & ) = delete; + + PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_pipelineCache, rhs.m_pipelineCache ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::PipelineCache const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_pipelineCache; + } + + VULKAN_HPP_NAMESPACE::PipelineCache const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_pipelineCache ); + } + + operator VULKAN_HPP_NAMESPACE::PipelineCache() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineCache; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_pipelineCache ) + { + getDispatcher()->vkDestroyPipelineCache( static_cast( m_device ), + static_cast( m_pipelineCache ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_pipelineCache = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::PipelineCache release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_pipelineCache, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( PipelineCache & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_pipelineCache, rhs.m_pipelineCache ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getData() const; + + // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html + typename ResultValueType::type merge( ArrayProxy const & srcCaches ) const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::PipelineCache m_pipelineCache = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipeline.html + class Pipeline + { + public: + using CType = VkPipeline; + using CppType = VULKAN_HPP_NAMESPACE::Pipeline; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipeline; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Pipeline( Device const & device, + Optional const & pipelineCache, + ComputePipelineCreateInfo const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createComputePipeline( pipelineCache, createInfo, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Pipeline( Device const & device, + Optional const & deferredOperation, + Optional const & pipelineCache, + DataGraphPipelineCreateInfoARM const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createDataGraphPipelineARM( deferredOperation, pipelineCache, createInfo, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + Pipeline( Device const & device, + Optional const & pipelineCache, + ExecutionGraphPipelineCreateInfoAMDX const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createExecutionGraphPipelineAMDX( pipelineCache, createInfo, allocator ); + } +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Pipeline( Device const & device, + Optional const & pipelineCache, + GraphicsPipelineCreateInfo const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createGraphicsPipeline( pipelineCache, createInfo, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Pipeline( Device const & device, + Optional const & deferredOperation, + Optional const & pipelineCache, + RayTracingPipelineCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createRayTracingPipelineKHR( deferredOperation, pipelineCache, createInfo, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Pipeline( Device const & device, + Optional const & pipelineCache, + RayTracingPipelineCreateInfoNV const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createRayTracingPipelineNV( pipelineCache, createInfo, allocator ); + } +# endif + + Pipeline( Device const & device, VkPipeline pipeline, Optional allocator = nullptr, Result successCode = Result::eSuccess ) + : m_device( device ) + , m_pipeline( pipeline ) + , m_allocator( static_cast( allocator ) ) + , m_constructorSuccessCode( successCode ) + , m_dispatcher( device.getDispatcher() ) + { + } + + Pipeline( std::nullptr_t ) {} + + ~Pipeline() + { + clear(); + } + + Pipeline() = delete; + Pipeline( Pipeline const & ) = delete; + + Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_pipeline( exchange( rhs.m_pipeline, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_constructorSuccessCode( exchange( rhs.m_constructorSuccessCode, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + Pipeline & operator=( Pipeline const & ) = delete; + + Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_pipeline, rhs.m_pipeline ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::Pipeline const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_pipeline; + } + + VULKAN_HPP_NAMESPACE::Pipeline const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_pipeline ); + } + + operator VULKAN_HPP_NAMESPACE::Pipeline() const VULKAN_HPP_NOEXCEPT + { + return m_pipeline; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_pipeline ) + { + getDispatcher()->vkDestroyPipeline( + static_cast( m_device ), static_cast( m_pipeline ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_pipeline = nullptr; + m_allocator = nullptr; + m_constructorSuccessCode = Result::eErrorUnknown; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::Pipeline release() + { + m_device = nullptr; + m_allocator = nullptr; + m_constructorSuccessCode = Result::eErrorUnknown; + m_dispatcher = nullptr; + return exchange( m_pipeline, nullptr ); + } + + Result getConstructorSuccessCode() const + { + return m_constructorSuccessCode; + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( Pipeline & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_pipeline, rhs.m_pipeline ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_AMD_shader_info === + + // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getShaderInfoAMD( ShaderStageFlagBits shaderStage, + ShaderInfoTypeAMD infoType ) const; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + + // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getExecutionGraphScratchSizeAMDX() const; + + // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html + VULKAN_HPP_NODISCARD typename ResultValueType::type + getExecutionGraphNodeIndexAMDX( const PipelineShaderStageNodeCreateInfoAMDX & nodeInfo ) const; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_KHR_ray_tracing_pipeline === + + // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; + + // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const; + + // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; + + // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, + uint32_t groupCount ) const; + + // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html + VULKAN_HPP_NODISCARD DeviceSize getRayTracingShaderGroupStackSizeKHR( uint32_t group, ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_ray_tracing === + + // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; + + // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const; + + // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html + typename ResultValueType::type compileDeferredNV( uint32_t shader ) const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Pipeline m_pipeline = {}; + const AllocationCallbacks * m_allocator = {}; + Result m_constructorSuccessCode = Result::eErrorUnknown; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + class Pipelines : public std::vector + { + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Pipelines( Device const & device, + Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) + { + *this = device.createComputePipelines( pipelineCache, createInfos, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Pipelines( Device const & device, + Optional const & deferredOperation, + Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) + { + *this = device.createDataGraphPipelinesARM( deferredOperation, pipelineCache, createInfos, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + Pipelines( Device const & device, + Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) + { + *this = device.createExecutionGraphPipelinesAMDX( pipelineCache, createInfos, allocator ); + } +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Pipelines( Device const & device, + Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) + { + *this = device.createGraphicsPipelines( pipelineCache, createInfos, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Pipelines( Device const & device, + Optional const & deferredOperation, + Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) + { + *this = device.createRayTracingPipelinesKHR( deferredOperation, pipelineCache, createInfos, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Pipelines( Device const & device, + Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator = nullptr ) + { + *this = device.createRayTracingPipelinesNV( pipelineCache, createInfos, allocator ); + } +# endif + + Pipelines( std::nullptr_t ) {} + + Pipelines() = delete; + Pipelines( Pipelines const & ) = delete; + Pipelines( Pipelines && rhs ) = default; + Pipelines & operator=( Pipelines const & ) = delete; + Pipelines & operator=( Pipelines && rhs ) = default; + + Pipelines( std::vector && rhs ) + { + std::swap( *this, rhs ); + } + }; + + // wrapper class for handle VkPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryKHR.html + class PipelineBinaryKHR + { + public: + using CType = VkPipelineBinaryKHR; + using CppType = VULKAN_HPP_NAMESPACE::PipelineBinaryKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineBinaryKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: + PipelineBinaryKHR( Device const & device, + VkPipelineBinaryKHR pipelineBinary, + Optional allocator = nullptr, + Result successCode = Result::eSuccess ) + : m_device( device ) + , m_pipelineBinaryKHR( pipelineBinary ) + , m_allocator( static_cast( allocator ) ) + , m_constructorSuccessCode( successCode ) + , m_dispatcher( device.getDispatcher() ) + { + } + + PipelineBinaryKHR( std::nullptr_t ) {} + + ~PipelineBinaryKHR() + { + clear(); + } + + PipelineBinaryKHR() = delete; + PipelineBinaryKHR( PipelineBinaryKHR const & ) = delete; + + PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_pipelineBinaryKHR( exchange( rhs.m_pipelineBinaryKHR, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_constructorSuccessCode( exchange( rhs.m_constructorSuccessCode, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + PipelineBinaryKHR & operator=( PipelineBinaryKHR const & ) = delete; + + PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_pipelineBinaryKHR, rhs.m_pipelineBinaryKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_pipelineBinaryKHR; + } + + VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_pipelineBinaryKHR ); + } + + operator VULKAN_HPP_NAMESPACE::PipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineBinaryKHR; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_pipelineBinaryKHR ) + { + getDispatcher()->vkDestroyPipelineBinaryKHR( static_cast( m_device ), + static_cast( m_pipelineBinaryKHR ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_pipelineBinaryKHR = nullptr; + m_allocator = nullptr; + m_constructorSuccessCode = Result::eErrorUnknown; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::PipelineBinaryKHR release() + { + m_device = nullptr; + m_allocator = nullptr; + m_constructorSuccessCode = Result::eErrorUnknown; + m_dispatcher = nullptr; + return exchange( m_pipelineBinaryKHR, nullptr ); + } + + Result getConstructorSuccessCode() const + { + return m_constructorSuccessCode; + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( PipelineBinaryKHR & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_pipelineBinaryKHR, rhs.m_pipelineBinaryKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::PipelineBinaryKHR m_pipelineBinaryKHR = {}; + const AllocationCallbacks * m_allocator = {}; + Result m_constructorSuccessCode = Result::eErrorUnknown; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + class PipelineBinaryKHRs : public std::vector + { + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + PipelineBinaryKHRs( Device const & device, PipelineBinaryCreateInfoKHR const & createInfo, Optional allocator = nullptr ) + { + *this = device.createPipelineBinariesKHR( createInfo, allocator ); + } +# endif + + PipelineBinaryKHRs( std::nullptr_t ) {} + + PipelineBinaryKHRs() = delete; + PipelineBinaryKHRs( PipelineBinaryKHRs const & ) = delete; + PipelineBinaryKHRs( PipelineBinaryKHRs && rhs ) = default; + PipelineBinaryKHRs & operator=( PipelineBinaryKHRs const & ) = delete; + PipelineBinaryKHRs & operator=( PipelineBinaryKHRs && rhs ) = default; + + PipelineBinaryKHRs( std::vector && rhs ) + { + std::swap( *this, rhs ); + } + }; + + // wrapper class for handle VkPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayout.html + class PipelineLayout + { + public: + using CType = VkPipelineLayout; + using CppType = VULKAN_HPP_NAMESPACE::PipelineLayout; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineLayout; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + PipelineLayout( Device const & device, PipelineLayoutCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createPipelineLayout( createInfo, allocator ); + } +# endif + + PipelineLayout( Device const & device, VkPipelineLayout pipelineLayout, Optional allocator = nullptr ) + : m_device( device ) + , m_pipelineLayout( pipelineLayout ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + PipelineLayout( std::nullptr_t ) {} + + ~PipelineLayout() + { + clear(); + } + + PipelineLayout() = delete; + PipelineLayout( PipelineLayout const & ) = delete; + + PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_pipelineLayout( exchange( rhs.m_pipelineLayout, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + PipelineLayout & operator=( PipelineLayout const & ) = delete; + + PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_pipelineLayout, rhs.m_pipelineLayout ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::PipelineLayout const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_pipelineLayout; + } + + VULKAN_HPP_NAMESPACE::PipelineLayout const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_pipelineLayout ); + } + + operator VULKAN_HPP_NAMESPACE::PipelineLayout() const VULKAN_HPP_NOEXCEPT + { + return m_pipelineLayout; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_pipelineLayout ) + { + getDispatcher()->vkDestroyPipelineLayout( static_cast( m_device ), + static_cast( m_pipelineLayout ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_pipelineLayout = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::PipelineLayout release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_pipelineLayout, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( PipelineLayout & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_pipelineLayout, rhs.m_pipelineLayout ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::PipelineLayout m_pipelineLayout = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlot.html + class PrivateDataSlot + { + public: + using CType = VkPrivateDataSlot; + using CppType = VULKAN_HPP_NAMESPACE::PrivateDataSlot; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePrivateDataSlot; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + PrivateDataSlot( Device const & device, PrivateDataSlotCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createPrivateDataSlot( createInfo, allocator ); + } +# endif + + PrivateDataSlot( Device const & device, VkPrivateDataSlot privateDataSlot, Optional allocator = nullptr ) + : m_device( device ) + , m_privateDataSlot( privateDataSlot ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + PrivateDataSlot( std::nullptr_t ) {} + + ~PrivateDataSlot() + { + clear(); + } + + PrivateDataSlot() = delete; + PrivateDataSlot( PrivateDataSlot const & ) = delete; + + PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_privateDataSlot( exchange( rhs.m_privateDataSlot, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + PrivateDataSlot & operator=( PrivateDataSlot const & ) = delete; + + PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_privateDataSlot, rhs.m_privateDataSlot ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::PrivateDataSlot const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_privateDataSlot; + } + + VULKAN_HPP_NAMESPACE::PrivateDataSlot const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_privateDataSlot ); + } + + operator VULKAN_HPP_NAMESPACE::PrivateDataSlot() const VULKAN_HPP_NOEXCEPT + { + return m_privateDataSlot; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_privateDataSlot ) + { + getDispatcher()->vkDestroyPrivateDataSlot( static_cast( m_device ), + static_cast( m_privateDataSlot ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_privateDataSlot = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::PrivateDataSlot release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_privateDataSlot, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( PrivateDataSlot & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_privateDataSlot, rhs.m_privateDataSlot ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::PrivateDataSlot m_privateDataSlot = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPool.html + class QueryPool + { + public: + using CType = VkQueryPool; + using CppType = VULKAN_HPP_NAMESPACE::QueryPool; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueryPool; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + QueryPool( Device const & device, QueryPoolCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createQueryPool( createInfo, allocator ); + } +# endif + + QueryPool( Device const & device, VkQueryPool queryPool, Optional allocator = nullptr ) + : m_device( device ) + , m_queryPool( queryPool ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + QueryPool( std::nullptr_t ) {} + + ~QueryPool() + { + clear(); + } + + QueryPool() = delete; + QueryPool( QueryPool const & ) = delete; + + QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_queryPool( exchange( rhs.m_queryPool, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + QueryPool & operator=( QueryPool const & ) = delete; + + QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_queryPool, rhs.m_queryPool ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::QueryPool const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_queryPool; + } + + VULKAN_HPP_NAMESPACE::QueryPool const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_queryPool ); + } + + operator VULKAN_HPP_NAMESPACE::QueryPool() const VULKAN_HPP_NOEXCEPT + { + return m_queryPool; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_queryPool ) + { + getDispatcher()->vkDestroyQueryPool( + static_cast( m_device ), static_cast( m_queryPool ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_queryPool = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::QueryPool release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_queryPool, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( QueryPool & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_queryPool, rhs.m_queryPool ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html + template + VULKAN_HPP_NODISCARD ResultValue> getResults( + uint32_t firstQuery, uint32_t queryCount, size_t dataSize, DeviceSize stride, QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html + template + VULKAN_HPP_NODISCARD ResultValue + getResult( uint32_t firstQuery, uint32_t queryCount, DeviceSize stride, QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + //=== VK_VERSION_1_2 === + + // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html + void reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_EXT_host_query_reset === + + // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html + void resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::QueryPool m_queryPool = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueue.html + class Queue + { + public: + using CType = VkQueue; + using CppType = VULKAN_HPP_NAMESPACE::Queue; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueue; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Queue( Device const & device, uint32_t queueFamilyIndex, uint32_t queueIndex ) + { + *this = device.getQueue( queueFamilyIndex, queueIndex ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Queue( Device const & device, DeviceQueueInfo2 const & queueInfo ) + { + *this = device.getQueue2( queueInfo ); + } +# endif + + Queue( Device const & device, VkQueue queue ) : m_queue( queue ), m_dispatcher( device.getDispatcher() ) {} + + Queue( std::nullptr_t ) {} + + ~Queue() + { + clear(); + } + + Queue() = delete; + + Queue( Queue const & rhs ) : m_queue( rhs.m_queue ), m_dispatcher( rhs.m_dispatcher ) {} + + Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT + : m_queue( exchange( rhs.m_queue, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + Queue & operator=( Queue const & rhs ) + { + m_queue = rhs.m_queue; + m_dispatcher = rhs.m_dispatcher; + return *this; + } + + Queue & operator=( Queue && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_queue, rhs.m_queue ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::Queue const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_queue; + } + + VULKAN_HPP_NAMESPACE::Queue const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_queue ); + } + + operator VULKAN_HPP_NAMESPACE::Queue() const VULKAN_HPP_NOEXCEPT + { + return m_queue; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + m_queue = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::Queue release() + { + m_dispatcher = nullptr; + return exchange( m_queue, nullptr ); + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( Queue & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_queue, rhs.m_queue ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html + typename ResultValueType::type submit( ArrayProxy const & submits, + VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html + typename ResultValueType::type waitIdle() const; + + // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html + typename ResultValueType::type bindSparse( ArrayProxy const & bindInfo, + VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + //=== VK_VERSION_1_3 === + + // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html + typename ResultValueType::type submit2( ArrayProxy const & submits, + VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + //=== VK_KHR_swapchain === + + // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html + VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR & presentInfo ) const; + + //=== VK_EXT_debug_utils === + + // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html + void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html + void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html + void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_NV_device_diagnostic_checkpoints === + + // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html + VULKAN_HPP_NODISCARD std::vector getCheckpointDataNV() const; + + // wrapper function for command vkGetQueueCheckpointData2NV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html + VULKAN_HPP_NODISCARD std::vector getCheckpointData2NV() const; + + //=== VK_INTEL_performance_query === + + // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html + typename ResultValueType::type setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const; + + //=== VK_KHR_synchronization2 === + + // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html + typename ResultValueType::type submit2KHR( ArrayProxy const & submits, + VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + //=== VK_NV_low_latency2 === + + // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html + void notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo ) const VULKAN_HPP_NOEXCEPT; + + private: + VULKAN_HPP_NAMESPACE::Queue m_queue = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPass.html + class RenderPass + { + public: + using CType = VkRenderPass; + using CppType = VULKAN_HPP_NAMESPACE::RenderPass; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eRenderPass; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + RenderPass( Device const & device, RenderPassCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createRenderPass( createInfo, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + RenderPass( Device const & device, RenderPassCreateInfo2 const & createInfo, Optional allocator = nullptr ) + { + *this = device.createRenderPass2( createInfo, allocator ); + } +# endif + + RenderPass( Device const & device, VkRenderPass renderPass, Optional allocator = nullptr ) + : m_device( device ) + , m_renderPass( renderPass ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + RenderPass( std::nullptr_t ) {} + + ~RenderPass() + { + clear(); + } + + RenderPass() = delete; + RenderPass( RenderPass const & ) = delete; + + RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_renderPass( exchange( rhs.m_renderPass, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + RenderPass & operator=( RenderPass const & ) = delete; + + RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_renderPass, rhs.m_renderPass ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::RenderPass const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_renderPass; + } + + VULKAN_HPP_NAMESPACE::RenderPass const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_renderPass ); + } + + operator VULKAN_HPP_NAMESPACE::RenderPass() const VULKAN_HPP_NOEXCEPT + { + return m_renderPass; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_renderPass ) + { + getDispatcher()->vkDestroyRenderPass( + static_cast( m_device ), static_cast( m_renderPass ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_renderPass = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::RenderPass release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_renderPass, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( RenderPass & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_renderPass, rhs.m_renderPass ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html + VULKAN_HPP_NODISCARD Extent2D getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT; + + //=== VK_HUAWEI_subpass_shading === + + // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getSubpassShadingMaxWorkgroupSizeHUAWEI() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::RenderPass m_renderPass = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampler.html + class Sampler + { + public: + using CType = VkSampler; + using CppType = VULKAN_HPP_NAMESPACE::Sampler; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSampler; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Sampler( Device const & device, SamplerCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createSampler( createInfo, allocator ); + } +# endif + + Sampler( Device const & device, VkSampler sampler, Optional allocator = nullptr ) + : m_device( device ), m_sampler( sampler ), m_allocator( static_cast( allocator ) ), m_dispatcher( device.getDispatcher() ) + { + } + + Sampler( std::nullptr_t ) {} + + ~Sampler() + { + clear(); + } + + Sampler() = delete; + Sampler( Sampler const & ) = delete; + + Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_sampler( exchange( rhs.m_sampler, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + Sampler & operator=( Sampler const & ) = delete; + + Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_sampler, rhs.m_sampler ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::Sampler const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_sampler; + } + + VULKAN_HPP_NAMESPACE::Sampler const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_sampler ); + } + + operator VULKAN_HPP_NAMESPACE::Sampler() const VULKAN_HPP_NOEXCEPT + { + return m_sampler; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_sampler ) + { + getDispatcher()->vkDestroySampler( + static_cast( m_device ), static_cast( m_sampler ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_sampler = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::Sampler release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_sampler, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( Sampler & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_sampler, rhs.m_sampler ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Sampler m_sampler = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkSamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversion.html + class SamplerYcbcrConversion + { + public: + using CType = VkSamplerYcbcrConversion; + using CppType = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSamplerYcbcrConversion; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + SamplerYcbcrConversion( Device const & device, + SamplerYcbcrConversionCreateInfo const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createSamplerYcbcrConversion( createInfo, allocator ); + } +# endif + + SamplerYcbcrConversion( Device const & device, VkSamplerYcbcrConversion ycbcrConversion, Optional allocator = nullptr ) + : m_device( device ) + , m_samplerYcbcrConversion( ycbcrConversion ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + SamplerYcbcrConversion( std::nullptr_t ) {} + + ~SamplerYcbcrConversion() + { + clear(); + } + + SamplerYcbcrConversion() = delete; + SamplerYcbcrConversion( SamplerYcbcrConversion const & ) = delete; + + SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_samplerYcbcrConversion( exchange( rhs.m_samplerYcbcrConversion, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & ) = delete; + + SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_samplerYcbcrConversion, rhs.m_samplerYcbcrConversion ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_samplerYcbcrConversion; + } + + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_samplerYcbcrConversion ); + } + + operator VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT + { + return m_samplerYcbcrConversion; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_samplerYcbcrConversion ) + { + getDispatcher()->vkDestroySamplerYcbcrConversion( static_cast( m_device ), + static_cast( m_samplerYcbcrConversion ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_samplerYcbcrConversion = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_samplerYcbcrConversion, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( SamplerYcbcrConversion & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_samplerYcbcrConversion, rhs.m_samplerYcbcrConversion ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_samplerYcbcrConversion = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphore.html + class Semaphore + { + public: + using CType = VkSemaphore; + using CppType = VULKAN_HPP_NAMESPACE::Semaphore; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSemaphore; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + Semaphore( Device const & device, SemaphoreCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createSemaphore( createInfo, allocator ); + } +# endif + + Semaphore( Device const & device, VkSemaphore semaphore, Optional allocator = nullptr ) + : m_device( device ) + , m_semaphore( semaphore ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + Semaphore( std::nullptr_t ) {} + + ~Semaphore() + { + clear(); + } + + Semaphore() = delete; + Semaphore( Semaphore const & ) = delete; + + Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_semaphore( exchange( rhs.m_semaphore, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + Semaphore & operator=( Semaphore const & ) = delete; + + Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_semaphore, rhs.m_semaphore ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::Semaphore const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_semaphore; + } + + VULKAN_HPP_NAMESPACE::Semaphore const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_semaphore ); + } + + operator VULKAN_HPP_NAMESPACE::Semaphore() const VULKAN_HPP_NOEXCEPT + { + return m_semaphore; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_semaphore ) + { + getDispatcher()->vkDestroySemaphore( + static_cast( m_device ), static_cast( m_semaphore ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_semaphore = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::Semaphore release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_semaphore, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( Semaphore & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_semaphore, rhs.m_semaphore ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_VERSION_1_2 === + + // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getCounterValue() const; + + //=== VK_KHR_timeline_semaphore === + + // wrapper function for command vkGetSemaphoreCounterValueKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getCounterValueKHR() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::Semaphore m_semaphore = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderEXT.html + class ShaderEXT + { + public: + using CType = VkShaderEXT; + using CppType = VULKAN_HPP_NAMESPACE::ShaderEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + ShaderEXT( Device const & device, ShaderCreateInfoEXT const & createInfo, Optional allocator = nullptr ) + { + *this = device.createShaderEXT( createInfo, allocator ); + } +# endif + + ShaderEXT( Device const & device, VkShaderEXT shader, Optional allocator = nullptr, Result successCode = Result::eSuccess ) + : m_device( device ) + , m_shaderEXT( shader ) + , m_allocator( static_cast( allocator ) ) + , m_constructorSuccessCode( successCode ) + , m_dispatcher( device.getDispatcher() ) + { + } + + ShaderEXT( std::nullptr_t ) {} + + ~ShaderEXT() + { + clear(); + } + + ShaderEXT() = delete; + ShaderEXT( ShaderEXT const & ) = delete; + + ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_shaderEXT( exchange( rhs.m_shaderEXT, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_constructorSuccessCode( exchange( rhs.m_constructorSuccessCode, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + ShaderEXT & operator=( ShaderEXT const & ) = delete; + + ShaderEXT & operator=( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_shaderEXT, rhs.m_shaderEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::ShaderEXT const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_shaderEXT; + } + + VULKAN_HPP_NAMESPACE::ShaderEXT const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_shaderEXT ); + } + + operator VULKAN_HPP_NAMESPACE::ShaderEXT() const VULKAN_HPP_NOEXCEPT + { + return m_shaderEXT; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_shaderEXT ) + { + getDispatcher()->vkDestroyShaderEXT( + static_cast( m_device ), static_cast( m_shaderEXT ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_shaderEXT = nullptr; + m_allocator = nullptr; + m_constructorSuccessCode = Result::eErrorUnknown; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::ShaderEXT release() + { + m_device = nullptr; + m_allocator = nullptr; + m_constructorSuccessCode = Result::eErrorUnknown; + m_dispatcher = nullptr; + return exchange( m_shaderEXT, nullptr ); + } + + Result getConstructorSuccessCode() const + { + return m_constructorSuccessCode; + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( ShaderEXT & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_shaderEXT, rhs.m_shaderEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_EXT_shader_object === + + // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getBinaryData() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ShaderEXT m_shaderEXT = {}; + const AllocationCallbacks * m_allocator = {}; + Result m_constructorSuccessCode = Result::eErrorUnknown; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + class ShaderEXTs : public std::vector + { + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + ShaderEXTs( Device const & device, ArrayProxy const & createInfos, Optional allocator = nullptr ) + { + *this = device.createShadersEXT( createInfos, allocator ); + } +# endif + + ShaderEXTs( std::nullptr_t ) {} + + ShaderEXTs() = delete; + ShaderEXTs( ShaderEXTs const & ) = delete; + ShaderEXTs( ShaderEXTs && rhs ) = default; + ShaderEXTs & operator=( ShaderEXTs const & ) = delete; + ShaderEXTs & operator=( ShaderEXTs && rhs ) = default; + + ShaderEXTs( std::vector && rhs ) + { + std::swap( *this, rhs ); + } + }; + + // wrapper class for handle VkShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModule.html + class ShaderModule + { + public: + using CType = VkShaderModule; + using CppType = VULKAN_HPP_NAMESPACE::ShaderModule; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eShaderModule; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + ShaderModule( Device const & device, ShaderModuleCreateInfo const & createInfo, Optional allocator = nullptr ) + { + *this = device.createShaderModule( createInfo, allocator ); + } +# endif + + ShaderModule( Device const & device, VkShaderModule shaderModule, Optional allocator = nullptr ) + : m_device( device ) + , m_shaderModule( shaderModule ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + ShaderModule( std::nullptr_t ) {} + + ~ShaderModule() + { + clear(); + } + + ShaderModule() = delete; + ShaderModule( ShaderModule const & ) = delete; + + ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_shaderModule( exchange( rhs.m_shaderModule, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + ShaderModule & operator=( ShaderModule const & ) = delete; + + ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_shaderModule, rhs.m_shaderModule ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::ShaderModule const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_shaderModule; + } + + VULKAN_HPP_NAMESPACE::ShaderModule const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_shaderModule ); + } + + operator VULKAN_HPP_NAMESPACE::ShaderModule() const VULKAN_HPP_NOEXCEPT + { + return m_shaderModule; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_shaderModule ) + { + getDispatcher()->vkDestroyShaderModule( + static_cast( m_device ), static_cast( m_shaderModule ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_shaderModule = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::ShaderModule release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_shaderModule, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( ShaderModule & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_shaderModule, rhs.m_shaderModule ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_EXT_shader_module_identifier === + + // wrapper function for command vkGetShaderModuleIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html + VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT getIdentifierEXT() const VULKAN_HPP_NOEXCEPT; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ShaderModule m_shaderModule = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceKHR.html + class SurfaceKHR + { + public: + using CType = VkSurfaceKHR; + using CppType = VULKAN_HPP_NAMESPACE::SurfaceKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSurfaceKHR; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + SurfaceKHR( Instance const & instance, AndroidSurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createAndroidSurfaceKHR( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + SurfaceKHR( Instance const & instance, DirectFBSurfaceCreateInfoEXT const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createDirectFBSurfaceEXT( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + SurfaceKHR( Instance const & instance, DisplaySurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createDisplayPlaneSurfaceKHR( createInfo, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + SurfaceKHR( Instance const & instance, HeadlessSurfaceCreateInfoEXT const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createHeadlessSurfaceEXT( createInfo, allocator ); + } +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_IOS_MVK ) + SurfaceKHR( Instance const & instance, IOSSurfaceCreateInfoMVK const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createIOSSurfaceMVK( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_IOS_MVK*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_FUCHSIA ) + SurfaceKHR( Instance const & instance, ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createImagePipeSurfaceFUCHSIA( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_FUCHSIA*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_MACOS_MVK ) + SurfaceKHR( Instance const & instance, MacOSSurfaceCreateInfoMVK const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createMacOSSurfaceMVK( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_MACOS_MVK*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_METAL_EXT ) + SurfaceKHR( Instance const & instance, MetalSurfaceCreateInfoEXT const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createMetalSurfaceEXT( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_METAL_EXT*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + SurfaceKHR( Instance const & instance, ScreenSurfaceCreateInfoQNX const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createScreenSurfaceQNX( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_GGP ) + SurfaceKHR( Instance const & instance, StreamDescriptorSurfaceCreateInfoGGP const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createStreamDescriptorSurfaceGGP( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_GGP*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_OHOS ) + SurfaceKHR( Instance const & instance, SurfaceCreateInfoOHOS const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createSurfaceOHOS( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_OHOS*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_VI_NN ) + SurfaceKHR( Instance const & instance, ViSurfaceCreateInfoNN const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createViSurfaceNN( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_VI_NN*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + SurfaceKHR( Instance const & instance, WaylandSurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createWaylandSurfaceKHR( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + SurfaceKHR( Instance const & instance, Win32SurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createWin32SurfaceKHR( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_XCB_KHR ) + SurfaceKHR( Instance const & instance, XcbSurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createXcbSurfaceKHR( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_XCB_KHR*/ +# endif + +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) +# if defined( VK_USE_PLATFORM_XLIB_KHR ) + SurfaceKHR( Instance const & instance, XlibSurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) + { + *this = instance.createXlibSurfaceKHR( createInfo, allocator ); + } +# endif /*VK_USE_PLATFORM_XLIB_KHR*/ +# endif + + SurfaceKHR( Instance const & instance, VkSurfaceKHR surface, Optional allocator = nullptr ) + : m_instance( instance ) + , m_surfaceKHR( surface ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( instance.getDispatcher() ) + { + } + + SurfaceKHR( std::nullptr_t ) {} + + ~SurfaceKHR() + { + clear(); + } + + SurfaceKHR() = delete; + SurfaceKHR( SurfaceKHR const & ) = delete; + + SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT + : m_instance( exchange( rhs.m_instance, {} ) ) + , m_surfaceKHR( exchange( rhs.m_surfaceKHR, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + SurfaceKHR & operator=( SurfaceKHR const & ) = delete; + + SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_instance, rhs.m_instance ); + std::swap( m_surfaceKHR, rhs.m_surfaceKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::SurfaceKHR const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_surfaceKHR; + } + + VULKAN_HPP_NAMESPACE::SurfaceKHR const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_surfaceKHR ); + } + + operator VULKAN_HPP_NAMESPACE::SurfaceKHR() const VULKAN_HPP_NOEXCEPT + { + return m_surfaceKHR; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_surfaceKHR ) + { + getDispatcher()->vkDestroySurfaceKHR( + static_cast( m_instance ), static_cast( m_surfaceKHR ), reinterpret_cast( m_allocator ) ); + } + m_instance = nullptr; + m_surfaceKHR = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::SurfaceKHR release() + { + m_instance = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_surfaceKHR, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Instance getInstance() const + { + return m_instance; + } + + detail::InstanceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( SurfaceKHR & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_instance, rhs.m_instance ); + std::swap( m_surfaceKHR, rhs.m_surfaceKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Instance m_instance = {}; + VULKAN_HPP_NAMESPACE::SurfaceKHR m_surfaceKHR = {}; + const AllocationCallbacks * m_allocator = {}; + detail::InstanceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainKHR.html + class SwapchainKHR + { + public: + using CType = VkSwapchainKHR; + using CppType = VULKAN_HPP_NAMESPACE::SwapchainKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSwapchainKHR; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + SwapchainKHR( Device const & device, SwapchainCreateInfoKHR const & createInfo, Optional allocator = nullptr ) + { + *this = device.createSwapchainKHR( createInfo, allocator ); + } +# endif + + SwapchainKHR( Device const & device, VkSwapchainKHR swapchain, Optional allocator = nullptr ) + : m_device( device ) + , m_swapchainKHR( swapchain ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + SwapchainKHR( std::nullptr_t ) {} + + ~SwapchainKHR() + { + clear(); + } + + SwapchainKHR() = delete; + SwapchainKHR( SwapchainKHR const & ) = delete; + + SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_swapchainKHR( exchange( rhs.m_swapchainKHR, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + SwapchainKHR & operator=( SwapchainKHR const & ) = delete; + + SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_swapchainKHR, rhs.m_swapchainKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::SwapchainKHR const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_swapchainKHR; + } + + VULKAN_HPP_NAMESPACE::SwapchainKHR const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_swapchainKHR ); + } + + operator VULKAN_HPP_NAMESPACE::SwapchainKHR() const VULKAN_HPP_NOEXCEPT + { + return m_swapchainKHR; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_swapchainKHR ) + { + getDispatcher()->vkDestroySwapchainKHR( + static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_swapchainKHR = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::SwapchainKHR release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_swapchainKHR, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( SwapchainKHR & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_swapchainKHR, rhs.m_swapchainKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_KHR_swapchain === + + // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getImages() const; + + // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html + VULKAN_HPP_NODISCARD ResultValue acquireNextImage( uint64_t timeout, + VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), + VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; + + //=== VK_EXT_display_control === + + // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html + VULKAN_HPP_NODISCARD +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + ResultValue +# else + typename ResultValueType::type +# endif + getCounterEXT( SurfaceCounterFlagBitsEXT counter ) const; + + //=== VK_GOOGLE_display_timing === + + // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html + VULKAN_HPP_NODISCARD typename ResultValueType::type getRefreshCycleDurationGOOGLE() const; + + // wrapper function for command vkGetPastPresentationTimingGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html + VULKAN_HPP_NODISCARD +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + ResultValue> +# else + typename ResultValueType>::type +# endif + getPastPresentationTimingGOOGLE() const; + + //=== VK_KHR_shared_presentable_image === + + // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html + VULKAN_HPP_NODISCARD Result getStatus() const; + + //=== VK_EXT_present_timing === + + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + VULKAN_HPP_NODISCARD Result setPresentTimingQueueSizeEXT( uint32_t size ) const; + + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + VULKAN_HPP_NODISCARD ResultValue> getTimingPropertiesEXT() const; + + // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html + VULKAN_HPP_NODISCARD Result getTimeDomainPropertiesEXT( SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, + uint64_t * pTimeDomainsCounter ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_AMD_display_native_hdr === + + // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html + void setLocalDimmingAMD( Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT; + + //=== VK_KHR_present_wait === + + // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html + VULKAN_HPP_NODISCARD Result waitForPresent( uint64_t presentId, uint64_t timeout ) const; + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + + // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html + typename ResultValueType::type acquireFullScreenExclusiveModeEXT() const; + + // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html + typename ResultValueType::type releaseFullScreenExclusiveModeEXT() const; +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_present_wait2 === + + // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html + VULKAN_HPP_NODISCARD Result waitForPresent2( const PresentWait2InfoKHR & presentWait2Info ) const; + + //=== VK_NV_low_latency2 === + + // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html + typename ResultValueType::type setLatencySleepModeNV( const LatencySleepModeInfoNV & sleepModeInfo ) const; + + // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html + typename ResultValueType::type latencySleepNV( const LatencySleepInfoNV & sleepInfo ) const; + + // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html + void setLatencyMarkerNV( const SetLatencyMarkerInfoNV & latencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html + VULKAN_HPP_NODISCARD std::vector getLatencyTimingsNV() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchainKHR = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + class SwapchainKHRs : public std::vector + { + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + SwapchainKHRs( Device const & device, ArrayProxy const & createInfos, Optional allocator = nullptr ) + { + *this = device.createSharedSwapchainsKHR( createInfos, allocator ); + } +# endif + + SwapchainKHRs( std::nullptr_t ) {} + + SwapchainKHRs() = delete; + SwapchainKHRs( SwapchainKHRs const & ) = delete; + SwapchainKHRs( SwapchainKHRs && rhs ) = default; + SwapchainKHRs & operator=( SwapchainKHRs const & ) = delete; + SwapchainKHRs & operator=( SwapchainKHRs && rhs ) = default; + + SwapchainKHRs( std::vector && rhs ) + { + std::swap( *this, rhs ); + } + }; + + // wrapper class for handle VkTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorARM.html + class TensorARM + { + public: + using CType = VkTensorARM; + using CppType = VULKAN_HPP_NAMESPACE::TensorARM; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + TensorARM( Device const & device, TensorCreateInfoARM const & createInfo, Optional allocator = nullptr ) + { + *this = device.createTensorARM( createInfo, allocator ); + } +# endif + + TensorARM( Device const & device, VkTensorARM tensor, Optional allocator = nullptr ) + : m_device( device ) + , m_tensorARM( tensor ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + TensorARM( std::nullptr_t ) {} + + ~TensorARM() + { + clear(); + } + + TensorARM() = delete; + TensorARM( TensorARM const & ) = delete; + + TensorARM( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_tensorARM( exchange( rhs.m_tensorARM, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + TensorARM & operator=( TensorARM const & ) = delete; + + TensorARM & operator=( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_tensorARM, rhs.m_tensorARM ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::TensorARM const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_tensorARM; + } + + VULKAN_HPP_NAMESPACE::TensorARM const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_tensorARM ); + } + + operator VULKAN_HPP_NAMESPACE::TensorARM() const VULKAN_HPP_NOEXCEPT + { + return m_tensorARM; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_tensorARM ) + { + getDispatcher()->vkDestroyTensorARM( + static_cast( m_device ), static_cast( m_tensorARM ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_tensorARM = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::TensorARM release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_tensorARM, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( TensorARM & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_tensorARM, rhs.m_tensorARM ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::TensorARM m_tensorARM = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewARM.html + class TensorViewARM + { + public: + using CType = VkTensorViewARM; + using CppType = VULKAN_HPP_NAMESPACE::TensorViewARM; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorViewARM; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + TensorViewARM( Device const & device, TensorViewCreateInfoARM const & createInfo, Optional allocator = nullptr ) + { + *this = device.createTensorViewARM( createInfo, allocator ); + } +# endif + + TensorViewARM( Device const & device, VkTensorViewARM tensorView, Optional allocator = nullptr ) + : m_device( device ) + , m_tensorViewARM( tensorView ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + TensorViewARM( std::nullptr_t ) {} + + ~TensorViewARM() + { + clear(); + } + + TensorViewARM() = delete; + TensorViewARM( TensorViewARM const & ) = delete; + + TensorViewARM( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_tensorViewARM( exchange( rhs.m_tensorViewARM, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + TensorViewARM & operator=( TensorViewARM const & ) = delete; + + TensorViewARM & operator=( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_tensorViewARM, rhs.m_tensorViewARM ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::TensorViewARM const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_tensorViewARM; + } + + VULKAN_HPP_NAMESPACE::TensorViewARM const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_tensorViewARM ); + } + + operator VULKAN_HPP_NAMESPACE::TensorViewARM() const VULKAN_HPP_NOEXCEPT + { + return m_tensorViewARM; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_tensorViewARM ) + { + getDispatcher()->vkDestroyTensorViewARM( static_cast( m_device ), + static_cast( m_tensorViewARM ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_tensorViewARM = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::TensorViewARM release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_tensorViewARM, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( TensorViewARM & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_tensorViewARM, rhs.m_tensorViewARM ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::TensorViewARM m_tensorViewARM = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheEXT.html + class ValidationCacheEXT + { + public: + using CType = VkValidationCacheEXT; + using CppType = VULKAN_HPP_NAMESPACE::ValidationCacheEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eValidationCacheEXT; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + ValidationCacheEXT( Device const & device, ValidationCacheCreateInfoEXT const & createInfo, Optional allocator = nullptr ) + { + *this = device.createValidationCacheEXT( createInfo, allocator ); + } +# endif + + ValidationCacheEXT( Device const & device, VkValidationCacheEXT validationCache, Optional allocator = nullptr ) + : m_device( device ) + , m_validationCacheEXT( validationCache ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + ValidationCacheEXT( std::nullptr_t ) {} + + ~ValidationCacheEXT() + { + clear(); + } + + ValidationCacheEXT() = delete; + ValidationCacheEXT( ValidationCacheEXT const & ) = delete; + + ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_validationCacheEXT( exchange( rhs.m_validationCacheEXT, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + ValidationCacheEXT & operator=( ValidationCacheEXT const & ) = delete; + + ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_validationCacheEXT, rhs.m_validationCacheEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_validationCacheEXT; + } + + VULKAN_HPP_NAMESPACE::ValidationCacheEXT const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_validationCacheEXT ); + } + + operator VULKAN_HPP_NAMESPACE::ValidationCacheEXT() const VULKAN_HPP_NOEXCEPT + { + return m_validationCacheEXT; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_validationCacheEXT ) + { + getDispatcher()->vkDestroyValidationCacheEXT( static_cast( m_device ), + static_cast( m_validationCacheEXT ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_validationCacheEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::ValidationCacheEXT release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_validationCacheEXT, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( ValidationCacheEXT & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_validationCacheEXT, rhs.m_validationCacheEXT ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_EXT_validation_cache === + + // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html + typename ResultValueType::type merge( ArrayProxy const & srcCaches ) const; + + // wrapper function for command vkGetValidationCacheDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getData() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCacheEXT = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionKHR.html + class VideoSessionKHR + { + public: + using CType = VkVideoSessionKHR; + using CppType = VULKAN_HPP_NAMESPACE::VideoSessionKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + VideoSessionKHR( Device const & device, VideoSessionCreateInfoKHR const & createInfo, Optional allocator = nullptr ) + { + *this = device.createVideoSessionKHR( createInfo, allocator ); + } +# endif + + VideoSessionKHR( Device const & device, VkVideoSessionKHR videoSession, Optional allocator = nullptr ) + : m_device( device ) + , m_videoSessionKHR( videoSession ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + VideoSessionKHR( std::nullptr_t ) {} + + ~VideoSessionKHR() + { + clear(); + } + + VideoSessionKHR() = delete; + VideoSessionKHR( VideoSessionKHR const & ) = delete; + + VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_videoSessionKHR( exchange( rhs.m_videoSessionKHR, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + VideoSessionKHR & operator=( VideoSessionKHR const & ) = delete; + + VideoSessionKHR & operator=( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_videoSessionKHR, rhs.m_videoSessionKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::VideoSessionKHR const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_videoSessionKHR; + } + + VULKAN_HPP_NAMESPACE::VideoSessionKHR const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_videoSessionKHR ); + } + + operator VULKAN_HPP_NAMESPACE::VideoSessionKHR() const VULKAN_HPP_NOEXCEPT + { + return m_videoSessionKHR; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_videoSessionKHR ) + { + getDispatcher()->vkDestroyVideoSessionKHR( static_cast( m_device ), + static_cast( m_videoSessionKHR ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_videoSessionKHR = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::VideoSessionKHR release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_videoSessionKHR, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( VideoSessionKHR & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_videoSessionKHR, rhs.m_videoSessionKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_KHR_video_queue === + + // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html + VULKAN_HPP_NODISCARD typename ResultValueType>::type getMemoryRequirements() const; + + // wrapper function for command vkBindVideoSessionMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html + typename ResultValueType::type bindMemory( ArrayProxy const & bindSessionMemoryInfos ) const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSessionKHR = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // wrapper class for handle VkVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersKHR.html + class VideoSessionParametersKHR + { + public: + using CType = VkVideoSessionParametersKHR; + using CppType = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR; + + static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionParametersKHR; + static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) + VideoSessionParametersKHR( Device const & device, + VideoSessionParametersCreateInfoKHR const & createInfo, + Optional allocator = nullptr ) + { + *this = device.createVideoSessionParametersKHR( createInfo, allocator ); + } +# endif + + VideoSessionParametersKHR( Device const & device, + VkVideoSessionParametersKHR videoSessionParameters, + Optional allocator = nullptr ) + : m_device( device ) + , m_videoSessionParametersKHR( videoSessionParameters ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + VideoSessionParametersKHR( std::nullptr_t ) {} + + ~VideoSessionParametersKHR() + { + clear(); + } + + VideoSessionParametersKHR() = delete; + VideoSessionParametersKHR( VideoSessionParametersKHR const & ) = delete; + + VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( exchange( rhs.m_device, {} ) ) + , m_videoSessionParametersKHR( exchange( rhs.m_videoSessionParametersKHR, {} ) ) + , m_allocator( exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & ) = delete; + + VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_videoSessionParametersKHR, rhs.m_videoSessionParametersKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & operator*() const & VULKAN_HPP_NOEXCEPT + { + return m_videoSessionParametersKHR; + } + + VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const && operator*() const && VULKAN_HPP_NOEXCEPT + { + return std::move( m_videoSessionParametersKHR ); + } + + operator VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT + { + return m_videoSessionParametersKHR; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_videoSessionParametersKHR ) + { + getDispatcher()->vkDestroyVideoSessionParametersKHR( static_cast( m_device ), + static_cast( m_videoSessionParametersKHR ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_videoSessionParametersKHR = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return exchange( m_videoSessionParametersKHR, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( VideoSessionParametersKHR & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_videoSessionParametersKHR, rhs.m_videoSessionParametersKHR ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_KHR_video_queue === + + // wrapper function for command vkUpdateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html + typename ResultValueType::type update( const VideoSessionParametersUpdateInfoKHR & updateInfo ) const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParametersKHR = {}; + const AllocationCallbacks * m_allocator = {}; + detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + + // operators to compare VULKAN_HPP_NAMESPACE::raii-handles +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + template ::value, bool>::type = 0> + auto operator<=>( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT + { + return *a <=> *b; + } +# else + template ::value, bool>::type = 0> + bool operator<( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT + { + return *a < *b; + } +# endif + + template ::value, bool>::type = 0> + bool operator==( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT + { + return *a == *b; + } + + template ::value, bool>::type = 0> + bool operator!=( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT + { + return *a != *b; + } + + template ::value, bool>::type = 0> + bool operator==( const T & v, std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + return !*v; + } + + template ::value, bool>::type = 0> + bool operator==( std::nullptr_t, const T & v ) VULKAN_HPP_NOEXCEPT + { + return !*v; + } + + template ::value, bool>::type = 0> + bool operator!=( const T & v, std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + return *v; + } + + template ::value, bool>::type = 0> + bool operator!=( std::nullptr_t, const T & v ) VULKAN_HPP_NOEXCEPT + { + return *v; + } + + //=========================== + //=== COMMAND Definitions === + //=========================== + + //=== VK_VERSION_1_0 === + + // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Context::createInstance( InstanceCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateInstance && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Instance instance; + Result result = static_cast( getDispatcher()->vkCreateInstance( reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &instance ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Context::createInstance" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Instance( *this, *reinterpret_cast( &instance ), allocator ) ); + } + + // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDevices() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDevices && "Function requires " ); + + std::vector physicalDevices; + uint32_t physicalDeviceCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkEnumeratePhysicalDevices( static_cast( m_instance ), &physicalDeviceCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceCount ) + { + physicalDevices.resize( physicalDeviceCount ); + result = static_cast( getDispatcher()->vkEnumeratePhysicalDevices( + static_cast( m_instance ), &physicalDeviceCount, reinterpret_cast( physicalDevices.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" ); + std::vector physicalDevicesRAII; + if ( result == Result::eSuccess ) + { + physicalDevicesRAII.reserve( physicalDevices.size() ); + for ( auto & physicalDevice : physicalDevices ) + { + physicalDevicesRAII.emplace_back( *this, *reinterpret_cast( &physicalDevice ) ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDevicesRAII ) ); + } + + // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures && "Function requires " ); + + PhysicalDeviceFeatures features; + getDispatcher()->vkGetPhysicalDeviceFeatures( static_cast( m_physicalDevice ), + reinterpret_cast( &features ) ); + + return features; + } + + // wrapper function for command vkGetPhysicalDeviceFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties && "Function requires " ); + + FormatProperties formatProperties; + getDispatcher()->vkGetPhysicalDeviceFormatProperties( + static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); + + return formatProperties; + } + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties && + "Function requires " ); + + ImageFormatProperties imageFormatProperties; + Result result = static_cast( + getDispatcher()->vkGetPhysicalDeviceImageFormatProperties( static_cast( m_physicalDevice ), + static_cast( format ), + static_cast( type ), + static_cast( tiling ), + static_cast( usage ), + static_cast( flags ), + reinterpret_cast( &imageFormatProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties && "Function requires " ); + + PhysicalDeviceProperties properties; + getDispatcher()->vkGetPhysicalDeviceProperties( static_cast( m_physicalDevice ), + reinterpret_cast( &properties ) ); + + return properties; + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties && + "Function requires " ); + + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast( m_physicalDevice ), + &queueFamilyPropertyCount, + reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + queueFamilyProperties.resize( queueFamilyPropertyCount ); + } + return queueFamilyProperties; + } + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties && "Function requires " ); + + PhysicalDeviceMemoryProperties memoryProperties; + getDispatcher()->vkGetPhysicalDeviceMemoryProperties( static_cast( m_physicalDevice ), + reinterpret_cast( &memoryProperties ) ); + + return memoryProperties; + } + + // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_VoidFunction Instance::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetInstanceProcAddr && "Function requires " ); + + PFN_vkVoidFunction result = getDispatcher()->vkGetInstanceProcAddr( static_cast( m_instance ), name.c_str() ); + + return result; + } + + // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_VoidFunction Device::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceProcAddr && "Function requires " ); + + PFN_vkVoidFunction result = getDispatcher()->vkGetDeviceProcAddr( static_cast( m_device ), name.c_str() ); + + return result; + } + + // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::createDevice( DeviceCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDevice && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Device device; + Result result = static_cast( getDispatcher()->vkCreateDevice( static_cast( m_physicalDevice ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &device ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::createDevice" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Device( *this, *reinterpret_cast( &device ), allocator ) ); + } + + // wrapper function for command vkEnumerateInstanceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Context::enumerateInstanceExtensionProperties( Optional layerName ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateInstanceExtensionProperties && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = + static_cast( getDispatcher()->vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkEnumerateInstanceExtensionProperties( + layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Context::enumerateInstanceExtensionProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkEnumerateDeviceExtensionProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateDeviceExtensionProperties && "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkEnumerateDeviceExtensionProperties( + static_cast( m_physicalDevice ), layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = + static_cast( getDispatcher()->vkEnumerateDeviceExtensionProperties( static_cast( m_physicalDevice ), + layerName ? layerName->c_str() : nullptr, + &propertyCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkEnumerateInstanceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Context::enumerateInstanceLayerProperties() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateInstanceLayerProperties && "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( + getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Context::enumerateInstanceLayerProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkEnumerateDeviceLayerProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceLayerProperties() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateDeviceLayerProperties && "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkEnumerateDeviceLayerProperties( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkEnumerateDeviceLayerProperties( + static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceQueue && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Queue queue; + getDispatcher()->vkGetDeviceQueue( static_cast( m_device ), queueFamilyIndex, queueIndex, reinterpret_cast( &queue ) ); + + return Queue( *this, *reinterpret_cast( &queue ) ); + } + + // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html + VULKAN_HPP_INLINE typename ResultValueType::type Queue::submit( ArrayProxy const & submits, + VULKAN_HPP_NAMESPACE::Fence fence ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkQueueSubmit( + static_cast( m_queue ), submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::submit" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html + VULKAN_HPP_INLINE typename ResultValueType::type Queue::waitIdle() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkQueueWaitIdle && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkQueueWaitIdle( static_cast( m_queue ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::waitIdle" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::waitIdle() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkDeviceWaitIdle && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkDeviceWaitIdle( static_cast( m_device ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::waitIdle" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::allocateMemory( MemoryAllocateInfo const & allocateInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAllocateMemory && "Function requires " ); + + VULKAN_HPP_NAMESPACE::DeviceMemory memory; + Result result = static_cast( getDispatcher()->vkAllocateMemory( static_cast( m_device ), + reinterpret_cast( &allocateInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &memory ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::allocateMemory" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, DeviceMemory( *this, *reinterpret_cast( &memory ), allocator ) ); + } + + // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + DeviceMemory::mapMemory( DeviceSize offset, DeviceSize size, MemoryMapFlags flags ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory && "Function requires " ); + + void * pData; + Result result = static_cast( getDispatcher()->vkMapMemory( static_cast( m_device ), + static_cast( m_deviceMemory ), + static_cast( offset ), + static_cast( size ), + static_cast( flags ), + &pData ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DeviceMemory::mapMemory" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pData ) ); + } + + // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html + VULKAN_HPP_INLINE void DeviceMemory::unmapMemory() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory && "Function requires " ); + + getDispatcher()->vkUnmapMemory( static_cast( m_device ), static_cast( m_deviceMemory ) ); + } + + // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::flushMappedMemoryRanges( ArrayProxy const & memoryRanges ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkFlushMappedMemoryRanges && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkFlushMappedMemoryRanges( + static_cast( m_device ), memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkInvalidateMappedMemoryRanges, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::invalidateMappedMemoryRanges( ArrayProxy const & memoryRanges ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkInvalidateMappedMemoryRanges && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkInvalidateMappedMemoryRanges( + static_cast( m_device ), memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize DeviceMemory::getCommitment() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMemoryCommitment && "Function requires " ); + + DeviceSize committedMemoryInBytes; + getDispatcher()->vkGetDeviceMemoryCommitment( + static_cast( m_device ), static_cast( m_deviceMemory ), reinterpret_cast( &committedMemoryInBytes ) ); + + return committedMemoryInBytes; + } + + // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html + VULKAN_HPP_INLINE typename ResultValueType::type Buffer::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, DeviceSize memoryOffset ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkBindBufferMemory( static_cast( m_device ), + static_cast( m_buffer ), + static_cast( memory ), + static_cast( memoryOffset ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Buffer::bindMemory" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html + VULKAN_HPP_INLINE typename ResultValueType::type Image::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, DeviceSize memoryOffset ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkBindImageMemory( static_cast( m_device ), + static_cast( m_image ), + static_cast( memory ), + static_cast( memoryOffset ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Image::bindMemory" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements Buffer::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements && "Function requires " ); + + MemoryRequirements memoryRequirements; + getDispatcher()->vkGetBufferMemoryRequirements( + static_cast( m_device ), static_cast( m_buffer ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements Image::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements && "Function requires " ); + + MemoryRequirements memoryRequirements; + getDispatcher()->vkGetImageMemoryRequirements( + static_cast( m_device ), static_cast( m_image ), reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Image::getSparseMemoryRequirements() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements && "Function requires " ); + + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + getDispatcher()->vkGetImageSparseMemoryRequirements( + static_cast( m_device ), static_cast( m_image ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + getDispatcher()->vkGetImageSparseMemoryRequirements( static_cast( m_device ), + static_cast( m_image ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties( + Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast( m_physicalDevice ), + static_cast( format ), + static_cast( type ), + static_cast( samples ), + static_cast( usage ), + static_cast( tiling ), + &propertyCount, + nullptr ); + properties.resize( propertyCount ); + getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast( m_physicalDevice ), + static_cast( format ), + static_cast( type ), + static_cast( samples ), + static_cast( usage ), + static_cast( tiling ), + &propertyCount, + reinterpret_cast( properties.data() ) ); + + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return properties; + } + + // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html + VULKAN_HPP_INLINE typename ResultValueType::type Queue::bindSparse( ArrayProxy const & bindInfo, + VULKAN_HPP_NAMESPACE::Fence fence ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkQueueBindSparse && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkQueueBindSparse( + static_cast( m_queue ), bindInfo.size(), reinterpret_cast( bindInfo.data() ), static_cast( fence ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::bindSparse" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createFence( FenceCreateInfo const & createInfo, Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateFence && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Fence fence; + Result result = static_cast( getDispatcher()->vkCreateFence( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &fence ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createFence" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Fence( *this, *reinterpret_cast( &fence ), allocator ) ); + } + + // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::resetFences( ArrayProxy const & fences ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkResetFences && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkResetFences( static_cast( m_device ), fences.size(), reinterpret_cast( fences.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::resetFences" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Fence::getStatus() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceStatus && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkGetFenceStatus( static_cast( m_device ), static_cast( m_fence ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Fence::getStatus", { Result::eSuccess, Result::eNotReady } ); + + return static_cast( result ); + } + + // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy const & fences, + Bool32 waitAll, + uint64_t timeout ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForFences && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkWaitForFences( + static_cast( m_device ), fences.size(), reinterpret_cast( fences.data() ), static_cast( waitAll ), timeout ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::waitForFences", { Result::eSuccess, Result::eTimeout } ); + + return static_cast( result ); + } + + // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createSemaphore( SemaphoreCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSemaphore && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Semaphore semaphore; + Result result = static_cast( getDispatcher()->vkCreateSemaphore( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &semaphore ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSemaphore" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Semaphore( *this, *reinterpret_cast( &semaphore ), allocator ) ); + } + + // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createQueryPool( QueryPoolCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateQueryPool && "Function requires " ); + + VULKAN_HPP_NAMESPACE::QueryPool queryPool; + Result result = static_cast( getDispatcher()->vkCreateQueryPool( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &queryPool ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createQueryPool" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, QueryPool( *this, *reinterpret_cast( &queryPool ), allocator ) ); + } + + // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> + QueryPool::getResults( uint32_t firstQuery, uint32_t queryCount, size_t dataSize, DeviceSize stride, QueryResultFlags flags ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueryPoolResults && "Function requires " ); + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( getDispatcher()->vkGetQueryPoolResults( static_cast( m_device ), + static_cast( m_queryPool ), + firstQuery, + queryCount, + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ), + static_cast( stride ), + static_cast( flags ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::QueryPool::getResults", { Result::eSuccess, Result::eNotReady } ); + + return ResultValue>( result, std::move( data ) ); + } + + // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue + QueryPool::getResult( uint32_t firstQuery, uint32_t queryCount, DeviceSize stride, QueryResultFlags flags ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueryPoolResults && "Function requires " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkGetQueryPoolResults( static_cast( m_device ), + static_cast( m_queryPool ), + firstQuery, + queryCount, + sizeof( DataType ), + reinterpret_cast( &data ), + static_cast( stride ), + static_cast( flags ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::QueryPool::getResult", { Result::eSuccess, Result::eNotReady } ); + + return ResultValue( result, std::move( data ) ); + } + + // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createBuffer( BufferCreateInfo const & createInfo, Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateBuffer && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Buffer buffer; + Result result = static_cast( getDispatcher()->vkCreateBuffer( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &buffer ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createBuffer" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Buffer( *this, *reinterpret_cast( &buffer ), allocator ) ); + } + + // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createImage( ImageCreateInfo const & createInfo, Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateImage && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Image image; + Result result = static_cast( getDispatcher()->vkCreateImage( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &image ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createImage" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Image( *this, *reinterpret_cast( &image ), allocator ) ); + } + + // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout Image::getSubresourceLayout( const ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSubresourceLayout && "Function requires " ); + + SubresourceLayout layout; + getDispatcher()->vkGetImageSubresourceLayout( static_cast( m_device ), + static_cast( m_image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return layout; + } + + // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createImageView( ImageViewCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateImageView && "Function requires " ); + + VULKAN_HPP_NAMESPACE::ImageView view; + Result result = static_cast( getDispatcher()->vkCreateImageView( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &view ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createImageView" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, ImageView( *this, *reinterpret_cast( &view ), allocator ) ); + } + + // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createCommandPool( CommandPoolCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateCommandPool && "Function requires " ); + + VULKAN_HPP_NAMESPACE::CommandPool commandPool; + Result result = static_cast( getDispatcher()->vkCreateCommandPool( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &commandPool ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createCommandPool" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, CommandPool( *this, *reinterpret_cast( &commandPool ), allocator ) ); + } + + // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html + VULKAN_HPP_INLINE typename ResultValueType::type CommandPool::reset( CommandPoolResetFlags flags ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkResetCommandPool && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkResetCommandPool( + static_cast( m_device ), static_cast( m_commandPool ), static_cast( flags ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandPool::reset" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::allocateCommandBuffers( CommandBufferAllocateInfo const & allocateInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAllocateCommandBuffers && "Function requires " ); + + std::vector commandBuffers( allocateInfo.commandBufferCount ); + Result result = static_cast( getDispatcher()->vkAllocateCommandBuffers( static_cast( m_device ), + reinterpret_cast( &allocateInfo ), + reinterpret_cast( commandBuffers.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); + std::vector commandBuffersRAII; + if ( result == Result::eSuccess ) + { + commandBuffersRAII.reserve( commandBuffers.size() ); + for ( auto & commandBuffer : commandBuffers ) + { + commandBuffersRAII.emplace_back( + *this, *reinterpret_cast( &commandBuffer ), static_cast( allocateInfo.commandPool ) ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( commandBuffersRAII ) ); + } + + // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html + VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBeginCommandBuffer && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkBeginCommandBuffer( static_cast( m_commandBuffer ), + reinterpret_cast( &beginInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::begin" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html + VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::end() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkEndCommandBuffer && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkEndCommandBuffer( static_cast( m_commandBuffer ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::end" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html + VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::reset( CommandBufferResetFlags flags ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkResetCommandBuffer && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkResetCommandBuffer( static_cast( m_commandBuffer ), static_cast( flags ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::reset" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html + VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer, + ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer && "Function requires " ); + + getDispatcher()->vkCmdCopyBuffer( static_cast( m_commandBuffer ), + static_cast( srcBuffer ), + static_cast( dstBuffer ), + regions.size(), + reinterpret_cast( regions.data() ) ); + } + + // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html + VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, + ImageLayout srcImageLayout, + VULKAN_HPP_NAMESPACE::Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage && "Function requires " ); + + getDispatcher()->vkCmdCopyImage( static_cast( m_commandBuffer ), + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regions.size(), + reinterpret_cast( regions.data() ) ); + } + + // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html + VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, + VULKAN_HPP_NAMESPACE::Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage && "Function requires " ); + + getDispatcher()->vkCmdCopyBufferToImage( static_cast( m_commandBuffer ), + static_cast( srcBuffer ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regions.size(), + reinterpret_cast( regions.data() ) ); + } + + // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html + VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, + ImageLayout srcImageLayout, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer, + ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer && "Function requires " ); + + getDispatcher()->vkCmdCopyImageToBuffer( static_cast( m_commandBuffer ), + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstBuffer ), + regions.size(), + reinterpret_cast( regions.data() ) ); + } + + // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html + template + VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, + DeviceSize dstOffset, + ArrayProxy const & data ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdUpdateBuffer && "Function requires " ); + + getDispatcher()->vkCmdUpdateBuffer( static_cast( m_commandBuffer ), + static_cast( dstBuffer ), + static_cast( dstOffset ), + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ) ); + } + + // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html + VULKAN_HPP_INLINE void + CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdFillBuffer && "Function requires " ); + + getDispatcher()->vkCmdFillBuffer( static_cast( m_commandBuffer ), + static_cast( dstBuffer ), + static_cast( dstOffset ), + static_cast( size ), + data ); + } + + // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html + VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + DependencyFlags dependencyFlags, + ArrayProxy const & memoryBarriers, + ArrayProxy const & bufferMemoryBarriers, + ArrayProxy const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier && "Function requires " ); + + getDispatcher()->vkCmdPipelineBarrier( static_cast( m_commandBuffer ), + static_cast( srcStageMask ), + static_cast( dstStageMask ), + static_cast( dependencyFlags ), + memoryBarriers.size(), + reinterpret_cast( memoryBarriers.data() ), + bufferMemoryBarriers.size(), + reinterpret_cast( bufferMemoryBarriers.data() ), + imageMemoryBarriers.size(), + reinterpret_cast( imageMemoryBarriers.data() ) ); + } + + // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html + VULKAN_HPP_INLINE void + CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, QueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQuery && "Function requires " ); + + getDispatcher()->vkCmdBeginQuery( + static_cast( m_commandBuffer ), static_cast( queryPool ), query, static_cast( flags ) ); + } + + // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html + VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQuery && "Function requires " ); + + getDispatcher()->vkCmdEndQuery( static_cast( m_commandBuffer ), static_cast( queryPool ), query ); + } + + // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html + VULKAN_HPP_INLINE void + CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetQueryPool && "Function requires " ); + + getDispatcher()->vkCmdResetQueryPool( static_cast( m_commandBuffer ), static_cast( queryPool ), firstQuery, queryCount ); + } + + // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html + VULKAN_HPP_INLINE void + CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp && "Function requires " ); + + getDispatcher()->vkCmdWriteTimestamp( + static_cast( m_commandBuffer ), static_cast( pipelineStage ), static_cast( queryPool ), query ); + } + + // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html + VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer, + DeviceSize dstOffset, + DeviceSize stride, + QueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyQueryPoolResults && "Function requires " ); + + getDispatcher()->vkCmdCopyQueryPoolResults( static_cast( m_commandBuffer ), + static_cast( queryPool ), + firstQuery, + queryCount, + static_cast( dstBuffer ), + static_cast( dstOffset ), + static_cast( stride ), + static_cast( flags ) ); + } + + // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html + VULKAN_HPP_INLINE void + CommandBuffer::executeCommands( ArrayProxy const & commandBuffers ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdExecuteCommands && "Function requires " ); + + getDispatcher()->vkCmdExecuteCommands( + static_cast( m_commandBuffer ), commandBuffers.size(), reinterpret_cast( commandBuffers.data() ) ); + } + + // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createEvent( EventCreateInfo const & createInfo, Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateEvent && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Event event; + Result result = static_cast( getDispatcher()->vkCreateEvent( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &event ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createEvent" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Event( *this, *reinterpret_cast( &event ), allocator ) ); + } + + // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Event::getStatus() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetEventStatus && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkGetEventStatus( static_cast( m_device ), static_cast( m_event ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Event::getStatus", { Result::eEventSet, Result::eEventReset } ); + + return static_cast( result ); + } + + // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html + VULKAN_HPP_INLINE typename ResultValueType::type Event::set() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetEvent && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkSetEvent( static_cast( m_device ), static_cast( m_event ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Event::set" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html + VULKAN_HPP_INLINE typename ResultValueType::type Event::reset() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkResetEvent && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkResetEvent( static_cast( m_device ), static_cast( m_event ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Event::reset" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createBufferView( BufferViewCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateBufferView && "Function requires " ); + + VULKAN_HPP_NAMESPACE::BufferView view; + Result result = static_cast( getDispatcher()->vkCreateBufferView( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &view ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createBufferView" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, BufferView( *this, *reinterpret_cast( &view ), allocator ) ); + } + + // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createShaderModule( ShaderModuleCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateShaderModule && "Function requires " ); + + VULKAN_HPP_NAMESPACE::ShaderModule shaderModule; + Result result = static_cast( getDispatcher()->vkCreateShaderModule( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &shaderModule ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createShaderModule" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, + ShaderModule( *this, *reinterpret_cast( &shaderModule ), allocator ) ); + } + + // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createPipelineCache( PipelineCacheCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreatePipelineCache && "Function requires " ); + + VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache; + Result result = static_cast( getDispatcher()->vkCreatePipelineCache( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipelineCache ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createPipelineCache" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, + PipelineCache( *this, *reinterpret_cast( &pipelineCache ), allocator ) ); + } + + // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PipelineCache::getData() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineCacheData && "Function requires " ); + + std::vector data; + size_t dataSize; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPipelineCacheData( static_cast( m_device ), static_cast( m_pipelineCache ), &dataSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( getDispatcher()->vkGetPipelineCacheData( + static_cast( m_device ), static_cast( m_pipelineCache ), &dataSize, reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PipelineCache::getData" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html + VULKAN_HPP_INLINE typename ResultValueType::type PipelineCache::merge( ArrayProxy const & srcCaches ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkMergePipelineCaches && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkMergePipelineCaches( static_cast( m_device ), + static_cast( m_pipelineCache ), + srcCaches.size(), + reinterpret_cast( srcCaches.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PipelineCache::merge" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createComputePipelines( Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateComputePipelines && "Function requires " ); + + std::vector pipelines( createInfos.size() ); + Result result = + static_cast( getDispatcher()->vkCreateComputePipelines( static_cast( m_device ), + pipelineCache ? static_cast( **pipelineCache ) : 0, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createComputePipelines", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + std::vector pipelinesRAII; + if ( result == Result::eSuccess ) + { + pipelinesRAII.reserve( pipelines.size() ); + for ( auto & pipeline : pipelines ) + { + pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); + } + + // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createComputePipeline( Optional const & pipelineCache, + ComputePipelineCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateComputePipelines && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Pipeline pipeline; + Result result = static_cast( getDispatcher()->vkCreateComputePipelines( static_cast( m_device ), + pipelineCache ? static_cast( **pipelineCache ) : 0, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createComputePipeline", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); + } + + // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createPipelineLayout( PipelineLayoutCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreatePipelineLayout && "Function requires " ); + + VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout; + Result result = static_cast( getDispatcher()->vkCreatePipelineLayout( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipelineLayout ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createPipelineLayout" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, PipelineLayout( *this, *reinterpret_cast( &pipelineLayout ), allocator ) ); + } + + // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createSampler( SamplerCreateInfo const & createInfo, Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSampler && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Sampler sampler; + Result result = static_cast( getDispatcher()->vkCreateSampler( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &sampler ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSampler" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Sampler( *this, *reinterpret_cast( &sampler ), allocator ) ); + } + + // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createDescriptorSetLayout( DescriptorSetLayoutCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDescriptorSetLayout && "Function requires " ); + + VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout; + Result result = + static_cast( getDispatcher()->vkCreateDescriptorSetLayout( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &setLayout ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDescriptorSetLayout" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, DescriptorSetLayout( *this, *reinterpret_cast( &setLayout ), allocator ) ); + } + + // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createDescriptorPool( DescriptorPoolCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDescriptorPool && "Function requires " ); + + VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool; + Result result = static_cast( getDispatcher()->vkCreateDescriptorPool( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &descriptorPool ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDescriptorPool" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, DescriptorPool( *this, *reinterpret_cast( &descriptorPool ), allocator ) ); + } + + // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html + VULKAN_HPP_INLINE typename ResultValueType::type DescriptorPool::reset( DescriptorPoolResetFlags flags ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkResetDescriptorPool && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkResetDescriptorPool( + static_cast( m_device ), static_cast( m_descriptorPool ), static_cast( flags ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DescriptorPool::reset" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::allocateDescriptorSets( DescriptorSetAllocateInfo const & allocateInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAllocateDescriptorSets && "Function requires " ); + + std::vector descriptorSets( allocateInfo.descriptorSetCount ); + Result result = static_cast( getDispatcher()->vkAllocateDescriptorSets( static_cast( m_device ), + reinterpret_cast( &allocateInfo ), + reinterpret_cast( descriptorSets.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); + std::vector descriptorSetsRAII; + if ( result == Result::eSuccess ) + { + descriptorSetsRAII.reserve( descriptorSets.size() ); + for ( auto & descriptorSet : descriptorSets ) + { + descriptorSetsRAII.emplace_back( + *this, *reinterpret_cast( &descriptorSet ), static_cast( allocateInfo.descriptorPool ) ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( descriptorSetsRAII ) ); + } + + // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html + VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy const & descriptorWrites, + ArrayProxy const & descriptorCopies ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateDescriptorSets && "Function requires " ); + + getDispatcher()->vkUpdateDescriptorSets( static_cast( m_device ), + descriptorWrites.size(), + reinterpret_cast( descriptorWrites.data() ), + descriptorCopies.size(), + reinterpret_cast( descriptorCopies.data() ) ); + } + + // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html + VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindPipeline && "Function requires " ); + + getDispatcher()->vkCmdBindPipeline( + static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( pipeline ) ); + } + + // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t firstSet, + ArrayProxy const & descriptorSets, + ArrayProxy const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorSets && "Function requires " ); + + getDispatcher()->vkCmdBindDescriptorSets( static_cast( m_commandBuffer ), + static_cast( pipelineBindPoint ), + static_cast( layout ), + firstSet, + descriptorSets.size(), + reinterpret_cast( descriptorSets.data() ), + dynamicOffsets.size(), + dynamicOffsets.data() ); + } + + // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html + VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( VULKAN_HPP_NAMESPACE::Image image, + ImageLayout imageLayout, + const ClearColorValue & color, + ArrayProxy const & ranges ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearColorImage && "Function requires " ); + + getDispatcher()->vkCmdClearColorImage( static_cast( m_commandBuffer ), + static_cast( image ), + static_cast( imageLayout ), + reinterpret_cast( &color ), + ranges.size(), + reinterpret_cast( ranges.data() ) ); + } + + // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html + VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatch && "Function requires " ); + + getDispatcher()->vkCmdDispatch( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); + } + + // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html + VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchIndirect && "Function requires " ); + + getDispatcher()->vkCmdDispatchIndirect( + static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ) ); + } + + // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html + VULKAN_HPP_INLINE void CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent && "Function requires " ); + + getDispatcher()->vkCmdSetEvent( + static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); + } + + // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html + VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent && "Function requires " ); + + getDispatcher()->vkCmdResetEvent( + static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); + } + + // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html + VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy const & events, + PipelineStageFlags srcStageMask, + PipelineStageFlags dstStageMask, + ArrayProxy const & memoryBarriers, + ArrayProxy const & bufferMemoryBarriers, + ArrayProxy const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents && "Function requires " ); + + getDispatcher()->vkCmdWaitEvents( static_cast( m_commandBuffer ), + events.size(), + reinterpret_cast( events.data() ), + static_cast( srcStageMask ), + static_cast( dstStageMask ), + memoryBarriers.size(), + reinterpret_cast( memoryBarriers.data() ), + bufferMemoryBarriers.size(), + reinterpret_cast( bufferMemoryBarriers.data() ), + imageMemoryBarriers.size(), + reinterpret_cast( imageMemoryBarriers.data() ) ); + } + + // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html + template + VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, + ShaderStageFlags stageFlags, + uint32_t offset, + ArrayProxy const & values ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushConstants && "Function requires " ); + + getDispatcher()->vkCmdPushConstants( static_cast( m_commandBuffer ), + static_cast( layout ), + static_cast( stageFlags ), + offset, + values.size() * sizeof( ValuesType ), + reinterpret_cast( values.data() ) ); + } + + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createGraphicsPipelines( Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateGraphicsPipelines && "Function requires " ); + + std::vector pipelines( createInfos.size() ); + Result result = + static_cast( getDispatcher()->vkCreateGraphicsPipelines( static_cast( m_device ), + pipelineCache ? static_cast( **pipelineCache ) : 0, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createGraphicsPipelines", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + std::vector pipelinesRAII; + if ( result == Result::eSuccess ) + { + pipelinesRAII.reserve( pipelines.size() ); + for ( auto & pipeline : pipelines ) + { + pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); + } + + // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createGraphicsPipeline( Optional const & pipelineCache, + GraphicsPipelineCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateGraphicsPipelines && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Pipeline pipeline; + Result result = static_cast( getDispatcher()->vkCreateGraphicsPipelines( static_cast( m_device ), + pipelineCache ? static_cast( **pipelineCache ) : 0, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createGraphicsPipeline", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); + } + + // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createFramebuffer( FramebufferCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateFramebuffer && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Framebuffer framebuffer; + Result result = static_cast( getDispatcher()->vkCreateFramebuffer( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &framebuffer ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createFramebuffer" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Framebuffer( *this, *reinterpret_cast( &framebuffer ), allocator ) ); + } + + // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createRenderPass( RenderPassCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRenderPass && "Function requires " ); + + VULKAN_HPP_NAMESPACE::RenderPass renderPass; + Result result = static_cast( getDispatcher()->vkCreateRenderPass( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &renderPass ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRenderPass" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, RenderPass( *this, *reinterpret_cast( &renderPass ), allocator ) ); + } + + // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRenderAreaGranularity && "Function requires " ); + + Extent2D granularity; + getDispatcher()->vkGetRenderAreaGranularity( + static_cast( m_device ), static_cast( m_renderPass ), reinterpret_cast( &granularity ) ); + + return granularity; + } + + // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html + VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewport && "Function requires " ); + + getDispatcher()->vkCmdSetViewport( + static_cast( m_commandBuffer ), firstViewport, viewports.size(), reinterpret_cast( viewports.data() ) ); + } + + // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html + VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissor && "Function requires " ); + + getDispatcher()->vkCmdSetScissor( + static_cast( m_commandBuffer ), firstScissor, scissors.size(), reinterpret_cast( scissors.data() ) ); + } + + // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html + VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineWidth && "Function requires " ); + + getDispatcher()->vkCmdSetLineWidth( static_cast( m_commandBuffer ), lineWidth ); + } + + // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html + VULKAN_HPP_INLINE void + CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBias && "Function requires " ); + + getDispatcher()->vkCmdSetDepthBias( static_cast( m_commandBuffer ), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); + } + + // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html + VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetBlendConstants && "Function requires " ); + + getDispatcher()->vkCmdSetBlendConstants( static_cast( m_commandBuffer ), blendConstants ); + } + + // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBounds && "Function requires " ); + + getDispatcher()->vkCmdSetDepthBounds( static_cast( m_commandBuffer ), minDepthBounds, maxDepthBounds ); + } + + // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html + VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilCompareMask && "Function requires " ); + + getDispatcher()->vkCmdSetStencilCompareMask( static_cast( m_commandBuffer ), static_cast( faceMask ), compareMask ); + } + + // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html + VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilWriteMask && "Function requires " ); + + getDispatcher()->vkCmdSetStencilWriteMask( static_cast( m_commandBuffer ), static_cast( faceMask ), writeMask ); + } + + // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html + VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilReference && "Function requires " ); + + getDispatcher()->vkCmdSetStencilReference( static_cast( m_commandBuffer ), static_cast( faceMask ), reference ); + } + + // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html + VULKAN_HPP_INLINE void + CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, IndexType indexType ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer && "Function requires " ); + + getDispatcher()->vkCmdBindIndexBuffer( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( indexType ) ); + } + + // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers && "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); +# else + if ( buffers.size() != offsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdBindVertexBuffers( static_cast( m_commandBuffer ), + firstBinding, + buffers.size(), + reinterpret_cast( buffers.data() ), + reinterpret_cast( offsets.data() ) ); + } + + // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html + VULKAN_HPP_INLINE void + CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDraw && "Function requires " ); + + getDispatcher()->vkCmdDraw( static_cast( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance ); + } + + // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( + uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexed && "Function requires " ); + + getDispatcher()->vkCmdDrawIndexed( static_cast( m_commandBuffer ), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); + } + + // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html + VULKAN_HPP_INLINE void + CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirect && "Function requires " ); + + getDispatcher()->vkCmdDrawIndirect( + static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); + } + + // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + uint32_t drawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexedIndirect && "Function requires " ); + + getDispatcher()->vkCmdDrawIndexedIndirect( + static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); + } + + // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html + VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, + ImageLayout srcImageLayout, + VULKAN_HPP_NAMESPACE::Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions, + Filter filter ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage && "Function requires " ); + + getDispatcher()->vkCmdBlitImage( static_cast( m_commandBuffer ), + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regions.size(), + reinterpret_cast( regions.data() ), + static_cast( filter ) ); + } + + // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html + VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, + ImageLayout imageLayout, + const ClearDepthStencilValue & depthStencil, + ArrayProxy const & ranges ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearDepthStencilImage && "Function requires " ); + + getDispatcher()->vkCmdClearDepthStencilImage( static_cast( m_commandBuffer ), + static_cast( image ), + static_cast( imageLayout ), + reinterpret_cast( &depthStencil ), + ranges.size(), + reinterpret_cast( ranges.data() ) ); + } + + // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html + VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy const & attachments, + ArrayProxy const & rects ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearAttachments && "Function requires " ); + + getDispatcher()->vkCmdClearAttachments( static_cast( m_commandBuffer ), + attachments.size(), + reinterpret_cast( attachments.data() ), + rects.size(), + reinterpret_cast( rects.data() ) ); + } + + // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html + VULKAN_HPP_INLINE void CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, + ImageLayout srcImageLayout, + VULKAN_HPP_NAMESPACE::Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage && "Function requires " ); + + getDispatcher()->vkCmdResolveImage( static_cast( m_commandBuffer ), + static_cast( srcImage ), + static_cast( srcImageLayout ), + static_cast( dstImage ), + static_cast( dstImageLayout ), + regions.size(), + reinterpret_cast( regions.data() ) ); + } + + // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass && "Function requires " ); + + getDispatcher()->vkCmdBeginRenderPass( static_cast( m_commandBuffer ), + reinterpret_cast( &renderPassBegin ), + static_cast( contents ) ); + } + + // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass && "Function requires " ); + + getDispatcher()->vkCmdNextSubpass( static_cast( m_commandBuffer ), static_cast( contents ) ); + } + + // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html + VULKAN_HPP_INLINE void CommandBuffer::endRenderPass() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass && "Function requires " ); + + getDispatcher()->vkCmdEndRenderPass( static_cast( m_commandBuffer ) ); + } + + //=== VK_VERSION_1_1 === + + // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Context::enumerateInstanceVersion() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateInstanceVersion && "Function requires " ); + + uint32_t apiVersion; + Result result = static_cast( getDispatcher()->vkEnumerateInstanceVersion( &apiVersion ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Context::enumerateInstanceVersion" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( apiVersion ) ); + } + + // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::bindBufferMemory2( ArrayProxy const & bindInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2 && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkBindBufferMemory2( + static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindBufferMemory2" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::bindImageMemory2( ArrayProxy const & bindInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2 && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkBindImageMemory2( + static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindImageMemory2" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures && + "Function requires or " ); + + PeerMemoryFeatureFlags peerMemoryFeatures; + getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures( static_cast( m_device ), + heapIndex, + localDeviceIndex, + remoteDeviceIndex, + reinterpret_cast( &peerMemoryFeatures ) ); + + return peerMemoryFeatures; + } + + // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html + VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMask && "Function requires or " ); + + getDispatcher()->vkCmdSetDeviceMask( static_cast( m_commandBuffer ), deviceMask ); + } + + // wrapper function for command vkEnumeratePhysicalDeviceGroups, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::enumeratePhysicalDeviceGroups() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceGroups && + "Function requires or " ); + + std::vector physicalDeviceGroupProperties; + uint32_t physicalDeviceGroupCount; + Result result; + do + { + result = + static_cast( getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast( m_instance ), &physicalDeviceGroupCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + result = static_cast( + getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast( m_instance ), + &physicalDeviceGroupCount, + reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); + if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); + } + + // wrapper function for command vkGetImageMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2 && + "Function requires or " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetImageMemoryRequirements2( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetImageMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2 && + "Function requires or " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetImageMemoryRequirements2( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkGetBufferMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2 && + "Function requires or " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetBufferMemoryRequirements2( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetBufferMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2 && + "Function requires or " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetBufferMemoryRequirements2( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkGetImageSparseMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements2 && + "Function requires or " ); + + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + getDispatcher()->vkGetImageSparseMemoryRequirements2( + static_cast( m_device ), reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + getDispatcher()->vkGetImageSparseMemoryRequirements2( static_cast( m_device ), + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } + + // wrapper function for command vkGetPhysicalDeviceFeatures2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2 && + "Function requires or " ); + + PhysicalDeviceFeatures2 features; + getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast( m_physicalDevice ), + reinterpret_cast( &features ) ); + + return features; + } + + // wrapper function for command vkGetPhysicalDeviceFeatures2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2 && + "Function requires or " ); + + StructureChain structureChain; + PhysicalDeviceFeatures2 & features = structureChain.template get(); + getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast( m_physicalDevice ), + reinterpret_cast( &features ) ); + + return structureChain; + } + + // wrapper function for command vkGetPhysicalDeviceProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2 && + "Function requires or " ); + + PhysicalDeviceProperties2 properties; + getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( &properties ) ); + + return properties; + } + + // wrapper function for command vkGetPhysicalDeviceProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2 && + "Function requires or " ); + + StructureChain structureChain; + PhysicalDeviceProperties2 & properties = structureChain.template get(); + getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( &properties ) ); + + return structureChain; + } + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2( Format format ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2 && + "Function requires or " ); + + FormatProperties2 formatProperties; + getDispatcher()->vkGetPhysicalDeviceFormatProperties2( + static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); + + return formatProperties; + } + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFormatProperties2( Format format ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2 && + "Function requires or " ); + + StructureChain structureChain; + FormatProperties2 & formatProperties = structureChain.template get(); + getDispatcher()->vkGetPhysicalDeviceFormatProperties2( + static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); + + return structureChain; + } + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( + const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, ImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2 && + "Function requires or " ); + return static_cast( + getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( pImageFormatInfo ), + reinterpret_cast( pImageFormatProperties ) ) ); + } + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2 && + "Function requires or " ); + + ImageFormatProperties2 imageFormatProperties; + Result result = static_cast( + getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( &imageFormatInfo ), + reinterpret_cast( &imageFormatProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2 && + "Function requires or " ); + + StructureChain structureChain; + ImageFormatProperties2 & imageFormatProperties = structureChain.template get(); + Result result = static_cast( + getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( &imageFormatInfo ), + reinterpret_cast( &imageFormatProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2 && + "Function requires or " ); + + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast( m_physicalDevice ), + &queueFamilyPropertyCount, + reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + queueFamilyProperties.resize( queueFamilyPropertyCount ); + } + return queueFamilyProperties; + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2 && + "Function requires or " ); + + std::vector structureChains; + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); + structureChains.resize( queueFamilyPropertyCount ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; + } + getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast( m_physicalDevice ), + &queueFamilyPropertyCount, + reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + structureChains.resize( queueFamilyPropertyCount ); + } + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + structureChains[i].template get() = queueFamilyProperties[i]; + } + return structureChains; + } + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2 && + "Function requires or " ); + + PhysicalDeviceMemoryProperties2 memoryProperties; + getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( &memoryProperties ) ); + + return memoryProperties; + } + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2 && + "Function requires or " ); + + StructureChain structureChain; + PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get(); + getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( &memoryProperties ) ); + + return structureChain; + } + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2 && + "Function requires or " ); + + std::vector properties; + uint32_t propertyCount; + getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( &formatInfo ), + &propertyCount, + nullptr ); + properties.resize( propertyCount ); + getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast( m_physicalDevice ), + reinterpret_cast( &formatInfo ), + &propertyCount, + reinterpret_cast( properties.data() ) ); + + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return properties; + } + + // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html + VULKAN_HPP_INLINE void CommandPool::trim( CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPool && "Function requires or " ); + + getDispatcher()->vkTrimCommandPool( + static_cast( m_device ), static_cast( m_commandPool ), static_cast( flags ) ); + } + + // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Queue Device::getQueue2( DeviceQueueInfo2 const & queueInfo ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceQueue2 && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Queue queue; + getDispatcher()->vkGetDeviceQueue2( + static_cast( m_device ), reinterpret_cast( &queueInfo ), reinterpret_cast( &queue ) ); + + return Queue( *this, *reinterpret_cast( &queue ) ); + } + + // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalBufferProperties + PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalBufferProperties && + "Function requires or " ); + + ExternalBufferProperties externalBufferProperties; + getDispatcher()->vkGetPhysicalDeviceExternalBufferProperties( static_cast( m_physicalDevice ), + reinterpret_cast( &externalBufferInfo ), + reinterpret_cast( &externalBufferProperties ) ); + + return externalBufferProperties; + } + + // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalFenceProperties + PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalFenceProperties && + "Function requires or " ); + + ExternalFenceProperties externalFenceProperties; + getDispatcher()->vkGetPhysicalDeviceExternalFenceProperties( static_cast( m_physicalDevice ), + reinterpret_cast( &externalFenceInfo ), + reinterpret_cast( &externalFenceProperties ) ); + + return externalFenceProperties; + } + + // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalSemaphoreProperties + PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalSemaphoreProperties && + "Function requires or " ); + + ExternalSemaphoreProperties externalSemaphoreProperties; + getDispatcher()->vkGetPhysicalDeviceExternalSemaphoreProperties( + static_cast( m_physicalDevice ), + reinterpret_cast( &externalSemaphoreInfo ), + reinterpret_cast( &externalSemaphoreProperties ) ); + + return externalSemaphoreProperties; + } + + // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html + VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBase && "Function requires or " ); + + getDispatcher()->vkCmdDispatchBase( + static_cast( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); + } + + // wrapper function for command vkCreateDescriptorUpdateTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createDescriptorUpdateTemplate( DescriptorUpdateTemplateCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDescriptorUpdateTemplate && + "Function requires or " ); + + VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; + Result result = + static_cast( getDispatcher()->vkCreateDescriptorUpdateTemplate( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &descriptorUpdateTemplate ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, DescriptorUpdateTemplate( *this, *reinterpret_cast( &descriptorUpdateTemplate ), allocator ) ); + } + + // wrapper function for command vkUpdateDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html + template + VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, + DataType const & data ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateDescriptorSetWithTemplate && + "Function requires or " ); + + getDispatcher()->vkUpdateDescriptorSetWithTemplate( static_cast( m_device ), + static_cast( m_descriptorSet ), + static_cast( descriptorUpdateTemplate ), + reinterpret_cast( &data ) ); + } + + // wrapper function for command vkGetDescriptorSetLayoutSupport, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutSupport + Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupport && + "Function requires or " ); + + DescriptorSetLayoutSupport support; + getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( &support ) ); + + return support; + } + + // wrapper function for command vkGetDescriptorSetLayoutSupport, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupport && + "Function requires or " ); + + StructureChain structureChain; + DescriptorSetLayoutSupport & support = structureChain.template get(); + getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( &support ) ); + + return structureChain; + } + + // wrapper function for command vkCreateSamplerYcbcrConversion, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createSamplerYcbcrConversion( SamplerYcbcrConversionCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSamplerYcbcrConversion && + "Function requires or " ); + + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; + Result result = + static_cast( getDispatcher()->vkCreateSamplerYcbcrConversion( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &ycbcrConversion ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, SamplerYcbcrConversion( *this, *reinterpret_cast( &ycbcrConversion ), allocator ) ); + } + + //=== VK_VERSION_1_2 === + + // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html + VULKAN_HPP_INLINE void QueryPool::reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPool && "Function requires or " ); + + getDispatcher()->vkResetQueryPool( static_cast( m_device ), static_cast( m_queryPool ), firstQuery, queryCount ); + } + + // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Semaphore::getCounterValue() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreCounterValue && + "Function requires or " ); + + uint64_t value; + Result result = static_cast( + getDispatcher()->vkGetSemaphoreCounterValue( static_cast( m_device ), static_cast( m_semaphore ), &value ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Semaphore::getCounterValue" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( value ) ); + } + + // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphores && "Function requires or " ); + + Result result = static_cast( + getDispatcher()->vkWaitSemaphores( static_cast( m_device ), reinterpret_cast( &waitInfo ), timeout ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::waitSemaphores", { Result::eSuccess, Result::eTimeout } ); + + return static_cast( result ); + } + + // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::signalSemaphore( const SemaphoreSignalInfo & signalInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphore && "Function requires or " ); + + Result result = static_cast( + getDispatcher()->vkSignalSemaphore( static_cast( m_device ), reinterpret_cast( &signalInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::signalSemaphore" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferDeviceAddress && + "Function requires or or " ); + + VkDeviceAddress result = + getDispatcher()->vkGetBufferDeviceAddress( static_cast( m_device ), reinterpret_cast( &info ) ); + + return static_cast( result ); + } + + // wrapper function for command vkGetBufferOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferOpaqueCaptureAddress && + "Function requires or " ); + + uint64_t result = + getDispatcher()->vkGetBufferOpaqueCaptureAddress( static_cast( m_device ), reinterpret_cast( &info ) ); + + return result; + } + + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t + Device::getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress && + "Function requires or " ); + + uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress( static_cast( m_device ), + reinterpret_cast( &info ) ); + + return result; + } + + // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCount && + "Function requires or or " ); + + getDispatcher()->vkCmdDrawIndirectCount( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + // wrapper function for command vkCmdDrawIndexedIndirectCount, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexedIndirectCount && + "Function requires or or " ); + + getDispatcher()->vkCmdDrawIndexedIndirectCount( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createRenderPass2( RenderPassCreateInfo2 const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRenderPass2 && "Function requires or " ); + + VULKAN_HPP_NAMESPACE::RenderPass renderPass; + Result result = static_cast( getDispatcher()->vkCreateRenderPass2( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &renderPass ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRenderPass2" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, RenderPass( *this, *reinterpret_cast( &renderPass ), allocator ) ); + } + + // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const RenderPassBeginInfo & renderPassBegin, + const SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2 && + "Function requires or " ); + + getDispatcher()->vkCmdBeginRenderPass2( static_cast( m_commandBuffer ), + reinterpret_cast( &renderPassBegin ), + reinterpret_cast( &subpassBeginInfo ) ); + } + + // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const SubpassBeginInfo & subpassBeginInfo, + const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2 && "Function requires or " ); + + getDispatcher()->vkCmdNextSubpass2( static_cast( m_commandBuffer ), + reinterpret_cast( &subpassBeginInfo ), + reinterpret_cast( &subpassEndInfo ) ); + } + + // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html + VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2 && "Function requires or " ); + + getDispatcher()->vkCmdEndRenderPass2( static_cast( m_commandBuffer ), reinterpret_cast( &subpassEndInfo ) ); + } + + //=== VK_VERSION_1_3 === + + // wrapper function for command vkGetPhysicalDeviceToolProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getToolProperties() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceToolProperties && + "Function requires or " ); + + std::vector toolProperties; + uint32_t toolCount; + Result result; + do + { + result = + static_cast( getDispatcher()->vkGetPhysicalDeviceToolProperties( static_cast( m_physicalDevice ), &toolCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && toolCount ) + { + toolProperties.resize( toolCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceToolProperties( + static_cast( m_physicalDevice ), &toolCount, reinterpret_cast( toolProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" ); + VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); + if ( toolCount < toolProperties.size() ) + { + toolProperties.resize( toolCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( toolProperties ) ); + } + + // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createPrivateDataSlot( PrivateDataSlotCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreatePrivateDataSlot && "Function requires or " ); + + VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; + Result result = static_cast( getDispatcher()->vkCreatePrivateDataSlot( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &privateDataSlot ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createPrivateDataSlot" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, PrivateDataSlot( *this, *reinterpret_cast( &privateDataSlot ), allocator ) ); + } + + // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::setPrivateData( ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetPrivateData && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkSetPrivateData( + static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::setPrivateData" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateData( ObjectType objectType_, + uint64_t objectHandle, + VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateData && "Function requires or " ); + + uint64_t data; + getDispatcher()->vkGetPrivateData( + static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), &data ); + + return data; + } + + // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html + VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2 && "Function requires or " ); + + getDispatcher()->vkCmdPipelineBarrier2( static_cast( m_commandBuffer ), reinterpret_cast( &dependencyInfo ) ); + } + + // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html + VULKAN_HPP_INLINE void + CommandBuffer::writeTimestamp2( PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2 && "Function requires or " ); + + getDispatcher()->vkCmdWriteTimestamp2( + static_cast( m_commandBuffer ), static_cast( stage ), static_cast( queryPool ), query ); + } + + // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html + VULKAN_HPP_INLINE typename ResultValueType::type Queue::submit2( ArrayProxy const & submits, + VULKAN_HPP_NAMESPACE::Fence fence ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2 && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkQueueSubmit2( + static_cast( m_queue ), submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::submit2" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html + VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2 && "Function requires or " ); + + getDispatcher()->vkCmdCopyBuffer2( static_cast( m_commandBuffer ), reinterpret_cast( ©BufferInfo ) ); + } + + // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html + VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2 && "Function requires or " ); + + getDispatcher()->vkCmdCopyImage2( static_cast( m_commandBuffer ), reinterpret_cast( ©ImageInfo ) ); + } + + // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html + VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2( const CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2 && + "Function requires or " ); + + getDispatcher()->vkCmdCopyBufferToImage2( static_cast( m_commandBuffer ), + reinterpret_cast( ©BufferToImageInfo ) ); + } + + // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html + VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2( const CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2 && + "Function requires or " ); + + getDispatcher()->vkCmdCopyImageToBuffer2( static_cast( m_commandBuffer ), + reinterpret_cast( ©ImageToBufferInfo ) ); + } + + // wrapper function for command vkGetDeviceBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirements && + "Function requires or " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDeviceBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirements && + "Function requires or " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkGetDeviceImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirements && + "Function requires or " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDeviceImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirements && + "Function requires or " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSparseMemoryRequirements && + "Function requires or " ); + + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( + static_cast( m_device ), reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( static_cast( m_device ), + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } + + // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html + VULKAN_HPP_INLINE void CommandBuffer::setEvent2( VULKAN_HPP_NAMESPACE::Event event, const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent2 && "Function requires or " ); + + getDispatcher()->vkCmdSetEvent2( + static_cast( m_commandBuffer ), static_cast( event ), reinterpret_cast( &dependencyInfo ) ); + } + + // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html + VULKAN_HPP_INLINE void CommandBuffer::resetEvent2( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2 && "Function requires or " ); + + getDispatcher()->vkCmdResetEvent2( + static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); + } + + // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html + VULKAN_HPP_INLINE void CommandBuffer::waitEvents2( ArrayProxy const & events, + ArrayProxy const & dependencyInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents2 && "Function requires or " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); +# else + if ( events.size() != dependencyInfos.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2: events.size() != dependencyInfos.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdWaitEvents2( static_cast( m_commandBuffer ), + events.size(), + reinterpret_cast( events.data() ), + reinterpret_cast( dependencyInfos.data() ) ); + } + + // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html + VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2 && "Function requires or " ); + + getDispatcher()->vkCmdBlitImage2( static_cast( m_commandBuffer ), reinterpret_cast( &blitImageInfo ) ); + } + + // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html + VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2 && "Function requires or " ); + + getDispatcher()->vkCmdResolveImage2( static_cast( m_commandBuffer ), + reinterpret_cast( &resolveImageInfo ) ); + } + + // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html + VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRendering && "Function requires or " ); + + getDispatcher()->vkCmdBeginRendering( static_cast( m_commandBuffer ), reinterpret_cast( &renderingInfo ) ); + } + + // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html + VULKAN_HPP_INLINE void CommandBuffer::endRendering() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRendering && "Function requires or " ); + + getDispatcher()->vkCmdEndRendering( static_cast( m_commandBuffer ) ); + } + + // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html + VULKAN_HPP_INLINE void CommandBuffer::setCullMode( CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullMode && + "Function requires or or " ); + + getDispatcher()->vkCmdSetCullMode( static_cast( m_commandBuffer ), static_cast( cullMode ) ); + } + + // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html + VULKAN_HPP_INLINE void CommandBuffer::setFrontFace( FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFace && + "Function requires or or " ); + + getDispatcher()->vkCmdSetFrontFace( static_cast( m_commandBuffer ), static_cast( frontFace ) ); + } + + // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html + VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology( PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveTopology && + "Function requires or or " ); + + getDispatcher()->vkCmdSetPrimitiveTopology( static_cast( m_commandBuffer ), static_cast( primitiveTopology ) ); + } + + // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html + VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCount( ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWithCount && + "Function requires or or " ); + + getDispatcher()->vkCmdSetViewportWithCount( + static_cast( m_commandBuffer ), viewports.size(), reinterpret_cast( viewports.data() ) ); + } + + // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html + VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCount( ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissorWithCount && + "Function requires or or " ); + + getDispatcher()->vkCmdSetScissorWithCount( + static_cast( m_commandBuffer ), scissors.size(), reinterpret_cast( scissors.data() ) ); + } + + // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes, + ArrayProxy const & strides ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers2 && + "Function requires or or " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); + VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); + VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); +# else + if ( buffers.size() != offsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != offsets.size()" ); + } + if ( !sizes.empty() && buffers.size() != sizes.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != sizes.size()" ); + } + if ( !strides.empty() && buffers.size() != strides.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != strides.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdBindVertexBuffers2( static_cast( m_commandBuffer ), + firstBinding, + buffers.size(), + reinterpret_cast( buffers.data() ), + reinterpret_cast( offsets.data() ), + reinterpret_cast( sizes.data() ), + reinterpret_cast( strides.data() ) ); + } + + // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable( Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthTestEnable && + "Function requires or or " ); + + getDispatcher()->vkCmdSetDepthTestEnable( static_cast( m_commandBuffer ), static_cast( depthTestEnable ) ); + } + + // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable( Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthWriteEnable && + "Function requires or or " ); + + getDispatcher()->vkCmdSetDepthWriteEnable( static_cast( m_commandBuffer ), static_cast( depthWriteEnable ) ); + } + + // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp( CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthCompareOp && + "Function requires or or " ); + + getDispatcher()->vkCmdSetDepthCompareOp( static_cast( m_commandBuffer ), static_cast( depthCompareOp ) ); + } + + // wrapper function for command vkCmdSetDepthBoundsTestEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBoundsTestEnable && + "Function requires or or " ); + + getDispatcher()->vkCmdSetDepthBoundsTestEnable( static_cast( m_commandBuffer ), static_cast( depthBoundsTestEnable ) ); + } + + // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html + VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable( Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilTestEnable && + "Function requires or or " ); + + getDispatcher()->vkCmdSetStencilTestEnable( static_cast( m_commandBuffer ), static_cast( stencilTestEnable ) ); + } + + // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html + VULKAN_HPP_INLINE void CommandBuffer::setStencilOp( + StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOp && + "Function requires or or " ); + + getDispatcher()->vkCmdSetStencilOp( static_cast( m_commandBuffer ), + static_cast( faceMask ), + static_cast( failOp ), + static_cast( passOp ), + static_cast( depthFailOp ), + static_cast( compareOp ) ); + } + + // wrapper function for command vkCmdSetRasterizerDiscardEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html + VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizerDiscardEnable && + "Function requires or or " ); + + getDispatcher()->vkCmdSetRasterizerDiscardEnable( static_cast( m_commandBuffer ), static_cast( rasterizerDiscardEnable ) ); + } + + // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable( Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBiasEnable && + "Function requires or or " ); + + getDispatcher()->vkCmdSetDepthBiasEnable( static_cast( m_commandBuffer ), static_cast( depthBiasEnable ) ); + } + + // wrapper function for command vkCmdSetPrimitiveRestartEnable, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html + VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable( Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveRestartEnable && + "Function requires or or " ); + + getDispatcher()->vkCmdSetPrimitiveRestartEnable( static_cast( m_commandBuffer ), static_cast( primitiveRestartEnable ) ); + } + + //=== VK_VERSION_1_4 === + + // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::mapMemory2( const MemoryMapInfo & memoryMapInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory2 && "Function requires or " ); + + void * pData; + Result result = static_cast( + getDispatcher()->vkMapMemory2( static_cast( m_device ), reinterpret_cast( &memoryMapInfo ), &pData ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::mapMemory2" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pData ) ); + } + + // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory2 && "Function requires or " ); + + Result result = static_cast( + getDispatcher()->vkUnmapMemory2( static_cast( m_device ), reinterpret_cast( &memoryUnmapInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::unmapMemory2" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetDeviceImageSubresourceLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 + Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayout && + "Function requires or " ); + + SubresourceLayout2 layout; + getDispatcher()->vkGetDeviceImageSubresourceLayout( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &layout ) ); + + return layout; + } + + // wrapper function for command vkGetDeviceImageSubresourceLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayout && + "Function requires or " ); + + StructureChain structureChain; + SubresourceLayout2 & layout = structureChain.template get(); + getDispatcher()->vkGetDeviceImageSubresourceLayout( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &layout ) ); + + return structureChain; + } + + // wrapper function for command vkGetImageSubresourceLayout2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Image::getSubresourceLayout2( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetImageSubresourceLayout2 && + "Function requires or or or " ); + + SubresourceLayout2 layout; + getDispatcher()->vkGetImageSubresourceLayout2( static_cast( m_device ), + static_cast( m_image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return layout; + } + + // wrapper function for command vkGetImageSubresourceLayout2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Image::getSubresourceLayout2( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetImageSubresourceLayout2 && + "Function requires or or or " ); + + StructureChain structureChain; + SubresourceLayout2 & layout = structureChain.template get(); + getDispatcher()->vkGetImageSubresourceLayout2( static_cast( m_device ), + static_cast( m_image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return structureChain; + } + + // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::copyMemoryToImage( const CopyMemoryToImageInfo & copyMemoryToImageInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToImage && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkCopyMemoryToImage( + static_cast( m_device ), reinterpret_cast( ©MemoryToImageInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMemoryToImage" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::copyImageToMemory( const CopyImageToMemoryInfo & copyImageToMemoryInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToMemory && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkCopyImageToMemory( + static_cast( m_device ), reinterpret_cast( ©ImageToMemoryInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyImageToMemory" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::copyImageToImage( const CopyImageToImageInfo & copyImageToImageInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToImage && "Function requires or " ); + + Result result = static_cast( + getDispatcher()->vkCopyImageToImage( static_cast( m_device ), reinterpret_cast( ©ImageToImageInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyImageToImage" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::transitionImageLayout( ArrayProxy const & transitions ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkTransitionImageLayout && + "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkTransitionImageLayout( + static_cast( m_device ), transitions.size(), reinterpret_cast( transitions.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::transitionImageLayout" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t set, + ArrayProxy const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSet && "Function requires or " ); + + getDispatcher()->vkCmdPushDescriptorSet( static_cast( m_commandBuffer ), + static_cast( pipelineBindPoint ), + static_cast( layout ), + set, + descriptorWrites.size(), + reinterpret_cast( descriptorWrites.data() ) ); + } + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html + template + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t set, + DataType const & data ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkCmdPushDescriptorSetWithTemplate && + "Function requires or or " ); + + getDispatcher()->vkCmdPushDescriptorSetWithTemplate( static_cast( m_commandBuffer ), + static_cast( descriptorUpdateTemplate ), + static_cast( layout ), + set, + reinterpret_cast( &data ) ); + } + + // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2( const BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorSets2 && + "Function requires or " ); + + getDispatcher()->vkCmdBindDescriptorSets2( static_cast( m_commandBuffer ), + reinterpret_cast( &bindDescriptorSetsInfo ) ); + } + + // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html + VULKAN_HPP_INLINE void CommandBuffer::pushConstants2( const PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushConstants2 && "Function requires or " ); + + getDispatcher()->vkCmdPushConstants2( static_cast( m_commandBuffer ), + reinterpret_cast( &pushConstantsInfo ) ); + } + + // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2( const PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSet2 && "Function requires or " ); + + getDispatcher()->vkCmdPushDescriptorSet2( static_cast( m_commandBuffer ), + reinterpret_cast( &pushDescriptorSetInfo ) ); + } + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html + VULKAN_HPP_INLINE void + CommandBuffer::pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetWithTemplate2 && + "Function requires or " ); + + getDispatcher()->vkCmdPushDescriptorSetWithTemplate2( + static_cast( m_commandBuffer ), reinterpret_cast( &pushDescriptorSetWithTemplateInfo ) ); + } + + // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html + VULKAN_HPP_INLINE void CommandBuffer::setLineStipple( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStipple && + "Function requires or or " ); + + getDispatcher()->vkCmdSetLineStipple( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); + } + + // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html + VULKAN_HPP_INLINE void + CommandBuffer::bindIndexBuffer2( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer2 && "Function requires or " ); + + getDispatcher()->vkCmdBindIndexBuffer2( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( size ), + static_cast( indexType ) ); + } + + // wrapper function for command vkGetRenderingAreaGranularity, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D Device::getRenderingAreaGranularity( const RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRenderingAreaGranularity && + "Function requires or " ); + + Extent2D granularity; + getDispatcher()->vkGetRenderingAreaGranularity( static_cast( m_device ), + reinterpret_cast( &renderingAreaInfo ), + reinterpret_cast( &granularity ) ); + + return granularity; + } + + // wrapper function for command vkCmdSetRenderingAttachmentLocations, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html + VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingAttachmentLocations && + "Function requires or " ); + + getDispatcher()->vkCmdSetRenderingAttachmentLocations( static_cast( m_commandBuffer ), + reinterpret_cast( &locationInfo ) ); + } + + // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html + VULKAN_HPP_INLINE void + CommandBuffer::setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingInputAttachmentIndices && + "Function requires or " ); + + getDispatcher()->vkCmdSetRenderingInputAttachmentIndices( static_cast( m_commandBuffer ), + reinterpret_cast( &inputAttachmentIndexInfo ) ); + } + + //=== VK_KHR_surface === + + // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR && "Function requires " ); + + Bool32 supported; + Result result = static_cast( getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR( static_cast( m_physicalDevice ), + queueFamilyIndex, + static_cast( surface ), + reinterpret_cast( &supported ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( supported ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR && + "Function requires " ); + + SurfaceCapabilitiesKHR surfaceCapabilities; + Result result = static_cast( + getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR( static_cast( m_physicalDevice ), + static_cast( surface ), + reinterpret_cast( &surfaceCapabilities ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceCapabilities ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR && "Function requires " ); + + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( + static_cast( m_physicalDevice ), static_cast( surface ), &surfaceFormatCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + surfaceFormats.resize( surfaceFormatCount ); + result = + static_cast( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast( m_physicalDevice ), + static_cast( surface ), + &surfaceFormatCount, + reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + if ( surfaceFormatCount < surfaceFormats.size() ) + { + surfaceFormats.resize( surfaceFormatCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceFormats ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR && + "Function requires " ); + + std::vector presentModes; + uint32_t presentModeCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( + static_cast( m_physicalDevice ), static_cast( surface ), &presentModeCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentModeCount ) + { + presentModes.resize( presentModeCount ); + result = + static_cast( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast( m_physicalDevice ), + static_cast( surface ), + &presentModeCount, + reinterpret_cast( presentModes.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + if ( presentModeCount < presentModes.size() ) + { + presentModes.resize( presentModeCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentModes ) ); + } + + //=== VK_KHR_swapchain === + + // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createSwapchainKHR( SwapchainCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSwapchainKHR && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; + Result result = static_cast( getDispatcher()->vkCreateSwapchainKHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &swapchain ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSwapchainKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SwapchainKHR( *this, *reinterpret_cast( &swapchain ), allocator ) ); + } + + // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type SwapchainKHR::getImages() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainImagesKHR && "Function requires " ); + + std::vector swapchainImages; + uint32_t swapchainImageCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetSwapchainImagesKHR( + static_cast( m_device ), static_cast( m_swapchainKHR ), &swapchainImageCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && swapchainImageCount ) + { + swapchainImages.resize( swapchainImageCount ); + result = static_cast( getDispatcher()->vkGetSwapchainImagesKHR( static_cast( m_device ), + static_cast( m_swapchainKHR ), + &swapchainImageCount, + reinterpret_cast( swapchainImages.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getImages" ); + VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); + if ( swapchainImageCount < swapchainImages.size() ) + { + swapchainImages.resize( swapchainImageCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( swapchainImages ) ); + } + + // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue + SwapchainKHR::acquireNextImage( uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImageKHR && "Function requires " ); + + uint32_t imageIndex; + Result result = static_cast( getDispatcher()->vkAcquireNextImageKHR( static_cast( m_device ), + static_cast( m_swapchainKHR ), + timeout, + static_cast( semaphore ), + static_cast( fence ), + &imageIndex ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::acquireNextImage", + { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::acquireNextImage", + { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); +# endif + + return ResultValue( result, std::move( imageIndex ) ); + } + + // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkQueuePresentKHR && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkQueuePresentKHR( static_cast( m_queue ), reinterpret_cast( &presentInfo ) ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); +# endif + + return static_cast( result ); + } + + // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getGroupPresentCapabilitiesKHR() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR && + "Function requires or " ); + + DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; + Result result = static_cast( getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR( + static_cast( m_device ), reinterpret_cast( &deviceGroupPresentCapabilities ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( deviceGroupPresentCapabilities ) ); + } + + // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR && + "Function requires or " ); + + DeviceGroupPresentModeFlagsKHR modes; + Result result = static_cast( getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR( + static_cast( m_device ), static_cast( surface ), reinterpret_cast( &modes ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( modes ) ); + } + + // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR && + "Function requires or " ); + + std::vector rects; + uint32_t rectCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR( + static_cast( m_physicalDevice ), static_cast( surface ), &rectCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && rectCount ) + { + rects.resize( rectCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR( static_cast( m_physicalDevice ), + static_cast( surface ), + &rectCount, + reinterpret_cast( rects.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); + VULKAN_HPP_ASSERT( rectCount <= rects.size() ); + if ( rectCount < rects.size() ) + { + rects.resize( rectCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( rects ) ); + } + + // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImage2KHR && "Function requires or " ); + + uint32_t imageIndex; + Result result = static_cast( getDispatcher()->vkAcquireNextImage2KHR( + static_cast( m_device ), reinterpret_cast( &acquireInfo ), &imageIndex ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::acquireNextImage2KHR", + { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::acquireNextImage2KHR", + { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); +# endif + + return ResultValue( result, std::move( imageIndex ) ); + } + + //=== VK_KHR_display === + + // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPropertiesKHR() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( + static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayPlanePropertiesKHR() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( + static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneSupportedDisplaysKHR && + "Function requires " ); + + std::vector displays; + uint32_t displayCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetDisplayPlaneSupportedDisplaysKHR( static_cast( m_physicalDevice ), planeIndex, &displayCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && displayCount ) + { + displays.resize( displayCount ); + result = static_cast( getDispatcher()->vkGetDisplayPlaneSupportedDisplaysKHR( + static_cast( m_physicalDevice ), planeIndex, &displayCount, reinterpret_cast( displays.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); + std::vector displaysRAII; + if ( result == Result::eSuccess ) + { + displaysRAII.reserve( displays.size() ); + for ( auto & display : displays ) + { + displaysRAII.emplace_back( *this, *reinterpret_cast( &display ) ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( displaysRAII ) ); + } + + // wrapper function for command vkGetDisplayModePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type DisplayKHR::getModeProperties() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModePropertiesKHR && "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetDisplayModePropertiesKHR( + static_cast( m_physicalDevice ), static_cast( m_displayKHR ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast( m_physicalDevice ), + static_cast( m_displayKHR ), + &propertyCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayKHR::getModeProperties" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + DisplayKHR::createMode( DisplayModeCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDisplayModeKHR && "Function requires " ); + + VULKAN_HPP_NAMESPACE::DisplayModeKHR mode; + Result result = static_cast( getDispatcher()->vkCreateDisplayModeKHR( static_cast( m_physicalDevice ), + static_cast( m_displayKHR ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &mode ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayKHR::createMode" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, DisplayModeKHR( *this, *reinterpret_cast( &mode ) ) ); + } + + // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + DisplayModeKHR::getDisplayPlaneCapabilities( uint32_t planeIndex ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR && "Function requires " ); + + DisplayPlaneCapabilitiesKHR capabilities; + Result result = + static_cast( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR( static_cast( m_physicalDevice ), + static_cast( m_displayModeKHR ), + planeIndex, + reinterpret_cast( &capabilities ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayModeKHR::getDisplayPlaneCapabilities" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( capabilities ) ); + } + + // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createDisplayPlaneSurfaceKHR( DisplaySurfaceCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDisplayPlaneSurfaceKHR && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = + static_cast( getDispatcher()->vkCreateDisplayPlaneSurfaceKHR( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } + + //=== VK_KHR_display_swapchain === + + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createSharedSwapchainsKHR( ArrayProxy const & createInfos, Optional allocator ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSharedSwapchainsKHR && "Function requires " ); + + std::vector swapchains( createInfos.size() ); + Result result = + static_cast( getDispatcher()->vkCreateSharedSwapchainsKHR( static_cast( m_device ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( swapchains.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); + std::vector swapchainsRAII; + if ( result == Result::eSuccess ) + { + swapchainsRAII.reserve( swapchains.size() ); + for ( auto & swapchain : swapchains ) + { + swapchainsRAII.emplace_back( *this, *reinterpret_cast( &swapchain ), allocator ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( swapchainsRAII ) ); + } + + // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createSharedSwapchainKHR( SwapchainCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSharedSwapchainsKHR && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; + Result result = static_cast( getDispatcher()->vkCreateSharedSwapchainsKHR( static_cast( m_device ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &swapchain ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SwapchainKHR( *this, *reinterpret_cast( &swapchain ), allocator ) ); + } + +# if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createXlibSurfaceKHR( XlibSurfaceCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateXlibSurfaceKHR && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateXlibSurfaceKHR( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } + + // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, + Display & dpy, + VisualID visualID ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR && + "Function requires " ); + + VkBool32 result = + getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex, &dpy, visualID ); + + return static_cast( result ); + } +# endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +# if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createXcbSurfaceKHR( XcbSurfaceCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateXcbSurfaceKHR && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateXcbSurfaceKHR( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } + + // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, + xcb_connection_t & connection, + xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR && + "Function requires " ); + + VkBool32 result = getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR( + static_cast( m_physicalDevice ), queueFamilyIndex, &connection, visual_id ); + + return static_cast( result ); + } +# endif /*VK_USE_PLATFORM_XCB_KHR*/ + +# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createWaylandSurfaceKHR( WaylandSurfaceCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateWaylandSurfaceKHR && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateWaylandSurfaceKHR( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } + + // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, + struct wl_display & display ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR && + "Function requires " ); + + VkBool32 result = + getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex, &display ); + + return static_cast( result ); + } +# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createAndroidSurfaceKHR( AndroidSurfaceCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateAndroidSurfaceKHR && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateAndroidSurfaceKHR( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createWin32SurfaceKHR( Win32SurfaceCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateWin32SurfaceKHR && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateWin32SurfaceKHR( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } + + // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR && + "Function requires " ); + + VkBool32 result = getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex ); + + return static_cast( result ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + + // wrapper function for command vkCreateDebugReportCallbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createDebugReportCallbackEXT( DebugReportCallbackCreateInfoEXT const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDebugReportCallbackEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback; + Result result = + static_cast( getDispatcher()->vkCreateDebugReportCallbackEXT( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &callback ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, DebugReportCallbackEXT( *this, *reinterpret_cast( &callback ), allocator ) ); + } + + // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html + VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, + DebugReportObjectTypeEXT objectType_, + uint64_t object, + size_t location, + int32_t messageCode, + const std::string & layerPrefix, + const std::string & message ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkDebugReportMessageEXT && "Function requires " ); + + getDispatcher()->vkDebugReportMessageEXT( static_cast( m_instance ), + static_cast( flags ), + static_cast( objectType_ ), + object, + location, + messageCode, + layerPrefix.c_str(), + message.c_str() ); + } + + //=== VK_EXT_debug_marker === + + // wrapper function for command vkDebugMarkerSetObjectTagEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectTagEXT && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkDebugMarkerSetObjectTagEXT( + static_cast( m_device ), reinterpret_cast( &tagInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkDebugMarkerSetObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectNameEXT && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkDebugMarkerSetObjectNameEXT( + static_cast( m_device ), reinterpret_cast( &nameInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerBeginEXT && "Function requires " ); + + getDispatcher()->vkCmdDebugMarkerBeginEXT( static_cast( m_commandBuffer ), + reinterpret_cast( &markerInfo ) ); + } + + // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerEndEXT && "Function requires " ); + + getDispatcher()->vkCmdDebugMarkerEndEXT( static_cast( m_commandBuffer ) ); + } + + // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html + VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerInsertEXT && "Function requires " ); + + getDispatcher()->vkCmdDebugMarkerInsertEXT( static_cast( m_commandBuffer ), + reinterpret_cast( &markerInfo ) ); + } + + //=== VK_KHR_video_queue === + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR * pVideoProfile, + VideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR && + "Function requires " ); + return static_cast( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( pVideoProfile ), + reinterpret_cast( pCapabilities ) ) ); + } + + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR && + "Function requires " ); + + VideoCapabilitiesKHR capabilities; + Result result = + static_cast( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( &videoProfile ), + reinterpret_cast( &capabilities ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( capabilities ) ); + } + + // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR && + "Function requires " ); + + StructureChain structureChain; + VideoCapabilitiesKHR & capabilities = structureChain.template get(); + Result result = + static_cast( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( &videoProfile ), + reinterpret_cast( &capabilities ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); + } + + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR && + "Function requires " ); + + std::vector videoFormatProperties; + uint32_t videoFormatPropertyCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( &videoFormatInfo ), + &videoFormatPropertyCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) + { + videoFormatProperties.resize( videoFormatPropertyCount ); + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( &videoFormatInfo ), + &videoFormatPropertyCount, + reinterpret_cast( videoFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); + VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); + if ( videoFormatPropertyCount < videoFormatProperties.size() ) + { + videoFormatProperties.resize( videoFormatPropertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( videoFormatProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR && + "Function requires " ); + + std::vector structureChains; + std::vector videoFormatProperties; + uint32_t videoFormatPropertyCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( &videoFormatInfo ), + &videoFormatPropertyCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) + { + structureChains.resize( videoFormatPropertyCount ); + videoFormatProperties.resize( videoFormatPropertyCount ); + for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) + { + videoFormatProperties[i].pNext = structureChains[i].template get().pNext; + } + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( &videoFormatInfo ), + &videoFormatPropertyCount, + reinterpret_cast( videoFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); + VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); + if ( videoFormatPropertyCount < videoFormatProperties.size() ) + { + structureChains.resize( videoFormatPropertyCount ); + } + for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) + { + structureChains[i].template get() = videoFormatProperties[i]; + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChains ) ); + } + + // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createVideoSessionKHR( VideoSessionCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateVideoSessionKHR && "Function requires " ); + + VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession; + Result result = static_cast( getDispatcher()->vkCreateVideoSessionKHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &videoSession ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createVideoSessionKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, VideoSessionKHR( *this, *reinterpret_cast( &videoSession ), allocator ) ); + } + + // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + VideoSessionKHR::getMemoryRequirements() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR && + "Function requires " ); + + std::vector memoryRequirements; + uint32_t memoryRequirementsCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( + static_cast( m_device ), static_cast( m_videoSessionKHR ), &memoryRequirementsCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && memoryRequirementsCount ) + { + memoryRequirements.resize( memoryRequirementsCount ); + result = static_cast( + getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast( m_device ), + static_cast( m_videoSessionKHR ), + &memoryRequirementsCount, + reinterpret_cast( memoryRequirements.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::VideoSessionKHR::getMemoryRequirements" ); + VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() ); + if ( memoryRequirementsCount < memoryRequirements.size() ) + { + memoryRequirements.resize( memoryRequirementsCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryRequirements ) ); + } + + // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html + VULKAN_HPP_INLINE typename ResultValueType::type + VideoSessionKHR::bindMemory( ArrayProxy const & bindSessionMemoryInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBindVideoSessionMemoryKHR && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkBindVideoSessionMemoryKHR( static_cast( m_device ), + static_cast( m_videoSessionKHR ), + bindSessionMemoryInfos.size(), + reinterpret_cast( bindSessionMemoryInfos.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::VideoSessionKHR::bindMemory" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCreateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createVideoSessionParametersKHR( VideoSessionParametersCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateVideoSessionParametersKHR && "Function requires " ); + + VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters; + Result result = + static_cast( getDispatcher()->vkCreateVideoSessionParametersKHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &videoSessionParameters ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, VideoSessionParametersKHR( *this, *reinterpret_cast( &videoSessionParameters ), allocator ) ); + } + + // wrapper function for command vkUpdateVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html + VULKAN_HPP_INLINE typename ResultValueType::type VideoSessionParametersKHR::update( const VideoSessionParametersUpdateInfoKHR & updateInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateVideoSessionParametersKHR && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkUpdateVideoSessionParametersKHR( static_cast( m_device ), + static_cast( m_videoSessionParametersKHR ), + reinterpret_cast( &updateInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::VideoSessionParametersKHR::update" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html + VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginVideoCodingKHR && "Function requires " ); + + getDispatcher()->vkCmdBeginVideoCodingKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &beginInfo ) ); + } + + // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html + VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndVideoCodingKHR && "Function requires " ); + + getDispatcher()->vkCmdEndVideoCodingKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &endCodingInfo ) ); + } + + // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html + VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdControlVideoCodingKHR && "Function requires " ); + + getDispatcher()->vkCmdControlVideoCodingKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &codingControlInfo ) ); + } + + //=== VK_KHR_video_decode_queue === + + // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html + VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR & decodeInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecodeVideoKHR && "Function requires " ); + + getDispatcher()->vkCmdDecodeVideoKHR( static_cast( m_commandBuffer ), reinterpret_cast( &decodeInfo ) ); + } + + //=== VK_EXT_transform_feedback === + + // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html + VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT && + "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); + VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); +# else + if ( buffers.size() != offsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); + } + if ( !sizes.empty() && buffers.size() != sizes.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT( static_cast( m_commandBuffer ), + firstBinding, + buffers.size(), + reinterpret_cast( buffers.data() ), + reinterpret_cast( offsets.data() ), + reinterpret_cast( sizes.data() ) ); + } + + // wrapper function for command vkCmdBeginTransformFeedbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html + VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, + ArrayProxy const & counterBuffers, + ArrayProxy const & counterBufferOffsets ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginTransformFeedbackEXT && "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); +# else + if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdBeginTransformFeedbackEXT( static_cast( m_commandBuffer ), + firstCounterBuffer, + counterBuffers.size(), + reinterpret_cast( counterBuffers.data() ), + reinterpret_cast( counterBufferOffsets.data() ) ); + } + + // wrapper function for command vkCmdEndTransformFeedbackEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html + VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, + ArrayProxy const & counterBuffers, + ArrayProxy const & counterBufferOffsets ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndTransformFeedbackEXT && "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); +# else + if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdEndTransformFeedbackEXT( static_cast( m_commandBuffer ), + firstCounterBuffer, + counterBuffers.size(), + reinterpret_cast( counterBuffers.data() ), + reinterpret_cast( counterBufferOffsets.data() ) ); + } + + // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html + VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t query, + QueryControlFlags flags, + uint32_t index ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQueryIndexedEXT && "Function requires " ); + + getDispatcher()->vkCmdBeginQueryIndexedEXT( + static_cast( m_commandBuffer ), static_cast( queryPool ), query, static_cast( flags ), index ); + } + + // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html + VULKAN_HPP_INLINE void + CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQueryIndexedEXT && "Function requires " ); + + getDispatcher()->vkCmdEndQueryIndexedEXT( static_cast( m_commandBuffer ), static_cast( queryPool ), query, index ); + } + + // wrapper function for command vkCmdDrawIndirectByteCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, + uint32_t firstInstance, + VULKAN_HPP_NAMESPACE::Buffer counterBuffer, + DeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectByteCountEXT && "Function requires " ); + + getDispatcher()->vkCmdDrawIndirectByteCountEXT( static_cast( m_commandBuffer ), + instanceCount, + firstInstance, + static_cast( counterBuffer ), + static_cast( counterBufferOffset ), + counterOffset, + vertexStride ); + } + + //=== VK_NVX_binary_import === + + // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createCuModuleNVX( CuModuleCreateInfoNVX const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateCuModuleNVX && "Function requires " ); + + VULKAN_HPP_NAMESPACE::CuModuleNVX module; + Result result = static_cast( getDispatcher()->vkCreateCuModuleNVX( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &module ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createCuModuleNVX" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, CuModuleNVX( *this, *reinterpret_cast( &module ), allocator ) ); + } + + // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createCuFunctionNVX( CuFunctionCreateInfoNVX const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateCuFunctionNVX && "Function requires " ); + + VULKAN_HPP_NAMESPACE::CuFunctionNVX function; + Result result = static_cast( getDispatcher()->vkCreateCuFunctionNVX( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &function ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createCuFunctionNVX" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, + CuFunctionNVX( *this, *reinterpret_cast( &function ), allocator ) ); + } + + // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html + VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCuLaunchKernelNVX && "Function requires " ); + + getDispatcher()->vkCmdCuLaunchKernelNVX( static_cast( m_commandBuffer ), reinterpret_cast( &launchInfo ) ); + } + + //=== VK_NVX_image_view_handle === + + // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewHandleNVX && "Function requires " ); + + uint32_t result = + getDispatcher()->vkGetImageViewHandleNVX( static_cast( m_device ), reinterpret_cast( &info ) ); + + return result; + } + + // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewHandle64NVX && "Function requires " ); + + uint64_t result = + getDispatcher()->vkGetImageViewHandle64NVX( static_cast( m_device ), reinterpret_cast( &info ) ); + + return result; + } + + // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type ImageView::getAddressNVX() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewAddressNVX && "Function requires " ); + + ImageViewAddressPropertiesNVX properties; + Result result = static_cast( getDispatcher()->vkGetImageViewAddressNVX( + static_cast( m_device ), static_cast( m_imageView ), reinterpret_cast( &properties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::ImageView::getAddressNVX" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex, + uint64_t samplerIndex ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceCombinedImageSamplerIndexNVX && + "Function requires " ); + + uint64_t result = getDispatcher()->vkGetDeviceCombinedImageSamplerIndexNVX( static_cast( m_device ), imageViewIndex, samplerIndex ); + + return result; + } + + //=== VK_AMD_draw_indirect_count === + + // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountAMD && + "Function requires or or " ); + + getDispatcher()->vkCmdDrawIndirectCountAMD( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkCmdDrawIndexedIndirectCountAMD && + "Function requires or or " ); + + getDispatcher()->vkCmdDrawIndexedIndirectCountAMD( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + //=== VK_AMD_shader_info === + + // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Pipeline::getShaderInfoAMD( ShaderStageFlagBits shaderStage, + ShaderInfoTypeAMD infoType ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderInfoAMD && "Function requires " ); + + std::vector info; + size_t infoSize; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetShaderInfoAMD( static_cast( m_device ), + static_cast( m_pipeline ), + static_cast( shaderStage ), + static_cast( infoType ), + &infoSize, + nullptr ) ); + if ( ( result == Result::eSuccess ) && infoSize ) + { + info.resize( infoSize ); + result = static_cast( getDispatcher()->vkGetShaderInfoAMD( static_cast( m_device ), + static_cast( m_pipeline ), + static_cast( shaderStage ), + static_cast( infoType ), + &infoSize, + reinterpret_cast( info.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getShaderInfoAMD" ); + VULKAN_HPP_ASSERT( infoSize <= info.size() ); + if ( infoSize < info.size() ) + { + info.resize( infoSize ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( info ) ); + } + + //=== VK_KHR_dynamic_rendering === + + // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html + VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderingKHR && + "Function requires or " ); + + getDispatcher()->vkCmdBeginRenderingKHR( static_cast( m_commandBuffer ), reinterpret_cast( &renderingInfo ) ); + } + + // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html + VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderingKHR && "Function requires or " ); + + getDispatcher()->vkCmdEndRenderingKHR( static_cast( m_commandBuffer ) ); + } + +# if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createStreamDescriptorSurfaceGGP( StreamDescriptorSurfaceCreateInfoGGP const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateStreamDescriptorSurfaceGGP && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( + getDispatcher()->vkCreateStreamDescriptorSurfaceGGP( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } +# endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, + ImageType type, + ImageTiling tiling, + ImageUsageFlags usage, + ImageCreateFlags flags, + ExternalMemoryHandleTypeFlagsNV externalHandleType ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV && + "Function requires " ); + + ExternalImageFormatPropertiesNV externalImageFormatProperties; + Result result = static_cast( getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV( + static_cast( m_physicalDevice ), + static_cast( format ), + static_cast( type ), + static_cast( tiling ), + static_cast( usage ), + static_cast( flags ), + static_cast( externalHandleType ), + reinterpret_cast( &externalImageFormatProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( externalImageFormatProperties ) ); + } + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_external_memory_win32 === + + // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + DeviceMemory::getMemoryWin32HandleNV( ExternalMemoryHandleTypeFlagsNV handleType ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleNV && "Function requires " ); + + HANDLE handle; + Result result = static_cast( getDispatcher()->vkGetMemoryWin32HandleNV( static_cast( m_device ), + static_cast( m_deviceMemory ), + static_cast( handleType ), + &handle ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_get_physical_device_properties2 === + + // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2KHR && + "Function requires or " ); + + PhysicalDeviceFeatures2 features; + getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &features ) ); + + return features; + } + + // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2KHR && + "Function requires or " ); + + StructureChain structureChain; + PhysicalDeviceFeatures2 & features = structureChain.template get(); + getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &features ) ); + + return structureChain; + } + + // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2KHR && + "Function requires or " ); + + PhysicalDeviceProperties2 properties; + getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &properties ) ); + + return properties; + } + + // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2KHR && + "Function requires or " ); + + StructureChain structureChain; + PhysicalDeviceProperties2 & properties = structureChain.template get(); + getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &properties ) ); + + return structureChain; + } + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2KHR( Format format ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR && + "Function requires or " ); + + FormatProperties2 formatProperties; + getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR( + static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); + + return formatProperties; + } + + // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFormatProperties2KHR( Format format ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR && + "Function requires or " ); + + StructureChain structureChain; + FormatProperties2 & formatProperties = structureChain.template get(); + getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR( + static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); + + return structureChain; + } + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( + const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, ImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR && + "Function requires or " ); + return static_cast( + getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( pImageFormatInfo ), + reinterpret_cast( pImageFormatProperties ) ) ); + } + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR && + "Function requires or " ); + + ImageFormatProperties2 imageFormatProperties; + Result result = static_cast( + getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &imageFormatInfo ), + reinterpret_cast( &imageFormatProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR && + "Function requires or " ); + + StructureChain structureChain; + ImageFormatProperties2 & imageFormatProperties = structureChain.template get(); + Result result = static_cast( + getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &imageFormatInfo ), + reinterpret_cast( &imageFormatProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2KHR() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR && + "Function requires or " ); + + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast( m_physicalDevice ), + &queueFamilyPropertyCount, + reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + queueFamilyProperties.resize( queueFamilyPropertyCount ); + } + return queueFamilyProperties; + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2KHR() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR && + "Function requires or " ); + + std::vector structureChains; + std::vector queueFamilyProperties; + uint32_t queueFamilyPropertyCount; + getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); + structureChains.resize( queueFamilyPropertyCount ); + queueFamilyProperties.resize( queueFamilyPropertyCount ); + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; + } + getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast( m_physicalDevice ), + &queueFamilyPropertyCount, + reinterpret_cast( queueFamilyProperties.data() ) ); + + VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); + if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) + { + structureChains.resize( queueFamilyPropertyCount ); + } + for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) + { + structureChains[i].template get() = queueFamilyProperties[i]; + } + return structureChains; + } + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR && + "Function requires or " ); + + PhysicalDeviceMemoryProperties2 memoryProperties; + getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &memoryProperties ) ); + + return memoryProperties; + } + + // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR && + "Function requires or " ); + + StructureChain structureChain; + PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get(); + getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &memoryProperties ) ); + + return structureChain; + } + + // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR && + "Function requires or " ); + + std::vector properties; + uint32_t propertyCount; + getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &formatInfo ), + &propertyCount, + nullptr ); + properties.resize( propertyCount ); + getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &formatInfo ), + &propertyCount, + reinterpret_cast( properties.data() ) ); + + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return properties; + } + + //=== VK_KHR_device_group === + + // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR && + "Function requires or " ); + + PeerMemoryFeatureFlags peerMemoryFeatures; + getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR( static_cast( m_device ), + heapIndex, + localDeviceIndex, + remoteDeviceIndex, + reinterpret_cast( &peerMemoryFeatures ) ); + + return peerMemoryFeatures; + } + + // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html + VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMaskKHR && "Function requires or " ); + + getDispatcher()->vkCmdSetDeviceMaskKHR( static_cast( m_commandBuffer ), deviceMask ); + } + + // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html + VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBaseKHR && "Function requires or " ); + + getDispatcher()->vkCmdDispatchBaseKHR( + static_cast( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); + } + +# if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createViSurfaceNN( ViSurfaceCreateInfoNN const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateViSurfaceNN && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateViSurfaceNN( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createViSurfaceNN" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } +# endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_KHR_maintenance1 === + + // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html + VULKAN_HPP_INLINE void CommandPool::trimKHR( CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPoolKHR && "Function requires or " ); + + getDispatcher()->vkTrimCommandPoolKHR( + static_cast( m_device ), static_cast( m_commandPool ), static_cast( flags ) ); + } + + //=== VK_KHR_device_group_creation === + + // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Instance::enumeratePhysicalDeviceGroupsKHR() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR && + "Function requires or " ); + + std::vector physicalDeviceGroupProperties; + uint32_t physicalDeviceGroupCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( static_cast( m_instance ), &physicalDeviceGroupCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + result = static_cast( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( + static_cast( m_instance ), + &physicalDeviceGroupCount, + reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); + VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); + if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) + { + physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); + } + + //=== VK_KHR_external_memory_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalBufferProperties + PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR && + "Function requires or " ); + + ExternalBufferProperties externalBufferProperties; + getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( &externalBufferInfo ), + reinterpret_cast( &externalBufferProperties ) ); + + return externalBufferProperties; + } + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_memory_win32 === + + // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleKHR && "Function requires " ); + + HANDLE handle; + Result result = static_cast( getDispatcher()->vkGetMemoryWin32HandleKHR( + static_cast( m_device ), reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); + } + + // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR && + "Function requires " ); + + MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; + Result result = static_cast( + getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR( static_cast( m_device ), + static_cast( handleType ), + handle, + reinterpret_cast( &memoryWin32HandleProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryWin32HandleProperties ) ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_memory_fd === + + // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdKHR && "Function requires " ); + + int fd; + Result result = static_cast( + getDispatcher()->vkGetMemoryFdKHR( static_cast( m_device ), reinterpret_cast( &getFdInfo ), &fd ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fd ) ); + } + + // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdPropertiesKHR && "Function requires " ); + + MemoryFdPropertiesKHR memoryFdProperties; + Result result = static_cast( getDispatcher()->vkGetMemoryFdPropertiesKHR( static_cast( m_device ), + static_cast( handleType ), + fd, + reinterpret_cast( &memoryFdProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryFdProperties ) ); + } + + //=== VK_KHR_external_semaphore_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalSemaphoreProperties + PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR && + "Function requires or " ); + + ExternalSemaphoreProperties externalSemaphoreProperties; + getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( + static_cast( m_physicalDevice ), + reinterpret_cast( &externalSemaphoreInfo ), + reinterpret_cast( &externalSemaphoreProperties ) ); + + return externalSemaphoreProperties; + } + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_semaphore_win32 === + + // wrapper function for command vkImportSemaphoreWin32HandleKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreWin32HandleKHR && + "Function requires " ); + + Result result = static_cast( getDispatcher()->vkImportSemaphoreWin32HandleKHR( + static_cast( m_device ), reinterpret_cast( &importSemaphoreWin32HandleInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetSemaphoreWin32HandleKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreWin32HandleKHR && + "Function requires " ); + + HANDLE handle; + Result result = static_cast( getDispatcher()->vkGetSemaphoreWin32HandleKHR( + static_cast( m_device ), reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_semaphore_fd === + + // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreFdKHR && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkImportSemaphoreFdKHR( + static_cast( m_device ), reinterpret_cast( &importSemaphoreFdInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreFdKHR && "Function requires " ); + + int fd; + Result result = static_cast( + getDispatcher()->vkGetSemaphoreFdKHR( static_cast( m_device ), reinterpret_cast( &getFdInfo ), &fd ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fd ) ); + } + + //=== VK_KHR_push_descriptor === + + // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t set, + ArrayProxy const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetKHR && + "Function requires or " ); + + getDispatcher()->vkCmdPushDescriptorSetKHR( static_cast( m_commandBuffer ), + static_cast( pipelineBindPoint ), + static_cast( layout ), + set, + descriptorWrites.size(), + reinterpret_cast( descriptorWrites.data() ) ); + } + + // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html + template + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t set, + DataType const & data ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR && + "Function requires or or " ); + + getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR( static_cast( m_commandBuffer ), + static_cast( descriptorUpdateTemplate ), + static_cast( layout ), + set, + reinterpret_cast( &data ) ); + } + + //=== VK_EXT_conditional_rendering === + + // wrapper function for command vkCmdBeginConditionalRenderingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html + VULKAN_HPP_INLINE void + CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginConditionalRenderingEXT && + "Function requires " ); + + getDispatcher()->vkCmdBeginConditionalRenderingEXT( static_cast( m_commandBuffer ), + reinterpret_cast( &conditionalRenderingBegin ) ); + } + + // wrapper function for command vkCmdEndConditionalRenderingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html + VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndConditionalRenderingEXT && + "Function requires " ); + + getDispatcher()->vkCmdEndConditionalRenderingEXT( static_cast( m_commandBuffer ) ); + } + + //=== VK_KHR_descriptor_update_template === + + // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDescriptorUpdateTemplateKHR && + "Function requires or " ); + + VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; + Result result = static_cast( + getDispatcher()->vkCreateDescriptorUpdateTemplateKHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &descriptorUpdateTemplate ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, DescriptorUpdateTemplate( *this, *reinterpret_cast( &descriptorUpdateTemplate ), allocator ) ); + } + + // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html + VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, + Optional allocator ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR && + "Function requires or " ); + + getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR( static_cast( m_device ), + static_cast( descriptorUpdateTemplate ), + reinterpret_cast( allocator.get() ) ); + } + + // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html + template + VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, + DataType const & data ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR && + "Function requires or " ); + + getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR( static_cast( m_device ), + static_cast( m_descriptorSet ), + static_cast( descriptorUpdateTemplate ), + reinterpret_cast( &data ) ); + } + + //=== VK_NV_clip_space_w_scaling === + + // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html + VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, + ArrayProxy const & viewportWScalings ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWScalingNV && "Function requires " ); + + getDispatcher()->vkCmdSetViewportWScalingNV( static_cast( m_commandBuffer ), + firstViewport, + viewportWScalings.size(), + reinterpret_cast( viewportWScalings.data() ) ); + } + +# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + //=== VK_EXT_acquire_xlib_display === + + // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, + VULKAN_HPP_NAMESPACE::DisplayKHR display ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireXlibDisplayEXT && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkAcquireXlibDisplayEXT( static_cast( m_physicalDevice ), &dpy, static_cast( display ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRandROutputDisplayEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::DisplayKHR display; + Result result = static_cast( getDispatcher()->vkGetRandROutputDisplayEXT( + static_cast( m_physicalDevice ), &dpy, rrOutput, reinterpret_cast( &display ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, DisplayKHR( *this, *reinterpret_cast( &display ) ) ); + } +# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + + //=== VK_EXT_display_surface_counter === + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT && + "Function requires " ); + + SurfaceCapabilities2EXT surfaceCapabilities; + Result result = static_cast( + getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT( static_cast( m_physicalDevice ), + static_cast( surface ), + reinterpret_cast( &surfaceCapabilities ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceCapabilities ) ); + } + + //=== VK_EXT_display_control === + + // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, + const DisplayPowerInfoEXT & displayPowerInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkDisplayPowerControlEXT && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkDisplayPowerControlEXT( + static_cast( m_device ), static_cast( display ), reinterpret_cast( &displayPowerInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::displayPowerControlEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::registerEventEXT( DeviceEventInfoEXT const & deviceEventInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkRegisterDeviceEventEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Fence fence; + Result result = static_cast( getDispatcher()->vkRegisterDeviceEventEXT( static_cast( m_device ), + reinterpret_cast( &deviceEventInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &fence ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::registerEventEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Fence( *this, *reinterpret_cast( &fence ), allocator ) ); + } + + // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::registerDisplayEventEXT( DisplayKHR const & display, + DisplayEventInfoEXT const & displayEventInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkRegisterDisplayEventEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Fence fence; + Result result = static_cast( getDispatcher()->vkRegisterDisplayEventEXT( static_cast( m_device ), + static_cast( *display ), + reinterpret_cast( &displayEventInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &fence ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::registerDisplayEventEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Fence( *this, *reinterpret_cast( &fence ), allocator ) ); + } + + // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + ResultValue +# else + typename ResultValueType::type +# endif + SwapchainKHR::getCounterEXT( SurfaceCounterFlagBitsEXT counter ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainCounterEXT && "Function requires " ); + + uint64_t counterValue; + Result result = static_cast( getDispatcher()->vkGetSwapchainCounterEXT( static_cast( m_device ), + static_cast( m_swapchainKHR ), + static_cast( counter ), + &counterValue ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT", { Result::eSuccess, Result::eErrorOutOfDateKHR } ); +# else + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT" ); +# endif + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + return ResultValue( result, std::move( counterValue ) ); +# else + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( counterValue ) ); +# endif + } + + //=== VK_GOOGLE_display_timing === + + // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type SwapchainKHR::getRefreshCycleDurationGOOGLE() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRefreshCycleDurationGOOGLE && "Function requires " ); + + RefreshCycleDurationGOOGLE displayTimingProperties; + Result result = + static_cast( getDispatcher()->vkGetRefreshCycleDurationGOOGLE( static_cast( m_device ), + static_cast( m_swapchainKHR ), + reinterpret_cast( &displayTimingProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( displayTimingProperties ) ); + } + + // wrapper function for command vkGetPastPresentationTimingGOOGLE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + ResultValue> +# else + typename ResultValueType>::type +# endif + SwapchainKHR::getPastPresentationTimingGOOGLE() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPastPresentationTimingGOOGLE && + "Function requires " ); + + std::vector presentationTimings; + uint32_t presentationTimingCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPastPresentationTimingGOOGLE( + static_cast( m_device ), static_cast( m_swapchainKHR ), &presentationTimingCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && presentationTimingCount ) + { + presentationTimings.resize( presentationTimingCount ); + result = static_cast( + getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast( m_device ), + static_cast( m_swapchainKHR ), + &presentationTimingCount, + reinterpret_cast( presentationTimings.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getPastPresentationTimingGOOGLE", + { Result::eSuccess, Result::eIncomplete, Result::eErrorOutOfDateKHR } ); +# else + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getPastPresentationTimingGOOGLE" ); +# endif + + VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); + if ( presentationTimingCount < presentationTimings.size() ) + { + presentationTimings.resize( presentationTimingCount ); + } + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + return ResultValue>( result, std::move( presentationTimings ) ); +# else + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentationTimings ) ); +# endif + } + + //=== VK_EXT_discard_rectangles === + + // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, + ArrayProxy const & discardRectangles ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleEXT && "Function requires " ); + + getDispatcher()->vkCmdSetDiscardRectangleEXT( static_cast( m_commandBuffer ), + firstDiscardRectangle, + discardRectangles.size(), + reinterpret_cast( discardRectangles.data() ) ); + } + + // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEnableEXT( Bool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleEnableEXT && + "Function requires " ); + + getDispatcher()->vkCmdSetDiscardRectangleEnableEXT( static_cast( m_commandBuffer ), static_cast( discardRectangleEnable ) ); + } + + // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleModeEXT( DiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleModeEXT && + "Function requires " ); + + getDispatcher()->vkCmdSetDiscardRectangleModeEXT( static_cast( m_commandBuffer ), + static_cast( discardRectangleMode ) ); + } + + //=== VK_EXT_hdr_metadata === + + // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html + VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy const & swapchains, + ArrayProxy const & metadata ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetHdrMetadataEXT && "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); +# else + if ( swapchains.size() != metadata.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkSetHdrMetadataEXT( static_cast( m_device ), + swapchains.size(), + reinterpret_cast( swapchains.data() ), + reinterpret_cast( metadata.data() ) ); + } + + //=== VK_KHR_create_renderpass2 === + + // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createRenderPass2KHR( RenderPassCreateInfo2 const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRenderPass2KHR && + "Function requires or " ); + + VULKAN_HPP_NAMESPACE::RenderPass renderPass; + Result result = static_cast( getDispatcher()->vkCreateRenderPass2KHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &renderPass ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRenderPass2KHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, RenderPass( *this, *reinterpret_cast( &renderPass ), allocator ) ); + } + + // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, + const SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2KHR && + "Function requires or " ); + + getDispatcher()->vkCmdBeginRenderPass2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &renderPassBegin ), + reinterpret_cast( &subpassBeginInfo ) ); + } + + // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo, + const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2KHR && "Function requires or " ); + + getDispatcher()->vkCmdNextSubpass2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &subpassBeginInfo ), + reinterpret_cast( &subpassEndInfo ) ); + } + + // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2KHR && + "Function requires or " ); + + getDispatcher()->vkCmdEndRenderPass2KHR( static_cast( m_commandBuffer ), reinterpret_cast( &subpassEndInfo ) ); + } + + //=== VK_KHR_shared_presentable_image === + + // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::getStatus() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainStatusKHR && "Function requires " ); + + Result result = + static_cast( getDispatcher()->vkGetSwapchainStatusKHR( static_cast( m_device ), static_cast( m_swapchainKHR ) ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getStatus", { Result::eSuccess, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getStatus", { Result::eSuccess, Result::eSuboptimalKHR } ); +# endif + + return static_cast( result ); + } + + //=== VK_KHR_external_fence_capabilities === + + // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalFenceProperties + PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR && + "Function requires or " ); + + ExternalFenceProperties externalFenceProperties; + getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR( static_cast( m_physicalDevice ), + reinterpret_cast( &externalFenceInfo ), + reinterpret_cast( &externalFenceProperties ) ); + + return externalFenceProperties; + } + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_external_fence_win32 === + + // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceWin32HandleKHR && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkImportFenceWin32HandleKHR( + static_cast( m_device ), reinterpret_cast( &importFenceWin32HandleInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceWin32HandleKHR && "Function requires " ); + + HANDLE handle; + Result result = static_cast( getDispatcher()->vkGetFenceWin32HandleKHR( + static_cast( m_device ), reinterpret_cast( &getWin32HandleInfo ), &handle ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_KHR_external_fence_fd === + + // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceFdKHR && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkImportFenceFdKHR( static_cast( m_device ), reinterpret_cast( &importFenceFdInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::importFenceFdKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceFdKHR && "Function requires " ); + + int fd; + Result result = static_cast( + getDispatcher()->vkGetFenceFdKHR( static_cast( m_device ), reinterpret_cast( &getFdInfo ), &fd ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getFenceFdKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fd ) ); + } + + //=== VK_KHR_performance_query === + + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, std::vector>>::type + PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && + "Function requires " ); + + std::pair, std::vector> data_; + std::vector & counters = data_.first; + std::vector & counterDescriptions = data_.second; + uint32_t counterCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + static_cast( m_physicalDevice ), queueFamilyIndex, &counterCount, nullptr, nullptr ) ); + if ( ( result == Result::eSuccess ) && counterCount ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + result = static_cast( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + static_cast( m_physicalDevice ), + queueFamilyIndex, + &counterCount, + reinterpret_cast( counters.data() ), + reinterpret_cast( counterDescriptions.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); + VULKAN_HPP_ASSERT( counterCount <= counters.size() ); + if ( counterCount < counters.size() ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t + PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR && + "Function requires " ); + + uint32_t numPasses; + getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + static_cast( m_physicalDevice ), + reinterpret_cast( &performanceQueryCreateInfo ), + &numPasses ); + + return numPasses; + } + + // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireProfilingLockKHR && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkAcquireProfilingLockKHR( static_cast( m_device ), reinterpret_cast( &info ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html + VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseProfilingLockKHR && "Function requires " ); + + getDispatcher()->vkReleaseProfilingLockKHR( static_cast( m_device ) ); + } + + //=== VK_KHR_get_surface_capabilities2 === + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( + const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, SurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR && + "Function requires " ); + return static_cast( + getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( pSurfaceInfo ), + reinterpret_cast( pSurfaceCapabilities ) ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR && + "Function requires " ); + + SurfaceCapabilities2KHR surfaceCapabilities; + Result result = static_cast( + getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &surfaceInfo ), + reinterpret_cast( &surfaceCapabilities ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceCapabilities ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR && + "Function requires " ); + + StructureChain structureChain; + SurfaceCapabilities2KHR & surfaceCapabilities = structureChain.template get(); + Result result = static_cast( + getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &surfaceInfo ), + reinterpret_cast( &surfaceCapabilities ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR && + "Function requires " ); + + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &surfaceInfo ), + &surfaceFormatCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + surfaceFormats.resize( surfaceFormatCount ); + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &surfaceInfo ), + &surfaceFormatCount, + reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + if ( surfaceFormatCount < surfaceFormats.size() ) + { + surfaceFormats.resize( surfaceFormatCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceFormats ) ); + } + + // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR && + "Function requires " ); + + std::vector structureChains; + std::vector surfaceFormats; + uint32_t surfaceFormatCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &surfaceInfo ), + &surfaceFormatCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && surfaceFormatCount ) + { + structureChains.resize( surfaceFormatCount ); + surfaceFormats.resize( surfaceFormatCount ); + for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) + { + surfaceFormats[i].pNext = structureChains[i].template get().pNext; + } + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &surfaceInfo ), + &surfaceFormatCount, + reinterpret_cast( surfaceFormats.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); + VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); + if ( surfaceFormatCount < surfaceFormats.size() ) + { + structureChains.resize( surfaceFormatCount ); + } + for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) + { + structureChains[i].template get() = surfaceFormats[i]; + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChains ) ); + } + + //=== VK_KHR_get_display_properties2 === + + // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayProperties2KHR() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( + static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getDisplayPlaneProperties2KHR() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( + static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type DisplayKHR::getModeProperties2() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModeProperties2KHR && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( + static_cast( m_physicalDevice ), static_cast( m_displayKHR ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = + static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast( m_physicalDevice ), + static_cast( m_displayKHR ), + &propertyCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayKHR::getModeProperties2" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetDisplayModeProperties2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type DisplayKHR::getModeProperties2() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModeProperties2KHR && + "Function requires " ); + + std::vector structureChains; + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( + static_cast( m_physicalDevice ), static_cast( m_displayKHR ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + structureChains.resize( propertyCount ); + properties.resize( propertyCount ); + for ( uint32_t i = 0; i < propertyCount; i++ ) + { + properties[i].pNext = structureChains[i].template get().pNext; + } + result = + static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast( m_physicalDevice ), + static_cast( m_displayKHR ), + &propertyCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayKHR::getModeProperties2" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + structureChains.resize( propertyCount ); + } + for ( uint32_t i = 0; i < propertyCount; i++ ) + { + structureChains[i].template get() = properties[i]; + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChains ) ); + } + + // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneCapabilities2KHR && + "Function requires " ); + + DisplayPlaneCapabilities2KHR capabilities; + Result result = + static_cast( getDispatcher()->vkGetDisplayPlaneCapabilities2KHR( static_cast( m_physicalDevice ), + reinterpret_cast( &displayPlaneInfo ), + reinterpret_cast( &capabilities ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( capabilities ) ); + } + +# if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createIOSSurfaceMVK( IOSSurfaceCreateInfoMVK const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateIOSSurfaceMVK && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateIOSSurfaceMVK( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } +# endif /*VK_USE_PLATFORM_IOS_MVK*/ + +# if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createMacOSSurfaceMVK( MacOSSurfaceCreateInfoMVK const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateMacOSSurfaceMVK && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateMacOSSurfaceMVK( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } +# endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + + // wrapper function for command vkSetDebugUtilsObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectNameEXT && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkSetDebugUtilsObjectNameEXT( + static_cast( m_device ), reinterpret_cast( &nameInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkSetDebugUtilsObjectNameEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html + template + VULKAN_HPP_INLINE typename ResultValueType::type Device::setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name ) const + { + VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); + // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member + VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo; + nameInfo.objectType = handle.objectType; + nameInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); + nameInfo.pObjectName = name.c_str(); + return setDebugUtilsObjectNameEXT( nameInfo ); + } + + // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectTagEXT && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkSetDebugUtilsObjectTagEXT( static_cast( m_device ), reinterpret_cast( &tagInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkSetDebugUtilsObjectTagEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html + template + VULKAN_HPP_INLINE typename ResultValueType::type + Device::setDebugUtilsObjectTagEXT( HandleType const & handle, uint64_t name, TagType const & tag ) const + { + VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); + // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member + VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo; + tagInfo.objectType = handle.objectType; + tagInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); + tagInfo.tagName = name; + tagInfo.tagSize = sizeof( TagType ); + tagInfo.pTag = &tag; + return setDebugUtilsObjectTagEXT( tagInfo ); + } + + // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html + VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkQueueBeginDebugUtilsLabelEXT && "Function requires " ); + + getDispatcher()->vkQueueBeginDebugUtilsLabelEXT( static_cast( m_queue ), reinterpret_cast( &labelInfo ) ); + } + + // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html + VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkQueueEndDebugUtilsLabelEXT && "Function requires " ); + + getDispatcher()->vkQueueEndDebugUtilsLabelEXT( static_cast( m_queue ) ); + } + + // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html + VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkQueueInsertDebugUtilsLabelEXT && "Function requires " ); + + getDispatcher()->vkQueueInsertDebugUtilsLabelEXT( static_cast( m_queue ), reinterpret_cast( &labelInfo ) ); + } + + // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html + VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginDebugUtilsLabelEXT && "Function requires " ); + + getDispatcher()->vkCmdBeginDebugUtilsLabelEXT( static_cast( m_commandBuffer ), + reinterpret_cast( &labelInfo ) ); + } + + // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html + VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndDebugUtilsLabelEXT && "Function requires " ); + + getDispatcher()->vkCmdEndDebugUtilsLabelEXT( static_cast( m_commandBuffer ) ); + } + + // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html + VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdInsertDebugUtilsLabelEXT && "Function requires " ); + + getDispatcher()->vkCmdInsertDebugUtilsLabelEXT( static_cast( m_commandBuffer ), + reinterpret_cast( &labelInfo ) ); + } + + // wrapper function for command vkCreateDebugUtilsMessengerEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createDebugUtilsMessengerEXT( DebugUtilsMessengerCreateInfoEXT const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDebugUtilsMessengerEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger; + Result result = + static_cast( getDispatcher()->vkCreateDebugUtilsMessengerEXT( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &messenger ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, DebugUtilsMessengerEXT( *this, *reinterpret_cast( &messenger ), allocator ) ); + } + + // wrapper function for command vkSubmitDebugUtilsMessageEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html + VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + DebugUtilsMessageTypeFlagsEXT messageTypes, + const DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSubmitDebugUtilsMessageEXT && "Function requires " ); + + getDispatcher()->vkSubmitDebugUtilsMessageEXT( static_cast( m_instance ), + static_cast( messageSeverity ), + static_cast( messageTypes ), + reinterpret_cast( &callbackData ) ); + } + +# if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_ANDROID_external_memory_android_hardware_buffer === + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( + const struct AHardwareBuffer * buffer, AndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID && + "Function requires " ); + return static_cast( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( + static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); + } + + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID && + "Function requires " ); + + AndroidHardwareBufferPropertiesANDROID properties; + Result result = static_cast( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( + static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID && + "Function requires " ); + + StructureChain structureChain; + AndroidHardwareBufferPropertiesANDROID & properties = structureChain.template get(); + Result result = static_cast( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( + static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); + } + + // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID && + "Function requires " ); + + struct AHardwareBuffer * buffer; + Result result = static_cast( getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID( + static_cast( m_device ), reinterpret_cast( &info ), &buffer ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( buffer ) ); + } +# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_shader_enqueue === + + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createExecutionGraphPipelinesAMDX( Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateExecutionGraphPipelinesAMDX && + "Function requires " ); + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( + getDispatcher()->vkCreateExecutionGraphPipelinesAMDX( static_cast( m_device ), + pipelineCache ? static_cast( **pipelineCache ) : 0, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + std::vector pipelinesRAII; + if ( result == Result::eSuccess ) + { + pipelinesRAII.reserve( pipelines.size() ); + for ( auto & pipeline : pipelines ) + { + pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); + } + + // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createExecutionGraphPipelineAMDX( Optional const & pipelineCache, + ExecutionGraphPipelineCreateInfoAMDX const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateExecutionGraphPipelinesAMDX && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::Pipeline pipeline; + Result result = static_cast( + getDispatcher()->vkCreateExecutionGraphPipelinesAMDX( static_cast( m_device ), + pipelineCache ? static_cast( **pipelineCache ) : 0, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDX", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); + } + + // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Pipeline::getExecutionGraphScratchSizeAMDX() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetExecutionGraphPipelineScratchSizeAMDX && + "Function requires " ); + + ExecutionGraphPipelineScratchSizeAMDX sizeInfo; + Result result = static_cast( getDispatcher()->vkGetExecutionGraphPipelineScratchSizeAMDX( + static_cast( m_device ), static_cast( m_pipeline ), reinterpret_cast( &sizeInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getExecutionGraphScratchSizeAMDX" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( sizeInfo ) ); + } + + // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Pipeline::getExecutionGraphNodeIndexAMDX( const PipelineShaderStageNodeCreateInfoAMDX & nodeInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetExecutionGraphPipelineNodeIndexAMDX && + "Function requires " ); + + uint32_t nodeIndex; + Result result = static_cast( + getDispatcher()->vkGetExecutionGraphPipelineNodeIndexAMDX( static_cast( m_device ), + static_cast( m_pipeline ), + reinterpret_cast( &nodeInfo ), + &nodeIndex ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getExecutionGraphNodeIndexAMDX" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( nodeIndex ) ); + } + + // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html + VULKAN_HPP_INLINE void CommandBuffer::initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, + DeviceAddress scratch, + DeviceSize scratchSize ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdInitializeGraphScratchMemoryAMDX && + "Function requires " ); + + getDispatcher()->vkCmdInitializeGraphScratchMemoryAMDX( static_cast( m_commandBuffer ), + static_cast( executionGraph ), + static_cast( scratch ), + static_cast( scratchSize ) ); + } + + // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html + VULKAN_HPP_INLINE void + CommandBuffer::dispatchGraphAMDX( DeviceAddress scratch, DeviceSize scratchSize, const DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphAMDX && "Function requires " ); + + getDispatcher()->vkCmdDispatchGraphAMDX( static_cast( m_commandBuffer ), + static_cast( scratch ), + static_cast( scratchSize ), + reinterpret_cast( &countInfo ) ); + } + + // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html + VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectAMDX( DeviceAddress scratch, + DeviceSize scratchSize, + const DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphIndirectAMDX && "Function requires " ); + + getDispatcher()->vkCmdDispatchGraphIndirectAMDX( static_cast( m_commandBuffer ), + static_cast( scratch ), + static_cast( scratchSize ), + reinterpret_cast( &countInfo ) ); + } + + // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html + VULKAN_HPP_INLINE void + CommandBuffer::dispatchGraphIndirectCountAMDX( DeviceAddress scratch, DeviceSize scratchSize, DeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphIndirectCountAMDX && + "Function requires " ); + + getDispatcher()->vkCmdDispatchGraphIndirectCountAMDX( static_cast( m_commandBuffer ), + static_cast( scratch ), + static_cast( scratchSize ), + static_cast( countInfo ) ); + } +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_descriptor_heap === + + // wrapper function for command vkWriteSamplerDescriptorsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::writeSamplerDescriptorsEXT( ArrayProxy const & samplers, + ArrayProxy const & descriptors ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkWriteSamplerDescriptorsEXT && "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( samplers.size() == descriptors.size() ); +# else + if ( samplers.size() != descriptors.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT: samplers.size() != descriptors.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + Result result = + static_cast( getDispatcher()->vkWriteSamplerDescriptorsEXT( static_cast( m_device ), + samplers.size(), + reinterpret_cast( samplers.data() ), + reinterpret_cast( descriptors.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkWriteResourceDescriptorsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::writeResourceDescriptorsEXT( ArrayProxy const & resources, + ArrayProxy const & descriptors ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkWriteResourceDescriptorsEXT && "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( resources.size() == descriptors.size() ); +# else + if ( resources.size() != descriptors.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT: resources.size() != descriptors.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + Result result = + static_cast( getDispatcher()->vkWriteResourceDescriptorsEXT( static_cast( m_device ), + resources.size(), + reinterpret_cast( resources.data() ), + reinterpret_cast( descriptors.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html + VULKAN_HPP_INLINE void CommandBuffer::bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindSamplerHeapEXT && "Function requires " ); + + getDispatcher()->vkCmdBindSamplerHeapEXT( static_cast( m_commandBuffer ), reinterpret_cast( &bindInfo ) ); + } + + // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html + VULKAN_HPP_INLINE void CommandBuffer::bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindResourceHeapEXT && "Function requires " ); + + getDispatcher()->vkCmdBindResourceHeapEXT( static_cast( m_commandBuffer ), reinterpret_cast( &bindInfo ) ); + } + + // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html + VULKAN_HPP_INLINE void CommandBuffer::pushDataEXT( const PushDataInfoEXT & pushDataInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDataEXT && "Function requires " ); + + getDispatcher()->vkCmdPushDataEXT( static_cast( m_commandBuffer ), reinterpret_cast( &pushDataInfo ) ); + } + + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getImageOpaqueCaptureDataEXT( ArrayProxy const & images ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageOpaqueCaptureDataEXT && "Function requires " ); + + std::vector datas( images.size() ); + Result result = static_cast( getDispatcher()->vkGetImageOpaqueCaptureDataEXT( static_cast( m_device ), + images.size(), + reinterpret_cast( images.data() ), + reinterpret_cast( datas.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( datas ) ); + } + + // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getImageOpaqueCaptureDataEXT( const VULKAN_HPP_NAMESPACE::Image & image ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageOpaqueCaptureDataEXT && "Function requires " ); + + HostAddressRangeEXT data; + Result result = static_cast( getDispatcher()->vkGetImageOpaqueCaptureDataEXT( + static_cast( m_device ), 1, reinterpret_cast( &image ), reinterpret_cast( &data ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize PhysicalDevice::getDescriptorSizeEXT( DescriptorType descriptorType ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDescriptorSizeEXT && + "Function requires " ); + + VkDeviceSize result = getDispatcher()->vkGetPhysicalDeviceDescriptorSizeEXT( static_cast( m_physicalDevice ), + static_cast( descriptorType ) ); + + return static_cast( result ); + } + + // wrapper function for command vkRegisterCustomBorderColorEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT & borderColor, Bool32 requestIndex ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkRegisterCustomBorderColorEXT && "Function requires " ); + + uint32_t index; + Result result = + static_cast( getDispatcher()->vkRegisterCustomBorderColorEXT( static_cast( m_device ), + reinterpret_cast( &borderColor ), + static_cast( requestIndex ), + &index ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::registerCustomBorderColorEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( index ) ); + } + + // wrapper function for command vkUnregisterCustomBorderColorEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html + VULKAN_HPP_INLINE void Device::unregisterCustomBorderColorEXT( uint32_t index ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkUnregisterCustomBorderColorEXT && "Function requires " ); + + getDispatcher()->vkUnregisterCustomBorderColorEXT( static_cast( m_device ), index ); + } + + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorOpaqueCaptureDataARM && "Function requires " ); + + std::vector datas( tensors.size() ); + Result result = static_cast( getDispatcher()->vkGetTensorOpaqueCaptureDataARM( static_cast( m_device ), + tensors.size(), + reinterpret_cast( tensors.data() ), + reinterpret_cast( datas.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( datas ) ); + } + + // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getTensorOpaqueCaptureDataARM( const VULKAN_HPP_NAMESPACE::TensorARM & tensor ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorOpaqueCaptureDataARM && "Function requires " ); + + HostAddressRangeEXT data; + Result result = static_cast( getDispatcher()->vkGetTensorOpaqueCaptureDataARM( + static_cast( m_device ), 1, reinterpret_cast( &tensor ), reinterpret_cast( &data ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + //=== VK_EXT_sample_locations === + + // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEXT && "Function requires " ); + + getDispatcher()->vkCmdSetSampleLocationsEXT( static_cast( m_commandBuffer ), + reinterpret_cast( &sampleLocationsInfo ) ); + } + + // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MultisamplePropertiesEXT + PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT && + "Function requires " ); + + MultisamplePropertiesEXT multisampleProperties; + getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT( static_cast( m_physicalDevice ), + static_cast( samples ), + reinterpret_cast( &multisampleProperties ) ); + + return multisampleProperties; + } + + //=== VK_KHR_get_memory_requirements2 === + + // wrapper function for command vkGetImageMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2KHR && + "Function requires or " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetImageMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2KHR && + "Function requires or " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkGetBufferMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2KHR && + "Function requires or " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetBufferMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2KHR && + "Function requires or " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements2KHR && + "Function requires or " ); + + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( + static_cast( m_device ), reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( static_cast( m_device ), + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } + + //=== VK_KHR_acceleration_structure === + + // wrapper function for command vkCreateAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createAccelerationStructureKHR( AccelerationStructureCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateAccelerationStructureKHR && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure; + Result result = + static_cast( getDispatcher()->vkCreateAccelerationStructureKHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &accelerationStructure ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, AccelerationStructureKHR( *this, *reinterpret_cast( &accelerationStructure ), allocator ) ); + } + + // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html + VULKAN_HPP_INLINE void + CommandBuffer::buildAccelerationStructuresKHR( ArrayProxy const & infos, + ArrayProxy const & pBuildRangeInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructuresKHR && + "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); +# else + if ( infos.size() != pBuildRangeInfos.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdBuildAccelerationStructuresKHR( + static_cast( m_commandBuffer ), + infos.size(), + reinterpret_cast( infos.data() ), + reinterpret_cast( pBuildRangeInfos.data() ) ); + } + + // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html + VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( ArrayProxy const & infos, + ArrayProxy const & indirectDeviceAddresses, + ArrayProxy const & indirectStrides, + ArrayProxy const & pMaxPrimitiveCounts ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR && + "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() ); + VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() ); + VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() ); +# else + if ( infos.size() != indirectDeviceAddresses.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" ); + } + if ( infos.size() != indirectStrides.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" ); + } + if ( infos.size() != pMaxPrimitiveCounts.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR( static_cast( m_commandBuffer ), + infos.size(), + reinterpret_cast( infos.data() ), + reinterpret_cast( indirectDeviceAddresses.data() ), + indirectStrides.data(), + pMaxPrimitiveCounts.data() ); + } + + // wrapper function for command vkBuildAccelerationStructuresKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + ArrayProxy const & infos, + ArrayProxy const & pBuildRangeInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBuildAccelerationStructuresKHR && + "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); +# else + if ( infos.size() != pBuildRangeInfos.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + Result result = static_cast( getDispatcher()->vkBuildAccelerationStructuresKHR( + static_cast( m_device ), + static_cast( deferredOperation ), + infos.size(), + reinterpret_cast( infos.data() ), + reinterpret_cast( pBuildRangeInfos.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } + + // wrapper function for command vkCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureInfoKHR & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyAccelerationStructureKHR && + "Function requires " ); + + Result result = + static_cast( getDispatcher()->vkCopyAccelerationStructureKHR( static_cast( m_device ), + static_cast( deferredOperation ), + reinterpret_cast( &info ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } + + // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const CopyAccelerationStructureToMemoryInfoKHR & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyAccelerationStructureToMemoryKHR && + "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkCopyAccelerationStructureToMemoryKHR( static_cast( m_device ), + static_cast( deferredOperation ), + reinterpret_cast( &info ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } + + // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const CopyMemoryToAccelerationStructureInfoKHR & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToAccelerationStructureKHR && + "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkCopyMemoryToAccelerationStructureKHR( static_cast( m_device ), + static_cast( deferredOperation ), + reinterpret_cast( &info ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } + + // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, + QueryType queryType, + size_t dataSize, + size_t stride ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR && + "Function requires " ); + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( + getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast( m_device ), + accelerationStructures.size(), + reinterpret_cast( accelerationStructures.data() ), + static_cast( queryType ), + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ), + stride ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::writeAccelerationStructuresPropertyKHR( + ArrayProxy const & accelerationStructures, QueryType queryType, size_t stride ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR && + "Function requires " ); + + DataType data; + Result result = static_cast( + getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast( m_device ), + accelerationStructures.size(), + reinterpret_cast( accelerationStructures.data() ), + static_cast( queryType ), + sizeof( DataType ), + reinterpret_cast( &data ), + stride ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkCmdCopyAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html + VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureKHR && + "Function requires " ); + + getDispatcher()->vkCmdCopyAccelerationStructureKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html + VULKAN_HPP_INLINE void + CommandBuffer::copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR && + "Function requires " ); + + getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html + VULKAN_HPP_INLINE void + CommandBuffer::copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR && + "Function requires " ); + + getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceAddress + Device::getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR && + "Function requires " ); + + VkDeviceAddress result = getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR( + static_cast( m_device ), reinterpret_cast( &info ) ); + + return static_cast( result ); + } + + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html + VULKAN_HPP_INLINE void + CommandBuffer::writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, + QueryType queryType, + VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR && + "Function requires " ); + + getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR( static_cast( m_commandBuffer ), + accelerationStructures.size(), + reinterpret_cast( accelerationStructures.data() ), + static_cast( queryType ), + static_cast( queryPool ), + firstQuery ); + } + + // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureCompatibilityKHR + Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR && + "Function requires " ); + + AccelerationStructureCompatibilityKHR compatibility; + getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR( static_cast( m_device ), + reinterpret_cast( &versionInfo ), + reinterpret_cast( &compatibility ) ); + + return compatibility; + } + + // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR + Device::getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, + const AccelerationStructureBuildGeometryInfoKHR & buildInfo, + ArrayProxy const & maxPrimitiveCounts ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureBuildSizesKHR && + "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( maxPrimitiveCounts.size() == buildInfo.geometryCount ); +# else + if ( maxPrimitiveCounts.size() != buildInfo.geometryCount ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + AccelerationStructureBuildSizesInfoKHR sizeInfo; + getDispatcher()->vkGetAccelerationStructureBuildSizesKHR( static_cast( m_device ), + static_cast( buildType ), + reinterpret_cast( &buildInfo ), + maxPrimitiveCounts.data(), + reinterpret_cast( &sizeInfo ) ); + + return sizeInfo; + } + + //=== VK_KHR_ray_tracing_pipeline === + + // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html + VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, + const StridedDeviceAddressRegionKHR & missShaderBindingTable, + const StridedDeviceAddressRegionKHR & hitShaderBindingTable, + const StridedDeviceAddressRegionKHR & callableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysKHR && "Function requires " ); + + getDispatcher()->vkCmdTraceRaysKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &raygenShaderBindingTable ), + reinterpret_cast( &missShaderBindingTable ), + reinterpret_cast( &hitShaderBindingTable ), + reinterpret_cast( &callableShaderBindingTable ), + width, + height, + depth ); + } + + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createRayTracingPipelinesKHR( Optional const & deferredOperation, + Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRayTracingPipelinesKHR && + "Function requires " ); + + std::vector pipelines( createInfos.size() ); + Result result = static_cast( + getDispatcher()->vkCreateRayTracingPipelinesKHR( static_cast( m_device ), + deferredOperation ? static_cast( **deferredOperation ) : 0, + pipelineCache ? static_cast( **pipelineCache ) : 0, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } ); + std::vector pipelinesRAII; + if ( result == Result::eSuccess ) + { + pipelinesRAII.reserve( pipelines.size() ); + for ( auto & pipeline : pipelines ) + { + pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); + } + + // wrapper function for command vkCreateRayTracingPipelinesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createRayTracingPipelineKHR( Optional const & deferredOperation, + Optional const & pipelineCache, + RayTracingPipelineCreateInfoKHR const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRayTracingPipelinesKHR && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::Pipeline pipeline; + Result result = static_cast( + getDispatcher()->vkCreateRayTracingPipelinesKHR( static_cast( m_device ), + deferredOperation ? static_cast( **deferredOperation ) : 0, + pipelineCache ? static_cast( **pipelineCache ) : 0, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRayTracingPipelineKHR", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); + } + + // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR && + "Function requires or " ); + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast( m_device ), + static_cast( m_pipeline ), + firstGroup, + groupCount, + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Pipeline::getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, + uint32_t groupCount ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR && + "Function requires or " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast( m_device ), + static_cast( m_pipeline ), + firstGroup, + groupCount, + sizeof( DataType ), + reinterpret_cast( &data ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && + "Function requires " ); + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast( m_device ), + static_cast( m_pipeline ), + firstGroup, + groupCount, + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && + "Function requires " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast( m_device ), + static_cast( m_pipeline ), + firstGroup, + groupCount, + sizeof( DataType ), + reinterpret_cast( &data ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html + VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, + const StridedDeviceAddressRegionKHR & missShaderBindingTable, + const StridedDeviceAddressRegionKHR & hitShaderBindingTable, + const StridedDeviceAddressRegionKHR & callableShaderBindingTable, + DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysIndirectKHR && "Function requires " ); + + getDispatcher()->vkCmdTraceRaysIndirectKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &raygenShaderBindingTable ), + reinterpret_cast( &missShaderBindingTable ), + reinterpret_cast( &hitShaderBindingTable ), + reinterpret_cast( &callableShaderBindingTable ), + static_cast( indirectDeviceAddress ) ); + } + + // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize + Pipeline::getRayTracingShaderGroupStackSizeKHR( uint32_t group, ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR && + "Function requires " ); + + VkDeviceSize result = getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR( + static_cast( m_device ), static_cast( m_pipeline ), group, static_cast( groupShader ) ); + + return static_cast( result ); + } + + // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html + VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR && + "Function requires " ); + + getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR( static_cast( m_commandBuffer ), pipelineStackSize ); + } + + //=== VK_KHR_sampler_ycbcr_conversion === + + // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createSamplerYcbcrConversionKHR( SamplerYcbcrConversionCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSamplerYcbcrConversionKHR && + "Function requires or " ); + + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; + Result result = + static_cast( getDispatcher()->vkCreateSamplerYcbcrConversionKHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &ycbcrConversion ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, SamplerYcbcrConversion( *this, *reinterpret_cast( &ycbcrConversion ), allocator ) ); + } + + // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html + VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, + Optional allocator ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkDestroySamplerYcbcrConversionKHR && + "Function requires or " ); + + getDispatcher()->vkDestroySamplerYcbcrConversionKHR( static_cast( m_device ), + static_cast( ycbcrConversion ), + reinterpret_cast( allocator.get() ) ); + } + + //=== VK_KHR_bind_memory2 === + + // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::bindBufferMemory2KHR( ArrayProxy const & bindInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2KHR && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkBindBufferMemory2KHR( + static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::bindImageMemory2KHR( ArrayProxy const & bindInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2KHR && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkBindImageMemory2KHR( + static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindImageMemory2KHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + //=== VK_EXT_image_drm_format_modifier === + + // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Image::getDrmFormatModifierPropertiesEXT() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT && + "Function requires " ); + + ImageDrmFormatModifierPropertiesEXT properties; + Result result = static_cast( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT( + static_cast( m_device ), static_cast( m_image ), reinterpret_cast( &properties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Image::getDrmFormatModifierPropertiesEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + //=== VK_EXT_validation_cache === + + // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createValidationCacheEXT( ValidationCacheCreateInfoEXT const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateValidationCacheEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache; + Result result = static_cast( getDispatcher()->vkCreateValidationCacheEXT( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &validationCache ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createValidationCacheEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, ValidationCacheEXT( *this, *reinterpret_cast( &validationCache ), allocator ) ); + } + + // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type + ValidationCacheEXT::merge( ArrayProxy const & srcCaches ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkMergeValidationCachesEXT && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkMergeValidationCachesEXT( static_cast( m_device ), + static_cast( m_validationCacheEXT ), + srcCaches.size(), + reinterpret_cast( srcCaches.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::ValidationCacheEXT::merge" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type ValidationCacheEXT::getData() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetValidationCacheDataEXT && "Function requires " ); + + std::vector data; + size_t dataSize; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetValidationCacheDataEXT( + static_cast( m_device ), static_cast( m_validationCacheEXT ), &dataSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( getDispatcher()->vkGetValidationCacheDataEXT( static_cast( m_device ), + static_cast( m_validationCacheEXT ), + &dataSize, + reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::ValidationCacheEXT::getData" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + //=== VK_NV_shading_rate_image === + + // wrapper function for command vkCmdBindShadingRateImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html + VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadingRateImageNV && "Function requires " ); + + getDispatcher()->vkCmdBindShadingRateImageNV( + static_cast( m_commandBuffer ), static_cast( imageView ), static_cast( imageLayout ) ); + } + + // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html + VULKAN_HPP_INLINE void + CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, + ArrayProxy const & shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportShadingRatePaletteNV && + "Function requires " ); + + getDispatcher()->vkCmdSetViewportShadingRatePaletteNV( static_cast( m_commandBuffer ), + firstViewport, + shadingRatePalettes.size(), + reinterpret_cast( shadingRatePalettes.data() ) ); + } + + // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html + VULKAN_HPP_INLINE void + CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, + ArrayProxy const & customSampleOrders ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoarseSampleOrderNV && "Function requires " ); + + getDispatcher()->vkCmdSetCoarseSampleOrderNV( static_cast( m_commandBuffer ), + static_cast( sampleOrderType ), + customSampleOrders.size(), + reinterpret_cast( customSampleOrders.data() ) ); + } + + //=== VK_NV_ray_tracing === + + // wrapper function for command vkCreateAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createAccelerationStructureNV( AccelerationStructureCreateInfoNV const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateAccelerationStructureNV && "Function requires " ); + + VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure; + Result result = + static_cast( getDispatcher()->vkCreateAccelerationStructureNV( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &accelerationStructure ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createAccelerationStructureNV" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, AccelerationStructureNV( *this, *reinterpret_cast( &accelerationStructure ), allocator ) ); + } + + // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2KHR + Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV && + "Function requires " ); + + MemoryRequirements2KHR memoryRequirements; + getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV && + "Function requires " ); + + StructureChain structureChain; + MemoryRequirements2KHR & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkBindAccelerationStructureMemoryNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::bindAccelerationStructureMemoryNV( ArrayProxy const & bindInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBindAccelerationStructureMemoryNV && + "Function requires " ); + + Result result = static_cast( getDispatcher()->vkBindAccelerationStructureMemoryNV( + static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdBuildAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html + VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, + VULKAN_HPP_NAMESPACE::Buffer instanceData, + DeviceSize instanceOffset, + Bool32 update, + VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, + VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, + VULKAN_HPP_NAMESPACE::Buffer scratch, + DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructureNV && "Function requires " ); + + getDispatcher()->vkCmdBuildAccelerationStructureNV( static_cast( m_commandBuffer ), + reinterpret_cast( &info ), + static_cast( instanceData ), + static_cast( instanceOffset ), + static_cast( update ), + static_cast( dst ), + static_cast( src ), + static_cast( scratch ), + static_cast( scratchOffset ) ); + } + + // wrapper function for command vkCmdCopyAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html + VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, + VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, + CopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureNV && "Function requires " ); + + getDispatcher()->vkCmdCopyAccelerationStructureNV( static_cast( m_commandBuffer ), + static_cast( dst ), + static_cast( src ), + static_cast( mode ) ); + } + + // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html + VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, + DeviceSize raygenShaderBindingOffset, + VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, + DeviceSize missShaderBindingOffset, + DeviceSize missShaderBindingStride, + VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, + DeviceSize hitShaderBindingOffset, + DeviceSize hitShaderBindingStride, + VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, + DeviceSize callableShaderBindingOffset, + DeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysNV && "Function requires " ); + + getDispatcher()->vkCmdTraceRaysNV( static_cast( m_commandBuffer ), + static_cast( raygenShaderBindingTableBuffer ), + static_cast( raygenShaderBindingOffset ), + static_cast( missShaderBindingTableBuffer ), + static_cast( missShaderBindingOffset ), + static_cast( missShaderBindingStride ), + static_cast( hitShaderBindingTableBuffer ), + static_cast( hitShaderBindingOffset ), + static_cast( hitShaderBindingStride ), + static_cast( callableShaderBindingTableBuffer ), + static_cast( callableShaderBindingOffset ), + static_cast( callableShaderBindingStride ), + width, + height, + depth ); + } + + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createRayTracingPipelinesNV( Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRayTracingPipelinesNV && "Function requires " ); + + std::vector pipelines( createInfos.size() ); + Result result = + static_cast( getDispatcher()->vkCreateRayTracingPipelinesNV( static_cast( m_device ), + pipelineCache ? static_cast( **pipelineCache ) : 0, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + std::vector pipelinesRAII; + if ( result == Result::eSuccess ) + { + pipelinesRAII.reserve( pipelines.size() ); + for ( auto & pipeline : pipelines ) + { + pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); + } + + // wrapper function for command vkCreateRayTracingPipelinesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createRayTracingPipelineNV( Optional const & pipelineCache, + RayTracingPipelineCreateInfoNV const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRayTracingPipelinesNV && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Pipeline pipeline; + Result result = + static_cast( getDispatcher()->vkCreateRayTracingPipelinesNV( static_cast( m_device ), + pipelineCache ? static_cast( **pipelineCache ) : 0, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRayTracingPipelineNV", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); + } + + // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV && + "Function requires or " ); + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast( m_device ), + static_cast( m_pipeline ), + firstGroup, + groupCount, + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesNV" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Pipeline::getRayTracingShaderGroupHandleNV( uint32_t firstGroup, + uint32_t groupCount ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV && + "Function requires or " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast( m_device ), + static_cast( m_pipeline ), + firstGroup, + groupCount, + sizeof( DataType ), + reinterpret_cast( &data ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleNV" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetAccelerationStructureHandleNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type AccelerationStructureNV::getHandle( size_t dataSize ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV && "Function requires " ); + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = + static_cast( getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast( m_device ), + static_cast( m_accelerationStructureNV ), + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetAccelerationStructureHandleNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type AccelerationStructureNV::getHandle() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV && "Function requires " ); + + DataType data; + Result result = + static_cast( getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast( m_device ), + static_cast( m_accelerationStructureNV ), + sizeof( DataType ), + reinterpret_cast( &data ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html + VULKAN_HPP_INLINE void + CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy const & accelerationStructures, + QueryType queryType, + VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV && + "Function requires " ); + + getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV( static_cast( m_commandBuffer ), + accelerationStructures.size(), + reinterpret_cast( accelerationStructures.data() ), + static_cast( queryType ), + static_cast( queryPool ), + firstQuery ); + } + + // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html + VULKAN_HPP_INLINE typename ResultValueType::type Pipeline::compileDeferredNV( uint32_t shader ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCompileDeferredNV && "Function requires " ); + + Result result = + static_cast( getDispatcher()->vkCompileDeferredNV( static_cast( m_device ), static_cast( m_pipeline ), shader ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::compileDeferredNV" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + //=== VK_KHR_maintenance3 === + + // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutSupport + Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupportKHR && + "Function requires or " ); + + DescriptorSetLayoutSupport support; + getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( &support ) ); + + return support; + } + + // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupportKHR && + "Function requires or " ); + + StructureChain structureChain; + DescriptorSetLayoutSupport & support = structureChain.template get(); + getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( &support ) ); + + return structureChain; + } + + //=== VK_KHR_draw_indirect_count === + + // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountKHR && + "Function requires or or " ); + + getDispatcher()->vkCmdDrawIndirectCountKHR( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html + VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkCmdDrawIndexedIndirectCountKHR && + "Function requires or or " ); + + getDispatcher()->vkCmdDrawIndexedIndirectCountKHR( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + //=== VK_EXT_external_memory_host === + + // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryHostPointerPropertiesEXT && + "Function requires " ); + + MemoryHostPointerPropertiesEXT memoryHostPointerProperties; + Result result = static_cast( + getDispatcher()->vkGetMemoryHostPointerPropertiesEXT( static_cast( m_device ), + static_cast( handleType ), + pHostPointer, + reinterpret_cast( &memoryHostPointerProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryHostPointerProperties ) ); + } + + //=== VK_AMD_buffer_marker === + + // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html + VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer, + DeviceSize dstOffset, + uint32_t marker ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarkerAMD && "Function requires " ); + + getDispatcher()->vkCmdWriteBufferMarkerAMD( static_cast( m_commandBuffer ), + static_cast( pipelineStage ), + static_cast( dstBuffer ), + static_cast( dstOffset ), + marker ); + } + + // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html + VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( PipelineStageFlags2 stage, + VULKAN_HPP_NAMESPACE::Buffer dstBuffer, + DeviceSize dstOffset, + uint32_t marker ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarker2AMD && "Function requires " ); + + getDispatcher()->vkCmdWriteBufferMarker2AMD( static_cast( m_commandBuffer ), + static_cast( stage ), + static_cast( dstBuffer ), + static_cast( dstOffset ), + marker ); + } + + //=== VK_EXT_calibrated_timestamps === + + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getCalibrateableTimeDomainsEXT() const + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT && + "Function requires or " ); + + std::vector timeDomains; + uint32_t timeDomainCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( static_cast( m_physicalDevice ), &timeDomainCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && timeDomainCount ) + { + timeDomains.resize( timeDomainCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( + static_cast( m_physicalDevice ), &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); + VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); + if ( timeDomainCount < timeDomains.size() ) + { + timeDomains.resize( timeDomainCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) ); + } + + // wrapper function for command vkGetCalibratedTimestampsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type + Device::getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && + "Function requires or " ); + + std::pair, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); + std::vector & timestamps = data_.first; + uint64_t & maxDeviation = data_.second; + Result result = + static_cast( getDispatcher()->vkGetCalibratedTimestampsEXT( static_cast( m_device ), + timestampInfos.size(), + reinterpret_cast( timestampInfos.data() ), + timestamps.data(), + &maxDeviation ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetCalibratedTimestampsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getCalibratedTimestampEXT( const CalibratedTimestampInfoKHR & timestampInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && + "Function requires or " ); + + std::pair data_; + uint64_t & timestamp = data_.first; + uint64_t & maxDeviation = data_.second; + Result result = static_cast( getDispatcher()->vkGetCalibratedTimestampsEXT( + static_cast( m_device ), 1, reinterpret_cast( ×tampInfo ), ×tamp, &maxDeviation ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); + } + + //=== VK_NV_mesh_shader === + + // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksNV && "Function requires " ); + + getDispatcher()->vkCmdDrawMeshTasksNV( static_cast( m_commandBuffer ), taskCount, firstTask ); + } + + // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + uint32_t drawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectNV && "Function requires " ); + + getDispatcher()->vkCmdDrawMeshTasksIndirectNV( + static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); + } + + // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV && "Function requires " ); + + getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + //=== VK_NV_scissor_exclusive === + + // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html + VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, + ArrayProxy const & exclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorEnableNV && + "Function requires " ); + + getDispatcher()->vkCmdSetExclusiveScissorEnableNV( static_cast( m_commandBuffer ), + firstExclusiveScissor, + exclusiveScissorEnables.size(), + reinterpret_cast( exclusiveScissorEnables.data() ) ); + } + + // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html + VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, + ArrayProxy const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorNV && "Function requires " ); + + getDispatcher()->vkCmdSetExclusiveScissorNV( static_cast( m_commandBuffer ), + firstExclusiveScissor, + exclusiveScissors.size(), + reinterpret_cast( exclusiveScissors.data() ) ); + } + + //=== VK_NV_device_diagnostic_checkpoints === + + // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html + template + VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCheckpointNV && "Function requires " ); + + getDispatcher()->vkCmdSetCheckpointNV( static_cast( m_commandBuffer ), reinterpret_cast( &checkpointMarker ) ); + } + + // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Queue::getCheckpointDataNV() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointDataNV && + "Function requires " ); + + std::vector checkpointData; + uint32_t checkpointDataCount; + getDispatcher()->vkGetQueueCheckpointDataNV( static_cast( m_queue ), &checkpointDataCount, nullptr ); + checkpointData.resize( checkpointDataCount ); + getDispatcher()->vkGetQueueCheckpointDataNV( + static_cast( m_queue ), &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); + + VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); + if ( checkpointDataCount < checkpointData.size() ) + { + checkpointData.resize( checkpointDataCount ); + } + return checkpointData; + } + + // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Queue::getCheckpointData2NV() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointData2NV && + "Function requires " ); + + std::vector checkpointData; + uint32_t checkpointDataCount; + getDispatcher()->vkGetQueueCheckpointData2NV( static_cast( m_queue ), &checkpointDataCount, nullptr ); + checkpointData.resize( checkpointDataCount ); + getDispatcher()->vkGetQueueCheckpointData2NV( + static_cast( m_queue ), &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); + + VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); + if ( checkpointDataCount < checkpointData.size() ) + { + checkpointData.resize( checkpointDataCount ); + } + return checkpointData; + } + + //=== VK_KHR_timeline_semaphore === + + // wrapper function for command vkGetSemaphoreCounterValueKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Semaphore::getCounterValueKHR() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreCounterValueKHR && + "Function requires or " ); + + uint64_t value; + Result result = static_cast( + getDispatcher()->vkGetSemaphoreCounterValueKHR( static_cast( m_device ), static_cast( m_semaphore ), &value ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( value ) ); + } + + // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphoresKHR && "Function requires or " ); + + Result result = static_cast( + getDispatcher()->vkWaitSemaphoresKHR( static_cast( m_device ), reinterpret_cast( &waitInfo ), timeout ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::waitSemaphoresKHR", { Result::eSuccess, Result::eTimeout } ); + + return static_cast( result ); + } + + // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphoreKHR && "Function requires or " ); + + Result result = static_cast( + getDispatcher()->vkSignalSemaphoreKHR( static_cast( m_device ), reinterpret_cast( &signalInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::signalSemaphoreKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + //=== VK_EXT_present_timing === + + // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::setPresentTimingQueueSizeEXT( uint32_t size ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetSwapchainPresentTimingQueueSizeEXT && + "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkSetSwapchainPresentTimingQueueSizeEXT( static_cast( m_device ), static_cast( m_swapchainKHR ), size ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::setPresentTimingQueueSizeEXT", { Result::eSuccess, Result::eNotReady } ); + + return static_cast( result ); + } + + // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> SwapchainKHR::getTimingPropertiesEXT() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainTimingPropertiesEXT && + "Function requires " ); + + std::pair data_; + SwapchainTimingPropertiesEXT & swapchainTimingProperties = data_.first; + uint64_t & swapchainTimingPropertiesCounter = data_.second; + Result result = static_cast( + getDispatcher()->vkGetSwapchainTimingPropertiesEXT( static_cast( m_device ), + static_cast( m_swapchainKHR ), + reinterpret_cast( &swapchainTimingProperties ), + &swapchainTimingPropertiesCounter ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getTimingPropertiesEXT", { Result::eSuccess, Result::eNotReady } ); + + return ResultValue>( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::getTimeDomainPropertiesEXT( SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, + uint64_t * pTimeDomainsCounter ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainTimeDomainPropertiesEXT && + "Function requires " ); + return static_cast( + getDispatcher()->vkGetSwapchainTimeDomainPropertiesEXT( static_cast( m_device ), + static_cast( m_swapchainKHR ), + reinterpret_cast( pSwapchainTimeDomainProperties ), + pTimeDomainsCounter ) ); + } // wrapper function for command vkGetPastPresentationTimingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, + PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPastPresentationTimingEXT && "Function requires " ); + return static_cast( + getDispatcher()->vkGetPastPresentationTimingEXT( static_cast( m_device ), + reinterpret_cast( pPastPresentationTimingInfo ), + reinterpret_cast( pPastPresentationTimingProperties ) ) ); + } + + //=== VK_INTEL_performance_query === + + // wrapper function for command vkInitializePerformanceApiINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkInitializePerformanceApiINTEL && + "Function requires " ); + + Result result = static_cast( getDispatcher()->vkInitializePerformanceApiINTEL( + static_cast( m_device ), reinterpret_cast( &initializeInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkUninitializePerformanceApiINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html + VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkUninitializePerformanceApiINTEL && + "Function requires " ); + + getDispatcher()->vkUninitializePerformanceApiINTEL( static_cast( m_device ) ); + } + + // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html + VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPerformanceMarkerINTEL && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkCmdSetPerformanceMarkerINTEL( + static_cast( m_commandBuffer ), reinterpret_cast( &markerInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html + VULKAN_HPP_INLINE typename ResultValueType::type + CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL && + "Function requires " ); + + Result result = static_cast( getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL( + static_cast( m_commandBuffer ), reinterpret_cast( &markerInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html + VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPerformanceOverrideINTEL && + "Function requires " ); + + Result result = static_cast( getDispatcher()->vkCmdSetPerformanceOverrideINTEL( + static_cast( m_commandBuffer ), reinterpret_cast( &overrideInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::acquirePerformanceConfigurationINTEL( PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAcquirePerformanceConfigurationINTEL && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration; + Result result = static_cast( + getDispatcher()->vkAcquirePerformanceConfigurationINTEL( static_cast( m_device ), + reinterpret_cast( &acquireInfo ), + reinterpret_cast( &configuration ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, PerformanceConfigurationINTEL( *this, *reinterpret_cast( &configuration ) ) ); + } + + // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html + VULKAN_HPP_INLINE typename ResultValueType::type + Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSetPerformanceConfigurationINTEL && + "Function requires " ); + + Result result = static_cast( getDispatcher()->vkQueueSetPerformanceConfigurationINTEL( + static_cast( m_queue ), static_cast( configuration ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetPerformanceParameterINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPerformanceParameterINTEL && "Function requires " ); + + PerformanceValueINTEL value; + Result result = static_cast( getDispatcher()->vkGetPerformanceParameterINTEL( + static_cast( m_device ), static_cast( parameter ), reinterpret_cast( &value ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( value ) ); + } + + //=== VK_AMD_display_native_hdr === + + // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html + VULKAN_HPP_INLINE void SwapchainKHR::setLocalDimmingAMD( Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetLocalDimmingAMD && "Function requires " ); + + getDispatcher()->vkSetLocalDimmingAMD( + static_cast( m_device ), static_cast( m_swapchainKHR ), static_cast( localDimmingEnable ) ); + } + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createImagePipeSurfaceFUCHSIA( ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateImagePipeSurfaceFUCHSIA && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = + static_cast( getDispatcher()->vkCreateImagePipeSurfaceFUCHSIA( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createMetalSurfaceEXT( MetalSurfaceCreateInfoEXT const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateMetalSurfaceEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateMetalSurfaceEXT( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + + // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getFragmentShadingRatesKHR() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR && + "Function requires " ); + + std::vector fragmentShadingRates; + uint32_t fragmentShadingRateCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( + static_cast( m_physicalDevice ), &fragmentShadingRateCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && fragmentShadingRateCount ) + { + fragmentShadingRates.resize( fragmentShadingRateCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( + static_cast( m_physicalDevice ), + &fragmentShadingRateCount, + reinterpret_cast( fragmentShadingRates.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); + VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); + if ( fragmentShadingRateCount < fragmentShadingRates.size() ) + { + fragmentShadingRates.resize( fragmentShadingRateCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fragmentShadingRates ) ); + } + + // wrapper function for command vkCmdSetFragmentShadingRateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html + VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( const Extent2D & fragmentSize, + const FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFragmentShadingRateKHR && + "Function requires " ); + + getDispatcher()->vkCmdSetFragmentShadingRateKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &fragmentSize ), + reinterpret_cast( combinerOps ) ); + } + + //=== VK_KHR_dynamic_rendering_local_read === + + // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html + VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingAttachmentLocationsKHR && + "Function requires or " ); + + getDispatcher()->vkCmdSetRenderingAttachmentLocationsKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &locationInfo ) ); + } + + // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html + VULKAN_HPP_INLINE void + CommandBuffer::setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingInputAttachmentIndicesKHR && + "Function requires or " ); + + getDispatcher()->vkCmdSetRenderingInputAttachmentIndicesKHR( static_cast( m_commandBuffer ), + reinterpret_cast( &inputAttachmentIndexInfo ) ); + } + + //=== VK_EXT_buffer_device_address === + + // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetBufferDeviceAddressEXT && + "Function requires or or " ); + + VkDeviceAddress result = + getDispatcher()->vkGetBufferDeviceAddressEXT( static_cast( m_device ), reinterpret_cast( &info ) ); + + return static_cast( result ); + } + + //=== VK_EXT_tooling_info === + + // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getToolPropertiesEXT() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT && + "Function requires or " ); + + std::vector toolProperties; + uint32_t toolCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( static_cast( m_physicalDevice ), &toolCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && toolCount ) + { + toolProperties.resize( toolCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( + static_cast( m_physicalDevice ), &toolCount, reinterpret_cast( toolProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); + VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); + if ( toolCount < toolProperties.size() ) + { + toolProperties.resize( toolCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( toolProperties ) ); + } + + //=== VK_KHR_present_wait === + + // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::waitForPresent( uint64_t presentId, uint64_t timeout ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForPresentKHR && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkWaitForPresentKHR( static_cast( m_device ), static_cast( m_swapchainKHR ), presentId, timeout ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::waitForPresent", + { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::waitForPresent", { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR } ); +# endif + + return static_cast( result ); + } + + //=== VK_NV_cooperative_matrix === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCooperativeMatrixPropertiesNV() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( + static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + //=== VK_NV_coverage_reduction_mode === + + // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV && + "Function requires " ); + + std::vector combinations; + uint32_t combinationCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + static_cast( m_physicalDevice ), &combinationCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && combinationCount ) + { + combinations.resize( combinationCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + static_cast( m_physicalDevice ), + &combinationCount, + reinterpret_cast( combinations.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); + VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); + if ( combinationCount < combinations.size() ) + { + combinations.resize( combinationCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( combinations ) ); + } + +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + + // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT && + "Function requires " ); + + std::vector presentModes; + uint32_t presentModeCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast( m_physicalDevice ), + reinterpret_cast( &surfaceInfo ), + &presentModeCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && presentModeCount ) + { + presentModes.resize( presentModeCount ); + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast( m_physicalDevice ), + reinterpret_cast( &surfaceInfo ), + &presentModeCount, + reinterpret_cast( presentModes.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" ); + VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); + if ( presentModeCount < presentModes.size() ) + { + presentModes.resize( presentModeCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentModes ) ); + } + + // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type SwapchainKHR::acquireFullScreenExclusiveModeEXT() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireFullScreenExclusiveModeEXT && + "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkAcquireFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( m_swapchainKHR ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type SwapchainKHR::releaseFullScreenExclusiveModeEXT() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseFullScreenExclusiveModeEXT && + "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkReleaseFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( m_swapchainKHR ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT && + "Function requires " ); + + DeviceGroupPresentModeFlagsKHR modes; + Result result = static_cast( + getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT( static_cast( m_device ), + reinterpret_cast( &surfaceInfo ), + reinterpret_cast( &modes ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( modes ) ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + + // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createHeadlessSurfaceEXT( HeadlessSurfaceCreateInfoEXT const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateHeadlessSurfaceEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateHeadlessSurfaceEXT( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } + + //=== VK_KHR_buffer_device_address === + + // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetBufferDeviceAddressKHR && + "Function requires or or " ); + + VkDeviceAddress result = + getDispatcher()->vkGetBufferDeviceAddressKHR( static_cast( m_device ), reinterpret_cast( &info ) ); + + return static_cast( result ); + } + + // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR && + "Function requires or " ); + + uint64_t result = + getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR( static_cast( m_device ), reinterpret_cast( &info ) ); + + return result; + } + + // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t + Device::getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR && + "Function requires or " ); + + uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR( static_cast( m_device ), + reinterpret_cast( &info ) ); + + return result; + } + + //=== VK_EXT_line_rasterization === + + // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetLineStippleEXT( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); + } + + //=== VK_EXT_host_query_reset === + + // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html + VULKAN_HPP_INLINE void QueryPool::resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPoolEXT && "Function requires or " ); + + getDispatcher()->vkResetQueryPoolEXT( static_cast( m_device ), static_cast( m_queryPool ), firstQuery, queryCount ); + } + + //=== VK_EXT_extended_dynamic_state === + + // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullModeEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetCullModeEXT( static_cast( m_commandBuffer ), static_cast( cullMode ) ); + } + + // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFaceEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetFrontFaceEXT( static_cast( m_commandBuffer ), static_cast( frontFace ) ); + } + + // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveTopologyEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetPrimitiveTopologyEXT( static_cast( m_commandBuffer ), static_cast( primitiveTopology ) ); + } + + // wrapper function for command vkCmdSetViewportWithCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWithCountEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetViewportWithCountEXT( + static_cast( m_commandBuffer ), viewports.size(), reinterpret_cast( viewports.data() ) ); + } + + // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissorWithCountEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetScissorWithCountEXT( + static_cast( m_commandBuffer ), scissors.size(), reinterpret_cast( scissors.data() ) ); + } + + // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html + VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding, + ArrayProxy const & buffers, + ArrayProxy const & offsets, + ArrayProxy const & sizes, + ArrayProxy const & strides ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers2EXT && + "Function requires or or " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); + VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); + VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); +# else + if ( buffers.size() != offsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); + } + if ( !sizes.empty() && buffers.size() != sizes.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" ); + } + if ( !strides.empty() && buffers.size() != strides.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdBindVertexBuffers2EXT( static_cast( m_commandBuffer ), + firstBinding, + buffers.size(), + reinterpret_cast( buffers.data() ), + reinterpret_cast( offsets.data() ), + reinterpret_cast( sizes.data() ), + reinterpret_cast( strides.data() ) ); + } + + // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthTestEnableEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetDepthTestEnableEXT( static_cast( m_commandBuffer ), static_cast( depthTestEnable ) ); + } + + // wrapper function for command vkCmdSetDepthWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthWriteEnableEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetDepthWriteEnableEXT( static_cast( m_commandBuffer ), static_cast( depthWriteEnable ) ); + } + + // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthCompareOpEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetDepthCompareOpEXT( static_cast( m_commandBuffer ), static_cast( depthCompareOp ) ); + } + + // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT( static_cast( m_commandBuffer ), static_cast( depthBoundsTestEnable ) ); + } + + // wrapper function for command vkCmdSetStencilTestEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilTestEnableEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetStencilTestEnableEXT( static_cast( m_commandBuffer ), static_cast( stencilTestEnable ) ); + } + + // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( + StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOpEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetStencilOpEXT( static_cast( m_commandBuffer ), + static_cast( faceMask ), + static_cast( failOp ), + static_cast( passOp ), + static_cast( depthFailOp ), + static_cast( compareOp ) ); + } + + //=== VK_KHR_deferred_host_operations === + + // wrapper function for command vkCreateDeferredOperationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createDeferredOperationKHR( Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDeferredOperationKHR && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation; + Result result = static_cast( getDispatcher()->vkCreateDeferredOperationKHR( static_cast( m_device ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &deferredOperation ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDeferredOperationKHR" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, DeferredOperationKHR( *this, *reinterpret_cast( &deferredOperation ), allocator ) ); + } + + // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t DeferredOperationKHR::getMaxConcurrency() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR && + "Function requires " ); + + uint32_t result = getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR( static_cast( m_device ), + static_cast( m_deferredOperationKHR ) ); + + return result; + } + + // wrapper function for command vkGetDeferredOperationResultKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result DeferredOperationKHR::getResult() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeferredOperationResultKHR && + "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkGetDeferredOperationResultKHR( static_cast( m_device ), static_cast( m_deferredOperationKHR ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DeferredOperationKHR::getResult", { Result::eSuccess, Result::eNotReady } ); + + return static_cast( result ); + } + + // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result DeferredOperationKHR::join() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkDeferredOperationJoinKHR && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkDeferredOperationJoinKHR( static_cast( m_device ), static_cast( m_deferredOperationKHR ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DeferredOperationKHR::join", { Result::eSuccess, Result::eThreadDoneKHR, Result::eThreadIdleKHR } ); + + return static_cast( result ); + } + + //=== VK_KHR_pipeline_executable_properties === + + // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineExecutablePropertiesKHR && + "Function requires " ); + + std::vector properties; + uint32_t executableCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPipelineExecutablePropertiesKHR( + static_cast( m_device ), reinterpret_cast( &pipelineInfo ), &executableCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && executableCount ) + { + properties.resize( executableCount ); + result = static_cast( + getDispatcher()->vkGetPipelineExecutablePropertiesKHR( static_cast( m_device ), + reinterpret_cast( &pipelineInfo ), + &executableCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); + VULKAN_HPP_ASSERT( executableCount <= properties.size() ); + if ( executableCount < properties.size() ) + { + properties.resize( executableCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineExecutableStatisticsKHR && + "Function requires " ); + + std::vector statistics; + uint32_t statisticCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPipelineExecutableStatisticsKHR( + static_cast( m_device ), reinterpret_cast( &executableInfo ), &statisticCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && statisticCount ) + { + statistics.resize( statisticCount ); + result = static_cast( + getDispatcher()->vkGetPipelineExecutableStatisticsKHR( static_cast( m_device ), + reinterpret_cast( &executableInfo ), + &statisticCount, + reinterpret_cast( statistics.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); + VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); + if ( statisticCount < statistics.size() ) + { + statistics.resize( statisticCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( statistics ) ); + } + + // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR && + "Function requires " ); + + std::vector internalRepresentations; + uint32_t internalRepresentationCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR( static_cast( m_device ), + reinterpret_cast( &executableInfo ), + &internalRepresentationCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && internalRepresentationCount ) + { + internalRepresentations.resize( internalRepresentationCount ); + result = static_cast( getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR( + static_cast( m_device ), + reinterpret_cast( &executableInfo ), + &internalRepresentationCount, + reinterpret_cast( internalRepresentations.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); + VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); + if ( internalRepresentationCount < internalRepresentations.size() ) + { + internalRepresentations.resize( internalRepresentationCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( internalRepresentations ) ); + } + + //=== VK_EXT_host_image_copy === + + // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::copyMemoryToImageEXT( const CopyMemoryToImageInfo & copyMemoryToImageInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToImageEXT && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkCopyMemoryToImageEXT( + static_cast( m_device ), reinterpret_cast( ©MemoryToImageInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMemoryToImageEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::copyImageToMemoryEXT( const CopyImageToMemoryInfo & copyImageToMemoryInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToMemoryEXT && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkCopyImageToMemoryEXT( + static_cast( m_device ), reinterpret_cast( ©ImageToMemoryInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyImageToMemoryEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::copyImageToImageEXT( const CopyImageToImageInfo & copyImageToImageInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToImageEXT && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkCopyImageToImageEXT( + static_cast( m_device ), reinterpret_cast( ©ImageToImageInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyImageToImageEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::transitionImageLayoutEXT( ArrayProxy const & transitions ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkTransitionImageLayoutEXT && + "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkTransitionImageLayoutEXT( + static_cast( m_device ), transitions.size(), reinterpret_cast( transitions.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::transitionImageLayoutEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetImageSubresourceLayout2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Image::getSubresourceLayout2EXT( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetImageSubresourceLayout2EXT && + "Function requires or or or " ); + + SubresourceLayout2 layout; + getDispatcher()->vkGetImageSubresourceLayout2EXT( static_cast( m_device ), + static_cast( m_image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return layout; + } + + // wrapper function for command vkGetImageSubresourceLayout2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Image::getSubresourceLayout2EXT( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetImageSubresourceLayout2EXT && + "Function requires or or or " ); + + StructureChain structureChain; + SubresourceLayout2 & layout = structureChain.template get(); + getDispatcher()->vkGetImageSubresourceLayout2EXT( static_cast( m_device ), + static_cast( m_image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return structureChain; + } + + //=== VK_KHR_map_memory2 === + + // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::mapMemory2KHR( const MemoryMapInfo & memoryMapInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory2KHR && "Function requires or " ); + + void * pData; + Result result = static_cast( + getDispatcher()->vkMapMemory2KHR( static_cast( m_device ), reinterpret_cast( &memoryMapInfo ), &pData ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::mapMemory2KHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pData ) ); + } + + // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory2KHR && "Function requires or " ); + + Result result = static_cast( + getDispatcher()->vkUnmapMemory2KHR( static_cast( m_device ), reinterpret_cast( &memoryUnmapInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::unmapMemory2KHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + //=== VK_EXT_swapchain_maintenance1 === + + // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseSwapchainImagesEXT && + "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkReleaseSwapchainImagesEXT( + static_cast( m_device ), reinterpret_cast( &releaseInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::releaseSwapchainImagesEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + //=== VK_NV_device_generated_commands === + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV && + "Function requires " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV && + "Function requires " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html + VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPreprocessGeneratedCommandsNV && + "Function requires " ); + + getDispatcher()->vkCmdPreprocessGeneratedCommandsNV( static_cast( m_commandBuffer ), + reinterpret_cast( &generatedCommandsInfo ) ); + } + + // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html + VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( Bool32 isPreprocessed, + const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdExecuteGeneratedCommandsNV && + "Function requires " ); + + getDispatcher()->vkCmdExecuteGeneratedCommandsNV( static_cast( m_commandBuffer ), + static_cast( isPreprocessed ), + reinterpret_cast( &generatedCommandsInfo ) ); + } + + // wrapper function for command vkCmdBindPipelineShaderGroupNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html + VULKAN_HPP_INLINE void CommandBuffer::bindPipelineShaderGroupNV( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::Pipeline pipeline, + uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindPipelineShaderGroupNV && + "Function requires " ); + + getDispatcher()->vkCmdBindPipelineShaderGroupNV( static_cast( m_commandBuffer ), + static_cast( pipelineBindPoint ), + static_cast( pipeline ), + groupIndex ); + } + + // wrapper function for command vkCreateIndirectCommandsLayoutNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createIndirectCommandsLayoutNV( IndirectCommandsLayoutCreateInfoNV const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateIndirectCommandsLayoutNV && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout; + Result result = + static_cast( getDispatcher()->vkCreateIndirectCommandsLayoutNV( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &indirectCommandsLayout ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, IndirectCommandsLayoutNV( *this, *reinterpret_cast( &indirectCommandsLayout ), allocator ) ); + } + + //=== VK_EXT_depth_bias_control === + + // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const DepthBiasInfoEXT & depthBiasInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBias2EXT && "Function requires " ); + + getDispatcher()->vkCmdSetDepthBias2EXT( static_cast( m_commandBuffer ), reinterpret_cast( &depthBiasInfo ) ); + } + + //=== VK_EXT_acquire_drm_display === + + // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireDrmDisplayEXT && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkAcquireDrmDisplayEXT( static_cast( m_physicalDevice ), drmFd, static_cast( display ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDrmDisplayEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::DisplayKHR display; + Result result = static_cast( getDispatcher()->vkGetDrmDisplayEXT( + static_cast( m_physicalDevice ), drmFd, connectorId, reinterpret_cast( &display ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, DisplayKHR( *this, *reinterpret_cast( &display ) ) ); + } + + //=== VK_EXT_private_data === + + // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createPrivateDataSlotEXT( PrivateDataSlotCreateInfo const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreatePrivateDataSlotEXT && + "Function requires or " ); + + VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; + Result result = static_cast( getDispatcher()->vkCreatePrivateDataSlotEXT( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &privateDataSlot ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, PrivateDataSlot( *this, *reinterpret_cast( &privateDataSlot ), allocator ) ); + } + + // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html + VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, + Optional allocator ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkDestroyPrivateDataSlotEXT && + "Function requires or " ); + + getDispatcher()->vkDestroyPrivateDataSlotEXT( static_cast( m_device ), + static_cast( privateDataSlot ), + reinterpret_cast( allocator.get() ) ); + } + + // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::setPrivateDataEXT( ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetPrivateDataEXT && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkSetPrivateDataEXT( + static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::setPrivateDataEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateDataEXT( ObjectType objectType_, + uint64_t objectHandle, + VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateDataEXT && "Function requires or " ); + + uint64_t data; + getDispatcher()->vkGetPrivateDataEXT( + static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), &data ); + + return data; + } + + //=== VK_KHR_video_encode_queue === + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, + VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && + "Function requires " ); + return static_cast( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + static_cast( m_physicalDevice ), + reinterpret_cast( pQualityLevelInfo ), + reinterpret_cast( pQualityLevelProperties ) ) ); + } + + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && + "Function requires " ); + + VideoEncodeQualityLevelPropertiesKHR qualityLevelProperties; + Result result = static_cast( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + static_cast( m_physicalDevice ), + reinterpret_cast( &qualityLevelInfo ), + reinterpret_cast( &qualityLevelProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( qualityLevelProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && + "Function requires " ); + + StructureChain structureChain; + VideoEncodeQualityLevelPropertiesKHR & qualityLevelProperties = structureChain.template get(); + Result result = static_cast( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + static_cast( m_physicalDevice ), + reinterpret_cast( &qualityLevelInfo ), + reinterpret_cast( &qualityLevelProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); + } + + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>>::type + Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetEncodedVideoSessionParametersKHR && + "Function requires " ); + + std::pair> data_; + VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; + std::vector & data = data_.second; + size_t dataSize; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( + static_cast( m_device ), + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( + static_cast( m_device ), + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, std::vector>>::type + Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetEncodedVideoSessionParametersKHR && + "Function requires " ); + + std::pair, std::vector> data_; + VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first.template get(); + std::vector & data = data_.second; + size_t dataSize; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( + static_cast( m_device ), + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( + static_cast( m_device ), + reinterpret_cast( &videoSessionParametersInfo ), + reinterpret_cast( &feedbackInfo ), + &dataSize, + reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html + VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEncodeVideoKHR && "Function requires " ); + + getDispatcher()->vkCmdEncodeVideoKHR( static_cast( m_commandBuffer ), reinterpret_cast( &encodeInfo ) ); + } + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + + // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createCudaModuleNV( CudaModuleCreateInfoNV const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateCudaModuleNV && "Function requires " ); + + VULKAN_HPP_NAMESPACE::CudaModuleNV module; + Result result = static_cast( getDispatcher()->vkCreateCudaModuleNV( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &module ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createCudaModuleNV" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, CudaModuleNV( *this, *reinterpret_cast( &module ), allocator ) ); + } + + // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type CudaModuleNV::getCache() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetCudaModuleCacheNV && "Function requires " ); + + std::vector cacheData; + size_t cacheSize; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetCudaModuleCacheNV( static_cast( m_device ), static_cast( m_cudaModuleNV ), &cacheSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && cacheSize ) + { + cacheData.resize( cacheSize ); + result = static_cast( getDispatcher()->vkGetCudaModuleCacheNV( + static_cast( m_device ), static_cast( m_cudaModuleNV ), &cacheSize, reinterpret_cast( cacheData.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CudaModuleNV::getCache" ); + VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() ); + if ( cacheSize < cacheData.size() ) + { + cacheData.resize( cacheSize ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( cacheData ) ); + } + + // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createCudaFunctionNV( CudaFunctionCreateInfoNV const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateCudaFunctionNV && "Function requires " ); + + VULKAN_HPP_NAMESPACE::CudaFunctionNV function; + Result result = static_cast( getDispatcher()->vkCreateCudaFunctionNV( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &function ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createCudaFunctionNV" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, + CudaFunctionNV( *this, *reinterpret_cast( &function ), allocator ) ); + } + + // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html + VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const CudaLaunchInfoNV & launchInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCudaLaunchKernelNV && "Function requires " ); + + getDispatcher()->vkCmdCudaLaunchKernelNV( static_cast( m_commandBuffer ), reinterpret_cast( &launchInfo ) ); + } +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_QCOM_tile_shading === + + // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html + VULKAN_HPP_INLINE void CommandBuffer::dispatchTileQCOM( const DispatchTileInfoQCOM & dispatchTileInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchTileQCOM && "Function requires " ); + + getDispatcher()->vkCmdDispatchTileQCOM( static_cast( m_commandBuffer ), + reinterpret_cast( &dispatchTileInfo ) ); + } + + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM & perTileBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginPerTileExecutionQCOM && "Function requires " ); + + getDispatcher()->vkCmdBeginPerTileExecutionQCOM( static_cast( m_commandBuffer ), + reinterpret_cast( &perTileBeginInfo ) ); + } + + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const PerTileEndInfoQCOM & perTileEndInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndPerTileExecutionQCOM && "Function requires " ); + + getDispatcher()->vkCmdEndPerTileExecutionQCOM( static_cast( m_commandBuffer ), + reinterpret_cast( &perTileEndInfo ) ); + } + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + + // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html + VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( ExportMetalObjectsInfoEXT & metalObjectsInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function requires " ); + + getDispatcher()->vkExportMetalObjectsEXT( static_cast( m_device ), reinterpret_cast( &metalObjectsInfo ) ); + } +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_synchronization2 === + + // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent2KHR && "Function requires or " ); + + getDispatcher()->vkCmdSetEvent2KHR( + static_cast( m_commandBuffer ), static_cast( event ), reinterpret_cast( &dependencyInfo ) ); + } + + // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2KHR && "Function requires or " ); + + getDispatcher()->vkCmdResetEvent2KHR( + static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); + } + + // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR( ArrayProxy const & events, + ArrayProxy const & dependencyInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents2KHR && "Function requires or " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); +# else + if ( events.size() != dependencyInfos.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdWaitEvents2KHR( static_cast( m_commandBuffer ), + events.size(), + reinterpret_cast( events.data() ), + reinterpret_cast( dependencyInfos.data() ) ); + } + + // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2KHR && + "Function requires or " ); + + getDispatcher()->vkCmdPipelineBarrier2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &dependencyInfo ) ); + } + + // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html + VULKAN_HPP_INLINE void + CommandBuffer::writeTimestamp2KHR( PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2KHR && + "Function requires or " ); + + getDispatcher()->vkCmdWriteTimestamp2KHR( + static_cast( m_commandBuffer ), static_cast( stage ), static_cast( queryPool ), query ); + } + + // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html + VULKAN_HPP_INLINE typename ResultValueType::type Queue::submit2KHR( ArrayProxy const & submits, + VULKAN_HPP_NAMESPACE::Fence fence ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2KHR && "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkQueueSubmit2KHR( + static_cast( m_queue ), submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::submit2KHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + //=== VK_EXT_descriptor_buffer === + + // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize DescriptorSetLayout::getSizeEXT() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSizeEXT && "Function requires " ); + + DeviceSize layoutSizeInBytes; + getDispatcher()->vkGetDescriptorSetLayoutSizeEXT( static_cast( m_device ), + static_cast( m_descriptorSetLayout ), + reinterpret_cast( &layoutSizeInBytes ) ); + + return layoutSizeInBytes; + } + + // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize DescriptorSetLayout::getBindingOffsetEXT( uint32_t binding ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutBindingOffsetEXT && + "Function requires " ); + + DeviceSize offset; + getDispatcher()->vkGetDescriptorSetLayoutBindingOffsetEXT( + static_cast( m_device ), static_cast( m_descriptorSetLayout ), binding, reinterpret_cast( &offset ) ); + + return offset; + } + + // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html + VULKAN_HPP_INLINE void + Device::getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorEXT && "Function requires " ); + + getDispatcher()->vkGetDescriptorEXT( + static_cast( m_device ), reinterpret_cast( &descriptorInfo ), dataSize, pDescriptor ); + } + + // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorType Device::getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorEXT && "Function requires " ); + + DescriptorType descriptor; + getDispatcher()->vkGetDescriptorEXT( static_cast( m_device ), + reinterpret_cast( &descriptorInfo ), + sizeof( DescriptorType ), + reinterpret_cast( &descriptor ) ); + + return descriptor; + } + + // wrapper function for command vkCmdBindDescriptorBuffersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html + VULKAN_HPP_INLINE void + CommandBuffer::bindDescriptorBuffersEXT( ArrayProxy const & bindingInfos ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorBuffersEXT && "Function requires " ); + + getDispatcher()->vkCmdBindDescriptorBuffersEXT( static_cast( m_commandBuffer ), + bindingInfos.size(), + reinterpret_cast( bindingInfos.data() ) ); + } + + // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t firstSet, + ArrayProxy const & bufferIndices, + ArrayProxy const & offsets ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDescriptorBufferOffsetsEXT && + "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( bufferIndices.size() == offsets.size() ); +# else + if ( bufferIndices.size() != offsets.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setDescriptorBufferOffsetsEXT: bufferIndices.size() != offsets.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdSetDescriptorBufferOffsetsEXT( static_cast( m_commandBuffer ), + static_cast( pipelineBindPoint ), + static_cast( layout ), + firstSet, + bufferIndices.size(), + bufferIndices.data(), + reinterpret_cast( offsets.data() ) ); + } + + // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::PipelineLayout layout, + uint32_t set ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplersEXT && + "Function requires " ); + + getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplersEXT( + static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( layout ), set ); + } + + // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferOpaqueCaptureDescriptorDataEXT && + "Function requires " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkGetBufferOpaqueCaptureDescriptorDataEXT( + static_cast( m_device ), reinterpret_cast( &info ), &data ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getBufferOpaqueCaptureDescriptorDataEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageOpaqueCaptureDescriptorDataEXT && + "Function requires " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkGetImageOpaqueCaptureDescriptorDataEXT( + static_cast( m_device ), reinterpret_cast( &info ), &data ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDescriptorDataEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewOpaqueCaptureDescriptorDataEXT && + "Function requires " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkGetImageViewOpaqueCaptureDescriptorDataEXT( + static_cast( m_device ), reinterpret_cast( &info ), &data ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getImageViewOpaqueCaptureDescriptorDataEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSamplerOpaqueCaptureDescriptorDataEXT && + "Function requires " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkGetSamplerOpaqueCaptureDescriptorDataEXT( + static_cast( m_device ), reinterpret_cast( &info ), &data ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getSamplerOpaqueCaptureDescriptorDataEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT && + "Function requires " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + static_cast( m_device ), reinterpret_cast( &info ), &data ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + //=== VK_NV_fragment_shading_rate_enums === + + // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html + VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, + const FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFragmentShadingRateEnumNV && + "Function requires " ); + + getDispatcher()->vkCmdSetFragmentShadingRateEnumNV( static_cast( m_commandBuffer ), + static_cast( shadingRate ), + reinterpret_cast( combinerOps ) ); + } + + //=== VK_EXT_mesh_shader === + + // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksEXT && "Function requires " ); + + getDispatcher()->vkCmdDrawMeshTasksEXT( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); + } + + // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + uint32_t drawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectEXT && "Function requires " ); + + getDispatcher()->vkCmdDrawMeshTasksIndirectEXT( + static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); + } + + // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html + VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + VULKAN_HPP_NAMESPACE::Buffer countBuffer, + DeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountEXT && "Function requires " ); + + getDispatcher()->vkCmdDrawMeshTasksIndirectCountEXT( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( countBuffer ), + static_cast( countBufferOffset ), + maxDrawCount, + stride ); + } + + //=== VK_KHR_copy_commands2 === + + // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2KHR && "Function requires or " ); + + getDispatcher()->vkCmdCopyBuffer2KHR( static_cast( m_commandBuffer ), reinterpret_cast( ©BufferInfo ) ); + } + + // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2KHR && "Function requires or " ); + + getDispatcher()->vkCmdCopyImage2KHR( static_cast( m_commandBuffer ), reinterpret_cast( ©ImageInfo ) ); + } + + // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2KHR && + "Function requires or " ); + + getDispatcher()->vkCmdCopyBufferToImage2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( ©BufferToImageInfo ) ); + } + + // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2KHR && + "Function requires or " ); + + getDispatcher()->vkCmdCopyImageToBuffer2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( ©ImageToBufferInfo ) ); + } + + // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2KHR && "Function requires or " ); + + getDispatcher()->vkCmdBlitImage2KHR( static_cast( m_commandBuffer ), reinterpret_cast( &blitImageInfo ) ); + } + + // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2KHR && "Function requires or " ); + + getDispatcher()->vkCmdResolveImage2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &resolveImageInfo ) ); + } + + //=== VK_EXT_device_fault === + // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts, + DeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceFaultInfoEXT && "Function requires " ); + return static_cast( getDispatcher()->vkGetDeviceFaultInfoEXT( static_cast( m_device ), + reinterpret_cast( pFaultCounts ), + reinterpret_cast( pFaultInfo ) ) ); + } +# if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_NV_acquire_winrt_display === + + // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html + VULKAN_HPP_INLINE typename ResultValueType::type DisplayKHR::acquireWinrtNV() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireWinrtDisplayNV && "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkAcquireWinrtDisplayNV( static_cast( m_physicalDevice ), static_cast( m_displayKHR ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetWinrtDisplayNV && "Function requires " ); + + VULKAN_HPP_NAMESPACE::DisplayKHR display; + Result result = static_cast( getDispatcher()->vkGetWinrtDisplayNV( + static_cast( m_physicalDevice ), deviceRelativeId, reinterpret_cast( &display ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, DisplayKHR( *this, *reinterpret_cast( &display ) ) ); + } +# endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createDirectFBSurfaceEXT( DirectFBSurfaceCreateInfoEXT const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDirectFBSurfaceEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateDirectFBSurfaceEXT( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } + + // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, + IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT && + "Function requires " ); + + VkBool32 result = + getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT( static_cast( m_physicalDevice ), queueFamilyIndex, &dfb ); + + return static_cast( result ); + } +# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_vertex_input_dynamic_state === + + // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html + VULKAN_HPP_INLINE void + CommandBuffer::setVertexInputEXT( ArrayProxy const & vertexBindingDescriptions, + ArrayProxy const & vertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetVertexInputEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetVertexInputEXT( static_cast( m_commandBuffer ), + vertexBindingDescriptions.size(), + reinterpret_cast( vertexBindingDescriptions.data() ), + vertexAttributeDescriptions.size(), + reinterpret_cast( vertexAttributeDescriptions.data() ) ); + } + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_memory === + + // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryZirconHandleFUCHSIA && "Function requires " ); + + zx_handle_t zirconHandle; + Result result = static_cast( getDispatcher()->vkGetMemoryZirconHandleFUCHSIA( + static_cast( m_device ), reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( zirconHandle ) ); + } + + // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA && + "Function requires " ); + + MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties; + Result result = static_cast( getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA( + static_cast( m_device ), + static_cast( handleType ), + zirconHandle, + reinterpret_cast( &memoryZirconHandleProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryZirconHandleProperties ) ); + } +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_external_semaphore === + + // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA && + "Function requires " ); + + Result result = static_cast( getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA( + static_cast( m_device ), reinterpret_cast( &importSemaphoreZirconHandleInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA && + "Function requires " ); + + zx_handle_t zirconHandle; + Result result = static_cast( getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA( + static_cast( m_device ), reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( zirconHandle ) ); + } +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + // wrapper function for command vkCreateBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createBufferCollectionFUCHSIA( BufferCollectionCreateInfoFUCHSIA const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateBufferCollectionFUCHSIA && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection; + Result result = + static_cast( getDispatcher()->vkCreateBufferCollectionFUCHSIA( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &collection ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIA" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, BufferCollectionFUCHSIA( *this, *reinterpret_cast( &collection ), allocator ) ); + } + + // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html + VULKAN_HPP_INLINE typename ResultValueType::type + BufferCollectionFUCHSIA::setImageConstraints( const ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA && + "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA( static_cast( m_device ), + static_cast( m_bufferCollectionFUCHSIA ), + reinterpret_cast( &imageConstraintsInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setImageConstraints" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html + VULKAN_HPP_INLINE typename ResultValueType::type + BufferCollectionFUCHSIA::setBufferConstraints( const BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA && + "Function requires " ); + + Result result = static_cast( + getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA( static_cast( m_device ), + static_cast( m_bufferCollectionFUCHSIA ), + reinterpret_cast( &bufferConstraintsInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setBufferConstraints" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type BufferCollectionFUCHSIA::getProperties() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA && + "Function requires " ); + + BufferCollectionPropertiesFUCHSIA properties; + Result result = static_cast( + getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA( static_cast( m_device ), + static_cast( m_bufferCollectionFUCHSIA ), + reinterpret_cast( &properties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::BufferCollectionFUCHSIA::getProperties" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_HUAWEI_subpass_shading === + + // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI && + "Function requires " ); + + Extent2D maxWorkgroupSize; + Result result = static_cast( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( + static_cast( m_device ), static_cast( m_renderPass ), reinterpret_cast( &maxWorkgroupSize ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( maxWorkgroupSize ) ); + } + + // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html + VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSubpassShadingHUAWEI && "Function requires " ); + + getDispatcher()->vkCmdSubpassShadingHUAWEI( static_cast( m_commandBuffer ) ); + } + + //=== VK_HUAWEI_invocation_mask === + + // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html + VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, + ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindInvocationMaskHUAWEI && "Function requires " ); + + getDispatcher()->vkCmdBindInvocationMaskHUAWEI( + static_cast( m_commandBuffer ), static_cast( imageView ), static_cast( imageLayout ) ); + } + + //=== VK_NV_external_memory_rdma === + + // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryRemoteAddressNV && "Function requires " ); + + RemoteAddressNV address; + Result result = static_cast( + getDispatcher()->vkGetMemoryRemoteAddressNV( static_cast( m_device ), + reinterpret_cast( &memoryGetRemoteAddressInfo ), + reinterpret_cast( &address ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( address ) ); + } + + //=== VK_EXT_pipeline_properties === + + // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getPipelinePropertiesEXT( const PipelineInfoEXT & pipelineInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelinePropertiesEXT && "Function requires " ); + + BaseOutStructure pipelineProperties; + Result result = static_cast( getDispatcher()->vkGetPipelinePropertiesEXT( static_cast( m_device ), + reinterpret_cast( &pipelineInfo ), + reinterpret_cast( &pipelineProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelineProperties ) ); + } + + //=== VK_EXT_extended_dynamic_state2 === + + // wrapper function for command vkCmdSetPatchControlPointsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPatchControlPointsEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetPatchControlPointsEXT( static_cast( m_commandBuffer ), patchControlPoints ); + } + + // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT( Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT( static_cast( m_commandBuffer ), static_cast( rasterizerDiscardEnable ) ); + } + + // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBiasEnableEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetDepthBiasEnableEXT( static_cast( m_commandBuffer ), static_cast( depthBiasEnable ) ); + } + + // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetLogicOpEXT( static_cast( m_commandBuffer ), static_cast( logicOp ) ); + } + + // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT( Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT && + "Function requires or or " ); + + getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT( static_cast( m_commandBuffer ), static_cast( primitiveRestartEnable ) ); + } + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createScreenSurfaceQNX( ScreenSurfaceCreateInfoQNX const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateScreenSurfaceQNX && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateScreenSurfaceQNX( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } + + // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, + struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX && + "Function requires " ); + + VkBool32 result = + getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX( static_cast( m_physicalDevice ), queueFamilyIndex, &window ); + + return static_cast( result ); + } +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_EXT_color_write_enable === + + // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( ArrayProxy const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteEnableEXT && "Function requires " ); + + getDispatcher()->vkCmdSetColorWriteEnableEXT( + static_cast( m_commandBuffer ), colorWriteEnables.size(), reinterpret_cast( colorWriteEnables.data() ) ); + } + + //=== VK_KHR_ray_tracing_maintenance1 === + + // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirect2KHR( DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysIndirect2KHR && "Function requires " ); + + getDispatcher()->vkCmdTraceRaysIndirect2KHR( static_cast( m_commandBuffer ), static_cast( indirectDeviceAddress ) ); + } + + //=== VK_EXT_multi_draw === + + // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html + VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT( StridedArrayProxy const & vertexInfo, + uint32_t instanceCount, + uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiEXT && "Function requires " ); + + getDispatcher()->vkCmdDrawMultiEXT( static_cast( m_commandBuffer ), + vertexInfo.size(), + reinterpret_cast( vertexInfo.data() ), + instanceCount, + firstInstance, + vertexInfo.stride() ); + } + + // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html + VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT( StridedArrayProxy const & indexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + Optional vertexOffset ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiIndexedEXT && "Function requires " ); + + getDispatcher()->vkCmdDrawMultiIndexedEXT( static_cast( m_commandBuffer ), + indexInfo.size(), + reinterpret_cast( indexInfo.data() ), + instanceCount, + firstInstance, + indexInfo.stride(), + vertexOffset.get() ); + } + + //=== VK_EXT_opacity_micromap === + + // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createMicromapEXT( MicromapCreateInfoEXT const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateMicromapEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::MicromapEXT micromap; + Result result = static_cast( getDispatcher()->vkCreateMicromapEXT( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( µmap ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createMicromapEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, MicromapEXT( *this, *reinterpret_cast( µmap ), allocator ) ); + } + + // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html + VULKAN_HPP_INLINE void CommandBuffer::buildMicromapsEXT( ArrayProxy const & infos ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildMicromapsEXT && "Function requires " ); + + getDispatcher()->vkCmdBuildMicromapsEXT( + static_cast( m_commandBuffer ), infos.size(), reinterpret_cast( infos.data() ) ); + } + + // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + ArrayProxy const & infos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBuildMicromapsEXT && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkBuildMicromapsEXT( static_cast( m_device ), + static_cast( deferredOperation ), + infos.size(), + reinterpret_cast( infos.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::buildMicromapsEXT", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } + + // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const CopyMicromapInfoEXT & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMicromapEXT && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkCopyMicromapEXT( static_cast( m_device ), + static_cast( deferredOperation ), + reinterpret_cast( &info ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMicromapEXT", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } + + // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const CopyMicromapToMemoryInfoEXT & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMicromapToMemoryEXT && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkCopyMicromapToMemoryEXT( static_cast( m_device ), + static_cast( deferredOperation ), + reinterpret_cast( &info ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMicromapToMemoryEXT", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } + + // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, + const CopyMemoryToMicromapInfoEXT & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToMicromapEXT && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkCopyMemoryToMicromapEXT( static_cast( m_device ), + static_cast( deferredOperation ), + reinterpret_cast( &info ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMemoryToMicromapEXT", + { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); + + return static_cast( result ); + } + + // wrapper function for command vkWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::writeMicromapsPropertiesEXT( + ArrayProxy const & micromaps, QueryType queryType, size_t dataSize, size_t stride ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkWriteMicromapsPropertiesEXT && "Function requires " ); + + VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); + std::vector data( dataSize / sizeof( DataType ) ); + Result result = static_cast( getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast( m_device ), + micromaps.size(), + reinterpret_cast( micromaps.data() ), + static_cast( queryType ), + data.size() * sizeof( DataType ), + reinterpret_cast( data.data() ), + stride ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeMicromapsPropertiesEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::writeMicromapsPropertyEXT( ArrayProxy const & micromaps, QueryType queryType, size_t stride ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkWriteMicromapsPropertiesEXT && "Function requires " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast( m_device ), + micromaps.size(), + reinterpret_cast( micromaps.data() ), + static_cast( queryType ), + sizeof( DataType ), + reinterpret_cast( &data ), + stride ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeMicromapsPropertyEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html + VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const CopyMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMicromapEXT && "Function requires " ); + + getDispatcher()->vkCmdCopyMicromapEXT( static_cast( m_commandBuffer ), reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html + VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMicromapToMemoryEXT && "Function requires " ); + + getDispatcher()->vkCmdCopyMicromapToMemoryEXT( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToMicromapEXT && "Function requires " ); + + getDispatcher()->vkCmdCopyMemoryToMicromapEXT( static_cast( m_commandBuffer ), + reinterpret_cast( &info ) ); + } + + // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html + VULKAN_HPP_INLINE void CommandBuffer::writeMicromapsPropertiesEXT( ArrayProxy const & micromaps, + QueryType queryType, + VULKAN_HPP_NAMESPACE::QueryPool queryPool, + uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteMicromapsPropertiesEXT && + "Function requires " ); + + getDispatcher()->vkCmdWriteMicromapsPropertiesEXT( static_cast( m_commandBuffer ), + micromaps.size(), + reinterpret_cast( micromaps.data() ), + static_cast( queryType ), + static_cast( queryPool ), + firstQuery ); + } + + // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureCompatibilityKHR + Device::getMicromapCompatibilityEXT( const MicromapVersionInfoEXT & versionInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMicromapCompatibilityEXT && + "Function requires " ); + + AccelerationStructureCompatibilityKHR compatibility; + getDispatcher()->vkGetDeviceMicromapCompatibilityEXT( static_cast( m_device ), + reinterpret_cast( &versionInfo ), + reinterpret_cast( &compatibility ) ); + + return compatibility; + } + + // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MicromapBuildSizesInfoEXT + Device::getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, const MicromapBuildInfoEXT & buildInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMicromapBuildSizesEXT && "Function requires " ); + + MicromapBuildSizesInfoEXT sizeInfo; + getDispatcher()->vkGetMicromapBuildSizesEXT( static_cast( m_device ), + static_cast( buildType ), + reinterpret_cast( &buildInfo ), + reinterpret_cast( &sizeInfo ) ); + + return sizeInfo; + } + + //=== VK_HUAWEI_cluster_culling_shader === + + // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html + VULKAN_HPP_INLINE void CommandBuffer::drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawClusterHUAWEI && "Function requires " ); + + getDispatcher()->vkCmdDrawClusterHUAWEI( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); + } + + // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html + VULKAN_HPP_INLINE void CommandBuffer::drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawClusterIndirectHUAWEI && + "Function requires " ); + + getDispatcher()->vkCmdDrawClusterIndirectHUAWEI( + static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ) ); + } + + //=== VK_EXT_pageable_device_local_memory === + + // wrapper function for command vkSetDeviceMemoryPriorityEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html + VULKAN_HPP_INLINE void DeviceMemory::setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetDeviceMemoryPriorityEXT && + "Function requires " ); + + getDispatcher()->vkSetDeviceMemoryPriorityEXT( static_cast( m_device ), static_cast( m_deviceMemory ), priority ); + } + + //=== VK_KHR_maintenance4 === + + // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR && + "Function requires or " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR && + "Function requires or " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR && + "Function requires or " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR && + "Function requires or " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR && + "Function requires or " ); + + std::vector sparseMemoryRequirements; + uint32_t sparseMemoryRequirementCount; + getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( + static_cast( m_device ), reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( static_cast( m_device ), + reinterpret_cast( &info ), + &sparseMemoryRequirementCount, + reinterpret_cast( sparseMemoryRequirements.data() ) ); + + VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); + if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) + { + sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); + } + return sparseMemoryRequirements; + } + + //=== VK_VALVE_descriptor_set_host_mapping === + + // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutHostMappingInfoVALVE + Device::getDescriptorSetLayoutHostMappingInfoVALVE( const DescriptorSetBindingReferenceVALVE & bindingReference ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutHostMappingInfoVALVE && + "Function requires " ); + + DescriptorSetLayoutHostMappingInfoVALVE hostMapping; + getDispatcher()->vkGetDescriptorSetLayoutHostMappingInfoVALVE( static_cast( m_device ), + reinterpret_cast( &bindingReference ), + reinterpret_cast( &hostMapping ) ); + + return hostMapping; + } + + // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * DescriptorSet::getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetHostMappingVALVE && + "Function requires " ); + + void * pData; + getDispatcher()->vkGetDescriptorSetHostMappingVALVE( static_cast( m_device ), static_cast( m_descriptorSet ), &pData ); + + return pData; + } + + //=== VK_NV_copy_memory_indirect === + + // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectNV( DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryIndirectNV && "Function requires " ); + + getDispatcher()->vkCmdCopyMemoryIndirectNV( + static_cast( m_commandBuffer ), static_cast( copyBufferAddress ), copyCount, stride ); + } + + // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html + VULKAN_HPP_INLINE void + CommandBuffer::copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, + uint32_t stride, + VULKAN_HPP_NAMESPACE::Image dstImage, + ImageLayout dstImageLayout, + ArrayProxy const & imageSubresources ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToImageIndirectNV && + "Function requires " ); + + getDispatcher()->vkCmdCopyMemoryToImageIndirectNV( static_cast( m_commandBuffer ), + static_cast( copyBufferAddress ), + imageSubresources.size(), + stride, + static_cast( dstImage ), + static_cast( dstImageLayout ), + reinterpret_cast( imageSubresources.data() ) ); + } + + //=== VK_NV_memory_decompression === + + // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html + VULKAN_HPP_INLINE void + CommandBuffer::decompressMemoryNV( ArrayProxy const & decompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryNV && "Function requires " ); + + getDispatcher()->vkCmdDecompressMemoryNV( static_cast( m_commandBuffer ), + decompressMemoryRegions.size(), + reinterpret_cast( decompressMemoryRegions.data() ) ); + } + + // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html + VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountNV( DeviceAddress indirectCommandsAddress, + DeviceAddress indirectCommandsCountAddress, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryIndirectCountNV && + "Function requires " ); + + getDispatcher()->vkCmdDecompressMemoryIndirectCountNV( static_cast( m_commandBuffer ), + static_cast( indirectCommandsAddress ), + static_cast( indirectCommandsCountAddress ), + stride ); + } + + //=== VK_NV_device_generated_commands_compute === + + // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV && + "Function requires " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV && + "Function requires " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html + VULKAN_HPP_INLINE void CommandBuffer::updatePipelineIndirectBufferNV( PipelineBindPoint pipelineBindPoint, + VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdUpdatePipelineIndirectBufferNV && + "Function requires " ); + + getDispatcher()->vkCmdUpdatePipelineIndirectBufferNV( + static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( pipeline ) ); + } + + // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceAddress + Device::getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineIndirectDeviceAddressNV && + "Function requires " ); + + VkDeviceAddress result = getDispatcher()->vkGetPipelineIndirectDeviceAddressNV( + static_cast( m_device ), reinterpret_cast( &info ) ); + + return static_cast( result ); + } + +# if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_external_memory === + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer * buffer, + NativeBufferPropertiesOHOS * pProperties ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetNativeBufferPropertiesOHOS && "Function requires " ); + return static_cast( getDispatcher()->vkGetNativeBufferPropertiesOHOS( + static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); + } + + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetNativeBufferPropertiesOHOS && "Function requires " ); + + NativeBufferPropertiesOHOS properties; + Result result = static_cast( getDispatcher()->vkGetNativeBufferPropertiesOHOS( + static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getNativeBufferPropertiesOHOS" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetNativeBufferPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetNativeBufferPropertiesOHOS && "Function requires " ); + + StructureChain structureChain; + NativeBufferPropertiesOHOS & properties = structureChain.template get(); + Result result = static_cast( getDispatcher()->vkGetNativeBufferPropertiesOHOS( + static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getNativeBufferPropertiesOHOS" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); + } + + // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryNativeBufferOHOS && "Function requires " ); + + struct OH_NativeBuffer * buffer; + Result result = static_cast( getDispatcher()->vkGetMemoryNativeBufferOHOS( + static_cast( m_device ), reinterpret_cast( &info ), &buffer ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryNativeBufferOHOS" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( buffer ) ); + } +# endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_EXT_extended_dynamic_state3 === + + // wrapper function for command vkCmdSetDepthClampEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClampEnableEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetDepthClampEnableEXT( static_cast( m_commandBuffer ), static_cast( depthClampEnable ) ); + } + + // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setPolygonModeEXT( PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPolygonModeEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetPolygonModeEXT( static_cast( m_commandBuffer ), static_cast( polygonMode ) ); + } + + // wrapper function for command vkCmdSetRasterizationSamplesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setRasterizationSamplesEXT( SampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizationSamplesEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetRasterizationSamplesEXT( static_cast( m_commandBuffer ), + static_cast( rasterizationSamples ) ); + } + + // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setSampleMaskEXT( SampleCountFlagBits samples, ArrayProxy const & sampleMask ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleMaskEXT && + "Function requires or " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( sampleMask.size() == ( static_cast( samples ) + 31 ) / 32 ); +# else + if ( sampleMask.size() != ( static_cast( samples ) + 31 ) / 32 ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::CommandBuffer::setSampleMaskEXT: sampleMask.size() != ( static_cast( samples ) + 31 ) / 32" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdSetSampleMaskEXT( static_cast( m_commandBuffer ), + static_cast( samples ), + reinterpret_cast( sampleMask.data() ) ); + } + + // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setAlphaToCoverageEnableEXT( Bool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAlphaToCoverageEnableEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetAlphaToCoverageEnableEXT( static_cast( m_commandBuffer ), static_cast( alphaToCoverageEnable ) ); + } + + // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setAlphaToOneEnableEXT( Bool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAlphaToOneEnableEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetAlphaToOneEnableEXT( static_cast( m_commandBuffer ), static_cast( alphaToOneEnable ) ); + } + + // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEnableEXT( Bool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEnableEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetLogicOpEnableEXT( static_cast( m_commandBuffer ), static_cast( logicOpEnable ) ); + } + + // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( uint32_t firstAttachment, + ArrayProxy const & colorBlendEnables ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendEnableEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetColorBlendEnableEXT( static_cast( m_commandBuffer ), + firstAttachment, + colorBlendEnables.size(), + reinterpret_cast( colorBlendEnables.data() ) ); + } + + // wrapper function for command vkCmdSetColorBlendEquationEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html + VULKAN_HPP_INLINE void + CommandBuffer::setColorBlendEquationEXT( uint32_t firstAttachment, + ArrayProxy const & colorBlendEquations ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendEquationEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetColorBlendEquationEXT( static_cast( m_commandBuffer ), + firstAttachment, + colorBlendEquations.size(), + reinterpret_cast( colorBlendEquations.data() ) ); + } + + // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT( uint32_t firstAttachment, + ArrayProxy const & colorWriteMasks ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteMaskEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetColorWriteMaskEXT( static_cast( m_commandBuffer ), + firstAttachment, + colorWriteMasks.size(), + reinterpret_cast( colorWriteMasks.data() ) ); + } + + // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setTessellationDomainOriginEXT( TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetTessellationDomainOriginEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetTessellationDomainOriginEXT( static_cast( m_commandBuffer ), + static_cast( domainOrigin ) ); + } + + // wrapper function for command vkCmdSetRasterizationStreamEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizationStreamEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetRasterizationStreamEXT( static_cast( m_commandBuffer ), rasterizationStream ); + } + + // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html + VULKAN_HPP_INLINE void + CommandBuffer::setConservativeRasterizationModeEXT( ConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetConservativeRasterizationModeEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetConservativeRasterizationModeEXT( static_cast( m_commandBuffer ), + static_cast( conservativeRasterizationMode ) ); + } + + // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExtraPrimitiveOverestimationSizeEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetExtraPrimitiveOverestimationSizeEXT( static_cast( m_commandBuffer ), extraPrimitiveOverestimationSize ); + } + + // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthClipEnableEXT( Bool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClipEnableEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetDepthClipEnableEXT( static_cast( m_commandBuffer ), static_cast( depthClipEnable ) ); + } + + // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEnableEXT( Bool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEnableEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetSampleLocationsEnableEXT( static_cast( m_commandBuffer ), static_cast( sampleLocationsEnable ) ); + } + + // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html + VULKAN_HPP_INLINE void + CommandBuffer::setColorBlendAdvancedEXT( uint32_t firstAttachment, + ArrayProxy const & colorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendAdvancedEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetColorBlendAdvancedEXT( static_cast( m_commandBuffer ), + firstAttachment, + colorBlendAdvanced.size(), + reinterpret_cast( colorBlendAdvanced.data() ) ); + } + + // wrapper function for command vkCmdSetProvokingVertexModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setProvokingVertexModeEXT( ProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetProvokingVertexModeEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetProvokingVertexModeEXT( static_cast( m_commandBuffer ), + static_cast( provokingVertexMode ) ); + } + + // wrapper function for command vkCmdSetLineRasterizationModeEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setLineRasterizationModeEXT( LineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineRasterizationModeEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetLineRasterizationModeEXT( static_cast( m_commandBuffer ), + static_cast( lineRasterizationMode ) ); + } + + // wrapper function for command vkCmdSetLineStippleEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEnableEXT( Bool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEnableEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetLineStippleEnableEXT( static_cast( m_commandBuffer ), static_cast( stippledLineEnable ) ); + } + + // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthClipNegativeOneToOneEXT( Bool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClipNegativeOneToOneEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetDepthClipNegativeOneToOneEXT( static_cast( m_commandBuffer ), static_cast( negativeOneToOne ) ); + } + + // wrapper function for command vkCmdSetViewportWScalingEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html + VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingEnableNV( Bool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWScalingEnableNV && + "Function requires or " ); + + getDispatcher()->vkCmdSetViewportWScalingEnableNV( static_cast( m_commandBuffer ), static_cast( viewportWScalingEnable ) ); + } + + // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html + VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV( uint32_t firstViewport, + ArrayProxy const & viewportSwizzles ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportSwizzleNV && + "Function requires or " ); + + getDispatcher()->vkCmdSetViewportSwizzleNV( static_cast( m_commandBuffer ), + firstViewport, + viewportSwizzles.size(), + reinterpret_cast( viewportSwizzles.data() ) ); + } + + // wrapper function for command vkCmdSetCoverageToColorEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html + VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorEnableNV( Bool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageToColorEnableNV && + "Function requires or " ); + + getDispatcher()->vkCmdSetCoverageToColorEnableNV( static_cast( m_commandBuffer ), static_cast( coverageToColorEnable ) ); + } + + // wrapper function for command vkCmdSetCoverageToColorLocationNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html + VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageToColorLocationNV && + "Function requires or " ); + + getDispatcher()->vkCmdSetCoverageToColorLocationNV( static_cast( m_commandBuffer ), coverageToColorLocation ); + } + + // wrapper function for command vkCmdSetCoverageModulationModeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html + VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationModeNV( CoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationModeNV && + "Function requires or " ); + + getDispatcher()->vkCmdSetCoverageModulationModeNV( static_cast( m_commandBuffer ), + static_cast( coverageModulationMode ) ); + } + + // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html + VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableEnableNV( Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationTableEnableNV && + "Function requires or " ); + + getDispatcher()->vkCmdSetCoverageModulationTableEnableNV( static_cast( m_commandBuffer ), + static_cast( coverageModulationTableEnable ) ); + } + + // wrapper function for command vkCmdSetCoverageModulationTableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html + VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableNV( ArrayProxy const & coverageModulationTable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationTableNV && + "Function requires or " ); + + getDispatcher()->vkCmdSetCoverageModulationTableNV( + static_cast( m_commandBuffer ), coverageModulationTable.size(), coverageModulationTable.data() ); + } + + // wrapper function for command vkCmdSetShadingRateImageEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html + VULKAN_HPP_INLINE void CommandBuffer::setShadingRateImageEnableNV( Bool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetShadingRateImageEnableNV && + "Function requires or " ); + + getDispatcher()->vkCmdSetShadingRateImageEnableNV( static_cast( m_commandBuffer ), static_cast( shadingRateImageEnable ) ); + } + + // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html + VULKAN_HPP_INLINE void CommandBuffer::setRepresentativeFragmentTestEnableNV( Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRepresentativeFragmentTestEnableNV && + "Function requires or " ); + + getDispatcher()->vkCmdSetRepresentativeFragmentTestEnableNV( static_cast( m_commandBuffer ), + static_cast( representativeFragmentTestEnable ) ); + } + + // wrapper function for command vkCmdSetCoverageReductionModeNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html + VULKAN_HPP_INLINE void CommandBuffer::setCoverageReductionModeNV( CoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageReductionModeNV && + "Function requires or " ); + + getDispatcher()->vkCmdSetCoverageReductionModeNV( static_cast( m_commandBuffer ), + static_cast( coverageReductionMode ) ); + } + + //=== VK_ARM_tensors === + + // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createTensorARM( TensorCreateInfoARM const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateTensorARM && "Function requires " ); + + VULKAN_HPP_NAMESPACE::TensorARM tensor; + Result result = static_cast( getDispatcher()->vkCreateTensorARM( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &tensor ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createTensorARM" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, TensorARM( *this, *reinterpret_cast( &tensor ), allocator ) ); + } + + // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createTensorViewARM( TensorViewCreateInfoARM const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateTensorViewARM && "Function requires " ); + + VULKAN_HPP_NAMESPACE::TensorViewARM view; + Result result = static_cast( getDispatcher()->vkCreateTensorViewARM( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &view ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createTensorViewARM" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, TensorViewARM( *this, *reinterpret_cast( &view ), allocator ) ); + } + + // wrapper function for command vkGetTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorMemoryRequirementsARM && "Function requires " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetTensorMemoryRequirementsARM( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorMemoryRequirementsARM && "Function requires " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetTensorMemoryRequirementsARM( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::bindTensorMemoryARM( ArrayProxy const & bindInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBindTensorMemoryARM && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkBindTensorMemoryARM( + static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindTensorMemoryARM" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceTensorMemoryRequirementsARM && + "Function requires " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetDeviceTensorMemoryRequirementsARM( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceTensorMemoryRequirementsARM && + "Function requires " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetDeviceTensorMemoryRequirementsARM( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html + VULKAN_HPP_INLINE void CommandBuffer::copyTensorARM( const CopyTensorInfoARM & copyTensorInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyTensorARM && "Function requires " ); + + getDispatcher()->vkCmdCopyTensorARM( static_cast( m_commandBuffer ), reinterpret_cast( ©TensorInfo ) ); + } + + // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalTensorPropertiesARM + PhysicalDevice::getExternalTensorPropertiesARM( const PhysicalDeviceExternalTensorInfoARM & externalTensorInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalTensorPropertiesARM && + "Function requires " ); + + ExternalTensorPropertiesARM externalTensorProperties; + getDispatcher()->vkGetPhysicalDeviceExternalTensorPropertiesARM( static_cast( m_physicalDevice ), + reinterpret_cast( &externalTensorInfo ), + reinterpret_cast( &externalTensorProperties ) ); + + return externalTensorProperties; + } + + // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorOpaqueCaptureDescriptorDataARM && + "Function requires " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkGetTensorOpaqueCaptureDescriptorDataARM( + static_cast( m_device ), reinterpret_cast( &info ), &data ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDescriptorDataARM" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorViewOpaqueCaptureDescriptorDataARM && + "Function requires " ); + + DataType data; + Result result = static_cast( getDispatcher()->vkGetTensorViewOpaqueCaptureDescriptorDataARM( + static_cast( m_device ), reinterpret_cast( &info ), &data ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getTensorViewOpaqueCaptureDescriptorDataARM" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + //=== VK_EXT_shader_module_identifier === + + // wrapper function for command vkGetShaderModuleIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ShaderModuleIdentifierEXT ShaderModule::getIdentifierEXT() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderModuleIdentifierEXT && + "Function requires " ); + + ShaderModuleIdentifierEXT identifier; + getDispatcher()->vkGetShaderModuleIdentifierEXT( + static_cast( m_device ), static_cast( m_shaderModule ), reinterpret_cast( &identifier ) ); + + return identifier; + } + + // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ShaderModuleIdentifierEXT + Device::getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderModuleCreateInfoIdentifierEXT && + "Function requires " ); + + ShaderModuleIdentifierEXT identifier; + getDispatcher()->vkGetShaderModuleCreateInfoIdentifierEXT( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( &identifier ) ); + + return identifier; + } + + //=== VK_NV_optical_flow === + + // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV && + "Function requires " ); + + std::vector imageFormatProperties; + uint32_t formatCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV( + static_cast( m_physicalDevice ), + reinterpret_cast( &opticalFlowImageFormatInfo ), + &formatCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && formatCount ) + { + imageFormatProperties.resize( formatCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV( + static_cast( m_physicalDevice ), + reinterpret_cast( &opticalFlowImageFormatInfo ), + &formatCount, + reinterpret_cast( imageFormatProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" ); + VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); + if ( formatCount < imageFormatProperties.size() ) + { + imageFormatProperties.resize( formatCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); + } + + // wrapper function for command vkCreateOpticalFlowSessionNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createOpticalFlowSessionNV( OpticalFlowSessionCreateInfoNV const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateOpticalFlowSessionNV && "Function requires " ); + + VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session; + Result result = + static_cast( getDispatcher()->vkCreateOpticalFlowSessionNV( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &session ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createOpticalFlowSessionNV" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, OpticalFlowSessionNV( *this, *reinterpret_cast( &session ), allocator ) ); + } + + // wrapper function for command vkBindOpticalFlowSessionImageNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html + VULKAN_HPP_INLINE typename ResultValueType::type + OpticalFlowSessionNV::bindImage( OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, ImageLayout layout ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBindOpticalFlowSessionImageNV && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkBindOpticalFlowSessionImageNV( static_cast( m_device ), + static_cast( m_opticalFlowSessionNV ), + static_cast( bindingPoint ), + static_cast( view ), + static_cast( layout ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::OpticalFlowSessionNV::bindImage" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html + VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, + const OpticalFlowExecuteInfoNV & executeInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdOpticalFlowExecuteNV && "Function requires " ); + + getDispatcher()->vkCmdOpticalFlowExecuteNV( static_cast( m_commandBuffer ), + static_cast( session ), + reinterpret_cast( &executeInfo ) ); + } + + //=== VK_KHR_maintenance5 === + + // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer, + DeviceSize offset, + DeviceSize size, + IndexType indexType ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer2KHR && + "Function requires or " ); + + getDispatcher()->vkCmdBindIndexBuffer2KHR( static_cast( m_commandBuffer ), + static_cast( buffer ), + static_cast( offset ), + static_cast( size ), + static_cast( indexType ) ); + } + + // wrapper function for command vkGetRenderingAreaGranularityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D + Device::getRenderingAreaGranularityKHR( const RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetRenderingAreaGranularityKHR && + "Function requires or " ); + + Extent2D granularity; + getDispatcher()->vkGetRenderingAreaGranularityKHR( static_cast( m_device ), + reinterpret_cast( &renderingAreaInfo ), + reinterpret_cast( &granularity ) ); + + return granularity; + } + + // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 + Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR && + "Function requires or " ); + + SubresourceLayout2 layout; + getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &layout ) ); + + return layout; + } + + // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR && + "Function requires or " ); + + StructureChain structureChain; + SubresourceLayout2 & layout = structureChain.template get(); + getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &layout ) ); + + return structureChain; + } + + // wrapper function for command vkGetImageSubresourceLayout2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Image::getSubresourceLayout2KHR( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetImageSubresourceLayout2KHR && + "Function requires or or or " ); + + SubresourceLayout2 layout; + getDispatcher()->vkGetImageSubresourceLayout2KHR( static_cast( m_device ), + static_cast( m_image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return layout; + } + + // wrapper function for command vkGetImageSubresourceLayout2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Image::getSubresourceLayout2KHR( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetImageSubresourceLayout2KHR && + "Function requires or or or " ); + + StructureChain structureChain; + SubresourceLayout2 & layout = structureChain.template get(); + getDispatcher()->vkGetImageSubresourceLayout2KHR( static_cast( m_device ), + static_cast( m_image ), + reinterpret_cast( &subresource ), + reinterpret_cast( &layout ) ); + + return structureChain; + } + + //=== VK_AMD_anti_lag === + + // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html + VULKAN_HPP_INLINE void Device::antiLagUpdateAMD( const AntiLagDataAMD & data ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkAntiLagUpdateAMD && "Function requires " ); + + getDispatcher()->vkAntiLagUpdateAMD( static_cast( m_device ), reinterpret_cast( &data ) ); + } + + //=== VK_KHR_present_wait2 === + + // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::waitForPresent2( const PresentWait2InfoKHR & presentWait2Info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForPresent2KHR && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkWaitForPresent2KHR( static_cast( m_device ), + static_cast( m_swapchainKHR ), + reinterpret_cast( &presentWait2Info ) ) ); + +# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::waitForPresent2", + { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); +# else + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::waitForPresent2", { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR } ); +# endif + + return static_cast( result ); + } + + //=== VK_EXT_shader_object === + + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createShadersEXT( ArrayProxy const & createInfos, Optional allocator ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateShadersEXT && "Function requires " ); + + std::vector shaders( createInfos.size() ); + Result result = static_cast( getDispatcher()->vkCreateShadersEXT( static_cast( m_device ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( shaders.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createShadersEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); + std::vector shadersRAII; + if ( result == Result::eSuccess ) + { + shadersRAII.reserve( shaders.size() ); + for ( auto & shader : shaders ) + { + shadersRAII.emplace_back( *this, *reinterpret_cast( &shader ), allocator, result ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( shadersRAII ) ); + } + + // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createShaderEXT( ShaderCreateInfoEXT const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateShadersEXT && "Function requires " ); + + VULKAN_HPP_NAMESPACE::ShaderEXT shader; + Result result = static_cast( getDispatcher()->vkCreateShadersEXT( static_cast( m_device ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &shader ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createShaderEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, ShaderEXT( *this, *reinterpret_cast( &shader ), allocator, result ) ); + } + + // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type ShaderEXT::getBinaryData() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderBinaryDataEXT && "Function requires " ); + + std::vector data; + size_t dataSize; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetShaderBinaryDataEXT( static_cast( m_device ), static_cast( m_shaderEXT ), &dataSize, nullptr ) ); + if ( ( result == Result::eSuccess ) && dataSize ) + { + data.resize( dataSize ); + result = static_cast( getDispatcher()->vkGetShaderBinaryDataEXT( + static_cast( m_device ), static_cast( m_shaderEXT ), &dataSize, reinterpret_cast( data.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::ShaderEXT::getBinaryData" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); + } + + // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html + VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( ArrayProxy const & stages, + ArrayProxy const & shaders ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadersEXT && "Function requires " ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( stages.size() == shaders.size() ); +# else + if ( stages.size() != shaders.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindShadersEXT: stages.size() != shaders.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + getDispatcher()->vkCmdBindShadersEXT( static_cast( m_commandBuffer ), + stages.size(), + reinterpret_cast( stages.data() ), + reinterpret_cast( shaders.data() ) ); + } + + // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, + Optional depthClampRange ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClampRangeEXT && + "Function requires or " ); + + getDispatcher()->vkCmdSetDepthClampRangeEXT( static_cast( m_commandBuffer ), + static_cast( depthClampMode ), + reinterpret_cast( depthClampRange.get() ) ); + } + + //=== VK_KHR_pipeline_binary === + + // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createPipelineBinariesKHR( PipelineBinaryCreateInfoKHR const & createInfo, Optional allocator ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreatePipelineBinariesKHR && "Function requires " ); + + std::vector pipelineBinaries; + PipelineBinaryHandlesInfoKHR binaries; + Result result; + if ( createInfo.pKeysAndDataInfo ) + { + VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo ); + pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount ); + binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount; + binaries.pPipelineBinaries = pipelineBinaries.data(); + result = static_cast( getDispatcher()->vkCreatePipelineBinariesKHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + } + else + { + VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo ); + result = static_cast( getDispatcher()->vkCreatePipelineBinariesKHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + if ( result == Result::eSuccess ) + { + pipelineBinaries.resize( binaries.pipelineBinaryCount ); + binaries.pPipelineBinaries = pipelineBinaries.data(); + result = static_cast( getDispatcher()->vkCreatePipelineBinariesKHR( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &binaries ) ) ); + } + } + + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createPipelineBinariesKHR", + { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } ); + std::vector pipelineBinariesRAII; + if ( result == Result::eSuccess ) + { + pipelineBinariesRAII.reserve( pipelineBinaries.size() ); + for ( auto & pipelineBinary : pipelineBinaries ) + { + pipelineBinariesRAII.emplace_back( *this, *reinterpret_cast( &pipelineBinary ), allocator, result ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelineBinariesRAII ) ); + } + + // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getPipelineKeyKHR( Optional pipelineCreateInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineKeyKHR && "Function requires " ); + + PipelineBinaryKeyKHR pipelineKey; + Result result = static_cast( getDispatcher()->vkGetPipelineKeyKHR( static_cast( m_device ), + reinterpret_cast( pipelineCreateInfo.get() ), + reinterpret_cast( &pipelineKey ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelineKeyKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelineKey ) ); + } + + // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>>::type + Device::getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineBinaryDataKHR && "Function requires " ); + + std::pair> data_; + PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first; + std::vector & pipelineBinaryData = data_.second; + size_t pipelineBinaryDataSize; + Result result = static_cast( getDispatcher()->vkGetPipelineBinaryDataKHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &pipelineBinaryKey ), + &pipelineBinaryDataSize, + nullptr ) ); + if ( result == Result::eSuccess ) + { + pipelineBinaryData.resize( pipelineBinaryDataSize ); + result = static_cast( getDispatcher()->vkGetPipelineBinaryDataKHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &pipelineBinaryKey ), + &pipelineBinaryDataSize, + reinterpret_cast( pipelineBinaryData.data() ) ) ); + } + + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkReleaseCapturedPipelineDataKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR & info, + Optional allocator ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseCapturedPipelineDataKHR && "Function requires " ); + + Result result = + static_cast( getDispatcher()->vkReleaseCapturedPipelineDataKHR( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( allocator.get() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::releaseCapturedPipelineDataKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + //=== VK_QCOM_tile_properties === + + // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Framebuffer::getTilePropertiesQCOM() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetFramebufferTilePropertiesQCOM && + "Function requires " ); + + std::vector properties; + uint32_t propertiesCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetFramebufferTilePropertiesQCOM( + static_cast( m_device ), static_cast( m_framebuffer ), &propertiesCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertiesCount ) + { + properties.resize( propertiesCount ); + result = static_cast( getDispatcher()->vkGetFramebufferTilePropertiesQCOM( static_cast( m_device ), + static_cast( m_framebuffer ), + &propertiesCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Framebuffer::getTilePropertiesQCOM" ); + VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); + if ( propertiesCount < properties.size() ) + { + properties.resize( propertiesCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDynamicRenderingTilePropertiesQCOM && + "Function requires " ); + + TilePropertiesQCOM properties; + Result result = + static_cast( getDispatcher()->vkGetDynamicRenderingTilePropertiesQCOM( static_cast( m_device ), + reinterpret_cast( &renderingInfo ), + reinterpret_cast( &properties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getDynamicRenderingTilePropertiesQCOM" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + //=== VK_KHR_swapchain_maintenance1 === + + // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html + VULKAN_HPP_INLINE typename ResultValueType::type Device::releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseSwapchainImagesKHR && + "Function requires or " ); + + Result result = static_cast( getDispatcher()->vkReleaseSwapchainImagesKHR( + static_cast( m_device ), reinterpret_cast( &releaseInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::releaseSwapchainImagesKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + //=== VK_NV_cooperative_vector === + + // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCooperativeVectorPropertiesNV() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeVectorPropertiesNV && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceCooperativeVectorPropertiesNV( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeVectorPropertiesNV( + static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCooperativeVectorPropertiesNV" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkConvertCooperativeVectorMatrixNV && + "Function requires " ); + + Result result = static_cast( getDispatcher()->vkConvertCooperativeVectorMatrixNV( + static_cast( m_device ), reinterpret_cast( &info ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::convertCooperativeVectorMatrixNV", { Result::eSuccess, Result::eIncomplete } ); + + return static_cast( result ); + } + + // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html + VULKAN_HPP_INLINE void + CommandBuffer::convertCooperativeVectorMatrixNV( ArrayProxy const & infos ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdConvertCooperativeVectorMatrixNV && + "Function requires " ); + + getDispatcher()->vkCmdConvertCooperativeVectorMatrixNV( + static_cast( m_commandBuffer ), infos.size(), reinterpret_cast( infos.data() ) ); + } + + //=== VK_NV_low_latency2 === + + // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html + VULKAN_HPP_INLINE typename ResultValueType::type SwapchainKHR::setLatencySleepModeNV( const LatencySleepModeInfoNV & sleepModeInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencySleepModeNV && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkSetLatencySleepModeNV( static_cast( m_device ), + static_cast( m_swapchainKHR ), + reinterpret_cast( &sleepModeInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::setLatencySleepModeNV" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html + VULKAN_HPP_INLINE typename ResultValueType::type SwapchainKHR::latencySleepNV( const LatencySleepInfoNV & sleepInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkLatencySleepNV && "Function requires " ); + + Result result = static_cast( getDispatcher()->vkLatencySleepNV( + static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( &sleepInfo ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::latencySleepNV" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html + VULKAN_HPP_INLINE void SwapchainKHR::setLatencyMarkerNV( const SetLatencyMarkerInfoNV & latencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencyMarkerNV && "Function requires " ); + + getDispatcher()->vkSetLatencyMarkerNV( static_cast( m_device ), + static_cast( m_swapchainKHR ), + reinterpret_cast( &latencyMarkerInfo ) ); + } + + // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector SwapchainKHR::getLatencyTimingsNV() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetLatencyTimingsNV && "Function requires " ); + + std::vector timings; + GetLatencyMarkerInfoNV latencyMarkerInfo; + getDispatcher()->vkGetLatencyTimingsNV( + static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( &latencyMarkerInfo ) ); + timings.resize( latencyMarkerInfo.timingCount ); + latencyMarkerInfo.pTimings = timings.data(); + getDispatcher()->vkGetLatencyTimingsNV( + static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( &latencyMarkerInfo ) ); + + return timings; + } + + // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html + VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkQueueNotifyOutOfBandNV && "Function requires " ); + + getDispatcher()->vkQueueNotifyOutOfBandNV( static_cast( m_queue ), reinterpret_cast( &queueTypeInfo ) ); + } + + //=== VK_KHR_cooperative_matrix === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCooperativeMatrixPropertiesKHR() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( + static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + //=== VK_ARM_data_graph === + + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createDataGraphPipelinesARM( Optional const & deferredOperation, + Optional const & pipelineCache, + ArrayProxy const & createInfos, + Optional allocator ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDataGraphPipelinesARM && "Function requires " ); + + std::vector pipelines( createInfos.size() ); + Result result = + static_cast( getDispatcher()->vkCreateDataGraphPipelinesARM( static_cast( m_device ), + deferredOperation ? static_cast( **deferredOperation ) : 0, + pipelineCache ? static_cast( **pipelineCache ) : 0, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( pipelines.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDataGraphPipelinesARM", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + std::vector pipelinesRAII; + if ( result == Result::eSuccess ) + { + pipelinesRAII.reserve( pipelines.size() ); + for ( auto & pipeline : pipelines ) + { + pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); + } + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); + } + + // wrapper function for command vkCreateDataGraphPipelinesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createDataGraphPipelineARM( Optional const & deferredOperation, + Optional const & pipelineCache, + DataGraphPipelineCreateInfoARM const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDataGraphPipelinesARM && "Function requires " ); + + VULKAN_HPP_NAMESPACE::Pipeline pipeline; + Result result = + static_cast( getDispatcher()->vkCreateDataGraphPipelinesARM( static_cast( m_device ), + deferredOperation ? static_cast( **deferredOperation ) : 0, + pipelineCache ? static_cast( **pipelineCache ) : 0, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &pipeline ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( + result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDataGraphPipelineARM", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); + } + + // wrapper function for command vkCreateDataGraphPipelineSessionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createDataGraphPipelineSessionARM( DataGraphPipelineSessionCreateInfoARM const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDataGraphPipelineSessionARM && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM session; + Result result = static_cast( + getDispatcher()->vkCreateDataGraphPipelineSessionARM( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &session ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDataGraphPipelineSessionARM" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, DataGraphPipelineSessionARM( *this, *reinterpret_cast( &session ), allocator ) ); + } + + // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM & info ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDataGraphPipelineSessionBindPointRequirementsARM && + "Function requires " ); + + std::vector bindPointRequirements; + uint32_t bindPointRequirementCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetDataGraphPipelineSessionBindPointRequirementsARM( + static_cast( m_device ), + reinterpret_cast( &info ), + &bindPointRequirementCount, + nullptr ) ); + if ( ( result == Result::eSuccess ) && bindPointRequirementCount ) + { + bindPointRequirements.resize( bindPointRequirementCount ); + result = static_cast( getDispatcher()->vkGetDataGraphPipelineSessionBindPointRequirementsARM( + static_cast( m_device ), + reinterpret_cast( &info ), + &bindPointRequirementCount, + reinterpret_cast( bindPointRequirements.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getDataGraphPipelineSessionBindPointRequirementsARM" ); + VULKAN_HPP_ASSERT( bindPointRequirementCount <= bindPointRequirements.size() ); + if ( bindPointRequirementCount < bindPointRequirements.size() ) + { + bindPointRequirements.resize( bindPointRequirementCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( bindPointRequirements ) ); + } + + // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDataGraphPipelineSessionMemoryRequirementsARM && + "Function requires " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetDataGraphPipelineSessionMemoryRequirementsARM( + static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDataGraphPipelineSessionMemoryRequirementsARM && + "Function requires " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetDataGraphPipelineSessionMemoryRequirementsARM( + static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html + VULKAN_HPP_INLINE typename ResultValueType::type + Device::bindDataGraphPipelineSessionMemoryARM( ArrayProxy const & bindInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkBindDataGraphPipelineSessionMemoryARM && + "Function requires " ); + + Result result = static_cast( getDispatcher()->vkBindDataGraphPipelineSessionMemoryARM( + static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindDataGraphPipelineSessionMemoryARM" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); + } + + // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html + VULKAN_HPP_INLINE void CommandBuffer::dispatchDataGraphARM( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM session, + Optional info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchDataGraphARM && "Function requires " ); + + getDispatcher()->vkCmdDispatchDataGraphARM( static_cast( m_commandBuffer ), + static_cast( session ), + reinterpret_cast( info.get() ) ); + } + + // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDataGraphPipelineAvailablePropertiesARM && + "Function requires " ); + + std::vector properties; + uint32_t propertiesCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetDataGraphPipelineAvailablePropertiesARM( + static_cast( m_device ), reinterpret_cast( &pipelineInfo ), &propertiesCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertiesCount ) + { + properties.resize( propertiesCount ); + result = static_cast( + getDispatcher()->vkGetDataGraphPipelineAvailablePropertiesARM( static_cast( m_device ), + reinterpret_cast( &pipelineInfo ), + &propertiesCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getDataGraphPipelineAvailablePropertiesARM" ); + VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); + if ( propertiesCount < properties.size() ) + { + properties.resize( propertiesCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetDataGraphPipelinePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelinePropertiesARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getDataGraphPipelinePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, + uint32_t propertiesCount, + DataGraphPipelinePropertyQueryResultARM * pProperties ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetDataGraphPipelinePropertiesARM && + "Function requires " ); + return static_cast( + getDispatcher()->vkGetDataGraphPipelinePropertiesARM( static_cast( m_device ), + reinterpret_cast( pPipelineInfo ), + propertiesCount, + reinterpret_cast( pProperties ) ) ); + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM && + "Function requires " ); + + std::vector queueFamilyDataGraphProperties; + uint32_t queueFamilyDataGraphPropertyCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( + static_cast( m_physicalDevice ), queueFamilyIndex, &queueFamilyDataGraphPropertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && queueFamilyDataGraphPropertyCount ) + { + queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( + static_cast( m_physicalDevice ), + queueFamilyIndex, + &queueFamilyDataGraphPropertyCount, + reinterpret_cast( queueFamilyDataGraphProperties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getQueueFamilyDataGraphPropertiesARM" ); + VULKAN_HPP_ASSERT( queueFamilyDataGraphPropertyCount <= queueFamilyDataGraphProperties.size() ); + if ( queueFamilyDataGraphPropertyCount < queueFamilyDataGraphProperties.size() ) + { + queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( queueFamilyDataGraphProperties ) ); + } + + // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE QueueFamilyDataGraphProcessingEnginePropertiesARM + PhysicalDevice::getQueueFamilyDataGraphProcessingEnginePropertiesARM( + const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & queueFamilyDataGraphProcessingEngineInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM && + "Function requires " ); + + QueueFamilyDataGraphProcessingEnginePropertiesARM queueFamilyDataGraphProcessingEngineProperties; + getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( + static_cast( m_physicalDevice ), + reinterpret_cast( &queueFamilyDataGraphProcessingEngineInfo ), + reinterpret_cast( &queueFamilyDataGraphProcessingEngineProperties ) ); + + return queueFamilyDataGraphProcessingEngineProperties; + } + + //=== VK_EXT_attachment_feedback_loop_dynamic_state === + + // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html + VULKAN_HPP_INLINE void CommandBuffer::setAttachmentFeedbackLoopEnableEXT( ImageAspectFlags aspectMask ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAttachmentFeedbackLoopEnableEXT && + "Function requires " ); + + getDispatcher()->vkCmdSetAttachmentFeedbackLoopEnableEXT( static_cast( m_commandBuffer ), + static_cast( aspectMask ) ); + } + +# if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_external_memory_screen_buffer === + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer, + ScreenBufferPropertiesQNX * pProperties ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetScreenBufferPropertiesQNX && + "Function requires " ); + return static_cast( getDispatcher()->vkGetScreenBufferPropertiesQNX( + static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); + } + + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetScreenBufferPropertiesQNX && + "Function requires " ); + + ScreenBufferPropertiesQNX properties; + Result result = static_cast( getDispatcher()->vkGetScreenBufferPropertiesQNX( + static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + + // wrapper function for command vkGetScreenBufferPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetScreenBufferPropertiesQNX && + "Function requires " ); + + StructureChain structureChain; + ScreenBufferPropertiesQNX & properties = structureChain.template get(); + Result result = static_cast( getDispatcher()->vkGetScreenBufferPropertiesQNX( + static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); + } +# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_KHR_line_rasterization === + + // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html + VULKAN_HPP_INLINE void CommandBuffer::setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleKHR && + "Function requires or or " ); + + getDispatcher()->vkCmdSetLineStippleKHR( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); + } + + //=== VK_KHR_calibrated_timestamps === + + // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getCalibrateableTimeDomainsKHR() const + { + VULKAN_HPP_ASSERT( + getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR && + "Function requires or " ); + + std::vector timeDomains; + uint32_t timeDomainCount; + Result result; + do + { + result = static_cast( + getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( static_cast( m_physicalDevice ), &timeDomainCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && timeDomainCount ) + { + timeDomains.resize( timeDomainCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( + static_cast( m_physicalDevice ), &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" ); + VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); + if ( timeDomainCount < timeDomains.size() ) + { + timeDomains.resize( timeDomainCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) ); + } + + // wrapper function for command vkGetCalibratedTimestampsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type + Device::getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsKHR && + "Function requires or " ); + + std::pair, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); + std::vector & timestamps = data_.first; + uint64_t & maxDeviation = data_.second; + Result result = + static_cast( getDispatcher()->vkGetCalibratedTimestampsKHR( static_cast( m_device ), + timestampInfos.size(), + reinterpret_cast( timestampInfos.data() ), + timestamps.data(), + &maxDeviation ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); + } + + // wrapper function for command vkGetCalibratedTimestampsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getCalibratedTimestampKHR( const CalibratedTimestampInfoKHR & timestampInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsKHR && + "Function requires or " ); + + std::pair data_; + uint64_t & timestamp = data_.first; + uint64_t & maxDeviation = data_.second; + Result result = static_cast( getDispatcher()->vkGetCalibratedTimestampsKHR( + static_cast( m_device ), 1, reinterpret_cast( ×tampInfo ), ×tamp, &maxDeviation ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); + } + + //=== VK_KHR_maintenance6 === + + // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2KHR( const BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorSets2KHR && + "Function requires or " ); + + getDispatcher()->vkCmdBindDescriptorSets2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &bindDescriptorSetsInfo ) ); + } + + // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushConstants2KHR && "Function requires or " ); + + getDispatcher()->vkCmdPushConstants2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &pushConstantsInfo ) ); + } + + // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2KHR( const PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSet2KHR && + "Function requires or " ); + + getDispatcher()->vkCmdPushDescriptorSet2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( &pushDescriptorSetInfo ) ); + } + + // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html + VULKAN_HPP_INLINE void + CommandBuffer::pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetWithTemplate2KHR && + "Function requires or " ); + + getDispatcher()->vkCmdPushDescriptorSetWithTemplate2KHR( + static_cast( m_commandBuffer ), reinterpret_cast( &pushDescriptorSetWithTemplateInfo ) ); + } + + // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html + VULKAN_HPP_INLINE void + CommandBuffer::setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDescriptorBufferOffsets2EXT && + "Function requires " ); + + getDispatcher()->vkCmdSetDescriptorBufferOffsets2EXT( static_cast( m_commandBuffer ), + reinterpret_cast( &setDescriptorBufferOffsetsInfo ) ); + } + + // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html + VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT( + const BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplers2EXT && + "Function requires " ); + + getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( + static_cast( m_commandBuffer ), + reinterpret_cast( &bindDescriptorBufferEmbeddedSamplersInfo ) ); + } + + //=== VK_QCOM_tile_memory_heap === + + // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html + VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( Optional tileMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindTileMemoryQCOM && "Function requires " ); + + getDispatcher()->vkCmdBindTileMemoryQCOM( static_cast( m_commandBuffer ), + reinterpret_cast( tileMemoryBindInfo.get() ) ); + } + + //=== VK_KHR_copy_memory_indirect === + + // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html + VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryIndirectKHR && "Function requires " ); + + getDispatcher()->vkCmdCopyMemoryIndirectKHR( static_cast( m_commandBuffer ), + reinterpret_cast( ©MemoryIndirectInfo ) ); + } + + // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html + VULKAN_HPP_INLINE void + CommandBuffer::copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToImageIndirectKHR && + "Function requires " ); + + getDispatcher()->vkCmdCopyMemoryToImageIndirectKHR( static_cast( m_commandBuffer ), + reinterpret_cast( ©MemoryToImageIndirectInfo ) ); + } + + //=== VK_EXT_memory_decompression === + + // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html + VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryEXT( const DecompressMemoryInfoEXT & decompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryEXT && "Function requires " ); + + getDispatcher()->vkCmdDecompressMemoryEXT( static_cast( m_commandBuffer ), + reinterpret_cast( &decompressMemoryInfoEXT ) ); + } + + // wrapper function for command vkCmdDecompressMemoryIndirectCountEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountEXT.html + VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod, + DeviceAddress indirectCommandsAddress, + DeviceAddress indirectCommandsCountAddress, + uint32_t maxDecompressionCount, + uint32_t stride ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryIndirectCountEXT && + "Function requires " ); + + getDispatcher()->vkCmdDecompressMemoryIndirectCountEXT( static_cast( m_commandBuffer ), + static_cast( decompressionMethod ), + static_cast( indirectCommandsAddress ), + static_cast( indirectCommandsCountAddress ), + maxDecompressionCount, + stride ); + } + + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createExternalComputeQueueNV( ExternalComputeQueueCreateInfoNV const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateExternalComputeQueueNV && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue; + Result result = + static_cast( getDispatcher()->vkCreateExternalComputeQueueNV( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &externalQueue ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createExternalComputeQueueNV" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, ExternalComputeQueueNV( *this, *reinterpret_cast( &externalQueue ), allocator ) ); + } + + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair ExternalComputeQueueNV::getData() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetExternalComputeQueueDataNV && + "Function requires " ); + + std::pair data_; + ExternalComputeQueueDataParamsNV & arams = data_.first; + DataType & data = data_.second; + getDispatcher()->vkGetExternalComputeQueueDataNV( + static_cast( m_externalComputeQueueNV ), reinterpret_cast( &arams ), &data ); + + return data_; + } + + //=== VK_NV_cluster_acceleration_structure === + + // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR + Device::getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetClusterAccelerationStructureBuildSizesNV && + "Function requires " ); + + AccelerationStructureBuildSizesInfoKHR sizeInfo; + getDispatcher()->vkGetClusterAccelerationStructureBuildSizesNV( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &sizeInfo ) ); + + return sizeInfo; + } + + // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html + VULKAN_HPP_INLINE void + CommandBuffer::buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV & commandInfos ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildClusterAccelerationStructureIndirectNV && + "Function requires " ); + + getDispatcher()->vkCmdBuildClusterAccelerationStructureIndirectNV( + static_cast( m_commandBuffer ), reinterpret_cast( &commandInfos ) ); + } + + //=== VK_NV_partitioned_acceleration_structure === + + // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR + Device::getPartitionedAccelerationStructuresBuildSizesNV( const PartitionedAccelerationStructureInstancesInputNV & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPartitionedAccelerationStructuresBuildSizesNV && + "Function requires " ); + + AccelerationStructureBuildSizesInfoKHR sizeInfo; + getDispatcher()->vkGetPartitionedAccelerationStructuresBuildSizesNV( + static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &sizeInfo ) ); + + return sizeInfo; + } + + // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html + VULKAN_HPP_INLINE void + CommandBuffer::buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV & buildInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildPartitionedAccelerationStructuresNV && + "Function requires " ); + + getDispatcher()->vkCmdBuildPartitionedAccelerationStructuresNV( static_cast( m_commandBuffer ), + reinterpret_cast( &buildInfo ) ); + } + + //=== VK_EXT_device_generated_commands === + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 + Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsEXT && + "Function requires " ); + + MemoryRequirements2 memoryRequirements; + getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsEXT( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return memoryRequirements; + } + + // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain + Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsEXT && + "Function requires " ); + + StructureChain structureChain; + MemoryRequirements2 & memoryRequirements = structureChain.template get(); + getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsEXT( static_cast( m_device ), + reinterpret_cast( &info ), + reinterpret_cast( &memoryRequirements ) ); + + return structureChain; + } + + // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html + VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT & generatedCommandsInfo, + VULKAN_HPP_NAMESPACE::CommandBuffer stateCommandBuffer ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPreprocessGeneratedCommandsEXT && + "Function requires " ); + + getDispatcher()->vkCmdPreprocessGeneratedCommandsEXT( static_cast( m_commandBuffer ), + reinterpret_cast( &generatedCommandsInfo ), + static_cast( stateCommandBuffer ) ); + } + + // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html + VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsEXT( Bool32 isPreprocessed, + const GeneratedCommandsInfoEXT & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdExecuteGeneratedCommandsEXT && + "Function requires " ); + + getDispatcher()->vkCmdExecuteGeneratedCommandsEXT( static_cast( m_commandBuffer ), + static_cast( isPreprocessed ), + reinterpret_cast( &generatedCommandsInfo ) ); + } + + // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createIndirectCommandsLayoutEXT( IndirectCommandsLayoutCreateInfoEXT const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateIndirectCommandsLayoutEXT && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT indirectCommandsLayout; + Result result = + static_cast( getDispatcher()->vkCreateIndirectCommandsLayoutEXT( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &indirectCommandsLayout ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, IndirectCommandsLayoutEXT( *this, *reinterpret_cast( &indirectCommandsLayout ), allocator ) ); + } + + // wrapper function for command vkCreateIndirectExecutionSetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createIndirectExecutionSetEXT( IndirectExecutionSetCreateInfoEXT const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateIndirectExecutionSetEXT && + "Function requires " ); + + VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT indirectExecutionSet; + Result result = + static_cast( getDispatcher()->vkCreateIndirectExecutionSetEXT( static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &indirectExecutionSet ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createIndirectExecutionSetEXT" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, IndirectExecutionSetEXT( *this, *reinterpret_cast( &indirectExecutionSet ), allocator ) ); + } + + // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html + VULKAN_HPP_INLINE void + IndirectExecutionSetEXT::updatePipeline( ArrayProxy const & executionSetWrites ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateIndirectExecutionSetPipelineEXT && + "Function requires " ); + + getDispatcher()->vkUpdateIndirectExecutionSetPipelineEXT( static_cast( m_device ), + static_cast( m_indirectExecutionSetEXT ), + executionSetWrites.size(), + reinterpret_cast( executionSetWrites.data() ) ); + } + + // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html + VULKAN_HPP_INLINE void + IndirectExecutionSetEXT::updateShader( ArrayProxy const & executionSetWrites ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateIndirectExecutionSetShaderEXT && + "Function requires " ); + + getDispatcher()->vkUpdateIndirectExecutionSetShaderEXT( static_cast( m_device ), + static_cast( m_indirectExecutionSetEXT ), + executionSetWrites.size(), + reinterpret_cast( executionSetWrites.data() ) ); + } + +# if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + + // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Instance::createSurfaceOHOS( SurfaceCreateInfoOHOS const & createInfo, + Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSurfaceOHOS && "Function requires " ); + + VULKAN_HPP_NAMESPACE::SurfaceKHR surface; + Result result = static_cast( getDispatcher()->vkCreateSurfaceOHOS( static_cast( m_instance ), + reinterpret_cast( &createInfo ), + reinterpret_cast( allocator.get() ), + reinterpret_cast( &surface ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createSurfaceOHOS" ); + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); + } +# endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_NV_cooperative_matrix2 === + + // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV && + "Function requires " ); + + std::vector properties; + uint32_t propertyCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( + static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); + if ( ( result == Result::eSuccess ) && propertyCount ) + { + properties.resize( propertyCount ); + result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( + static_cast( m_physicalDevice ), + &propertyCount, + reinterpret_cast( properties.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV" ); + VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); + if ( propertyCount < properties.size() ) + { + properties.resize( propertyCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); + } + +# if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_external_memory_metal === + + // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT & getMetalHandleInfo ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryMetalHandleEXT && "Function requires " ); + + void * handle; + Result result = static_cast( getDispatcher()->vkGetMemoryMetalHandleEXT( + static_cast( m_device ), reinterpret_cast( &getMetalHandleInfo ), &handle ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryMetalHandleEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); + } + + // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryMetalHandlePropertiesEXT && + "Function requires " ); + + MemoryMetalHandlePropertiesEXT memoryMetalHandleProperties; + Result result = static_cast( + getDispatcher()->vkGetMemoryMetalHandlePropertiesEXT( static_cast( m_device ), + static_cast( handleType ), + reinterpret_cast( &handle ), + reinterpret_cast( &memoryMetalHandleProperties ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryMetalHandlePropertiesEXT" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryMetalHandleProperties ) ); + } +# endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_ARM_performance_counters_by_region === + + // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, std::vector>>::type + PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM && + "Function requires " ); + + std::pair, std::vector> data_; + std::vector & counters = data_.first; + std::vector & counterDescriptions = data_.second; + uint32_t counterCount; + Result result; + do + { + result = static_cast( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( + static_cast( m_physicalDevice ), queueFamilyIndex, &counterCount, nullptr, nullptr ) ); + if ( ( result == Result::eSuccess ) && counterCount ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + result = static_cast( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( + static_cast( m_physicalDevice ), + queueFamilyIndex, + &counterCount, + reinterpret_cast( counters.data() ), + reinterpret_cast( counterDescriptions.data() ) ) ); + } + } while ( result == Result::eIncomplete ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, + VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM" ); + VULKAN_HPP_ASSERT( counterCount <= counters.size() ); + if ( counterCount < counters.size() ) + { + counters.resize( counterCount ); + counterDescriptions.resize( counterCount ); + } + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); + } + + //=== VK_EXT_fragment_density_map_offset === + + // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html + VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( Optional renderingEndInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRendering2EXT && + "Function requires or " ); + + getDispatcher()->vkCmdEndRendering2EXT( static_cast( m_commandBuffer ), + reinterpret_cast( renderingEndInfo.get() ) ); + } + + //=== VK_EXT_custom_resolve === + + // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html + VULKAN_HPP_INLINE void CommandBuffer::beginCustomResolveEXT( Optional beginCustomResolveInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginCustomResolveEXT && "Function requires " ); + + getDispatcher()->vkCmdBeginCustomResolveEXT( static_cast( m_commandBuffer ), + reinterpret_cast( beginCustomResolveInfo.get() ) ); + } + + //=== VK_KHR_maintenance10 === + + // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html + VULKAN_HPP_INLINE void CommandBuffer::endRendering2KHR( Optional renderingEndInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRendering2KHR && + "Function requires or " ); + + getDispatcher()->vkCmdEndRendering2KHR( static_cast( m_commandBuffer ), + reinterpret_cast( renderingEndInfo.get() ) ); + } + + //=== VK_NV_compute_occupancy_priority === + + // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html + VULKAN_HPP_INLINE void CommandBuffer::setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV & parameters ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetComputeOccupancyPriorityNV && + "Function requires " ); + + getDispatcher()->vkCmdSetComputeOccupancyPriorityNV( static_cast( m_commandBuffer ), + reinterpret_cast( ¶meters ) ); + } + + //==================== + //=== RAII Helpers === + //==================== + + template + std::vector filterCppTypes( std::vector const & raiiTypes ) + { + std::vector cppTypes( raiiTypes.size() ); + std::transform( raiiTypes.begin(), raiiTypes.end(), cppTypes.begin(), []( RAIIType const & d ) { return *d; } ); + return cppTypes; + } + + template + std::vector filterCppTypes( std::vector const & raiiTypes, UnaryPredicate p ) + { + std::vector cppTypes; + for ( auto const & t : raiiTypes ) + { + if ( p( t ) ) + { + cppTypes.push_back( *t ); + } + } + return cppTypes; + } + + } // namespace VULKAN_HPP_RAII_NAMESPACE +} // namespace VULKAN_HPP_NAMESPACE +#endif +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_screen.h b/lib/vulkan-headers/include/vulkan/vulkan_screen.h new file mode 100644 index 00000000000..15e9d09028f --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_screen.h @@ -0,0 +1,114 @@ +#ifndef VULKAN_SCREEN_H_ +#define VULKAN_SCREEN_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_QNX_screen_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_QNX_screen_surface 1 +#define VK_QNX_SCREEN_SURFACE_SPEC_VERSION 1 +#define VK_QNX_SCREEN_SURFACE_EXTENSION_NAME "VK_QNX_screen_surface" +typedef VkFlags VkScreenSurfaceCreateFlagsQNX; +typedef struct VkScreenSurfaceCreateInfoQNX { + VkStructureType sType; + const void* pNext; + VkScreenSurfaceCreateFlagsQNX flags; + struct _screen_context* context; + struct _screen_window* window; +} VkScreenSurfaceCreateInfoQNX; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateScreenSurfaceQNX)(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX( + VkInstance instance, + const VkScreenSurfaceCreateInfoQNX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window* window); +#endif +#endif + + +// VK_QNX_external_memory_screen_buffer is a preprocessor guard. Do not pass it to API calls. +#define VK_QNX_external_memory_screen_buffer 1 +#define VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION 1 +#define VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME "VK_QNX_external_memory_screen_buffer" +typedef struct VkScreenBufferPropertiesQNX { + VkStructureType sType; + void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeBits; +} VkScreenBufferPropertiesQNX; + +typedef struct VkScreenBufferFormatPropertiesQNX { + VkStructureType sType; + void* pNext; + VkFormat format; + uint64_t externalFormat; + uint64_t screenUsage; + VkFormatFeatureFlags formatFeatures; + VkComponentMapping samplerYcbcrConversionComponents; + VkSamplerYcbcrModelConversion suggestedYcbcrModel; + VkSamplerYcbcrRange suggestedYcbcrRange; + VkChromaLocation suggestedXChromaOffset; + VkChromaLocation suggestedYChromaOffset; +} VkScreenBufferFormatPropertiesQNX; + +typedef struct VkImportScreenBufferInfoQNX { + VkStructureType sType; + const void* pNext; + struct _screen_buffer* buffer; +} VkImportScreenBufferInfoQNX; + +typedef struct VkExternalFormatQNX { + VkStructureType sType; + void* pNext; + uint64_t externalFormat; +} VkExternalFormatQNX; + +typedef struct VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX { + VkStructureType sType; + void* pNext; + VkBool32 screenBufferImport; +} VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; + +typedef VkResult (VKAPI_PTR *PFN_vkGetScreenBufferPropertiesQNX)(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetScreenBufferPropertiesQNX( + VkDevice device, + const struct _screen_buffer* buffer, + VkScreenBufferPropertiesQNX* pProperties); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_shared.hpp b/lib/vulkan-headers/include/vulkan/vulkan_shared.hpp new file mode 100644 index 00000000000..9fe99de2365 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_shared.hpp @@ -0,0 +1,1197 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_SHARED_HPP +#define VULKAN_SHARED_HPP + +#include + +#if !defined( VULKAN_HPP_CXX_MODULE ) +# include // std::atomic_size_t +#endif + +namespace VULKAN_HPP_NAMESPACE +{ +#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) + template + class SharedHandleTraits; + + class NoDestructor + { + }; + + template + struct HasDestructorType : std::false_type + { + }; + + template + struct HasDestructorType::DestructorType() )> : std::true_type + { + }; + + template + struct GetDestructorType + { + using type = NoDestructor; + }; + + template + struct GetDestructorType::value>::type> + { + using type = typename SharedHandleTraits::DestructorType; + }; + + template + using DestructorTypeOf = typename GetDestructorType::type; + + template + struct HasDestructor : std::integral_constant, NoDestructor>::value> + { + }; + + template + struct HasPoolType : std::false_type + { + }; + + template + struct HasPoolType::deleter::PoolTypeExport() )> : std::true_type + { + }; + + template + struct GetPoolType + { + using type = NoDestructor; + }; + + template + struct GetPoolType::value>::type> + { + using type = typename SharedHandleTraits::deleter::PoolTypeExport; + }; + + //===================================================================================================================== + + template + class SharedHandle; + + template + struct SharedHeader + { + SharedHeader( SharedHandle parent, Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT + : parent( std::move( parent ) ) + , deleter( std::move( deleter ) ) + { + } + + SharedHandle parent; + Deleter deleter; + }; + + template + struct SharedHeader + { + SharedHeader( Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {} + + Deleter deleter; + }; + + //===================================================================================================================== + + template + class ReferenceCounter + { + public: + template + ReferenceCounter( Args &&... control_args ) : m_header( std::forward( control_args )... ) + { + } + + ReferenceCounter( const ReferenceCounter & ) = delete; + ReferenceCounter & operator=( const ReferenceCounter & ) = delete; + + public: + size_t addRef() VULKAN_HPP_NOEXCEPT + { + // Relaxed memory order is sufficient since this does not impose any ordering on other operations + return m_ref_cnt.fetch_add( 1, std::memory_order_relaxed ); + } + + size_t release() VULKAN_HPP_NOEXCEPT + { + // A release memory order to ensure that all releases are ordered + return m_ref_cnt.fetch_sub( 1, std::memory_order_release ); + } + + public: + std::atomic_size_t m_ref_cnt{ 1 }; + HeaderType m_header; + }; + + //===================================================================================================================== + + template > + class SharedHandleBase + { + public: + SharedHandleBase() = default; + + template + SharedHandleBase( HandleType handle, Args &&... control_args ) + : m_control( new ReferenceCounter( std::forward( control_args )... ) ), m_handle( handle ) + { + } + + SharedHandleBase( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT + { + o.addRef(); + m_handle = o.m_handle; + m_control = o.m_control; + } + + SharedHandleBase( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT + : m_control( o.m_control ) + , m_handle( o.m_handle ) + { + o.m_handle = nullptr; + o.m_control = nullptr; + } + + SharedHandleBase & operator=( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT + { + SharedHandleBase( o ).swap( *this ); + return *this; + } + + SharedHandleBase & operator=( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT + { + SharedHandleBase( std::move( o ) ).swap( *this ); + return *this; + } + + ~SharedHandleBase() + { + // only this function owns the last reference to the control block + // the same principle is used in the default deleter of std::shared_ptr + if ( m_control && ( m_control->release() == 1 ) ) + { + // noop in x86, but does thread synchronization in ARM + // it is required to ensure that last thread is getting to destroy the control block + // by ordering all atomic operations before this fence + std::atomic_thread_fence( std::memory_order_acquire ); + ForwardType::internalDestroy( getHeader(), m_handle ); + delete m_control; + } + } + + public: + HandleType get() const VULKAN_HPP_NOEXCEPT + { + return m_handle; + } + + HandleType operator*() const VULKAN_HPP_NOEXCEPT + { + return m_handle; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return bool( m_handle ); + } + +# if defined( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST ) + operator HandleType() const VULKAN_HPP_NOEXCEPT + { + return m_handle; + } +# endif + + const HandleType * operator->() const VULKAN_HPP_NOEXCEPT + { + return &m_handle; + } + + HandleType * operator->() VULKAN_HPP_NOEXCEPT + { + return &m_handle; + } + + void reset() VULKAN_HPP_NOEXCEPT + { + SharedHandleBase().swap( *this ); + } + + void swap( SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_handle, o.m_handle ); + std::swap( m_control, o.m_control ); + } + + template + typename std::enable_if::value, const SharedHandle> &>::type getDestructorType() const VULKAN_HPP_NOEXCEPT + { + return getHeader().parent; + } + + protected: + template + static typename std::enable_if::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT + { + control.deleter.destroy( handle ); + } + + template + static typename std::enable_if::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT + { + control.deleter.destroy( control.parent.get(), handle ); + } + + const HeaderType & getHeader() const VULKAN_HPP_NOEXCEPT + { + return m_control->m_header; + } + + private: + void addRef() const VULKAN_HPP_NOEXCEPT + { + if ( m_control ) + m_control->addRef(); + } + + protected: + ReferenceCounter * m_control = nullptr; + HandleType m_handle{}; + }; + + template + class SharedHandle : public SharedHandleBase, typename SharedHandleTraits::deleter>> + { + private: + using BaseType = SharedHandleBase, typename SharedHandleTraits::deleter>>; + using DeleterType = typename SharedHandleTraits::deleter; + friend BaseType; + + public: + SharedHandle() = default; + + template ::value && !HasPoolType::value>::type> + explicit SharedHandle( HandleType handle, + SharedHandle> parent, + DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT + : BaseType( handle, std::move( parent ), std::move( deleter ) ) + { + } + + template ::value && HasPoolType::value>::type> + explicit SharedHandle( HandleType handle, + SharedHandle> parent, + SharedHandle::type> pool, + const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT + : BaseType( handle, std::move( parent ), DeleterType{ std::move( pool ), dispatch } ) + { + } + + template ::value>::type> + explicit SharedHandle( HandleType handle, DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT + : BaseType( handle, std::move( deleter ) ) + { + } + + protected: + using BaseType::internalDestroy; + }; + + namespace detail + { +// Silence the function cast warnings. +# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER ) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wcast-function-type" +# elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER ) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wcast-function-type" +# endif + + template + class ObjectDestroyShared + { + public: + using DestructorType = typename SharedHandleTraits::DestructorType; + + using DestroyFunctionPointerType = + typename std::conditional::value, + void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const, + void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type; + + using SelectorType = typename std::conditional::value, DestructorType, HandleType>::type; + + ObjectDestroyShared( Optional allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) + : m_destroy( reinterpret_cast( static_cast( &SelectorType::destroy ) ) ) + , m_dispatch( &dispatch ) + , m_allocationCallbacks( allocationCallbacks ) + { + } + + public: + template + typename std::enable_if::value, void>::type destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_destroy && m_dispatch ); + ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch ); + } + + template + typename std::enable_if::value, void>::type destroy( HandleType handle ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_destroy && m_dispatch ); + ( handle.*m_destroy )( m_allocationCallbacks, *m_dispatch ); + } + + private: + DestroyFunctionPointerType m_destroy = nullptr; + const Dispatcher * m_dispatch = nullptr; + Optional m_allocationCallbacks = nullptr; + }; + + template + class ObjectFreeShared + { + public: + using DestructorType = typename SharedHandleTraits::DestructorType; + + using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const; + + ObjectFreeShared( Optional allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), + const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) + : m_destroy( reinterpret_cast( static_cast( &DestructorType::free ) ) ) + , m_dispatch( &dispatch ) + , m_allocationCallbacks( allocationCallbacks ) + { + } + + public: + void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_destroy && m_dispatch ); + ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch ); + } + + private: + DestroyFunctionPointerType m_destroy = nullptr; + const Dispatcher * m_dispatch = nullptr; + Optional m_allocationCallbacks = nullptr; + }; + + template + class ObjectReleaseShared + { + public: + using DestructorType = typename SharedHandleTraits::DestructorType; + + using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const; + + ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) + : m_destroy( reinterpret_cast( static_cast( &DestructorType::release ) ) ), m_dispatch( &dispatch ) + { + } + + public: + void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_destroy && m_dispatch ); + ( parent.*m_destroy )( handle, *m_dispatch ); + } + + private: + DestroyFunctionPointerType m_destroy = nullptr; + const Dispatcher * m_dispatch = nullptr; + }; + + template + class PoolFreeShared + { + public: + using DestructorType = typename SharedHandleTraits::DestructorType; + + using PoolTypeExport = PoolType; + + using ReturnType = decltype( std::declval().free( PoolType(), 0u, nullptr, Dispatcher() ) ); + + using DestroyFunctionPointerType = ReturnType ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const; + + PoolFreeShared() = default; + + PoolFreeShared( SharedHandle pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) + : m_destroy( reinterpret_cast( static_cast( &DestructorType::free ) ) ) + , m_dispatch( &dispatch ) + , m_pool( std::move( pool ) ) + { + } + + public: + void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( m_destroy && m_dispatch && m_pool ); + ( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch ); + } + + private: + DestroyFunctionPointerType m_destroy = nullptr; + const Dispatcher * m_dispatch = nullptr; + SharedHandle m_pool{}; + }; + +# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER ) +# pragma GCC diagnostic pop +# elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER ) +# pragma clang diagnostic pop +# endif + } // namespace detail + + //====================== + //=== SHARED HANDLEs === + //====================== + + //=== VK_VERSION_1_0 === + template <> + class SharedHandleTraits + { + public: + using DestructorType = NoDestructor; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedInstance = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = NoDestructor; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedDevice = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectFreeShared; + }; + + using SharedDeviceMemory = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedFence = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedSemaphore = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedQueryPool = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedBuffer = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedImage = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedImageView = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedCommandPool = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::PoolFreeShared; + }; + + using SharedCommandBuffer = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedEvent = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedBufferView = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedShaderModule = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedPipelineCache = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedPipeline = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedPipelineLayout = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedSampler = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedDescriptorPool = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::PoolFreeShared; + }; + + using SharedDescriptorSet = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedDescriptorSetLayout = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedFramebuffer = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedRenderPass = SharedHandle; + + //=== VK_VERSION_1_1 === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedDescriptorUpdateTemplate = SharedHandle; + using SharedDescriptorUpdateTemplateKHR = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedSamplerYcbcrConversion = SharedHandle; + using SharedSamplerYcbcrConversionKHR = SharedHandle; + + //=== VK_VERSION_1_3 === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedPrivateDataSlot = SharedHandle; + using SharedPrivateDataSlotEXT = SharedHandle; + + //=== VK_KHR_surface === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Instance; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedSurfaceKHR = SharedHandle; + + //=== VK_KHR_swapchain === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedSwapchainKHR = SharedHandle; + + //=== VK_KHR_display === + template <> + class SharedHandleTraits + { + public: + using DestructorType = PhysicalDevice; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedDisplayKHR = SharedHandle; + + //=== VK_EXT_debug_report === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Instance; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedDebugReportCallbackEXT = SharedHandle; + + //=== VK_KHR_video_queue === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedVideoSessionKHR = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedVideoSessionParametersKHR = SharedHandle; + + //=== VK_NVX_binary_import === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedCuModuleNVX = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedCuFunctionNVX = SharedHandle; + + //=== VK_EXT_debug_utils === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Instance; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedDebugUtilsMessengerEXT = SharedHandle; + + //=== VK_EXT_descriptor_heap === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedTensorARM = SharedHandle; + + //=== VK_KHR_acceleration_structure === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedAccelerationStructureKHR = SharedHandle; + + //=== VK_EXT_validation_cache === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedValidationCacheEXT = SharedHandle; + + //=== VK_NV_ray_tracing === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedAccelerationStructureNV = SharedHandle; + + //=== VK_INTEL_performance_query === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedPerformanceConfigurationINTEL = SharedHandle; + + //=== VK_KHR_deferred_host_operations === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedDeferredOperationKHR = SharedHandle; + + //=== VK_NV_device_generated_commands === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedIndirectCommandsLayoutNV = SharedHandle; + +# if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_cuda_kernel_launch === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedCudaModuleNV = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedCudaFunctionNV = SharedHandle; +# endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +# if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedBufferCollectionFUCHSIA = SharedHandle; +# endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_opacity_micromap === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedMicromapEXT = SharedHandle; + + //=== VK_ARM_tensors === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedTensorViewARM = SharedHandle; + + //=== VK_NV_optical_flow === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedOpticalFlowSessionNV = SharedHandle; + + //=== VK_EXT_shader_object === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedShaderEXT = SharedHandle; + + //=== VK_KHR_pipeline_binary === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedPipelineBinaryKHR = SharedHandle; + + //=== VK_ARM_data_graph === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedDataGraphPipelineSessionARM = SharedHandle; + + //=== VK_NV_external_compute_queue === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedExternalComputeQueueNV = SharedHandle; + + //=== VK_EXT_device_generated_commands === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedIndirectCommandsLayoutEXT = SharedHandle; + + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedIndirectExecutionSetEXT = SharedHandle; + + // a number of SharedHandle specializations + enum class SwapchainOwns + { + no, + yes, + }; + + struct ImageHeader : SharedHeader, typename SharedHandleTraits::deleter> + { + ImageHeader( SharedHandle> parent, + typename SharedHandleTraits::deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits::deleter() ), + SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT + : SharedHeader, typename SharedHandleTraits::deleter>( std::move( parent ), std::move( deleter ) ) + , swapchainOwned( swapchainOwned ) + { + } + + SwapchainOwns swapchainOwned = SwapchainOwns::no; + }; + + template <> + class SharedHandle : public SharedHandleBase + { + using BaseType = SharedHandleBase; + using DeleterType = typename SharedHandleTraits::deleter; + friend BaseType; + + public: + SharedHandle() = default; + + explicit SharedHandle( Image handle, + SharedHandle> parent, + SwapchainOwns swapchain_owned VULKAN_HPP_DEFAULT_ASSIGNMENT( SwapchainOwns::no ), + DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT + : BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned ) + { + } + + protected: + static void internalDestroy( const ImageHeader & control, Image handle ) VULKAN_HPP_NOEXCEPT + { + if ( control.swapchainOwned == SwapchainOwns::no ) + { + control.deleter.destroy( control.parent.get(), handle ); + } + } + }; + + struct SwapchainHeader + { + SwapchainHeader( SharedHandle surface, + SharedHandle> parent, + typename SharedHandleTraits::deleter deleter + VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits::deleter() ) ) VULKAN_HPP_NOEXCEPT + : surface( std::move( surface ) ) + , parent( std::move( parent ) ) + , deleter( std::move( deleter ) ) + { + } + + SharedHandle surface; + SharedHandle> parent; + typename SharedHandleTraits::deleter deleter; + }; + + template <> + class SharedHandle : public SharedHandleBase + { + using BaseType = SharedHandleBase; + using DeleterType = typename SharedHandleTraits::deleter; + friend BaseType; + + public: + SharedHandle() = default; + + explicit SharedHandle( SwapchainKHR handle, + SharedHandle> parent, + SharedHandle surface, + DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT + : BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) ) + { + } + + public: + const SharedHandle & getSurface() const VULKAN_HPP_NOEXCEPT + { + return getHeader().surface; + } + + protected: + using BaseType::internalDestroy; + }; + + template + class SharedHandleBaseNoDestroy : public SharedHandleBase + { + public: + using SharedHandleBase::SharedHandleBase; + + const DestructorType & getDestructorType() const VULKAN_HPP_NOEXCEPT + { + return SharedHandleBase::getHeader(); + } + + protected: + static void internalDestroy( const DestructorType &, HandleType ) VULKAN_HPP_NOEXCEPT {} + }; + + //=== VK_VERSION_1_0 === + + template <> + class SharedHandle : public SharedHandleBaseNoDestroy + { + friend SharedHandleBase; + + public: + SharedHandle() = default; + + explicit SharedHandle( PhysicalDevice handle, SharedInstance parent ) noexcept + : SharedHandleBaseNoDestroy( handle, std::move( parent ) ) + { + } + }; + + using SharedPhysicalDevice = SharedHandle; + + template <> + class SharedHandle : public SharedHandleBaseNoDestroy + { + friend SharedHandleBase; + + public: + SharedHandle() = default; + + explicit SharedHandle( Queue handle, SharedDevice parent ) noexcept : SharedHandleBaseNoDestroy( handle, std::move( parent ) ) {} + }; + + using SharedQueue = SharedHandle; + + //=== VK_KHR_display === + + template <> + class SharedHandle : public SharedHandleBaseNoDestroy + { + friend SharedHandleBase; + + public: + SharedHandle() = default; + + explicit SharedHandle( DisplayModeKHR handle, SharedDisplayKHR parent ) noexcept + : SharedHandleBaseNoDestroy( handle, std::move( parent ) ) + { + } + }; + + using SharedDisplayModeKHR = SharedHandle; +#endif // !VULKAN_HPP_NO_SMART_HANDLE +} // namespace VULKAN_HPP_NAMESPACE +#endif // VULKAN_SHARED_HPP diff --git a/lib/vulkan-headers/include/vulkan/vulkan_static_assertions.hpp b/lib/vulkan-headers/include/vulkan/vulkan_static_assertions.hpp new file mode 100644 index 00000000000..62992e01fbd --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_static_assertions.hpp @@ -0,0 +1,9861 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_STATIC_ASSERTIONS_HPP +#define VULKAN_STATIC_ASSERTIONS_HPP + +#include + +//========================= +//=== static_assertions === +//========================= + +//=== VK_VERSION_1_0 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Instance is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Instance is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "PhysicalDevice is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevice is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Device is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Device is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Queue is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Queue is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DeviceMemory is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DeviceMemory is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Fence is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Fence is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Semaphore is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Semaphore is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "QueryPool is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "QueryPool is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Buffer is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Buffer is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Image is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Image is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "ImageView is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageView is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CommandPool is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CommandPool is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CommandBuffer is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CommandBuffer is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Event is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Event is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "BufferView is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "BufferView is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "ShaderModule is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ShaderModule is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "PipelineCache is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PipelineCache is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Pipeline is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Pipeline is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "PipelineLayout is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineLayout is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Sampler is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Sampler is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DescriptorPool is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorPool is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DescriptorSet is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DescriptorSet is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DescriptorSetLayout is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorSetLayout is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Framebuffer is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Framebuffer is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "RenderPass is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "RenderPass is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Extent2D is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Extent3D is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Offset2D is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Offset3D is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Rect2D is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BaseInStructure is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BaseOutStructure is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferMemoryBarrier is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageMemoryBarrier is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MemoryBarrier is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AllocationCallbacks is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ApplicationInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FormatProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageFormatProperties ) == sizeof( VkImageFormatProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageFormatProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "InstanceCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MemoryHeap is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MemoryType is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceLimits is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMemoryProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSparseProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceQueueCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExtensionProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "LayerProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SubmitInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MappedMemoryRange is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryAllocateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryRequirements is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindSparseInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageSubresource is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SparseBufferMemoryBindInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SparseImageFormatProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SparseImageMemoryBind is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SparseImageMemoryBindInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SparseImageMemoryRequirements is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SparseImageOpaqueMemoryBindInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SparseMemoryBind is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FenceCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SemaphoreCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueryPoolCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubresourceLayout is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ComponentMapping is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageSubresourceRange is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageViewCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CommandPoolCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CommandBufferAllocateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CommandBufferBeginInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CommandBufferInheritanceInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "BufferCopy is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferImageCopy is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageCopy is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageSubresourceLayers is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DispatchIndirectCommand is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne ) == sizeof( VkPipelineCacheHeaderVersionOne ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineCacheHeaderVersionOne is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "EventCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferViewCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ShaderModuleCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineCacheCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ComputePipelineCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineShaderStageCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SpecializationInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SpecializationMapEntry is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineLayoutCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PushConstantRange is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyDescriptorSet is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorBufferInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorImageInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorPoolCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorPoolSize is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorSetAllocateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorSetLayoutBinding is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorSetLayoutCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "WriteDescriptorSet is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClearColorValue ) == sizeof( VkClearColorValue ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClearColorValue is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DrawIndexedIndirectCommand is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DrawIndirectCommand is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GraphicsPipelineCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineColorBlendAttachmentState is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineColorBlendStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineDepthStencilStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineDynamicStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineInputAssemblyStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineMultisampleStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineRasterizationStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineTessellationStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineVertexInputStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineViewportStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "StencilOpState is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VertexInputAttributeDescription is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VertexInputBindingDescription is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Viewport is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentDescription ) == sizeof( VkAttachmentDescription ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AttachmentDescription is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AttachmentReference is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FramebufferCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubpassDependency is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubpassDescription is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClearAttachment is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClearDepthStencilValue is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ClearRect is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClearValue ) == sizeof( VkClearValue ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ClearValue is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageBlit is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageResolve is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassBeginInfo is not nothrow_move_constructible!" ); + +//=== VK_VERSION_1_1 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "DescriptorUpdateTemplate is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorUpdateTemplate is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "SamplerYcbcrConversion is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerYcbcrConversion is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindBufferMemoryInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindImageMemoryInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryDedicatedRequirements is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryDedicatedAllocateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryAllocateFlagsInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceGroupCommandBufferBeginInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceGroupSubmitInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceGroupBindSparseInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindBufferMemoryDeviceGroupInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindImageMemoryDeviceGroupInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceGroupProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceGroupDeviceCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferMemoryRequirementsInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageMemoryRequirementsInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageSparseMemoryRequirementsInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryRequirements2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SparseImageMemoryRequirements2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFeatures2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceProperties2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FormatProperties2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageFormatProperties2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageFormatInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyProperties2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMemoryProperties2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SparseImageFormatProperties2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSparseImageFormatInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageViewUsageCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceProtectedMemoryFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceProtectedMemoryProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceQueueInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ProtectedSubmitInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindImagePlaneMemoryInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImagePlaneMemoryRequirementsInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalMemoryProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalImageFormatInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalImageFormatProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalBufferInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalBufferProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceIDProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalMemoryImageCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalMemoryBufferCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMemoryAllocateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalFenceInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalFenceProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportFenceCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportSemaphoreCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalSemaphoreInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalSemaphoreProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSubgroupProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevice16BitStorageFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVariablePointersFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorUpdateTemplateEntry is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorUpdateTemplateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance3Properties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorSetLayoutSupport is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerYcbcrConversionCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerYcbcrConversionInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures ) == + sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSamplerYcbcrConversionFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties ) == + sizeof( VkSamplerYcbcrConversionImageFormatProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerYcbcrConversionImageFormatProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceGroupRenderPassBeginInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePointClippingProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassInputAttachmentAspectCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "InputAttachmentAspectReference is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo ) == + sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineTessellationDomainOriginStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassMultiviewCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMultiviewFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMultiviewProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderDrawParametersFeatures is not nothrow_move_constructible!" ); + +//=== VK_VERSION_1_2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features ) == sizeof( VkPhysicalDeviceVulkan11Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVulkan11Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties ) == sizeof( VkPhysicalDeviceVulkan11Properties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVulkan11Properties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features ) == sizeof( VkPhysicalDeviceVulkan12Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVulkan12Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties ) == sizeof( VkPhysicalDeviceVulkan12Properties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVulkan12Properties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo ) == sizeof( VkImageFormatListCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageFormatListCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ConformanceVersion ) == sizeof( VkConformanceVersion ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ConformanceVersion is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties ) == sizeof( VkPhysicalDeviceDriverProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDriverProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVulkanMemoryModelFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures ) == sizeof( VkPhysicalDeviceHostQueryResetFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceHostQueryResetFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTimelineSemaphoreFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties ) == sizeof( VkPhysicalDeviceTimelineSemaphoreProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTimelineSemaphoreProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo ) == sizeof( VkSemaphoreTypeCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SemaphoreTypeCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo ) == sizeof( VkTimelineSemaphoreSubmitInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TimelineSemaphoreSubmitInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo ) == sizeof( VkSemaphoreWaitInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SemaphoreWaitInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo ) == sizeof( VkSemaphoreSignalInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SemaphoreSignalInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceBufferDeviceAddressFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo ) == sizeof( VkBufferDeviceAddressInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferDeviceAddressInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo ) == sizeof( VkBufferOpaqueCaptureAddressCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferOpaqueCaptureAddressCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo ) == sizeof( VkMemoryOpaqueCaptureAddressAllocateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryOpaqueCaptureAddressAllocateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo ) == sizeof( VkDeviceMemoryOpaqueCaptureAddressInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceMemoryOpaqueCaptureAddressInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures ) == sizeof( VkPhysicalDevice8BitStorageFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevice8BitStorageFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features ) == sizeof( VkPhysicalDeviceShaderAtomicInt64Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderAtomicInt64Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features ) == sizeof( VkPhysicalDeviceShaderFloat16Int8Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderFloat16Int8Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties ) == sizeof( VkPhysicalDeviceFloatControlsProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFloatControlsProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorSetLayoutBindingFlagsCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorIndexingFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties ) == sizeof( VkPhysicalDeviceDescriptorIndexingProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorIndexingProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo ) == + sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorSetVariableDescriptorCountAllocateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport ) == + sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupport ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorSetVariableDescriptorCountLayoutSupport is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceScalarBlockLayoutFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo ) == sizeof( VkSamplerReductionModeCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerReductionModeCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties ) == + sizeof( VkPhysicalDeviceSamplerFilterMinmaxProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSamplerFilterMinmaxProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures ) == + sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceUniformBufferStandardLayoutFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures ) == + sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderSubgroupExtendedTypesFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 ) == sizeof( VkRenderPassCreateInfo2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassCreateInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentDescription2 ) == sizeof( VkAttachmentDescription2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AttachmentDescription2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentReference2 ) == sizeof( VkAttachmentReference2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AttachmentReference2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassDescription2 ) == sizeof( VkSubpassDescription2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubpassDescription2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassDependency2 ) == sizeof( VkSubpassDependency2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubpassDependency2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassBeginInfo ) == sizeof( VkSubpassBeginInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubpassBeginInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassEndInfo ) == sizeof( VkSubpassEndInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubpassEndInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve ) == sizeof( VkSubpassDescriptionDepthStencilResolve ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubpassDescriptionDepthStencilResolve is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties ) == + sizeof( VkPhysicalDeviceDepthStencilResolveProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDepthStencilResolveProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo ) == sizeof( VkImageStencilUsageCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageStencilUsageCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImagelessFramebufferFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo ) == sizeof( VkFramebufferAttachmentsCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FramebufferAttachmentsCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo ) == sizeof( VkFramebufferAttachmentImageInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FramebufferAttachmentImageInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo ) == sizeof( VkRenderPassAttachmentBeginInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassAttachmentBeginInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures ) == + sizeof( VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSeparateDepthStencilLayoutsFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout ) == sizeof( VkAttachmentReferenceStencilLayout ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AttachmentReferenceStencilLayout is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout ) == sizeof( VkAttachmentDescriptionStencilLayout ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AttachmentDescriptionStencilLayout is not nothrow_move_constructible!" ); + +//=== VK_VERSION_1_3 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlot ) == sizeof( VkPrivateDataSlot ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "PrivateDataSlot is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PrivateDataSlot is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features ) == sizeof( VkPhysicalDeviceVulkan13Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVulkan13Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties ) == sizeof( VkPhysicalDeviceVulkan13Properties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVulkan13Properties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties ) == sizeof( VkPhysicalDeviceToolProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceToolProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures ) == sizeof( VkPhysicalDevicePrivateDataFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePrivateDataFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo ) == sizeof( VkDevicePrivateDataCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DevicePrivateDataCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo ) == sizeof( VkPrivateDataSlotCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PrivateDataSlotCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryBarrier2 ) == sizeof( VkMemoryBarrier2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryBarrier2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 ) == sizeof( VkBufferMemoryBarrier2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferMemoryBarrier2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 ) == sizeof( VkImageMemoryBarrier2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageMemoryBarrier2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DependencyInfo ) == sizeof( VkDependencyInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DependencyInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubmitInfo2 ) == sizeof( VkSubmitInfo2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SubmitInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo ) == sizeof( VkSemaphoreSubmitInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SemaphoreSubmitInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo ) == sizeof( VkCommandBufferSubmitInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CommandBufferSubmitInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features ) == sizeof( VkPhysicalDeviceSynchronization2Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSynchronization2Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 ) == sizeof( VkCopyBufferInfo2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyBufferInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyImageInfo2 ) == sizeof( VkCopyImageInfo2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyImageInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 ) == sizeof( VkCopyBufferToImageInfo2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyBufferToImageInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 ) == sizeof( VkCopyImageToBufferInfo2 ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyImageToBufferInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCopy2 ) == sizeof( VkBufferCopy2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "BufferCopy2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCopy2 ) == sizeof( VkImageCopy2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageCopy2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferImageCopy2 ) == sizeof( VkBufferImageCopy2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferImageCopy2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures ) == + sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTextureCompressionASTCHDRFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FormatProperties3 ) == sizeof( VkFormatProperties3 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FormatProperties3 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features ) == sizeof( VkPhysicalDeviceMaintenance4Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance4Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties ) == sizeof( VkPhysicalDeviceMaintenance4Properties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance4Properties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements ) == sizeof( VkDeviceBufferMemoryRequirements ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceBufferMemoryRequirements is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements ) == sizeof( VkDeviceImageMemoryRequirements ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceImageMemoryRequirements is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo ) == sizeof( VkPipelineCreationFeedbackCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineCreationFeedbackCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCreationFeedback ) == sizeof( VkPipelineCreationFeedback ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineCreationFeedback is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures ) == + sizeof( VkPhysicalDeviceShaderTerminateInvocationFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderTerminateInvocationFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures ) == + sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderDemoteToHelperInvocationFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures ) == + sizeof( VkPhysicalDevicePipelineCreationCacheControlFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePipelineCreationCacheControlFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures ) == + sizeof( VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures ) == sizeof( VkPhysicalDeviceImageRobustnessFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageRobustnessFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSubgroupSizeControlFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties ) == + sizeof( VkPhysicalDeviceSubgroupSizeControlProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSubgroupSizeControlProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo ) == + sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineShaderStageRequiredSubgroupSizeCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceInlineUniformBlockFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties ) == sizeof( VkPhysicalDeviceInlineUniformBlockProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceInlineUniformBlockProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock ) == sizeof( VkWriteDescriptorSetInlineUniformBlock ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "WriteDescriptorSetInlineUniformBlock is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorPoolInlineUniformBlockCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures ) == + sizeof( VkPhysicalDeviceShaderIntegerDotProductFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderIntegerDotProductFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties ) == + sizeof( VkPhysicalDeviceShaderIntegerDotProductProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderIntegerDotProductProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties ) == + sizeof( VkPhysicalDeviceTexelBufferAlignmentProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTexelBufferAlignmentProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BlitImageInfo2 ) == sizeof( VkBlitImageInfo2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BlitImageInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageBlit2 ) == sizeof( VkImageBlit2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageBlit2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 ) == sizeof( VkResolveImageInfo2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ResolveImageInfo2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageResolve2 ) == sizeof( VkImageResolve2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageResolve2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingInfo ) == sizeof( VkRenderingInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "RenderingInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingAttachmentInfo ) == sizeof( VkRenderingAttachmentInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderingAttachmentInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo ) == sizeof( VkPipelineRenderingCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineRenderingCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures ) == sizeof( VkPhysicalDeviceDynamicRenderingFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDynamicRenderingFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo ) == sizeof( VkCommandBufferInheritanceRenderingInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CommandBufferInheritanceRenderingInfo is not nothrow_move_constructible!" ); + +//=== VK_VERSION_1_4 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Features ) == sizeof( VkPhysicalDeviceVulkan14Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVulkan14Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Properties ) == sizeof( VkPhysicalDeviceVulkan14Properties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVulkan14Properties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfo ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceQueueGlobalPriorityCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeatures ) == sizeof( VkPhysicalDeviceGlobalPriorityQueryFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceGlobalPriorityQueryFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityProperties ) == sizeof( VkQueueFamilyGlobalPriorityProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyGlobalPriorityProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8Features ) == sizeof( VkPhysicalDeviceIndexTypeUint8Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceIndexTypeUint8Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMapInfo ) == sizeof( VkMemoryMapInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MemoryMapInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryUnmapInfo ) == sizeof( VkMemoryUnmapInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryUnmapInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Features ) == sizeof( VkPhysicalDeviceMaintenance5Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance5Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Properties ) == sizeof( VkPhysicalDeviceMaintenance5Properties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance5Properties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo ) == sizeof( VkDeviceImageSubresourceInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceImageSubresourceInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSubresource2 ) == sizeof( VkImageSubresource2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageSubresource2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubresourceLayout2 ) == sizeof( VkSubresourceLayout2 ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubresourceLayout2 is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfo ) == sizeof( VkBufferUsageFlags2CreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferUsageFlags2CreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Features ) == sizeof( VkPhysicalDeviceMaintenance6Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance6Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Properties ) == sizeof( VkPhysicalDeviceMaintenance6Properties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance6Properties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindMemoryStatus ) == sizeof( VkBindMemoryStatus ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindMemoryStatus is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeatures ) == sizeof( VkPhysicalDeviceHostImageCopyFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceHostImageCopyFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyProperties ) == sizeof( VkPhysicalDeviceHostImageCopyProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceHostImageCopyProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryToImageCopy ) == sizeof( VkMemoryToImageCopy ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryToImageCopy is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageToMemoryCopy ) == sizeof( VkImageToMemoryCopy ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageToMemoryCopy is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo ) == sizeof( VkCopyMemoryToImageInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyMemoryToImageInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo ) == sizeof( VkCopyImageToMemoryInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyImageToMemoryInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyImageToImageInfo ) == sizeof( VkCopyImageToImageInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyImageToImageInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo ) == sizeof( VkHostImageLayoutTransitionInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "HostImageLayoutTransitionInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySize ) == sizeof( VkSubresourceHostMemcpySize ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubresourceHostMemcpySize is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQuery ) == sizeof( VkHostImageCopyDevicePerformanceQuery ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "HostImageCopyDevicePerformanceQuery is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeatures ) == sizeof( VkPhysicalDeviceShaderSubgroupRotateFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderSubgroupRotateFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2Features ) == sizeof( VkPhysicalDeviceShaderFloatControls2Features ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderFloatControls2Features is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeatures ) == sizeof( VkPhysicalDeviceShaderExpectAssumeFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderExpectAssumeFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfo ) == sizeof( VkPipelineCreateFlags2CreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineCreateFlags2CreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorProperties ) == sizeof( VkPhysicalDevicePushDescriptorProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePushDescriptorProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo ) == sizeof( VkBindDescriptorSetsInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindDescriptorSetsInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushConstantsInfo ) == sizeof( VkPushConstantsInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PushConstantsInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo ) == sizeof( VkPushDescriptorSetInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PushDescriptorSetInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo ) == sizeof( VkPushDescriptorSetWithTemplateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PushDescriptorSetWithTemplateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeatures ) == + sizeof( VkPhysicalDevicePipelineProtectedAccessFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePipelineProtectedAccessFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeatures ) == sizeof( VkPhysicalDevicePipelineRobustnessFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePipelineRobustnessFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessProperties ) == sizeof( VkPhysicalDevicePipelineRobustnessProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePipelineRobustnessProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfo ) == sizeof( VkPipelineRobustnessCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineRobustnessCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeatures ) == sizeof( VkPhysicalDeviceLineRasterizationFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceLineRasterizationFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationProperties ) == sizeof( VkPhysicalDeviceLineRasterizationProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceLineRasterizationProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfo ) == sizeof( VkPipelineRasterizationLineStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineRasterizationLineStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorProperties ) == + sizeof( VkPhysicalDeviceVertexAttributeDivisorProperties ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVertexAttributeDivisorProperties is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescription ) == sizeof( VkVertexInputBindingDivisorDescription ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VertexInputBindingDivisorDescription is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfo ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineVertexInputDivisorStateCreateInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeatures ) == + sizeof( VkPhysicalDeviceVertexAttributeDivisorFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVertexAttributeDivisorFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingAreaInfo ) == sizeof( VkRenderingAreaInfo ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderingAreaInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeatures ) == + sizeof( VkPhysicalDeviceDynamicRenderingLocalReadFeatures ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDynamicRenderingLocalReadFeatures is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo ) == sizeof( VkRenderingAttachmentLocationInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderingAttachmentLocationInfo is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo ) == sizeof( VkRenderingInputAttachmentIndexInfo ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderingInputAttachmentIndexInfo is not nothrow_move_constructible!" ); + +//=== VK_KHR_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "SurfaceKHR is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SurfaceKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceFormatKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_swapchain === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "SwapchainKHR is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SwapchainKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageSwapchainCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindImageMemorySwapchainInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AcquireNextImageInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceGroupPresentCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceGroupPresentInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceGroupSwapchainCreateInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_display === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DisplayKHR is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DisplayKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DisplayModeKHR is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayModeKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayModeCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayModeParametersKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayModePropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayPlaneCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayPlanePropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplaySurfaceCreateInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_display_swapchain === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayPresentInfoKHR is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) +//=== VK_KHR_xlib_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "XlibSurfaceCreateInfoKHR is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) +//=== VK_KHR_xcb_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "XcbSurfaceCreateInfoKHR is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) +//=== VK_KHR_wayland_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "WaylandSurfaceCreateInfoKHR is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) +//=== VK_KHR_android_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AndroidSurfaceCreateInfoKHR is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) +//=== VK_KHR_win32_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "Win32SurfaceCreateInfoKHR is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +//=== VK_EXT_debug_report === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "DebugReportCallbackEXT is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DebugReportCallbackEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DebugReportCallbackCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_AMD_rasterization_order === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD ) == + sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineRasterizationStateRasterizationOrderAMD is not nothrow_move_constructible!" ); + +//=== VK_EXT_debug_marker === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DebugMarkerObjectNameInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DebugMarkerObjectTagInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DebugMarkerMarkerInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_queue === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionKHR ) == sizeof( VkVideoSessionKHR ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "VideoSessionKHR is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoSessionKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR ) == sizeof( VkVideoSessionParametersKHR ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "VideoSessionParametersKHR is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoSessionParametersKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR ) == sizeof( VkQueueFamilyQueryResultStatusPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyQueryResultStatusPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR ) == sizeof( VkQueueFamilyVideoPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyVideoPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR ) == sizeof( VkVideoProfileInfoKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoProfileInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR ) == sizeof( VkVideoProfileListInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoProfileListInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR ) == sizeof( VkVideoCapabilitiesKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR ) == sizeof( VkPhysicalDeviceVideoFormatInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVideoFormatInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR ) == sizeof( VkVideoFormatPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoFormatPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR ) == sizeof( VkVideoPictureResourceInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoPictureResourceInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR ) == sizeof( VkVideoReferenceSlotInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoReferenceSlotInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR ) == sizeof( VkVideoSessionMemoryRequirementsKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoSessionMemoryRequirementsKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR ) == sizeof( VkBindVideoSessionMemoryInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindVideoSessionMemoryInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR ) == sizeof( VkVideoSessionCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoSessionCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR ) == sizeof( VkVideoSessionParametersCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoSessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR ) == sizeof( VkVideoSessionParametersUpdateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoSessionParametersUpdateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR ) == sizeof( VkVideoBeginCodingInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoBeginCodingInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR ) == sizeof( VkVideoEndCodingInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEndCodingInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR ) == sizeof( VkVideoCodingControlInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoCodingControlInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_decode_queue === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR ) == sizeof( VkVideoDecodeCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR ) == sizeof( VkVideoDecodeUsageInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeUsageInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR ) == sizeof( VkVideoDecodeInfoKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_dedicated_allocation === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DedicatedAllocationImageCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DedicatedAllocationBufferCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DedicatedAllocationMemoryAllocateInfoNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_transform_feedback === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTransformFeedbackFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT ) == + sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTransformFeedbackPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT ) == + sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineRasterizationStateStreamCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_NVX_binary_import === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuModuleNVX ) == sizeof( VkCuModuleNVX ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CuModuleNVX is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CuModuleNVX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionNVX ) == sizeof( VkCuFunctionNVX ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CuFunctionNVX is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CuFunctionNVX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX ) == sizeof( VkCuModuleCreateInfoNVX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CuModuleCreateInfoNVX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX ) == sizeof( VkCuModuleTexturingModeCreateInfoNVX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CuModuleTexturingModeCreateInfoNVX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX ) == sizeof( VkCuFunctionCreateInfoNVX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CuFunctionCreateInfoNVX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX ) == sizeof( VkCuLaunchInfoNVX ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CuLaunchInfoNVX is not nothrow_move_constructible!" ); + +//=== VK_NVX_image_view_handle === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageViewHandleInfoNVX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX ) == sizeof( VkImageViewAddressPropertiesNVX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageViewAddressPropertiesNVX is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_encode_h264 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR ) == sizeof( VkVideoEncodeH264CapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264CapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR ) == sizeof( VkVideoEncodeH264QualityLevelPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264QualityLevelPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR ) == sizeof( VkVideoEncodeH264SessionCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264SessionCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR ) == + sizeof( VkVideoEncodeH264SessionParametersCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR ) == sizeof( VkVideoEncodeH264SessionParametersAddInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264SessionParametersAddInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR ) == sizeof( VkVideoEncodeH264SessionParametersGetInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264SessionParametersGetInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR ) == + sizeof( VkVideoEncodeH264SessionParametersFeedbackInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264SessionParametersFeedbackInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR ) == sizeof( VkVideoEncodeH264PictureInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264PictureInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR ) == sizeof( VkVideoEncodeH264DpbSlotInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264DpbSlotInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR ) == sizeof( VkVideoEncodeH264NaluSliceInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264NaluSliceInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR ) == sizeof( VkVideoEncodeH264ProfileInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264ProfileInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR ) == sizeof( VkVideoEncodeH264RateControlInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264RateControlInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR ) == sizeof( VkVideoEncodeH264RateControlLayerInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264RateControlLayerInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR ) == sizeof( VkVideoEncodeH264QpKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264QpKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR ) == sizeof( VkVideoEncodeH264FrameSizeKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264FrameSizeKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR ) == sizeof( VkVideoEncodeH264GopRemainingFrameInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264GopRemainingFrameInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_encode_h265 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR ) == sizeof( VkVideoEncodeH265CapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265CapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR ) == sizeof( VkVideoEncodeH265SessionCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265SessionCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR ) == sizeof( VkVideoEncodeH265QualityLevelPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265QualityLevelPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR ) == + sizeof( VkVideoEncodeH265SessionParametersCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR ) == sizeof( VkVideoEncodeH265SessionParametersAddInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265SessionParametersAddInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR ) == sizeof( VkVideoEncodeH265SessionParametersGetInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265SessionParametersGetInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR ) == + sizeof( VkVideoEncodeH265SessionParametersFeedbackInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265SessionParametersFeedbackInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR ) == sizeof( VkVideoEncodeH265PictureInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265PictureInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR ) == sizeof( VkVideoEncodeH265DpbSlotInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265DpbSlotInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR ) == sizeof( VkVideoEncodeH265NaluSliceSegmentInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265NaluSliceSegmentInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR ) == sizeof( VkVideoEncodeH265ProfileInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265ProfileInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR ) == sizeof( VkVideoEncodeH265RateControlInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265RateControlInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR ) == sizeof( VkVideoEncodeH265RateControlLayerInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265RateControlLayerInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR ) == sizeof( VkVideoEncodeH265QpKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265QpKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR ) == sizeof( VkVideoEncodeH265FrameSizeKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265FrameSizeKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR ) == sizeof( VkVideoEncodeH265GopRemainingFrameInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265GopRemainingFrameInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_decode_h264 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR ) == sizeof( VkVideoDecodeH264ProfileInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH264ProfileInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR ) == sizeof( VkVideoDecodeH264CapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH264CapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR ) == + sizeof( VkVideoDecodeH264SessionParametersCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH264SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR ) == sizeof( VkVideoDecodeH264SessionParametersAddInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH264SessionParametersAddInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR ) == sizeof( VkVideoDecodeH264PictureInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH264PictureInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR ) == sizeof( VkVideoDecodeH264DpbSlotInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH264DpbSlotInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_AMD_texture_gather_bias_lod === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TextureLODGatherFormatPropertiesAMD is not nothrow_move_constructible!" ); + +//=== VK_AMD_shader_info === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ShaderResourceUsageAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ShaderStatisticsInfoAMD is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_GGP ) +//=== VK_GGP_stream_descriptor_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "StreamDescriptorSurfaceCreateInfoGGP is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_GGP*/ + +//=== VK_NV_corner_sampled_image === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCornerSampledImageFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_NV_external_memory_capabilities === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalImageFormatPropertiesNV is not nothrow_move_constructible!" ); + +//=== VK_NV_external_memory === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalMemoryImageCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMemoryAllocateInfoNV is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) +//=== VK_NV_external_memory_win32 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportMemoryWin32HandleInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMemoryWin32HandleInfoNV is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) +//=== VK_NV_win32_keyed_mutex === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "Win32KeyedMutexAcquireReleaseInfoNV is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +//=== VK_EXT_validation_flags === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ValidationFlagsEXT is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_VI_NN ) +//=== VK_NN_vi_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ViSurfaceCreateInfoNN is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_VI_NN*/ + +//=== VK_EXT_astc_decode_mode === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageViewASTCDecodeModeEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceASTCDecodeFeaturesEXT is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) +//=== VK_KHR_external_memory_win32 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportMemoryWin32HandleInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMemoryWin32HandleInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryWin32HandlePropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryGetWin32HandleInfoKHR is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +//=== VK_KHR_external_memory_fd === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportMemoryFdInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryFdPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryGetFdInfoKHR is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) +//=== VK_KHR_win32_keyed_mutex === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "Win32KeyedMutexAcquireReleaseInfoKHR is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) +//=== VK_KHR_external_semaphore_win32 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportSemaphoreWin32HandleInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportSemaphoreWin32HandleInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "D3D12FenceSubmitInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SemaphoreGetWin32HandleInfoKHR is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +//=== VK_KHR_external_semaphore_fd === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportSemaphoreFdInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SemaphoreGetFdInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_EXT_conditional_rendering === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ConditionalRenderingBeginInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT ) == + sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceConditionalRenderingFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT ) == + sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CommandBufferInheritanceConditionalRenderingInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_incremental_present === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentRegionsKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentRegionKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "RectLayerKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_clip_space_w_scaling === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ViewportWScalingNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineViewportWScalingStateCreateInfoNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_display_surface_counter === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceCapabilities2EXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_display_control === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayPowerInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceEventInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayEventInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainCounterCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_GOOGLE_display_timing === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RefreshCycleDurationGOOGLE is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PastPresentationTimingGOOGLE is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentTimesInfoGOOGLE is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentTimeGOOGLE is not nothrow_move_constructible!" ); + +//=== VK_NVX_multiview_per_view_attributes === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == + sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX ) == sizeof( VkMultiviewPerViewAttributesInfoNVX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MultiviewPerViewAttributesInfoNVX is not nothrow_move_constructible!" ); + +//=== VK_NV_viewport_swizzle === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ViewportSwizzleNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineViewportSwizzleStateCreateInfoNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_discard_rectangles === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT ) == + sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDiscardRectanglePropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineDiscardRectangleStateCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_conservative_rasterization === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT ) == + sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceConservativeRasterizationPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT ) == + sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineRasterizationConservativeStateCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_depth_clip_enable === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDepthClipEnableFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT ) == + sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineRasterizationDepthClipStateCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_hdr_metadata === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "HdrMetadataEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "XYColorEXT is not nothrow_move_constructible!" ); + +//=== VK_IMG_relaxed_line_rasterization === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG ) == + sizeof( VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRelaxedLineRasterizationFeaturesIMG is not nothrow_move_constructible!" ); + +//=== VK_KHR_shared_presentable_image === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SharedPresentSurfaceCapabilitiesKHR is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) +//=== VK_KHR_external_fence_win32 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportFenceWin32HandleInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportFenceWin32HandleInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FenceGetWin32HandleInfoKHR is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +//=== VK_KHR_external_fence_fd === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportFenceFdInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FenceGetFdInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_performance_query === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR ) == sizeof( VkPhysicalDevicePerformanceQueryFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePerformanceQueryFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR ) == + sizeof( VkPhysicalDevicePerformanceQueryPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePerformanceQueryPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR ) == sizeof( VkPerformanceCounterKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceCounterKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR ) == sizeof( VkPerformanceCounterDescriptionKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceCounterDescriptionKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR ) == sizeof( VkQueryPoolPerformanceCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueryPoolPerformanceCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR ) == sizeof( VkPerformanceCounterResultKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceCounterResultKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR ) == sizeof( VkAcquireProfilingLockInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AcquireProfilingLockInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR ) == sizeof( VkPerformanceQuerySubmitInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceQuerySubmitInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_get_surface_capabilities2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSurfaceInfo2KHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceCapabilities2KHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceFormat2KHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_get_display_properties2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayProperties2KHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayPlaneProperties2KHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayModeProperties2KHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayPlaneInfo2KHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayPlaneCapabilities2KHR is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_IOS_MVK ) +//=== VK_MVK_ios_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IOSSurfaceCreateInfoMVK is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) +//=== VK_MVK_macos_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MacOSSurfaceCreateInfoMVK is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + +//=== VK_EXT_debug_utils === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "DebugUtilsMessengerEXT is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DebugUtilsMessengerEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DebugUtilsLabelEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DebugUtilsMessengerCallbackDataEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DebugUtilsMessengerCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DebugUtilsObjectNameInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DebugUtilsObjectTagInfoEXT is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) +//=== VK_ANDROID_external_memory_android_hardware_buffer === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AndroidHardwareBufferUsageANDROID is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AndroidHardwareBufferPropertiesANDROID is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID ) == + sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AndroidHardwareBufferFormatPropertiesANDROID is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportAndroidHardwareBufferInfoANDROID is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryGetAndroidHardwareBufferInfoANDROID is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalFormatANDROID is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID ) == + sizeof( VkAndroidHardwareBufferFormatProperties2ANDROID ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AndroidHardwareBufferFormatProperties2ANDROID is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) +//=== VK_AMDX_shader_enqueue === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX ) == sizeof( VkPhysicalDeviceShaderEnqueueFeaturesAMDX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderEnqueueFeaturesAMDX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX ) == sizeof( VkPhysicalDeviceShaderEnqueuePropertiesAMDX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderEnqueuePropertiesAMDX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX ) == sizeof( VkExecutionGraphPipelineScratchSizeAMDX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExecutionGraphPipelineScratchSizeAMDX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX ) == sizeof( VkExecutionGraphPipelineCreateInfoAMDX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExecutionGraphPipelineCreateInfoAMDX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchGraphInfoAMDX ) == sizeof( VkDispatchGraphInfoAMDX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DispatchGraphInfoAMDX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX ) == sizeof( VkDispatchGraphCountInfoAMDX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DispatchGraphCountInfoAMDX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX ) == sizeof( VkPipelineShaderStageNodeCreateInfoAMDX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineShaderStageNodeCreateInfoAMDX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstAMDX ) == sizeof( VkDeviceOrHostAddressConstAMDX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceOrHostAddressConstAMDX is not nothrow_move_constructible!" ); +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +//=== VK_EXT_descriptor_heap === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorARM ) == sizeof( VkTensorARM ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "TensorARM is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "TensorARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HostAddressRangeEXT ) == sizeof( VkHostAddressRangeEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "HostAddressRangeEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT ) == sizeof( VkHostAddressRangeConstEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "HostAddressRangeConstEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT ) == sizeof( VkDeviceAddressRangeEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceAddressRangeEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT ) == sizeof( VkTexelBufferDescriptorInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TexelBufferDescriptorInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT ) == sizeof( VkImageDescriptorInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageDescriptorInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ResourceDescriptorInfoEXT ) == sizeof( VkResourceDescriptorInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ResourceDescriptorInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ResourceDescriptorDataEXT ) == sizeof( VkResourceDescriptorDataEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ResourceDescriptorDataEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindHeapInfoEXT ) == sizeof( VkBindHeapInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindHeapInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushDataInfoEXT ) == sizeof( VkPushDataInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PushDataInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT ) == sizeof( VkDescriptorMappingSourceConstantOffsetEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorMappingSourceConstantOffsetEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT ) == sizeof( VkDescriptorMappingSourcePushIndexEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorMappingSourcePushIndexEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT ) == sizeof( VkDescriptorMappingSourceIndirectIndexEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorMappingSourceIndirectIndexEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT ) == sizeof( VkDescriptorMappingSourceHeapDataEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorMappingSourceHeapDataEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT ) == sizeof( VkDescriptorMappingSourceIndirectAddressEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorMappingSourceIndirectAddressEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT ) == + sizeof( VkDescriptorMappingSourceShaderRecordIndexEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorMappingSourceShaderRecordIndexEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceDataEXT ) == sizeof( VkDescriptorMappingSourceDataEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorMappingSourceDataEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT ) == + sizeof( VkDescriptorMappingSourceIndirectIndexArrayEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorMappingSourceIndirectIndexArrayEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetAndBindingMappingEXT ) == sizeof( VkDescriptorSetAndBindingMappingEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorSetAndBindingMappingEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT ) == + sizeof( VkShaderDescriptorSetAndBindingMappingInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ShaderDescriptorSetAndBindingMappingInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT ) == sizeof( VkOpaqueCaptureDataCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "OpaqueCaptureDataCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorHeapFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorHeapFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorHeapPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorHeapPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT ) == + sizeof( VkCommandBufferInheritanceDescriptorHeapInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CommandBufferInheritanceDescriptorHeapInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT ) == sizeof( VkSamplerCustomBorderColorIndexCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerCustomBorderColorIndexCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV ) == sizeof( VkIndirectCommandsLayoutPushDataTokenNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsLayoutPushDataTokenNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT ) == sizeof( VkSubsampledImageFormatPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubsampledImageFormatPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM ) == sizeof( VkTensorViewCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TensorViewCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM ) == + sizeof( VkPhysicalDeviceDescriptorHeapTensorPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorHeapTensorPropertiesARM is not nothrow_move_constructible!" ); + +//=== VK_AMD_mixed_attachment_samples === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD ) == sizeof( VkAttachmentSampleCountInfoAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AttachmentSampleCountInfoAMD is not nothrow_move_constructible!" ); + +//=== VK_KHR_shader_bfloat16 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderBfloat16FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderBfloat16FeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_EXT_sample_locations === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SampleLocationEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SampleLocationsInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AttachmentSampleLocationsEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubpassSampleLocationsEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassSampleLocationsBeginInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineSampleLocationsStateCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSampleLocationsPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MultisamplePropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_blend_operation_advanced === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == + sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceBlendOperationAdvancedFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == + sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceBlendOperationAdvancedPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT ) == + sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineColorBlendAdvancedStateCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_NV_fragment_coverage_to_color === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineCoverageToColorStateCreateInfoNV is not nothrow_move_constructible!" ); + +//=== VK_KHR_acceleration_structure === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR ) == sizeof( VkAccelerationStructureKHR ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "AccelerationStructureKHR is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR ) == sizeof( VkDeviceOrHostAddressKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceOrHostAddressKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR ) == sizeof( VkDeviceOrHostAddressConstKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceOrHostAddressConstKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR ) == sizeof( VkAccelerationStructureBuildRangeInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureBuildRangeInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AabbPositionsKHR ) == sizeof( VkAabbPositionsKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AabbPositionsKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR ) == + sizeof( VkAccelerationStructureGeometryTrianglesDataKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureGeometryTrianglesDataKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TransformMatrixKHR ) == sizeof( VkTransformMatrixKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TransformMatrixKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR ) == sizeof( VkAccelerationStructureBuildGeometryInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureBuildGeometryInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR ) == sizeof( VkAccelerationStructureGeometryAabbsDataKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureGeometryAabbsDataKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR ) == sizeof( VkAccelerationStructureInstanceKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureInstanceKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR ) == + sizeof( VkAccelerationStructureGeometryInstancesDataKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureGeometryInstancesDataKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR ) == sizeof( VkAccelerationStructureGeometryDataKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureGeometryDataKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR ) == sizeof( VkAccelerationStructureGeometryKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureGeometryKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR ) == sizeof( VkAccelerationStructureCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR ) == sizeof( VkWriteDescriptorSetAccelerationStructureKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "WriteDescriptorSetAccelerationStructureKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR ) == + sizeof( VkPhysicalDeviceAccelerationStructureFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceAccelerationStructureFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR ) == + sizeof( VkPhysicalDeviceAccelerationStructurePropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceAccelerationStructurePropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR ) == sizeof( VkAccelerationStructureDeviceAddressInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureDeviceAddressInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR ) == sizeof( VkAccelerationStructureVersionInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureVersionInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR ) == sizeof( VkCopyAccelerationStructureToMemoryInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyAccelerationStructureToMemoryInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR ) == sizeof( VkCopyMemoryToAccelerationStructureInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyMemoryToAccelerationStructureInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR ) == sizeof( VkCopyAccelerationStructureInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyAccelerationStructureInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR ) == sizeof( VkAccelerationStructureBuildSizesInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureBuildSizesInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_ray_tracing_pipeline === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR ) == sizeof( VkRayTracingShaderGroupCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RayTracingShaderGroupCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR ) == sizeof( VkRayTracingPipelineCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RayTracingPipelineCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR ) == + sizeof( VkPhysicalDeviceRayTracingPipelineFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingPipelineFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR ) == + sizeof( VkPhysicalDeviceRayTracingPipelinePropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingPipelinePropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR ) == sizeof( VkStridedDeviceAddressRegionKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "StridedDeviceAddressRegionKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR ) == sizeof( VkTraceRaysIndirectCommandKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TraceRaysIndirectCommandKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR ) == sizeof( VkRayTracingPipelineInterfaceCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RayTracingPipelineInterfaceCreateInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_ray_query === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR ) == sizeof( VkPhysicalDeviceRayQueryFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayQueryFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_framebuffer_mixed_samples === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV ) == + sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineCoverageModulationStateCreateInfoNV is not nothrow_move_constructible!" ); + +//=== VK_NV_shader_sm_builtins === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderSMBuiltinsPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderSMBuiltinsFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_image_drm_format_modifier === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DrmFormatModifierPropertiesListEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DrmFormatModifierPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT ) == + sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageDrmFormatModifierInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageDrmFormatModifierListCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT ) == + sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageDrmFormatModifierExplicitCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageDrmFormatModifierPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT ) == sizeof( VkDrmFormatModifierPropertiesList2EXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DrmFormatModifierPropertiesList2EXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT ) == sizeof( VkDrmFormatModifierProperties2EXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DrmFormatModifierProperties2EXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_validation_cache === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "ValidationCacheEXT is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ValidationCacheEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ValidationCacheCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ShaderModuleValidationCacheCreateInfoEXT is not nothrow_move_constructible!" ); + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) +//=== VK_KHR_portability_subset === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR ) == sizeof( VkPhysicalDevicePortabilitySubsetFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePortabilitySubsetFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR ) == + sizeof( VkPhysicalDevicePortabilitySubsetPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePortabilitySubsetPropertiesKHR is not nothrow_move_constructible!" ); +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +//=== VK_NV_shading_rate_image === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ShadingRatePaletteNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV ) == + sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineViewportShadingRateImageStateCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShadingRateImageFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShadingRateImagePropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CoarseSampleLocationNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CoarseSampleOrderCustomNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == + sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineViewportCoarseSampleOrderStateCreateInfoNV is not nothrow_move_constructible!" ); + +//=== VK_NV_ray_tracing === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "AccelerationStructureNV is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RayTracingShaderGroupCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RayTracingPipelineCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GeometryTrianglesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GeometryAABBNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GeometryDataNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "GeometryNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindAccelerationStructureMemoryInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "WriteDescriptorSetAccelerationStructureNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV ) == + sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureMemoryRequirementsInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingPropertiesNV is not nothrow_move_constructible!" ); + +//=== VK_NV_representative_fragment_test === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == + sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRepresentativeFragmentTestFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV ) == + sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineRepresentativeFragmentTestStateCreateInfoNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_filter_cubic === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageViewImageFormatInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT ) == + sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FilterCubicImageViewImageFormatPropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_external_memory_host === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportMemoryHostPointerInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryHostPointerPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT ) == + sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalMemoryHostPropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_shader_clock === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderClockFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_AMD_pipeline_compiler_control === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineCompilerControlCreateInfoAMD is not nothrow_move_constructible!" ); + +//=== VK_AMD_shader_core_properties === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderCorePropertiesAMD is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_decode_h265 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR ) == sizeof( VkVideoDecodeH265ProfileInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH265ProfileInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR ) == sizeof( VkVideoDecodeH265CapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH265CapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR ) == + sizeof( VkVideoDecodeH265SessionParametersCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH265SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR ) == sizeof( VkVideoDecodeH265SessionParametersAddInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH265SessionParametersAddInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR ) == sizeof( VkVideoDecodeH265PictureInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH265PictureInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR ) == sizeof( VkVideoDecodeH265DpbSlotInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH265DpbSlotInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_AMD_memory_overallocation_behavior === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceMemoryOverallocationCreateInfoAMD is not nothrow_move_constructible!" ); + +//=== VK_EXT_vertex_attribute_divisor === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == + sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVertexAttributeDivisorPropertiesEXT is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_GGP ) +//=== VK_GGP_frame_token === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentFrameTokenGGP is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_GGP*/ + +//=== VK_NV_mesh_shader === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMeshShaderFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMeshShaderPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DrawMeshTasksIndirectCommandNV is not nothrow_move_constructible!" ); + +//=== VK_NV_shader_image_footprint === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV ) == + sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderImageFootprintFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_NV_scissor_exclusive === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV ) == + sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineViewportExclusiveScissorStateCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExclusiveScissorFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_NV_device_diagnostic_checkpoints === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyCheckpointPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CheckpointDataNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV ) == sizeof( VkQueueFamilyCheckpointProperties2NV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyCheckpointProperties2NV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CheckpointData2NV ) == sizeof( VkCheckpointData2NV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CheckpointData2NV is not nothrow_move_constructible!" ); + +//=== VK_EXT_present_timing === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentTimingFeaturesEXT ) == sizeof( VkPhysicalDevicePresentTimingFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePresentTimingFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimingSurfaceCapabilitiesEXT ) == sizeof( VkPresentTimingSurfaceCapabilitiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentTimingSurfaceCapabilitiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainCalibratedTimestampInfoEXT ) == sizeof( VkSwapchainCalibratedTimestampInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainCalibratedTimestampInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainTimingPropertiesEXT ) == sizeof( VkSwapchainTimingPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainTimingPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainTimeDomainPropertiesEXT ) == sizeof( VkSwapchainTimeDomainPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainTimeDomainPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PastPresentationTimingInfoEXT ) == sizeof( VkPastPresentationTimingInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PastPresentationTimingInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PastPresentationTimingPropertiesEXT ) == sizeof( VkPastPresentationTimingPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PastPresentationTimingPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PastPresentationTimingEXT ) == sizeof( VkPastPresentationTimingEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PastPresentationTimingEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimingsInfoEXT ) == sizeof( VkPresentTimingsInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentTimingsInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimingInfoEXT ) == sizeof( VkPresentTimingInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentTimingInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentStageTimeEXT ) == sizeof( VkPresentStageTimeEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentStageTimeEXT is not nothrow_move_constructible!" ); + +//=== VK_INTEL_shader_integer_functions2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == + sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL is not nothrow_move_constructible!" ); + +//=== VK_INTEL_performance_query === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL ) == sizeof( VkPerformanceConfigurationINTEL ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "PerformanceConfigurationINTEL is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceConfigurationINTEL is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL ) == sizeof( VkPerformanceValueDataINTEL ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceValueDataINTEL is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceValueINTEL ) == sizeof( VkPerformanceValueINTEL ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceValueINTEL is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "InitializePerformanceApiInfoINTEL is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL ) == sizeof( VkQueryPoolPerformanceQueryCreateInfoINTEL ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueryPoolPerformanceQueryCreateInfoINTEL is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceMarkerInfoINTEL is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceStreamMarkerInfoINTEL is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceOverrideInfoINTEL is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceConfigurationAcquireInfoINTEL is not nothrow_move_constructible!" ); + +//=== VK_EXT_pci_bus_info === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePCIBusInfoPropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_AMD_display_native_hdr === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayNativeHdrSurfaceCapabilitiesAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainDisplayNativeHdrCreateInfoAMD is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_FUCHSIA ) +//=== VK_FUCHSIA_imagepipe_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImagePipeSurfaceCreateInfoFUCHSIA is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) +//=== VK_EXT_metal_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MetalSurfaceCreateInfoEXT is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +//=== VK_EXT_fragment_density_map === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT ) == + sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentDensityMapFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT ) == + sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentDensityMapPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassFragmentDensityMapCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT ) == + sizeof( VkRenderingFragmentDensityMapAttachmentInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderingFragmentDensityMapAttachmentInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_fragment_shading_rate === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR ) == sizeof( VkFragmentShadingRateAttachmentInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FragmentShadingRateAttachmentInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR ) == + sizeof( VkPipelineFragmentShadingRateStateCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineFragmentShadingRateStateCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR ) == + sizeof( VkPhysicalDeviceFragmentShadingRateFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentShadingRateFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR ) == + sizeof( VkPhysicalDeviceFragmentShadingRatePropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentShadingRatePropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR ) == sizeof( VkPhysicalDeviceFragmentShadingRateKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentShadingRateKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR ) == + sizeof( VkRenderingFragmentShadingRateAttachmentInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderingFragmentShadingRateAttachmentInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_AMD_shader_core_properties2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderCoreProperties2AMD is not nothrow_move_constructible!" ); + +//=== VK_AMD_device_coherent_memory === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCoherentMemoryFeaturesAMD is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_image_atomic_int64 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT ) == + sizeof( VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_shader_quad_control === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderQuadControlFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderQuadControlFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_EXT_memory_budget === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMemoryBudgetPropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_memory_priority === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMemoryPriorityFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryPriorityAllocateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_surface_protected_capabilities === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceProtectedCapabilitiesKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_dedicated_allocation_image_aliasing === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == + sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_buffer_device_address === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == + sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceBufferDeviceAddressFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferDeviceAddressCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_validation_features === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ValidationFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_present_wait === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR ) == sizeof( VkPhysicalDevicePresentWaitFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePresentWaitFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_cooperative_matrix === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CooperativeMatrixPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCooperativeMatrixFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV ) == + sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCooperativeMatrixPropertiesNV is not nothrow_move_constructible!" ); + +//=== VK_NV_coverage_reduction_mode === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV ) == + sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCoverageReductionModeFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineCoverageReductionStateCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FramebufferMixedSamplesCombinationNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_fragment_shader_interlock === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == + sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentShaderInterlockFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_ycbcr_image_arrays === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceYcbcrImageArraysFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_provoking_vertex === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT ) == sizeof( VkPhysicalDeviceProvokingVertexFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceProvokingVertexFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT ) == sizeof( VkPhysicalDeviceProvokingVertexPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceProvokingVertexPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT ) == + sizeof( VkPipelineRasterizationProvokingVertexStateCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineRasterizationProvokingVertexStateCreateInfoEXT is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) +//=== VK_EXT_full_screen_exclusive === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceFullScreenExclusiveInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceCapabilitiesFullScreenExclusiveEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceFullScreenExclusiveWin32InfoEXT is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +//=== VK_EXT_headless_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "HeadlessSurfaceCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_atomic_float === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderAtomicFloatFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_extended_dynamic_state === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT ) == + sizeof( VkPhysicalDeviceExtendedDynamicStateFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExtendedDynamicStateFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_deferred_host_operations === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DeferredOperationKHR is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeferredOperationKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_pipeline_executable_properties === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == + sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineExecutablePropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineExecutableInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR ) == sizeof( VkPipelineExecutableStatisticValueKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineExecutableStatisticValueKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineExecutableStatisticKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR ) == + sizeof( VkPipelineExecutableInternalRepresentationKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineExecutableInternalRepresentationKHR is not nothrow_move_constructible!" ); + +//=== VK_EXT_map_memory_placed === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT ) == sizeof( VkPhysicalDeviceMapMemoryPlacedFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMapMemoryPlacedFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT ) == sizeof( VkPhysicalDeviceMapMemoryPlacedPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMapMemoryPlacedPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT ) == sizeof( VkMemoryMapPlacedInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryMapPlacedInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_atomic_float2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT ) == + sizeof( VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderAtomicFloat2FeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_NV_device_generated_commands === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV ) == sizeof( VkIndirectCommandsLayoutNV ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "IndirectCommandsLayoutNV is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsLayoutNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV ) == + sizeof( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDeviceGeneratedCommandsPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV ) == + sizeof( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDeviceGeneratedCommandsFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV ) == sizeof( VkGraphicsShaderGroupCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GraphicsShaderGroupCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV ) == sizeof( VkGraphicsPipelineShaderGroupsCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GraphicsPipelineShaderGroupsCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV ) == sizeof( VkBindShaderGroupIndirectCommandNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindShaderGroupIndirectCommandNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV ) == sizeof( VkBindIndexBufferIndirectCommandNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindIndexBufferIndirectCommandNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV ) == sizeof( VkBindVertexBufferIndirectCommandNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindVertexBufferIndirectCommandNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV ) == sizeof( VkSetStateFlagsIndirectCommandNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SetStateFlagsIndirectCommandNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV ) == sizeof( VkIndirectCommandsStreamNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsStreamNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV ) == sizeof( VkIndirectCommandsLayoutTokenNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsLayoutTokenNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV ) == sizeof( VkIndirectCommandsLayoutCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsLayoutCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV ) == sizeof( VkGeneratedCommandsInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GeneratedCommandsInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV ) == sizeof( VkGeneratedCommandsMemoryRequirementsInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GeneratedCommandsMemoryRequirementsInfoNV is not nothrow_move_constructible!" ); + +//=== VK_NV_inherited_viewport_scissor === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV ) == + sizeof( VkPhysicalDeviceInheritedViewportScissorFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceInheritedViewportScissorFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV ) == + sizeof( VkCommandBufferInheritanceViewportScissorInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CommandBufferInheritanceViewportScissorInfoNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_texel_buffer_alignment === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == + sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTexelBufferAlignmentFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_QCOM_render_pass_transform === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM ) == sizeof( VkRenderPassTransformBeginInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassTransformBeginInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM ) == + sizeof( VkCommandBufferInheritanceRenderPassTransformInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CommandBufferInheritanceRenderPassTransformInfoQCOM is not nothrow_move_constructible!" ); + +//=== VK_EXT_depth_bias_control === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthBiasControlFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDepthBiasControlFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT ) == sizeof( VkDepthBiasInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DepthBiasInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT ) == sizeof( VkDepthBiasRepresentationInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DepthBiasRepresentationInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_device_memory_report === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT ) == + sizeof( VkPhysicalDeviceDeviceMemoryReportFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDeviceMemoryReportFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT ) == sizeof( VkDeviceDeviceMemoryReportCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceDeviceMemoryReportCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT ) == sizeof( VkDeviceMemoryReportCallbackDataEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceMemoryReportCallbackDataEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_custom_border_color === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorCreateInfoEXT ) == sizeof( VkSamplerCustomBorderColorCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerCustomBorderColorCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT ) == + sizeof( VkPhysicalDeviceCustomBorderColorPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCustomBorderColorPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT ) == sizeof( VkPhysicalDeviceCustomBorderColorFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCustomBorderColorFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_texture_compression_astc_3d === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT ) == + sizeof( VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTextureCompressionASTC3DFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_pipeline_library === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR ) == sizeof( VkPipelineLibraryCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineLibraryCreateInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_present_barrier === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV ) == sizeof( VkPhysicalDevicePresentBarrierFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePresentBarrierFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV ) == sizeof( VkSurfaceCapabilitiesPresentBarrierNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceCapabilitiesPresentBarrierNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV ) == sizeof( VkSwapchainPresentBarrierCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainPresentBarrierCreateInfoNV is not nothrow_move_constructible!" ); + +//=== VK_KHR_present_id === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentIdKHR ) == sizeof( VkPresentIdKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PresentIdKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR ) == sizeof( VkPhysicalDevicePresentIdFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePresentIdFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_encode_queue === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR ) == sizeof( VkVideoEncodeInfoKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR ) == sizeof( VkVideoEncodeCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR ) == sizeof( VkQueryPoolVideoEncodeFeedbackCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueryPoolVideoEncodeFeedbackCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR ) == sizeof( VkVideoEncodeUsageInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeUsageInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR ) == sizeof( VkVideoEncodeRateControlInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeRateControlInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR ) == sizeof( VkVideoEncodeRateControlLayerInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeRateControlLayerInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR ) == + sizeof( VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVideoEncodeQualityLevelInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR ) == sizeof( VkVideoEncodeQualityLevelPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeQualityLevelPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR ) == sizeof( VkVideoEncodeQualityLevelInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeQualityLevelInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR ) == sizeof( VkVideoEncodeSessionParametersGetInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeSessionParametersGetInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR ) == + sizeof( VkVideoEncodeSessionParametersFeedbackInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeSessionParametersFeedbackInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_device_diagnostics_config === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV ) == sizeof( VkPhysicalDeviceDiagnosticsConfigFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDiagnosticsConfigFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV ) == sizeof( VkDeviceDiagnosticsConfigCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceDiagnosticsConfigCreateInfoNV is not nothrow_move_constructible!" ); + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) +//=== VK_NV_cuda_kernel_launch === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CudaModuleNV ) == sizeof( VkCudaModuleNV ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CudaModuleNV is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CudaModuleNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CudaFunctionNV ) == sizeof( VkCudaFunctionNV ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CudaFunctionNV is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CudaFunctionNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV ) == sizeof( VkCudaModuleCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CudaModuleCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV ) == sizeof( VkCudaFunctionCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CudaFunctionCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV ) == sizeof( VkCudaLaunchInfoNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CudaLaunchInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV ) == sizeof( VkPhysicalDeviceCudaKernelLaunchFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCudaKernelLaunchFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV ) == sizeof( VkPhysicalDeviceCudaKernelLaunchPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCudaKernelLaunchPropertiesNV is not nothrow_move_constructible!" ); +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +//=== VK_QCOM_tile_shading === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM ) == sizeof( VkPhysicalDeviceTileShadingFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTileShadingFeaturesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM ) == sizeof( VkPhysicalDeviceTileShadingPropertiesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTileShadingPropertiesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM ) == sizeof( VkRenderPassTileShadingCreateInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassTileShadingCreateInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM ) == sizeof( VkPerTileBeginInfoQCOM ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerTileBeginInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM ) == sizeof( VkPerTileEndInfoQCOM ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerTileEndInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM ) == sizeof( VkDispatchTileInfoQCOM ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DispatchTileInfoQCOM is not nothrow_move_constructible!" ); + +//=== VK_NV_low_latency === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV ) == sizeof( VkQueryLowLatencySupportNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueryLowLatencySupportNV is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_METAL_EXT ) +//=== VK_EXT_metal_objects === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT ) == sizeof( VkExportMetalObjectCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMetalObjectCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT ) == sizeof( VkExportMetalObjectsInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMetalObjectsInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT ) == sizeof( VkExportMetalDeviceInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMetalDeviceInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT ) == sizeof( VkExportMetalCommandQueueInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMetalCommandQueueInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT ) == sizeof( VkExportMetalBufferInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMetalBufferInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT ) == sizeof( VkImportMetalBufferInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportMetalBufferInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT ) == sizeof( VkExportMetalTextureInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMetalTextureInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT ) == sizeof( VkImportMetalTextureInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportMetalTextureInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT ) == sizeof( VkExportMetalIOSurfaceInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMetalIOSurfaceInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT ) == sizeof( VkImportMetalIOSurfaceInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportMetalIOSurfaceInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT ) == sizeof( VkExportMetalSharedEventInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExportMetalSharedEventInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT ) == sizeof( VkImportMetalSharedEventInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportMetalSharedEventInfoEXT is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +//=== VK_EXT_descriptor_buffer === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT ) == + sizeof( VkPhysicalDeviceDescriptorBufferPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorBufferPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT ) == + sizeof( VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorBufferFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorBufferFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT ) == sizeof( VkDescriptorAddressInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorAddressInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT ) == sizeof( VkDescriptorBufferBindingInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorBufferBindingInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT ) == + sizeof( VkDescriptorBufferBindingPushDescriptorBufferHandleEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorBufferBindingPushDescriptorBufferHandleEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorDataEXT ) == sizeof( VkDescriptorDataEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorDataEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT ) == sizeof( VkDescriptorGetInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorGetInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT ) == sizeof( VkBufferCaptureDescriptorDataInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferCaptureDescriptorDataInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT ) == sizeof( VkImageCaptureDescriptorDataInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageCaptureDescriptorDataInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT ) == sizeof( VkImageViewCaptureDescriptorDataInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageViewCaptureDescriptorDataInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT ) == sizeof( VkSamplerCaptureDescriptorDataInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerCaptureDescriptorDataInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT ) == sizeof( VkOpaqueCaptureDescriptorDataCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "OpaqueCaptureDescriptorDataCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT ) == + sizeof( VkAccelerationStructureCaptureDescriptorDataInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureCaptureDescriptorDataInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_graphics_pipeline_library === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT ) == + sizeof( VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT ) == + sizeof( VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT ) == sizeof( VkGraphicsPipelineLibraryCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GraphicsPipelineLibraryCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_AMD_shader_early_and_late_fragment_tests === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ) == + sizeof( VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD is not nothrow_move_constructible!" ); + +//=== VK_KHR_fragment_shader_barycentric === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR ) == + sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentShaderBarycentricFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR ) == + sizeof( VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentShaderBarycentricPropertiesKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_shader_subgroup_uniform_control_flow === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) == + sizeof( VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_fragment_shading_rate_enums === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV ) == + sizeof( VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentShadingRateEnumsFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV ) == + sizeof( VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentShadingRateEnumsPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV ) == + sizeof( VkPipelineFragmentShadingRateEnumStateCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineFragmentShadingRateEnumStateCreateInfoNV is not nothrow_move_constructible!" ); + +//=== VK_NV_ray_tracing_motion_blur === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryMotionTrianglesDataNV ) == + sizeof( VkAccelerationStructureGeometryMotionTrianglesDataNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureGeometryMotionTrianglesDataNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV ) == sizeof( VkAccelerationStructureMotionInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureMotionInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceNV ) == sizeof( VkAccelerationStructureMotionInstanceNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureMotionInstanceNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV ) == sizeof( VkAccelerationStructureMotionInstanceDataNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureMotionInstanceDataNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV ) == + sizeof( VkAccelerationStructureMatrixMotionInstanceNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureMatrixMotionInstanceNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV ) == sizeof( VkAccelerationStructureSRTMotionInstanceNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureSRTMotionInstanceNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SRTDataNV ) == sizeof( VkSRTDataNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SRTDataNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV ) == + sizeof( VkPhysicalDeviceRayTracingMotionBlurFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingMotionBlurFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_mesh_shader === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMeshShaderFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMeshShaderPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT ) == sizeof( VkDrawMeshTasksIndirectCommandEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DrawMeshTasksIndirectCommandEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_ycbcr_2plane_444_formats === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) == + sizeof( VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_fragment_density_map2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT ) == + sizeof( VkPhysicalDeviceFragmentDensityMap2FeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentDensityMap2FeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT ) == + sizeof( VkPhysicalDeviceFragmentDensityMap2PropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentDensityMap2PropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_QCOM_rotated_copy_commands === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM ) == sizeof( VkCopyCommandTransformInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyCommandTransformInfoQCOM is not nothrow_move_constructible!" ); + +//=== VK_KHR_workgroup_memory_explicit_layout === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) == + sizeof( VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_EXT_image_compression_control === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT ) == + sizeof( VkPhysicalDeviceImageCompressionControlFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageCompressionControlFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT ) == sizeof( VkImageCompressionControlEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageCompressionControlEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT ) == sizeof( VkImageCompressionPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageCompressionPropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_attachment_feedback_loop_layout === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ) == + sizeof( VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_4444_formats === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT ) == sizeof( VkPhysicalDevice4444FormatsFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevice4444FormatsFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_device_fault === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT ) == sizeof( VkPhysicalDeviceFaultFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFaultFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT ) == sizeof( VkDeviceFaultCountsEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceFaultCountsEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT ) == sizeof( VkDeviceFaultInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceFaultInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT ) == sizeof( VkDeviceFaultAddressInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceFaultAddressInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT ) == sizeof( VkDeviceFaultVendorInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceFaultVendorInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT ) == sizeof( VkDeviceFaultVendorBinaryHeaderVersionOneEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceFaultVendorBinaryHeaderVersionOneEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_rgba10x6_formats === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT ) == sizeof( VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRGBA10X6FormatsFeaturesEXT is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) +//=== VK_EXT_directfb_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT ) == sizeof( VkDirectFBSurfaceCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DirectFBSurfaceCreateInfoEXT is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + +//=== VK_EXT_vertex_input_dynamic_state === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT ) == + sizeof( VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVertexInputDynamicStateFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT ) == sizeof( VkVertexInputBindingDescription2EXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VertexInputBindingDescription2EXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT ) == sizeof( VkVertexInputAttributeDescription2EXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VertexInputAttributeDescription2EXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_physical_device_drm === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT ) == sizeof( VkPhysicalDeviceDrmPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDrmPropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_device_address_binding_report === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT ) == + sizeof( VkPhysicalDeviceAddressBindingReportFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceAddressBindingReportFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT ) == sizeof( VkDeviceAddressBindingCallbackDataEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceAddressBindingCallbackDataEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_depth_clip_control === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipControlFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDepthClipControlFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT ) == + sizeof( VkPipelineViewportDepthClipControlCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineViewportDepthClipControlCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_primitive_topology_list_restart === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT ) == + sizeof( VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_FUCHSIA ) +//=== VK_FUCHSIA_external_memory === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA ) == sizeof( VkImportMemoryZirconHandleInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportMemoryZirconHandleInfoFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA ) == sizeof( VkMemoryZirconHandlePropertiesFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryZirconHandlePropertiesFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA ) == sizeof( VkMemoryGetZirconHandleInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryGetZirconHandleInfoFUCHSIA is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) +//=== VK_FUCHSIA_external_semaphore === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA ) == sizeof( VkImportSemaphoreZirconHandleInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportSemaphoreZirconHandleInfoFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA ) == sizeof( VkSemaphoreGetZirconHandleInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SemaphoreGetZirconHandleInfoFUCHSIA is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) +//=== VK_FUCHSIA_buffer_collection === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA ) == sizeof( VkBufferCollectionFUCHSIA ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "BufferCollectionFUCHSIA is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferCollectionFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA ) == sizeof( VkBufferCollectionCreateInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferCollectionCreateInfoFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA ) == sizeof( VkImportMemoryBufferCollectionFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportMemoryBufferCollectionFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA ) == sizeof( VkBufferCollectionImageCreateInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferCollectionImageCreateInfoFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA ) == sizeof( VkBufferConstraintsInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferConstraintsInfoFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA ) == sizeof( VkBufferCollectionBufferCreateInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferCollectionBufferCreateInfoFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA ) == sizeof( VkBufferCollectionPropertiesFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferCollectionPropertiesFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA ) == sizeof( VkSysmemColorSpaceFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SysmemColorSpaceFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA ) == sizeof( VkImageConstraintsInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageConstraintsInfoFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA ) == sizeof( VkImageFormatConstraintsInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageFormatConstraintsInfoFUCHSIA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA ) == sizeof( VkBufferCollectionConstraintsInfoFUCHSIA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BufferCollectionConstraintsInfoFUCHSIA is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +//=== VK_HUAWEI_subpass_shading === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI ) == sizeof( VkSubpassShadingPipelineCreateInfoHUAWEI ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubpassShadingPipelineCreateInfoHUAWEI is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI ) == sizeof( VkPhysicalDeviceSubpassShadingFeaturesHUAWEI ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSubpassShadingFeaturesHUAWEI is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI ) == + sizeof( VkPhysicalDeviceSubpassShadingPropertiesHUAWEI ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSubpassShadingPropertiesHUAWEI is not nothrow_move_constructible!" ); + +//=== VK_HUAWEI_invocation_mask === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI ) == sizeof( VkPhysicalDeviceInvocationMaskFeaturesHUAWEI ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceInvocationMaskFeaturesHUAWEI is not nothrow_move_constructible!" ); + +//=== VK_NV_external_memory_rdma === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV ) == sizeof( VkMemoryGetRemoteAddressInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryGetRemoteAddressInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV ) == sizeof( VkPhysicalDeviceExternalMemoryRDMAFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalMemoryRDMAFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_pipeline_properties === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT ) == sizeof( VkPipelinePropertiesIdentifierEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelinePropertiesIdentifierEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT ) == + sizeof( VkPhysicalDevicePipelinePropertiesFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePipelinePropertiesFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_frame_boundary === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT ) == sizeof( VkPhysicalDeviceFrameBoundaryFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFrameBoundaryFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT ) == sizeof( VkFrameBoundaryEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FrameBoundaryEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_multisampled_render_to_single_sampled === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) == + sizeof( VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT ) == sizeof( VkSubpassResolvePerformanceQueryEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SubpassResolvePerformanceQueryEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT ) == sizeof( VkMultisampledRenderToSingleSampledInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MultisampledRenderToSingleSampledInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_extended_dynamic_state2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT ) == + sizeof( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExtendedDynamicState2FeaturesEXT is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) +//=== VK_QNX_screen_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX ) == sizeof( VkScreenSurfaceCreateInfoQNX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ScreenSurfaceCreateInfoQNX is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + +//=== VK_EXT_color_write_enable === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceColorWriteEnableFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceColorWriteEnableFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT ) == sizeof( VkPipelineColorWriteCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineColorWriteCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_primitives_generated_query === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT ) == + sizeof( VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_ray_tracing_maintenance1 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR ) == + sizeof( VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingMaintenance1FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR ) == sizeof( VkTraceRaysIndirectCommand2KHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TraceRaysIndirectCommand2KHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_shader_untyped_pointers === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR ) == + sizeof( VkPhysicalDeviceShaderUntypedPointersFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderUntypedPointersFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_VALVE_video_encode_rgb_conversion === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE ) == + sizeof( VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE ) == sizeof( VkVideoEncodeRgbConversionCapabilitiesVALVE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeRgbConversionCapabilitiesVALVE is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE ) == sizeof( VkVideoEncodeProfileRgbConversionInfoVALVE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeProfileRgbConversionInfoVALVE is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE ) == + sizeof( VkVideoEncodeSessionRgbConversionCreateInfoVALVE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeSessionRgbConversionCreateInfoVALVE is not nothrow_move_constructible!" ); + +//=== VK_EXT_image_view_min_lod === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT ) == sizeof( VkPhysicalDeviceImageViewMinLodFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageViewMinLodFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT ) == sizeof( VkImageViewMinLodCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageViewMinLodCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_multi_draw === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT ) == sizeof( VkPhysicalDeviceMultiDrawFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMultiDrawFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT ) == sizeof( VkPhysicalDeviceMultiDrawPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMultiDrawPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT ) == sizeof( VkMultiDrawInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MultiDrawInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT ) == sizeof( VkMultiDrawIndexedInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MultiDrawIndexedInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_image_2d_view_of_3d === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT ) == sizeof( VkPhysicalDeviceImage2DViewOf3DFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImage2DViewOf3DFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_tile_image === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderTileImageFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderTileImageFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT ) == sizeof( VkPhysicalDeviceShaderTileImagePropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderTileImagePropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_opacity_micromap === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapEXT ) == sizeof( VkMicromapEXT ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "MicromapEXT is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MicromapEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT ) == sizeof( VkMicromapBuildInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MicromapBuildInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapUsageEXT ) == sizeof( VkMicromapUsageEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MicromapUsageEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT ) == sizeof( VkMicromapCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MicromapCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT ) == sizeof( VkPhysicalDeviceOpacityMicromapFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceOpacityMicromapFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT ) == sizeof( VkPhysicalDeviceOpacityMicromapPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceOpacityMicromapPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT ) == sizeof( VkMicromapVersionInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MicromapVersionInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT ) == sizeof( VkCopyMicromapToMemoryInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyMicromapToMemoryInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT ) == sizeof( VkCopyMemoryToMicromapInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyMemoryToMicromapInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT ) == sizeof( VkCopyMicromapInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyMicromapInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT ) == sizeof( VkMicromapBuildSizesInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MicromapBuildSizesInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesOpacityMicromapEXT ) == + sizeof( VkAccelerationStructureTrianglesOpacityMicromapEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureTrianglesOpacityMicromapEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT ) == sizeof( VkMicromapTriangleEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MicromapTriangleEXT is not nothrow_move_constructible!" ); + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) +//=== VK_NV_displacement_micromap === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV ) == + sizeof( VkPhysicalDeviceDisplacementMicromapFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDisplacementMicromapFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV ) == + sizeof( VkPhysicalDeviceDisplacementMicromapPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDisplacementMicromapPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesDisplacementMicromapNV ) == + sizeof( VkAccelerationStructureTrianglesDisplacementMicromapNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureTrianglesDisplacementMicromapNV is not nothrow_move_constructible!" ); +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +//=== VK_HUAWEI_cluster_culling_shader === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI ) == + sizeof( VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceClusterCullingShaderFeaturesHUAWEI is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI ) == + sizeof( VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceClusterCullingShaderPropertiesHUAWEI is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI ) == + sizeof( VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI is not nothrow_move_constructible!" ); + +//=== VK_EXT_border_color_swizzle === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT ) == + sizeof( VkPhysicalDeviceBorderColorSwizzleFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceBorderColorSwizzleFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT ) == + sizeof( VkSamplerBorderColorComponentMappingCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerBorderColorComponentMappingCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_pageable_device_local_memory === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT ) == + sizeof( VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_ARM_shader_core_properties === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM ) == sizeof( VkPhysicalDeviceShaderCorePropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderCorePropertiesARM is not nothrow_move_constructible!" ); + +//=== VK_ARM_scheduling_controls === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM ) == sizeof( VkDeviceQueueShaderCoreControlCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceQueueShaderCoreControlCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM ) == + sizeof( VkPhysicalDeviceSchedulingControlsFeaturesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSchedulingControlsFeaturesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM ) == + sizeof( VkPhysicalDeviceSchedulingControlsPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSchedulingControlsPropertiesARM is not nothrow_move_constructible!" ); + +//=== VK_EXT_image_sliced_view_of_3d === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT ) == + sizeof( VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageSlicedViewOf3DFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT ) == sizeof( VkImageViewSlicedCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageViewSlicedCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_VALVE_descriptor_set_host_mapping === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE ) == + sizeof( VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE ) == sizeof( VkDescriptorSetBindingReferenceVALVE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorSetBindingReferenceVALVE is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE ) == sizeof( VkDescriptorSetLayoutHostMappingInfoVALVE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorSetLayoutHostMappingInfoVALVE is not nothrow_move_constructible!" ); + +//=== VK_EXT_non_seamless_cube_map === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT ) == + sizeof( VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceNonSeamlessCubeMapFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_ARM_render_pass_striped === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM ) == sizeof( VkPhysicalDeviceRenderPassStripedFeaturesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRenderPassStripedFeaturesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM ) == + sizeof( VkPhysicalDeviceRenderPassStripedPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRenderPassStripedPropertiesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM ) == sizeof( VkRenderPassStripeBeginInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassStripeBeginInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM ) == sizeof( VkRenderPassStripeInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassStripeInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM ) == sizeof( VkRenderPassStripeSubmitInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassStripeSubmitInfoARM is not nothrow_move_constructible!" ); + +//=== VK_NV_copy_memory_indirect === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV ) == sizeof( VkPhysicalDeviceCopyMemoryIndirectFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCopyMemoryIndirectFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_NV_memory_decompression === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV ) == sizeof( VkDecompressMemoryRegionNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DecompressMemoryRegionNV is not nothrow_move_constructible!" ); + +//=== VK_NV_device_generated_commands_compute === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ) == + sizeof( VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV ) == sizeof( VkComputePipelineIndirectBufferInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ComputePipelineIndirectBufferInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV ) == sizeof( VkPipelineIndirectDeviceAddressInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineIndirectDeviceAddressInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV ) == sizeof( VkBindPipelineIndirectCommandNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindPipelineIndirectCommandNV is not nothrow_move_constructible!" ); + +//=== VK_NV_ray_tracing_linear_swept_spheres === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV ) == + sizeof( VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV ) == + sizeof( VkAccelerationStructureGeometryLinearSweptSpheresDataNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureGeometryLinearSweptSpheresDataNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV ) == sizeof( VkAccelerationStructureGeometrySpheresDataNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureGeometrySpheresDataNV is not nothrow_move_constructible!" ); + +//=== VK_NV_linear_color_attachment === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV ) == + sizeof( VkPhysicalDeviceLinearColorAttachmentFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceLinearColorAttachmentFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_KHR_shader_maximal_reconvergence === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR ) == + sizeof( VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_EXT_image_compression_control_swapchain === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT ) == + sizeof( VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_QCOM_image_processing === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM ) == sizeof( VkImageViewSampleWeightCreateInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageViewSampleWeightCreateInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM ) == sizeof( VkPhysicalDeviceImageProcessingFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageProcessingFeaturesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM ) == + sizeof( VkPhysicalDeviceImageProcessingPropertiesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageProcessingPropertiesQCOM is not nothrow_move_constructible!" ); + +//=== VK_EXT_nested_command_buffer === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT ) == + sizeof( VkPhysicalDeviceNestedCommandBufferFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceNestedCommandBufferFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT ) == + sizeof( VkPhysicalDeviceNestedCommandBufferPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceNestedCommandBufferPropertiesEXT is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_OHOS ) +//=== VK_OHOS_external_memory === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS ) == sizeof( VkNativeBufferUsageOHOS ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "NativeBufferUsageOHOS is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS ) == sizeof( VkNativeBufferPropertiesOHOS ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "NativeBufferPropertiesOHOS is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS ) == sizeof( VkNativeBufferFormatPropertiesOHOS ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "NativeBufferFormatPropertiesOHOS is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS ) == sizeof( VkImportNativeBufferInfoOHOS ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportNativeBufferInfoOHOS is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS ) == sizeof( VkMemoryGetNativeBufferInfoOHOS ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryGetNativeBufferInfoOHOS is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalFormatOHOS ) == sizeof( VkExternalFormatOHOS ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalFormatOHOS is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_OHOS*/ + +//=== VK_EXT_external_memory_acquire_unmodified === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT ) == sizeof( VkExternalMemoryAcquireUnmodifiedEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalMemoryAcquireUnmodifiedEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_extended_dynamic_state3 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT ) == + sizeof( VkPhysicalDeviceExtendedDynamicState3FeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExtendedDynamicState3FeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT ) == + sizeof( VkPhysicalDeviceExtendedDynamicState3PropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExtendedDynamicState3PropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT ) == sizeof( VkColorBlendEquationEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ColorBlendEquationEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT ) == sizeof( VkColorBlendAdvancedEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ColorBlendAdvancedEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_subpass_merge_feedback === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT ) == + sizeof( VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSubpassMergeFeedbackFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT ) == sizeof( VkRenderPassCreationControlEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassCreationControlEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT ) == sizeof( VkRenderPassCreationFeedbackInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassCreationFeedbackInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT ) == sizeof( VkRenderPassCreationFeedbackCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassCreationFeedbackCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT ) == sizeof( VkRenderPassSubpassFeedbackInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassSubpassFeedbackInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT ) == sizeof( VkRenderPassSubpassFeedbackCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassSubpassFeedbackCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_LUNARG_direct_driver_loading === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG ) == sizeof( VkDirectDriverLoadingInfoLUNARG ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DirectDriverLoadingInfoLUNARG is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG ) == sizeof( VkDirectDriverLoadingListLUNARG ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DirectDriverLoadingListLUNARG is not nothrow_move_constructible!" ); + +//=== VK_ARM_tensors === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorARM ) == sizeof( VkTensorARM ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "TensorARM is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "TensorARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorViewARM ) == sizeof( VkTensorViewARM ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "TensorViewARM is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "TensorViewARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorDescriptionARM ) == sizeof( VkTensorDescriptionARM ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TensorDescriptionARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorCreateInfoARM ) == sizeof( VkTensorCreateInfoARM ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TensorCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM ) == sizeof( VkTensorMemoryRequirementsInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TensorMemoryRequirementsInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindTensorMemoryInfoARM ) == sizeof( VkBindTensorMemoryInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindTensorMemoryInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetTensorARM ) == sizeof( VkWriteDescriptorSetTensorARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "WriteDescriptorSetTensorARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorFormatPropertiesARM ) == sizeof( VkTensorFormatPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TensorFormatPropertiesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorPropertiesARM ) == sizeof( VkPhysicalDeviceTensorPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTensorPropertiesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorMemoryBarrierARM ) == sizeof( VkTensorMemoryBarrierARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TensorMemoryBarrierARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorDependencyInfoARM ) == sizeof( VkTensorDependencyInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TensorDependencyInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorFeaturesARM ) == sizeof( VkPhysicalDeviceTensorFeaturesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTensorFeaturesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM ) == sizeof( VkDeviceTensorMemoryRequirementsARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DeviceTensorMemoryRequirementsARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyTensorInfoARM ) == sizeof( VkCopyTensorInfoARM ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyTensorInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorCopyARM ) == sizeof( VkTensorCopyARM ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "TensorCopyARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoTensorARM ) == sizeof( VkMemoryDedicatedAllocateInfoTensorARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryDedicatedAllocateInfoTensorARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalTensorInfoARM ) == sizeof( VkPhysicalDeviceExternalTensorInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalTensorInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalTensorPropertiesARM ) == sizeof( VkExternalTensorPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalTensorPropertiesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryTensorCreateInfoARM ) == sizeof( VkExternalMemoryTensorCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalMemoryTensorCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorFeaturesARM ) == + sizeof( VkPhysicalDeviceDescriptorBufferTensorFeaturesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorBufferTensorFeaturesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorPropertiesARM ) == + sizeof( VkPhysicalDeviceDescriptorBufferTensorPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorBufferTensorPropertiesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorGetTensorInfoARM ) == sizeof( VkDescriptorGetTensorInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DescriptorGetTensorInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorCaptureDescriptorDataInfoARM ) == sizeof( VkTensorCaptureDescriptorDataInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TensorCaptureDescriptorDataInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM ) == sizeof( VkTensorViewCaptureDescriptorDataInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TensorViewCaptureDescriptorDataInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FrameBoundaryTensorsARM ) == sizeof( VkFrameBoundaryTensorsARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "FrameBoundaryTensorsARM is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_module_identifier === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT ) == + sizeof( VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderModuleIdentifierFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT ) == + sizeof( VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderModuleIdentifierPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT ) == + sizeof( VkPipelineShaderStageModuleIdentifierCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineShaderStageModuleIdentifierCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT ) == sizeof( VkShaderModuleIdentifierEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ShaderModuleIdentifierEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_rasterization_order_attachment_access === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ) == + sizeof( VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_NV_optical_flow === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV ) == sizeof( VkOpticalFlowSessionNV ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "OpticalFlowSessionNV is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "OpticalFlowSessionNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV ) == sizeof( VkPhysicalDeviceOpticalFlowFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceOpticalFlowFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV ) == sizeof( VkPhysicalDeviceOpticalFlowPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceOpticalFlowPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV ) == sizeof( VkOpticalFlowImageFormatInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "OpticalFlowImageFormatInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV ) == sizeof( VkOpticalFlowImageFormatPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "OpticalFlowImageFormatPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV ) == sizeof( VkOpticalFlowSessionCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "OpticalFlowSessionCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV ) == sizeof( VkOpticalFlowSessionCreatePrivateDataInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "OpticalFlowSessionCreatePrivateDataInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV ) == sizeof( VkOpticalFlowExecuteInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "OpticalFlowExecuteInfoNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_legacy_dithering === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT ) == sizeof( VkPhysicalDeviceLegacyDitheringFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceLegacyDitheringFeaturesEXT is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) +//=== VK_ANDROID_external_format_resolve === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID ) == + sizeof( VkPhysicalDeviceExternalFormatResolveFeaturesANDROID ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalFormatResolveFeaturesANDROID is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID ) == + sizeof( VkPhysicalDeviceExternalFormatResolvePropertiesANDROID ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalFormatResolvePropertiesANDROID is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID ) == + sizeof( VkAndroidHardwareBufferFormatResolvePropertiesANDROID ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AndroidHardwareBufferFormatResolvePropertiesANDROID is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +//=== VK_AMD_anti_lag === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD ) == sizeof( VkPhysicalDeviceAntiLagFeaturesAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceAntiLagFeaturesAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AntiLagDataAMD ) == sizeof( VkAntiLagDataAMD ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AntiLagDataAMD is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD ) == sizeof( VkAntiLagPresentationInfoAMD ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AntiLagPresentationInfoAMD is not nothrow_move_constructible!" ); + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) +//=== VK_AMDX_dense_geometry_format === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX ) == + sizeof( VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDenseGeometryFormatFeaturesAMDX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureDenseGeometryFormatTrianglesDataAMDX ) == + sizeof( VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AccelerationStructureDenseGeometryFormatTrianglesDataAMDX is not nothrow_move_constructible!" ); +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +//=== VK_KHR_present_id2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentId2KHR ) == sizeof( VkSurfaceCapabilitiesPresentId2KHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceCapabilitiesPresentId2KHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentId2KHR ) == sizeof( VkPresentId2KHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PresentId2KHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentId2FeaturesKHR ) == sizeof( VkPhysicalDevicePresentId2FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePresentId2FeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_present_wait2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentWait2KHR ) == sizeof( VkSurfaceCapabilitiesPresentWait2KHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceCapabilitiesPresentWait2KHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWait2FeaturesKHR ) == sizeof( VkPhysicalDevicePresentWait2FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePresentWait2FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentWait2InfoKHR ) == sizeof( VkPresentWait2InfoKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PresentWait2InfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_ray_tracing_position_fetch === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR ) == + sizeof( VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingPositionFetchFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_object === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderEXT ) == sizeof( VkShaderEXT ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "ShaderEXT is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ShaderEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderObjectFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderObjectFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT ) == sizeof( VkPhysicalDeviceShaderObjectPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderObjectPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT ) == sizeof( VkShaderCreateInfoEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ShaderCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_pipeline_binary === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR ) == sizeof( VkPipelineBinaryKHR ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "PipelineBinaryKHR is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineBinaryKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineBinaryFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePipelineBinaryFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR ) == sizeof( VkPhysicalDevicePipelineBinaryPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePipelineBinaryPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR ) == + sizeof( VkDevicePipelineBinaryInternalCacheControlKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DevicePipelineBinaryInternalCacheControlKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR ) == sizeof( VkPipelineBinaryKeyKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineBinaryKeyKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR ) == sizeof( VkPipelineBinaryDataKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineBinaryDataKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR ) == sizeof( VkPipelineBinaryKeysAndDataKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineBinaryKeysAndDataKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR ) == sizeof( VkPipelineBinaryCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineBinaryCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR ) == sizeof( VkPipelineBinaryInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineBinaryInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR ) == sizeof( VkReleaseCapturedPipelineDataInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ReleaseCapturedPipelineDataInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR ) == sizeof( VkPipelineBinaryDataInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineBinaryDataInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR ) == sizeof( VkPipelineCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR ) == sizeof( VkPipelineBinaryHandlesInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineBinaryHandlesInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_QCOM_tile_properties === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM ) == sizeof( VkPhysicalDeviceTilePropertiesFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTilePropertiesFeaturesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TilePropertiesQCOM ) == sizeof( VkTilePropertiesQCOM ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TilePropertiesQCOM is not nothrow_move_constructible!" ); + +//=== VK_SEC_amigo_profiling === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC ) == sizeof( VkPhysicalDeviceAmigoProfilingFeaturesSEC ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceAmigoProfilingFeaturesSEC is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC ) == sizeof( VkAmigoProfilingSubmitInfoSEC ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AmigoProfilingSubmitInfoSEC is not nothrow_move_constructible!" ); + +//=== VK_KHR_surface_maintenance1 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfacePresentModeKHR ) == sizeof( VkSurfacePresentModeKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfacePresentModeKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesKHR ) == sizeof( VkSurfacePresentScalingCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfacePresentScalingCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityKHR ) == sizeof( VkSurfacePresentModeCompatibilityKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfacePresentModeCompatibilityKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_swapchain_maintenance1 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesKHR ) == + sizeof( VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceSwapchainMaintenance1FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoKHR ) == sizeof( VkSwapchainPresentFenceInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainPresentFenceInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoKHR ) == sizeof( VkSwapchainPresentModesCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainPresentModesCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoKHR ) == sizeof( VkSwapchainPresentModeInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainPresentModeInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoKHR ) == sizeof( VkSwapchainPresentScalingCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainPresentScalingCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoKHR ) == sizeof( VkReleaseSwapchainImagesInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ReleaseSwapchainImagesInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_QCOM_multiview_per_view_viewports === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) == + sizeof( VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM is not nothrow_move_constructible!" ); + +//=== VK_NV_ray_tracing_invocation_reorder === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV ) == + sizeof( VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingInvocationReorderPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV ) == + sizeof( VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingInvocationReorderFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_NV_cooperative_vector === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV ) == + sizeof( VkPhysicalDeviceCooperativeVectorPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCooperativeVectorPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeVectorFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCooperativeVectorFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV ) == sizeof( VkCooperativeVectorPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CooperativeVectorPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV ) == sizeof( VkConvertCooperativeVectorMatrixInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ConvertCooperativeVectorMatrixInfoNV is not nothrow_move_constructible!" ); + +//=== VK_NV_extended_sparse_address_space === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV ) == + sizeof( VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV ) == + sizeof( VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExtendedSparseAddressSpacePropertiesNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_mutable_descriptor_type === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT ) == + sizeof( VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMutableDescriptorTypeFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT ) == sizeof( VkMutableDescriptorTypeListEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MutableDescriptorTypeListEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT ) == sizeof( VkMutableDescriptorTypeCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MutableDescriptorTypeCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_legacy_vertex_attributes === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT ) == + sizeof( VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceLegacyVertexAttributesFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT ) == + sizeof( VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceLegacyVertexAttributesPropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_layer_settings === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT ) == sizeof( VkLayerSettingsCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "LayerSettingsCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LayerSettingEXT ) == sizeof( VkLayerSettingEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "LayerSettingEXT is not nothrow_move_constructible!" ); + +//=== VK_ARM_shader_core_builtins === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM ) == + sizeof( VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderCoreBuiltinsFeaturesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM ) == + sizeof( VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderCoreBuiltinsPropertiesARM is not nothrow_move_constructible!" ); + +//=== VK_EXT_pipeline_library_group_handles === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT ) == + sizeof( VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_dynamic_rendering_unused_attachments === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ) == + sizeof( VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_internally_synchronized_queues === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR ) == + sizeof( VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_low_latency2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV ) == sizeof( VkLatencySleepModeInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "LatencySleepModeInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV ) == sizeof( VkLatencySleepInfoNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "LatencySleepInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV ) == sizeof( VkSetLatencyMarkerInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SetLatencyMarkerInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV ) == sizeof( VkGetLatencyMarkerInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GetLatencyMarkerInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV ) == sizeof( VkLatencyTimingsFrameReportNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "LatencyTimingsFrameReportNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV ) == sizeof( VkLatencySubmissionPresentIdNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "LatencySubmissionPresentIdNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV ) == sizeof( VkSwapchainLatencyCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SwapchainLatencyCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV ) == sizeof( VkOutOfBandQueueTypeInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "OutOfBandQueueTypeInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV ) == sizeof( VkLatencySurfaceCapabilitiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "LatencySurfaceCapabilitiesNV is not nothrow_move_constructible!" ); + +//=== VK_KHR_cooperative_matrix === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR ) == sizeof( VkCooperativeMatrixPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CooperativeMatrixPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCooperativeMatrixFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR ) == + sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCooperativeMatrixPropertiesKHR is not nothrow_move_constructible!" ); + +//=== VK_ARM_data_graph === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM ) == sizeof( VkDataGraphPipelineSessionARM ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "DataGraphPipelineSessionARM is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineSessionARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphFeaturesARM ) == sizeof( VkPhysicalDeviceDataGraphFeaturesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDataGraphFeaturesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantARM ) == sizeof( VkDataGraphPipelineConstantARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineConstantARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoARM ) == sizeof( VkDataGraphPipelineResourceInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineResourceInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM ) == + sizeof( VkDataGraphPipelineCompilerControlCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineCompilerControlCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineCreateInfoARM ) == sizeof( VkDataGraphPipelineCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineShaderModuleCreateInfoARM ) == sizeof( VkDataGraphPipelineShaderModuleCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineShaderModuleCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateInfoARM ) == sizeof( VkDataGraphPipelineSessionCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineSessionCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementsInfoARM ) == + sizeof( VkDataGraphPipelineSessionBindPointRequirementsInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineSessionBindPointRequirementsInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementARM ) == + sizeof( VkDataGraphPipelineSessionBindPointRequirementARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineSessionBindPointRequirementARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionMemoryRequirementsInfoARM ) == + sizeof( VkDataGraphPipelineSessionMemoryRequirementsInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineSessionMemoryRequirementsInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindDataGraphPipelineSessionMemoryInfoARM ) == sizeof( VkBindDataGraphPipelineSessionMemoryInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindDataGraphPipelineSessionMemoryInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineInfoARM ) == sizeof( VkDataGraphPipelineInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyQueryResultARM ) == sizeof( VkDataGraphPipelinePropertyQueryResultARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelinePropertyQueryResultARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineIdentifierCreateInfoARM ) == sizeof( VkDataGraphPipelineIdentifierCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineIdentifierCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchInfoARM ) == sizeof( VkDataGraphPipelineDispatchInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineDispatchInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineARM ) == sizeof( VkPhysicalDeviceDataGraphProcessingEngineARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDataGraphProcessingEngineARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphPropertiesARM ) == sizeof( VkQueueFamilyDataGraphPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyDataGraphPropertiesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphProcessingEngineCreateInfoARM ) == sizeof( VkDataGraphProcessingEngineCreateInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphProcessingEngineCreateInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM ) == + sizeof( VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphProcessingEnginePropertiesARM ) == + sizeof( VkQueueFamilyDataGraphProcessingEnginePropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyDataGraphProcessingEnginePropertiesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM ) == sizeof( VkPhysicalDeviceDataGraphOperationSupportARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDataGraphOperationSupportARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM ) == + sizeof( VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM is not nothrow_move_constructible!" ); + +//=== VK_QCOM_multiview_per_view_render_areas === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) == + sizeof( VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) == + sizeof( VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM is not nothrow_move_constructible!" ); + +//=== VK_KHR_compute_shader_derivatives === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesKHR ) == + sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceComputeShaderDerivativesFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesPropertiesKHR ) == + sizeof( VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceComputeShaderDerivativesPropertiesKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_decode_av1 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR ) == sizeof( VkVideoDecodeAV1ProfileInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1ProfileInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR ) == sizeof( VkVideoDecodeAV1CapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1CapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR ) == + sizeof( VkVideoDecodeAV1SessionParametersCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR ) == sizeof( VkVideoDecodeAV1PictureInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1PictureInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR ) == sizeof( VkVideoDecodeAV1DpbSlotInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1DpbSlotInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_encode_av1 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoEncodeAV1FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVideoEncodeAV1FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR ) == sizeof( VkVideoEncodeAV1CapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1CapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR ) == sizeof( VkVideoEncodeAV1QualityLevelPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1QualityLevelPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR ) == sizeof( VkVideoEncodeAV1SessionCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1SessionCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR ) == + sizeof( VkVideoEncodeAV1SessionParametersCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR ) == sizeof( VkVideoEncodeAV1PictureInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1PictureInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR ) == sizeof( VkVideoEncodeAV1DpbSlotInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1DpbSlotInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR ) == sizeof( VkVideoEncodeAV1ProfileInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1ProfileInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR ) == sizeof( VkVideoEncodeAV1QIndexKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1QIndexKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR ) == sizeof( VkVideoEncodeAV1FrameSizeKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1FrameSizeKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR ) == sizeof( VkVideoEncodeAV1GopRemainingFrameInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1GopRemainingFrameInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR ) == sizeof( VkVideoEncodeAV1RateControlInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1RateControlInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR ) == sizeof( VkVideoEncodeAV1RateControlLayerInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1RateControlLayerInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_decode_vp9 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoDecodeVP9FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoDecodeVP9FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVideoDecodeVP9FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeVP9ProfileInfoKHR ) == sizeof( VkVideoDecodeVP9ProfileInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeVP9ProfileInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeVP9CapabilitiesKHR ) == sizeof( VkVideoDecodeVP9CapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeVP9CapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeVP9PictureInfoKHR ) == sizeof( VkVideoDecodeVP9PictureInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeVP9PictureInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_maintenance1 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance1FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVideoMaintenance1FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR ) == sizeof( VkVideoInlineQueryInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoInlineQueryInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_per_stage_descriptor_set === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV ) == + sizeof( VkPhysicalDevicePerStageDescriptorSetFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePerStageDescriptorSetFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_QCOM_image_processing2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM ) == sizeof( VkPhysicalDeviceImageProcessing2FeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageProcessing2FeaturesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM ) == + sizeof( VkPhysicalDeviceImageProcessing2PropertiesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageProcessing2PropertiesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM ) == sizeof( VkSamplerBlockMatchWindowCreateInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerBlockMatchWindowCreateInfoQCOM is not nothrow_move_constructible!" ); + +//=== VK_QCOM_filter_cubic_weights === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM ) == sizeof( VkPhysicalDeviceCubicWeightsFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCubicWeightsFeaturesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM ) == sizeof( VkSamplerCubicWeightsCreateInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerCubicWeightsCreateInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM ) == sizeof( VkBlitImageCubicWeightsInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BlitImageCubicWeightsInfoQCOM is not nothrow_move_constructible!" ); + +//=== VK_QCOM_ycbcr_degamma === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM ) == sizeof( VkPhysicalDeviceYcbcrDegammaFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceYcbcrDegammaFeaturesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ) == + sizeof( VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM is not nothrow_move_constructible!" ); + +//=== VK_QCOM_filter_cubic_clamp === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM ) == sizeof( VkPhysicalDeviceCubicClampFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCubicClampFeaturesQCOM is not nothrow_move_constructible!" ); + +//=== VK_EXT_attachment_feedback_loop_dynamic_state === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ) == + sizeof( VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_unified_image_layouts === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceUnifiedImageLayoutsFeaturesKHR ) == + sizeof( VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceUnifiedImageLayoutsFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentFeedbackLoopInfoEXT ) == sizeof( VkAttachmentFeedbackLoopInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "AttachmentFeedbackLoopInfoEXT is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) +//=== VK_QNX_external_memory_screen_buffer === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX ) == sizeof( VkScreenBufferPropertiesQNX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ScreenBufferPropertiesQNX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX ) == sizeof( VkScreenBufferFormatPropertiesQNX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ScreenBufferFormatPropertiesQNX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX ) == sizeof( VkImportScreenBufferInfoQNX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportScreenBufferInfoQNX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalFormatQNX ) == sizeof( VkExternalFormatQNX ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalFormatQNX is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX ) == + sizeof( VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + +//=== VK_MSFT_layered_driver === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT ) == sizeof( VkPhysicalDeviceLayeredDriverPropertiesMSFT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceLayeredDriverPropertiesMSFT is not nothrow_move_constructible!" ); + +//=== VK_KHR_calibrated_timestamps === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR ) == sizeof( VkCalibratedTimestampInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CalibratedTimestampInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_maintenance6 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT ) == sizeof( VkSetDescriptorBufferOffsetsInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SetDescriptorBufferOffsetsInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT ) == + sizeof( VkBindDescriptorBufferEmbeddedSamplersInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindDescriptorBufferEmbeddedSamplersInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_NV_descriptor_pool_overallocation === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV ) == + sizeof( VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_QCOM_tile_memory_heap === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM ) == sizeof( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTileMemoryHeapFeaturesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM ) == sizeof( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTileMemoryHeapPropertiesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM ) == sizeof( VkTileMemoryRequirementsQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TileMemoryRequirementsQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM ) == sizeof( VkTileMemoryBindInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TileMemoryBindInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM ) == sizeof( VkTileMemorySizeInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "TileMemorySizeInfoQCOM is not nothrow_move_constructible!" ); + +//=== VK_KHR_copy_memory_indirect === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR ) == sizeof( VkStridedDeviceAddressRangeKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "StridedDeviceAddressRangeKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR ) == sizeof( VkCopyMemoryIndirectCommandKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyMemoryIndirectCommandKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR ) == sizeof( VkCopyMemoryIndirectInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyMemoryIndirectInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR ) == sizeof( VkCopyMemoryToImageIndirectCommandKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyMemoryToImageIndirectCommandKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR ) == sizeof( VkCopyMemoryToImageIndirectInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CopyMemoryToImageIndirectInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR ) == + sizeof( VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCopyMemoryIndirectFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR ) == + sizeof( VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCopyMemoryIndirectPropertiesKHR is not nothrow_move_constructible!" ); + +//=== VK_EXT_memory_decompression === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT ) == sizeof( VkDecompressMemoryInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DecompressMemoryInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT ) == sizeof( VkDecompressMemoryRegionEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DecompressMemoryRegionEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT ) == + sizeof( VkPhysicalDeviceMemoryDecompressionFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMemoryDecompressionFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT ) == + sizeof( VkPhysicalDeviceMemoryDecompressionPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMemoryDecompressionPropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_NV_display_stereo === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV ) == sizeof( VkDisplaySurfaceStereoCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplaySurfaceStereoCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV ) == sizeof( VkDisplayModeStereoPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DisplayModeStereoPropertiesNV is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_encode_intra_refresh === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshCapabilitiesKHR ) == sizeof( VkVideoEncodeIntraRefreshCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeIntraRefreshCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeSessionIntraRefreshCreateInfoKHR ) == + sizeof( VkVideoEncodeSessionIntraRefreshCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeSessionIntraRefreshCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshInfoKHR ) == sizeof( VkVideoEncodeIntraRefreshInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeIntraRefreshInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoReferenceIntraRefreshInfoKHR ) == sizeof( VkVideoReferenceIntraRefreshInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoReferenceIntraRefreshInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR ) == + sizeof( VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_encode_quantization_map === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR ) == sizeof( VkVideoEncodeQuantizationMapCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeQuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR ) == sizeof( VkVideoFormatQuantizationMapPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoFormatQuantizationMapPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR ) == sizeof( VkVideoEncodeQuantizationMapInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeQuantizationMapInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR ) == + sizeof( VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeQuantizationMapSessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR ) == + sizeof( VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR ) == + sizeof( VkVideoEncodeH264QuantizationMapCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH264QuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR ) == + sizeof( VkVideoEncodeH265QuantizationMapCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeH265QuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR ) == + sizeof( VkVideoFormatH265QuantizationMapPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoFormatH265QuantizationMapPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR ) == + sizeof( VkVideoEncodeAV1QuantizationMapCapabilitiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoEncodeAV1QuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR ) == sizeof( VkVideoFormatAV1QuantizationMapPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoFormatAV1QuantizationMapPropertiesKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_raw_access_chains === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV ) == sizeof( VkPhysicalDeviceRawAccessChainsFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRawAccessChainsFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_NV_external_compute_queue === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV ) == sizeof( VkExternalComputeQueueNV ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "ExternalComputeQueueNV is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalComputeQueueNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV ) == sizeof( VkExternalComputeQueueDeviceCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalComputeQueueDeviceCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV ) == sizeof( VkExternalComputeQueueCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalComputeQueueCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV ) == sizeof( VkExternalComputeQueueDataParamsNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalComputeQueueDataParamsNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV ) == + sizeof( VkPhysicalDeviceExternalComputeQueuePropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalComputeQueuePropertiesNV is not nothrow_move_constructible!" ); + +//=== VK_KHR_shader_relaxed_extended_instruction === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ) == + sizeof( VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_command_buffer_inheritance === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCommandBufferInheritanceFeaturesNV ) == + sizeof( VkPhysicalDeviceCommandBufferInheritanceFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCommandBufferInheritanceFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_KHR_maintenance7 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance7FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance7FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR ) == sizeof( VkPhysicalDeviceMaintenance7PropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance7PropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR ) == sizeof( VkPhysicalDeviceLayeredApiPropertiesListKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceLayeredApiPropertiesListKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR ) == sizeof( VkPhysicalDeviceLayeredApiPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceLayeredApiPropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR ) == + sizeof( VkPhysicalDeviceLayeredApiVulkanPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceLayeredApiVulkanPropertiesKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_shader_atomic_float16_vector === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ) == + sizeof( VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_replicated_composites === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT ) == + sizeof( VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderReplicatedCompositesFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_float8 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat8FeaturesEXT ) == sizeof( VkPhysicalDeviceShaderFloat8FeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderFloat8FeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_NV_ray_tracing_validation === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV ) == + sizeof( VkPhysicalDeviceRayTracingValidationFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingValidationFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_NV_cluster_acceleration_structure === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV ) == + sizeof( VkPhysicalDeviceClusterAccelerationStructureFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceClusterAccelerationStructureFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV ) == + sizeof( VkPhysicalDeviceClusterAccelerationStructurePropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceClusterAccelerationStructurePropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV ) == + sizeof( VkClusterAccelerationStructureClustersBottomLevelInputNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureClustersBottomLevelInputNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV ) == + sizeof( VkClusterAccelerationStructureTriangleClusterInputNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureTriangleClusterInputNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV ) == + sizeof( VkClusterAccelerationStructureMoveObjectsInputNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureMoveObjectsInputNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV ) == sizeof( VkClusterAccelerationStructureOpInputNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureOpInputNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV ) == sizeof( VkClusterAccelerationStructureInputInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureInputInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV ) == sizeof( VkClusterAccelerationStructureCommandsInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureCommandsInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV ) == sizeof( VkStridedDeviceAddressNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "StridedDeviceAddressNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV ) == + sizeof( VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV ) == + sizeof( VkClusterAccelerationStructureMoveObjectsInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureMoveObjectsInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV ) == + sizeof( VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureBuildClustersBottomLevelInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV ) == + sizeof( VkClusterAccelerationStructureBuildTriangleClusterInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureBuildTriangleClusterInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV ) == + sizeof( VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV ) == + sizeof( VkClusterAccelerationStructureInstantiateClusterInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureInstantiateClusterInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGetTemplateIndicesInfoNV ) == + sizeof( VkClusterAccelerationStructureGetTemplateIndicesInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ClusterAccelerationStructureGetTemplateIndicesInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV ) == + sizeof( VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RayTracingPipelineClusterAccelerationStructureCreateInfoNV is not nothrow_move_constructible!" ); + +//=== VK_NV_partitioned_acceleration_structure === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV ) == + sizeof( VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePartitionedAccelerationStructureFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV ) == + sizeof( VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePartitionedAccelerationStructurePropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV ) == sizeof( VkPartitionedAccelerationStructureFlagsNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PartitionedAccelerationStructureFlagsNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV ) == + sizeof( VkBuildPartitionedAccelerationStructureIndirectCommandNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BuildPartitionedAccelerationStructureIndirectCommandNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV ) == + sizeof( VkPartitionedAccelerationStructureWriteInstanceDataNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PartitionedAccelerationStructureWriteInstanceDataNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV ) == + sizeof( VkPartitionedAccelerationStructureUpdateInstanceDataNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PartitionedAccelerationStructureUpdateInstanceDataNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV ) == + sizeof( VkPartitionedAccelerationStructureWritePartitionTranslationDataNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PartitionedAccelerationStructureWritePartitionTranslationDataNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV ) == + sizeof( VkWriteDescriptorSetPartitionedAccelerationStructureNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "WriteDescriptorSetPartitionedAccelerationStructureNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV ) == + sizeof( VkPartitionedAccelerationStructureInstancesInputNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PartitionedAccelerationStructureInstancesInputNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV ) == + sizeof( VkBuildPartitionedAccelerationStructureInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BuildPartitionedAccelerationStructureInfoNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_device_generated_commands === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT ) == sizeof( VkIndirectCommandsLayoutEXT ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "IndirectCommandsLayoutEXT is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsLayoutEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT ) == sizeof( VkIndirectExecutionSetEXT ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "IndirectExecutionSetEXT is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectExecutionSetEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT ) == + sizeof( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT ) == + sizeof( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoEXT ) == sizeof( VkGeneratedCommandsMemoryRequirementsInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GeneratedCommandsMemoryRequirementsInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetCreateInfoEXT ) == sizeof( VkIndirectExecutionSetCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectExecutionSetCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoEXT ) == sizeof( VkIndirectExecutionSetInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectExecutionSetInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT ) == sizeof( VkIndirectExecutionSetPipelineInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectExecutionSetPipelineInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT ) == sizeof( VkIndirectExecutionSetShaderInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectExecutionSetShaderInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT ) == sizeof( VkGeneratedCommandsInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GeneratedCommandsInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetPipelineEXT ) == sizeof( VkWriteIndirectExecutionSetPipelineEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "WriteIndirectExecutionSetPipelineEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoEXT ) == sizeof( VkIndirectCommandsLayoutCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsLayoutCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenEXT ) == sizeof( VkIndirectCommandsLayoutTokenEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsLayoutTokenEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawIndirectCountIndirectCommandEXT ) == sizeof( VkDrawIndirectCountIndirectCommandEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DrawIndirectCountIndirectCommandEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsVertexBufferTokenEXT ) == sizeof( VkIndirectCommandsVertexBufferTokenEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsVertexBufferTokenEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT ) == sizeof( VkBindVertexBufferIndirectCommandEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindVertexBufferIndirectCommandEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsIndexBufferTokenEXT ) == sizeof( VkIndirectCommandsIndexBufferTokenEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsIndexBufferTokenEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT ) == sizeof( VkBindIndexBufferIndirectCommandEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BindIndexBufferIndirectCommandEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsPushConstantTokenEXT ) == sizeof( VkIndirectCommandsPushConstantTokenEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsPushConstantTokenEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsExecutionSetTokenEXT ) == sizeof( VkIndirectCommandsExecutionSetTokenEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsExecutionSetTokenEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsTokenDataEXT ) == sizeof( VkIndirectCommandsTokenDataEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectCommandsTokenDataEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT ) == sizeof( VkIndirectExecutionSetShaderLayoutInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "IndirectExecutionSetShaderLayoutInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsPipelineInfoEXT ) == sizeof( VkGeneratedCommandsPipelineInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GeneratedCommandsPipelineInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsShaderInfoEXT ) == sizeof( VkGeneratedCommandsShaderInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "GeneratedCommandsShaderInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT ) == sizeof( VkWriteIndirectExecutionSetShaderEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "WriteIndirectExecutionSetShaderEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_maintenance8 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR ) == sizeof( VkMemoryBarrierAccessFlags3KHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryBarrierAccessFlags3KHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance8FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance8FeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_MESA_image_alignment_control === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA ) == + sizeof( VkPhysicalDeviceImageAlignmentControlFeaturesMESA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageAlignmentControlFeaturesMESA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA ) == + sizeof( VkPhysicalDeviceImageAlignmentControlPropertiesMESA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceImageAlignmentControlPropertiesMESA is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA ) == sizeof( VkImageAlignmentControlCreateInfoMESA ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImageAlignmentControlCreateInfoMESA is not nothrow_move_constructible!" ); + +//=== VK_KHR_shader_fma === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFmaFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderFmaFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_NV_push_constant_bank === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV ) == sizeof( VkPushConstantBankInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PushConstantBankInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV ) == sizeof( VkPhysicalDevicePushConstantBankFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePushConstantBankFeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV ) == sizeof( VkPhysicalDevicePushConstantBankPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePushConstantBankPropertiesNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_ray_tracing_invocation_reorder === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT ) == + sizeof( VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingInvocationReorderPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT ) == + sizeof( VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRayTracingInvocationReorderFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_depth_clamp_control === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClampControlFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDepthClampControlFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT ) == + sizeof( VkPipelineViewportDepthClampControlCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineViewportDepthClampControlCreateInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DepthClampRangeEXT ) == sizeof( VkDepthClampRangeEXT ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DepthClampRangeEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_maintenance9 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance9FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance9FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9PropertiesKHR ) == sizeof( VkPhysicalDeviceMaintenance9PropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance9PropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyOwnershipTransferPropertiesKHR ) == sizeof( VkQueueFamilyOwnershipTransferPropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "QueueFamilyOwnershipTransferPropertiesKHR is not nothrow_move_constructible!" ); + +//=== VK_KHR_video_maintenance2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance2FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVideoMaintenance2FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR ) == + sizeof( VkVideoDecodeH264InlineSessionParametersInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH264InlineSessionParametersInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR ) == + sizeof( VkVideoDecodeH265InlineSessionParametersInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeH265InlineSessionParametersInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR ) == + sizeof( VkVideoDecodeAV1InlineSessionParametersInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "VideoDecodeAV1InlineSessionParametersInfoKHR is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_OHOS ) +//=== VK_OHOS_surface === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS ) == sizeof( VkSurfaceCreateInfoOHOS ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SurfaceCreateInfoOHOS is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_OHOS*/ + +//=== VK_HUAWEI_hdr_vivid === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI ) == sizeof( VkPhysicalDeviceHdrVividFeaturesHUAWEI ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceHdrVividFeaturesHUAWEI is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI ) == sizeof( VkHdrVividDynamicMetadataHUAWEI ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "HdrVividDynamicMetadataHUAWEI is not nothrow_move_constructible!" ); + +//=== VK_NV_cooperative_matrix2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV ) == + sizeof( VkCooperativeMatrixFlexibleDimensionsPropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CooperativeMatrixFlexibleDimensionsPropertiesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrix2FeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCooperativeMatrix2FeaturesNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV ) == + sizeof( VkPhysicalDeviceCooperativeMatrix2PropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCooperativeMatrix2PropertiesNV is not nothrow_move_constructible!" ); + +//=== VK_ARM_pipeline_opacity_micromap === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM ) == + sizeof( VkPhysicalDevicePipelineOpacityMicromapFeaturesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePipelineOpacityMicromapFeaturesARM is not nothrow_move_constructible!" ); + +#if defined( VK_USE_PLATFORM_METAL_EXT ) +//=== VK_EXT_external_memory_metal === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT ) == sizeof( VkImportMemoryMetalHandleInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ImportMemoryMetalHandleInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT ) == sizeof( VkMemoryMetalHandlePropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryMetalHandlePropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT ) == sizeof( VkMemoryGetMetalHandleInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "MemoryGetMetalHandleInfoEXT is not nothrow_move_constructible!" ); +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +//=== VK_KHR_depth_clamp_zero_one === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR ) == sizeof( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDepthClampZeroOneFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_ARM_performance_counters_by_region === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM ) == + sizeof( VkPhysicalDevicePerformanceCountersByRegionFeaturesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePerformanceCountersByRegionFeaturesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM ) == + sizeof( VkPhysicalDevicePerformanceCountersByRegionPropertiesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePerformanceCountersByRegionPropertiesARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceCounterARM ) == sizeof( VkPerformanceCounterARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceCounterARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM ) == sizeof( VkPerformanceCounterDescriptionARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerformanceCounterDescriptionARM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM ) == + sizeof( VkRenderPassPerformanceCountersByRegionBeginInfoARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassPerformanceCountersByRegionBeginInfoARM is not nothrow_move_constructible!" ); + +//=== VK_EXT_vertex_attribute_robustness === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT ) == + sizeof( VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_ARM_format_pack === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM ) == sizeof( VkPhysicalDeviceFormatPackFeaturesARM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFormatPackFeaturesARM is not nothrow_move_constructible!" ); + +//=== VK_VALVE_fragment_density_map_layered === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE ) == + sizeof( VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE ) == + sizeof( VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE ) == + sizeof( VkPipelineFragmentDensityMapLayeredCreateInfoVALVE ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineFragmentDensityMapLayeredCreateInfoVALVE is not nothrow_move_constructible!" ); + +//=== VK_KHR_robustness2 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR ) == sizeof( VkPhysicalDeviceRobustness2FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRobustness2FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR ) == sizeof( VkPhysicalDeviceRobustness2PropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceRobustness2PropertiesKHR is not nothrow_move_constructible!" ); + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) +//=== VK_NV_present_metering === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetPresentConfigNV ) == sizeof( VkSetPresentConfigNV ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "SetPresentConfigNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV ) == sizeof( VkPhysicalDevicePresentMeteringFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePresentMeteringFeaturesNV is not nothrow_move_constructible!" ); +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +//=== VK_EXT_fragment_density_map_offset === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ) == + sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ) == + sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT ) == + sizeof( VkRenderPassFragmentDensityMapOffsetEndInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassFragmentDensityMapOffsetEndInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_zero_initialize_device_memory === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT ) == + sizeof( VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_KHR_present_mode_fifo_latest_ready === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR ) == + sizeof( VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_64bit_indexing === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT ) == + sizeof( VkPhysicalDeviceShader64BitIndexingFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShader64BitIndexingFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_EXT_custom_resolve === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomResolveFeaturesEXT ) == sizeof( VkPhysicalDeviceCustomResolveFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceCustomResolveFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BeginCustomResolveInfoEXT ) == sizeof( VkBeginCustomResolveInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "BeginCustomResolveInfoEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CustomResolveCreateInfoEXT ) == sizeof( VkCustomResolveCreateInfoEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "CustomResolveCreateInfoEXT is not nothrow_move_constructible!" ); + +//=== VK_QCOM_data_graph_model === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM ) == sizeof( VkPipelineCacheHeaderVersionDataGraphQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PipelineCacheHeaderVersionDataGraphQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM ) == + sizeof( VkDataGraphPipelineBuiltinModelCreateInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DataGraphPipelineBuiltinModelCreateInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM ) == sizeof( VkPhysicalDeviceDataGraphModelFeaturesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceDataGraphModelFeaturesQCOM is not nothrow_move_constructible!" ); + +//=== VK_KHR_maintenance10 === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance10FeaturesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance10FeaturesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR ) == sizeof( VkPhysicalDeviceMaintenance10PropertiesKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceMaintenance10PropertiesKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR ) == sizeof( VkRenderingEndInfoKHR ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderingEndInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR ) == sizeof( VkRenderingAttachmentFlagsInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderingAttachmentFlagsInfoKHR is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR ) == sizeof( VkResolveImageModeInfoKHR ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ResolveImageModeInfoKHR is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_long_vector === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderLongVectorFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderLongVectorFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT ) == + sizeof( VkPhysicalDeviceShaderLongVectorPropertiesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderLongVectorPropertiesEXT is not nothrow_move_constructible!" ); + +//=== VK_SEC_pipeline_cache_incremental_mode === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC ) == + sizeof( VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_uniform_buffer_unsized_array === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT ) == + sizeof( VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT is not nothrow_move_constructible!" ); + +//=== VK_NV_compute_occupancy_priority === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityParametersNV ) == sizeof( VkComputeOccupancyPriorityParametersNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ComputeOccupancyPriorityParametersNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeOccupancyPriorityFeaturesNV ) == + sizeof( VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceComputeOccupancyPriorityFeaturesNV is not nothrow_move_constructible!" ); + +//=== VK_EXT_shader_subgroup_partitioned === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT ) == + sizeof( VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT is not nothrow_move_constructible!" ); + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_structs.hpp b/lib/vulkan-headers/include/vulkan/vulkan_structs.hpp new file mode 100644 index 00000000000..36e2f1e5c01 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_structs.hpp @@ -0,0 +1,206351 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_STRUCTS_HPP +#define VULKAN_STRUCTS_HPP + +// include-what-you-use: make sure, vulkan.hpp is used by code-completers +// IWYU pragma: private, include "vulkan/vulkan.hpp" + +#if !defined( VULKAN_HPP_CXX_MODULE ) +# include // strcmp +#endif + +namespace VULKAN_HPP_NAMESPACE +{ + + //=============== + //=== STRUCTS === + //=============== + + // wrapper struct for struct VkAabbPositionsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAabbPositionsKHR.html + struct AabbPositionsKHR + { + using NativeType = VkAabbPositionsKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + AabbPositionsKHR( float minX_ = {}, float minY_ = {}, float minZ_ = {}, float maxX_ = {}, float maxY_ = {}, float maxZ_ = {} ) VULKAN_HPP_NOEXCEPT + : minX{ minX_ } + , minY{ minY_ } + , minZ{ minZ_ } + , maxX{ maxX_ } + , maxY{ maxY_ } + , maxZ{ maxZ_ } + { + } + + VULKAN_HPP_CONSTEXPR AabbPositionsKHR( AabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AabbPositionsKHR( VkAabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT : AabbPositionsKHR( *reinterpret_cast( &rhs ) ) {} + + AabbPositionsKHR & operator=( AabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AabbPositionsKHR & operator=( VkAabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMinX( float minX_ ) & VULKAN_HPP_NOEXCEPT + { + minX = minX_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMinX( float minX_ ) && VULKAN_HPP_NOEXCEPT + { + minX = minX_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMinY( float minY_ ) & VULKAN_HPP_NOEXCEPT + { + minY = minY_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMinY( float minY_ ) && VULKAN_HPP_NOEXCEPT + { + minY = minY_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMinZ( float minZ_ ) & VULKAN_HPP_NOEXCEPT + { + minZ = minZ_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMinZ( float minZ_ ) && VULKAN_HPP_NOEXCEPT + { + minZ = minZ_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMaxX( float maxX_ ) & VULKAN_HPP_NOEXCEPT + { + maxX = maxX_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMaxX( float maxX_ ) && VULKAN_HPP_NOEXCEPT + { + maxX = maxX_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMaxY( float maxY_ ) & VULKAN_HPP_NOEXCEPT + { + maxY = maxY_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMaxY( float maxY_ ) && VULKAN_HPP_NOEXCEPT + { + maxY = maxY_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMaxZ( float maxZ_ ) & VULKAN_HPP_NOEXCEPT + { + maxZ = maxZ_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMaxZ( float maxZ_ ) && VULKAN_HPP_NOEXCEPT + { + maxZ = maxZ_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAabbPositionsKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAabbPositionsKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAabbPositionsKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAabbPositionsKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( minX, minY, minZ, maxX, maxY, maxZ ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AabbPositionsKHR const & ) const = default; +#else + bool operator==( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( minX == rhs.minX ) && ( minY == rhs.minY ) && ( minZ == rhs.minZ ) && ( maxX == rhs.maxX ) && ( maxY == rhs.maxY ) && ( maxZ == rhs.maxZ ); +# endif + } + + bool operator!=( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + float minX = {}; + float minY = {}; + float minZ = {}; + float maxX = {}; + float maxY = {}; + float maxZ = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AabbPositionsKHR; + }; +#endif + using AabbPositionsNV = AabbPositionsKHR; + + union DeviceOrHostAddressConstKHR + { + using NativeType = VkDeviceOrHostAddressConstKHR; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR( DeviceAddress deviceAddress_ = {} ) : deviceAddress( deviceAddress_ ) {} + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR( const void * hostAddress_ ) : hostAddress( hostAddress_ ) {} +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR & setHostAddress( const void * hostAddress_ ) & VULKAN_HPP_NOEXCEPT + { + hostAddress = hostAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR && setHostAddress( const void * hostAddress_ ) && VULKAN_HPP_NOEXCEPT + { + hostAddress = hostAddress_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceOrHostAddressConstKHR const &() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceOrHostAddressConstKHR &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + DeviceAddress deviceAddress; + const void * hostAddress; +#else + VkDeviceAddress deviceAddress; + const void * hostAddress; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceOrHostAddressConstKHR; + }; +#endif + + // wrapper struct for struct VkAccelerationStructureGeometryTrianglesDataKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html + struct AccelerationStructureGeometryTrianglesDataKHR + { + using NativeType = VkAccelerationStructureGeometryTrianglesDataKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR( Format vertexFormat_ = Format::eUndefined, + DeviceOrHostAddressConstKHR vertexData_ = {}, + DeviceSize vertexStride_ = {}, + uint32_t maxVertex_ = {}, + IndexType indexType_ = IndexType::eUint16, + DeviceOrHostAddressConstKHR indexData_ = {}, + DeviceOrHostAddressConstKHR transformData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vertexFormat{ vertexFormat_ } + , vertexData{ vertexData_ } + , vertexStride{ vertexStride_ } + , maxVertex{ maxVertex_ } + , indexType{ indexType_ } + , indexData{ indexData_ } + , transformData{ transformData_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + AccelerationStructureGeometryTrianglesDataKHR( AccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureGeometryTrianglesDataKHR( VkAccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureGeometryTrianglesDataKHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureGeometryTrianglesDataKHR & operator=( AccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureGeometryTrianglesDataKHR & operator=( VkAccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT + { + vertexFormat = vertexFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT + { + vertexFormat = vertexFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexData = vertexData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexData = vertexData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT + { + vertexStride = vertexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT + { + vertexStride = vertexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setMaxVertex( uint32_t maxVertex_ ) & VULKAN_HPP_NOEXCEPT + { + maxVertex = maxVertex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setMaxVertex( uint32_t maxVertex_ ) && VULKAN_HPP_NOEXCEPT + { + maxVertex = maxVertex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) & VULKAN_HPP_NOEXCEPT + { + indexData = indexData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) && + VULKAN_HPP_NOEXCEPT + { + indexData = indexData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setTransformData( DeviceOrHostAddressConstKHR const & transformData_ ) & + VULKAN_HPP_NOEXCEPT + { + transformData = transformData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setTransformData( DeviceOrHostAddressConstKHR const & transformData_ ) && + VULKAN_HPP_NOEXCEPT + { + transformData = transformData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureGeometryTrianglesDataKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryTrianglesDataKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryTrianglesDataKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryTrianglesDataKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexFormat, vertexData, vertexStride, maxVertex, indexType, indexData, transformData ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR; + const void * pNext = {}; + Format vertexFormat = Format::eUndefined; + DeviceOrHostAddressConstKHR vertexData = {}; + DeviceSize vertexStride = {}; + uint32_t maxVertex = {}; + IndexType indexType = IndexType::eUint16; + DeviceOrHostAddressConstKHR indexData = {}; + DeviceOrHostAddressConstKHR transformData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureGeometryTrianglesDataKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureGeometryTrianglesDataKHR; + }; + + // wrapper struct for struct VkAccelerationStructureGeometryAabbsDataKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html + struct AccelerationStructureGeometryAabbsDataKHR + { + using NativeType = VkAccelerationStructureGeometryAabbsDataKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryAabbsDataKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR( DeviceOrHostAddressConstKHR data_ = {}, + DeviceSize stride_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , data{ data_ } + , stride{ stride_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR( AccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureGeometryAabbsDataKHR( VkAccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureGeometryAabbsDataKHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureGeometryAabbsDataKHR & operator=( AccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureGeometryAabbsDataKHR & operator=( VkAccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR & setData( DeviceOrHostAddressConstKHR const & data_ ) & VULKAN_HPP_NOEXCEPT + { + data = data_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR && setData( DeviceOrHostAddressConstKHR const & data_ ) && VULKAN_HPP_NOEXCEPT + { + data = data_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR & setStride( DeviceSize stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR && setStride( DeviceSize stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureGeometryAabbsDataKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryAabbsDataKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryAabbsDataKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryAabbsDataKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, data, stride ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureGeometryAabbsDataKHR; + const void * pNext = {}; + DeviceOrHostAddressConstKHR data = {}; + DeviceSize stride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureGeometryAabbsDataKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureGeometryAabbsDataKHR; + }; + + // wrapper struct for struct VkAccelerationStructureGeometryInstancesDataKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html + struct AccelerationStructureGeometryInstancesDataKHR + { + using NativeType = VkAccelerationStructureGeometryInstancesDataKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryInstancesDataKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR( Bool32 arrayOfPointers_ = {}, + DeviceOrHostAddressConstKHR data_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , arrayOfPointers{ arrayOfPointers_ } + , data{ data_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + AccelerationStructureGeometryInstancesDataKHR( AccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureGeometryInstancesDataKHR( VkAccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureGeometryInstancesDataKHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureGeometryInstancesDataKHR & operator=( AccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureGeometryInstancesDataKHR & operator=( VkAccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR & setArrayOfPointers( Bool32 arrayOfPointers_ ) & VULKAN_HPP_NOEXCEPT + { + arrayOfPointers = arrayOfPointers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR && setArrayOfPointers( Bool32 arrayOfPointers_ ) && VULKAN_HPP_NOEXCEPT + { + arrayOfPointers = arrayOfPointers_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR & setData( DeviceOrHostAddressConstKHR const & data_ ) & VULKAN_HPP_NOEXCEPT + { + data = data_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR && setData( DeviceOrHostAddressConstKHR const & data_ ) && VULKAN_HPP_NOEXCEPT + { + data = data_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureGeometryInstancesDataKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryInstancesDataKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryInstancesDataKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryInstancesDataKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, arrayOfPointers, data ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureGeometryInstancesDataKHR; + const void * pNext = {}; + Bool32 arrayOfPointers = {}; + DeviceOrHostAddressConstKHR data = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureGeometryInstancesDataKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureGeometryInstancesDataKHR; + }; + + union AccelerationStructureGeometryDataKHR + { + using NativeType = VkAccelerationStructureGeometryDataKHR; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR( AccelerationStructureGeometryTrianglesDataKHR triangles_ = {} ) : triangles( triangles_ ) {} + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR( AccelerationStructureGeometryAabbsDataKHR aabbs_ ) : aabbs( aabbs_ ) {} + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR( AccelerationStructureGeometryInstancesDataKHR instances_ ) : instances( instances_ ) {} +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR & setTriangles( AccelerationStructureGeometryTrianglesDataKHR const & triangles_ ) & + VULKAN_HPP_NOEXCEPT + { + triangles = triangles_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR && setTriangles( AccelerationStructureGeometryTrianglesDataKHR const & triangles_ ) && + VULKAN_HPP_NOEXCEPT + { + triangles = triangles_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR & setAabbs( AccelerationStructureGeometryAabbsDataKHR const & aabbs_ ) & VULKAN_HPP_NOEXCEPT + { + aabbs = aabbs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR && setAabbs( AccelerationStructureGeometryAabbsDataKHR const & aabbs_ ) && VULKAN_HPP_NOEXCEPT + { + aabbs = aabbs_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR & setInstances( AccelerationStructureGeometryInstancesDataKHR const & instances_ ) & + VULKAN_HPP_NOEXCEPT + { + instances = instances_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR && setInstances( AccelerationStructureGeometryInstancesDataKHR const & instances_ ) && + VULKAN_HPP_NOEXCEPT + { + instances = instances_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureGeometryDataKHR const &() const + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryDataKHR &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + AccelerationStructureGeometryTrianglesDataKHR triangles; + AccelerationStructureGeometryAabbsDataKHR aabbs; + AccelerationStructureGeometryInstancesDataKHR instances; +#else + VkAccelerationStructureGeometryTrianglesDataKHR triangles; + VkAccelerationStructureGeometryAabbsDataKHR aabbs; + VkAccelerationStructureGeometryInstancesDataKHR instances; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureGeometryDataKHR; + }; +#endif + + // wrapper struct for struct VkAccelerationStructureGeometryKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryKHR.html + struct AccelerationStructureGeometryKHR + { + using NativeType = VkAccelerationStructureGeometryKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR( GeometryTypeKHR geometryType_ = GeometryTypeKHR::eTriangles, + AccelerationStructureGeometryDataKHR geometry_ = {}, + GeometryFlagsKHR flags_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , geometryType{ geometryType_ } + , geometry{ geometry_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR( AccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureGeometryKHR( VkAccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureGeometryKHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureGeometryKHR & operator=( AccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureGeometryKHR & operator=( VkAccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setGeometryType( GeometryTypeKHR geometryType_ ) & VULKAN_HPP_NOEXCEPT + { + geometryType = geometryType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setGeometryType( GeometryTypeKHR geometryType_ ) && VULKAN_HPP_NOEXCEPT + { + geometryType = geometryType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setGeometry( AccelerationStructureGeometryDataKHR const & geometry_ ) & VULKAN_HPP_NOEXCEPT + { + geometry = geometry_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setGeometry( AccelerationStructureGeometryDataKHR const & geometry_ ) && VULKAN_HPP_NOEXCEPT + { + geometry = geometry_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setFlags( GeometryFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setFlags( GeometryFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureGeometryKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, geometryType, geometry, flags ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureGeometryKHR; + const void * pNext = {}; + GeometryTypeKHR geometryType = GeometryTypeKHR::eTriangles; + AccelerationStructureGeometryDataKHR geometry = {}; + GeometryFlagsKHR flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureGeometryKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureGeometryKHR; + }; + + union DeviceOrHostAddressKHR + { + using NativeType = VkDeviceOrHostAddressKHR; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR( DeviceAddress deviceAddress_ = {} ) : deviceAddress( deviceAddress_ ) {} + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR( void * hostAddress_ ) : hostAddress( hostAddress_ ) {} +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR & setHostAddress( void * hostAddress_ ) & VULKAN_HPP_NOEXCEPT + { + hostAddress = hostAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR && setHostAddress( void * hostAddress_ ) && VULKAN_HPP_NOEXCEPT + { + hostAddress = hostAddress_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceOrHostAddressKHR const &() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceOrHostAddressKHR &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + DeviceAddress deviceAddress; + void * hostAddress; +#else + VkDeviceAddress deviceAddress; + void * hostAddress; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceOrHostAddressKHR; + }; +#endif + + // wrapper struct for struct VkAccelerationStructureBuildGeometryInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html + struct AccelerationStructureBuildGeometryInfoKHR + { + using NativeType = VkAccelerationStructureBuildGeometryInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureBuildGeometryInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR( AccelerationStructureTypeKHR type_ = AccelerationStructureTypeKHR::eTopLevel, + BuildAccelerationStructureFlagsKHR flags_ = {}, + BuildAccelerationStructureModeKHR mode_ = BuildAccelerationStructureModeKHR::eBuild, + AccelerationStructureKHR srcAccelerationStructure_ = {}, + AccelerationStructureKHR dstAccelerationStructure_ = {}, + uint32_t geometryCount_ = {}, + const AccelerationStructureGeometryKHR * pGeometries_ = {}, + const AccelerationStructureGeometryKHR * const * ppGeometries_ = {}, + DeviceOrHostAddressKHR scratchData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , flags{ flags_ } + , mode{ mode_ } + , srcAccelerationStructure{ srcAccelerationStructure_ } + , dstAccelerationStructure{ dstAccelerationStructure_ } + , geometryCount{ geometryCount_ } + , pGeometries{ pGeometries_ } + , ppGeometries{ ppGeometries_ } + , scratchData{ scratchData_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR( AccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureBuildGeometryInfoKHR( VkAccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureBuildGeometryInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureBuildGeometryInfoKHR( AccelerationStructureTypeKHR type_, + BuildAccelerationStructureFlagsKHR flags_, + BuildAccelerationStructureModeKHR mode_, + AccelerationStructureKHR srcAccelerationStructure_, + AccelerationStructureKHR dstAccelerationStructure_, + ArrayProxyNoTemporaries const & geometries_, + ArrayProxyNoTemporaries const & pGeometries_ = {}, + DeviceOrHostAddressKHR scratchData_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , type( type_ ) + , flags( flags_ ) + , mode( mode_ ) + , srcAccelerationStructure( srcAccelerationStructure_ ) + , dstAccelerationStructure( dstAccelerationStructure_ ) + , geometryCount( static_cast( !geometries_.empty() ? geometries_.size() : pGeometries_.size() ) ) + , pGeometries( geometries_.data() ) + , ppGeometries( pGeometries_.data() ) + , scratchData( scratchData_ ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( ( !geometries_.empty() + !pGeometries_.empty() ) <= 1 ); +# else + if ( 1 < ( !geometries_.empty() + !pGeometries_.empty() ) ) + { + throw LogicError( + VULKAN_HPP_NAMESPACE_STRING + "::AccelerationStructureBuildGeometryInfoKHR::AccelerationStructureBuildGeometryInfoKHR: 1 < ( !geometries_.empty() + !pGeometries_.empty() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + AccelerationStructureBuildGeometryInfoKHR & operator=( AccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureBuildGeometryInfoKHR & operator=( VkAccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setType( AccelerationStructureTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setType( AccelerationStructureTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setFlags( BuildAccelerationStructureFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setFlags( BuildAccelerationStructureFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setMode( BuildAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setMode( BuildAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setSrcAccelerationStructure( AccelerationStructureKHR srcAccelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + srcAccelerationStructure = srcAccelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setSrcAccelerationStructure( AccelerationStructureKHR srcAccelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + srcAccelerationStructure = srcAccelerationStructure_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setDstAccelerationStructure( AccelerationStructureKHR dstAccelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + dstAccelerationStructure = dstAccelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setDstAccelerationStructure( AccelerationStructureKHR dstAccelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + dstAccelerationStructure = dstAccelerationStructure_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setGeometryCount( uint32_t geometryCount_ ) & VULKAN_HPP_NOEXCEPT + { + geometryCount = geometryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setGeometryCount( uint32_t geometryCount_ ) && VULKAN_HPP_NOEXCEPT + { + geometryCount = geometryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setPGeometries( const AccelerationStructureGeometryKHR * pGeometries_ ) & + VULKAN_HPP_NOEXCEPT + { + pGeometries = pGeometries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setPGeometries( const AccelerationStructureGeometryKHR * pGeometries_ ) && + VULKAN_HPP_NOEXCEPT + { + pGeometries = pGeometries_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureBuildGeometryInfoKHR & + setGeometries( ArrayProxyNoTemporaries const & geometries_ ) VULKAN_HPP_NOEXCEPT + { + geometryCount = static_cast( geometries_.size() ); + pGeometries = geometries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setPpGeometries( const AccelerationStructureGeometryKHR * const * ppGeometries_ ) & + VULKAN_HPP_NOEXCEPT + { + ppGeometries = ppGeometries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setPpGeometries( const AccelerationStructureGeometryKHR * const * ppGeometries_ ) && + VULKAN_HPP_NOEXCEPT + { + ppGeometries = ppGeometries_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureBuildGeometryInfoKHR & + setPGeometries( ArrayProxyNoTemporaries const & pGeometries_ ) VULKAN_HPP_NOEXCEPT + { + geometryCount = static_cast( pGeometries_.size() ); + ppGeometries = pGeometries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setScratchData( DeviceOrHostAddressKHR const & scratchData_ ) & VULKAN_HPP_NOEXCEPT + { + scratchData = scratchData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setScratchData( DeviceOrHostAddressKHR const & scratchData_ ) && VULKAN_HPP_NOEXCEPT + { + scratchData = scratchData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureBuildGeometryInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureBuildGeometryInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureBuildGeometryInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureBuildGeometryInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, type, flags, mode, srcAccelerationStructure, dstAccelerationStructure, geometryCount, pGeometries, ppGeometries, scratchData ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureBuildGeometryInfoKHR; + const void * pNext = {}; + AccelerationStructureTypeKHR type = AccelerationStructureTypeKHR::eTopLevel; + BuildAccelerationStructureFlagsKHR flags = {}; + BuildAccelerationStructureModeKHR mode = BuildAccelerationStructureModeKHR::eBuild; + AccelerationStructureKHR srcAccelerationStructure = {}; + AccelerationStructureKHR dstAccelerationStructure = {}; + uint32_t geometryCount = {}; + const AccelerationStructureGeometryKHR * pGeometries = {}; + const AccelerationStructureGeometryKHR * const * ppGeometries = {}; + DeviceOrHostAddressKHR scratchData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureBuildGeometryInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureBuildGeometryInfoKHR; + }; + + // wrapper struct for struct VkAccelerationStructureBuildRangeInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildRangeInfoKHR.html + struct AccelerationStructureBuildRangeInfoKHR + { + using NativeType = VkAccelerationStructureBuildRangeInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureBuildRangeInfoKHR( uint32_t primitiveCount_ = {}, + uint32_t primitiveOffset_ = {}, + uint32_t firstVertex_ = {}, + uint32_t transformOffset_ = {} ) VULKAN_HPP_NOEXCEPT + : primitiveCount{ primitiveCount_ } + , primitiveOffset{ primitiveOffset_ } + , firstVertex{ firstVertex_ } + , transformOffset{ transformOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR AccelerationStructureBuildRangeInfoKHR( AccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureBuildRangeInfoKHR( VkAccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureBuildRangeInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureBuildRangeInfoKHR & operator=( AccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureBuildRangeInfoKHR & operator=( VkAccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setPrimitiveCount( uint32_t primitiveCount_ ) & VULKAN_HPP_NOEXCEPT + { + primitiveCount = primitiveCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setPrimitiveCount( uint32_t primitiveCount_ ) && VULKAN_HPP_NOEXCEPT + { + primitiveCount = primitiveCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setPrimitiveOffset( uint32_t primitiveOffset_ ) & VULKAN_HPP_NOEXCEPT + { + primitiveOffset = primitiveOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setPrimitiveOffset( uint32_t primitiveOffset_ ) && VULKAN_HPP_NOEXCEPT + { + primitiveOffset = primitiveOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setFirstVertex( uint32_t firstVertex_ ) & VULKAN_HPP_NOEXCEPT + { + firstVertex = firstVertex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setFirstVertex( uint32_t firstVertex_ ) && VULKAN_HPP_NOEXCEPT + { + firstVertex = firstVertex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setTransformOffset( uint32_t transformOffset_ ) & VULKAN_HPP_NOEXCEPT + { + transformOffset = transformOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setTransformOffset( uint32_t transformOffset_ ) && VULKAN_HPP_NOEXCEPT + { + transformOffset = transformOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureBuildRangeInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureBuildRangeInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureBuildRangeInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureBuildRangeInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( primitiveCount, primitiveOffset, firstVertex, transformOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureBuildRangeInfoKHR const & ) const = default; +#else + bool operator==( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( primitiveCount == rhs.primitiveCount ) && ( primitiveOffset == rhs.primitiveOffset ) && ( firstVertex == rhs.firstVertex ) && + ( transformOffset == rhs.transformOffset ); +# endif + } + + bool operator!=( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t primitiveCount = {}; + uint32_t primitiveOffset = {}; + uint32_t firstVertex = {}; + uint32_t transformOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureBuildRangeInfoKHR; + }; +#endif + + // wrapper struct for struct VkAccelerationStructureBuildSizesInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildSizesInfoKHR.html + struct AccelerationStructureBuildSizesInfoKHR + { + using NativeType = VkAccelerationStructureBuildSizesInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureBuildSizesInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureBuildSizesInfoKHR( DeviceSize accelerationStructureSize_ = {}, + DeviceSize updateScratchSize_ = {}, + DeviceSize buildScratchSize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , accelerationStructureSize{ accelerationStructureSize_ } + , updateScratchSize{ updateScratchSize_ } + , buildScratchSize{ buildScratchSize_ } + { + } + + VULKAN_HPP_CONSTEXPR AccelerationStructureBuildSizesInfoKHR( AccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureBuildSizesInfoKHR( VkAccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureBuildSizesInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureBuildSizesInfoKHR & operator=( AccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureBuildSizesInfoKHR & operator=( VkAccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkAccelerationStructureBuildSizesInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureBuildSizesInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureBuildSizesInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureBuildSizesInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructureSize, updateScratchSize, buildScratchSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureBuildSizesInfoKHR const & ) const = default; +#else + bool operator==( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureSize == rhs.accelerationStructureSize ) && + ( updateScratchSize == rhs.updateScratchSize ) && ( buildScratchSize == rhs.buildScratchSize ); +# endif + } + + bool operator!=( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureBuildSizesInfoKHR; + void * pNext = {}; + DeviceSize accelerationStructureSize = {}; + DeviceSize updateScratchSize = {}; + DeviceSize buildScratchSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureBuildSizesInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureBuildSizesInfoKHR; + }; + + // wrapper struct for struct VkAccelerationStructureCaptureDescriptorDataInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCaptureDescriptorDataInfoEXT.html + struct AccelerationStructureCaptureDescriptorDataInfoEXT + { + using NativeType = VkAccelerationStructureCaptureDescriptorDataInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureCaptureDescriptorDataInfoEXT( AccelerationStructureKHR accelerationStructure_ = {}, + AccelerationStructureNV accelerationStructureNV_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , accelerationStructure{ accelerationStructure_ } + , accelerationStructureNV{ accelerationStructureNV_ } + { + } + + VULKAN_HPP_CONSTEXPR + AccelerationStructureCaptureDescriptorDataInfoEXT( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureCaptureDescriptorDataInfoEXT( VkAccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureCaptureDescriptorDataInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureCaptureDescriptorDataInfoEXT & + operator=( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureCaptureDescriptorDataInfoEXT & operator=( VkAccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT & setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT && setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT & setAccelerationStructureNV( AccelerationStructureNV accelerationStructureNV_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructureNV = accelerationStructureNV_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT && + setAccelerationStructureNV( AccelerationStructureNV accelerationStructureNV_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructureNV = accelerationStructureNV_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructure, accelerationStructureNV ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureCaptureDescriptorDataInfoEXT const & ) const = default; +#else + bool operator==( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ) && + ( accelerationStructureNV == rhs.accelerationStructureNV ); +# endif + } + + bool operator!=( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT; + const void * pNext = {}; + AccelerationStructureKHR accelerationStructure = {}; + AccelerationStructureNV accelerationStructureNV = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureCaptureDescriptorDataInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureCaptureDescriptorDataInfoEXT; + }; + + // wrapper struct for struct VkAccelerationStructureCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateInfoKHR.html + struct AccelerationStructureCreateInfoKHR + { + using NativeType = VkAccelerationStructureCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoKHR( AccelerationStructureCreateFlagsKHR createFlags_ = {}, + Buffer buffer_ = {}, + DeviceSize offset_ = {}, + DeviceSize size_ = {}, + AccelerationStructureTypeKHR type_ = AccelerationStructureTypeKHR::eTopLevel, + DeviceAddress deviceAddress_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , createFlags{ createFlags_ } + , buffer{ buffer_ } + , offset{ offset_ } + , size{ size_ } + , type{ type_ } + , deviceAddress{ deviceAddress_ } + { + } + + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoKHR( AccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureCreateInfoKHR( VkAccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureCreateInfoKHR & operator=( AccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureCreateInfoKHR & operator=( VkAccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setCreateFlags( AccelerationStructureCreateFlagsKHR createFlags_ ) & VULKAN_HPP_NOEXCEPT + { + createFlags = createFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setCreateFlags( AccelerationStructureCreateFlagsKHR createFlags_ ) && VULKAN_HPP_NOEXCEPT + { + createFlags = createFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setType( AccelerationStructureTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setType( AccelerationStructureTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureCreateInfoKHR const & ) const = default; +#else + bool operator==( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && + ( size == rhs.size ) && ( type == rhs.type ) && ( deviceAddress == rhs.deviceAddress ); +# endif + } + + bool operator!=( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureCreateInfoKHR; + const void * pNext = {}; + AccelerationStructureCreateFlagsKHR createFlags = {}; + Buffer buffer = {}; + DeviceSize offset = {}; + DeviceSize size = {}; + AccelerationStructureTypeKHR type = AccelerationStructureTypeKHR::eTopLevel; + DeviceAddress deviceAddress = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureCreateInfoKHR; + }; + + // wrapper struct for struct VkGeometryTrianglesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryTrianglesNV.html + struct GeometryTrianglesNV + { + using NativeType = VkGeometryTrianglesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryTrianglesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( Buffer vertexData_ = {}, + DeviceSize vertexOffset_ = {}, + uint32_t vertexCount_ = {}, + DeviceSize vertexStride_ = {}, + Format vertexFormat_ = Format::eUndefined, + Buffer indexData_ = {}, + DeviceSize indexOffset_ = {}, + uint32_t indexCount_ = {}, + IndexType indexType_ = IndexType::eUint16, + Buffer transformData_ = {}, + DeviceSize transformOffset_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vertexData{ vertexData_ } + , vertexOffset{ vertexOffset_ } + , vertexCount{ vertexCount_ } + , vertexStride{ vertexStride_ } + , vertexFormat{ vertexFormat_ } + , indexData{ indexData_ } + , indexOffset{ indexOffset_ } + , indexCount{ indexCount_ } + , indexType{ indexType_ } + , transformData{ transformData_ } + , transformOffset{ transformOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryTrianglesNV( *reinterpret_cast( &rhs ) ) + { + } + + GeometryTrianglesNV & operator=( GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GeometryTrianglesNV & operator=( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexData( Buffer vertexData_ ) & VULKAN_HPP_NOEXCEPT + { + vertexData = vertexData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexData( Buffer vertexData_ ) && VULKAN_HPP_NOEXCEPT + { + vertexData = vertexData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexOffset( DeviceSize vertexOffset_ ) & VULKAN_HPP_NOEXCEPT + { + vertexOffset = vertexOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexOffset( DeviceSize vertexOffset_ ) && VULKAN_HPP_NOEXCEPT + { + vertexOffset = vertexOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT + { + vertexCount = vertexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT + { + vertexCount = vertexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT + { + vertexStride = vertexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT + { + vertexStride = vertexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT + { + vertexFormat = vertexFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT + { + vertexFormat = vertexFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexData( Buffer indexData_ ) & VULKAN_HPP_NOEXCEPT + { + indexData = indexData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexData( Buffer indexData_ ) && VULKAN_HPP_NOEXCEPT + { + indexData = indexData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexOffset( DeviceSize indexOffset_ ) & VULKAN_HPP_NOEXCEPT + { + indexOffset = indexOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexOffset( DeviceSize indexOffset_ ) && VULKAN_HPP_NOEXCEPT + { + indexOffset = indexOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexCount( uint32_t indexCount_ ) & VULKAN_HPP_NOEXCEPT + { + indexCount = indexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexCount( uint32_t indexCount_ ) && VULKAN_HPP_NOEXCEPT + { + indexCount = indexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setTransformData( Buffer transformData_ ) & VULKAN_HPP_NOEXCEPT + { + transformData = transformData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setTransformData( Buffer transformData_ ) && VULKAN_HPP_NOEXCEPT + { + transformData = transformData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setTransformOffset( DeviceSize transformOffset_ ) & VULKAN_HPP_NOEXCEPT + { + transformOffset = transformOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setTransformOffset( DeviceSize transformOffset_ ) && VULKAN_HPP_NOEXCEPT + { + transformOffset = transformOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGeometryTrianglesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeometryTrianglesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeometryTrianglesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGeometryTrianglesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + vertexData, + vertexOffset, + vertexCount, + vertexStride, + vertexFormat, + indexData, + indexOffset, + indexCount, + indexType, + transformData, + transformOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GeometryTrianglesNV const & ) const = default; +#else + bool operator==( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexData == rhs.vertexData ) && ( vertexOffset == rhs.vertexOffset ) && + ( vertexCount == rhs.vertexCount ) && ( vertexStride == rhs.vertexStride ) && ( vertexFormat == rhs.vertexFormat ) && + ( indexData == rhs.indexData ) && ( indexOffset == rhs.indexOffset ) && ( indexCount == rhs.indexCount ) && ( indexType == rhs.indexType ) && + ( transformData == rhs.transformData ) && ( transformOffset == rhs.transformOffset ); +# endif + } + + bool operator!=( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGeometryTrianglesNV; + const void * pNext = {}; + Buffer vertexData = {}; + DeviceSize vertexOffset = {}; + uint32_t vertexCount = {}; + DeviceSize vertexStride = {}; + Format vertexFormat = Format::eUndefined; + Buffer indexData = {}; + DeviceSize indexOffset = {}; + uint32_t indexCount = {}; + IndexType indexType = IndexType::eUint16; + Buffer transformData = {}; + DeviceSize transformOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GeometryTrianglesNV; + }; +#endif + + template <> + struct CppType + { + using Type = GeometryTrianglesNV; + }; + + // wrapper struct for struct VkGeometryAABBNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryAABBNV.html + struct GeometryAABBNV + { + using NativeType = VkGeometryAABBNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryAabbNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GeometryAABBNV( + Buffer aabbData_ = {}, uint32_t numAABBs_ = {}, uint32_t stride_ = {}, DeviceSize offset_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , aabbData{ aabbData_ } + , numAABBs{ numAABBs_ } + , stride{ stride_ } + , offset{ offset_ } + { + } + + VULKAN_HPP_CONSTEXPR GeometryAABBNV( GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GeometryAABBNV( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryAABBNV( *reinterpret_cast( &rhs ) ) {} + + GeometryAABBNV & operator=( GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GeometryAABBNV & operator=( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setAabbData( Buffer aabbData_ ) & VULKAN_HPP_NOEXCEPT + { + aabbData = aabbData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setAabbData( Buffer aabbData_ ) && VULKAN_HPP_NOEXCEPT + { + aabbData = aabbData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setNumAABBs( uint32_t numAABBs_ ) & VULKAN_HPP_NOEXCEPT + { + numAABBs = numAABBs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setNumAABBs( uint32_t numAABBs_ ) && VULKAN_HPP_NOEXCEPT + { + numAABBs = numAABBs_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGeometryAABBNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeometryAABBNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeometryAABBNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGeometryAABBNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, aabbData, numAABBs, stride, offset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GeometryAABBNV const & ) const = default; +#else + bool operator==( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aabbData == rhs.aabbData ) && ( numAABBs == rhs.numAABBs ) && ( stride == rhs.stride ) && + ( offset == rhs.offset ); +# endif + } + + bool operator!=( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGeometryAabbNV; + const void * pNext = {}; + Buffer aabbData = {}; + uint32_t numAABBs = {}; + uint32_t stride = {}; + DeviceSize offset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GeometryAABBNV; + }; +#endif + + template <> + struct CppType + { + using Type = GeometryAABBNV; + }; + + // wrapper struct for struct VkGeometryDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryDataNV.html + struct GeometryDataNV + { + using NativeType = VkGeometryDataNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GeometryDataNV( GeometryTrianglesNV triangles_ = {}, GeometryAABBNV aabbs_ = {} ) VULKAN_HPP_NOEXCEPT + : triangles{ triangles_ } + , aabbs{ aabbs_ } + { + } + + VULKAN_HPP_CONSTEXPR GeometryDataNV( GeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GeometryDataNV( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryDataNV( *reinterpret_cast( &rhs ) ) {} + + GeometryDataNV & operator=( GeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GeometryDataNV & operator=( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GeometryDataNV & setTriangles( GeometryTrianglesNV const & triangles_ ) & VULKAN_HPP_NOEXCEPT + { + triangles = triangles_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryDataNV && setTriangles( GeometryTrianglesNV const & triangles_ ) && VULKAN_HPP_NOEXCEPT + { + triangles = triangles_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryDataNV & setAabbs( GeometryAABBNV const & aabbs_ ) & VULKAN_HPP_NOEXCEPT + { + aabbs = aabbs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryDataNV && setAabbs( GeometryAABBNV const & aabbs_ ) && VULKAN_HPP_NOEXCEPT + { + aabbs = aabbs_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGeometryDataNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeometryDataNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeometryDataNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGeometryDataNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( triangles, aabbs ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GeometryDataNV const & ) const = default; +#else + bool operator==( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( triangles == rhs.triangles ) && ( aabbs == rhs.aabbs ); +# endif + } + + bool operator!=( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + GeometryTrianglesNV triangles = {}; + GeometryAABBNV aabbs = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GeometryDataNV; + }; +#endif + + // wrapper struct for struct VkGeometryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryNV.html + struct GeometryNV + { + using NativeType = VkGeometryNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GeometryNV( GeometryTypeKHR geometryType_ = GeometryTypeKHR::eTriangles, + GeometryDataNV geometry_ = {}, + GeometryFlagsKHR flags_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , geometryType{ geometryType_ } + , geometry{ geometry_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR GeometryNV( GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GeometryNV( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryNV( *reinterpret_cast( &rhs ) ) {} + + GeometryNV & operator=( GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GeometryNV & operator=( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GeometryNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryNV & setGeometryType( GeometryTypeKHR geometryType_ ) & VULKAN_HPP_NOEXCEPT + { + geometryType = geometryType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryNV && setGeometryType( GeometryTypeKHR geometryType_ ) && VULKAN_HPP_NOEXCEPT + { + geometryType = geometryType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryNV & setGeometry( GeometryDataNV const & geometry_ ) & VULKAN_HPP_NOEXCEPT + { + geometry = geometry_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryNV && setGeometry( GeometryDataNV const & geometry_ ) && VULKAN_HPP_NOEXCEPT + { + geometry = geometry_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeometryNV & setFlags( GeometryFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeometryNV && setFlags( GeometryFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGeometryNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeometryNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeometryNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGeometryNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, geometryType, geometry, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GeometryNV const & ) const = default; +#else + bool operator==( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( geometryType == rhs.geometryType ) && ( geometry == rhs.geometry ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGeometryNV; + const void * pNext = {}; + GeometryTypeKHR geometryType = GeometryTypeKHR::eTriangles; + GeometryDataNV geometry = {}; + GeometryFlagsKHR flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GeometryNV; + }; +#endif + + template <> + struct CppType + { + using Type = GeometryNV; + }; + + // wrapper struct for struct VkAccelerationStructureInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureInfoNV.html + struct AccelerationStructureInfoNV + { + using NativeType = VkAccelerationStructureInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( AccelerationStructureTypeNV type_ = {}, + BuildAccelerationStructureFlagsNV flags_ = {}, + uint32_t instanceCount_ = {}, + uint32_t geometryCount_ = {}, + const GeometryNV * pGeometries_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , flags{ flags_ } + , instanceCount{ instanceCount_ } + , geometryCount{ geometryCount_ } + , pGeometries{ pGeometries_ } + { + } + + VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureInfoNV( AccelerationStructureTypeNV type_, + BuildAccelerationStructureFlagsNV flags_, + uint32_t instanceCount_, + ArrayProxyNoTemporaries const & geometries_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , type( type_ ) + , flags( flags_ ) + , instanceCount( instanceCount_ ) + , geometryCount( static_cast( geometries_.size() ) ) + , pGeometries( geometries_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + AccelerationStructureInfoNV & operator=( AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureInfoNV & operator=( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setType( AccelerationStructureTypeNV type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setType( AccelerationStructureTypeNV type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setFlags( BuildAccelerationStructureFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setFlags( BuildAccelerationStructureFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setInstanceCount( uint32_t instanceCount_ ) & VULKAN_HPP_NOEXCEPT + { + instanceCount = instanceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setInstanceCount( uint32_t instanceCount_ ) && VULKAN_HPP_NOEXCEPT + { + instanceCount = instanceCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setGeometryCount( uint32_t geometryCount_ ) & VULKAN_HPP_NOEXCEPT + { + geometryCount = geometryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setGeometryCount( uint32_t geometryCount_ ) && VULKAN_HPP_NOEXCEPT + { + geometryCount = geometryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setPGeometries( const GeometryNV * pGeometries_ ) & VULKAN_HPP_NOEXCEPT + { + pGeometries = pGeometries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setPGeometries( const GeometryNV * pGeometries_ ) && VULKAN_HPP_NOEXCEPT + { + pGeometries = pGeometries_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureInfoNV & setGeometries( ArrayProxyNoTemporaries const & geometries_ ) VULKAN_HPP_NOEXCEPT + { + geometryCount = static_cast( geometries_.size() ); + pGeometries = geometries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, flags, instanceCount, geometryCount, pGeometries ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureInfoNV const & ) const = default; +#else + bool operator==( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( flags == rhs.flags ) && ( instanceCount == rhs.instanceCount ) && + ( geometryCount == rhs.geometryCount ) && ( pGeometries == rhs.pGeometries ); +# endif + } + + bool operator!=( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureInfoNV; + const void * pNext = {}; + AccelerationStructureTypeNV type = {}; + BuildAccelerationStructureFlagsNV flags = {}; + uint32_t instanceCount = {}; + uint32_t geometryCount = {}; + const GeometryNV * pGeometries = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureInfoNV; + }; + + // wrapper struct for struct VkAccelerationStructureCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateInfoNV.html + struct AccelerationStructureCreateInfoNV + { + using NativeType = VkAccelerationStructureCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( DeviceSize compactedSize_ = {}, + AccelerationStructureInfoNV info_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , compactedSize{ compactedSize_ } + , info{ info_ } + { + } + + VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureCreateInfoNV & operator=( AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureCreateInfoNV & operator=( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV & setCompactedSize( DeviceSize compactedSize_ ) & VULKAN_HPP_NOEXCEPT + { + compactedSize = compactedSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV && setCompactedSize( DeviceSize compactedSize_ ) && VULKAN_HPP_NOEXCEPT + { + compactedSize = compactedSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV & setInfo( AccelerationStructureInfoNV const & info_ ) & VULKAN_HPP_NOEXCEPT + { + info = info_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV && setInfo( AccelerationStructureInfoNV const & info_ ) && VULKAN_HPP_NOEXCEPT + { + info = info_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, compactedSize, info ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureCreateInfoNV const & ) const = default; +#else + bool operator==( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compactedSize == rhs.compactedSize ) && ( info == rhs.info ); +# endif + } + + bool operator!=( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureCreateInfoNV; + const void * pNext = {}; + DeviceSize compactedSize = {}; + AccelerationStructureInfoNV info = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureCreateInfoNV; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX.html + struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX + { + using NativeType = VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( DeviceOrHostAddressConstKHR compressedData_ = {}, + DeviceSize dataSize_ = {}, + uint32_t numTriangles_ = {}, + uint32_t numVertices_ = {}, + uint32_t maxPrimitiveIndex_ = {}, + uint32_t maxGeometryIndex_ = {}, + CompressedTriangleFormatAMDX format_ = CompressedTriangleFormatAMDX::eDgf1, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , compressedData{ compressedData_ } + , dataSize{ dataSize_ } + , numTriangles{ numTriangles_ } + , numVertices{ numVertices_ } + , maxPrimitiveIndex{ maxPrimitiveIndex_ } + , maxGeometryIndex{ maxGeometryIndex_ } + , format{ format_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( + *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & + operator=( AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & + operator=( VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & + setCompressedData( DeviceOrHostAddressConstKHR const & compressedData_ ) & + VULKAN_HPP_NOEXCEPT + { + compressedData = compressedData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && + setCompressedData( DeviceOrHostAddressConstKHR const & compressedData_ ) && + VULKAN_HPP_NOEXCEPT + { + compressedData = compressedData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setDataSize( DeviceSize dataSize_ ) & VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setDataSize( DeviceSize dataSize_ ) && VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setNumTriangles( uint32_t numTriangles_ ) & VULKAN_HPP_NOEXCEPT + { + numTriangles = numTriangles_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setNumTriangles( uint32_t numTriangles_ ) && VULKAN_HPP_NOEXCEPT + { + numTriangles = numTriangles_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setNumVertices( uint32_t numVertices_ ) & VULKAN_HPP_NOEXCEPT + { + numVertices = numVertices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setNumVertices( uint32_t numVertices_ ) && VULKAN_HPP_NOEXCEPT + { + numVertices = numVertices_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setMaxPrimitiveIndex( uint32_t maxPrimitiveIndex_ ) & + VULKAN_HPP_NOEXCEPT + { + maxPrimitiveIndex = maxPrimitiveIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setMaxPrimitiveIndex( uint32_t maxPrimitiveIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + maxPrimitiveIndex = maxPrimitiveIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setMaxGeometryIndex( uint32_t maxGeometryIndex_ ) & VULKAN_HPP_NOEXCEPT + { + maxGeometryIndex = maxGeometryIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setMaxGeometryIndex( uint32_t maxGeometryIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + maxGeometryIndex = maxGeometryIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setFormat( CompressedTriangleFormatAMDX format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setFormat( CompressedTriangleFormatAMDX format_ ) && + VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, compressedData, dataSize, numTriangles, numVertices, maxPrimitiveIndex, maxGeometryIndex, format ); + } +# endif + + public: + StructureType sType = StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX; + const void * pNext = {}; + DeviceOrHostAddressConstKHR compressedData = {}; + DeviceSize dataSize = {}; + uint32_t numTriangles = {}; + uint32_t numVertices = {}; + uint32_t maxPrimitiveIndex = {}; + uint32_t maxGeometryIndex = {}; + CompressedTriangleFormatAMDX format = CompressedTriangleFormatAMDX::eDgf1; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureDenseGeometryFormatTrianglesDataAMDX; + }; +# endif + + template <> + struct CppType + { + using Type = AccelerationStructureDenseGeometryFormatTrianglesDataAMDX; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkAccelerationStructureDeviceAddressInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html + struct AccelerationStructureDeviceAddressInfoKHR + { + using NativeType = VkAccelerationStructureDeviceAddressInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureDeviceAddressInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureDeviceAddressInfoKHR( AccelerationStructureKHR accelerationStructure_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , accelerationStructure{ accelerationStructure_ } + { + } + + VULKAN_HPP_CONSTEXPR AccelerationStructureDeviceAddressInfoKHR( AccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureDeviceAddressInfoKHR( VkAccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureDeviceAddressInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureDeviceAddressInfoKHR & operator=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureDeviceAddressInfoKHR & operator=( VkAccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR & setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR && setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureDeviceAddressInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureDeviceAddressInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureDeviceAddressInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureDeviceAddressInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructure ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureDeviceAddressInfoKHR const & ) const = default; +#else + bool operator==( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ); +# endif + } + + bool operator!=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureDeviceAddressInfoKHR; + const void * pNext = {}; + AccelerationStructureKHR accelerationStructure = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureDeviceAddressInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureDeviceAddressInfoKHR; + }; + + // wrapper struct for struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryLinearSweptSpheresDataNV.html + struct AccelerationStructureGeometryLinearSweptSpheresDataNV + { + using NativeType = VkAccelerationStructureGeometryLinearSweptSpheresDataNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryLinearSweptSpheresDataNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + AccelerationStructureGeometryLinearSweptSpheresDataNV( Format vertexFormat_ = Format::eUndefined, + DeviceOrHostAddressConstKHR vertexData_ = {}, + DeviceSize vertexStride_ = {}, + Format radiusFormat_ = Format::eUndefined, + DeviceOrHostAddressConstKHR radiusData_ = {}, + DeviceSize radiusStride_ = {}, + IndexType indexType_ = IndexType::eUint16, + DeviceOrHostAddressConstKHR indexData_ = {}, + DeviceSize indexStride_ = {}, + RayTracingLssIndexingModeNV indexingMode_ = RayTracingLssIndexingModeNV::eList, + RayTracingLssPrimitiveEndCapsModeNV endCapsMode_ = RayTracingLssPrimitiveEndCapsModeNV::eNone, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vertexFormat{ vertexFormat_ } + , vertexData{ vertexData_ } + , vertexStride{ vertexStride_ } + , radiusFormat{ radiusFormat_ } + , radiusData{ radiusData_ } + , radiusStride{ radiusStride_ } + , indexType{ indexType_ } + , indexData{ indexData_ } + , indexStride{ indexStride_ } + , indexingMode{ indexingMode_ } + , endCapsMode{ endCapsMode_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + AccelerationStructureGeometryLinearSweptSpheresDataNV( AccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureGeometryLinearSweptSpheresDataNV( VkAccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureGeometryLinearSweptSpheresDataNV( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureGeometryLinearSweptSpheresDataNV & + operator=( AccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureGeometryLinearSweptSpheresDataNV & operator=( VkAccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT + { + vertexFormat = vertexFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT + { + vertexFormat = vertexFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexData = vertexData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexData = vertexData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT + { + vertexStride = vertexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT + { + vertexStride = vertexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setRadiusFormat( Format radiusFormat_ ) & VULKAN_HPP_NOEXCEPT + { + radiusFormat = radiusFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setRadiusFormat( Format radiusFormat_ ) && VULKAN_HPP_NOEXCEPT + { + radiusFormat = radiusFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) & + VULKAN_HPP_NOEXCEPT + { + radiusData = radiusData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) && + VULKAN_HPP_NOEXCEPT + { + radiusData = radiusData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setRadiusStride( DeviceSize radiusStride_ ) & VULKAN_HPP_NOEXCEPT + { + radiusStride = radiusStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setRadiusStride( DeviceSize radiusStride_ ) && VULKAN_HPP_NOEXCEPT + { + radiusStride = radiusStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) & + VULKAN_HPP_NOEXCEPT + { + indexData = indexData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) && + VULKAN_HPP_NOEXCEPT + { + indexData = indexData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT + { + indexStride = indexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT + { + indexStride = indexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexingMode( RayTracingLssIndexingModeNV indexingMode_ ) & + VULKAN_HPP_NOEXCEPT + { + indexingMode = indexingMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexingMode( RayTracingLssIndexingModeNV indexingMode_ ) && + VULKAN_HPP_NOEXCEPT + { + indexingMode = indexingMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setEndCapsMode( RayTracingLssPrimitiveEndCapsModeNV endCapsMode_ ) & + VULKAN_HPP_NOEXCEPT + { + endCapsMode = endCapsMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setEndCapsMode( RayTracingLssPrimitiveEndCapsModeNV endCapsMode_ ) && + VULKAN_HPP_NOEXCEPT + { + endCapsMode = endCapsMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + vertexFormat, + vertexData, + vertexStride, + radiusFormat, + radiusData, + radiusStride, + indexType, + indexData, + indexStride, + indexingMode, + endCapsMode ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureGeometryLinearSweptSpheresDataNV; + const void * pNext = {}; + Format vertexFormat = Format::eUndefined; + DeviceOrHostAddressConstKHR vertexData = {}; + DeviceSize vertexStride = {}; + Format radiusFormat = Format::eUndefined; + DeviceOrHostAddressConstKHR radiusData = {}; + DeviceSize radiusStride = {}; + IndexType indexType = IndexType::eUint16; + DeviceOrHostAddressConstKHR indexData = {}; + DeviceSize indexStride = {}; + RayTracingLssIndexingModeNV indexingMode = RayTracingLssIndexingModeNV::eList; + RayTracingLssPrimitiveEndCapsModeNV endCapsMode = RayTracingLssPrimitiveEndCapsModeNV::eNone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureGeometryLinearSweptSpheresDataNV; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureGeometryLinearSweptSpheresDataNV; + }; + + // wrapper struct for struct VkAccelerationStructureGeometryMotionTrianglesDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryMotionTrianglesDataNV.html + struct AccelerationStructureGeometryMotionTrianglesDataNV + { + using NativeType = VkAccelerationStructureGeometryMotionTrianglesDataNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV( DeviceOrHostAddressConstKHR vertexData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vertexData{ vertexData_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + AccelerationStructureGeometryMotionTrianglesDataNV( AccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureGeometryMotionTrianglesDataNV( VkAccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureGeometryMotionTrianglesDataNV( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureGeometryMotionTrianglesDataNV & + operator=( AccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureGeometryMotionTrianglesDataNV & operator=( VkAccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexData = vertexData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexData = vertexData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureGeometryMotionTrianglesDataNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryMotionTrianglesDataNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryMotionTrianglesDataNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometryMotionTrianglesDataNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexData ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV; + const void * pNext = {}; + DeviceOrHostAddressConstKHR vertexData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureGeometryMotionTrianglesDataNV; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureGeometryMotionTrianglesDataNV; + }; + + // wrapper struct for struct VkAccelerationStructureGeometrySpheresDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometrySpheresDataNV.html + struct AccelerationStructureGeometrySpheresDataNV + { + using NativeType = VkAccelerationStructureGeometrySpheresDataNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometrySpheresDataNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV( Format vertexFormat_ = Format::eUndefined, + DeviceOrHostAddressConstKHR vertexData_ = {}, + DeviceSize vertexStride_ = {}, + Format radiusFormat_ = Format::eUndefined, + DeviceOrHostAddressConstKHR radiusData_ = {}, + DeviceSize radiusStride_ = {}, + IndexType indexType_ = IndexType::eUint16, + DeviceOrHostAddressConstKHR indexData_ = {}, + DeviceSize indexStride_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vertexFormat{ vertexFormat_ } + , vertexData{ vertexData_ } + , vertexStride{ vertexStride_ } + , radiusFormat{ radiusFormat_ } + , radiusData{ radiusData_ } + , radiusStride{ radiusStride_ } + , indexType{ indexType_ } + , indexData{ indexData_ } + , indexStride{ indexStride_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV( AccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureGeometrySpheresDataNV( VkAccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureGeometrySpheresDataNV( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureGeometrySpheresDataNV & operator=( AccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureGeometrySpheresDataNV & operator=( VkAccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT + { + vertexFormat = vertexFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT + { + vertexFormat = vertexFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) & VULKAN_HPP_NOEXCEPT + { + vertexData = vertexData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexData = vertexData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT + { + vertexStride = vertexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT + { + vertexStride = vertexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setRadiusFormat( Format radiusFormat_ ) & VULKAN_HPP_NOEXCEPT + { + radiusFormat = radiusFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setRadiusFormat( Format radiusFormat_ ) && VULKAN_HPP_NOEXCEPT + { + radiusFormat = radiusFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) & VULKAN_HPP_NOEXCEPT + { + radiusData = radiusData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) && + VULKAN_HPP_NOEXCEPT + { + radiusData = radiusData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setRadiusStride( DeviceSize radiusStride_ ) & VULKAN_HPP_NOEXCEPT + { + radiusStride = radiusStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setRadiusStride( DeviceSize radiusStride_ ) && VULKAN_HPP_NOEXCEPT + { + radiusStride = radiusStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) & VULKAN_HPP_NOEXCEPT + { + indexData = indexData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) && VULKAN_HPP_NOEXCEPT + { + indexData = indexData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT + { + indexStride = indexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT + { + indexStride = indexStride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureGeometrySpheresDataNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometrySpheresDataNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometrySpheresDataNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureGeometrySpheresDataNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexFormat, vertexData, vertexStride, radiusFormat, radiusData, radiusStride, indexType, indexData, indexStride ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureGeometrySpheresDataNV; + const void * pNext = {}; + Format vertexFormat = Format::eUndefined; + DeviceOrHostAddressConstKHR vertexData = {}; + DeviceSize vertexStride = {}; + Format radiusFormat = Format::eUndefined; + DeviceOrHostAddressConstKHR radiusData = {}; + DeviceSize radiusStride = {}; + IndexType indexType = IndexType::eUint16; + DeviceOrHostAddressConstKHR indexData = {}; + DeviceSize indexStride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureGeometrySpheresDataNV; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureGeometrySpheresDataNV; + }; + + // wrapper struct for struct VkTransformMatrixKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTransformMatrixKHR.html + struct TransformMatrixKHR + { + using NativeType = VkTransformMatrixKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR( std::array, 3> const & matrix_ = {} ) VULKAN_HPP_NOEXCEPT : matrix{ matrix_ } {} + + VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR( TransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TransformMatrixKHR( VkTransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT : TransformMatrixKHR( *reinterpret_cast( &rhs ) ) {} + + TransformMatrixKHR & operator=( TransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TransformMatrixKHR & operator=( VkTransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR & setMatrix( std::array, 3> matrix_ ) & VULKAN_HPP_NOEXCEPT + { + matrix = matrix_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR && setMatrix( std::array, 3> matrix_ ) && VULKAN_HPP_NOEXCEPT + { + matrix = matrix_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTransformMatrixKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTransformMatrixKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTransformMatrixKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTransformMatrixKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( matrix ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TransformMatrixKHR const & ) const = default; +#else + bool operator==( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( matrix == rhs.matrix ); +# endif + } + + bool operator!=( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ArrayWrapper2D matrix = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TransformMatrixKHR; + }; +#endif + using TransformMatrixNV = TransformMatrixKHR; + + // wrapper struct for struct VkAccelerationStructureInstanceKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureInstanceKHR.html + struct AccelerationStructureInstanceKHR + { + using NativeType = VkAccelerationStructureInstanceKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR( TransformMatrixKHR transform_ = {}, + uint32_t instanceCustomIndex_ = {}, + uint32_t mask_ = {}, + uint32_t instanceShaderBindingTableRecordOffset_ = {}, + GeometryInstanceFlagsKHR flags_ = {}, + uint64_t accelerationStructureReference_ = {} ) VULKAN_HPP_NOEXCEPT + : transform{ transform_ } + , instanceCustomIndex{ instanceCustomIndex_ } + , mask{ mask_ } + , instanceShaderBindingTableRecordOffset{ instanceShaderBindingTableRecordOffset_ } + , flags{ flags_ } + , accelerationStructureReference{ accelerationStructureReference_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR( AccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureInstanceKHR( VkAccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureInstanceKHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureInstanceKHR & operator=( AccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureInstanceKHR & operator=( VkAccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setTransform( TransformMatrixKHR const & transform_ ) & VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setTransform( TransformMatrixKHR const & transform_ ) && VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) & VULKAN_HPP_NOEXCEPT + { + instanceCustomIndex = instanceCustomIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) && VULKAN_HPP_NOEXCEPT + { + instanceCustomIndex = instanceCustomIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setMask( uint32_t mask_ ) & VULKAN_HPP_NOEXCEPT + { + mask = mask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setMask( uint32_t mask_ ) && VULKAN_HPP_NOEXCEPT + { + mask = mask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) & + VULKAN_HPP_NOEXCEPT + { + instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) && + VULKAN_HPP_NOEXCEPT + { + instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; + return std::move( *this ); + } + + AccelerationStructureInstanceKHR & setFlags( GeometryInstanceFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = *reinterpret_cast( &flags_ ); + return *this; + } + + AccelerationStructureInstanceKHR && setFlags( GeometryInstanceFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = *reinterpret_cast( &flags_ ); + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructureReference = accelerationStructureReference_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructureReference = accelerationStructureReference_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureInstanceKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureInstanceKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureInstanceKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureInstanceKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( transform, instanceCustomIndex, mask, instanceShaderBindingTableRecordOffset, flags, accelerationStructureReference ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureInstanceKHR const & ) const = default; +#else + bool operator==( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( transform == rhs.transform ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) && + ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && ( flags == rhs.flags ) && + ( accelerationStructureReference == rhs.accelerationStructureReference ); +# endif + } + + bool operator!=( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + TransformMatrixKHR transform = {}; + uint32_t instanceCustomIndex : 24; + uint32_t mask : 8; + uint32_t instanceShaderBindingTableRecordOffset : 24; + VkGeometryInstanceFlagsKHR flags : 8; + uint64_t accelerationStructureReference = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureInstanceKHR; + }; +#endif + using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR; + + // wrapper struct for struct VkAccelerationStructureMatrixMotionInstanceNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMatrixMotionInstanceNV.html + struct AccelerationStructureMatrixMotionInstanceNV + { + using NativeType = VkAccelerationStructureMatrixMotionInstanceNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV( TransformMatrixKHR transformT0_ = {}, + TransformMatrixKHR transformT1_ = {}, + uint32_t instanceCustomIndex_ = {}, + uint32_t mask_ = {}, + uint32_t instanceShaderBindingTableRecordOffset_ = {}, + GeometryInstanceFlagsKHR flags_ = {}, + uint64_t accelerationStructureReference_ = {} ) VULKAN_HPP_NOEXCEPT + : transformT0{ transformT0_ } + , transformT1{ transformT1_ } + , instanceCustomIndex{ instanceCustomIndex_ } + , mask{ mask_ } + , instanceShaderBindingTableRecordOffset{ instanceShaderBindingTableRecordOffset_ } + , flags{ flags_ } + , accelerationStructureReference{ accelerationStructureReference_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + AccelerationStructureMatrixMotionInstanceNV( AccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureMatrixMotionInstanceNV( VkAccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureMatrixMotionInstanceNV( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureMatrixMotionInstanceNV & operator=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureMatrixMotionInstanceNV & operator=( VkAccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setTransformT0( TransformMatrixKHR const & transformT0_ ) & VULKAN_HPP_NOEXCEPT + { + transformT0 = transformT0_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setTransformT0( TransformMatrixKHR const & transformT0_ ) && VULKAN_HPP_NOEXCEPT + { + transformT0 = transformT0_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setTransformT1( TransformMatrixKHR const & transformT1_ ) & VULKAN_HPP_NOEXCEPT + { + transformT1 = transformT1_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setTransformT1( TransformMatrixKHR const & transformT1_ ) && VULKAN_HPP_NOEXCEPT + { + transformT1 = transformT1_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) & VULKAN_HPP_NOEXCEPT + { + instanceCustomIndex = instanceCustomIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) && VULKAN_HPP_NOEXCEPT + { + instanceCustomIndex = instanceCustomIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setMask( uint32_t mask_ ) & VULKAN_HPP_NOEXCEPT + { + mask = mask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setMask( uint32_t mask_ ) && VULKAN_HPP_NOEXCEPT + { + mask = mask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & + setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) & + VULKAN_HPP_NOEXCEPT + { + instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && + setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) && + VULKAN_HPP_NOEXCEPT + { + instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; + return std::move( *this ); + } + + AccelerationStructureMatrixMotionInstanceNV & setFlags( GeometryInstanceFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = *reinterpret_cast( &flags_ ); + return *this; + } + + AccelerationStructureMatrixMotionInstanceNV && setFlags( GeometryInstanceFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = *reinterpret_cast( &flags_ ); + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructureReference = accelerationStructureReference_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructureReference = accelerationStructureReference_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureMatrixMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureMatrixMotionInstanceNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureMatrixMotionInstanceNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureMatrixMotionInstanceNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( transformT0, transformT1, instanceCustomIndex, mask, instanceShaderBindingTableRecordOffset, flags, accelerationStructureReference ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureMatrixMotionInstanceNV const & ) const = default; +#else + bool operator==( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) && + ( mask == rhs.mask ) && ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && ( flags == rhs.flags ) && + ( accelerationStructureReference == rhs.accelerationStructureReference ); +# endif + } + + bool operator!=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + TransformMatrixKHR transformT0 = {}; + TransformMatrixKHR transformT1 = {}; + uint32_t instanceCustomIndex : 24; + uint32_t mask : 8; + uint32_t instanceShaderBindingTableRecordOffset : 24; + VkGeometryInstanceFlagsKHR flags : 8; + uint64_t accelerationStructureReference = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureMatrixMotionInstanceNV; + }; +#endif + + // wrapper struct for struct VkAccelerationStructureMemoryRequirementsInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html + struct AccelerationStructureMemoryRequirementsInfoNV + { + using NativeType = VkAccelerationStructureMemoryRequirementsInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( + AccelerationStructureMemoryRequirementsTypeNV type_ = AccelerationStructureMemoryRequirementsTypeNV::eObject, + AccelerationStructureNV accelerationStructure_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , accelerationStructure{ accelerationStructure_ } + { + } + + VULKAN_HPP_CONSTEXPR + AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureMemoryRequirementsInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureMemoryRequirementsInfoNV & operator=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureMemoryRequirementsInfoNV & operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV & setType( AccelerationStructureMemoryRequirementsTypeNV type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV && setType( AccelerationStructureMemoryRequirementsTypeNV type_ ) && + VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV && setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureMemoryRequirementsInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureMemoryRequirementsInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, accelerationStructure ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureMemoryRequirementsInfoNV const & ) const = default; +#else + bool operator==( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( accelerationStructure == rhs.accelerationStructure ); +# endif + } + + bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; + const void * pNext = {}; + AccelerationStructureMemoryRequirementsTypeNV type = AccelerationStructureMemoryRequirementsTypeNV::eObject; + AccelerationStructureNV accelerationStructure = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureMemoryRequirementsInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureMemoryRequirementsInfoNV; + }; + + // wrapper struct for struct VkAccelerationStructureMotionInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInfoNV.html + struct AccelerationStructureMotionInfoNV + { + using NativeType = VkAccelerationStructureMotionInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureMotionInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureMotionInfoNV( uint32_t maxInstances_ = {}, + AccelerationStructureMotionInfoFlagsNV flags_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxInstances{ maxInstances_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR AccelerationStructureMotionInfoNV( AccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureMotionInfoNV( VkAccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureMotionInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureMotionInfoNV & operator=( AccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureMotionInfoNV & operator=( VkAccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV & setMaxInstances( uint32_t maxInstances_ ) & VULKAN_HPP_NOEXCEPT + { + maxInstances = maxInstances_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV && setMaxInstances( uint32_t maxInstances_ ) && VULKAN_HPP_NOEXCEPT + { + maxInstances = maxInstances_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV & setFlags( AccelerationStructureMotionInfoFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV && setFlags( AccelerationStructureMotionInfoFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureMotionInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureMotionInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureMotionInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureMotionInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxInstances, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureMotionInfoNV const & ) const = default; +#else + bool operator==( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInstances == rhs.maxInstances ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureMotionInfoNV; + const void * pNext = {}; + uint32_t maxInstances = {}; + AccelerationStructureMotionInfoFlagsNV flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureMotionInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureMotionInfoNV; + }; + + // wrapper struct for struct VkSRTDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSRTDataNV.html + struct SRTDataNV + { + using NativeType = VkSRTDataNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SRTDataNV( float sx_ = {}, + float a_ = {}, + float b_ = {}, + float pvx_ = {}, + float sy_ = {}, + float c_ = {}, + float pvy_ = {}, + float sz_ = {}, + float pvz_ = {}, + float qx_ = {}, + float qy_ = {}, + float qz_ = {}, + float qw_ = {}, + float tx_ = {}, + float ty_ = {}, + float tz_ = {} ) VULKAN_HPP_NOEXCEPT + : sx{ sx_ } + , a{ a_ } + , b{ b_ } + , pvx{ pvx_ } + , sy{ sy_ } + , c{ c_ } + , pvy{ pvy_ } + , sz{ sz_ } + , pvz{ pvz_ } + , qx{ qx_ } + , qy{ qy_ } + , qz{ qz_ } + , qw{ qw_ } + , tx{ tx_ } + , ty{ ty_ } + , tz{ tz_ } + { + } + + VULKAN_HPP_CONSTEXPR SRTDataNV( SRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SRTDataNV( VkSRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT : SRTDataNV( *reinterpret_cast( &rhs ) ) {} + + SRTDataNV & operator=( SRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SRTDataNV & operator=( VkSRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setSx( float sx_ ) & VULKAN_HPP_NOEXCEPT + { + sx = sx_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setSx( float sx_ ) && VULKAN_HPP_NOEXCEPT + { + sx = sx_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setA( float a_ ) & VULKAN_HPP_NOEXCEPT + { + a = a_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setA( float a_ ) && VULKAN_HPP_NOEXCEPT + { + a = a_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setB( float b_ ) & VULKAN_HPP_NOEXCEPT + { + b = b_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setB( float b_ ) && VULKAN_HPP_NOEXCEPT + { + b = b_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setPvx( float pvx_ ) & VULKAN_HPP_NOEXCEPT + { + pvx = pvx_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setPvx( float pvx_ ) && VULKAN_HPP_NOEXCEPT + { + pvx = pvx_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setSy( float sy_ ) & VULKAN_HPP_NOEXCEPT + { + sy = sy_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setSy( float sy_ ) && VULKAN_HPP_NOEXCEPT + { + sy = sy_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setC( float c_ ) & VULKAN_HPP_NOEXCEPT + { + c = c_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setC( float c_ ) && VULKAN_HPP_NOEXCEPT + { + c = c_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setPvy( float pvy_ ) & VULKAN_HPP_NOEXCEPT + { + pvy = pvy_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setPvy( float pvy_ ) && VULKAN_HPP_NOEXCEPT + { + pvy = pvy_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setSz( float sz_ ) & VULKAN_HPP_NOEXCEPT + { + sz = sz_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setSz( float sz_ ) && VULKAN_HPP_NOEXCEPT + { + sz = sz_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setPvz( float pvz_ ) & VULKAN_HPP_NOEXCEPT + { + pvz = pvz_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setPvz( float pvz_ ) && VULKAN_HPP_NOEXCEPT + { + pvz = pvz_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQx( float qx_ ) & VULKAN_HPP_NOEXCEPT + { + qx = qx_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQx( float qx_ ) && VULKAN_HPP_NOEXCEPT + { + qx = qx_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQy( float qy_ ) & VULKAN_HPP_NOEXCEPT + { + qy = qy_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQy( float qy_ ) && VULKAN_HPP_NOEXCEPT + { + qy = qy_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQz( float qz_ ) & VULKAN_HPP_NOEXCEPT + { + qz = qz_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQz( float qz_ ) && VULKAN_HPP_NOEXCEPT + { + qz = qz_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQw( float qw_ ) & VULKAN_HPP_NOEXCEPT + { + qw = qw_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQw( float qw_ ) && VULKAN_HPP_NOEXCEPT + { + qw = qw_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setTx( float tx_ ) & VULKAN_HPP_NOEXCEPT + { + tx = tx_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setTx( float tx_ ) && VULKAN_HPP_NOEXCEPT + { + tx = tx_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setTy( float ty_ ) & VULKAN_HPP_NOEXCEPT + { + ty = ty_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setTy( float ty_ ) && VULKAN_HPP_NOEXCEPT + { + ty = ty_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setTz( float tz_ ) & VULKAN_HPP_NOEXCEPT + { + tz = tz_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setTz( float tz_ ) && VULKAN_HPP_NOEXCEPT + { + tz = tz_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSRTDataNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSRTDataNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSRTDataNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSRTDataNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sx, a, b, pvx, sy, c, pvy, sz, pvz, qx, qy, qz, qw, tx, ty, tz ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SRTDataNV const & ) const = default; +#else + bool operator==( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sx == rhs.sx ) && ( a == rhs.a ) && ( b == rhs.b ) && ( pvx == rhs.pvx ) && ( sy == rhs.sy ) && ( c == rhs.c ) && ( pvy == rhs.pvy ) && + ( sz == rhs.sz ) && ( pvz == rhs.pvz ) && ( qx == rhs.qx ) && ( qy == rhs.qy ) && ( qz == rhs.qz ) && ( qw == rhs.qw ) && ( tx == rhs.tx ) && + ( ty == rhs.ty ) && ( tz == rhs.tz ); +# endif + } + + bool operator!=( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + float sx = {}; + float a = {}; + float b = {}; + float pvx = {}; + float sy = {}; + float c = {}; + float pvy = {}; + float sz = {}; + float pvz = {}; + float qx = {}; + float qy = {}; + float qz = {}; + float qw = {}; + float tx = {}; + float ty = {}; + float tz = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SRTDataNV; + }; +#endif + + // wrapper struct for struct VkAccelerationStructureSRTMotionInstanceNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureSRTMotionInstanceNV.html + struct AccelerationStructureSRTMotionInstanceNV + { + using NativeType = VkAccelerationStructureSRTMotionInstanceNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureSRTMotionInstanceNV( SRTDataNV transformT0_ = {}, + SRTDataNV transformT1_ = {}, + uint32_t instanceCustomIndex_ = {}, + uint32_t mask_ = {}, + uint32_t instanceShaderBindingTableRecordOffset_ = {}, + GeometryInstanceFlagsKHR flags_ = {}, + uint64_t accelerationStructureReference_ = {} ) VULKAN_HPP_NOEXCEPT + : transformT0{ transformT0_ } + , transformT1{ transformT1_ } + , instanceCustomIndex{ instanceCustomIndex_ } + , mask{ mask_ } + , instanceShaderBindingTableRecordOffset{ instanceShaderBindingTableRecordOffset_ } + , flags{ flags_ } + , accelerationStructureReference{ accelerationStructureReference_ } + { + } + + VULKAN_HPP_CONSTEXPR AccelerationStructureSRTMotionInstanceNV( AccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureSRTMotionInstanceNV( VkAccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureSRTMotionInstanceNV( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureSRTMotionInstanceNV & operator=( AccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureSRTMotionInstanceNV & operator=( VkAccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setTransformT0( SRTDataNV const & transformT0_ ) & VULKAN_HPP_NOEXCEPT + { + transformT0 = transformT0_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setTransformT0( SRTDataNV const & transformT0_ ) && VULKAN_HPP_NOEXCEPT + { + transformT0 = transformT0_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setTransformT1( SRTDataNV const & transformT1_ ) & VULKAN_HPP_NOEXCEPT + { + transformT1 = transformT1_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setTransformT1( SRTDataNV const & transformT1_ ) && VULKAN_HPP_NOEXCEPT + { + transformT1 = transformT1_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) & VULKAN_HPP_NOEXCEPT + { + instanceCustomIndex = instanceCustomIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) && VULKAN_HPP_NOEXCEPT + { + instanceCustomIndex = instanceCustomIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setMask( uint32_t mask_ ) & VULKAN_HPP_NOEXCEPT + { + mask = mask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setMask( uint32_t mask_ ) && VULKAN_HPP_NOEXCEPT + { + mask = mask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & + setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) & + VULKAN_HPP_NOEXCEPT + { + instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && + setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) && + VULKAN_HPP_NOEXCEPT + { + instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; + return std::move( *this ); + } + + AccelerationStructureSRTMotionInstanceNV & setFlags( GeometryInstanceFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = *reinterpret_cast( &flags_ ); + return *this; + } + + AccelerationStructureSRTMotionInstanceNV && setFlags( GeometryInstanceFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = *reinterpret_cast( &flags_ ); + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructureReference = accelerationStructureReference_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructureReference = accelerationStructureReference_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureSRTMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureSRTMotionInstanceNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureSRTMotionInstanceNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureSRTMotionInstanceNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( transformT0, transformT1, instanceCustomIndex, mask, instanceShaderBindingTableRecordOffset, flags, accelerationStructureReference ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureSRTMotionInstanceNV const & ) const = default; +#else + bool operator==( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) && + ( mask == rhs.mask ) && ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && ( flags == rhs.flags ) && + ( accelerationStructureReference == rhs.accelerationStructureReference ); +# endif + } + + bool operator!=( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + SRTDataNV transformT0 = {}; + SRTDataNV transformT1 = {}; + uint32_t instanceCustomIndex : 24; + uint32_t mask : 8; + uint32_t instanceShaderBindingTableRecordOffset : 24; + VkGeometryInstanceFlagsKHR flags : 8; + uint64_t accelerationStructureReference = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureSRTMotionInstanceNV; + }; +#endif + + union AccelerationStructureMotionInstanceDataNV + { + using NativeType = VkAccelerationStructureMotionInstanceDataNV; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV( AccelerationStructureInstanceKHR staticInstance_ = {} ) + : staticInstance( staticInstance_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV( AccelerationStructureMatrixMotionInstanceNV matrixMotionInstance_ ) + : matrixMotionInstance( matrixMotionInstance_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV( AccelerationStructureSRTMotionInstanceNV srtMotionInstance_ ) + : srtMotionInstance( srtMotionInstance_ ) + { + } +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV & setStaticInstance( AccelerationStructureInstanceKHR const & staticInstance_ ) & + VULKAN_HPP_NOEXCEPT + { + staticInstance = staticInstance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV && setStaticInstance( AccelerationStructureInstanceKHR const & staticInstance_ ) && + VULKAN_HPP_NOEXCEPT + { + staticInstance = staticInstance_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV & + setMatrixMotionInstance( AccelerationStructureMatrixMotionInstanceNV const & matrixMotionInstance_ ) & + VULKAN_HPP_NOEXCEPT + { + matrixMotionInstance = matrixMotionInstance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV && + setMatrixMotionInstance( AccelerationStructureMatrixMotionInstanceNV const & matrixMotionInstance_ ) && + VULKAN_HPP_NOEXCEPT + { + matrixMotionInstance = matrixMotionInstance_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV & + setSrtMotionInstance( AccelerationStructureSRTMotionInstanceNV const & srtMotionInstance_ ) & + VULKAN_HPP_NOEXCEPT + { + srtMotionInstance = srtMotionInstance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV && + setSrtMotionInstance( AccelerationStructureSRTMotionInstanceNV const & srtMotionInstance_ ) && + VULKAN_HPP_NOEXCEPT + { + srtMotionInstance = srtMotionInstance_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureMotionInstanceDataNV const &() const + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureMotionInstanceDataNV &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + AccelerationStructureInstanceKHR staticInstance; + AccelerationStructureMatrixMotionInstanceNV matrixMotionInstance; + AccelerationStructureSRTMotionInstanceNV srtMotionInstance; +#else + VkAccelerationStructureInstanceKHR staticInstance; + VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance; + VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureMotionInstanceDataNV; + }; +#endif + + // wrapper struct for struct VkAccelerationStructureMotionInstanceNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceNV.html + struct AccelerationStructureMotionInstanceNV + { + using NativeType = VkAccelerationStructureMotionInstanceNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + AccelerationStructureMotionInstanceNV( AccelerationStructureMotionInstanceTypeNV type_ = AccelerationStructureMotionInstanceTypeNV::eStatic, + AccelerationStructureMotionInstanceFlagsNV flags_ = {}, + AccelerationStructureMotionInstanceDataNV data_ = {} ) VULKAN_HPP_NOEXCEPT + : type{ type_ } + , flags{ flags_ } + , data{ data_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV( AccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureMotionInstanceNV( VkAccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureMotionInstanceNV( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureMotionInstanceNV & operator=( AccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureMotionInstanceNV & operator=( VkAccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV & setType( AccelerationStructureMotionInstanceTypeNV type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV && setType( AccelerationStructureMotionInstanceTypeNV type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV & setFlags( AccelerationStructureMotionInstanceFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV && setFlags( AccelerationStructureMotionInstanceFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV & setData( AccelerationStructureMotionInstanceDataNV const & data_ ) & VULKAN_HPP_NOEXCEPT + { + data = data_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV && setData( AccelerationStructureMotionInstanceDataNV const & data_ ) && VULKAN_HPP_NOEXCEPT + { + data = data_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureMotionInstanceNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureMotionInstanceNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureMotionInstanceNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( type, flags, data ); + } +#endif + + public: + AccelerationStructureMotionInstanceTypeNV type = AccelerationStructureMotionInstanceTypeNV::eStatic; + AccelerationStructureMotionInstanceFlagsNV flags = {}; + AccelerationStructureMotionInstanceDataNV data = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureMotionInstanceNV; + }; +#endif + + // wrapper struct for struct VkMicromapUsageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapUsageEXT.html + struct MicromapUsageEXT + { + using NativeType = VkMicromapUsageEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MicromapUsageEXT( uint32_t count_ = {}, uint32_t subdivisionLevel_ = {}, uint32_t format_ = {} ) VULKAN_HPP_NOEXCEPT + : count{ count_ } + , subdivisionLevel{ subdivisionLevel_ } + , format{ format_ } + { + } + + VULKAN_HPP_CONSTEXPR MicromapUsageEXT( MicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MicromapUsageEXT( VkMicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT : MicromapUsageEXT( *reinterpret_cast( &rhs ) ) {} + + MicromapUsageEXT & operator=( MicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MicromapUsageEXT & operator=( VkMicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT & setCount( uint32_t count_ ) & VULKAN_HPP_NOEXCEPT + { + count = count_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT && setCount( uint32_t count_ ) && VULKAN_HPP_NOEXCEPT + { + count = count_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT & setSubdivisionLevel( uint32_t subdivisionLevel_ ) & VULKAN_HPP_NOEXCEPT + { + subdivisionLevel = subdivisionLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT && setSubdivisionLevel( uint32_t subdivisionLevel_ ) && VULKAN_HPP_NOEXCEPT + { + subdivisionLevel = subdivisionLevel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT & setFormat( uint32_t format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT && setFormat( uint32_t format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMicromapUsageEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapUsageEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapUsageEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMicromapUsageEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( count, subdivisionLevel, format ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MicromapUsageEXT const & ) const = default; +#else + bool operator==( MicromapUsageEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( count == rhs.count ) && ( subdivisionLevel == rhs.subdivisionLevel ) && ( format == rhs.format ); +# endif + } + + bool operator!=( MicromapUsageEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t count = {}; + uint32_t subdivisionLevel = {}; + uint32_t format = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MicromapUsageEXT; + }; +#endif + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkAccelerationStructureTrianglesDisplacementMicromapNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTrianglesDisplacementMicromapNV.html + struct AccelerationStructureTrianglesDisplacementMicromapNV + { + using NativeType = VkAccelerationStructureTrianglesDisplacementMicromapNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV( Format displacementBiasAndScaleFormat_ = Format::eUndefined, + Format displacementVectorFormat_ = Format::eUndefined, + DeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer_ = {}, + DeviceSize displacementBiasAndScaleStride_ = {}, + DeviceOrHostAddressConstKHR displacementVectorBuffer_ = {}, + DeviceSize displacementVectorStride_ = {}, + DeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags_ = {}, + DeviceSize displacedMicromapPrimitiveFlagsStride_ = {}, + IndexType indexType_ = IndexType::eUint16, + DeviceOrHostAddressConstKHR indexBuffer_ = {}, + DeviceSize indexStride_ = {}, + uint32_t baseTriangle_ = {}, + uint32_t usageCountsCount_ = {}, + const MicromapUsageEXT * pUsageCounts_ = {}, + const MicromapUsageEXT * const * ppUsageCounts_ = {}, + MicromapEXT micromap_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , displacementBiasAndScaleFormat{ displacementBiasAndScaleFormat_ } + , displacementVectorFormat{ displacementVectorFormat_ } + , displacementBiasAndScaleBuffer{ displacementBiasAndScaleBuffer_ } + , displacementBiasAndScaleStride{ displacementBiasAndScaleStride_ } + , displacementVectorBuffer{ displacementVectorBuffer_ } + , displacementVectorStride{ displacementVectorStride_ } + , displacedMicromapPrimitiveFlags{ displacedMicromapPrimitiveFlags_ } + , displacedMicromapPrimitiveFlagsStride{ displacedMicromapPrimitiveFlagsStride_ } + , indexType{ indexType_ } + , indexBuffer{ indexBuffer_ } + , indexStride{ indexStride_ } + , baseTriangle{ baseTriangle_ } + , usageCountsCount{ usageCountsCount_ } + , pUsageCounts{ pUsageCounts_ } + , ppUsageCounts{ ppUsageCounts_ } + , micromap{ micromap_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + AccelerationStructureTrianglesDisplacementMicromapNV( AccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureTrianglesDisplacementMicromapNV( VkAccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureTrianglesDisplacementMicromapNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureTrianglesDisplacementMicromapNV( Format displacementBiasAndScaleFormat_, + Format displacementVectorFormat_, + DeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer_, + DeviceSize displacementBiasAndScaleStride_, + DeviceOrHostAddressConstKHR displacementVectorBuffer_, + DeviceSize displacementVectorStride_, + DeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags_, + DeviceSize displacedMicromapPrimitiveFlagsStride_, + IndexType indexType_, + DeviceOrHostAddressConstKHR indexBuffer_, + DeviceSize indexStride_, + uint32_t baseTriangle_, + ArrayProxyNoTemporaries const & usageCounts_, + ArrayProxyNoTemporaries const & pUsageCounts_ = {}, + MicromapEXT micromap_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ) + , displacementBiasAndScaleFormat( displacementBiasAndScaleFormat_ ) + , displacementVectorFormat( displacementVectorFormat_ ) + , displacementBiasAndScaleBuffer( displacementBiasAndScaleBuffer_ ) + , displacementBiasAndScaleStride( displacementBiasAndScaleStride_ ) + , displacementVectorBuffer( displacementVectorBuffer_ ) + , displacementVectorStride( displacementVectorStride_ ) + , displacedMicromapPrimitiveFlags( displacedMicromapPrimitiveFlags_ ) + , displacedMicromapPrimitiveFlagsStride( displacedMicromapPrimitiveFlagsStride_ ) + , indexType( indexType_ ) + , indexBuffer( indexBuffer_ ) + , indexStride( indexStride_ ) + , baseTriangle( baseTriangle_ ) + , usageCountsCount( static_cast( usageCounts_.size() ) ) + , pUsageCounts( usageCounts_.data() ) + , ppUsageCounts( pUsageCounts_.data() ) + , micromap( micromap_ ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( usageCounts_.empty() || pUsageCounts_.empty() || ( usageCounts_.size() == pUsageCounts_.size() ) ); +# else + if ( !usageCounts_.empty() && !pUsageCounts_.empty() && ( usageCounts_.size() != pUsageCounts_.size() ) ) + { + throw LogicError( + VULKAN_HPP_NAMESPACE_STRING + "::AccelerationStructureTrianglesDisplacementMicromapNV::AccelerationStructureTrianglesDisplacementMicromapNV: !usageCounts_.empty() && !pUsageCounts_.empty() && ( usageCounts_.size() != pUsageCounts_.size() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + AccelerationStructureTrianglesDisplacementMicromapNV & + operator=( AccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureTrianglesDisplacementMicromapNV & operator=( VkAccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setDisplacementBiasAndScaleFormat( Format displacementBiasAndScaleFormat_ ) & + VULKAN_HPP_NOEXCEPT + { + displacementBiasAndScaleFormat = displacementBiasAndScaleFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && + setDisplacementBiasAndScaleFormat( Format displacementBiasAndScaleFormat_ ) && + VULKAN_HPP_NOEXCEPT + { + displacementBiasAndScaleFormat = displacementBiasAndScaleFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setDisplacementVectorFormat( Format displacementVectorFormat_ ) & + VULKAN_HPP_NOEXCEPT + { + displacementVectorFormat = displacementVectorFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setDisplacementVectorFormat( Format displacementVectorFormat_ ) && + VULKAN_HPP_NOEXCEPT + { + displacementVectorFormat = displacementVectorFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & + setDisplacementBiasAndScaleBuffer( DeviceOrHostAddressConstKHR const & displacementBiasAndScaleBuffer_ ) & + VULKAN_HPP_NOEXCEPT + { + displacementBiasAndScaleBuffer = displacementBiasAndScaleBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && + setDisplacementBiasAndScaleBuffer( DeviceOrHostAddressConstKHR const & displacementBiasAndScaleBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + displacementBiasAndScaleBuffer = displacementBiasAndScaleBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & + setDisplacementBiasAndScaleStride( DeviceSize displacementBiasAndScaleStride_ ) & + VULKAN_HPP_NOEXCEPT + { + displacementBiasAndScaleStride = displacementBiasAndScaleStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && + setDisplacementBiasAndScaleStride( DeviceSize displacementBiasAndScaleStride_ ) && + VULKAN_HPP_NOEXCEPT + { + displacementBiasAndScaleStride = displacementBiasAndScaleStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & + setDisplacementVectorBuffer( DeviceOrHostAddressConstKHR const & displacementVectorBuffer_ ) & + VULKAN_HPP_NOEXCEPT + { + displacementVectorBuffer = displacementVectorBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && + setDisplacementVectorBuffer( DeviceOrHostAddressConstKHR const & displacementVectorBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + displacementVectorBuffer = displacementVectorBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setDisplacementVectorStride( DeviceSize displacementVectorStride_ ) & + VULKAN_HPP_NOEXCEPT + { + displacementVectorStride = displacementVectorStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setDisplacementVectorStride( DeviceSize displacementVectorStride_ ) && + VULKAN_HPP_NOEXCEPT + { + displacementVectorStride = displacementVectorStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & + setDisplacedMicromapPrimitiveFlags( DeviceOrHostAddressConstKHR const & displacedMicromapPrimitiveFlags_ ) & + VULKAN_HPP_NOEXCEPT + { + displacedMicromapPrimitiveFlags = displacedMicromapPrimitiveFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && + setDisplacedMicromapPrimitiveFlags( DeviceOrHostAddressConstKHR const & displacedMicromapPrimitiveFlags_ ) && + VULKAN_HPP_NOEXCEPT + { + displacedMicromapPrimitiveFlags = displacedMicromapPrimitiveFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & + setDisplacedMicromapPrimitiveFlagsStride( DeviceSize displacedMicromapPrimitiveFlagsStride_ ) & + VULKAN_HPP_NOEXCEPT + { + displacedMicromapPrimitiveFlagsStride = displacedMicromapPrimitiveFlagsStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && + setDisplacedMicromapPrimitiveFlagsStride( DeviceSize displacedMicromapPrimitiveFlagsStride_ ) && + VULKAN_HPP_NOEXCEPT + { + displacedMicromapPrimitiveFlagsStride = displacedMicromapPrimitiveFlagsStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) & + VULKAN_HPP_NOEXCEPT + { + indexBuffer = indexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + indexBuffer = indexBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT + { + indexStride = indexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT + { + indexStride = indexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setBaseTriangle( uint32_t baseTriangle_ ) & VULKAN_HPP_NOEXCEPT + { + baseTriangle = baseTriangle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setBaseTriangle( uint32_t baseTriangle_ ) && VULKAN_HPP_NOEXCEPT + { + baseTriangle = baseTriangle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setUsageCountsCount( uint32_t usageCountsCount_ ) & VULKAN_HPP_NOEXCEPT + { + usageCountsCount = usageCountsCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setUsageCountsCount( uint32_t usageCountsCount_ ) && VULKAN_HPP_NOEXCEPT + { + usageCountsCount = usageCountsCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) & + VULKAN_HPP_NOEXCEPT + { + pUsageCounts = pUsageCounts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) && + VULKAN_HPP_NOEXCEPT + { + pUsageCounts = pUsageCounts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureTrianglesDisplacementMicromapNV & + setUsageCounts( ArrayProxyNoTemporaries const & usageCounts_ ) VULKAN_HPP_NOEXCEPT + { + usageCountsCount = static_cast( usageCounts_.size() ); + pUsageCounts = usageCounts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) & + VULKAN_HPP_NOEXCEPT + { + ppUsageCounts = ppUsageCounts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) && + VULKAN_HPP_NOEXCEPT + { + ppUsageCounts = ppUsageCounts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureTrianglesDisplacementMicromapNV & + setPUsageCounts( ArrayProxyNoTemporaries const & pUsageCounts_ ) VULKAN_HPP_NOEXCEPT + { + usageCountsCount = static_cast( pUsageCounts_.size() ); + ppUsageCounts = pUsageCounts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setMicromap( MicromapEXT micromap_ ) & VULKAN_HPP_NOEXCEPT + { + micromap = micromap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setMicromap( MicromapEXT micromap_ ) && VULKAN_HPP_NOEXCEPT + { + micromap = micromap_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureTrianglesDisplacementMicromapNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureTrianglesDisplacementMicromapNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureTrianglesDisplacementMicromapNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureTrianglesDisplacementMicromapNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + displacementBiasAndScaleFormat, + displacementVectorFormat, + displacementBiasAndScaleBuffer, + displacementBiasAndScaleStride, + displacementVectorBuffer, + displacementVectorStride, + displacedMicromapPrimitiveFlags, + displacedMicromapPrimitiveFlagsStride, + indexType, + indexBuffer, + indexStride, + baseTriangle, + usageCountsCount, + pUsageCounts, + ppUsageCounts, + micromap ); + } +# endif + + public: + StructureType sType = StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV; + void * pNext = {}; + Format displacementBiasAndScaleFormat = Format::eUndefined; + Format displacementVectorFormat = Format::eUndefined; + DeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer = {}; + DeviceSize displacementBiasAndScaleStride = {}; + DeviceOrHostAddressConstKHR displacementVectorBuffer = {}; + DeviceSize displacementVectorStride = {}; + DeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags = {}; + DeviceSize displacedMicromapPrimitiveFlagsStride = {}; + IndexType indexType = IndexType::eUint16; + DeviceOrHostAddressConstKHR indexBuffer = {}; + DeviceSize indexStride = {}; + uint32_t baseTriangle = {}; + uint32_t usageCountsCount = {}; + const MicromapUsageEXT * pUsageCounts = {}; + const MicromapUsageEXT * const * ppUsageCounts = {}; + MicromapEXT micromap = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureTrianglesDisplacementMicromapNV; + }; +# endif + + template <> + struct CppType + { + using Type = AccelerationStructureTrianglesDisplacementMicromapNV; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkAccelerationStructureTrianglesOpacityMicromapEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTrianglesOpacityMicromapEXT.html + struct AccelerationStructureTrianglesOpacityMicromapEXT + { + using NativeType = VkAccelerationStructureTrianglesOpacityMicromapEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT( IndexType indexType_ = IndexType::eUint16, + DeviceOrHostAddressConstKHR indexBuffer_ = {}, + DeviceSize indexStride_ = {}, + uint32_t baseTriangle_ = {}, + uint32_t usageCountsCount_ = {}, + const MicromapUsageEXT * pUsageCounts_ = {}, + const MicromapUsageEXT * const * ppUsageCounts_ = {}, + MicromapEXT micromap_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , indexType{ indexType_ } + , indexBuffer{ indexBuffer_ } + , indexStride{ indexStride_ } + , baseTriangle{ baseTriangle_ } + , usageCountsCount{ usageCountsCount_ } + , pUsageCounts{ pUsageCounts_ } + , ppUsageCounts{ ppUsageCounts_ } + , micromap{ micromap_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + AccelerationStructureTrianglesOpacityMicromapEXT( AccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureTrianglesOpacityMicromapEXT( VkAccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureTrianglesOpacityMicromapEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureTrianglesOpacityMicromapEXT( IndexType indexType_, + DeviceOrHostAddressConstKHR indexBuffer_, + DeviceSize indexStride_, + uint32_t baseTriangle_, + ArrayProxyNoTemporaries const & usageCounts_, + ArrayProxyNoTemporaries const & pUsageCounts_ = {}, + MicromapEXT micromap_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ) + , indexType( indexType_ ) + , indexBuffer( indexBuffer_ ) + , indexStride( indexStride_ ) + , baseTriangle( baseTriangle_ ) + , usageCountsCount( static_cast( !usageCounts_.empty() ? usageCounts_.size() : pUsageCounts_.size() ) ) + , pUsageCounts( usageCounts_.data() ) + , ppUsageCounts( pUsageCounts_.data() ) + , micromap( micromap_ ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( ( !usageCounts_.empty() + !pUsageCounts_.empty() ) <= 1 ); +# else + if ( 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() ) ) + { + throw LogicError( + VULKAN_HPP_NAMESPACE_STRING + "::AccelerationStructureTrianglesOpacityMicromapEXT::AccelerationStructureTrianglesOpacityMicromapEXT: 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + AccelerationStructureTrianglesOpacityMicromapEXT & operator=( AccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureTrianglesOpacityMicromapEXT & operator=( VkAccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) & + VULKAN_HPP_NOEXCEPT + { + indexBuffer = indexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + indexBuffer = indexBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT + { + indexStride = indexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT + { + indexStride = indexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setBaseTriangle( uint32_t baseTriangle_ ) & VULKAN_HPP_NOEXCEPT + { + baseTriangle = baseTriangle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setBaseTriangle( uint32_t baseTriangle_ ) && VULKAN_HPP_NOEXCEPT + { + baseTriangle = baseTriangle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setUsageCountsCount( uint32_t usageCountsCount_ ) & VULKAN_HPP_NOEXCEPT + { + usageCountsCount = usageCountsCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setUsageCountsCount( uint32_t usageCountsCount_ ) && VULKAN_HPP_NOEXCEPT + { + usageCountsCount = usageCountsCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) & VULKAN_HPP_NOEXCEPT + { + pUsageCounts = pUsageCounts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) && VULKAN_HPP_NOEXCEPT + { + pUsageCounts = pUsageCounts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureTrianglesOpacityMicromapEXT & + setUsageCounts( ArrayProxyNoTemporaries const & usageCounts_ ) VULKAN_HPP_NOEXCEPT + { + usageCountsCount = static_cast( usageCounts_.size() ); + pUsageCounts = usageCounts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) & + VULKAN_HPP_NOEXCEPT + { + ppUsageCounts = ppUsageCounts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) && + VULKAN_HPP_NOEXCEPT + { + ppUsageCounts = ppUsageCounts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AccelerationStructureTrianglesOpacityMicromapEXT & + setPUsageCounts( ArrayProxyNoTemporaries const & pUsageCounts_ ) VULKAN_HPP_NOEXCEPT + { + usageCountsCount = static_cast( pUsageCounts_.size() ); + ppUsageCounts = pUsageCounts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setMicromap( MicromapEXT micromap_ ) & VULKAN_HPP_NOEXCEPT + { + micromap = micromap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setMicromap( MicromapEXT micromap_ ) && VULKAN_HPP_NOEXCEPT + { + micromap = micromap_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureTrianglesOpacityMicromapEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureTrianglesOpacityMicromapEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureTrianglesOpacityMicromapEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureTrianglesOpacityMicromapEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, indexType, indexBuffer, indexStride, baseTriangle, usageCountsCount, pUsageCounts, ppUsageCounts, micromap ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT; + void * pNext = {}; + IndexType indexType = IndexType::eUint16; + DeviceOrHostAddressConstKHR indexBuffer = {}; + DeviceSize indexStride = {}; + uint32_t baseTriangle = {}; + uint32_t usageCountsCount = {}; + const MicromapUsageEXT * pUsageCounts = {}; + const MicromapUsageEXT * const * ppUsageCounts = {}; + MicromapEXT micromap = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureTrianglesOpacityMicromapEXT; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureTrianglesOpacityMicromapEXT; + }; + + // wrapper struct for struct VkAccelerationStructureVersionInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureVersionInfoKHR.html + struct AccelerationStructureVersionInfoKHR + { + using NativeType = VkAccelerationStructureVersionInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureVersionInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AccelerationStructureVersionInfoKHR( const uint8_t * pVersionData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pVersionData{ pVersionData_ } + { + } + + VULKAN_HPP_CONSTEXPR AccelerationStructureVersionInfoKHR( AccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AccelerationStructureVersionInfoKHR( VkAccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AccelerationStructureVersionInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + AccelerationStructureVersionInfoKHR & operator=( AccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AccelerationStructureVersionInfoKHR & operator=( VkAccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR & setPVersionData( const uint8_t * pVersionData_ ) & VULKAN_HPP_NOEXCEPT + { + pVersionData = pVersionData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR && setPVersionData( const uint8_t * pVersionData_ ) && VULKAN_HPP_NOEXCEPT + { + pVersionData = pVersionData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAccelerationStructureVersionInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureVersionInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAccelerationStructureVersionInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAccelerationStructureVersionInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pVersionData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AccelerationStructureVersionInfoKHR const & ) const = default; +#else + bool operator==( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData ); +# endif + } + + bool operator!=( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAccelerationStructureVersionInfoKHR; + const void * pNext = {}; + const uint8_t * pVersionData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AccelerationStructureVersionInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AccelerationStructureVersionInfoKHR; + }; + + // wrapper struct for struct VkAcquireNextImageInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAcquireNextImageInfoKHR.html + struct AcquireNextImageInfoKHR + { + using NativeType = VkAcquireNextImageInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAcquireNextImageInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( SwapchainKHR swapchain_ = {}, + uint64_t timeout_ = {}, + Semaphore semaphore_ = {}, + Fence fence_ = {}, + uint32_t deviceMask_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchain{ swapchain_ } + , timeout{ timeout_ } + , semaphore{ semaphore_ } + , fence{ fence_ } + , deviceMask{ deviceMask_ } + { + } + + VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AcquireNextImageInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + AcquireNextImageInfoKHR & operator=( AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AcquireNextImageInfoKHR & operator=( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setTimeout( uint64_t timeout_ ) & VULKAN_HPP_NOEXCEPT + { + timeout = timeout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setTimeout( uint64_t timeout_ ) && VULKAN_HPP_NOEXCEPT + { + timeout = timeout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setFence( Fence fence_ ) & VULKAN_HPP_NOEXCEPT + { + fence = fence_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setFence( Fence fence_ ) && VULKAN_HPP_NOEXCEPT + { + fence = fence_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT + { + deviceMask = deviceMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT + { + deviceMask = deviceMask_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAcquireNextImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAcquireNextImageInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAcquireNextImageInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAcquireNextImageInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain, timeout, semaphore, fence, deviceMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AcquireNextImageInfoKHR const & ) const = default; +#else + bool operator==( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( timeout == rhs.timeout ) && + ( semaphore == rhs.semaphore ) && ( fence == rhs.fence ) && ( deviceMask == rhs.deviceMask ); +# endif + } + + bool operator!=( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAcquireNextImageInfoKHR; + const void * pNext = {}; + SwapchainKHR swapchain = {}; + uint64_t timeout = {}; + Semaphore semaphore = {}; + Fence fence = {}; + uint32_t deviceMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AcquireNextImageInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AcquireNextImageInfoKHR; + }; + + // wrapper struct for struct VkAcquireProfilingLockInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAcquireProfilingLockInfoKHR.html + struct AcquireProfilingLockInfoKHR + { + using NativeType = VkAcquireProfilingLockInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAcquireProfilingLockInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + AcquireProfilingLockInfoKHR( AcquireProfilingLockFlagsKHR flags_ = {}, uint64_t timeout_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , timeout{ timeout_ } + { + } + + VULKAN_HPP_CONSTEXPR AcquireProfilingLockInfoKHR( AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AcquireProfilingLockInfoKHR( VkAcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AcquireProfilingLockInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + AcquireProfilingLockInfoKHR & operator=( AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AcquireProfilingLockInfoKHR & operator=( VkAcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR & setFlags( AcquireProfilingLockFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR && setFlags( AcquireProfilingLockFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR & setTimeout( uint64_t timeout_ ) & VULKAN_HPP_NOEXCEPT + { + timeout = timeout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR && setTimeout( uint64_t timeout_ ) && VULKAN_HPP_NOEXCEPT + { + timeout = timeout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAcquireProfilingLockInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAcquireProfilingLockInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAcquireProfilingLockInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, timeout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AcquireProfilingLockInfoKHR const & ) const = default; +#else + bool operator==( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( timeout == rhs.timeout ); +# endif + } + + bool operator!=( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAcquireProfilingLockInfoKHR; + const void * pNext = {}; + AcquireProfilingLockFlagsKHR flags = {}; + uint64_t timeout = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AcquireProfilingLockInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = AcquireProfilingLockInfoKHR; + }; + + typedef void *( VKAPI_PTR * PFN_AllocationFunction )( void * pUserData, size_t size, size_t alignment, SystemAllocationScope allocationScope ); + + typedef void *( VKAPI_PTR * PFN_ReallocationFunction )( + void * pUserData, void * pOriginal, size_t size, size_t alignment, SystemAllocationScope allocationScope ); + + typedef void( VKAPI_PTR * PFN_FreeFunction )( void * pUserData, void * pMemory ); + + typedef void( VKAPI_PTR * PFN_InternalAllocationNotification )( void * pUserData, + size_t size, + InternalAllocationType allocationType, + SystemAllocationScope allocationScope ); + + typedef void( VKAPI_PTR * PFN_InternalFreeNotification )( void * pUserData, + size_t size, + InternalAllocationType allocationType, + SystemAllocationScope allocationScope ); + + // wrapper struct for struct VkAllocationCallbacks, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAllocationCallbacks.html + struct AllocationCallbacks + { + using NativeType = VkAllocationCallbacks; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AllocationCallbacks( void * pUserData_ = {}, + PFN_AllocationFunction pfnAllocation_ = {}, + PFN_ReallocationFunction pfnReallocation_ = {}, + PFN_FreeFunction pfnFree_ = {}, + PFN_InternalAllocationNotification pfnInternalAllocation_ = {}, + PFN_InternalFreeNotification pfnInternalFree_ = {} ) VULKAN_HPP_NOEXCEPT + : pUserData{ pUserData_ } + , pfnAllocation{ pfnAllocation_ } + , pfnReallocation{ pfnReallocation_ } + , pfnFree{ pfnFree_ } + , pfnInternalAllocation{ pfnInternalAllocation_ } + , pfnInternalFree{ pfnInternalFree_ } + { + } + + VULKAN_HPP_CONSTEXPR AllocationCallbacks( AllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AllocationCallbacks( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT : AllocationCallbacks( *reinterpret_cast( &rhs ) ) + { + } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + + AllocationCallbacks( void * pUserData_, + PFN_vkAllocationFunction pfnAllocation_, + PFN_vkReallocationFunction pfnReallocation_ = {}, + PFN_vkFreeFunction pfnFree_ = {}, + PFN_vkInternalAllocationNotification pfnInternalAllocation_ = {}, + PFN_vkInternalFreeNotification pfnInternalFree_ = {} ) VULKAN_HPP_NOEXCEPT + : AllocationCallbacks( pUserData_, + reinterpret_cast( pfnAllocation_ ), + reinterpret_cast( pfnReallocation_ ), + reinterpret_cast( pfnFree_ ), + reinterpret_cast( pfnInternalAllocation_ ), + reinterpret_cast( pfnInternalFree_ ) ) + { + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif + + AllocationCallbacks & operator=( AllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AllocationCallbacks & operator=( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT + { + pUserData = pUserData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT + { + pUserData = pUserData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnAllocation( PFN_AllocationFunction pfnAllocation_ ) & VULKAN_HPP_NOEXCEPT + { + pfnAllocation = pfnAllocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnAllocation( PFN_AllocationFunction pfnAllocation_ ) && VULKAN_HPP_NOEXCEPT + { + pfnAllocation = pfnAllocation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnReallocation( PFN_ReallocationFunction pfnReallocation_ ) & VULKAN_HPP_NOEXCEPT + { + pfnReallocation = pfnReallocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnReallocation( PFN_ReallocationFunction pfnReallocation_ ) && VULKAN_HPP_NOEXCEPT + { + pfnReallocation = pfnReallocation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnFree( PFN_FreeFunction pfnFree_ ) & VULKAN_HPP_NOEXCEPT + { + pfnFree = pfnFree_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnFree( PFN_FreeFunction pfnFree_ ) && VULKAN_HPP_NOEXCEPT + { + pfnFree = pfnFree_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalAllocation( PFN_InternalAllocationNotification pfnInternalAllocation_ ) & VULKAN_HPP_NOEXCEPT + { + pfnInternalAllocation = pfnInternalAllocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnInternalAllocation( PFN_InternalAllocationNotification pfnInternalAllocation_ ) && VULKAN_HPP_NOEXCEPT + { + pfnInternalAllocation = pfnInternalAllocation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalFree( PFN_InternalFreeNotification pfnInternalFree_ ) & VULKAN_HPP_NOEXCEPT + { + pfnInternalFree = pfnInternalFree_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnInternalFree( PFN_InternalFreeNotification pfnInternalFree_ ) && VULKAN_HPP_NOEXCEPT + { + pfnInternalFree = pfnInternalFree_; + return std::move( *this ); + } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + AllocationCallbacks & setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnAllocation( reinterpret_cast( pfnAllocation_ ) ); + } + + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + AllocationCallbacks & setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnReallocation( reinterpret_cast( pfnReallocation_ ) ); + } + + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + AllocationCallbacks & setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnInternalAllocation( reinterpret_cast( pfnInternalAllocation_ ) ); + } + + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + AllocationCallbacks & setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnInternalFree( reinterpret_cast( pfnInternalFree_ ) ); + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAllocationCallbacks &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAllocationCallbacks const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAllocationCallbacks *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( pUserData, pfnAllocation, pfnReallocation, pfnFree, pfnInternalAllocation, pfnInternalFree ); + } +#endif + + bool operator==( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT + { +#if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +#else + return ( pUserData == rhs.pUserData ) && ( pfnAllocation == rhs.pfnAllocation ) && ( pfnReallocation == rhs.pfnReallocation ) && + ( pfnFree == rhs.pfnFree ) && ( pfnInternalAllocation == rhs.pfnInternalAllocation ) && ( pfnInternalFree == rhs.pfnInternalFree ); +#endif + } + + bool operator!=( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + void * pUserData = {}; + PFN_AllocationFunction pfnAllocation = {}; + PFN_ReallocationFunction pfnReallocation = {}; + PFN_FreeFunction pfnFree = {}; + PFN_InternalAllocationNotification pfnInternalAllocation = {}; + PFN_InternalFreeNotification pfnInternalFree = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AllocationCallbacks; + }; +#endif + + // wrapper struct for struct VkAmigoProfilingSubmitInfoSEC, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAmigoProfilingSubmitInfoSEC.html + struct AmigoProfilingSubmitInfoSEC + { + using NativeType = VkAmigoProfilingSubmitInfoSEC; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAmigoProfilingSubmitInfoSEC; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + AmigoProfilingSubmitInfoSEC( uint64_t firstDrawTimestamp_ = {}, uint64_t swapBufferTimestamp_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , firstDrawTimestamp{ firstDrawTimestamp_ } + , swapBufferTimestamp{ swapBufferTimestamp_ } + { + } + + VULKAN_HPP_CONSTEXPR AmigoProfilingSubmitInfoSEC( AmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AmigoProfilingSubmitInfoSEC( VkAmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT + : AmigoProfilingSubmitInfoSEC( *reinterpret_cast( &rhs ) ) + { + } + + AmigoProfilingSubmitInfoSEC & operator=( AmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AmigoProfilingSubmitInfoSEC & operator=( VkAmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC & setFirstDrawTimestamp( uint64_t firstDrawTimestamp_ ) & VULKAN_HPP_NOEXCEPT + { + firstDrawTimestamp = firstDrawTimestamp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC && setFirstDrawTimestamp( uint64_t firstDrawTimestamp_ ) && VULKAN_HPP_NOEXCEPT + { + firstDrawTimestamp = firstDrawTimestamp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC & setSwapBufferTimestamp( uint64_t swapBufferTimestamp_ ) & VULKAN_HPP_NOEXCEPT + { + swapBufferTimestamp = swapBufferTimestamp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC && setSwapBufferTimestamp( uint64_t swapBufferTimestamp_ ) && VULKAN_HPP_NOEXCEPT + { + swapBufferTimestamp = swapBufferTimestamp_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAmigoProfilingSubmitInfoSEC const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAmigoProfilingSubmitInfoSEC &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAmigoProfilingSubmitInfoSEC const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAmigoProfilingSubmitInfoSEC *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, firstDrawTimestamp, swapBufferTimestamp ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AmigoProfilingSubmitInfoSEC const & ) const = default; +#else + bool operator==( AmigoProfilingSubmitInfoSEC const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( firstDrawTimestamp == rhs.firstDrawTimestamp ) && + ( swapBufferTimestamp == rhs.swapBufferTimestamp ); +# endif + } + + bool operator!=( AmigoProfilingSubmitInfoSEC const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAmigoProfilingSubmitInfoSEC; + const void * pNext = {}; + uint64_t firstDrawTimestamp = {}; + uint64_t swapBufferTimestamp = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AmigoProfilingSubmitInfoSEC; + }; +#endif + + template <> + struct CppType + { + using Type = AmigoProfilingSubmitInfoSEC; + }; + + // wrapper struct for struct VkComponentMapping, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkComponentMapping.html + struct ComponentMapping + { + using NativeType = VkComponentMapping; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity, + ComponentSwizzle g_ = ComponentSwizzle::eIdentity, + ComponentSwizzle b_ = ComponentSwizzle::eIdentity, + ComponentSwizzle a_ = ComponentSwizzle::eIdentity ) VULKAN_HPP_NOEXCEPT + : r{ r_ } + , g{ g_ } + , b{ b_ } + , a{ a_ } + { + } + + VULKAN_HPP_CONSTEXPR ComponentMapping( ComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ComponentMapping( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT : ComponentMapping( *reinterpret_cast( &rhs ) ) {} + + ComponentMapping & operator=( ComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ComponentMapping & operator=( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setR( ComponentSwizzle r_ ) & VULKAN_HPP_NOEXCEPT + { + r = r_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setR( ComponentSwizzle r_ ) && VULKAN_HPP_NOEXCEPT + { + r = r_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setG( ComponentSwizzle g_ ) & VULKAN_HPP_NOEXCEPT + { + g = g_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setG( ComponentSwizzle g_ ) && VULKAN_HPP_NOEXCEPT + { + g = g_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setB( ComponentSwizzle b_ ) & VULKAN_HPP_NOEXCEPT + { + b = b_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setB( ComponentSwizzle b_ ) && VULKAN_HPP_NOEXCEPT + { + b = b_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setA( ComponentSwizzle a_ ) & VULKAN_HPP_NOEXCEPT + { + a = a_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setA( ComponentSwizzle a_ ) && VULKAN_HPP_NOEXCEPT + { + a = a_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkComponentMapping const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkComponentMapping &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkComponentMapping const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkComponentMapping *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( r, g, b, a ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ComponentMapping const & ) const = default; +#else + bool operator==( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( r == rhs.r ) && ( g == rhs.g ) && ( b == rhs.b ) && ( a == rhs.a ); +# endif + } + + bool operator!=( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ComponentSwizzle r = ComponentSwizzle::eIdentity; + ComponentSwizzle g = ComponentSwizzle::eIdentity; + ComponentSwizzle b = ComponentSwizzle::eIdentity; + ComponentSwizzle a = ComponentSwizzle::eIdentity; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ComponentMapping; + }; +#endif + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + // wrapper struct for struct VkAndroidHardwareBufferFormatProperties2ANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatProperties2ANDROID.html + struct AndroidHardwareBufferFormatProperties2ANDROID + { + using NativeType = VkAndroidHardwareBufferFormatProperties2ANDROID; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferFormatProperties2ANDROID; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + AndroidHardwareBufferFormatProperties2ANDROID( Format format_ = Format::eUndefined, + uint64_t externalFormat_ = {}, + FormatFeatureFlags2 formatFeatures_ = {}, + ComponentMapping samplerYcbcrConversionComponents_ = {}, + SamplerYcbcrModelConversion suggestedYcbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, + SamplerYcbcrRange suggestedYcbcrRange_ = SamplerYcbcrRange::eItuFull, + ChromaLocation suggestedXChromaOffset_ = ChromaLocation::eCositedEven, + ChromaLocation suggestedYChromaOffset_ = ChromaLocation::eCositedEven, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , format{ format_ } + , externalFormat{ externalFormat_ } + , formatFeatures{ formatFeatures_ } + , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ } + , suggestedYcbcrModel{ suggestedYcbcrModel_ } + , suggestedYcbcrRange{ suggestedYcbcrRange_ } + , suggestedXChromaOffset{ suggestedXChromaOffset_ } + , suggestedYChromaOffset{ suggestedYChromaOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR + AndroidHardwareBufferFormatProperties2ANDROID( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AndroidHardwareBufferFormatProperties2ANDROID( VkAndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + : AndroidHardwareBufferFormatProperties2ANDROID( *reinterpret_cast( &rhs ) ) + { + } + + AndroidHardwareBufferFormatProperties2ANDROID & operator=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AndroidHardwareBufferFormatProperties2ANDROID & operator=( VkAndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkAndroidHardwareBufferFormatProperties2ANDROID const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferFormatProperties2ANDROID &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferFormatProperties2ANDROID const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferFormatProperties2ANDROID *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + format, + externalFormat, + formatFeatures, + samplerYcbcrConversionComponents, + suggestedYcbcrModel, + suggestedYcbcrRange, + suggestedXChromaOffset, + suggestedYChromaOffset ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AndroidHardwareBufferFormatProperties2ANDROID const & ) const = default; +# else + bool operator==( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) && + ( formatFeatures == rhs.formatFeatures ) && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && + ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && + ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); +# endif + } + + bool operator!=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eAndroidHardwareBufferFormatProperties2ANDROID; + void * pNext = {}; + Format format = Format::eUndefined; + uint64_t externalFormat = {}; + FormatFeatureFlags2 formatFeatures = {}; + ComponentMapping samplerYcbcrConversionComponents = {}; + SamplerYcbcrModelConversion suggestedYcbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; + SamplerYcbcrRange suggestedYcbcrRange = SamplerYcbcrRange::eItuFull; + ChromaLocation suggestedXChromaOffset = ChromaLocation::eCositedEven; + ChromaLocation suggestedYChromaOffset = ChromaLocation::eCositedEven; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AndroidHardwareBufferFormatProperties2ANDROID; + }; +# endif + + template <> + struct CppType + { + using Type = AndroidHardwareBufferFormatProperties2ANDROID; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + // wrapper struct for struct VkAndroidHardwareBufferFormatPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatPropertiesANDROID.html + struct AndroidHardwareBufferFormatPropertiesANDROID + { + using NativeType = VkAndroidHardwareBufferFormatPropertiesANDROID; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + AndroidHardwareBufferFormatPropertiesANDROID( Format format_ = Format::eUndefined, + uint64_t externalFormat_ = {}, + FormatFeatureFlags formatFeatures_ = {}, + ComponentMapping samplerYcbcrConversionComponents_ = {}, + SamplerYcbcrModelConversion suggestedYcbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, + SamplerYcbcrRange suggestedYcbcrRange_ = SamplerYcbcrRange::eItuFull, + ChromaLocation suggestedXChromaOffset_ = ChromaLocation::eCositedEven, + ChromaLocation suggestedYChromaOffset_ = ChromaLocation::eCositedEven, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , format{ format_ } + , externalFormat{ externalFormat_ } + , formatFeatures{ formatFeatures_ } + , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ } + , suggestedYcbcrModel{ suggestedYcbcrModel_ } + , suggestedYcbcrRange{ suggestedYcbcrRange_ } + , suggestedXChromaOffset{ suggestedXChromaOffset_ } + , suggestedYChromaOffset{ suggestedYChromaOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR AndroidHardwareBufferFormatPropertiesANDROID( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + : AndroidHardwareBufferFormatPropertiesANDROID( *reinterpret_cast( &rhs ) ) + { + } + + AndroidHardwareBufferFormatPropertiesANDROID & operator=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AndroidHardwareBufferFormatPropertiesANDROID & operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkAndroidHardwareBufferFormatPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferFormatPropertiesANDROID &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferFormatPropertiesANDROID const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferFormatPropertiesANDROID *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + format, + externalFormat, + formatFeatures, + samplerYcbcrConversionComponents, + suggestedYcbcrModel, + suggestedYcbcrRange, + suggestedXChromaOffset, + suggestedYChromaOffset ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AndroidHardwareBufferFormatPropertiesANDROID const & ) const = default; +# else + bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) && + ( formatFeatures == rhs.formatFeatures ) && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && + ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && + ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); +# endif + } + + bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; + void * pNext = {}; + Format format = Format::eUndefined; + uint64_t externalFormat = {}; + FormatFeatureFlags formatFeatures = {}; + ComponentMapping samplerYcbcrConversionComponents = {}; + SamplerYcbcrModelConversion suggestedYcbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; + SamplerYcbcrRange suggestedYcbcrRange = SamplerYcbcrRange::eItuFull; + ChromaLocation suggestedXChromaOffset = ChromaLocation::eCositedEven; + ChromaLocation suggestedYChromaOffset = ChromaLocation::eCositedEven; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AndroidHardwareBufferFormatPropertiesANDROID; + }; +# endif + + template <> + struct CppType + { + using Type = AndroidHardwareBufferFormatPropertiesANDROID; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + // wrapper struct for struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatResolvePropertiesANDROID.html + struct AndroidHardwareBufferFormatResolvePropertiesANDROID + { + using NativeType = VkAndroidHardwareBufferFormatResolvePropertiesANDROID; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AndroidHardwareBufferFormatResolvePropertiesANDROID( Format colorAttachmentFormat_ = Format::eUndefined, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , colorAttachmentFormat{ colorAttachmentFormat_ } + { + } + + VULKAN_HPP_CONSTEXPR + AndroidHardwareBufferFormatResolvePropertiesANDROID( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AndroidHardwareBufferFormatResolvePropertiesANDROID( VkAndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + : AndroidHardwareBufferFormatResolvePropertiesANDROID( *reinterpret_cast( &rhs ) ) + { + } + + AndroidHardwareBufferFormatResolvePropertiesANDROID & + operator=( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AndroidHardwareBufferFormatResolvePropertiesANDROID & operator=( VkAndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorAttachmentFormat ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AndroidHardwareBufferFormatResolvePropertiesANDROID const & ) const = default; +# else + bool operator==( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentFormat == rhs.colorAttachmentFormat ); +# endif + } + + bool operator!=( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID; + void * pNext = {}; + Format colorAttachmentFormat = Format::eUndefined; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AndroidHardwareBufferFormatResolvePropertiesANDROID; + }; +# endif + + template <> + struct CppType + { + using Type = AndroidHardwareBufferFormatResolvePropertiesANDROID; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + // wrapper struct for struct VkAndroidHardwareBufferPropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferPropertiesANDROID.html + struct AndroidHardwareBufferPropertiesANDROID + { + using NativeType = VkAndroidHardwareBufferPropertiesANDROID; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferPropertiesANDROID; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + AndroidHardwareBufferPropertiesANDROID( DeviceSize allocationSize_ = {}, uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , allocationSize{ allocationSize_ } + , memoryTypeBits{ memoryTypeBits_ } + { + } + + VULKAN_HPP_CONSTEXPR AndroidHardwareBufferPropertiesANDROID( AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + : AndroidHardwareBufferPropertiesANDROID( *reinterpret_cast( &rhs ) ) + { + } + + AndroidHardwareBufferPropertiesANDROID & operator=( AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AndroidHardwareBufferPropertiesANDROID & operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkAndroidHardwareBufferPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferPropertiesANDROID &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferPropertiesANDROID const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferPropertiesANDROID *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allocationSize, memoryTypeBits ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AndroidHardwareBufferPropertiesANDROID const & ) const = default; +# else + bool operator==( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif + } + + bool operator!=( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID; + void * pNext = {}; + DeviceSize allocationSize = {}; + uint32_t memoryTypeBits = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AndroidHardwareBufferPropertiesANDROID; + }; +# endif + + template <> + struct CppType + { + using Type = AndroidHardwareBufferPropertiesANDROID; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + // wrapper struct for struct VkAndroidHardwareBufferUsageANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferUsageANDROID.html + struct AndroidHardwareBufferUsageANDROID + { + using NativeType = VkAndroidHardwareBufferUsageANDROID; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferUsageANDROID; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AndroidHardwareBufferUsageANDROID( uint64_t androidHardwareBufferUsage_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , androidHardwareBufferUsage{ androidHardwareBufferUsage_ } + { + } + + VULKAN_HPP_CONSTEXPR AndroidHardwareBufferUsageANDROID( AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + : AndroidHardwareBufferUsageANDROID( *reinterpret_cast( &rhs ) ) + { + } + + AndroidHardwareBufferUsageANDROID & operator=( AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AndroidHardwareBufferUsageANDROID & operator=( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkAndroidHardwareBufferUsageANDROID const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferUsageANDROID &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferUsageANDROID const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAndroidHardwareBufferUsageANDROID *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, androidHardwareBufferUsage ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AndroidHardwareBufferUsageANDROID const & ) const = default; +# else + bool operator==( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage ); +# endif + } + + bool operator!=( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID; + void * pNext = {}; + uint64_t androidHardwareBufferUsage = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AndroidHardwareBufferUsageANDROID; + }; +# endif + + template <> + struct CppType + { + using Type = AndroidHardwareBufferUsageANDROID; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + // wrapper struct for struct VkAndroidSurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidSurfaceCreateInfoKHR.html + struct AndroidSurfaceCreateInfoKHR + { + using NativeType = VkAndroidSurfaceCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidSurfaceCreateInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = {}, + struct ANativeWindow * window_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , window{ window_ } + { + } + + VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : AndroidSurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + AndroidSurfaceCreateInfoKHR & operator=( AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AndroidSurfaceCreateInfoKHR & operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR & setFlags( AndroidSurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR && setFlags( AndroidSurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR & setWindow( struct ANativeWindow * window_ ) & VULKAN_HPP_NOEXCEPT + { + window = window_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR && setWindow( struct ANativeWindow * window_ ) && VULKAN_HPP_NOEXCEPT + { + window = window_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAndroidSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAndroidSurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAndroidSurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, window ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AndroidSurfaceCreateInfoKHR const & ) const = default; +# else + bool operator==( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); +# endif + } + + bool operator!=( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR; + const void * pNext = {}; + AndroidSurfaceCreateFlagsKHR flags = {}; + struct ANativeWindow * window = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AndroidSurfaceCreateInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = AndroidSurfaceCreateInfoKHR; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + // wrapper struct for struct VkAntiLagPresentationInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagPresentationInfoAMD.html + struct AntiLagPresentationInfoAMD + { + using NativeType = VkAntiLagPresentationInfoAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAntiLagPresentationInfoAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + AntiLagPresentationInfoAMD( AntiLagStageAMD stage_ = AntiLagStageAMD::eInput, uint64_t frameIndex_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stage{ stage_ } + , frameIndex{ frameIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR AntiLagPresentationInfoAMD( AntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AntiLagPresentationInfoAMD( VkAntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : AntiLagPresentationInfoAMD( *reinterpret_cast( &rhs ) ) + { + } + + AntiLagPresentationInfoAMD & operator=( AntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AntiLagPresentationInfoAMD & operator=( VkAntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD & setStage( AntiLagStageAMD stage_ ) & VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD && setStage( AntiLagStageAMD stage_ ) && VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD & setFrameIndex( uint64_t frameIndex_ ) & VULKAN_HPP_NOEXCEPT + { + frameIndex = frameIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD && setFrameIndex( uint64_t frameIndex_ ) && VULKAN_HPP_NOEXCEPT + { + frameIndex = frameIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAntiLagPresentationInfoAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAntiLagPresentationInfoAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAntiLagPresentationInfoAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAntiLagPresentationInfoAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stage, frameIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AntiLagPresentationInfoAMD const & ) const = default; +#else + bool operator==( AntiLagPresentationInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && ( frameIndex == rhs.frameIndex ); +# endif + } + + bool operator!=( AntiLagPresentationInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAntiLagPresentationInfoAMD; + void * pNext = {}; + AntiLagStageAMD stage = AntiLagStageAMD::eInput; + uint64_t frameIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AntiLagPresentationInfoAMD; + }; +#endif + + template <> + struct CppType + { + using Type = AntiLagPresentationInfoAMD; + }; + + // wrapper struct for struct VkAntiLagDataAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagDataAMD.html + struct AntiLagDataAMD + { + using NativeType = VkAntiLagDataAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAntiLagDataAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AntiLagDataAMD( AntiLagModeAMD mode_ = AntiLagModeAMD::eDriverControl, + uint32_t maxFPS_ = {}, + const AntiLagPresentationInfoAMD * pPresentationInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , mode{ mode_ } + , maxFPS{ maxFPS_ } + , pPresentationInfo{ pPresentationInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR AntiLagDataAMD( AntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AntiLagDataAMD( VkAntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT : AntiLagDataAMD( *reinterpret_cast( &rhs ) ) {} + + AntiLagDataAMD & operator=( AntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AntiLagDataAMD & operator=( VkAntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setMode( AntiLagModeAMD mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setMode( AntiLagModeAMD mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setMaxFPS( uint32_t maxFPS_ ) & VULKAN_HPP_NOEXCEPT + { + maxFPS = maxFPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setMaxFPS( uint32_t maxFPS_ ) && VULKAN_HPP_NOEXCEPT + { + maxFPS = maxFPS_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setPPresentationInfo( const AntiLagPresentationInfoAMD * pPresentationInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pPresentationInfo = pPresentationInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setPPresentationInfo( const AntiLagPresentationInfoAMD * pPresentationInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pPresentationInfo = pPresentationInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAntiLagDataAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAntiLagDataAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAntiLagDataAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAntiLagDataAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mode, maxFPS, pPresentationInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AntiLagDataAMD const & ) const = default; +#else + bool operator==( AntiLagDataAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && ( maxFPS == rhs.maxFPS ) && + ( pPresentationInfo == rhs.pPresentationInfo ); +# endif + } + + bool operator!=( AntiLagDataAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAntiLagDataAMD; + const void * pNext = {}; + AntiLagModeAMD mode = AntiLagModeAMD::eDriverControl; + uint32_t maxFPS = {}; + const AntiLagPresentationInfoAMD * pPresentationInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AntiLagDataAMD; + }; +#endif + + template <> + struct CppType + { + using Type = AntiLagDataAMD; + }; + + // wrapper struct for struct VkApplicationInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkApplicationInfo.html + struct ApplicationInfo + { + using NativeType = VkApplicationInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eApplicationInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ApplicationInfo( const char * pApplicationName_ = {}, + uint32_t applicationVersion_ = {}, + const char * pEngineName_ = {}, + uint32_t engineVersion_ = {}, + uint32_t apiVersion_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pApplicationName{ pApplicationName_ } + , applicationVersion{ applicationVersion_ } + , pEngineName{ pEngineName_ } + , engineVersion{ engineVersion_ } + , apiVersion{ apiVersion_ } + { + } + + VULKAN_HPP_CONSTEXPR ApplicationInfo( ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ApplicationInfo( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT : ApplicationInfo( *reinterpret_cast( &rhs ) ) {} + + ApplicationInfo & operator=( ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ApplicationInfo & operator=( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setPApplicationName( const char * pApplicationName_ ) & VULKAN_HPP_NOEXCEPT + { + pApplicationName = pApplicationName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setPApplicationName( const char * pApplicationName_ ) && VULKAN_HPP_NOEXCEPT + { + pApplicationName = pApplicationName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setApplicationVersion( uint32_t applicationVersion_ ) & VULKAN_HPP_NOEXCEPT + { + applicationVersion = applicationVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setApplicationVersion( uint32_t applicationVersion_ ) && VULKAN_HPP_NOEXCEPT + { + applicationVersion = applicationVersion_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setPEngineName( const char * pEngineName_ ) & VULKAN_HPP_NOEXCEPT + { + pEngineName = pEngineName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setPEngineName( const char * pEngineName_ ) && VULKAN_HPP_NOEXCEPT + { + pEngineName = pEngineName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setEngineVersion( uint32_t engineVersion_ ) & VULKAN_HPP_NOEXCEPT + { + engineVersion = engineVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setEngineVersion( uint32_t engineVersion_ ) && VULKAN_HPP_NOEXCEPT + { + engineVersion = engineVersion_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setApiVersion( uint32_t apiVersion_ ) & VULKAN_HPP_NOEXCEPT + { + apiVersion = apiVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setApiVersion( uint32_t apiVersion_ ) && VULKAN_HPP_NOEXCEPT + { + apiVersion = apiVersion_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkApplicationInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkApplicationInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkApplicationInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkApplicationInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pApplicationName, applicationVersion, pEngineName, engineVersion, apiVersion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( pApplicationName != rhs.pApplicationName ) + if ( auto cmp = strcmp( pApplicationName, rhs.pApplicationName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = applicationVersion <=> rhs.applicationVersion; cmp != 0 ) + return cmp; + if ( pEngineName != rhs.pEngineName ) + if ( auto cmp = strcmp( pEngineName, rhs.pEngineName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = engineVersion <=> rhs.engineVersion; cmp != 0 ) + return cmp; + if ( auto cmp = apiVersion <=> rhs.apiVersion; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( ( pApplicationName == rhs.pApplicationName ) || ( strcmp( pApplicationName, rhs.pApplicationName ) == 0 ) ) && + ( applicationVersion == rhs.applicationVersion ) && ( ( pEngineName == rhs.pEngineName ) || ( strcmp( pEngineName, rhs.pEngineName ) == 0 ) ) && + ( engineVersion == rhs.engineVersion ) && ( apiVersion == rhs.apiVersion ); + } + + bool operator!=( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eApplicationInfo; + const void * pNext = {}; + const char * pApplicationName = {}; + uint32_t applicationVersion = {}; + const char * pEngineName = {}; + uint32_t engineVersion = {}; + uint32_t apiVersion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ApplicationInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ApplicationInfo; + }; + + // wrapper struct for struct VkAttachmentDescription, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescription.html + struct AttachmentDescription + { + using NativeType = VkAttachmentDescription; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AttachmentDescription( AttachmentDescriptionFlags flags_ = {}, + Format format_ = Format::eUndefined, + SampleCountFlagBits samples_ = SampleCountFlagBits::e1, + AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, + AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, + AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, + AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, + ImageLayout initialLayout_ = ImageLayout::eUndefined, + ImageLayout finalLayout_ = ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT + : flags{ flags_ } + , format{ format_ } + , samples{ samples_ } + , loadOp{ loadOp_ } + , storeOp{ storeOp_ } + , stencilLoadOp{ stencilLoadOp_ } + , stencilStoreOp{ stencilStoreOp_ } + , initialLayout{ initialLayout_ } + , finalLayout{ finalLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR AttachmentDescription( AttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AttachmentDescription( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT + : AttachmentDescription( *reinterpret_cast( &rhs ) ) + { + } + + AttachmentDescription & operator=( AttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AttachmentDescription & operator=( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setFlags( AttachmentDescriptionFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setFlags( AttachmentDescriptionFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setSamples( SampleCountFlagBits samples_ ) & VULKAN_HPP_NOEXCEPT + { + samples = samples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setSamples( SampleCountFlagBits samples_ ) && VULKAN_HPP_NOEXCEPT + { + samples = samples_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setLoadOp( AttachmentLoadOp loadOp_ ) & VULKAN_HPP_NOEXCEPT + { + loadOp = loadOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setLoadOp( AttachmentLoadOp loadOp_ ) && VULKAN_HPP_NOEXCEPT + { + loadOp = loadOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setStoreOp( AttachmentStoreOp storeOp_ ) & VULKAN_HPP_NOEXCEPT + { + storeOp = storeOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setStoreOp( AttachmentStoreOp storeOp_ ) && VULKAN_HPP_NOEXCEPT + { + storeOp = storeOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) & VULKAN_HPP_NOEXCEPT + { + stencilLoadOp = stencilLoadOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) && VULKAN_HPP_NOEXCEPT + { + stencilLoadOp = stencilLoadOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) & VULKAN_HPP_NOEXCEPT + { + stencilStoreOp = stencilStoreOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) && VULKAN_HPP_NOEXCEPT + { + stencilStoreOp = stencilStoreOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setInitialLayout( ImageLayout initialLayout_ ) & VULKAN_HPP_NOEXCEPT + { + initialLayout = initialLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setInitialLayout( ImageLayout initialLayout_ ) && VULKAN_HPP_NOEXCEPT + { + initialLayout = initialLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setFinalLayout( ImageLayout finalLayout_ ) & VULKAN_HPP_NOEXCEPT + { + finalLayout = finalLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setFinalLayout( ImageLayout finalLayout_ ) && VULKAN_HPP_NOEXCEPT + { + finalLayout = finalLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAttachmentDescription const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentDescription &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentDescription const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAttachmentDescription *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AttachmentDescription const & ) const = default; +#else + bool operator==( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) && ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && + ( stencilLoadOp == rhs.stencilLoadOp ) && ( stencilStoreOp == rhs.stencilStoreOp ) && ( initialLayout == rhs.initialLayout ) && + ( finalLayout == rhs.finalLayout ); +# endif + } + + bool operator!=( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + AttachmentDescriptionFlags flags = {}; + Format format = Format::eUndefined; + SampleCountFlagBits samples = SampleCountFlagBits::e1; + AttachmentLoadOp loadOp = AttachmentLoadOp::eLoad; + AttachmentStoreOp storeOp = AttachmentStoreOp::eStore; + AttachmentLoadOp stencilLoadOp = AttachmentLoadOp::eLoad; + AttachmentStoreOp stencilStoreOp = AttachmentStoreOp::eStore; + ImageLayout initialLayout = ImageLayout::eUndefined; + ImageLayout finalLayout = ImageLayout::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AttachmentDescription; + }; +#endif + + // wrapper struct for struct VkAttachmentDescription2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescription2.html + struct AttachmentDescription2 + { + using NativeType = VkAttachmentDescription2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentDescription2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AttachmentDescription2( AttachmentDescriptionFlags flags_ = {}, + Format format_ = Format::eUndefined, + SampleCountFlagBits samples_ = SampleCountFlagBits::e1, + AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, + AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, + AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, + AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, + ImageLayout initialLayout_ = ImageLayout::eUndefined, + ImageLayout finalLayout_ = ImageLayout::eUndefined, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , format{ format_ } + , samples{ samples_ } + , loadOp{ loadOp_ } + , storeOp{ storeOp_ } + , stencilLoadOp{ stencilLoadOp_ } + , stencilStoreOp{ stencilStoreOp_ } + , initialLayout{ initialLayout_ } + , finalLayout{ finalLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR AttachmentDescription2( AttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AttachmentDescription2( VkAttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT + : AttachmentDescription2( *reinterpret_cast( &rhs ) ) + { + } + + AttachmentDescription2 & operator=( AttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AttachmentDescription2 & operator=( VkAttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setFlags( AttachmentDescriptionFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setFlags( AttachmentDescriptionFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setSamples( SampleCountFlagBits samples_ ) & VULKAN_HPP_NOEXCEPT + { + samples = samples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setSamples( SampleCountFlagBits samples_ ) && VULKAN_HPP_NOEXCEPT + { + samples = samples_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setLoadOp( AttachmentLoadOp loadOp_ ) & VULKAN_HPP_NOEXCEPT + { + loadOp = loadOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setLoadOp( AttachmentLoadOp loadOp_ ) && VULKAN_HPP_NOEXCEPT + { + loadOp = loadOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setStoreOp( AttachmentStoreOp storeOp_ ) & VULKAN_HPP_NOEXCEPT + { + storeOp = storeOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setStoreOp( AttachmentStoreOp storeOp_ ) && VULKAN_HPP_NOEXCEPT + { + storeOp = storeOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) & VULKAN_HPP_NOEXCEPT + { + stencilLoadOp = stencilLoadOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) && VULKAN_HPP_NOEXCEPT + { + stencilLoadOp = stencilLoadOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) & VULKAN_HPP_NOEXCEPT + { + stencilStoreOp = stencilStoreOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) && VULKAN_HPP_NOEXCEPT + { + stencilStoreOp = stencilStoreOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setInitialLayout( ImageLayout initialLayout_ ) & VULKAN_HPP_NOEXCEPT + { + initialLayout = initialLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setInitialLayout( ImageLayout initialLayout_ ) && VULKAN_HPP_NOEXCEPT + { + initialLayout = initialLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setFinalLayout( ImageLayout finalLayout_ ) & VULKAN_HPP_NOEXCEPT + { + finalLayout = finalLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setFinalLayout( ImageLayout finalLayout_ ) && VULKAN_HPP_NOEXCEPT + { + finalLayout = finalLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAttachmentDescription2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentDescription2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentDescription2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAttachmentDescription2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AttachmentDescription2 const & ) const = default; +#else + bool operator==( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) && + ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && ( stencilLoadOp == rhs.stencilLoadOp ) && ( stencilStoreOp == rhs.stencilStoreOp ) && + ( initialLayout == rhs.initialLayout ) && ( finalLayout == rhs.finalLayout ); +# endif + } + + bool operator!=( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAttachmentDescription2; + const void * pNext = {}; + AttachmentDescriptionFlags flags = {}; + Format format = Format::eUndefined; + SampleCountFlagBits samples = SampleCountFlagBits::e1; + AttachmentLoadOp loadOp = AttachmentLoadOp::eLoad; + AttachmentStoreOp storeOp = AttachmentStoreOp::eStore; + AttachmentLoadOp stencilLoadOp = AttachmentLoadOp::eLoad; + AttachmentStoreOp stencilStoreOp = AttachmentStoreOp::eStore; + ImageLayout initialLayout = ImageLayout::eUndefined; + ImageLayout finalLayout = ImageLayout::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AttachmentDescription2; + }; +#endif + + template <> + struct CppType + { + using Type = AttachmentDescription2; + }; + + using AttachmentDescription2KHR = AttachmentDescription2; + + // wrapper struct for struct VkAttachmentDescriptionStencilLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescriptionStencilLayout.html + struct AttachmentDescriptionStencilLayout + { + using NativeType = VkAttachmentDescriptionStencilLayout; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentDescriptionStencilLayout; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayout( ImageLayout stencilInitialLayout_ = ImageLayout::eUndefined, + ImageLayout stencilFinalLayout_ = ImageLayout::eUndefined, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stencilInitialLayout{ stencilInitialLayout_ } + , stencilFinalLayout{ stencilFinalLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayout( AttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AttachmentDescriptionStencilLayout( VkAttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT + : AttachmentDescriptionStencilLayout( *reinterpret_cast( &rhs ) ) + { + } + + AttachmentDescriptionStencilLayout & operator=( AttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AttachmentDescriptionStencilLayout & operator=( VkAttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout & setStencilInitialLayout( ImageLayout stencilInitialLayout_ ) & VULKAN_HPP_NOEXCEPT + { + stencilInitialLayout = stencilInitialLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout && setStencilInitialLayout( ImageLayout stencilInitialLayout_ ) && VULKAN_HPP_NOEXCEPT + { + stencilInitialLayout = stencilInitialLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout & setStencilFinalLayout( ImageLayout stencilFinalLayout_ ) & VULKAN_HPP_NOEXCEPT + { + stencilFinalLayout = stencilFinalLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout && setStencilFinalLayout( ImageLayout stencilFinalLayout_ ) && VULKAN_HPP_NOEXCEPT + { + stencilFinalLayout = stencilFinalLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAttachmentDescriptionStencilLayout const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentDescriptionStencilLayout &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentDescriptionStencilLayout const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAttachmentDescriptionStencilLayout *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stencilInitialLayout, stencilFinalLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AttachmentDescriptionStencilLayout const & ) const = default; +#else + bool operator==( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilInitialLayout == rhs.stencilInitialLayout ) && + ( stencilFinalLayout == rhs.stencilFinalLayout ); +# endif + } + + bool operator!=( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAttachmentDescriptionStencilLayout; + void * pNext = {}; + ImageLayout stencilInitialLayout = ImageLayout::eUndefined; + ImageLayout stencilFinalLayout = ImageLayout::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AttachmentDescriptionStencilLayout; + }; +#endif + + template <> + struct CppType + { + using Type = AttachmentDescriptionStencilLayout; + }; + + using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout; + + // wrapper struct for struct VkAttachmentFeedbackLoopInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentFeedbackLoopInfoEXT.html + struct AttachmentFeedbackLoopInfoEXT + { + using NativeType = VkAttachmentFeedbackLoopInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentFeedbackLoopInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AttachmentFeedbackLoopInfoEXT( Bool32 feedbackLoopEnable_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , feedbackLoopEnable{ feedbackLoopEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR AttachmentFeedbackLoopInfoEXT( AttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AttachmentFeedbackLoopInfoEXT( VkAttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : AttachmentFeedbackLoopInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + AttachmentFeedbackLoopInfoEXT & operator=( AttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AttachmentFeedbackLoopInfoEXT & operator=( VkAttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT & setFeedbackLoopEnable( Bool32 feedbackLoopEnable_ ) & VULKAN_HPP_NOEXCEPT + { + feedbackLoopEnable = feedbackLoopEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT && setFeedbackLoopEnable( Bool32 feedbackLoopEnable_ ) && VULKAN_HPP_NOEXCEPT + { + feedbackLoopEnable = feedbackLoopEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAttachmentFeedbackLoopInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentFeedbackLoopInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentFeedbackLoopInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAttachmentFeedbackLoopInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, feedbackLoopEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AttachmentFeedbackLoopInfoEXT const & ) const = default; +#else + bool operator==( AttachmentFeedbackLoopInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( feedbackLoopEnable == rhs.feedbackLoopEnable ); +# endif + } + + bool operator!=( AttachmentFeedbackLoopInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAttachmentFeedbackLoopInfoEXT; + const void * pNext = {}; + Bool32 feedbackLoopEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AttachmentFeedbackLoopInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = AttachmentFeedbackLoopInfoEXT; + }; + + // wrapper struct for struct VkAttachmentReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentReference.html + struct AttachmentReference + { + using NativeType = VkAttachmentReference; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AttachmentReference( uint32_t attachment_ = {}, ImageLayout layout_ = ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT + : attachment{ attachment_ } + , layout{ layout_ } + { + } + + VULKAN_HPP_CONSTEXPR AttachmentReference( AttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AttachmentReference( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT : AttachmentReference( *reinterpret_cast( &rhs ) ) + { + } + + AttachmentReference & operator=( AttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AttachmentReference & operator=( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AttachmentReference & setAttachment( uint32_t attachment_ ) & VULKAN_HPP_NOEXCEPT + { + attachment = attachment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReference && setAttachment( uint32_t attachment_ ) && VULKAN_HPP_NOEXCEPT + { + attachment = attachment_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReference & setLayout( ImageLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReference && setLayout( ImageLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAttachmentReference const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentReference &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentReference const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAttachmentReference *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( attachment, layout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AttachmentReference const & ) const = default; +#else + bool operator==( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( attachment == rhs.attachment ) && ( layout == rhs.layout ); +# endif + } + + bool operator!=( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t attachment = {}; + ImageLayout layout = ImageLayout::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AttachmentReference; + }; +#endif + + // wrapper struct for struct VkAttachmentReference2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentReference2.html + struct AttachmentReference2 + { + using NativeType = VkAttachmentReference2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentReference2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AttachmentReference2( uint32_t attachment_ = {}, + ImageLayout layout_ = ImageLayout::eUndefined, + ImageAspectFlags aspectMask_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , attachment{ attachment_ } + , layout{ layout_ } + , aspectMask{ aspectMask_ } + { + } + + VULKAN_HPP_CONSTEXPR AttachmentReference2( AttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AttachmentReference2( VkAttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT + : AttachmentReference2( *reinterpret_cast( &rhs ) ) + { + } + + AttachmentReference2 & operator=( AttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AttachmentReference2 & operator=( VkAttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setAttachment( uint32_t attachment_ ) & VULKAN_HPP_NOEXCEPT + { + attachment = attachment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setAttachment( uint32_t attachment_ ) && VULKAN_HPP_NOEXCEPT + { + attachment = attachment_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setLayout( ImageLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setLayout( ImageLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAttachmentReference2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentReference2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentReference2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAttachmentReference2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachment, layout, aspectMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AttachmentReference2 const & ) const = default; +#else + bool operator==( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachment == rhs.attachment ) && ( layout == rhs.layout ) && + ( aspectMask == rhs.aspectMask ); +# endif + } + + bool operator!=( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAttachmentReference2; + const void * pNext = {}; + uint32_t attachment = {}; + ImageLayout layout = ImageLayout::eUndefined; + ImageAspectFlags aspectMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AttachmentReference2; + }; +#endif + + template <> + struct CppType + { + using Type = AttachmentReference2; + }; + + using AttachmentReference2KHR = AttachmentReference2; + + // wrapper struct for struct VkAttachmentReferenceStencilLayout, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentReferenceStencilLayout.html + struct AttachmentReferenceStencilLayout + { + using NativeType = VkAttachmentReferenceStencilLayout; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentReferenceStencilLayout; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayout( ImageLayout stencilLayout_ = ImageLayout::eUndefined, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stencilLayout{ stencilLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayout( AttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AttachmentReferenceStencilLayout( VkAttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT + : AttachmentReferenceStencilLayout( *reinterpret_cast( &rhs ) ) + { + } + + AttachmentReferenceStencilLayout & operator=( AttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AttachmentReferenceStencilLayout & operator=( VkAttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout & setStencilLayout( ImageLayout stencilLayout_ ) & VULKAN_HPP_NOEXCEPT + { + stencilLayout = stencilLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout && setStencilLayout( ImageLayout stencilLayout_ ) && VULKAN_HPP_NOEXCEPT + { + stencilLayout = stencilLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAttachmentReferenceStencilLayout const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentReferenceStencilLayout &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentReferenceStencilLayout const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAttachmentReferenceStencilLayout *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stencilLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AttachmentReferenceStencilLayout const & ) const = default; +#else + bool operator==( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilLayout == rhs.stencilLayout ); +# endif + } + + bool operator!=( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAttachmentReferenceStencilLayout; + void * pNext = {}; + ImageLayout stencilLayout = ImageLayout::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AttachmentReferenceStencilLayout; + }; +#endif + + template <> + struct CppType + { + using Type = AttachmentReferenceStencilLayout; + }; + + using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout; + + // wrapper struct for struct VkAttachmentSampleCountInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentSampleCountInfoAMD.html + struct AttachmentSampleCountInfoAMD + { + using NativeType = VkAttachmentSampleCountInfoAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentSampleCountInfoAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AttachmentSampleCountInfoAMD( uint32_t colorAttachmentCount_ = {}, + const SampleCountFlagBits * pColorAttachmentSamples_ = {}, + SampleCountFlagBits depthStencilAttachmentSamples_ = SampleCountFlagBits::e1, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , colorAttachmentCount{ colorAttachmentCount_ } + , pColorAttachmentSamples{ pColorAttachmentSamples_ } + , depthStencilAttachmentSamples{ depthStencilAttachmentSamples_ } + { + } + + VULKAN_HPP_CONSTEXPR AttachmentSampleCountInfoAMD( AttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AttachmentSampleCountInfoAMD( VkAttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : AttachmentSampleCountInfoAMD( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AttachmentSampleCountInfoAMD( ArrayProxyNoTemporaries const & colorAttachmentSamples_, + SampleCountFlagBits depthStencilAttachmentSamples_ = SampleCountFlagBits::e1, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , colorAttachmentCount( static_cast( colorAttachmentSamples_.size() ) ) + , pColorAttachmentSamples( colorAttachmentSamples_.data() ) + , depthStencilAttachmentSamples( depthStencilAttachmentSamples_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + AttachmentSampleCountInfoAMD & operator=( AttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AttachmentSampleCountInfoAMD & operator=( VkAttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setPColorAttachmentSamples( const SampleCountFlagBits * pColorAttachmentSamples_ ) & + VULKAN_HPP_NOEXCEPT + { + pColorAttachmentSamples = pColorAttachmentSamples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setPColorAttachmentSamples( const SampleCountFlagBits * pColorAttachmentSamples_ ) && + VULKAN_HPP_NOEXCEPT + { + pColorAttachmentSamples = pColorAttachmentSamples_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + AttachmentSampleCountInfoAMD & + setColorAttachmentSamples( ArrayProxyNoTemporaries const & colorAttachmentSamples_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( colorAttachmentSamples_.size() ); + pColorAttachmentSamples = colorAttachmentSamples_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setDepthStencilAttachmentSamples( SampleCountFlagBits depthStencilAttachmentSamples_ ) & + VULKAN_HPP_NOEXCEPT + { + depthStencilAttachmentSamples = depthStencilAttachmentSamples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setDepthStencilAttachmentSamples( SampleCountFlagBits depthStencilAttachmentSamples_ ) && + VULKAN_HPP_NOEXCEPT + { + depthStencilAttachmentSamples = depthStencilAttachmentSamples_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAttachmentSampleCountInfoAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentSampleCountInfoAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentSampleCountInfoAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAttachmentSampleCountInfoAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentSamples, depthStencilAttachmentSamples ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AttachmentSampleCountInfoAMD const & ) const = default; +#else + bool operator==( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && + ( pColorAttachmentSamples == rhs.pColorAttachmentSamples ) && ( depthStencilAttachmentSamples == rhs.depthStencilAttachmentSamples ); +# endif + } + + bool operator!=( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eAttachmentSampleCountInfoAMD; + const void * pNext = {}; + uint32_t colorAttachmentCount = {}; + const SampleCountFlagBits * pColorAttachmentSamples = {}; + SampleCountFlagBits depthStencilAttachmentSamples = SampleCountFlagBits::e1; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AttachmentSampleCountInfoAMD; + }; +#endif + + template <> + struct CppType + { + using Type = AttachmentSampleCountInfoAMD; + }; + + using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD; + + // wrapper struct for struct VkExtent2D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExtent2D.html + struct Extent2D + { + using NativeType = VkExtent2D; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR Extent2D( uint32_t width_ = {}, uint32_t height_ = {} ) VULKAN_HPP_NOEXCEPT + : width{ width_ } + , height{ height_ } + { + } + + VULKAN_HPP_CONSTEXPR Extent2D( Extent2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + Extent2D( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT : Extent2D( *reinterpret_cast( &rhs ) ) {} + + Extent2D & operator=( Extent2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + Extent2D & operator=( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 Extent2D & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT + { + width = width_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Extent2D && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT + { + width = width_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Extent2D & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT + { + height = height_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Extent2D && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT + { + height = height_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExtent2D const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExtent2D &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExtent2D const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExtent2D *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( width, height ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( Extent2D const & ) const = default; +#else + bool operator==( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( width == rhs.width ) && ( height == rhs.height ); +# endif + } + + bool operator!=( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t width = {}; + uint32_t height = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = Extent2D; + }; +#endif + + // wrapper struct for struct VkSampleLocationEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleLocationEXT.html + struct SampleLocationEXT + { + using NativeType = VkSampleLocationEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SampleLocationEXT( float x_ = {}, float y_ = {} ) VULKAN_HPP_NOEXCEPT + : x{ x_ } + , y{ y_ } + { + } + + VULKAN_HPP_CONSTEXPR SampleLocationEXT( SampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SampleLocationEXT( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT : SampleLocationEXT( *reinterpret_cast( &rhs ) ) {} + + SampleLocationEXT & operator=( SampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SampleLocationEXT & operator=( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT & setX( float x_ ) & VULKAN_HPP_NOEXCEPT + { + x = x_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT && setX( float x_ ) && VULKAN_HPP_NOEXCEPT + { + x = x_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT & setY( float y_ ) & VULKAN_HPP_NOEXCEPT + { + y = y_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT && setY( float y_ ) && VULKAN_HPP_NOEXCEPT + { + y = y_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSampleLocationEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSampleLocationEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSampleLocationEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSampleLocationEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SampleLocationEXT const & ) const = default; +#else + bool operator==( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ); +# endif + } + + bool operator!=( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + float x = {}; + float y = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SampleLocationEXT; + }; +#endif + + // wrapper struct for struct VkSampleLocationsInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleLocationsInfoEXT.html + struct SampleLocationsInfoEXT + { + using NativeType = VkSampleLocationsInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSampleLocationsInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1, + Extent2D sampleLocationGridSize_ = {}, + uint32_t sampleLocationsCount_ = {}, + const SampleLocationEXT * pSampleLocations_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , sampleLocationsPerPixel{ sampleLocationsPerPixel_ } + , sampleLocationGridSize{ sampleLocationGridSize_ } + , sampleLocationsCount{ sampleLocationsCount_ } + , pSampleLocations{ pSampleLocations_ } + { + } + + VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SampleLocationsInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_, + Extent2D sampleLocationGridSize_, + ArrayProxyNoTemporaries const & sampleLocations_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , sampleLocationsPerPixel( sampleLocationsPerPixel_ ) + , sampleLocationGridSize( sampleLocationGridSize_ ) + , sampleLocationsCount( static_cast( sampleLocations_.size() ) ) + , pSampleLocations( sampleLocations_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SampleLocationsInfoEXT & operator=( SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SampleLocationsInfoEXT & operator=( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ ) & VULKAN_HPP_NOEXCEPT + { + sampleLocationsPerPixel = sampleLocationsPerPixel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ ) && VULKAN_HPP_NOEXCEPT + { + sampleLocationsPerPixel = sampleLocationsPerPixel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setSampleLocationGridSize( Extent2D const & sampleLocationGridSize_ ) & VULKAN_HPP_NOEXCEPT + { + sampleLocationGridSize = sampleLocationGridSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setSampleLocationGridSize( Extent2D const & sampleLocationGridSize_ ) && VULKAN_HPP_NOEXCEPT + { + sampleLocationGridSize = sampleLocationGridSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setSampleLocationsCount( uint32_t sampleLocationsCount_ ) & VULKAN_HPP_NOEXCEPT + { + sampleLocationsCount = sampleLocationsCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setSampleLocationsCount( uint32_t sampleLocationsCount_ ) && VULKAN_HPP_NOEXCEPT + { + sampleLocationsCount = sampleLocationsCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setPSampleLocations( const SampleLocationEXT * pSampleLocations_ ) & VULKAN_HPP_NOEXCEPT + { + pSampleLocations = pSampleLocations_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setPSampleLocations( const SampleLocationEXT * pSampleLocations_ ) && VULKAN_HPP_NOEXCEPT + { + pSampleLocations = pSampleLocations_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SampleLocationsInfoEXT & setSampleLocations( ArrayProxyNoTemporaries const & sampleLocations_ ) VULKAN_HPP_NOEXCEPT + { + sampleLocationsCount = static_cast( sampleLocations_.size() ); + pSampleLocations = sampleLocations_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSampleLocationsInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSampleLocationsInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSampleLocationsInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSampleLocationsInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sampleLocationsPerPixel, sampleLocationGridSize, sampleLocationsCount, pSampleLocations ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SampleLocationsInfoEXT const & ) const = default; +#else + bool operator==( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) && + ( sampleLocationGridSize == rhs.sampleLocationGridSize ) && ( sampleLocationsCount == rhs.sampleLocationsCount ) && + ( pSampleLocations == rhs.pSampleLocations ); +# endif + } + + bool operator!=( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSampleLocationsInfoEXT; + const void * pNext = {}; + SampleCountFlagBits sampleLocationsPerPixel = SampleCountFlagBits::e1; + Extent2D sampleLocationGridSize = {}; + uint32_t sampleLocationsCount = {}; + const SampleLocationEXT * pSampleLocations = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SampleLocationsInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SampleLocationsInfoEXT; + }; + + // wrapper struct for struct VkAttachmentSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentSampleLocationsEXT.html + struct AttachmentSampleLocationsEXT + { + using NativeType = VkAttachmentSampleLocationsEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = {}, SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT + : attachmentIndex{ attachmentIndex_ } + , sampleLocationsInfo{ sampleLocationsInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( AttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : AttachmentSampleLocationsEXT( *reinterpret_cast( &rhs ) ) + { + } + + AttachmentSampleLocationsEXT & operator=( AttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + AttachmentSampleLocationsEXT & operator=( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT & setAttachmentIndex( uint32_t attachmentIndex_ ) & VULKAN_HPP_NOEXCEPT + { + attachmentIndex = attachmentIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT && setAttachmentIndex( uint32_t attachmentIndex_ ) && VULKAN_HPP_NOEXCEPT + { + attachmentIndex = attachmentIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT & setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) & VULKAN_HPP_NOEXCEPT + { + sampleLocationsInfo = sampleLocationsInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT && setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) && VULKAN_HPP_NOEXCEPT + { + sampleLocationsInfo = sampleLocationsInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkAttachmentSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkAttachmentSampleLocationsEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkAttachmentSampleLocationsEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( attachmentIndex, sampleLocationsInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( AttachmentSampleLocationsEXT const & ) const = default; +#else + bool operator==( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( attachmentIndex == rhs.attachmentIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); +# endif + } + + bool operator!=( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t attachmentIndex = {}; + SampleLocationsInfoEXT sampleLocationsInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = AttachmentSampleLocationsEXT; + }; +#endif + + // wrapper struct for struct VkBaseInStructure, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBaseInStructure.html + struct BaseInStructure + { + using NativeType = VkBaseInStructure; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + BaseInStructure( StructureType sType_ = StructureType::eApplicationInfo, const struct BaseInStructure * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : sType{ sType_ } + , pNext{ pNext_ } + { + } + + BaseInStructure( BaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT : BaseInStructure( *reinterpret_cast( &rhs ) ) {} + + BaseInStructure & operator=( BaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BaseInStructure & operator=( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BaseInStructure & setPNext( const struct BaseInStructure * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BaseInStructure && setPNext( const struct BaseInStructure * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBaseInStructure const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBaseInStructure &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBaseInStructure const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBaseInStructure *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BaseInStructure const & ) const = default; +#else + bool operator==( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eApplicationInfo; + const struct BaseInStructure * pNext = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BaseInStructure; + }; +#endif + + // wrapper struct for struct VkBaseOutStructure, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBaseOutStructure.html + struct BaseOutStructure + { + using NativeType = VkBaseOutStructure; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + BaseOutStructure( StructureType sType_ = StructureType::eApplicationInfo, struct BaseOutStructure * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : sType{ sType_ } + , pNext{ pNext_ } + { + } + + BaseOutStructure( BaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT : BaseOutStructure( *reinterpret_cast( &rhs ) ) {} + + BaseOutStructure & operator=( BaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BaseOutStructure & operator=( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BaseOutStructure & setPNext( struct BaseOutStructure * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BaseOutStructure && setPNext( struct BaseOutStructure * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBaseOutStructure const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBaseOutStructure &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBaseOutStructure const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBaseOutStructure *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BaseOutStructure const & ) const = default; +#else + bool operator==( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eApplicationInfo; + struct BaseOutStructure * pNext = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BaseOutStructure; + }; +#endif + + // wrapper struct for struct VkBeginCustomResolveInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBeginCustomResolveInfoEXT.html + struct BeginCustomResolveInfoEXT + { + using NativeType = VkBeginCustomResolveInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBeginCustomResolveInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BeginCustomResolveInfoEXT( void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} + + VULKAN_HPP_CONSTEXPR BeginCustomResolveInfoEXT( BeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BeginCustomResolveInfoEXT( VkBeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : BeginCustomResolveInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + BeginCustomResolveInfoEXT & operator=( BeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BeginCustomResolveInfoEXT & operator=( VkBeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BeginCustomResolveInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BeginCustomResolveInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBeginCustomResolveInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBeginCustomResolveInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBeginCustomResolveInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBeginCustomResolveInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BeginCustomResolveInfoEXT const & ) const = default; +#else + bool operator==( BeginCustomResolveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( BeginCustomResolveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBeginCustomResolveInfoEXT; + void * pNext = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BeginCustomResolveInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = BeginCustomResolveInfoEXT; + }; + + // wrapper struct for struct VkBindAccelerationStructureMemoryInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindAccelerationStructureMemoryInfoNV.html + struct BindAccelerationStructureMemoryInfoNV + { + using NativeType = VkBindAccelerationStructureMemoryInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindAccelerationStructureMemoryInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_ = {}, + DeviceMemory memory_ = {}, + DeviceSize memoryOffset_ = {}, + uint32_t deviceIndexCount_ = {}, + const uint32_t * pDeviceIndices_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , accelerationStructure{ accelerationStructure_ } + , memory{ memory_ } + , memoryOffset{ memoryOffset_ } + , deviceIndexCount{ deviceIndexCount_ } + , pDeviceIndices{ pDeviceIndices_ } + { + } + + VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( BindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : BindAccelerationStructureMemoryInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_, + DeviceMemory memory_, + DeviceSize memoryOffset_, + ArrayProxyNoTemporaries const & deviceIndices_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , accelerationStructure( accelerationStructure_ ) + , memory( memory_ ) + , memoryOffset( memoryOffset_ ) + , deviceIndexCount( static_cast( deviceIndices_.size() ) ) + , pDeviceIndices( deviceIndices_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + BindAccelerationStructureMemoryInfoNV & operator=( BindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindAccelerationStructureMemoryInfoNV & operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setDeviceIndexCount( uint32_t deviceIndexCount_ ) & VULKAN_HPP_NOEXCEPT + { + deviceIndexCount = deviceIndexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setDeviceIndexCount( uint32_t deviceIndexCount_ ) && VULKAN_HPP_NOEXCEPT + { + deviceIndexCount = deviceIndexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setPDeviceIndices( const uint32_t * pDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pDeviceIndices = pDeviceIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setPDeviceIndices( const uint32_t * pDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pDeviceIndices = pDeviceIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindAccelerationStructureMemoryInfoNV & setDeviceIndices( ArrayProxyNoTemporaries const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT + { + deviceIndexCount = static_cast( deviceIndices_.size() ); + pDeviceIndices = deviceIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindAccelerationStructureMemoryInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindAccelerationStructureMemoryInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindAccelerationStructureMemoryInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindAccelerationStructureMemoryInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructure, memory, memoryOffset, deviceIndexCount, pDeviceIndices ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindAccelerationStructureMemoryInfoNV const & ) const = default; +#else + bool operator==( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ) && ( memory == rhs.memory ) && + ( memoryOffset == rhs.memoryOffset ) && ( deviceIndexCount == rhs.deviceIndexCount ) && ( pDeviceIndices == rhs.pDeviceIndices ); +# endif + } + + bool operator!=( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV; + const void * pNext = {}; + AccelerationStructureNV accelerationStructure = {}; + DeviceMemory memory = {}; + DeviceSize memoryOffset = {}; + uint32_t deviceIndexCount = {}; + const uint32_t * pDeviceIndices = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindAccelerationStructureMemoryInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = BindAccelerationStructureMemoryInfoNV; + }; + + // wrapper struct for struct VkBindBufferMemoryDeviceGroupInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindBufferMemoryDeviceGroupInfo.html + struct BindBufferMemoryDeviceGroupInfo + { + using NativeType = VkBindBufferMemoryDeviceGroupInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindBufferMemoryDeviceGroupInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = {}, + const uint32_t * pDeviceIndices_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceIndexCount{ deviceIndexCount_ } + , pDeviceIndices{ pDeviceIndices_ } + { + } + + VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : BindBufferMemoryDeviceGroupInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindBufferMemoryDeviceGroupInfo( ArrayProxyNoTemporaries const & deviceIndices_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), deviceIndexCount( static_cast( deviceIndices_.size() ) ), pDeviceIndices( deviceIndices_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + BindBufferMemoryDeviceGroupInfo & operator=( BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindBufferMemoryDeviceGroupInfo & operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo & setDeviceIndexCount( uint32_t deviceIndexCount_ ) & VULKAN_HPP_NOEXCEPT + { + deviceIndexCount = deviceIndexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo && setDeviceIndexCount( uint32_t deviceIndexCount_ ) && VULKAN_HPP_NOEXCEPT + { + deviceIndexCount = deviceIndexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo & setPDeviceIndices( const uint32_t * pDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pDeviceIndices = pDeviceIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo && setPDeviceIndices( const uint32_t * pDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pDeviceIndices = pDeviceIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindBufferMemoryDeviceGroupInfo & setDeviceIndices( ArrayProxyNoTemporaries const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT + { + deviceIndexCount = static_cast( deviceIndices_.size() ); + pDeviceIndices = deviceIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindBufferMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindBufferMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindBufferMemoryDeviceGroupInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindBufferMemoryDeviceGroupInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindBufferMemoryDeviceGroupInfo const & ) const = default; +#else + bool operator==( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && ( pDeviceIndices == rhs.pDeviceIndices ); +# endif + } + + bool operator!=( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo; + const void * pNext = {}; + uint32_t deviceIndexCount = {}; + const uint32_t * pDeviceIndices = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindBufferMemoryDeviceGroupInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BindBufferMemoryDeviceGroupInfo; + }; + + using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo; + + // wrapper struct for struct VkBindBufferMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindBufferMemoryInfo.html + struct BindBufferMemoryInfo + { + using NativeType = VkBindBufferMemoryInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindBufferMemoryInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + BindBufferMemoryInfo( Buffer buffer_ = {}, DeviceMemory memory_ = {}, DeviceSize memoryOffset_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , buffer{ buffer_ } + , memory{ memory_ } + , memoryOffset{ memoryOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : BindBufferMemoryInfo( *reinterpret_cast( &rhs ) ) + { + } + + BindBufferMemoryInfo & operator=( BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindBufferMemoryInfo & operator=( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindBufferMemoryInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindBufferMemoryInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindBufferMemoryInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindBufferMemoryInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer, memory, memoryOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindBufferMemoryInfo const & ) const = default; +#else + bool operator==( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ); +# endif + } + + bool operator!=( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindBufferMemoryInfo; + const void * pNext = {}; + Buffer buffer = {}; + DeviceMemory memory = {}; + DeviceSize memoryOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindBufferMemoryInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BindBufferMemoryInfo; + }; + + using BindBufferMemoryInfoKHR = BindBufferMemoryInfo; + + // wrapper struct for struct VkBindDataGraphPipelineSessionMemoryInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindDataGraphPipelineSessionMemoryInfoARM.html + struct BindDataGraphPipelineSessionMemoryInfoARM + { + using NativeType = VkBindDataGraphPipelineSessionMemoryInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindDataGraphPipelineSessionMemoryInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + BindDataGraphPipelineSessionMemoryInfoARM( DataGraphPipelineSessionARM session_ = {}, + DataGraphPipelineSessionBindPointARM bindPoint_ = DataGraphPipelineSessionBindPointARM::eTransient, + uint32_t objectIndex_ = {}, + DeviceMemory memory_ = {}, + DeviceSize memoryOffset_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , session{ session_ } + , bindPoint{ bindPoint_ } + , objectIndex{ objectIndex_ } + , memory{ memory_ } + , memoryOffset{ memoryOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR BindDataGraphPipelineSessionMemoryInfoARM( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindDataGraphPipelineSessionMemoryInfoARM( VkBindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : BindDataGraphPipelineSessionMemoryInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + BindDataGraphPipelineSessionMemoryInfoARM & operator=( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindDataGraphPipelineSessionMemoryInfoARM & operator=( VkBindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setSession( DataGraphPipelineSessionARM session_ ) & VULKAN_HPP_NOEXCEPT + { + session = session_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setSession( DataGraphPipelineSessionARM session_ ) && VULKAN_HPP_NOEXCEPT + { + session = session_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) & VULKAN_HPP_NOEXCEPT + { + bindPoint = bindPoint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) && VULKAN_HPP_NOEXCEPT + { + bindPoint = bindPoint_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setObjectIndex( uint32_t objectIndex_ ) & VULKAN_HPP_NOEXCEPT + { + objectIndex = objectIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setObjectIndex( uint32_t objectIndex_ ) && VULKAN_HPP_NOEXCEPT + { + objectIndex = objectIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindDataGraphPipelineSessionMemoryInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindDataGraphPipelineSessionMemoryInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindDataGraphPipelineSessionMemoryInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindDataGraphPipelineSessionMemoryInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, session, bindPoint, objectIndex, memory, memoryOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindDataGraphPipelineSessionMemoryInfoARM const & ) const = default; +#else + bool operator==( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( session == rhs.session ) && ( bindPoint == rhs.bindPoint ) && + ( objectIndex == rhs.objectIndex ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ); +# endif + } + + bool operator!=( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindDataGraphPipelineSessionMemoryInfoARM; + const void * pNext = {}; + DataGraphPipelineSessionARM session = {}; + DataGraphPipelineSessionBindPointARM bindPoint = DataGraphPipelineSessionBindPointARM::eTransient; + uint32_t objectIndex = {}; + DeviceMemory memory = {}; + DeviceSize memoryOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindDataGraphPipelineSessionMemoryInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = BindDataGraphPipelineSessionMemoryInfoARM; + }; + + // wrapper struct for struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindDescriptorBufferEmbeddedSamplersInfoEXT.html + struct BindDescriptorBufferEmbeddedSamplersInfoEXT + { + using NativeType = VkBindDescriptorBufferEmbeddedSamplersInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindDescriptorBufferEmbeddedSamplersInfoEXT( ShaderStageFlags stageFlags_ = {}, + PipelineLayout layout_ = {}, + uint32_t set_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stageFlags{ stageFlags_ } + , layout{ layout_ } + , set{ set_ } + { + } + + VULKAN_HPP_CONSTEXPR BindDescriptorBufferEmbeddedSamplersInfoEXT( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindDescriptorBufferEmbeddedSamplersInfoEXT( VkBindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : BindDescriptorBufferEmbeddedSamplersInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + BindDescriptorBufferEmbeddedSamplersInfoEXT & operator=( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindDescriptorBufferEmbeddedSamplersInfoEXT & operator=( VkBindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT + { + set = set_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT + { + set = set_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stageFlags, layout, set ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindDescriptorBufferEmbeddedSamplersInfoEXT const & ) const = default; +#else + bool operator==( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( set == rhs.set ); +# endif + } + + bool operator!=( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT; + const void * pNext = {}; + ShaderStageFlags stageFlags = {}; + PipelineLayout layout = {}; + uint32_t set = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindDescriptorBufferEmbeddedSamplersInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = BindDescriptorBufferEmbeddedSamplersInfoEXT; + }; + + // wrapper struct for struct VkBindDescriptorSetsInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindDescriptorSetsInfo.html + struct BindDescriptorSetsInfo + { + using NativeType = VkBindDescriptorSetsInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindDescriptorSetsInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindDescriptorSetsInfo( ShaderStageFlags stageFlags_ = {}, + PipelineLayout layout_ = {}, + uint32_t firstSet_ = {}, + uint32_t descriptorSetCount_ = {}, + const DescriptorSet * pDescriptorSets_ = {}, + uint32_t dynamicOffsetCount_ = {}, + const uint32_t * pDynamicOffsets_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stageFlags{ stageFlags_ } + , layout{ layout_ } + , firstSet{ firstSet_ } + , descriptorSetCount{ descriptorSetCount_ } + , pDescriptorSets{ pDescriptorSets_ } + , dynamicOffsetCount{ dynamicOffsetCount_ } + , pDynamicOffsets{ pDynamicOffsets_ } + { + } + + VULKAN_HPP_CONSTEXPR BindDescriptorSetsInfo( BindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindDescriptorSetsInfo( VkBindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : BindDescriptorSetsInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindDescriptorSetsInfo( ShaderStageFlags stageFlags_, + PipelineLayout layout_, + uint32_t firstSet_, + ArrayProxyNoTemporaries const & descriptorSets_, + ArrayProxyNoTemporaries const & dynamicOffsets_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , stageFlags( stageFlags_ ) + , layout( layout_ ) + , firstSet( firstSet_ ) + , descriptorSetCount( static_cast( descriptorSets_.size() ) ) + , pDescriptorSets( descriptorSets_.data() ) + , dynamicOffsetCount( static_cast( dynamicOffsets_.size() ) ) + , pDynamicOffsets( dynamicOffsets_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + BindDescriptorSetsInfo & operator=( BindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindDescriptorSetsInfo & operator=( VkBindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setFirstSet( uint32_t firstSet_ ) & VULKAN_HPP_NOEXCEPT + { + firstSet = firstSet_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setFirstSet( uint32_t firstSet_ ) && VULKAN_HPP_NOEXCEPT + { + firstSet = firstSet_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setDescriptorSetCount( uint32_t descriptorSetCount_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorSetCount = descriptorSetCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setDescriptorSetCount( uint32_t descriptorSetCount_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorSetCount = descriptorSetCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setPDescriptorSets( const DescriptorSet * pDescriptorSets_ ) & VULKAN_HPP_NOEXCEPT + { + pDescriptorSets = pDescriptorSets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setPDescriptorSets( const DescriptorSet * pDescriptorSets_ ) && VULKAN_HPP_NOEXCEPT + { + pDescriptorSets = pDescriptorSets_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindDescriptorSetsInfo & setDescriptorSets( ArrayProxyNoTemporaries const & descriptorSets_ ) VULKAN_HPP_NOEXCEPT + { + descriptorSetCount = static_cast( descriptorSets_.size() ); + pDescriptorSets = descriptorSets_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setDynamicOffsetCount( uint32_t dynamicOffsetCount_ ) & VULKAN_HPP_NOEXCEPT + { + dynamicOffsetCount = dynamicOffsetCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setDynamicOffsetCount( uint32_t dynamicOffsetCount_ ) && VULKAN_HPP_NOEXCEPT + { + dynamicOffsetCount = dynamicOffsetCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setPDynamicOffsets( const uint32_t * pDynamicOffsets_ ) & VULKAN_HPP_NOEXCEPT + { + pDynamicOffsets = pDynamicOffsets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setPDynamicOffsets( const uint32_t * pDynamicOffsets_ ) && VULKAN_HPP_NOEXCEPT + { + pDynamicOffsets = pDynamicOffsets_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindDescriptorSetsInfo & setDynamicOffsets( ArrayProxyNoTemporaries const & dynamicOffsets_ ) VULKAN_HPP_NOEXCEPT + { + dynamicOffsetCount = static_cast( dynamicOffsets_.size() ); + pDynamicOffsets = dynamicOffsets_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindDescriptorSetsInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindDescriptorSetsInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindDescriptorSetsInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindDescriptorSetsInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stageFlags, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindDescriptorSetsInfo const & ) const = default; +#else + bool operator==( BindDescriptorSetsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( firstSet == rhs.firstSet ) && + ( descriptorSetCount == rhs.descriptorSetCount ) && ( pDescriptorSets == rhs.pDescriptorSets ) && + ( dynamicOffsetCount == rhs.dynamicOffsetCount ) && ( pDynamicOffsets == rhs.pDynamicOffsets ); +# endif + } + + bool operator!=( BindDescriptorSetsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindDescriptorSetsInfo; + const void * pNext = {}; + ShaderStageFlags stageFlags = {}; + PipelineLayout layout = {}; + uint32_t firstSet = {}; + uint32_t descriptorSetCount = {}; + const DescriptorSet * pDescriptorSets = {}; + uint32_t dynamicOffsetCount = {}; + const uint32_t * pDynamicOffsets = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindDescriptorSetsInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BindDescriptorSetsInfo; + }; + + using BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo; + + // wrapper struct for struct VkDeviceAddressRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressRangeEXT.html + struct DeviceAddressRangeEXT + { + using NativeType = VkDeviceAddressRangeEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceAddressRangeEXT( DeviceAddress address_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT + : address{ address_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceAddressRangeEXT( DeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceAddressRangeEXT( VkDeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceAddressRangeEXT( *reinterpret_cast( &rhs ) ) + { + } + + DeviceAddressRangeEXT & operator=( DeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceAddressRangeEXT & operator=( VkDeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT + { + address = address_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT + { + address = address_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceAddressRangeEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceAddressRangeEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceAddressRangeEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceAddressRangeEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( address, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceAddressRangeEXT const & ) const = default; +#else + bool operator==( DeviceAddressRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( address == rhs.address ) && ( size == rhs.size ); +# endif + } + + bool operator!=( DeviceAddressRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress address = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceAddressRangeEXT; + }; +#endif + + // wrapper struct for struct VkBindHeapInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindHeapInfoEXT.html + struct BindHeapInfoEXT + { + using NativeType = VkBindHeapInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindHeapInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindHeapInfoEXT( DeviceAddressRangeEXT heapRange_ = {}, + DeviceSize reservedRangeOffset_ = {}, + DeviceSize reservedRangeSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , heapRange{ heapRange_ } + , reservedRangeOffset{ reservedRangeOffset_ } + , reservedRangeSize{ reservedRangeSize_ } + { + } + + VULKAN_HPP_CONSTEXPR BindHeapInfoEXT( BindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindHeapInfoEXT( VkBindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : BindHeapInfoEXT( *reinterpret_cast( &rhs ) ) {} + + BindHeapInfoEXT & operator=( BindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindHeapInfoEXT & operator=( VkBindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setHeapRange( DeviceAddressRangeEXT const & heapRange_ ) & VULKAN_HPP_NOEXCEPT + { + heapRange = heapRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setHeapRange( DeviceAddressRangeEXT const & heapRange_ ) && VULKAN_HPP_NOEXCEPT + { + heapRange = heapRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setReservedRangeOffset( DeviceSize reservedRangeOffset_ ) & VULKAN_HPP_NOEXCEPT + { + reservedRangeOffset = reservedRangeOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setReservedRangeOffset( DeviceSize reservedRangeOffset_ ) && VULKAN_HPP_NOEXCEPT + { + reservedRangeOffset = reservedRangeOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setReservedRangeSize( DeviceSize reservedRangeSize_ ) & VULKAN_HPP_NOEXCEPT + { + reservedRangeSize = reservedRangeSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setReservedRangeSize( DeviceSize reservedRangeSize_ ) && VULKAN_HPP_NOEXCEPT + { + reservedRangeSize = reservedRangeSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindHeapInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindHeapInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindHeapInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindHeapInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, heapRange, reservedRangeOffset, reservedRangeSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindHeapInfoEXT const & ) const = default; +#else + bool operator==( BindHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapRange == rhs.heapRange ) && ( reservedRangeOffset == rhs.reservedRangeOffset ) && + ( reservedRangeSize == rhs.reservedRangeSize ); +# endif + } + + bool operator!=( BindHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindHeapInfoEXT; + const void * pNext = {}; + DeviceAddressRangeEXT heapRange = {}; + DeviceSize reservedRangeOffset = {}; + DeviceSize reservedRangeSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindHeapInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = BindHeapInfoEXT; + }; + + // wrapper struct for struct VkOffset2D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOffset2D.html + struct Offset2D + { + using NativeType = VkOffset2D; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR Offset2D( int32_t x_ = {}, int32_t y_ = {} ) VULKAN_HPP_NOEXCEPT + : x{ x_ } + , y{ y_ } + { + } + + VULKAN_HPP_CONSTEXPR Offset2D( Offset2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + Offset2D( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT : Offset2D( *reinterpret_cast( &rhs ) ) {} + + Offset2D & operator=( Offset2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + Offset2D & operator=( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 Offset2D & setX( int32_t x_ ) & VULKAN_HPP_NOEXCEPT + { + x = x_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Offset2D && setX( int32_t x_ ) && VULKAN_HPP_NOEXCEPT + { + x = x_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Offset2D & setY( int32_t y_ ) & VULKAN_HPP_NOEXCEPT + { + y = y_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Offset2D && setY( int32_t y_ ) && VULKAN_HPP_NOEXCEPT + { + y = y_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkOffset2D const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOffset2D &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOffset2D const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkOffset2D *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( Offset2D const & ) const = default; +#else + bool operator==( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ); +# endif + } + + bool operator!=( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + int32_t x = {}; + int32_t y = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = Offset2D; + }; +#endif + + // wrapper struct for struct VkRect2D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRect2D.html + struct Rect2D + { + using NativeType = VkRect2D; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR Rect2D( Offset2D offset_ = {}, Extent2D extent_ = {} ) VULKAN_HPP_NOEXCEPT + : offset{ offset_ } + , extent{ extent_ } + { + } + + VULKAN_HPP_CONSTEXPR Rect2D( Rect2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + Rect2D( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT : Rect2D( *reinterpret_cast( &rhs ) ) {} + + Rect2D & operator=( Rect2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + Rect2D & operator=( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 Rect2D & setOffset( Offset2D const & offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Rect2D && setOffset( Offset2D const & offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Rect2D & setExtent( Extent2D const & extent_ ) & VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Rect2D && setExtent( Extent2D const & extent_ ) && VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRect2D const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRect2D &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRect2D const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRect2D *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( offset, extent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( Rect2D const & ) const = default; +#else + bool operator==( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( offset == rhs.offset ) && ( extent == rhs.extent ); +# endif + } + + bool operator!=( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Offset2D offset = {}; + Extent2D extent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = Rect2D; + }; +#endif + + // wrapper struct for struct VkBindImageMemoryDeviceGroupInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImageMemoryDeviceGroupInfo.html + struct BindImageMemoryDeviceGroupInfo + { + using NativeType = VkBindImageMemoryDeviceGroupInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemoryDeviceGroupInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = {}, + const uint32_t * pDeviceIndices_ = {}, + uint32_t splitInstanceBindRegionCount_ = {}, + const Rect2D * pSplitInstanceBindRegions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceIndexCount{ deviceIndexCount_ } + , pDeviceIndices{ pDeviceIndices_ } + , splitInstanceBindRegionCount{ splitInstanceBindRegionCount_ } + , pSplitInstanceBindRegions{ pSplitInstanceBindRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : BindImageMemoryDeviceGroupInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindImageMemoryDeviceGroupInfo( ArrayProxyNoTemporaries const & deviceIndices_, + ArrayProxyNoTemporaries const & splitInstanceBindRegions_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , deviceIndexCount( static_cast( deviceIndices_.size() ) ) + , pDeviceIndices( deviceIndices_.data() ) + , splitInstanceBindRegionCount( static_cast( splitInstanceBindRegions_.size() ) ) + , pSplitInstanceBindRegions( splitInstanceBindRegions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + BindImageMemoryDeviceGroupInfo & operator=( BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindImageMemoryDeviceGroupInfo & operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setDeviceIndexCount( uint32_t deviceIndexCount_ ) & VULKAN_HPP_NOEXCEPT + { + deviceIndexCount = deviceIndexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setDeviceIndexCount( uint32_t deviceIndexCount_ ) && VULKAN_HPP_NOEXCEPT + { + deviceIndexCount = deviceIndexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setPDeviceIndices( const uint32_t * pDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pDeviceIndices = pDeviceIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setPDeviceIndices( const uint32_t * pDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pDeviceIndices = pDeviceIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindImageMemoryDeviceGroupInfo & setDeviceIndices( ArrayProxyNoTemporaries const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT + { + deviceIndexCount = static_cast( deviceIndices_.size() ); + pDeviceIndices = deviceIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setSplitInstanceBindRegionCount( uint32_t splitInstanceBindRegionCount_ ) & VULKAN_HPP_NOEXCEPT + { + splitInstanceBindRegionCount = splitInstanceBindRegionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setSplitInstanceBindRegionCount( uint32_t splitInstanceBindRegionCount_ ) && VULKAN_HPP_NOEXCEPT + { + splitInstanceBindRegionCount = splitInstanceBindRegionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setPSplitInstanceBindRegions( const Rect2D * pSplitInstanceBindRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pSplitInstanceBindRegions = pSplitInstanceBindRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setPSplitInstanceBindRegions( const Rect2D * pSplitInstanceBindRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pSplitInstanceBindRegions = pSplitInstanceBindRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindImageMemoryDeviceGroupInfo & setSplitInstanceBindRegions( ArrayProxyNoTemporaries const & splitInstanceBindRegions_ ) VULKAN_HPP_NOEXCEPT + { + splitInstanceBindRegionCount = static_cast( splitInstanceBindRegions_.size() ); + pSplitInstanceBindRegions = splitInstanceBindRegions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindImageMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindImageMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindImageMemoryDeviceGroupInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindImageMemoryDeviceGroupInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices, splitInstanceBindRegionCount, pSplitInstanceBindRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindImageMemoryDeviceGroupInfo const & ) const = default; +#else + bool operator==( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && ( pDeviceIndices == rhs.pDeviceIndices ) && + ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount ) && ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions ); +# endif + } + + bool operator!=( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo; + const void * pNext = {}; + uint32_t deviceIndexCount = {}; + const uint32_t * pDeviceIndices = {}; + uint32_t splitInstanceBindRegionCount = {}; + const Rect2D * pSplitInstanceBindRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindImageMemoryDeviceGroupInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BindImageMemoryDeviceGroupInfo; + }; + + using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo; + + // wrapper struct for struct VkBindImageMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImageMemoryInfo.html + struct BindImageMemoryInfo + { + using NativeType = VkBindImageMemoryInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemoryInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + BindImageMemoryInfo( Image image_ = {}, DeviceMemory memory_ = {}, DeviceSize memoryOffset_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image{ image_ } + , memory{ memory_ } + , memoryOffset{ memoryOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT : BindImageMemoryInfo( *reinterpret_cast( &rhs ) ) + { + } + + BindImageMemoryInfo & operator=( BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindImageMemoryInfo & operator=( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindImageMemoryInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindImageMemoryInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindImageMemoryInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindImageMemoryInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, memory, memoryOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindImageMemoryInfo const & ) const = default; +#else + bool operator==( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ); +# endif + } + + bool operator!=( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindImageMemoryInfo; + const void * pNext = {}; + Image image = {}; + DeviceMemory memory = {}; + DeviceSize memoryOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindImageMemoryInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BindImageMemoryInfo; + }; + + using BindImageMemoryInfoKHR = BindImageMemoryInfo; + + // wrapper struct for struct VkBindImageMemorySwapchainInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImageMemorySwapchainInfoKHR.html + struct BindImageMemorySwapchainInfoKHR + { + using NativeType = VkBindImageMemorySwapchainInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemorySwapchainInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + BindImageMemorySwapchainInfoKHR( SwapchainKHR swapchain_ = {}, uint32_t imageIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchain{ swapchain_ } + , imageIndex{ imageIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : BindImageMemorySwapchainInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + BindImageMemorySwapchainInfoKHR & operator=( BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindImageMemorySwapchainInfoKHR & operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR & setImageIndex( uint32_t imageIndex_ ) & VULKAN_HPP_NOEXCEPT + { + imageIndex = imageIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR && setImageIndex( uint32_t imageIndex_ ) && VULKAN_HPP_NOEXCEPT + { + imageIndex = imageIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindImageMemorySwapchainInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindImageMemorySwapchainInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindImageMemorySwapchainInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindImageMemorySwapchainInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain, imageIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindImageMemorySwapchainInfoKHR const & ) const = default; +#else + bool operator==( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( imageIndex == rhs.imageIndex ); +# endif + } + + bool operator!=( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR; + const void * pNext = {}; + SwapchainKHR swapchain = {}; + uint32_t imageIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindImageMemorySwapchainInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = BindImageMemorySwapchainInfoKHR; + }; + + // wrapper struct for struct VkBindImagePlaneMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImagePlaneMemoryInfo.html + struct BindImagePlaneMemoryInfo + { + using NativeType = VkBindImagePlaneMemoryInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImagePlaneMemoryInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , planeAspect{ planeAspect_ } + { + } + + VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : BindImagePlaneMemoryInfo( *reinterpret_cast( &rhs ) ) + { + } + + BindImagePlaneMemoryInfo & operator=( BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindImagePlaneMemoryInfo & operator=( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo & setPlaneAspect( ImageAspectFlagBits planeAspect_ ) & VULKAN_HPP_NOEXCEPT + { + planeAspect = planeAspect_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo && setPlaneAspect( ImageAspectFlagBits planeAspect_ ) && VULKAN_HPP_NOEXCEPT + { + planeAspect = planeAspect_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindImagePlaneMemoryInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindImagePlaneMemoryInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindImagePlaneMemoryInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindImagePlaneMemoryInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, planeAspect ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindImagePlaneMemoryInfo const & ) const = default; +#else + bool operator==( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect ); +# endif + } + + bool operator!=( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindImagePlaneMemoryInfo; + const void * pNext = {}; + ImageAspectFlagBits planeAspect = ImageAspectFlagBits::eColor; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindImagePlaneMemoryInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BindImagePlaneMemoryInfo; + }; + + using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; + + // wrapper struct for struct VkBindIndexBufferIndirectCommandEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindIndexBufferIndirectCommandEXT.html + struct BindIndexBufferIndirectCommandEXT + { + using NativeType = VkBindIndexBufferIndirectCommandEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + BindIndexBufferIndirectCommandEXT( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, IndexType indexType_ = IndexType::eUint16 ) VULKAN_HPP_NOEXCEPT + : bufferAddress{ bufferAddress_ } + , size{ size_ } + , indexType{ indexType_ } + { + } + + VULKAN_HPP_CONSTEXPR BindIndexBufferIndirectCommandEXT( BindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindIndexBufferIndirectCommandEXT( VkBindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : BindIndexBufferIndirectCommandEXT( *reinterpret_cast( &rhs ) ) + { + } + + BindIndexBufferIndirectCommandEXT & operator=( BindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindIndexBufferIndirectCommandEXT & operator=( VkBindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT + { + bufferAddress = bufferAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT + { + bufferAddress = bufferAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindIndexBufferIndirectCommandEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindIndexBufferIndirectCommandEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindIndexBufferIndirectCommandEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindIndexBufferIndirectCommandEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferAddress, size, indexType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindIndexBufferIndirectCommandEXT const & ) const = default; +#else + bool operator==( BindIndexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType ); +# endif + } + + bool operator!=( BindIndexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress bufferAddress = {}; + uint32_t size = {}; + IndexType indexType = IndexType::eUint16; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindIndexBufferIndirectCommandEXT; + }; +#endif + + // wrapper struct for struct VkBindIndexBufferIndirectCommandNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindIndexBufferIndirectCommandNV.html + struct BindIndexBufferIndirectCommandNV + { + using NativeType = VkBindIndexBufferIndirectCommandNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + BindIndexBufferIndirectCommandNV( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, IndexType indexType_ = IndexType::eUint16 ) VULKAN_HPP_NOEXCEPT + : bufferAddress{ bufferAddress_ } + , size{ size_ } + , indexType{ indexType_ } + { + } + + VULKAN_HPP_CONSTEXPR BindIndexBufferIndirectCommandNV( BindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindIndexBufferIndirectCommandNV( VkBindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + : BindIndexBufferIndirectCommandNV( *reinterpret_cast( &rhs ) ) + { + } + + BindIndexBufferIndirectCommandNV & operator=( BindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindIndexBufferIndirectCommandNV & operator=( VkBindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT + { + bufferAddress = bufferAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT + { + bufferAddress = bufferAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindIndexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindIndexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindIndexBufferIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindIndexBufferIndirectCommandNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferAddress, size, indexType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindIndexBufferIndirectCommandNV const & ) const = default; +#else + bool operator==( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType ); +# endif + } + + bool operator!=( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress bufferAddress = {}; + uint32_t size = {}; + IndexType indexType = IndexType::eUint16; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindIndexBufferIndirectCommandNV; + }; +#endif + + // wrapper struct for struct VkBindMemoryStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindMemoryStatus.html + struct BindMemoryStatus + { + using NativeType = VkBindMemoryStatus; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindMemoryStatus; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindMemoryStatus( Result * pResult_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pResult{ pResult_ } + { + } + + VULKAN_HPP_CONSTEXPR BindMemoryStatus( BindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindMemoryStatus( VkBindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT : BindMemoryStatus( *reinterpret_cast( &rhs ) ) {} + + BindMemoryStatus & operator=( BindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindMemoryStatus & operator=( VkBindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus & setPResult( Result * pResult_ ) & VULKAN_HPP_NOEXCEPT + { + pResult = pResult_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus && setPResult( Result * pResult_ ) && VULKAN_HPP_NOEXCEPT + { + pResult = pResult_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindMemoryStatus const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindMemoryStatus &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindMemoryStatus const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindMemoryStatus *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pResult ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindMemoryStatus const & ) const = default; +#else + bool operator==( BindMemoryStatus const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pResult == rhs.pResult ); +# endif + } + + bool operator!=( BindMemoryStatus const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindMemoryStatus; + const void * pNext = {}; + Result * pResult = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindMemoryStatus; + }; +#endif + + template <> + struct CppType + { + using Type = BindMemoryStatus; + }; + + using BindMemoryStatusKHR = BindMemoryStatus; + + // wrapper struct for struct VkBindPipelineIndirectCommandNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindPipelineIndirectCommandNV.html + struct BindPipelineIndirectCommandNV + { + using NativeType = VkBindPipelineIndirectCommandNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindPipelineIndirectCommandNV( DeviceAddress pipelineAddress_ = {} ) VULKAN_HPP_NOEXCEPT : pipelineAddress{ pipelineAddress_ } {} + + VULKAN_HPP_CONSTEXPR BindPipelineIndirectCommandNV( BindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindPipelineIndirectCommandNV( VkBindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + : BindPipelineIndirectCommandNV( *reinterpret_cast( &rhs ) ) + { + } + + BindPipelineIndirectCommandNV & operator=( BindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindPipelineIndirectCommandNV & operator=( VkBindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindPipelineIndirectCommandNV & setPipelineAddress( DeviceAddress pipelineAddress_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineAddress = pipelineAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindPipelineIndirectCommandNV && setPipelineAddress( DeviceAddress pipelineAddress_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineAddress = pipelineAddress_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindPipelineIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindPipelineIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindPipelineIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindPipelineIndirectCommandNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( pipelineAddress ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindPipelineIndirectCommandNV const & ) const = default; +#else + bool operator==( BindPipelineIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( pipelineAddress == rhs.pipelineAddress ); +# endif + } + + bool operator!=( BindPipelineIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress pipelineAddress = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindPipelineIndirectCommandNV; + }; +#endif + + // wrapper struct for struct VkBindShaderGroupIndirectCommandNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindShaderGroupIndirectCommandNV.html + struct BindShaderGroupIndirectCommandNV + { + using NativeType = VkBindShaderGroupIndirectCommandNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindShaderGroupIndirectCommandNV( uint32_t groupIndex_ = {} ) VULKAN_HPP_NOEXCEPT : groupIndex{ groupIndex_ } {} + + VULKAN_HPP_CONSTEXPR BindShaderGroupIndirectCommandNV( BindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindShaderGroupIndirectCommandNV( VkBindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + : BindShaderGroupIndirectCommandNV( *reinterpret_cast( &rhs ) ) + { + } + + BindShaderGroupIndirectCommandNV & operator=( BindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindShaderGroupIndirectCommandNV & operator=( VkBindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindShaderGroupIndirectCommandNV & setGroupIndex( uint32_t groupIndex_ ) & VULKAN_HPP_NOEXCEPT + { + groupIndex = groupIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindShaderGroupIndirectCommandNV && setGroupIndex( uint32_t groupIndex_ ) && VULKAN_HPP_NOEXCEPT + { + groupIndex = groupIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindShaderGroupIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindShaderGroupIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindShaderGroupIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindShaderGroupIndirectCommandNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( groupIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindShaderGroupIndirectCommandNV const & ) const = default; +#else + bool operator==( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( groupIndex == rhs.groupIndex ); +# endif + } + + bool operator!=( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t groupIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindShaderGroupIndirectCommandNV; + }; +#endif + + // wrapper struct for struct VkSparseMemoryBind, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseMemoryBind.html + struct SparseMemoryBind + { + using NativeType = VkSparseMemoryBind; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SparseMemoryBind( DeviceSize resourceOffset_ = {}, + DeviceSize size_ = {}, + DeviceMemory memory_ = {}, + DeviceSize memoryOffset_ = {}, + SparseMemoryBindFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT + : resourceOffset{ resourceOffset_ } + , size{ size_ } + , memory{ memory_ } + , memoryOffset{ memoryOffset_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR SparseMemoryBind( SparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SparseMemoryBind( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT : SparseMemoryBind( *reinterpret_cast( &rhs ) ) {} + + SparseMemoryBind & operator=( SparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SparseMemoryBind & operator=( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setResourceOffset( DeviceSize resourceOffset_ ) & VULKAN_HPP_NOEXCEPT + { + resourceOffset = resourceOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setResourceOffset( DeviceSize resourceOffset_ ) && VULKAN_HPP_NOEXCEPT + { + resourceOffset = resourceOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setFlags( SparseMemoryBindFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setFlags( SparseMemoryBindFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSparseMemoryBind const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseMemoryBind &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseMemoryBind const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSparseMemoryBind *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( resourceOffset, size, memory, memoryOffset, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SparseMemoryBind const & ) const = default; +#else + bool operator==( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( resourceOffset == rhs.resourceOffset ) && ( size == rhs.size ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && + ( flags == rhs.flags ); +# endif + } + + bool operator!=( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceSize resourceOffset = {}; + DeviceSize size = {}; + DeviceMemory memory = {}; + DeviceSize memoryOffset = {}; + SparseMemoryBindFlags flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SparseMemoryBind; + }; +#endif + + // wrapper struct for struct VkSparseBufferMemoryBindInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseBufferMemoryBindInfo.html + struct SparseBufferMemoryBindInfo + { + using NativeType = VkSparseBufferMemoryBindInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SparseBufferMemoryBindInfo( Buffer buffer_ = {}, uint32_t bindCount_ = {}, const SparseMemoryBind * pBinds_ = {} ) VULKAN_HPP_NOEXCEPT + : buffer{ buffer_ } + , bindCount{ bindCount_ } + , pBinds{ pBinds_ } + { + } + + VULKAN_HPP_CONSTEXPR SparseBufferMemoryBindInfo( SparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : SparseBufferMemoryBindInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SparseBufferMemoryBindInfo( Buffer buffer_, ArrayProxyNoTemporaries const & binds_ ) + : buffer( buffer_ ), bindCount( static_cast( binds_.size() ) ), pBinds( binds_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SparseBufferMemoryBindInfo & operator=( SparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SparseBufferMemoryBindInfo & operator=( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo & setBindCount( uint32_t bindCount_ ) & VULKAN_HPP_NOEXCEPT + { + bindCount = bindCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo && setBindCount( uint32_t bindCount_ ) && VULKAN_HPP_NOEXCEPT + { + bindCount = bindCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo & setPBinds( const SparseMemoryBind * pBinds_ ) & VULKAN_HPP_NOEXCEPT + { + pBinds = pBinds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo && setPBinds( const SparseMemoryBind * pBinds_ ) && VULKAN_HPP_NOEXCEPT + { + pBinds = pBinds_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SparseBufferMemoryBindInfo & setBinds( ArrayProxyNoTemporaries const & binds_ ) VULKAN_HPP_NOEXCEPT + { + bindCount = static_cast( binds_.size() ); + pBinds = binds_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSparseBufferMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseBufferMemoryBindInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseBufferMemoryBindInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSparseBufferMemoryBindInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( buffer, bindCount, pBinds ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SparseBufferMemoryBindInfo const & ) const = default; +#else + bool operator==( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( buffer == rhs.buffer ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); +# endif + } + + bool operator!=( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Buffer buffer = {}; + uint32_t bindCount = {}; + const SparseMemoryBind * pBinds = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SparseBufferMemoryBindInfo; + }; +#endif + + // wrapper struct for struct VkSparseImageOpaqueMemoryBindInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageOpaqueMemoryBindInfo.html + struct SparseImageOpaqueMemoryBindInfo + { + using NativeType = VkSparseImageOpaqueMemoryBindInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + SparseImageOpaqueMemoryBindInfo( Image image_ = {}, uint32_t bindCount_ = {}, const SparseMemoryBind * pBinds_ = {} ) VULKAN_HPP_NOEXCEPT + : image{ image_ } + , bindCount{ bindCount_ } + , pBinds{ pBinds_ } + { + } + + VULKAN_HPP_CONSTEXPR SparseImageOpaqueMemoryBindInfo( SparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : SparseImageOpaqueMemoryBindInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SparseImageOpaqueMemoryBindInfo( Image image_, ArrayProxyNoTemporaries const & binds_ ) + : image( image_ ), bindCount( static_cast( binds_.size() ) ), pBinds( binds_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SparseImageOpaqueMemoryBindInfo & operator=( SparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SparseImageOpaqueMemoryBindInfo & operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo & setBindCount( uint32_t bindCount_ ) & VULKAN_HPP_NOEXCEPT + { + bindCount = bindCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo && setBindCount( uint32_t bindCount_ ) && VULKAN_HPP_NOEXCEPT + { + bindCount = bindCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo & setPBinds( const SparseMemoryBind * pBinds_ ) & VULKAN_HPP_NOEXCEPT + { + pBinds = pBinds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo && setPBinds( const SparseMemoryBind * pBinds_ ) && VULKAN_HPP_NOEXCEPT + { + pBinds = pBinds_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SparseImageOpaqueMemoryBindInfo & setBinds( ArrayProxyNoTemporaries const & binds_ ) VULKAN_HPP_NOEXCEPT + { + bindCount = static_cast( binds_.size() ); + pBinds = binds_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSparseImageOpaqueMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageOpaqueMemoryBindInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageOpaqueMemoryBindInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSparseImageOpaqueMemoryBindInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( image, bindCount, pBinds ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SparseImageOpaqueMemoryBindInfo const & ) const = default; +#else + bool operator==( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); +# endif + } + + bool operator!=( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Image image = {}; + uint32_t bindCount = {}; + const SparseMemoryBind * pBinds = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SparseImageOpaqueMemoryBindInfo; + }; +#endif + + // wrapper struct for struct VkImageSubresource, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSubresource.html + struct ImageSubresource + { + using NativeType = VkImageSubresource; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageSubresource( ImageAspectFlags aspectMask_ = {}, uint32_t mipLevel_ = {}, uint32_t arrayLayer_ = {} ) VULKAN_HPP_NOEXCEPT + : aspectMask{ aspectMask_ } + , mipLevel{ mipLevel_ } + , arrayLayer{ arrayLayer_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageSubresource( ImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageSubresource( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT : ImageSubresource( *reinterpret_cast( &rhs ) ) {} + + ImageSubresource & operator=( ImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageSubresource & operator=( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageSubresource & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresource && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresource & setMipLevel( uint32_t mipLevel_ ) & VULKAN_HPP_NOEXCEPT + { + mipLevel = mipLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresource && setMipLevel( uint32_t mipLevel_ ) && VULKAN_HPP_NOEXCEPT + { + mipLevel = mipLevel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresource & setArrayLayer( uint32_t arrayLayer_ ) & VULKAN_HPP_NOEXCEPT + { + arrayLayer = arrayLayer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresource && setArrayLayer( uint32_t arrayLayer_ ) && VULKAN_HPP_NOEXCEPT + { + arrayLayer = arrayLayer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageSubresource const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSubresource &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSubresource const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageSubresource *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, mipLevel, arrayLayer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageSubresource const & ) const = default; +#else + bool operator==( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( arrayLayer == rhs.arrayLayer ); +# endif + } + + bool operator!=( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ImageAspectFlags aspectMask = {}; + uint32_t mipLevel = {}; + uint32_t arrayLayer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageSubresource; + }; +#endif + + // wrapper struct for struct VkOffset3D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOffset3D.html + struct Offset3D + { + using NativeType = VkOffset3D; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR Offset3D( int32_t x_ = {}, int32_t y_ = {}, int32_t z_ = {} ) VULKAN_HPP_NOEXCEPT + : x{ x_ } + , y{ y_ } + , z{ z_ } + { + } + + VULKAN_HPP_CONSTEXPR Offset3D( Offset3D const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + Offset3D( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT : Offset3D( *reinterpret_cast( &rhs ) ) {} + + explicit Offset3D( Offset2D const & offset2D, int32_t z_ = {} ) : x( offset2D.x ), y( offset2D.y ), z( z_ ) {} + + Offset3D & operator=( Offset3D const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + Offset3D & operator=( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 Offset3D & setX( int32_t x_ ) & VULKAN_HPP_NOEXCEPT + { + x = x_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Offset3D && setX( int32_t x_ ) && VULKAN_HPP_NOEXCEPT + { + x = x_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Offset3D & setY( int32_t y_ ) & VULKAN_HPP_NOEXCEPT + { + y = y_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Offset3D && setY( int32_t y_ ) && VULKAN_HPP_NOEXCEPT + { + y = y_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Offset3D & setZ( int32_t z_ ) & VULKAN_HPP_NOEXCEPT + { + z = z_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Offset3D && setZ( int32_t z_ ) && VULKAN_HPP_NOEXCEPT + { + z = z_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkOffset3D const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOffset3D &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOffset3D const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkOffset3D *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, z ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( Offset3D const & ) const = default; +#else + bool operator==( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ); +# endif + } + + bool operator!=( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + int32_t x = {}; + int32_t y = {}; + int32_t z = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = Offset3D; + }; +#endif + + // wrapper struct for struct VkExtent3D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExtent3D.html + struct Extent3D + { + using NativeType = VkExtent3D; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR Extent3D( uint32_t width_ = {}, uint32_t height_ = {}, uint32_t depth_ = {} ) VULKAN_HPP_NOEXCEPT + : width{ width_ } + , height{ height_ } + , depth{ depth_ } + { + } + + VULKAN_HPP_CONSTEXPR Extent3D( Extent3D const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + Extent3D( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT : Extent3D( *reinterpret_cast( &rhs ) ) {} + + explicit Extent3D( Extent2D const & extent2D, uint32_t depth_ = {} ) : width( extent2D.width ), height( extent2D.height ), depth( depth_ ) {} + + Extent3D & operator=( Extent3D const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + Extent3D & operator=( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 Extent3D & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT + { + width = width_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Extent3D && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT + { + width = width_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Extent3D & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT + { + height = height_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Extent3D && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT + { + height = height_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Extent3D & setDepth( uint32_t depth_ ) & VULKAN_HPP_NOEXCEPT + { + depth = depth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Extent3D && setDepth( uint32_t depth_ ) && VULKAN_HPP_NOEXCEPT + { + depth = depth_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExtent3D const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExtent3D &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExtent3D const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExtent3D *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( width, height, depth ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( Extent3D const & ) const = default; +#else + bool operator==( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth ); +# endif + } + + bool operator!=( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t width = {}; + uint32_t height = {}; + uint32_t depth = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = Extent3D; + }; +#endif + + // wrapper struct for struct VkSparseImageMemoryBind, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageMemoryBind.html + struct SparseImageMemoryBind + { + using NativeType = VkSparseImageMemoryBind; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SparseImageMemoryBind( ImageSubresource subresource_ = {}, + Offset3D offset_ = {}, + Extent3D extent_ = {}, + DeviceMemory memory_ = {}, + DeviceSize memoryOffset_ = {}, + SparseMemoryBindFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT + : subresource{ subresource_ } + , offset{ offset_ } + , extent{ extent_ } + , memory{ memory_ } + , memoryOffset{ memoryOffset_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR SparseImageMemoryBind( SparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT + : SparseImageMemoryBind( *reinterpret_cast( &rhs ) ) + { + } + + SparseImageMemoryBind & operator=( SparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SparseImageMemoryBind & operator=( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setSubresource( ImageSubresource const & subresource_ ) & VULKAN_HPP_NOEXCEPT + { + subresource = subresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setSubresource( ImageSubresource const & subresource_ ) && VULKAN_HPP_NOEXCEPT + { + subresource = subresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setOffset( Offset3D const & offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setOffset( Offset3D const & offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setFlags( SparseMemoryBindFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setFlags( SparseMemoryBindFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSparseImageMemoryBind const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryBind &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryBind const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSparseImageMemoryBind *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( subresource, offset, extent, memory, memoryOffset, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SparseImageMemoryBind const & ) const = default; +#else + bool operator==( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( subresource == rhs.subresource ) && ( offset == rhs.offset ) && ( extent == rhs.extent ) && ( memory == rhs.memory ) && + ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ImageSubresource subresource = {}; + Offset3D offset = {}; + Extent3D extent = {}; + DeviceMemory memory = {}; + DeviceSize memoryOffset = {}; + SparseMemoryBindFlags flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SparseImageMemoryBind; + }; +#endif + + // wrapper struct for struct VkSparseImageMemoryBindInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageMemoryBindInfo.html + struct SparseImageMemoryBindInfo + { + using NativeType = VkSparseImageMemoryBindInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + SparseImageMemoryBindInfo( Image image_ = {}, uint32_t bindCount_ = {}, const SparseImageMemoryBind * pBinds_ = {} ) VULKAN_HPP_NOEXCEPT + : image{ image_ } + , bindCount{ bindCount_ } + , pBinds{ pBinds_ } + { + } + + VULKAN_HPP_CONSTEXPR SparseImageMemoryBindInfo( SparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : SparseImageMemoryBindInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SparseImageMemoryBindInfo( Image image_, ArrayProxyNoTemporaries const & binds_ ) + : image( image_ ), bindCount( static_cast( binds_.size() ) ), pBinds( binds_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SparseImageMemoryBindInfo & operator=( SparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SparseImageMemoryBindInfo & operator=( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo & setBindCount( uint32_t bindCount_ ) & VULKAN_HPP_NOEXCEPT + { + bindCount = bindCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo && setBindCount( uint32_t bindCount_ ) && VULKAN_HPP_NOEXCEPT + { + bindCount = bindCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo & setPBinds( const SparseImageMemoryBind * pBinds_ ) & VULKAN_HPP_NOEXCEPT + { + pBinds = pBinds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo && setPBinds( const SparseImageMemoryBind * pBinds_ ) && VULKAN_HPP_NOEXCEPT + { + pBinds = pBinds_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SparseImageMemoryBindInfo & setBinds( ArrayProxyNoTemporaries const & binds_ ) VULKAN_HPP_NOEXCEPT + { + bindCount = static_cast( binds_.size() ); + pBinds = binds_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSparseImageMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryBindInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryBindInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSparseImageMemoryBindInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( image, bindCount, pBinds ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SparseImageMemoryBindInfo const & ) const = default; +#else + bool operator==( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); +# endif + } + + bool operator!=( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Image image = {}; + uint32_t bindCount = {}; + const SparseImageMemoryBind * pBinds = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SparseImageMemoryBindInfo; + }; +#endif + + // wrapper struct for struct VkBindSparseInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindSparseInfo.html + struct BindSparseInfo + { + using NativeType = VkBindSparseInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindSparseInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = {}, + const Semaphore * pWaitSemaphores_ = {}, + uint32_t bufferBindCount_ = {}, + const SparseBufferMemoryBindInfo * pBufferBinds_ = {}, + uint32_t imageOpaqueBindCount_ = {}, + const SparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds_ = {}, + uint32_t imageBindCount_ = {}, + const SparseImageMemoryBindInfo * pImageBinds_ = {}, + uint32_t signalSemaphoreCount_ = {}, + const Semaphore * pSignalSemaphores_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , waitSemaphoreCount{ waitSemaphoreCount_ } + , pWaitSemaphores{ pWaitSemaphores_ } + , bufferBindCount{ bufferBindCount_ } + , pBufferBinds{ pBufferBinds_ } + , imageOpaqueBindCount{ imageOpaqueBindCount_ } + , pImageOpaqueBinds{ pImageOpaqueBinds_ } + , imageBindCount{ imageBindCount_ } + , pImageBinds{ pImageBinds_ } + , signalSemaphoreCount{ signalSemaphoreCount_ } + , pSignalSemaphores{ pSignalSemaphores_ } + { + } + + VULKAN_HPP_CONSTEXPR BindSparseInfo( BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindSparseInfo( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT : BindSparseInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindSparseInfo( ArrayProxyNoTemporaries const & waitSemaphores_, + ArrayProxyNoTemporaries const & bufferBinds_ = {}, + ArrayProxyNoTemporaries const & imageOpaqueBinds_ = {}, + ArrayProxyNoTemporaries const & imageBinds_ = {}, + ArrayProxyNoTemporaries const & signalSemaphores_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , waitSemaphoreCount( static_cast( waitSemaphores_.size() ) ) + , pWaitSemaphores( waitSemaphores_.data() ) + , bufferBindCount( static_cast( bufferBinds_.size() ) ) + , pBufferBinds( bufferBinds_.data() ) + , imageOpaqueBindCount( static_cast( imageOpaqueBinds_.size() ) ) + , pImageOpaqueBinds( imageOpaqueBinds_.data() ) + , imageBindCount( static_cast( imageBinds_.size() ) ) + , pImageBinds( imageBinds_.data() ) + , signalSemaphoreCount( static_cast( signalSemaphores_.size() ) ) + , pSignalSemaphores( signalSemaphores_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + BindSparseInfo & operator=( BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindSparseInfo & operator=( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = waitSemaphoreCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = waitSemaphoreCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) & VULKAN_HPP_NOEXCEPT + { + pWaitSemaphores = pWaitSemaphores_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) && VULKAN_HPP_NOEXCEPT + { + pWaitSemaphores = pWaitSemaphores_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindSparseInfo & setWaitSemaphores( ArrayProxyNoTemporaries const & waitSemaphores_ ) VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = static_cast( waitSemaphores_.size() ); + pWaitSemaphores = waitSemaphores_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setBufferBindCount( uint32_t bufferBindCount_ ) & VULKAN_HPP_NOEXCEPT + { + bufferBindCount = bufferBindCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setBufferBindCount( uint32_t bufferBindCount_ ) && VULKAN_HPP_NOEXCEPT + { + bufferBindCount = bufferBindCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPBufferBinds( const SparseBufferMemoryBindInfo * pBufferBinds_ ) & VULKAN_HPP_NOEXCEPT + { + pBufferBinds = pBufferBinds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPBufferBinds( const SparseBufferMemoryBindInfo * pBufferBinds_ ) && VULKAN_HPP_NOEXCEPT + { + pBufferBinds = pBufferBinds_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindSparseInfo & setBufferBinds( ArrayProxyNoTemporaries const & bufferBinds_ ) VULKAN_HPP_NOEXCEPT + { + bufferBindCount = static_cast( bufferBinds_.size() ); + pBufferBinds = bufferBinds_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) & VULKAN_HPP_NOEXCEPT + { + imageOpaqueBindCount = imageOpaqueBindCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) && VULKAN_HPP_NOEXCEPT + { + imageOpaqueBindCount = imageOpaqueBindCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds_ ) & VULKAN_HPP_NOEXCEPT + { + pImageOpaqueBinds = pImageOpaqueBinds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds_ ) && VULKAN_HPP_NOEXCEPT + { + pImageOpaqueBinds = pImageOpaqueBinds_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindSparseInfo & setImageOpaqueBinds( ArrayProxyNoTemporaries const & imageOpaqueBinds_ ) VULKAN_HPP_NOEXCEPT + { + imageOpaqueBindCount = static_cast( imageOpaqueBinds_.size() ); + pImageOpaqueBinds = imageOpaqueBinds_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setImageBindCount( uint32_t imageBindCount_ ) & VULKAN_HPP_NOEXCEPT + { + imageBindCount = imageBindCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setImageBindCount( uint32_t imageBindCount_ ) && VULKAN_HPP_NOEXCEPT + { + imageBindCount = imageBindCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPImageBinds( const SparseImageMemoryBindInfo * pImageBinds_ ) & VULKAN_HPP_NOEXCEPT + { + pImageBinds = pImageBinds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPImageBinds( const SparseImageMemoryBindInfo * pImageBinds_ ) && VULKAN_HPP_NOEXCEPT + { + pImageBinds = pImageBinds_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindSparseInfo & setImageBinds( ArrayProxyNoTemporaries const & imageBinds_ ) VULKAN_HPP_NOEXCEPT + { + imageBindCount = static_cast( imageBinds_.size() ); + pImageBinds = imageBinds_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT + { + signalSemaphoreCount = signalSemaphoreCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT + { + signalSemaphoreCount = signalSemaphoreCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPSignalSemaphores( const Semaphore * pSignalSemaphores_ ) & VULKAN_HPP_NOEXCEPT + { + pSignalSemaphores = pSignalSemaphores_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPSignalSemaphores( const Semaphore * pSignalSemaphores_ ) && VULKAN_HPP_NOEXCEPT + { + pSignalSemaphores = pSignalSemaphores_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BindSparseInfo & setSignalSemaphores( ArrayProxyNoTemporaries const & signalSemaphores_ ) VULKAN_HPP_NOEXCEPT + { + signalSemaphoreCount = static_cast( signalSemaphores_.size() ); + pSignalSemaphores = signalSemaphores_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindSparseInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindSparseInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindSparseInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreCount, + pWaitSemaphores, + bufferBindCount, + pBufferBinds, + imageOpaqueBindCount, + pImageOpaqueBinds, + imageBindCount, + pImageBinds, + signalSemaphoreCount, + pSignalSemaphores ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindSparseInfo const & ) const = default; +#else + bool operator==( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && + ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( bufferBindCount == rhs.bufferBindCount ) && ( pBufferBinds == rhs.pBufferBinds ) && + ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) && + ( imageBindCount == rhs.imageBindCount ) && ( pImageBinds == rhs.pImageBinds ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && + ( pSignalSemaphores == rhs.pSignalSemaphores ); +# endif + } + + bool operator!=( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindSparseInfo; + const void * pNext = {}; + uint32_t waitSemaphoreCount = {}; + const Semaphore * pWaitSemaphores = {}; + uint32_t bufferBindCount = {}; + const SparseBufferMemoryBindInfo * pBufferBinds = {}; + uint32_t imageOpaqueBindCount = {}; + const SparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds = {}; + uint32_t imageBindCount = {}; + const SparseImageMemoryBindInfo * pImageBinds = {}; + uint32_t signalSemaphoreCount = {}; + const Semaphore * pSignalSemaphores = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindSparseInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BindSparseInfo; + }; + + // wrapper struct for struct VkBindTensorMemoryInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindTensorMemoryInfoARM.html + struct BindTensorMemoryInfoARM + { + using NativeType = VkBindTensorMemoryInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindTensorMemoryInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindTensorMemoryInfoARM( TensorARM tensor_ = {}, + DeviceMemory memory_ = {}, + DeviceSize memoryOffset_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensor{ tensor_ } + , memory{ memory_ } + , memoryOffset{ memoryOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR BindTensorMemoryInfoARM( BindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindTensorMemoryInfoARM( VkBindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : BindTensorMemoryInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + BindTensorMemoryInfoARM & operator=( BindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindTensorMemoryInfoARM & operator=( VkBindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindTensorMemoryInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindTensorMemoryInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindTensorMemoryInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindTensorMemoryInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tensor, memory, memoryOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindTensorMemoryInfoARM const & ) const = default; +#else + bool operator==( BindTensorMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensor == rhs.tensor ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ); +# endif + } + + bool operator!=( BindTensorMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindTensorMemoryInfoARM; + const void * pNext = {}; + TensorARM tensor = {}; + DeviceMemory memory = {}; + DeviceSize memoryOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindTensorMemoryInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = BindTensorMemoryInfoARM; + }; + + // wrapper struct for struct VkBindVertexBufferIndirectCommandEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVertexBufferIndirectCommandEXT.html + struct BindVertexBufferIndirectCommandEXT + { + using NativeType = VkBindVertexBufferIndirectCommandEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandEXT( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, uint32_t stride_ = {} ) VULKAN_HPP_NOEXCEPT + : bufferAddress{ bufferAddress_ } + , size{ size_ } + , stride{ stride_ } + { + } + + VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandEXT( BindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindVertexBufferIndirectCommandEXT( VkBindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : BindVertexBufferIndirectCommandEXT( *reinterpret_cast( &rhs ) ) + { + } + + BindVertexBufferIndirectCommandEXT & operator=( BindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindVertexBufferIndirectCommandEXT & operator=( VkBindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT + { + bufferAddress = bufferAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT + { + bufferAddress = bufferAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindVertexBufferIndirectCommandEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindVertexBufferIndirectCommandEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindVertexBufferIndirectCommandEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindVertexBufferIndirectCommandEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferAddress, size, stride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindVertexBufferIndirectCommandEXT const & ) const = default; +#else + bool operator==( BindVertexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride ); +# endif + } + + bool operator!=( BindVertexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress bufferAddress = {}; + uint32_t size = {}; + uint32_t stride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindVertexBufferIndirectCommandEXT; + }; +#endif + + // wrapper struct for struct VkBindVertexBufferIndirectCommandNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVertexBufferIndirectCommandNV.html + struct BindVertexBufferIndirectCommandNV + { + using NativeType = VkBindVertexBufferIndirectCommandNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandNV( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, uint32_t stride_ = {} ) VULKAN_HPP_NOEXCEPT + : bufferAddress{ bufferAddress_ } + , size{ size_ } + , stride{ stride_ } + { + } + + VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandNV( BindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindVertexBufferIndirectCommandNV( VkBindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + : BindVertexBufferIndirectCommandNV( *reinterpret_cast( &rhs ) ) + { + } + + BindVertexBufferIndirectCommandNV & operator=( BindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindVertexBufferIndirectCommandNV & operator=( VkBindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT + { + bufferAddress = bufferAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT + { + bufferAddress = bufferAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindVertexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindVertexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindVertexBufferIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindVertexBufferIndirectCommandNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferAddress, size, stride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindVertexBufferIndirectCommandNV const & ) const = default; +#else + bool operator==( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride ); +# endif + } + + bool operator!=( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress bufferAddress = {}; + uint32_t size = {}; + uint32_t stride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindVertexBufferIndirectCommandNV; + }; +#endif + + // wrapper struct for struct VkBindVideoSessionMemoryInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVideoSessionMemoryInfoKHR.html + struct BindVideoSessionMemoryInfoKHR + { + using NativeType = VkBindVideoSessionMemoryInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindVideoSessionMemoryInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BindVideoSessionMemoryInfoKHR( uint32_t memoryBindIndex_ = {}, + DeviceMemory memory_ = {}, + DeviceSize memoryOffset_ = {}, + DeviceSize memorySize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryBindIndex{ memoryBindIndex_ } + , memory{ memory_ } + , memoryOffset{ memoryOffset_ } + , memorySize{ memorySize_ } + { + } + + VULKAN_HPP_CONSTEXPR BindVideoSessionMemoryInfoKHR( BindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BindVideoSessionMemoryInfoKHR( VkBindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : BindVideoSessionMemoryInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + BindVideoSessionMemoryInfoKHR & operator=( BindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BindVideoSessionMemoryInfoKHR & operator=( VkBindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemoryBindIndex( uint32_t memoryBindIndex_ ) & VULKAN_HPP_NOEXCEPT + { + memoryBindIndex = memoryBindIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemoryBindIndex( uint32_t memoryBindIndex_ ) && VULKAN_HPP_NOEXCEPT + { + memoryBindIndex = memoryBindIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT + { + memoryOffset = memoryOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemorySize( DeviceSize memorySize_ ) & VULKAN_HPP_NOEXCEPT + { + memorySize = memorySize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemorySize( DeviceSize memorySize_ ) && VULKAN_HPP_NOEXCEPT + { + memorySize = memorySize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBindVideoSessionMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindVideoSessionMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBindVideoSessionMemoryInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBindVideoSessionMemoryInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryBindIndex, memory, memoryOffset, memorySize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BindVideoSessionMemoryInfoKHR const & ) const = default; +#else + bool operator==( BindVideoSessionMemoryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && ( memory == rhs.memory ) && + ( memoryOffset == rhs.memoryOffset ) && ( memorySize == rhs.memorySize ); +# endif + } + + bool operator!=( BindVideoSessionMemoryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBindVideoSessionMemoryInfoKHR; + const void * pNext = {}; + uint32_t memoryBindIndex = {}; + DeviceMemory memory = {}; + DeviceSize memoryOffset = {}; + DeviceSize memorySize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BindVideoSessionMemoryInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = BindVideoSessionMemoryInfoKHR; + }; + + // wrapper struct for struct VkBlitImageCubicWeightsInfoQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlitImageCubicWeightsInfoQCOM.html + struct BlitImageCubicWeightsInfoQCOM + { + using NativeType = VkBlitImageCubicWeightsInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBlitImageCubicWeightsInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BlitImageCubicWeightsInfoQCOM( CubicFilterWeightsQCOM cubicWeights_ = CubicFilterWeightsQCOM::eCatmullRom, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cubicWeights{ cubicWeights_ } + { + } + + VULKAN_HPP_CONSTEXPR BlitImageCubicWeightsInfoQCOM( BlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BlitImageCubicWeightsInfoQCOM( VkBlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : BlitImageCubicWeightsInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + BlitImageCubicWeightsInfoQCOM & operator=( BlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BlitImageCubicWeightsInfoQCOM & operator=( VkBlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM & setCubicWeights( CubicFilterWeightsQCOM cubicWeights_ ) & VULKAN_HPP_NOEXCEPT + { + cubicWeights = cubicWeights_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM && setCubicWeights( CubicFilterWeightsQCOM cubicWeights_ ) && VULKAN_HPP_NOEXCEPT + { + cubicWeights = cubicWeights_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBlitImageCubicWeightsInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBlitImageCubicWeightsInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBlitImageCubicWeightsInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBlitImageCubicWeightsInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cubicWeights ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BlitImageCubicWeightsInfoQCOM const & ) const = default; +#else + bool operator==( BlitImageCubicWeightsInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cubicWeights == rhs.cubicWeights ); +# endif + } + + bool operator!=( BlitImageCubicWeightsInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBlitImageCubicWeightsInfoQCOM; + const void * pNext = {}; + CubicFilterWeightsQCOM cubicWeights = CubicFilterWeightsQCOM::eCatmullRom; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BlitImageCubicWeightsInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = BlitImageCubicWeightsInfoQCOM; + }; + + // wrapper struct for struct VkImageSubresourceLayers, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSubresourceLayers.html + struct ImageSubresourceLayers + { + using NativeType = VkImageSubresourceLayers; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( ImageAspectFlags aspectMask_ = {}, + uint32_t mipLevel_ = {}, + uint32_t baseArrayLayer_ = {}, + uint32_t layerCount_ = {} ) VULKAN_HPP_NOEXCEPT + : aspectMask{ aspectMask_ } + , mipLevel{ mipLevel_ } + , baseArrayLayer{ baseArrayLayer_ } + , layerCount{ layerCount_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( ImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageSubresourceLayers( *reinterpret_cast( &rhs ) ) + { + } + + ImageSubresourceLayers & operator=( ImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageSubresourceLayers & operator=( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setMipLevel( uint32_t mipLevel_ ) & VULKAN_HPP_NOEXCEPT + { + mipLevel = mipLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setMipLevel( uint32_t mipLevel_ ) && VULKAN_HPP_NOEXCEPT + { + mipLevel = mipLevel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setBaseArrayLayer( uint32_t baseArrayLayer_ ) & VULKAN_HPP_NOEXCEPT + { + baseArrayLayer = baseArrayLayer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setBaseArrayLayer( uint32_t baseArrayLayer_ ) && VULKAN_HPP_NOEXCEPT + { + baseArrayLayer = baseArrayLayer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageSubresourceLayers const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSubresourceLayers &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSubresourceLayers const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageSubresourceLayers *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, mipLevel, baseArrayLayer, layerCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageSubresourceLayers const & ) const = default; +#else + bool operator==( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); +# endif + } + + bool operator!=( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ImageAspectFlags aspectMask = {}; + uint32_t mipLevel = {}; + uint32_t baseArrayLayer = {}; + uint32_t layerCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageSubresourceLayers; + }; +#endif + + // wrapper struct for struct VkImageBlit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageBlit2.html + struct ImageBlit2 + { + using NativeType = VkImageBlit2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageBlit2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 ImageBlit2( ImageSubresourceLayers srcSubresource_ = {}, + std::array const & srcOffsets_ = {}, + ImageSubresourceLayers dstSubresource_ = {}, + std::array const & dstOffsets_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcSubresource{ srcSubresource_ } + , srcOffsets{ srcOffsets_ } + , dstSubresource{ dstSubresource_ } + , dstOffsets{ dstOffsets_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit2( ImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageBlit2( VkImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageBlit2( *reinterpret_cast( &rhs ) ) {} + + ImageBlit2 & operator=( ImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageBlit2 & operator=( VkImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setSrcOffsets( std::array const & srcOffsets_ ) & VULKAN_HPP_NOEXCEPT + { + srcOffsets = srcOffsets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setSrcOffsets( std::array const & srcOffsets_ ) && VULKAN_HPP_NOEXCEPT + { + srcOffsets = srcOffsets_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setDstOffsets( std::array const & dstOffsets_ ) & VULKAN_HPP_NOEXCEPT + { + dstOffsets = dstOffsets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setDstOffsets( std::array const & dstOffsets_ ) && VULKAN_HPP_NOEXCEPT + { + dstOffsets = dstOffsets_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageBlit2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageBlit2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageBlit2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageBlit2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ImageSubresourceLayers const &, + ArrayWrapper1D const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcSubresource, srcOffsets, dstSubresource, dstOffsets ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageBlit2 const & ) const = default; +#else + bool operator==( ImageBlit2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) && + ( dstSubresource == rhs.dstSubresource ) && ( dstOffsets == rhs.dstOffsets ); +# endif + } + + bool operator!=( ImageBlit2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageBlit2; + const void * pNext = {}; + ImageSubresourceLayers srcSubresource = {}; + ArrayWrapper1D srcOffsets = {}; + ImageSubresourceLayers dstSubresource = {}; + ArrayWrapper1D dstOffsets = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageBlit2; + }; +#endif + + template <> + struct CppType + { + using Type = ImageBlit2; + }; + + using ImageBlit2KHR = ImageBlit2; + + // wrapper struct for struct VkBlitImageInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlitImageInfo2.html + struct BlitImageInfo2 + { + using NativeType = VkBlitImageInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBlitImageInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2( Image srcImage_ = {}, + ImageLayout srcImageLayout_ = ImageLayout::eUndefined, + Image dstImage_ = {}, + ImageLayout dstImageLayout_ = ImageLayout::eUndefined, + uint32_t regionCount_ = {}, + const ImageBlit2 * pRegions_ = {}, + Filter filter_ = Filter::eNearest, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcImage{ srcImage_ } + , srcImageLayout{ srcImageLayout_ } + , dstImage{ dstImage_ } + , dstImageLayout{ dstImageLayout_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + , filter{ filter_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2( BlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BlitImageInfo2( VkBlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : BlitImageInfo2( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BlitImageInfo2( Image srcImage_, + ImageLayout srcImageLayout_, + Image dstImage_, + ImageLayout dstImageLayout_, + ArrayProxyNoTemporaries const & regions_, + Filter filter_ = Filter::eNearest, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , srcImage( srcImage_ ) + , srcImageLayout( srcImageLayout_ ) + , dstImage( dstImage_ ) + , dstImageLayout( dstImageLayout_ ) + , regionCount( static_cast( regions_.size() ) ) + , pRegions( regions_.data() ) + , filter( filter_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + BlitImageInfo2 & operator=( BlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BlitImageInfo2 & operator=( VkBlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setPRegions( const ImageBlit2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setPRegions( const ImageBlit2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BlitImageInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setFilter( Filter filter_ ) & VULKAN_HPP_NOEXCEPT + { + filter = filter_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setFilter( Filter filter_ ) && VULKAN_HPP_NOEXCEPT + { + filter = filter_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBlitImageInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBlitImageInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBlitImageInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBlitImageInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BlitImageInfo2 const & ) const = default; +#else + bool operator==( BlitImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) && + ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ) && + ( filter == rhs.filter ); +# endif + } + + bool operator!=( BlitImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBlitImageInfo2; + const void * pNext = {}; + Image srcImage = {}; + ImageLayout srcImageLayout = ImageLayout::eUndefined; + Image dstImage = {}; + ImageLayout dstImageLayout = ImageLayout::eUndefined; + uint32_t regionCount = {}; + const ImageBlit2 * pRegions = {}; + Filter filter = Filter::eNearest; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BlitImageInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = BlitImageInfo2; + }; + + using BlitImageInfo2KHR = BlitImageInfo2; + + // wrapper struct for struct VkBufferCaptureDescriptorDataInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCaptureDescriptorDataInfoEXT.html + struct BufferCaptureDescriptorDataInfoEXT + { + using NativeType = VkBufferCaptureDescriptorDataInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCaptureDescriptorDataInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferCaptureDescriptorDataInfoEXT( Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , buffer{ buffer_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferCaptureDescriptorDataInfoEXT( BufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferCaptureDescriptorDataInfoEXT( VkBufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferCaptureDescriptorDataInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + BufferCaptureDescriptorDataInfoEXT & operator=( BufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferCaptureDescriptorDataInfoEXT & operator=( VkBufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferCaptureDescriptorDataInfoEXT const & ) const = default; +#else + bool operator==( BufferCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); +# endif + } + + bool operator!=( BufferCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferCaptureDescriptorDataInfoEXT; + const void * pNext = {}; + Buffer buffer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferCaptureDescriptorDataInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = BufferCaptureDescriptorDataInfoEXT; + }; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkBufferCollectionBufferCreateInfoFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionBufferCreateInfoFUCHSIA.html + struct BufferCollectionBufferCreateInfoFUCHSIA + { + using NativeType = VkBufferCollectionBufferCreateInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCollectionBufferCreateInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferCollectionBufferCreateInfoFUCHSIA( BufferCollectionFUCHSIA collection_ = {}, + uint32_t index_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , collection{ collection_ } + , index{ index_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferCollectionBufferCreateInfoFUCHSIA( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferCollectionBufferCreateInfoFUCHSIA( VkBufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferCollectionBufferCreateInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + BufferCollectionBufferCreateInfoFUCHSIA & operator=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferCollectionBufferCreateInfoFUCHSIA & operator=( VkBufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA & setCollection( BufferCollectionFUCHSIA collection_ ) & VULKAN_HPP_NOEXCEPT + { + collection = collection_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA && setCollection( BufferCollectionFUCHSIA collection_ ) && VULKAN_HPP_NOEXCEPT + { + collection = collection_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT + { + index = index_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT + { + index = index_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferCollectionBufferCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCollectionBufferCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCollectionBufferCreateInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferCollectionBufferCreateInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collection, index ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferCollectionBufferCreateInfoFUCHSIA const & ) const = default; +# else + bool operator==( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && ( index == rhs.index ); +# endif + } + + bool operator!=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eBufferCollectionBufferCreateInfoFUCHSIA; + const void * pNext = {}; + BufferCollectionFUCHSIA collection = {}; + uint32_t index = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferCollectionBufferCreateInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = BufferCollectionBufferCreateInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkBufferCollectionConstraintsInfoFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionConstraintsInfoFUCHSIA.html + struct BufferCollectionConstraintsInfoFUCHSIA + { + using NativeType = VkBufferCollectionConstraintsInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCollectionConstraintsInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferCollectionConstraintsInfoFUCHSIA( uint32_t minBufferCount_ = {}, + uint32_t maxBufferCount_ = {}, + uint32_t minBufferCountForCamping_ = {}, + uint32_t minBufferCountForDedicatedSlack_ = {}, + uint32_t minBufferCountForSharedSlack_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minBufferCount{ minBufferCount_ } + , maxBufferCount{ maxBufferCount_ } + , minBufferCountForCamping{ minBufferCountForCamping_ } + , minBufferCountForDedicatedSlack{ minBufferCountForDedicatedSlack_ } + , minBufferCountForSharedSlack{ minBufferCountForSharedSlack_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferCollectionConstraintsInfoFUCHSIA( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferCollectionConstraintsInfoFUCHSIA( VkBufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferCollectionConstraintsInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + BufferCollectionConstraintsInfoFUCHSIA & operator=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferCollectionConstraintsInfoFUCHSIA & operator=( VkBufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCount( uint32_t minBufferCount_ ) & VULKAN_HPP_NOEXCEPT + { + minBufferCount = minBufferCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCount( uint32_t minBufferCount_ ) && VULKAN_HPP_NOEXCEPT + { + minBufferCount = minBufferCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMaxBufferCount( uint32_t maxBufferCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxBufferCount = maxBufferCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMaxBufferCount( uint32_t maxBufferCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxBufferCount = maxBufferCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCountForCamping( uint32_t minBufferCountForCamping_ ) & VULKAN_HPP_NOEXCEPT + { + minBufferCountForCamping = minBufferCountForCamping_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCountForCamping( uint32_t minBufferCountForCamping_ ) && VULKAN_HPP_NOEXCEPT + { + minBufferCountForCamping = minBufferCountForCamping_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCountForDedicatedSlack( uint32_t minBufferCountForDedicatedSlack_ ) & + VULKAN_HPP_NOEXCEPT + { + minBufferCountForDedicatedSlack = minBufferCountForDedicatedSlack_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCountForDedicatedSlack( uint32_t minBufferCountForDedicatedSlack_ ) && + VULKAN_HPP_NOEXCEPT + { + minBufferCountForDedicatedSlack = minBufferCountForDedicatedSlack_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCountForSharedSlack( uint32_t minBufferCountForSharedSlack_ ) & + VULKAN_HPP_NOEXCEPT + { + minBufferCountForSharedSlack = minBufferCountForSharedSlack_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCountForSharedSlack( uint32_t minBufferCountForSharedSlack_ ) && + VULKAN_HPP_NOEXCEPT + { + minBufferCountForSharedSlack = minBufferCountForSharedSlack_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferCollectionConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCollectionConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCollectionConstraintsInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferCollectionConstraintsInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minBufferCount, maxBufferCount, minBufferCountForCamping, minBufferCountForDedicatedSlack, minBufferCountForSharedSlack ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferCollectionConstraintsInfoFUCHSIA const & ) const = default; +# else + bool operator==( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minBufferCount == rhs.minBufferCount ) && ( maxBufferCount == rhs.maxBufferCount ) && + ( minBufferCountForCamping == rhs.minBufferCountForCamping ) && ( minBufferCountForDedicatedSlack == rhs.minBufferCountForDedicatedSlack ) && + ( minBufferCountForSharedSlack == rhs.minBufferCountForSharedSlack ); +# endif + } + + bool operator!=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eBufferCollectionConstraintsInfoFUCHSIA; + const void * pNext = {}; + uint32_t minBufferCount = {}; + uint32_t maxBufferCount = {}; + uint32_t minBufferCountForCamping = {}; + uint32_t minBufferCountForDedicatedSlack = {}; + uint32_t minBufferCountForSharedSlack = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferCollectionConstraintsInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = BufferCollectionConstraintsInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkBufferCollectionCreateInfoFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionCreateInfoFUCHSIA.html + struct BufferCollectionCreateInfoFUCHSIA + { + using NativeType = VkBufferCollectionCreateInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCollectionCreateInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferCollectionCreateInfoFUCHSIA( zx_handle_t collectionToken_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , collectionToken{ collectionToken_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferCollectionCreateInfoFUCHSIA( BufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferCollectionCreateInfoFUCHSIA( VkBufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferCollectionCreateInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + BufferCollectionCreateInfoFUCHSIA & operator=( BufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferCollectionCreateInfoFUCHSIA & operator=( VkBufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA & setCollectionToken( zx_handle_t collectionToken_ ) & VULKAN_HPP_NOEXCEPT + { + collectionToken = collectionToken_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA && setCollectionToken( zx_handle_t collectionToken_ ) && VULKAN_HPP_NOEXCEPT + { + collectionToken = collectionToken_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferCollectionCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCollectionCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCollectionCreateInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferCollectionCreateInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collectionToken ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ) == 0 ); + } + + bool operator!=( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eBufferCollectionCreateInfoFUCHSIA; + const void * pNext = {}; + zx_handle_t collectionToken = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferCollectionCreateInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = BufferCollectionCreateInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkBufferCollectionImageCreateInfoFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionImageCreateInfoFUCHSIA.html + struct BufferCollectionImageCreateInfoFUCHSIA + { + using NativeType = VkBufferCollectionImageCreateInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCollectionImageCreateInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferCollectionImageCreateInfoFUCHSIA( BufferCollectionFUCHSIA collection_ = {}, + uint32_t index_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , collection{ collection_ } + , index{ index_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferCollectionImageCreateInfoFUCHSIA( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferCollectionImageCreateInfoFUCHSIA( VkBufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferCollectionImageCreateInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + BufferCollectionImageCreateInfoFUCHSIA & operator=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferCollectionImageCreateInfoFUCHSIA & operator=( VkBufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA & setCollection( BufferCollectionFUCHSIA collection_ ) & VULKAN_HPP_NOEXCEPT + { + collection = collection_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA && setCollection( BufferCollectionFUCHSIA collection_ ) && VULKAN_HPP_NOEXCEPT + { + collection = collection_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT + { + index = index_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT + { + index = index_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferCollectionImageCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCollectionImageCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCollectionImageCreateInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferCollectionImageCreateInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collection, index ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferCollectionImageCreateInfoFUCHSIA const & ) const = default; +# else + bool operator==( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && ( index == rhs.index ); +# endif + } + + bool operator!=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eBufferCollectionImageCreateInfoFUCHSIA; + const void * pNext = {}; + BufferCollectionFUCHSIA collection = {}; + uint32_t index = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferCollectionImageCreateInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = BufferCollectionImageCreateInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkSysmemColorSpaceFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSysmemColorSpaceFUCHSIA.html + struct SysmemColorSpaceFUCHSIA + { + using NativeType = VkSysmemColorSpaceFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSysmemColorSpaceFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SysmemColorSpaceFUCHSIA( uint32_t colorSpace_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , colorSpace{ colorSpace_ } + { + } + + VULKAN_HPP_CONSTEXPR SysmemColorSpaceFUCHSIA( SysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SysmemColorSpaceFUCHSIA( VkSysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : SysmemColorSpaceFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + SysmemColorSpaceFUCHSIA & operator=( SysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SysmemColorSpaceFUCHSIA & operator=( VkSysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA & setColorSpace( uint32_t colorSpace_ ) & VULKAN_HPP_NOEXCEPT + { + colorSpace = colorSpace_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA && setColorSpace( uint32_t colorSpace_ ) && VULKAN_HPP_NOEXCEPT + { + colorSpace = colorSpace_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSysmemColorSpaceFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSysmemColorSpaceFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSysmemColorSpaceFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSysmemColorSpaceFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorSpace ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SysmemColorSpaceFUCHSIA const & ) const = default; +# else + bool operator==( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorSpace == rhs.colorSpace ); +# endif + } + + bool operator!=( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eSysmemColorSpaceFUCHSIA; + const void * pNext = {}; + uint32_t colorSpace = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SysmemColorSpaceFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = SysmemColorSpaceFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkBufferCollectionPropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionPropertiesFUCHSIA.html + struct BufferCollectionPropertiesFUCHSIA + { + using NativeType = VkBufferCollectionPropertiesFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCollectionPropertiesFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferCollectionPropertiesFUCHSIA( uint32_t memoryTypeBits_ = {}, + uint32_t bufferCount_ = {}, + uint32_t createInfoIndex_ = {}, + uint64_t sysmemPixelFormat_ = {}, + FormatFeatureFlags formatFeatures_ = {}, + SysmemColorSpaceFUCHSIA sysmemColorSpaceIndex_ = {}, + ComponentMapping samplerYcbcrConversionComponents_ = {}, + SamplerYcbcrModelConversion suggestedYcbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, + SamplerYcbcrRange suggestedYcbcrRange_ = SamplerYcbcrRange::eItuFull, + ChromaLocation suggestedXChromaOffset_ = ChromaLocation::eCositedEven, + ChromaLocation suggestedYChromaOffset_ = ChromaLocation::eCositedEven, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryTypeBits{ memoryTypeBits_ } + , bufferCount{ bufferCount_ } + , createInfoIndex{ createInfoIndex_ } + , sysmemPixelFormat{ sysmemPixelFormat_ } + , formatFeatures{ formatFeatures_ } + , sysmemColorSpaceIndex{ sysmemColorSpaceIndex_ } + , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ } + , suggestedYcbcrModel{ suggestedYcbcrModel_ } + , suggestedYcbcrRange{ suggestedYcbcrRange_ } + , suggestedXChromaOffset{ suggestedXChromaOffset_ } + , suggestedYChromaOffset{ suggestedYChromaOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferCollectionPropertiesFUCHSIA( BufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferCollectionPropertiesFUCHSIA( VkBufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferCollectionPropertiesFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + BufferCollectionPropertiesFUCHSIA & operator=( BufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferCollectionPropertiesFUCHSIA & operator=( VkBufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkBufferCollectionPropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCollectionPropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCollectionPropertiesFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferCollectionPropertiesFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + memoryTypeBits, + bufferCount, + createInfoIndex, + sysmemPixelFormat, + formatFeatures, + sysmemColorSpaceIndex, + samplerYcbcrConversionComponents, + suggestedYcbcrModel, + suggestedYcbcrRange, + suggestedXChromaOffset, + suggestedYChromaOffset ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferCollectionPropertiesFUCHSIA const & ) const = default; +# else + bool operator==( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ) && ( bufferCount == rhs.bufferCount ) && + ( createInfoIndex == rhs.createInfoIndex ) && ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( formatFeatures == rhs.formatFeatures ) && + ( sysmemColorSpaceIndex == rhs.sysmemColorSpaceIndex ) && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && + ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && + ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); +# endif + } + + bool operator!=( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eBufferCollectionPropertiesFUCHSIA; + void * pNext = {}; + uint32_t memoryTypeBits = {}; + uint32_t bufferCount = {}; + uint32_t createInfoIndex = {}; + uint64_t sysmemPixelFormat = {}; + FormatFeatureFlags formatFeatures = {}; + SysmemColorSpaceFUCHSIA sysmemColorSpaceIndex = {}; + ComponentMapping samplerYcbcrConversionComponents = {}; + SamplerYcbcrModelConversion suggestedYcbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; + SamplerYcbcrRange suggestedYcbcrRange = SamplerYcbcrRange::eItuFull; + ChromaLocation suggestedXChromaOffset = ChromaLocation::eCositedEven; + ChromaLocation suggestedYChromaOffset = ChromaLocation::eCositedEven; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferCollectionPropertiesFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = BufferCollectionPropertiesFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + // wrapper struct for struct VkBufferCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCreateInfo.html + struct BufferCreateInfo + { + using NativeType = VkBufferCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferCreateInfo( BufferCreateFlags flags_ = {}, + DeviceSize size_ = {}, + BufferUsageFlags usage_ = {}, + SharingMode sharingMode_ = SharingMode::eExclusive, + uint32_t queueFamilyIndexCount_ = {}, + const uint32_t * pQueueFamilyIndices_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , size{ size_ } + , usage{ usage_ } + , sharingMode{ sharingMode_ } + , queueFamilyIndexCount{ queueFamilyIndexCount_ } + , pQueueFamilyIndices{ pQueueFamilyIndices_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferCreateInfo( BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferCreateInfo( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : BufferCreateInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BufferCreateInfo( BufferCreateFlags flags_, + DeviceSize size_, + BufferUsageFlags usage_, + SharingMode sharingMode_, + ArrayProxyNoTemporaries const & queueFamilyIndices_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , size( size_ ) + , usage( usage_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( static_cast( queueFamilyIndices_.size() ) ) + , pQueueFamilyIndices( queueFamilyIndices_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + BufferCreateInfo & operator=( BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferCreateInfo & operator=( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setFlags( BufferCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setFlags( BufferCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setUsage( BufferUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setUsage( BufferUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setSharingMode( SharingMode sharingMode_ ) & VULKAN_HPP_NOEXCEPT + { + sharingMode = sharingMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setSharingMode( SharingMode sharingMode_ ) && VULKAN_HPP_NOEXCEPT + { + sharingMode = sharingMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) & VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) && VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + BufferCreateInfo & setQueueFamilyIndices( ArrayProxyNoTemporaries const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = static_cast( queueFamilyIndices_.size() ); + pQueueFamilyIndices = queueFamilyIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferCreateInfo const & ) const = default; +#else + bool operator==( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( size == rhs.size ) && ( usage == rhs.usage ) && + ( sharingMode == rhs.sharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); +# endif + } + + bool operator!=( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferCreateInfo; + const void * pNext = {}; + BufferCreateFlags flags = {}; + DeviceSize size = {}; + BufferUsageFlags usage = {}; + SharingMode sharingMode = SharingMode::eExclusive; + uint32_t queueFamilyIndexCount = {}; + const uint32_t * pQueueFamilyIndices = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BufferCreateInfo; + }; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkBufferConstraintsInfoFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferConstraintsInfoFUCHSIA.html + struct BufferConstraintsInfoFUCHSIA + { + using NativeType = VkBufferConstraintsInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferConstraintsInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferConstraintsInfoFUCHSIA( BufferCreateInfo createInfo_ = {}, + FormatFeatureFlags requiredFormatFeatures_ = {}, + BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , createInfo{ createInfo_ } + , requiredFormatFeatures{ requiredFormatFeatures_ } + , bufferCollectionConstraints{ bufferCollectionConstraints_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferConstraintsInfoFUCHSIA( BufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferConstraintsInfoFUCHSIA( VkBufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferConstraintsInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + BufferConstraintsInfoFUCHSIA & operator=( BufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferConstraintsInfoFUCHSIA & operator=( VkBufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA & setCreateInfo( BufferCreateInfo const & createInfo_ ) & VULKAN_HPP_NOEXCEPT + { + createInfo = createInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA && setCreateInfo( BufferCreateInfo const & createInfo_ ) && VULKAN_HPP_NOEXCEPT + { + createInfo = createInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA & setRequiredFormatFeatures( FormatFeatureFlags requiredFormatFeatures_ ) & VULKAN_HPP_NOEXCEPT + { + requiredFormatFeatures = requiredFormatFeatures_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA && setRequiredFormatFeatures( FormatFeatureFlags requiredFormatFeatures_ ) && VULKAN_HPP_NOEXCEPT + { + requiredFormatFeatures = requiredFormatFeatures_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA & + setBufferCollectionConstraints( BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraints_ ) & + VULKAN_HPP_NOEXCEPT + { + bufferCollectionConstraints = bufferCollectionConstraints_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA && + setBufferCollectionConstraints( BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraints_ ) && + VULKAN_HPP_NOEXCEPT + { + bufferCollectionConstraints = bufferCollectionConstraints_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferConstraintsInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferConstraintsInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, createInfo, requiredFormatFeatures, bufferCollectionConstraints ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferConstraintsInfoFUCHSIA const & ) const = default; +# else + bool operator==( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createInfo == rhs.createInfo ) && ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && + ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ); +# endif + } + + bool operator!=( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eBufferConstraintsInfoFUCHSIA; + const void * pNext = {}; + BufferCreateInfo createInfo = {}; + FormatFeatureFlags requiredFormatFeatures = {}; + BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferConstraintsInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = BufferConstraintsInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + // wrapper struct for struct VkBufferCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCopy.html + struct BufferCopy + { + using NativeType = VkBufferCopy; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferCopy( DeviceSize srcOffset_ = {}, DeviceSize dstOffset_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT + : srcOffset{ srcOffset_ } + , dstOffset{ dstOffset_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferCopy( BufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferCopy( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT : BufferCopy( *reinterpret_cast( &rhs ) ) {} + + BufferCopy & operator=( BufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferCopy & operator=( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferCopy & setSrcOffset( DeviceSize srcOffset_ ) & VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy && setSrcOffset( DeviceSize srcOffset_ ) && VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy & setDstOffset( DeviceSize dstOffset_ ) & VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy && setDstOffset( DeviceSize dstOffset_ ) && VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferCopy const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCopy &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCopy const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferCopy *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcOffset, dstOffset, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferCopy const & ) const = default; +#else + bool operator==( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size ); +# endif + } + + bool operator!=( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceSize srcOffset = {}; + DeviceSize dstOffset = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferCopy; + }; +#endif + + // wrapper struct for struct VkBufferCopy2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCopy2.html + struct BufferCopy2 + { + using NativeType = VkBufferCopy2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCopy2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + BufferCopy2( DeviceSize srcOffset_ = {}, DeviceSize dstOffset_ = {}, DeviceSize size_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcOffset{ srcOffset_ } + , dstOffset{ dstOffset_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferCopy2( BufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferCopy2( VkBufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT : BufferCopy2( *reinterpret_cast( &rhs ) ) {} + + BufferCopy2 & operator=( BufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferCopy2 & operator=( VkBufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setSrcOffset( DeviceSize srcOffset_ ) & VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setSrcOffset( DeviceSize srcOffset_ ) && VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setDstOffset( DeviceSize dstOffset_ ) & VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setDstOffset( DeviceSize dstOffset_ ) && VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferCopy2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCopy2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferCopy2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferCopy2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcOffset, dstOffset, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferCopy2 const & ) const = default; +#else + bool operator==( BufferCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size ); +# endif + } + + bool operator!=( BufferCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferCopy2; + const void * pNext = {}; + DeviceSize srcOffset = {}; + DeviceSize dstOffset = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferCopy2; + }; +#endif + + template <> + struct CppType + { + using Type = BufferCopy2; + }; + + using BufferCopy2KHR = BufferCopy2; + + // wrapper struct for struct VkBufferDeviceAddressCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferDeviceAddressCreateInfoEXT.html + struct BufferDeviceAddressCreateInfoEXT + { + using NativeType = VkBufferDeviceAddressCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferDeviceAddressCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( DeviceAddress deviceAddress_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceAddress{ deviceAddress_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferDeviceAddressCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + BufferDeviceAddressCreateInfoEXT & operator=( BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferDeviceAddressCreateInfoEXT & operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferDeviceAddressCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferDeviceAddressCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferDeviceAddressCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferDeviceAddressCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceAddress ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferDeviceAddressCreateInfoEXT const & ) const = default; +#else + bool operator==( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ); +# endif + } + + bool operator!=( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT; + const void * pNext = {}; + DeviceAddress deviceAddress = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferDeviceAddressCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = BufferDeviceAddressCreateInfoEXT; + }; + + // wrapper struct for struct VkBufferDeviceAddressInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferDeviceAddressInfo.html + struct BufferDeviceAddressInfo + { + using NativeType = VkBufferDeviceAddressInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferDeviceAddressInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfo( Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , buffer{ buffer_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfo( BufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferDeviceAddressInfo( VkBufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferDeviceAddressInfo( *reinterpret_cast( &rhs ) ) + { + } + + BufferDeviceAddressInfo & operator=( BufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferDeviceAddressInfo & operator=( VkBufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferDeviceAddressInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferDeviceAddressInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferDeviceAddressInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferDeviceAddressInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferDeviceAddressInfo const & ) const = default; +#else + bool operator==( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); +# endif + } + + bool operator!=( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferDeviceAddressInfo; + const void * pNext = {}; + Buffer buffer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferDeviceAddressInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BufferDeviceAddressInfo; + }; + + using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo; + using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo; + + // wrapper struct for struct VkBufferImageCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferImageCopy.html + struct BufferImageCopy + { + using NativeType = VkBufferImageCopy; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferImageCopy( DeviceSize bufferOffset_ = {}, + uint32_t bufferRowLength_ = {}, + uint32_t bufferImageHeight_ = {}, + ImageSubresourceLayers imageSubresource_ = {}, + Offset3D imageOffset_ = {}, + Extent3D imageExtent_ = {} ) VULKAN_HPP_NOEXCEPT + : bufferOffset{ bufferOffset_ } + , bufferRowLength{ bufferRowLength_ } + , bufferImageHeight{ bufferImageHeight_ } + , imageSubresource{ imageSubresource_ } + , imageOffset{ imageOffset_ } + , imageExtent{ imageExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferImageCopy( BufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferImageCopy( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT : BufferImageCopy( *reinterpret_cast( &rhs ) ) {} + + BufferImageCopy & operator=( BufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferImageCopy & operator=( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setBufferOffset( DeviceSize bufferOffset_ ) & VULKAN_HPP_NOEXCEPT + { + bufferOffset = bufferOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setBufferOffset( DeviceSize bufferOffset_ ) && VULKAN_HPP_NOEXCEPT + { + bufferOffset = bufferOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setBufferRowLength( uint32_t bufferRowLength_ ) & VULKAN_HPP_NOEXCEPT + { + bufferRowLength = bufferRowLength_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setBufferRowLength( uint32_t bufferRowLength_ ) && VULKAN_HPP_NOEXCEPT + { + bufferRowLength = bufferRowLength_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setBufferImageHeight( uint32_t bufferImageHeight_ ) & VULKAN_HPP_NOEXCEPT + { + bufferImageHeight = bufferImageHeight_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setBufferImageHeight( uint32_t bufferImageHeight_ ) && VULKAN_HPP_NOEXCEPT + { + bufferImageHeight = bufferImageHeight_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferImageCopy const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferImageCopy &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferImageCopy const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferImageCopy *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferImageCopy const & ) const = default; +#else + bool operator==( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) && ( bufferImageHeight == rhs.bufferImageHeight ) && + ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent ); +# endif + } + + bool operator!=( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceSize bufferOffset = {}; + uint32_t bufferRowLength = {}; + uint32_t bufferImageHeight = {}; + ImageSubresourceLayers imageSubresource = {}; + Offset3D imageOffset = {}; + Extent3D imageExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferImageCopy; + }; +#endif + + // wrapper struct for struct VkBufferImageCopy2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferImageCopy2.html + struct BufferImageCopy2 + { + using NativeType = VkBufferImageCopy2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferImageCopy2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferImageCopy2( DeviceSize bufferOffset_ = {}, + uint32_t bufferRowLength_ = {}, + uint32_t bufferImageHeight_ = {}, + ImageSubresourceLayers imageSubresource_ = {}, + Offset3D imageOffset_ = {}, + Extent3D imageExtent_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , bufferOffset{ bufferOffset_ } + , bufferRowLength{ bufferRowLength_ } + , bufferImageHeight{ bufferImageHeight_ } + , imageSubresource{ imageSubresource_ } + , imageOffset{ imageOffset_ } + , imageExtent{ imageExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferImageCopy2( BufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferImageCopy2( VkBufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT : BufferImageCopy2( *reinterpret_cast( &rhs ) ) {} + + BufferImageCopy2 & operator=( BufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferImageCopy2 & operator=( VkBufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setBufferOffset( DeviceSize bufferOffset_ ) & VULKAN_HPP_NOEXCEPT + { + bufferOffset = bufferOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setBufferOffset( DeviceSize bufferOffset_ ) && VULKAN_HPP_NOEXCEPT + { + bufferOffset = bufferOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setBufferRowLength( uint32_t bufferRowLength_ ) & VULKAN_HPP_NOEXCEPT + { + bufferRowLength = bufferRowLength_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setBufferRowLength( uint32_t bufferRowLength_ ) && VULKAN_HPP_NOEXCEPT + { + bufferRowLength = bufferRowLength_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setBufferImageHeight( uint32_t bufferImageHeight_ ) & VULKAN_HPP_NOEXCEPT + { + bufferImageHeight = bufferImageHeight_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setBufferImageHeight( uint32_t bufferImageHeight_ ) && VULKAN_HPP_NOEXCEPT + { + bufferImageHeight = bufferImageHeight_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferImageCopy2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferImageCopy2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferImageCopy2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferImageCopy2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferImageCopy2 const & ) const = default; +#else + bool operator==( BufferImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) && + ( bufferImageHeight == rhs.bufferImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && + ( imageExtent == rhs.imageExtent ); +# endif + } + + bool operator!=( BufferImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferImageCopy2; + const void * pNext = {}; + DeviceSize bufferOffset = {}; + uint32_t bufferRowLength = {}; + uint32_t bufferImageHeight = {}; + ImageSubresourceLayers imageSubresource = {}; + Offset3D imageOffset = {}; + Extent3D imageExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferImageCopy2; + }; +#endif + + template <> + struct CppType + { + using Type = BufferImageCopy2; + }; + + using BufferImageCopy2KHR = BufferImageCopy2; + + // wrapper struct for struct VkBufferMemoryBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferMemoryBarrier.html + struct BufferMemoryBarrier + { + using NativeType = VkBufferMemoryBarrier; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryBarrier; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( AccessFlags srcAccessMask_ = {}, + AccessFlags dstAccessMask_ = {}, + uint32_t srcQueueFamilyIndex_ = {}, + uint32_t dstQueueFamilyIndex_ = {}, + Buffer buffer_ = {}, + DeviceSize offset_ = {}, + DeviceSize size_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcAccessMask{ srcAccessMask_ } + , dstAccessMask{ dstAccessMask_ } + , srcQueueFamilyIndex{ srcQueueFamilyIndex_ } + , dstQueueFamilyIndex{ dstQueueFamilyIndex_ } + , buffer{ buffer_ } + , offset{ offset_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT : BufferMemoryBarrier( *reinterpret_cast( &rhs ) ) + { + } + + BufferMemoryBarrier & operator=( BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferMemoryBarrier & operator=( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setSrcAccessMask( AccessFlags srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setDstAccessMask( AccessFlags dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferMemoryBarrier &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferMemoryBarrier const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferMemoryBarrier *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcAccessMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferMemoryBarrier const & ) const = default; +#else + bool operator==( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) && + ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) && + ( offset == rhs.offset ) && ( size == rhs.size ); +# endif + } + + bool operator!=( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferMemoryBarrier; + const void * pNext = {}; + AccessFlags srcAccessMask = {}; + AccessFlags dstAccessMask = {}; + uint32_t srcQueueFamilyIndex = {}; + uint32_t dstQueueFamilyIndex = {}; + Buffer buffer = {}; + DeviceSize offset = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferMemoryBarrier; + }; +#endif + + template <> + struct CppType + { + using Type = BufferMemoryBarrier; + }; + + // wrapper struct for struct VkBufferMemoryBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferMemoryBarrier2.html + struct BufferMemoryBarrier2 + { + using NativeType = VkBufferMemoryBarrier2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryBarrier2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferMemoryBarrier2( PipelineStageFlags2 srcStageMask_ = {}, + AccessFlags2 srcAccessMask_ = {}, + PipelineStageFlags2 dstStageMask_ = {}, + AccessFlags2 dstAccessMask_ = {}, + uint32_t srcQueueFamilyIndex_ = {}, + uint32_t dstQueueFamilyIndex_ = {}, + Buffer buffer_ = {}, + DeviceSize offset_ = {}, + DeviceSize size_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcStageMask{ srcStageMask_ } + , srcAccessMask{ srcAccessMask_ } + , dstStageMask{ dstStageMask_ } + , dstAccessMask{ dstAccessMask_ } + , srcQueueFamilyIndex{ srcQueueFamilyIndex_ } + , dstQueueFamilyIndex{ dstQueueFamilyIndex_ } + , buffer{ buffer_ } + , offset{ offset_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferMemoryBarrier2( BufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferMemoryBarrier2( VkBufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferMemoryBarrier2( *reinterpret_cast( &rhs ) ) + { + } + + BufferMemoryBarrier2 & operator=( BufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferMemoryBarrier2 & operator=( VkBufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferMemoryBarrier2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferMemoryBarrier2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferMemoryBarrier2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferMemoryBarrier2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferMemoryBarrier2 const & ) const = default; +#else + bool operator==( BufferMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && + ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && + ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( size == rhs.size ); +# endif + } + + bool operator!=( BufferMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferMemoryBarrier2; + const void * pNext = {}; + PipelineStageFlags2 srcStageMask = {}; + AccessFlags2 srcAccessMask = {}; + PipelineStageFlags2 dstStageMask = {}; + AccessFlags2 dstAccessMask = {}; + uint32_t srcQueueFamilyIndex = {}; + uint32_t dstQueueFamilyIndex = {}; + Buffer buffer = {}; + DeviceSize offset = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferMemoryBarrier2; + }; +#endif + + template <> + struct CppType + { + using Type = BufferMemoryBarrier2; + }; + + using BufferMemoryBarrier2KHR = BufferMemoryBarrier2; + + // wrapper struct for struct VkBufferMemoryRequirementsInfo2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferMemoryRequirementsInfo2.html + struct BufferMemoryRequirementsInfo2 + { + using NativeType = VkBufferMemoryRequirementsInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryRequirementsInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , buffer{ buffer_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferMemoryRequirementsInfo2( *reinterpret_cast( &rhs ) ) + { + } + + BufferMemoryRequirementsInfo2 & operator=( BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferMemoryRequirementsInfo2 & operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferMemoryRequirementsInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferMemoryRequirementsInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferMemoryRequirementsInfo2 const & ) const = default; +#else + bool operator==( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); +# endif + } + + bool operator!=( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferMemoryRequirementsInfo2; + const void * pNext = {}; + Buffer buffer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferMemoryRequirementsInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = BufferMemoryRequirementsInfo2; + }; + + using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2; + + // wrapper struct for struct VkBufferOpaqueCaptureAddressCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html + struct BufferOpaqueCaptureAddressCreateInfo + { + using NativeType = VkBufferOpaqueCaptureAddressCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferOpaqueCaptureAddressCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferOpaqueCaptureAddressCreateInfo( uint64_t opaqueCaptureAddress_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , opaqueCaptureAddress{ opaqueCaptureAddress_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferOpaqueCaptureAddressCreateInfo( BufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferOpaqueCaptureAddressCreateInfo( VkBufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferOpaqueCaptureAddressCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + BufferOpaqueCaptureAddressCreateInfo & operator=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferOpaqueCaptureAddressCreateInfo & operator=( VkBufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo & setOpaqueCaptureAddress( uint64_t opaqueCaptureAddress_ ) & VULKAN_HPP_NOEXCEPT + { + opaqueCaptureAddress = opaqueCaptureAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo && setOpaqueCaptureAddress( uint64_t opaqueCaptureAddress_ ) && VULKAN_HPP_NOEXCEPT + { + opaqueCaptureAddress = opaqueCaptureAddress_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferOpaqueCaptureAddressCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferOpaqueCaptureAddressCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferOpaqueCaptureAddressCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferOpaqueCaptureAddressCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, opaqueCaptureAddress ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferOpaqueCaptureAddressCreateInfo const & ) const = default; +#else + bool operator==( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress ); +# endif + } + + bool operator!=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferOpaqueCaptureAddressCreateInfo; + const void * pNext = {}; + uint64_t opaqueCaptureAddress = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferOpaqueCaptureAddressCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BufferOpaqueCaptureAddressCreateInfo; + }; + + using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo; + + // wrapper struct for struct VkBufferUsageFlags2CreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlags2CreateInfo.html + struct BufferUsageFlags2CreateInfo + { + using NativeType = VkBufferUsageFlags2CreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferUsageFlags2CreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferUsageFlags2CreateInfo( BufferUsageFlags2 usage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , usage{ usage_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferUsageFlags2CreateInfo( BufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferUsageFlags2CreateInfo( VkBufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferUsageFlags2CreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + BufferUsageFlags2CreateInfo & operator=( BufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferUsageFlags2CreateInfo & operator=( VkBufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo & setUsage( BufferUsageFlags2 usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo && setUsage( BufferUsageFlags2 usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferUsageFlags2CreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferUsageFlags2CreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferUsageFlags2CreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferUsageFlags2CreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, usage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferUsageFlags2CreateInfo const & ) const = default; +#else + bool operator==( BufferUsageFlags2CreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage ); +# endif + } + + bool operator!=( BufferUsageFlags2CreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferUsageFlags2CreateInfo; + const void * pNext = {}; + BufferUsageFlags2 usage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferUsageFlags2CreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BufferUsageFlags2CreateInfo; + }; + + using BufferUsageFlags2CreateInfoKHR = BufferUsageFlags2CreateInfo; + + // wrapper struct for struct VkBufferViewCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferViewCreateInfo.html + struct BufferViewCreateInfo + { + using NativeType = VkBufferViewCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferViewCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( BufferViewCreateFlags flags_ = {}, + Buffer buffer_ = {}, + Format format_ = Format::eUndefined, + DeviceSize offset_ = {}, + DeviceSize range_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , buffer{ buffer_ } + , format{ format_ } + , offset{ offset_ } + , range{ range_ } + { + } + + VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : BufferViewCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + BufferViewCreateInfo & operator=( BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BufferViewCreateInfo & operator=( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setFlags( BufferViewCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setFlags( BufferViewCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setRange( DeviceSize range_ ) & VULKAN_HPP_NOEXCEPT + { + range = range_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setRange( DeviceSize range_ ) && VULKAN_HPP_NOEXCEPT + { + range = range_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBufferViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferViewCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBufferViewCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBufferViewCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, buffer, format, offset, range ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BufferViewCreateInfo const & ) const = default; +#else + bool operator==( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( buffer == rhs.buffer ) && ( format == rhs.format ) && + ( offset == rhs.offset ) && ( range == rhs.range ); +# endif + } + + bool operator!=( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBufferViewCreateInfo; + const void * pNext = {}; + BufferViewCreateFlags flags = {}; + Buffer buffer = {}; + Format format = Format::eUndefined; + DeviceSize offset = {}; + DeviceSize range = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BufferViewCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = BufferViewCreateInfo; + }; + + // wrapper struct for struct VkStridedDeviceAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressNV.html + struct StridedDeviceAddressNV + { + using NativeType = VkStridedDeviceAddressNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR StridedDeviceAddressNV( DeviceAddress startAddress_ = {}, DeviceSize strideInBytes_ = {} ) VULKAN_HPP_NOEXCEPT + : startAddress{ startAddress_ } + , strideInBytes{ strideInBytes_ } + { + } + + VULKAN_HPP_CONSTEXPR StridedDeviceAddressNV( StridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + StridedDeviceAddressNV( VkStridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT + : StridedDeviceAddressNV( *reinterpret_cast( &rhs ) ) + { + } + + StridedDeviceAddressNV & operator=( StridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + StridedDeviceAddressNV & operator=( VkStridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV & setStartAddress( DeviceAddress startAddress_ ) & VULKAN_HPP_NOEXCEPT + { + startAddress = startAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV && setStartAddress( DeviceAddress startAddress_ ) && VULKAN_HPP_NOEXCEPT + { + startAddress = startAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV & setStrideInBytes( DeviceSize strideInBytes_ ) & VULKAN_HPP_NOEXCEPT + { + strideInBytes = strideInBytes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV && setStrideInBytes( DeviceSize strideInBytes_ ) && VULKAN_HPP_NOEXCEPT + { + strideInBytes = strideInBytes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkStridedDeviceAddressNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( startAddress, strideInBytes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( StridedDeviceAddressNV const & ) const = default; +#else + bool operator==( StridedDeviceAddressNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( startAddress == rhs.startAddress ) && ( strideInBytes == rhs.strideInBytes ); +# endif + } + + bool operator!=( StridedDeviceAddressNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress startAddress = {}; + DeviceSize strideInBytes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = StridedDeviceAddressNV; + }; +#endif + + // wrapper struct for struct VkBuildPartitionedAccelerationStructureIndirectCommandNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildPartitionedAccelerationStructureIndirectCommandNV.html + struct BuildPartitionedAccelerationStructureIndirectCommandNV + { + using NativeType = VkBuildPartitionedAccelerationStructureIndirectCommandNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureIndirectCommandNV( + PartitionedAccelerationStructureOpTypeNV opType_ = PartitionedAccelerationStructureOpTypeNV::eWriteInstance, + uint32_t argCount_ = {}, + StridedDeviceAddressNV argData_ = {} ) VULKAN_HPP_NOEXCEPT + : opType{ opType_ } + , argCount{ argCount_ } + , argData{ argData_ } + { + } + + VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureIndirectCommandNV( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + BuildPartitionedAccelerationStructureIndirectCommandNV( VkBuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + : BuildPartitionedAccelerationStructureIndirectCommandNV( *reinterpret_cast( &rhs ) ) + { + } + + BuildPartitionedAccelerationStructureIndirectCommandNV & + operator=( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BuildPartitionedAccelerationStructureIndirectCommandNV & + operator=( VkBuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV & setOpType( PartitionedAccelerationStructureOpTypeNV opType_ ) & + VULKAN_HPP_NOEXCEPT + { + opType = opType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV && setOpType( PartitionedAccelerationStructureOpTypeNV opType_ ) && + VULKAN_HPP_NOEXCEPT + { + opType = opType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV & setArgCount( uint32_t argCount_ ) & VULKAN_HPP_NOEXCEPT + { + argCount = argCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV && setArgCount( uint32_t argCount_ ) && VULKAN_HPP_NOEXCEPT + { + argCount = argCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV & setArgData( StridedDeviceAddressNV const & argData_ ) & VULKAN_HPP_NOEXCEPT + { + argData = argData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV && setArgData( StridedDeviceAddressNV const & argData_ ) && + VULKAN_HPP_NOEXCEPT + { + argData = argData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBuildPartitionedAccelerationStructureIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBuildPartitionedAccelerationStructureIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBuildPartitionedAccelerationStructureIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBuildPartitionedAccelerationStructureIndirectCommandNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( opType, argCount, argData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BuildPartitionedAccelerationStructureIndirectCommandNV const & ) const = default; +#else + bool operator==( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( opType == rhs.opType ) && ( argCount == rhs.argCount ) && ( argData == rhs.argData ); +# endif + } + + bool operator!=( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + PartitionedAccelerationStructureOpTypeNV opType = PartitionedAccelerationStructureOpTypeNV::eWriteInstance; + uint32_t argCount = {}; + StridedDeviceAddressNV argData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BuildPartitionedAccelerationStructureIndirectCommandNV; + }; +#endif + + // wrapper struct for struct VkPartitionedAccelerationStructureInstancesInputNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureInstancesInputNV.html + struct PartitionedAccelerationStructureInstancesInputNV + { + using NativeType = VkPartitionedAccelerationStructureInstancesInputNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePartitionedAccelerationStructureInstancesInputNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PartitionedAccelerationStructureInstancesInputNV( BuildAccelerationStructureFlagsKHR flags_ = {}, + uint32_t instanceCount_ = {}, + uint32_t maxInstancePerPartitionCount_ = {}, + uint32_t partitionCount_ = {}, + uint32_t maxInstanceInGlobalPartitionCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , instanceCount{ instanceCount_ } + , maxInstancePerPartitionCount{ maxInstancePerPartitionCount_ } + , partitionCount{ partitionCount_ } + , maxInstanceInGlobalPartitionCount{ maxInstanceInGlobalPartitionCount_ } + { + } + + VULKAN_HPP_CONSTEXPR + PartitionedAccelerationStructureInstancesInputNV( PartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PartitionedAccelerationStructureInstancesInputNV( VkPartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PartitionedAccelerationStructureInstancesInputNV( *reinterpret_cast( &rhs ) ) + { + } + + PartitionedAccelerationStructureInstancesInputNV & operator=( PartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PartitionedAccelerationStructureInstancesInputNV & operator=( VkPartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setFlags( BuildAccelerationStructureFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setFlags( BuildAccelerationStructureFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setInstanceCount( uint32_t instanceCount_ ) & VULKAN_HPP_NOEXCEPT + { + instanceCount = instanceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setInstanceCount( uint32_t instanceCount_ ) && VULKAN_HPP_NOEXCEPT + { + instanceCount = instanceCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setMaxInstancePerPartitionCount( uint32_t maxInstancePerPartitionCount_ ) & + VULKAN_HPP_NOEXCEPT + { + maxInstancePerPartitionCount = maxInstancePerPartitionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setMaxInstancePerPartitionCount( uint32_t maxInstancePerPartitionCount_ ) && + VULKAN_HPP_NOEXCEPT + { + maxInstancePerPartitionCount = maxInstancePerPartitionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setPartitionCount( uint32_t partitionCount_ ) & VULKAN_HPP_NOEXCEPT + { + partitionCount = partitionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setPartitionCount( uint32_t partitionCount_ ) && VULKAN_HPP_NOEXCEPT + { + partitionCount = partitionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & + setMaxInstanceInGlobalPartitionCount( uint32_t maxInstanceInGlobalPartitionCount_ ) & + VULKAN_HPP_NOEXCEPT + { + maxInstanceInGlobalPartitionCount = maxInstanceInGlobalPartitionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && + setMaxInstanceInGlobalPartitionCount( uint32_t maxInstanceInGlobalPartitionCount_ ) && + VULKAN_HPP_NOEXCEPT + { + maxInstanceInGlobalPartitionCount = maxInstanceInGlobalPartitionCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPartitionedAccelerationStructureInstancesInputNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureInstancesInputNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureInstancesInputNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureInstancesInputNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, instanceCount, maxInstancePerPartitionCount, partitionCount, maxInstanceInGlobalPartitionCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PartitionedAccelerationStructureInstancesInputNV const & ) const = default; +#else + bool operator==( PartitionedAccelerationStructureInstancesInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( instanceCount == rhs.instanceCount ) && + ( maxInstancePerPartitionCount == rhs.maxInstancePerPartitionCount ) && ( partitionCount == rhs.partitionCount ) && + ( maxInstanceInGlobalPartitionCount == rhs.maxInstanceInGlobalPartitionCount ); +# endif + } + + bool operator!=( PartitionedAccelerationStructureInstancesInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePartitionedAccelerationStructureInstancesInputNV; + void * pNext = {}; + BuildAccelerationStructureFlagsKHR flags = {}; + uint32_t instanceCount = {}; + uint32_t maxInstancePerPartitionCount = {}; + uint32_t partitionCount = {}; + uint32_t maxInstanceInGlobalPartitionCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PartitionedAccelerationStructureInstancesInputNV; + }; +#endif + + template <> + struct CppType + { + using Type = PartitionedAccelerationStructureInstancesInputNV; + }; + + // wrapper struct for struct VkBuildPartitionedAccelerationStructureInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildPartitionedAccelerationStructureInfoNV.html + struct BuildPartitionedAccelerationStructureInfoNV + { + using NativeType = VkBuildPartitionedAccelerationStructureInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBuildPartitionedAccelerationStructureInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureInfoNV( PartitionedAccelerationStructureInstancesInputNV input_ = {}, + DeviceAddress srcAccelerationStructureData_ = {}, + DeviceAddress dstAccelerationStructureData_ = {}, + DeviceAddress scratchData_ = {}, + DeviceAddress srcInfos_ = {}, + DeviceAddress srcInfosCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , input{ input_ } + , srcAccelerationStructureData{ srcAccelerationStructureData_ } + , dstAccelerationStructureData{ dstAccelerationStructureData_ } + , scratchData{ scratchData_ } + , srcInfos{ srcInfos_ } + , srcInfosCount{ srcInfosCount_ } + { + } + + VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureInfoNV( BuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + BuildPartitionedAccelerationStructureInfoNV( VkBuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : BuildPartitionedAccelerationStructureInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + BuildPartitionedAccelerationStructureInfoNV & operator=( BuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + BuildPartitionedAccelerationStructureInfoNV & operator=( VkBuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setInput( PartitionedAccelerationStructureInstancesInputNV const & input_ ) & + VULKAN_HPP_NOEXCEPT + { + input = input_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setInput( PartitionedAccelerationStructureInstancesInputNV const & input_ ) && + VULKAN_HPP_NOEXCEPT + { + input = input_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setSrcAccelerationStructureData( DeviceAddress srcAccelerationStructureData_ ) & + VULKAN_HPP_NOEXCEPT + { + srcAccelerationStructureData = srcAccelerationStructureData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setSrcAccelerationStructureData( DeviceAddress srcAccelerationStructureData_ ) && + VULKAN_HPP_NOEXCEPT + { + srcAccelerationStructureData = srcAccelerationStructureData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setDstAccelerationStructureData( DeviceAddress dstAccelerationStructureData_ ) & + VULKAN_HPP_NOEXCEPT + { + dstAccelerationStructureData = dstAccelerationStructureData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setDstAccelerationStructureData( DeviceAddress dstAccelerationStructureData_ ) && + VULKAN_HPP_NOEXCEPT + { + dstAccelerationStructureData = dstAccelerationStructureData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setScratchData( DeviceAddress scratchData_ ) & VULKAN_HPP_NOEXCEPT + { + scratchData = scratchData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setScratchData( DeviceAddress scratchData_ ) && VULKAN_HPP_NOEXCEPT + { + scratchData = scratchData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setSrcInfos( DeviceAddress srcInfos_ ) & VULKAN_HPP_NOEXCEPT + { + srcInfos = srcInfos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setSrcInfos( DeviceAddress srcInfos_ ) && VULKAN_HPP_NOEXCEPT + { + srcInfos = srcInfos_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setSrcInfosCount( DeviceAddress srcInfosCount_ ) & VULKAN_HPP_NOEXCEPT + { + srcInfosCount = srcInfosCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setSrcInfosCount( DeviceAddress srcInfosCount_ ) && VULKAN_HPP_NOEXCEPT + { + srcInfosCount = srcInfosCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkBuildPartitionedAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBuildPartitionedAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkBuildPartitionedAccelerationStructureInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkBuildPartitionedAccelerationStructureInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, input, srcAccelerationStructureData, dstAccelerationStructureData, scratchData, srcInfos, srcInfosCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( BuildPartitionedAccelerationStructureInfoNV const & ) const = default; +#else + bool operator==( BuildPartitionedAccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( input == rhs.input ) && + ( srcAccelerationStructureData == rhs.srcAccelerationStructureData ) && ( dstAccelerationStructureData == rhs.dstAccelerationStructureData ) && + ( scratchData == rhs.scratchData ) && ( srcInfos == rhs.srcInfos ) && ( srcInfosCount == rhs.srcInfosCount ); +# endif + } + + bool operator!=( BuildPartitionedAccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eBuildPartitionedAccelerationStructureInfoNV; + void * pNext = {}; + PartitionedAccelerationStructureInstancesInputNV input = {}; + DeviceAddress srcAccelerationStructureData = {}; + DeviceAddress dstAccelerationStructureData = {}; + DeviceAddress scratchData = {}; + DeviceAddress srcInfos = {}; + DeviceAddress srcInfosCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = BuildPartitionedAccelerationStructureInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = BuildPartitionedAccelerationStructureInfoNV; + }; + + // wrapper struct for struct VkCalibratedTimestampInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCalibratedTimestampInfoKHR.html + struct CalibratedTimestampInfoKHR + { + using NativeType = VkCalibratedTimestampInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCalibratedTimestampInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoKHR( TimeDomainKHR timeDomain_ = TimeDomainKHR::eDevice, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , timeDomain{ timeDomain_ } + { + } + + VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoKHR( CalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CalibratedTimestampInfoKHR( VkCalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : CalibratedTimestampInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + CalibratedTimestampInfoKHR & operator=( CalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CalibratedTimestampInfoKHR & operator=( VkCalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR & setTimeDomain( TimeDomainKHR timeDomain_ ) & VULKAN_HPP_NOEXCEPT + { + timeDomain = timeDomain_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR && setTimeDomain( TimeDomainKHR timeDomain_ ) && VULKAN_HPP_NOEXCEPT + { + timeDomain = timeDomain_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCalibratedTimestampInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCalibratedTimestampInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCalibratedTimestampInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCalibratedTimestampInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, timeDomain ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CalibratedTimestampInfoKHR const & ) const = default; +#else + bool operator==( CalibratedTimestampInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomain == rhs.timeDomain ); +# endif + } + + bool operator!=( CalibratedTimestampInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCalibratedTimestampInfoKHR; + const void * pNext = {}; + TimeDomainKHR timeDomain = TimeDomainKHR::eDevice; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CalibratedTimestampInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = CalibratedTimestampInfoKHR; + }; + + using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR; + + // wrapper struct for struct VkCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCheckpointData2NV.html + struct CheckpointData2NV + { + using NativeType = VkCheckpointData2NV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCheckpointData2NV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CheckpointData2NV( PipelineStageFlags2 stage_ = {}, void * pCheckpointMarker_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stage{ stage_ } + , pCheckpointMarker{ pCheckpointMarker_ } + { + } + + VULKAN_HPP_CONSTEXPR CheckpointData2NV( CheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CheckpointData2NV( VkCheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT : CheckpointData2NV( *reinterpret_cast( &rhs ) ) {} + + CheckpointData2NV & operator=( CheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CheckpointData2NV & operator=( VkCheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkCheckpointData2NV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCheckpointData2NV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCheckpointData2NV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCheckpointData2NV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stage, pCheckpointMarker ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CheckpointData2NV const & ) const = default; +#else + bool operator==( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && ( pCheckpointMarker == rhs.pCheckpointMarker ); +# endif + } + + bool operator!=( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCheckpointData2NV; + void * pNext = {}; + PipelineStageFlags2 stage = {}; + void * pCheckpointMarker = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CheckpointData2NV; + }; +#endif + + template <> + struct CppType + { + using Type = CheckpointData2NV; + }; + + // wrapper struct for struct VkCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCheckpointDataNV.html + struct CheckpointDataNV + { + using NativeType = VkCheckpointDataNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCheckpointDataNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CheckpointDataNV( PipelineStageFlagBits stage_ = PipelineStageFlagBits::eTopOfPipe, + void * pCheckpointMarker_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stage{ stage_ } + , pCheckpointMarker{ pCheckpointMarker_ } + { + } + + VULKAN_HPP_CONSTEXPR CheckpointDataNV( CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CheckpointDataNV( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT : CheckpointDataNV( *reinterpret_cast( &rhs ) ) {} + + CheckpointDataNV & operator=( CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CheckpointDataNV & operator=( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkCheckpointDataNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCheckpointDataNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCheckpointDataNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCheckpointDataNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stage, pCheckpointMarker ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CheckpointDataNV const & ) const = default; +#else + bool operator==( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && ( pCheckpointMarker == rhs.pCheckpointMarker ); +# endif + } + + bool operator!=( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCheckpointDataNV; + void * pNext = {}; + PipelineStageFlagBits stage = PipelineStageFlagBits::eTopOfPipe; + void * pCheckpointMarker = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CheckpointDataNV; + }; +#endif + + template <> + struct CppType + { + using Type = CheckpointDataNV; + }; + + union ClearColorValue + { + using NativeType = VkClearColorValue; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 ClearColorValue( const std::array & float32_ = {} ) : float32( float32_ ) {} + + VULKAN_HPP_CONSTEXPR ClearColorValue( float float32_0, float float32_1, float float32_2, float float32_3 ) + : float32{ { { float32_0, float32_1, float32_2, float32_3 } } } + { + } + + VULKAN_HPP_CONSTEXPR_14 ClearColorValue( const std::array & int32_ ) : int32( int32_ ) {} + + VULKAN_HPP_CONSTEXPR ClearColorValue( int32_t int32_0, int32_t int32_1, int32_t int32_2, int32_t int32_3 ) + : int32{ { { int32_0, int32_1, int32_2, int32_3 } } } + { + } + + VULKAN_HPP_CONSTEXPR_14 ClearColorValue( const std::array & uint32_ ) : uint32( uint32_ ) {} + + VULKAN_HPP_CONSTEXPR ClearColorValue( uint32_t uint32_0, uint32_t uint32_1, uint32_t uint32_2, uint32_t uint32_3 ) + : uint32{ { { uint32_0, uint32_1, uint32_2, uint32_3 } } } + { + } +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClearColorValue & setFloat32( std::array float32_ ) & VULKAN_HPP_NOEXCEPT + { + float32 = float32_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearColorValue && setFloat32( std::array float32_ ) && VULKAN_HPP_NOEXCEPT + { + float32 = float32_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClearColorValue & setInt32( std::array int32_ ) & VULKAN_HPP_NOEXCEPT + { + int32 = int32_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearColorValue && setInt32( std::array int32_ ) && VULKAN_HPP_NOEXCEPT + { + int32 = int32_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClearColorValue & setUint32( std::array uint32_ ) & VULKAN_HPP_NOEXCEPT + { + uint32 = uint32_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearColorValue && setUint32( std::array uint32_ ) && VULKAN_HPP_NOEXCEPT + { + uint32 = uint32_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClearColorValue const &() const + { + return *reinterpret_cast( this ); + } + + operator VkClearColorValue &() + { + return *reinterpret_cast( this ); + } + + ArrayWrapper1D float32; + ArrayWrapper1D int32; + ArrayWrapper1D uint32; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClearColorValue; + }; +#endif + + // wrapper struct for struct VkClearDepthStencilValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkClearDepthStencilValue.html + struct ClearDepthStencilValue + { + using NativeType = VkClearDepthStencilValue; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ClearDepthStencilValue( float depth_ = {}, uint32_t stencil_ = {} ) VULKAN_HPP_NOEXCEPT + : depth{ depth_ } + , stencil{ stencil_ } + { + } + + VULKAN_HPP_CONSTEXPR ClearDepthStencilValue( ClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT + : ClearDepthStencilValue( *reinterpret_cast( &rhs ) ) + { + } + + ClearDepthStencilValue & operator=( ClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClearDepthStencilValue & operator=( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue & setDepth( float depth_ ) & VULKAN_HPP_NOEXCEPT + { + depth = depth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue && setDepth( float depth_ ) && VULKAN_HPP_NOEXCEPT + { + depth = depth_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue & setStencil( uint32_t stencil_ ) & VULKAN_HPP_NOEXCEPT + { + stencil = stencil_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue && setStencil( uint32_t stencil_ ) && VULKAN_HPP_NOEXCEPT + { + stencil = stencil_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClearDepthStencilValue const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClearDepthStencilValue &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClearDepthStencilValue const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClearDepthStencilValue *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( depth, stencil ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClearDepthStencilValue const & ) const = default; +#else + bool operator==( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( depth == rhs.depth ) && ( stencil == rhs.stencil ); +# endif + } + + bool operator!=( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + float depth = {}; + uint32_t stencil = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClearDepthStencilValue; + }; +#endif + + union ClearValue + { + using NativeType = VkClearValue; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 ClearValue( ClearColorValue color_ = {} ) : color( color_ ) {} + + VULKAN_HPP_CONSTEXPR_14 ClearValue( ClearDepthStencilValue depthStencil_ ) : depthStencil( depthStencil_ ) {} +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClearValue & setColor( ClearColorValue const & color_ ) & VULKAN_HPP_NOEXCEPT + { + color = color_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearValue && setColor( ClearColorValue const & color_ ) && VULKAN_HPP_NOEXCEPT + { + color = color_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClearValue & setDepthStencil( ClearDepthStencilValue const & depthStencil_ ) & VULKAN_HPP_NOEXCEPT + { + depthStencil = depthStencil_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearValue && setDepthStencil( ClearDepthStencilValue const & depthStencil_ ) && VULKAN_HPP_NOEXCEPT + { + depthStencil = depthStencil_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClearValue const &() const + { + return *reinterpret_cast( this ); + } + + operator VkClearValue &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + ClearColorValue color; + ClearDepthStencilValue depthStencil; +#else + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClearValue; + }; +#endif + + // wrapper struct for struct VkClearAttachment, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkClearAttachment.html + struct ClearAttachment + { + using NativeType = VkClearAttachment; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + ClearAttachment( ImageAspectFlags aspectMask_ = {}, uint32_t colorAttachment_ = {}, ClearValue clearValue_ = {} ) VULKAN_HPP_NOEXCEPT + : aspectMask{ aspectMask_ } + , colorAttachment{ colorAttachment_ } + , clearValue{ clearValue_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 ClearAttachment( ClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ClearAttachment( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT : ClearAttachment( *reinterpret_cast( &rhs ) ) {} + + ClearAttachment & operator=( ClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClearAttachment & operator=( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClearAttachment & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearAttachment && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClearAttachment & setColorAttachment( uint32_t colorAttachment_ ) & VULKAN_HPP_NOEXCEPT + { + colorAttachment = colorAttachment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearAttachment && setColorAttachment( uint32_t colorAttachment_ ) && VULKAN_HPP_NOEXCEPT + { + colorAttachment = colorAttachment_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClearAttachment & setClearValue( ClearValue const & clearValue_ ) & VULKAN_HPP_NOEXCEPT + { + clearValue = clearValue_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearAttachment && setClearValue( ClearValue const & clearValue_ ) && VULKAN_HPP_NOEXCEPT + { + clearValue = clearValue_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClearAttachment const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClearAttachment &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClearAttachment const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClearAttachment *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, colorAttachment, clearValue ); + } +#endif + + public: + ImageAspectFlags aspectMask = {}; + uint32_t colorAttachment = {}; + ClearValue clearValue = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClearAttachment; + }; +#endif + + // wrapper struct for struct VkClearRect, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkClearRect.html + struct ClearRect + { + using NativeType = VkClearRect; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ClearRect( Rect2D rect_ = {}, uint32_t baseArrayLayer_ = {}, uint32_t layerCount_ = {} ) VULKAN_HPP_NOEXCEPT + : rect{ rect_ } + , baseArrayLayer{ baseArrayLayer_ } + , layerCount{ layerCount_ } + { + } + + VULKAN_HPP_CONSTEXPR ClearRect( ClearRect const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ClearRect( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT : ClearRect( *reinterpret_cast( &rhs ) ) {} + + ClearRect & operator=( ClearRect const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClearRect & operator=( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClearRect & setRect( Rect2D const & rect_ ) & VULKAN_HPP_NOEXCEPT + { + rect = rect_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearRect && setRect( Rect2D const & rect_ ) && VULKAN_HPP_NOEXCEPT + { + rect = rect_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClearRect & setBaseArrayLayer( uint32_t baseArrayLayer_ ) & VULKAN_HPP_NOEXCEPT + { + baseArrayLayer = baseArrayLayer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearRect && setBaseArrayLayer( uint32_t baseArrayLayer_ ) && VULKAN_HPP_NOEXCEPT + { + baseArrayLayer = baseArrayLayer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClearRect & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClearRect && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClearRect const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClearRect &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClearRect const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClearRect *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( rect, baseArrayLayer, layerCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClearRect const & ) const = default; +#else + bool operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( rect == rhs.rect ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); +# endif + } + + bool operator!=( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Rect2D rect = {}; + uint32_t baseArrayLayer = {}; + uint32_t layerCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClearRect; + }; +#endif + + // wrapper struct for struct VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV.html + struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNV + { + using NativeType = VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildClustersBottomLevelInfoNV( uint32_t clusterReferencesCount_ = {}, + uint32_t clusterReferencesStride_ = {}, + DeviceAddress clusterReferences_ = {} ) VULKAN_HPP_NOEXCEPT + : clusterReferencesCount{ clusterReferencesCount_ } + , clusterReferencesStride{ clusterReferencesStride_ } + , clusterReferences{ clusterReferences_ } + { + } + + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildClustersBottomLevelInfoNV( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureBuildClustersBottomLevelInfoNV( VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureBuildClustersBottomLevelInfoNV( + *reinterpret_cast( &rhs ) ) + { + } + + ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & + operator=( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & + operator=( VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & setClusterReferencesCount( uint32_t clusterReferencesCount_ ) & + VULKAN_HPP_NOEXCEPT + { + clusterReferencesCount = clusterReferencesCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV && setClusterReferencesCount( uint32_t clusterReferencesCount_ ) && + VULKAN_HPP_NOEXCEPT + { + clusterReferencesCount = clusterReferencesCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & setClusterReferencesStride( uint32_t clusterReferencesStride_ ) & + VULKAN_HPP_NOEXCEPT + { + clusterReferencesStride = clusterReferencesStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV && setClusterReferencesStride( uint32_t clusterReferencesStride_ ) && + VULKAN_HPP_NOEXCEPT + { + clusterReferencesStride = clusterReferencesStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & setClusterReferences( DeviceAddress clusterReferences_ ) & + VULKAN_HPP_NOEXCEPT + { + clusterReferences = clusterReferences_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV && setClusterReferences( DeviceAddress clusterReferences_ ) && + VULKAN_HPP_NOEXCEPT + { + clusterReferences = clusterReferences_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( clusterReferencesCount, clusterReferencesStride, clusterReferences ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & ) const = default; +#else + bool operator==( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( clusterReferencesCount == rhs.clusterReferencesCount ) && ( clusterReferencesStride == rhs.clusterReferencesStride ) && + ( clusterReferences == rhs.clusterReferences ); +# endif + } + + bool operator!=( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t clusterReferencesCount = {}; + uint32_t clusterReferencesStride = {}; + DeviceAddress clusterReferences = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureBuildClustersBottomLevelInfoNV; + }; +#endif + + // wrapper struct for struct VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.html + struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV + { + using NativeType = VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV( uint32_t geometryIndex_ = {}, + uint32_t reserved_ = {}, + uint32_t geometryFlags_ = {} ) VULKAN_HPP_NOEXCEPT + : geometryIndex{ geometryIndex_ } + , reserved{ reserved_ } + , geometryFlags{ geometryFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV( VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV( + *reinterpret_cast( &rhs ) ) + { + } + + ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & + operator=( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & + operator=( VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & setGeometryIndex( uint32_t geometryIndex_ ) & VULKAN_HPP_NOEXCEPT + { + geometryIndex = geometryIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV && setGeometryIndex( uint32_t geometryIndex_ ) && VULKAN_HPP_NOEXCEPT + { + geometryIndex = geometryIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & setReserved( uint32_t reserved_ ) & VULKAN_HPP_NOEXCEPT + { + reserved = reserved_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV && setReserved( uint32_t reserved_ ) && VULKAN_HPP_NOEXCEPT + { + reserved = reserved_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & setGeometryFlags( uint32_t geometryFlags_ ) & VULKAN_HPP_NOEXCEPT + { + geometryFlags = geometryFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV && setGeometryFlags( uint32_t geometryFlags_ ) && VULKAN_HPP_NOEXCEPT + { + geometryFlags = geometryFlags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( geometryIndex, reserved, geometryFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & ) const = default; +#else + bool operator==( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( geometryIndex == rhs.geometryIndex ) && ( reserved == rhs.reserved ) && ( geometryFlags == rhs.geometryFlags ); +# endif + } + + bool operator!=( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t geometryIndex : 24; + uint32_t reserved : 5; + uint32_t geometryFlags : 3; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV; + }; +#endif + + // wrapper struct for struct VkClusterAccelerationStructureBuildTriangleClusterInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildTriangleClusterInfoNV.html + struct ClusterAccelerationStructureBuildTriangleClusterInfoNV + { + using NativeType = VkClusterAccelerationStructureBuildTriangleClusterInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterInfoNV( + uint32_t clusterID_ = {}, + ClusterAccelerationStructureClusterFlagsNV clusterFlags_ = {}, + uint32_t triangleCount_ = {}, + uint32_t vertexCount_ = {}, + uint32_t positionTruncateBitCount_ = {}, + uint32_t indexType_ = {}, + uint32_t opacityMicromapIndexType_ = {}, + ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags_ = {}, + uint16_t indexBufferStride_ = {}, + uint16_t vertexBufferStride_ = {}, + uint16_t geometryIndexAndFlagsBufferStride_ = {}, + uint16_t opacityMicromapIndexBufferStride_ = {}, + DeviceAddress indexBuffer_ = {}, + DeviceAddress vertexBuffer_ = {}, + DeviceAddress geometryIndexAndFlagsBuffer_ = {}, + DeviceAddress opacityMicromapArray_ = {}, + DeviceAddress opacityMicromapIndexBuffer_ = {} ) VULKAN_HPP_NOEXCEPT + : clusterID{ clusterID_ } + , clusterFlags{ clusterFlags_ } + , triangleCount{ triangleCount_ } + , vertexCount{ vertexCount_ } + , positionTruncateBitCount{ positionTruncateBitCount_ } + , indexType{ indexType_ } + , opacityMicromapIndexType{ opacityMicromapIndexType_ } + , baseGeometryIndexAndGeometryFlags{ baseGeometryIndexAndGeometryFlags_ } + , indexBufferStride{ indexBufferStride_ } + , vertexBufferStride{ vertexBufferStride_ } + , geometryIndexAndFlagsBufferStride{ geometryIndexAndFlagsBufferStride_ } + , opacityMicromapIndexBufferStride{ opacityMicromapIndexBufferStride_ } + , indexBuffer{ indexBuffer_ } + , vertexBuffer{ vertexBuffer_ } + , geometryIndexAndFlagsBuffer{ geometryIndexAndFlagsBuffer_ } + , opacityMicromapArray{ opacityMicromapArray_ } + , opacityMicromapIndexBuffer{ opacityMicromapIndexBuffer_ } + { + } + + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterInfoNV( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureBuildTriangleClusterInfoNV( VkClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureBuildTriangleClusterInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ClusterAccelerationStructureBuildTriangleClusterInfoNV & + operator=( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureBuildTriangleClusterInfoNV & + operator=( VkClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setClusterID( uint32_t clusterID_ ) & VULKAN_HPP_NOEXCEPT + { + clusterID = clusterID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setClusterID( uint32_t clusterID_ ) && VULKAN_HPP_NOEXCEPT + { + clusterID = clusterID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & + setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) & + VULKAN_HPP_NOEXCEPT + { + clusterFlags = clusterFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && + setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) && + VULKAN_HPP_NOEXCEPT + { + clusterFlags = clusterFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setTriangleCount( uint32_t triangleCount_ ) & VULKAN_HPP_NOEXCEPT + { + triangleCount = triangleCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setTriangleCount( uint32_t triangleCount_ ) && VULKAN_HPP_NOEXCEPT + { + triangleCount = triangleCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT + { + vertexCount = vertexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT + { + vertexCount = vertexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) & + VULKAN_HPP_NOEXCEPT + { + positionTruncateBitCount = positionTruncateBitCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) && + VULKAN_HPP_NOEXCEPT + { + positionTruncateBitCount = positionTruncateBitCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setIndexType( uint32_t indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setIndexType( uint32_t indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) & + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexType = opacityMicromapIndexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) && + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexType = opacityMicromapIndexType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & + setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) & + VULKAN_HPP_NOEXCEPT + { + baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && + setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) && + VULKAN_HPP_NOEXCEPT + { + baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setIndexBufferStride( uint16_t indexBufferStride_ ) & VULKAN_HPP_NOEXCEPT + { + indexBufferStride = indexBufferStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setIndexBufferStride( uint16_t indexBufferStride_ ) && VULKAN_HPP_NOEXCEPT + { + indexBufferStride = indexBufferStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setVertexBufferStride( uint16_t vertexBufferStride_ ) & VULKAN_HPP_NOEXCEPT + { + vertexBufferStride = vertexBufferStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setVertexBufferStride( uint16_t vertexBufferStride_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexBufferStride = vertexBufferStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & + setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) & + VULKAN_HPP_NOEXCEPT + { + geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && + setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) && + VULKAN_HPP_NOEXCEPT + { + geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & + setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) & + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && + setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) && + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setIndexBuffer( DeviceAddress indexBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + indexBuffer = indexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setIndexBuffer( DeviceAddress indexBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + indexBuffer = indexBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setVertexBuffer( DeviceAddress vertexBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + vertexBuffer = vertexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setVertexBuffer( DeviceAddress vertexBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + vertexBuffer = vertexBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & + setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) & + VULKAN_HPP_NOEXCEPT + { + geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && + setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) & + VULKAN_HPP_NOEXCEPT + { + opacityMicromapArray = opacityMicromapArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) && + VULKAN_HPP_NOEXCEPT + { + opacityMicromapArray = opacityMicromapArray_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & + setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) & + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && + setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( clusterID, + clusterFlags, + triangleCount, + vertexCount, + positionTruncateBitCount, + indexType, + opacityMicromapIndexType, + baseGeometryIndexAndGeometryFlags, + indexBufferStride, + vertexBufferStride, + geometryIndexAndFlagsBufferStride, + opacityMicromapIndexBufferStride, + indexBuffer, + vertexBuffer, + geometryIndexAndFlagsBuffer, + opacityMicromapArray, + opacityMicromapIndexBuffer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & ) const = default; +#else + bool operator==( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( clusterID == rhs.clusterID ) && ( clusterFlags == rhs.clusterFlags ) && ( triangleCount == rhs.triangleCount ) && + ( vertexCount == rhs.vertexCount ) && ( positionTruncateBitCount == rhs.positionTruncateBitCount ) && ( indexType == rhs.indexType ) && + ( opacityMicromapIndexType == rhs.opacityMicromapIndexType ) && ( baseGeometryIndexAndGeometryFlags == rhs.baseGeometryIndexAndGeometryFlags ) && + ( indexBufferStride == rhs.indexBufferStride ) && ( vertexBufferStride == rhs.vertexBufferStride ) && + ( geometryIndexAndFlagsBufferStride == rhs.geometryIndexAndFlagsBufferStride ) && + ( opacityMicromapIndexBufferStride == rhs.opacityMicromapIndexBufferStride ) && ( indexBuffer == rhs.indexBuffer ) && + ( vertexBuffer == rhs.vertexBuffer ) && ( geometryIndexAndFlagsBuffer == rhs.geometryIndexAndFlagsBuffer ) && + ( opacityMicromapArray == rhs.opacityMicromapArray ) && ( opacityMicromapIndexBuffer == rhs.opacityMicromapIndexBuffer ); +# endif + } + + bool operator!=( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t clusterID = {}; + ClusterAccelerationStructureClusterFlagsNV clusterFlags = {}; + uint32_t triangleCount : 9; + uint32_t vertexCount : 9; + uint32_t positionTruncateBitCount : 6; + uint32_t indexType : 4; + uint32_t opacityMicromapIndexType : 4; + ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags = {}; + uint16_t indexBufferStride = {}; + uint16_t vertexBufferStride = {}; + uint16_t geometryIndexAndFlagsBufferStride = {}; + uint16_t opacityMicromapIndexBufferStride = {}; + DeviceAddress indexBuffer = {}; + DeviceAddress vertexBuffer = {}; + DeviceAddress geometryIndexAndFlagsBuffer = {}; + DeviceAddress opacityMicromapArray = {}; + DeviceAddress opacityMicromapIndexBuffer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureBuildTriangleClusterInfoNV; + }; +#endif + + // wrapper struct for struct VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.html + struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV + { + using NativeType = VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV( + uint32_t clusterID_ = {}, + ClusterAccelerationStructureClusterFlagsNV clusterFlags_ = {}, + uint32_t triangleCount_ = {}, + uint32_t vertexCount_ = {}, + uint32_t positionTruncateBitCount_ = {}, + uint32_t indexType_ = {}, + uint32_t opacityMicromapIndexType_ = {}, + ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags_ = {}, + uint16_t indexBufferStride_ = {}, + uint16_t vertexBufferStride_ = {}, + uint16_t geometryIndexAndFlagsBufferStride_ = {}, + uint16_t opacityMicromapIndexBufferStride_ = {}, + DeviceAddress indexBuffer_ = {}, + DeviceAddress vertexBuffer_ = {}, + DeviceAddress geometryIndexAndFlagsBuffer_ = {}, + DeviceAddress opacityMicromapArray_ = {}, + DeviceAddress opacityMicromapIndexBuffer_ = {}, + DeviceAddress instantiationBoundingBoxLimit_ = {} ) VULKAN_HPP_NOEXCEPT + : clusterID{ clusterID_ } + , clusterFlags{ clusterFlags_ } + , triangleCount{ triangleCount_ } + , vertexCount{ vertexCount_ } + , positionTruncateBitCount{ positionTruncateBitCount_ } + , indexType{ indexType_ } + , opacityMicromapIndexType{ opacityMicromapIndexType_ } + , baseGeometryIndexAndGeometryFlags{ baseGeometryIndexAndGeometryFlags_ } + , indexBufferStride{ indexBufferStride_ } + , vertexBufferStride{ vertexBufferStride_ } + , geometryIndexAndFlagsBufferStride{ geometryIndexAndFlagsBufferStride_ } + , opacityMicromapIndexBufferStride{ opacityMicromapIndexBufferStride_ } + , indexBuffer{ indexBuffer_ } + , vertexBuffer{ vertexBuffer_ } + , geometryIndexAndFlagsBuffer{ geometryIndexAndFlagsBuffer_ } + , opacityMicromapArray{ opacityMicromapArray_ } + , opacityMicromapIndexBuffer{ opacityMicromapIndexBuffer_ } + , instantiationBoundingBoxLimit{ instantiationBoundingBoxLimit_ } + { + } + + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV( + ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV( VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) + VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV( + *reinterpret_cast( &rhs ) ) + { + } + + explicit ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV( + ClusterAccelerationStructureBuildTriangleClusterInfoNV const & clusterAccelerationStructureBuildTriangleClusterInfoNV, + DeviceAddress instantiationBoundingBoxLimit_ = {} ) + : clusterID( clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterID ) + , clusterFlags( clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterFlags ) + , triangleCount( clusterAccelerationStructureBuildTriangleClusterInfoNV.triangleCount ) + , vertexCount( clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexCount ) + , positionTruncateBitCount( clusterAccelerationStructureBuildTriangleClusterInfoNV.positionTruncateBitCount ) + , indexType( clusterAccelerationStructureBuildTriangleClusterInfoNV.indexType ) + , opacityMicromapIndexType( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexType ) + , baseGeometryIndexAndGeometryFlags( clusterAccelerationStructureBuildTriangleClusterInfoNV.baseGeometryIndexAndGeometryFlags ) + , indexBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBufferStride ) + , vertexBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBufferStride ) + , geometryIndexAndFlagsBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBufferStride ) + , opacityMicromapIndexBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBufferStride ) + , indexBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBuffer ) + , vertexBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBuffer ) + , geometryIndexAndFlagsBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBuffer ) + , opacityMicromapArray( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapArray ) + , opacityMicromapIndexBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBuffer ) + , instantiationBoundingBoxLimit( instantiationBoundingBoxLimit_ ) + { + } + + ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & + operator=( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & + operator=( VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setClusterID( uint32_t clusterID_ ) & VULKAN_HPP_NOEXCEPT + { + clusterID = clusterID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setClusterID( uint32_t clusterID_ ) && VULKAN_HPP_NOEXCEPT + { + clusterID = clusterID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & + setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) & + VULKAN_HPP_NOEXCEPT + { + clusterFlags = clusterFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && + setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) && + VULKAN_HPP_NOEXCEPT + { + clusterFlags = clusterFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setTriangleCount( uint32_t triangleCount_ ) & VULKAN_HPP_NOEXCEPT + { + triangleCount = triangleCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setTriangleCount( uint32_t triangleCount_ ) && VULKAN_HPP_NOEXCEPT + { + triangleCount = triangleCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT + { + vertexCount = vertexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT + { + vertexCount = vertexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) & + VULKAN_HPP_NOEXCEPT + { + positionTruncateBitCount = positionTruncateBitCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && + setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) && + VULKAN_HPP_NOEXCEPT + { + positionTruncateBitCount = positionTruncateBitCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setIndexType( uint32_t indexType_ ) & VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setIndexType( uint32_t indexType_ ) && VULKAN_HPP_NOEXCEPT + { + indexType = indexType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) & + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexType = opacityMicromapIndexType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && + setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) && + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexType = opacityMicromapIndexType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & + setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) & + VULKAN_HPP_NOEXCEPT + { + baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && + setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) && + VULKAN_HPP_NOEXCEPT + { + baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setIndexBufferStride( uint16_t indexBufferStride_ ) & + VULKAN_HPP_NOEXCEPT + { + indexBufferStride = indexBufferStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setIndexBufferStride( uint16_t indexBufferStride_ ) && + VULKAN_HPP_NOEXCEPT + { + indexBufferStride = indexBufferStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setVertexBufferStride( uint16_t vertexBufferStride_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexBufferStride = vertexBufferStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setVertexBufferStride( uint16_t vertexBufferStride_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexBufferStride = vertexBufferStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & + setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) & + VULKAN_HPP_NOEXCEPT + { + geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && + setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) && + VULKAN_HPP_NOEXCEPT + { + geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & + setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) & + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && + setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) && + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setIndexBuffer( DeviceAddress indexBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + indexBuffer = indexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setIndexBuffer( DeviceAddress indexBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + indexBuffer = indexBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setVertexBuffer( DeviceAddress vertexBuffer_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexBuffer = vertexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setVertexBuffer( DeviceAddress vertexBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexBuffer = vertexBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & + setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) & + VULKAN_HPP_NOEXCEPT + { + geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && + setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) & + VULKAN_HPP_NOEXCEPT + { + opacityMicromapArray = opacityMicromapArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) && + VULKAN_HPP_NOEXCEPT + { + opacityMicromapArray = opacityMicromapArray_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & + setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) & + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && + setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & + setInstantiationBoundingBoxLimit( DeviceAddress instantiationBoundingBoxLimit_ ) & + VULKAN_HPP_NOEXCEPT + { + instantiationBoundingBoxLimit = instantiationBoundingBoxLimit_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && + setInstantiationBoundingBoxLimit( DeviceAddress instantiationBoundingBoxLimit_ ) && + VULKAN_HPP_NOEXCEPT + { + instantiationBoundingBoxLimit = instantiationBoundingBoxLimit_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( clusterID, + clusterFlags, + triangleCount, + vertexCount, + positionTruncateBitCount, + indexType, + opacityMicromapIndexType, + baseGeometryIndexAndGeometryFlags, + indexBufferStride, + vertexBufferStride, + geometryIndexAndFlagsBufferStride, + opacityMicromapIndexBufferStride, + indexBuffer, + vertexBuffer, + geometryIndexAndFlagsBuffer, + opacityMicromapArray, + opacityMicromapIndexBuffer, + instantiationBoundingBoxLimit ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & ) const = default; +#else + bool operator==( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( clusterID == rhs.clusterID ) && ( clusterFlags == rhs.clusterFlags ) && ( triangleCount == rhs.triangleCount ) && + ( vertexCount == rhs.vertexCount ) && ( positionTruncateBitCount == rhs.positionTruncateBitCount ) && ( indexType == rhs.indexType ) && + ( opacityMicromapIndexType == rhs.opacityMicromapIndexType ) && ( baseGeometryIndexAndGeometryFlags == rhs.baseGeometryIndexAndGeometryFlags ) && + ( indexBufferStride == rhs.indexBufferStride ) && ( vertexBufferStride == rhs.vertexBufferStride ) && + ( geometryIndexAndFlagsBufferStride == rhs.geometryIndexAndFlagsBufferStride ) && + ( opacityMicromapIndexBufferStride == rhs.opacityMicromapIndexBufferStride ) && ( indexBuffer == rhs.indexBuffer ) && + ( vertexBuffer == rhs.vertexBuffer ) && ( geometryIndexAndFlagsBuffer == rhs.geometryIndexAndFlagsBuffer ) && + ( opacityMicromapArray == rhs.opacityMicromapArray ) && ( opacityMicromapIndexBuffer == rhs.opacityMicromapIndexBuffer ) && + ( instantiationBoundingBoxLimit == rhs.instantiationBoundingBoxLimit ); +# endif + } + + bool operator!=( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t clusterID = {}; + ClusterAccelerationStructureClusterFlagsNV clusterFlags = {}; + uint32_t triangleCount : 9; + uint32_t vertexCount : 9; + uint32_t positionTruncateBitCount : 6; + uint32_t indexType : 4; + uint32_t opacityMicromapIndexType : 4; + ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags = {}; + uint16_t indexBufferStride = {}; + uint16_t vertexBufferStride = {}; + uint16_t geometryIndexAndFlagsBufferStride = {}; + uint16_t opacityMicromapIndexBufferStride = {}; + DeviceAddress indexBuffer = {}; + DeviceAddress vertexBuffer = {}; + DeviceAddress geometryIndexAndFlagsBuffer = {}; + DeviceAddress opacityMicromapArray = {}; + DeviceAddress opacityMicromapIndexBuffer = {}; + DeviceAddress instantiationBoundingBoxLimit = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV; + }; +#endif + + // wrapper struct for struct VkClusterAccelerationStructureClustersBottomLevelInputNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureClustersBottomLevelInputNV.html + struct ClusterAccelerationStructureClustersBottomLevelInputNV + { + using NativeType = VkClusterAccelerationStructureClustersBottomLevelInputNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eClusterAccelerationStructureClustersBottomLevelInputNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureClustersBottomLevelInputNV( uint32_t maxTotalClusterCount_ = {}, + uint32_t maxClusterCountPerAccelerationStructure_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxTotalClusterCount{ maxTotalClusterCount_ } + , maxClusterCountPerAccelerationStructure{ maxClusterCountPerAccelerationStructure_ } + { + } + + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureClustersBottomLevelInputNV( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureClustersBottomLevelInputNV( VkClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureClustersBottomLevelInputNV( *reinterpret_cast( &rhs ) ) + { + } + + ClusterAccelerationStructureClustersBottomLevelInputNV & + operator=( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureClustersBottomLevelInputNV & + operator=( VkClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV & setMaxTotalClusterCount( uint32_t maxTotalClusterCount_ ) & + VULKAN_HPP_NOEXCEPT + { + maxTotalClusterCount = maxTotalClusterCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV && setMaxTotalClusterCount( uint32_t maxTotalClusterCount_ ) && + VULKAN_HPP_NOEXCEPT + { + maxTotalClusterCount = maxTotalClusterCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV & + setMaxClusterCountPerAccelerationStructure( uint32_t maxClusterCountPerAccelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + maxClusterCountPerAccelerationStructure = maxClusterCountPerAccelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV && + setMaxClusterCountPerAccelerationStructure( uint32_t maxClusterCountPerAccelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + maxClusterCountPerAccelerationStructure = maxClusterCountPerAccelerationStructure_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureClustersBottomLevelInputNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureClustersBottomLevelInputNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureClustersBottomLevelInputNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureClustersBottomLevelInputNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxTotalClusterCount, maxClusterCountPerAccelerationStructure ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClusterAccelerationStructureClustersBottomLevelInputNV const & ) const = default; +#else + bool operator==( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTotalClusterCount == rhs.maxTotalClusterCount ) && + ( maxClusterCountPerAccelerationStructure == rhs.maxClusterCountPerAccelerationStructure ); +# endif + } + + bool operator!=( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eClusterAccelerationStructureClustersBottomLevelInputNV; + void * pNext = {}; + uint32_t maxTotalClusterCount = {}; + uint32_t maxClusterCountPerAccelerationStructure = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureClustersBottomLevelInputNV; + }; +#endif + + template <> + struct CppType + { + using Type = ClusterAccelerationStructureClustersBottomLevelInputNV; + }; + + // wrapper struct for struct VkClusterAccelerationStructureTriangleClusterInputNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureTriangleClusterInputNV.html + struct ClusterAccelerationStructureTriangleClusterInputNV + { + using NativeType = VkClusterAccelerationStructureTriangleClusterInputNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eClusterAccelerationStructureTriangleClusterInputNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureTriangleClusterInputNV( Format vertexFormat_ = Format::eUndefined, + uint32_t maxGeometryIndexValue_ = {}, + uint32_t maxClusterUniqueGeometryCount_ = {}, + uint32_t maxClusterTriangleCount_ = {}, + uint32_t maxClusterVertexCount_ = {}, + uint32_t maxTotalTriangleCount_ = {}, + uint32_t maxTotalVertexCount_ = {}, + uint32_t minPositionTruncateBitCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vertexFormat{ vertexFormat_ } + , maxGeometryIndexValue{ maxGeometryIndexValue_ } + , maxClusterUniqueGeometryCount{ maxClusterUniqueGeometryCount_ } + , maxClusterTriangleCount{ maxClusterTriangleCount_ } + , maxClusterVertexCount{ maxClusterVertexCount_ } + , maxTotalTriangleCount{ maxTotalTriangleCount_ } + , maxTotalVertexCount{ maxTotalVertexCount_ } + , minPositionTruncateBitCount{ minPositionTruncateBitCount_ } + { + } + + VULKAN_HPP_CONSTEXPR + ClusterAccelerationStructureTriangleClusterInputNV( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureTriangleClusterInputNV( VkClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureTriangleClusterInputNV( *reinterpret_cast( &rhs ) ) + { + } + + ClusterAccelerationStructureTriangleClusterInputNV & + operator=( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureTriangleClusterInputNV & operator=( VkClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT + { + vertexFormat = vertexFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT + { + vertexFormat = vertexFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxGeometryIndexValue( uint32_t maxGeometryIndexValue_ ) & + VULKAN_HPP_NOEXCEPT + { + maxGeometryIndexValue = maxGeometryIndexValue_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxGeometryIndexValue( uint32_t maxGeometryIndexValue_ ) && + VULKAN_HPP_NOEXCEPT + { + maxGeometryIndexValue = maxGeometryIndexValue_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxClusterUniqueGeometryCount( uint32_t maxClusterUniqueGeometryCount_ ) & + VULKAN_HPP_NOEXCEPT + { + maxClusterUniqueGeometryCount = maxClusterUniqueGeometryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxClusterUniqueGeometryCount( uint32_t maxClusterUniqueGeometryCount_ ) && + VULKAN_HPP_NOEXCEPT + { + maxClusterUniqueGeometryCount = maxClusterUniqueGeometryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxClusterTriangleCount( uint32_t maxClusterTriangleCount_ ) & + VULKAN_HPP_NOEXCEPT + { + maxClusterTriangleCount = maxClusterTriangleCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxClusterTriangleCount( uint32_t maxClusterTriangleCount_ ) && + VULKAN_HPP_NOEXCEPT + { + maxClusterTriangleCount = maxClusterTriangleCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxClusterVertexCount( uint32_t maxClusterVertexCount_ ) & + VULKAN_HPP_NOEXCEPT + { + maxClusterVertexCount = maxClusterVertexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxClusterVertexCount( uint32_t maxClusterVertexCount_ ) && + VULKAN_HPP_NOEXCEPT + { + maxClusterVertexCount = maxClusterVertexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxTotalTriangleCount( uint32_t maxTotalTriangleCount_ ) & + VULKAN_HPP_NOEXCEPT + { + maxTotalTriangleCount = maxTotalTriangleCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxTotalTriangleCount( uint32_t maxTotalTriangleCount_ ) && + VULKAN_HPP_NOEXCEPT + { + maxTotalTriangleCount = maxTotalTriangleCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxTotalVertexCount( uint32_t maxTotalVertexCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxTotalVertexCount = maxTotalVertexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxTotalVertexCount( uint32_t maxTotalVertexCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxTotalVertexCount = maxTotalVertexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMinPositionTruncateBitCount( uint32_t minPositionTruncateBitCount_ ) & + VULKAN_HPP_NOEXCEPT + { + minPositionTruncateBitCount = minPositionTruncateBitCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMinPositionTruncateBitCount( uint32_t minPositionTruncateBitCount_ ) && + VULKAN_HPP_NOEXCEPT + { + minPositionTruncateBitCount = minPositionTruncateBitCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureTriangleClusterInputNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureTriangleClusterInputNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureTriangleClusterInputNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureTriangleClusterInputNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + vertexFormat, + maxGeometryIndexValue, + maxClusterUniqueGeometryCount, + maxClusterTriangleCount, + maxClusterVertexCount, + maxTotalTriangleCount, + maxTotalVertexCount, + minPositionTruncateBitCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClusterAccelerationStructureTriangleClusterInputNV const & ) const = default; +#else + bool operator==( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexFormat == rhs.vertexFormat ) && + ( maxGeometryIndexValue == rhs.maxGeometryIndexValue ) && ( maxClusterUniqueGeometryCount == rhs.maxClusterUniqueGeometryCount ) && + ( maxClusterTriangleCount == rhs.maxClusterTriangleCount ) && ( maxClusterVertexCount == rhs.maxClusterVertexCount ) && + ( maxTotalTriangleCount == rhs.maxTotalTriangleCount ) && ( maxTotalVertexCount == rhs.maxTotalVertexCount ) && + ( minPositionTruncateBitCount == rhs.minPositionTruncateBitCount ); +# endif + } + + bool operator!=( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eClusterAccelerationStructureTriangleClusterInputNV; + void * pNext = {}; + Format vertexFormat = Format::eUndefined; + uint32_t maxGeometryIndexValue = {}; + uint32_t maxClusterUniqueGeometryCount = {}; + uint32_t maxClusterTriangleCount = {}; + uint32_t maxClusterVertexCount = {}; + uint32_t maxTotalTriangleCount = {}; + uint32_t maxTotalVertexCount = {}; + uint32_t minPositionTruncateBitCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureTriangleClusterInputNV; + }; +#endif + + template <> + struct CppType + { + using Type = ClusterAccelerationStructureTriangleClusterInputNV; + }; + + // wrapper struct for struct VkClusterAccelerationStructureMoveObjectsInputNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureMoveObjectsInputNV.html + struct ClusterAccelerationStructureMoveObjectsInputNV + { + using NativeType = VkClusterAccelerationStructureMoveObjectsInputNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eClusterAccelerationStructureMoveObjectsInputNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + ClusterAccelerationStructureMoveObjectsInputNV( ClusterAccelerationStructureTypeNV type_ = ClusterAccelerationStructureTypeNV::eClustersBottomLevel, + Bool32 noMoveOverlap_ = {}, + DeviceSize maxMovedBytes_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , noMoveOverlap{ noMoveOverlap_ } + , maxMovedBytes{ maxMovedBytes_ } + { + } + + VULKAN_HPP_CONSTEXPR + ClusterAccelerationStructureMoveObjectsInputNV( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureMoveObjectsInputNV( VkClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureMoveObjectsInputNV( *reinterpret_cast( &rhs ) ) + { + } + + ClusterAccelerationStructureMoveObjectsInputNV & operator=( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureMoveObjectsInputNV & operator=( VkClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setType( ClusterAccelerationStructureTypeNV type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setType( ClusterAccelerationStructureTypeNV type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setNoMoveOverlap( Bool32 noMoveOverlap_ ) & VULKAN_HPP_NOEXCEPT + { + noMoveOverlap = noMoveOverlap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setNoMoveOverlap( Bool32 noMoveOverlap_ ) && VULKAN_HPP_NOEXCEPT + { + noMoveOverlap = noMoveOverlap_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setMaxMovedBytes( DeviceSize maxMovedBytes_ ) & VULKAN_HPP_NOEXCEPT + { + maxMovedBytes = maxMovedBytes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setMaxMovedBytes( DeviceSize maxMovedBytes_ ) && VULKAN_HPP_NOEXCEPT + { + maxMovedBytes = maxMovedBytes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureMoveObjectsInputNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureMoveObjectsInputNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureMoveObjectsInputNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureMoveObjectsInputNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, noMoveOverlap, maxMovedBytes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClusterAccelerationStructureMoveObjectsInputNV const & ) const = default; +#else + bool operator==( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( noMoveOverlap == rhs.noMoveOverlap ) && + ( maxMovedBytes == rhs.maxMovedBytes ); +# endif + } + + bool operator!=( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eClusterAccelerationStructureMoveObjectsInputNV; + void * pNext = {}; + ClusterAccelerationStructureTypeNV type = ClusterAccelerationStructureTypeNV::eClustersBottomLevel; + Bool32 noMoveOverlap = {}; + DeviceSize maxMovedBytes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureMoveObjectsInputNV; + }; +#endif + + template <> + struct CppType + { + using Type = ClusterAccelerationStructureMoveObjectsInputNV; + }; + + union ClusterAccelerationStructureOpInputNV + { + using NativeType = VkClusterAccelerationStructureOpInputNV; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV( ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel_ = {} ) + : pClustersBottomLevel( pClustersBottomLevel_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV( ClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters_ ) + : pTriangleClusters( pTriangleClusters_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV( ClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects_ ) + : pMoveObjects( pMoveObjects_ ) + { + } +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV & + setPClustersBottomLevel( ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel_ ) & + VULKAN_HPP_NOEXCEPT + { + pClustersBottomLevel = pClustersBottomLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV && + setPClustersBottomLevel( ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel_ ) && + VULKAN_HPP_NOEXCEPT + { + pClustersBottomLevel = pClustersBottomLevel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV & + setPTriangleClusters( ClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters_ ) & + VULKAN_HPP_NOEXCEPT + { + pTriangleClusters = pTriangleClusters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV && + setPTriangleClusters( ClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters_ ) && + VULKAN_HPP_NOEXCEPT + { + pTriangleClusters = pTriangleClusters_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV & setPMoveObjects( ClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects_ ) & + VULKAN_HPP_NOEXCEPT + { + pMoveObjects = pMoveObjects_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV && setPMoveObjects( ClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects_ ) && + VULKAN_HPP_NOEXCEPT + { + pMoveObjects = pMoveObjects_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureOpInputNV const &() const + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureOpInputNV &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel; + ClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters; + ClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects; +#else + VkClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel; + VkClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters; + VkClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureOpInputNV; + }; +#endif + + // wrapper struct for struct VkClusterAccelerationStructureInputInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureInputInfoNV.html + struct ClusterAccelerationStructureInputInfoNV + { + using NativeType = VkClusterAccelerationStructureInputInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eClusterAccelerationStructureInputInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + ClusterAccelerationStructureInputInfoNV( uint32_t maxAccelerationStructureCount_ = {}, + BuildAccelerationStructureFlagsKHR flags_ = {}, + ClusterAccelerationStructureOpTypeNV opType_ = ClusterAccelerationStructureOpTypeNV::eMoveObjects, + ClusterAccelerationStructureOpModeNV opMode_ = ClusterAccelerationStructureOpModeNV::eImplicitDestinations, + ClusterAccelerationStructureOpInputNV opInput_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxAccelerationStructureCount{ maxAccelerationStructureCount_ } + , flags{ flags_ } + , opType{ opType_ } + , opMode{ opMode_ } + , opInput{ opInput_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV( ClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureInputInfoNV( VkClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureInputInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ClusterAccelerationStructureInputInfoNV & operator=( ClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureInputInfoNV & operator=( VkClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setMaxAccelerationStructureCount( uint32_t maxAccelerationStructureCount_ ) & + VULKAN_HPP_NOEXCEPT + { + maxAccelerationStructureCount = maxAccelerationStructureCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setMaxAccelerationStructureCount( uint32_t maxAccelerationStructureCount_ ) && + VULKAN_HPP_NOEXCEPT + { + maxAccelerationStructureCount = maxAccelerationStructureCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setFlags( BuildAccelerationStructureFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setFlags( BuildAccelerationStructureFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setOpType( ClusterAccelerationStructureOpTypeNV opType_ ) & VULKAN_HPP_NOEXCEPT + { + opType = opType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setOpType( ClusterAccelerationStructureOpTypeNV opType_ ) && VULKAN_HPP_NOEXCEPT + { + opType = opType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setOpMode( ClusterAccelerationStructureOpModeNV opMode_ ) & VULKAN_HPP_NOEXCEPT + { + opMode = opMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setOpMode( ClusterAccelerationStructureOpModeNV opMode_ ) && VULKAN_HPP_NOEXCEPT + { + opMode = opMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setOpInput( ClusterAccelerationStructureOpInputNV const & opInput_ ) & VULKAN_HPP_NOEXCEPT + { + opInput = opInput_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setOpInput( ClusterAccelerationStructureOpInputNV const & opInput_ ) && + VULKAN_HPP_NOEXCEPT + { + opInput = opInput_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureInputInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureInputInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureInputInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureInputInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxAccelerationStructureCount, flags, opType, opMode, opInput ); + } +#endif + + public: + StructureType sType = StructureType::eClusterAccelerationStructureInputInfoNV; + void * pNext = {}; + uint32_t maxAccelerationStructureCount = {}; + BuildAccelerationStructureFlagsKHR flags = {}; + ClusterAccelerationStructureOpTypeNV opType = ClusterAccelerationStructureOpTypeNV::eMoveObjects; + ClusterAccelerationStructureOpModeNV opMode = ClusterAccelerationStructureOpModeNV::eImplicitDestinations; + ClusterAccelerationStructureOpInputNV opInput = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureInputInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = ClusterAccelerationStructureInputInfoNV; + }; + + // wrapper struct for struct VkStridedDeviceAddressRegionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressRegionKHR.html + struct StridedDeviceAddressRegionKHR + { + using NativeType = VkStridedDeviceAddressRegionKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR StridedDeviceAddressRegionKHR( DeviceAddress deviceAddress_ = {}, DeviceSize stride_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT + : deviceAddress{ deviceAddress_ } + , stride{ stride_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR StridedDeviceAddressRegionKHR( StridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + StridedDeviceAddressRegionKHR( VkStridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : StridedDeviceAddressRegionKHR( *reinterpret_cast( &rhs ) ) + { + } + + StridedDeviceAddressRegionKHR & operator=( StridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + StridedDeviceAddressRegionKHR & operator=( VkStridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR & setStride( DeviceSize stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR && setStride( DeviceSize stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkStridedDeviceAddressRegionKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressRegionKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressRegionKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressRegionKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( deviceAddress, stride, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( StridedDeviceAddressRegionKHR const & ) const = default; +#else + bool operator==( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( deviceAddress == rhs.deviceAddress ) && ( stride == rhs.stride ) && ( size == rhs.size ); +# endif + } + + bool operator!=( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress deviceAddress = {}; + DeviceSize stride = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = StridedDeviceAddressRegionKHR; + }; +#endif + + // wrapper struct for struct VkClusterAccelerationStructureCommandsInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureCommandsInfoNV.html + struct ClusterAccelerationStructureCommandsInfoNV + { + using NativeType = VkClusterAccelerationStructureCommandsInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eClusterAccelerationStructureCommandsInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV( ClusterAccelerationStructureInputInfoNV input_ = {}, + DeviceAddress dstImplicitData_ = {}, + DeviceAddress scratchData_ = {}, + StridedDeviceAddressRegionKHR dstAddressesArray_ = {}, + StridedDeviceAddressRegionKHR dstSizesArray_ = {}, + StridedDeviceAddressRegionKHR srcInfosArray_ = {}, + DeviceAddress srcInfosCount_ = {}, + ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , input{ input_ } + , dstImplicitData{ dstImplicitData_ } + , scratchData{ scratchData_ } + , dstAddressesArray{ dstAddressesArray_ } + , dstSizesArray{ dstSizesArray_ } + , srcInfosArray{ srcInfosArray_ } + , srcInfosCount{ srcInfosCount_ } + , addressResolutionFlags{ addressResolutionFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV( ClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureCommandsInfoNV( VkClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureCommandsInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ClusterAccelerationStructureCommandsInfoNV & operator=( ClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureCommandsInfoNV & operator=( VkClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setInput( ClusterAccelerationStructureInputInfoNV const & input_ ) & + VULKAN_HPP_NOEXCEPT + { + input = input_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setInput( ClusterAccelerationStructureInputInfoNV const & input_ ) && + VULKAN_HPP_NOEXCEPT + { + input = input_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setDstImplicitData( DeviceAddress dstImplicitData_ ) & VULKAN_HPP_NOEXCEPT + { + dstImplicitData = dstImplicitData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setDstImplicitData( DeviceAddress dstImplicitData_ ) && VULKAN_HPP_NOEXCEPT + { + dstImplicitData = dstImplicitData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setScratchData( DeviceAddress scratchData_ ) & VULKAN_HPP_NOEXCEPT + { + scratchData = scratchData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setScratchData( DeviceAddress scratchData_ ) && VULKAN_HPP_NOEXCEPT + { + scratchData = scratchData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setDstAddressesArray( StridedDeviceAddressRegionKHR const & dstAddressesArray_ ) & + VULKAN_HPP_NOEXCEPT + { + dstAddressesArray = dstAddressesArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setDstAddressesArray( StridedDeviceAddressRegionKHR const & dstAddressesArray_ ) && + VULKAN_HPP_NOEXCEPT + { + dstAddressesArray = dstAddressesArray_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setDstSizesArray( StridedDeviceAddressRegionKHR const & dstSizesArray_ ) & + VULKAN_HPP_NOEXCEPT + { + dstSizesArray = dstSizesArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setDstSizesArray( StridedDeviceAddressRegionKHR const & dstSizesArray_ ) && + VULKAN_HPP_NOEXCEPT + { + dstSizesArray = dstSizesArray_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setSrcInfosArray( StridedDeviceAddressRegionKHR const & srcInfosArray_ ) & + VULKAN_HPP_NOEXCEPT + { + srcInfosArray = srcInfosArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setSrcInfosArray( StridedDeviceAddressRegionKHR const & srcInfosArray_ ) && + VULKAN_HPP_NOEXCEPT + { + srcInfosArray = srcInfosArray_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setSrcInfosCount( DeviceAddress srcInfosCount_ ) & VULKAN_HPP_NOEXCEPT + { + srcInfosCount = srcInfosCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setSrcInfosCount( DeviceAddress srcInfosCount_ ) && VULKAN_HPP_NOEXCEPT + { + srcInfosCount = srcInfosCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & + setAddressResolutionFlags( ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags_ ) & + VULKAN_HPP_NOEXCEPT + { + addressResolutionFlags = addressResolutionFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && + setAddressResolutionFlags( ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags_ ) && + VULKAN_HPP_NOEXCEPT + { + addressResolutionFlags = addressResolutionFlags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureCommandsInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureCommandsInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureCommandsInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, input, dstImplicitData, scratchData, dstAddressesArray, dstSizesArray, srcInfosArray, srcInfosCount, addressResolutionFlags ); + } +#endif + + public: + StructureType sType = StructureType::eClusterAccelerationStructureCommandsInfoNV; + void * pNext = {}; + ClusterAccelerationStructureInputInfoNV input = {}; + DeviceAddress dstImplicitData = {}; + DeviceAddress scratchData = {}; + StridedDeviceAddressRegionKHR dstAddressesArray = {}; + StridedDeviceAddressRegionKHR dstSizesArray = {}; + StridedDeviceAddressRegionKHR srcInfosArray = {}; + DeviceAddress srcInfosCount = {}; + ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureCommandsInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = ClusterAccelerationStructureCommandsInfoNV; + }; + + // wrapper struct for struct VkClusterAccelerationStructureGetTemplateIndicesInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGetTemplateIndicesInfoNV.html + struct ClusterAccelerationStructureGetTemplateIndicesInfoNV + { + using NativeType = VkClusterAccelerationStructureGetTemplateIndicesInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureGetTemplateIndicesInfoNV( DeviceAddress clusterTemplateAddress_ = {} ) VULKAN_HPP_NOEXCEPT + : clusterTemplateAddress{ clusterTemplateAddress_ } + { + } + + VULKAN_HPP_CONSTEXPR + ClusterAccelerationStructureGetTemplateIndicesInfoNV( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureGetTemplateIndicesInfoNV( VkClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureGetTemplateIndicesInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ClusterAccelerationStructureGetTemplateIndicesInfoNV & + operator=( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureGetTemplateIndicesInfoNV & operator=( VkClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGetTemplateIndicesInfoNV & setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) & + VULKAN_HPP_NOEXCEPT + { + clusterTemplateAddress = clusterTemplateAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGetTemplateIndicesInfoNV && setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) && + VULKAN_HPP_NOEXCEPT + { + clusterTemplateAddress = clusterTemplateAddress_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( clusterTemplateAddress ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & ) const = default; +#else + bool operator==( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( clusterTemplateAddress == rhs.clusterTemplateAddress ); +# endif + } + + bool operator!=( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress clusterTemplateAddress = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureGetTemplateIndicesInfoNV; + }; +#endif + + // wrapper struct for struct VkClusterAccelerationStructureInstantiateClusterInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureInstantiateClusterInfoNV.html + struct ClusterAccelerationStructureInstantiateClusterInfoNV + { + using NativeType = VkClusterAccelerationStructureInstantiateClusterInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureInstantiateClusterInfoNV( uint32_t clusterIdOffset_ = {}, + uint32_t geometryIndexOffset_ = {}, + uint32_t reserved_ = {}, + DeviceAddress clusterTemplateAddress_ = {}, + StridedDeviceAddressNV vertexBuffer_ = {} ) VULKAN_HPP_NOEXCEPT + : clusterIdOffset{ clusterIdOffset_ } + , geometryIndexOffset{ geometryIndexOffset_ } + , reserved{ reserved_ } + , clusterTemplateAddress{ clusterTemplateAddress_ } + , vertexBuffer{ vertexBuffer_ } + { + } + + VULKAN_HPP_CONSTEXPR + ClusterAccelerationStructureInstantiateClusterInfoNV( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureInstantiateClusterInfoNV( VkClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureInstantiateClusterInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ClusterAccelerationStructureInstantiateClusterInfoNV & + operator=( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureInstantiateClusterInfoNV & operator=( VkClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setClusterIdOffset( uint32_t clusterIdOffset_ ) & VULKAN_HPP_NOEXCEPT + { + clusterIdOffset = clusterIdOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setClusterIdOffset( uint32_t clusterIdOffset_ ) && VULKAN_HPP_NOEXCEPT + { + clusterIdOffset = clusterIdOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setGeometryIndexOffset( uint32_t geometryIndexOffset_ ) & VULKAN_HPP_NOEXCEPT + { + geometryIndexOffset = geometryIndexOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setGeometryIndexOffset( uint32_t geometryIndexOffset_ ) && + VULKAN_HPP_NOEXCEPT + { + geometryIndexOffset = geometryIndexOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setReserved( uint32_t reserved_ ) & VULKAN_HPP_NOEXCEPT + { + reserved = reserved_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setReserved( uint32_t reserved_ ) && VULKAN_HPP_NOEXCEPT + { + reserved = reserved_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) & + VULKAN_HPP_NOEXCEPT + { + clusterTemplateAddress = clusterTemplateAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) && + VULKAN_HPP_NOEXCEPT + { + clusterTemplateAddress = clusterTemplateAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setVertexBuffer( StridedDeviceAddressNV const & vertexBuffer_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexBuffer = vertexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setVertexBuffer( StridedDeviceAddressNV const & vertexBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexBuffer = vertexBuffer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureInstantiateClusterInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureInstantiateClusterInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureInstantiateClusterInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureInstantiateClusterInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( clusterIdOffset, geometryIndexOffset, reserved, clusterTemplateAddress, vertexBuffer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClusterAccelerationStructureInstantiateClusterInfoNV const & ) const = default; +#else + bool operator==( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( clusterIdOffset == rhs.clusterIdOffset ) && ( geometryIndexOffset == rhs.geometryIndexOffset ) && ( reserved == rhs.reserved ) && + ( clusterTemplateAddress == rhs.clusterTemplateAddress ) && ( vertexBuffer == rhs.vertexBuffer ); +# endif + } + + bool operator!=( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t clusterIdOffset = {}; + uint32_t geometryIndexOffset : 24; + uint32_t reserved : 8; + DeviceAddress clusterTemplateAddress = {}; + StridedDeviceAddressNV vertexBuffer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureInstantiateClusterInfoNV; + }; +#endif + + // wrapper struct for struct VkClusterAccelerationStructureMoveObjectsInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureMoveObjectsInfoNV.html + struct ClusterAccelerationStructureMoveObjectsInfoNV + { + using NativeType = VkClusterAccelerationStructureMoveObjectsInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureMoveObjectsInfoNV( DeviceAddress srcAccelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT + : srcAccelerationStructure{ srcAccelerationStructure_ } + { + } + + VULKAN_HPP_CONSTEXPR + ClusterAccelerationStructureMoveObjectsInfoNV( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ClusterAccelerationStructureMoveObjectsInfoNV( VkClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ClusterAccelerationStructureMoveObjectsInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ClusterAccelerationStructureMoveObjectsInfoNV & operator=( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ClusterAccelerationStructureMoveObjectsInfoNV & operator=( VkClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInfoNV & setSrcAccelerationStructure( DeviceAddress srcAccelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + srcAccelerationStructure = srcAccelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInfoNV && setSrcAccelerationStructure( DeviceAddress srcAccelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + srcAccelerationStructure = srcAccelerationStructure_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkClusterAccelerationStructureMoveObjectsInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureMoveObjectsInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureMoveObjectsInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkClusterAccelerationStructureMoveObjectsInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcAccelerationStructure ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ClusterAccelerationStructureMoveObjectsInfoNV const & ) const = default; +#else + bool operator==( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( srcAccelerationStructure == rhs.srcAccelerationStructure ); +# endif + } + + bool operator!=( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress srcAccelerationStructure = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ClusterAccelerationStructureMoveObjectsInfoNV; + }; +#endif + + // wrapper struct for struct VkCoarseSampleLocationNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoarseSampleLocationNV.html + struct CoarseSampleLocationNV + { + using NativeType = VkCoarseSampleLocationNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CoarseSampleLocationNV( uint32_t pixelX_ = {}, uint32_t pixelY_ = {}, uint32_t sample_ = {} ) VULKAN_HPP_NOEXCEPT + : pixelX{ pixelX_ } + , pixelY{ pixelY_ } + , sample{ sample_ } + { + } + + VULKAN_HPP_CONSTEXPR CoarseSampleLocationNV( CoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT + : CoarseSampleLocationNV( *reinterpret_cast( &rhs ) ) + { + } + + CoarseSampleLocationNV & operator=( CoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CoarseSampleLocationNV & operator=( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV & setPixelX( uint32_t pixelX_ ) & VULKAN_HPP_NOEXCEPT + { + pixelX = pixelX_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV && setPixelX( uint32_t pixelX_ ) && VULKAN_HPP_NOEXCEPT + { + pixelX = pixelX_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV & setPixelY( uint32_t pixelY_ ) & VULKAN_HPP_NOEXCEPT + { + pixelY = pixelY_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV && setPixelY( uint32_t pixelY_ ) && VULKAN_HPP_NOEXCEPT + { + pixelY = pixelY_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV & setSample( uint32_t sample_ ) & VULKAN_HPP_NOEXCEPT + { + sample = sample_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV && setSample( uint32_t sample_ ) && VULKAN_HPP_NOEXCEPT + { + sample = sample_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCoarseSampleLocationNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCoarseSampleLocationNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCoarseSampleLocationNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCoarseSampleLocationNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( pixelX, pixelY, sample ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CoarseSampleLocationNV const & ) const = default; +#else + bool operator==( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( pixelX == rhs.pixelX ) && ( pixelY == rhs.pixelY ) && ( sample == rhs.sample ); +# endif + } + + bool operator!=( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t pixelX = {}; + uint32_t pixelY = {}; + uint32_t sample = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CoarseSampleLocationNV; + }; +#endif + + // wrapper struct for struct VkCoarseSampleOrderCustomNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoarseSampleOrderCustomNV.html + struct CoarseSampleOrderCustomNV + { + using NativeType = VkCoarseSampleOrderCustomNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV shadingRate_ = ShadingRatePaletteEntryNV::eNoInvocations, + uint32_t sampleCount_ = {}, + uint32_t sampleLocationCount_ = {}, + const CoarseSampleLocationNV * pSampleLocations_ = {} ) VULKAN_HPP_NOEXCEPT + : shadingRate{ shadingRate_ } + , sampleCount{ sampleCount_ } + , sampleLocationCount{ sampleLocationCount_ } + , pSampleLocations{ pSampleLocations_ } + { + } + + VULKAN_HPP_CONSTEXPR CoarseSampleOrderCustomNV( CoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT + : CoarseSampleOrderCustomNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV shadingRate_, + uint32_t sampleCount_, + ArrayProxyNoTemporaries const & sampleLocations_ ) + : shadingRate( shadingRate_ ) + , sampleCount( sampleCount_ ) + , sampleLocationCount( static_cast( sampleLocations_.size() ) ) + , pSampleLocations( sampleLocations_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CoarseSampleOrderCustomNV & operator=( CoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CoarseSampleOrderCustomNV & operator=( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setShadingRate( ShadingRatePaletteEntryNV shadingRate_ ) & VULKAN_HPP_NOEXCEPT + { + shadingRate = shadingRate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setShadingRate( ShadingRatePaletteEntryNV shadingRate_ ) && VULKAN_HPP_NOEXCEPT + { + shadingRate = shadingRate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setSampleCount( uint32_t sampleCount_ ) & VULKAN_HPP_NOEXCEPT + { + sampleCount = sampleCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setSampleCount( uint32_t sampleCount_ ) && VULKAN_HPP_NOEXCEPT + { + sampleCount = sampleCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setSampleLocationCount( uint32_t sampleLocationCount_ ) & VULKAN_HPP_NOEXCEPT + { + sampleLocationCount = sampleLocationCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setSampleLocationCount( uint32_t sampleLocationCount_ ) && VULKAN_HPP_NOEXCEPT + { + sampleLocationCount = sampleLocationCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setPSampleLocations( const CoarseSampleLocationNV * pSampleLocations_ ) & VULKAN_HPP_NOEXCEPT + { + pSampleLocations = pSampleLocations_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setPSampleLocations( const CoarseSampleLocationNV * pSampleLocations_ ) && VULKAN_HPP_NOEXCEPT + { + pSampleLocations = pSampleLocations_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CoarseSampleOrderCustomNV & setSampleLocations( ArrayProxyNoTemporaries const & sampleLocations_ ) VULKAN_HPP_NOEXCEPT + { + sampleLocationCount = static_cast( sampleLocations_.size() ); + pSampleLocations = sampleLocations_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCoarseSampleOrderCustomNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCoarseSampleOrderCustomNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCoarseSampleOrderCustomNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCoarseSampleOrderCustomNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( shadingRate, sampleCount, sampleLocationCount, pSampleLocations ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CoarseSampleOrderCustomNV const & ) const = default; +#else + bool operator==( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( shadingRate == rhs.shadingRate ) && ( sampleCount == rhs.sampleCount ) && ( sampleLocationCount == rhs.sampleLocationCount ) && + ( pSampleLocations == rhs.pSampleLocations ); +# endif + } + + bool operator!=( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ShadingRatePaletteEntryNV shadingRate = ShadingRatePaletteEntryNV::eNoInvocations; + uint32_t sampleCount = {}; + uint32_t sampleLocationCount = {}; + const CoarseSampleLocationNV * pSampleLocations = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CoarseSampleOrderCustomNV; + }; +#endif + + // wrapper struct for struct VkColorBlendAdvancedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorBlendAdvancedEXT.html + struct ColorBlendAdvancedEXT + { + using NativeType = VkColorBlendAdvancedEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ColorBlendAdvancedEXT( BlendOp advancedBlendOp_ = BlendOp::eAdd, + Bool32 srcPremultiplied_ = {}, + Bool32 dstPremultiplied_ = {}, + BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated, + Bool32 clampResults_ = {} ) VULKAN_HPP_NOEXCEPT + : advancedBlendOp{ advancedBlendOp_ } + , srcPremultiplied{ srcPremultiplied_ } + , dstPremultiplied{ dstPremultiplied_ } + , blendOverlap{ blendOverlap_ } + , clampResults{ clampResults_ } + { + } + + VULKAN_HPP_CONSTEXPR ColorBlendAdvancedEXT( ColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ColorBlendAdvancedEXT( VkColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ColorBlendAdvancedEXT( *reinterpret_cast( &rhs ) ) + { + } + + ColorBlendAdvancedEXT & operator=( ColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ColorBlendAdvancedEXT & operator=( VkColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setAdvancedBlendOp( BlendOp advancedBlendOp_ ) & VULKAN_HPP_NOEXCEPT + { + advancedBlendOp = advancedBlendOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setAdvancedBlendOp( BlendOp advancedBlendOp_ ) && VULKAN_HPP_NOEXCEPT + { + advancedBlendOp = advancedBlendOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setSrcPremultiplied( Bool32 srcPremultiplied_ ) & VULKAN_HPP_NOEXCEPT + { + srcPremultiplied = srcPremultiplied_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setSrcPremultiplied( Bool32 srcPremultiplied_ ) && VULKAN_HPP_NOEXCEPT + { + srcPremultiplied = srcPremultiplied_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setDstPremultiplied( Bool32 dstPremultiplied_ ) & VULKAN_HPP_NOEXCEPT + { + dstPremultiplied = dstPremultiplied_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setDstPremultiplied( Bool32 dstPremultiplied_ ) && VULKAN_HPP_NOEXCEPT + { + dstPremultiplied = dstPremultiplied_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setBlendOverlap( BlendOverlapEXT blendOverlap_ ) & VULKAN_HPP_NOEXCEPT + { + blendOverlap = blendOverlap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setBlendOverlap( BlendOverlapEXT blendOverlap_ ) && VULKAN_HPP_NOEXCEPT + { + blendOverlap = blendOverlap_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setClampResults( Bool32 clampResults_ ) & VULKAN_HPP_NOEXCEPT + { + clampResults = clampResults_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setClampResults( Bool32 clampResults_ ) && VULKAN_HPP_NOEXCEPT + { + clampResults = clampResults_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkColorBlendAdvancedEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkColorBlendAdvancedEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkColorBlendAdvancedEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkColorBlendAdvancedEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( advancedBlendOp, srcPremultiplied, dstPremultiplied, blendOverlap, clampResults ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ColorBlendAdvancedEXT const & ) const = default; +#else + bool operator==( ColorBlendAdvancedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( advancedBlendOp == rhs.advancedBlendOp ) && ( srcPremultiplied == rhs.srcPremultiplied ) && ( dstPremultiplied == rhs.dstPremultiplied ) && + ( blendOverlap == rhs.blendOverlap ) && ( clampResults == rhs.clampResults ); +# endif + } + + bool operator!=( ColorBlendAdvancedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + BlendOp advancedBlendOp = BlendOp::eAdd; + Bool32 srcPremultiplied = {}; + Bool32 dstPremultiplied = {}; + BlendOverlapEXT blendOverlap = BlendOverlapEXT::eUncorrelated; + Bool32 clampResults = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ColorBlendAdvancedEXT; + }; +#endif + + // wrapper struct for struct VkColorBlendEquationEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorBlendEquationEXT.html + struct ColorBlendEquationEXT + { + using NativeType = VkColorBlendEquationEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ColorBlendEquationEXT( BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, + BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, + BlendOp colorBlendOp_ = BlendOp::eAdd, + BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, + BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, + BlendOp alphaBlendOp_ = BlendOp::eAdd ) VULKAN_HPP_NOEXCEPT + : srcColorBlendFactor{ srcColorBlendFactor_ } + , dstColorBlendFactor{ dstColorBlendFactor_ } + , colorBlendOp{ colorBlendOp_ } + , srcAlphaBlendFactor{ srcAlphaBlendFactor_ } + , dstAlphaBlendFactor{ dstAlphaBlendFactor_ } + , alphaBlendOp{ alphaBlendOp_ } + { + } + + VULKAN_HPP_CONSTEXPR ColorBlendEquationEXT( ColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ColorBlendEquationEXT( VkColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ColorBlendEquationEXT( *reinterpret_cast( &rhs ) ) + { + } + + ColorBlendEquationEXT & operator=( ColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ColorBlendEquationEXT & operator=( VkColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) & VULKAN_HPP_NOEXCEPT + { + srcColorBlendFactor = srcColorBlendFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) && VULKAN_HPP_NOEXCEPT + { + srcColorBlendFactor = srcColorBlendFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) & VULKAN_HPP_NOEXCEPT + { + dstColorBlendFactor = dstColorBlendFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) && VULKAN_HPP_NOEXCEPT + { + dstColorBlendFactor = dstColorBlendFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setColorBlendOp( BlendOp colorBlendOp_ ) & VULKAN_HPP_NOEXCEPT + { + colorBlendOp = colorBlendOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setColorBlendOp( BlendOp colorBlendOp_ ) && VULKAN_HPP_NOEXCEPT + { + colorBlendOp = colorBlendOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) & VULKAN_HPP_NOEXCEPT + { + srcAlphaBlendFactor = srcAlphaBlendFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) && VULKAN_HPP_NOEXCEPT + { + srcAlphaBlendFactor = srcAlphaBlendFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) & VULKAN_HPP_NOEXCEPT + { + dstAlphaBlendFactor = dstAlphaBlendFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) && VULKAN_HPP_NOEXCEPT + { + dstAlphaBlendFactor = dstAlphaBlendFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setAlphaBlendOp( BlendOp alphaBlendOp_ ) & VULKAN_HPP_NOEXCEPT + { + alphaBlendOp = alphaBlendOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setAlphaBlendOp( BlendOp alphaBlendOp_ ) && VULKAN_HPP_NOEXCEPT + { + alphaBlendOp = alphaBlendOp_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkColorBlendEquationEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkColorBlendEquationEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkColorBlendEquationEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkColorBlendEquationEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcColorBlendFactor, dstColorBlendFactor, colorBlendOp, srcAlphaBlendFactor, dstAlphaBlendFactor, alphaBlendOp ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ColorBlendEquationEXT const & ) const = default; +#else + bool operator==( ColorBlendEquationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( srcColorBlendFactor == rhs.srcColorBlendFactor ) && ( dstColorBlendFactor == rhs.dstColorBlendFactor ) && ( colorBlendOp == rhs.colorBlendOp ) && + ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) && ( alphaBlendOp == rhs.alphaBlendOp ); +# endif + } + + bool operator!=( ColorBlendEquationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + BlendFactor srcColorBlendFactor = BlendFactor::eZero; + BlendFactor dstColorBlendFactor = BlendFactor::eZero; + BlendOp colorBlendOp = BlendOp::eAdd; + BlendFactor srcAlphaBlendFactor = BlendFactor::eZero; + BlendFactor dstAlphaBlendFactor = BlendFactor::eZero; + BlendOp alphaBlendOp = BlendOp::eAdd; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ColorBlendEquationEXT; + }; +#endif + + // wrapper struct for struct VkCommandBufferAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferAllocateInfo.html + struct CommandBufferAllocateInfo + { + using NativeType = VkCommandBufferAllocateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferAllocateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( CommandPool commandPool_ = {}, + CommandBufferLevel level_ = CommandBufferLevel::ePrimary, + uint32_t commandBufferCount_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , commandPool{ commandPool_ } + , level{ level_ } + , commandBufferCount{ commandBufferCount_ } + { + } + + VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : CommandBufferAllocateInfo( *reinterpret_cast( &rhs ) ) + { + } + + CommandBufferAllocateInfo & operator=( CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CommandBufferAllocateInfo & operator=( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setCommandPool( CommandPool commandPool_ ) & VULKAN_HPP_NOEXCEPT + { + commandPool = commandPool_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setCommandPool( CommandPool commandPool_ ) && VULKAN_HPP_NOEXCEPT + { + commandPool = commandPool_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setLevel( CommandBufferLevel level_ ) & VULKAN_HPP_NOEXCEPT + { + level = level_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setLevel( CommandBufferLevel level_ ) && VULKAN_HPP_NOEXCEPT + { + level = level_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setCommandBufferCount( uint32_t commandBufferCount_ ) & VULKAN_HPP_NOEXCEPT + { + commandBufferCount = commandBufferCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setCommandBufferCount( uint32_t commandBufferCount_ ) && VULKAN_HPP_NOEXCEPT + { + commandBufferCount = commandBufferCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCommandBufferAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferAllocateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferAllocateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCommandBufferAllocateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, commandPool, level, commandBufferCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CommandBufferAllocateInfo const & ) const = default; +#else + bool operator==( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandPool == rhs.commandPool ) && ( level == rhs.level ) && + ( commandBufferCount == rhs.commandBufferCount ); +# endif + } + + bool operator!=( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCommandBufferAllocateInfo; + const void * pNext = {}; + CommandPool commandPool = {}; + CommandBufferLevel level = CommandBufferLevel::ePrimary; + uint32_t commandBufferCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CommandBufferAllocateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = CommandBufferAllocateInfo; + }; + + // wrapper struct for struct VkCommandBufferInheritanceInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceInfo.html + struct CommandBufferInheritanceInfo + { + using NativeType = VkCommandBufferInheritanceInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( RenderPass renderPass_ = {}, + uint32_t subpass_ = {}, + Framebuffer framebuffer_ = {}, + Bool32 occlusionQueryEnable_ = {}, + QueryControlFlags queryFlags_ = {}, + QueryPipelineStatisticFlags pipelineStatistics_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , renderPass{ renderPass_ } + , subpass{ subpass_ } + , framebuffer{ framebuffer_ } + , occlusionQueryEnable{ occlusionQueryEnable_ } + , queryFlags{ queryFlags_ } + , pipelineStatistics{ pipelineStatistics_ } + { + } + + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : CommandBufferInheritanceInfo( *reinterpret_cast( &rhs ) ) + { + } + + CommandBufferInheritanceInfo & operator=( CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CommandBufferInheritanceInfo & operator=( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setRenderPass( RenderPass renderPass_ ) & VULKAN_HPP_NOEXCEPT + { + renderPass = renderPass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setRenderPass( RenderPass renderPass_ ) && VULKAN_HPP_NOEXCEPT + { + renderPass = renderPass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setSubpass( uint32_t subpass_ ) & VULKAN_HPP_NOEXCEPT + { + subpass = subpass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setSubpass( uint32_t subpass_ ) && VULKAN_HPP_NOEXCEPT + { + subpass = subpass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setFramebuffer( Framebuffer framebuffer_ ) & VULKAN_HPP_NOEXCEPT + { + framebuffer = framebuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setFramebuffer( Framebuffer framebuffer_ ) && VULKAN_HPP_NOEXCEPT + { + framebuffer = framebuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ ) & VULKAN_HPP_NOEXCEPT + { + occlusionQueryEnable = occlusionQueryEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ ) && VULKAN_HPP_NOEXCEPT + { + occlusionQueryEnable = occlusionQueryEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setQueryFlags( QueryControlFlags queryFlags_ ) & VULKAN_HPP_NOEXCEPT + { + queryFlags = queryFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setQueryFlags( QueryControlFlags queryFlags_ ) && VULKAN_HPP_NOEXCEPT + { + queryFlags = queryFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineStatistics = pipelineStatistics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineStatistics = pipelineStatistics_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCommandBufferInheritanceInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, renderPass, subpass, framebuffer, occlusionQueryEnable, queryFlags, pipelineStatistics ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CommandBufferInheritanceInfo const & ) const = default; +#else + bool operator==( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && ( subpass == rhs.subpass ) && + ( framebuffer == rhs.framebuffer ) && ( occlusionQueryEnable == rhs.occlusionQueryEnable ) && ( queryFlags == rhs.queryFlags ) && + ( pipelineStatistics == rhs.pipelineStatistics ); +# endif + } + + bool operator!=( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCommandBufferInheritanceInfo; + const void * pNext = {}; + RenderPass renderPass = {}; + uint32_t subpass = {}; + Framebuffer framebuffer = {}; + Bool32 occlusionQueryEnable = {}; + QueryControlFlags queryFlags = {}; + QueryPipelineStatisticFlags pipelineStatistics = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CommandBufferInheritanceInfo; + }; +#endif + + template <> + struct CppType + { + using Type = CommandBufferInheritanceInfo; + }; + + // wrapper struct for struct VkCommandBufferBeginInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferBeginInfo.html + struct CommandBufferBeginInfo + { + using NativeType = VkCommandBufferBeginInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferBeginInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = {}, + const CommandBufferInheritanceInfo * pInheritanceInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pInheritanceInfo{ pInheritanceInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : CommandBufferBeginInfo( *reinterpret_cast( &rhs ) ) + { + } + + CommandBufferBeginInfo & operator=( CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CommandBufferBeginInfo & operator=( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo & setFlags( CommandBufferUsageFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo && setFlags( CommandBufferUsageFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo & setPInheritanceInfo( const CommandBufferInheritanceInfo * pInheritanceInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pInheritanceInfo = pInheritanceInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo && setPInheritanceInfo( const CommandBufferInheritanceInfo * pInheritanceInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pInheritanceInfo = pInheritanceInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferBeginInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCommandBufferBeginInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pInheritanceInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CommandBufferBeginInfo const & ) const = default; +#else + bool operator==( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pInheritanceInfo == rhs.pInheritanceInfo ); +# endif + } + + bool operator!=( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCommandBufferBeginInfo; + const void * pNext = {}; + CommandBufferUsageFlags flags = {}; + const CommandBufferInheritanceInfo * pInheritanceInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CommandBufferBeginInfo; + }; +#endif + + template <> + struct CppType + { + using Type = CommandBufferBeginInfo; + }; + + // wrapper struct for struct VkCommandBufferInheritanceConditionalRenderingInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html + struct CommandBufferInheritanceConditionalRenderingInfoEXT + { + using NativeType = VkCommandBufferInheritanceConditionalRenderingInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( Bool32 conditionalRenderingEnable_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , conditionalRenderingEnable{ conditionalRenderingEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR + CommandBufferInheritanceConditionalRenderingInfoEXT( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : CommandBufferInheritanceConditionalRenderingInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + CommandBufferInheritanceConditionalRenderingInfoEXT & + operator=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CommandBufferInheritanceConditionalRenderingInfoEXT & operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT & setConditionalRenderingEnable( Bool32 conditionalRenderingEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + conditionalRenderingEnable = conditionalRenderingEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT && setConditionalRenderingEnable( Bool32 conditionalRenderingEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + conditionalRenderingEnable = conditionalRenderingEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceConditionalRenderingInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, conditionalRenderingEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CommandBufferInheritanceConditionalRenderingInfoEXT const & ) const = default; +#else + bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRenderingEnable == rhs.conditionalRenderingEnable ); +# endif + } + + bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; + const void * pNext = {}; + Bool32 conditionalRenderingEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CommandBufferInheritanceConditionalRenderingInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = CommandBufferInheritanceConditionalRenderingInfoEXT; + }; + + // wrapper struct for struct VkCommandBufferInheritanceDescriptorHeapInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceDescriptorHeapInfoEXT.html + struct CommandBufferInheritanceDescriptorHeapInfoEXT + { + using NativeType = VkCommandBufferInheritanceDescriptorHeapInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceDescriptorHeapInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceDescriptorHeapInfoEXT( const BindHeapInfoEXT * pSamplerHeapBindInfo_ = {}, + const BindHeapInfoEXT * pResourceHeapBindInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pSamplerHeapBindInfo{ pSamplerHeapBindInfo_ } + , pResourceHeapBindInfo{ pResourceHeapBindInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR + CommandBufferInheritanceDescriptorHeapInfoEXT( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CommandBufferInheritanceDescriptorHeapInfoEXT( VkCommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : CommandBufferInheritanceDescriptorHeapInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + CommandBufferInheritanceDescriptorHeapInfoEXT & operator=( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CommandBufferInheritanceDescriptorHeapInfoEXT & operator=( VkCommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT & setPSamplerHeapBindInfo( const BindHeapInfoEXT * pSamplerHeapBindInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pSamplerHeapBindInfo = pSamplerHeapBindInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT && setPSamplerHeapBindInfo( const BindHeapInfoEXT * pSamplerHeapBindInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pSamplerHeapBindInfo = pSamplerHeapBindInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT & setPResourceHeapBindInfo( const BindHeapInfoEXT * pResourceHeapBindInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pResourceHeapBindInfo = pResourceHeapBindInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT && setPResourceHeapBindInfo( const BindHeapInfoEXT * pResourceHeapBindInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pResourceHeapBindInfo = pResourceHeapBindInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCommandBufferInheritanceDescriptorHeapInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceDescriptorHeapInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceDescriptorHeapInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceDescriptorHeapInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pSamplerHeapBindInfo, pResourceHeapBindInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CommandBufferInheritanceDescriptorHeapInfoEXT const & ) const = default; +#else + bool operator==( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSamplerHeapBindInfo == rhs.pSamplerHeapBindInfo ) && + ( pResourceHeapBindInfo == rhs.pResourceHeapBindInfo ); +# endif + } + + bool operator!=( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCommandBufferInheritanceDescriptorHeapInfoEXT; + const void * pNext = {}; + const BindHeapInfoEXT * pSamplerHeapBindInfo = {}; + const BindHeapInfoEXT * pResourceHeapBindInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CommandBufferInheritanceDescriptorHeapInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = CommandBufferInheritanceDescriptorHeapInfoEXT; + }; + + // wrapper struct for struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html + struct CommandBufferInheritanceRenderPassTransformInfoQCOM + { + using NativeType = VkCommandBufferInheritanceRenderPassTransformInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderPassTransformInfoQCOM( SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, + Rect2D renderArea_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , transform{ transform_ } + , renderArea{ renderArea_ } + { + } + + VULKAN_HPP_CONSTEXPR + CommandBufferInheritanceRenderPassTransformInfoQCOM( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CommandBufferInheritanceRenderPassTransformInfoQCOM( VkCommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : CommandBufferInheritanceRenderPassTransformInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + CommandBufferInheritanceRenderPassTransformInfoQCOM & + operator=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CommandBufferInheritanceRenderPassTransformInfoQCOM & operator=( VkCommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM & setTransform( SurfaceTransformFlagBitsKHR transform_ ) & VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM && setTransform( SurfaceTransformFlagBitsKHR transform_ ) && VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM & setRenderArea( Rect2D const & renderArea_ ) & VULKAN_HPP_NOEXCEPT + { + renderArea = renderArea_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM && setRenderArea( Rect2D const & renderArea_ ) && VULKAN_HPP_NOEXCEPT + { + renderArea = renderArea_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transform, renderArea ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CommandBufferInheritanceRenderPassTransformInfoQCOM const & ) const = default; +#else + bool operator==( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ) && ( renderArea == rhs.renderArea ); +# endif + } + + bool operator!=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM; + const void * pNext = {}; + SurfaceTransformFlagBitsKHR transform = SurfaceTransformFlagBitsKHR::eIdentity; + Rect2D renderArea = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM; + }; + + // wrapper struct for struct VkCommandBufferInheritanceRenderingInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceRenderingInfo.html + struct CommandBufferInheritanceRenderingInfo + { + using NativeType = VkCommandBufferInheritanceRenderingInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceRenderingInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderingInfo( RenderingFlags flags_ = {}, + uint32_t viewMask_ = {}, + uint32_t colorAttachmentCount_ = {}, + const Format * pColorAttachmentFormats_ = {}, + Format depthAttachmentFormat_ = Format::eUndefined, + Format stencilAttachmentFormat_ = Format::eUndefined, + SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , viewMask{ viewMask_ } + , colorAttachmentCount{ colorAttachmentCount_ } + , pColorAttachmentFormats{ pColorAttachmentFormats_ } + , depthAttachmentFormat{ depthAttachmentFormat_ } + , stencilAttachmentFormat{ stencilAttachmentFormat_ } + , rasterizationSamples{ rasterizationSamples_ } + { + } + + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderingInfo( CommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CommandBufferInheritanceRenderingInfo( VkCommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : CommandBufferInheritanceRenderingInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CommandBufferInheritanceRenderingInfo( RenderingFlags flags_, + uint32_t viewMask_, + ArrayProxyNoTemporaries const & colorAttachmentFormats_, + Format depthAttachmentFormat_ = Format::eUndefined, + Format stencilAttachmentFormat_ = Format::eUndefined, + SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , viewMask( viewMask_ ) + , colorAttachmentCount( static_cast( colorAttachmentFormats_.size() ) ) + , pColorAttachmentFormats( colorAttachmentFormats_.data() ) + , depthAttachmentFormat( depthAttachmentFormat_ ) + , stencilAttachmentFormat( stencilAttachmentFormat_ ) + , rasterizationSamples( rasterizationSamples_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CommandBufferInheritanceRenderingInfo & operator=( CommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CommandBufferInheritanceRenderingInfo & operator=( VkCommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setFlags( RenderingFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setFlags( RenderingFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setViewMask( uint32_t viewMask_ ) & VULKAN_HPP_NOEXCEPT + { + viewMask = viewMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setViewMask( uint32_t viewMask_ ) && VULKAN_HPP_NOEXCEPT + { + viewMask = viewMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) & VULKAN_HPP_NOEXCEPT + { + pColorAttachmentFormats = pColorAttachmentFormats_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) && + VULKAN_HPP_NOEXCEPT + { + pColorAttachmentFormats = pColorAttachmentFormats_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CommandBufferInheritanceRenderingInfo & + setColorAttachmentFormats( ArrayProxyNoTemporaries const & colorAttachmentFormats_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( colorAttachmentFormats_.size() ); + pColorAttachmentFormats = colorAttachmentFormats_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setDepthAttachmentFormat( Format depthAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT + { + depthAttachmentFormat = depthAttachmentFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setDepthAttachmentFormat( Format depthAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT + { + depthAttachmentFormat = depthAttachmentFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT + { + stencilAttachmentFormat = stencilAttachmentFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT + { + stencilAttachmentFormat = stencilAttachmentFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) & VULKAN_HPP_NOEXCEPT + { + rasterizationSamples = rasterizationSamples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) && VULKAN_HPP_NOEXCEPT + { + rasterizationSamples = rasterizationSamples_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCommandBufferInheritanceRenderingInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceRenderingInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceRenderingInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceRenderingInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, flags, viewMask, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat, rasterizationSamples ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CommandBufferInheritanceRenderingInfo const & ) const = default; +#else + bool operator==( CommandBufferInheritanceRenderingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( viewMask == rhs.viewMask ) && + ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && + ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ) && + ( rasterizationSamples == rhs.rasterizationSamples ); +# endif + } + + bool operator!=( CommandBufferInheritanceRenderingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCommandBufferInheritanceRenderingInfo; + const void * pNext = {}; + RenderingFlags flags = {}; + uint32_t viewMask = {}; + uint32_t colorAttachmentCount = {}; + const Format * pColorAttachmentFormats = {}; + Format depthAttachmentFormat = Format::eUndefined; + Format stencilAttachmentFormat = Format::eUndefined; + SampleCountFlagBits rasterizationSamples = SampleCountFlagBits::e1; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CommandBufferInheritanceRenderingInfo; + }; +#endif + + template <> + struct CppType + { + using Type = CommandBufferInheritanceRenderingInfo; + }; + + using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo; + + // wrapper struct for struct VkViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViewport.html + struct Viewport + { + using NativeType = VkViewport; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + Viewport( float x_ = {}, float y_ = {}, float width_ = {}, float height_ = {}, float minDepth_ = {}, float maxDepth_ = {} ) VULKAN_HPP_NOEXCEPT + : x{ x_ } + , y{ y_ } + , width{ width_ } + , height{ height_ } + , minDepth{ minDepth_ } + , maxDepth{ maxDepth_ } + { + } + + VULKAN_HPP_CONSTEXPR Viewport( Viewport const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + Viewport( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT : Viewport( *reinterpret_cast( &rhs ) ) {} + + Viewport & operator=( Viewport const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + Viewport & operator=( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 Viewport & setX( float x_ ) & VULKAN_HPP_NOEXCEPT + { + x = x_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Viewport && setX( float x_ ) && VULKAN_HPP_NOEXCEPT + { + x = x_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Viewport & setY( float y_ ) & VULKAN_HPP_NOEXCEPT + { + y = y_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Viewport && setY( float y_ ) && VULKAN_HPP_NOEXCEPT + { + y = y_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Viewport & setWidth( float width_ ) & VULKAN_HPP_NOEXCEPT + { + width = width_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Viewport && setWidth( float width_ ) && VULKAN_HPP_NOEXCEPT + { + width = width_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Viewport & setHeight( float height_ ) & VULKAN_HPP_NOEXCEPT + { + height = height_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Viewport && setHeight( float height_ ) && VULKAN_HPP_NOEXCEPT + { + height = height_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Viewport & setMinDepth( float minDepth_ ) & VULKAN_HPP_NOEXCEPT + { + minDepth = minDepth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Viewport && setMinDepth( float minDepth_ ) && VULKAN_HPP_NOEXCEPT + { + minDepth = minDepth_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Viewport & setMaxDepth( float maxDepth_ ) & VULKAN_HPP_NOEXCEPT + { + maxDepth = maxDepth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Viewport && setMaxDepth( float maxDepth_ ) && VULKAN_HPP_NOEXCEPT + { + maxDepth = maxDepth_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkViewport const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkViewport &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkViewport const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkViewport *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, width, height, minDepth, maxDepth ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( Viewport const & ) const = default; +#else + bool operator==( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ) && ( width == rhs.width ) && ( height == rhs.height ) && ( minDepth == rhs.minDepth ) && + ( maxDepth == rhs.maxDepth ); +# endif + } + + bool operator!=( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + float x = {}; + float y = {}; + float width = {}; + float height = {}; + float minDepth = {}; + float maxDepth = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = Viewport; + }; +#endif + + // wrapper struct for struct VkCommandBufferInheritanceViewportScissorInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceViewportScissorInfoNV.html + struct CommandBufferInheritanceViewportScissorInfoNV + { + using NativeType = VkCommandBufferInheritanceViewportScissorInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceViewportScissorInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CommandBufferInheritanceViewportScissorInfoNV( Bool32 viewportScissor2D_ = {}, + uint32_t viewportDepthCount_ = {}, + const Viewport * pViewportDepths_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , viewportScissor2D{ viewportScissor2D_ } + , viewportDepthCount{ viewportDepthCount_ } + , pViewportDepths{ pViewportDepths_ } + { + } + + VULKAN_HPP_CONSTEXPR + CommandBufferInheritanceViewportScissorInfoNV( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CommandBufferInheritanceViewportScissorInfoNV( VkCommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : CommandBufferInheritanceViewportScissorInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + CommandBufferInheritanceViewportScissorInfoNV & operator=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CommandBufferInheritanceViewportScissorInfoNV & operator=( VkCommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setViewportScissor2D( Bool32 viewportScissor2D_ ) & VULKAN_HPP_NOEXCEPT + { + viewportScissor2D = viewportScissor2D_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setViewportScissor2D( Bool32 viewportScissor2D_ ) && VULKAN_HPP_NOEXCEPT + { + viewportScissor2D = viewportScissor2D_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setViewportDepthCount( uint32_t viewportDepthCount_ ) & VULKAN_HPP_NOEXCEPT + { + viewportDepthCount = viewportDepthCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setViewportDepthCount( uint32_t viewportDepthCount_ ) && VULKAN_HPP_NOEXCEPT + { + viewportDepthCount = viewportDepthCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setPViewportDepths( const Viewport * pViewportDepths_ ) & VULKAN_HPP_NOEXCEPT + { + pViewportDepths = pViewportDepths_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setPViewportDepths( const Viewport * pViewportDepths_ ) && VULKAN_HPP_NOEXCEPT + { + pViewportDepths = pViewportDepths_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCommandBufferInheritanceViewportScissorInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceViewportScissorInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceViewportScissorInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCommandBufferInheritanceViewportScissorInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, viewportScissor2D, viewportDepthCount, pViewportDepths ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CommandBufferInheritanceViewportScissorInfoNV const & ) const = default; +#else + bool operator==( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportScissor2D == rhs.viewportScissor2D ) && + ( viewportDepthCount == rhs.viewportDepthCount ) && ( pViewportDepths == rhs.pViewportDepths ); +# endif + } + + bool operator!=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCommandBufferInheritanceViewportScissorInfoNV; + const void * pNext = {}; + Bool32 viewportScissor2D = {}; + uint32_t viewportDepthCount = {}; + const Viewport * pViewportDepths = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CommandBufferInheritanceViewportScissorInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = CommandBufferInheritanceViewportScissorInfoNV; + }; + + // wrapper struct for struct VkCommandBufferSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferSubmitInfo.html + struct CommandBufferSubmitInfo + { + using NativeType = VkCommandBufferSubmitInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferSubmitInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + CommandBufferSubmitInfo( CommandBuffer commandBuffer_ = {}, uint32_t deviceMask_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , commandBuffer{ commandBuffer_ } + , deviceMask{ deviceMask_ } + { + } + + VULKAN_HPP_CONSTEXPR CommandBufferSubmitInfo( CommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CommandBufferSubmitInfo( VkCommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : CommandBufferSubmitInfo( *reinterpret_cast( &rhs ) ) + { + } + + CommandBufferSubmitInfo & operator=( CommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CommandBufferSubmitInfo & operator=( VkCommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo & setCommandBuffer( CommandBuffer commandBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + commandBuffer = commandBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo && setCommandBuffer( CommandBuffer commandBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + commandBuffer = commandBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT + { + deviceMask = deviceMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT + { + deviceMask = deviceMask_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCommandBufferSubmitInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferSubmitInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandBufferSubmitInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCommandBufferSubmitInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, commandBuffer, deviceMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CommandBufferSubmitInfo const & ) const = default; +#else + bool operator==( CommandBufferSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBuffer == rhs.commandBuffer ) && ( deviceMask == rhs.deviceMask ); +# endif + } + + bool operator!=( CommandBufferSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCommandBufferSubmitInfo; + const void * pNext = {}; + CommandBuffer commandBuffer = {}; + uint32_t deviceMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CommandBufferSubmitInfo; + }; +#endif + + template <> + struct CppType + { + using Type = CommandBufferSubmitInfo; + }; + + using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo; + + // wrapper struct for struct VkCommandPoolCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolCreateInfo.html + struct CommandPoolCreateInfo + { + using NativeType = VkCommandPoolCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandPoolCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = {}, uint32_t queueFamilyIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , queueFamilyIndex{ queueFamilyIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : CommandPoolCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + CommandPoolCreateInfo & operator=( CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CommandPoolCreateInfo & operator=( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo & setFlags( CommandPoolCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo && setFlags( CommandPoolCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCommandPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandPoolCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCommandPoolCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCommandPoolCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queueFamilyIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CommandPoolCreateInfo const & ) const = default; +#else + bool operator==( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueFamilyIndex == rhs.queueFamilyIndex ); +# endif + } + + bool operator!=( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCommandPoolCreateInfo; + const void * pNext = {}; + CommandPoolCreateFlags flags = {}; + uint32_t queueFamilyIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CommandPoolCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = CommandPoolCreateInfo; + }; + + // wrapper struct for struct VkComputeOccupancyPriorityParametersNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkComputeOccupancyPriorityParametersNV.html + struct ComputeOccupancyPriorityParametersNV + { + using NativeType = VkComputeOccupancyPriorityParametersNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eComputeOccupancyPriorityParametersNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + ComputeOccupancyPriorityParametersNV( float occupancyPriority_ = {}, float occupancyThrottling_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , occupancyPriority{ occupancyPriority_ } + , occupancyThrottling{ occupancyThrottling_ } + { + } + + VULKAN_HPP_CONSTEXPR ComputeOccupancyPriorityParametersNV( ComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ComputeOccupancyPriorityParametersNV( VkComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ComputeOccupancyPriorityParametersNV( *reinterpret_cast( &rhs ) ) + { + } + + ComputeOccupancyPriorityParametersNV & operator=( ComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ComputeOccupancyPriorityParametersNV & operator=( VkComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV & setOccupancyPriority( float occupancyPriority_ ) & VULKAN_HPP_NOEXCEPT + { + occupancyPriority = occupancyPriority_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV && setOccupancyPriority( float occupancyPriority_ ) && VULKAN_HPP_NOEXCEPT + { + occupancyPriority = occupancyPriority_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV & setOccupancyThrottling( float occupancyThrottling_ ) & VULKAN_HPP_NOEXCEPT + { + occupancyThrottling = occupancyThrottling_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV && setOccupancyThrottling( float occupancyThrottling_ ) && VULKAN_HPP_NOEXCEPT + { + occupancyThrottling = occupancyThrottling_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkComputeOccupancyPriorityParametersNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkComputeOccupancyPriorityParametersNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkComputeOccupancyPriorityParametersNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkComputeOccupancyPriorityParametersNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, occupancyPriority, occupancyThrottling ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ComputeOccupancyPriorityParametersNV const & ) const = default; +#else + bool operator==( ComputeOccupancyPriorityParametersNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( occupancyPriority == rhs.occupancyPriority ) && + ( occupancyThrottling == rhs.occupancyThrottling ); +# endif + } + + bool operator!=( ComputeOccupancyPriorityParametersNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eComputeOccupancyPriorityParametersNV; + const void * pNext = {}; + float occupancyPriority = {}; + float occupancyThrottling = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ComputeOccupancyPriorityParametersNV; + }; +#endif + + template <> + struct CppType + { + using Type = ComputeOccupancyPriorityParametersNV; + }; + + // wrapper struct for struct VkSpecializationMapEntry, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpecializationMapEntry.html + struct SpecializationMapEntry + { + using NativeType = VkSpecializationMapEntry; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SpecializationMapEntry( uint32_t constantID_ = {}, uint32_t offset_ = {}, size_t size_ = {} ) VULKAN_HPP_NOEXCEPT + : constantID{ constantID_ } + , offset{ offset_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR SpecializationMapEntry( SpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT + : SpecializationMapEntry( *reinterpret_cast( &rhs ) ) + { + } + + SpecializationMapEntry & operator=( SpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SpecializationMapEntry & operator=( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry & setConstantID( uint32_t constantID_ ) & VULKAN_HPP_NOEXCEPT + { + constantID = constantID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry && setConstantID( uint32_t constantID_ ) && VULKAN_HPP_NOEXCEPT + { + constantID = constantID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry & setSize( size_t size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry && setSize( size_t size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSpecializationMapEntry const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSpecializationMapEntry &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSpecializationMapEntry const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSpecializationMapEntry *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( constantID, offset, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SpecializationMapEntry const & ) const = default; +#else + bool operator==( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( constantID == rhs.constantID ) && ( offset == rhs.offset ) && ( size == rhs.size ); +# endif + } + + bool operator!=( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t constantID = {}; + uint32_t offset = {}; + size_t size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SpecializationMapEntry; + }; +#endif + + // wrapper struct for struct VkSpecializationInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpecializationInfo.html + struct SpecializationInfo + { + using NativeType = VkSpecializationInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SpecializationInfo( uint32_t mapEntryCount_ = {}, + const SpecializationMapEntry * pMapEntries_ = {}, + size_t dataSize_ = {}, + const void * pData_ = {} ) VULKAN_HPP_NOEXCEPT + : mapEntryCount{ mapEntryCount_ } + , pMapEntries{ pMapEntries_ } + , dataSize{ dataSize_ } + , pData{ pData_ } + { + } + + VULKAN_HPP_CONSTEXPR SpecializationInfo( SpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SpecializationInfo( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SpecializationInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + SpecializationInfo( ArrayProxyNoTemporaries const & mapEntries_, ArrayProxyNoTemporaries const & data_ = {} ) + : mapEntryCount( static_cast( mapEntries_.size() ) ) + , pMapEntries( mapEntries_.data() ) + , dataSize( data_.size() * sizeof( T ) ) + , pData( data_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SpecializationInfo & operator=( SpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SpecializationInfo & operator=( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setMapEntryCount( uint32_t mapEntryCount_ ) & VULKAN_HPP_NOEXCEPT + { + mapEntryCount = mapEntryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setMapEntryCount( uint32_t mapEntryCount_ ) && VULKAN_HPP_NOEXCEPT + { + mapEntryCount = mapEntryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setPMapEntries( const SpecializationMapEntry * pMapEntries_ ) & VULKAN_HPP_NOEXCEPT + { + pMapEntries = pMapEntries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setPMapEntries( const SpecializationMapEntry * pMapEntries_ ) && VULKAN_HPP_NOEXCEPT + { + pMapEntries = pMapEntries_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SpecializationInfo & setMapEntries( ArrayProxyNoTemporaries const & mapEntries_ ) VULKAN_HPP_NOEXCEPT + { + mapEntryCount = static_cast( mapEntries_.size() ); + pMapEntries = mapEntries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setPData( const void * pData_ ) & VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setPData( const void * pData_ ) && VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + SpecializationInfo & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT + { + dataSize = data_.size() * sizeof( T ); + pData = data_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSpecializationInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSpecializationInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSpecializationInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSpecializationInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( mapEntryCount, pMapEntries, dataSize, pData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SpecializationInfo const & ) const = default; +#else + bool operator==( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( mapEntryCount == rhs.mapEntryCount ) && ( pMapEntries == rhs.pMapEntries ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); +# endif + } + + bool operator!=( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t mapEntryCount = {}; + const SpecializationMapEntry * pMapEntries = {}; + size_t dataSize = {}; + const void * pData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SpecializationInfo; + }; +#endif + + // wrapper struct for struct VkPipelineShaderStageCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageCreateInfo.html + struct PipelineShaderStageCreateInfo + { + using NativeType = VkPipelineShaderStageCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = {}, + ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, + ShaderModule module_ = {}, + const char * pName_ = {}, + const SpecializationInfo * pSpecializationInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , stage{ stage_ } + , module{ module_ } + , pName{ pName_ } + , pSpecializationInfo{ pSpecializationInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineShaderStageCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PipelineShaderStageCreateInfo & operator=( PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineShaderStageCreateInfo & operator=( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setFlags( PipelineShaderStageCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setFlags( PipelineShaderStageCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setStage( ShaderStageFlagBits stage_ ) & VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setStage( ShaderStageFlagBits stage_ ) && VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setModule( ShaderModule module_ ) & VULKAN_HPP_NOEXCEPT + { + module = module_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setModule( ShaderModule module_ ) && VULKAN_HPP_NOEXCEPT + { + module = module_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pSpecializationInfo = pSpecializationInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pSpecializationInfo = pSpecializationInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineShaderStageCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineShaderStageCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineShaderStageCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineShaderStageCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, stage, module, pName, pSpecializationInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = stage <=> rhs.stage; cmp != 0 ) + return cmp; + if ( auto cmp = module <=> rhs.module; cmp != 0 ) + return cmp; + if ( pName != rhs.pName ) + if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = pSpecializationInfo <=> rhs.pSpecializationInfo; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( module == rhs.module ) && + ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( pSpecializationInfo == rhs.pSpecializationInfo ); + } + + bool operator!=( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::ePipelineShaderStageCreateInfo; + const void * pNext = {}; + PipelineShaderStageCreateFlags flags = {}; + ShaderStageFlagBits stage = ShaderStageFlagBits::eVertex; + ShaderModule module = {}; + const char * pName = {}; + const SpecializationInfo * pSpecializationInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineShaderStageCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineShaderStageCreateInfo; + }; + + // wrapper struct for struct VkComputePipelineCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkComputePipelineCreateInfo.html + struct ComputePipelineCreateInfo + { + using NativeType = VkComputePipelineCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eComputePipelineCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( PipelineCreateFlags flags_ = {}, + PipelineShaderStageCreateInfo stage_ = {}, + PipelineLayout layout_ = {}, + Pipeline basePipelineHandle_ = {}, + int32_t basePipelineIndex_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , stage{ stage_ } + , layout{ layout_ } + , basePipelineHandle{ basePipelineHandle_ } + , basePipelineIndex{ basePipelineIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : ComputePipelineCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + ComputePipelineCreateInfo & operator=( ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ComputePipelineCreateInfo & operator=( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setFlags( PipelineCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setFlags( PipelineCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setStage( PipelineShaderStageCreateInfo const & stage_ ) & VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setStage( PipelineShaderStageCreateInfo const & stage_ ) && VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setBasePipelineHandle( Pipeline basePipelineHandle_ ) & VULKAN_HPP_NOEXCEPT + { + basePipelineHandle = basePipelineHandle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setBasePipelineHandle( Pipeline basePipelineHandle_ ) && VULKAN_HPP_NOEXCEPT + { + basePipelineHandle = basePipelineHandle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setBasePipelineIndex( int32_t basePipelineIndex_ ) & VULKAN_HPP_NOEXCEPT + { + basePipelineIndex = basePipelineIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setBasePipelineIndex( int32_t basePipelineIndex_ ) && VULKAN_HPP_NOEXCEPT + { + basePipelineIndex = basePipelineIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkComputePipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkComputePipelineCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkComputePipelineCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkComputePipelineCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, stage, layout, basePipelineHandle, basePipelineIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ComputePipelineCreateInfo const & ) const = default; +#else + bool operator==( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( layout == rhs.layout ) && + ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex ); +# endif + } + + bool operator!=( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eComputePipelineCreateInfo; + const void * pNext = {}; + PipelineCreateFlags flags = {}; + PipelineShaderStageCreateInfo stage = {}; + PipelineLayout layout = {}; + Pipeline basePipelineHandle = {}; + int32_t basePipelineIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ComputePipelineCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ComputePipelineCreateInfo; + }; + + // wrapper struct for struct VkComputePipelineIndirectBufferInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkComputePipelineIndirectBufferInfoNV.html + struct ComputePipelineIndirectBufferInfoNV + { + using NativeType = VkComputePipelineIndirectBufferInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eComputePipelineIndirectBufferInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ComputePipelineIndirectBufferInfoNV( DeviceAddress deviceAddress_ = {}, + DeviceSize size_ = {}, + DeviceAddress pipelineDeviceAddressCaptureReplay_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceAddress{ deviceAddress_ } + , size{ size_ } + , pipelineDeviceAddressCaptureReplay{ pipelineDeviceAddressCaptureReplay_ } + { + } + + VULKAN_HPP_CONSTEXPR ComputePipelineIndirectBufferInfoNV( ComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ComputePipelineIndirectBufferInfoNV( VkComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ComputePipelineIndirectBufferInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ComputePipelineIndirectBufferInfoNV & operator=( ComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ComputePipelineIndirectBufferInfoNV & operator=( VkComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setPipelineDeviceAddressCaptureReplay( DeviceAddress pipelineDeviceAddressCaptureReplay_ ) & + VULKAN_HPP_NOEXCEPT + { + pipelineDeviceAddressCaptureReplay = pipelineDeviceAddressCaptureReplay_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setPipelineDeviceAddressCaptureReplay( DeviceAddress pipelineDeviceAddressCaptureReplay_ ) && + VULKAN_HPP_NOEXCEPT + { + pipelineDeviceAddressCaptureReplay = pipelineDeviceAddressCaptureReplay_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkComputePipelineIndirectBufferInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkComputePipelineIndirectBufferInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkComputePipelineIndirectBufferInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkComputePipelineIndirectBufferInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceAddress, size, pipelineDeviceAddressCaptureReplay ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ComputePipelineIndirectBufferInfoNV const & ) const = default; +#else + bool operator==( ComputePipelineIndirectBufferInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) && ( size == rhs.size ) && + ( pipelineDeviceAddressCaptureReplay == rhs.pipelineDeviceAddressCaptureReplay ); +# endif + } + + bool operator!=( ComputePipelineIndirectBufferInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eComputePipelineIndirectBufferInfoNV; + const void * pNext = {}; + DeviceAddress deviceAddress = {}; + DeviceSize size = {}; + DeviceAddress pipelineDeviceAddressCaptureReplay = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ComputePipelineIndirectBufferInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = ComputePipelineIndirectBufferInfoNV; + }; + + // wrapper struct for struct VkConditionalRenderingBeginInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingBeginInfoEXT.html + struct ConditionalRenderingBeginInfoEXT + { + using NativeType = VkConditionalRenderingBeginInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eConditionalRenderingBeginInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( Buffer buffer_ = {}, + DeviceSize offset_ = {}, + ConditionalRenderingFlagsEXT flags_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , buffer{ buffer_ } + , offset{ offset_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ConditionalRenderingBeginInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ConditionalRenderingBeginInfoEXT & operator=( ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ConditionalRenderingBeginInfoEXT & operator=( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setFlags( ConditionalRenderingFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setFlags( ConditionalRenderingFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkConditionalRenderingBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkConditionalRenderingBeginInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkConditionalRenderingBeginInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkConditionalRenderingBeginInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer, offset, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ConditionalRenderingBeginInfoEXT const & ) const = default; +#else + bool operator==( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT; + const void * pNext = {}; + Buffer buffer = {}; + DeviceSize offset = {}; + ConditionalRenderingFlagsEXT flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ConditionalRenderingBeginInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ConditionalRenderingBeginInfoEXT; + }; + + // wrapper struct for struct VkConformanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkConformanceVersion.html + struct ConformanceVersion + { + using NativeType = VkConformanceVersion; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ConformanceVersion( uint8_t major_ = {}, uint8_t minor_ = {}, uint8_t subminor_ = {}, uint8_t patch_ = {} ) VULKAN_HPP_NOEXCEPT + : major{ major_ } + , minor{ minor_ } + , subminor{ subminor_ } + , patch{ patch_ } + { + } + + VULKAN_HPP_CONSTEXPR ConformanceVersion( ConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ConformanceVersion( VkConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT : ConformanceVersion( *reinterpret_cast( &rhs ) ) {} + + ConformanceVersion & operator=( ConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ConformanceVersion & operator=( VkConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setMajor( uint8_t major_ ) & VULKAN_HPP_NOEXCEPT + { + major = major_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setMajor( uint8_t major_ ) && VULKAN_HPP_NOEXCEPT + { + major = major_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setMinor( uint8_t minor_ ) & VULKAN_HPP_NOEXCEPT + { + minor = minor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setMinor( uint8_t minor_ ) && VULKAN_HPP_NOEXCEPT + { + minor = minor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setSubminor( uint8_t subminor_ ) & VULKAN_HPP_NOEXCEPT + { + subminor = subminor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setSubminor( uint8_t subminor_ ) && VULKAN_HPP_NOEXCEPT + { + subminor = subminor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setPatch( uint8_t patch_ ) & VULKAN_HPP_NOEXCEPT + { + patch = patch_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setPatch( uint8_t patch_ ) && VULKAN_HPP_NOEXCEPT + { + patch = patch_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkConformanceVersion const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkConformanceVersion &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkConformanceVersion const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkConformanceVersion *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( major, minor, subminor, patch ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ConformanceVersion const & ) const = default; +#else + bool operator==( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( major == rhs.major ) && ( minor == rhs.minor ) && ( subminor == rhs.subminor ) && ( patch == rhs.patch ); +# endif + } + + bool operator!=( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint8_t major = {}; + uint8_t minor = {}; + uint8_t subminor = {}; + uint8_t patch = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ConformanceVersion; + }; +#endif + using ConformanceVersionKHR = ConformanceVersion; + + // wrapper struct for struct VkConvertCooperativeVectorMatrixInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConvertCooperativeVectorMatrixInfoNV.html + struct ConvertCooperativeVectorMatrixInfoNV + { + using NativeType = VkConvertCooperativeVectorMatrixInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eConvertCooperativeVectorMatrixInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV( size_t srcSize_ = {}, + DeviceOrHostAddressConstKHR srcData_ = {}, + size_t * pDstSize_ = {}, + DeviceOrHostAddressKHR dstData_ = {}, + ComponentTypeKHR srcComponentType_ = ComponentTypeKHR::eFloat16, + ComponentTypeKHR dstComponentType_ = ComponentTypeKHR::eFloat16, + uint32_t numRows_ = {}, + uint32_t numColumns_ = {}, + CooperativeVectorMatrixLayoutNV srcLayout_ = CooperativeVectorMatrixLayoutNV::eRowMajor, + size_t srcStride_ = {}, + CooperativeVectorMatrixLayoutNV dstLayout_ = CooperativeVectorMatrixLayoutNV::eRowMajor, + size_t dstStride_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcSize{ srcSize_ } + , srcData{ srcData_ } + , pDstSize{ pDstSize_ } + , dstData{ dstData_ } + , srcComponentType{ srcComponentType_ } + , dstComponentType{ dstComponentType_ } + , numRows{ numRows_ } + , numColumns{ numColumns_ } + , srcLayout{ srcLayout_ } + , srcStride{ srcStride_ } + , dstLayout{ dstLayout_ } + , dstStride{ dstStride_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV( ConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ConvertCooperativeVectorMatrixInfoNV( VkConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ConvertCooperativeVectorMatrixInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ConvertCooperativeVectorMatrixInfoNV & operator=( ConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ConvertCooperativeVectorMatrixInfoNV & operator=( VkConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcSize( size_t srcSize_ ) & VULKAN_HPP_NOEXCEPT + { + srcSize = srcSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcSize( size_t srcSize_ ) && VULKAN_HPP_NOEXCEPT + { + srcSize = srcSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcData( DeviceOrHostAddressConstKHR const & srcData_ ) & VULKAN_HPP_NOEXCEPT + { + srcData = srcData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcData( DeviceOrHostAddressConstKHR const & srcData_ ) && VULKAN_HPP_NOEXCEPT + { + srcData = srcData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setPDstSize( size_t * pDstSize_ ) & VULKAN_HPP_NOEXCEPT + { + pDstSize = pDstSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setPDstSize( size_t * pDstSize_ ) && VULKAN_HPP_NOEXCEPT + { + pDstSize = pDstSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstData( DeviceOrHostAddressKHR const & dstData_ ) & VULKAN_HPP_NOEXCEPT + { + dstData = dstData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstData( DeviceOrHostAddressKHR const & dstData_ ) && VULKAN_HPP_NOEXCEPT + { + dstData = dstData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcComponentType( ComponentTypeKHR srcComponentType_ ) & VULKAN_HPP_NOEXCEPT + { + srcComponentType = srcComponentType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcComponentType( ComponentTypeKHR srcComponentType_ ) && VULKAN_HPP_NOEXCEPT + { + srcComponentType = srcComponentType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstComponentType( ComponentTypeKHR dstComponentType_ ) & VULKAN_HPP_NOEXCEPT + { + dstComponentType = dstComponentType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstComponentType( ComponentTypeKHR dstComponentType_ ) && VULKAN_HPP_NOEXCEPT + { + dstComponentType = dstComponentType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setNumRows( uint32_t numRows_ ) & VULKAN_HPP_NOEXCEPT + { + numRows = numRows_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setNumRows( uint32_t numRows_ ) && VULKAN_HPP_NOEXCEPT + { + numRows = numRows_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setNumColumns( uint32_t numColumns_ ) & VULKAN_HPP_NOEXCEPT + { + numColumns = numColumns_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setNumColumns( uint32_t numColumns_ ) && VULKAN_HPP_NOEXCEPT + { + numColumns = numColumns_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcLayout( CooperativeVectorMatrixLayoutNV srcLayout_ ) & VULKAN_HPP_NOEXCEPT + { + srcLayout = srcLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcLayout( CooperativeVectorMatrixLayoutNV srcLayout_ ) && VULKAN_HPP_NOEXCEPT + { + srcLayout = srcLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcStride( size_t srcStride_ ) & VULKAN_HPP_NOEXCEPT + { + srcStride = srcStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcStride( size_t srcStride_ ) && VULKAN_HPP_NOEXCEPT + { + srcStride = srcStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstLayout( CooperativeVectorMatrixLayoutNV dstLayout_ ) & VULKAN_HPP_NOEXCEPT + { + dstLayout = dstLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstLayout( CooperativeVectorMatrixLayoutNV dstLayout_ ) && VULKAN_HPP_NOEXCEPT + { + dstLayout = dstLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstStride( size_t dstStride_ ) & VULKAN_HPP_NOEXCEPT + { + dstStride = dstStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstStride( size_t dstStride_ ) && VULKAN_HPP_NOEXCEPT + { + dstStride = dstStride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkConvertCooperativeVectorMatrixInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkConvertCooperativeVectorMatrixInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkConvertCooperativeVectorMatrixInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkConvertCooperativeVectorMatrixInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + srcSize, + srcData, + pDstSize, + dstData, + srcComponentType, + dstComponentType, + numRows, + numColumns, + srcLayout, + srcStride, + dstLayout, + dstStride ); + } +#endif + + public: + StructureType sType = StructureType::eConvertCooperativeVectorMatrixInfoNV; + const void * pNext = {}; + size_t srcSize = {}; + DeviceOrHostAddressConstKHR srcData = {}; + size_t * pDstSize = {}; + DeviceOrHostAddressKHR dstData = {}; + ComponentTypeKHR srcComponentType = ComponentTypeKHR::eFloat16; + ComponentTypeKHR dstComponentType = ComponentTypeKHR::eFloat16; + uint32_t numRows = {}; + uint32_t numColumns = {}; + CooperativeVectorMatrixLayoutNV srcLayout = CooperativeVectorMatrixLayoutNV::eRowMajor; + size_t srcStride = {}; + CooperativeVectorMatrixLayoutNV dstLayout = CooperativeVectorMatrixLayoutNV::eRowMajor; + size_t dstStride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ConvertCooperativeVectorMatrixInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = ConvertCooperativeVectorMatrixInfoNV; + }; + + // wrapper struct for struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixFlexibleDimensionsPropertiesNV.html + struct CooperativeMatrixFlexibleDimensionsPropertiesNV + { + using NativeType = VkCooperativeMatrixFlexibleDimensionsPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CooperativeMatrixFlexibleDimensionsPropertiesNV( uint32_t MGranularity_ = {}, + uint32_t NGranularity_ = {}, + uint32_t KGranularity_ = {}, + ComponentTypeKHR AType_ = ComponentTypeKHR::eFloat16, + ComponentTypeKHR BType_ = ComponentTypeKHR::eFloat16, + ComponentTypeKHR CType_ = ComponentTypeKHR::eFloat16, + ComponentTypeKHR ResultType_ = ComponentTypeKHR::eFloat16, + Bool32 saturatingAccumulation_ = {}, + ScopeKHR scope_ = ScopeKHR::eDevice, + uint32_t workgroupInvocations_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , MGranularity{ MGranularity_ } + , NGranularity{ NGranularity_ } + , KGranularity{ KGranularity_ } + , AType{ AType_ } + , BType{ BType_ } + , CType{ CType_ } + , ResultType{ ResultType_ } + , saturatingAccumulation{ saturatingAccumulation_ } + , scope{ scope_ } + , workgroupInvocations{ workgroupInvocations_ } + { + } + + VULKAN_HPP_CONSTEXPR + CooperativeMatrixFlexibleDimensionsPropertiesNV( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CooperativeMatrixFlexibleDimensionsPropertiesNV( VkCooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : CooperativeMatrixFlexibleDimensionsPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + CooperativeMatrixFlexibleDimensionsPropertiesNV & operator=( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CooperativeMatrixFlexibleDimensionsPropertiesNV & operator=( VkCooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, MGranularity, NGranularity, KGranularity, AType, BType, CType, ResultType, saturatingAccumulation, scope, workgroupInvocations ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CooperativeMatrixFlexibleDimensionsPropertiesNV const & ) const = default; +#else + bool operator==( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MGranularity == rhs.MGranularity ) && ( NGranularity == rhs.NGranularity ) && + ( KGranularity == rhs.KGranularity ) && ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) && + ( ResultType == rhs.ResultType ) && ( saturatingAccumulation == rhs.saturatingAccumulation ) && ( scope == rhs.scope ) && + ( workgroupInvocations == rhs.workgroupInvocations ); +# endif + } + + bool operator!=( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV; + void * pNext = {}; + uint32_t MGranularity = {}; + uint32_t NGranularity = {}; + uint32_t KGranularity = {}; + ComponentTypeKHR AType = ComponentTypeKHR::eFloat16; + ComponentTypeKHR BType = ComponentTypeKHR::eFloat16; + ComponentTypeKHR CType = ComponentTypeKHR::eFloat16; + ComponentTypeKHR ResultType = ComponentTypeKHR::eFloat16; + Bool32 saturatingAccumulation = {}; + ScopeKHR scope = ScopeKHR::eDevice; + uint32_t workgroupInvocations = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CooperativeMatrixFlexibleDimensionsPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = CooperativeMatrixFlexibleDimensionsPropertiesNV; + }; + + // wrapper struct for struct VkCooperativeMatrixPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixPropertiesKHR.html + struct CooperativeMatrixPropertiesKHR + { + using NativeType = VkCooperativeMatrixPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCooperativeMatrixPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesKHR( uint32_t MSize_ = {}, + uint32_t NSize_ = {}, + uint32_t KSize_ = {}, + ComponentTypeKHR AType_ = ComponentTypeKHR::eFloat16, + ComponentTypeKHR BType_ = ComponentTypeKHR::eFloat16, + ComponentTypeKHR CType_ = ComponentTypeKHR::eFloat16, + ComponentTypeKHR ResultType_ = ComponentTypeKHR::eFloat16, + Bool32 saturatingAccumulation_ = {}, + ScopeKHR scope_ = ScopeKHR::eDevice, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , MSize{ MSize_ } + , NSize{ NSize_ } + , KSize{ KSize_ } + , AType{ AType_ } + , BType{ BType_ } + , CType{ CType_ } + , ResultType{ ResultType_ } + , saturatingAccumulation{ saturatingAccumulation_ } + , scope{ scope_ } + { + } + + VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CooperativeMatrixPropertiesKHR( VkCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : CooperativeMatrixPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + CooperativeMatrixPropertiesKHR & operator=( CooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CooperativeMatrixPropertiesKHR & operator=( VkCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkCooperativeMatrixPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCooperativeMatrixPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCooperativeMatrixPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCooperativeMatrixPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, ResultType, saturatingAccumulation, scope ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CooperativeMatrixPropertiesKHR const & ) const = default; +#else + bool operator==( CooperativeMatrixPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) && ( KSize == rhs.KSize ) && + ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) && ( ResultType == rhs.ResultType ) && + ( saturatingAccumulation == rhs.saturatingAccumulation ) && ( scope == rhs.scope ); +# endif + } + + bool operator!=( CooperativeMatrixPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCooperativeMatrixPropertiesKHR; + void * pNext = {}; + uint32_t MSize = {}; + uint32_t NSize = {}; + uint32_t KSize = {}; + ComponentTypeKHR AType = ComponentTypeKHR::eFloat16; + ComponentTypeKHR BType = ComponentTypeKHR::eFloat16; + ComponentTypeKHR CType = ComponentTypeKHR::eFloat16; + ComponentTypeKHR ResultType = ComponentTypeKHR::eFloat16; + Bool32 saturatingAccumulation = {}; + ScopeKHR scope = ScopeKHR::eDevice; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CooperativeMatrixPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = CooperativeMatrixPropertiesKHR; + }; + + // wrapper struct for struct VkCooperativeMatrixPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixPropertiesNV.html + struct CooperativeMatrixPropertiesNV + { + using NativeType = VkCooperativeMatrixPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCooperativeMatrixPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = {}, + uint32_t NSize_ = {}, + uint32_t KSize_ = {}, + ComponentTypeNV AType_ = {}, + ComponentTypeNV BType_ = {}, + ComponentTypeNV CType_ = {}, + ComponentTypeNV DType_ = {}, + ScopeNV scope_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , MSize{ MSize_ } + , NSize{ NSize_ } + , KSize{ KSize_ } + , AType{ AType_ } + , BType{ BType_ } + , CType{ CType_ } + , DType{ DType_ } + , scope{ scope_ } + { + } + + VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : CooperativeMatrixPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + CooperativeMatrixPropertiesNV & operator=( CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CooperativeMatrixPropertiesNV & operator=( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCooperativeMatrixPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCooperativeMatrixPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, DType, scope ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CooperativeMatrixPropertiesNV const & ) const = default; +#else + bool operator==( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) && ( KSize == rhs.KSize ) && + ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) && ( DType == rhs.DType ) && ( scope == rhs.scope ); +# endif + } + + bool operator!=( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCooperativeMatrixPropertiesNV; + void * pNext = {}; + uint32_t MSize = {}; + uint32_t NSize = {}; + uint32_t KSize = {}; + ComponentTypeNV AType = {}; + ComponentTypeNV BType = {}; + ComponentTypeNV CType = {}; + ComponentTypeNV DType = {}; + ScopeNV scope = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CooperativeMatrixPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = CooperativeMatrixPropertiesNV; + }; + + // wrapper struct for struct VkCooperativeVectorPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeVectorPropertiesNV.html + struct CooperativeVectorPropertiesNV + { + using NativeType = VkCooperativeVectorPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCooperativeVectorPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CooperativeVectorPropertiesNV( ComponentTypeKHR inputType_ = ComponentTypeKHR::eFloat16, + ComponentTypeKHR inputInterpretation_ = ComponentTypeKHR::eFloat16, + ComponentTypeKHR matrixInterpretation_ = ComponentTypeKHR::eFloat16, + ComponentTypeKHR biasInterpretation_ = ComponentTypeKHR::eFloat16, + ComponentTypeKHR resultType_ = ComponentTypeKHR::eFloat16, + Bool32 transpose_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , inputType{ inputType_ } + , inputInterpretation{ inputInterpretation_ } + , matrixInterpretation{ matrixInterpretation_ } + , biasInterpretation{ biasInterpretation_ } + , resultType{ resultType_ } + , transpose{ transpose_ } + { + } + + VULKAN_HPP_CONSTEXPR CooperativeVectorPropertiesNV( CooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CooperativeVectorPropertiesNV( VkCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : CooperativeVectorPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + CooperativeVectorPropertiesNV & operator=( CooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CooperativeVectorPropertiesNV & operator=( VkCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setInputType( ComponentTypeKHR inputType_ ) & VULKAN_HPP_NOEXCEPT + { + inputType = inputType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setInputType( ComponentTypeKHR inputType_ ) && VULKAN_HPP_NOEXCEPT + { + inputType = inputType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setInputInterpretation( ComponentTypeKHR inputInterpretation_ ) & VULKAN_HPP_NOEXCEPT + { + inputInterpretation = inputInterpretation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setInputInterpretation( ComponentTypeKHR inputInterpretation_ ) && VULKAN_HPP_NOEXCEPT + { + inputInterpretation = inputInterpretation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setMatrixInterpretation( ComponentTypeKHR matrixInterpretation_ ) & VULKAN_HPP_NOEXCEPT + { + matrixInterpretation = matrixInterpretation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setMatrixInterpretation( ComponentTypeKHR matrixInterpretation_ ) && VULKAN_HPP_NOEXCEPT + { + matrixInterpretation = matrixInterpretation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setBiasInterpretation( ComponentTypeKHR biasInterpretation_ ) & VULKAN_HPP_NOEXCEPT + { + biasInterpretation = biasInterpretation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setBiasInterpretation( ComponentTypeKHR biasInterpretation_ ) && VULKAN_HPP_NOEXCEPT + { + biasInterpretation = biasInterpretation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setResultType( ComponentTypeKHR resultType_ ) & VULKAN_HPP_NOEXCEPT + { + resultType = resultType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setResultType( ComponentTypeKHR resultType_ ) && VULKAN_HPP_NOEXCEPT + { + resultType = resultType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setTranspose( Bool32 transpose_ ) & VULKAN_HPP_NOEXCEPT + { + transpose = transpose_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setTranspose( Bool32 transpose_ ) && VULKAN_HPP_NOEXCEPT + { + transpose = transpose_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCooperativeVectorPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCooperativeVectorPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCooperativeVectorPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCooperativeVectorPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, inputType, inputInterpretation, matrixInterpretation, biasInterpretation, resultType, transpose ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CooperativeVectorPropertiesNV const & ) const = default; +#else + bool operator==( CooperativeVectorPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inputType == rhs.inputType ) && ( inputInterpretation == rhs.inputInterpretation ) && + ( matrixInterpretation == rhs.matrixInterpretation ) && ( biasInterpretation == rhs.biasInterpretation ) && ( resultType == rhs.resultType ) && + ( transpose == rhs.transpose ); +# endif + } + + bool operator!=( CooperativeVectorPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCooperativeVectorPropertiesNV; + void * pNext = {}; + ComponentTypeKHR inputType = ComponentTypeKHR::eFloat16; + ComponentTypeKHR inputInterpretation = ComponentTypeKHR::eFloat16; + ComponentTypeKHR matrixInterpretation = ComponentTypeKHR::eFloat16; + ComponentTypeKHR biasInterpretation = ComponentTypeKHR::eFloat16; + ComponentTypeKHR resultType = ComponentTypeKHR::eFloat16; + Bool32 transpose = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CooperativeVectorPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = CooperativeVectorPropertiesNV; + }; + + // wrapper struct for struct VkCopyAccelerationStructureInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyAccelerationStructureInfoKHR.html + struct CopyAccelerationStructureInfoKHR + { + using NativeType = VkCopyAccelerationStructureInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyAccelerationStructureInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyAccelerationStructureInfoKHR( AccelerationStructureKHR src_ = {}, + AccelerationStructureKHR dst_ = {}, + CopyAccelerationStructureModeKHR mode_ = CopyAccelerationStructureModeKHR::eClone, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , src{ src_ } + , dst{ dst_ } + , mode{ mode_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyAccelerationStructureInfoKHR( CopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyAccelerationStructureInfoKHR( VkCopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyAccelerationStructureInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + CopyAccelerationStructureInfoKHR & operator=( CopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyAccelerationStructureInfoKHR & operator=( VkCopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setSrc( AccelerationStructureKHR src_ ) & VULKAN_HPP_NOEXCEPT + { + src = src_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setSrc( AccelerationStructureKHR src_ ) && VULKAN_HPP_NOEXCEPT + { + src = src_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setDst( AccelerationStructureKHR dst_ ) & VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setDst( AccelerationStructureKHR dst_ ) && VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setMode( CopyAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setMode( CopyAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyAccelerationStructureInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyAccelerationStructureInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyAccelerationStructureInfoKHR const & ) const = default; +#else + bool operator==( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) && ( mode == rhs.mode ); +# endif + } + + bool operator!=( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyAccelerationStructureInfoKHR; + const void * pNext = {}; + AccelerationStructureKHR src = {}; + AccelerationStructureKHR dst = {}; + CopyAccelerationStructureModeKHR mode = CopyAccelerationStructureModeKHR::eClone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyAccelerationStructureInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = CopyAccelerationStructureInfoKHR; + }; + + // wrapper struct for struct VkCopyAccelerationStructureToMemoryInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html + struct CopyAccelerationStructureToMemoryInfoKHR + { + using NativeType = VkCopyAccelerationStructureToMemoryInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR( AccelerationStructureKHR src_ = {}, + DeviceOrHostAddressKHR dst_ = {}, + CopyAccelerationStructureModeKHR mode_ = CopyAccelerationStructureModeKHR::eClone, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , src{ src_ } + , dst{ dst_ } + , mode{ mode_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR( CopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyAccelerationStructureToMemoryInfoKHR( VkCopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyAccelerationStructureToMemoryInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + CopyAccelerationStructureToMemoryInfoKHR & operator=( CopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyAccelerationStructureToMemoryInfoKHR & operator=( VkCopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setSrc( AccelerationStructureKHR src_ ) & VULKAN_HPP_NOEXCEPT + { + src = src_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setSrc( AccelerationStructureKHR src_ ) && VULKAN_HPP_NOEXCEPT + { + src = src_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setDst( DeviceOrHostAddressKHR const & dst_ ) & VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setDst( DeviceOrHostAddressKHR const & dst_ ) && VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setMode( CopyAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setMode( CopyAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyAccelerationStructureToMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyAccelerationStructureToMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyAccelerationStructureToMemoryInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyAccelerationStructureToMemoryInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } +#endif + + public: + StructureType sType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR; + const void * pNext = {}; + AccelerationStructureKHR src = {}; + DeviceOrHostAddressKHR dst = {}; + CopyAccelerationStructureModeKHR mode = CopyAccelerationStructureModeKHR::eClone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyAccelerationStructureToMemoryInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = CopyAccelerationStructureToMemoryInfoKHR; + }; + + // wrapper struct for struct VkCopyBufferInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyBufferInfo2.html + struct CopyBufferInfo2 + { + using NativeType = VkCopyBufferInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyBufferInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyBufferInfo2( Buffer srcBuffer_ = {}, + Buffer dstBuffer_ = {}, + uint32_t regionCount_ = {}, + const BufferCopy2 * pRegions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcBuffer{ srcBuffer_ } + , dstBuffer{ dstBuffer_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyBufferInfo2( CopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyBufferInfo2( VkCopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : CopyBufferInfo2( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyBufferInfo2( Buffer srcBuffer_, Buffer dstBuffer_, ArrayProxyNoTemporaries const & regions_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), srcBuffer( srcBuffer_ ), dstBuffer( dstBuffer_ ), regionCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CopyBufferInfo2 & operator=( CopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyBufferInfo2 & operator=( VkCopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setSrcBuffer( Buffer srcBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + srcBuffer = srcBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setSrcBuffer( Buffer srcBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + srcBuffer = srcBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setDstBuffer( Buffer dstBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + dstBuffer = dstBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setDstBuffer( Buffer dstBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + dstBuffer = dstBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setPRegions( const BufferCopy2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setPRegions( const BufferCopy2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyBufferInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyBufferInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyBufferInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyBufferInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyBufferInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcBuffer, dstBuffer, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyBufferInfo2 const & ) const = default; +#else + bool operator==( CopyBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && ( dstBuffer == rhs.dstBuffer ) && + ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( CopyBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyBufferInfo2; + const void * pNext = {}; + Buffer srcBuffer = {}; + Buffer dstBuffer = {}; + uint32_t regionCount = {}; + const BufferCopy2 * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyBufferInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = CopyBufferInfo2; + }; + + using CopyBufferInfo2KHR = CopyBufferInfo2; + + // wrapper struct for struct VkCopyBufferToImageInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyBufferToImageInfo2.html + struct CopyBufferToImageInfo2 + { + using NativeType = VkCopyBufferToImageInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyBufferToImageInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyBufferToImageInfo2( Buffer srcBuffer_ = {}, + Image dstImage_ = {}, + ImageLayout dstImageLayout_ = ImageLayout::eUndefined, + uint32_t regionCount_ = {}, + const BufferImageCopy2 * pRegions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcBuffer{ srcBuffer_ } + , dstImage{ dstImage_ } + , dstImageLayout{ dstImageLayout_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyBufferToImageInfo2( CopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyBufferToImageInfo2( VkCopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyBufferToImageInfo2( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyBufferToImageInfo2( Buffer srcBuffer_, + Image dstImage_, + ImageLayout dstImageLayout_, + ArrayProxyNoTemporaries const & regions_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , srcBuffer( srcBuffer_ ) + , dstImage( dstImage_ ) + , dstImageLayout( dstImageLayout_ ) + , regionCount( static_cast( regions_.size() ) ) + , pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CopyBufferToImageInfo2 & operator=( CopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyBufferToImageInfo2 & operator=( VkCopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setSrcBuffer( Buffer srcBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + srcBuffer = srcBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setSrcBuffer( Buffer srcBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + srcBuffer = srcBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setPRegions( const BufferImageCopy2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setPRegions( const BufferImageCopy2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyBufferToImageInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyBufferToImageInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyBufferToImageInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyBufferToImageInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyBufferToImageInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyBufferToImageInfo2 const & ) const = default; +#else + bool operator==( CopyBufferToImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && ( dstImage == rhs.dstImage ) && + ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( CopyBufferToImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyBufferToImageInfo2; + const void * pNext = {}; + Buffer srcBuffer = {}; + Image dstImage = {}; + ImageLayout dstImageLayout = ImageLayout::eUndefined; + uint32_t regionCount = {}; + const BufferImageCopy2 * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyBufferToImageInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = CopyBufferToImageInfo2; + }; + + using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2; + + // wrapper struct for struct VkCopyCommandTransformInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyCommandTransformInfoQCOM.html + struct CopyCommandTransformInfoQCOM + { + using NativeType = VkCopyCommandTransformInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyCommandTransformInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyCommandTransformInfoQCOM( SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , transform{ transform_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyCommandTransformInfoQCOM( CopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyCommandTransformInfoQCOM( VkCopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyCommandTransformInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + CopyCommandTransformInfoQCOM & operator=( CopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyCommandTransformInfoQCOM & operator=( VkCopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM & setTransform( SurfaceTransformFlagBitsKHR transform_ ) & VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM && setTransform( SurfaceTransformFlagBitsKHR transform_ ) && VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyCommandTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyCommandTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyCommandTransformInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyCommandTransformInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transform ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyCommandTransformInfoQCOM const & ) const = default; +#else + bool operator==( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ); +# endif + } + + bool operator!=( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyCommandTransformInfoQCOM; + const void * pNext = {}; + SurfaceTransformFlagBitsKHR transform = SurfaceTransformFlagBitsKHR::eIdentity; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyCommandTransformInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = CopyCommandTransformInfoQCOM; + }; + + // wrapper struct for struct VkCopyDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyDescriptorSet.html + struct CopyDescriptorSet + { + using NativeType = VkCopyDescriptorSet; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyDescriptorSet; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyDescriptorSet( DescriptorSet srcSet_ = {}, + uint32_t srcBinding_ = {}, + uint32_t srcArrayElement_ = {}, + DescriptorSet dstSet_ = {}, + uint32_t dstBinding_ = {}, + uint32_t dstArrayElement_ = {}, + uint32_t descriptorCount_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcSet{ srcSet_ } + , srcBinding{ srcBinding_ } + , srcArrayElement{ srcArrayElement_ } + , dstSet{ dstSet_ } + , dstBinding{ dstBinding_ } + , dstArrayElement{ dstArrayElement_ } + , descriptorCount{ descriptorCount_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyDescriptorSet( CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT : CopyDescriptorSet( *reinterpret_cast( &rhs ) ) {} + + CopyDescriptorSet & operator=( CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyDescriptorSet & operator=( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setSrcSet( DescriptorSet srcSet_ ) & VULKAN_HPP_NOEXCEPT + { + srcSet = srcSet_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setSrcSet( DescriptorSet srcSet_ ) && VULKAN_HPP_NOEXCEPT + { + srcSet = srcSet_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setSrcBinding( uint32_t srcBinding_ ) & VULKAN_HPP_NOEXCEPT + { + srcBinding = srcBinding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setSrcBinding( uint32_t srcBinding_ ) && VULKAN_HPP_NOEXCEPT + { + srcBinding = srcBinding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setSrcArrayElement( uint32_t srcArrayElement_ ) & VULKAN_HPP_NOEXCEPT + { + srcArrayElement = srcArrayElement_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setSrcArrayElement( uint32_t srcArrayElement_ ) && VULKAN_HPP_NOEXCEPT + { + srcArrayElement = srcArrayElement_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDstSet( DescriptorSet dstSet_ ) & VULKAN_HPP_NOEXCEPT + { + dstSet = dstSet_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDstSet( DescriptorSet dstSet_ ) && VULKAN_HPP_NOEXCEPT + { + dstSet = dstSet_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDstBinding( uint32_t dstBinding_ ) & VULKAN_HPP_NOEXCEPT + { + dstBinding = dstBinding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDstBinding( uint32_t dstBinding_ ) && VULKAN_HPP_NOEXCEPT + { + dstBinding = dstBinding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDstArrayElement( uint32_t dstArrayElement_ ) & VULKAN_HPP_NOEXCEPT + { + dstArrayElement = dstArrayElement_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDstArrayElement( uint32_t dstArrayElement_ ) && VULKAN_HPP_NOEXCEPT + { + dstArrayElement = dstArrayElement_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorCount = descriptorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorCount = descriptorCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyDescriptorSet const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyDescriptorSet &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyDescriptorSet const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyDescriptorSet *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcSet, srcBinding, srcArrayElement, dstSet, dstBinding, dstArrayElement, descriptorCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyDescriptorSet const & ) const = default; +#else + bool operator==( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSet == rhs.srcSet ) && ( srcBinding == rhs.srcBinding ) && + ( srcArrayElement == rhs.srcArrayElement ) && ( dstSet == rhs.dstSet ) && ( dstBinding == rhs.dstBinding ) && + ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount ); +# endif + } + + bool operator!=( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyDescriptorSet; + const void * pNext = {}; + DescriptorSet srcSet = {}; + uint32_t srcBinding = {}; + uint32_t srcArrayElement = {}; + DescriptorSet dstSet = {}; + uint32_t dstBinding = {}; + uint32_t dstArrayElement = {}; + uint32_t descriptorCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyDescriptorSet; + }; +#endif + + template <> + struct CppType + { + using Type = CopyDescriptorSet; + }; + + // wrapper struct for struct VkImageCopy2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCopy2.html + struct ImageCopy2 + { + using NativeType = VkImageCopy2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCopy2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageCopy2( ImageSubresourceLayers srcSubresource_ = {}, + Offset3D srcOffset_ = {}, + ImageSubresourceLayers dstSubresource_ = {}, + Offset3D dstOffset_ = {}, + Extent3D extent_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcSubresource{ srcSubresource_ } + , srcOffset{ srcOffset_ } + , dstSubresource{ dstSubresource_ } + , dstOffset{ dstOffset_ } + , extent{ extent_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageCopy2( ImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageCopy2( VkImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageCopy2( *reinterpret_cast( &rhs ) ) {} + + ImageCopy2 & operator=( ImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageCopy2 & operator=( VkImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setSrcOffset( Offset3D const & srcOffset_ ) & VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setSrcOffset( Offset3D const & srcOffset_ ) && VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setDstOffset( Offset3D const & dstOffset_ ) & VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setDstOffset( Offset3D const & dstOffset_ ) && VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageCopy2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCopy2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCopy2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageCopy2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageCopy2 const & ) const = default; +#else + bool operator==( ImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && + ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); +# endif + } + + bool operator!=( ImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageCopy2; + const void * pNext = {}; + ImageSubresourceLayers srcSubresource = {}; + Offset3D srcOffset = {}; + ImageSubresourceLayers dstSubresource = {}; + Offset3D dstOffset = {}; + Extent3D extent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageCopy2; + }; +#endif + + template <> + struct CppType + { + using Type = ImageCopy2; + }; + + using ImageCopy2KHR = ImageCopy2; + + // wrapper struct for struct VkCopyImageInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageInfo2.html + struct CopyImageInfo2 + { + using NativeType = VkCopyImageInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyImageInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyImageInfo2( Image srcImage_ = {}, + ImageLayout srcImageLayout_ = ImageLayout::eUndefined, + Image dstImage_ = {}, + ImageLayout dstImageLayout_ = ImageLayout::eUndefined, + uint32_t regionCount_ = {}, + const ImageCopy2 * pRegions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcImage{ srcImage_ } + , srcImageLayout{ srcImageLayout_ } + , dstImage{ dstImage_ } + , dstImageLayout{ dstImageLayout_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyImageInfo2( CopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyImageInfo2( VkCopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : CopyImageInfo2( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyImageInfo2( Image srcImage_, + ImageLayout srcImageLayout_, + Image dstImage_, + ImageLayout dstImageLayout_, + ArrayProxyNoTemporaries const & regions_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , srcImage( srcImage_ ) + , srcImageLayout( srcImageLayout_ ) + , dstImage( dstImage_ ) + , dstImageLayout( dstImageLayout_ ) + , regionCount( static_cast( regions_.size() ) ) + , pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CopyImageInfo2 & operator=( CopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyImageInfo2 & operator=( VkCopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setPRegions( const ImageCopy2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setPRegions( const ImageCopy2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyImageInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyImageInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyImageInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyImageInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyImageInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyImageInfo2 const & ) const = default; +#else + bool operator==( CopyImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) && + ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( CopyImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyImageInfo2; + const void * pNext = {}; + Image srcImage = {}; + ImageLayout srcImageLayout = ImageLayout::eUndefined; + Image dstImage = {}; + ImageLayout dstImageLayout = ImageLayout::eUndefined; + uint32_t regionCount = {}; + const ImageCopy2 * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyImageInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = CopyImageInfo2; + }; + + using CopyImageInfo2KHR = CopyImageInfo2; + + // wrapper struct for struct VkCopyImageToBufferInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageToBufferInfo2.html + struct CopyImageToBufferInfo2 + { + using NativeType = VkCopyImageToBufferInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyImageToBufferInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyImageToBufferInfo2( Image srcImage_ = {}, + ImageLayout srcImageLayout_ = ImageLayout::eUndefined, + Buffer dstBuffer_ = {}, + uint32_t regionCount_ = {}, + const BufferImageCopy2 * pRegions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcImage{ srcImage_ } + , srcImageLayout{ srcImageLayout_ } + , dstBuffer{ dstBuffer_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyImageToBufferInfo2( CopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyImageToBufferInfo2( VkCopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyImageToBufferInfo2( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyImageToBufferInfo2( Image srcImage_, + ImageLayout srcImageLayout_, + Buffer dstBuffer_, + ArrayProxyNoTemporaries const & regions_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , srcImage( srcImage_ ) + , srcImageLayout( srcImageLayout_ ) + , dstBuffer( dstBuffer_ ) + , regionCount( static_cast( regions_.size() ) ) + , pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CopyImageToBufferInfo2 & operator=( CopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyImageToBufferInfo2 & operator=( VkCopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setDstBuffer( Buffer dstBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + dstBuffer = dstBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setDstBuffer( Buffer dstBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + dstBuffer = dstBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setPRegions( const BufferImageCopy2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setPRegions( const BufferImageCopy2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyImageToBufferInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyImageToBufferInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyImageToBufferInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyImageToBufferInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyImageToBufferInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyImageToBufferInfo2 const & ) const = default; +#else + bool operator==( CopyImageToBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) && + ( dstBuffer == rhs.dstBuffer ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( CopyImageToBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyImageToBufferInfo2; + const void * pNext = {}; + Image srcImage = {}; + ImageLayout srcImageLayout = ImageLayout::eUndefined; + Buffer dstBuffer = {}; + uint32_t regionCount = {}; + const BufferImageCopy2 * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyImageToBufferInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = CopyImageToBufferInfo2; + }; + + using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2; + + // wrapper struct for struct VkCopyImageToImageInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageToImageInfo.html + struct CopyImageToImageInfo + { + using NativeType = VkCopyImageToImageInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyImageToImageInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyImageToImageInfo( HostImageCopyFlags flags_ = {}, + Image srcImage_ = {}, + ImageLayout srcImageLayout_ = ImageLayout::eUndefined, + Image dstImage_ = {}, + ImageLayout dstImageLayout_ = ImageLayout::eUndefined, + uint32_t regionCount_ = {}, + const ImageCopy2 * pRegions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , srcImage{ srcImage_ } + , srcImageLayout{ srcImageLayout_ } + , dstImage{ dstImage_ } + , dstImageLayout{ dstImageLayout_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyImageToImageInfo( CopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyImageToImageInfo( VkCopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyImageToImageInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyImageToImageInfo( HostImageCopyFlags flags_, + Image srcImage_, + ImageLayout srcImageLayout_, + Image dstImage_, + ImageLayout dstImageLayout_, + ArrayProxyNoTemporaries const & regions_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , srcImage( srcImage_ ) + , srcImageLayout( srcImageLayout_ ) + , dstImage( dstImage_ ) + , dstImageLayout( dstImageLayout_ ) + , regionCount( static_cast( regions_.size() ) ) + , pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CopyImageToImageInfo & operator=( CopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyImageToImageInfo & operator=( VkCopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setFlags( HostImageCopyFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setFlags( HostImageCopyFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setPRegions( const ImageCopy2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setPRegions( const ImageCopy2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyImageToImageInfo & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyImageToImageInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyImageToImageInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyImageToImageInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyImageToImageInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyImageToImageInfo const & ) const = default; +#else + bool operator==( CopyImageToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcImage == rhs.srcImage ) && + ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && + ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( CopyImageToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyImageToImageInfo; + const void * pNext = {}; + HostImageCopyFlags flags = {}; + Image srcImage = {}; + ImageLayout srcImageLayout = ImageLayout::eUndefined; + Image dstImage = {}; + ImageLayout dstImageLayout = ImageLayout::eUndefined; + uint32_t regionCount = {}; + const ImageCopy2 * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyImageToImageInfo; + }; +#endif + + template <> + struct CppType + { + using Type = CopyImageToImageInfo; + }; + + using CopyImageToImageInfoEXT = CopyImageToImageInfo; + + // wrapper struct for struct VkImageToMemoryCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageToMemoryCopy.html + struct ImageToMemoryCopy + { + using NativeType = VkImageToMemoryCopy; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageToMemoryCopy; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageToMemoryCopy( void * pHostPointer_ = {}, + uint32_t memoryRowLength_ = {}, + uint32_t memoryImageHeight_ = {}, + ImageSubresourceLayers imageSubresource_ = {}, + Offset3D imageOffset_ = {}, + Extent3D imageExtent_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pHostPointer{ pHostPointer_ } + , memoryRowLength{ memoryRowLength_ } + , memoryImageHeight{ memoryImageHeight_ } + , imageSubresource{ imageSubresource_ } + , imageOffset{ imageOffset_ } + , imageExtent{ imageExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageToMemoryCopy( ImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageToMemoryCopy( VkImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT : ImageToMemoryCopy( *reinterpret_cast( &rhs ) ) {} + + ImageToMemoryCopy & operator=( ImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageToMemoryCopy & operator=( VkImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setPHostPointer( void * pHostPointer_ ) & VULKAN_HPP_NOEXCEPT + { + pHostPointer = pHostPointer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setPHostPointer( void * pHostPointer_ ) && VULKAN_HPP_NOEXCEPT + { + pHostPointer = pHostPointer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setMemoryRowLength( uint32_t memoryRowLength_ ) & VULKAN_HPP_NOEXCEPT + { + memoryRowLength = memoryRowLength_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setMemoryRowLength( uint32_t memoryRowLength_ ) && VULKAN_HPP_NOEXCEPT + { + memoryRowLength = memoryRowLength_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setMemoryImageHeight( uint32_t memoryImageHeight_ ) & VULKAN_HPP_NOEXCEPT + { + memoryImageHeight = memoryImageHeight_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setMemoryImageHeight( uint32_t memoryImageHeight_ ) && VULKAN_HPP_NOEXCEPT + { + memoryImageHeight = memoryImageHeight_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageToMemoryCopy const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageToMemoryCopy &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageToMemoryCopy const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageToMemoryCopy *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pHostPointer, memoryRowLength, memoryImageHeight, imageSubresource, imageOffset, imageExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageToMemoryCopy const & ) const = default; +#else + bool operator==( ImageToMemoryCopy const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pHostPointer == rhs.pHostPointer ) && ( memoryRowLength == rhs.memoryRowLength ) && + ( memoryImageHeight == rhs.memoryImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && + ( imageExtent == rhs.imageExtent ); +# endif + } + + bool operator!=( ImageToMemoryCopy const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageToMemoryCopy; + const void * pNext = {}; + void * pHostPointer = {}; + uint32_t memoryRowLength = {}; + uint32_t memoryImageHeight = {}; + ImageSubresourceLayers imageSubresource = {}; + Offset3D imageOffset = {}; + Extent3D imageExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageToMemoryCopy; + }; +#endif + + template <> + struct CppType + { + using Type = ImageToMemoryCopy; + }; + + using ImageToMemoryCopyEXT = ImageToMemoryCopy; + + // wrapper struct for struct VkCopyImageToMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageToMemoryInfo.html + struct CopyImageToMemoryInfo + { + using NativeType = VkCopyImageToMemoryInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyImageToMemoryInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyImageToMemoryInfo( HostImageCopyFlags flags_ = {}, + Image srcImage_ = {}, + ImageLayout srcImageLayout_ = ImageLayout::eUndefined, + uint32_t regionCount_ = {}, + const ImageToMemoryCopy * pRegions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , srcImage{ srcImage_ } + , srcImageLayout{ srcImageLayout_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyImageToMemoryInfo( CopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyImageToMemoryInfo( VkCopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyImageToMemoryInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyImageToMemoryInfo( HostImageCopyFlags flags_, + Image srcImage_, + ImageLayout srcImageLayout_, + ArrayProxyNoTemporaries const & regions_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , srcImage( srcImage_ ) + , srcImageLayout( srcImageLayout_ ) + , regionCount( static_cast( regions_.size() ) ) + , pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CopyImageToMemoryInfo & operator=( CopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyImageToMemoryInfo & operator=( VkCopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setFlags( HostImageCopyFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setFlags( HostImageCopyFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setPRegions( const ImageToMemoryCopy * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setPRegions( const ImageToMemoryCopy * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyImageToMemoryInfo & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyImageToMemoryInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyImageToMemoryInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyImageToMemoryInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyImageToMemoryInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, srcImage, srcImageLayout, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyImageToMemoryInfo const & ) const = default; +#else + bool operator==( CopyImageToMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcImage == rhs.srcImage ) && + ( srcImageLayout == rhs.srcImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( CopyImageToMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyImageToMemoryInfo; + const void * pNext = {}; + HostImageCopyFlags flags = {}; + Image srcImage = {}; + ImageLayout srcImageLayout = ImageLayout::eUndefined; + uint32_t regionCount = {}; + const ImageToMemoryCopy * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyImageToMemoryInfo; + }; +#endif + + template <> + struct CppType + { + using Type = CopyImageToMemoryInfo; + }; + + using CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo; + + // wrapper struct for struct VkCopyMemoryIndirectCommandKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryIndirectCommandKHR.html + struct CopyMemoryIndirectCommandKHR + { + using NativeType = VkCopyMemoryIndirectCommandKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + CopyMemoryIndirectCommandKHR( DeviceAddress srcAddress_ = {}, DeviceAddress dstAddress_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT + : srcAddress{ srcAddress_ } + , dstAddress{ dstAddress_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyMemoryIndirectCommandKHR( CopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyMemoryIndirectCommandKHR( VkCopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyMemoryIndirectCommandKHR( *reinterpret_cast( &rhs ) ) + { + } + + CopyMemoryIndirectCommandKHR & operator=( CopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyMemoryIndirectCommandKHR & operator=( VkCopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT + { + srcAddress = srcAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT + { + srcAddress = srcAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setDstAddress( DeviceAddress dstAddress_ ) & VULKAN_HPP_NOEXCEPT + { + dstAddress = dstAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR && setDstAddress( DeviceAddress dstAddress_ ) && VULKAN_HPP_NOEXCEPT + { + dstAddress = dstAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyMemoryIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryIndirectCommandKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyMemoryIndirectCommandKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcAddress, dstAddress, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyMemoryIndirectCommandKHR const & ) const = default; +#else + bool operator==( CopyMemoryIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( srcAddress == rhs.srcAddress ) && ( dstAddress == rhs.dstAddress ) && ( size == rhs.size ); +# endif + } + + bool operator!=( CopyMemoryIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress srcAddress = {}; + DeviceAddress dstAddress = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyMemoryIndirectCommandKHR; + }; +#endif + using CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR; + + // wrapper struct for struct VkStridedDeviceAddressRangeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressRangeKHR.html + struct StridedDeviceAddressRangeKHR + { + using NativeType = VkStridedDeviceAddressRangeKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( DeviceAddress address_ = {}, DeviceSize size_ = {}, DeviceSize stride_ = {} ) VULKAN_HPP_NOEXCEPT + : address{ address_ } + , size{ size_ } + , stride{ stride_ } + { + } + + VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + StridedDeviceAddressRangeKHR( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : StridedDeviceAddressRangeKHR( *reinterpret_cast( &rhs ) ) + { + } + + StridedDeviceAddressRangeKHR & operator=( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + StridedDeviceAddressRangeKHR & operator=( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT + { + address = address_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT + { + address = address_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setStride( DeviceSize stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setStride( DeviceSize stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkStridedDeviceAddressRangeKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressRangeKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressRangeKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkStridedDeviceAddressRangeKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( address, size, stride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( StridedDeviceAddressRangeKHR const & ) const = default; +#else + bool operator==( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( address == rhs.address ) && ( size == rhs.size ) && ( stride == rhs.stride ); +# endif + } + + bool operator!=( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress address = {}; + DeviceSize size = {}; + DeviceSize stride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = StridedDeviceAddressRangeKHR; + }; +#endif + + // wrapper struct for struct VkCopyMemoryIndirectInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryIndirectInfoKHR.html + struct CopyMemoryIndirectInfoKHR + { + using NativeType = VkCopyMemoryIndirectInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryIndirectInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyMemoryIndirectInfoKHR( AddressCopyFlagsKHR srcCopyFlags_ = {}, + AddressCopyFlagsKHR dstCopyFlags_ = {}, + uint32_t copyCount_ = {}, + StridedDeviceAddressRangeKHR copyAddressRange_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcCopyFlags{ srcCopyFlags_ } + , dstCopyFlags{ dstCopyFlags_ } + , copyCount{ copyCount_ } + , copyAddressRange{ copyAddressRange_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyMemoryIndirectInfoKHR( CopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyMemoryIndirectInfoKHR( VkCopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyMemoryIndirectInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + CopyMemoryIndirectInfoKHR & operator=( CopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyMemoryIndirectInfoKHR & operator=( VkCopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) & VULKAN_HPP_NOEXCEPT + { + srcCopyFlags = srcCopyFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) && VULKAN_HPP_NOEXCEPT + { + srcCopyFlags = srcCopyFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setDstCopyFlags( AddressCopyFlagsKHR dstCopyFlags_ ) & VULKAN_HPP_NOEXCEPT + { + dstCopyFlags = dstCopyFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setDstCopyFlags( AddressCopyFlagsKHR dstCopyFlags_ ) && VULKAN_HPP_NOEXCEPT + { + dstCopyFlags = dstCopyFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setCopyCount( uint32_t copyCount_ ) & VULKAN_HPP_NOEXCEPT + { + copyCount = copyCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setCopyCount( uint32_t copyCount_ ) && VULKAN_HPP_NOEXCEPT + { + copyCount = copyCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) & VULKAN_HPP_NOEXCEPT + { + copyAddressRange = copyAddressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) && VULKAN_HPP_NOEXCEPT + { + copyAddressRange = copyAddressRange_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyMemoryIndirectInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryIndirectInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryIndirectInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyMemoryIndirectInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcCopyFlags, dstCopyFlags, copyCount, copyAddressRange ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyMemoryIndirectInfoKHR const & ) const = default; +#else + bool operator==( CopyMemoryIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcCopyFlags == rhs.srcCopyFlags ) && ( dstCopyFlags == rhs.dstCopyFlags ) && + ( copyCount == rhs.copyCount ) && ( copyAddressRange == rhs.copyAddressRange ); +# endif + } + + bool operator!=( CopyMemoryIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyMemoryIndirectInfoKHR; + const void * pNext = {}; + AddressCopyFlagsKHR srcCopyFlags = {}; + AddressCopyFlagsKHR dstCopyFlags = {}; + uint32_t copyCount = {}; + StridedDeviceAddressRangeKHR copyAddressRange = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyMemoryIndirectInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = CopyMemoryIndirectInfoKHR; + }; + + // wrapper struct for struct VkCopyMemoryToAccelerationStructureInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html + struct CopyMemoryToAccelerationStructureInfoKHR + { + using NativeType = VkCopyMemoryToAccelerationStructureInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR( DeviceOrHostAddressConstKHR src_ = {}, + AccelerationStructureKHR dst_ = {}, + CopyAccelerationStructureModeKHR mode_ = CopyAccelerationStructureModeKHR::eClone, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , src{ src_ } + , dst{ dst_ } + , mode{ mode_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR( CopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyMemoryToAccelerationStructureInfoKHR( VkCopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyMemoryToAccelerationStructureInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + CopyMemoryToAccelerationStructureInfoKHR & operator=( CopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyMemoryToAccelerationStructureInfoKHR & operator=( VkCopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setSrc( DeviceOrHostAddressConstKHR const & src_ ) & VULKAN_HPP_NOEXCEPT + { + src = src_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setSrc( DeviceOrHostAddressConstKHR const & src_ ) && VULKAN_HPP_NOEXCEPT + { + src = src_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setDst( AccelerationStructureKHR dst_ ) & VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setDst( AccelerationStructureKHR dst_ ) && VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setMode( CopyAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setMode( CopyAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyMemoryToAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryToAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryToAccelerationStructureInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyMemoryToAccelerationStructureInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } +#endif + + public: + StructureType sType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR; + const void * pNext = {}; + DeviceOrHostAddressConstKHR src = {}; + AccelerationStructureKHR dst = {}; + CopyAccelerationStructureModeKHR mode = CopyAccelerationStructureModeKHR::eClone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyMemoryToAccelerationStructureInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = CopyMemoryToAccelerationStructureInfoKHR; + }; + + // wrapper struct for struct VkCopyMemoryToImageIndirectCommandKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageIndirectCommandKHR.html + struct CopyMemoryToImageIndirectCommandKHR + { + using NativeType = VkCopyMemoryToImageIndirectCommandKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectCommandKHR( DeviceAddress srcAddress_ = {}, + uint32_t bufferRowLength_ = {}, + uint32_t bufferImageHeight_ = {}, + ImageSubresourceLayers imageSubresource_ = {}, + Offset3D imageOffset_ = {}, + Extent3D imageExtent_ = {} ) VULKAN_HPP_NOEXCEPT + : srcAddress{ srcAddress_ } + , bufferRowLength{ bufferRowLength_ } + , bufferImageHeight{ bufferImageHeight_ } + , imageSubresource{ imageSubresource_ } + , imageOffset{ imageOffset_ } + , imageExtent{ imageExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectCommandKHR( CopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyMemoryToImageIndirectCommandKHR( VkCopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyMemoryToImageIndirectCommandKHR( *reinterpret_cast( &rhs ) ) + { + } + + CopyMemoryToImageIndirectCommandKHR & operator=( CopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyMemoryToImageIndirectCommandKHR & operator=( VkCopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT + { + srcAddress = srcAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT + { + srcAddress = srcAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setBufferRowLength( uint32_t bufferRowLength_ ) & VULKAN_HPP_NOEXCEPT + { + bufferRowLength = bufferRowLength_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setBufferRowLength( uint32_t bufferRowLength_ ) && VULKAN_HPP_NOEXCEPT + { + bufferRowLength = bufferRowLength_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setBufferImageHeight( uint32_t bufferImageHeight_ ) & VULKAN_HPP_NOEXCEPT + { + bufferImageHeight = bufferImageHeight_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setBufferImageHeight( uint32_t bufferImageHeight_ ) && VULKAN_HPP_NOEXCEPT + { + bufferImageHeight = bufferImageHeight_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && + VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyMemoryToImageIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryToImageIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryToImageIndirectCommandKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyMemoryToImageIndirectCommandKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcAddress, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyMemoryToImageIndirectCommandKHR const & ) const = default; +#else + bool operator==( CopyMemoryToImageIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( srcAddress == rhs.srcAddress ) && ( bufferRowLength == rhs.bufferRowLength ) && ( bufferImageHeight == rhs.bufferImageHeight ) && + ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent ); +# endif + } + + bool operator!=( CopyMemoryToImageIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress srcAddress = {}; + uint32_t bufferRowLength = {}; + uint32_t bufferImageHeight = {}; + ImageSubresourceLayers imageSubresource = {}; + Offset3D imageOffset = {}; + Extent3D imageExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyMemoryToImageIndirectCommandKHR; + }; +#endif + using CopyMemoryToImageIndirectCommandNV = CopyMemoryToImageIndirectCommandKHR; + + // wrapper struct for struct VkCopyMemoryToImageIndirectInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageIndirectInfoKHR.html + struct CopyMemoryToImageIndirectInfoKHR + { + using NativeType = VkCopyMemoryToImageIndirectInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryToImageIndirectInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectInfoKHR( AddressCopyFlagsKHR srcCopyFlags_ = {}, + uint32_t copyCount_ = {}, + StridedDeviceAddressRangeKHR copyAddressRange_ = {}, + Image dstImage_ = {}, + ImageLayout dstImageLayout_ = ImageLayout::eUndefined, + const ImageSubresourceLayers * pImageSubresources_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcCopyFlags{ srcCopyFlags_ } + , copyCount{ copyCount_ } + , copyAddressRange{ copyAddressRange_ } + , dstImage{ dstImage_ } + , dstImageLayout{ dstImageLayout_ } + , pImageSubresources{ pImageSubresources_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectInfoKHR( CopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyMemoryToImageIndirectInfoKHR( VkCopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyMemoryToImageIndirectInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyMemoryToImageIndirectInfoKHR( AddressCopyFlagsKHR srcCopyFlags_, + StridedDeviceAddressRangeKHR copyAddressRange_, + Image dstImage_, + ImageLayout dstImageLayout_, + ArrayProxyNoTemporaries const & imageSubresources_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , srcCopyFlags( srcCopyFlags_ ) + , copyCount( static_cast( imageSubresources_.size() ) ) + , copyAddressRange( copyAddressRange_ ) + , dstImage( dstImage_ ) + , dstImageLayout( dstImageLayout_ ) + , pImageSubresources( imageSubresources_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CopyMemoryToImageIndirectInfoKHR & operator=( CopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyMemoryToImageIndirectInfoKHR & operator=( VkCopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) & VULKAN_HPP_NOEXCEPT + { + srcCopyFlags = srcCopyFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) && VULKAN_HPP_NOEXCEPT + { + srcCopyFlags = srcCopyFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setCopyCount( uint32_t copyCount_ ) & VULKAN_HPP_NOEXCEPT + { + copyCount = copyCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setCopyCount( uint32_t copyCount_ ) && VULKAN_HPP_NOEXCEPT + { + copyCount = copyCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) & + VULKAN_HPP_NOEXCEPT + { + copyAddressRange = copyAddressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) && + VULKAN_HPP_NOEXCEPT + { + copyAddressRange = copyAddressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setPImageSubresources( const ImageSubresourceLayers * pImageSubresources_ ) & VULKAN_HPP_NOEXCEPT + { + pImageSubresources = pImageSubresources_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setPImageSubresources( const ImageSubresourceLayers * pImageSubresources_ ) && + VULKAN_HPP_NOEXCEPT + { + pImageSubresources = pImageSubresources_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyMemoryToImageIndirectInfoKHR & + setImageSubresources( ArrayProxyNoTemporaries const & imageSubresources_ ) VULKAN_HPP_NOEXCEPT + { + copyCount = static_cast( imageSubresources_.size() ); + pImageSubresources = imageSubresources_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyMemoryToImageIndirectInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryToImageIndirectInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryToImageIndirectInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyMemoryToImageIndirectInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcCopyFlags, copyCount, copyAddressRange, dstImage, dstImageLayout, pImageSubresources ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyMemoryToImageIndirectInfoKHR const & ) const = default; +#else + bool operator==( CopyMemoryToImageIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcCopyFlags == rhs.srcCopyFlags ) && ( copyCount == rhs.copyCount ) && + ( copyAddressRange == rhs.copyAddressRange ) && ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && + ( pImageSubresources == rhs.pImageSubresources ); +# endif + } + + bool operator!=( CopyMemoryToImageIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyMemoryToImageIndirectInfoKHR; + const void * pNext = {}; + AddressCopyFlagsKHR srcCopyFlags = {}; + uint32_t copyCount = {}; + StridedDeviceAddressRangeKHR copyAddressRange = {}; + Image dstImage = {}; + ImageLayout dstImageLayout = ImageLayout::eUndefined; + const ImageSubresourceLayers * pImageSubresources = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyMemoryToImageIndirectInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = CopyMemoryToImageIndirectInfoKHR; + }; + + // wrapper struct for struct VkMemoryToImageCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryToImageCopy.html + struct MemoryToImageCopy + { + using NativeType = VkMemoryToImageCopy; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryToImageCopy; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryToImageCopy( const void * pHostPointer_ = {}, + uint32_t memoryRowLength_ = {}, + uint32_t memoryImageHeight_ = {}, + ImageSubresourceLayers imageSubresource_ = {}, + Offset3D imageOffset_ = {}, + Extent3D imageExtent_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pHostPointer{ pHostPointer_ } + , memoryRowLength{ memoryRowLength_ } + , memoryImageHeight{ memoryImageHeight_ } + , imageSubresource{ imageSubresource_ } + , imageOffset{ imageOffset_ } + , imageExtent{ imageExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryToImageCopy( MemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryToImageCopy( VkMemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryToImageCopy( *reinterpret_cast( &rhs ) ) {} + + MemoryToImageCopy & operator=( MemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryToImageCopy & operator=( VkMemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setPHostPointer( const void * pHostPointer_ ) & VULKAN_HPP_NOEXCEPT + { + pHostPointer = pHostPointer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setPHostPointer( const void * pHostPointer_ ) && VULKAN_HPP_NOEXCEPT + { + pHostPointer = pHostPointer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setMemoryRowLength( uint32_t memoryRowLength_ ) & VULKAN_HPP_NOEXCEPT + { + memoryRowLength = memoryRowLength_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setMemoryRowLength( uint32_t memoryRowLength_ ) && VULKAN_HPP_NOEXCEPT + { + memoryRowLength = memoryRowLength_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setMemoryImageHeight( uint32_t memoryImageHeight_ ) & VULKAN_HPP_NOEXCEPT + { + memoryImageHeight = memoryImageHeight_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setMemoryImageHeight( uint32_t memoryImageHeight_ ) && VULKAN_HPP_NOEXCEPT + { + memoryImageHeight = memoryImageHeight_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT + { + imageOffset = imageOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryToImageCopy const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryToImageCopy &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryToImageCopy const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryToImageCopy *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pHostPointer, memoryRowLength, memoryImageHeight, imageSubresource, imageOffset, imageExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryToImageCopy const & ) const = default; +#else + bool operator==( MemoryToImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pHostPointer == rhs.pHostPointer ) && ( memoryRowLength == rhs.memoryRowLength ) && + ( memoryImageHeight == rhs.memoryImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && + ( imageExtent == rhs.imageExtent ); +# endif + } + + bool operator!=( MemoryToImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryToImageCopy; + const void * pNext = {}; + const void * pHostPointer = {}; + uint32_t memoryRowLength = {}; + uint32_t memoryImageHeight = {}; + ImageSubresourceLayers imageSubresource = {}; + Offset3D imageOffset = {}; + Extent3D imageExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryToImageCopy; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryToImageCopy; + }; + + using MemoryToImageCopyEXT = MemoryToImageCopy; + + // wrapper struct for struct VkCopyMemoryToImageInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageInfo.html + struct CopyMemoryToImageInfo + { + using NativeType = VkCopyMemoryToImageInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryToImageInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyMemoryToImageInfo( HostImageCopyFlags flags_ = {}, + Image dstImage_ = {}, + ImageLayout dstImageLayout_ = ImageLayout::eUndefined, + uint32_t regionCount_ = {}, + const MemoryToImageCopy * pRegions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , dstImage{ dstImage_ } + , dstImageLayout{ dstImageLayout_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyMemoryToImageInfo( CopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyMemoryToImageInfo( VkCopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyMemoryToImageInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyMemoryToImageInfo( HostImageCopyFlags flags_, + Image dstImage_, + ImageLayout dstImageLayout_, + ArrayProxyNoTemporaries const & regions_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , dstImage( dstImage_ ) + , dstImageLayout( dstImageLayout_ ) + , regionCount( static_cast( regions_.size() ) ) + , pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CopyMemoryToImageInfo & operator=( CopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyMemoryToImageInfo & operator=( VkCopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setFlags( HostImageCopyFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setFlags( HostImageCopyFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setPRegions( const MemoryToImageCopy * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setPRegions( const MemoryToImageCopy * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyMemoryToImageInfo & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyMemoryToImageInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryToImageInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryToImageInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyMemoryToImageInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, dstImage, dstImageLayout, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyMemoryToImageInfo const & ) const = default; +#else + bool operator==( CopyMemoryToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dstImage == rhs.dstImage ) && + ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( CopyMemoryToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyMemoryToImageInfo; + const void * pNext = {}; + HostImageCopyFlags flags = {}; + Image dstImage = {}; + ImageLayout dstImageLayout = ImageLayout::eUndefined; + uint32_t regionCount = {}; + const MemoryToImageCopy * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyMemoryToImageInfo; + }; +#endif + + template <> + struct CppType + { + using Type = CopyMemoryToImageInfo; + }; + + using CopyMemoryToImageInfoEXT = CopyMemoryToImageInfo; + + // wrapper struct for struct VkCopyMemoryToMicromapInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToMicromapInfoEXT.html + struct CopyMemoryToMicromapInfoEXT + { + using NativeType = VkCopyMemoryToMicromapInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryToMicromapInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT( DeviceOrHostAddressConstKHR src_ = {}, + MicromapEXT dst_ = {}, + CopyMicromapModeEXT mode_ = CopyMicromapModeEXT::eClone, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , src{ src_ } + , dst{ dst_ } + , mode{ mode_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT( CopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyMemoryToMicromapInfoEXT( VkCopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyMemoryToMicromapInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + CopyMemoryToMicromapInfoEXT & operator=( CopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyMemoryToMicromapInfoEXT & operator=( VkCopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setSrc( DeviceOrHostAddressConstKHR const & src_ ) & VULKAN_HPP_NOEXCEPT + { + src = src_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setSrc( DeviceOrHostAddressConstKHR const & src_ ) && VULKAN_HPP_NOEXCEPT + { + src = src_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setDst( MicromapEXT dst_ ) & VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setDst( MicromapEXT dst_ ) && VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setMode( CopyMicromapModeEXT mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setMode( CopyMicromapModeEXT mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyMemoryToMicromapInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryToMicromapInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMemoryToMicromapInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyMemoryToMicromapInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } +#endif + + public: + StructureType sType = StructureType::eCopyMemoryToMicromapInfoEXT; + const void * pNext = {}; + DeviceOrHostAddressConstKHR src = {}; + MicromapEXT dst = {}; + CopyMicromapModeEXT mode = CopyMicromapModeEXT::eClone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyMemoryToMicromapInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = CopyMemoryToMicromapInfoEXT; + }; + + // wrapper struct for struct VkCopyMicromapInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMicromapInfoEXT.html + struct CopyMicromapInfoEXT + { + using NativeType = VkCopyMicromapInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMicromapInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyMicromapInfoEXT( MicromapEXT src_ = {}, + MicromapEXT dst_ = {}, + CopyMicromapModeEXT mode_ = CopyMicromapModeEXT::eClone, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , src{ src_ } + , dst{ dst_ } + , mode{ mode_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyMicromapInfoEXT( CopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyMicromapInfoEXT( VkCopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : CopyMicromapInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + CopyMicromapInfoEXT & operator=( CopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyMicromapInfoEXT & operator=( VkCopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setSrc( MicromapEXT src_ ) & VULKAN_HPP_NOEXCEPT + { + src = src_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setSrc( MicromapEXT src_ ) && VULKAN_HPP_NOEXCEPT + { + src = src_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setDst( MicromapEXT dst_ ) & VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setDst( MicromapEXT dst_ ) && VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setMode( CopyMicromapModeEXT mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setMode( CopyMicromapModeEXT mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyMicromapInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMicromapInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMicromapInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyMicromapInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyMicromapInfoEXT const & ) const = default; +#else + bool operator==( CopyMicromapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) && ( mode == rhs.mode ); +# endif + } + + bool operator!=( CopyMicromapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyMicromapInfoEXT; + const void * pNext = {}; + MicromapEXT src = {}; + MicromapEXT dst = {}; + CopyMicromapModeEXT mode = CopyMicromapModeEXT::eClone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyMicromapInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = CopyMicromapInfoEXT; + }; + + // wrapper struct for struct VkCopyMicromapToMemoryInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMicromapToMemoryInfoEXT.html + struct CopyMicromapToMemoryInfoEXT + { + using NativeType = VkCopyMicromapToMemoryInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMicromapToMemoryInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT( MicromapEXT src_ = {}, + DeviceOrHostAddressKHR dst_ = {}, + CopyMicromapModeEXT mode_ = CopyMicromapModeEXT::eClone, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , src{ src_ } + , dst{ dst_ } + , mode{ mode_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT( CopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyMicromapToMemoryInfoEXT( VkCopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : CopyMicromapToMemoryInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + CopyMicromapToMemoryInfoEXT & operator=( CopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyMicromapToMemoryInfoEXT & operator=( VkCopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setSrc( MicromapEXT src_ ) & VULKAN_HPP_NOEXCEPT + { + src = src_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setSrc( MicromapEXT src_ ) && VULKAN_HPP_NOEXCEPT + { + src = src_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setDst( DeviceOrHostAddressKHR const & dst_ ) & VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setDst( DeviceOrHostAddressKHR const & dst_ ) && VULKAN_HPP_NOEXCEPT + { + dst = dst_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setMode( CopyMicromapModeEXT mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setMode( CopyMicromapModeEXT mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyMicromapToMemoryInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMicromapToMemoryInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyMicromapToMemoryInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyMicromapToMemoryInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, src, dst, mode ); + } +#endif + + public: + StructureType sType = StructureType::eCopyMicromapToMemoryInfoEXT; + const void * pNext = {}; + MicromapEXT src = {}; + DeviceOrHostAddressKHR dst = {}; + CopyMicromapModeEXT mode = CopyMicromapModeEXT::eClone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyMicromapToMemoryInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = CopyMicromapToMemoryInfoEXT; + }; + + // wrapper struct for struct VkTensorCopyARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCopyARM.html + struct TensorCopyARM + { + using NativeType = VkTensorCopyARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorCopyARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TensorCopyARM( uint32_t dimensionCount_ = {}, + const uint64_t * pSrcOffset_ = {}, + const uint64_t * pDstOffset_ = {}, + const uint64_t * pExtent_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dimensionCount{ dimensionCount_ } + , pSrcOffset{ pSrcOffset_ } + , pDstOffset{ pDstOffset_ } + , pExtent{ pExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR TensorCopyARM( TensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TensorCopyARM( VkTensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT : TensorCopyARM( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TensorCopyARM( ArrayProxyNoTemporaries const & srcOffset_, + ArrayProxyNoTemporaries const & dstOffset_ = {}, + ArrayProxyNoTemporaries const & extent_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , dimensionCount( static_cast( srcOffset_.size() ) ) + , pSrcOffset( srcOffset_.data() ) + , pDstOffset( dstOffset_.data() ) + , pExtent( extent_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( srcOffset_.empty() || dstOffset_.empty() || ( srcOffset_.size() == dstOffset_.size() ) ); + VULKAN_HPP_ASSERT( srcOffset_.empty() || extent_.empty() || ( srcOffset_.size() == extent_.size() ) ); + VULKAN_HPP_ASSERT( dstOffset_.empty() || extent_.empty() || ( dstOffset_.size() == extent_.size() ) ); +# else + if ( !srcOffset_.empty() && !dstOffset_.empty() && ( srcOffset_.size() != dstOffset_.size() ) ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::TensorCopyARM::TensorCopyARM: !srcOffset_.empty() && !dstOffset_.empty() && ( srcOffset_.size() != dstOffset_.size() )" ); + } + if ( !srcOffset_.empty() && !extent_.empty() && ( srcOffset_.size() != extent_.size() ) ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::TensorCopyARM::TensorCopyARM: !srcOffset_.empty() && !extent_.empty() && ( srcOffset_.size() != extent_.size() )" ); + } + if ( !dstOffset_.empty() && !extent_.empty() && ( dstOffset_.size() != extent_.size() ) ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::TensorCopyARM::TensorCopyARM: !dstOffset_.empty() && !extent_.empty() && ( dstOffset_.size() != extent_.size() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + TensorCopyARM & operator=( TensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TensorCopyARM & operator=( VkTensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setDimensionCount( uint32_t dimensionCount_ ) & VULKAN_HPP_NOEXCEPT + { + dimensionCount = dimensionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setDimensionCount( uint32_t dimensionCount_ ) && VULKAN_HPP_NOEXCEPT + { + dimensionCount = dimensionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPSrcOffset( const uint64_t * pSrcOffset_ ) & VULKAN_HPP_NOEXCEPT + { + pSrcOffset = pSrcOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPSrcOffset( const uint64_t * pSrcOffset_ ) && VULKAN_HPP_NOEXCEPT + { + pSrcOffset = pSrcOffset_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TensorCopyARM & setSrcOffset( ArrayProxyNoTemporaries const & srcOffset_ ) VULKAN_HPP_NOEXCEPT + { + dimensionCount = static_cast( srcOffset_.size() ); + pSrcOffset = srcOffset_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPDstOffset( const uint64_t * pDstOffset_ ) & VULKAN_HPP_NOEXCEPT + { + pDstOffset = pDstOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPDstOffset( const uint64_t * pDstOffset_ ) && VULKAN_HPP_NOEXCEPT + { + pDstOffset = pDstOffset_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TensorCopyARM & setDstOffset( ArrayProxyNoTemporaries const & dstOffset_ ) VULKAN_HPP_NOEXCEPT + { + dimensionCount = static_cast( dstOffset_.size() ); + pDstOffset = dstOffset_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPExtent( const uint64_t * pExtent_ ) & VULKAN_HPP_NOEXCEPT + { + pExtent = pExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPExtent( const uint64_t * pExtent_ ) && VULKAN_HPP_NOEXCEPT + { + pExtent = pExtent_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TensorCopyARM & setExtent( ArrayProxyNoTemporaries const & extent_ ) VULKAN_HPP_NOEXCEPT + { + dimensionCount = static_cast( extent_.size() ); + pExtent = extent_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTensorCopyARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorCopyARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorCopyARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTensorCopyARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dimensionCount, pSrcOffset, pDstOffset, pExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TensorCopyARM const & ) const = default; +#else + bool operator==( TensorCopyARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dimensionCount == rhs.dimensionCount ) && ( pSrcOffset == rhs.pSrcOffset ) && + ( pDstOffset == rhs.pDstOffset ) && ( pExtent == rhs.pExtent ); +# endif + } + + bool operator!=( TensorCopyARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTensorCopyARM; + const void * pNext = {}; + uint32_t dimensionCount = {}; + const uint64_t * pSrcOffset = {}; + const uint64_t * pDstOffset = {}; + const uint64_t * pExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TensorCopyARM; + }; +#endif + + template <> + struct CppType + { + using Type = TensorCopyARM; + }; + + // wrapper struct for struct VkCopyTensorInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyTensorInfoARM.html + struct CopyTensorInfoARM + { + using NativeType = VkCopyTensorInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyTensorInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CopyTensorInfoARM( TensorARM srcTensor_ = {}, + TensorARM dstTensor_ = {}, + uint32_t regionCount_ = {}, + const TensorCopyARM * pRegions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcTensor{ srcTensor_ } + , dstTensor{ dstTensor_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR CopyTensorInfoARM( CopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CopyTensorInfoARM( VkCopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT : CopyTensorInfoARM( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyTensorInfoARM( TensorARM srcTensor_, + TensorARM dstTensor_, + ArrayProxyNoTemporaries const & regions_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), srcTensor( srcTensor_ ), dstTensor( dstTensor_ ), regionCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CopyTensorInfoARM & operator=( CopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CopyTensorInfoARM & operator=( VkCopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setSrcTensor( TensorARM srcTensor_ ) & VULKAN_HPP_NOEXCEPT + { + srcTensor = srcTensor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setSrcTensor( TensorARM srcTensor_ ) && VULKAN_HPP_NOEXCEPT + { + srcTensor = srcTensor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setDstTensor( TensorARM dstTensor_ ) & VULKAN_HPP_NOEXCEPT + { + dstTensor = dstTensor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setDstTensor( TensorARM dstTensor_ ) && VULKAN_HPP_NOEXCEPT + { + dstTensor = dstTensor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setPRegions( const TensorCopyARM * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setPRegions( const TensorCopyARM * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CopyTensorInfoARM & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCopyTensorInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyTensorInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCopyTensorInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCopyTensorInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcTensor, dstTensor, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CopyTensorInfoARM const & ) const = default; +#else + bool operator==( CopyTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcTensor == rhs.srcTensor ) && ( dstTensor == rhs.dstTensor ) && + ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( CopyTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCopyTensorInfoARM; + const void * pNext = {}; + TensorARM srcTensor = {}; + TensorARM dstTensor = {}; + uint32_t regionCount = {}; + const TensorCopyARM * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CopyTensorInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = CopyTensorInfoARM; + }; + + // wrapper struct for struct VkCuFunctionCreateInfoNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuFunctionCreateInfoNVX.html + struct CuFunctionCreateInfoNVX + { + using NativeType = VkCuFunctionCreateInfoNVX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCuFunctionCreateInfoNVX; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CuFunctionCreateInfoNVX( CuModuleNVX module_ = {}, const char * pName_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , module{ module_ } + , pName{ pName_ } + { + } + + VULKAN_HPP_CONSTEXPR CuFunctionCreateInfoNVX( CuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CuFunctionCreateInfoNVX( VkCuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + : CuFunctionCreateInfoNVX( *reinterpret_cast( &rhs ) ) + { + } + + CuFunctionCreateInfoNVX & operator=( CuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CuFunctionCreateInfoNVX & operator=( VkCuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX & setModule( CuModuleNVX module_ ) & VULKAN_HPP_NOEXCEPT + { + module = module_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX && setModule( CuModuleNVX module_ ) && VULKAN_HPP_NOEXCEPT + { + module = module_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCuFunctionCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCuFunctionCreateInfoNVX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCuFunctionCreateInfoNVX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCuFunctionCreateInfoNVX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, module, pName ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = module <=> rhs.module; cmp != 0 ) + return cmp; + if ( pName != rhs.pName ) + if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ); + } + + bool operator!=( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eCuFunctionCreateInfoNVX; + const void * pNext = {}; + CuModuleNVX module = {}; + const char * pName = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CuFunctionCreateInfoNVX; + }; +#endif + + template <> + struct CppType + { + using Type = CuFunctionCreateInfoNVX; + }; + + // wrapper struct for struct VkCuLaunchInfoNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuLaunchInfoNVX.html + struct CuLaunchInfoNVX + { + using NativeType = VkCuLaunchInfoNVX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCuLaunchInfoNVX; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CuLaunchInfoNVX( CuFunctionNVX function_ = {}, + uint32_t gridDimX_ = {}, + uint32_t gridDimY_ = {}, + uint32_t gridDimZ_ = {}, + uint32_t blockDimX_ = {}, + uint32_t blockDimY_ = {}, + uint32_t blockDimZ_ = {}, + uint32_t sharedMemBytes_ = {}, + size_t paramCount_ = {}, + const void * const * pParams_ = {}, + size_t extraCount_ = {}, + const void * const * pExtras_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , function{ function_ } + , gridDimX{ gridDimX_ } + , gridDimY{ gridDimY_ } + , gridDimZ{ gridDimZ_ } + , blockDimX{ blockDimX_ } + , blockDimY{ blockDimY_ } + , blockDimZ{ blockDimZ_ } + , sharedMemBytes{ sharedMemBytes_ } + , paramCount{ paramCount_ } + , pParams{ pParams_ } + , extraCount{ extraCount_ } + , pExtras{ pExtras_ } + { + } + + VULKAN_HPP_CONSTEXPR CuLaunchInfoNVX( CuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CuLaunchInfoNVX( VkCuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT : CuLaunchInfoNVX( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CuLaunchInfoNVX( CuFunctionNVX function_, + uint32_t gridDimX_, + uint32_t gridDimY_, + uint32_t gridDimZ_, + uint32_t blockDimX_, + uint32_t blockDimY_, + uint32_t blockDimZ_, + uint32_t sharedMemBytes_, + ArrayProxyNoTemporaries const & params_, + ArrayProxyNoTemporaries const & extras_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , function( function_ ) + , gridDimX( gridDimX_ ) + , gridDimY( gridDimY_ ) + , gridDimZ( gridDimZ_ ) + , blockDimX( blockDimX_ ) + , blockDimY( blockDimY_ ) + , blockDimZ( blockDimZ_ ) + , sharedMemBytes( sharedMemBytes_ ) + , paramCount( params_.size() ) + , pParams( params_.data() ) + , extraCount( extras_.size() ) + , pExtras( extras_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CuLaunchInfoNVX & operator=( CuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CuLaunchInfoNVX & operator=( VkCuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setFunction( CuFunctionNVX function_ ) & VULKAN_HPP_NOEXCEPT + { + function = function_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setFunction( CuFunctionNVX function_ ) && VULKAN_HPP_NOEXCEPT + { + function = function_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setGridDimX( uint32_t gridDimX_ ) & VULKAN_HPP_NOEXCEPT + { + gridDimX = gridDimX_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setGridDimX( uint32_t gridDimX_ ) && VULKAN_HPP_NOEXCEPT + { + gridDimX = gridDimX_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setGridDimY( uint32_t gridDimY_ ) & VULKAN_HPP_NOEXCEPT + { + gridDimY = gridDimY_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setGridDimY( uint32_t gridDimY_ ) && VULKAN_HPP_NOEXCEPT + { + gridDimY = gridDimY_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setGridDimZ( uint32_t gridDimZ_ ) & VULKAN_HPP_NOEXCEPT + { + gridDimZ = gridDimZ_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setGridDimZ( uint32_t gridDimZ_ ) && VULKAN_HPP_NOEXCEPT + { + gridDimZ = gridDimZ_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setBlockDimX( uint32_t blockDimX_ ) & VULKAN_HPP_NOEXCEPT + { + blockDimX = blockDimX_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setBlockDimX( uint32_t blockDimX_ ) && VULKAN_HPP_NOEXCEPT + { + blockDimX = blockDimX_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setBlockDimY( uint32_t blockDimY_ ) & VULKAN_HPP_NOEXCEPT + { + blockDimY = blockDimY_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setBlockDimY( uint32_t blockDimY_ ) && VULKAN_HPP_NOEXCEPT + { + blockDimY = blockDimY_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setBlockDimZ( uint32_t blockDimZ_ ) & VULKAN_HPP_NOEXCEPT + { + blockDimZ = blockDimZ_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setBlockDimZ( uint32_t blockDimZ_ ) && VULKAN_HPP_NOEXCEPT + { + blockDimZ = blockDimZ_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setSharedMemBytes( uint32_t sharedMemBytes_ ) & VULKAN_HPP_NOEXCEPT + { + sharedMemBytes = sharedMemBytes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setSharedMemBytes( uint32_t sharedMemBytes_ ) && VULKAN_HPP_NOEXCEPT + { + sharedMemBytes = sharedMemBytes_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setParamCount( size_t paramCount_ ) & VULKAN_HPP_NOEXCEPT + { + paramCount = paramCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setParamCount( size_t paramCount_ ) && VULKAN_HPP_NOEXCEPT + { + paramCount = paramCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setPParams( const void * const * pParams_ ) & VULKAN_HPP_NOEXCEPT + { + pParams = pParams_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setPParams( const void * const * pParams_ ) && VULKAN_HPP_NOEXCEPT + { + pParams = pParams_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CuLaunchInfoNVX & setParams( ArrayProxyNoTemporaries const & params_ ) VULKAN_HPP_NOEXCEPT + { + paramCount = params_.size(); + pParams = params_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setExtraCount( size_t extraCount_ ) & VULKAN_HPP_NOEXCEPT + { + extraCount = extraCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setExtraCount( size_t extraCount_ ) && VULKAN_HPP_NOEXCEPT + { + extraCount = extraCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setPExtras( const void * const * pExtras_ ) & VULKAN_HPP_NOEXCEPT + { + pExtras = pExtras_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setPExtras( const void * const * pExtras_ ) && VULKAN_HPP_NOEXCEPT + { + pExtras = pExtras_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CuLaunchInfoNVX & setExtras( ArrayProxyNoTemporaries const & extras_ ) VULKAN_HPP_NOEXCEPT + { + extraCount = extras_.size(); + pExtras = extras_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCuLaunchInfoNVX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCuLaunchInfoNVX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCuLaunchInfoNVX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCuLaunchInfoNVX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, function, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, paramCount, pParams, extraCount, pExtras ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CuLaunchInfoNVX const & ) const = default; +#else + bool operator==( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) && ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) && + ( gridDimZ == rhs.gridDimZ ) && ( blockDimX == rhs.blockDimX ) && ( blockDimY == rhs.blockDimY ) && ( blockDimZ == rhs.blockDimZ ) && + ( sharedMemBytes == rhs.sharedMemBytes ) && ( paramCount == rhs.paramCount ) && ( pParams == rhs.pParams ) && ( extraCount == rhs.extraCount ) && + ( pExtras == rhs.pExtras ); +# endif + } + + bool operator!=( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCuLaunchInfoNVX; + const void * pNext = {}; + CuFunctionNVX function = {}; + uint32_t gridDimX = {}; + uint32_t gridDimY = {}; + uint32_t gridDimZ = {}; + uint32_t blockDimX = {}; + uint32_t blockDimY = {}; + uint32_t blockDimZ = {}; + uint32_t sharedMemBytes = {}; + size_t paramCount = {}; + const void * const * pParams = {}; + size_t extraCount = {}; + const void * const * pExtras = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CuLaunchInfoNVX; + }; +#endif + + template <> + struct CppType + { + using Type = CuLaunchInfoNVX; + }; + + // wrapper struct for struct VkCuModuleCreateInfoNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleCreateInfoNVX.html + struct CuModuleCreateInfoNVX + { + using NativeType = VkCuModuleCreateInfoNVX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCuModuleCreateInfoNVX; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CuModuleCreateInfoNVX( size_t dataSize_ = {}, const void * pData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dataSize{ dataSize_ } + , pData{ pData_ } + { + } + + VULKAN_HPP_CONSTEXPR CuModuleCreateInfoNVX( CuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CuModuleCreateInfoNVX( VkCuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + : CuModuleCreateInfoNVX( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + CuModuleCreateInfoNVX( ArrayProxyNoTemporaries const & data_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CuModuleCreateInfoNVX & operator=( CuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CuModuleCreateInfoNVX & operator=( VkCuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX & setPData( const void * pData_ ) & VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX && setPData( const void * pData_ ) && VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + CuModuleCreateInfoNVX & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT + { + dataSize = data_.size() * sizeof( T ); + pData = data_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCuModuleCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCuModuleCreateInfoNVX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCuModuleCreateInfoNVX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCuModuleCreateInfoNVX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataSize, pData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CuModuleCreateInfoNVX const & ) const = default; +#else + bool operator==( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); +# endif + } + + bool operator!=( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCuModuleCreateInfoNVX; + const void * pNext = {}; + size_t dataSize = {}; + const void * pData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CuModuleCreateInfoNVX; + }; +#endif + + template <> + struct CppType + { + using Type = CuModuleCreateInfoNVX; + }; + + // wrapper struct for struct VkCuModuleTexturingModeCreateInfoNVX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleTexturingModeCreateInfoNVX.html + struct CuModuleTexturingModeCreateInfoNVX + { + using NativeType = VkCuModuleTexturingModeCreateInfoNVX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCuModuleTexturingModeCreateInfoNVX; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CuModuleTexturingModeCreateInfoNVX( Bool32 use64bitTexturing_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , use64bitTexturing{ use64bitTexturing_ } + { + } + + VULKAN_HPP_CONSTEXPR CuModuleTexturingModeCreateInfoNVX( CuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CuModuleTexturingModeCreateInfoNVX( VkCuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + : CuModuleTexturingModeCreateInfoNVX( *reinterpret_cast( &rhs ) ) + { + } + + CuModuleTexturingModeCreateInfoNVX & operator=( CuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CuModuleTexturingModeCreateInfoNVX & operator=( VkCuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX & setUse64bitTexturing( Bool32 use64bitTexturing_ ) & VULKAN_HPP_NOEXCEPT + { + use64bitTexturing = use64bitTexturing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX && setUse64bitTexturing( Bool32 use64bitTexturing_ ) && VULKAN_HPP_NOEXCEPT + { + use64bitTexturing = use64bitTexturing_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCuModuleTexturingModeCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCuModuleTexturingModeCreateInfoNVX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCuModuleTexturingModeCreateInfoNVX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCuModuleTexturingModeCreateInfoNVX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, use64bitTexturing ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CuModuleTexturingModeCreateInfoNVX const & ) const = default; +#else + bool operator==( CuModuleTexturingModeCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( use64bitTexturing == rhs.use64bitTexturing ); +# endif + } + + bool operator!=( CuModuleTexturingModeCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCuModuleTexturingModeCreateInfoNVX; + const void * pNext = {}; + Bool32 use64bitTexturing = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CuModuleTexturingModeCreateInfoNVX; + }; +#endif + + template <> + struct CppType + { + using Type = CuModuleTexturingModeCreateInfoNVX; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkCudaFunctionCreateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaFunctionCreateInfoNV.html + struct CudaFunctionCreateInfoNV + { + using NativeType = VkCudaFunctionCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCudaFunctionCreateInfoNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CudaFunctionCreateInfoNV( CudaModuleNV module_ = {}, const char * pName_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , module{ module_ } + , pName{ pName_ } + { + } + + VULKAN_HPP_CONSTEXPR CudaFunctionCreateInfoNV( CudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CudaFunctionCreateInfoNV( VkCudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : CudaFunctionCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + CudaFunctionCreateInfoNV & operator=( CudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CudaFunctionCreateInfoNV & operator=( VkCudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV & setModule( CudaModuleNV module_ ) & VULKAN_HPP_NOEXCEPT + { + module = module_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV && setModule( CudaModuleNV module_ ) && VULKAN_HPP_NOEXCEPT + { + module = module_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCudaFunctionCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCudaFunctionCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCudaFunctionCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCudaFunctionCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, module, pName ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( CudaFunctionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = module <=> rhs.module; cmp != 0 ) + return cmp; + if ( pName != rhs.pName ) + if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( CudaFunctionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ); + } + + bool operator!=( CudaFunctionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eCudaFunctionCreateInfoNV; + const void * pNext = {}; + CudaModuleNV module = {}; + const char * pName = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CudaFunctionCreateInfoNV; + }; +# endif + + template <> + struct CppType + { + using Type = CudaFunctionCreateInfoNV; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkCudaLaunchInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaLaunchInfoNV.html + struct CudaLaunchInfoNV + { + using NativeType = VkCudaLaunchInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCudaLaunchInfoNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CudaLaunchInfoNV( CudaFunctionNV function_ = {}, + uint32_t gridDimX_ = {}, + uint32_t gridDimY_ = {}, + uint32_t gridDimZ_ = {}, + uint32_t blockDimX_ = {}, + uint32_t blockDimY_ = {}, + uint32_t blockDimZ_ = {}, + uint32_t sharedMemBytes_ = {}, + size_t paramCount_ = {}, + const void * const * pParams_ = {}, + size_t extraCount_ = {}, + const void * const * pExtras_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , function{ function_ } + , gridDimX{ gridDimX_ } + , gridDimY{ gridDimY_ } + , gridDimZ{ gridDimZ_ } + , blockDimX{ blockDimX_ } + , blockDimY{ blockDimY_ } + , blockDimZ{ blockDimZ_ } + , sharedMemBytes{ sharedMemBytes_ } + , paramCount{ paramCount_ } + , pParams{ pParams_ } + , extraCount{ extraCount_ } + , pExtras{ pExtras_ } + { + } + + VULKAN_HPP_CONSTEXPR CudaLaunchInfoNV( CudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CudaLaunchInfoNV( VkCudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT : CudaLaunchInfoNV( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CudaLaunchInfoNV( CudaFunctionNV function_, + uint32_t gridDimX_, + uint32_t gridDimY_, + uint32_t gridDimZ_, + uint32_t blockDimX_, + uint32_t blockDimY_, + uint32_t blockDimZ_, + uint32_t sharedMemBytes_, + ArrayProxyNoTemporaries const & params_, + ArrayProxyNoTemporaries const & extras_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , function( function_ ) + , gridDimX( gridDimX_ ) + , gridDimY( gridDimY_ ) + , gridDimZ( gridDimZ_ ) + , blockDimX( blockDimX_ ) + , blockDimY( blockDimY_ ) + , blockDimZ( blockDimZ_ ) + , sharedMemBytes( sharedMemBytes_ ) + , paramCount( params_.size() ) + , pParams( params_.data() ) + , extraCount( extras_.size() ) + , pExtras( extras_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CudaLaunchInfoNV & operator=( CudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CudaLaunchInfoNV & operator=( VkCudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setFunction( CudaFunctionNV function_ ) & VULKAN_HPP_NOEXCEPT + { + function = function_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setFunction( CudaFunctionNV function_ ) && VULKAN_HPP_NOEXCEPT + { + function = function_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setGridDimX( uint32_t gridDimX_ ) & VULKAN_HPP_NOEXCEPT + { + gridDimX = gridDimX_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setGridDimX( uint32_t gridDimX_ ) && VULKAN_HPP_NOEXCEPT + { + gridDimX = gridDimX_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setGridDimY( uint32_t gridDimY_ ) & VULKAN_HPP_NOEXCEPT + { + gridDimY = gridDimY_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setGridDimY( uint32_t gridDimY_ ) && VULKAN_HPP_NOEXCEPT + { + gridDimY = gridDimY_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setGridDimZ( uint32_t gridDimZ_ ) & VULKAN_HPP_NOEXCEPT + { + gridDimZ = gridDimZ_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setGridDimZ( uint32_t gridDimZ_ ) && VULKAN_HPP_NOEXCEPT + { + gridDimZ = gridDimZ_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setBlockDimX( uint32_t blockDimX_ ) & VULKAN_HPP_NOEXCEPT + { + blockDimX = blockDimX_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setBlockDimX( uint32_t blockDimX_ ) && VULKAN_HPP_NOEXCEPT + { + blockDimX = blockDimX_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setBlockDimY( uint32_t blockDimY_ ) & VULKAN_HPP_NOEXCEPT + { + blockDimY = blockDimY_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setBlockDimY( uint32_t blockDimY_ ) && VULKAN_HPP_NOEXCEPT + { + blockDimY = blockDimY_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setBlockDimZ( uint32_t blockDimZ_ ) & VULKAN_HPP_NOEXCEPT + { + blockDimZ = blockDimZ_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setBlockDimZ( uint32_t blockDimZ_ ) && VULKAN_HPP_NOEXCEPT + { + blockDimZ = blockDimZ_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setSharedMemBytes( uint32_t sharedMemBytes_ ) & VULKAN_HPP_NOEXCEPT + { + sharedMemBytes = sharedMemBytes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setSharedMemBytes( uint32_t sharedMemBytes_ ) && VULKAN_HPP_NOEXCEPT + { + sharedMemBytes = sharedMemBytes_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setParamCount( size_t paramCount_ ) & VULKAN_HPP_NOEXCEPT + { + paramCount = paramCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setParamCount( size_t paramCount_ ) && VULKAN_HPP_NOEXCEPT + { + paramCount = paramCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setPParams( const void * const * pParams_ ) & VULKAN_HPP_NOEXCEPT + { + pParams = pParams_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setPParams( const void * const * pParams_ ) && VULKAN_HPP_NOEXCEPT + { + pParams = pParams_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CudaLaunchInfoNV & setParams( ArrayProxyNoTemporaries const & params_ ) VULKAN_HPP_NOEXCEPT + { + paramCount = params_.size(); + pParams = params_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setExtraCount( size_t extraCount_ ) & VULKAN_HPP_NOEXCEPT + { + extraCount = extraCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setExtraCount( size_t extraCount_ ) && VULKAN_HPP_NOEXCEPT + { + extraCount = extraCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setPExtras( const void * const * pExtras_ ) & VULKAN_HPP_NOEXCEPT + { + pExtras = pExtras_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setPExtras( const void * const * pExtras_ ) && VULKAN_HPP_NOEXCEPT + { + pExtras = pExtras_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CudaLaunchInfoNV & setExtras( ArrayProxyNoTemporaries const & extras_ ) VULKAN_HPP_NOEXCEPT + { + extraCount = extras_.size(); + pExtras = extras_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCudaLaunchInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCudaLaunchInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCudaLaunchInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCudaLaunchInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, function, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, paramCount, pParams, extraCount, pExtras ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CudaLaunchInfoNV const & ) const = default; +# else + bool operator==( CudaLaunchInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) && ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) && + ( gridDimZ == rhs.gridDimZ ) && ( blockDimX == rhs.blockDimX ) && ( blockDimY == rhs.blockDimY ) && ( blockDimZ == rhs.blockDimZ ) && + ( sharedMemBytes == rhs.sharedMemBytes ) && ( paramCount == rhs.paramCount ) && ( pParams == rhs.pParams ) && ( extraCount == rhs.extraCount ) && + ( pExtras == rhs.pExtras ); +# endif + } + + bool operator!=( CudaLaunchInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eCudaLaunchInfoNV; + const void * pNext = {}; + CudaFunctionNV function = {}; + uint32_t gridDimX = {}; + uint32_t gridDimY = {}; + uint32_t gridDimZ = {}; + uint32_t blockDimX = {}; + uint32_t blockDimY = {}; + uint32_t blockDimZ = {}; + uint32_t sharedMemBytes = {}; + size_t paramCount = {}; + const void * const * pParams = {}; + size_t extraCount = {}; + const void * const * pExtras = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CudaLaunchInfoNV; + }; +# endif + + template <> + struct CppType + { + using Type = CudaLaunchInfoNV; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkCudaModuleCreateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaModuleCreateInfoNV.html + struct CudaModuleCreateInfoNV + { + using NativeType = VkCudaModuleCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCudaModuleCreateInfoNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CudaModuleCreateInfoNV( size_t dataSize_ = {}, const void * pData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dataSize{ dataSize_ } + , pData{ pData_ } + { + } + + VULKAN_HPP_CONSTEXPR CudaModuleCreateInfoNV( CudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CudaModuleCreateInfoNV( VkCudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : CudaModuleCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + CudaModuleCreateInfoNV( ArrayProxyNoTemporaries const & data_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CudaModuleCreateInfoNV & operator=( CudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CudaModuleCreateInfoNV & operator=( VkCudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV & setPData( const void * pData_ ) & VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV && setPData( const void * pData_ ) && VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + CudaModuleCreateInfoNV & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT + { + dataSize = data_.size() * sizeof( T ); + pData = data_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCudaModuleCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCudaModuleCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCudaModuleCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCudaModuleCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataSize, pData ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CudaModuleCreateInfoNV const & ) const = default; +# else + bool operator==( CudaModuleCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); +# endif + } + + bool operator!=( CudaModuleCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eCudaModuleCreateInfoNV; + const void * pNext = {}; + size_t dataSize = {}; + const void * pData = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CudaModuleCreateInfoNV; + }; +# endif + + template <> + struct CppType + { + using Type = CudaModuleCreateInfoNV; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkCustomResolveCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCustomResolveCreateInfoEXT.html + struct CustomResolveCreateInfoEXT + { + using NativeType = VkCustomResolveCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCustomResolveCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR CustomResolveCreateInfoEXT( Bool32 customResolve_ = {}, + uint32_t colorAttachmentCount_ = {}, + const Format * pColorAttachmentFormats_ = {}, + Format depthAttachmentFormat_ = Format::eUndefined, + Format stencilAttachmentFormat_ = Format::eUndefined, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , customResolve{ customResolve_ } + , colorAttachmentCount{ colorAttachmentCount_ } + , pColorAttachmentFormats{ pColorAttachmentFormats_ } + , depthAttachmentFormat{ depthAttachmentFormat_ } + , stencilAttachmentFormat{ stencilAttachmentFormat_ } + { + } + + VULKAN_HPP_CONSTEXPR CustomResolveCreateInfoEXT( CustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + CustomResolveCreateInfoEXT( VkCustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : CustomResolveCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CustomResolveCreateInfoEXT( Bool32 customResolve_, + ArrayProxyNoTemporaries const & colorAttachmentFormats_, + Format depthAttachmentFormat_ = Format::eUndefined, + Format stencilAttachmentFormat_ = Format::eUndefined, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , customResolve( customResolve_ ) + , colorAttachmentCount( static_cast( colorAttachmentFormats_.size() ) ) + , pColorAttachmentFormats( colorAttachmentFormats_.data() ) + , depthAttachmentFormat( depthAttachmentFormat_ ) + , stencilAttachmentFormat( stencilAttachmentFormat_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + CustomResolveCreateInfoEXT & operator=( CustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + CustomResolveCreateInfoEXT & operator=( VkCustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setCustomResolve( Bool32 customResolve_ ) & VULKAN_HPP_NOEXCEPT + { + customResolve = customResolve_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setCustomResolve( Bool32 customResolve_ ) && VULKAN_HPP_NOEXCEPT + { + customResolve = customResolve_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) & VULKAN_HPP_NOEXCEPT + { + pColorAttachmentFormats = pColorAttachmentFormats_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) && VULKAN_HPP_NOEXCEPT + { + pColorAttachmentFormats = pColorAttachmentFormats_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + CustomResolveCreateInfoEXT & setColorAttachmentFormats( ArrayProxyNoTemporaries const & colorAttachmentFormats_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( colorAttachmentFormats_.size() ); + pColorAttachmentFormats = colorAttachmentFormats_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setDepthAttachmentFormat( Format depthAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT + { + depthAttachmentFormat = depthAttachmentFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setDepthAttachmentFormat( Format depthAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT + { + depthAttachmentFormat = depthAttachmentFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT + { + stencilAttachmentFormat = stencilAttachmentFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT + { + stencilAttachmentFormat = stencilAttachmentFormat_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkCustomResolveCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCustomResolveCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkCustomResolveCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkCustomResolveCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, customResolve, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( CustomResolveCreateInfoEXT const & ) const = default; +#else + bool operator==( CustomResolveCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customResolve == rhs.customResolve ) && + ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && + ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ); +# endif + } + + bool operator!=( CustomResolveCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eCustomResolveCreateInfoEXT; + const void * pNext = {}; + Bool32 customResolve = {}; + uint32_t colorAttachmentCount = {}; + const Format * pColorAttachmentFormats = {}; + Format depthAttachmentFormat = Format::eUndefined; + Format stencilAttachmentFormat = Format::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = CustomResolveCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = CustomResolveCreateInfoEXT; + }; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkD3D12FenceSubmitInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkD3D12FenceSubmitInfoKHR.html + struct D3D12FenceSubmitInfoKHR + { + using NativeType = VkD3D12FenceSubmitInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eD3D12FenceSubmitInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = {}, + const uint64_t * pWaitSemaphoreValues_ = {}, + uint32_t signalSemaphoreValuesCount_ = {}, + const uint64_t * pSignalSemaphoreValues_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , waitSemaphoreValuesCount{ waitSemaphoreValuesCount_ } + , pWaitSemaphoreValues{ pWaitSemaphoreValues_ } + , signalSemaphoreValuesCount{ signalSemaphoreValuesCount_ } + , pSignalSemaphoreValues{ pSignalSemaphoreValues_ } + { + } + + VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : D3D12FenceSubmitInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + D3D12FenceSubmitInfoKHR( ArrayProxyNoTemporaries const & waitSemaphoreValues_, + ArrayProxyNoTemporaries const & signalSemaphoreValues_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , waitSemaphoreValuesCount( static_cast( waitSemaphoreValues_.size() ) ) + , pWaitSemaphoreValues( waitSemaphoreValues_.data() ) + , signalSemaphoreValuesCount( static_cast( signalSemaphoreValues_.size() ) ) + , pSignalSemaphoreValues( signalSemaphoreValues_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + D3D12FenceSubmitInfoKHR & operator=( D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + D3D12FenceSubmitInfoKHR & operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) & VULKAN_HPP_NOEXCEPT + { + waitSemaphoreValuesCount = waitSemaphoreValuesCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) && VULKAN_HPP_NOEXCEPT + { + waitSemaphoreValuesCount = waitSemaphoreValuesCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setPWaitSemaphoreValues( const uint64_t * pWaitSemaphoreValues_ ) & VULKAN_HPP_NOEXCEPT + { + pWaitSemaphoreValues = pWaitSemaphoreValues_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setPWaitSemaphoreValues( const uint64_t * pWaitSemaphoreValues_ ) && VULKAN_HPP_NOEXCEPT + { + pWaitSemaphoreValues = pWaitSemaphoreValues_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + D3D12FenceSubmitInfoKHR & setWaitSemaphoreValues( ArrayProxyNoTemporaries const & waitSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT + { + waitSemaphoreValuesCount = static_cast( waitSemaphoreValues_.size() ); + pWaitSemaphoreValues = waitSemaphoreValues_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) & VULKAN_HPP_NOEXCEPT + { + signalSemaphoreValuesCount = signalSemaphoreValuesCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) && VULKAN_HPP_NOEXCEPT + { + signalSemaphoreValuesCount = signalSemaphoreValuesCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setPSignalSemaphoreValues( const uint64_t * pSignalSemaphoreValues_ ) & VULKAN_HPP_NOEXCEPT + { + pSignalSemaphoreValues = pSignalSemaphoreValues_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setPSignalSemaphoreValues( const uint64_t * pSignalSemaphoreValues_ ) && VULKAN_HPP_NOEXCEPT + { + pSignalSemaphoreValues = pSignalSemaphoreValues_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + D3D12FenceSubmitInfoKHR & setSignalSemaphoreValues( ArrayProxyNoTemporaries const & signalSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT + { + signalSemaphoreValuesCount = static_cast( signalSemaphoreValues_.size() ); + pSignalSemaphoreValues = signalSemaphoreValues_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkD3D12FenceSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkD3D12FenceSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkD3D12FenceSubmitInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkD3D12FenceSubmitInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, waitSemaphoreValuesCount, pWaitSemaphoreValues, signalSemaphoreValuesCount, pSignalSemaphoreValues ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( D3D12FenceSubmitInfoKHR const & ) const = default; +# else + bool operator==( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) && + ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) && ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) && + ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); +# endif + } + + bool operator!=( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR; + const void * pNext = {}; + uint32_t waitSemaphoreValuesCount = {}; + const uint64_t * pWaitSemaphoreValues = {}; + uint32_t signalSemaphoreValuesCount = {}; + const uint64_t * pSignalSemaphoreValues = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = D3D12FenceSubmitInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = D3D12FenceSubmitInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + // wrapper struct for struct VkPhysicalDeviceDataGraphOperationSupportARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationSupportARM.html + struct PhysicalDeviceDataGraphOperationSupportARM + { + using NativeType = VkPhysicalDeviceDataGraphOperationSupportARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM( + PhysicalDeviceDataGraphOperationTypeARM operationType_ = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet, + std::array const & name_ = {}, + uint32_t version_ = {} ) VULKAN_HPP_NOEXCEPT + : operationType{ operationType_ } + , name{ name_ } + , version{ version_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDataGraphOperationSupportARM( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDataGraphOperationSupportARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationTypeARM operationType_, std::string const & name_, uint32_t version_ = {} ) + : operationType( operationType_ ), version( version_ ) + { + VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM ); +# if defined( _WIN32 ) + strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() ); +# else + strncpy( name, name_.data(), std::min( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) ); +# endif + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PhysicalDeviceDataGraphOperationSupportARM & operator=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDataGraphOperationSupportARM & operator=( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) & + VULKAN_HPP_NOEXCEPT + { + operationType = operationType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM && setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) && + VULKAN_HPP_NOEXCEPT + { + operationType = operationType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & + setName( std::array name_ ) & + VULKAN_HPP_NOEXCEPT + { + name = name_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM && + setName( std::array name_ ) && + VULKAN_HPP_NOEXCEPT + { + name = name_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceDataGraphOperationSupportARM & setName( std::string const & name_ ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM ); +# if defined( _WIN32 ) + strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() ); +# else + strncpy( name, name_.data(), std::min( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) ); +# endif + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setVersion( uint32_t version_ ) & VULKAN_HPP_NOEXCEPT + { + version = version_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM && setVersion( uint32_t version_ ) && VULKAN_HPP_NOEXCEPT + { + version = version_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDataGraphOperationSupportARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphOperationSupportARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphOperationSupportARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphOperationSupportARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + uint32_t const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( operationType, name, version ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = operationType <=> rhs.operationType; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = version <=> rhs.version; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( operationType == rhs.operationType ) && ( strcmp( name, rhs.name ) == 0 ) && ( version == rhs.version ); + } + + bool operator!=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + PhysicalDeviceDataGraphOperationTypeARM operationType = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet; + ArrayWrapper1D name = {}; + uint32_t version = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDataGraphOperationSupportARM; + }; +#endif + + // wrapper struct for struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineBuiltinModelCreateInfoQCOM.html + struct DataGraphPipelineBuiltinModelCreateInfoQCOM + { + using NativeType = VkDataGraphPipelineBuiltinModelCreateInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pOperation{ pOperation_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + DataGraphPipelineBuiltinModelCreateInfoQCOM( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineBuiltinModelCreateInfoQCOM( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineBuiltinModelCreateInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM & setPOperation( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ ) & + VULKAN_HPP_NOEXCEPT + { + pOperation = pOperation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM && setPOperation( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ ) && + VULKAN_HPP_NOEXCEPT + { + pOperation = pOperation_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pOperation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineBuiltinModelCreateInfoQCOM const & ) const = default; +#else + bool operator==( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pOperation == rhs.pOperation ); +# endif + } + + bool operator!=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM; + const void * pNext = {}; + const PhysicalDeviceDataGraphOperationSupportARM * pOperation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM; + }; + + // wrapper struct for struct VkDataGraphPipelineCompilerControlCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineCompilerControlCreateInfoARM.html + struct DataGraphPipelineCompilerControlCreateInfoARM + { + using NativeType = VkDataGraphPipelineCompilerControlCreateInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineCompilerControlCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineCompilerControlCreateInfoARM( const char * pVendorOptions_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pVendorOptions{ pVendorOptions_ } + { + } + + VULKAN_HPP_CONSTEXPR + DataGraphPipelineCompilerControlCreateInfoARM( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineCompilerControlCreateInfoARM( VkDataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineCompilerControlCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineCompilerControlCreateInfoARM & operator=( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineCompilerControlCreateInfoARM & operator=( VkDataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM & setPVendorOptions( const char * pVendorOptions_ ) & VULKAN_HPP_NOEXCEPT + { + pVendorOptions = pVendorOptions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM && setPVendorOptions( const char * pVendorOptions_ ) && VULKAN_HPP_NOEXCEPT + { + pVendorOptions = pVendorOptions_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineCompilerControlCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineCompilerControlCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineCompilerControlCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineCompilerControlCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pVendorOptions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( pVendorOptions != rhs.pVendorOptions ) + if ( auto cmp = strcmp( pVendorOptions, rhs.pVendorOptions ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( ( pVendorOptions == rhs.pVendorOptions ) || ( strcmp( pVendorOptions, rhs.pVendorOptions ) == 0 ) ); + } + + bool operator!=( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDataGraphPipelineCompilerControlCreateInfoARM; + const void * pNext = {}; + const char * pVendorOptions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineCompilerControlCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineCompilerControlCreateInfoARM; + }; + + // wrapper struct for struct VkDataGraphPipelineConstantARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineConstantARM.html + struct DataGraphPipelineConstantARM + { + using NativeType = VkDataGraphPipelineConstantARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineConstantARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantARM( uint32_t id_ = {}, const void * pConstantData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , id{ id_ } + , pConstantData{ pConstantData_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantARM( DataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineConstantARM( VkDataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineConstantARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineConstantARM & operator=( DataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineConstantARM & operator=( VkDataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM & setId( uint32_t id_ ) & VULKAN_HPP_NOEXCEPT + { + id = id_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM && setId( uint32_t id_ ) && VULKAN_HPP_NOEXCEPT + { + id = id_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM & setPConstantData( const void * pConstantData_ ) & VULKAN_HPP_NOEXCEPT + { + pConstantData = pConstantData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM && setPConstantData( const void * pConstantData_ ) && VULKAN_HPP_NOEXCEPT + { + pConstantData = pConstantData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineConstantARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineConstantARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineConstantARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineConstantARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, id, pConstantData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineConstantARM const & ) const = default; +#else + bool operator==( DataGraphPipelineConstantARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( id == rhs.id ) && ( pConstantData == rhs.pConstantData ); +# endif + } + + bool operator!=( DataGraphPipelineConstantARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineConstantARM; + const void * pNext = {}; + uint32_t id = {}; + const void * pConstantData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineConstantARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineConstantARM; + }; + + // wrapper struct for struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.html + struct DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM + { + using NativeType = VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM( uint32_t dimension_ = {}, + uint32_t zeroCount_ = {}, + uint32_t groupSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dimension{ dimension_ } + , zeroCount{ zeroCount_ } + , groupSize{ groupSize_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM( + DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM( VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) + VULKAN_HPP_NOEXCEPT + : DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM( + *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & + operator=( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & + operator=( VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setDimension( uint32_t dimension_ ) & VULKAN_HPP_NOEXCEPT + { + dimension = dimension_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setDimension( uint32_t dimension_ ) && VULKAN_HPP_NOEXCEPT + { + dimension = dimension_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setZeroCount( uint32_t zeroCount_ ) & VULKAN_HPP_NOEXCEPT + { + zeroCount = zeroCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setZeroCount( uint32_t zeroCount_ ) && VULKAN_HPP_NOEXCEPT + { + zeroCount = zeroCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setGroupSize( uint32_t groupSize_ ) & VULKAN_HPP_NOEXCEPT + { + groupSize = groupSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setGroupSize( uint32_t groupSize_ ) && VULKAN_HPP_NOEXCEPT + { + groupSize = groupSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dimension, zeroCount, groupSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dimension == rhs.dimension ) && ( zeroCount == rhs.zeroCount ) && + ( groupSize == rhs.groupSize ); +# endif + } + + bool operator!=( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; + const void * pNext = {}; + uint32_t dimension = {}; + uint32_t zeroCount = {}; + uint32_t groupSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; + }; + + // wrapper struct for struct VkDataGraphPipelineResourceInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineResourceInfoARM.html + struct DataGraphPipelineResourceInfoARM + { + using NativeType = VkDataGraphPipelineResourceInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineResourceInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineResourceInfoARM( uint32_t descriptorSet_ = {}, + uint32_t binding_ = {}, + uint32_t arrayElement_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorSet{ descriptorSet_ } + , binding{ binding_ } + , arrayElement{ arrayElement_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineResourceInfoARM( DataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineResourceInfoARM( VkDataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineResourceInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineResourceInfoARM & operator=( DataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineResourceInfoARM & operator=( VkDataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setDescriptorSet( uint32_t descriptorSet_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorSet = descriptorSet_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setDescriptorSet( uint32_t descriptorSet_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorSet = descriptorSet_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setArrayElement( uint32_t arrayElement_ ) & VULKAN_HPP_NOEXCEPT + { + arrayElement = arrayElement_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setArrayElement( uint32_t arrayElement_ ) && VULKAN_HPP_NOEXCEPT + { + arrayElement = arrayElement_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineResourceInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineResourceInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineResourceInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineResourceInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorSet, binding, arrayElement ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineResourceInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineResourceInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSet == rhs.descriptorSet ) && ( binding == rhs.binding ) && + ( arrayElement == rhs.arrayElement ); +# endif + } + + bool operator!=( DataGraphPipelineResourceInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineResourceInfoARM; + const void * pNext = {}; + uint32_t descriptorSet = {}; + uint32_t binding = {}; + uint32_t arrayElement = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineResourceInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineResourceInfoARM; + }; + + // wrapper struct for struct VkDataGraphPipelineCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineCreateInfoARM.html + struct DataGraphPipelineCreateInfoARM + { + using NativeType = VkDataGraphPipelineCreateInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineCreateInfoARM( PipelineCreateFlags2KHR flags_ = {}, + PipelineLayout layout_ = {}, + uint32_t resourceInfoCount_ = {}, + const DataGraphPipelineResourceInfoARM * pResourceInfos_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , layout{ layout_ } + , resourceInfoCount{ resourceInfoCount_ } + , pResourceInfos{ pResourceInfos_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineCreateInfoARM( DataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineCreateInfoARM( VkDataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DataGraphPipelineCreateInfoARM( PipelineCreateFlags2KHR flags_, + PipelineLayout layout_, + ArrayProxyNoTemporaries const & resourceInfos_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , layout( layout_ ) + , resourceInfoCount( static_cast( resourceInfos_.size() ) ) + , pResourceInfos( resourceInfos_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DataGraphPipelineCreateInfoARM & operator=( DataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineCreateInfoARM & operator=( VkDataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setFlags( PipelineCreateFlags2KHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setFlags( PipelineCreateFlags2KHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setResourceInfoCount( uint32_t resourceInfoCount_ ) & VULKAN_HPP_NOEXCEPT + { + resourceInfoCount = resourceInfoCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setResourceInfoCount( uint32_t resourceInfoCount_ ) && VULKAN_HPP_NOEXCEPT + { + resourceInfoCount = resourceInfoCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setPResourceInfos( const DataGraphPipelineResourceInfoARM * pResourceInfos_ ) & VULKAN_HPP_NOEXCEPT + { + pResourceInfos = pResourceInfos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setPResourceInfos( const DataGraphPipelineResourceInfoARM * pResourceInfos_ ) && + VULKAN_HPP_NOEXCEPT + { + pResourceInfos = pResourceInfos_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DataGraphPipelineCreateInfoARM & + setResourceInfos( ArrayProxyNoTemporaries const & resourceInfos_ ) VULKAN_HPP_NOEXCEPT + { + resourceInfoCount = static_cast( resourceInfos_.size() ); + pResourceInfos = resourceInfos_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, layout, resourceInfoCount, pResourceInfos ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineCreateInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( layout == rhs.layout ) && + ( resourceInfoCount == rhs.resourceInfoCount ) && ( pResourceInfos == rhs.pResourceInfos ); +# endif + } + + bool operator!=( DataGraphPipelineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineCreateInfoARM; + const void * pNext = {}; + PipelineCreateFlags2KHR flags = {}; + PipelineLayout layout = {}; + uint32_t resourceInfoCount = {}; + const DataGraphPipelineResourceInfoARM * pResourceInfos = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineCreateInfoARM; + }; + + // wrapper struct for struct VkDataGraphPipelineDispatchInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineDispatchInfoARM.html + struct DataGraphPipelineDispatchInfoARM + { + using NativeType = VkDataGraphPipelineDispatchInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineDispatchInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineDispatchInfoARM( DataGraphPipelineDispatchFlagsARM flags_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineDispatchInfoARM( DataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineDispatchInfoARM( VkDataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineDispatchInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineDispatchInfoARM & operator=( DataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineDispatchInfoARM & operator=( VkDataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM & setFlags( DataGraphPipelineDispatchFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM && setFlags( DataGraphPipelineDispatchFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineDispatchInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineDispatchInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineDispatchInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineDispatchInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineDispatchInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineDispatchInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( DataGraphPipelineDispatchInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineDispatchInfoARM; + void * pNext = {}; + DataGraphPipelineDispatchFlagsARM flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineDispatchInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineDispatchInfoARM; + }; + + // wrapper struct for struct VkDataGraphPipelineIdentifierCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineIdentifierCreateInfoARM.html + struct DataGraphPipelineIdentifierCreateInfoARM + { + using NativeType = VkDataGraphPipelineIdentifierCreateInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineIdentifierCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineIdentifierCreateInfoARM( uint32_t identifierSize_ = {}, + const uint8_t * pIdentifier_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , identifierSize{ identifierSize_ } + , pIdentifier{ pIdentifier_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineIdentifierCreateInfoARM( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineIdentifierCreateInfoARM( VkDataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineIdentifierCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DataGraphPipelineIdentifierCreateInfoARM( ArrayProxyNoTemporaries const & identifier_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), identifierSize( static_cast( identifier_.size() ) ), pIdentifier( identifier_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DataGraphPipelineIdentifierCreateInfoARM & operator=( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineIdentifierCreateInfoARM & operator=( VkDataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM & setIdentifierSize( uint32_t identifierSize_ ) & VULKAN_HPP_NOEXCEPT + { + identifierSize = identifierSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM && setIdentifierSize( uint32_t identifierSize_ ) && VULKAN_HPP_NOEXCEPT + { + identifierSize = identifierSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM & setPIdentifier( const uint8_t * pIdentifier_ ) & VULKAN_HPP_NOEXCEPT + { + pIdentifier = pIdentifier_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM && setPIdentifier( const uint8_t * pIdentifier_ ) && VULKAN_HPP_NOEXCEPT + { + pIdentifier = pIdentifier_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DataGraphPipelineIdentifierCreateInfoARM & setIdentifier( ArrayProxyNoTemporaries const & identifier_ ) VULKAN_HPP_NOEXCEPT + { + identifierSize = static_cast( identifier_.size() ); + pIdentifier = identifier_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineIdentifierCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineIdentifierCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineIdentifierCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineIdentifierCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, identifierSize, pIdentifier ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineIdentifierCreateInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( identifierSize == rhs.identifierSize ) && ( pIdentifier == rhs.pIdentifier ); +# endif + } + + bool operator!=( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineIdentifierCreateInfoARM; + const void * pNext = {}; + uint32_t identifierSize = {}; + const uint8_t * pIdentifier = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineIdentifierCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineIdentifierCreateInfoARM; + }; + + // wrapper struct for struct VkDataGraphPipelineInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineInfoARM.html + struct DataGraphPipelineInfoARM + { + using NativeType = VkDataGraphPipelineInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineInfoARM( Pipeline dataGraphPipeline_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dataGraphPipeline{ dataGraphPipeline_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineInfoARM( DataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineInfoARM( VkDataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineInfoARM & operator=( DataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineInfoARM & operator=( VkDataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM & setDataGraphPipeline( Pipeline dataGraphPipeline_ ) & VULKAN_HPP_NOEXCEPT + { + dataGraphPipeline = dataGraphPipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM && setDataGraphPipeline( Pipeline dataGraphPipeline_ ) && VULKAN_HPP_NOEXCEPT + { + dataGraphPipeline = dataGraphPipeline_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataGraphPipeline ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataGraphPipeline == rhs.dataGraphPipeline ); +# endif + } + + bool operator!=( DataGraphPipelineInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineInfoARM; + const void * pNext = {}; + Pipeline dataGraphPipeline = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineInfoARM; + }; + + // wrapper struct for struct VkDataGraphPipelinePropertyQueryResultARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelinePropertyQueryResultARM.html + struct DataGraphPipelinePropertyQueryResultARM + { + using NativeType = VkDataGraphPipelinePropertyQueryResultARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelinePropertyQueryResultARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelinePropertyQueryResultARM( DataGraphPipelinePropertyARM property_ = DataGraphPipelinePropertyARM::eCreationLog, + Bool32 isText_ = {}, + size_t dataSize_ = {}, + void * pData_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , property{ property_ } + , isText{ isText_ } + , dataSize{ dataSize_ } + , pData{ pData_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelinePropertyQueryResultARM( DataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelinePropertyQueryResultARM( VkDataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelinePropertyQueryResultARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + DataGraphPipelinePropertyQueryResultARM( DataGraphPipelinePropertyARM property_, + Bool32 isText_, + ArrayProxyNoTemporaries const & data_, + void * pNext_ = nullptr ) + : pNext( pNext_ ), property( property_ ), isText( isText_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DataGraphPipelinePropertyQueryResultARM & operator=( DataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelinePropertyQueryResultARM & operator=( VkDataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setProperty( DataGraphPipelinePropertyARM property_ ) & VULKAN_HPP_NOEXCEPT + { + property = property_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setProperty( DataGraphPipelinePropertyARM property_ ) && VULKAN_HPP_NOEXCEPT + { + property = property_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setIsText( Bool32 isText_ ) & VULKAN_HPP_NOEXCEPT + { + isText = isText_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setIsText( Bool32 isText_ ) && VULKAN_HPP_NOEXCEPT + { + isText = isText_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setPData( void * pData_ ) & VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setPData( void * pData_ ) && VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + DataGraphPipelinePropertyQueryResultARM & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT + { + dataSize = data_.size() * sizeof( T ); + pData = data_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelinePropertyQueryResultARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelinePropertyQueryResultARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelinePropertyQueryResultARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelinePropertyQueryResultARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, property, isText, dataSize, pData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelinePropertyQueryResultARM const & ) const = default; +#else + bool operator==( DataGraphPipelinePropertyQueryResultARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( property == rhs.property ) && ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) && + ( pData == rhs.pData ); +# endif + } + + bool operator!=( DataGraphPipelinePropertyQueryResultARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelinePropertyQueryResultARM; + void * pNext = {}; + DataGraphPipelinePropertyARM property = DataGraphPipelinePropertyARM::eCreationLog; + Bool32 isText = {}; + size_t dataSize = {}; + void * pData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelinePropertyQueryResultARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelinePropertyQueryResultARM; + }; + + // wrapper struct for struct VkDataGraphPipelineSessionBindPointRequirementARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointRequirementARM.html + struct DataGraphPipelineSessionBindPointRequirementARM + { + using NativeType = VkDataGraphPipelineSessionBindPointRequirementARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineSessionBindPointRequirementARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionBindPointRequirementARM( + DataGraphPipelineSessionBindPointARM bindPoint_ = DataGraphPipelineSessionBindPointARM::eTransient, + DataGraphPipelineSessionBindPointTypeARM bindPointType_ = DataGraphPipelineSessionBindPointTypeARM::eMemory, + uint32_t numObjects_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , bindPoint{ bindPoint_ } + , bindPointType{ bindPointType_ } + , numObjects{ numObjects_ } + { + } + + VULKAN_HPP_CONSTEXPR + DataGraphPipelineSessionBindPointRequirementARM( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineSessionBindPointRequirementARM( VkDataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineSessionBindPointRequirementARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineSessionBindPointRequirementARM & operator=( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineSessionBindPointRequirementARM & operator=( VkDataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDataGraphPipelineSessionBindPointRequirementARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionBindPointRequirementARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionBindPointRequirementARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionBindPointRequirementARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, bindPoint, bindPointType, numObjects ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineSessionBindPointRequirementARM const & ) const = default; +#else + bool operator==( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindPoint == rhs.bindPoint ) && ( bindPointType == rhs.bindPointType ) && + ( numObjects == rhs.numObjects ); +# endif + } + + bool operator!=( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineSessionBindPointRequirementARM; + void * pNext = {}; + DataGraphPipelineSessionBindPointARM bindPoint = DataGraphPipelineSessionBindPointARM::eTransient; + DataGraphPipelineSessionBindPointTypeARM bindPointType = DataGraphPipelineSessionBindPointTypeARM::eMemory; + uint32_t numObjects = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineSessionBindPointRequirementARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineSessionBindPointRequirementARM; + }; + + // wrapper struct for struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointRequirementsInfoARM.html + struct DataGraphPipelineSessionBindPointRequirementsInfoARM + { + using NativeType = VkDataGraphPipelineSessionBindPointRequirementsInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineSessionBindPointRequirementsInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionBindPointRequirementsInfoARM( DataGraphPipelineSessionARM session_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , session{ session_ } + { + } + + VULKAN_HPP_CONSTEXPR + DataGraphPipelineSessionBindPointRequirementsInfoARM( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineSessionBindPointRequirementsInfoARM( VkDataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineSessionBindPointRequirementsInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineSessionBindPointRequirementsInfoARM & + operator=( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineSessionBindPointRequirementsInfoARM & operator=( VkDataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM & setSession( DataGraphPipelineSessionARM session_ ) & VULKAN_HPP_NOEXCEPT + { + session = session_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM && setSession( DataGraphPipelineSessionARM session_ ) && VULKAN_HPP_NOEXCEPT + { + session = session_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, session ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineSessionBindPointRequirementsInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( session == rhs.session ); +# endif + } + + bool operator!=( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineSessionBindPointRequirementsInfoARM; + const void * pNext = {}; + DataGraphPipelineSessionARM session = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineSessionBindPointRequirementsInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineSessionBindPointRequirementsInfoARM; + }; + + // wrapper struct for struct VkDataGraphPipelineSessionCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionCreateInfoARM.html + struct DataGraphPipelineSessionCreateInfoARM + { + using NativeType = VkDataGraphPipelineSessionCreateInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineSessionCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionCreateInfoARM( DataGraphPipelineSessionCreateFlagsARM flags_ = {}, + Pipeline dataGraphPipeline_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , dataGraphPipeline{ dataGraphPipeline_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionCreateInfoARM( DataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineSessionCreateInfoARM( VkDataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineSessionCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineSessionCreateInfoARM & operator=( DataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineSessionCreateInfoARM & operator=( VkDataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM & setFlags( DataGraphPipelineSessionCreateFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM && setFlags( DataGraphPipelineSessionCreateFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM & setDataGraphPipeline( Pipeline dataGraphPipeline_ ) & VULKAN_HPP_NOEXCEPT + { + dataGraphPipeline = dataGraphPipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM && setDataGraphPipeline( Pipeline dataGraphPipeline_ ) && VULKAN_HPP_NOEXCEPT + { + dataGraphPipeline = dataGraphPipeline_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineSessionCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, dataGraphPipeline ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineSessionCreateInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineSessionCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dataGraphPipeline == rhs.dataGraphPipeline ); +# endif + } + + bool operator!=( DataGraphPipelineSessionCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineSessionCreateInfoARM; + const void * pNext = {}; + DataGraphPipelineSessionCreateFlagsARM flags = {}; + Pipeline dataGraphPipeline = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineSessionCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineSessionCreateInfoARM; + }; + + // wrapper struct for struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionMemoryRequirementsInfoARM.html + struct DataGraphPipelineSessionMemoryRequirementsInfoARM + { + using NativeType = VkDataGraphPipelineSessionMemoryRequirementsInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineSessionMemoryRequirementsInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DataGraphPipelineSessionMemoryRequirementsInfoARM( DataGraphPipelineSessionARM session_ = {}, + DataGraphPipelineSessionBindPointARM bindPoint_ = DataGraphPipelineSessionBindPointARM::eTransient, + uint32_t objectIndex_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , session{ session_ } + , bindPoint{ bindPoint_ } + , objectIndex{ objectIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR + DataGraphPipelineSessionMemoryRequirementsInfoARM( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineSessionMemoryRequirementsInfoARM( VkDataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineSessionMemoryRequirementsInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DataGraphPipelineSessionMemoryRequirementsInfoARM & + operator=( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineSessionMemoryRequirementsInfoARM & operator=( VkDataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setSession( DataGraphPipelineSessionARM session_ ) & VULKAN_HPP_NOEXCEPT + { + session = session_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setSession( DataGraphPipelineSessionARM session_ ) && VULKAN_HPP_NOEXCEPT + { + session = session_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) & + VULKAN_HPP_NOEXCEPT + { + bindPoint = bindPoint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) && + VULKAN_HPP_NOEXCEPT + { + bindPoint = bindPoint_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setObjectIndex( uint32_t objectIndex_ ) & VULKAN_HPP_NOEXCEPT + { + objectIndex = objectIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setObjectIndex( uint32_t objectIndex_ ) && VULKAN_HPP_NOEXCEPT + { + objectIndex = objectIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, session, bindPoint, objectIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphPipelineSessionMemoryRequirementsInfoARM const & ) const = default; +#else + bool operator==( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( session == rhs.session ) && ( bindPoint == rhs.bindPoint ) && + ( objectIndex == rhs.objectIndex ); +# endif + } + + bool operator!=( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphPipelineSessionMemoryRequirementsInfoARM; + const void * pNext = {}; + DataGraphPipelineSessionARM session = {}; + DataGraphPipelineSessionBindPointARM bindPoint = DataGraphPipelineSessionBindPointARM::eTransient; + uint32_t objectIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineSessionMemoryRequirementsInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineSessionMemoryRequirementsInfoARM; + }; + + // wrapper struct for struct VkDataGraphPipelineShaderModuleCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineShaderModuleCreateInfoARM.html + struct DataGraphPipelineShaderModuleCreateInfoARM + { + using NativeType = VkDataGraphPipelineShaderModuleCreateInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineShaderModuleCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphPipelineShaderModuleCreateInfoARM( ShaderModule module_ = {}, + const char * pName_ = {}, + const SpecializationInfo * pSpecializationInfo_ = {}, + uint32_t constantCount_ = {}, + const DataGraphPipelineConstantARM * pConstants_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , module{ module_ } + , pName{ pName_ } + , pSpecializationInfo{ pSpecializationInfo_ } + , constantCount{ constantCount_ } + , pConstants{ pConstants_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphPipelineShaderModuleCreateInfoARM( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphPipelineShaderModuleCreateInfoARM( VkDataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphPipelineShaderModuleCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DataGraphPipelineShaderModuleCreateInfoARM( ShaderModule module_, + const char * pName_, + const SpecializationInfo * pSpecializationInfo_, + ArrayProxyNoTemporaries const & constants_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , module( module_ ) + , pName( pName_ ) + , pSpecializationInfo( pSpecializationInfo_ ) + , constantCount( static_cast( constants_.size() ) ) + , pConstants( constants_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DataGraphPipelineShaderModuleCreateInfoARM & operator=( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphPipelineShaderModuleCreateInfoARM & operator=( VkDataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setModule( ShaderModule module_ ) & VULKAN_HPP_NOEXCEPT + { + module = module_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setModule( ShaderModule module_ ) && VULKAN_HPP_NOEXCEPT + { + module = module_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pSpecializationInfo = pSpecializationInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pSpecializationInfo = pSpecializationInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setConstantCount( uint32_t constantCount_ ) & VULKAN_HPP_NOEXCEPT + { + constantCount = constantCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setConstantCount( uint32_t constantCount_ ) && VULKAN_HPP_NOEXCEPT + { + constantCount = constantCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPConstants( const DataGraphPipelineConstantARM * pConstants_ ) & VULKAN_HPP_NOEXCEPT + { + pConstants = pConstants_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPConstants( const DataGraphPipelineConstantARM * pConstants_ ) && + VULKAN_HPP_NOEXCEPT + { + pConstants = pConstants_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DataGraphPipelineShaderModuleCreateInfoARM & + setConstants( ArrayProxyNoTemporaries const & constants_ ) VULKAN_HPP_NOEXCEPT + { + constantCount = static_cast( constants_.size() ); + pConstants = constants_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphPipelineShaderModuleCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineShaderModuleCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphPipelineShaderModuleCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphPipelineShaderModuleCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, module, pName, pSpecializationInfo, constantCount, pConstants ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = module <=> rhs.module; cmp != 0 ) + return cmp; + if ( pName != rhs.pName ) + if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = pSpecializationInfo <=> rhs.pSpecializationInfo; cmp != 0 ) + return cmp; + if ( auto cmp = constantCount <=> rhs.constantCount; cmp != 0 ) + return cmp; + if ( auto cmp = pConstants <=> rhs.pConstants; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && + ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( pSpecializationInfo == rhs.pSpecializationInfo ) && + ( constantCount == rhs.constantCount ) && ( pConstants == rhs.pConstants ); + } + + bool operator!=( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDataGraphPipelineShaderModuleCreateInfoARM; + const void * pNext = {}; + ShaderModule module = {}; + const char * pName = {}; + const SpecializationInfo * pSpecializationInfo = {}; + uint32_t constantCount = {}; + const DataGraphPipelineConstantARM * pConstants = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphPipelineShaderModuleCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphPipelineShaderModuleCreateInfoARM; + }; + + // wrapper struct for struct VkPhysicalDeviceDataGraphProcessingEngineARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphProcessingEngineARM.html + struct PhysicalDeviceDataGraphProcessingEngineARM + { + using NativeType = VkPhysicalDeviceDataGraphProcessingEngineARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphProcessingEngineARM( + PhysicalDeviceDataGraphProcessingEngineTypeARM type_ = PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault, + Bool32 isForeign_ = {} ) VULKAN_HPP_NOEXCEPT + : type{ type_ } + , isForeign{ isForeign_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphProcessingEngineARM( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDataGraphProcessingEngineARM( VkPhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDataGraphProcessingEngineARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDataGraphProcessingEngineARM & operator=( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDataGraphProcessingEngineARM & operator=( VkPhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM & setType( PhysicalDeviceDataGraphProcessingEngineTypeARM type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM && setType( PhysicalDeviceDataGraphProcessingEngineTypeARM type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM & setIsForeign( Bool32 isForeign_ ) & VULKAN_HPP_NOEXCEPT + { + isForeign = isForeign_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM && setIsForeign( Bool32 isForeign_ ) && VULKAN_HPP_NOEXCEPT + { + isForeign = isForeign_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDataGraphProcessingEngineARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphProcessingEngineARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphProcessingEngineARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphProcessingEngineARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( type, isForeign ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDataGraphProcessingEngineARM const & ) const = default; +#else + bool operator==( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( type == rhs.type ) && ( isForeign == rhs.isForeign ); +# endif + } + + bool operator!=( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + PhysicalDeviceDataGraphProcessingEngineTypeARM type = PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault; + Bool32 isForeign = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDataGraphProcessingEngineARM; + }; +#endif + + // wrapper struct for struct VkDataGraphProcessingEngineCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphProcessingEngineCreateInfoARM.html + struct DataGraphProcessingEngineCreateInfoARM + { + using NativeType = VkDataGraphProcessingEngineCreateInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphProcessingEngineCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DataGraphProcessingEngineCreateInfoARM( uint32_t processingEngineCount_ = {}, + PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , processingEngineCount{ processingEngineCount_ } + , pProcessingEngines{ pProcessingEngines_ } + { + } + + VULKAN_HPP_CONSTEXPR DataGraphProcessingEngineCreateInfoARM( DataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DataGraphProcessingEngineCreateInfoARM( VkDataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DataGraphProcessingEngineCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DataGraphProcessingEngineCreateInfoARM( ArrayProxyNoTemporaries const & processingEngines_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), processingEngineCount( static_cast( processingEngines_.size() ) ), pProcessingEngines( processingEngines_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DataGraphProcessingEngineCreateInfoARM & operator=( DataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DataGraphProcessingEngineCreateInfoARM & operator=( VkDataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM & setProcessingEngineCount( uint32_t processingEngineCount_ ) & VULKAN_HPP_NOEXCEPT + { + processingEngineCount = processingEngineCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM && setProcessingEngineCount( uint32_t processingEngineCount_ ) && VULKAN_HPP_NOEXCEPT + { + processingEngineCount = processingEngineCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM & setPProcessingEngines( PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines_ ) & + VULKAN_HPP_NOEXCEPT + { + pProcessingEngines = pProcessingEngines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM && + setPProcessingEngines( PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines_ ) && + VULKAN_HPP_NOEXCEPT + { + pProcessingEngines = pProcessingEngines_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DataGraphProcessingEngineCreateInfoARM & + setProcessingEngines( ArrayProxyNoTemporaries const & processingEngines_ ) VULKAN_HPP_NOEXCEPT + { + processingEngineCount = static_cast( processingEngines_.size() ); + pProcessingEngines = processingEngines_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDataGraphProcessingEngineCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphProcessingEngineCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDataGraphProcessingEngineCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDataGraphProcessingEngineCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, processingEngineCount, pProcessingEngines ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DataGraphProcessingEngineCreateInfoARM const & ) const = default; +#else + bool operator==( DataGraphProcessingEngineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( processingEngineCount == rhs.processingEngineCount ) && + ( pProcessingEngines == rhs.pProcessingEngines ); +# endif + } + + bool operator!=( DataGraphProcessingEngineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDataGraphProcessingEngineCreateInfoARM; + const void * pNext = {}; + uint32_t processingEngineCount = {}; + PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DataGraphProcessingEngineCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DataGraphProcessingEngineCreateInfoARM; + }; + + // wrapper struct for struct VkDebugMarkerMarkerInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugMarkerMarkerInfoEXT.html + struct DebugMarkerMarkerInfoEXT + { + using NativeType = VkDebugMarkerMarkerInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerMarkerInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + DebugMarkerMarkerInfoEXT( const char * pMarkerName_ = {}, std::array const & color_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pMarkerName{ pMarkerName_ } + , color{ color_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DebugMarkerMarkerInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + DebugMarkerMarkerInfoEXT & operator=( DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DebugMarkerMarkerInfoEXT & operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT & setPMarkerName( const char * pMarkerName_ ) & VULKAN_HPP_NOEXCEPT + { + pMarkerName = pMarkerName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT && setPMarkerName( const char * pMarkerName_ ) && VULKAN_HPP_NOEXCEPT + { + pMarkerName = pMarkerName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT & setColor( std::array color_ ) & VULKAN_HPP_NOEXCEPT + { + color = color_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT && setColor( std::array color_ ) && VULKAN_HPP_NOEXCEPT + { + color = color_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDebugMarkerMarkerInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugMarkerMarkerInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugMarkerMarkerInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDebugMarkerMarkerInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pMarkerName, color ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::partial_ordering operator<=>( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( pMarkerName != rhs.pMarkerName ) + if ( auto cmp = strcmp( pMarkerName, rhs.pMarkerName ); cmp != 0 ) + return ( cmp < 0 ) ? std::partial_ordering::less : std::partial_ordering::greater; + if ( auto cmp = color <=> rhs.color; cmp != 0 ) + return cmp; + + return std::partial_ordering::equivalent; + } +#endif + + bool operator==( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ( pMarkerName == rhs.pMarkerName ) || ( strcmp( pMarkerName, rhs.pMarkerName ) == 0 ) ) && + ( color == rhs.color ); + } + + bool operator!=( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT; + const void * pNext = {}; + const char * pMarkerName = {}; + ArrayWrapper1D color = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DebugMarkerMarkerInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DebugMarkerMarkerInfoEXT; + }; + + // wrapper struct for struct VkDebugMarkerObjectNameInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugMarkerObjectNameInfoEXT.html + struct DebugMarkerObjectNameInfoEXT + { + using NativeType = VkDebugMarkerObjectNameInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerObjectNameInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, + uint64_t object_ = {}, + const char * pObjectName_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , objectType{ objectType_ } + , object{ object_ } + , pObjectName{ pObjectName_ } + { + } + + VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DebugMarkerObjectNameInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + DebugMarkerObjectNameInfoEXT & operator=( DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DebugMarkerObjectNameInfoEXT & operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ ) & VULKAN_HPP_NOEXCEPT + { + objectType = objectType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setObjectType( DebugReportObjectTypeEXT objectType_ ) && VULKAN_HPP_NOEXCEPT + { + objectType = objectType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setObject( uint64_t object_ ) & VULKAN_HPP_NOEXCEPT + { + object = object_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setObject( uint64_t object_ ) && VULKAN_HPP_NOEXCEPT + { + object = object_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setPObjectName( const char * pObjectName_ ) & VULKAN_HPP_NOEXCEPT + { + pObjectName = pObjectName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setPObjectName( const char * pObjectName_ ) && VULKAN_HPP_NOEXCEPT + { + pObjectName = pObjectName_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDebugMarkerObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugMarkerObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugMarkerObjectNameInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDebugMarkerObjectNameInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, object, pObjectName ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = objectType <=> rhs.objectType; cmp != 0 ) + return cmp; + if ( auto cmp = object <=> rhs.object; cmp != 0 ) + return cmp; + if ( pObjectName != rhs.pObjectName ) + if ( auto cmp = strcmp( pObjectName, rhs.pObjectName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( object == rhs.object ) && + ( ( pObjectName == rhs.pObjectName ) || ( strcmp( pObjectName, rhs.pObjectName ) == 0 ) ); + } + + bool operator!=( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT; + const void * pNext = {}; + DebugReportObjectTypeEXT objectType = DebugReportObjectTypeEXT::eUnknown; + uint64_t object = {}; + const char * pObjectName = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DebugMarkerObjectNameInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DebugMarkerObjectNameInfoEXT; + }; + + // wrapper struct for struct VkDebugMarkerObjectTagInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugMarkerObjectTagInfoEXT.html + struct DebugMarkerObjectTagInfoEXT + { + using NativeType = VkDebugMarkerObjectTagInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerObjectTagInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, + uint64_t object_ = {}, + uint64_t tagName_ = {}, + size_t tagSize_ = {}, + const void * pTag_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , objectType{ objectType_ } + , object{ object_ } + , tagName{ tagName_ } + , tagSize{ tagSize_ } + , pTag{ pTag_ } + { + } + + VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DebugMarkerObjectTagInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + DebugMarkerObjectTagInfoEXT( + DebugReportObjectTypeEXT objectType_, uint64_t object_, uint64_t tagName_, ArrayProxyNoTemporaries const & tag_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), objectType( objectType_ ), object( object_ ), tagName( tagName_ ), tagSize( tag_.size() * sizeof( T ) ), pTag( tag_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DebugMarkerObjectTagInfoEXT & operator=( DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DebugMarkerObjectTagInfoEXT & operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ ) & VULKAN_HPP_NOEXCEPT + { + objectType = objectType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setObjectType( DebugReportObjectTypeEXT objectType_ ) && VULKAN_HPP_NOEXCEPT + { + objectType = objectType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setObject( uint64_t object_ ) & VULKAN_HPP_NOEXCEPT + { + object = object_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setObject( uint64_t object_ ) && VULKAN_HPP_NOEXCEPT + { + object = object_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setTagName( uint64_t tagName_ ) & VULKAN_HPP_NOEXCEPT + { + tagName = tagName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setTagName( uint64_t tagName_ ) && VULKAN_HPP_NOEXCEPT + { + tagName = tagName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setTagSize( size_t tagSize_ ) & VULKAN_HPP_NOEXCEPT + { + tagSize = tagSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setTagSize( size_t tagSize_ ) && VULKAN_HPP_NOEXCEPT + { + tagSize = tagSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setPTag( const void * pTag_ ) & VULKAN_HPP_NOEXCEPT + { + pTag = pTag_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setPTag( const void * pTag_ ) && VULKAN_HPP_NOEXCEPT + { + pTag = pTag_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + DebugMarkerObjectTagInfoEXT & setTag( ArrayProxyNoTemporaries const & tag_ ) VULKAN_HPP_NOEXCEPT + { + tagSize = tag_.size() * sizeof( T ); + pTag = tag_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDebugMarkerObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugMarkerObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugMarkerObjectTagInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDebugMarkerObjectTagInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, object, tagName, tagSize, pTag ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DebugMarkerObjectTagInfoEXT const & ) const = default; +#else + bool operator==( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( object == rhs.object ) && ( tagName == rhs.tagName ) && + ( tagSize == rhs.tagSize ) && ( pTag == rhs.pTag ); +# endif + } + + bool operator!=( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT; + const void * pNext = {}; + DebugReportObjectTypeEXT objectType = DebugReportObjectTypeEXT::eUnknown; + uint64_t object = {}; + uint64_t tagName = {}; + size_t tagSize = {}; + const void * pTag = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DebugMarkerObjectTagInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DebugMarkerObjectTagInfoEXT; + }; + + typedef Bool32( VKAPI_PTR * PFN_DebugReportCallbackEXT )( DebugReportFlagsEXT flags, + DebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char * pLayerPrefix, + const char * pMessage, + void * pUserData ); + + // wrapper struct for struct VkDebugReportCallbackCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportCallbackCreateInfoEXT.html + struct DebugReportCallbackCreateInfoEXT + { + using NativeType = VkDebugReportCallbackCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugReportCallbackCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = {}, + PFN_DebugReportCallbackEXT pfnCallback_ = {}, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pfnCallback{ pfnCallback_ } + , pUserData{ pUserData_ } + { + } + + VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DebugReportCallbackCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + + DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_, + PFN_vkDebugReportCallbackEXT pfnCallback_, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : DebugReportCallbackCreateInfoEXT( flags_, reinterpret_cast( pfnCallback_ ), pUserData_, pNext_ ) + { + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif + + DebugReportCallbackCreateInfoEXT & operator=( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DebugReportCallbackCreateInfoEXT & operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setFlags( DebugReportFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setFlags( DebugReportFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_DebugReportCallbackEXT pfnCallback_ ) & VULKAN_HPP_NOEXCEPT + { + pfnCallback = pfnCallback_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setPfnCallback( PFN_DebugReportCallbackEXT pfnCallback_ ) && VULKAN_HPP_NOEXCEPT + { + pfnCallback = pfnCallback_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT + { + pUserData = pUserData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT + { + pUserData = pUserData_; + return std::move( *this ); + } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnCallback( reinterpret_cast( pfnCallback_ ) ); + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugReportCallbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugReportCallbackCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDebugReportCallbackCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pfnCallback, pUserData ); + } +#endif + + bool operator==( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +#if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +#else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pfnCallback == rhs.pfnCallback ) && ( pUserData == rhs.pUserData ); +#endif + } + + bool operator!=( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; + const void * pNext = {}; + DebugReportFlagsEXT flags = {}; + PFN_DebugReportCallbackEXT pfnCallback = {}; + void * pUserData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DebugReportCallbackCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DebugReportCallbackCreateInfoEXT; + }; + + // wrapper struct for struct VkDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsLabelEXT.html + struct DebugUtilsLabelEXT + { + using NativeType = VkDebugUtilsLabelEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsLabelEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + DebugUtilsLabelEXT( const char * pLabelName_ = {}, std::array const & color_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pLabelName{ pLabelName_ } + , color{ color_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DebugUtilsLabelEXT( *reinterpret_cast( &rhs ) ) {} + + DebugUtilsLabelEXT & operator=( DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DebugUtilsLabelEXT & operator=( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT & setPLabelName( const char * pLabelName_ ) & VULKAN_HPP_NOEXCEPT + { + pLabelName = pLabelName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT && setPLabelName( const char * pLabelName_ ) && VULKAN_HPP_NOEXCEPT + { + pLabelName = pLabelName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT & setColor( std::array color_ ) & VULKAN_HPP_NOEXCEPT + { + color = color_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT && setColor( std::array color_ ) && VULKAN_HPP_NOEXCEPT + { + color = color_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDebugUtilsLabelEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsLabelEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsLabelEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDebugUtilsLabelEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pLabelName, color ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::partial_ordering operator<=>( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( pLabelName != rhs.pLabelName ) + if ( auto cmp = strcmp( pLabelName, rhs.pLabelName ); cmp != 0 ) + return ( cmp < 0 ) ? std::partial_ordering::less : std::partial_ordering::greater; + if ( auto cmp = color <=> rhs.color; cmp != 0 ) + return cmp; + + return std::partial_ordering::equivalent; + } +#endif + + bool operator==( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ( pLabelName == rhs.pLabelName ) || ( strcmp( pLabelName, rhs.pLabelName ) == 0 ) ) && + ( color == rhs.color ); + } + + bool operator!=( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDebugUtilsLabelEXT; + const void * pNext = {}; + const char * pLabelName = {}; + ArrayWrapper1D color = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DebugUtilsLabelEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DebugUtilsLabelEXT; + }; + + // wrapper struct for struct VkDebugUtilsObjectNameInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsObjectNameInfoEXT.html + struct DebugUtilsObjectNameInfoEXT + { + using NativeType = VkDebugUtilsObjectNameInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsObjectNameInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown, + uint64_t objectHandle_ = {}, + const char * pObjectName_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , objectType{ objectType_ } + , objectHandle{ objectHandle_ } + , pObjectName{ pObjectName_ } + { + } + + VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DebugUtilsObjectNameInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + DebugUtilsObjectNameInfoEXT & operator=( DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DebugUtilsObjectNameInfoEXT & operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setObjectType( ObjectType objectType_ ) & VULKAN_HPP_NOEXCEPT + { + objectType = objectType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setObjectType( ObjectType objectType_ ) && VULKAN_HPP_NOEXCEPT + { + objectType = objectType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setObjectHandle( uint64_t objectHandle_ ) & VULKAN_HPP_NOEXCEPT + { + objectHandle = objectHandle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setObjectHandle( uint64_t objectHandle_ ) && VULKAN_HPP_NOEXCEPT + { + objectHandle = objectHandle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setPObjectName( const char * pObjectName_ ) & VULKAN_HPP_NOEXCEPT + { + pObjectName = pObjectName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setPObjectName( const char * pObjectName_ ) && VULKAN_HPP_NOEXCEPT + { + pObjectName = pObjectName_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDebugUtilsObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsObjectNameInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDebugUtilsObjectNameInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, objectHandle, pObjectName ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = objectType <=> rhs.objectType; cmp != 0 ) + return cmp; + if ( auto cmp = objectHandle <=> rhs.objectHandle; cmp != 0 ) + return cmp; + if ( pObjectName != rhs.pObjectName ) + if ( auto cmp = strcmp( pObjectName, rhs.pObjectName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) && + ( ( pObjectName == rhs.pObjectName ) || ( strcmp( pObjectName, rhs.pObjectName ) == 0 ) ); + } + + bool operator!=( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT; + const void * pNext = {}; + ObjectType objectType = ObjectType::eUnknown; + uint64_t objectHandle = {}; + const char * pObjectName = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DebugUtilsObjectNameInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DebugUtilsObjectNameInfoEXT; + }; + + // wrapper struct for struct VkDebugUtilsMessengerCallbackDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCallbackDataEXT.html + struct DebugUtilsMessengerCallbackDataEXT + { + using NativeType = VkDebugUtilsMessengerCallbackDataEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsMessengerCallbackDataEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_ = {}, + const char * pMessageIdName_ = {}, + int32_t messageIdNumber_ = {}, + const char * pMessage_ = {}, + uint32_t queueLabelCount_ = {}, + const DebugUtilsLabelEXT * pQueueLabels_ = {}, + uint32_t cmdBufLabelCount_ = {}, + const DebugUtilsLabelEXT * pCmdBufLabels_ = {}, + uint32_t objectCount_ = {}, + const DebugUtilsObjectNameInfoEXT * pObjects_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pMessageIdName{ pMessageIdName_ } + , messageIdNumber{ messageIdNumber_ } + , pMessage{ pMessage_ } + , queueLabelCount{ queueLabelCount_ } + , pQueueLabels{ pQueueLabels_ } + , cmdBufLabelCount{ cmdBufLabelCount_ } + , pCmdBufLabels{ pCmdBufLabels_ } + , objectCount{ objectCount_ } + , pObjects{ pObjects_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DebugUtilsMessengerCallbackDataEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_, + const char * pMessageIdName_, + int32_t messageIdNumber_, + const char * pMessage_, + ArrayProxyNoTemporaries const & queueLabels_, + ArrayProxyNoTemporaries const & cmdBufLabels_ = {}, + ArrayProxyNoTemporaries const & objects_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , pMessageIdName( pMessageIdName_ ) + , messageIdNumber( messageIdNumber_ ) + , pMessage( pMessage_ ) + , queueLabelCount( static_cast( queueLabels_.size() ) ) + , pQueueLabels( queueLabels_.data() ) + , cmdBufLabelCount( static_cast( cmdBufLabels_.size() ) ) + , pCmdBufLabels( cmdBufLabels_.data() ) + , objectCount( static_cast( objects_.size() ) ) + , pObjects( objects_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DebugUtilsMessengerCallbackDataEXT & operator=( DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DebugUtilsMessengerCallbackDataEXT & operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPMessageIdName( const char * pMessageIdName_ ) & VULKAN_HPP_NOEXCEPT + { + pMessageIdName = pMessageIdName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPMessageIdName( const char * pMessageIdName_ ) && VULKAN_HPP_NOEXCEPT + { + pMessageIdName = pMessageIdName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setMessageIdNumber( int32_t messageIdNumber_ ) & VULKAN_HPP_NOEXCEPT + { + messageIdNumber = messageIdNumber_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setMessageIdNumber( int32_t messageIdNumber_ ) && VULKAN_HPP_NOEXCEPT + { + messageIdNumber = messageIdNumber_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPMessage( const char * pMessage_ ) & VULKAN_HPP_NOEXCEPT + { + pMessage = pMessage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPMessage( const char * pMessage_ ) && VULKAN_HPP_NOEXCEPT + { + pMessage = pMessage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setQueueLabelCount( uint32_t queueLabelCount_ ) & VULKAN_HPP_NOEXCEPT + { + queueLabelCount = queueLabelCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setQueueLabelCount( uint32_t queueLabelCount_ ) && VULKAN_HPP_NOEXCEPT + { + queueLabelCount = queueLabelCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPQueueLabels( const DebugUtilsLabelEXT * pQueueLabels_ ) & VULKAN_HPP_NOEXCEPT + { + pQueueLabels = pQueueLabels_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPQueueLabels( const DebugUtilsLabelEXT * pQueueLabels_ ) && VULKAN_HPP_NOEXCEPT + { + pQueueLabels = pQueueLabels_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DebugUtilsMessengerCallbackDataEXT & setQueueLabels( ArrayProxyNoTemporaries const & queueLabels_ ) VULKAN_HPP_NOEXCEPT + { + queueLabelCount = static_cast( queueLabels_.size() ); + pQueueLabels = queueLabels_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setCmdBufLabelCount( uint32_t cmdBufLabelCount_ ) & VULKAN_HPP_NOEXCEPT + { + cmdBufLabelCount = cmdBufLabelCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setCmdBufLabelCount( uint32_t cmdBufLabelCount_ ) && VULKAN_HPP_NOEXCEPT + { + cmdBufLabelCount = cmdBufLabelCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPCmdBufLabels( const DebugUtilsLabelEXT * pCmdBufLabels_ ) & VULKAN_HPP_NOEXCEPT + { + pCmdBufLabels = pCmdBufLabels_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPCmdBufLabels( const DebugUtilsLabelEXT * pCmdBufLabels_ ) && VULKAN_HPP_NOEXCEPT + { + pCmdBufLabels = pCmdBufLabels_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DebugUtilsMessengerCallbackDataEXT & setCmdBufLabels( ArrayProxyNoTemporaries const & cmdBufLabels_ ) VULKAN_HPP_NOEXCEPT + { + cmdBufLabelCount = static_cast( cmdBufLabels_.size() ); + pCmdBufLabels = cmdBufLabels_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setObjectCount( uint32_t objectCount_ ) & VULKAN_HPP_NOEXCEPT + { + objectCount = objectCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setObjectCount( uint32_t objectCount_ ) && VULKAN_HPP_NOEXCEPT + { + objectCount = objectCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPObjects( const DebugUtilsObjectNameInfoEXT * pObjects_ ) & VULKAN_HPP_NOEXCEPT + { + pObjects = pObjects_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPObjects( const DebugUtilsObjectNameInfoEXT * pObjects_ ) && VULKAN_HPP_NOEXCEPT + { + pObjects = pObjects_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DebugUtilsMessengerCallbackDataEXT & setObjects( ArrayProxyNoTemporaries const & objects_ ) VULKAN_HPP_NOEXCEPT + { + objectCount = static_cast( objects_.size() ); + pObjects = objects_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDebugUtilsMessengerCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsMessengerCallbackDataEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsMessengerCallbackDataEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDebugUtilsMessengerCallbackDataEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, flags, pMessageIdName, messageIdNumber, pMessage, queueLabelCount, pQueueLabels, cmdBufLabelCount, pCmdBufLabels, objectCount, pObjects ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( pMessageIdName != rhs.pMessageIdName ) + if ( auto cmp = strcmp( pMessageIdName, rhs.pMessageIdName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = messageIdNumber <=> rhs.messageIdNumber; cmp != 0 ) + return cmp; + if ( pMessage != rhs.pMessage ) + if ( auto cmp = strcmp( pMessage, rhs.pMessage ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = queueLabelCount <=> rhs.queueLabelCount; cmp != 0 ) + return cmp; + if ( auto cmp = pQueueLabels <=> rhs.pQueueLabels; cmp != 0 ) + return cmp; + if ( auto cmp = cmdBufLabelCount <=> rhs.cmdBufLabelCount; cmp != 0 ) + return cmp; + if ( auto cmp = pCmdBufLabels <=> rhs.pCmdBufLabels; cmp != 0 ) + return cmp; + if ( auto cmp = objectCount <=> rhs.objectCount; cmp != 0 ) + return cmp; + if ( auto cmp = pObjects <=> rhs.pObjects; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( ( pMessageIdName == rhs.pMessageIdName ) || ( strcmp( pMessageIdName, rhs.pMessageIdName ) == 0 ) ) && + ( messageIdNumber == rhs.messageIdNumber ) && ( ( pMessage == rhs.pMessage ) || ( strcmp( pMessage, rhs.pMessage ) == 0 ) ) && + ( queueLabelCount == rhs.queueLabelCount ) && ( pQueueLabels == rhs.pQueueLabels ) && ( cmdBufLabelCount == rhs.cmdBufLabelCount ) && + ( pCmdBufLabels == rhs.pCmdBufLabels ) && ( objectCount == rhs.objectCount ) && ( pObjects == rhs.pObjects ); + } + + bool operator!=( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT; + const void * pNext = {}; + DebugUtilsMessengerCallbackDataFlagsEXT flags = {}; + const char * pMessageIdName = {}; + int32_t messageIdNumber = {}; + const char * pMessage = {}; + uint32_t queueLabelCount = {}; + const DebugUtilsLabelEXT * pQueueLabels = {}; + uint32_t cmdBufLabelCount = {}; + const DebugUtilsLabelEXT * pCmdBufLabels = {}; + uint32_t objectCount = {}; + const DebugUtilsObjectNameInfoEXT * pObjects = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DebugUtilsMessengerCallbackDataEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DebugUtilsMessengerCallbackDataEXT; + }; + + typedef Bool32( VKAPI_PTR * PFN_DebugUtilsMessengerCallbackEXT )( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + DebugUtilsMessageTypeFlagsEXT messageTypes, + const DebugUtilsMessengerCallbackDataEXT * pCallbackData, + void * pUserData ); + + // wrapper struct for struct VkDebugUtilsMessengerCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCreateInfoEXT.html + struct DebugUtilsMessengerCreateInfoEXT + { + using NativeType = VkDebugUtilsMessengerCreateInfoEXT; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsMessengerCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_ = {}, + DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = {}, + DebugUtilsMessageTypeFlagsEXT messageType_ = {}, + PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ = {}, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , messageSeverity{ messageSeverity_ } + , messageType{ messageType_ } + , pfnUserCallback{ pfnUserCallback_ } + , pUserData{ pUserData_ } + { + } + + VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DebugUtilsMessengerCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + + DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_, + DebugUtilsMessageSeverityFlagsEXT messageSeverity_, + DebugUtilsMessageTypeFlagsEXT messageType_, + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : DebugUtilsMessengerCreateInfoEXT( + flags_, messageSeverity_, messageType_, reinterpret_cast( pfnUserCallback_ ), pUserData_, pNext_ ) + { + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif + + DebugUtilsMessengerCreateInfoEXT & operator=( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DebugUtilsMessengerCreateInfoEXT & operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ ) & VULKAN_HPP_NOEXCEPT + { + messageSeverity = messageSeverity_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ ) && VULKAN_HPP_NOEXCEPT + { + messageSeverity = messageSeverity_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ ) & VULKAN_HPP_NOEXCEPT + { + messageType = messageType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ ) && VULKAN_HPP_NOEXCEPT + { + messageType = messageType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ ) & VULKAN_HPP_NOEXCEPT + { + pfnUserCallback = pfnUserCallback_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setPfnUserCallback( PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ ) && VULKAN_HPP_NOEXCEPT + { + pfnUserCallback = pfnUserCallback_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT + { + pUserData = pUserData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT + { + pUserData = pUserData_; + return std::move( *this ); + } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnUserCallback( reinterpret_cast( pfnUserCallback_ ) ); + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsMessengerCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsMessengerCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDebugUtilsMessengerCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, messageSeverity, messageType, pfnUserCallback, pUserData ); + } +#endif + + bool operator==( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +#if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +#else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( messageSeverity == rhs.messageSeverity ) && + ( messageType == rhs.messageType ) && ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData ); +#endif + } + + bool operator!=( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT; + const void * pNext = {}; + DebugUtilsMessengerCreateFlagsEXT flags = {}; + DebugUtilsMessageSeverityFlagsEXT messageSeverity = {}; + DebugUtilsMessageTypeFlagsEXT messageType = {}; + PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback = {}; + void * pUserData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DebugUtilsMessengerCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DebugUtilsMessengerCreateInfoEXT; + }; + + // wrapper struct for struct VkDebugUtilsObjectTagInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsObjectTagInfoEXT.html + struct DebugUtilsObjectTagInfoEXT + { + using NativeType = VkDebugUtilsObjectTagInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsObjectTagInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown, + uint64_t objectHandle_ = {}, + uint64_t tagName_ = {}, + size_t tagSize_ = {}, + const void * pTag_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , objectType{ objectType_ } + , objectHandle{ objectHandle_ } + , tagName{ tagName_ } + , tagSize{ tagSize_ } + , pTag{ pTag_ } + { + } + + VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DebugUtilsObjectTagInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + DebugUtilsObjectTagInfoEXT( + ObjectType objectType_, uint64_t objectHandle_, uint64_t tagName_, ArrayProxyNoTemporaries const & tag_, const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , objectType( objectType_ ) + , objectHandle( objectHandle_ ) + , tagName( tagName_ ) + , tagSize( tag_.size() * sizeof( T ) ) + , pTag( tag_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DebugUtilsObjectTagInfoEXT & operator=( DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DebugUtilsObjectTagInfoEXT & operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setObjectType( ObjectType objectType_ ) & VULKAN_HPP_NOEXCEPT + { + objectType = objectType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setObjectType( ObjectType objectType_ ) && VULKAN_HPP_NOEXCEPT + { + objectType = objectType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setObjectHandle( uint64_t objectHandle_ ) & VULKAN_HPP_NOEXCEPT + { + objectHandle = objectHandle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setObjectHandle( uint64_t objectHandle_ ) && VULKAN_HPP_NOEXCEPT + { + objectHandle = objectHandle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setTagName( uint64_t tagName_ ) & VULKAN_HPP_NOEXCEPT + { + tagName = tagName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setTagName( uint64_t tagName_ ) && VULKAN_HPP_NOEXCEPT + { + tagName = tagName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setTagSize( size_t tagSize_ ) & VULKAN_HPP_NOEXCEPT + { + tagSize = tagSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setTagSize( size_t tagSize_ ) && VULKAN_HPP_NOEXCEPT + { + tagSize = tagSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setPTag( const void * pTag_ ) & VULKAN_HPP_NOEXCEPT + { + pTag = pTag_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setPTag( const void * pTag_ ) && VULKAN_HPP_NOEXCEPT + { + pTag = pTag_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + DebugUtilsObjectTagInfoEXT & setTag( ArrayProxyNoTemporaries const & tag_ ) VULKAN_HPP_NOEXCEPT + { + tagSize = tag_.size() * sizeof( T ); + pTag = tag_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDebugUtilsObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDebugUtilsObjectTagInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDebugUtilsObjectTagInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, objectType, objectHandle, tagName, tagSize, pTag ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DebugUtilsObjectTagInfoEXT const & ) const = default; +#else + bool operator==( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) && + ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) && ( pTag == rhs.pTag ); +# endif + } + + bool operator!=( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT; + const void * pNext = {}; + ObjectType objectType = ObjectType::eUnknown; + uint64_t objectHandle = {}; + uint64_t tagName = {}; + size_t tagSize = {}; + const void * pTag = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DebugUtilsObjectTagInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DebugUtilsObjectTagInfoEXT; + }; + + // wrapper struct for struct VkDecompressMemoryRegionEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDecompressMemoryRegionEXT.html + struct DecompressMemoryRegionEXT + { + using NativeType = VkDecompressMemoryRegionEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DecompressMemoryRegionEXT( DeviceAddress srcAddress_ = {}, + DeviceAddress dstAddress_ = {}, + DeviceSize compressedSize_ = {}, + DeviceSize decompressedSize_ = {} ) VULKAN_HPP_NOEXCEPT + : srcAddress{ srcAddress_ } + , dstAddress{ dstAddress_ } + , compressedSize{ compressedSize_ } + , decompressedSize{ decompressedSize_ } + { + } + + VULKAN_HPP_CONSTEXPR DecompressMemoryRegionEXT( DecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DecompressMemoryRegionEXT( VkDecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DecompressMemoryRegionEXT( *reinterpret_cast( &rhs ) ) + { + } + + DecompressMemoryRegionEXT & operator=( DecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DecompressMemoryRegionEXT & operator=( VkDecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT + { + srcAddress = srcAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT + { + srcAddress = srcAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setDstAddress( DeviceAddress dstAddress_ ) & VULKAN_HPP_NOEXCEPT + { + dstAddress = dstAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setDstAddress( DeviceAddress dstAddress_ ) && VULKAN_HPP_NOEXCEPT + { + dstAddress = dstAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setCompressedSize( DeviceSize compressedSize_ ) & VULKAN_HPP_NOEXCEPT + { + compressedSize = compressedSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setCompressedSize( DeviceSize compressedSize_ ) && VULKAN_HPP_NOEXCEPT + { + compressedSize = compressedSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setDecompressedSize( DeviceSize decompressedSize_ ) & VULKAN_HPP_NOEXCEPT + { + decompressedSize = decompressedSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setDecompressedSize( DeviceSize decompressedSize_ ) && VULKAN_HPP_NOEXCEPT + { + decompressedSize = decompressedSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDecompressMemoryRegionEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDecompressMemoryRegionEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDecompressMemoryRegionEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDecompressMemoryRegionEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcAddress, dstAddress, compressedSize, decompressedSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DecompressMemoryRegionEXT const & ) const = default; +#else + bool operator==( DecompressMemoryRegionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( srcAddress == rhs.srcAddress ) && ( dstAddress == rhs.dstAddress ) && ( compressedSize == rhs.compressedSize ) && + ( decompressedSize == rhs.decompressedSize ); +# endif + } + + bool operator!=( DecompressMemoryRegionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress srcAddress = {}; + DeviceAddress dstAddress = {}; + DeviceSize compressedSize = {}; + DeviceSize decompressedSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DecompressMemoryRegionEXT; + }; +#endif + + // wrapper struct for struct VkDecompressMemoryInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDecompressMemoryInfoEXT.html + struct DecompressMemoryInfoEXT + { + using NativeType = VkDecompressMemoryInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDecompressMemoryInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DecompressMemoryInfoEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod_ = {}, + uint32_t regionCount_ = {}, + const DecompressMemoryRegionEXT * pRegions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , decompressionMethod{ decompressionMethod_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR DecompressMemoryInfoEXT( DecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DecompressMemoryInfoEXT( VkDecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DecompressMemoryInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DecompressMemoryInfoEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod_, + ArrayProxyNoTemporaries const & regions_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), decompressionMethod( decompressionMethod_ ), regionCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DecompressMemoryInfoEXT & operator=( DecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DecompressMemoryInfoEXT & operator=( VkDecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setDecompressionMethod( MemoryDecompressionMethodFlagsEXT decompressionMethod_ ) & VULKAN_HPP_NOEXCEPT + { + decompressionMethod = decompressionMethod_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setDecompressionMethod( MemoryDecompressionMethodFlagsEXT decompressionMethod_ ) && VULKAN_HPP_NOEXCEPT + { + decompressionMethod = decompressionMethod_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setPRegions( const DecompressMemoryRegionEXT * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setPRegions( const DecompressMemoryRegionEXT * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DecompressMemoryInfoEXT & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDecompressMemoryInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDecompressMemoryInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDecompressMemoryInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDecompressMemoryInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, decompressionMethod, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DecompressMemoryInfoEXT const & ) const = default; +#else + bool operator==( DecompressMemoryInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decompressionMethod == rhs.decompressionMethod ) && ( regionCount == rhs.regionCount ) && + ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( DecompressMemoryInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDecompressMemoryInfoEXT; + const void * pNext = {}; + MemoryDecompressionMethodFlagsEXT decompressionMethod = {}; + uint32_t regionCount = {}; + const DecompressMemoryRegionEXT * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DecompressMemoryInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DecompressMemoryInfoEXT; + }; + + // wrapper struct for struct VkDecompressMemoryRegionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDecompressMemoryRegionNV.html + struct DecompressMemoryRegionNV + { + using NativeType = VkDecompressMemoryRegionNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DecompressMemoryRegionNV( DeviceAddress srcAddress_ = {}, + DeviceAddress dstAddress_ = {}, + DeviceSize compressedSize_ = {}, + DeviceSize decompressedSize_ = {}, + MemoryDecompressionMethodFlagsNV decompressionMethod_ = {} ) VULKAN_HPP_NOEXCEPT + : srcAddress{ srcAddress_ } + , dstAddress{ dstAddress_ } + , compressedSize{ compressedSize_ } + , decompressedSize{ decompressedSize_ } + , decompressionMethod{ decompressionMethod_ } + { + } + + VULKAN_HPP_CONSTEXPR DecompressMemoryRegionNV( DecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DecompressMemoryRegionNV( VkDecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT + : DecompressMemoryRegionNV( *reinterpret_cast( &rhs ) ) + { + } + + DecompressMemoryRegionNV & operator=( DecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DecompressMemoryRegionNV & operator=( VkDecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT + { + srcAddress = srcAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT + { + srcAddress = srcAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setDstAddress( DeviceAddress dstAddress_ ) & VULKAN_HPP_NOEXCEPT + { + dstAddress = dstAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setDstAddress( DeviceAddress dstAddress_ ) && VULKAN_HPP_NOEXCEPT + { + dstAddress = dstAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setCompressedSize( DeviceSize compressedSize_ ) & VULKAN_HPP_NOEXCEPT + { + compressedSize = compressedSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setCompressedSize( DeviceSize compressedSize_ ) && VULKAN_HPP_NOEXCEPT + { + compressedSize = compressedSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setDecompressedSize( DeviceSize decompressedSize_ ) & VULKAN_HPP_NOEXCEPT + { + decompressedSize = decompressedSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setDecompressedSize( DeviceSize decompressedSize_ ) && VULKAN_HPP_NOEXCEPT + { + decompressedSize = decompressedSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setDecompressionMethod( MemoryDecompressionMethodFlagsNV decompressionMethod_ ) & VULKAN_HPP_NOEXCEPT + { + decompressionMethod = decompressionMethod_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setDecompressionMethod( MemoryDecompressionMethodFlagsNV decompressionMethod_ ) && VULKAN_HPP_NOEXCEPT + { + decompressionMethod = decompressionMethod_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDecompressMemoryRegionNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDecompressMemoryRegionNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDecompressMemoryRegionNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDecompressMemoryRegionNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcAddress, dstAddress, compressedSize, decompressedSize, decompressionMethod ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DecompressMemoryRegionNV const & ) const = default; +#else + bool operator==( DecompressMemoryRegionNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( srcAddress == rhs.srcAddress ) && ( dstAddress == rhs.dstAddress ) && ( compressedSize == rhs.compressedSize ) && + ( decompressedSize == rhs.decompressedSize ) && ( decompressionMethod == rhs.decompressionMethod ); +# endif + } + + bool operator!=( DecompressMemoryRegionNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress srcAddress = {}; + DeviceAddress dstAddress = {}; + DeviceSize compressedSize = {}; + DeviceSize decompressedSize = {}; + MemoryDecompressionMethodFlagsNV decompressionMethod = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DecompressMemoryRegionNV; + }; +#endif + + // wrapper struct for struct VkDedicatedAllocationBufferCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDedicatedAllocationBufferCreateInfoNV.html + struct DedicatedAllocationBufferCreateInfoNV + { + using NativeType = VkDedicatedAllocationBufferCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationBufferCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dedicatedAllocation{ dedicatedAllocation_ } + { + } + + VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : DedicatedAllocationBufferCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + DedicatedAllocationBufferCreateInfoNV & operator=( DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DedicatedAllocationBufferCreateInfoNV & operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ ) & VULKAN_HPP_NOEXCEPT + { + dedicatedAllocation = dedicatedAllocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV && setDedicatedAllocation( Bool32 dedicatedAllocation_ ) && VULKAN_HPP_NOEXCEPT + { + dedicatedAllocation = dedicatedAllocation_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDedicatedAllocationBufferCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDedicatedAllocationBufferCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDedicatedAllocationBufferCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDedicatedAllocationBufferCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dedicatedAllocation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DedicatedAllocationBufferCreateInfoNV const & ) const = default; +#else + bool operator==( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation ); +# endif + } + + bool operator!=( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV; + const void * pNext = {}; + Bool32 dedicatedAllocation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DedicatedAllocationBufferCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = DedicatedAllocationBufferCreateInfoNV; + }; + + // wrapper struct for struct VkDedicatedAllocationImageCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDedicatedAllocationImageCreateInfoNV.html + struct DedicatedAllocationImageCreateInfoNV + { + using NativeType = VkDedicatedAllocationImageCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationImageCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dedicatedAllocation{ dedicatedAllocation_ } + { + } + + VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : DedicatedAllocationImageCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + DedicatedAllocationImageCreateInfoNV & operator=( DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DedicatedAllocationImageCreateInfoNV & operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ ) & VULKAN_HPP_NOEXCEPT + { + dedicatedAllocation = dedicatedAllocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV && setDedicatedAllocation( Bool32 dedicatedAllocation_ ) && VULKAN_HPP_NOEXCEPT + { + dedicatedAllocation = dedicatedAllocation_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDedicatedAllocationImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDedicatedAllocationImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDedicatedAllocationImageCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDedicatedAllocationImageCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dedicatedAllocation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DedicatedAllocationImageCreateInfoNV const & ) const = default; +#else + bool operator==( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation ); +# endif + } + + bool operator!=( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV; + const void * pNext = {}; + Bool32 dedicatedAllocation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DedicatedAllocationImageCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = DedicatedAllocationImageCreateInfoNV; + }; + + // wrapper struct for struct VkDedicatedAllocationMemoryAllocateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html + struct DedicatedAllocationMemoryAllocateInfoNV + { + using NativeType = VkDedicatedAllocationMemoryAllocateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( Image image_ = {}, Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image{ image_ } + , buffer{ buffer_ } + { + } + + VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : DedicatedAllocationMemoryAllocateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + DedicatedAllocationMemoryAllocateInfoNV & operator=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DedicatedAllocationMemoryAllocateInfoNV & operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDedicatedAllocationMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDedicatedAllocationMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDedicatedAllocationMemoryAllocateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDedicatedAllocationMemoryAllocateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, buffer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DedicatedAllocationMemoryAllocateInfoNV const & ) const = default; +#else + bool operator==( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer ); +# endif + } + + bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; + const void * pNext = {}; + Image image = {}; + Buffer buffer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DedicatedAllocationMemoryAllocateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = DedicatedAllocationMemoryAllocateInfoNV; + }; + + // wrapper struct for struct VkMemoryBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryBarrier2.html + struct MemoryBarrier2 + { + using NativeType = VkMemoryBarrier2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryBarrier2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryBarrier2( PipelineStageFlags2 srcStageMask_ = {}, + AccessFlags2 srcAccessMask_ = {}, + PipelineStageFlags2 dstStageMask_ = {}, + AccessFlags2 dstAccessMask_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcStageMask{ srcStageMask_ } + , srcAccessMask{ srcAccessMask_ } + , dstStageMask{ dstStageMask_ } + , dstAccessMask{ dstAccessMask_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryBarrier2( MemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryBarrier2( VkMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryBarrier2( *reinterpret_cast( &rhs ) ) {} + + MemoryBarrier2 & operator=( MemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryBarrier2 & operator=( VkMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryBarrier2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryBarrier2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryBarrier2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryBarrier2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryBarrier2 const & ) const = default; +#else + bool operator==( MemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && + ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask ); +# endif + } + + bool operator!=( MemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryBarrier2; + const void * pNext = {}; + PipelineStageFlags2 srcStageMask = {}; + AccessFlags2 srcAccessMask = {}; + PipelineStageFlags2 dstStageMask = {}; + AccessFlags2 dstAccessMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryBarrier2; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryBarrier2; + }; + + using MemoryBarrier2KHR = MemoryBarrier2; + + // wrapper struct for struct VkImageSubresourceRange, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSubresourceRange.html + struct ImageSubresourceRange + { + using NativeType = VkImageSubresourceRange; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageSubresourceRange( ImageAspectFlags aspectMask_ = {}, + uint32_t baseMipLevel_ = {}, + uint32_t levelCount_ = {}, + uint32_t baseArrayLayer_ = {}, + uint32_t layerCount_ = {} ) VULKAN_HPP_NOEXCEPT + : aspectMask{ aspectMask_ } + , baseMipLevel{ baseMipLevel_ } + , levelCount{ levelCount_ } + , baseArrayLayer{ baseArrayLayer_ } + , layerCount{ layerCount_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageSubresourceRange( ImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageSubresourceRange( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageSubresourceRange( *reinterpret_cast( &rhs ) ) + { + } + + ImageSubresourceRange & operator=( ImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageSubresourceRange & operator=( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setBaseMipLevel( uint32_t baseMipLevel_ ) & VULKAN_HPP_NOEXCEPT + { + baseMipLevel = baseMipLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setBaseMipLevel( uint32_t baseMipLevel_ ) && VULKAN_HPP_NOEXCEPT + { + baseMipLevel = baseMipLevel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setLevelCount( uint32_t levelCount_ ) & VULKAN_HPP_NOEXCEPT + { + levelCount = levelCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setLevelCount( uint32_t levelCount_ ) && VULKAN_HPP_NOEXCEPT + { + levelCount = levelCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setBaseArrayLayer( uint32_t baseArrayLayer_ ) & VULKAN_HPP_NOEXCEPT + { + baseArrayLayer = baseArrayLayer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setBaseArrayLayer( uint32_t baseArrayLayer_ ) && VULKAN_HPP_NOEXCEPT + { + baseArrayLayer = baseArrayLayer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageSubresourceRange const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSubresourceRange &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSubresourceRange const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageSubresourceRange *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, baseMipLevel, levelCount, baseArrayLayer, layerCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageSubresourceRange const & ) const = default; +#else + bool operator==( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( aspectMask == rhs.aspectMask ) && ( baseMipLevel == rhs.baseMipLevel ) && ( levelCount == rhs.levelCount ) && + ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); +# endif + } + + bool operator!=( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ImageAspectFlags aspectMask = {}; + uint32_t baseMipLevel = {}; + uint32_t levelCount = {}; + uint32_t baseArrayLayer = {}; + uint32_t layerCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageSubresourceRange; + }; +#endif + + // wrapper struct for struct VkImageMemoryBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageMemoryBarrier2.html + struct ImageMemoryBarrier2 + { + using NativeType = VkImageMemoryBarrier2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryBarrier2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageMemoryBarrier2( PipelineStageFlags2 srcStageMask_ = {}, + AccessFlags2 srcAccessMask_ = {}, + PipelineStageFlags2 dstStageMask_ = {}, + AccessFlags2 dstAccessMask_ = {}, + ImageLayout oldLayout_ = ImageLayout::eUndefined, + ImageLayout newLayout_ = ImageLayout::eUndefined, + uint32_t srcQueueFamilyIndex_ = {}, + uint32_t dstQueueFamilyIndex_ = {}, + Image image_ = {}, + ImageSubresourceRange subresourceRange_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcStageMask{ srcStageMask_ } + , srcAccessMask{ srcAccessMask_ } + , dstStageMask{ dstStageMask_ } + , dstAccessMask{ dstAccessMask_ } + , oldLayout{ oldLayout_ } + , newLayout{ newLayout_ } + , srcQueueFamilyIndex{ srcQueueFamilyIndex_ } + , dstQueueFamilyIndex{ dstQueueFamilyIndex_ } + , image{ image_ } + , subresourceRange{ subresourceRange_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageMemoryBarrier2( ImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageMemoryBarrier2( VkImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageMemoryBarrier2( *reinterpret_cast( &rhs ) ) + { + } + + ImageMemoryBarrier2 & operator=( ImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageMemoryBarrier2 & operator=( VkImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setOldLayout( ImageLayout oldLayout_ ) & VULKAN_HPP_NOEXCEPT + { + oldLayout = oldLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setOldLayout( ImageLayout oldLayout_ ) && VULKAN_HPP_NOEXCEPT + { + oldLayout = oldLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setNewLayout( ImageLayout newLayout_ ) & VULKAN_HPP_NOEXCEPT + { + newLayout = newLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setNewLayout( ImageLayout newLayout_ ) && VULKAN_HPP_NOEXCEPT + { + newLayout = newLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) & VULKAN_HPP_NOEXCEPT + { + subresourceRange = subresourceRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) && VULKAN_HPP_NOEXCEPT + { + subresourceRange = subresourceRange_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageMemoryBarrier2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageMemoryBarrier2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageMemoryBarrier2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageMemoryBarrier2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + srcStageMask, + srcAccessMask, + dstStageMask, + dstAccessMask, + oldLayout, + newLayout, + srcQueueFamilyIndex, + dstQueueFamilyIndex, + image, + subresourceRange ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageMemoryBarrier2 const & ) const = default; +#else + bool operator==( ImageMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && + ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) && + ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && + ( image == rhs.image ) && ( subresourceRange == rhs.subresourceRange ); +# endif + } + + bool operator!=( ImageMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageMemoryBarrier2; + const void * pNext = {}; + PipelineStageFlags2 srcStageMask = {}; + AccessFlags2 srcAccessMask = {}; + PipelineStageFlags2 dstStageMask = {}; + AccessFlags2 dstAccessMask = {}; + ImageLayout oldLayout = ImageLayout::eUndefined; + ImageLayout newLayout = ImageLayout::eUndefined; + uint32_t srcQueueFamilyIndex = {}; + uint32_t dstQueueFamilyIndex = {}; + Image image = {}; + ImageSubresourceRange subresourceRange = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageMemoryBarrier2; + }; +#endif + + template <> + struct CppType + { + using Type = ImageMemoryBarrier2; + }; + + using ImageMemoryBarrier2KHR = ImageMemoryBarrier2; + + // wrapper struct for struct VkDependencyInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDependencyInfo.html + struct DependencyInfo + { + using NativeType = VkDependencyInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDependencyInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DependencyInfo( DependencyFlags dependencyFlags_ = {}, + uint32_t memoryBarrierCount_ = {}, + const MemoryBarrier2 * pMemoryBarriers_ = {}, + uint32_t bufferMemoryBarrierCount_ = {}, + const BufferMemoryBarrier2 * pBufferMemoryBarriers_ = {}, + uint32_t imageMemoryBarrierCount_ = {}, + const ImageMemoryBarrier2 * pImageMemoryBarriers_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dependencyFlags{ dependencyFlags_ } + , memoryBarrierCount{ memoryBarrierCount_ } + , pMemoryBarriers{ pMemoryBarriers_ } + , bufferMemoryBarrierCount{ bufferMemoryBarrierCount_ } + , pBufferMemoryBarriers{ pBufferMemoryBarriers_ } + , imageMemoryBarrierCount{ imageMemoryBarrierCount_ } + , pImageMemoryBarriers{ pImageMemoryBarriers_ } + { + } + + VULKAN_HPP_CONSTEXPR DependencyInfo( DependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DependencyInfo( VkDependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT : DependencyInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DependencyInfo( DependencyFlags dependencyFlags_, + ArrayProxyNoTemporaries const & memoryBarriers_, + ArrayProxyNoTemporaries const & bufferMemoryBarriers_ = {}, + ArrayProxyNoTemporaries const & imageMemoryBarriers_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , dependencyFlags( dependencyFlags_ ) + , memoryBarrierCount( static_cast( memoryBarriers_.size() ) ) + , pMemoryBarriers( memoryBarriers_.data() ) + , bufferMemoryBarrierCount( static_cast( bufferMemoryBarriers_.size() ) ) + , pBufferMemoryBarriers( bufferMemoryBarriers_.data() ) + , imageMemoryBarrierCount( static_cast( imageMemoryBarriers_.size() ) ) + , pImageMemoryBarriers( imageMemoryBarriers_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DependencyInfo & operator=( DependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DependencyInfo & operator=( VkDependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setDependencyFlags( DependencyFlags dependencyFlags_ ) & VULKAN_HPP_NOEXCEPT + { + dependencyFlags = dependencyFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setDependencyFlags( DependencyFlags dependencyFlags_ ) && VULKAN_HPP_NOEXCEPT + { + dependencyFlags = dependencyFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setMemoryBarrierCount( uint32_t memoryBarrierCount_ ) & VULKAN_HPP_NOEXCEPT + { + memoryBarrierCount = memoryBarrierCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setMemoryBarrierCount( uint32_t memoryBarrierCount_ ) && VULKAN_HPP_NOEXCEPT + { + memoryBarrierCount = memoryBarrierCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPMemoryBarriers( const MemoryBarrier2 * pMemoryBarriers_ ) & VULKAN_HPP_NOEXCEPT + { + pMemoryBarriers = pMemoryBarriers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPMemoryBarriers( const MemoryBarrier2 * pMemoryBarriers_ ) && VULKAN_HPP_NOEXCEPT + { + pMemoryBarriers = pMemoryBarriers_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DependencyInfo & setMemoryBarriers( ArrayProxyNoTemporaries const & memoryBarriers_ ) VULKAN_HPP_NOEXCEPT + { + memoryBarrierCount = static_cast( memoryBarriers_.size() ); + pMemoryBarriers = memoryBarriers_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setBufferMemoryBarrierCount( uint32_t bufferMemoryBarrierCount_ ) & VULKAN_HPP_NOEXCEPT + { + bufferMemoryBarrierCount = bufferMemoryBarrierCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setBufferMemoryBarrierCount( uint32_t bufferMemoryBarrierCount_ ) && VULKAN_HPP_NOEXCEPT + { + bufferMemoryBarrierCount = bufferMemoryBarrierCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPBufferMemoryBarriers( const BufferMemoryBarrier2 * pBufferMemoryBarriers_ ) & VULKAN_HPP_NOEXCEPT + { + pBufferMemoryBarriers = pBufferMemoryBarriers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPBufferMemoryBarriers( const BufferMemoryBarrier2 * pBufferMemoryBarriers_ ) && VULKAN_HPP_NOEXCEPT + { + pBufferMemoryBarriers = pBufferMemoryBarriers_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DependencyInfo & setBufferMemoryBarriers( ArrayProxyNoTemporaries const & bufferMemoryBarriers_ ) VULKAN_HPP_NOEXCEPT + { + bufferMemoryBarrierCount = static_cast( bufferMemoryBarriers_.size() ); + pBufferMemoryBarriers = bufferMemoryBarriers_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setImageMemoryBarrierCount( uint32_t imageMemoryBarrierCount_ ) & VULKAN_HPP_NOEXCEPT + { + imageMemoryBarrierCount = imageMemoryBarrierCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setImageMemoryBarrierCount( uint32_t imageMemoryBarrierCount_ ) && VULKAN_HPP_NOEXCEPT + { + imageMemoryBarrierCount = imageMemoryBarrierCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPImageMemoryBarriers( const ImageMemoryBarrier2 * pImageMemoryBarriers_ ) & VULKAN_HPP_NOEXCEPT + { + pImageMemoryBarriers = pImageMemoryBarriers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPImageMemoryBarriers( const ImageMemoryBarrier2 * pImageMemoryBarriers_ ) && VULKAN_HPP_NOEXCEPT + { + pImageMemoryBarriers = pImageMemoryBarriers_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DependencyInfo & setImageMemoryBarriers( ArrayProxyNoTemporaries const & imageMemoryBarriers_ ) VULKAN_HPP_NOEXCEPT + { + imageMemoryBarrierCount = static_cast( imageMemoryBarriers_.size() ); + pImageMemoryBarriers = imageMemoryBarriers_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDependencyInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDependencyInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDependencyInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDependencyInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + dependencyFlags, + memoryBarrierCount, + pMemoryBarriers, + bufferMemoryBarrierCount, + pBufferMemoryBarriers, + imageMemoryBarrierCount, + pImageMemoryBarriers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DependencyInfo const & ) const = default; +#else + bool operator==( DependencyInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dependencyFlags == rhs.dependencyFlags ) && + ( memoryBarrierCount == rhs.memoryBarrierCount ) && ( pMemoryBarriers == rhs.pMemoryBarriers ) && + ( bufferMemoryBarrierCount == rhs.bufferMemoryBarrierCount ) && ( pBufferMemoryBarriers == rhs.pBufferMemoryBarriers ) && + ( imageMemoryBarrierCount == rhs.imageMemoryBarrierCount ) && ( pImageMemoryBarriers == rhs.pImageMemoryBarriers ); +# endif + } + + bool operator!=( DependencyInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDependencyInfo; + const void * pNext = {}; + DependencyFlags dependencyFlags = {}; + uint32_t memoryBarrierCount = {}; + const MemoryBarrier2 * pMemoryBarriers = {}; + uint32_t bufferMemoryBarrierCount = {}; + const BufferMemoryBarrier2 * pBufferMemoryBarriers = {}; + uint32_t imageMemoryBarrierCount = {}; + const ImageMemoryBarrier2 * pImageMemoryBarriers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DependencyInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DependencyInfo; + }; + + using DependencyInfoKHR = DependencyInfo; + + // wrapper struct for struct VkDepthBiasInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthBiasInfoEXT.html + struct DepthBiasInfoEXT + { + using NativeType = VkDepthBiasInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDepthBiasInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DepthBiasInfoEXT( float depthBiasConstantFactor_ = {}, + float depthBiasClamp_ = {}, + float depthBiasSlopeFactor_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , depthBiasConstantFactor{ depthBiasConstantFactor_ } + , depthBiasClamp{ depthBiasClamp_ } + , depthBiasSlopeFactor{ depthBiasSlopeFactor_ } + { + } + + VULKAN_HPP_CONSTEXPR DepthBiasInfoEXT( DepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DepthBiasInfoEXT( VkDepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DepthBiasInfoEXT( *reinterpret_cast( &rhs ) ) {} + + DepthBiasInfoEXT & operator=( DepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DepthBiasInfoEXT & operator=( VkDepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) & VULKAN_HPP_NOEXCEPT + { + depthBiasConstantFactor = depthBiasConstantFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) && VULKAN_HPP_NOEXCEPT + { + depthBiasConstantFactor = depthBiasConstantFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setDepthBiasClamp( float depthBiasClamp_ ) & VULKAN_HPP_NOEXCEPT + { + depthBiasClamp = depthBiasClamp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setDepthBiasClamp( float depthBiasClamp_ ) && VULKAN_HPP_NOEXCEPT + { + depthBiasClamp = depthBiasClamp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) & VULKAN_HPP_NOEXCEPT + { + depthBiasSlopeFactor = depthBiasSlopeFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) && VULKAN_HPP_NOEXCEPT + { + depthBiasSlopeFactor = depthBiasSlopeFactor_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDepthBiasInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDepthBiasInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDepthBiasInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDepthBiasInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DepthBiasInfoEXT const & ) const = default; +#else + bool operator==( DepthBiasInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) && + ( depthBiasClamp == rhs.depthBiasClamp ) && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor ); +# endif + } + + bool operator!=( DepthBiasInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDepthBiasInfoEXT; + const void * pNext = {}; + float depthBiasConstantFactor = {}; + float depthBiasClamp = {}; + float depthBiasSlopeFactor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DepthBiasInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DepthBiasInfoEXT; + }; + + // wrapper struct for struct VkDepthBiasRepresentationInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthBiasRepresentationInfoEXT.html + struct DepthBiasRepresentationInfoEXT + { + using NativeType = VkDepthBiasRepresentationInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDepthBiasRepresentationInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DepthBiasRepresentationInfoEXT( DepthBiasRepresentationEXT depthBiasRepresentation_ = DepthBiasRepresentationEXT::eLeastRepresentableValueFormat, + Bool32 depthBiasExact_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , depthBiasRepresentation{ depthBiasRepresentation_ } + , depthBiasExact{ depthBiasExact_ } + { + } + + VULKAN_HPP_CONSTEXPR DepthBiasRepresentationInfoEXT( DepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DepthBiasRepresentationInfoEXT( VkDepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DepthBiasRepresentationInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + DepthBiasRepresentationInfoEXT & operator=( DepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DepthBiasRepresentationInfoEXT & operator=( VkDepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT & setDepthBiasRepresentation( DepthBiasRepresentationEXT depthBiasRepresentation_ ) & + VULKAN_HPP_NOEXCEPT + { + depthBiasRepresentation = depthBiasRepresentation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT && setDepthBiasRepresentation( DepthBiasRepresentationEXT depthBiasRepresentation_ ) && + VULKAN_HPP_NOEXCEPT + { + depthBiasRepresentation = depthBiasRepresentation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT & setDepthBiasExact( Bool32 depthBiasExact_ ) & VULKAN_HPP_NOEXCEPT + { + depthBiasExact = depthBiasExact_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT && setDepthBiasExact( Bool32 depthBiasExact_ ) && VULKAN_HPP_NOEXCEPT + { + depthBiasExact = depthBiasExact_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDepthBiasRepresentationInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDepthBiasRepresentationInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDepthBiasRepresentationInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDepthBiasRepresentationInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthBiasRepresentation, depthBiasExact ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DepthBiasRepresentationInfoEXT const & ) const = default; +#else + bool operator==( DepthBiasRepresentationInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthBiasRepresentation == rhs.depthBiasRepresentation ) && + ( depthBiasExact == rhs.depthBiasExact ); +# endif + } + + bool operator!=( DepthBiasRepresentationInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDepthBiasRepresentationInfoEXT; + const void * pNext = {}; + DepthBiasRepresentationEXT depthBiasRepresentation = DepthBiasRepresentationEXT::eLeastRepresentableValueFormat; + Bool32 depthBiasExact = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DepthBiasRepresentationInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DepthBiasRepresentationInfoEXT; + }; + + // wrapper struct for struct VkDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthClampRangeEXT.html + struct DepthClampRangeEXT + { + using NativeType = VkDepthClampRangeEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DepthClampRangeEXT( float minDepthClamp_ = {}, float maxDepthClamp_ = {} ) VULKAN_HPP_NOEXCEPT + : minDepthClamp{ minDepthClamp_ } + , maxDepthClamp{ maxDepthClamp_ } + { + } + + VULKAN_HPP_CONSTEXPR DepthClampRangeEXT( DepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DepthClampRangeEXT( VkDepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DepthClampRangeEXT( *reinterpret_cast( &rhs ) ) {} + + DepthClampRangeEXT & operator=( DepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DepthClampRangeEXT & operator=( VkDepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT & setMinDepthClamp( float minDepthClamp_ ) & VULKAN_HPP_NOEXCEPT + { + minDepthClamp = minDepthClamp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT && setMinDepthClamp( float minDepthClamp_ ) && VULKAN_HPP_NOEXCEPT + { + minDepthClamp = minDepthClamp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT & setMaxDepthClamp( float maxDepthClamp_ ) & VULKAN_HPP_NOEXCEPT + { + maxDepthClamp = maxDepthClamp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT && setMaxDepthClamp( float maxDepthClamp_ ) && VULKAN_HPP_NOEXCEPT + { + maxDepthClamp = maxDepthClamp_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDepthClampRangeEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDepthClampRangeEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDepthClampRangeEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDepthClampRangeEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( minDepthClamp, maxDepthClamp ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DepthClampRangeEXT const & ) const = default; +#else + bool operator==( DepthClampRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( minDepthClamp == rhs.minDepthClamp ) && ( maxDepthClamp == rhs.maxDepthClamp ); +# endif + } + + bool operator!=( DepthClampRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + float minDepthClamp = {}; + float maxDepthClamp = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DepthClampRangeEXT; + }; +#endif + + // wrapper struct for struct VkDescriptorAddressInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorAddressInfoEXT.html + struct DescriptorAddressInfoEXT + { + using NativeType = VkDescriptorAddressInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorAddressInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorAddressInfoEXT( DeviceAddress address_ = {}, + DeviceSize range_ = {}, + Format format_ = Format::eUndefined, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , address{ address_ } + , range{ range_ } + , format{ format_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorAddressInfoEXT( DescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorAddressInfoEXT( VkDescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorAddressInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorAddressInfoEXT & operator=( DescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorAddressInfoEXT & operator=( VkDescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT + { + address = address_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT + { + address = address_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setRange( DeviceSize range_ ) & VULKAN_HPP_NOEXCEPT + { + range = range_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setRange( DeviceSize range_ ) && VULKAN_HPP_NOEXCEPT + { + range = range_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorAddressInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorAddressInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorAddressInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorAddressInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, address, range, format ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorAddressInfoEXT const & ) const = default; +#else + bool operator==( DescriptorAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( address == rhs.address ) && ( range == rhs.range ) && ( format == rhs.format ); +# endif + } + + bool operator!=( DescriptorAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorAddressInfoEXT; + void * pNext = {}; + DeviceAddress address = {}; + DeviceSize range = {}; + Format format = Format::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorAddressInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorAddressInfoEXT; + }; + + // wrapper struct for struct VkDescriptorBufferBindingInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBufferBindingInfoEXT.html + struct DescriptorBufferBindingInfoEXT + { + using NativeType = VkDescriptorBufferBindingInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorBufferBindingInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DescriptorBufferBindingInfoEXT( DeviceAddress address_ = {}, BufferUsageFlags usage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , address{ address_ } + , usage{ usage_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorBufferBindingInfoEXT( DescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorBufferBindingInfoEXT( VkDescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorBufferBindingInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorBufferBindingInfoEXT & operator=( DescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorBufferBindingInfoEXT & operator=( VkDescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT + { + address = address_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT + { + address = address_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT & setUsage( BufferUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT && setUsage( BufferUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorBufferBindingInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorBufferBindingInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorBufferBindingInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorBufferBindingInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, address, usage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorBufferBindingInfoEXT const & ) const = default; +#else + bool operator==( DescriptorBufferBindingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( address == rhs.address ) && ( usage == rhs.usage ); +# endif + } + + bool operator!=( DescriptorBufferBindingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorBufferBindingInfoEXT; + const void * pNext = {}; + DeviceAddress address = {}; + BufferUsageFlags usage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorBufferBindingInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorBufferBindingInfoEXT; + }; + + // wrapper struct for struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.html + struct DescriptorBufferBindingPushDescriptorBufferHandleEXT + { + using NativeType = VkDescriptorBufferBindingPushDescriptorBufferHandleEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorBufferBindingPushDescriptorBufferHandleEXT( Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , buffer{ buffer_ } + { + } + + VULKAN_HPP_CONSTEXPR + DescriptorBufferBindingPushDescriptorBufferHandleEXT( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorBufferBindingPushDescriptorBufferHandleEXT( VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorBufferBindingPushDescriptorBufferHandleEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorBufferBindingPushDescriptorBufferHandleEXT & + operator=( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorBufferBindingPushDescriptorBufferHandleEXT & operator=( VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & ) const = default; +#else + bool operator==( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); +# endif + } + + bool operator!=( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT; + const void * pNext = {}; + Buffer buffer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorBufferBindingPushDescriptorBufferHandleEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorBufferBindingPushDescriptorBufferHandleEXT; + }; + + // wrapper struct for struct VkDescriptorBufferInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBufferInfo.html + struct DescriptorBufferInfo + { + using NativeType = VkDescriptorBufferInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( Buffer buffer_ = {}, DeviceSize offset_ = {}, DeviceSize range_ = {} ) VULKAN_HPP_NOEXCEPT + : buffer{ buffer_ } + , offset{ offset_ } + , range{ range_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( DescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorBufferInfo( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorBufferInfo & operator=( DescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorBufferInfo & operator=( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo & setRange( DeviceSize range_ ) & VULKAN_HPP_NOEXCEPT + { + range = range_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo && setRange( DeviceSize range_ ) && VULKAN_HPP_NOEXCEPT + { + range = range_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorBufferInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorBufferInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorBufferInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorBufferInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( buffer, offset, range ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorBufferInfo const & ) const = default; +#else + bool operator==( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( range == rhs.range ); +# endif + } + + bool operator!=( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Buffer buffer = {}; + DeviceSize offset = {}; + DeviceSize range = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorBufferInfo; + }; +#endif + + // wrapper struct for struct VkDescriptorImageInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorImageInfo.html + struct DescriptorImageInfo + { + using NativeType = VkDescriptorImageInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DescriptorImageInfo( Sampler sampler_ = {}, ImageView imageView_ = {}, ImageLayout imageLayout_ = ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT + : sampler{ sampler_ } + , imageView{ imageView_ } + , imageLayout{ imageLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorImageInfo( DescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT : DescriptorImageInfo( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorImageInfo & operator=( DescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorImageInfo & operator=( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo & setSampler( Sampler sampler_ ) & VULKAN_HPP_NOEXCEPT + { + sampler = sampler_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo && setSampler( Sampler sampler_ ) && VULKAN_HPP_NOEXCEPT + { + sampler = sampler_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo & setImageLayout( ImageLayout imageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + imageLayout = imageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo && setImageLayout( ImageLayout imageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + imageLayout = imageLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorImageInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorImageInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorImageInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorImageInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sampler, imageView, imageLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorImageInfo const & ) const = default; +#else + bool operator==( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sampler == rhs.sampler ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout ); +# endif + } + + bool operator!=( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Sampler sampler = {}; + ImageView imageView = {}; + ImageLayout imageLayout = ImageLayout::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorImageInfo; + }; +#endif + + union DescriptorDataEXT + { + using NativeType = VkDescriptorDataEXT; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( const Sampler * pSampler_ = {} ) : pSampler( pSampler_ ) {} + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( const DescriptorImageInfo * pDescriptorImageInfo_ ) : pCombinedImageSampler( pDescriptorImageInfo_ ) {} + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( const DescriptorAddressInfoEXT * pDescriptorAddressInfoEXT_ ) : pUniformTexelBuffer( pDescriptorAddressInfoEXT_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( DeviceAddress accelerationStructure_ ) : accelerationStructure( accelerationStructure_ ) {} +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPSampler( const Sampler * pSampler_ ) & VULKAN_HPP_NOEXCEPT + { + pSampler = pSampler_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPSampler( const Sampler * pSampler_ ) && VULKAN_HPP_NOEXCEPT + { + pSampler = pSampler_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPCombinedImageSampler( const DescriptorImageInfo * pCombinedImageSampler_ ) & VULKAN_HPP_NOEXCEPT + { + pCombinedImageSampler = pCombinedImageSampler_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPCombinedImageSampler( const DescriptorImageInfo * pCombinedImageSampler_ ) && VULKAN_HPP_NOEXCEPT + { + pCombinedImageSampler = pCombinedImageSampler_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPInputAttachmentImage( const DescriptorImageInfo * pInputAttachmentImage_ ) & VULKAN_HPP_NOEXCEPT + { + pInputAttachmentImage = pInputAttachmentImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPInputAttachmentImage( const DescriptorImageInfo * pInputAttachmentImage_ ) && VULKAN_HPP_NOEXCEPT + { + pInputAttachmentImage = pInputAttachmentImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPSampledImage( const DescriptorImageInfo * pSampledImage_ ) & VULKAN_HPP_NOEXCEPT + { + pSampledImage = pSampledImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPSampledImage( const DescriptorImageInfo * pSampledImage_ ) && VULKAN_HPP_NOEXCEPT + { + pSampledImage = pSampledImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPStorageImage( const DescriptorImageInfo * pStorageImage_ ) & VULKAN_HPP_NOEXCEPT + { + pStorageImage = pStorageImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPStorageImage( const DescriptorImageInfo * pStorageImage_ ) && VULKAN_HPP_NOEXCEPT + { + pStorageImage = pStorageImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPUniformTexelBuffer( const DescriptorAddressInfoEXT * pUniformTexelBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + pUniformTexelBuffer = pUniformTexelBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPUniformTexelBuffer( const DescriptorAddressInfoEXT * pUniformTexelBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + pUniformTexelBuffer = pUniformTexelBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPStorageTexelBuffer( const DescriptorAddressInfoEXT * pStorageTexelBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + pStorageTexelBuffer = pStorageTexelBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPStorageTexelBuffer( const DescriptorAddressInfoEXT * pStorageTexelBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + pStorageTexelBuffer = pStorageTexelBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPUniformBuffer( const DescriptorAddressInfoEXT * pUniformBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + pUniformBuffer = pUniformBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPUniformBuffer( const DescriptorAddressInfoEXT * pUniformBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + pUniformBuffer = pUniformBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPStorageBuffer( const DescriptorAddressInfoEXT * pStorageBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + pStorageBuffer = pStorageBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPStorageBuffer( const DescriptorAddressInfoEXT * pStorageBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + pStorageBuffer = pStorageBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setAccelerationStructure( DeviceAddress accelerationStructure_ ) & VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setAccelerationStructure( DeviceAddress accelerationStructure_ ) && VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorDataEXT const &() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorDataEXT &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + const Sampler * pSampler; + const DescriptorImageInfo * pCombinedImageSampler; + const DescriptorImageInfo * pInputAttachmentImage; + const DescriptorImageInfo * pSampledImage; + const DescriptorImageInfo * pStorageImage; + const DescriptorAddressInfoEXT * pUniformTexelBuffer; + const DescriptorAddressInfoEXT * pStorageTexelBuffer; + const DescriptorAddressInfoEXT * pUniformBuffer; + const DescriptorAddressInfoEXT * pStorageBuffer; + DeviceAddress accelerationStructure; +#else + const VkSampler * pSampler; + const VkDescriptorImageInfo * pCombinedImageSampler; + const VkDescriptorImageInfo * pInputAttachmentImage; + const VkDescriptorImageInfo * pSampledImage; + const VkDescriptorImageInfo * pStorageImage; + const VkDescriptorAddressInfoEXT * pUniformTexelBuffer; + const VkDescriptorAddressInfoEXT * pStorageTexelBuffer; + const VkDescriptorAddressInfoEXT * pUniformBuffer; + const VkDescriptorAddressInfoEXT * pStorageBuffer; + VkDeviceAddress accelerationStructure; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorDataEXT; + }; +#endif + + // wrapper struct for struct VkDescriptorGetInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorGetInfoEXT.html + struct DescriptorGetInfoEXT + { + using NativeType = VkDescriptorGetInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorGetInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + DescriptorGetInfoEXT( DescriptorType type_ = DescriptorType::eSampler, DescriptorDataEXT data_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , data{ data_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT( DescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorGetInfoEXT( VkDescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorGetInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorGetInfoEXT & operator=( DescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorGetInfoEXT & operator=( VkDescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT & setType( DescriptorType type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT && setType( DescriptorType type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT & setData( DescriptorDataEXT const & data_ ) & VULKAN_HPP_NOEXCEPT + { + data = data_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT && setData( DescriptorDataEXT const & data_ ) && VULKAN_HPP_NOEXCEPT + { + data = data_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorGetInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorGetInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorGetInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorGetInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, data ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorGetInfoEXT; + const void * pNext = {}; + DescriptorType type = DescriptorType::eSampler; + DescriptorDataEXT data = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorGetInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorGetInfoEXT; + }; + + // wrapper struct for struct VkDescriptorGetTensorInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorGetTensorInfoARM.html + struct DescriptorGetTensorInfoARM + { + using NativeType = VkDescriptorGetTensorInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorGetTensorInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorGetTensorInfoARM( TensorViewARM tensorView_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensorView{ tensorView_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorGetTensorInfoARM( DescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorGetTensorInfoARM( VkDescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorGetTensorInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorGetTensorInfoARM & operator=( DescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorGetTensorInfoARM & operator=( VkDescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM & setTensorView( TensorViewARM tensorView_ ) & VULKAN_HPP_NOEXCEPT + { + tensorView = tensorView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM && setTensorView( TensorViewARM tensorView_ ) && VULKAN_HPP_NOEXCEPT + { + tensorView = tensorView_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorGetTensorInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorGetTensorInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorGetTensorInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorGetTensorInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tensorView ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorGetTensorInfoARM const & ) const = default; +#else + bool operator==( DescriptorGetTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorView == rhs.tensorView ); +# endif + } + + bool operator!=( DescriptorGetTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorGetTensorInfoARM; + const void * pNext = {}; + TensorViewARM tensorView = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorGetTensorInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorGetTensorInfoARM; + }; + + // wrapper struct for struct VkSamplerCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCreateInfo.html + struct SamplerCreateInfo + { + using NativeType = VkSamplerCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SamplerCreateInfo( SamplerCreateFlags flags_ = {}, + Filter magFilter_ = Filter::eNearest, + Filter minFilter_ = Filter::eNearest, + SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest, + SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat, + SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat, + SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat, + float mipLodBias_ = {}, + Bool32 anisotropyEnable_ = {}, + float maxAnisotropy_ = {}, + Bool32 compareEnable_ = {}, + CompareOp compareOp_ = CompareOp::eNever, + float minLod_ = {}, + float maxLod_ = {}, + BorderColor borderColor_ = BorderColor::eFloatTransparentBlack, + Bool32 unnormalizedCoordinates_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , magFilter{ magFilter_ } + , minFilter{ minFilter_ } + , mipmapMode{ mipmapMode_ } + , addressModeU{ addressModeU_ } + , addressModeV{ addressModeV_ } + , addressModeW{ addressModeW_ } + , mipLodBias{ mipLodBias_ } + , anisotropyEnable{ anisotropyEnable_ } + , maxAnisotropy{ maxAnisotropy_ } + , compareEnable{ compareEnable_ } + , compareOp{ compareOp_ } + , minLod{ minLod_ } + , maxLod{ maxLod_ } + , borderColor{ borderColor_ } + , unnormalizedCoordinates{ unnormalizedCoordinates_ } + { + } + + VULKAN_HPP_CONSTEXPR SamplerCreateInfo( SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SamplerCreateInfo( *reinterpret_cast( &rhs ) ) {} + + SamplerCreateInfo & operator=( SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerCreateInfo & operator=( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setFlags( SamplerCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setFlags( SamplerCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMagFilter( Filter magFilter_ ) & VULKAN_HPP_NOEXCEPT + { + magFilter = magFilter_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMagFilter( Filter magFilter_ ) && VULKAN_HPP_NOEXCEPT + { + magFilter = magFilter_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMinFilter( Filter minFilter_ ) & VULKAN_HPP_NOEXCEPT + { + minFilter = minFilter_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMinFilter( Filter minFilter_ ) && VULKAN_HPP_NOEXCEPT + { + minFilter = minFilter_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMipmapMode( SamplerMipmapMode mipmapMode_ ) & VULKAN_HPP_NOEXCEPT + { + mipmapMode = mipmapMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMipmapMode( SamplerMipmapMode mipmapMode_ ) && VULKAN_HPP_NOEXCEPT + { + mipmapMode = mipmapMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAddressModeU( SamplerAddressMode addressModeU_ ) & VULKAN_HPP_NOEXCEPT + { + addressModeU = addressModeU_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAddressModeU( SamplerAddressMode addressModeU_ ) && VULKAN_HPP_NOEXCEPT + { + addressModeU = addressModeU_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAddressModeV( SamplerAddressMode addressModeV_ ) & VULKAN_HPP_NOEXCEPT + { + addressModeV = addressModeV_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAddressModeV( SamplerAddressMode addressModeV_ ) && VULKAN_HPP_NOEXCEPT + { + addressModeV = addressModeV_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAddressModeW( SamplerAddressMode addressModeW_ ) & VULKAN_HPP_NOEXCEPT + { + addressModeW = addressModeW_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAddressModeW( SamplerAddressMode addressModeW_ ) && VULKAN_HPP_NOEXCEPT + { + addressModeW = addressModeW_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMipLodBias( float mipLodBias_ ) & VULKAN_HPP_NOEXCEPT + { + mipLodBias = mipLodBias_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMipLodBias( float mipLodBias_ ) && VULKAN_HPP_NOEXCEPT + { + mipLodBias = mipLodBias_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAnisotropyEnable( Bool32 anisotropyEnable_ ) & VULKAN_HPP_NOEXCEPT + { + anisotropyEnable = anisotropyEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAnisotropyEnable( Bool32 anisotropyEnable_ ) && VULKAN_HPP_NOEXCEPT + { + anisotropyEnable = anisotropyEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMaxAnisotropy( float maxAnisotropy_ ) & VULKAN_HPP_NOEXCEPT + { + maxAnisotropy = maxAnisotropy_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMaxAnisotropy( float maxAnisotropy_ ) && VULKAN_HPP_NOEXCEPT + { + maxAnisotropy = maxAnisotropy_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setCompareEnable( Bool32 compareEnable_ ) & VULKAN_HPP_NOEXCEPT + { + compareEnable = compareEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setCompareEnable( Bool32 compareEnable_ ) && VULKAN_HPP_NOEXCEPT + { + compareEnable = compareEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setCompareOp( CompareOp compareOp_ ) & VULKAN_HPP_NOEXCEPT + { + compareOp = compareOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setCompareOp( CompareOp compareOp_ ) && VULKAN_HPP_NOEXCEPT + { + compareOp = compareOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMinLod( float minLod_ ) & VULKAN_HPP_NOEXCEPT + { + minLod = minLod_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMinLod( float minLod_ ) && VULKAN_HPP_NOEXCEPT + { + minLod = minLod_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMaxLod( float maxLod_ ) & VULKAN_HPP_NOEXCEPT + { + maxLod = maxLod_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMaxLod( float maxLod_ ) && VULKAN_HPP_NOEXCEPT + { + maxLod = maxLod_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setBorderColor( BorderColor borderColor_ ) & VULKAN_HPP_NOEXCEPT + { + borderColor = borderColor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setBorderColor( BorderColor borderColor_ ) && VULKAN_HPP_NOEXCEPT + { + borderColor = borderColor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ ) & VULKAN_HPP_NOEXCEPT + { + unnormalizedCoordinates = unnormalizedCoordinates_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ ) && VULKAN_HPP_NOEXCEPT + { + unnormalizedCoordinates = unnormalizedCoordinates_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSamplerCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + magFilter, + minFilter, + mipmapMode, + addressModeU, + addressModeV, + addressModeW, + mipLodBias, + anisotropyEnable, + maxAnisotropy, + compareEnable, + compareOp, + minLod, + maxLod, + borderColor, + unnormalizedCoordinates ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SamplerCreateInfo const & ) const = default; +#else + bool operator==( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( magFilter == rhs.magFilter ) && ( minFilter == rhs.minFilter ) && + ( mipmapMode == rhs.mipmapMode ) && ( addressModeU == rhs.addressModeU ) && ( addressModeV == rhs.addressModeV ) && + ( addressModeW == rhs.addressModeW ) && ( mipLodBias == rhs.mipLodBias ) && ( anisotropyEnable == rhs.anisotropyEnable ) && + ( maxAnisotropy == rhs.maxAnisotropy ) && ( compareEnable == rhs.compareEnable ) && ( compareOp == rhs.compareOp ) && ( minLod == rhs.minLod ) && + ( maxLod == rhs.maxLod ) && ( borderColor == rhs.borderColor ) && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates ); +# endif + } + + bool operator!=( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerCreateInfo; + const void * pNext = {}; + SamplerCreateFlags flags = {}; + Filter magFilter = Filter::eNearest; + Filter minFilter = Filter::eNearest; + SamplerMipmapMode mipmapMode = SamplerMipmapMode::eNearest; + SamplerAddressMode addressModeU = SamplerAddressMode::eRepeat; + SamplerAddressMode addressModeV = SamplerAddressMode::eRepeat; + SamplerAddressMode addressModeW = SamplerAddressMode::eRepeat; + float mipLodBias = {}; + Bool32 anisotropyEnable = {}; + float maxAnisotropy = {}; + Bool32 compareEnable = {}; + CompareOp compareOp = CompareOp::eNever; + float minLod = {}; + float maxLod = {}; + BorderColor borderColor = BorderColor::eFloatTransparentBlack; + Bool32 unnormalizedCoordinates = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerCreateInfo; + }; + + // wrapper struct for struct VkDescriptorMappingSourceConstantOffsetEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceConstantOffsetEXT.html + struct DescriptorMappingSourceConstantOffsetEXT + { + using NativeType = VkDescriptorMappingSourceConstantOffsetEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceConstantOffsetEXT( uint32_t heapOffset_ = {}, + uint32_t heapArrayStride_ = {}, + const SamplerCreateInfo * pEmbeddedSampler_ = {}, + uint32_t samplerHeapOffset_ = {}, + uint32_t samplerHeapArrayStride_ = {} ) VULKAN_HPP_NOEXCEPT + : heapOffset{ heapOffset_ } + , heapArrayStride{ heapArrayStride_ } + , pEmbeddedSampler{ pEmbeddedSampler_ } + , samplerHeapOffset{ samplerHeapOffset_ } + , samplerHeapArrayStride{ samplerHeapArrayStride_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceConstantOffsetEXT( DescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorMappingSourceConstantOffsetEXT( VkDescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorMappingSourceConstantOffsetEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorMappingSourceConstantOffsetEXT & operator=( DescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorMappingSourceConstantOffsetEXT & operator=( VkDescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT + { + heapArrayStride = heapArrayStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT + { + heapArrayStride = heapArrayStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) & VULKAN_HPP_NOEXCEPT + { + pEmbeddedSampler = pEmbeddedSampler_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) && + VULKAN_HPP_NOEXCEPT + { + pEmbeddedSampler = pEmbeddedSampler_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapOffset = samplerHeapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapOffset = samplerHeapOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapArrayStride = samplerHeapArrayStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapArrayStride = samplerHeapArrayStride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorMappingSourceConstantOffsetEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceConstantOffsetEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceConstantOffsetEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceConstantOffsetEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( heapOffset, heapArrayStride, pEmbeddedSampler, samplerHeapOffset, samplerHeapArrayStride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorMappingSourceConstantOffsetEXT const & ) const = default; +#else + bool operator==( DescriptorMappingSourceConstantOffsetEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( heapOffset == rhs.heapOffset ) && ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) && + ( samplerHeapOffset == rhs.samplerHeapOffset ) && ( samplerHeapArrayStride == rhs.samplerHeapArrayStride ); +# endif + } + + bool operator!=( DescriptorMappingSourceConstantOffsetEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t heapOffset = {}; + uint32_t heapArrayStride = {}; + const SamplerCreateInfo * pEmbeddedSampler = {}; + uint32_t samplerHeapOffset = {}; + uint32_t samplerHeapArrayStride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorMappingSourceConstantOffsetEXT; + }; +#endif + + // wrapper struct for struct VkDescriptorMappingSourcePushIndexEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourcePushIndexEXT.html + struct DescriptorMappingSourcePushIndexEXT + { + using NativeType = VkDescriptorMappingSourcePushIndexEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorMappingSourcePushIndexEXT( uint32_t heapOffset_ = {}, + uint32_t pushOffset_ = {}, + uint32_t heapIndexStride_ = {}, + uint32_t heapArrayStride_ = {}, + const SamplerCreateInfo * pEmbeddedSampler_ = {}, + Bool32 useCombinedImageSamplerIndex_ = {}, + uint32_t samplerHeapOffset_ = {}, + uint32_t samplerPushOffset_ = {}, + uint32_t samplerHeapIndexStride_ = {}, + uint32_t samplerHeapArrayStride_ = {} ) VULKAN_HPP_NOEXCEPT + : heapOffset{ heapOffset_ } + , pushOffset{ pushOffset_ } + , heapIndexStride{ heapIndexStride_ } + , heapArrayStride{ heapArrayStride_ } + , pEmbeddedSampler{ pEmbeddedSampler_ } + , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ } + , samplerHeapOffset{ samplerHeapOffset_ } + , samplerPushOffset{ samplerPushOffset_ } + , samplerHeapIndexStride{ samplerHeapIndexStride_ } + , samplerHeapArrayStride{ samplerHeapArrayStride_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorMappingSourcePushIndexEXT( DescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorMappingSourcePushIndexEXT( VkDescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorMappingSourcePushIndexEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorMappingSourcePushIndexEXT & operator=( DescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorMappingSourcePushIndexEXT & operator=( VkDescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT + { + pushOffset = pushOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT + { + pushOffset = pushOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT + { + heapIndexStride = heapIndexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT + { + heapIndexStride = heapIndexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT + { + heapArrayStride = heapArrayStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT + { + heapArrayStride = heapArrayStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) & VULKAN_HPP_NOEXCEPT + { + pEmbeddedSampler = pEmbeddedSampler_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) && VULKAN_HPP_NOEXCEPT + { + pEmbeddedSampler = pEmbeddedSampler_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) & VULKAN_HPP_NOEXCEPT + { + useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapOffset = samplerHeapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapOffset = samplerHeapOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerPushOffset( uint32_t samplerPushOffset_ ) & VULKAN_HPP_NOEXCEPT + { + samplerPushOffset = samplerPushOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerPushOffset( uint32_t samplerPushOffset_ ) && VULKAN_HPP_NOEXCEPT + { + samplerPushOffset = samplerPushOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapIndexStride = samplerHeapIndexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapIndexStride = samplerHeapIndexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapArrayStride = samplerHeapArrayStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapArrayStride = samplerHeapArrayStride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorMappingSourcePushIndexEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourcePushIndexEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourcePushIndexEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourcePushIndexEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( heapOffset, + pushOffset, + heapIndexStride, + heapArrayStride, + pEmbeddedSampler, + useCombinedImageSamplerIndex, + samplerHeapOffset, + samplerPushOffset, + samplerHeapIndexStride, + samplerHeapArrayStride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorMappingSourcePushIndexEXT const & ) const = default; +#else + bool operator==( DescriptorMappingSourcePushIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset ) && ( heapIndexStride == rhs.heapIndexStride ) && + ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) && + ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) && + ( samplerPushOffset == rhs.samplerPushOffset ) && ( samplerHeapIndexStride == rhs.samplerHeapIndexStride ) && + ( samplerHeapArrayStride == rhs.samplerHeapArrayStride ); +# endif + } + + bool operator!=( DescriptorMappingSourcePushIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t heapOffset = {}; + uint32_t pushOffset = {}; + uint32_t heapIndexStride = {}; + uint32_t heapArrayStride = {}; + const SamplerCreateInfo * pEmbeddedSampler = {}; + Bool32 useCombinedImageSamplerIndex = {}; + uint32_t samplerHeapOffset = {}; + uint32_t samplerPushOffset = {}; + uint32_t samplerHeapIndexStride = {}; + uint32_t samplerHeapArrayStride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorMappingSourcePushIndexEXT; + }; +#endif + + // wrapper struct for struct VkDescriptorMappingSourceIndirectIndexEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceIndirectIndexEXT.html + struct DescriptorMappingSourceIndirectIndexEXT + { + using NativeType = VkDescriptorMappingSourceIndirectIndexEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexEXT( uint32_t heapOffset_ = {}, + uint32_t pushOffset_ = {}, + uint32_t addressOffset_ = {}, + uint32_t heapIndexStride_ = {}, + uint32_t heapArrayStride_ = {}, + const SamplerCreateInfo * pEmbeddedSampler_ = {}, + Bool32 useCombinedImageSamplerIndex_ = {}, + uint32_t samplerHeapOffset_ = {}, + uint32_t samplerPushOffset_ = {}, + uint32_t samplerAddressOffset_ = {}, + uint32_t samplerHeapIndexStride_ = {}, + uint32_t samplerHeapArrayStride_ = {} ) VULKAN_HPP_NOEXCEPT + : heapOffset{ heapOffset_ } + , pushOffset{ pushOffset_ } + , addressOffset{ addressOffset_ } + , heapIndexStride{ heapIndexStride_ } + , heapArrayStride{ heapArrayStride_ } + , pEmbeddedSampler{ pEmbeddedSampler_ } + , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ } + , samplerHeapOffset{ samplerHeapOffset_ } + , samplerPushOffset{ samplerPushOffset_ } + , samplerAddressOffset{ samplerAddressOffset_ } + , samplerHeapIndexStride{ samplerHeapIndexStride_ } + , samplerHeapArrayStride{ samplerHeapArrayStride_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexEXT( DescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorMappingSourceIndirectIndexEXT( VkDescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorMappingSourceIndirectIndexEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorMappingSourceIndirectIndexEXT & operator=( DescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorMappingSourceIndirectIndexEXT & operator=( VkDescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT + { + pushOffset = pushOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT + { + pushOffset = pushOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setAddressOffset( uint32_t addressOffset_ ) & VULKAN_HPP_NOEXCEPT + { + addressOffset = addressOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setAddressOffset( uint32_t addressOffset_ ) && VULKAN_HPP_NOEXCEPT + { + addressOffset = addressOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT + { + heapIndexStride = heapIndexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT + { + heapIndexStride = heapIndexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT + { + heapArrayStride = heapArrayStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT + { + heapArrayStride = heapArrayStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) & VULKAN_HPP_NOEXCEPT + { + pEmbeddedSampler = pEmbeddedSampler_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) && VULKAN_HPP_NOEXCEPT + { + pEmbeddedSampler = pEmbeddedSampler_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) & + VULKAN_HPP_NOEXCEPT + { + useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapOffset = samplerHeapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapOffset = samplerHeapOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerPushOffset( uint32_t samplerPushOffset_ ) & VULKAN_HPP_NOEXCEPT + { + samplerPushOffset = samplerPushOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerPushOffset( uint32_t samplerPushOffset_ ) && VULKAN_HPP_NOEXCEPT + { + samplerPushOffset = samplerPushOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) & VULKAN_HPP_NOEXCEPT + { + samplerAddressOffset = samplerAddressOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) && VULKAN_HPP_NOEXCEPT + { + samplerAddressOffset = samplerAddressOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapIndexStride = samplerHeapIndexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapIndexStride = samplerHeapIndexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapArrayStride = samplerHeapArrayStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapArrayStride = samplerHeapArrayStride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorMappingSourceIndirectIndexEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceIndirectIndexEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceIndirectIndexEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceIndirectIndexEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( heapOffset, + pushOffset, + addressOffset, + heapIndexStride, + heapArrayStride, + pEmbeddedSampler, + useCombinedImageSamplerIndex, + samplerHeapOffset, + samplerPushOffset, + samplerAddressOffset, + samplerHeapIndexStride, + samplerHeapArrayStride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorMappingSourceIndirectIndexEXT const & ) const = default; +#else + bool operator==( DescriptorMappingSourceIndirectIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset ) && ( addressOffset == rhs.addressOffset ) && + ( heapIndexStride == rhs.heapIndexStride ) && ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) && + ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) && + ( samplerPushOffset == rhs.samplerPushOffset ) && ( samplerAddressOffset == rhs.samplerAddressOffset ) && + ( samplerHeapIndexStride == rhs.samplerHeapIndexStride ) && ( samplerHeapArrayStride == rhs.samplerHeapArrayStride ); +# endif + } + + bool operator!=( DescriptorMappingSourceIndirectIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t heapOffset = {}; + uint32_t pushOffset = {}; + uint32_t addressOffset = {}; + uint32_t heapIndexStride = {}; + uint32_t heapArrayStride = {}; + const SamplerCreateInfo * pEmbeddedSampler = {}; + Bool32 useCombinedImageSamplerIndex = {}; + uint32_t samplerHeapOffset = {}; + uint32_t samplerPushOffset = {}; + uint32_t samplerAddressOffset = {}; + uint32_t samplerHeapIndexStride = {}; + uint32_t samplerHeapArrayStride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorMappingSourceIndirectIndexEXT; + }; +#endif + + // wrapper struct for struct VkDescriptorMappingSourceIndirectIndexArrayEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceIndirectIndexArrayEXT.html + struct DescriptorMappingSourceIndirectIndexArrayEXT + { + using NativeType = VkDescriptorMappingSourceIndirectIndexArrayEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexArrayEXT( uint32_t heapOffset_ = {}, + uint32_t pushOffset_ = {}, + uint32_t addressOffset_ = {}, + uint32_t heapIndexStride_ = {}, + const SamplerCreateInfo * pEmbeddedSampler_ = {}, + Bool32 useCombinedImageSamplerIndex_ = {}, + uint32_t samplerHeapOffset_ = {}, + uint32_t samplerPushOffset_ = {}, + uint32_t samplerAddressOffset_ = {}, + uint32_t samplerHeapIndexStride_ = {} ) VULKAN_HPP_NOEXCEPT + : heapOffset{ heapOffset_ } + , pushOffset{ pushOffset_ } + , addressOffset{ addressOffset_ } + , heapIndexStride{ heapIndexStride_ } + , pEmbeddedSampler{ pEmbeddedSampler_ } + , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ } + , samplerHeapOffset{ samplerHeapOffset_ } + , samplerPushOffset{ samplerPushOffset_ } + , samplerAddressOffset{ samplerAddressOffset_ } + , samplerHeapIndexStride{ samplerHeapIndexStride_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexArrayEXT( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorMappingSourceIndirectIndexArrayEXT( VkDescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorMappingSourceIndirectIndexArrayEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorMappingSourceIndirectIndexArrayEXT & operator=( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorMappingSourceIndirectIndexArrayEXT & operator=( VkDescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT + { + pushOffset = pushOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT + { + pushOffset = pushOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setAddressOffset( uint32_t addressOffset_ ) & VULKAN_HPP_NOEXCEPT + { + addressOffset = addressOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setAddressOffset( uint32_t addressOffset_ ) && VULKAN_HPP_NOEXCEPT + { + addressOffset = addressOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT + { + heapIndexStride = heapIndexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT + { + heapIndexStride = heapIndexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) & + VULKAN_HPP_NOEXCEPT + { + pEmbeddedSampler = pEmbeddedSampler_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) && + VULKAN_HPP_NOEXCEPT + { + pEmbeddedSampler = pEmbeddedSampler_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) & + VULKAN_HPP_NOEXCEPT + { + useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapOffset = samplerHeapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapOffset = samplerHeapOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerPushOffset( uint32_t samplerPushOffset_ ) & VULKAN_HPP_NOEXCEPT + { + samplerPushOffset = samplerPushOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerPushOffset( uint32_t samplerPushOffset_ ) && VULKAN_HPP_NOEXCEPT + { + samplerPushOffset = samplerPushOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) & VULKAN_HPP_NOEXCEPT + { + samplerAddressOffset = samplerAddressOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) && VULKAN_HPP_NOEXCEPT + { + samplerAddressOffset = samplerAddressOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapIndexStride = samplerHeapIndexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapIndexStride = samplerHeapIndexStride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorMappingSourceIndirectIndexArrayEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceIndirectIndexArrayEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceIndirectIndexArrayEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceIndirectIndexArrayEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( heapOffset, + pushOffset, + addressOffset, + heapIndexStride, + pEmbeddedSampler, + useCombinedImageSamplerIndex, + samplerHeapOffset, + samplerPushOffset, + samplerAddressOffset, + samplerHeapIndexStride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorMappingSourceIndirectIndexArrayEXT const & ) const = default; +#else + bool operator==( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset ) && ( addressOffset == rhs.addressOffset ) && + ( heapIndexStride == rhs.heapIndexStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) && + ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) && + ( samplerPushOffset == rhs.samplerPushOffset ) && ( samplerAddressOffset == rhs.samplerAddressOffset ) && + ( samplerHeapIndexStride == rhs.samplerHeapIndexStride ); +# endif + } + + bool operator!=( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t heapOffset = {}; + uint32_t pushOffset = {}; + uint32_t addressOffset = {}; + uint32_t heapIndexStride = {}; + const SamplerCreateInfo * pEmbeddedSampler = {}; + Bool32 useCombinedImageSamplerIndex = {}; + uint32_t samplerHeapOffset = {}; + uint32_t samplerPushOffset = {}; + uint32_t samplerAddressOffset = {}; + uint32_t samplerHeapIndexStride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorMappingSourceIndirectIndexArrayEXT; + }; +#endif + + // wrapper struct for struct VkDescriptorMappingSourceHeapDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceHeapDataEXT.html + struct DescriptorMappingSourceHeapDataEXT + { + using NativeType = VkDescriptorMappingSourceHeapDataEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceHeapDataEXT( uint32_t heapOffset_ = {}, uint32_t pushOffset_ = {} ) VULKAN_HPP_NOEXCEPT + : heapOffset{ heapOffset_ } + , pushOffset{ pushOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceHeapDataEXT( DescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorMappingSourceHeapDataEXT( VkDescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorMappingSourceHeapDataEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorMappingSourceHeapDataEXT & operator=( DescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorMappingSourceHeapDataEXT & operator=( VkDescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT + { + pushOffset = pushOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT + { + pushOffset = pushOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorMappingSourceHeapDataEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceHeapDataEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceHeapDataEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceHeapDataEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( heapOffset, pushOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorMappingSourceHeapDataEXT const & ) const = default; +#else + bool operator==( DescriptorMappingSourceHeapDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset ); +# endif + } + + bool operator!=( DescriptorMappingSourceHeapDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t heapOffset = {}; + uint32_t pushOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorMappingSourceHeapDataEXT; + }; +#endif + + // wrapper struct for struct VkDescriptorMappingSourceIndirectAddressEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceIndirectAddressEXT.html + struct DescriptorMappingSourceIndirectAddressEXT + { + using NativeType = VkDescriptorMappingSourceIndirectAddressEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectAddressEXT( uint32_t pushOffset_ = {}, uint32_t addressOffset_ = {} ) VULKAN_HPP_NOEXCEPT + : pushOffset{ pushOffset_ } + , addressOffset{ addressOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectAddressEXT( DescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorMappingSourceIndirectAddressEXT( VkDescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorMappingSourceIndirectAddressEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorMappingSourceIndirectAddressEXT & operator=( DescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorMappingSourceIndirectAddressEXT & operator=( VkDescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT + { + pushOffset = pushOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT + { + pushOffset = pushOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT & setAddressOffset( uint32_t addressOffset_ ) & VULKAN_HPP_NOEXCEPT + { + addressOffset = addressOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT && setAddressOffset( uint32_t addressOffset_ ) && VULKAN_HPP_NOEXCEPT + { + addressOffset = addressOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorMappingSourceIndirectAddressEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceIndirectAddressEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceIndirectAddressEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceIndirectAddressEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( pushOffset, addressOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorMappingSourceIndirectAddressEXT const & ) const = default; +#else + bool operator==( DescriptorMappingSourceIndirectAddressEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( pushOffset == rhs.pushOffset ) && ( addressOffset == rhs.addressOffset ); +# endif + } + + bool operator!=( DescriptorMappingSourceIndirectAddressEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t pushOffset = {}; + uint32_t addressOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorMappingSourceIndirectAddressEXT; + }; +#endif + + // wrapper struct for struct VkDescriptorMappingSourceShaderRecordIndexEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceShaderRecordIndexEXT.html + struct DescriptorMappingSourceShaderRecordIndexEXT + { + using NativeType = VkDescriptorMappingSourceShaderRecordIndexEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceShaderRecordIndexEXT( uint32_t heapOffset_ = {}, + uint32_t shaderRecordOffset_ = {}, + uint32_t heapIndexStride_ = {}, + uint32_t heapArrayStride_ = {}, + const SamplerCreateInfo * pEmbeddedSampler_ = {}, + Bool32 useCombinedImageSamplerIndex_ = {}, + uint32_t samplerHeapOffset_ = {}, + uint32_t samplerShaderRecordOffset_ = {}, + uint32_t samplerHeapIndexStride_ = {}, + uint32_t samplerHeapArrayStride_ = {} ) VULKAN_HPP_NOEXCEPT + : heapOffset{ heapOffset_ } + , shaderRecordOffset{ shaderRecordOffset_ } + , heapIndexStride{ heapIndexStride_ } + , heapArrayStride{ heapArrayStride_ } + , pEmbeddedSampler{ pEmbeddedSampler_ } + , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ } + , samplerHeapOffset{ samplerHeapOffset_ } + , samplerShaderRecordOffset{ samplerShaderRecordOffset_ } + , samplerHeapIndexStride{ samplerHeapIndexStride_ } + , samplerHeapArrayStride{ samplerHeapArrayStride_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorMappingSourceShaderRecordIndexEXT( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorMappingSourceShaderRecordIndexEXT( VkDescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorMappingSourceShaderRecordIndexEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorMappingSourceShaderRecordIndexEXT & operator=( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorMappingSourceShaderRecordIndexEXT & operator=( VkDescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT + { + heapOffset = heapOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setShaderRecordOffset( uint32_t shaderRecordOffset_ ) & VULKAN_HPP_NOEXCEPT + { + shaderRecordOffset = shaderRecordOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setShaderRecordOffset( uint32_t shaderRecordOffset_ ) && VULKAN_HPP_NOEXCEPT + { + shaderRecordOffset = shaderRecordOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT + { + heapIndexStride = heapIndexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT + { + heapIndexStride = heapIndexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT + { + heapArrayStride = heapArrayStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT + { + heapArrayStride = heapArrayStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) & + VULKAN_HPP_NOEXCEPT + { + pEmbeddedSampler = pEmbeddedSampler_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) && + VULKAN_HPP_NOEXCEPT + { + pEmbeddedSampler = pEmbeddedSampler_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) & + VULKAN_HPP_NOEXCEPT + { + useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapOffset = samplerHeapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapOffset = samplerHeapOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerShaderRecordOffset( uint32_t samplerShaderRecordOffset_ ) & + VULKAN_HPP_NOEXCEPT + { + samplerShaderRecordOffset = samplerShaderRecordOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerShaderRecordOffset( uint32_t samplerShaderRecordOffset_ ) && + VULKAN_HPP_NOEXCEPT + { + samplerShaderRecordOffset = samplerShaderRecordOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapIndexStride = samplerHeapIndexStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapIndexStride = samplerHeapIndexStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT + { + samplerHeapArrayStride = samplerHeapArrayStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT + { + samplerHeapArrayStride = samplerHeapArrayStride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorMappingSourceShaderRecordIndexEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceShaderRecordIndexEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceShaderRecordIndexEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceShaderRecordIndexEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( heapOffset, + shaderRecordOffset, + heapIndexStride, + heapArrayStride, + pEmbeddedSampler, + useCombinedImageSamplerIndex, + samplerHeapOffset, + samplerShaderRecordOffset, + samplerHeapIndexStride, + samplerHeapArrayStride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorMappingSourceShaderRecordIndexEXT const & ) const = default; +#else + bool operator==( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( heapOffset == rhs.heapOffset ) && ( shaderRecordOffset == rhs.shaderRecordOffset ) && ( heapIndexStride == rhs.heapIndexStride ) && + ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) && + ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) && + ( samplerShaderRecordOffset == rhs.samplerShaderRecordOffset ) && ( samplerHeapIndexStride == rhs.samplerHeapIndexStride ) && + ( samplerHeapArrayStride == rhs.samplerHeapArrayStride ); +# endif + } + + bool operator!=( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t heapOffset = {}; + uint32_t shaderRecordOffset = {}; + uint32_t heapIndexStride = {}; + uint32_t heapArrayStride = {}; + const SamplerCreateInfo * pEmbeddedSampler = {}; + Bool32 useCombinedImageSamplerIndex = {}; + uint32_t samplerHeapOffset = {}; + uint32_t samplerShaderRecordOffset = {}; + uint32_t samplerHeapIndexStride = {}; + uint32_t samplerHeapArrayStride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorMappingSourceShaderRecordIndexEXT; + }; +#endif + + union DescriptorMappingSourceDataEXT + { + using NativeType = VkDescriptorMappingSourceDataEXT; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceConstantOffsetEXT constantOffset_ = {} ) : constantOffset( constantOffset_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourcePushIndexEXT pushIndex_ ) : pushIndex( pushIndex_ ) {} + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceIndirectIndexEXT indirectIndex_ ) : indirectIndex( indirectIndex_ ) {} + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray_ ) + : indirectIndexArray( indirectIndexArray_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceHeapDataEXT heapData_ ) : heapData( heapData_ ) {} + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( uint32_t uint32_t_ ) : pushDataOffset( uint32_t_ ) {} + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceIndirectAddressEXT indirectAddress_ ) : indirectAddress( indirectAddress_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceShaderRecordIndexEXT shaderRecordIndex_ ) + : shaderRecordIndex( shaderRecordIndex_ ) + { + } +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setConstantOffset( DescriptorMappingSourceConstantOffsetEXT const & constantOffset_ ) & + VULKAN_HPP_NOEXCEPT + { + constantOffset = constantOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setConstantOffset( DescriptorMappingSourceConstantOffsetEXT const & constantOffset_ ) && + VULKAN_HPP_NOEXCEPT + { + constantOffset = constantOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setPushIndex( DescriptorMappingSourcePushIndexEXT const & pushIndex_ ) & VULKAN_HPP_NOEXCEPT + { + pushIndex = pushIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setPushIndex( DescriptorMappingSourcePushIndexEXT const & pushIndex_ ) && VULKAN_HPP_NOEXCEPT + { + pushIndex = pushIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setIndirectIndex( DescriptorMappingSourceIndirectIndexEXT const & indirectIndex_ ) & + VULKAN_HPP_NOEXCEPT + { + indirectIndex = indirectIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setIndirectIndex( DescriptorMappingSourceIndirectIndexEXT const & indirectIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + indirectIndex = indirectIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setIndirectIndexArray( DescriptorMappingSourceIndirectIndexArrayEXT const & indirectIndexArray_ ) & + VULKAN_HPP_NOEXCEPT + { + indirectIndexArray = indirectIndexArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && + setIndirectIndexArray( DescriptorMappingSourceIndirectIndexArrayEXT const & indirectIndexArray_ ) && + VULKAN_HPP_NOEXCEPT + { + indirectIndexArray = indirectIndexArray_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setHeapData( DescriptorMappingSourceHeapDataEXT const & heapData_ ) & VULKAN_HPP_NOEXCEPT + { + heapData = heapData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setHeapData( DescriptorMappingSourceHeapDataEXT const & heapData_ ) && VULKAN_HPP_NOEXCEPT + { + heapData = heapData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setPushDataOffset( uint32_t pushDataOffset_ ) & VULKAN_HPP_NOEXCEPT + { + pushDataOffset = pushDataOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setPushDataOffset( uint32_t pushDataOffset_ ) && VULKAN_HPP_NOEXCEPT + { + pushDataOffset = pushDataOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setPushAddressOffset( uint32_t pushAddressOffset_ ) & VULKAN_HPP_NOEXCEPT + { + pushAddressOffset = pushAddressOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setPushAddressOffset( uint32_t pushAddressOffset_ ) && VULKAN_HPP_NOEXCEPT + { + pushAddressOffset = pushAddressOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setIndirectAddress( DescriptorMappingSourceIndirectAddressEXT const & indirectAddress_ ) & + VULKAN_HPP_NOEXCEPT + { + indirectAddress = indirectAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setIndirectAddress( DescriptorMappingSourceIndirectAddressEXT const & indirectAddress_ ) && + VULKAN_HPP_NOEXCEPT + { + indirectAddress = indirectAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setShaderRecordIndex( DescriptorMappingSourceShaderRecordIndexEXT const & shaderRecordIndex_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderRecordIndex = shaderRecordIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setShaderRecordIndex( DescriptorMappingSourceShaderRecordIndexEXT const & shaderRecordIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderRecordIndex = shaderRecordIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setShaderRecordDataOffset( uint32_t shaderRecordDataOffset_ ) & VULKAN_HPP_NOEXCEPT + { + shaderRecordDataOffset = shaderRecordDataOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setShaderRecordDataOffset( uint32_t shaderRecordDataOffset_ ) && VULKAN_HPP_NOEXCEPT + { + shaderRecordDataOffset = shaderRecordDataOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setShaderRecordAddressOffset( uint32_t shaderRecordAddressOffset_ ) & VULKAN_HPP_NOEXCEPT + { + shaderRecordAddressOffset = shaderRecordAddressOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setShaderRecordAddressOffset( uint32_t shaderRecordAddressOffset_ ) && VULKAN_HPP_NOEXCEPT + { + shaderRecordAddressOffset = shaderRecordAddressOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorMappingSourceDataEXT const &() const + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorMappingSourceDataEXT &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + DescriptorMappingSourceConstantOffsetEXT constantOffset; + DescriptorMappingSourcePushIndexEXT pushIndex; + DescriptorMappingSourceIndirectIndexEXT indirectIndex; + DescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray; + DescriptorMappingSourceHeapDataEXT heapData; + uint32_t pushDataOffset; + uint32_t pushAddressOffset; + DescriptorMappingSourceIndirectAddressEXT indirectAddress; + DescriptorMappingSourceShaderRecordIndexEXT shaderRecordIndex; + uint32_t shaderRecordDataOffset; + uint32_t shaderRecordAddressOffset; +#else + VkDescriptorMappingSourceConstantOffsetEXT constantOffset; + VkDescriptorMappingSourcePushIndexEXT pushIndex; + VkDescriptorMappingSourceIndirectIndexEXT indirectIndex; + VkDescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray; + VkDescriptorMappingSourceHeapDataEXT heapData; + uint32_t pushDataOffset; + uint32_t pushAddressOffset; + VkDescriptorMappingSourceIndirectAddressEXT indirectAddress; + VkDescriptorMappingSourceShaderRecordIndexEXT shaderRecordIndex; + uint32_t shaderRecordDataOffset; + uint32_t shaderRecordAddressOffset; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorMappingSourceDataEXT; + }; +#endif + + // wrapper struct for struct VkDescriptorPoolSize, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolSize.html + struct DescriptorPoolSize + { + using NativeType = VkDescriptorPoolSize; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler, uint32_t descriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT + : type{ type_ } + , descriptorCount{ descriptorCount_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorPoolSize( DescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT : DescriptorPoolSize( *reinterpret_cast( &rhs ) ) {} + + DescriptorPoolSize & operator=( DescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorPoolSize & operator=( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize & setType( DescriptorType type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize && setType( DescriptorType type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorCount = descriptorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorCount = descriptorCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorPoolSize const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorPoolSize &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorPoolSize const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorPoolSize *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( type, descriptorCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorPoolSize const & ) const = default; +#else + bool operator==( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( type == rhs.type ) && ( descriptorCount == rhs.descriptorCount ); +# endif + } + + bool operator!=( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DescriptorType type = DescriptorType::eSampler; + uint32_t descriptorCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorPoolSize; + }; +#endif + + // wrapper struct for struct VkDescriptorPoolCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolCreateInfo.html + struct DescriptorPoolCreateInfo + { + using NativeType = VkDescriptorPoolCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorPoolCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = {}, + uint32_t maxSets_ = {}, + uint32_t poolSizeCount_ = {}, + const DescriptorPoolSize * pPoolSizes_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , maxSets{ maxSets_ } + , poolSizeCount{ poolSizeCount_ } + , pPoolSizes{ pPoolSizes_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorPoolCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_, + uint32_t maxSets_, + ArrayProxyNoTemporaries const & poolSizes_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), flags( flags_ ), maxSets( maxSets_ ), poolSizeCount( static_cast( poolSizes_.size() ) ), pPoolSizes( poolSizes_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DescriptorPoolCreateInfo & operator=( DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorPoolCreateInfo & operator=( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setFlags( DescriptorPoolCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setFlags( DescriptorPoolCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setMaxSets( uint32_t maxSets_ ) & VULKAN_HPP_NOEXCEPT + { + maxSets = maxSets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setMaxSets( uint32_t maxSets_ ) && VULKAN_HPP_NOEXCEPT + { + maxSets = maxSets_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setPoolSizeCount( uint32_t poolSizeCount_ ) & VULKAN_HPP_NOEXCEPT + { + poolSizeCount = poolSizeCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setPoolSizeCount( uint32_t poolSizeCount_ ) && VULKAN_HPP_NOEXCEPT + { + poolSizeCount = poolSizeCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setPPoolSizes( const DescriptorPoolSize * pPoolSizes_ ) & VULKAN_HPP_NOEXCEPT + { + pPoolSizes = pPoolSizes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setPPoolSizes( const DescriptorPoolSize * pPoolSizes_ ) && VULKAN_HPP_NOEXCEPT + { + pPoolSizes = pPoolSizes_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorPoolCreateInfo & setPoolSizes( ArrayProxyNoTemporaries const & poolSizes_ ) VULKAN_HPP_NOEXCEPT + { + poolSizeCount = static_cast( poolSizes_.size() ); + pPoolSizes = poolSizes_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorPoolCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorPoolCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorPoolCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, maxSets, poolSizeCount, pPoolSizes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorPoolCreateInfo const & ) const = default; +#else + bool operator==( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxSets == rhs.maxSets ) && + ( poolSizeCount == rhs.poolSizeCount ) && ( pPoolSizes == rhs.pPoolSizes ); +# endif + } + + bool operator!=( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorPoolCreateInfo; + const void * pNext = {}; + DescriptorPoolCreateFlags flags = {}; + uint32_t maxSets = {}; + uint32_t poolSizeCount = {}; + const DescriptorPoolSize * pPoolSizes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorPoolCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorPoolCreateInfo; + }; + + // wrapper struct for struct VkDescriptorPoolInlineUniformBlockCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolInlineUniformBlockCreateInfo.html + struct DescriptorPoolInlineUniformBlockCreateInfo + { + using NativeType = VkDescriptorPoolInlineUniformBlockCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfo( uint32_t maxInlineUniformBlockBindings_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxInlineUniformBlockBindings{ maxInlineUniformBlockBindings_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfo( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorPoolInlineUniformBlockCreateInfo( VkDescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorPoolInlineUniformBlockCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorPoolInlineUniformBlockCreateInfo & operator=( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorPoolInlineUniformBlockCreateInfo & operator=( VkDescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo & setMaxInlineUniformBlockBindings( uint32_t maxInlineUniformBlockBindings_ ) & + VULKAN_HPP_NOEXCEPT + { + maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo && setMaxInlineUniformBlockBindings( uint32_t maxInlineUniformBlockBindings_ ) && + VULKAN_HPP_NOEXCEPT + { + maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorPoolInlineUniformBlockCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorPoolInlineUniformBlockCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorPoolInlineUniformBlockCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorPoolInlineUniformBlockCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxInlineUniformBlockBindings ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfo const & ) const = default; +#else + bool operator==( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings ); +# endif + } + + bool operator!=( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfo; + const void * pNext = {}; + uint32_t maxInlineUniformBlockBindings = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorPoolInlineUniformBlockCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorPoolInlineUniformBlockCreateInfo; + }; + + using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo; + + // wrapper struct for struct VkDescriptorSetAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetAllocateInfo.html + struct DescriptorSetAllocateInfo + { + using NativeType = VkDescriptorSetAllocateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetAllocateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = {}, + uint32_t descriptorSetCount_ = {}, + const DescriptorSetLayout * pSetLayouts_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorPool{ descriptorPool_ } + , descriptorSetCount{ descriptorSetCount_ } + , pSetLayouts{ pSetLayouts_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorSetAllocateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorSetAllocateInfo( DescriptorPool descriptorPool_, + ArrayProxyNoTemporaries const & setLayouts_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), descriptorPool( descriptorPool_ ), descriptorSetCount( static_cast( setLayouts_.size() ) ), pSetLayouts( setLayouts_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DescriptorSetAllocateInfo & operator=( DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorSetAllocateInfo & operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setDescriptorPool( DescriptorPool descriptorPool_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorPool = descriptorPool_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setDescriptorPool( DescriptorPool descriptorPool_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorPool = descriptorPool_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setDescriptorSetCount( uint32_t descriptorSetCount_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorSetCount = descriptorSetCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setDescriptorSetCount( uint32_t descriptorSetCount_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorSetCount = descriptorSetCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) & VULKAN_HPP_NOEXCEPT + { + pSetLayouts = pSetLayouts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) && VULKAN_HPP_NOEXCEPT + { + pSetLayouts = pSetLayouts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorSetAllocateInfo & setSetLayouts( ArrayProxyNoTemporaries const & setLayouts_ ) VULKAN_HPP_NOEXCEPT + { + descriptorSetCount = static_cast( setLayouts_.size() ); + pSetLayouts = setLayouts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorSetAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetAllocateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetAllocateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorSetAllocateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorPool, descriptorSetCount, pSetLayouts ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorSetAllocateInfo const & ) const = default; +#else + bool operator==( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPool == rhs.descriptorPool ) && ( descriptorSetCount == rhs.descriptorSetCount ) && + ( pSetLayouts == rhs.pSetLayouts ); +# endif + } + + bool operator!=( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorSetAllocateInfo; + const void * pNext = {}; + DescriptorPool descriptorPool = {}; + uint32_t descriptorSetCount = {}; + const DescriptorSetLayout * pSetLayouts = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorSetAllocateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorSetAllocateInfo; + }; + + // wrapper struct for struct VkDescriptorSetAndBindingMappingEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetAndBindingMappingEXT.html + struct DescriptorSetAndBindingMappingEXT + { + using NativeType = VkDescriptorSetAndBindingMappingEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetAndBindingMappingEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT( uint32_t descriptorSet_ = {}, + uint32_t firstBinding_ = {}, + uint32_t bindingCount_ = {}, + SpirvResourceTypeFlagsEXT resourceMask_ = {}, + DescriptorMappingSourceEXT source_ = DescriptorMappingSourceEXT::eHeapWithConstantOffset, + DescriptorMappingSourceDataEXT sourceData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorSet{ descriptorSet_ } + , firstBinding{ firstBinding_ } + , bindingCount{ bindingCount_ } + , resourceMask{ resourceMask_ } + , source{ source_ } + , sourceData{ sourceData_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT( DescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorSetAndBindingMappingEXT( VkDescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorSetAndBindingMappingEXT( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorSetAndBindingMappingEXT & operator=( DescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorSetAndBindingMappingEXT & operator=( VkDescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setDescriptorSet( uint32_t descriptorSet_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorSet = descriptorSet_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setDescriptorSet( uint32_t descriptorSet_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorSet = descriptorSet_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setFirstBinding( uint32_t firstBinding_ ) & VULKAN_HPP_NOEXCEPT + { + firstBinding = firstBinding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setFirstBinding( uint32_t firstBinding_ ) && VULKAN_HPP_NOEXCEPT + { + firstBinding = firstBinding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setBindingCount( uint32_t bindingCount_ ) & VULKAN_HPP_NOEXCEPT + { + bindingCount = bindingCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setBindingCount( uint32_t bindingCount_ ) && VULKAN_HPP_NOEXCEPT + { + bindingCount = bindingCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setResourceMask( SpirvResourceTypeFlagsEXT resourceMask_ ) & VULKAN_HPP_NOEXCEPT + { + resourceMask = resourceMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setResourceMask( SpirvResourceTypeFlagsEXT resourceMask_ ) && VULKAN_HPP_NOEXCEPT + { + resourceMask = resourceMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setSource( DescriptorMappingSourceEXT source_ ) & VULKAN_HPP_NOEXCEPT + { + source = source_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setSource( DescriptorMappingSourceEXT source_ ) && VULKAN_HPP_NOEXCEPT + { + source = source_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setSourceData( DescriptorMappingSourceDataEXT const & sourceData_ ) & VULKAN_HPP_NOEXCEPT + { + sourceData = sourceData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setSourceData( DescriptorMappingSourceDataEXT const & sourceData_ ) && VULKAN_HPP_NOEXCEPT + { + sourceData = sourceData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorSetAndBindingMappingEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetAndBindingMappingEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetAndBindingMappingEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorSetAndBindingMappingEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorSet, firstBinding, bindingCount, resourceMask, source, sourceData ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorSetAndBindingMappingEXT; + const void * pNext = {}; + uint32_t descriptorSet = {}; + uint32_t firstBinding = {}; + uint32_t bindingCount = {}; + SpirvResourceTypeFlagsEXT resourceMask = {}; + DescriptorMappingSourceEXT source = DescriptorMappingSourceEXT::eHeapWithConstantOffset; + DescriptorMappingSourceDataEXT sourceData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorSetAndBindingMappingEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorSetAndBindingMappingEXT; + }; + + // wrapper struct for struct VkDescriptorSetBindingReferenceVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetBindingReferenceVALVE.html + struct DescriptorSetBindingReferenceVALVE + { + using NativeType = VkDescriptorSetBindingReferenceVALVE; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetBindingReferenceVALVE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorSetBindingReferenceVALVE( DescriptorSetLayout descriptorSetLayout_ = {}, + uint32_t binding_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorSetLayout{ descriptorSetLayout_ } + , binding{ binding_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorSetBindingReferenceVALVE( DescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorSetBindingReferenceVALVE( VkDescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorSetBindingReferenceVALVE( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorSetBindingReferenceVALVE & operator=( DescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorSetBindingReferenceVALVE & operator=( VkDescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE & setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorSetLayout = descriptorSetLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE && setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorSetLayout = descriptorSetLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorSetBindingReferenceVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetBindingReferenceVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetBindingReferenceVALVE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorSetBindingReferenceVALVE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorSetLayout, binding ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorSetBindingReferenceVALVE const & ) const = default; +#else + bool operator==( DescriptorSetBindingReferenceVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetLayout == rhs.descriptorSetLayout ) && ( binding == rhs.binding ); +# endif + } + + bool operator!=( DescriptorSetBindingReferenceVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorSetBindingReferenceVALVE; + const void * pNext = {}; + DescriptorSetLayout descriptorSetLayout = {}; + uint32_t binding = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorSetBindingReferenceVALVE; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorSetBindingReferenceVALVE; + }; + + // wrapper struct for struct VkDescriptorSetLayoutBinding, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutBinding.html + struct DescriptorSetLayoutBinding + { + using NativeType = VkDescriptorSetLayoutBinding; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( uint32_t binding_ = {}, + DescriptorType descriptorType_ = DescriptorType::eSampler, + uint32_t descriptorCount_ = {}, + ShaderStageFlags stageFlags_ = {}, + const Sampler * pImmutableSamplers_ = {} ) VULKAN_HPP_NOEXCEPT + : binding{ binding_ } + , descriptorType{ descriptorType_ } + , descriptorCount{ descriptorCount_ } + , stageFlags{ stageFlags_ } + , pImmutableSamplers{ pImmutableSamplers_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( DescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorSetLayoutBinding( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorSetLayoutBinding( uint32_t binding_, + DescriptorType descriptorType_, + ShaderStageFlags stageFlags_, + ArrayProxyNoTemporaries const & immutableSamplers_ ) + : binding( binding_ ) + , descriptorType( descriptorType_ ) + , descriptorCount( static_cast( immutableSamplers_.size() ) ) + , stageFlags( stageFlags_ ) + , pImmutableSamplers( immutableSamplers_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DescriptorSetLayoutBinding & operator=( DescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorSetLayoutBinding & operator=( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setDescriptorType( DescriptorType descriptorType_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorType = descriptorType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setDescriptorType( DescriptorType descriptorType_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorType = descriptorType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorCount = descriptorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorCount = descriptorCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setPImmutableSamplers( const Sampler * pImmutableSamplers_ ) & VULKAN_HPP_NOEXCEPT + { + pImmutableSamplers = pImmutableSamplers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setPImmutableSamplers( const Sampler * pImmutableSamplers_ ) && VULKAN_HPP_NOEXCEPT + { + pImmutableSamplers = pImmutableSamplers_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorSetLayoutBinding & setImmutableSamplers( ArrayProxyNoTemporaries const & immutableSamplers_ ) VULKAN_HPP_NOEXCEPT + { + descriptorCount = static_cast( immutableSamplers_.size() ); + pImmutableSamplers = immutableSamplers_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorSetLayoutBinding const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutBinding &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutBinding const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutBinding *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorSetLayoutBinding const & ) const = default; +#else + bool operator==( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( binding == rhs.binding ) && ( descriptorType == rhs.descriptorType ) && ( descriptorCount == rhs.descriptorCount ) && + ( stageFlags == rhs.stageFlags ) && ( pImmutableSamplers == rhs.pImmutableSamplers ); +# endif + } + + bool operator!=( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t binding = {}; + DescriptorType descriptorType = DescriptorType::eSampler; + uint32_t descriptorCount = {}; + ShaderStageFlags stageFlags = {}; + const Sampler * pImmutableSamplers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorSetLayoutBinding; + }; +#endif + + // wrapper struct for struct VkDescriptorSetLayoutBindingFlagsCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html + struct DescriptorSetLayoutBindingFlagsCreateInfo + { + using NativeType = VkDescriptorSetLayoutBindingFlagsCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfo( uint32_t bindingCount_ = {}, + const DescriptorBindingFlags * pBindingFlags_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , bindingCount{ bindingCount_ } + , pBindingFlags{ pBindingFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfo( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorSetLayoutBindingFlagsCreateInfo( VkDescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorSetLayoutBindingFlagsCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorSetLayoutBindingFlagsCreateInfo( ArrayProxyNoTemporaries const & bindingFlags_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), bindingCount( static_cast( bindingFlags_.size() ) ), pBindingFlags( bindingFlags_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DescriptorSetLayoutBindingFlagsCreateInfo & operator=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorSetLayoutBindingFlagsCreateInfo & operator=( VkDescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo & setBindingCount( uint32_t bindingCount_ ) & VULKAN_HPP_NOEXCEPT + { + bindingCount = bindingCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo && setBindingCount( uint32_t bindingCount_ ) && VULKAN_HPP_NOEXCEPT + { + bindingCount = bindingCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo & setPBindingFlags( const DescriptorBindingFlags * pBindingFlags_ ) & VULKAN_HPP_NOEXCEPT + { + pBindingFlags = pBindingFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo && setPBindingFlags( const DescriptorBindingFlags * pBindingFlags_ ) && + VULKAN_HPP_NOEXCEPT + { + pBindingFlags = pBindingFlags_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorSetLayoutBindingFlagsCreateInfo & + setBindingFlags( ArrayProxyNoTemporaries const & bindingFlags_ ) VULKAN_HPP_NOEXCEPT + { + bindingCount = static_cast( bindingFlags_.size() ); + pBindingFlags = bindingFlags_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorSetLayoutBindingFlagsCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutBindingFlagsCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutBindingFlagsCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutBindingFlagsCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, bindingCount, pBindingFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfo const & ) const = default; +#else + bool operator==( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindingCount == rhs.bindingCount ) && ( pBindingFlags == rhs.pBindingFlags ); +# endif + } + + bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo; + const void * pNext = {}; + uint32_t bindingCount = {}; + const DescriptorBindingFlags * pBindingFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorSetLayoutBindingFlagsCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorSetLayoutBindingFlagsCreateInfo; + }; + + using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo; + + // wrapper struct for struct VkDescriptorSetLayoutCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutCreateInfo.html + struct DescriptorSetLayoutCreateInfo + { + using NativeType = VkDescriptorSetLayoutCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = {}, + uint32_t bindingCount_ = {}, + const DescriptorSetLayoutBinding * pBindings_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , bindingCount{ bindingCount_ } + , pBindings{ pBindings_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorSetLayoutCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_, + ArrayProxyNoTemporaries const & bindings_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), flags( flags_ ), bindingCount( static_cast( bindings_.size() ) ), pBindings( bindings_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DescriptorSetLayoutCreateInfo & operator=( DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorSetLayoutCreateInfo & operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setFlags( DescriptorSetLayoutCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setFlags( DescriptorSetLayoutCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setBindingCount( uint32_t bindingCount_ ) & VULKAN_HPP_NOEXCEPT + { + bindingCount = bindingCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setBindingCount( uint32_t bindingCount_ ) && VULKAN_HPP_NOEXCEPT + { + bindingCount = bindingCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setPBindings( const DescriptorSetLayoutBinding * pBindings_ ) & VULKAN_HPP_NOEXCEPT + { + pBindings = pBindings_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setPBindings( const DescriptorSetLayoutBinding * pBindings_ ) && VULKAN_HPP_NOEXCEPT + { + pBindings = pBindings_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorSetLayoutCreateInfo & setBindings( ArrayProxyNoTemporaries const & bindings_ ) VULKAN_HPP_NOEXCEPT + { + bindingCount = static_cast( bindings_.size() ); + pBindings = bindings_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorSetLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, bindingCount, pBindings ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorSetLayoutCreateInfo const & ) const = default; +#else + bool operator==( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( bindingCount == rhs.bindingCount ) && + ( pBindings == rhs.pBindings ); +# endif + } + + bool operator!=( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo; + const void * pNext = {}; + DescriptorSetLayoutCreateFlags flags = {}; + uint32_t bindingCount = {}; + const DescriptorSetLayoutBinding * pBindings = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorSetLayoutCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorSetLayoutCreateInfo; + }; + + // wrapper struct for struct VkDescriptorSetLayoutHostMappingInfoVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutHostMappingInfoVALVE.html + struct DescriptorSetLayoutHostMappingInfoVALVE + { + using NativeType = VkDescriptorSetLayoutHostMappingInfoVALVE; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutHostMappingInfoVALVE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DescriptorSetLayoutHostMappingInfoVALVE( size_t descriptorOffset_ = {}, uint32_t descriptorSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorOffset{ descriptorOffset_ } + , descriptorSize{ descriptorSize_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutHostMappingInfoVALVE( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorSetLayoutHostMappingInfoVALVE( VkDescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorSetLayoutHostMappingInfoVALVE( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorSetLayoutHostMappingInfoVALVE & operator=( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorSetLayoutHostMappingInfoVALVE & operator=( VkDescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE & setDescriptorOffset( size_t descriptorOffset_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorOffset = descriptorOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE && setDescriptorOffset( size_t descriptorOffset_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorOffset = descriptorOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE & setDescriptorSize( uint32_t descriptorSize_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorSize = descriptorSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE && setDescriptorSize( uint32_t descriptorSize_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorSize = descriptorSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorSetLayoutHostMappingInfoVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutHostMappingInfoVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutHostMappingInfoVALVE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutHostMappingInfoVALVE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorOffset, descriptorSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorSetLayoutHostMappingInfoVALVE const & ) const = default; +#else + bool operator==( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorOffset == rhs.descriptorOffset ) && ( descriptorSize == rhs.descriptorSize ); +# endif + } + + bool operator!=( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorSetLayoutHostMappingInfoVALVE; + void * pNext = {}; + size_t descriptorOffset = {}; + uint32_t descriptorSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorSetLayoutHostMappingInfoVALVE; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorSetLayoutHostMappingInfoVALVE; + }; + + // wrapper struct for struct VkDescriptorSetLayoutSupport, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutSupport.html + struct DescriptorSetLayoutSupport + { + using NativeType = VkDescriptorSetLayoutSupport; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutSupport; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( Bool32 supported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , supported{ supported_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorSetLayoutSupport( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorSetLayoutSupport & operator=( DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorSetLayoutSupport & operator=( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDescriptorSetLayoutSupport const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutSupport &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutSupport const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorSetLayoutSupport *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supported ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorSetLayoutSupport const & ) const = default; +#else + bool operator==( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported ); +# endif + } + + bool operator!=( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorSetLayoutSupport; + void * pNext = {}; + Bool32 supported = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorSetLayoutSupport; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorSetLayoutSupport; + }; + + using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; + + // wrapper struct for struct VkDescriptorSetVariableDescriptorCountAllocateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html + struct DescriptorSetVariableDescriptorCountAllocateInfo + { + using NativeType = VkDescriptorSetVariableDescriptorCountAllocateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfo( uint32_t descriptorSetCount_ = {}, + const uint32_t * pDescriptorCounts_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorSetCount{ descriptorSetCount_ } + , pDescriptorCounts{ pDescriptorCounts_ } + { + } + + VULKAN_HPP_CONSTEXPR + DescriptorSetVariableDescriptorCountAllocateInfo( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorSetVariableDescriptorCountAllocateInfo( VkDescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorSetVariableDescriptorCountAllocateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorSetVariableDescriptorCountAllocateInfo( ArrayProxyNoTemporaries const & descriptorCounts_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), descriptorSetCount( static_cast( descriptorCounts_.size() ) ), pDescriptorCounts( descriptorCounts_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DescriptorSetVariableDescriptorCountAllocateInfo & operator=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorSetVariableDescriptorCountAllocateInfo & operator=( VkDescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo & setDescriptorSetCount( uint32_t descriptorSetCount_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorSetCount = descriptorSetCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo && setDescriptorSetCount( uint32_t descriptorSetCount_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorSetCount = descriptorSetCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo & setPDescriptorCounts( const uint32_t * pDescriptorCounts_ ) & VULKAN_HPP_NOEXCEPT + { + pDescriptorCounts = pDescriptorCounts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo && setPDescriptorCounts( const uint32_t * pDescriptorCounts_ ) && + VULKAN_HPP_NOEXCEPT + { + pDescriptorCounts = pDescriptorCounts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorSetVariableDescriptorCountAllocateInfo & + setDescriptorCounts( ArrayProxyNoTemporaries const & descriptorCounts_ ) VULKAN_HPP_NOEXCEPT + { + descriptorSetCount = static_cast( descriptorCounts_.size() ); + pDescriptorCounts = descriptorCounts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorSetVariableDescriptorCountAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetVariableDescriptorCountAllocateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetVariableDescriptorCountAllocateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorSetVariableDescriptorCountAllocateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorSetCount, pDescriptorCounts ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfo const & ) const = default; +#else + bool operator==( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetCount == rhs.descriptorSetCount ) && + ( pDescriptorCounts == rhs.pDescriptorCounts ); +# endif + } + + bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo; + const void * pNext = {}; + uint32_t descriptorSetCount = {}; + const uint32_t * pDescriptorCounts = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorSetVariableDescriptorCountAllocateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorSetVariableDescriptorCountAllocateInfo; + }; + + using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo; + + // wrapper struct for struct VkDescriptorSetVariableDescriptorCountLayoutSupport, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html + struct DescriptorSetVariableDescriptorCountLayoutSupport + { + using NativeType = VkDescriptorSetVariableDescriptorCountLayoutSupport; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountLayoutSupport( uint32_t maxVariableDescriptorCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxVariableDescriptorCount{ maxVariableDescriptorCount_ } + { + } + + VULKAN_HPP_CONSTEXPR + DescriptorSetVariableDescriptorCountLayoutSupport( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorSetVariableDescriptorCountLayoutSupport( VkDescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorSetVariableDescriptorCountLayoutSupport( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorSetVariableDescriptorCountLayoutSupport & + operator=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorSetVariableDescriptorCountLayoutSupport & operator=( VkDescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDescriptorSetVariableDescriptorCountLayoutSupport const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetVariableDescriptorCountLayoutSupport &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorSetVariableDescriptorCountLayoutSupport const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorSetVariableDescriptorCountLayoutSupport *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxVariableDescriptorCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupport const & ) const = default; +#else + bool operator==( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount ); +# endif + } + + bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport; + void * pNext = {}; + uint32_t maxVariableDescriptorCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorSetVariableDescriptorCountLayoutSupport; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorSetVariableDescriptorCountLayoutSupport; + }; + + using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport; + + // wrapper struct for struct VkDescriptorUpdateTemplateEntry, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateEntry.html + struct DescriptorUpdateTemplateEntry + { + using NativeType = VkDescriptorUpdateTemplateEntry; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = {}, + uint32_t dstArrayElement_ = {}, + uint32_t descriptorCount_ = {}, + DescriptorType descriptorType_ = DescriptorType::eSampler, + size_t offset_ = {}, + size_t stride_ = {} ) VULKAN_HPP_NOEXCEPT + : dstBinding{ dstBinding_ } + , dstArrayElement{ dstArrayElement_ } + , descriptorCount{ descriptorCount_ } + , descriptorType{ descriptorType_ } + , offset{ offset_ } + , stride{ stride_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( DescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorUpdateTemplateEntry( *reinterpret_cast( &rhs ) ) + { + } + + DescriptorUpdateTemplateEntry & operator=( DescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorUpdateTemplateEntry & operator=( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDstBinding( uint32_t dstBinding_ ) & VULKAN_HPP_NOEXCEPT + { + dstBinding = dstBinding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDstBinding( uint32_t dstBinding_ ) && VULKAN_HPP_NOEXCEPT + { + dstBinding = dstBinding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDstArrayElement( uint32_t dstArrayElement_ ) & VULKAN_HPP_NOEXCEPT + { + dstArrayElement = dstArrayElement_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDstArrayElement( uint32_t dstArrayElement_ ) && VULKAN_HPP_NOEXCEPT + { + dstArrayElement = dstArrayElement_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorCount = descriptorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorCount = descriptorCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDescriptorType( DescriptorType descriptorType_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorType = descriptorType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDescriptorType( DescriptorType descriptorType_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorType = descriptorType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setOffset( size_t offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setOffset( size_t offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setStride( size_t stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setStride( size_t stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorUpdateTemplateEntry const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorUpdateTemplateEntry &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorUpdateTemplateEntry const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorUpdateTemplateEntry *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( dstBinding, dstArrayElement, descriptorCount, descriptorType, offset, stride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorUpdateTemplateEntry const & ) const = default; +#else + bool operator==( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount ) && + ( descriptorType == rhs.descriptorType ) && ( offset == rhs.offset ) && ( stride == rhs.stride ); +# endif + } + + bool operator!=( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t dstBinding = {}; + uint32_t dstArrayElement = {}; + uint32_t descriptorCount = {}; + DescriptorType descriptorType = DescriptorType::eSampler; + size_t offset = {}; + size_t stride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorUpdateTemplateEntry; + }; +#endif + using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry; + + // wrapper struct for struct VkDescriptorUpdateTemplateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateCreateInfo.html + struct DescriptorUpdateTemplateCreateInfo + { + using NativeType = VkDescriptorUpdateTemplateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorUpdateTemplateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = {}, + uint32_t descriptorUpdateEntryCount_ = {}, + const DescriptorUpdateTemplateEntry * pDescriptorUpdateEntries_ = {}, + DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet, + DescriptorSetLayout descriptorSetLayout_ = {}, + PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + PipelineLayout pipelineLayout_ = {}, + uint32_t set_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , descriptorUpdateEntryCount{ descriptorUpdateEntryCount_ } + , pDescriptorUpdateEntries{ pDescriptorUpdateEntries_ } + , templateType{ templateType_ } + , descriptorSetLayout{ descriptorSetLayout_ } + , pipelineBindPoint{ pipelineBindPoint_ } + , pipelineLayout{ pipelineLayout_ } + , set{ set_ } + { + } + + VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DescriptorUpdateTemplateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_, + ArrayProxyNoTemporaries const & descriptorUpdateEntries_, + DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet, + DescriptorSetLayout descriptorSetLayout_ = {}, + PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + PipelineLayout pipelineLayout_ = {}, + uint32_t set_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , descriptorUpdateEntryCount( static_cast( descriptorUpdateEntries_.size() ) ) + , pDescriptorUpdateEntries( descriptorUpdateEntries_.data() ) + , templateType( templateType_ ) + , descriptorSetLayout( descriptorSetLayout_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , pipelineLayout( pipelineLayout_ ) + , set( set_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DescriptorUpdateTemplateCreateInfo & operator=( DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DescriptorUpdateTemplateCreateInfo & operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setFlags( DescriptorUpdateTemplateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setFlags( DescriptorUpdateTemplateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorUpdateEntryCount = descriptorUpdateEntryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorUpdateEntryCount = descriptorUpdateEntryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & + setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry * pDescriptorUpdateEntries_ ) & + VULKAN_HPP_NOEXCEPT + { + pDescriptorUpdateEntries = pDescriptorUpdateEntries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && + setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry * pDescriptorUpdateEntries_ ) && + VULKAN_HPP_NOEXCEPT + { + pDescriptorUpdateEntries = pDescriptorUpdateEntries_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DescriptorUpdateTemplateCreateInfo & + setDescriptorUpdateEntries( ArrayProxyNoTemporaries const & descriptorUpdateEntries_ ) VULKAN_HPP_NOEXCEPT + { + descriptorUpdateEntryCount = static_cast( descriptorUpdateEntries_.size() ); + pDescriptorUpdateEntries = descriptorUpdateEntries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setTemplateType( DescriptorUpdateTemplateType templateType_ ) & VULKAN_HPP_NOEXCEPT + { + templateType = templateType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setTemplateType( DescriptorUpdateTemplateType templateType_ ) && VULKAN_HPP_NOEXCEPT + { + templateType = templateType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorSetLayout = descriptorSetLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorSetLayout = descriptorSetLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setPipelineLayout( PipelineLayout pipelineLayout_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineLayout = pipelineLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setPipelineLayout( PipelineLayout pipelineLayout_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineLayout = pipelineLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT + { + set = set_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT + { + set = set_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDescriptorUpdateTemplateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorUpdateTemplateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDescriptorUpdateTemplateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDescriptorUpdateTemplateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, flags, descriptorUpdateEntryCount, pDescriptorUpdateEntries, templateType, descriptorSetLayout, pipelineBindPoint, pipelineLayout, set ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DescriptorUpdateTemplateCreateInfo const & ) const = default; +#else + bool operator==( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) && + ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) && ( templateType == rhs.templateType ) && + ( descriptorSetLayout == rhs.descriptorSetLayout ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipelineLayout == rhs.pipelineLayout ) && + ( set == rhs.set ); +# endif + } + + bool operator!=( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo; + const void * pNext = {}; + DescriptorUpdateTemplateCreateFlags flags = {}; + uint32_t descriptorUpdateEntryCount = {}; + const DescriptorUpdateTemplateEntry * pDescriptorUpdateEntries = {}; + DescriptorUpdateTemplateType templateType = DescriptorUpdateTemplateType::eDescriptorSet; + DescriptorSetLayout descriptorSetLayout = {}; + PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; + PipelineLayout pipelineLayout = {}; + uint32_t set = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DescriptorUpdateTemplateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DescriptorUpdateTemplateCreateInfo; + }; + + using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; + + // wrapper struct for struct VkDeviceAddressBindingCallbackDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingCallbackDataEXT.html + struct DeviceAddressBindingCallbackDataEXT + { + using NativeType = VkDeviceAddressBindingCallbackDataEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceAddressBindingCallbackDataEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceAddressBindingCallbackDataEXT( DeviceAddressBindingFlagsEXT flags_ = {}, + DeviceAddress baseAddress_ = {}, + DeviceSize size_ = {}, + DeviceAddressBindingTypeEXT bindingType_ = DeviceAddressBindingTypeEXT::eBind, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , baseAddress{ baseAddress_ } + , size{ size_ } + , bindingType{ bindingType_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceAddressBindingCallbackDataEXT( DeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceAddressBindingCallbackDataEXT( VkDeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceAddressBindingCallbackDataEXT( *reinterpret_cast( &rhs ) ) + { + } + + DeviceAddressBindingCallbackDataEXT & operator=( DeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceAddressBindingCallbackDataEXT & operator=( VkDeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setFlags( DeviceAddressBindingFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setFlags( DeviceAddressBindingFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setBaseAddress( DeviceAddress baseAddress_ ) & VULKAN_HPP_NOEXCEPT + { + baseAddress = baseAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setBaseAddress( DeviceAddress baseAddress_ ) && VULKAN_HPP_NOEXCEPT + { + baseAddress = baseAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setBindingType( DeviceAddressBindingTypeEXT bindingType_ ) & VULKAN_HPP_NOEXCEPT + { + bindingType = bindingType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setBindingType( DeviceAddressBindingTypeEXT bindingType_ ) && VULKAN_HPP_NOEXCEPT + { + bindingType = bindingType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceAddressBindingCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceAddressBindingCallbackDataEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceAddressBindingCallbackDataEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceAddressBindingCallbackDataEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, baseAddress, size, bindingType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceAddressBindingCallbackDataEXT const & ) const = default; +#else + bool operator==( DeviceAddressBindingCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( baseAddress == rhs.baseAddress ) && ( size == rhs.size ) && + ( bindingType == rhs.bindingType ); +# endif + } + + bool operator!=( DeviceAddressBindingCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceAddressBindingCallbackDataEXT; + void * pNext = {}; + DeviceAddressBindingFlagsEXT flags = {}; + DeviceAddress baseAddress = {}; + DeviceSize size = {}; + DeviceAddressBindingTypeEXT bindingType = DeviceAddressBindingTypeEXT::eBind; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceAddressBindingCallbackDataEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceAddressBindingCallbackDataEXT; + }; + + // wrapper struct for struct VkDeviceBufferMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceBufferMemoryRequirements.html + struct DeviceBufferMemoryRequirements + { + using NativeType = VkDeviceBufferMemoryRequirements; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceBufferMemoryRequirements; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceBufferMemoryRequirements( const BufferCreateInfo * pCreateInfo_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pCreateInfo{ pCreateInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceBufferMemoryRequirements( DeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceBufferMemoryRequirements( VkDeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceBufferMemoryRequirements( *reinterpret_cast( &rhs ) ) + { + } + + DeviceBufferMemoryRequirements & operator=( DeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceBufferMemoryRequirements & operator=( VkDeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements & setPCreateInfo( const BufferCreateInfo * pCreateInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pCreateInfo = pCreateInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements && setPCreateInfo( const BufferCreateInfo * pCreateInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pCreateInfo = pCreateInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceBufferMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceBufferMemoryRequirements &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceBufferMemoryRequirements const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceBufferMemoryRequirements *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pCreateInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceBufferMemoryRequirements const & ) const = default; +#else + bool operator==( DeviceBufferMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ); +# endif + } + + bool operator!=( DeviceBufferMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceBufferMemoryRequirements; + const void * pNext = {}; + const BufferCreateInfo * pCreateInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceBufferMemoryRequirements; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceBufferMemoryRequirements; + }; + + using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements; + + // wrapper struct for struct VkDeviceQueueCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueCreateInfo.html + struct DeviceQueueCreateInfo + { + using NativeType = VkDeviceQueueCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = {}, + uint32_t queueFamilyIndex_ = {}, + uint32_t queueCount_ = {}, + const float * pQueuePriorities_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , queueFamilyIndex{ queueFamilyIndex_ } + , queueCount{ queueCount_ } + , pQueuePriorities{ pQueuePriorities_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceQueueCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_, + uint32_t queueFamilyIndex_, + ArrayProxyNoTemporaries const & queuePriorities_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , queueFamilyIndex( queueFamilyIndex_ ) + , queueCount( static_cast( queuePriorities_.size() ) ) + , pQueuePriorities( queuePriorities_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DeviceQueueCreateInfo & operator=( DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceQueueCreateInfo & operator=( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setFlags( DeviceQueueCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setFlags( DeviceQueueCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setQueueCount( uint32_t queueCount_ ) & VULKAN_HPP_NOEXCEPT + { + queueCount = queueCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setQueueCount( uint32_t queueCount_ ) && VULKAN_HPP_NOEXCEPT + { + queueCount = queueCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setPQueuePriorities( const float * pQueuePriorities_ ) & VULKAN_HPP_NOEXCEPT + { + pQueuePriorities = pQueuePriorities_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setPQueuePriorities( const float * pQueuePriorities_ ) && VULKAN_HPP_NOEXCEPT + { + pQueuePriorities = pQueuePriorities_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceQueueCreateInfo & setQueuePriorities( ArrayProxyNoTemporaries const & queuePriorities_ ) VULKAN_HPP_NOEXCEPT + { + queueCount = static_cast( queuePriorities_.size() ); + pQueuePriorities = queuePriorities_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceQueueCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceQueueCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceQueueCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceQueueCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queueFamilyIndex, queueCount, pQueuePriorities ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceQueueCreateInfo const & ) const = default; +#else + bool operator==( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && + ( queueCount == rhs.queueCount ) && ( pQueuePriorities == rhs.pQueuePriorities ); +# endif + } + + bool operator!=( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceQueueCreateInfo; + const void * pNext = {}; + DeviceQueueCreateFlags flags = {}; + uint32_t queueFamilyIndex = {}; + uint32_t queueCount = {}; + const float * pQueuePriorities = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceQueueCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceQueueCreateInfo; + }; + + // wrapper struct for struct VkPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFeatures.html + struct PhysicalDeviceFeatures + { + using NativeType = VkPhysicalDeviceFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures( Bool32 robustBufferAccess_ = {}, + Bool32 fullDrawIndexUint32_ = {}, + Bool32 imageCubeArray_ = {}, + Bool32 independentBlend_ = {}, + Bool32 geometryShader_ = {}, + Bool32 tessellationShader_ = {}, + Bool32 sampleRateShading_ = {}, + Bool32 dualSrcBlend_ = {}, + Bool32 logicOp_ = {}, + Bool32 multiDrawIndirect_ = {}, + Bool32 drawIndirectFirstInstance_ = {}, + Bool32 depthClamp_ = {}, + Bool32 depthBiasClamp_ = {}, + Bool32 fillModeNonSolid_ = {}, + Bool32 depthBounds_ = {}, + Bool32 wideLines_ = {}, + Bool32 largePoints_ = {}, + Bool32 alphaToOne_ = {}, + Bool32 multiViewport_ = {}, + Bool32 samplerAnisotropy_ = {}, + Bool32 textureCompressionETC2_ = {}, + Bool32 textureCompressionASTC_LDR_ = {}, + Bool32 textureCompressionBC_ = {}, + Bool32 occlusionQueryPrecise_ = {}, + Bool32 pipelineStatisticsQuery_ = {}, + Bool32 vertexPipelineStoresAndAtomics_ = {}, + Bool32 fragmentStoresAndAtomics_ = {}, + Bool32 shaderTessellationAndGeometryPointSize_ = {}, + Bool32 shaderImageGatherExtended_ = {}, + Bool32 shaderStorageImageExtendedFormats_ = {}, + Bool32 shaderStorageImageMultisample_ = {}, + Bool32 shaderStorageImageReadWithoutFormat_ = {}, + Bool32 shaderStorageImageWriteWithoutFormat_ = {}, + Bool32 shaderUniformBufferArrayDynamicIndexing_ = {}, + Bool32 shaderSampledImageArrayDynamicIndexing_ = {}, + Bool32 shaderStorageBufferArrayDynamicIndexing_ = {}, + Bool32 shaderStorageImageArrayDynamicIndexing_ = {}, + Bool32 shaderClipDistance_ = {}, + Bool32 shaderCullDistance_ = {}, + Bool32 shaderFloat64_ = {}, + Bool32 shaderInt64_ = {}, + Bool32 shaderInt16_ = {}, + Bool32 shaderResourceResidency_ = {}, + Bool32 shaderResourceMinLod_ = {}, + Bool32 sparseBinding_ = {}, + Bool32 sparseResidencyBuffer_ = {}, + Bool32 sparseResidencyImage2D_ = {}, + Bool32 sparseResidencyImage3D_ = {}, + Bool32 sparseResidency2Samples_ = {}, + Bool32 sparseResidency4Samples_ = {}, + Bool32 sparseResidency8Samples_ = {}, + Bool32 sparseResidency16Samples_ = {}, + Bool32 sparseResidencyAliased_ = {}, + Bool32 variableMultisampleRate_ = {}, + Bool32 inheritedQueries_ = {} ) VULKAN_HPP_NOEXCEPT + : robustBufferAccess{ robustBufferAccess_ } + , fullDrawIndexUint32{ fullDrawIndexUint32_ } + , imageCubeArray{ imageCubeArray_ } + , independentBlend{ independentBlend_ } + , geometryShader{ geometryShader_ } + , tessellationShader{ tessellationShader_ } + , sampleRateShading{ sampleRateShading_ } + , dualSrcBlend{ dualSrcBlend_ } + , logicOp{ logicOp_ } + , multiDrawIndirect{ multiDrawIndirect_ } + , drawIndirectFirstInstance{ drawIndirectFirstInstance_ } + , depthClamp{ depthClamp_ } + , depthBiasClamp{ depthBiasClamp_ } + , fillModeNonSolid{ fillModeNonSolid_ } + , depthBounds{ depthBounds_ } + , wideLines{ wideLines_ } + , largePoints{ largePoints_ } + , alphaToOne{ alphaToOne_ } + , multiViewport{ multiViewport_ } + , samplerAnisotropy{ samplerAnisotropy_ } + , textureCompressionETC2{ textureCompressionETC2_ } + , textureCompressionASTC_LDR{ textureCompressionASTC_LDR_ } + , textureCompressionBC{ textureCompressionBC_ } + , occlusionQueryPrecise{ occlusionQueryPrecise_ } + , pipelineStatisticsQuery{ pipelineStatisticsQuery_ } + , vertexPipelineStoresAndAtomics{ vertexPipelineStoresAndAtomics_ } + , fragmentStoresAndAtomics{ fragmentStoresAndAtomics_ } + , shaderTessellationAndGeometryPointSize{ shaderTessellationAndGeometryPointSize_ } + , shaderImageGatherExtended{ shaderImageGatherExtended_ } + , shaderStorageImageExtendedFormats{ shaderStorageImageExtendedFormats_ } + , shaderStorageImageMultisample{ shaderStorageImageMultisample_ } + , shaderStorageImageReadWithoutFormat{ shaderStorageImageReadWithoutFormat_ } + , shaderStorageImageWriteWithoutFormat{ shaderStorageImageWriteWithoutFormat_ } + , shaderUniformBufferArrayDynamicIndexing{ shaderUniformBufferArrayDynamicIndexing_ } + , shaderSampledImageArrayDynamicIndexing{ shaderSampledImageArrayDynamicIndexing_ } + , shaderStorageBufferArrayDynamicIndexing{ shaderStorageBufferArrayDynamicIndexing_ } + , shaderStorageImageArrayDynamicIndexing{ shaderStorageImageArrayDynamicIndexing_ } + , shaderClipDistance{ shaderClipDistance_ } + , shaderCullDistance{ shaderCullDistance_ } + , shaderFloat64{ shaderFloat64_ } + , shaderInt64{ shaderInt64_ } + , shaderInt16{ shaderInt16_ } + , shaderResourceResidency{ shaderResourceResidency_ } + , shaderResourceMinLod{ shaderResourceMinLod_ } + , sparseBinding{ sparseBinding_ } + , sparseResidencyBuffer{ sparseResidencyBuffer_ } + , sparseResidencyImage2D{ sparseResidencyImage2D_ } + , sparseResidencyImage3D{ sparseResidencyImage3D_ } + , sparseResidency2Samples{ sparseResidency2Samples_ } + , sparseResidency4Samples{ sparseResidency4Samples_ } + , sparseResidency8Samples{ sparseResidency8Samples_ } + , sparseResidency16Samples{ sparseResidency16Samples_ } + , sparseResidencyAliased{ sparseResidencyAliased_ } + , variableMultisampleRate{ variableMultisampleRate_ } + , inheritedQueries{ inheritedQueries_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures( PhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFeatures & operator=( PhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFeatures & operator=( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setRobustBufferAccess( Bool32 robustBufferAccess_ ) & VULKAN_HPP_NOEXCEPT + { + robustBufferAccess = robustBufferAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setRobustBufferAccess( Bool32 robustBufferAccess_ ) && VULKAN_HPP_NOEXCEPT + { + robustBufferAccess = robustBufferAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ ) & VULKAN_HPP_NOEXCEPT + { + fullDrawIndexUint32 = fullDrawIndexUint32_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ ) && VULKAN_HPP_NOEXCEPT + { + fullDrawIndexUint32 = fullDrawIndexUint32_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setImageCubeArray( Bool32 imageCubeArray_ ) & VULKAN_HPP_NOEXCEPT + { + imageCubeArray = imageCubeArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setImageCubeArray( Bool32 imageCubeArray_ ) && VULKAN_HPP_NOEXCEPT + { + imageCubeArray = imageCubeArray_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setIndependentBlend( Bool32 independentBlend_ ) & VULKAN_HPP_NOEXCEPT + { + independentBlend = independentBlend_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setIndependentBlend( Bool32 independentBlend_ ) && VULKAN_HPP_NOEXCEPT + { + independentBlend = independentBlend_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setGeometryShader( Bool32 geometryShader_ ) & VULKAN_HPP_NOEXCEPT + { + geometryShader = geometryShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setGeometryShader( Bool32 geometryShader_ ) && VULKAN_HPP_NOEXCEPT + { + geometryShader = geometryShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTessellationShader( Bool32 tessellationShader_ ) & VULKAN_HPP_NOEXCEPT + { + tessellationShader = tessellationShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTessellationShader( Bool32 tessellationShader_ ) && VULKAN_HPP_NOEXCEPT + { + tessellationShader = tessellationShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSampleRateShading( Bool32 sampleRateShading_ ) & VULKAN_HPP_NOEXCEPT + { + sampleRateShading = sampleRateShading_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSampleRateShading( Bool32 sampleRateShading_ ) && VULKAN_HPP_NOEXCEPT + { + sampleRateShading = sampleRateShading_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDualSrcBlend( Bool32 dualSrcBlend_ ) & VULKAN_HPP_NOEXCEPT + { + dualSrcBlend = dualSrcBlend_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDualSrcBlend( Bool32 dualSrcBlend_ ) && VULKAN_HPP_NOEXCEPT + { + dualSrcBlend = dualSrcBlend_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setLogicOp( Bool32 logicOp_ ) & VULKAN_HPP_NOEXCEPT + { + logicOp = logicOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setLogicOp( Bool32 logicOp_ ) && VULKAN_HPP_NOEXCEPT + { + logicOp = logicOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setMultiDrawIndirect( Bool32 multiDrawIndirect_ ) & VULKAN_HPP_NOEXCEPT + { + multiDrawIndirect = multiDrawIndirect_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setMultiDrawIndirect( Bool32 multiDrawIndirect_ ) && VULKAN_HPP_NOEXCEPT + { + multiDrawIndirect = multiDrawIndirect_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ ) & VULKAN_HPP_NOEXCEPT + { + drawIndirectFirstInstance = drawIndirectFirstInstance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ ) && VULKAN_HPP_NOEXCEPT + { + drawIndirectFirstInstance = drawIndirectFirstInstance_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDepthClamp( Bool32 depthClamp_ ) & VULKAN_HPP_NOEXCEPT + { + depthClamp = depthClamp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDepthClamp( Bool32 depthClamp_ ) && VULKAN_HPP_NOEXCEPT + { + depthClamp = depthClamp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDepthBiasClamp( Bool32 depthBiasClamp_ ) & VULKAN_HPP_NOEXCEPT + { + depthBiasClamp = depthBiasClamp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDepthBiasClamp( Bool32 depthBiasClamp_ ) && VULKAN_HPP_NOEXCEPT + { + depthBiasClamp = depthBiasClamp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setFillModeNonSolid( Bool32 fillModeNonSolid_ ) & VULKAN_HPP_NOEXCEPT + { + fillModeNonSolid = fillModeNonSolid_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setFillModeNonSolid( Bool32 fillModeNonSolid_ ) && VULKAN_HPP_NOEXCEPT + { + fillModeNonSolid = fillModeNonSolid_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDepthBounds( Bool32 depthBounds_ ) & VULKAN_HPP_NOEXCEPT + { + depthBounds = depthBounds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDepthBounds( Bool32 depthBounds_ ) && VULKAN_HPP_NOEXCEPT + { + depthBounds = depthBounds_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setWideLines( Bool32 wideLines_ ) & VULKAN_HPP_NOEXCEPT + { + wideLines = wideLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setWideLines( Bool32 wideLines_ ) && VULKAN_HPP_NOEXCEPT + { + wideLines = wideLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setLargePoints( Bool32 largePoints_ ) & VULKAN_HPP_NOEXCEPT + { + largePoints = largePoints_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setLargePoints( Bool32 largePoints_ ) && VULKAN_HPP_NOEXCEPT + { + largePoints = largePoints_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setAlphaToOne( Bool32 alphaToOne_ ) & VULKAN_HPP_NOEXCEPT + { + alphaToOne = alphaToOne_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setAlphaToOne( Bool32 alphaToOne_ ) && VULKAN_HPP_NOEXCEPT + { + alphaToOne = alphaToOne_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setMultiViewport( Bool32 multiViewport_ ) & VULKAN_HPP_NOEXCEPT + { + multiViewport = multiViewport_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setMultiViewport( Bool32 multiViewport_ ) && VULKAN_HPP_NOEXCEPT + { + multiViewport = multiViewport_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSamplerAnisotropy( Bool32 samplerAnisotropy_ ) & VULKAN_HPP_NOEXCEPT + { + samplerAnisotropy = samplerAnisotropy_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSamplerAnisotropy( Bool32 samplerAnisotropy_ ) && VULKAN_HPP_NOEXCEPT + { + samplerAnisotropy = samplerAnisotropy_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTextureCompressionETC2( Bool32 textureCompressionETC2_ ) & VULKAN_HPP_NOEXCEPT + { + textureCompressionETC2 = textureCompressionETC2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTextureCompressionETC2( Bool32 textureCompressionETC2_ ) && VULKAN_HPP_NOEXCEPT + { + textureCompressionETC2 = textureCompressionETC2_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ ) & VULKAN_HPP_NOEXCEPT + { + textureCompressionASTC_LDR = textureCompressionASTC_LDR_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ ) && VULKAN_HPP_NOEXCEPT + { + textureCompressionASTC_LDR = textureCompressionASTC_LDR_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTextureCompressionBC( Bool32 textureCompressionBC_ ) & VULKAN_HPP_NOEXCEPT + { + textureCompressionBC = textureCompressionBC_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTextureCompressionBC( Bool32 textureCompressionBC_ ) && VULKAN_HPP_NOEXCEPT + { + textureCompressionBC = textureCompressionBC_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ ) & VULKAN_HPP_NOEXCEPT + { + occlusionQueryPrecise = occlusionQueryPrecise_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ ) && VULKAN_HPP_NOEXCEPT + { + occlusionQueryPrecise = occlusionQueryPrecise_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineStatisticsQuery = pipelineStatisticsQuery_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineStatisticsQuery = pipelineStatisticsQuery_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ ) & VULKAN_HPP_NOEXCEPT + { + vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ ) && VULKAN_HPP_NOEXCEPT + { + vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ ) & VULKAN_HPP_NOEXCEPT + { + fragmentStoresAndAtomics = fragmentStoresAndAtomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ ) && VULKAN_HPP_NOEXCEPT + { + fragmentStoresAndAtomics = fragmentStoresAndAtomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ ) & VULKAN_HPP_NOEXCEPT + { + shaderImageGatherExtended = shaderImageGatherExtended_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ ) && VULKAN_HPP_NOEXCEPT + { + shaderImageGatherExtended = shaderImageGatherExtended_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ ) & VULKAN_HPP_NOEXCEPT + { + shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ ) && VULKAN_HPP_NOEXCEPT + { + shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ ) & VULKAN_HPP_NOEXCEPT + { + shaderStorageImageMultisample = shaderStorageImageMultisample_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ ) && VULKAN_HPP_NOEXCEPT + { + shaderStorageImageMultisample = shaderStorageImageMultisample_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ ) & VULKAN_HPP_NOEXCEPT + { + shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderClipDistance( Bool32 shaderClipDistance_ ) & VULKAN_HPP_NOEXCEPT + { + shaderClipDistance = shaderClipDistance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderClipDistance( Bool32 shaderClipDistance_ ) && VULKAN_HPP_NOEXCEPT + { + shaderClipDistance = shaderClipDistance_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderCullDistance( Bool32 shaderCullDistance_ ) & VULKAN_HPP_NOEXCEPT + { + shaderCullDistance = shaderCullDistance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderCullDistance( Bool32 shaderCullDistance_ ) && VULKAN_HPP_NOEXCEPT + { + shaderCullDistance = shaderCullDistance_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderFloat64( Bool32 shaderFloat64_ ) & VULKAN_HPP_NOEXCEPT + { + shaderFloat64 = shaderFloat64_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderFloat64( Bool32 shaderFloat64_ ) && VULKAN_HPP_NOEXCEPT + { + shaderFloat64 = shaderFloat64_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderInt64( Bool32 shaderInt64_ ) & VULKAN_HPP_NOEXCEPT + { + shaderInt64 = shaderInt64_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderInt64( Bool32 shaderInt64_ ) && VULKAN_HPP_NOEXCEPT + { + shaderInt64 = shaderInt64_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderInt16( Bool32 shaderInt16_ ) & VULKAN_HPP_NOEXCEPT + { + shaderInt16 = shaderInt16_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderInt16( Bool32 shaderInt16_ ) && VULKAN_HPP_NOEXCEPT + { + shaderInt16 = shaderInt16_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderResourceResidency( Bool32 shaderResourceResidency_ ) & VULKAN_HPP_NOEXCEPT + { + shaderResourceResidency = shaderResourceResidency_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderResourceResidency( Bool32 shaderResourceResidency_ ) && VULKAN_HPP_NOEXCEPT + { + shaderResourceResidency = shaderResourceResidency_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderResourceMinLod( Bool32 shaderResourceMinLod_ ) & VULKAN_HPP_NOEXCEPT + { + shaderResourceMinLod = shaderResourceMinLod_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderResourceMinLod( Bool32 shaderResourceMinLod_ ) && VULKAN_HPP_NOEXCEPT + { + shaderResourceMinLod = shaderResourceMinLod_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseBinding( Bool32 sparseBinding_ ) & VULKAN_HPP_NOEXCEPT + { + sparseBinding = sparseBinding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseBinding( Bool32 sparseBinding_ ) && VULKAN_HPP_NOEXCEPT + { + sparseBinding = sparseBinding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + sparseResidencyBuffer = sparseResidencyBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + sparseResidencyBuffer = sparseResidencyBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ ) & VULKAN_HPP_NOEXCEPT + { + sparseResidencyImage2D = sparseResidencyImage2D_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ ) && VULKAN_HPP_NOEXCEPT + { + sparseResidencyImage2D = sparseResidencyImage2D_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ ) & VULKAN_HPP_NOEXCEPT + { + sparseResidencyImage3D = sparseResidencyImage3D_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ ) && VULKAN_HPP_NOEXCEPT + { + sparseResidencyImage3D = sparseResidencyImage3D_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidency2Samples( Bool32 sparseResidency2Samples_ ) & VULKAN_HPP_NOEXCEPT + { + sparseResidency2Samples = sparseResidency2Samples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidency2Samples( Bool32 sparseResidency2Samples_ ) && VULKAN_HPP_NOEXCEPT + { + sparseResidency2Samples = sparseResidency2Samples_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidency4Samples( Bool32 sparseResidency4Samples_ ) & VULKAN_HPP_NOEXCEPT + { + sparseResidency4Samples = sparseResidency4Samples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidency4Samples( Bool32 sparseResidency4Samples_ ) && VULKAN_HPP_NOEXCEPT + { + sparseResidency4Samples = sparseResidency4Samples_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidency8Samples( Bool32 sparseResidency8Samples_ ) & VULKAN_HPP_NOEXCEPT + { + sparseResidency8Samples = sparseResidency8Samples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidency8Samples( Bool32 sparseResidency8Samples_ ) && VULKAN_HPP_NOEXCEPT + { + sparseResidency8Samples = sparseResidency8Samples_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidency16Samples( Bool32 sparseResidency16Samples_ ) & VULKAN_HPP_NOEXCEPT + { + sparseResidency16Samples = sparseResidency16Samples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidency16Samples( Bool32 sparseResidency16Samples_ ) && VULKAN_HPP_NOEXCEPT + { + sparseResidency16Samples = sparseResidency16Samples_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidencyAliased( Bool32 sparseResidencyAliased_ ) & VULKAN_HPP_NOEXCEPT + { + sparseResidencyAliased = sparseResidencyAliased_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidencyAliased( Bool32 sparseResidencyAliased_ ) && VULKAN_HPP_NOEXCEPT + { + sparseResidencyAliased = sparseResidencyAliased_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setVariableMultisampleRate( Bool32 variableMultisampleRate_ ) & VULKAN_HPP_NOEXCEPT + { + variableMultisampleRate = variableMultisampleRate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setVariableMultisampleRate( Bool32 variableMultisampleRate_ ) && VULKAN_HPP_NOEXCEPT + { + variableMultisampleRate = variableMultisampleRate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setInheritedQueries( Bool32 inheritedQueries_ ) & VULKAN_HPP_NOEXCEPT + { + inheritedQueries = inheritedQueries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setInheritedQueries( Bool32 inheritedQueries_ ) && VULKAN_HPP_NOEXCEPT + { + inheritedQueries = inheritedQueries_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( robustBufferAccess, + fullDrawIndexUint32, + imageCubeArray, + independentBlend, + geometryShader, + tessellationShader, + sampleRateShading, + dualSrcBlend, + logicOp, + multiDrawIndirect, + drawIndirectFirstInstance, + depthClamp, + depthBiasClamp, + fillModeNonSolid, + depthBounds, + wideLines, + largePoints, + alphaToOne, + multiViewport, + samplerAnisotropy, + textureCompressionETC2, + textureCompressionASTC_LDR, + textureCompressionBC, + occlusionQueryPrecise, + pipelineStatisticsQuery, + vertexPipelineStoresAndAtomics, + fragmentStoresAndAtomics, + shaderTessellationAndGeometryPointSize, + shaderImageGatherExtended, + shaderStorageImageExtendedFormats, + shaderStorageImageMultisample, + shaderStorageImageReadWithoutFormat, + shaderStorageImageWriteWithoutFormat, + shaderUniformBufferArrayDynamicIndexing, + shaderSampledImageArrayDynamicIndexing, + shaderStorageBufferArrayDynamicIndexing, + shaderStorageImageArrayDynamicIndexing, + shaderClipDistance, + shaderCullDistance, + shaderFloat64, + shaderInt64, + shaderInt16, + shaderResourceResidency, + shaderResourceMinLod, + sparseBinding, + sparseResidencyBuffer, + sparseResidencyImage2D, + sparseResidencyImage3D, + sparseResidency2Samples, + sparseResidency4Samples, + sparseResidency8Samples, + sparseResidency16Samples, + sparseResidencyAliased, + variableMultisampleRate, + inheritedQueries ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( robustBufferAccess == rhs.robustBufferAccess ) && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 ) && + ( imageCubeArray == rhs.imageCubeArray ) && ( independentBlend == rhs.independentBlend ) && ( geometryShader == rhs.geometryShader ) && + ( tessellationShader == rhs.tessellationShader ) && ( sampleRateShading == rhs.sampleRateShading ) && ( dualSrcBlend == rhs.dualSrcBlend ) && + ( logicOp == rhs.logicOp ) && ( multiDrawIndirect == rhs.multiDrawIndirect ) && ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance ) && + ( depthClamp == rhs.depthClamp ) && ( depthBiasClamp == rhs.depthBiasClamp ) && ( fillModeNonSolid == rhs.fillModeNonSolid ) && + ( depthBounds == rhs.depthBounds ) && ( wideLines == rhs.wideLines ) && ( largePoints == rhs.largePoints ) && ( alphaToOne == rhs.alphaToOne ) && + ( multiViewport == rhs.multiViewport ) && ( samplerAnisotropy == rhs.samplerAnisotropy ) && + ( textureCompressionETC2 == rhs.textureCompressionETC2 ) && ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR ) && + ( textureCompressionBC == rhs.textureCompressionBC ) && ( occlusionQueryPrecise == rhs.occlusionQueryPrecise ) && + ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery ) && ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics ) && + ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics ) && + ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize ) && + ( shaderImageGatherExtended == rhs.shaderImageGatherExtended ) && ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats ) && + ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample ) && + ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat ) && + ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat ) && + ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing ) && + ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing ) && + ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing ) && + ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing ) && ( shaderClipDistance == rhs.shaderClipDistance ) && + ( shaderCullDistance == rhs.shaderCullDistance ) && ( shaderFloat64 == rhs.shaderFloat64 ) && ( shaderInt64 == rhs.shaderInt64 ) && + ( shaderInt16 == rhs.shaderInt16 ) && ( shaderResourceResidency == rhs.shaderResourceResidency ) && + ( shaderResourceMinLod == rhs.shaderResourceMinLod ) && ( sparseBinding == rhs.sparseBinding ) && + ( sparseResidencyBuffer == rhs.sparseResidencyBuffer ) && ( sparseResidencyImage2D == rhs.sparseResidencyImage2D ) && + ( sparseResidencyImage3D == rhs.sparseResidencyImage3D ) && ( sparseResidency2Samples == rhs.sparseResidency2Samples ) && + ( sparseResidency4Samples == rhs.sparseResidency4Samples ) && ( sparseResidency8Samples == rhs.sparseResidency8Samples ) && + ( sparseResidency16Samples == rhs.sparseResidency16Samples ) && ( sparseResidencyAliased == rhs.sparseResidencyAliased ) && + ( variableMultisampleRate == rhs.variableMultisampleRate ) && ( inheritedQueries == rhs.inheritedQueries ); +# endif + } + + bool operator!=( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Bool32 robustBufferAccess = {}; + Bool32 fullDrawIndexUint32 = {}; + Bool32 imageCubeArray = {}; + Bool32 independentBlend = {}; + Bool32 geometryShader = {}; + Bool32 tessellationShader = {}; + Bool32 sampleRateShading = {}; + Bool32 dualSrcBlend = {}; + Bool32 logicOp = {}; + Bool32 multiDrawIndirect = {}; + Bool32 drawIndirectFirstInstance = {}; + Bool32 depthClamp = {}; + Bool32 depthBiasClamp = {}; + Bool32 fillModeNonSolid = {}; + Bool32 depthBounds = {}; + Bool32 wideLines = {}; + Bool32 largePoints = {}; + Bool32 alphaToOne = {}; + Bool32 multiViewport = {}; + Bool32 samplerAnisotropy = {}; + Bool32 textureCompressionETC2 = {}; + Bool32 textureCompressionASTC_LDR = {}; + Bool32 textureCompressionBC = {}; + Bool32 occlusionQueryPrecise = {}; + Bool32 pipelineStatisticsQuery = {}; + Bool32 vertexPipelineStoresAndAtomics = {}; + Bool32 fragmentStoresAndAtomics = {}; + Bool32 shaderTessellationAndGeometryPointSize = {}; + Bool32 shaderImageGatherExtended = {}; + Bool32 shaderStorageImageExtendedFormats = {}; + Bool32 shaderStorageImageMultisample = {}; + Bool32 shaderStorageImageReadWithoutFormat = {}; + Bool32 shaderStorageImageWriteWithoutFormat = {}; + Bool32 shaderUniformBufferArrayDynamicIndexing = {}; + Bool32 shaderSampledImageArrayDynamicIndexing = {}; + Bool32 shaderStorageBufferArrayDynamicIndexing = {}; + Bool32 shaderStorageImageArrayDynamicIndexing = {}; + Bool32 shaderClipDistance = {}; + Bool32 shaderCullDistance = {}; + Bool32 shaderFloat64 = {}; + Bool32 shaderInt64 = {}; + Bool32 shaderInt16 = {}; + Bool32 shaderResourceResidency = {}; + Bool32 shaderResourceMinLod = {}; + Bool32 sparseBinding = {}; + Bool32 sparseResidencyBuffer = {}; + Bool32 sparseResidencyImage2D = {}; + Bool32 sparseResidencyImage3D = {}; + Bool32 sparseResidency2Samples = {}; + Bool32 sparseResidency4Samples = {}; + Bool32 sparseResidency8Samples = {}; + Bool32 sparseResidency16Samples = {}; + Bool32 sparseResidencyAliased = {}; + Bool32 variableMultisampleRate = {}; + Bool32 inheritedQueries = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFeatures; + }; +#endif + + // wrapper struct for struct VkDeviceCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceCreateInfo.html + struct DeviceCreateInfo + { + using NativeType = VkDeviceCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + +# if defined( _MSC_VER ) +# pragma warning( push ) +# pragma warning( disable : 4996 ) // 'function': was declared deprecated +# elif defined( __clang__ ) +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wdeprecated-declarations" +# elif defined( __GNUC__ ) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# else +// unknown compiler... just ignore the warnings for yourselves ;) +# endif + + VULKAN_HPP_CONSTEXPR_17 DeviceCreateInfo( DeviceCreateFlags flags_ = {}, + uint32_t queueCreateInfoCount_ = {}, + const DeviceQueueCreateInfo * pQueueCreateInfos_ = {}, + uint32_t enabledLayerCount_ = {}, + const char * const * ppEnabledLayerNames_ = {}, + uint32_t enabledExtensionCount_ = {}, + const char * const * ppEnabledExtensionNames_ = {}, + const PhysicalDeviceFeatures * pEnabledFeatures_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , queueCreateInfoCount{ queueCreateInfoCount_ } + , pQueueCreateInfos{ pQueueCreateInfos_ } + , enabledLayerCount{ enabledLayerCount_ } + , ppEnabledLayerNames{ ppEnabledLayerNames_ } + , enabledExtensionCount{ enabledExtensionCount_ } + , ppEnabledExtensionNames{ ppEnabledExtensionNames_ } + , pEnabledFeatures{ pEnabledFeatures_ } + { + } + + VULKAN_HPP_CONSTEXPR_17 DeviceCreateInfo( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceCreateInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceCreateInfo( DeviceCreateFlags flags_, + ArrayProxyNoTemporaries const & queueCreateInfos_, + ArrayProxyNoTemporaries const & pEnabledLayerNames_ = {}, + ArrayProxyNoTemporaries const & pEnabledExtensionNames_ = {}, + const PhysicalDeviceFeatures * pEnabledFeatures_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , queueCreateInfoCount( static_cast( queueCreateInfos_.size() ) ) + , pQueueCreateInfos( queueCreateInfos_.data() ) + , enabledLayerCount( static_cast( pEnabledLayerNames_.size() ) ) + , ppEnabledLayerNames( pEnabledLayerNames_.data() ) + , enabledExtensionCount( static_cast( pEnabledExtensionNames_.size() ) ) + , ppEnabledExtensionNames( pEnabledExtensionNames_.data() ) + , pEnabledFeatures( pEnabledFeatures_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DeviceCreateInfo & operator=( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + +# if defined( _MSC_VER ) +# pragma warning( pop ) +# elif defined( __clang__ ) +# pragma clang diagnostic pop +# elif defined( __GNUC__ ) +# pragma GCC diagnostic pop +# else +// unknown compiler... just ignore the warnings for yourselves ;) +# endif + +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceCreateInfo & operator=( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + pNext = rhs.pNext; + flags = static_cast( rhs.flags ); + queueCreateInfoCount = rhs.queueCreateInfoCount; + pQueueCreateInfos = reinterpret_cast( rhs.pQueueCreateInfos ); + enabledExtensionCount = rhs.enabledExtensionCount; + ppEnabledExtensionNames = rhs.ppEnabledExtensionNames; + pEnabledFeatures = reinterpret_cast( rhs.pEnabledFeatures ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setFlags( DeviceCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setFlags( DeviceCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ ) & VULKAN_HPP_NOEXCEPT + { + queueCreateInfoCount = queueCreateInfoCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ ) && VULKAN_HPP_NOEXCEPT + { + queueCreateInfoCount = queueCreateInfoCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPQueueCreateInfos( const DeviceQueueCreateInfo * pQueueCreateInfos_ ) & VULKAN_HPP_NOEXCEPT + { + pQueueCreateInfos = pQueueCreateInfos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setPQueueCreateInfos( const DeviceQueueCreateInfo * pQueueCreateInfos_ ) && VULKAN_HPP_NOEXCEPT + { + pQueueCreateInfos = pQueueCreateInfos_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceCreateInfo & setQueueCreateInfos( ArrayProxyNoTemporaries const & queueCreateInfos_ ) VULKAN_HPP_NOEXCEPT + { + queueCreateInfoCount = static_cast( queueCreateInfos_.size() ); + pQueueCreateInfos = queueCreateInfos_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_DEPRECATED( "ignored" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ ) & VULKAN_HPP_NOEXCEPT + { + detail::ignore( enabledLayerCount_ ); + return *this; + } + + VULKAN_HPP_DEPRECATED( "ignored" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setEnabledLayerCount( uint32_t enabledLayerCount_ ) && VULKAN_HPP_NOEXCEPT + { + detail::ignore( enabledLayerCount_ ); + return std::move( *this ); + } + + VULKAN_HPP_DEPRECATED( "ignored" ) + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPpEnabledLayerNames( const char * const * ppEnabledLayerNames_ ) & VULKAN_HPP_NOEXCEPT + { + detail::ignore( ppEnabledLayerNames_ ); + return *this; + } + + VULKAN_HPP_DEPRECATED( "ignored" ) + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setPpEnabledLayerNames( const char * const * ppEnabledLayerNames_ ) && VULKAN_HPP_NOEXCEPT + { + detail::ignore( ppEnabledLayerNames_ ); + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VULKAN_HPP_DEPRECATED( "ignored" ) + DeviceCreateInfo & setPEnabledLayerNames( ArrayProxyNoTemporaries const & pEnabledLayerNames_ ) VULKAN_HPP_NOEXCEPT + { + detail::ignore( pEnabledLayerNames_ ); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) & VULKAN_HPP_NOEXCEPT + { + enabledExtensionCount = enabledExtensionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) && VULKAN_HPP_NOEXCEPT + { + enabledExtensionCount = enabledExtensionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPpEnabledExtensionNames( const char * const * ppEnabledExtensionNames_ ) & VULKAN_HPP_NOEXCEPT + { + ppEnabledExtensionNames = ppEnabledExtensionNames_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setPpEnabledExtensionNames( const char * const * ppEnabledExtensionNames_ ) && VULKAN_HPP_NOEXCEPT + { + ppEnabledExtensionNames = ppEnabledExtensionNames_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceCreateInfo & setPEnabledExtensionNames( ArrayProxyNoTemporaries const & pEnabledExtensionNames_ ) VULKAN_HPP_NOEXCEPT + { + enabledExtensionCount = static_cast( pEnabledExtensionNames_.size() ); + ppEnabledExtensionNames = pEnabledExtensionNames_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPEnabledFeatures( const PhysicalDeviceFeatures * pEnabledFeatures_ ) & VULKAN_HPP_NOEXCEPT + { + pEnabledFeatures = pEnabledFeatures_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setPEnabledFeatures( const PhysicalDeviceFeatures * pEnabledFeatures_ ) && VULKAN_HPP_NOEXCEPT + { + pEnabledFeatures = pEnabledFeatures_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + queueCreateInfoCount, + pQueueCreateInfos, + enabledLayerCount, + ppEnabledLayerNames, + enabledExtensionCount, + ppEnabledExtensionNames, + pEnabledFeatures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = queueCreateInfoCount <=> rhs.queueCreateInfoCount; cmp != 0 ) + return cmp; + if ( auto cmp = pQueueCreateInfos <=> rhs.pQueueCreateInfos; cmp != 0 ) + return cmp; + if ( auto cmp = enabledExtensionCount <=> rhs.enabledExtensionCount; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < enabledExtensionCount; ++i ) + { + if ( ppEnabledExtensionNames[i] != rhs.ppEnabledExtensionNames[i] ) + if ( auto cmp = strcmp( ppEnabledExtensionNames[i], rhs.ppEnabledExtensionNames[i] ); cmp != 0 ) + return cmp < 0 ? std::strong_ordering::less : std::strong_ordering::greater; + } + if ( auto cmp = pEnabledFeatures <=> rhs.pEnabledFeatures; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueCreateInfoCount == rhs.queueCreateInfoCount ) && + ( pQueueCreateInfos == rhs.pQueueCreateInfos ) && ( enabledExtensionCount == rhs.enabledExtensionCount ) && + std::equal( ppEnabledExtensionNames, + ppEnabledExtensionNames + enabledExtensionCount, + rhs.ppEnabledExtensionNames, + []( char const * left, char const * right ) { return ( left == right ) || ( strcmp( left, right ) == 0 ); } ) && + ( pEnabledFeatures == rhs.pEnabledFeatures ); + } + + bool operator!=( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDeviceCreateInfo; + const void * pNext = {}; + DeviceCreateFlags flags = {}; + uint32_t queueCreateInfoCount = {}; + const DeviceQueueCreateInfo * pQueueCreateInfos = {}; + VULKAN_HPP_DEPRECATED( "ignored" ) uint32_t enabledLayerCount = {}; + VULKAN_HPP_DEPRECATED( "ignored" ) const char * const * ppEnabledLayerNames = {}; + uint32_t enabledExtensionCount = {}; + const char * const * ppEnabledExtensionNames = {}; + const PhysicalDeviceFeatures * pEnabledFeatures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceCreateInfo; + }; + + // wrapper struct for struct VkDeviceMemoryReportCallbackDataEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryReportCallbackDataEXT.html + struct DeviceMemoryReportCallbackDataEXT + { + using NativeType = VkDeviceMemoryReportCallbackDataEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryReportCallbackDataEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT( DeviceMemoryReportFlagsEXT flags_ = {}, + DeviceMemoryReportEventTypeEXT type_ = DeviceMemoryReportEventTypeEXT::eAllocate, + uint64_t memoryObjectId_ = {}, + DeviceSize size_ = {}, + ObjectType objectType_ = ObjectType::eUnknown, + uint64_t objectHandle_ = {}, + uint32_t heapIndex_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , type{ type_ } + , memoryObjectId{ memoryObjectId_ } + , size{ size_ } + , objectType{ objectType_ } + , objectHandle{ objectHandle_ } + , heapIndex{ heapIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceMemoryReportCallbackDataEXT( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceMemoryReportCallbackDataEXT( *reinterpret_cast( &rhs ) ) + { + } + + DeviceMemoryReportCallbackDataEXT & operator=( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceMemoryReportCallbackDataEXT & operator=( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryReportCallbackDataEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceMemoryReportCallbackDataEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default; +#else + bool operator==( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( type == rhs.type ) && ( memoryObjectId == rhs.memoryObjectId ) && + ( size == rhs.size ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) && ( heapIndex == rhs.heapIndex ); +# endif + } + + bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceMemoryReportCallbackDataEXT; + void * pNext = {}; + DeviceMemoryReportFlagsEXT flags = {}; + DeviceMemoryReportEventTypeEXT type = DeviceMemoryReportEventTypeEXT::eAllocate; + uint64_t memoryObjectId = {}; + DeviceSize size = {}; + ObjectType objectType = ObjectType::eUnknown; + uint64_t objectHandle = {}; + uint32_t heapIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceMemoryReportCallbackDataEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceMemoryReportCallbackDataEXT; + }; + + typedef void( VKAPI_PTR * PFN_DeviceMemoryReportCallbackEXT )( const DeviceMemoryReportCallbackDataEXT * pCallbackData, void * pUserData ); + + // wrapper struct for struct VkDeviceDeviceMemoryReportCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceDeviceMemoryReportCreateInfoEXT.html + struct DeviceDeviceMemoryReportCreateInfoEXT + { + using NativeType = VkDeviceDeviceMemoryReportCreateInfoEXT; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceDeviceMemoryReportCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceDeviceMemoryReportCreateInfoEXT( DeviceMemoryReportFlagsEXT flags_ = {}, + PFN_DeviceMemoryReportCallbackEXT pfnUserCallback_ = {}, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pfnUserCallback{ pfnUserCallback_ } + , pUserData{ pUserData_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceDeviceMemoryReportCreateInfoEXT( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceDeviceMemoryReportCreateInfoEXT( VkDeviceDeviceMemoryReportCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceDeviceMemoryReportCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) + + DeviceDeviceMemoryReportCreateInfoEXT( DeviceMemoryReportFlagsEXT flags_, + PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_, + void * pUserData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : DeviceDeviceMemoryReportCreateInfoEXT( flags_, reinterpret_cast( pfnUserCallback_ ), pUserData_, pNext_ ) + { + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif + + DeviceDeviceMemoryReportCreateInfoEXT & operator=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceDeviceMemoryReportCreateInfoEXT & operator=( VkDeviceDeviceMemoryReportCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT & setFlags( DeviceMemoryReportFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT && setFlags( DeviceMemoryReportFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT & setPfnUserCallback( PFN_DeviceMemoryReportCallbackEXT pfnUserCallback_ ) & + VULKAN_HPP_NOEXCEPT + { + pfnUserCallback = pfnUserCallback_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT && setPfnUserCallback( PFN_DeviceMemoryReportCallbackEXT pfnUserCallback_ ) && + VULKAN_HPP_NOEXCEPT + { + pfnUserCallback = pfnUserCallback_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT + { + pUserData = pUserData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT + { + pUserData = pUserData_; + return std::move( *this ); + } + +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# if defined( __clang__ ) +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# endif +# pragma GCC diagnostic ignored "-Wcast-function-type" +# endif + VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) + + DeviceDeviceMemoryReportCreateInfoEXT & setPfnUserCallback( PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT + { + return setPfnUserCallback( reinterpret_cast( pfnUserCallback_ ) ); + } +# if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +# endif +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceDeviceMemoryReportCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceDeviceMemoryReportCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceDeviceMemoryReportCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceDeviceMemoryReportCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pfnUserCallback, pUserData ); + } +#endif + + bool operator==( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +#if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +#else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pfnUserCallback == rhs.pfnUserCallback ) && + ( pUserData == rhs.pUserData ); +#endif + } + + bool operator!=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDeviceDeviceMemoryReportCreateInfoEXT; + const void * pNext = {}; + DeviceMemoryReportFlagsEXT flags = {}; + PFN_DeviceMemoryReportCallbackEXT pfnUserCallback = {}; + void * pUserData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceDeviceMemoryReportCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceDeviceMemoryReportCreateInfoEXT; + }; + + // wrapper struct for struct VkDeviceDiagnosticsConfigCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceDiagnosticsConfigCreateInfoNV.html + struct DeviceDiagnosticsConfigCreateInfoNV + { + using NativeType = VkDeviceDiagnosticsConfigCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceDiagnosticsConfigCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigCreateInfoNV( DeviceDiagnosticsConfigFlagsNV flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigCreateInfoNV( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceDiagnosticsConfigCreateInfoNV( VkDeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceDiagnosticsConfigCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + DeviceDiagnosticsConfigCreateInfoNV & operator=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceDiagnosticsConfigCreateInfoNV & operator=( VkDeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceDiagnosticsConfigCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceDiagnosticsConfigCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceDiagnosticsConfigCreateInfoNV & setFlags( DeviceDiagnosticsConfigFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceDiagnosticsConfigCreateInfoNV && setFlags( DeviceDiagnosticsConfigFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceDiagnosticsConfigCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceDiagnosticsConfigCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceDiagnosticsConfigCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceDiagnosticsConfigCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceDiagnosticsConfigCreateInfoNV const & ) const = default; +#else + bool operator==( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceDiagnosticsConfigCreateInfoNV; + const void * pNext = {}; + DeviceDiagnosticsConfigFlagsNV flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceDiagnosticsConfigCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceDiagnosticsConfigCreateInfoNV; + }; + + // wrapper struct for struct VkDeviceEventInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceEventInfoEXT.html + struct DeviceEventInfoEXT + { + using NativeType = VkDeviceEventInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceEventInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceEvent{ deviceEvent_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( DeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceEventInfoEXT( *reinterpret_cast( &rhs ) ) {} + + DeviceEventInfoEXT & operator=( DeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceEventInfoEXT & operator=( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceEventInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceEventInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceEventInfoEXT & setDeviceEvent( DeviceEventTypeEXT deviceEvent_ ) & VULKAN_HPP_NOEXCEPT + { + deviceEvent = deviceEvent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceEventInfoEXT && setDeviceEvent( DeviceEventTypeEXT deviceEvent_ ) && VULKAN_HPP_NOEXCEPT + { + deviceEvent = deviceEvent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceEventInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceEventInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceEventInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceEvent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceEventInfoEXT const & ) const = default; +#else + bool operator==( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceEvent == rhs.deviceEvent ); +# endif + } + + bool operator!=( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceEventInfoEXT; + const void * pNext = {}; + DeviceEventTypeEXT deviceEvent = DeviceEventTypeEXT::eDisplayHotplug; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceEventInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceEventInfoEXT; + }; + + // wrapper struct for struct VkDeviceFaultAddressInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultAddressInfoEXT.html + struct DeviceFaultAddressInfoEXT + { + using NativeType = VkDeviceFaultAddressInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceFaultAddressInfoEXT( DeviceFaultAddressTypeEXT addressType_ = DeviceFaultAddressTypeEXT::eNone, + DeviceAddress reportedAddress_ = {}, + DeviceSize addressPrecision_ = {} ) VULKAN_HPP_NOEXCEPT + : addressType{ addressType_ } + , reportedAddress{ reportedAddress_ } + , addressPrecision{ addressPrecision_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceFaultAddressInfoEXT( DeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceFaultAddressInfoEXT( VkDeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceFaultAddressInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + DeviceFaultAddressInfoEXT & operator=( DeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceFaultAddressInfoEXT & operator=( VkDeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT & setAddressType( DeviceFaultAddressTypeEXT addressType_ ) & VULKAN_HPP_NOEXCEPT + { + addressType = addressType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT && setAddressType( DeviceFaultAddressTypeEXT addressType_ ) && VULKAN_HPP_NOEXCEPT + { + addressType = addressType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT & setReportedAddress( DeviceAddress reportedAddress_ ) & VULKAN_HPP_NOEXCEPT + { + reportedAddress = reportedAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT && setReportedAddress( DeviceAddress reportedAddress_ ) && VULKAN_HPP_NOEXCEPT + { + reportedAddress = reportedAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT & setAddressPrecision( DeviceSize addressPrecision_ ) & VULKAN_HPP_NOEXCEPT + { + addressPrecision = addressPrecision_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT && setAddressPrecision( DeviceSize addressPrecision_ ) && VULKAN_HPP_NOEXCEPT + { + addressPrecision = addressPrecision_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceFaultAddressInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultAddressInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultAddressInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceFaultAddressInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( addressType, reportedAddress, addressPrecision ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceFaultAddressInfoEXT const & ) const = default; +#else + bool operator==( DeviceFaultAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( addressType == rhs.addressType ) && ( reportedAddress == rhs.reportedAddress ) && ( addressPrecision == rhs.addressPrecision ); +# endif + } + + bool operator!=( DeviceFaultAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceFaultAddressTypeEXT addressType = DeviceFaultAddressTypeEXT::eNone; + DeviceAddress reportedAddress = {}; + DeviceSize addressPrecision = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceFaultAddressInfoEXT; + }; +#endif + + // wrapper struct for struct VkDeviceFaultCountsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultCountsEXT.html + struct DeviceFaultCountsEXT + { + using NativeType = VkDeviceFaultCountsEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceFaultCountsEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceFaultCountsEXT( uint32_t addressInfoCount_ = {}, + uint32_t vendorInfoCount_ = {}, + DeviceSize vendorBinarySize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , addressInfoCount{ addressInfoCount_ } + , vendorInfoCount{ vendorInfoCount_ } + , vendorBinarySize{ vendorBinarySize_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceFaultCountsEXT( DeviceFaultCountsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceFaultCountsEXT( VkDeviceFaultCountsEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceFaultCountsEXT( *reinterpret_cast( &rhs ) ) + { + } + + DeviceFaultCountsEXT & operator=( DeviceFaultCountsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceFaultCountsEXT & operator=( VkDeviceFaultCountsEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT & setAddressInfoCount( uint32_t addressInfoCount_ ) & VULKAN_HPP_NOEXCEPT + { + addressInfoCount = addressInfoCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT && setAddressInfoCount( uint32_t addressInfoCount_ ) && VULKAN_HPP_NOEXCEPT + { + addressInfoCount = addressInfoCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT & setVendorInfoCount( uint32_t vendorInfoCount_ ) & VULKAN_HPP_NOEXCEPT + { + vendorInfoCount = vendorInfoCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT && setVendorInfoCount( uint32_t vendorInfoCount_ ) && VULKAN_HPP_NOEXCEPT + { + vendorInfoCount = vendorInfoCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT & setVendorBinarySize( DeviceSize vendorBinarySize_ ) & VULKAN_HPP_NOEXCEPT + { + vendorBinarySize = vendorBinarySize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT && setVendorBinarySize( DeviceSize vendorBinarySize_ ) && VULKAN_HPP_NOEXCEPT + { + vendorBinarySize = vendorBinarySize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceFaultCountsEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultCountsEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultCountsEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceFaultCountsEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, addressInfoCount, vendorInfoCount, vendorBinarySize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceFaultCountsEXT const & ) const = default; +#else + bool operator==( DeviceFaultCountsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( addressInfoCount == rhs.addressInfoCount ) && ( vendorInfoCount == rhs.vendorInfoCount ) && + ( vendorBinarySize == rhs.vendorBinarySize ); +# endif + } + + bool operator!=( DeviceFaultCountsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceFaultCountsEXT; + void * pNext = {}; + uint32_t addressInfoCount = {}; + uint32_t vendorInfoCount = {}; + DeviceSize vendorBinarySize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceFaultCountsEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceFaultCountsEXT; + }; + + // wrapper struct for struct VkDeviceFaultVendorInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorInfoEXT.html + struct DeviceFaultVendorInfoEXT + { + using NativeType = VkDeviceFaultVendorInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT( std::array const & description_ = {}, + uint64_t vendorFaultCode_ = {}, + uint64_t vendorFaultData_ = {} ) VULKAN_HPP_NOEXCEPT + : description{ description_ } + , vendorFaultCode{ vendorFaultCode_ } + , vendorFaultData{ vendorFaultData_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT( DeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceFaultVendorInfoEXT( VkDeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceFaultVendorInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceFaultVendorInfoEXT( std::string const & description_, uint64_t vendorFaultCode_ = {}, uint64_t vendorFaultData_ = {} ) + : vendorFaultCode( vendorFaultCode_ ), vendorFaultData( vendorFaultData_ ) + { + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); +# if defined( _WIN32 ) + strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); +# else + strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); +# endif + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DeviceFaultVendorInfoEXT & operator=( DeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceFaultVendorInfoEXT & operator=( VkDeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT & setDescription( std::array description_ ) & VULKAN_HPP_NOEXCEPT + { + description = description_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT && setDescription( std::array description_ ) && VULKAN_HPP_NOEXCEPT + { + description = description_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceFaultVendorInfoEXT & setDescription( std::string const & description_ ) VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); +# if defined( _WIN32 ) + strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); +# else + strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); +# endif + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT & setVendorFaultCode( uint64_t vendorFaultCode_ ) & VULKAN_HPP_NOEXCEPT + { + vendorFaultCode = vendorFaultCode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT && setVendorFaultCode( uint64_t vendorFaultCode_ ) && VULKAN_HPP_NOEXCEPT + { + vendorFaultCode = vendorFaultCode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT & setVendorFaultData( uint64_t vendorFaultData_ ) & VULKAN_HPP_NOEXCEPT + { + vendorFaultData = vendorFaultData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT && setVendorFaultData( uint64_t vendorFaultData_ ) && VULKAN_HPP_NOEXCEPT + { + vendorFaultData = vendorFaultData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceFaultVendorInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultVendorInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultVendorInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceFaultVendorInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, uint64_t const &, uint64_t const &> reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( description, vendorFaultCode, vendorFaultData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = vendorFaultCode <=> rhs.vendorFaultCode; cmp != 0 ) + return cmp; + if ( auto cmp = vendorFaultData <=> rhs.vendorFaultData; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( strcmp( description, rhs.description ) == 0 ) && ( vendorFaultCode == rhs.vendorFaultCode ) && ( vendorFaultData == rhs.vendorFaultData ); + } + + bool operator!=( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + ArrayWrapper1D description = {}; + uint64_t vendorFaultCode = {}; + uint64_t vendorFaultData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceFaultVendorInfoEXT; + }; +#endif + + // wrapper struct for struct VkDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultInfoEXT.html + struct DeviceFaultInfoEXT + { + using NativeType = VkDeviceFaultInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceFaultInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT( std::array const & description_ = {}, + DeviceFaultAddressInfoEXT * pAddressInfos_ = {}, + DeviceFaultVendorInfoEXT * pVendorInfos_ = {}, + void * pVendorBinaryData_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , description{ description_ } + , pAddressInfos{ pAddressInfos_ } + , pVendorInfos{ pVendorInfos_ } + , pVendorBinaryData{ pVendorBinaryData_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT( DeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceFaultInfoEXT( VkDeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceFaultInfoEXT( *reinterpret_cast( &rhs ) ) {} + + DeviceFaultInfoEXT & operator=( DeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceFaultInfoEXT & operator=( VkDeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDeviceFaultInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceFaultInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + DeviceFaultAddressInfoEXT * const &, + DeviceFaultVendorInfoEXT * const &, + void * const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, description, pAddressInfos, pVendorInfos, pVendorBinaryData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( DeviceFaultInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = pAddressInfos <=> rhs.pAddressInfos; cmp != 0 ) + return cmp; + if ( auto cmp = pVendorInfos <=> rhs.pVendorInfos; cmp != 0 ) + return cmp; + if ( auto cmp = pVendorBinaryData <=> rhs.pVendorBinaryData; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( DeviceFaultInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( strcmp( description, rhs.description ) == 0 ) && ( pAddressInfos == rhs.pAddressInfos ) && + ( pVendorInfos == rhs.pVendorInfos ) && ( pVendorBinaryData == rhs.pVendorBinaryData ); + } + + bool operator!=( DeviceFaultInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDeviceFaultInfoEXT; + void * pNext = {}; + ArrayWrapper1D description = {}; + DeviceFaultAddressInfoEXT * pAddressInfos = {}; + DeviceFaultVendorInfoEXT * pVendorInfos = {}; + void * pVendorBinaryData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceFaultInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceFaultInfoEXT; + }; + + // wrapper struct for struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorBinaryHeaderVersionOneEXT.html + struct DeviceFaultVendorBinaryHeaderVersionOneEXT + { + using NativeType = VkDeviceFaultVendorBinaryHeaderVersionOneEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + DeviceFaultVendorBinaryHeaderVersionOneEXT( uint32_t headerSize_ = {}, + DeviceFaultVendorBinaryHeaderVersionEXT headerVersion_ = DeviceFaultVendorBinaryHeaderVersionEXT::eOne, + uint32_t vendorID_ = {}, + uint32_t deviceID_ = {}, + uint32_t driverVersion_ = {}, + std::array const & pipelineCacheUUID_ = {}, + uint32_t applicationNameOffset_ = {}, + uint32_t applicationVersion_ = {}, + uint32_t engineNameOffset_ = {}, + uint32_t engineVersion_ = {}, + uint32_t apiVersion_ = {} ) VULKAN_HPP_NOEXCEPT + : headerSize{ headerSize_ } + , headerVersion{ headerVersion_ } + , vendorID{ vendorID_ } + , deviceID{ deviceID_ } + , driverVersion{ driverVersion_ } + , pipelineCacheUUID{ pipelineCacheUUID_ } + , applicationNameOffset{ applicationNameOffset_ } + , applicationVersion{ applicationVersion_ } + , engineNameOffset{ engineNameOffset_ } + , engineVersion{ engineVersion_ } + , apiVersion{ apiVersion_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceFaultVendorBinaryHeaderVersionOneEXT( VkDeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceFaultVendorBinaryHeaderVersionOneEXT( *reinterpret_cast( &rhs ) ) + { + } + + DeviceFaultVendorBinaryHeaderVersionOneEXT & operator=( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceFaultVendorBinaryHeaderVersionOneEXT & operator=( VkDeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setHeaderSize( uint32_t headerSize_ ) & VULKAN_HPP_NOEXCEPT + { + headerSize = headerSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setHeaderSize( uint32_t headerSize_ ) && VULKAN_HPP_NOEXCEPT + { + headerSize = headerSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setHeaderVersion( DeviceFaultVendorBinaryHeaderVersionEXT headerVersion_ ) & + VULKAN_HPP_NOEXCEPT + { + headerVersion = headerVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setHeaderVersion( DeviceFaultVendorBinaryHeaderVersionEXT headerVersion_ ) && + VULKAN_HPP_NOEXCEPT + { + headerVersion = headerVersion_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setVendorID( uint32_t vendorID_ ) & VULKAN_HPP_NOEXCEPT + { + vendorID = vendorID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setVendorID( uint32_t vendorID_ ) && VULKAN_HPP_NOEXCEPT + { + vendorID = vendorID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setDeviceID( uint32_t deviceID_ ) & VULKAN_HPP_NOEXCEPT + { + deviceID = deviceID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setDeviceID( uint32_t deviceID_ ) && VULKAN_HPP_NOEXCEPT + { + deviceID = deviceID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setDriverVersion( uint32_t driverVersion_ ) & VULKAN_HPP_NOEXCEPT + { + driverVersion = driverVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setDriverVersion( uint32_t driverVersion_ ) && VULKAN_HPP_NOEXCEPT + { + driverVersion = driverVersion_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setPipelineCacheUUID( std::array pipelineCacheUUID_ ) & + VULKAN_HPP_NOEXCEPT + { + pipelineCacheUUID = pipelineCacheUUID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setPipelineCacheUUID( std::array pipelineCacheUUID_ ) && + VULKAN_HPP_NOEXCEPT + { + pipelineCacheUUID = pipelineCacheUUID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setApplicationNameOffset( uint32_t applicationNameOffset_ ) & VULKAN_HPP_NOEXCEPT + { + applicationNameOffset = applicationNameOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setApplicationNameOffset( uint32_t applicationNameOffset_ ) && VULKAN_HPP_NOEXCEPT + { + applicationNameOffset = applicationNameOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setApplicationVersion( uint32_t applicationVersion_ ) & VULKAN_HPP_NOEXCEPT + { + applicationVersion = applicationVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setApplicationVersion( uint32_t applicationVersion_ ) && VULKAN_HPP_NOEXCEPT + { + applicationVersion = applicationVersion_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setEngineNameOffset( uint32_t engineNameOffset_ ) & VULKAN_HPP_NOEXCEPT + { + engineNameOffset = engineNameOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setEngineNameOffset( uint32_t engineNameOffset_ ) && VULKAN_HPP_NOEXCEPT + { + engineNameOffset = engineNameOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setEngineVersion( uint32_t engineVersion_ ) & VULKAN_HPP_NOEXCEPT + { + engineVersion = engineVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setEngineVersion( uint32_t engineVersion_ ) && VULKAN_HPP_NOEXCEPT + { + engineVersion = engineVersion_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setApiVersion( uint32_t apiVersion_ ) & VULKAN_HPP_NOEXCEPT + { + apiVersion = apiVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setApiVersion( uint32_t apiVersion_ ) && VULKAN_HPP_NOEXCEPT + { + apiVersion = apiVersion_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( headerSize, + headerVersion, + vendorID, + deviceID, + driverVersion, + pipelineCacheUUID, + applicationNameOffset, + applicationVersion, + engineNameOffset, + engineVersion, + apiVersion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceFaultVendorBinaryHeaderVersionOneEXT const & ) const = default; +#else + bool operator==( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && + ( driverVersion == rhs.driverVersion ) && ( pipelineCacheUUID == rhs.pipelineCacheUUID ) && + ( applicationNameOffset == rhs.applicationNameOffset ) && ( applicationVersion == rhs.applicationVersion ) && + ( engineNameOffset == rhs.engineNameOffset ) && ( engineVersion == rhs.engineVersion ) && ( apiVersion == rhs.apiVersion ); +# endif + } + + bool operator!=( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t headerSize = {}; + DeviceFaultVendorBinaryHeaderVersionEXT headerVersion = DeviceFaultVendorBinaryHeaderVersionEXT::eOne; + uint32_t vendorID = {}; + uint32_t deviceID = {}; + uint32_t driverVersion = {}; + ArrayWrapper1D pipelineCacheUUID = {}; + uint32_t applicationNameOffset = {}; + uint32_t applicationVersion = {}; + uint32_t engineNameOffset = {}; + uint32_t engineVersion = {}; + uint32_t apiVersion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceFaultVendorBinaryHeaderVersionOneEXT; + }; +#endif + + // wrapper struct for struct VkDeviceGroupBindSparseInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupBindSparseInfo.html + struct DeviceGroupBindSparseInfo + { + using NativeType = VkDeviceGroupBindSparseInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupBindSparseInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = {}, uint32_t memoryDeviceIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , resourceDeviceIndex{ resourceDeviceIndex_ } + , memoryDeviceIndex{ memoryDeviceIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( DeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceGroupBindSparseInfo( *reinterpret_cast( &rhs ) ) + { + } + + DeviceGroupBindSparseInfo & operator=( DeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceGroupBindSparseInfo & operator=( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo & setResourceDeviceIndex( uint32_t resourceDeviceIndex_ ) & VULKAN_HPP_NOEXCEPT + { + resourceDeviceIndex = resourceDeviceIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo && setResourceDeviceIndex( uint32_t resourceDeviceIndex_ ) && VULKAN_HPP_NOEXCEPT + { + resourceDeviceIndex = resourceDeviceIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo & setMemoryDeviceIndex( uint32_t memoryDeviceIndex_ ) & VULKAN_HPP_NOEXCEPT + { + memoryDeviceIndex = memoryDeviceIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo && setMemoryDeviceIndex( uint32_t memoryDeviceIndex_ ) && VULKAN_HPP_NOEXCEPT + { + memoryDeviceIndex = memoryDeviceIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceGroupBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupBindSparseInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupBindSparseInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceGroupBindSparseInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, resourceDeviceIndex, memoryDeviceIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceGroupBindSparseInfo const & ) const = default; +#else + bool operator==( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) && + ( memoryDeviceIndex == rhs.memoryDeviceIndex ); +# endif + } + + bool operator!=( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceGroupBindSparseInfo; + const void * pNext = {}; + uint32_t resourceDeviceIndex = {}; + uint32_t memoryDeviceIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceGroupBindSparseInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceGroupBindSparseInfo; + }; + + using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo; + + // wrapper struct for struct VkDeviceGroupCommandBufferBeginInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupCommandBufferBeginInfo.html + struct DeviceGroupCommandBufferBeginInfo + { + using NativeType = VkDeviceGroupCommandBufferBeginInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupCommandBufferBeginInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceMask{ deviceMask_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( DeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceGroupCommandBufferBeginInfo( *reinterpret_cast( &rhs ) ) + { + } + + DeviceGroupCommandBufferBeginInfo & operator=( DeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceGroupCommandBufferBeginInfo & operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceGroupCommandBufferBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupCommandBufferBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupCommandBufferBeginInfo & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT + { + deviceMask = deviceMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupCommandBufferBeginInfo && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT + { + deviceMask = deviceMask_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceGroupCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupCommandBufferBeginInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceGroupCommandBufferBeginInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceGroupCommandBufferBeginInfo const & ) const = default; +#else + bool operator==( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ); +# endif + } + + bool operator!=( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo; + const void * pNext = {}; + uint32_t deviceMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceGroupCommandBufferBeginInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceGroupCommandBufferBeginInfo; + }; + + using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo; + + // wrapper struct for struct VkDeviceGroupDeviceCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupDeviceCreateInfo.html + struct DeviceGroupDeviceCreateInfo + { + using NativeType = VkDeviceGroupDeviceCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupDeviceCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = {}, + const PhysicalDevice * pPhysicalDevices_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , physicalDeviceCount{ physicalDeviceCount_ } + , pPhysicalDevices{ pPhysicalDevices_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( DeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceGroupDeviceCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceGroupDeviceCreateInfo( ArrayProxyNoTemporaries const & physicalDevices_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), physicalDeviceCount( static_cast( physicalDevices_.size() ) ), pPhysicalDevices( physicalDevices_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DeviceGroupDeviceCreateInfo & operator=( DeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceGroupDeviceCreateInfo & operator=( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo & setPhysicalDeviceCount( uint32_t physicalDeviceCount_ ) & VULKAN_HPP_NOEXCEPT + { + physicalDeviceCount = physicalDeviceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo && setPhysicalDeviceCount( uint32_t physicalDeviceCount_ ) && VULKAN_HPP_NOEXCEPT + { + physicalDeviceCount = physicalDeviceCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo & setPPhysicalDevices( const PhysicalDevice * pPhysicalDevices_ ) & VULKAN_HPP_NOEXCEPT + { + pPhysicalDevices = pPhysicalDevices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo && setPPhysicalDevices( const PhysicalDevice * pPhysicalDevices_ ) && VULKAN_HPP_NOEXCEPT + { + pPhysicalDevices = pPhysicalDevices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceGroupDeviceCreateInfo & setPhysicalDevices( ArrayProxyNoTemporaries const & physicalDevices_ ) VULKAN_HPP_NOEXCEPT + { + physicalDeviceCount = static_cast( physicalDevices_.size() ); + pPhysicalDevices = physicalDevices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceGroupDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupDeviceCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceGroupDeviceCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, physicalDeviceCount, pPhysicalDevices ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceGroupDeviceCreateInfo const & ) const = default; +#else + bool operator==( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) && + ( pPhysicalDevices == rhs.pPhysicalDevices ); +# endif + } + + bool operator!=( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo; + const void * pNext = {}; + uint32_t physicalDeviceCount = {}; + const PhysicalDevice * pPhysicalDevices = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceGroupDeviceCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceGroupDeviceCreateInfo; + }; + + using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo; + + // wrapper struct for struct VkDeviceGroupPresentCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupPresentCapabilitiesKHR.html + struct DeviceGroupPresentCapabilitiesKHR + { + using NativeType = VkDeviceGroupPresentCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupPresentCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentCapabilitiesKHR( std::array const & presentMask_ = {}, + DeviceGroupPresentModeFlagsKHR modes_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentMask{ presentMask_ } + , modes{ modes_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceGroupPresentCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + DeviceGroupPresentCapabilitiesKHR & operator=( DeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceGroupPresentCapabilitiesKHR & operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDeviceGroupPresentCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupPresentCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupPresentCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceGroupPresentCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, DeviceGroupPresentModeFlagsKHR const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentMask, modes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceGroupPresentCapabilitiesKHR const & ) const = default; +#else + bool operator==( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMask == rhs.presentMask ) && ( modes == rhs.modes ); +# endif + } + + bool operator!=( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR; + void * pNext = {}; + ArrayWrapper1D presentMask = {}; + DeviceGroupPresentModeFlagsKHR modes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceGroupPresentCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceGroupPresentCapabilitiesKHR; + }; + + // wrapper struct for struct VkDeviceGroupPresentInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupPresentInfoKHR.html + struct DeviceGroupPresentInfoKHR + { + using NativeType = VkDeviceGroupPresentInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupPresentInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = {}, + const uint32_t * pDeviceMasks_ = {}, + DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchainCount{ swapchainCount_ } + , pDeviceMasks{ pDeviceMasks_ } + , mode{ mode_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( DeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceGroupPresentInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceGroupPresentInfoKHR( ArrayProxyNoTemporaries const & deviceMasks_, + DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), swapchainCount( static_cast( deviceMasks_.size() ) ), pDeviceMasks( deviceMasks_.data() ), mode( mode_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DeviceGroupPresentInfoKHR & operator=( DeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceGroupPresentInfoKHR & operator=( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR & setPDeviceMasks( const uint32_t * pDeviceMasks_ ) & VULKAN_HPP_NOEXCEPT + { + pDeviceMasks = pDeviceMasks_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR && setPDeviceMasks( const uint32_t * pDeviceMasks_ ) && VULKAN_HPP_NOEXCEPT + { + pDeviceMasks = pDeviceMasks_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceGroupPresentInfoKHR & setDeviceMasks( ArrayProxyNoTemporaries const & deviceMasks_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( deviceMasks_.size() ); + pDeviceMasks = deviceMasks_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR & setMode( DeviceGroupPresentModeFlagBitsKHR mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR && setMode( DeviceGroupPresentModeFlagBitsKHR mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceGroupPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupPresentInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupPresentInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceGroupPresentInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pDeviceMasks, mode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceGroupPresentInfoKHR const & ) const = default; +#else + bool operator==( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pDeviceMasks == rhs.pDeviceMasks ) && + ( mode == rhs.mode ); +# endif + } + + bool operator!=( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceGroupPresentInfoKHR; + const void * pNext = {}; + uint32_t swapchainCount = {}; + const uint32_t * pDeviceMasks = {}; + DeviceGroupPresentModeFlagBitsKHR mode = DeviceGroupPresentModeFlagBitsKHR::eLocal; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceGroupPresentInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceGroupPresentInfoKHR; + }; + + // wrapper struct for struct VkDeviceGroupRenderPassBeginInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupRenderPassBeginInfo.html + struct DeviceGroupRenderPassBeginInfo + { + using NativeType = VkDeviceGroupRenderPassBeginInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupRenderPassBeginInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = {}, + uint32_t deviceRenderAreaCount_ = {}, + const Rect2D * pDeviceRenderAreas_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceMask{ deviceMask_ } + , deviceRenderAreaCount{ deviceRenderAreaCount_ } + , pDeviceRenderAreas{ pDeviceRenderAreas_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( DeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceGroupRenderPassBeginInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_, ArrayProxyNoTemporaries const & deviceRenderAreas_, const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , deviceMask( deviceMask_ ) + , deviceRenderAreaCount( static_cast( deviceRenderAreas_.size() ) ) + , pDeviceRenderAreas( deviceRenderAreas_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DeviceGroupRenderPassBeginInfo & operator=( DeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceGroupRenderPassBeginInfo & operator=( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT + { + deviceMask = deviceMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT + { + deviceMask = deviceMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo & setDeviceRenderAreaCount( uint32_t deviceRenderAreaCount_ ) & VULKAN_HPP_NOEXCEPT + { + deviceRenderAreaCount = deviceRenderAreaCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo && setDeviceRenderAreaCount( uint32_t deviceRenderAreaCount_ ) && VULKAN_HPP_NOEXCEPT + { + deviceRenderAreaCount = deviceRenderAreaCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo & setPDeviceRenderAreas( const Rect2D * pDeviceRenderAreas_ ) & VULKAN_HPP_NOEXCEPT + { + pDeviceRenderAreas = pDeviceRenderAreas_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo && setPDeviceRenderAreas( const Rect2D * pDeviceRenderAreas_ ) && VULKAN_HPP_NOEXCEPT + { + pDeviceRenderAreas = pDeviceRenderAreas_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceGroupRenderPassBeginInfo & setDeviceRenderAreas( ArrayProxyNoTemporaries const & deviceRenderAreas_ ) VULKAN_HPP_NOEXCEPT + { + deviceRenderAreaCount = static_cast( deviceRenderAreas_.size() ); + pDeviceRenderAreas = deviceRenderAreas_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceGroupRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupRenderPassBeginInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceGroupRenderPassBeginInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceMask, deviceRenderAreaCount, pDeviceRenderAreas ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceGroupRenderPassBeginInfo const & ) const = default; +#else + bool operator==( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ) && ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) && + ( pDeviceRenderAreas == rhs.pDeviceRenderAreas ); +# endif + } + + bool operator!=( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo; + const void * pNext = {}; + uint32_t deviceMask = {}; + uint32_t deviceRenderAreaCount = {}; + const Rect2D * pDeviceRenderAreas = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceGroupRenderPassBeginInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceGroupRenderPassBeginInfo; + }; + + using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo; + + // wrapper struct for struct VkDeviceGroupSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupSubmitInfo.html + struct DeviceGroupSubmitInfo + { + using NativeType = VkDeviceGroupSubmitInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupSubmitInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = {}, + const uint32_t * pWaitSemaphoreDeviceIndices_ = {}, + uint32_t commandBufferCount_ = {}, + const uint32_t * pCommandBufferDeviceMasks_ = {}, + uint32_t signalSemaphoreCount_ = {}, + const uint32_t * pSignalSemaphoreDeviceIndices_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , waitSemaphoreCount{ waitSemaphoreCount_ } + , pWaitSemaphoreDeviceIndices{ pWaitSemaphoreDeviceIndices_ } + , commandBufferCount{ commandBufferCount_ } + , pCommandBufferDeviceMasks{ pCommandBufferDeviceMasks_ } + , signalSemaphoreCount{ signalSemaphoreCount_ } + , pSignalSemaphoreDeviceIndices{ pSignalSemaphoreDeviceIndices_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( DeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceGroupSubmitInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceGroupSubmitInfo( ArrayProxyNoTemporaries const & waitSemaphoreDeviceIndices_, + ArrayProxyNoTemporaries const & commandBufferDeviceMasks_ = {}, + ArrayProxyNoTemporaries const & signalSemaphoreDeviceIndices_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , waitSemaphoreCount( static_cast( waitSemaphoreDeviceIndices_.size() ) ) + , pWaitSemaphoreDeviceIndices( waitSemaphoreDeviceIndices_.data() ) + , commandBufferCount( static_cast( commandBufferDeviceMasks_.size() ) ) + , pCommandBufferDeviceMasks( commandBufferDeviceMasks_.data() ) + , signalSemaphoreCount( static_cast( signalSemaphoreDeviceIndices_.size() ) ) + , pSignalSemaphoreDeviceIndices( signalSemaphoreDeviceIndices_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DeviceGroupSubmitInfo & operator=( DeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceGroupSubmitInfo & operator=( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = waitSemaphoreCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = waitSemaphoreCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setPWaitSemaphoreDeviceIndices( const uint32_t * pWaitSemaphoreDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setPWaitSemaphoreDeviceIndices( const uint32_t * pWaitSemaphoreDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceGroupSubmitInfo & setWaitSemaphoreDeviceIndices( ArrayProxyNoTemporaries const & waitSemaphoreDeviceIndices_ ) VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = static_cast( waitSemaphoreDeviceIndices_.size() ); + pWaitSemaphoreDeviceIndices = waitSemaphoreDeviceIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setCommandBufferCount( uint32_t commandBufferCount_ ) & VULKAN_HPP_NOEXCEPT + { + commandBufferCount = commandBufferCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setCommandBufferCount( uint32_t commandBufferCount_ ) && VULKAN_HPP_NOEXCEPT + { + commandBufferCount = commandBufferCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setPCommandBufferDeviceMasks( const uint32_t * pCommandBufferDeviceMasks_ ) & VULKAN_HPP_NOEXCEPT + { + pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setPCommandBufferDeviceMasks( const uint32_t * pCommandBufferDeviceMasks_ ) && VULKAN_HPP_NOEXCEPT + { + pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceGroupSubmitInfo & setCommandBufferDeviceMasks( ArrayProxyNoTemporaries const & commandBufferDeviceMasks_ ) VULKAN_HPP_NOEXCEPT + { + commandBufferCount = static_cast( commandBufferDeviceMasks_.size() ); + pCommandBufferDeviceMasks = commandBufferDeviceMasks_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT + { + signalSemaphoreCount = signalSemaphoreCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT + { + signalSemaphoreCount = signalSemaphoreCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setPSignalSemaphoreDeviceIndices( const uint32_t * pSignalSemaphoreDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setPSignalSemaphoreDeviceIndices( const uint32_t * pSignalSemaphoreDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DeviceGroupSubmitInfo & setSignalSemaphoreDeviceIndices( ArrayProxyNoTemporaries const & signalSemaphoreDeviceIndices_ ) VULKAN_HPP_NOEXCEPT + { + signalSemaphoreCount = static_cast( signalSemaphoreDeviceIndices_.size() ); + pSignalSemaphoreDeviceIndices = signalSemaphoreDeviceIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceGroupSubmitInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupSubmitInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupSubmitInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceGroupSubmitInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + waitSemaphoreCount, + pWaitSemaphoreDeviceIndices, + commandBufferCount, + pCommandBufferDeviceMasks, + signalSemaphoreCount, + pSignalSemaphoreDeviceIndices ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceGroupSubmitInfo const & ) const = default; +#else + bool operator==( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && + ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices ) && ( commandBufferCount == rhs.commandBufferCount ) && + ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && + ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices ); +# endif + } + + bool operator!=( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceGroupSubmitInfo; + const void * pNext = {}; + uint32_t waitSemaphoreCount = {}; + const uint32_t * pWaitSemaphoreDeviceIndices = {}; + uint32_t commandBufferCount = {}; + const uint32_t * pCommandBufferDeviceMasks = {}; + uint32_t signalSemaphoreCount = {}; + const uint32_t * pSignalSemaphoreDeviceIndices = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceGroupSubmitInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceGroupSubmitInfo; + }; + + using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo; + + // wrapper struct for struct VkDeviceGroupSwapchainCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupSwapchainCreateInfoKHR.html + struct DeviceGroupSwapchainCreateInfoKHR + { + using NativeType = VkDeviceGroupSwapchainCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( DeviceGroupPresentModeFlagsKHR modes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , modes{ modes_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( DeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceGroupSwapchainCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + DeviceGroupSwapchainCreateInfoKHR & operator=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceGroupSwapchainCreateInfoKHR & operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSwapchainCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSwapchainCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSwapchainCreateInfoKHR & setModes( DeviceGroupPresentModeFlagsKHR modes_ ) & VULKAN_HPP_NOEXCEPT + { + modes = modes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceGroupSwapchainCreateInfoKHR && setModes( DeviceGroupPresentModeFlagsKHR modes_ ) && VULKAN_HPP_NOEXCEPT + { + modes = modes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceGroupSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceGroupSwapchainCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceGroupSwapchainCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, modes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceGroupSwapchainCreateInfoKHR const & ) const = default; +#else + bool operator==( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( modes == rhs.modes ); +# endif + } + + bool operator!=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; + const void * pNext = {}; + DeviceGroupPresentModeFlagsKHR modes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceGroupSwapchainCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceGroupSwapchainCreateInfoKHR; + }; + + // wrapper struct for struct VkImageCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateInfo.html + struct ImageCreateInfo + { + using NativeType = VkImageCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageCreateInfo( ImageCreateFlags flags_ = {}, + ImageType imageType_ = ImageType::e1D, + Format format_ = Format::eUndefined, + Extent3D extent_ = {}, + uint32_t mipLevels_ = {}, + uint32_t arrayLayers_ = {}, + SampleCountFlagBits samples_ = SampleCountFlagBits::e1, + ImageTiling tiling_ = ImageTiling::eOptimal, + ImageUsageFlags usage_ = {}, + SharingMode sharingMode_ = SharingMode::eExclusive, + uint32_t queueFamilyIndexCount_ = {}, + const uint32_t * pQueueFamilyIndices_ = {}, + ImageLayout initialLayout_ = ImageLayout::eUndefined, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , imageType{ imageType_ } + , format{ format_ } + , extent{ extent_ } + , mipLevels{ mipLevels_ } + , arrayLayers{ arrayLayers_ } + , samples{ samples_ } + , tiling{ tiling_ } + , usage{ usage_ } + , sharingMode{ sharingMode_ } + , queueFamilyIndexCount{ queueFamilyIndexCount_ } + , pQueueFamilyIndices{ pQueueFamilyIndices_ } + , initialLayout{ initialLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageCreateInfo( ImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageCreateInfo( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : ImageCreateInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageCreateInfo( ImageCreateFlags flags_, + ImageType imageType_, + Format format_, + Extent3D extent_, + uint32_t mipLevels_, + uint32_t arrayLayers_, + SampleCountFlagBits samples_, + ImageTiling tiling_, + ImageUsageFlags usage_, + SharingMode sharingMode_, + ArrayProxyNoTemporaries const & queueFamilyIndices_, + ImageLayout initialLayout_ = ImageLayout::eUndefined, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , imageType( imageType_ ) + , format( format_ ) + , extent( extent_ ) + , mipLevels( mipLevels_ ) + , arrayLayers( arrayLayers_ ) + , samples( samples_ ) + , tiling( tiling_ ) + , usage( usage_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( static_cast( queueFamilyIndices_.size() ) ) + , pQueueFamilyIndices( queueFamilyIndices_.data() ) + , initialLayout( initialLayout_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ImageCreateInfo & operator=( ImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageCreateInfo & operator=( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setFlags( ImageCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setFlags( ImageCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setImageType( ImageType imageType_ ) & VULKAN_HPP_NOEXCEPT + { + imageType = imageType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setImageType( ImageType imageType_ ) && VULKAN_HPP_NOEXCEPT + { + imageType = imageType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setMipLevels( uint32_t mipLevels_ ) & VULKAN_HPP_NOEXCEPT + { + mipLevels = mipLevels_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setMipLevels( uint32_t mipLevels_ ) && VULKAN_HPP_NOEXCEPT + { + mipLevels = mipLevels_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setArrayLayers( uint32_t arrayLayers_ ) & VULKAN_HPP_NOEXCEPT + { + arrayLayers = arrayLayers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setArrayLayers( uint32_t arrayLayers_ ) && VULKAN_HPP_NOEXCEPT + { + arrayLayers = arrayLayers_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setSamples( SampleCountFlagBits samples_ ) & VULKAN_HPP_NOEXCEPT + { + samples = samples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setSamples( SampleCountFlagBits samples_ ) && VULKAN_HPP_NOEXCEPT + { + samples = samples_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setTiling( ImageTiling tiling_ ) & VULKAN_HPP_NOEXCEPT + { + tiling = tiling_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setTiling( ImageTiling tiling_ ) && VULKAN_HPP_NOEXCEPT + { + tiling = tiling_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setUsage( ImageUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setUsage( ImageUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setSharingMode( SharingMode sharingMode_ ) & VULKAN_HPP_NOEXCEPT + { + sharingMode = sharingMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setSharingMode( SharingMode sharingMode_ ) && VULKAN_HPP_NOEXCEPT + { + sharingMode = sharingMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) & VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) && VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageCreateInfo & setQueueFamilyIndices( ArrayProxyNoTemporaries const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = static_cast( queueFamilyIndices_.size() ); + pQueueFamilyIndices = queueFamilyIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setInitialLayout( ImageLayout initialLayout_ ) & VULKAN_HPP_NOEXCEPT + { + initialLayout = initialLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setInitialLayout( ImageLayout initialLayout_ ) && VULKAN_HPP_NOEXCEPT + { + initialLayout = initialLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + imageType, + format, + extent, + mipLevels, + arrayLayers, + samples, + tiling, + usage, + sharingMode, + queueFamilyIndexCount, + pQueueFamilyIndices, + initialLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageCreateInfo const & ) const = default; +#else + bool operator==( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( imageType == rhs.imageType ) && ( format == rhs.format ) && + ( extent == rhs.extent ) && ( mipLevels == rhs.mipLevels ) && ( arrayLayers == rhs.arrayLayers ) && ( samples == rhs.samples ) && + ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) && + ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && + ( initialLayout == rhs.initialLayout ); +# endif + } + + bool operator!=( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageCreateInfo; + const void * pNext = {}; + ImageCreateFlags flags = {}; + ImageType imageType = ImageType::e1D; + Format format = Format::eUndefined; + Extent3D extent = {}; + uint32_t mipLevels = {}; + uint32_t arrayLayers = {}; + SampleCountFlagBits samples = SampleCountFlagBits::e1; + ImageTiling tiling = ImageTiling::eOptimal; + ImageUsageFlags usage = {}; + SharingMode sharingMode = SharingMode::eExclusive; + uint32_t queueFamilyIndexCount = {}; + const uint32_t * pQueueFamilyIndices = {}; + ImageLayout initialLayout = ImageLayout::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ImageCreateInfo; + }; + + // wrapper struct for struct VkDeviceImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceImageMemoryRequirements.html + struct DeviceImageMemoryRequirements + { + using NativeType = VkDeviceImageMemoryRequirements; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceImageMemoryRequirements; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceImageMemoryRequirements( const ImageCreateInfo * pCreateInfo_ = {}, + ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pCreateInfo{ pCreateInfo_ } + , planeAspect{ planeAspect_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceImageMemoryRequirements( DeviceImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceImageMemoryRequirements( VkDeviceImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceImageMemoryRequirements( *reinterpret_cast( &rhs ) ) + { + } + + DeviceImageMemoryRequirements & operator=( DeviceImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceImageMemoryRequirements & operator=( VkDeviceImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements & setPCreateInfo( const ImageCreateInfo * pCreateInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pCreateInfo = pCreateInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements && setPCreateInfo( const ImageCreateInfo * pCreateInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pCreateInfo = pCreateInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements & setPlaneAspect( ImageAspectFlagBits planeAspect_ ) & VULKAN_HPP_NOEXCEPT + { + planeAspect = planeAspect_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements && setPlaneAspect( ImageAspectFlagBits planeAspect_ ) && VULKAN_HPP_NOEXCEPT + { + planeAspect = planeAspect_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceImageMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceImageMemoryRequirements &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceImageMemoryRequirements const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceImageMemoryRequirements *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pCreateInfo, planeAspect ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceImageMemoryRequirements const & ) const = default; +#else + bool operator==( DeviceImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) && ( planeAspect == rhs.planeAspect ); +# endif + } + + bool operator!=( DeviceImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceImageMemoryRequirements; + const void * pNext = {}; + const ImageCreateInfo * pCreateInfo = {}; + ImageAspectFlagBits planeAspect = ImageAspectFlagBits::eColor; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceImageMemoryRequirements; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceImageMemoryRequirements; + }; + + using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements; + + // wrapper struct for struct VkImageSubresource2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSubresource2.html + struct ImageSubresource2 + { + using NativeType = VkImageSubresource2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageSubresource2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageSubresource2( ImageSubresource imageSubresource_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageSubresource{ imageSubresource_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageSubresource2( ImageSubresource2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageSubresource2( VkImageSubresource2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageSubresource2( *reinterpret_cast( &rhs ) ) {} + + ImageSubresource2 & operator=( ImageSubresource2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageSubresource2 & operator=( VkImageSubresource2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageSubresource2 & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresource2 && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresource2 & setImageSubresource( ImageSubresource const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSubresource2 && setImageSubresource( ImageSubresource const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + imageSubresource = imageSubresource_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageSubresource2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSubresource2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSubresource2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageSubresource2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageSubresource ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageSubresource2 const & ) const = default; +#else + bool operator==( ImageSubresource2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageSubresource == rhs.imageSubresource ); +# endif + } + + bool operator!=( ImageSubresource2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageSubresource2; + void * pNext = {}; + ImageSubresource imageSubresource = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageSubresource2; + }; +#endif + + template <> + struct CppType + { + using Type = ImageSubresource2; + }; + + using ImageSubresource2EXT = ImageSubresource2; + using ImageSubresource2KHR = ImageSubresource2; + + // wrapper struct for struct VkDeviceImageSubresourceInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceImageSubresourceInfo.html + struct DeviceImageSubresourceInfo + { + using NativeType = VkDeviceImageSubresourceInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceImageSubresourceInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceImageSubresourceInfo( const ImageCreateInfo * pCreateInfo_ = {}, + const ImageSubresource2 * pSubresource_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pCreateInfo{ pCreateInfo_ } + , pSubresource{ pSubresource_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceImageSubresourceInfo( DeviceImageSubresourceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceImageSubresourceInfo( VkDeviceImageSubresourceInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceImageSubresourceInfo( *reinterpret_cast( &rhs ) ) + { + } + + DeviceImageSubresourceInfo & operator=( DeviceImageSubresourceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceImageSubresourceInfo & operator=( VkDeviceImageSubresourceInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo & setPCreateInfo( const ImageCreateInfo * pCreateInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pCreateInfo = pCreateInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo && setPCreateInfo( const ImageCreateInfo * pCreateInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pCreateInfo = pCreateInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo & setPSubresource( const ImageSubresource2 * pSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + pSubresource = pSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo && setPSubresource( const ImageSubresource2 * pSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + pSubresource = pSubresource_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceImageSubresourceInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceImageSubresourceInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceImageSubresourceInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceImageSubresourceInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pCreateInfo, pSubresource ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceImageSubresourceInfo const & ) const = default; +#else + bool operator==( DeviceImageSubresourceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) && ( pSubresource == rhs.pSubresource ); +# endif + } + + bool operator!=( DeviceImageSubresourceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceImageSubresourceInfo; + const void * pNext = {}; + const ImageCreateInfo * pCreateInfo = {}; + const ImageSubresource2 * pSubresource = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceImageSubresourceInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceImageSubresourceInfo; + }; + + using DeviceImageSubresourceInfoKHR = DeviceImageSubresourceInfo; + + // wrapper struct for struct VkDeviceMemoryOpaqueCaptureAddressInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html + struct DeviceMemoryOpaqueCaptureAddressInfo + { + using NativeType = VkDeviceMemoryOpaqueCaptureAddressInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryOpaqueCaptureAddressInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceMemoryOpaqueCaptureAddressInfo( DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceMemoryOpaqueCaptureAddressInfo( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceMemoryOpaqueCaptureAddressInfo( VkDeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceMemoryOpaqueCaptureAddressInfo( *reinterpret_cast( &rhs ) ) + { + } + + DeviceMemoryOpaqueCaptureAddressInfo & operator=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceMemoryOpaqueCaptureAddressInfo & operator=( VkDeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOpaqueCaptureAddressInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOpaqueCaptureAddressInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOpaqueCaptureAddressInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOpaqueCaptureAddressInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceMemoryOpaqueCaptureAddressInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryOpaqueCaptureAddressInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryOpaqueCaptureAddressInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceMemoryOpaqueCaptureAddressInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceMemoryOpaqueCaptureAddressInfo const & ) const = default; +#else + bool operator==( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); +# endif + } + + bool operator!=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceMemoryOpaqueCaptureAddressInfo; + const void * pNext = {}; + DeviceMemory memory = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceMemoryOpaqueCaptureAddressInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceMemoryOpaqueCaptureAddressInfo; + }; + + using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo; + + // wrapper struct for struct VkDeviceMemoryOverallocationCreateInfoAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryOverallocationCreateInfoAMD.html + struct DeviceMemoryOverallocationCreateInfoAMD + { + using NativeType = VkDeviceMemoryOverallocationCreateInfoAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DeviceMemoryOverallocationCreateInfoAMD( MemoryOverallocationBehaviorAMD overallocationBehavior_ = MemoryOverallocationBehaviorAMD::eDefault, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , overallocationBehavior{ overallocationBehavior_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceMemoryOverallocationCreateInfoAMD( *reinterpret_cast( &rhs ) ) + { + } + + DeviceMemoryOverallocationCreateInfoAMD & operator=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceMemoryOverallocationCreateInfoAMD & operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOverallocationCreateInfoAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOverallocationCreateInfoAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOverallocationCreateInfoAMD & setOverallocationBehavior( MemoryOverallocationBehaviorAMD overallocationBehavior_ ) & + VULKAN_HPP_NOEXCEPT + { + overallocationBehavior = overallocationBehavior_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOverallocationCreateInfoAMD && setOverallocationBehavior( MemoryOverallocationBehaviorAMD overallocationBehavior_ ) && + VULKAN_HPP_NOEXCEPT + { + overallocationBehavior = overallocationBehavior_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceMemoryOverallocationCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryOverallocationCreateInfoAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceMemoryOverallocationCreateInfoAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceMemoryOverallocationCreateInfoAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, overallocationBehavior ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceMemoryOverallocationCreateInfoAMD const & ) const = default; +#else + bool operator==( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( overallocationBehavior == rhs.overallocationBehavior ); +# endif + } + + bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; + const void * pNext = {}; + MemoryOverallocationBehaviorAMD overallocationBehavior = MemoryOverallocationBehaviorAMD::eDefault; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceMemoryOverallocationCreateInfoAMD; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceMemoryOverallocationCreateInfoAMD; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + union DeviceOrHostAddressConstAMDX + { + using NativeType = VkDeviceOrHostAddressConstAMDX; +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX( DeviceAddress deviceAddress_ = {} ) : deviceAddress( deviceAddress_ ) {} + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX( const void * hostAddress_ ) : hostAddress( hostAddress_ ) {} +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX & setHostAddress( const void * hostAddress_ ) & VULKAN_HPP_NOEXCEPT + { + hostAddress = hostAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX && setHostAddress( const void * hostAddress_ ) && VULKAN_HPP_NOEXCEPT + { + hostAddress = hostAddress_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceOrHostAddressConstAMDX const &() const + { + return *reinterpret_cast( this ); + } + + operator VkDeviceOrHostAddressConstAMDX &() + { + return *reinterpret_cast( this ); + } + +# ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + DeviceAddress deviceAddress; + const void * hostAddress; +# else + VkDeviceAddress deviceAddress; + const void * hostAddress; +# endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceOrHostAddressConstAMDX; + }; +# endif +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkDevicePipelineBinaryInternalCacheControlKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDevicePipelineBinaryInternalCacheControlKHR.html + struct DevicePipelineBinaryInternalCacheControlKHR + { + using NativeType = VkDevicePipelineBinaryInternalCacheControlKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDevicePipelineBinaryInternalCacheControlKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DevicePipelineBinaryInternalCacheControlKHR( Bool32 disableInternalCache_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , disableInternalCache{ disableInternalCache_ } + { + } + + VULKAN_HPP_CONSTEXPR DevicePipelineBinaryInternalCacheControlKHR( DevicePipelineBinaryInternalCacheControlKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DevicePipelineBinaryInternalCacheControlKHR( VkDevicePipelineBinaryInternalCacheControlKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DevicePipelineBinaryInternalCacheControlKHR( *reinterpret_cast( &rhs ) ) + { + } + + DevicePipelineBinaryInternalCacheControlKHR & operator=( DevicePipelineBinaryInternalCacheControlKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DevicePipelineBinaryInternalCacheControlKHR & operator=( VkDevicePipelineBinaryInternalCacheControlKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DevicePipelineBinaryInternalCacheControlKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DevicePipelineBinaryInternalCacheControlKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DevicePipelineBinaryInternalCacheControlKHR & setDisableInternalCache( Bool32 disableInternalCache_ ) & VULKAN_HPP_NOEXCEPT + { + disableInternalCache = disableInternalCache_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DevicePipelineBinaryInternalCacheControlKHR && setDisableInternalCache( Bool32 disableInternalCache_ ) && VULKAN_HPP_NOEXCEPT + { + disableInternalCache = disableInternalCache_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDevicePipelineBinaryInternalCacheControlKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDevicePipelineBinaryInternalCacheControlKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDevicePipelineBinaryInternalCacheControlKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDevicePipelineBinaryInternalCacheControlKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, disableInternalCache ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DevicePipelineBinaryInternalCacheControlKHR const & ) const = default; +#else + bool operator==( DevicePipelineBinaryInternalCacheControlKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( disableInternalCache == rhs.disableInternalCache ); +# endif + } + + bool operator!=( DevicePipelineBinaryInternalCacheControlKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDevicePipelineBinaryInternalCacheControlKHR; + const void * pNext = {}; + Bool32 disableInternalCache = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DevicePipelineBinaryInternalCacheControlKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DevicePipelineBinaryInternalCacheControlKHR; + }; + + // wrapper struct for struct VkDevicePrivateDataCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDevicePrivateDataCreateInfo.html + struct DevicePrivateDataCreateInfo + { + using NativeType = VkDevicePrivateDataCreateInfo; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDevicePrivateDataCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DevicePrivateDataCreateInfo( uint32_t privateDataSlotRequestCount_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , privateDataSlotRequestCount{ privateDataSlotRequestCount_ } + { + } + + VULKAN_HPP_CONSTEXPR DevicePrivateDataCreateInfo( DevicePrivateDataCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DevicePrivateDataCreateInfo( VkDevicePrivateDataCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DevicePrivateDataCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + DevicePrivateDataCreateInfo & operator=( DevicePrivateDataCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DevicePrivateDataCreateInfo & operator=( VkDevicePrivateDataCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DevicePrivateDataCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DevicePrivateDataCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DevicePrivateDataCreateInfo & setPrivateDataSlotRequestCount( uint32_t privateDataSlotRequestCount_ ) & VULKAN_HPP_NOEXCEPT + { + privateDataSlotRequestCount = privateDataSlotRequestCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DevicePrivateDataCreateInfo && setPrivateDataSlotRequestCount( uint32_t privateDataSlotRequestCount_ ) && VULKAN_HPP_NOEXCEPT + { + privateDataSlotRequestCount = privateDataSlotRequestCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDevicePrivateDataCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDevicePrivateDataCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDevicePrivateDataCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDevicePrivateDataCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, privateDataSlotRequestCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DevicePrivateDataCreateInfo const & ) const = default; +#else + bool operator==( DevicePrivateDataCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateDataSlotRequestCount == rhs.privateDataSlotRequestCount ); +# endif + } + + bool operator!=( DevicePrivateDataCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDevicePrivateDataCreateInfo; + const void * pNext = {}; + uint32_t privateDataSlotRequestCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DevicePrivateDataCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DevicePrivateDataCreateInfo; + }; + + using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo; + + // wrapper struct for struct VkDeviceQueueGlobalPriorityCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueGlobalPriorityCreateInfo.html + struct DeviceQueueGlobalPriorityCreateInfo + { + using NativeType = VkDeviceQueueGlobalPriorityCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueGlobalPriorityCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfo( QueueGlobalPriority globalPriority_ = QueueGlobalPriority::eLow, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , globalPriority{ globalPriority_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfo( DeviceQueueGlobalPriorityCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceQueueGlobalPriorityCreateInfo( VkDeviceQueueGlobalPriorityCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceQueueGlobalPriorityCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + DeviceQueueGlobalPriorityCreateInfo & operator=( DeviceQueueGlobalPriorityCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceQueueGlobalPriorityCreateInfo & operator=( VkDeviceQueueGlobalPriorityCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceQueueGlobalPriorityCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueGlobalPriorityCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueGlobalPriorityCreateInfo & setGlobalPriority( QueueGlobalPriority globalPriority_ ) & VULKAN_HPP_NOEXCEPT + { + globalPriority = globalPriority_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueGlobalPriorityCreateInfo && setGlobalPriority( QueueGlobalPriority globalPriority_ ) && VULKAN_HPP_NOEXCEPT + { + globalPriority = globalPriority_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceQueueGlobalPriorityCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceQueueGlobalPriorityCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceQueueGlobalPriorityCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceQueueGlobalPriorityCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, globalPriority ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceQueueGlobalPriorityCreateInfo const & ) const = default; +#else + bool operator==( DeviceQueueGlobalPriorityCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriority == rhs.globalPriority ); +# endif + } + + bool operator!=( DeviceQueueGlobalPriorityCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfo; + const void * pNext = {}; + QueueGlobalPriority globalPriority = QueueGlobalPriority::eLow; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceQueueGlobalPriorityCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceQueueGlobalPriorityCreateInfo; + }; + + using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfo; + using DeviceQueueGlobalPriorityCreateInfoKHR = DeviceQueueGlobalPriorityCreateInfo; + + // wrapper struct for struct VkDeviceQueueInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueInfo2.html + struct DeviceQueueInfo2 + { + using NativeType = VkDeviceQueueInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( DeviceQueueCreateFlags flags_ = {}, + uint32_t queueFamilyIndex_ = {}, + uint32_t queueIndex_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , queueFamilyIndex{ queueFamilyIndex_ } + , queueIndex{ queueIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( DeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceQueueInfo2( *reinterpret_cast( &rhs ) ) {} + + DeviceQueueInfo2 & operator=( DeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceQueueInfo2 & operator=( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 & setFlags( DeviceQueueCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 && setFlags( DeviceQueueCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 & setQueueIndex( uint32_t queueIndex_ ) & VULKAN_HPP_NOEXCEPT + { + queueIndex = queueIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 && setQueueIndex( uint32_t queueIndex_ ) && VULKAN_HPP_NOEXCEPT + { + queueIndex = queueIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceQueueInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceQueueInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceQueueInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceQueueInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queueFamilyIndex, queueIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceQueueInfo2 const & ) const = default; +#else + bool operator==( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && + ( queueIndex == rhs.queueIndex ); +# endif + } + + bool operator!=( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceQueueInfo2; + const void * pNext = {}; + DeviceQueueCreateFlags flags = {}; + uint32_t queueFamilyIndex = {}; + uint32_t queueIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceQueueInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceQueueInfo2; + }; + + // wrapper struct for struct VkDeviceQueueShaderCoreControlCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueShaderCoreControlCreateInfoARM.html + struct DeviceQueueShaderCoreControlCreateInfoARM + { + using NativeType = VkDeviceQueueShaderCoreControlCreateInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueShaderCoreControlCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceQueueShaderCoreControlCreateInfoARM( uint32_t shaderCoreCount_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderCoreCount{ shaderCoreCount_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceQueueShaderCoreControlCreateInfoARM( DeviceQueueShaderCoreControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceQueueShaderCoreControlCreateInfoARM( VkDeviceQueueShaderCoreControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceQueueShaderCoreControlCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + DeviceQueueShaderCoreControlCreateInfoARM & operator=( DeviceQueueShaderCoreControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceQueueShaderCoreControlCreateInfoARM & operator=( VkDeviceQueueShaderCoreControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceQueueShaderCoreControlCreateInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueShaderCoreControlCreateInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueShaderCoreControlCreateInfoARM & setShaderCoreCount( uint32_t shaderCoreCount_ ) & VULKAN_HPP_NOEXCEPT + { + shaderCoreCount = shaderCoreCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceQueueShaderCoreControlCreateInfoARM && setShaderCoreCount( uint32_t shaderCoreCount_ ) && VULKAN_HPP_NOEXCEPT + { + shaderCoreCount = shaderCoreCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceQueueShaderCoreControlCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceQueueShaderCoreControlCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceQueueShaderCoreControlCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceQueueShaderCoreControlCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderCoreCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceQueueShaderCoreControlCreateInfoARM const & ) const = default; +#else + bool operator==( DeviceQueueShaderCoreControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreCount == rhs.shaderCoreCount ); +# endif + } + + bool operator!=( DeviceQueueShaderCoreControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceQueueShaderCoreControlCreateInfoARM; + void * pNext = {}; + uint32_t shaderCoreCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceQueueShaderCoreControlCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceQueueShaderCoreControlCreateInfoARM; + }; + + // wrapper struct for struct VkTensorDescriptionARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorDescriptionARM.html + struct TensorDescriptionARM + { + using NativeType = VkTensorDescriptionARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorDescriptionARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TensorDescriptionARM( TensorTilingARM tiling_ = TensorTilingARM::eOptimal, + Format format_ = Format::eUndefined, + uint32_t dimensionCount_ = {}, + const int64_t * pDimensions_ = {}, + const int64_t * pStrides_ = {}, + TensorUsageFlagsARM usage_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tiling{ tiling_ } + , format{ format_ } + , dimensionCount{ dimensionCount_ } + , pDimensions{ pDimensions_ } + , pStrides{ pStrides_ } + , usage{ usage_ } + { + } + + VULKAN_HPP_CONSTEXPR TensorDescriptionARM( TensorDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TensorDescriptionARM( VkTensorDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT + : TensorDescriptionARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TensorDescriptionARM( TensorTilingARM tiling_, + Format format_, + ArrayProxyNoTemporaries const & dimensions_, + ArrayProxyNoTemporaries const & strides_ = {}, + TensorUsageFlagsARM usage_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , tiling( tiling_ ) + , format( format_ ) + , dimensionCount( static_cast( dimensions_.size() ) ) + , pDimensions( dimensions_.data() ) + , pStrides( strides_.data() ) + , usage( usage_ ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( strides_.empty() || ( dimensions_.size() == strides_.size() ) ); +# else + if ( !strides_.empty() && ( dimensions_.size() != strides_.size() ) ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::TensorDescriptionARM::TensorDescriptionARM: !strides_.empty() && ( dimensions_.size() != strides_.size() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + TensorDescriptionARM & operator=( TensorDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TensorDescriptionARM & operator=( VkTensorDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setTiling( TensorTilingARM tiling_ ) & VULKAN_HPP_NOEXCEPT + { + tiling = tiling_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setTiling( TensorTilingARM tiling_ ) && VULKAN_HPP_NOEXCEPT + { + tiling = tiling_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setDimensionCount( uint32_t dimensionCount_ ) & VULKAN_HPP_NOEXCEPT + { + dimensionCount = dimensionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setDimensionCount( uint32_t dimensionCount_ ) && VULKAN_HPP_NOEXCEPT + { + dimensionCount = dimensionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setPDimensions( const int64_t * pDimensions_ ) & VULKAN_HPP_NOEXCEPT + { + pDimensions = pDimensions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setPDimensions( const int64_t * pDimensions_ ) && VULKAN_HPP_NOEXCEPT + { + pDimensions = pDimensions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TensorDescriptionARM & setDimensions( ArrayProxyNoTemporaries const & dimensions_ ) VULKAN_HPP_NOEXCEPT + { + dimensionCount = static_cast( dimensions_.size() ); + pDimensions = dimensions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setPStrides( const int64_t * pStrides_ ) & VULKAN_HPP_NOEXCEPT + { + pStrides = pStrides_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setPStrides( const int64_t * pStrides_ ) && VULKAN_HPP_NOEXCEPT + { + pStrides = pStrides_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TensorDescriptionARM & setStrides( ArrayProxyNoTemporaries const & strides_ ) VULKAN_HPP_NOEXCEPT + { + dimensionCount = static_cast( strides_.size() ); + pStrides = strides_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setUsage( TensorUsageFlagsARM usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setUsage( TensorUsageFlagsARM usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTensorDescriptionARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorDescriptionARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorDescriptionARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTensorDescriptionARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tiling, format, dimensionCount, pDimensions, pStrides, usage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TensorDescriptionARM const & ) const = default; +#else + bool operator==( TensorDescriptionARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tiling == rhs.tiling ) && ( format == rhs.format ) && + ( dimensionCount == rhs.dimensionCount ) && ( pDimensions == rhs.pDimensions ) && ( pStrides == rhs.pStrides ) && ( usage == rhs.usage ); +# endif + } + + bool operator!=( TensorDescriptionARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTensorDescriptionARM; + const void * pNext = {}; + TensorTilingARM tiling = TensorTilingARM::eOptimal; + Format format = Format::eUndefined; + uint32_t dimensionCount = {}; + const int64_t * pDimensions = {}; + const int64_t * pStrides = {}; + TensorUsageFlagsARM usage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TensorDescriptionARM; + }; +#endif + + template <> + struct CppType + { + using Type = TensorDescriptionARM; + }; + + // wrapper struct for struct VkTensorCreateInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCreateInfoARM.html + struct TensorCreateInfoARM + { + using NativeType = VkTensorCreateInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TensorCreateInfoARM( TensorCreateFlagsARM flags_ = {}, + const TensorDescriptionARM * pDescription_ = {}, + SharingMode sharingMode_ = SharingMode::eExclusive, + uint32_t queueFamilyIndexCount_ = {}, + const uint32_t * pQueueFamilyIndices_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pDescription{ pDescription_ } + , sharingMode{ sharingMode_ } + , queueFamilyIndexCount{ queueFamilyIndexCount_ } + , pQueueFamilyIndices{ pQueueFamilyIndices_ } + { + } + + VULKAN_HPP_CONSTEXPR TensorCreateInfoARM( TensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TensorCreateInfoARM( VkTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT : TensorCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TensorCreateInfoARM( TensorCreateFlagsARM flags_, + const TensorDescriptionARM * pDescription_, + SharingMode sharingMode_, + ArrayProxyNoTemporaries const & queueFamilyIndices_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , pDescription( pDescription_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( static_cast( queueFamilyIndices_.size() ) ) + , pQueueFamilyIndices( queueFamilyIndices_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + TensorCreateInfoARM & operator=( TensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TensorCreateInfoARM & operator=( VkTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setFlags( TensorCreateFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setFlags( TensorCreateFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setPDescription( const TensorDescriptionARM * pDescription_ ) & VULKAN_HPP_NOEXCEPT + { + pDescription = pDescription_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setPDescription( const TensorDescriptionARM * pDescription_ ) && VULKAN_HPP_NOEXCEPT + { + pDescription = pDescription_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setSharingMode( SharingMode sharingMode_ ) & VULKAN_HPP_NOEXCEPT + { + sharingMode = sharingMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setSharingMode( SharingMode sharingMode_ ) && VULKAN_HPP_NOEXCEPT + { + sharingMode = sharingMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) & VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) && VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TensorCreateInfoARM & setQueueFamilyIndices( ArrayProxyNoTemporaries const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = static_cast( queueFamilyIndices_.size() ); + pQueueFamilyIndices = queueFamilyIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTensorCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTensorCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pDescription, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TensorCreateInfoARM const & ) const = default; +#else + bool operator==( TensorCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pDescription == rhs.pDescription ) && + ( sharingMode == rhs.sharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); +# endif + } + + bool operator!=( TensorCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTensorCreateInfoARM; + const void * pNext = {}; + TensorCreateFlagsARM flags = {}; + const TensorDescriptionARM * pDescription = {}; + SharingMode sharingMode = SharingMode::eExclusive; + uint32_t queueFamilyIndexCount = {}; + const uint32_t * pQueueFamilyIndices = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TensorCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = TensorCreateInfoARM; + }; + + // wrapper struct for struct VkDeviceTensorMemoryRequirementsARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceTensorMemoryRequirementsARM.html + struct DeviceTensorMemoryRequirementsARM + { + using NativeType = VkDeviceTensorMemoryRequirementsARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceTensorMemoryRequirementsARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DeviceTensorMemoryRequirementsARM( const TensorCreateInfoARM * pCreateInfo_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pCreateInfo{ pCreateInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR DeviceTensorMemoryRequirementsARM( DeviceTensorMemoryRequirementsARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DeviceTensorMemoryRequirementsARM( VkDeviceTensorMemoryRequirementsARM const & rhs ) VULKAN_HPP_NOEXCEPT + : DeviceTensorMemoryRequirementsARM( *reinterpret_cast( &rhs ) ) + { + } + + DeviceTensorMemoryRequirementsARM & operator=( DeviceTensorMemoryRequirementsARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DeviceTensorMemoryRequirementsARM & operator=( VkDeviceTensorMemoryRequirementsARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DeviceTensorMemoryRequirementsARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceTensorMemoryRequirementsARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DeviceTensorMemoryRequirementsARM & setPCreateInfo( const TensorCreateInfoARM * pCreateInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pCreateInfo = pCreateInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DeviceTensorMemoryRequirementsARM && setPCreateInfo( const TensorCreateInfoARM * pCreateInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pCreateInfo = pCreateInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDeviceTensorMemoryRequirementsARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceTensorMemoryRequirementsARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDeviceTensorMemoryRequirementsARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDeviceTensorMemoryRequirementsARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pCreateInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DeviceTensorMemoryRequirementsARM const & ) const = default; +#else + bool operator==( DeviceTensorMemoryRequirementsARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ); +# endif + } + + bool operator!=( DeviceTensorMemoryRequirementsARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDeviceTensorMemoryRequirementsARM; + const void * pNext = {}; + const TensorCreateInfoARM * pCreateInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DeviceTensorMemoryRequirementsARM; + }; +#endif + + template <> + struct CppType + { + using Type = DeviceTensorMemoryRequirementsARM; + }; + + typedef PFN_vkVoidFunction( VKAPI_PTR * PFN_GetInstanceProcAddrLUNARG )( Instance instance, const char * pName ); + + // wrapper struct for struct VkDirectDriverLoadingInfoLUNARG, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectDriverLoadingInfoLUNARG.html + struct DirectDriverLoadingInfoLUNARG + { + using NativeType = VkDirectDriverLoadingInfoLUNARG; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDirectDriverLoadingInfoLUNARG; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DirectDriverLoadingInfoLUNARG( DirectDriverLoadingFlagsLUNARG flags_ = {}, + PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pfnGetInstanceProcAddr{ pfnGetInstanceProcAddr_ } + { + } + + VULKAN_HPP_CONSTEXPR DirectDriverLoadingInfoLUNARG( DirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DirectDriverLoadingInfoLUNARG( VkDirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT + : DirectDriverLoadingInfoLUNARG( *reinterpret_cast( &rhs ) ) + { + } + + DirectDriverLoadingInfoLUNARG & operator=( DirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DirectDriverLoadingInfoLUNARG & operator=( VkDirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG & setFlags( DirectDriverLoadingFlagsLUNARG flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG && setFlags( DirectDriverLoadingFlagsLUNARG flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG & setPfnGetInstanceProcAddr( PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ ) & + VULKAN_HPP_NOEXCEPT + { + pfnGetInstanceProcAddr = pfnGetInstanceProcAddr_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG && setPfnGetInstanceProcAddr( PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ ) && + VULKAN_HPP_NOEXCEPT + { + pfnGetInstanceProcAddr = pfnGetInstanceProcAddr_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDirectDriverLoadingInfoLUNARG const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDirectDriverLoadingInfoLUNARG &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDirectDriverLoadingInfoLUNARG const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDirectDriverLoadingInfoLUNARG *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pfnGetInstanceProcAddr ); + } +#endif + + bool operator==( DirectDriverLoadingInfoLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT + { +#if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +#else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pfnGetInstanceProcAddr == rhs.pfnGetInstanceProcAddr ); +#endif + } + + bool operator!=( DirectDriverLoadingInfoLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDirectDriverLoadingInfoLUNARG; + void * pNext = {}; + DirectDriverLoadingFlagsLUNARG flags = {}; + PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DirectDriverLoadingInfoLUNARG; + }; +#endif + + template <> + struct CppType + { + using Type = DirectDriverLoadingInfoLUNARG; + }; + + // wrapper struct for struct VkDirectDriverLoadingListLUNARG, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectDriverLoadingListLUNARG.html + struct DirectDriverLoadingListLUNARG + { + using NativeType = VkDirectDriverLoadingListLUNARG; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDirectDriverLoadingListLUNARG; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DirectDriverLoadingListLUNARG( DirectDriverLoadingModeLUNARG mode_ = DirectDriverLoadingModeLUNARG::eExclusive, + uint32_t driverCount_ = {}, + const DirectDriverLoadingInfoLUNARG * pDrivers_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , mode{ mode_ } + , driverCount{ driverCount_ } + , pDrivers{ pDrivers_ } + { + } + + VULKAN_HPP_CONSTEXPR DirectDriverLoadingListLUNARG( DirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DirectDriverLoadingListLUNARG( VkDirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT + : DirectDriverLoadingListLUNARG( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DirectDriverLoadingListLUNARG( DirectDriverLoadingModeLUNARG mode_, + ArrayProxyNoTemporaries const & drivers_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), mode( mode_ ), driverCount( static_cast( drivers_.size() ) ), pDrivers( drivers_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + DirectDriverLoadingListLUNARG & operator=( DirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DirectDriverLoadingListLUNARG & operator=( VkDirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG & setMode( DirectDriverLoadingModeLUNARG mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG && setMode( DirectDriverLoadingModeLUNARG mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG & setDriverCount( uint32_t driverCount_ ) & VULKAN_HPP_NOEXCEPT + { + driverCount = driverCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG && setDriverCount( uint32_t driverCount_ ) && VULKAN_HPP_NOEXCEPT + { + driverCount = driverCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG & setPDrivers( const DirectDriverLoadingInfoLUNARG * pDrivers_ ) & VULKAN_HPP_NOEXCEPT + { + pDrivers = pDrivers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG && setPDrivers( const DirectDriverLoadingInfoLUNARG * pDrivers_ ) && VULKAN_HPP_NOEXCEPT + { + pDrivers = pDrivers_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + DirectDriverLoadingListLUNARG & setDrivers( ArrayProxyNoTemporaries const & drivers_ ) VULKAN_HPP_NOEXCEPT + { + driverCount = static_cast( drivers_.size() ); + pDrivers = drivers_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDirectDriverLoadingListLUNARG const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDirectDriverLoadingListLUNARG &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDirectDriverLoadingListLUNARG const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDirectDriverLoadingListLUNARG *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mode, driverCount, pDrivers ); + } +#endif + + bool operator==( DirectDriverLoadingListLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT + { +#if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +#else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && ( driverCount == rhs.driverCount ) && ( pDrivers == rhs.pDrivers ); +#endif + } + + bool operator!=( DirectDriverLoadingListLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eDirectDriverLoadingListLUNARG; + const void * pNext = {}; + DirectDriverLoadingModeLUNARG mode = DirectDriverLoadingModeLUNARG::eExclusive; + uint32_t driverCount = {}; + const DirectDriverLoadingInfoLUNARG * pDrivers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DirectDriverLoadingListLUNARG; + }; +#endif + + template <> + struct CppType + { + using Type = DirectDriverLoadingListLUNARG; + }; + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + // wrapper struct for struct VkDirectFBSurfaceCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectFBSurfaceCreateInfoEXT.html + struct DirectFBSurfaceCreateInfoEXT + { + using NativeType = VkDirectFBSurfaceCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDirectfbSurfaceCreateInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DirectFBSurfaceCreateInfoEXT( DirectFBSurfaceCreateFlagsEXT flags_ = {}, + IDirectFB * dfb_ = {}, + IDirectFBSurface * surface_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , dfb{ dfb_ } + , surface{ surface_ } + { + } + + VULKAN_HPP_CONSTEXPR DirectFBSurfaceCreateInfoEXT( DirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DirectFBSurfaceCreateInfoEXT( VkDirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DirectFBSurfaceCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + DirectFBSurfaceCreateInfoEXT & operator=( DirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DirectFBSurfaceCreateInfoEXT & operator=( VkDirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT & setFlags( DirectFBSurfaceCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT && setFlags( DirectFBSurfaceCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT & setDfb( IDirectFB * dfb_ ) & VULKAN_HPP_NOEXCEPT + { + dfb = dfb_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT && setDfb( IDirectFB * dfb_ ) && VULKAN_HPP_NOEXCEPT + { + dfb = dfb_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT & setSurface( IDirectFBSurface * surface_ ) & VULKAN_HPP_NOEXCEPT + { + surface = surface_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT && setSurface( IDirectFBSurface * surface_ ) && VULKAN_HPP_NOEXCEPT + { + surface = surface_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDirectFBSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDirectFBSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDirectFBSurfaceCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDirectFBSurfaceCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, dfb, surface ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DirectFBSurfaceCreateInfoEXT const & ) const = default; +# else + bool operator==( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dfb == rhs.dfb ) && ( surface == rhs.surface ); +# endif + } + + bool operator!=( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eDirectfbSurfaceCreateInfoEXT; + const void * pNext = {}; + DirectFBSurfaceCreateFlagsEXT flags = {}; + IDirectFB * dfb = {}; + IDirectFBSurface * surface = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DirectFBSurfaceCreateInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = DirectFBSurfaceCreateInfoEXT; + }; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkDispatchGraphCountInfoAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDispatchGraphCountInfoAMDX.html + struct DispatchGraphCountInfoAMDX + { + using NativeType = VkDispatchGraphCountInfoAMDX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + DispatchGraphCountInfoAMDX( uint32_t count_ = {}, DeviceOrHostAddressConstAMDX infos_ = {}, uint64_t stride_ = {} ) VULKAN_HPP_NOEXCEPT + : count{ count_ } + , infos{ infos_ } + , stride{ stride_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX( DispatchGraphCountInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DispatchGraphCountInfoAMDX( VkDispatchGraphCountInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + : DispatchGraphCountInfoAMDX( *reinterpret_cast( &rhs ) ) + { + } + + DispatchGraphCountInfoAMDX & operator=( DispatchGraphCountInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DispatchGraphCountInfoAMDX & operator=( VkDispatchGraphCountInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX & setCount( uint32_t count_ ) & VULKAN_HPP_NOEXCEPT + { + count = count_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX && setCount( uint32_t count_ ) && VULKAN_HPP_NOEXCEPT + { + count = count_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX & setInfos( DeviceOrHostAddressConstAMDX const & infos_ ) & VULKAN_HPP_NOEXCEPT + { + infos = infos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX && setInfos( DeviceOrHostAddressConstAMDX const & infos_ ) && VULKAN_HPP_NOEXCEPT + { + infos = infos_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX & setStride( uint64_t stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX && setStride( uint64_t stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDispatchGraphCountInfoAMDX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchGraphCountInfoAMDX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchGraphCountInfoAMDX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDispatchGraphCountInfoAMDX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( count, infos, stride ); + } +# endif + + public: + uint32_t count = {}; + DeviceOrHostAddressConstAMDX infos = {}; + uint64_t stride = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DispatchGraphCountInfoAMDX; + }; +# endif +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkDispatchGraphInfoAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDispatchGraphInfoAMDX.html + struct DispatchGraphInfoAMDX + { + using NativeType = VkDispatchGraphInfoAMDX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX( uint32_t nodeIndex_ = {}, + uint32_t payloadCount_ = {}, + DeviceOrHostAddressConstAMDX payloads_ = {}, + uint64_t payloadStride_ = {} ) VULKAN_HPP_NOEXCEPT + : nodeIndex{ nodeIndex_ } + , payloadCount{ payloadCount_ } + , payloads{ payloads_ } + , payloadStride{ payloadStride_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX( DispatchGraphInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DispatchGraphInfoAMDX( VkDispatchGraphInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + : DispatchGraphInfoAMDX( *reinterpret_cast( &rhs ) ) + { + } + + DispatchGraphInfoAMDX & operator=( DispatchGraphInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DispatchGraphInfoAMDX & operator=( VkDispatchGraphInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX & setNodeIndex( uint32_t nodeIndex_ ) & VULKAN_HPP_NOEXCEPT + { + nodeIndex = nodeIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX && setNodeIndex( uint32_t nodeIndex_ ) && VULKAN_HPP_NOEXCEPT + { + nodeIndex = nodeIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX & setPayloadCount( uint32_t payloadCount_ ) & VULKAN_HPP_NOEXCEPT + { + payloadCount = payloadCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX && setPayloadCount( uint32_t payloadCount_ ) && VULKAN_HPP_NOEXCEPT + { + payloadCount = payloadCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX & setPayloads( DeviceOrHostAddressConstAMDX const & payloads_ ) & VULKAN_HPP_NOEXCEPT + { + payloads = payloads_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX && setPayloads( DeviceOrHostAddressConstAMDX const & payloads_ ) && VULKAN_HPP_NOEXCEPT + { + payloads = payloads_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX & setPayloadStride( uint64_t payloadStride_ ) & VULKAN_HPP_NOEXCEPT + { + payloadStride = payloadStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX && setPayloadStride( uint64_t payloadStride_ ) && VULKAN_HPP_NOEXCEPT + { + payloadStride = payloadStride_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDispatchGraphInfoAMDX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchGraphInfoAMDX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchGraphInfoAMDX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDispatchGraphInfoAMDX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( nodeIndex, payloadCount, payloads, payloadStride ); + } +# endif + + public: + uint32_t nodeIndex = {}; + uint32_t payloadCount = {}; + DeviceOrHostAddressConstAMDX payloads = {}; + uint64_t payloadStride = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DispatchGraphInfoAMDX; + }; +# endif +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkDispatchIndirectCommand, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDispatchIndirectCommand.html + struct DispatchIndirectCommand + { + using NativeType = VkDispatchIndirectCommand; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DispatchIndirectCommand( uint32_t x_ = {}, uint32_t y_ = {}, uint32_t z_ = {} ) VULKAN_HPP_NOEXCEPT + : x{ x_ } + , y{ y_ } + , z{ z_ } + { + } + + VULKAN_HPP_CONSTEXPR DispatchIndirectCommand( DispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT + : DispatchIndirectCommand( *reinterpret_cast( &rhs ) ) + { + } + + DispatchIndirectCommand & operator=( DispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DispatchIndirectCommand & operator=( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand & setX( uint32_t x_ ) & VULKAN_HPP_NOEXCEPT + { + x = x_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand && setX( uint32_t x_ ) && VULKAN_HPP_NOEXCEPT + { + x = x_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand & setY( uint32_t y_ ) & VULKAN_HPP_NOEXCEPT + { + y = y_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand && setY( uint32_t y_ ) && VULKAN_HPP_NOEXCEPT + { + y = y_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand & setZ( uint32_t z_ ) & VULKAN_HPP_NOEXCEPT + { + z = z_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand && setZ( uint32_t z_ ) && VULKAN_HPP_NOEXCEPT + { + z = z_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDispatchIndirectCommand const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchIndirectCommand &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchIndirectCommand const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDispatchIndirectCommand *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, z ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DispatchIndirectCommand const & ) const = default; +#else + bool operator==( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ); +# endif + } + + bool operator!=( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t x = {}; + uint32_t y = {}; + uint32_t z = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DispatchIndirectCommand; + }; +#endif + + // wrapper struct for struct VkDispatchTileInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDispatchTileInfoQCOM.html + struct DispatchTileInfoQCOM + { + using NativeType = VkDispatchTileInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDispatchTileInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DispatchTileInfoQCOM( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} + + VULKAN_HPP_CONSTEXPR DispatchTileInfoQCOM( DispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DispatchTileInfoQCOM( VkDispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : DispatchTileInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + DispatchTileInfoQCOM & operator=( DispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DispatchTileInfoQCOM & operator=( VkDispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DispatchTileInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DispatchTileInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDispatchTileInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchTileInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchTileInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDispatchTileInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DispatchTileInfoQCOM const & ) const = default; +#else + bool operator==( DispatchTileInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( DispatchTileInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDispatchTileInfoQCOM; + const void * pNext = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DispatchTileInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = DispatchTileInfoQCOM; + }; + + // wrapper struct for struct VkDisplayEventInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayEventInfoEXT.html + struct DisplayEventInfoEXT + { + using NativeType = VkDisplayEventInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayEventInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , displayEvent{ displayEvent_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DisplayEventInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + DisplayEventInfoEXT & operator=( DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayEventInfoEXT & operator=( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DisplayEventInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayEventInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplayEventInfoEXT & setDisplayEvent( DisplayEventTypeEXT displayEvent_ ) & VULKAN_HPP_NOEXCEPT + { + displayEvent = displayEvent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayEventInfoEXT && setDisplayEvent( DisplayEventTypeEXT displayEvent_ ) && VULKAN_HPP_NOEXCEPT + { + displayEvent = displayEvent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDisplayEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayEventInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayEventInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayEventInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayEvent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayEventInfoEXT const & ) const = default; +#else + bool operator==( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayEvent == rhs.displayEvent ); +# endif + } + + bool operator!=( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplayEventInfoEXT; + const void * pNext = {}; + DisplayEventTypeEXT displayEvent = DisplayEventTypeEXT::eFirstPixelOut; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayEventInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DisplayEventInfoEXT; + }; + + // wrapper struct for struct VkDisplayModeParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeParametersKHR.html + struct DisplayModeParametersKHR + { + using NativeType = VkDisplayModeParametersKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( Extent2D visibleRegion_ = {}, uint32_t refreshRate_ = {} ) VULKAN_HPP_NOEXCEPT + : visibleRegion{ visibleRegion_ } + , refreshRate{ refreshRate_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( DisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayModeParametersKHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayModeParametersKHR & operator=( DisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayModeParametersKHR & operator=( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DisplayModeParametersKHR & setVisibleRegion( Extent2D const & visibleRegion_ ) & VULKAN_HPP_NOEXCEPT + { + visibleRegion = visibleRegion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayModeParametersKHR && setVisibleRegion( Extent2D const & visibleRegion_ ) && VULKAN_HPP_NOEXCEPT + { + visibleRegion = visibleRegion_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplayModeParametersKHR & setRefreshRate( uint32_t refreshRate_ ) & VULKAN_HPP_NOEXCEPT + { + refreshRate = refreshRate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayModeParametersKHR && setRefreshRate( uint32_t refreshRate_ ) && VULKAN_HPP_NOEXCEPT + { + refreshRate = refreshRate_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDisplayModeParametersKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModeParametersKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModeParametersKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayModeParametersKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( visibleRegion, refreshRate ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayModeParametersKHR const & ) const = default; +#else + bool operator==( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( visibleRegion == rhs.visibleRegion ) && ( refreshRate == rhs.refreshRate ); +# endif + } + + bool operator!=( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Extent2D visibleRegion = {}; + uint32_t refreshRate = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayModeParametersKHR; + }; +#endif + + // wrapper struct for struct VkDisplayModeCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeCreateInfoKHR.html + struct DisplayModeCreateInfoKHR + { + using NativeType = VkDisplayModeCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = {}, + DisplayModeParametersKHR parameters_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , parameters{ parameters_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayModeCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayModeCreateInfoKHR & operator=( DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayModeCreateInfoKHR & operator=( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR & setFlags( DisplayModeCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR && setFlags( DisplayModeCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR & setParameters( DisplayModeParametersKHR const & parameters_ ) & VULKAN_HPP_NOEXCEPT + { + parameters = parameters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR && setParameters( DisplayModeParametersKHR const & parameters_ ) && VULKAN_HPP_NOEXCEPT + { + parameters = parameters_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDisplayModeCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModeCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModeCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayModeCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, parameters ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayModeCreateInfoKHR const & ) const = default; +#else + bool operator==( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( parameters == rhs.parameters ); +# endif + } + + bool operator!=( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplayModeCreateInfoKHR; + const void * pNext = {}; + DisplayModeCreateFlagsKHR flags = {}; + DisplayModeParametersKHR parameters = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayModeCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DisplayModeCreateInfoKHR; + }; + + // wrapper struct for struct VkDisplayModePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModePropertiesKHR.html + struct DisplayModePropertiesKHR + { + using NativeType = VkDisplayModePropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayModePropertiesKHR( DisplayModeKHR displayMode_ = {}, DisplayModeParametersKHR parameters_ = {} ) VULKAN_HPP_NOEXCEPT + : displayMode{ displayMode_ } + , parameters{ parameters_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayModePropertiesKHR( DisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayModePropertiesKHR( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayModePropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayModePropertiesKHR & operator=( DisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayModePropertiesKHR & operator=( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDisplayModePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModePropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayModePropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( displayMode, parameters ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayModePropertiesKHR const & ) const = default; +#else + bool operator==( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( displayMode == rhs.displayMode ) && ( parameters == rhs.parameters ); +# endif + } + + bool operator!=( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DisplayModeKHR displayMode = {}; + DisplayModeParametersKHR parameters = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayModePropertiesKHR; + }; +#endif + + // wrapper struct for struct VkDisplayModeProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeProperties2KHR.html + struct DisplayModeProperties2KHR + { + using NativeType = VkDisplayModeProperties2KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeProperties2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayModeProperties2KHR( DisplayModePropertiesKHR displayModeProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , displayModeProperties{ displayModeProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayModeProperties2KHR( DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayModeProperties2KHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayModeProperties2KHR & operator=( DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayModeProperties2KHR & operator=( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDisplayModeProperties2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModeProperties2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModeProperties2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayModeProperties2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayModeProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayModeProperties2KHR const & ) const = default; +#else + bool operator==( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayModeProperties == rhs.displayModeProperties ); +# endif + } + + bool operator!=( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplayModeProperties2KHR; + void * pNext = {}; + DisplayModePropertiesKHR displayModeProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayModeProperties2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = DisplayModeProperties2KHR; + }; + + // wrapper struct for struct VkDisplayModeStereoPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeStereoPropertiesNV.html + struct DisplayModeStereoPropertiesNV + { + using NativeType = VkDisplayModeStereoPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeStereoPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayModeStereoPropertiesNV( Bool32 hdmi3DSupported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , hdmi3DSupported{ hdmi3DSupported_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayModeStereoPropertiesNV( DisplayModeStereoPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayModeStereoPropertiesNV( VkDisplayModeStereoPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayModeStereoPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + DisplayModeStereoPropertiesNV & operator=( DisplayModeStereoPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayModeStereoPropertiesNV & operator=( VkDisplayModeStereoPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDisplayModeStereoPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModeStereoPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayModeStereoPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayModeStereoPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hdmi3DSupported ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayModeStereoPropertiesNV const & ) const = default; +#else + bool operator==( DisplayModeStereoPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hdmi3DSupported == rhs.hdmi3DSupported ); +# endif + } + + bool operator!=( DisplayModeStereoPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplayModeStereoPropertiesNV; + void * pNext = {}; + Bool32 hdmi3DSupported = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayModeStereoPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = DisplayModeStereoPropertiesNV; + }; + + // wrapper struct for struct VkDisplayNativeHdrSurfaceCapabilitiesAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayNativeHdrSurfaceCapabilitiesAMD.html + struct DisplayNativeHdrSurfaceCapabilitiesAMD + { + using NativeType = VkDisplayNativeHdrSurfaceCapabilitiesAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayNativeHdrSurfaceCapabilitiesAMD( Bool32 localDimmingSupport_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , localDimmingSupport{ localDimmingSupport_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayNativeHdrSurfaceCapabilitiesAMD( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayNativeHdrSurfaceCapabilitiesAMD( *reinterpret_cast( &rhs ) ) + { + } + + DisplayNativeHdrSurfaceCapabilitiesAMD & operator=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayNativeHdrSurfaceCapabilitiesAMD & operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayNativeHdrSurfaceCapabilitiesAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayNativeHdrSurfaceCapabilitiesAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, localDimmingSupport ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayNativeHdrSurfaceCapabilitiesAMD const & ) const = default; +#else + bool operator==( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingSupport == rhs.localDimmingSupport ); +# endif + } + + bool operator!=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; + void * pNext = {}; + Bool32 localDimmingSupport = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayNativeHdrSurfaceCapabilitiesAMD; + }; +#endif + + template <> + struct CppType + { + using Type = DisplayNativeHdrSurfaceCapabilitiesAMD; + }; + + // wrapper struct for struct VkDisplayPlaneCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneCapabilitiesKHR.html + struct DisplayPlaneCapabilitiesKHR + { + using NativeType = VkDisplayPlaneCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilitiesKHR( DisplayPlaneAlphaFlagsKHR supportedAlpha_ = {}, + Offset2D minSrcPosition_ = {}, + Offset2D maxSrcPosition_ = {}, + Extent2D minSrcExtent_ = {}, + Extent2D maxSrcExtent_ = {}, + Offset2D minDstPosition_ = {}, + Offset2D maxDstPosition_ = {}, + Extent2D minDstExtent_ = {}, + Extent2D maxDstExtent_ = {} ) VULKAN_HPP_NOEXCEPT + : supportedAlpha{ supportedAlpha_ } + , minSrcPosition{ minSrcPosition_ } + , maxSrcPosition{ maxSrcPosition_ } + , minSrcExtent{ minSrcExtent_ } + , maxSrcExtent{ maxSrcExtent_ } + , minDstPosition{ minDstPosition_ } + , maxDstPosition{ maxDstPosition_ } + , minDstExtent{ minDstExtent_ } + , maxDstExtent{ maxDstExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilitiesKHR( DisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayPlaneCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayPlaneCapabilitiesKHR & operator=( DisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayPlaneCapabilitiesKHR & operator=( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDisplayPlaneCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayPlaneCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( supportedAlpha, minSrcPosition, maxSrcPosition, minSrcExtent, maxSrcExtent, minDstPosition, maxDstPosition, minDstExtent, maxDstExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayPlaneCapabilitiesKHR const & ) const = default; +#else + bool operator==( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( supportedAlpha == rhs.supportedAlpha ) && ( minSrcPosition == rhs.minSrcPosition ) && ( maxSrcPosition == rhs.maxSrcPosition ) && + ( minSrcExtent == rhs.minSrcExtent ) && ( maxSrcExtent == rhs.maxSrcExtent ) && ( minDstPosition == rhs.minDstPosition ) && + ( maxDstPosition == rhs.maxDstPosition ) && ( minDstExtent == rhs.minDstExtent ) && ( maxDstExtent == rhs.maxDstExtent ); +# endif + } + + bool operator!=( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DisplayPlaneAlphaFlagsKHR supportedAlpha = {}; + Offset2D minSrcPosition = {}; + Offset2D maxSrcPosition = {}; + Extent2D minSrcExtent = {}; + Extent2D maxSrcExtent = {}; + Offset2D minDstPosition = {}; + Offset2D maxDstPosition = {}; + Extent2D minDstExtent = {}; + Extent2D maxDstExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayPlaneCapabilitiesKHR; + }; +#endif + + // wrapper struct for struct VkDisplayPlaneCapabilities2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneCapabilities2KHR.html + struct DisplayPlaneCapabilities2KHR + { + using NativeType = VkDisplayPlaneCapabilities2KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneCapabilities2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilities2KHR( DisplayPlaneCapabilitiesKHR capabilities_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , capabilities{ capabilities_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilities2KHR( DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayPlaneCapabilities2KHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayPlaneCapabilities2KHR & operator=( DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayPlaneCapabilities2KHR & operator=( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDisplayPlaneCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneCapabilities2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneCapabilities2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayPlaneCapabilities2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, capabilities ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayPlaneCapabilities2KHR const & ) const = default; +#else + bool operator==( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilities == rhs.capabilities ); +# endif + } + + bool operator!=( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR; + void * pNext = {}; + DisplayPlaneCapabilitiesKHR capabilities = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayPlaneCapabilities2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = DisplayPlaneCapabilities2KHR; + }; + + // wrapper struct for struct VkDisplayPlaneInfo2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneInfo2KHR.html + struct DisplayPlaneInfo2KHR + { + using NativeType = VkDisplayPlaneInfo2KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneInfo2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( DisplayModeKHR mode_ = {}, uint32_t planeIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , mode{ mode_ } + , planeIndex{ planeIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayPlaneInfo2KHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayPlaneInfo2KHR & operator=( DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayPlaneInfo2KHR & operator=( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR & setMode( DisplayModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR && setMode( DisplayModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR & setPlaneIndex( uint32_t planeIndex_ ) & VULKAN_HPP_NOEXCEPT + { + planeIndex = planeIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR && setPlaneIndex( uint32_t planeIndex_ ) && VULKAN_HPP_NOEXCEPT + { + planeIndex = planeIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDisplayPlaneInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneInfo2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneInfo2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayPlaneInfo2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mode, planeIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayPlaneInfo2KHR const & ) const = default; +#else + bool operator==( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && ( planeIndex == rhs.planeIndex ); +# endif + } + + bool operator!=( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplayPlaneInfo2KHR; + const void * pNext = {}; + DisplayModeKHR mode = {}; + uint32_t planeIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayPlaneInfo2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = DisplayPlaneInfo2KHR; + }; + + // wrapper struct for struct VkDisplayPlanePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlanePropertiesKHR.html + struct DisplayPlanePropertiesKHR + { + using NativeType = VkDisplayPlanePropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayPlanePropertiesKHR( DisplayKHR currentDisplay_ = {}, uint32_t currentStackIndex_ = {} ) VULKAN_HPP_NOEXCEPT + : currentDisplay{ currentDisplay_ } + , currentStackIndex{ currentStackIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayPlanePropertiesKHR( DisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayPlanePropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayPlanePropertiesKHR & operator=( DisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayPlanePropertiesKHR & operator=( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDisplayPlanePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlanePropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlanePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayPlanePropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( currentDisplay, currentStackIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayPlanePropertiesKHR const & ) const = default; +#else + bool operator==( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( currentDisplay == rhs.currentDisplay ) && ( currentStackIndex == rhs.currentStackIndex ); +# endif + } + + bool operator!=( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DisplayKHR currentDisplay = {}; + uint32_t currentStackIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayPlanePropertiesKHR; + }; +#endif + + // wrapper struct for struct VkDisplayPlaneProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneProperties2KHR.html + struct DisplayPlaneProperties2KHR + { + using NativeType = VkDisplayPlaneProperties2KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneProperties2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayPlaneProperties2KHR( DisplayPlanePropertiesKHR displayPlaneProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , displayPlaneProperties{ displayPlaneProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayPlaneProperties2KHR( DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayPlaneProperties2KHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayPlaneProperties2KHR & operator=( DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayPlaneProperties2KHR & operator=( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDisplayPlaneProperties2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneProperties2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPlaneProperties2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayPlaneProperties2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayPlaneProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayPlaneProperties2KHR const & ) const = default; +#else + bool operator==( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayPlaneProperties == rhs.displayPlaneProperties ); +# endif + } + + bool operator!=( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplayPlaneProperties2KHR; + void * pNext = {}; + DisplayPlanePropertiesKHR displayPlaneProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayPlaneProperties2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = DisplayPlaneProperties2KHR; + }; + + // wrapper struct for struct VkDisplayPowerInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPowerInfoEXT.html + struct DisplayPowerInfoEXT + { + using NativeType = VkDisplayPowerInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPowerInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , powerState{ powerState_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DisplayPowerInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + DisplayPowerInfoEXT & operator=( DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayPowerInfoEXT & operator=( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DisplayPowerInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPowerInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPowerInfoEXT & setPowerState( DisplayPowerStateEXT powerState_ ) & VULKAN_HPP_NOEXCEPT + { + powerState = powerState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPowerInfoEXT && setPowerState( DisplayPowerStateEXT powerState_ ) && VULKAN_HPP_NOEXCEPT + { + powerState = powerState_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDisplayPowerInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPowerInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPowerInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayPowerInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, powerState ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayPowerInfoEXT const & ) const = default; +#else + bool operator==( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( powerState == rhs.powerState ); +# endif + } + + bool operator!=( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplayPowerInfoEXT; + const void * pNext = {}; + DisplayPowerStateEXT powerState = DisplayPowerStateEXT::eOff; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayPowerInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DisplayPowerInfoEXT; + }; + + // wrapper struct for struct VkDisplayPresentInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPresentInfoKHR.html + struct DisplayPresentInfoKHR + { + using NativeType = VkDisplayPresentInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPresentInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DisplayPresentInfoKHR( Rect2D srcRect_ = {}, Rect2D dstRect_ = {}, Bool32 persistent_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcRect{ srcRect_ } + , dstRect{ dstRect_ } + , persistent{ persistent_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayPresentInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayPresentInfoKHR & operator=( DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayPresentInfoKHR & operator=( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR & setSrcRect( Rect2D const & srcRect_ ) & VULKAN_HPP_NOEXCEPT + { + srcRect = srcRect_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR && setSrcRect( Rect2D const & srcRect_ ) && VULKAN_HPP_NOEXCEPT + { + srcRect = srcRect_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR & setDstRect( Rect2D const & dstRect_ ) & VULKAN_HPP_NOEXCEPT + { + dstRect = dstRect_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR && setDstRect( Rect2D const & dstRect_ ) && VULKAN_HPP_NOEXCEPT + { + dstRect = dstRect_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR & setPersistent( Bool32 persistent_ ) & VULKAN_HPP_NOEXCEPT + { + persistent = persistent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR && setPersistent( Bool32 persistent_ ) && VULKAN_HPP_NOEXCEPT + { + persistent = persistent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDisplayPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPresentInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPresentInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayPresentInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcRect, dstRect, persistent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayPresentInfoKHR const & ) const = default; +#else + bool operator==( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcRect == rhs.srcRect ) && ( dstRect == rhs.dstRect ) && ( persistent == rhs.persistent ); +# endif + } + + bool operator!=( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplayPresentInfoKHR; + const void * pNext = {}; + Rect2D srcRect = {}; + Rect2D dstRect = {}; + Bool32 persistent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayPresentInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DisplayPresentInfoKHR; + }; + + // wrapper struct for struct VkDisplayPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPropertiesKHR.html + struct DisplayPropertiesKHR + { + using NativeType = VkDisplayPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayPropertiesKHR( DisplayKHR display_ = {}, + const char * displayName_ = {}, + Extent2D physicalDimensions_ = {}, + Extent2D physicalResolution_ = {}, + SurfaceTransformFlagsKHR supportedTransforms_ = {}, + Bool32 planeReorderPossible_ = {}, + Bool32 persistentContent_ = {} ) VULKAN_HPP_NOEXCEPT + : display{ display_ } + , displayName{ displayName_ } + , physicalDimensions{ physicalDimensions_ } + , physicalResolution{ physicalResolution_ } + , supportedTransforms{ supportedTransforms_ } + , planeReorderPossible{ planeReorderPossible_ } + , persistentContent{ persistentContent_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayPropertiesKHR( DisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayPropertiesKHR( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayPropertiesKHR & operator=( DisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayPropertiesKHR & operator=( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDisplayPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( display, displayName, physicalDimensions, physicalResolution, supportedTransforms, planeReorderPossible, persistentContent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = display <=> rhs.display; cmp != 0 ) + return cmp; + if ( displayName != rhs.displayName ) + if ( auto cmp = strcmp( displayName, rhs.displayName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = physicalDimensions <=> rhs.physicalDimensions; cmp != 0 ) + return cmp; + if ( auto cmp = physicalResolution <=> rhs.physicalResolution; cmp != 0 ) + return cmp; + if ( auto cmp = supportedTransforms <=> rhs.supportedTransforms; cmp != 0 ) + return cmp; + if ( auto cmp = planeReorderPossible <=> rhs.planeReorderPossible; cmp != 0 ) + return cmp; + if ( auto cmp = persistentContent <=> rhs.persistentContent; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( display == rhs.display ) && ( ( displayName == rhs.displayName ) || ( strcmp( displayName, rhs.displayName ) == 0 ) ) && + ( physicalDimensions == rhs.physicalDimensions ) && ( physicalResolution == rhs.physicalResolution ) && + ( supportedTransforms == rhs.supportedTransforms ) && ( planeReorderPossible == rhs.planeReorderPossible ) && + ( persistentContent == rhs.persistentContent ); + } + + bool operator!=( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + DisplayKHR display = {}; + const char * displayName = {}; + Extent2D physicalDimensions = {}; + Extent2D physicalResolution = {}; + SurfaceTransformFlagsKHR supportedTransforms = {}; + Bool32 planeReorderPossible = {}; + Bool32 persistentContent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayPropertiesKHR; + }; +#endif + + // wrapper struct for struct VkDisplayProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayProperties2KHR.html + struct DisplayProperties2KHR + { + using NativeType = VkDisplayProperties2KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayProperties2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplayProperties2KHR( DisplayPropertiesKHR displayProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , displayProperties{ displayProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplayProperties2KHR( DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplayProperties2KHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplayProperties2KHR & operator=( DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplayProperties2KHR & operator=( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDisplayProperties2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayProperties2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplayProperties2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplayProperties2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displayProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplayProperties2KHR const & ) const = default; +#else + bool operator==( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayProperties == rhs.displayProperties ); +# endif + } + + bool operator!=( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplayProperties2KHR; + void * pNext = {}; + DisplayPropertiesKHR displayProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplayProperties2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = DisplayProperties2KHR; + }; + + // wrapper struct for struct VkDisplaySurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplaySurfaceCreateInfoKHR.html + struct DisplaySurfaceCreateInfoKHR + { + using NativeType = VkDisplaySurfaceCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplaySurfaceCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = {}, + DisplayModeKHR displayMode_ = {}, + uint32_t planeIndex_ = {}, + uint32_t planeStackIndex_ = {}, + SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, + float globalAlpha_ = {}, + DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque, + Extent2D imageExtent_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , displayMode{ displayMode_ } + , planeIndex{ planeIndex_ } + , planeStackIndex{ planeStackIndex_ } + , transform{ transform_ } + , globalAlpha{ globalAlpha_ } + , alphaMode{ alphaMode_ } + , imageExtent{ imageExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplaySurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + DisplaySurfaceCreateInfoKHR & operator=( DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplaySurfaceCreateInfoKHR & operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setFlags( DisplaySurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setFlags( DisplaySurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setDisplayMode( DisplayModeKHR displayMode_ ) & VULKAN_HPP_NOEXCEPT + { + displayMode = displayMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setDisplayMode( DisplayModeKHR displayMode_ ) && VULKAN_HPP_NOEXCEPT + { + displayMode = displayMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setPlaneIndex( uint32_t planeIndex_ ) & VULKAN_HPP_NOEXCEPT + { + planeIndex = planeIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setPlaneIndex( uint32_t planeIndex_ ) && VULKAN_HPP_NOEXCEPT + { + planeIndex = planeIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setPlaneStackIndex( uint32_t planeStackIndex_ ) & VULKAN_HPP_NOEXCEPT + { + planeStackIndex = planeStackIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setPlaneStackIndex( uint32_t planeStackIndex_ ) && VULKAN_HPP_NOEXCEPT + { + planeStackIndex = planeStackIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setTransform( SurfaceTransformFlagBitsKHR transform_ ) & VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setTransform( SurfaceTransformFlagBitsKHR transform_ ) && VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setGlobalAlpha( float globalAlpha_ ) & VULKAN_HPP_NOEXCEPT + { + globalAlpha = globalAlpha_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setGlobalAlpha( float globalAlpha_ ) && VULKAN_HPP_NOEXCEPT + { + globalAlpha = globalAlpha_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ ) & VULKAN_HPP_NOEXCEPT + { + alphaMode = alphaMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ ) && VULKAN_HPP_NOEXCEPT + { + alphaMode = alphaMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setImageExtent( Extent2D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setImageExtent( Extent2D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDisplaySurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplaySurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplaySurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplaySurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, displayMode, planeIndex, planeStackIndex, transform, globalAlpha, alphaMode, imageExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplaySurfaceCreateInfoKHR const & ) const = default; +#else + bool operator==( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( displayMode == rhs.displayMode ) && + ( planeIndex == rhs.planeIndex ) && ( planeStackIndex == rhs.planeStackIndex ) && ( transform == rhs.transform ) && + ( globalAlpha == rhs.globalAlpha ) && ( alphaMode == rhs.alphaMode ) && ( imageExtent == rhs.imageExtent ); +# endif + } + + bool operator!=( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR; + const void * pNext = {}; + DisplaySurfaceCreateFlagsKHR flags = {}; + DisplayModeKHR displayMode = {}; + uint32_t planeIndex = {}; + uint32_t planeStackIndex = {}; + SurfaceTransformFlagBitsKHR transform = SurfaceTransformFlagBitsKHR::eIdentity; + float globalAlpha = {}; + DisplayPlaneAlphaFlagBitsKHR alphaMode = DisplayPlaneAlphaFlagBitsKHR::eOpaque; + Extent2D imageExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplaySurfaceCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = DisplaySurfaceCreateInfoKHR; + }; + + // wrapper struct for struct VkDisplaySurfaceStereoCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplaySurfaceStereoCreateInfoNV.html + struct DisplaySurfaceStereoCreateInfoNV + { + using NativeType = VkDisplaySurfaceStereoCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplaySurfaceStereoCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DisplaySurfaceStereoCreateInfoNV( DisplaySurfaceStereoTypeNV stereoType_ = DisplaySurfaceStereoTypeNV::eNone, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stereoType{ stereoType_ } + { + } + + VULKAN_HPP_CONSTEXPR DisplaySurfaceStereoCreateInfoNV( DisplaySurfaceStereoCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DisplaySurfaceStereoCreateInfoNV( VkDisplaySurfaceStereoCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : DisplaySurfaceStereoCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + DisplaySurfaceStereoCreateInfoNV & operator=( DisplaySurfaceStereoCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DisplaySurfaceStereoCreateInfoNV & operator=( VkDisplaySurfaceStereoCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceStereoCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceStereoCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceStereoCreateInfoNV & setStereoType( DisplaySurfaceStereoTypeNV stereoType_ ) & VULKAN_HPP_NOEXCEPT + { + stereoType = stereoType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceStereoCreateInfoNV && setStereoType( DisplaySurfaceStereoTypeNV stereoType_ ) && VULKAN_HPP_NOEXCEPT + { + stereoType = stereoType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDisplaySurfaceStereoCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplaySurfaceStereoCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDisplaySurfaceStereoCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDisplaySurfaceStereoCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stereoType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DisplaySurfaceStereoCreateInfoNV const & ) const = default; +#else + bool operator==( DisplaySurfaceStereoCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stereoType == rhs.stereoType ); +# endif + } + + bool operator!=( DisplaySurfaceStereoCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDisplaySurfaceStereoCreateInfoNV; + const void * pNext = {}; + DisplaySurfaceStereoTypeNV stereoType = DisplaySurfaceStereoTypeNV::eNone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DisplaySurfaceStereoCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = DisplaySurfaceStereoCreateInfoNV; + }; + + // wrapper struct for struct VkDrawIndexedIndirectCommand, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawIndexedIndirectCommand.html + struct DrawIndexedIndirectCommand + { + using NativeType = VkDrawIndexedIndirectCommand; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DrawIndexedIndirectCommand( uint32_t indexCount_ = {}, + uint32_t instanceCount_ = {}, + uint32_t firstIndex_ = {}, + int32_t vertexOffset_ = {}, + uint32_t firstInstance_ = {} ) VULKAN_HPP_NOEXCEPT + : indexCount{ indexCount_ } + , instanceCount{ instanceCount_ } + , firstIndex{ firstIndex_ } + , vertexOffset{ vertexOffset_ } + , firstInstance{ firstInstance_ } + { + } + + VULKAN_HPP_CONSTEXPR DrawIndexedIndirectCommand( DrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT + : DrawIndexedIndirectCommand( *reinterpret_cast( &rhs ) ) + { + } + + DrawIndexedIndirectCommand & operator=( DrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DrawIndexedIndirectCommand & operator=( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand & setIndexCount( uint32_t indexCount_ ) & VULKAN_HPP_NOEXCEPT + { + indexCount = indexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand && setIndexCount( uint32_t indexCount_ ) && VULKAN_HPP_NOEXCEPT + { + indexCount = indexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand & setInstanceCount( uint32_t instanceCount_ ) & VULKAN_HPP_NOEXCEPT + { + instanceCount = instanceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand && setInstanceCount( uint32_t instanceCount_ ) && VULKAN_HPP_NOEXCEPT + { + instanceCount = instanceCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand & setFirstIndex( uint32_t firstIndex_ ) & VULKAN_HPP_NOEXCEPT + { + firstIndex = firstIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand && setFirstIndex( uint32_t firstIndex_ ) && VULKAN_HPP_NOEXCEPT + { + firstIndex = firstIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand & setVertexOffset( int32_t vertexOffset_ ) & VULKAN_HPP_NOEXCEPT + { + vertexOffset = vertexOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand && setVertexOffset( int32_t vertexOffset_ ) && VULKAN_HPP_NOEXCEPT + { + vertexOffset = vertexOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand & setFirstInstance( uint32_t firstInstance_ ) & VULKAN_HPP_NOEXCEPT + { + firstInstance = firstInstance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand && setFirstInstance( uint32_t firstInstance_ ) && VULKAN_HPP_NOEXCEPT + { + firstInstance = firstInstance_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDrawIndexedIndirectCommand const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndexedIndirectCommand &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndexedIndirectCommand const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDrawIndexedIndirectCommand *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DrawIndexedIndirectCommand const & ) const = default; +#else + bool operator==( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( indexCount == rhs.indexCount ) && ( instanceCount == rhs.instanceCount ) && ( firstIndex == rhs.firstIndex ) && + ( vertexOffset == rhs.vertexOffset ) && ( firstInstance == rhs.firstInstance ); +# endif + } + + bool operator!=( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t indexCount = {}; + uint32_t instanceCount = {}; + uint32_t firstIndex = {}; + int32_t vertexOffset = {}; + uint32_t firstInstance = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DrawIndexedIndirectCommand; + }; +#endif + + // wrapper struct for struct VkDrawIndirectCommand, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawIndirectCommand.html + struct DrawIndirectCommand + { + using NativeType = VkDrawIndirectCommand; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DrawIndirectCommand( uint32_t vertexCount_ = {}, + uint32_t instanceCount_ = {}, + uint32_t firstVertex_ = {}, + uint32_t firstInstance_ = {} ) VULKAN_HPP_NOEXCEPT + : vertexCount{ vertexCount_ } + , instanceCount{ instanceCount_ } + , firstVertex{ firstVertex_ } + , firstInstance{ firstInstance_ } + { + } + + VULKAN_HPP_CONSTEXPR DrawIndirectCommand( DrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT : DrawIndirectCommand( *reinterpret_cast( &rhs ) ) + { + } + + DrawIndirectCommand & operator=( DrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DrawIndirectCommand & operator=( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT + { + vertexCount = vertexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT + { + vertexCount = vertexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand & setInstanceCount( uint32_t instanceCount_ ) & VULKAN_HPP_NOEXCEPT + { + instanceCount = instanceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand && setInstanceCount( uint32_t instanceCount_ ) && VULKAN_HPP_NOEXCEPT + { + instanceCount = instanceCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand & setFirstVertex( uint32_t firstVertex_ ) & VULKAN_HPP_NOEXCEPT + { + firstVertex = firstVertex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand && setFirstVertex( uint32_t firstVertex_ ) && VULKAN_HPP_NOEXCEPT + { + firstVertex = firstVertex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand & setFirstInstance( uint32_t firstInstance_ ) & VULKAN_HPP_NOEXCEPT + { + firstInstance = firstInstance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand && setFirstInstance( uint32_t firstInstance_ ) && VULKAN_HPP_NOEXCEPT + { + firstInstance = firstInstance_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDrawIndirectCommand const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndirectCommand &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndirectCommand const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDrawIndirectCommand *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( vertexCount, instanceCount, firstVertex, firstInstance ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DrawIndirectCommand const & ) const = default; +#else + bool operator==( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( vertexCount == rhs.vertexCount ) && ( instanceCount == rhs.instanceCount ) && ( firstVertex == rhs.firstVertex ) && + ( firstInstance == rhs.firstInstance ); +# endif + } + + bool operator!=( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t vertexCount = {}; + uint32_t instanceCount = {}; + uint32_t firstVertex = {}; + uint32_t firstInstance = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DrawIndirectCommand; + }; +#endif + + // wrapper struct for struct VkDrawIndirectCountIndirectCommandEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawIndirectCountIndirectCommandEXT.html + struct DrawIndirectCountIndirectCommandEXT + { + using NativeType = VkDrawIndirectCountIndirectCommandEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DrawIndirectCountIndirectCommandEXT( DeviceAddress bufferAddress_ = {}, uint32_t stride_ = {}, uint32_t commandCount_ = {} ) VULKAN_HPP_NOEXCEPT + : bufferAddress{ bufferAddress_ } + , stride{ stride_ } + , commandCount{ commandCount_ } + { + } + + VULKAN_HPP_CONSTEXPR DrawIndirectCountIndirectCommandEXT( DrawIndirectCountIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DrawIndirectCountIndirectCommandEXT( VkDrawIndirectCountIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DrawIndirectCountIndirectCommandEXT( *reinterpret_cast( &rhs ) ) + { + } + + DrawIndirectCountIndirectCommandEXT & operator=( DrawIndirectCountIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DrawIndirectCountIndirectCommandEXT & operator=( VkDrawIndirectCountIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT + { + bufferAddress = bufferAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT + { + bufferAddress = bufferAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT & setCommandCount( uint32_t commandCount_ ) & VULKAN_HPP_NOEXCEPT + { + commandCount = commandCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT && setCommandCount( uint32_t commandCount_ ) && VULKAN_HPP_NOEXCEPT + { + commandCount = commandCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDrawIndirectCountIndirectCommandEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndirectCountIndirectCommandEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawIndirectCountIndirectCommandEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDrawIndirectCountIndirectCommandEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( bufferAddress, stride, commandCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DrawIndirectCountIndirectCommandEXT const & ) const = default; +#else + bool operator==( DrawIndirectCountIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( bufferAddress == rhs.bufferAddress ) && ( stride == rhs.stride ) && ( commandCount == rhs.commandCount ); +# endif + } + + bool operator!=( DrawIndirectCountIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress bufferAddress = {}; + uint32_t stride = {}; + uint32_t commandCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DrawIndirectCountIndirectCommandEXT; + }; +#endif + + // wrapper struct for struct VkDrawMeshTasksIndirectCommandEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawMeshTasksIndirectCommandEXT.html + struct DrawMeshTasksIndirectCommandEXT + { + using NativeType = VkDrawMeshTasksIndirectCommandEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + DrawMeshTasksIndirectCommandEXT( uint32_t groupCountX_ = {}, uint32_t groupCountY_ = {}, uint32_t groupCountZ_ = {} ) VULKAN_HPP_NOEXCEPT + : groupCountX{ groupCountX_ } + , groupCountY{ groupCountY_ } + , groupCountZ{ groupCountZ_ } + { + } + + VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandEXT( DrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DrawMeshTasksIndirectCommandEXT( VkDrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DrawMeshTasksIndirectCommandEXT( *reinterpret_cast( &rhs ) ) + { + } + + DrawMeshTasksIndirectCommandEXT & operator=( DrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DrawMeshTasksIndirectCommandEXT & operator=( VkDrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT & setGroupCountX( uint32_t groupCountX_ ) & VULKAN_HPP_NOEXCEPT + { + groupCountX = groupCountX_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT && setGroupCountX( uint32_t groupCountX_ ) && VULKAN_HPP_NOEXCEPT + { + groupCountX = groupCountX_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT & setGroupCountY( uint32_t groupCountY_ ) & VULKAN_HPP_NOEXCEPT + { + groupCountY = groupCountY_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT && setGroupCountY( uint32_t groupCountY_ ) && VULKAN_HPP_NOEXCEPT + { + groupCountY = groupCountY_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT & setGroupCountZ( uint32_t groupCountZ_ ) & VULKAN_HPP_NOEXCEPT + { + groupCountZ = groupCountZ_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT && setGroupCountZ( uint32_t groupCountZ_ ) && VULKAN_HPP_NOEXCEPT + { + groupCountZ = groupCountZ_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDrawMeshTasksIndirectCommandEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawMeshTasksIndirectCommandEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawMeshTasksIndirectCommandEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDrawMeshTasksIndirectCommandEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( groupCountX, groupCountY, groupCountZ ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DrawMeshTasksIndirectCommandEXT const & ) const = default; +#else + bool operator==( DrawMeshTasksIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( groupCountX == rhs.groupCountX ) && ( groupCountY == rhs.groupCountY ) && ( groupCountZ == rhs.groupCountZ ); +# endif + } + + bool operator!=( DrawMeshTasksIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t groupCountX = {}; + uint32_t groupCountY = {}; + uint32_t groupCountZ = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DrawMeshTasksIndirectCommandEXT; + }; +#endif + + // wrapper struct for struct VkDrawMeshTasksIndirectCommandNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawMeshTasksIndirectCommandNV.html + struct DrawMeshTasksIndirectCommandNV + { + using NativeType = VkDrawMeshTasksIndirectCommandNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = {}, uint32_t firstTask_ = {} ) VULKAN_HPP_NOEXCEPT + : taskCount{ taskCount_ } + , firstTask{ firstTask_ } + { + } + + VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandNV( DrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + : DrawMeshTasksIndirectCommandNV( *reinterpret_cast( &rhs ) ) + { + } + + DrawMeshTasksIndirectCommandNV & operator=( DrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DrawMeshTasksIndirectCommandNV & operator=( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandNV & setTaskCount( uint32_t taskCount_ ) & VULKAN_HPP_NOEXCEPT + { + taskCount = taskCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandNV && setTaskCount( uint32_t taskCount_ ) && VULKAN_HPP_NOEXCEPT + { + taskCount = taskCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandNV & setFirstTask( uint32_t firstTask_ ) & VULKAN_HPP_NOEXCEPT + { + firstTask = firstTask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandNV && setFirstTask( uint32_t firstTask_ ) && VULKAN_HPP_NOEXCEPT + { + firstTask = firstTask_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDrawMeshTasksIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawMeshTasksIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrawMeshTasksIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDrawMeshTasksIndirectCommandNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( taskCount, firstTask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DrawMeshTasksIndirectCommandNV const & ) const = default; +#else + bool operator==( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( taskCount == rhs.taskCount ) && ( firstTask == rhs.firstTask ); +# endif + } + + bool operator!=( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t taskCount = {}; + uint32_t firstTask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DrawMeshTasksIndirectCommandNV; + }; +#endif + + // wrapper struct for struct VkDrmFormatModifierProperties2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrmFormatModifierProperties2EXT.html + struct DrmFormatModifierProperties2EXT + { + using NativeType = VkDrmFormatModifierProperties2EXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DrmFormatModifierProperties2EXT( uint64_t drmFormatModifier_ = {}, + uint32_t drmFormatModifierPlaneCount_ = {}, + FormatFeatureFlags2 drmFormatModifierTilingFeatures_ = {} ) VULKAN_HPP_NOEXCEPT + : drmFormatModifier{ drmFormatModifier_ } + , drmFormatModifierPlaneCount{ drmFormatModifierPlaneCount_ } + , drmFormatModifierTilingFeatures{ drmFormatModifierTilingFeatures_ } + { + } + + VULKAN_HPP_CONSTEXPR DrmFormatModifierProperties2EXT( DrmFormatModifierProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DrmFormatModifierProperties2EXT( VkDrmFormatModifierProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DrmFormatModifierProperties2EXT( *reinterpret_cast( &rhs ) ) + { + } + + DrmFormatModifierProperties2EXT & operator=( DrmFormatModifierProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DrmFormatModifierProperties2EXT & operator=( VkDrmFormatModifierProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDrmFormatModifierProperties2EXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrmFormatModifierProperties2EXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrmFormatModifierProperties2EXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDrmFormatModifierProperties2EXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DrmFormatModifierProperties2EXT const & ) const = default; +#else + bool operator==( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( drmFormatModifier == rhs.drmFormatModifier ) && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && + ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures ); +# endif + } + + bool operator!=( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint64_t drmFormatModifier = {}; + uint32_t drmFormatModifierPlaneCount = {}; + FormatFeatureFlags2 drmFormatModifierTilingFeatures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DrmFormatModifierProperties2EXT; + }; +#endif + + // wrapper struct for struct VkDrmFormatModifierPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrmFormatModifierPropertiesEXT.html + struct DrmFormatModifierPropertiesEXT + { + using NativeType = VkDrmFormatModifierPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = {}, + uint32_t drmFormatModifierPlaneCount_ = {}, + FormatFeatureFlags drmFormatModifierTilingFeatures_ = {} ) VULKAN_HPP_NOEXCEPT + : drmFormatModifier{ drmFormatModifier_ } + , drmFormatModifierPlaneCount{ drmFormatModifierPlaneCount_ } + , drmFormatModifierTilingFeatures{ drmFormatModifierTilingFeatures_ } + { + } + + VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesEXT( DrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DrmFormatModifierPropertiesEXT( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DrmFormatModifierPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + DrmFormatModifierPropertiesEXT & operator=( DrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DrmFormatModifierPropertiesEXT & operator=( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrmFormatModifierPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDrmFormatModifierPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DrmFormatModifierPropertiesEXT const & ) const = default; +#else + bool operator==( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( drmFormatModifier == rhs.drmFormatModifier ) && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && + ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures ); +# endif + } + + bool operator!=( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint64_t drmFormatModifier = {}; + uint32_t drmFormatModifierPlaneCount = {}; + FormatFeatureFlags drmFormatModifierTilingFeatures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DrmFormatModifierPropertiesEXT; + }; +#endif + + // wrapper struct for struct VkDrmFormatModifierPropertiesList2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrmFormatModifierPropertiesList2EXT.html + struct DrmFormatModifierPropertiesList2EXT + { + using NativeType = VkDrmFormatModifierPropertiesList2EXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDrmFormatModifierPropertiesList2EXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesList2EXT( uint32_t drmFormatModifierCount_ = {}, + DrmFormatModifierProperties2EXT * pDrmFormatModifierProperties_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , drmFormatModifierCount{ drmFormatModifierCount_ } + , pDrmFormatModifierProperties{ pDrmFormatModifierProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesList2EXT( DrmFormatModifierPropertiesList2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DrmFormatModifierPropertiesList2EXT( VkDrmFormatModifierPropertiesList2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DrmFormatModifierPropertiesList2EXT( *reinterpret_cast( &rhs ) ) + { + } + + DrmFormatModifierPropertiesList2EXT & operator=( DrmFormatModifierPropertiesList2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DrmFormatModifierPropertiesList2EXT & operator=( VkDrmFormatModifierPropertiesList2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDrmFormatModifierPropertiesList2EXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrmFormatModifierPropertiesList2EXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrmFormatModifierPropertiesList2EXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDrmFormatModifierPropertiesList2EXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DrmFormatModifierPropertiesList2EXT const & ) const = default; +#else + bool operator==( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && + ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties ); +# endif + } + + bool operator!=( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDrmFormatModifierPropertiesList2EXT; + void * pNext = {}; + uint32_t drmFormatModifierCount = {}; + DrmFormatModifierProperties2EXT * pDrmFormatModifierProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DrmFormatModifierPropertiesList2EXT; + }; +#endif + + template <> + struct CppType + { + using Type = DrmFormatModifierPropertiesList2EXT; + }; + + // wrapper struct for struct VkDrmFormatModifierPropertiesListEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrmFormatModifierPropertiesListEXT.html + struct DrmFormatModifierPropertiesListEXT + { + using NativeType = VkDrmFormatModifierPropertiesListEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDrmFormatModifierPropertiesListEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = {}, + DrmFormatModifierPropertiesEXT * pDrmFormatModifierProperties_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , drmFormatModifierCount{ drmFormatModifierCount_ } + , pDrmFormatModifierProperties{ pDrmFormatModifierProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesListEXT( DrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : DrmFormatModifierPropertiesListEXT( *reinterpret_cast( &rhs ) ) + { + } + + DrmFormatModifierPropertiesListEXT & operator=( DrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DrmFormatModifierPropertiesListEXT & operator=( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkDrmFormatModifierPropertiesListEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrmFormatModifierPropertiesListEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDrmFormatModifierPropertiesListEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDrmFormatModifierPropertiesListEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DrmFormatModifierPropertiesListEXT const & ) const = default; +#else + bool operator==( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && + ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties ); +# endif + } + + bool operator!=( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT; + void * pNext = {}; + uint32_t drmFormatModifierCount = {}; + DrmFormatModifierPropertiesEXT * pDrmFormatModifierProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = DrmFormatModifierPropertiesListEXT; + }; +#endif + + template <> + struct CppType + { + using Type = DrmFormatModifierPropertiesListEXT; + }; + + // wrapper struct for struct VkEventCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEventCreateInfo.html + struct EventCreateInfo + { + using NativeType = VkEventCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eEventCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR EventCreateInfo( EventCreateFlags flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR EventCreateInfo( EventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + EventCreateInfo( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : EventCreateInfo( *reinterpret_cast( &rhs ) ) {} + + EventCreateInfo & operator=( EventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + EventCreateInfo & operator=( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 EventCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 EventCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 EventCreateInfo & setFlags( EventCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 EventCreateInfo && setFlags( EventCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkEventCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkEventCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkEventCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkEventCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( EventCreateInfo const & ) const = default; +#else + bool operator==( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eEventCreateInfo; + const void * pNext = {}; + EventCreateFlags flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = EventCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = EventCreateInfo; + }; + + // wrapper struct for struct VkPipelineLibraryCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLibraryCreateInfoKHR.html + struct PipelineLibraryCreateInfoKHR + { + using NativeType = VkPipelineLibraryCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineLibraryCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PipelineLibraryCreateInfoKHR( uint32_t libraryCount_ = {}, const Pipeline * pLibraries_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , libraryCount{ libraryCount_ } + , pLibraries{ pLibraries_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineLibraryCreateInfoKHR( PipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineLibraryCreateInfoKHR( VkPipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineLibraryCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineLibraryCreateInfoKHR( ArrayProxyNoTemporaries const & libraries_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), libraryCount( static_cast( libraries_.size() ) ), pLibraries( libraries_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineLibraryCreateInfoKHR & operator=( PipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineLibraryCreateInfoKHR & operator=( VkPipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR & setLibraryCount( uint32_t libraryCount_ ) & VULKAN_HPP_NOEXCEPT + { + libraryCount = libraryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR && setLibraryCount( uint32_t libraryCount_ ) && VULKAN_HPP_NOEXCEPT + { + libraryCount = libraryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR & setPLibraries( const Pipeline * pLibraries_ ) & VULKAN_HPP_NOEXCEPT + { + pLibraries = pLibraries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR && setPLibraries( const Pipeline * pLibraries_ ) && VULKAN_HPP_NOEXCEPT + { + pLibraries = pLibraries_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineLibraryCreateInfoKHR & setLibraries( ArrayProxyNoTemporaries const & libraries_ ) VULKAN_HPP_NOEXCEPT + { + libraryCount = static_cast( libraries_.size() ); + pLibraries = libraries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineLibraryCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineLibraryCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineLibraryCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineLibraryCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, libraryCount, pLibraries ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineLibraryCreateInfoKHR const & ) const = default; +#else + bool operator==( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( libraryCount == rhs.libraryCount ) && ( pLibraries == rhs.pLibraries ); +# endif + } + + bool operator!=( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineLibraryCreateInfoKHR; + const void * pNext = {}; + uint32_t libraryCount = {}; + const Pipeline * pLibraries = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineLibraryCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineLibraryCreateInfoKHR; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkExecutionGraphPipelineCreateInfoAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExecutionGraphPipelineCreateInfoAMDX.html + struct ExecutionGraphPipelineCreateInfoAMDX + { + using NativeType = VkExecutionGraphPipelineCreateInfoAMDX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExecutionGraphPipelineCreateInfoAMDX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExecutionGraphPipelineCreateInfoAMDX( PipelineCreateFlags flags_ = {}, + uint32_t stageCount_ = {}, + const PipelineShaderStageCreateInfo * pStages_ = {}, + const PipelineLibraryCreateInfoKHR * pLibraryInfo_ = {}, + PipelineLayout layout_ = {}, + Pipeline basePipelineHandle_ = {}, + int32_t basePipelineIndex_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , stageCount{ stageCount_ } + , pStages{ pStages_ } + , pLibraryInfo{ pLibraryInfo_ } + , layout{ layout_ } + , basePipelineHandle{ basePipelineHandle_ } + , basePipelineIndex{ basePipelineIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR ExecutionGraphPipelineCreateInfoAMDX( ExecutionGraphPipelineCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExecutionGraphPipelineCreateInfoAMDX( VkExecutionGraphPipelineCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + : ExecutionGraphPipelineCreateInfoAMDX( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ExecutionGraphPipelineCreateInfoAMDX( PipelineCreateFlags flags_, + ArrayProxyNoTemporaries const & stages_, + const PipelineLibraryCreateInfoKHR * pLibraryInfo_ = {}, + PipelineLayout layout_ = {}, + Pipeline basePipelineHandle_ = {}, + int32_t basePipelineIndex_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , stageCount( static_cast( stages_.size() ) ) + , pStages( stages_.data() ) + , pLibraryInfo( pLibraryInfo_ ) + , layout( layout_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ExecutionGraphPipelineCreateInfoAMDX & operator=( ExecutionGraphPipelineCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExecutionGraphPipelineCreateInfoAMDX & operator=( VkExecutionGraphPipelineCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setFlags( PipelineCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setFlags( PipelineCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setStageCount( uint32_t stageCount_ ) & VULKAN_HPP_NOEXCEPT + { + stageCount = stageCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setStageCount( uint32_t stageCount_ ) && VULKAN_HPP_NOEXCEPT + { + stageCount = stageCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setPStages( const PipelineShaderStageCreateInfo * pStages_ ) & VULKAN_HPP_NOEXCEPT + { + pStages = pStages_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setPStages( const PipelineShaderStageCreateInfo * pStages_ ) && VULKAN_HPP_NOEXCEPT + { + pStages = pStages_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ExecutionGraphPipelineCreateInfoAMDX & setStages( ArrayProxyNoTemporaries const & stages_ ) VULKAN_HPP_NOEXCEPT + { + stageCount = static_cast( stages_.size() ); + pStages = stages_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setPLibraryInfo( const PipelineLibraryCreateInfoKHR * pLibraryInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pLibraryInfo = pLibraryInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setPLibraryInfo( const PipelineLibraryCreateInfoKHR * pLibraryInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pLibraryInfo = pLibraryInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setBasePipelineHandle( Pipeline basePipelineHandle_ ) & VULKAN_HPP_NOEXCEPT + { + basePipelineHandle = basePipelineHandle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setBasePipelineHandle( Pipeline basePipelineHandle_ ) && VULKAN_HPP_NOEXCEPT + { + basePipelineHandle = basePipelineHandle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setBasePipelineIndex( int32_t basePipelineIndex_ ) & VULKAN_HPP_NOEXCEPT + { + basePipelineIndex = basePipelineIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setBasePipelineIndex( int32_t basePipelineIndex_ ) && VULKAN_HPP_NOEXCEPT + { + basePipelineIndex = basePipelineIndex_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExecutionGraphPipelineCreateInfoAMDX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExecutionGraphPipelineCreateInfoAMDX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExecutionGraphPipelineCreateInfoAMDX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExecutionGraphPipelineCreateInfoAMDX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, stageCount, pStages, pLibraryInfo, layout, basePipelineHandle, basePipelineIndex ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExecutionGraphPipelineCreateInfoAMDX const & ) const = default; +# else + bool operator==( ExecutionGraphPipelineCreateInfoAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && + ( pLibraryInfo == rhs.pLibraryInfo ) && ( layout == rhs.layout ) && ( basePipelineHandle == rhs.basePipelineHandle ) && + ( basePipelineIndex == rhs.basePipelineIndex ); +# endif + } + + bool operator!=( ExecutionGraphPipelineCreateInfoAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExecutionGraphPipelineCreateInfoAMDX; + const void * pNext = {}; + PipelineCreateFlags flags = {}; + uint32_t stageCount = {}; + const PipelineShaderStageCreateInfo * pStages = {}; + const PipelineLibraryCreateInfoKHR * pLibraryInfo = {}; + PipelineLayout layout = {}; + Pipeline basePipelineHandle = {}; + int32_t basePipelineIndex = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExecutionGraphPipelineCreateInfoAMDX; + }; +# endif + + template <> + struct CppType + { + using Type = ExecutionGraphPipelineCreateInfoAMDX; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkExecutionGraphPipelineScratchSizeAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExecutionGraphPipelineScratchSizeAMDX.html + struct ExecutionGraphPipelineScratchSizeAMDX + { + using NativeType = VkExecutionGraphPipelineScratchSizeAMDX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExecutionGraphPipelineScratchSizeAMDX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExecutionGraphPipelineScratchSizeAMDX( DeviceSize minSize_ = {}, + DeviceSize maxSize_ = {}, + DeviceSize sizeGranularity_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minSize{ minSize_ } + , maxSize{ maxSize_ } + , sizeGranularity{ sizeGranularity_ } + { + } + + VULKAN_HPP_CONSTEXPR ExecutionGraphPipelineScratchSizeAMDX( ExecutionGraphPipelineScratchSizeAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExecutionGraphPipelineScratchSizeAMDX( VkExecutionGraphPipelineScratchSizeAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + : ExecutionGraphPipelineScratchSizeAMDX( *reinterpret_cast( &rhs ) ) + { + } + + ExecutionGraphPipelineScratchSizeAMDX & operator=( ExecutionGraphPipelineScratchSizeAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExecutionGraphPipelineScratchSizeAMDX & operator=( VkExecutionGraphPipelineScratchSizeAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX & setMinSize( DeviceSize minSize_ ) & VULKAN_HPP_NOEXCEPT + { + minSize = minSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX && setMinSize( DeviceSize minSize_ ) && VULKAN_HPP_NOEXCEPT + { + minSize = minSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX & setMaxSize( DeviceSize maxSize_ ) & VULKAN_HPP_NOEXCEPT + { + maxSize = maxSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX && setMaxSize( DeviceSize maxSize_ ) && VULKAN_HPP_NOEXCEPT + { + maxSize = maxSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX & setSizeGranularity( DeviceSize sizeGranularity_ ) & VULKAN_HPP_NOEXCEPT + { + sizeGranularity = sizeGranularity_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX && setSizeGranularity( DeviceSize sizeGranularity_ ) && VULKAN_HPP_NOEXCEPT + { + sizeGranularity = sizeGranularity_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExecutionGraphPipelineScratchSizeAMDX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExecutionGraphPipelineScratchSizeAMDX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExecutionGraphPipelineScratchSizeAMDX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExecutionGraphPipelineScratchSizeAMDX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minSize, maxSize, sizeGranularity ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExecutionGraphPipelineScratchSizeAMDX const & ) const = default; +# else + bool operator==( ExecutionGraphPipelineScratchSizeAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSize == rhs.minSize ) && ( maxSize == rhs.maxSize ) && + ( sizeGranularity == rhs.sizeGranularity ); +# endif + } + + bool operator!=( ExecutionGraphPipelineScratchSizeAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExecutionGraphPipelineScratchSizeAMDX; + void * pNext = {}; + DeviceSize minSize = {}; + DeviceSize maxSize = {}; + DeviceSize sizeGranularity = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExecutionGraphPipelineScratchSizeAMDX; + }; +# endif + + template <> + struct CppType + { + using Type = ExecutionGraphPipelineScratchSizeAMDX; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkExportFenceCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportFenceCreateInfo.html + struct ExportFenceCreateInfo + { + using NativeType = VkExportFenceCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportFenceCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( ExternalFenceHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleTypes{ handleTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( ExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportFenceCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + ExportFenceCreateInfo & operator=( ExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportFenceCreateInfo & operator=( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportFenceCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportFenceCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportFenceCreateInfo & setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportFenceCreateInfo && setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportFenceCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportFenceCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportFenceCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportFenceCreateInfo const & ) const = default; +#else + bool operator==( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif + } + + bool operator!=( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExportFenceCreateInfo; + const void * pNext = {}; + ExternalFenceHandleTypeFlags handleTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportFenceCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ExportFenceCreateInfo; + }; + + using ExportFenceCreateInfoKHR = ExportFenceCreateInfo; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkExportFenceWin32HandleInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportFenceWin32HandleInfoKHR.html + struct ExportFenceWin32HandleInfoKHR + { + using NativeType = VkExportFenceWin32HandleInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportFenceWin32HandleInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES * pAttributes_ = {}, + DWORD dwAccess_ = {}, + LPCWSTR name_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pAttributes{ pAttributes_ } + , dwAccess{ dwAccess_ } + , name{ name_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( ExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportFenceWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ExportFenceWin32HandleInfoKHR & operator=( ExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportFenceWin32HandleInfoKHR & operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR & setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) & VULKAN_HPP_NOEXCEPT + { + pAttributes = pAttributes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR && setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) && VULKAN_HPP_NOEXCEPT + { + pAttributes = pAttributes_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR & setDwAccess( DWORD dwAccess_ ) & VULKAN_HPP_NOEXCEPT + { + dwAccess = dwAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR && setDwAccess( DWORD dwAccess_ ) && VULKAN_HPP_NOEXCEPT + { + dwAccess = dwAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT + { + name = name_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT + { + name = name_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportFenceWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportFenceWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess, name ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportFenceWin32HandleInfoKHR const & ) const = default; +# else + bool operator==( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); +# endif + } + + bool operator!=( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR; + const void * pNext = {}; + const SECURITY_ATTRIBUTES * pAttributes = {}; + DWORD dwAccess = {}; + LPCWSTR name = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportFenceWin32HandleInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = ExportFenceWin32HandleInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + // wrapper struct for struct VkExportMemoryAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMemoryAllocateInfo.html + struct ExportMemoryAllocateInfo + { + using NativeType = VkExportMemoryAllocateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryAllocateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleTypes{ handleTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( ExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMemoryAllocateInfo( *reinterpret_cast( &rhs ) ) + { + } + + ExportMemoryAllocateInfo & operator=( ExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMemoryAllocateInfo & operator=( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfo && setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryAllocateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMemoryAllocateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMemoryAllocateInfo const & ) const = default; +#else + bool operator==( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif + } + + bool operator!=( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExportMemoryAllocateInfo; + const void * pNext = {}; + ExternalMemoryHandleTypeFlags handleTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMemoryAllocateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ExportMemoryAllocateInfo; + }; + + using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo; + + // wrapper struct for struct VkExportMemoryAllocateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMemoryAllocateInfoNV.html + struct ExportMemoryAllocateInfoNV + { + using NativeType = VkExportMemoryAllocateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryAllocateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleTypes{ handleTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( ExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMemoryAllocateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ExportMemoryAllocateInfoNV & operator=( ExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMemoryAllocateInfoNV & operator=( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfoNV & setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) & VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfoNV && setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) && VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryAllocateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMemoryAllocateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMemoryAllocateInfoNV const & ) const = default; +#else + bool operator==( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif + } + + bool operator!=( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExportMemoryAllocateInfoNV; + const void * pNext = {}; + ExternalMemoryHandleTypeFlagsNV handleTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMemoryAllocateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = ExportMemoryAllocateInfoNV; + }; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkExportMemoryWin32HandleInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMemoryWin32HandleInfoKHR.html + struct ExportMemoryWin32HandleInfoKHR + { + using NativeType = VkExportMemoryWin32HandleInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryWin32HandleInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES * pAttributes_ = {}, + DWORD dwAccess_ = {}, + LPCWSTR name_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pAttributes{ pAttributes_ } + , dwAccess{ dwAccess_ } + , name{ name_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( ExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMemoryWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ExportMemoryWin32HandleInfoKHR & operator=( ExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMemoryWin32HandleInfoKHR & operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR & setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) & VULKAN_HPP_NOEXCEPT + { + pAttributes = pAttributes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR && setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) && VULKAN_HPP_NOEXCEPT + { + pAttributes = pAttributes_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR & setDwAccess( DWORD dwAccess_ ) & VULKAN_HPP_NOEXCEPT + { + dwAccess = dwAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR && setDwAccess( DWORD dwAccess_ ) && VULKAN_HPP_NOEXCEPT + { + dwAccess = dwAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT + { + name = name_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT + { + name = name_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMemoryWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess, name ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMemoryWin32HandleInfoKHR const & ) const = default; +# else + bool operator==( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); +# endif + } + + bool operator!=( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR; + const void * pNext = {}; + const SECURITY_ATTRIBUTES * pAttributes = {}; + DWORD dwAccess = {}; + LPCWSTR name = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMemoryWin32HandleInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = ExportMemoryWin32HandleInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkExportMemoryWin32HandleInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMemoryWin32HandleInfoNV.html + struct ExportMemoryWin32HandleInfoNV + { + using NativeType = VkExportMemoryWin32HandleInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryWin32HandleInfoNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES * pAttributes_ = {}, DWORD dwAccess_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pAttributes{ pAttributes_ } + , dwAccess{ dwAccess_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( ExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMemoryWin32HandleInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ExportMemoryWin32HandleInfoNV & operator=( ExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMemoryWin32HandleInfoNV & operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV & setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) & VULKAN_HPP_NOEXCEPT + { + pAttributes = pAttributes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV && setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) && VULKAN_HPP_NOEXCEPT + { + pAttributes = pAttributes_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV & setDwAccess( DWORD dwAccess_ ) & VULKAN_HPP_NOEXCEPT + { + dwAccess = dwAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV && setDwAccess( DWORD dwAccess_ ) && VULKAN_HPP_NOEXCEPT + { + dwAccess = dwAccess_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMemoryWin32HandleInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMemoryWin32HandleInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMemoryWin32HandleInfoNV const & ) const = default; +# else + bool operator==( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess ); +# endif + } + + bool operator!=( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV; + const void * pNext = {}; + const SECURITY_ATTRIBUTES * pAttributes = {}; + DWORD dwAccess = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMemoryWin32HandleInfoNV; + }; +# endif + + template <> + struct CppType + { + using Type = ExportMemoryWin32HandleInfoNV; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkExportMetalBufferInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalBufferInfoEXT.html + struct ExportMetalBufferInfoEXT + { + using NativeType = VkExportMetalBufferInfoEXT; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalBufferInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportMetalBufferInfoEXT( DeviceMemory memory_ = {}, MTLBuffer_id mtlBuffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + , mtlBuffer{ mtlBuffer_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportMetalBufferInfoEXT( ExportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMetalBufferInfoEXT( VkExportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMetalBufferInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ExportMetalBufferInfoEXT & operator=( ExportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMetalBufferInfoEXT & operator=( VkExportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT & setMtlBuffer( MTLBuffer_id mtlBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + mtlBuffer = mtlBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT && setMtlBuffer( MTLBuffer_id mtlBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + mtlBuffer = mtlBuffer_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMetalBufferInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalBufferInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalBufferInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMetalBufferInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, mtlBuffer ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMetalBufferInfoEXT const & ) const = default; +# else + bool operator==( ExportMetalBufferInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( mtlBuffer == rhs.mtlBuffer ); +# endif + } + + bool operator!=( ExportMetalBufferInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportMetalBufferInfoEXT; + const void * pNext = {}; + DeviceMemory memory = {}; + MTLBuffer_id mtlBuffer = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMetalBufferInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ExportMetalBufferInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkExportMetalCommandQueueInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalCommandQueueInfoEXT.html + struct ExportMetalCommandQueueInfoEXT + { + using NativeType = VkExportMetalCommandQueueInfoEXT; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalCommandQueueInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + ExportMetalCommandQueueInfoEXT( Queue queue_ = {}, MTLCommandQueue_id mtlCommandQueue_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , queue{ queue_ } + , mtlCommandQueue{ mtlCommandQueue_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportMetalCommandQueueInfoEXT( ExportMetalCommandQueueInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMetalCommandQueueInfoEXT( VkExportMetalCommandQueueInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMetalCommandQueueInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ExportMetalCommandQueueInfoEXT & operator=( ExportMetalCommandQueueInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMetalCommandQueueInfoEXT & operator=( VkExportMetalCommandQueueInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT & setQueue( Queue queue_ ) & VULKAN_HPP_NOEXCEPT + { + queue = queue_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT && setQueue( Queue queue_ ) && VULKAN_HPP_NOEXCEPT + { + queue = queue_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT & setMtlCommandQueue( MTLCommandQueue_id mtlCommandQueue_ ) & VULKAN_HPP_NOEXCEPT + { + mtlCommandQueue = mtlCommandQueue_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT && setMtlCommandQueue( MTLCommandQueue_id mtlCommandQueue_ ) && VULKAN_HPP_NOEXCEPT + { + mtlCommandQueue = mtlCommandQueue_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMetalCommandQueueInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalCommandQueueInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalCommandQueueInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMetalCommandQueueInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queue, mtlCommandQueue ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMetalCommandQueueInfoEXT const & ) const = default; +# else + bool operator==( ExportMetalCommandQueueInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queue == rhs.queue ) && ( mtlCommandQueue == rhs.mtlCommandQueue ); +# endif + } + + bool operator!=( ExportMetalCommandQueueInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportMetalCommandQueueInfoEXT; + const void * pNext = {}; + Queue queue = {}; + MTLCommandQueue_id mtlCommandQueue = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMetalCommandQueueInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ExportMetalCommandQueueInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkExportMetalDeviceInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalDeviceInfoEXT.html + struct ExportMetalDeviceInfoEXT + { + using NativeType = VkExportMetalDeviceInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalDeviceInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportMetalDeviceInfoEXT( MTLDevice_id mtlDevice_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , mtlDevice{ mtlDevice_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportMetalDeviceInfoEXT( ExportMetalDeviceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMetalDeviceInfoEXT( VkExportMetalDeviceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMetalDeviceInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ExportMetalDeviceInfoEXT & operator=( ExportMetalDeviceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMetalDeviceInfoEXT & operator=( VkExportMetalDeviceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMetalDeviceInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalDeviceInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalDeviceInfoEXT & setMtlDevice( MTLDevice_id mtlDevice_ ) & VULKAN_HPP_NOEXCEPT + { + mtlDevice = mtlDevice_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalDeviceInfoEXT && setMtlDevice( MTLDevice_id mtlDevice_ ) && VULKAN_HPP_NOEXCEPT + { + mtlDevice = mtlDevice_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMetalDeviceInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalDeviceInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalDeviceInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMetalDeviceInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mtlDevice ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMetalDeviceInfoEXT const & ) const = default; +# else + bool operator==( ExportMetalDeviceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mtlDevice == rhs.mtlDevice ); +# endif + } + + bool operator!=( ExportMetalDeviceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportMetalDeviceInfoEXT; + const void * pNext = {}; + MTLDevice_id mtlDevice = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMetalDeviceInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ExportMetalDeviceInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkExportMetalIOSurfaceInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalIOSurfaceInfoEXT.html + struct ExportMetalIOSurfaceInfoEXT + { + using NativeType = VkExportMetalIOSurfaceInfoEXT; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalIoSurfaceInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportMetalIOSurfaceInfoEXT( Image image_ = {}, IOSurfaceRef ioSurface_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image{ image_ } + , ioSurface{ ioSurface_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportMetalIOSurfaceInfoEXT( ExportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMetalIOSurfaceInfoEXT( VkExportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMetalIOSurfaceInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ExportMetalIOSurfaceInfoEXT & operator=( ExportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMetalIOSurfaceInfoEXT & operator=( VkExportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT & setIoSurface( IOSurfaceRef ioSurface_ ) & VULKAN_HPP_NOEXCEPT + { + ioSurface = ioSurface_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT && setIoSurface( IOSurfaceRef ioSurface_ ) && VULKAN_HPP_NOEXCEPT + { + ioSurface = ioSurface_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMetalIOSurfaceInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalIOSurfaceInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalIOSurfaceInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMetalIOSurfaceInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, ioSurface ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMetalIOSurfaceInfoEXT const & ) const = default; +# else + bool operator==( ExportMetalIOSurfaceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( ioSurface == rhs.ioSurface ); +# endif + } + + bool operator!=( ExportMetalIOSurfaceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportMetalIoSurfaceInfoEXT; + const void * pNext = {}; + Image image = {}; + IOSurfaceRef ioSurface = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMetalIOSurfaceInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ExportMetalIOSurfaceInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkExportMetalObjectCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalObjectCreateInfoEXT.html + struct ExportMetalObjectCreateInfoEXT + { + using NativeType = VkExportMetalObjectCreateInfoEXT; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalObjectCreateInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportMetalObjectCreateInfoEXT( ExportMetalObjectTypeFlagBitsEXT exportObjectType_ = ExportMetalObjectTypeFlagBitsEXT::eMetalDevice, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , exportObjectType{ exportObjectType_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportMetalObjectCreateInfoEXT( ExportMetalObjectCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMetalObjectCreateInfoEXT( VkExportMetalObjectCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMetalObjectCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ExportMetalObjectCreateInfoEXT & operator=( ExportMetalObjectCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMetalObjectCreateInfoEXT & operator=( VkExportMetalObjectCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectCreateInfoEXT & setExportObjectType( ExportMetalObjectTypeFlagBitsEXT exportObjectType_ ) & VULKAN_HPP_NOEXCEPT + { + exportObjectType = exportObjectType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectCreateInfoEXT && setExportObjectType( ExportMetalObjectTypeFlagBitsEXT exportObjectType_ ) && VULKAN_HPP_NOEXCEPT + { + exportObjectType = exportObjectType_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMetalObjectCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalObjectCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalObjectCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMetalObjectCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exportObjectType ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMetalObjectCreateInfoEXT const & ) const = default; +# else + bool operator==( ExportMetalObjectCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exportObjectType == rhs.exportObjectType ); +# endif + } + + bool operator!=( ExportMetalObjectCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportMetalObjectCreateInfoEXT; + const void * pNext = {}; + ExportMetalObjectTypeFlagBitsEXT exportObjectType = ExportMetalObjectTypeFlagBitsEXT::eMetalDevice; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMetalObjectCreateInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ExportMetalObjectCreateInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkExportMetalObjectsInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalObjectsInfoEXT.html + struct ExportMetalObjectsInfoEXT + { + using NativeType = VkExportMetalObjectsInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalObjectsInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportMetalObjectsInfoEXT( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} + + VULKAN_HPP_CONSTEXPR ExportMetalObjectsInfoEXT( ExportMetalObjectsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMetalObjectsInfoEXT( VkExportMetalObjectsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMetalObjectsInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ExportMetalObjectsInfoEXT & operator=( ExportMetalObjectsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMetalObjectsInfoEXT & operator=( VkExportMetalObjectsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMetalObjectsInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalObjectsInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalObjectsInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMetalObjectsInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMetalObjectsInfoEXT const & ) const = default; +# else + bool operator==( ExportMetalObjectsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( ExportMetalObjectsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportMetalObjectsInfoEXT; + const void * pNext = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMetalObjectsInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ExportMetalObjectsInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkExportMetalSharedEventInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalSharedEventInfoEXT.html + struct ExportMetalSharedEventInfoEXT + { + using NativeType = VkExportMetalSharedEventInfoEXT; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalSharedEventInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportMetalSharedEventInfoEXT( Semaphore semaphore_ = {}, + Event event_ = {}, + MTLSharedEvent_id mtlSharedEvent_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , semaphore{ semaphore_ } + , event{ event_ } + , mtlSharedEvent{ mtlSharedEvent_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportMetalSharedEventInfoEXT( ExportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMetalSharedEventInfoEXT( VkExportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMetalSharedEventInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ExportMetalSharedEventInfoEXT & operator=( ExportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMetalSharedEventInfoEXT & operator=( VkExportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT & setEvent( Event event_ ) & VULKAN_HPP_NOEXCEPT + { + event = event_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT && setEvent( Event event_ ) && VULKAN_HPP_NOEXCEPT + { + event = event_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT & setMtlSharedEvent( MTLSharedEvent_id mtlSharedEvent_ ) & VULKAN_HPP_NOEXCEPT + { + mtlSharedEvent = mtlSharedEvent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT && setMtlSharedEvent( MTLSharedEvent_id mtlSharedEvent_ ) && VULKAN_HPP_NOEXCEPT + { + mtlSharedEvent = mtlSharedEvent_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMetalSharedEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalSharedEventInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalSharedEventInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMetalSharedEventInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, event, mtlSharedEvent ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMetalSharedEventInfoEXT const & ) const = default; +# else + bool operator==( ExportMetalSharedEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( event == rhs.event ) && + ( mtlSharedEvent == rhs.mtlSharedEvent ); +# endif + } + + bool operator!=( ExportMetalSharedEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportMetalSharedEventInfoEXT; + const void * pNext = {}; + Semaphore semaphore = {}; + Event event = {}; + MTLSharedEvent_id mtlSharedEvent = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMetalSharedEventInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ExportMetalSharedEventInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkExportMetalTextureInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalTextureInfoEXT.html + struct ExportMetalTextureInfoEXT + { + using NativeType = VkExportMetalTextureInfoEXT; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalTextureInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportMetalTextureInfoEXT( Image image_ = {}, + ImageView imageView_ = {}, + BufferView bufferView_ = {}, + ImageAspectFlagBits plane_ = ImageAspectFlagBits::eColor, + MTLTexture_id mtlTexture_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image{ image_ } + , imageView{ imageView_ } + , bufferView{ bufferView_ } + , plane{ plane_ } + , mtlTexture{ mtlTexture_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportMetalTextureInfoEXT( ExportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportMetalTextureInfoEXT( VkExportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportMetalTextureInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ExportMetalTextureInfoEXT & operator=( ExportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportMetalTextureInfoEXT & operator=( VkExportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setBufferView( BufferView bufferView_ ) & VULKAN_HPP_NOEXCEPT + { + bufferView = bufferView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setBufferView( BufferView bufferView_ ) && VULKAN_HPP_NOEXCEPT + { + bufferView = bufferView_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setPlane( ImageAspectFlagBits plane_ ) & VULKAN_HPP_NOEXCEPT + { + plane = plane_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setPlane( ImageAspectFlagBits plane_ ) && VULKAN_HPP_NOEXCEPT + { + plane = plane_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setMtlTexture( MTLTexture_id mtlTexture_ ) & VULKAN_HPP_NOEXCEPT + { + mtlTexture = mtlTexture_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setMtlTexture( MTLTexture_id mtlTexture_ ) && VULKAN_HPP_NOEXCEPT + { + mtlTexture = mtlTexture_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportMetalTextureInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalTextureInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportMetalTextureInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportMetalTextureInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, imageView, bufferView, plane, mtlTexture ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportMetalTextureInfoEXT const & ) const = default; +# else + bool operator==( ExportMetalTextureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( imageView == rhs.imageView ) && ( bufferView == rhs.bufferView ) && + ( plane == rhs.plane ) && ( mtlTexture == rhs.mtlTexture ); +# endif + } + + bool operator!=( ExportMetalTextureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportMetalTextureInfoEXT; + const void * pNext = {}; + Image image = {}; + ImageView imageView = {}; + BufferView bufferView = {}; + ImageAspectFlagBits plane = ImageAspectFlagBits::eColor; + MTLTexture_id mtlTexture = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportMetalTextureInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ExportMetalTextureInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + // wrapper struct for struct VkExportSemaphoreCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportSemaphoreCreateInfo.html + struct ExportSemaphoreCreateInfo + { + using NativeType = VkExportSemaphoreCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportSemaphoreCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( ExternalSemaphoreHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleTypes{ handleTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( ExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportSemaphoreCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + ExportSemaphoreCreateInfo & operator=( ExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportSemaphoreCreateInfo & operator=( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreCreateInfo & setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreCreateInfo && setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportSemaphoreCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportSemaphoreCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportSemaphoreCreateInfo const & ) const = default; +#else + bool operator==( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif + } + + bool operator!=( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExportSemaphoreCreateInfo; + const void * pNext = {}; + ExternalSemaphoreHandleTypeFlags handleTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportSemaphoreCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ExportSemaphoreCreateInfo; + }; + + using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkExportSemaphoreWin32HandleInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportSemaphoreWin32HandleInfoKHR.html + struct ExportSemaphoreWin32HandleInfoKHR + { + using NativeType = VkExportSemaphoreWin32HandleInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportSemaphoreWin32HandleInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES * pAttributes_ = {}, + DWORD dwAccess_ = {}, + LPCWSTR name_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pAttributes{ pAttributes_ } + , dwAccess{ dwAccess_ } + , name{ name_ } + { + } + + VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( ExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ExportSemaphoreWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ExportSemaphoreWin32HandleInfoKHR & operator=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExportSemaphoreWin32HandleInfoKHR & operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR & setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) & VULKAN_HPP_NOEXCEPT + { + pAttributes = pAttributes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR && setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) && VULKAN_HPP_NOEXCEPT + { + pAttributes = pAttributes_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR & setDwAccess( DWORD dwAccess_ ) & VULKAN_HPP_NOEXCEPT + { + dwAccess = dwAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR && setDwAccess( DWORD dwAccess_ ) && VULKAN_HPP_NOEXCEPT + { + dwAccess = dwAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT + { + name = name_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT + { + name = name_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExportSemaphoreWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExportSemaphoreWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pAttributes, dwAccess, name ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExportSemaphoreWin32HandleInfoKHR const & ) const = default; +# else + bool operator==( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); +# endif + } + + bool operator!=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR; + const void * pNext = {}; + const SECURITY_ATTRIBUTES * pAttributes = {}; + DWORD dwAccess = {}; + LPCWSTR name = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExportSemaphoreWin32HandleInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = ExportSemaphoreWin32HandleInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + // wrapper struct for struct VkExtensionProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExtensionProperties.html + struct ExtensionProperties + { + using NativeType = VkExtensionProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 ExtensionProperties( std::array const & extensionName_ = {}, + uint32_t specVersion_ = {} ) VULKAN_HPP_NOEXCEPT + : extensionName{ extensionName_ } + , specVersion{ specVersion_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 ExtensionProperties( ExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExtensionProperties( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT : ExtensionProperties( *reinterpret_cast( &rhs ) ) + { + } + + ExtensionProperties & operator=( ExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExtensionProperties & operator=( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkExtensionProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExtensionProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExtensionProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExtensionProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( extensionName, specVersion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = strcmp( extensionName, rhs.extensionName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = specVersion <=> rhs.specVersion; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( strcmp( extensionName, rhs.extensionName ) == 0 ) && ( specVersion == rhs.specVersion ); + } + + bool operator!=( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + ArrayWrapper1D extensionName = {}; + uint32_t specVersion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExtensionProperties; + }; +#endif + + // wrapper struct for struct VkExternalMemoryProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryProperties.html + struct ExternalMemoryProperties + { + using NativeType = VkExternalMemoryProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalMemoryProperties( ExternalMemoryFeatureFlags externalMemoryFeatures_ = {}, + ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes_ = {}, + ExternalMemoryHandleTypeFlags compatibleHandleTypes_ = {} ) VULKAN_HPP_NOEXCEPT + : externalMemoryFeatures{ externalMemoryFeatures_ } + , exportFromImportedHandleTypes{ exportFromImportedHandleTypes_ } + , compatibleHandleTypes{ compatibleHandleTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalMemoryProperties( ExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalMemoryProperties( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalMemoryProperties( *reinterpret_cast( &rhs ) ) + { + } + + ExternalMemoryProperties & operator=( ExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalMemoryProperties & operator=( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkExternalMemoryProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalMemoryProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalMemoryProperties const & ) const = default; +#else + bool operator==( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && + ( compatibleHandleTypes == rhs.compatibleHandleTypes ); +# endif + } + + bool operator!=( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ExternalMemoryFeatureFlags externalMemoryFeatures = {}; + ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes = {}; + ExternalMemoryHandleTypeFlags compatibleHandleTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalMemoryProperties; + }; +#endif + using ExternalMemoryPropertiesKHR = ExternalMemoryProperties; + + // wrapper struct for struct VkExternalBufferProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalBufferProperties.html + struct ExternalBufferProperties + { + using NativeType = VkExternalBufferProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalBufferProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalBufferProperties( ExternalMemoryProperties externalMemoryProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , externalMemoryProperties{ externalMemoryProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalBufferProperties( ExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalBufferProperties( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalBufferProperties( *reinterpret_cast( &rhs ) ) + { + } + + ExternalBufferProperties & operator=( ExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalBufferProperties & operator=( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkExternalBufferProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalBufferProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalBufferProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalBufferProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalMemoryProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalBufferProperties const & ) const = default; +#else + bool operator==( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryProperties == rhs.externalMemoryProperties ); +# endif + } + + bool operator!=( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalBufferProperties; + void * pNext = {}; + ExternalMemoryProperties externalMemoryProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalBufferProperties; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalBufferProperties; + }; + + using ExternalBufferPropertiesKHR = ExternalBufferProperties; + + // wrapper struct for struct VkExternalComputeQueueCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueCreateInfoNV.html + struct ExternalComputeQueueCreateInfoNV + { + using NativeType = VkExternalComputeQueueCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalComputeQueueCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalComputeQueueCreateInfoNV( Queue preferredQueue_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , preferredQueue{ preferredQueue_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalComputeQueueCreateInfoNV( ExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalComputeQueueCreateInfoNV( VkExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalComputeQueueCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ExternalComputeQueueCreateInfoNV & operator=( ExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalComputeQueueCreateInfoNV & operator=( VkExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueCreateInfoNV & setPreferredQueue( Queue preferredQueue_ ) & VULKAN_HPP_NOEXCEPT + { + preferredQueue = preferredQueue_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueCreateInfoNV && setPreferredQueue( Queue preferredQueue_ ) && VULKAN_HPP_NOEXCEPT + { + preferredQueue = preferredQueue_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalComputeQueueCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalComputeQueueCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, preferredQueue ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalComputeQueueCreateInfoNV const & ) const = default; +#else + bool operator==( ExternalComputeQueueCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredQueue == rhs.preferredQueue ); +# endif + } + + bool operator!=( ExternalComputeQueueCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalComputeQueueCreateInfoNV; + const void * pNext = {}; + Queue preferredQueue = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalComputeQueueCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalComputeQueueCreateInfoNV; + }; + + // wrapper struct for struct VkExternalComputeQueueDataParamsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueDataParamsNV.html + struct ExternalComputeQueueDataParamsNV + { + using NativeType = VkExternalComputeQueueDataParamsNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalComputeQueueDataParamsNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalComputeQueueDataParamsNV( uint32_t deviceIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceIndex{ deviceIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalComputeQueueDataParamsNV( ExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalComputeQueueDataParamsNV( VkExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalComputeQueueDataParamsNV( *reinterpret_cast( &rhs ) ) + { + } + + ExternalComputeQueueDataParamsNV & operator=( ExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalComputeQueueDataParamsNV & operator=( VkExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDataParamsNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDataParamsNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDataParamsNV & setDeviceIndex( uint32_t deviceIndex_ ) & VULKAN_HPP_NOEXCEPT + { + deviceIndex = deviceIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDataParamsNV && setDeviceIndex( uint32_t deviceIndex_ ) && VULKAN_HPP_NOEXCEPT + { + deviceIndex = deviceIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalComputeQueueDataParamsNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDataParamsNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDataParamsNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDataParamsNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalComputeQueueDataParamsNV const & ) const = default; +#else + bool operator==( ExternalComputeQueueDataParamsNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndex == rhs.deviceIndex ); +# endif + } + + bool operator!=( ExternalComputeQueueDataParamsNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalComputeQueueDataParamsNV; + const void * pNext = {}; + uint32_t deviceIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalComputeQueueDataParamsNV; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalComputeQueueDataParamsNV; + }; + + // wrapper struct for struct VkExternalComputeQueueDeviceCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueDeviceCreateInfoNV.html + struct ExternalComputeQueueDeviceCreateInfoNV + { + using NativeType = VkExternalComputeQueueDeviceCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalComputeQueueDeviceCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalComputeQueueDeviceCreateInfoNV( uint32_t reservedExternalQueues_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , reservedExternalQueues{ reservedExternalQueues_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalComputeQueueDeviceCreateInfoNV( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalComputeQueueDeviceCreateInfoNV( VkExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalComputeQueueDeviceCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ExternalComputeQueueDeviceCreateInfoNV & operator=( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalComputeQueueDeviceCreateInfoNV & operator=( VkExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDeviceCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDeviceCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDeviceCreateInfoNV & setReservedExternalQueues( uint32_t reservedExternalQueues_ ) & VULKAN_HPP_NOEXCEPT + { + reservedExternalQueues = reservedExternalQueues_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDeviceCreateInfoNV && setReservedExternalQueues( uint32_t reservedExternalQueues_ ) && VULKAN_HPP_NOEXCEPT + { + reservedExternalQueues = reservedExternalQueues_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalComputeQueueDeviceCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDeviceCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDeviceCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDeviceCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, reservedExternalQueues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalComputeQueueDeviceCreateInfoNV const & ) const = default; +#else + bool operator==( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reservedExternalQueues == rhs.reservedExternalQueues ); +# endif + } + + bool operator!=( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalComputeQueueDeviceCreateInfoNV; + const void * pNext = {}; + uint32_t reservedExternalQueues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalComputeQueueDeviceCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalComputeQueueDeviceCreateInfoNV; + }; + + // wrapper struct for struct VkExternalFenceProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceProperties.html + struct ExternalFenceProperties + { + using NativeType = VkExternalFenceProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFenceProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalFenceProperties( ExternalFenceHandleTypeFlags exportFromImportedHandleTypes_ = {}, + ExternalFenceHandleTypeFlags compatibleHandleTypes_ = {}, + ExternalFenceFeatureFlags externalFenceFeatures_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , exportFromImportedHandleTypes{ exportFromImportedHandleTypes_ } + , compatibleHandleTypes{ compatibleHandleTypes_ } + , externalFenceFeatures{ externalFenceFeatures_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalFenceProperties( ExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalFenceProperties( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalFenceProperties( *reinterpret_cast( &rhs ) ) + { + } + + ExternalFenceProperties & operator=( ExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalFenceProperties & operator=( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkExternalFenceProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalFenceProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalFenceProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalFenceProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalFenceFeatures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalFenceProperties const & ) const = default; +#else + bool operator==( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && + ( compatibleHandleTypes == rhs.compatibleHandleTypes ) && ( externalFenceFeatures == rhs.externalFenceFeatures ); +# endif + } + + bool operator!=( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalFenceProperties; + void * pNext = {}; + ExternalFenceHandleTypeFlags exportFromImportedHandleTypes = {}; + ExternalFenceHandleTypeFlags compatibleHandleTypes = {}; + ExternalFenceFeatureFlags externalFenceFeatures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalFenceProperties; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalFenceProperties; + }; + + using ExternalFencePropertiesKHR = ExternalFenceProperties; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + // wrapper struct for struct VkExternalFormatANDROID, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFormatANDROID.html + struct ExternalFormatANDROID + { + using NativeType = VkExternalFormatANDROID; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFormatANDROID; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , externalFormat{ externalFormat_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( ExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalFormatANDROID( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalFormatANDROID( *reinterpret_cast( &rhs ) ) + { + } + + ExternalFormatANDROID & operator=( ExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalFormatANDROID & operator=( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalFormatANDROID & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalFormatANDROID && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalFormatANDROID & setExternalFormat( uint64_t externalFormat_ ) & VULKAN_HPP_NOEXCEPT + { + externalFormat = externalFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalFormatANDROID && setExternalFormat( uint64_t externalFormat_ ) && VULKAN_HPP_NOEXCEPT + { + externalFormat = externalFormat_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalFormatANDROID const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalFormatANDROID &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalFormatANDROID const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalFormatANDROID *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalFormat ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalFormatANDROID const & ) const = default; +# else + bool operator==( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat ); +# endif + } + + bool operator!=( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExternalFormatANDROID; + void * pNext = {}; + uint64_t externalFormat = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalFormatANDROID; + }; +# endif + + template <> + struct CppType + { + using Type = ExternalFormatANDROID; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_OHOS ) + // wrapper struct for struct VkExternalFormatOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFormatOHOS.html + struct ExternalFormatOHOS + { + using NativeType = VkExternalFormatOHOS; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFormatOHOS; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalFormatOHOS( uint64_t externalFormat_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , externalFormat{ externalFormat_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalFormatOHOS( ExternalFormatOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalFormatOHOS( VkExternalFormatOHOS const & rhs ) VULKAN_HPP_NOEXCEPT : ExternalFormatOHOS( *reinterpret_cast( &rhs ) ) {} + + ExternalFormatOHOS & operator=( ExternalFormatOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalFormatOHOS & operator=( VkExternalFormatOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalFormatOHOS & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalFormatOHOS && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalFormatOHOS & setExternalFormat( uint64_t externalFormat_ ) & VULKAN_HPP_NOEXCEPT + { + externalFormat = externalFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalFormatOHOS && setExternalFormat( uint64_t externalFormat_ ) && VULKAN_HPP_NOEXCEPT + { + externalFormat = externalFormat_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalFormatOHOS const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalFormatOHOS &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalFormatOHOS const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalFormatOHOS *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalFormat ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalFormatOHOS const & ) const = default; +# else + bool operator==( ExternalFormatOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat ); +# endif + } + + bool operator!=( ExternalFormatOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExternalFormatOHOS; + void * pNext = {}; + uint64_t externalFormat = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalFormatOHOS; + }; +# endif + + template <> + struct CppType + { + using Type = ExternalFormatOHOS; + }; +#endif /*VK_USE_PLATFORM_OHOS*/ + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + // wrapper struct for struct VkExternalFormatQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFormatQNX.html + struct ExternalFormatQNX + { + using NativeType = VkExternalFormatQNX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFormatQNX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalFormatQNX( uint64_t externalFormat_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , externalFormat{ externalFormat_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalFormatQNX( ExternalFormatQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalFormatQNX( VkExternalFormatQNX const & rhs ) VULKAN_HPP_NOEXCEPT : ExternalFormatQNX( *reinterpret_cast( &rhs ) ) {} + + ExternalFormatQNX & operator=( ExternalFormatQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalFormatQNX & operator=( VkExternalFormatQNX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalFormatQNX & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalFormatQNX && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalFormatQNX & setExternalFormat( uint64_t externalFormat_ ) & VULKAN_HPP_NOEXCEPT + { + externalFormat = externalFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalFormatQNX && setExternalFormat( uint64_t externalFormat_ ) && VULKAN_HPP_NOEXCEPT + { + externalFormat = externalFormat_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalFormatQNX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalFormatQNX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalFormatQNX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalFormatQNX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalFormat ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalFormatQNX const & ) const = default; +# else + bool operator==( ExternalFormatQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat ); +# endif + } + + bool operator!=( ExternalFormatQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eExternalFormatQNX; + void * pNext = {}; + uint64_t externalFormat = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalFormatQNX; + }; +# endif + + template <> + struct CppType + { + using Type = ExternalFormatQNX; + }; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + // wrapper struct for struct VkExternalImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalImageFormatProperties.html + struct ExternalImageFormatProperties + { + using NativeType = VkExternalImageFormatProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalImageFormatProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalImageFormatProperties( ExternalMemoryProperties externalMemoryProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , externalMemoryProperties{ externalMemoryProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalImageFormatProperties( ExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalImageFormatProperties( *reinterpret_cast( &rhs ) ) + { + } + + ExternalImageFormatProperties & operator=( ExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalImageFormatProperties & operator=( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkExternalImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalImageFormatProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalImageFormatProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalImageFormatProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalMemoryProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalImageFormatProperties const & ) const = default; +#else + bool operator==( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryProperties == rhs.externalMemoryProperties ); +# endif + } + + bool operator!=( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalImageFormatProperties; + void * pNext = {}; + ExternalMemoryProperties externalMemoryProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalImageFormatProperties; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalImageFormatProperties; + }; + + using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties; + + // wrapper struct for struct VkImageFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatProperties.html + struct ImageFormatProperties + { + using NativeType = VkImageFormatProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageFormatProperties( Extent3D maxExtent_ = {}, + uint32_t maxMipLevels_ = {}, + uint32_t maxArrayLayers_ = {}, + SampleCountFlags sampleCounts_ = {}, + DeviceSize maxResourceSize_ = {} ) VULKAN_HPP_NOEXCEPT + : maxExtent{ maxExtent_ } + , maxMipLevels{ maxMipLevels_ } + , maxArrayLayers{ maxArrayLayers_ } + , sampleCounts{ sampleCounts_ } + , maxResourceSize{ maxResourceSize_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageFormatProperties( ImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageFormatProperties( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageFormatProperties( *reinterpret_cast( &rhs ) ) + { + } + + ImageFormatProperties & operator=( ImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageFormatProperties & operator=( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageFormatProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageFormatProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageFormatProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( maxExtent, maxMipLevels, maxArrayLayers, sampleCounts, maxResourceSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageFormatProperties const & ) const = default; +#else + bool operator==( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( maxExtent == rhs.maxExtent ) && ( maxMipLevels == rhs.maxMipLevels ) && ( maxArrayLayers == rhs.maxArrayLayers ) && + ( sampleCounts == rhs.sampleCounts ) && ( maxResourceSize == rhs.maxResourceSize ); +# endif + } + + bool operator!=( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Extent3D maxExtent = {}; + uint32_t maxMipLevels = {}; + uint32_t maxArrayLayers = {}; + SampleCountFlags sampleCounts = {}; + DeviceSize maxResourceSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageFormatProperties; + }; +#endif + + // wrapper struct for struct VkExternalImageFormatPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalImageFormatPropertiesNV.html + struct ExternalImageFormatPropertiesNV + { + using NativeType = VkExternalImageFormatPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalImageFormatPropertiesNV( ImageFormatProperties imageFormatProperties_ = {}, + ExternalMemoryFeatureFlagsNV externalMemoryFeatures_ = {}, + ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes_ = {}, + ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes_ = {} ) VULKAN_HPP_NOEXCEPT + : imageFormatProperties{ imageFormatProperties_ } + , externalMemoryFeatures{ externalMemoryFeatures_ } + , exportFromImportedHandleTypes{ exportFromImportedHandleTypes_ } + , compatibleHandleTypes{ compatibleHandleTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalImageFormatPropertiesNV( ExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalImageFormatPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + ExternalImageFormatPropertiesNV & operator=( ExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalImageFormatPropertiesNV & operator=( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkExternalImageFormatPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalImageFormatPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalImageFormatPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalImageFormatPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( imageFormatProperties, externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalImageFormatPropertiesNV const & ) const = default; +#else + bool operator==( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( imageFormatProperties == rhs.imageFormatProperties ) && ( externalMemoryFeatures == rhs.externalMemoryFeatures ) && + ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); +# endif + } + + bool operator!=( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ImageFormatProperties imageFormatProperties = {}; + ExternalMemoryFeatureFlagsNV externalMemoryFeatures = {}; + ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes = {}; + ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalImageFormatPropertiesNV; + }; +#endif + + // wrapper struct for struct VkExternalMemoryAcquireUnmodifiedEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryAcquireUnmodifiedEXT.html + struct ExternalMemoryAcquireUnmodifiedEXT + { + using NativeType = VkExternalMemoryAcquireUnmodifiedEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryAcquireUnmodifiedEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalMemoryAcquireUnmodifiedEXT( Bool32 acquireUnmodifiedMemory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , acquireUnmodifiedMemory{ acquireUnmodifiedMemory_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalMemoryAcquireUnmodifiedEXT( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalMemoryAcquireUnmodifiedEXT( VkExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalMemoryAcquireUnmodifiedEXT( *reinterpret_cast( &rhs ) ) + { + } + + ExternalMemoryAcquireUnmodifiedEXT & operator=( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalMemoryAcquireUnmodifiedEXT & operator=( VkExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT & setAcquireUnmodifiedMemory( Bool32 acquireUnmodifiedMemory_ ) & VULKAN_HPP_NOEXCEPT + { + acquireUnmodifiedMemory = acquireUnmodifiedMemory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT && setAcquireUnmodifiedMemory( Bool32 acquireUnmodifiedMemory_ ) && VULKAN_HPP_NOEXCEPT + { + acquireUnmodifiedMemory = acquireUnmodifiedMemory_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalMemoryAcquireUnmodifiedEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryAcquireUnmodifiedEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryAcquireUnmodifiedEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalMemoryAcquireUnmodifiedEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, acquireUnmodifiedMemory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalMemoryAcquireUnmodifiedEXT const & ) const = default; +#else + bool operator==( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireUnmodifiedMemory == rhs.acquireUnmodifiedMemory ); +# endif + } + + bool operator!=( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalMemoryAcquireUnmodifiedEXT; + const void * pNext = {}; + Bool32 acquireUnmodifiedMemory = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalMemoryAcquireUnmodifiedEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalMemoryAcquireUnmodifiedEXT; + }; + + // wrapper struct for struct VkExternalMemoryBufferCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryBufferCreateInfo.html + struct ExternalMemoryBufferCreateInfo + { + using NativeType = VkExternalMemoryBufferCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryBufferCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleTypes{ handleTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( ExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalMemoryBufferCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + ExternalMemoryBufferCreateInfo & operator=( ExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalMemoryBufferCreateInfo & operator=( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryBufferCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryBufferCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryBufferCreateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryBufferCreateInfo && setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalMemoryBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryBufferCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryBufferCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalMemoryBufferCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalMemoryBufferCreateInfo const & ) const = default; +#else + bool operator==( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif + } + + bool operator!=( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalMemoryBufferCreateInfo; + const void * pNext = {}; + ExternalMemoryHandleTypeFlags handleTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalMemoryBufferCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalMemoryBufferCreateInfo; + }; + + using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo; + + // wrapper struct for struct VkExternalMemoryImageCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryImageCreateInfo.html + struct ExternalMemoryImageCreateInfo + { + using NativeType = VkExternalMemoryImageCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryImageCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleTypes{ handleTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( ExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalMemoryImageCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + ExternalMemoryImageCreateInfo & operator=( ExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalMemoryImageCreateInfo & operator=( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfo && setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalMemoryImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryImageCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryImageCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalMemoryImageCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalMemoryImageCreateInfo const & ) const = default; +#else + bool operator==( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif + } + + bool operator!=( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalMemoryImageCreateInfo; + const void * pNext = {}; + ExternalMemoryHandleTypeFlags handleTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalMemoryImageCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalMemoryImageCreateInfo; + }; + + using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo; + + // wrapper struct for struct VkExternalMemoryImageCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryImageCreateInfoNV.html + struct ExternalMemoryImageCreateInfoNV + { + using NativeType = VkExternalMemoryImageCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryImageCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleTypes{ handleTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( ExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalMemoryImageCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ExternalMemoryImageCreateInfoNV & operator=( ExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalMemoryImageCreateInfoNV & operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfoNV & setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) & VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfoNV && setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) && VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalMemoryImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryImageCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalMemoryImageCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalMemoryImageCreateInfoNV const & ) const = default; +#else + bool operator==( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif + } + + bool operator!=( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV; + const void * pNext = {}; + ExternalMemoryHandleTypeFlagsNV handleTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalMemoryImageCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalMemoryImageCreateInfoNV; + }; + + // wrapper struct for struct VkExternalMemoryTensorCreateInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryTensorCreateInfoARM.html + struct ExternalMemoryTensorCreateInfoARM + { + using NativeType = VkExternalMemoryTensorCreateInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryTensorCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalMemoryTensorCreateInfoARM( ExternalMemoryHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleTypes{ handleTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalMemoryTensorCreateInfoARM( ExternalMemoryTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalMemoryTensorCreateInfoARM( VkExternalMemoryTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalMemoryTensorCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + ExternalMemoryTensorCreateInfoARM & operator=( ExternalMemoryTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalMemoryTensorCreateInfoARM & operator=( VkExternalMemoryTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryTensorCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryTensorCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryTensorCreateInfoARM & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalMemoryTensorCreateInfoARM && setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT + { + handleTypes = handleTypes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalMemoryTensorCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryTensorCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalMemoryTensorCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalMemoryTensorCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalMemoryTensorCreateInfoARM const & ) const = default; +#else + bool operator==( ExternalMemoryTensorCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); +# endif + } + + bool operator!=( ExternalMemoryTensorCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalMemoryTensorCreateInfoARM; + const void * pNext = {}; + ExternalMemoryHandleTypeFlags handleTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalMemoryTensorCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalMemoryTensorCreateInfoARM; + }; + + // wrapper struct for struct VkExternalSemaphoreProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreProperties.html + struct ExternalSemaphoreProperties + { + using NativeType = VkExternalSemaphoreProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalSemaphoreProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalSemaphoreProperties( ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes_ = {}, + ExternalSemaphoreHandleTypeFlags compatibleHandleTypes_ = {}, + ExternalSemaphoreFeatureFlags externalSemaphoreFeatures_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , exportFromImportedHandleTypes{ exportFromImportedHandleTypes_ } + , compatibleHandleTypes{ compatibleHandleTypes_ } + , externalSemaphoreFeatures{ externalSemaphoreFeatures_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalSemaphoreProperties( ExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalSemaphoreProperties( *reinterpret_cast( &rhs ) ) + { + } + + ExternalSemaphoreProperties & operator=( ExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalSemaphoreProperties & operator=( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkExternalSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalSemaphoreProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalSemaphoreProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalSemaphoreProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalSemaphoreFeatures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalSemaphoreProperties const & ) const = default; +#else + bool operator==( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && + ( compatibleHandleTypes == rhs.compatibleHandleTypes ) && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures ); +# endif + } + + bool operator!=( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalSemaphoreProperties; + void * pNext = {}; + ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes = {}; + ExternalSemaphoreHandleTypeFlags compatibleHandleTypes = {}; + ExternalSemaphoreFeatureFlags externalSemaphoreFeatures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalSemaphoreProperties; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalSemaphoreProperties; + }; + + using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; + + // wrapper struct for struct VkExternalTensorPropertiesARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalTensorPropertiesARM.html + struct ExternalTensorPropertiesARM + { + using NativeType = VkExternalTensorPropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalTensorPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalTensorPropertiesARM( ExternalMemoryProperties externalMemoryProperties_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , externalMemoryProperties{ externalMemoryProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalTensorPropertiesARM( ExternalTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalTensorPropertiesARM( VkExternalTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalTensorPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + ExternalTensorPropertiesARM & operator=( ExternalTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalTensorPropertiesARM & operator=( VkExternalTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalTensorPropertiesARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalTensorPropertiesARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ExternalTensorPropertiesARM & setExternalMemoryProperties( ExternalMemoryProperties const & externalMemoryProperties_ ) & + VULKAN_HPP_NOEXCEPT + { + externalMemoryProperties = externalMemoryProperties_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalTensorPropertiesARM && setExternalMemoryProperties( ExternalMemoryProperties const & externalMemoryProperties_ ) && + VULKAN_HPP_NOEXCEPT + { + externalMemoryProperties = externalMemoryProperties_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalTensorPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalTensorPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalTensorPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalTensorPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalMemoryProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalTensorPropertiesARM const & ) const = default; +#else + bool operator==( ExternalTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryProperties == rhs.externalMemoryProperties ); +# endif + } + + bool operator!=( ExternalTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eExternalTensorPropertiesARM; + const void * pNext = {}; + ExternalMemoryProperties externalMemoryProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ExternalTensorPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = ExternalTensorPropertiesARM; + }; + + // wrapper struct for struct VkFenceCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceCreateInfo.html + struct FenceCreateInfo + { + using NativeType = VkFenceCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FenceCreateInfo( FenceCreateFlags flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR FenceCreateInfo( FenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FenceCreateInfo( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : FenceCreateInfo( *reinterpret_cast( &rhs ) ) {} + + FenceCreateInfo & operator=( FenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FenceCreateInfo & operator=( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 FenceCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FenceCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FenceCreateInfo & setFlags( FenceCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FenceCreateInfo && setFlags( FenceCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFenceCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFenceCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFenceCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FenceCreateInfo const & ) const = default; +#else + bool operator==( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFenceCreateInfo; + const void * pNext = {}; + FenceCreateFlags flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FenceCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = FenceCreateInfo; + }; + + // wrapper struct for struct VkFenceGetFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceGetFdInfoKHR.html + struct FenceGetFdInfoKHR + { + using NativeType = VkFenceGetFdInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceGetFdInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( Fence fence_ = {}, + ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fence{ fence_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( FenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : FenceGetFdInfoKHR( *reinterpret_cast( &rhs ) ) {} + + FenceGetFdInfoKHR & operator=( FenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FenceGetFdInfoKHR & operator=( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR & setFence( Fence fence_ ) & VULKAN_HPP_NOEXCEPT + { + fence = fence_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR && setFence( Fence fence_ ) && VULKAN_HPP_NOEXCEPT + { + fence = fence_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR && setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkFenceGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFenceGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFenceGetFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFenceGetFdInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, handleType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FenceGetFdInfoKHR const & ) const = default; +#else + bool operator==( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFenceGetFdInfoKHR; + const void * pNext = {}; + Fence fence = {}; + ExternalFenceHandleTypeFlagBits handleType = ExternalFenceHandleTypeFlagBits::eOpaqueFd; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FenceGetFdInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = FenceGetFdInfoKHR; + }; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkFenceGetWin32HandleInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceGetWin32HandleInfoKHR.html + struct FenceGetWin32HandleInfoKHR + { + using NativeType = VkFenceGetWin32HandleInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceGetWin32HandleInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( Fence fence_ = {}, + ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fence{ fence_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( FenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : FenceGetWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + FenceGetWin32HandleInfoKHR & operator=( FenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FenceGetWin32HandleInfoKHR & operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR & setFence( Fence fence_ ) & VULKAN_HPP_NOEXCEPT + { + fence = fence_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR && setFence( Fence fence_ ) && VULKAN_HPP_NOEXCEPT + { + fence = fence_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR && setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkFenceGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFenceGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFenceGetWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFenceGetWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, handleType ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FenceGetWin32HandleInfoKHR const & ) const = default; +# else + bool operator==( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR; + const void * pNext = {}; + Fence fence = {}; + ExternalFenceHandleTypeFlagBits handleType = ExternalFenceHandleTypeFlagBits::eOpaqueFd; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FenceGetWin32HandleInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = FenceGetWin32HandleInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + // wrapper struct for struct VkFilterCubicImageViewImageFormatPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFilterCubicImageViewImageFormatPropertiesEXT.html + struct FilterCubicImageViewImageFormatPropertiesEXT + { + using NativeType = VkFilterCubicImageViewImageFormatPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + FilterCubicImageViewImageFormatPropertiesEXT( Bool32 filterCubic_ = {}, Bool32 filterCubicMinmax_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , filterCubic{ filterCubic_ } + , filterCubicMinmax{ filterCubicMinmax_ } + { + } + + VULKAN_HPP_CONSTEXPR FilterCubicImageViewImageFormatPropertiesEXT( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : FilterCubicImageViewImageFormatPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + FilterCubicImageViewImageFormatPropertiesEXT & operator=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FilterCubicImageViewImageFormatPropertiesEXT & operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkFilterCubicImageViewImageFormatPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFilterCubicImageViewImageFormatPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFilterCubicImageViewImageFormatPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFilterCubicImageViewImageFormatPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, filterCubic, filterCubicMinmax ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FilterCubicImageViewImageFormatPropertiesEXT const & ) const = default; +#else + bool operator==( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCubic == rhs.filterCubic ) && ( filterCubicMinmax == rhs.filterCubicMinmax ); +# endif + } + + bool operator!=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; + void * pNext = {}; + Bool32 filterCubic = {}; + Bool32 filterCubicMinmax = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FilterCubicImageViewImageFormatPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = FilterCubicImageViewImageFormatPropertiesEXT; + }; + + // wrapper struct for struct VkFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatProperties.html + struct FormatProperties + { + using NativeType = VkFormatProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FormatProperties( FormatFeatureFlags linearTilingFeatures_ = {}, + FormatFeatureFlags optimalTilingFeatures_ = {}, + FormatFeatureFlags bufferFeatures_ = {} ) VULKAN_HPP_NOEXCEPT + : linearTilingFeatures{ linearTilingFeatures_ } + , optimalTilingFeatures{ optimalTilingFeatures_ } + , bufferFeatures{ bufferFeatures_ } + { + } + + VULKAN_HPP_CONSTEXPR FormatProperties( FormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FormatProperties( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT : FormatProperties( *reinterpret_cast( &rhs ) ) {} + + FormatProperties & operator=( FormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FormatProperties & operator=( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkFormatProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFormatProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFormatProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFormatProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( linearTilingFeatures, optimalTilingFeatures, bufferFeatures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FormatProperties const & ) const = default; +#else + bool operator==( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( linearTilingFeatures == rhs.linearTilingFeatures ) && ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && + ( bufferFeatures == rhs.bufferFeatures ); +# endif + } + + bool operator!=( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + FormatFeatureFlags linearTilingFeatures = {}; + FormatFeatureFlags optimalTilingFeatures = {}; + FormatFeatureFlags bufferFeatures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FormatProperties; + }; +#endif + + // wrapper struct for struct VkFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatProperties2.html + struct FormatProperties2 + { + using NativeType = VkFormatProperties2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFormatProperties2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FormatProperties2( FormatProperties formatProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , formatProperties{ formatProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR FormatProperties2( FormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FormatProperties2( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT : FormatProperties2( *reinterpret_cast( &rhs ) ) {} + + FormatProperties2 & operator=( FormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FormatProperties2 & operator=( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFormatProperties2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFormatProperties2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFormatProperties2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FormatProperties2 const & ) const = default; +#else + bool operator==( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatProperties == rhs.formatProperties ); +# endif + } + + bool operator!=( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFormatProperties2; + void * pNext = {}; + FormatProperties formatProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FormatProperties2; + }; +#endif + + template <> + struct CppType + { + using Type = FormatProperties2; + }; + + using FormatProperties2KHR = FormatProperties2; + + // wrapper struct for struct VkFormatProperties3, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatProperties3.html + struct FormatProperties3 + { + using NativeType = VkFormatProperties3; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFormatProperties3; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FormatProperties3( FormatFeatureFlags2 linearTilingFeatures_ = {}, + FormatFeatureFlags2 optimalTilingFeatures_ = {}, + FormatFeatureFlags2 bufferFeatures_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , linearTilingFeatures{ linearTilingFeatures_ } + , optimalTilingFeatures{ optimalTilingFeatures_ } + , bufferFeatures{ bufferFeatures_ } + { + } + + VULKAN_HPP_CONSTEXPR FormatProperties3( FormatProperties3 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FormatProperties3( VkFormatProperties3 const & rhs ) VULKAN_HPP_NOEXCEPT : FormatProperties3( *reinterpret_cast( &rhs ) ) {} + + FormatProperties3 & operator=( FormatProperties3 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FormatProperties3 & operator=( VkFormatProperties3 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkFormatProperties3 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFormatProperties3 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFormatProperties3 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFormatProperties3 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, linearTilingFeatures, optimalTilingFeatures, bufferFeatures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FormatProperties3 const & ) const = default; +#else + bool operator==( FormatProperties3 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearTilingFeatures == rhs.linearTilingFeatures ) && + ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures ); +# endif + } + + bool operator!=( FormatProperties3 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFormatProperties3; + void * pNext = {}; + FormatFeatureFlags2 linearTilingFeatures = {}; + FormatFeatureFlags2 optimalTilingFeatures = {}; + FormatFeatureFlags2 bufferFeatures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FormatProperties3; + }; +#endif + + template <> + struct CppType + { + using Type = FormatProperties3; + }; + + using FormatProperties3KHR = FormatProperties3; + + // wrapper struct for struct VkFragmentShadingRateAttachmentInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFragmentShadingRateAttachmentInfoKHR.html + struct FragmentShadingRateAttachmentInfoKHR + { + using NativeType = VkFragmentShadingRateAttachmentInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFragmentShadingRateAttachmentInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FragmentShadingRateAttachmentInfoKHR( const AttachmentReference2 * pFragmentShadingRateAttachment_ = {}, + Extent2D shadingRateAttachmentTexelSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pFragmentShadingRateAttachment{ pFragmentShadingRateAttachment_ } + , shadingRateAttachmentTexelSize{ shadingRateAttachmentTexelSize_ } + { + } + + VULKAN_HPP_CONSTEXPR FragmentShadingRateAttachmentInfoKHR( FragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FragmentShadingRateAttachmentInfoKHR( VkFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : FragmentShadingRateAttachmentInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + FragmentShadingRateAttachmentInfoKHR & operator=( FragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FragmentShadingRateAttachmentInfoKHR & operator=( VkFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR & + setPFragmentShadingRateAttachment( const AttachmentReference2 * pFragmentShadingRateAttachment_ ) & + VULKAN_HPP_NOEXCEPT + { + pFragmentShadingRateAttachment = pFragmentShadingRateAttachment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR && + setPFragmentShadingRateAttachment( const AttachmentReference2 * pFragmentShadingRateAttachment_ ) && + VULKAN_HPP_NOEXCEPT + { + pFragmentShadingRateAttachment = pFragmentShadingRateAttachment_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR & setShadingRateAttachmentTexelSize( Extent2D const & shadingRateAttachmentTexelSize_ ) & + VULKAN_HPP_NOEXCEPT + { + shadingRateAttachmentTexelSize = shadingRateAttachmentTexelSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR && setShadingRateAttachmentTexelSize( Extent2D const & shadingRateAttachmentTexelSize_ ) && + VULKAN_HPP_NOEXCEPT + { + shadingRateAttachmentTexelSize = shadingRateAttachmentTexelSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFragmentShadingRateAttachmentInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFragmentShadingRateAttachmentInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pFragmentShadingRateAttachment, shadingRateAttachmentTexelSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FragmentShadingRateAttachmentInfoKHR const & ) const = default; +#else + bool operator==( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pFragmentShadingRateAttachment == rhs.pFragmentShadingRateAttachment ) && + ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize ); +# endif + } + + bool operator!=( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFragmentShadingRateAttachmentInfoKHR; + const void * pNext = {}; + const AttachmentReference2 * pFragmentShadingRateAttachment = {}; + Extent2D shadingRateAttachmentTexelSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FragmentShadingRateAttachmentInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = FragmentShadingRateAttachmentInfoKHR; + }; + + // wrapper struct for struct VkFrameBoundaryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrameBoundaryEXT.html + struct FrameBoundaryEXT + { + using NativeType = VkFrameBoundaryEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFrameBoundaryEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FrameBoundaryEXT( FrameBoundaryFlagsEXT flags_ = {}, + uint64_t frameID_ = {}, + uint32_t imageCount_ = {}, + const Image * pImages_ = {}, + uint32_t bufferCount_ = {}, + const Buffer * pBuffers_ = {}, + uint64_t tagName_ = {}, + size_t tagSize_ = {}, + const void * pTag_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , frameID{ frameID_ } + , imageCount{ imageCount_ } + , pImages{ pImages_ } + , bufferCount{ bufferCount_ } + , pBuffers{ pBuffers_ } + , tagName{ tagName_ } + , tagSize{ tagSize_ } + , pTag{ pTag_ } + { + } + + VULKAN_HPP_CONSTEXPR FrameBoundaryEXT( FrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FrameBoundaryEXT( VkFrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT : FrameBoundaryEXT( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + FrameBoundaryEXT( FrameBoundaryFlagsEXT flags_, + uint64_t frameID_, + ArrayProxyNoTemporaries const & images_, + ArrayProxyNoTemporaries const & buffers_ = {}, + uint64_t tagName_ = {}, + ArrayProxyNoTemporaries const & tag_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , frameID( frameID_ ) + , imageCount( static_cast( images_.size() ) ) + , pImages( images_.data() ) + , bufferCount( static_cast( buffers_.size() ) ) + , pBuffers( buffers_.data() ) + , tagName( tagName_ ) + , tagSize( tag_.size() * sizeof( T ) ) + , pTag( tag_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + FrameBoundaryEXT & operator=( FrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FrameBoundaryEXT & operator=( VkFrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setFlags( FrameBoundaryFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setFlags( FrameBoundaryFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setFrameID( uint64_t frameID_ ) & VULKAN_HPP_NOEXCEPT + { + frameID = frameID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setFrameID( uint64_t frameID_ ) && VULKAN_HPP_NOEXCEPT + { + frameID = frameID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setImageCount( uint32_t imageCount_ ) & VULKAN_HPP_NOEXCEPT + { + imageCount = imageCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setImageCount( uint32_t imageCount_ ) && VULKAN_HPP_NOEXCEPT + { + imageCount = imageCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPImages( const Image * pImages_ ) & VULKAN_HPP_NOEXCEPT + { + pImages = pImages_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setPImages( const Image * pImages_ ) && VULKAN_HPP_NOEXCEPT + { + pImages = pImages_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + FrameBoundaryEXT & setImages( ArrayProxyNoTemporaries const & images_ ) VULKAN_HPP_NOEXCEPT + { + imageCount = static_cast( images_.size() ); + pImages = images_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setBufferCount( uint32_t bufferCount_ ) & VULKAN_HPP_NOEXCEPT + { + bufferCount = bufferCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setBufferCount( uint32_t bufferCount_ ) && VULKAN_HPP_NOEXCEPT + { + bufferCount = bufferCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPBuffers( const Buffer * pBuffers_ ) & VULKAN_HPP_NOEXCEPT + { + pBuffers = pBuffers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setPBuffers( const Buffer * pBuffers_ ) && VULKAN_HPP_NOEXCEPT + { + pBuffers = pBuffers_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + FrameBoundaryEXT & setBuffers( ArrayProxyNoTemporaries const & buffers_ ) VULKAN_HPP_NOEXCEPT + { + bufferCount = static_cast( buffers_.size() ); + pBuffers = buffers_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setTagName( uint64_t tagName_ ) & VULKAN_HPP_NOEXCEPT + { + tagName = tagName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setTagName( uint64_t tagName_ ) && VULKAN_HPP_NOEXCEPT + { + tagName = tagName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setTagSize( size_t tagSize_ ) & VULKAN_HPP_NOEXCEPT + { + tagSize = tagSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setTagSize( size_t tagSize_ ) && VULKAN_HPP_NOEXCEPT + { + tagSize = tagSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPTag( const void * pTag_ ) & VULKAN_HPP_NOEXCEPT + { + pTag = pTag_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setPTag( const void * pTag_ ) && VULKAN_HPP_NOEXCEPT + { + pTag = pTag_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + FrameBoundaryEXT & setTag( ArrayProxyNoTemporaries const & tag_ ) VULKAN_HPP_NOEXCEPT + { + tagSize = tag_.size() * sizeof( T ); + pTag = tag_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkFrameBoundaryEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFrameBoundaryEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFrameBoundaryEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFrameBoundaryEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, frameID, imageCount, pImages, bufferCount, pBuffers, tagName, tagSize, pTag ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FrameBoundaryEXT const & ) const = default; +#else + bool operator==( FrameBoundaryEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( frameID == rhs.frameID ) && ( imageCount == rhs.imageCount ) && + ( pImages == rhs.pImages ) && ( bufferCount == rhs.bufferCount ) && ( pBuffers == rhs.pBuffers ) && ( tagName == rhs.tagName ) && + ( tagSize == rhs.tagSize ) && ( pTag == rhs.pTag ); +# endif + } + + bool operator!=( FrameBoundaryEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFrameBoundaryEXT; + const void * pNext = {}; + FrameBoundaryFlagsEXT flags = {}; + uint64_t frameID = {}; + uint32_t imageCount = {}; + const Image * pImages = {}; + uint32_t bufferCount = {}; + const Buffer * pBuffers = {}; + uint64_t tagName = {}; + size_t tagSize = {}; + const void * pTag = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FrameBoundaryEXT; + }; +#endif + + template <> + struct CppType + { + using Type = FrameBoundaryEXT; + }; + + // wrapper struct for struct VkFrameBoundaryTensorsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrameBoundaryTensorsARM.html + struct FrameBoundaryTensorsARM + { + using NativeType = VkFrameBoundaryTensorsARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFrameBoundaryTensorsARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + FrameBoundaryTensorsARM( uint32_t tensorCount_ = {}, const TensorARM * pTensors_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensorCount{ tensorCount_ } + , pTensors{ pTensors_ } + { + } + + VULKAN_HPP_CONSTEXPR FrameBoundaryTensorsARM( FrameBoundaryTensorsARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FrameBoundaryTensorsARM( VkFrameBoundaryTensorsARM const & rhs ) VULKAN_HPP_NOEXCEPT + : FrameBoundaryTensorsARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + FrameBoundaryTensorsARM( ArrayProxyNoTemporaries const & tensors_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), tensorCount( static_cast( tensors_.size() ) ), pTensors( tensors_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + FrameBoundaryTensorsARM & operator=( FrameBoundaryTensorsARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FrameBoundaryTensorsARM & operator=( VkFrameBoundaryTensorsARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM & setTensorCount( uint32_t tensorCount_ ) & VULKAN_HPP_NOEXCEPT + { + tensorCount = tensorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM && setTensorCount( uint32_t tensorCount_ ) && VULKAN_HPP_NOEXCEPT + { + tensorCount = tensorCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM & setPTensors( const TensorARM * pTensors_ ) & VULKAN_HPP_NOEXCEPT + { + pTensors = pTensors_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM && setPTensors( const TensorARM * pTensors_ ) && VULKAN_HPP_NOEXCEPT + { + pTensors = pTensors_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + FrameBoundaryTensorsARM & setTensors( ArrayProxyNoTemporaries const & tensors_ ) VULKAN_HPP_NOEXCEPT + { + tensorCount = static_cast( tensors_.size() ); + pTensors = tensors_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkFrameBoundaryTensorsARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFrameBoundaryTensorsARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFrameBoundaryTensorsARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFrameBoundaryTensorsARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tensorCount, pTensors ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FrameBoundaryTensorsARM const & ) const = default; +#else + bool operator==( FrameBoundaryTensorsARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorCount == rhs.tensorCount ) && ( pTensors == rhs.pTensors ); +# endif + } + + bool operator!=( FrameBoundaryTensorsARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFrameBoundaryTensorsARM; + const void * pNext = {}; + uint32_t tensorCount = {}; + const TensorARM * pTensors = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FrameBoundaryTensorsARM; + }; +#endif + + template <> + struct CppType + { + using Type = FrameBoundaryTensorsARM; + }; + + // wrapper struct for struct VkFramebufferAttachmentImageInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferAttachmentImageInfo.html + struct FramebufferAttachmentImageInfo + { + using NativeType = VkFramebufferAttachmentImageInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferAttachmentImageInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfo( ImageCreateFlags flags_ = {}, + ImageUsageFlags usage_ = {}, + uint32_t width_ = {}, + uint32_t height_ = {}, + uint32_t layerCount_ = {}, + uint32_t viewFormatCount_ = {}, + const Format * pViewFormats_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , usage{ usage_ } + , width{ width_ } + , height{ height_ } + , layerCount{ layerCount_ } + , viewFormatCount{ viewFormatCount_ } + , pViewFormats{ pViewFormats_ } + { + } + + VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfo( FramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FramebufferAttachmentImageInfo( VkFramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : FramebufferAttachmentImageInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + FramebufferAttachmentImageInfo( ImageCreateFlags flags_, + ImageUsageFlags usage_, + uint32_t width_, + uint32_t height_, + uint32_t layerCount_, + ArrayProxyNoTemporaries const & viewFormats_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , usage( usage_ ) + , width( width_ ) + , height( height_ ) + , layerCount( layerCount_ ) + , viewFormatCount( static_cast( viewFormats_.size() ) ) + , pViewFormats( viewFormats_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + FramebufferAttachmentImageInfo & operator=( FramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FramebufferAttachmentImageInfo & operator=( VkFramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setFlags( ImageCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setFlags( ImageCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setUsage( ImageUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setUsage( ImageUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT + { + width = width_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT + { + width = width_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT + { + height = height_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT + { + height = height_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setViewFormatCount( uint32_t viewFormatCount_ ) & VULKAN_HPP_NOEXCEPT + { + viewFormatCount = viewFormatCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setViewFormatCount( uint32_t viewFormatCount_ ) && VULKAN_HPP_NOEXCEPT + { + viewFormatCount = viewFormatCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setPViewFormats( const Format * pViewFormats_ ) & VULKAN_HPP_NOEXCEPT + { + pViewFormats = pViewFormats_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setPViewFormats( const Format * pViewFormats_ ) && VULKAN_HPP_NOEXCEPT + { + pViewFormats = pViewFormats_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + FramebufferAttachmentImageInfo & setViewFormats( ArrayProxyNoTemporaries const & viewFormats_ ) VULKAN_HPP_NOEXCEPT + { + viewFormatCount = static_cast( viewFormats_.size() ); + pViewFormats = viewFormats_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkFramebufferAttachmentImageInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFramebufferAttachmentImageInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFramebufferAttachmentImageInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFramebufferAttachmentImageInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, usage, width, height, layerCount, viewFormatCount, pViewFormats ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FramebufferAttachmentImageInfo const & ) const = default; +#else + bool operator==( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) && ( width == rhs.width ) && + ( height == rhs.height ) && ( layerCount == rhs.layerCount ) && ( viewFormatCount == rhs.viewFormatCount ) && ( pViewFormats == rhs.pViewFormats ); +# endif + } + + bool operator!=( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFramebufferAttachmentImageInfo; + const void * pNext = {}; + ImageCreateFlags flags = {}; + ImageUsageFlags usage = {}; + uint32_t width = {}; + uint32_t height = {}; + uint32_t layerCount = {}; + uint32_t viewFormatCount = {}; + const Format * pViewFormats = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FramebufferAttachmentImageInfo; + }; +#endif + + template <> + struct CppType + { + using Type = FramebufferAttachmentImageInfo; + }; + + using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo; + + // wrapper struct for struct VkFramebufferAttachmentsCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferAttachmentsCreateInfo.html + struct FramebufferAttachmentsCreateInfo + { + using NativeType = VkFramebufferAttachmentsCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferAttachmentsCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfo( uint32_t attachmentImageInfoCount_ = {}, + const FramebufferAttachmentImageInfo * pAttachmentImageInfos_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , attachmentImageInfoCount{ attachmentImageInfoCount_ } + , pAttachmentImageInfos{ pAttachmentImageInfos_ } + { + } + + VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfo( FramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FramebufferAttachmentsCreateInfo( VkFramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : FramebufferAttachmentsCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + FramebufferAttachmentsCreateInfo( ArrayProxyNoTemporaries const & attachmentImageInfos_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , attachmentImageInfoCount( static_cast( attachmentImageInfos_.size() ) ) + , pAttachmentImageInfos( attachmentImageInfos_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + FramebufferAttachmentsCreateInfo & operator=( FramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FramebufferAttachmentsCreateInfo & operator=( VkFramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo & setAttachmentImageInfoCount( uint32_t attachmentImageInfoCount_ ) & VULKAN_HPP_NOEXCEPT + { + attachmentImageInfoCount = attachmentImageInfoCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo && setAttachmentImageInfoCount( uint32_t attachmentImageInfoCount_ ) && VULKAN_HPP_NOEXCEPT + { + attachmentImageInfoCount = attachmentImageInfoCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo & setPAttachmentImageInfos( const FramebufferAttachmentImageInfo * pAttachmentImageInfos_ ) & + VULKAN_HPP_NOEXCEPT + { + pAttachmentImageInfos = pAttachmentImageInfos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo && setPAttachmentImageInfos( const FramebufferAttachmentImageInfo * pAttachmentImageInfos_ ) && + VULKAN_HPP_NOEXCEPT + { + pAttachmentImageInfos = pAttachmentImageInfos_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + FramebufferAttachmentsCreateInfo & + setAttachmentImageInfos( ArrayProxyNoTemporaries const & attachmentImageInfos_ ) VULKAN_HPP_NOEXCEPT + { + attachmentImageInfoCount = static_cast( attachmentImageInfos_.size() ); + pAttachmentImageInfos = attachmentImageInfos_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkFramebufferAttachmentsCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFramebufferAttachmentsCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFramebufferAttachmentsCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFramebufferAttachmentsCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachmentImageInfoCount, pAttachmentImageInfos ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FramebufferAttachmentsCreateInfo const & ) const = default; +#else + bool operator==( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentImageInfoCount == rhs.attachmentImageInfoCount ) && + ( pAttachmentImageInfos == rhs.pAttachmentImageInfos ); +# endif + } + + bool operator!=( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFramebufferAttachmentsCreateInfo; + const void * pNext = {}; + uint32_t attachmentImageInfoCount = {}; + const FramebufferAttachmentImageInfo * pAttachmentImageInfos = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FramebufferAttachmentsCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = FramebufferAttachmentsCreateInfo; + }; + + using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo; + + // wrapper struct for struct VkFramebufferCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferCreateInfo.html + struct FramebufferCreateInfo + { + using NativeType = VkFramebufferCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( FramebufferCreateFlags flags_ = {}, + RenderPass renderPass_ = {}, + uint32_t attachmentCount_ = {}, + const ImageView * pAttachments_ = {}, + uint32_t width_ = {}, + uint32_t height_ = {}, + uint32_t layers_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , renderPass{ renderPass_ } + , attachmentCount{ attachmentCount_ } + , pAttachments{ pAttachments_ } + , width{ width_ } + , height{ height_ } + , layers{ layers_ } + { + } + + VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( FramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : FramebufferCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + FramebufferCreateInfo( FramebufferCreateFlags flags_, + RenderPass renderPass_, + ArrayProxyNoTemporaries const & attachments_, + uint32_t width_ = {}, + uint32_t height_ = {}, + uint32_t layers_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , renderPass( renderPass_ ) + , attachmentCount( static_cast( attachments_.size() ) ) + , pAttachments( attachments_.data() ) + , width( width_ ) + , height( height_ ) + , layers( layers_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + FramebufferCreateInfo & operator=( FramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FramebufferCreateInfo & operator=( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setFlags( FramebufferCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setFlags( FramebufferCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setRenderPass( RenderPass renderPass_ ) & VULKAN_HPP_NOEXCEPT + { + renderPass = renderPass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setRenderPass( RenderPass renderPass_ ) && VULKAN_HPP_NOEXCEPT + { + renderPass = renderPass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setPAttachments( const ImageView * pAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pAttachments = pAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setPAttachments( const ImageView * pAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pAttachments = pAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + FramebufferCreateInfo & setAttachments( ArrayProxyNoTemporaries const & attachments_ ) VULKAN_HPP_NOEXCEPT + { + attachmentCount = static_cast( attachments_.size() ); + pAttachments = attachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT + { + width = width_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT + { + width = width_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT + { + height = height_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT + { + height = height_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setLayers( uint32_t layers_ ) & VULKAN_HPP_NOEXCEPT + { + layers = layers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setLayers( uint32_t layers_ ) && VULKAN_HPP_NOEXCEPT + { + layers = layers_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkFramebufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFramebufferCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFramebufferCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFramebufferCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, renderPass, attachmentCount, pAttachments, width, height, layers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FramebufferCreateInfo const & ) const = default; +#else + bool operator==( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( renderPass == rhs.renderPass ) && + ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) && ( width == rhs.width ) && ( height == rhs.height ) && + ( layers == rhs.layers ); +# endif + } + + bool operator!=( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFramebufferCreateInfo; + const void * pNext = {}; + FramebufferCreateFlags flags = {}; + RenderPass renderPass = {}; + uint32_t attachmentCount = {}; + const ImageView * pAttachments = {}; + uint32_t width = {}; + uint32_t height = {}; + uint32_t layers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FramebufferCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = FramebufferCreateInfo; + }; + + // wrapper struct for struct VkFramebufferMixedSamplesCombinationNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferMixedSamplesCombinationNV.html + struct FramebufferMixedSamplesCombinationNV + { + using NativeType = VkFramebufferMixedSamplesCombinationNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferMixedSamplesCombinationNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR FramebufferMixedSamplesCombinationNV( CoverageReductionModeNV coverageReductionMode_ = CoverageReductionModeNV::eMerge, + SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, + SampleCountFlags depthStencilSamples_ = {}, + SampleCountFlags colorSamples_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , coverageReductionMode{ coverageReductionMode_ } + , rasterizationSamples{ rasterizationSamples_ } + , depthStencilSamples{ depthStencilSamples_ } + , colorSamples{ colorSamples_ } + { + } + + VULKAN_HPP_CONSTEXPR FramebufferMixedSamplesCombinationNV( FramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT + : FramebufferMixedSamplesCombinationNV( *reinterpret_cast( &rhs ) ) + { + } + + FramebufferMixedSamplesCombinationNV & operator=( FramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + FramebufferMixedSamplesCombinationNV & operator=( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkFramebufferMixedSamplesCombinationNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFramebufferMixedSamplesCombinationNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkFramebufferMixedSamplesCombinationNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkFramebufferMixedSamplesCombinationNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, coverageReductionMode, rasterizationSamples, depthStencilSamples, colorSamples ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( FramebufferMixedSamplesCombinationNV const & ) const = default; +#else + bool operator==( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode ) && + ( rasterizationSamples == rhs.rasterizationSamples ) && ( depthStencilSamples == rhs.depthStencilSamples ) && ( colorSamples == rhs.colorSamples ); +# endif + } + + bool operator!=( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV; + void * pNext = {}; + CoverageReductionModeNV coverageReductionMode = CoverageReductionModeNV::eMerge; + SampleCountFlagBits rasterizationSamples = SampleCountFlagBits::e1; + SampleCountFlags depthStencilSamples = {}; + SampleCountFlags colorSamples = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = FramebufferMixedSamplesCombinationNV; + }; +#endif + + template <> + struct CppType + { + using Type = FramebufferMixedSamplesCombinationNV; + }; + + // wrapper struct for struct VkGeneratedCommandsInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsInfoEXT.html + struct GeneratedCommandsInfoEXT + { + using NativeType = VkGeneratedCommandsInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoEXT( ShaderStageFlags shaderStages_ = {}, + IndirectExecutionSetEXT indirectExecutionSet_ = {}, + IndirectCommandsLayoutEXT indirectCommandsLayout_ = {}, + DeviceAddress indirectAddress_ = {}, + DeviceSize indirectAddressSize_ = {}, + DeviceAddress preprocessAddress_ = {}, + DeviceSize preprocessSize_ = {}, + uint32_t maxSequenceCount_ = {}, + DeviceAddress sequenceCountAddress_ = {}, + uint32_t maxDrawCount_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderStages{ shaderStages_ } + , indirectExecutionSet{ indirectExecutionSet_ } + , indirectCommandsLayout{ indirectCommandsLayout_ } + , indirectAddress{ indirectAddress_ } + , indirectAddressSize{ indirectAddressSize_ } + , preprocessAddress{ preprocessAddress_ } + , preprocessSize{ preprocessSize_ } + , maxSequenceCount{ maxSequenceCount_ } + , sequenceCountAddress{ sequenceCountAddress_ } + , maxDrawCount{ maxDrawCount_ } + { + } + + VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoEXT( GeneratedCommandsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GeneratedCommandsInfoEXT( VkGeneratedCommandsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : GeneratedCommandsInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + GeneratedCommandsInfoEXT & operator=( GeneratedCommandsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GeneratedCommandsInfoEXT & operator=( VkGeneratedCommandsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setShaderStages( ShaderStageFlags shaderStages_ ) & VULKAN_HPP_NOEXCEPT + { + shaderStages = shaderStages_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setShaderStages( ShaderStageFlags shaderStages_ ) && VULKAN_HPP_NOEXCEPT + { + shaderStages = shaderStages_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setIndirectExecutionSet( IndirectExecutionSetEXT indirectExecutionSet_ ) & VULKAN_HPP_NOEXCEPT + { + indirectExecutionSet = indirectExecutionSet_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setIndirectExecutionSet( IndirectExecutionSetEXT indirectExecutionSet_ ) && VULKAN_HPP_NOEXCEPT + { + indirectExecutionSet = indirectExecutionSet_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setIndirectCommandsLayout( IndirectCommandsLayoutEXT indirectCommandsLayout_ ) & VULKAN_HPP_NOEXCEPT + { + indirectCommandsLayout = indirectCommandsLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setIndirectCommandsLayout( IndirectCommandsLayoutEXT indirectCommandsLayout_ ) && VULKAN_HPP_NOEXCEPT + { + indirectCommandsLayout = indirectCommandsLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setIndirectAddress( DeviceAddress indirectAddress_ ) & VULKAN_HPP_NOEXCEPT + { + indirectAddress = indirectAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setIndirectAddress( DeviceAddress indirectAddress_ ) && VULKAN_HPP_NOEXCEPT + { + indirectAddress = indirectAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setIndirectAddressSize( DeviceSize indirectAddressSize_ ) & VULKAN_HPP_NOEXCEPT + { + indirectAddressSize = indirectAddressSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setIndirectAddressSize( DeviceSize indirectAddressSize_ ) && VULKAN_HPP_NOEXCEPT + { + indirectAddressSize = indirectAddressSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setPreprocessAddress( DeviceAddress preprocessAddress_ ) & VULKAN_HPP_NOEXCEPT + { + preprocessAddress = preprocessAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setPreprocessAddress( DeviceAddress preprocessAddress_ ) && VULKAN_HPP_NOEXCEPT + { + preprocessAddress = preprocessAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setPreprocessSize( DeviceSize preprocessSize_ ) & VULKAN_HPP_NOEXCEPT + { + preprocessSize = preprocessSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setPreprocessSize( DeviceSize preprocessSize_ ) && VULKAN_HPP_NOEXCEPT + { + preprocessSize = preprocessSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setMaxSequenceCount( uint32_t maxSequenceCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxSequenceCount = maxSequenceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setMaxSequenceCount( uint32_t maxSequenceCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxSequenceCount = maxSequenceCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setSequenceCountAddress( DeviceAddress sequenceCountAddress_ ) & VULKAN_HPP_NOEXCEPT + { + sequenceCountAddress = sequenceCountAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setSequenceCountAddress( DeviceAddress sequenceCountAddress_ ) && VULKAN_HPP_NOEXCEPT + { + sequenceCountAddress = sequenceCountAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setMaxDrawCount( uint32_t maxDrawCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxDrawCount = maxDrawCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setMaxDrawCount( uint32_t maxDrawCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxDrawCount = maxDrawCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGeneratedCommandsInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGeneratedCommandsInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderStages, + indirectExecutionSet, + indirectCommandsLayout, + indirectAddress, + indirectAddressSize, + preprocessAddress, + preprocessSize, + maxSequenceCount, + sequenceCountAddress, + maxDrawCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GeneratedCommandsInfoEXT const & ) const = default; +#else + bool operator==( GeneratedCommandsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderStages == rhs.shaderStages ) && ( indirectExecutionSet == rhs.indirectExecutionSet ) && + ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && ( indirectAddress == rhs.indirectAddress ) && + ( indirectAddressSize == rhs.indirectAddressSize ) && ( preprocessAddress == rhs.preprocessAddress ) && ( preprocessSize == rhs.preprocessSize ) && + ( maxSequenceCount == rhs.maxSequenceCount ) && ( sequenceCountAddress == rhs.sequenceCountAddress ) && ( maxDrawCount == rhs.maxDrawCount ); +# endif + } + + bool operator!=( GeneratedCommandsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGeneratedCommandsInfoEXT; + const void * pNext = {}; + ShaderStageFlags shaderStages = {}; + IndirectExecutionSetEXT indirectExecutionSet = {}; + IndirectCommandsLayoutEXT indirectCommandsLayout = {}; + DeviceAddress indirectAddress = {}; + DeviceSize indirectAddressSize = {}; + DeviceAddress preprocessAddress = {}; + DeviceSize preprocessSize = {}; + uint32_t maxSequenceCount = {}; + DeviceAddress sequenceCountAddress = {}; + uint32_t maxDrawCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GeneratedCommandsInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = GeneratedCommandsInfoEXT; + }; + + // wrapper struct for struct VkIndirectCommandsStreamNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsStreamNV.html + struct IndirectCommandsStreamNV + { + using NativeType = VkIndirectCommandsStreamNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR IndirectCommandsStreamNV( Buffer buffer_ = {}, DeviceSize offset_ = {} ) VULKAN_HPP_NOEXCEPT + : buffer{ buffer_ } + , offset{ offset_ } + { + } + + VULKAN_HPP_CONSTEXPR IndirectCommandsStreamNV( IndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectCommandsStreamNV( VkIndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectCommandsStreamNV( *reinterpret_cast( &rhs ) ) + { + } + + IndirectCommandsStreamNV & operator=( IndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectCommandsStreamNV & operator=( VkIndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsStreamNV & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsStreamNV && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsStreamNV & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsStreamNV && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectCommandsStreamNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsStreamNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsStreamNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectCommandsStreamNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( buffer, offset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectCommandsStreamNV const & ) const = default; +#else + bool operator==( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( buffer == rhs.buffer ) && ( offset == rhs.offset ); +# endif + } + + bool operator!=( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Buffer buffer = {}; + DeviceSize offset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectCommandsStreamNV; + }; +#endif + + // wrapper struct for struct VkGeneratedCommandsInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsInfoNV.html + struct GeneratedCommandsInfoNV + { + using NativeType = VkGeneratedCommandsInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoNV( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + Pipeline pipeline_ = {}, + IndirectCommandsLayoutNV indirectCommandsLayout_ = {}, + uint32_t streamCount_ = {}, + const IndirectCommandsStreamNV * pStreams_ = {}, + uint32_t sequencesCount_ = {}, + Buffer preprocessBuffer_ = {}, + DeviceSize preprocessOffset_ = {}, + DeviceSize preprocessSize_ = {}, + Buffer sequencesCountBuffer_ = {}, + DeviceSize sequencesCountOffset_ = {}, + Buffer sequencesIndexBuffer_ = {}, + DeviceSize sequencesIndexOffset_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineBindPoint{ pipelineBindPoint_ } + , pipeline{ pipeline_ } + , indirectCommandsLayout{ indirectCommandsLayout_ } + , streamCount{ streamCount_ } + , pStreams{ pStreams_ } + , sequencesCount{ sequencesCount_ } + , preprocessBuffer{ preprocessBuffer_ } + , preprocessOffset{ preprocessOffset_ } + , preprocessSize{ preprocessSize_ } + , sequencesCountBuffer{ sequencesCountBuffer_ } + , sequencesCountOffset{ sequencesCountOffset_ } + , sequencesIndexBuffer{ sequencesIndexBuffer_ } + , sequencesIndexOffset{ sequencesIndexOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoNV( GeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GeneratedCommandsInfoNV( VkGeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : GeneratedCommandsInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GeneratedCommandsInfoNV( PipelineBindPoint pipelineBindPoint_, + Pipeline pipeline_, + IndirectCommandsLayoutNV indirectCommandsLayout_, + ArrayProxyNoTemporaries const & streams_, + uint32_t sequencesCount_ = {}, + Buffer preprocessBuffer_ = {}, + DeviceSize preprocessOffset_ = {}, + DeviceSize preprocessSize_ = {}, + Buffer sequencesCountBuffer_ = {}, + DeviceSize sequencesCountOffset_ = {}, + Buffer sequencesIndexBuffer_ = {}, + DeviceSize sequencesIndexOffset_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , pipeline( pipeline_ ) + , indirectCommandsLayout( indirectCommandsLayout_ ) + , streamCount( static_cast( streams_.size() ) ) + , pStreams( streams_.data() ) + , sequencesCount( sequencesCount_ ) + , preprocessBuffer( preprocessBuffer_ ) + , preprocessOffset( preprocessOffset_ ) + , preprocessSize( preprocessSize_ ) + , sequencesCountBuffer( sequencesCountBuffer_ ) + , sequencesCountOffset( sequencesCountOffset_ ) + , sequencesIndexBuffer( sequencesIndexBuffer_ ) + , sequencesIndexOffset( sequencesIndexOffset_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + GeneratedCommandsInfoNV & operator=( GeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GeneratedCommandsInfoNV & operator=( VkGeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setIndirectCommandsLayout( IndirectCommandsLayoutNV indirectCommandsLayout_ ) & VULKAN_HPP_NOEXCEPT + { + indirectCommandsLayout = indirectCommandsLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setIndirectCommandsLayout( IndirectCommandsLayoutNV indirectCommandsLayout_ ) && VULKAN_HPP_NOEXCEPT + { + indirectCommandsLayout = indirectCommandsLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setStreamCount( uint32_t streamCount_ ) & VULKAN_HPP_NOEXCEPT + { + streamCount = streamCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setStreamCount( uint32_t streamCount_ ) && VULKAN_HPP_NOEXCEPT + { + streamCount = streamCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPStreams( const IndirectCommandsStreamNV * pStreams_ ) & VULKAN_HPP_NOEXCEPT + { + pStreams = pStreams_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPStreams( const IndirectCommandsStreamNV * pStreams_ ) && VULKAN_HPP_NOEXCEPT + { + pStreams = pStreams_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GeneratedCommandsInfoNV & setStreams( ArrayProxyNoTemporaries const & streams_ ) VULKAN_HPP_NOEXCEPT + { + streamCount = static_cast( streams_.size() ); + pStreams = streams_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setSequencesCount( uint32_t sequencesCount_ ) & VULKAN_HPP_NOEXCEPT + { + sequencesCount = sequencesCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setSequencesCount( uint32_t sequencesCount_ ) && VULKAN_HPP_NOEXCEPT + { + sequencesCount = sequencesCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPreprocessBuffer( Buffer preprocessBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + preprocessBuffer = preprocessBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPreprocessBuffer( Buffer preprocessBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + preprocessBuffer = preprocessBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPreprocessOffset( DeviceSize preprocessOffset_ ) & VULKAN_HPP_NOEXCEPT + { + preprocessOffset = preprocessOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPreprocessOffset( DeviceSize preprocessOffset_ ) && VULKAN_HPP_NOEXCEPT + { + preprocessOffset = preprocessOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPreprocessSize( DeviceSize preprocessSize_ ) & VULKAN_HPP_NOEXCEPT + { + preprocessSize = preprocessSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPreprocessSize( DeviceSize preprocessSize_ ) && VULKAN_HPP_NOEXCEPT + { + preprocessSize = preprocessSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setSequencesCountBuffer( Buffer sequencesCountBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + sequencesCountBuffer = sequencesCountBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setSequencesCountBuffer( Buffer sequencesCountBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + sequencesCountBuffer = sequencesCountBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setSequencesCountOffset( DeviceSize sequencesCountOffset_ ) & VULKAN_HPP_NOEXCEPT + { + sequencesCountOffset = sequencesCountOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setSequencesCountOffset( DeviceSize sequencesCountOffset_ ) && VULKAN_HPP_NOEXCEPT + { + sequencesCountOffset = sequencesCountOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + sequencesIndexBuffer = sequencesIndexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + sequencesIndexBuffer = sequencesIndexBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ ) & VULKAN_HPP_NOEXCEPT + { + sequencesIndexOffset = sequencesIndexOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ ) && VULKAN_HPP_NOEXCEPT + { + sequencesIndexOffset = sequencesIndexOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGeneratedCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGeneratedCommandsInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + pipelineBindPoint, + pipeline, + indirectCommandsLayout, + streamCount, + pStreams, + sequencesCount, + preprocessBuffer, + preprocessOffset, + preprocessSize, + sequencesCountBuffer, + sequencesCountOffset, + sequencesIndexBuffer, + sequencesIndexOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GeneratedCommandsInfoNV const & ) const = default; +#else + bool operator==( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipeline == rhs.pipeline ) && + ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && ( streamCount == rhs.streamCount ) && ( pStreams == rhs.pStreams ) && + ( sequencesCount == rhs.sequencesCount ) && ( preprocessBuffer == rhs.preprocessBuffer ) && ( preprocessOffset == rhs.preprocessOffset ) && + ( preprocessSize == rhs.preprocessSize ) && ( sequencesCountBuffer == rhs.sequencesCountBuffer ) && + ( sequencesCountOffset == rhs.sequencesCountOffset ) && ( sequencesIndexBuffer == rhs.sequencesIndexBuffer ) && + ( sequencesIndexOffset == rhs.sequencesIndexOffset ); +# endif + } + + bool operator!=( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGeneratedCommandsInfoNV; + const void * pNext = {}; + PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; + Pipeline pipeline = {}; + IndirectCommandsLayoutNV indirectCommandsLayout = {}; + uint32_t streamCount = {}; + const IndirectCommandsStreamNV * pStreams = {}; + uint32_t sequencesCount = {}; + Buffer preprocessBuffer = {}; + DeviceSize preprocessOffset = {}; + DeviceSize preprocessSize = {}; + Buffer sequencesCountBuffer = {}; + DeviceSize sequencesCountOffset = {}; + Buffer sequencesIndexBuffer = {}; + DeviceSize sequencesIndexOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GeneratedCommandsInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = GeneratedCommandsInfoNV; + }; + + // wrapper struct for struct VkGeneratedCommandsMemoryRequirementsInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsMemoryRequirementsInfoEXT.html + struct GeneratedCommandsMemoryRequirementsInfoEXT + { + using NativeType = VkGeneratedCommandsMemoryRequirementsInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsMemoryRequirementsInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoEXT( IndirectExecutionSetEXT indirectExecutionSet_ = {}, + IndirectCommandsLayoutEXT indirectCommandsLayout_ = {}, + uint32_t maxSequenceCount_ = {}, + uint32_t maxDrawCount_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , indirectExecutionSet{ indirectExecutionSet_ } + , indirectCommandsLayout{ indirectCommandsLayout_ } + , maxSequenceCount{ maxSequenceCount_ } + , maxDrawCount{ maxDrawCount_ } + { + } + + VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoEXT( GeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GeneratedCommandsMemoryRequirementsInfoEXT( VkGeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : GeneratedCommandsMemoryRequirementsInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + GeneratedCommandsMemoryRequirementsInfoEXT & operator=( GeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GeneratedCommandsMemoryRequirementsInfoEXT & operator=( VkGeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT & setIndirectExecutionSet( IndirectExecutionSetEXT indirectExecutionSet_ ) & + VULKAN_HPP_NOEXCEPT + { + indirectExecutionSet = indirectExecutionSet_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT && setIndirectExecutionSet( IndirectExecutionSetEXT indirectExecutionSet_ ) && + VULKAN_HPP_NOEXCEPT + { + indirectExecutionSet = indirectExecutionSet_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT & setIndirectCommandsLayout( IndirectCommandsLayoutEXT indirectCommandsLayout_ ) & + VULKAN_HPP_NOEXCEPT + { + indirectCommandsLayout = indirectCommandsLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT && setIndirectCommandsLayout( IndirectCommandsLayoutEXT indirectCommandsLayout_ ) && + VULKAN_HPP_NOEXCEPT + { + indirectCommandsLayout = indirectCommandsLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT & setMaxSequenceCount( uint32_t maxSequenceCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxSequenceCount = maxSequenceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT && setMaxSequenceCount( uint32_t maxSequenceCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxSequenceCount = maxSequenceCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT & setMaxDrawCount( uint32_t maxDrawCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxDrawCount = maxDrawCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT && setMaxDrawCount( uint32_t maxDrawCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxDrawCount = maxDrawCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGeneratedCommandsMemoryRequirementsInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsMemoryRequirementsInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsMemoryRequirementsInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGeneratedCommandsMemoryRequirementsInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, indirectExecutionSet, indirectCommandsLayout, maxSequenceCount, maxDrawCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GeneratedCommandsMemoryRequirementsInfoEXT const & ) const = default; +#else + bool operator==( GeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indirectExecutionSet == rhs.indirectExecutionSet ) && + ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && ( maxSequenceCount == rhs.maxSequenceCount ) && ( maxDrawCount == rhs.maxDrawCount ); +# endif + } + + bool operator!=( GeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGeneratedCommandsMemoryRequirementsInfoEXT; + const void * pNext = {}; + IndirectExecutionSetEXT indirectExecutionSet = {}; + IndirectCommandsLayoutEXT indirectCommandsLayout = {}; + uint32_t maxSequenceCount = {}; + uint32_t maxDrawCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GeneratedCommandsMemoryRequirementsInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = GeneratedCommandsMemoryRequirementsInfoEXT; + }; + + // wrapper struct for struct VkGeneratedCommandsMemoryRequirementsInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html + struct GeneratedCommandsMemoryRequirementsInfoNV + { + using NativeType = VkGeneratedCommandsMemoryRequirementsInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsMemoryRequirementsInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoNV( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + Pipeline pipeline_ = {}, + IndirectCommandsLayoutNV indirectCommandsLayout_ = {}, + uint32_t maxSequencesCount_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineBindPoint{ pipelineBindPoint_ } + , pipeline{ pipeline_ } + , indirectCommandsLayout{ indirectCommandsLayout_ } + , maxSequencesCount{ maxSequencesCount_ } + { + } + + VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoNV( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GeneratedCommandsMemoryRequirementsInfoNV( VkGeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : GeneratedCommandsMemoryRequirementsInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + GeneratedCommandsMemoryRequirementsInfoNV & operator=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GeneratedCommandsMemoryRequirementsInfoNV & operator=( VkGeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV & setIndirectCommandsLayout( IndirectCommandsLayoutNV indirectCommandsLayout_ ) & + VULKAN_HPP_NOEXCEPT + { + indirectCommandsLayout = indirectCommandsLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV && setIndirectCommandsLayout( IndirectCommandsLayoutNV indirectCommandsLayout_ ) && + VULKAN_HPP_NOEXCEPT + { + indirectCommandsLayout = indirectCommandsLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV & setMaxSequencesCount( uint32_t maxSequencesCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxSequencesCount = maxSequencesCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV && setMaxSequencesCount( uint32_t maxSequencesCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxSequencesCount = maxSequencesCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGeneratedCommandsMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsMemoryRequirementsInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGeneratedCommandsMemoryRequirementsInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineBindPoint, pipeline, indirectCommandsLayout, maxSequencesCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GeneratedCommandsMemoryRequirementsInfoNV const & ) const = default; +#else + bool operator==( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipeline == rhs.pipeline ) && + ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && ( maxSequencesCount == rhs.maxSequencesCount ); +# endif + } + + bool operator!=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGeneratedCommandsMemoryRequirementsInfoNV; + const void * pNext = {}; + PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; + Pipeline pipeline = {}; + IndirectCommandsLayoutNV indirectCommandsLayout = {}; + uint32_t maxSequencesCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GeneratedCommandsMemoryRequirementsInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = GeneratedCommandsMemoryRequirementsInfoNV; + }; + + // wrapper struct for struct VkGeneratedCommandsPipelineInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsPipelineInfoEXT.html + struct GeneratedCommandsPipelineInfoEXT + { + using NativeType = VkGeneratedCommandsPipelineInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsPipelineInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GeneratedCommandsPipelineInfoEXT( Pipeline pipeline_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipeline{ pipeline_ } + { + } + + VULKAN_HPP_CONSTEXPR GeneratedCommandsPipelineInfoEXT( GeneratedCommandsPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GeneratedCommandsPipelineInfoEXT( VkGeneratedCommandsPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : GeneratedCommandsPipelineInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + GeneratedCommandsPipelineInfoEXT & operator=( GeneratedCommandsPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GeneratedCommandsPipelineInfoEXT & operator=( VkGeneratedCommandsPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsPipelineInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsPipelineInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsPipelineInfoEXT & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsPipelineInfoEXT && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGeneratedCommandsPipelineInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsPipelineInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsPipelineInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGeneratedCommandsPipelineInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipeline ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GeneratedCommandsPipelineInfoEXT const & ) const = default; +#else + bool operator==( GeneratedCommandsPipelineInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ); +# endif + } + + bool operator!=( GeneratedCommandsPipelineInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGeneratedCommandsPipelineInfoEXT; + void * pNext = {}; + Pipeline pipeline = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GeneratedCommandsPipelineInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = GeneratedCommandsPipelineInfoEXT; + }; + + // wrapper struct for struct VkGeneratedCommandsShaderInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsShaderInfoEXT.html + struct GeneratedCommandsShaderInfoEXT + { + using NativeType = VkGeneratedCommandsShaderInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsShaderInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + GeneratedCommandsShaderInfoEXT( uint32_t shaderCount_ = {}, const ShaderEXT * pShaders_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderCount{ shaderCount_ } + , pShaders{ pShaders_ } + { + } + + VULKAN_HPP_CONSTEXPR GeneratedCommandsShaderInfoEXT( GeneratedCommandsShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GeneratedCommandsShaderInfoEXT( VkGeneratedCommandsShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : GeneratedCommandsShaderInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GeneratedCommandsShaderInfoEXT( ArrayProxyNoTemporaries const & shaders_, void * pNext_ = nullptr ) + : pNext( pNext_ ), shaderCount( static_cast( shaders_.size() ) ), pShaders( shaders_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + GeneratedCommandsShaderInfoEXT & operator=( GeneratedCommandsShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GeneratedCommandsShaderInfoEXT & operator=( VkGeneratedCommandsShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT & setShaderCount( uint32_t shaderCount_ ) & VULKAN_HPP_NOEXCEPT + { + shaderCount = shaderCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT && setShaderCount( uint32_t shaderCount_ ) && VULKAN_HPP_NOEXCEPT + { + shaderCount = shaderCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT & setPShaders( const ShaderEXT * pShaders_ ) & VULKAN_HPP_NOEXCEPT + { + pShaders = pShaders_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT && setPShaders( const ShaderEXT * pShaders_ ) && VULKAN_HPP_NOEXCEPT + { + pShaders = pShaders_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GeneratedCommandsShaderInfoEXT & setShaders( ArrayProxyNoTemporaries const & shaders_ ) VULKAN_HPP_NOEXCEPT + { + shaderCount = static_cast( shaders_.size() ); + pShaders = shaders_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGeneratedCommandsShaderInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsShaderInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGeneratedCommandsShaderInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGeneratedCommandsShaderInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderCount, pShaders ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GeneratedCommandsShaderInfoEXT const & ) const = default; +#else + bool operator==( GeneratedCommandsShaderInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCount == rhs.shaderCount ) && ( pShaders == rhs.pShaders ); +# endif + } + + bool operator!=( GeneratedCommandsShaderInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGeneratedCommandsShaderInfoEXT; + void * pNext = {}; + uint32_t shaderCount = {}; + const ShaderEXT * pShaders = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GeneratedCommandsShaderInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = GeneratedCommandsShaderInfoEXT; + }; + + // wrapper struct for struct VkLatencyTimingsFrameReportNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencyTimingsFrameReportNV.html + struct LatencyTimingsFrameReportNV + { + using NativeType = VkLatencyTimingsFrameReportNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencyTimingsFrameReportNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR LatencyTimingsFrameReportNV( uint64_t presentID_ = {}, + uint64_t inputSampleTimeUs_ = {}, + uint64_t simStartTimeUs_ = {}, + uint64_t simEndTimeUs_ = {}, + uint64_t renderSubmitStartTimeUs_ = {}, + uint64_t renderSubmitEndTimeUs_ = {}, + uint64_t presentStartTimeUs_ = {}, + uint64_t presentEndTimeUs_ = {}, + uint64_t driverStartTimeUs_ = {}, + uint64_t driverEndTimeUs_ = {}, + uint64_t osRenderQueueStartTimeUs_ = {}, + uint64_t osRenderQueueEndTimeUs_ = {}, + uint64_t gpuRenderStartTimeUs_ = {}, + uint64_t gpuRenderEndTimeUs_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentID{ presentID_ } + , inputSampleTimeUs{ inputSampleTimeUs_ } + , simStartTimeUs{ simStartTimeUs_ } + , simEndTimeUs{ simEndTimeUs_ } + , renderSubmitStartTimeUs{ renderSubmitStartTimeUs_ } + , renderSubmitEndTimeUs{ renderSubmitEndTimeUs_ } + , presentStartTimeUs{ presentStartTimeUs_ } + , presentEndTimeUs{ presentEndTimeUs_ } + , driverStartTimeUs{ driverStartTimeUs_ } + , driverEndTimeUs{ driverEndTimeUs_ } + , osRenderQueueStartTimeUs{ osRenderQueueStartTimeUs_ } + , osRenderQueueEndTimeUs{ osRenderQueueEndTimeUs_ } + , gpuRenderStartTimeUs{ gpuRenderStartTimeUs_ } + , gpuRenderEndTimeUs{ gpuRenderEndTimeUs_ } + { + } + + VULKAN_HPP_CONSTEXPR LatencyTimingsFrameReportNV( LatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + LatencyTimingsFrameReportNV( VkLatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT + : LatencyTimingsFrameReportNV( *reinterpret_cast( &rhs ) ) + { + } + + LatencyTimingsFrameReportNV & operator=( LatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + LatencyTimingsFrameReportNV & operator=( VkLatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkLatencyTimingsFrameReportNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLatencyTimingsFrameReportNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLatencyTimingsFrameReportNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkLatencyTimingsFrameReportNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + presentID, + inputSampleTimeUs, + simStartTimeUs, + simEndTimeUs, + renderSubmitStartTimeUs, + renderSubmitEndTimeUs, + presentStartTimeUs, + presentEndTimeUs, + driverStartTimeUs, + driverEndTimeUs, + osRenderQueueStartTimeUs, + osRenderQueueEndTimeUs, + gpuRenderStartTimeUs, + gpuRenderEndTimeUs ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( LatencyTimingsFrameReportNV const & ) const = default; +#else + bool operator==( LatencyTimingsFrameReportNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID ) && ( inputSampleTimeUs == rhs.inputSampleTimeUs ) && + ( simStartTimeUs == rhs.simStartTimeUs ) && ( simEndTimeUs == rhs.simEndTimeUs ) && ( renderSubmitStartTimeUs == rhs.renderSubmitStartTimeUs ) && + ( renderSubmitEndTimeUs == rhs.renderSubmitEndTimeUs ) && ( presentStartTimeUs == rhs.presentStartTimeUs ) && + ( presentEndTimeUs == rhs.presentEndTimeUs ) && ( driverStartTimeUs == rhs.driverStartTimeUs ) && ( driverEndTimeUs == rhs.driverEndTimeUs ) && + ( osRenderQueueStartTimeUs == rhs.osRenderQueueStartTimeUs ) && ( osRenderQueueEndTimeUs == rhs.osRenderQueueEndTimeUs ) && + ( gpuRenderStartTimeUs == rhs.gpuRenderStartTimeUs ) && ( gpuRenderEndTimeUs == rhs.gpuRenderEndTimeUs ); +# endif + } + + bool operator!=( LatencyTimingsFrameReportNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eLatencyTimingsFrameReportNV; + void * pNext = {}; + uint64_t presentID = {}; + uint64_t inputSampleTimeUs = {}; + uint64_t simStartTimeUs = {}; + uint64_t simEndTimeUs = {}; + uint64_t renderSubmitStartTimeUs = {}; + uint64_t renderSubmitEndTimeUs = {}; + uint64_t presentStartTimeUs = {}; + uint64_t presentEndTimeUs = {}; + uint64_t driverStartTimeUs = {}; + uint64_t driverEndTimeUs = {}; + uint64_t osRenderQueueStartTimeUs = {}; + uint64_t osRenderQueueEndTimeUs = {}; + uint64_t gpuRenderStartTimeUs = {}; + uint64_t gpuRenderEndTimeUs = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = LatencyTimingsFrameReportNV; + }; +#endif + + template <> + struct CppType + { + using Type = LatencyTimingsFrameReportNV; + }; + + // wrapper struct for struct VkGetLatencyMarkerInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGetLatencyMarkerInfoNV.html + struct GetLatencyMarkerInfoNV + { + using NativeType = VkGetLatencyMarkerInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGetLatencyMarkerInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + GetLatencyMarkerInfoNV( uint32_t timingCount_ = {}, LatencyTimingsFrameReportNV * pTimings_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , timingCount{ timingCount_ } + , pTimings{ pTimings_ } + { + } + + VULKAN_HPP_CONSTEXPR GetLatencyMarkerInfoNV( GetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GetLatencyMarkerInfoNV( VkGetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : GetLatencyMarkerInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GetLatencyMarkerInfoNV( ArrayProxyNoTemporaries const & timings_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), timingCount( static_cast( timings_.size() ) ), pTimings( timings_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + GetLatencyMarkerInfoNV & operator=( GetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GetLatencyMarkerInfoNV & operator=( VkGetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV & setTimingCount( uint32_t timingCount_ ) & VULKAN_HPP_NOEXCEPT + { + timingCount = timingCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV && setTimingCount( uint32_t timingCount_ ) && VULKAN_HPP_NOEXCEPT + { + timingCount = timingCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV & setPTimings( LatencyTimingsFrameReportNV * pTimings_ ) & VULKAN_HPP_NOEXCEPT + { + pTimings = pTimings_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV && setPTimings( LatencyTimingsFrameReportNV * pTimings_ ) && VULKAN_HPP_NOEXCEPT + { + pTimings = pTimings_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GetLatencyMarkerInfoNV & setTimings( ArrayProxyNoTemporaries const & timings_ ) VULKAN_HPP_NOEXCEPT + { + timingCount = static_cast( timings_.size() ); + pTimings = timings_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGetLatencyMarkerInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGetLatencyMarkerInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGetLatencyMarkerInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGetLatencyMarkerInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, timingCount, pTimings ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GetLatencyMarkerInfoNV const & ) const = default; +#else + bool operator==( GetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timingCount == rhs.timingCount ) && ( pTimings == rhs.pTimings ); +# endif + } + + bool operator!=( GetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGetLatencyMarkerInfoNV; + const void * pNext = {}; + uint32_t timingCount = {}; + LatencyTimingsFrameReportNV * pTimings = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GetLatencyMarkerInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = GetLatencyMarkerInfoNV; + }; + + // wrapper struct for struct VkVertexInputBindingDescription, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputBindingDescription.html + struct VertexInputBindingDescription + { + using NativeType = VkVertexInputBindingDescription; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VertexInputBindingDescription( uint32_t binding_ = {}, uint32_t stride_ = {}, VertexInputRate inputRate_ = VertexInputRate::eVertex ) VULKAN_HPP_NOEXCEPT + : binding{ binding_ } + , stride{ stride_ } + , inputRate{ inputRate_ } + { + } + + VULKAN_HPP_CONSTEXPR VertexInputBindingDescription( VertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT + : VertexInputBindingDescription( *reinterpret_cast( &rhs ) ) + { + } + + VertexInputBindingDescription & operator=( VertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VertexInputBindingDescription & operator=( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription & setInputRate( VertexInputRate inputRate_ ) & VULKAN_HPP_NOEXCEPT + { + inputRate = inputRate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription && setInputRate( VertexInputRate inputRate_ ) && VULKAN_HPP_NOEXCEPT + { + inputRate = inputRate_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVertexInputBindingDescription const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputBindingDescription &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputBindingDescription const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVertexInputBindingDescription *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( binding, stride, inputRate ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VertexInputBindingDescription const & ) const = default; +#else + bool operator==( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( binding == rhs.binding ) && ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ); +# endif + } + + bool operator!=( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t binding = {}; + uint32_t stride = {}; + VertexInputRate inputRate = VertexInputRate::eVertex; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VertexInputBindingDescription; + }; +#endif + + // wrapper struct for struct VkVertexInputAttributeDescription, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputAttributeDescription.html + struct VertexInputAttributeDescription + { + using NativeType = VkVertexInputAttributeDescription; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription( uint32_t location_ = {}, + uint32_t binding_ = {}, + Format format_ = Format::eUndefined, + uint32_t offset_ = {} ) VULKAN_HPP_NOEXCEPT + : location{ location_ } + , binding{ binding_ } + , format{ format_ } + , offset{ offset_ } + { + } + + VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription( VertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT + : VertexInputAttributeDescription( *reinterpret_cast( &rhs ) ) + { + } + + VertexInputAttributeDescription & operator=( VertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VertexInputAttributeDescription & operator=( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription & setLocation( uint32_t location_ ) & VULKAN_HPP_NOEXCEPT + { + location = location_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription && setLocation( uint32_t location_ ) && VULKAN_HPP_NOEXCEPT + { + location = location_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVertexInputAttributeDescription const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputAttributeDescription &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputAttributeDescription const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVertexInputAttributeDescription *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( location, binding, format, offset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VertexInputAttributeDescription const & ) const = default; +#else + bool operator==( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( location == rhs.location ) && ( binding == rhs.binding ) && ( format == rhs.format ) && ( offset == rhs.offset ); +# endif + } + + bool operator!=( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t location = {}; + uint32_t binding = {}; + Format format = Format::eUndefined; + uint32_t offset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VertexInputAttributeDescription; + }; +#endif + + // wrapper struct for struct VkPipelineVertexInputStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineVertexInputStateCreateInfo.html + struct PipelineVertexInputStateCreateInfo + { + using NativeType = VkPipelineVertexInputStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineVertexInputStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = {}, + uint32_t vertexBindingDescriptionCount_ = {}, + const VertexInputBindingDescription * pVertexBindingDescriptions_ = {}, + uint32_t vertexAttributeDescriptionCount_ = {}, + const VertexInputAttributeDescription * pVertexAttributeDescriptions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , vertexBindingDescriptionCount{ vertexBindingDescriptionCount_ } + , pVertexBindingDescriptions{ pVertexBindingDescriptions_ } + , vertexAttributeDescriptionCount{ vertexAttributeDescriptionCount_ } + , pVertexAttributeDescriptions{ pVertexAttributeDescriptions_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineVertexInputStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_, + ArrayProxyNoTemporaries const & vertexBindingDescriptions_, + ArrayProxyNoTemporaries const & vertexAttributeDescriptions_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , vertexBindingDescriptionCount( static_cast( vertexBindingDescriptions_.size() ) ) + , pVertexBindingDescriptions( vertexBindingDescriptions_.data() ) + , vertexAttributeDescriptionCount( static_cast( vertexAttributeDescriptions_.size() ) ) + , pVertexAttributeDescriptions( vertexAttributeDescriptions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineVertexInputStateCreateInfo & operator=( PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineVertexInputStateCreateInfo & operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & setFlags( PipelineVertexInputStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && setFlags( PipelineVertexInputStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexBindingDescriptionCount = vertexBindingDescriptionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexBindingDescriptionCount = vertexBindingDescriptionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & + setPVertexBindingDescriptions( const VertexInputBindingDescription * pVertexBindingDescriptions_ ) & + VULKAN_HPP_NOEXCEPT + { + pVertexBindingDescriptions = pVertexBindingDescriptions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && + setPVertexBindingDescriptions( const VertexInputBindingDescription * pVertexBindingDescriptions_ ) && + VULKAN_HPP_NOEXCEPT + { + pVertexBindingDescriptions = pVertexBindingDescriptions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineVertexInputStateCreateInfo & + setVertexBindingDescriptions( ArrayProxyNoTemporaries const & vertexBindingDescriptions_ ) VULKAN_HPP_NOEXCEPT + { + vertexBindingDescriptionCount = static_cast( vertexBindingDescriptions_.size() ); + pVertexBindingDescriptions = vertexBindingDescriptions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & + setPVertexAttributeDescriptions( const VertexInputAttributeDescription * pVertexAttributeDescriptions_ ) & + VULKAN_HPP_NOEXCEPT + { + pVertexAttributeDescriptions = pVertexAttributeDescriptions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && + setPVertexAttributeDescriptions( const VertexInputAttributeDescription * pVertexAttributeDescriptions_ ) && + VULKAN_HPP_NOEXCEPT + { + pVertexAttributeDescriptions = pVertexAttributeDescriptions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineVertexInputStateCreateInfo & + setVertexAttributeDescriptions( ArrayProxyNoTemporaries const & vertexAttributeDescriptions_ ) VULKAN_HPP_NOEXCEPT + { + vertexAttributeDescriptionCount = static_cast( vertexAttributeDescriptions_.size() ); + pVertexAttributeDescriptions = vertexAttributeDescriptions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineVertexInputStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineVertexInputStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineVertexInputStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineVertexInputStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, flags, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineVertexInputStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount ) && ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions ) && + ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount ) && ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions ); +# endif + } + + bool operator!=( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo; + const void * pNext = {}; + PipelineVertexInputStateCreateFlags flags = {}; + uint32_t vertexBindingDescriptionCount = {}; + const VertexInputBindingDescription * pVertexBindingDescriptions = {}; + uint32_t vertexAttributeDescriptionCount = {}; + const VertexInputAttributeDescription * pVertexAttributeDescriptions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineVertexInputStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineVertexInputStateCreateInfo; + }; + + // wrapper struct for struct VkPipelineInputAssemblyStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineInputAssemblyStateCreateInfo.html + struct PipelineInputAssemblyStateCreateInfo + { + using NativeType = VkPipelineInputAssemblyStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineInputAssemblyStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = {}, + PrimitiveTopology topology_ = PrimitiveTopology::ePointList, + Bool32 primitiveRestartEnable_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , topology{ topology_ } + , primitiveRestartEnable{ primitiveRestartEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineInputAssemblyStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PipelineInputAssemblyStateCreateInfo & operator=( PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineInputAssemblyStateCreateInfo & operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo & setFlags( PipelineInputAssemblyStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo && setFlags( PipelineInputAssemblyStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo & setTopology( PrimitiveTopology topology_ ) & VULKAN_HPP_NOEXCEPT + { + topology = topology_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo && setTopology( PrimitiveTopology topology_ ) && VULKAN_HPP_NOEXCEPT + { + topology = topology_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo & setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ ) & VULKAN_HPP_NOEXCEPT + { + primitiveRestartEnable = primitiveRestartEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo && setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ ) && VULKAN_HPP_NOEXCEPT + { + primitiveRestartEnable = primitiveRestartEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineInputAssemblyStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineInputAssemblyStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineInputAssemblyStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineInputAssemblyStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, topology, primitiveRestartEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineInputAssemblyStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( topology == rhs.topology ) && + ( primitiveRestartEnable == rhs.primitiveRestartEnable ); +# endif + } + + bool operator!=( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo; + const void * pNext = {}; + PipelineInputAssemblyStateCreateFlags flags = {}; + PrimitiveTopology topology = PrimitiveTopology::ePointList; + Bool32 primitiveRestartEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineInputAssemblyStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineInputAssemblyStateCreateInfo; + }; + + // wrapper struct for struct VkPipelineTessellationStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineTessellationStateCreateInfo.html + struct PipelineTessellationStateCreateInfo + { + using NativeType = VkPipelineTessellationStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineTessellationStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = {}, + uint32_t patchControlPoints_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , patchControlPoints{ patchControlPoints_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineTessellationStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PipelineTessellationStateCreateInfo & operator=( PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineTessellationStateCreateInfo & operator=( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo & setFlags( PipelineTessellationStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo && setFlags( PipelineTessellationStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo & setPatchControlPoints( uint32_t patchControlPoints_ ) & VULKAN_HPP_NOEXCEPT + { + patchControlPoints = patchControlPoints_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo && setPatchControlPoints( uint32_t patchControlPoints_ ) && VULKAN_HPP_NOEXCEPT + { + patchControlPoints = patchControlPoints_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineTessellationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineTessellationStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineTessellationStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineTessellationStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, patchControlPoints ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineTessellationStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( patchControlPoints == rhs.patchControlPoints ); +# endif + } + + bool operator!=( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineTessellationStateCreateInfo; + const void * pNext = {}; + PipelineTessellationStateCreateFlags flags = {}; + uint32_t patchControlPoints = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineTessellationStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineTessellationStateCreateInfo; + }; + + // wrapper struct for struct VkPipelineViewportStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportStateCreateInfo.html + struct PipelineViewportStateCreateInfo + { + using NativeType = VkPipelineViewportStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = {}, + uint32_t viewportCount_ = {}, + const Viewport * pViewports_ = {}, + uint32_t scissorCount_ = {}, + const Rect2D * pScissors_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , viewportCount{ viewportCount_ } + , pViewports{ pViewports_ } + , scissorCount{ scissorCount_ } + , pScissors{ pScissors_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineViewportStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_, + ArrayProxyNoTemporaries const & viewports_, + ArrayProxyNoTemporaries const & scissors_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , viewportCount( static_cast( viewports_.size() ) ) + , pViewports( viewports_.data() ) + , scissorCount( static_cast( scissors_.size() ) ) + , pScissors( scissors_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineViewportStateCreateInfo & operator=( PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineViewportStateCreateInfo & operator=( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setFlags( PipelineViewportStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setFlags( PipelineViewportStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setViewportCount( uint32_t viewportCount_ ) & VULKAN_HPP_NOEXCEPT + { + viewportCount = viewportCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setViewportCount( uint32_t viewportCount_ ) && VULKAN_HPP_NOEXCEPT + { + viewportCount = viewportCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setPViewports( const Viewport * pViewports_ ) & VULKAN_HPP_NOEXCEPT + { + pViewports = pViewports_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setPViewports( const Viewport * pViewports_ ) && VULKAN_HPP_NOEXCEPT + { + pViewports = pViewports_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportStateCreateInfo & setViewports( ArrayProxyNoTemporaries const & viewports_ ) VULKAN_HPP_NOEXCEPT + { + viewportCount = static_cast( viewports_.size() ); + pViewports = viewports_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setScissorCount( uint32_t scissorCount_ ) & VULKAN_HPP_NOEXCEPT + { + scissorCount = scissorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setScissorCount( uint32_t scissorCount_ ) && VULKAN_HPP_NOEXCEPT + { + scissorCount = scissorCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setPScissors( const Rect2D * pScissors_ ) & VULKAN_HPP_NOEXCEPT + { + pScissors = pScissors_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setPScissors( const Rect2D * pScissors_ ) && VULKAN_HPP_NOEXCEPT + { + pScissors = pScissors_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportStateCreateInfo & setScissors( ArrayProxyNoTemporaries const & scissors_ ) VULKAN_HPP_NOEXCEPT + { + scissorCount = static_cast( scissors_.size() ); + pScissors = scissors_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineViewportStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineViewportStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, viewportCount, pViewports, scissorCount, pScissors ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineViewportStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( viewportCount == rhs.viewportCount ) && + ( pViewports == rhs.pViewports ) && ( scissorCount == rhs.scissorCount ) && ( pScissors == rhs.pScissors ); +# endif + } + + bool operator!=( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineViewportStateCreateInfo; + const void * pNext = {}; + PipelineViewportStateCreateFlags flags = {}; + uint32_t viewportCount = {}; + const Viewport * pViewports = {}; + uint32_t scissorCount = {}; + const Rect2D * pScissors = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineViewportStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineViewportStateCreateInfo; + }; + + // wrapper struct for struct VkPipelineRasterizationStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateCreateInfo.html + struct PipelineRasterizationStateCreateInfo + { + using NativeType = VkPipelineRasterizationStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateFlags flags_ = {}, + Bool32 depthClampEnable_ = {}, + Bool32 rasterizerDiscardEnable_ = {}, + PolygonMode polygonMode_ = PolygonMode::eFill, + CullModeFlags cullMode_ = {}, + FrontFace frontFace_ = FrontFace::eCounterClockwise, + Bool32 depthBiasEnable_ = {}, + float depthBiasConstantFactor_ = {}, + float depthBiasClamp_ = {}, + float depthBiasSlopeFactor_ = {}, + float lineWidth_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , depthClampEnable{ depthClampEnable_ } + , rasterizerDiscardEnable{ rasterizerDiscardEnable_ } + , polygonMode{ polygonMode_ } + , cullMode{ cullMode_ } + , frontFace{ frontFace_ } + , depthBiasEnable{ depthBiasEnable_ } + , depthBiasConstantFactor{ depthBiasConstantFactor_ } + , depthBiasClamp{ depthBiasClamp_ } + , depthBiasSlopeFactor{ depthBiasSlopeFactor_ } + , lineWidth{ lineWidth_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineRasterizationStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PipelineRasterizationStateCreateInfo & operator=( PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineRasterizationStateCreateInfo & operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setFlags( PipelineRasterizationStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setFlags( PipelineRasterizationStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setDepthClampEnable( Bool32 depthClampEnable_ ) & VULKAN_HPP_NOEXCEPT + { + depthClampEnable = depthClampEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setDepthClampEnable( Bool32 depthClampEnable_ ) && VULKAN_HPP_NOEXCEPT + { + depthClampEnable = depthClampEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ ) & VULKAN_HPP_NOEXCEPT + { + rasterizerDiscardEnable = rasterizerDiscardEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ ) && VULKAN_HPP_NOEXCEPT + { + rasterizerDiscardEnable = rasterizerDiscardEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setPolygonMode( PolygonMode polygonMode_ ) & VULKAN_HPP_NOEXCEPT + { + polygonMode = polygonMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setPolygonMode( PolygonMode polygonMode_ ) && VULKAN_HPP_NOEXCEPT + { + polygonMode = polygonMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setCullMode( CullModeFlags cullMode_ ) & VULKAN_HPP_NOEXCEPT + { + cullMode = cullMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setCullMode( CullModeFlags cullMode_ ) && VULKAN_HPP_NOEXCEPT + { + cullMode = cullMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setFrontFace( FrontFace frontFace_ ) & VULKAN_HPP_NOEXCEPT + { + frontFace = frontFace_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setFrontFace( FrontFace frontFace_ ) && VULKAN_HPP_NOEXCEPT + { + frontFace = frontFace_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setDepthBiasEnable( Bool32 depthBiasEnable_ ) & VULKAN_HPP_NOEXCEPT + { + depthBiasEnable = depthBiasEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setDepthBiasEnable( Bool32 depthBiasEnable_ ) && VULKAN_HPP_NOEXCEPT + { + depthBiasEnable = depthBiasEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) & VULKAN_HPP_NOEXCEPT + { + depthBiasConstantFactor = depthBiasConstantFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) && VULKAN_HPP_NOEXCEPT + { + depthBiasConstantFactor = depthBiasConstantFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setDepthBiasClamp( float depthBiasClamp_ ) & VULKAN_HPP_NOEXCEPT + { + depthBiasClamp = depthBiasClamp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setDepthBiasClamp( float depthBiasClamp_ ) && VULKAN_HPP_NOEXCEPT + { + depthBiasClamp = depthBiasClamp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) & VULKAN_HPP_NOEXCEPT + { + depthBiasSlopeFactor = depthBiasSlopeFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) && VULKAN_HPP_NOEXCEPT + { + depthBiasSlopeFactor = depthBiasSlopeFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setLineWidth( float lineWidth_ ) & VULKAN_HPP_NOEXCEPT + { + lineWidth = lineWidth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setLineWidth( float lineWidth_ ) && VULKAN_HPP_NOEXCEPT + { + lineWidth = lineWidth_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineRasterizationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + depthClampEnable, + rasterizerDiscardEnable, + polygonMode, + cullMode, + frontFace, + depthBiasEnable, + depthBiasConstantFactor, + depthBiasClamp, + depthBiasSlopeFactor, + lineWidth ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineRasterizationStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( depthClampEnable == rhs.depthClampEnable ) && + ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable ) && ( polygonMode == rhs.polygonMode ) && ( cullMode == rhs.cullMode ) && + ( frontFace == rhs.frontFace ) && ( depthBiasEnable == rhs.depthBiasEnable ) && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) && + ( depthBiasClamp == rhs.depthBiasClamp ) && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor ) && ( lineWidth == rhs.lineWidth ); +# endif + } + + bool operator!=( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo; + const void * pNext = {}; + PipelineRasterizationStateCreateFlags flags = {}; + Bool32 depthClampEnable = {}; + Bool32 rasterizerDiscardEnable = {}; + PolygonMode polygonMode = PolygonMode::eFill; + CullModeFlags cullMode = {}; + FrontFace frontFace = FrontFace::eCounterClockwise; + Bool32 depthBiasEnable = {}; + float depthBiasConstantFactor = {}; + float depthBiasClamp = {}; + float depthBiasSlopeFactor = {}; + float lineWidth = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineRasterizationStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineRasterizationStateCreateInfo; + }; + + // wrapper struct for struct VkPipelineMultisampleStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineMultisampleStateCreateInfo.html + struct PipelineMultisampleStateCreateInfo + { + using NativeType = VkPipelineMultisampleStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineMultisampleStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = {}, + SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, + Bool32 sampleShadingEnable_ = {}, + float minSampleShading_ = {}, + const SampleMask * pSampleMask_ = {}, + Bool32 alphaToCoverageEnable_ = {}, + Bool32 alphaToOneEnable_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , rasterizationSamples{ rasterizationSamples_ } + , sampleShadingEnable{ sampleShadingEnable_ } + , minSampleShading{ minSampleShading_ } + , pSampleMask{ pSampleMask_ } + , alphaToCoverageEnable{ alphaToCoverageEnable_ } + , alphaToOneEnable{ alphaToOneEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineMultisampleStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PipelineMultisampleStateCreateInfo & operator=( PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineMultisampleStateCreateInfo & operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setFlags( PipelineMultisampleStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setFlags( PipelineMultisampleStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) & VULKAN_HPP_NOEXCEPT + { + rasterizationSamples = rasterizationSamples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) && VULKAN_HPP_NOEXCEPT + { + rasterizationSamples = rasterizationSamples_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setSampleShadingEnable( Bool32 sampleShadingEnable_ ) & VULKAN_HPP_NOEXCEPT + { + sampleShadingEnable = sampleShadingEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setSampleShadingEnable( Bool32 sampleShadingEnable_ ) && VULKAN_HPP_NOEXCEPT + { + sampleShadingEnable = sampleShadingEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setMinSampleShading( float minSampleShading_ ) & VULKAN_HPP_NOEXCEPT + { + minSampleShading = minSampleShading_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setMinSampleShading( float minSampleShading_ ) && VULKAN_HPP_NOEXCEPT + { + minSampleShading = minSampleShading_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setPSampleMask( const SampleMask * pSampleMask_ ) & VULKAN_HPP_NOEXCEPT + { + pSampleMask = pSampleMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setPSampleMask( const SampleMask * pSampleMask_ ) && VULKAN_HPP_NOEXCEPT + { + pSampleMask = pSampleMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ ) & VULKAN_HPP_NOEXCEPT + { + alphaToCoverageEnable = alphaToCoverageEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ ) && VULKAN_HPP_NOEXCEPT + { + alphaToCoverageEnable = alphaToCoverageEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setAlphaToOneEnable( Bool32 alphaToOneEnable_ ) & VULKAN_HPP_NOEXCEPT + { + alphaToOneEnable = alphaToOneEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setAlphaToOneEnable( Bool32 alphaToOneEnable_ ) && VULKAN_HPP_NOEXCEPT + { + alphaToOneEnable = alphaToOneEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineMultisampleStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineMultisampleStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineMultisampleStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineMultisampleStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, rasterizationSamples, sampleShadingEnable, minSampleShading, pSampleMask, alphaToCoverageEnable, alphaToOneEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineMultisampleStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rasterizationSamples == rhs.rasterizationSamples ) && + ( sampleShadingEnable == rhs.sampleShadingEnable ) && ( minSampleShading == rhs.minSampleShading ) && ( pSampleMask == rhs.pSampleMask ) && + ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) && ( alphaToOneEnable == rhs.alphaToOneEnable ); +# endif + } + + bool operator!=( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo; + const void * pNext = {}; + PipelineMultisampleStateCreateFlags flags = {}; + SampleCountFlagBits rasterizationSamples = SampleCountFlagBits::e1; + Bool32 sampleShadingEnable = {}; + float minSampleShading = {}; + const SampleMask * pSampleMask = {}; + Bool32 alphaToCoverageEnable = {}; + Bool32 alphaToOneEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineMultisampleStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineMultisampleStateCreateInfo; + }; + + // wrapper struct for struct VkStencilOpState, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilOpState.html + struct StencilOpState + { + using NativeType = VkStencilOpState; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR StencilOpState( StencilOp failOp_ = StencilOp::eKeep, + StencilOp passOp_ = StencilOp::eKeep, + StencilOp depthFailOp_ = StencilOp::eKeep, + CompareOp compareOp_ = CompareOp::eNever, + uint32_t compareMask_ = {}, + uint32_t writeMask_ = {}, + uint32_t reference_ = {} ) VULKAN_HPP_NOEXCEPT + : failOp{ failOp_ } + , passOp{ passOp_ } + , depthFailOp{ depthFailOp_ } + , compareOp{ compareOp_ } + , compareMask{ compareMask_ } + , writeMask{ writeMask_ } + , reference{ reference_ } + { + } + + VULKAN_HPP_CONSTEXPR StencilOpState( StencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + StencilOpState( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT : StencilOpState( *reinterpret_cast( &rhs ) ) {} + + StencilOpState & operator=( StencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + StencilOpState & operator=( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 StencilOpState & setFailOp( StencilOp failOp_ ) & VULKAN_HPP_NOEXCEPT + { + failOp = failOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState && setFailOp( StencilOp failOp_ ) && VULKAN_HPP_NOEXCEPT + { + failOp = failOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState & setPassOp( StencilOp passOp_ ) & VULKAN_HPP_NOEXCEPT + { + passOp = passOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState && setPassOp( StencilOp passOp_ ) && VULKAN_HPP_NOEXCEPT + { + passOp = passOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState & setDepthFailOp( StencilOp depthFailOp_ ) & VULKAN_HPP_NOEXCEPT + { + depthFailOp = depthFailOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState && setDepthFailOp( StencilOp depthFailOp_ ) && VULKAN_HPP_NOEXCEPT + { + depthFailOp = depthFailOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState & setCompareOp( CompareOp compareOp_ ) & VULKAN_HPP_NOEXCEPT + { + compareOp = compareOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState && setCompareOp( CompareOp compareOp_ ) && VULKAN_HPP_NOEXCEPT + { + compareOp = compareOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState & setCompareMask( uint32_t compareMask_ ) & VULKAN_HPP_NOEXCEPT + { + compareMask = compareMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState && setCompareMask( uint32_t compareMask_ ) && VULKAN_HPP_NOEXCEPT + { + compareMask = compareMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState & setWriteMask( uint32_t writeMask_ ) & VULKAN_HPP_NOEXCEPT + { + writeMask = writeMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState && setWriteMask( uint32_t writeMask_ ) && VULKAN_HPP_NOEXCEPT + { + writeMask = writeMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState & setReference( uint32_t reference_ ) & VULKAN_HPP_NOEXCEPT + { + reference = reference_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StencilOpState && setReference( uint32_t reference_ ) && VULKAN_HPP_NOEXCEPT + { + reference = reference_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkStencilOpState const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStencilOpState &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStencilOpState const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkStencilOpState *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( failOp, passOp, depthFailOp, compareOp, compareMask, writeMask, reference ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( StencilOpState const & ) const = default; +#else + bool operator==( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( failOp == rhs.failOp ) && ( passOp == rhs.passOp ) && ( depthFailOp == rhs.depthFailOp ) && ( compareOp == rhs.compareOp ) && + ( compareMask == rhs.compareMask ) && ( writeMask == rhs.writeMask ) && ( reference == rhs.reference ); +# endif + } + + bool operator!=( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StencilOp failOp = StencilOp::eKeep; + StencilOp passOp = StencilOp::eKeep; + StencilOp depthFailOp = StencilOp::eKeep; + CompareOp compareOp = CompareOp::eNever; + uint32_t compareMask = {}; + uint32_t writeMask = {}; + uint32_t reference = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = StencilOpState; + }; +#endif + + // wrapper struct for struct VkPipelineDepthStencilStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDepthStencilStateCreateInfo.html + struct PipelineDepthStencilStateCreateInfo + { + using NativeType = VkPipelineDepthStencilStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDepthStencilStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateFlags flags_ = {}, + Bool32 depthTestEnable_ = {}, + Bool32 depthWriteEnable_ = {}, + CompareOp depthCompareOp_ = CompareOp::eNever, + Bool32 depthBoundsTestEnable_ = {}, + Bool32 stencilTestEnable_ = {}, + StencilOpState front_ = {}, + StencilOpState back_ = {}, + float minDepthBounds_ = {}, + float maxDepthBounds_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , depthTestEnable{ depthTestEnable_ } + , depthWriteEnable{ depthWriteEnable_ } + , depthCompareOp{ depthCompareOp_ } + , depthBoundsTestEnable{ depthBoundsTestEnable_ } + , stencilTestEnable{ stencilTestEnable_ } + , front{ front_ } + , back{ back_ } + , minDepthBounds{ minDepthBounds_ } + , maxDepthBounds{ maxDepthBounds_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineDepthStencilStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PipelineDepthStencilStateCreateInfo & operator=( PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineDepthStencilStateCreateInfo & operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setFlags( PipelineDepthStencilStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setFlags( PipelineDepthStencilStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setDepthTestEnable( Bool32 depthTestEnable_ ) & VULKAN_HPP_NOEXCEPT + { + depthTestEnable = depthTestEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setDepthTestEnable( Bool32 depthTestEnable_ ) && VULKAN_HPP_NOEXCEPT + { + depthTestEnable = depthTestEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setDepthWriteEnable( Bool32 depthWriteEnable_ ) & VULKAN_HPP_NOEXCEPT + { + depthWriteEnable = depthWriteEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setDepthWriteEnable( Bool32 depthWriteEnable_ ) && VULKAN_HPP_NOEXCEPT + { + depthWriteEnable = depthWriteEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setDepthCompareOp( CompareOp depthCompareOp_ ) & VULKAN_HPP_NOEXCEPT + { + depthCompareOp = depthCompareOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setDepthCompareOp( CompareOp depthCompareOp_ ) && VULKAN_HPP_NOEXCEPT + { + depthCompareOp = depthCompareOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ ) & VULKAN_HPP_NOEXCEPT + { + depthBoundsTestEnable = depthBoundsTestEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ ) && VULKAN_HPP_NOEXCEPT + { + depthBoundsTestEnable = depthBoundsTestEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setStencilTestEnable( Bool32 stencilTestEnable_ ) & VULKAN_HPP_NOEXCEPT + { + stencilTestEnable = stencilTestEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setStencilTestEnable( Bool32 stencilTestEnable_ ) && VULKAN_HPP_NOEXCEPT + { + stencilTestEnable = stencilTestEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setFront( StencilOpState const & front_ ) & VULKAN_HPP_NOEXCEPT + { + front = front_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setFront( StencilOpState const & front_ ) && VULKAN_HPP_NOEXCEPT + { + front = front_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setBack( StencilOpState const & back_ ) & VULKAN_HPP_NOEXCEPT + { + back = back_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setBack( StencilOpState const & back_ ) && VULKAN_HPP_NOEXCEPT + { + back = back_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setMinDepthBounds( float minDepthBounds_ ) & VULKAN_HPP_NOEXCEPT + { + minDepthBounds = minDepthBounds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setMinDepthBounds( float minDepthBounds_ ) && VULKAN_HPP_NOEXCEPT + { + minDepthBounds = minDepthBounds_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setMaxDepthBounds( float maxDepthBounds_ ) & VULKAN_HPP_NOEXCEPT + { + maxDepthBounds = maxDepthBounds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setMaxDepthBounds( float maxDepthBounds_ ) && VULKAN_HPP_NOEXCEPT + { + maxDepthBounds = maxDepthBounds_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineDepthStencilStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineDepthStencilStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineDepthStencilStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineDepthStencilStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + depthTestEnable, + depthWriteEnable, + depthCompareOp, + depthBoundsTestEnable, + stencilTestEnable, + front, + back, + minDepthBounds, + maxDepthBounds ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineDepthStencilStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( depthTestEnable == rhs.depthTestEnable ) && + ( depthWriteEnable == rhs.depthWriteEnable ) && ( depthCompareOp == rhs.depthCompareOp ) && + ( depthBoundsTestEnable == rhs.depthBoundsTestEnable ) && ( stencilTestEnable == rhs.stencilTestEnable ) && ( front == rhs.front ) && + ( back == rhs.back ) && ( minDepthBounds == rhs.minDepthBounds ) && ( maxDepthBounds == rhs.maxDepthBounds ); +# endif + } + + bool operator!=( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo; + const void * pNext = {}; + PipelineDepthStencilStateCreateFlags flags = {}; + Bool32 depthTestEnable = {}; + Bool32 depthWriteEnable = {}; + CompareOp depthCompareOp = CompareOp::eNever; + Bool32 depthBoundsTestEnable = {}; + Bool32 stencilTestEnable = {}; + StencilOpState front = {}; + StencilOpState back = {}; + float minDepthBounds = {}; + float maxDepthBounds = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineDepthStencilStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineDepthStencilStateCreateInfo; + }; + + // wrapper struct for struct VkPipelineColorBlendAttachmentState, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendAttachmentState.html + struct PipelineColorBlendAttachmentState + { + using NativeType = VkPipelineColorBlendAttachmentState; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( Bool32 blendEnable_ = {}, + BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, + BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, + BlendOp colorBlendOp_ = BlendOp::eAdd, + BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, + BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, + BlendOp alphaBlendOp_ = BlendOp::eAdd, + ColorComponentFlags colorWriteMask_ = {} ) VULKAN_HPP_NOEXCEPT + : blendEnable{ blendEnable_ } + , srcColorBlendFactor{ srcColorBlendFactor_ } + , dstColorBlendFactor{ dstColorBlendFactor_ } + , colorBlendOp{ colorBlendOp_ } + , srcAlphaBlendFactor{ srcAlphaBlendFactor_ } + , dstAlphaBlendFactor{ dstAlphaBlendFactor_ } + , alphaBlendOp{ alphaBlendOp_ } + , colorWriteMask{ colorWriteMask_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( PipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineColorBlendAttachmentState( *reinterpret_cast( &rhs ) ) + { + } + + PipelineColorBlendAttachmentState & operator=( PipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineColorBlendAttachmentState & operator=( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setBlendEnable( Bool32 blendEnable_ ) & VULKAN_HPP_NOEXCEPT + { + blendEnable = blendEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setBlendEnable( Bool32 blendEnable_ ) && VULKAN_HPP_NOEXCEPT + { + blendEnable = blendEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) & VULKAN_HPP_NOEXCEPT + { + srcColorBlendFactor = srcColorBlendFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) && VULKAN_HPP_NOEXCEPT + { + srcColorBlendFactor = srcColorBlendFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) & VULKAN_HPP_NOEXCEPT + { + dstColorBlendFactor = dstColorBlendFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) && VULKAN_HPP_NOEXCEPT + { + dstColorBlendFactor = dstColorBlendFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setColorBlendOp( BlendOp colorBlendOp_ ) & VULKAN_HPP_NOEXCEPT + { + colorBlendOp = colorBlendOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setColorBlendOp( BlendOp colorBlendOp_ ) && VULKAN_HPP_NOEXCEPT + { + colorBlendOp = colorBlendOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) & VULKAN_HPP_NOEXCEPT + { + srcAlphaBlendFactor = srcAlphaBlendFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) && VULKAN_HPP_NOEXCEPT + { + srcAlphaBlendFactor = srcAlphaBlendFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) & VULKAN_HPP_NOEXCEPT + { + dstAlphaBlendFactor = dstAlphaBlendFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) && VULKAN_HPP_NOEXCEPT + { + dstAlphaBlendFactor = dstAlphaBlendFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setAlphaBlendOp( BlendOp alphaBlendOp_ ) & VULKAN_HPP_NOEXCEPT + { + alphaBlendOp = alphaBlendOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setAlphaBlendOp( BlendOp alphaBlendOp_ ) && VULKAN_HPP_NOEXCEPT + { + alphaBlendOp = alphaBlendOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setColorWriteMask( ColorComponentFlags colorWriteMask_ ) & VULKAN_HPP_NOEXCEPT + { + colorWriteMask = colorWriteMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setColorWriteMask( ColorComponentFlags colorWriteMask_ ) && VULKAN_HPP_NOEXCEPT + { + colorWriteMask = colorWriteMask_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineColorBlendAttachmentState const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineColorBlendAttachmentState &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineColorBlendAttachmentState const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineColorBlendAttachmentState *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + blendEnable, srcColorBlendFactor, dstColorBlendFactor, colorBlendOp, srcAlphaBlendFactor, dstAlphaBlendFactor, alphaBlendOp, colorWriteMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineColorBlendAttachmentState const & ) const = default; +#else + bool operator==( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( blendEnable == rhs.blendEnable ) && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) && ( dstColorBlendFactor == rhs.dstColorBlendFactor ) && + ( colorBlendOp == rhs.colorBlendOp ) && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) && + ( alphaBlendOp == rhs.alphaBlendOp ) && ( colorWriteMask == rhs.colorWriteMask ); +# endif + } + + bool operator!=( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Bool32 blendEnable = {}; + BlendFactor srcColorBlendFactor = BlendFactor::eZero; + BlendFactor dstColorBlendFactor = BlendFactor::eZero; + BlendOp colorBlendOp = BlendOp::eAdd; + BlendFactor srcAlphaBlendFactor = BlendFactor::eZero; + BlendFactor dstAlphaBlendFactor = BlendFactor::eZero; + BlendOp alphaBlendOp = BlendOp::eAdd; + ColorComponentFlags colorWriteMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineColorBlendAttachmentState; + }; +#endif + + // wrapper struct for struct VkPipelineColorBlendStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendStateCreateInfo.html + struct PipelineColorBlendStateCreateInfo + { + using NativeType = VkPipelineColorBlendStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineColorBlendStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = {}, + Bool32 logicOpEnable_ = {}, + LogicOp logicOp_ = LogicOp::eClear, + uint32_t attachmentCount_ = {}, + const PipelineColorBlendAttachmentState * pAttachments_ = {}, + std::array const & blendConstants_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , logicOpEnable{ logicOpEnable_ } + , logicOp{ logicOp_ } + , attachmentCount{ attachmentCount_ } + , pAttachments{ pAttachments_ } + , blendConstants{ blendConstants_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineColorBlendStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_, + Bool32 logicOpEnable_, + LogicOp logicOp_, + ArrayProxyNoTemporaries const & attachments_, + std::array const & blendConstants_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , logicOpEnable( logicOpEnable_ ) + , logicOp( logicOp_ ) + , attachmentCount( static_cast( attachments_.size() ) ) + , pAttachments( attachments_.data() ) + , blendConstants( blendConstants_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineColorBlendStateCreateInfo & operator=( PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineColorBlendStateCreateInfo & operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setFlags( PipelineColorBlendStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setFlags( PipelineColorBlendStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setLogicOpEnable( Bool32 logicOpEnable_ ) & VULKAN_HPP_NOEXCEPT + { + logicOpEnable = logicOpEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setLogicOpEnable( Bool32 logicOpEnable_ ) && VULKAN_HPP_NOEXCEPT + { + logicOpEnable = logicOpEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setLogicOp( LogicOp logicOp_ ) & VULKAN_HPP_NOEXCEPT + { + logicOp = logicOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setLogicOp( LogicOp logicOp_ ) && VULKAN_HPP_NOEXCEPT + { + logicOp = logicOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setPAttachments( const PipelineColorBlendAttachmentState * pAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pAttachments = pAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setPAttachments( const PipelineColorBlendAttachmentState * pAttachments_ ) && + VULKAN_HPP_NOEXCEPT + { + pAttachments = pAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineColorBlendStateCreateInfo & + setAttachments( ArrayProxyNoTemporaries const & attachments_ ) VULKAN_HPP_NOEXCEPT + { + attachmentCount = static_cast( attachments_.size() ); + pAttachments = attachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setBlendConstants( std::array blendConstants_ ) & VULKAN_HPP_NOEXCEPT + { + blendConstants = blendConstants_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setBlendConstants( std::array blendConstants_ ) && VULKAN_HPP_NOEXCEPT + { + blendConstants = blendConstants_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineColorBlendStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineColorBlendStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineColorBlendStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineColorBlendStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, logicOpEnable, logicOp, attachmentCount, pAttachments, blendConstants ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineColorBlendStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( logicOpEnable == rhs.logicOpEnable ) && + ( logicOp == rhs.logicOp ) && ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) && + ( blendConstants == rhs.blendConstants ); +# endif + } + + bool operator!=( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo; + const void * pNext = {}; + PipelineColorBlendStateCreateFlags flags = {}; + Bool32 logicOpEnable = {}; + LogicOp logicOp = LogicOp::eClear; + uint32_t attachmentCount = {}; + const PipelineColorBlendAttachmentState * pAttachments = {}; + ArrayWrapper1D blendConstants = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineColorBlendStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineColorBlendStateCreateInfo; + }; + + // wrapper struct for struct VkPipelineDynamicStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDynamicStateCreateInfo.html + struct PipelineDynamicStateCreateInfo + { + using NativeType = VkPipelineDynamicStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDynamicStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = {}, + uint32_t dynamicStateCount_ = {}, + const DynamicState * pDynamicStates_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , dynamicStateCount{ dynamicStateCount_ } + , pDynamicStates{ pDynamicStates_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineDynamicStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_, + ArrayProxyNoTemporaries const & dynamicStates_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), flags( flags_ ), dynamicStateCount( static_cast( dynamicStates_.size() ) ), pDynamicStates( dynamicStates_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineDynamicStateCreateInfo & operator=( PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineDynamicStateCreateInfo & operator=( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo & setFlags( PipelineDynamicStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo && setFlags( PipelineDynamicStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo & setDynamicStateCount( uint32_t dynamicStateCount_ ) & VULKAN_HPP_NOEXCEPT + { + dynamicStateCount = dynamicStateCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo && setDynamicStateCount( uint32_t dynamicStateCount_ ) && VULKAN_HPP_NOEXCEPT + { + dynamicStateCount = dynamicStateCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo & setPDynamicStates( const DynamicState * pDynamicStates_ ) & VULKAN_HPP_NOEXCEPT + { + pDynamicStates = pDynamicStates_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo && setPDynamicStates( const DynamicState * pDynamicStates_ ) && VULKAN_HPP_NOEXCEPT + { + pDynamicStates = pDynamicStates_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineDynamicStateCreateInfo & setDynamicStates( ArrayProxyNoTemporaries const & dynamicStates_ ) VULKAN_HPP_NOEXCEPT + { + dynamicStateCount = static_cast( dynamicStates_.size() ); + pDynamicStates = dynamicStates_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineDynamicStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineDynamicStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineDynamicStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineDynamicStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, dynamicStateCount, pDynamicStates ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineDynamicStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dynamicStateCount == rhs.dynamicStateCount ) && + ( pDynamicStates == rhs.pDynamicStates ); +# endif + } + + bool operator!=( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineDynamicStateCreateInfo; + const void * pNext = {}; + PipelineDynamicStateCreateFlags flags = {}; + uint32_t dynamicStateCount = {}; + const DynamicState * pDynamicStates = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineDynamicStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineDynamicStateCreateInfo; + }; + + // wrapper struct for struct VkGraphicsPipelineCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineCreateInfo.html + struct GraphicsPipelineCreateInfo + { + using NativeType = VkGraphicsPipelineCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsPipelineCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = {}, + uint32_t stageCount_ = {}, + const PipelineShaderStageCreateInfo * pStages_ = {}, + const PipelineVertexInputStateCreateInfo * pVertexInputState_ = {}, + const PipelineInputAssemblyStateCreateInfo * pInputAssemblyState_ = {}, + const PipelineTessellationStateCreateInfo * pTessellationState_ = {}, + const PipelineViewportStateCreateInfo * pViewportState_ = {}, + const PipelineRasterizationStateCreateInfo * pRasterizationState_ = {}, + const PipelineMultisampleStateCreateInfo * pMultisampleState_ = {}, + const PipelineDepthStencilStateCreateInfo * pDepthStencilState_ = {}, + const PipelineColorBlendStateCreateInfo * pColorBlendState_ = {}, + const PipelineDynamicStateCreateInfo * pDynamicState_ = {}, + PipelineLayout layout_ = {}, + RenderPass renderPass_ = {}, + uint32_t subpass_ = {}, + Pipeline basePipelineHandle_ = {}, + int32_t basePipelineIndex_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , stageCount{ stageCount_ } + , pStages{ pStages_ } + , pVertexInputState{ pVertexInputState_ } + , pInputAssemblyState{ pInputAssemblyState_ } + , pTessellationState{ pTessellationState_ } + , pViewportState{ pViewportState_ } + , pRasterizationState{ pRasterizationState_ } + , pMultisampleState{ pMultisampleState_ } + , pDepthStencilState{ pDepthStencilState_ } + , pColorBlendState{ pColorBlendState_ } + , pDynamicState{ pDynamicState_ } + , layout{ layout_ } + , renderPass{ renderPass_ } + , subpass{ subpass_ } + , basePipelineHandle{ basePipelineHandle_ } + , basePipelineIndex{ basePipelineIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo( GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : GraphicsPipelineCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GraphicsPipelineCreateInfo( PipelineCreateFlags flags_, + ArrayProxyNoTemporaries const & stages_, + const PipelineVertexInputStateCreateInfo * pVertexInputState_ = {}, + const PipelineInputAssemblyStateCreateInfo * pInputAssemblyState_ = {}, + const PipelineTessellationStateCreateInfo * pTessellationState_ = {}, + const PipelineViewportStateCreateInfo * pViewportState_ = {}, + const PipelineRasterizationStateCreateInfo * pRasterizationState_ = {}, + const PipelineMultisampleStateCreateInfo * pMultisampleState_ = {}, + const PipelineDepthStencilStateCreateInfo * pDepthStencilState_ = {}, + const PipelineColorBlendStateCreateInfo * pColorBlendState_ = {}, + const PipelineDynamicStateCreateInfo * pDynamicState_ = {}, + PipelineLayout layout_ = {}, + RenderPass renderPass_ = {}, + uint32_t subpass_ = {}, + Pipeline basePipelineHandle_ = {}, + int32_t basePipelineIndex_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , stageCount( static_cast( stages_.size() ) ) + , pStages( stages_.data() ) + , pVertexInputState( pVertexInputState_ ) + , pInputAssemblyState( pInputAssemblyState_ ) + , pTessellationState( pTessellationState_ ) + , pViewportState( pViewportState_ ) + , pRasterizationState( pRasterizationState_ ) + , pMultisampleState( pMultisampleState_ ) + , pDepthStencilState( pDepthStencilState_ ) + , pColorBlendState( pColorBlendState_ ) + , pDynamicState( pDynamicState_ ) + , layout( layout_ ) + , renderPass( renderPass_ ) + , subpass( subpass_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + GraphicsPipelineCreateInfo & operator=( GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GraphicsPipelineCreateInfo & operator=( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setFlags( PipelineCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setFlags( PipelineCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setStageCount( uint32_t stageCount_ ) & VULKAN_HPP_NOEXCEPT + { + stageCount = stageCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setStageCount( uint32_t stageCount_ ) && VULKAN_HPP_NOEXCEPT + { + stageCount = stageCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPStages( const PipelineShaderStageCreateInfo * pStages_ ) & VULKAN_HPP_NOEXCEPT + { + pStages = pStages_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPStages( const PipelineShaderStageCreateInfo * pStages_ ) && VULKAN_HPP_NOEXCEPT + { + pStages = pStages_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GraphicsPipelineCreateInfo & setStages( ArrayProxyNoTemporaries const & stages_ ) VULKAN_HPP_NOEXCEPT + { + stageCount = static_cast( stages_.size() ); + pStages = stages_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPVertexInputState( const PipelineVertexInputStateCreateInfo * pVertexInputState_ ) & + VULKAN_HPP_NOEXCEPT + { + pVertexInputState = pVertexInputState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPVertexInputState( const PipelineVertexInputStateCreateInfo * pVertexInputState_ ) && + VULKAN_HPP_NOEXCEPT + { + pVertexInputState = pVertexInputState_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo * pInputAssemblyState_ ) & + VULKAN_HPP_NOEXCEPT + { + pInputAssemblyState = pInputAssemblyState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo * pInputAssemblyState_ ) && + VULKAN_HPP_NOEXCEPT + { + pInputAssemblyState = pInputAssemblyState_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPTessellationState( const PipelineTessellationStateCreateInfo * pTessellationState_ ) & + VULKAN_HPP_NOEXCEPT + { + pTessellationState = pTessellationState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPTessellationState( const PipelineTessellationStateCreateInfo * pTessellationState_ ) && + VULKAN_HPP_NOEXCEPT + { + pTessellationState = pTessellationState_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPViewportState( const PipelineViewportStateCreateInfo * pViewportState_ ) & VULKAN_HPP_NOEXCEPT + { + pViewportState = pViewportState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPViewportState( const PipelineViewportStateCreateInfo * pViewportState_ ) && VULKAN_HPP_NOEXCEPT + { + pViewportState = pViewportState_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPRasterizationState( const PipelineRasterizationStateCreateInfo * pRasterizationState_ ) & + VULKAN_HPP_NOEXCEPT + { + pRasterizationState = pRasterizationState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPRasterizationState( const PipelineRasterizationStateCreateInfo * pRasterizationState_ ) && + VULKAN_HPP_NOEXCEPT + { + pRasterizationState = pRasterizationState_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPMultisampleState( const PipelineMultisampleStateCreateInfo * pMultisampleState_ ) & + VULKAN_HPP_NOEXCEPT + { + pMultisampleState = pMultisampleState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPMultisampleState( const PipelineMultisampleStateCreateInfo * pMultisampleState_ ) && + VULKAN_HPP_NOEXCEPT + { + pMultisampleState = pMultisampleState_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPDepthStencilState( const PipelineDepthStencilStateCreateInfo * pDepthStencilState_ ) & + VULKAN_HPP_NOEXCEPT + { + pDepthStencilState = pDepthStencilState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPDepthStencilState( const PipelineDepthStencilStateCreateInfo * pDepthStencilState_ ) && + VULKAN_HPP_NOEXCEPT + { + pDepthStencilState = pDepthStencilState_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPColorBlendState( const PipelineColorBlendStateCreateInfo * pColorBlendState_ ) & + VULKAN_HPP_NOEXCEPT + { + pColorBlendState = pColorBlendState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPColorBlendState( const PipelineColorBlendStateCreateInfo * pColorBlendState_ ) && + VULKAN_HPP_NOEXCEPT + { + pColorBlendState = pColorBlendState_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPDynamicState( const PipelineDynamicStateCreateInfo * pDynamicState_ ) & VULKAN_HPP_NOEXCEPT + { + pDynamicState = pDynamicState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPDynamicState( const PipelineDynamicStateCreateInfo * pDynamicState_ ) && VULKAN_HPP_NOEXCEPT + { + pDynamicState = pDynamicState_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setRenderPass( RenderPass renderPass_ ) & VULKAN_HPP_NOEXCEPT + { + renderPass = renderPass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setRenderPass( RenderPass renderPass_ ) && VULKAN_HPP_NOEXCEPT + { + renderPass = renderPass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setSubpass( uint32_t subpass_ ) & VULKAN_HPP_NOEXCEPT + { + subpass = subpass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setSubpass( uint32_t subpass_ ) && VULKAN_HPP_NOEXCEPT + { + subpass = subpass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setBasePipelineHandle( Pipeline basePipelineHandle_ ) & VULKAN_HPP_NOEXCEPT + { + basePipelineHandle = basePipelineHandle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setBasePipelineHandle( Pipeline basePipelineHandle_ ) && VULKAN_HPP_NOEXCEPT + { + basePipelineHandle = basePipelineHandle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setBasePipelineIndex( int32_t basePipelineIndex_ ) & VULKAN_HPP_NOEXCEPT + { + basePipelineIndex = basePipelineIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setBasePipelineIndex( int32_t basePipelineIndex_ ) && VULKAN_HPP_NOEXCEPT + { + basePipelineIndex = basePipelineIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGraphicsPipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGraphicsPipelineCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGraphicsPipelineCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGraphicsPipelineCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + stageCount, + pStages, + pVertexInputState, + pInputAssemblyState, + pTessellationState, + pViewportState, + pRasterizationState, + pMultisampleState, + pDepthStencilState, + pColorBlendState, + pDynamicState, + layout, + renderPass, + subpass, + basePipelineHandle, + basePipelineIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GraphicsPipelineCreateInfo const & ) const = default; +#else + bool operator==( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && + ( pVertexInputState == rhs.pVertexInputState ) && ( pInputAssemblyState == rhs.pInputAssemblyState ) && + ( pTessellationState == rhs.pTessellationState ) && ( pViewportState == rhs.pViewportState ) && + ( pRasterizationState == rhs.pRasterizationState ) && ( pMultisampleState == rhs.pMultisampleState ) && + ( pDepthStencilState == rhs.pDepthStencilState ) && ( pColorBlendState == rhs.pColorBlendState ) && ( pDynamicState == rhs.pDynamicState ) && + ( layout == rhs.layout ) && ( renderPass == rhs.renderPass ) && ( subpass == rhs.subpass ) && ( basePipelineHandle == rhs.basePipelineHandle ) && + ( basePipelineIndex == rhs.basePipelineIndex ); +# endif + } + + bool operator!=( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGraphicsPipelineCreateInfo; + const void * pNext = {}; + PipelineCreateFlags flags = {}; + uint32_t stageCount = {}; + const PipelineShaderStageCreateInfo * pStages = {}; + const PipelineVertexInputStateCreateInfo * pVertexInputState = {}; + const PipelineInputAssemblyStateCreateInfo * pInputAssemblyState = {}; + const PipelineTessellationStateCreateInfo * pTessellationState = {}; + const PipelineViewportStateCreateInfo * pViewportState = {}; + const PipelineRasterizationStateCreateInfo * pRasterizationState = {}; + const PipelineMultisampleStateCreateInfo * pMultisampleState = {}; + const PipelineDepthStencilStateCreateInfo * pDepthStencilState = {}; + const PipelineColorBlendStateCreateInfo * pColorBlendState = {}; + const PipelineDynamicStateCreateInfo * pDynamicState = {}; + PipelineLayout layout = {}; + RenderPass renderPass = {}; + uint32_t subpass = {}; + Pipeline basePipelineHandle = {}; + int32_t basePipelineIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GraphicsPipelineCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = GraphicsPipelineCreateInfo; + }; + + // wrapper struct for struct VkGraphicsPipelineLibraryCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineLibraryCreateInfoEXT.html + struct GraphicsPipelineLibraryCreateInfoEXT + { + using NativeType = VkGraphicsPipelineLibraryCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsPipelineLibraryCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GraphicsPipelineLibraryCreateInfoEXT( GraphicsPipelineLibraryFlagsEXT flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR GraphicsPipelineLibraryCreateInfoEXT( GraphicsPipelineLibraryCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GraphicsPipelineLibraryCreateInfoEXT( VkGraphicsPipelineLibraryCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : GraphicsPipelineLibraryCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + GraphicsPipelineLibraryCreateInfoEXT & operator=( GraphicsPipelineLibraryCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GraphicsPipelineLibraryCreateInfoEXT & operator=( VkGraphicsPipelineLibraryCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineLibraryCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineLibraryCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineLibraryCreateInfoEXT & setFlags( GraphicsPipelineLibraryFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineLibraryCreateInfoEXT && setFlags( GraphicsPipelineLibraryFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGraphicsPipelineLibraryCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGraphicsPipelineLibraryCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGraphicsPipelineLibraryCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGraphicsPipelineLibraryCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GraphicsPipelineLibraryCreateInfoEXT const & ) const = default; +#else + bool operator==( GraphicsPipelineLibraryCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( GraphicsPipelineLibraryCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGraphicsPipelineLibraryCreateInfoEXT; + const void * pNext = {}; + GraphicsPipelineLibraryFlagsEXT flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GraphicsPipelineLibraryCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = GraphicsPipelineLibraryCreateInfoEXT; + }; + + // wrapper struct for struct VkGraphicsShaderGroupCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsShaderGroupCreateInfoNV.html + struct GraphicsShaderGroupCreateInfoNV + { + using NativeType = VkGraphicsShaderGroupCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsShaderGroupCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GraphicsShaderGroupCreateInfoNV( uint32_t stageCount_ = {}, + const PipelineShaderStageCreateInfo * pStages_ = {}, + const PipelineVertexInputStateCreateInfo * pVertexInputState_ = {}, + const PipelineTessellationStateCreateInfo * pTessellationState_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stageCount{ stageCount_ } + , pStages{ pStages_ } + , pVertexInputState{ pVertexInputState_ } + , pTessellationState{ pTessellationState_ } + { + } + + VULKAN_HPP_CONSTEXPR GraphicsShaderGroupCreateInfoNV( GraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GraphicsShaderGroupCreateInfoNV( VkGraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : GraphicsShaderGroupCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GraphicsShaderGroupCreateInfoNV( ArrayProxyNoTemporaries const & stages_, + const PipelineVertexInputStateCreateInfo * pVertexInputState_ = {}, + const PipelineTessellationStateCreateInfo * pTessellationState_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , stageCount( static_cast( stages_.size() ) ) + , pStages( stages_.data() ) + , pVertexInputState( pVertexInputState_ ) + , pTessellationState( pTessellationState_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + GraphicsShaderGroupCreateInfoNV & operator=( GraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GraphicsShaderGroupCreateInfoNV & operator=( VkGraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV & setStageCount( uint32_t stageCount_ ) & VULKAN_HPP_NOEXCEPT + { + stageCount = stageCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV && setStageCount( uint32_t stageCount_ ) && VULKAN_HPP_NOEXCEPT + { + stageCount = stageCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV & setPStages( const PipelineShaderStageCreateInfo * pStages_ ) & VULKAN_HPP_NOEXCEPT + { + pStages = pStages_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV && setPStages( const PipelineShaderStageCreateInfo * pStages_ ) && VULKAN_HPP_NOEXCEPT + { + pStages = pStages_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GraphicsShaderGroupCreateInfoNV & setStages( ArrayProxyNoTemporaries const & stages_ ) VULKAN_HPP_NOEXCEPT + { + stageCount = static_cast( stages_.size() ); + pStages = stages_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV & setPVertexInputState( const PipelineVertexInputStateCreateInfo * pVertexInputState_ ) & + VULKAN_HPP_NOEXCEPT + { + pVertexInputState = pVertexInputState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV && setPVertexInputState( const PipelineVertexInputStateCreateInfo * pVertexInputState_ ) && + VULKAN_HPP_NOEXCEPT + { + pVertexInputState = pVertexInputState_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV & setPTessellationState( const PipelineTessellationStateCreateInfo * pTessellationState_ ) & + VULKAN_HPP_NOEXCEPT + { + pTessellationState = pTessellationState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV && setPTessellationState( const PipelineTessellationStateCreateInfo * pTessellationState_ ) && + VULKAN_HPP_NOEXCEPT + { + pTessellationState = pTessellationState_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGraphicsShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGraphicsShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGraphicsShaderGroupCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGraphicsShaderGroupCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stageCount, pStages, pVertexInputState, pTessellationState ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GraphicsShaderGroupCreateInfoNV const & ) const = default; +#else + bool operator==( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && + ( pVertexInputState == rhs.pVertexInputState ) && ( pTessellationState == rhs.pTessellationState ); +# endif + } + + bool operator!=( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGraphicsShaderGroupCreateInfoNV; + const void * pNext = {}; + uint32_t stageCount = {}; + const PipelineShaderStageCreateInfo * pStages = {}; + const PipelineVertexInputStateCreateInfo * pVertexInputState = {}; + const PipelineTessellationStateCreateInfo * pTessellationState = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GraphicsShaderGroupCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = GraphicsShaderGroupCreateInfoNV; + }; + + // wrapper struct for struct VkGraphicsPipelineShaderGroupsCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html + struct GraphicsPipelineShaderGroupsCreateInfoNV + { + using NativeType = VkGraphicsPipelineShaderGroupsCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR GraphicsPipelineShaderGroupsCreateInfoNV( uint32_t groupCount_ = {}, + const GraphicsShaderGroupCreateInfoNV * pGroups_ = {}, + uint32_t pipelineCount_ = {}, + const Pipeline * pPipelines_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , groupCount{ groupCount_ } + , pGroups{ pGroups_ } + , pipelineCount{ pipelineCount_ } + , pPipelines{ pPipelines_ } + { + } + + VULKAN_HPP_CONSTEXPR GraphicsPipelineShaderGroupsCreateInfoNV( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + GraphicsPipelineShaderGroupsCreateInfoNV( VkGraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : GraphicsPipelineShaderGroupsCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GraphicsPipelineShaderGroupsCreateInfoNV( ArrayProxyNoTemporaries const & groups_, + ArrayProxyNoTemporaries const & pipelines_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , groupCount( static_cast( groups_.size() ) ) + , pGroups( groups_.data() ) + , pipelineCount( static_cast( pipelines_.size() ) ) + , pPipelines( pipelines_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + GraphicsPipelineShaderGroupsCreateInfoNV & operator=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + GraphicsPipelineShaderGroupsCreateInfoNV & operator=( VkGraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV & setGroupCount( uint32_t groupCount_ ) & VULKAN_HPP_NOEXCEPT + { + groupCount = groupCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV && setGroupCount( uint32_t groupCount_ ) && VULKAN_HPP_NOEXCEPT + { + groupCount = groupCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV & setPGroups( const GraphicsShaderGroupCreateInfoNV * pGroups_ ) & VULKAN_HPP_NOEXCEPT + { + pGroups = pGroups_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV && setPGroups( const GraphicsShaderGroupCreateInfoNV * pGroups_ ) && VULKAN_HPP_NOEXCEPT + { + pGroups = pGroups_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GraphicsPipelineShaderGroupsCreateInfoNV & setGroups( ArrayProxyNoTemporaries const & groups_ ) VULKAN_HPP_NOEXCEPT + { + groupCount = static_cast( groups_.size() ); + pGroups = groups_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV & setPipelineCount( uint32_t pipelineCount_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineCount = pipelineCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV && setPipelineCount( uint32_t pipelineCount_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineCount = pipelineCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV & setPPipelines( const Pipeline * pPipelines_ ) & VULKAN_HPP_NOEXCEPT + { + pPipelines = pPipelines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV && setPPipelines( const Pipeline * pPipelines_ ) && VULKAN_HPP_NOEXCEPT + { + pPipelines = pPipelines_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + GraphicsPipelineShaderGroupsCreateInfoNV & setPipelines( ArrayProxyNoTemporaries const & pipelines_ ) VULKAN_HPP_NOEXCEPT + { + pipelineCount = static_cast( pipelines_.size() ); + pPipelines = pipelines_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkGraphicsPipelineShaderGroupsCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGraphicsPipelineShaderGroupsCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkGraphicsPipelineShaderGroupsCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkGraphicsPipelineShaderGroupsCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, groupCount, pGroups, pipelineCount, pPipelines ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( GraphicsPipelineShaderGroupsCreateInfoNV const & ) const = default; +#else + bool operator==( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( groupCount == rhs.groupCount ) && ( pGroups == rhs.pGroups ) && + ( pipelineCount == rhs.pipelineCount ) && ( pPipelines == rhs.pPipelines ); +# endif + } + + bool operator!=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV; + const void * pNext = {}; + uint32_t groupCount = {}; + const GraphicsShaderGroupCreateInfoNV * pGroups = {}; + uint32_t pipelineCount = {}; + const Pipeline * pPipelines = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = GraphicsPipelineShaderGroupsCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = GraphicsPipelineShaderGroupsCreateInfoNV; + }; + + // wrapper struct for struct VkXYColorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXYColorEXT.html + struct XYColorEXT + { + using NativeType = VkXYColorEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR XYColorEXT( float x_ = {}, float y_ = {} ) VULKAN_HPP_NOEXCEPT + : x{ x_ } + , y{ y_ } + { + } + + VULKAN_HPP_CONSTEXPR XYColorEXT( XYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + XYColorEXT( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT : XYColorEXT( *reinterpret_cast( &rhs ) ) {} + + XYColorEXT & operator=( XYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + XYColorEXT & operator=( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 XYColorEXT & setX( float x_ ) & VULKAN_HPP_NOEXCEPT + { + x = x_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 XYColorEXT && setX( float x_ ) && VULKAN_HPP_NOEXCEPT + { + x = x_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 XYColorEXT & setY( float y_ ) & VULKAN_HPP_NOEXCEPT + { + y = y_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 XYColorEXT && setY( float y_ ) && VULKAN_HPP_NOEXCEPT + { + y = y_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkXYColorEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkXYColorEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkXYColorEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkXYColorEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( XYColorEXT const & ) const = default; +#else + bool operator==( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ); +# endif + } + + bool operator!=( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + float x = {}; + float y = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = XYColorEXT; + }; +#endif + + // wrapper struct for struct VkHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHdrMetadataEXT.html + struct HdrMetadataEXT + { + using NativeType = VkHdrMetadataEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHdrMetadataEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR HdrMetadataEXT( XYColorEXT displayPrimaryRed_ = {}, + XYColorEXT displayPrimaryGreen_ = {}, + XYColorEXT displayPrimaryBlue_ = {}, + XYColorEXT whitePoint_ = {}, + float maxLuminance_ = {}, + float minLuminance_ = {}, + float maxContentLightLevel_ = {}, + float maxFrameAverageLightLevel_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , displayPrimaryRed{ displayPrimaryRed_ } + , displayPrimaryGreen{ displayPrimaryGreen_ } + , displayPrimaryBlue{ displayPrimaryBlue_ } + , whitePoint{ whitePoint_ } + , maxLuminance{ maxLuminance_ } + , minLuminance{ minLuminance_ } + , maxContentLightLevel{ maxContentLightLevel_ } + , maxFrameAverageLightLevel{ maxFrameAverageLightLevel_ } + { + } + + VULKAN_HPP_CONSTEXPR HdrMetadataEXT( HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT : HdrMetadataEXT( *reinterpret_cast( &rhs ) ) {} + + HdrMetadataEXT & operator=( HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + HdrMetadataEXT & operator=( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setDisplayPrimaryRed( XYColorEXT const & displayPrimaryRed_ ) & VULKAN_HPP_NOEXCEPT + { + displayPrimaryRed = displayPrimaryRed_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setDisplayPrimaryRed( XYColorEXT const & displayPrimaryRed_ ) && VULKAN_HPP_NOEXCEPT + { + displayPrimaryRed = displayPrimaryRed_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setDisplayPrimaryGreen( XYColorEXT const & displayPrimaryGreen_ ) & VULKAN_HPP_NOEXCEPT + { + displayPrimaryGreen = displayPrimaryGreen_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setDisplayPrimaryGreen( XYColorEXT const & displayPrimaryGreen_ ) && VULKAN_HPP_NOEXCEPT + { + displayPrimaryGreen = displayPrimaryGreen_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setDisplayPrimaryBlue( XYColorEXT const & displayPrimaryBlue_ ) & VULKAN_HPP_NOEXCEPT + { + displayPrimaryBlue = displayPrimaryBlue_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setDisplayPrimaryBlue( XYColorEXT const & displayPrimaryBlue_ ) && VULKAN_HPP_NOEXCEPT + { + displayPrimaryBlue = displayPrimaryBlue_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setWhitePoint( XYColorEXT const & whitePoint_ ) & VULKAN_HPP_NOEXCEPT + { + whitePoint = whitePoint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setWhitePoint( XYColorEXT const & whitePoint_ ) && VULKAN_HPP_NOEXCEPT + { + whitePoint = whitePoint_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setMaxLuminance( float maxLuminance_ ) & VULKAN_HPP_NOEXCEPT + { + maxLuminance = maxLuminance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setMaxLuminance( float maxLuminance_ ) && VULKAN_HPP_NOEXCEPT + { + maxLuminance = maxLuminance_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setMinLuminance( float minLuminance_ ) & VULKAN_HPP_NOEXCEPT + { + minLuminance = minLuminance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setMinLuminance( float minLuminance_ ) && VULKAN_HPP_NOEXCEPT + { + minLuminance = minLuminance_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setMaxContentLightLevel( float maxContentLightLevel_ ) & VULKAN_HPP_NOEXCEPT + { + maxContentLightLevel = maxContentLightLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setMaxContentLightLevel( float maxContentLightLevel_ ) && VULKAN_HPP_NOEXCEPT + { + maxContentLightLevel = maxContentLightLevel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ ) & VULKAN_HPP_NOEXCEPT + { + maxFrameAverageLightLevel = maxFrameAverageLightLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ ) && VULKAN_HPP_NOEXCEPT + { + maxFrameAverageLightLevel = maxFrameAverageLightLevel_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkHdrMetadataEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHdrMetadataEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHdrMetadataEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkHdrMetadataEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + displayPrimaryRed, + displayPrimaryGreen, + displayPrimaryBlue, + whitePoint, + maxLuminance, + minLuminance, + maxContentLightLevel, + maxFrameAverageLightLevel ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( HdrMetadataEXT const & ) const = default; +#else + bool operator==( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayPrimaryRed == rhs.displayPrimaryRed ) && + ( displayPrimaryGreen == rhs.displayPrimaryGreen ) && ( displayPrimaryBlue == rhs.displayPrimaryBlue ) && ( whitePoint == rhs.whitePoint ) && + ( maxLuminance == rhs.maxLuminance ) && ( minLuminance == rhs.minLuminance ) && ( maxContentLightLevel == rhs.maxContentLightLevel ) && + ( maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel ); +# endif + } + + bool operator!=( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eHdrMetadataEXT; + const void * pNext = {}; + XYColorEXT displayPrimaryRed = {}; + XYColorEXT displayPrimaryGreen = {}; + XYColorEXT displayPrimaryBlue = {}; + XYColorEXT whitePoint = {}; + float maxLuminance = {}; + float minLuminance = {}; + float maxContentLightLevel = {}; + float maxFrameAverageLightLevel = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = HdrMetadataEXT; + }; +#endif + + template <> + struct CppType + { + using Type = HdrMetadataEXT; + }; + + // wrapper struct for struct VkHdrVividDynamicMetadataHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkHdrVividDynamicMetadataHUAWEI.html + struct HdrVividDynamicMetadataHUAWEI + { + using NativeType = VkHdrVividDynamicMetadataHUAWEI; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHdrVividDynamicMetadataHUAWEI; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + HdrVividDynamicMetadataHUAWEI( size_t dynamicMetadataSize_ = {}, const void * pDynamicMetadata_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dynamicMetadataSize{ dynamicMetadataSize_ } + , pDynamicMetadata{ pDynamicMetadata_ } + { + } + + VULKAN_HPP_CONSTEXPR HdrVividDynamicMetadataHUAWEI( HdrVividDynamicMetadataHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + HdrVividDynamicMetadataHUAWEI( VkHdrVividDynamicMetadataHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + : HdrVividDynamicMetadataHUAWEI( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + HdrVividDynamicMetadataHUAWEI( ArrayProxyNoTemporaries const & dynamicMetadata_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), dynamicMetadataSize( dynamicMetadata_.size() * sizeof( T ) ), pDynamicMetadata( dynamicMetadata_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + HdrVividDynamicMetadataHUAWEI & operator=( HdrVividDynamicMetadataHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + HdrVividDynamicMetadataHUAWEI & operator=( VkHdrVividDynamicMetadataHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI & setDynamicMetadataSize( size_t dynamicMetadataSize_ ) & VULKAN_HPP_NOEXCEPT + { + dynamicMetadataSize = dynamicMetadataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI && setDynamicMetadataSize( size_t dynamicMetadataSize_ ) && VULKAN_HPP_NOEXCEPT + { + dynamicMetadataSize = dynamicMetadataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI & setPDynamicMetadata( const void * pDynamicMetadata_ ) & VULKAN_HPP_NOEXCEPT + { + pDynamicMetadata = pDynamicMetadata_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI && setPDynamicMetadata( const void * pDynamicMetadata_ ) && VULKAN_HPP_NOEXCEPT + { + pDynamicMetadata = pDynamicMetadata_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + HdrVividDynamicMetadataHUAWEI & setDynamicMetadata( ArrayProxyNoTemporaries const & dynamicMetadata_ ) VULKAN_HPP_NOEXCEPT + { + dynamicMetadataSize = dynamicMetadata_.size() * sizeof( T ); + pDynamicMetadata = dynamicMetadata_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkHdrVividDynamicMetadataHUAWEI const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHdrVividDynamicMetadataHUAWEI &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHdrVividDynamicMetadataHUAWEI const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkHdrVividDynamicMetadataHUAWEI *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dynamicMetadataSize, pDynamicMetadata ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( HdrVividDynamicMetadataHUAWEI const & ) const = default; +#else + bool operator==( HdrVividDynamicMetadataHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicMetadataSize == rhs.dynamicMetadataSize ) && + ( pDynamicMetadata == rhs.pDynamicMetadata ); +# endif + } + + bool operator!=( HdrVividDynamicMetadataHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eHdrVividDynamicMetadataHUAWEI; + const void * pNext = {}; + size_t dynamicMetadataSize = {}; + const void * pDynamicMetadata = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = HdrVividDynamicMetadataHUAWEI; + }; +#endif + + template <> + struct CppType + { + using Type = HdrVividDynamicMetadataHUAWEI; + }; + + // wrapper struct for struct VkHeadlessSurfaceCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHeadlessSurfaceCreateInfoEXT.html + struct HeadlessSurfaceCreateInfoEXT + { + using NativeType = VkHeadlessSurfaceCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHeadlessSurfaceCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( HeadlessSurfaceCreateFlagsEXT flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( HeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : HeadlessSurfaceCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + HeadlessSurfaceCreateInfoEXT & operator=( HeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + HeadlessSurfaceCreateInfoEXT & operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 HeadlessSurfaceCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HeadlessSurfaceCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HeadlessSurfaceCreateInfoEXT & setFlags( HeadlessSurfaceCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HeadlessSurfaceCreateInfoEXT && setFlags( HeadlessSurfaceCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkHeadlessSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHeadlessSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHeadlessSurfaceCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkHeadlessSurfaceCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( HeadlessSurfaceCreateInfoEXT const & ) const = default; +#else + bool operator==( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT; + const void * pNext = {}; + HeadlessSurfaceCreateFlagsEXT flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = HeadlessSurfaceCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = HeadlessSurfaceCreateInfoEXT; + }; + + // wrapper struct for struct VkHostAddressRangeConstEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostAddressRangeConstEXT.html + struct HostAddressRangeConstEXT + { + using NativeType = VkHostAddressRangeConstEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR HostAddressRangeConstEXT( const void * address_ = {}, size_t size_ = {} ) VULKAN_HPP_NOEXCEPT + : address{ address_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR HostAddressRangeConstEXT( HostAddressRangeConstEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + HostAddressRangeConstEXT( VkHostAddressRangeConstEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : HostAddressRangeConstEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + HostAddressRangeConstEXT( ArrayProxyNoTemporaries const & address_ ) : address( address_.data() ), size( address_.size() * sizeof( T ) ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + HostAddressRangeConstEXT & operator=( HostAddressRangeConstEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + HostAddressRangeConstEXT & operator=( VkHostAddressRangeConstEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 HostAddressRangeConstEXT & setAddress( const void * address_ ) & VULKAN_HPP_NOEXCEPT + { + address = address_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HostAddressRangeConstEXT && setAddress( const void * address_ ) && VULKAN_HPP_NOEXCEPT + { + address = address_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + HostAddressRangeConstEXT & setAddress( ArrayProxyNoTemporaries const & address_ ) VULKAN_HPP_NOEXCEPT + { + size = address_.size() * sizeof( T ); + address = address_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 HostAddressRangeConstEXT & setSize( size_t size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HostAddressRangeConstEXT && setSize( size_t size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkHostAddressRangeConstEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHostAddressRangeConstEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHostAddressRangeConstEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkHostAddressRangeConstEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( address, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( HostAddressRangeConstEXT const & ) const = default; +#else + bool operator==( HostAddressRangeConstEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( address == rhs.address ) && ( size == rhs.size ); +# endif + } + + bool operator!=( HostAddressRangeConstEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + const void * address = {}; + size_t size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = HostAddressRangeConstEXT; + }; +#endif + + // wrapper struct for struct VkHostAddressRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostAddressRangeEXT.html + struct HostAddressRangeEXT + { + using NativeType = VkHostAddressRangeEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR HostAddressRangeEXT( void * address_ = {}, size_t size_ = {} ) VULKAN_HPP_NOEXCEPT + : address{ address_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR HostAddressRangeEXT( HostAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + HostAddressRangeEXT( VkHostAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT : HostAddressRangeEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + HostAddressRangeEXT( ArrayProxyNoTemporaries const & address_ ) : address( address_.data() ), size( address_.size() * sizeof( T ) ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + HostAddressRangeEXT & operator=( HostAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + HostAddressRangeEXT & operator=( VkHostAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 HostAddressRangeEXT & setAddress( void * address_ ) & VULKAN_HPP_NOEXCEPT + { + address = address_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HostAddressRangeEXT && setAddress( void * address_ ) && VULKAN_HPP_NOEXCEPT + { + address = address_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + HostAddressRangeEXT & setAddress( ArrayProxyNoTemporaries const & address_ ) VULKAN_HPP_NOEXCEPT + { + size = address_.size() * sizeof( T ); + address = address_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 HostAddressRangeEXT & setSize( size_t size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HostAddressRangeEXT && setSize( size_t size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkHostAddressRangeEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHostAddressRangeEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHostAddressRangeEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkHostAddressRangeEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( address, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( HostAddressRangeEXT const & ) const = default; +#else + bool operator==( HostAddressRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( address == rhs.address ) && ( size == rhs.size ); +# endif + } + + bool operator!=( HostAddressRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + void * address = {}; + size_t size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = HostAddressRangeEXT; + }; +#endif + + // wrapper struct for struct VkHostImageCopyDevicePerformanceQuery, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostImageCopyDevicePerformanceQuery.html + struct HostImageCopyDevicePerformanceQuery + { + using NativeType = VkHostImageCopyDevicePerformanceQuery; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHostImageCopyDevicePerformanceQuery; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + HostImageCopyDevicePerformanceQuery( Bool32 optimalDeviceAccess_ = {}, Bool32 identicalMemoryLayout_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , optimalDeviceAccess{ optimalDeviceAccess_ } + , identicalMemoryLayout{ identicalMemoryLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR HostImageCopyDevicePerformanceQuery( HostImageCopyDevicePerformanceQuery const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + HostImageCopyDevicePerformanceQuery( VkHostImageCopyDevicePerformanceQuery const & rhs ) VULKAN_HPP_NOEXCEPT + : HostImageCopyDevicePerformanceQuery( *reinterpret_cast( &rhs ) ) + { + } + + HostImageCopyDevicePerformanceQuery & operator=( HostImageCopyDevicePerformanceQuery const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + HostImageCopyDevicePerformanceQuery & operator=( VkHostImageCopyDevicePerformanceQuery const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkHostImageCopyDevicePerformanceQuery const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHostImageCopyDevicePerformanceQuery &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHostImageCopyDevicePerformanceQuery const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkHostImageCopyDevicePerformanceQuery *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, optimalDeviceAccess, identicalMemoryLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( HostImageCopyDevicePerformanceQuery const & ) const = default; +#else + bool operator==( HostImageCopyDevicePerformanceQuery const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( optimalDeviceAccess == rhs.optimalDeviceAccess ) && + ( identicalMemoryLayout == rhs.identicalMemoryLayout ); +# endif + } + + bool operator!=( HostImageCopyDevicePerformanceQuery const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eHostImageCopyDevicePerformanceQuery; + void * pNext = {}; + Bool32 optimalDeviceAccess = {}; + Bool32 identicalMemoryLayout = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = HostImageCopyDevicePerformanceQuery; + }; +#endif + + template <> + struct CppType + { + using Type = HostImageCopyDevicePerformanceQuery; + }; + + using HostImageCopyDevicePerformanceQueryEXT = HostImageCopyDevicePerformanceQuery; + + // wrapper struct for struct VkHostImageLayoutTransitionInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostImageLayoutTransitionInfo.html + struct HostImageLayoutTransitionInfo + { + using NativeType = VkHostImageLayoutTransitionInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHostImageLayoutTransitionInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR HostImageLayoutTransitionInfo( Image image_ = {}, + ImageLayout oldLayout_ = ImageLayout::eUndefined, + ImageLayout newLayout_ = ImageLayout::eUndefined, + ImageSubresourceRange subresourceRange_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image{ image_ } + , oldLayout{ oldLayout_ } + , newLayout{ newLayout_ } + , subresourceRange{ subresourceRange_ } + { + } + + VULKAN_HPP_CONSTEXPR HostImageLayoutTransitionInfo( HostImageLayoutTransitionInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + HostImageLayoutTransitionInfo( VkHostImageLayoutTransitionInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : HostImageLayoutTransitionInfo( *reinterpret_cast( &rhs ) ) + { + } + + HostImageLayoutTransitionInfo & operator=( HostImageLayoutTransitionInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + HostImageLayoutTransitionInfo & operator=( VkHostImageLayoutTransitionInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo & setOldLayout( ImageLayout oldLayout_ ) & VULKAN_HPP_NOEXCEPT + { + oldLayout = oldLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo && setOldLayout( ImageLayout oldLayout_ ) && VULKAN_HPP_NOEXCEPT + { + oldLayout = oldLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo & setNewLayout( ImageLayout newLayout_ ) & VULKAN_HPP_NOEXCEPT + { + newLayout = newLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo && setNewLayout( ImageLayout newLayout_ ) && VULKAN_HPP_NOEXCEPT + { + newLayout = newLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo & setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) & VULKAN_HPP_NOEXCEPT + { + subresourceRange = subresourceRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo && setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) && VULKAN_HPP_NOEXCEPT + { + subresourceRange = subresourceRange_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkHostImageLayoutTransitionInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHostImageLayoutTransitionInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkHostImageLayoutTransitionInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkHostImageLayoutTransitionInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, oldLayout, newLayout, subresourceRange ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( HostImageLayoutTransitionInfo const & ) const = default; +#else + bool operator==( HostImageLayoutTransitionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( oldLayout == rhs.oldLayout ) && ( newLayout == rhs.newLayout ) && + ( subresourceRange == rhs.subresourceRange ); +# endif + } + + bool operator!=( HostImageLayoutTransitionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eHostImageLayoutTransitionInfo; + const void * pNext = {}; + Image image = {}; + ImageLayout oldLayout = ImageLayout::eUndefined; + ImageLayout newLayout = ImageLayout::eUndefined; + ImageSubresourceRange subresourceRange = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = HostImageLayoutTransitionInfo; + }; +#endif + + template <> + struct CppType + { + using Type = HostImageLayoutTransitionInfo; + }; + + using HostImageLayoutTransitionInfoEXT = HostImageLayoutTransitionInfo; + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + // wrapper struct for struct VkIOSSurfaceCreateInfoMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIOSSurfaceCreateInfoMVK.html + struct IOSSurfaceCreateInfoMVK + { + using NativeType = VkIOSSurfaceCreateInfoMVK; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIosSurfaceCreateInfoMVK; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = {}, const void * pView_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pView{ pView_ } + { + } + + VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( IOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT + : IOSSurfaceCreateInfoMVK( *reinterpret_cast( &rhs ) ) + { + } + + IOSSurfaceCreateInfoMVK & operator=( IOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IOSSurfaceCreateInfoMVK & operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK & setFlags( IOSSurfaceCreateFlagsMVK flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK && setFlags( IOSSurfaceCreateFlagsMVK flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK & setPView( const void * pView_ ) & VULKAN_HPP_NOEXCEPT + { + pView = pView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK && setPView( const void * pView_ ) && VULKAN_HPP_NOEXCEPT + { + pView = pView_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIOSSurfaceCreateInfoMVK const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIOSSurfaceCreateInfoMVK *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pView ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IOSSurfaceCreateInfoMVK const & ) const = default; +# else + bool operator==( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView ); +# endif + } + + bool operator!=( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eIosSurfaceCreateInfoMVK; + const void * pNext = {}; + IOSSurfaceCreateFlagsMVK flags = {}; + const void * pView = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IOSSurfaceCreateInfoMVK; + }; +# endif + + template <> + struct CppType + { + using Type = IOSSurfaceCreateInfoMVK; + }; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + + // wrapper struct for struct VkImageAlignmentControlCreateInfoMESA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageAlignmentControlCreateInfoMESA.html + struct ImageAlignmentControlCreateInfoMESA + { + using NativeType = VkImageAlignmentControlCreateInfoMESA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageAlignmentControlCreateInfoMESA; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageAlignmentControlCreateInfoMESA( uint32_t maximumRequestedAlignment_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maximumRequestedAlignment{ maximumRequestedAlignment_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageAlignmentControlCreateInfoMESA( ImageAlignmentControlCreateInfoMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageAlignmentControlCreateInfoMESA( VkImageAlignmentControlCreateInfoMESA const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageAlignmentControlCreateInfoMESA( *reinterpret_cast( &rhs ) ) + { + } + + ImageAlignmentControlCreateInfoMESA & operator=( ImageAlignmentControlCreateInfoMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageAlignmentControlCreateInfoMESA & operator=( VkImageAlignmentControlCreateInfoMESA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageAlignmentControlCreateInfoMESA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageAlignmentControlCreateInfoMESA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageAlignmentControlCreateInfoMESA & setMaximumRequestedAlignment( uint32_t maximumRequestedAlignment_ ) & VULKAN_HPP_NOEXCEPT + { + maximumRequestedAlignment = maximumRequestedAlignment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageAlignmentControlCreateInfoMESA && setMaximumRequestedAlignment( uint32_t maximumRequestedAlignment_ ) && VULKAN_HPP_NOEXCEPT + { + maximumRequestedAlignment = maximumRequestedAlignment_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageAlignmentControlCreateInfoMESA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageAlignmentControlCreateInfoMESA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageAlignmentControlCreateInfoMESA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageAlignmentControlCreateInfoMESA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maximumRequestedAlignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageAlignmentControlCreateInfoMESA const & ) const = default; +#else + bool operator==( ImageAlignmentControlCreateInfoMESA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maximumRequestedAlignment == rhs.maximumRequestedAlignment ); +# endif + } + + bool operator!=( ImageAlignmentControlCreateInfoMESA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageAlignmentControlCreateInfoMESA; + const void * pNext = {}; + uint32_t maximumRequestedAlignment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageAlignmentControlCreateInfoMESA; + }; +#endif + + template <> + struct CppType + { + using Type = ImageAlignmentControlCreateInfoMESA; + }; + + // wrapper struct for struct VkImageBlit, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageBlit.html + struct ImageBlit + { + using NativeType = VkImageBlit; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 ImageBlit( ImageSubresourceLayers srcSubresource_ = {}, + std::array const & srcOffsets_ = {}, + ImageSubresourceLayers dstSubresource_ = {}, + std::array const & dstOffsets_ = {} ) VULKAN_HPP_NOEXCEPT + : srcSubresource{ srcSubresource_ } + , srcOffsets{ srcOffsets_ } + , dstSubresource{ dstSubresource_ } + , dstOffsets{ dstOffsets_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit( ImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageBlit( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT : ImageBlit( *reinterpret_cast( &rhs ) ) {} + + ImageBlit & operator=( ImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageBlit & operator=( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageBlit & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit & setSrcOffsets( std::array const & srcOffsets_ ) & VULKAN_HPP_NOEXCEPT + { + srcOffsets = srcOffsets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit && setSrcOffsets( std::array const & srcOffsets_ ) && VULKAN_HPP_NOEXCEPT + { + srcOffsets = srcOffsets_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit & setDstOffsets( std::array const & dstOffsets_ ) & VULKAN_HPP_NOEXCEPT + { + dstOffsets = dstOffsets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageBlit && setDstOffsets( std::array const & dstOffsets_ ) && VULKAN_HPP_NOEXCEPT + { + dstOffsets = dstOffsets_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageBlit const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageBlit &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageBlit const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageBlit *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, ImageSubresourceLayers const &, ArrayWrapper1D const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcSubresource, srcOffsets, dstSubresource, dstOffsets ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageBlit const & ) const = default; +#else + bool operator==( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) && ( dstSubresource == rhs.dstSubresource ) && + ( dstOffsets == rhs.dstOffsets ); +# endif + } + + bool operator!=( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ImageSubresourceLayers srcSubresource = {}; + ArrayWrapper1D srcOffsets = {}; + ImageSubresourceLayers dstSubresource = {}; + ArrayWrapper1D dstOffsets = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageBlit; + }; +#endif + + // wrapper struct for struct VkImageCaptureDescriptorDataInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCaptureDescriptorDataInfoEXT.html + struct ImageCaptureDescriptorDataInfoEXT + { + using NativeType = VkImageCaptureDescriptorDataInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCaptureDescriptorDataInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageCaptureDescriptorDataInfoEXT( Image image_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image{ image_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageCaptureDescriptorDataInfoEXT( ImageCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageCaptureDescriptorDataInfoEXT( VkImageCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageCaptureDescriptorDataInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImageCaptureDescriptorDataInfoEXT & operator=( ImageCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageCaptureDescriptorDataInfoEXT & operator=( VkImageCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageCaptureDescriptorDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCaptureDescriptorDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCaptureDescriptorDataInfoEXT & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCaptureDescriptorDataInfoEXT && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageCaptureDescriptorDataInfoEXT const & ) const = default; +#else + bool operator==( ImageCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); +# endif + } + + bool operator!=( ImageCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageCaptureDescriptorDataInfoEXT; + const void * pNext = {}; + Image image = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageCaptureDescriptorDataInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImageCaptureDescriptorDataInfoEXT; + }; + + // wrapper struct for struct VkImageCompressionControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionControlEXT.html + struct ImageCompressionControlEXT + { + using NativeType = VkImageCompressionControlEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCompressionControlEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageCompressionControlEXT( ImageCompressionFlagsEXT flags_ = {}, + uint32_t compressionControlPlaneCount_ = {}, + ImageCompressionFixedRateFlagsEXT * pFixedRateFlags_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , compressionControlPlaneCount{ compressionControlPlaneCount_ } + , pFixedRateFlags{ pFixedRateFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageCompressionControlEXT( ImageCompressionControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageCompressionControlEXT( VkImageCompressionControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageCompressionControlEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageCompressionControlEXT( ImageCompressionFlagsEXT flags_, + ArrayProxyNoTemporaries const & fixedRateFlags_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , compressionControlPlaneCount( static_cast( fixedRateFlags_.size() ) ) + , pFixedRateFlags( fixedRateFlags_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ImageCompressionControlEXT & operator=( ImageCompressionControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageCompressionControlEXT & operator=( VkImageCompressionControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT & setFlags( ImageCompressionFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT && setFlags( ImageCompressionFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT & setCompressionControlPlaneCount( uint32_t compressionControlPlaneCount_ ) & VULKAN_HPP_NOEXCEPT + { + compressionControlPlaneCount = compressionControlPlaneCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT && setCompressionControlPlaneCount( uint32_t compressionControlPlaneCount_ ) && VULKAN_HPP_NOEXCEPT + { + compressionControlPlaneCount = compressionControlPlaneCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT & setPFixedRateFlags( ImageCompressionFixedRateFlagsEXT * pFixedRateFlags_ ) & VULKAN_HPP_NOEXCEPT + { + pFixedRateFlags = pFixedRateFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT && setPFixedRateFlags( ImageCompressionFixedRateFlagsEXT * pFixedRateFlags_ ) && VULKAN_HPP_NOEXCEPT + { + pFixedRateFlags = pFixedRateFlags_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageCompressionControlEXT & setFixedRateFlags( ArrayProxyNoTemporaries const & fixedRateFlags_ ) VULKAN_HPP_NOEXCEPT + { + compressionControlPlaneCount = static_cast( fixedRateFlags_.size() ); + pFixedRateFlags = fixedRateFlags_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageCompressionControlEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCompressionControlEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCompressionControlEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageCompressionControlEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, compressionControlPlaneCount, pFixedRateFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageCompressionControlEXT const & ) const = default; +#else + bool operator==( ImageCompressionControlEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( compressionControlPlaneCount == rhs.compressionControlPlaneCount ) && ( pFixedRateFlags == rhs.pFixedRateFlags ); +# endif + } + + bool operator!=( ImageCompressionControlEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageCompressionControlEXT; + const void * pNext = {}; + ImageCompressionFlagsEXT flags = {}; + uint32_t compressionControlPlaneCount = {}; + ImageCompressionFixedRateFlagsEXT * pFixedRateFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageCompressionControlEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImageCompressionControlEXT; + }; + + // wrapper struct for struct VkImageCompressionPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionPropertiesEXT.html + struct ImageCompressionPropertiesEXT + { + using NativeType = VkImageCompressionPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCompressionPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageCompressionPropertiesEXT( ImageCompressionFlagsEXT imageCompressionFlags_ = {}, + ImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageCompressionFlags{ imageCompressionFlags_ } + , imageCompressionFixedRateFlags{ imageCompressionFixedRateFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageCompressionPropertiesEXT( ImageCompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageCompressionPropertiesEXT( VkImageCompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageCompressionPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImageCompressionPropertiesEXT & operator=( ImageCompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageCompressionPropertiesEXT & operator=( VkImageCompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkImageCompressionPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCompressionPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCompressionPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageCompressionPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageCompressionFlags, imageCompressionFixedRateFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageCompressionPropertiesEXT const & ) const = default; +#else + bool operator==( ImageCompressionPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCompressionFlags == rhs.imageCompressionFlags ) && + ( imageCompressionFixedRateFlags == rhs.imageCompressionFixedRateFlags ); +# endif + } + + bool operator!=( ImageCompressionPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageCompressionPropertiesEXT; + void * pNext = {}; + ImageCompressionFlagsEXT imageCompressionFlags = {}; + ImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageCompressionPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImageCompressionPropertiesEXT; + }; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkImageFormatConstraintsInfoFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatConstraintsInfoFUCHSIA.html + struct ImageFormatConstraintsInfoFUCHSIA + { + using NativeType = VkImageFormatConstraintsInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatConstraintsInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageFormatConstraintsInfoFUCHSIA( ImageCreateInfo imageCreateInfo_ = {}, + FormatFeatureFlags requiredFormatFeatures_ = {}, + ImageFormatConstraintsFlagsFUCHSIA flags_ = {}, + uint64_t sysmemPixelFormat_ = {}, + uint32_t colorSpaceCount_ = {}, + const SysmemColorSpaceFUCHSIA * pColorSpaces_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageCreateInfo{ imageCreateInfo_ } + , requiredFormatFeatures{ requiredFormatFeatures_ } + , flags{ flags_ } + , sysmemPixelFormat{ sysmemPixelFormat_ } + , colorSpaceCount{ colorSpaceCount_ } + , pColorSpaces{ pColorSpaces_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageFormatConstraintsInfoFUCHSIA( ImageFormatConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageFormatConstraintsInfoFUCHSIA( VkImageFormatConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageFormatConstraintsInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageFormatConstraintsInfoFUCHSIA( ImageCreateInfo imageCreateInfo_, + FormatFeatureFlags requiredFormatFeatures_, + ImageFormatConstraintsFlagsFUCHSIA flags_, + uint64_t sysmemPixelFormat_, + ArrayProxyNoTemporaries const & colorSpaces_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , imageCreateInfo( imageCreateInfo_ ) + , requiredFormatFeatures( requiredFormatFeatures_ ) + , flags( flags_ ) + , sysmemPixelFormat( sysmemPixelFormat_ ) + , colorSpaceCount( static_cast( colorSpaces_.size() ) ) + , pColorSpaces( colorSpaces_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ImageFormatConstraintsInfoFUCHSIA & operator=( ImageFormatConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageFormatConstraintsInfoFUCHSIA & operator=( VkImageFormatConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setImageCreateInfo( ImageCreateInfo const & imageCreateInfo_ ) & VULKAN_HPP_NOEXCEPT + { + imageCreateInfo = imageCreateInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setImageCreateInfo( ImageCreateInfo const & imageCreateInfo_ ) && VULKAN_HPP_NOEXCEPT + { + imageCreateInfo = imageCreateInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setRequiredFormatFeatures( FormatFeatureFlags requiredFormatFeatures_ ) & VULKAN_HPP_NOEXCEPT + { + requiredFormatFeatures = requiredFormatFeatures_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setRequiredFormatFeatures( FormatFeatureFlags requiredFormatFeatures_ ) && VULKAN_HPP_NOEXCEPT + { + requiredFormatFeatures = requiredFormatFeatures_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setFlags( ImageFormatConstraintsFlagsFUCHSIA flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setFlags( ImageFormatConstraintsFlagsFUCHSIA flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setSysmemPixelFormat( uint64_t sysmemPixelFormat_ ) & VULKAN_HPP_NOEXCEPT + { + sysmemPixelFormat = sysmemPixelFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setSysmemPixelFormat( uint64_t sysmemPixelFormat_ ) && VULKAN_HPP_NOEXCEPT + { + sysmemPixelFormat = sysmemPixelFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setColorSpaceCount( uint32_t colorSpaceCount_ ) & VULKAN_HPP_NOEXCEPT + { + colorSpaceCount = colorSpaceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setColorSpaceCount( uint32_t colorSpaceCount_ ) && VULKAN_HPP_NOEXCEPT + { + colorSpaceCount = colorSpaceCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setPColorSpaces( const SysmemColorSpaceFUCHSIA * pColorSpaces_ ) & VULKAN_HPP_NOEXCEPT + { + pColorSpaces = pColorSpaces_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setPColorSpaces( const SysmemColorSpaceFUCHSIA * pColorSpaces_ ) && VULKAN_HPP_NOEXCEPT + { + pColorSpaces = pColorSpaces_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageFormatConstraintsInfoFUCHSIA & setColorSpaces( ArrayProxyNoTemporaries const & colorSpaces_ ) VULKAN_HPP_NOEXCEPT + { + colorSpaceCount = static_cast( colorSpaces_.size() ); + pColorSpaces = colorSpaces_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageFormatConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageFormatConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageFormatConstraintsInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageFormatConstraintsInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageCreateInfo, requiredFormatFeatures, flags, sysmemPixelFormat, colorSpaceCount, pColorSpaces ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageFormatConstraintsInfoFUCHSIA const & ) const = default; +# else + bool operator==( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCreateInfo == rhs.imageCreateInfo ) && + ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && ( flags == rhs.flags ) && ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && + ( colorSpaceCount == rhs.colorSpaceCount ) && ( pColorSpaces == rhs.pColorSpaces ); +# endif + } + + bool operator!=( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImageFormatConstraintsInfoFUCHSIA; + const void * pNext = {}; + ImageCreateInfo imageCreateInfo = {}; + FormatFeatureFlags requiredFormatFeatures = {}; + ImageFormatConstraintsFlagsFUCHSIA flags = {}; + uint64_t sysmemPixelFormat = {}; + uint32_t colorSpaceCount = {}; + const SysmemColorSpaceFUCHSIA * pColorSpaces = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageFormatConstraintsInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = ImageFormatConstraintsInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkImageConstraintsInfoFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageConstraintsInfoFUCHSIA.html + struct ImageConstraintsInfoFUCHSIA + { + using NativeType = VkImageConstraintsInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageConstraintsInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFUCHSIA( uint32_t formatConstraintsCount_ = {}, + const ImageFormatConstraintsInfoFUCHSIA * pFormatConstraints_ = {}, + BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints_ = {}, + ImageConstraintsInfoFlagsFUCHSIA flags_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , formatConstraintsCount{ formatConstraintsCount_ } + , pFormatConstraints{ pFormatConstraints_ } + , bufferCollectionConstraints{ bufferCollectionConstraints_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFUCHSIA( ImageConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageConstraintsInfoFUCHSIA( VkImageConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageConstraintsInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageConstraintsInfoFUCHSIA( ArrayProxyNoTemporaries const & formatConstraints_, + BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints_ = {}, + ImageConstraintsInfoFlagsFUCHSIA flags_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , formatConstraintsCount( static_cast( formatConstraints_.size() ) ) + , pFormatConstraints( formatConstraints_.data() ) + , bufferCollectionConstraints( bufferCollectionConstraints_ ) + , flags( flags_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ImageConstraintsInfoFUCHSIA & operator=( ImageConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageConstraintsInfoFUCHSIA & operator=( VkImageConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA & setFormatConstraintsCount( uint32_t formatConstraintsCount_ ) & VULKAN_HPP_NOEXCEPT + { + formatConstraintsCount = formatConstraintsCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA && setFormatConstraintsCount( uint32_t formatConstraintsCount_ ) && VULKAN_HPP_NOEXCEPT + { + formatConstraintsCount = formatConstraintsCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA & setPFormatConstraints( const ImageFormatConstraintsInfoFUCHSIA * pFormatConstraints_ ) & + VULKAN_HPP_NOEXCEPT + { + pFormatConstraints = pFormatConstraints_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA && setPFormatConstraints( const ImageFormatConstraintsInfoFUCHSIA * pFormatConstraints_ ) && + VULKAN_HPP_NOEXCEPT + { + pFormatConstraints = pFormatConstraints_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageConstraintsInfoFUCHSIA & + setFormatConstraints( ArrayProxyNoTemporaries const & formatConstraints_ ) VULKAN_HPP_NOEXCEPT + { + formatConstraintsCount = static_cast( formatConstraints_.size() ); + pFormatConstraints = formatConstraints_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA & + setBufferCollectionConstraints( BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraints_ ) & + VULKAN_HPP_NOEXCEPT + { + bufferCollectionConstraints = bufferCollectionConstraints_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA && + setBufferCollectionConstraints( BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraints_ ) && + VULKAN_HPP_NOEXCEPT + { + bufferCollectionConstraints = bufferCollectionConstraints_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA & setFlags( ImageConstraintsInfoFlagsFUCHSIA flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA && setFlags( ImageConstraintsInfoFlagsFUCHSIA flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageConstraintsInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageConstraintsInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatConstraintsCount, pFormatConstraints, bufferCollectionConstraints, flags ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageConstraintsInfoFUCHSIA const & ) const = default; +# else + bool operator==( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatConstraintsCount == rhs.formatConstraintsCount ) && + ( pFormatConstraints == rhs.pFormatConstraints ) && ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImageConstraintsInfoFUCHSIA; + const void * pNext = {}; + uint32_t formatConstraintsCount = {}; + const ImageFormatConstraintsInfoFUCHSIA * pFormatConstraints = {}; + BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints = {}; + ImageConstraintsInfoFlagsFUCHSIA flags = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageConstraintsInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = ImageConstraintsInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + // wrapper struct for struct VkImageCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCopy.html + struct ImageCopy + { + using NativeType = VkImageCopy; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageCopy( ImageSubresourceLayers srcSubresource_ = {}, + Offset3D srcOffset_ = {}, + ImageSubresourceLayers dstSubresource_ = {}, + Offset3D dstOffset_ = {}, + Extent3D extent_ = {} ) VULKAN_HPP_NOEXCEPT + : srcSubresource{ srcSubresource_ } + , srcOffset{ srcOffset_ } + , dstSubresource{ dstSubresource_ } + , dstOffset{ dstOffset_ } + , extent{ extent_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageCopy( ImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageCopy( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT : ImageCopy( *reinterpret_cast( &rhs ) ) {} + + ImageCopy & operator=( ImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageCopy & operator=( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageCopy & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy & setSrcOffset( Offset3D const & srcOffset_ ) & VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy && setSrcOffset( Offset3D const & srcOffset_ ) && VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy & setDstOffset( Offset3D const & dstOffset_ ) & VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy && setDstOffset( Offset3D const & dstOffset_ ) && VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageCopy && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageCopy const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCopy &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageCopy const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageCopy *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageCopy const & ) const = default; +#else + bool operator==( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) && + ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); +# endif + } + + bool operator!=( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ImageSubresourceLayers srcSubresource = {}; + Offset3D srcOffset = {}; + ImageSubresourceLayers dstSubresource = {}; + Offset3D dstOffset = {}; + Extent3D extent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageCopy; + }; +#endif + + // wrapper struct for struct VkImageViewCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewCreateInfo.html + struct ImageViewCreateInfo + { + using NativeType = VkImageViewCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( ImageViewCreateFlags flags_ = {}, + Image image_ = {}, + ImageViewType viewType_ = ImageViewType::e1D, + Format format_ = Format::eUndefined, + ComponentMapping components_ = {}, + ImageSubresourceRange subresourceRange_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , image{ image_ } + , viewType{ viewType_ } + , format{ format_ } + , components{ components_ } + , subresourceRange{ subresourceRange_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( ImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : ImageViewCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + ImageViewCreateInfo & operator=( ImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageViewCreateInfo & operator=( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setFlags( ImageViewCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setFlags( ImageViewCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setViewType( ImageViewType viewType_ ) & VULKAN_HPP_NOEXCEPT + { + viewType = viewType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setViewType( ImageViewType viewType_ ) && VULKAN_HPP_NOEXCEPT + { + viewType = viewType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setComponents( ComponentMapping const & components_ ) & VULKAN_HPP_NOEXCEPT + { + components = components_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setComponents( ComponentMapping const & components_ ) && VULKAN_HPP_NOEXCEPT + { + components = components_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) & VULKAN_HPP_NOEXCEPT + { + subresourceRange = subresourceRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) && VULKAN_HPP_NOEXCEPT + { + subresourceRange = subresourceRange_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageViewCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, image, viewType, format, components, subresourceRange ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageViewCreateInfo const & ) const = default; +#else + bool operator==( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( image == rhs.image ) && ( viewType == rhs.viewType ) && + ( format == rhs.format ) && ( components == rhs.components ) && ( subresourceRange == rhs.subresourceRange ); +# endif + } + + bool operator!=( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageViewCreateInfo; + const void * pNext = {}; + ImageViewCreateFlags flags = {}; + Image image = {}; + ImageViewType viewType = ImageViewType::e1D; + Format format = Format::eUndefined; + ComponentMapping components = {}; + ImageSubresourceRange subresourceRange = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageViewCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ImageViewCreateInfo; + }; + + // wrapper struct for struct VkImageDescriptorInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageDescriptorInfoEXT.html + struct ImageDescriptorInfoEXT + { + using NativeType = VkImageDescriptorInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDescriptorInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageDescriptorInfoEXT( const ImageViewCreateInfo * pView_ = {}, + ImageLayout layout_ = ImageLayout::eUndefined, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pView{ pView_ } + , layout{ layout_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageDescriptorInfoEXT( ImageDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageDescriptorInfoEXT( VkImageDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageDescriptorInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImageDescriptorInfoEXT & operator=( ImageDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageDescriptorInfoEXT & operator=( VkImageDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT & setPView( const ImageViewCreateInfo * pView_ ) & VULKAN_HPP_NOEXCEPT + { + pView = pView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT && setPView( const ImageViewCreateInfo * pView_ ) && VULKAN_HPP_NOEXCEPT + { + pView = pView_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT & setLayout( ImageLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT && setLayout( ImageLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageDescriptorInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageDescriptorInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageDescriptorInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageDescriptorInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pView, layout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageDescriptorInfoEXT const & ) const = default; +#else + bool operator==( ImageDescriptorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pView == rhs.pView ) && ( layout == rhs.layout ); +# endif + } + + bool operator!=( ImageDescriptorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageDescriptorInfoEXT; + const void * pNext = {}; + const ImageViewCreateInfo * pView = {}; + ImageLayout layout = ImageLayout::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageDescriptorInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImageDescriptorInfoEXT; + }; + + // wrapper struct for struct VkSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubresourceLayout.html + struct SubresourceLayout + { + using NativeType = VkSubresourceLayout; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubresourceLayout( + DeviceSize offset_ = {}, DeviceSize size_ = {}, DeviceSize rowPitch_ = {}, DeviceSize arrayPitch_ = {}, DeviceSize depthPitch_ = {} ) VULKAN_HPP_NOEXCEPT + : offset{ offset_ } + , size{ size_ } + , rowPitch{ rowPitch_ } + , arrayPitch{ arrayPitch_ } + , depthPitch{ depthPitch_ } + { + } + + VULKAN_HPP_CONSTEXPR SubresourceLayout( SubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubresourceLayout( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT : SubresourceLayout( *reinterpret_cast( &rhs ) ) {} + + SubresourceLayout & operator=( SubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubresourceLayout & operator=( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubresourceLayout && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubresourceLayout && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setRowPitch( DeviceSize rowPitch_ ) & VULKAN_HPP_NOEXCEPT + { + rowPitch = rowPitch_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubresourceLayout && setRowPitch( DeviceSize rowPitch_ ) && VULKAN_HPP_NOEXCEPT + { + rowPitch = rowPitch_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setArrayPitch( DeviceSize arrayPitch_ ) & VULKAN_HPP_NOEXCEPT + { + arrayPitch = arrayPitch_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubresourceLayout && setArrayPitch( DeviceSize arrayPitch_ ) && VULKAN_HPP_NOEXCEPT + { + arrayPitch = arrayPitch_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setDepthPitch( DeviceSize depthPitch_ ) & VULKAN_HPP_NOEXCEPT + { + depthPitch = depthPitch_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubresourceLayout && setDepthPitch( DeviceSize depthPitch_ ) && VULKAN_HPP_NOEXCEPT + { + depthPitch = depthPitch_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubresourceLayout const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubresourceLayout &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubresourceLayout const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubresourceLayout *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( offset, size, rowPitch, arrayPitch, depthPitch ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubresourceLayout const & ) const = default; +#else + bool operator==( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( offset == rhs.offset ) && ( size == rhs.size ) && ( rowPitch == rhs.rowPitch ) && ( arrayPitch == rhs.arrayPitch ) && + ( depthPitch == rhs.depthPitch ); +# endif + } + + bool operator!=( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceSize offset = {}; + DeviceSize size = {}; + DeviceSize rowPitch = {}; + DeviceSize arrayPitch = {}; + DeviceSize depthPitch = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubresourceLayout; + }; +#endif + + // wrapper struct for struct VkImageDrmFormatModifierExplicitCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageDrmFormatModifierExplicitCreateInfoEXT.html + struct ImageDrmFormatModifierExplicitCreateInfoEXT + { + using NativeType = VkImageDrmFormatModifierExplicitCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = {}, + uint32_t drmFormatModifierPlaneCount_ = {}, + const SubresourceLayout * pPlaneLayouts_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , drmFormatModifier{ drmFormatModifier_ } + , drmFormatModifierPlaneCount{ drmFormatModifierPlaneCount_ } + , pPlaneLayouts{ pPlaneLayouts_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageDrmFormatModifierExplicitCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_, + ArrayProxyNoTemporaries const & planeLayouts_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , drmFormatModifier( drmFormatModifier_ ) + , drmFormatModifierPlaneCount( static_cast( planeLayouts_.size() ) ) + , pPlaneLayouts( planeLayouts_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ImageDrmFormatModifierExplicitCreateInfoEXT & operator=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageDrmFormatModifierExplicitCreateInfoEXT & operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT & setDrmFormatModifier( uint64_t drmFormatModifier_ ) & VULKAN_HPP_NOEXCEPT + { + drmFormatModifier = drmFormatModifier_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT && setDrmFormatModifier( uint64_t drmFormatModifier_ ) && VULKAN_HPP_NOEXCEPT + { + drmFormatModifier = drmFormatModifier_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT & setDrmFormatModifierPlaneCount( uint32_t drmFormatModifierPlaneCount_ ) & + VULKAN_HPP_NOEXCEPT + { + drmFormatModifierPlaneCount = drmFormatModifierPlaneCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT && setDrmFormatModifierPlaneCount( uint32_t drmFormatModifierPlaneCount_ ) && + VULKAN_HPP_NOEXCEPT + { + drmFormatModifierPlaneCount = drmFormatModifierPlaneCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT & setPPlaneLayouts( const SubresourceLayout * pPlaneLayouts_ ) & VULKAN_HPP_NOEXCEPT + { + pPlaneLayouts = pPlaneLayouts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT && setPPlaneLayouts( const SubresourceLayout * pPlaneLayouts_ ) && VULKAN_HPP_NOEXCEPT + { + pPlaneLayouts = pPlaneLayouts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageDrmFormatModifierExplicitCreateInfoEXT & setPlaneLayouts( ArrayProxyNoTemporaries const & planeLayouts_ ) VULKAN_HPP_NOEXCEPT + { + drmFormatModifierPlaneCount = static_cast( planeLayouts_.size() ); + pPlaneLayouts = planeLayouts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageDrmFormatModifierExplicitCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierExplicitCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierExplicitCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierExplicitCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifier, drmFormatModifierPlaneCount, pPlaneLayouts ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageDrmFormatModifierExplicitCreateInfoEXT const & ) const = default; +#else + bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) && + ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && ( pPlaneLayouts == rhs.pPlaneLayouts ); +# endif + } + + bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; + const void * pNext = {}; + uint64_t drmFormatModifier = {}; + uint32_t drmFormatModifierPlaneCount = {}; + const SubresourceLayout * pPlaneLayouts = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageDrmFormatModifierExplicitCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImageDrmFormatModifierExplicitCreateInfoEXT; + }; + + // wrapper struct for struct VkImageDrmFormatModifierListCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageDrmFormatModifierListCreateInfoEXT.html + struct ImageDrmFormatModifierListCreateInfoEXT + { + using NativeType = VkImageDrmFormatModifierListCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierListCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = {}, + const uint64_t * pDrmFormatModifiers_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , drmFormatModifierCount{ drmFormatModifierCount_ } + , pDrmFormatModifiers{ pDrmFormatModifiers_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageDrmFormatModifierListCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageDrmFormatModifierListCreateInfoEXT( ArrayProxyNoTemporaries const & drmFormatModifiers_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), drmFormatModifierCount( static_cast( drmFormatModifiers_.size() ) ), pDrmFormatModifiers( drmFormatModifiers_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ImageDrmFormatModifierListCreateInfoEXT & operator=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageDrmFormatModifierListCreateInfoEXT & operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT & setDrmFormatModifierCount( uint32_t drmFormatModifierCount_ ) & VULKAN_HPP_NOEXCEPT + { + drmFormatModifierCount = drmFormatModifierCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT && setDrmFormatModifierCount( uint32_t drmFormatModifierCount_ ) && VULKAN_HPP_NOEXCEPT + { + drmFormatModifierCount = drmFormatModifierCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT & setPDrmFormatModifiers( const uint64_t * pDrmFormatModifiers_ ) & VULKAN_HPP_NOEXCEPT + { + pDrmFormatModifiers = pDrmFormatModifiers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT && setPDrmFormatModifiers( const uint64_t * pDrmFormatModifiers_ ) && VULKAN_HPP_NOEXCEPT + { + pDrmFormatModifiers = pDrmFormatModifiers_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageDrmFormatModifierListCreateInfoEXT & setDrmFormatModifiers( ArrayProxyNoTemporaries const & drmFormatModifiers_ ) VULKAN_HPP_NOEXCEPT + { + drmFormatModifierCount = static_cast( drmFormatModifiers_.size() ); + pDrmFormatModifiers = drmFormatModifiers_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageDrmFormatModifierListCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierListCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierListCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierListCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifiers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageDrmFormatModifierListCreateInfoEXT const & ) const = default; +#else + bool operator==( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && + ( pDrmFormatModifiers == rhs.pDrmFormatModifiers ); +# endif + } + + bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT; + const void * pNext = {}; + uint32_t drmFormatModifierCount = {}; + const uint64_t * pDrmFormatModifiers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageDrmFormatModifierListCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImageDrmFormatModifierListCreateInfoEXT; + }; + + // wrapper struct for struct VkImageDrmFormatModifierPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageDrmFormatModifierPropertiesEXT.html + struct ImageDrmFormatModifierPropertiesEXT + { + using NativeType = VkImageDrmFormatModifierPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , drmFormatModifier{ drmFormatModifier_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierPropertiesEXT( ImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageDrmFormatModifierPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImageDrmFormatModifierPropertiesEXT & operator=( ImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageDrmFormatModifierPropertiesEXT & operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkImageDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageDrmFormatModifierPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifier ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageDrmFormatModifierPropertiesEXT const & ) const = default; +#else + bool operator==( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ); +# endif + } + + bool operator!=( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT; + void * pNext = {}; + uint64_t drmFormatModifier = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageDrmFormatModifierPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImageDrmFormatModifierPropertiesEXT; + }; + + // wrapper struct for struct VkImageFormatListCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatListCreateInfo.html + struct ImageFormatListCreateInfo + { + using NativeType = VkImageFormatListCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatListCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + ImageFormatListCreateInfo( uint32_t viewFormatCount_ = {}, const Format * pViewFormats_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , viewFormatCount{ viewFormatCount_ } + , pViewFormats{ pViewFormats_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfo( ImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageFormatListCreateInfo( VkImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageFormatListCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageFormatListCreateInfo( ArrayProxyNoTemporaries const & viewFormats_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), viewFormatCount( static_cast( viewFormats_.size() ) ), pViewFormats( viewFormats_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ImageFormatListCreateInfo & operator=( ImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageFormatListCreateInfo & operator=( VkImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo & setViewFormatCount( uint32_t viewFormatCount_ ) & VULKAN_HPP_NOEXCEPT + { + viewFormatCount = viewFormatCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo && setViewFormatCount( uint32_t viewFormatCount_ ) && VULKAN_HPP_NOEXCEPT + { + viewFormatCount = viewFormatCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo & setPViewFormats( const Format * pViewFormats_ ) & VULKAN_HPP_NOEXCEPT + { + pViewFormats = pViewFormats_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo && setPViewFormats( const Format * pViewFormats_ ) && VULKAN_HPP_NOEXCEPT + { + pViewFormats = pViewFormats_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ImageFormatListCreateInfo & setViewFormats( ArrayProxyNoTemporaries const & viewFormats_ ) VULKAN_HPP_NOEXCEPT + { + viewFormatCount = static_cast( viewFormats_.size() ); + pViewFormats = viewFormats_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageFormatListCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageFormatListCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageFormatListCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageFormatListCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, viewFormatCount, pViewFormats ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageFormatListCreateInfo const & ) const = default; +#else + bool operator==( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewFormatCount == rhs.viewFormatCount ) && ( pViewFormats == rhs.pViewFormats ); +# endif + } + + bool operator!=( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageFormatListCreateInfo; + const void * pNext = {}; + uint32_t viewFormatCount = {}; + const Format * pViewFormats = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageFormatListCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ImageFormatListCreateInfo; + }; + + using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo; + + // wrapper struct for struct VkImageFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatProperties2.html + struct ImageFormatProperties2 + { + using NativeType = VkImageFormatProperties2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatProperties2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageFormatProperties2( ImageFormatProperties imageFormatProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageFormatProperties{ imageFormatProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageFormatProperties2( ImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageFormatProperties2( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageFormatProperties2( *reinterpret_cast( &rhs ) ) + { + } + + ImageFormatProperties2 & operator=( ImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageFormatProperties2 & operator=( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageFormatProperties2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageFormatProperties2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageFormatProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageFormatProperties2 const & ) const = default; +#else + bool operator==( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFormatProperties == rhs.imageFormatProperties ); +# endif + } + + bool operator!=( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageFormatProperties2; + void * pNext = {}; + ImageFormatProperties imageFormatProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageFormatProperties2; + }; +#endif + + template <> + struct CppType + { + using Type = ImageFormatProperties2; + }; + + using ImageFormatProperties2KHR = ImageFormatProperties2; + + // wrapper struct for struct VkImageMemoryBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageMemoryBarrier.html + struct ImageMemoryBarrier + { + using NativeType = VkImageMemoryBarrier; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryBarrier; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( AccessFlags srcAccessMask_ = {}, + AccessFlags dstAccessMask_ = {}, + ImageLayout oldLayout_ = ImageLayout::eUndefined, + ImageLayout newLayout_ = ImageLayout::eUndefined, + uint32_t srcQueueFamilyIndex_ = {}, + uint32_t dstQueueFamilyIndex_ = {}, + Image image_ = {}, + ImageSubresourceRange subresourceRange_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcAccessMask{ srcAccessMask_ } + , dstAccessMask{ dstAccessMask_ } + , oldLayout{ oldLayout_ } + , newLayout{ newLayout_ } + , srcQueueFamilyIndex{ srcQueueFamilyIndex_ } + , dstQueueFamilyIndex{ dstQueueFamilyIndex_ } + , image{ image_ } + , subresourceRange{ subresourceRange_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( ImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT : ImageMemoryBarrier( *reinterpret_cast( &rhs ) ) {} + + ImageMemoryBarrier & operator=( ImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageMemoryBarrier & operator=( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setSrcAccessMask( AccessFlags srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setDstAccessMask( AccessFlags dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setOldLayout( ImageLayout oldLayout_ ) & VULKAN_HPP_NOEXCEPT + { + oldLayout = oldLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setOldLayout( ImageLayout oldLayout_ ) && VULKAN_HPP_NOEXCEPT + { + oldLayout = oldLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setNewLayout( ImageLayout newLayout_ ) & VULKAN_HPP_NOEXCEPT + { + newLayout = newLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setNewLayout( ImageLayout newLayout_ ) && VULKAN_HPP_NOEXCEPT + { + newLayout = newLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) & VULKAN_HPP_NOEXCEPT + { + subresourceRange = subresourceRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) && VULKAN_HPP_NOEXCEPT + { + subresourceRange = subresourceRange_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageMemoryBarrier &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageMemoryBarrier const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageMemoryBarrier *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcAccessMask, dstAccessMask, oldLayout, newLayout, srcQueueFamilyIndex, dstQueueFamilyIndex, image, subresourceRange ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageMemoryBarrier const & ) const = default; +#else + bool operator==( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) && + ( oldLayout == rhs.oldLayout ) && ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && + ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) && ( subresourceRange == rhs.subresourceRange ); +# endif + } + + bool operator!=( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageMemoryBarrier; + const void * pNext = {}; + AccessFlags srcAccessMask = {}; + AccessFlags dstAccessMask = {}; + ImageLayout oldLayout = ImageLayout::eUndefined; + ImageLayout newLayout = ImageLayout::eUndefined; + uint32_t srcQueueFamilyIndex = {}; + uint32_t dstQueueFamilyIndex = {}; + Image image = {}; + ImageSubresourceRange subresourceRange = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageMemoryBarrier; + }; +#endif + + template <> + struct CppType + { + using Type = ImageMemoryBarrier; + }; + + // wrapper struct for struct VkImageMemoryRequirementsInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageMemoryRequirementsInfo2.html + struct ImageMemoryRequirementsInfo2 + { + using NativeType = VkImageMemoryRequirementsInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryRequirementsInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( Image image_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image{ image_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( ImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageMemoryRequirementsInfo2( *reinterpret_cast( &rhs ) ) + { + } + + ImageMemoryRequirementsInfo2 & operator=( ImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageMemoryRequirementsInfo2 & operator=( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageMemoryRequirementsInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryRequirementsInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryRequirementsInfo2 & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageMemoryRequirementsInfo2 && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageMemoryRequirementsInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageMemoryRequirementsInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageMemoryRequirementsInfo2 const & ) const = default; +#else + bool operator==( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); +# endif + } + + bool operator!=( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageMemoryRequirementsInfo2; + const void * pNext = {}; + Image image = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageMemoryRequirementsInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = ImageMemoryRequirementsInfo2; + }; + + using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2; + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkImagePipeSurfaceCreateInfoFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImagePipeSurfaceCreateInfoFUCHSIA.html + struct ImagePipeSurfaceCreateInfoFUCHSIA + { + using NativeType = VkImagePipeSurfaceCreateInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = {}, + zx_handle_t imagePipeHandle_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , imagePipeHandle{ imagePipeHandle_ } + { + } + + VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : ImagePipeSurfaceCreateInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + ImagePipeSurfaceCreateInfoFUCHSIA & operator=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImagePipeSurfaceCreateInfoFUCHSIA & operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA & setFlags( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA && setFlags( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA & setImagePipeHandle( zx_handle_t imagePipeHandle_ ) & VULKAN_HPP_NOEXCEPT + { + imagePipeHandle = imagePipeHandle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA && setImagePipeHandle( zx_handle_t imagePipeHandle_ ) && VULKAN_HPP_NOEXCEPT + { + imagePipeHandle = imagePipeHandle_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImagePipeSurfaceCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImagePipeSurfaceCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImagePipeSurfaceCreateInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImagePipeSurfaceCreateInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, imagePipeHandle ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &imagePipeHandle, &rhs.imagePipeHandle, sizeof( zx_handle_t ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( memcmp( &imagePipeHandle, &rhs.imagePipeHandle, sizeof( zx_handle_t ) ) == 0 ); + } + + bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; + const void * pNext = {}; + ImagePipeSurfaceCreateFlagsFUCHSIA flags = {}; + zx_handle_t imagePipeHandle = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImagePipeSurfaceCreateInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = ImagePipeSurfaceCreateInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + // wrapper struct for struct VkImagePlaneMemoryRequirementsInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImagePlaneMemoryRequirementsInfo.html + struct ImagePlaneMemoryRequirementsInfo + { + using NativeType = VkImagePlaneMemoryRequirementsInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImagePlaneMemoryRequirementsInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , planeAspect{ planeAspect_ } + { + } + + VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( ImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : ImagePlaneMemoryRequirementsInfo( *reinterpret_cast( &rhs ) ) + { + } + + ImagePlaneMemoryRequirementsInfo & operator=( ImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImagePlaneMemoryRequirementsInfo & operator=( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImagePlaneMemoryRequirementsInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImagePlaneMemoryRequirementsInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImagePlaneMemoryRequirementsInfo & setPlaneAspect( ImageAspectFlagBits planeAspect_ ) & VULKAN_HPP_NOEXCEPT + { + planeAspect = planeAspect_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImagePlaneMemoryRequirementsInfo && setPlaneAspect( ImageAspectFlagBits planeAspect_ ) && VULKAN_HPP_NOEXCEPT + { + planeAspect = planeAspect_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImagePlaneMemoryRequirementsInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImagePlaneMemoryRequirementsInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImagePlaneMemoryRequirementsInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImagePlaneMemoryRequirementsInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, planeAspect ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImagePlaneMemoryRequirementsInfo const & ) const = default; +#else + bool operator==( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect ); +# endif + } + + bool operator!=( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo; + const void * pNext = {}; + ImageAspectFlagBits planeAspect = ImageAspectFlagBits::eColor; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImagePlaneMemoryRequirementsInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ImagePlaneMemoryRequirementsInfo; + }; + + using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo; + + // wrapper struct for struct VkImageResolve, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageResolve.html + struct ImageResolve + { + using NativeType = VkImageResolve; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageResolve( ImageSubresourceLayers srcSubresource_ = {}, + Offset3D srcOffset_ = {}, + ImageSubresourceLayers dstSubresource_ = {}, + Offset3D dstOffset_ = {}, + Extent3D extent_ = {} ) VULKAN_HPP_NOEXCEPT + : srcSubresource{ srcSubresource_ } + , srcOffset{ srcOffset_ } + , dstSubresource{ dstSubresource_ } + , dstOffset{ dstOffset_ } + , extent{ extent_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageResolve( ImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageResolve( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT : ImageResolve( *reinterpret_cast( &rhs ) ) {} + + ImageResolve & operator=( ImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageResolve & operator=( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageResolve & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve & setSrcOffset( Offset3D const & srcOffset_ ) & VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve && setSrcOffset( Offset3D const & srcOffset_ ) && VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve & setDstOffset( Offset3D const & dstOffset_ ) & VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve && setDstOffset( Offset3D const & dstOffset_ ) && VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageResolve const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageResolve &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageResolve const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageResolve *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageResolve const & ) const = default; +#else + bool operator==( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) && + ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); +# endif + } + + bool operator!=( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ImageSubresourceLayers srcSubresource = {}; + Offset3D srcOffset = {}; + ImageSubresourceLayers dstSubresource = {}; + Offset3D dstOffset = {}; + Extent3D extent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageResolve; + }; +#endif + + // wrapper struct for struct VkImageResolve2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageResolve2.html + struct ImageResolve2 + { + using NativeType = VkImageResolve2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageResolve2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageResolve2( ImageSubresourceLayers srcSubresource_ = {}, + Offset3D srcOffset_ = {}, + ImageSubresourceLayers dstSubresource_ = {}, + Offset3D dstOffset_ = {}, + Extent3D extent_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcSubresource{ srcSubresource_ } + , srcOffset{ srcOffset_ } + , dstSubresource{ dstSubresource_ } + , dstOffset{ dstOffset_ } + , extent{ extent_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageResolve2( ImageResolve2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageResolve2( VkImageResolve2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageResolve2( *reinterpret_cast( &rhs ) ) {} + + ImageResolve2 & operator=( ImageResolve2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageResolve2 & operator=( VkImageResolve2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + srcSubresource = srcSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setSrcOffset( Offset3D const & srcOffset_ ) & VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setSrcOffset( Offset3D const & srcOffset_ ) && VULKAN_HPP_NOEXCEPT + { + srcOffset = srcOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT + { + dstSubresource = dstSubresource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setDstOffset( Offset3D const & dstOffset_ ) & VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setDstOffset( Offset3D const & dstOffset_ ) && VULKAN_HPP_NOEXCEPT + { + dstOffset = dstOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageResolve2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageResolve2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageResolve2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageResolve2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageResolve2 const & ) const = default; +#else + bool operator==( ImageResolve2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && + ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); +# endif + } + + bool operator!=( ImageResolve2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageResolve2; + const void * pNext = {}; + ImageSubresourceLayers srcSubresource = {}; + Offset3D srcOffset = {}; + ImageSubresourceLayers dstSubresource = {}; + Offset3D dstOffset = {}; + Extent3D extent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageResolve2; + }; +#endif + + template <> + struct CppType + { + using Type = ImageResolve2; + }; + + using ImageResolve2KHR = ImageResolve2; + + // wrapper struct for struct VkImageSparseMemoryRequirementsInfo2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSparseMemoryRequirementsInfo2.html + struct ImageSparseMemoryRequirementsInfo2 + { + using NativeType = VkImageSparseMemoryRequirementsInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageSparseMemoryRequirementsInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( Image image_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image{ image_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( ImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageSparseMemoryRequirementsInfo2( *reinterpret_cast( &rhs ) ) + { + } + + ImageSparseMemoryRequirementsInfo2 & operator=( ImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageSparseMemoryRequirementsInfo2 & operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageSparseMemoryRequirementsInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSparseMemoryRequirementsInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSparseMemoryRequirementsInfo2 & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSparseMemoryRequirementsInfo2 && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageSparseMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSparseMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSparseMemoryRequirementsInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageSparseMemoryRequirementsInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageSparseMemoryRequirementsInfo2 const & ) const = default; +#else + bool operator==( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); +# endif + } + + bool operator!=( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2; + const void * pNext = {}; + Image image = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageSparseMemoryRequirementsInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = ImageSparseMemoryRequirementsInfo2; + }; + + using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; + + // wrapper struct for struct VkImageStencilUsageCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageStencilUsageCreateInfo.html + struct ImageStencilUsageCreateInfo + { + using NativeType = VkImageStencilUsageCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageStencilUsageCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfo( ImageUsageFlags stencilUsage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stencilUsage{ stencilUsage_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfo( ImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageStencilUsageCreateInfo( VkImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageStencilUsageCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + ImageStencilUsageCreateInfo & operator=( ImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageStencilUsageCreateInfo & operator=( VkImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageStencilUsageCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageStencilUsageCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageStencilUsageCreateInfo & setStencilUsage( ImageUsageFlags stencilUsage_ ) & VULKAN_HPP_NOEXCEPT + { + stencilUsage = stencilUsage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageStencilUsageCreateInfo && setStencilUsage( ImageUsageFlags stencilUsage_ ) && VULKAN_HPP_NOEXCEPT + { + stencilUsage = stencilUsage_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageStencilUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageStencilUsageCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageStencilUsageCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageStencilUsageCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stencilUsage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageStencilUsageCreateInfo const & ) const = default; +#else + bool operator==( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilUsage == rhs.stencilUsage ); +# endif + } + + bool operator!=( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageStencilUsageCreateInfo; + const void * pNext = {}; + ImageUsageFlags stencilUsage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageStencilUsageCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ImageStencilUsageCreateInfo; + }; + + using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo; + + // wrapper struct for struct VkImageSwapchainCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSwapchainCreateInfoKHR.html + struct ImageSwapchainCreateInfoKHR + { + using NativeType = VkImageSwapchainCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageSwapchainCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( SwapchainKHR swapchain_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchain{ swapchain_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( ImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageSwapchainCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ImageSwapchainCreateInfoKHR & operator=( ImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageSwapchainCreateInfoKHR & operator=( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageSwapchainCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSwapchainCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageSwapchainCreateInfoKHR & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageSwapchainCreateInfoKHR && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageSwapchainCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageSwapchainCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageSwapchainCreateInfoKHR const & ) const = default; +#else + bool operator==( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ); +# endif + } + + bool operator!=( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageSwapchainCreateInfoKHR; + const void * pNext = {}; + SwapchainKHR swapchain = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageSwapchainCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = ImageSwapchainCreateInfoKHR; + }; + + // wrapper struct for struct VkImageViewASTCDecodeModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewASTCDecodeModeEXT.html + struct ImageViewASTCDecodeModeEXT + { + using NativeType = VkImageViewASTCDecodeModeEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewAstcDecodeModeEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( Format decodeMode_ = Format::eUndefined, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , decodeMode{ decodeMode_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( ImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageViewASTCDecodeModeEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImageViewASTCDecodeModeEXT & operator=( ImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageViewASTCDecodeModeEXT & operator=( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageViewASTCDecodeModeEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewASTCDecodeModeEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewASTCDecodeModeEXT & setDecodeMode( Format decodeMode_ ) & VULKAN_HPP_NOEXCEPT + { + decodeMode = decodeMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewASTCDecodeModeEXT && setDecodeMode( Format decodeMode_ ) && VULKAN_HPP_NOEXCEPT + { + decodeMode = decodeMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageViewASTCDecodeModeEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewASTCDecodeModeEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewASTCDecodeModeEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageViewASTCDecodeModeEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, decodeMode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageViewASTCDecodeModeEXT const & ) const = default; +#else + bool operator==( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeMode == rhs.decodeMode ); +# endif + } + + bool operator!=( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageViewAstcDecodeModeEXT; + const void * pNext = {}; + Format decodeMode = Format::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageViewASTCDecodeModeEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImageViewASTCDecodeModeEXT; + }; + + // wrapper struct for struct VkImageViewAddressPropertiesNVX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewAddressPropertiesNVX.html + struct ImageViewAddressPropertiesNVX + { + using NativeType = VkImageViewAddressPropertiesNVX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewAddressPropertiesNVX; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageViewAddressPropertiesNVX( DeviceAddress deviceAddress_ = {}, DeviceSize size_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceAddress{ deviceAddress_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageViewAddressPropertiesNVX( ImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageViewAddressPropertiesNVX( VkImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageViewAddressPropertiesNVX( *reinterpret_cast( &rhs ) ) + { + } + + ImageViewAddressPropertiesNVX & operator=( ImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageViewAddressPropertiesNVX & operator=( VkImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkImageViewAddressPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewAddressPropertiesNVX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewAddressPropertiesNVX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageViewAddressPropertiesNVX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceAddress, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageViewAddressPropertiesNVX const & ) const = default; +#else + bool operator==( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) && ( size == rhs.size ); +# endif + } + + bool operator!=( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageViewAddressPropertiesNVX; + void * pNext = {}; + DeviceAddress deviceAddress = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageViewAddressPropertiesNVX; + }; +#endif + + template <> + struct CppType + { + using Type = ImageViewAddressPropertiesNVX; + }; + + // wrapper struct for struct VkImageViewCaptureDescriptorDataInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewCaptureDescriptorDataInfoEXT.html + struct ImageViewCaptureDescriptorDataInfoEXT + { + using NativeType = VkImageViewCaptureDescriptorDataInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewCaptureDescriptorDataInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageViewCaptureDescriptorDataInfoEXT( ImageView imageView_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageView{ imageView_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageViewCaptureDescriptorDataInfoEXT( ImageViewCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageViewCaptureDescriptorDataInfoEXT( VkImageViewCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageViewCaptureDescriptorDataInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImageViewCaptureDescriptorDataInfoEXT & operator=( ImageViewCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageViewCaptureDescriptorDataInfoEXT & operator=( VkImageViewCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageViewCaptureDescriptorDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCaptureDescriptorDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCaptureDescriptorDataInfoEXT & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewCaptureDescriptorDataInfoEXT && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageViewCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageViewCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageView ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageViewCaptureDescriptorDataInfoEXT const & ) const = default; +#else + bool operator==( ImageViewCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ); +# endif + } + + bool operator!=( ImageViewCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageViewCaptureDescriptorDataInfoEXT; + const void * pNext = {}; + ImageView imageView = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageViewCaptureDescriptorDataInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImageViewCaptureDescriptorDataInfoEXT; + }; + + // wrapper struct for struct VkImageViewHandleInfoNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewHandleInfoNVX.html + struct ImageViewHandleInfoNVX + { + using NativeType = VkImageViewHandleInfoNVX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewHandleInfoNVX; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( ImageView imageView_ = {}, + DescriptorType descriptorType_ = DescriptorType::eSampler, + Sampler sampler_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageView{ imageView_ } + , descriptorType{ descriptorType_ } + , sampler{ sampler_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( ImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageViewHandleInfoNVX( *reinterpret_cast( &rhs ) ) + { + } + + ImageViewHandleInfoNVX & operator=( ImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageViewHandleInfoNVX & operator=( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX & setDescriptorType( DescriptorType descriptorType_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorType = descriptorType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX && setDescriptorType( DescriptorType descriptorType_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorType = descriptorType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX & setSampler( Sampler sampler_ ) & VULKAN_HPP_NOEXCEPT + { + sampler = sampler_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX && setSampler( Sampler sampler_ ) && VULKAN_HPP_NOEXCEPT + { + sampler = sampler_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageViewHandleInfoNVX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewHandleInfoNVX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewHandleInfoNVX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageViewHandleInfoNVX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageView, descriptorType, sampler ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageViewHandleInfoNVX const & ) const = default; +#else + bool operator==( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && ( descriptorType == rhs.descriptorType ) && + ( sampler == rhs.sampler ); +# endif + } + + bool operator!=( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageViewHandleInfoNVX; + const void * pNext = {}; + ImageView imageView = {}; + DescriptorType descriptorType = DescriptorType::eSampler; + Sampler sampler = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageViewHandleInfoNVX; + }; +#endif + + template <> + struct CppType + { + using Type = ImageViewHandleInfoNVX; + }; + + // wrapper struct for struct VkImageViewMinLodCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewMinLodCreateInfoEXT.html + struct ImageViewMinLodCreateInfoEXT + { + using NativeType = VkImageViewMinLodCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewMinLodCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageViewMinLodCreateInfoEXT( float minLod_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minLod{ minLod_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageViewMinLodCreateInfoEXT( ImageViewMinLodCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageViewMinLodCreateInfoEXT( VkImageViewMinLodCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageViewMinLodCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImageViewMinLodCreateInfoEXT & operator=( ImageViewMinLodCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageViewMinLodCreateInfoEXT & operator=( VkImageViewMinLodCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageViewMinLodCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewMinLodCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewMinLodCreateInfoEXT & setMinLod( float minLod_ ) & VULKAN_HPP_NOEXCEPT + { + minLod = minLod_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewMinLodCreateInfoEXT && setMinLod( float minLod_ ) && VULKAN_HPP_NOEXCEPT + { + minLod = minLod_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageViewMinLodCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewMinLodCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewMinLodCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageViewMinLodCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minLod ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageViewMinLodCreateInfoEXT const & ) const = default; +#else + bool operator==( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod ); +# endif + } + + bool operator!=( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageViewMinLodCreateInfoEXT; + const void * pNext = {}; + float minLod = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageViewMinLodCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImageViewMinLodCreateInfoEXT; + }; + + // wrapper struct for struct VkImageViewSampleWeightCreateInfoQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewSampleWeightCreateInfoQCOM.html + struct ImageViewSampleWeightCreateInfoQCOM + { + using NativeType = VkImageViewSampleWeightCreateInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewSampleWeightCreateInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageViewSampleWeightCreateInfoQCOM( Offset2D filterCenter_ = {}, + Extent2D filterSize_ = {}, + uint32_t numPhases_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , filterCenter{ filterCenter_ } + , filterSize{ filterSize_ } + , numPhases{ numPhases_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageViewSampleWeightCreateInfoQCOM( ImageViewSampleWeightCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageViewSampleWeightCreateInfoQCOM( VkImageViewSampleWeightCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageViewSampleWeightCreateInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + ImageViewSampleWeightCreateInfoQCOM & operator=( ImageViewSampleWeightCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageViewSampleWeightCreateInfoQCOM & operator=( VkImageViewSampleWeightCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM & setFilterCenter( Offset2D const & filterCenter_ ) & VULKAN_HPP_NOEXCEPT + { + filterCenter = filterCenter_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM && setFilterCenter( Offset2D const & filterCenter_ ) && VULKAN_HPP_NOEXCEPT + { + filterCenter = filterCenter_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM & setFilterSize( Extent2D const & filterSize_ ) & VULKAN_HPP_NOEXCEPT + { + filterSize = filterSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM && setFilterSize( Extent2D const & filterSize_ ) && VULKAN_HPP_NOEXCEPT + { + filterSize = filterSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM & setNumPhases( uint32_t numPhases_ ) & VULKAN_HPP_NOEXCEPT + { + numPhases = numPhases_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM && setNumPhases( uint32_t numPhases_ ) && VULKAN_HPP_NOEXCEPT + { + numPhases = numPhases_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageViewSampleWeightCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewSampleWeightCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewSampleWeightCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageViewSampleWeightCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, filterCenter, filterSize, numPhases ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageViewSampleWeightCreateInfoQCOM const & ) const = default; +#else + bool operator==( ImageViewSampleWeightCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCenter == rhs.filterCenter ) && ( filterSize == rhs.filterSize ) && + ( numPhases == rhs.numPhases ); +# endif + } + + bool operator!=( ImageViewSampleWeightCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageViewSampleWeightCreateInfoQCOM; + const void * pNext = {}; + Offset2D filterCenter = {}; + Extent2D filterSize = {}; + uint32_t numPhases = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageViewSampleWeightCreateInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = ImageViewSampleWeightCreateInfoQCOM; + }; + + // wrapper struct for struct VkImageViewSlicedCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewSlicedCreateInfoEXT.html + struct ImageViewSlicedCreateInfoEXT + { + using NativeType = VkImageViewSlicedCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewSlicedCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + ImageViewSlicedCreateInfoEXT( uint32_t sliceOffset_ = {}, uint32_t sliceCount_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , sliceOffset{ sliceOffset_ } + , sliceCount{ sliceCount_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageViewSlicedCreateInfoEXT( ImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageViewSlicedCreateInfoEXT( VkImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageViewSlicedCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImageViewSlicedCreateInfoEXT & operator=( ImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageViewSlicedCreateInfoEXT & operator=( VkImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT & setSliceOffset( uint32_t sliceOffset_ ) & VULKAN_HPP_NOEXCEPT + { + sliceOffset = sliceOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT && setSliceOffset( uint32_t sliceOffset_ ) && VULKAN_HPP_NOEXCEPT + { + sliceOffset = sliceOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT & setSliceCount( uint32_t sliceCount_ ) & VULKAN_HPP_NOEXCEPT + { + sliceCount = sliceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT && setSliceCount( uint32_t sliceCount_ ) && VULKAN_HPP_NOEXCEPT + { + sliceCount = sliceCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageViewSlicedCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewSlicedCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewSlicedCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageViewSlicedCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sliceOffset, sliceCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageViewSlicedCreateInfoEXT const & ) const = default; +#else + bool operator==( ImageViewSlicedCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sliceOffset == rhs.sliceOffset ) && ( sliceCount == rhs.sliceCount ); +# endif + } + + bool operator!=( ImageViewSlicedCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageViewSlicedCreateInfoEXT; + const void * pNext = {}; + uint32_t sliceOffset = {}; + uint32_t sliceCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageViewSlicedCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImageViewSlicedCreateInfoEXT; + }; + + // wrapper struct for struct VkImageViewUsageCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewUsageCreateInfo.html + struct ImageViewUsageCreateInfo + { + using NativeType = VkImageViewUsageCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewUsageCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( ImageUsageFlags usage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , usage{ usage_ } + { + } + + VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( ImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : ImageViewUsageCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + ImageViewUsageCreateInfo & operator=( ImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImageViewUsageCreateInfo & operator=( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImageViewUsageCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewUsageCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewUsageCreateInfo & setUsage( ImageUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImageViewUsageCreateInfo && setUsage( ImageUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImageViewUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewUsageCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImageViewUsageCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImageViewUsageCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, usage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImageViewUsageCreateInfo const & ) const = default; +#else + bool operator==( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage ); +# endif + } + + bool operator!=( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImageViewUsageCreateInfo; + const void * pNext = {}; + ImageUsageFlags usage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImageViewUsageCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ImageViewUsageCreateInfo; + }; + + using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + // wrapper struct for struct VkImportAndroidHardwareBufferInfoANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportAndroidHardwareBufferInfoANDROID.html + struct ImportAndroidHardwareBufferInfoANDROID + { + using NativeType = VkImportAndroidHardwareBufferInfoANDROID; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportAndroidHardwareBufferInfoANDROID; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer * buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , buffer{ buffer_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( ImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportAndroidHardwareBufferInfoANDROID( *reinterpret_cast( &rhs ) ) + { + } + + ImportAndroidHardwareBufferInfoANDROID & operator=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportAndroidHardwareBufferInfoANDROID & operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportAndroidHardwareBufferInfoANDROID & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportAndroidHardwareBufferInfoANDROID && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportAndroidHardwareBufferInfoANDROID & setBuffer( struct AHardwareBuffer * buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportAndroidHardwareBufferInfoANDROID && setBuffer( struct AHardwareBuffer * buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportAndroidHardwareBufferInfoANDROID const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportAndroidHardwareBufferInfoANDROID *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportAndroidHardwareBufferInfoANDROID const & ) const = default; +# else + bool operator==( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); +# endif + } + + bool operator!=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID; + const void * pNext = {}; + struct AHardwareBuffer * buffer = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportAndroidHardwareBufferInfoANDROID; + }; +# endif + + template <> + struct CppType + { + using Type = ImportAndroidHardwareBufferInfoANDROID; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + // wrapper struct for struct VkImportFenceFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportFenceFdInfoKHR.html + struct ImportFenceFdInfoKHR + { + using NativeType = VkImportFenceFdInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportFenceFdInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( Fence fence_ = {}, + FenceImportFlags flags_ = {}, + ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, + int fd_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fence{ fence_ } + , flags{ flags_ } + , handleType{ handleType_ } + , fd{ fd_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( ImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportFenceFdInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ImportFenceFdInfoKHR & operator=( ImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportFenceFdInfoKHR & operator=( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR & setFence( Fence fence_ ) & VULKAN_HPP_NOEXCEPT + { + fence = fence_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR && setFence( Fence fence_ ) && VULKAN_HPP_NOEXCEPT + { + fence = fence_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR & setFlags( FenceImportFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR && setFlags( FenceImportFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR && setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR & setFd( int fd_ ) & VULKAN_HPP_NOEXCEPT + { + fd = fd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR && setFd( int fd_ ) && VULKAN_HPP_NOEXCEPT + { + fd = fd_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportFenceFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportFenceFdInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportFenceFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportFenceFdInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, flags, handleType, fd ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportFenceFdInfoKHR const & ) const = default; +#else + bool operator==( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && + ( fd == rhs.fd ); +# endif + } + + bool operator!=( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImportFenceFdInfoKHR; + const void * pNext = {}; + Fence fence = {}; + FenceImportFlags flags = {}; + ExternalFenceHandleTypeFlagBits handleType = ExternalFenceHandleTypeFlagBits::eOpaqueFd; + int fd = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportFenceFdInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = ImportFenceFdInfoKHR; + }; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkImportFenceWin32HandleInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportFenceWin32HandleInfoKHR.html + struct ImportFenceWin32HandleInfoKHR + { + using NativeType = VkImportFenceWin32HandleInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportFenceWin32HandleInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( Fence fence_ = {}, + FenceImportFlags flags_ = {}, + ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, + HANDLE handle_ = {}, + LPCWSTR name_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fence{ fence_ } + , flags{ flags_ } + , handleType{ handleType_ } + , handle{ handle_ } + , name{ name_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( ImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportFenceWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ImportFenceWin32HandleInfoKHR & operator=( ImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportFenceWin32HandleInfoKHR & operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setFence( Fence fence_ ) & VULKAN_HPP_NOEXCEPT + { + fence = fence_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setFence( Fence fence_ ) && VULKAN_HPP_NOEXCEPT + { + fence = fence_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setFlags( FenceImportFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setFlags( FenceImportFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setHandle( HANDLE handle_ ) & VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setHandle( HANDLE handle_ ) && VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT + { + name = name_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT + { + name = name_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportFenceWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportFenceWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fence, flags, handleType, handle, name ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportFenceWin32HandleInfoKHR const & ) const = default; +# else + bool operator==( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && + ( handle == rhs.handle ) && ( name == rhs.name ); +# endif + } + + bool operator!=( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR; + const void * pNext = {}; + Fence fence = {}; + FenceImportFlags flags = {}; + ExternalFenceHandleTypeFlagBits handleType = ExternalFenceHandleTypeFlagBits::eOpaqueFd; + HANDLE handle = {}; + LPCWSTR name = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportFenceWin32HandleInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = ImportFenceWin32HandleInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkImportMemoryBufferCollectionFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryBufferCollectionFUCHSIA.html + struct ImportMemoryBufferCollectionFUCHSIA + { + using NativeType = VkImportMemoryBufferCollectionFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryBufferCollectionFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + ImportMemoryBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection_ = {}, uint32_t index_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , collection{ collection_ } + , index{ index_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportMemoryBufferCollectionFUCHSIA( ImportMemoryBufferCollectionFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportMemoryBufferCollectionFUCHSIA( VkImportMemoryBufferCollectionFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportMemoryBufferCollectionFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + ImportMemoryBufferCollectionFUCHSIA & operator=( ImportMemoryBufferCollectionFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportMemoryBufferCollectionFUCHSIA & operator=( VkImportMemoryBufferCollectionFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA & setCollection( BufferCollectionFUCHSIA collection_ ) & VULKAN_HPP_NOEXCEPT + { + collection = collection_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA && setCollection( BufferCollectionFUCHSIA collection_ ) && VULKAN_HPP_NOEXCEPT + { + collection = collection_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT + { + index = index_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT + { + index = index_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportMemoryBufferCollectionFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryBufferCollectionFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryBufferCollectionFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportMemoryBufferCollectionFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, collection, index ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportMemoryBufferCollectionFUCHSIA const & ) const = default; +# else + bool operator==( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && ( index == rhs.index ); +# endif + } + + bool operator!=( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportMemoryBufferCollectionFUCHSIA; + const void * pNext = {}; + BufferCollectionFUCHSIA collection = {}; + uint32_t index = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportMemoryBufferCollectionFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = ImportMemoryBufferCollectionFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + // wrapper struct for struct VkImportMemoryFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryFdInfoKHR.html + struct ImportMemoryFdInfoKHR + { + using NativeType = VkImportMemoryFdInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryFdInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + int fd_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleType{ handleType_ } + , fd{ fd_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( ImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportMemoryFdInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ImportMemoryFdInfoKHR & operator=( ImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportMemoryFdInfoKHR & operator=( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR & setFd( int fd_ ) & VULKAN_HPP_NOEXCEPT + { + fd = fd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR && setFd( int fd_ ) && VULKAN_HPP_NOEXCEPT + { + fd = fd_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportMemoryFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryFdInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportMemoryFdInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, fd ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportMemoryFdInfoKHR const & ) const = default; +#else + bool operator==( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd ); +# endif + } + + bool operator!=( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImportMemoryFdInfoKHR; + const void * pNext = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + int fd = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportMemoryFdInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = ImportMemoryFdInfoKHR; + }; + + // wrapper struct for struct VkImportMemoryHostPointerInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryHostPointerInfoEXT.html + struct ImportMemoryHostPointerInfoEXT + { + using NativeType = VkImportMemoryHostPointerInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryHostPointerInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + void * pHostPointer_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleType{ handleType_ } + , pHostPointer{ pHostPointer_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( ImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportMemoryHostPointerInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImportMemoryHostPointerInfoEXT & operator=( ImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportMemoryHostPointerInfoEXT & operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT & setPHostPointer( void * pHostPointer_ ) & VULKAN_HPP_NOEXCEPT + { + pHostPointer = pHostPointer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT && setPHostPointer( void * pHostPointer_ ) && VULKAN_HPP_NOEXCEPT + { + pHostPointer = pHostPointer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportMemoryHostPointerInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryHostPointerInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryHostPointerInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportMemoryHostPointerInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, pHostPointer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportMemoryHostPointerInfoEXT const & ) const = default; +#else + bool operator==( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( pHostPointer == rhs.pHostPointer ); +# endif + } + + bool operator!=( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT; + const void * pNext = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + void * pHostPointer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportMemoryHostPointerInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ImportMemoryHostPointerInfoEXT; + }; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkImportMemoryMetalHandleInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryMetalHandleInfoEXT.html + struct ImportMemoryMetalHandleInfoEXT + { + using NativeType = VkImportMemoryMetalHandleInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryMetalHandleInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportMemoryMetalHandleInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + void * handle_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleType{ handleType_ } + , handle{ handle_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportMemoryMetalHandleInfoEXT( ImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportMemoryMetalHandleInfoEXT( VkImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportMemoryMetalHandleInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImportMemoryMetalHandleInfoEXT & operator=( ImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportMemoryMetalHandleInfoEXT & operator=( VkImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT & setHandle( void * handle_ ) & VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT && setHandle( void * handle_ ) && VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportMemoryMetalHandleInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryMetalHandleInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryMetalHandleInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportMemoryMetalHandleInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, handle ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportMemoryMetalHandleInfoEXT const & ) const = default; +# else + bool operator==( ImportMemoryMetalHandleInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ); +# endif + } + + bool operator!=( ImportMemoryMetalHandleInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportMemoryMetalHandleInfoEXT; + const void * pNext = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + void * handle = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportMemoryMetalHandleInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ImportMemoryMetalHandleInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkImportMemoryWin32HandleInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryWin32HandleInfoKHR.html + struct ImportMemoryWin32HandleInfoKHR + { + using NativeType = VkImportMemoryWin32HandleInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryWin32HandleInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + HANDLE handle_ = {}, + LPCWSTR name_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleType{ handleType_ } + , handle{ handle_ } + , name{ name_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( ImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportMemoryWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ImportMemoryWin32HandleInfoKHR & operator=( ImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportMemoryWin32HandleInfoKHR & operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR & setHandle( HANDLE handle_ ) & VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR && setHandle( HANDLE handle_ ) && VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT + { + name = name_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT + { + name = name_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportMemoryWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, handle, name ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportMemoryWin32HandleInfoKHR const & ) const = default; +# else + bool operator==( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && ( name == rhs.name ); +# endif + } + + bool operator!=( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR; + const void * pNext = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + HANDLE handle = {}; + LPCWSTR name = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportMemoryWin32HandleInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = ImportMemoryWin32HandleInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkImportMemoryWin32HandleInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryWin32HandleInfoNV.html + struct ImportMemoryWin32HandleInfoNV + { + using NativeType = VkImportMemoryWin32HandleInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryWin32HandleInfoNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = {}, HANDLE handle_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleType{ handleType_ } + , handle{ handle_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( ImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportMemoryWin32HandleInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ImportMemoryWin32HandleInfoNV & operator=( ImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportMemoryWin32HandleInfoNV & operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV & setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV && setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV & setHandle( HANDLE handle_ ) & VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV && setHandle( HANDLE handle_ ) && VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryWin32HandleInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportMemoryWin32HandleInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, handle ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportMemoryWin32HandleInfoNV const & ) const = default; +# else + bool operator==( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ); +# endif + } + + bool operator!=( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV; + const void * pNext = {}; + ExternalMemoryHandleTypeFlagsNV handleType = {}; + HANDLE handle = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportMemoryWin32HandleInfoNV; + }; +# endif + + template <> + struct CppType + { + using Type = ImportMemoryWin32HandleInfoNV; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkImportMemoryZirconHandleInfoFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryZirconHandleInfoFUCHSIA.html + struct ImportMemoryZirconHandleInfoFUCHSIA + { + using NativeType = VkImportMemoryZirconHandleInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryZirconHandleInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportMemoryZirconHandleInfoFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + zx_handle_t handle_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleType{ handleType_ } + , handle{ handle_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportMemoryZirconHandleInfoFUCHSIA( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportMemoryZirconHandleInfoFUCHSIA( VkImportMemoryZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportMemoryZirconHandleInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + ImportMemoryZirconHandleInfoFUCHSIA & operator=( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportMemoryZirconHandleInfoFUCHSIA & operator=( VkImportMemoryZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA & setHandle( zx_handle_t handle_ ) & VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA && setHandle( zx_handle_t handle_ ) && VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportMemoryZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMemoryZirconHandleInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportMemoryZirconHandleInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType, handle ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = handleType <=> rhs.handleType; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &handle, &rhs.handle, sizeof( zx_handle_t ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && + ( memcmp( &handle, &rhs.handle, sizeof( zx_handle_t ) ) == 0 ); + } + + bool operator!=( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eImportMemoryZirconHandleInfoFUCHSIA; + const void * pNext = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + zx_handle_t handle = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportMemoryZirconHandleInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = ImportMemoryZirconHandleInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkImportMetalBufferInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMetalBufferInfoEXT.html + struct ImportMetalBufferInfoEXT + { + using NativeType = VkImportMetalBufferInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMetalBufferInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportMetalBufferInfoEXT( MTLBuffer_id mtlBuffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , mtlBuffer{ mtlBuffer_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportMetalBufferInfoEXT( ImportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportMetalBufferInfoEXT( VkImportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportMetalBufferInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImportMetalBufferInfoEXT & operator=( ImportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportMetalBufferInfoEXT & operator=( VkImportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportMetalBufferInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalBufferInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalBufferInfoEXT & setMtlBuffer( MTLBuffer_id mtlBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + mtlBuffer = mtlBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalBufferInfoEXT && setMtlBuffer( MTLBuffer_id mtlBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + mtlBuffer = mtlBuffer_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportMetalBufferInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMetalBufferInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMetalBufferInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportMetalBufferInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mtlBuffer ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportMetalBufferInfoEXT const & ) const = default; +# else + bool operator==( ImportMetalBufferInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mtlBuffer == rhs.mtlBuffer ); +# endif + } + + bool operator!=( ImportMetalBufferInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportMetalBufferInfoEXT; + const void * pNext = {}; + MTLBuffer_id mtlBuffer = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportMetalBufferInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ImportMetalBufferInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkImportMetalIOSurfaceInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMetalIOSurfaceInfoEXT.html + struct ImportMetalIOSurfaceInfoEXT + { + using NativeType = VkImportMetalIOSurfaceInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMetalIoSurfaceInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportMetalIOSurfaceInfoEXT( IOSurfaceRef ioSurface_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , ioSurface{ ioSurface_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportMetalIOSurfaceInfoEXT( ImportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportMetalIOSurfaceInfoEXT( VkImportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportMetalIOSurfaceInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImportMetalIOSurfaceInfoEXT & operator=( ImportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportMetalIOSurfaceInfoEXT & operator=( VkImportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportMetalIOSurfaceInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalIOSurfaceInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalIOSurfaceInfoEXT & setIoSurface( IOSurfaceRef ioSurface_ ) & VULKAN_HPP_NOEXCEPT + { + ioSurface = ioSurface_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalIOSurfaceInfoEXT && setIoSurface( IOSurfaceRef ioSurface_ ) && VULKAN_HPP_NOEXCEPT + { + ioSurface = ioSurface_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportMetalIOSurfaceInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMetalIOSurfaceInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMetalIOSurfaceInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportMetalIOSurfaceInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, ioSurface ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportMetalIOSurfaceInfoEXT const & ) const = default; +# else + bool operator==( ImportMetalIOSurfaceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ioSurface == rhs.ioSurface ); +# endif + } + + bool operator!=( ImportMetalIOSurfaceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportMetalIoSurfaceInfoEXT; + const void * pNext = {}; + IOSurfaceRef ioSurface = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportMetalIOSurfaceInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ImportMetalIOSurfaceInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkImportMetalSharedEventInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMetalSharedEventInfoEXT.html + struct ImportMetalSharedEventInfoEXT + { + using NativeType = VkImportMetalSharedEventInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMetalSharedEventInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportMetalSharedEventInfoEXT( MTLSharedEvent_id mtlSharedEvent_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , mtlSharedEvent{ mtlSharedEvent_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportMetalSharedEventInfoEXT( ImportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportMetalSharedEventInfoEXT( VkImportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportMetalSharedEventInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImportMetalSharedEventInfoEXT & operator=( ImportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportMetalSharedEventInfoEXT & operator=( VkImportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportMetalSharedEventInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalSharedEventInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalSharedEventInfoEXT & setMtlSharedEvent( MTLSharedEvent_id mtlSharedEvent_ ) & VULKAN_HPP_NOEXCEPT + { + mtlSharedEvent = mtlSharedEvent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalSharedEventInfoEXT && setMtlSharedEvent( MTLSharedEvent_id mtlSharedEvent_ ) && VULKAN_HPP_NOEXCEPT + { + mtlSharedEvent = mtlSharedEvent_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportMetalSharedEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMetalSharedEventInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMetalSharedEventInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportMetalSharedEventInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mtlSharedEvent ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportMetalSharedEventInfoEXT const & ) const = default; +# else + bool operator==( ImportMetalSharedEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mtlSharedEvent == rhs.mtlSharedEvent ); +# endif + } + + bool operator!=( ImportMetalSharedEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportMetalSharedEventInfoEXT; + const void * pNext = {}; + MTLSharedEvent_id mtlSharedEvent = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportMetalSharedEventInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ImportMetalSharedEventInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkImportMetalTextureInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMetalTextureInfoEXT.html + struct ImportMetalTextureInfoEXT + { + using NativeType = VkImportMetalTextureInfoEXT; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMetalTextureInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportMetalTextureInfoEXT( ImageAspectFlagBits plane_ = ImageAspectFlagBits::eColor, + MTLTexture_id mtlTexture_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , plane{ plane_ } + , mtlTexture{ mtlTexture_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportMetalTextureInfoEXT( ImportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportMetalTextureInfoEXT( VkImportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportMetalTextureInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ImportMetalTextureInfoEXT & operator=( ImportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportMetalTextureInfoEXT & operator=( VkImportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT & setPlane( ImageAspectFlagBits plane_ ) & VULKAN_HPP_NOEXCEPT + { + plane = plane_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT && setPlane( ImageAspectFlagBits plane_ ) && VULKAN_HPP_NOEXCEPT + { + plane = plane_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT & setMtlTexture( MTLTexture_id mtlTexture_ ) & VULKAN_HPP_NOEXCEPT + { + mtlTexture = mtlTexture_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT && setMtlTexture( MTLTexture_id mtlTexture_ ) && VULKAN_HPP_NOEXCEPT + { + mtlTexture = mtlTexture_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportMetalTextureInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMetalTextureInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportMetalTextureInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportMetalTextureInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, plane, mtlTexture ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportMetalTextureInfoEXT const & ) const = default; +# else + bool operator==( ImportMetalTextureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( plane == rhs.plane ) && ( mtlTexture == rhs.mtlTexture ); +# endif + } + + bool operator!=( ImportMetalTextureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportMetalTextureInfoEXT; + const void * pNext = {}; + ImageAspectFlagBits plane = ImageAspectFlagBits::eColor; + MTLTexture_id mtlTexture = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportMetalTextureInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = ImportMetalTextureInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_OHOS ) + // wrapper struct for struct VkImportNativeBufferInfoOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportNativeBufferInfoOHOS.html + struct ImportNativeBufferInfoOHOS + { + using NativeType = VkImportNativeBufferInfoOHOS; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportNativeBufferInfoOHOS; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportNativeBufferInfoOHOS( struct OH_NativeBuffer * buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , buffer{ buffer_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportNativeBufferInfoOHOS( ImportNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportNativeBufferInfoOHOS( VkImportNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportNativeBufferInfoOHOS( *reinterpret_cast( &rhs ) ) + { + } + + ImportNativeBufferInfoOHOS & operator=( ImportNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportNativeBufferInfoOHOS & operator=( VkImportNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportNativeBufferInfoOHOS & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportNativeBufferInfoOHOS && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportNativeBufferInfoOHOS & setBuffer( struct OH_NativeBuffer * buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportNativeBufferInfoOHOS && setBuffer( struct OH_NativeBuffer * buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportNativeBufferInfoOHOS const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportNativeBufferInfoOHOS &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportNativeBufferInfoOHOS const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportNativeBufferInfoOHOS *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportNativeBufferInfoOHOS const & ) const = default; +# else + bool operator==( ImportNativeBufferInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); +# endif + } + + bool operator!=( ImportNativeBufferInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportNativeBufferInfoOHOS; + const void * pNext = {}; + struct OH_NativeBuffer * buffer = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportNativeBufferInfoOHOS; + }; +# endif + + template <> + struct CppType + { + using Type = ImportNativeBufferInfoOHOS; + }; +#endif /*VK_USE_PLATFORM_OHOS*/ + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + // wrapper struct for struct VkImportScreenBufferInfoQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportScreenBufferInfoQNX.html + struct ImportScreenBufferInfoQNX + { + using NativeType = VkImportScreenBufferInfoQNX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportScreenBufferInfoQNX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportScreenBufferInfoQNX( struct _screen_buffer * buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , buffer{ buffer_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportScreenBufferInfoQNX( ImportScreenBufferInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportScreenBufferInfoQNX( VkImportScreenBufferInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportScreenBufferInfoQNX( *reinterpret_cast( &rhs ) ) + { + } + + ImportScreenBufferInfoQNX & operator=( ImportScreenBufferInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportScreenBufferInfoQNX & operator=( VkImportScreenBufferInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportScreenBufferInfoQNX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportScreenBufferInfoQNX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportScreenBufferInfoQNX & setBuffer( struct _screen_buffer * buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportScreenBufferInfoQNX && setBuffer( struct _screen_buffer * buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportScreenBufferInfoQNX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportScreenBufferInfoQNX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportScreenBufferInfoQNX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportScreenBufferInfoQNX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, buffer ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportScreenBufferInfoQNX const & ) const = default; +# else + bool operator==( ImportScreenBufferInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); +# endif + } + + bool operator!=( ImportScreenBufferInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportScreenBufferInfoQNX; + const void * pNext = {}; + struct _screen_buffer * buffer = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportScreenBufferInfoQNX; + }; +# endif + + template <> + struct CppType + { + using Type = ImportScreenBufferInfoQNX; + }; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + // wrapper struct for struct VkImportSemaphoreFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportSemaphoreFdInfoKHR.html + struct ImportSemaphoreFdInfoKHR + { + using NativeType = VkImportSemaphoreFdInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportSemaphoreFdInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = {}, + SemaphoreImportFlags flags_ = {}, + ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, + int fd_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , semaphore{ semaphore_ } + , flags{ flags_ } + , handleType{ handleType_ } + , fd{ fd_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( ImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportSemaphoreFdInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ImportSemaphoreFdInfoKHR & operator=( ImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportSemaphoreFdInfoKHR & operator=( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR & setFlags( SemaphoreImportFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR && setFlags( SemaphoreImportFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR & setFd( int fd_ ) & VULKAN_HPP_NOEXCEPT + { + fd = fd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR && setFd( int fd_ ) && VULKAN_HPP_NOEXCEPT + { + fd = fd_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportSemaphoreFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportSemaphoreFdInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportSemaphoreFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportSemaphoreFdInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, flags, handleType, fd ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportSemaphoreFdInfoKHR const & ) const = default; +#else + bool operator==( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && + ( fd == rhs.fd ); +# endif + } + + bool operator!=( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eImportSemaphoreFdInfoKHR; + const void * pNext = {}; + Semaphore semaphore = {}; + SemaphoreImportFlags flags = {}; + ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; + int fd = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportSemaphoreFdInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = ImportSemaphoreFdInfoKHR; + }; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkImportSemaphoreWin32HandleInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportSemaphoreWin32HandleInfoKHR.html + struct ImportSemaphoreWin32HandleInfoKHR + { + using NativeType = VkImportSemaphoreWin32HandleInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportSemaphoreWin32HandleInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = {}, + SemaphoreImportFlags flags_ = {}, + ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, + HANDLE handle_ = {}, + LPCWSTR name_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , semaphore{ semaphore_ } + , flags{ flags_ } + , handleType{ handleType_ } + , handle{ handle_ } + , name{ name_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( ImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportSemaphoreWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ImportSemaphoreWin32HandleInfoKHR & operator=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportSemaphoreWin32HandleInfoKHR & operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setFlags( SemaphoreImportFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setFlags( SemaphoreImportFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setHandle( HANDLE handle_ ) & VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setHandle( HANDLE handle_ ) && VULKAN_HPP_NOEXCEPT + { + handle = handle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT + { + name = name_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT + { + name = name_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportSemaphoreWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportSemaphoreWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, flags, handleType, handle, name ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ImportSemaphoreWin32HandleInfoKHR const & ) const = default; +# else + bool operator==( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && + ( handle == rhs.handle ) && ( name == rhs.name ); +# endif + } + + bool operator!=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR; + const void * pNext = {}; + Semaphore semaphore = {}; + SemaphoreImportFlags flags = {}; + ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; + HANDLE handle = {}; + LPCWSTR name = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportSemaphoreWin32HandleInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = ImportSemaphoreWin32HandleInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkImportSemaphoreZirconHandleInfoFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportSemaphoreZirconHandleInfoFUCHSIA.html + struct ImportSemaphoreZirconHandleInfoFUCHSIA + { + using NativeType = VkImportSemaphoreZirconHandleInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportSemaphoreZirconHandleInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + ImportSemaphoreZirconHandleInfoFUCHSIA( Semaphore semaphore_ = {}, + SemaphoreImportFlags flags_ = {}, + ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, + zx_handle_t zirconHandle_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , semaphore{ semaphore_ } + , flags{ flags_ } + , handleType{ handleType_ } + , zirconHandle{ zirconHandle_ } + { + } + + VULKAN_HPP_CONSTEXPR ImportSemaphoreZirconHandleInfoFUCHSIA( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ImportSemaphoreZirconHandleInfoFUCHSIA( VkImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : ImportSemaphoreZirconHandleInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + ImportSemaphoreZirconHandleInfoFUCHSIA & operator=( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ImportSemaphoreZirconHandleInfoFUCHSIA & operator=( VkImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA & setFlags( SemaphoreImportFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA && setFlags( SemaphoreImportFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA & setZirconHandle( zx_handle_t zirconHandle_ ) & VULKAN_HPP_NOEXCEPT + { + zirconHandle = zirconHandle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA && setZirconHandle( zx_handle_t zirconHandle_ ) && VULKAN_HPP_NOEXCEPT + { + zirconHandle = zirconHandle_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkImportSemaphoreZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportSemaphoreZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkImportSemaphoreZirconHandleInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkImportSemaphoreZirconHandleInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, flags, handleType, zirconHandle ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = semaphore <=> rhs.semaphore; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = handleType <=> rhs.handleType; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &zirconHandle, &rhs.zirconHandle, sizeof( zx_handle_t ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && + ( memcmp( &zirconHandle, &rhs.zirconHandle, sizeof( zx_handle_t ) ) == 0 ); + } + + bool operator!=( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eImportSemaphoreZirconHandleInfoFUCHSIA; + const void * pNext = {}; + Semaphore semaphore = {}; + SemaphoreImportFlags flags = {}; + ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; + zx_handle_t zirconHandle = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ImportSemaphoreZirconHandleInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = ImportSemaphoreZirconHandleInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + // wrapper struct for struct VkIndirectCommandsExecutionSetTokenEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsExecutionSetTokenEXT.html + struct IndirectCommandsExecutionSetTokenEXT + { + using NativeType = VkIndirectCommandsExecutionSetTokenEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR IndirectCommandsExecutionSetTokenEXT( IndirectExecutionSetInfoTypeEXT type_ = IndirectExecutionSetInfoTypeEXT::ePipelines, + ShaderStageFlags shaderStages_ = {} ) VULKAN_HPP_NOEXCEPT + : type{ type_ } + , shaderStages{ shaderStages_ } + { + } + + VULKAN_HPP_CONSTEXPR IndirectCommandsExecutionSetTokenEXT( IndirectCommandsExecutionSetTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectCommandsExecutionSetTokenEXT( VkIndirectCommandsExecutionSetTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectCommandsExecutionSetTokenEXT( *reinterpret_cast( &rhs ) ) + { + } + + IndirectCommandsExecutionSetTokenEXT & operator=( IndirectCommandsExecutionSetTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectCommandsExecutionSetTokenEXT & operator=( VkIndirectCommandsExecutionSetTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsExecutionSetTokenEXT & setType( IndirectExecutionSetInfoTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsExecutionSetTokenEXT && setType( IndirectExecutionSetInfoTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsExecutionSetTokenEXT & setShaderStages( ShaderStageFlags shaderStages_ ) & VULKAN_HPP_NOEXCEPT + { + shaderStages = shaderStages_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsExecutionSetTokenEXT && setShaderStages( ShaderStageFlags shaderStages_ ) && VULKAN_HPP_NOEXCEPT + { + shaderStages = shaderStages_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectCommandsExecutionSetTokenEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsExecutionSetTokenEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsExecutionSetTokenEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectCommandsExecutionSetTokenEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( type, shaderStages ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectCommandsExecutionSetTokenEXT const & ) const = default; +#else + bool operator==( IndirectCommandsExecutionSetTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( type == rhs.type ) && ( shaderStages == rhs.shaderStages ); +# endif + } + + bool operator!=( IndirectCommandsExecutionSetTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + IndirectExecutionSetInfoTypeEXT type = IndirectExecutionSetInfoTypeEXT::ePipelines; + ShaderStageFlags shaderStages = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectCommandsExecutionSetTokenEXT; + }; +#endif + + // wrapper struct for struct VkIndirectCommandsIndexBufferTokenEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsIndexBufferTokenEXT.html + struct IndirectCommandsIndexBufferTokenEXT + { + using NativeType = VkIndirectCommandsIndexBufferTokenEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR IndirectCommandsIndexBufferTokenEXT( + IndirectCommandsInputModeFlagBitsEXT mode_ = IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer ) VULKAN_HPP_NOEXCEPT : mode{ mode_ } + { + } + + VULKAN_HPP_CONSTEXPR IndirectCommandsIndexBufferTokenEXT( IndirectCommandsIndexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectCommandsIndexBufferTokenEXT( VkIndirectCommandsIndexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectCommandsIndexBufferTokenEXT( *reinterpret_cast( &rhs ) ) + { + } + + IndirectCommandsIndexBufferTokenEXT & operator=( IndirectCommandsIndexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectCommandsIndexBufferTokenEXT & operator=( VkIndirectCommandsIndexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsIndexBufferTokenEXT & setMode( IndirectCommandsInputModeFlagBitsEXT mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsIndexBufferTokenEXT && setMode( IndirectCommandsInputModeFlagBitsEXT mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectCommandsIndexBufferTokenEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsIndexBufferTokenEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsIndexBufferTokenEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectCommandsIndexBufferTokenEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( mode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectCommandsIndexBufferTokenEXT const & ) const = default; +#else + bool operator==( IndirectCommandsIndexBufferTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( mode == rhs.mode ); +# endif + } + + bool operator!=( IndirectCommandsIndexBufferTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + IndirectCommandsInputModeFlagBitsEXT mode = IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectCommandsIndexBufferTokenEXT; + }; +#endif + + // wrapper struct for struct VkPushConstantRange, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushConstantRange.html + struct PushConstantRange + { + using NativeType = VkPushConstantRange; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PushConstantRange( ShaderStageFlags stageFlags_ = {}, uint32_t offset_ = {}, uint32_t size_ = {} ) VULKAN_HPP_NOEXCEPT + : stageFlags{ stageFlags_ } + , offset{ offset_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR PushConstantRange( PushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PushConstantRange( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT : PushConstantRange( *reinterpret_cast( &rhs ) ) {} + + PushConstantRange & operator=( PushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PushConstantRange & operator=( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PushConstantRange & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantRange && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantRange & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantRange && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantRange & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantRange && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPushConstantRange const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushConstantRange &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushConstantRange const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPushConstantRange *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( stageFlags, offset, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PushConstantRange const & ) const = default; +#else + bool operator==( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( stageFlags == rhs.stageFlags ) && ( offset == rhs.offset ) && ( size == rhs.size ); +# endif + } + + bool operator!=( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ShaderStageFlags stageFlags = {}; + uint32_t offset = {}; + uint32_t size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PushConstantRange; + }; +#endif + + // wrapper struct for struct VkIndirectCommandsPushConstantTokenEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsPushConstantTokenEXT.html + struct IndirectCommandsPushConstantTokenEXT + { + using NativeType = VkIndirectCommandsPushConstantTokenEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR IndirectCommandsPushConstantTokenEXT( PushConstantRange updateRange_ = {} ) VULKAN_HPP_NOEXCEPT : updateRange{ updateRange_ } {} + + VULKAN_HPP_CONSTEXPR IndirectCommandsPushConstantTokenEXT( IndirectCommandsPushConstantTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectCommandsPushConstantTokenEXT( VkIndirectCommandsPushConstantTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectCommandsPushConstantTokenEXT( *reinterpret_cast( &rhs ) ) + { + } + + IndirectCommandsPushConstantTokenEXT & operator=( IndirectCommandsPushConstantTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectCommandsPushConstantTokenEXT & operator=( VkIndirectCommandsPushConstantTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsPushConstantTokenEXT & setUpdateRange( PushConstantRange const & updateRange_ ) & VULKAN_HPP_NOEXCEPT + { + updateRange = updateRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsPushConstantTokenEXT && setUpdateRange( PushConstantRange const & updateRange_ ) && VULKAN_HPP_NOEXCEPT + { + updateRange = updateRange_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectCommandsPushConstantTokenEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsPushConstantTokenEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsPushConstantTokenEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectCommandsPushConstantTokenEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( updateRange ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectCommandsPushConstantTokenEXT const & ) const = default; +#else + bool operator==( IndirectCommandsPushConstantTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( updateRange == rhs.updateRange ); +# endif + } + + bool operator!=( IndirectCommandsPushConstantTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + PushConstantRange updateRange = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectCommandsPushConstantTokenEXT; + }; +#endif + + // wrapper struct for struct VkIndirectCommandsVertexBufferTokenEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsVertexBufferTokenEXT.html + struct IndirectCommandsVertexBufferTokenEXT + { + using NativeType = VkIndirectCommandsVertexBufferTokenEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR IndirectCommandsVertexBufferTokenEXT( uint32_t vertexBindingUnit_ = {} ) VULKAN_HPP_NOEXCEPT : vertexBindingUnit{ vertexBindingUnit_ } + { + } + + VULKAN_HPP_CONSTEXPR IndirectCommandsVertexBufferTokenEXT( IndirectCommandsVertexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectCommandsVertexBufferTokenEXT( VkIndirectCommandsVertexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectCommandsVertexBufferTokenEXT( *reinterpret_cast( &rhs ) ) + { + } + + IndirectCommandsVertexBufferTokenEXT & operator=( IndirectCommandsVertexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectCommandsVertexBufferTokenEXT & operator=( VkIndirectCommandsVertexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsVertexBufferTokenEXT & setVertexBindingUnit( uint32_t vertexBindingUnit_ ) & VULKAN_HPP_NOEXCEPT + { + vertexBindingUnit = vertexBindingUnit_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsVertexBufferTokenEXT && setVertexBindingUnit( uint32_t vertexBindingUnit_ ) && VULKAN_HPP_NOEXCEPT + { + vertexBindingUnit = vertexBindingUnit_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectCommandsVertexBufferTokenEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsVertexBufferTokenEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsVertexBufferTokenEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectCommandsVertexBufferTokenEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( vertexBindingUnit ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectCommandsVertexBufferTokenEXT const & ) const = default; +#else + bool operator==( IndirectCommandsVertexBufferTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( vertexBindingUnit == rhs.vertexBindingUnit ); +# endif + } + + bool operator!=( IndirectCommandsVertexBufferTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t vertexBindingUnit = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectCommandsVertexBufferTokenEXT; + }; +#endif + + union IndirectCommandsTokenDataEXT + { + using NativeType = VkIndirectCommandsTokenDataEXT; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT( const IndirectCommandsPushConstantTokenEXT * pPushConstant_ = {} ) : pPushConstant( pPushConstant_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT( const IndirectCommandsVertexBufferTokenEXT * pVertexBuffer_ ) : pVertexBuffer( pVertexBuffer_ ) {} + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT( const IndirectCommandsIndexBufferTokenEXT * pIndexBuffer_ ) : pIndexBuffer( pIndexBuffer_ ) {} + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT( const IndirectCommandsExecutionSetTokenEXT * pExecutionSet_ ) : pExecutionSet( pExecutionSet_ ) {} +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT & setPPushConstant( const IndirectCommandsPushConstantTokenEXT * pPushConstant_ ) & VULKAN_HPP_NOEXCEPT + { + pPushConstant = pPushConstant_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT && setPPushConstant( const IndirectCommandsPushConstantTokenEXT * pPushConstant_ ) && + VULKAN_HPP_NOEXCEPT + { + pPushConstant = pPushConstant_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT & setPVertexBuffer( const IndirectCommandsVertexBufferTokenEXT * pVertexBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + pVertexBuffer = pVertexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT && setPVertexBuffer( const IndirectCommandsVertexBufferTokenEXT * pVertexBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + pVertexBuffer = pVertexBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT & setPIndexBuffer( const IndirectCommandsIndexBufferTokenEXT * pIndexBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + pIndexBuffer = pIndexBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT && setPIndexBuffer( const IndirectCommandsIndexBufferTokenEXT * pIndexBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + pIndexBuffer = pIndexBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT & setPExecutionSet( const IndirectCommandsExecutionSetTokenEXT * pExecutionSet_ ) & VULKAN_HPP_NOEXCEPT + { + pExecutionSet = pExecutionSet_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT && setPExecutionSet( const IndirectCommandsExecutionSetTokenEXT * pExecutionSet_ ) && + VULKAN_HPP_NOEXCEPT + { + pExecutionSet = pExecutionSet_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectCommandsTokenDataEXT const &() const + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsTokenDataEXT &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + const IndirectCommandsPushConstantTokenEXT * pPushConstant; + const IndirectCommandsVertexBufferTokenEXT * pVertexBuffer; + const IndirectCommandsIndexBufferTokenEXT * pIndexBuffer; + const IndirectCommandsExecutionSetTokenEXT * pExecutionSet; +#else + const VkIndirectCommandsPushConstantTokenEXT * pPushConstant; + const VkIndirectCommandsVertexBufferTokenEXT * pVertexBuffer; + const VkIndirectCommandsIndexBufferTokenEXT * pIndexBuffer; + const VkIndirectCommandsExecutionSetTokenEXT * pExecutionSet; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectCommandsTokenDataEXT; + }; +#endif + + // wrapper struct for struct VkIndirectCommandsLayoutTokenEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutTokenEXT.html + struct IndirectCommandsLayoutTokenEXT + { + using NativeType = VkIndirectCommandsLayoutTokenEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutTokenEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT( IndirectCommandsTokenTypeEXT type_ = IndirectCommandsTokenTypeEXT::eExecutionSet, + IndirectCommandsTokenDataEXT data_ = {}, + uint32_t offset_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , data{ data_ } + , offset{ offset_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT( IndirectCommandsLayoutTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectCommandsLayoutTokenEXT( VkIndirectCommandsLayoutTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectCommandsLayoutTokenEXT( *reinterpret_cast( &rhs ) ) + { + } + + IndirectCommandsLayoutTokenEXT & operator=( IndirectCommandsLayoutTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectCommandsLayoutTokenEXT & operator=( VkIndirectCommandsLayoutTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT & setType( IndirectCommandsTokenTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT && setType( IndirectCommandsTokenTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT & setData( IndirectCommandsTokenDataEXT const & data_ ) & VULKAN_HPP_NOEXCEPT + { + data = data_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT && setData( IndirectCommandsTokenDataEXT const & data_ ) && VULKAN_HPP_NOEXCEPT + { + data = data_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectCommandsLayoutTokenEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutTokenEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutTokenEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutTokenEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, data, offset ); + } +#endif + + public: + StructureType sType = StructureType::eIndirectCommandsLayoutTokenEXT; + const void * pNext = {}; + IndirectCommandsTokenTypeEXT type = IndirectCommandsTokenTypeEXT::eExecutionSet; + IndirectCommandsTokenDataEXT data = {}; + uint32_t offset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectCommandsLayoutTokenEXT; + }; +#endif + + template <> + struct CppType + { + using Type = IndirectCommandsLayoutTokenEXT; + }; + + // wrapper struct for struct VkIndirectCommandsLayoutCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutCreateInfoEXT.html + struct IndirectCommandsLayoutCreateInfoEXT + { + using NativeType = VkIndirectCommandsLayoutCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoEXT( IndirectCommandsLayoutUsageFlagsEXT flags_ = {}, + ShaderStageFlags shaderStages_ = {}, + uint32_t indirectStride_ = {}, + PipelineLayout pipelineLayout_ = {}, + uint32_t tokenCount_ = {}, + const IndirectCommandsLayoutTokenEXT * pTokens_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , shaderStages{ shaderStages_ } + , indirectStride{ indirectStride_ } + , pipelineLayout{ pipelineLayout_ } + , tokenCount{ tokenCount_ } + , pTokens{ pTokens_ } + { + } + + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoEXT( IndirectCommandsLayoutCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectCommandsLayoutCreateInfoEXT( VkIndirectCommandsLayoutCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectCommandsLayoutCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectCommandsLayoutCreateInfoEXT( IndirectCommandsLayoutUsageFlagsEXT flags_, + ShaderStageFlags shaderStages_, + uint32_t indirectStride_, + PipelineLayout pipelineLayout_, + ArrayProxyNoTemporaries const & tokens_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , shaderStages( shaderStages_ ) + , indirectStride( indirectStride_ ) + , pipelineLayout( pipelineLayout_ ) + , tokenCount( static_cast( tokens_.size() ) ) + , pTokens( tokens_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + IndirectCommandsLayoutCreateInfoEXT & operator=( IndirectCommandsLayoutCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectCommandsLayoutCreateInfoEXT & operator=( VkIndirectCommandsLayoutCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setFlags( IndirectCommandsLayoutUsageFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setFlags( IndirectCommandsLayoutUsageFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setShaderStages( ShaderStageFlags shaderStages_ ) & VULKAN_HPP_NOEXCEPT + { + shaderStages = shaderStages_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setShaderStages( ShaderStageFlags shaderStages_ ) && VULKAN_HPP_NOEXCEPT + { + shaderStages = shaderStages_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setIndirectStride( uint32_t indirectStride_ ) & VULKAN_HPP_NOEXCEPT + { + indirectStride = indirectStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setIndirectStride( uint32_t indirectStride_ ) && VULKAN_HPP_NOEXCEPT + { + indirectStride = indirectStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setPipelineLayout( PipelineLayout pipelineLayout_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineLayout = pipelineLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setPipelineLayout( PipelineLayout pipelineLayout_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineLayout = pipelineLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setTokenCount( uint32_t tokenCount_ ) & VULKAN_HPP_NOEXCEPT + { + tokenCount = tokenCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setTokenCount( uint32_t tokenCount_ ) && VULKAN_HPP_NOEXCEPT + { + tokenCount = tokenCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setPTokens( const IndirectCommandsLayoutTokenEXT * pTokens_ ) & VULKAN_HPP_NOEXCEPT + { + pTokens = pTokens_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setPTokens( const IndirectCommandsLayoutTokenEXT * pTokens_ ) && VULKAN_HPP_NOEXCEPT + { + pTokens = pTokens_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectCommandsLayoutCreateInfoEXT & setTokens( ArrayProxyNoTemporaries const & tokens_ ) VULKAN_HPP_NOEXCEPT + { + tokenCount = static_cast( tokens_.size() ); + pTokens = tokens_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectCommandsLayoutCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, shaderStages, indirectStride, pipelineLayout, tokenCount, pTokens ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectCommandsLayoutCreateInfoEXT const & ) const = default; +#else + bool operator==( IndirectCommandsLayoutCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( shaderStages == rhs.shaderStages ) && + ( indirectStride == rhs.indirectStride ) && ( pipelineLayout == rhs.pipelineLayout ) && ( tokenCount == rhs.tokenCount ) && + ( pTokens == rhs.pTokens ); +# endif + } + + bool operator!=( IndirectCommandsLayoutCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoEXT; + const void * pNext = {}; + IndirectCommandsLayoutUsageFlagsEXT flags = {}; + ShaderStageFlags shaderStages = {}; + uint32_t indirectStride = {}; + PipelineLayout pipelineLayout = {}; + uint32_t tokenCount = {}; + const IndirectCommandsLayoutTokenEXT * pTokens = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectCommandsLayoutCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = IndirectCommandsLayoutCreateInfoEXT; + }; + + // wrapper struct for struct VkIndirectCommandsLayoutTokenNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutTokenNV.html + struct IndirectCommandsLayoutTokenNV + { + using NativeType = VkIndirectCommandsLayoutTokenNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutTokenNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNV( IndirectCommandsTokenTypeNV tokenType_ = IndirectCommandsTokenTypeNV::eShaderGroup, + uint32_t stream_ = {}, + uint32_t offset_ = {}, + uint32_t vertexBindingUnit_ = {}, + Bool32 vertexDynamicStride_ = {}, + PipelineLayout pushconstantPipelineLayout_ = {}, + ShaderStageFlags pushconstantShaderStageFlags_ = {}, + uint32_t pushconstantOffset_ = {}, + uint32_t pushconstantSize_ = {}, + IndirectStateFlagsNV indirectStateFlags_ = {}, + uint32_t indexTypeCount_ = {}, + const IndexType * pIndexTypes_ = {}, + const uint32_t * pIndexTypeValues_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tokenType{ tokenType_ } + , stream{ stream_ } + , offset{ offset_ } + , vertexBindingUnit{ vertexBindingUnit_ } + , vertexDynamicStride{ vertexDynamicStride_ } + , pushconstantPipelineLayout{ pushconstantPipelineLayout_ } + , pushconstantShaderStageFlags{ pushconstantShaderStageFlags_ } + , pushconstantOffset{ pushconstantOffset_ } + , pushconstantSize{ pushconstantSize_ } + , indirectStateFlags{ indirectStateFlags_ } + , indexTypeCount{ indexTypeCount_ } + , pIndexTypes{ pIndexTypes_ } + , pIndexTypeValues{ pIndexTypeValues_ } + { + } + + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNV( IndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectCommandsLayoutTokenNV( VkIndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectCommandsLayoutTokenNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectCommandsLayoutTokenNV( IndirectCommandsTokenTypeNV tokenType_, + uint32_t stream_, + uint32_t offset_, + uint32_t vertexBindingUnit_, + Bool32 vertexDynamicStride_, + PipelineLayout pushconstantPipelineLayout_, + ShaderStageFlags pushconstantShaderStageFlags_, + uint32_t pushconstantOffset_, + uint32_t pushconstantSize_, + IndirectStateFlagsNV indirectStateFlags_, + ArrayProxyNoTemporaries const & indexTypes_, + ArrayProxyNoTemporaries const & indexTypeValues_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , tokenType( tokenType_ ) + , stream( stream_ ) + , offset( offset_ ) + , vertexBindingUnit( vertexBindingUnit_ ) + , vertexDynamicStride( vertexDynamicStride_ ) + , pushconstantPipelineLayout( pushconstantPipelineLayout_ ) + , pushconstantShaderStageFlags( pushconstantShaderStageFlags_ ) + , pushconstantOffset( pushconstantOffset_ ) + , pushconstantSize( pushconstantSize_ ) + , indirectStateFlags( indirectStateFlags_ ) + , indexTypeCount( static_cast( indexTypes_.size() ) ) + , pIndexTypes( indexTypes_.data() ) + , pIndexTypeValues( indexTypeValues_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( indexTypes_.size() == indexTypeValues_.size() ); +# else + if ( indexTypes_.size() != indexTypeValues_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::IndirectCommandsLayoutTokenNV::IndirectCommandsLayoutTokenNV: indexTypes_.size() != indexTypeValues_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + IndirectCommandsLayoutTokenNV & operator=( IndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectCommandsLayoutTokenNV & operator=( VkIndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setTokenType( IndirectCommandsTokenTypeNV tokenType_ ) & VULKAN_HPP_NOEXCEPT + { + tokenType = tokenType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setTokenType( IndirectCommandsTokenTypeNV tokenType_ ) && VULKAN_HPP_NOEXCEPT + { + tokenType = tokenType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setStream( uint32_t stream_ ) & VULKAN_HPP_NOEXCEPT + { + stream = stream_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setStream( uint32_t stream_ ) && VULKAN_HPP_NOEXCEPT + { + stream = stream_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setVertexBindingUnit( uint32_t vertexBindingUnit_ ) & VULKAN_HPP_NOEXCEPT + { + vertexBindingUnit = vertexBindingUnit_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setVertexBindingUnit( uint32_t vertexBindingUnit_ ) && VULKAN_HPP_NOEXCEPT + { + vertexBindingUnit = vertexBindingUnit_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setVertexDynamicStride( Bool32 vertexDynamicStride_ ) & VULKAN_HPP_NOEXCEPT + { + vertexDynamicStride = vertexDynamicStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setVertexDynamicStride( Bool32 vertexDynamicStride_ ) && VULKAN_HPP_NOEXCEPT + { + vertexDynamicStride = vertexDynamicStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPushconstantPipelineLayout( PipelineLayout pushconstantPipelineLayout_ ) & VULKAN_HPP_NOEXCEPT + { + pushconstantPipelineLayout = pushconstantPipelineLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPushconstantPipelineLayout( PipelineLayout pushconstantPipelineLayout_ ) && VULKAN_HPP_NOEXCEPT + { + pushconstantPipelineLayout = pushconstantPipelineLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPushconstantShaderStageFlags( ShaderStageFlags pushconstantShaderStageFlags_ ) & + VULKAN_HPP_NOEXCEPT + { + pushconstantShaderStageFlags = pushconstantShaderStageFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPushconstantShaderStageFlags( ShaderStageFlags pushconstantShaderStageFlags_ ) && + VULKAN_HPP_NOEXCEPT + { + pushconstantShaderStageFlags = pushconstantShaderStageFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPushconstantOffset( uint32_t pushconstantOffset_ ) & VULKAN_HPP_NOEXCEPT + { + pushconstantOffset = pushconstantOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPushconstantOffset( uint32_t pushconstantOffset_ ) && VULKAN_HPP_NOEXCEPT + { + pushconstantOffset = pushconstantOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPushconstantSize( uint32_t pushconstantSize_ ) & VULKAN_HPP_NOEXCEPT + { + pushconstantSize = pushconstantSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPushconstantSize( uint32_t pushconstantSize_ ) && VULKAN_HPP_NOEXCEPT + { + pushconstantSize = pushconstantSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setIndirectStateFlags( IndirectStateFlagsNV indirectStateFlags_ ) & VULKAN_HPP_NOEXCEPT + { + indirectStateFlags = indirectStateFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setIndirectStateFlags( IndirectStateFlagsNV indirectStateFlags_ ) && VULKAN_HPP_NOEXCEPT + { + indirectStateFlags = indirectStateFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setIndexTypeCount( uint32_t indexTypeCount_ ) & VULKAN_HPP_NOEXCEPT + { + indexTypeCount = indexTypeCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setIndexTypeCount( uint32_t indexTypeCount_ ) && VULKAN_HPP_NOEXCEPT + { + indexTypeCount = indexTypeCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPIndexTypes( const IndexType * pIndexTypes_ ) & VULKAN_HPP_NOEXCEPT + { + pIndexTypes = pIndexTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPIndexTypes( const IndexType * pIndexTypes_ ) && VULKAN_HPP_NOEXCEPT + { + pIndexTypes = pIndexTypes_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectCommandsLayoutTokenNV & setIndexTypes( ArrayProxyNoTemporaries const & indexTypes_ ) VULKAN_HPP_NOEXCEPT + { + indexTypeCount = static_cast( indexTypes_.size() ); + pIndexTypes = indexTypes_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPIndexTypeValues( const uint32_t * pIndexTypeValues_ ) & VULKAN_HPP_NOEXCEPT + { + pIndexTypeValues = pIndexTypeValues_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPIndexTypeValues( const uint32_t * pIndexTypeValues_ ) && VULKAN_HPP_NOEXCEPT + { + pIndexTypeValues = pIndexTypeValues_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectCommandsLayoutTokenNV & setIndexTypeValues( ArrayProxyNoTemporaries const & indexTypeValues_ ) VULKAN_HPP_NOEXCEPT + { + indexTypeCount = static_cast( indexTypeValues_.size() ); + pIndexTypeValues = indexTypeValues_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectCommandsLayoutTokenNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutTokenNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutTokenNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutTokenNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + tokenType, + stream, + offset, + vertexBindingUnit, + vertexDynamicStride, + pushconstantPipelineLayout, + pushconstantShaderStageFlags, + pushconstantOffset, + pushconstantSize, + indirectStateFlags, + indexTypeCount, + pIndexTypes, + pIndexTypeValues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectCommandsLayoutTokenNV const & ) const = default; +#else + bool operator==( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tokenType == rhs.tokenType ) && ( stream == rhs.stream ) && ( offset == rhs.offset ) && + ( vertexBindingUnit == rhs.vertexBindingUnit ) && ( vertexDynamicStride == rhs.vertexDynamicStride ) && + ( pushconstantPipelineLayout == rhs.pushconstantPipelineLayout ) && ( pushconstantShaderStageFlags == rhs.pushconstantShaderStageFlags ) && + ( pushconstantOffset == rhs.pushconstantOffset ) && ( pushconstantSize == rhs.pushconstantSize ) && + ( indirectStateFlags == rhs.indirectStateFlags ) && ( indexTypeCount == rhs.indexTypeCount ) && ( pIndexTypes == rhs.pIndexTypes ) && + ( pIndexTypeValues == rhs.pIndexTypeValues ); +# endif + } + + bool operator!=( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eIndirectCommandsLayoutTokenNV; + const void * pNext = {}; + IndirectCommandsTokenTypeNV tokenType = IndirectCommandsTokenTypeNV::eShaderGroup; + uint32_t stream = {}; + uint32_t offset = {}; + uint32_t vertexBindingUnit = {}; + Bool32 vertexDynamicStride = {}; + PipelineLayout pushconstantPipelineLayout = {}; + ShaderStageFlags pushconstantShaderStageFlags = {}; + uint32_t pushconstantOffset = {}; + uint32_t pushconstantSize = {}; + IndirectStateFlagsNV indirectStateFlags = {}; + uint32_t indexTypeCount = {}; + const IndexType * pIndexTypes = {}; + const uint32_t * pIndexTypeValues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectCommandsLayoutTokenNV; + }; +#endif + + template <> + struct CppType + { + using Type = IndirectCommandsLayoutTokenNV; + }; + + // wrapper struct for struct VkIndirectCommandsLayoutCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutCreateInfoNV.html + struct IndirectCommandsLayoutCreateInfoNV + { + using NativeType = VkIndirectCommandsLayoutCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNV( IndirectCommandsLayoutUsageFlagsNV flags_ = {}, + PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + uint32_t tokenCount_ = {}, + const IndirectCommandsLayoutTokenNV * pTokens_ = {}, + uint32_t streamCount_ = {}, + const uint32_t * pStreamStrides_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pipelineBindPoint{ pipelineBindPoint_ } + , tokenCount{ tokenCount_ } + , pTokens{ pTokens_ } + , streamCount{ streamCount_ } + , pStreamStrides{ pStreamStrides_ } + { + } + + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNV( IndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectCommandsLayoutCreateInfoNV( VkIndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectCommandsLayoutCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectCommandsLayoutCreateInfoNV( IndirectCommandsLayoutUsageFlagsNV flags_, + PipelineBindPoint pipelineBindPoint_, + ArrayProxyNoTemporaries const & tokens_, + ArrayProxyNoTemporaries const & streamStrides_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , tokenCount( static_cast( tokens_.size() ) ) + , pTokens( tokens_.data() ) + , streamCount( static_cast( streamStrides_.size() ) ) + , pStreamStrides( streamStrides_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + IndirectCommandsLayoutCreateInfoNV & operator=( IndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectCommandsLayoutCreateInfoNV & operator=( VkIndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setFlags( IndirectCommandsLayoutUsageFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setFlags( IndirectCommandsLayoutUsageFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setTokenCount( uint32_t tokenCount_ ) & VULKAN_HPP_NOEXCEPT + { + tokenCount = tokenCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setTokenCount( uint32_t tokenCount_ ) && VULKAN_HPP_NOEXCEPT + { + tokenCount = tokenCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setPTokens( const IndirectCommandsLayoutTokenNV * pTokens_ ) & VULKAN_HPP_NOEXCEPT + { + pTokens = pTokens_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setPTokens( const IndirectCommandsLayoutTokenNV * pTokens_ ) && VULKAN_HPP_NOEXCEPT + { + pTokens = pTokens_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectCommandsLayoutCreateInfoNV & setTokens( ArrayProxyNoTemporaries const & tokens_ ) VULKAN_HPP_NOEXCEPT + { + tokenCount = static_cast( tokens_.size() ); + pTokens = tokens_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setStreamCount( uint32_t streamCount_ ) & VULKAN_HPP_NOEXCEPT + { + streamCount = streamCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setStreamCount( uint32_t streamCount_ ) && VULKAN_HPP_NOEXCEPT + { + streamCount = streamCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setPStreamStrides( const uint32_t * pStreamStrides_ ) & VULKAN_HPP_NOEXCEPT + { + pStreamStrides = pStreamStrides_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setPStreamStrides( const uint32_t * pStreamStrides_ ) && VULKAN_HPP_NOEXCEPT + { + pStreamStrides = pStreamStrides_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectCommandsLayoutCreateInfoNV & setStreamStrides( ArrayProxyNoTemporaries const & streamStrides_ ) VULKAN_HPP_NOEXCEPT + { + streamCount = static_cast( streamStrides_.size() ); + pStreamStrides = streamStrides_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectCommandsLayoutCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pipelineBindPoint, tokenCount, pTokens, streamCount, pStreamStrides ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectCommandsLayoutCreateInfoNV const & ) const = default; +#else + bool operator==( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && + ( tokenCount == rhs.tokenCount ) && ( pTokens == rhs.pTokens ) && ( streamCount == rhs.streamCount ) && ( pStreamStrides == rhs.pStreamStrides ); +# endif + } + + bool operator!=( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNV; + const void * pNext = {}; + IndirectCommandsLayoutUsageFlagsNV flags = {}; + PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; + uint32_t tokenCount = {}; + const IndirectCommandsLayoutTokenNV * pTokens = {}; + uint32_t streamCount = {}; + const uint32_t * pStreamStrides = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectCommandsLayoutCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = IndirectCommandsLayoutCreateInfoNV; + }; + + // wrapper struct for struct VkIndirectCommandsLayoutPushDataTokenNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutPushDataTokenNV.html + struct IndirectCommandsLayoutPushDataTokenNV + { + using NativeType = VkIndirectCommandsLayoutPushDataTokenNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutPushDataTokenNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + IndirectCommandsLayoutPushDataTokenNV( uint32_t pushDataOffset_ = {}, uint32_t pushDataSize_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pushDataOffset{ pushDataOffset_ } + , pushDataSize{ pushDataSize_ } + { + } + + VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutPushDataTokenNV( IndirectCommandsLayoutPushDataTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectCommandsLayoutPushDataTokenNV( VkIndirectCommandsLayoutPushDataTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectCommandsLayoutPushDataTokenNV( *reinterpret_cast( &rhs ) ) + { + } + + IndirectCommandsLayoutPushDataTokenNV & operator=( IndirectCommandsLayoutPushDataTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectCommandsLayoutPushDataTokenNV & operator=( VkIndirectCommandsLayoutPushDataTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV & setPushDataOffset( uint32_t pushDataOffset_ ) & VULKAN_HPP_NOEXCEPT + { + pushDataOffset = pushDataOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV && setPushDataOffset( uint32_t pushDataOffset_ ) && VULKAN_HPP_NOEXCEPT + { + pushDataOffset = pushDataOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV & setPushDataSize( uint32_t pushDataSize_ ) & VULKAN_HPP_NOEXCEPT + { + pushDataSize = pushDataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV && setPushDataSize( uint32_t pushDataSize_ ) && VULKAN_HPP_NOEXCEPT + { + pushDataSize = pushDataSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectCommandsLayoutPushDataTokenNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutPushDataTokenNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutPushDataTokenNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectCommandsLayoutPushDataTokenNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pushDataOffset, pushDataSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectCommandsLayoutPushDataTokenNV const & ) const = default; +#else + bool operator==( IndirectCommandsLayoutPushDataTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pushDataOffset == rhs.pushDataOffset ) && ( pushDataSize == rhs.pushDataSize ); +# endif + } + + bool operator!=( IndirectCommandsLayoutPushDataTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eIndirectCommandsLayoutPushDataTokenNV; + const void * pNext = {}; + uint32_t pushDataOffset = {}; + uint32_t pushDataSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectCommandsLayoutPushDataTokenNV; + }; +#endif + + template <> + struct CppType + { + using Type = IndirectCommandsLayoutPushDataTokenNV; + }; + + // wrapper struct for struct VkIndirectExecutionSetPipelineInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetPipelineInfoEXT.html + struct IndirectExecutionSetPipelineInfoEXT + { + using NativeType = VkIndirectExecutionSetPipelineInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectExecutionSetPipelineInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + IndirectExecutionSetPipelineInfoEXT( Pipeline initialPipeline_ = {}, uint32_t maxPipelineCount_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , initialPipeline{ initialPipeline_ } + , maxPipelineCount{ maxPipelineCount_ } + { + } + + VULKAN_HPP_CONSTEXPR IndirectExecutionSetPipelineInfoEXT( IndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectExecutionSetPipelineInfoEXT( VkIndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectExecutionSetPipelineInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + IndirectExecutionSetPipelineInfoEXT & operator=( IndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectExecutionSetPipelineInfoEXT & operator=( VkIndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT & setInitialPipeline( Pipeline initialPipeline_ ) & VULKAN_HPP_NOEXCEPT + { + initialPipeline = initialPipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT && setInitialPipeline( Pipeline initialPipeline_ ) && VULKAN_HPP_NOEXCEPT + { + initialPipeline = initialPipeline_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT & setMaxPipelineCount( uint32_t maxPipelineCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxPipelineCount = maxPipelineCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT && setMaxPipelineCount( uint32_t maxPipelineCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxPipelineCount = maxPipelineCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectExecutionSetPipelineInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetPipelineInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetPipelineInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetPipelineInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, initialPipeline, maxPipelineCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectExecutionSetPipelineInfoEXT const & ) const = default; +#else + bool operator==( IndirectExecutionSetPipelineInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( initialPipeline == rhs.initialPipeline ) && ( maxPipelineCount == rhs.maxPipelineCount ); +# endif + } + + bool operator!=( IndirectExecutionSetPipelineInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eIndirectExecutionSetPipelineInfoEXT; + const void * pNext = {}; + Pipeline initialPipeline = {}; + uint32_t maxPipelineCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectExecutionSetPipelineInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = IndirectExecutionSetPipelineInfoEXT; + }; + + // wrapper struct for struct VkIndirectExecutionSetShaderLayoutInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetShaderLayoutInfoEXT.html + struct IndirectExecutionSetShaderLayoutInfoEXT + { + using NativeType = VkIndirectExecutionSetShaderLayoutInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectExecutionSetShaderLayoutInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderLayoutInfoEXT( uint32_t setLayoutCount_ = {}, + const DescriptorSetLayout * pSetLayouts_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , setLayoutCount{ setLayoutCount_ } + , pSetLayouts{ pSetLayouts_ } + { + } + + VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderLayoutInfoEXT( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectExecutionSetShaderLayoutInfoEXT( VkIndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectExecutionSetShaderLayoutInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectExecutionSetShaderLayoutInfoEXT( ArrayProxyNoTemporaries const & setLayouts_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), setLayoutCount( static_cast( setLayouts_.size() ) ), pSetLayouts( setLayouts_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + IndirectExecutionSetShaderLayoutInfoEXT & operator=( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectExecutionSetShaderLayoutInfoEXT & operator=( VkIndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT & setSetLayoutCount( uint32_t setLayoutCount_ ) & VULKAN_HPP_NOEXCEPT + { + setLayoutCount = setLayoutCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT && setSetLayoutCount( uint32_t setLayoutCount_ ) && VULKAN_HPP_NOEXCEPT + { + setLayoutCount = setLayoutCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT & setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) & VULKAN_HPP_NOEXCEPT + { + pSetLayouts = pSetLayouts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT && setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) && VULKAN_HPP_NOEXCEPT + { + pSetLayouts = pSetLayouts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectExecutionSetShaderLayoutInfoEXT & setSetLayouts( ArrayProxyNoTemporaries const & setLayouts_ ) VULKAN_HPP_NOEXCEPT + { + setLayoutCount = static_cast( setLayouts_.size() ); + pSetLayouts = setLayouts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectExecutionSetShaderLayoutInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetShaderLayoutInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetShaderLayoutInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetShaderLayoutInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, setLayoutCount, pSetLayouts ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectExecutionSetShaderLayoutInfoEXT const & ) const = default; +#else + bool operator==( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( setLayoutCount == rhs.setLayoutCount ) && ( pSetLayouts == rhs.pSetLayouts ); +# endif + } + + bool operator!=( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eIndirectExecutionSetShaderLayoutInfoEXT; + const void * pNext = {}; + uint32_t setLayoutCount = {}; + const DescriptorSetLayout * pSetLayouts = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectExecutionSetShaderLayoutInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = IndirectExecutionSetShaderLayoutInfoEXT; + }; + + // wrapper struct for struct VkIndirectExecutionSetShaderInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetShaderInfoEXT.html + struct IndirectExecutionSetShaderInfoEXT + { + using NativeType = VkIndirectExecutionSetShaderInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectExecutionSetShaderInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderInfoEXT( uint32_t shaderCount_ = {}, + const ShaderEXT * pInitialShaders_ = {}, + const IndirectExecutionSetShaderLayoutInfoEXT * pSetLayoutInfos_ = {}, + uint32_t maxShaderCount_ = {}, + uint32_t pushConstantRangeCount_ = {}, + const PushConstantRange * pPushConstantRanges_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderCount{ shaderCount_ } + , pInitialShaders{ pInitialShaders_ } + , pSetLayoutInfos{ pSetLayoutInfos_ } + , maxShaderCount{ maxShaderCount_ } + , pushConstantRangeCount{ pushConstantRangeCount_ } + , pPushConstantRanges{ pPushConstantRanges_ } + { + } + + VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderInfoEXT( IndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectExecutionSetShaderInfoEXT( VkIndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectExecutionSetShaderInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectExecutionSetShaderInfoEXT( ArrayProxyNoTemporaries const & initialShaders_, + ArrayProxyNoTemporaries const & setLayoutInfos_ = {}, + uint32_t maxShaderCount_ = {}, + ArrayProxyNoTemporaries const & pushConstantRanges_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , shaderCount( static_cast( initialShaders_.size() ) ) + , pInitialShaders( initialShaders_.data() ) + , pSetLayoutInfos( setLayoutInfos_.data() ) + , maxShaderCount( maxShaderCount_ ) + , pushConstantRangeCount( static_cast( pushConstantRanges_.size() ) ) + , pPushConstantRanges( pushConstantRanges_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( setLayoutInfos_.empty() || ( initialShaders_.size() == setLayoutInfos_.size() ) ); +# else + if ( !setLayoutInfos_.empty() && ( initialShaders_.size() != setLayoutInfos_.size() ) ) + { + throw LogicError( + VULKAN_HPP_NAMESPACE_STRING + "::IndirectExecutionSetShaderInfoEXT::IndirectExecutionSetShaderInfoEXT: !setLayoutInfos_.empty() && ( initialShaders_.size() != setLayoutInfos_.size() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + IndirectExecutionSetShaderInfoEXT & operator=( IndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectExecutionSetShaderInfoEXT & operator=( VkIndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setShaderCount( uint32_t shaderCount_ ) & VULKAN_HPP_NOEXCEPT + { + shaderCount = shaderCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setShaderCount( uint32_t shaderCount_ ) && VULKAN_HPP_NOEXCEPT + { + shaderCount = shaderCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPInitialShaders( const ShaderEXT * pInitialShaders_ ) & VULKAN_HPP_NOEXCEPT + { + pInitialShaders = pInitialShaders_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setPInitialShaders( const ShaderEXT * pInitialShaders_ ) && VULKAN_HPP_NOEXCEPT + { + pInitialShaders = pInitialShaders_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectExecutionSetShaderInfoEXT & setInitialShaders( ArrayProxyNoTemporaries const & initialShaders_ ) VULKAN_HPP_NOEXCEPT + { + shaderCount = static_cast( initialShaders_.size() ); + pInitialShaders = initialShaders_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPSetLayoutInfos( const IndirectExecutionSetShaderLayoutInfoEXT * pSetLayoutInfos_ ) & + VULKAN_HPP_NOEXCEPT + { + pSetLayoutInfos = pSetLayoutInfos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setPSetLayoutInfos( const IndirectExecutionSetShaderLayoutInfoEXT * pSetLayoutInfos_ ) && + VULKAN_HPP_NOEXCEPT + { + pSetLayoutInfos = pSetLayoutInfos_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectExecutionSetShaderInfoEXT & + setSetLayoutInfos( ArrayProxyNoTemporaries const & setLayoutInfos_ ) VULKAN_HPP_NOEXCEPT + { + shaderCount = static_cast( setLayoutInfos_.size() ); + pSetLayoutInfos = setLayoutInfos_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setMaxShaderCount( uint32_t maxShaderCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxShaderCount = maxShaderCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setMaxShaderCount( uint32_t maxShaderCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxShaderCount = maxShaderCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) & VULKAN_HPP_NOEXCEPT + { + pushConstantRangeCount = pushConstantRangeCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) && VULKAN_HPP_NOEXCEPT + { + pushConstantRangeCount = pushConstantRangeCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) & VULKAN_HPP_NOEXCEPT + { + pPushConstantRanges = pPushConstantRanges_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) && VULKAN_HPP_NOEXCEPT + { + pPushConstantRanges = pPushConstantRanges_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + IndirectExecutionSetShaderInfoEXT & + setPushConstantRanges( ArrayProxyNoTemporaries const & pushConstantRanges_ ) VULKAN_HPP_NOEXCEPT + { + pushConstantRangeCount = static_cast( pushConstantRanges_.size() ); + pPushConstantRanges = pushConstantRanges_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectExecutionSetShaderInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetShaderInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetShaderInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetShaderInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderCount, pInitialShaders, pSetLayoutInfos, maxShaderCount, pushConstantRangeCount, pPushConstantRanges ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( IndirectExecutionSetShaderInfoEXT const & ) const = default; +#else + bool operator==( IndirectExecutionSetShaderInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCount == rhs.shaderCount ) && ( pInitialShaders == rhs.pInitialShaders ) && + ( pSetLayoutInfos == rhs.pSetLayoutInfos ) && ( maxShaderCount == rhs.maxShaderCount ) && + ( pushConstantRangeCount == rhs.pushConstantRangeCount ) && ( pPushConstantRanges == rhs.pPushConstantRanges ); +# endif + } + + bool operator!=( IndirectExecutionSetShaderInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eIndirectExecutionSetShaderInfoEXT; + const void * pNext = {}; + uint32_t shaderCount = {}; + const ShaderEXT * pInitialShaders = {}; + const IndirectExecutionSetShaderLayoutInfoEXT * pSetLayoutInfos = {}; + uint32_t maxShaderCount = {}; + uint32_t pushConstantRangeCount = {}; + const PushConstantRange * pPushConstantRanges = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectExecutionSetShaderInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = IndirectExecutionSetShaderInfoEXT; + }; + + union IndirectExecutionSetInfoEXT + { + using NativeType = VkIndirectExecutionSetInfoEXT; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT( const IndirectExecutionSetPipelineInfoEXT * pPipelineInfo_ = {} ) : pPipelineInfo( pPipelineInfo_ ) {} + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT( const IndirectExecutionSetShaderInfoEXT * pShaderInfo_ ) : pShaderInfo( pShaderInfo_ ) {} +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT & setPPipelineInfo( const IndirectExecutionSetPipelineInfoEXT * pPipelineInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pPipelineInfo = pPipelineInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT && setPPipelineInfo( const IndirectExecutionSetPipelineInfoEXT * pPipelineInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pPipelineInfo = pPipelineInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT & setPShaderInfo( const IndirectExecutionSetShaderInfoEXT * pShaderInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pShaderInfo = pShaderInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT && setPShaderInfo( const IndirectExecutionSetShaderInfoEXT * pShaderInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pShaderInfo = pShaderInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectExecutionSetInfoEXT const &() const + { + return *reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetInfoEXT &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + const IndirectExecutionSetPipelineInfoEXT * pPipelineInfo; + const IndirectExecutionSetShaderInfoEXT * pShaderInfo; +#else + const VkIndirectExecutionSetPipelineInfoEXT * pPipelineInfo; + const VkIndirectExecutionSetShaderInfoEXT * pShaderInfo; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectExecutionSetInfoEXT; + }; +#endif + + // wrapper struct for struct VkIndirectExecutionSetCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetCreateInfoEXT.html + struct IndirectExecutionSetCreateInfoEXT + { + using NativeType = VkIndirectExecutionSetCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectExecutionSetCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT( IndirectExecutionSetInfoTypeEXT type_ = IndirectExecutionSetInfoTypeEXT::ePipelines, + IndirectExecutionSetInfoEXT info_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , info{ info_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT( IndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + IndirectExecutionSetCreateInfoEXT( VkIndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : IndirectExecutionSetCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + IndirectExecutionSetCreateInfoEXT & operator=( IndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + IndirectExecutionSetCreateInfoEXT & operator=( VkIndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT & setType( IndirectExecutionSetInfoTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT && setType( IndirectExecutionSetInfoTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT & setInfo( IndirectExecutionSetInfoEXT const & info_ ) & VULKAN_HPP_NOEXCEPT + { + info = info_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT && setInfo( IndirectExecutionSetInfoEXT const & info_ ) && VULKAN_HPP_NOEXCEPT + { + info = info_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkIndirectExecutionSetCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkIndirectExecutionSetCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, info ); + } +#endif + + public: + StructureType sType = StructureType::eIndirectExecutionSetCreateInfoEXT; + const void * pNext = {}; + IndirectExecutionSetInfoTypeEXT type = IndirectExecutionSetInfoTypeEXT::ePipelines; + IndirectExecutionSetInfoEXT info = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = IndirectExecutionSetCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = IndirectExecutionSetCreateInfoEXT; + }; + + // wrapper struct for struct VkInitializePerformanceApiInfoINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkInitializePerformanceApiInfoINTEL.html + struct InitializePerformanceApiInfoINTEL + { + using NativeType = VkInitializePerformanceApiInfoINTEL; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eInitializePerformanceApiInfoINTEL; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void * pUserData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pUserData{ pUserData_ } + { + } + + VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( InitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + : InitializePerformanceApiInfoINTEL( *reinterpret_cast( &rhs ) ) + { + } + + InitializePerformanceApiInfoINTEL & operator=( InitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + InitializePerformanceApiInfoINTEL & operator=( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 InitializePerformanceApiInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InitializePerformanceApiInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 InitializePerformanceApiInfoINTEL & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT + { + pUserData = pUserData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InitializePerformanceApiInfoINTEL && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT + { + pUserData = pUserData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkInitializePerformanceApiInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkInitializePerformanceApiInfoINTEL &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkInitializePerformanceApiInfoINTEL const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkInitializePerformanceApiInfoINTEL *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pUserData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( InitializePerformanceApiInfoINTEL const & ) const = default; +#else + bool operator==( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pUserData == rhs.pUserData ); +# endif + } + + bool operator!=( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL; + const void * pNext = {}; + void * pUserData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = InitializePerformanceApiInfoINTEL; + }; +#endif + + template <> + struct CppType + { + using Type = InitializePerformanceApiInfoINTEL; + }; + + // wrapper struct for struct VkInputAttachmentAspectReference, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkInputAttachmentAspectReference.html + struct InputAttachmentAspectReference + { + using NativeType = VkInputAttachmentAspectReference; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + InputAttachmentAspectReference( uint32_t subpass_ = {}, uint32_t inputAttachmentIndex_ = {}, ImageAspectFlags aspectMask_ = {} ) VULKAN_HPP_NOEXCEPT + : subpass{ subpass_ } + , inputAttachmentIndex{ inputAttachmentIndex_ } + , aspectMask{ aspectMask_ } + { + } + + VULKAN_HPP_CONSTEXPR InputAttachmentAspectReference( InputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT + : InputAttachmentAspectReference( *reinterpret_cast( &rhs ) ) + { + } + + InputAttachmentAspectReference & operator=( InputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + InputAttachmentAspectReference & operator=( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference & setSubpass( uint32_t subpass_ ) & VULKAN_HPP_NOEXCEPT + { + subpass = subpass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference && setSubpass( uint32_t subpass_ ) && VULKAN_HPP_NOEXCEPT + { + subpass = subpass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference & setInputAttachmentIndex( uint32_t inputAttachmentIndex_ ) & VULKAN_HPP_NOEXCEPT + { + inputAttachmentIndex = inputAttachmentIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference && setInputAttachmentIndex( uint32_t inputAttachmentIndex_ ) && VULKAN_HPP_NOEXCEPT + { + inputAttachmentIndex = inputAttachmentIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT + { + aspectMask = aspectMask_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkInputAttachmentAspectReference const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkInputAttachmentAspectReference &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkInputAttachmentAspectReference const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkInputAttachmentAspectReference *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( subpass, inputAttachmentIndex, aspectMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( InputAttachmentAspectReference const & ) const = default; +#else + bool operator==( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( subpass == rhs.subpass ) && ( inputAttachmentIndex == rhs.inputAttachmentIndex ) && ( aspectMask == rhs.aspectMask ); +# endif + } + + bool operator!=( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t subpass = {}; + uint32_t inputAttachmentIndex = {}; + ImageAspectFlags aspectMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = InputAttachmentAspectReference; + }; +#endif + using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; + + // wrapper struct for struct VkInstanceCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstanceCreateInfo.html + struct InstanceCreateInfo + { + using NativeType = VkInstanceCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eInstanceCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR InstanceCreateInfo( InstanceCreateFlags flags_ = {}, + const ApplicationInfo * pApplicationInfo_ = {}, + uint32_t enabledLayerCount_ = {}, + const char * const * ppEnabledLayerNames_ = {}, + uint32_t enabledExtensionCount_ = {}, + const char * const * ppEnabledExtensionNames_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pApplicationInfo{ pApplicationInfo_ } + , enabledLayerCount{ enabledLayerCount_ } + , ppEnabledLayerNames{ ppEnabledLayerNames_ } + , enabledExtensionCount{ enabledExtensionCount_ } + , ppEnabledExtensionNames{ ppEnabledExtensionNames_ } + { + } + + VULKAN_HPP_CONSTEXPR InstanceCreateInfo( InstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : InstanceCreateInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + InstanceCreateInfo( InstanceCreateFlags flags_, + const ApplicationInfo * pApplicationInfo_, + ArrayProxyNoTemporaries const & pEnabledLayerNames_, + ArrayProxyNoTemporaries const & pEnabledExtensionNames_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , pApplicationInfo( pApplicationInfo_ ) + , enabledLayerCount( static_cast( pEnabledLayerNames_.size() ) ) + , ppEnabledLayerNames( pEnabledLayerNames_.data() ) + , enabledExtensionCount( static_cast( pEnabledExtensionNames_.size() ) ) + , ppEnabledExtensionNames( pEnabledExtensionNames_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + InstanceCreateInfo & operator=( InstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + InstanceCreateInfo & operator=( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setFlags( InstanceCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setFlags( InstanceCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setPApplicationInfo( const ApplicationInfo * pApplicationInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pApplicationInfo = pApplicationInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setPApplicationInfo( const ApplicationInfo * pApplicationInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pApplicationInfo = pApplicationInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ ) & VULKAN_HPP_NOEXCEPT + { + enabledLayerCount = enabledLayerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setEnabledLayerCount( uint32_t enabledLayerCount_ ) && VULKAN_HPP_NOEXCEPT + { + enabledLayerCount = enabledLayerCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setPpEnabledLayerNames( const char * const * ppEnabledLayerNames_ ) & VULKAN_HPP_NOEXCEPT + { + ppEnabledLayerNames = ppEnabledLayerNames_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setPpEnabledLayerNames( const char * const * ppEnabledLayerNames_ ) && VULKAN_HPP_NOEXCEPT + { + ppEnabledLayerNames = ppEnabledLayerNames_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + InstanceCreateInfo & setPEnabledLayerNames( ArrayProxyNoTemporaries const & pEnabledLayerNames_ ) VULKAN_HPP_NOEXCEPT + { + enabledLayerCount = static_cast( pEnabledLayerNames_.size() ); + ppEnabledLayerNames = pEnabledLayerNames_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) & VULKAN_HPP_NOEXCEPT + { + enabledExtensionCount = enabledExtensionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) && VULKAN_HPP_NOEXCEPT + { + enabledExtensionCount = enabledExtensionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setPpEnabledExtensionNames( const char * const * ppEnabledExtensionNames_ ) & VULKAN_HPP_NOEXCEPT + { + ppEnabledExtensionNames = ppEnabledExtensionNames_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setPpEnabledExtensionNames( const char * const * ppEnabledExtensionNames_ ) && VULKAN_HPP_NOEXCEPT + { + ppEnabledExtensionNames = ppEnabledExtensionNames_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + InstanceCreateInfo & setPEnabledExtensionNames( ArrayProxyNoTemporaries const & pEnabledExtensionNames_ ) VULKAN_HPP_NOEXCEPT + { + enabledExtensionCount = static_cast( pEnabledExtensionNames_.size() ); + ppEnabledExtensionNames = pEnabledExtensionNames_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkInstanceCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkInstanceCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkInstanceCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkInstanceCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pApplicationInfo, enabledLayerCount, ppEnabledLayerNames, enabledExtensionCount, ppEnabledExtensionNames ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = pApplicationInfo <=> rhs.pApplicationInfo; cmp != 0 ) + return cmp; + if ( auto cmp = enabledLayerCount <=> rhs.enabledLayerCount; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < enabledLayerCount; ++i ) + { + if ( ppEnabledLayerNames[i] != rhs.ppEnabledLayerNames[i] ) + if ( auto cmp = strcmp( ppEnabledLayerNames[i], rhs.ppEnabledLayerNames[i] ); cmp != 0 ) + return cmp < 0 ? std::strong_ordering::less : std::strong_ordering::greater; + } + if ( auto cmp = enabledExtensionCount <=> rhs.enabledExtensionCount; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < enabledExtensionCount; ++i ) + { + if ( ppEnabledExtensionNames[i] != rhs.ppEnabledExtensionNames[i] ) + if ( auto cmp = strcmp( ppEnabledExtensionNames[i], rhs.ppEnabledExtensionNames[i] ); cmp != 0 ) + return cmp < 0 ? std::strong_ordering::less : std::strong_ordering::greater; + } + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pApplicationInfo == rhs.pApplicationInfo ) && + ( enabledLayerCount == rhs.enabledLayerCount ) && + std::equal( ppEnabledLayerNames, + ppEnabledLayerNames + enabledLayerCount, + rhs.ppEnabledLayerNames, + []( char const * left, char const * right ) { return ( left == right ) || ( strcmp( left, right ) == 0 ); } ) && + ( enabledExtensionCount == rhs.enabledExtensionCount ) && + std::equal( ppEnabledExtensionNames, + ppEnabledExtensionNames + enabledExtensionCount, + rhs.ppEnabledExtensionNames, + []( char const * left, char const * right ) { return ( left == right ) || ( strcmp( left, right ) == 0 ); } ); + } + + bool operator!=( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eInstanceCreateInfo; + const void * pNext = {}; + InstanceCreateFlags flags = {}; + const ApplicationInfo * pApplicationInfo = {}; + uint32_t enabledLayerCount = {}; + const char * const * ppEnabledLayerNames = {}; + uint32_t enabledExtensionCount = {}; + const char * const * ppEnabledExtensionNames = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = InstanceCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = InstanceCreateInfo; + }; + + // wrapper struct for struct VkLatencySleepInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencySleepInfoNV.html + struct LatencySleepInfoNV + { + using NativeType = VkLatencySleepInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySleepInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR LatencySleepInfoNV( Semaphore signalSemaphore_ = {}, uint64_t value_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , signalSemaphore{ signalSemaphore_ } + , value{ value_ } + { + } + + VULKAN_HPP_CONSTEXPR LatencySleepInfoNV( LatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + LatencySleepInfoNV( VkLatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT : LatencySleepInfoNV( *reinterpret_cast( &rhs ) ) {} + + LatencySleepInfoNV & operator=( LatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + LatencySleepInfoNV & operator=( VkLatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV & setSignalSemaphore( Semaphore signalSemaphore_ ) & VULKAN_HPP_NOEXCEPT + { + signalSemaphore = signalSemaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV && setSignalSemaphore( Semaphore signalSemaphore_ ) && VULKAN_HPP_NOEXCEPT + { + signalSemaphore = signalSemaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV & setValue( uint64_t value_ ) & VULKAN_HPP_NOEXCEPT + { + value = value_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV && setValue( uint64_t value_ ) && VULKAN_HPP_NOEXCEPT + { + value = value_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkLatencySleepInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLatencySleepInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLatencySleepInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkLatencySleepInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, signalSemaphore, value ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( LatencySleepInfoNV const & ) const = default; +#else + bool operator==( LatencySleepInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( signalSemaphore == rhs.signalSemaphore ) && ( value == rhs.value ); +# endif + } + + bool operator!=( LatencySleepInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eLatencySleepInfoNV; + const void * pNext = {}; + Semaphore signalSemaphore = {}; + uint64_t value = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = LatencySleepInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = LatencySleepInfoNV; + }; + + // wrapper struct for struct VkLatencySleepModeInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencySleepModeInfoNV.html + struct LatencySleepModeInfoNV + { + using NativeType = VkLatencySleepModeInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySleepModeInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR LatencySleepModeInfoNV( Bool32 lowLatencyMode_ = {}, + Bool32 lowLatencyBoost_ = {}, + uint32_t minimumIntervalUs_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , lowLatencyMode{ lowLatencyMode_ } + , lowLatencyBoost{ lowLatencyBoost_ } + , minimumIntervalUs{ minimumIntervalUs_ } + { + } + + VULKAN_HPP_CONSTEXPR LatencySleepModeInfoNV( LatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + LatencySleepModeInfoNV( VkLatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : LatencySleepModeInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + LatencySleepModeInfoNV & operator=( LatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + LatencySleepModeInfoNV & operator=( VkLatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setLowLatencyMode( Bool32 lowLatencyMode_ ) & VULKAN_HPP_NOEXCEPT + { + lowLatencyMode = lowLatencyMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV && setLowLatencyMode( Bool32 lowLatencyMode_ ) && VULKAN_HPP_NOEXCEPT + { + lowLatencyMode = lowLatencyMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setLowLatencyBoost( Bool32 lowLatencyBoost_ ) & VULKAN_HPP_NOEXCEPT + { + lowLatencyBoost = lowLatencyBoost_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV && setLowLatencyBoost( Bool32 lowLatencyBoost_ ) && VULKAN_HPP_NOEXCEPT + { + lowLatencyBoost = lowLatencyBoost_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setMinimumIntervalUs( uint32_t minimumIntervalUs_ ) & VULKAN_HPP_NOEXCEPT + { + minimumIntervalUs = minimumIntervalUs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV && setMinimumIntervalUs( uint32_t minimumIntervalUs_ ) && VULKAN_HPP_NOEXCEPT + { + minimumIntervalUs = minimumIntervalUs_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkLatencySleepModeInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLatencySleepModeInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLatencySleepModeInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkLatencySleepModeInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, lowLatencyMode, lowLatencyBoost, minimumIntervalUs ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( LatencySleepModeInfoNV const & ) const = default; +#else + bool operator==( LatencySleepModeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lowLatencyMode == rhs.lowLatencyMode ) && ( lowLatencyBoost == rhs.lowLatencyBoost ) && + ( minimumIntervalUs == rhs.minimumIntervalUs ); +# endif + } + + bool operator!=( LatencySleepModeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eLatencySleepModeInfoNV; + const void * pNext = {}; + Bool32 lowLatencyMode = {}; + Bool32 lowLatencyBoost = {}; + uint32_t minimumIntervalUs = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = LatencySleepModeInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = LatencySleepModeInfoNV; + }; + + // wrapper struct for struct VkLatencySubmissionPresentIdNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencySubmissionPresentIdNV.html + struct LatencySubmissionPresentIdNV + { + using NativeType = VkLatencySubmissionPresentIdNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySubmissionPresentIdNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR LatencySubmissionPresentIdNV( uint64_t presentID_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentID{ presentID_ } + { + } + + VULKAN_HPP_CONSTEXPR LatencySubmissionPresentIdNV( LatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + LatencySubmissionPresentIdNV( VkLatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT + : LatencySubmissionPresentIdNV( *reinterpret_cast( &rhs ) ) + { + } + + LatencySubmissionPresentIdNV & operator=( LatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + LatencySubmissionPresentIdNV & operator=( VkLatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 LatencySubmissionPresentIdNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySubmissionPresentIdNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LatencySubmissionPresentIdNV & setPresentID( uint64_t presentID_ ) & VULKAN_HPP_NOEXCEPT + { + presentID = presentID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySubmissionPresentIdNV && setPresentID( uint64_t presentID_ ) && VULKAN_HPP_NOEXCEPT + { + presentID = presentID_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkLatencySubmissionPresentIdNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLatencySubmissionPresentIdNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLatencySubmissionPresentIdNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkLatencySubmissionPresentIdNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentID ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( LatencySubmissionPresentIdNV const & ) const = default; +#else + bool operator==( LatencySubmissionPresentIdNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID ); +# endif + } + + bool operator!=( LatencySubmissionPresentIdNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eLatencySubmissionPresentIdNV; + const void * pNext = {}; + uint64_t presentID = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = LatencySubmissionPresentIdNV; + }; +#endif + + template <> + struct CppType + { + using Type = LatencySubmissionPresentIdNV; + }; + + // wrapper struct for struct VkLatencySurfaceCapabilitiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencySurfaceCapabilitiesNV.html + struct LatencySurfaceCapabilitiesNV + { + using NativeType = VkLatencySurfaceCapabilitiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySurfaceCapabilitiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + LatencySurfaceCapabilitiesNV( uint32_t presentModeCount_ = {}, PresentModeKHR * pPresentModes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentModeCount{ presentModeCount_ } + , pPresentModes{ pPresentModes_ } + { + } + + VULKAN_HPP_CONSTEXPR LatencySurfaceCapabilitiesNV( LatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + LatencySurfaceCapabilitiesNV( VkLatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : LatencySurfaceCapabilitiesNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + LatencySurfaceCapabilitiesNV( ArrayProxyNoTemporaries const & presentModes_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), presentModeCount( static_cast( presentModes_.size() ) ), pPresentModes( presentModes_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + LatencySurfaceCapabilitiesNV & operator=( LatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + LatencySurfaceCapabilitiesNV & operator=( VkLatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV & setPresentModeCount( uint32_t presentModeCount_ ) & VULKAN_HPP_NOEXCEPT + { + presentModeCount = presentModeCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV && setPresentModeCount( uint32_t presentModeCount_ ) && VULKAN_HPP_NOEXCEPT + { + presentModeCount = presentModeCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV & setPPresentModes( PresentModeKHR * pPresentModes_ ) & VULKAN_HPP_NOEXCEPT + { + pPresentModes = pPresentModes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV && setPPresentModes( PresentModeKHR * pPresentModes_ ) && VULKAN_HPP_NOEXCEPT + { + pPresentModes = pPresentModes_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + LatencySurfaceCapabilitiesNV & setPresentModes( ArrayProxyNoTemporaries const & presentModes_ ) VULKAN_HPP_NOEXCEPT + { + presentModeCount = static_cast( presentModes_.size() ); + pPresentModes = presentModes_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkLatencySurfaceCapabilitiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLatencySurfaceCapabilitiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLatencySurfaceCapabilitiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkLatencySurfaceCapabilitiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentModeCount, pPresentModes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( LatencySurfaceCapabilitiesNV const & ) const = default; +#else + bool operator==( LatencySurfaceCapabilitiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeCount == rhs.presentModeCount ) && ( pPresentModes == rhs.pPresentModes ); +# endif + } + + bool operator!=( LatencySurfaceCapabilitiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eLatencySurfaceCapabilitiesNV; + const void * pNext = {}; + uint32_t presentModeCount = {}; + PresentModeKHR * pPresentModes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = LatencySurfaceCapabilitiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = LatencySurfaceCapabilitiesNV; + }; + + // wrapper struct for struct VkLayerProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayerProperties.html + struct LayerProperties + { + using NativeType = VkLayerProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 LayerProperties( std::array const & layerName_ = {}, + uint32_t specVersion_ = {}, + uint32_t implementationVersion_ = {}, + std::array const & description_ = {} ) VULKAN_HPP_NOEXCEPT + : layerName{ layerName_ } + , specVersion{ specVersion_ } + , implementationVersion{ implementationVersion_ } + , description{ description_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 LayerProperties( LayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + LayerProperties( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT : LayerProperties( *reinterpret_cast( &rhs ) ) {} + + LayerProperties & operator=( LayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + LayerProperties & operator=( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkLayerProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLayerProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLayerProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkLayerProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple const &, uint32_t const &, uint32_t const &, ArrayWrapper1D const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( layerName, specVersion, implementationVersion, description ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = strcmp( layerName, rhs.layerName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = specVersion <=> rhs.specVersion; cmp != 0 ) + return cmp; + if ( auto cmp = implementationVersion <=> rhs.implementationVersion; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( strcmp( layerName, rhs.layerName ) == 0 ) && ( specVersion == rhs.specVersion ) && ( implementationVersion == rhs.implementationVersion ) && + ( strcmp( description, rhs.description ) == 0 ); + } + + bool operator!=( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + ArrayWrapper1D layerName = {}; + uint32_t specVersion = {}; + uint32_t implementationVersion = {}; + ArrayWrapper1D description = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = LayerProperties; + }; +#endif + + // wrapper struct for struct VkLayerSettingEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayerSettingEXT.html + struct LayerSettingEXT + { + using NativeType = VkLayerSettingEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR LayerSettingEXT( const char * pLayerName_ = {}, + const char * pSettingName_ = {}, + LayerSettingTypeEXT type_ = LayerSettingTypeEXT::eBool32, + uint32_t valueCount_ = {}, + const void * pValues_ = {} ) VULKAN_HPP_NOEXCEPT + : pLayerName{ pLayerName_ } + , pSettingName{ pSettingName_ } + , type{ type_ } + , valueCount{ valueCount_ } + , pValues{ pValues_ } + { + } + + VULKAN_HPP_CONSTEXPR LayerSettingEXT( LayerSettingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + LayerSettingEXT( VkLayerSettingEXT const & rhs ) VULKAN_HPP_NOEXCEPT : LayerSettingEXT( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + // NOTE: you need to provide the type because Bool32 and uint32_t are indistinguishable! + LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) + : pLayerName( pLayerName_ ) + , pSettingName( pSettingName_ ) + , type( type_ ) + , valueCount( static_cast( values_.size() ) ) + , pValues( values_.data() ) + { + VULKAN_HPP_ASSERT( isSameType( type ) ); + } + + LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) + : pLayerName( pLayerName_ ) + , pSettingName( pSettingName_ ) + , type( type_ ) + , valueCount( static_cast( values_.size() ) ) + , pValues( values_.data() ) + { + VULKAN_HPP_ASSERT( isSameType( type ) ); + } + + LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) + : pLayerName( pLayerName_ ) + , pSettingName( pSettingName_ ) + , type( type_ ) + , valueCount( static_cast( values_.size() ) ) + , pValues( values_.data() ) + { + VULKAN_HPP_ASSERT( isSameType( type ) ); + } + + LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) + : pLayerName( pLayerName_ ) + , pSettingName( pSettingName_ ) + , type( type_ ) + , valueCount( static_cast( values_.size() ) ) + , pValues( values_.data() ) + { + VULKAN_HPP_ASSERT( isSameType( type ) ); + } + + LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) + : pLayerName( pLayerName_ ) + , pSettingName( pSettingName_ ) + , type( type_ ) + , valueCount( static_cast( values_.size() ) ) + , pValues( values_.data() ) + { + VULKAN_HPP_ASSERT( isSameType( type ) ); + } + + LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) + : pLayerName( pLayerName_ ) + , pSettingName( pSettingName_ ) + , type( type_ ) + , valueCount( static_cast( values_.size() ) ) + , pValues( values_.data() ) + { + VULKAN_HPP_ASSERT( isSameType( type ) ); + } + + LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) + : pLayerName( pLayerName_ ) + , pSettingName( pSettingName_ ) + , type( type_ ) + , valueCount( static_cast( values_.size() ) ) + , pValues( values_.data() ) + { + VULKAN_HPP_ASSERT( isSameType( type ) ); + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + LayerSettingEXT & operator=( LayerSettingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + LayerSettingEXT & operator=( VkLayerSettingEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT & setPLayerName( const char * pLayerName_ ) & VULKAN_HPP_NOEXCEPT + { + pLayerName = pLayerName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT && setPLayerName( const char * pLayerName_ ) && VULKAN_HPP_NOEXCEPT + { + pLayerName = pLayerName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT & setPSettingName( const char * pSettingName_ ) & VULKAN_HPP_NOEXCEPT + { + pSettingName = pSettingName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT && setPSettingName( const char * pSettingName_ ) && VULKAN_HPP_NOEXCEPT + { + pSettingName = pSettingName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT & setType( LayerSettingTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT && setType( LayerSettingTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT & setValueCount( uint32_t valueCount_ ) & VULKAN_HPP_NOEXCEPT + { + valueCount = valueCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT && setValueCount( uint32_t valueCount_ ) && VULKAN_HPP_NOEXCEPT + { + valueCount = valueCount_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT + { + valueCount = static_cast( values_.size() ); + pValues = values_.data(); + return *this; + } + + LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT + { + valueCount = static_cast( values_.size() ); + pValues = values_.data(); + return *this; + } + + LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT + { + valueCount = static_cast( values_.size() ); + pValues = values_.data(); + return *this; + } + + LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT + { + valueCount = static_cast( values_.size() ); + pValues = values_.data(); + return *this; + } + + LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT + { + valueCount = static_cast( values_.size() ); + pValues = values_.data(); + return *this; + } + + LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT + { + valueCount = static_cast( values_.size() ); + pValues = values_.data(); + return *this; + } + + LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT + { + valueCount = static_cast( values_.size() ); + pValues = values_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkLayerSettingEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLayerSettingEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLayerSettingEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkLayerSettingEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( pLayerName, pSettingName, type, valueCount, pValues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( LayerSettingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( pLayerName != rhs.pLayerName ) + if ( auto cmp = strcmp( pLayerName, rhs.pLayerName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( pSettingName != rhs.pSettingName ) + if ( auto cmp = strcmp( pSettingName, rhs.pSettingName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = type <=> rhs.type; cmp != 0 ) + return cmp; + if ( auto cmp = valueCount <=> rhs.valueCount; cmp != 0 ) + return cmp; + if ( auto cmp = pValues <=> rhs.pValues; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( LayerSettingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( ( pLayerName == rhs.pLayerName ) || ( strcmp( pLayerName, rhs.pLayerName ) == 0 ) ) && + ( ( pSettingName == rhs.pSettingName ) || ( strcmp( pSettingName, rhs.pSettingName ) == 0 ) ) && ( type == rhs.type ) && + ( valueCount == rhs.valueCount ) && ( pValues == rhs.pValues ); + } + + bool operator!=( LayerSettingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + const char * pLayerName = {}; + const char * pSettingName = {}; + LayerSettingTypeEXT type = LayerSettingTypeEXT::eBool32; + uint32_t valueCount = {}; + const void * pValues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = LayerSettingEXT; + }; +#endif + + // wrapper struct for struct VkLayerSettingsCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayerSettingsCreateInfoEXT.html + struct LayerSettingsCreateInfoEXT + { + using NativeType = VkLayerSettingsCreateInfoEXT; + + static const bool allowDuplicate = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLayerSettingsCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + LayerSettingsCreateInfoEXT( uint32_t settingCount_ = {}, const LayerSettingEXT * pSettings_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , settingCount{ settingCount_ } + , pSettings{ pSettings_ } + { + } + + VULKAN_HPP_CONSTEXPR LayerSettingsCreateInfoEXT( LayerSettingsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + LayerSettingsCreateInfoEXT( VkLayerSettingsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : LayerSettingsCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + LayerSettingsCreateInfoEXT( ArrayProxyNoTemporaries const & settings_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), settingCount( static_cast( settings_.size() ) ), pSettings( settings_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + LayerSettingsCreateInfoEXT & operator=( LayerSettingsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + LayerSettingsCreateInfoEXT & operator=( VkLayerSettingsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT & setSettingCount( uint32_t settingCount_ ) & VULKAN_HPP_NOEXCEPT + { + settingCount = settingCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT && setSettingCount( uint32_t settingCount_ ) && VULKAN_HPP_NOEXCEPT + { + settingCount = settingCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT & setPSettings( const LayerSettingEXT * pSettings_ ) & VULKAN_HPP_NOEXCEPT + { + pSettings = pSettings_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT && setPSettings( const LayerSettingEXT * pSettings_ ) && VULKAN_HPP_NOEXCEPT + { + pSettings = pSettings_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + LayerSettingsCreateInfoEXT & setSettings( ArrayProxyNoTemporaries const & settings_ ) VULKAN_HPP_NOEXCEPT + { + settingCount = static_cast( settings_.size() ); + pSettings = settings_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkLayerSettingsCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLayerSettingsCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkLayerSettingsCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkLayerSettingsCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, settingCount, pSettings ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( LayerSettingsCreateInfoEXT const & ) const = default; +#else + bool operator==( LayerSettingsCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( settingCount == rhs.settingCount ) && ( pSettings == rhs.pSettings ); +# endif + } + + bool operator!=( LayerSettingsCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eLayerSettingsCreateInfoEXT; + const void * pNext = {}; + uint32_t settingCount = {}; + const LayerSettingEXT * pSettings = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = LayerSettingsCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = LayerSettingsCreateInfoEXT; + }; + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + // wrapper struct for struct VkMacOSSurfaceCreateInfoMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMacOSSurfaceCreateInfoMVK.html + struct MacOSSurfaceCreateInfoMVK + { + using NativeType = VkMacOSSurfaceCreateInfoMVK; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMacosSurfaceCreateInfoMVK; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = {}, const void * pView_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pView{ pView_ } + { + } + + VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT + : MacOSSurfaceCreateInfoMVK( *reinterpret_cast( &rhs ) ) + { + } + + MacOSSurfaceCreateInfoMVK & operator=( MacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MacOSSurfaceCreateInfoMVK & operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK & setFlags( MacOSSurfaceCreateFlagsMVK flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK && setFlags( MacOSSurfaceCreateFlagsMVK flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK & setPView( const void * pView_ ) & VULKAN_HPP_NOEXCEPT + { + pView = pView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK && setPView( const void * pView_ ) && VULKAN_HPP_NOEXCEPT + { + pView = pView_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMacOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMacOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMacOSSurfaceCreateInfoMVK const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMacOSSurfaceCreateInfoMVK *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pView ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MacOSSurfaceCreateInfoMVK const & ) const = default; +# else + bool operator==( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView ); +# endif + } + + bool operator!=( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK; + const void * pNext = {}; + MacOSSurfaceCreateFlagsMVK flags = {}; + const void * pView = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MacOSSurfaceCreateInfoMVK; + }; +# endif + + template <> + struct CppType + { + using Type = MacOSSurfaceCreateInfoMVK; + }; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + // wrapper struct for struct VkMappedMemoryRange, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMappedMemoryRange.html + struct MappedMemoryRange + { + using NativeType = VkMappedMemoryRange; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMappedMemoryRange; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + MappedMemoryRange( DeviceMemory memory_ = {}, DeviceSize offset_ = {}, DeviceSize size_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + , offset{ offset_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR MappedMemoryRange( MappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MappedMemoryRange( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT : MappedMemoryRange( *reinterpret_cast( &rhs ) ) {} + + MappedMemoryRange & operator=( MappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MappedMemoryRange & operator=( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMappedMemoryRange const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMappedMemoryRange &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMappedMemoryRange const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMappedMemoryRange *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, offset, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MappedMemoryRange const & ) const = default; +#else + bool operator==( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) && ( size == rhs.size ); +# endif + } + + bool operator!=( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMappedMemoryRange; + const void * pNext = {}; + DeviceMemory memory = {}; + DeviceSize offset = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MappedMemoryRange; + }; +#endif + + template <> + struct CppType + { + using Type = MappedMemoryRange; + }; + + // wrapper struct for struct VkMemoryAllocateFlagsInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryAllocateFlagsInfo.html + struct MemoryAllocateFlagsInfo + { + using NativeType = VkMemoryAllocateFlagsInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryAllocateFlagsInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + MemoryAllocateFlagsInfo( MemoryAllocateFlags flags_ = {}, uint32_t deviceMask_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , deviceMask{ deviceMask_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( MemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryAllocateFlagsInfo( *reinterpret_cast( &rhs ) ) + { + } + + MemoryAllocateFlagsInfo & operator=( MemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryAllocateFlagsInfo & operator=( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo & setFlags( MemoryAllocateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo && setFlags( MemoryAllocateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT + { + deviceMask = deviceMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT + { + deviceMask = deviceMask_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryAllocateFlagsInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryAllocateFlagsInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryAllocateFlagsInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryAllocateFlagsInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, deviceMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryAllocateFlagsInfo const & ) const = default; +#else + bool operator==( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( deviceMask == rhs.deviceMask ); +# endif + } + + bool operator!=( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryAllocateFlagsInfo; + const void * pNext = {}; + MemoryAllocateFlags flags = {}; + uint32_t deviceMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryAllocateFlagsInfo; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryAllocateFlagsInfo; + }; + + using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo; + + // wrapper struct for struct VkMemoryAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryAllocateInfo.html + struct MemoryAllocateInfo + { + using NativeType = VkMemoryAllocateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryAllocateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + MemoryAllocateInfo( DeviceSize allocationSize_ = {}, uint32_t memoryTypeIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , allocationSize{ allocationSize_ } + , memoryTypeIndex{ memoryTypeIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( MemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryAllocateInfo( *reinterpret_cast( &rhs ) ) {} + + MemoryAllocateInfo & operator=( MemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryAllocateInfo & operator=( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo & setAllocationSize( DeviceSize allocationSize_ ) & VULKAN_HPP_NOEXCEPT + { + allocationSize = allocationSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo && setAllocationSize( DeviceSize allocationSize_ ) && VULKAN_HPP_NOEXCEPT + { + allocationSize = allocationSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo & setMemoryTypeIndex( uint32_t memoryTypeIndex_ ) & VULKAN_HPP_NOEXCEPT + { + memoryTypeIndex = memoryTypeIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo && setMemoryTypeIndex( uint32_t memoryTypeIndex_ ) && VULKAN_HPP_NOEXCEPT + { + memoryTypeIndex = memoryTypeIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryAllocateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryAllocateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allocationSize, memoryTypeIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryAllocateInfo const & ) const = default; +#else + bool operator==( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeIndex == rhs.memoryTypeIndex ); +# endif + } + + bool operator!=( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryAllocateInfo; + const void * pNext = {}; + DeviceSize allocationSize = {}; + uint32_t memoryTypeIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryAllocateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryAllocateInfo; + }; + + // wrapper struct for struct VkMemoryBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryBarrier.html + struct MemoryBarrier + { + using NativeType = VkMemoryBarrier; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryBarrier; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryBarrier( AccessFlags srcAccessMask_ = {}, AccessFlags dstAccessMask_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcAccessMask{ srcAccessMask_ } + , dstAccessMask{ dstAccessMask_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryBarrier( MemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryBarrier( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryBarrier( *reinterpret_cast( &rhs ) ) {} + + MemoryBarrier & operator=( MemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryBarrier & operator=( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier && setSrcAccessMask( AccessFlags srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrier && setDstAccessMask( AccessFlags dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryBarrier &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryBarrier const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryBarrier *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcAccessMask, dstAccessMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryBarrier const & ) const = default; +#else + bool operator==( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ); +# endif + } + + bool operator!=( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryBarrier; + const void * pNext = {}; + AccessFlags srcAccessMask = {}; + AccessFlags dstAccessMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryBarrier; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryBarrier; + }; + + // wrapper struct for struct VkMemoryBarrierAccessFlags3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryBarrierAccessFlags3KHR.html + struct MemoryBarrierAccessFlags3KHR + { + using NativeType = VkMemoryBarrierAccessFlags3KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryBarrierAccessFlags3KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryBarrierAccessFlags3KHR( AccessFlags3KHR srcAccessMask3_ = {}, + AccessFlags3KHR dstAccessMask3_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcAccessMask3{ srcAccessMask3_ } + , dstAccessMask3{ dstAccessMask3_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryBarrierAccessFlags3KHR( MemoryBarrierAccessFlags3KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryBarrierAccessFlags3KHR( VkMemoryBarrierAccessFlags3KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryBarrierAccessFlags3KHR( *reinterpret_cast( &rhs ) ) + { + } + + MemoryBarrierAccessFlags3KHR & operator=( MemoryBarrierAccessFlags3KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryBarrierAccessFlags3KHR & operator=( VkMemoryBarrierAccessFlags3KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR & setSrcAccessMask3( AccessFlags3KHR srcAccessMask3_ ) & VULKAN_HPP_NOEXCEPT + { + srcAccessMask3 = srcAccessMask3_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR && setSrcAccessMask3( AccessFlags3KHR srcAccessMask3_ ) && VULKAN_HPP_NOEXCEPT + { + srcAccessMask3 = srcAccessMask3_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR & setDstAccessMask3( AccessFlags3KHR dstAccessMask3_ ) & VULKAN_HPP_NOEXCEPT + { + dstAccessMask3 = dstAccessMask3_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR && setDstAccessMask3( AccessFlags3KHR dstAccessMask3_ ) && VULKAN_HPP_NOEXCEPT + { + dstAccessMask3 = dstAccessMask3_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryBarrierAccessFlags3KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryBarrierAccessFlags3KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryBarrierAccessFlags3KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryBarrierAccessFlags3KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcAccessMask3, dstAccessMask3 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryBarrierAccessFlags3KHR const & ) const = default; +#else + bool operator==( MemoryBarrierAccessFlags3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask3 == rhs.srcAccessMask3 ) && ( dstAccessMask3 == rhs.dstAccessMask3 ); +# endif + } + + bool operator!=( MemoryBarrierAccessFlags3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryBarrierAccessFlags3KHR; + const void * pNext = {}; + AccessFlags3KHR srcAccessMask3 = {}; + AccessFlags3KHR dstAccessMask3 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryBarrierAccessFlags3KHR; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryBarrierAccessFlags3KHR; + }; + + // wrapper struct for struct VkMemoryDedicatedAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDedicatedAllocateInfo.html + struct MemoryDedicatedAllocateInfo + { + using NativeType = VkMemoryDedicatedAllocateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedAllocateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( Image image_ = {}, Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image{ image_ } + , buffer{ buffer_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( MemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryDedicatedAllocateInfo( *reinterpret_cast( &rhs ) ) + { + } + + MemoryDedicatedAllocateInfo & operator=( MemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryDedicatedAllocateInfo & operator=( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT + { + image = image_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT + { + image = image_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryDedicatedAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryDedicatedAllocateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryDedicatedAllocateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryDedicatedAllocateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image, buffer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryDedicatedAllocateInfo const & ) const = default; +#else + bool operator==( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer ); +# endif + } + + bool operator!=( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryDedicatedAllocateInfo; + const void * pNext = {}; + Image image = {}; + Buffer buffer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryDedicatedAllocateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryDedicatedAllocateInfo; + }; + + using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo; + + // wrapper struct for struct VkMemoryDedicatedAllocateInfoTensorARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDedicatedAllocateInfoTensorARM.html + struct MemoryDedicatedAllocateInfoTensorARM + { + using NativeType = VkMemoryDedicatedAllocateInfoTensorARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedAllocateInfoTensorARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfoTensorARM( TensorARM tensor_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensor{ tensor_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfoTensorARM( MemoryDedicatedAllocateInfoTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryDedicatedAllocateInfoTensorARM( VkMemoryDedicatedAllocateInfoTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryDedicatedAllocateInfoTensorARM( *reinterpret_cast( &rhs ) ) + { + } + + MemoryDedicatedAllocateInfoTensorARM & operator=( MemoryDedicatedAllocateInfoTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryDedicatedAllocateInfoTensorARM & operator=( VkMemoryDedicatedAllocateInfoTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfoTensorARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfoTensorARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfoTensorARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfoTensorARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryDedicatedAllocateInfoTensorARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryDedicatedAllocateInfoTensorARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryDedicatedAllocateInfoTensorARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryDedicatedAllocateInfoTensorARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tensor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryDedicatedAllocateInfoTensorARM const & ) const = default; +#else + bool operator==( MemoryDedicatedAllocateInfoTensorARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensor == rhs.tensor ); +# endif + } + + bool operator!=( MemoryDedicatedAllocateInfoTensorARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryDedicatedAllocateInfoTensorARM; + const void * pNext = {}; + TensorARM tensor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryDedicatedAllocateInfoTensorARM; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryDedicatedAllocateInfoTensorARM; + }; + + // wrapper struct for struct VkMemoryDedicatedRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDedicatedRequirements.html + struct MemoryDedicatedRequirements + { + using NativeType = VkMemoryDedicatedRequirements; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedRequirements; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryDedicatedRequirements( Bool32 prefersDedicatedAllocation_ = {}, + Bool32 requiresDedicatedAllocation_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , prefersDedicatedAllocation{ prefersDedicatedAllocation_ } + , requiresDedicatedAllocation{ requiresDedicatedAllocation_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryDedicatedRequirements( MemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryDedicatedRequirements( *reinterpret_cast( &rhs ) ) + { + } + + MemoryDedicatedRequirements & operator=( MemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryDedicatedRequirements & operator=( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkMemoryDedicatedRequirements const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryDedicatedRequirements &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryDedicatedRequirements const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryDedicatedRequirements *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, prefersDedicatedAllocation, requiresDedicatedAllocation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryDedicatedRequirements const & ) const = default; +#else + bool operator==( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) && + ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation ); +# endif + } + + bool operator!=( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryDedicatedRequirements; + void * pNext = {}; + Bool32 prefersDedicatedAllocation = {}; + Bool32 requiresDedicatedAllocation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryDedicatedRequirements; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryDedicatedRequirements; + }; + + using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements; + + // wrapper struct for struct VkMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryFdPropertiesKHR.html + struct MemoryFdPropertiesKHR + { + using NativeType = VkMemoryFdPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryFdPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryFdPropertiesKHR( uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryTypeBits{ memoryTypeBits_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryFdPropertiesKHR( MemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryFdPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + MemoryFdPropertiesKHR & operator=( MemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryFdPropertiesKHR & operator=( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkMemoryFdPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryFdPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryFdPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryFdPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryFdPropertiesKHR const & ) const = default; +#else + bool operator==( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif + } + + bool operator!=( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryFdPropertiesKHR; + void * pNext = {}; + uint32_t memoryTypeBits = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryFdPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryFdPropertiesKHR; + }; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + // wrapper struct for struct VkMemoryGetAndroidHardwareBufferInfoANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetAndroidHardwareBufferInfoANDROID.html + struct MemoryGetAndroidHardwareBufferInfoANDROID + { + using NativeType = VkMemoryGetAndroidHardwareBufferInfoANDROID; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryGetAndroidHardwareBufferInfoANDROID( *reinterpret_cast( &rhs ) ) + { + } + + MemoryGetAndroidHardwareBufferInfoANDROID & operator=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryGetAndroidHardwareBufferInfoANDROID & operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryGetAndroidHardwareBufferInfoANDROID & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetAndroidHardwareBufferInfoANDROID && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetAndroidHardwareBufferInfoANDROID & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetAndroidHardwareBufferInfoANDROID && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryGetAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetAndroidHardwareBufferInfoANDROID const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryGetAndroidHardwareBufferInfoANDROID *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryGetAndroidHardwareBufferInfoANDROID const & ) const = default; +# else + bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); +# endif + } + + bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; + const void * pNext = {}; + DeviceMemory memory = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryGetAndroidHardwareBufferInfoANDROID; + }; +# endif + + template <> + struct CppType + { + using Type = MemoryGetAndroidHardwareBufferInfoANDROID; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + // wrapper struct for struct VkMemoryGetFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetFdInfoKHR.html + struct MemoryGetFdInfoKHR + { + using NativeType = VkMemoryGetFdInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetFdInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( DeviceMemory memory_ = {}, + ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( MemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryGetFdInfoKHR( *reinterpret_cast( &rhs ) ) {} + + MemoryGetFdInfoKHR & operator=( MemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryGetFdInfoKHR & operator=( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryGetFdInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryGetFdInfoKHR const & ) const = default; +#else + bool operator==( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryGetFdInfoKHR; + const void * pNext = {}; + DeviceMemory memory = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryGetFdInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryGetFdInfoKHR; + }; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkMemoryGetMetalHandleInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetMetalHandleInfoEXT.html + struct MemoryGetMetalHandleInfoEXT + { + using NativeType = VkMemoryGetMetalHandleInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetMetalHandleInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryGetMetalHandleInfoEXT( DeviceMemory memory_ = {}, + ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryGetMetalHandleInfoEXT( MemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryGetMetalHandleInfoEXT( VkMemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryGetMetalHandleInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + MemoryGetMetalHandleInfoEXT & operator=( MemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryGetMetalHandleInfoEXT & operator=( VkMemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryGetMetalHandleInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetMetalHandleInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetMetalHandleInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryGetMetalHandleInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryGetMetalHandleInfoEXT const & ) const = default; +# else + bool operator==( MemoryGetMetalHandleInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( MemoryGetMetalHandleInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eMemoryGetMetalHandleInfoEXT; + const void * pNext = {}; + DeviceMemory memory = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryGetMetalHandleInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = MemoryGetMetalHandleInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + +#if defined( VK_USE_PLATFORM_OHOS ) + // wrapper struct for struct VkMemoryGetNativeBufferInfoOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetNativeBufferInfoOHOS.html + struct MemoryGetNativeBufferInfoOHOS + { + using NativeType = VkMemoryGetNativeBufferInfoOHOS; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetNativeBufferInfoOHOS; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryGetNativeBufferInfoOHOS( DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryGetNativeBufferInfoOHOS( MemoryGetNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryGetNativeBufferInfoOHOS( VkMemoryGetNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryGetNativeBufferInfoOHOS( *reinterpret_cast( &rhs ) ) + { + } + + MemoryGetNativeBufferInfoOHOS & operator=( MemoryGetNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryGetNativeBufferInfoOHOS & operator=( VkMemoryGetNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryGetNativeBufferInfoOHOS & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetNativeBufferInfoOHOS && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetNativeBufferInfoOHOS & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetNativeBufferInfoOHOS && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryGetNativeBufferInfoOHOS const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetNativeBufferInfoOHOS &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetNativeBufferInfoOHOS const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryGetNativeBufferInfoOHOS *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryGetNativeBufferInfoOHOS const & ) const = default; +# else + bool operator==( MemoryGetNativeBufferInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); +# endif + } + + bool operator!=( MemoryGetNativeBufferInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eMemoryGetNativeBufferInfoOHOS; + const void * pNext = {}; + DeviceMemory memory = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryGetNativeBufferInfoOHOS; + }; +# endif + + template <> + struct CppType + { + using Type = MemoryGetNativeBufferInfoOHOS; + }; +#endif /*VK_USE_PLATFORM_OHOS*/ + + // wrapper struct for struct VkMemoryGetRemoteAddressInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetRemoteAddressInfoNV.html + struct MemoryGetRemoteAddressInfoNV + { + using NativeType = VkMemoryGetRemoteAddressInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetRemoteAddressInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryGetRemoteAddressInfoNV( DeviceMemory memory_ = {}, + ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryGetRemoteAddressInfoNV( MemoryGetRemoteAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryGetRemoteAddressInfoNV( VkMemoryGetRemoteAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryGetRemoteAddressInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + MemoryGetRemoteAddressInfoNV & operator=( MemoryGetRemoteAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryGetRemoteAddressInfoNV & operator=( VkMemoryGetRemoteAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryGetRemoteAddressInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetRemoteAddressInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetRemoteAddressInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryGetRemoteAddressInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryGetRemoteAddressInfoNV const & ) const = default; +#else + bool operator==( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryGetRemoteAddressInfoNV; + const void * pNext = {}; + DeviceMemory memory = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryGetRemoteAddressInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryGetRemoteAddressInfoNV; + }; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkMemoryGetWin32HandleInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetWin32HandleInfoKHR.html + struct MemoryGetWin32HandleInfoKHR + { + using NativeType = VkMemoryGetWin32HandleInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetWin32HandleInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = {}, + ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( MemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryGetWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + MemoryGetWin32HandleInfoKHR & operator=( MemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryGetWin32HandleInfoKHR & operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryGetWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryGetWin32HandleInfoKHR const & ) const = default; +# else + bool operator==( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR; + const void * pNext = {}; + DeviceMemory memory = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryGetWin32HandleInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = MemoryGetWin32HandleInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkMemoryGetZirconHandleInfoFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetZirconHandleInfoFUCHSIA.html + struct MemoryGetZirconHandleInfoFUCHSIA + { + using NativeType = VkMemoryGetZirconHandleInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetZirconHandleInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryGetZirconHandleInfoFUCHSIA( DeviceMemory memory_ = {}, + ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryGetZirconHandleInfoFUCHSIA( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryGetZirconHandleInfoFUCHSIA( VkMemoryGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryGetZirconHandleInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + MemoryGetZirconHandleInfoFUCHSIA & operator=( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryGetZirconHandleInfoFUCHSIA & operator=( VkMemoryGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryGetZirconHandleInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryGetZirconHandleInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory, handleType ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryGetZirconHandleInfoFUCHSIA const & ) const = default; +# else + bool operator==( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eMemoryGetZirconHandleInfoFUCHSIA; + const void * pNext = {}; + DeviceMemory memory = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryGetZirconHandleInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = MemoryGetZirconHandleInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + // wrapper struct for struct VkMemoryHeap, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryHeap.html + struct MemoryHeap + { + using NativeType = VkMemoryHeap; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryHeap( DeviceSize size_ = {}, MemoryHeapFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT + : size{ size_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryHeap( MemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryHeap( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryHeap( *reinterpret_cast( &rhs ) ) {} + + MemoryHeap & operator=( MemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryHeap & operator=( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkMemoryHeap const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryHeap &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryHeap const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryHeap *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( size, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryHeap const & ) const = default; +#else + bool operator==( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( size == rhs.size ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceSize size = {}; + MemoryHeapFlags flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryHeap; + }; +#endif + + // wrapper struct for struct VkMemoryHostPointerPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryHostPointerPropertiesEXT.html + struct MemoryHostPointerPropertiesEXT + { + using NativeType = VkMemoryHostPointerPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryHostPointerPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryTypeBits{ memoryTypeBits_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryHostPointerPropertiesEXT( MemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryHostPointerPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + MemoryHostPointerPropertiesEXT & operator=( MemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryHostPointerPropertiesEXT & operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkMemoryHostPointerPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryHostPointerPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryHostPointerPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryHostPointerPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryHostPointerPropertiesEXT const & ) const = default; +#else + bool operator==( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif + } + + bool operator!=( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT; + void * pNext = {}; + uint32_t memoryTypeBits = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryHostPointerPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryHostPointerPropertiesEXT; + }; + + // wrapper struct for struct VkMemoryMapInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMapInfo.html + struct MemoryMapInfo + { + using NativeType = VkMemoryMapInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryMapInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryMapInfo( + MemoryMapFlags flags_ = {}, DeviceMemory memory_ = {}, DeviceSize offset_ = {}, DeviceSize size_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , memory{ memory_ } + , offset{ offset_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryMapInfo( MemoryMapInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryMapInfo( VkMemoryMapInfo const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryMapInfo( *reinterpret_cast( &rhs ) ) {} + + MemoryMapInfo & operator=( MemoryMapInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryMapInfo & operator=( VkMemoryMapInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo & setFlags( MemoryMapFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo && setFlags( MemoryMapFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryMapInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryMapInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryMapInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryMapInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, memory, offset, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryMapInfo const & ) const = default; +#else + bool operator==( MemoryMapInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) && + ( size == rhs.size ); +# endif + } + + bool operator!=( MemoryMapInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryMapInfo; + const void * pNext = {}; + MemoryMapFlags flags = {}; + DeviceMemory memory = {}; + DeviceSize offset = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryMapInfo; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryMapInfo; + }; + + using MemoryMapInfoKHR = MemoryMapInfo; + + // wrapper struct for struct VkMemoryMapPlacedInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMapPlacedInfoEXT.html + struct MemoryMapPlacedInfoEXT + { + using NativeType = VkMemoryMapPlacedInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryMapPlacedInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryMapPlacedInfoEXT( void * pPlacedAddress_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pPlacedAddress{ pPlacedAddress_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryMapPlacedInfoEXT( MemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryMapPlacedInfoEXT( VkMemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryMapPlacedInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + MemoryMapPlacedInfoEXT & operator=( MemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryMapPlacedInfoEXT & operator=( VkMemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryMapPlacedInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapPlacedInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapPlacedInfoEXT & setPPlacedAddress( void * pPlacedAddress_ ) & VULKAN_HPP_NOEXCEPT + { + pPlacedAddress = pPlacedAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryMapPlacedInfoEXT && setPPlacedAddress( void * pPlacedAddress_ ) && VULKAN_HPP_NOEXCEPT + { + pPlacedAddress = pPlacedAddress_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryMapPlacedInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryMapPlacedInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryMapPlacedInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryMapPlacedInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pPlacedAddress ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryMapPlacedInfoEXT const & ) const = default; +#else + bool operator==( MemoryMapPlacedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pPlacedAddress == rhs.pPlacedAddress ); +# endif + } + + bool operator!=( MemoryMapPlacedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryMapPlacedInfoEXT; + const void * pNext = {}; + void * pPlacedAddress = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryMapPlacedInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryMapPlacedInfoEXT; + }; + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkMemoryMetalHandlePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMetalHandlePropertiesEXT.html + struct MemoryMetalHandlePropertiesEXT + { + using NativeType = VkMemoryMetalHandlePropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryMetalHandlePropertiesEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryMetalHandlePropertiesEXT( uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryTypeBits{ memoryTypeBits_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryMetalHandlePropertiesEXT( MemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryMetalHandlePropertiesEXT( VkMemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryMetalHandlePropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + MemoryMetalHandlePropertiesEXT & operator=( MemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryMetalHandlePropertiesEXT & operator=( VkMemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkMemoryMetalHandlePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryMetalHandlePropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryMetalHandlePropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryMetalHandlePropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryMetalHandlePropertiesEXT const & ) const = default; +# else + bool operator==( MemoryMetalHandlePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif + } + + bool operator!=( MemoryMetalHandlePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eMemoryMetalHandlePropertiesEXT; + void * pNext = {}; + uint32_t memoryTypeBits = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryMetalHandlePropertiesEXT; + }; +# endif + + template <> + struct CppType + { + using Type = MemoryMetalHandlePropertiesEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + // wrapper struct for struct VkMemoryOpaqueCaptureAddressAllocateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html + struct MemoryOpaqueCaptureAddressAllocateInfo + { + using NativeType = VkMemoryOpaqueCaptureAddressAllocateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryOpaqueCaptureAddressAllocateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryOpaqueCaptureAddressAllocateInfo( uint64_t opaqueCaptureAddress_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , opaqueCaptureAddress{ opaqueCaptureAddress_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryOpaqueCaptureAddressAllocateInfo( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryOpaqueCaptureAddressAllocateInfo( VkMemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryOpaqueCaptureAddressAllocateInfo( *reinterpret_cast( &rhs ) ) + { + } + + MemoryOpaqueCaptureAddressAllocateInfo & operator=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryOpaqueCaptureAddressAllocateInfo & operator=( VkMemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryOpaqueCaptureAddressAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryOpaqueCaptureAddressAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryOpaqueCaptureAddressAllocateInfo & setOpaqueCaptureAddress( uint64_t opaqueCaptureAddress_ ) & VULKAN_HPP_NOEXCEPT + { + opaqueCaptureAddress = opaqueCaptureAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryOpaqueCaptureAddressAllocateInfo && setOpaqueCaptureAddress( uint64_t opaqueCaptureAddress_ ) && VULKAN_HPP_NOEXCEPT + { + opaqueCaptureAddress = opaqueCaptureAddress_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryOpaqueCaptureAddressAllocateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryOpaqueCaptureAddressAllocateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryOpaqueCaptureAddressAllocateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryOpaqueCaptureAddressAllocateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, opaqueCaptureAddress ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryOpaqueCaptureAddressAllocateInfo const & ) const = default; +#else + bool operator==( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress ); +# endif + } + + bool operator!=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryOpaqueCaptureAddressAllocateInfo; + const void * pNext = {}; + uint64_t opaqueCaptureAddress = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryOpaqueCaptureAddressAllocateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryOpaqueCaptureAddressAllocateInfo; + }; + + using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo; + + // wrapper struct for struct VkMemoryPriorityAllocateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryPriorityAllocateInfoEXT.html + struct MemoryPriorityAllocateInfoEXT + { + using NativeType = VkMemoryPriorityAllocateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryPriorityAllocateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , priority{ priority_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( MemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryPriorityAllocateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + MemoryPriorityAllocateInfoEXT & operator=( MemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryPriorityAllocateInfoEXT & operator=( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryPriorityAllocateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryPriorityAllocateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryPriorityAllocateInfoEXT & setPriority( float priority_ ) & VULKAN_HPP_NOEXCEPT + { + priority = priority_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryPriorityAllocateInfoEXT && setPriority( float priority_ ) && VULKAN_HPP_NOEXCEPT + { + priority = priority_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryPriorityAllocateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryPriorityAllocateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryPriorityAllocateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryPriorityAllocateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, priority ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryPriorityAllocateInfoEXT const & ) const = default; +#else + bool operator==( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priority == rhs.priority ); +# endif + } + + bool operator!=( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT; + const void * pNext = {}; + float priority = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryPriorityAllocateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryPriorityAllocateInfoEXT; + }; + + // wrapper struct for struct VkMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryRequirements.html + struct MemoryRequirements + { + using NativeType = VkMemoryRequirements; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryRequirements( DeviceSize size_ = {}, DeviceSize alignment_ = {}, uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT + : size{ size_ } + , alignment{ alignment_ } + , memoryTypeBits{ memoryTypeBits_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryRequirements( MemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryRequirements( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryRequirements( *reinterpret_cast( &rhs ) ) {} + + MemoryRequirements & operator=( MemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryRequirements & operator=( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryRequirements &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryRequirements const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryRequirements *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( size, alignment, memoryTypeBits ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryRequirements const & ) const = default; +#else + bool operator==( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( size == rhs.size ) && ( alignment == rhs.alignment ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif + } + + bool operator!=( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceSize size = {}; + DeviceSize alignment = {}; + uint32_t memoryTypeBits = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryRequirements; + }; +#endif + + // wrapper struct for struct VkMemoryRequirements2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryRequirements2.html + struct MemoryRequirements2 + { + using NativeType = VkMemoryRequirements2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryRequirements2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryRequirements2( MemoryRequirements memoryRequirements_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryRequirements{ memoryRequirements_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryRequirements2( MemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryRequirements2( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryRequirements2( *reinterpret_cast( &rhs ) ) + { + } + + MemoryRequirements2 & operator=( MemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryRequirements2 & operator=( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryRequirements2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryRequirements2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryRequirements ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryRequirements2 const & ) const = default; +#else + bool operator==( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements ); +# endif + } + + bool operator!=( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryRequirements2; + void * pNext = {}; + MemoryRequirements memoryRequirements = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryRequirements2; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryRequirements2; + }; + + using MemoryRequirements2KHR = MemoryRequirements2; + + // wrapper struct for struct VkMemoryType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryType.html + struct MemoryType + { + using NativeType = VkMemoryType; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryType( MemoryPropertyFlags propertyFlags_ = {}, uint32_t heapIndex_ = {} ) VULKAN_HPP_NOEXCEPT + : propertyFlags{ propertyFlags_ } + , heapIndex{ heapIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryType( MemoryType const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryType( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryType( *reinterpret_cast( &rhs ) ) {} + + MemoryType & operator=( MemoryType const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryType & operator=( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkMemoryType const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryType &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryType const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryType *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( propertyFlags, heapIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryType const & ) const = default; +#else + bool operator==( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( propertyFlags == rhs.propertyFlags ) && ( heapIndex == rhs.heapIndex ); +# endif + } + + bool operator!=( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + MemoryPropertyFlags propertyFlags = {}; + uint32_t heapIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryType; + }; +#endif + + // wrapper struct for struct VkMemoryUnmapInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryUnmapInfo.html + struct MemoryUnmapInfo + { + using NativeType = VkMemoryUnmapInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryUnmapInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryUnmapInfo( MemoryUnmapFlags flags_ = {}, DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , memory{ memory_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryUnmapInfo( MemoryUnmapInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryUnmapInfo( VkMemoryUnmapInfo const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryUnmapInfo( *reinterpret_cast( &rhs ) ) {} + + MemoryUnmapInfo & operator=( MemoryUnmapInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryUnmapInfo & operator=( VkMemoryUnmapInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo & setFlags( MemoryUnmapFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo && setFlags( MemoryUnmapFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMemoryUnmapInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryUnmapInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryUnmapInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryUnmapInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, memory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryUnmapInfo const & ) const = default; +#else + bool operator==( MemoryUnmapInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( memory == rhs.memory ); +# endif + } + + bool operator!=( MemoryUnmapInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMemoryUnmapInfo; + const void * pNext = {}; + MemoryUnmapFlags flags = {}; + DeviceMemory memory = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryUnmapInfo; + }; +#endif + + template <> + struct CppType + { + using Type = MemoryUnmapInfo; + }; + + using MemoryUnmapInfoKHR = MemoryUnmapInfo; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkMemoryWin32HandlePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryWin32HandlePropertiesKHR.html + struct MemoryWin32HandlePropertiesKHR + { + using NativeType = VkMemoryWin32HandlePropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryWin32HandlePropertiesKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryWin32HandlePropertiesKHR( uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryTypeBits{ memoryTypeBits_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryWin32HandlePropertiesKHR( MemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryWin32HandlePropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + MemoryWin32HandlePropertiesKHR & operator=( MemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryWin32HandlePropertiesKHR & operator=( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkMemoryWin32HandlePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryWin32HandlePropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryWin32HandlePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryWin32HandlePropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryWin32HandlePropertiesKHR const & ) const = default; +# else + bool operator==( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif + } + + bool operator!=( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR; + void * pNext = {}; + uint32_t memoryTypeBits = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryWin32HandlePropertiesKHR; + }; +# endif + + template <> + struct CppType + { + using Type = MemoryWin32HandlePropertiesKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkMemoryZirconHandlePropertiesFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryZirconHandlePropertiesFUCHSIA.html + struct MemoryZirconHandlePropertiesFUCHSIA + { + using NativeType = VkMemoryZirconHandlePropertiesFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryZirconHandlePropertiesFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MemoryZirconHandlePropertiesFUCHSIA( uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryTypeBits{ memoryTypeBits_ } + { + } + + VULKAN_HPP_CONSTEXPR MemoryZirconHandlePropertiesFUCHSIA( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MemoryZirconHandlePropertiesFUCHSIA( VkMemoryZirconHandlePropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : MemoryZirconHandlePropertiesFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + MemoryZirconHandlePropertiesFUCHSIA & operator=( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MemoryZirconHandlePropertiesFUCHSIA & operator=( VkMemoryZirconHandlePropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkMemoryZirconHandlePropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryZirconHandlePropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMemoryZirconHandlePropertiesFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMemoryZirconHandlePropertiesFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryTypeBits ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MemoryZirconHandlePropertiesFUCHSIA const & ) const = default; +# else + bool operator==( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif + } + + bool operator!=( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eMemoryZirconHandlePropertiesFUCHSIA; + void * pNext = {}; + uint32_t memoryTypeBits = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MemoryZirconHandlePropertiesFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = MemoryZirconHandlePropertiesFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + // wrapper struct for struct VkMetalSurfaceCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMetalSurfaceCreateInfoEXT.html + struct MetalSurfaceCreateInfoEXT + { + using NativeType = VkMetalSurfaceCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMetalSurfaceCreateInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + MetalSurfaceCreateInfoEXT( MetalSurfaceCreateFlagsEXT flags_ = {}, const CAMetalLayer * pLayer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pLayer{ pLayer_ } + { + } + + VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( MetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MetalSurfaceCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + MetalSurfaceCreateInfoEXT & operator=( MetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MetalSurfaceCreateInfoEXT & operator=( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT & setFlags( MetalSurfaceCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT && setFlags( MetalSurfaceCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT & setPLayer( const CAMetalLayer * pLayer_ ) & VULKAN_HPP_NOEXCEPT + { + pLayer = pLayer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT && setPLayer( const CAMetalLayer * pLayer_ ) && VULKAN_HPP_NOEXCEPT + { + pLayer = pLayer_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMetalSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMetalSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMetalSurfaceCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMetalSurfaceCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pLayer ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MetalSurfaceCreateInfoEXT const & ) const = default; +# else + bool operator==( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pLayer == rhs.pLayer ); +# endif + } + + bool operator!=( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT; + const void * pNext = {}; + MetalSurfaceCreateFlagsEXT flags = {}; + const CAMetalLayer * pLayer = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MetalSurfaceCreateInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = MetalSurfaceCreateInfoEXT; + }; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + // wrapper struct for struct VkMicromapBuildInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapBuildInfoEXT.html + struct MicromapBuildInfoEXT + { + using NativeType = VkMicromapBuildInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMicromapBuildInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT( MicromapTypeEXT type_ = MicromapTypeEXT::eOpacityMicromap, + BuildMicromapFlagsEXT flags_ = {}, + BuildMicromapModeEXT mode_ = BuildMicromapModeEXT::eBuild, + MicromapEXT dstMicromap_ = {}, + uint32_t usageCountsCount_ = {}, + const MicromapUsageEXT * pUsageCounts_ = {}, + const MicromapUsageEXT * const * ppUsageCounts_ = {}, + DeviceOrHostAddressConstKHR data_ = {}, + DeviceOrHostAddressKHR scratchData_ = {}, + DeviceOrHostAddressConstKHR triangleArray_ = {}, + DeviceSize triangleArrayStride_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , flags{ flags_ } + , mode{ mode_ } + , dstMicromap{ dstMicromap_ } + , usageCountsCount{ usageCountsCount_ } + , pUsageCounts{ pUsageCounts_ } + , ppUsageCounts{ ppUsageCounts_ } + , data{ data_ } + , scratchData{ scratchData_ } + , triangleArray{ triangleArray_ } + , triangleArrayStride{ triangleArrayStride_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT( MicromapBuildInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MicromapBuildInfoEXT( VkMicromapBuildInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MicromapBuildInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MicromapBuildInfoEXT( MicromapTypeEXT type_, + BuildMicromapFlagsEXT flags_, + BuildMicromapModeEXT mode_, + MicromapEXT dstMicromap_, + ArrayProxyNoTemporaries const & usageCounts_, + ArrayProxyNoTemporaries const & pUsageCounts_ = {}, + DeviceOrHostAddressConstKHR data_ = {}, + DeviceOrHostAddressKHR scratchData_ = {}, + DeviceOrHostAddressConstKHR triangleArray_ = {}, + DeviceSize triangleArrayStride_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , type( type_ ) + , flags( flags_ ) + , mode( mode_ ) + , dstMicromap( dstMicromap_ ) + , usageCountsCount( static_cast( !usageCounts_.empty() ? usageCounts_.size() : pUsageCounts_.size() ) ) + , pUsageCounts( usageCounts_.data() ) + , ppUsageCounts( pUsageCounts_.data() ) + , data( data_ ) + , scratchData( scratchData_ ) + , triangleArray( triangleArray_ ) + , triangleArrayStride( triangleArrayStride_ ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( ( !usageCounts_.empty() + !pUsageCounts_.empty() ) <= 1 ); +# else + if ( 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() ) ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::MicromapBuildInfoEXT::MicromapBuildInfoEXT: 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + MicromapBuildInfoEXT & operator=( MicromapBuildInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MicromapBuildInfoEXT & operator=( VkMicromapBuildInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setType( MicromapTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setType( MicromapTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setFlags( BuildMicromapFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setFlags( BuildMicromapFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setMode( BuildMicromapModeEXT mode_ ) & VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setMode( BuildMicromapModeEXT mode_ ) && VULKAN_HPP_NOEXCEPT + { + mode = mode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setDstMicromap( MicromapEXT dstMicromap_ ) & VULKAN_HPP_NOEXCEPT + { + dstMicromap = dstMicromap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setDstMicromap( MicromapEXT dstMicromap_ ) && VULKAN_HPP_NOEXCEPT + { + dstMicromap = dstMicromap_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setUsageCountsCount( uint32_t usageCountsCount_ ) & VULKAN_HPP_NOEXCEPT + { + usageCountsCount = usageCountsCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setUsageCountsCount( uint32_t usageCountsCount_ ) && VULKAN_HPP_NOEXCEPT + { + usageCountsCount = usageCountsCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) & VULKAN_HPP_NOEXCEPT + { + pUsageCounts = pUsageCounts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) && VULKAN_HPP_NOEXCEPT + { + pUsageCounts = pUsageCounts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MicromapBuildInfoEXT & setUsageCounts( ArrayProxyNoTemporaries const & usageCounts_ ) VULKAN_HPP_NOEXCEPT + { + usageCountsCount = static_cast( usageCounts_.size() ); + pUsageCounts = usageCounts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) & VULKAN_HPP_NOEXCEPT + { + ppUsageCounts = ppUsageCounts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) && VULKAN_HPP_NOEXCEPT + { + ppUsageCounts = ppUsageCounts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MicromapBuildInfoEXT & setPUsageCounts( ArrayProxyNoTemporaries const & pUsageCounts_ ) VULKAN_HPP_NOEXCEPT + { + usageCountsCount = static_cast( pUsageCounts_.size() ); + ppUsageCounts = pUsageCounts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setData( DeviceOrHostAddressConstKHR const & data_ ) & VULKAN_HPP_NOEXCEPT + { + data = data_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setData( DeviceOrHostAddressConstKHR const & data_ ) && VULKAN_HPP_NOEXCEPT + { + data = data_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setScratchData( DeviceOrHostAddressKHR const & scratchData_ ) & VULKAN_HPP_NOEXCEPT + { + scratchData = scratchData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setScratchData( DeviceOrHostAddressKHR const & scratchData_ ) && VULKAN_HPP_NOEXCEPT + { + scratchData = scratchData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setTriangleArray( DeviceOrHostAddressConstKHR const & triangleArray_ ) & VULKAN_HPP_NOEXCEPT + { + triangleArray = triangleArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setTriangleArray( DeviceOrHostAddressConstKHR const & triangleArray_ ) && VULKAN_HPP_NOEXCEPT + { + triangleArray = triangleArray_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setTriangleArrayStride( DeviceSize triangleArrayStride_ ) & VULKAN_HPP_NOEXCEPT + { + triangleArrayStride = triangleArrayStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setTriangleArrayStride( DeviceSize triangleArrayStride_ ) && VULKAN_HPP_NOEXCEPT + { + triangleArrayStride = triangleArrayStride_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMicromapBuildInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapBuildInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapBuildInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMicromapBuildInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, type, flags, mode, dstMicromap, usageCountsCount, pUsageCounts, ppUsageCounts, data, scratchData, triangleArray, triangleArrayStride ); + } +#endif + + public: + StructureType sType = StructureType::eMicromapBuildInfoEXT; + const void * pNext = {}; + MicromapTypeEXT type = MicromapTypeEXT::eOpacityMicromap; + BuildMicromapFlagsEXT flags = {}; + BuildMicromapModeEXT mode = BuildMicromapModeEXT::eBuild; + MicromapEXT dstMicromap = {}; + uint32_t usageCountsCount = {}; + const MicromapUsageEXT * pUsageCounts = {}; + const MicromapUsageEXT * const * ppUsageCounts = {}; + DeviceOrHostAddressConstKHR data = {}; + DeviceOrHostAddressKHR scratchData = {}; + DeviceOrHostAddressConstKHR triangleArray = {}; + DeviceSize triangleArrayStride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MicromapBuildInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = MicromapBuildInfoEXT; + }; + + // wrapper struct for struct VkMicromapBuildSizesInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapBuildSizesInfoEXT.html + struct MicromapBuildSizesInfoEXT + { + using NativeType = VkMicromapBuildSizesInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMicromapBuildSizesInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MicromapBuildSizesInfoEXT( DeviceSize micromapSize_ = {}, + DeviceSize buildScratchSize_ = {}, + Bool32 discardable_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , micromapSize{ micromapSize_ } + , buildScratchSize{ buildScratchSize_ } + , discardable{ discardable_ } + { + } + + VULKAN_HPP_CONSTEXPR MicromapBuildSizesInfoEXT( MicromapBuildSizesInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MicromapBuildSizesInfoEXT( VkMicromapBuildSizesInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MicromapBuildSizesInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + MicromapBuildSizesInfoEXT & operator=( MicromapBuildSizesInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MicromapBuildSizesInfoEXT & operator=( VkMicromapBuildSizesInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT & setMicromapSize( DeviceSize micromapSize_ ) & VULKAN_HPP_NOEXCEPT + { + micromapSize = micromapSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT && setMicromapSize( DeviceSize micromapSize_ ) && VULKAN_HPP_NOEXCEPT + { + micromapSize = micromapSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT & setBuildScratchSize( DeviceSize buildScratchSize_ ) & VULKAN_HPP_NOEXCEPT + { + buildScratchSize = buildScratchSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT && setBuildScratchSize( DeviceSize buildScratchSize_ ) && VULKAN_HPP_NOEXCEPT + { + buildScratchSize = buildScratchSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT & setDiscardable( Bool32 discardable_ ) & VULKAN_HPP_NOEXCEPT + { + discardable = discardable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT && setDiscardable( Bool32 discardable_ ) && VULKAN_HPP_NOEXCEPT + { + discardable = discardable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMicromapBuildSizesInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapBuildSizesInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapBuildSizesInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMicromapBuildSizesInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, micromapSize, buildScratchSize, discardable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MicromapBuildSizesInfoEXT const & ) const = default; +#else + bool operator==( MicromapBuildSizesInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( micromapSize == rhs.micromapSize ) && ( buildScratchSize == rhs.buildScratchSize ) && + ( discardable == rhs.discardable ); +# endif + } + + bool operator!=( MicromapBuildSizesInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMicromapBuildSizesInfoEXT; + const void * pNext = {}; + DeviceSize micromapSize = {}; + DeviceSize buildScratchSize = {}; + Bool32 discardable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MicromapBuildSizesInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = MicromapBuildSizesInfoEXT; + }; + + // wrapper struct for struct VkMicromapCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapCreateInfoEXT.html + struct MicromapCreateInfoEXT + { + using NativeType = VkMicromapCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMicromapCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MicromapCreateInfoEXT( MicromapCreateFlagsEXT createFlags_ = {}, + Buffer buffer_ = {}, + DeviceSize offset_ = {}, + DeviceSize size_ = {}, + MicromapTypeEXT type_ = MicromapTypeEXT::eOpacityMicromap, + DeviceAddress deviceAddress_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , createFlags{ createFlags_ } + , buffer{ buffer_ } + , offset{ offset_ } + , size{ size_ } + , type{ type_ } + , deviceAddress{ deviceAddress_ } + { + } + + VULKAN_HPP_CONSTEXPR MicromapCreateInfoEXT( MicromapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MicromapCreateInfoEXT( VkMicromapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MicromapCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + MicromapCreateInfoEXT & operator=( MicromapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MicromapCreateInfoEXT & operator=( VkMicromapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setCreateFlags( MicromapCreateFlagsEXT createFlags_ ) & VULKAN_HPP_NOEXCEPT + { + createFlags = createFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setCreateFlags( MicromapCreateFlagsEXT createFlags_ ) && VULKAN_HPP_NOEXCEPT + { + createFlags = createFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT + { + buffer = buffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setType( MicromapTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setType( MicromapTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT + { + deviceAddress = deviceAddress_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMicromapCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMicromapCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MicromapCreateInfoEXT const & ) const = default; +#else + bool operator==( MicromapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && + ( size == rhs.size ) && ( type == rhs.type ) && ( deviceAddress == rhs.deviceAddress ); +# endif + } + + bool operator!=( MicromapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMicromapCreateInfoEXT; + const void * pNext = {}; + MicromapCreateFlagsEXT createFlags = {}; + Buffer buffer = {}; + DeviceSize offset = {}; + DeviceSize size = {}; + MicromapTypeEXT type = MicromapTypeEXT::eOpacityMicromap; + DeviceAddress deviceAddress = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MicromapCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = MicromapCreateInfoEXT; + }; + + // wrapper struct for struct VkMicromapTriangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapTriangleEXT.html + struct MicromapTriangleEXT + { + using NativeType = VkMicromapTriangleEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MicromapTriangleEXT( uint32_t dataOffset_ = {}, uint16_t subdivisionLevel_ = {}, uint16_t format_ = {} ) VULKAN_HPP_NOEXCEPT + : dataOffset{ dataOffset_ } + , subdivisionLevel{ subdivisionLevel_ } + , format{ format_ } + { + } + + VULKAN_HPP_CONSTEXPR MicromapTriangleEXT( MicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MicromapTriangleEXT( VkMicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT : MicromapTriangleEXT( *reinterpret_cast( &rhs ) ) + { + } + + MicromapTriangleEXT & operator=( MicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MicromapTriangleEXT & operator=( VkMicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT & setDataOffset( uint32_t dataOffset_ ) & VULKAN_HPP_NOEXCEPT + { + dataOffset = dataOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT && setDataOffset( uint32_t dataOffset_ ) && VULKAN_HPP_NOEXCEPT + { + dataOffset = dataOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT & setSubdivisionLevel( uint16_t subdivisionLevel_ ) & VULKAN_HPP_NOEXCEPT + { + subdivisionLevel = subdivisionLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT && setSubdivisionLevel( uint16_t subdivisionLevel_ ) && VULKAN_HPP_NOEXCEPT + { + subdivisionLevel = subdivisionLevel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT & setFormat( uint16_t format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT && setFormat( uint16_t format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMicromapTriangleEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapTriangleEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapTriangleEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMicromapTriangleEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( dataOffset, subdivisionLevel, format ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MicromapTriangleEXT const & ) const = default; +#else + bool operator==( MicromapTriangleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( dataOffset == rhs.dataOffset ) && ( subdivisionLevel == rhs.subdivisionLevel ) && ( format == rhs.format ); +# endif + } + + bool operator!=( MicromapTriangleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t dataOffset = {}; + uint16_t subdivisionLevel = {}; + uint16_t format = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MicromapTriangleEXT; + }; +#endif + + // wrapper struct for struct VkMicromapVersionInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapVersionInfoEXT.html + struct MicromapVersionInfoEXT + { + using NativeType = VkMicromapVersionInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMicromapVersionInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MicromapVersionInfoEXT( const uint8_t * pVersionData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pVersionData{ pVersionData_ } + { + } + + VULKAN_HPP_CONSTEXPR MicromapVersionInfoEXT( MicromapVersionInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MicromapVersionInfoEXT( VkMicromapVersionInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MicromapVersionInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + MicromapVersionInfoEXT & operator=( MicromapVersionInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MicromapVersionInfoEXT & operator=( VkMicromapVersionInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MicromapVersionInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapVersionInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MicromapVersionInfoEXT & setPVersionData( const uint8_t * pVersionData_ ) & VULKAN_HPP_NOEXCEPT + { + pVersionData = pVersionData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MicromapVersionInfoEXT && setPVersionData( const uint8_t * pVersionData_ ) && VULKAN_HPP_NOEXCEPT + { + pVersionData = pVersionData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMicromapVersionInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapVersionInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMicromapVersionInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMicromapVersionInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pVersionData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MicromapVersionInfoEXT const & ) const = default; +#else + bool operator==( MicromapVersionInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData ); +# endif + } + + bool operator!=( MicromapVersionInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMicromapVersionInfoEXT; + const void * pNext = {}; + const uint8_t * pVersionData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MicromapVersionInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = MicromapVersionInfoEXT; + }; + + // wrapper struct for struct VkMultiDrawIndexedInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultiDrawIndexedInfoEXT.html + struct MultiDrawIndexedInfoEXT + { + using NativeType = VkMultiDrawIndexedInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MultiDrawIndexedInfoEXT( uint32_t firstIndex_ = {}, uint32_t indexCount_ = {}, int32_t vertexOffset_ = {} ) VULKAN_HPP_NOEXCEPT + : firstIndex{ firstIndex_ } + , indexCount{ indexCount_ } + , vertexOffset{ vertexOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR MultiDrawIndexedInfoEXT( MultiDrawIndexedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MultiDrawIndexedInfoEXT( VkMultiDrawIndexedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MultiDrawIndexedInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + MultiDrawIndexedInfoEXT & operator=( MultiDrawIndexedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MultiDrawIndexedInfoEXT & operator=( VkMultiDrawIndexedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT & setFirstIndex( uint32_t firstIndex_ ) & VULKAN_HPP_NOEXCEPT + { + firstIndex = firstIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT && setFirstIndex( uint32_t firstIndex_ ) && VULKAN_HPP_NOEXCEPT + { + firstIndex = firstIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT & setIndexCount( uint32_t indexCount_ ) & VULKAN_HPP_NOEXCEPT + { + indexCount = indexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT && setIndexCount( uint32_t indexCount_ ) && VULKAN_HPP_NOEXCEPT + { + indexCount = indexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT & setVertexOffset( int32_t vertexOffset_ ) & VULKAN_HPP_NOEXCEPT + { + vertexOffset = vertexOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT && setVertexOffset( int32_t vertexOffset_ ) && VULKAN_HPP_NOEXCEPT + { + vertexOffset = vertexOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMultiDrawIndexedInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultiDrawIndexedInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultiDrawIndexedInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMultiDrawIndexedInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( firstIndex, indexCount, vertexOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MultiDrawIndexedInfoEXT const & ) const = default; +#else + bool operator==( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( firstIndex == rhs.firstIndex ) && ( indexCount == rhs.indexCount ) && ( vertexOffset == rhs.vertexOffset ); +# endif + } + + bool operator!=( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t firstIndex = {}; + uint32_t indexCount = {}; + int32_t vertexOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MultiDrawIndexedInfoEXT; + }; +#endif + + // wrapper struct for struct VkMultiDrawInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultiDrawInfoEXT.html + struct MultiDrawInfoEXT + { + using NativeType = VkMultiDrawInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MultiDrawInfoEXT( uint32_t firstVertex_ = {}, uint32_t vertexCount_ = {} ) VULKAN_HPP_NOEXCEPT + : firstVertex{ firstVertex_ } + , vertexCount{ vertexCount_ } + { + } + + VULKAN_HPP_CONSTEXPR MultiDrawInfoEXT( MultiDrawInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MultiDrawInfoEXT( VkMultiDrawInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : MultiDrawInfoEXT( *reinterpret_cast( &rhs ) ) {} + + MultiDrawInfoEXT & operator=( MultiDrawInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MultiDrawInfoEXT & operator=( VkMultiDrawInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MultiDrawInfoEXT & setFirstVertex( uint32_t firstVertex_ ) & VULKAN_HPP_NOEXCEPT + { + firstVertex = firstVertex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultiDrawInfoEXT && setFirstVertex( uint32_t firstVertex_ ) && VULKAN_HPP_NOEXCEPT + { + firstVertex = firstVertex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MultiDrawInfoEXT & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT + { + vertexCount = vertexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultiDrawInfoEXT && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT + { + vertexCount = vertexCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMultiDrawInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultiDrawInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultiDrawInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMultiDrawInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( firstVertex, vertexCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MultiDrawInfoEXT const & ) const = default; +#else + bool operator==( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( firstVertex == rhs.firstVertex ) && ( vertexCount == rhs.vertexCount ); +# endif + } + + bool operator!=( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t firstVertex = {}; + uint32_t vertexCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MultiDrawInfoEXT; + }; +#endif + + // wrapper struct for struct VkMultisamplePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultisamplePropertiesEXT.html + struct MultisamplePropertiesEXT + { + using NativeType = VkMultisamplePropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultisamplePropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MultisamplePropertiesEXT( Extent2D maxSampleLocationGridSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxSampleLocationGridSize{ maxSampleLocationGridSize_ } + { + } + + VULKAN_HPP_CONSTEXPR MultisamplePropertiesEXT( MultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MultisamplePropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + MultisamplePropertiesEXT & operator=( MultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MultisamplePropertiesEXT & operator=( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkMultisamplePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultisamplePropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultisamplePropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMultisamplePropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSampleLocationGridSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MultisamplePropertiesEXT const & ) const = default; +#else + bool operator==( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ); +# endif + } + + bool operator!=( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMultisamplePropertiesEXT; + void * pNext = {}; + Extent2D maxSampleLocationGridSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MultisamplePropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = MultisamplePropertiesEXT; + }; + + // wrapper struct for struct VkMultisampledRenderToSingleSampledInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultisampledRenderToSingleSampledInfoEXT.html + struct MultisampledRenderToSingleSampledInfoEXT + { + using NativeType = VkMultisampledRenderToSingleSampledInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultisampledRenderToSingleSampledInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MultisampledRenderToSingleSampledInfoEXT( Bool32 multisampledRenderToSingleSampledEnable_ = {}, + SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , multisampledRenderToSingleSampledEnable{ multisampledRenderToSingleSampledEnable_ } + , rasterizationSamples{ rasterizationSamples_ } + { + } + + VULKAN_HPP_CONSTEXPR MultisampledRenderToSingleSampledInfoEXT( MultisampledRenderToSingleSampledInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MultisampledRenderToSingleSampledInfoEXT( VkMultisampledRenderToSingleSampledInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MultisampledRenderToSingleSampledInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + MultisampledRenderToSingleSampledInfoEXT & operator=( MultisampledRenderToSingleSampledInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MultisampledRenderToSingleSampledInfoEXT & operator=( VkMultisampledRenderToSingleSampledInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT & + setMultisampledRenderToSingleSampledEnable( Bool32 multisampledRenderToSingleSampledEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + multisampledRenderToSingleSampledEnable = multisampledRenderToSingleSampledEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT && + setMultisampledRenderToSingleSampledEnable( Bool32 multisampledRenderToSingleSampledEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + multisampledRenderToSingleSampledEnable = multisampledRenderToSingleSampledEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT & setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) & + VULKAN_HPP_NOEXCEPT + { + rasterizationSamples = rasterizationSamples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT && setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) && + VULKAN_HPP_NOEXCEPT + { + rasterizationSamples = rasterizationSamples_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMultisampledRenderToSingleSampledInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultisampledRenderToSingleSampledInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultisampledRenderToSingleSampledInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMultisampledRenderToSingleSampledInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, multisampledRenderToSingleSampledEnable, rasterizationSamples ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MultisampledRenderToSingleSampledInfoEXT const & ) const = default; +#else + bool operator==( MultisampledRenderToSingleSampledInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multisampledRenderToSingleSampledEnable == rhs.multisampledRenderToSingleSampledEnable ) && + ( rasterizationSamples == rhs.rasterizationSamples ); +# endif + } + + bool operator!=( MultisampledRenderToSingleSampledInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMultisampledRenderToSingleSampledInfoEXT; + const void * pNext = {}; + Bool32 multisampledRenderToSingleSampledEnable = {}; + SampleCountFlagBits rasterizationSamples = SampleCountFlagBits::e1; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MultisampledRenderToSingleSampledInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = MultisampledRenderToSingleSampledInfoEXT; + }; + + // wrapper struct for struct VkMultiviewPerViewAttributesInfoNVX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultiviewPerViewAttributesInfoNVX.html + struct MultiviewPerViewAttributesInfoNVX + { + using NativeType = VkMultiviewPerViewAttributesInfoNVX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultiviewPerViewAttributesInfoNVX; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MultiviewPerViewAttributesInfoNVX( Bool32 perViewAttributes_ = {}, + Bool32 perViewAttributesPositionXOnly_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , perViewAttributes{ perViewAttributes_ } + , perViewAttributesPositionXOnly{ perViewAttributesPositionXOnly_ } + { + } + + VULKAN_HPP_CONSTEXPR MultiviewPerViewAttributesInfoNVX( MultiviewPerViewAttributesInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MultiviewPerViewAttributesInfoNVX( VkMultiviewPerViewAttributesInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + : MultiviewPerViewAttributesInfoNVX( *reinterpret_cast( &rhs ) ) + { + } + + MultiviewPerViewAttributesInfoNVX & operator=( MultiviewPerViewAttributesInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MultiviewPerViewAttributesInfoNVX & operator=( VkMultiviewPerViewAttributesInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX & setPerViewAttributes( Bool32 perViewAttributes_ ) & VULKAN_HPP_NOEXCEPT + { + perViewAttributes = perViewAttributes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX && setPerViewAttributes( Bool32 perViewAttributes_ ) && VULKAN_HPP_NOEXCEPT + { + perViewAttributes = perViewAttributes_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX & setPerViewAttributesPositionXOnly( Bool32 perViewAttributesPositionXOnly_ ) & + VULKAN_HPP_NOEXCEPT + { + perViewAttributesPositionXOnly = perViewAttributesPositionXOnly_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX && setPerViewAttributesPositionXOnly( Bool32 perViewAttributesPositionXOnly_ ) && + VULKAN_HPP_NOEXCEPT + { + perViewAttributesPositionXOnly = perViewAttributesPositionXOnly_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMultiviewPerViewAttributesInfoNVX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultiviewPerViewAttributesInfoNVX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultiviewPerViewAttributesInfoNVX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMultiviewPerViewAttributesInfoNVX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, perViewAttributes, perViewAttributesPositionXOnly ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MultiviewPerViewAttributesInfoNVX const & ) const = default; +#else + bool operator==( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewAttributes == rhs.perViewAttributes ) && + ( perViewAttributesPositionXOnly == rhs.perViewAttributesPositionXOnly ); +# endif + } + + bool operator!=( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMultiviewPerViewAttributesInfoNVX; + const void * pNext = {}; + Bool32 perViewAttributes = {}; + Bool32 perViewAttributesPositionXOnly = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MultiviewPerViewAttributesInfoNVX; + }; +#endif + + template <> + struct CppType + { + using Type = MultiviewPerViewAttributesInfoNVX; + }; + + // wrapper struct for struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.html + struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM + { + using NativeType = VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( uint32_t perViewRenderAreaCount_ = {}, + const Rect2D * pPerViewRenderAreas_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , perViewRenderAreaCount{ perViewRenderAreaCount_ } + , pPerViewRenderAreas{ pPerViewRenderAreas_ } + { + } + + VULKAN_HPP_CONSTEXPR + MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( ArrayProxyNoTemporaries const & perViewRenderAreas_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), perViewRenderAreaCount( static_cast( perViewRenderAreas_.size() ) ), pPerViewRenderAreas( perViewRenderAreas_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & + operator=( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & operator=( VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & setPerViewRenderAreaCount( uint32_t perViewRenderAreaCount_ ) & + VULKAN_HPP_NOEXCEPT + { + perViewRenderAreaCount = perViewRenderAreaCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM && setPerViewRenderAreaCount( uint32_t perViewRenderAreaCount_ ) && + VULKAN_HPP_NOEXCEPT + { + perViewRenderAreaCount = perViewRenderAreaCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & setPPerViewRenderAreas( const Rect2D * pPerViewRenderAreas_ ) & + VULKAN_HPP_NOEXCEPT + { + pPerViewRenderAreas = pPerViewRenderAreas_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM && setPPerViewRenderAreas( const Rect2D * pPerViewRenderAreas_ ) && + VULKAN_HPP_NOEXCEPT + { + pPerViewRenderAreas = pPerViewRenderAreas_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & + setPerViewRenderAreas( ArrayProxyNoTemporaries const & perViewRenderAreas_ ) VULKAN_HPP_NOEXCEPT + { + perViewRenderAreaCount = static_cast( perViewRenderAreas_.size() ); + pPerViewRenderAreas = perViewRenderAreas_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, perViewRenderAreaCount, pPerViewRenderAreas ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & ) const = default; +#else + bool operator==( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewRenderAreaCount == rhs.perViewRenderAreaCount ) && + ( pPerViewRenderAreas == rhs.pPerViewRenderAreas ); +# endif + } + + bool operator!=( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + const void * pNext = {}; + uint32_t perViewRenderAreaCount = {}; + const Rect2D * pPerViewRenderAreas = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; + }; + + // wrapper struct for struct VkMutableDescriptorTypeListEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMutableDescriptorTypeListEXT.html + struct MutableDescriptorTypeListEXT + { + using NativeType = VkMutableDescriptorTypeListEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MutableDescriptorTypeListEXT( uint32_t descriptorTypeCount_ = {}, const DescriptorType * pDescriptorTypes_ = {} ) VULKAN_HPP_NOEXCEPT + : descriptorTypeCount{ descriptorTypeCount_ } + , pDescriptorTypes{ pDescriptorTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR MutableDescriptorTypeListEXT( MutableDescriptorTypeListEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MutableDescriptorTypeListEXT( VkMutableDescriptorTypeListEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MutableDescriptorTypeListEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MutableDescriptorTypeListEXT( ArrayProxyNoTemporaries const & descriptorTypes_ ) + : descriptorTypeCount( static_cast( descriptorTypes_.size() ) ), pDescriptorTypes( descriptorTypes_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + MutableDescriptorTypeListEXT & operator=( MutableDescriptorTypeListEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MutableDescriptorTypeListEXT & operator=( VkMutableDescriptorTypeListEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeListEXT & setDescriptorTypeCount( uint32_t descriptorTypeCount_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorTypeCount = descriptorTypeCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeListEXT && setDescriptorTypeCount( uint32_t descriptorTypeCount_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorTypeCount = descriptorTypeCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeListEXT & setPDescriptorTypes( const DescriptorType * pDescriptorTypes_ ) & VULKAN_HPP_NOEXCEPT + { + pDescriptorTypes = pDescriptorTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeListEXT && setPDescriptorTypes( const DescriptorType * pDescriptorTypes_ ) && VULKAN_HPP_NOEXCEPT + { + pDescriptorTypes = pDescriptorTypes_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MutableDescriptorTypeListEXT & setDescriptorTypes( ArrayProxyNoTemporaries const & descriptorTypes_ ) VULKAN_HPP_NOEXCEPT + { + descriptorTypeCount = static_cast( descriptorTypes_.size() ); + pDescriptorTypes = descriptorTypes_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMutableDescriptorTypeListEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMutableDescriptorTypeListEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMutableDescriptorTypeListEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMutableDescriptorTypeListEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( descriptorTypeCount, pDescriptorTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MutableDescriptorTypeListEXT const & ) const = default; +#else + bool operator==( MutableDescriptorTypeListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( descriptorTypeCount == rhs.descriptorTypeCount ) && ( pDescriptorTypes == rhs.pDescriptorTypes ); +# endif + } + + bool operator!=( MutableDescriptorTypeListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t descriptorTypeCount = {}; + const DescriptorType * pDescriptorTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MutableDescriptorTypeListEXT; + }; +#endif + using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT; + + // wrapper struct for struct VkMutableDescriptorTypeCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMutableDescriptorTypeCreateInfoEXT.html + struct MutableDescriptorTypeCreateInfoEXT + { + using NativeType = VkMutableDescriptorTypeCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMutableDescriptorTypeCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoEXT( uint32_t mutableDescriptorTypeListCount_ = {}, + const MutableDescriptorTypeListEXT * pMutableDescriptorTypeLists_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , mutableDescriptorTypeListCount{ mutableDescriptorTypeListCount_ } + , pMutableDescriptorTypeLists{ pMutableDescriptorTypeLists_ } + { + } + + VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoEXT( MutableDescriptorTypeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + MutableDescriptorTypeCreateInfoEXT( VkMutableDescriptorTypeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : MutableDescriptorTypeCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MutableDescriptorTypeCreateInfoEXT( ArrayProxyNoTemporaries const & mutableDescriptorTypeLists_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , mutableDescriptorTypeListCount( static_cast( mutableDescriptorTypeLists_.size() ) ) + , pMutableDescriptorTypeLists( mutableDescriptorTypeLists_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + MutableDescriptorTypeCreateInfoEXT & operator=( MutableDescriptorTypeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + MutableDescriptorTypeCreateInfoEXT & operator=( VkMutableDescriptorTypeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT & setMutableDescriptorTypeListCount( uint32_t mutableDescriptorTypeListCount_ ) & + VULKAN_HPP_NOEXCEPT + { + mutableDescriptorTypeListCount = mutableDescriptorTypeListCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT && setMutableDescriptorTypeListCount( uint32_t mutableDescriptorTypeListCount_ ) && + VULKAN_HPP_NOEXCEPT + { + mutableDescriptorTypeListCount = mutableDescriptorTypeListCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT & + setPMutableDescriptorTypeLists( const MutableDescriptorTypeListEXT * pMutableDescriptorTypeLists_ ) & + VULKAN_HPP_NOEXCEPT + { + pMutableDescriptorTypeLists = pMutableDescriptorTypeLists_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT && + setPMutableDescriptorTypeLists( const MutableDescriptorTypeListEXT * pMutableDescriptorTypeLists_ ) && + VULKAN_HPP_NOEXCEPT + { + pMutableDescriptorTypeLists = pMutableDescriptorTypeLists_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + MutableDescriptorTypeCreateInfoEXT & + setMutableDescriptorTypeLists( ArrayProxyNoTemporaries const & mutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT + { + mutableDescriptorTypeListCount = static_cast( mutableDescriptorTypeLists_.size() ); + pMutableDescriptorTypeLists = mutableDescriptorTypeLists_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkMutableDescriptorTypeCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMutableDescriptorTypeCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkMutableDescriptorTypeCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkMutableDescriptorTypeCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mutableDescriptorTypeListCount, pMutableDescriptorTypeLists ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( MutableDescriptorTypeCreateInfoEXT const & ) const = default; +#else + bool operator==( MutableDescriptorTypeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) && + ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists ); +# endif + } + + bool operator!=( MutableDescriptorTypeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eMutableDescriptorTypeCreateInfoEXT; + const void * pNext = {}; + uint32_t mutableDescriptorTypeListCount = {}; + const MutableDescriptorTypeListEXT * pMutableDescriptorTypeLists = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = MutableDescriptorTypeCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = MutableDescriptorTypeCreateInfoEXT; + }; + + using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT; + +#if defined( VK_USE_PLATFORM_OHOS ) + // wrapper struct for struct VkNativeBufferFormatPropertiesOHOS, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkNativeBufferFormatPropertiesOHOS.html + struct NativeBufferFormatPropertiesOHOS + { + using NativeType = VkNativeBufferFormatPropertiesOHOS; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eNativeBufferFormatPropertiesOHOS; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR NativeBufferFormatPropertiesOHOS( Format format_ = Format::eUndefined, + uint64_t externalFormat_ = {}, + FormatFeatureFlags formatFeatures_ = {}, + ComponentMapping samplerYcbcrConversionComponents_ = {}, + SamplerYcbcrModelConversion suggestedYcbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, + SamplerYcbcrRange suggestedYcbcrRange_ = SamplerYcbcrRange::eItuFull, + ChromaLocation suggestedXChromaOffset_ = ChromaLocation::eCositedEven, + ChromaLocation suggestedYChromaOffset_ = ChromaLocation::eCositedEven, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , format{ format_ } + , externalFormat{ externalFormat_ } + , formatFeatures{ formatFeatures_ } + , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ } + , suggestedYcbcrModel{ suggestedYcbcrModel_ } + , suggestedYcbcrRange{ suggestedYcbcrRange_ } + , suggestedXChromaOffset{ suggestedXChromaOffset_ } + , suggestedYChromaOffset{ suggestedYChromaOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR NativeBufferFormatPropertiesOHOS( NativeBufferFormatPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + NativeBufferFormatPropertiesOHOS( VkNativeBufferFormatPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + : NativeBufferFormatPropertiesOHOS( *reinterpret_cast( &rhs ) ) + { + } + + NativeBufferFormatPropertiesOHOS & operator=( NativeBufferFormatPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + NativeBufferFormatPropertiesOHOS & operator=( VkNativeBufferFormatPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkNativeBufferFormatPropertiesOHOS const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkNativeBufferFormatPropertiesOHOS &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkNativeBufferFormatPropertiesOHOS const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkNativeBufferFormatPropertiesOHOS *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + format, + externalFormat, + formatFeatures, + samplerYcbcrConversionComponents, + suggestedYcbcrModel, + suggestedYcbcrRange, + suggestedXChromaOffset, + suggestedYChromaOffset ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( NativeBufferFormatPropertiesOHOS const & ) const = default; +# else + bool operator==( NativeBufferFormatPropertiesOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) && + ( formatFeatures == rhs.formatFeatures ) && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && + ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && + ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); +# endif + } + + bool operator!=( NativeBufferFormatPropertiesOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eNativeBufferFormatPropertiesOHOS; + void * pNext = {}; + Format format = Format::eUndefined; + uint64_t externalFormat = {}; + FormatFeatureFlags formatFeatures = {}; + ComponentMapping samplerYcbcrConversionComponents = {}; + SamplerYcbcrModelConversion suggestedYcbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; + SamplerYcbcrRange suggestedYcbcrRange = SamplerYcbcrRange::eItuFull; + ChromaLocation suggestedXChromaOffset = ChromaLocation::eCositedEven; + ChromaLocation suggestedYChromaOffset = ChromaLocation::eCositedEven; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = NativeBufferFormatPropertiesOHOS; + }; +# endif + + template <> + struct CppType + { + using Type = NativeBufferFormatPropertiesOHOS; + }; +#endif /*VK_USE_PLATFORM_OHOS*/ + +#if defined( VK_USE_PLATFORM_OHOS ) + // wrapper struct for struct VkNativeBufferPropertiesOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkNativeBufferPropertiesOHOS.html + struct NativeBufferPropertiesOHOS + { + using NativeType = VkNativeBufferPropertiesOHOS; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eNativeBufferPropertiesOHOS; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + NativeBufferPropertiesOHOS( DeviceSize allocationSize_ = {}, uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , allocationSize{ allocationSize_ } + , memoryTypeBits{ memoryTypeBits_ } + { + } + + VULKAN_HPP_CONSTEXPR NativeBufferPropertiesOHOS( NativeBufferPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + NativeBufferPropertiesOHOS( VkNativeBufferPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + : NativeBufferPropertiesOHOS( *reinterpret_cast( &rhs ) ) + { + } + + NativeBufferPropertiesOHOS & operator=( NativeBufferPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + NativeBufferPropertiesOHOS & operator=( VkNativeBufferPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkNativeBufferPropertiesOHOS const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkNativeBufferPropertiesOHOS &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkNativeBufferPropertiesOHOS const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkNativeBufferPropertiesOHOS *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allocationSize, memoryTypeBits ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( NativeBufferPropertiesOHOS const & ) const = default; +# else + bool operator==( NativeBufferPropertiesOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif + } + + bool operator!=( NativeBufferPropertiesOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eNativeBufferPropertiesOHOS; + void * pNext = {}; + DeviceSize allocationSize = {}; + uint32_t memoryTypeBits = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = NativeBufferPropertiesOHOS; + }; +# endif + + template <> + struct CppType + { + using Type = NativeBufferPropertiesOHOS; + }; +#endif /*VK_USE_PLATFORM_OHOS*/ + +#if defined( VK_USE_PLATFORM_OHOS ) + // wrapper struct for struct VkNativeBufferUsageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkNativeBufferUsageOHOS.html + struct NativeBufferUsageOHOS + { + using NativeType = VkNativeBufferUsageOHOS; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eNativeBufferUsageOHOS; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR NativeBufferUsageOHOS( uint64_t OHOSNativeBufferUsage_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , OHOSNativeBufferUsage{ OHOSNativeBufferUsage_ } + { + } + + VULKAN_HPP_CONSTEXPR NativeBufferUsageOHOS( NativeBufferUsageOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + NativeBufferUsageOHOS( VkNativeBufferUsageOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + : NativeBufferUsageOHOS( *reinterpret_cast( &rhs ) ) + { + } + + NativeBufferUsageOHOS & operator=( NativeBufferUsageOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + NativeBufferUsageOHOS & operator=( VkNativeBufferUsageOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkNativeBufferUsageOHOS const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkNativeBufferUsageOHOS &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkNativeBufferUsageOHOS const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkNativeBufferUsageOHOS *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, OHOSNativeBufferUsage ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( NativeBufferUsageOHOS const & ) const = default; +# else + bool operator==( NativeBufferUsageOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( OHOSNativeBufferUsage == rhs.OHOSNativeBufferUsage ); +# endif + } + + bool operator!=( NativeBufferUsageOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eNativeBufferUsageOHOS; + void * pNext = {}; + uint64_t OHOSNativeBufferUsage = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = NativeBufferUsageOHOS; + }; +# endif + + template <> + struct CppType + { + using Type = NativeBufferUsageOHOS; + }; +#endif /*VK_USE_PLATFORM_OHOS*/ + + // wrapper struct for struct VkOpaqueCaptureDataCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpaqueCaptureDataCreateInfoEXT.html + struct OpaqueCaptureDataCreateInfoEXT + { + using NativeType = VkOpaqueCaptureDataCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpaqueCaptureDataCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR OpaqueCaptureDataCreateInfoEXT( const HostAddressRangeConstEXT * pData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pData{ pData_ } + { + } + + VULKAN_HPP_CONSTEXPR OpaqueCaptureDataCreateInfoEXT( OpaqueCaptureDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + OpaqueCaptureDataCreateInfoEXT( VkOpaqueCaptureDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : OpaqueCaptureDataCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + OpaqueCaptureDataCreateInfoEXT & operator=( OpaqueCaptureDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + OpaqueCaptureDataCreateInfoEXT & operator=( VkOpaqueCaptureDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDataCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDataCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDataCreateInfoEXT & setPData( const HostAddressRangeConstEXT * pData_ ) & VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDataCreateInfoEXT && setPData( const HostAddressRangeConstEXT * pData_ ) && VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkOpaqueCaptureDataCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpaqueCaptureDataCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpaqueCaptureDataCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkOpaqueCaptureDataCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( OpaqueCaptureDataCreateInfoEXT const & ) const = default; +#else + bool operator==( OpaqueCaptureDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pData == rhs.pData ); +# endif + } + + bool operator!=( OpaqueCaptureDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eOpaqueCaptureDataCreateInfoEXT; + const void * pNext = {}; + const HostAddressRangeConstEXT * pData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = OpaqueCaptureDataCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = OpaqueCaptureDataCreateInfoEXT; + }; + + // wrapper struct for struct VkOpaqueCaptureDescriptorDataCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpaqueCaptureDescriptorDataCreateInfoEXT.html + struct OpaqueCaptureDescriptorDataCreateInfoEXT + { + using NativeType = VkOpaqueCaptureDescriptorDataCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpaqueCaptureDescriptorDataCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR OpaqueCaptureDescriptorDataCreateInfoEXT( const void * opaqueCaptureDescriptorData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , opaqueCaptureDescriptorData{ opaqueCaptureDescriptorData_ } + { + } + + VULKAN_HPP_CONSTEXPR OpaqueCaptureDescriptorDataCreateInfoEXT( OpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + OpaqueCaptureDescriptorDataCreateInfoEXT( VkOpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : OpaqueCaptureDescriptorDataCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + OpaqueCaptureDescriptorDataCreateInfoEXT & operator=( OpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + OpaqueCaptureDescriptorDataCreateInfoEXT & operator=( VkOpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDescriptorDataCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDescriptorDataCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDescriptorDataCreateInfoEXT & setOpaqueCaptureDescriptorData( const void * opaqueCaptureDescriptorData_ ) & + VULKAN_HPP_NOEXCEPT + { + opaqueCaptureDescriptorData = opaqueCaptureDescriptorData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDescriptorDataCreateInfoEXT && setOpaqueCaptureDescriptorData( const void * opaqueCaptureDescriptorData_ ) && + VULKAN_HPP_NOEXCEPT + { + opaqueCaptureDescriptorData = opaqueCaptureDescriptorData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkOpaqueCaptureDescriptorDataCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpaqueCaptureDescriptorDataCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpaqueCaptureDescriptorDataCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkOpaqueCaptureDescriptorDataCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, opaqueCaptureDescriptorData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( OpaqueCaptureDescriptorDataCreateInfoEXT const & ) const = default; +#else + bool operator==( OpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureDescriptorData == rhs.opaqueCaptureDescriptorData ); +# endif + } + + bool operator!=( OpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eOpaqueCaptureDescriptorDataCreateInfoEXT; + const void * pNext = {}; + const void * opaqueCaptureDescriptorData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = OpaqueCaptureDescriptorDataCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = OpaqueCaptureDescriptorDataCreateInfoEXT; + }; + + // wrapper struct for struct VkOpticalFlowExecuteInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowExecuteInfoNV.html + struct OpticalFlowExecuteInfoNV + { + using NativeType = VkOpticalFlowExecuteInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpticalFlowExecuteInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR OpticalFlowExecuteInfoNV( OpticalFlowExecuteFlagsNV flags_ = {}, + uint32_t regionCount_ = {}, + const Rect2D * pRegions_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR OpticalFlowExecuteInfoNV( OpticalFlowExecuteInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + OpticalFlowExecuteInfoNV( VkOpticalFlowExecuteInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : OpticalFlowExecuteInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + OpticalFlowExecuteInfoNV( OpticalFlowExecuteFlagsNV flags_, ArrayProxyNoTemporaries const & regions_, void * pNext_ = nullptr ) + : pNext( pNext_ ), flags( flags_ ), regionCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + OpticalFlowExecuteInfoNV & operator=( OpticalFlowExecuteInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + OpticalFlowExecuteInfoNV & operator=( VkOpticalFlowExecuteInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV & setFlags( OpticalFlowExecuteFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV && setFlags( OpticalFlowExecuteFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV & setPRegions( const Rect2D * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV && setPRegions( const Rect2D * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + OpticalFlowExecuteInfoNV & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkOpticalFlowExecuteInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpticalFlowExecuteInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpticalFlowExecuteInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkOpticalFlowExecuteInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( OpticalFlowExecuteInfoNV const & ) const = default; +#else + bool operator==( OpticalFlowExecuteInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( OpticalFlowExecuteInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eOpticalFlowExecuteInfoNV; + void * pNext = {}; + OpticalFlowExecuteFlagsNV flags = {}; + uint32_t regionCount = {}; + const Rect2D * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = OpticalFlowExecuteInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = OpticalFlowExecuteInfoNV; + }; + + // wrapper struct for struct VkOpticalFlowImageFormatInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowImageFormatInfoNV.html + struct OpticalFlowImageFormatInfoNV + { + using NativeType = VkOpticalFlowImageFormatInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpticalFlowImageFormatInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR OpticalFlowImageFormatInfoNV( OpticalFlowUsageFlagsNV usage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , usage{ usage_ } + { + } + + VULKAN_HPP_CONSTEXPR OpticalFlowImageFormatInfoNV( OpticalFlowImageFormatInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + OpticalFlowImageFormatInfoNV( VkOpticalFlowImageFormatInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : OpticalFlowImageFormatInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + OpticalFlowImageFormatInfoNV & operator=( OpticalFlowImageFormatInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + OpticalFlowImageFormatInfoNV & operator=( VkOpticalFlowImageFormatInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 OpticalFlowImageFormatInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowImageFormatInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowImageFormatInfoNV & setUsage( OpticalFlowUsageFlagsNV usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowImageFormatInfoNV && setUsage( OpticalFlowUsageFlagsNV usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkOpticalFlowImageFormatInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpticalFlowImageFormatInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpticalFlowImageFormatInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkOpticalFlowImageFormatInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, usage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( OpticalFlowImageFormatInfoNV const & ) const = default; +#else + bool operator==( OpticalFlowImageFormatInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage ); +# endif + } + + bool operator!=( OpticalFlowImageFormatInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eOpticalFlowImageFormatInfoNV; + const void * pNext = {}; + OpticalFlowUsageFlagsNV usage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = OpticalFlowImageFormatInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = OpticalFlowImageFormatInfoNV; + }; + + // wrapper struct for struct VkOpticalFlowImageFormatPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowImageFormatPropertiesNV.html + struct OpticalFlowImageFormatPropertiesNV + { + using NativeType = VkOpticalFlowImageFormatPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpticalFlowImageFormatPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR OpticalFlowImageFormatPropertiesNV( Format format_ = Format::eUndefined, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , format{ format_ } + { + } + + VULKAN_HPP_CONSTEXPR OpticalFlowImageFormatPropertiesNV( OpticalFlowImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + OpticalFlowImageFormatPropertiesNV( VkOpticalFlowImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : OpticalFlowImageFormatPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + OpticalFlowImageFormatPropertiesNV & operator=( OpticalFlowImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + OpticalFlowImageFormatPropertiesNV & operator=( VkOpticalFlowImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkOpticalFlowImageFormatPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpticalFlowImageFormatPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpticalFlowImageFormatPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkOpticalFlowImageFormatPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( OpticalFlowImageFormatPropertiesNV const & ) const = default; +#else + bool operator==( OpticalFlowImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ); +# endif + } + + bool operator!=( OpticalFlowImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eOpticalFlowImageFormatPropertiesNV; + void * pNext = {}; + Format format = Format::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = OpticalFlowImageFormatPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = OpticalFlowImageFormatPropertiesNV; + }; + + // wrapper struct for struct VkOpticalFlowSessionCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreateInfoNV.html + struct OpticalFlowSessionCreateInfoNV + { + using NativeType = VkOpticalFlowSessionCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpticalFlowSessionCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR OpticalFlowSessionCreateInfoNV( uint32_t width_ = {}, + uint32_t height_ = {}, + Format imageFormat_ = Format::eUndefined, + Format flowVectorFormat_ = Format::eUndefined, + Format costFormat_ = Format::eUndefined, + OpticalFlowGridSizeFlagsNV outputGridSize_ = {}, + OpticalFlowGridSizeFlagsNV hintGridSize_ = {}, + OpticalFlowPerformanceLevelNV performanceLevel_ = OpticalFlowPerformanceLevelNV::eUnknown, + OpticalFlowSessionCreateFlagsNV flags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , width{ width_ } + , height{ height_ } + , imageFormat{ imageFormat_ } + , flowVectorFormat{ flowVectorFormat_ } + , costFormat{ costFormat_ } + , outputGridSize{ outputGridSize_ } + , hintGridSize{ hintGridSize_ } + , performanceLevel{ performanceLevel_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR OpticalFlowSessionCreateInfoNV( OpticalFlowSessionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + OpticalFlowSessionCreateInfoNV( VkOpticalFlowSessionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : OpticalFlowSessionCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + OpticalFlowSessionCreateInfoNV & operator=( OpticalFlowSessionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + OpticalFlowSessionCreateInfoNV & operator=( VkOpticalFlowSessionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT + { + width = width_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT + { + width = width_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT + { + height = height_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT + { + height = height_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setImageFormat( Format imageFormat_ ) & VULKAN_HPP_NOEXCEPT + { + imageFormat = imageFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setImageFormat( Format imageFormat_ ) && VULKAN_HPP_NOEXCEPT + { + imageFormat = imageFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setFlowVectorFormat( Format flowVectorFormat_ ) & VULKAN_HPP_NOEXCEPT + { + flowVectorFormat = flowVectorFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setFlowVectorFormat( Format flowVectorFormat_ ) && VULKAN_HPP_NOEXCEPT + { + flowVectorFormat = flowVectorFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setCostFormat( Format costFormat_ ) & VULKAN_HPP_NOEXCEPT + { + costFormat = costFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setCostFormat( Format costFormat_ ) && VULKAN_HPP_NOEXCEPT + { + costFormat = costFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setOutputGridSize( OpticalFlowGridSizeFlagsNV outputGridSize_ ) & VULKAN_HPP_NOEXCEPT + { + outputGridSize = outputGridSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setOutputGridSize( OpticalFlowGridSizeFlagsNV outputGridSize_ ) && VULKAN_HPP_NOEXCEPT + { + outputGridSize = outputGridSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setHintGridSize( OpticalFlowGridSizeFlagsNV hintGridSize_ ) & VULKAN_HPP_NOEXCEPT + { + hintGridSize = hintGridSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setHintGridSize( OpticalFlowGridSizeFlagsNV hintGridSize_ ) && VULKAN_HPP_NOEXCEPT + { + hintGridSize = hintGridSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setPerformanceLevel( OpticalFlowPerformanceLevelNV performanceLevel_ ) & VULKAN_HPP_NOEXCEPT + { + performanceLevel = performanceLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setPerformanceLevel( OpticalFlowPerformanceLevelNV performanceLevel_ ) && VULKAN_HPP_NOEXCEPT + { + performanceLevel = performanceLevel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setFlags( OpticalFlowSessionCreateFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setFlags( OpticalFlowSessionCreateFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkOpticalFlowSessionCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpticalFlowSessionCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpticalFlowSessionCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkOpticalFlowSessionCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, width, height, imageFormat, flowVectorFormat, costFormat, outputGridSize, hintGridSize, performanceLevel, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( OpticalFlowSessionCreateInfoNV const & ) const = default; +#else + bool operator==( OpticalFlowSessionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( width == rhs.width ) && ( height == rhs.height ) && ( imageFormat == rhs.imageFormat ) && + ( flowVectorFormat == rhs.flowVectorFormat ) && ( costFormat == rhs.costFormat ) && ( outputGridSize == rhs.outputGridSize ) && + ( hintGridSize == rhs.hintGridSize ) && ( performanceLevel == rhs.performanceLevel ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( OpticalFlowSessionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eOpticalFlowSessionCreateInfoNV; + void * pNext = {}; + uint32_t width = {}; + uint32_t height = {}; + Format imageFormat = Format::eUndefined; + Format flowVectorFormat = Format::eUndefined; + Format costFormat = Format::eUndefined; + OpticalFlowGridSizeFlagsNV outputGridSize = {}; + OpticalFlowGridSizeFlagsNV hintGridSize = {}; + OpticalFlowPerformanceLevelNV performanceLevel = OpticalFlowPerformanceLevelNV::eUnknown; + OpticalFlowSessionCreateFlagsNV flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = OpticalFlowSessionCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = OpticalFlowSessionCreateInfoNV; + }; + + // wrapper struct for struct VkOpticalFlowSessionCreatePrivateDataInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreatePrivateDataInfoNV.html + struct OpticalFlowSessionCreatePrivateDataInfoNV + { + using NativeType = VkOpticalFlowSessionCreatePrivateDataInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR OpticalFlowSessionCreatePrivateDataInfoNV( uint32_t id_ = {}, + uint32_t size_ = {}, + const void * pPrivateData_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , id{ id_ } + , size{ size_ } + , pPrivateData{ pPrivateData_ } + { + } + + VULKAN_HPP_CONSTEXPR OpticalFlowSessionCreatePrivateDataInfoNV( OpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + OpticalFlowSessionCreatePrivateDataInfoNV( VkOpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : OpticalFlowSessionCreatePrivateDataInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + OpticalFlowSessionCreatePrivateDataInfoNV & operator=( OpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + OpticalFlowSessionCreatePrivateDataInfoNV & operator=( VkOpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV & setId( uint32_t id_ ) & VULKAN_HPP_NOEXCEPT + { + id = id_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV && setId( uint32_t id_ ) && VULKAN_HPP_NOEXCEPT + { + id = id_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV & setPPrivateData( const void * pPrivateData_ ) & VULKAN_HPP_NOEXCEPT + { + pPrivateData = pPrivateData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV && setPPrivateData( const void * pPrivateData_ ) && VULKAN_HPP_NOEXCEPT + { + pPrivateData = pPrivateData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkOpticalFlowSessionCreatePrivateDataInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpticalFlowSessionCreatePrivateDataInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOpticalFlowSessionCreatePrivateDataInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkOpticalFlowSessionCreatePrivateDataInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, id, size, pPrivateData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( OpticalFlowSessionCreatePrivateDataInfoNV const & ) const = default; +#else + bool operator==( OpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( id == rhs.id ) && ( size == rhs.size ) && ( pPrivateData == rhs.pPrivateData ); +# endif + } + + bool operator!=( OpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV; + void * pNext = {}; + uint32_t id = {}; + uint32_t size = {}; + const void * pPrivateData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = OpticalFlowSessionCreatePrivateDataInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = OpticalFlowSessionCreatePrivateDataInfoNV; + }; + + // wrapper struct for struct VkOutOfBandQueueTypeInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOutOfBandQueueTypeInfoNV.html + struct OutOfBandQueueTypeInfoNV + { + using NativeType = VkOutOfBandQueueTypeInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOutOfBandQueueTypeInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR OutOfBandQueueTypeInfoNV( OutOfBandQueueTypeNV queueType_ = OutOfBandQueueTypeNV::eRender, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , queueType{ queueType_ } + { + } + + VULKAN_HPP_CONSTEXPR OutOfBandQueueTypeInfoNV( OutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + OutOfBandQueueTypeInfoNV( VkOutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : OutOfBandQueueTypeInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + OutOfBandQueueTypeInfoNV & operator=( OutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + OutOfBandQueueTypeInfoNV & operator=( VkOutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 OutOfBandQueueTypeInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OutOfBandQueueTypeInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 OutOfBandQueueTypeInfoNV & setQueueType( OutOfBandQueueTypeNV queueType_ ) & VULKAN_HPP_NOEXCEPT + { + queueType = queueType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 OutOfBandQueueTypeInfoNV && setQueueType( OutOfBandQueueTypeNV queueType_ ) && VULKAN_HPP_NOEXCEPT + { + queueType = queueType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkOutOfBandQueueTypeInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOutOfBandQueueTypeInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkOutOfBandQueueTypeInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkOutOfBandQueueTypeInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queueType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( OutOfBandQueueTypeInfoNV const & ) const = default; +#else + bool operator==( OutOfBandQueueTypeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueType == rhs.queueType ); +# endif + } + + bool operator!=( OutOfBandQueueTypeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eOutOfBandQueueTypeInfoNV; + const void * pNext = {}; + OutOfBandQueueTypeNV queueType = OutOfBandQueueTypeNV::eRender; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = OutOfBandQueueTypeInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = OutOfBandQueueTypeInfoNV; + }; + + // wrapper struct for struct VkPartitionedAccelerationStructureFlagsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureFlagsNV.html + struct PartitionedAccelerationStructureFlagsNV + { + using NativeType = VkPartitionedAccelerationStructureFlagsNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePartitionedAccelerationStructureFlagsNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PartitionedAccelerationStructureFlagsNV( Bool32 enablePartitionTranslation_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , enablePartitionTranslation{ enablePartitionTranslation_ } + { + } + + VULKAN_HPP_CONSTEXPR PartitionedAccelerationStructureFlagsNV( PartitionedAccelerationStructureFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PartitionedAccelerationStructureFlagsNV( VkPartitionedAccelerationStructureFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PartitionedAccelerationStructureFlagsNV( *reinterpret_cast( &rhs ) ) + { + } + + PartitionedAccelerationStructureFlagsNV & operator=( PartitionedAccelerationStructureFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PartitionedAccelerationStructureFlagsNV & operator=( VkPartitionedAccelerationStructureFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureFlagsNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureFlagsNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureFlagsNV & setEnablePartitionTranslation( Bool32 enablePartitionTranslation_ ) & VULKAN_HPP_NOEXCEPT + { + enablePartitionTranslation = enablePartitionTranslation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureFlagsNV && setEnablePartitionTranslation( Bool32 enablePartitionTranslation_ ) && + VULKAN_HPP_NOEXCEPT + { + enablePartitionTranslation = enablePartitionTranslation_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPartitionedAccelerationStructureFlagsNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureFlagsNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureFlagsNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureFlagsNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, enablePartitionTranslation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PartitionedAccelerationStructureFlagsNV const & ) const = default; +#else + bool operator==( PartitionedAccelerationStructureFlagsNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( enablePartitionTranslation == rhs.enablePartitionTranslation ); +# endif + } + + bool operator!=( PartitionedAccelerationStructureFlagsNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePartitionedAccelerationStructureFlagsNV; + void * pNext = {}; + Bool32 enablePartitionTranslation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PartitionedAccelerationStructureFlagsNV; + }; +#endif + + template <> + struct CppType + { + using Type = PartitionedAccelerationStructureFlagsNV; + }; + + // wrapper struct for struct VkPartitionedAccelerationStructureUpdateInstanceDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureUpdateInstanceDataNV.html + struct PartitionedAccelerationStructureUpdateInstanceDataNV + { + using NativeType = VkPartitionedAccelerationStructureUpdateInstanceDataNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PartitionedAccelerationStructureUpdateInstanceDataNV( uint32_t instanceIndex_ = {}, + uint32_t instanceContributionToHitGroupIndex_ = {}, + DeviceAddress accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT + : instanceIndex{ instanceIndex_ } + , instanceContributionToHitGroupIndex{ instanceContributionToHitGroupIndex_ } + , accelerationStructure{ accelerationStructure_ } + { + } + + VULKAN_HPP_CONSTEXPR + PartitionedAccelerationStructureUpdateInstanceDataNV( PartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PartitionedAccelerationStructureUpdateInstanceDataNV( VkPartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PartitionedAccelerationStructureUpdateInstanceDataNV( *reinterpret_cast( &rhs ) ) + { + } + + PartitionedAccelerationStructureUpdateInstanceDataNV & + operator=( PartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PartitionedAccelerationStructureUpdateInstanceDataNV & operator=( VkPartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV & setInstanceIndex( uint32_t instanceIndex_ ) & VULKAN_HPP_NOEXCEPT + { + instanceIndex = instanceIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV && setInstanceIndex( uint32_t instanceIndex_ ) && VULKAN_HPP_NOEXCEPT + { + instanceIndex = instanceIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV & + setInstanceContributionToHitGroupIndex( uint32_t instanceContributionToHitGroupIndex_ ) & + VULKAN_HPP_NOEXCEPT + { + instanceContributionToHitGroupIndex = instanceContributionToHitGroupIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV && + setInstanceContributionToHitGroupIndex( uint32_t instanceContributionToHitGroupIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + instanceContributionToHitGroupIndex = instanceContributionToHitGroupIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV & setAccelerationStructure( DeviceAddress accelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV && setAccelerationStructure( DeviceAddress accelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPartitionedAccelerationStructureUpdateInstanceDataNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureUpdateInstanceDataNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureUpdateInstanceDataNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureUpdateInstanceDataNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( instanceIndex, instanceContributionToHitGroupIndex, accelerationStructure ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PartitionedAccelerationStructureUpdateInstanceDataNV const & ) const = default; +#else + bool operator==( PartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( instanceIndex == rhs.instanceIndex ) && ( instanceContributionToHitGroupIndex == rhs.instanceContributionToHitGroupIndex ) && + ( accelerationStructure == rhs.accelerationStructure ); +# endif + } + + bool operator!=( PartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t instanceIndex = {}; + uint32_t instanceContributionToHitGroupIndex = {}; + DeviceAddress accelerationStructure = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PartitionedAccelerationStructureUpdateInstanceDataNV; + }; +#endif + + // wrapper struct for struct VkPartitionedAccelerationStructureWriteInstanceDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureWriteInstanceDataNV.html + struct PartitionedAccelerationStructureWriteInstanceDataNV + { + using NativeType = VkPartitionedAccelerationStructureWriteInstanceDataNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV( TransformMatrixKHR transform_ = {}, + std::array const & explicitAABB_ = {}, + uint32_t instanceID_ = {}, + uint32_t instanceMask_ = {}, + uint32_t instanceContributionToHitGroupIndex_ = {}, + PartitionedAccelerationStructureInstanceFlagsNV instanceFlags_ = {}, + uint32_t instanceIndex_ = {}, + uint32_t partitionIndex_ = {}, + DeviceAddress accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT + : transform{ transform_ } + , explicitAABB{ explicitAABB_ } + , instanceID{ instanceID_ } + , instanceMask{ instanceMask_ } + , instanceContributionToHitGroupIndex{ instanceContributionToHitGroupIndex_ } + , instanceFlags{ instanceFlags_ } + , instanceIndex{ instanceIndex_ } + , partitionIndex{ partitionIndex_ } + , accelerationStructure{ accelerationStructure_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + PartitionedAccelerationStructureWriteInstanceDataNV( PartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PartitionedAccelerationStructureWriteInstanceDataNV( VkPartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PartitionedAccelerationStructureWriteInstanceDataNV( *reinterpret_cast( &rhs ) ) + { + } + + PartitionedAccelerationStructureWriteInstanceDataNV & + operator=( PartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PartitionedAccelerationStructureWriteInstanceDataNV & operator=( VkPartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setTransform( TransformMatrixKHR const & transform_ ) & VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setTransform( TransformMatrixKHR const & transform_ ) && VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setExplicitAABB( std::array explicitAABB_ ) & VULKAN_HPP_NOEXCEPT + { + explicitAABB = explicitAABB_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setExplicitAABB( std::array explicitAABB_ ) && VULKAN_HPP_NOEXCEPT + { + explicitAABB = explicitAABB_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setInstanceID( uint32_t instanceID_ ) & VULKAN_HPP_NOEXCEPT + { + instanceID = instanceID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setInstanceID( uint32_t instanceID_ ) && VULKAN_HPP_NOEXCEPT + { + instanceID = instanceID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setInstanceMask( uint32_t instanceMask_ ) & VULKAN_HPP_NOEXCEPT + { + instanceMask = instanceMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setInstanceMask( uint32_t instanceMask_ ) && VULKAN_HPP_NOEXCEPT + { + instanceMask = instanceMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & + setInstanceContributionToHitGroupIndex( uint32_t instanceContributionToHitGroupIndex_ ) & + VULKAN_HPP_NOEXCEPT + { + instanceContributionToHitGroupIndex = instanceContributionToHitGroupIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && + setInstanceContributionToHitGroupIndex( uint32_t instanceContributionToHitGroupIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + instanceContributionToHitGroupIndex = instanceContributionToHitGroupIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & + setInstanceFlags( PartitionedAccelerationStructureInstanceFlagsNV instanceFlags_ ) & + VULKAN_HPP_NOEXCEPT + { + instanceFlags = instanceFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && + setInstanceFlags( PartitionedAccelerationStructureInstanceFlagsNV instanceFlags_ ) && + VULKAN_HPP_NOEXCEPT + { + instanceFlags = instanceFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setInstanceIndex( uint32_t instanceIndex_ ) & VULKAN_HPP_NOEXCEPT + { + instanceIndex = instanceIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setInstanceIndex( uint32_t instanceIndex_ ) && VULKAN_HPP_NOEXCEPT + { + instanceIndex = instanceIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setPartitionIndex( uint32_t partitionIndex_ ) & VULKAN_HPP_NOEXCEPT + { + partitionIndex = partitionIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setPartitionIndex( uint32_t partitionIndex_ ) && VULKAN_HPP_NOEXCEPT + { + partitionIndex = partitionIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setAccelerationStructure( DeviceAddress accelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setAccelerationStructure( DeviceAddress accelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPartitionedAccelerationStructureWriteInstanceDataNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureWriteInstanceDataNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureWriteInstanceDataNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureWriteInstanceDataNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + PartitionedAccelerationStructureInstanceFlagsNV const &, + uint32_t const &, + uint32_t const &, + DeviceAddress const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( transform, + explicitAABB, + instanceID, + instanceMask, + instanceContributionToHitGroupIndex, + instanceFlags, + instanceIndex, + partitionIndex, + accelerationStructure ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PartitionedAccelerationStructureWriteInstanceDataNV const & ) const = default; +#else + bool operator==( PartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( transform == rhs.transform ) && ( explicitAABB == rhs.explicitAABB ) && ( instanceID == rhs.instanceID ) && + ( instanceMask == rhs.instanceMask ) && ( instanceContributionToHitGroupIndex == rhs.instanceContributionToHitGroupIndex ) && + ( instanceFlags == rhs.instanceFlags ) && ( instanceIndex == rhs.instanceIndex ) && ( partitionIndex == rhs.partitionIndex ) && + ( accelerationStructure == rhs.accelerationStructure ); +# endif + } + + bool operator!=( PartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + TransformMatrixKHR transform = {}; + ArrayWrapper1D explicitAABB = {}; + uint32_t instanceID = {}; + uint32_t instanceMask = {}; + uint32_t instanceContributionToHitGroupIndex = {}; + PartitionedAccelerationStructureInstanceFlagsNV instanceFlags = {}; + uint32_t instanceIndex = {}; + uint32_t partitionIndex = {}; + DeviceAddress accelerationStructure = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PartitionedAccelerationStructureWriteInstanceDataNV; + }; +#endif + + // wrapper struct for struct VkPartitionedAccelerationStructureWritePartitionTranslationDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureWritePartitionTranslationDataNV.html + struct PartitionedAccelerationStructureWritePartitionTranslationDataNV + { + using NativeType = VkPartitionedAccelerationStructureWritePartitionTranslationDataNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + PartitionedAccelerationStructureWritePartitionTranslationDataNV( uint32_t partitionIndex_ = {}, + std::array const & partitionTranslation_ = {} ) VULKAN_HPP_NOEXCEPT + : partitionIndex{ partitionIndex_ } + , partitionTranslation{ partitionTranslation_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWritePartitionTranslationDataNV( + PartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PartitionedAccelerationStructureWritePartitionTranslationDataNV( VkPartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) + VULKAN_HPP_NOEXCEPT + : PartitionedAccelerationStructureWritePartitionTranslationDataNV( + *reinterpret_cast( &rhs ) ) + { + } + + PartitionedAccelerationStructureWritePartitionTranslationDataNV & + operator=( PartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PartitionedAccelerationStructureWritePartitionTranslationDataNV & + operator=( VkPartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWritePartitionTranslationDataNV & setPartitionIndex( uint32_t partitionIndex_ ) & + VULKAN_HPP_NOEXCEPT + { + partitionIndex = partitionIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWritePartitionTranslationDataNV && setPartitionIndex( uint32_t partitionIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + partitionIndex = partitionIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWritePartitionTranslationDataNV & + setPartitionTranslation( std::array partitionTranslation_ ) & + VULKAN_HPP_NOEXCEPT + { + partitionTranslation = partitionTranslation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWritePartitionTranslationDataNV && + setPartitionTranslation( std::array partitionTranslation_ ) && + VULKAN_HPP_NOEXCEPT + { + partitionTranslation = partitionTranslation_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPartitionedAccelerationStructureWritePartitionTranslationDataNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureWritePartitionTranslationDataNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureWritePartitionTranslationDataNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPartitionedAccelerationStructureWritePartitionTranslationDataNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( partitionIndex, partitionTranslation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PartitionedAccelerationStructureWritePartitionTranslationDataNV const & ) const = default; +#else + bool operator==( PartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( partitionIndex == rhs.partitionIndex ) && ( partitionTranslation == rhs.partitionTranslation ); +# endif + } + + bool operator!=( PartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t partitionIndex = {}; + ArrayWrapper1D partitionTranslation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PartitionedAccelerationStructureWritePartitionTranslationDataNV; + }; +#endif + + // wrapper struct for struct VkPresentStageTimeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentStageTimeEXT.html + struct PresentStageTimeEXT + { + using NativeType = VkPresentStageTimeEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentStageTimeEXT( PresentStageFlagsEXT stage_ = {}, uint64_t time_ = {} ) VULKAN_HPP_NOEXCEPT + : stage{ stage_ } + , time{ time_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentStageTimeEXT( PresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentStageTimeEXT( VkPresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT : PresentStageTimeEXT( *reinterpret_cast( &rhs ) ) + { + } + + PresentStageTimeEXT & operator=( PresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentStageTimeEXT & operator=( VkPresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPresentStageTimeEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentStageTimeEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentStageTimeEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentStageTimeEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( stage, time ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentStageTimeEXT const & ) const = default; +#else + bool operator==( PresentStageTimeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( stage == rhs.stage ) && ( time == rhs.time ); +# endif + } + + bool operator!=( PresentStageTimeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + PresentStageFlagsEXT stage = {}; + uint64_t time = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentStageTimeEXT; + }; +#endif + + // wrapper struct for struct VkPastPresentationTimingEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingEXT.html + struct PastPresentationTimingEXT + { + using NativeType = VkPastPresentationTimingEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePastPresentationTimingEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PastPresentationTimingEXT( uint64_t presentId_ = {}, + uint64_t targetTime_ = {}, + uint32_t presentStageCount_ = {}, + PresentStageTimeEXT * pPresentStages_ = {}, + TimeDomainKHR timeDomain_ = TimeDomainKHR::eDevice, + uint64_t timeDomainId_ = {}, + Bool32 reportComplete_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentId{ presentId_ } + , targetTime{ targetTime_ } + , presentStageCount{ presentStageCount_ } + , pPresentStages{ pPresentStages_ } + , timeDomain{ timeDomain_ } + , timeDomainId{ timeDomainId_ } + , reportComplete{ reportComplete_ } + { + } + + VULKAN_HPP_CONSTEXPR PastPresentationTimingEXT( PastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PastPresentationTimingEXT( VkPastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PastPresentationTimingEXT( *reinterpret_cast( &rhs ) ) + { + } + + PastPresentationTimingEXT & operator=( PastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PastPresentationTimingEXT & operator=( VkPastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPastPresentationTimingEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPastPresentationTimingEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentId, targetTime, presentStageCount, pPresentStages, timeDomain, timeDomainId, reportComplete ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PastPresentationTimingEXT const & ) const = default; +#else + bool operator==( PastPresentationTimingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId ) && ( targetTime == rhs.targetTime ) && + ( presentStageCount == rhs.presentStageCount ) && ( pPresentStages == rhs.pPresentStages ) && ( timeDomain == rhs.timeDomain ) && + ( timeDomainId == rhs.timeDomainId ) && ( reportComplete == rhs.reportComplete ); +# endif + } + + bool operator!=( PastPresentationTimingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePastPresentationTimingEXT; + void * pNext = {}; + uint64_t presentId = {}; + uint64_t targetTime = {}; + uint32_t presentStageCount = {}; + PresentStageTimeEXT * pPresentStages = {}; + TimeDomainKHR timeDomain = TimeDomainKHR::eDevice; + uint64_t timeDomainId = {}; + Bool32 reportComplete = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PastPresentationTimingEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PastPresentationTimingEXT; + }; + + // wrapper struct for struct VkPastPresentationTimingGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingGOOGLE.html + struct PastPresentationTimingGOOGLE + { + using NativeType = VkPastPresentationTimingGOOGLE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PastPresentationTimingGOOGLE( uint32_t presentID_ = {}, + uint64_t desiredPresentTime_ = {}, + uint64_t actualPresentTime_ = {}, + uint64_t earliestPresentTime_ = {}, + uint64_t presentMargin_ = {} ) VULKAN_HPP_NOEXCEPT + : presentID{ presentID_ } + , desiredPresentTime{ desiredPresentTime_ } + , actualPresentTime{ actualPresentTime_ } + , earliestPresentTime{ earliestPresentTime_ } + , presentMargin{ presentMargin_ } + { + } + + VULKAN_HPP_CONSTEXPR PastPresentationTimingGOOGLE( PastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT + : PastPresentationTimingGOOGLE( *reinterpret_cast( &rhs ) ) + { + } + + PastPresentationTimingGOOGLE & operator=( PastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PastPresentationTimingGOOGLE & operator=( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPastPresentationTimingGOOGLE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingGOOGLE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingGOOGLE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPastPresentationTimingGOOGLE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( presentID, desiredPresentTime, actualPresentTime, earliestPresentTime, presentMargin ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PastPresentationTimingGOOGLE const & ) const = default; +#else + bool operator==( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ) && ( actualPresentTime == rhs.actualPresentTime ) && + ( earliestPresentTime == rhs.earliestPresentTime ) && ( presentMargin == rhs.presentMargin ); +# endif + } + + bool operator!=( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t presentID = {}; + uint64_t desiredPresentTime = {}; + uint64_t actualPresentTime = {}; + uint64_t earliestPresentTime = {}; + uint64_t presentMargin = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PastPresentationTimingGOOGLE; + }; +#endif + + // wrapper struct for struct VkPastPresentationTimingInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingInfoEXT.html + struct PastPresentationTimingInfoEXT + { + using NativeType = VkPastPresentationTimingInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePastPresentationTimingInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PastPresentationTimingInfoEXT( PastPresentationTimingFlagsEXT flags_ = {}, + SwapchainKHR swapchain_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , swapchain{ swapchain_ } + { + } + + VULKAN_HPP_CONSTEXPR PastPresentationTimingInfoEXT( PastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PastPresentationTimingInfoEXT( VkPastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PastPresentationTimingInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PastPresentationTimingInfoEXT & operator=( PastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PastPresentationTimingInfoEXT & operator=( VkPastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT & setFlags( PastPresentationTimingFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT && setFlags( PastPresentationTimingFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPastPresentationTimingInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPastPresentationTimingInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, swapchain ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PastPresentationTimingInfoEXT const & ) const = default; +#else + bool operator==( PastPresentationTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( swapchain == rhs.swapchain ); +# endif + } + + bool operator!=( PastPresentationTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePastPresentationTimingInfoEXT; + const void * pNext = {}; + PastPresentationTimingFlagsEXT flags = {}; + SwapchainKHR swapchain = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PastPresentationTimingInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PastPresentationTimingInfoEXT; + }; + + // wrapper struct for struct VkPastPresentationTimingPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingPropertiesEXT.html + struct PastPresentationTimingPropertiesEXT + { + using NativeType = VkPastPresentationTimingPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePastPresentationTimingPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PastPresentationTimingPropertiesEXT( uint64_t timingPropertiesCounter_ = {}, + uint64_t timeDomainsCounter_ = {}, + uint32_t presentationTimingCount_ = {}, + PastPresentationTimingEXT * pPresentationTimings_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , timingPropertiesCounter{ timingPropertiesCounter_ } + , timeDomainsCounter{ timeDomainsCounter_ } + , presentationTimingCount{ presentationTimingCount_ } + , pPresentationTimings{ pPresentationTimings_ } + { + } + + VULKAN_HPP_CONSTEXPR PastPresentationTimingPropertiesEXT( PastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PastPresentationTimingPropertiesEXT( VkPastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PastPresentationTimingPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PastPresentationTimingPropertiesEXT & operator=( PastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PastPresentationTimingPropertiesEXT & operator=( VkPastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPastPresentationTimingPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPastPresentationTimingPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPastPresentationTimingPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, timingPropertiesCounter, timeDomainsCounter, presentationTimingCount, pPresentationTimings ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PastPresentationTimingPropertiesEXT const & ) const = default; +#else + bool operator==( PastPresentationTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timingPropertiesCounter == rhs.timingPropertiesCounter ) && + ( timeDomainsCounter == rhs.timeDomainsCounter ) && ( presentationTimingCount == rhs.presentationTimingCount ) && + ( pPresentationTimings == rhs.pPresentationTimings ); +# endif + } + + bool operator!=( PastPresentationTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePastPresentationTimingPropertiesEXT; + void * pNext = {}; + uint64_t timingPropertiesCounter = {}; + uint64_t timeDomainsCounter = {}; + uint32_t presentationTimingCount = {}; + PastPresentationTimingEXT * pPresentationTimings = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PastPresentationTimingPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PastPresentationTimingPropertiesEXT; + }; + + // wrapper struct for struct VkPerTileBeginInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerTileBeginInfoQCOM.html + struct PerTileBeginInfoQCOM + { + using NativeType = VkPerTileBeginInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerTileBeginInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PerTileBeginInfoQCOM( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} + + VULKAN_HPP_CONSTEXPR PerTileBeginInfoQCOM( PerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerTileBeginInfoQCOM( VkPerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PerTileBeginInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PerTileBeginInfoQCOM & operator=( PerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerTileBeginInfoQCOM & operator=( VkPerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PerTileBeginInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerTileBeginInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPerTileBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerTileBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerTileBeginInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerTileBeginInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PerTileBeginInfoQCOM const & ) const = default; +#else + bool operator==( PerTileBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( PerTileBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePerTileBeginInfoQCOM; + const void * pNext = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerTileBeginInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PerTileBeginInfoQCOM; + }; + + // wrapper struct for struct VkPerTileEndInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerTileEndInfoQCOM.html + struct PerTileEndInfoQCOM + { + using NativeType = VkPerTileEndInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerTileEndInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PerTileEndInfoQCOM( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} + + VULKAN_HPP_CONSTEXPR PerTileEndInfoQCOM( PerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerTileEndInfoQCOM( VkPerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT : PerTileEndInfoQCOM( *reinterpret_cast( &rhs ) ) {} + + PerTileEndInfoQCOM & operator=( PerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerTileEndInfoQCOM & operator=( VkPerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PerTileEndInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerTileEndInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPerTileEndInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerTileEndInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerTileEndInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerTileEndInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PerTileEndInfoQCOM const & ) const = default; +#else + bool operator==( PerTileEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( PerTileEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePerTileEndInfoQCOM; + const void * pNext = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerTileEndInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PerTileEndInfoQCOM; + }; + + // wrapper struct for struct VkPerformanceConfigurationAcquireInfoINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html + struct PerformanceConfigurationAcquireInfoINTEL + { + using NativeType = VkPerformanceConfigurationAcquireInfoINTEL; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceConfigurationAcquireInfoINTEL; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( + PerformanceConfigurationTypeINTEL type_ = PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + { + } + + VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( PerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + : PerformanceConfigurationAcquireInfoINTEL( *reinterpret_cast( &rhs ) ) + { + } + + PerformanceConfigurationAcquireInfoINTEL & operator=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerformanceConfigurationAcquireInfoINTEL & operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PerformanceConfigurationAcquireInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceConfigurationAcquireInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceConfigurationAcquireInfoINTEL & setType( PerformanceConfigurationTypeINTEL type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceConfigurationAcquireInfoINTEL && setType( PerformanceConfigurationTypeINTEL type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPerformanceConfigurationAcquireInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceConfigurationAcquireInfoINTEL &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceConfigurationAcquireInfoINTEL const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerformanceConfigurationAcquireInfoINTEL *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PerformanceConfigurationAcquireInfoINTEL const & ) const = default; +#else + bool operator==( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ); +# endif + } + + bool operator!=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL; + const void * pNext = {}; + PerformanceConfigurationTypeINTEL type = PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceConfigurationAcquireInfoINTEL; + }; +#endif + + template <> + struct CppType + { + using Type = PerformanceConfigurationAcquireInfoINTEL; + }; + + // wrapper struct for struct VkPerformanceCounterARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterARM.html + struct PerformanceCounterARM + { + using NativeType = VkPerformanceCounterARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PerformanceCounterARM( uint32_t counterID_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , counterID{ counterID_ } + { + } + + VULKAN_HPP_CONSTEXPR PerformanceCounterARM( PerformanceCounterARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerformanceCounterARM( VkPerformanceCounterARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PerformanceCounterARM( *reinterpret_cast( &rhs ) ) + { + } + + PerformanceCounterARM & operator=( PerformanceCounterARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerformanceCounterARM & operator=( VkPerformanceCounterARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPerformanceCounterARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceCounterARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceCounterARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerformanceCounterARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, counterID ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PerformanceCounterARM const & ) const = default; +#else + bool operator==( PerformanceCounterARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterID == rhs.counterID ); +# endif + } + + bool operator!=( PerformanceCounterARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePerformanceCounterARM; + void * pNext = {}; + uint32_t counterID = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceCounterARM; + }; +#endif + + template <> + struct CppType + { + using Type = PerformanceCounterARM; + }; + + // wrapper struct for struct VkPerformanceCounterDescriptionARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionARM.html + struct PerformanceCounterDescriptionARM + { + using NativeType = VkPerformanceCounterDescriptionARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterDescriptionARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionARM( PerformanceCounterDescriptionFlagsARM flags_ = {}, + std::array const & name_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , name{ name_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionARM( PerformanceCounterDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerformanceCounterDescriptionARM( VkPerformanceCounterDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PerformanceCounterDescriptionARM( *reinterpret_cast( &rhs ) ) + { + } + + PerformanceCounterDescriptionARM & operator=( PerformanceCounterDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerformanceCounterDescriptionARM & operator=( VkPerformanceCounterDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPerformanceCounterDescriptionARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceCounterDescriptionARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceCounterDescriptionARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerformanceCounterDescriptionARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, name ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PerformanceCounterDescriptionARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( PerformanceCounterDescriptionARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( strcmp( name, rhs.name ) == 0 ); + } + + bool operator!=( PerformanceCounterDescriptionARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::ePerformanceCounterDescriptionARM; + void * pNext = {}; + PerformanceCounterDescriptionFlagsARM flags = {}; + ArrayWrapper1D name = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceCounterDescriptionARM; + }; +#endif + + template <> + struct CppType + { + using Type = PerformanceCounterDescriptionARM; + }; + + // wrapper struct for struct VkPerformanceCounterDescriptionKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionKHR.html + struct PerformanceCounterDescriptionKHR + { + using NativeType = VkPerformanceCounterDescriptionKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterDescriptionKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionKHR( PerformanceCounterDescriptionFlagsKHR flags_ = {}, + std::array const & name_ = {}, + std::array const & category_ = {}, + std::array const & description_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , name{ name_ } + , category{ category_ } + , description{ description_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionKHR( PerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerformanceCounterDescriptionKHR( VkPerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PerformanceCounterDescriptionKHR( *reinterpret_cast( &rhs ) ) + { + } + + PerformanceCounterDescriptionKHR & operator=( PerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerformanceCounterDescriptionKHR & operator=( VkPerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPerformanceCounterDescriptionKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceCounterDescriptionKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceCounterDescriptionKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerformanceCounterDescriptionKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &, + ArrayWrapper1D const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, name, category, description ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( category, rhs.category ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( strcmp( name, rhs.name ) == 0 ) && + ( strcmp( category, rhs.category ) == 0 ) && ( strcmp( description, rhs.description ) == 0 ); + } + + bool operator!=( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::ePerformanceCounterDescriptionKHR; + void * pNext = {}; + PerformanceCounterDescriptionFlagsKHR flags = {}; + ArrayWrapper1D name = {}; + ArrayWrapper1D category = {}; + ArrayWrapper1D description = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceCounterDescriptionKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PerformanceCounterDescriptionKHR; + }; + + // wrapper struct for struct VkPerformanceCounterKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterKHR.html + struct PerformanceCounterKHR + { + using NativeType = VkPerformanceCounterKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterKHR( PerformanceCounterUnitKHR unit_ = PerformanceCounterUnitKHR::eGeneric, + PerformanceCounterScopeKHR scope_ = PerformanceCounterScopeKHR::eCommandBuffer, + PerformanceCounterStorageKHR storage_ = PerformanceCounterStorageKHR::eInt32, + std::array const & uuid_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , unit{ unit_ } + , scope{ scope_ } + , storage{ storage_ } + , uuid{ uuid_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterKHR( PerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerformanceCounterKHR( VkPerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PerformanceCounterKHR( *reinterpret_cast( &rhs ) ) + { + } + + PerformanceCounterKHR & operator=( PerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerformanceCounterKHR & operator=( VkPerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPerformanceCounterKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceCounterKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceCounterKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerformanceCounterKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, unit, scope, storage, uuid ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PerformanceCounterKHR const & ) const = default; +#else + bool operator==( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( unit == rhs.unit ) && ( scope == rhs.scope ) && ( storage == rhs.storage ) && + ( uuid == rhs.uuid ); +# endif + } + + bool operator!=( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePerformanceCounterKHR; + void * pNext = {}; + PerformanceCounterUnitKHR unit = PerformanceCounterUnitKHR::eGeneric; + PerformanceCounterScopeKHR scope = PerformanceCounterScopeKHR::eCommandBuffer; + PerformanceCounterStorageKHR storage = PerformanceCounterStorageKHR::eInt32; + ArrayWrapper1D uuid = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceCounterKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PerformanceCounterKHR; + }; + + union PerformanceCounterResultKHR + { + using NativeType = VkPerformanceCounterResultKHR; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( int32_t int32_ = {} ) : int32( int32_ ) {} + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( int64_t int64_ ) : int64( int64_ ) {} + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( uint32_t uint32_ ) : uint32( uint32_ ) {} + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( uint64_t uint64_ ) : uint64( uint64_ ) {} + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( float float32_ ) : float32( float32_ ) {} + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( double float64_ ) : float64( float64_ ) {} +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setInt32( int32_t int32_ ) & VULKAN_HPP_NOEXCEPT + { + int32 = int32_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setInt32( int32_t int32_ ) && VULKAN_HPP_NOEXCEPT + { + int32 = int32_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setInt64( int64_t int64_ ) & VULKAN_HPP_NOEXCEPT + { + int64 = int64_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setInt64( int64_t int64_ ) && VULKAN_HPP_NOEXCEPT + { + int64 = int64_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setUint32( uint32_t uint32_ ) & VULKAN_HPP_NOEXCEPT + { + uint32 = uint32_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setUint32( uint32_t uint32_ ) && VULKAN_HPP_NOEXCEPT + { + uint32 = uint32_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setUint64( uint64_t uint64_ ) & VULKAN_HPP_NOEXCEPT + { + uint64 = uint64_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setUint64( uint64_t uint64_ ) && VULKAN_HPP_NOEXCEPT + { + uint64 = uint64_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setFloat32( float float32_ ) & VULKAN_HPP_NOEXCEPT + { + float32 = float32_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setFloat32( float float32_ ) && VULKAN_HPP_NOEXCEPT + { + float32 = float32_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setFloat64( double float64_ ) & VULKAN_HPP_NOEXCEPT + { + float64 = float64_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setFloat64( double float64_ ) && VULKAN_HPP_NOEXCEPT + { + float64 = float64_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPerformanceCounterResultKHR const &() const + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceCounterResultKHR &() + { + return *reinterpret_cast( this ); + } + + int32_t int32; + int64_t int64; + uint32_t uint32; + uint64_t uint64; + float float32; + double float64; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceCounterResultKHR; + }; +#endif + + // wrapper struct for struct VkPerformanceMarkerInfoINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceMarkerInfoINTEL.html + struct PerformanceMarkerInfoINTEL + { + using NativeType = VkPerformanceMarkerInfoINTEL; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceMarkerInfoINTEL; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , marker{ marker_ } + { + } + + VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + : PerformanceMarkerInfoINTEL( *reinterpret_cast( &rhs ) ) + { + } + + PerformanceMarkerInfoINTEL & operator=( PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerformanceMarkerInfoINTEL & operator=( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PerformanceMarkerInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceMarkerInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceMarkerInfoINTEL & setMarker( uint64_t marker_ ) & VULKAN_HPP_NOEXCEPT + { + marker = marker_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceMarkerInfoINTEL && setMarker( uint64_t marker_ ) && VULKAN_HPP_NOEXCEPT + { + marker = marker_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPerformanceMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceMarkerInfoINTEL const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerformanceMarkerInfoINTEL *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, marker ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PerformanceMarkerInfoINTEL const & ) const = default; +#else + bool operator==( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker ); +# endif + } + + bool operator!=( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePerformanceMarkerInfoINTEL; + const void * pNext = {}; + uint64_t marker = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceMarkerInfoINTEL; + }; +#endif + + template <> + struct CppType + { + using Type = PerformanceMarkerInfoINTEL; + }; + + // wrapper struct for struct VkPerformanceOverrideInfoINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceOverrideInfoINTEL.html + struct PerformanceOverrideInfoINTEL + { + using NativeType = VkPerformanceOverrideInfoINTEL; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceOverrideInfoINTEL; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( PerformanceOverrideTypeINTEL type_ = PerformanceOverrideTypeINTEL::eNullHardware, + Bool32 enable_ = {}, + uint64_t parameter_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , enable{ enable_ } + , parameter{ parameter_ } + { + } + + VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( PerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + : PerformanceOverrideInfoINTEL( *reinterpret_cast( &rhs ) ) + { + } + + PerformanceOverrideInfoINTEL & operator=( PerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerformanceOverrideInfoINTEL & operator=( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL & setType( PerformanceOverrideTypeINTEL type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL && setType( PerformanceOverrideTypeINTEL type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL & setEnable( Bool32 enable_ ) & VULKAN_HPP_NOEXCEPT + { + enable = enable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL && setEnable( Bool32 enable_ ) && VULKAN_HPP_NOEXCEPT + { + enable = enable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL & setParameter( uint64_t parameter_ ) & VULKAN_HPP_NOEXCEPT + { + parameter = parameter_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL && setParameter( uint64_t parameter_ ) && VULKAN_HPP_NOEXCEPT + { + parameter = parameter_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPerformanceOverrideInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceOverrideInfoINTEL &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceOverrideInfoINTEL const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerformanceOverrideInfoINTEL *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, enable, parameter ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PerformanceOverrideInfoINTEL const & ) const = default; +#else + bool operator==( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( enable == rhs.enable ) && ( parameter == rhs.parameter ); +# endif + } + + bool operator!=( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePerformanceOverrideInfoINTEL; + const void * pNext = {}; + PerformanceOverrideTypeINTEL type = PerformanceOverrideTypeINTEL::eNullHardware; + Bool32 enable = {}; + uint64_t parameter = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceOverrideInfoINTEL; + }; +#endif + + template <> + struct CppType + { + using Type = PerformanceOverrideInfoINTEL; + }; + + // wrapper struct for struct VkPerformanceQuerySubmitInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceQuerySubmitInfoKHR.html + struct PerformanceQuerySubmitInfoKHR + { + using NativeType = VkPerformanceQuerySubmitInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceQuerySubmitInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PerformanceQuerySubmitInfoKHR( uint32_t counterPassIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , counterPassIndex{ counterPassIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR PerformanceQuerySubmitInfoKHR( PerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerformanceQuerySubmitInfoKHR( VkPerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PerformanceQuerySubmitInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + PerformanceQuerySubmitInfoKHR & operator=( PerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerformanceQuerySubmitInfoKHR & operator=( VkPerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PerformanceQuerySubmitInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceQuerySubmitInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceQuerySubmitInfoKHR & setCounterPassIndex( uint32_t counterPassIndex_ ) & VULKAN_HPP_NOEXCEPT + { + counterPassIndex = counterPassIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceQuerySubmitInfoKHR && setCounterPassIndex( uint32_t counterPassIndex_ ) && VULKAN_HPP_NOEXCEPT + { + counterPassIndex = counterPassIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPerformanceQuerySubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceQuerySubmitInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceQuerySubmitInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerformanceQuerySubmitInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, counterPassIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PerformanceQuerySubmitInfoKHR const & ) const = default; +#else + bool operator==( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterPassIndex == rhs.counterPassIndex ); +# endif + } + + bool operator!=( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePerformanceQuerySubmitInfoKHR; + const void * pNext = {}; + uint32_t counterPassIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceQuerySubmitInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PerformanceQuerySubmitInfoKHR; + }; + + // wrapper struct for struct VkPerformanceStreamMarkerInfoINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceStreamMarkerInfoINTEL.html + struct PerformanceStreamMarkerInfoINTEL + { + using NativeType = VkPerformanceStreamMarkerInfoINTEL; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceStreamMarkerInfoINTEL; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , marker{ marker_ } + { + } + + VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( PerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + : PerformanceStreamMarkerInfoINTEL( *reinterpret_cast( &rhs ) ) + { + } + + PerformanceStreamMarkerInfoINTEL & operator=( PerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerformanceStreamMarkerInfoINTEL & operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PerformanceStreamMarkerInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceStreamMarkerInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceStreamMarkerInfoINTEL & setMarker( uint32_t marker_ ) & VULKAN_HPP_NOEXCEPT + { + marker = marker_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceStreamMarkerInfoINTEL && setMarker( uint32_t marker_ ) && VULKAN_HPP_NOEXCEPT + { + marker = marker_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPerformanceStreamMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceStreamMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceStreamMarkerInfoINTEL const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerformanceStreamMarkerInfoINTEL *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, marker ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PerformanceStreamMarkerInfoINTEL const & ) const = default; +#else + bool operator==( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker ); +# endif + } + + bool operator!=( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL; + const void * pNext = {}; + uint32_t marker = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceStreamMarkerInfoINTEL; + }; +#endif + + template <> + struct CppType + { + using Type = PerformanceStreamMarkerInfoINTEL; + }; + + union PerformanceValueDataINTEL + { + using NativeType = VkPerformanceValueDataINTEL; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL( uint32_t value32_ = {} ) : value32( value32_ ) {} + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL( uint64_t value64_ ) : value64( value64_ ) {} + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL( float valueFloat_ ) : valueFloat( valueFloat_ ) {} + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL( const char * valueString_ ) : valueString( valueString_ ) {} +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL & setValue32( uint32_t value32_ ) & VULKAN_HPP_NOEXCEPT + { + value32 = value32_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL && setValue32( uint32_t value32_ ) && VULKAN_HPP_NOEXCEPT + { + value32 = value32_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL & setValue64( uint64_t value64_ ) & VULKAN_HPP_NOEXCEPT + { + value64 = value64_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL && setValue64( uint64_t value64_ ) && VULKAN_HPP_NOEXCEPT + { + value64 = value64_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL & setValueFloat( float valueFloat_ ) & VULKAN_HPP_NOEXCEPT + { + valueFloat = valueFloat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL && setValueFloat( float valueFloat_ ) && VULKAN_HPP_NOEXCEPT + { + valueFloat = valueFloat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL & setValueBool( Bool32 valueBool_ ) & VULKAN_HPP_NOEXCEPT + { + valueBool = valueBool_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL && setValueBool( Bool32 valueBool_ ) && VULKAN_HPP_NOEXCEPT + { + valueBool = valueBool_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL & setValueString( const char * valueString_ ) & VULKAN_HPP_NOEXCEPT + { + valueString = valueString_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL && setValueString( const char * valueString_ ) && VULKAN_HPP_NOEXCEPT + { + valueString = valueString_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPerformanceValueDataINTEL const &() const + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceValueDataINTEL &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + uint32_t value32; + uint64_t value64; + float valueFloat; + Bool32 valueBool; + const char * valueString; +#else + uint32_t value32; + uint64_t value64; + float valueFloat; + VkBool32 valueBool; + const char * valueString; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceValueDataINTEL; + }; +#endif + + // wrapper struct for struct VkPerformanceValueINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceValueINTEL.html + struct PerformanceValueINTEL + { + using NativeType = VkPerformanceValueINTEL; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PerformanceValueINTEL( PerformanceValueTypeINTEL type_ = PerformanceValueTypeINTEL::eUint32, + PerformanceValueDataINTEL data_ = {} ) VULKAN_HPP_NOEXCEPT + : type{ type_ } + , data{ data_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PerformanceValueINTEL( PerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerformanceValueINTEL( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + : PerformanceValueINTEL( *reinterpret_cast( &rhs ) ) + { + } + + PerformanceValueINTEL & operator=( PerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerformanceValueINTEL & operator=( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPerformanceValueINTEL const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceValueINTEL &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerformanceValueINTEL const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerformanceValueINTEL *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( type, data ); + } +#endif + + public: + PerformanceValueTypeINTEL type = PerformanceValueTypeINTEL::eUint32; + PerformanceValueDataINTEL data = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PerformanceValueINTEL; + }; +#endif + + // wrapper struct for struct VkPhysicalDevice16BitStorageFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice16BitStorageFeatures.html + struct PhysicalDevice16BitStorageFeatures + { + using NativeType = VkPhysicalDevice16BitStorageFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevice16BitStorageFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( Bool32 storageBuffer16BitAccess_ = {}, + Bool32 uniformAndStorageBuffer16BitAccess_ = {}, + Bool32 storagePushConstant16_ = {}, + Bool32 storageInputOutput16_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , storageBuffer16BitAccess{ storageBuffer16BitAccess_ } + , uniformAndStorageBuffer16BitAccess{ uniformAndStorageBuffer16BitAccess_ } + , storagePushConstant16{ storagePushConstant16_ } + , storageInputOutput16{ storageInputOutput16_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( PhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevice16BitStorageFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevice16BitStorageFeatures & operator=( PhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevice16BitStorageFeatures & operator=( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures & setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) & VULKAN_HPP_NOEXCEPT + { + storageBuffer16BitAccess = storageBuffer16BitAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures && setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) && VULKAN_HPP_NOEXCEPT + { + storageBuffer16BitAccess = storageBuffer16BitAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures & setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures && setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures & setStoragePushConstant16( Bool32 storagePushConstant16_ ) & VULKAN_HPP_NOEXCEPT + { + storagePushConstant16 = storagePushConstant16_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures && setStoragePushConstant16( Bool32 storagePushConstant16_ ) && VULKAN_HPP_NOEXCEPT + { + storagePushConstant16 = storagePushConstant16_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures & setStorageInputOutput16( Bool32 storageInputOutput16_ ) & VULKAN_HPP_NOEXCEPT + { + storageInputOutput16 = storageInputOutput16_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures && setStorageInputOutput16( Bool32 storageInputOutput16_ ) && VULKAN_HPP_NOEXCEPT + { + storageInputOutput16 = storageInputOutput16_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevice16BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevice16BitStorageFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevice16BitStorageFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevice16BitStorageFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, storageBuffer16BitAccess, uniformAndStorageBuffer16BitAccess, storagePushConstant16, storageInputOutput16 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevice16BitStorageFeatures const & ) const = default; +#else + bool operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) && + ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) && ( storagePushConstant16 == rhs.storagePushConstant16 ) && + ( storageInputOutput16 == rhs.storageInputOutput16 ); +# endif + } + + bool operator!=( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures; + void * pNext = {}; + Bool32 storageBuffer16BitAccess = {}; + Bool32 uniformAndStorageBuffer16BitAccess = {}; + Bool32 storagePushConstant16 = {}; + Bool32 storageInputOutput16 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevice16BitStorageFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevice16BitStorageFeatures; + }; + + using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; + + // wrapper struct for struct VkPhysicalDevice4444FormatsFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html + struct PhysicalDevice4444FormatsFeaturesEXT + { + using NativeType = VkPhysicalDevice4444FormatsFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevice4444FormatsFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDevice4444FormatsFeaturesEXT( Bool32 formatA4R4G4B4_ = {}, Bool32 formatA4B4G4R4_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , formatA4R4G4B4{ formatA4R4G4B4_ } + , formatA4B4G4R4{ formatA4B4G4R4_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevice4444FormatsFeaturesEXT( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevice4444FormatsFeaturesEXT( VkPhysicalDevice4444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevice4444FormatsFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevice4444FormatsFeaturesEXT & operator=( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevice4444FormatsFeaturesEXT & operator=( VkPhysicalDevice4444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT & setFormatA4R4G4B4( Bool32 formatA4R4G4B4_ ) & VULKAN_HPP_NOEXCEPT + { + formatA4R4G4B4 = formatA4R4G4B4_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT && setFormatA4R4G4B4( Bool32 formatA4R4G4B4_ ) && VULKAN_HPP_NOEXCEPT + { + formatA4R4G4B4 = formatA4R4G4B4_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT & setFormatA4B4G4R4( Bool32 formatA4B4G4R4_ ) & VULKAN_HPP_NOEXCEPT + { + formatA4B4G4R4 = formatA4B4G4R4_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT && setFormatA4B4G4R4( Bool32 formatA4B4G4R4_ ) && VULKAN_HPP_NOEXCEPT + { + formatA4B4G4R4 = formatA4B4G4R4_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevice4444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevice4444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevice4444FormatsFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevice4444FormatsFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatA4R4G4B4, formatA4B4G4R4 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevice4444FormatsFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatA4R4G4B4 == rhs.formatA4R4G4B4 ) && ( formatA4B4G4R4 == rhs.formatA4B4G4R4 ); +# endif + } + + bool operator!=( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevice4444FormatsFeaturesEXT; + void * pNext = {}; + Bool32 formatA4R4G4B4 = {}; + Bool32 formatA4B4G4R4 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevice4444FormatsFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevice4444FormatsFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDevice8BitStorageFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice8BitStorageFeatures.html + struct PhysicalDevice8BitStorageFeatures + { + using NativeType = VkPhysicalDevice8BitStorageFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevice8BitStorageFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeatures( Bool32 storageBuffer8BitAccess_ = {}, + Bool32 uniformAndStorageBuffer8BitAccess_ = {}, + Bool32 storagePushConstant8_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , storageBuffer8BitAccess{ storageBuffer8BitAccess_ } + , uniformAndStorageBuffer8BitAccess{ uniformAndStorageBuffer8BitAccess_ } + , storagePushConstant8{ storagePushConstant8_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeatures( PhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevice8BitStorageFeatures( VkPhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevice8BitStorageFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevice8BitStorageFeatures & operator=( PhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevice8BitStorageFeatures & operator=( VkPhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures & setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ ) & VULKAN_HPP_NOEXCEPT + { + storageBuffer8BitAccess = storageBuffer8BitAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures && setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ ) && VULKAN_HPP_NOEXCEPT + { + storageBuffer8BitAccess = storageBuffer8BitAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures & setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures && setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures & setStoragePushConstant8( Bool32 storagePushConstant8_ ) & VULKAN_HPP_NOEXCEPT + { + storagePushConstant8 = storagePushConstant8_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures && setStoragePushConstant8( Bool32 storagePushConstant8_ ) && VULKAN_HPP_NOEXCEPT + { + storagePushConstant8 = storagePushConstant8_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevice8BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevice8BitStorageFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevice8BitStorageFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevice8BitStorageFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, storageBuffer8BitAccess, uniformAndStorageBuffer8BitAccess, storagePushConstant8 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevice8BitStorageFeatures const & ) const = default; +#else + bool operator==( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) && + ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) && ( storagePushConstant8 == rhs.storagePushConstant8 ); +# endif + } + + bool operator!=( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevice8BitStorageFeatures; + void * pNext = {}; + Bool32 storageBuffer8BitAccess = {}; + Bool32 uniformAndStorageBuffer8BitAccess = {}; + Bool32 storagePushConstant8 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevice8BitStorageFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevice8BitStorageFeatures; + }; + + using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures; + + // wrapper struct for struct VkPhysicalDeviceASTCDecodeFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html + struct PhysicalDeviceASTCDecodeFeaturesEXT + { + using NativeType = VkPhysicalDeviceASTCDecodeFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( Bool32 decodeModeSharedExponent_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , decodeModeSharedExponent{ decodeModeSharedExponent_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceASTCDecodeFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceASTCDecodeFeaturesEXT & operator=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceASTCDecodeFeaturesEXT & operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceASTCDecodeFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceASTCDecodeFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceASTCDecodeFeaturesEXT & setDecodeModeSharedExponent( Bool32 decodeModeSharedExponent_ ) & VULKAN_HPP_NOEXCEPT + { + decodeModeSharedExponent = decodeModeSharedExponent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceASTCDecodeFeaturesEXT && setDecodeModeSharedExponent( Bool32 decodeModeSharedExponent_ ) && VULKAN_HPP_NOEXCEPT + { + decodeModeSharedExponent = decodeModeSharedExponent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceASTCDecodeFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceASTCDecodeFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceASTCDecodeFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceASTCDecodeFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, decodeModeSharedExponent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceASTCDecodeFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeModeSharedExponent == rhs.decodeModeSharedExponent ); +# endif + } + + bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; + void * pNext = {}; + Bool32 decodeModeSharedExponent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceASTCDecodeFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceASTCDecodeFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceAccelerationStructureFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html + struct PhysicalDeviceAccelerationStructureFeaturesKHR + { + using NativeType = VkPhysicalDeviceAccelerationStructureFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAccelerationStructureFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceAccelerationStructureFeaturesKHR( Bool32 accelerationStructure_ = {}, + Bool32 accelerationStructureCaptureReplay_ = {}, + Bool32 accelerationStructureIndirectBuild_ = {}, + Bool32 accelerationStructureHostCommands_ = {}, + Bool32 descriptorBindingAccelerationStructureUpdateAfterBind_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , accelerationStructure{ accelerationStructure_ } + , accelerationStructureCaptureReplay{ accelerationStructureCaptureReplay_ } + , accelerationStructureIndirectBuild{ accelerationStructureIndirectBuild_ } + , accelerationStructureHostCommands{ accelerationStructureHostCommands_ } + , descriptorBindingAccelerationStructureUpdateAfterBind{ descriptorBindingAccelerationStructureUpdateAfterBind_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceAccelerationStructureFeaturesKHR( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceAccelerationStructureFeaturesKHR( VkPhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceAccelerationStructureFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceAccelerationStructureFeaturesKHR & operator=( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceAccelerationStructureFeaturesKHR & operator=( VkPhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & setAccelerationStructure( Bool32 accelerationStructure_ ) & VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && setAccelerationStructure( Bool32 accelerationStructure_ ) && VULKAN_HPP_NOEXCEPT + { + accelerationStructure = accelerationStructure_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & + setAccelerationStructureCaptureReplay( Bool32 accelerationStructureCaptureReplay_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructureCaptureReplay = accelerationStructureCaptureReplay_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && + setAccelerationStructureCaptureReplay( Bool32 accelerationStructureCaptureReplay_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructureCaptureReplay = accelerationStructureCaptureReplay_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & + setAccelerationStructureIndirectBuild( Bool32 accelerationStructureIndirectBuild_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructureIndirectBuild = accelerationStructureIndirectBuild_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && + setAccelerationStructureIndirectBuild( Bool32 accelerationStructureIndirectBuild_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructureIndirectBuild = accelerationStructureIndirectBuild_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & setAccelerationStructureHostCommands( Bool32 accelerationStructureHostCommands_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructureHostCommands = accelerationStructureHostCommands_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && + setAccelerationStructureHostCommands( Bool32 accelerationStructureHostCommands_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructureHostCommands = accelerationStructureHostCommands_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & + setDescriptorBindingAccelerationStructureUpdateAfterBind( Bool32 descriptorBindingAccelerationStructureUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingAccelerationStructureUpdateAfterBind = descriptorBindingAccelerationStructureUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && + setDescriptorBindingAccelerationStructureUpdateAfterBind( Bool32 descriptorBindingAccelerationStructureUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingAccelerationStructureUpdateAfterBind = descriptorBindingAccelerationStructureUpdateAfterBind_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceAccelerationStructureFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAccelerationStructureFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAccelerationStructureFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAccelerationStructureFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + accelerationStructure, + accelerationStructureCaptureReplay, + accelerationStructureIndirectBuild, + accelerationStructureHostCommands, + descriptorBindingAccelerationStructureUpdateAfterBind ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceAccelerationStructureFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ) && + ( accelerationStructureCaptureReplay == rhs.accelerationStructureCaptureReplay ) && + ( accelerationStructureIndirectBuild == rhs.accelerationStructureIndirectBuild ) && + ( accelerationStructureHostCommands == rhs.accelerationStructureHostCommands ) && + ( descriptorBindingAccelerationStructureUpdateAfterBind == rhs.descriptorBindingAccelerationStructureUpdateAfterBind ); +# endif + } + + bool operator!=( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceAccelerationStructureFeaturesKHR; + void * pNext = {}; + Bool32 accelerationStructure = {}; + Bool32 accelerationStructureCaptureReplay = {}; + Bool32 accelerationStructureIndirectBuild = {}; + Bool32 accelerationStructureHostCommands = {}; + Bool32 descriptorBindingAccelerationStructureUpdateAfterBind = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceAccelerationStructureFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceAccelerationStructureFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceAccelerationStructurePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html + struct PhysicalDeviceAccelerationStructurePropertiesKHR + { + using NativeType = VkPhysicalDeviceAccelerationStructurePropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAccelerationStructurePropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceAccelerationStructurePropertiesKHR( uint64_t maxGeometryCount_ = {}, + uint64_t maxInstanceCount_ = {}, + uint64_t maxPrimitiveCount_ = {}, + uint32_t maxPerStageDescriptorAccelerationStructures_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures_ = {}, + uint32_t maxDescriptorSetAccelerationStructures_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures_ = {}, + uint32_t minAccelerationStructureScratchOffsetAlignment_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxGeometryCount{ maxGeometryCount_ } + , maxInstanceCount{ maxInstanceCount_ } + , maxPrimitiveCount{ maxPrimitiveCount_ } + , maxPerStageDescriptorAccelerationStructures{ maxPerStageDescriptorAccelerationStructures_ } + , maxPerStageDescriptorUpdateAfterBindAccelerationStructures{ maxPerStageDescriptorUpdateAfterBindAccelerationStructures_ } + , maxDescriptorSetAccelerationStructures{ maxDescriptorSetAccelerationStructures_ } + , maxDescriptorSetUpdateAfterBindAccelerationStructures{ maxDescriptorSetUpdateAfterBindAccelerationStructures_ } + , minAccelerationStructureScratchOffsetAlignment{ minAccelerationStructureScratchOffsetAlignment_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceAccelerationStructurePropertiesKHR( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceAccelerationStructurePropertiesKHR( VkPhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceAccelerationStructurePropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceAccelerationStructurePropertiesKHR & operator=( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceAccelerationStructurePropertiesKHR & operator=( VkPhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceAccelerationStructurePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAccelerationStructurePropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAccelerationStructurePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAccelerationStructurePropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxGeometryCount, + maxInstanceCount, + maxPrimitiveCount, + maxPerStageDescriptorAccelerationStructures, + maxPerStageDescriptorUpdateAfterBindAccelerationStructures, + maxDescriptorSetAccelerationStructures, + maxDescriptorSetUpdateAfterBindAccelerationStructures, + minAccelerationStructureScratchOffsetAlignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceAccelerationStructurePropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGeometryCount == rhs.maxGeometryCount ) && ( maxInstanceCount == rhs.maxInstanceCount ) && + ( maxPrimitiveCount == rhs.maxPrimitiveCount ) && + ( maxPerStageDescriptorAccelerationStructures == rhs.maxPerStageDescriptorAccelerationStructures ) && + ( maxPerStageDescriptorUpdateAfterBindAccelerationStructures == rhs.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ) && + ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ) && + ( maxDescriptorSetUpdateAfterBindAccelerationStructures == rhs.maxDescriptorSetUpdateAfterBindAccelerationStructures ) && + ( minAccelerationStructureScratchOffsetAlignment == rhs.minAccelerationStructureScratchOffsetAlignment ); +# endif + } + + bool operator!=( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceAccelerationStructurePropertiesKHR; + void * pNext = {}; + uint64_t maxGeometryCount = {}; + uint64_t maxInstanceCount = {}; + uint64_t maxPrimitiveCount = {}; + uint32_t maxPerStageDescriptorAccelerationStructures = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures = {}; + uint32_t maxDescriptorSetAccelerationStructures = {}; + uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures = {}; + uint32_t minAccelerationStructureScratchOffsetAlignment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceAccelerationStructurePropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceAccelerationStructurePropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceAddressBindingReportFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAddressBindingReportFeaturesEXT.html + struct PhysicalDeviceAddressBindingReportFeaturesEXT + { + using NativeType = VkPhysicalDeviceAddressBindingReportFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAddressBindingReportFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceAddressBindingReportFeaturesEXT( Bool32 reportAddressBinding_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , reportAddressBinding{ reportAddressBinding_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceAddressBindingReportFeaturesEXT( PhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceAddressBindingReportFeaturesEXT( VkPhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceAddressBindingReportFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceAddressBindingReportFeaturesEXT & operator=( PhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceAddressBindingReportFeaturesEXT & operator=( VkPhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAddressBindingReportFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAddressBindingReportFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAddressBindingReportFeaturesEXT & setReportAddressBinding( Bool32 reportAddressBinding_ ) & VULKAN_HPP_NOEXCEPT + { + reportAddressBinding = reportAddressBinding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAddressBindingReportFeaturesEXT && setReportAddressBinding( Bool32 reportAddressBinding_ ) && VULKAN_HPP_NOEXCEPT + { + reportAddressBinding = reportAddressBinding_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceAddressBindingReportFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAddressBindingReportFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAddressBindingReportFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAddressBindingReportFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, reportAddressBinding ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceAddressBindingReportFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reportAddressBinding == rhs.reportAddressBinding ); +# endif + } + + bool operator!=( PhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceAddressBindingReportFeaturesEXT; + void * pNext = {}; + Bool32 reportAddressBinding = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceAddressBindingReportFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceAddressBindingReportFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceAmigoProfilingFeaturesSEC, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAmigoProfilingFeaturesSEC.html + struct PhysicalDeviceAmigoProfilingFeaturesSEC + { + using NativeType = VkPhysicalDeviceAmigoProfilingFeaturesSEC; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceAmigoProfilingFeaturesSEC( Bool32 amigoProfiling_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , amigoProfiling{ amigoProfiling_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceAmigoProfilingFeaturesSEC( PhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceAmigoProfilingFeaturesSEC( VkPhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceAmigoProfilingFeaturesSEC( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceAmigoProfilingFeaturesSEC & operator=( PhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceAmigoProfilingFeaturesSEC & operator=( VkPhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAmigoProfilingFeaturesSEC & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAmigoProfilingFeaturesSEC && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAmigoProfilingFeaturesSEC & setAmigoProfiling( Bool32 amigoProfiling_ ) & VULKAN_HPP_NOEXCEPT + { + amigoProfiling = amigoProfiling_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAmigoProfilingFeaturesSEC && setAmigoProfiling( Bool32 amigoProfiling_ ) && VULKAN_HPP_NOEXCEPT + { + amigoProfiling = amigoProfiling_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceAmigoProfilingFeaturesSEC const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAmigoProfilingFeaturesSEC &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAmigoProfilingFeaturesSEC const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAmigoProfilingFeaturesSEC *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, amigoProfiling ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceAmigoProfilingFeaturesSEC const & ) const = default; +#else + bool operator==( PhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( amigoProfiling == rhs.amigoProfiling ); +# endif + } + + bool operator!=( PhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC; + void * pNext = {}; + Bool32 amigoProfiling = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceAmigoProfilingFeaturesSEC; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceAmigoProfilingFeaturesSEC; + }; + + // wrapper struct for struct VkPhysicalDeviceAntiLagFeaturesAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAntiLagFeaturesAMD.html + struct PhysicalDeviceAntiLagFeaturesAMD + { + using NativeType = VkPhysicalDeviceAntiLagFeaturesAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAntiLagFeaturesAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceAntiLagFeaturesAMD( Bool32 antiLag_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , antiLag{ antiLag_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceAntiLagFeaturesAMD( PhysicalDeviceAntiLagFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceAntiLagFeaturesAMD( VkPhysicalDeviceAntiLagFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceAntiLagFeaturesAMD( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceAntiLagFeaturesAMD & operator=( PhysicalDeviceAntiLagFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceAntiLagFeaturesAMD & operator=( VkPhysicalDeviceAntiLagFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAntiLagFeaturesAMD & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAntiLagFeaturesAMD && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAntiLagFeaturesAMD & setAntiLag( Bool32 antiLag_ ) & VULKAN_HPP_NOEXCEPT + { + antiLag = antiLag_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAntiLagFeaturesAMD && setAntiLag( Bool32 antiLag_ ) && VULKAN_HPP_NOEXCEPT + { + antiLag = antiLag_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceAntiLagFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAntiLagFeaturesAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAntiLagFeaturesAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAntiLagFeaturesAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, antiLag ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceAntiLagFeaturesAMD const & ) const = default; +#else + bool operator==( PhysicalDeviceAntiLagFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( antiLag == rhs.antiLag ); +# endif + } + + bool operator!=( PhysicalDeviceAntiLagFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceAntiLagFeaturesAMD; + void * pNext = {}; + Bool32 antiLag = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceAntiLagFeaturesAMD; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceAntiLagFeaturesAMD; + }; + + // wrapper struct for struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.html + struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT + { + using NativeType = VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( Bool32 attachmentFeedbackLoopDynamicState_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , attachmentFeedbackLoopDynamicState{ attachmentFeedbackLoopDynamicState_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( + *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT & + operator=( PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT & + operator=( VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT & + setAttachmentFeedbackLoopDynamicState( Bool32 attachmentFeedbackLoopDynamicState_ ) & + VULKAN_HPP_NOEXCEPT + { + attachmentFeedbackLoopDynamicState = attachmentFeedbackLoopDynamicState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT && + setAttachmentFeedbackLoopDynamicState( Bool32 attachmentFeedbackLoopDynamicState_ ) && + VULKAN_HPP_NOEXCEPT + { + attachmentFeedbackLoopDynamicState = attachmentFeedbackLoopDynamicState_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachmentFeedbackLoopDynamicState ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentFeedbackLoopDynamicState == rhs.attachmentFeedbackLoopDynamicState ); +# endif + } + + bool operator!=( PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + void * pNext = {}; + Bool32 attachmentFeedbackLoopDynamicState = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.html + struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT + { + using NativeType = VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( Bool32 attachmentFeedbackLoopLayout_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , attachmentFeedbackLoopLayout{ attachmentFeedbackLoopLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT & + operator=( PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT & operator=( VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT & setAttachmentFeedbackLoopLayout( Bool32 attachmentFeedbackLoopLayout_ ) & + VULKAN_HPP_NOEXCEPT + { + attachmentFeedbackLoopLayout = attachmentFeedbackLoopLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT && setAttachmentFeedbackLoopLayout( Bool32 attachmentFeedbackLoopLayout_ ) && + VULKAN_HPP_NOEXCEPT + { + attachmentFeedbackLoopLayout = attachmentFeedbackLoopLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachmentFeedbackLoopLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentFeedbackLoopLayout == rhs.attachmentFeedbackLoopLayout ); +# endif + } + + bool operator!=( PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + void * pNext = {}; + Bool32 attachmentFeedbackLoopLayout = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html + struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT + { + using NativeType = VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , advancedBlendCoherentOperations{ advancedBlendCoherentOperations_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceBlendOperationAdvancedFeaturesEXT( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceBlendOperationAdvancedFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceBlendOperationAdvancedFeaturesEXT & operator=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceBlendOperationAdvancedFeaturesEXT & operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBlendOperationAdvancedFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ ) & + VULKAN_HPP_NOEXCEPT + { + advancedBlendCoherentOperations = advancedBlendCoherentOperations_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBlendOperationAdvancedFeaturesEXT && setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ ) && + VULKAN_HPP_NOEXCEPT + { + advancedBlendCoherentOperations = advancedBlendCoherentOperations_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, advancedBlendCoherentOperations ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations ); +# endif + } + + bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; + void * pNext = {}; + Bool32 advancedBlendCoherentOperations = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html + struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT + { + using NativeType = VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedPropertiesEXT( uint32_t advancedBlendMaxColorAttachments_ = {}, + Bool32 advancedBlendIndependentBlend_ = {}, + Bool32 advancedBlendNonPremultipliedSrcColor_ = {}, + Bool32 advancedBlendNonPremultipliedDstColor_ = {}, + Bool32 advancedBlendCorrelatedOverlap_ = {}, + Bool32 advancedBlendAllOperations_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , advancedBlendMaxColorAttachments{ advancedBlendMaxColorAttachments_ } + , advancedBlendIndependentBlend{ advancedBlendIndependentBlend_ } + , advancedBlendNonPremultipliedSrcColor{ advancedBlendNonPremultipliedSrcColor_ } + , advancedBlendNonPremultipliedDstColor{ advancedBlendNonPremultipliedDstColor_ } + , advancedBlendCorrelatedOverlap{ advancedBlendCorrelatedOverlap_ } + , advancedBlendAllOperations{ advancedBlendAllOperations_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceBlendOperationAdvancedPropertiesEXT( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceBlendOperationAdvancedPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceBlendOperationAdvancedPropertiesEXT & + operator=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceBlendOperationAdvancedPropertiesEXT & operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + advancedBlendMaxColorAttachments, + advancedBlendIndependentBlend, + advancedBlendNonPremultipliedSrcColor, + advancedBlendNonPremultipliedDstColor, + advancedBlendCorrelatedOverlap, + advancedBlendAllOperations ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) && + ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) && + ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) && + ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) && + ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) && ( advancedBlendAllOperations == rhs.advancedBlendAllOperations ); +# endif + } + + bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; + void * pNext = {}; + uint32_t advancedBlendMaxColorAttachments = {}; + Bool32 advancedBlendIndependentBlend = {}; + Bool32 advancedBlendNonPremultipliedSrcColor = {}; + Bool32 advancedBlendNonPremultipliedDstColor = {}; + Bool32 advancedBlendCorrelatedOverlap = {}; + Bool32 advancedBlendAllOperations = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.html + struct PhysicalDeviceBorderColorSwizzleFeaturesEXT + { + using NativeType = VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBorderColorSwizzleFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceBorderColorSwizzleFeaturesEXT( Bool32 borderColorSwizzle_ = {}, + Bool32 borderColorSwizzleFromImage_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , borderColorSwizzle{ borderColorSwizzle_ } + , borderColorSwizzleFromImage{ borderColorSwizzleFromImage_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceBorderColorSwizzleFeaturesEXT( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceBorderColorSwizzleFeaturesEXT( VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceBorderColorSwizzleFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceBorderColorSwizzleFeaturesEXT & operator=( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceBorderColorSwizzleFeaturesEXT & operator=( VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT & setBorderColorSwizzle( Bool32 borderColorSwizzle_ ) & VULKAN_HPP_NOEXCEPT + { + borderColorSwizzle = borderColorSwizzle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT && setBorderColorSwizzle( Bool32 borderColorSwizzle_ ) && VULKAN_HPP_NOEXCEPT + { + borderColorSwizzle = borderColorSwizzle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT & setBorderColorSwizzleFromImage( Bool32 borderColorSwizzleFromImage_ ) & + VULKAN_HPP_NOEXCEPT + { + borderColorSwizzleFromImage = borderColorSwizzleFromImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT && setBorderColorSwizzleFromImage( Bool32 borderColorSwizzleFromImage_ ) && + VULKAN_HPP_NOEXCEPT + { + borderColorSwizzleFromImage = borderColorSwizzleFromImage_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, borderColorSwizzle, borderColorSwizzleFromImage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( borderColorSwizzle == rhs.borderColorSwizzle ) && + ( borderColorSwizzleFromImage == rhs.borderColorSwizzleFromImage ); +# endif + } + + bool operator!=( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceBorderColorSwizzleFeaturesEXT; + void * pNext = {}; + Bool32 borderColorSwizzle = {}; + Bool32 borderColorSwizzleFromImage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceBorderColorSwizzleFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceBorderColorSwizzleFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceBufferDeviceAddressFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html + struct PhysicalDeviceBufferDeviceAddressFeatures + { + using NativeType = VkPhysicalDeviceBufferDeviceAddressFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBufferDeviceAddressFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeatures( Bool32 bufferDeviceAddress_ = {}, + Bool32 bufferDeviceAddressCaptureReplay_ = {}, + Bool32 bufferDeviceAddressMultiDevice_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , bufferDeviceAddress{ bufferDeviceAddress_ } + , bufferDeviceAddressCaptureReplay{ bufferDeviceAddressCaptureReplay_ } + , bufferDeviceAddressMultiDevice{ bufferDeviceAddressMultiDevice_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeatures( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceBufferDeviceAddressFeatures( VkPhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceBufferDeviceAddressFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceBufferDeviceAddressFeatures & operator=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceBufferDeviceAddressFeatures & operator=( VkPhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures & setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) & VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddress = bufferDeviceAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures && setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) && VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddress = bufferDeviceAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures & setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) & + VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures && setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) && + VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures & setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) & + VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures && setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) && + VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceBufferDeviceAddressFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBufferDeviceAddressFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBufferDeviceAddressFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBufferDeviceAddressFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceBufferDeviceAddressFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && + ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && + ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); +# endif + } + + bool operator!=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeatures; + void * pNext = {}; + Bool32 bufferDeviceAddress = {}; + Bool32 bufferDeviceAddressCaptureReplay = {}; + Bool32 bufferDeviceAddressMultiDevice = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceBufferDeviceAddressFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceBufferDeviceAddressFeatures; + }; + + using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures; + + // wrapper struct for struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.html + struct PhysicalDeviceBufferDeviceAddressFeaturesEXT + { + using NativeType = VkPhysicalDeviceBufferDeviceAddressFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( Bool32 bufferDeviceAddress_ = {}, + Bool32 bufferDeviceAddressCaptureReplay_ = {}, + Bool32 bufferDeviceAddressMultiDevice_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , bufferDeviceAddress{ bufferDeviceAddress_ } + , bufferDeviceAddressCaptureReplay{ bufferDeviceAddressCaptureReplay_ } + , bufferDeviceAddressMultiDevice{ bufferDeviceAddressMultiDevice_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceBufferDeviceAddressFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceBufferDeviceAddressFeaturesEXT & operator=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceBufferDeviceAddressFeaturesEXT & operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) & VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddress = bufferDeviceAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT && setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) && VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddress = bufferDeviceAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) & + VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT && setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) && + VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) & + VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT && setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) && + VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && + ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && + ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); +# endif + } + + bool operator!=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; + void * pNext = {}; + Bool32 bufferDeviceAddress = {}; + Bool32 bufferDeviceAddressCaptureReplay = {}; + Bool32 bufferDeviceAddressMultiDevice = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceBufferDeviceAddressFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceBufferDeviceAddressFeaturesEXT; + }; + + using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT; + + // wrapper struct for struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.html + struct PhysicalDeviceClusterAccelerationStructureFeaturesNV + { + using NativeType = VkPhysicalDeviceClusterAccelerationStructureFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceClusterAccelerationStructureFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceClusterAccelerationStructureFeaturesNV( Bool32 clusterAccelerationStructure_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , clusterAccelerationStructure{ clusterAccelerationStructure_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceClusterAccelerationStructureFeaturesNV( PhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceClusterAccelerationStructureFeaturesNV( VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceClusterAccelerationStructureFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceClusterAccelerationStructureFeaturesNV & + operator=( PhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceClusterAccelerationStructureFeaturesNV & operator=( VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterAccelerationStructureFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterAccelerationStructureFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterAccelerationStructureFeaturesNV & setClusterAccelerationStructure( Bool32 clusterAccelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + clusterAccelerationStructure = clusterAccelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterAccelerationStructureFeaturesNV && setClusterAccelerationStructure( Bool32 clusterAccelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + clusterAccelerationStructure = clusterAccelerationStructure_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterAccelerationStructureFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, clusterAccelerationStructure ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceClusterAccelerationStructureFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( clusterAccelerationStructure == rhs.clusterAccelerationStructure ); +# endif + } + + bool operator!=( PhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceClusterAccelerationStructureFeaturesNV; + void * pNext = {}; + Bool32 clusterAccelerationStructure = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceClusterAccelerationStructureFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceClusterAccelerationStructureFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterAccelerationStructurePropertiesNV.html + struct PhysicalDeviceClusterAccelerationStructurePropertiesNV + { + using NativeType = VkPhysicalDeviceClusterAccelerationStructurePropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceClusterAccelerationStructurePropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceClusterAccelerationStructurePropertiesNV( uint32_t maxVerticesPerCluster_ = {}, + uint32_t maxTrianglesPerCluster_ = {}, + uint32_t clusterScratchByteAlignment_ = {}, + uint32_t clusterByteAlignment_ = {}, + uint32_t clusterTemplateByteAlignment_ = {}, + uint32_t clusterBottomLevelByteAlignment_ = {}, + uint32_t clusterTemplateBoundsByteAlignment_ = {}, + uint32_t maxClusterGeometryIndex_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxVerticesPerCluster{ maxVerticesPerCluster_ } + , maxTrianglesPerCluster{ maxTrianglesPerCluster_ } + , clusterScratchByteAlignment{ clusterScratchByteAlignment_ } + , clusterByteAlignment{ clusterByteAlignment_ } + , clusterTemplateByteAlignment{ clusterTemplateByteAlignment_ } + , clusterBottomLevelByteAlignment{ clusterBottomLevelByteAlignment_ } + , clusterTemplateBoundsByteAlignment{ clusterTemplateBoundsByteAlignment_ } + , maxClusterGeometryIndex{ maxClusterGeometryIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceClusterAccelerationStructurePropertiesNV( PhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceClusterAccelerationStructurePropertiesNV( VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceClusterAccelerationStructurePropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceClusterAccelerationStructurePropertiesNV & + operator=( PhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceClusterAccelerationStructurePropertiesNV & + operator=( VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterAccelerationStructurePropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterAccelerationStructurePropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxVerticesPerCluster, + maxTrianglesPerCluster, + clusterScratchByteAlignment, + clusterByteAlignment, + clusterTemplateByteAlignment, + clusterBottomLevelByteAlignment, + clusterTemplateBoundsByteAlignment, + maxClusterGeometryIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceClusterAccelerationStructurePropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVerticesPerCluster == rhs.maxVerticesPerCluster ) && + ( maxTrianglesPerCluster == rhs.maxTrianglesPerCluster ) && ( clusterScratchByteAlignment == rhs.clusterScratchByteAlignment ) && + ( clusterByteAlignment == rhs.clusterByteAlignment ) && ( clusterTemplateByteAlignment == rhs.clusterTemplateByteAlignment ) && + ( clusterBottomLevelByteAlignment == rhs.clusterBottomLevelByteAlignment ) && + ( clusterTemplateBoundsByteAlignment == rhs.clusterTemplateBoundsByteAlignment ) && ( maxClusterGeometryIndex == rhs.maxClusterGeometryIndex ); +# endif + } + + bool operator!=( PhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceClusterAccelerationStructurePropertiesNV; + void * pNext = {}; + uint32_t maxVerticesPerCluster = {}; + uint32_t maxTrianglesPerCluster = {}; + uint32_t clusterScratchByteAlignment = {}; + uint32_t clusterByteAlignment = {}; + uint32_t clusterTemplateByteAlignment = {}; + uint32_t clusterBottomLevelByteAlignment = {}; + uint32_t clusterTemplateBoundsByteAlignment = {}; + uint32_t maxClusterGeometryIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceClusterAccelerationStructurePropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceClusterAccelerationStructurePropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.html + struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI + { + using NativeType = VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceClusterCullingShaderFeaturesHUAWEI; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceClusterCullingShaderFeaturesHUAWEI( Bool32 clustercullingShader_ = {}, + Bool32 multiviewClusterCullingShader_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , clustercullingShader{ clustercullingShader_ } + , multiviewClusterCullingShader{ multiviewClusterCullingShader_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceClusterCullingShaderFeaturesHUAWEI( PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceClusterCullingShaderFeaturesHUAWEI( VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceClusterCullingShaderFeaturesHUAWEI( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceClusterCullingShaderFeaturesHUAWEI & operator=( PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceClusterCullingShaderFeaturesHUAWEI & operator=( VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI & setClustercullingShader( Bool32 clustercullingShader_ ) & VULKAN_HPP_NOEXCEPT + { + clustercullingShader = clustercullingShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI && setClustercullingShader( Bool32 clustercullingShader_ ) && VULKAN_HPP_NOEXCEPT + { + clustercullingShader = clustercullingShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI & setMultiviewClusterCullingShader( Bool32 multiviewClusterCullingShader_ ) & + VULKAN_HPP_NOEXCEPT + { + multiviewClusterCullingShader = multiviewClusterCullingShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI && setMultiviewClusterCullingShader( Bool32 multiviewClusterCullingShader_ ) && + VULKAN_HPP_NOEXCEPT + { + multiviewClusterCullingShader = multiviewClusterCullingShader_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, clustercullingShader, multiviewClusterCullingShader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & ) const = default; +#else + bool operator==( PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( clustercullingShader == rhs.clustercullingShader ) && + ( multiviewClusterCullingShader == rhs.multiviewClusterCullingShader ); +# endif + } + + bool operator!=( PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceClusterCullingShaderFeaturesHUAWEI; + void * pNext = {}; + Bool32 clustercullingShader = {}; + Bool32 multiviewClusterCullingShader = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceClusterCullingShaderFeaturesHUAWEI; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceClusterCullingShaderFeaturesHUAWEI; + }; + + // wrapper struct for struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI.html + struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI + { + using NativeType = VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceClusterCullingShaderPropertiesHUAWEI; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderPropertiesHUAWEI( std::array const & maxWorkGroupCount_ = {}, + std::array const & maxWorkGroupSize_ = {}, + uint32_t maxOutputClusterCount_ = {}, + DeviceSize indirectBufferOffsetAlignment_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxWorkGroupCount{ maxWorkGroupCount_ } + , maxWorkGroupSize{ maxWorkGroupSize_ } + , maxOutputClusterCount{ maxOutputClusterCount_ } + , indirectBufferOffsetAlignment{ indirectBufferOffsetAlignment_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + PhysicalDeviceClusterCullingShaderPropertiesHUAWEI( PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceClusterCullingShaderPropertiesHUAWEI( VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceClusterCullingShaderPropertiesHUAWEI( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceClusterCullingShaderPropertiesHUAWEI & + operator=( PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceClusterCullingShaderPropertiesHUAWEI & operator=( VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &, + uint32_t const &, + DeviceSize const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxWorkGroupCount, maxWorkGroupSize, maxOutputClusterCount, indirectBufferOffsetAlignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & ) const = default; +#else + bool operator==( PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxWorkGroupCount == rhs.maxWorkGroupCount ) && + ( maxWorkGroupSize == rhs.maxWorkGroupSize ) && ( maxOutputClusterCount == rhs.maxOutputClusterCount ) && + ( indirectBufferOffsetAlignment == rhs.indirectBufferOffsetAlignment ); +# endif + } + + bool operator!=( PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceClusterCullingShaderPropertiesHUAWEI; + void * pNext = {}; + ArrayWrapper1D maxWorkGroupCount = {}; + ArrayWrapper1D maxWorkGroupSize = {}; + uint32_t maxOutputClusterCount = {}; + DeviceSize indirectBufferOffsetAlignment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceClusterCullingShaderPropertiesHUAWEI; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceClusterCullingShaderPropertiesHUAWEI; + }; + + // wrapper struct for struct VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.html + struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI + { + using NativeType = VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( Bool32 clusterShadingRate_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , clusterShadingRate{ clusterShadingRate_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI & + operator=( PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI & operator=( VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI & setClusterShadingRate( Bool32 clusterShadingRate_ ) & VULKAN_HPP_NOEXCEPT + { + clusterShadingRate = clusterShadingRate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI && setClusterShadingRate( Bool32 clusterShadingRate_ ) && VULKAN_HPP_NOEXCEPT + { + clusterShadingRate = clusterShadingRate_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, clusterShadingRate ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & ) const = default; +#else + bool operator==( PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( clusterShadingRate == rhs.clusterShadingRate ); +# endif + } + + bool operator!=( PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; + void * pNext = {}; + Bool32 clusterShadingRate = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; + }; + + // wrapper struct for struct VkPhysicalDeviceCoherentMemoryFeaturesAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html + struct PhysicalDeviceCoherentMemoryFeaturesAMD + { + using NativeType = VkPhysicalDeviceCoherentMemoryFeaturesAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( Bool32 deviceCoherentMemory_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceCoherentMemory{ deviceCoherentMemory_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCoherentMemoryFeaturesAMD( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCoherentMemoryFeaturesAMD & operator=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCoherentMemoryFeaturesAMD & operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoherentMemoryFeaturesAMD & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoherentMemoryFeaturesAMD && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoherentMemoryFeaturesAMD & setDeviceCoherentMemory( Bool32 deviceCoherentMemory_ ) & VULKAN_HPP_NOEXCEPT + { + deviceCoherentMemory = deviceCoherentMemory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoherentMemoryFeaturesAMD && setDeviceCoherentMemory( Bool32 deviceCoherentMemory_ ) && VULKAN_HPP_NOEXCEPT + { + deviceCoherentMemory = deviceCoherentMemory_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCoherentMemoryFeaturesAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCoherentMemoryFeaturesAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceCoherentMemory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCoherentMemoryFeaturesAMD const & ) const = default; +#else + bool operator==( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceCoherentMemory == rhs.deviceCoherentMemory ); +# endif + } + + bool operator!=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD; + void * pNext = {}; + Bool32 deviceCoherentMemory = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCoherentMemoryFeaturesAMD; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCoherentMemoryFeaturesAMD; + }; + + // wrapper struct for struct VkPhysicalDeviceColorWriteEnableFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceColorWriteEnableFeaturesEXT.html + struct PhysicalDeviceColorWriteEnableFeaturesEXT + { + using NativeType = VkPhysicalDeviceColorWriteEnableFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceColorWriteEnableFeaturesEXT( Bool32 colorWriteEnable_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , colorWriteEnable{ colorWriteEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceColorWriteEnableFeaturesEXT( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceColorWriteEnableFeaturesEXT( VkPhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceColorWriteEnableFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceColorWriteEnableFeaturesEXT & operator=( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceColorWriteEnableFeaturesEXT & operator=( VkPhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceColorWriteEnableFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceColorWriteEnableFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceColorWriteEnableFeaturesEXT & setColorWriteEnable( Bool32 colorWriteEnable_ ) & VULKAN_HPP_NOEXCEPT + { + colorWriteEnable = colorWriteEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceColorWriteEnableFeaturesEXT && setColorWriteEnable( Bool32 colorWriteEnable_ ) && VULKAN_HPP_NOEXCEPT + { + colorWriteEnable = colorWriteEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceColorWriteEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceColorWriteEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceColorWriteEnableFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceColorWriteEnableFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorWriteEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceColorWriteEnableFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorWriteEnable == rhs.colorWriteEnable ); +# endif + } + + bool operator!=( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT; + void * pNext = {}; + Bool32 colorWriteEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceColorWriteEnableFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceColorWriteEnableFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.html + struct PhysicalDeviceCommandBufferInheritanceFeaturesNV + { + using NativeType = VkPhysicalDeviceCommandBufferInheritanceFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCommandBufferInheritanceFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCommandBufferInheritanceFeaturesNV( Bool32 commandBufferInheritance_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , commandBufferInheritance{ commandBufferInheritance_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceCommandBufferInheritanceFeaturesNV( PhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCommandBufferInheritanceFeaturesNV( VkPhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCommandBufferInheritanceFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCommandBufferInheritanceFeaturesNV & operator=( PhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCommandBufferInheritanceFeaturesNV & operator=( VkPhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCommandBufferInheritanceFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCommandBufferInheritanceFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCommandBufferInheritanceFeaturesNV & setCommandBufferInheritance( Bool32 commandBufferInheritance_ ) & + VULKAN_HPP_NOEXCEPT + { + commandBufferInheritance = commandBufferInheritance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCommandBufferInheritanceFeaturesNV && setCommandBufferInheritance( Bool32 commandBufferInheritance_ ) && + VULKAN_HPP_NOEXCEPT + { + commandBufferInheritance = commandBufferInheritance_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCommandBufferInheritanceFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCommandBufferInheritanceFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCommandBufferInheritanceFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, commandBufferInheritance ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCommandBufferInheritanceFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBufferInheritance == rhs.commandBufferInheritance ); +# endif + } + + bool operator!=( PhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCommandBufferInheritanceFeaturesNV; + void * pNext = {}; + Bool32 commandBufferInheritance = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCommandBufferInheritanceFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCommandBufferInheritanceFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV.html + struct PhysicalDeviceComputeOccupancyPriorityFeaturesNV + { + using NativeType = VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceComputeOccupancyPriorityFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeOccupancyPriorityFeaturesNV( Bool32 computeOccupancyPriority_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , computeOccupancyPriority{ computeOccupancyPriority_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceComputeOccupancyPriorityFeaturesNV( PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceComputeOccupancyPriorityFeaturesNV( VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceComputeOccupancyPriorityFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceComputeOccupancyPriorityFeaturesNV & operator=( PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceComputeOccupancyPriorityFeaturesNV & operator=( VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeOccupancyPriorityFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeOccupancyPriorityFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeOccupancyPriorityFeaturesNV & setComputeOccupancyPriority( Bool32 computeOccupancyPriority_ ) & + VULKAN_HPP_NOEXCEPT + { + computeOccupancyPriority = computeOccupancyPriority_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeOccupancyPriorityFeaturesNV && setComputeOccupancyPriority( Bool32 computeOccupancyPriority_ ) && + VULKAN_HPP_NOEXCEPT + { + computeOccupancyPriority = computeOccupancyPriority_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, computeOccupancyPriority ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( computeOccupancyPriority == rhs.computeOccupancyPriority ); +# endif + } + + bool operator!=( PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceComputeOccupancyPriorityFeaturesNV; + void * pNext = {}; + Bool32 computeOccupancyPriority = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceComputeOccupancyPriorityFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceComputeOccupancyPriorityFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.html + struct PhysicalDeviceComputeShaderDerivativesFeaturesKHR + { + using NativeType = VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesKHR( Bool32 computeDerivativeGroupQuads_ = {}, + Bool32 computeDerivativeGroupLinear_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , computeDerivativeGroupQuads{ computeDerivativeGroupQuads_ } + , computeDerivativeGroupLinear{ computeDerivativeGroupLinear_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceComputeShaderDerivativesFeaturesKHR( PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceComputeShaderDerivativesFeaturesKHR( VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceComputeShaderDerivativesFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceComputeShaderDerivativesFeaturesKHR & + operator=( PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceComputeShaderDerivativesFeaturesKHR & operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR & setComputeDerivativeGroupQuads( Bool32 computeDerivativeGroupQuads_ ) & + VULKAN_HPP_NOEXCEPT + { + computeDerivativeGroupQuads = computeDerivativeGroupQuads_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR && setComputeDerivativeGroupQuads( Bool32 computeDerivativeGroupQuads_ ) && + VULKAN_HPP_NOEXCEPT + { + computeDerivativeGroupQuads = computeDerivativeGroupQuads_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR & setComputeDerivativeGroupLinear( Bool32 computeDerivativeGroupLinear_ ) & + VULKAN_HPP_NOEXCEPT + { + computeDerivativeGroupLinear = computeDerivativeGroupLinear_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR && setComputeDerivativeGroupLinear( Bool32 computeDerivativeGroupLinear_ ) && + VULKAN_HPP_NOEXCEPT + { + computeDerivativeGroupLinear = computeDerivativeGroupLinear_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, computeDerivativeGroupQuads, computeDerivativeGroupLinear ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads ) && + ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear ); +# endif + } + + bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesKHR; + void * pNext = {}; + Bool32 computeDerivativeGroupQuads = {}; + Bool32 computeDerivativeGroupLinear = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceComputeShaderDerivativesFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceComputeShaderDerivativesFeaturesKHR; + }; + + using PhysicalDeviceComputeShaderDerivativesFeaturesNV = PhysicalDeviceComputeShaderDerivativesFeaturesKHR; + + // wrapper struct for struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR.html + struct PhysicalDeviceComputeShaderDerivativesPropertiesKHR + { + using NativeType = VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceComputeShaderDerivativesPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesPropertiesKHR( Bool32 meshAndTaskShaderDerivatives_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , meshAndTaskShaderDerivatives{ meshAndTaskShaderDerivatives_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceComputeShaderDerivativesPropertiesKHR( PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceComputeShaderDerivativesPropertiesKHR( VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceComputeShaderDerivativesPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceComputeShaderDerivativesPropertiesKHR & + operator=( PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceComputeShaderDerivativesPropertiesKHR & operator=( VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, meshAndTaskShaderDerivatives ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( meshAndTaskShaderDerivatives == rhs.meshAndTaskShaderDerivatives ); +# endif + } + + bool operator!=( PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesPropertiesKHR; + void * pNext = {}; + Bool32 meshAndTaskShaderDerivatives = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceComputeShaderDerivativesPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceComputeShaderDerivativesPropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceConditionalRenderingFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html + struct PhysicalDeviceConditionalRenderingFeaturesEXT + { + using NativeType = VkPhysicalDeviceConditionalRenderingFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( Bool32 conditionalRendering_ = {}, + Bool32 inheritedConditionalRendering_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , conditionalRendering{ conditionalRendering_ } + , inheritedConditionalRendering{ inheritedConditionalRendering_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceConditionalRenderingFeaturesEXT( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceConditionalRenderingFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceConditionalRenderingFeaturesEXT & operator=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceConditionalRenderingFeaturesEXT & operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT & setConditionalRendering( Bool32 conditionalRendering_ ) & VULKAN_HPP_NOEXCEPT + { + conditionalRendering = conditionalRendering_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT && setConditionalRendering( Bool32 conditionalRendering_ ) && VULKAN_HPP_NOEXCEPT + { + conditionalRendering = conditionalRendering_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT & setInheritedConditionalRendering( Bool32 inheritedConditionalRendering_ ) & + VULKAN_HPP_NOEXCEPT + { + inheritedConditionalRendering = inheritedConditionalRendering_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT && setInheritedConditionalRendering( Bool32 inheritedConditionalRendering_ ) && + VULKAN_HPP_NOEXCEPT + { + inheritedConditionalRendering = inheritedConditionalRendering_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceConditionalRenderingFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, conditionalRendering, inheritedConditionalRendering ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceConditionalRenderingFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRendering == rhs.conditionalRendering ) && + ( inheritedConditionalRendering == rhs.inheritedConditionalRendering ); +# endif + } + + bool operator!=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; + void * pNext = {}; + Bool32 conditionalRendering = {}; + Bool32 inheritedConditionalRendering = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceConditionalRenderingFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceConditionalRenderingFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html + struct PhysicalDeviceConservativeRasterizationPropertiesEXT + { + using NativeType = VkPhysicalDeviceConservativeRasterizationPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = {}, + float maxExtraPrimitiveOverestimationSize_ = {}, + float extraPrimitiveOverestimationSizeGranularity_ = {}, + Bool32 primitiveUnderestimation_ = {}, + Bool32 conservativePointAndLineRasterization_ = {}, + Bool32 degenerateTrianglesRasterized_ = {}, + Bool32 degenerateLinesRasterized_ = {}, + Bool32 fullyCoveredFragmentShaderInputVariable_ = {}, + Bool32 conservativeRasterizationPostDepthCoverage_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , primitiveOverestimationSize{ primitiveOverestimationSize_ } + , maxExtraPrimitiveOverestimationSize{ maxExtraPrimitiveOverestimationSize_ } + , extraPrimitiveOverestimationSizeGranularity{ extraPrimitiveOverestimationSizeGranularity_ } + , primitiveUnderestimation{ primitiveUnderestimation_ } + , conservativePointAndLineRasterization{ conservativePointAndLineRasterization_ } + , degenerateTrianglesRasterized{ degenerateTrianglesRasterized_ } + , degenerateLinesRasterized{ degenerateLinesRasterized_ } + , fullyCoveredFragmentShaderInputVariable{ fullyCoveredFragmentShaderInputVariable_ } + , conservativeRasterizationPostDepthCoverage{ conservativeRasterizationPostDepthCoverage_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceConservativeRasterizationPropertiesEXT( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceConservativeRasterizationPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceConservativeRasterizationPropertiesEXT & + operator=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceConservativeRasterizationPropertiesEXT & operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + primitiveOverestimationSize, + maxExtraPrimitiveOverestimationSize, + extraPrimitiveOverestimationSizeGranularity, + primitiveUnderestimation, + conservativePointAndLineRasterization, + degenerateTrianglesRasterized, + degenerateLinesRasterized, + fullyCoveredFragmentShaderInputVariable, + conservativeRasterizationPostDepthCoverage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceConservativeRasterizationPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( primitiveOverestimationSize == rhs.primitiveOverestimationSize ) && + ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize ) && + ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity ) && + ( primitiveUnderestimation == rhs.primitiveUnderestimation ) && + ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization ) && + ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized ) && ( degenerateLinesRasterized == rhs.degenerateLinesRasterized ) && + ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable ) && + ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage ); +# endif + } + + bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; + void * pNext = {}; + float primitiveOverestimationSize = {}; + float maxExtraPrimitiveOverestimationSize = {}; + float extraPrimitiveOverestimationSizeGranularity = {}; + Bool32 primitiveUnderestimation = {}; + Bool32 conservativePointAndLineRasterization = {}; + Bool32 degenerateTrianglesRasterized = {}; + Bool32 degenerateLinesRasterized = {}; + Bool32 fullyCoveredFragmentShaderInputVariable = {}; + Bool32 conservativeRasterizationPostDepthCoverage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrix2FeaturesNV.html + struct PhysicalDeviceCooperativeMatrix2FeaturesNV + { + using NativeType = VkPhysicalDeviceCooperativeMatrix2FeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2FeaturesNV( Bool32 cooperativeMatrixWorkgroupScope_ = {}, + Bool32 cooperativeMatrixFlexibleDimensions_ = {}, + Bool32 cooperativeMatrixReductions_ = {}, + Bool32 cooperativeMatrixConversions_ = {}, + Bool32 cooperativeMatrixPerElementOperations_ = {}, + Bool32 cooperativeMatrixTensorAddressing_ = {}, + Bool32 cooperativeMatrixBlockLoads_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cooperativeMatrixWorkgroupScope{ cooperativeMatrixWorkgroupScope_ } + , cooperativeMatrixFlexibleDimensions{ cooperativeMatrixFlexibleDimensions_ } + , cooperativeMatrixReductions{ cooperativeMatrixReductions_ } + , cooperativeMatrixConversions{ cooperativeMatrixConversions_ } + , cooperativeMatrixPerElementOperations{ cooperativeMatrixPerElementOperations_ } + , cooperativeMatrixTensorAddressing{ cooperativeMatrixTensorAddressing_ } + , cooperativeMatrixBlockLoads{ cooperativeMatrixBlockLoads_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2FeaturesNV( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCooperativeMatrix2FeaturesNV( VkPhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCooperativeMatrix2FeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCooperativeMatrix2FeaturesNV & operator=( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCooperativeMatrix2FeaturesNV & operator=( VkPhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixWorkgroupScope( Bool32 cooperativeMatrixWorkgroupScope_ ) & + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixWorkgroupScope = cooperativeMatrixWorkgroupScope_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setCooperativeMatrixWorkgroupScope( Bool32 cooperativeMatrixWorkgroupScope_ ) && + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixWorkgroupScope = cooperativeMatrixWorkgroupScope_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixFlexibleDimensions( Bool32 cooperativeMatrixFlexibleDimensions_ ) & + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixFlexibleDimensions = cooperativeMatrixFlexibleDimensions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && + setCooperativeMatrixFlexibleDimensions( Bool32 cooperativeMatrixFlexibleDimensions_ ) && + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixFlexibleDimensions = cooperativeMatrixFlexibleDimensions_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixReductions( Bool32 cooperativeMatrixReductions_ ) & + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixReductions = cooperativeMatrixReductions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setCooperativeMatrixReductions( Bool32 cooperativeMatrixReductions_ ) && + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixReductions = cooperativeMatrixReductions_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixConversions( Bool32 cooperativeMatrixConversions_ ) & + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixConversions = cooperativeMatrixConversions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setCooperativeMatrixConversions( Bool32 cooperativeMatrixConversions_ ) && + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixConversions = cooperativeMatrixConversions_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & + setCooperativeMatrixPerElementOperations( Bool32 cooperativeMatrixPerElementOperations_ ) & + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixPerElementOperations = cooperativeMatrixPerElementOperations_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && + setCooperativeMatrixPerElementOperations( Bool32 cooperativeMatrixPerElementOperations_ ) && + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixPerElementOperations = cooperativeMatrixPerElementOperations_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixTensorAddressing( Bool32 cooperativeMatrixTensorAddressing_ ) & + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixTensorAddressing = cooperativeMatrixTensorAddressing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setCooperativeMatrixTensorAddressing( Bool32 cooperativeMatrixTensorAddressing_ ) && + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixTensorAddressing = cooperativeMatrixTensorAddressing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixBlockLoads( Bool32 cooperativeMatrixBlockLoads_ ) & + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixBlockLoads = cooperativeMatrixBlockLoads_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setCooperativeMatrixBlockLoads( Bool32 cooperativeMatrixBlockLoads_ ) && + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixBlockLoads = cooperativeMatrixBlockLoads_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCooperativeMatrix2FeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrix2FeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrix2FeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrix2FeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + cooperativeMatrixWorkgroupScope, + cooperativeMatrixFlexibleDimensions, + cooperativeMatrixReductions, + cooperativeMatrixConversions, + cooperativeMatrixPerElementOperations, + cooperativeMatrixTensorAddressing, + cooperativeMatrixBlockLoads ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCooperativeMatrix2FeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrixWorkgroupScope == rhs.cooperativeMatrixWorkgroupScope ) && + ( cooperativeMatrixFlexibleDimensions == rhs.cooperativeMatrixFlexibleDimensions ) && + ( cooperativeMatrixReductions == rhs.cooperativeMatrixReductions ) && ( cooperativeMatrixConversions == rhs.cooperativeMatrixConversions ) && + ( cooperativeMatrixPerElementOperations == rhs.cooperativeMatrixPerElementOperations ) && + ( cooperativeMatrixTensorAddressing == rhs.cooperativeMatrixTensorAddressing ) && + ( cooperativeMatrixBlockLoads == rhs.cooperativeMatrixBlockLoads ); +# endif + } + + bool operator!=( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV; + void * pNext = {}; + Bool32 cooperativeMatrixWorkgroupScope = {}; + Bool32 cooperativeMatrixFlexibleDimensions = {}; + Bool32 cooperativeMatrixReductions = {}; + Bool32 cooperativeMatrixConversions = {}; + Bool32 cooperativeMatrixPerElementOperations = {}; + Bool32 cooperativeMatrixTensorAddressing = {}; + Bool32 cooperativeMatrixBlockLoads = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrix2FeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrix2FeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrix2PropertiesNV.html + struct PhysicalDeviceCooperativeMatrix2PropertiesNV + { + using NativeType = VkPhysicalDeviceCooperativeMatrix2PropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2PropertiesNV( uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize_ = {}, + uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension_ = {}, + uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cooperativeMatrixWorkgroupScopeMaxWorkgroupSize{ cooperativeMatrixWorkgroupScopeMaxWorkgroupSize_ } + , cooperativeMatrixFlexibleDimensionsMaxDimension{ cooperativeMatrixFlexibleDimensionsMaxDimension_ } + , cooperativeMatrixWorkgroupScopeReservedSharedMemory{ cooperativeMatrixWorkgroupScopeReservedSharedMemory_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2PropertiesNV( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCooperativeMatrix2PropertiesNV( VkPhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCooperativeMatrix2PropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCooperativeMatrix2PropertiesNV & operator=( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCooperativeMatrix2PropertiesNV & operator=( VkPhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceCooperativeMatrix2PropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrix2PropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrix2PropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrix2PropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + cooperativeMatrixWorkgroupScopeMaxWorkgroupSize, + cooperativeMatrixFlexibleDimensionsMaxDimension, + cooperativeMatrixWorkgroupScopeReservedSharedMemory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCooperativeMatrix2PropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( cooperativeMatrixWorkgroupScopeMaxWorkgroupSize == rhs.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize ) && + ( cooperativeMatrixFlexibleDimensionsMaxDimension == rhs.cooperativeMatrixFlexibleDimensionsMaxDimension ) && + ( cooperativeMatrixWorkgroupScopeReservedSharedMemory == rhs.cooperativeMatrixWorkgroupScopeReservedSharedMemory ); +# endif + } + + bool operator!=( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV; + void * pNext = {}; + uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = {}; + uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension = {}; + uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrix2PropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrix2PropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesKHR.html + struct PhysicalDeviceCooperativeMatrixFeaturesKHR + { + using NativeType = VkPhysicalDeviceCooperativeMatrixFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesKHR( Bool32 cooperativeMatrix_ = {}, + Bool32 cooperativeMatrixRobustBufferAccess_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cooperativeMatrix{ cooperativeMatrix_ } + , cooperativeMatrixRobustBufferAccess{ cooperativeMatrixRobustBufferAccess_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesKHR( PhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCooperativeMatrixFeaturesKHR( VkPhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCooperativeMatrixFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCooperativeMatrixFeaturesKHR & operator=( PhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCooperativeMatrixFeaturesKHR & operator=( VkPhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR & setCooperativeMatrix( Bool32 cooperativeMatrix_ ) & VULKAN_HPP_NOEXCEPT + { + cooperativeMatrix = cooperativeMatrix_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR && setCooperativeMatrix( Bool32 cooperativeMatrix_ ) && VULKAN_HPP_NOEXCEPT + { + cooperativeMatrix = cooperativeMatrix_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR & setCooperativeMatrixRobustBufferAccess( Bool32 cooperativeMatrixRobustBufferAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR && + setCooperativeMatrixRobustBufferAccess( Bool32 cooperativeMatrixRobustBufferAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCooperativeMatrixFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) && + ( cooperativeMatrixRobustBufferAccess == rhs.cooperativeMatrixRobustBufferAccess ); +# endif + } + + bool operator!=( PhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesKHR; + void * pNext = {}; + Bool32 cooperativeMatrix = {}; + Bool32 cooperativeMatrixRobustBufferAccess = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrixFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrixFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html + struct PhysicalDeviceCooperativeMatrixFeaturesNV + { + using NativeType = VkPhysicalDeviceCooperativeMatrixFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( Bool32 cooperativeMatrix_ = {}, + Bool32 cooperativeMatrixRobustBufferAccess_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cooperativeMatrix{ cooperativeMatrix_ } + , cooperativeMatrixRobustBufferAccess{ cooperativeMatrixRobustBufferAccess_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCooperativeMatrixFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCooperativeMatrixFeaturesNV & operator=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCooperativeMatrixFeaturesNV & operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrix( Bool32 cooperativeMatrix_ ) & VULKAN_HPP_NOEXCEPT + { + cooperativeMatrix = cooperativeMatrix_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV && setCooperativeMatrix( Bool32 cooperativeMatrix_ ) && VULKAN_HPP_NOEXCEPT + { + cooperativeMatrix = cooperativeMatrix_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrixRobustBufferAccess( Bool32 cooperativeMatrixRobustBufferAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV && + setCooperativeMatrixRobustBufferAccess( Bool32 cooperativeMatrixRobustBufferAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) && + ( cooperativeMatrixRobustBufferAccess == rhs.cooperativeMatrixRobustBufferAccess ); +# endif + } + + bool operator!=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; + void * pNext = {}; + Bool32 cooperativeMatrix = {}; + Bool32 cooperativeMatrixRobustBufferAccess = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrixFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrixFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesKHR.html + struct PhysicalDeviceCooperativeMatrixPropertiesKHR + { + using NativeType = VkPhysicalDeviceCooperativeMatrixPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesKHR( ShaderStageFlags cooperativeMatrixSupportedStages_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cooperativeMatrixSupportedStages{ cooperativeMatrixSupportedStages_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesKHR( PhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCooperativeMatrixPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCooperativeMatrixPropertiesKHR & operator=( PhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCooperativeMatrixPropertiesKHR & operator=( VkPhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceCooperativeMatrixPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cooperativeMatrixSupportedStages ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages ); +# endif + } + + bool operator!=( PhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR; + void * pNext = {}; + ShaderStageFlags cooperativeMatrixSupportedStages = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrixPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrixPropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html + struct PhysicalDeviceCooperativeMatrixPropertiesNV + { + using NativeType = VkPhysicalDeviceCooperativeMatrixPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesNV( ShaderStageFlags cooperativeMatrixSupportedStages_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cooperativeMatrixSupportedStages{ cooperativeMatrixSupportedStages_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesNV( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCooperativeMatrixPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCooperativeMatrixPropertiesNV & operator=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCooperativeMatrixPropertiesNV & operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeMatrixPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cooperativeMatrixSupportedStages ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages ); +# endif + } + + bool operator!=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; + void * pNext = {}; + ShaderStageFlags cooperativeMatrixSupportedStages = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrixPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeMatrixPropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceCooperativeVectorFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeVectorFeaturesNV.html + struct PhysicalDeviceCooperativeVectorFeaturesNV + { + using NativeType = VkPhysicalDeviceCooperativeVectorFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeVectorFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeVectorFeaturesNV( Bool32 cooperativeVector_ = {}, + Bool32 cooperativeVectorTraining_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cooperativeVector{ cooperativeVector_ } + , cooperativeVectorTraining{ cooperativeVectorTraining_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeVectorFeaturesNV( PhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCooperativeVectorFeaturesNV( VkPhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCooperativeVectorFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCooperativeVectorFeaturesNV & operator=( PhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCooperativeVectorFeaturesNV & operator=( VkPhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV & setCooperativeVector( Bool32 cooperativeVector_ ) & VULKAN_HPP_NOEXCEPT + { + cooperativeVector = cooperativeVector_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV && setCooperativeVector( Bool32 cooperativeVector_ ) && VULKAN_HPP_NOEXCEPT + { + cooperativeVector = cooperativeVector_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV & setCooperativeVectorTraining( Bool32 cooperativeVectorTraining_ ) & VULKAN_HPP_NOEXCEPT + { + cooperativeVectorTraining = cooperativeVectorTraining_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV && setCooperativeVectorTraining( Bool32 cooperativeVectorTraining_ ) && + VULKAN_HPP_NOEXCEPT + { + cooperativeVectorTraining = cooperativeVectorTraining_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCooperativeVectorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeVectorFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeVectorFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeVectorFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cooperativeVector, cooperativeVectorTraining ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCooperativeVectorFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeVector == rhs.cooperativeVector ) && + ( cooperativeVectorTraining == rhs.cooperativeVectorTraining ); +# endif + } + + bool operator!=( PhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCooperativeVectorFeaturesNV; + void * pNext = {}; + Bool32 cooperativeVector = {}; + Bool32 cooperativeVectorTraining = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeVectorFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeVectorFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceCooperativeVectorPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeVectorPropertiesNV.html + struct PhysicalDeviceCooperativeVectorPropertiesNV + { + using NativeType = VkPhysicalDeviceCooperativeVectorPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeVectorPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeVectorPropertiesNV( ShaderStageFlags cooperativeVectorSupportedStages_ = {}, + Bool32 cooperativeVectorTrainingFloat16Accumulation_ = {}, + Bool32 cooperativeVectorTrainingFloat32Accumulation_ = {}, + uint32_t maxCooperativeVectorComponents_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cooperativeVectorSupportedStages{ cooperativeVectorSupportedStages_ } + , cooperativeVectorTrainingFloat16Accumulation{ cooperativeVectorTrainingFloat16Accumulation_ } + , cooperativeVectorTrainingFloat32Accumulation{ cooperativeVectorTrainingFloat32Accumulation_ } + , maxCooperativeVectorComponents{ maxCooperativeVectorComponents_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeVectorPropertiesNV( PhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCooperativeVectorPropertiesNV( VkPhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCooperativeVectorPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCooperativeVectorPropertiesNV & operator=( PhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCooperativeVectorPropertiesNV & operator=( VkPhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceCooperativeVectorPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeVectorPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeVectorPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCooperativeVectorPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + cooperativeVectorSupportedStages, + cooperativeVectorTrainingFloat16Accumulation, + cooperativeVectorTrainingFloat32Accumulation, + maxCooperativeVectorComponents ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCooperativeVectorPropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeVectorSupportedStages == rhs.cooperativeVectorSupportedStages ) && + ( cooperativeVectorTrainingFloat16Accumulation == rhs.cooperativeVectorTrainingFloat16Accumulation ) && + ( cooperativeVectorTrainingFloat32Accumulation == rhs.cooperativeVectorTrainingFloat32Accumulation ) && + ( maxCooperativeVectorComponents == rhs.maxCooperativeVectorComponents ); +# endif + } + + bool operator!=( PhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCooperativeVectorPropertiesNV; + void * pNext = {}; + ShaderStageFlags cooperativeVectorSupportedStages = {}; + Bool32 cooperativeVectorTrainingFloat16Accumulation = {}; + Bool32 cooperativeVectorTrainingFloat32Accumulation = {}; + uint32_t maxCooperativeVectorComponents = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeVectorPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCooperativeVectorPropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR.html + struct PhysicalDeviceCopyMemoryIndirectFeaturesKHR + { + using NativeType = VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectFeaturesKHR( Bool32 indirectMemoryCopy_ = {}, + Bool32 indirectMemoryToImageCopy_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , indirectMemoryCopy{ indirectMemoryCopy_ } + , indirectMemoryToImageCopy{ indirectMemoryToImageCopy_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectFeaturesKHR( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCopyMemoryIndirectFeaturesKHR( VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCopyMemoryIndirectFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCopyMemoryIndirectFeaturesKHR & operator=( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCopyMemoryIndirectFeaturesKHR & operator=( VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR & setIndirectMemoryCopy( Bool32 indirectMemoryCopy_ ) & VULKAN_HPP_NOEXCEPT + { + indirectMemoryCopy = indirectMemoryCopy_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR && setIndirectMemoryCopy( Bool32 indirectMemoryCopy_ ) && VULKAN_HPP_NOEXCEPT + { + indirectMemoryCopy = indirectMemoryCopy_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR & setIndirectMemoryToImageCopy( Bool32 indirectMemoryToImageCopy_ ) & + VULKAN_HPP_NOEXCEPT + { + indirectMemoryToImageCopy = indirectMemoryToImageCopy_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR && setIndirectMemoryToImageCopy( Bool32 indirectMemoryToImageCopy_ ) && + VULKAN_HPP_NOEXCEPT + { + indirectMemoryToImageCopy = indirectMemoryToImageCopy_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, indirectMemoryCopy, indirectMemoryToImageCopy ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indirectMemoryCopy == rhs.indirectMemoryCopy ) && + ( indirectMemoryToImageCopy == rhs.indirectMemoryToImageCopy ); +# endif + } + + bool operator!=( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesKHR; + void * pNext = {}; + Bool32 indirectMemoryCopy = {}; + Bool32 indirectMemoryToImageCopy = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCopyMemoryIndirectFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCopyMemoryIndirectFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.html + struct PhysicalDeviceCopyMemoryIndirectFeaturesNV + { + using NativeType = VkPhysicalDeviceCopyMemoryIndirectFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectFeaturesNV( Bool32 indirectCopy_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , indirectCopy{ indirectCopy_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectFeaturesNV( PhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCopyMemoryIndirectFeaturesNV( VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCopyMemoryIndirectFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCopyMemoryIndirectFeaturesNV & operator=( PhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCopyMemoryIndirectFeaturesNV & operator=( VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesNV & setIndirectCopy( Bool32 indirectCopy_ ) & VULKAN_HPP_NOEXCEPT + { + indirectCopy = indirectCopy_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesNV && setIndirectCopy( Bool32 indirectCopy_ ) && VULKAN_HPP_NOEXCEPT + { + indirectCopy = indirectCopy_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCopyMemoryIndirectFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, indirectCopy ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCopyMemoryIndirectFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indirectCopy == rhs.indirectCopy ); +# endif + } + + bool operator!=( PhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesNV; + void * pNext = {}; + Bool32 indirectCopy = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCopyMemoryIndirectFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCopyMemoryIndirectFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR.html + struct PhysicalDeviceCopyMemoryIndirectPropertiesKHR + { + using NativeType = VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectPropertiesKHR( QueueFlags supportedQueues_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , supportedQueues{ supportedQueues_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceCopyMemoryIndirectPropertiesKHR( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCopyMemoryIndirectPropertiesKHR( VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCopyMemoryIndirectPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCopyMemoryIndirectPropertiesKHR & operator=( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCopyMemoryIndirectPropertiesKHR & operator=( VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supportedQueues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedQueues == rhs.supportedQueues ); +# endif + } + + bool operator!=( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesKHR; + void * pNext = {}; + QueueFlags supportedQueues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCopyMemoryIndirectPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCopyMemoryIndirectPropertiesKHR; + }; + + using PhysicalDeviceCopyMemoryIndirectPropertiesNV = PhysicalDeviceCopyMemoryIndirectPropertiesKHR; + + // wrapper struct for struct VkPhysicalDeviceCornerSampledImageFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html + struct PhysicalDeviceCornerSampledImageFeaturesNV + { + using NativeType = VkPhysicalDeviceCornerSampledImageFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( Bool32 cornerSampledImage_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cornerSampledImage{ cornerSampledImage_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCornerSampledImageFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCornerSampledImageFeaturesNV & operator=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCornerSampledImageFeaturesNV & operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCornerSampledImageFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCornerSampledImageFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCornerSampledImageFeaturesNV & setCornerSampledImage( Bool32 cornerSampledImage_ ) & VULKAN_HPP_NOEXCEPT + { + cornerSampledImage = cornerSampledImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCornerSampledImageFeaturesNV && setCornerSampledImage( Bool32 cornerSampledImage_ ) && VULKAN_HPP_NOEXCEPT + { + cornerSampledImage = cornerSampledImage_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCornerSampledImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCornerSampledImageFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCornerSampledImageFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCornerSampledImageFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cornerSampledImage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCornerSampledImageFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cornerSampledImage == rhs.cornerSampledImage ); +# endif + } + + bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; + void * pNext = {}; + Bool32 cornerSampledImage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCornerSampledImageFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCornerSampledImageFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceCoverageReductionModeFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html + struct PhysicalDeviceCoverageReductionModeFeaturesNV + { + using NativeType = VkPhysicalDeviceCoverageReductionModeFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( Bool32 coverageReductionMode_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , coverageReductionMode{ coverageReductionMode_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceCoverageReductionModeFeaturesNV( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCoverageReductionModeFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCoverageReductionModeFeaturesNV & operator=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCoverageReductionModeFeaturesNV & operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoverageReductionModeFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoverageReductionModeFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoverageReductionModeFeaturesNV & setCoverageReductionMode( Bool32 coverageReductionMode_ ) & VULKAN_HPP_NOEXCEPT + { + coverageReductionMode = coverageReductionMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoverageReductionModeFeaturesNV && setCoverageReductionMode( Bool32 coverageReductionMode_ ) && VULKAN_HPP_NOEXCEPT + { + coverageReductionMode = coverageReductionMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCoverageReductionModeFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCoverageReductionModeFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, coverageReductionMode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCoverageReductionModeFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode ); +# endif + } + + bool operator!=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; + void * pNext = {}; + Bool32 coverageReductionMode = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCoverageReductionModeFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCoverageReductionModeFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceCubicClampFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCubicClampFeaturesQCOM.html + struct PhysicalDeviceCubicClampFeaturesQCOM + { + using NativeType = VkPhysicalDeviceCubicClampFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCubicClampFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCubicClampFeaturesQCOM( Bool32 cubicRangeClamp_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cubicRangeClamp{ cubicRangeClamp_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCubicClampFeaturesQCOM( PhysicalDeviceCubicClampFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCubicClampFeaturesQCOM( VkPhysicalDeviceCubicClampFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCubicClampFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCubicClampFeaturesQCOM & operator=( PhysicalDeviceCubicClampFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCubicClampFeaturesQCOM & operator=( VkPhysicalDeviceCubicClampFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicClampFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicClampFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicClampFeaturesQCOM & setCubicRangeClamp( Bool32 cubicRangeClamp_ ) & VULKAN_HPP_NOEXCEPT + { + cubicRangeClamp = cubicRangeClamp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicClampFeaturesQCOM && setCubicRangeClamp( Bool32 cubicRangeClamp_ ) && VULKAN_HPP_NOEXCEPT + { + cubicRangeClamp = cubicRangeClamp_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCubicClampFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCubicClampFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCubicClampFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCubicClampFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cubicRangeClamp ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCubicClampFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceCubicClampFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cubicRangeClamp == rhs.cubicRangeClamp ); +# endif + } + + bool operator!=( PhysicalDeviceCubicClampFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCubicClampFeaturesQCOM; + void * pNext = {}; + Bool32 cubicRangeClamp = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCubicClampFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCubicClampFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceCubicWeightsFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCubicWeightsFeaturesQCOM.html + struct PhysicalDeviceCubicWeightsFeaturesQCOM + { + using NativeType = VkPhysicalDeviceCubicWeightsFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCubicWeightsFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCubicWeightsFeaturesQCOM( Bool32 selectableCubicWeights_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , selectableCubicWeights{ selectableCubicWeights_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCubicWeightsFeaturesQCOM( PhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCubicWeightsFeaturesQCOM( VkPhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCubicWeightsFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCubicWeightsFeaturesQCOM & operator=( PhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCubicWeightsFeaturesQCOM & operator=( VkPhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicWeightsFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicWeightsFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicWeightsFeaturesQCOM & setSelectableCubicWeights( Bool32 selectableCubicWeights_ ) & VULKAN_HPP_NOEXCEPT + { + selectableCubicWeights = selectableCubicWeights_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicWeightsFeaturesQCOM && setSelectableCubicWeights( Bool32 selectableCubicWeights_ ) && VULKAN_HPP_NOEXCEPT + { + selectableCubicWeights = selectableCubicWeights_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCubicWeightsFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCubicWeightsFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCubicWeightsFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCubicWeightsFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, selectableCubicWeights ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCubicWeightsFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( selectableCubicWeights == rhs.selectableCubicWeights ); +# endif + } + + bool operator!=( PhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCubicWeightsFeaturesQCOM; + void * pNext = {}; + Bool32 selectableCubicWeights = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCubicWeightsFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCubicWeightsFeaturesQCOM; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCudaKernelLaunchFeaturesNV.html + struct PhysicalDeviceCudaKernelLaunchFeaturesNV + { + using NativeType = VkPhysicalDeviceCudaKernelLaunchFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCudaKernelLaunchFeaturesNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCudaKernelLaunchFeaturesNV( Bool32 cudaKernelLaunchFeatures_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cudaKernelLaunchFeatures{ cudaKernelLaunchFeatures_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCudaKernelLaunchFeaturesNV( PhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCudaKernelLaunchFeaturesNV( VkPhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCudaKernelLaunchFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCudaKernelLaunchFeaturesNV & operator=( PhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCudaKernelLaunchFeaturesNV & operator=( VkPhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCudaKernelLaunchFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCudaKernelLaunchFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCudaKernelLaunchFeaturesNV & setCudaKernelLaunchFeatures( Bool32 cudaKernelLaunchFeatures_ ) & VULKAN_HPP_NOEXCEPT + { + cudaKernelLaunchFeatures = cudaKernelLaunchFeatures_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCudaKernelLaunchFeaturesNV && setCudaKernelLaunchFeatures( Bool32 cudaKernelLaunchFeatures_ ) && VULKAN_HPP_NOEXCEPT + { + cudaKernelLaunchFeatures = cudaKernelLaunchFeatures_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCudaKernelLaunchFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCudaKernelLaunchFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCudaKernelLaunchFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCudaKernelLaunchFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cudaKernelLaunchFeatures ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCudaKernelLaunchFeaturesNV const & ) const = default; +# else + bool operator==( PhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cudaKernelLaunchFeatures == rhs.cudaKernelLaunchFeatures ); +# endif + } + + bool operator!=( PhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCudaKernelLaunchFeaturesNV; + void * pNext = {}; + Bool32 cudaKernelLaunchFeatures = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCudaKernelLaunchFeaturesNV; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCudaKernelLaunchFeaturesNV; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCudaKernelLaunchPropertiesNV.html + struct PhysicalDeviceCudaKernelLaunchPropertiesNV + { + using NativeType = VkPhysicalDeviceCudaKernelLaunchPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCudaKernelLaunchPropertiesNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCudaKernelLaunchPropertiesNV( uint32_t computeCapabilityMinor_ = {}, + uint32_t computeCapabilityMajor_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , computeCapabilityMinor{ computeCapabilityMinor_ } + , computeCapabilityMajor{ computeCapabilityMajor_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCudaKernelLaunchPropertiesNV( PhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCudaKernelLaunchPropertiesNV( VkPhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCudaKernelLaunchPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCudaKernelLaunchPropertiesNV & operator=( PhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCudaKernelLaunchPropertiesNV & operator=( VkPhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceCudaKernelLaunchPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCudaKernelLaunchPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCudaKernelLaunchPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCudaKernelLaunchPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, computeCapabilityMinor, computeCapabilityMajor ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCudaKernelLaunchPropertiesNV const & ) const = default; +# else + bool operator==( PhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( computeCapabilityMinor == rhs.computeCapabilityMinor ) && + ( computeCapabilityMajor == rhs.computeCapabilityMajor ); +# endif + } + + bool operator!=( PhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCudaKernelLaunchPropertiesNV; + void * pNext = {}; + uint32_t computeCapabilityMinor = {}; + uint32_t computeCapabilityMajor = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCudaKernelLaunchPropertiesNV; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCudaKernelLaunchPropertiesNV; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkPhysicalDeviceCustomBorderColorFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html + struct PhysicalDeviceCustomBorderColorFeaturesEXT + { + using NativeType = VkPhysicalDeviceCustomBorderColorFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomBorderColorFeaturesEXT( Bool32 customBorderColors_ = {}, + Bool32 customBorderColorWithoutFormat_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , customBorderColors{ customBorderColors_ } + , customBorderColorWithoutFormat{ customBorderColorWithoutFormat_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomBorderColorFeaturesEXT( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCustomBorderColorFeaturesEXT( VkPhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCustomBorderColorFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCustomBorderColorFeaturesEXT & operator=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCustomBorderColorFeaturesEXT & operator=( VkPhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT & setCustomBorderColors( Bool32 customBorderColors_ ) & VULKAN_HPP_NOEXCEPT + { + customBorderColors = customBorderColors_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT && setCustomBorderColors( Bool32 customBorderColors_ ) && VULKAN_HPP_NOEXCEPT + { + customBorderColors = customBorderColors_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT & setCustomBorderColorWithoutFormat( Bool32 customBorderColorWithoutFormat_ ) & + VULKAN_HPP_NOEXCEPT + { + customBorderColorWithoutFormat = customBorderColorWithoutFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT && setCustomBorderColorWithoutFormat( Bool32 customBorderColorWithoutFormat_ ) && + VULKAN_HPP_NOEXCEPT + { + customBorderColorWithoutFormat = customBorderColorWithoutFormat_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCustomBorderColorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCustomBorderColorFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCustomBorderColorFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCustomBorderColorFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, customBorderColors, customBorderColorWithoutFormat ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCustomBorderColorFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customBorderColors == rhs.customBorderColors ) && + ( customBorderColorWithoutFormat == rhs.customBorderColorWithoutFormat ); +# endif + } + + bool operator!=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT; + void * pNext = {}; + Bool32 customBorderColors = {}; + Bool32 customBorderColorWithoutFormat = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCustomBorderColorFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCustomBorderColorFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceCustomBorderColorPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCustomBorderColorPropertiesEXT.html + struct PhysicalDeviceCustomBorderColorPropertiesEXT + { + using NativeType = VkPhysicalDeviceCustomBorderColorPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomBorderColorPropertiesEXT( uint32_t maxCustomBorderColorSamplers_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxCustomBorderColorSamplers{ maxCustomBorderColorSamplers_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomBorderColorPropertiesEXT( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCustomBorderColorPropertiesEXT( VkPhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCustomBorderColorPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCustomBorderColorPropertiesEXT & operator=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCustomBorderColorPropertiesEXT & operator=( VkPhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceCustomBorderColorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCustomBorderColorPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCustomBorderColorPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCustomBorderColorPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxCustomBorderColorSamplers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCustomBorderColorPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxCustomBorderColorSamplers == rhs.maxCustomBorderColorSamplers ); +# endif + } + + bool operator!=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT; + void * pNext = {}; + uint32_t maxCustomBorderColorSamplers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCustomBorderColorPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCustomBorderColorPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceCustomResolveFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCustomResolveFeaturesEXT.html + struct PhysicalDeviceCustomResolveFeaturesEXT + { + using NativeType = VkPhysicalDeviceCustomResolveFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCustomResolveFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomResolveFeaturesEXT( Bool32 customResolve_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , customResolve{ customResolve_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomResolveFeaturesEXT( PhysicalDeviceCustomResolveFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceCustomResolveFeaturesEXT( VkPhysicalDeviceCustomResolveFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceCustomResolveFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceCustomResolveFeaturesEXT & operator=( PhysicalDeviceCustomResolveFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceCustomResolveFeaturesEXT & operator=( VkPhysicalDeviceCustomResolveFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomResolveFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomResolveFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomResolveFeaturesEXT & setCustomResolve( Bool32 customResolve_ ) & VULKAN_HPP_NOEXCEPT + { + customResolve = customResolve_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomResolveFeaturesEXT && setCustomResolve( Bool32 customResolve_ ) && VULKAN_HPP_NOEXCEPT + { + customResolve = customResolve_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceCustomResolveFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCustomResolveFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCustomResolveFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceCustomResolveFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, customResolve ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceCustomResolveFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceCustomResolveFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customResolve == rhs.customResolve ); +# endif + } + + bool operator!=( PhysicalDeviceCustomResolveFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceCustomResolveFeaturesEXT; + void * pNext = {}; + Bool32 customResolve = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceCustomResolveFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceCustomResolveFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDataGraphFeaturesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphFeaturesARM.html + struct PhysicalDeviceDataGraphFeaturesARM + { + using NativeType = VkPhysicalDeviceDataGraphFeaturesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDataGraphFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphFeaturesARM( Bool32 dataGraph_ = {}, + Bool32 dataGraphUpdateAfterBind_ = {}, + Bool32 dataGraphSpecializationConstants_ = {}, + Bool32 dataGraphDescriptorBuffer_ = {}, + Bool32 dataGraphShaderModule_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dataGraph{ dataGraph_ } + , dataGraphUpdateAfterBind{ dataGraphUpdateAfterBind_ } + , dataGraphSpecializationConstants{ dataGraphSpecializationConstants_ } + , dataGraphDescriptorBuffer{ dataGraphDescriptorBuffer_ } + , dataGraphShaderModule{ dataGraphShaderModule_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphFeaturesARM( PhysicalDeviceDataGraphFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDataGraphFeaturesARM( VkPhysicalDeviceDataGraphFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDataGraphFeaturesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDataGraphFeaturesARM & operator=( PhysicalDeviceDataGraphFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDataGraphFeaturesARM & operator=( VkPhysicalDeviceDataGraphFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setDataGraph( Bool32 dataGraph_ ) & VULKAN_HPP_NOEXCEPT + { + dataGraph = dataGraph_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setDataGraph( Bool32 dataGraph_ ) && VULKAN_HPP_NOEXCEPT + { + dataGraph = dataGraph_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setDataGraphUpdateAfterBind( Bool32 dataGraphUpdateAfterBind_ ) & VULKAN_HPP_NOEXCEPT + { + dataGraphUpdateAfterBind = dataGraphUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setDataGraphUpdateAfterBind( Bool32 dataGraphUpdateAfterBind_ ) && VULKAN_HPP_NOEXCEPT + { + dataGraphUpdateAfterBind = dataGraphUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setDataGraphSpecializationConstants( Bool32 dataGraphSpecializationConstants_ ) & + VULKAN_HPP_NOEXCEPT + { + dataGraphSpecializationConstants = dataGraphSpecializationConstants_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setDataGraphSpecializationConstants( Bool32 dataGraphSpecializationConstants_ ) && + VULKAN_HPP_NOEXCEPT + { + dataGraphSpecializationConstants = dataGraphSpecializationConstants_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setDataGraphDescriptorBuffer( Bool32 dataGraphDescriptorBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + dataGraphDescriptorBuffer = dataGraphDescriptorBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setDataGraphDescriptorBuffer( Bool32 dataGraphDescriptorBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + dataGraphDescriptorBuffer = dataGraphDescriptorBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setDataGraphShaderModule( Bool32 dataGraphShaderModule_ ) & VULKAN_HPP_NOEXCEPT + { + dataGraphShaderModule = dataGraphShaderModule_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setDataGraphShaderModule( Bool32 dataGraphShaderModule_ ) && VULKAN_HPP_NOEXCEPT + { + dataGraphShaderModule = dataGraphShaderModule_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDataGraphFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphFeaturesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphFeaturesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphFeaturesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataGraph, dataGraphUpdateAfterBind, dataGraphSpecializationConstants, dataGraphDescriptorBuffer, dataGraphShaderModule ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDataGraphFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceDataGraphFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataGraph == rhs.dataGraph ) && + ( dataGraphUpdateAfterBind == rhs.dataGraphUpdateAfterBind ) && ( dataGraphSpecializationConstants == rhs.dataGraphSpecializationConstants ) && + ( dataGraphDescriptorBuffer == rhs.dataGraphDescriptorBuffer ) && ( dataGraphShaderModule == rhs.dataGraphShaderModule ); +# endif + } + + bool operator!=( PhysicalDeviceDataGraphFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDataGraphFeaturesARM; + void * pNext = {}; + Bool32 dataGraph = {}; + Bool32 dataGraphUpdateAfterBind = {}; + Bool32 dataGraphSpecializationConstants = {}; + Bool32 dataGraphDescriptorBuffer = {}; + Bool32 dataGraphShaderModule = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDataGraphFeaturesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDataGraphFeaturesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceDataGraphModelFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphModelFeaturesQCOM.html + struct PhysicalDeviceDataGraphModelFeaturesQCOM + { + using NativeType = VkPhysicalDeviceDataGraphModelFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphModelFeaturesQCOM( Bool32 dataGraphModel_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dataGraphModel{ dataGraphModel_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphModelFeaturesQCOM( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDataGraphModelFeaturesQCOM( VkPhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDataGraphModelFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDataGraphModelFeaturesQCOM & operator=( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDataGraphModelFeaturesQCOM & operator=( VkPhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM & setDataGraphModel( Bool32 dataGraphModel_ ) & VULKAN_HPP_NOEXCEPT + { + dataGraphModel = dataGraphModel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM && setDataGraphModel( Bool32 dataGraphModel_ ) && VULKAN_HPP_NOEXCEPT + { + dataGraphModel = dataGraphModel_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDataGraphModelFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphModelFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphModelFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDataGraphModelFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataGraphModel ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDataGraphModelFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataGraphModel == rhs.dataGraphModel ); +# endif + } + + bool operator!=( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM; + void * pNext = {}; + Bool32 dataGraphModel = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDataGraphModelFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDataGraphModelFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html + struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV + { + using NativeType = VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( Bool32 dedicatedAllocationImageAliasing_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dedicatedAllocationImageAliasing{ dedicatedAllocationImageAliasing_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & + operator=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & + operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & + setDedicatedAllocationImageAliasing( Bool32 dedicatedAllocationImageAliasing_ ) & + VULKAN_HPP_NOEXCEPT + { + dedicatedAllocationImageAliasing = dedicatedAllocationImageAliasing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV && + setDedicatedAllocationImageAliasing( Bool32 dedicatedAllocationImageAliasing_ ) && + VULKAN_HPP_NOEXCEPT + { + dedicatedAllocationImageAliasing = dedicatedAllocationImageAliasing_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dedicatedAllocationImageAliasing ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocationImageAliasing == rhs.dedicatedAllocationImageAliasing ); +# endif + } + + bool operator!=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + void * pNext = {}; + Bool32 dedicatedAllocationImageAliasing = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX.html + struct PhysicalDeviceDenseGeometryFormatFeaturesAMDX + { + using NativeType = VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDenseGeometryFormatFeaturesAMDX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDenseGeometryFormatFeaturesAMDX( Bool32 denseGeometryFormat_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , denseGeometryFormat{ denseGeometryFormat_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDenseGeometryFormatFeaturesAMDX( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDenseGeometryFormatFeaturesAMDX( VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDenseGeometryFormatFeaturesAMDX( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDenseGeometryFormatFeaturesAMDX & operator=( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDenseGeometryFormatFeaturesAMDX & operator=( VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDenseGeometryFormatFeaturesAMDX & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDenseGeometryFormatFeaturesAMDX && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDenseGeometryFormatFeaturesAMDX & setDenseGeometryFormat( Bool32 denseGeometryFormat_ ) & VULKAN_HPP_NOEXCEPT + { + denseGeometryFormat = denseGeometryFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDenseGeometryFormatFeaturesAMDX && setDenseGeometryFormat( Bool32 denseGeometryFormat_ ) && VULKAN_HPP_NOEXCEPT + { + denseGeometryFormat = denseGeometryFormat_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, denseGeometryFormat ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & ) const = default; +# else + bool operator==( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( denseGeometryFormat == rhs.denseGeometryFormat ); +# endif + } + + bool operator!=( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDenseGeometryFormatFeaturesAMDX; + void * pNext = {}; + Bool32 denseGeometryFormat = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDenseGeometryFormatFeaturesAMDX; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDenseGeometryFormatFeaturesAMDX; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkPhysicalDeviceDepthBiasControlFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthBiasControlFeaturesEXT.html + struct PhysicalDeviceDepthBiasControlFeaturesEXT + { + using NativeType = VkPhysicalDeviceDepthBiasControlFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthBiasControlFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthBiasControlFeaturesEXT( Bool32 depthBiasControl_ = {}, + Bool32 leastRepresentableValueForceUnormRepresentation_ = {}, + Bool32 floatRepresentation_ = {}, + Bool32 depthBiasExact_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , depthBiasControl{ depthBiasControl_ } + , leastRepresentableValueForceUnormRepresentation{ leastRepresentableValueForceUnormRepresentation_ } + , floatRepresentation{ floatRepresentation_ } + , depthBiasExact{ depthBiasExact_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthBiasControlFeaturesEXT( PhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDepthBiasControlFeaturesEXT( VkPhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDepthBiasControlFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDepthBiasControlFeaturesEXT & operator=( PhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDepthBiasControlFeaturesEXT & operator=( VkPhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT & setDepthBiasControl( Bool32 depthBiasControl_ ) & VULKAN_HPP_NOEXCEPT + { + depthBiasControl = depthBiasControl_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT && setDepthBiasControl( Bool32 depthBiasControl_ ) && VULKAN_HPP_NOEXCEPT + { + depthBiasControl = depthBiasControl_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT & + setLeastRepresentableValueForceUnormRepresentation( Bool32 leastRepresentableValueForceUnormRepresentation_ ) & + VULKAN_HPP_NOEXCEPT + { + leastRepresentableValueForceUnormRepresentation = leastRepresentableValueForceUnormRepresentation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT && + setLeastRepresentableValueForceUnormRepresentation( Bool32 leastRepresentableValueForceUnormRepresentation_ ) && + VULKAN_HPP_NOEXCEPT + { + leastRepresentableValueForceUnormRepresentation = leastRepresentableValueForceUnormRepresentation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT & setFloatRepresentation( Bool32 floatRepresentation_ ) & VULKAN_HPP_NOEXCEPT + { + floatRepresentation = floatRepresentation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT && setFloatRepresentation( Bool32 floatRepresentation_ ) && VULKAN_HPP_NOEXCEPT + { + floatRepresentation = floatRepresentation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT & setDepthBiasExact( Bool32 depthBiasExact_ ) & VULKAN_HPP_NOEXCEPT + { + depthBiasExact = depthBiasExact_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT && setDepthBiasExact( Bool32 depthBiasExact_ ) && VULKAN_HPP_NOEXCEPT + { + depthBiasExact = depthBiasExact_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDepthBiasControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthBiasControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthBiasControlFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthBiasControlFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthBiasControl, leastRepresentableValueForceUnormRepresentation, floatRepresentation, depthBiasExact ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDepthBiasControlFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthBiasControl == rhs.depthBiasControl ) && + ( leastRepresentableValueForceUnormRepresentation == rhs.leastRepresentableValueForceUnormRepresentation ) && + ( floatRepresentation == rhs.floatRepresentation ) && ( depthBiasExact == rhs.depthBiasExact ); +# endif + } + + bool operator!=( PhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDepthBiasControlFeaturesEXT; + void * pNext = {}; + Bool32 depthBiasControl = {}; + Bool32 leastRepresentableValueForceUnormRepresentation = {}; + Bool32 floatRepresentation = {}; + Bool32 depthBiasExact = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDepthBiasControlFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDepthBiasControlFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDepthClampControlFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClampControlFeaturesEXT.html + struct PhysicalDeviceDepthClampControlFeaturesEXT + { + using NativeType = VkPhysicalDeviceDepthClampControlFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampControlFeaturesEXT( Bool32 depthClampControl_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , depthClampControl{ depthClampControl_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampControlFeaturesEXT( PhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDepthClampControlFeaturesEXT( VkPhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDepthClampControlFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDepthClampControlFeaturesEXT & operator=( PhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDepthClampControlFeaturesEXT & operator=( VkPhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampControlFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampControlFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampControlFeaturesEXT & setDepthClampControl( Bool32 depthClampControl_ ) & VULKAN_HPP_NOEXCEPT + { + depthClampControl = depthClampControl_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampControlFeaturesEXT && setDepthClampControl( Bool32 depthClampControl_ ) && VULKAN_HPP_NOEXCEPT + { + depthClampControl = depthClampControl_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDepthClampControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClampControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClampControlFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClampControlFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthClampControl ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDepthClampControlFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClampControl == rhs.depthClampControl ); +# endif + } + + bool operator!=( PhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT; + void * pNext = {}; + Bool32 depthClampControl = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDepthClampControlFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDepthClampControlFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.html + struct PhysicalDeviceDepthClampZeroOneFeaturesKHR + { + using NativeType = VkPhysicalDeviceDepthClampZeroOneFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampZeroOneFeaturesKHR( Bool32 depthClampZeroOne_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , depthClampZeroOne{ depthClampZeroOne_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampZeroOneFeaturesKHR( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDepthClampZeroOneFeaturesKHR( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDepthClampZeroOneFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDepthClampZeroOneFeaturesKHR & operator=( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDepthClampZeroOneFeaturesKHR & operator=( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesKHR & setDepthClampZeroOne( Bool32 depthClampZeroOne_ ) & VULKAN_HPP_NOEXCEPT + { + depthClampZeroOne = depthClampZeroOne_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesKHR && setDepthClampZeroOne( Bool32 depthClampZeroOne_ ) && VULKAN_HPP_NOEXCEPT + { + depthClampZeroOne = depthClampZeroOne_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClampZeroOneFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthClampZeroOne ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClampZeroOne == rhs.depthClampZeroOne ); +# endif + } + + bool operator!=( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR; + void * pNext = {}; + Bool32 depthClampZeroOne = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDepthClampZeroOneFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDepthClampZeroOneFeaturesKHR; + }; + + using PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR; + + // wrapper struct for struct VkPhysicalDeviceDepthClipControlFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClipControlFeaturesEXT.html + struct PhysicalDeviceDepthClipControlFeaturesEXT + { + using NativeType = VkPhysicalDeviceDepthClipControlFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClipControlFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipControlFeaturesEXT( Bool32 depthClipControl_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , depthClipControl{ depthClipControl_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipControlFeaturesEXT( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDepthClipControlFeaturesEXT( VkPhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDepthClipControlFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDepthClipControlFeaturesEXT & operator=( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDepthClipControlFeaturesEXT & operator=( VkPhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipControlFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipControlFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipControlFeaturesEXT & setDepthClipControl( Bool32 depthClipControl_ ) & VULKAN_HPP_NOEXCEPT + { + depthClipControl = depthClipControl_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipControlFeaturesEXT && setDepthClipControl( Bool32 depthClipControl_ ) && VULKAN_HPP_NOEXCEPT + { + depthClipControl = depthClipControl_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDepthClipControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClipControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClipControlFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClipControlFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthClipControl ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDepthClipControlFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipControl == rhs.depthClipControl ); +# endif + } + + bool operator!=( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDepthClipControlFeaturesEXT; + void * pNext = {}; + Bool32 depthClipControl = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDepthClipControlFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDepthClipControlFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDepthClipEnableFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html + struct PhysicalDeviceDepthClipEnableFeaturesEXT + { + using NativeType = VkPhysicalDeviceDepthClipEnableFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( Bool32 depthClipEnable_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , depthClipEnable{ depthClipEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDepthClipEnableFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDepthClipEnableFeaturesEXT & operator=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDepthClipEnableFeaturesEXT & operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipEnableFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipEnableFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipEnableFeaturesEXT & setDepthClipEnable( Bool32 depthClipEnable_ ) & VULKAN_HPP_NOEXCEPT + { + depthClipEnable = depthClipEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipEnableFeaturesEXT && setDepthClipEnable( Bool32 depthClipEnable_ ) && VULKAN_HPP_NOEXCEPT + { + depthClipEnable = depthClipEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClipEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthClipEnableFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthClipEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDepthClipEnableFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipEnable == rhs.depthClipEnable ); +# endif + } + + bool operator!=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; + void * pNext = {}; + Bool32 depthClipEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDepthClipEnableFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDepthClipEnableFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDepthStencilResolveProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html + struct PhysicalDeviceDepthStencilResolveProperties + { + using NativeType = VkPhysicalDeviceDepthStencilResolveProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthStencilResolveProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthStencilResolveProperties( ResolveModeFlags supportedDepthResolveModes_ = {}, + ResolveModeFlags supportedStencilResolveModes_ = {}, + Bool32 independentResolveNone_ = {}, + Bool32 independentResolve_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , supportedDepthResolveModes{ supportedDepthResolveModes_ } + , supportedStencilResolveModes{ supportedStencilResolveModes_ } + , independentResolveNone{ independentResolveNone_ } + , independentResolve{ independentResolve_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthStencilResolveProperties( PhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDepthStencilResolveProperties( VkPhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDepthStencilResolveProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDepthStencilResolveProperties & operator=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDepthStencilResolveProperties & operator=( VkPhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDepthStencilResolveProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthStencilResolveProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthStencilResolveProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDepthStencilResolveProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supportedDepthResolveModes, supportedStencilResolveModes, independentResolveNone, independentResolve ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDepthStencilResolveProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) && + ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) && ( independentResolveNone == rhs.independentResolveNone ) && + ( independentResolve == rhs.independentResolve ); +# endif + } + + bool operator!=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolveProperties; + void * pNext = {}; + ResolveModeFlags supportedDepthResolveModes = {}; + ResolveModeFlags supportedStencilResolveModes = {}; + Bool32 independentResolveNone = {}; + Bool32 independentResolve = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDepthStencilResolveProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDepthStencilResolveProperties; + }; + + using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties; + + // wrapper struct for struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.html + struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT + { + using NativeType = VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( size_t combinedImageSamplerDensityMapDescriptorSize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , combinedImageSamplerDensityMapDescriptorSize{ combinedImageSamplerDensityMapDescriptorSize_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT & + operator=( PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT & operator=( VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, combinedImageSamplerDensityMapDescriptorSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( combinedImageSamplerDensityMapDescriptorSize == rhs.combinedImageSamplerDensityMapDescriptorSize ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + void * pNext = {}; + size_t combinedImageSamplerDensityMapDescriptorSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDescriptorBufferFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferFeaturesEXT.html + struct PhysicalDeviceDescriptorBufferFeaturesEXT + { + using NativeType = VkPhysicalDeviceDescriptorBufferFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorBufferFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferFeaturesEXT( Bool32 descriptorBuffer_ = {}, + Bool32 descriptorBufferCaptureReplay_ = {}, + Bool32 descriptorBufferImageLayoutIgnored_ = {}, + Bool32 descriptorBufferPushDescriptors_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorBuffer{ descriptorBuffer_ } + , descriptorBufferCaptureReplay{ descriptorBufferCaptureReplay_ } + , descriptorBufferImageLayoutIgnored{ descriptorBufferImageLayoutIgnored_ } + , descriptorBufferPushDescriptors{ descriptorBufferPushDescriptors_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferFeaturesEXT( PhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorBufferFeaturesEXT( VkPhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorBufferFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorBufferFeaturesEXT & operator=( PhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorBufferFeaturesEXT & operator=( VkPhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT & setDescriptorBuffer( Bool32 descriptorBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorBuffer = descriptorBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT && setDescriptorBuffer( Bool32 descriptorBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorBuffer = descriptorBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT & setDescriptorBufferCaptureReplay( Bool32 descriptorBufferCaptureReplay_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBufferCaptureReplay = descriptorBufferCaptureReplay_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT && setDescriptorBufferCaptureReplay( Bool32 descriptorBufferCaptureReplay_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBufferCaptureReplay = descriptorBufferCaptureReplay_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT & setDescriptorBufferImageLayoutIgnored( Bool32 descriptorBufferImageLayoutIgnored_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBufferImageLayoutIgnored = descriptorBufferImageLayoutIgnored_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT && setDescriptorBufferImageLayoutIgnored( Bool32 descriptorBufferImageLayoutIgnored_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBufferImageLayoutIgnored = descriptorBufferImageLayoutIgnored_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT & setDescriptorBufferPushDescriptors( Bool32 descriptorBufferPushDescriptors_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBufferPushDescriptors = descriptorBufferPushDescriptors_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT && setDescriptorBufferPushDescriptors( Bool32 descriptorBufferPushDescriptors_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBufferPushDescriptors = descriptorBufferPushDescriptors_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDescriptorBufferFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorBuffer, descriptorBufferCaptureReplay, descriptorBufferImageLayoutIgnored, descriptorBufferPushDescriptors ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorBufferFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorBuffer == rhs.descriptorBuffer ) && + ( descriptorBufferCaptureReplay == rhs.descriptorBufferCaptureReplay ) && + ( descriptorBufferImageLayoutIgnored == rhs.descriptorBufferImageLayoutIgnored ) && + ( descriptorBufferPushDescriptors == rhs.descriptorBufferPushDescriptors ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorBufferFeaturesEXT; + void * pNext = {}; + Bool32 descriptorBuffer = {}; + Bool32 descriptorBufferCaptureReplay = {}; + Bool32 descriptorBufferImageLayoutIgnored = {}; + Bool32 descriptorBufferPushDescriptors = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorBufferFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorBufferFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDescriptorBufferPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferPropertiesEXT.html + struct PhysicalDeviceDescriptorBufferPropertiesEXT + { + using NativeType = VkPhysicalDeviceDescriptorBufferPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorBufferPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferPropertiesEXT( Bool32 combinedImageSamplerDescriptorSingleArray_ = {}, + Bool32 bufferlessPushDescriptors_ = {}, + Bool32 allowSamplerImageViewPostSubmitCreation_ = {}, + DeviceSize descriptorBufferOffsetAlignment_ = {}, + uint32_t maxDescriptorBufferBindings_ = {}, + uint32_t maxResourceDescriptorBufferBindings_ = {}, + uint32_t maxSamplerDescriptorBufferBindings_ = {}, + uint32_t maxEmbeddedImmutableSamplerBindings_ = {}, + uint32_t maxEmbeddedImmutableSamplers_ = {}, + size_t bufferCaptureReplayDescriptorDataSize_ = {}, + size_t imageCaptureReplayDescriptorDataSize_ = {}, + size_t imageViewCaptureReplayDescriptorDataSize_ = {}, + size_t samplerCaptureReplayDescriptorDataSize_ = {}, + size_t accelerationStructureCaptureReplayDescriptorDataSize_ = {}, + size_t samplerDescriptorSize_ = {}, + size_t combinedImageSamplerDescriptorSize_ = {}, + size_t sampledImageDescriptorSize_ = {}, + size_t storageImageDescriptorSize_ = {}, + size_t uniformTexelBufferDescriptorSize_ = {}, + size_t robustUniformTexelBufferDescriptorSize_ = {}, + size_t storageTexelBufferDescriptorSize_ = {}, + size_t robustStorageTexelBufferDescriptorSize_ = {}, + size_t uniformBufferDescriptorSize_ = {}, + size_t robustUniformBufferDescriptorSize_ = {}, + size_t storageBufferDescriptorSize_ = {}, + size_t robustStorageBufferDescriptorSize_ = {}, + size_t inputAttachmentDescriptorSize_ = {}, + size_t accelerationStructureDescriptorSize_ = {}, + DeviceSize maxSamplerDescriptorBufferRange_ = {}, + DeviceSize maxResourceDescriptorBufferRange_ = {}, + DeviceSize samplerDescriptorBufferAddressSpaceSize_ = {}, + DeviceSize resourceDescriptorBufferAddressSpaceSize_ = {}, + DeviceSize descriptorBufferAddressSpaceSize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , combinedImageSamplerDescriptorSingleArray{ combinedImageSamplerDescriptorSingleArray_ } + , bufferlessPushDescriptors{ bufferlessPushDescriptors_ } + , allowSamplerImageViewPostSubmitCreation{ allowSamplerImageViewPostSubmitCreation_ } + , descriptorBufferOffsetAlignment{ descriptorBufferOffsetAlignment_ } + , maxDescriptorBufferBindings{ maxDescriptorBufferBindings_ } + , maxResourceDescriptorBufferBindings{ maxResourceDescriptorBufferBindings_ } + , maxSamplerDescriptorBufferBindings{ maxSamplerDescriptorBufferBindings_ } + , maxEmbeddedImmutableSamplerBindings{ maxEmbeddedImmutableSamplerBindings_ } + , maxEmbeddedImmutableSamplers{ maxEmbeddedImmutableSamplers_ } + , bufferCaptureReplayDescriptorDataSize{ bufferCaptureReplayDescriptorDataSize_ } + , imageCaptureReplayDescriptorDataSize{ imageCaptureReplayDescriptorDataSize_ } + , imageViewCaptureReplayDescriptorDataSize{ imageViewCaptureReplayDescriptorDataSize_ } + , samplerCaptureReplayDescriptorDataSize{ samplerCaptureReplayDescriptorDataSize_ } + , accelerationStructureCaptureReplayDescriptorDataSize{ accelerationStructureCaptureReplayDescriptorDataSize_ } + , samplerDescriptorSize{ samplerDescriptorSize_ } + , combinedImageSamplerDescriptorSize{ combinedImageSamplerDescriptorSize_ } + , sampledImageDescriptorSize{ sampledImageDescriptorSize_ } + , storageImageDescriptorSize{ storageImageDescriptorSize_ } + , uniformTexelBufferDescriptorSize{ uniformTexelBufferDescriptorSize_ } + , robustUniformTexelBufferDescriptorSize{ robustUniformTexelBufferDescriptorSize_ } + , storageTexelBufferDescriptorSize{ storageTexelBufferDescriptorSize_ } + , robustStorageTexelBufferDescriptorSize{ robustStorageTexelBufferDescriptorSize_ } + , uniformBufferDescriptorSize{ uniformBufferDescriptorSize_ } + , robustUniformBufferDescriptorSize{ robustUniformBufferDescriptorSize_ } + , storageBufferDescriptorSize{ storageBufferDescriptorSize_ } + , robustStorageBufferDescriptorSize{ robustStorageBufferDescriptorSize_ } + , inputAttachmentDescriptorSize{ inputAttachmentDescriptorSize_ } + , accelerationStructureDescriptorSize{ accelerationStructureDescriptorSize_ } + , maxSamplerDescriptorBufferRange{ maxSamplerDescriptorBufferRange_ } + , maxResourceDescriptorBufferRange{ maxResourceDescriptorBufferRange_ } + , samplerDescriptorBufferAddressSpaceSize{ samplerDescriptorBufferAddressSpaceSize_ } + , resourceDescriptorBufferAddressSpaceSize{ resourceDescriptorBufferAddressSpaceSize_ } + , descriptorBufferAddressSpaceSize{ descriptorBufferAddressSpaceSize_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferPropertiesEXT( PhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorBufferPropertiesEXT( VkPhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorBufferPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorBufferPropertiesEXT & operator=( PhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorBufferPropertiesEXT & operator=( VkPhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDescriptorBufferPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + combinedImageSamplerDescriptorSingleArray, + bufferlessPushDescriptors, + allowSamplerImageViewPostSubmitCreation, + descriptorBufferOffsetAlignment, + maxDescriptorBufferBindings, + maxResourceDescriptorBufferBindings, + maxSamplerDescriptorBufferBindings, + maxEmbeddedImmutableSamplerBindings, + maxEmbeddedImmutableSamplers, + bufferCaptureReplayDescriptorDataSize, + imageCaptureReplayDescriptorDataSize, + imageViewCaptureReplayDescriptorDataSize, + samplerCaptureReplayDescriptorDataSize, + accelerationStructureCaptureReplayDescriptorDataSize, + samplerDescriptorSize, + combinedImageSamplerDescriptorSize, + sampledImageDescriptorSize, + storageImageDescriptorSize, + uniformTexelBufferDescriptorSize, + robustUniformTexelBufferDescriptorSize, + storageTexelBufferDescriptorSize, + robustStorageTexelBufferDescriptorSize, + uniformBufferDescriptorSize, + robustUniformBufferDescriptorSize, + storageBufferDescriptorSize, + robustStorageBufferDescriptorSize, + inputAttachmentDescriptorSize, + accelerationStructureDescriptorSize, + maxSamplerDescriptorBufferRange, + maxResourceDescriptorBufferRange, + samplerDescriptorBufferAddressSpaceSize, + resourceDescriptorBufferAddressSpaceSize, + descriptorBufferAddressSpaceSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorBufferPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( combinedImageSamplerDescriptorSingleArray == rhs.combinedImageSamplerDescriptorSingleArray ) && + ( bufferlessPushDescriptors == rhs.bufferlessPushDescriptors ) && + ( allowSamplerImageViewPostSubmitCreation == rhs.allowSamplerImageViewPostSubmitCreation ) && + ( descriptorBufferOffsetAlignment == rhs.descriptorBufferOffsetAlignment ) && ( maxDescriptorBufferBindings == rhs.maxDescriptorBufferBindings ) && + ( maxResourceDescriptorBufferBindings == rhs.maxResourceDescriptorBufferBindings ) && + ( maxSamplerDescriptorBufferBindings == rhs.maxSamplerDescriptorBufferBindings ) && + ( maxEmbeddedImmutableSamplerBindings == rhs.maxEmbeddedImmutableSamplerBindings ) && + ( maxEmbeddedImmutableSamplers == rhs.maxEmbeddedImmutableSamplers ) && + ( bufferCaptureReplayDescriptorDataSize == rhs.bufferCaptureReplayDescriptorDataSize ) && + ( imageCaptureReplayDescriptorDataSize == rhs.imageCaptureReplayDescriptorDataSize ) && + ( imageViewCaptureReplayDescriptorDataSize == rhs.imageViewCaptureReplayDescriptorDataSize ) && + ( samplerCaptureReplayDescriptorDataSize == rhs.samplerCaptureReplayDescriptorDataSize ) && + ( accelerationStructureCaptureReplayDescriptorDataSize == rhs.accelerationStructureCaptureReplayDescriptorDataSize ) && + ( samplerDescriptorSize == rhs.samplerDescriptorSize ) && ( combinedImageSamplerDescriptorSize == rhs.combinedImageSamplerDescriptorSize ) && + ( sampledImageDescriptorSize == rhs.sampledImageDescriptorSize ) && ( storageImageDescriptorSize == rhs.storageImageDescriptorSize ) && + ( uniformTexelBufferDescriptorSize == rhs.uniformTexelBufferDescriptorSize ) && + ( robustUniformTexelBufferDescriptorSize == rhs.robustUniformTexelBufferDescriptorSize ) && + ( storageTexelBufferDescriptorSize == rhs.storageTexelBufferDescriptorSize ) && + ( robustStorageTexelBufferDescriptorSize == rhs.robustStorageTexelBufferDescriptorSize ) && + ( uniformBufferDescriptorSize == rhs.uniformBufferDescriptorSize ) && + ( robustUniformBufferDescriptorSize == rhs.robustUniformBufferDescriptorSize ) && + ( storageBufferDescriptorSize == rhs.storageBufferDescriptorSize ) && + ( robustStorageBufferDescriptorSize == rhs.robustStorageBufferDescriptorSize ) && + ( inputAttachmentDescriptorSize == rhs.inputAttachmentDescriptorSize ) && + ( accelerationStructureDescriptorSize == rhs.accelerationStructureDescriptorSize ) && + ( maxSamplerDescriptorBufferRange == rhs.maxSamplerDescriptorBufferRange ) && + ( maxResourceDescriptorBufferRange == rhs.maxResourceDescriptorBufferRange ) && + ( samplerDescriptorBufferAddressSpaceSize == rhs.samplerDescriptorBufferAddressSpaceSize ) && + ( resourceDescriptorBufferAddressSpaceSize == rhs.resourceDescriptorBufferAddressSpaceSize ) && + ( descriptorBufferAddressSpaceSize == rhs.descriptorBufferAddressSpaceSize ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorBufferPropertiesEXT; + void * pNext = {}; + Bool32 combinedImageSamplerDescriptorSingleArray = {}; + Bool32 bufferlessPushDescriptors = {}; + Bool32 allowSamplerImageViewPostSubmitCreation = {}; + DeviceSize descriptorBufferOffsetAlignment = {}; + uint32_t maxDescriptorBufferBindings = {}; + uint32_t maxResourceDescriptorBufferBindings = {}; + uint32_t maxSamplerDescriptorBufferBindings = {}; + uint32_t maxEmbeddedImmutableSamplerBindings = {}; + uint32_t maxEmbeddedImmutableSamplers = {}; + size_t bufferCaptureReplayDescriptorDataSize = {}; + size_t imageCaptureReplayDescriptorDataSize = {}; + size_t imageViewCaptureReplayDescriptorDataSize = {}; + size_t samplerCaptureReplayDescriptorDataSize = {}; + size_t accelerationStructureCaptureReplayDescriptorDataSize = {}; + size_t samplerDescriptorSize = {}; + size_t combinedImageSamplerDescriptorSize = {}; + size_t sampledImageDescriptorSize = {}; + size_t storageImageDescriptorSize = {}; + size_t uniformTexelBufferDescriptorSize = {}; + size_t robustUniformTexelBufferDescriptorSize = {}; + size_t storageTexelBufferDescriptorSize = {}; + size_t robustStorageTexelBufferDescriptorSize = {}; + size_t uniformBufferDescriptorSize = {}; + size_t robustUniformBufferDescriptorSize = {}; + size_t storageBufferDescriptorSize = {}; + size_t robustStorageBufferDescriptorSize = {}; + size_t inputAttachmentDescriptorSize = {}; + size_t accelerationStructureDescriptorSize = {}; + DeviceSize maxSamplerDescriptorBufferRange = {}; + DeviceSize maxResourceDescriptorBufferRange = {}; + DeviceSize samplerDescriptorBufferAddressSpaceSize = {}; + DeviceSize resourceDescriptorBufferAddressSpaceSize = {}; + DeviceSize descriptorBufferAddressSpaceSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorBufferPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorBufferPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferTensorFeaturesARM.html + struct PhysicalDeviceDescriptorBufferTensorFeaturesARM + { + using NativeType = VkPhysicalDeviceDescriptorBufferTensorFeaturesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorBufferTensorFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferTensorFeaturesARM( Bool32 descriptorBufferTensorDescriptors_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorBufferTensorDescriptors{ descriptorBufferTensorDescriptors_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDescriptorBufferTensorFeaturesARM( PhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorBufferTensorFeaturesARM( VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorBufferTensorFeaturesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorBufferTensorFeaturesARM & operator=( PhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorBufferTensorFeaturesARM & operator=( VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorFeaturesARM & + setDescriptorBufferTensorDescriptors( Bool32 descriptorBufferTensorDescriptors_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBufferTensorDescriptors = descriptorBufferTensorDescriptors_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorFeaturesARM && + setDescriptorBufferTensorDescriptors( Bool32 descriptorBufferTensorDescriptors_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBufferTensorDescriptors = descriptorBufferTensorDescriptors_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferTensorFeaturesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorBufferTensorDescriptors ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorBufferTensorFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorBufferTensorDescriptors == rhs.descriptorBufferTensorDescriptors ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorBufferTensorFeaturesARM; + void * pNext = {}; + Bool32 descriptorBufferTensorDescriptors = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorBufferTensorFeaturesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorBufferTensorFeaturesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferTensorPropertiesARM.html + struct PhysicalDeviceDescriptorBufferTensorPropertiesARM + { + using NativeType = VkPhysicalDeviceDescriptorBufferTensorPropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorBufferTensorPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferTensorPropertiesARM( size_t tensorCaptureReplayDescriptorDataSize_ = {}, + size_t tensorViewCaptureReplayDescriptorDataSize_ = {}, + size_t tensorDescriptorSize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensorCaptureReplayDescriptorDataSize{ tensorCaptureReplayDescriptorDataSize_ } + , tensorViewCaptureReplayDescriptorDataSize{ tensorViewCaptureReplayDescriptorDataSize_ } + , tensorDescriptorSize{ tensorDescriptorSize_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDescriptorBufferTensorPropertiesARM( PhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorBufferTensorPropertiesARM( VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorBufferTensorPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorBufferTensorPropertiesARM & + operator=( PhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorBufferTensorPropertiesARM & operator=( VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM & + setTensorCaptureReplayDescriptorDataSize( size_t tensorCaptureReplayDescriptorDataSize_ ) & + VULKAN_HPP_NOEXCEPT + { + tensorCaptureReplayDescriptorDataSize = tensorCaptureReplayDescriptorDataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM && + setTensorCaptureReplayDescriptorDataSize( size_t tensorCaptureReplayDescriptorDataSize_ ) && + VULKAN_HPP_NOEXCEPT + { + tensorCaptureReplayDescriptorDataSize = tensorCaptureReplayDescriptorDataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM & + setTensorViewCaptureReplayDescriptorDataSize( size_t tensorViewCaptureReplayDescriptorDataSize_ ) & + VULKAN_HPP_NOEXCEPT + { + tensorViewCaptureReplayDescriptorDataSize = tensorViewCaptureReplayDescriptorDataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM && + setTensorViewCaptureReplayDescriptorDataSize( size_t tensorViewCaptureReplayDescriptorDataSize_ ) && + VULKAN_HPP_NOEXCEPT + { + tensorViewCaptureReplayDescriptorDataSize = tensorViewCaptureReplayDescriptorDataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM & setTensorDescriptorSize( size_t tensorDescriptorSize_ ) & VULKAN_HPP_NOEXCEPT + { + tensorDescriptorSize = tensorDescriptorSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM && setTensorDescriptorSize( size_t tensorDescriptorSize_ ) && VULKAN_HPP_NOEXCEPT + { + tensorDescriptorSize = tensorDescriptorSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferTensorPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tensorCaptureReplayDescriptorDataSize, tensorViewCaptureReplayDescriptorDataSize, tensorDescriptorSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorBufferTensorPropertiesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorCaptureReplayDescriptorDataSize == rhs.tensorCaptureReplayDescriptorDataSize ) && + ( tensorViewCaptureReplayDescriptorDataSize == rhs.tensorViewCaptureReplayDescriptorDataSize ) && + ( tensorDescriptorSize == rhs.tensorDescriptorSize ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorBufferTensorPropertiesARM; + void * pNext = {}; + size_t tensorCaptureReplayDescriptorDataSize = {}; + size_t tensorViewCaptureReplayDescriptorDataSize = {}; + size_t tensorDescriptorSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorBufferTensorPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorBufferTensorPropertiesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceDescriptorHeapFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorHeapFeaturesEXT.html + struct PhysicalDeviceDescriptorHeapFeaturesEXT + { + using NativeType = VkPhysicalDeviceDescriptorHeapFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorHeapFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorHeapFeaturesEXT( Bool32 descriptorHeap_ = {}, + Bool32 descriptorHeapCaptureReplay_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorHeap{ descriptorHeap_ } + , descriptorHeapCaptureReplay{ descriptorHeapCaptureReplay_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorHeapFeaturesEXT( PhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorHeapFeaturesEXT( VkPhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorHeapFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorHeapFeaturesEXT & operator=( PhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorHeapFeaturesEXT & operator=( VkPhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT & setDescriptorHeap( Bool32 descriptorHeap_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorHeap = descriptorHeap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT && setDescriptorHeap( Bool32 descriptorHeap_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorHeap = descriptorHeap_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT & setDescriptorHeapCaptureReplay( Bool32 descriptorHeapCaptureReplay_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorHeapCaptureReplay = descriptorHeapCaptureReplay_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT && setDescriptorHeapCaptureReplay( Bool32 descriptorHeapCaptureReplay_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorHeapCaptureReplay = descriptorHeapCaptureReplay_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDescriptorHeapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorHeapFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorHeapFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorHeapFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorHeap, descriptorHeapCaptureReplay ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorHeapFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorHeap == rhs.descriptorHeap ) && + ( descriptorHeapCaptureReplay == rhs.descriptorHeapCaptureReplay ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorHeapFeaturesEXT; + void * pNext = {}; + Bool32 descriptorHeap = {}; + Bool32 descriptorHeapCaptureReplay = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorHeapFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorHeapFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDescriptorHeapPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorHeapPropertiesEXT.html + struct PhysicalDeviceDescriptorHeapPropertiesEXT + { + using NativeType = VkPhysicalDeviceDescriptorHeapPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorHeapPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorHeapPropertiesEXT( DeviceSize samplerHeapAlignment_ = {}, + DeviceSize resourceHeapAlignment_ = {}, + DeviceSize maxSamplerHeapSize_ = {}, + DeviceSize maxResourceHeapSize_ = {}, + DeviceSize minSamplerHeapReservedRange_ = {}, + DeviceSize minSamplerHeapReservedRangeWithEmbedded_ = {}, + DeviceSize minResourceHeapReservedRange_ = {}, + DeviceSize samplerDescriptorSize_ = {}, + DeviceSize imageDescriptorSize_ = {}, + DeviceSize bufferDescriptorSize_ = {}, + DeviceSize samplerDescriptorAlignment_ = {}, + DeviceSize imageDescriptorAlignment_ = {}, + DeviceSize bufferDescriptorAlignment_ = {}, + DeviceSize maxPushDataSize_ = {}, + size_t imageCaptureReplayOpaqueDataSize_ = {}, + uint32_t maxDescriptorHeapEmbeddedSamplers_ = {}, + uint32_t samplerYcbcrConversionCount_ = {}, + Bool32 sparseDescriptorHeaps_ = {}, + Bool32 protectedDescriptorHeaps_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , samplerHeapAlignment{ samplerHeapAlignment_ } + , resourceHeapAlignment{ resourceHeapAlignment_ } + , maxSamplerHeapSize{ maxSamplerHeapSize_ } + , maxResourceHeapSize{ maxResourceHeapSize_ } + , minSamplerHeapReservedRange{ minSamplerHeapReservedRange_ } + , minSamplerHeapReservedRangeWithEmbedded{ minSamplerHeapReservedRangeWithEmbedded_ } + , minResourceHeapReservedRange{ minResourceHeapReservedRange_ } + , samplerDescriptorSize{ samplerDescriptorSize_ } + , imageDescriptorSize{ imageDescriptorSize_ } + , bufferDescriptorSize{ bufferDescriptorSize_ } + , samplerDescriptorAlignment{ samplerDescriptorAlignment_ } + , imageDescriptorAlignment{ imageDescriptorAlignment_ } + , bufferDescriptorAlignment{ bufferDescriptorAlignment_ } + , maxPushDataSize{ maxPushDataSize_ } + , imageCaptureReplayOpaqueDataSize{ imageCaptureReplayOpaqueDataSize_ } + , maxDescriptorHeapEmbeddedSamplers{ maxDescriptorHeapEmbeddedSamplers_ } + , samplerYcbcrConversionCount{ samplerYcbcrConversionCount_ } + , sparseDescriptorHeaps{ sparseDescriptorHeaps_ } + , protectedDescriptorHeaps{ protectedDescriptorHeaps_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorHeapPropertiesEXT( PhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorHeapPropertiesEXT( VkPhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorHeapPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorHeapPropertiesEXT & operator=( PhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorHeapPropertiesEXT & operator=( VkPhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDescriptorHeapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorHeapPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorHeapPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorHeapPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + samplerHeapAlignment, + resourceHeapAlignment, + maxSamplerHeapSize, + maxResourceHeapSize, + minSamplerHeapReservedRange, + minSamplerHeapReservedRangeWithEmbedded, + minResourceHeapReservedRange, + samplerDescriptorSize, + imageDescriptorSize, + bufferDescriptorSize, + samplerDescriptorAlignment, + imageDescriptorAlignment, + bufferDescriptorAlignment, + maxPushDataSize, + imageCaptureReplayOpaqueDataSize, + maxDescriptorHeapEmbeddedSamplers, + samplerYcbcrConversionCount, + sparseDescriptorHeaps, + protectedDescriptorHeaps ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorHeapPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( samplerHeapAlignment == rhs.samplerHeapAlignment ) && + ( resourceHeapAlignment == rhs.resourceHeapAlignment ) && ( maxSamplerHeapSize == rhs.maxSamplerHeapSize ) && + ( maxResourceHeapSize == rhs.maxResourceHeapSize ) && ( minSamplerHeapReservedRange == rhs.minSamplerHeapReservedRange ) && + ( minSamplerHeapReservedRangeWithEmbedded == rhs.minSamplerHeapReservedRangeWithEmbedded ) && + ( minResourceHeapReservedRange == rhs.minResourceHeapReservedRange ) && ( samplerDescriptorSize == rhs.samplerDescriptorSize ) && + ( imageDescriptorSize == rhs.imageDescriptorSize ) && ( bufferDescriptorSize == rhs.bufferDescriptorSize ) && + ( samplerDescriptorAlignment == rhs.samplerDescriptorAlignment ) && ( imageDescriptorAlignment == rhs.imageDescriptorAlignment ) && + ( bufferDescriptorAlignment == rhs.bufferDescriptorAlignment ) && ( maxPushDataSize == rhs.maxPushDataSize ) && + ( imageCaptureReplayOpaqueDataSize == rhs.imageCaptureReplayOpaqueDataSize ) && + ( maxDescriptorHeapEmbeddedSamplers == rhs.maxDescriptorHeapEmbeddedSamplers ) && + ( samplerYcbcrConversionCount == rhs.samplerYcbcrConversionCount ) && ( sparseDescriptorHeaps == rhs.sparseDescriptorHeaps ) && + ( protectedDescriptorHeaps == rhs.protectedDescriptorHeaps ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorHeapPropertiesEXT; + void * pNext = {}; + DeviceSize samplerHeapAlignment = {}; + DeviceSize resourceHeapAlignment = {}; + DeviceSize maxSamplerHeapSize = {}; + DeviceSize maxResourceHeapSize = {}; + DeviceSize minSamplerHeapReservedRange = {}; + DeviceSize minSamplerHeapReservedRangeWithEmbedded = {}; + DeviceSize minResourceHeapReservedRange = {}; + DeviceSize samplerDescriptorSize = {}; + DeviceSize imageDescriptorSize = {}; + DeviceSize bufferDescriptorSize = {}; + DeviceSize samplerDescriptorAlignment = {}; + DeviceSize imageDescriptorAlignment = {}; + DeviceSize bufferDescriptorAlignment = {}; + DeviceSize maxPushDataSize = {}; + size_t imageCaptureReplayOpaqueDataSize = {}; + uint32_t maxDescriptorHeapEmbeddedSamplers = {}; + uint32_t samplerYcbcrConversionCount = {}; + Bool32 sparseDescriptorHeaps = {}; + Bool32 protectedDescriptorHeaps = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorHeapPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorHeapPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDescriptorHeapTensorPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorHeapTensorPropertiesARM.html + struct PhysicalDeviceDescriptorHeapTensorPropertiesARM + { + using NativeType = VkPhysicalDeviceDescriptorHeapTensorPropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorHeapTensorPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorHeapTensorPropertiesARM( DeviceSize tensorDescriptorSize_ = {}, + DeviceSize tensorDescriptorAlignment_ = {}, + size_t tensorCaptureReplayOpaqueDataSize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensorDescriptorSize{ tensorDescriptorSize_ } + , tensorDescriptorAlignment{ tensorDescriptorAlignment_ } + , tensorCaptureReplayOpaqueDataSize{ tensorCaptureReplayOpaqueDataSize_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDescriptorHeapTensorPropertiesARM( PhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorHeapTensorPropertiesARM( VkPhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorHeapTensorPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorHeapTensorPropertiesARM & operator=( PhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorHeapTensorPropertiesARM & operator=( VkPhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDescriptorHeapTensorPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorHeapTensorPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorHeapTensorPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorHeapTensorPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tensorDescriptorSize, tensorDescriptorAlignment, tensorCaptureReplayOpaqueDataSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorHeapTensorPropertiesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorDescriptorSize == rhs.tensorDescriptorSize ) && + ( tensorDescriptorAlignment == rhs.tensorDescriptorAlignment ) && ( tensorCaptureReplayOpaqueDataSize == rhs.tensorCaptureReplayOpaqueDataSize ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorHeapTensorPropertiesARM; + void * pNext = {}; + DeviceSize tensorDescriptorSize = {}; + DeviceSize tensorDescriptorAlignment = {}; + size_t tensorCaptureReplayOpaqueDataSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorHeapTensorPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorHeapTensorPropertiesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceDescriptorIndexingFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html + struct PhysicalDeviceDescriptorIndexingFeatures + { + using NativeType = VkPhysicalDeviceDescriptorIndexingFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorIndexingFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeatures( Bool32 shaderInputAttachmentArrayDynamicIndexing_ = {}, + Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = {}, + Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = {}, + Bool32 shaderUniformBufferArrayNonUniformIndexing_ = {}, + Bool32 shaderSampledImageArrayNonUniformIndexing_ = {}, + Bool32 shaderStorageBufferArrayNonUniformIndexing_ = {}, + Bool32 shaderStorageImageArrayNonUniformIndexing_ = {}, + Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = {}, + Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = {}, + Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = {}, + Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = {}, + Bool32 descriptorBindingSampledImageUpdateAfterBind_ = {}, + Bool32 descriptorBindingStorageImageUpdateAfterBind_ = {}, + Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = {}, + Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = {}, + Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = {}, + Bool32 descriptorBindingUpdateUnusedWhilePending_ = {}, + Bool32 descriptorBindingPartiallyBound_ = {}, + Bool32 descriptorBindingVariableDescriptorCount_ = {}, + Bool32 runtimeDescriptorArray_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderInputAttachmentArrayDynamicIndexing{ shaderInputAttachmentArrayDynamicIndexing_ } + , shaderUniformTexelBufferArrayDynamicIndexing{ shaderUniformTexelBufferArrayDynamicIndexing_ } + , shaderStorageTexelBufferArrayDynamicIndexing{ shaderStorageTexelBufferArrayDynamicIndexing_ } + , shaderUniformBufferArrayNonUniformIndexing{ shaderUniformBufferArrayNonUniformIndexing_ } + , shaderSampledImageArrayNonUniformIndexing{ shaderSampledImageArrayNonUniformIndexing_ } + , shaderStorageBufferArrayNonUniformIndexing{ shaderStorageBufferArrayNonUniformIndexing_ } + , shaderStorageImageArrayNonUniformIndexing{ shaderStorageImageArrayNonUniformIndexing_ } + , shaderInputAttachmentArrayNonUniformIndexing{ shaderInputAttachmentArrayNonUniformIndexing_ } + , shaderUniformTexelBufferArrayNonUniformIndexing{ shaderUniformTexelBufferArrayNonUniformIndexing_ } + , shaderStorageTexelBufferArrayNonUniformIndexing{ shaderStorageTexelBufferArrayNonUniformIndexing_ } + , descriptorBindingUniformBufferUpdateAfterBind{ descriptorBindingUniformBufferUpdateAfterBind_ } + , descriptorBindingSampledImageUpdateAfterBind{ descriptorBindingSampledImageUpdateAfterBind_ } + , descriptorBindingStorageImageUpdateAfterBind{ descriptorBindingStorageImageUpdateAfterBind_ } + , descriptorBindingStorageBufferUpdateAfterBind{ descriptorBindingStorageBufferUpdateAfterBind_ } + , descriptorBindingUniformTexelBufferUpdateAfterBind{ descriptorBindingUniformTexelBufferUpdateAfterBind_ } + , descriptorBindingStorageTexelBufferUpdateAfterBind{ descriptorBindingStorageTexelBufferUpdateAfterBind_ } + , descriptorBindingUpdateUnusedWhilePending{ descriptorBindingUpdateUnusedWhilePending_ } + , descriptorBindingPartiallyBound{ descriptorBindingPartiallyBound_ } + , descriptorBindingVariableDescriptorCount{ descriptorBindingVariableDescriptorCount_ } + , runtimeDescriptorArray{ runtimeDescriptorArray_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeatures( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorIndexingFeatures( VkPhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorIndexingFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorIndexingFeatures & operator=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorIndexingFeatures & operator=( VkPhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & + setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && + setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ ) & VULKAN_HPP_NOEXCEPT + { + runtimeDescriptorArray = runtimeDescriptorArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ ) && VULKAN_HPP_NOEXCEPT + { + runtimeDescriptorArray = runtimeDescriptorArray_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDescriptorIndexingFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorIndexingFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorIndexingFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorIndexingFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderInputAttachmentArrayDynamicIndexing, + shaderUniformTexelBufferArrayDynamicIndexing, + shaderStorageTexelBufferArrayDynamicIndexing, + shaderUniformBufferArrayNonUniformIndexing, + shaderSampledImageArrayNonUniformIndexing, + shaderStorageBufferArrayNonUniformIndexing, + shaderStorageImageArrayNonUniformIndexing, + shaderInputAttachmentArrayNonUniformIndexing, + shaderUniformTexelBufferArrayNonUniformIndexing, + shaderStorageTexelBufferArrayNonUniformIndexing, + descriptorBindingUniformBufferUpdateAfterBind, + descriptorBindingSampledImageUpdateAfterBind, + descriptorBindingStorageImageUpdateAfterBind, + descriptorBindingStorageBufferUpdateAfterBind, + descriptorBindingUniformTexelBufferUpdateAfterBind, + descriptorBindingStorageTexelBufferUpdateAfterBind, + descriptorBindingUpdateUnusedWhilePending, + descriptorBindingPartiallyBound, + descriptorBindingVariableDescriptorCount, + runtimeDescriptorArray ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorIndexingFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) && + ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) && + ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) && + ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) && + ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) && + ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) && + ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) && + ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) && + ( shaderUniformTexelBufferArrayNonUniformIndexing == rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) && + ( shaderStorageTexelBufferArrayNonUniformIndexing == rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) && + ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) && + ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) && + ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) && + ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) && + ( descriptorBindingUniformTexelBufferUpdateAfterBind == rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) && + ( descriptorBindingStorageTexelBufferUpdateAfterBind == rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) && + ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) && + ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) && + ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) && + ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeatures; + void * pNext = {}; + Bool32 shaderInputAttachmentArrayDynamicIndexing = {}; + Bool32 shaderUniformTexelBufferArrayDynamicIndexing = {}; + Bool32 shaderStorageTexelBufferArrayDynamicIndexing = {}; + Bool32 shaderUniformBufferArrayNonUniformIndexing = {}; + Bool32 shaderSampledImageArrayNonUniformIndexing = {}; + Bool32 shaderStorageBufferArrayNonUniformIndexing = {}; + Bool32 shaderStorageImageArrayNonUniformIndexing = {}; + Bool32 shaderInputAttachmentArrayNonUniformIndexing = {}; + Bool32 shaderUniformTexelBufferArrayNonUniformIndexing = {}; + Bool32 shaderStorageTexelBufferArrayNonUniformIndexing = {}; + Bool32 descriptorBindingUniformBufferUpdateAfterBind = {}; + Bool32 descriptorBindingSampledImageUpdateAfterBind = {}; + Bool32 descriptorBindingStorageImageUpdateAfterBind = {}; + Bool32 descriptorBindingStorageBufferUpdateAfterBind = {}; + Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind = {}; + Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind = {}; + Bool32 descriptorBindingUpdateUnusedWhilePending = {}; + Bool32 descriptorBindingPartiallyBound = {}; + Bool32 descriptorBindingVariableDescriptorCount = {}; + Bool32 runtimeDescriptorArray = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorIndexingFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorIndexingFeatures; + }; + + using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures; + + // wrapper struct for struct VkPhysicalDeviceDescriptorIndexingProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html + struct PhysicalDeviceDescriptorIndexingProperties + { + using NativeType = VkPhysicalDeviceDescriptorIndexingProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorIndexingProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingProperties( uint32_t maxUpdateAfterBindDescriptorsInAllPools_ = {}, + Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ = {}, + Bool32 shaderSampledImageArrayNonUniformIndexingNative_ = {}, + Bool32 shaderStorageBufferArrayNonUniformIndexingNative_ = {}, + Bool32 shaderStorageImageArrayNonUniformIndexingNative_ = {}, + Bool32 shaderInputAttachmentArrayNonUniformIndexingNative_ = {}, + Bool32 robustBufferAccessUpdateAfterBind_ = {}, + Bool32 quadDivergentImplicitLod_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments_ = {}, + uint32_t maxPerStageUpdateAfterBindResources_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindSamplers_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindSampledImages_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindStorageImages_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxUpdateAfterBindDescriptorsInAllPools{ maxUpdateAfterBindDescriptorsInAllPools_ } + , shaderUniformBufferArrayNonUniformIndexingNative{ shaderUniformBufferArrayNonUniformIndexingNative_ } + , shaderSampledImageArrayNonUniformIndexingNative{ shaderSampledImageArrayNonUniformIndexingNative_ } + , shaderStorageBufferArrayNonUniformIndexingNative{ shaderStorageBufferArrayNonUniformIndexingNative_ } + , shaderStorageImageArrayNonUniformIndexingNative{ shaderStorageImageArrayNonUniformIndexingNative_ } + , shaderInputAttachmentArrayNonUniformIndexingNative{ shaderInputAttachmentArrayNonUniformIndexingNative_ } + , robustBufferAccessUpdateAfterBind{ robustBufferAccessUpdateAfterBind_ } + , quadDivergentImplicitLod{ quadDivergentImplicitLod_ } + , maxPerStageDescriptorUpdateAfterBindSamplers{ maxPerStageDescriptorUpdateAfterBindSamplers_ } + , maxPerStageDescriptorUpdateAfterBindUniformBuffers{ maxPerStageDescriptorUpdateAfterBindUniformBuffers_ } + , maxPerStageDescriptorUpdateAfterBindStorageBuffers{ maxPerStageDescriptorUpdateAfterBindStorageBuffers_ } + , maxPerStageDescriptorUpdateAfterBindSampledImages{ maxPerStageDescriptorUpdateAfterBindSampledImages_ } + , maxPerStageDescriptorUpdateAfterBindStorageImages{ maxPerStageDescriptorUpdateAfterBindStorageImages_ } + , maxPerStageDescriptorUpdateAfterBindInputAttachments{ maxPerStageDescriptorUpdateAfterBindInputAttachments_ } + , maxPerStageUpdateAfterBindResources{ maxPerStageUpdateAfterBindResources_ } + , maxDescriptorSetUpdateAfterBindSamplers{ maxDescriptorSetUpdateAfterBindSamplers_ } + , maxDescriptorSetUpdateAfterBindUniformBuffers{ maxDescriptorSetUpdateAfterBindUniformBuffers_ } + , maxDescriptorSetUpdateAfterBindUniformBuffersDynamic{ maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ } + , maxDescriptorSetUpdateAfterBindStorageBuffers{ maxDescriptorSetUpdateAfterBindStorageBuffers_ } + , maxDescriptorSetUpdateAfterBindStorageBuffersDynamic{ maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ } + , maxDescriptorSetUpdateAfterBindSampledImages{ maxDescriptorSetUpdateAfterBindSampledImages_ } + , maxDescriptorSetUpdateAfterBindStorageImages{ maxDescriptorSetUpdateAfterBindStorageImages_ } + , maxDescriptorSetUpdateAfterBindInputAttachments{ maxDescriptorSetUpdateAfterBindInputAttachments_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingProperties( PhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorIndexingProperties( VkPhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorIndexingProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorIndexingProperties & operator=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorIndexingProperties & operator=( VkPhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDescriptorIndexingProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorIndexingProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorIndexingProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorIndexingProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxUpdateAfterBindDescriptorsInAllPools, + shaderUniformBufferArrayNonUniformIndexingNative, + shaderSampledImageArrayNonUniformIndexingNative, + shaderStorageBufferArrayNonUniformIndexingNative, + shaderStorageImageArrayNonUniformIndexingNative, + shaderInputAttachmentArrayNonUniformIndexingNative, + robustBufferAccessUpdateAfterBind, + quadDivergentImplicitLod, + maxPerStageDescriptorUpdateAfterBindSamplers, + maxPerStageDescriptorUpdateAfterBindUniformBuffers, + maxPerStageDescriptorUpdateAfterBindStorageBuffers, + maxPerStageDescriptorUpdateAfterBindSampledImages, + maxPerStageDescriptorUpdateAfterBindStorageImages, + maxPerStageDescriptorUpdateAfterBindInputAttachments, + maxPerStageUpdateAfterBindResources, + maxDescriptorSetUpdateAfterBindSamplers, + maxDescriptorSetUpdateAfterBindUniformBuffers, + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, + maxDescriptorSetUpdateAfterBindStorageBuffers, + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, + maxDescriptorSetUpdateAfterBindSampledImages, + maxDescriptorSetUpdateAfterBindStorageImages, + maxDescriptorSetUpdateAfterBindInputAttachments ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorIndexingProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) && + ( shaderUniformBufferArrayNonUniformIndexingNative == rhs.shaderUniformBufferArrayNonUniformIndexingNative ) && + ( shaderSampledImageArrayNonUniformIndexingNative == rhs.shaderSampledImageArrayNonUniformIndexingNative ) && + ( shaderStorageBufferArrayNonUniformIndexingNative == rhs.shaderStorageBufferArrayNonUniformIndexingNative ) && + ( shaderStorageImageArrayNonUniformIndexingNative == rhs.shaderStorageImageArrayNonUniformIndexingNative ) && + ( shaderInputAttachmentArrayNonUniformIndexingNative == rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) && + ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) && ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) && + ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) && + ( maxPerStageDescriptorUpdateAfterBindUniformBuffers == rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) && + ( maxPerStageDescriptorUpdateAfterBindStorageBuffers == rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) && + ( maxPerStageDescriptorUpdateAfterBindSampledImages == rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) && + ( maxPerStageDescriptorUpdateAfterBindStorageImages == rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) && + ( maxPerStageDescriptorUpdateAfterBindInputAttachments == rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) && + ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) && + ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) && + ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) && + ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) && + ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) && + ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) && + ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) && + ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) && + ( maxDescriptorSetUpdateAfterBindInputAttachments == rhs.maxDescriptorSetUpdateAfterBindInputAttachments ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingProperties; + void * pNext = {}; + uint32_t maxUpdateAfterBindDescriptorsInAllPools = {}; + Bool32 shaderUniformBufferArrayNonUniformIndexingNative = {}; + Bool32 shaderSampledImageArrayNonUniformIndexingNative = {}; + Bool32 shaderStorageBufferArrayNonUniformIndexingNative = {}; + Bool32 shaderStorageImageArrayNonUniformIndexingNative = {}; + Bool32 shaderInputAttachmentArrayNonUniformIndexingNative = {}; + Bool32 robustBufferAccessUpdateAfterBind = {}; + Bool32 quadDivergentImplicitLod = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments = {}; + uint32_t maxPerStageUpdateAfterBindResources = {}; + uint32_t maxDescriptorSetUpdateAfterBindSamplers = {}; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers = {}; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = {}; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers = {}; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = {}; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages = {}; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages = {}; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorIndexingProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorIndexingProperties; + }; + + using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties; + + // wrapper struct for struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.html + struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV + { + using NativeType = VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( Bool32 descriptorPoolOverallocation_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorPoolOverallocation{ descriptorPoolOverallocation_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorPoolOverallocationFeaturesNV & + operator=( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorPoolOverallocationFeaturesNV & operator=( VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorPoolOverallocationFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorPoolOverallocationFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorPoolOverallocationFeaturesNV & setDescriptorPoolOverallocation( Bool32 descriptorPoolOverallocation_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorPoolOverallocation = descriptorPoolOverallocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorPoolOverallocationFeaturesNV && setDescriptorPoolOverallocation( Bool32 descriptorPoolOverallocation_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorPoolOverallocation = descriptorPoolOverallocation_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorPoolOverallocation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPoolOverallocation == rhs.descriptorPoolOverallocation ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + void * pNext = {}; + Bool32 descriptorPoolOverallocation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.html + struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE + { + using NativeType = VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( Bool32 descriptorSetHostMapping_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorSetHostMapping{ descriptorSetHostMapping_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE & + operator=( PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE & operator=( VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE & setDescriptorSetHostMapping( Bool32 descriptorSetHostMapping_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorSetHostMapping = descriptorSetHostMapping_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE && setDescriptorSetHostMapping( Bool32 descriptorSetHostMapping_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorSetHostMapping = descriptorSetHostMapping_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorSetHostMapping ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & ) const = default; +#else + bool operator==( PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetHostMapping == rhs.descriptorSetHostMapping ); +# endif + } + + bool operator!=( PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + void * pNext = {}; + Bool32 descriptorSetHostMapping = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + }; + + // wrapper struct for struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.html + struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV + { + using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( Bool32 deviceGeneratedCompute_ = {}, + Bool32 deviceGeneratedComputePipelines_ = {}, + Bool32 deviceGeneratedComputeCaptureReplay_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceGeneratedCompute{ deviceGeneratedCompute_ } + , deviceGeneratedComputePipelines{ deviceGeneratedComputePipelines_ } + , deviceGeneratedComputeCaptureReplay{ deviceGeneratedComputeCaptureReplay_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & + operator=( PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & + operator=( VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & setDeviceGeneratedCompute( Bool32 deviceGeneratedCompute_ ) & + VULKAN_HPP_NOEXCEPT + { + deviceGeneratedCompute = deviceGeneratedCompute_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV && setDeviceGeneratedCompute( Bool32 deviceGeneratedCompute_ ) && + VULKAN_HPP_NOEXCEPT + { + deviceGeneratedCompute = deviceGeneratedCompute_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & + setDeviceGeneratedComputePipelines( Bool32 deviceGeneratedComputePipelines_ ) & + VULKAN_HPP_NOEXCEPT + { + deviceGeneratedComputePipelines = deviceGeneratedComputePipelines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV && + setDeviceGeneratedComputePipelines( Bool32 deviceGeneratedComputePipelines_ ) && + VULKAN_HPP_NOEXCEPT + { + deviceGeneratedComputePipelines = deviceGeneratedComputePipelines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & + setDeviceGeneratedComputeCaptureReplay( Bool32 deviceGeneratedComputeCaptureReplay_ ) & + VULKAN_HPP_NOEXCEPT + { + deviceGeneratedComputeCaptureReplay = deviceGeneratedComputeCaptureReplay_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV && + setDeviceGeneratedComputeCaptureReplay( Bool32 deviceGeneratedComputeCaptureReplay_ ) && + VULKAN_HPP_NOEXCEPT + { + deviceGeneratedComputeCaptureReplay = deviceGeneratedComputeCaptureReplay_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceGeneratedCompute, deviceGeneratedComputePipelines, deviceGeneratedComputeCaptureReplay ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceGeneratedCompute == rhs.deviceGeneratedCompute ) && + ( deviceGeneratedComputePipelines == rhs.deviceGeneratedComputePipelines ) && + ( deviceGeneratedComputeCaptureReplay == rhs.deviceGeneratedComputeCaptureReplay ); +# endif + } + + bool operator!=( PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; + void * pNext = {}; + Bool32 deviceGeneratedCompute = {}; + Bool32 deviceGeneratedComputePipelines = {}; + Bool32 deviceGeneratedComputeCaptureReplay = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.html + struct PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT + { + using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( Bool32 deviceGeneratedCommands_ = {}, + Bool32 dynamicGeneratedPipelineLayout_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceGeneratedCommands{ deviceGeneratedCommands_ } + , dynamicGeneratedPipelineLayout{ dynamicGeneratedPipelineLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT & operator=( PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT & operator=( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT & setDeviceGeneratedCommands( Bool32 deviceGeneratedCommands_ ) & + VULKAN_HPP_NOEXCEPT + { + deviceGeneratedCommands = deviceGeneratedCommands_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT && setDeviceGeneratedCommands( Bool32 deviceGeneratedCommands_ ) && + VULKAN_HPP_NOEXCEPT + { + deviceGeneratedCommands = deviceGeneratedCommands_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT & setDynamicGeneratedPipelineLayout( Bool32 dynamicGeneratedPipelineLayout_ ) & + VULKAN_HPP_NOEXCEPT + { + dynamicGeneratedPipelineLayout = dynamicGeneratedPipelineLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT && setDynamicGeneratedPipelineLayout( Bool32 dynamicGeneratedPipelineLayout_ ) && + VULKAN_HPP_NOEXCEPT + { + dynamicGeneratedPipelineLayout = dynamicGeneratedPipelineLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceGeneratedCommands, dynamicGeneratedPipelineLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceGeneratedCommands == rhs.deviceGeneratedCommands ) && + ( dynamicGeneratedPipelineLayout == rhs.dynamicGeneratedPipelineLayout ); +# endif + } + + bool operator!=( PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + void * pNext = {}; + Bool32 deviceGeneratedCommands = {}; + Bool32 dynamicGeneratedPipelineLayout = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html + struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV + { + using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( Bool32 deviceGeneratedCommands_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceGeneratedCommands{ deviceGeneratedCommands_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & operator=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & operator=( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & setDeviceGeneratedCommands( Bool32 deviceGeneratedCommands_ ) & + VULKAN_HPP_NOEXCEPT + { + deviceGeneratedCommands = deviceGeneratedCommands_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesNV && setDeviceGeneratedCommands( Bool32 deviceGeneratedCommands_ ) && + VULKAN_HPP_NOEXCEPT + { + deviceGeneratedCommands = deviceGeneratedCommands_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceGeneratedCommands ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceGeneratedCommands == rhs.deviceGeneratedCommands ); +# endif + } + + bool operator!=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + void * pNext = {}; + Bool32 deviceGeneratedCommands = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.html + struct PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT + { + using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT( uint32_t maxIndirectPipelineCount_ = {}, + uint32_t maxIndirectShaderObjectCount_ = {}, + uint32_t maxIndirectSequenceCount_ = {}, + uint32_t maxIndirectCommandsTokenCount_ = {}, + uint32_t maxIndirectCommandsTokenOffset_ = {}, + uint32_t maxIndirectCommandsIndirectStride_ = {}, + IndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes_ = {}, + ShaderStageFlags supportedIndirectCommandsShaderStages_ = {}, + ShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding_ = {}, + ShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding_ = {}, + Bool32 deviceGeneratedCommandsTransformFeedback_ = {}, + Bool32 deviceGeneratedCommandsMultiDrawIndirectCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxIndirectPipelineCount{ maxIndirectPipelineCount_ } + , maxIndirectShaderObjectCount{ maxIndirectShaderObjectCount_ } + , maxIndirectSequenceCount{ maxIndirectSequenceCount_ } + , maxIndirectCommandsTokenCount{ maxIndirectCommandsTokenCount_ } + , maxIndirectCommandsTokenOffset{ maxIndirectCommandsTokenOffset_ } + , maxIndirectCommandsIndirectStride{ maxIndirectCommandsIndirectStride_ } + , supportedIndirectCommandsInputModes{ supportedIndirectCommandsInputModes_ } + , supportedIndirectCommandsShaderStages{ supportedIndirectCommandsShaderStages_ } + , supportedIndirectCommandsShaderStagesPipelineBinding{ supportedIndirectCommandsShaderStagesPipelineBinding_ } + , supportedIndirectCommandsShaderStagesShaderBinding{ supportedIndirectCommandsShaderStagesShaderBinding_ } + , deviceGeneratedCommandsTransformFeedback{ deviceGeneratedCommandsTransformFeedback_ } + , deviceGeneratedCommandsMultiDrawIndirectCount{ deviceGeneratedCommandsMultiDrawIndirectCount_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT( PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT & + operator=( PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT & operator=( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxIndirectPipelineCount, + maxIndirectShaderObjectCount, + maxIndirectSequenceCount, + maxIndirectCommandsTokenCount, + maxIndirectCommandsTokenOffset, + maxIndirectCommandsIndirectStride, + supportedIndirectCommandsInputModes, + supportedIndirectCommandsShaderStages, + supportedIndirectCommandsShaderStagesPipelineBinding, + supportedIndirectCommandsShaderStagesShaderBinding, + deviceGeneratedCommandsTransformFeedback, + deviceGeneratedCommandsMultiDrawIndirectCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxIndirectPipelineCount == rhs.maxIndirectPipelineCount ) && + ( maxIndirectShaderObjectCount == rhs.maxIndirectShaderObjectCount ) && ( maxIndirectSequenceCount == rhs.maxIndirectSequenceCount ) && + ( maxIndirectCommandsTokenCount == rhs.maxIndirectCommandsTokenCount ) && + ( maxIndirectCommandsTokenOffset == rhs.maxIndirectCommandsTokenOffset ) && + ( maxIndirectCommandsIndirectStride == rhs.maxIndirectCommandsIndirectStride ) && + ( supportedIndirectCommandsInputModes == rhs.supportedIndirectCommandsInputModes ) && + ( supportedIndirectCommandsShaderStages == rhs.supportedIndirectCommandsShaderStages ) && + ( supportedIndirectCommandsShaderStagesPipelineBinding == rhs.supportedIndirectCommandsShaderStagesPipelineBinding ) && + ( supportedIndirectCommandsShaderStagesShaderBinding == rhs.supportedIndirectCommandsShaderStagesShaderBinding ) && + ( deviceGeneratedCommandsTransformFeedback == rhs.deviceGeneratedCommandsTransformFeedback ) && + ( deviceGeneratedCommandsMultiDrawIndirectCount == rhs.deviceGeneratedCommandsMultiDrawIndirectCount ); +# endif + } + + bool operator!=( PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + void * pNext = {}; + uint32_t maxIndirectPipelineCount = {}; + uint32_t maxIndirectShaderObjectCount = {}; + uint32_t maxIndirectSequenceCount = {}; + uint32_t maxIndirectCommandsTokenCount = {}; + uint32_t maxIndirectCommandsTokenOffset = {}; + uint32_t maxIndirectCommandsIndirectStride = {}; + IndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes = {}; + ShaderStageFlags supportedIndirectCommandsShaderStages = {}; + ShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding = {}; + ShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding = {}; + Bool32 deviceGeneratedCommandsTransformFeedback = {}; + Bool32 deviceGeneratedCommandsMultiDrawIndirectCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html + struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV + { + using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( uint32_t maxGraphicsShaderGroupCount_ = {}, + uint32_t maxIndirectSequenceCount_ = {}, + uint32_t maxIndirectCommandsTokenCount_ = {}, + uint32_t maxIndirectCommandsStreamCount_ = {}, + uint32_t maxIndirectCommandsTokenOffset_ = {}, + uint32_t maxIndirectCommandsStreamStride_ = {}, + uint32_t minSequencesCountBufferOffsetAlignment_ = {}, + uint32_t minSequencesIndexBufferOffsetAlignment_ = {}, + uint32_t minIndirectCommandsBufferOffsetAlignment_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxGraphicsShaderGroupCount{ maxGraphicsShaderGroupCount_ } + , maxIndirectSequenceCount{ maxIndirectSequenceCount_ } + , maxIndirectCommandsTokenCount{ maxIndirectCommandsTokenCount_ } + , maxIndirectCommandsStreamCount{ maxIndirectCommandsStreamCount_ } + , maxIndirectCommandsTokenOffset{ maxIndirectCommandsTokenOffset_ } + , maxIndirectCommandsStreamStride{ maxIndirectCommandsStreamStride_ } + , minSequencesCountBufferOffsetAlignment{ minSequencesCountBufferOffsetAlignment_ } + , minSequencesIndexBufferOffsetAlignment{ minSequencesIndexBufferOffsetAlignment_ } + , minIndirectCommandsBufferOffsetAlignment{ minIndirectCommandsBufferOffsetAlignment_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDeviceGeneratedCommandsPropertiesNV & + operator=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDeviceGeneratedCommandsPropertiesNV & operator=( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxGraphicsShaderGroupCount, + maxIndirectSequenceCount, + maxIndirectCommandsTokenCount, + maxIndirectCommandsStreamCount, + maxIndirectCommandsTokenOffset, + maxIndirectCommandsStreamStride, + minSequencesCountBufferOffsetAlignment, + minSequencesIndexBufferOffsetAlignment, + minIndirectCommandsBufferOffsetAlignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGraphicsShaderGroupCount == rhs.maxGraphicsShaderGroupCount ) && + ( maxIndirectSequenceCount == rhs.maxIndirectSequenceCount ) && ( maxIndirectCommandsTokenCount == rhs.maxIndirectCommandsTokenCount ) && + ( maxIndirectCommandsStreamCount == rhs.maxIndirectCommandsStreamCount ) && + ( maxIndirectCommandsTokenOffset == rhs.maxIndirectCommandsTokenOffset ) && + ( maxIndirectCommandsStreamStride == rhs.maxIndirectCommandsStreamStride ) && + ( minSequencesCountBufferOffsetAlignment == rhs.minSequencesCountBufferOffsetAlignment ) && + ( minSequencesIndexBufferOffsetAlignment == rhs.minSequencesIndexBufferOffsetAlignment ) && + ( minIndirectCommandsBufferOffsetAlignment == rhs.minIndirectCommandsBufferOffsetAlignment ); +# endif + } + + bool operator!=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + void * pNext = {}; + uint32_t maxGraphicsShaderGroupCount = {}; + uint32_t maxIndirectSequenceCount = {}; + uint32_t maxIndirectCommandsTokenCount = {}; + uint32_t maxIndirectCommandsStreamCount = {}; + uint32_t maxIndirectCommandsTokenOffset = {}; + uint32_t maxIndirectCommandsStreamStride = {}; + uint32_t minSequencesCountBufferOffsetAlignment = {}; + uint32_t minSequencesIndexBufferOffsetAlignment = {}; + uint32_t minIndirectCommandsBufferOffsetAlignment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.html + struct PhysicalDeviceDeviceMemoryReportFeaturesEXT + { + using NativeType = VkPhysicalDeviceDeviceMemoryReportFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceMemoryReportFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceMemoryReportFeaturesEXT( Bool32 deviceMemoryReport_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceMemoryReport{ deviceMemoryReport_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceMemoryReportFeaturesEXT( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDeviceMemoryReportFeaturesEXT( VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDeviceMemoryReportFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDeviceMemoryReportFeaturesEXT & operator=( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDeviceMemoryReportFeaturesEXT & operator=( VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceMemoryReportFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceMemoryReportFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceMemoryReportFeaturesEXT & setDeviceMemoryReport( Bool32 deviceMemoryReport_ ) & VULKAN_HPP_NOEXCEPT + { + deviceMemoryReport = deviceMemoryReport_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceMemoryReportFeaturesEXT && setDeviceMemoryReport( Bool32 deviceMemoryReport_ ) && VULKAN_HPP_NOEXCEPT + { + deviceMemoryReport = deviceMemoryReport_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceMemoryReport ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMemoryReport == rhs.deviceMemoryReport ); +# endif + } + + bool operator!=( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDeviceMemoryReportFeaturesEXT; + void * pNext = {}; + Bool32 deviceMemoryReport = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceMemoryReportFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDeviceMemoryReportFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html + struct PhysicalDeviceDiagnosticsConfigFeaturesNV + { + using NativeType = VkPhysicalDeviceDiagnosticsConfigFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDiagnosticsConfigFeaturesNV( Bool32 diagnosticsConfig_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , diagnosticsConfig{ diagnosticsConfig_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDiagnosticsConfigFeaturesNV( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDiagnosticsConfigFeaturesNV( VkPhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDiagnosticsConfigFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDiagnosticsConfigFeaturesNV & operator=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDiagnosticsConfigFeaturesNV & operator=( VkPhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDiagnosticsConfigFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDiagnosticsConfigFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDiagnosticsConfigFeaturesNV & setDiagnosticsConfig( Bool32 diagnosticsConfig_ ) & VULKAN_HPP_NOEXCEPT + { + diagnosticsConfig = diagnosticsConfig_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDiagnosticsConfigFeaturesNV && setDiagnosticsConfig( Bool32 diagnosticsConfig_ ) && VULKAN_HPP_NOEXCEPT + { + diagnosticsConfig = diagnosticsConfig_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, diagnosticsConfig ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDiagnosticsConfigFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( diagnosticsConfig == rhs.diagnosticsConfig ); +# endif + } + + bool operator!=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV; + void * pNext = {}; + Bool32 diagnosticsConfig = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDiagnosticsConfigFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDiagnosticsConfigFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceDiscardRectanglePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html + struct PhysicalDeviceDiscardRectanglePropertiesEXT + { + using NativeType = VkPhysicalDeviceDiscardRectanglePropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxDiscardRectangles{ maxDiscardRectangles_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDiscardRectanglePropertiesEXT( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDiscardRectanglePropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDiscardRectanglePropertiesEXT & operator=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDiscardRectanglePropertiesEXT & operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDiscardRectanglePropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxDiscardRectangles ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDiscardRectanglePropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDiscardRectangles == rhs.maxDiscardRectangles ); +# endif + } + + bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; + void * pNext = {}; + uint32_t maxDiscardRectangles = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDiscardRectanglePropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDiscardRectanglePropertiesEXT; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkPhysicalDeviceDisplacementMicromapFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDisplacementMicromapFeaturesNV.html + struct PhysicalDeviceDisplacementMicromapFeaturesNV + { + using NativeType = VkPhysicalDeviceDisplacementMicromapFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDisplacementMicromapFeaturesNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDisplacementMicromapFeaturesNV( Bool32 displacementMicromap_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , displacementMicromap{ displacementMicromap_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDisplacementMicromapFeaturesNV( PhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDisplacementMicromapFeaturesNV( VkPhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDisplacementMicromapFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDisplacementMicromapFeaturesNV & operator=( PhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDisplacementMicromapFeaturesNV & operator=( VkPhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDisplacementMicromapFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDisplacementMicromapFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDisplacementMicromapFeaturesNV & setDisplacementMicromap( Bool32 displacementMicromap_ ) & VULKAN_HPP_NOEXCEPT + { + displacementMicromap = displacementMicromap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDisplacementMicromapFeaturesNV && setDisplacementMicromap( Bool32 displacementMicromap_ ) && VULKAN_HPP_NOEXCEPT + { + displacementMicromap = displacementMicromap_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDisplacementMicromapFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDisplacementMicromapFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDisplacementMicromapFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDisplacementMicromapFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, displacementMicromap ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDisplacementMicromapFeaturesNV const & ) const = default; +# else + bool operator==( PhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displacementMicromap == rhs.displacementMicromap ); +# endif + } + + bool operator!=( PhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDisplacementMicromapFeaturesNV; + void * pNext = {}; + Bool32 displacementMicromap = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDisplacementMicromapFeaturesNV; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDisplacementMicromapFeaturesNV; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkPhysicalDeviceDisplacementMicromapPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDisplacementMicromapPropertiesNV.html + struct PhysicalDeviceDisplacementMicromapPropertiesNV + { + using NativeType = VkPhysicalDeviceDisplacementMicromapPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDisplacementMicromapPropertiesNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDisplacementMicromapPropertiesNV( uint32_t maxDisplacementMicromapSubdivisionLevel_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxDisplacementMicromapSubdivisionLevel{ maxDisplacementMicromapSubdivisionLevel_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDisplacementMicromapPropertiesNV( PhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDisplacementMicromapPropertiesNV( VkPhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDisplacementMicromapPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDisplacementMicromapPropertiesNV & operator=( PhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDisplacementMicromapPropertiesNV & operator=( VkPhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDisplacementMicromapPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDisplacementMicromapPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDisplacementMicromapPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDisplacementMicromapPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxDisplacementMicromapSubdivisionLevel ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDisplacementMicromapPropertiesNV const & ) const = default; +# else + bool operator==( PhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDisplacementMicromapSubdivisionLevel == rhs.maxDisplacementMicromapSubdivisionLevel ); +# endif + } + + bool operator!=( PhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDisplacementMicromapPropertiesNV; + void * pNext = {}; + uint32_t maxDisplacementMicromapSubdivisionLevel = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDisplacementMicromapPropertiesNV; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDisplacementMicromapPropertiesNV; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkPhysicalDeviceDriverProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDriverProperties.html + struct PhysicalDeviceDriverProperties + { + using NativeType = VkPhysicalDeviceDriverProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDriverProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDriverProperties( DriverId driverID_ = DriverId::eAmdProprietary, + std::array const & driverName_ = {}, + std::array const & driverInfo_ = {}, + ConformanceVersion conformanceVersion_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , driverID{ driverID_ } + , driverName{ driverName_ } + , driverInfo{ driverInfo_ } + , conformanceVersion{ conformanceVersion_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDriverProperties( PhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDriverProperties( VkPhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDriverProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDriverProperties & operator=( PhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDriverProperties & operator=( VkPhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDriverProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDriverProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDriverProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDriverProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &, + ConformanceVersion const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, driverID, driverName, driverInfo, conformanceVersion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = driverID <=> rhs.driverID; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( driverName, rhs.driverName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( driverInfo, rhs.driverInfo ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = conformanceVersion <=> rhs.conformanceVersion; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && ( strcmp( driverName, rhs.driverName ) == 0 ) && + ( strcmp( driverInfo, rhs.driverInfo ) == 0 ) && ( conformanceVersion == rhs.conformanceVersion ); + } + + bool operator!=( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::ePhysicalDeviceDriverProperties; + void * pNext = {}; + DriverId driverID = DriverId::eAmdProprietary; + ArrayWrapper1D driverName = {}; + ArrayWrapper1D driverInfo = {}; + ConformanceVersion conformanceVersion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDriverProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDriverProperties; + }; + + using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties; + + // wrapper struct for struct VkPhysicalDeviceDrmPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDrmPropertiesEXT.html + struct PhysicalDeviceDrmPropertiesEXT + { + using NativeType = VkPhysicalDeviceDrmPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDrmPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDrmPropertiesEXT( Bool32 hasPrimary_ = {}, + Bool32 hasRender_ = {}, + int64_t primaryMajor_ = {}, + int64_t primaryMinor_ = {}, + int64_t renderMajor_ = {}, + int64_t renderMinor_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , hasPrimary{ hasPrimary_ } + , hasRender{ hasRender_ } + , primaryMajor{ primaryMajor_ } + , primaryMinor{ primaryMinor_ } + , renderMajor{ renderMajor_ } + , renderMinor{ renderMinor_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDrmPropertiesEXT( PhysicalDeviceDrmPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDrmPropertiesEXT( VkPhysicalDeviceDrmPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDrmPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDrmPropertiesEXT & operator=( PhysicalDeviceDrmPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDrmPropertiesEXT & operator=( VkPhysicalDeviceDrmPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceDrmPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDrmPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDrmPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDrmPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hasPrimary, hasRender, primaryMajor, primaryMinor, renderMajor, renderMinor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDrmPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasPrimary == rhs.hasPrimary ) && ( hasRender == rhs.hasRender ) && + ( primaryMajor == rhs.primaryMajor ) && ( primaryMinor == rhs.primaryMinor ) && ( renderMajor == rhs.renderMajor ) && + ( renderMinor == rhs.renderMinor ); +# endif + } + + bool operator!=( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDrmPropertiesEXT; + void * pNext = {}; + Bool32 hasPrimary = {}; + Bool32 hasRender = {}; + int64_t primaryMajor = {}; + int64_t primaryMinor = {}; + int64_t renderMajor = {}; + int64_t renderMinor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDrmPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDrmPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceDynamicRenderingFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDynamicRenderingFeatures.html + struct PhysicalDeviceDynamicRenderingFeatures + { + using NativeType = VkPhysicalDeviceDynamicRenderingFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDynamicRenderingFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDynamicRenderingFeatures( Bool32 dynamicRendering_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dynamicRendering{ dynamicRendering_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDynamicRenderingFeatures( PhysicalDeviceDynamicRenderingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDynamicRenderingFeatures( VkPhysicalDeviceDynamicRenderingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDynamicRenderingFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDynamicRenderingFeatures & operator=( PhysicalDeviceDynamicRenderingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDynamicRenderingFeatures & operator=( VkPhysicalDeviceDynamicRenderingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingFeatures & setDynamicRendering( Bool32 dynamicRendering_ ) & VULKAN_HPP_NOEXCEPT + { + dynamicRendering = dynamicRendering_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingFeatures && setDynamicRendering( Bool32 dynamicRendering_ ) && VULKAN_HPP_NOEXCEPT + { + dynamicRendering = dynamicRendering_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDynamicRenderingFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDynamicRenderingFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDynamicRenderingFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDynamicRenderingFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dynamicRendering ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDynamicRenderingFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceDynamicRenderingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRendering == rhs.dynamicRendering ); +# endif + } + + bool operator!=( PhysicalDeviceDynamicRenderingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDynamicRenderingFeatures; + void * pNext = {}; + Bool32 dynamicRendering = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDynamicRenderingFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDynamicRenderingFeatures; + }; + + using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures; + + // wrapper struct for struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDynamicRenderingLocalReadFeatures.html + struct PhysicalDeviceDynamicRenderingLocalReadFeatures + { + using NativeType = VkPhysicalDeviceDynamicRenderingLocalReadFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDynamicRenderingLocalReadFeatures( Bool32 dynamicRenderingLocalRead_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dynamicRenderingLocalRead{ dynamicRenderingLocalRead_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceDynamicRenderingLocalReadFeatures( PhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDynamicRenderingLocalReadFeatures( VkPhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDynamicRenderingLocalReadFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDynamicRenderingLocalReadFeatures & operator=( PhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDynamicRenderingLocalReadFeatures & operator=( VkPhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingLocalReadFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingLocalReadFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingLocalReadFeatures & setDynamicRenderingLocalRead( Bool32 dynamicRenderingLocalRead_ ) & + VULKAN_HPP_NOEXCEPT + { + dynamicRenderingLocalRead = dynamicRenderingLocalRead_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingLocalReadFeatures && setDynamicRenderingLocalRead( Bool32 dynamicRenderingLocalRead_ ) && + VULKAN_HPP_NOEXCEPT + { + dynamicRenderingLocalRead = dynamicRenderingLocalRead_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDynamicRenderingLocalReadFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDynamicRenderingLocalReadFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDynamicRenderingLocalReadFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDynamicRenderingLocalReadFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dynamicRenderingLocalRead ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDynamicRenderingLocalReadFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRenderingLocalRead == rhs.dynamicRenderingLocalRead ); +# endif + } + + bool operator!=( PhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeatures; + void * pNext = {}; + Bool32 dynamicRenderingLocalRead = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDynamicRenderingLocalReadFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDynamicRenderingLocalReadFeatures; + }; + + using PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = PhysicalDeviceDynamicRenderingLocalReadFeatures; + + // wrapper struct for struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.html + struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT + { + using NativeType = VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( Bool32 dynamicRenderingUnusedAttachments_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dynamicRenderingUnusedAttachments{ dynamicRenderingUnusedAttachments_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( + *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT & + operator=( PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT & + operator=( VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT & + setDynamicRenderingUnusedAttachments( Bool32 dynamicRenderingUnusedAttachments_ ) & + VULKAN_HPP_NOEXCEPT + { + dynamicRenderingUnusedAttachments = dynamicRenderingUnusedAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT && + setDynamicRenderingUnusedAttachments( Bool32 dynamicRenderingUnusedAttachments_ ) && + VULKAN_HPP_NOEXCEPT + { + dynamicRenderingUnusedAttachments = dynamicRenderingUnusedAttachments_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dynamicRenderingUnusedAttachments ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRenderingUnusedAttachments == rhs.dynamicRenderingUnusedAttachments ); +# endif + } + + bool operator!=( PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; + void * pNext = {}; + Bool32 dynamicRenderingUnusedAttachments = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceExclusiveScissorFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html + struct PhysicalDeviceExclusiveScissorFeaturesNV + { + using NativeType = VkPhysicalDeviceExclusiveScissorFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( Bool32 exclusiveScissor_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , exclusiveScissor{ exclusiveScissor_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExclusiveScissorFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExclusiveScissorFeaturesNV & operator=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExclusiveScissorFeaturesNV & operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExclusiveScissorFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExclusiveScissorFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExclusiveScissorFeaturesNV & setExclusiveScissor( Bool32 exclusiveScissor_ ) & VULKAN_HPP_NOEXCEPT + { + exclusiveScissor = exclusiveScissor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExclusiveScissorFeaturesNV && setExclusiveScissor( Bool32 exclusiveScissor_ ) && VULKAN_HPP_NOEXCEPT + { + exclusiveScissor = exclusiveScissor_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExclusiveScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExclusiveScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExclusiveScissorFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExclusiveScissorFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exclusiveScissor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExclusiveScissorFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissor == rhs.exclusiveScissor ); +# endif + } + + bool operator!=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; + void * pNext = {}; + Bool32 exclusiveScissor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExclusiveScissorFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExclusiveScissorFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html + struct PhysicalDeviceExtendedDynamicState2FeaturesEXT + { + using NativeType = VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicState2FeaturesEXT( Bool32 extendedDynamicState2_ = {}, + Bool32 extendedDynamicState2LogicOp_ = {}, + Bool32 extendedDynamicState2PatchControlPoints_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , extendedDynamicState2{ extendedDynamicState2_ } + , extendedDynamicState2LogicOp{ extendedDynamicState2LogicOp_ } + , extendedDynamicState2PatchControlPoints{ extendedDynamicState2PatchControlPoints_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExtendedDynamicState2FeaturesEXT( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExtendedDynamicState2FeaturesEXT( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExtendedDynamicState2FeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExtendedDynamicState2FeaturesEXT & operator=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExtendedDynamicState2FeaturesEXT & operator=( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT & setExtendedDynamicState2( Bool32 extendedDynamicState2_ ) & VULKAN_HPP_NOEXCEPT + { + extendedDynamicState2 = extendedDynamicState2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT && setExtendedDynamicState2( Bool32 extendedDynamicState2_ ) && VULKAN_HPP_NOEXCEPT + { + extendedDynamicState2 = extendedDynamicState2_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT & setExtendedDynamicState2LogicOp( Bool32 extendedDynamicState2LogicOp_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState2LogicOp = extendedDynamicState2LogicOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT && setExtendedDynamicState2LogicOp( Bool32 extendedDynamicState2LogicOp_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState2LogicOp = extendedDynamicState2LogicOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT & + setExtendedDynamicState2PatchControlPoints( Bool32 extendedDynamicState2PatchControlPoints_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState2PatchControlPoints = extendedDynamicState2PatchControlPoints_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT && + setExtendedDynamicState2PatchControlPoints( Bool32 extendedDynamicState2PatchControlPoints_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState2PatchControlPoints = extendedDynamicState2PatchControlPoints_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, extendedDynamicState2, extendedDynamicState2LogicOp, extendedDynamicState2PatchControlPoints ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState2 == rhs.extendedDynamicState2 ) && + ( extendedDynamicState2LogicOp == rhs.extendedDynamicState2LogicOp ) && + ( extendedDynamicState2PatchControlPoints == rhs.extendedDynamicState2PatchControlPoints ); +# endif + } + + bool operator!=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT; + void * pNext = {}; + Bool32 extendedDynamicState2 = {}; + Bool32 extendedDynamicState2LogicOp = {}; + Bool32 extendedDynamicState2PatchControlPoints = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedDynamicState2FeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedDynamicState2FeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.html + struct PhysicalDeviceExtendedDynamicState3FeaturesEXT + { + using NativeType = VkPhysicalDeviceExtendedDynamicState3FeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicState3FeaturesEXT( Bool32 extendedDynamicState3TessellationDomainOrigin_ = {}, + Bool32 extendedDynamicState3DepthClampEnable_ = {}, + Bool32 extendedDynamicState3PolygonMode_ = {}, + Bool32 extendedDynamicState3RasterizationSamples_ = {}, + Bool32 extendedDynamicState3SampleMask_ = {}, + Bool32 extendedDynamicState3AlphaToCoverageEnable_ = {}, + Bool32 extendedDynamicState3AlphaToOneEnable_ = {}, + Bool32 extendedDynamicState3LogicOpEnable_ = {}, + Bool32 extendedDynamicState3ColorBlendEnable_ = {}, + Bool32 extendedDynamicState3ColorBlendEquation_ = {}, + Bool32 extendedDynamicState3ColorWriteMask_ = {}, + Bool32 extendedDynamicState3RasterizationStream_ = {}, + Bool32 extendedDynamicState3ConservativeRasterizationMode_ = {}, + Bool32 extendedDynamicState3ExtraPrimitiveOverestimationSize_ = {}, + Bool32 extendedDynamicState3DepthClipEnable_ = {}, + Bool32 extendedDynamicState3SampleLocationsEnable_ = {}, + Bool32 extendedDynamicState3ColorBlendAdvanced_ = {}, + Bool32 extendedDynamicState3ProvokingVertexMode_ = {}, + Bool32 extendedDynamicState3LineRasterizationMode_ = {}, + Bool32 extendedDynamicState3LineStippleEnable_ = {}, + Bool32 extendedDynamicState3DepthClipNegativeOneToOne_ = {}, + Bool32 extendedDynamicState3ViewportWScalingEnable_ = {}, + Bool32 extendedDynamicState3ViewportSwizzle_ = {}, + Bool32 extendedDynamicState3CoverageToColorEnable_ = {}, + Bool32 extendedDynamicState3CoverageToColorLocation_ = {}, + Bool32 extendedDynamicState3CoverageModulationMode_ = {}, + Bool32 extendedDynamicState3CoverageModulationTableEnable_ = {}, + Bool32 extendedDynamicState3CoverageModulationTable_ = {}, + Bool32 extendedDynamicState3CoverageReductionMode_ = {}, + Bool32 extendedDynamicState3RepresentativeFragmentTestEnable_ = {}, + Bool32 extendedDynamicState3ShadingRateImageEnable_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , extendedDynamicState3TessellationDomainOrigin{ extendedDynamicState3TessellationDomainOrigin_ } + , extendedDynamicState3DepthClampEnable{ extendedDynamicState3DepthClampEnable_ } + , extendedDynamicState3PolygonMode{ extendedDynamicState3PolygonMode_ } + , extendedDynamicState3RasterizationSamples{ extendedDynamicState3RasterizationSamples_ } + , extendedDynamicState3SampleMask{ extendedDynamicState3SampleMask_ } + , extendedDynamicState3AlphaToCoverageEnable{ extendedDynamicState3AlphaToCoverageEnable_ } + , extendedDynamicState3AlphaToOneEnable{ extendedDynamicState3AlphaToOneEnable_ } + , extendedDynamicState3LogicOpEnable{ extendedDynamicState3LogicOpEnable_ } + , extendedDynamicState3ColorBlendEnable{ extendedDynamicState3ColorBlendEnable_ } + , extendedDynamicState3ColorBlendEquation{ extendedDynamicState3ColorBlendEquation_ } + , extendedDynamicState3ColorWriteMask{ extendedDynamicState3ColorWriteMask_ } + , extendedDynamicState3RasterizationStream{ extendedDynamicState3RasterizationStream_ } + , extendedDynamicState3ConservativeRasterizationMode{ extendedDynamicState3ConservativeRasterizationMode_ } + , extendedDynamicState3ExtraPrimitiveOverestimationSize{ extendedDynamicState3ExtraPrimitiveOverestimationSize_ } + , extendedDynamicState3DepthClipEnable{ extendedDynamicState3DepthClipEnable_ } + , extendedDynamicState3SampleLocationsEnable{ extendedDynamicState3SampleLocationsEnable_ } + , extendedDynamicState3ColorBlendAdvanced{ extendedDynamicState3ColorBlendAdvanced_ } + , extendedDynamicState3ProvokingVertexMode{ extendedDynamicState3ProvokingVertexMode_ } + , extendedDynamicState3LineRasterizationMode{ extendedDynamicState3LineRasterizationMode_ } + , extendedDynamicState3LineStippleEnable{ extendedDynamicState3LineStippleEnable_ } + , extendedDynamicState3DepthClipNegativeOneToOne{ extendedDynamicState3DepthClipNegativeOneToOne_ } + , extendedDynamicState3ViewportWScalingEnable{ extendedDynamicState3ViewportWScalingEnable_ } + , extendedDynamicState3ViewportSwizzle{ extendedDynamicState3ViewportSwizzle_ } + , extendedDynamicState3CoverageToColorEnable{ extendedDynamicState3CoverageToColorEnable_ } + , extendedDynamicState3CoverageToColorLocation{ extendedDynamicState3CoverageToColorLocation_ } + , extendedDynamicState3CoverageModulationMode{ extendedDynamicState3CoverageModulationMode_ } + , extendedDynamicState3CoverageModulationTableEnable{ extendedDynamicState3CoverageModulationTableEnable_ } + , extendedDynamicState3CoverageModulationTable{ extendedDynamicState3CoverageModulationTable_ } + , extendedDynamicState3CoverageReductionMode{ extendedDynamicState3CoverageReductionMode_ } + , extendedDynamicState3RepresentativeFragmentTestEnable{ extendedDynamicState3RepresentativeFragmentTestEnable_ } + , extendedDynamicState3ShadingRateImageEnable{ extendedDynamicState3ShadingRateImageEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExtendedDynamicState3FeaturesEXT( PhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExtendedDynamicState3FeaturesEXT( VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExtendedDynamicState3FeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExtendedDynamicState3FeaturesEXT & operator=( PhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExtendedDynamicState3FeaturesEXT & operator=( VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3TessellationDomainOrigin( Bool32 extendedDynamicState3TessellationDomainOrigin_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3TessellationDomainOrigin = extendedDynamicState3TessellationDomainOrigin_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3TessellationDomainOrigin( Bool32 extendedDynamicState3TessellationDomainOrigin_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3TessellationDomainOrigin = extendedDynamicState3TessellationDomainOrigin_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3DepthClampEnable( Bool32 extendedDynamicState3DepthClampEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3DepthClampEnable = extendedDynamicState3DepthClampEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3DepthClampEnable( Bool32 extendedDynamicState3DepthClampEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3DepthClampEnable = extendedDynamicState3DepthClampEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & setExtendedDynamicState3PolygonMode( Bool32 extendedDynamicState3PolygonMode_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3PolygonMode = extendedDynamicState3PolygonMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && setExtendedDynamicState3PolygonMode( Bool32 extendedDynamicState3PolygonMode_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3PolygonMode = extendedDynamicState3PolygonMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3RasterizationSamples( Bool32 extendedDynamicState3RasterizationSamples_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3RasterizationSamples = extendedDynamicState3RasterizationSamples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3RasterizationSamples( Bool32 extendedDynamicState3RasterizationSamples_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3RasterizationSamples = extendedDynamicState3RasterizationSamples_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & setExtendedDynamicState3SampleMask( Bool32 extendedDynamicState3SampleMask_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3SampleMask = extendedDynamicState3SampleMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && setExtendedDynamicState3SampleMask( Bool32 extendedDynamicState3SampleMask_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3SampleMask = extendedDynamicState3SampleMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3AlphaToCoverageEnable( Bool32 extendedDynamicState3AlphaToCoverageEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3AlphaToCoverageEnable = extendedDynamicState3AlphaToCoverageEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3AlphaToCoverageEnable( Bool32 extendedDynamicState3AlphaToCoverageEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3AlphaToCoverageEnable = extendedDynamicState3AlphaToCoverageEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3AlphaToOneEnable( Bool32 extendedDynamicState3AlphaToOneEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3AlphaToOneEnable = extendedDynamicState3AlphaToOneEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3AlphaToOneEnable( Bool32 extendedDynamicState3AlphaToOneEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3AlphaToOneEnable = extendedDynamicState3AlphaToOneEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3LogicOpEnable( Bool32 extendedDynamicState3LogicOpEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3LogicOpEnable = extendedDynamicState3LogicOpEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3LogicOpEnable( Bool32 extendedDynamicState3LogicOpEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3LogicOpEnable = extendedDynamicState3LogicOpEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3ColorBlendEnable( Bool32 extendedDynamicState3ColorBlendEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ColorBlendEnable = extendedDynamicState3ColorBlendEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3ColorBlendEnable( Bool32 extendedDynamicState3ColorBlendEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ColorBlendEnable = extendedDynamicState3ColorBlendEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3ColorBlendEquation( Bool32 extendedDynamicState3ColorBlendEquation_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ColorBlendEquation = extendedDynamicState3ColorBlendEquation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3ColorBlendEquation( Bool32 extendedDynamicState3ColorBlendEquation_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ColorBlendEquation = extendedDynamicState3ColorBlendEquation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3ColorWriteMask( Bool32 extendedDynamicState3ColorWriteMask_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ColorWriteMask = extendedDynamicState3ColorWriteMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3ColorWriteMask( Bool32 extendedDynamicState3ColorWriteMask_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ColorWriteMask = extendedDynamicState3ColorWriteMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3RasterizationStream( Bool32 extendedDynamicState3RasterizationStream_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3RasterizationStream = extendedDynamicState3RasterizationStream_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3RasterizationStream( Bool32 extendedDynamicState3RasterizationStream_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3RasterizationStream = extendedDynamicState3RasterizationStream_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3ConservativeRasterizationMode( Bool32 extendedDynamicState3ConservativeRasterizationMode_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ConservativeRasterizationMode = extendedDynamicState3ConservativeRasterizationMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3ConservativeRasterizationMode( Bool32 extendedDynamicState3ConservativeRasterizationMode_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ConservativeRasterizationMode = extendedDynamicState3ConservativeRasterizationMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3ExtraPrimitiveOverestimationSize( Bool32 extendedDynamicState3ExtraPrimitiveOverestimationSize_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ExtraPrimitiveOverestimationSize = extendedDynamicState3ExtraPrimitiveOverestimationSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3ExtraPrimitiveOverestimationSize( Bool32 extendedDynamicState3ExtraPrimitiveOverestimationSize_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ExtraPrimitiveOverestimationSize = extendedDynamicState3ExtraPrimitiveOverestimationSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3DepthClipEnable( Bool32 extendedDynamicState3DepthClipEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3DepthClipEnable = extendedDynamicState3DepthClipEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3DepthClipEnable( Bool32 extendedDynamicState3DepthClipEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3DepthClipEnable = extendedDynamicState3DepthClipEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3SampleLocationsEnable( Bool32 extendedDynamicState3SampleLocationsEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3SampleLocationsEnable = extendedDynamicState3SampleLocationsEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3SampleLocationsEnable( Bool32 extendedDynamicState3SampleLocationsEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3SampleLocationsEnable = extendedDynamicState3SampleLocationsEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3ColorBlendAdvanced( Bool32 extendedDynamicState3ColorBlendAdvanced_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ColorBlendAdvanced = extendedDynamicState3ColorBlendAdvanced_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3ColorBlendAdvanced( Bool32 extendedDynamicState3ColorBlendAdvanced_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ColorBlendAdvanced = extendedDynamicState3ColorBlendAdvanced_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3ProvokingVertexMode( Bool32 extendedDynamicState3ProvokingVertexMode_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ProvokingVertexMode = extendedDynamicState3ProvokingVertexMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3ProvokingVertexMode( Bool32 extendedDynamicState3ProvokingVertexMode_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ProvokingVertexMode = extendedDynamicState3ProvokingVertexMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3LineRasterizationMode( Bool32 extendedDynamicState3LineRasterizationMode_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3LineRasterizationMode = extendedDynamicState3LineRasterizationMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3LineRasterizationMode( Bool32 extendedDynamicState3LineRasterizationMode_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3LineRasterizationMode = extendedDynamicState3LineRasterizationMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3LineStippleEnable( Bool32 extendedDynamicState3LineStippleEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3LineStippleEnable = extendedDynamicState3LineStippleEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3LineStippleEnable( Bool32 extendedDynamicState3LineStippleEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3LineStippleEnable = extendedDynamicState3LineStippleEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3DepthClipNegativeOneToOne( Bool32 extendedDynamicState3DepthClipNegativeOneToOne_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3DepthClipNegativeOneToOne = extendedDynamicState3DepthClipNegativeOneToOne_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3DepthClipNegativeOneToOne( Bool32 extendedDynamicState3DepthClipNegativeOneToOne_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3DepthClipNegativeOneToOne = extendedDynamicState3DepthClipNegativeOneToOne_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3ViewportWScalingEnable( Bool32 extendedDynamicState3ViewportWScalingEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ViewportWScalingEnable = extendedDynamicState3ViewportWScalingEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3ViewportWScalingEnable( Bool32 extendedDynamicState3ViewportWScalingEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ViewportWScalingEnable = extendedDynamicState3ViewportWScalingEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3ViewportSwizzle( Bool32 extendedDynamicState3ViewportSwizzle_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ViewportSwizzle = extendedDynamicState3ViewportSwizzle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3ViewportSwizzle( Bool32 extendedDynamicState3ViewportSwizzle_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ViewportSwizzle = extendedDynamicState3ViewportSwizzle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3CoverageToColorEnable( Bool32 extendedDynamicState3CoverageToColorEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageToColorEnable = extendedDynamicState3CoverageToColorEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3CoverageToColorEnable( Bool32 extendedDynamicState3CoverageToColorEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageToColorEnable = extendedDynamicState3CoverageToColorEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3CoverageToColorLocation( Bool32 extendedDynamicState3CoverageToColorLocation_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageToColorLocation = extendedDynamicState3CoverageToColorLocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3CoverageToColorLocation( Bool32 extendedDynamicState3CoverageToColorLocation_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageToColorLocation = extendedDynamicState3CoverageToColorLocation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3CoverageModulationMode( Bool32 extendedDynamicState3CoverageModulationMode_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageModulationMode = extendedDynamicState3CoverageModulationMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3CoverageModulationMode( Bool32 extendedDynamicState3CoverageModulationMode_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageModulationMode = extendedDynamicState3CoverageModulationMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3CoverageModulationTableEnable( Bool32 extendedDynamicState3CoverageModulationTableEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageModulationTableEnable = extendedDynamicState3CoverageModulationTableEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3CoverageModulationTableEnable( Bool32 extendedDynamicState3CoverageModulationTableEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageModulationTableEnable = extendedDynamicState3CoverageModulationTableEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3CoverageModulationTable( Bool32 extendedDynamicState3CoverageModulationTable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageModulationTable = extendedDynamicState3CoverageModulationTable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3CoverageModulationTable( Bool32 extendedDynamicState3CoverageModulationTable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageModulationTable = extendedDynamicState3CoverageModulationTable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3CoverageReductionMode( Bool32 extendedDynamicState3CoverageReductionMode_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageReductionMode = extendedDynamicState3CoverageReductionMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3CoverageReductionMode( Bool32 extendedDynamicState3CoverageReductionMode_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3CoverageReductionMode = extendedDynamicState3CoverageReductionMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3RepresentativeFragmentTestEnable( Bool32 extendedDynamicState3RepresentativeFragmentTestEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3RepresentativeFragmentTestEnable = extendedDynamicState3RepresentativeFragmentTestEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3RepresentativeFragmentTestEnable( Bool32 extendedDynamicState3RepresentativeFragmentTestEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3RepresentativeFragmentTestEnable = extendedDynamicState3RepresentativeFragmentTestEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & + setExtendedDynamicState3ShadingRateImageEnable( Bool32 extendedDynamicState3ShadingRateImageEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ShadingRateImageEnable = extendedDynamicState3ShadingRateImageEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && + setExtendedDynamicState3ShadingRateImageEnable( Bool32 extendedDynamicState3ShadingRateImageEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedDynamicState3ShadingRateImageEnable = extendedDynamicState3ShadingRateImageEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicState3FeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + extendedDynamicState3TessellationDomainOrigin, + extendedDynamicState3DepthClampEnable, + extendedDynamicState3PolygonMode, + extendedDynamicState3RasterizationSamples, + extendedDynamicState3SampleMask, + extendedDynamicState3AlphaToCoverageEnable, + extendedDynamicState3AlphaToOneEnable, + extendedDynamicState3LogicOpEnable, + extendedDynamicState3ColorBlendEnable, + extendedDynamicState3ColorBlendEquation, + extendedDynamicState3ColorWriteMask, + extendedDynamicState3RasterizationStream, + extendedDynamicState3ConservativeRasterizationMode, + extendedDynamicState3ExtraPrimitiveOverestimationSize, + extendedDynamicState3DepthClipEnable, + extendedDynamicState3SampleLocationsEnable, + extendedDynamicState3ColorBlendAdvanced, + extendedDynamicState3ProvokingVertexMode, + extendedDynamicState3LineRasterizationMode, + extendedDynamicState3LineStippleEnable, + extendedDynamicState3DepthClipNegativeOneToOne, + extendedDynamicState3ViewportWScalingEnable, + extendedDynamicState3ViewportSwizzle, + extendedDynamicState3CoverageToColorEnable, + extendedDynamicState3CoverageToColorLocation, + extendedDynamicState3CoverageModulationMode, + extendedDynamicState3CoverageModulationTableEnable, + extendedDynamicState3CoverageModulationTable, + extendedDynamicState3CoverageReductionMode, + extendedDynamicState3RepresentativeFragmentTestEnable, + extendedDynamicState3ShadingRateImageEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExtendedDynamicState3FeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( extendedDynamicState3TessellationDomainOrigin == rhs.extendedDynamicState3TessellationDomainOrigin ) && + ( extendedDynamicState3DepthClampEnable == rhs.extendedDynamicState3DepthClampEnable ) && + ( extendedDynamicState3PolygonMode == rhs.extendedDynamicState3PolygonMode ) && + ( extendedDynamicState3RasterizationSamples == rhs.extendedDynamicState3RasterizationSamples ) && + ( extendedDynamicState3SampleMask == rhs.extendedDynamicState3SampleMask ) && + ( extendedDynamicState3AlphaToCoverageEnable == rhs.extendedDynamicState3AlphaToCoverageEnable ) && + ( extendedDynamicState3AlphaToOneEnable == rhs.extendedDynamicState3AlphaToOneEnable ) && + ( extendedDynamicState3LogicOpEnable == rhs.extendedDynamicState3LogicOpEnable ) && + ( extendedDynamicState3ColorBlendEnable == rhs.extendedDynamicState3ColorBlendEnable ) && + ( extendedDynamicState3ColorBlendEquation == rhs.extendedDynamicState3ColorBlendEquation ) && + ( extendedDynamicState3ColorWriteMask == rhs.extendedDynamicState3ColorWriteMask ) && + ( extendedDynamicState3RasterizationStream == rhs.extendedDynamicState3RasterizationStream ) && + ( extendedDynamicState3ConservativeRasterizationMode == rhs.extendedDynamicState3ConservativeRasterizationMode ) && + ( extendedDynamicState3ExtraPrimitiveOverestimationSize == rhs.extendedDynamicState3ExtraPrimitiveOverestimationSize ) && + ( extendedDynamicState3DepthClipEnable == rhs.extendedDynamicState3DepthClipEnable ) && + ( extendedDynamicState3SampleLocationsEnable == rhs.extendedDynamicState3SampleLocationsEnable ) && + ( extendedDynamicState3ColorBlendAdvanced == rhs.extendedDynamicState3ColorBlendAdvanced ) && + ( extendedDynamicState3ProvokingVertexMode == rhs.extendedDynamicState3ProvokingVertexMode ) && + ( extendedDynamicState3LineRasterizationMode == rhs.extendedDynamicState3LineRasterizationMode ) && + ( extendedDynamicState3LineStippleEnable == rhs.extendedDynamicState3LineStippleEnable ) && + ( extendedDynamicState3DepthClipNegativeOneToOne == rhs.extendedDynamicState3DepthClipNegativeOneToOne ) && + ( extendedDynamicState3ViewportWScalingEnable == rhs.extendedDynamicState3ViewportWScalingEnable ) && + ( extendedDynamicState3ViewportSwizzle == rhs.extendedDynamicState3ViewportSwizzle ) && + ( extendedDynamicState3CoverageToColorEnable == rhs.extendedDynamicState3CoverageToColorEnable ) && + ( extendedDynamicState3CoverageToColorLocation == rhs.extendedDynamicState3CoverageToColorLocation ) && + ( extendedDynamicState3CoverageModulationMode == rhs.extendedDynamicState3CoverageModulationMode ) && + ( extendedDynamicState3CoverageModulationTableEnable == rhs.extendedDynamicState3CoverageModulationTableEnable ) && + ( extendedDynamicState3CoverageModulationTable == rhs.extendedDynamicState3CoverageModulationTable ) && + ( extendedDynamicState3CoverageReductionMode == rhs.extendedDynamicState3CoverageReductionMode ) && + ( extendedDynamicState3RepresentativeFragmentTestEnable == rhs.extendedDynamicState3RepresentativeFragmentTestEnable ) && + ( extendedDynamicState3ShadingRateImageEnable == rhs.extendedDynamicState3ShadingRateImageEnable ); +# endif + } + + bool operator!=( PhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT; + void * pNext = {}; + Bool32 extendedDynamicState3TessellationDomainOrigin = {}; + Bool32 extendedDynamicState3DepthClampEnable = {}; + Bool32 extendedDynamicState3PolygonMode = {}; + Bool32 extendedDynamicState3RasterizationSamples = {}; + Bool32 extendedDynamicState3SampleMask = {}; + Bool32 extendedDynamicState3AlphaToCoverageEnable = {}; + Bool32 extendedDynamicState3AlphaToOneEnable = {}; + Bool32 extendedDynamicState3LogicOpEnable = {}; + Bool32 extendedDynamicState3ColorBlendEnable = {}; + Bool32 extendedDynamicState3ColorBlendEquation = {}; + Bool32 extendedDynamicState3ColorWriteMask = {}; + Bool32 extendedDynamicState3RasterizationStream = {}; + Bool32 extendedDynamicState3ConservativeRasterizationMode = {}; + Bool32 extendedDynamicState3ExtraPrimitiveOverestimationSize = {}; + Bool32 extendedDynamicState3DepthClipEnable = {}; + Bool32 extendedDynamicState3SampleLocationsEnable = {}; + Bool32 extendedDynamicState3ColorBlendAdvanced = {}; + Bool32 extendedDynamicState3ProvokingVertexMode = {}; + Bool32 extendedDynamicState3LineRasterizationMode = {}; + Bool32 extendedDynamicState3LineStippleEnable = {}; + Bool32 extendedDynamicState3DepthClipNegativeOneToOne = {}; + Bool32 extendedDynamicState3ViewportWScalingEnable = {}; + Bool32 extendedDynamicState3ViewportSwizzle = {}; + Bool32 extendedDynamicState3CoverageToColorEnable = {}; + Bool32 extendedDynamicState3CoverageToColorLocation = {}; + Bool32 extendedDynamicState3CoverageModulationMode = {}; + Bool32 extendedDynamicState3CoverageModulationTableEnable = {}; + Bool32 extendedDynamicState3CoverageModulationTable = {}; + Bool32 extendedDynamicState3CoverageReductionMode = {}; + Bool32 extendedDynamicState3RepresentativeFragmentTestEnable = {}; + Bool32 extendedDynamicState3ShadingRateImageEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedDynamicState3FeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedDynamicState3FeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicState3PropertiesEXT.html + struct PhysicalDeviceExtendedDynamicState3PropertiesEXT + { + using NativeType = VkPhysicalDeviceExtendedDynamicState3PropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicState3PropertiesEXT( Bool32 dynamicPrimitiveTopologyUnrestricted_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dynamicPrimitiveTopologyUnrestricted{ dynamicPrimitiveTopologyUnrestricted_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExtendedDynamicState3PropertiesEXT( PhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExtendedDynamicState3PropertiesEXT( VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExtendedDynamicState3PropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExtendedDynamicState3PropertiesEXT & operator=( PhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExtendedDynamicState3PropertiesEXT & operator=( VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicState3PropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dynamicPrimitiveTopologyUnrestricted ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExtendedDynamicState3PropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicPrimitiveTopologyUnrestricted == rhs.dynamicPrimitiveTopologyUnrestricted ); +# endif + } + + bool operator!=( PhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT; + void * pNext = {}; + Bool32 dynamicPrimitiveTopologyUnrestricted = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedDynamicState3PropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedDynamicState3PropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.html + struct PhysicalDeviceExtendedDynamicStateFeaturesEXT + { + using NativeType = VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicStateFeaturesEXT( Bool32 extendedDynamicState_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , extendedDynamicState{ extendedDynamicState_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExtendedDynamicStateFeaturesEXT( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExtendedDynamicStateFeaturesEXT( VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExtendedDynamicStateFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExtendedDynamicStateFeaturesEXT & operator=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExtendedDynamicStateFeaturesEXT & operator=( VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicStateFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicStateFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicStateFeaturesEXT & setExtendedDynamicState( Bool32 extendedDynamicState_ ) & VULKAN_HPP_NOEXCEPT + { + extendedDynamicState = extendedDynamicState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicStateFeaturesEXT && setExtendedDynamicState( Bool32 extendedDynamicState_ ) && VULKAN_HPP_NOEXCEPT + { + extendedDynamicState = extendedDynamicState_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, extendedDynamicState ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState == rhs.extendedDynamicState ); +# endif + } + + bool operator!=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT; + void * pNext = {}; + Bool32 extendedDynamicState = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedDynamicStateFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedDynamicStateFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.html + struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV + { + using NativeType = VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV( Bool32 extendedSparseAddressSpace_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , extendedSparseAddressSpace{ extendedSparseAddressSpace_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV( PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV( VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV & + operator=( PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV & operator=( VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV & setExtendedSparseAddressSpace( Bool32 extendedSparseAddressSpace_ ) & + VULKAN_HPP_NOEXCEPT + { + extendedSparseAddressSpace = extendedSparseAddressSpace_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV && setExtendedSparseAddressSpace( Bool32 extendedSparseAddressSpace_ ) && + VULKAN_HPP_NOEXCEPT + { + extendedSparseAddressSpace = extendedSparseAddressSpace_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, extendedSparseAddressSpace ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedSparseAddressSpace == rhs.extendedSparseAddressSpace ); +# endif + } + + bool operator!=( PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; + void * pNext = {}; + Bool32 extendedSparseAddressSpace = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV.html + struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV + { + using NativeType = VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedSparseAddressSpacePropertiesNV( DeviceSize extendedSparseAddressSpaceSize_ = {}, + ImageUsageFlags extendedSparseImageUsageFlags_ = {}, + BufferUsageFlags extendedSparseBufferUsageFlags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , extendedSparseAddressSpaceSize{ extendedSparseAddressSpaceSize_ } + , extendedSparseImageUsageFlags{ extendedSparseImageUsageFlags_ } + , extendedSparseBufferUsageFlags{ extendedSparseBufferUsageFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExtendedSparseAddressSpacePropertiesNV( PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExtendedSparseAddressSpacePropertiesNV( VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExtendedSparseAddressSpacePropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExtendedSparseAddressSpacePropertiesNV & + operator=( PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExtendedSparseAddressSpacePropertiesNV & operator=( VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, extendedSparseAddressSpaceSize, extendedSparseImageUsageFlags, extendedSparseBufferUsageFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedSparseAddressSpaceSize == rhs.extendedSparseAddressSpaceSize ) && + ( extendedSparseImageUsageFlags == rhs.extendedSparseImageUsageFlags ) && ( extendedSparseBufferUsageFlags == rhs.extendedSparseBufferUsageFlags ); +# endif + } + + bool operator!=( PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV; + void * pNext = {}; + DeviceSize extendedSparseAddressSpaceSize = {}; + ImageUsageFlags extendedSparseImageUsageFlags = {}; + BufferUsageFlags extendedSparseBufferUsageFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedSparseAddressSpacePropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExtendedSparseAddressSpacePropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceExternalBufferInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalBufferInfo.html + struct PhysicalDeviceExternalBufferInfo + { + using NativeType = VkPhysicalDeviceExternalBufferInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalBufferInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( BufferCreateFlags flags_ = {}, + BufferUsageFlags usage_ = {}, + ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , usage{ usage_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( PhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalBufferInfo( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalBufferInfo & operator=( PhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalBufferInfo & operator=( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo & setFlags( BufferCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo && setFlags( BufferCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo & setUsage( BufferUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo && setUsage( BufferUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExternalBufferInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalBufferInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalBufferInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalBufferInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, usage, handleType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalBufferInfo const & ) const = default; +#else + bool operator==( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo; + const void * pNext = {}; + BufferCreateFlags flags = {}; + BufferUsageFlags usage = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExternalBufferInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalBufferInfo; + }; + + using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; + + // wrapper struct for struct VkPhysicalDeviceExternalComputeQueuePropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalComputeQueuePropertiesNV.html + struct PhysicalDeviceExternalComputeQueuePropertiesNV + { + using NativeType = VkPhysicalDeviceExternalComputeQueuePropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalComputeQueuePropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalComputeQueuePropertiesNV( uint32_t externalDataSize_ = {}, + uint32_t maxExternalQueues_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , externalDataSize{ externalDataSize_ } + , maxExternalQueues{ maxExternalQueues_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExternalComputeQueuePropertiesNV( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalComputeQueuePropertiesNV( VkPhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalComputeQueuePropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalComputeQueuePropertiesNV & operator=( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalComputeQueuePropertiesNV & operator=( VkPhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceExternalComputeQueuePropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalComputeQueuePropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalComputeQueuePropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalComputeQueuePropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalDataSize, maxExternalQueues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalComputeQueuePropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalDataSize == rhs.externalDataSize ) && ( maxExternalQueues == rhs.maxExternalQueues ); +# endif + } + + bool operator!=( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExternalComputeQueuePropertiesNV; + void * pNext = {}; + uint32_t externalDataSize = {}; + uint32_t maxExternalQueues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExternalComputeQueuePropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalComputeQueuePropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceExternalFenceInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalFenceInfo.html + struct PhysicalDeviceExternalFenceInfo + { + using NativeType = VkPhysicalDeviceExternalFenceInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalFenceInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( PhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalFenceInfo( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalFenceInfo & operator=( PhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalFenceInfo & operator=( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFenceInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFenceInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFenceInfo & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFenceInfo && setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExternalFenceInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalFenceInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalFenceInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalFenceInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalFenceInfo const & ) const = default; +#else + bool operator==( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo; + const void * pNext = {}; + ExternalFenceHandleTypeFlagBits handleType = ExternalFenceHandleTypeFlagBits::eOpaqueFd; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExternalFenceInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalFenceInfo; + }; + + using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + // wrapper struct for struct VkPhysicalDeviceExternalFormatResolveFeaturesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.html + struct PhysicalDeviceExternalFormatResolveFeaturesANDROID + { + using NativeType = VkPhysicalDeviceExternalFormatResolveFeaturesANDROID; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFormatResolveFeaturesANDROID( Bool32 externalFormatResolve_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , externalFormatResolve{ externalFormatResolve_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExternalFormatResolveFeaturesANDROID( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalFormatResolveFeaturesANDROID( VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalFormatResolveFeaturesANDROID( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalFormatResolveFeaturesANDROID & + operator=( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalFormatResolveFeaturesANDROID & operator=( VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFormatResolveFeaturesANDROID & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFormatResolveFeaturesANDROID && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFormatResolveFeaturesANDROID & setExternalFormatResolve( Bool32 externalFormatResolve_ ) & VULKAN_HPP_NOEXCEPT + { + externalFormatResolve = externalFormatResolve_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFormatResolveFeaturesANDROID && setExternalFormatResolve( Bool32 externalFormatResolve_ ) && + VULKAN_HPP_NOEXCEPT + { + externalFormatResolve = externalFormatResolve_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalFormatResolveFeaturesANDROID &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalFormatResolve ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & ) const = default; +# else + bool operator==( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormatResolve == rhs.externalFormatResolve ); +# endif + } + + bool operator!=( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID; + void * pNext = {}; + Bool32 externalFormatResolve = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExternalFormatResolveFeaturesANDROID; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalFormatResolveFeaturesANDROID; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + // wrapper struct for struct VkPhysicalDeviceExternalFormatResolvePropertiesANDROID, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalFormatResolvePropertiesANDROID.html + struct PhysicalDeviceExternalFormatResolvePropertiesANDROID + { + using NativeType = VkPhysicalDeviceExternalFormatResolvePropertiesANDROID; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExternalFormatResolvePropertiesANDROID( Bool32 nullColorAttachmentWithExternalFormatResolve_ = {}, + ChromaLocation externalFormatResolveChromaOffsetX_ = ChromaLocation::eCositedEven, + ChromaLocation externalFormatResolveChromaOffsetY_ = ChromaLocation::eCositedEven, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , nullColorAttachmentWithExternalFormatResolve{ nullColorAttachmentWithExternalFormatResolve_ } + , externalFormatResolveChromaOffsetX{ externalFormatResolveChromaOffsetX_ } + , externalFormatResolveChromaOffsetY{ externalFormatResolveChromaOffsetY_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExternalFormatResolvePropertiesANDROID( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalFormatResolvePropertiesANDROID( VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalFormatResolvePropertiesANDROID( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalFormatResolvePropertiesANDROID & + operator=( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalFormatResolvePropertiesANDROID & operator=( VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalFormatResolvePropertiesANDROID &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalFormatResolvePropertiesANDROID *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, nullColorAttachmentWithExternalFormatResolve, externalFormatResolveChromaOffsetX, externalFormatResolveChromaOffsetY ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & ) const = default; +# else + bool operator==( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( nullColorAttachmentWithExternalFormatResolve == rhs.nullColorAttachmentWithExternalFormatResolve ) && + ( externalFormatResolveChromaOffsetX == rhs.externalFormatResolveChromaOffsetX ) && + ( externalFormatResolveChromaOffsetY == rhs.externalFormatResolveChromaOffsetY ); +# endif + } + + bool operator!=( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID; + void * pNext = {}; + Bool32 nullColorAttachmentWithExternalFormatResolve = {}; + ChromaLocation externalFormatResolveChromaOffsetX = ChromaLocation::eCositedEven; + ChromaLocation externalFormatResolveChromaOffsetY = ChromaLocation::eCositedEven; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExternalFormatResolvePropertiesANDROID; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalFormatResolvePropertiesANDROID; + }; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + + // wrapper struct for struct VkPhysicalDeviceExternalImageFormatInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalImageFormatInfo.html + struct PhysicalDeviceExternalImageFormatInfo + { + using NativeType = VkPhysicalDeviceExternalImageFormatInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalImageFormatInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( PhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalImageFormatInfo( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalImageFormatInfo & operator=( PhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalImageFormatInfo & operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalImageFormatInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalImageFormatInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalImageFormatInfo & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalImageFormatInfo && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExternalImageFormatInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalImageFormatInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalImageFormatInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalImageFormatInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalImageFormatInfo const & ) const = default; +#else + bool operator==( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo; + const void * pNext = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExternalImageFormatInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalImageFormatInfo; + }; + + using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo; + + // wrapper struct for struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html + struct PhysicalDeviceExternalMemoryHostPropertiesEXT + { + using NativeType = VkPhysicalDeviceExternalMemoryHostPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minImportedHostPointerAlignment{ minImportedHostPointerAlignment_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExternalMemoryHostPropertiesEXT( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalMemoryHostPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalMemoryHostPropertiesEXT & operator=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalMemoryHostPropertiesEXT & operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minImportedHostPointerAlignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalMemoryHostPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment ); +# endif + } + + bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; + void * pNext = {}; + DeviceSize minImportedHostPointerAlignment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExternalMemoryHostPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalMemoryHostPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.html + struct PhysicalDeviceExternalMemoryRDMAFeaturesNV + { + using NativeType = VkPhysicalDeviceExternalMemoryRDMAFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryRDMAFeaturesNV( Bool32 externalMemoryRDMA_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , externalMemoryRDMA{ externalMemoryRDMA_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryRDMAFeaturesNV( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalMemoryRDMAFeaturesNV( VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalMemoryRDMAFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalMemoryRDMAFeaturesNV & operator=( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalMemoryRDMAFeaturesNV & operator=( VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryRDMAFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryRDMAFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryRDMAFeaturesNV & setExternalMemoryRDMA( Bool32 externalMemoryRDMA_ ) & VULKAN_HPP_NOEXCEPT + { + externalMemoryRDMA = externalMemoryRDMA_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryRDMAFeaturesNV && setExternalMemoryRDMA( Bool32 externalMemoryRDMA_ ) && VULKAN_HPP_NOEXCEPT + { + externalMemoryRDMA = externalMemoryRDMA_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalMemoryRDMA ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryRDMA == rhs.externalMemoryRDMA ); +# endif + } + + bool operator!=( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV; + void * pNext = {}; + Bool32 externalMemoryRDMA = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExternalMemoryRDMAFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalMemoryRDMAFeaturesNV; + }; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + // wrapper struct for struct VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.html + struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX + { + using NativeType = VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( Bool32 screenBufferImport_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , screenBufferImport{ screenBufferImport_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX & + operator=( PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX & operator=( VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX & setScreenBufferImport( Bool32 screenBufferImport_ ) & VULKAN_HPP_NOEXCEPT + { + screenBufferImport = screenBufferImport_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX && setScreenBufferImport( Bool32 screenBufferImport_ ) && VULKAN_HPP_NOEXCEPT + { + screenBufferImport = screenBufferImport_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, screenBufferImport ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & ) const = default; +# else + bool operator==( PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( screenBufferImport == rhs.screenBufferImport ); +# endif + } + + bool operator!=( PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; + void * pNext = {}; + Bool32 screenBufferImport = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; + }; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + // wrapper struct for struct VkPhysicalDeviceExternalSemaphoreInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalSemaphoreInfo.html + struct PhysicalDeviceExternalSemaphoreInfo + { + using NativeType = VkPhysicalDeviceExternalSemaphoreInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( PhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalSemaphoreInfo( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalSemaphoreInfo & operator=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalSemaphoreInfo & operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalSemaphoreInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalSemaphoreInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalSemaphoreInfo & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalSemaphoreInfo && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExternalSemaphoreInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalSemaphoreInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalSemaphoreInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalSemaphoreInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, handleType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalSemaphoreInfo const & ) const = default; +#else + bool operator==( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; + const void * pNext = {}; + ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExternalSemaphoreInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalSemaphoreInfo; + }; + + using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; + + // wrapper struct for struct VkPhysicalDeviceExternalTensorInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalTensorInfoARM.html + struct PhysicalDeviceExternalTensorInfoARM + { + using NativeType = VkPhysicalDeviceExternalTensorInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalTensorInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalTensorInfoARM( TensorCreateFlagsARM flags_ = {}, + const TensorDescriptionARM * pDescription_ = {}, + ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pDescription{ pDescription_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalTensorInfoARM( PhysicalDeviceExternalTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalTensorInfoARM( VkPhysicalDeviceExternalTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalTensorInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalTensorInfoARM & operator=( PhysicalDeviceExternalTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalTensorInfoARM & operator=( VkPhysicalDeviceExternalTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM & setFlags( TensorCreateFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM && setFlags( TensorCreateFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM & setPDescription( const TensorDescriptionARM * pDescription_ ) & VULKAN_HPP_NOEXCEPT + { + pDescription = pDescription_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM && setPDescription( const TensorDescriptionARM * pDescription_ ) && VULKAN_HPP_NOEXCEPT + { + pDescription = pDescription_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceExternalTensorInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalTensorInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalTensorInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalTensorInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, pDescription, handleType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalTensorInfoARM const & ) const = default; +#else + bool operator==( PhysicalDeviceExternalTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pDescription == rhs.pDescription ) && + ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( PhysicalDeviceExternalTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceExternalTensorInfoARM; + const void * pNext = {}; + TensorCreateFlagsARM flags = {}; + const TensorDescriptionARM * pDescription = {}; + ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceExternalTensorInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalTensorInfoARM; + }; + + // wrapper struct for struct VkPhysicalDeviceFaultFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFaultFeaturesEXT.html + struct PhysicalDeviceFaultFeaturesEXT + { + using NativeType = VkPhysicalDeviceFaultFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFaultFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFaultFeaturesEXT( Bool32 deviceFault_ = {}, Bool32 deviceFaultVendorBinary_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceFault{ deviceFault_ } + , deviceFaultVendorBinary{ deviceFaultVendorBinary_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFaultFeaturesEXT( PhysicalDeviceFaultFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFaultFeaturesEXT( VkPhysicalDeviceFaultFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFaultFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFaultFeaturesEXT & operator=( PhysicalDeviceFaultFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFaultFeaturesEXT & operator=( VkPhysicalDeviceFaultFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT & setDeviceFault( Bool32 deviceFault_ ) & VULKAN_HPP_NOEXCEPT + { + deviceFault = deviceFault_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT && setDeviceFault( Bool32 deviceFault_ ) && VULKAN_HPP_NOEXCEPT + { + deviceFault = deviceFault_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT & setDeviceFaultVendorBinary( Bool32 deviceFaultVendorBinary_ ) & VULKAN_HPP_NOEXCEPT + { + deviceFaultVendorBinary = deviceFaultVendorBinary_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT && setDeviceFaultVendorBinary( Bool32 deviceFaultVendorBinary_ ) && VULKAN_HPP_NOEXCEPT + { + deviceFaultVendorBinary = deviceFaultVendorBinary_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFaultFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFaultFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFaultFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFaultFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceFault, deviceFaultVendorBinary ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFaultFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceFaultFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceFault == rhs.deviceFault ) && + ( deviceFaultVendorBinary == rhs.deviceFaultVendorBinary ); +# endif + } + + bool operator!=( PhysicalDeviceFaultFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFaultFeaturesEXT; + void * pNext = {}; + Bool32 deviceFault = {}; + Bool32 deviceFaultVendorBinary = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFaultFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFaultFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFeatures2.html + struct PhysicalDeviceFeatures2 + { + using NativeType = VkPhysicalDeviceFeatures2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFeatures2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( PhysicalDeviceFeatures features_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , features{ features_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( PhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFeatures2( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFeatures2 & operator=( PhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFeatures2 & operator=( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures2 & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures2 && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures2 & setFeatures( PhysicalDeviceFeatures const & features_ ) & VULKAN_HPP_NOEXCEPT + { + features = features_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures2 && setFeatures( PhysicalDeviceFeatures const & features_ ) && VULKAN_HPP_NOEXCEPT + { + features = features_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFeatures2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFeatures2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFeatures2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFeatures2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, features ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFeatures2 const & ) const = default; +#else + bool operator==( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( features == rhs.features ); +# endif + } + + bool operator!=( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFeatures2; + void * pNext = {}; + PhysicalDeviceFeatures features = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFeatures2; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFeatures2; + }; + + using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; + + // wrapper struct for struct VkPhysicalDeviceFloatControlsProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFloatControlsProperties.html + struct PhysicalDeviceFloatControlsProperties + { + using NativeType = VkPhysicalDeviceFloatControlsProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFloatControlsProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFloatControlsProperties( ShaderFloatControlsIndependence denormBehaviorIndependence_ = ShaderFloatControlsIndependence::e32BitOnly, + ShaderFloatControlsIndependence roundingModeIndependence_ = ShaderFloatControlsIndependence::e32BitOnly, + Bool32 shaderSignedZeroInfNanPreserveFloat16_ = {}, + Bool32 shaderSignedZeroInfNanPreserveFloat32_ = {}, + Bool32 shaderSignedZeroInfNanPreserveFloat64_ = {}, + Bool32 shaderDenormPreserveFloat16_ = {}, + Bool32 shaderDenormPreserveFloat32_ = {}, + Bool32 shaderDenormPreserveFloat64_ = {}, + Bool32 shaderDenormFlushToZeroFloat16_ = {}, + Bool32 shaderDenormFlushToZeroFloat32_ = {}, + Bool32 shaderDenormFlushToZeroFloat64_ = {}, + Bool32 shaderRoundingModeRTEFloat16_ = {}, + Bool32 shaderRoundingModeRTEFloat32_ = {}, + Bool32 shaderRoundingModeRTEFloat64_ = {}, + Bool32 shaderRoundingModeRTZFloat16_ = {}, + Bool32 shaderRoundingModeRTZFloat32_ = {}, + Bool32 shaderRoundingModeRTZFloat64_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , denormBehaviorIndependence{ denormBehaviorIndependence_ } + , roundingModeIndependence{ roundingModeIndependence_ } + , shaderSignedZeroInfNanPreserveFloat16{ shaderSignedZeroInfNanPreserveFloat16_ } + , shaderSignedZeroInfNanPreserveFloat32{ shaderSignedZeroInfNanPreserveFloat32_ } + , shaderSignedZeroInfNanPreserveFloat64{ shaderSignedZeroInfNanPreserveFloat64_ } + , shaderDenormPreserveFloat16{ shaderDenormPreserveFloat16_ } + , shaderDenormPreserveFloat32{ shaderDenormPreserveFloat32_ } + , shaderDenormPreserveFloat64{ shaderDenormPreserveFloat64_ } + , shaderDenormFlushToZeroFloat16{ shaderDenormFlushToZeroFloat16_ } + , shaderDenormFlushToZeroFloat32{ shaderDenormFlushToZeroFloat32_ } + , shaderDenormFlushToZeroFloat64{ shaderDenormFlushToZeroFloat64_ } + , shaderRoundingModeRTEFloat16{ shaderRoundingModeRTEFloat16_ } + , shaderRoundingModeRTEFloat32{ shaderRoundingModeRTEFloat32_ } + , shaderRoundingModeRTEFloat64{ shaderRoundingModeRTEFloat64_ } + , shaderRoundingModeRTZFloat16{ shaderRoundingModeRTZFloat16_ } + , shaderRoundingModeRTZFloat32{ shaderRoundingModeRTZFloat32_ } + , shaderRoundingModeRTZFloat64{ shaderRoundingModeRTZFloat64_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFloatControlsProperties( PhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFloatControlsProperties( VkPhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFloatControlsProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFloatControlsProperties & operator=( PhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFloatControlsProperties & operator=( VkPhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceFloatControlsProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFloatControlsProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFloatControlsProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFloatControlsProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + denormBehaviorIndependence, + roundingModeIndependence, + shaderSignedZeroInfNanPreserveFloat16, + shaderSignedZeroInfNanPreserveFloat32, + shaderSignedZeroInfNanPreserveFloat64, + shaderDenormPreserveFloat16, + shaderDenormPreserveFloat32, + shaderDenormPreserveFloat64, + shaderDenormFlushToZeroFloat16, + shaderDenormFlushToZeroFloat32, + shaderDenormFlushToZeroFloat64, + shaderRoundingModeRTEFloat16, + shaderRoundingModeRTEFloat32, + shaderRoundingModeRTEFloat64, + shaderRoundingModeRTZFloat16, + shaderRoundingModeRTZFloat32, + shaderRoundingModeRTZFloat64 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFloatControlsProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) && + ( roundingModeIndependence == rhs.roundingModeIndependence ) && + ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) && + ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) && + ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) && + ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) && ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) && + ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) && ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) && + ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) && + ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) && ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) && + ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) && ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) && + ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) && ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) && + ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 ); +# endif + } + + bool operator!=( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFloatControlsProperties; + void * pNext = {}; + ShaderFloatControlsIndependence denormBehaviorIndependence = ShaderFloatControlsIndependence::e32BitOnly; + ShaderFloatControlsIndependence roundingModeIndependence = ShaderFloatControlsIndependence::e32BitOnly; + Bool32 shaderSignedZeroInfNanPreserveFloat16 = {}; + Bool32 shaderSignedZeroInfNanPreserveFloat32 = {}; + Bool32 shaderSignedZeroInfNanPreserveFloat64 = {}; + Bool32 shaderDenormPreserveFloat16 = {}; + Bool32 shaderDenormPreserveFloat32 = {}; + Bool32 shaderDenormPreserveFloat64 = {}; + Bool32 shaderDenormFlushToZeroFloat16 = {}; + Bool32 shaderDenormFlushToZeroFloat32 = {}; + Bool32 shaderDenormFlushToZeroFloat64 = {}; + Bool32 shaderRoundingModeRTEFloat16 = {}; + Bool32 shaderRoundingModeRTEFloat32 = {}; + Bool32 shaderRoundingModeRTEFloat64 = {}; + Bool32 shaderRoundingModeRTZFloat16 = {}; + Bool32 shaderRoundingModeRTZFloat32 = {}; + Bool32 shaderRoundingModeRTZFloat64 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFloatControlsProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFloatControlsProperties; + }; + + using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties; + + // wrapper struct for struct VkPhysicalDeviceFormatPackFeaturesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFormatPackFeaturesARM.html + struct PhysicalDeviceFormatPackFeaturesARM + { + using NativeType = VkPhysicalDeviceFormatPackFeaturesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFormatPackFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFormatPackFeaturesARM( Bool32 formatPack_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , formatPack{ formatPack_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFormatPackFeaturesARM( PhysicalDeviceFormatPackFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFormatPackFeaturesARM( VkPhysicalDeviceFormatPackFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFormatPackFeaturesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFormatPackFeaturesARM & operator=( PhysicalDeviceFormatPackFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFormatPackFeaturesARM & operator=( VkPhysicalDeviceFormatPackFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFormatPackFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFormatPackFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFormatPackFeaturesARM & setFormatPack( Bool32 formatPack_ ) & VULKAN_HPP_NOEXCEPT + { + formatPack = formatPack_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFormatPackFeaturesARM && setFormatPack( Bool32 formatPack_ ) && VULKAN_HPP_NOEXCEPT + { + formatPack = formatPack_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFormatPackFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFormatPackFeaturesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFormatPackFeaturesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFormatPackFeaturesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatPack ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFormatPackFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceFormatPackFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatPack == rhs.formatPack ); +# endif + } + + bool operator!=( PhysicalDeviceFormatPackFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFormatPackFeaturesARM; + void * pNext = {}; + Bool32 formatPack = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFormatPackFeaturesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFormatPackFeaturesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.html + struct PhysicalDeviceFragmentDensityMap2FeaturesEXT + { + using NativeType = VkPhysicalDeviceFragmentDensityMap2FeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMap2FeaturesEXT( Bool32 fragmentDensityMapDeferred_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fragmentDensityMapDeferred{ fragmentDensityMapDeferred_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMap2FeaturesEXT( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMap2FeaturesEXT( VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentDensityMap2FeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentDensityMap2FeaturesEXT & operator=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentDensityMap2FeaturesEXT & operator=( VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMap2FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMap2FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMap2FeaturesEXT & setFragmentDensityMapDeferred( Bool32 fragmentDensityMapDeferred_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapDeferred = fragmentDensityMapDeferred_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMap2FeaturesEXT && setFragmentDensityMapDeferred( Bool32 fragmentDensityMapDeferred_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapDeferred = fragmentDensityMapDeferred_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityMapDeferred ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMapDeferred == rhs.fragmentDensityMapDeferred ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT; + void * pNext = {}; + Bool32 fragmentDensityMapDeferred = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMap2FeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMap2FeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html + struct PhysicalDeviceFragmentDensityMap2PropertiesEXT + { + using NativeType = VkPhysicalDeviceFragmentDensityMap2PropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMap2PropertiesEXT( Bool32 subsampledLoads_ = {}, + Bool32 subsampledCoarseReconstructionEarlyAccess_ = {}, + uint32_t maxSubsampledArrayLayers_ = {}, + uint32_t maxDescriptorSetSubsampledSamplers_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , subsampledLoads{ subsampledLoads_ } + , subsampledCoarseReconstructionEarlyAccess{ subsampledCoarseReconstructionEarlyAccess_ } + , maxSubsampledArrayLayers{ maxSubsampledArrayLayers_ } + , maxDescriptorSetSubsampledSamplers{ maxDescriptorSetSubsampledSamplers_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentDensityMap2PropertiesEXT( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMap2PropertiesEXT( VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentDensityMap2PropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentDensityMap2PropertiesEXT & operator=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentDensityMap2PropertiesEXT & operator=( VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subsampledLoads, subsampledCoarseReconstructionEarlyAccess, maxSubsampledArrayLayers, maxDescriptorSetSubsampledSamplers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledLoads == rhs.subsampledLoads ) && + ( subsampledCoarseReconstructionEarlyAccess == rhs.subsampledCoarseReconstructionEarlyAccess ) && + ( maxSubsampledArrayLayers == rhs.maxSubsampledArrayLayers ) && ( maxDescriptorSetSubsampledSamplers == rhs.maxDescriptorSetSubsampledSamplers ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT; + void * pNext = {}; + Bool32 subsampledLoads = {}; + Bool32 subsampledCoarseReconstructionEarlyAccess = {}; + uint32_t maxSubsampledArrayLayers = {}; + uint32_t maxDescriptorSetSubsampledSamplers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMap2PropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMap2PropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html + struct PhysicalDeviceFragmentDensityMapFeaturesEXT + { + using NativeType = VkPhysicalDeviceFragmentDensityMapFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapFeaturesEXT( Bool32 fragmentDensityMap_ = {}, + Bool32 fragmentDensityMapDynamic_ = {}, + Bool32 fragmentDensityMapNonSubsampledImages_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fragmentDensityMap{ fragmentDensityMap_ } + , fragmentDensityMapDynamic{ fragmentDensityMapDynamic_ } + , fragmentDensityMapNonSubsampledImages{ fragmentDensityMapNonSubsampledImages_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapFeaturesEXT( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentDensityMapFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentDensityMapFeaturesEXT & operator=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentDensityMapFeaturesEXT & operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT & setFragmentDensityMap( Bool32 fragmentDensityMap_ ) & VULKAN_HPP_NOEXCEPT + { + fragmentDensityMap = fragmentDensityMap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT && setFragmentDensityMap( Bool32 fragmentDensityMap_ ) && VULKAN_HPP_NOEXCEPT + { + fragmentDensityMap = fragmentDensityMap_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT & setFragmentDensityMapDynamic( Bool32 fragmentDensityMapDynamic_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapDynamic = fragmentDensityMapDynamic_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT && setFragmentDensityMapDynamic( Bool32 fragmentDensityMapDynamic_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapDynamic = fragmentDensityMapDynamic_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT & + setFragmentDensityMapNonSubsampledImages( Bool32 fragmentDensityMapNonSubsampledImages_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapNonSubsampledImages = fragmentDensityMapNonSubsampledImages_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT && + setFragmentDensityMapNonSubsampledImages( Bool32 fragmentDensityMapNonSubsampledImages_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapNonSubsampledImages = fragmentDensityMapNonSubsampledImages_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityMap, fragmentDensityMapDynamic, fragmentDensityMapNonSubsampledImages ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentDensityMapFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMap == rhs.fragmentDensityMap ) && + ( fragmentDensityMapDynamic == rhs.fragmentDensityMapDynamic ) && + ( fragmentDensityMapNonSubsampledImages == rhs.fragmentDensityMapNonSubsampledImages ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; + void * pNext = {}; + Bool32 fragmentDensityMap = {}; + Bool32 fragmentDensityMapDynamic = {}; + Bool32 fragmentDensityMapNonSubsampledImages = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE.html + struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE + { + using NativeType = VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE( Bool32 fragmentDensityMapLayered_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fragmentDensityMapLayered{ fragmentDensityMapLayered_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE( VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & + operator=( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & operator=( VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & setFragmentDensityMapLayered( Bool32 fragmentDensityMapLayered_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapLayered = fragmentDensityMapLayered_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE && setFragmentDensityMapLayered( Bool32 fragmentDensityMapLayered_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapLayered = fragmentDensityMapLayered_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityMapLayered ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMapLayered == rhs.fragmentDensityMapLayered ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; + void * pNext = {}; + Bool32 fragmentDensityMapLayered = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE.html + struct PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE + { + using NativeType = VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE( uint32_t maxFragmentDensityMapLayers_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxFragmentDensityMapLayers{ maxFragmentDensityMapLayers_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE( VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE & + operator=( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE & + operator=( VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxFragmentDensityMapLayers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxFragmentDensityMapLayers == rhs.maxFragmentDensityMapLayers ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; + void * pNext = {}; + uint32_t maxFragmentDensityMapLayers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.html + struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT + { + using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( Bool32 fragmentDensityMapOffset_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fragmentDensityMapOffset{ fragmentDensityMapOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & + operator=( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & operator=( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & setFragmentDensityMapOffset( Bool32 fragmentDensityMapOffset_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapOffset = fragmentDensityMapOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT && setFragmentDensityMapOffset( Bool32 fragmentDensityMapOffset_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapOffset = fragmentDensityMapOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityMapOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMapOffset == rhs.fragmentDensityMapOffset ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; + void * pNext = {}; + Bool32 fragmentDensityMapOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; + }; + + using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; + + // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.html + struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT + { + using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( Extent2D fragmentDensityOffsetGranularity_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fragmentDensityOffsetGranularity{ fragmentDensityOffsetGranularity_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT & + operator=( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT & operator=( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityOffsetGranularity ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityOffsetGranularity == rhs.fragmentDensityOffsetGranularity ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; + void * pNext = {}; + Extent2D fragmentDensityOffsetGranularity = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; + }; + + using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; + + // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html + struct PhysicalDeviceFragmentDensityMapPropertiesEXT + { + using NativeType = VkPhysicalDeviceFragmentDensityMapPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapPropertiesEXT( Extent2D minFragmentDensityTexelSize_ = {}, + Extent2D maxFragmentDensityTexelSize_ = {}, + Bool32 fragmentDensityInvocations_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minFragmentDensityTexelSize{ minFragmentDensityTexelSize_ } + , maxFragmentDensityTexelSize{ maxFragmentDensityTexelSize_ } + , fragmentDensityInvocations{ fragmentDensityInvocations_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentDensityMapPropertiesEXT( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentDensityMapPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentDensityMapPropertiesEXT & operator=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentDensityMapPropertiesEXT & operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minFragmentDensityTexelSize, maxFragmentDensityTexelSize, fragmentDensityInvocations ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentDensityMapPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minFragmentDensityTexelSize == rhs.minFragmentDensityTexelSize ) && + ( maxFragmentDensityTexelSize == rhs.maxFragmentDensityTexelSize ) && ( fragmentDensityInvocations == rhs.fragmentDensityInvocations ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; + void * pNext = {}; + Extent2D minFragmentDensityTexelSize = {}; + Extent2D maxFragmentDensityTexelSize = {}; + Bool32 fragmentDensityInvocations = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentDensityMapPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.html + struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR + { + using NativeType = VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesKHR( Bool32 fragmentShaderBarycentric_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fragmentShaderBarycentric{ fragmentShaderBarycentric_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentShaderBarycentricFeaturesKHR( PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentShaderBarycentricFeaturesKHR( VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentShaderBarycentricFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentShaderBarycentricFeaturesKHR & + operator=( PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentShaderBarycentricFeaturesKHR & operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderBarycentricFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderBarycentricFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderBarycentricFeaturesKHR & setFragmentShaderBarycentric( Bool32 fragmentShaderBarycentric_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentShaderBarycentric = fragmentShaderBarycentric_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderBarycentricFeaturesKHR && setFragmentShaderBarycentric( Bool32 fragmentShaderBarycentric_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentShaderBarycentric = fragmentShaderBarycentric_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentShaderBarycentric ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + void * pNext = {}; + Bool32 fragmentShaderBarycentric = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + }; + + using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + + // wrapper struct for struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR.html + struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR + { + using NativeType = VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricPropertiesKHR( Bool32 triStripVertexOrderIndependentOfProvokingVertex_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , triStripVertexOrderIndependentOfProvokingVertex{ triStripVertexOrderIndependentOfProvokingVertex_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentShaderBarycentricPropertiesKHR( PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentShaderBarycentricPropertiesKHR( VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentShaderBarycentricPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentShaderBarycentricPropertiesKHR & + operator=( PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentShaderBarycentricPropertiesKHR & operator=( VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, triStripVertexOrderIndependentOfProvokingVertex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( triStripVertexOrderIndependentOfProvokingVertex == rhs.triStripVertexOrderIndependentOfProvokingVertex ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + void * pNext = {}; + Bool32 triStripVertexOrderIndependentOfProvokingVertex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html + struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT + { + using NativeType = VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( Bool32 fragmentShaderSampleInterlock_ = {}, + Bool32 fragmentShaderPixelInterlock_ = {}, + Bool32 fragmentShaderShadingRateInterlock_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fragmentShaderSampleInterlock{ fragmentShaderSampleInterlock_ } + , fragmentShaderPixelInterlock{ fragmentShaderPixelInterlock_ } + , fragmentShaderShadingRateInterlock{ fragmentShaderShadingRateInterlock_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentShaderInterlockFeaturesEXT( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentShaderInterlockFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentShaderInterlockFeaturesEXT & operator=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentShaderInterlockFeaturesEXT & operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderSampleInterlock( Bool32 fragmentShaderSampleInterlock_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentShaderSampleInterlock = fragmentShaderSampleInterlock_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT && setFragmentShaderSampleInterlock( Bool32 fragmentShaderSampleInterlock_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentShaderSampleInterlock = fragmentShaderSampleInterlock_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderPixelInterlock( Bool32 fragmentShaderPixelInterlock_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentShaderPixelInterlock = fragmentShaderPixelInterlock_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT && setFragmentShaderPixelInterlock( Bool32 fragmentShaderPixelInterlock_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentShaderPixelInterlock = fragmentShaderPixelInterlock_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT & + setFragmentShaderShadingRateInterlock( Bool32 fragmentShaderShadingRateInterlock_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentShaderShadingRateInterlock = fragmentShaderShadingRateInterlock_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT && + setFragmentShaderShadingRateInterlock( Bool32 fragmentShaderShadingRateInterlock_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentShaderShadingRateInterlock = fragmentShaderShadingRateInterlock_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentShaderSampleInterlock, fragmentShaderPixelInterlock, fragmentShaderShadingRateInterlock ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentShaderSampleInterlock == rhs.fragmentShaderSampleInterlock ) && + ( fragmentShaderPixelInterlock == rhs.fragmentShaderPixelInterlock ) && + ( fragmentShaderShadingRateInterlock == rhs.fragmentShaderShadingRateInterlock ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT; + void * pNext = {}; + Bool32 fragmentShaderSampleInterlock = {}; + Bool32 fragmentShaderPixelInterlock = {}; + Bool32 fragmentShaderShadingRateInterlock = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html + struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV + { + using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShadingRateEnumsFeaturesNV( Bool32 fragmentShadingRateEnums_ = {}, + Bool32 supersampleFragmentShadingRates_ = {}, + Bool32 noInvocationFragmentShadingRates_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fragmentShadingRateEnums{ fragmentShadingRateEnums_ } + , supersampleFragmentShadingRates{ supersampleFragmentShadingRates_ } + , noInvocationFragmentShadingRates{ noInvocationFragmentShadingRates_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentShadingRateEnumsFeaturesNV( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentShadingRateEnumsFeaturesNV( VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentShadingRateEnumsFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & operator=( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & operator=( VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & setFragmentShadingRateEnums( Bool32 fragmentShadingRateEnums_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentShadingRateEnums = fragmentShadingRateEnums_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV && setFragmentShadingRateEnums( Bool32 fragmentShadingRateEnums_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentShadingRateEnums = fragmentShadingRateEnums_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & setSupersampleFragmentShadingRates( Bool32 supersampleFragmentShadingRates_ ) & + VULKAN_HPP_NOEXCEPT + { + supersampleFragmentShadingRates = supersampleFragmentShadingRates_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV && setSupersampleFragmentShadingRates( Bool32 supersampleFragmentShadingRates_ ) && + VULKAN_HPP_NOEXCEPT + { + supersampleFragmentShadingRates = supersampleFragmentShadingRates_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & setNoInvocationFragmentShadingRates( Bool32 noInvocationFragmentShadingRates_ ) & + VULKAN_HPP_NOEXCEPT + { + noInvocationFragmentShadingRates = noInvocationFragmentShadingRates_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV && + setNoInvocationFragmentShadingRates( Bool32 noInvocationFragmentShadingRates_ ) && + VULKAN_HPP_NOEXCEPT + { + noInvocationFragmentShadingRates = noInvocationFragmentShadingRates_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentShadingRateEnums, supersampleFragmentShadingRates, noInvocationFragmentShadingRates ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentShadingRateEnums == rhs.fragmentShadingRateEnums ) && + ( supersampleFragmentShadingRates == rhs.supersampleFragmentShadingRates ) && + ( noInvocationFragmentShadingRates == rhs.noInvocationFragmentShadingRates ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + void * pNext = {}; + Bool32 fragmentShadingRateEnums = {}; + Bool32 supersampleFragmentShadingRates = {}; + Bool32 noInvocationFragmentShadingRates = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.html + struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV + { + using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentShadingRateEnumsPropertiesNV( SampleCountFlagBits maxFragmentShadingRateInvocationCount_ = SampleCountFlagBits::e1, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxFragmentShadingRateInvocationCount{ maxFragmentShadingRateInvocationCount_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentShadingRateEnumsPropertiesNV( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentShadingRateEnumsPropertiesNV( VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentShadingRateEnumsPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentShadingRateEnumsPropertiesNV & + operator=( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentShadingRateEnumsPropertiesNV & operator=( VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxFragmentShadingRateInvocationCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxFragmentShadingRateInvocationCount == rhs.maxFragmentShadingRateInvocationCount ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + void * pNext = {}; + SampleCountFlagBits maxFragmentShadingRateInvocationCount = SampleCountFlagBits::e1; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html + struct PhysicalDeviceFragmentShadingRateFeaturesKHR + { + using NativeType = VkPhysicalDeviceFragmentShadingRateFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShadingRateFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShadingRateFeaturesKHR( Bool32 pipelineFragmentShadingRate_ = {}, + Bool32 primitiveFragmentShadingRate_ = {}, + Bool32 attachmentFragmentShadingRate_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineFragmentShadingRate{ pipelineFragmentShadingRate_ } + , primitiveFragmentShadingRate{ primitiveFragmentShadingRate_ } + , attachmentFragmentShadingRate{ attachmentFragmentShadingRate_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShadingRateFeaturesKHR( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentShadingRateFeaturesKHR( VkPhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentShadingRateFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentShadingRateFeaturesKHR & operator=( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentShadingRateFeaturesKHR & operator=( VkPhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR & setPipelineFragmentShadingRate( Bool32 pipelineFragmentShadingRate_ ) & + VULKAN_HPP_NOEXCEPT + { + pipelineFragmentShadingRate = pipelineFragmentShadingRate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR && setPipelineFragmentShadingRate( Bool32 pipelineFragmentShadingRate_ ) && + VULKAN_HPP_NOEXCEPT + { + pipelineFragmentShadingRate = pipelineFragmentShadingRate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR & setPrimitiveFragmentShadingRate( Bool32 primitiveFragmentShadingRate_ ) & + VULKAN_HPP_NOEXCEPT + { + primitiveFragmentShadingRate = primitiveFragmentShadingRate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR && setPrimitiveFragmentShadingRate( Bool32 primitiveFragmentShadingRate_ ) && + VULKAN_HPP_NOEXCEPT + { + primitiveFragmentShadingRate = primitiveFragmentShadingRate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR & setAttachmentFragmentShadingRate( Bool32 attachmentFragmentShadingRate_ ) & + VULKAN_HPP_NOEXCEPT + { + attachmentFragmentShadingRate = attachmentFragmentShadingRate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR && setAttachmentFragmentShadingRate( Bool32 attachmentFragmentShadingRate_ ) && + VULKAN_HPP_NOEXCEPT + { + attachmentFragmentShadingRate = attachmentFragmentShadingRate_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineFragmentShadingRate, primitiveFragmentShadingRate, attachmentFragmentShadingRate ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentShadingRateFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineFragmentShadingRate == rhs.pipelineFragmentShadingRate ) && + ( primitiveFragmentShadingRate == rhs.primitiveFragmentShadingRate ) && ( attachmentFragmentShadingRate == rhs.attachmentFragmentShadingRate ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentShadingRateFeaturesKHR; + void * pNext = {}; + Bool32 pipelineFragmentShadingRate = {}; + Bool32 primitiveFragmentShadingRate = {}; + Bool32 attachmentFragmentShadingRate = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShadingRateFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShadingRateFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentShadingRateKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateKHR.html + struct PhysicalDeviceFragmentShadingRateKHR + { + using NativeType = VkPhysicalDeviceFragmentShadingRateKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShadingRateKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentShadingRateKHR( SampleCountFlags sampleCounts_ = {}, Extent2D fragmentSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , sampleCounts{ sampleCounts_ } + , fragmentSize{ fragmentSize_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShadingRateKHR( PhysicalDeviceFragmentShadingRateKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentShadingRateKHR( VkPhysicalDeviceFragmentShadingRateKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentShadingRateKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentShadingRateKHR & operator=( PhysicalDeviceFragmentShadingRateKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentShadingRateKHR & operator=( VkPhysicalDeviceFragmentShadingRateKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceFragmentShadingRateKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRateKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sampleCounts, fragmentSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentShadingRateKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleCounts == rhs.sampleCounts ) && ( fragmentSize == rhs.fragmentSize ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentShadingRateKHR; + void * pNext = {}; + SampleCountFlags sampleCounts = {}; + Extent2D fragmentSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShadingRateKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShadingRateKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html + struct PhysicalDeviceFragmentShadingRatePropertiesKHR + { + using NativeType = VkPhysicalDeviceFragmentShadingRatePropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShadingRatePropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentShadingRatePropertiesKHR( Extent2D minFragmentShadingRateAttachmentTexelSize_ = {}, + Extent2D maxFragmentShadingRateAttachmentTexelSize_ = {}, + uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio_ = {}, + Bool32 primitiveFragmentShadingRateWithMultipleViewports_ = {}, + Bool32 layeredShadingRateAttachments_ = {}, + Bool32 fragmentShadingRateNonTrivialCombinerOps_ = {}, + Extent2D maxFragmentSize_ = {}, + uint32_t maxFragmentSizeAspectRatio_ = {}, + uint32_t maxFragmentShadingRateCoverageSamples_ = {}, + SampleCountFlagBits maxFragmentShadingRateRasterizationSamples_ = SampleCountFlagBits::e1, + Bool32 fragmentShadingRateWithShaderDepthStencilWrites_ = {}, + Bool32 fragmentShadingRateWithSampleMask_ = {}, + Bool32 fragmentShadingRateWithShaderSampleMask_ = {}, + Bool32 fragmentShadingRateWithConservativeRasterization_ = {}, + Bool32 fragmentShadingRateWithFragmentShaderInterlock_ = {}, + Bool32 fragmentShadingRateWithCustomSampleLocations_ = {}, + Bool32 fragmentShadingRateStrictMultiplyCombiner_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minFragmentShadingRateAttachmentTexelSize{ minFragmentShadingRateAttachmentTexelSize_ } + , maxFragmentShadingRateAttachmentTexelSize{ maxFragmentShadingRateAttachmentTexelSize_ } + , maxFragmentShadingRateAttachmentTexelSizeAspectRatio{ maxFragmentShadingRateAttachmentTexelSizeAspectRatio_ } + , primitiveFragmentShadingRateWithMultipleViewports{ primitiveFragmentShadingRateWithMultipleViewports_ } + , layeredShadingRateAttachments{ layeredShadingRateAttachments_ } + , fragmentShadingRateNonTrivialCombinerOps{ fragmentShadingRateNonTrivialCombinerOps_ } + , maxFragmentSize{ maxFragmentSize_ } + , maxFragmentSizeAspectRatio{ maxFragmentSizeAspectRatio_ } + , maxFragmentShadingRateCoverageSamples{ maxFragmentShadingRateCoverageSamples_ } + , maxFragmentShadingRateRasterizationSamples{ maxFragmentShadingRateRasterizationSamples_ } + , fragmentShadingRateWithShaderDepthStencilWrites{ fragmentShadingRateWithShaderDepthStencilWrites_ } + , fragmentShadingRateWithSampleMask{ fragmentShadingRateWithSampleMask_ } + , fragmentShadingRateWithShaderSampleMask{ fragmentShadingRateWithShaderSampleMask_ } + , fragmentShadingRateWithConservativeRasterization{ fragmentShadingRateWithConservativeRasterization_ } + , fragmentShadingRateWithFragmentShaderInterlock{ fragmentShadingRateWithFragmentShaderInterlock_ } + , fragmentShadingRateWithCustomSampleLocations{ fragmentShadingRateWithCustomSampleLocations_ } + , fragmentShadingRateStrictMultiplyCombiner{ fragmentShadingRateStrictMultiplyCombiner_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceFragmentShadingRatePropertiesKHR( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFragmentShadingRatePropertiesKHR( VkPhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFragmentShadingRatePropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFragmentShadingRatePropertiesKHR & operator=( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFragmentShadingRatePropertiesKHR & operator=( VkPhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + minFragmentShadingRateAttachmentTexelSize, + maxFragmentShadingRateAttachmentTexelSize, + maxFragmentShadingRateAttachmentTexelSizeAspectRatio, + primitiveFragmentShadingRateWithMultipleViewports, + layeredShadingRateAttachments, + fragmentShadingRateNonTrivialCombinerOps, + maxFragmentSize, + maxFragmentSizeAspectRatio, + maxFragmentShadingRateCoverageSamples, + maxFragmentShadingRateRasterizationSamples, + fragmentShadingRateWithShaderDepthStencilWrites, + fragmentShadingRateWithSampleMask, + fragmentShadingRateWithShaderSampleMask, + fragmentShadingRateWithConservativeRasterization, + fragmentShadingRateWithFragmentShaderInterlock, + fragmentShadingRateWithCustomSampleLocations, + fragmentShadingRateStrictMultiplyCombiner ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFragmentShadingRatePropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( minFragmentShadingRateAttachmentTexelSize == rhs.minFragmentShadingRateAttachmentTexelSize ) && + ( maxFragmentShadingRateAttachmentTexelSize == rhs.maxFragmentShadingRateAttachmentTexelSize ) && + ( maxFragmentShadingRateAttachmentTexelSizeAspectRatio == rhs.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ) && + ( primitiveFragmentShadingRateWithMultipleViewports == rhs.primitiveFragmentShadingRateWithMultipleViewports ) && + ( layeredShadingRateAttachments == rhs.layeredShadingRateAttachments ) && + ( fragmentShadingRateNonTrivialCombinerOps == rhs.fragmentShadingRateNonTrivialCombinerOps ) && ( maxFragmentSize == rhs.maxFragmentSize ) && + ( maxFragmentSizeAspectRatio == rhs.maxFragmentSizeAspectRatio ) && + ( maxFragmentShadingRateCoverageSamples == rhs.maxFragmentShadingRateCoverageSamples ) && + ( maxFragmentShadingRateRasterizationSamples == rhs.maxFragmentShadingRateRasterizationSamples ) && + ( fragmentShadingRateWithShaderDepthStencilWrites == rhs.fragmentShadingRateWithShaderDepthStencilWrites ) && + ( fragmentShadingRateWithSampleMask == rhs.fragmentShadingRateWithSampleMask ) && + ( fragmentShadingRateWithShaderSampleMask == rhs.fragmentShadingRateWithShaderSampleMask ) && + ( fragmentShadingRateWithConservativeRasterization == rhs.fragmentShadingRateWithConservativeRasterization ) && + ( fragmentShadingRateWithFragmentShaderInterlock == rhs.fragmentShadingRateWithFragmentShaderInterlock ) && + ( fragmentShadingRateWithCustomSampleLocations == rhs.fragmentShadingRateWithCustomSampleLocations ) && + ( fragmentShadingRateStrictMultiplyCombiner == rhs.fragmentShadingRateStrictMultiplyCombiner ); +# endif + } + + bool operator!=( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFragmentShadingRatePropertiesKHR; + void * pNext = {}; + Extent2D minFragmentShadingRateAttachmentTexelSize = {}; + Extent2D maxFragmentShadingRateAttachmentTexelSize = {}; + uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio = {}; + Bool32 primitiveFragmentShadingRateWithMultipleViewports = {}; + Bool32 layeredShadingRateAttachments = {}; + Bool32 fragmentShadingRateNonTrivialCombinerOps = {}; + Extent2D maxFragmentSize = {}; + uint32_t maxFragmentSizeAspectRatio = {}; + uint32_t maxFragmentShadingRateCoverageSamples = {}; + SampleCountFlagBits maxFragmentShadingRateRasterizationSamples = SampleCountFlagBits::e1; + Bool32 fragmentShadingRateWithShaderDepthStencilWrites = {}; + Bool32 fragmentShadingRateWithSampleMask = {}; + Bool32 fragmentShadingRateWithShaderSampleMask = {}; + Bool32 fragmentShadingRateWithConservativeRasterization = {}; + Bool32 fragmentShadingRateWithFragmentShaderInterlock = {}; + Bool32 fragmentShadingRateWithCustomSampleLocations = {}; + Bool32 fragmentShadingRateStrictMultiplyCombiner = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShadingRatePropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFragmentShadingRatePropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceFrameBoundaryFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFrameBoundaryFeaturesEXT.html + struct PhysicalDeviceFrameBoundaryFeaturesEXT + { + using NativeType = VkPhysicalDeviceFrameBoundaryFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceFrameBoundaryFeaturesEXT( Bool32 frameBoundary_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , frameBoundary{ frameBoundary_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceFrameBoundaryFeaturesEXT( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceFrameBoundaryFeaturesEXT( VkPhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceFrameBoundaryFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceFrameBoundaryFeaturesEXT & operator=( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceFrameBoundaryFeaturesEXT & operator=( VkPhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT & setFrameBoundary( Bool32 frameBoundary_ ) & VULKAN_HPP_NOEXCEPT + { + frameBoundary = frameBoundary_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT && setFrameBoundary( Bool32 frameBoundary_ ) && VULKAN_HPP_NOEXCEPT + { + frameBoundary = frameBoundary_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceFrameBoundaryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFrameBoundaryFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFrameBoundaryFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceFrameBoundaryFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, frameBoundary ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceFrameBoundaryFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( frameBoundary == rhs.frameBoundary ); +# endif + } + + bool operator!=( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT; + void * pNext = {}; + Bool32 frameBoundary = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceFrameBoundaryFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceFrameBoundaryFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceGlobalPriorityQueryFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGlobalPriorityQueryFeatures.html + struct PhysicalDeviceGlobalPriorityQueryFeatures + { + using NativeType = VkPhysicalDeviceGlobalPriorityQueryFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGlobalPriorityQueryFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceGlobalPriorityQueryFeatures( Bool32 globalPriorityQuery_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , globalPriorityQuery{ globalPriorityQuery_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceGlobalPriorityQueryFeatures( PhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceGlobalPriorityQueryFeatures( VkPhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceGlobalPriorityQueryFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceGlobalPriorityQueryFeatures & operator=( PhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceGlobalPriorityQueryFeatures & operator=( VkPhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGlobalPriorityQueryFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGlobalPriorityQueryFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGlobalPriorityQueryFeatures & setGlobalPriorityQuery( Bool32 globalPriorityQuery_ ) & VULKAN_HPP_NOEXCEPT + { + globalPriorityQuery = globalPriorityQuery_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGlobalPriorityQueryFeatures && setGlobalPriorityQuery( Bool32 globalPriorityQuery_ ) && VULKAN_HPP_NOEXCEPT + { + globalPriorityQuery = globalPriorityQuery_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceGlobalPriorityQueryFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGlobalPriorityQueryFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGlobalPriorityQueryFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGlobalPriorityQueryFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, globalPriorityQuery ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceGlobalPriorityQueryFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriorityQuery == rhs.globalPriorityQuery ); +# endif + } + + bool operator!=( PhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceGlobalPriorityQueryFeatures; + void * pNext = {}; + Bool32 globalPriorityQuery = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceGlobalPriorityQueryFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceGlobalPriorityQueryFeatures; + }; + + using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeatures; + using PhysicalDeviceGlobalPriorityQueryFeaturesKHR = PhysicalDeviceGlobalPriorityQueryFeatures; + + // wrapper struct for struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.html + struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT + { + using NativeType = VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT( Bool32 graphicsPipelineLibrary_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , graphicsPipelineLibrary{ graphicsPipelineLibrary_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT( PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT( VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT & operator=( PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT & operator=( VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT & setGraphicsPipelineLibrary( Bool32 graphicsPipelineLibrary_ ) & + VULKAN_HPP_NOEXCEPT + { + graphicsPipelineLibrary = graphicsPipelineLibrary_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT && setGraphicsPipelineLibrary( Bool32 graphicsPipelineLibrary_ ) && + VULKAN_HPP_NOEXCEPT + { + graphicsPipelineLibrary = graphicsPipelineLibrary_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, graphicsPipelineLibrary ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( graphicsPipelineLibrary == rhs.graphicsPipelineLibrary ); +# endif + } + + bool operator!=( PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + void * pNext = {}; + Bool32 graphicsPipelineLibrary = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.html + struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT + { + using NativeType = VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT( Bool32 graphicsPipelineLibraryFastLinking_ = {}, + Bool32 graphicsPipelineLibraryIndependentInterpolationDecoration_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , graphicsPipelineLibraryFastLinking{ graphicsPipelineLibraryFastLinking_ } + , graphicsPipelineLibraryIndependentInterpolationDecoration{ graphicsPipelineLibraryIndependentInterpolationDecoration_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT( PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT( VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT & + operator=( PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT & operator=( VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, graphicsPipelineLibraryFastLinking, graphicsPipelineLibraryIndependentInterpolationDecoration ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( graphicsPipelineLibraryFastLinking == rhs.graphicsPipelineLibraryFastLinking ) && + ( graphicsPipelineLibraryIndependentInterpolationDecoration == rhs.graphicsPipelineLibraryIndependentInterpolationDecoration ); +# endif + } + + bool operator!=( PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + void * pNext = {}; + Bool32 graphicsPipelineLibraryFastLinking = {}; + Bool32 graphicsPipelineLibraryIndependentInterpolationDecoration = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceGroupProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGroupProperties.html + struct PhysicalDeviceGroupProperties + { + using NativeType = VkPhysicalDeviceGroupProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGroupProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGroupProperties( uint32_t physicalDeviceCount_ = {}, + std::array const & physicalDevices_ = {}, + Bool32 subsetAllocation_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , physicalDeviceCount{ physicalDeviceCount_ } + , physicalDevices{ physicalDevices_ } + , subsetAllocation{ subsetAllocation_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGroupProperties( PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceGroupProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceGroupProperties & operator=( PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceGroupProperties & operator=( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceGroupProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGroupProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGroupProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceGroupProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, Bool32 const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, physicalDeviceCount, physicalDevices, subsetAllocation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = physicalDeviceCount <=> rhs.physicalDeviceCount; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < physicalDeviceCount; ++i ) + { + if ( auto cmp = physicalDevices[i] <=> rhs.physicalDevices[i]; cmp != 0 ) + return cmp; + } + if ( auto cmp = subsetAllocation <=> rhs.subsetAllocation; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) && + ( memcmp( physicalDevices, rhs.physicalDevices, physicalDeviceCount * sizeof( PhysicalDevice ) ) == 0 ) && + ( subsetAllocation == rhs.subsetAllocation ); + } + + bool operator!=( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::ePhysicalDeviceGroupProperties; + void * pNext = {}; + uint32_t physicalDeviceCount = {}; + ArrayWrapper1D physicalDevices = {}; + Bool32 subsetAllocation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceGroupProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceGroupProperties; + }; + + using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; + + // wrapper struct for struct VkPhysicalDeviceHdrVividFeaturesHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceHdrVividFeaturesHUAWEI.html + struct PhysicalDeviceHdrVividFeaturesHUAWEI + { + using NativeType = VkPhysicalDeviceHdrVividFeaturesHUAWEI; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceHdrVividFeaturesHUAWEI; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceHdrVividFeaturesHUAWEI( Bool32 hdrVivid_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , hdrVivid{ hdrVivid_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceHdrVividFeaturesHUAWEI( PhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceHdrVividFeaturesHUAWEI( VkPhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceHdrVividFeaturesHUAWEI( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceHdrVividFeaturesHUAWEI & operator=( PhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceHdrVividFeaturesHUAWEI & operator=( VkPhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHdrVividFeaturesHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHdrVividFeaturesHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHdrVividFeaturesHUAWEI & setHdrVivid( Bool32 hdrVivid_ ) & VULKAN_HPP_NOEXCEPT + { + hdrVivid = hdrVivid_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHdrVividFeaturesHUAWEI && setHdrVivid( Bool32 hdrVivid_ ) && VULKAN_HPP_NOEXCEPT + { + hdrVivid = hdrVivid_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceHdrVividFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHdrVividFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHdrVividFeaturesHUAWEI const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHdrVividFeaturesHUAWEI *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hdrVivid ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceHdrVividFeaturesHUAWEI const & ) const = default; +#else + bool operator==( PhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hdrVivid == rhs.hdrVivid ); +# endif + } + + bool operator!=( PhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceHdrVividFeaturesHUAWEI; + void * pNext = {}; + Bool32 hdrVivid = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceHdrVividFeaturesHUAWEI; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceHdrVividFeaturesHUAWEI; + }; + + // wrapper struct for struct VkPhysicalDeviceHostImageCopyFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceHostImageCopyFeatures.html + struct PhysicalDeviceHostImageCopyFeatures + { + using NativeType = VkPhysicalDeviceHostImageCopyFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceHostImageCopyFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceHostImageCopyFeatures( Bool32 hostImageCopy_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , hostImageCopy{ hostImageCopy_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceHostImageCopyFeatures( PhysicalDeviceHostImageCopyFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceHostImageCopyFeatures( VkPhysicalDeviceHostImageCopyFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceHostImageCopyFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceHostImageCopyFeatures & operator=( PhysicalDeviceHostImageCopyFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceHostImageCopyFeatures & operator=( VkPhysicalDeviceHostImageCopyFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyFeatures & setHostImageCopy( Bool32 hostImageCopy_ ) & VULKAN_HPP_NOEXCEPT + { + hostImageCopy = hostImageCopy_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyFeatures && setHostImageCopy( Bool32 hostImageCopy_ ) && VULKAN_HPP_NOEXCEPT + { + hostImageCopy = hostImageCopy_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceHostImageCopyFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHostImageCopyFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHostImageCopyFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHostImageCopyFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hostImageCopy ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceHostImageCopyFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceHostImageCopyFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostImageCopy == rhs.hostImageCopy ); +# endif + } + + bool operator!=( PhysicalDeviceHostImageCopyFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceHostImageCopyFeatures; + void * pNext = {}; + Bool32 hostImageCopy = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceHostImageCopyFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceHostImageCopyFeatures; + }; + + using PhysicalDeviceHostImageCopyFeaturesEXT = PhysicalDeviceHostImageCopyFeatures; + + // wrapper struct for struct VkPhysicalDeviceHostImageCopyProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceHostImageCopyProperties.html + struct PhysicalDeviceHostImageCopyProperties + { + using NativeType = VkPhysicalDeviceHostImageCopyProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceHostImageCopyProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties( uint32_t copySrcLayoutCount_ = {}, + ImageLayout * pCopySrcLayouts_ = {}, + uint32_t copyDstLayoutCount_ = {}, + ImageLayout * pCopyDstLayouts_ = {}, + std::array const & optimalTilingLayoutUUID_ = {}, + Bool32 identicalMemoryTypeRequirements_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , copySrcLayoutCount{ copySrcLayoutCount_ } + , pCopySrcLayouts{ pCopySrcLayouts_ } + , copyDstLayoutCount{ copyDstLayoutCount_ } + , pCopyDstLayouts{ pCopyDstLayouts_ } + , optimalTilingLayoutUUID{ optimalTilingLayoutUUID_ } + , identicalMemoryTypeRequirements{ identicalMemoryTypeRequirements_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties( PhysicalDeviceHostImageCopyProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceHostImageCopyProperties( VkPhysicalDeviceHostImageCopyProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceHostImageCopyProperties( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceHostImageCopyProperties( ArrayProxyNoTemporaries const & copySrcLayouts_, + ArrayProxyNoTemporaries const & copyDstLayouts_ = {}, + std::array const & optimalTilingLayoutUUID_ = {}, + Bool32 identicalMemoryTypeRequirements_ = {}, + void * pNext_ = nullptr ) + : pNext( pNext_ ) + , copySrcLayoutCount( static_cast( copySrcLayouts_.size() ) ) + , pCopySrcLayouts( copySrcLayouts_.data() ) + , copyDstLayoutCount( static_cast( copyDstLayouts_.size() ) ) + , pCopyDstLayouts( copyDstLayouts_.data() ) + , optimalTilingLayoutUUID( optimalTilingLayoutUUID_ ) + , identicalMemoryTypeRequirements( identicalMemoryTypeRequirements_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PhysicalDeviceHostImageCopyProperties & operator=( PhysicalDeviceHostImageCopyProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceHostImageCopyProperties & operator=( VkPhysicalDeviceHostImageCopyProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setCopySrcLayoutCount( uint32_t copySrcLayoutCount_ ) & VULKAN_HPP_NOEXCEPT + { + copySrcLayoutCount = copySrcLayoutCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setCopySrcLayoutCount( uint32_t copySrcLayoutCount_ ) && VULKAN_HPP_NOEXCEPT + { + copySrcLayoutCount = copySrcLayoutCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setPCopySrcLayouts( ImageLayout * pCopySrcLayouts_ ) & VULKAN_HPP_NOEXCEPT + { + pCopySrcLayouts = pCopySrcLayouts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setPCopySrcLayouts( ImageLayout * pCopySrcLayouts_ ) && VULKAN_HPP_NOEXCEPT + { + pCopySrcLayouts = pCopySrcLayouts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceHostImageCopyProperties & setCopySrcLayouts( ArrayProxyNoTemporaries const & copySrcLayouts_ ) VULKAN_HPP_NOEXCEPT + { + copySrcLayoutCount = static_cast( copySrcLayouts_.size() ); + pCopySrcLayouts = copySrcLayouts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setCopyDstLayoutCount( uint32_t copyDstLayoutCount_ ) & VULKAN_HPP_NOEXCEPT + { + copyDstLayoutCount = copyDstLayoutCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setCopyDstLayoutCount( uint32_t copyDstLayoutCount_ ) && VULKAN_HPP_NOEXCEPT + { + copyDstLayoutCount = copyDstLayoutCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setPCopyDstLayouts( ImageLayout * pCopyDstLayouts_ ) & VULKAN_HPP_NOEXCEPT + { + pCopyDstLayouts = pCopyDstLayouts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setPCopyDstLayouts( ImageLayout * pCopyDstLayouts_ ) && VULKAN_HPP_NOEXCEPT + { + pCopyDstLayouts = pCopyDstLayouts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceHostImageCopyProperties & setCopyDstLayouts( ArrayProxyNoTemporaries const & copyDstLayouts_ ) VULKAN_HPP_NOEXCEPT + { + copyDstLayoutCount = static_cast( copyDstLayouts_.size() ); + pCopyDstLayouts = copyDstLayouts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setOptimalTilingLayoutUUID( std::array optimalTilingLayoutUUID_ ) & + VULKAN_HPP_NOEXCEPT + { + optimalTilingLayoutUUID = optimalTilingLayoutUUID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setOptimalTilingLayoutUUID( std::array optimalTilingLayoutUUID_ ) && + VULKAN_HPP_NOEXCEPT + { + optimalTilingLayoutUUID = optimalTilingLayoutUUID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setIdenticalMemoryTypeRequirements( Bool32 identicalMemoryTypeRequirements_ ) & + VULKAN_HPP_NOEXCEPT + { + identicalMemoryTypeRequirements = identicalMemoryTypeRequirements_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setIdenticalMemoryTypeRequirements( Bool32 identicalMemoryTypeRequirements_ ) && + VULKAN_HPP_NOEXCEPT + { + identicalMemoryTypeRequirements = identicalMemoryTypeRequirements_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceHostImageCopyProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHostImageCopyProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHostImageCopyProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHostImageCopyProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + Bool32 const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, copySrcLayoutCount, pCopySrcLayouts, copyDstLayoutCount, pCopyDstLayouts, optimalTilingLayoutUUID, identicalMemoryTypeRequirements ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceHostImageCopyProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceHostImageCopyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( copySrcLayoutCount == rhs.copySrcLayoutCount ) && + ( pCopySrcLayouts == rhs.pCopySrcLayouts ) && ( copyDstLayoutCount == rhs.copyDstLayoutCount ) && ( pCopyDstLayouts == rhs.pCopyDstLayouts ) && + ( optimalTilingLayoutUUID == rhs.optimalTilingLayoutUUID ) && ( identicalMemoryTypeRequirements == rhs.identicalMemoryTypeRequirements ); +# endif + } + + bool operator!=( PhysicalDeviceHostImageCopyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceHostImageCopyProperties; + void * pNext = {}; + uint32_t copySrcLayoutCount = {}; + ImageLayout * pCopySrcLayouts = {}; + uint32_t copyDstLayoutCount = {}; + ImageLayout * pCopyDstLayouts = {}; + ArrayWrapper1D optimalTilingLayoutUUID = {}; + Bool32 identicalMemoryTypeRequirements = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceHostImageCopyProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceHostImageCopyProperties; + }; + + using PhysicalDeviceHostImageCopyPropertiesEXT = PhysicalDeviceHostImageCopyProperties; + + // wrapper struct for struct VkPhysicalDeviceHostQueryResetFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceHostQueryResetFeatures.html + struct PhysicalDeviceHostQueryResetFeatures + { + using NativeType = VkPhysicalDeviceHostQueryResetFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceHostQueryResetFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeatures( Bool32 hostQueryReset_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , hostQueryReset{ hostQueryReset_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeatures( PhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceHostQueryResetFeatures( VkPhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceHostQueryResetFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceHostQueryResetFeatures & operator=( PhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceHostQueryResetFeatures & operator=( VkPhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostQueryResetFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostQueryResetFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostQueryResetFeatures & setHostQueryReset( Bool32 hostQueryReset_ ) & VULKAN_HPP_NOEXCEPT + { + hostQueryReset = hostQueryReset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostQueryResetFeatures && setHostQueryReset( Bool32 hostQueryReset_ ) && VULKAN_HPP_NOEXCEPT + { + hostQueryReset = hostQueryReset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceHostQueryResetFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHostQueryResetFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHostQueryResetFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceHostQueryResetFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hostQueryReset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceHostQueryResetFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostQueryReset == rhs.hostQueryReset ); +# endif + } + + bool operator!=( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeatures; + void * pNext = {}; + Bool32 hostQueryReset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceHostQueryResetFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceHostQueryResetFeatures; + }; + + using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures; + + // wrapper struct for struct VkPhysicalDeviceIDProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceIDProperties.html + struct PhysicalDeviceIDProperties + { + using NativeType = VkPhysicalDeviceIDProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceIdProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIDProperties( std::array const & deviceUUID_ = {}, + std::array const & driverUUID_ = {}, + std::array const & deviceLUID_ = {}, + uint32_t deviceNodeMask_ = {}, + Bool32 deviceLUIDValid_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceUUID{ deviceUUID_ } + , driverUUID{ driverUUID_ } + , deviceLUID{ deviceLUID_ } + , deviceNodeMask{ deviceNodeMask_ } + , deviceLUIDValid{ deviceLUIDValid_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIDProperties( PhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceIDProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceIDProperties & operator=( PhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceIDProperties & operator=( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceIDProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceIDProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceIDProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceIDProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &, + ArrayWrapper1D const &, + uint32_t const &, + Bool32 const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceUUID, driverUUID, deviceLUID, deviceNodeMask, deviceLUIDValid ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceIDProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) && ( driverUUID == rhs.driverUUID ) && + ( deviceLUID == rhs.deviceLUID ) && ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ); +# endif + } + + bool operator!=( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceIdProperties; + void * pNext = {}; + ArrayWrapper1D deviceUUID = {}; + ArrayWrapper1D driverUUID = {}; + ArrayWrapper1D deviceLUID = {}; + uint32_t deviceNodeMask = {}; + Bool32 deviceLUIDValid = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceIDProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceIDProperties; + }; + + using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; + + // wrapper struct for struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.html + struct PhysicalDeviceImage2DViewOf3DFeaturesEXT + { + using NativeType = VkPhysicalDeviceImage2DViewOf3DFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceImage2DViewOf3DFeaturesEXT( Bool32 image2DViewOf3D_ = {}, Bool32 sampler2DViewOf3D_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image2DViewOf3D{ image2DViewOf3D_ } + , sampler2DViewOf3D{ sampler2DViewOf3D_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImage2DViewOf3DFeaturesEXT( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImage2DViewOf3DFeaturesEXT( VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImage2DViewOf3DFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImage2DViewOf3DFeaturesEXT & operator=( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImage2DViewOf3DFeaturesEXT & operator=( VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT & setImage2DViewOf3D( Bool32 image2DViewOf3D_ ) & VULKAN_HPP_NOEXCEPT + { + image2DViewOf3D = image2DViewOf3D_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT && setImage2DViewOf3D( Bool32 image2DViewOf3D_ ) && VULKAN_HPP_NOEXCEPT + { + image2DViewOf3D = image2DViewOf3D_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT & setSampler2DViewOf3D( Bool32 sampler2DViewOf3D_ ) & VULKAN_HPP_NOEXCEPT + { + sampler2DViewOf3D = sampler2DViewOf3D_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT && setSampler2DViewOf3D( Bool32 sampler2DViewOf3D_ ) && VULKAN_HPP_NOEXCEPT + { + sampler2DViewOf3D = sampler2DViewOf3D_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImage2DViewOf3DFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image2DViewOf3D, sampler2DViewOf3D ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image2DViewOf3D == rhs.image2DViewOf3D ) && ( sampler2DViewOf3D == rhs.sampler2DViewOf3D ); +# endif + } + + bool operator!=( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT; + void * pNext = {}; + Bool32 image2DViewOf3D = {}; + Bool32 sampler2DViewOf3D = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImage2DViewOf3DFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImage2DViewOf3DFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageAlignmentControlFeaturesMESA.html + struct PhysicalDeviceImageAlignmentControlFeaturesMESA + { + using NativeType = VkPhysicalDeviceImageAlignmentControlFeaturesMESA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageAlignmentControlFeaturesMESA( Bool32 imageAlignmentControl_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageAlignmentControl{ imageAlignmentControl_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceImageAlignmentControlFeaturesMESA( PhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageAlignmentControlFeaturesMESA( VkPhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageAlignmentControlFeaturesMESA( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageAlignmentControlFeaturesMESA & operator=( PhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageAlignmentControlFeaturesMESA & operator=( VkPhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageAlignmentControlFeaturesMESA & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageAlignmentControlFeaturesMESA && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageAlignmentControlFeaturesMESA & setImageAlignmentControl( Bool32 imageAlignmentControl_ ) & VULKAN_HPP_NOEXCEPT + { + imageAlignmentControl = imageAlignmentControl_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageAlignmentControlFeaturesMESA && setImageAlignmentControl( Bool32 imageAlignmentControl_ ) && VULKAN_HPP_NOEXCEPT + { + imageAlignmentControl = imageAlignmentControl_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageAlignmentControlFeaturesMESA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageAlignmentControlFeaturesMESA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageAlignmentControlFeaturesMESA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageAlignmentControlFeaturesMESA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageAlignmentControl ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageAlignmentControlFeaturesMESA const & ) const = default; +#else + bool operator==( PhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageAlignmentControl == rhs.imageAlignmentControl ); +# endif + } + + bool operator!=( PhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA; + void * pNext = {}; + Bool32 imageAlignmentControl = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageAlignmentControlFeaturesMESA; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageAlignmentControlFeaturesMESA; + }; + + // wrapper struct for struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageAlignmentControlPropertiesMESA.html + struct PhysicalDeviceImageAlignmentControlPropertiesMESA + { + using NativeType = VkPhysicalDeviceImageAlignmentControlPropertiesMESA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageAlignmentControlPropertiesMESA( uint32_t supportedImageAlignmentMask_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , supportedImageAlignmentMask{ supportedImageAlignmentMask_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceImageAlignmentControlPropertiesMESA( PhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageAlignmentControlPropertiesMESA( VkPhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageAlignmentControlPropertiesMESA( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageAlignmentControlPropertiesMESA & + operator=( PhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageAlignmentControlPropertiesMESA & operator=( VkPhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceImageAlignmentControlPropertiesMESA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageAlignmentControlPropertiesMESA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageAlignmentControlPropertiesMESA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageAlignmentControlPropertiesMESA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supportedImageAlignmentMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageAlignmentControlPropertiesMESA const & ) const = default; +#else + bool operator==( PhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedImageAlignmentMask == rhs.supportedImageAlignmentMask ); +# endif + } + + bool operator!=( PhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA; + void * pNext = {}; + uint32_t supportedImageAlignmentMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageAlignmentControlPropertiesMESA; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageAlignmentControlPropertiesMESA; + }; + + // wrapper struct for struct VkPhysicalDeviceImageCompressionControlFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageCompressionControlFeaturesEXT.html + struct PhysicalDeviceImageCompressionControlFeaturesEXT + { + using NativeType = VkPhysicalDeviceImageCompressionControlFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageCompressionControlFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageCompressionControlFeaturesEXT( Bool32 imageCompressionControl_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageCompressionControl{ imageCompressionControl_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceImageCompressionControlFeaturesEXT( PhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageCompressionControlFeaturesEXT( VkPhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageCompressionControlFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageCompressionControlFeaturesEXT & operator=( PhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageCompressionControlFeaturesEXT & operator=( VkPhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlFeaturesEXT & setImageCompressionControl( Bool32 imageCompressionControl_ ) & + VULKAN_HPP_NOEXCEPT + { + imageCompressionControl = imageCompressionControl_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlFeaturesEXT && setImageCompressionControl( Bool32 imageCompressionControl_ ) && + VULKAN_HPP_NOEXCEPT + { + imageCompressionControl = imageCompressionControl_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageCompressionControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageCompressionControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageCompressionControlFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageCompressionControlFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageCompressionControl ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageCompressionControlFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCompressionControl == rhs.imageCompressionControl ); +# endif + } + + bool operator!=( PhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageCompressionControlFeaturesEXT; + void * pNext = {}; + Bool32 imageCompressionControl = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageCompressionControlFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageCompressionControlFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.html + struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT + { + using NativeType = VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( Bool32 imageCompressionControlSwapchain_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageCompressionControlSwapchain{ imageCompressionControlSwapchain_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( + *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT & + operator=( PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT & + operator=( VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT & + setImageCompressionControlSwapchain( Bool32 imageCompressionControlSwapchain_ ) & + VULKAN_HPP_NOEXCEPT + { + imageCompressionControlSwapchain = imageCompressionControlSwapchain_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT && + setImageCompressionControlSwapchain( Bool32 imageCompressionControlSwapchain_ ) && + VULKAN_HPP_NOEXCEPT + { + imageCompressionControlSwapchain = imageCompressionControlSwapchain_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageCompressionControlSwapchain ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCompressionControlSwapchain == rhs.imageCompressionControlSwapchain ); +# endif + } + + bool operator!=( PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + void * pNext = {}; + Bool32 imageCompressionControlSwapchain = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageDrmFormatModifierInfoEXT.html + struct PhysicalDeviceImageDrmFormatModifierInfoEXT + { + using NativeType = VkPhysicalDeviceImageDrmFormatModifierInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = {}, + SharingMode sharingMode_ = SharingMode::eExclusive, + uint32_t queueFamilyIndexCount_ = {}, + const uint32_t * pQueueFamilyIndices_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , drmFormatModifier{ drmFormatModifier_ } + , sharingMode{ sharingMode_ } + , queueFamilyIndexCount{ queueFamilyIndexCount_ } + , pQueueFamilyIndices{ pQueueFamilyIndices_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageDrmFormatModifierInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_, + SharingMode sharingMode_, + ArrayProxyNoTemporaries const & queueFamilyIndices_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , drmFormatModifier( drmFormatModifier_ ) + , sharingMode( sharingMode_ ) + , queueFamilyIndexCount( static_cast( queueFamilyIndices_.size() ) ) + , pQueueFamilyIndices( queueFamilyIndices_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PhysicalDeviceImageDrmFormatModifierInfoEXT & operator=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageDrmFormatModifierInfoEXT & operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT & setDrmFormatModifier( uint64_t drmFormatModifier_ ) & VULKAN_HPP_NOEXCEPT + { + drmFormatModifier = drmFormatModifier_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT && setDrmFormatModifier( uint64_t drmFormatModifier_ ) && VULKAN_HPP_NOEXCEPT + { + drmFormatModifier = drmFormatModifier_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT & setSharingMode( SharingMode sharingMode_ ) & VULKAN_HPP_NOEXCEPT + { + sharingMode = sharingMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT && setSharingMode( SharingMode sharingMode_ ) && VULKAN_HPP_NOEXCEPT + { + sharingMode = sharingMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) & VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT && setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) && VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT & setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT && setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) && + VULKAN_HPP_NOEXCEPT + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceImageDrmFormatModifierInfoEXT & + setQueueFamilyIndices( ArrayProxyNoTemporaries const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = static_cast( queueFamilyIndices_.size() ); + pQueueFamilyIndices = queueFamilyIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, drmFormatModifier, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageDrmFormatModifierInfoEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) && ( sharingMode == rhs.sharingMode ) && + ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); +# endif + } + + bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; + const void * pNext = {}; + uint64_t drmFormatModifier = {}; + SharingMode sharingMode = SharingMode::eExclusive; + uint32_t queueFamilyIndexCount = {}; + const uint32_t * pQueueFamilyIndices = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageDrmFormatModifierInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageDrmFormatModifierInfoEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceImageFormatInfo2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageFormatInfo2.html + struct PhysicalDeviceImageFormatInfo2 + { + using NativeType = VkPhysicalDeviceImageFormatInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageFormatInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( Format format_ = Format::eUndefined, + ImageType type_ = ImageType::e1D, + ImageTiling tiling_ = ImageTiling::eOptimal, + ImageUsageFlags usage_ = {}, + ImageCreateFlags flags_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , format{ format_ } + , type{ type_ } + , tiling{ tiling_ } + , usage{ usage_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( PhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageFormatInfo2( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageFormatInfo2 & operator=( PhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageFormatInfo2 & operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setType( ImageType type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setType( ImageType type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setTiling( ImageTiling tiling_ ) & VULKAN_HPP_NOEXCEPT + { + tiling = tiling_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setTiling( ImageTiling tiling_ ) && VULKAN_HPP_NOEXCEPT + { + tiling = tiling_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setUsage( ImageUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setUsage( ImageUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setFlags( ImageCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setFlags( ImageCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageFormatInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageFormatInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format, type, tiling, usage, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageFormatInfo2 const & ) const = default; +#else + bool operator==( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && ( tiling == rhs.tiling ) && + ( usage == rhs.usage ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2; + const void * pNext = {}; + Format format = Format::eUndefined; + ImageType type = ImageType::e1D; + ImageTiling tiling = ImageTiling::eOptimal; + ImageUsageFlags usage = {}; + ImageCreateFlags flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageFormatInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageFormatInfo2; + }; + + using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; + + // wrapper struct for struct VkPhysicalDeviceImageProcessing2FeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessing2FeaturesQCOM.html + struct PhysicalDeviceImageProcessing2FeaturesQCOM + { + using NativeType = VkPhysicalDeviceImageProcessing2FeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageProcessing2FeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessing2FeaturesQCOM( Bool32 textureBlockMatch2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , textureBlockMatch2{ textureBlockMatch2_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessing2FeaturesQCOM( PhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageProcessing2FeaturesQCOM( VkPhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageProcessing2FeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageProcessing2FeaturesQCOM & operator=( PhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageProcessing2FeaturesQCOM & operator=( VkPhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing2FeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing2FeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing2FeaturesQCOM & setTextureBlockMatch2( Bool32 textureBlockMatch2_ ) & VULKAN_HPP_NOEXCEPT + { + textureBlockMatch2 = textureBlockMatch2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing2FeaturesQCOM && setTextureBlockMatch2( Bool32 textureBlockMatch2_ ) && VULKAN_HPP_NOEXCEPT + { + textureBlockMatch2 = textureBlockMatch2_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageProcessing2FeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessing2FeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessing2FeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessing2FeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, textureBlockMatch2 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageProcessing2FeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( textureBlockMatch2 == rhs.textureBlockMatch2 ); +# endif + } + + bool operator!=( PhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageProcessing2FeaturesQCOM; + void * pNext = {}; + Bool32 textureBlockMatch2 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageProcessing2FeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageProcessing2FeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceImageProcessing2PropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessing2PropertiesQCOM.html + struct PhysicalDeviceImageProcessing2PropertiesQCOM + { + using NativeType = VkPhysicalDeviceImageProcessing2PropertiesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageProcessing2PropertiesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessing2PropertiesQCOM( Extent2D maxBlockMatchWindow_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxBlockMatchWindow{ maxBlockMatchWindow_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessing2PropertiesQCOM( PhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageProcessing2PropertiesQCOM( VkPhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageProcessing2PropertiesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageProcessing2PropertiesQCOM & operator=( PhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageProcessing2PropertiesQCOM & operator=( VkPhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceImageProcessing2PropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessing2PropertiesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessing2PropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessing2PropertiesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxBlockMatchWindow ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageProcessing2PropertiesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBlockMatchWindow == rhs.maxBlockMatchWindow ); +# endif + } + + bool operator!=( PhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageProcessing2PropertiesQCOM; + void * pNext = {}; + Extent2D maxBlockMatchWindow = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageProcessing2PropertiesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageProcessing2PropertiesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceImageProcessingFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessingFeaturesQCOM.html + struct PhysicalDeviceImageProcessingFeaturesQCOM + { + using NativeType = VkPhysicalDeviceImageProcessingFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessingFeaturesQCOM( Bool32 textureSampleWeighted_ = {}, + Bool32 textureBoxFilter_ = {}, + Bool32 textureBlockMatch_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , textureSampleWeighted{ textureSampleWeighted_ } + , textureBoxFilter{ textureBoxFilter_ } + , textureBlockMatch{ textureBlockMatch_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessingFeaturesQCOM( PhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageProcessingFeaturesQCOM( VkPhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageProcessingFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageProcessingFeaturesQCOM & operator=( PhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageProcessingFeaturesQCOM & operator=( VkPhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM & setTextureSampleWeighted( Bool32 textureSampleWeighted_ ) & VULKAN_HPP_NOEXCEPT + { + textureSampleWeighted = textureSampleWeighted_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM && setTextureSampleWeighted( Bool32 textureSampleWeighted_ ) && VULKAN_HPP_NOEXCEPT + { + textureSampleWeighted = textureSampleWeighted_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM & setTextureBoxFilter( Bool32 textureBoxFilter_ ) & VULKAN_HPP_NOEXCEPT + { + textureBoxFilter = textureBoxFilter_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM && setTextureBoxFilter( Bool32 textureBoxFilter_ ) && VULKAN_HPP_NOEXCEPT + { + textureBoxFilter = textureBoxFilter_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM & setTextureBlockMatch( Bool32 textureBlockMatch_ ) & VULKAN_HPP_NOEXCEPT + { + textureBlockMatch = textureBlockMatch_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM && setTextureBlockMatch( Bool32 textureBlockMatch_ ) && VULKAN_HPP_NOEXCEPT + { + textureBlockMatch = textureBlockMatch_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageProcessingFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessingFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessingFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessingFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, textureSampleWeighted, textureBoxFilter, textureBlockMatch ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageProcessingFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( textureSampleWeighted == rhs.textureSampleWeighted ) && + ( textureBoxFilter == rhs.textureBoxFilter ) && ( textureBlockMatch == rhs.textureBlockMatch ); +# endif + } + + bool operator!=( PhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM; + void * pNext = {}; + Bool32 textureSampleWeighted = {}; + Bool32 textureBoxFilter = {}; + Bool32 textureBlockMatch = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageProcessingFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageProcessingFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceImageProcessingPropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessingPropertiesQCOM.html + struct PhysicalDeviceImageProcessingPropertiesQCOM + { + using NativeType = VkPhysicalDeviceImageProcessingPropertiesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessingPropertiesQCOM( uint32_t maxWeightFilterPhases_ = {}, + Extent2D maxWeightFilterDimension_ = {}, + Extent2D maxBlockMatchRegion_ = {}, + Extent2D maxBoxFilterBlockSize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxWeightFilterPhases{ maxWeightFilterPhases_ } + , maxWeightFilterDimension{ maxWeightFilterDimension_ } + , maxBlockMatchRegion{ maxBlockMatchRegion_ } + , maxBoxFilterBlockSize{ maxBoxFilterBlockSize_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessingPropertiesQCOM( PhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageProcessingPropertiesQCOM( VkPhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageProcessingPropertiesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageProcessingPropertiesQCOM & operator=( PhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageProcessingPropertiesQCOM & operator=( VkPhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceImageProcessingPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessingPropertiesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessingPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageProcessingPropertiesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxWeightFilterPhases, maxWeightFilterDimension, maxBlockMatchRegion, maxBoxFilterBlockSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageProcessingPropertiesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxWeightFilterPhases == rhs.maxWeightFilterPhases ) && + ( maxWeightFilterDimension == rhs.maxWeightFilterDimension ) && ( maxBlockMatchRegion == rhs.maxBlockMatchRegion ) && + ( maxBoxFilterBlockSize == rhs.maxBoxFilterBlockSize ); +# endif + } + + bool operator!=( PhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM; + void * pNext = {}; + uint32_t maxWeightFilterPhases = {}; + Extent2D maxWeightFilterDimension = {}; + Extent2D maxBlockMatchRegion = {}; + Extent2D maxBoxFilterBlockSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageProcessingPropertiesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageProcessingPropertiesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceImageRobustnessFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageRobustnessFeatures.html + struct PhysicalDeviceImageRobustnessFeatures + { + using NativeType = VkPhysicalDeviceImageRobustnessFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageRobustnessFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageRobustnessFeatures( Bool32 robustImageAccess_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , robustImageAccess{ robustImageAccess_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageRobustnessFeatures( PhysicalDeviceImageRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageRobustnessFeatures( VkPhysicalDeviceImageRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageRobustnessFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageRobustnessFeatures & operator=( PhysicalDeviceImageRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageRobustnessFeatures & operator=( VkPhysicalDeviceImageRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageRobustnessFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageRobustnessFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageRobustnessFeatures & setRobustImageAccess( Bool32 robustImageAccess_ ) & VULKAN_HPP_NOEXCEPT + { + robustImageAccess = robustImageAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageRobustnessFeatures && setRobustImageAccess( Bool32 robustImageAccess_ ) && VULKAN_HPP_NOEXCEPT + { + robustImageAccess = robustImageAccess_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageRobustnessFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageRobustnessFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageRobustnessFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageRobustnessFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, robustImageAccess ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageRobustnessFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceImageRobustnessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess ); +# endif + } + + bool operator!=( PhysicalDeviceImageRobustnessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageRobustnessFeatures; + void * pNext = {}; + Bool32 robustImageAccess = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageRobustnessFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageRobustnessFeatures; + }; + + using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures; + + // wrapper struct for struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.html + struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT + { + using NativeType = VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( Bool32 imageSlicedViewOf3D_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageSlicedViewOf3D{ imageSlicedViewOf3D_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageSlicedViewOf3DFeaturesEXT & operator=( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageSlicedViewOf3DFeaturesEXT & operator=( VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT & setImageSlicedViewOf3D( Bool32 imageSlicedViewOf3D_ ) & VULKAN_HPP_NOEXCEPT + { + imageSlicedViewOf3D = imageSlicedViewOf3D_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT && setImageSlicedViewOf3D( Bool32 imageSlicedViewOf3D_ ) && VULKAN_HPP_NOEXCEPT + { + imageSlicedViewOf3D = imageSlicedViewOf3D_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageSlicedViewOf3D ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageSlicedViewOf3D == rhs.imageSlicedViewOf3D ); +# endif + } + + bool operator!=( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT; + void * pNext = {}; + Bool32 imageSlicedViewOf3D = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageSlicedViewOf3DFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageSlicedViewOf3DFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceImageViewImageFormatInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageViewImageFormatInfoEXT.html + struct PhysicalDeviceImageViewImageFormatInfoEXT + { + using NativeType = VkPhysicalDeviceImageViewImageFormatInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( ImageViewType imageViewType_ = ImageViewType::e1D, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageViewType{ imageViewType_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageViewImageFormatInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageViewImageFormatInfoEXT & operator=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageViewImageFormatInfoEXT & operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewImageFormatInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewImageFormatInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewImageFormatInfoEXT & setImageViewType( ImageViewType imageViewType_ ) & VULKAN_HPP_NOEXCEPT + { + imageViewType = imageViewType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewImageFormatInfoEXT && setImageViewType( ImageViewType imageViewType_ ) && VULKAN_HPP_NOEXCEPT + { + imageViewType = imageViewType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageViewImageFormatInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageViewImageFormatInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageViewImageFormatInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageViewImageFormatInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageViewType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageViewImageFormatInfoEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageViewType == rhs.imageViewType ); +# endif + } + + bool operator!=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; + void * pNext = {}; + ImageViewType imageViewType = ImageViewType::e1D; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageViewImageFormatInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageViewImageFormatInfoEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceImageViewMinLodFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageViewMinLodFeaturesEXT.html + struct PhysicalDeviceImageViewMinLodFeaturesEXT + { + using NativeType = VkPhysicalDeviceImageViewMinLodFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageViewMinLodFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewMinLodFeaturesEXT( Bool32 minLod_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minLod{ minLod_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewMinLodFeaturesEXT( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImageViewMinLodFeaturesEXT( VkPhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImageViewMinLodFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImageViewMinLodFeaturesEXT & operator=( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImageViewMinLodFeaturesEXT & operator=( VkPhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewMinLodFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewMinLodFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewMinLodFeaturesEXT & setMinLod( Bool32 minLod_ ) & VULKAN_HPP_NOEXCEPT + { + minLod = minLod_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewMinLodFeaturesEXT && setMinLod( Bool32 minLod_ ) && VULKAN_HPP_NOEXCEPT + { + minLod = minLod_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImageViewMinLodFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageViewMinLodFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageViewMinLodFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImageViewMinLodFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minLod ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImageViewMinLodFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod ); +# endif + } + + bool operator!=( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImageViewMinLodFeaturesEXT; + void * pNext = {}; + Bool32 minLod = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImageViewMinLodFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImageViewMinLodFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceImagelessFramebufferFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html + struct PhysicalDeviceImagelessFramebufferFeatures + { + using NativeType = VkPhysicalDeviceImagelessFramebufferFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImagelessFramebufferFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeatures( Bool32 imagelessFramebuffer_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imagelessFramebuffer{ imagelessFramebuffer_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeatures( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceImagelessFramebufferFeatures( VkPhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceImagelessFramebufferFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceImagelessFramebufferFeatures & operator=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceImagelessFramebufferFeatures & operator=( VkPhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImagelessFramebufferFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImagelessFramebufferFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImagelessFramebufferFeatures & setImagelessFramebuffer( Bool32 imagelessFramebuffer_ ) & VULKAN_HPP_NOEXCEPT + { + imagelessFramebuffer = imagelessFramebuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImagelessFramebufferFeatures && setImagelessFramebuffer( Bool32 imagelessFramebuffer_ ) && VULKAN_HPP_NOEXCEPT + { + imagelessFramebuffer = imagelessFramebuffer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceImagelessFramebufferFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImagelessFramebufferFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImagelessFramebufferFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceImagelessFramebufferFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imagelessFramebuffer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceImagelessFramebufferFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imagelessFramebuffer == rhs.imagelessFramebuffer ); +# endif + } + + bool operator!=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeatures; + void * pNext = {}; + Bool32 imagelessFramebuffer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceImagelessFramebufferFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceImagelessFramebufferFeatures; + }; + + using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures; + + // wrapper struct for struct VkPhysicalDeviceIndexTypeUint8Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceIndexTypeUint8Features.html + struct PhysicalDeviceIndexTypeUint8Features + { + using NativeType = VkPhysicalDeviceIndexTypeUint8Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceIndexTypeUint8Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8Features( Bool32 indexTypeUint8_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , indexTypeUint8{ indexTypeUint8_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8Features( PhysicalDeviceIndexTypeUint8Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceIndexTypeUint8Features( VkPhysicalDeviceIndexTypeUint8Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceIndexTypeUint8Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceIndexTypeUint8Features & operator=( PhysicalDeviceIndexTypeUint8Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceIndexTypeUint8Features & operator=( VkPhysicalDeviceIndexTypeUint8Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8Features & setIndexTypeUint8( Bool32 indexTypeUint8_ ) & VULKAN_HPP_NOEXCEPT + { + indexTypeUint8 = indexTypeUint8_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8Features && setIndexTypeUint8( Bool32 indexTypeUint8_ ) && VULKAN_HPP_NOEXCEPT + { + indexTypeUint8 = indexTypeUint8_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceIndexTypeUint8Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceIndexTypeUint8Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceIndexTypeUint8Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceIndexTypeUint8Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, indexTypeUint8 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceIndexTypeUint8Features const & ) const = default; +#else + bool operator==( PhysicalDeviceIndexTypeUint8Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indexTypeUint8 == rhs.indexTypeUint8 ); +# endif + } + + bool operator!=( PhysicalDeviceIndexTypeUint8Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8Features; + void * pNext = {}; + Bool32 indexTypeUint8 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceIndexTypeUint8Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceIndexTypeUint8Features; + }; + + using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8Features; + using PhysicalDeviceIndexTypeUint8FeaturesKHR = PhysicalDeviceIndexTypeUint8Features; + + // wrapper struct for struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.html + struct PhysicalDeviceInheritedViewportScissorFeaturesNV + { + using NativeType = VkPhysicalDeviceInheritedViewportScissorFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInheritedViewportScissorFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceInheritedViewportScissorFeaturesNV( Bool32 inheritedViewportScissor2D_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , inheritedViewportScissor2D{ inheritedViewportScissor2D_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceInheritedViewportScissorFeaturesNV( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceInheritedViewportScissorFeaturesNV( VkPhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceInheritedViewportScissorFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceInheritedViewportScissorFeaturesNV & operator=( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceInheritedViewportScissorFeaturesNV & operator=( VkPhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInheritedViewportScissorFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInheritedViewportScissorFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInheritedViewportScissorFeaturesNV & setInheritedViewportScissor2D( Bool32 inheritedViewportScissor2D_ ) & + VULKAN_HPP_NOEXCEPT + { + inheritedViewportScissor2D = inheritedViewportScissor2D_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInheritedViewportScissorFeaturesNV && setInheritedViewportScissor2D( Bool32 inheritedViewportScissor2D_ ) && + VULKAN_HPP_NOEXCEPT + { + inheritedViewportScissor2D = inheritedViewportScissor2D_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, inheritedViewportScissor2D ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceInheritedViewportScissorFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inheritedViewportScissor2D == rhs.inheritedViewportScissor2D ); +# endif + } + + bool operator!=( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceInheritedViewportScissorFeaturesNV; + void * pNext = {}; + Bool32 inheritedViewportScissor2D = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceInheritedViewportScissorFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceInheritedViewportScissorFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceInlineUniformBlockFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceInlineUniformBlockFeatures.html + struct PhysicalDeviceInlineUniformBlockFeatures + { + using NativeType = VkPhysicalDeviceInlineUniformBlockFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInlineUniformBlockFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeatures( Bool32 inlineUniformBlock_ = {}, + Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , inlineUniformBlock{ inlineUniformBlock_ } + , descriptorBindingInlineUniformBlockUpdateAfterBind{ descriptorBindingInlineUniformBlockUpdateAfterBind_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeatures( PhysicalDeviceInlineUniformBlockFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceInlineUniformBlockFeatures( VkPhysicalDeviceInlineUniformBlockFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceInlineUniformBlockFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceInlineUniformBlockFeatures & operator=( PhysicalDeviceInlineUniformBlockFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceInlineUniformBlockFeatures & operator=( VkPhysicalDeviceInlineUniformBlockFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures & setInlineUniformBlock( Bool32 inlineUniformBlock_ ) & VULKAN_HPP_NOEXCEPT + { + inlineUniformBlock = inlineUniformBlock_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures && setInlineUniformBlock( Bool32 inlineUniformBlock_ ) && VULKAN_HPP_NOEXCEPT + { + inlineUniformBlock = inlineUniformBlock_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures & + setDescriptorBindingInlineUniformBlockUpdateAfterBind( Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures && + setDescriptorBindingInlineUniformBlockUpdateAfterBind( Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceInlineUniformBlockFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInlineUniformBlockFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInlineUniformBlockFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInlineUniformBlockFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, inlineUniformBlock, descriptorBindingInlineUniformBlockUpdateAfterBind ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceInlineUniformBlockFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceInlineUniformBlockFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inlineUniformBlock == rhs.inlineUniformBlock ) && + ( descriptorBindingInlineUniformBlockUpdateAfterBind == rhs.descriptorBindingInlineUniformBlockUpdateAfterBind ); +# endif + } + + bool operator!=( PhysicalDeviceInlineUniformBlockFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeatures; + void * pNext = {}; + Bool32 inlineUniformBlock = {}; + Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceInlineUniformBlockFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceInlineUniformBlockFeatures; + }; + + using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures; + + // wrapper struct for struct VkPhysicalDeviceInlineUniformBlockProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceInlineUniformBlockProperties.html + struct PhysicalDeviceInlineUniformBlockProperties + { + using NativeType = VkPhysicalDeviceInlineUniformBlockProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInlineUniformBlockProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockProperties( uint32_t maxInlineUniformBlockSize_ = {}, + uint32_t maxPerStageDescriptorInlineUniformBlocks_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ = {}, + uint32_t maxDescriptorSetInlineUniformBlocks_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxInlineUniformBlockSize{ maxInlineUniformBlockSize_ } + , maxPerStageDescriptorInlineUniformBlocks{ maxPerStageDescriptorInlineUniformBlocks_ } + , maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks{ maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ } + , maxDescriptorSetInlineUniformBlocks{ maxDescriptorSetInlineUniformBlocks_ } + , maxDescriptorSetUpdateAfterBindInlineUniformBlocks{ maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockProperties( PhysicalDeviceInlineUniformBlockProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceInlineUniformBlockProperties( VkPhysicalDeviceInlineUniformBlockProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceInlineUniformBlockProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceInlineUniformBlockProperties & operator=( PhysicalDeviceInlineUniformBlockProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceInlineUniformBlockProperties & operator=( VkPhysicalDeviceInlineUniformBlockProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceInlineUniformBlockProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInlineUniformBlockProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInlineUniformBlockProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInlineUniformBlockProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxInlineUniformBlockSize, + maxPerStageDescriptorInlineUniformBlocks, + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, + maxDescriptorSetInlineUniformBlocks, + maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceInlineUniformBlockProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceInlineUniformBlockProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) && + ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks ) && + ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ) && + ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks ) && + ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks == rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); +# endif + } + + bool operator!=( PhysicalDeviceInlineUniformBlockProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockProperties; + void * pNext = {}; + uint32_t maxInlineUniformBlockSize = {}; + uint32_t maxPerStageDescriptorInlineUniformBlocks = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = {}; + uint32_t maxDescriptorSetInlineUniformBlocks = {}; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceInlineUniformBlockProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceInlineUniformBlockProperties; + }; + + using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties; + + // wrapper struct for struct VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR.html + struct PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR + { + using NativeType = VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR( Bool32 internallySynchronizedQueues_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , internallySynchronizedQueues{ internallySynchronizedQueues_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR( PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR( VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR & + operator=( PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR & operator=( VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR & setInternallySynchronizedQueues( Bool32 internallySynchronizedQueues_ ) & + VULKAN_HPP_NOEXCEPT + { + internallySynchronizedQueues = internallySynchronizedQueues_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR && setInternallySynchronizedQueues( Bool32 internallySynchronizedQueues_ ) && + VULKAN_HPP_NOEXCEPT + { + internallySynchronizedQueues = internallySynchronizedQueues_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, internallySynchronizedQueues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( internallySynchronizedQueues == rhs.internallySynchronizedQueues ); +# endif + } + + bool operator!=( PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; + void * pNext = {}; + Bool32 internallySynchronizedQueues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html + struct PhysicalDeviceInvocationMaskFeaturesHUAWEI + { + using NativeType = VkPhysicalDeviceInvocationMaskFeaturesHUAWEI; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInvocationMaskFeaturesHUAWEI; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceInvocationMaskFeaturesHUAWEI( Bool32 invocationMask_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , invocationMask{ invocationMask_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceInvocationMaskFeaturesHUAWEI( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceInvocationMaskFeaturesHUAWEI( VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceInvocationMaskFeaturesHUAWEI( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceInvocationMaskFeaturesHUAWEI & operator=( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceInvocationMaskFeaturesHUAWEI & operator=( VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInvocationMaskFeaturesHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInvocationMaskFeaturesHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInvocationMaskFeaturesHUAWEI & setInvocationMask( Bool32 invocationMask_ ) & VULKAN_HPP_NOEXCEPT + { + invocationMask = invocationMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInvocationMaskFeaturesHUAWEI && setInvocationMask( Bool32 invocationMask_ ) && VULKAN_HPP_NOEXCEPT + { + invocationMask = invocationMask_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, invocationMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & ) const = default; +#else + bool operator==( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( invocationMask == rhs.invocationMask ); +# endif + } + + bool operator!=( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceInvocationMaskFeaturesHUAWEI; + void * pNext = {}; + Bool32 invocationMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceInvocationMaskFeaturesHUAWEI; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceInvocationMaskFeaturesHUAWEI; + }; + + // wrapper struct for struct VkPhysicalDeviceLayeredApiPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiPropertiesKHR.html + struct PhysicalDeviceLayeredApiPropertiesKHR + { + using NativeType = VkPhysicalDeviceLayeredApiPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLayeredApiPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesKHR( uint32_t vendorID_ = {}, + uint32_t deviceID_ = {}, + PhysicalDeviceLayeredApiKHR layeredAPI_ = PhysicalDeviceLayeredApiKHR::eVulkan, + std::array const & deviceName_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vendorID{ vendorID_ } + , deviceID{ deviceID_ } + , layeredAPI{ layeredAPI_ } + , deviceName{ deviceName_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesKHR( PhysicalDeviceLayeredApiPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLayeredApiPropertiesKHR( VkPhysicalDeviceLayeredApiPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLayeredApiPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceLayeredApiPropertiesKHR & operator=( PhysicalDeviceLayeredApiPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceLayeredApiPropertiesKHR & operator=( VkPhysicalDeviceLayeredApiPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceLayeredApiPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredApiPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredApiPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredApiPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vendorID, deviceID, layeredAPI, deviceName ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLayeredApiPropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceLayeredApiPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && + ( layeredAPI == rhs.layeredAPI ) && ( deviceName == rhs.deviceName ); +# endif + } + + bool operator!=( PhysicalDeviceLayeredApiPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceLayeredApiPropertiesKHR; + void * pNext = {}; + uint32_t vendorID = {}; + uint32_t deviceID = {}; + PhysicalDeviceLayeredApiKHR layeredAPI = PhysicalDeviceLayeredApiKHR::eVulkan; + ArrayWrapper1D deviceName = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceLayeredApiPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceLayeredApiPropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceLayeredApiPropertiesListKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiPropertiesListKHR.html + struct PhysicalDeviceLayeredApiPropertiesListKHR + { + using NativeType = VkPhysicalDeviceLayeredApiPropertiesListKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLayeredApiPropertiesListKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR( uint32_t layeredApiCount_ = {}, + PhysicalDeviceLayeredApiPropertiesKHR * pLayeredApis_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , layeredApiCount{ layeredApiCount_ } + , pLayeredApis{ pLayeredApis_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR( PhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLayeredApiPropertiesListKHR( VkPhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLayeredApiPropertiesListKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceLayeredApiPropertiesListKHR( ArrayProxyNoTemporaries const & layeredApis_, void * pNext_ = nullptr ) + : pNext( pNext_ ), layeredApiCount( static_cast( layeredApis_.size() ) ), pLayeredApis( layeredApis_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PhysicalDeviceLayeredApiPropertiesListKHR & operator=( PhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceLayeredApiPropertiesListKHR & operator=( VkPhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR & setLayeredApiCount( uint32_t layeredApiCount_ ) & VULKAN_HPP_NOEXCEPT + { + layeredApiCount = layeredApiCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR && setLayeredApiCount( uint32_t layeredApiCount_ ) && VULKAN_HPP_NOEXCEPT + { + layeredApiCount = layeredApiCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR & setPLayeredApis( PhysicalDeviceLayeredApiPropertiesKHR * pLayeredApis_ ) & + VULKAN_HPP_NOEXCEPT + { + pLayeredApis = pLayeredApis_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR && setPLayeredApis( PhysicalDeviceLayeredApiPropertiesKHR * pLayeredApis_ ) && + VULKAN_HPP_NOEXCEPT + { + pLayeredApis = pLayeredApis_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PhysicalDeviceLayeredApiPropertiesListKHR & + setLayeredApis( ArrayProxyNoTemporaries const & layeredApis_ ) VULKAN_HPP_NOEXCEPT + { + layeredApiCount = static_cast( layeredApis_.size() ); + pLayeredApis = layeredApis_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceLayeredApiPropertiesListKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredApiPropertiesListKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredApiPropertiesListKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredApiPropertiesListKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, layeredApiCount, pLayeredApis ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLayeredApiPropertiesListKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( layeredApiCount == rhs.layeredApiCount ) && ( pLayeredApis == rhs.pLayeredApis ); +# endif + } + + bool operator!=( PhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceLayeredApiPropertiesListKHR; + void * pNext = {}; + uint32_t layeredApiCount = {}; + PhysicalDeviceLayeredApiPropertiesKHR * pLayeredApis = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceLayeredApiPropertiesListKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceLayeredApiPropertiesListKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceLimits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLimits.html + struct PhysicalDeviceLimits + { + using NativeType = VkPhysicalDeviceLimits; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLimits( uint32_t maxImageDimension1D_ = {}, + uint32_t maxImageDimension2D_ = {}, + uint32_t maxImageDimension3D_ = {}, + uint32_t maxImageDimensionCube_ = {}, + uint32_t maxImageArrayLayers_ = {}, + uint32_t maxTexelBufferElements_ = {}, + uint32_t maxUniformBufferRange_ = {}, + uint32_t maxStorageBufferRange_ = {}, + uint32_t maxPushConstantsSize_ = {}, + uint32_t maxMemoryAllocationCount_ = {}, + uint32_t maxSamplerAllocationCount_ = {}, + DeviceSize bufferImageGranularity_ = {}, + DeviceSize sparseAddressSpaceSize_ = {}, + uint32_t maxBoundDescriptorSets_ = {}, + uint32_t maxPerStageDescriptorSamplers_ = {}, + uint32_t maxPerStageDescriptorUniformBuffers_ = {}, + uint32_t maxPerStageDescriptorStorageBuffers_ = {}, + uint32_t maxPerStageDescriptorSampledImages_ = {}, + uint32_t maxPerStageDescriptorStorageImages_ = {}, + uint32_t maxPerStageDescriptorInputAttachments_ = {}, + uint32_t maxPerStageResources_ = {}, + uint32_t maxDescriptorSetSamplers_ = {}, + uint32_t maxDescriptorSetUniformBuffers_ = {}, + uint32_t maxDescriptorSetUniformBuffersDynamic_ = {}, + uint32_t maxDescriptorSetStorageBuffers_ = {}, + uint32_t maxDescriptorSetStorageBuffersDynamic_ = {}, + uint32_t maxDescriptorSetSampledImages_ = {}, + uint32_t maxDescriptorSetStorageImages_ = {}, + uint32_t maxDescriptorSetInputAttachments_ = {}, + uint32_t maxVertexInputAttributes_ = {}, + uint32_t maxVertexInputBindings_ = {}, + uint32_t maxVertexInputAttributeOffset_ = {}, + uint32_t maxVertexInputBindingStride_ = {}, + uint32_t maxVertexOutputComponents_ = {}, + uint32_t maxTessellationGenerationLevel_ = {}, + uint32_t maxTessellationPatchSize_ = {}, + uint32_t maxTessellationControlPerVertexInputComponents_ = {}, + uint32_t maxTessellationControlPerVertexOutputComponents_ = {}, + uint32_t maxTessellationControlPerPatchOutputComponents_ = {}, + uint32_t maxTessellationControlTotalOutputComponents_ = {}, + uint32_t maxTessellationEvaluationInputComponents_ = {}, + uint32_t maxTessellationEvaluationOutputComponents_ = {}, + uint32_t maxGeometryShaderInvocations_ = {}, + uint32_t maxGeometryInputComponents_ = {}, + uint32_t maxGeometryOutputComponents_ = {}, + uint32_t maxGeometryOutputVertices_ = {}, + uint32_t maxGeometryTotalOutputComponents_ = {}, + uint32_t maxFragmentInputComponents_ = {}, + uint32_t maxFragmentOutputAttachments_ = {}, + uint32_t maxFragmentDualSrcAttachments_ = {}, + uint32_t maxFragmentCombinedOutputResources_ = {}, + uint32_t maxComputeSharedMemorySize_ = {}, + std::array const & maxComputeWorkGroupCount_ = {}, + uint32_t maxComputeWorkGroupInvocations_ = {}, + std::array const & maxComputeWorkGroupSize_ = {}, + uint32_t subPixelPrecisionBits_ = {}, + uint32_t subTexelPrecisionBits_ = {}, + uint32_t mipmapPrecisionBits_ = {}, + uint32_t maxDrawIndexedIndexValue_ = {}, + uint32_t maxDrawIndirectCount_ = {}, + float maxSamplerLodBias_ = {}, + float maxSamplerAnisotropy_ = {}, + uint32_t maxViewports_ = {}, + std::array const & maxViewportDimensions_ = {}, + std::array const & viewportBoundsRange_ = {}, + uint32_t viewportSubPixelBits_ = {}, + size_t minMemoryMapAlignment_ = {}, + DeviceSize minTexelBufferOffsetAlignment_ = {}, + DeviceSize minUniformBufferOffsetAlignment_ = {}, + DeviceSize minStorageBufferOffsetAlignment_ = {}, + int32_t minTexelOffset_ = {}, + uint32_t maxTexelOffset_ = {}, + int32_t minTexelGatherOffset_ = {}, + uint32_t maxTexelGatherOffset_ = {}, + float minInterpolationOffset_ = {}, + float maxInterpolationOffset_ = {}, + uint32_t subPixelInterpolationOffsetBits_ = {}, + uint32_t maxFramebufferWidth_ = {}, + uint32_t maxFramebufferHeight_ = {}, + uint32_t maxFramebufferLayers_ = {}, + SampleCountFlags framebufferColorSampleCounts_ = {}, + SampleCountFlags framebufferDepthSampleCounts_ = {}, + SampleCountFlags framebufferStencilSampleCounts_ = {}, + SampleCountFlags framebufferNoAttachmentsSampleCounts_ = {}, + uint32_t maxColorAttachments_ = {}, + SampleCountFlags sampledImageColorSampleCounts_ = {}, + SampleCountFlags sampledImageIntegerSampleCounts_ = {}, + SampleCountFlags sampledImageDepthSampleCounts_ = {}, + SampleCountFlags sampledImageStencilSampleCounts_ = {}, + SampleCountFlags storageImageSampleCounts_ = {}, + uint32_t maxSampleMaskWords_ = {}, + Bool32 timestampComputeAndGraphics_ = {}, + float timestampPeriod_ = {}, + uint32_t maxClipDistances_ = {}, + uint32_t maxCullDistances_ = {}, + uint32_t maxCombinedClipAndCullDistances_ = {}, + uint32_t discreteQueuePriorities_ = {}, + std::array const & pointSizeRange_ = {}, + std::array const & lineWidthRange_ = {}, + float pointSizeGranularity_ = {}, + float lineWidthGranularity_ = {}, + Bool32 strictLines_ = {}, + Bool32 standardSampleLocations_ = {}, + DeviceSize optimalBufferCopyOffsetAlignment_ = {}, + DeviceSize optimalBufferCopyRowPitchAlignment_ = {}, + DeviceSize nonCoherentAtomSize_ = {} ) VULKAN_HPP_NOEXCEPT + : maxImageDimension1D{ maxImageDimension1D_ } + , maxImageDimension2D{ maxImageDimension2D_ } + , maxImageDimension3D{ maxImageDimension3D_ } + , maxImageDimensionCube{ maxImageDimensionCube_ } + , maxImageArrayLayers{ maxImageArrayLayers_ } + , maxTexelBufferElements{ maxTexelBufferElements_ } + , maxUniformBufferRange{ maxUniformBufferRange_ } + , maxStorageBufferRange{ maxStorageBufferRange_ } + , maxPushConstantsSize{ maxPushConstantsSize_ } + , maxMemoryAllocationCount{ maxMemoryAllocationCount_ } + , maxSamplerAllocationCount{ maxSamplerAllocationCount_ } + , bufferImageGranularity{ bufferImageGranularity_ } + , sparseAddressSpaceSize{ sparseAddressSpaceSize_ } + , maxBoundDescriptorSets{ maxBoundDescriptorSets_ } + , maxPerStageDescriptorSamplers{ maxPerStageDescriptorSamplers_ } + , maxPerStageDescriptorUniformBuffers{ maxPerStageDescriptorUniformBuffers_ } + , maxPerStageDescriptorStorageBuffers{ maxPerStageDescriptorStorageBuffers_ } + , maxPerStageDescriptorSampledImages{ maxPerStageDescriptorSampledImages_ } + , maxPerStageDescriptorStorageImages{ maxPerStageDescriptorStorageImages_ } + , maxPerStageDescriptorInputAttachments{ maxPerStageDescriptorInputAttachments_ } + , maxPerStageResources{ maxPerStageResources_ } + , maxDescriptorSetSamplers{ maxDescriptorSetSamplers_ } + , maxDescriptorSetUniformBuffers{ maxDescriptorSetUniformBuffers_ } + , maxDescriptorSetUniformBuffersDynamic{ maxDescriptorSetUniformBuffersDynamic_ } + , maxDescriptorSetStorageBuffers{ maxDescriptorSetStorageBuffers_ } + , maxDescriptorSetStorageBuffersDynamic{ maxDescriptorSetStorageBuffersDynamic_ } + , maxDescriptorSetSampledImages{ maxDescriptorSetSampledImages_ } + , maxDescriptorSetStorageImages{ maxDescriptorSetStorageImages_ } + , maxDescriptorSetInputAttachments{ maxDescriptorSetInputAttachments_ } + , maxVertexInputAttributes{ maxVertexInputAttributes_ } + , maxVertexInputBindings{ maxVertexInputBindings_ } + , maxVertexInputAttributeOffset{ maxVertexInputAttributeOffset_ } + , maxVertexInputBindingStride{ maxVertexInputBindingStride_ } + , maxVertexOutputComponents{ maxVertexOutputComponents_ } + , maxTessellationGenerationLevel{ maxTessellationGenerationLevel_ } + , maxTessellationPatchSize{ maxTessellationPatchSize_ } + , maxTessellationControlPerVertexInputComponents{ maxTessellationControlPerVertexInputComponents_ } + , maxTessellationControlPerVertexOutputComponents{ maxTessellationControlPerVertexOutputComponents_ } + , maxTessellationControlPerPatchOutputComponents{ maxTessellationControlPerPatchOutputComponents_ } + , maxTessellationControlTotalOutputComponents{ maxTessellationControlTotalOutputComponents_ } + , maxTessellationEvaluationInputComponents{ maxTessellationEvaluationInputComponents_ } + , maxTessellationEvaluationOutputComponents{ maxTessellationEvaluationOutputComponents_ } + , maxGeometryShaderInvocations{ maxGeometryShaderInvocations_ } + , maxGeometryInputComponents{ maxGeometryInputComponents_ } + , maxGeometryOutputComponents{ maxGeometryOutputComponents_ } + , maxGeometryOutputVertices{ maxGeometryOutputVertices_ } + , maxGeometryTotalOutputComponents{ maxGeometryTotalOutputComponents_ } + , maxFragmentInputComponents{ maxFragmentInputComponents_ } + , maxFragmentOutputAttachments{ maxFragmentOutputAttachments_ } + , maxFragmentDualSrcAttachments{ maxFragmentDualSrcAttachments_ } + , maxFragmentCombinedOutputResources{ maxFragmentCombinedOutputResources_ } + , maxComputeSharedMemorySize{ maxComputeSharedMemorySize_ } + , maxComputeWorkGroupCount{ maxComputeWorkGroupCount_ } + , maxComputeWorkGroupInvocations{ maxComputeWorkGroupInvocations_ } + , maxComputeWorkGroupSize{ maxComputeWorkGroupSize_ } + , subPixelPrecisionBits{ subPixelPrecisionBits_ } + , subTexelPrecisionBits{ subTexelPrecisionBits_ } + , mipmapPrecisionBits{ mipmapPrecisionBits_ } + , maxDrawIndexedIndexValue{ maxDrawIndexedIndexValue_ } + , maxDrawIndirectCount{ maxDrawIndirectCount_ } + , maxSamplerLodBias{ maxSamplerLodBias_ } + , maxSamplerAnisotropy{ maxSamplerAnisotropy_ } + , maxViewports{ maxViewports_ } + , maxViewportDimensions{ maxViewportDimensions_ } + , viewportBoundsRange{ viewportBoundsRange_ } + , viewportSubPixelBits{ viewportSubPixelBits_ } + , minMemoryMapAlignment{ minMemoryMapAlignment_ } + , minTexelBufferOffsetAlignment{ minTexelBufferOffsetAlignment_ } + , minUniformBufferOffsetAlignment{ minUniformBufferOffsetAlignment_ } + , minStorageBufferOffsetAlignment{ minStorageBufferOffsetAlignment_ } + , minTexelOffset{ minTexelOffset_ } + , maxTexelOffset{ maxTexelOffset_ } + , minTexelGatherOffset{ minTexelGatherOffset_ } + , maxTexelGatherOffset{ maxTexelGatherOffset_ } + , minInterpolationOffset{ minInterpolationOffset_ } + , maxInterpolationOffset{ maxInterpolationOffset_ } + , subPixelInterpolationOffsetBits{ subPixelInterpolationOffsetBits_ } + , maxFramebufferWidth{ maxFramebufferWidth_ } + , maxFramebufferHeight{ maxFramebufferHeight_ } + , maxFramebufferLayers{ maxFramebufferLayers_ } + , framebufferColorSampleCounts{ framebufferColorSampleCounts_ } + , framebufferDepthSampleCounts{ framebufferDepthSampleCounts_ } + , framebufferStencilSampleCounts{ framebufferStencilSampleCounts_ } + , framebufferNoAttachmentsSampleCounts{ framebufferNoAttachmentsSampleCounts_ } + , maxColorAttachments{ maxColorAttachments_ } + , sampledImageColorSampleCounts{ sampledImageColorSampleCounts_ } + , sampledImageIntegerSampleCounts{ sampledImageIntegerSampleCounts_ } + , sampledImageDepthSampleCounts{ sampledImageDepthSampleCounts_ } + , sampledImageStencilSampleCounts{ sampledImageStencilSampleCounts_ } + , storageImageSampleCounts{ storageImageSampleCounts_ } + , maxSampleMaskWords{ maxSampleMaskWords_ } + , timestampComputeAndGraphics{ timestampComputeAndGraphics_ } + , timestampPeriod{ timestampPeriod_ } + , maxClipDistances{ maxClipDistances_ } + , maxCullDistances{ maxCullDistances_ } + , maxCombinedClipAndCullDistances{ maxCombinedClipAndCullDistances_ } + , discreteQueuePriorities{ discreteQueuePriorities_ } + , pointSizeRange{ pointSizeRange_ } + , lineWidthRange{ lineWidthRange_ } + , pointSizeGranularity{ pointSizeGranularity_ } + , lineWidthGranularity{ lineWidthGranularity_ } + , strictLines{ strictLines_ } + , standardSampleLocations{ standardSampleLocations_ } + , optimalBufferCopyOffsetAlignment{ optimalBufferCopyOffsetAlignment_ } + , optimalBufferCopyRowPitchAlignment{ optimalBufferCopyRowPitchAlignment_ } + , nonCoherentAtomSize{ nonCoherentAtomSize_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLimits( PhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLimits( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLimits( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceLimits & operator=( PhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceLimits & operator=( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceLimits const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLimits &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLimits const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLimits *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + uint32_t const &, + ArrayWrapper1D const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + float const &, + float const &, + uint32_t const &, + ArrayWrapper1D const &, + ArrayWrapper1D const &, + uint32_t const &, + size_t const &, + DeviceSize const &, + DeviceSize const &, + DeviceSize const &, + int32_t const &, + uint32_t const &, + int32_t const &, + uint32_t const &, + float const &, + float const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + SampleCountFlags const &, + SampleCountFlags const &, + SampleCountFlags const &, + SampleCountFlags const &, + uint32_t const &, + SampleCountFlags const &, + SampleCountFlags const &, + SampleCountFlags const &, + SampleCountFlags const &, + SampleCountFlags const &, + uint32_t const &, + Bool32 const &, + float const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + ArrayWrapper1D const &, + ArrayWrapper1D const &, + float const &, + float const &, + Bool32 const &, + Bool32 const &, + DeviceSize const &, + DeviceSize const &, + DeviceSize const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( maxImageDimension1D, + maxImageDimension2D, + maxImageDimension3D, + maxImageDimensionCube, + maxImageArrayLayers, + maxTexelBufferElements, + maxUniformBufferRange, + maxStorageBufferRange, + maxPushConstantsSize, + maxMemoryAllocationCount, + maxSamplerAllocationCount, + bufferImageGranularity, + sparseAddressSpaceSize, + maxBoundDescriptorSets, + maxPerStageDescriptorSamplers, + maxPerStageDescriptorUniformBuffers, + maxPerStageDescriptorStorageBuffers, + maxPerStageDescriptorSampledImages, + maxPerStageDescriptorStorageImages, + maxPerStageDescriptorInputAttachments, + maxPerStageResources, + maxDescriptorSetSamplers, + maxDescriptorSetUniformBuffers, + maxDescriptorSetUniformBuffersDynamic, + maxDescriptorSetStorageBuffers, + maxDescriptorSetStorageBuffersDynamic, + maxDescriptorSetSampledImages, + maxDescriptorSetStorageImages, + maxDescriptorSetInputAttachments, + maxVertexInputAttributes, + maxVertexInputBindings, + maxVertexInputAttributeOffset, + maxVertexInputBindingStride, + maxVertexOutputComponents, + maxTessellationGenerationLevel, + maxTessellationPatchSize, + maxTessellationControlPerVertexInputComponents, + maxTessellationControlPerVertexOutputComponents, + maxTessellationControlPerPatchOutputComponents, + maxTessellationControlTotalOutputComponents, + maxTessellationEvaluationInputComponents, + maxTessellationEvaluationOutputComponents, + maxGeometryShaderInvocations, + maxGeometryInputComponents, + maxGeometryOutputComponents, + maxGeometryOutputVertices, + maxGeometryTotalOutputComponents, + maxFragmentInputComponents, + maxFragmentOutputAttachments, + maxFragmentDualSrcAttachments, + maxFragmentCombinedOutputResources, + maxComputeSharedMemorySize, + maxComputeWorkGroupCount, + maxComputeWorkGroupInvocations, + maxComputeWorkGroupSize, + subPixelPrecisionBits, + subTexelPrecisionBits, + mipmapPrecisionBits, + maxDrawIndexedIndexValue, + maxDrawIndirectCount, + maxSamplerLodBias, + maxSamplerAnisotropy, + maxViewports, + maxViewportDimensions, + viewportBoundsRange, + viewportSubPixelBits, + minMemoryMapAlignment, + minTexelBufferOffsetAlignment, + minUniformBufferOffsetAlignment, + minStorageBufferOffsetAlignment, + minTexelOffset, + maxTexelOffset, + minTexelGatherOffset, + maxTexelGatherOffset, + minInterpolationOffset, + maxInterpolationOffset, + subPixelInterpolationOffsetBits, + maxFramebufferWidth, + maxFramebufferHeight, + maxFramebufferLayers, + framebufferColorSampleCounts, + framebufferDepthSampleCounts, + framebufferStencilSampleCounts, + framebufferNoAttachmentsSampleCounts, + maxColorAttachments, + sampledImageColorSampleCounts, + sampledImageIntegerSampleCounts, + sampledImageDepthSampleCounts, + sampledImageStencilSampleCounts, + storageImageSampleCounts, + maxSampleMaskWords, + timestampComputeAndGraphics, + timestampPeriod, + maxClipDistances, + maxCullDistances, + maxCombinedClipAndCullDistances, + discreteQueuePriorities, + pointSizeRange, + lineWidthRange, + pointSizeGranularity, + lineWidthGranularity, + strictLines, + standardSampleLocations, + optimalBufferCopyOffsetAlignment, + optimalBufferCopyRowPitchAlignment, + nonCoherentAtomSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLimits const & ) const = default; +#else + bool operator==( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( maxImageDimension1D == rhs.maxImageDimension1D ) && ( maxImageDimension2D == rhs.maxImageDimension2D ) && + ( maxImageDimension3D == rhs.maxImageDimension3D ) && ( maxImageDimensionCube == rhs.maxImageDimensionCube ) && + ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && ( maxTexelBufferElements == rhs.maxTexelBufferElements ) && + ( maxUniformBufferRange == rhs.maxUniformBufferRange ) && ( maxStorageBufferRange == rhs.maxStorageBufferRange ) && + ( maxPushConstantsSize == rhs.maxPushConstantsSize ) && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) && + ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) && ( bufferImageGranularity == rhs.bufferImageGranularity ) && + ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) && + ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) && + ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) && + ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) && + ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) && + ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) && + ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) && ( maxPerStageResources == rhs.maxPerStageResources ) && + ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) && + ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) && + ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) && + ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) && + ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) && + ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) && + ( maxVertexInputBindings == rhs.maxVertexInputBindings ) && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) && + ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) && + ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) && + ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) && + ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents ) && + ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) && + ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) && + ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) && + ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) && + ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) && + ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) && + ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) && + ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) && + ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) && + ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) && ( maxComputeWorkGroupCount == rhs.maxComputeWorkGroupCount ) && + ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) && ( maxComputeWorkGroupSize == rhs.maxComputeWorkGroupSize ) && + ( subPixelPrecisionBits == rhs.subPixelPrecisionBits ) && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits ) && + ( mipmapPrecisionBits == rhs.mipmapPrecisionBits ) && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue ) && + ( maxDrawIndirectCount == rhs.maxDrawIndirectCount ) && ( maxSamplerLodBias == rhs.maxSamplerLodBias ) && + ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy ) && ( maxViewports == rhs.maxViewports ) && + ( maxViewportDimensions == rhs.maxViewportDimensions ) && ( viewportBoundsRange == rhs.viewportBoundsRange ) && + ( viewportSubPixelBits == rhs.viewportSubPixelBits ) && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment ) && + ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment ) && + ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment ) && + ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment ) && ( minTexelOffset == rhs.minTexelOffset ) && + ( maxTexelOffset == rhs.maxTexelOffset ) && ( minTexelGatherOffset == rhs.minTexelGatherOffset ) && + ( maxTexelGatherOffset == rhs.maxTexelGatherOffset ) && ( minInterpolationOffset == rhs.minInterpolationOffset ) && + ( maxInterpolationOffset == rhs.maxInterpolationOffset ) && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits ) && + ( maxFramebufferWidth == rhs.maxFramebufferWidth ) && ( maxFramebufferHeight == rhs.maxFramebufferHeight ) && + ( maxFramebufferLayers == rhs.maxFramebufferLayers ) && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts ) && + ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts ) && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts ) && + ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts ) && ( maxColorAttachments == rhs.maxColorAttachments ) && + ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts ) && + ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts ) && + ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts ) && + ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts ) && ( storageImageSampleCounts == rhs.storageImageSampleCounts ) && + ( maxSampleMaskWords == rhs.maxSampleMaskWords ) && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics ) && + ( timestampPeriod == rhs.timestampPeriod ) && ( maxClipDistances == rhs.maxClipDistances ) && ( maxCullDistances == rhs.maxCullDistances ) && + ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances ) && ( discreteQueuePriorities == rhs.discreteQueuePriorities ) && + ( pointSizeRange == rhs.pointSizeRange ) && ( lineWidthRange == rhs.lineWidthRange ) && ( pointSizeGranularity == rhs.pointSizeGranularity ) && + ( lineWidthGranularity == rhs.lineWidthGranularity ) && ( strictLines == rhs.strictLines ) && + ( standardSampleLocations == rhs.standardSampleLocations ) && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) && + ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize ); +# endif + } + + bool operator!=( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t maxImageDimension1D = {}; + uint32_t maxImageDimension2D = {}; + uint32_t maxImageDimension3D = {}; + uint32_t maxImageDimensionCube = {}; + uint32_t maxImageArrayLayers = {}; + uint32_t maxTexelBufferElements = {}; + uint32_t maxUniformBufferRange = {}; + uint32_t maxStorageBufferRange = {}; + uint32_t maxPushConstantsSize = {}; + uint32_t maxMemoryAllocationCount = {}; + uint32_t maxSamplerAllocationCount = {}; + DeviceSize bufferImageGranularity = {}; + DeviceSize sparseAddressSpaceSize = {}; + uint32_t maxBoundDescriptorSets = {}; + uint32_t maxPerStageDescriptorSamplers = {}; + uint32_t maxPerStageDescriptorUniformBuffers = {}; + uint32_t maxPerStageDescriptorStorageBuffers = {}; + uint32_t maxPerStageDescriptorSampledImages = {}; + uint32_t maxPerStageDescriptorStorageImages = {}; + uint32_t maxPerStageDescriptorInputAttachments = {}; + uint32_t maxPerStageResources = {}; + uint32_t maxDescriptorSetSamplers = {}; + uint32_t maxDescriptorSetUniformBuffers = {}; + uint32_t maxDescriptorSetUniformBuffersDynamic = {}; + uint32_t maxDescriptorSetStorageBuffers = {}; + uint32_t maxDescriptorSetStorageBuffersDynamic = {}; + uint32_t maxDescriptorSetSampledImages = {}; + uint32_t maxDescriptorSetStorageImages = {}; + uint32_t maxDescriptorSetInputAttachments = {}; + uint32_t maxVertexInputAttributes = {}; + uint32_t maxVertexInputBindings = {}; + uint32_t maxVertexInputAttributeOffset = {}; + uint32_t maxVertexInputBindingStride = {}; + uint32_t maxVertexOutputComponents = {}; + uint32_t maxTessellationGenerationLevel = {}; + uint32_t maxTessellationPatchSize = {}; + uint32_t maxTessellationControlPerVertexInputComponents = {}; + uint32_t maxTessellationControlPerVertexOutputComponents = {}; + uint32_t maxTessellationControlPerPatchOutputComponents = {}; + uint32_t maxTessellationControlTotalOutputComponents = {}; + uint32_t maxTessellationEvaluationInputComponents = {}; + uint32_t maxTessellationEvaluationOutputComponents = {}; + uint32_t maxGeometryShaderInvocations = {}; + uint32_t maxGeometryInputComponents = {}; + uint32_t maxGeometryOutputComponents = {}; + uint32_t maxGeometryOutputVertices = {}; + uint32_t maxGeometryTotalOutputComponents = {}; + uint32_t maxFragmentInputComponents = {}; + uint32_t maxFragmentOutputAttachments = {}; + uint32_t maxFragmentDualSrcAttachments = {}; + uint32_t maxFragmentCombinedOutputResources = {}; + uint32_t maxComputeSharedMemorySize = {}; + ArrayWrapper1D maxComputeWorkGroupCount = {}; + uint32_t maxComputeWorkGroupInvocations = {}; + ArrayWrapper1D maxComputeWorkGroupSize = {}; + uint32_t subPixelPrecisionBits = {}; + uint32_t subTexelPrecisionBits = {}; + uint32_t mipmapPrecisionBits = {}; + uint32_t maxDrawIndexedIndexValue = {}; + uint32_t maxDrawIndirectCount = {}; + float maxSamplerLodBias = {}; + float maxSamplerAnisotropy = {}; + uint32_t maxViewports = {}; + ArrayWrapper1D maxViewportDimensions = {}; + ArrayWrapper1D viewportBoundsRange = {}; + uint32_t viewportSubPixelBits = {}; + size_t minMemoryMapAlignment = {}; + DeviceSize minTexelBufferOffsetAlignment = {}; + DeviceSize minUniformBufferOffsetAlignment = {}; + DeviceSize minStorageBufferOffsetAlignment = {}; + int32_t minTexelOffset = {}; + uint32_t maxTexelOffset = {}; + int32_t minTexelGatherOffset = {}; + uint32_t maxTexelGatherOffset = {}; + float minInterpolationOffset = {}; + float maxInterpolationOffset = {}; + uint32_t subPixelInterpolationOffsetBits = {}; + uint32_t maxFramebufferWidth = {}; + uint32_t maxFramebufferHeight = {}; + uint32_t maxFramebufferLayers = {}; + SampleCountFlags framebufferColorSampleCounts = {}; + SampleCountFlags framebufferDepthSampleCounts = {}; + SampleCountFlags framebufferStencilSampleCounts = {}; + SampleCountFlags framebufferNoAttachmentsSampleCounts = {}; + uint32_t maxColorAttachments = {}; + SampleCountFlags sampledImageColorSampleCounts = {}; + SampleCountFlags sampledImageIntegerSampleCounts = {}; + SampleCountFlags sampledImageDepthSampleCounts = {}; + SampleCountFlags sampledImageStencilSampleCounts = {}; + SampleCountFlags storageImageSampleCounts = {}; + uint32_t maxSampleMaskWords = {}; + Bool32 timestampComputeAndGraphics = {}; + float timestampPeriod = {}; + uint32_t maxClipDistances = {}; + uint32_t maxCullDistances = {}; + uint32_t maxCombinedClipAndCullDistances = {}; + uint32_t discreteQueuePriorities = {}; + ArrayWrapper1D pointSizeRange = {}; + ArrayWrapper1D lineWidthRange = {}; + float pointSizeGranularity = {}; + float lineWidthGranularity = {}; + Bool32 strictLines = {}; + Bool32 standardSampleLocations = {}; + DeviceSize optimalBufferCopyOffsetAlignment = {}; + DeviceSize optimalBufferCopyRowPitchAlignment = {}; + DeviceSize nonCoherentAtomSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceLimits; + }; +#endif + + // wrapper struct for struct VkPhysicalDeviceSparseProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSparseProperties.html + struct PhysicalDeviceSparseProperties + { + using NativeType = VkPhysicalDeviceSparseProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseProperties( Bool32 residencyStandard2DBlockShape_ = {}, + Bool32 residencyStandard2DMultisampleBlockShape_ = {}, + Bool32 residencyStandard3DBlockShape_ = {}, + Bool32 residencyAlignedMipSize_ = {}, + Bool32 residencyNonResidentStrict_ = {} ) VULKAN_HPP_NOEXCEPT + : residencyStandard2DBlockShape{ residencyStandard2DBlockShape_ } + , residencyStandard2DMultisampleBlockShape{ residencyStandard2DMultisampleBlockShape_ } + , residencyStandard3DBlockShape{ residencyStandard3DBlockShape_ } + , residencyAlignedMipSize{ residencyAlignedMipSize_ } + , residencyNonResidentStrict{ residencyNonResidentStrict_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseProperties( PhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSparseProperties( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSparseProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSparseProperties & operator=( PhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSparseProperties & operator=( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceSparseProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSparseProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSparseProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSparseProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( residencyStandard2DBlockShape, + residencyStandard2DMultisampleBlockShape, + residencyStandard3DBlockShape, + residencyAlignedMipSize, + residencyNonResidentStrict ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSparseProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape ) && + ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape ) && + ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape ) && ( residencyAlignedMipSize == rhs.residencyAlignedMipSize ) && + ( residencyNonResidentStrict == rhs.residencyNonResidentStrict ); +# endif + } + + bool operator!=( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Bool32 residencyStandard2DBlockShape = {}; + Bool32 residencyStandard2DMultisampleBlockShape = {}; + Bool32 residencyStandard3DBlockShape = {}; + Bool32 residencyAlignedMipSize = {}; + Bool32 residencyNonResidentStrict = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSparseProperties; + }; +#endif + + // wrapper struct for struct VkPhysicalDeviceProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProperties.html + struct PhysicalDeviceProperties + { + using NativeType = VkPhysicalDeviceProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties( uint32_t apiVersion_ = {}, + uint32_t driverVersion_ = {}, + uint32_t vendorID_ = {}, + uint32_t deviceID_ = {}, + PhysicalDeviceType deviceType_ = PhysicalDeviceType::eOther, + std::array const & deviceName_ = {}, + std::array const & pipelineCacheUUID_ = {}, + PhysicalDeviceLimits limits_ = {}, + PhysicalDeviceSparseProperties sparseProperties_ = {} ) VULKAN_HPP_NOEXCEPT + : apiVersion{ apiVersion_ } + , driverVersion{ driverVersion_ } + , vendorID{ vendorID_ } + , deviceID{ deviceID_ } + , deviceType{ deviceType_ } + , deviceName{ deviceName_ } + , pipelineCacheUUID{ pipelineCacheUUID_ } + , limits{ limits_ } + , sparseProperties{ sparseProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties( PhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceProperties( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceProperties & operator=( PhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceProperties & operator=( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &, + PhysicalDeviceLimits const &, + PhysicalDeviceSparseProperties const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( apiVersion, driverVersion, vendorID, deviceID, deviceType, deviceName, pipelineCacheUUID, limits, sparseProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::partial_ordering operator<=>( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = apiVersion <=> rhs.apiVersion; cmp != 0 ) + return cmp; + if ( auto cmp = driverVersion <=> rhs.driverVersion; cmp != 0 ) + return cmp; + if ( auto cmp = vendorID <=> rhs.vendorID; cmp != 0 ) + return cmp; + if ( auto cmp = deviceID <=> rhs.deviceID; cmp != 0 ) + return cmp; + if ( auto cmp = deviceType <=> rhs.deviceType; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( deviceName, rhs.deviceName ); cmp != 0 ) + return ( cmp < 0 ) ? std::partial_ordering::less : std::partial_ordering::greater; + if ( auto cmp = pipelineCacheUUID <=> rhs.pipelineCacheUUID; cmp != 0 ) + return cmp; + if ( auto cmp = limits <=> rhs.limits; cmp != 0 ) + return cmp; + if ( auto cmp = sparseProperties <=> rhs.sparseProperties; cmp != 0 ) + return cmp; + + return std::partial_ordering::equivalent; + } +#endif + + bool operator==( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( apiVersion == rhs.apiVersion ) && ( driverVersion == rhs.driverVersion ) && ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && + ( deviceType == rhs.deviceType ) && ( strcmp( deviceName, rhs.deviceName ) == 0 ) && ( pipelineCacheUUID == rhs.pipelineCacheUUID ) && + ( limits == rhs.limits ) && ( sparseProperties == rhs.sparseProperties ); + } + + bool operator!=( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t apiVersion = {}; + uint32_t driverVersion = {}; + uint32_t vendorID = {}; + uint32_t deviceID = {}; + PhysicalDeviceType deviceType = PhysicalDeviceType::eOther; + ArrayWrapper1D deviceName = {}; + ArrayWrapper1D pipelineCacheUUID = {}; + PhysicalDeviceLimits limits = {}; + PhysicalDeviceSparseProperties sparseProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceProperties; + }; +#endif + + // wrapper struct for struct VkPhysicalDeviceProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProperties2.html + struct PhysicalDeviceProperties2 + { + using NativeType = VkPhysicalDeviceProperties2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProperties2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties2( PhysicalDeviceProperties properties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , properties{ properties_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties2( PhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceProperties2( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceProperties2 & operator=( PhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceProperties2 & operator=( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceProperties2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProperties2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProperties2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProperties2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, properties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceProperties2 const & ) const = default; +#else + bool operator==( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); +# endif + } + + bool operator!=( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceProperties2; + void * pNext = {}; + PhysicalDeviceProperties properties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceProperties2; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceProperties2; + }; + + using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; + + // wrapper struct for struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiVulkanPropertiesKHR.html + struct PhysicalDeviceLayeredApiVulkanPropertiesKHR + { + using NativeType = VkPhysicalDeviceLayeredApiVulkanPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLayeredApiVulkanPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiVulkanPropertiesKHR( PhysicalDeviceProperties2 properties_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , properties{ properties_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + PhysicalDeviceLayeredApiVulkanPropertiesKHR( PhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLayeredApiVulkanPropertiesKHR( VkPhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLayeredApiVulkanPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceLayeredApiVulkanPropertiesKHR & operator=( PhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceLayeredApiVulkanPropertiesKHR & operator=( VkPhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceLayeredApiVulkanPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredApiVulkanPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredApiVulkanPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredApiVulkanPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, properties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLayeredApiVulkanPropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); +# endif + } + + bool operator!=( PhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceLayeredApiVulkanPropertiesKHR; + void * pNext = {}; + PhysicalDeviceProperties2 properties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceLayeredApiVulkanPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceLayeredApiVulkanPropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceLayeredDriverPropertiesMSFT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredDriverPropertiesMSFT.html + struct PhysicalDeviceLayeredDriverPropertiesMSFT + { + using NativeType = VkPhysicalDeviceLayeredDriverPropertiesMSFT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceLayeredDriverPropertiesMSFT( LayeredDriverUnderlyingApiMSFT underlyingAPI_ = LayeredDriverUnderlyingApiMSFT::eNone, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , underlyingAPI{ underlyingAPI_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceLayeredDriverPropertiesMSFT( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLayeredDriverPropertiesMSFT( VkPhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLayeredDriverPropertiesMSFT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceLayeredDriverPropertiesMSFT & operator=( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceLayeredDriverPropertiesMSFT & operator=( VkPhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceLayeredDriverPropertiesMSFT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredDriverPropertiesMSFT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredDriverPropertiesMSFT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLayeredDriverPropertiesMSFT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, underlyingAPI ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLayeredDriverPropertiesMSFT const & ) const = default; +#else + bool operator==( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( underlyingAPI == rhs.underlyingAPI ); +# endif + } + + bool operator!=( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT; + void * pNext = {}; + LayeredDriverUnderlyingApiMSFT underlyingAPI = LayeredDriverUnderlyingApiMSFT::eNone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceLayeredDriverPropertiesMSFT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceLayeredDriverPropertiesMSFT; + }; + + // wrapper struct for struct VkPhysicalDeviceLegacyDitheringFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLegacyDitheringFeaturesEXT.html + struct PhysicalDeviceLegacyDitheringFeaturesEXT + { + using NativeType = VkPhysicalDeviceLegacyDitheringFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceLegacyDitheringFeaturesEXT( Bool32 legacyDithering_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , legacyDithering{ legacyDithering_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceLegacyDitheringFeaturesEXT( PhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLegacyDitheringFeaturesEXT( VkPhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLegacyDitheringFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceLegacyDitheringFeaturesEXT & operator=( PhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceLegacyDitheringFeaturesEXT & operator=( VkPhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyDitheringFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyDitheringFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyDitheringFeaturesEXT & setLegacyDithering( Bool32 legacyDithering_ ) & VULKAN_HPP_NOEXCEPT + { + legacyDithering = legacyDithering_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyDitheringFeaturesEXT && setLegacyDithering( Bool32 legacyDithering_ ) && VULKAN_HPP_NOEXCEPT + { + legacyDithering = legacyDithering_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceLegacyDitheringFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLegacyDitheringFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLegacyDitheringFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLegacyDitheringFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, legacyDithering ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLegacyDitheringFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( legacyDithering == rhs.legacyDithering ); +# endif + } + + bool operator!=( PhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT; + void * pNext = {}; + Bool32 legacyDithering = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceLegacyDitheringFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceLegacyDitheringFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.html + struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT + { + using NativeType = VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLegacyVertexAttributesFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceLegacyVertexAttributesFeaturesEXT( Bool32 legacyVertexAttributes_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , legacyVertexAttributes{ legacyVertexAttributes_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceLegacyVertexAttributesFeaturesEXT( PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLegacyVertexAttributesFeaturesEXT( VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLegacyVertexAttributesFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceLegacyVertexAttributesFeaturesEXT & operator=( PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceLegacyVertexAttributesFeaturesEXT & operator=( VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyVertexAttributesFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyVertexAttributesFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyVertexAttributesFeaturesEXT & setLegacyVertexAttributes( Bool32 legacyVertexAttributes_ ) & VULKAN_HPP_NOEXCEPT + { + legacyVertexAttributes = legacyVertexAttributes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyVertexAttributesFeaturesEXT && setLegacyVertexAttributes( Bool32 legacyVertexAttributes_ ) && + VULKAN_HPP_NOEXCEPT + { + legacyVertexAttributes = legacyVertexAttributes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, legacyVertexAttributes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( legacyVertexAttributes == rhs.legacyVertexAttributes ); +# endif + } + + bool operator!=( PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceLegacyVertexAttributesFeaturesEXT; + void * pNext = {}; + Bool32 legacyVertexAttributes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceLegacyVertexAttributesFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceLegacyVertexAttributesFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT.html + struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT + { + using NativeType = VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLegacyVertexAttributesPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceLegacyVertexAttributesPropertiesEXT( Bool32 nativeUnalignedPerformance_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , nativeUnalignedPerformance{ nativeUnalignedPerformance_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceLegacyVertexAttributesPropertiesEXT( PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLegacyVertexAttributesPropertiesEXT( VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLegacyVertexAttributesPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceLegacyVertexAttributesPropertiesEXT & + operator=( PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceLegacyVertexAttributesPropertiesEXT & operator=( VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, nativeUnalignedPerformance ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( nativeUnalignedPerformance == rhs.nativeUnalignedPerformance ); +# endif + } + + bool operator!=( PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceLegacyVertexAttributesPropertiesEXT; + void * pNext = {}; + Bool32 nativeUnalignedPerformance = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceLegacyVertexAttributesPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceLegacyVertexAttributesPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceLineRasterizationFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLineRasterizationFeatures.html + struct PhysicalDeviceLineRasterizationFeatures + { + using NativeType = VkPhysicalDeviceLineRasterizationFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLineRasterizationFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeatures( Bool32 rectangularLines_ = {}, + Bool32 bresenhamLines_ = {}, + Bool32 smoothLines_ = {}, + Bool32 stippledRectangularLines_ = {}, + Bool32 stippledBresenhamLines_ = {}, + Bool32 stippledSmoothLines_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rectangularLines{ rectangularLines_ } + , bresenhamLines{ bresenhamLines_ } + , smoothLines{ smoothLines_ } + , stippledRectangularLines{ stippledRectangularLines_ } + , stippledBresenhamLines{ stippledBresenhamLines_ } + , stippledSmoothLines{ stippledSmoothLines_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeatures( PhysicalDeviceLineRasterizationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLineRasterizationFeatures( VkPhysicalDeviceLineRasterizationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLineRasterizationFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceLineRasterizationFeatures & operator=( PhysicalDeviceLineRasterizationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceLineRasterizationFeatures & operator=( VkPhysicalDeviceLineRasterizationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setRectangularLines( Bool32 rectangularLines_ ) & VULKAN_HPP_NOEXCEPT + { + rectangularLines = rectangularLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setRectangularLines( Bool32 rectangularLines_ ) && VULKAN_HPP_NOEXCEPT + { + rectangularLines = rectangularLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setBresenhamLines( Bool32 bresenhamLines_ ) & VULKAN_HPP_NOEXCEPT + { + bresenhamLines = bresenhamLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setBresenhamLines( Bool32 bresenhamLines_ ) && VULKAN_HPP_NOEXCEPT + { + bresenhamLines = bresenhamLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setSmoothLines( Bool32 smoothLines_ ) & VULKAN_HPP_NOEXCEPT + { + smoothLines = smoothLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setSmoothLines( Bool32 smoothLines_ ) && VULKAN_HPP_NOEXCEPT + { + smoothLines = smoothLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setStippledRectangularLines( Bool32 stippledRectangularLines_ ) & VULKAN_HPP_NOEXCEPT + { + stippledRectangularLines = stippledRectangularLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setStippledRectangularLines( Bool32 stippledRectangularLines_ ) && VULKAN_HPP_NOEXCEPT + { + stippledRectangularLines = stippledRectangularLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setStippledBresenhamLines( Bool32 stippledBresenhamLines_ ) & VULKAN_HPP_NOEXCEPT + { + stippledBresenhamLines = stippledBresenhamLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setStippledBresenhamLines( Bool32 stippledBresenhamLines_ ) && VULKAN_HPP_NOEXCEPT + { + stippledBresenhamLines = stippledBresenhamLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setStippledSmoothLines( Bool32 stippledSmoothLines_ ) & VULKAN_HPP_NOEXCEPT + { + stippledSmoothLines = stippledSmoothLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setStippledSmoothLines( Bool32 stippledSmoothLines_ ) && VULKAN_HPP_NOEXCEPT + { + stippledSmoothLines = stippledSmoothLines_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceLineRasterizationFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLineRasterizationFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLineRasterizationFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLineRasterizationFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rectangularLines, bresenhamLines, smoothLines, stippledRectangularLines, stippledBresenhamLines, stippledSmoothLines ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLineRasterizationFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceLineRasterizationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rectangularLines == rhs.rectangularLines ) && ( bresenhamLines == rhs.bresenhamLines ) && + ( smoothLines == rhs.smoothLines ) && ( stippledRectangularLines == rhs.stippledRectangularLines ) && + ( stippledBresenhamLines == rhs.stippledBresenhamLines ) && ( stippledSmoothLines == rhs.stippledSmoothLines ); +# endif + } + + bool operator!=( PhysicalDeviceLineRasterizationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceLineRasterizationFeatures; + void * pNext = {}; + Bool32 rectangularLines = {}; + Bool32 bresenhamLines = {}; + Bool32 smoothLines = {}; + Bool32 stippledRectangularLines = {}; + Bool32 stippledBresenhamLines = {}; + Bool32 stippledSmoothLines = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceLineRasterizationFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceLineRasterizationFeatures; + }; + + using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeatures; + using PhysicalDeviceLineRasterizationFeaturesKHR = PhysicalDeviceLineRasterizationFeatures; + + // wrapper struct for struct VkPhysicalDeviceLineRasterizationProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLineRasterizationProperties.html + struct PhysicalDeviceLineRasterizationProperties + { + using NativeType = VkPhysicalDeviceLineRasterizationProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLineRasterizationProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationProperties( uint32_t lineSubPixelPrecisionBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , lineSubPixelPrecisionBits{ lineSubPixelPrecisionBits_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationProperties( PhysicalDeviceLineRasterizationProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLineRasterizationProperties( VkPhysicalDeviceLineRasterizationProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLineRasterizationProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceLineRasterizationProperties & operator=( PhysicalDeviceLineRasterizationProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceLineRasterizationProperties & operator=( VkPhysicalDeviceLineRasterizationProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceLineRasterizationProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLineRasterizationProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLineRasterizationProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLineRasterizationProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, lineSubPixelPrecisionBits ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLineRasterizationProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceLineRasterizationProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits ); +# endif + } + + bool operator!=( PhysicalDeviceLineRasterizationProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceLineRasterizationProperties; + void * pNext = {}; + uint32_t lineSubPixelPrecisionBits = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceLineRasterizationProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceLineRasterizationProperties; + }; + + using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationProperties; + using PhysicalDeviceLineRasterizationPropertiesKHR = PhysicalDeviceLineRasterizationProperties; + + // wrapper struct for struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLinearColorAttachmentFeaturesNV.html + struct PhysicalDeviceLinearColorAttachmentFeaturesNV + { + using NativeType = VkPhysicalDeviceLinearColorAttachmentFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceLinearColorAttachmentFeaturesNV( Bool32 linearColorAttachment_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , linearColorAttachment{ linearColorAttachment_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceLinearColorAttachmentFeaturesNV( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceLinearColorAttachmentFeaturesNV( VkPhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceLinearColorAttachmentFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceLinearColorAttachmentFeaturesNV & operator=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceLinearColorAttachmentFeaturesNV & operator=( VkPhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV & setLinearColorAttachment( Bool32 linearColorAttachment_ ) & VULKAN_HPP_NOEXCEPT + { + linearColorAttachment = linearColorAttachment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV && setLinearColorAttachment( Bool32 linearColorAttachment_ ) && VULKAN_HPP_NOEXCEPT + { + linearColorAttachment = linearColorAttachment_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, linearColorAttachment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceLinearColorAttachmentFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearColorAttachment == rhs.linearColorAttachment ); +# endif + } + + bool operator!=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV; + void * pNext = {}; + Bool32 linearColorAttachment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceLinearColorAttachmentFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceLinearColorAttachmentFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceMaintenance10FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance10FeaturesKHR.html + struct PhysicalDeviceMaintenance10FeaturesKHR + { + using NativeType = VkPhysicalDeviceMaintenance10FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance10FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance10FeaturesKHR( Bool32 maintenance10_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maintenance10{ maintenance10_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance10FeaturesKHR( PhysicalDeviceMaintenance10FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance10FeaturesKHR( VkPhysicalDeviceMaintenance10FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance10FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance10FeaturesKHR & operator=( PhysicalDeviceMaintenance10FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance10FeaturesKHR & operator=( VkPhysicalDeviceMaintenance10FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance10FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance10FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance10FeaturesKHR & setMaintenance10( Bool32 maintenance10_ ) & VULKAN_HPP_NOEXCEPT + { + maintenance10 = maintenance10_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance10FeaturesKHR && setMaintenance10( Bool32 maintenance10_ ) && VULKAN_HPP_NOEXCEPT + { + maintenance10 = maintenance10_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMaintenance10FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance10FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance10FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance10FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maintenance10 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance10FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance10FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance10 == rhs.maintenance10 ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance10FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance10FeaturesKHR; + void * pNext = {}; + Bool32 maintenance10 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance10FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance10FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceMaintenance10PropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance10PropertiesKHR.html + struct PhysicalDeviceMaintenance10PropertiesKHR + { + using NativeType = VkPhysicalDeviceMaintenance10PropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance10PropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance10PropertiesKHR( Bool32 rgba4OpaqueBlackSwizzled_ = {}, + Bool32 resolveSrgbFormatAppliesTransferFunction_ = {}, + Bool32 resolveSrgbFormatSupportsTransferFunctionControl_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rgba4OpaqueBlackSwizzled{ rgba4OpaqueBlackSwizzled_ } + , resolveSrgbFormatAppliesTransferFunction{ resolveSrgbFormatAppliesTransferFunction_ } + , resolveSrgbFormatSupportsTransferFunctionControl{ resolveSrgbFormatSupportsTransferFunctionControl_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance10PropertiesKHR( PhysicalDeviceMaintenance10PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance10PropertiesKHR( VkPhysicalDeviceMaintenance10PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance10PropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance10PropertiesKHR & operator=( PhysicalDeviceMaintenance10PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance10PropertiesKHR & operator=( VkPhysicalDeviceMaintenance10PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMaintenance10PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance10PropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance10PropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance10PropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rgba4OpaqueBlackSwizzled, resolveSrgbFormatAppliesTransferFunction, resolveSrgbFormatSupportsTransferFunctionControl ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance10PropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance10PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rgba4OpaqueBlackSwizzled == rhs.rgba4OpaqueBlackSwizzled ) && + ( resolveSrgbFormatAppliesTransferFunction == rhs.resolveSrgbFormatAppliesTransferFunction ) && + ( resolveSrgbFormatSupportsTransferFunctionControl == rhs.resolveSrgbFormatSupportsTransferFunctionControl ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance10PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance10PropertiesKHR; + void * pNext = {}; + Bool32 rgba4OpaqueBlackSwizzled = {}; + Bool32 resolveSrgbFormatAppliesTransferFunction = {}; + Bool32 resolveSrgbFormatSupportsTransferFunctionControl = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance10PropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance10PropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceMaintenance3Properties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance3Properties.html + struct PhysicalDeviceMaintenance3Properties + { + using NativeType = VkPhysicalDeviceMaintenance3Properties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance3Properties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance3Properties( uint32_t maxPerSetDescriptors_ = {}, + DeviceSize maxMemoryAllocationSize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxPerSetDescriptors{ maxPerSetDescriptors_ } + , maxMemoryAllocationSize{ maxMemoryAllocationSize_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance3Properties( PhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance3Properties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance3Properties & operator=( PhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance3Properties & operator=( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMaintenance3Properties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance3Properties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance3Properties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance3Properties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxPerSetDescriptors, maxMemoryAllocationSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance3Properties const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) && + ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties; + void * pNext = {}; + uint32_t maxPerSetDescriptors = {}; + DeviceSize maxMemoryAllocationSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance3Properties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance3Properties; + }; + + using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; + + // wrapper struct for struct VkPhysicalDeviceMaintenance4Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance4Features.html + struct PhysicalDeviceMaintenance4Features + { + using NativeType = VkPhysicalDeviceMaintenance4Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance4Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance4Features( Bool32 maintenance4_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maintenance4{ maintenance4_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance4Features( PhysicalDeviceMaintenance4Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance4Features( VkPhysicalDeviceMaintenance4Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance4Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance4Features & operator=( PhysicalDeviceMaintenance4Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance4Features & operator=( VkPhysicalDeviceMaintenance4Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance4Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance4Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance4Features & setMaintenance4( Bool32 maintenance4_ ) & VULKAN_HPP_NOEXCEPT + { + maintenance4 = maintenance4_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance4Features && setMaintenance4( Bool32 maintenance4_ ) && VULKAN_HPP_NOEXCEPT + { + maintenance4 = maintenance4_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMaintenance4Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance4Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance4Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance4Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maintenance4 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance4Features const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance4Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance4 == rhs.maintenance4 ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance4Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance4Features; + void * pNext = {}; + Bool32 maintenance4 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance4Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance4Features; + }; + + using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features; + + // wrapper struct for struct VkPhysicalDeviceMaintenance4Properties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance4Properties.html + struct PhysicalDeviceMaintenance4Properties + { + using NativeType = VkPhysicalDeviceMaintenance4Properties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance4Properties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance4Properties( DeviceSize maxBufferSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxBufferSize{ maxBufferSize_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance4Properties( PhysicalDeviceMaintenance4Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance4Properties( VkPhysicalDeviceMaintenance4Properties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance4Properties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance4Properties & operator=( PhysicalDeviceMaintenance4Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance4Properties & operator=( VkPhysicalDeviceMaintenance4Properties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMaintenance4Properties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance4Properties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance4Properties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance4Properties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxBufferSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance4Properties const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance4Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBufferSize == rhs.maxBufferSize ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance4Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance4Properties; + void * pNext = {}; + DeviceSize maxBufferSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance4Properties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance4Properties; + }; + + using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties; + + // wrapper struct for struct VkPhysicalDeviceMaintenance5Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance5Features.html + struct PhysicalDeviceMaintenance5Features + { + using NativeType = VkPhysicalDeviceMaintenance5Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance5Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance5Features( Bool32 maintenance5_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maintenance5{ maintenance5_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance5Features( PhysicalDeviceMaintenance5Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance5Features( VkPhysicalDeviceMaintenance5Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance5Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance5Features & operator=( PhysicalDeviceMaintenance5Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance5Features & operator=( VkPhysicalDeviceMaintenance5Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance5Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance5Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance5Features & setMaintenance5( Bool32 maintenance5_ ) & VULKAN_HPP_NOEXCEPT + { + maintenance5 = maintenance5_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance5Features && setMaintenance5( Bool32 maintenance5_ ) && VULKAN_HPP_NOEXCEPT + { + maintenance5 = maintenance5_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMaintenance5Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance5Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance5Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance5Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maintenance5 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance5Features const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance5Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance5 == rhs.maintenance5 ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance5Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance5Features; + void * pNext = {}; + Bool32 maintenance5 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance5Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance5Features; + }; + + using PhysicalDeviceMaintenance5FeaturesKHR = PhysicalDeviceMaintenance5Features; + + // wrapper struct for struct VkPhysicalDeviceMaintenance5Properties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance5Properties.html + struct PhysicalDeviceMaintenance5Properties + { + using NativeType = VkPhysicalDeviceMaintenance5Properties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance5Properties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance5Properties( Bool32 earlyFragmentMultisampleCoverageAfterSampleCounting_ = {}, + Bool32 earlyFragmentSampleMaskTestBeforeSampleCounting_ = {}, + Bool32 depthStencilSwizzleOneSupport_ = {}, + Bool32 polygonModePointSize_ = {}, + Bool32 nonStrictSinglePixelWideLinesUseParallelogram_ = {}, + Bool32 nonStrictWideLinesUseParallelogram_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , earlyFragmentMultisampleCoverageAfterSampleCounting{ earlyFragmentMultisampleCoverageAfterSampleCounting_ } + , earlyFragmentSampleMaskTestBeforeSampleCounting{ earlyFragmentSampleMaskTestBeforeSampleCounting_ } + , depthStencilSwizzleOneSupport{ depthStencilSwizzleOneSupport_ } + , polygonModePointSize{ polygonModePointSize_ } + , nonStrictSinglePixelWideLinesUseParallelogram{ nonStrictSinglePixelWideLinesUseParallelogram_ } + , nonStrictWideLinesUseParallelogram{ nonStrictWideLinesUseParallelogram_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance5Properties( PhysicalDeviceMaintenance5Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance5Properties( VkPhysicalDeviceMaintenance5Properties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance5Properties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance5Properties & operator=( PhysicalDeviceMaintenance5Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance5Properties & operator=( VkPhysicalDeviceMaintenance5Properties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMaintenance5Properties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance5Properties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance5Properties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance5Properties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + earlyFragmentMultisampleCoverageAfterSampleCounting, + earlyFragmentSampleMaskTestBeforeSampleCounting, + depthStencilSwizzleOneSupport, + polygonModePointSize, + nonStrictSinglePixelWideLinesUseParallelogram, + nonStrictWideLinesUseParallelogram ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance5Properties const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance5Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( earlyFragmentMultisampleCoverageAfterSampleCounting == rhs.earlyFragmentMultisampleCoverageAfterSampleCounting ) && + ( earlyFragmentSampleMaskTestBeforeSampleCounting == rhs.earlyFragmentSampleMaskTestBeforeSampleCounting ) && + ( depthStencilSwizzleOneSupport == rhs.depthStencilSwizzleOneSupport ) && ( polygonModePointSize == rhs.polygonModePointSize ) && + ( nonStrictSinglePixelWideLinesUseParallelogram == rhs.nonStrictSinglePixelWideLinesUseParallelogram ) && + ( nonStrictWideLinesUseParallelogram == rhs.nonStrictWideLinesUseParallelogram ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance5Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance5Properties; + void * pNext = {}; + Bool32 earlyFragmentMultisampleCoverageAfterSampleCounting = {}; + Bool32 earlyFragmentSampleMaskTestBeforeSampleCounting = {}; + Bool32 depthStencilSwizzleOneSupport = {}; + Bool32 polygonModePointSize = {}; + Bool32 nonStrictSinglePixelWideLinesUseParallelogram = {}; + Bool32 nonStrictWideLinesUseParallelogram = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance5Properties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance5Properties; + }; + + using PhysicalDeviceMaintenance5PropertiesKHR = PhysicalDeviceMaintenance5Properties; + + // wrapper struct for struct VkPhysicalDeviceMaintenance6Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance6Features.html + struct PhysicalDeviceMaintenance6Features + { + using NativeType = VkPhysicalDeviceMaintenance6Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance6Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance6Features( Bool32 maintenance6_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maintenance6{ maintenance6_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance6Features( PhysicalDeviceMaintenance6Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance6Features( VkPhysicalDeviceMaintenance6Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance6Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance6Features & operator=( PhysicalDeviceMaintenance6Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance6Features & operator=( VkPhysicalDeviceMaintenance6Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance6Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance6Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance6Features & setMaintenance6( Bool32 maintenance6_ ) & VULKAN_HPP_NOEXCEPT + { + maintenance6 = maintenance6_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance6Features && setMaintenance6( Bool32 maintenance6_ ) && VULKAN_HPP_NOEXCEPT + { + maintenance6 = maintenance6_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMaintenance6Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance6Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance6Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance6Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maintenance6 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance6Features const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance6Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance6 == rhs.maintenance6 ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance6Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance6Features; + void * pNext = {}; + Bool32 maintenance6 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance6Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance6Features; + }; + + using PhysicalDeviceMaintenance6FeaturesKHR = PhysicalDeviceMaintenance6Features; + + // wrapper struct for struct VkPhysicalDeviceMaintenance6Properties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance6Properties.html + struct PhysicalDeviceMaintenance6Properties + { + using NativeType = VkPhysicalDeviceMaintenance6Properties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance6Properties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance6Properties( Bool32 blockTexelViewCompatibleMultipleLayers_ = {}, + uint32_t maxCombinedImageSamplerDescriptorCount_ = {}, + Bool32 fragmentShadingRateClampCombinerInputs_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , blockTexelViewCompatibleMultipleLayers{ blockTexelViewCompatibleMultipleLayers_ } + , maxCombinedImageSamplerDescriptorCount{ maxCombinedImageSamplerDescriptorCount_ } + , fragmentShadingRateClampCombinerInputs{ fragmentShadingRateClampCombinerInputs_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance6Properties( PhysicalDeviceMaintenance6Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance6Properties( VkPhysicalDeviceMaintenance6Properties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance6Properties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance6Properties & operator=( PhysicalDeviceMaintenance6Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance6Properties & operator=( VkPhysicalDeviceMaintenance6Properties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMaintenance6Properties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance6Properties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance6Properties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance6Properties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, blockTexelViewCompatibleMultipleLayers, maxCombinedImageSamplerDescriptorCount, fragmentShadingRateClampCombinerInputs ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance6Properties const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance6Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( blockTexelViewCompatibleMultipleLayers == rhs.blockTexelViewCompatibleMultipleLayers ) && + ( maxCombinedImageSamplerDescriptorCount == rhs.maxCombinedImageSamplerDescriptorCount ) && + ( fragmentShadingRateClampCombinerInputs == rhs.fragmentShadingRateClampCombinerInputs ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance6Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance6Properties; + void * pNext = {}; + Bool32 blockTexelViewCompatibleMultipleLayers = {}; + uint32_t maxCombinedImageSamplerDescriptorCount = {}; + Bool32 fragmentShadingRateClampCombinerInputs = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance6Properties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance6Properties; + }; + + using PhysicalDeviceMaintenance6PropertiesKHR = PhysicalDeviceMaintenance6Properties; + + // wrapper struct for struct VkPhysicalDeviceMaintenance7FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance7FeaturesKHR.html + struct PhysicalDeviceMaintenance7FeaturesKHR + { + using NativeType = VkPhysicalDeviceMaintenance7FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance7FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance7FeaturesKHR( Bool32 maintenance7_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maintenance7{ maintenance7_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance7FeaturesKHR( PhysicalDeviceMaintenance7FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance7FeaturesKHR( VkPhysicalDeviceMaintenance7FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance7FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance7FeaturesKHR & operator=( PhysicalDeviceMaintenance7FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance7FeaturesKHR & operator=( VkPhysicalDeviceMaintenance7FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance7FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance7FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance7FeaturesKHR & setMaintenance7( Bool32 maintenance7_ ) & VULKAN_HPP_NOEXCEPT + { + maintenance7 = maintenance7_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance7FeaturesKHR && setMaintenance7( Bool32 maintenance7_ ) && VULKAN_HPP_NOEXCEPT + { + maintenance7 = maintenance7_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMaintenance7FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance7FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance7FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance7FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maintenance7 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance7FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance7FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance7 == rhs.maintenance7 ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance7FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance7FeaturesKHR; + void * pNext = {}; + Bool32 maintenance7 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance7FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance7FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceMaintenance7PropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance7PropertiesKHR.html + struct PhysicalDeviceMaintenance7PropertiesKHR + { + using NativeType = VkPhysicalDeviceMaintenance7PropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance7PropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance7PropertiesKHR( Bool32 robustFragmentShadingRateAttachmentAccess_ = {}, + Bool32 separateDepthStencilAttachmentAccess_ = {}, + uint32_t maxDescriptorSetTotalUniformBuffersDynamic_ = {}, + uint32_t maxDescriptorSetTotalStorageBuffersDynamic_ = {}, + uint32_t maxDescriptorSetTotalBuffersDynamic_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindTotalBuffersDynamic_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , robustFragmentShadingRateAttachmentAccess{ robustFragmentShadingRateAttachmentAccess_ } + , separateDepthStencilAttachmentAccess{ separateDepthStencilAttachmentAccess_ } + , maxDescriptorSetTotalUniformBuffersDynamic{ maxDescriptorSetTotalUniformBuffersDynamic_ } + , maxDescriptorSetTotalStorageBuffersDynamic{ maxDescriptorSetTotalStorageBuffersDynamic_ } + , maxDescriptorSetTotalBuffersDynamic{ maxDescriptorSetTotalBuffersDynamic_ } + , maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic{ maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic_ } + , maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic{ maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic_ } + , maxDescriptorSetUpdateAfterBindTotalBuffersDynamic{ maxDescriptorSetUpdateAfterBindTotalBuffersDynamic_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance7PropertiesKHR( PhysicalDeviceMaintenance7PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance7PropertiesKHR( VkPhysicalDeviceMaintenance7PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance7PropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance7PropertiesKHR & operator=( PhysicalDeviceMaintenance7PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance7PropertiesKHR & operator=( VkPhysicalDeviceMaintenance7PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMaintenance7PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance7PropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance7PropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance7PropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + robustFragmentShadingRateAttachmentAccess, + separateDepthStencilAttachmentAccess, + maxDescriptorSetTotalUniformBuffersDynamic, + maxDescriptorSetTotalStorageBuffersDynamic, + maxDescriptorSetTotalBuffersDynamic, + maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic, + maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic, + maxDescriptorSetUpdateAfterBindTotalBuffersDynamic ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance7PropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance7PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( robustFragmentShadingRateAttachmentAccess == rhs.robustFragmentShadingRateAttachmentAccess ) && + ( separateDepthStencilAttachmentAccess == rhs.separateDepthStencilAttachmentAccess ) && + ( maxDescriptorSetTotalUniformBuffersDynamic == rhs.maxDescriptorSetTotalUniformBuffersDynamic ) && + ( maxDescriptorSetTotalStorageBuffersDynamic == rhs.maxDescriptorSetTotalStorageBuffersDynamic ) && + ( maxDescriptorSetTotalBuffersDynamic == rhs.maxDescriptorSetTotalBuffersDynamic ) && + ( maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic ) && + ( maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic ) && + ( maxDescriptorSetUpdateAfterBindTotalBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance7PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance7PropertiesKHR; + void * pNext = {}; + Bool32 robustFragmentShadingRateAttachmentAccess = {}; + Bool32 separateDepthStencilAttachmentAccess = {}; + uint32_t maxDescriptorSetTotalUniformBuffersDynamic = {}; + uint32_t maxDescriptorSetTotalStorageBuffersDynamic = {}; + uint32_t maxDescriptorSetTotalBuffersDynamic = {}; + uint32_t maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic = {}; + uint32_t maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic = {}; + uint32_t maxDescriptorSetUpdateAfterBindTotalBuffersDynamic = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance7PropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance7PropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceMaintenance8FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance8FeaturesKHR.html + struct PhysicalDeviceMaintenance8FeaturesKHR + { + using NativeType = VkPhysicalDeviceMaintenance8FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance8FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance8FeaturesKHR( Bool32 maintenance8_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maintenance8{ maintenance8_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance8FeaturesKHR( PhysicalDeviceMaintenance8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance8FeaturesKHR( VkPhysicalDeviceMaintenance8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance8FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance8FeaturesKHR & operator=( PhysicalDeviceMaintenance8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance8FeaturesKHR & operator=( VkPhysicalDeviceMaintenance8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance8FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance8FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance8FeaturesKHR & setMaintenance8( Bool32 maintenance8_ ) & VULKAN_HPP_NOEXCEPT + { + maintenance8 = maintenance8_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance8FeaturesKHR && setMaintenance8( Bool32 maintenance8_ ) && VULKAN_HPP_NOEXCEPT + { + maintenance8 = maintenance8_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMaintenance8FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance8FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance8FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance8FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maintenance8 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance8FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance8FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance8 == rhs.maintenance8 ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance8FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance8FeaturesKHR; + void * pNext = {}; + Bool32 maintenance8 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance8FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance8FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceMaintenance9FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance9FeaturesKHR.html + struct PhysicalDeviceMaintenance9FeaturesKHR + { + using NativeType = VkPhysicalDeviceMaintenance9FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance9FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance9FeaturesKHR( Bool32 maintenance9_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maintenance9{ maintenance9_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance9FeaturesKHR( PhysicalDeviceMaintenance9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance9FeaturesKHR( VkPhysicalDeviceMaintenance9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance9FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance9FeaturesKHR & operator=( PhysicalDeviceMaintenance9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance9FeaturesKHR & operator=( VkPhysicalDeviceMaintenance9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance9FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance9FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance9FeaturesKHR & setMaintenance9( Bool32 maintenance9_ ) & VULKAN_HPP_NOEXCEPT + { + maintenance9 = maintenance9_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance9FeaturesKHR && setMaintenance9( Bool32 maintenance9_ ) && VULKAN_HPP_NOEXCEPT + { + maintenance9 = maintenance9_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMaintenance9FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance9FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance9FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance9FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maintenance9 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance9FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance9FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance9 == rhs.maintenance9 ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance9FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance9FeaturesKHR; + void * pNext = {}; + Bool32 maintenance9 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance9FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance9FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceMaintenance9PropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance9PropertiesKHR.html + struct PhysicalDeviceMaintenance9PropertiesKHR + { + using NativeType = VkPhysicalDeviceMaintenance9PropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance9PropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceMaintenance9PropertiesKHR( Bool32 image2DViewOf3DSparse_ = {}, + DefaultVertexAttributeValueKHR defaultVertexAttributeValue_ = DefaultVertexAttributeValueKHR::eZeroZeroZeroZero, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , image2DViewOf3DSparse{ image2DViewOf3DSparse_ } + , defaultVertexAttributeValue{ defaultVertexAttributeValue_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance9PropertiesKHR( PhysicalDeviceMaintenance9PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMaintenance9PropertiesKHR( VkPhysicalDeviceMaintenance9PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMaintenance9PropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMaintenance9PropertiesKHR & operator=( PhysicalDeviceMaintenance9PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMaintenance9PropertiesKHR & operator=( VkPhysicalDeviceMaintenance9PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMaintenance9PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance9PropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance9PropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMaintenance9PropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, image2DViewOf3DSparse, defaultVertexAttributeValue ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMaintenance9PropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceMaintenance9PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image2DViewOf3DSparse == rhs.image2DViewOf3DSparse ) && + ( defaultVertexAttributeValue == rhs.defaultVertexAttributeValue ); +# endif + } + + bool operator!=( PhysicalDeviceMaintenance9PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMaintenance9PropertiesKHR; + void * pNext = {}; + Bool32 image2DViewOf3DSparse = {}; + DefaultVertexAttributeValueKHR defaultVertexAttributeValue = DefaultVertexAttributeValueKHR::eZeroZeroZeroZero; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance9PropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMaintenance9PropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.html + struct PhysicalDeviceMapMemoryPlacedFeaturesEXT + { + using NativeType = VkPhysicalDeviceMapMemoryPlacedFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMapMemoryPlacedFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedFeaturesEXT( Bool32 memoryMapPlaced_ = {}, + Bool32 memoryMapRangePlaced_ = {}, + Bool32 memoryUnmapReserve_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryMapPlaced{ memoryMapPlaced_ } + , memoryMapRangePlaced{ memoryMapRangePlaced_ } + , memoryUnmapReserve{ memoryUnmapReserve_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedFeaturesEXT( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMapMemoryPlacedFeaturesEXT( VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMapMemoryPlacedFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMapMemoryPlacedFeaturesEXT & operator=( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMapMemoryPlacedFeaturesEXT & operator=( VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & setMemoryMapPlaced( Bool32 memoryMapPlaced_ ) & VULKAN_HPP_NOEXCEPT + { + memoryMapPlaced = memoryMapPlaced_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT && setMemoryMapPlaced( Bool32 memoryMapPlaced_ ) && VULKAN_HPP_NOEXCEPT + { + memoryMapPlaced = memoryMapPlaced_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & setMemoryMapRangePlaced( Bool32 memoryMapRangePlaced_ ) & VULKAN_HPP_NOEXCEPT + { + memoryMapRangePlaced = memoryMapRangePlaced_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT && setMemoryMapRangePlaced( Bool32 memoryMapRangePlaced_ ) && VULKAN_HPP_NOEXCEPT + { + memoryMapRangePlaced = memoryMapRangePlaced_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & setMemoryUnmapReserve( Bool32 memoryUnmapReserve_ ) & VULKAN_HPP_NOEXCEPT + { + memoryUnmapReserve = memoryUnmapReserve_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT && setMemoryUnmapReserve( Bool32 memoryUnmapReserve_ ) && VULKAN_HPP_NOEXCEPT + { + memoryUnmapReserve = memoryUnmapReserve_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMapMemoryPlacedFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryMapPlaced, memoryMapRangePlaced, memoryUnmapReserve ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryMapPlaced == rhs.memoryMapPlaced ) && + ( memoryMapRangePlaced == rhs.memoryMapRangePlaced ) && ( memoryUnmapReserve == rhs.memoryUnmapReserve ); +# endif + } + + bool operator!=( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMapMemoryPlacedFeaturesEXT; + void * pNext = {}; + Bool32 memoryMapPlaced = {}; + Bool32 memoryMapRangePlaced = {}; + Bool32 memoryUnmapReserve = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMapMemoryPlacedFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMapMemoryPlacedFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMapMemoryPlacedPropertiesEXT.html + struct PhysicalDeviceMapMemoryPlacedPropertiesEXT + { + using NativeType = VkPhysicalDeviceMapMemoryPlacedPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMapMemoryPlacedPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedPropertiesEXT( DeviceSize minPlacedMemoryMapAlignment_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minPlacedMemoryMapAlignment{ minPlacedMemoryMapAlignment_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedPropertiesEXT( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMapMemoryPlacedPropertiesEXT( VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMapMemoryPlacedPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMapMemoryPlacedPropertiesEXT & operator=( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMapMemoryPlacedPropertiesEXT & operator=( VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMapMemoryPlacedPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minPlacedMemoryMapAlignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minPlacedMemoryMapAlignment == rhs.minPlacedMemoryMapAlignment ); +# endif + } + + bool operator!=( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMapMemoryPlacedPropertiesEXT; + void * pNext = {}; + DeviceSize minPlacedMemoryMapAlignment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMapMemoryPlacedPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMapMemoryPlacedPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceMemoryBudgetPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryBudgetPropertiesEXT.html + struct PhysicalDeviceMemoryBudgetPropertiesEXT + { + using NativeType = VkPhysicalDeviceMemoryBudgetPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryBudgetPropertiesEXT( std::array const & heapBudget_ = {}, + std::array const & heapUsage_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , heapBudget{ heapBudget_ } + , heapUsage{ heapUsage_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryBudgetPropertiesEXT( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMemoryBudgetPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMemoryBudgetPropertiesEXT & operator=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMemoryBudgetPropertiesEXT & operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryBudgetPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryBudgetPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, heapBudget, heapUsage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMemoryBudgetPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapBudget == rhs.heapBudget ) && ( heapUsage == rhs.heapUsage ); +# endif + } + + bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; + void * pNext = {}; + ArrayWrapper1D heapBudget = {}; + ArrayWrapper1D heapUsage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryBudgetPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryBudgetPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceMemoryDecompressionFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryDecompressionFeaturesEXT.html + struct PhysicalDeviceMemoryDecompressionFeaturesEXT + { + using NativeType = VkPhysicalDeviceMemoryDecompressionFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryDecompressionFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryDecompressionFeaturesEXT( Bool32 memoryDecompression_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryDecompression{ memoryDecompression_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryDecompressionFeaturesEXT( PhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMemoryDecompressionFeaturesEXT( VkPhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMemoryDecompressionFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMemoryDecompressionFeaturesEXT & operator=( PhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMemoryDecompressionFeaturesEXT & operator=( VkPhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryDecompressionFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryDecompressionFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryDecompressionFeaturesEXT & setMemoryDecompression( Bool32 memoryDecompression_ ) & VULKAN_HPP_NOEXCEPT + { + memoryDecompression = memoryDecompression_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryDecompressionFeaturesEXT && setMemoryDecompression( Bool32 memoryDecompression_ ) && VULKAN_HPP_NOEXCEPT + { + memoryDecompression = memoryDecompression_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMemoryDecompressionFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryDecompressionFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryDecompressionFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryDecompressionFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryDecompression ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMemoryDecompressionFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryDecompression == rhs.memoryDecompression ); +# endif + } + + bool operator!=( PhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMemoryDecompressionFeaturesEXT; + void * pNext = {}; + Bool32 memoryDecompression = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryDecompressionFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryDecompressionFeaturesEXT; + }; + + using PhysicalDeviceMemoryDecompressionFeaturesNV = PhysicalDeviceMemoryDecompressionFeaturesEXT; + + // wrapper struct for struct VkPhysicalDeviceMemoryDecompressionPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryDecompressionPropertiesEXT.html + struct PhysicalDeviceMemoryDecompressionPropertiesEXT + { + using NativeType = VkPhysicalDeviceMemoryDecompressionPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryDecompressionPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryDecompressionPropertiesEXT( MemoryDecompressionMethodFlagsEXT decompressionMethods_ = {}, + uint64_t maxDecompressionIndirectCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , decompressionMethods{ decompressionMethods_ } + , maxDecompressionIndirectCount{ maxDecompressionIndirectCount_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceMemoryDecompressionPropertiesEXT( PhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMemoryDecompressionPropertiesEXT( VkPhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMemoryDecompressionPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMemoryDecompressionPropertiesEXT & operator=( PhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMemoryDecompressionPropertiesEXT & operator=( VkPhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMemoryDecompressionPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryDecompressionPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryDecompressionPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryDecompressionPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, decompressionMethods, maxDecompressionIndirectCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMemoryDecompressionPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decompressionMethods == rhs.decompressionMethods ) && + ( maxDecompressionIndirectCount == rhs.maxDecompressionIndirectCount ); +# endif + } + + bool operator!=( PhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMemoryDecompressionPropertiesEXT; + void * pNext = {}; + MemoryDecompressionMethodFlagsEXT decompressionMethods = {}; + uint64_t maxDecompressionIndirectCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryDecompressionPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryDecompressionPropertiesEXT; + }; + + using PhysicalDeviceMemoryDecompressionPropertiesNV = PhysicalDeviceMemoryDecompressionPropertiesEXT; + + // wrapper struct for struct VkPhysicalDeviceMemoryPriorityFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html + struct PhysicalDeviceMemoryPriorityFeaturesEXT + { + using NativeType = VkPhysicalDeviceMemoryPriorityFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( Bool32 memoryPriority_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryPriority{ memoryPriority_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMemoryPriorityFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMemoryPriorityFeaturesEXT & operator=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMemoryPriorityFeaturesEXT & operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryPriorityFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryPriorityFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryPriorityFeaturesEXT & setMemoryPriority( Bool32 memoryPriority_ ) & VULKAN_HPP_NOEXCEPT + { + memoryPriority = memoryPriority_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryPriorityFeaturesEXT && setMemoryPriority( Bool32 memoryPriority_ ) && VULKAN_HPP_NOEXCEPT + { + memoryPriority = memoryPriority_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryPriorityFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryPriorityFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryPriority ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMemoryPriorityFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryPriority == rhs.memoryPriority ); +# endif + } + + bool operator!=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; + void * pNext = {}; + Bool32 memoryPriority = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryPriorityFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryPriorityFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceMemoryProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryProperties.html + struct PhysicalDeviceMemoryProperties + { + using NativeType = VkPhysicalDeviceMemoryProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties( uint32_t memoryTypeCount_ = {}, + std::array const & memoryTypes_ = {}, + uint32_t memoryHeapCount_ = {}, + std::array const & memoryHeaps_ = {} ) VULKAN_HPP_NOEXCEPT + : memoryTypeCount{ memoryTypeCount_ } + , memoryTypes{ memoryTypes_ } + , memoryHeapCount{ memoryHeapCount_ } + , memoryHeaps{ memoryHeaps_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties( PhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMemoryProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMemoryProperties & operator=( PhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMemoryProperties & operator=( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMemoryProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + uint32_t const &, + ArrayWrapper1D const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( memoryTypeCount, memoryTypes, memoryHeapCount, memoryHeaps ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = memoryTypeCount <=> rhs.memoryTypeCount; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < memoryTypeCount; ++i ) + { + if ( auto cmp = memoryTypes[i] <=> rhs.memoryTypes[i]; cmp != 0 ) + return cmp; + } + if ( auto cmp = memoryHeapCount <=> rhs.memoryHeapCount; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < memoryHeapCount; ++i ) + { + if ( auto cmp = memoryHeaps[i] <=> rhs.memoryHeaps[i]; cmp != 0 ) + return cmp; + } + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( memoryTypeCount == rhs.memoryTypeCount ) && ( memcmp( memoryTypes, rhs.memoryTypes, memoryTypeCount * sizeof( MemoryType ) ) == 0 ) && + ( memoryHeapCount == rhs.memoryHeapCount ) && ( memcmp( memoryHeaps, rhs.memoryHeaps, memoryHeapCount * sizeof( MemoryHeap ) ) == 0 ); + } + + bool operator!=( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t memoryTypeCount = {}; + ArrayWrapper1D memoryTypes = {}; + uint32_t memoryHeapCount = {}; + ArrayWrapper1D memoryHeaps = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryProperties; + }; +#endif + + // wrapper struct for struct VkPhysicalDeviceMemoryProperties2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryProperties2.html + struct PhysicalDeviceMemoryProperties2 + { + using NativeType = VkPhysicalDeviceMemoryProperties2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryProperties2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties2( PhysicalDeviceMemoryProperties memoryProperties_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryProperties{ memoryProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties2( PhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMemoryProperties2( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMemoryProperties2 & operator=( PhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMemoryProperties2 & operator=( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMemoryProperties2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryProperties2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryProperties2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMemoryProperties2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMemoryProperties2 const & ) const = default; +#else + bool operator==( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryProperties == rhs.memoryProperties ); +# endif + } + + bool operator!=( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2; + void * pNext = {}; + PhysicalDeviceMemoryProperties memoryProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryProperties2; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMemoryProperties2; + }; + + using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; + + // wrapper struct for struct VkPhysicalDeviceMeshShaderFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderFeaturesEXT.html + struct PhysicalDeviceMeshShaderFeaturesEXT + { + using NativeType = VkPhysicalDeviceMeshShaderFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesEXT( Bool32 taskShader_ = {}, + Bool32 meshShader_ = {}, + Bool32 multiviewMeshShader_ = {}, + Bool32 primitiveFragmentShadingRateMeshShader_ = {}, + Bool32 meshShaderQueries_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , taskShader{ taskShader_ } + , meshShader{ meshShader_ } + , multiviewMeshShader{ multiviewMeshShader_ } + , primitiveFragmentShadingRateMeshShader{ primitiveFragmentShadingRateMeshShader_ } + , meshShaderQueries{ meshShaderQueries_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesEXT( PhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMeshShaderFeaturesEXT( VkPhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMeshShaderFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMeshShaderFeaturesEXT & operator=( PhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMeshShaderFeaturesEXT & operator=( VkPhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setTaskShader( Bool32 taskShader_ ) & VULKAN_HPP_NOEXCEPT + { + taskShader = taskShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && setTaskShader( Bool32 taskShader_ ) && VULKAN_HPP_NOEXCEPT + { + taskShader = taskShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setMeshShader( Bool32 meshShader_ ) & VULKAN_HPP_NOEXCEPT + { + meshShader = meshShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && setMeshShader( Bool32 meshShader_ ) && VULKAN_HPP_NOEXCEPT + { + meshShader = meshShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setMultiviewMeshShader( Bool32 multiviewMeshShader_ ) & VULKAN_HPP_NOEXCEPT + { + multiviewMeshShader = multiviewMeshShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && setMultiviewMeshShader( Bool32 multiviewMeshShader_ ) && VULKAN_HPP_NOEXCEPT + { + multiviewMeshShader = multiviewMeshShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setPrimitiveFragmentShadingRateMeshShader( Bool32 primitiveFragmentShadingRateMeshShader_ ) & + VULKAN_HPP_NOEXCEPT + { + primitiveFragmentShadingRateMeshShader = primitiveFragmentShadingRateMeshShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && + setPrimitiveFragmentShadingRateMeshShader( Bool32 primitiveFragmentShadingRateMeshShader_ ) && + VULKAN_HPP_NOEXCEPT + { + primitiveFragmentShadingRateMeshShader = primitiveFragmentShadingRateMeshShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setMeshShaderQueries( Bool32 meshShaderQueries_ ) & VULKAN_HPP_NOEXCEPT + { + meshShaderQueries = meshShaderQueries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && setMeshShaderQueries( Bool32 meshShaderQueries_ ) && VULKAN_HPP_NOEXCEPT + { + meshShaderQueries = meshShaderQueries_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMeshShaderFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, taskShader, meshShader, multiviewMeshShader, primitiveFragmentShadingRateMeshShader, meshShaderQueries ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMeshShaderFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMeshShaderFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) && ( meshShader == rhs.meshShader ) && + ( multiviewMeshShader == rhs.multiviewMeshShader ) && ( primitiveFragmentShadingRateMeshShader == rhs.primitiveFragmentShadingRateMeshShader ) && + ( meshShaderQueries == rhs.meshShaderQueries ); +# endif + } + + bool operator!=( PhysicalDeviceMeshShaderFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesEXT; + void * pNext = {}; + Bool32 taskShader = {}; + Bool32 meshShader = {}; + Bool32 multiviewMeshShader = {}; + Bool32 primitiveFragmentShadingRateMeshShader = {}; + Bool32 meshShaderQueries = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMeshShaderFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMeshShaderFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceMeshShaderFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html + struct PhysicalDeviceMeshShaderFeaturesNV + { + using NativeType = VkPhysicalDeviceMeshShaderFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( Bool32 taskShader_ = {}, Bool32 meshShader_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , taskShader{ taskShader_ } + , meshShader{ meshShader_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMeshShaderFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMeshShaderFeaturesNV & operator=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMeshShaderFeaturesNV & operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV & setTaskShader( Bool32 taskShader_ ) & VULKAN_HPP_NOEXCEPT + { + taskShader = taskShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV && setTaskShader( Bool32 taskShader_ ) && VULKAN_HPP_NOEXCEPT + { + taskShader = taskShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV & setMeshShader( Bool32 meshShader_ ) & VULKAN_HPP_NOEXCEPT + { + meshShader = meshShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV && setMeshShader( Bool32 meshShader_ ) && VULKAN_HPP_NOEXCEPT + { + meshShader = meshShader_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMeshShaderFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, taskShader, meshShader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMeshShaderFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) && ( meshShader == rhs.meshShader ); +# endif + } + + bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV; + void * pNext = {}; + Bool32 taskShader = {}; + Bool32 meshShader = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMeshShaderFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMeshShaderFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceMeshShaderPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderPropertiesEXT.html + struct PhysicalDeviceMeshShaderPropertiesEXT + { + using NativeType = VkPhysicalDeviceMeshShaderPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesEXT( uint32_t maxTaskWorkGroupTotalCount_ = {}, + std::array const & maxTaskWorkGroupCount_ = {}, + uint32_t maxTaskWorkGroupInvocations_ = {}, + std::array const & maxTaskWorkGroupSize_ = {}, + uint32_t maxTaskPayloadSize_ = {}, + uint32_t maxTaskSharedMemorySize_ = {}, + uint32_t maxTaskPayloadAndSharedMemorySize_ = {}, + uint32_t maxMeshWorkGroupTotalCount_ = {}, + std::array const & maxMeshWorkGroupCount_ = {}, + uint32_t maxMeshWorkGroupInvocations_ = {}, + std::array const & maxMeshWorkGroupSize_ = {}, + uint32_t maxMeshSharedMemorySize_ = {}, + uint32_t maxMeshPayloadAndSharedMemorySize_ = {}, + uint32_t maxMeshOutputMemorySize_ = {}, + uint32_t maxMeshPayloadAndOutputMemorySize_ = {}, + uint32_t maxMeshOutputComponents_ = {}, + uint32_t maxMeshOutputVertices_ = {}, + uint32_t maxMeshOutputPrimitives_ = {}, + uint32_t maxMeshOutputLayers_ = {}, + uint32_t maxMeshMultiviewViewCount_ = {}, + uint32_t meshOutputPerVertexGranularity_ = {}, + uint32_t meshOutputPerPrimitiveGranularity_ = {}, + uint32_t maxPreferredTaskWorkGroupInvocations_ = {}, + uint32_t maxPreferredMeshWorkGroupInvocations_ = {}, + Bool32 prefersLocalInvocationVertexOutput_ = {}, + Bool32 prefersLocalInvocationPrimitiveOutput_ = {}, + Bool32 prefersCompactVertexOutput_ = {}, + Bool32 prefersCompactPrimitiveOutput_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxTaskWorkGroupTotalCount{ maxTaskWorkGroupTotalCount_ } + , maxTaskWorkGroupCount{ maxTaskWorkGroupCount_ } + , maxTaskWorkGroupInvocations{ maxTaskWorkGroupInvocations_ } + , maxTaskWorkGroupSize{ maxTaskWorkGroupSize_ } + , maxTaskPayloadSize{ maxTaskPayloadSize_ } + , maxTaskSharedMemorySize{ maxTaskSharedMemorySize_ } + , maxTaskPayloadAndSharedMemorySize{ maxTaskPayloadAndSharedMemorySize_ } + , maxMeshWorkGroupTotalCount{ maxMeshWorkGroupTotalCount_ } + , maxMeshWorkGroupCount{ maxMeshWorkGroupCount_ } + , maxMeshWorkGroupInvocations{ maxMeshWorkGroupInvocations_ } + , maxMeshWorkGroupSize{ maxMeshWorkGroupSize_ } + , maxMeshSharedMemorySize{ maxMeshSharedMemorySize_ } + , maxMeshPayloadAndSharedMemorySize{ maxMeshPayloadAndSharedMemorySize_ } + , maxMeshOutputMemorySize{ maxMeshOutputMemorySize_ } + , maxMeshPayloadAndOutputMemorySize{ maxMeshPayloadAndOutputMemorySize_ } + , maxMeshOutputComponents{ maxMeshOutputComponents_ } + , maxMeshOutputVertices{ maxMeshOutputVertices_ } + , maxMeshOutputPrimitives{ maxMeshOutputPrimitives_ } + , maxMeshOutputLayers{ maxMeshOutputLayers_ } + , maxMeshMultiviewViewCount{ maxMeshMultiviewViewCount_ } + , meshOutputPerVertexGranularity{ meshOutputPerVertexGranularity_ } + , meshOutputPerPrimitiveGranularity{ meshOutputPerPrimitiveGranularity_ } + , maxPreferredTaskWorkGroupInvocations{ maxPreferredTaskWorkGroupInvocations_ } + , maxPreferredMeshWorkGroupInvocations{ maxPreferredMeshWorkGroupInvocations_ } + , prefersLocalInvocationVertexOutput{ prefersLocalInvocationVertexOutput_ } + , prefersLocalInvocationPrimitiveOutput{ prefersLocalInvocationPrimitiveOutput_ } + , prefersCompactVertexOutput{ prefersCompactVertexOutput_ } + , prefersCompactPrimitiveOutput{ prefersCompactPrimitiveOutput_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesEXT( PhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMeshShaderPropertiesEXT( VkPhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMeshShaderPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMeshShaderPropertiesEXT & operator=( PhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMeshShaderPropertiesEXT & operator=( VkPhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMeshShaderPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + uint32_t const &, + ArrayWrapper1D const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + ArrayWrapper1D const &, + uint32_t const &, + ArrayWrapper1D const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxTaskWorkGroupTotalCount, + maxTaskWorkGroupCount, + maxTaskWorkGroupInvocations, + maxTaskWorkGroupSize, + maxTaskPayloadSize, + maxTaskSharedMemorySize, + maxTaskPayloadAndSharedMemorySize, + maxMeshWorkGroupTotalCount, + maxMeshWorkGroupCount, + maxMeshWorkGroupInvocations, + maxMeshWorkGroupSize, + maxMeshSharedMemorySize, + maxMeshPayloadAndSharedMemorySize, + maxMeshOutputMemorySize, + maxMeshPayloadAndOutputMemorySize, + maxMeshOutputComponents, + maxMeshOutputVertices, + maxMeshOutputPrimitives, + maxMeshOutputLayers, + maxMeshMultiviewViewCount, + meshOutputPerVertexGranularity, + meshOutputPerPrimitiveGranularity, + maxPreferredTaskWorkGroupInvocations, + maxPreferredMeshWorkGroupInvocations, + prefersLocalInvocationVertexOutput, + prefersLocalInvocationPrimitiveOutput, + prefersCompactVertexOutput, + prefersCompactPrimitiveOutput ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMeshShaderPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMeshShaderPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTaskWorkGroupTotalCount == rhs.maxTaskWorkGroupTotalCount ) && + ( maxTaskWorkGroupCount == rhs.maxTaskWorkGroupCount ) && ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations ) && + ( maxTaskWorkGroupSize == rhs.maxTaskWorkGroupSize ) && ( maxTaskPayloadSize == rhs.maxTaskPayloadSize ) && + ( maxTaskSharedMemorySize == rhs.maxTaskSharedMemorySize ) && ( maxTaskPayloadAndSharedMemorySize == rhs.maxTaskPayloadAndSharedMemorySize ) && + ( maxMeshWorkGroupTotalCount == rhs.maxMeshWorkGroupTotalCount ) && ( maxMeshWorkGroupCount == rhs.maxMeshWorkGroupCount ) && + ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations ) && ( maxMeshWorkGroupSize == rhs.maxMeshWorkGroupSize ) && + ( maxMeshSharedMemorySize == rhs.maxMeshSharedMemorySize ) && ( maxMeshPayloadAndSharedMemorySize == rhs.maxMeshPayloadAndSharedMemorySize ) && + ( maxMeshOutputMemorySize == rhs.maxMeshOutputMemorySize ) && ( maxMeshPayloadAndOutputMemorySize == rhs.maxMeshPayloadAndOutputMemorySize ) && + ( maxMeshOutputComponents == rhs.maxMeshOutputComponents ) && ( maxMeshOutputVertices == rhs.maxMeshOutputVertices ) && + ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives ) && ( maxMeshOutputLayers == rhs.maxMeshOutputLayers ) && + ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount ) && ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity ) && + ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity ) && + ( maxPreferredTaskWorkGroupInvocations == rhs.maxPreferredTaskWorkGroupInvocations ) && + ( maxPreferredMeshWorkGroupInvocations == rhs.maxPreferredMeshWorkGroupInvocations ) && + ( prefersLocalInvocationVertexOutput == rhs.prefersLocalInvocationVertexOutput ) && + ( prefersLocalInvocationPrimitiveOutput == rhs.prefersLocalInvocationPrimitiveOutput ) && + ( prefersCompactVertexOutput == rhs.prefersCompactVertexOutput ) && ( prefersCompactPrimitiveOutput == rhs.prefersCompactPrimitiveOutput ); +# endif + } + + bool operator!=( PhysicalDeviceMeshShaderPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesEXT; + void * pNext = {}; + uint32_t maxTaskWorkGroupTotalCount = {}; + ArrayWrapper1D maxTaskWorkGroupCount = {}; + uint32_t maxTaskWorkGroupInvocations = {}; + ArrayWrapper1D maxTaskWorkGroupSize = {}; + uint32_t maxTaskPayloadSize = {}; + uint32_t maxTaskSharedMemorySize = {}; + uint32_t maxTaskPayloadAndSharedMemorySize = {}; + uint32_t maxMeshWorkGroupTotalCount = {}; + ArrayWrapper1D maxMeshWorkGroupCount = {}; + uint32_t maxMeshWorkGroupInvocations = {}; + ArrayWrapper1D maxMeshWorkGroupSize = {}; + uint32_t maxMeshSharedMemorySize = {}; + uint32_t maxMeshPayloadAndSharedMemorySize = {}; + uint32_t maxMeshOutputMemorySize = {}; + uint32_t maxMeshPayloadAndOutputMemorySize = {}; + uint32_t maxMeshOutputComponents = {}; + uint32_t maxMeshOutputVertices = {}; + uint32_t maxMeshOutputPrimitives = {}; + uint32_t maxMeshOutputLayers = {}; + uint32_t maxMeshMultiviewViewCount = {}; + uint32_t meshOutputPerVertexGranularity = {}; + uint32_t meshOutputPerPrimitiveGranularity = {}; + uint32_t maxPreferredTaskWorkGroupInvocations = {}; + uint32_t maxPreferredMeshWorkGroupInvocations = {}; + Bool32 prefersLocalInvocationVertexOutput = {}; + Bool32 prefersLocalInvocationPrimitiveOutput = {}; + Bool32 prefersCompactVertexOutput = {}; + Bool32 prefersCompactPrimitiveOutput = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMeshShaderPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMeshShaderPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceMeshShaderPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html + struct PhysicalDeviceMeshShaderPropertiesNV + { + using NativeType = VkPhysicalDeviceMeshShaderPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = {}, + uint32_t maxTaskWorkGroupInvocations_ = {}, + std::array const & maxTaskWorkGroupSize_ = {}, + uint32_t maxTaskTotalMemorySize_ = {}, + uint32_t maxTaskOutputCount_ = {}, + uint32_t maxMeshWorkGroupInvocations_ = {}, + std::array const & maxMeshWorkGroupSize_ = {}, + uint32_t maxMeshTotalMemorySize_ = {}, + uint32_t maxMeshOutputVertices_ = {}, + uint32_t maxMeshOutputPrimitives_ = {}, + uint32_t maxMeshMultiviewViewCount_ = {}, + uint32_t meshOutputPerVertexGranularity_ = {}, + uint32_t meshOutputPerPrimitiveGranularity_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxDrawMeshTasksCount{ maxDrawMeshTasksCount_ } + , maxTaskWorkGroupInvocations{ maxTaskWorkGroupInvocations_ } + , maxTaskWorkGroupSize{ maxTaskWorkGroupSize_ } + , maxTaskTotalMemorySize{ maxTaskTotalMemorySize_ } + , maxTaskOutputCount{ maxTaskOutputCount_ } + , maxMeshWorkGroupInvocations{ maxMeshWorkGroupInvocations_ } + , maxMeshWorkGroupSize{ maxMeshWorkGroupSize_ } + , maxMeshTotalMemorySize{ maxMeshTotalMemorySize_ } + , maxMeshOutputVertices{ maxMeshOutputVertices_ } + , maxMeshOutputPrimitives{ maxMeshOutputPrimitives_ } + , maxMeshMultiviewViewCount{ maxMeshMultiviewViewCount_ } + , meshOutputPerVertexGranularity{ meshOutputPerVertexGranularity_ } + , meshOutputPerPrimitiveGranularity{ meshOutputPerPrimitiveGranularity_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesNV( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMeshShaderPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMeshShaderPropertiesNV & operator=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMeshShaderPropertiesNV & operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMeshShaderPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMeshShaderPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + ArrayWrapper1D const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxDrawMeshTasksCount, + maxTaskWorkGroupInvocations, + maxTaskWorkGroupSize, + maxTaskTotalMemorySize, + maxTaskOutputCount, + maxMeshWorkGroupInvocations, + maxMeshWorkGroupSize, + maxMeshTotalMemorySize, + maxMeshOutputVertices, + maxMeshOutputPrimitives, + maxMeshMultiviewViewCount, + meshOutputPerVertexGranularity, + meshOutputPerPrimitiveGranularity ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMeshShaderPropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount ) && + ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations ) && ( maxTaskWorkGroupSize == rhs.maxTaskWorkGroupSize ) && + ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize ) && ( maxTaskOutputCount == rhs.maxTaskOutputCount ) && + ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations ) && ( maxMeshWorkGroupSize == rhs.maxMeshWorkGroupSize ) && + ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize ) && ( maxMeshOutputVertices == rhs.maxMeshOutputVertices ) && + ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives ) && ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount ) && + ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity ) && + ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity ); +# endif + } + + bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV; + void * pNext = {}; + uint32_t maxDrawMeshTasksCount = {}; + uint32_t maxTaskWorkGroupInvocations = {}; + ArrayWrapper1D maxTaskWorkGroupSize = {}; + uint32_t maxTaskTotalMemorySize = {}; + uint32_t maxTaskOutputCount = {}; + uint32_t maxMeshWorkGroupInvocations = {}; + ArrayWrapper1D maxMeshWorkGroupSize = {}; + uint32_t maxMeshTotalMemorySize = {}; + uint32_t maxMeshOutputVertices = {}; + uint32_t maxMeshOutputPrimitives = {}; + uint32_t maxMeshMultiviewViewCount = {}; + uint32_t meshOutputPerVertexGranularity = {}; + uint32_t meshOutputPerPrimitiveGranularity = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMeshShaderPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMeshShaderPropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceMultiDrawFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiDrawFeaturesEXT.html + struct PhysicalDeviceMultiDrawFeaturesEXT + { + using NativeType = VkPhysicalDeviceMultiDrawFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiDrawFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiDrawFeaturesEXT( Bool32 multiDraw_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , multiDraw{ multiDraw_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiDrawFeaturesEXT( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMultiDrawFeaturesEXT( VkPhysicalDeviceMultiDrawFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMultiDrawFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMultiDrawFeaturesEXT & operator=( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMultiDrawFeaturesEXT & operator=( VkPhysicalDeviceMultiDrawFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiDrawFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiDrawFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiDrawFeaturesEXT & setMultiDraw( Bool32 multiDraw_ ) & VULKAN_HPP_NOEXCEPT + { + multiDraw = multiDraw_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiDrawFeaturesEXT && setMultiDraw( Bool32 multiDraw_ ) && VULKAN_HPP_NOEXCEPT + { + multiDraw = multiDraw_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMultiDrawFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiDrawFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiDrawFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiDrawFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, multiDraw ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMultiDrawFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiDraw == rhs.multiDraw ); +# endif + } + + bool operator!=( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMultiDrawFeaturesEXT; + void * pNext = {}; + Bool32 multiDraw = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMultiDrawFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMultiDrawFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceMultiDrawPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiDrawPropertiesEXT.html + struct PhysicalDeviceMultiDrawPropertiesEXT + { + using NativeType = VkPhysicalDeviceMultiDrawPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiDrawPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiDrawPropertiesEXT( uint32_t maxMultiDrawCount_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxMultiDrawCount{ maxMultiDrawCount_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiDrawPropertiesEXT( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMultiDrawPropertiesEXT( VkPhysicalDeviceMultiDrawPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMultiDrawPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMultiDrawPropertiesEXT & operator=( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMultiDrawPropertiesEXT & operator=( VkPhysicalDeviceMultiDrawPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMultiDrawPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiDrawPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiDrawPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiDrawPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxMultiDrawCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMultiDrawPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiDrawCount == rhs.maxMultiDrawCount ); +# endif + } + + bool operator!=( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMultiDrawPropertiesEXT; + void * pNext = {}; + uint32_t maxMultiDrawCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMultiDrawPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMultiDrawPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.html + struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT + { + using NativeType = VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( Bool32 multisampledRenderToSingleSampled_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , multisampledRenderToSingleSampled{ multisampledRenderToSingleSampled_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( + *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT & + operator=( PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT & + operator=( VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT & + setMultisampledRenderToSingleSampled( Bool32 multisampledRenderToSingleSampled_ ) & + VULKAN_HPP_NOEXCEPT + { + multisampledRenderToSingleSampled = multisampledRenderToSingleSampled_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT && + setMultisampledRenderToSingleSampled( Bool32 multisampledRenderToSingleSampled_ ) && + VULKAN_HPP_NOEXCEPT + { + multisampledRenderToSingleSampled = multisampledRenderToSingleSampled_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, multisampledRenderToSingleSampled ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multisampledRenderToSingleSampled == rhs.multisampledRenderToSingleSampled ); +# endif + } + + bool operator!=( PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + void * pNext = {}; + Bool32 multisampledRenderToSingleSampled = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceMultiviewFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewFeatures.html + struct PhysicalDeviceMultiviewFeatures + { + using NativeType = VkPhysicalDeviceMultiviewFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( Bool32 multiview_ = {}, + Bool32 multiviewGeometryShader_ = {}, + Bool32 multiviewTessellationShader_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , multiview{ multiview_ } + , multiviewGeometryShader{ multiviewGeometryShader_ } + , multiviewTessellationShader{ multiviewTessellationShader_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( PhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMultiviewFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMultiviewFeatures & operator=( PhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMultiviewFeatures & operator=( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures & setMultiview( Bool32 multiview_ ) & VULKAN_HPP_NOEXCEPT + { + multiview = multiview_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures && setMultiview( Bool32 multiview_ ) && VULKAN_HPP_NOEXCEPT + { + multiview = multiview_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures & setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ ) & VULKAN_HPP_NOEXCEPT + { + multiviewGeometryShader = multiviewGeometryShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures && setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ ) && VULKAN_HPP_NOEXCEPT + { + multiviewGeometryShader = multiviewGeometryShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures & setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ ) & VULKAN_HPP_NOEXCEPT + { + multiviewTessellationShader = multiviewTessellationShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures && setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ ) && VULKAN_HPP_NOEXCEPT + { + multiviewTessellationShader = multiviewTessellationShader_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMultiviewFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, multiview, multiviewGeometryShader, multiviewTessellationShader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMultiviewFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiview == rhs.multiview ) && ( multiviewGeometryShader == rhs.multiviewGeometryShader ) && + ( multiviewTessellationShader == rhs.multiviewTessellationShader ); +# endif + } + + bool operator!=( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures; + void * pNext = {}; + Bool32 multiview = {}; + Bool32 multiviewGeometryShader = {}; + Bool32 multiviewTessellationShader = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewFeatures; + }; + + using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures; + + // wrapper struct for struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html + struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX + { + using NativeType = VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( Bool32 perViewPositionAllComponents_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , perViewPositionAllComponents{ perViewPositionAllComponents_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX & + operator=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX & operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, perViewPositionAllComponents ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & ) const = default; +#else + bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewPositionAllComponents == rhs.perViewPositionAllComponents ); +# endif + } + + bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + void * pNext = {}; + Bool32 perViewPositionAllComponents = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; + }; + + // wrapper struct for struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.html + struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM + { + using NativeType = VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( Bool32 multiviewPerViewRenderAreas_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , multiviewPerViewRenderAreas{ multiviewPerViewRenderAreas_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM & + operator=( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM & operator=( VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM & setMultiviewPerViewRenderAreas( Bool32 multiviewPerViewRenderAreas_ ) & + VULKAN_HPP_NOEXCEPT + { + multiviewPerViewRenderAreas = multiviewPerViewRenderAreas_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM && setMultiviewPerViewRenderAreas( Bool32 multiviewPerViewRenderAreas_ ) && + VULKAN_HPP_NOEXCEPT + { + multiviewPerViewRenderAreas = multiviewPerViewRenderAreas_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, multiviewPerViewRenderAreas ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiviewPerViewRenderAreas == rhs.multiviewPerViewRenderAreas ); +# endif + } + + bool operator!=( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + void * pNext = {}; + Bool32 multiviewPerViewRenderAreas = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.html + struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM + { + using NativeType = VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( Bool32 multiviewPerViewViewports_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , multiviewPerViewViewports{ multiviewPerViewViewports_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM & + operator=( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM & operator=( VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM & setMultiviewPerViewViewports( Bool32 multiviewPerViewViewports_ ) & + VULKAN_HPP_NOEXCEPT + { + multiviewPerViewViewports = multiviewPerViewViewports_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM && setMultiviewPerViewViewports( Bool32 multiviewPerViewViewports_ ) && + VULKAN_HPP_NOEXCEPT + { + multiviewPerViewViewports = multiviewPerViewViewports_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, multiviewPerViewViewports ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiviewPerViewViewports == rhs.multiviewPerViewViewports ); +# endif + } + + bool operator!=( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + void * pNext = {}; + Bool32 multiviewPerViewViewports = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceMultiviewProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewProperties.html + struct PhysicalDeviceMultiviewProperties + { + using NativeType = VkPhysicalDeviceMultiviewProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewProperties( uint32_t maxMultiviewViewCount_ = {}, + uint32_t maxMultiviewInstanceIndex_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxMultiviewViewCount{ maxMultiviewViewCount_ } + , maxMultiviewInstanceIndex{ maxMultiviewInstanceIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewProperties( PhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMultiviewProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMultiviewProperties & operator=( PhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMultiviewProperties & operator=( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceMultiviewProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMultiviewProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxMultiviewViewCount, maxMultiviewInstanceIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMultiviewProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) && + ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ); +# endif + } + + bool operator!=( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties; + void * pNext = {}; + uint32_t maxMultiviewViewCount = {}; + uint32_t maxMultiviewInstanceIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMultiviewProperties; + }; + + using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; + + // wrapper struct for struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.html + struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT + { + using NativeType = VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceMutableDescriptorTypeFeaturesEXT( Bool32 mutableDescriptorType_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , mutableDescriptorType{ mutableDescriptorType_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceMutableDescriptorTypeFeaturesEXT( PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceMutableDescriptorTypeFeaturesEXT( VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceMutableDescriptorTypeFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceMutableDescriptorTypeFeaturesEXT & operator=( PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceMutableDescriptorTypeFeaturesEXT & operator=( VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMutableDescriptorTypeFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMutableDescriptorTypeFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMutableDescriptorTypeFeaturesEXT & setMutableDescriptorType( Bool32 mutableDescriptorType_ ) & VULKAN_HPP_NOEXCEPT + { + mutableDescriptorType = mutableDescriptorType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMutableDescriptorTypeFeaturesEXT && setMutableDescriptorType( Bool32 mutableDescriptorType_ ) && VULKAN_HPP_NOEXCEPT + { + mutableDescriptorType = mutableDescriptorType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mutableDescriptorType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorType == rhs.mutableDescriptorType ); +# endif + } + + bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT; + void * pNext = {}; + Bool32 mutableDescriptorType = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceMutableDescriptorTypeFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceMutableDescriptorTypeFeaturesEXT; + }; + + using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT; + + // wrapper struct for struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceNestedCommandBufferFeaturesEXT.html + struct PhysicalDeviceNestedCommandBufferFeaturesEXT + { + using NativeType = VkPhysicalDeviceNestedCommandBufferFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceNestedCommandBufferFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceNestedCommandBufferFeaturesEXT( Bool32 nestedCommandBuffer_ = {}, + Bool32 nestedCommandBufferRendering_ = {}, + Bool32 nestedCommandBufferSimultaneousUse_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , nestedCommandBuffer{ nestedCommandBuffer_ } + , nestedCommandBufferRendering{ nestedCommandBufferRendering_ } + , nestedCommandBufferSimultaneousUse{ nestedCommandBufferSimultaneousUse_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceNestedCommandBufferFeaturesEXT( PhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceNestedCommandBufferFeaturesEXT( VkPhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceNestedCommandBufferFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceNestedCommandBufferFeaturesEXT & operator=( PhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceNestedCommandBufferFeaturesEXT & operator=( VkPhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT & setNestedCommandBuffer( Bool32 nestedCommandBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + nestedCommandBuffer = nestedCommandBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT && setNestedCommandBuffer( Bool32 nestedCommandBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + nestedCommandBuffer = nestedCommandBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT & setNestedCommandBufferRendering( Bool32 nestedCommandBufferRendering_ ) & + VULKAN_HPP_NOEXCEPT + { + nestedCommandBufferRendering = nestedCommandBufferRendering_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT && setNestedCommandBufferRendering( Bool32 nestedCommandBufferRendering_ ) && + VULKAN_HPP_NOEXCEPT + { + nestedCommandBufferRendering = nestedCommandBufferRendering_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT & setNestedCommandBufferSimultaneousUse( Bool32 nestedCommandBufferSimultaneousUse_ ) & + VULKAN_HPP_NOEXCEPT + { + nestedCommandBufferSimultaneousUse = nestedCommandBufferSimultaneousUse_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT && + setNestedCommandBufferSimultaneousUse( Bool32 nestedCommandBufferSimultaneousUse_ ) && + VULKAN_HPP_NOEXCEPT + { + nestedCommandBufferSimultaneousUse = nestedCommandBufferSimultaneousUse_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceNestedCommandBufferFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceNestedCommandBufferFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceNestedCommandBufferFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceNestedCommandBufferFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, nestedCommandBuffer, nestedCommandBufferRendering, nestedCommandBufferSimultaneousUse ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceNestedCommandBufferFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( nestedCommandBuffer == rhs.nestedCommandBuffer ) && + ( nestedCommandBufferRendering == rhs.nestedCommandBufferRendering ) && + ( nestedCommandBufferSimultaneousUse == rhs.nestedCommandBufferSimultaneousUse ); +# endif + } + + bool operator!=( PhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceNestedCommandBufferFeaturesEXT; + void * pNext = {}; + Bool32 nestedCommandBuffer = {}; + Bool32 nestedCommandBufferRendering = {}; + Bool32 nestedCommandBufferSimultaneousUse = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceNestedCommandBufferFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceNestedCommandBufferFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceNestedCommandBufferPropertiesEXT.html + struct PhysicalDeviceNestedCommandBufferPropertiesEXT + { + using NativeType = VkPhysicalDeviceNestedCommandBufferPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceNestedCommandBufferPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceNestedCommandBufferPropertiesEXT( uint32_t maxCommandBufferNestingLevel_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxCommandBufferNestingLevel{ maxCommandBufferNestingLevel_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceNestedCommandBufferPropertiesEXT( PhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceNestedCommandBufferPropertiesEXT( VkPhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceNestedCommandBufferPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceNestedCommandBufferPropertiesEXT & operator=( PhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceNestedCommandBufferPropertiesEXT & operator=( VkPhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceNestedCommandBufferPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceNestedCommandBufferPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceNestedCommandBufferPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceNestedCommandBufferPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxCommandBufferNestingLevel ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceNestedCommandBufferPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxCommandBufferNestingLevel == rhs.maxCommandBufferNestingLevel ); +# endif + } + + bool operator!=( PhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceNestedCommandBufferPropertiesEXT; + void * pNext = {}; + uint32_t maxCommandBufferNestingLevel = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceNestedCommandBufferPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceNestedCommandBufferPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.html + struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT + { + using NativeType = VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceNonSeamlessCubeMapFeaturesEXT( Bool32 nonSeamlessCubeMap_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , nonSeamlessCubeMap{ nonSeamlessCubeMap_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceNonSeamlessCubeMapFeaturesEXT( PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceNonSeamlessCubeMapFeaturesEXT( VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceNonSeamlessCubeMapFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceNonSeamlessCubeMapFeaturesEXT & operator=( PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceNonSeamlessCubeMapFeaturesEXT & operator=( VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT & setNonSeamlessCubeMap( Bool32 nonSeamlessCubeMap_ ) & VULKAN_HPP_NOEXCEPT + { + nonSeamlessCubeMap = nonSeamlessCubeMap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT && setNonSeamlessCubeMap( Bool32 nonSeamlessCubeMap_ ) && VULKAN_HPP_NOEXCEPT + { + nonSeamlessCubeMap = nonSeamlessCubeMap_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, nonSeamlessCubeMap ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( nonSeamlessCubeMap == rhs.nonSeamlessCubeMap ); +# endif + } + + bool operator!=( PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + void * pNext = {}; + Bool32 nonSeamlessCubeMap = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceOpacityMicromapFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpacityMicromapFeaturesEXT.html + struct PhysicalDeviceOpacityMicromapFeaturesEXT + { + using NativeType = VkPhysicalDeviceOpacityMicromapFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceOpacityMicromapFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapFeaturesEXT( Bool32 micromap_ = {}, + Bool32 micromapCaptureReplay_ = {}, + Bool32 micromapHostCommands_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , micromap{ micromap_ } + , micromapCaptureReplay{ micromapCaptureReplay_ } + , micromapHostCommands{ micromapHostCommands_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapFeaturesEXT( PhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceOpacityMicromapFeaturesEXT( VkPhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceOpacityMicromapFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceOpacityMicromapFeaturesEXT & operator=( PhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceOpacityMicromapFeaturesEXT & operator=( VkPhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT & setMicromap( Bool32 micromap_ ) & VULKAN_HPP_NOEXCEPT + { + micromap = micromap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT && setMicromap( Bool32 micromap_ ) && VULKAN_HPP_NOEXCEPT + { + micromap = micromap_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT & setMicromapCaptureReplay( Bool32 micromapCaptureReplay_ ) & VULKAN_HPP_NOEXCEPT + { + micromapCaptureReplay = micromapCaptureReplay_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT && setMicromapCaptureReplay( Bool32 micromapCaptureReplay_ ) && VULKAN_HPP_NOEXCEPT + { + micromapCaptureReplay = micromapCaptureReplay_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT & setMicromapHostCommands( Bool32 micromapHostCommands_ ) & VULKAN_HPP_NOEXCEPT + { + micromapHostCommands = micromapHostCommands_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT && setMicromapHostCommands( Bool32 micromapHostCommands_ ) && VULKAN_HPP_NOEXCEPT + { + micromapHostCommands = micromapHostCommands_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceOpacityMicromapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, micromap, micromapCaptureReplay, micromapHostCommands ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceOpacityMicromapFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( micromap == rhs.micromap ) && ( micromapCaptureReplay == rhs.micromapCaptureReplay ) && + ( micromapHostCommands == rhs.micromapHostCommands ); +# endif + } + + bool operator!=( PhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceOpacityMicromapFeaturesEXT; + void * pNext = {}; + Bool32 micromap = {}; + Bool32 micromapCaptureReplay = {}; + Bool32 micromapHostCommands = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceOpacityMicromapFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceOpacityMicromapFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceOpacityMicromapPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpacityMicromapPropertiesEXT.html + struct PhysicalDeviceOpacityMicromapPropertiesEXT + { + using NativeType = VkPhysicalDeviceOpacityMicromapPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceOpacityMicromapPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapPropertiesEXT( uint32_t maxOpacity2StateSubdivisionLevel_ = {}, + uint32_t maxOpacity4StateSubdivisionLevel_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxOpacity2StateSubdivisionLevel{ maxOpacity2StateSubdivisionLevel_ } + , maxOpacity4StateSubdivisionLevel{ maxOpacity4StateSubdivisionLevel_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapPropertiesEXT( PhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceOpacityMicromapPropertiesEXT( VkPhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceOpacityMicromapPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceOpacityMicromapPropertiesEXT & operator=( PhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceOpacityMicromapPropertiesEXT & operator=( VkPhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceOpacityMicromapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpacityMicromapPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxOpacity2StateSubdivisionLevel, maxOpacity4StateSubdivisionLevel ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceOpacityMicromapPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxOpacity2StateSubdivisionLevel == rhs.maxOpacity2StateSubdivisionLevel ) && + ( maxOpacity4StateSubdivisionLevel == rhs.maxOpacity4StateSubdivisionLevel ); +# endif + } + + bool operator!=( PhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceOpacityMicromapPropertiesEXT; + void * pNext = {}; + uint32_t maxOpacity2StateSubdivisionLevel = {}; + uint32_t maxOpacity4StateSubdivisionLevel = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceOpacityMicromapPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceOpacityMicromapPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceOpticalFlowFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpticalFlowFeaturesNV.html + struct PhysicalDeviceOpticalFlowFeaturesNV + { + using NativeType = VkPhysicalDeviceOpticalFlowFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceOpticalFlowFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpticalFlowFeaturesNV( Bool32 opticalFlow_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , opticalFlow{ opticalFlow_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpticalFlowFeaturesNV( PhysicalDeviceOpticalFlowFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceOpticalFlowFeaturesNV( VkPhysicalDeviceOpticalFlowFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceOpticalFlowFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceOpticalFlowFeaturesNV & operator=( PhysicalDeviceOpticalFlowFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceOpticalFlowFeaturesNV & operator=( VkPhysicalDeviceOpticalFlowFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpticalFlowFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpticalFlowFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpticalFlowFeaturesNV & setOpticalFlow( Bool32 opticalFlow_ ) & VULKAN_HPP_NOEXCEPT + { + opticalFlow = opticalFlow_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpticalFlowFeaturesNV && setOpticalFlow( Bool32 opticalFlow_ ) && VULKAN_HPP_NOEXCEPT + { + opticalFlow = opticalFlow_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceOpticalFlowFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpticalFlowFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpticalFlowFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpticalFlowFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, opticalFlow ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceOpticalFlowFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceOpticalFlowFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opticalFlow == rhs.opticalFlow ); +# endif + } + + bool operator!=( PhysicalDeviceOpticalFlowFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceOpticalFlowFeaturesNV; + void * pNext = {}; + Bool32 opticalFlow = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceOpticalFlowFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceOpticalFlowFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceOpticalFlowPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpticalFlowPropertiesNV.html + struct PhysicalDeviceOpticalFlowPropertiesNV + { + using NativeType = VkPhysicalDeviceOpticalFlowPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceOpticalFlowPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpticalFlowPropertiesNV( OpticalFlowGridSizeFlagsNV supportedOutputGridSizes_ = {}, + OpticalFlowGridSizeFlagsNV supportedHintGridSizes_ = {}, + Bool32 hintSupported_ = {}, + Bool32 costSupported_ = {}, + Bool32 bidirectionalFlowSupported_ = {}, + Bool32 globalFlowSupported_ = {}, + uint32_t minWidth_ = {}, + uint32_t minHeight_ = {}, + uint32_t maxWidth_ = {}, + uint32_t maxHeight_ = {}, + uint32_t maxNumRegionsOfInterest_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , supportedOutputGridSizes{ supportedOutputGridSizes_ } + , supportedHintGridSizes{ supportedHintGridSizes_ } + , hintSupported{ hintSupported_ } + , costSupported{ costSupported_ } + , bidirectionalFlowSupported{ bidirectionalFlowSupported_ } + , globalFlowSupported{ globalFlowSupported_ } + , minWidth{ minWidth_ } + , minHeight{ minHeight_ } + , maxWidth{ maxWidth_ } + , maxHeight{ maxHeight_ } + , maxNumRegionsOfInterest{ maxNumRegionsOfInterest_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceOpticalFlowPropertiesNV( PhysicalDeviceOpticalFlowPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceOpticalFlowPropertiesNV( VkPhysicalDeviceOpticalFlowPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceOpticalFlowPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceOpticalFlowPropertiesNV & operator=( PhysicalDeviceOpticalFlowPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceOpticalFlowPropertiesNV & operator=( VkPhysicalDeviceOpticalFlowPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceOpticalFlowPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpticalFlowPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpticalFlowPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceOpticalFlowPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + supportedOutputGridSizes, + supportedHintGridSizes, + hintSupported, + costSupported, + bidirectionalFlowSupported, + globalFlowSupported, + minWidth, + minHeight, + maxWidth, + maxHeight, + maxNumRegionsOfInterest ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceOpticalFlowPropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceOpticalFlowPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedOutputGridSizes == rhs.supportedOutputGridSizes ) && + ( supportedHintGridSizes == rhs.supportedHintGridSizes ) && ( hintSupported == rhs.hintSupported ) && ( costSupported == rhs.costSupported ) && + ( bidirectionalFlowSupported == rhs.bidirectionalFlowSupported ) && ( globalFlowSupported == rhs.globalFlowSupported ) && + ( minWidth == rhs.minWidth ) && ( minHeight == rhs.minHeight ) && ( maxWidth == rhs.maxWidth ) && ( maxHeight == rhs.maxHeight ) && + ( maxNumRegionsOfInterest == rhs.maxNumRegionsOfInterest ); +# endif + } + + bool operator!=( PhysicalDeviceOpticalFlowPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceOpticalFlowPropertiesNV; + void * pNext = {}; + OpticalFlowGridSizeFlagsNV supportedOutputGridSizes = {}; + OpticalFlowGridSizeFlagsNV supportedHintGridSizes = {}; + Bool32 hintSupported = {}; + Bool32 costSupported = {}; + Bool32 bidirectionalFlowSupported = {}; + Bool32 globalFlowSupported = {}; + uint32_t minWidth = {}; + uint32_t minHeight = {}; + uint32_t maxWidth = {}; + uint32_t maxHeight = {}; + uint32_t maxNumRegionsOfInterest = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceOpticalFlowPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceOpticalFlowPropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDevicePCIBusInfoPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html + struct PhysicalDevicePCIBusInfoPropertiesEXT + { + using NativeType = VkPhysicalDevicePCIBusInfoPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePCIBusInfoPropertiesEXT( + uint32_t pciDomain_ = {}, uint32_t pciBus_ = {}, uint32_t pciDevice_ = {}, uint32_t pciFunction_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pciDomain{ pciDomain_ } + , pciBus{ pciBus_ } + , pciDevice{ pciDevice_ } + , pciFunction{ pciFunction_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePCIBusInfoPropertiesEXT( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePCIBusInfoPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePCIBusInfoPropertiesEXT & operator=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePCIBusInfoPropertiesEXT & operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDevicePCIBusInfoPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePCIBusInfoPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePCIBusInfoPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePCIBusInfoPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pciDomain, pciBus, pciDevice, pciFunction ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePCIBusInfoPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pciDomain == rhs.pciDomain ) && ( pciBus == rhs.pciBus ) && ( pciDevice == rhs.pciDevice ) && + ( pciFunction == rhs.pciFunction ); +# endif + } + + bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; + void * pNext = {}; + uint32_t pciDomain = {}; + uint32_t pciBus = {}; + uint32_t pciDevice = {}; + uint32_t pciFunction = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePCIBusInfoPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePCIBusInfoPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.html + struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT + { + using NativeType = VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT( Bool32 pageableDeviceLocalMemory_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pageableDeviceLocalMemory{ pageableDeviceLocalMemory_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT( VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT & + operator=( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT & operator=( VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT & setPageableDeviceLocalMemory( Bool32 pageableDeviceLocalMemory_ ) & + VULKAN_HPP_NOEXCEPT + { + pageableDeviceLocalMemory = pageableDeviceLocalMemory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT && setPageableDeviceLocalMemory( Bool32 pageableDeviceLocalMemory_ ) && + VULKAN_HPP_NOEXCEPT + { + pageableDeviceLocalMemory = pageableDeviceLocalMemory_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pageableDeviceLocalMemory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pageableDeviceLocalMemory == rhs.pageableDeviceLocalMemory ); +# endif + } + + bool operator!=( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + void * pNext = {}; + Bool32 pageableDeviceLocalMemory = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.html + struct PhysicalDevicePartitionedAccelerationStructureFeaturesNV + { + using NativeType = VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePartitionedAccelerationStructureFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePartitionedAccelerationStructureFeaturesNV( Bool32 partitionedAccelerationStructure_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , partitionedAccelerationStructure{ partitionedAccelerationStructure_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePartitionedAccelerationStructureFeaturesNV( PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePartitionedAccelerationStructureFeaturesNV( VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePartitionedAccelerationStructureFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePartitionedAccelerationStructureFeaturesNV & + operator=( PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePartitionedAccelerationStructureFeaturesNV & + operator=( VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePartitionedAccelerationStructureFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePartitionedAccelerationStructureFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePartitionedAccelerationStructureFeaturesNV & + setPartitionedAccelerationStructure( Bool32 partitionedAccelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + partitionedAccelerationStructure = partitionedAccelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePartitionedAccelerationStructureFeaturesNV && + setPartitionedAccelerationStructure( Bool32 partitionedAccelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + partitionedAccelerationStructure = partitionedAccelerationStructure_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, partitionedAccelerationStructure ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( partitionedAccelerationStructure == rhs.partitionedAccelerationStructure ); +# endif + } + + bool operator!=( PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePartitionedAccelerationStructureFeaturesNV; + void * pNext = {}; + Bool32 partitionedAccelerationStructure = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePartitionedAccelerationStructureFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePartitionedAccelerationStructureFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV.html + struct PhysicalDevicePartitionedAccelerationStructurePropertiesNV + { + using NativeType = VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePartitionedAccelerationStructurePropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePartitionedAccelerationStructurePropertiesNV( uint32_t maxPartitionCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxPartitionCount{ maxPartitionCount_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePartitionedAccelerationStructurePropertiesNV( PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePartitionedAccelerationStructurePropertiesNV( VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePartitionedAccelerationStructurePropertiesNV( + *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePartitionedAccelerationStructurePropertiesNV & + operator=( PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePartitionedAccelerationStructurePropertiesNV & + operator=( VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxPartitionCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPartitionCount == rhs.maxPartitionCount ); +# endif + } + + bool operator!=( PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePartitionedAccelerationStructurePropertiesNV; + void * pNext = {}; + uint32_t maxPartitionCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePartitionedAccelerationStructurePropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePartitionedAccelerationStructurePropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePerStageDescriptorSetFeaturesNV.html + struct PhysicalDevicePerStageDescriptorSetFeaturesNV + { + using NativeType = VkPhysicalDevicePerStageDescriptorSetFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePerStageDescriptorSetFeaturesNV( Bool32 perStageDescriptorSet_ = {}, + Bool32 dynamicPipelineLayout_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , perStageDescriptorSet{ perStageDescriptorSet_ } + , dynamicPipelineLayout{ dynamicPipelineLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePerStageDescriptorSetFeaturesNV( PhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePerStageDescriptorSetFeaturesNV( VkPhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePerStageDescriptorSetFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePerStageDescriptorSetFeaturesNV & operator=( PhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePerStageDescriptorSetFeaturesNV & operator=( VkPhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV & setPerStageDescriptorSet( Bool32 perStageDescriptorSet_ ) & VULKAN_HPP_NOEXCEPT + { + perStageDescriptorSet = perStageDescriptorSet_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV && setPerStageDescriptorSet( Bool32 perStageDescriptorSet_ ) && VULKAN_HPP_NOEXCEPT + { + perStageDescriptorSet = perStageDescriptorSet_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV & setDynamicPipelineLayout( Bool32 dynamicPipelineLayout_ ) & VULKAN_HPP_NOEXCEPT + { + dynamicPipelineLayout = dynamicPipelineLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV && setDynamicPipelineLayout( Bool32 dynamicPipelineLayout_ ) && VULKAN_HPP_NOEXCEPT + { + dynamicPipelineLayout = dynamicPipelineLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePerStageDescriptorSetFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerStageDescriptorSetFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerStageDescriptorSetFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerStageDescriptorSetFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, perStageDescriptorSet, dynamicPipelineLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePerStageDescriptorSetFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perStageDescriptorSet == rhs.perStageDescriptorSet ) && + ( dynamicPipelineLayout == rhs.dynamicPipelineLayout ); +# endif + } + + bool operator!=( PhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV; + void * pNext = {}; + Bool32 perStageDescriptorSet = {}; + Bool32 dynamicPipelineLayout = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePerStageDescriptorSetFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePerStageDescriptorSetFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDevicePerformanceCountersByRegionFeaturesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePerformanceCountersByRegionFeaturesARM.html + struct PhysicalDevicePerformanceCountersByRegionFeaturesARM + { + using NativeType = VkPhysicalDevicePerformanceCountersByRegionFeaturesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceCountersByRegionFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceCountersByRegionFeaturesARM( Bool32 performanceCountersByRegion_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , performanceCountersByRegion{ performanceCountersByRegion_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePerformanceCountersByRegionFeaturesARM( PhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePerformanceCountersByRegionFeaturesARM( VkPhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePerformanceCountersByRegionFeaturesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePerformanceCountersByRegionFeaturesARM & + operator=( PhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePerformanceCountersByRegionFeaturesARM & operator=( VkPhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceCountersByRegionFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceCountersByRegionFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceCountersByRegionFeaturesARM & setPerformanceCountersByRegion( Bool32 performanceCountersByRegion_ ) & + VULKAN_HPP_NOEXCEPT + { + performanceCountersByRegion = performanceCountersByRegion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceCountersByRegionFeaturesARM && setPerformanceCountersByRegion( Bool32 performanceCountersByRegion_ ) && + VULKAN_HPP_NOEXCEPT + { + performanceCountersByRegion = performanceCountersByRegion_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePerformanceCountersByRegionFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceCountersByRegionFeaturesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceCountersByRegionFeaturesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceCountersByRegionFeaturesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, performanceCountersByRegion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePerformanceCountersByRegionFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( performanceCountersByRegion == rhs.performanceCountersByRegion ); +# endif + } + + bool operator!=( PhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePerformanceCountersByRegionFeaturesARM; + void * pNext = {}; + Bool32 performanceCountersByRegion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePerformanceCountersByRegionFeaturesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePerformanceCountersByRegionFeaturesARM; + }; + + // wrapper struct for struct VkPhysicalDevicePerformanceCountersByRegionPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePerformanceCountersByRegionPropertiesARM.html + struct PhysicalDevicePerformanceCountersByRegionPropertiesARM + { + using NativeType = VkPhysicalDevicePerformanceCountersByRegionPropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceCountersByRegionPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceCountersByRegionPropertiesARM( uint32_t maxPerRegionPerformanceCounters_ = {}, + Extent2D performanceCounterRegionSize_ = {}, + uint32_t rowStrideAlignment_ = {}, + uint32_t regionAlignment_ = {}, + Bool32 identityTransformOrder_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxPerRegionPerformanceCounters{ maxPerRegionPerformanceCounters_ } + , performanceCounterRegionSize{ performanceCounterRegionSize_ } + , rowStrideAlignment{ rowStrideAlignment_ } + , regionAlignment{ regionAlignment_ } + , identityTransformOrder{ identityTransformOrder_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceCountersByRegionPropertiesARM( PhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePerformanceCountersByRegionPropertiesARM( VkPhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePerformanceCountersByRegionPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePerformanceCountersByRegionPropertiesARM & + operator=( PhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePerformanceCountersByRegionPropertiesARM & + operator=( VkPhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDevicePerformanceCountersByRegionPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceCountersByRegionPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceCountersByRegionPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceCountersByRegionPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, maxPerRegionPerformanceCounters, performanceCounterRegionSize, rowStrideAlignment, regionAlignment, identityTransformOrder ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePerformanceCountersByRegionPropertiesARM const & ) const = default; +#else + bool operator==( PhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPerRegionPerformanceCounters == rhs.maxPerRegionPerformanceCounters ) && + ( performanceCounterRegionSize == rhs.performanceCounterRegionSize ) && ( rowStrideAlignment == rhs.rowStrideAlignment ) && + ( regionAlignment == rhs.regionAlignment ) && ( identityTransformOrder == rhs.identityTransformOrder ); +# endif + } + + bool operator!=( PhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePerformanceCountersByRegionPropertiesARM; + void * pNext = {}; + uint32_t maxPerRegionPerformanceCounters = {}; + Extent2D performanceCounterRegionSize = {}; + uint32_t rowStrideAlignment = {}; + uint32_t regionAlignment = {}; + Bool32 identityTransformOrder = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePerformanceCountersByRegionPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePerformanceCountersByRegionPropertiesARM; + }; + + // wrapper struct for struct VkPhysicalDevicePerformanceQueryFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html + struct PhysicalDevicePerformanceQueryFeaturesKHR + { + using NativeType = VkPhysicalDevicePerformanceQueryFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryFeaturesKHR( Bool32 performanceCounterQueryPools_ = {}, + Bool32 performanceCounterMultipleQueryPools_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , performanceCounterQueryPools{ performanceCounterQueryPools_ } + , performanceCounterMultipleQueryPools{ performanceCounterMultipleQueryPools_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryFeaturesKHR( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePerformanceQueryFeaturesKHR( VkPhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePerformanceQueryFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePerformanceQueryFeaturesKHR & operator=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePerformanceQueryFeaturesKHR & operator=( VkPhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR & setPerformanceCounterQueryPools( Bool32 performanceCounterQueryPools_ ) & + VULKAN_HPP_NOEXCEPT + { + performanceCounterQueryPools = performanceCounterQueryPools_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR && setPerformanceCounterQueryPools( Bool32 performanceCounterQueryPools_ ) && + VULKAN_HPP_NOEXCEPT + { + performanceCounterQueryPools = performanceCounterQueryPools_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR & + setPerformanceCounterMultipleQueryPools( Bool32 performanceCounterMultipleQueryPools_ ) & + VULKAN_HPP_NOEXCEPT + { + performanceCounterMultipleQueryPools = performanceCounterMultipleQueryPools_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR && + setPerformanceCounterMultipleQueryPools( Bool32 performanceCounterMultipleQueryPools_ ) && + VULKAN_HPP_NOEXCEPT + { + performanceCounterMultipleQueryPools = performanceCounterMultipleQueryPools_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePerformanceQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceQueryFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceQueryFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, performanceCounterQueryPools, performanceCounterMultipleQueryPools ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePerformanceQueryFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( performanceCounterQueryPools == rhs.performanceCounterQueryPools ) && + ( performanceCounterMultipleQueryPools == rhs.performanceCounterMultipleQueryPools ); +# endif + } + + bool operator!=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR; + void * pNext = {}; + Bool32 performanceCounterQueryPools = {}; + Bool32 performanceCounterMultipleQueryPools = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePerformanceQueryFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePerformanceQueryFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDevicePerformanceQueryPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html + struct PhysicalDevicePerformanceQueryPropertiesKHR + { + using NativeType = VkPhysicalDevicePerformanceQueryPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryPropertiesKHR( Bool32 allowCommandBufferQueryCopies_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , allowCommandBufferQueryCopies{ allowCommandBufferQueryCopies_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryPropertiesKHR( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePerformanceQueryPropertiesKHR( VkPhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePerformanceQueryPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePerformanceQueryPropertiesKHR & operator=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePerformanceQueryPropertiesKHR & operator=( VkPhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDevicePerformanceQueryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceQueryPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceQueryPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePerformanceQueryPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allowCommandBufferQueryCopies ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePerformanceQueryPropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allowCommandBufferQueryCopies == rhs.allowCommandBufferQueryCopies ); +# endif + } + + bool operator!=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR; + void * pNext = {}; + Bool32 allowCommandBufferQueryCopies = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePerformanceQueryPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePerformanceQueryPropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDevicePipelineBinaryFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineBinaryFeaturesKHR.html + struct PhysicalDevicePipelineBinaryFeaturesKHR + { + using NativeType = VkPhysicalDevicePipelineBinaryFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineBinaryFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineBinaryFeaturesKHR( Bool32 pipelineBinaries_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineBinaries{ pipelineBinaries_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineBinaryFeaturesKHR( PhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelineBinaryFeaturesKHR( VkPhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelineBinaryFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelineBinaryFeaturesKHR & operator=( PhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelineBinaryFeaturesKHR & operator=( VkPhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineBinaryFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineBinaryFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineBinaryFeaturesKHR & setPipelineBinaries( Bool32 pipelineBinaries_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineBinaries = pipelineBinaries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineBinaryFeaturesKHR && setPipelineBinaries( Bool32 pipelineBinaries_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineBinaries = pipelineBinaries_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePipelineBinaryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineBinaryFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineBinaryFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineBinaryFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineBinaries ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelineBinaryFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBinaries == rhs.pipelineBinaries ); +# endif + } + + bool operator!=( PhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePipelineBinaryFeaturesKHR; + void * pNext = {}; + Bool32 pipelineBinaries = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePipelineBinaryFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePipelineBinaryFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDevicePipelineBinaryPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineBinaryPropertiesKHR.html + struct PhysicalDevicePipelineBinaryPropertiesKHR + { + using NativeType = VkPhysicalDevicePipelineBinaryPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineBinaryPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineBinaryPropertiesKHR( Bool32 pipelineBinaryInternalCache_ = {}, + Bool32 pipelineBinaryInternalCacheControl_ = {}, + Bool32 pipelineBinaryPrefersInternalCache_ = {}, + Bool32 pipelineBinaryPrecompiledInternalCache_ = {}, + Bool32 pipelineBinaryCompressedData_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineBinaryInternalCache{ pipelineBinaryInternalCache_ } + , pipelineBinaryInternalCacheControl{ pipelineBinaryInternalCacheControl_ } + , pipelineBinaryPrefersInternalCache{ pipelineBinaryPrefersInternalCache_ } + , pipelineBinaryPrecompiledInternalCache{ pipelineBinaryPrecompiledInternalCache_ } + , pipelineBinaryCompressedData{ pipelineBinaryCompressedData_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineBinaryPropertiesKHR( PhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelineBinaryPropertiesKHR( VkPhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelineBinaryPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelineBinaryPropertiesKHR & operator=( PhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelineBinaryPropertiesKHR & operator=( VkPhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDevicePipelineBinaryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineBinaryPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineBinaryPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineBinaryPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + pipelineBinaryInternalCache, + pipelineBinaryInternalCacheControl, + pipelineBinaryPrefersInternalCache, + pipelineBinaryPrecompiledInternalCache, + pipelineBinaryCompressedData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelineBinaryPropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBinaryInternalCache == rhs.pipelineBinaryInternalCache ) && + ( pipelineBinaryInternalCacheControl == rhs.pipelineBinaryInternalCacheControl ) && + ( pipelineBinaryPrefersInternalCache == rhs.pipelineBinaryPrefersInternalCache ) && + ( pipelineBinaryPrecompiledInternalCache == rhs.pipelineBinaryPrecompiledInternalCache ) && + ( pipelineBinaryCompressedData == rhs.pipelineBinaryCompressedData ); +# endif + } + + bool operator!=( PhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePipelineBinaryPropertiesKHR; + void * pNext = {}; + Bool32 pipelineBinaryInternalCache = {}; + Bool32 pipelineBinaryInternalCacheControl = {}; + Bool32 pipelineBinaryPrefersInternalCache = {}; + Bool32 pipelineBinaryPrecompiledInternalCache = {}; + Bool32 pipelineBinaryCompressedData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePipelineBinaryPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePipelineBinaryPropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC.html + struct PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC + { + using NativeType = VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC( Bool32 pipelineCacheIncrementalMode_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineCacheIncrementalMode{ pipelineCacheIncrementalMode_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC( PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC( VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC & + operator=( PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC & operator=( VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC & setPipelineCacheIncrementalMode( Bool32 pipelineCacheIncrementalMode_ ) & + VULKAN_HPP_NOEXCEPT + { + pipelineCacheIncrementalMode = pipelineCacheIncrementalMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC && setPipelineCacheIncrementalMode( Bool32 pipelineCacheIncrementalMode_ ) && + VULKAN_HPP_NOEXCEPT + { + pipelineCacheIncrementalMode = pipelineCacheIncrementalMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineCacheIncrementalMode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & ) const = default; +#else + bool operator==( PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineCacheIncrementalMode == rhs.pipelineCacheIncrementalMode ); +# endif + } + + bool operator!=( PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; + void * pNext = {}; + Bool32 pipelineCacheIncrementalMode = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; + }; + + // wrapper struct for struct VkPhysicalDevicePipelineCreationCacheControlFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineCreationCacheControlFeatures.html + struct PhysicalDevicePipelineCreationCacheControlFeatures + { + using NativeType = VkPhysicalDevicePipelineCreationCacheControlFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineCreationCacheControlFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineCreationCacheControlFeatures( Bool32 pipelineCreationCacheControl_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineCreationCacheControl{ pipelineCreationCacheControl_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePipelineCreationCacheControlFeatures( PhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelineCreationCacheControlFeatures( VkPhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelineCreationCacheControlFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelineCreationCacheControlFeatures & + operator=( PhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelineCreationCacheControlFeatures & operator=( VkPhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCreationCacheControlFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCreationCacheControlFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCreationCacheControlFeatures & setPipelineCreationCacheControl( Bool32 pipelineCreationCacheControl_ ) & + VULKAN_HPP_NOEXCEPT + { + pipelineCreationCacheControl = pipelineCreationCacheControl_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCreationCacheControlFeatures && setPipelineCreationCacheControl( Bool32 pipelineCreationCacheControl_ ) && + VULKAN_HPP_NOEXCEPT + { + pipelineCreationCacheControl = pipelineCreationCacheControl_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePipelineCreationCacheControlFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineCreationCacheControlFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineCreationCacheControlFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineCreationCacheControlFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineCreationCacheControl ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelineCreationCacheControlFeatures const & ) const = default; +#else + bool operator==( PhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineCreationCacheControl == rhs.pipelineCreationCacheControl ); +# endif + } + + bool operator!=( PhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePipelineCreationCacheControlFeatures; + void * pNext = {}; + Bool32 pipelineCreationCacheControl = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePipelineCreationCacheControlFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePipelineCreationCacheControlFeatures; + }; + + using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures; + + // wrapper struct for struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html + struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR + { + using NativeType = VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( Bool32 pipelineExecutableInfo_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineExecutableInfo{ pipelineExecutableInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & + operator=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineExecutablePropertiesFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & setPipelineExecutableInfo( Bool32 pipelineExecutableInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pipelineExecutableInfo = pipelineExecutableInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineExecutablePropertiesFeaturesKHR && setPipelineExecutableInfo( Bool32 pipelineExecutableInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pipelineExecutableInfo = pipelineExecutableInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineExecutableInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineExecutableInfo == rhs.pipelineExecutableInfo ); +# endif + } + + bool operator!=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + void * pNext = {}; + Bool32 pipelineExecutableInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.html + struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT + { + using NativeType = VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( Bool32 pipelineLibraryGroupHandles_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineLibraryGroupHandles{ pipelineLibraryGroupHandles_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT & + operator=( PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT & operator=( VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT & setPipelineLibraryGroupHandles( Bool32 pipelineLibraryGroupHandles_ ) & + VULKAN_HPP_NOEXCEPT + { + pipelineLibraryGroupHandles = pipelineLibraryGroupHandles_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT && setPipelineLibraryGroupHandles( Bool32 pipelineLibraryGroupHandles_ ) && + VULKAN_HPP_NOEXCEPT + { + pipelineLibraryGroupHandles = pipelineLibraryGroupHandles_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineLibraryGroupHandles ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineLibraryGroupHandles == rhs.pipelineLibraryGroupHandles ); +# endif + } + + bool operator!=( PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + void * pNext = {}; + Bool32 pipelineLibraryGroupHandles = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.html + struct PhysicalDevicePipelineOpacityMicromapFeaturesARM + { + using NativeType = VkPhysicalDevicePipelineOpacityMicromapFeaturesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineOpacityMicromapFeaturesARM( Bool32 pipelineOpacityMicromap_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineOpacityMicromap{ pipelineOpacityMicromap_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePipelineOpacityMicromapFeaturesARM( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelineOpacityMicromapFeaturesARM( VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelineOpacityMicromapFeaturesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelineOpacityMicromapFeaturesARM & operator=( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelineOpacityMicromapFeaturesARM & operator=( VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineOpacityMicromapFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineOpacityMicromapFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineOpacityMicromapFeaturesARM & setPipelineOpacityMicromap( Bool32 pipelineOpacityMicromap_ ) & + VULKAN_HPP_NOEXCEPT + { + pipelineOpacityMicromap = pipelineOpacityMicromap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineOpacityMicromapFeaturesARM && setPipelineOpacityMicromap( Bool32 pipelineOpacityMicromap_ ) && + VULKAN_HPP_NOEXCEPT + { + pipelineOpacityMicromap = pipelineOpacityMicromap_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineOpacityMicromapFeaturesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineOpacityMicromap ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineOpacityMicromap == rhs.pipelineOpacityMicromap ); +# endif + } + + bool operator!=( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM; + void * pNext = {}; + Bool32 pipelineOpacityMicromap = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePipelineOpacityMicromapFeaturesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePipelineOpacityMicromapFeaturesARM; + }; + + // wrapper struct for struct VkPhysicalDevicePipelinePropertiesFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelinePropertiesFeaturesEXT.html + struct PhysicalDevicePipelinePropertiesFeaturesEXT + { + using NativeType = VkPhysicalDevicePipelinePropertiesFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelinePropertiesFeaturesEXT( Bool32 pipelinePropertiesIdentifier_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelinePropertiesIdentifier{ pipelinePropertiesIdentifier_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelinePropertiesFeaturesEXT( PhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelinePropertiesFeaturesEXT( VkPhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelinePropertiesFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelinePropertiesFeaturesEXT & operator=( PhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelinePropertiesFeaturesEXT & operator=( VkPhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelinePropertiesFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelinePropertiesFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelinePropertiesFeaturesEXT & setPipelinePropertiesIdentifier( Bool32 pipelinePropertiesIdentifier_ ) & + VULKAN_HPP_NOEXCEPT + { + pipelinePropertiesIdentifier = pipelinePropertiesIdentifier_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelinePropertiesFeaturesEXT && setPipelinePropertiesIdentifier( Bool32 pipelinePropertiesIdentifier_ ) && + VULKAN_HPP_NOEXCEPT + { + pipelinePropertiesIdentifier = pipelinePropertiesIdentifier_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePipelinePropertiesFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelinePropertiesFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelinePropertiesFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelinePropertiesFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelinePropertiesIdentifier ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelinePropertiesFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelinePropertiesIdentifier == rhs.pipelinePropertiesIdentifier ); +# endif + } + + bool operator!=( PhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT; + void * pNext = {}; + Bool32 pipelinePropertiesIdentifier = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePipelinePropertiesFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePipelinePropertiesFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDevicePipelineProtectedAccessFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineProtectedAccessFeatures.html + struct PhysicalDevicePipelineProtectedAccessFeatures + { + using NativeType = VkPhysicalDevicePipelineProtectedAccessFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineProtectedAccessFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineProtectedAccessFeatures( Bool32 pipelineProtectedAccess_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineProtectedAccess{ pipelineProtectedAccess_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePipelineProtectedAccessFeatures( PhysicalDevicePipelineProtectedAccessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelineProtectedAccessFeatures( VkPhysicalDevicePipelineProtectedAccessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelineProtectedAccessFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelineProtectedAccessFeatures & operator=( PhysicalDevicePipelineProtectedAccessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelineProtectedAccessFeatures & operator=( VkPhysicalDevicePipelineProtectedAccessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineProtectedAccessFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineProtectedAccessFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineProtectedAccessFeatures & setPipelineProtectedAccess( Bool32 pipelineProtectedAccess_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineProtectedAccess = pipelineProtectedAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineProtectedAccessFeatures && setPipelineProtectedAccess( Bool32 pipelineProtectedAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + pipelineProtectedAccess = pipelineProtectedAccess_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePipelineProtectedAccessFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineProtectedAccessFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineProtectedAccessFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineProtectedAccessFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineProtectedAccess ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelineProtectedAccessFeatures const & ) const = default; +#else + bool operator==( PhysicalDevicePipelineProtectedAccessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineProtectedAccess == rhs.pipelineProtectedAccess ); +# endif + } + + bool operator!=( PhysicalDevicePipelineProtectedAccessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePipelineProtectedAccessFeatures; + void * pNext = {}; + Bool32 pipelineProtectedAccess = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePipelineProtectedAccessFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePipelineProtectedAccessFeatures; + }; + + using PhysicalDevicePipelineProtectedAccessFeaturesEXT = PhysicalDevicePipelineProtectedAccessFeatures; + + // wrapper struct for struct VkPhysicalDevicePipelineRobustnessFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineRobustnessFeatures.html + struct PhysicalDevicePipelineRobustnessFeatures + { + using NativeType = VkPhysicalDevicePipelineRobustnessFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineRobustnessFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineRobustnessFeatures( Bool32 pipelineRobustness_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineRobustness{ pipelineRobustness_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineRobustnessFeatures( PhysicalDevicePipelineRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelineRobustnessFeatures( VkPhysicalDevicePipelineRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelineRobustnessFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelineRobustnessFeatures & operator=( PhysicalDevicePipelineRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelineRobustnessFeatures & operator=( VkPhysicalDevicePipelineRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineRobustnessFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineRobustnessFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineRobustnessFeatures & setPipelineRobustness( Bool32 pipelineRobustness_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineRobustness = pipelineRobustness_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineRobustnessFeatures && setPipelineRobustness( Bool32 pipelineRobustness_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineRobustness = pipelineRobustness_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePipelineRobustnessFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineRobustnessFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineRobustnessFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineRobustnessFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineRobustness ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelineRobustnessFeatures const & ) const = default; +#else + bool operator==( PhysicalDevicePipelineRobustnessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineRobustness == rhs.pipelineRobustness ); +# endif + } + + bool operator!=( PhysicalDevicePipelineRobustnessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePipelineRobustnessFeatures; + void * pNext = {}; + Bool32 pipelineRobustness = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePipelineRobustnessFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePipelineRobustnessFeatures; + }; + + using PhysicalDevicePipelineRobustnessFeaturesEXT = PhysicalDevicePipelineRobustnessFeatures; + + // wrapper struct for struct VkPhysicalDevicePipelineRobustnessProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineRobustnessProperties.html + struct PhysicalDevicePipelineRobustnessProperties + { + using NativeType = VkPhysicalDevicePipelineRobustnessProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineRobustnessProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineRobustnessProperties( + PipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, + PipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, + PipelineRobustnessBufferBehavior defaultRobustnessVertexInputs_ = PipelineRobustnessBufferBehavior::eDeviceDefault, + PipelineRobustnessImageBehavior defaultRobustnessImages_ = PipelineRobustnessImageBehavior::eDeviceDefault, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , defaultRobustnessStorageBuffers{ defaultRobustnessStorageBuffers_ } + , defaultRobustnessUniformBuffers{ defaultRobustnessUniformBuffers_ } + , defaultRobustnessVertexInputs{ defaultRobustnessVertexInputs_ } + , defaultRobustnessImages{ defaultRobustnessImages_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineRobustnessProperties( PhysicalDevicePipelineRobustnessProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePipelineRobustnessProperties( VkPhysicalDevicePipelineRobustnessProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePipelineRobustnessProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePipelineRobustnessProperties & operator=( PhysicalDevicePipelineRobustnessProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePipelineRobustnessProperties & operator=( VkPhysicalDevicePipelineRobustnessProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDevicePipelineRobustnessProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineRobustnessProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineRobustnessProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePipelineRobustnessProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, defaultRobustnessStorageBuffers, defaultRobustnessUniformBuffers, defaultRobustnessVertexInputs, defaultRobustnessImages ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePipelineRobustnessProperties const & ) const = default; +#else + bool operator==( PhysicalDevicePipelineRobustnessProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( defaultRobustnessStorageBuffers == rhs.defaultRobustnessStorageBuffers ) && + ( defaultRobustnessUniformBuffers == rhs.defaultRobustnessUniformBuffers ) && + ( defaultRobustnessVertexInputs == rhs.defaultRobustnessVertexInputs ) && ( defaultRobustnessImages == rhs.defaultRobustnessImages ); +# endif + } + + bool operator!=( PhysicalDevicePipelineRobustnessProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePipelineRobustnessProperties; + void * pNext = {}; + PipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; + PipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; + PipelineRobustnessBufferBehavior defaultRobustnessVertexInputs = PipelineRobustnessBufferBehavior::eDeviceDefault; + PipelineRobustnessImageBehavior defaultRobustnessImages = PipelineRobustnessImageBehavior::eDeviceDefault; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePipelineRobustnessProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePipelineRobustnessProperties; + }; + + using PhysicalDevicePipelineRobustnessPropertiesEXT = PhysicalDevicePipelineRobustnessProperties; + + // wrapper struct for struct VkPhysicalDevicePointClippingProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePointClippingProperties.html + struct PhysicalDevicePointClippingProperties + { + using NativeType = VkPhysicalDevicePointClippingProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePointClippingProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePointClippingProperties( PointClippingBehavior pointClippingBehavior_ = PointClippingBehavior::eAllClipPlanes, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pointClippingBehavior{ pointClippingBehavior_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePointClippingProperties( PhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePointClippingProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePointClippingProperties & operator=( PhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePointClippingProperties & operator=( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDevicePointClippingProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePointClippingProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePointClippingProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePointClippingProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pointClippingBehavior ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePointClippingProperties const & ) const = default; +#else + bool operator==( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pointClippingBehavior == rhs.pointClippingBehavior ); +# endif + } + + bool operator!=( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePointClippingProperties; + void * pNext = {}; + PointClippingBehavior pointClippingBehavior = PointClippingBehavior::eAllClipPlanes; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePointClippingProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePointClippingProperties; + }; + + using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkPhysicalDevicePortabilitySubsetFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html + struct PhysicalDevicePortabilitySubsetFeaturesKHR + { + using NativeType = VkPhysicalDevicePortabilitySubsetFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePortabilitySubsetFeaturesKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePortabilitySubsetFeaturesKHR( Bool32 constantAlphaColorBlendFactors_ = {}, + Bool32 events_ = {}, + Bool32 imageViewFormatReinterpretation_ = {}, + Bool32 imageViewFormatSwizzle_ = {}, + Bool32 imageView2DOn3DImage_ = {}, + Bool32 multisampleArrayImage_ = {}, + Bool32 mutableComparisonSamplers_ = {}, + Bool32 pointPolygons_ = {}, + Bool32 samplerMipLodBias_ = {}, + Bool32 separateStencilMaskRef_ = {}, + Bool32 shaderSampleRateInterpolationFunctions_ = {}, + Bool32 tessellationIsolines_ = {}, + Bool32 tessellationPointMode_ = {}, + Bool32 triangleFans_ = {}, + Bool32 vertexAttributeAccessBeyondStride_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , constantAlphaColorBlendFactors{ constantAlphaColorBlendFactors_ } + , events{ events_ } + , imageViewFormatReinterpretation{ imageViewFormatReinterpretation_ } + , imageViewFormatSwizzle{ imageViewFormatSwizzle_ } + , imageView2DOn3DImage{ imageView2DOn3DImage_ } + , multisampleArrayImage{ multisampleArrayImage_ } + , mutableComparisonSamplers{ mutableComparisonSamplers_ } + , pointPolygons{ pointPolygons_ } + , samplerMipLodBias{ samplerMipLodBias_ } + , separateStencilMaskRef{ separateStencilMaskRef_ } + , shaderSampleRateInterpolationFunctions{ shaderSampleRateInterpolationFunctions_ } + , tessellationIsolines{ tessellationIsolines_ } + , tessellationPointMode{ tessellationPointMode_ } + , triangleFans{ triangleFans_ } + , vertexAttributeAccessBeyondStride{ vertexAttributeAccessBeyondStride_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePortabilitySubsetFeaturesKHR( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePortabilitySubsetFeaturesKHR( VkPhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePortabilitySubsetFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePortabilitySubsetFeaturesKHR & operator=( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePortabilitySubsetFeaturesKHR & operator=( VkPhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setConstantAlphaColorBlendFactors( Bool32 constantAlphaColorBlendFactors_ ) & + VULKAN_HPP_NOEXCEPT + { + constantAlphaColorBlendFactors = constantAlphaColorBlendFactors_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setConstantAlphaColorBlendFactors( Bool32 constantAlphaColorBlendFactors_ ) && + VULKAN_HPP_NOEXCEPT + { + constantAlphaColorBlendFactors = constantAlphaColorBlendFactors_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setEvents( Bool32 events_ ) & VULKAN_HPP_NOEXCEPT + { + events = events_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setEvents( Bool32 events_ ) && VULKAN_HPP_NOEXCEPT + { + events = events_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setImageViewFormatReinterpretation( Bool32 imageViewFormatReinterpretation_ ) & + VULKAN_HPP_NOEXCEPT + { + imageViewFormatReinterpretation = imageViewFormatReinterpretation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setImageViewFormatReinterpretation( Bool32 imageViewFormatReinterpretation_ ) && + VULKAN_HPP_NOEXCEPT + { + imageViewFormatReinterpretation = imageViewFormatReinterpretation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setImageViewFormatSwizzle( Bool32 imageViewFormatSwizzle_ ) & VULKAN_HPP_NOEXCEPT + { + imageViewFormatSwizzle = imageViewFormatSwizzle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setImageViewFormatSwizzle( Bool32 imageViewFormatSwizzle_ ) && VULKAN_HPP_NOEXCEPT + { + imageViewFormatSwizzle = imageViewFormatSwizzle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setImageView2DOn3DImage( Bool32 imageView2DOn3DImage_ ) & VULKAN_HPP_NOEXCEPT + { + imageView2DOn3DImage = imageView2DOn3DImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setImageView2DOn3DImage( Bool32 imageView2DOn3DImage_ ) && VULKAN_HPP_NOEXCEPT + { + imageView2DOn3DImage = imageView2DOn3DImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setMultisampleArrayImage( Bool32 multisampleArrayImage_ ) & VULKAN_HPP_NOEXCEPT + { + multisampleArrayImage = multisampleArrayImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setMultisampleArrayImage( Bool32 multisampleArrayImage_ ) && VULKAN_HPP_NOEXCEPT + { + multisampleArrayImage = multisampleArrayImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setMutableComparisonSamplers( Bool32 mutableComparisonSamplers_ ) & VULKAN_HPP_NOEXCEPT + { + mutableComparisonSamplers = mutableComparisonSamplers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setMutableComparisonSamplers( Bool32 mutableComparisonSamplers_ ) && + VULKAN_HPP_NOEXCEPT + { + mutableComparisonSamplers = mutableComparisonSamplers_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setPointPolygons( Bool32 pointPolygons_ ) & VULKAN_HPP_NOEXCEPT + { + pointPolygons = pointPolygons_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setPointPolygons( Bool32 pointPolygons_ ) && VULKAN_HPP_NOEXCEPT + { + pointPolygons = pointPolygons_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setSamplerMipLodBias( Bool32 samplerMipLodBias_ ) & VULKAN_HPP_NOEXCEPT + { + samplerMipLodBias = samplerMipLodBias_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setSamplerMipLodBias( Bool32 samplerMipLodBias_ ) && VULKAN_HPP_NOEXCEPT + { + samplerMipLodBias = samplerMipLodBias_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setSeparateStencilMaskRef( Bool32 separateStencilMaskRef_ ) & VULKAN_HPP_NOEXCEPT + { + separateStencilMaskRef = separateStencilMaskRef_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setSeparateStencilMaskRef( Bool32 separateStencilMaskRef_ ) && VULKAN_HPP_NOEXCEPT + { + separateStencilMaskRef = separateStencilMaskRef_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & + setShaderSampleRateInterpolationFunctions( Bool32 shaderSampleRateInterpolationFunctions_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSampleRateInterpolationFunctions = shaderSampleRateInterpolationFunctions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && + setShaderSampleRateInterpolationFunctions( Bool32 shaderSampleRateInterpolationFunctions_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSampleRateInterpolationFunctions = shaderSampleRateInterpolationFunctions_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setTessellationIsolines( Bool32 tessellationIsolines_ ) & VULKAN_HPP_NOEXCEPT + { + tessellationIsolines = tessellationIsolines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setTessellationIsolines( Bool32 tessellationIsolines_ ) && VULKAN_HPP_NOEXCEPT + { + tessellationIsolines = tessellationIsolines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setTessellationPointMode( Bool32 tessellationPointMode_ ) & VULKAN_HPP_NOEXCEPT + { + tessellationPointMode = tessellationPointMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setTessellationPointMode( Bool32 tessellationPointMode_ ) && VULKAN_HPP_NOEXCEPT + { + tessellationPointMode = tessellationPointMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setTriangleFans( Bool32 triangleFans_ ) & VULKAN_HPP_NOEXCEPT + { + triangleFans = triangleFans_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setTriangleFans( Bool32 triangleFans_ ) && VULKAN_HPP_NOEXCEPT + { + triangleFans = triangleFans_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setVertexAttributeAccessBeyondStride( Bool32 vertexAttributeAccessBeyondStride_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexAttributeAccessBeyondStride = vertexAttributeAccessBeyondStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setVertexAttributeAccessBeyondStride( Bool32 vertexAttributeAccessBeyondStride_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexAttributeAccessBeyondStride = vertexAttributeAccessBeyondStride_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePortabilitySubsetFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePortabilitySubsetFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePortabilitySubsetFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePortabilitySubsetFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + constantAlphaColorBlendFactors, + events, + imageViewFormatReinterpretation, + imageViewFormatSwizzle, + imageView2DOn3DImage, + multisampleArrayImage, + mutableComparisonSamplers, + pointPolygons, + samplerMipLodBias, + separateStencilMaskRef, + shaderSampleRateInterpolationFunctions, + tessellationIsolines, + tessellationPointMode, + triangleFans, + vertexAttributeAccessBeyondStride ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePortabilitySubsetFeaturesKHR const & ) const = default; +# else + bool operator==( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantAlphaColorBlendFactors == rhs.constantAlphaColorBlendFactors ) && + ( events == rhs.events ) && ( imageViewFormatReinterpretation == rhs.imageViewFormatReinterpretation ) && + ( imageViewFormatSwizzle == rhs.imageViewFormatSwizzle ) && ( imageView2DOn3DImage == rhs.imageView2DOn3DImage ) && + ( multisampleArrayImage == rhs.multisampleArrayImage ) && ( mutableComparisonSamplers == rhs.mutableComparisonSamplers ) && + ( pointPolygons == rhs.pointPolygons ) && ( samplerMipLodBias == rhs.samplerMipLodBias ) && + ( separateStencilMaskRef == rhs.separateStencilMaskRef ) && + ( shaderSampleRateInterpolationFunctions == rhs.shaderSampleRateInterpolationFunctions ) && ( tessellationIsolines == rhs.tessellationIsolines ) && + ( tessellationPointMode == rhs.tessellationPointMode ) && ( triangleFans == rhs.triangleFans ) && + ( vertexAttributeAccessBeyondStride == rhs.vertexAttributeAccessBeyondStride ); +# endif + } + + bool operator!=( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDevicePortabilitySubsetFeaturesKHR; + void * pNext = {}; + Bool32 constantAlphaColorBlendFactors = {}; + Bool32 events = {}; + Bool32 imageViewFormatReinterpretation = {}; + Bool32 imageViewFormatSwizzle = {}; + Bool32 imageView2DOn3DImage = {}; + Bool32 multisampleArrayImage = {}; + Bool32 mutableComparisonSamplers = {}; + Bool32 pointPolygons = {}; + Bool32 samplerMipLodBias = {}; + Bool32 separateStencilMaskRef = {}; + Bool32 shaderSampleRateInterpolationFunctions = {}; + Bool32 tessellationIsolines = {}; + Bool32 tessellationPointMode = {}; + Bool32 triangleFans = {}; + Bool32 vertexAttributeAccessBeyondStride = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePortabilitySubsetFeaturesKHR; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDevicePortabilitySubsetFeaturesKHR; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkPhysicalDevicePortabilitySubsetPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePortabilitySubsetPropertiesKHR.html + struct PhysicalDevicePortabilitySubsetPropertiesKHR + { + using NativeType = VkPhysicalDevicePortabilitySubsetPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePortabilitySubsetPropertiesKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePortabilitySubsetPropertiesKHR( uint32_t minVertexInputBindingStrideAlignment_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minVertexInputBindingStrideAlignment{ minVertexInputBindingStrideAlignment_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePortabilitySubsetPropertiesKHR( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePortabilitySubsetPropertiesKHR( VkPhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePortabilitySubsetPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePortabilitySubsetPropertiesKHR & operator=( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePortabilitySubsetPropertiesKHR & operator=( VkPhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDevicePortabilitySubsetPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePortabilitySubsetPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePortabilitySubsetPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePortabilitySubsetPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minVertexInputBindingStrideAlignment ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePortabilitySubsetPropertiesKHR const & ) const = default; +# else + bool operator==( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minVertexInputBindingStrideAlignment == rhs.minVertexInputBindingStrideAlignment ); +# endif + } + + bool operator!=( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDevicePortabilitySubsetPropertiesKHR; + void * pNext = {}; + uint32_t minVertexInputBindingStrideAlignment = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePortabilitySubsetPropertiesKHR; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDevicePortabilitySubsetPropertiesKHR; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkPhysicalDevicePresentBarrierFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentBarrierFeaturesNV.html + struct PhysicalDevicePresentBarrierFeaturesNV + { + using NativeType = VkPhysicalDevicePresentBarrierFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentBarrierFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentBarrierFeaturesNV( Bool32 presentBarrier_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentBarrier{ presentBarrier_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentBarrierFeaturesNV( PhysicalDevicePresentBarrierFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePresentBarrierFeaturesNV( VkPhysicalDevicePresentBarrierFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePresentBarrierFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePresentBarrierFeaturesNV & operator=( PhysicalDevicePresentBarrierFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePresentBarrierFeaturesNV & operator=( VkPhysicalDevicePresentBarrierFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentBarrierFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentBarrierFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentBarrierFeaturesNV & setPresentBarrier( Bool32 presentBarrier_ ) & VULKAN_HPP_NOEXCEPT + { + presentBarrier = presentBarrier_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentBarrierFeaturesNV && setPresentBarrier( Bool32 presentBarrier_ ) && VULKAN_HPP_NOEXCEPT + { + presentBarrier = presentBarrier_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePresentBarrierFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentBarrierFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentBarrierFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentBarrierFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentBarrier ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePresentBarrierFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDevicePresentBarrierFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentBarrier == rhs.presentBarrier ); +# endif + } + + bool operator!=( PhysicalDevicePresentBarrierFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePresentBarrierFeaturesNV; + void * pNext = {}; + Bool32 presentBarrier = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePresentBarrierFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePresentBarrierFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDevicePresentId2FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentId2FeaturesKHR.html + struct PhysicalDevicePresentId2FeaturesKHR + { + using NativeType = VkPhysicalDevicePresentId2FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentId2FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentId2FeaturesKHR( Bool32 presentId2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentId2{ presentId2_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentId2FeaturesKHR( PhysicalDevicePresentId2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePresentId2FeaturesKHR( VkPhysicalDevicePresentId2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePresentId2FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePresentId2FeaturesKHR & operator=( PhysicalDevicePresentId2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePresentId2FeaturesKHR & operator=( VkPhysicalDevicePresentId2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentId2FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentId2FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentId2FeaturesKHR & setPresentId2( Bool32 presentId2_ ) & VULKAN_HPP_NOEXCEPT + { + presentId2 = presentId2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentId2FeaturesKHR && setPresentId2( Bool32 presentId2_ ) && VULKAN_HPP_NOEXCEPT + { + presentId2 = presentId2_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePresentId2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentId2FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentId2FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentId2FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentId2 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePresentId2FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDevicePresentId2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId2 == rhs.presentId2 ); +# endif + } + + bool operator!=( PhysicalDevicePresentId2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePresentId2FeaturesKHR; + void * pNext = {}; + Bool32 presentId2 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePresentId2FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePresentId2FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDevicePresentIdFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html + struct PhysicalDevicePresentIdFeaturesKHR + { + using NativeType = VkPhysicalDevicePresentIdFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentIdFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentIdFeaturesKHR( Bool32 presentId_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentId{ presentId_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentIdFeaturesKHR( PhysicalDevicePresentIdFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePresentIdFeaturesKHR( VkPhysicalDevicePresentIdFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePresentIdFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePresentIdFeaturesKHR & operator=( PhysicalDevicePresentIdFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePresentIdFeaturesKHR & operator=( VkPhysicalDevicePresentIdFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentIdFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentIdFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentIdFeaturesKHR & setPresentId( Bool32 presentId_ ) & VULKAN_HPP_NOEXCEPT + { + presentId = presentId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentIdFeaturesKHR && setPresentId( Bool32 presentId_ ) && VULKAN_HPP_NOEXCEPT + { + presentId = presentId_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePresentIdFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentIdFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentIdFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentIdFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentId ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePresentIdFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId ); +# endif + } + + bool operator!=( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePresentIdFeaturesKHR; + void * pNext = {}; + Bool32 presentId = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePresentIdFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePresentIdFeaturesKHR; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkPhysicalDevicePresentMeteringFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentMeteringFeaturesNV.html + struct PhysicalDevicePresentMeteringFeaturesNV + { + using NativeType = VkPhysicalDevicePresentMeteringFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentMeteringFeaturesNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentMeteringFeaturesNV( Bool32 presentMetering_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentMetering{ presentMetering_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentMeteringFeaturesNV( PhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePresentMeteringFeaturesNV( VkPhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePresentMeteringFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePresentMeteringFeaturesNV & operator=( PhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePresentMeteringFeaturesNV & operator=( VkPhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentMeteringFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentMeteringFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentMeteringFeaturesNV & setPresentMetering( Bool32 presentMetering_ ) & VULKAN_HPP_NOEXCEPT + { + presentMetering = presentMetering_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentMeteringFeaturesNV && setPresentMetering( Bool32 presentMetering_ ) && VULKAN_HPP_NOEXCEPT + { + presentMetering = presentMetering_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePresentMeteringFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentMeteringFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentMeteringFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentMeteringFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentMetering ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePresentMeteringFeaturesNV const & ) const = default; +# else + bool operator==( PhysicalDevicePresentMeteringFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMetering == rhs.presentMetering ); +# endif + } + + bool operator!=( PhysicalDevicePresentMeteringFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDevicePresentMeteringFeaturesNV; + void * pNext = {}; + Bool32 presentMetering = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePresentMeteringFeaturesNV; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDevicePresentMeteringFeaturesNV; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR.html + struct PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR + { + using NativeType = VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR( Bool32 presentModeFifoLatestReady_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentModeFifoLatestReady{ presentModeFifoLatestReady_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR( PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR( VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR & + operator=( PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR & operator=( VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR & setPresentModeFifoLatestReady( Bool32 presentModeFifoLatestReady_ ) & + VULKAN_HPP_NOEXCEPT + { + presentModeFifoLatestReady = presentModeFifoLatestReady_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR && setPresentModeFifoLatestReady( Bool32 presentModeFifoLatestReady_ ) && + VULKAN_HPP_NOEXCEPT + { + presentModeFifoLatestReady = presentModeFifoLatestReady_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentModeFifoLatestReady ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeFifoLatestReady == rhs.presentModeFifoLatestReady ); +# endif + } + + bool operator!=( PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + void * pNext = {}; + Bool32 presentModeFifoLatestReady = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + }; + + using PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; + + // wrapper struct for struct VkPhysicalDevicePresentTimingFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentTimingFeaturesEXT.html + struct PhysicalDevicePresentTimingFeaturesEXT + { + using NativeType = VkPhysicalDevicePresentTimingFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentTimingFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentTimingFeaturesEXT( Bool32 presentTiming_ = {}, + Bool32 presentAtAbsoluteTime_ = {}, + Bool32 presentAtRelativeTime_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentTiming{ presentTiming_ } + , presentAtAbsoluteTime{ presentAtAbsoluteTime_ } + , presentAtRelativeTime{ presentAtRelativeTime_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentTimingFeaturesEXT( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePresentTimingFeaturesEXT( VkPhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePresentTimingFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePresentTimingFeaturesEXT & operator=( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePresentTimingFeaturesEXT & operator=( VkPhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPresentTiming( Bool32 presentTiming_ ) & VULKAN_HPP_NOEXCEPT + { + presentTiming = presentTiming_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT && setPresentTiming( Bool32 presentTiming_ ) && VULKAN_HPP_NOEXCEPT + { + presentTiming = presentTiming_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPresentAtAbsoluteTime( Bool32 presentAtAbsoluteTime_ ) & VULKAN_HPP_NOEXCEPT + { + presentAtAbsoluteTime = presentAtAbsoluteTime_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT && setPresentAtAbsoluteTime( Bool32 presentAtAbsoluteTime_ ) && VULKAN_HPP_NOEXCEPT + { + presentAtAbsoluteTime = presentAtAbsoluteTime_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPresentAtRelativeTime( Bool32 presentAtRelativeTime_ ) & VULKAN_HPP_NOEXCEPT + { + presentAtRelativeTime = presentAtRelativeTime_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT && setPresentAtRelativeTime( Bool32 presentAtRelativeTime_ ) && VULKAN_HPP_NOEXCEPT + { + presentAtRelativeTime = presentAtRelativeTime_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePresentTimingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentTimingFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentTimingFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentTimingFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentTiming, presentAtAbsoluteTime, presentAtRelativeTime ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePresentTimingFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentTiming == rhs.presentTiming ) && + ( presentAtAbsoluteTime == rhs.presentAtAbsoluteTime ) && ( presentAtRelativeTime == rhs.presentAtRelativeTime ); +# endif + } + + bool operator!=( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePresentTimingFeaturesEXT; + void * pNext = {}; + Bool32 presentTiming = {}; + Bool32 presentAtAbsoluteTime = {}; + Bool32 presentAtRelativeTime = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePresentTimingFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePresentTimingFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDevicePresentWait2FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentWait2FeaturesKHR.html + struct PhysicalDevicePresentWait2FeaturesKHR + { + using NativeType = VkPhysicalDevicePresentWait2FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentWait2FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentWait2FeaturesKHR( Bool32 presentWait2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentWait2{ presentWait2_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentWait2FeaturesKHR( PhysicalDevicePresentWait2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePresentWait2FeaturesKHR( VkPhysicalDevicePresentWait2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePresentWait2FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePresentWait2FeaturesKHR & operator=( PhysicalDevicePresentWait2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePresentWait2FeaturesKHR & operator=( VkPhysicalDevicePresentWait2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWait2FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWait2FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWait2FeaturesKHR & setPresentWait2( Bool32 presentWait2_ ) & VULKAN_HPP_NOEXCEPT + { + presentWait2 = presentWait2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWait2FeaturesKHR && setPresentWait2( Bool32 presentWait2_ ) && VULKAN_HPP_NOEXCEPT + { + presentWait2 = presentWait2_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePresentWait2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentWait2FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentWait2FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentWait2FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentWait2 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePresentWait2FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDevicePresentWait2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait2 == rhs.presentWait2 ); +# endif + } + + bool operator!=( PhysicalDevicePresentWait2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePresentWait2FeaturesKHR; + void * pNext = {}; + Bool32 presentWait2 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePresentWait2FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePresentWait2FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDevicePresentWaitFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html + struct PhysicalDevicePresentWaitFeaturesKHR + { + using NativeType = VkPhysicalDevicePresentWaitFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentWaitFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentWaitFeaturesKHR( Bool32 presentWait_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentWait{ presentWait_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePresentWaitFeaturesKHR( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePresentWaitFeaturesKHR( VkPhysicalDevicePresentWaitFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePresentWaitFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePresentWaitFeaturesKHR & operator=( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePresentWaitFeaturesKHR & operator=( VkPhysicalDevicePresentWaitFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWaitFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWaitFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWaitFeaturesKHR & setPresentWait( Bool32 presentWait_ ) & VULKAN_HPP_NOEXCEPT + { + presentWait = presentWait_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWaitFeaturesKHR && setPresentWait( Bool32 presentWait_ ) && VULKAN_HPP_NOEXCEPT + { + presentWait = presentWait_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePresentWaitFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentWaitFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentWaitFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePresentWaitFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentWait ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePresentWaitFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait == rhs.presentWait ); +# endif + } + + bool operator!=( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePresentWaitFeaturesKHR; + void * pNext = {}; + Bool32 presentWait = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePresentWaitFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePresentWaitFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.html + struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT + { + using NativeType = VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( Bool32 primitiveTopologyListRestart_ = {}, + Bool32 primitiveTopologyPatchListRestart_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , primitiveTopologyListRestart{ primitiveTopologyListRestart_ } + , primitiveTopologyPatchListRestart{ primitiveTopologyPatchListRestart_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT & + operator=( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT & operator=( VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT & setPrimitiveTopologyListRestart( Bool32 primitiveTopologyListRestart_ ) & + VULKAN_HPP_NOEXCEPT + { + primitiveTopologyListRestart = primitiveTopologyListRestart_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT && setPrimitiveTopologyListRestart( Bool32 primitiveTopologyListRestart_ ) && + VULKAN_HPP_NOEXCEPT + { + primitiveTopologyListRestart = primitiveTopologyListRestart_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT & + setPrimitiveTopologyPatchListRestart( Bool32 primitiveTopologyPatchListRestart_ ) & + VULKAN_HPP_NOEXCEPT + { + primitiveTopologyPatchListRestart = primitiveTopologyPatchListRestart_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT && + setPrimitiveTopologyPatchListRestart( Bool32 primitiveTopologyPatchListRestart_ ) && + VULKAN_HPP_NOEXCEPT + { + primitiveTopologyPatchListRestart = primitiveTopologyPatchListRestart_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, primitiveTopologyListRestart, primitiveTopologyPatchListRestart ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( primitiveTopologyListRestart == rhs.primitiveTopologyListRestart ) && + ( primitiveTopologyPatchListRestart == rhs.primitiveTopologyPatchListRestart ); +# endif + } + + bool operator!=( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + void * pNext = {}; + Bool32 primitiveTopologyListRestart = {}; + Bool32 primitiveTopologyPatchListRestart = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.html + struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT + { + using NativeType = VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT( Bool32 primitivesGeneratedQuery_ = {}, + Bool32 primitivesGeneratedQueryWithRasterizerDiscard_ = {}, + Bool32 primitivesGeneratedQueryWithNonZeroStreams_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , primitivesGeneratedQuery{ primitivesGeneratedQuery_ } + , primitivesGeneratedQueryWithRasterizerDiscard{ primitivesGeneratedQueryWithRasterizerDiscard_ } + , primitivesGeneratedQueryWithNonZeroStreams{ primitivesGeneratedQueryWithNonZeroStreams_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT( PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT( VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & + operator=( PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & operator=( VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & setPrimitivesGeneratedQuery( Bool32 primitivesGeneratedQuery_ ) & + VULKAN_HPP_NOEXCEPT + { + primitivesGeneratedQuery = primitivesGeneratedQuery_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT && setPrimitivesGeneratedQuery( Bool32 primitivesGeneratedQuery_ ) && + VULKAN_HPP_NOEXCEPT + { + primitivesGeneratedQuery = primitivesGeneratedQuery_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & + setPrimitivesGeneratedQueryWithRasterizerDiscard( Bool32 primitivesGeneratedQueryWithRasterizerDiscard_ ) & + VULKAN_HPP_NOEXCEPT + { + primitivesGeneratedQueryWithRasterizerDiscard = primitivesGeneratedQueryWithRasterizerDiscard_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT && + setPrimitivesGeneratedQueryWithRasterizerDiscard( Bool32 primitivesGeneratedQueryWithRasterizerDiscard_ ) && + VULKAN_HPP_NOEXCEPT + { + primitivesGeneratedQueryWithRasterizerDiscard = primitivesGeneratedQueryWithRasterizerDiscard_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & + setPrimitivesGeneratedQueryWithNonZeroStreams( Bool32 primitivesGeneratedQueryWithNonZeroStreams_ ) & + VULKAN_HPP_NOEXCEPT + { + primitivesGeneratedQueryWithNonZeroStreams = primitivesGeneratedQueryWithNonZeroStreams_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT && + setPrimitivesGeneratedQueryWithNonZeroStreams( Bool32 primitivesGeneratedQueryWithNonZeroStreams_ ) && + VULKAN_HPP_NOEXCEPT + { + primitivesGeneratedQueryWithNonZeroStreams = primitivesGeneratedQueryWithNonZeroStreams_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, primitivesGeneratedQuery, primitivesGeneratedQueryWithRasterizerDiscard, primitivesGeneratedQueryWithNonZeroStreams ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( primitivesGeneratedQuery == rhs.primitivesGeneratedQuery ) && + ( primitivesGeneratedQueryWithRasterizerDiscard == rhs.primitivesGeneratedQueryWithRasterizerDiscard ) && + ( primitivesGeneratedQueryWithNonZeroStreams == rhs.primitivesGeneratedQueryWithNonZeroStreams ); +# endif + } + + bool operator!=( PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; + void * pNext = {}; + Bool32 primitivesGeneratedQuery = {}; + Bool32 primitivesGeneratedQueryWithRasterizerDiscard = {}; + Bool32 primitivesGeneratedQueryWithNonZeroStreams = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDevicePrivateDataFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePrivateDataFeatures.html + struct PhysicalDevicePrivateDataFeatures + { + using NativeType = VkPhysicalDevicePrivateDataFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePrivateDataFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePrivateDataFeatures( Bool32 privateData_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , privateData{ privateData_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePrivateDataFeatures( PhysicalDevicePrivateDataFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePrivateDataFeatures( VkPhysicalDevicePrivateDataFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePrivateDataFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePrivateDataFeatures & operator=( PhysicalDevicePrivateDataFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePrivateDataFeatures & operator=( VkPhysicalDevicePrivateDataFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataFeatures & setPrivateData( Bool32 privateData_ ) & VULKAN_HPP_NOEXCEPT + { + privateData = privateData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataFeatures && setPrivateData( Bool32 privateData_ ) && VULKAN_HPP_NOEXCEPT + { + privateData = privateData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePrivateDataFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePrivateDataFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePrivateDataFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePrivateDataFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, privateData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePrivateDataFeatures const & ) const = default; +#else + bool operator==( PhysicalDevicePrivateDataFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateData == rhs.privateData ); +# endif + } + + bool operator!=( PhysicalDevicePrivateDataFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePrivateDataFeatures; + void * pNext = {}; + Bool32 privateData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePrivateDataFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePrivateDataFeatures; + }; + + using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures; + + // wrapper struct for struct VkPhysicalDeviceProtectedMemoryFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProtectedMemoryFeatures.html + struct PhysicalDeviceProtectedMemoryFeatures + { + using NativeType = VkPhysicalDeviceProtectedMemoryFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( Bool32 protectedMemory_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , protectedMemory{ protectedMemory_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( PhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceProtectedMemoryFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceProtectedMemoryFeatures & operator=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceProtectedMemoryFeatures & operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProtectedMemoryFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProtectedMemoryFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProtectedMemoryFeatures & setProtectedMemory( Bool32 protectedMemory_ ) & VULKAN_HPP_NOEXCEPT + { + protectedMemory = protectedMemory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProtectedMemoryFeatures && setProtectedMemory( Bool32 protectedMemory_ ) && VULKAN_HPP_NOEXCEPT + { + protectedMemory = protectedMemory_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceProtectedMemoryFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProtectedMemoryFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProtectedMemoryFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProtectedMemoryFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, protectedMemory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceProtectedMemoryFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedMemory == rhs.protectedMemory ); +# endif + } + + bool operator!=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; + void * pNext = {}; + Bool32 protectedMemory = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceProtectedMemoryFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceProtectedMemoryFeatures; + }; + + // wrapper struct for struct VkPhysicalDeviceProtectedMemoryProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProtectedMemoryProperties.html + struct PhysicalDeviceProtectedMemoryProperties + { + using NativeType = VkPhysicalDeviceProtectedMemoryProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProtectedMemoryProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryProperties( Bool32 protectedNoFault_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , protectedNoFault{ protectedNoFault_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryProperties( PhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceProtectedMemoryProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceProtectedMemoryProperties & operator=( PhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceProtectedMemoryProperties & operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceProtectedMemoryProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProtectedMemoryProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProtectedMemoryProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProtectedMemoryProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, protectedNoFault ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceProtectedMemoryProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedNoFault == rhs.protectedNoFault ); +# endif + } + + bool operator!=( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties; + void * pNext = {}; + Bool32 protectedNoFault = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceProtectedMemoryProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceProtectedMemoryProperties; + }; + + // wrapper struct for struct VkPhysicalDeviceProvokingVertexFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProvokingVertexFeaturesEXT.html + struct PhysicalDeviceProvokingVertexFeaturesEXT + { + using NativeType = VkPhysicalDeviceProvokingVertexFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProvokingVertexFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceProvokingVertexFeaturesEXT( Bool32 provokingVertexLast_ = {}, + Bool32 transformFeedbackPreservesProvokingVertex_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , provokingVertexLast{ provokingVertexLast_ } + , transformFeedbackPreservesProvokingVertex{ transformFeedbackPreservesProvokingVertex_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceProvokingVertexFeaturesEXT( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceProvokingVertexFeaturesEXT( VkPhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceProvokingVertexFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceProvokingVertexFeaturesEXT & operator=( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceProvokingVertexFeaturesEXT & operator=( VkPhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT & setProvokingVertexLast( Bool32 provokingVertexLast_ ) & VULKAN_HPP_NOEXCEPT + { + provokingVertexLast = provokingVertexLast_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT && setProvokingVertexLast( Bool32 provokingVertexLast_ ) && VULKAN_HPP_NOEXCEPT + { + provokingVertexLast = provokingVertexLast_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT & + setTransformFeedbackPreservesProvokingVertex( Bool32 transformFeedbackPreservesProvokingVertex_ ) & + VULKAN_HPP_NOEXCEPT + { + transformFeedbackPreservesProvokingVertex = transformFeedbackPreservesProvokingVertex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT && + setTransformFeedbackPreservesProvokingVertex( Bool32 transformFeedbackPreservesProvokingVertex_ ) && + VULKAN_HPP_NOEXCEPT + { + transformFeedbackPreservesProvokingVertex = transformFeedbackPreservesProvokingVertex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceProvokingVertexFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProvokingVertexFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProvokingVertexFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProvokingVertexFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, provokingVertexLast, transformFeedbackPreservesProvokingVertex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceProvokingVertexFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexLast == rhs.provokingVertexLast ) && + ( transformFeedbackPreservesProvokingVertex == rhs.transformFeedbackPreservesProvokingVertex ); +# endif + } + + bool operator!=( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceProvokingVertexFeaturesEXT; + void * pNext = {}; + Bool32 provokingVertexLast = {}; + Bool32 transformFeedbackPreservesProvokingVertex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceProvokingVertexFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceProvokingVertexFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceProvokingVertexPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProvokingVertexPropertiesEXT.html + struct PhysicalDeviceProvokingVertexPropertiesEXT + { + using NativeType = VkPhysicalDeviceProvokingVertexPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProvokingVertexPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceProvokingVertexPropertiesEXT( Bool32 provokingVertexModePerPipeline_ = {}, + Bool32 transformFeedbackPreservesTriangleFanProvokingVertex_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , provokingVertexModePerPipeline{ provokingVertexModePerPipeline_ } + , transformFeedbackPreservesTriangleFanProvokingVertex{ transformFeedbackPreservesTriangleFanProvokingVertex_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceProvokingVertexPropertiesEXT( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceProvokingVertexPropertiesEXT( VkPhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceProvokingVertexPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceProvokingVertexPropertiesEXT & operator=( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceProvokingVertexPropertiesEXT & operator=( VkPhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceProvokingVertexPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProvokingVertexPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProvokingVertexPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceProvokingVertexPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, provokingVertexModePerPipeline, transformFeedbackPreservesTriangleFanProvokingVertex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceProvokingVertexPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexModePerPipeline == rhs.provokingVertexModePerPipeline ) && + ( transformFeedbackPreservesTriangleFanProvokingVertex == rhs.transformFeedbackPreservesTriangleFanProvokingVertex ); +# endif + } + + bool operator!=( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceProvokingVertexPropertiesEXT; + void * pNext = {}; + Bool32 provokingVertexModePerPipeline = {}; + Bool32 transformFeedbackPreservesTriangleFanProvokingVertex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceProvokingVertexPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceProvokingVertexPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDevicePushConstantBankFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePushConstantBankFeaturesNV.html + struct PhysicalDevicePushConstantBankFeaturesNV + { + using NativeType = VkPhysicalDevicePushConstantBankFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePushConstantBankFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePushConstantBankFeaturesNV( Bool32 pushConstantBank_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pushConstantBank{ pushConstantBank_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePushConstantBankFeaturesNV( PhysicalDevicePushConstantBankFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePushConstantBankFeaturesNV( VkPhysicalDevicePushConstantBankFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePushConstantBankFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePushConstantBankFeaturesNV & operator=( PhysicalDevicePushConstantBankFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePushConstantBankFeaturesNV & operator=( VkPhysicalDevicePushConstantBankFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePushConstantBankFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePushConstantBankFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePushConstantBankFeaturesNV & setPushConstantBank( Bool32 pushConstantBank_ ) & VULKAN_HPP_NOEXCEPT + { + pushConstantBank = pushConstantBank_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePushConstantBankFeaturesNV && setPushConstantBank( Bool32 pushConstantBank_ ) && VULKAN_HPP_NOEXCEPT + { + pushConstantBank = pushConstantBank_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDevicePushConstantBankFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePushConstantBankFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePushConstantBankFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePushConstantBankFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pushConstantBank ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePushConstantBankFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDevicePushConstantBankFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pushConstantBank == rhs.pushConstantBank ); +# endif + } + + bool operator!=( PhysicalDevicePushConstantBankFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePushConstantBankFeaturesNV; + void * pNext = {}; + Bool32 pushConstantBank = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePushConstantBankFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePushConstantBankFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDevicePushConstantBankPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePushConstantBankPropertiesNV.html + struct PhysicalDevicePushConstantBankPropertiesNV + { + using NativeType = VkPhysicalDevicePushConstantBankPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePushConstantBankPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePushConstantBankPropertiesNV( uint32_t maxGraphicsPushConstantBanks_ = {}, + uint32_t maxComputePushConstantBanks_ = {}, + uint32_t maxGraphicsPushDataBanks_ = {}, + uint32_t maxComputePushDataBanks_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxGraphicsPushConstantBanks{ maxGraphicsPushConstantBanks_ } + , maxComputePushConstantBanks{ maxComputePushConstantBanks_ } + , maxGraphicsPushDataBanks{ maxGraphicsPushDataBanks_ } + , maxComputePushDataBanks{ maxComputePushDataBanks_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePushConstantBankPropertiesNV( PhysicalDevicePushConstantBankPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePushConstantBankPropertiesNV( VkPhysicalDevicePushConstantBankPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePushConstantBankPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePushConstantBankPropertiesNV & operator=( PhysicalDevicePushConstantBankPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePushConstantBankPropertiesNV & operator=( VkPhysicalDevicePushConstantBankPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDevicePushConstantBankPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePushConstantBankPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePushConstantBankPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePushConstantBankPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxGraphicsPushConstantBanks, maxComputePushConstantBanks, maxGraphicsPushDataBanks, maxComputePushDataBanks ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePushConstantBankPropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDevicePushConstantBankPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGraphicsPushConstantBanks == rhs.maxGraphicsPushConstantBanks ) && + ( maxComputePushConstantBanks == rhs.maxComputePushConstantBanks ) && ( maxGraphicsPushDataBanks == rhs.maxGraphicsPushDataBanks ) && + ( maxComputePushDataBanks == rhs.maxComputePushDataBanks ); +# endif + } + + bool operator!=( PhysicalDevicePushConstantBankPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePushConstantBankPropertiesNV; + void * pNext = {}; + uint32_t maxGraphicsPushConstantBanks = {}; + uint32_t maxComputePushConstantBanks = {}; + uint32_t maxGraphicsPushDataBanks = {}; + uint32_t maxComputePushDataBanks = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePushConstantBankPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePushConstantBankPropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDevicePushDescriptorProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePushDescriptorProperties.html + struct PhysicalDevicePushDescriptorProperties + { + using NativeType = VkPhysicalDevicePushDescriptorProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePushDescriptorProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDevicePushDescriptorProperties( uint32_t maxPushDescriptors_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxPushDescriptors{ maxPushDescriptors_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDevicePushDescriptorProperties( PhysicalDevicePushDescriptorProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDevicePushDescriptorProperties( VkPhysicalDevicePushDescriptorProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDevicePushDescriptorProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDevicePushDescriptorProperties & operator=( PhysicalDevicePushDescriptorProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDevicePushDescriptorProperties & operator=( VkPhysicalDevicePushDescriptorProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDevicePushDescriptorProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePushDescriptorProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDevicePushDescriptorProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDevicePushDescriptorProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxPushDescriptors ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDevicePushDescriptorProperties const & ) const = default; +#else + bool operator==( PhysicalDevicePushDescriptorProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPushDescriptors == rhs.maxPushDescriptors ); +# endif + } + + bool operator!=( PhysicalDevicePushDescriptorProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDevicePushDescriptorProperties; + void * pNext = {}; + uint32_t maxPushDescriptors = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDevicePushDescriptorProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDevicePushDescriptorProperties; + }; + + using PhysicalDevicePushDescriptorPropertiesKHR = PhysicalDevicePushDescriptorProperties; + + // wrapper struct for struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.html + struct PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM + { + using NativeType = VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM( + uint32_t queueFamilyIndex_ = {}, + PhysicalDeviceDataGraphProcessingEngineTypeARM engineType_ = PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , queueFamilyIndex{ queueFamilyIndex_ } + , engineType{ engineType_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM( PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM( VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM( + *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & + operator=( PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & + operator=( VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & + setEngineType( PhysicalDeviceDataGraphProcessingEngineTypeARM engineType_ ) & + VULKAN_HPP_NOEXCEPT + { + engineType = engineType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM && + setEngineType( PhysicalDeviceDataGraphProcessingEngineTypeARM engineType_ ) && + VULKAN_HPP_NOEXCEPT + { + engineType = engineType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queueFamilyIndex, engineType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & ) const = default; +#else + bool operator==( PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( engineType == rhs.engineType ); +# endif + } + + bool operator!=( PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; + const void * pNext = {}; + uint32_t queueFamilyIndex = {}; + PhysicalDeviceDataGraphProcessingEngineTypeARM engineType = PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; + }; + + // wrapper struct for struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.html + struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT + { + using NativeType = VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRgba10X6FormatsFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRGBA10X6FormatsFeaturesEXT( Bool32 formatRgba10x6WithoutYCbCrSampler_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , formatRgba10x6WithoutYCbCrSampler{ formatRgba10x6WithoutYCbCrSampler_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRGBA10X6FormatsFeaturesEXT( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRGBA10X6FormatsFeaturesEXT( VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRGBA10X6FormatsFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRGBA10X6FormatsFeaturesEXT & operator=( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRGBA10X6FormatsFeaturesEXT & operator=( VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRGBA10X6FormatsFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRGBA10X6FormatsFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRGBA10X6FormatsFeaturesEXT & setFormatRgba10x6WithoutYCbCrSampler( Bool32 formatRgba10x6WithoutYCbCrSampler_ ) & + VULKAN_HPP_NOEXCEPT + { + formatRgba10x6WithoutYCbCrSampler = formatRgba10x6WithoutYCbCrSampler_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRGBA10X6FormatsFeaturesEXT && setFormatRgba10x6WithoutYCbCrSampler( Bool32 formatRgba10x6WithoutYCbCrSampler_ ) && + VULKAN_HPP_NOEXCEPT + { + formatRgba10x6WithoutYCbCrSampler = formatRgba10x6WithoutYCbCrSampler_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, formatRgba10x6WithoutYCbCrSampler ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatRgba10x6WithoutYCbCrSampler == rhs.formatRgba10x6WithoutYCbCrSampler ); +# endif + } + + bool operator!=( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRgba10X6FormatsFeaturesEXT; + void * pNext = {}; + Bool32 formatRgba10x6WithoutYCbCrSampler = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRGBA10X6FormatsFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRGBA10X6FormatsFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.html + struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT + { + using NativeType = VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( Bool32 rasterizationOrderColorAttachmentAccess_ = {}, + Bool32 rasterizationOrderDepthAttachmentAccess_ = {}, + Bool32 rasterizationOrderStencilAttachmentAccess_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rasterizationOrderColorAttachmentAccess{ rasterizationOrderColorAttachmentAccess_ } + , rasterizationOrderDepthAttachmentAccess{ rasterizationOrderDepthAttachmentAccess_ } + , rasterizationOrderStencilAttachmentAccess{ rasterizationOrderStencilAttachmentAccess_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( + *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & + operator=( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & + operator=( VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & + setRasterizationOrderColorAttachmentAccess( Bool32 rasterizationOrderColorAttachmentAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + rasterizationOrderColorAttachmentAccess = rasterizationOrderColorAttachmentAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT && + setRasterizationOrderColorAttachmentAccess( Bool32 rasterizationOrderColorAttachmentAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + rasterizationOrderColorAttachmentAccess = rasterizationOrderColorAttachmentAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & + setRasterizationOrderDepthAttachmentAccess( Bool32 rasterizationOrderDepthAttachmentAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + rasterizationOrderDepthAttachmentAccess = rasterizationOrderDepthAttachmentAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT && + setRasterizationOrderDepthAttachmentAccess( Bool32 rasterizationOrderDepthAttachmentAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + rasterizationOrderDepthAttachmentAccess = rasterizationOrderDepthAttachmentAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & + setRasterizationOrderStencilAttachmentAccess( Bool32 rasterizationOrderStencilAttachmentAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + rasterizationOrderStencilAttachmentAccess = rasterizationOrderStencilAttachmentAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT && + setRasterizationOrderStencilAttachmentAccess( Bool32 rasterizationOrderStencilAttachmentAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + rasterizationOrderStencilAttachmentAccess = rasterizationOrderStencilAttachmentAccess_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, rasterizationOrderColorAttachmentAccess, rasterizationOrderDepthAttachmentAccess, rasterizationOrderStencilAttachmentAccess ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrderColorAttachmentAccess == rhs.rasterizationOrderColorAttachmentAccess ) && + ( rasterizationOrderDepthAttachmentAccess == rhs.rasterizationOrderDepthAttachmentAccess ) && + ( rasterizationOrderStencilAttachmentAccess == rhs.rasterizationOrderStencilAttachmentAccess ); +# endif + } + + bool operator!=( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + void * pNext = {}; + Bool32 rasterizationOrderColorAttachmentAccess = {}; + Bool32 rasterizationOrderDepthAttachmentAccess = {}; + Bool32 rasterizationOrderStencilAttachmentAccess = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + }; + + using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + + // wrapper struct for struct VkPhysicalDeviceRawAccessChainsFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRawAccessChainsFeaturesNV.html + struct PhysicalDeviceRawAccessChainsFeaturesNV + { + using NativeType = VkPhysicalDeviceRawAccessChainsFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRawAccessChainsFeaturesNV( Bool32 shaderRawAccessChains_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderRawAccessChains{ shaderRawAccessChains_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRawAccessChainsFeaturesNV( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRawAccessChainsFeaturesNV( VkPhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRawAccessChainsFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRawAccessChainsFeaturesNV & operator=( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRawAccessChainsFeaturesNV & operator=( VkPhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV & setShaderRawAccessChains( Bool32 shaderRawAccessChains_ ) & VULKAN_HPP_NOEXCEPT + { + shaderRawAccessChains = shaderRawAccessChains_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV && setShaderRawAccessChains( Bool32 shaderRawAccessChains_ ) && VULKAN_HPP_NOEXCEPT + { + shaderRawAccessChains = shaderRawAccessChains_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRawAccessChainsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRawAccessChainsFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRawAccessChainsFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRawAccessChainsFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderRawAccessChains ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRawAccessChainsFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderRawAccessChains == rhs.shaderRawAccessChains ); +# endif + } + + bool operator!=( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV; + void * pNext = {}; + Bool32 shaderRawAccessChains = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRawAccessChainsFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRawAccessChainsFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceRayQueryFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayQueryFeaturesKHR.html + struct PhysicalDeviceRayQueryFeaturesKHR + { + using NativeType = VkPhysicalDeviceRayQueryFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayQueryFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayQueryFeaturesKHR( Bool32 rayQuery_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rayQuery{ rayQuery_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayQueryFeaturesKHR( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayQueryFeaturesKHR( VkPhysicalDeviceRayQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayQueryFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayQueryFeaturesKHR & operator=( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayQueryFeaturesKHR & operator=( VkPhysicalDeviceRayQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayQueryFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayQueryFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayQueryFeaturesKHR & setRayQuery( Bool32 rayQuery_ ) & VULKAN_HPP_NOEXCEPT + { + rayQuery = rayQuery_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayQueryFeaturesKHR && setRayQuery( Bool32 rayQuery_ ) && VULKAN_HPP_NOEXCEPT + { + rayQuery = rayQuery_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRayQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayQueryFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayQueryFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayQuery ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayQueryFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayQuery == rhs.rayQuery ); +# endif + } + + bool operator!=( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayQueryFeaturesKHR; + void * pNext = {}; + Bool32 rayQuery = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayQueryFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayQueryFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT.html + struct PhysicalDeviceRayTracingInvocationReorderFeaturesEXT + { + using NativeType = VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingInvocationReorderFeaturesEXT( Bool32 rayTracingInvocationReorder_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rayTracingInvocationReorder{ rayTracingInvocationReorder_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceRayTracingInvocationReorderFeaturesEXT( PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingInvocationReorderFeaturesEXT( VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingInvocationReorderFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingInvocationReorderFeaturesEXT & + operator=( PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingInvocationReorderFeaturesEXT & operator=( VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesEXT & setRayTracingInvocationReorder( Bool32 rayTracingInvocationReorder_ ) & + VULKAN_HPP_NOEXCEPT + { + rayTracingInvocationReorder = rayTracingInvocationReorder_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesEXT && setRayTracingInvocationReorder( Bool32 rayTracingInvocationReorder_ ) && + VULKAN_HPP_NOEXCEPT + { + rayTracingInvocationReorder = rayTracingInvocationReorder_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayTracingInvocationReorder ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingInvocationReorder == rhs.rayTracingInvocationReorder ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesEXT; + void * pNext = {}; + Bool32 rayTracingInvocationReorder = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingInvocationReorderFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingInvocationReorderFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.html + struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV + { + using NativeType = VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingInvocationReorderFeaturesNV( Bool32 rayTracingInvocationReorder_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rayTracingInvocationReorder{ rayTracingInvocationReorder_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceRayTracingInvocationReorderFeaturesNV( PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingInvocationReorderFeaturesNV( VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingInvocationReorderFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingInvocationReorderFeaturesNV & + operator=( PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingInvocationReorderFeaturesNV & operator=( VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesNV & setRayTracingInvocationReorder( Bool32 rayTracingInvocationReorder_ ) & + VULKAN_HPP_NOEXCEPT + { + rayTracingInvocationReorder = rayTracingInvocationReorder_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesNV && setRayTracingInvocationReorder( Bool32 rayTracingInvocationReorder_ ) && + VULKAN_HPP_NOEXCEPT + { + rayTracingInvocationReorder = rayTracingInvocationReorder_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayTracingInvocationReorder ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingInvocationReorder == rhs.rayTracingInvocationReorder ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV; + void * pNext = {}; + Bool32 rayTracingInvocationReorder = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingInvocationReorderFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingInvocationReorderFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT.html + struct PhysicalDeviceRayTracingInvocationReorderPropertiesEXT + { + using NativeType = VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingInvocationReorderPropertiesEXT( + RayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint_ = RayTracingInvocationReorderModeEXT::eNone, + uint32_t maxShaderBindingTableRecordIndex_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rayTracingInvocationReorderReorderingHint{ rayTracingInvocationReorderReorderingHint_ } + , maxShaderBindingTableRecordIndex{ maxShaderBindingTableRecordIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingInvocationReorderPropertiesEXT( PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingInvocationReorderPropertiesEXT( VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingInvocationReorderPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingInvocationReorderPropertiesEXT & + operator=( PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingInvocationReorderPropertiesEXT & + operator=( VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayTracingInvocationReorderReorderingHint, maxShaderBindingTableRecordIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && + ( rayTracingInvocationReorderReorderingHint == rhs.rayTracingInvocationReorderReorderingHint ) && + ( maxShaderBindingTableRecordIndex == rhs.maxShaderBindingTableRecordIndex ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesEXT; + void * pNext = {}; + RayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint = RayTracingInvocationReorderModeEXT::eNone; + uint32_t maxShaderBindingTableRecordIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingInvocationReorderPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingInvocationReorderPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV.html + struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV + { + using NativeType = VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingInvocationReorderPropertiesNV( + RayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint_ = RayTracingInvocationReorderModeEXT::eNone, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rayTracingInvocationReorderReorderingHint{ rayTracingInvocationReorderReorderingHint_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceRayTracingInvocationReorderPropertiesNV( PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingInvocationReorderPropertiesNV( VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingInvocationReorderPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingInvocationReorderPropertiesNV & + operator=( PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingInvocationReorderPropertiesNV & operator=( VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayTracingInvocationReorderReorderingHint ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingInvocationReorderReorderingHint == rhs.rayTracingInvocationReorderReorderingHint ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV; + void * pNext = {}; + RayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint = RayTracingInvocationReorderModeEXT::eNone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingInvocationReorderPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingInvocationReorderPropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.html + struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV + { + using NativeType = VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV( Bool32 spheres_ = {}, Bool32 linearSweptSpheres_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , spheres{ spheres_ } + , linearSweptSpheres{ linearSweptSpheres_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV( PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV( VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV & + operator=( PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV & operator=( VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV & setSpheres( Bool32 spheres_ ) & VULKAN_HPP_NOEXCEPT + { + spheres = spheres_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV && setSpheres( Bool32 spheres_ ) && VULKAN_HPP_NOEXCEPT + { + spheres = spheres_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV & setLinearSweptSpheres( Bool32 linearSweptSpheres_ ) & VULKAN_HPP_NOEXCEPT + { + linearSweptSpheres = linearSweptSpheres_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV && setLinearSweptSpheres( Bool32 linearSweptSpheres_ ) && VULKAN_HPP_NOEXCEPT + { + linearSweptSpheres = linearSweptSpheres_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, spheres, linearSweptSpheres ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spheres == rhs.spheres ) && ( linearSweptSpheres == rhs.linearSweptSpheres ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; + void * pNext = {}; + Bool32 spheres = {}; + Bool32 linearSweptSpheres = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.html + struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR + { + using NativeType = VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingMaintenance1FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingMaintenance1FeaturesKHR( Bool32 rayTracingMaintenance1_ = {}, + Bool32 rayTracingPipelineTraceRaysIndirect2_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rayTracingMaintenance1{ rayTracingMaintenance1_ } + , rayTracingPipelineTraceRaysIndirect2{ rayTracingPipelineTraceRaysIndirect2_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceRayTracingMaintenance1FeaturesKHR( PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingMaintenance1FeaturesKHR( VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingMaintenance1FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingMaintenance1FeaturesKHR & operator=( PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingMaintenance1FeaturesKHR & operator=( VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR & setRayTracingMaintenance1( Bool32 rayTracingMaintenance1_ ) & VULKAN_HPP_NOEXCEPT + { + rayTracingMaintenance1 = rayTracingMaintenance1_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR && setRayTracingMaintenance1( Bool32 rayTracingMaintenance1_ ) && + VULKAN_HPP_NOEXCEPT + { + rayTracingMaintenance1 = rayTracingMaintenance1_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR & + setRayTracingPipelineTraceRaysIndirect2( Bool32 rayTracingPipelineTraceRaysIndirect2_ ) & + VULKAN_HPP_NOEXCEPT + { + rayTracingPipelineTraceRaysIndirect2 = rayTracingPipelineTraceRaysIndirect2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR && + setRayTracingPipelineTraceRaysIndirect2( Bool32 rayTracingPipelineTraceRaysIndirect2_ ) && + VULKAN_HPP_NOEXCEPT + { + rayTracingPipelineTraceRaysIndirect2 = rayTracingPipelineTraceRaysIndirect2_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayTracingMaintenance1, rayTracingPipelineTraceRaysIndirect2 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMaintenance1 == rhs.rayTracingMaintenance1 ) && + ( rayTracingPipelineTraceRaysIndirect2 == rhs.rayTracingPipelineTraceRaysIndirect2 ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingMaintenance1FeaturesKHR; + void * pNext = {}; + Bool32 rayTracingMaintenance1 = {}; + Bool32 rayTracingPipelineTraceRaysIndirect2 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingMaintenance1FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingMaintenance1FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.html + struct PhysicalDeviceRayTracingMotionBlurFeaturesNV + { + using NativeType = VkPhysicalDeviceRayTracingMotionBlurFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingMotionBlurFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingMotionBlurFeaturesNV( Bool32 rayTracingMotionBlur_ = {}, + Bool32 rayTracingMotionBlurPipelineTraceRaysIndirect_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rayTracingMotionBlur{ rayTracingMotionBlur_ } + , rayTracingMotionBlurPipelineTraceRaysIndirect{ rayTracingMotionBlurPipelineTraceRaysIndirect_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingMotionBlurFeaturesNV( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingMotionBlurFeaturesNV( VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingMotionBlurFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingMotionBlurFeaturesNV & operator=( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingMotionBlurFeaturesNV & operator=( VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV & setRayTracingMotionBlur( Bool32 rayTracingMotionBlur_ ) & VULKAN_HPP_NOEXCEPT + { + rayTracingMotionBlur = rayTracingMotionBlur_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV && setRayTracingMotionBlur( Bool32 rayTracingMotionBlur_ ) && VULKAN_HPP_NOEXCEPT + { + rayTracingMotionBlur = rayTracingMotionBlur_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV & + setRayTracingMotionBlurPipelineTraceRaysIndirect( Bool32 rayTracingMotionBlurPipelineTraceRaysIndirect_ ) & + VULKAN_HPP_NOEXCEPT + { + rayTracingMotionBlurPipelineTraceRaysIndirect = rayTracingMotionBlurPipelineTraceRaysIndirect_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV && + setRayTracingMotionBlurPipelineTraceRaysIndirect( Bool32 rayTracingMotionBlurPipelineTraceRaysIndirect_ ) && + VULKAN_HPP_NOEXCEPT + { + rayTracingMotionBlurPipelineTraceRaysIndirect = rayTracingMotionBlurPipelineTraceRaysIndirect_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayTracingMotionBlur, rayTracingMotionBlurPipelineTraceRaysIndirect ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMotionBlur == rhs.rayTracingMotionBlur ) && + ( rayTracingMotionBlurPipelineTraceRaysIndirect == rhs.rayTracingMotionBlurPipelineTraceRaysIndirect ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingMotionBlurFeaturesNV; + void * pNext = {}; + Bool32 rayTracingMotionBlur = {}; + Bool32 rayTracingMotionBlurPipelineTraceRaysIndirect = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingMotionBlurFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingMotionBlurFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html + struct PhysicalDeviceRayTracingPipelineFeaturesKHR + { + using NativeType = VkPhysicalDeviceRayTracingPipelineFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPipelineFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPipelineFeaturesKHR( Bool32 rayTracingPipeline_ = {}, + Bool32 rayTracingPipelineShaderGroupHandleCaptureReplay_ = {}, + Bool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed_ = {}, + Bool32 rayTracingPipelineTraceRaysIndirect_ = {}, + Bool32 rayTraversalPrimitiveCulling_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rayTracingPipeline{ rayTracingPipeline_ } + , rayTracingPipelineShaderGroupHandleCaptureReplay{ rayTracingPipelineShaderGroupHandleCaptureReplay_ } + , rayTracingPipelineShaderGroupHandleCaptureReplayMixed{ rayTracingPipelineShaderGroupHandleCaptureReplayMixed_ } + , rayTracingPipelineTraceRaysIndirect{ rayTracingPipelineTraceRaysIndirect_ } + , rayTraversalPrimitiveCulling{ rayTraversalPrimitiveCulling_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPipelineFeaturesKHR( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingPipelineFeaturesKHR( VkPhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingPipelineFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingPipelineFeaturesKHR & operator=( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingPipelineFeaturesKHR & operator=( VkPhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & setRayTracingPipeline( Bool32 rayTracingPipeline_ ) & VULKAN_HPP_NOEXCEPT + { + rayTracingPipeline = rayTracingPipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && setRayTracingPipeline( Bool32 rayTracingPipeline_ ) && VULKAN_HPP_NOEXCEPT + { + rayTracingPipeline = rayTracingPipeline_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & + setRayTracingPipelineShaderGroupHandleCaptureReplay( Bool32 rayTracingPipelineShaderGroupHandleCaptureReplay_ ) & + VULKAN_HPP_NOEXCEPT + { + rayTracingPipelineShaderGroupHandleCaptureReplay = rayTracingPipelineShaderGroupHandleCaptureReplay_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && + setRayTracingPipelineShaderGroupHandleCaptureReplay( Bool32 rayTracingPipelineShaderGroupHandleCaptureReplay_ ) && + VULKAN_HPP_NOEXCEPT + { + rayTracingPipelineShaderGroupHandleCaptureReplay = rayTracingPipelineShaderGroupHandleCaptureReplay_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & + setRayTracingPipelineShaderGroupHandleCaptureReplayMixed( Bool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed_ ) & + VULKAN_HPP_NOEXCEPT + { + rayTracingPipelineShaderGroupHandleCaptureReplayMixed = rayTracingPipelineShaderGroupHandleCaptureReplayMixed_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && + setRayTracingPipelineShaderGroupHandleCaptureReplayMixed( Bool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed_ ) && + VULKAN_HPP_NOEXCEPT + { + rayTracingPipelineShaderGroupHandleCaptureReplayMixed = rayTracingPipelineShaderGroupHandleCaptureReplayMixed_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & + setRayTracingPipelineTraceRaysIndirect( Bool32 rayTracingPipelineTraceRaysIndirect_ ) & + VULKAN_HPP_NOEXCEPT + { + rayTracingPipelineTraceRaysIndirect = rayTracingPipelineTraceRaysIndirect_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && + setRayTracingPipelineTraceRaysIndirect( Bool32 rayTracingPipelineTraceRaysIndirect_ ) && + VULKAN_HPP_NOEXCEPT + { + rayTracingPipelineTraceRaysIndirect = rayTracingPipelineTraceRaysIndirect_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & setRayTraversalPrimitiveCulling( Bool32 rayTraversalPrimitiveCulling_ ) & + VULKAN_HPP_NOEXCEPT + { + rayTraversalPrimitiveCulling = rayTraversalPrimitiveCulling_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && setRayTraversalPrimitiveCulling( Bool32 rayTraversalPrimitiveCulling_ ) && + VULKAN_HPP_NOEXCEPT + { + rayTraversalPrimitiveCulling = rayTraversalPrimitiveCulling_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + rayTracingPipeline, + rayTracingPipelineShaderGroupHandleCaptureReplay, + rayTracingPipelineShaderGroupHandleCaptureReplayMixed, + rayTracingPipelineTraceRaysIndirect, + rayTraversalPrimitiveCulling ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingPipelineFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPipeline == rhs.rayTracingPipeline ) && + ( rayTracingPipelineShaderGroupHandleCaptureReplay == rhs.rayTracingPipelineShaderGroupHandleCaptureReplay ) && + ( rayTracingPipelineShaderGroupHandleCaptureReplayMixed == rhs.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ) && + ( rayTracingPipelineTraceRaysIndirect == rhs.rayTracingPipelineTraceRaysIndirect ) && + ( rayTraversalPrimitiveCulling == rhs.rayTraversalPrimitiveCulling ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingPipelineFeaturesKHR; + void * pNext = {}; + Bool32 rayTracingPipeline = {}; + Bool32 rayTracingPipelineShaderGroupHandleCaptureReplay = {}; + Bool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed = {}; + Bool32 rayTracingPipelineTraceRaysIndirect = {}; + Bool32 rayTraversalPrimitiveCulling = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingPipelineFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingPipelineFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html + struct PhysicalDeviceRayTracingPipelinePropertiesKHR + { + using NativeType = VkPhysicalDeviceRayTracingPipelinePropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPipelinePropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPipelinePropertiesKHR( uint32_t shaderGroupHandleSize_ = {}, + uint32_t maxRayRecursionDepth_ = {}, + uint32_t maxShaderGroupStride_ = {}, + uint32_t shaderGroupBaseAlignment_ = {}, + uint32_t shaderGroupHandleCaptureReplaySize_ = {}, + uint32_t maxRayDispatchInvocationCount_ = {}, + uint32_t shaderGroupHandleAlignment_ = {}, + uint32_t maxRayHitAttributeSize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderGroupHandleSize{ shaderGroupHandleSize_ } + , maxRayRecursionDepth{ maxRayRecursionDepth_ } + , maxShaderGroupStride{ maxShaderGroupStride_ } + , shaderGroupBaseAlignment{ shaderGroupBaseAlignment_ } + , shaderGroupHandleCaptureReplaySize{ shaderGroupHandleCaptureReplaySize_ } + , maxRayDispatchInvocationCount{ maxRayDispatchInvocationCount_ } + , shaderGroupHandleAlignment{ shaderGroupHandleAlignment_ } + , maxRayHitAttributeSize{ maxRayHitAttributeSize_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceRayTracingPipelinePropertiesKHR( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingPipelinePropertiesKHR( VkPhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingPipelinePropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingPipelinePropertiesKHR & operator=( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingPipelinePropertiesKHR & operator=( VkPhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderGroupHandleSize, + maxRayRecursionDepth, + maxShaderGroupStride, + shaderGroupBaseAlignment, + shaderGroupHandleCaptureReplaySize, + maxRayDispatchInvocationCount, + shaderGroupHandleAlignment, + maxRayHitAttributeSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingPipelinePropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) && + ( maxRayRecursionDepth == rhs.maxRayRecursionDepth ) && ( maxShaderGroupStride == rhs.maxShaderGroupStride ) && + ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) && ( shaderGroupHandleCaptureReplaySize == rhs.shaderGroupHandleCaptureReplaySize ) && + ( maxRayDispatchInvocationCount == rhs.maxRayDispatchInvocationCount ) && ( shaderGroupHandleAlignment == rhs.shaderGroupHandleAlignment ) && + ( maxRayHitAttributeSize == rhs.maxRayHitAttributeSize ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingPipelinePropertiesKHR; + void * pNext = {}; + uint32_t shaderGroupHandleSize = {}; + uint32_t maxRayRecursionDepth = {}; + uint32_t maxShaderGroupStride = {}; + uint32_t shaderGroupBaseAlignment = {}; + uint32_t shaderGroupHandleCaptureReplaySize = {}; + uint32_t maxRayDispatchInvocationCount = {}; + uint32_t shaderGroupHandleAlignment = {}; + uint32_t maxRayHitAttributeSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingPipelinePropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingPipelinePropertiesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.html + struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR + { + using NativeType = VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPositionFetchFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPositionFetchFeaturesKHR( Bool32 rayTracingPositionFetch_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rayTracingPositionFetch{ rayTracingPositionFetch_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceRayTracingPositionFetchFeaturesKHR( PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingPositionFetchFeaturesKHR( VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingPositionFetchFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingPositionFetchFeaturesKHR & operator=( PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingPositionFetchFeaturesKHR & operator=( VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPositionFetchFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPositionFetchFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPositionFetchFeaturesKHR & setRayTracingPositionFetch( Bool32 rayTracingPositionFetch_ ) & + VULKAN_HPP_NOEXCEPT + { + rayTracingPositionFetch = rayTracingPositionFetch_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPositionFetchFeaturesKHR && setRayTracingPositionFetch( Bool32 rayTracingPositionFetch_ ) && + VULKAN_HPP_NOEXCEPT + { + rayTracingPositionFetch = rayTracingPositionFetch_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayTracingPositionFetch ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPositionFetch == rhs.rayTracingPositionFetch ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingPositionFetchFeaturesKHR; + void * pNext = {}; + Bool32 rayTracingPositionFetch = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingPositionFetchFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingPositionFetchFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html + struct PhysicalDeviceRayTracingPropertiesNV + { + using NativeType = VkPhysicalDeviceRayTracingPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = {}, + uint32_t maxRecursionDepth_ = {}, + uint32_t maxShaderGroupStride_ = {}, + uint32_t shaderGroupBaseAlignment_ = {}, + uint64_t maxGeometryCount_ = {}, + uint64_t maxInstanceCount_ = {}, + uint64_t maxTriangleCount_ = {}, + uint32_t maxDescriptorSetAccelerationStructures_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderGroupHandleSize{ shaderGroupHandleSize_ } + , maxRecursionDepth{ maxRecursionDepth_ } + , maxShaderGroupStride{ maxShaderGroupStride_ } + , shaderGroupBaseAlignment{ shaderGroupBaseAlignment_ } + , maxGeometryCount{ maxGeometryCount_ } + , maxInstanceCount{ maxInstanceCount_ } + , maxTriangleCount{ maxTriangleCount_ } + , maxDescriptorSetAccelerationStructures{ maxDescriptorSetAccelerationStructures_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesNV( PhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingPropertiesNV & operator=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingPropertiesNV & operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceRayTracingPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderGroupHandleSize, + maxRecursionDepth, + maxShaderGroupStride, + shaderGroupBaseAlignment, + maxGeometryCount, + maxInstanceCount, + maxTriangleCount, + maxDescriptorSetAccelerationStructures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingPropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) && + ( maxRecursionDepth == rhs.maxRecursionDepth ) && ( maxShaderGroupStride == rhs.maxShaderGroupStride ) && + ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) && ( maxGeometryCount == rhs.maxGeometryCount ) && + ( maxInstanceCount == rhs.maxInstanceCount ) && ( maxTriangleCount == rhs.maxTriangleCount ) && + ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; + void * pNext = {}; + uint32_t shaderGroupHandleSize = {}; + uint32_t maxRecursionDepth = {}; + uint32_t maxShaderGroupStride = {}; + uint32_t shaderGroupBaseAlignment = {}; + uint64_t maxGeometryCount = {}; + uint64_t maxInstanceCount = {}; + uint64_t maxTriangleCount = {}; + uint32_t maxDescriptorSetAccelerationStructures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingPropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceRayTracingValidationFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingValidationFeaturesNV.html + struct PhysicalDeviceRayTracingValidationFeaturesNV + { + using NativeType = VkPhysicalDeviceRayTracingValidationFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingValidationFeaturesNV( Bool32 rayTracingValidation_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rayTracingValidation{ rayTracingValidation_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingValidationFeaturesNV( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRayTracingValidationFeaturesNV( VkPhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRayTracingValidationFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRayTracingValidationFeaturesNV & operator=( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRayTracingValidationFeaturesNV & operator=( VkPhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV & setRayTracingValidation( Bool32 rayTracingValidation_ ) & VULKAN_HPP_NOEXCEPT + { + rayTracingValidation = rayTracingValidation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV && setRayTracingValidation( Bool32 rayTracingValidation_ ) && VULKAN_HPP_NOEXCEPT + { + rayTracingValidation = rayTracingValidation_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRayTracingValidationFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingValidationFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingValidationFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRayTracingValidationFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rayTracingValidation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRayTracingValidationFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingValidation == rhs.rayTracingValidation ); +# endif + } + + bool operator!=( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV; + void * pNext = {}; + Bool32 rayTracingValidation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingValidationFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRayTracingValidationFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.html + struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG + { + using NativeType = VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRelaxedLineRasterizationFeaturesIMG; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRelaxedLineRasterizationFeaturesIMG( Bool32 relaxedLineRasterization_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , relaxedLineRasterization{ relaxedLineRasterization_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceRelaxedLineRasterizationFeaturesIMG( PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRelaxedLineRasterizationFeaturesIMG( VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRelaxedLineRasterizationFeaturesIMG( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRelaxedLineRasterizationFeaturesIMG & + operator=( PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRelaxedLineRasterizationFeaturesIMG & operator=( VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRelaxedLineRasterizationFeaturesIMG & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRelaxedLineRasterizationFeaturesIMG && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRelaxedLineRasterizationFeaturesIMG & setRelaxedLineRasterization( Bool32 relaxedLineRasterization_ ) & + VULKAN_HPP_NOEXCEPT + { + relaxedLineRasterization = relaxedLineRasterization_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRelaxedLineRasterizationFeaturesIMG && setRelaxedLineRasterization( Bool32 relaxedLineRasterization_ ) && + VULKAN_HPP_NOEXCEPT + { + relaxedLineRasterization = relaxedLineRasterization_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, relaxedLineRasterization ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & ) const = default; +#else + bool operator==( PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( relaxedLineRasterization == rhs.relaxedLineRasterization ); +# endif + } + + bool operator!=( PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRelaxedLineRasterizationFeaturesIMG; + void * pNext = {}; + Bool32 relaxedLineRasterization = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRelaxedLineRasterizationFeaturesIMG; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRelaxedLineRasterizationFeaturesIMG; + }; + + // wrapper struct for struct VkPhysicalDeviceRenderPassStripedFeaturesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRenderPassStripedFeaturesARM.html + struct PhysicalDeviceRenderPassStripedFeaturesARM + { + using NativeType = VkPhysicalDeviceRenderPassStripedFeaturesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRenderPassStripedFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRenderPassStripedFeaturesARM( Bool32 renderPassStriped_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , renderPassStriped{ renderPassStriped_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRenderPassStripedFeaturesARM( PhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRenderPassStripedFeaturesARM( VkPhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRenderPassStripedFeaturesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRenderPassStripedFeaturesARM & operator=( PhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRenderPassStripedFeaturesARM & operator=( VkPhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRenderPassStripedFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRenderPassStripedFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRenderPassStripedFeaturesARM & setRenderPassStriped( Bool32 renderPassStriped_ ) & VULKAN_HPP_NOEXCEPT + { + renderPassStriped = renderPassStriped_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRenderPassStripedFeaturesARM && setRenderPassStriped( Bool32 renderPassStriped_ ) && VULKAN_HPP_NOEXCEPT + { + renderPassStriped = renderPassStriped_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRenderPassStripedFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRenderPassStripedFeaturesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRenderPassStripedFeaturesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRenderPassStripedFeaturesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, renderPassStriped ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRenderPassStripedFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPassStriped == rhs.renderPassStriped ); +# endif + } + + bool operator!=( PhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRenderPassStripedFeaturesARM; + void * pNext = {}; + Bool32 renderPassStriped = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRenderPassStripedFeaturesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRenderPassStripedFeaturesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceRenderPassStripedPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRenderPassStripedPropertiesARM.html + struct PhysicalDeviceRenderPassStripedPropertiesARM + { + using NativeType = VkPhysicalDeviceRenderPassStripedPropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRenderPassStripedPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRenderPassStripedPropertiesARM( Extent2D renderPassStripeGranularity_ = {}, + uint32_t maxRenderPassStripes_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , renderPassStripeGranularity{ renderPassStripeGranularity_ } + , maxRenderPassStripes{ maxRenderPassStripes_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRenderPassStripedPropertiesARM( PhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRenderPassStripedPropertiesARM( VkPhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRenderPassStripedPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRenderPassStripedPropertiesARM & operator=( PhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRenderPassStripedPropertiesARM & operator=( VkPhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceRenderPassStripedPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRenderPassStripedPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRenderPassStripedPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRenderPassStripedPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, renderPassStripeGranularity, maxRenderPassStripes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRenderPassStripedPropertiesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPassStripeGranularity == rhs.renderPassStripeGranularity ) && + ( maxRenderPassStripes == rhs.maxRenderPassStripes ); +# endif + } + + bool operator!=( PhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRenderPassStripedPropertiesARM; + void * pNext = {}; + Extent2D renderPassStripeGranularity = {}; + uint32_t maxRenderPassStripes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRenderPassStripedPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRenderPassStripedPropertiesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html + struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV + { + using NativeType = VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( Bool32 representativeFragmentTest_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , representativeFragmentTest{ representativeFragmentTest_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceRepresentativeFragmentTestFeaturesNV( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRepresentativeFragmentTestFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRepresentativeFragmentTestFeaturesNV & + operator=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRepresentativeFragmentTestFeaturesNV & operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRepresentativeFragmentTestFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setRepresentativeFragmentTest( Bool32 representativeFragmentTest_ ) & + VULKAN_HPP_NOEXCEPT + { + representativeFragmentTest = representativeFragmentTest_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRepresentativeFragmentTestFeaturesNV && setRepresentativeFragmentTest( Bool32 representativeFragmentTest_ ) && + VULKAN_HPP_NOEXCEPT + { + representativeFragmentTest = representativeFragmentTest_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, representativeFragmentTest ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( representativeFragmentTest == rhs.representativeFragmentTest ); +# endif + } + + bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; + void * pNext = {}; + Bool32 representativeFragmentTest = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceRobustness2FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2FeaturesKHR.html + struct PhysicalDeviceRobustness2FeaturesKHR + { + using NativeType = VkPhysicalDeviceRobustness2FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesKHR( Bool32 robustBufferAccess2_ = {}, + Bool32 robustImageAccess2_ = {}, + Bool32 nullDescriptor_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , robustBufferAccess2{ robustBufferAccess2_ } + , robustImageAccess2{ robustImageAccess2_ } + , nullDescriptor{ nullDescriptor_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesKHR( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRobustness2FeaturesKHR( VkPhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRobustness2FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRobustness2FeaturesKHR & operator=( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRobustness2FeaturesKHR & operator=( VkPhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setRobustBufferAccess2( Bool32 robustBufferAccess2_ ) & VULKAN_HPP_NOEXCEPT + { + robustBufferAccess2 = robustBufferAccess2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR && setRobustBufferAccess2( Bool32 robustBufferAccess2_ ) && VULKAN_HPP_NOEXCEPT + { + robustBufferAccess2 = robustBufferAccess2_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setRobustImageAccess2( Bool32 robustImageAccess2_ ) & VULKAN_HPP_NOEXCEPT + { + robustImageAccess2 = robustImageAccess2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR && setRobustImageAccess2( Bool32 robustImageAccess2_ ) && VULKAN_HPP_NOEXCEPT + { + robustImageAccess2 = robustImageAccess2_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setNullDescriptor( Bool32 nullDescriptor_ ) & VULKAN_HPP_NOEXCEPT + { + nullDescriptor = nullDescriptor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR && setNullDescriptor( Bool32 nullDescriptor_ ) && VULKAN_HPP_NOEXCEPT + { + nullDescriptor = nullDescriptor_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceRobustness2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRobustness2FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRobustness2FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRobustness2FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, robustBufferAccess2, robustImageAccess2, nullDescriptor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRobustness2FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustBufferAccess2 == rhs.robustBufferAccess2 ) && + ( robustImageAccess2 == rhs.robustImageAccess2 ) && ( nullDescriptor == rhs.nullDescriptor ); +# endif + } + + bool operator!=( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRobustness2FeaturesKHR; + void * pNext = {}; + Bool32 robustBufferAccess2 = {}; + Bool32 robustImageAccess2 = {}; + Bool32 nullDescriptor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRobustness2FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRobustness2FeaturesKHR; + }; + + using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR; + + // wrapper struct for struct VkPhysicalDeviceRobustness2PropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2PropertiesKHR.html + struct PhysicalDeviceRobustness2PropertiesKHR + { + using NativeType = VkPhysicalDeviceRobustness2PropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2PropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesKHR( DeviceSize robustStorageBufferAccessSizeAlignment_ = {}, + DeviceSize robustUniformBufferAccessSizeAlignment_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , robustStorageBufferAccessSizeAlignment{ robustStorageBufferAccessSizeAlignment_ } + , robustUniformBufferAccessSizeAlignment{ robustUniformBufferAccessSizeAlignment_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesKHR( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceRobustness2PropertiesKHR( VkPhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceRobustness2PropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceRobustness2PropertiesKHR & operator=( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceRobustness2PropertiesKHR & operator=( VkPhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceRobustness2PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRobustness2PropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRobustness2PropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceRobustness2PropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, robustStorageBufferAccessSizeAlignment, robustUniformBufferAccessSizeAlignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceRobustness2PropertiesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment ) && + ( robustUniformBufferAccessSizeAlignment == rhs.robustUniformBufferAccessSizeAlignment ); +# endif + } + + bool operator!=( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceRobustness2PropertiesKHR; + void * pNext = {}; + DeviceSize robustStorageBufferAccessSizeAlignment = {}; + DeviceSize robustUniformBufferAccessSizeAlignment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceRobustness2PropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceRobustness2PropertiesKHR; + }; + + using PhysicalDeviceRobustness2PropertiesEXT = PhysicalDeviceRobustness2PropertiesKHR; + + // wrapper struct for struct VkPhysicalDeviceSampleLocationsPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html + struct PhysicalDeviceSampleLocationsPropertiesEXT + { + using NativeType = VkPhysicalDeviceSampleLocationsPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSampleLocationsPropertiesEXT( SampleCountFlags sampleLocationSampleCounts_ = {}, + Extent2D maxSampleLocationGridSize_ = {}, + std::array const & sampleLocationCoordinateRange_ = {}, + uint32_t sampleLocationSubPixelBits_ = {}, + Bool32 variableSampleLocations_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , sampleLocationSampleCounts{ sampleLocationSampleCounts_ } + , maxSampleLocationGridSize{ maxSampleLocationGridSize_ } + , sampleLocationCoordinateRange{ sampleLocationCoordinateRange_ } + , sampleLocationSubPixelBits{ sampleLocationSubPixelBits_ } + , variableSampleLocations{ variableSampleLocations_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSampleLocationsPropertiesEXT( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSampleLocationsPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSampleLocationsPropertiesEXT & operator=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSampleLocationsPropertiesEXT & operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceSampleLocationsPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSampleLocationsPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSampleLocationsPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSampleLocationsPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + uint32_t const &, + Bool32 const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + sampleLocationSampleCounts, + maxSampleLocationGridSize, + sampleLocationCoordinateRange, + sampleLocationSubPixelBits, + variableSampleLocations ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSampleLocationsPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) && + ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ) && ( sampleLocationCoordinateRange == rhs.sampleLocationCoordinateRange ) && + ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits ) && ( variableSampleLocations == rhs.variableSampleLocations ); +# endif + } + + bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; + void * pNext = {}; + SampleCountFlags sampleLocationSampleCounts = {}; + Extent2D maxSampleLocationGridSize = {}; + ArrayWrapper1D sampleLocationCoordinateRange = {}; + uint32_t sampleLocationSubPixelBits = {}; + Bool32 variableSampleLocations = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSampleLocationsPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSampleLocationsPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceSamplerFilterMinmaxProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html + struct PhysicalDeviceSamplerFilterMinmaxProperties + { + using NativeType = VkPhysicalDeviceSamplerFilterMinmaxProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerFilterMinmaxProperties( Bool32 filterMinmaxSingleComponentFormats_ = {}, + Bool32 filterMinmaxImageComponentMapping_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , filterMinmaxSingleComponentFormats{ filterMinmaxSingleComponentFormats_ } + , filterMinmaxImageComponentMapping{ filterMinmaxImageComponentMapping_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerFilterMinmaxProperties( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSamplerFilterMinmaxProperties( VkPhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSamplerFilterMinmaxProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSamplerFilterMinmaxProperties & operator=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSamplerFilterMinmaxProperties & operator=( VkPhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceSamplerFilterMinmaxProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSamplerFilterMinmaxProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSamplerFilterMinmaxProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSamplerFilterMinmaxProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, filterMinmaxSingleComponentFormats, filterMinmaxImageComponentMapping ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSamplerFilterMinmaxProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) && + ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ); +# endif + } + + bool operator!=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties; + void * pNext = {}; + Bool32 filterMinmaxSingleComponentFormats = {}; + Bool32 filterMinmaxImageComponentMapping = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSamplerFilterMinmaxProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSamplerFilterMinmaxProperties; + }; + + using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties; + + // wrapper struct for struct VkPhysicalDeviceSamplerYcbcrConversionFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeatures.html + struct PhysicalDeviceSamplerYcbcrConversionFeatures + { + using NativeType = VkPhysicalDeviceSamplerYcbcrConversionFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( Bool32 samplerYcbcrConversion_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , samplerYcbcrConversion{ samplerYcbcrConversion_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSamplerYcbcrConversionFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSamplerYcbcrConversionFeatures & operator=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSamplerYcbcrConversionFeatures & operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSamplerYcbcrConversionFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSamplerYcbcrConversionFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSamplerYcbcrConversionFeatures & setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ ) & VULKAN_HPP_NOEXCEPT + { + samplerYcbcrConversion = samplerYcbcrConversion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSamplerYcbcrConversionFeatures && setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ ) && VULKAN_HPP_NOEXCEPT + { + samplerYcbcrConversion = samplerYcbcrConversion_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSamplerYcbcrConversionFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, samplerYcbcrConversion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSamplerYcbcrConversionFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ); +# endif + } + + bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; + void * pNext = {}; + Bool32 samplerYcbcrConversion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSamplerYcbcrConversionFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSamplerYcbcrConversionFeatures; + }; + + using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures; + + // wrapper struct for struct VkPhysicalDeviceScalarBlockLayoutFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html + struct PhysicalDeviceScalarBlockLayoutFeatures + { + using NativeType = VkPhysicalDeviceScalarBlockLayoutFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceScalarBlockLayoutFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeatures( Bool32 scalarBlockLayout_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , scalarBlockLayout{ scalarBlockLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeatures( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceScalarBlockLayoutFeatures( VkPhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceScalarBlockLayoutFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceScalarBlockLayoutFeatures & operator=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceScalarBlockLayoutFeatures & operator=( VkPhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceScalarBlockLayoutFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceScalarBlockLayoutFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceScalarBlockLayoutFeatures & setScalarBlockLayout( Bool32 scalarBlockLayout_ ) & VULKAN_HPP_NOEXCEPT + { + scalarBlockLayout = scalarBlockLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceScalarBlockLayoutFeatures && setScalarBlockLayout( Bool32 scalarBlockLayout_ ) && VULKAN_HPP_NOEXCEPT + { + scalarBlockLayout = scalarBlockLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceScalarBlockLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceScalarBlockLayoutFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceScalarBlockLayoutFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceScalarBlockLayoutFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, scalarBlockLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceScalarBlockLayoutFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalarBlockLayout == rhs.scalarBlockLayout ); +# endif + } + + bool operator!=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeatures; + void * pNext = {}; + Bool32 scalarBlockLayout = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceScalarBlockLayoutFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceScalarBlockLayoutFeatures; + }; + + using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures; + + // wrapper struct for struct VkPhysicalDeviceSchedulingControlsFeaturesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsFeaturesARM.html + struct PhysicalDeviceSchedulingControlsFeaturesARM + { + using NativeType = VkPhysicalDeviceSchedulingControlsFeaturesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSchedulingControlsFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSchedulingControlsFeaturesARM( Bool32 schedulingControls_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , schedulingControls{ schedulingControls_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSchedulingControlsFeaturesARM( PhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSchedulingControlsFeaturesARM( VkPhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSchedulingControlsFeaturesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSchedulingControlsFeaturesARM & operator=( PhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSchedulingControlsFeaturesARM & operator=( VkPhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSchedulingControlsFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSchedulingControlsFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSchedulingControlsFeaturesARM & setSchedulingControls( Bool32 schedulingControls_ ) & VULKAN_HPP_NOEXCEPT + { + schedulingControls = schedulingControls_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSchedulingControlsFeaturesARM && setSchedulingControls( Bool32 schedulingControls_ ) && VULKAN_HPP_NOEXCEPT + { + schedulingControls = schedulingControls_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceSchedulingControlsFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSchedulingControlsFeaturesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSchedulingControlsFeaturesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSchedulingControlsFeaturesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, schedulingControls ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSchedulingControlsFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( schedulingControls == rhs.schedulingControls ); +# endif + } + + bool operator!=( PhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSchedulingControlsFeaturesARM; + void * pNext = {}; + Bool32 schedulingControls = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSchedulingControlsFeaturesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSchedulingControlsFeaturesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceSchedulingControlsPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsPropertiesARM.html + struct PhysicalDeviceSchedulingControlsPropertiesARM + { + using NativeType = VkPhysicalDeviceSchedulingControlsPropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSchedulingControlsPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSchedulingControlsPropertiesARM( PhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , schedulingControlsFlags{ schedulingControlsFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceSchedulingControlsPropertiesARM( PhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSchedulingControlsPropertiesARM( VkPhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSchedulingControlsPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSchedulingControlsPropertiesARM & operator=( PhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSchedulingControlsPropertiesARM & operator=( VkPhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceSchedulingControlsPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSchedulingControlsPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSchedulingControlsPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSchedulingControlsPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, schedulingControlsFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSchedulingControlsPropertiesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( schedulingControlsFlags == rhs.schedulingControlsFlags ); +# endif + } + + bool operator!=( PhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSchedulingControlsPropertiesARM; + void * pNext = {}; + PhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSchedulingControlsPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSchedulingControlsPropertiesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html + struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures + { + using NativeType = VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSeparateDepthStencilLayoutsFeatures( Bool32 separateDepthStencilLayouts_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , separateDepthStencilLayouts{ separateDepthStencilLayouts_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceSeparateDepthStencilLayoutsFeatures( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSeparateDepthStencilLayoutsFeatures( VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSeparateDepthStencilLayoutsFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSeparateDepthStencilLayoutsFeatures & + operator=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSeparateDepthStencilLayoutsFeatures & operator=( VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSeparateDepthStencilLayoutsFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSeparateDepthStencilLayoutsFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSeparateDepthStencilLayoutsFeatures & setSeparateDepthStencilLayouts( Bool32 separateDepthStencilLayouts_ ) & + VULKAN_HPP_NOEXCEPT + { + separateDepthStencilLayouts = separateDepthStencilLayouts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSeparateDepthStencilLayoutsFeatures && setSeparateDepthStencilLayouts( Bool32 separateDepthStencilLayouts_ ) && + VULKAN_HPP_NOEXCEPT + { + separateDepthStencilLayouts = separateDepthStencilLayouts_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, separateDepthStencilLayouts ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts ); +# endif + } + + bool operator!=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures; + void * pNext = {}; + Bool32 separateDepthStencilLayouts = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; + }; + + using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; + + // wrapper struct for struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShader64BitIndexingFeaturesEXT.html + struct PhysicalDeviceShader64BitIndexingFeaturesEXT + { + using NativeType = VkPhysicalDeviceShader64BitIndexingFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShader64BitIndexingFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShader64BitIndexingFeaturesEXT( Bool32 shader64BitIndexing_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shader64BitIndexing{ shader64BitIndexing_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShader64BitIndexingFeaturesEXT( PhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShader64BitIndexingFeaturesEXT( VkPhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShader64BitIndexingFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShader64BitIndexingFeaturesEXT & operator=( PhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShader64BitIndexingFeaturesEXT & operator=( VkPhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShader64BitIndexingFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShader64BitIndexingFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShader64BitIndexingFeaturesEXT & setShader64BitIndexing( Bool32 shader64BitIndexing_ ) & VULKAN_HPP_NOEXCEPT + { + shader64BitIndexing = shader64BitIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShader64BitIndexingFeaturesEXT && setShader64BitIndexing( Bool32 shader64BitIndexing_ ) && VULKAN_HPP_NOEXCEPT + { + shader64BitIndexing = shader64BitIndexing_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShader64BitIndexingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShader64BitIndexingFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShader64BitIndexingFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShader64BitIndexingFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shader64BitIndexing ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShader64BitIndexingFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shader64BitIndexing == rhs.shader64BitIndexing ); +# endif + } + + bool operator!=( PhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShader64BitIndexingFeaturesEXT; + void * pNext = {}; + Bool32 shader64BitIndexing = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShader64BitIndexingFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShader64BitIndexingFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.html + struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV + { + using NativeType = VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( Bool32 shaderFloat16VectorAtomics_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderFloat16VectorAtomics{ shaderFloat16VectorAtomics_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & + operator=( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & operator=( VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & setShaderFloat16VectorAtomics( Bool32 shaderFloat16VectorAtomics_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderFloat16VectorAtomics = shaderFloat16VectorAtomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV && setShaderFloat16VectorAtomics( Bool32 shaderFloat16VectorAtomics_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderFloat16VectorAtomics = shaderFloat16VectorAtomics_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderFloat16VectorAtomics ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16VectorAtomics == rhs.shaderFloat16VectorAtomics ); +# endif + } + + bool operator!=( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + void * pNext = {}; + Bool32 shaderFloat16VectorAtomics = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html + struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloat2FeaturesEXT( Bool32 shaderBufferFloat16Atomics_ = {}, + Bool32 shaderBufferFloat16AtomicAdd_ = {}, + Bool32 shaderBufferFloat16AtomicMinMax_ = {}, + Bool32 shaderBufferFloat32AtomicMinMax_ = {}, + Bool32 shaderBufferFloat64AtomicMinMax_ = {}, + Bool32 shaderSharedFloat16Atomics_ = {}, + Bool32 shaderSharedFloat16AtomicAdd_ = {}, + Bool32 shaderSharedFloat16AtomicMinMax_ = {}, + Bool32 shaderSharedFloat32AtomicMinMax_ = {}, + Bool32 shaderSharedFloat64AtomicMinMax_ = {}, + Bool32 shaderImageFloat32AtomicMinMax_ = {}, + Bool32 sparseImageFloat32AtomicMinMax_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderBufferFloat16Atomics{ shaderBufferFloat16Atomics_ } + , shaderBufferFloat16AtomicAdd{ shaderBufferFloat16AtomicAdd_ } + , shaderBufferFloat16AtomicMinMax{ shaderBufferFloat16AtomicMinMax_ } + , shaderBufferFloat32AtomicMinMax{ shaderBufferFloat32AtomicMinMax_ } + , shaderBufferFloat64AtomicMinMax{ shaderBufferFloat64AtomicMinMax_ } + , shaderSharedFloat16Atomics{ shaderSharedFloat16Atomics_ } + , shaderSharedFloat16AtomicAdd{ shaderSharedFloat16AtomicAdd_ } + , shaderSharedFloat16AtomicMinMax{ shaderSharedFloat16AtomicMinMax_ } + , shaderSharedFloat32AtomicMinMax{ shaderSharedFloat32AtomicMinMax_ } + , shaderSharedFloat64AtomicMinMax{ shaderSharedFloat64AtomicMinMax_ } + , shaderImageFloat32AtomicMinMax{ shaderImageFloat32AtomicMinMax_ } + , sparseImageFloat32AtomicMinMax{ sparseImageFloat32AtomicMinMax_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloat2FeaturesEXT( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderAtomicFloat2FeaturesEXT( VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderAtomicFloat2FeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderAtomicFloat2FeaturesEXT & operator=( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderAtomicFloat2FeaturesEXT & operator=( VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderBufferFloat16Atomics( Bool32 shaderBufferFloat16Atomics_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat16Atomics = shaderBufferFloat16Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderBufferFloat16Atomics( Bool32 shaderBufferFloat16Atomics_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat16Atomics = shaderBufferFloat16Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderBufferFloat16AtomicAdd( Bool32 shaderBufferFloat16AtomicAdd_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat16AtomicAdd = shaderBufferFloat16AtomicAdd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderBufferFloat16AtomicAdd( Bool32 shaderBufferFloat16AtomicAdd_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat16AtomicAdd = shaderBufferFloat16AtomicAdd_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderBufferFloat16AtomicMinMax( Bool32 shaderBufferFloat16AtomicMinMax_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat16AtomicMinMax = shaderBufferFloat16AtomicMinMax_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderBufferFloat16AtomicMinMax( Bool32 shaderBufferFloat16AtomicMinMax_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat16AtomicMinMax = shaderBufferFloat16AtomicMinMax_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderBufferFloat32AtomicMinMax( Bool32 shaderBufferFloat32AtomicMinMax_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat32AtomicMinMax = shaderBufferFloat32AtomicMinMax_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderBufferFloat32AtomicMinMax( Bool32 shaderBufferFloat32AtomicMinMax_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat32AtomicMinMax = shaderBufferFloat32AtomicMinMax_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderBufferFloat64AtomicMinMax( Bool32 shaderBufferFloat64AtomicMinMax_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat64AtomicMinMax = shaderBufferFloat64AtomicMinMax_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderBufferFloat64AtomicMinMax( Bool32 shaderBufferFloat64AtomicMinMax_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat64AtomicMinMax = shaderBufferFloat64AtomicMinMax_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderSharedFloat16Atomics( Bool32 shaderSharedFloat16Atomics_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat16Atomics = shaderSharedFloat16Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderSharedFloat16Atomics( Bool32 shaderSharedFloat16Atomics_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat16Atomics = shaderSharedFloat16Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderSharedFloat16AtomicAdd( Bool32 shaderSharedFloat16AtomicAdd_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat16AtomicAdd = shaderSharedFloat16AtomicAdd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderSharedFloat16AtomicAdd( Bool32 shaderSharedFloat16AtomicAdd_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat16AtomicAdd = shaderSharedFloat16AtomicAdd_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderSharedFloat16AtomicMinMax( Bool32 shaderSharedFloat16AtomicMinMax_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat16AtomicMinMax = shaderSharedFloat16AtomicMinMax_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderSharedFloat16AtomicMinMax( Bool32 shaderSharedFloat16AtomicMinMax_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat16AtomicMinMax = shaderSharedFloat16AtomicMinMax_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderSharedFloat32AtomicMinMax( Bool32 shaderSharedFloat32AtomicMinMax_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat32AtomicMinMax = shaderSharedFloat32AtomicMinMax_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderSharedFloat32AtomicMinMax( Bool32 shaderSharedFloat32AtomicMinMax_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat32AtomicMinMax = shaderSharedFloat32AtomicMinMax_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderSharedFloat64AtomicMinMax( Bool32 shaderSharedFloat64AtomicMinMax_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat64AtomicMinMax = shaderSharedFloat64AtomicMinMax_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderSharedFloat64AtomicMinMax( Bool32 shaderSharedFloat64AtomicMinMax_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat64AtomicMinMax = shaderSharedFloat64AtomicMinMax_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderImageFloat32AtomicMinMax( Bool32 shaderImageFloat32AtomicMinMax_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderImageFloat32AtomicMinMax = shaderImageFloat32AtomicMinMax_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderImageFloat32AtomicMinMax( Bool32 shaderImageFloat32AtomicMinMax_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderImageFloat32AtomicMinMax = shaderImageFloat32AtomicMinMax_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setSparseImageFloat32AtomicMinMax( Bool32 sparseImageFloat32AtomicMinMax_ ) & + VULKAN_HPP_NOEXCEPT + { + sparseImageFloat32AtomicMinMax = sparseImageFloat32AtomicMinMax_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setSparseImageFloat32AtomicMinMax( Bool32 sparseImageFloat32AtomicMinMax_ ) && + VULKAN_HPP_NOEXCEPT + { + sparseImageFloat32AtomicMinMax = sparseImageFloat32AtomicMinMax_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderBufferFloat16Atomics, + shaderBufferFloat16AtomicAdd, + shaderBufferFloat16AtomicMinMax, + shaderBufferFloat32AtomicMinMax, + shaderBufferFloat64AtomicMinMax, + shaderSharedFloat16Atomics, + shaderSharedFloat16AtomicAdd, + shaderSharedFloat16AtomicMinMax, + shaderSharedFloat32AtomicMinMax, + shaderSharedFloat64AtomicMinMax, + shaderImageFloat32AtomicMinMax, + sparseImageFloat32AtomicMinMax ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBufferFloat16Atomics == rhs.shaderBufferFloat16Atomics ) && + ( shaderBufferFloat16AtomicAdd == rhs.shaderBufferFloat16AtomicAdd ) && + ( shaderBufferFloat16AtomicMinMax == rhs.shaderBufferFloat16AtomicMinMax ) && + ( shaderBufferFloat32AtomicMinMax == rhs.shaderBufferFloat32AtomicMinMax ) && + ( shaderBufferFloat64AtomicMinMax == rhs.shaderBufferFloat64AtomicMinMax ) && ( shaderSharedFloat16Atomics == rhs.shaderSharedFloat16Atomics ) && + ( shaderSharedFloat16AtomicAdd == rhs.shaderSharedFloat16AtomicAdd ) && + ( shaderSharedFloat16AtomicMinMax == rhs.shaderSharedFloat16AtomicMinMax ) && + ( shaderSharedFloat32AtomicMinMax == rhs.shaderSharedFloat32AtomicMinMax ) && + ( shaderSharedFloat64AtomicMinMax == rhs.shaderSharedFloat64AtomicMinMax ) && + ( shaderImageFloat32AtomicMinMax == rhs.shaderImageFloat32AtomicMinMax ) && + ( sparseImageFloat32AtomicMinMax == rhs.sparseImageFloat32AtomicMinMax ); +# endif + } + + bool operator!=( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT; + void * pNext = {}; + Bool32 shaderBufferFloat16Atomics = {}; + Bool32 shaderBufferFloat16AtomicAdd = {}; + Bool32 shaderBufferFloat16AtomicMinMax = {}; + Bool32 shaderBufferFloat32AtomicMinMax = {}; + Bool32 shaderBufferFloat64AtomicMinMax = {}; + Bool32 shaderSharedFloat16Atomics = {}; + Bool32 shaderSharedFloat16AtomicAdd = {}; + Bool32 shaderSharedFloat16AtomicMinMax = {}; + Bool32 shaderSharedFloat32AtomicMinMax = {}; + Bool32 shaderSharedFloat64AtomicMinMax = {}; + Bool32 shaderImageFloat32AtomicMinMax = {}; + Bool32 sparseImageFloat32AtomicMinMax = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAtomicFloat2FeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAtomicFloat2FeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html + struct PhysicalDeviceShaderAtomicFloatFeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloatFeaturesEXT( Bool32 shaderBufferFloat32Atomics_ = {}, + Bool32 shaderBufferFloat32AtomicAdd_ = {}, + Bool32 shaderBufferFloat64Atomics_ = {}, + Bool32 shaderBufferFloat64AtomicAdd_ = {}, + Bool32 shaderSharedFloat32Atomics_ = {}, + Bool32 shaderSharedFloat32AtomicAdd_ = {}, + Bool32 shaderSharedFloat64Atomics_ = {}, + Bool32 shaderSharedFloat64AtomicAdd_ = {}, + Bool32 shaderImageFloat32Atomics_ = {}, + Bool32 shaderImageFloat32AtomicAdd_ = {}, + Bool32 sparseImageFloat32Atomics_ = {}, + Bool32 sparseImageFloat32AtomicAdd_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderBufferFloat32Atomics{ shaderBufferFloat32Atomics_ } + , shaderBufferFloat32AtomicAdd{ shaderBufferFloat32AtomicAdd_ } + , shaderBufferFloat64Atomics{ shaderBufferFloat64Atomics_ } + , shaderBufferFloat64AtomicAdd{ shaderBufferFloat64AtomicAdd_ } + , shaderSharedFloat32Atomics{ shaderSharedFloat32Atomics_ } + , shaderSharedFloat32AtomicAdd{ shaderSharedFloat32AtomicAdd_ } + , shaderSharedFloat64Atomics{ shaderSharedFloat64Atomics_ } + , shaderSharedFloat64AtomicAdd{ shaderSharedFloat64AtomicAdd_ } + , shaderImageFloat32Atomics{ shaderImageFloat32Atomics_ } + , shaderImageFloat32AtomicAdd{ shaderImageFloat32AtomicAdd_ } + , sparseImageFloat32Atomics{ sparseImageFloat32Atomics_ } + , sparseImageFloat32AtomicAdd{ sparseImageFloat32AtomicAdd_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloatFeaturesEXT( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderAtomicFloatFeaturesEXT( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderAtomicFloatFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderAtomicFloatFeaturesEXT & operator=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderAtomicFloatFeaturesEXT & operator=( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderBufferFloat32Atomics( Bool32 shaderBufferFloat32Atomics_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat32Atomics = shaderBufferFloat32Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderBufferFloat32Atomics( Bool32 shaderBufferFloat32Atomics_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat32Atomics = shaderBufferFloat32Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderBufferFloat32AtomicAdd( Bool32 shaderBufferFloat32AtomicAdd_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat32AtomicAdd = shaderBufferFloat32AtomicAdd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderBufferFloat32AtomicAdd( Bool32 shaderBufferFloat32AtomicAdd_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat32AtomicAdd = shaderBufferFloat32AtomicAdd_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderBufferFloat64Atomics( Bool32 shaderBufferFloat64Atomics_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat64Atomics = shaderBufferFloat64Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderBufferFloat64Atomics( Bool32 shaderBufferFloat64Atomics_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat64Atomics = shaderBufferFloat64Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderBufferFloat64AtomicAdd( Bool32 shaderBufferFloat64AtomicAdd_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat64AtomicAdd = shaderBufferFloat64AtomicAdd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderBufferFloat64AtomicAdd( Bool32 shaderBufferFloat64AtomicAdd_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderBufferFloat64AtomicAdd = shaderBufferFloat64AtomicAdd_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderSharedFloat32Atomics( Bool32 shaderSharedFloat32Atomics_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat32Atomics = shaderSharedFloat32Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderSharedFloat32Atomics( Bool32 shaderSharedFloat32Atomics_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat32Atomics = shaderSharedFloat32Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderSharedFloat32AtomicAdd( Bool32 shaderSharedFloat32AtomicAdd_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat32AtomicAdd = shaderSharedFloat32AtomicAdd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderSharedFloat32AtomicAdd( Bool32 shaderSharedFloat32AtomicAdd_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat32AtomicAdd = shaderSharedFloat32AtomicAdd_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderSharedFloat64Atomics( Bool32 shaderSharedFloat64Atomics_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat64Atomics = shaderSharedFloat64Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderSharedFloat64Atomics( Bool32 shaderSharedFloat64Atomics_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat64Atomics = shaderSharedFloat64Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderSharedFloat64AtomicAdd( Bool32 shaderSharedFloat64AtomicAdd_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat64AtomicAdd = shaderSharedFloat64AtomicAdd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderSharedFloat64AtomicAdd( Bool32 shaderSharedFloat64AtomicAdd_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSharedFloat64AtomicAdd = shaderSharedFloat64AtomicAdd_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderImageFloat32Atomics( Bool32 shaderImageFloat32Atomics_ ) & VULKAN_HPP_NOEXCEPT + { + shaderImageFloat32Atomics = shaderImageFloat32Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderImageFloat32Atomics( Bool32 shaderImageFloat32Atomics_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderImageFloat32Atomics = shaderImageFloat32Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderImageFloat32AtomicAdd( Bool32 shaderImageFloat32AtomicAdd_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderImageFloat32AtomicAdd = shaderImageFloat32AtomicAdd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderImageFloat32AtomicAdd( Bool32 shaderImageFloat32AtomicAdd_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderImageFloat32AtomicAdd = shaderImageFloat32AtomicAdd_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setSparseImageFloat32Atomics( Bool32 sparseImageFloat32Atomics_ ) & VULKAN_HPP_NOEXCEPT + { + sparseImageFloat32Atomics = sparseImageFloat32Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setSparseImageFloat32Atomics( Bool32 sparseImageFloat32Atomics_ ) && + VULKAN_HPP_NOEXCEPT + { + sparseImageFloat32Atomics = sparseImageFloat32Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setSparseImageFloat32AtomicAdd( Bool32 sparseImageFloat32AtomicAdd_ ) & + VULKAN_HPP_NOEXCEPT + { + sparseImageFloat32AtomicAdd = sparseImageFloat32AtomicAdd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setSparseImageFloat32AtomicAdd( Bool32 sparseImageFloat32AtomicAdd_ ) && + VULKAN_HPP_NOEXCEPT + { + sparseImageFloat32AtomicAdd = sparseImageFloat32AtomicAdd_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderBufferFloat32Atomics, + shaderBufferFloat32AtomicAdd, + shaderBufferFloat64Atomics, + shaderBufferFloat64AtomicAdd, + shaderSharedFloat32Atomics, + shaderSharedFloat32AtomicAdd, + shaderSharedFloat64Atomics, + shaderSharedFloat64AtomicAdd, + shaderImageFloat32Atomics, + shaderImageFloat32AtomicAdd, + sparseImageFloat32Atomics, + sparseImageFloat32AtomicAdd ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBufferFloat32Atomics == rhs.shaderBufferFloat32Atomics ) && + ( shaderBufferFloat32AtomicAdd == rhs.shaderBufferFloat32AtomicAdd ) && ( shaderBufferFloat64Atomics == rhs.shaderBufferFloat64Atomics ) && + ( shaderBufferFloat64AtomicAdd == rhs.shaderBufferFloat64AtomicAdd ) && ( shaderSharedFloat32Atomics == rhs.shaderSharedFloat32Atomics ) && + ( shaderSharedFloat32AtomicAdd == rhs.shaderSharedFloat32AtomicAdd ) && ( shaderSharedFloat64Atomics == rhs.shaderSharedFloat64Atomics ) && + ( shaderSharedFloat64AtomicAdd == rhs.shaderSharedFloat64AtomicAdd ) && ( shaderImageFloat32Atomics == rhs.shaderImageFloat32Atomics ) && + ( shaderImageFloat32AtomicAdd == rhs.shaderImageFloat32AtomicAdd ) && ( sparseImageFloat32Atomics == rhs.sparseImageFloat32Atomics ) && + ( sparseImageFloat32AtomicAdd == rhs.sparseImageFloat32AtomicAdd ); +# endif + } + + bool operator!=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT; + void * pNext = {}; + Bool32 shaderBufferFloat32Atomics = {}; + Bool32 shaderBufferFloat32AtomicAdd = {}; + Bool32 shaderBufferFloat64Atomics = {}; + Bool32 shaderBufferFloat64AtomicAdd = {}; + Bool32 shaderSharedFloat32Atomics = {}; + Bool32 shaderSharedFloat32AtomicAdd = {}; + Bool32 shaderSharedFloat64Atomics = {}; + Bool32 shaderSharedFloat64AtomicAdd = {}; + Bool32 shaderImageFloat32Atomics = {}; + Bool32 shaderImageFloat32AtomicAdd = {}; + Bool32 sparseImageFloat32Atomics = {}; + Bool32 sparseImageFloat32AtomicAdd = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAtomicFloatFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAtomicFloatFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderAtomicInt64Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html + struct PhysicalDeviceShaderAtomicInt64Features + { + using NativeType = VkPhysicalDeviceShaderAtomicInt64Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAtomicInt64Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64Features( Bool32 shaderBufferInt64Atomics_ = {}, + Bool32 shaderSharedInt64Atomics_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderBufferInt64Atomics{ shaderBufferInt64Atomics_ } + , shaderSharedInt64Atomics{ shaderSharedInt64Atomics_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64Features( PhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderAtomicInt64Features( VkPhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderAtomicInt64Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderAtomicInt64Features & operator=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderAtomicInt64Features & operator=( VkPhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features & setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ ) & VULKAN_HPP_NOEXCEPT + { + shaderBufferInt64Atomics = shaderBufferInt64Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features && setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ ) && VULKAN_HPP_NOEXCEPT + { + shaderBufferInt64Atomics = shaderBufferInt64Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features & setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ ) & VULKAN_HPP_NOEXCEPT + { + shaderSharedInt64Atomics = shaderSharedInt64Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features && setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ ) && VULKAN_HPP_NOEXCEPT + { + shaderSharedInt64Atomics = shaderSharedInt64Atomics_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderAtomicInt64Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicInt64Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicInt64Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderAtomicInt64Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderBufferInt64Atomics, shaderSharedInt64Atomics ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderAtomicInt64Features const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) && + ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ); +# endif + } + + bool operator!=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64Features; + void * pNext = {}; + Bool32 shaderBufferInt64Atomics = {}; + Bool32 shaderSharedInt64Atomics = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAtomicInt64Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderAtomicInt64Features; + }; + + using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features; + + // wrapper struct for struct VkPhysicalDeviceShaderBfloat16FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderBfloat16FeaturesKHR.html + struct PhysicalDeviceShaderBfloat16FeaturesKHR + { + using NativeType = VkPhysicalDeviceShaderBfloat16FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderBfloat16FeaturesKHR( Bool32 shaderBFloat16Type_ = {}, + Bool32 shaderBFloat16DotProduct_ = {}, + Bool32 shaderBFloat16CooperativeMatrix_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderBFloat16Type{ shaderBFloat16Type_ } + , shaderBFloat16DotProduct{ shaderBFloat16DotProduct_ } + , shaderBFloat16CooperativeMatrix{ shaderBFloat16CooperativeMatrix_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderBfloat16FeaturesKHR( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderBfloat16FeaturesKHR( VkPhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderBfloat16FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderBfloat16FeaturesKHR & operator=( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderBfloat16FeaturesKHR & operator=( VkPhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR & setShaderBFloat16Type( Bool32 shaderBFloat16Type_ ) & VULKAN_HPP_NOEXCEPT + { + shaderBFloat16Type = shaderBFloat16Type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR && setShaderBFloat16Type( Bool32 shaderBFloat16Type_ ) && VULKAN_HPP_NOEXCEPT + { + shaderBFloat16Type = shaderBFloat16Type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR & setShaderBFloat16DotProduct( Bool32 shaderBFloat16DotProduct_ ) & VULKAN_HPP_NOEXCEPT + { + shaderBFloat16DotProduct = shaderBFloat16DotProduct_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR && setShaderBFloat16DotProduct( Bool32 shaderBFloat16DotProduct_ ) && VULKAN_HPP_NOEXCEPT + { + shaderBFloat16DotProduct = shaderBFloat16DotProduct_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR & setShaderBFloat16CooperativeMatrix( Bool32 shaderBFloat16CooperativeMatrix_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderBFloat16CooperativeMatrix = shaderBFloat16CooperativeMatrix_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR && setShaderBFloat16CooperativeMatrix( Bool32 shaderBFloat16CooperativeMatrix_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderBFloat16CooperativeMatrix = shaderBFloat16CooperativeMatrix_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderBfloat16FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderBfloat16FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderBfloat16FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderBfloat16FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderBFloat16Type, shaderBFloat16DotProduct, shaderBFloat16CooperativeMatrix ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderBfloat16FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBFloat16Type == rhs.shaderBFloat16Type ) && + ( shaderBFloat16DotProduct == rhs.shaderBFloat16DotProduct ) && ( shaderBFloat16CooperativeMatrix == rhs.shaderBFloat16CooperativeMatrix ); +# endif + } + + bool operator!=( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR; + void * pNext = {}; + Bool32 shaderBFloat16Type = {}; + Bool32 shaderBFloat16DotProduct = {}; + Bool32 shaderBFloat16CooperativeMatrix = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderBfloat16FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderBfloat16FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderClockFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html + struct PhysicalDeviceShaderClockFeaturesKHR + { + using NativeType = VkPhysicalDeviceShaderClockFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderClockFeaturesKHR( Bool32 shaderSubgroupClock_ = {}, Bool32 shaderDeviceClock_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderSubgroupClock{ shaderSubgroupClock_ } + , shaderDeviceClock{ shaderDeviceClock_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderClockFeaturesKHR( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderClockFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderClockFeaturesKHR & operator=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderClockFeaturesKHR & operator=( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR & setShaderSubgroupClock( Bool32 shaderSubgroupClock_ ) & VULKAN_HPP_NOEXCEPT + { + shaderSubgroupClock = shaderSubgroupClock_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR && setShaderSubgroupClock( Bool32 shaderSubgroupClock_ ) && VULKAN_HPP_NOEXCEPT + { + shaderSubgroupClock = shaderSubgroupClock_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR & setShaderDeviceClock( Bool32 shaderDeviceClock_ ) & VULKAN_HPP_NOEXCEPT + { + shaderDeviceClock = shaderDeviceClock_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR && setShaderDeviceClock( Bool32 shaderDeviceClock_ ) && VULKAN_HPP_NOEXCEPT + { + shaderDeviceClock = shaderDeviceClock_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderClockFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderClockFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderClockFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderClockFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSubgroupClock, shaderDeviceClock ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderClockFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupClock == rhs.shaderSubgroupClock ) && + ( shaderDeviceClock == rhs.shaderDeviceClock ); +# endif + } + + bool operator!=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR; + void * pNext = {}; + Bool32 shaderSubgroupClock = {}; + Bool32 shaderDeviceClock = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderClockFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderClockFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.html + struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM + { + using NativeType = VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreBuiltinsFeaturesARM( Bool32 shaderCoreBuiltins_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderCoreBuiltins{ shaderCoreBuiltins_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreBuiltinsFeaturesARM( PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderCoreBuiltinsFeaturesARM( VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderCoreBuiltinsFeaturesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderCoreBuiltinsFeaturesARM & operator=( PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderCoreBuiltinsFeaturesARM & operator=( VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderCoreBuiltinsFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderCoreBuiltinsFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderCoreBuiltinsFeaturesARM & setShaderCoreBuiltins( Bool32 shaderCoreBuiltins_ ) & VULKAN_HPP_NOEXCEPT + { + shaderCoreBuiltins = shaderCoreBuiltins_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderCoreBuiltinsFeaturesARM && setShaderCoreBuiltins( Bool32 shaderCoreBuiltins_ ) && VULKAN_HPP_NOEXCEPT + { + shaderCoreBuiltins = shaderCoreBuiltins_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderCoreBuiltins ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreBuiltins == rhs.shaderCoreBuiltins ); +# endif + } + + bool operator!=( PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM; + void * pNext = {}; + Bool32 shaderCoreBuiltins = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCoreBuiltinsFeaturesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCoreBuiltinsFeaturesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM.html + struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM + { + using NativeType = VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreBuiltinsPropertiesARM( uint64_t shaderCoreMask_ = {}, + uint32_t shaderCoreCount_ = {}, + uint32_t shaderWarpsPerCore_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderCoreMask{ shaderCoreMask_ } + , shaderCoreCount{ shaderCoreCount_ } + , shaderWarpsPerCore{ shaderWarpsPerCore_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderCoreBuiltinsPropertiesARM( PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderCoreBuiltinsPropertiesARM( VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderCoreBuiltinsPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderCoreBuiltinsPropertiesARM & operator=( PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderCoreBuiltinsPropertiesARM & operator=( VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderCoreMask, shaderCoreCount, shaderWarpsPerCore ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreMask == rhs.shaderCoreMask ) && ( shaderCoreCount == rhs.shaderCoreCount ) && + ( shaderWarpsPerCore == rhs.shaderWarpsPerCore ); +# endif + } + + bool operator!=( PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM; + void * pNext = {}; + uint64_t shaderCoreMask = {}; + uint32_t shaderCoreCount = {}; + uint32_t shaderWarpsPerCore = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCoreBuiltinsPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCoreBuiltinsPropertiesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderCoreProperties2AMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html + struct PhysicalDeviceShaderCoreProperties2AMD + { + using NativeType = VkPhysicalDeviceShaderCoreProperties2AMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreProperties2AMD( ShaderCorePropertiesFlagsAMD shaderCoreFeatures_ = {}, + uint32_t activeComputeUnitCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderCoreFeatures{ shaderCoreFeatures_ } + , activeComputeUnitCount{ activeComputeUnitCount_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreProperties2AMD( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderCoreProperties2AMD( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderCoreProperties2AMD & operator=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderCoreProperties2AMD & operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderCoreProperties2AMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCoreProperties2AMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCoreProperties2AMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCoreProperties2AMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderCoreFeatures, activeComputeUnitCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderCoreProperties2AMD const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreFeatures == rhs.shaderCoreFeatures ) && + ( activeComputeUnitCount == rhs.activeComputeUnitCount ); +# endif + } + + bool operator!=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD; + void * pNext = {}; + ShaderCorePropertiesFlagsAMD shaderCoreFeatures = {}; + uint32_t activeComputeUnitCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCoreProperties2AMD; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCoreProperties2AMD; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderCorePropertiesAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html + struct PhysicalDeviceShaderCorePropertiesAMD + { + using NativeType = VkPhysicalDeviceShaderCorePropertiesAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesAMD( uint32_t shaderEngineCount_ = {}, + uint32_t shaderArraysPerEngineCount_ = {}, + uint32_t computeUnitsPerShaderArray_ = {}, + uint32_t simdPerComputeUnit_ = {}, + uint32_t wavefrontsPerSimd_ = {}, + uint32_t wavefrontSize_ = {}, + uint32_t sgprsPerSimd_ = {}, + uint32_t minSgprAllocation_ = {}, + uint32_t maxSgprAllocation_ = {}, + uint32_t sgprAllocationGranularity_ = {}, + uint32_t vgprsPerSimd_ = {}, + uint32_t minVgprAllocation_ = {}, + uint32_t maxVgprAllocation_ = {}, + uint32_t vgprAllocationGranularity_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderEngineCount{ shaderEngineCount_ } + , shaderArraysPerEngineCount{ shaderArraysPerEngineCount_ } + , computeUnitsPerShaderArray{ computeUnitsPerShaderArray_ } + , simdPerComputeUnit{ simdPerComputeUnit_ } + , wavefrontsPerSimd{ wavefrontsPerSimd_ } + , wavefrontSize{ wavefrontSize_ } + , sgprsPerSimd{ sgprsPerSimd_ } + , minSgprAllocation{ minSgprAllocation_ } + , maxSgprAllocation{ maxSgprAllocation_ } + , sgprAllocationGranularity{ sgprAllocationGranularity_ } + , vgprsPerSimd{ vgprsPerSimd_ } + , minVgprAllocation{ minVgprAllocation_ } + , maxVgprAllocation{ maxVgprAllocation_ } + , vgprAllocationGranularity{ vgprAllocationGranularity_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesAMD( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderCorePropertiesAMD( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderCorePropertiesAMD & operator=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderCorePropertiesAMD & operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderCorePropertiesAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCorePropertiesAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCorePropertiesAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCorePropertiesAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + shaderEngineCount, + shaderArraysPerEngineCount, + computeUnitsPerShaderArray, + simdPerComputeUnit, + wavefrontsPerSimd, + wavefrontSize, + sgprsPerSimd, + minSgprAllocation, + maxSgprAllocation, + sgprAllocationGranularity, + vgprsPerSimd, + minVgprAllocation, + maxVgprAllocation, + vgprAllocationGranularity ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderCorePropertiesAMD const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEngineCount == rhs.shaderEngineCount ) && + ( shaderArraysPerEngineCount == rhs.shaderArraysPerEngineCount ) && ( computeUnitsPerShaderArray == rhs.computeUnitsPerShaderArray ) && + ( simdPerComputeUnit == rhs.simdPerComputeUnit ) && ( wavefrontsPerSimd == rhs.wavefrontsPerSimd ) && ( wavefrontSize == rhs.wavefrontSize ) && + ( sgprsPerSimd == rhs.sgprsPerSimd ) && ( minSgprAllocation == rhs.minSgprAllocation ) && ( maxSgprAllocation == rhs.maxSgprAllocation ) && + ( sgprAllocationGranularity == rhs.sgprAllocationGranularity ) && ( vgprsPerSimd == rhs.vgprsPerSimd ) && + ( minVgprAllocation == rhs.minVgprAllocation ) && ( maxVgprAllocation == rhs.maxVgprAllocation ) && + ( vgprAllocationGranularity == rhs.vgprAllocationGranularity ); +# endif + } + + bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; + void * pNext = {}; + uint32_t shaderEngineCount = {}; + uint32_t shaderArraysPerEngineCount = {}; + uint32_t computeUnitsPerShaderArray = {}; + uint32_t simdPerComputeUnit = {}; + uint32_t wavefrontsPerSimd = {}; + uint32_t wavefrontSize = {}; + uint32_t sgprsPerSimd = {}; + uint32_t minSgprAllocation = {}; + uint32_t maxSgprAllocation = {}; + uint32_t sgprAllocationGranularity = {}; + uint32_t vgprsPerSimd = {}; + uint32_t minVgprAllocation = {}; + uint32_t maxVgprAllocation = {}; + uint32_t vgprAllocationGranularity = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCorePropertiesAMD; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCorePropertiesAMD; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderCorePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCorePropertiesARM.html + struct PhysicalDeviceShaderCorePropertiesARM + { + using NativeType = VkPhysicalDeviceShaderCorePropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCorePropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesARM( uint32_t pixelRate_ = {}, + uint32_t texelRate_ = {}, + uint32_t fmaRate_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pixelRate{ pixelRate_ } + , texelRate{ texelRate_ } + , fmaRate{ fmaRate_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesARM( PhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderCorePropertiesARM( VkPhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderCorePropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderCorePropertiesARM & operator=( PhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderCorePropertiesARM & operator=( VkPhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderCorePropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCorePropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCorePropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderCorePropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pixelRate, texelRate, fmaRate ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderCorePropertiesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderCorePropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pixelRate == rhs.pixelRate ) && ( texelRate == rhs.texelRate ) && ( fmaRate == rhs.fmaRate ); +# endif + } + + bool operator!=( PhysicalDeviceShaderCorePropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesARM; + void * pNext = {}; + uint32_t pixelRate = {}; + uint32_t texelRate = {}; + uint32_t fmaRate = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCorePropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderCorePropertiesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.html + struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures + { + using NativeType = VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeatures( Bool32 shaderDemoteToHelperInvocation_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderDemoteToHelperInvocation{ shaderDemoteToHelperInvocation_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderDemoteToHelperInvocationFeatures( PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderDemoteToHelperInvocationFeatures( VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderDemoteToHelperInvocationFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderDemoteToHelperInvocationFeatures & + operator=( PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderDemoteToHelperInvocationFeatures & operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDemoteToHelperInvocationFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDemoteToHelperInvocationFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDemoteToHelperInvocationFeatures & setShaderDemoteToHelperInvocation( Bool32 shaderDemoteToHelperInvocation_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDemoteToHelperInvocationFeatures && + setShaderDemoteToHelperInvocation( Bool32 shaderDemoteToHelperInvocation_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderDemoteToHelperInvocation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation ); +# endif + } + + bool operator!=( PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeatures; + void * pNext = {}; + Bool32 shaderDemoteToHelperInvocation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; + }; + + using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; + + // wrapper struct for struct VkPhysicalDeviceShaderDrawParametersFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderDrawParametersFeatures.html + struct PhysicalDeviceShaderDrawParametersFeatures + { + using NativeType = VkPhysicalDeviceShaderDrawParametersFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( Bool32 shaderDrawParameters_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderDrawParameters{ shaderDrawParameters_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderDrawParametersFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderDrawParametersFeatures & operator=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderDrawParametersFeatures & operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDrawParametersFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDrawParametersFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDrawParametersFeatures & setShaderDrawParameters( Bool32 shaderDrawParameters_ ) & VULKAN_HPP_NOEXCEPT + { + shaderDrawParameters = shaderDrawParameters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDrawParametersFeatures && setShaderDrawParameters( Bool32 shaderDrawParameters_ ) && VULKAN_HPP_NOEXCEPT + { + shaderDrawParameters = shaderDrawParameters_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderDrawParametersFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderDrawParametersFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderDrawParametersFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderDrawParametersFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderDrawParameters ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderDrawParametersFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDrawParameters == rhs.shaderDrawParameters ); +# endif + } + + bool operator!=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures; + void * pNext = {}; + Bool32 shaderDrawParameters = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderDrawParametersFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderDrawParametersFeatures; + }; + + using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures; + + // wrapper struct for struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.html + struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD + { + using NativeType = VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( Bool32 shaderEarlyAndLateFragmentTests_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderEarlyAndLateFragmentTests{ shaderEarlyAndLateFragmentTests_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD & + operator=( PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD & + operator=( VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD & + setShaderEarlyAndLateFragmentTests( Bool32 shaderEarlyAndLateFragmentTests_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderEarlyAndLateFragmentTests = shaderEarlyAndLateFragmentTests_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD && + setShaderEarlyAndLateFragmentTests( Bool32 shaderEarlyAndLateFragmentTests_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderEarlyAndLateFragmentTests = shaderEarlyAndLateFragmentTests_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderEarlyAndLateFragmentTests ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEarlyAndLateFragmentTests == rhs.shaderEarlyAndLateFragmentTests ); +# endif + } + + bool operator!=( PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + void * pNext = {}; + Bool32 shaderEarlyAndLateFragmentTests = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkPhysicalDeviceShaderEnqueueFeaturesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderEnqueueFeaturesAMDX.html + struct PhysicalDeviceShaderEnqueueFeaturesAMDX + { + using NativeType = VkPhysicalDeviceShaderEnqueueFeaturesAMDX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderEnqueueFeaturesAMDX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderEnqueueFeaturesAMDX( Bool32 shaderEnqueue_ = {}, Bool32 shaderMeshEnqueue_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderEnqueue{ shaderEnqueue_ } + , shaderMeshEnqueue{ shaderMeshEnqueue_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderEnqueueFeaturesAMDX( PhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderEnqueueFeaturesAMDX( VkPhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderEnqueueFeaturesAMDX( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderEnqueueFeaturesAMDX & operator=( PhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderEnqueueFeaturesAMDX & operator=( VkPhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX & setShaderEnqueue( Bool32 shaderEnqueue_ ) & VULKAN_HPP_NOEXCEPT + { + shaderEnqueue = shaderEnqueue_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX && setShaderEnqueue( Bool32 shaderEnqueue_ ) && VULKAN_HPP_NOEXCEPT + { + shaderEnqueue = shaderEnqueue_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX & setShaderMeshEnqueue( Bool32 shaderMeshEnqueue_ ) & VULKAN_HPP_NOEXCEPT + { + shaderMeshEnqueue = shaderMeshEnqueue_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX && setShaderMeshEnqueue( Bool32 shaderMeshEnqueue_ ) && VULKAN_HPP_NOEXCEPT + { + shaderMeshEnqueue = shaderMeshEnqueue_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderEnqueueFeaturesAMDX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderEnqueueFeaturesAMDX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderEnqueueFeaturesAMDX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderEnqueueFeaturesAMDX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderEnqueue, shaderMeshEnqueue ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderEnqueueFeaturesAMDX const & ) const = default; +# else + bool operator==( PhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEnqueue == rhs.shaderEnqueue ) && ( shaderMeshEnqueue == rhs.shaderMeshEnqueue ); +# endif + } + + bool operator!=( PhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderEnqueueFeaturesAMDX; + void * pNext = {}; + Bool32 shaderEnqueue = {}; + Bool32 shaderMeshEnqueue = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderEnqueueFeaturesAMDX; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderEnqueueFeaturesAMDX; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderEnqueuePropertiesAMDX.html + struct PhysicalDeviceShaderEnqueuePropertiesAMDX + { + using NativeType = VkPhysicalDeviceShaderEnqueuePropertiesAMDX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderEnqueuePropertiesAMDX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueuePropertiesAMDX( uint32_t maxExecutionGraphDepth_ = {}, + uint32_t maxExecutionGraphShaderOutputNodes_ = {}, + uint32_t maxExecutionGraphShaderPayloadSize_ = {}, + uint32_t maxExecutionGraphShaderPayloadCount_ = {}, + uint32_t executionGraphDispatchAddressAlignment_ = {}, + std::array const & maxExecutionGraphWorkgroupCount_ = {}, + uint32_t maxExecutionGraphWorkgroups_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxExecutionGraphDepth{ maxExecutionGraphDepth_ } + , maxExecutionGraphShaderOutputNodes{ maxExecutionGraphShaderOutputNodes_ } + , maxExecutionGraphShaderPayloadSize{ maxExecutionGraphShaderPayloadSize_ } + , maxExecutionGraphShaderPayloadCount{ maxExecutionGraphShaderPayloadCount_ } + , executionGraphDispatchAddressAlignment{ executionGraphDispatchAddressAlignment_ } + , maxExecutionGraphWorkgroupCount{ maxExecutionGraphWorkgroupCount_ } + , maxExecutionGraphWorkgroups{ maxExecutionGraphWorkgroups_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueuePropertiesAMDX( PhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderEnqueuePropertiesAMDX( VkPhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderEnqueuePropertiesAMDX( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderEnqueuePropertiesAMDX & operator=( PhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderEnqueuePropertiesAMDX & operator=( VkPhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderEnqueuePropertiesAMDX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderEnqueuePropertiesAMDX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderEnqueuePropertiesAMDX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderEnqueuePropertiesAMDX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + uint32_t const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxExecutionGraphDepth, + maxExecutionGraphShaderOutputNodes, + maxExecutionGraphShaderPayloadSize, + maxExecutionGraphShaderPayloadCount, + executionGraphDispatchAddressAlignment, + maxExecutionGraphWorkgroupCount, + maxExecutionGraphWorkgroups ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderEnqueuePropertiesAMDX const & ) const = default; +# else + bool operator==( PhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxExecutionGraphDepth == rhs.maxExecutionGraphDepth ) && + ( maxExecutionGraphShaderOutputNodes == rhs.maxExecutionGraphShaderOutputNodes ) && + ( maxExecutionGraphShaderPayloadSize == rhs.maxExecutionGraphShaderPayloadSize ) && + ( maxExecutionGraphShaderPayloadCount == rhs.maxExecutionGraphShaderPayloadCount ) && + ( executionGraphDispatchAddressAlignment == rhs.executionGraphDispatchAddressAlignment ) && + ( maxExecutionGraphWorkgroupCount == rhs.maxExecutionGraphWorkgroupCount ) && ( maxExecutionGraphWorkgroups == rhs.maxExecutionGraphWorkgroups ); +# endif + } + + bool operator!=( PhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderEnqueuePropertiesAMDX; + void * pNext = {}; + uint32_t maxExecutionGraphDepth = {}; + uint32_t maxExecutionGraphShaderOutputNodes = {}; + uint32_t maxExecutionGraphShaderPayloadSize = {}; + uint32_t maxExecutionGraphShaderPayloadCount = {}; + uint32_t executionGraphDispatchAddressAlignment = {}; + ArrayWrapper1D maxExecutionGraphWorkgroupCount = {}; + uint32_t maxExecutionGraphWorkgroups = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderEnqueuePropertiesAMDX; + }; +# endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderEnqueuePropertiesAMDX; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkPhysicalDeviceShaderExpectAssumeFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderExpectAssumeFeatures.html + struct PhysicalDeviceShaderExpectAssumeFeatures + { + using NativeType = VkPhysicalDeviceShaderExpectAssumeFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderExpectAssumeFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderExpectAssumeFeatures( Bool32 shaderExpectAssume_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderExpectAssume{ shaderExpectAssume_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderExpectAssumeFeatures( PhysicalDeviceShaderExpectAssumeFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderExpectAssumeFeatures( VkPhysicalDeviceShaderExpectAssumeFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderExpectAssumeFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderExpectAssumeFeatures & operator=( PhysicalDeviceShaderExpectAssumeFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderExpectAssumeFeatures & operator=( VkPhysicalDeviceShaderExpectAssumeFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderExpectAssumeFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderExpectAssumeFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderExpectAssumeFeatures & setShaderExpectAssume( Bool32 shaderExpectAssume_ ) & VULKAN_HPP_NOEXCEPT + { + shaderExpectAssume = shaderExpectAssume_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderExpectAssumeFeatures && setShaderExpectAssume( Bool32 shaderExpectAssume_ ) && VULKAN_HPP_NOEXCEPT + { + shaderExpectAssume = shaderExpectAssume_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderExpectAssumeFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderExpectAssumeFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderExpectAssumeFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderExpectAssumeFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderExpectAssume ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderExpectAssumeFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderExpectAssumeFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderExpectAssume == rhs.shaderExpectAssume ); +# endif + } + + bool operator!=( PhysicalDeviceShaderExpectAssumeFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderExpectAssumeFeatures; + void * pNext = {}; + Bool32 shaderExpectAssume = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderExpectAssumeFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderExpectAssumeFeatures; + }; + + using PhysicalDeviceShaderExpectAssumeFeaturesKHR = PhysicalDeviceShaderExpectAssumeFeatures; + + // wrapper struct for struct VkPhysicalDeviceShaderFloat16Int8Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html + struct PhysicalDeviceShaderFloat16Int8Features + { + using NativeType = VkPhysicalDeviceShaderFloat16Int8Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFloat16Int8Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderFloat16Int8Features( Bool32 shaderFloat16_ = {}, Bool32 shaderInt8_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderFloat16{ shaderFloat16_ } + , shaderInt8{ shaderInt8_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8Features( PhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderFloat16Int8Features( VkPhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderFloat16Int8Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderFloat16Int8Features & operator=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderFloat16Int8Features & operator=( VkPhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features & setShaderFloat16( Bool32 shaderFloat16_ ) & VULKAN_HPP_NOEXCEPT + { + shaderFloat16 = shaderFloat16_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features && setShaderFloat16( Bool32 shaderFloat16_ ) && VULKAN_HPP_NOEXCEPT + { + shaderFloat16 = shaderFloat16_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features & setShaderInt8( Bool32 shaderInt8_ ) & VULKAN_HPP_NOEXCEPT + { + shaderInt8 = shaderInt8_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features && setShaderInt8( Bool32 shaderInt8_ ) && VULKAN_HPP_NOEXCEPT + { + shaderInt8 = shaderInt8_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderFloat16Int8Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFloat16Int8Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFloat16Int8Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFloat16Int8Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderFloat16, shaderInt8 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderFloat16Int8Features const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16 == rhs.shaderFloat16 ) && ( shaderInt8 == rhs.shaderInt8 ); +# endif + } + + bool operator!=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8Features; + void * pNext = {}; + Bool32 shaderFloat16 = {}; + Bool32 shaderInt8 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderFloat16Int8Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderFloat16Int8Features; + }; + + using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; + using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; + + // wrapper struct for struct VkPhysicalDeviceShaderFloat8FeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFloat8FeaturesEXT.html + struct PhysicalDeviceShaderFloat8FeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderFloat8FeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFloat8FeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat8FeaturesEXT( Bool32 shaderFloat8_ = {}, + Bool32 shaderFloat8CooperativeMatrix_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderFloat8{ shaderFloat8_ } + , shaderFloat8CooperativeMatrix{ shaderFloat8CooperativeMatrix_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat8FeaturesEXT( PhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderFloat8FeaturesEXT( VkPhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderFloat8FeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderFloat8FeaturesEXT & operator=( PhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderFloat8FeaturesEXT & operator=( VkPhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT & setShaderFloat8( Bool32 shaderFloat8_ ) & VULKAN_HPP_NOEXCEPT + { + shaderFloat8 = shaderFloat8_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT && setShaderFloat8( Bool32 shaderFloat8_ ) && VULKAN_HPP_NOEXCEPT + { + shaderFloat8 = shaderFloat8_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT & setShaderFloat8CooperativeMatrix( Bool32 shaderFloat8CooperativeMatrix_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderFloat8CooperativeMatrix = shaderFloat8CooperativeMatrix_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT && setShaderFloat8CooperativeMatrix( Bool32 shaderFloat8CooperativeMatrix_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderFloat8CooperativeMatrix = shaderFloat8CooperativeMatrix_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderFloat8FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFloat8FeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFloat8FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFloat8FeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderFloat8, shaderFloat8CooperativeMatrix ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderFloat8FeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat8 == rhs.shaderFloat8 ) && + ( shaderFloat8CooperativeMatrix == rhs.shaderFloat8CooperativeMatrix ); +# endif + } + + bool operator!=( PhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderFloat8FeaturesEXT; + void * pNext = {}; + Bool32 shaderFloat8 = {}; + Bool32 shaderFloat8CooperativeMatrix = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderFloat8FeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderFloat8FeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderFloatControls2Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFloatControls2Features.html + struct PhysicalDeviceShaderFloatControls2Features + { + using NativeType = VkPhysicalDeviceShaderFloatControls2Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFloatControls2Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloatControls2Features( Bool32 shaderFloatControls2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderFloatControls2{ shaderFloatControls2_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloatControls2Features( PhysicalDeviceShaderFloatControls2Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderFloatControls2Features( VkPhysicalDeviceShaderFloatControls2Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderFloatControls2Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderFloatControls2Features & operator=( PhysicalDeviceShaderFloatControls2Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderFloatControls2Features & operator=( VkPhysicalDeviceShaderFloatControls2Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloatControls2Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloatControls2Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloatControls2Features & setShaderFloatControls2( Bool32 shaderFloatControls2_ ) & VULKAN_HPP_NOEXCEPT + { + shaderFloatControls2 = shaderFloatControls2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloatControls2Features && setShaderFloatControls2( Bool32 shaderFloatControls2_ ) && VULKAN_HPP_NOEXCEPT + { + shaderFloatControls2 = shaderFloatControls2_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderFloatControls2Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFloatControls2Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFloatControls2Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFloatControls2Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderFloatControls2 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderFloatControls2Features const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderFloatControls2Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloatControls2 == rhs.shaderFloatControls2 ); +# endif + } + + bool operator!=( PhysicalDeviceShaderFloatControls2Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderFloatControls2Features; + void * pNext = {}; + Bool32 shaderFloatControls2 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderFloatControls2Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderFloatControls2Features; + }; + + using PhysicalDeviceShaderFloatControls2FeaturesKHR = PhysicalDeviceShaderFloatControls2Features; + + // wrapper struct for struct VkPhysicalDeviceShaderFmaFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFmaFeaturesKHR.html + struct PhysicalDeviceShaderFmaFeaturesKHR + { + using NativeType = VkPhysicalDeviceShaderFmaFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFmaFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFmaFeaturesKHR( Bool32 shaderFmaFloat16_ = {}, + Bool32 shaderFmaFloat32_ = {}, + Bool32 shaderFmaFloat64_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderFmaFloat16{ shaderFmaFloat16_ } + , shaderFmaFloat32{ shaderFmaFloat32_ } + , shaderFmaFloat64{ shaderFmaFloat64_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFmaFeaturesKHR( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderFmaFeaturesKHR( VkPhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderFmaFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderFmaFeaturesKHR & operator=( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderFmaFeaturesKHR & operator=( VkPhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat16( Bool32 shaderFmaFloat16_ ) & VULKAN_HPP_NOEXCEPT + { + shaderFmaFloat16 = shaderFmaFloat16_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR && setShaderFmaFloat16( Bool32 shaderFmaFloat16_ ) && VULKAN_HPP_NOEXCEPT + { + shaderFmaFloat16 = shaderFmaFloat16_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat32( Bool32 shaderFmaFloat32_ ) & VULKAN_HPP_NOEXCEPT + { + shaderFmaFloat32 = shaderFmaFloat32_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR && setShaderFmaFloat32( Bool32 shaderFmaFloat32_ ) && VULKAN_HPP_NOEXCEPT + { + shaderFmaFloat32 = shaderFmaFloat32_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat64( Bool32 shaderFmaFloat64_ ) & VULKAN_HPP_NOEXCEPT + { + shaderFmaFloat64 = shaderFmaFloat64_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR && setShaderFmaFloat64( Bool32 shaderFmaFloat64_ ) && VULKAN_HPP_NOEXCEPT + { + shaderFmaFloat64 = shaderFmaFloat64_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderFmaFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFmaFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFmaFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderFmaFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderFmaFloat16, shaderFmaFloat32, shaderFmaFloat64 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderFmaFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFmaFloat16 == rhs.shaderFmaFloat16 ) && ( shaderFmaFloat32 == rhs.shaderFmaFloat32 ) && + ( shaderFmaFloat64 == rhs.shaderFmaFloat64 ); +# endif + } + + bool operator!=( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderFmaFeaturesKHR; + void * pNext = {}; + Bool32 shaderFmaFloat16 = {}; + Bool32 shaderFmaFloat32 = {}; + Bool32 shaderFmaFloat64 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderFmaFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderFmaFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html + struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageAtomicInt64FeaturesEXT( Bool32 shaderImageInt64Atomics_ = {}, + Bool32 sparseImageInt64Atomics_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderImageInt64Atomics{ shaderImageInt64Atomics_ } + , sparseImageInt64Atomics{ sparseImageInt64Atomics_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderImageAtomicInt64FeaturesEXT( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderImageAtomicInt64FeaturesEXT( VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderImageAtomicInt64FeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderImageAtomicInt64FeaturesEXT & operator=( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderImageAtomicInt64FeaturesEXT & operator=( VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT & setShaderImageInt64Atomics( Bool32 shaderImageInt64Atomics_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderImageInt64Atomics = shaderImageInt64Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT && setShaderImageInt64Atomics( Bool32 shaderImageInt64Atomics_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderImageInt64Atomics = shaderImageInt64Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT & setSparseImageInt64Atomics( Bool32 sparseImageInt64Atomics_ ) & + VULKAN_HPP_NOEXCEPT + { + sparseImageInt64Atomics = sparseImageInt64Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT && setSparseImageInt64Atomics( Bool32 sparseImageInt64Atomics_ ) && + VULKAN_HPP_NOEXCEPT + { + sparseImageInt64Atomics = sparseImageInt64Atomics_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderImageInt64Atomics, sparseImageInt64Atomics ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderImageInt64Atomics == rhs.shaderImageInt64Atomics ) && + ( sparseImageInt64Atomics == rhs.sparseImageInt64Atomics ); +# endif + } + + bool operator!=( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + void * pNext = {}; + Bool32 shaderImageInt64Atomics = {}; + Bool32 sparseImageInt64Atomics = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderImageFootprintFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html + struct PhysicalDeviceShaderImageFootprintFeaturesNV + { + using NativeType = VkPhysicalDeviceShaderImageFootprintFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( Bool32 imageFootprint_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageFootprint{ imageFootprint_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderImageFootprintFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderImageFootprintFeaturesNV & operator=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderImageFootprintFeaturesNV & operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageFootprintFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageFootprintFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageFootprintFeaturesNV & setImageFootprint( Bool32 imageFootprint_ ) & VULKAN_HPP_NOEXCEPT + { + imageFootprint = imageFootprint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageFootprintFeaturesNV && setImageFootprint( Bool32 imageFootprint_ ) && VULKAN_HPP_NOEXCEPT + { + imageFootprint = imageFootprint_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderImageFootprintFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageFootprint ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderImageFootprintFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFootprint == rhs.imageFootprint ); +# endif + } + + bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; + void * pNext = {}; + Bool32 imageFootprint = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderImageFootprintFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderImageFootprintFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderIntegerDotProductFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderIntegerDotProductFeatures.html + struct PhysicalDeviceShaderIntegerDotProductFeatures + { + using NativeType = VkPhysicalDeviceShaderIntegerDotProductFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderIntegerDotProductFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerDotProductFeatures( Bool32 shaderIntegerDotProduct_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderIntegerDotProduct{ shaderIntegerDotProduct_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderIntegerDotProductFeatures( PhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderIntegerDotProductFeatures( VkPhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderIntegerDotProductFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderIntegerDotProductFeatures & operator=( PhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderIntegerDotProductFeatures & operator=( VkPhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductFeatures & setShaderIntegerDotProduct( Bool32 shaderIntegerDotProduct_ ) & VULKAN_HPP_NOEXCEPT + { + shaderIntegerDotProduct = shaderIntegerDotProduct_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductFeatures && setShaderIntegerDotProduct( Bool32 shaderIntegerDotProduct_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderIntegerDotProduct = shaderIntegerDotProduct_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderIntegerDotProductFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderIntegerDotProductFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderIntegerDotProductFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderIntegerDotProductFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderIntegerDotProduct ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderIntegerDotProductFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderIntegerDotProduct == rhs.shaderIntegerDotProduct ); +# endif + } + + bool operator!=( PhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderIntegerDotProductFeatures; + void * pNext = {}; + Bool32 shaderIntegerDotProduct = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderIntegerDotProductFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderIntegerDotProductFeatures; + }; + + using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures; + + // wrapper struct for struct VkPhysicalDeviceShaderIntegerDotProductProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderIntegerDotProductProperties.html + struct PhysicalDeviceShaderIntegerDotProductProperties + { + using NativeType = VkPhysicalDeviceShaderIntegerDotProductProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderIntegerDotProductProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderIntegerDotProductProperties( Bool32 integerDotProduct8BitUnsignedAccelerated_ = {}, + Bool32 integerDotProduct8BitSignedAccelerated_ = {}, + Bool32 integerDotProduct8BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProduct4x8BitPackedUnsignedAccelerated_ = {}, + Bool32 integerDotProduct4x8BitPackedSignedAccelerated_ = {}, + Bool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated_ = {}, + Bool32 integerDotProduct16BitUnsignedAccelerated_ = {}, + Bool32 integerDotProduct16BitSignedAccelerated_ = {}, + Bool32 integerDotProduct16BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProduct32BitUnsignedAccelerated_ = {}, + Bool32 integerDotProduct32BitSignedAccelerated_ = {}, + Bool32 integerDotProduct32BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProduct64BitUnsignedAccelerated_ = {}, + Bool32 integerDotProduct64BitSignedAccelerated_ = {}, + Bool32 integerDotProduct64BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , integerDotProduct8BitUnsignedAccelerated{ integerDotProduct8BitUnsignedAccelerated_ } + , integerDotProduct8BitSignedAccelerated{ integerDotProduct8BitSignedAccelerated_ } + , integerDotProduct8BitMixedSignednessAccelerated{ integerDotProduct8BitMixedSignednessAccelerated_ } + , integerDotProduct4x8BitPackedUnsignedAccelerated{ integerDotProduct4x8BitPackedUnsignedAccelerated_ } + , integerDotProduct4x8BitPackedSignedAccelerated{ integerDotProduct4x8BitPackedSignedAccelerated_ } + , integerDotProduct4x8BitPackedMixedSignednessAccelerated{ integerDotProduct4x8BitPackedMixedSignednessAccelerated_ } + , integerDotProduct16BitUnsignedAccelerated{ integerDotProduct16BitUnsignedAccelerated_ } + , integerDotProduct16BitSignedAccelerated{ integerDotProduct16BitSignedAccelerated_ } + , integerDotProduct16BitMixedSignednessAccelerated{ integerDotProduct16BitMixedSignednessAccelerated_ } + , integerDotProduct32BitUnsignedAccelerated{ integerDotProduct32BitUnsignedAccelerated_ } + , integerDotProduct32BitSignedAccelerated{ integerDotProduct32BitSignedAccelerated_ } + , integerDotProduct32BitMixedSignednessAccelerated{ integerDotProduct32BitMixedSignednessAccelerated_ } + , integerDotProduct64BitUnsignedAccelerated{ integerDotProduct64BitUnsignedAccelerated_ } + , integerDotProduct64BitSignedAccelerated{ integerDotProduct64BitSignedAccelerated_ } + , integerDotProduct64BitMixedSignednessAccelerated{ integerDotProduct64BitMixedSignednessAccelerated_ } + , integerDotProductAccumulatingSaturating8BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating8BitUnsignedAccelerated_ } + , integerDotProductAccumulatingSaturating8BitSignedAccelerated{ integerDotProductAccumulatingSaturating8BitSignedAccelerated_ } + , integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated_ } + , integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated_ } + , integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated_ } + , integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated_ } + , integerDotProductAccumulatingSaturating16BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating16BitUnsignedAccelerated_ } + , integerDotProductAccumulatingSaturating16BitSignedAccelerated{ integerDotProductAccumulatingSaturating16BitSignedAccelerated_ } + , integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated_ } + , integerDotProductAccumulatingSaturating32BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating32BitUnsignedAccelerated_ } + , integerDotProductAccumulatingSaturating32BitSignedAccelerated{ integerDotProductAccumulatingSaturating32BitSignedAccelerated_ } + , integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated_ } + , integerDotProductAccumulatingSaturating64BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating64BitUnsignedAccelerated_ } + , integerDotProductAccumulatingSaturating64BitSignedAccelerated{ integerDotProductAccumulatingSaturating64BitSignedAccelerated_ } + , integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderIntegerDotProductProperties( PhysicalDeviceShaderIntegerDotProductProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderIntegerDotProductProperties( VkPhysicalDeviceShaderIntegerDotProductProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderIntegerDotProductProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderIntegerDotProductProperties & operator=( PhysicalDeviceShaderIntegerDotProductProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderIntegerDotProductProperties & operator=( VkPhysicalDeviceShaderIntegerDotProductProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderIntegerDotProductProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderIntegerDotProductProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderIntegerDotProductProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderIntegerDotProductProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + integerDotProduct8BitUnsignedAccelerated, + integerDotProduct8BitSignedAccelerated, + integerDotProduct8BitMixedSignednessAccelerated, + integerDotProduct4x8BitPackedUnsignedAccelerated, + integerDotProduct4x8BitPackedSignedAccelerated, + integerDotProduct4x8BitPackedMixedSignednessAccelerated, + integerDotProduct16BitUnsignedAccelerated, + integerDotProduct16BitSignedAccelerated, + integerDotProduct16BitMixedSignednessAccelerated, + integerDotProduct32BitUnsignedAccelerated, + integerDotProduct32BitSignedAccelerated, + integerDotProduct32BitMixedSignednessAccelerated, + integerDotProduct64BitUnsignedAccelerated, + integerDotProduct64BitSignedAccelerated, + integerDotProduct64BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating8BitSignedAccelerated, + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating16BitSignedAccelerated, + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating32BitSignedAccelerated, + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating64BitSignedAccelerated, + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderIntegerDotProductProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderIntegerDotProductProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( integerDotProduct8BitUnsignedAccelerated == rhs.integerDotProduct8BitUnsignedAccelerated ) && + ( integerDotProduct8BitSignedAccelerated == rhs.integerDotProduct8BitSignedAccelerated ) && + ( integerDotProduct8BitMixedSignednessAccelerated == rhs.integerDotProduct8BitMixedSignednessAccelerated ) && + ( integerDotProduct4x8BitPackedUnsignedAccelerated == rhs.integerDotProduct4x8BitPackedUnsignedAccelerated ) && + ( integerDotProduct4x8BitPackedSignedAccelerated == rhs.integerDotProduct4x8BitPackedSignedAccelerated ) && + ( integerDotProduct4x8BitPackedMixedSignednessAccelerated == rhs.integerDotProduct4x8BitPackedMixedSignednessAccelerated ) && + ( integerDotProduct16BitUnsignedAccelerated == rhs.integerDotProduct16BitUnsignedAccelerated ) && + ( integerDotProduct16BitSignedAccelerated == rhs.integerDotProduct16BitSignedAccelerated ) && + ( integerDotProduct16BitMixedSignednessAccelerated == rhs.integerDotProduct16BitMixedSignednessAccelerated ) && + ( integerDotProduct32BitUnsignedAccelerated == rhs.integerDotProduct32BitUnsignedAccelerated ) && + ( integerDotProduct32BitSignedAccelerated == rhs.integerDotProduct32BitSignedAccelerated ) && + ( integerDotProduct32BitMixedSignednessAccelerated == rhs.integerDotProduct32BitMixedSignednessAccelerated ) && + ( integerDotProduct64BitUnsignedAccelerated == rhs.integerDotProduct64BitUnsignedAccelerated ) && + ( integerDotProduct64BitSignedAccelerated == rhs.integerDotProduct64BitSignedAccelerated ) && + ( integerDotProduct64BitMixedSignednessAccelerated == rhs.integerDotProduct64BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating8BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating8BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating8BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated == + rhs.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated == + rhs.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating16BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating16BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating16BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating32BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating32BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating32BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating64BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating64BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating64BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); +# endif + } + + bool operator!=( PhysicalDeviceShaderIntegerDotProductProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderIntegerDotProductProperties; + void * pNext = {}; + Bool32 integerDotProduct8BitUnsignedAccelerated = {}; + Bool32 integerDotProduct8BitSignedAccelerated = {}; + Bool32 integerDotProduct8BitMixedSignednessAccelerated = {}; + Bool32 integerDotProduct4x8BitPackedUnsignedAccelerated = {}; + Bool32 integerDotProduct4x8BitPackedSignedAccelerated = {}; + Bool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated = {}; + Bool32 integerDotProduct16BitUnsignedAccelerated = {}; + Bool32 integerDotProduct16BitSignedAccelerated = {}; + Bool32 integerDotProduct16BitMixedSignednessAccelerated = {}; + Bool32 integerDotProduct32BitUnsignedAccelerated = {}; + Bool32 integerDotProduct32BitSignedAccelerated = {}; + Bool32 integerDotProduct32BitMixedSignednessAccelerated = {}; + Bool32 integerDotProduct64BitUnsignedAccelerated = {}; + Bool32 integerDotProduct64BitSignedAccelerated = {}; + Bool32 integerDotProduct64BitMixedSignednessAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderIntegerDotProductProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderIntegerDotProductProperties; + }; + + using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties; + + // wrapper struct for struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html + struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL + { + using NativeType = VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( Bool32 shaderIntegerFunctions2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderIntegerFunctions2{ shaderIntegerFunctions2_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & + operator=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & setShaderIntegerFunctions2( Bool32 shaderIntegerFunctions2_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderIntegerFunctions2 = shaderIntegerFunctions2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL && setShaderIntegerFunctions2( Bool32 shaderIntegerFunctions2_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderIntegerFunctions2 = shaderIntegerFunctions2_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderIntegerFunctions2 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 ); +# endif + } + + bool operator!=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + void * pNext = {}; + Bool32 shaderIntegerFunctions2 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderLongVectorFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderLongVectorFeaturesEXT.html + struct PhysicalDeviceShaderLongVectorFeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderLongVectorFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderLongVectorFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorFeaturesEXT( Bool32 longVector_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , longVector{ longVector_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorFeaturesEXT( PhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderLongVectorFeaturesEXT( VkPhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderLongVectorFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderLongVectorFeaturesEXT & operator=( PhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderLongVectorFeaturesEXT & operator=( VkPhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT & setLongVector( Bool32 longVector_ ) & VULKAN_HPP_NOEXCEPT + { + longVector = longVector_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT && setLongVector( Bool32 longVector_ ) && VULKAN_HPP_NOEXCEPT + { + longVector = longVector_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderLongVectorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderLongVectorFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderLongVectorFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderLongVectorFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, longVector ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderLongVectorFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( longVector == rhs.longVector ); +# endif + } + + bool operator!=( PhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderLongVectorFeaturesEXT; + void * pNext = {}; + Bool32 longVector = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderLongVectorFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderLongVectorFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderLongVectorPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderLongVectorPropertiesEXT.html + struct PhysicalDeviceShaderLongVectorPropertiesEXT + { + using NativeType = VkPhysicalDeviceShaderLongVectorPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderLongVectorPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorPropertiesEXT( uint32_t maxVectorComponents_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxVectorComponents{ maxVectorComponents_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorPropertiesEXT( PhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderLongVectorPropertiesEXT( VkPhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderLongVectorPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderLongVectorPropertiesEXT & operator=( PhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderLongVectorPropertiesEXT & operator=( VkPhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderLongVectorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderLongVectorPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderLongVectorPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderLongVectorPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxVectorComponents ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderLongVectorPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVectorComponents == rhs.maxVectorComponents ); +# endif + } + + bool operator!=( PhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderLongVectorPropertiesEXT; + void * pNext = {}; + uint32_t maxVectorComponents = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderLongVectorPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderLongVectorPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.html + struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR + { + using NativeType = VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( Bool32 shaderMaximalReconvergence_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderMaximalReconvergence{ shaderMaximalReconvergence_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR & + operator=( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR & operator=( VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR & setShaderMaximalReconvergence( Bool32 shaderMaximalReconvergence_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderMaximalReconvergence = shaderMaximalReconvergence_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR && setShaderMaximalReconvergence( Bool32 shaderMaximalReconvergence_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderMaximalReconvergence = shaderMaximalReconvergence_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderMaximalReconvergence ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderMaximalReconvergence == rhs.shaderMaximalReconvergence ); +# endif + } + + bool operator!=( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; + void * pNext = {}; + Bool32 shaderMaximalReconvergence = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.html + struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderModuleIdentifierFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderModuleIdentifierFeaturesEXT( Bool32 shaderModuleIdentifier_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderModuleIdentifier{ shaderModuleIdentifier_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderModuleIdentifierFeaturesEXT( PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderModuleIdentifierFeaturesEXT( VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderModuleIdentifierFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderModuleIdentifierFeaturesEXT & operator=( PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderModuleIdentifierFeaturesEXT & operator=( VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderModuleIdentifierFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderModuleIdentifierFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderModuleIdentifierFeaturesEXT & setShaderModuleIdentifier( Bool32 shaderModuleIdentifier_ ) & VULKAN_HPP_NOEXCEPT + { + shaderModuleIdentifier = shaderModuleIdentifier_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderModuleIdentifierFeaturesEXT && setShaderModuleIdentifier( Bool32 shaderModuleIdentifier_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderModuleIdentifier = shaderModuleIdentifier_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderModuleIdentifier ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderModuleIdentifier == rhs.shaderModuleIdentifier ); +# endif + } + + bool operator!=( PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderModuleIdentifierFeaturesEXT; + void * pNext = {}; + Bool32 shaderModuleIdentifier = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderModuleIdentifierFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderModuleIdentifierFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.html + struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT + { + using NativeType = VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + PhysicalDeviceShaderModuleIdentifierPropertiesEXT( std::array const & shaderModuleIdentifierAlgorithmUUID_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderModuleIdentifierAlgorithmUUID{ shaderModuleIdentifierAlgorithmUUID_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + PhysicalDeviceShaderModuleIdentifierPropertiesEXT( PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderModuleIdentifierPropertiesEXT( VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderModuleIdentifierPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderModuleIdentifierPropertiesEXT & + operator=( PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderModuleIdentifierPropertiesEXT & operator=( VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderModuleIdentifierAlgorithmUUID ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderModuleIdentifierAlgorithmUUID == rhs.shaderModuleIdentifierAlgorithmUUID ); +# endif + } + + bool operator!=( PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT; + void * pNext = {}; + ArrayWrapper1D shaderModuleIdentifierAlgorithmUUID = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderModuleIdentifierPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderModuleIdentifierPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderObjectFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderObjectFeaturesEXT.html + struct PhysicalDeviceShaderObjectFeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderObjectFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderObjectFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderObjectFeaturesEXT( Bool32 shaderObject_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderObject{ shaderObject_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderObjectFeaturesEXT( PhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderObjectFeaturesEXT( VkPhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderObjectFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderObjectFeaturesEXT & operator=( PhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderObjectFeaturesEXT & operator=( VkPhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectFeaturesEXT & setShaderObject( Bool32 shaderObject_ ) & VULKAN_HPP_NOEXCEPT + { + shaderObject = shaderObject_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectFeaturesEXT && setShaderObject( Bool32 shaderObject_ ) && VULKAN_HPP_NOEXCEPT + { + shaderObject = shaderObject_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderObjectFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderObjectFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderObjectFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderObjectFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderObject ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderObjectFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderObjectFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderObject == rhs.shaderObject ); +# endif + } + + bool operator!=( PhysicalDeviceShaderObjectFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderObjectFeaturesEXT; + void * pNext = {}; + Bool32 shaderObject = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderObjectFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderObjectFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderObjectPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderObjectPropertiesEXT.html + struct PhysicalDeviceShaderObjectPropertiesEXT + { + using NativeType = VkPhysicalDeviceShaderObjectPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderObjectPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectPropertiesEXT( std::array const & shaderBinaryUUID_ = {}, + uint32_t shaderBinaryVersion_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderBinaryUUID{ shaderBinaryUUID_ } + , shaderBinaryVersion{ shaderBinaryVersion_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectPropertiesEXT( PhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderObjectPropertiesEXT( VkPhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderObjectPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderObjectPropertiesEXT & operator=( PhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderObjectPropertiesEXT & operator=( VkPhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderObjectPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderObjectPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderObjectPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderObjectPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderBinaryUUID, shaderBinaryVersion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderObjectPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderObjectPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBinaryUUID == rhs.shaderBinaryUUID ) && + ( shaderBinaryVersion == rhs.shaderBinaryVersion ); +# endif + } + + bool operator!=( PhysicalDeviceShaderObjectPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderObjectPropertiesEXT; + void * pNext = {}; + ArrayWrapper1D shaderBinaryUUID = {}; + uint32_t shaderBinaryVersion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderObjectPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderObjectPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderQuadControlFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderQuadControlFeaturesKHR.html + struct PhysicalDeviceShaderQuadControlFeaturesKHR + { + using NativeType = VkPhysicalDeviceShaderQuadControlFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderQuadControlFeaturesKHR( Bool32 shaderQuadControl_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderQuadControl{ shaderQuadControl_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderQuadControlFeaturesKHR( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderQuadControlFeaturesKHR( VkPhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderQuadControlFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderQuadControlFeaturesKHR & operator=( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderQuadControlFeaturesKHR & operator=( VkPhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderQuadControlFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderQuadControlFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderQuadControlFeaturesKHR & setShaderQuadControl( Bool32 shaderQuadControl_ ) & VULKAN_HPP_NOEXCEPT + { + shaderQuadControl = shaderQuadControl_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderQuadControlFeaturesKHR && setShaderQuadControl( Bool32 shaderQuadControl_ ) && VULKAN_HPP_NOEXCEPT + { + shaderQuadControl = shaderQuadControl_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderQuadControlFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderQuadControlFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderQuadControlFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderQuadControlFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderQuadControl ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderQuadControlFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderQuadControl == rhs.shaderQuadControl ); +# endif + } + + bool operator!=( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR; + void * pNext = {}; + Bool32 shaderQuadControl = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderQuadControlFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderQuadControlFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.html + struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR + { + using NativeType = VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR( Bool32 shaderRelaxedExtendedInstruction_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderRelaxedExtendedInstruction{ shaderRelaxedExtendedInstruction_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR( PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR( VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR( + *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR & + operator=( PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR & + operator=( VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR & + setShaderRelaxedExtendedInstruction( Bool32 shaderRelaxedExtendedInstruction_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderRelaxedExtendedInstruction = shaderRelaxedExtendedInstruction_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR && + setShaderRelaxedExtendedInstruction( Bool32 shaderRelaxedExtendedInstruction_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderRelaxedExtendedInstruction = shaderRelaxedExtendedInstruction_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderRelaxedExtendedInstruction ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderRelaxedExtendedInstruction == rhs.shaderRelaxedExtendedInstruction ); +# endif + } + + bool operator!=( PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; + void * pNext = {}; + Bool32 shaderRelaxedExtendedInstruction = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.html + struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderReplicatedCompositesFeaturesEXT( Bool32 shaderReplicatedComposites_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderReplicatedComposites{ shaderReplicatedComposites_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderReplicatedCompositesFeaturesEXT( PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderReplicatedCompositesFeaturesEXT( VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderReplicatedCompositesFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderReplicatedCompositesFeaturesEXT & + operator=( PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderReplicatedCompositesFeaturesEXT & operator=( VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderReplicatedCompositesFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderReplicatedCompositesFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderReplicatedCompositesFeaturesEXT & setShaderReplicatedComposites( Bool32 shaderReplicatedComposites_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderReplicatedComposites = shaderReplicatedComposites_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderReplicatedCompositesFeaturesEXT && setShaderReplicatedComposites( Bool32 shaderReplicatedComposites_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderReplicatedComposites = shaderReplicatedComposites_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderReplicatedComposites ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderReplicatedComposites == rhs.shaderReplicatedComposites ); +# endif + } + + bool operator!=( PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT; + void * pNext = {}; + Bool32 shaderReplicatedComposites = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderReplicatedCompositesFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderReplicatedCompositesFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html + struct PhysicalDeviceShaderSMBuiltinsFeaturesNV + { + using NativeType = VkPhysicalDeviceShaderSMBuiltinsFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( Bool32 shaderSMBuiltins_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderSMBuiltins{ shaderSMBuiltins_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderSMBuiltinsFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderSMBuiltinsFeaturesNV & operator=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderSMBuiltinsFeaturesNV & operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSMBuiltinsFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSMBuiltinsFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSMBuiltinsFeaturesNV & setShaderSMBuiltins( Bool32 shaderSMBuiltins_ ) & VULKAN_HPP_NOEXCEPT + { + shaderSMBuiltins = shaderSMBuiltins_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSMBuiltinsFeaturesNV && setShaderSMBuiltins( Bool32 shaderSMBuiltins_ ) && VULKAN_HPP_NOEXCEPT + { + shaderSMBuiltins = shaderSMBuiltins_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSMBuiltins ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMBuiltins == rhs.shaderSMBuiltins ); +# endif + } + + bool operator!=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV; + void * pNext = {}; + Bool32 shaderSMBuiltins = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSMBuiltinsFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSMBuiltinsFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html + struct PhysicalDeviceShaderSMBuiltinsPropertiesNV + { + using NativeType = VkPhysicalDeviceShaderSMBuiltinsPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderSMBuiltinsPropertiesNV( uint32_t shaderSMCount_ = {}, uint32_t shaderWarpsPerSM_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderSMCount{ shaderSMCount_ } + , shaderWarpsPerSM{ shaderWarpsPerSM_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsPropertiesNV( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderSMBuiltinsPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderSMBuiltinsPropertiesNV & operator=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderSMBuiltinsPropertiesNV & operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSMCount, shaderWarpsPerSM ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMCount == rhs.shaderSMCount ) && ( shaderWarpsPerSM == rhs.shaderWarpsPerSM ); +# endif + } + + bool operator!=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV; + void * pNext = {}; + uint32_t shaderSMCount = {}; + uint32_t shaderWarpsPerSM = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html + struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures + { + using NativeType = VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeatures( Bool32 shaderSubgroupExtendedTypes_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderSubgroupExtendedTypes{ shaderSubgroupExtendedTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderSubgroupExtendedTypesFeatures( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderSubgroupExtendedTypesFeatures( VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderSubgroupExtendedTypesFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderSubgroupExtendedTypesFeatures & + operator=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderSubgroupExtendedTypesFeatures & operator=( VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupExtendedTypesFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupExtendedTypesFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupExtendedTypesFeatures & setShaderSubgroupExtendedTypes( Bool32 shaderSubgroupExtendedTypes_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupExtendedTypesFeatures && setShaderSubgroupExtendedTypes( Bool32 shaderSubgroupExtendedTypes_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSubgroupExtendedTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes ); +# endif + } + + bool operator!=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures; + void * pNext = {}; + Bool32 shaderSubgroupExtendedTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; + }; + + using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; + + // wrapper struct for struct VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT.html + struct PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT( Bool32 shaderSubgroupPartitioned_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderSubgroupPartitioned{ shaderSubgroupPartitioned_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT( PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT( VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT & + operator=( PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT & operator=( VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT & setShaderSubgroupPartitioned( Bool32 shaderSubgroupPartitioned_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSubgroupPartitioned = shaderSubgroupPartitioned_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT && setShaderSubgroupPartitioned( Bool32 shaderSubgroupPartitioned_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSubgroupPartitioned = shaderSubgroupPartitioned_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSubgroupPartitioned ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupPartitioned == rhs.shaderSubgroupPartitioned ); +# endif + } + + bool operator!=( PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; + void * pNext = {}; + Bool32 shaderSubgroupPartitioned = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderSubgroupRotateFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupRotateFeatures.html + struct PhysicalDeviceShaderSubgroupRotateFeatures + { + using NativeType = VkPhysicalDeviceShaderSubgroupRotateFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSubgroupRotateFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupRotateFeatures( Bool32 shaderSubgroupRotate_ = {}, + Bool32 shaderSubgroupRotateClustered_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderSubgroupRotate{ shaderSubgroupRotate_ } + , shaderSubgroupRotateClustered{ shaderSubgroupRotateClustered_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupRotateFeatures( PhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderSubgroupRotateFeatures( VkPhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderSubgroupRotateFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderSubgroupRotateFeatures & operator=( PhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderSubgroupRotateFeatures & operator=( VkPhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures & setShaderSubgroupRotate( Bool32 shaderSubgroupRotate_ ) & VULKAN_HPP_NOEXCEPT + { + shaderSubgroupRotate = shaderSubgroupRotate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures && setShaderSubgroupRotate( Bool32 shaderSubgroupRotate_ ) && VULKAN_HPP_NOEXCEPT + { + shaderSubgroupRotate = shaderSubgroupRotate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures & setShaderSubgroupRotateClustered( Bool32 shaderSubgroupRotateClustered_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSubgroupRotateClustered = shaderSubgroupRotateClustered_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures && setShaderSubgroupRotateClustered( Bool32 shaderSubgroupRotateClustered_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSubgroupRotateClustered = shaderSubgroupRotateClustered_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderSubgroupRotateFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupRotateFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupRotateFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupRotateFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSubgroupRotate, shaderSubgroupRotateClustered ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderSubgroupRotateFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupRotate == rhs.shaderSubgroupRotate ) && + ( shaderSubgroupRotateClustered == rhs.shaderSubgroupRotateClustered ); +# endif + } + + bool operator!=( PhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupRotateFeatures; + void * pNext = {}; + Bool32 shaderSubgroupRotate = {}; + Bool32 shaderSubgroupRotateClustered = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSubgroupRotateFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSubgroupRotateFeatures; + }; + + using PhysicalDeviceShaderSubgroupRotateFeaturesKHR = PhysicalDeviceShaderSubgroupRotateFeatures; + + // wrapper struct for struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.html + struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR + { + using NativeType = VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( Bool32 shaderSubgroupUniformControlFlow_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderSubgroupUniformControlFlow{ shaderSubgroupUniformControlFlow_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( + *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR & + operator=( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR & + operator=( VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR & + setShaderSubgroupUniformControlFlow( Bool32 shaderSubgroupUniformControlFlow_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSubgroupUniformControlFlow = shaderSubgroupUniformControlFlow_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR && + setShaderSubgroupUniformControlFlow( Bool32 shaderSubgroupUniformControlFlow_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSubgroupUniformControlFlow = shaderSubgroupUniformControlFlow_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderSubgroupUniformControlFlow ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupUniformControlFlow == rhs.shaderSubgroupUniformControlFlow ); +# endif + } + + bool operator!=( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + void * pNext = {}; + Bool32 shaderSubgroupUniformControlFlow = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderTerminateInvocationFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderTerminateInvocationFeatures.html + struct PhysicalDeviceShaderTerminateInvocationFeatures + { + using NativeType = VkPhysicalDeviceShaderTerminateInvocationFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderTerminateInvocationFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTerminateInvocationFeatures( Bool32 shaderTerminateInvocation_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderTerminateInvocation{ shaderTerminateInvocation_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderTerminateInvocationFeatures( PhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderTerminateInvocationFeatures( VkPhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderTerminateInvocationFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderTerminateInvocationFeatures & operator=( PhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderTerminateInvocationFeatures & operator=( VkPhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTerminateInvocationFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTerminateInvocationFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTerminateInvocationFeatures & setShaderTerminateInvocation( Bool32 shaderTerminateInvocation_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderTerminateInvocation = shaderTerminateInvocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTerminateInvocationFeatures && setShaderTerminateInvocation( Bool32 shaderTerminateInvocation_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderTerminateInvocation = shaderTerminateInvocation_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderTerminateInvocationFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderTerminateInvocationFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderTerminateInvocationFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderTerminateInvocationFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderTerminateInvocation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderTerminateInvocationFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderTerminateInvocation == rhs.shaderTerminateInvocation ); +# endif + } + + bool operator!=( PhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderTerminateInvocationFeatures; + void * pNext = {}; + Bool32 shaderTerminateInvocation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderTerminateInvocationFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderTerminateInvocationFeatures; + }; + + using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures; + + // wrapper struct for struct VkPhysicalDeviceShaderTileImageFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderTileImageFeaturesEXT.html + struct PhysicalDeviceShaderTileImageFeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderTileImageFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImageFeaturesEXT( Bool32 shaderTileImageColorReadAccess_ = {}, + Bool32 shaderTileImageDepthReadAccess_ = {}, + Bool32 shaderTileImageStencilReadAccess_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderTileImageColorReadAccess{ shaderTileImageColorReadAccess_ } + , shaderTileImageDepthReadAccess{ shaderTileImageDepthReadAccess_ } + , shaderTileImageStencilReadAccess{ shaderTileImageStencilReadAccess_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImageFeaturesEXT( PhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderTileImageFeaturesEXT( VkPhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderTileImageFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderTileImageFeaturesEXT & operator=( PhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderTileImageFeaturesEXT & operator=( VkPhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & setShaderTileImageColorReadAccess( Bool32 shaderTileImageColorReadAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderTileImageColorReadAccess = shaderTileImageColorReadAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT && setShaderTileImageColorReadAccess( Bool32 shaderTileImageColorReadAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderTileImageColorReadAccess = shaderTileImageColorReadAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & setShaderTileImageDepthReadAccess( Bool32 shaderTileImageDepthReadAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderTileImageDepthReadAccess = shaderTileImageDepthReadAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT && setShaderTileImageDepthReadAccess( Bool32 shaderTileImageDepthReadAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderTileImageDepthReadAccess = shaderTileImageDepthReadAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & setShaderTileImageStencilReadAccess( Bool32 shaderTileImageStencilReadAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderTileImageStencilReadAccess = shaderTileImageStencilReadAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT && setShaderTileImageStencilReadAccess( Bool32 shaderTileImageStencilReadAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderTileImageStencilReadAccess = shaderTileImageStencilReadAccess_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderTileImageFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderTileImageFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderTileImageFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderTileImageFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderTileImageColorReadAccess, shaderTileImageDepthReadAccess, shaderTileImageStencilReadAccess ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderTileImageFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderTileImageColorReadAccess == rhs.shaderTileImageColorReadAccess ) && + ( shaderTileImageDepthReadAccess == rhs.shaderTileImageDepthReadAccess ) && + ( shaderTileImageStencilReadAccess == rhs.shaderTileImageStencilReadAccess ); +# endif + } + + bool operator!=( PhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT; + void * pNext = {}; + Bool32 shaderTileImageColorReadAccess = {}; + Bool32 shaderTileImageDepthReadAccess = {}; + Bool32 shaderTileImageStencilReadAccess = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderTileImageFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderTileImageFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderTileImagePropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderTileImagePropertiesEXT.html + struct PhysicalDeviceShaderTileImagePropertiesEXT + { + using NativeType = VkPhysicalDeviceShaderTileImagePropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImagePropertiesEXT( Bool32 shaderTileImageCoherentReadAccelerated_ = {}, + Bool32 shaderTileImageReadSampleFromPixelRateInvocation_ = {}, + Bool32 shaderTileImageReadFromHelperInvocation_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderTileImageCoherentReadAccelerated{ shaderTileImageCoherentReadAccelerated_ } + , shaderTileImageReadSampleFromPixelRateInvocation{ shaderTileImageReadSampleFromPixelRateInvocation_ } + , shaderTileImageReadFromHelperInvocation{ shaderTileImageReadFromHelperInvocation_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImagePropertiesEXT( PhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderTileImagePropertiesEXT( VkPhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderTileImagePropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderTileImagePropertiesEXT & operator=( PhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderTileImagePropertiesEXT & operator=( VkPhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderTileImagePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderTileImagePropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderTileImagePropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderTileImagePropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, shaderTileImageCoherentReadAccelerated, shaderTileImageReadSampleFromPixelRateInvocation, shaderTileImageReadFromHelperInvocation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderTileImagePropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderTileImageCoherentReadAccelerated == rhs.shaderTileImageCoherentReadAccelerated ) && + ( shaderTileImageReadSampleFromPixelRateInvocation == rhs.shaderTileImageReadSampleFromPixelRateInvocation ) && + ( shaderTileImageReadFromHelperInvocation == rhs.shaderTileImageReadFromHelperInvocation ); +# endif + } + + bool operator!=( PhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT; + void * pNext = {}; + Bool32 shaderTileImageCoherentReadAccelerated = {}; + Bool32 shaderTileImageReadSampleFromPixelRateInvocation = {}; + Bool32 shaderTileImageReadFromHelperInvocation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderTileImagePropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderTileImagePropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.html + struct PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT( Bool32 shaderUniformBufferUnsizedArray_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderUniformBufferUnsizedArray{ shaderUniformBufferUnsizedArray_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT( PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT( VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT & + operator=( PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT & + operator=( VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT & + setShaderUniformBufferUnsizedArray( Bool32 shaderUniformBufferUnsizedArray_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderUniformBufferUnsizedArray = shaderUniformBufferUnsizedArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT && + setShaderUniformBufferUnsizedArray( Bool32 shaderUniformBufferUnsizedArray_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderUniformBufferUnsizedArray = shaderUniformBufferUnsizedArray_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderUniformBufferUnsizedArray ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderUniformBufferUnsizedArray == rhs.shaderUniformBufferUnsizedArray ); +# endif + } + + bool operator!=( PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; + void * pNext = {}; + Bool32 shaderUniformBufferUnsizedArray = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderUntypedPointersFeaturesKHR.html + struct PhysicalDeviceShaderUntypedPointersFeaturesKHR + { + using NativeType = VkPhysicalDeviceShaderUntypedPointersFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderUntypedPointersFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderUntypedPointersFeaturesKHR( Bool32 shaderUntypedPointers_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderUntypedPointers{ shaderUntypedPointers_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceShaderUntypedPointersFeaturesKHR( PhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderUntypedPointersFeaturesKHR( VkPhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderUntypedPointersFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderUntypedPointersFeaturesKHR & operator=( PhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShaderUntypedPointersFeaturesKHR & operator=( VkPhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUntypedPointersFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUntypedPointersFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUntypedPointersFeaturesKHR & setShaderUntypedPointers( Bool32 shaderUntypedPointers_ ) & VULKAN_HPP_NOEXCEPT + { + shaderUntypedPointers = shaderUntypedPointers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUntypedPointersFeaturesKHR && setShaderUntypedPointers( Bool32 shaderUntypedPointers_ ) && VULKAN_HPP_NOEXCEPT + { + shaderUntypedPointers = shaderUntypedPointers_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShaderUntypedPointersFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderUntypedPointersFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderUntypedPointersFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderUntypedPointers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderUntypedPointersFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderUntypedPointers == rhs.shaderUntypedPointers ); +# endif + } + + bool operator!=( PhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShaderUntypedPointersFeaturesKHR; + void * pNext = {}; + Bool32 shaderUntypedPointers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShaderUntypedPointersFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderUntypedPointersFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceShadingRateImageFeaturesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html + struct PhysicalDeviceShadingRateImageFeaturesNV + { + using NativeType = VkPhysicalDeviceShadingRateImageFeaturesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( Bool32 shadingRateImage_ = {}, + Bool32 shadingRateCoarseSampleOrder_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shadingRateImage{ shadingRateImage_ } + , shadingRateCoarseSampleOrder{ shadingRateCoarseSampleOrder_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShadingRateImageFeaturesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShadingRateImageFeaturesNV & operator=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShadingRateImageFeaturesNV & operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateImage( Bool32 shadingRateImage_ ) & VULKAN_HPP_NOEXCEPT + { + shadingRateImage = shadingRateImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV && setShadingRateImage( Bool32 shadingRateImage_ ) && VULKAN_HPP_NOEXCEPT + { + shadingRateImage = shadingRateImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateCoarseSampleOrder( Bool32 shadingRateCoarseSampleOrder_ ) & + VULKAN_HPP_NOEXCEPT + { + shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV && setShadingRateCoarseSampleOrder( Bool32 shadingRateCoarseSampleOrder_ ) && + VULKAN_HPP_NOEXCEPT + { + shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceShadingRateImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShadingRateImageFeaturesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShadingRateImageFeaturesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShadingRateImageFeaturesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateImage, shadingRateCoarseSampleOrder ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShadingRateImageFeaturesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImage == rhs.shadingRateImage ) && + ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder ); +# endif + } + + bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; + void * pNext = {}; + Bool32 shadingRateImage = {}; + Bool32 shadingRateCoarseSampleOrder = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShadingRateImageFeaturesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShadingRateImageFeaturesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceShadingRateImagePropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html + struct PhysicalDeviceShadingRateImagePropertiesNV + { + using NativeType = VkPhysicalDeviceShadingRateImagePropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImagePropertiesNV( Extent2D shadingRateTexelSize_ = {}, + uint32_t shadingRatePaletteSize_ = {}, + uint32_t shadingRateMaxCoarseSamples_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shadingRateTexelSize{ shadingRateTexelSize_ } + , shadingRatePaletteSize{ shadingRatePaletteSize_ } + , shadingRateMaxCoarseSamples{ shadingRateMaxCoarseSamples_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImagePropertiesNV( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShadingRateImagePropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShadingRateImagePropertiesNV & operator=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceShadingRateImagePropertiesNV & operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShadingRateImagePropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShadingRateImagePropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShadingRateImagePropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShadingRateImagePropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateTexelSize, shadingRatePaletteSize, shadingRateMaxCoarseSamples ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShadingRateImagePropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateTexelSize == rhs.shadingRateTexelSize ) && + ( shadingRatePaletteSize == rhs.shadingRatePaletteSize ) && ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples ); +# endif + } + + bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; + void * pNext = {}; + Extent2D shadingRateTexelSize = {}; + uint32_t shadingRatePaletteSize = {}; + uint32_t shadingRateMaxCoarseSamples = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceShadingRateImagePropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceShadingRateImagePropertiesNV; + }; + + // wrapper struct for struct VkPhysicalDeviceSparseImageFormatInfo2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSparseImageFormatInfo2.html + struct PhysicalDeviceSparseImageFormatInfo2 + { + using NativeType = VkPhysicalDeviceSparseImageFormatInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( Format format_ = Format::eUndefined, + ImageType type_ = ImageType::e1D, + SampleCountFlagBits samples_ = SampleCountFlagBits::e1, + ImageUsageFlags usage_ = {}, + ImageTiling tiling_ = ImageTiling::eOptimal, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , format{ format_ } + , type{ type_ } + , samples{ samples_ } + , usage{ usage_ } + , tiling{ tiling_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSparseImageFormatInfo2( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSparseImageFormatInfo2 & operator=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSparseImageFormatInfo2 & operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setType( ImageType type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setType( ImageType type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setSamples( SampleCountFlagBits samples_ ) & VULKAN_HPP_NOEXCEPT + { + samples = samples_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setSamples( SampleCountFlagBits samples_ ) && VULKAN_HPP_NOEXCEPT + { + samples = samples_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setUsage( ImageUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setUsage( ImageUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT + { + usage = usage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setTiling( ImageTiling tiling_ ) & VULKAN_HPP_NOEXCEPT + { + tiling = tiling_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setTiling( ImageTiling tiling_ ) && VULKAN_HPP_NOEXCEPT + { + tiling = tiling_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceSparseImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSparseImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSparseImageFormatInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSparseImageFormatInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format, type, samples, usage, tiling ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSparseImageFormatInfo2 const & ) const = default; +#else + bool operator==( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && ( samples == rhs.samples ) && + ( usage == rhs.usage ) && ( tiling == rhs.tiling ); +# endif + } + + bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; + const void * pNext = {}; + Format format = Format::eUndefined; + ImageType type = ImageType::e1D; + SampleCountFlagBits samples = SampleCountFlagBits::e1; + ImageUsageFlags usage = {}; + ImageTiling tiling = ImageTiling::eOptimal; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSparseImageFormatInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSparseImageFormatInfo2; + }; + + using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; + + // wrapper struct for struct VkPhysicalDeviceSubgroupProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubgroupProperties.html + struct PhysicalDeviceSubgroupProperties + { + using NativeType = VkPhysicalDeviceSubgroupProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupProperties( uint32_t subgroupSize_ = {}, + ShaderStageFlags supportedStages_ = {}, + SubgroupFeatureFlags supportedOperations_ = {}, + Bool32 quadOperationsInAllStages_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , subgroupSize{ subgroupSize_ } + , supportedStages{ supportedStages_ } + , supportedOperations{ supportedOperations_ } + , quadOperationsInAllStages{ quadOperationsInAllStages_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupProperties( PhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSubgroupProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSubgroupProperties & operator=( PhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSubgroupProperties & operator=( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceSubgroupProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubgroupProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubgroupProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubgroupProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subgroupSize, supportedStages, supportedOperations, quadOperationsInAllStages ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSubgroupProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSize == rhs.subgroupSize ) && ( supportedStages == rhs.supportedStages ) && + ( supportedOperations == rhs.supportedOperations ) && ( quadOperationsInAllStages == rhs.quadOperationsInAllStages ); +# endif + } + + bool operator!=( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties; + void * pNext = {}; + uint32_t subgroupSize = {}; + ShaderStageFlags supportedStages = {}; + SubgroupFeatureFlags supportedOperations = {}; + Bool32 quadOperationsInAllStages = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSubgroupProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSubgroupProperties; + }; + + // wrapper struct for struct VkPhysicalDeviceSubgroupSizeControlFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubgroupSizeControlFeatures.html + struct PhysicalDeviceSubgroupSizeControlFeatures + { + using NativeType = VkPhysicalDeviceSubgroupSizeControlFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupSizeControlFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeatures( Bool32 subgroupSizeControl_ = {}, + Bool32 computeFullSubgroups_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , subgroupSizeControl{ subgroupSizeControl_ } + , computeFullSubgroups{ computeFullSubgroups_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeatures( PhysicalDeviceSubgroupSizeControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSubgroupSizeControlFeatures( VkPhysicalDeviceSubgroupSizeControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSubgroupSizeControlFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSubgroupSizeControlFeatures & operator=( PhysicalDeviceSubgroupSizeControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSubgroupSizeControlFeatures & operator=( VkPhysicalDeviceSubgroupSizeControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures & setSubgroupSizeControl( Bool32 subgroupSizeControl_ ) & VULKAN_HPP_NOEXCEPT + { + subgroupSizeControl = subgroupSizeControl_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures && setSubgroupSizeControl( Bool32 subgroupSizeControl_ ) && VULKAN_HPP_NOEXCEPT + { + subgroupSizeControl = subgroupSizeControl_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures & setComputeFullSubgroups( Bool32 computeFullSubgroups_ ) & VULKAN_HPP_NOEXCEPT + { + computeFullSubgroups = computeFullSubgroups_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures && setComputeFullSubgroups( Bool32 computeFullSubgroups_ ) && VULKAN_HPP_NOEXCEPT + { + computeFullSubgroups = computeFullSubgroups_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceSubgroupSizeControlFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubgroupSizeControlFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubgroupSizeControlFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubgroupSizeControlFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subgroupSizeControl, computeFullSubgroups ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSubgroupSizeControlFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceSubgroupSizeControlFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSizeControl == rhs.subgroupSizeControl ) && + ( computeFullSubgroups == rhs.computeFullSubgroups ); +# endif + } + + bool operator!=( PhysicalDeviceSubgroupSizeControlFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeatures; + void * pNext = {}; + Bool32 subgroupSizeControl = {}; + Bool32 computeFullSubgroups = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSubgroupSizeControlFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSubgroupSizeControlFeatures; + }; + + using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures; + + // wrapper struct for struct VkPhysicalDeviceSubgroupSizeControlProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubgroupSizeControlProperties.html + struct PhysicalDeviceSubgroupSizeControlProperties + { + using NativeType = VkPhysicalDeviceSubgroupSizeControlProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupSizeControlProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlProperties( uint32_t minSubgroupSize_ = {}, + uint32_t maxSubgroupSize_ = {}, + uint32_t maxComputeWorkgroupSubgroups_ = {}, + ShaderStageFlags requiredSubgroupSizeStages_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minSubgroupSize{ minSubgroupSize_ } + , maxSubgroupSize{ maxSubgroupSize_ } + , maxComputeWorkgroupSubgroups{ maxComputeWorkgroupSubgroups_ } + , requiredSubgroupSizeStages{ requiredSubgroupSizeStages_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlProperties( PhysicalDeviceSubgroupSizeControlProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSubgroupSizeControlProperties( VkPhysicalDeviceSubgroupSizeControlProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSubgroupSizeControlProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSubgroupSizeControlProperties & operator=( PhysicalDeviceSubgroupSizeControlProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSubgroupSizeControlProperties & operator=( VkPhysicalDeviceSubgroupSizeControlProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceSubgroupSizeControlProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubgroupSizeControlProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubgroupSizeControlProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubgroupSizeControlProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minSubgroupSize, maxSubgroupSize, maxComputeWorkgroupSubgroups, requiredSubgroupSizeStages ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSubgroupSizeControlProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceSubgroupSizeControlProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) && ( maxSubgroupSize == rhs.maxSubgroupSize ) && + ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups ) && ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages ); +# endif + } + + bool operator!=( PhysicalDeviceSubgroupSizeControlProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlProperties; + void * pNext = {}; + uint32_t minSubgroupSize = {}; + uint32_t maxSubgroupSize = {}; + uint32_t maxComputeWorkgroupSubgroups = {}; + ShaderStageFlags requiredSubgroupSizeStages = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSubgroupSizeControlProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSubgroupSizeControlProperties; + }; + + using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties; + + // wrapper struct for struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.html + struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT + { + using NativeType = VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubpassMergeFeedbackFeaturesEXT( Bool32 subpassMergeFeedback_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , subpassMergeFeedback{ subpassMergeFeedback_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceSubpassMergeFeedbackFeaturesEXT( PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSubpassMergeFeedbackFeaturesEXT( VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSubpassMergeFeedbackFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSubpassMergeFeedbackFeaturesEXT & operator=( PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSubpassMergeFeedbackFeaturesEXT & operator=( VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassMergeFeedbackFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassMergeFeedbackFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassMergeFeedbackFeaturesEXT & setSubpassMergeFeedback( Bool32 subpassMergeFeedback_ ) & VULKAN_HPP_NOEXCEPT + { + subpassMergeFeedback = subpassMergeFeedback_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassMergeFeedbackFeaturesEXT && setSubpassMergeFeedback( Bool32 subpassMergeFeedback_ ) && VULKAN_HPP_NOEXCEPT + { + subpassMergeFeedback = subpassMergeFeedback_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subpassMergeFeedback ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassMergeFeedback == rhs.subpassMergeFeedback ); +# endif + } + + bool operator!=( PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + void * pNext = {}; + Bool32 subpassMergeFeedback = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.html + struct PhysicalDeviceSubpassShadingFeaturesHUAWEI + { + using NativeType = VkPhysicalDeviceSubpassShadingFeaturesHUAWEI; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubpassShadingFeaturesHUAWEI; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubpassShadingFeaturesHUAWEI( Bool32 subpassShading_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , subpassShading{ subpassShading_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubpassShadingFeaturesHUAWEI( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSubpassShadingFeaturesHUAWEI( VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSubpassShadingFeaturesHUAWEI( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSubpassShadingFeaturesHUAWEI & operator=( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSubpassShadingFeaturesHUAWEI & operator=( VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassShadingFeaturesHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassShadingFeaturesHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassShadingFeaturesHUAWEI & setSubpassShading( Bool32 subpassShading_ ) & VULKAN_HPP_NOEXCEPT + { + subpassShading = subpassShading_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassShadingFeaturesHUAWEI && setSubpassShading( Bool32 subpassShading_ ) && VULKAN_HPP_NOEXCEPT + { + subpassShading = subpassShading_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subpassShading ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & ) const = default; +#else + bool operator==( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassShading == rhs.subpassShading ); +# endif + } + + bool operator!=( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSubpassShadingFeaturesHUAWEI; + void * pNext = {}; + Bool32 subpassShading = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSubpassShadingFeaturesHUAWEI; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSubpassShadingFeaturesHUAWEI; + }; + + // wrapper struct for struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.html + struct PhysicalDeviceSubpassShadingPropertiesHUAWEI + { + using NativeType = VkPhysicalDeviceSubpassShadingPropertiesHUAWEI; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubpassShadingPropertiesHUAWEI; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubpassShadingPropertiesHUAWEI( uint32_t maxSubpassShadingWorkgroupSizeAspectRatio_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxSubpassShadingWorkgroupSizeAspectRatio{ maxSubpassShadingWorkgroupSizeAspectRatio_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSubpassShadingPropertiesHUAWEI( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSubpassShadingPropertiesHUAWEI( VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSubpassShadingPropertiesHUAWEI( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSubpassShadingPropertiesHUAWEI & operator=( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSubpassShadingPropertiesHUAWEI & operator=( VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxSubpassShadingWorkgroupSizeAspectRatio ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & ) const = default; +#else + bool operator==( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSubpassShadingWorkgroupSizeAspectRatio == rhs.maxSubpassShadingWorkgroupSizeAspectRatio ); +# endif + } + + bool operator!=( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSubpassShadingPropertiesHUAWEI; + void * pNext = {}; + uint32_t maxSubpassShadingWorkgroupSizeAspectRatio = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSubpassShadingPropertiesHUAWEI; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSubpassShadingPropertiesHUAWEI; + }; + + // wrapper struct for struct VkPhysicalDeviceSurfaceInfo2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSurfaceInfo2KHR.html + struct PhysicalDeviceSurfaceInfo2KHR + { + using NativeType = VkPhysicalDeviceSurfaceInfo2KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , surface{ surface_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( PhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSurfaceInfo2KHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSurfaceInfo2KHR & operator=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSurfaceInfo2KHR & operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSurfaceInfo2KHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSurfaceInfo2KHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSurfaceInfo2KHR & setSurface( SurfaceKHR surface_ ) & VULKAN_HPP_NOEXCEPT + { + surface = surface_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSurfaceInfo2KHR && setSurface( SurfaceKHR surface_ ) && VULKAN_HPP_NOEXCEPT + { + surface = surface_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceSurfaceInfo2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSurfaceInfo2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSurfaceInfo2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSurfaceInfo2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surface ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSurfaceInfo2KHR const & ) const = default; +#else + bool operator==( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surface == rhs.surface ); +# endif + } + + bool operator!=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; + const void * pNext = {}; + SurfaceKHR surface = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSurfaceInfo2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSurfaceInfo2KHR; + }; + + // wrapper struct for struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR.html + struct PhysicalDeviceSwapchainMaintenance1FeaturesKHR + { + using NativeType = VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSwapchainMaintenance1FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSwapchainMaintenance1FeaturesKHR( Bool32 swapchainMaintenance1_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchainMaintenance1{ swapchainMaintenance1_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceSwapchainMaintenance1FeaturesKHR( PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSwapchainMaintenance1FeaturesKHR( VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSwapchainMaintenance1FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSwapchainMaintenance1FeaturesKHR & operator=( PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSwapchainMaintenance1FeaturesKHR & operator=( VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSwapchainMaintenance1FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSwapchainMaintenance1FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSwapchainMaintenance1FeaturesKHR & setSwapchainMaintenance1( Bool32 swapchainMaintenance1_ ) & VULKAN_HPP_NOEXCEPT + { + swapchainMaintenance1 = swapchainMaintenance1_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSwapchainMaintenance1FeaturesKHR && setSwapchainMaintenance1( Bool32 swapchainMaintenance1_ ) && VULKAN_HPP_NOEXCEPT + { + swapchainMaintenance1 = swapchainMaintenance1_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainMaintenance1 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainMaintenance1 == rhs.swapchainMaintenance1 ); +# endif + } + + bool operator!=( PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSwapchainMaintenance1FeaturesKHR; + void * pNext = {}; + Bool32 swapchainMaintenance1 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSwapchainMaintenance1FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSwapchainMaintenance1FeaturesKHR; + }; + + using PhysicalDeviceSwapchainMaintenance1FeaturesEXT = PhysicalDeviceSwapchainMaintenance1FeaturesKHR; + + // wrapper struct for struct VkPhysicalDeviceSynchronization2Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSynchronization2Features.html + struct PhysicalDeviceSynchronization2Features + { + using NativeType = VkPhysicalDeviceSynchronization2Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSynchronization2Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceSynchronization2Features( Bool32 synchronization2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , synchronization2{ synchronization2_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceSynchronization2Features( PhysicalDeviceSynchronization2Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceSynchronization2Features( VkPhysicalDeviceSynchronization2Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceSynchronization2Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceSynchronization2Features & operator=( PhysicalDeviceSynchronization2Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceSynchronization2Features & operator=( VkPhysicalDeviceSynchronization2Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSynchronization2Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSynchronization2Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSynchronization2Features & setSynchronization2( Bool32 synchronization2_ ) & VULKAN_HPP_NOEXCEPT + { + synchronization2 = synchronization2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSynchronization2Features && setSynchronization2( Bool32 synchronization2_ ) && VULKAN_HPP_NOEXCEPT + { + synchronization2 = synchronization2_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceSynchronization2Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSynchronization2Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSynchronization2Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceSynchronization2Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, synchronization2 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceSynchronization2Features const & ) const = default; +#else + bool operator==( PhysicalDeviceSynchronization2Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( synchronization2 == rhs.synchronization2 ); +# endif + } + + bool operator!=( PhysicalDeviceSynchronization2Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceSynchronization2Features; + void * pNext = {}; + Bool32 synchronization2 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceSynchronization2Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceSynchronization2Features; + }; + + using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features; + + // wrapper struct for struct VkPhysicalDeviceTensorFeaturesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTensorFeaturesARM.html + struct PhysicalDeviceTensorFeaturesARM + { + using NativeType = VkPhysicalDeviceTensorFeaturesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTensorFeaturesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTensorFeaturesARM( Bool32 tensorNonPacked_ = {}, + Bool32 shaderTensorAccess_ = {}, + Bool32 shaderStorageTensorArrayDynamicIndexing_ = {}, + Bool32 shaderStorageTensorArrayNonUniformIndexing_ = {}, + Bool32 descriptorBindingStorageTensorUpdateAfterBind_ = {}, + Bool32 tensors_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensorNonPacked{ tensorNonPacked_ } + , shaderTensorAccess{ shaderTensorAccess_ } + , shaderStorageTensorArrayDynamicIndexing{ shaderStorageTensorArrayDynamicIndexing_ } + , shaderStorageTensorArrayNonUniformIndexing{ shaderStorageTensorArrayNonUniformIndexing_ } + , descriptorBindingStorageTensorUpdateAfterBind{ descriptorBindingStorageTensorUpdateAfterBind_ } + , tensors{ tensors_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTensorFeaturesARM( PhysicalDeviceTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTensorFeaturesARM( VkPhysicalDeviceTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTensorFeaturesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTensorFeaturesARM & operator=( PhysicalDeviceTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTensorFeaturesARM & operator=( VkPhysicalDeviceTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & setTensorNonPacked( Bool32 tensorNonPacked_ ) & VULKAN_HPP_NOEXCEPT + { + tensorNonPacked = tensorNonPacked_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && setTensorNonPacked( Bool32 tensorNonPacked_ ) && VULKAN_HPP_NOEXCEPT + { + tensorNonPacked = tensorNonPacked_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & setShaderTensorAccess( Bool32 shaderTensorAccess_ ) & VULKAN_HPP_NOEXCEPT + { + shaderTensorAccess = shaderTensorAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && setShaderTensorAccess( Bool32 shaderTensorAccess_ ) && VULKAN_HPP_NOEXCEPT + { + shaderTensorAccess = shaderTensorAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & setShaderStorageTensorArrayDynamicIndexing( Bool32 shaderStorageTensorArrayDynamicIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageTensorArrayDynamicIndexing = shaderStorageTensorArrayDynamicIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && setShaderStorageTensorArrayDynamicIndexing( Bool32 shaderStorageTensorArrayDynamicIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageTensorArrayDynamicIndexing = shaderStorageTensorArrayDynamicIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & + setShaderStorageTensorArrayNonUniformIndexing( Bool32 shaderStorageTensorArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageTensorArrayNonUniformIndexing = shaderStorageTensorArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && + setShaderStorageTensorArrayNonUniformIndexing( Bool32 shaderStorageTensorArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageTensorArrayNonUniformIndexing = shaderStorageTensorArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & + setDescriptorBindingStorageTensorUpdateAfterBind( Bool32 descriptorBindingStorageTensorUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageTensorUpdateAfterBind = descriptorBindingStorageTensorUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && + setDescriptorBindingStorageTensorUpdateAfterBind( Bool32 descriptorBindingStorageTensorUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageTensorUpdateAfterBind = descriptorBindingStorageTensorUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & setTensors( Bool32 tensors_ ) & VULKAN_HPP_NOEXCEPT + { + tensors = tensors_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && setTensors( Bool32 tensors_ ) && VULKAN_HPP_NOEXCEPT + { + tensors = tensors_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTensorFeaturesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTensorFeaturesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTensorFeaturesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTensorFeaturesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + tensorNonPacked, + shaderTensorAccess, + shaderStorageTensorArrayDynamicIndexing, + shaderStorageTensorArrayNonUniformIndexing, + descriptorBindingStorageTensorUpdateAfterBind, + tensors ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTensorFeaturesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceTensorFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorNonPacked == rhs.tensorNonPacked ) && + ( shaderTensorAccess == rhs.shaderTensorAccess ) && ( shaderStorageTensorArrayDynamicIndexing == rhs.shaderStorageTensorArrayDynamicIndexing ) && + ( shaderStorageTensorArrayNonUniformIndexing == rhs.shaderStorageTensorArrayNonUniformIndexing ) && + ( descriptorBindingStorageTensorUpdateAfterBind == rhs.descriptorBindingStorageTensorUpdateAfterBind ) && ( tensors == rhs.tensors ); +# endif + } + + bool operator!=( PhysicalDeviceTensorFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTensorFeaturesARM; + void * pNext = {}; + Bool32 tensorNonPacked = {}; + Bool32 shaderTensorAccess = {}; + Bool32 shaderStorageTensorArrayDynamicIndexing = {}; + Bool32 shaderStorageTensorArrayNonUniformIndexing = {}; + Bool32 descriptorBindingStorageTensorUpdateAfterBind = {}; + Bool32 tensors = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTensorFeaturesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTensorFeaturesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceTensorPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTensorPropertiesARM.html + struct PhysicalDeviceTensorPropertiesARM + { + using NativeType = VkPhysicalDeviceTensorPropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTensorPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTensorPropertiesARM( uint32_t maxTensorDimensionCount_ = {}, + uint64_t maxTensorElements_ = {}, + uint64_t maxPerDimensionTensorElements_ = {}, + int64_t maxTensorStride_ = {}, + uint64_t maxTensorSize_ = {}, + uint32_t maxTensorShaderAccessArrayLength_ = {}, + uint32_t maxTensorShaderAccessSize_ = {}, + uint32_t maxDescriptorSetStorageTensors_ = {}, + uint32_t maxPerStageDescriptorSetStorageTensors_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindStorageTensors_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors_ = {}, + Bool32 shaderStorageTensorArrayNonUniformIndexingNative_ = {}, + ShaderStageFlags shaderTensorSupportedStages_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxTensorDimensionCount{ maxTensorDimensionCount_ } + , maxTensorElements{ maxTensorElements_ } + , maxPerDimensionTensorElements{ maxPerDimensionTensorElements_ } + , maxTensorStride{ maxTensorStride_ } + , maxTensorSize{ maxTensorSize_ } + , maxTensorShaderAccessArrayLength{ maxTensorShaderAccessArrayLength_ } + , maxTensorShaderAccessSize{ maxTensorShaderAccessSize_ } + , maxDescriptorSetStorageTensors{ maxDescriptorSetStorageTensors_ } + , maxPerStageDescriptorSetStorageTensors{ maxPerStageDescriptorSetStorageTensors_ } + , maxDescriptorSetUpdateAfterBindStorageTensors{ maxDescriptorSetUpdateAfterBindStorageTensors_ } + , maxPerStageDescriptorUpdateAfterBindStorageTensors{ maxPerStageDescriptorUpdateAfterBindStorageTensors_ } + , shaderStorageTensorArrayNonUniformIndexingNative{ shaderStorageTensorArrayNonUniformIndexingNative_ } + , shaderTensorSupportedStages{ shaderTensorSupportedStages_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTensorPropertiesARM( PhysicalDeviceTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTensorPropertiesARM( VkPhysicalDeviceTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTensorPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTensorPropertiesARM & operator=( PhysicalDeviceTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTensorPropertiesARM & operator=( VkPhysicalDeviceTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceTensorPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTensorPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTensorPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTensorPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxTensorDimensionCount, + maxTensorElements, + maxPerDimensionTensorElements, + maxTensorStride, + maxTensorSize, + maxTensorShaderAccessArrayLength, + maxTensorShaderAccessSize, + maxDescriptorSetStorageTensors, + maxPerStageDescriptorSetStorageTensors, + maxDescriptorSetUpdateAfterBindStorageTensors, + maxPerStageDescriptorUpdateAfterBindStorageTensors, + shaderStorageTensorArrayNonUniformIndexingNative, + shaderTensorSupportedStages ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTensorPropertiesARM const & ) const = default; +#else + bool operator==( PhysicalDeviceTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTensorDimensionCount == rhs.maxTensorDimensionCount ) && + ( maxTensorElements == rhs.maxTensorElements ) && ( maxPerDimensionTensorElements == rhs.maxPerDimensionTensorElements ) && + ( maxTensorStride == rhs.maxTensorStride ) && ( maxTensorSize == rhs.maxTensorSize ) && + ( maxTensorShaderAccessArrayLength == rhs.maxTensorShaderAccessArrayLength ) && ( maxTensorShaderAccessSize == rhs.maxTensorShaderAccessSize ) && + ( maxDescriptorSetStorageTensors == rhs.maxDescriptorSetStorageTensors ) && + ( maxPerStageDescriptorSetStorageTensors == rhs.maxPerStageDescriptorSetStorageTensors ) && + ( maxDescriptorSetUpdateAfterBindStorageTensors == rhs.maxDescriptorSetUpdateAfterBindStorageTensors ) && + ( maxPerStageDescriptorUpdateAfterBindStorageTensors == rhs.maxPerStageDescriptorUpdateAfterBindStorageTensors ) && + ( shaderStorageTensorArrayNonUniformIndexingNative == rhs.shaderStorageTensorArrayNonUniformIndexingNative ) && + ( shaderTensorSupportedStages == rhs.shaderTensorSupportedStages ); +# endif + } + + bool operator!=( PhysicalDeviceTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTensorPropertiesARM; + void * pNext = {}; + uint32_t maxTensorDimensionCount = {}; + uint64_t maxTensorElements = {}; + uint64_t maxPerDimensionTensorElements = {}; + int64_t maxTensorStride = {}; + uint64_t maxTensorSize = {}; + uint32_t maxTensorShaderAccessArrayLength = {}; + uint32_t maxTensorShaderAccessSize = {}; + uint32_t maxDescriptorSetStorageTensors = {}; + uint32_t maxPerStageDescriptorSetStorageTensors = {}; + uint32_t maxDescriptorSetUpdateAfterBindStorageTensors = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors = {}; + Bool32 shaderStorageTensorArrayNonUniformIndexingNative = {}; + ShaderStageFlags shaderTensorSupportedStages = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTensorPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTensorPropertiesARM; + }; + + // wrapper struct for struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html + struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT + { + using NativeType = VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( Bool32 texelBufferAlignment_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , texelBufferAlignment{ texelBufferAlignment_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceTexelBufferAlignmentFeaturesEXT( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTexelBufferAlignmentFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTexelBufferAlignmentFeaturesEXT & operator=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTexelBufferAlignmentFeaturesEXT & operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTexelBufferAlignmentFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTexelBufferAlignmentFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTexelBufferAlignmentFeaturesEXT & setTexelBufferAlignment( Bool32 texelBufferAlignment_ ) & VULKAN_HPP_NOEXCEPT + { + texelBufferAlignment = texelBufferAlignment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTexelBufferAlignmentFeaturesEXT && setTexelBufferAlignment( Bool32 texelBufferAlignment_ ) && VULKAN_HPP_NOEXCEPT + { + texelBufferAlignment = texelBufferAlignment_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, texelBufferAlignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( texelBufferAlignment == rhs.texelBufferAlignment ); +# endif + } + + bool operator!=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT; + void * pNext = {}; + Bool32 texelBufferAlignment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceTexelBufferAlignmentProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTexelBufferAlignmentProperties.html + struct PhysicalDeviceTexelBufferAlignmentProperties + { + using NativeType = VkPhysicalDeviceTexelBufferAlignmentProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTexelBufferAlignmentProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentProperties( DeviceSize storageTexelBufferOffsetAlignmentBytes_ = {}, + Bool32 storageTexelBufferOffsetSingleTexelAlignment_ = {}, + DeviceSize uniformTexelBufferOffsetAlignmentBytes_ = {}, + Bool32 uniformTexelBufferOffsetSingleTexelAlignment_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , storageTexelBufferOffsetAlignmentBytes{ storageTexelBufferOffsetAlignmentBytes_ } + , storageTexelBufferOffsetSingleTexelAlignment{ storageTexelBufferOffsetSingleTexelAlignment_ } + , uniformTexelBufferOffsetAlignmentBytes{ uniformTexelBufferOffsetAlignmentBytes_ } + , uniformTexelBufferOffsetSingleTexelAlignment{ uniformTexelBufferOffsetSingleTexelAlignment_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentProperties( PhysicalDeviceTexelBufferAlignmentProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTexelBufferAlignmentProperties( VkPhysicalDeviceTexelBufferAlignmentProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTexelBufferAlignmentProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTexelBufferAlignmentProperties & operator=( PhysicalDeviceTexelBufferAlignmentProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTexelBufferAlignmentProperties & operator=( VkPhysicalDeviceTexelBufferAlignmentProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceTexelBufferAlignmentProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTexelBufferAlignmentProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTexelBufferAlignmentProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTexelBufferAlignmentProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + storageTexelBufferOffsetAlignmentBytes, + storageTexelBufferOffsetSingleTexelAlignment, + uniformTexelBufferOffsetAlignmentBytes, + uniformTexelBufferOffsetSingleTexelAlignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTexelBufferAlignmentProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceTexelBufferAlignmentProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes ) && + ( storageTexelBufferOffsetSingleTexelAlignment == rhs.storageTexelBufferOffsetSingleTexelAlignment ) && + ( uniformTexelBufferOffsetAlignmentBytes == rhs.uniformTexelBufferOffsetAlignmentBytes ) && + ( uniformTexelBufferOffsetSingleTexelAlignment == rhs.uniformTexelBufferOffsetSingleTexelAlignment ); +# endif + } + + bool operator!=( PhysicalDeviceTexelBufferAlignmentProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentProperties; + void * pNext = {}; + DeviceSize storageTexelBufferOffsetAlignmentBytes = {}; + Bool32 storageTexelBufferOffsetSingleTexelAlignment = {}; + DeviceSize uniformTexelBufferOffsetAlignmentBytes = {}; + Bool32 uniformTexelBufferOffsetSingleTexelAlignment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTexelBufferAlignmentProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTexelBufferAlignmentProperties; + }; + + using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties; + + // wrapper struct for struct VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT.html + struct PhysicalDeviceTextureCompressionASTC3DFeaturesEXT + { + using NativeType = VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( Bool32 textureCompressionASTC_3D_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , textureCompressionASTC_3D{ textureCompressionASTC_3D_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTextureCompressionASTC3DFeaturesEXT & + operator=( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTextureCompressionASTC3DFeaturesEXT & operator=( VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT & setTextureCompressionASTC_3D( Bool32 textureCompressionASTC_3D_ ) & + VULKAN_HPP_NOEXCEPT + { + textureCompressionASTC_3D = textureCompressionASTC_3D_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT && setTextureCompressionASTC_3D( Bool32 textureCompressionASTC_3D_ ) && + VULKAN_HPP_NOEXCEPT + { + textureCompressionASTC_3D = textureCompressionASTC_3D_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, textureCompressionASTC_3D ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( textureCompressionASTC_3D == rhs.textureCompressionASTC_3D ); +# endif + } + + bool operator!=( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT; + void * pNext = {}; + Bool32 textureCompressionASTC_3D = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTextureCompressionASTC3DFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTextureCompressionASTC3DFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeatures.html + struct PhysicalDeviceTextureCompressionASTCHDRFeatures + { + using NativeType = VkPhysicalDeviceTextureCompressionASTCHDRFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeatures( Bool32 textureCompressionASTC_HDR_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , textureCompressionASTC_HDR{ textureCompressionASTC_HDR_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceTextureCompressionASTCHDRFeatures( PhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTextureCompressionASTCHDRFeatures( VkPhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTextureCompressionASTCHDRFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTextureCompressionASTCHDRFeatures & operator=( PhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTextureCompressionASTCHDRFeatures & operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTCHDRFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTCHDRFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTCHDRFeatures & setTextureCompressionASTC_HDR( Bool32 textureCompressionASTC_HDR_ ) & + VULKAN_HPP_NOEXCEPT + { + textureCompressionASTC_HDR = textureCompressionASTC_HDR_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTCHDRFeatures && setTextureCompressionASTC_HDR( Bool32 textureCompressionASTC_HDR_ ) && + VULKAN_HPP_NOEXCEPT + { + textureCompressionASTC_HDR = textureCompressionASTC_HDR_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTextureCompressionASTCHDRFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTextureCompressionASTCHDRFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTextureCompressionASTCHDRFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTextureCompressionASTCHDRFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, textureCompressionASTC_HDR ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTextureCompressionASTCHDRFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR ); +# endif + } + + bool operator!=( PhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeatures; + void * pNext = {}; + Bool32 textureCompressionASTC_HDR = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTextureCompressionASTCHDRFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTextureCompressionASTCHDRFeatures; + }; + + using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures; + + // wrapper struct for struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.html + struct PhysicalDeviceTileMemoryHeapFeaturesQCOM + { + using NativeType = VkPhysicalDeviceTileMemoryHeapFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapFeaturesQCOM( Bool32 tileMemoryHeap_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tileMemoryHeap{ tileMemoryHeap_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapFeaturesQCOM( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTileMemoryHeapFeaturesQCOM( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTileMemoryHeapFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTileMemoryHeapFeaturesQCOM & operator=( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTileMemoryHeapFeaturesQCOM & operator=( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM & setTileMemoryHeap( Bool32 tileMemoryHeap_ ) & VULKAN_HPP_NOEXCEPT + { + tileMemoryHeap = tileMemoryHeap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM && setTileMemoryHeap( Bool32 tileMemoryHeap_ ) && VULKAN_HPP_NOEXCEPT + { + tileMemoryHeap = tileMemoryHeap_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tileMemoryHeap ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tileMemoryHeap == rhs.tileMemoryHeap ); +# endif + } + + bool operator!=( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM; + void * pNext = {}; + Bool32 tileMemoryHeap = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTileMemoryHeapFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTileMemoryHeapFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileMemoryHeapPropertiesQCOM.html + struct PhysicalDeviceTileMemoryHeapPropertiesQCOM + { + using NativeType = VkPhysicalDeviceTileMemoryHeapPropertiesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapPropertiesQCOM( Bool32 queueSubmitBoundary_ = {}, + Bool32 tileBufferTransfers_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , queueSubmitBoundary{ queueSubmitBoundary_ } + , tileBufferTransfers{ tileBufferTransfers_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapPropertiesQCOM( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTileMemoryHeapPropertiesQCOM( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTileMemoryHeapPropertiesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTileMemoryHeapPropertiesQCOM & operator=( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTileMemoryHeapPropertiesQCOM & operator=( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM & setQueueSubmitBoundary( Bool32 queueSubmitBoundary_ ) & VULKAN_HPP_NOEXCEPT + { + queueSubmitBoundary = queueSubmitBoundary_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM && setQueueSubmitBoundary( Bool32 queueSubmitBoundary_ ) && VULKAN_HPP_NOEXCEPT + { + queueSubmitBoundary = queueSubmitBoundary_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM & setTileBufferTransfers( Bool32 tileBufferTransfers_ ) & VULKAN_HPP_NOEXCEPT + { + tileBufferTransfers = tileBufferTransfers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM && setTileBufferTransfers( Bool32 tileBufferTransfers_ ) && VULKAN_HPP_NOEXCEPT + { + tileBufferTransfers = tileBufferTransfers_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queueSubmitBoundary, tileBufferTransfers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueSubmitBoundary == rhs.queueSubmitBoundary ) && + ( tileBufferTransfers == rhs.tileBufferTransfers ); +# endif + } + + bool operator!=( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM; + void * pNext = {}; + Bool32 queueSubmitBoundary = {}; + Bool32 tileBufferTransfers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTileMemoryHeapPropertiesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTileMemoryHeapPropertiesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceTilePropertiesFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTilePropertiesFeaturesQCOM.html + struct PhysicalDeviceTilePropertiesFeaturesQCOM + { + using NativeType = VkPhysicalDeviceTilePropertiesFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTilePropertiesFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTilePropertiesFeaturesQCOM( Bool32 tileProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tileProperties{ tileProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTilePropertiesFeaturesQCOM( PhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTilePropertiesFeaturesQCOM( VkPhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTilePropertiesFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTilePropertiesFeaturesQCOM & operator=( PhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTilePropertiesFeaturesQCOM & operator=( VkPhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTilePropertiesFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTilePropertiesFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTilePropertiesFeaturesQCOM & setTileProperties( Bool32 tileProperties_ ) & VULKAN_HPP_NOEXCEPT + { + tileProperties = tileProperties_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTilePropertiesFeaturesQCOM && setTileProperties( Bool32 tileProperties_ ) && VULKAN_HPP_NOEXCEPT + { + tileProperties = tileProperties_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTilePropertiesFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTilePropertiesFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTilePropertiesFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTilePropertiesFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tileProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTilePropertiesFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tileProperties == rhs.tileProperties ); +# endif + } + + bool operator!=( PhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTilePropertiesFeaturesQCOM; + void * pNext = {}; + Bool32 tileProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTilePropertiesFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTilePropertiesFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceTileShadingFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileShadingFeaturesQCOM.html + struct PhysicalDeviceTileShadingFeaturesQCOM + { + using NativeType = VkPhysicalDeviceTileShadingFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileShadingFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingFeaturesQCOM( Bool32 tileShading_ = {}, + Bool32 tileShadingFragmentStage_ = {}, + Bool32 tileShadingColorAttachments_ = {}, + Bool32 tileShadingDepthAttachments_ = {}, + Bool32 tileShadingStencilAttachments_ = {}, + Bool32 tileShadingInputAttachments_ = {}, + Bool32 tileShadingSampledAttachments_ = {}, + Bool32 tileShadingPerTileDraw_ = {}, + Bool32 tileShadingPerTileDispatch_ = {}, + Bool32 tileShadingDispatchTile_ = {}, + Bool32 tileShadingApron_ = {}, + Bool32 tileShadingAnisotropicApron_ = {}, + Bool32 tileShadingAtomicOps_ = {}, + Bool32 tileShadingImageProcessing_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tileShading{ tileShading_ } + , tileShadingFragmentStage{ tileShadingFragmentStage_ } + , tileShadingColorAttachments{ tileShadingColorAttachments_ } + , tileShadingDepthAttachments{ tileShadingDepthAttachments_ } + , tileShadingStencilAttachments{ tileShadingStencilAttachments_ } + , tileShadingInputAttachments{ tileShadingInputAttachments_ } + , tileShadingSampledAttachments{ tileShadingSampledAttachments_ } + , tileShadingPerTileDraw{ tileShadingPerTileDraw_ } + , tileShadingPerTileDispatch{ tileShadingPerTileDispatch_ } + , tileShadingDispatchTile{ tileShadingDispatchTile_ } + , tileShadingApron{ tileShadingApron_ } + , tileShadingAnisotropicApron{ tileShadingAnisotropicApron_ } + , tileShadingAtomicOps{ tileShadingAtomicOps_ } + , tileShadingImageProcessing{ tileShadingImageProcessing_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingFeaturesQCOM( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTileShadingFeaturesQCOM( VkPhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTileShadingFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTileShadingFeaturesQCOM & operator=( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTileShadingFeaturesQCOM & operator=( VkPhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShading( Bool32 tileShading_ ) & VULKAN_HPP_NOEXCEPT + { + tileShading = tileShading_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShading( Bool32 tileShading_ ) && VULKAN_HPP_NOEXCEPT + { + tileShading = tileShading_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingFragmentStage( Bool32 tileShadingFragmentStage_ ) & VULKAN_HPP_NOEXCEPT + { + tileShadingFragmentStage = tileShadingFragmentStage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingFragmentStage( Bool32 tileShadingFragmentStage_ ) && VULKAN_HPP_NOEXCEPT + { + tileShadingFragmentStage = tileShadingFragmentStage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingColorAttachments( Bool32 tileShadingColorAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + tileShadingColorAttachments = tileShadingColorAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingColorAttachments( Bool32 tileShadingColorAttachments_ ) && + VULKAN_HPP_NOEXCEPT + { + tileShadingColorAttachments = tileShadingColorAttachments_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingDepthAttachments( Bool32 tileShadingDepthAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + tileShadingDepthAttachments = tileShadingDepthAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingDepthAttachments( Bool32 tileShadingDepthAttachments_ ) && + VULKAN_HPP_NOEXCEPT + { + tileShadingDepthAttachments = tileShadingDepthAttachments_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingStencilAttachments( Bool32 tileShadingStencilAttachments_ ) & + VULKAN_HPP_NOEXCEPT + { + tileShadingStencilAttachments = tileShadingStencilAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingStencilAttachments( Bool32 tileShadingStencilAttachments_ ) && + VULKAN_HPP_NOEXCEPT + { + tileShadingStencilAttachments = tileShadingStencilAttachments_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingInputAttachments( Bool32 tileShadingInputAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + tileShadingInputAttachments = tileShadingInputAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingInputAttachments( Bool32 tileShadingInputAttachments_ ) && + VULKAN_HPP_NOEXCEPT + { + tileShadingInputAttachments = tileShadingInputAttachments_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingSampledAttachments( Bool32 tileShadingSampledAttachments_ ) & + VULKAN_HPP_NOEXCEPT + { + tileShadingSampledAttachments = tileShadingSampledAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingSampledAttachments( Bool32 tileShadingSampledAttachments_ ) && + VULKAN_HPP_NOEXCEPT + { + tileShadingSampledAttachments = tileShadingSampledAttachments_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingPerTileDraw( Bool32 tileShadingPerTileDraw_ ) & VULKAN_HPP_NOEXCEPT + { + tileShadingPerTileDraw = tileShadingPerTileDraw_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingPerTileDraw( Bool32 tileShadingPerTileDraw_ ) && VULKAN_HPP_NOEXCEPT + { + tileShadingPerTileDraw = tileShadingPerTileDraw_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingPerTileDispatch( Bool32 tileShadingPerTileDispatch_ ) & VULKAN_HPP_NOEXCEPT + { + tileShadingPerTileDispatch = tileShadingPerTileDispatch_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingPerTileDispatch( Bool32 tileShadingPerTileDispatch_ ) && VULKAN_HPP_NOEXCEPT + { + tileShadingPerTileDispatch = tileShadingPerTileDispatch_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingDispatchTile( Bool32 tileShadingDispatchTile_ ) & VULKAN_HPP_NOEXCEPT + { + tileShadingDispatchTile = tileShadingDispatchTile_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingDispatchTile( Bool32 tileShadingDispatchTile_ ) && VULKAN_HPP_NOEXCEPT + { + tileShadingDispatchTile = tileShadingDispatchTile_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingApron( Bool32 tileShadingApron_ ) & VULKAN_HPP_NOEXCEPT + { + tileShadingApron = tileShadingApron_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingApron( Bool32 tileShadingApron_ ) && VULKAN_HPP_NOEXCEPT + { + tileShadingApron = tileShadingApron_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingAnisotropicApron( Bool32 tileShadingAnisotropicApron_ ) & VULKAN_HPP_NOEXCEPT + { + tileShadingAnisotropicApron = tileShadingAnisotropicApron_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingAnisotropicApron( Bool32 tileShadingAnisotropicApron_ ) && + VULKAN_HPP_NOEXCEPT + { + tileShadingAnisotropicApron = tileShadingAnisotropicApron_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingAtomicOps( Bool32 tileShadingAtomicOps_ ) & VULKAN_HPP_NOEXCEPT + { + tileShadingAtomicOps = tileShadingAtomicOps_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingAtomicOps( Bool32 tileShadingAtomicOps_ ) && VULKAN_HPP_NOEXCEPT + { + tileShadingAtomicOps = tileShadingAtomicOps_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingImageProcessing( Bool32 tileShadingImageProcessing_ ) & VULKAN_HPP_NOEXCEPT + { + tileShadingImageProcessing = tileShadingImageProcessing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingImageProcessing( Bool32 tileShadingImageProcessing_ ) && VULKAN_HPP_NOEXCEPT + { + tileShadingImageProcessing = tileShadingImageProcessing_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTileShadingFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + tileShading, + tileShadingFragmentStage, + tileShadingColorAttachments, + tileShadingDepthAttachments, + tileShadingStencilAttachments, + tileShadingInputAttachments, + tileShadingSampledAttachments, + tileShadingPerTileDraw, + tileShadingPerTileDispatch, + tileShadingDispatchTile, + tileShadingApron, + tileShadingAnisotropicApron, + tileShadingAtomicOps, + tileShadingImageProcessing ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTileShadingFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tileShading == rhs.tileShading ) && + ( tileShadingFragmentStage == rhs.tileShadingFragmentStage ) && ( tileShadingColorAttachments == rhs.tileShadingColorAttachments ) && + ( tileShadingDepthAttachments == rhs.tileShadingDepthAttachments ) && ( tileShadingStencilAttachments == rhs.tileShadingStencilAttachments ) && + ( tileShadingInputAttachments == rhs.tileShadingInputAttachments ) && ( tileShadingSampledAttachments == rhs.tileShadingSampledAttachments ) && + ( tileShadingPerTileDraw == rhs.tileShadingPerTileDraw ) && ( tileShadingPerTileDispatch == rhs.tileShadingPerTileDispatch ) && + ( tileShadingDispatchTile == rhs.tileShadingDispatchTile ) && ( tileShadingApron == rhs.tileShadingApron ) && + ( tileShadingAnisotropicApron == rhs.tileShadingAnisotropicApron ) && ( tileShadingAtomicOps == rhs.tileShadingAtomicOps ) && + ( tileShadingImageProcessing == rhs.tileShadingImageProcessing ); +# endif + } + + bool operator!=( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTileShadingFeaturesQCOM; + void * pNext = {}; + Bool32 tileShading = {}; + Bool32 tileShadingFragmentStage = {}; + Bool32 tileShadingColorAttachments = {}; + Bool32 tileShadingDepthAttachments = {}; + Bool32 tileShadingStencilAttachments = {}; + Bool32 tileShadingInputAttachments = {}; + Bool32 tileShadingSampledAttachments = {}; + Bool32 tileShadingPerTileDraw = {}; + Bool32 tileShadingPerTileDispatch = {}; + Bool32 tileShadingDispatchTile = {}; + Bool32 tileShadingApron = {}; + Bool32 tileShadingAnisotropicApron = {}; + Bool32 tileShadingAtomicOps = {}; + Bool32 tileShadingImageProcessing = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTileShadingFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTileShadingFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceTileShadingPropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileShadingPropertiesQCOM.html + struct PhysicalDeviceTileShadingPropertiesQCOM + { + using NativeType = VkPhysicalDeviceTileShadingPropertiesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileShadingPropertiesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingPropertiesQCOM( uint32_t maxApronSize_ = {}, + Bool32 preferNonCoherent_ = {}, + Extent2D tileGranularity_ = {}, + Extent2D maxTileShadingRate_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxApronSize{ maxApronSize_ } + , preferNonCoherent{ preferNonCoherent_ } + , tileGranularity{ tileGranularity_ } + , maxTileShadingRate{ maxTileShadingRate_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingPropertiesQCOM( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTileShadingPropertiesQCOM( VkPhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTileShadingPropertiesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTileShadingPropertiesQCOM & operator=( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTileShadingPropertiesQCOM & operator=( VkPhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceTileShadingPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingPropertiesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingPropertiesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxApronSize, preferNonCoherent, tileGranularity, maxTileShadingRate ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTileShadingPropertiesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxApronSize == rhs.maxApronSize ) && ( preferNonCoherent == rhs.preferNonCoherent ) && + ( tileGranularity == rhs.tileGranularity ) && ( maxTileShadingRate == rhs.maxTileShadingRate ); +# endif + } + + bool operator!=( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTileShadingPropertiesQCOM; + void * pNext = {}; + uint32_t maxApronSize = {}; + Bool32 preferNonCoherent = {}; + Extent2D tileGranularity = {}; + Extent2D maxTileShadingRate = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTileShadingPropertiesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTileShadingPropertiesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceTimelineSemaphoreFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html + struct PhysicalDeviceTimelineSemaphoreFeatures + { + using NativeType = VkPhysicalDeviceTimelineSemaphoreFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTimelineSemaphoreFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeatures( Bool32 timelineSemaphore_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , timelineSemaphore{ timelineSemaphore_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeatures( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTimelineSemaphoreFeatures( VkPhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTimelineSemaphoreFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTimelineSemaphoreFeatures & operator=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTimelineSemaphoreFeatures & operator=( VkPhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTimelineSemaphoreFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTimelineSemaphoreFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTimelineSemaphoreFeatures & setTimelineSemaphore( Bool32 timelineSemaphore_ ) & VULKAN_HPP_NOEXCEPT + { + timelineSemaphore = timelineSemaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTimelineSemaphoreFeatures && setTimelineSemaphore( Bool32 timelineSemaphore_ ) && VULKAN_HPP_NOEXCEPT + { + timelineSemaphore = timelineSemaphore_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTimelineSemaphoreFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTimelineSemaphoreFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTimelineSemaphoreFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTimelineSemaphoreFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, timelineSemaphore ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTimelineSemaphoreFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timelineSemaphore == rhs.timelineSemaphore ); +# endif + } + + bool operator!=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreFeatures; + void * pNext = {}; + Bool32 timelineSemaphore = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTimelineSemaphoreFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTimelineSemaphoreFeatures; + }; + + using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures; + + // wrapper struct for struct VkPhysicalDeviceTimelineSemaphoreProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html + struct PhysicalDeviceTimelineSemaphoreProperties + { + using NativeType = VkPhysicalDeviceTimelineSemaphoreProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTimelineSemaphoreProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreProperties( uint64_t maxTimelineSemaphoreValueDifference_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxTimelineSemaphoreValueDifference{ maxTimelineSemaphoreValueDifference_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreProperties( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTimelineSemaphoreProperties( VkPhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTimelineSemaphoreProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTimelineSemaphoreProperties & operator=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTimelineSemaphoreProperties & operator=( VkPhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceTimelineSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTimelineSemaphoreProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTimelineSemaphoreProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTimelineSemaphoreProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxTimelineSemaphoreValueDifference ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTimelineSemaphoreProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ); +# endif + } + + bool operator!=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreProperties; + void * pNext = {}; + uint64_t maxTimelineSemaphoreValueDifference = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTimelineSemaphoreProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTimelineSemaphoreProperties; + }; + + using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties; + + // wrapper struct for struct VkPhysicalDeviceToolProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceToolProperties.html + struct PhysicalDeviceToolProperties + { + using NativeType = VkPhysicalDeviceToolProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceToolProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceToolProperties( std::array const & name_ = {}, + std::array const & version_ = {}, + ToolPurposeFlags purposes_ = {}, + std::array const & description_ = {}, + std::array const & layer_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , name{ name_ } + , version{ version_ } + , purposes{ purposes_ } + , description{ description_ } + , layer{ layer_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceToolProperties( PhysicalDeviceToolProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceToolProperties( VkPhysicalDeviceToolProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceToolProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceToolProperties & operator=( PhysicalDeviceToolProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceToolProperties & operator=( VkPhysicalDeviceToolProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceToolProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceToolProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceToolProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceToolProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &, + ToolPurposeFlags const &, + ArrayWrapper1D const &, + ArrayWrapper1D const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, name, version, purposes, description, layer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PhysicalDeviceToolProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( version, rhs.version ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = purposes <=> rhs.purposes; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( layer, rhs.layer ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( PhysicalDeviceToolProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( strcmp( name, rhs.name ) == 0 ) && ( strcmp( version, rhs.version ) == 0 ) && + ( purposes == rhs.purposes ) && ( strcmp( description, rhs.description ) == 0 ) && ( strcmp( layer, rhs.layer ) == 0 ); + } + + bool operator!=( PhysicalDeviceToolProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::ePhysicalDeviceToolProperties; + void * pNext = {}; + ArrayWrapper1D name = {}; + ArrayWrapper1D version = {}; + ToolPurposeFlags purposes = {}; + ArrayWrapper1D description = {}; + ArrayWrapper1D layer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceToolProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceToolProperties; + }; + + using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties; + + // wrapper struct for struct VkPhysicalDeviceTransformFeedbackFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html + struct PhysicalDeviceTransformFeedbackFeaturesEXT + { + using NativeType = VkPhysicalDeviceTransformFeedbackFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PhysicalDeviceTransformFeedbackFeaturesEXT( Bool32 transformFeedback_ = {}, Bool32 geometryStreams_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , transformFeedback{ transformFeedback_ } + , geometryStreams{ geometryStreams_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTransformFeedbackFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTransformFeedbackFeaturesEXT & operator=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTransformFeedbackFeaturesEXT & operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT & setTransformFeedback( Bool32 transformFeedback_ ) & VULKAN_HPP_NOEXCEPT + { + transformFeedback = transformFeedback_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT && setTransformFeedback( Bool32 transformFeedback_ ) && VULKAN_HPP_NOEXCEPT + { + transformFeedback = transformFeedback_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT & setGeometryStreams( Bool32 geometryStreams_ ) & VULKAN_HPP_NOEXCEPT + { + geometryStreams = geometryStreams_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT && setGeometryStreams( Bool32 geometryStreams_ ) && VULKAN_HPP_NOEXCEPT + { + geometryStreams = geometryStreams_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTransformFeedbackFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transformFeedback, geometryStreams ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTransformFeedbackFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transformFeedback == rhs.transformFeedback ) && ( geometryStreams == rhs.geometryStreams ); +# endif + } + + bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; + void * pNext = {}; + Bool32 transformFeedback = {}; + Bool32 geometryStreams = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTransformFeedbackFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTransformFeedbackFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceTransformFeedbackPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html + struct PhysicalDeviceTransformFeedbackPropertiesEXT + { + using NativeType = VkPhysicalDeviceTransformFeedbackPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackPropertiesEXT( uint32_t maxTransformFeedbackStreams_ = {}, + uint32_t maxTransformFeedbackBuffers_ = {}, + DeviceSize maxTransformFeedbackBufferSize_ = {}, + uint32_t maxTransformFeedbackStreamDataSize_ = {}, + uint32_t maxTransformFeedbackBufferDataSize_ = {}, + uint32_t maxTransformFeedbackBufferDataStride_ = {}, + Bool32 transformFeedbackQueries_ = {}, + Bool32 transformFeedbackStreamsLinesTriangles_ = {}, + Bool32 transformFeedbackRasterizationStreamSelect_ = {}, + Bool32 transformFeedbackDraw_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxTransformFeedbackStreams{ maxTransformFeedbackStreams_ } + , maxTransformFeedbackBuffers{ maxTransformFeedbackBuffers_ } + , maxTransformFeedbackBufferSize{ maxTransformFeedbackBufferSize_ } + , maxTransformFeedbackStreamDataSize{ maxTransformFeedbackStreamDataSize_ } + , maxTransformFeedbackBufferDataSize{ maxTransformFeedbackBufferDataSize_ } + , maxTransformFeedbackBufferDataStride{ maxTransformFeedbackBufferDataStride_ } + , transformFeedbackQueries{ transformFeedbackQueries_ } + , transformFeedbackStreamsLinesTriangles{ transformFeedbackStreamsLinesTriangles_ } + , transformFeedbackRasterizationStreamSelect{ transformFeedbackRasterizationStreamSelect_ } + , transformFeedbackDraw{ transformFeedbackDraw_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackPropertiesEXT( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTransformFeedbackPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTransformFeedbackPropertiesEXT & operator=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTransformFeedbackPropertiesEXT & operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTransformFeedbackPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + maxTransformFeedbackStreams, + maxTransformFeedbackBuffers, + maxTransformFeedbackBufferSize, + maxTransformFeedbackStreamDataSize, + maxTransformFeedbackBufferDataSize, + maxTransformFeedbackBufferDataStride, + transformFeedbackQueries, + transformFeedbackStreamsLinesTriangles, + transformFeedbackRasterizationStreamSelect, + transformFeedbackDraw ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTransformFeedbackPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams ) && + ( maxTransformFeedbackBuffers == rhs.maxTransformFeedbackBuffers ) && ( maxTransformFeedbackBufferSize == rhs.maxTransformFeedbackBufferSize ) && + ( maxTransformFeedbackStreamDataSize == rhs.maxTransformFeedbackStreamDataSize ) && + ( maxTransformFeedbackBufferDataSize == rhs.maxTransformFeedbackBufferDataSize ) && + ( maxTransformFeedbackBufferDataStride == rhs.maxTransformFeedbackBufferDataStride ) && + ( transformFeedbackQueries == rhs.transformFeedbackQueries ) && + ( transformFeedbackStreamsLinesTriangles == rhs.transformFeedbackStreamsLinesTriangles ) && + ( transformFeedbackRasterizationStreamSelect == rhs.transformFeedbackRasterizationStreamSelect ) && + ( transformFeedbackDraw == rhs.transformFeedbackDraw ); +# endif + } + + bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; + void * pNext = {}; + uint32_t maxTransformFeedbackStreams = {}; + uint32_t maxTransformFeedbackBuffers = {}; + DeviceSize maxTransformFeedbackBufferSize = {}; + uint32_t maxTransformFeedbackStreamDataSize = {}; + uint32_t maxTransformFeedbackBufferDataSize = {}; + uint32_t maxTransformFeedbackBufferDataStride = {}; + Bool32 transformFeedbackQueries = {}; + Bool32 transformFeedbackStreamsLinesTriangles = {}; + Bool32 transformFeedbackRasterizationStreamSelect = {}; + Bool32 transformFeedbackDraw = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceTransformFeedbackPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceTransformFeedbackPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR.html + struct PhysicalDeviceUnifiedImageLayoutsFeaturesKHR + { + using NativeType = VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceUnifiedImageLayoutsFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceUnifiedImageLayoutsFeaturesKHR( Bool32 unifiedImageLayouts_ = {}, + Bool32 unifiedImageLayoutsVideo_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , unifiedImageLayouts{ unifiedImageLayouts_ } + , unifiedImageLayoutsVideo{ unifiedImageLayoutsVideo_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceUnifiedImageLayoutsFeaturesKHR( PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceUnifiedImageLayoutsFeaturesKHR( VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceUnifiedImageLayoutsFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceUnifiedImageLayoutsFeaturesKHR & operator=( PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceUnifiedImageLayoutsFeaturesKHR & operator=( VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR & setUnifiedImageLayouts( Bool32 unifiedImageLayouts_ ) & VULKAN_HPP_NOEXCEPT + { + unifiedImageLayouts = unifiedImageLayouts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR && setUnifiedImageLayouts( Bool32 unifiedImageLayouts_ ) && VULKAN_HPP_NOEXCEPT + { + unifiedImageLayouts = unifiedImageLayouts_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR & setUnifiedImageLayoutsVideo( Bool32 unifiedImageLayoutsVideo_ ) & VULKAN_HPP_NOEXCEPT + { + unifiedImageLayoutsVideo = unifiedImageLayoutsVideo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR && setUnifiedImageLayoutsVideo( Bool32 unifiedImageLayoutsVideo_ ) && + VULKAN_HPP_NOEXCEPT + { + unifiedImageLayoutsVideo = unifiedImageLayoutsVideo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, unifiedImageLayouts, unifiedImageLayoutsVideo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( unifiedImageLayouts == rhs.unifiedImageLayouts ) && + ( unifiedImageLayoutsVideo == rhs.unifiedImageLayoutsVideo ); +# endif + } + + bool operator!=( PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceUnifiedImageLayoutsFeaturesKHR; + void * pNext = {}; + Bool32 unifiedImageLayouts = {}; + Bool32 unifiedImageLayoutsVideo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceUnifiedImageLayoutsFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceUnifiedImageLayoutsFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html + struct PhysicalDeviceUniformBufferStandardLayoutFeatures + { + using NativeType = VkPhysicalDeviceUniformBufferStandardLayoutFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeatures( Bool32 uniformBufferStandardLayout_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , uniformBufferStandardLayout{ uniformBufferStandardLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceUniformBufferStandardLayoutFeatures( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceUniformBufferStandardLayoutFeatures( VkPhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceUniformBufferStandardLayoutFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceUniformBufferStandardLayoutFeatures & + operator=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceUniformBufferStandardLayoutFeatures & operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUniformBufferStandardLayoutFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUniformBufferStandardLayoutFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUniformBufferStandardLayoutFeatures & setUniformBufferStandardLayout( Bool32 uniformBufferStandardLayout_ ) & + VULKAN_HPP_NOEXCEPT + { + uniformBufferStandardLayout = uniformBufferStandardLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUniformBufferStandardLayoutFeatures && setUniformBufferStandardLayout( Bool32 uniformBufferStandardLayout_ ) && + VULKAN_HPP_NOEXCEPT + { + uniformBufferStandardLayout = uniformBufferStandardLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, uniformBufferStandardLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceUniformBufferStandardLayoutFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ); +# endif + } + + bool operator!=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures; + void * pNext = {}; + Bool32 uniformBufferStandardLayout = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceUniformBufferStandardLayoutFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceUniformBufferStandardLayoutFeatures; + }; + + using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures; + + // wrapper struct for struct VkPhysicalDeviceVariablePointersFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVariablePointersFeatures.html + struct PhysicalDeviceVariablePointersFeatures + { + using NativeType = VkPhysicalDeviceVariablePointersFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVariablePointersFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( Bool32 variablePointersStorageBuffer_ = {}, + Bool32 variablePointers_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , variablePointersStorageBuffer{ variablePointersStorageBuffer_ } + , variablePointers{ variablePointers_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( PhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVariablePointersFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVariablePointersFeatures & operator=( PhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVariablePointersFeatures & operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures & setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) & + VULKAN_HPP_NOEXCEPT + { + variablePointersStorageBuffer = variablePointersStorageBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures && setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) && + VULKAN_HPP_NOEXCEPT + { + variablePointersStorageBuffer = variablePointersStorageBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures & setVariablePointers( Bool32 variablePointers_ ) & VULKAN_HPP_NOEXCEPT + { + variablePointers = variablePointers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures && setVariablePointers( Bool32 variablePointers_ ) && VULKAN_HPP_NOEXCEPT + { + variablePointers = variablePointers_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVariablePointersFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVariablePointersFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVariablePointersFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVariablePointersFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, variablePointersStorageBuffer, variablePointers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVariablePointersFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) && + ( variablePointers == rhs.variablePointers ); +# endif + } + + bool operator!=( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures; + void * pNext = {}; + Bool32 variablePointersStorageBuffer = {}; + Bool32 variablePointers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVariablePointersFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVariablePointersFeatures; + }; + + using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures; + using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures; + using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures; + + // wrapper struct for struct VkPhysicalDeviceVertexAttributeDivisorFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorFeatures.html + struct PhysicalDeviceVertexAttributeDivisorFeatures + { + using NativeType = VkPhysicalDeviceVertexAttributeDivisorFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeatures( Bool32 vertexAttributeInstanceRateDivisor_ = {}, + Bool32 vertexAttributeInstanceRateZeroDivisor_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vertexAttributeInstanceRateDivisor{ vertexAttributeInstanceRateDivisor_ } + , vertexAttributeInstanceRateZeroDivisor{ vertexAttributeInstanceRateZeroDivisor_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeatures( PhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVertexAttributeDivisorFeatures( VkPhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVertexAttributeDivisorFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVertexAttributeDivisorFeatures & operator=( PhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVertexAttributeDivisorFeatures & operator=( VkPhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures & setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures && + setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures & + setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures && + setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVertexAttributeDivisorFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeDivisorFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeDivisorFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeDivisorFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexAttributeInstanceRateDivisor, vertexAttributeInstanceRateZeroDivisor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVertexAttributeDivisorFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) && + ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor ); +# endif + } + + bool operator!=( PhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeatures; + void * pNext = {}; + Bool32 vertexAttributeInstanceRateDivisor = {}; + Bool32 vertexAttributeInstanceRateZeroDivisor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVertexAttributeDivisorFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVertexAttributeDivisorFeatures; + }; + + using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeatures; + using PhysicalDeviceVertexAttributeDivisorFeaturesKHR = PhysicalDeviceVertexAttributeDivisorFeatures; + + // wrapper struct for struct VkPhysicalDeviceVertexAttributeDivisorProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorProperties.html + struct PhysicalDeviceVertexAttributeDivisorProperties + { + using NativeType = VkPhysicalDeviceVertexAttributeDivisorProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeDivisorProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorProperties( uint32_t maxVertexAttribDivisor_ = {}, + Bool32 supportsNonZeroFirstInstance_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxVertexAttribDivisor{ maxVertexAttribDivisor_ } + , supportsNonZeroFirstInstance{ supportsNonZeroFirstInstance_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceVertexAttributeDivisorProperties( PhysicalDeviceVertexAttributeDivisorProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVertexAttributeDivisorProperties( VkPhysicalDeviceVertexAttributeDivisorProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVertexAttributeDivisorProperties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVertexAttributeDivisorProperties & operator=( PhysicalDeviceVertexAttributeDivisorProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVertexAttributeDivisorProperties & operator=( VkPhysicalDeviceVertexAttributeDivisorProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceVertexAttributeDivisorProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeDivisorProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeDivisorProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeDivisorProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxVertexAttribDivisor, supportsNonZeroFirstInstance ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVertexAttributeDivisorProperties const & ) const = default; +#else + bool operator==( PhysicalDeviceVertexAttributeDivisorProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ) && + ( supportsNonZeroFirstInstance == rhs.supportsNonZeroFirstInstance ); +# endif + } + + bool operator!=( PhysicalDeviceVertexAttributeDivisorProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorProperties; + void * pNext = {}; + uint32_t maxVertexAttribDivisor = {}; + Bool32 supportsNonZeroFirstInstance = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVertexAttributeDivisorProperties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVertexAttributeDivisorProperties; + }; + + using PhysicalDeviceVertexAttributeDivisorPropertiesKHR = PhysicalDeviceVertexAttributeDivisorProperties; + + // wrapper struct for struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html + struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT + { + using NativeType = VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxVertexAttribDivisor{ maxVertexAttribDivisor_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceVertexAttributeDivisorPropertiesEXT( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVertexAttributeDivisorPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVertexAttributeDivisorPropertiesEXT & + operator=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVertexAttributeDivisorPropertiesEXT & operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxVertexAttribDivisor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ); +# endif + } + + bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; + void * pNext = {}; + uint32_t maxVertexAttribDivisor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.html + struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT + { + using NativeType = VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeRobustnessFeaturesEXT( Bool32 vertexAttributeRobustness_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vertexAttributeRobustness{ vertexAttributeRobustness_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceVertexAttributeRobustnessFeaturesEXT( PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVertexAttributeRobustnessFeaturesEXT( VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVertexAttributeRobustnessFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVertexAttributeRobustnessFeaturesEXT & + operator=( PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVertexAttributeRobustnessFeaturesEXT & operator=( VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeRobustnessFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeRobustnessFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeRobustnessFeaturesEXT & setVertexAttributeRobustness( Bool32 vertexAttributeRobustness_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexAttributeRobustness = vertexAttributeRobustness_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeRobustnessFeaturesEXT && setVertexAttributeRobustness( Bool32 vertexAttributeRobustness_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexAttributeRobustness = vertexAttributeRobustness_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexAttributeRobustness ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexAttributeRobustness == rhs.vertexAttributeRobustness ); +# endif + } + + bool operator!=( PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT; + void * pNext = {}; + Bool32 vertexAttributeRobustness = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVertexAttributeRobustnessFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVertexAttributeRobustnessFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.html + struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT + { + using NativeType = VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexInputDynamicStateFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexInputDynamicStateFeaturesEXT( Bool32 vertexInputDynamicState_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vertexInputDynamicState{ vertexInputDynamicState_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceVertexInputDynamicStateFeaturesEXT( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVertexInputDynamicStateFeaturesEXT( VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVertexInputDynamicStateFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVertexInputDynamicStateFeaturesEXT & operator=( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVertexInputDynamicStateFeaturesEXT & operator=( VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexInputDynamicStateFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexInputDynamicStateFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexInputDynamicStateFeaturesEXT & setVertexInputDynamicState( Bool32 vertexInputDynamicState_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexInputDynamicState = vertexInputDynamicState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexInputDynamicStateFeaturesEXT && setVertexInputDynamicState( Bool32 vertexInputDynamicState_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexInputDynamicState = vertexInputDynamicState_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexInputDynamicState ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexInputDynamicState == rhs.vertexInputDynamicState ); +# endif + } + + bool operator!=( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVertexInputDynamicStateFeaturesEXT; + void * pNext = {}; + Bool32 vertexInputDynamicState = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVertexInputDynamicStateFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVertexInputDynamicStateFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoDecodeVP9FeaturesKHR.html + struct PhysicalDeviceVideoDecodeVP9FeaturesKHR + { + using NativeType = VkPhysicalDeviceVideoDecodeVP9FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoDecodeVp9FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoDecodeVP9FeaturesKHR( Bool32 videoDecodeVP9_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoDecodeVP9{ videoDecodeVP9_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoDecodeVP9FeaturesKHR( PhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVideoDecodeVP9FeaturesKHR( VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVideoDecodeVP9FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVideoDecodeVP9FeaturesKHR & operator=( PhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVideoDecodeVP9FeaturesKHR & operator=( VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoDecodeVP9FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoDecodeVP9FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoDecodeVP9FeaturesKHR & setVideoDecodeVP9( Bool32 videoDecodeVP9_ ) & VULKAN_HPP_NOEXCEPT + { + videoDecodeVP9 = videoDecodeVP9_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoDecodeVP9FeaturesKHR && setVideoDecodeVP9( Bool32 videoDecodeVP9_ ) && VULKAN_HPP_NOEXCEPT + { + videoDecodeVP9 = videoDecodeVP9_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoDecodeVP9FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoDecodeVP9 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVideoDecodeVP9FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoDecodeVP9 == rhs.videoDecodeVP9 ); +# endif + } + + bool operator!=( PhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVideoDecodeVp9FeaturesKHR; + void * pNext = {}; + Bool32 videoDecodeVP9 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVideoDecodeVP9FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVideoDecodeVP9FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.html + struct PhysicalDeviceVideoEncodeAV1FeaturesKHR + { + using NativeType = VkPhysicalDeviceVideoEncodeAV1FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeAv1FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeAV1FeaturesKHR( Bool32 videoEncodeAV1_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoEncodeAV1{ videoEncodeAV1_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeAV1FeaturesKHR( PhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVideoEncodeAV1FeaturesKHR( VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVideoEncodeAV1FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVideoEncodeAV1FeaturesKHR & operator=( PhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVideoEncodeAV1FeaturesKHR & operator=( VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeAV1FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeAV1FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeAV1FeaturesKHR & setVideoEncodeAV1( Bool32 videoEncodeAV1_ ) & VULKAN_HPP_NOEXCEPT + { + videoEncodeAV1 = videoEncodeAV1_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeAV1FeaturesKHR && setVideoEncodeAV1( Bool32 videoEncodeAV1_ ) && VULKAN_HPP_NOEXCEPT + { + videoEncodeAV1 = videoEncodeAV1_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeAV1FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoEncodeAV1 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVideoEncodeAV1FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoEncodeAV1 == rhs.videoEncodeAV1 ); +# endif + } + + bool operator!=( PhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVideoEncodeAv1FeaturesKHR; + void * pNext = {}; + Bool32 videoEncodeAV1 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVideoEncodeAV1FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVideoEncodeAV1FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR.html + struct PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR + { + using NativeType = VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR( Bool32 videoEncodeIntraRefresh_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoEncodeIntraRefresh{ videoEncodeIntraRefresh_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR( PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR( VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR & operator=( PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR & operator=( VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR & setVideoEncodeIntraRefresh( Bool32 videoEncodeIntraRefresh_ ) & + VULKAN_HPP_NOEXCEPT + { + videoEncodeIntraRefresh = videoEncodeIntraRefresh_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR && setVideoEncodeIntraRefresh( Bool32 videoEncodeIntraRefresh_ ) && + VULKAN_HPP_NOEXCEPT + { + videoEncodeIntraRefresh = videoEncodeIntraRefresh_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoEncodeIntraRefresh ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoEncodeIntraRefresh == rhs.videoEncodeIntraRefresh ); +# endif + } + + bool operator!=( PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; + void * pNext = {}; + Bool32 videoEncodeIntraRefresh = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; + }; + + // wrapper struct for struct VkVideoProfileInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoProfileInfoKHR.html + struct VideoProfileInfoKHR + { + using NativeType = VkVideoProfileInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoProfileInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR( VideoCodecOperationFlagBitsKHR videoCodecOperation_ = VideoCodecOperationFlagBitsKHR::eNone, + VideoChromaSubsamplingFlagsKHR chromaSubsampling_ = {}, + VideoComponentBitDepthFlagsKHR lumaBitDepth_ = {}, + VideoComponentBitDepthFlagsKHR chromaBitDepth_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoCodecOperation{ videoCodecOperation_ } + , chromaSubsampling{ chromaSubsampling_ } + , lumaBitDepth{ lumaBitDepth_ } + , chromaBitDepth{ chromaBitDepth_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoProfileInfoKHR( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoProfileInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoProfileInfoKHR & operator=( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoProfileInfoKHR & operator=( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setVideoCodecOperation( VideoCodecOperationFlagBitsKHR videoCodecOperation_ ) & VULKAN_HPP_NOEXCEPT + { + videoCodecOperation = videoCodecOperation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR && setVideoCodecOperation( VideoCodecOperationFlagBitsKHR videoCodecOperation_ ) && VULKAN_HPP_NOEXCEPT + { + videoCodecOperation = videoCodecOperation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setChromaSubsampling( VideoChromaSubsamplingFlagsKHR chromaSubsampling_ ) & VULKAN_HPP_NOEXCEPT + { + chromaSubsampling = chromaSubsampling_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR && setChromaSubsampling( VideoChromaSubsamplingFlagsKHR chromaSubsampling_ ) && VULKAN_HPP_NOEXCEPT + { + chromaSubsampling = chromaSubsampling_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setLumaBitDepth( VideoComponentBitDepthFlagsKHR lumaBitDepth_ ) & VULKAN_HPP_NOEXCEPT + { + lumaBitDepth = lumaBitDepth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR && setLumaBitDepth( VideoComponentBitDepthFlagsKHR lumaBitDepth_ ) && VULKAN_HPP_NOEXCEPT + { + lumaBitDepth = lumaBitDepth_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setChromaBitDepth( VideoComponentBitDepthFlagsKHR chromaBitDepth_ ) & VULKAN_HPP_NOEXCEPT + { + chromaBitDepth = chromaBitDepth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR && setChromaBitDepth( VideoComponentBitDepthFlagsKHR chromaBitDepth_ ) && VULKAN_HPP_NOEXCEPT + { + chromaBitDepth = chromaBitDepth_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoProfileInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoProfileInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoProfileInfoKHR const & ) const = default; +#else + bool operator==( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) && + ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) && ( chromaBitDepth == rhs.chromaBitDepth ); +# endif + } + + bool operator!=( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoProfileInfoKHR; + const void * pNext = {}; + VideoCodecOperationFlagBitsKHR videoCodecOperation = VideoCodecOperationFlagBitsKHR::eNone; + VideoChromaSubsamplingFlagsKHR chromaSubsampling = {}; + VideoComponentBitDepthFlagsKHR lumaBitDepth = {}; + VideoComponentBitDepthFlagsKHR chromaBitDepth = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoProfileInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoProfileInfoKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR.html + struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR + { + using NativeType = VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeQualityLevelInfoKHR( const VideoProfileInfoKHR * pVideoProfile_ = {}, + uint32_t qualityLevel_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pVideoProfile{ pVideoProfile_ } + , qualityLevel{ qualityLevel_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeQualityLevelInfoKHR( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVideoEncodeQualityLevelInfoKHR( VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVideoEncodeQualityLevelInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVideoEncodeQualityLevelInfoKHR & operator=( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVideoEncodeQualityLevelInfoKHR & operator=( VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR & setPVideoProfile( const VideoProfileInfoKHR * pVideoProfile_ ) & VULKAN_HPP_NOEXCEPT + { + pVideoProfile = pVideoProfile_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR && setPVideoProfile( const VideoProfileInfoKHR * pVideoProfile_ ) && + VULKAN_HPP_NOEXCEPT + { + pVideoProfile = pVideoProfile_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR & setQualityLevel( uint32_t qualityLevel_ ) & VULKAN_HPP_NOEXCEPT + { + qualityLevel = qualityLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR && setQualityLevel( uint32_t qualityLevel_ ) && VULKAN_HPP_NOEXCEPT + { + qualityLevel = qualityLevel_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pVideoProfile, qualityLevel ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVideoProfile == rhs.pVideoProfile ) && ( qualityLevel == rhs.qualityLevel ); +# endif + } + + bool operator!=( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR; + const void * pNext = {}; + const VideoProfileInfoKHR * pVideoProfile = {}; + uint32_t qualityLevel = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVideoEncodeQualityLevelInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVideoEncodeQualityLevelInfoKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.html + struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR + { + using NativeType = VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR( Bool32 videoEncodeQuantizationMap_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoEncodeQuantizationMap{ videoEncodeQuantizationMap_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR( PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR( VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR & + operator=( PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR & operator=( VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR & setVideoEncodeQuantizationMap( Bool32 videoEncodeQuantizationMap_ ) & + VULKAN_HPP_NOEXCEPT + { + videoEncodeQuantizationMap = videoEncodeQuantizationMap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR && setVideoEncodeQuantizationMap( Bool32 videoEncodeQuantizationMap_ ) && + VULKAN_HPP_NOEXCEPT + { + videoEncodeQuantizationMap = videoEncodeQuantizationMap_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoEncodeQuantizationMap ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoEncodeQuantizationMap == rhs.videoEncodeQuantizationMap ); +# endif + } + + bool operator!=( PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; + void * pNext = {}; + Bool32 videoEncodeQuantizationMap = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE.html + struct PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE + { + using NativeType = VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( Bool32 videoEncodeRgbConversion_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoEncodeRgbConversion{ videoEncodeRgbConversion_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE & + operator=( PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE & operator=( VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE & setVideoEncodeRgbConversion( Bool32 videoEncodeRgbConversion_ ) & + VULKAN_HPP_NOEXCEPT + { + videoEncodeRgbConversion = videoEncodeRgbConversion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE && setVideoEncodeRgbConversion( Bool32 videoEncodeRgbConversion_ ) && + VULKAN_HPP_NOEXCEPT + { + videoEncodeRgbConversion = videoEncodeRgbConversion_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoEncodeRgbConversion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & ) const = default; +#else + bool operator==( PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoEncodeRgbConversion == rhs.videoEncodeRgbConversion ); +# endif + } + + bool operator!=( PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; + void * pNext = {}; + Bool32 videoEncodeRgbConversion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; + }; + + // wrapper struct for struct VkPhysicalDeviceVideoFormatInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoFormatInfoKHR.html + struct PhysicalDeviceVideoFormatInfoKHR + { + using NativeType = VkPhysicalDeviceVideoFormatInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoFormatInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoFormatInfoKHR( ImageUsageFlags imageUsage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageUsage{ imageUsage_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoFormatInfoKHR( PhysicalDeviceVideoFormatInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVideoFormatInfoKHR( VkPhysicalDeviceVideoFormatInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVideoFormatInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVideoFormatInfoKHR & operator=( PhysicalDeviceVideoFormatInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVideoFormatInfoKHR & operator=( VkPhysicalDeviceVideoFormatInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoFormatInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoFormatInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoFormatInfoKHR & setImageUsage( ImageUsageFlags imageUsage_ ) & VULKAN_HPP_NOEXCEPT + { + imageUsage = imageUsage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoFormatInfoKHR && setImageUsage( ImageUsageFlags imageUsage_ ) && VULKAN_HPP_NOEXCEPT + { + imageUsage = imageUsage_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVideoFormatInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoFormatInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoFormatInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoFormatInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageUsage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVideoFormatInfoKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageUsage == rhs.imageUsage ); +# endif + } + + bool operator!=( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVideoFormatInfoKHR; + const void * pNext = {}; + ImageUsageFlags imageUsage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVideoFormatInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVideoFormatInfoKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoMaintenance1FeaturesKHR.html + struct PhysicalDeviceVideoMaintenance1FeaturesKHR + { + using NativeType = VkPhysicalDeviceVideoMaintenance1FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoMaintenance1FeaturesKHR( Bool32 videoMaintenance1_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoMaintenance1{ videoMaintenance1_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoMaintenance1FeaturesKHR( PhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVideoMaintenance1FeaturesKHR( VkPhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVideoMaintenance1FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVideoMaintenance1FeaturesKHR & operator=( PhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVideoMaintenance1FeaturesKHR & operator=( VkPhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance1FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance1FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance1FeaturesKHR & setVideoMaintenance1( Bool32 videoMaintenance1_ ) & VULKAN_HPP_NOEXCEPT + { + videoMaintenance1 = videoMaintenance1_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance1FeaturesKHR && setVideoMaintenance1( Bool32 videoMaintenance1_ ) && VULKAN_HPP_NOEXCEPT + { + videoMaintenance1 = videoMaintenance1_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVideoMaintenance1FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoMaintenance1FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoMaintenance1FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoMaintenance1FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoMaintenance1 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVideoMaintenance1FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoMaintenance1 == rhs.videoMaintenance1 ); +# endif + } + + bool operator!=( PhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR; + void * pNext = {}; + Bool32 videoMaintenance1 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVideoMaintenance1FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVideoMaintenance1FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoMaintenance2FeaturesKHR.html + struct PhysicalDeviceVideoMaintenance2FeaturesKHR + { + using NativeType = VkPhysicalDeviceVideoMaintenance2FeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoMaintenance2FeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoMaintenance2FeaturesKHR( Bool32 videoMaintenance2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoMaintenance2{ videoMaintenance2_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoMaintenance2FeaturesKHR( PhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVideoMaintenance2FeaturesKHR( VkPhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVideoMaintenance2FeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVideoMaintenance2FeaturesKHR & operator=( PhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVideoMaintenance2FeaturesKHR & operator=( VkPhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance2FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance2FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance2FeaturesKHR & setVideoMaintenance2( Bool32 videoMaintenance2_ ) & VULKAN_HPP_NOEXCEPT + { + videoMaintenance2 = videoMaintenance2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance2FeaturesKHR && setVideoMaintenance2( Bool32 videoMaintenance2_ ) && VULKAN_HPP_NOEXCEPT + { + videoMaintenance2 = videoMaintenance2_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVideoMaintenance2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoMaintenance2FeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoMaintenance2FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVideoMaintenance2FeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoMaintenance2 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVideoMaintenance2FeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoMaintenance2 == rhs.videoMaintenance2 ); +# endif + } + + bool operator!=( PhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVideoMaintenance2FeaturesKHR; + void * pNext = {}; + Bool32 videoMaintenance2 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVideoMaintenance2FeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVideoMaintenance2FeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceVulkan11Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan11Features.html + struct PhysicalDeviceVulkan11Features + { + using NativeType = VkPhysicalDeviceVulkan11Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan11Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan11Features( Bool32 storageBuffer16BitAccess_ = {}, + Bool32 uniformAndStorageBuffer16BitAccess_ = {}, + Bool32 storagePushConstant16_ = {}, + Bool32 storageInputOutput16_ = {}, + Bool32 multiview_ = {}, + Bool32 multiviewGeometryShader_ = {}, + Bool32 multiviewTessellationShader_ = {}, + Bool32 variablePointersStorageBuffer_ = {}, + Bool32 variablePointers_ = {}, + Bool32 protectedMemory_ = {}, + Bool32 samplerYcbcrConversion_ = {}, + Bool32 shaderDrawParameters_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , storageBuffer16BitAccess{ storageBuffer16BitAccess_ } + , uniformAndStorageBuffer16BitAccess{ uniformAndStorageBuffer16BitAccess_ } + , storagePushConstant16{ storagePushConstant16_ } + , storageInputOutput16{ storageInputOutput16_ } + , multiview{ multiview_ } + , multiviewGeometryShader{ multiviewGeometryShader_ } + , multiviewTessellationShader{ multiviewTessellationShader_ } + , variablePointersStorageBuffer{ variablePointersStorageBuffer_ } + , variablePointers{ variablePointers_ } + , protectedMemory{ protectedMemory_ } + , samplerYcbcrConversion{ samplerYcbcrConversion_ } + , shaderDrawParameters{ shaderDrawParameters_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan11Features( PhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVulkan11Features( VkPhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVulkan11Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVulkan11Features & operator=( PhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVulkan11Features & operator=( VkPhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) & VULKAN_HPP_NOEXCEPT + { + storageBuffer16BitAccess = storageBuffer16BitAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) && VULKAN_HPP_NOEXCEPT + { + storageBuffer16BitAccess = storageBuffer16BitAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setStoragePushConstant16( Bool32 storagePushConstant16_ ) & VULKAN_HPP_NOEXCEPT + { + storagePushConstant16 = storagePushConstant16_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setStoragePushConstant16( Bool32 storagePushConstant16_ ) && VULKAN_HPP_NOEXCEPT + { + storagePushConstant16 = storagePushConstant16_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setStorageInputOutput16( Bool32 storageInputOutput16_ ) & VULKAN_HPP_NOEXCEPT + { + storageInputOutput16 = storageInputOutput16_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setStorageInputOutput16( Bool32 storageInputOutput16_ ) && VULKAN_HPP_NOEXCEPT + { + storageInputOutput16 = storageInputOutput16_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setMultiview( Bool32 multiview_ ) & VULKAN_HPP_NOEXCEPT + { + multiview = multiview_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setMultiview( Bool32 multiview_ ) && VULKAN_HPP_NOEXCEPT + { + multiview = multiview_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ ) & VULKAN_HPP_NOEXCEPT + { + multiviewGeometryShader = multiviewGeometryShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ ) && VULKAN_HPP_NOEXCEPT + { + multiviewGeometryShader = multiviewGeometryShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ ) & VULKAN_HPP_NOEXCEPT + { + multiviewTessellationShader = multiviewTessellationShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ ) && VULKAN_HPP_NOEXCEPT + { + multiviewTessellationShader = multiviewTessellationShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + variablePointersStorageBuffer = variablePointersStorageBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + variablePointersStorageBuffer = variablePointersStorageBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setVariablePointers( Bool32 variablePointers_ ) & VULKAN_HPP_NOEXCEPT + { + variablePointers = variablePointers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setVariablePointers( Bool32 variablePointers_ ) && VULKAN_HPP_NOEXCEPT + { + variablePointers = variablePointers_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setProtectedMemory( Bool32 protectedMemory_ ) & VULKAN_HPP_NOEXCEPT + { + protectedMemory = protectedMemory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setProtectedMemory( Bool32 protectedMemory_ ) && VULKAN_HPP_NOEXCEPT + { + protectedMemory = protectedMemory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ ) & VULKAN_HPP_NOEXCEPT + { + samplerYcbcrConversion = samplerYcbcrConversion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ ) && VULKAN_HPP_NOEXCEPT + { + samplerYcbcrConversion = samplerYcbcrConversion_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setShaderDrawParameters( Bool32 shaderDrawParameters_ ) & VULKAN_HPP_NOEXCEPT + { + shaderDrawParameters = shaderDrawParameters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setShaderDrawParameters( Bool32 shaderDrawParameters_ ) && VULKAN_HPP_NOEXCEPT + { + shaderDrawParameters = shaderDrawParameters_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVulkan11Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan11Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan11Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan11Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + storageBuffer16BitAccess, + uniformAndStorageBuffer16BitAccess, + storagePushConstant16, + storageInputOutput16, + multiview, + multiviewGeometryShader, + multiviewTessellationShader, + variablePointersStorageBuffer, + variablePointers, + protectedMemory, + samplerYcbcrConversion, + shaderDrawParameters ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVulkan11Features const & ) const = default; +#else + bool operator==( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) && + ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) && ( storagePushConstant16 == rhs.storagePushConstant16 ) && + ( storageInputOutput16 == rhs.storageInputOutput16 ) && ( multiview == rhs.multiview ) && + ( multiviewGeometryShader == rhs.multiviewGeometryShader ) && ( multiviewTessellationShader == rhs.multiviewTessellationShader ) && + ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) && ( variablePointers == rhs.variablePointers ) && + ( protectedMemory == rhs.protectedMemory ) && ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ) && + ( shaderDrawParameters == rhs.shaderDrawParameters ); +# endif + } + + bool operator!=( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVulkan11Features; + void * pNext = {}; + Bool32 storageBuffer16BitAccess = {}; + Bool32 uniformAndStorageBuffer16BitAccess = {}; + Bool32 storagePushConstant16 = {}; + Bool32 storageInputOutput16 = {}; + Bool32 multiview = {}; + Bool32 multiviewGeometryShader = {}; + Bool32 multiviewTessellationShader = {}; + Bool32 variablePointersStorageBuffer = {}; + Bool32 variablePointers = {}; + Bool32 protectedMemory = {}; + Bool32 samplerYcbcrConversion = {}; + Bool32 shaderDrawParameters = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan11Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan11Features; + }; + + // wrapper struct for struct VkPhysicalDeviceVulkan11Properties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan11Properties.html + struct PhysicalDeviceVulkan11Properties + { + using NativeType = VkPhysicalDeviceVulkan11Properties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan11Properties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Properties( std::array const & deviceUUID_ = {}, + std::array const & driverUUID_ = {}, + std::array const & deviceLUID_ = {}, + uint32_t deviceNodeMask_ = {}, + Bool32 deviceLUIDValid_ = {}, + uint32_t subgroupSize_ = {}, + ShaderStageFlags subgroupSupportedStages_ = {}, + SubgroupFeatureFlags subgroupSupportedOperations_ = {}, + Bool32 subgroupQuadOperationsInAllStages_ = {}, + PointClippingBehavior pointClippingBehavior_ = PointClippingBehavior::eAllClipPlanes, + uint32_t maxMultiviewViewCount_ = {}, + uint32_t maxMultiviewInstanceIndex_ = {}, + Bool32 protectedNoFault_ = {}, + uint32_t maxPerSetDescriptors_ = {}, + DeviceSize maxMemoryAllocationSize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceUUID{ deviceUUID_ } + , driverUUID{ driverUUID_ } + , deviceLUID{ deviceLUID_ } + , deviceNodeMask{ deviceNodeMask_ } + , deviceLUIDValid{ deviceLUIDValid_ } + , subgroupSize{ subgroupSize_ } + , subgroupSupportedStages{ subgroupSupportedStages_ } + , subgroupSupportedOperations{ subgroupSupportedOperations_ } + , subgroupQuadOperationsInAllStages{ subgroupQuadOperationsInAllStages_ } + , pointClippingBehavior{ pointClippingBehavior_ } + , maxMultiviewViewCount{ maxMultiviewViewCount_ } + , maxMultiviewInstanceIndex{ maxMultiviewInstanceIndex_ } + , protectedNoFault{ protectedNoFault_ } + , maxPerSetDescriptors{ maxPerSetDescriptors_ } + , maxMemoryAllocationSize{ maxMemoryAllocationSize_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Properties( PhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVulkan11Properties( VkPhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVulkan11Properties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVulkan11Properties & operator=( PhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVulkan11Properties & operator=( VkPhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceVulkan11Properties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan11Properties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan11Properties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan11Properties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &, + ArrayWrapper1D const &, + uint32_t const &, + Bool32 const &, + uint32_t const &, + ShaderStageFlags const &, + SubgroupFeatureFlags const &, + Bool32 const &, + PointClippingBehavior const &, + uint32_t const &, + uint32_t const &, + Bool32 const &, + uint32_t const &, + DeviceSize const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + deviceUUID, + driverUUID, + deviceLUID, + deviceNodeMask, + deviceLUIDValid, + subgroupSize, + subgroupSupportedStages, + subgroupSupportedOperations, + subgroupQuadOperationsInAllStages, + pointClippingBehavior, + maxMultiviewViewCount, + maxMultiviewInstanceIndex, + protectedNoFault, + maxPerSetDescriptors, + maxMemoryAllocationSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVulkan11Properties const & ) const = default; +#else + bool operator==( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) && ( driverUUID == rhs.driverUUID ) && + ( deviceLUID == rhs.deviceLUID ) && ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ) && + ( subgroupSize == rhs.subgroupSize ) && ( subgroupSupportedStages == rhs.subgroupSupportedStages ) && + ( subgroupSupportedOperations == rhs.subgroupSupportedOperations ) && + ( subgroupQuadOperationsInAllStages == rhs.subgroupQuadOperationsInAllStages ) && ( pointClippingBehavior == rhs.pointClippingBehavior ) && + ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) && ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ) && + ( protectedNoFault == rhs.protectedNoFault ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) && + ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize ); +# endif + } + + bool operator!=( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVulkan11Properties; + void * pNext = {}; + ArrayWrapper1D deviceUUID = {}; + ArrayWrapper1D driverUUID = {}; + ArrayWrapper1D deviceLUID = {}; + uint32_t deviceNodeMask = {}; + Bool32 deviceLUIDValid = {}; + uint32_t subgroupSize = {}; + ShaderStageFlags subgroupSupportedStages = {}; + SubgroupFeatureFlags subgroupSupportedOperations = {}; + Bool32 subgroupQuadOperationsInAllStages = {}; + PointClippingBehavior pointClippingBehavior = PointClippingBehavior::eAllClipPlanes; + uint32_t maxMultiviewViewCount = {}; + uint32_t maxMultiviewInstanceIndex = {}; + Bool32 protectedNoFault = {}; + uint32_t maxPerSetDescriptors = {}; + DeviceSize maxMemoryAllocationSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan11Properties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan11Properties; + }; + + // wrapper struct for struct VkPhysicalDeviceVulkan12Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan12Features.html + struct PhysicalDeviceVulkan12Features + { + using NativeType = VkPhysicalDeviceVulkan12Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan12Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan12Features( Bool32 samplerMirrorClampToEdge_ = {}, + Bool32 drawIndirectCount_ = {}, + Bool32 storageBuffer8BitAccess_ = {}, + Bool32 uniformAndStorageBuffer8BitAccess_ = {}, + Bool32 storagePushConstant8_ = {}, + Bool32 shaderBufferInt64Atomics_ = {}, + Bool32 shaderSharedInt64Atomics_ = {}, + Bool32 shaderFloat16_ = {}, + Bool32 shaderInt8_ = {}, + Bool32 descriptorIndexing_ = {}, + Bool32 shaderInputAttachmentArrayDynamicIndexing_ = {}, + Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = {}, + Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = {}, + Bool32 shaderUniformBufferArrayNonUniformIndexing_ = {}, + Bool32 shaderSampledImageArrayNonUniformIndexing_ = {}, + Bool32 shaderStorageBufferArrayNonUniformIndexing_ = {}, + Bool32 shaderStorageImageArrayNonUniformIndexing_ = {}, + Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = {}, + Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = {}, + Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = {}, + Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = {}, + Bool32 descriptorBindingSampledImageUpdateAfterBind_ = {}, + Bool32 descriptorBindingStorageImageUpdateAfterBind_ = {}, + Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = {}, + Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = {}, + Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = {}, + Bool32 descriptorBindingUpdateUnusedWhilePending_ = {}, + Bool32 descriptorBindingPartiallyBound_ = {}, + Bool32 descriptorBindingVariableDescriptorCount_ = {}, + Bool32 runtimeDescriptorArray_ = {}, + Bool32 samplerFilterMinmax_ = {}, + Bool32 scalarBlockLayout_ = {}, + Bool32 imagelessFramebuffer_ = {}, + Bool32 uniformBufferStandardLayout_ = {}, + Bool32 shaderSubgroupExtendedTypes_ = {}, + Bool32 separateDepthStencilLayouts_ = {}, + Bool32 hostQueryReset_ = {}, + Bool32 timelineSemaphore_ = {}, + Bool32 bufferDeviceAddress_ = {}, + Bool32 bufferDeviceAddressCaptureReplay_ = {}, + Bool32 bufferDeviceAddressMultiDevice_ = {}, + Bool32 vulkanMemoryModel_ = {}, + Bool32 vulkanMemoryModelDeviceScope_ = {}, + Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = {}, + Bool32 shaderOutputViewportIndex_ = {}, + Bool32 shaderOutputLayer_ = {}, + Bool32 subgroupBroadcastDynamicId_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , samplerMirrorClampToEdge{ samplerMirrorClampToEdge_ } + , drawIndirectCount{ drawIndirectCount_ } + , storageBuffer8BitAccess{ storageBuffer8BitAccess_ } + , uniformAndStorageBuffer8BitAccess{ uniformAndStorageBuffer8BitAccess_ } + , storagePushConstant8{ storagePushConstant8_ } + , shaderBufferInt64Atomics{ shaderBufferInt64Atomics_ } + , shaderSharedInt64Atomics{ shaderSharedInt64Atomics_ } + , shaderFloat16{ shaderFloat16_ } + , shaderInt8{ shaderInt8_ } + , descriptorIndexing{ descriptorIndexing_ } + , shaderInputAttachmentArrayDynamicIndexing{ shaderInputAttachmentArrayDynamicIndexing_ } + , shaderUniformTexelBufferArrayDynamicIndexing{ shaderUniformTexelBufferArrayDynamicIndexing_ } + , shaderStorageTexelBufferArrayDynamicIndexing{ shaderStorageTexelBufferArrayDynamicIndexing_ } + , shaderUniformBufferArrayNonUniformIndexing{ shaderUniformBufferArrayNonUniformIndexing_ } + , shaderSampledImageArrayNonUniformIndexing{ shaderSampledImageArrayNonUniformIndexing_ } + , shaderStorageBufferArrayNonUniformIndexing{ shaderStorageBufferArrayNonUniformIndexing_ } + , shaderStorageImageArrayNonUniformIndexing{ shaderStorageImageArrayNonUniformIndexing_ } + , shaderInputAttachmentArrayNonUniformIndexing{ shaderInputAttachmentArrayNonUniformIndexing_ } + , shaderUniformTexelBufferArrayNonUniformIndexing{ shaderUniformTexelBufferArrayNonUniformIndexing_ } + , shaderStorageTexelBufferArrayNonUniformIndexing{ shaderStorageTexelBufferArrayNonUniformIndexing_ } + , descriptorBindingUniformBufferUpdateAfterBind{ descriptorBindingUniformBufferUpdateAfterBind_ } + , descriptorBindingSampledImageUpdateAfterBind{ descriptorBindingSampledImageUpdateAfterBind_ } + , descriptorBindingStorageImageUpdateAfterBind{ descriptorBindingStorageImageUpdateAfterBind_ } + , descriptorBindingStorageBufferUpdateAfterBind{ descriptorBindingStorageBufferUpdateAfterBind_ } + , descriptorBindingUniformTexelBufferUpdateAfterBind{ descriptorBindingUniformTexelBufferUpdateAfterBind_ } + , descriptorBindingStorageTexelBufferUpdateAfterBind{ descriptorBindingStorageTexelBufferUpdateAfterBind_ } + , descriptorBindingUpdateUnusedWhilePending{ descriptorBindingUpdateUnusedWhilePending_ } + , descriptorBindingPartiallyBound{ descriptorBindingPartiallyBound_ } + , descriptorBindingVariableDescriptorCount{ descriptorBindingVariableDescriptorCount_ } + , runtimeDescriptorArray{ runtimeDescriptorArray_ } + , samplerFilterMinmax{ samplerFilterMinmax_ } + , scalarBlockLayout{ scalarBlockLayout_ } + , imagelessFramebuffer{ imagelessFramebuffer_ } + , uniformBufferStandardLayout{ uniformBufferStandardLayout_ } + , shaderSubgroupExtendedTypes{ shaderSubgroupExtendedTypes_ } + , separateDepthStencilLayouts{ separateDepthStencilLayouts_ } + , hostQueryReset{ hostQueryReset_ } + , timelineSemaphore{ timelineSemaphore_ } + , bufferDeviceAddress{ bufferDeviceAddress_ } + , bufferDeviceAddressCaptureReplay{ bufferDeviceAddressCaptureReplay_ } + , bufferDeviceAddressMultiDevice{ bufferDeviceAddressMultiDevice_ } + , vulkanMemoryModel{ vulkanMemoryModel_ } + , vulkanMemoryModelDeviceScope{ vulkanMemoryModelDeviceScope_ } + , vulkanMemoryModelAvailabilityVisibilityChains{ vulkanMemoryModelAvailabilityVisibilityChains_ } + , shaderOutputViewportIndex{ shaderOutputViewportIndex_ } + , shaderOutputLayer{ shaderOutputLayer_ } + , subgroupBroadcastDynamicId{ subgroupBroadcastDynamicId_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan12Features( PhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVulkan12Features( VkPhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVulkan12Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVulkan12Features & operator=( PhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVulkan12Features & operator=( VkPhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setSamplerMirrorClampToEdge( Bool32 samplerMirrorClampToEdge_ ) & VULKAN_HPP_NOEXCEPT + { + samplerMirrorClampToEdge = samplerMirrorClampToEdge_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setSamplerMirrorClampToEdge( Bool32 samplerMirrorClampToEdge_ ) && VULKAN_HPP_NOEXCEPT + { + samplerMirrorClampToEdge = samplerMirrorClampToEdge_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setDrawIndirectCount( Bool32 drawIndirectCount_ ) & VULKAN_HPP_NOEXCEPT + { + drawIndirectCount = drawIndirectCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setDrawIndirectCount( Bool32 drawIndirectCount_ ) && VULKAN_HPP_NOEXCEPT + { + drawIndirectCount = drawIndirectCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ ) & VULKAN_HPP_NOEXCEPT + { + storageBuffer8BitAccess = storageBuffer8BitAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ ) && VULKAN_HPP_NOEXCEPT + { + storageBuffer8BitAccess = storageBuffer8BitAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setStoragePushConstant8( Bool32 storagePushConstant8_ ) & VULKAN_HPP_NOEXCEPT + { + storagePushConstant8 = storagePushConstant8_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setStoragePushConstant8( Bool32 storagePushConstant8_ ) && VULKAN_HPP_NOEXCEPT + { + storagePushConstant8 = storagePushConstant8_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ ) & VULKAN_HPP_NOEXCEPT + { + shaderBufferInt64Atomics = shaderBufferInt64Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ ) && VULKAN_HPP_NOEXCEPT + { + shaderBufferInt64Atomics = shaderBufferInt64Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ ) & VULKAN_HPP_NOEXCEPT + { + shaderSharedInt64Atomics = shaderSharedInt64Atomics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ ) && VULKAN_HPP_NOEXCEPT + { + shaderSharedInt64Atomics = shaderSharedInt64Atomics_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderFloat16( Bool32 shaderFloat16_ ) & VULKAN_HPP_NOEXCEPT + { + shaderFloat16 = shaderFloat16_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderFloat16( Bool32 shaderFloat16_ ) && VULKAN_HPP_NOEXCEPT + { + shaderFloat16 = shaderFloat16_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderInt8( Bool32 shaderInt8_ ) & VULKAN_HPP_NOEXCEPT + { + shaderInt8 = shaderInt8_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderInt8( Bool32 shaderInt8_ ) && VULKAN_HPP_NOEXCEPT + { + shaderInt8 = shaderInt8_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setDescriptorIndexing( Bool32 descriptorIndexing_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorIndexing = descriptorIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setDescriptorIndexing( Bool32 descriptorIndexing_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorIndexing = descriptorIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ ) & VULKAN_HPP_NOEXCEPT + { + runtimeDescriptorArray = runtimeDescriptorArray_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ ) && VULKAN_HPP_NOEXCEPT + { + runtimeDescriptorArray = runtimeDescriptorArray_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setSamplerFilterMinmax( Bool32 samplerFilterMinmax_ ) & VULKAN_HPP_NOEXCEPT + { + samplerFilterMinmax = samplerFilterMinmax_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setSamplerFilterMinmax( Bool32 samplerFilterMinmax_ ) && VULKAN_HPP_NOEXCEPT + { + samplerFilterMinmax = samplerFilterMinmax_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setScalarBlockLayout( Bool32 scalarBlockLayout_ ) & VULKAN_HPP_NOEXCEPT + { + scalarBlockLayout = scalarBlockLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setScalarBlockLayout( Bool32 scalarBlockLayout_ ) && VULKAN_HPP_NOEXCEPT + { + scalarBlockLayout = scalarBlockLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setImagelessFramebuffer( Bool32 imagelessFramebuffer_ ) & VULKAN_HPP_NOEXCEPT + { + imagelessFramebuffer = imagelessFramebuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setImagelessFramebuffer( Bool32 imagelessFramebuffer_ ) && VULKAN_HPP_NOEXCEPT + { + imagelessFramebuffer = imagelessFramebuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setUniformBufferStandardLayout( Bool32 uniformBufferStandardLayout_ ) & VULKAN_HPP_NOEXCEPT + { + uniformBufferStandardLayout = uniformBufferStandardLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setUniformBufferStandardLayout( Bool32 uniformBufferStandardLayout_ ) && VULKAN_HPP_NOEXCEPT + { + uniformBufferStandardLayout = uniformBufferStandardLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderSubgroupExtendedTypes( Bool32 shaderSubgroupExtendedTypes_ ) & VULKAN_HPP_NOEXCEPT + { + shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderSubgroupExtendedTypes( Bool32 shaderSubgroupExtendedTypes_ ) && VULKAN_HPP_NOEXCEPT + { + shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setSeparateDepthStencilLayouts( Bool32 separateDepthStencilLayouts_ ) & VULKAN_HPP_NOEXCEPT + { + separateDepthStencilLayouts = separateDepthStencilLayouts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setSeparateDepthStencilLayouts( Bool32 separateDepthStencilLayouts_ ) && VULKAN_HPP_NOEXCEPT + { + separateDepthStencilLayouts = separateDepthStencilLayouts_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setHostQueryReset( Bool32 hostQueryReset_ ) & VULKAN_HPP_NOEXCEPT + { + hostQueryReset = hostQueryReset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setHostQueryReset( Bool32 hostQueryReset_ ) && VULKAN_HPP_NOEXCEPT + { + hostQueryReset = hostQueryReset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setTimelineSemaphore( Bool32 timelineSemaphore_ ) & VULKAN_HPP_NOEXCEPT + { + timelineSemaphore = timelineSemaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setTimelineSemaphore( Bool32 timelineSemaphore_ ) && VULKAN_HPP_NOEXCEPT + { + timelineSemaphore = timelineSemaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) & VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddress = bufferDeviceAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) && VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddress = bufferDeviceAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) & + VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) && + VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) & VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) && VULKAN_HPP_NOEXCEPT + { + bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setVulkanMemoryModel( Bool32 vulkanMemoryModel_ ) & VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModel = vulkanMemoryModel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setVulkanMemoryModel( Bool32 vulkanMemoryModel_ ) && VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModel = vulkanMemoryModel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setVulkanMemoryModelDeviceScope( Bool32 vulkanMemoryModelDeviceScope_ ) & VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setVulkanMemoryModelDeviceScope( Bool32 vulkanMemoryModelDeviceScope_ ) && VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & + setVulkanMemoryModelAvailabilityVisibilityChains( Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ ) & + VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && + setVulkanMemoryModelAvailabilityVisibilityChains( Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ ) && + VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderOutputViewportIndex( Bool32 shaderOutputViewportIndex_ ) & VULKAN_HPP_NOEXCEPT + { + shaderOutputViewportIndex = shaderOutputViewportIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderOutputViewportIndex( Bool32 shaderOutputViewportIndex_ ) && VULKAN_HPP_NOEXCEPT + { + shaderOutputViewportIndex = shaderOutputViewportIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderOutputLayer( Bool32 shaderOutputLayer_ ) & VULKAN_HPP_NOEXCEPT + { + shaderOutputLayer = shaderOutputLayer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderOutputLayer( Bool32 shaderOutputLayer_ ) && VULKAN_HPP_NOEXCEPT + { + shaderOutputLayer = shaderOutputLayer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setSubgroupBroadcastDynamicId( Bool32 subgroupBroadcastDynamicId_ ) & VULKAN_HPP_NOEXCEPT + { + subgroupBroadcastDynamicId = subgroupBroadcastDynamicId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setSubgroupBroadcastDynamicId( Bool32 subgroupBroadcastDynamicId_ ) && VULKAN_HPP_NOEXCEPT + { + subgroupBroadcastDynamicId = subgroupBroadcastDynamicId_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVulkan12Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan12Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan12Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan12Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + samplerMirrorClampToEdge, + drawIndirectCount, + storageBuffer8BitAccess, + uniformAndStorageBuffer8BitAccess, + storagePushConstant8, + shaderBufferInt64Atomics, + shaderSharedInt64Atomics, + shaderFloat16, + shaderInt8, + descriptorIndexing, + shaderInputAttachmentArrayDynamicIndexing, + shaderUniformTexelBufferArrayDynamicIndexing, + shaderStorageTexelBufferArrayDynamicIndexing, + shaderUniformBufferArrayNonUniformIndexing, + shaderSampledImageArrayNonUniformIndexing, + shaderStorageBufferArrayNonUniformIndexing, + shaderStorageImageArrayNonUniformIndexing, + shaderInputAttachmentArrayNonUniformIndexing, + shaderUniformTexelBufferArrayNonUniformIndexing, + shaderStorageTexelBufferArrayNonUniformIndexing, + descriptorBindingUniformBufferUpdateAfterBind, + descriptorBindingSampledImageUpdateAfterBind, + descriptorBindingStorageImageUpdateAfterBind, + descriptorBindingStorageBufferUpdateAfterBind, + descriptorBindingUniformTexelBufferUpdateAfterBind, + descriptorBindingStorageTexelBufferUpdateAfterBind, + descriptorBindingUpdateUnusedWhilePending, + descriptorBindingPartiallyBound, + descriptorBindingVariableDescriptorCount, + runtimeDescriptorArray, + samplerFilterMinmax, + scalarBlockLayout, + imagelessFramebuffer, + uniformBufferStandardLayout, + shaderSubgroupExtendedTypes, + separateDepthStencilLayouts, + hostQueryReset, + timelineSemaphore, + bufferDeviceAddress, + bufferDeviceAddressCaptureReplay, + bufferDeviceAddressMultiDevice, + vulkanMemoryModel, + vulkanMemoryModelDeviceScope, + vulkanMemoryModelAvailabilityVisibilityChains, + shaderOutputViewportIndex, + shaderOutputLayer, + subgroupBroadcastDynamicId ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVulkan12Features const & ) const = default; +#else + bool operator==( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( samplerMirrorClampToEdge == rhs.samplerMirrorClampToEdge ) && + ( drawIndirectCount == rhs.drawIndirectCount ) && ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) && + ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) && ( storagePushConstant8 == rhs.storagePushConstant8 ) && + ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) && ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ) && + ( shaderFloat16 == rhs.shaderFloat16 ) && ( shaderInt8 == rhs.shaderInt8 ) && ( descriptorIndexing == rhs.descriptorIndexing ) && + ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) && + ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) && + ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) && + ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) && + ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) && + ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) && + ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) && + ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) && + ( shaderUniformTexelBufferArrayNonUniformIndexing == rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) && + ( shaderStorageTexelBufferArrayNonUniformIndexing == rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) && + ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) && + ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) && + ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) && + ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) && + ( descriptorBindingUniformTexelBufferUpdateAfterBind == rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) && + ( descriptorBindingStorageTexelBufferUpdateAfterBind == rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) && + ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) && + ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) && + ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) && + ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ) && ( samplerFilterMinmax == rhs.samplerFilterMinmax ) && + ( scalarBlockLayout == rhs.scalarBlockLayout ) && ( imagelessFramebuffer == rhs.imagelessFramebuffer ) && + ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ) && ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes ) && + ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts ) && ( hostQueryReset == rhs.hostQueryReset ) && + ( timelineSemaphore == rhs.timelineSemaphore ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && + ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && + ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ) && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) && + ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) && + ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ) && + ( shaderOutputViewportIndex == rhs.shaderOutputViewportIndex ) && ( shaderOutputLayer == rhs.shaderOutputLayer ) && + ( subgroupBroadcastDynamicId == rhs.subgroupBroadcastDynamicId ); +# endif + } + + bool operator!=( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVulkan12Features; + void * pNext = {}; + Bool32 samplerMirrorClampToEdge = {}; + Bool32 drawIndirectCount = {}; + Bool32 storageBuffer8BitAccess = {}; + Bool32 uniformAndStorageBuffer8BitAccess = {}; + Bool32 storagePushConstant8 = {}; + Bool32 shaderBufferInt64Atomics = {}; + Bool32 shaderSharedInt64Atomics = {}; + Bool32 shaderFloat16 = {}; + Bool32 shaderInt8 = {}; + Bool32 descriptorIndexing = {}; + Bool32 shaderInputAttachmentArrayDynamicIndexing = {}; + Bool32 shaderUniformTexelBufferArrayDynamicIndexing = {}; + Bool32 shaderStorageTexelBufferArrayDynamicIndexing = {}; + Bool32 shaderUniformBufferArrayNonUniformIndexing = {}; + Bool32 shaderSampledImageArrayNonUniformIndexing = {}; + Bool32 shaderStorageBufferArrayNonUniformIndexing = {}; + Bool32 shaderStorageImageArrayNonUniformIndexing = {}; + Bool32 shaderInputAttachmentArrayNonUniformIndexing = {}; + Bool32 shaderUniformTexelBufferArrayNonUniformIndexing = {}; + Bool32 shaderStorageTexelBufferArrayNonUniformIndexing = {}; + Bool32 descriptorBindingUniformBufferUpdateAfterBind = {}; + Bool32 descriptorBindingSampledImageUpdateAfterBind = {}; + Bool32 descriptorBindingStorageImageUpdateAfterBind = {}; + Bool32 descriptorBindingStorageBufferUpdateAfterBind = {}; + Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind = {}; + Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind = {}; + Bool32 descriptorBindingUpdateUnusedWhilePending = {}; + Bool32 descriptorBindingPartiallyBound = {}; + Bool32 descriptorBindingVariableDescriptorCount = {}; + Bool32 runtimeDescriptorArray = {}; + Bool32 samplerFilterMinmax = {}; + Bool32 scalarBlockLayout = {}; + Bool32 imagelessFramebuffer = {}; + Bool32 uniformBufferStandardLayout = {}; + Bool32 shaderSubgroupExtendedTypes = {}; + Bool32 separateDepthStencilLayouts = {}; + Bool32 hostQueryReset = {}; + Bool32 timelineSemaphore = {}; + Bool32 bufferDeviceAddress = {}; + Bool32 bufferDeviceAddressCaptureReplay = {}; + Bool32 bufferDeviceAddressMultiDevice = {}; + Bool32 vulkanMemoryModel = {}; + Bool32 vulkanMemoryModelDeviceScope = {}; + Bool32 vulkanMemoryModelAvailabilityVisibilityChains = {}; + Bool32 shaderOutputViewportIndex = {}; + Bool32 shaderOutputLayer = {}; + Bool32 subgroupBroadcastDynamicId = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan12Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan12Features; + }; + + // wrapper struct for struct VkPhysicalDeviceVulkan12Properties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan12Properties.html + struct PhysicalDeviceVulkan12Properties + { + using NativeType = VkPhysicalDeviceVulkan12Properties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan12Properties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + PhysicalDeviceVulkan12Properties( DriverId driverID_ = DriverId::eAmdProprietary, + std::array const & driverName_ = {}, + std::array const & driverInfo_ = {}, + ConformanceVersion conformanceVersion_ = {}, + ShaderFloatControlsIndependence denormBehaviorIndependence_ = ShaderFloatControlsIndependence::e32BitOnly, + ShaderFloatControlsIndependence roundingModeIndependence_ = ShaderFloatControlsIndependence::e32BitOnly, + Bool32 shaderSignedZeroInfNanPreserveFloat16_ = {}, + Bool32 shaderSignedZeroInfNanPreserveFloat32_ = {}, + Bool32 shaderSignedZeroInfNanPreserveFloat64_ = {}, + Bool32 shaderDenormPreserveFloat16_ = {}, + Bool32 shaderDenormPreserveFloat32_ = {}, + Bool32 shaderDenormPreserveFloat64_ = {}, + Bool32 shaderDenormFlushToZeroFloat16_ = {}, + Bool32 shaderDenormFlushToZeroFloat32_ = {}, + Bool32 shaderDenormFlushToZeroFloat64_ = {}, + Bool32 shaderRoundingModeRTEFloat16_ = {}, + Bool32 shaderRoundingModeRTEFloat32_ = {}, + Bool32 shaderRoundingModeRTEFloat64_ = {}, + Bool32 shaderRoundingModeRTZFloat16_ = {}, + Bool32 shaderRoundingModeRTZFloat32_ = {}, + Bool32 shaderRoundingModeRTZFloat64_ = {}, + uint32_t maxUpdateAfterBindDescriptorsInAllPools_ = {}, + Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ = {}, + Bool32 shaderSampledImageArrayNonUniformIndexingNative_ = {}, + Bool32 shaderStorageBufferArrayNonUniformIndexingNative_ = {}, + Bool32 shaderStorageImageArrayNonUniformIndexingNative_ = {}, + Bool32 shaderInputAttachmentArrayNonUniformIndexingNative_ = {}, + Bool32 robustBufferAccessUpdateAfterBind_ = {}, + Bool32 quadDivergentImplicitLod_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments_ = {}, + uint32_t maxPerStageUpdateAfterBindResources_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindSamplers_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindSampledImages_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindStorageImages_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments_ = {}, + ResolveModeFlags supportedDepthResolveModes_ = {}, + ResolveModeFlags supportedStencilResolveModes_ = {}, + Bool32 independentResolveNone_ = {}, + Bool32 independentResolve_ = {}, + Bool32 filterMinmaxSingleComponentFormats_ = {}, + Bool32 filterMinmaxImageComponentMapping_ = {}, + uint64_t maxTimelineSemaphoreValueDifference_ = {}, + SampleCountFlags framebufferIntegerColorSampleCounts_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , driverID{ driverID_ } + , driverName{ driverName_ } + , driverInfo{ driverInfo_ } + , conformanceVersion{ conformanceVersion_ } + , denormBehaviorIndependence{ denormBehaviorIndependence_ } + , roundingModeIndependence{ roundingModeIndependence_ } + , shaderSignedZeroInfNanPreserveFloat16{ shaderSignedZeroInfNanPreserveFloat16_ } + , shaderSignedZeroInfNanPreserveFloat32{ shaderSignedZeroInfNanPreserveFloat32_ } + , shaderSignedZeroInfNanPreserveFloat64{ shaderSignedZeroInfNanPreserveFloat64_ } + , shaderDenormPreserveFloat16{ shaderDenormPreserveFloat16_ } + , shaderDenormPreserveFloat32{ shaderDenormPreserveFloat32_ } + , shaderDenormPreserveFloat64{ shaderDenormPreserveFloat64_ } + , shaderDenormFlushToZeroFloat16{ shaderDenormFlushToZeroFloat16_ } + , shaderDenormFlushToZeroFloat32{ shaderDenormFlushToZeroFloat32_ } + , shaderDenormFlushToZeroFloat64{ shaderDenormFlushToZeroFloat64_ } + , shaderRoundingModeRTEFloat16{ shaderRoundingModeRTEFloat16_ } + , shaderRoundingModeRTEFloat32{ shaderRoundingModeRTEFloat32_ } + , shaderRoundingModeRTEFloat64{ shaderRoundingModeRTEFloat64_ } + , shaderRoundingModeRTZFloat16{ shaderRoundingModeRTZFloat16_ } + , shaderRoundingModeRTZFloat32{ shaderRoundingModeRTZFloat32_ } + , shaderRoundingModeRTZFloat64{ shaderRoundingModeRTZFloat64_ } + , maxUpdateAfterBindDescriptorsInAllPools{ maxUpdateAfterBindDescriptorsInAllPools_ } + , shaderUniformBufferArrayNonUniformIndexingNative{ shaderUniformBufferArrayNonUniformIndexingNative_ } + , shaderSampledImageArrayNonUniformIndexingNative{ shaderSampledImageArrayNonUniformIndexingNative_ } + , shaderStorageBufferArrayNonUniformIndexingNative{ shaderStorageBufferArrayNonUniformIndexingNative_ } + , shaderStorageImageArrayNonUniformIndexingNative{ shaderStorageImageArrayNonUniformIndexingNative_ } + , shaderInputAttachmentArrayNonUniformIndexingNative{ shaderInputAttachmentArrayNonUniformIndexingNative_ } + , robustBufferAccessUpdateAfterBind{ robustBufferAccessUpdateAfterBind_ } + , quadDivergentImplicitLod{ quadDivergentImplicitLod_ } + , maxPerStageDescriptorUpdateAfterBindSamplers{ maxPerStageDescriptorUpdateAfterBindSamplers_ } + , maxPerStageDescriptorUpdateAfterBindUniformBuffers{ maxPerStageDescriptorUpdateAfterBindUniformBuffers_ } + , maxPerStageDescriptorUpdateAfterBindStorageBuffers{ maxPerStageDescriptorUpdateAfterBindStorageBuffers_ } + , maxPerStageDescriptorUpdateAfterBindSampledImages{ maxPerStageDescriptorUpdateAfterBindSampledImages_ } + , maxPerStageDescriptorUpdateAfterBindStorageImages{ maxPerStageDescriptorUpdateAfterBindStorageImages_ } + , maxPerStageDescriptorUpdateAfterBindInputAttachments{ maxPerStageDescriptorUpdateAfterBindInputAttachments_ } + , maxPerStageUpdateAfterBindResources{ maxPerStageUpdateAfterBindResources_ } + , maxDescriptorSetUpdateAfterBindSamplers{ maxDescriptorSetUpdateAfterBindSamplers_ } + , maxDescriptorSetUpdateAfterBindUniformBuffers{ maxDescriptorSetUpdateAfterBindUniformBuffers_ } + , maxDescriptorSetUpdateAfterBindUniformBuffersDynamic{ maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ } + , maxDescriptorSetUpdateAfterBindStorageBuffers{ maxDescriptorSetUpdateAfterBindStorageBuffers_ } + , maxDescriptorSetUpdateAfterBindStorageBuffersDynamic{ maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ } + , maxDescriptorSetUpdateAfterBindSampledImages{ maxDescriptorSetUpdateAfterBindSampledImages_ } + , maxDescriptorSetUpdateAfterBindStorageImages{ maxDescriptorSetUpdateAfterBindStorageImages_ } + , maxDescriptorSetUpdateAfterBindInputAttachments{ maxDescriptorSetUpdateAfterBindInputAttachments_ } + , supportedDepthResolveModes{ supportedDepthResolveModes_ } + , supportedStencilResolveModes{ supportedStencilResolveModes_ } + , independentResolveNone{ independentResolveNone_ } + , independentResolve{ independentResolve_ } + , filterMinmaxSingleComponentFormats{ filterMinmaxSingleComponentFormats_ } + , filterMinmaxImageComponentMapping{ filterMinmaxImageComponentMapping_ } + , maxTimelineSemaphoreValueDifference{ maxTimelineSemaphoreValueDifference_ } + , framebufferIntegerColorSampleCounts{ framebufferIntegerColorSampleCounts_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Properties( PhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVulkan12Properties( VkPhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVulkan12Properties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVulkan12Properties & operator=( PhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVulkan12Properties & operator=( VkPhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceVulkan12Properties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan12Properties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan12Properties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan12Properties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &, + ConformanceVersion const &, + ShaderFloatControlsIndependence const &, + ShaderFloatControlsIndependence const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + uint32_t const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + uint32_t const &, + ResolveModeFlags const &, + ResolveModeFlags const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + Bool32 const &, + uint64_t const &, + SampleCountFlags const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + driverID, + driverName, + driverInfo, + conformanceVersion, + denormBehaviorIndependence, + roundingModeIndependence, + shaderSignedZeroInfNanPreserveFloat16, + shaderSignedZeroInfNanPreserveFloat32, + shaderSignedZeroInfNanPreserveFloat64, + shaderDenormPreserveFloat16, + shaderDenormPreserveFloat32, + shaderDenormPreserveFloat64, + shaderDenormFlushToZeroFloat16, + shaderDenormFlushToZeroFloat32, + shaderDenormFlushToZeroFloat64, + shaderRoundingModeRTEFloat16, + shaderRoundingModeRTEFloat32, + shaderRoundingModeRTEFloat64, + shaderRoundingModeRTZFloat16, + shaderRoundingModeRTZFloat32, + shaderRoundingModeRTZFloat64, + maxUpdateAfterBindDescriptorsInAllPools, + shaderUniformBufferArrayNonUniformIndexingNative, + shaderSampledImageArrayNonUniformIndexingNative, + shaderStorageBufferArrayNonUniformIndexingNative, + shaderStorageImageArrayNonUniformIndexingNative, + shaderInputAttachmentArrayNonUniformIndexingNative, + robustBufferAccessUpdateAfterBind, + quadDivergentImplicitLod, + maxPerStageDescriptorUpdateAfterBindSamplers, + maxPerStageDescriptorUpdateAfterBindUniformBuffers, + maxPerStageDescriptorUpdateAfterBindStorageBuffers, + maxPerStageDescriptorUpdateAfterBindSampledImages, + maxPerStageDescriptorUpdateAfterBindStorageImages, + maxPerStageDescriptorUpdateAfterBindInputAttachments, + maxPerStageUpdateAfterBindResources, + maxDescriptorSetUpdateAfterBindSamplers, + maxDescriptorSetUpdateAfterBindUniformBuffers, + maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, + maxDescriptorSetUpdateAfterBindStorageBuffers, + maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, + maxDescriptorSetUpdateAfterBindSampledImages, + maxDescriptorSetUpdateAfterBindStorageImages, + maxDescriptorSetUpdateAfterBindInputAttachments, + supportedDepthResolveModes, + supportedStencilResolveModes, + independentResolveNone, + independentResolve, + filterMinmaxSingleComponentFormats, + filterMinmaxImageComponentMapping, + maxTimelineSemaphoreValueDifference, + framebufferIntegerColorSampleCounts ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = driverID <=> rhs.driverID; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( driverName, rhs.driverName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( driverInfo, rhs.driverInfo ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = conformanceVersion <=> rhs.conformanceVersion; cmp != 0 ) + return cmp; + if ( auto cmp = denormBehaviorIndependence <=> rhs.denormBehaviorIndependence; cmp != 0 ) + return cmp; + if ( auto cmp = roundingModeIndependence <=> rhs.roundingModeIndependence; cmp != 0 ) + return cmp; + if ( auto cmp = shaderSignedZeroInfNanPreserveFloat16 <=> rhs.shaderSignedZeroInfNanPreserveFloat16; cmp != 0 ) + return cmp; + if ( auto cmp = shaderSignedZeroInfNanPreserveFloat32 <=> rhs.shaderSignedZeroInfNanPreserveFloat32; cmp != 0 ) + return cmp; + if ( auto cmp = shaderSignedZeroInfNanPreserveFloat64 <=> rhs.shaderSignedZeroInfNanPreserveFloat64; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormPreserveFloat16 <=> rhs.shaderDenormPreserveFloat16; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormPreserveFloat32 <=> rhs.shaderDenormPreserveFloat32; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormPreserveFloat64 <=> rhs.shaderDenormPreserveFloat64; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormFlushToZeroFloat16 <=> rhs.shaderDenormFlushToZeroFloat16; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormFlushToZeroFloat32 <=> rhs.shaderDenormFlushToZeroFloat32; cmp != 0 ) + return cmp; + if ( auto cmp = shaderDenormFlushToZeroFloat64 <=> rhs.shaderDenormFlushToZeroFloat64; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTEFloat16 <=> rhs.shaderRoundingModeRTEFloat16; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTEFloat32 <=> rhs.shaderRoundingModeRTEFloat32; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTEFloat64 <=> rhs.shaderRoundingModeRTEFloat64; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTZFloat16 <=> rhs.shaderRoundingModeRTZFloat16; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTZFloat32 <=> rhs.shaderRoundingModeRTZFloat32; cmp != 0 ) + return cmp; + if ( auto cmp = shaderRoundingModeRTZFloat64 <=> rhs.shaderRoundingModeRTZFloat64; cmp != 0 ) + return cmp; + if ( auto cmp = maxUpdateAfterBindDescriptorsInAllPools <=> rhs.maxUpdateAfterBindDescriptorsInAllPools; cmp != 0 ) + return cmp; + if ( auto cmp = shaderUniformBufferArrayNonUniformIndexingNative <=> rhs.shaderUniformBufferArrayNonUniformIndexingNative; cmp != 0 ) + return cmp; + if ( auto cmp = shaderSampledImageArrayNonUniformIndexingNative <=> rhs.shaderSampledImageArrayNonUniformIndexingNative; cmp != 0 ) + return cmp; + if ( auto cmp = shaderStorageBufferArrayNonUniformIndexingNative <=> rhs.shaderStorageBufferArrayNonUniformIndexingNative; cmp != 0 ) + return cmp; + if ( auto cmp = shaderStorageImageArrayNonUniformIndexingNative <=> rhs.shaderStorageImageArrayNonUniformIndexingNative; cmp != 0 ) + return cmp; + if ( auto cmp = shaderInputAttachmentArrayNonUniformIndexingNative <=> rhs.shaderInputAttachmentArrayNonUniformIndexingNative; cmp != 0 ) + return cmp; + if ( auto cmp = robustBufferAccessUpdateAfterBind <=> rhs.robustBufferAccessUpdateAfterBind; cmp != 0 ) + return cmp; + if ( auto cmp = quadDivergentImplicitLod <=> rhs.quadDivergentImplicitLod; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindSamplers <=> rhs.maxPerStageDescriptorUpdateAfterBindSamplers; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindUniformBuffers <=> rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindStorageBuffers <=> rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindSampledImages <=> rhs.maxPerStageDescriptorUpdateAfterBindSampledImages; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindStorageImages <=> rhs.maxPerStageDescriptorUpdateAfterBindStorageImages; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageDescriptorUpdateAfterBindInputAttachments <=> rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments; cmp != 0 ) + return cmp; + if ( auto cmp = maxPerStageUpdateAfterBindResources <=> rhs.maxPerStageUpdateAfterBindResources; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindSamplers <=> rhs.maxDescriptorSetUpdateAfterBindSamplers; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindUniformBuffers <=> rhs.maxDescriptorSetUpdateAfterBindUniformBuffers; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindUniformBuffersDynamic <=> rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindStorageBuffers <=> rhs.maxDescriptorSetUpdateAfterBindStorageBuffers; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindStorageBuffersDynamic <=> rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindSampledImages <=> rhs.maxDescriptorSetUpdateAfterBindSampledImages; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindStorageImages <=> rhs.maxDescriptorSetUpdateAfterBindStorageImages; cmp != 0 ) + return cmp; + if ( auto cmp = maxDescriptorSetUpdateAfterBindInputAttachments <=> rhs.maxDescriptorSetUpdateAfterBindInputAttachments; cmp != 0 ) + return cmp; + if ( auto cmp = supportedDepthResolveModes <=> rhs.supportedDepthResolveModes; cmp != 0 ) + return cmp; + if ( auto cmp = supportedStencilResolveModes <=> rhs.supportedStencilResolveModes; cmp != 0 ) + return cmp; + if ( auto cmp = independentResolveNone <=> rhs.independentResolveNone; cmp != 0 ) + return cmp; + if ( auto cmp = independentResolve <=> rhs.independentResolve; cmp != 0 ) + return cmp; + if ( auto cmp = filterMinmaxSingleComponentFormats <=> rhs.filterMinmaxSingleComponentFormats; cmp != 0 ) + return cmp; + if ( auto cmp = filterMinmaxImageComponentMapping <=> rhs.filterMinmaxImageComponentMapping; cmp != 0 ) + return cmp; + if ( auto cmp = maxTimelineSemaphoreValueDifference <=> rhs.maxTimelineSemaphoreValueDifference; cmp != 0 ) + return cmp; + if ( auto cmp = framebufferIntegerColorSampleCounts <=> rhs.framebufferIntegerColorSampleCounts; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && ( strcmp( driverName, rhs.driverName ) == 0 ) && + ( strcmp( driverInfo, rhs.driverInfo ) == 0 ) && ( conformanceVersion == rhs.conformanceVersion ) && + ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) && ( roundingModeIndependence == rhs.roundingModeIndependence ) && + ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) && + ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) && + ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) && + ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) && ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) && + ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) && ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) && + ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) && + ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) && ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) && + ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) && ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) && + ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) && ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) && + ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 ) && + ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) && + ( shaderUniformBufferArrayNonUniformIndexingNative == rhs.shaderUniformBufferArrayNonUniformIndexingNative ) && + ( shaderSampledImageArrayNonUniformIndexingNative == rhs.shaderSampledImageArrayNonUniformIndexingNative ) && + ( shaderStorageBufferArrayNonUniformIndexingNative == rhs.shaderStorageBufferArrayNonUniformIndexingNative ) && + ( shaderStorageImageArrayNonUniformIndexingNative == rhs.shaderStorageImageArrayNonUniformIndexingNative ) && + ( shaderInputAttachmentArrayNonUniformIndexingNative == rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) && + ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) && ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) && + ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) && + ( maxPerStageDescriptorUpdateAfterBindUniformBuffers == rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) && + ( maxPerStageDescriptorUpdateAfterBindStorageBuffers == rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) && + ( maxPerStageDescriptorUpdateAfterBindSampledImages == rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) && + ( maxPerStageDescriptorUpdateAfterBindStorageImages == rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) && + ( maxPerStageDescriptorUpdateAfterBindInputAttachments == rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) && + ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) && + ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) && + ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) && + ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) && + ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) && + ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) && + ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) && + ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) && + ( maxDescriptorSetUpdateAfterBindInputAttachments == rhs.maxDescriptorSetUpdateAfterBindInputAttachments ) && + ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) && ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) && + ( independentResolveNone == rhs.independentResolveNone ) && ( independentResolve == rhs.independentResolve ) && + ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) && + ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ) && + ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ) && + ( framebufferIntegerColorSampleCounts == rhs.framebufferIntegerColorSampleCounts ); + } + + bool operator!=( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::ePhysicalDeviceVulkan12Properties; + void * pNext = {}; + DriverId driverID = DriverId::eAmdProprietary; + ArrayWrapper1D driverName = {}; + ArrayWrapper1D driverInfo = {}; + ConformanceVersion conformanceVersion = {}; + ShaderFloatControlsIndependence denormBehaviorIndependence = ShaderFloatControlsIndependence::e32BitOnly; + ShaderFloatControlsIndependence roundingModeIndependence = ShaderFloatControlsIndependence::e32BitOnly; + Bool32 shaderSignedZeroInfNanPreserveFloat16 = {}; + Bool32 shaderSignedZeroInfNanPreserveFloat32 = {}; + Bool32 shaderSignedZeroInfNanPreserveFloat64 = {}; + Bool32 shaderDenormPreserveFloat16 = {}; + Bool32 shaderDenormPreserveFloat32 = {}; + Bool32 shaderDenormPreserveFloat64 = {}; + Bool32 shaderDenormFlushToZeroFloat16 = {}; + Bool32 shaderDenormFlushToZeroFloat32 = {}; + Bool32 shaderDenormFlushToZeroFloat64 = {}; + Bool32 shaderRoundingModeRTEFloat16 = {}; + Bool32 shaderRoundingModeRTEFloat32 = {}; + Bool32 shaderRoundingModeRTEFloat64 = {}; + Bool32 shaderRoundingModeRTZFloat16 = {}; + Bool32 shaderRoundingModeRTZFloat32 = {}; + Bool32 shaderRoundingModeRTZFloat64 = {}; + uint32_t maxUpdateAfterBindDescriptorsInAllPools = {}; + Bool32 shaderUniformBufferArrayNonUniformIndexingNative = {}; + Bool32 shaderSampledImageArrayNonUniformIndexingNative = {}; + Bool32 shaderStorageBufferArrayNonUniformIndexingNative = {}; + Bool32 shaderStorageImageArrayNonUniformIndexingNative = {}; + Bool32 shaderInputAttachmentArrayNonUniformIndexingNative = {}; + Bool32 robustBufferAccessUpdateAfterBind = {}; + Bool32 quadDivergentImplicitLod = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments = {}; + uint32_t maxPerStageUpdateAfterBindResources = {}; + uint32_t maxDescriptorSetUpdateAfterBindSamplers = {}; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers = {}; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = {}; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers = {}; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = {}; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages = {}; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages = {}; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments = {}; + ResolveModeFlags supportedDepthResolveModes = {}; + ResolveModeFlags supportedStencilResolveModes = {}; + Bool32 independentResolveNone = {}; + Bool32 independentResolve = {}; + Bool32 filterMinmaxSingleComponentFormats = {}; + Bool32 filterMinmaxImageComponentMapping = {}; + uint64_t maxTimelineSemaphoreValueDifference = {}; + SampleCountFlags framebufferIntegerColorSampleCounts = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan12Properties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan12Properties; + }; + + // wrapper struct for struct VkPhysicalDeviceVulkan13Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan13Features.html + struct PhysicalDeviceVulkan13Features + { + using NativeType = VkPhysicalDeviceVulkan13Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan13Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan13Features( Bool32 robustImageAccess_ = {}, + Bool32 inlineUniformBlock_ = {}, + Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = {}, + Bool32 pipelineCreationCacheControl_ = {}, + Bool32 privateData_ = {}, + Bool32 shaderDemoteToHelperInvocation_ = {}, + Bool32 shaderTerminateInvocation_ = {}, + Bool32 subgroupSizeControl_ = {}, + Bool32 computeFullSubgroups_ = {}, + Bool32 synchronization2_ = {}, + Bool32 textureCompressionASTC_HDR_ = {}, + Bool32 shaderZeroInitializeWorkgroupMemory_ = {}, + Bool32 dynamicRendering_ = {}, + Bool32 shaderIntegerDotProduct_ = {}, + Bool32 maintenance4_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , robustImageAccess{ robustImageAccess_ } + , inlineUniformBlock{ inlineUniformBlock_ } + , descriptorBindingInlineUniformBlockUpdateAfterBind{ descriptorBindingInlineUniformBlockUpdateAfterBind_ } + , pipelineCreationCacheControl{ pipelineCreationCacheControl_ } + , privateData{ privateData_ } + , shaderDemoteToHelperInvocation{ shaderDemoteToHelperInvocation_ } + , shaderTerminateInvocation{ shaderTerminateInvocation_ } + , subgroupSizeControl{ subgroupSizeControl_ } + , computeFullSubgroups{ computeFullSubgroups_ } + , synchronization2{ synchronization2_ } + , textureCompressionASTC_HDR{ textureCompressionASTC_HDR_ } + , shaderZeroInitializeWorkgroupMemory{ shaderZeroInitializeWorkgroupMemory_ } + , dynamicRendering{ dynamicRendering_ } + , shaderIntegerDotProduct{ shaderIntegerDotProduct_ } + , maintenance4{ maintenance4_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan13Features( PhysicalDeviceVulkan13Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVulkan13Features( VkPhysicalDeviceVulkan13Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVulkan13Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVulkan13Features & operator=( PhysicalDeviceVulkan13Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVulkan13Features & operator=( VkPhysicalDeviceVulkan13Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setRobustImageAccess( Bool32 robustImageAccess_ ) & VULKAN_HPP_NOEXCEPT + { + robustImageAccess = robustImageAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setRobustImageAccess( Bool32 robustImageAccess_ ) && VULKAN_HPP_NOEXCEPT + { + robustImageAccess = robustImageAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setInlineUniformBlock( Bool32 inlineUniformBlock_ ) & VULKAN_HPP_NOEXCEPT + { + inlineUniformBlock = inlineUniformBlock_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setInlineUniformBlock( Bool32 inlineUniformBlock_ ) && VULKAN_HPP_NOEXCEPT + { + inlineUniformBlock = inlineUniformBlock_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & + setDescriptorBindingInlineUniformBlockUpdateAfterBind( Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && + setDescriptorBindingInlineUniformBlockUpdateAfterBind( Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setPipelineCreationCacheControl( Bool32 pipelineCreationCacheControl_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineCreationCacheControl = pipelineCreationCacheControl_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setPipelineCreationCacheControl( Bool32 pipelineCreationCacheControl_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineCreationCacheControl = pipelineCreationCacheControl_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setPrivateData( Bool32 privateData_ ) & VULKAN_HPP_NOEXCEPT + { + privateData = privateData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setPrivateData( Bool32 privateData_ ) && VULKAN_HPP_NOEXCEPT + { + privateData = privateData_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setShaderDemoteToHelperInvocation( Bool32 shaderDemoteToHelperInvocation_ ) & VULKAN_HPP_NOEXCEPT + { + shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setShaderDemoteToHelperInvocation( Bool32 shaderDemoteToHelperInvocation_ ) && VULKAN_HPP_NOEXCEPT + { + shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setShaderTerminateInvocation( Bool32 shaderTerminateInvocation_ ) & VULKAN_HPP_NOEXCEPT + { + shaderTerminateInvocation = shaderTerminateInvocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setShaderTerminateInvocation( Bool32 shaderTerminateInvocation_ ) && VULKAN_HPP_NOEXCEPT + { + shaderTerminateInvocation = shaderTerminateInvocation_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setSubgroupSizeControl( Bool32 subgroupSizeControl_ ) & VULKAN_HPP_NOEXCEPT + { + subgroupSizeControl = subgroupSizeControl_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setSubgroupSizeControl( Bool32 subgroupSizeControl_ ) && VULKAN_HPP_NOEXCEPT + { + subgroupSizeControl = subgroupSizeControl_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setComputeFullSubgroups( Bool32 computeFullSubgroups_ ) & VULKAN_HPP_NOEXCEPT + { + computeFullSubgroups = computeFullSubgroups_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setComputeFullSubgroups( Bool32 computeFullSubgroups_ ) && VULKAN_HPP_NOEXCEPT + { + computeFullSubgroups = computeFullSubgroups_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setSynchronization2( Bool32 synchronization2_ ) & VULKAN_HPP_NOEXCEPT + { + synchronization2 = synchronization2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setSynchronization2( Bool32 synchronization2_ ) && VULKAN_HPP_NOEXCEPT + { + synchronization2 = synchronization2_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setTextureCompressionASTC_HDR( Bool32 textureCompressionASTC_HDR_ ) & VULKAN_HPP_NOEXCEPT + { + textureCompressionASTC_HDR = textureCompressionASTC_HDR_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setTextureCompressionASTC_HDR( Bool32 textureCompressionASTC_HDR_ ) && VULKAN_HPP_NOEXCEPT + { + textureCompressionASTC_HDR = textureCompressionASTC_HDR_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setShaderZeroInitializeWorkgroupMemory( Bool32 shaderZeroInitializeWorkgroupMemory_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderZeroInitializeWorkgroupMemory = shaderZeroInitializeWorkgroupMemory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setShaderZeroInitializeWorkgroupMemory( Bool32 shaderZeroInitializeWorkgroupMemory_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderZeroInitializeWorkgroupMemory = shaderZeroInitializeWorkgroupMemory_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setDynamicRendering( Bool32 dynamicRendering_ ) & VULKAN_HPP_NOEXCEPT + { + dynamicRendering = dynamicRendering_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setDynamicRendering( Bool32 dynamicRendering_ ) && VULKAN_HPP_NOEXCEPT + { + dynamicRendering = dynamicRendering_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setShaderIntegerDotProduct( Bool32 shaderIntegerDotProduct_ ) & VULKAN_HPP_NOEXCEPT + { + shaderIntegerDotProduct = shaderIntegerDotProduct_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setShaderIntegerDotProduct( Bool32 shaderIntegerDotProduct_ ) && VULKAN_HPP_NOEXCEPT + { + shaderIntegerDotProduct = shaderIntegerDotProduct_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setMaintenance4( Bool32 maintenance4_ ) & VULKAN_HPP_NOEXCEPT + { + maintenance4 = maintenance4_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setMaintenance4( Bool32 maintenance4_ ) && VULKAN_HPP_NOEXCEPT + { + maintenance4 = maintenance4_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVulkan13Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan13Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan13Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan13Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + robustImageAccess, + inlineUniformBlock, + descriptorBindingInlineUniformBlockUpdateAfterBind, + pipelineCreationCacheControl, + privateData, + shaderDemoteToHelperInvocation, + shaderTerminateInvocation, + subgroupSizeControl, + computeFullSubgroups, + synchronization2, + textureCompressionASTC_HDR, + shaderZeroInitializeWorkgroupMemory, + dynamicRendering, + shaderIntegerDotProduct, + maintenance4 ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVulkan13Features const & ) const = default; +#else + bool operator==( PhysicalDeviceVulkan13Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess ) && + ( inlineUniformBlock == rhs.inlineUniformBlock ) && + ( descriptorBindingInlineUniformBlockUpdateAfterBind == rhs.descriptorBindingInlineUniformBlockUpdateAfterBind ) && + ( pipelineCreationCacheControl == rhs.pipelineCreationCacheControl ) && ( privateData == rhs.privateData ) && + ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation ) && ( shaderTerminateInvocation == rhs.shaderTerminateInvocation ) && + ( subgroupSizeControl == rhs.subgroupSizeControl ) && ( computeFullSubgroups == rhs.computeFullSubgroups ) && + ( synchronization2 == rhs.synchronization2 ) && ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR ) && + ( shaderZeroInitializeWorkgroupMemory == rhs.shaderZeroInitializeWorkgroupMemory ) && ( dynamicRendering == rhs.dynamicRendering ) && + ( shaderIntegerDotProduct == rhs.shaderIntegerDotProduct ) && ( maintenance4 == rhs.maintenance4 ); +# endif + } + + bool operator!=( PhysicalDeviceVulkan13Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVulkan13Features; + void * pNext = {}; + Bool32 robustImageAccess = {}; + Bool32 inlineUniformBlock = {}; + Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind = {}; + Bool32 pipelineCreationCacheControl = {}; + Bool32 privateData = {}; + Bool32 shaderDemoteToHelperInvocation = {}; + Bool32 shaderTerminateInvocation = {}; + Bool32 subgroupSizeControl = {}; + Bool32 computeFullSubgroups = {}; + Bool32 synchronization2 = {}; + Bool32 textureCompressionASTC_HDR = {}; + Bool32 shaderZeroInitializeWorkgroupMemory = {}; + Bool32 dynamicRendering = {}; + Bool32 shaderIntegerDotProduct = {}; + Bool32 maintenance4 = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan13Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan13Features; + }; + + // wrapper struct for struct VkPhysicalDeviceVulkan13Properties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan13Properties.html + struct PhysicalDeviceVulkan13Properties + { + using NativeType = VkPhysicalDeviceVulkan13Properties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan13Properties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan13Properties( uint32_t minSubgroupSize_ = {}, + uint32_t maxSubgroupSize_ = {}, + uint32_t maxComputeWorkgroupSubgroups_ = {}, + ShaderStageFlags requiredSubgroupSizeStages_ = {}, + uint32_t maxInlineUniformBlockSize_ = {}, + uint32_t maxPerStageDescriptorInlineUniformBlocks_ = {}, + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ = {}, + uint32_t maxDescriptorSetInlineUniformBlocks_ = {}, + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ = {}, + uint32_t maxInlineUniformTotalSize_ = {}, + Bool32 integerDotProduct8BitUnsignedAccelerated_ = {}, + Bool32 integerDotProduct8BitSignedAccelerated_ = {}, + Bool32 integerDotProduct8BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProduct4x8BitPackedUnsignedAccelerated_ = {}, + Bool32 integerDotProduct4x8BitPackedSignedAccelerated_ = {}, + Bool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated_ = {}, + Bool32 integerDotProduct16BitUnsignedAccelerated_ = {}, + Bool32 integerDotProduct16BitSignedAccelerated_ = {}, + Bool32 integerDotProduct16BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProduct32BitUnsignedAccelerated_ = {}, + Bool32 integerDotProduct32BitSignedAccelerated_ = {}, + Bool32 integerDotProduct32BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProduct64BitUnsignedAccelerated_ = {}, + Bool32 integerDotProduct64BitSignedAccelerated_ = {}, + Bool32 integerDotProduct64BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated_ = {}, + Bool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated_ = {}, + DeviceSize storageTexelBufferOffsetAlignmentBytes_ = {}, + Bool32 storageTexelBufferOffsetSingleTexelAlignment_ = {}, + DeviceSize uniformTexelBufferOffsetAlignmentBytes_ = {}, + Bool32 uniformTexelBufferOffsetSingleTexelAlignment_ = {}, + DeviceSize maxBufferSize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minSubgroupSize{ minSubgroupSize_ } + , maxSubgroupSize{ maxSubgroupSize_ } + , maxComputeWorkgroupSubgroups{ maxComputeWorkgroupSubgroups_ } + , requiredSubgroupSizeStages{ requiredSubgroupSizeStages_ } + , maxInlineUniformBlockSize{ maxInlineUniformBlockSize_ } + , maxPerStageDescriptorInlineUniformBlocks{ maxPerStageDescriptorInlineUniformBlocks_ } + , maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks{ maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ } + , maxDescriptorSetInlineUniformBlocks{ maxDescriptorSetInlineUniformBlocks_ } + , maxDescriptorSetUpdateAfterBindInlineUniformBlocks{ maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ } + , maxInlineUniformTotalSize{ maxInlineUniformTotalSize_ } + , integerDotProduct8BitUnsignedAccelerated{ integerDotProduct8BitUnsignedAccelerated_ } + , integerDotProduct8BitSignedAccelerated{ integerDotProduct8BitSignedAccelerated_ } + , integerDotProduct8BitMixedSignednessAccelerated{ integerDotProduct8BitMixedSignednessAccelerated_ } + , integerDotProduct4x8BitPackedUnsignedAccelerated{ integerDotProduct4x8BitPackedUnsignedAccelerated_ } + , integerDotProduct4x8BitPackedSignedAccelerated{ integerDotProduct4x8BitPackedSignedAccelerated_ } + , integerDotProduct4x8BitPackedMixedSignednessAccelerated{ integerDotProduct4x8BitPackedMixedSignednessAccelerated_ } + , integerDotProduct16BitUnsignedAccelerated{ integerDotProduct16BitUnsignedAccelerated_ } + , integerDotProduct16BitSignedAccelerated{ integerDotProduct16BitSignedAccelerated_ } + , integerDotProduct16BitMixedSignednessAccelerated{ integerDotProduct16BitMixedSignednessAccelerated_ } + , integerDotProduct32BitUnsignedAccelerated{ integerDotProduct32BitUnsignedAccelerated_ } + , integerDotProduct32BitSignedAccelerated{ integerDotProduct32BitSignedAccelerated_ } + , integerDotProduct32BitMixedSignednessAccelerated{ integerDotProduct32BitMixedSignednessAccelerated_ } + , integerDotProduct64BitUnsignedAccelerated{ integerDotProduct64BitUnsignedAccelerated_ } + , integerDotProduct64BitSignedAccelerated{ integerDotProduct64BitSignedAccelerated_ } + , integerDotProduct64BitMixedSignednessAccelerated{ integerDotProduct64BitMixedSignednessAccelerated_ } + , integerDotProductAccumulatingSaturating8BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating8BitUnsignedAccelerated_ } + , integerDotProductAccumulatingSaturating8BitSignedAccelerated{ integerDotProductAccumulatingSaturating8BitSignedAccelerated_ } + , integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated_ } + , integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated_ } + , integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated_ } + , integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated_ } + , integerDotProductAccumulatingSaturating16BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating16BitUnsignedAccelerated_ } + , integerDotProductAccumulatingSaturating16BitSignedAccelerated{ integerDotProductAccumulatingSaturating16BitSignedAccelerated_ } + , integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated_ } + , integerDotProductAccumulatingSaturating32BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating32BitUnsignedAccelerated_ } + , integerDotProductAccumulatingSaturating32BitSignedAccelerated{ integerDotProductAccumulatingSaturating32BitSignedAccelerated_ } + , integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated_ } + , integerDotProductAccumulatingSaturating64BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating64BitUnsignedAccelerated_ } + , integerDotProductAccumulatingSaturating64BitSignedAccelerated{ integerDotProductAccumulatingSaturating64BitSignedAccelerated_ } + , integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated_ } + , storageTexelBufferOffsetAlignmentBytes{ storageTexelBufferOffsetAlignmentBytes_ } + , storageTexelBufferOffsetSingleTexelAlignment{ storageTexelBufferOffsetSingleTexelAlignment_ } + , uniformTexelBufferOffsetAlignmentBytes{ uniformTexelBufferOffsetAlignmentBytes_ } + , uniformTexelBufferOffsetSingleTexelAlignment{ uniformTexelBufferOffsetSingleTexelAlignment_ } + , maxBufferSize{ maxBufferSize_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan13Properties( PhysicalDeviceVulkan13Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVulkan13Properties( VkPhysicalDeviceVulkan13Properties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVulkan13Properties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVulkan13Properties & operator=( PhysicalDeviceVulkan13Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVulkan13Properties & operator=( VkPhysicalDeviceVulkan13Properties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceVulkan13Properties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan13Properties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan13Properties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan13Properties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + minSubgroupSize, + maxSubgroupSize, + maxComputeWorkgroupSubgroups, + requiredSubgroupSizeStages, + maxInlineUniformBlockSize, + maxPerStageDescriptorInlineUniformBlocks, + maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, + maxDescriptorSetInlineUniformBlocks, + maxDescriptorSetUpdateAfterBindInlineUniformBlocks, + maxInlineUniformTotalSize, + integerDotProduct8BitUnsignedAccelerated, + integerDotProduct8BitSignedAccelerated, + integerDotProduct8BitMixedSignednessAccelerated, + integerDotProduct4x8BitPackedUnsignedAccelerated, + integerDotProduct4x8BitPackedSignedAccelerated, + integerDotProduct4x8BitPackedMixedSignednessAccelerated, + integerDotProduct16BitUnsignedAccelerated, + integerDotProduct16BitSignedAccelerated, + integerDotProduct16BitMixedSignednessAccelerated, + integerDotProduct32BitUnsignedAccelerated, + integerDotProduct32BitSignedAccelerated, + integerDotProduct32BitMixedSignednessAccelerated, + integerDotProduct64BitUnsignedAccelerated, + integerDotProduct64BitSignedAccelerated, + integerDotProduct64BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating8BitSignedAccelerated, + integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, + integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating16BitSignedAccelerated, + integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating32BitSignedAccelerated, + integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, + integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, + integerDotProductAccumulatingSaturating64BitSignedAccelerated, + integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, + storageTexelBufferOffsetAlignmentBytes, + storageTexelBufferOffsetSingleTexelAlignment, + uniformTexelBufferOffsetAlignmentBytes, + uniformTexelBufferOffsetSingleTexelAlignment, + maxBufferSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVulkan13Properties const & ) const = default; +#else + bool operator==( PhysicalDeviceVulkan13Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) && ( maxSubgroupSize == rhs.maxSubgroupSize ) && + ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups ) && ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages ) && + ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) && + ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks ) && + ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ) && + ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks ) && + ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks == rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ) && + ( maxInlineUniformTotalSize == rhs.maxInlineUniformTotalSize ) && + ( integerDotProduct8BitUnsignedAccelerated == rhs.integerDotProduct8BitUnsignedAccelerated ) && + ( integerDotProduct8BitSignedAccelerated == rhs.integerDotProduct8BitSignedAccelerated ) && + ( integerDotProduct8BitMixedSignednessAccelerated == rhs.integerDotProduct8BitMixedSignednessAccelerated ) && + ( integerDotProduct4x8BitPackedUnsignedAccelerated == rhs.integerDotProduct4x8BitPackedUnsignedAccelerated ) && + ( integerDotProduct4x8BitPackedSignedAccelerated == rhs.integerDotProduct4x8BitPackedSignedAccelerated ) && + ( integerDotProduct4x8BitPackedMixedSignednessAccelerated == rhs.integerDotProduct4x8BitPackedMixedSignednessAccelerated ) && + ( integerDotProduct16BitUnsignedAccelerated == rhs.integerDotProduct16BitUnsignedAccelerated ) && + ( integerDotProduct16BitSignedAccelerated == rhs.integerDotProduct16BitSignedAccelerated ) && + ( integerDotProduct16BitMixedSignednessAccelerated == rhs.integerDotProduct16BitMixedSignednessAccelerated ) && + ( integerDotProduct32BitUnsignedAccelerated == rhs.integerDotProduct32BitUnsignedAccelerated ) && + ( integerDotProduct32BitSignedAccelerated == rhs.integerDotProduct32BitSignedAccelerated ) && + ( integerDotProduct32BitMixedSignednessAccelerated == rhs.integerDotProduct32BitMixedSignednessAccelerated ) && + ( integerDotProduct64BitUnsignedAccelerated == rhs.integerDotProduct64BitUnsignedAccelerated ) && + ( integerDotProduct64BitSignedAccelerated == rhs.integerDotProduct64BitSignedAccelerated ) && + ( integerDotProduct64BitMixedSignednessAccelerated == rhs.integerDotProduct64BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating8BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating8BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating8BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated == + rhs.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated == + rhs.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating16BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating16BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating16BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating32BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating32BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating32BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ) && + ( integerDotProductAccumulatingSaturating64BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ) && + ( integerDotProductAccumulatingSaturating64BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating64BitSignedAccelerated ) && + ( integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated == + rhs.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ) && + ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes ) && + ( storageTexelBufferOffsetSingleTexelAlignment == rhs.storageTexelBufferOffsetSingleTexelAlignment ) && + ( uniformTexelBufferOffsetAlignmentBytes == rhs.uniformTexelBufferOffsetAlignmentBytes ) && + ( uniformTexelBufferOffsetSingleTexelAlignment == rhs.uniformTexelBufferOffsetSingleTexelAlignment ) && ( maxBufferSize == rhs.maxBufferSize ); +# endif + } + + bool operator!=( PhysicalDeviceVulkan13Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVulkan13Properties; + void * pNext = {}; + uint32_t minSubgroupSize = {}; + uint32_t maxSubgroupSize = {}; + uint32_t maxComputeWorkgroupSubgroups = {}; + ShaderStageFlags requiredSubgroupSizeStages = {}; + uint32_t maxInlineUniformBlockSize = {}; + uint32_t maxPerStageDescriptorInlineUniformBlocks = {}; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = {}; + uint32_t maxDescriptorSetInlineUniformBlocks = {}; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks = {}; + uint32_t maxInlineUniformTotalSize = {}; + Bool32 integerDotProduct8BitUnsignedAccelerated = {}; + Bool32 integerDotProduct8BitSignedAccelerated = {}; + Bool32 integerDotProduct8BitMixedSignednessAccelerated = {}; + Bool32 integerDotProduct4x8BitPackedUnsignedAccelerated = {}; + Bool32 integerDotProduct4x8BitPackedSignedAccelerated = {}; + Bool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated = {}; + Bool32 integerDotProduct16BitUnsignedAccelerated = {}; + Bool32 integerDotProduct16BitSignedAccelerated = {}; + Bool32 integerDotProduct16BitMixedSignednessAccelerated = {}; + Bool32 integerDotProduct32BitUnsignedAccelerated = {}; + Bool32 integerDotProduct32BitSignedAccelerated = {}; + Bool32 integerDotProduct32BitMixedSignednessAccelerated = {}; + Bool32 integerDotProduct64BitUnsignedAccelerated = {}; + Bool32 integerDotProduct64BitSignedAccelerated = {}; + Bool32 integerDotProduct64BitMixedSignednessAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated = {}; + Bool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = {}; + DeviceSize storageTexelBufferOffsetAlignmentBytes = {}; + Bool32 storageTexelBufferOffsetSingleTexelAlignment = {}; + DeviceSize uniformTexelBufferOffsetAlignmentBytes = {}; + Bool32 uniformTexelBufferOffsetSingleTexelAlignment = {}; + DeviceSize maxBufferSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan13Properties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan13Properties; + }; + + // wrapper struct for struct VkPhysicalDeviceVulkan14Features, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan14Features.html + struct PhysicalDeviceVulkan14Features + { + using NativeType = VkPhysicalDeviceVulkan14Features; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan14Features; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan14Features( Bool32 globalPriorityQuery_ = {}, + Bool32 shaderSubgroupRotate_ = {}, + Bool32 shaderSubgroupRotateClustered_ = {}, + Bool32 shaderFloatControls2_ = {}, + Bool32 shaderExpectAssume_ = {}, + Bool32 rectangularLines_ = {}, + Bool32 bresenhamLines_ = {}, + Bool32 smoothLines_ = {}, + Bool32 stippledRectangularLines_ = {}, + Bool32 stippledBresenhamLines_ = {}, + Bool32 stippledSmoothLines_ = {}, + Bool32 vertexAttributeInstanceRateDivisor_ = {}, + Bool32 vertexAttributeInstanceRateZeroDivisor_ = {}, + Bool32 indexTypeUint8_ = {}, + Bool32 dynamicRenderingLocalRead_ = {}, + Bool32 maintenance5_ = {}, + Bool32 maintenance6_ = {}, + Bool32 pipelineProtectedAccess_ = {}, + Bool32 pipelineRobustness_ = {}, + Bool32 hostImageCopy_ = {}, + Bool32 pushDescriptor_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , globalPriorityQuery{ globalPriorityQuery_ } + , shaderSubgroupRotate{ shaderSubgroupRotate_ } + , shaderSubgroupRotateClustered{ shaderSubgroupRotateClustered_ } + , shaderFloatControls2{ shaderFloatControls2_ } + , shaderExpectAssume{ shaderExpectAssume_ } + , rectangularLines{ rectangularLines_ } + , bresenhamLines{ bresenhamLines_ } + , smoothLines{ smoothLines_ } + , stippledRectangularLines{ stippledRectangularLines_ } + , stippledBresenhamLines{ stippledBresenhamLines_ } + , stippledSmoothLines{ stippledSmoothLines_ } + , vertexAttributeInstanceRateDivisor{ vertexAttributeInstanceRateDivisor_ } + , vertexAttributeInstanceRateZeroDivisor{ vertexAttributeInstanceRateZeroDivisor_ } + , indexTypeUint8{ indexTypeUint8_ } + , dynamicRenderingLocalRead{ dynamicRenderingLocalRead_ } + , maintenance5{ maintenance5_ } + , maintenance6{ maintenance6_ } + , pipelineProtectedAccess{ pipelineProtectedAccess_ } + , pipelineRobustness{ pipelineRobustness_ } + , hostImageCopy{ hostImageCopy_ } + , pushDescriptor{ pushDescriptor_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan14Features( PhysicalDeviceVulkan14Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVulkan14Features( VkPhysicalDeviceVulkan14Features const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVulkan14Features( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVulkan14Features & operator=( PhysicalDeviceVulkan14Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVulkan14Features & operator=( VkPhysicalDeviceVulkan14Features const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setGlobalPriorityQuery( Bool32 globalPriorityQuery_ ) & VULKAN_HPP_NOEXCEPT + { + globalPriorityQuery = globalPriorityQuery_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setGlobalPriorityQuery( Bool32 globalPriorityQuery_ ) && VULKAN_HPP_NOEXCEPT + { + globalPriorityQuery = globalPriorityQuery_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setShaderSubgroupRotate( Bool32 shaderSubgroupRotate_ ) & VULKAN_HPP_NOEXCEPT + { + shaderSubgroupRotate = shaderSubgroupRotate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setShaderSubgroupRotate( Bool32 shaderSubgroupRotate_ ) && VULKAN_HPP_NOEXCEPT + { + shaderSubgroupRotate = shaderSubgroupRotate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setShaderSubgroupRotateClustered( Bool32 shaderSubgroupRotateClustered_ ) & VULKAN_HPP_NOEXCEPT + { + shaderSubgroupRotateClustered = shaderSubgroupRotateClustered_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setShaderSubgroupRotateClustered( Bool32 shaderSubgroupRotateClustered_ ) && VULKAN_HPP_NOEXCEPT + { + shaderSubgroupRotateClustered = shaderSubgroupRotateClustered_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setShaderFloatControls2( Bool32 shaderFloatControls2_ ) & VULKAN_HPP_NOEXCEPT + { + shaderFloatControls2 = shaderFloatControls2_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setShaderFloatControls2( Bool32 shaderFloatControls2_ ) && VULKAN_HPP_NOEXCEPT + { + shaderFloatControls2 = shaderFloatControls2_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setShaderExpectAssume( Bool32 shaderExpectAssume_ ) & VULKAN_HPP_NOEXCEPT + { + shaderExpectAssume = shaderExpectAssume_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setShaderExpectAssume( Bool32 shaderExpectAssume_ ) && VULKAN_HPP_NOEXCEPT + { + shaderExpectAssume = shaderExpectAssume_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setRectangularLines( Bool32 rectangularLines_ ) & VULKAN_HPP_NOEXCEPT + { + rectangularLines = rectangularLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setRectangularLines( Bool32 rectangularLines_ ) && VULKAN_HPP_NOEXCEPT + { + rectangularLines = rectangularLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setBresenhamLines( Bool32 bresenhamLines_ ) & VULKAN_HPP_NOEXCEPT + { + bresenhamLines = bresenhamLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setBresenhamLines( Bool32 bresenhamLines_ ) && VULKAN_HPP_NOEXCEPT + { + bresenhamLines = bresenhamLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setSmoothLines( Bool32 smoothLines_ ) & VULKAN_HPP_NOEXCEPT + { + smoothLines = smoothLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setSmoothLines( Bool32 smoothLines_ ) && VULKAN_HPP_NOEXCEPT + { + smoothLines = smoothLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setStippledRectangularLines( Bool32 stippledRectangularLines_ ) & VULKAN_HPP_NOEXCEPT + { + stippledRectangularLines = stippledRectangularLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setStippledRectangularLines( Bool32 stippledRectangularLines_ ) && VULKAN_HPP_NOEXCEPT + { + stippledRectangularLines = stippledRectangularLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setStippledBresenhamLines( Bool32 stippledBresenhamLines_ ) & VULKAN_HPP_NOEXCEPT + { + stippledBresenhamLines = stippledBresenhamLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setStippledBresenhamLines( Bool32 stippledBresenhamLines_ ) && VULKAN_HPP_NOEXCEPT + { + stippledBresenhamLines = stippledBresenhamLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setStippledSmoothLines( Bool32 stippledSmoothLines_ ) & VULKAN_HPP_NOEXCEPT + { + stippledSmoothLines = stippledSmoothLines_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setStippledSmoothLines( Bool32 stippledSmoothLines_ ) && VULKAN_HPP_NOEXCEPT + { + stippledSmoothLines = stippledSmoothLines_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setIndexTypeUint8( Bool32 indexTypeUint8_ ) & VULKAN_HPP_NOEXCEPT + { + indexTypeUint8 = indexTypeUint8_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setIndexTypeUint8( Bool32 indexTypeUint8_ ) && VULKAN_HPP_NOEXCEPT + { + indexTypeUint8 = indexTypeUint8_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setDynamicRenderingLocalRead( Bool32 dynamicRenderingLocalRead_ ) & VULKAN_HPP_NOEXCEPT + { + dynamicRenderingLocalRead = dynamicRenderingLocalRead_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setDynamicRenderingLocalRead( Bool32 dynamicRenderingLocalRead_ ) && VULKAN_HPP_NOEXCEPT + { + dynamicRenderingLocalRead = dynamicRenderingLocalRead_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setMaintenance5( Bool32 maintenance5_ ) & VULKAN_HPP_NOEXCEPT + { + maintenance5 = maintenance5_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setMaintenance5( Bool32 maintenance5_ ) && VULKAN_HPP_NOEXCEPT + { + maintenance5 = maintenance5_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setMaintenance6( Bool32 maintenance6_ ) & VULKAN_HPP_NOEXCEPT + { + maintenance6 = maintenance6_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setMaintenance6( Bool32 maintenance6_ ) && VULKAN_HPP_NOEXCEPT + { + maintenance6 = maintenance6_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setPipelineProtectedAccess( Bool32 pipelineProtectedAccess_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineProtectedAccess = pipelineProtectedAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setPipelineProtectedAccess( Bool32 pipelineProtectedAccess_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineProtectedAccess = pipelineProtectedAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setPipelineRobustness( Bool32 pipelineRobustness_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineRobustness = pipelineRobustness_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setPipelineRobustness( Bool32 pipelineRobustness_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineRobustness = pipelineRobustness_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setHostImageCopy( Bool32 hostImageCopy_ ) & VULKAN_HPP_NOEXCEPT + { + hostImageCopy = hostImageCopy_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setHostImageCopy( Bool32 hostImageCopy_ ) && VULKAN_HPP_NOEXCEPT + { + hostImageCopy = hostImageCopy_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setPushDescriptor( Bool32 pushDescriptor_ ) & VULKAN_HPP_NOEXCEPT + { + pushDescriptor = pushDescriptor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setPushDescriptor( Bool32 pushDescriptor_ ) && VULKAN_HPP_NOEXCEPT + { + pushDescriptor = pushDescriptor_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVulkan14Features const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan14Features &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan14Features const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan14Features *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + globalPriorityQuery, + shaderSubgroupRotate, + shaderSubgroupRotateClustered, + shaderFloatControls2, + shaderExpectAssume, + rectangularLines, + bresenhamLines, + smoothLines, + stippledRectangularLines, + stippledBresenhamLines, + stippledSmoothLines, + vertexAttributeInstanceRateDivisor, + vertexAttributeInstanceRateZeroDivisor, + indexTypeUint8, + dynamicRenderingLocalRead, + maintenance5, + maintenance6, + pipelineProtectedAccess, + pipelineRobustness, + hostImageCopy, + pushDescriptor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVulkan14Features const & ) const = default; +#else + bool operator==( PhysicalDeviceVulkan14Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriorityQuery == rhs.globalPriorityQuery ) && + ( shaderSubgroupRotate == rhs.shaderSubgroupRotate ) && ( shaderSubgroupRotateClustered == rhs.shaderSubgroupRotateClustered ) && + ( shaderFloatControls2 == rhs.shaderFloatControls2 ) && ( shaderExpectAssume == rhs.shaderExpectAssume ) && + ( rectangularLines == rhs.rectangularLines ) && ( bresenhamLines == rhs.bresenhamLines ) && ( smoothLines == rhs.smoothLines ) && + ( stippledRectangularLines == rhs.stippledRectangularLines ) && ( stippledBresenhamLines == rhs.stippledBresenhamLines ) && + ( stippledSmoothLines == rhs.stippledSmoothLines ) && ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) && + ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor ) && ( indexTypeUint8 == rhs.indexTypeUint8 ) && + ( dynamicRenderingLocalRead == rhs.dynamicRenderingLocalRead ) && ( maintenance5 == rhs.maintenance5 ) && ( maintenance6 == rhs.maintenance6 ) && + ( pipelineProtectedAccess == rhs.pipelineProtectedAccess ) && ( pipelineRobustness == rhs.pipelineRobustness ) && + ( hostImageCopy == rhs.hostImageCopy ) && ( pushDescriptor == rhs.pushDescriptor ); +# endif + } + + bool operator!=( PhysicalDeviceVulkan14Features const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVulkan14Features; + void * pNext = {}; + Bool32 globalPriorityQuery = {}; + Bool32 shaderSubgroupRotate = {}; + Bool32 shaderSubgroupRotateClustered = {}; + Bool32 shaderFloatControls2 = {}; + Bool32 shaderExpectAssume = {}; + Bool32 rectangularLines = {}; + Bool32 bresenhamLines = {}; + Bool32 smoothLines = {}; + Bool32 stippledRectangularLines = {}; + Bool32 stippledBresenhamLines = {}; + Bool32 stippledSmoothLines = {}; + Bool32 vertexAttributeInstanceRateDivisor = {}; + Bool32 vertexAttributeInstanceRateZeroDivisor = {}; + Bool32 indexTypeUint8 = {}; + Bool32 dynamicRenderingLocalRead = {}; + Bool32 maintenance5 = {}; + Bool32 maintenance6 = {}; + Bool32 pipelineProtectedAccess = {}; + Bool32 pipelineRobustness = {}; + Bool32 hostImageCopy = {}; + Bool32 pushDescriptor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan14Features; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan14Features; + }; + + // wrapper struct for struct VkPhysicalDeviceVulkan14Properties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan14Properties.html + struct PhysicalDeviceVulkan14Properties + { + using NativeType = VkPhysicalDeviceVulkan14Properties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan14Properties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + PhysicalDeviceVulkan14Properties( uint32_t lineSubPixelPrecisionBits_ = {}, + uint32_t maxVertexAttribDivisor_ = {}, + Bool32 supportsNonZeroFirstInstance_ = {}, + uint32_t maxPushDescriptors_ = {}, + Bool32 dynamicRenderingLocalReadDepthStencilAttachments_ = {}, + Bool32 dynamicRenderingLocalReadMultisampledAttachments_ = {}, + Bool32 earlyFragmentMultisampleCoverageAfterSampleCounting_ = {}, + Bool32 earlyFragmentSampleMaskTestBeforeSampleCounting_ = {}, + Bool32 depthStencilSwizzleOneSupport_ = {}, + Bool32 polygonModePointSize_ = {}, + Bool32 nonStrictSinglePixelWideLinesUseParallelogram_ = {}, + Bool32 nonStrictWideLinesUseParallelogram_ = {}, + Bool32 blockTexelViewCompatibleMultipleLayers_ = {}, + uint32_t maxCombinedImageSamplerDescriptorCount_ = {}, + Bool32 fragmentShadingRateClampCombinerInputs_ = {}, + PipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, + PipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, + PipelineRobustnessBufferBehavior defaultRobustnessVertexInputs_ = PipelineRobustnessBufferBehavior::eDeviceDefault, + PipelineRobustnessImageBehavior defaultRobustnessImages_ = PipelineRobustnessImageBehavior::eDeviceDefault, + uint32_t copySrcLayoutCount_ = {}, + ImageLayout * pCopySrcLayouts_ = {}, + uint32_t copyDstLayoutCount_ = {}, + ImageLayout * pCopyDstLayouts_ = {}, + std::array const & optimalTilingLayoutUUID_ = {}, + Bool32 identicalMemoryTypeRequirements_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , lineSubPixelPrecisionBits{ lineSubPixelPrecisionBits_ } + , maxVertexAttribDivisor{ maxVertexAttribDivisor_ } + , supportsNonZeroFirstInstance{ supportsNonZeroFirstInstance_ } + , maxPushDescriptors{ maxPushDescriptors_ } + , dynamicRenderingLocalReadDepthStencilAttachments{ dynamicRenderingLocalReadDepthStencilAttachments_ } + , dynamicRenderingLocalReadMultisampledAttachments{ dynamicRenderingLocalReadMultisampledAttachments_ } + , earlyFragmentMultisampleCoverageAfterSampleCounting{ earlyFragmentMultisampleCoverageAfterSampleCounting_ } + , earlyFragmentSampleMaskTestBeforeSampleCounting{ earlyFragmentSampleMaskTestBeforeSampleCounting_ } + , depthStencilSwizzleOneSupport{ depthStencilSwizzleOneSupport_ } + , polygonModePointSize{ polygonModePointSize_ } + , nonStrictSinglePixelWideLinesUseParallelogram{ nonStrictSinglePixelWideLinesUseParallelogram_ } + , nonStrictWideLinesUseParallelogram{ nonStrictWideLinesUseParallelogram_ } + , blockTexelViewCompatibleMultipleLayers{ blockTexelViewCompatibleMultipleLayers_ } + , maxCombinedImageSamplerDescriptorCount{ maxCombinedImageSamplerDescriptorCount_ } + , fragmentShadingRateClampCombinerInputs{ fragmentShadingRateClampCombinerInputs_ } + , defaultRobustnessStorageBuffers{ defaultRobustnessStorageBuffers_ } + , defaultRobustnessUniformBuffers{ defaultRobustnessUniformBuffers_ } + , defaultRobustnessVertexInputs{ defaultRobustnessVertexInputs_ } + , defaultRobustnessImages{ defaultRobustnessImages_ } + , copySrcLayoutCount{ copySrcLayoutCount_ } + , pCopySrcLayouts{ pCopySrcLayouts_ } + , copyDstLayoutCount{ copyDstLayoutCount_ } + , pCopyDstLayouts{ pCopyDstLayouts_ } + , optimalTilingLayoutUUID{ optimalTilingLayoutUUID_ } + , identicalMemoryTypeRequirements{ identicalMemoryTypeRequirements_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Properties( PhysicalDeviceVulkan14Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVulkan14Properties( VkPhysicalDeviceVulkan14Properties const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVulkan14Properties( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVulkan14Properties & operator=( PhysicalDeviceVulkan14Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVulkan14Properties & operator=( VkPhysicalDeviceVulkan14Properties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceVulkan14Properties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan14Properties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan14Properties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkan14Properties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + Bool32 const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + lineSubPixelPrecisionBits, + maxVertexAttribDivisor, + supportsNonZeroFirstInstance, + maxPushDescriptors, + dynamicRenderingLocalReadDepthStencilAttachments, + dynamicRenderingLocalReadMultisampledAttachments, + earlyFragmentMultisampleCoverageAfterSampleCounting, + earlyFragmentSampleMaskTestBeforeSampleCounting, + depthStencilSwizzleOneSupport, + polygonModePointSize, + nonStrictSinglePixelWideLinesUseParallelogram, + nonStrictWideLinesUseParallelogram, + blockTexelViewCompatibleMultipleLayers, + maxCombinedImageSamplerDescriptorCount, + fragmentShadingRateClampCombinerInputs, + defaultRobustnessStorageBuffers, + defaultRobustnessUniformBuffers, + defaultRobustnessVertexInputs, + defaultRobustnessImages, + copySrcLayoutCount, + pCopySrcLayouts, + copyDstLayoutCount, + pCopyDstLayouts, + optimalTilingLayoutUUID, + identicalMemoryTypeRequirements ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVulkan14Properties const & ) const = default; +#else + bool operator==( PhysicalDeviceVulkan14Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits ) && + ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ) && ( supportsNonZeroFirstInstance == rhs.supportsNonZeroFirstInstance ) && + ( maxPushDescriptors == rhs.maxPushDescriptors ) && + ( dynamicRenderingLocalReadDepthStencilAttachments == rhs.dynamicRenderingLocalReadDepthStencilAttachments ) && + ( dynamicRenderingLocalReadMultisampledAttachments == rhs.dynamicRenderingLocalReadMultisampledAttachments ) && + ( earlyFragmentMultisampleCoverageAfterSampleCounting == rhs.earlyFragmentMultisampleCoverageAfterSampleCounting ) && + ( earlyFragmentSampleMaskTestBeforeSampleCounting == rhs.earlyFragmentSampleMaskTestBeforeSampleCounting ) && + ( depthStencilSwizzleOneSupport == rhs.depthStencilSwizzleOneSupport ) && ( polygonModePointSize == rhs.polygonModePointSize ) && + ( nonStrictSinglePixelWideLinesUseParallelogram == rhs.nonStrictSinglePixelWideLinesUseParallelogram ) && + ( nonStrictWideLinesUseParallelogram == rhs.nonStrictWideLinesUseParallelogram ) && + ( blockTexelViewCompatibleMultipleLayers == rhs.blockTexelViewCompatibleMultipleLayers ) && + ( maxCombinedImageSamplerDescriptorCount == rhs.maxCombinedImageSamplerDescriptorCount ) && + ( fragmentShadingRateClampCombinerInputs == rhs.fragmentShadingRateClampCombinerInputs ) && + ( defaultRobustnessStorageBuffers == rhs.defaultRobustnessStorageBuffers ) && + ( defaultRobustnessUniformBuffers == rhs.defaultRobustnessUniformBuffers ) && + ( defaultRobustnessVertexInputs == rhs.defaultRobustnessVertexInputs ) && ( defaultRobustnessImages == rhs.defaultRobustnessImages ) && + ( copySrcLayoutCount == rhs.copySrcLayoutCount ) && ( pCopySrcLayouts == rhs.pCopySrcLayouts ) && + ( copyDstLayoutCount == rhs.copyDstLayoutCount ) && ( pCopyDstLayouts == rhs.pCopyDstLayouts ) && + ( optimalTilingLayoutUUID == rhs.optimalTilingLayoutUUID ) && ( identicalMemoryTypeRequirements == rhs.identicalMemoryTypeRequirements ); +# endif + } + + bool operator!=( PhysicalDeviceVulkan14Properties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVulkan14Properties; + void * pNext = {}; + uint32_t lineSubPixelPrecisionBits = {}; + uint32_t maxVertexAttribDivisor = {}; + Bool32 supportsNonZeroFirstInstance = {}; + uint32_t maxPushDescriptors = {}; + Bool32 dynamicRenderingLocalReadDepthStencilAttachments = {}; + Bool32 dynamicRenderingLocalReadMultisampledAttachments = {}; + Bool32 earlyFragmentMultisampleCoverageAfterSampleCounting = {}; + Bool32 earlyFragmentSampleMaskTestBeforeSampleCounting = {}; + Bool32 depthStencilSwizzleOneSupport = {}; + Bool32 polygonModePointSize = {}; + Bool32 nonStrictSinglePixelWideLinesUseParallelogram = {}; + Bool32 nonStrictWideLinesUseParallelogram = {}; + Bool32 blockTexelViewCompatibleMultipleLayers = {}; + uint32_t maxCombinedImageSamplerDescriptorCount = {}; + Bool32 fragmentShadingRateClampCombinerInputs = {}; + PipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; + PipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; + PipelineRobustnessBufferBehavior defaultRobustnessVertexInputs = PipelineRobustnessBufferBehavior::eDeviceDefault; + PipelineRobustnessImageBehavior defaultRobustnessImages = PipelineRobustnessImageBehavior::eDeviceDefault; + uint32_t copySrcLayoutCount = {}; + ImageLayout * pCopySrcLayouts = {}; + uint32_t copyDstLayoutCount = {}; + ImageLayout * pCopyDstLayouts = {}; + ArrayWrapper1D optimalTilingLayoutUUID = {}; + Bool32 identicalMemoryTypeRequirements = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan14Properties; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVulkan14Properties; + }; + + // wrapper struct for struct VkPhysicalDeviceVulkanMemoryModelFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html + struct PhysicalDeviceVulkanMemoryModelFeatures + { + using NativeType = VkPhysicalDeviceVulkanMemoryModelFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkanMemoryModelFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeatures( Bool32 vulkanMemoryModel_ = {}, + Bool32 vulkanMemoryModelDeviceScope_ = {}, + Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vulkanMemoryModel{ vulkanMemoryModel_ } + , vulkanMemoryModelDeviceScope{ vulkanMemoryModelDeviceScope_ } + , vulkanMemoryModelAvailabilityVisibilityChains{ vulkanMemoryModelAvailabilityVisibilityChains_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeatures( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceVulkanMemoryModelFeatures( VkPhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceVulkanMemoryModelFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceVulkanMemoryModelFeatures & operator=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceVulkanMemoryModelFeatures & operator=( VkPhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures & setVulkanMemoryModel( Bool32 vulkanMemoryModel_ ) & VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModel = vulkanMemoryModel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures && setVulkanMemoryModel( Bool32 vulkanMemoryModel_ ) && VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModel = vulkanMemoryModel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures & setVulkanMemoryModelDeviceScope( Bool32 vulkanMemoryModelDeviceScope_ ) & + VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures && setVulkanMemoryModelDeviceScope( Bool32 vulkanMemoryModelDeviceScope_ ) && + VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures & + setVulkanMemoryModelAvailabilityVisibilityChains( Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ ) & + VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures && + setVulkanMemoryModelAvailabilityVisibilityChains( Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ ) && + VULKAN_HPP_NOEXCEPT + { + vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceVulkanMemoryModelFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkanMemoryModelFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkanMemoryModelFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceVulkanMemoryModelFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vulkanMemoryModel, vulkanMemoryModelDeviceScope, vulkanMemoryModelAvailabilityVisibilityChains ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceVulkanMemoryModelFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) && + ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) && + ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ); +# endif + } + + bool operator!=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeatures; + void * pNext = {}; + Bool32 vulkanMemoryModel = {}; + Bool32 vulkanMemoryModelDeviceScope = {}; + Bool32 vulkanMemoryModelAvailabilityVisibilityChains = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceVulkanMemoryModelFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceVulkanMemoryModelFeatures; + }; + + using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures; + + // wrapper struct for struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html + struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR + { + using NativeType = VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( Bool32 workgroupMemoryExplicitLayout_ = {}, + Bool32 workgroupMemoryExplicitLayoutScalarBlockLayout_ = {}, + Bool32 workgroupMemoryExplicitLayout8BitAccess_ = {}, + Bool32 workgroupMemoryExplicitLayout16BitAccess_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , workgroupMemoryExplicitLayout{ workgroupMemoryExplicitLayout_ } + , workgroupMemoryExplicitLayoutScalarBlockLayout{ workgroupMemoryExplicitLayoutScalarBlockLayout_ } + , workgroupMemoryExplicitLayout8BitAccess{ workgroupMemoryExplicitLayout8BitAccess_ } + , workgroupMemoryExplicitLayout16BitAccess{ workgroupMemoryExplicitLayout16BitAccess_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & + operator=( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & + operator=( VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & setWorkgroupMemoryExplicitLayout( Bool32 workgroupMemoryExplicitLayout_ ) & + VULKAN_HPP_NOEXCEPT + { + workgroupMemoryExplicitLayout = workgroupMemoryExplicitLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR && + setWorkgroupMemoryExplicitLayout( Bool32 workgroupMemoryExplicitLayout_ ) && + VULKAN_HPP_NOEXCEPT + { + workgroupMemoryExplicitLayout = workgroupMemoryExplicitLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & + setWorkgroupMemoryExplicitLayoutScalarBlockLayout( Bool32 workgroupMemoryExplicitLayoutScalarBlockLayout_ ) & + VULKAN_HPP_NOEXCEPT + { + workgroupMemoryExplicitLayoutScalarBlockLayout = workgroupMemoryExplicitLayoutScalarBlockLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR && + setWorkgroupMemoryExplicitLayoutScalarBlockLayout( Bool32 workgroupMemoryExplicitLayoutScalarBlockLayout_ ) && + VULKAN_HPP_NOEXCEPT + { + workgroupMemoryExplicitLayoutScalarBlockLayout = workgroupMemoryExplicitLayoutScalarBlockLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & + setWorkgroupMemoryExplicitLayout8BitAccess( Bool32 workgroupMemoryExplicitLayout8BitAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + workgroupMemoryExplicitLayout8BitAccess = workgroupMemoryExplicitLayout8BitAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR && + setWorkgroupMemoryExplicitLayout8BitAccess( Bool32 workgroupMemoryExplicitLayout8BitAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + workgroupMemoryExplicitLayout8BitAccess = workgroupMemoryExplicitLayout8BitAccess_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & + setWorkgroupMemoryExplicitLayout16BitAccess( Bool32 workgroupMemoryExplicitLayout16BitAccess_ ) & + VULKAN_HPP_NOEXCEPT + { + workgroupMemoryExplicitLayout16BitAccess = workgroupMemoryExplicitLayout16BitAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR && + setWorkgroupMemoryExplicitLayout16BitAccess( Bool32 workgroupMemoryExplicitLayout16BitAccess_ ) && + VULKAN_HPP_NOEXCEPT + { + workgroupMemoryExplicitLayout16BitAccess = workgroupMemoryExplicitLayout16BitAccess_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + workgroupMemoryExplicitLayout, + workgroupMemoryExplicitLayoutScalarBlockLayout, + workgroupMemoryExplicitLayout8BitAccess, + workgroupMemoryExplicitLayout16BitAccess ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & ) const = default; +#else + bool operator==( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( workgroupMemoryExplicitLayout == rhs.workgroupMemoryExplicitLayout ) && + ( workgroupMemoryExplicitLayoutScalarBlockLayout == rhs.workgroupMemoryExplicitLayoutScalarBlockLayout ) && + ( workgroupMemoryExplicitLayout8BitAccess == rhs.workgroupMemoryExplicitLayout8BitAccess ) && + ( workgroupMemoryExplicitLayout16BitAccess == rhs.workgroupMemoryExplicitLayout16BitAccess ); +# endif + } + + bool operator!=( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + void * pNext = {}; + Bool32 workgroupMemoryExplicitLayout = {}; + Bool32 workgroupMemoryExplicitLayoutScalarBlockLayout = {}; + Bool32 workgroupMemoryExplicitLayout8BitAccess = {}; + Bool32 workgroupMemoryExplicitLayout16BitAccess = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + }; + + // wrapper struct for struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.html + struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT + { + using NativeType = VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT( Bool32 ycbcr2plane444Formats_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , ycbcr2plane444Formats{ ycbcr2plane444Formats_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT( VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT & operator=( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT & operator=( VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT & setYcbcr2plane444Formats( Bool32 ycbcr2plane444Formats_ ) & VULKAN_HPP_NOEXCEPT + { + ycbcr2plane444Formats = ycbcr2plane444Formats_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT && setYcbcr2plane444Formats( Bool32 ycbcr2plane444Formats_ ) && VULKAN_HPP_NOEXCEPT + { + ycbcr2plane444Formats = ycbcr2plane444Formats_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, ycbcr2plane444Formats ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcr2plane444Formats == rhs.ycbcr2plane444Formats ); +# endif + } + + bool operator!=( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + void * pNext = {}; + Bool32 ycbcr2plane444Formats = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.html + struct PhysicalDeviceYcbcrDegammaFeaturesQCOM + { + using NativeType = VkPhysicalDeviceYcbcrDegammaFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceYcbcrDegammaFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrDegammaFeaturesQCOM( Bool32 ycbcrDegamma_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , ycbcrDegamma{ ycbcrDegamma_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrDegammaFeaturesQCOM( PhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceYcbcrDegammaFeaturesQCOM( VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceYcbcrDegammaFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceYcbcrDegammaFeaturesQCOM & operator=( PhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceYcbcrDegammaFeaturesQCOM & operator=( VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrDegammaFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrDegammaFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrDegammaFeaturesQCOM & setYcbcrDegamma( Bool32 ycbcrDegamma_ ) & VULKAN_HPP_NOEXCEPT + { + ycbcrDegamma = ycbcrDegamma_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrDegammaFeaturesQCOM && setYcbcrDegamma( Bool32 ycbcrDegamma_ ) && VULKAN_HPP_NOEXCEPT + { + ycbcrDegamma = ycbcrDegamma_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceYcbcrDegammaFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, ycbcrDegamma ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceYcbcrDegammaFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrDegamma == rhs.ycbcrDegamma ); +# endif + } + + bool operator!=( PhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceYcbcrDegammaFeaturesQCOM; + void * pNext = {}; + Bool32 ycbcrDegamma = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceYcbcrDegammaFeaturesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceYcbcrDegammaFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html + struct PhysicalDeviceYcbcrImageArraysFeaturesEXT + { + using NativeType = VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( Bool32 ycbcrImageArrays_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , ycbcrImageArrays{ ycbcrImageArrays_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceYcbcrImageArraysFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceYcbcrImageArraysFeaturesEXT & operator=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceYcbcrImageArraysFeaturesEXT & operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrImageArraysFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrImageArraysFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrImageArraysFeaturesEXT & setYcbcrImageArrays( Bool32 ycbcrImageArrays_ ) & VULKAN_HPP_NOEXCEPT + { + ycbcrImageArrays = ycbcrImageArrays_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrImageArraysFeaturesEXT && setYcbcrImageArrays( Bool32 ycbcrImageArrays_ ) && VULKAN_HPP_NOEXCEPT + { + ycbcrImageArrays = ycbcrImageArrays_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, ycbcrImageArrays ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrImageArrays == rhs.ycbcrImageArrays ); +# endif + } + + bool operator!=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT; + void * pNext = {}; + Bool32 ycbcrImageArrays = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.html + struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT + { + using NativeType = VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( Bool32 zeroInitializeDeviceMemory_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , zeroInitializeDeviceMemory{ zeroInitializeDeviceMemory_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & + operator=( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & operator=( VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & setZeroInitializeDeviceMemory( Bool32 zeroInitializeDeviceMemory_ ) & + VULKAN_HPP_NOEXCEPT + { + zeroInitializeDeviceMemory = zeroInitializeDeviceMemory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT && setZeroInitializeDeviceMemory( Bool32 zeroInitializeDeviceMemory_ ) && + VULKAN_HPP_NOEXCEPT + { + zeroInitializeDeviceMemory = zeroInitializeDeviceMemory_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, zeroInitializeDeviceMemory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( zeroInitializeDeviceMemory == rhs.zeroInitializeDeviceMemory ); +# endif + } + + bool operator!=( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + void * pNext = {}; + Bool32 zeroInitializeDeviceMemory = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; + }; + + // wrapper struct for struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.html + struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures + { + using NativeType = VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( Bool32 shaderZeroInitializeWorkgroupMemory_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shaderZeroInitializeWorkgroupMemory{ shaderZeroInitializeWorkgroupMemory_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures & + operator=( PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures & operator=( VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures & + setShaderZeroInitializeWorkgroupMemory( Bool32 shaderZeroInitializeWorkgroupMemory_ ) & + VULKAN_HPP_NOEXCEPT + { + shaderZeroInitializeWorkgroupMemory = shaderZeroInitializeWorkgroupMemory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures && + setShaderZeroInitializeWorkgroupMemory( Bool32 shaderZeroInitializeWorkgroupMemory_ ) && + VULKAN_HPP_NOEXCEPT + { + shaderZeroInitializeWorkgroupMemory = shaderZeroInitializeWorkgroupMemory_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderZeroInitializeWorkgroupMemory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & ) const = default; +#else + bool operator==( PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderZeroInitializeWorkgroupMemory == rhs.shaderZeroInitializeWorkgroupMemory ); +# endif + } + + bool operator!=( PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + void * pNext = {}; + Bool32 shaderZeroInitializeWorkgroupMemory = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + }; +#endif + + template <> + struct CppType + { + using Type = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + }; + + using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + + // wrapper struct for struct VkPipelineBinaryKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryKeyKHR.html + struct PipelineBinaryKeyKHR + { + using NativeType = VkPipelineBinaryKeyKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineBinaryKeyKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR( uint32_t keySize_ = {}, + std::array const & key_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , keySize{ keySize_ } + , key{ key_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR( PipelineBinaryKeyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineBinaryKeyKHR( VkPipelineBinaryKeyKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineBinaryKeyKHR( *reinterpret_cast( &rhs ) ) + { + } + + PipelineBinaryKeyKHR & operator=( PipelineBinaryKeyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineBinaryKeyKHR & operator=( VkPipelineBinaryKeyKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR & setKeySize( uint32_t keySize_ ) & VULKAN_HPP_NOEXCEPT + { + keySize = keySize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR && setKeySize( uint32_t keySize_ ) && VULKAN_HPP_NOEXCEPT + { + keySize = keySize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR & setKey( std::array key_ ) & VULKAN_HPP_NOEXCEPT + { + key = key_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR && setKey( std::array key_ ) && VULKAN_HPP_NOEXCEPT + { + key = key_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineBinaryKeyKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryKeyKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryKeyKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineBinaryKeyKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, keySize, key ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineBinaryKeyKHR const & ) const = default; +#else + bool operator==( PipelineBinaryKeyKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( keySize == rhs.keySize ) && ( key == rhs.key ); +# endif + } + + bool operator!=( PipelineBinaryKeyKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineBinaryKeyKHR; + void * pNext = {}; + uint32_t keySize = {}; + ArrayWrapper1D key = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineBinaryKeyKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineBinaryKeyKHR; + }; + + // wrapper struct for struct VkPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryDataKHR.html + struct PipelineBinaryDataKHR + { + using NativeType = VkPipelineBinaryDataKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineBinaryDataKHR( size_t dataSize_ = {}, void * pData_ = {} ) VULKAN_HPP_NOEXCEPT + : dataSize{ dataSize_ } + , pData{ pData_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineBinaryDataKHR( PipelineBinaryDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineBinaryDataKHR( VkPipelineBinaryDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineBinaryDataKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + PipelineBinaryDataKHR( ArrayProxyNoTemporaries const & data_ ) : dataSize( data_.size() * sizeof( T ) ), pData( data_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineBinaryDataKHR & operator=( PipelineBinaryDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineBinaryDataKHR & operator=( VkPipelineBinaryDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataKHR & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataKHR && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataKHR & setPData( void * pData_ ) & VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataKHR && setPData( void * pData_ ) && VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + PipelineBinaryDataKHR & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT + { + dataSize = data_.size() * sizeof( T ); + pData = data_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineBinaryDataKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryDataKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryDataKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineBinaryDataKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( dataSize, pData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineBinaryDataKHR const & ) const = default; +#else + bool operator==( PipelineBinaryDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); +# endif + } + + bool operator!=( PipelineBinaryDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + size_t dataSize = {}; + void * pData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineBinaryDataKHR; + }; +#endif + + // wrapper struct for struct VkPipelineBinaryKeysAndDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryKeysAndDataKHR.html + struct PipelineBinaryKeysAndDataKHR + { + using NativeType = VkPipelineBinaryKeysAndDataKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR( uint32_t binaryCount_ = {}, + const PipelineBinaryKeyKHR * pPipelineBinaryKeys_ = {}, + const PipelineBinaryDataKHR * pPipelineBinaryData_ = {} ) VULKAN_HPP_NOEXCEPT + : binaryCount{ binaryCount_ } + , pPipelineBinaryKeys{ pPipelineBinaryKeys_ } + , pPipelineBinaryData{ pPipelineBinaryData_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR( PipelineBinaryKeysAndDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineBinaryKeysAndDataKHR( VkPipelineBinaryKeysAndDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineBinaryKeysAndDataKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineBinaryKeysAndDataKHR( ArrayProxyNoTemporaries const & pipelineBinaryKeys_, + ArrayProxyNoTemporaries const & pipelineBinaryData_ = {} ) + : binaryCount( static_cast( pipelineBinaryKeys_.size() ) ) + , pPipelineBinaryKeys( pipelineBinaryKeys_.data() ) + , pPipelineBinaryData( pipelineBinaryData_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( pipelineBinaryKeys_.size() == pipelineBinaryData_.size() ); +# else + if ( pipelineBinaryKeys_.size() != pipelineBinaryData_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::PipelineBinaryKeysAndDataKHR::PipelineBinaryKeysAndDataKHR: pipelineBinaryKeys_.size() != pipelineBinaryData_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineBinaryKeysAndDataKHR & operator=( PipelineBinaryKeysAndDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineBinaryKeysAndDataKHR & operator=( VkPipelineBinaryKeysAndDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR & setBinaryCount( uint32_t binaryCount_ ) & VULKAN_HPP_NOEXCEPT + { + binaryCount = binaryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR && setBinaryCount( uint32_t binaryCount_ ) && VULKAN_HPP_NOEXCEPT + { + binaryCount = binaryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR & setPPipelineBinaryKeys( const PipelineBinaryKeyKHR * pPipelineBinaryKeys_ ) & VULKAN_HPP_NOEXCEPT + { + pPipelineBinaryKeys = pPipelineBinaryKeys_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR && setPPipelineBinaryKeys( const PipelineBinaryKeyKHR * pPipelineBinaryKeys_ ) && VULKAN_HPP_NOEXCEPT + { + pPipelineBinaryKeys = pPipelineBinaryKeys_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineBinaryKeysAndDataKHR & setPipelineBinaryKeys( ArrayProxyNoTemporaries const & pipelineBinaryKeys_ ) VULKAN_HPP_NOEXCEPT + { + binaryCount = static_cast( pipelineBinaryKeys_.size() ); + pPipelineBinaryKeys = pipelineBinaryKeys_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR & setPPipelineBinaryData( const PipelineBinaryDataKHR * pPipelineBinaryData_ ) & VULKAN_HPP_NOEXCEPT + { + pPipelineBinaryData = pPipelineBinaryData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR && setPPipelineBinaryData( const PipelineBinaryDataKHR * pPipelineBinaryData_ ) && VULKAN_HPP_NOEXCEPT + { + pPipelineBinaryData = pPipelineBinaryData_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineBinaryKeysAndDataKHR & setPipelineBinaryData( ArrayProxyNoTemporaries const & pipelineBinaryData_ ) VULKAN_HPP_NOEXCEPT + { + binaryCount = static_cast( pipelineBinaryData_.size() ); + pPipelineBinaryData = pipelineBinaryData_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineBinaryKeysAndDataKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryKeysAndDataKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryKeysAndDataKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineBinaryKeysAndDataKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( binaryCount, pPipelineBinaryKeys, pPipelineBinaryData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineBinaryKeysAndDataKHR const & ) const = default; +#else + bool operator==( PipelineBinaryKeysAndDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( binaryCount == rhs.binaryCount ) && ( pPipelineBinaryKeys == rhs.pPipelineBinaryKeys ) && ( pPipelineBinaryData == rhs.pPipelineBinaryData ); +# endif + } + + bool operator!=( PipelineBinaryKeysAndDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t binaryCount = {}; + const PipelineBinaryKeyKHR * pPipelineBinaryKeys = {}; + const PipelineBinaryDataKHR * pPipelineBinaryData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineBinaryKeysAndDataKHR; + }; +#endif + + // wrapper struct for struct VkPipelineCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateInfoKHR.html + struct PipelineCreateInfoKHR + { + using NativeType = VkPipelineCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineCreateInfoKHR( void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} + + VULKAN_HPP_CONSTEXPR PipelineCreateInfoKHR( PipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineCreateInfoKHR( VkPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + PipelineCreateInfoKHR & operator=( PipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineCreateInfoKHR & operator=( VkPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCreateInfoKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCreateInfoKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineCreateInfoKHR const & ) const = default; +#else + bool operator==( PipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( PipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineCreateInfoKHR; + void * pNext = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineCreateInfoKHR; + }; + + // wrapper struct for struct VkPipelineBinaryCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryCreateInfoKHR.html + struct PipelineBinaryCreateInfoKHR + { + using NativeType = VkPipelineBinaryCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineBinaryCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR( const PipelineBinaryKeysAndDataKHR * pKeysAndDataInfo_ = {}, + Pipeline pipeline_ = {}, + const PipelineCreateInfoKHR * pPipelineCreateInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pKeysAndDataInfo{ pKeysAndDataInfo_ } + , pipeline{ pipeline_ } + , pPipelineCreateInfo{ pPipelineCreateInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR( PipelineBinaryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineBinaryCreateInfoKHR( VkPipelineBinaryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineBinaryCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + PipelineBinaryCreateInfoKHR & operator=( PipelineBinaryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineBinaryCreateInfoKHR & operator=( VkPipelineBinaryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR & setPKeysAndDataInfo( const PipelineBinaryKeysAndDataKHR * pKeysAndDataInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pKeysAndDataInfo = pKeysAndDataInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR && setPKeysAndDataInfo( const PipelineBinaryKeysAndDataKHR * pKeysAndDataInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pKeysAndDataInfo = pKeysAndDataInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR & setPPipelineCreateInfo( const PipelineCreateInfoKHR * pPipelineCreateInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pPipelineCreateInfo = pPipelineCreateInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR && setPPipelineCreateInfo( const PipelineCreateInfoKHR * pPipelineCreateInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pPipelineCreateInfo = pPipelineCreateInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineBinaryCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineBinaryCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pKeysAndDataInfo, pipeline, pPipelineCreateInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineBinaryCreateInfoKHR const & ) const = default; +#else + bool operator==( PipelineBinaryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pKeysAndDataInfo == rhs.pKeysAndDataInfo ) && ( pipeline == rhs.pipeline ) && + ( pPipelineCreateInfo == rhs.pPipelineCreateInfo ); +# endif + } + + bool operator!=( PipelineBinaryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineBinaryCreateInfoKHR; + const void * pNext = {}; + const PipelineBinaryKeysAndDataKHR * pKeysAndDataInfo = {}; + Pipeline pipeline = {}; + const PipelineCreateInfoKHR * pPipelineCreateInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineBinaryCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineBinaryCreateInfoKHR; + }; + + // wrapper struct for struct VkPipelineBinaryDataInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryDataInfoKHR.html + struct PipelineBinaryDataInfoKHR + { + using NativeType = VkPipelineBinaryDataInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineBinaryDataInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineBinaryDataInfoKHR( PipelineBinaryKHR pipelineBinary_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineBinary{ pipelineBinary_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineBinaryDataInfoKHR( PipelineBinaryDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineBinaryDataInfoKHR( VkPipelineBinaryDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineBinaryDataInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + PipelineBinaryDataInfoKHR & operator=( PipelineBinaryDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineBinaryDataInfoKHR & operator=( VkPipelineBinaryDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataInfoKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataInfoKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataInfoKHR & setPipelineBinary( PipelineBinaryKHR pipelineBinary_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineBinary = pipelineBinary_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataInfoKHR && setPipelineBinary( PipelineBinaryKHR pipelineBinary_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineBinary = pipelineBinary_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineBinaryDataInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryDataInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryDataInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineBinaryDataInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineBinary ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineBinaryDataInfoKHR const & ) const = default; +#else + bool operator==( PipelineBinaryDataInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBinary == rhs.pipelineBinary ); +# endif + } + + bool operator!=( PipelineBinaryDataInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineBinaryDataInfoKHR; + void * pNext = {}; + PipelineBinaryKHR pipelineBinary = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineBinaryDataInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineBinaryDataInfoKHR; + }; + + // wrapper struct for struct VkPipelineBinaryHandlesInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryHandlesInfoKHR.html + struct PipelineBinaryHandlesInfoKHR + { + using NativeType = VkPipelineBinaryHandlesInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineBinaryHandlesInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineBinaryHandlesInfoKHR( uint32_t pipelineBinaryCount_ = {}, + PipelineBinaryKHR * pPipelineBinaries_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineBinaryCount{ pipelineBinaryCount_ } + , pPipelineBinaries{ pPipelineBinaries_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineBinaryHandlesInfoKHR( PipelineBinaryHandlesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineBinaryHandlesInfoKHR( VkPipelineBinaryHandlesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineBinaryHandlesInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineBinaryHandlesInfoKHR( ArrayProxyNoTemporaries const & pipelineBinaries_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), pipelineBinaryCount( static_cast( pipelineBinaries_.size() ) ), pPipelineBinaries( pipelineBinaries_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineBinaryHandlesInfoKHR & operator=( PipelineBinaryHandlesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineBinaryHandlesInfoKHR & operator=( VkPipelineBinaryHandlesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR & setPipelineBinaryCount( uint32_t pipelineBinaryCount_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineBinaryCount = pipelineBinaryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR && setPipelineBinaryCount( uint32_t pipelineBinaryCount_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineBinaryCount = pipelineBinaryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR & setPPipelineBinaries( PipelineBinaryKHR * pPipelineBinaries_ ) & VULKAN_HPP_NOEXCEPT + { + pPipelineBinaries = pPipelineBinaries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR && setPPipelineBinaries( PipelineBinaryKHR * pPipelineBinaries_ ) && VULKAN_HPP_NOEXCEPT + { + pPipelineBinaries = pPipelineBinaries_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineBinaryHandlesInfoKHR & setPipelineBinaries( ArrayProxyNoTemporaries const & pipelineBinaries_ ) VULKAN_HPP_NOEXCEPT + { + pipelineBinaryCount = static_cast( pipelineBinaries_.size() ); + pPipelineBinaries = pipelineBinaries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineBinaryHandlesInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryHandlesInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryHandlesInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineBinaryHandlesInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineBinaryCount, pPipelineBinaries ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineBinaryHandlesInfoKHR const & ) const = default; +#else + bool operator==( PipelineBinaryHandlesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBinaryCount == rhs.pipelineBinaryCount ) && + ( pPipelineBinaries == rhs.pPipelineBinaries ); +# endif + } + + bool operator!=( PipelineBinaryHandlesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineBinaryHandlesInfoKHR; + const void * pNext = {}; + uint32_t pipelineBinaryCount = {}; + PipelineBinaryKHR * pPipelineBinaries = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineBinaryHandlesInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineBinaryHandlesInfoKHR; + }; + + // wrapper struct for struct VkPipelineBinaryInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryInfoKHR.html + struct PipelineBinaryInfoKHR + { + using NativeType = VkPipelineBinaryInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineBinaryInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PipelineBinaryInfoKHR( uint32_t binaryCount_ = {}, const PipelineBinaryKHR * pPipelineBinaries_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , binaryCount{ binaryCount_ } + , pPipelineBinaries{ pPipelineBinaries_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineBinaryInfoKHR( PipelineBinaryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineBinaryInfoKHR( VkPipelineBinaryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineBinaryInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineBinaryInfoKHR( ArrayProxyNoTemporaries const & pipelineBinaries_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), binaryCount( static_cast( pipelineBinaries_.size() ) ), pPipelineBinaries( pipelineBinaries_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineBinaryInfoKHR & operator=( PipelineBinaryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineBinaryInfoKHR & operator=( VkPipelineBinaryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR & setBinaryCount( uint32_t binaryCount_ ) & VULKAN_HPP_NOEXCEPT + { + binaryCount = binaryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR && setBinaryCount( uint32_t binaryCount_ ) && VULKAN_HPP_NOEXCEPT + { + binaryCount = binaryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR & setPPipelineBinaries( const PipelineBinaryKHR * pPipelineBinaries_ ) & VULKAN_HPP_NOEXCEPT + { + pPipelineBinaries = pPipelineBinaries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR && setPPipelineBinaries( const PipelineBinaryKHR * pPipelineBinaries_ ) && VULKAN_HPP_NOEXCEPT + { + pPipelineBinaries = pPipelineBinaries_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineBinaryInfoKHR & setPipelineBinaries( ArrayProxyNoTemporaries const & pipelineBinaries_ ) VULKAN_HPP_NOEXCEPT + { + binaryCount = static_cast( pipelineBinaries_.size() ); + pPipelineBinaries = pipelineBinaries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineBinaryInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineBinaryInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineBinaryInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, binaryCount, pPipelineBinaries ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineBinaryInfoKHR const & ) const = default; +#else + bool operator==( PipelineBinaryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( binaryCount == rhs.binaryCount ) && ( pPipelineBinaries == rhs.pPipelineBinaries ); +# endif + } + + bool operator!=( PipelineBinaryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineBinaryInfoKHR; + const void * pNext = {}; + uint32_t binaryCount = {}; + const PipelineBinaryKHR * pPipelineBinaries = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineBinaryInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineBinaryInfoKHR; + }; + + // wrapper struct for struct VkPipelineCacheCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheCreateInfo.html + struct PipelineCacheCreateInfo + { + using NativeType = VkPipelineCacheCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCacheCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = {}, + size_t initialDataSize_ = {}, + const void * pInitialData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , initialDataSize{ initialDataSize_ } + , pInitialData{ pInitialData_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( PipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineCacheCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_, ArrayProxyNoTemporaries const & initialData_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), flags( flags_ ), initialDataSize( initialData_.size() * sizeof( T ) ), pInitialData( initialData_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineCacheCreateInfo & operator=( PipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineCacheCreateInfo & operator=( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo & setFlags( PipelineCacheCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo && setFlags( PipelineCacheCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo & setInitialDataSize( size_t initialDataSize_ ) & VULKAN_HPP_NOEXCEPT + { + initialDataSize = initialDataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo && setInitialDataSize( size_t initialDataSize_ ) && VULKAN_HPP_NOEXCEPT + { + initialDataSize = initialDataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo & setPInitialData( const void * pInitialData_ ) & VULKAN_HPP_NOEXCEPT + { + pInitialData = pInitialData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo && setPInitialData( const void * pInitialData_ ) && VULKAN_HPP_NOEXCEPT + { + pInitialData = pInitialData_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + PipelineCacheCreateInfo & setInitialData( ArrayProxyNoTemporaries const & initialData_ ) VULKAN_HPP_NOEXCEPT + { + initialDataSize = initialData_.size() * sizeof( T ); + pInitialData = initialData_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineCacheCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCacheCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCacheCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineCacheCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, initialDataSize, pInitialData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineCacheCreateInfo const & ) const = default; +#else + bool operator==( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( initialDataSize == rhs.initialDataSize ) && + ( pInitialData == rhs.pInitialData ); +# endif + } + + bool operator!=( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineCacheCreateInfo; + const void * pNext = {}; + PipelineCacheCreateFlags flags = {}; + size_t initialDataSize = {}; + const void * pInitialData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineCacheCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineCacheCreateInfo; + }; + + // wrapper struct for struct VkPipelineCacheHeaderVersionDataGraphQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersionDataGraphQCOM.html + struct PipelineCacheHeaderVersionDataGraphQCOM + { + using NativeType = VkPipelineCacheHeaderVersionDataGraphQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM( + uint32_t headerSize_ = {}, + PipelineCacheHeaderVersion headerVersion_ = PipelineCacheHeaderVersion::eOne, + DataGraphModelCacheTypeQCOM cacheType_ = DataGraphModelCacheTypeQCOM::eGenericBinary, + uint32_t cacheVersion_ = {}, + std::array const & toolchainVersion_ = {} ) VULKAN_HPP_NOEXCEPT + : headerSize{ headerSize_ } + , headerVersion{ headerVersion_ } + , cacheType{ cacheType_ } + , cacheVersion{ cacheVersion_ } + , toolchainVersion{ toolchainVersion_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineCacheHeaderVersionDataGraphQCOM( VkPipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineCacheHeaderVersionDataGraphQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PipelineCacheHeaderVersionDataGraphQCOM & operator=( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineCacheHeaderVersionDataGraphQCOM & operator=( VkPipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setHeaderSize( uint32_t headerSize_ ) & VULKAN_HPP_NOEXCEPT + { + headerSize = headerSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM && setHeaderSize( uint32_t headerSize_ ) && VULKAN_HPP_NOEXCEPT + { + headerSize = headerSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setHeaderVersion( PipelineCacheHeaderVersion headerVersion_ ) & VULKAN_HPP_NOEXCEPT + { + headerVersion = headerVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM && setHeaderVersion( PipelineCacheHeaderVersion headerVersion_ ) && VULKAN_HPP_NOEXCEPT + { + headerVersion = headerVersion_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setCacheType( DataGraphModelCacheTypeQCOM cacheType_ ) & VULKAN_HPP_NOEXCEPT + { + cacheType = cacheType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM && setCacheType( DataGraphModelCacheTypeQCOM cacheType_ ) && VULKAN_HPP_NOEXCEPT + { + cacheType = cacheType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setCacheVersion( uint32_t cacheVersion_ ) & VULKAN_HPP_NOEXCEPT + { + cacheVersion = cacheVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM && setCacheVersion( uint32_t cacheVersion_ ) && VULKAN_HPP_NOEXCEPT + { + cacheVersion = cacheVersion_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & + setToolchainVersion( std::array toolchainVersion_ ) & + VULKAN_HPP_NOEXCEPT + { + toolchainVersion = toolchainVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM && + setToolchainVersion( std::array toolchainVersion_ ) && + VULKAN_HPP_NOEXCEPT + { + toolchainVersion = toolchainVersion_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineCacheHeaderVersionDataGraphQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCacheHeaderVersionDataGraphQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCacheHeaderVersionDataGraphQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineCacheHeaderVersionDataGraphQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( headerSize, headerVersion, cacheType, cacheVersion, toolchainVersion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineCacheHeaderVersionDataGraphQCOM const & ) const = default; +#else + bool operator==( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && ( cacheType == rhs.cacheType ) && + ( cacheVersion == rhs.cacheVersion ) && ( toolchainVersion == rhs.toolchainVersion ); +# endif + } + + bool operator!=( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t headerSize = {}; + PipelineCacheHeaderVersion headerVersion = PipelineCacheHeaderVersion::eOne; + DataGraphModelCacheTypeQCOM cacheType = DataGraphModelCacheTypeQCOM::eGenericBinary; + uint32_t cacheVersion = {}; + ArrayWrapper1D toolchainVersion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineCacheHeaderVersionDataGraphQCOM; + }; +#endif + + // wrapper struct for struct VkPipelineCacheHeaderVersionOne, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersionOne.html + struct PipelineCacheHeaderVersionOne + { + using NativeType = VkPipelineCacheHeaderVersionOne; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne( uint32_t headerSize_ = {}, + PipelineCacheHeaderVersion headerVersion_ = PipelineCacheHeaderVersion::eOne, + uint32_t vendorID_ = {}, + uint32_t deviceID_ = {}, + std::array const & pipelineCacheUUID_ = {} ) VULKAN_HPP_NOEXCEPT + : headerSize{ headerSize_ } + , headerVersion{ headerVersion_ } + , vendorID{ vendorID_ } + , deviceID{ deviceID_ } + , pipelineCacheUUID{ pipelineCacheUUID_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne( PipelineCacheHeaderVersionOne const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineCacheHeaderVersionOne( VkPipelineCacheHeaderVersionOne const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineCacheHeaderVersionOne( *reinterpret_cast( &rhs ) ) + { + } + + PipelineCacheHeaderVersionOne & operator=( PipelineCacheHeaderVersionOne const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineCacheHeaderVersionOne & operator=( VkPipelineCacheHeaderVersionOne const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne & setHeaderSize( uint32_t headerSize_ ) & VULKAN_HPP_NOEXCEPT + { + headerSize = headerSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne && setHeaderSize( uint32_t headerSize_ ) && VULKAN_HPP_NOEXCEPT + { + headerSize = headerSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne & setHeaderVersion( PipelineCacheHeaderVersion headerVersion_ ) & VULKAN_HPP_NOEXCEPT + { + headerVersion = headerVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne && setHeaderVersion( PipelineCacheHeaderVersion headerVersion_ ) && VULKAN_HPP_NOEXCEPT + { + headerVersion = headerVersion_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne & setVendorID( uint32_t vendorID_ ) & VULKAN_HPP_NOEXCEPT + { + vendorID = vendorID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne && setVendorID( uint32_t vendorID_ ) && VULKAN_HPP_NOEXCEPT + { + vendorID = vendorID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne & setDeviceID( uint32_t deviceID_ ) & VULKAN_HPP_NOEXCEPT + { + deviceID = deviceID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne && setDeviceID( uint32_t deviceID_ ) && VULKAN_HPP_NOEXCEPT + { + deviceID = deviceID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne & setPipelineCacheUUID( std::array pipelineCacheUUID_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineCacheUUID = pipelineCacheUUID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne && setPipelineCacheUUID( std::array pipelineCacheUUID_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineCacheUUID = pipelineCacheUUID_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineCacheHeaderVersionOne const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCacheHeaderVersionOne &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCacheHeaderVersionOne const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineCacheHeaderVersionOne *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( headerSize, headerVersion, vendorID, deviceID, pipelineCacheUUID ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineCacheHeaderVersionOne const & ) const = default; +#else + bool operator==( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && + ( pipelineCacheUUID == rhs.pipelineCacheUUID ); +# endif + } + + bool operator!=( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t headerSize = {}; + PipelineCacheHeaderVersion headerVersion = PipelineCacheHeaderVersion::eOne; + uint32_t vendorID = {}; + uint32_t deviceID = {}; + ArrayWrapper1D pipelineCacheUUID = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineCacheHeaderVersionOne; + }; +#endif + + // wrapper struct for struct VkPipelineColorBlendAdvancedStateCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendAdvancedStateCreateInfoEXT.html + struct PipelineColorBlendAdvancedStateCreateInfoEXT + { + using NativeType = VkPipelineColorBlendAdvancedStateCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = {}, + Bool32 dstPremultiplied_ = {}, + BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcPremultiplied{ srcPremultiplied_ } + , dstPremultiplied{ dstPremultiplied_ } + , blendOverlap{ blendOverlap_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineColorBlendAdvancedStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PipelineColorBlendAdvancedStateCreateInfoEXT & operator=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineColorBlendAdvancedStateCreateInfoEXT & operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT & setSrcPremultiplied( Bool32 srcPremultiplied_ ) & VULKAN_HPP_NOEXCEPT + { + srcPremultiplied = srcPremultiplied_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT && setSrcPremultiplied( Bool32 srcPremultiplied_ ) && VULKAN_HPP_NOEXCEPT + { + srcPremultiplied = srcPremultiplied_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT & setDstPremultiplied( Bool32 dstPremultiplied_ ) & VULKAN_HPP_NOEXCEPT + { + dstPremultiplied = dstPremultiplied_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT && setDstPremultiplied( Bool32 dstPremultiplied_ ) && VULKAN_HPP_NOEXCEPT + { + dstPremultiplied = dstPremultiplied_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT & setBlendOverlap( BlendOverlapEXT blendOverlap_ ) & VULKAN_HPP_NOEXCEPT + { + blendOverlap = blendOverlap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT && setBlendOverlap( BlendOverlapEXT blendOverlap_ ) && VULKAN_HPP_NOEXCEPT + { + blendOverlap = blendOverlap_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineColorBlendAdvancedStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcPremultiplied, dstPremultiplied, blendOverlap ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineColorBlendAdvancedStateCreateInfoEXT const & ) const = default; +#else + bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcPremultiplied == rhs.srcPremultiplied ) && ( dstPremultiplied == rhs.dstPremultiplied ) && + ( blendOverlap == rhs.blendOverlap ); +# endif + } + + bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; + const void * pNext = {}; + Bool32 srcPremultiplied = {}; + Bool32 dstPremultiplied = {}; + BlendOverlapEXT blendOverlap = BlendOverlapEXT::eUncorrelated; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineColorBlendAdvancedStateCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineColorBlendAdvancedStateCreateInfoEXT; + }; + + // wrapper struct for struct VkPipelineColorWriteCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorWriteCreateInfoEXT.html + struct PipelineColorWriteCreateInfoEXT + { + using NativeType = VkPipelineColorWriteCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineColorWriteCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineColorWriteCreateInfoEXT( uint32_t attachmentCount_ = {}, + const Bool32 * pColorWriteEnables_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , attachmentCount{ attachmentCount_ } + , pColorWriteEnables{ pColorWriteEnables_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineColorWriteCreateInfoEXT( PipelineColorWriteCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineColorWriteCreateInfoEXT( VkPipelineColorWriteCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineColorWriteCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineColorWriteCreateInfoEXT( ArrayProxyNoTemporaries const & colorWriteEnables_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), attachmentCount( static_cast( colorWriteEnables_.size() ) ), pColorWriteEnables( colorWriteEnables_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineColorWriteCreateInfoEXT & operator=( PipelineColorWriteCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineColorWriteCreateInfoEXT & operator=( VkPipelineColorWriteCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT & setPColorWriteEnables( const Bool32 * pColorWriteEnables_ ) & VULKAN_HPP_NOEXCEPT + { + pColorWriteEnables = pColorWriteEnables_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT && setPColorWriteEnables( const Bool32 * pColorWriteEnables_ ) && VULKAN_HPP_NOEXCEPT + { + pColorWriteEnables = pColorWriteEnables_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineColorWriteCreateInfoEXT & setColorWriteEnables( ArrayProxyNoTemporaries const & colorWriteEnables_ ) VULKAN_HPP_NOEXCEPT + { + attachmentCount = static_cast( colorWriteEnables_.size() ); + pColorWriteEnables = colorWriteEnables_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineColorWriteCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineColorWriteCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineColorWriteCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineColorWriteCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachmentCount, pColorWriteEnables ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineColorWriteCreateInfoEXT const & ) const = default; +#else + bool operator==( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && ( pColorWriteEnables == rhs.pColorWriteEnables ); +# endif + } + + bool operator!=( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineColorWriteCreateInfoEXT; + const void * pNext = {}; + uint32_t attachmentCount = {}; + const Bool32 * pColorWriteEnables = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineColorWriteCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineColorWriteCreateInfoEXT; + }; + + // wrapper struct for struct VkPipelineCompilerControlCreateInfoAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCompilerControlCreateInfoAMD.html + struct PipelineCompilerControlCreateInfoAMD + { + using NativeType = VkPipelineCompilerControlCreateInfoAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCompilerControlCreateInfoAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( PipelineCompilerControlFlagsAMD compilerControlFlags_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , compilerControlFlags{ compilerControlFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( PipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineCompilerControlCreateInfoAMD( *reinterpret_cast( &rhs ) ) + { + } + + PipelineCompilerControlCreateInfoAMD & operator=( PipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineCompilerControlCreateInfoAMD & operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCompilerControlCreateInfoAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCompilerControlCreateInfoAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCompilerControlCreateInfoAMD & setCompilerControlFlags( PipelineCompilerControlFlagsAMD compilerControlFlags_ ) & + VULKAN_HPP_NOEXCEPT + { + compilerControlFlags = compilerControlFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCompilerControlCreateInfoAMD && setCompilerControlFlags( PipelineCompilerControlFlagsAMD compilerControlFlags_ ) && + VULKAN_HPP_NOEXCEPT + { + compilerControlFlags = compilerControlFlags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineCompilerControlCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCompilerControlCreateInfoAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCompilerControlCreateInfoAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineCompilerControlCreateInfoAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, compilerControlFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineCompilerControlCreateInfoAMD const & ) const = default; +#else + bool operator==( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compilerControlFlags == rhs.compilerControlFlags ); +# endif + } + + bool operator!=( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD; + const void * pNext = {}; + PipelineCompilerControlFlagsAMD compilerControlFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineCompilerControlCreateInfoAMD; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineCompilerControlCreateInfoAMD; + }; + + // wrapper struct for struct VkPipelineCoverageModulationStateCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageModulationStateCreateInfoNV.html + struct PipelineCoverageModulationStateCreateInfoNV + { + using NativeType = VkPipelineCoverageModulationStateCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = {}, + CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone, + Bool32 coverageModulationTableEnable_ = {}, + uint32_t coverageModulationTableCount_ = {}, + const float * pCoverageModulationTable_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , coverageModulationMode{ coverageModulationMode_ } + , coverageModulationTableEnable{ coverageModulationTableEnable_ } + , coverageModulationTableCount{ coverageModulationTableCount_ } + , pCoverageModulationTable{ pCoverageModulationTable_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineCoverageModulationStateCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_, + CoverageModulationModeNV coverageModulationMode_, + Bool32 coverageModulationTableEnable_, + ArrayProxyNoTemporaries const & coverageModulationTable_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , coverageModulationMode( coverageModulationMode_ ) + , coverageModulationTableEnable( coverageModulationTableEnable_ ) + , coverageModulationTableCount( static_cast( coverageModulationTable_.size() ) ) + , pCoverageModulationTable( coverageModulationTable_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineCoverageModulationStateCreateInfoNV & operator=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineCoverageModulationStateCreateInfoNV & operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ ) && + VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ ) & + VULKAN_HPP_NOEXCEPT + { + coverageModulationMode = coverageModulationMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ ) && + VULKAN_HPP_NOEXCEPT + { + coverageModulationMode = coverageModulationMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + coverageModulationTableEnable = coverageModulationTableEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + coverageModulationTableEnable = coverageModulationTableEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ ) & + VULKAN_HPP_NOEXCEPT + { + coverageModulationTableCount = coverageModulationTableCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ ) && + VULKAN_HPP_NOEXCEPT + { + coverageModulationTableCount = coverageModulationTableCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setPCoverageModulationTable( const float * pCoverageModulationTable_ ) & + VULKAN_HPP_NOEXCEPT + { + pCoverageModulationTable = pCoverageModulationTable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setPCoverageModulationTable( const float * pCoverageModulationTable_ ) && + VULKAN_HPP_NOEXCEPT + { + pCoverageModulationTable = pCoverageModulationTable_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineCoverageModulationStateCreateInfoNV & + setCoverageModulationTable( ArrayProxyNoTemporaries const & coverageModulationTable_ ) VULKAN_HPP_NOEXCEPT + { + coverageModulationTableCount = static_cast( coverageModulationTable_.size() ); + pCoverageModulationTable = coverageModulationTable_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineCoverageModulationStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCoverageModulationStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCoverageModulationStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineCoverageModulationStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, coverageModulationMode, coverageModulationTableEnable, coverageModulationTableCount, pCoverageModulationTable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineCoverageModulationStateCreateInfoNV const & ) const = default; +#else + bool operator==( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( coverageModulationMode == rhs.coverageModulationMode ) && + ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) && ( coverageModulationTableCount == rhs.coverageModulationTableCount ) && + ( pCoverageModulationTable == rhs.pCoverageModulationTable ); +# endif + } + + bool operator!=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; + const void * pNext = {}; + PipelineCoverageModulationStateCreateFlagsNV flags = {}; + CoverageModulationModeNV coverageModulationMode = CoverageModulationModeNV::eNone; + Bool32 coverageModulationTableEnable = {}; + uint32_t coverageModulationTableCount = {}; + const float * pCoverageModulationTable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineCoverageModulationStateCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineCoverageModulationStateCreateInfoNV; + }; + + // wrapper struct for struct VkPipelineCoverageReductionStateCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageReductionStateCreateInfoNV.html + struct PipelineCoverageReductionStateCreateInfoNV + { + using NativeType = VkPipelineCoverageReductionStateCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageReductionStateCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( PipelineCoverageReductionStateCreateFlagsNV flags_ = {}, + CoverageReductionModeNV coverageReductionMode_ = CoverageReductionModeNV::eMerge, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , coverageReductionMode{ coverageReductionMode_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( PipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineCoverageReductionStateCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + PipelineCoverageReductionStateCreateInfoNV & operator=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineCoverageReductionStateCreateInfoNV & operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV & setFlags( PipelineCoverageReductionStateCreateFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV && setFlags( PipelineCoverageReductionStateCreateFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV & setCoverageReductionMode( CoverageReductionModeNV coverageReductionMode_ ) & + VULKAN_HPP_NOEXCEPT + { + coverageReductionMode = coverageReductionMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV && setCoverageReductionMode( CoverageReductionModeNV coverageReductionMode_ ) && + VULKAN_HPP_NOEXCEPT + { + coverageReductionMode = coverageReductionMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineCoverageReductionStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCoverageReductionStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCoverageReductionStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineCoverageReductionStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, coverageReductionMode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineCoverageReductionStateCreateInfoNV const & ) const = default; +#else + bool operator==( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( coverageReductionMode == rhs.coverageReductionMode ); +# endif + } + + bool operator!=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV; + const void * pNext = {}; + PipelineCoverageReductionStateCreateFlagsNV flags = {}; + CoverageReductionModeNV coverageReductionMode = CoverageReductionModeNV::eMerge; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineCoverageReductionStateCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineCoverageReductionStateCreateInfoNV; + }; + + // wrapper struct for struct VkPipelineCoverageToColorStateCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageToColorStateCreateInfoNV.html + struct PipelineCoverageToColorStateCreateInfoNV + { + using NativeType = VkPipelineCoverageToColorStateCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = {}, + Bool32 coverageToColorEnable_ = {}, + uint32_t coverageToColorLocation_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , coverageToColorEnable{ coverageToColorEnable_ } + , coverageToColorLocation{ coverageToColorLocation_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineCoverageToColorStateCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + PipelineCoverageToColorStateCreateInfoNV & operator=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineCoverageToColorStateCreateInfoNV & operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV & setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV && setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorEnable( Bool32 coverageToColorEnable_ ) & VULKAN_HPP_NOEXCEPT + { + coverageToColorEnable = coverageToColorEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV && setCoverageToColorEnable( Bool32 coverageToColorEnable_ ) && VULKAN_HPP_NOEXCEPT + { + coverageToColorEnable = coverageToColorEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorLocation( uint32_t coverageToColorLocation_ ) & VULKAN_HPP_NOEXCEPT + { + coverageToColorLocation = coverageToColorLocation_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV && setCoverageToColorLocation( uint32_t coverageToColorLocation_ ) && VULKAN_HPP_NOEXCEPT + { + coverageToColorLocation = coverageToColorLocation_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineCoverageToColorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCoverageToColorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCoverageToColorStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineCoverageToColorStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, coverageToColorEnable, coverageToColorLocation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineCoverageToColorStateCreateInfoNV const & ) const = default; +#else + bool operator==( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( coverageToColorEnable == rhs.coverageToColorEnable ) && + ( coverageToColorLocation == rhs.coverageToColorLocation ); +# endif + } + + bool operator!=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; + const void * pNext = {}; + PipelineCoverageToColorStateCreateFlagsNV flags = {}; + Bool32 coverageToColorEnable = {}; + uint32_t coverageToColorLocation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineCoverageToColorStateCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineCoverageToColorStateCreateInfoNV; + }; + + // wrapper struct for struct VkPipelineCreateFlags2CreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlags2CreateInfo.html + struct PipelineCreateFlags2CreateInfo + { + using NativeType = VkPipelineCreateFlags2CreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCreateFlags2CreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineCreateFlags2CreateInfo( PipelineCreateFlags2 flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineCreateFlags2CreateInfo( PipelineCreateFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineCreateFlags2CreateInfo( VkPipelineCreateFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineCreateFlags2CreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PipelineCreateFlags2CreateInfo & operator=( PipelineCreateFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineCreateFlags2CreateInfo & operator=( VkPipelineCreateFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCreateFlags2CreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCreateFlags2CreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCreateFlags2CreateInfo & setFlags( PipelineCreateFlags2 flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCreateFlags2CreateInfo && setFlags( PipelineCreateFlags2 flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineCreateFlags2CreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCreateFlags2CreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCreateFlags2CreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineCreateFlags2CreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineCreateFlags2CreateInfo const & ) const = default; +#else + bool operator==( PipelineCreateFlags2CreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( PipelineCreateFlags2CreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineCreateFlags2CreateInfo; + const void * pNext = {}; + PipelineCreateFlags2 flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineCreateFlags2CreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineCreateFlags2CreateInfo; + }; + + using PipelineCreateFlags2CreateInfoKHR = PipelineCreateFlags2CreateInfo; + + // wrapper struct for struct VkPipelineCreationFeedback, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreationFeedback.html + struct PipelineCreationFeedback + { + using NativeType = VkPipelineCreationFeedback; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineCreationFeedback( PipelineCreationFeedbackFlags flags_ = {}, uint64_t duration_ = {} ) VULKAN_HPP_NOEXCEPT + : flags{ flags_ } + , duration{ duration_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineCreationFeedback( PipelineCreationFeedback const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineCreationFeedback( VkPipelineCreationFeedback const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineCreationFeedback( *reinterpret_cast( &rhs ) ) + { + } + + PipelineCreationFeedback & operator=( PipelineCreationFeedback const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineCreationFeedback & operator=( VkPipelineCreationFeedback const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPipelineCreationFeedback const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCreationFeedback &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCreationFeedback const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineCreationFeedback *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( flags, duration ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineCreationFeedback const & ) const = default; +#else + bool operator==( PipelineCreationFeedback const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( flags == rhs.flags ) && ( duration == rhs.duration ); +# endif + } + + bool operator!=( PipelineCreationFeedback const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + PipelineCreationFeedbackFlags flags = {}; + uint64_t duration = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineCreationFeedback; + }; +#endif + using PipelineCreationFeedbackEXT = PipelineCreationFeedback; + + // wrapper struct for struct VkPipelineCreationFeedbackCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreationFeedbackCreateInfo.html + struct PipelineCreationFeedbackCreateInfo + { + using NativeType = VkPipelineCreationFeedbackCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCreationFeedbackCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfo( PipelineCreationFeedback * pPipelineCreationFeedback_ = {}, + uint32_t pipelineStageCreationFeedbackCount_ = {}, + PipelineCreationFeedback * pPipelineStageCreationFeedbacks_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pPipelineCreationFeedback{ pPipelineCreationFeedback_ } + , pipelineStageCreationFeedbackCount{ pipelineStageCreationFeedbackCount_ } + , pPipelineStageCreationFeedbacks{ pPipelineStageCreationFeedbacks_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfo( PipelineCreationFeedbackCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineCreationFeedbackCreateInfo( VkPipelineCreationFeedbackCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineCreationFeedbackCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineCreationFeedbackCreateInfo( PipelineCreationFeedback * pPipelineCreationFeedback_, + ArrayProxyNoTemporaries const & pipelineStageCreationFeedbacks_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , pPipelineCreationFeedback( pPipelineCreationFeedback_ ) + , pipelineStageCreationFeedbackCount( static_cast( pipelineStageCreationFeedbacks_.size() ) ) + , pPipelineStageCreationFeedbacks( pipelineStageCreationFeedbacks_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineCreationFeedbackCreateInfo & operator=( PipelineCreationFeedbackCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineCreationFeedbackCreateInfo & operator=( VkPipelineCreationFeedbackCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo & setPPipelineCreationFeedback( PipelineCreationFeedback * pPipelineCreationFeedback_ ) & + VULKAN_HPP_NOEXCEPT + { + pPipelineCreationFeedback = pPipelineCreationFeedback_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo && setPPipelineCreationFeedback( PipelineCreationFeedback * pPipelineCreationFeedback_ ) && + VULKAN_HPP_NOEXCEPT + { + pPipelineCreationFeedback = pPipelineCreationFeedback_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo & setPipelineStageCreationFeedbackCount( uint32_t pipelineStageCreationFeedbackCount_ ) & + VULKAN_HPP_NOEXCEPT + { + pipelineStageCreationFeedbackCount = pipelineStageCreationFeedbackCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo && setPipelineStageCreationFeedbackCount( uint32_t pipelineStageCreationFeedbackCount_ ) && + VULKAN_HPP_NOEXCEPT + { + pipelineStageCreationFeedbackCount = pipelineStageCreationFeedbackCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo & + setPPipelineStageCreationFeedbacks( PipelineCreationFeedback * pPipelineStageCreationFeedbacks_ ) & + VULKAN_HPP_NOEXCEPT + { + pPipelineStageCreationFeedbacks = pPipelineStageCreationFeedbacks_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo && + setPPipelineStageCreationFeedbacks( PipelineCreationFeedback * pPipelineStageCreationFeedbacks_ ) && + VULKAN_HPP_NOEXCEPT + { + pPipelineStageCreationFeedbacks = pPipelineStageCreationFeedbacks_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineCreationFeedbackCreateInfo & + setPipelineStageCreationFeedbacks( ArrayProxyNoTemporaries const & pipelineStageCreationFeedbacks_ ) VULKAN_HPP_NOEXCEPT + { + pipelineStageCreationFeedbackCount = static_cast( pipelineStageCreationFeedbacks_.size() ); + pPipelineStageCreationFeedbacks = pipelineStageCreationFeedbacks_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineCreationFeedbackCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCreationFeedbackCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineCreationFeedbackCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineCreationFeedbackCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pPipelineCreationFeedback, pipelineStageCreationFeedbackCount, pPipelineStageCreationFeedbacks ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineCreationFeedbackCreateInfo const & ) const = default; +#else + bool operator==( PipelineCreationFeedbackCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pPipelineCreationFeedback == rhs.pPipelineCreationFeedback ) && + ( pipelineStageCreationFeedbackCount == rhs.pipelineStageCreationFeedbackCount ) && + ( pPipelineStageCreationFeedbacks == rhs.pPipelineStageCreationFeedbacks ); +# endif + } + + bool operator!=( PipelineCreationFeedbackCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfo; + const void * pNext = {}; + PipelineCreationFeedback * pPipelineCreationFeedback = {}; + uint32_t pipelineStageCreationFeedbackCount = {}; + PipelineCreationFeedback * pPipelineStageCreationFeedbacks = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineCreationFeedbackCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineCreationFeedbackCreateInfo; + }; + + using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo; + + // wrapper struct for struct VkPipelineDiscardRectangleStateCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDiscardRectangleStateCreateInfoEXT.html + struct PipelineDiscardRectangleStateCreateInfoEXT + { + using NativeType = VkPipelineDiscardRectangleStateCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = {}, + DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive, + uint32_t discardRectangleCount_ = {}, + const Rect2D * pDiscardRectangles_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , discardRectangleMode{ discardRectangleMode_ } + , discardRectangleCount{ discardRectangleCount_ } + , pDiscardRectangles{ pDiscardRectangles_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineDiscardRectangleStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_, + DiscardRectangleModeEXT discardRectangleMode_, + ArrayProxyNoTemporaries const & discardRectangles_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , discardRectangleMode( discardRectangleMode_ ) + , discardRectangleCount( static_cast( discardRectangles_.size() ) ) + , pDiscardRectangles( discardRectangles_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineDiscardRectangleStateCreateInfoEXT & operator=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineDiscardRectangleStateCreateInfoEXT & operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT & setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT && setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ ) & + VULKAN_HPP_NOEXCEPT + { + discardRectangleMode = discardRectangleMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT && setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ ) && + VULKAN_HPP_NOEXCEPT + { + discardRectangleMode = discardRectangleMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleCount( uint32_t discardRectangleCount_ ) & VULKAN_HPP_NOEXCEPT + { + discardRectangleCount = discardRectangleCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT && setDiscardRectangleCount( uint32_t discardRectangleCount_ ) && VULKAN_HPP_NOEXCEPT + { + discardRectangleCount = discardRectangleCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT & setPDiscardRectangles( const Rect2D * pDiscardRectangles_ ) & VULKAN_HPP_NOEXCEPT + { + pDiscardRectangles = pDiscardRectangles_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT && setPDiscardRectangles( const Rect2D * pDiscardRectangles_ ) && VULKAN_HPP_NOEXCEPT + { + pDiscardRectangles = pDiscardRectangles_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangles( ArrayProxyNoTemporaries const & discardRectangles_ ) VULKAN_HPP_NOEXCEPT + { + discardRectangleCount = static_cast( discardRectangles_.size() ); + pDiscardRectangles = discardRectangles_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineDiscardRectangleStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineDiscardRectangleStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineDiscardRectangleStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineDiscardRectangleStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, discardRectangleMode, discardRectangleCount, pDiscardRectangles ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineDiscardRectangleStateCreateInfoEXT const & ) const = default; +#else + bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( discardRectangleMode == rhs.discardRectangleMode ) && + ( discardRectangleCount == rhs.discardRectangleCount ) && ( pDiscardRectangles == rhs.pDiscardRectangles ); +# endif + } + + bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; + const void * pNext = {}; + PipelineDiscardRectangleStateCreateFlagsEXT flags = {}; + DiscardRectangleModeEXT discardRectangleMode = DiscardRectangleModeEXT::eInclusive; + uint32_t discardRectangleCount = {}; + const Rect2D * pDiscardRectangles = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineDiscardRectangleStateCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineDiscardRectangleStateCreateInfoEXT; + }; + + // wrapper struct for struct VkPipelineExecutableInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineExecutableInfoKHR.html + struct PipelineExecutableInfoKHR + { + using NativeType = VkPipelineExecutableInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( Pipeline pipeline_ = {}, uint32_t executableIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipeline{ pipeline_ } + , executableIndex{ executableIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( PipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineExecutableInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + PipelineExecutableInfoKHR & operator=( PipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineExecutableInfoKHR & operator=( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR & setExecutableIndex( uint32_t executableIndex_ ) & VULKAN_HPP_NOEXCEPT + { + executableIndex = executableIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR && setExecutableIndex( uint32_t executableIndex_ ) && VULKAN_HPP_NOEXCEPT + { + executableIndex = executableIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineExecutableInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutableInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutableInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineExecutableInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipeline, executableIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineExecutableInfoKHR const & ) const = default; +#else + bool operator==( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ) && ( executableIndex == rhs.executableIndex ); +# endif + } + + bool operator!=( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineExecutableInfoKHR; + const void * pNext = {}; + Pipeline pipeline = {}; + uint32_t executableIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineExecutableInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineExecutableInfoKHR; + }; + + // wrapper struct for struct VkPipelineExecutableInternalRepresentationKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineExecutableInternalRepresentationKHR.html + struct PipelineExecutableInternalRepresentationKHR + { + using NativeType = VkPipelineExecutableInternalRepresentationKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableInternalRepresentationKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array const & name_ = {}, + std::array const & description_ = {}, + Bool32 isText_ = {}, + size_t dataSize_ = {}, + void * pData_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , name{ name_ } + , description{ description_ } + , isText{ isText_ } + , dataSize{ dataSize_ } + , pData{ pData_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + PipelineExecutableInternalRepresentationKHR( PipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineExecutableInternalRepresentationKHR( *reinterpret_cast( &rhs ) ) + { + } + + PipelineExecutableInternalRepresentationKHR & operator=( PipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineExecutableInternalRepresentationKHR & operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPipelineExecutableInternalRepresentationKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutableInternalRepresentationKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutableInternalRepresentationKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineExecutableInternalRepresentationKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &, + Bool32 const &, + size_t const &, + void * const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, name, description, isText, dataSize, pData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = isText <=> rhs.isText; cmp != 0 ) + return cmp; + if ( auto cmp = dataSize <=> rhs.dataSize; cmp != 0 ) + return cmp; + if ( auto cmp = pData <=> rhs.pData; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( strcmp( name, rhs.name ) == 0 ) && ( strcmp( description, rhs.description ) == 0 ) && + ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); + } + + bool operator!=( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR; + void * pNext = {}; + ArrayWrapper1D name = {}; + ArrayWrapper1D description = {}; + Bool32 isText = {}; + size_t dataSize = {}; + void * pData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineExecutableInternalRepresentationKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineExecutableInternalRepresentationKHR; + }; + + // wrapper struct for struct VkPipelineExecutablePropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineExecutablePropertiesKHR.html + struct PipelineExecutablePropertiesKHR + { + using NativeType = VkPipelineExecutablePropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutablePropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelineExecutablePropertiesKHR( ShaderStageFlags stages_ = {}, + std::array const & name_ = {}, + std::array const & description_ = {}, + uint32_t subgroupSize_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stages{ stages_ } + , name{ name_ } + , description{ description_ } + , subgroupSize{ subgroupSize_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutablePropertiesKHR( PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineExecutablePropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + PipelineExecutablePropertiesKHR & operator=( PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineExecutablePropertiesKHR & operator=( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPipelineExecutablePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutablePropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutablePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineExecutablePropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &, + uint32_t const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stages, name, description, subgroupSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = stages <=> rhs.stages; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = subgroupSize <=> rhs.subgroupSize; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stages == rhs.stages ) && ( strcmp( name, rhs.name ) == 0 ) && + ( strcmp( description, rhs.description ) == 0 ) && ( subgroupSize == rhs.subgroupSize ); + } + + bool operator!=( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::ePipelineExecutablePropertiesKHR; + void * pNext = {}; + ShaderStageFlags stages = {}; + ArrayWrapper1D name = {}; + ArrayWrapper1D description = {}; + uint32_t subgroupSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineExecutablePropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineExecutablePropertiesKHR; + }; + + union PipelineExecutableStatisticValueKHR + { + using NativeType = VkPipelineExecutableStatisticValueKHR; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR( Bool32 b32_ = {} ) : b32( b32_ ) {} + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR( int64_t i64_ ) : i64( i64_ ) {} + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR( uint64_t u64_ ) : u64( u64_ ) {} + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR( double f64_ ) : f64( f64_ ) {} +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR & setB32( Bool32 b32_ ) & VULKAN_HPP_NOEXCEPT + { + b32 = b32_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR && setB32( Bool32 b32_ ) && VULKAN_HPP_NOEXCEPT + { + b32 = b32_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR & setI64( int64_t i64_ ) & VULKAN_HPP_NOEXCEPT + { + i64 = i64_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR && setI64( int64_t i64_ ) && VULKAN_HPP_NOEXCEPT + { + i64 = i64_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR & setU64( uint64_t u64_ ) & VULKAN_HPP_NOEXCEPT + { + u64 = u64_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR && setU64( uint64_t u64_ ) && VULKAN_HPP_NOEXCEPT + { + u64 = u64_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR & setF64( double f64_ ) & VULKAN_HPP_NOEXCEPT + { + f64 = f64_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR && setF64( double f64_ ) && VULKAN_HPP_NOEXCEPT + { + f64 = f64_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineExecutableStatisticValueKHR const &() const + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutableStatisticValueKHR &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + Bool32 b32; + int64_t i64; + uint64_t u64; + double f64; +#else + VkBool32 b32; + int64_t i64; + uint64_t u64; + double f64; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineExecutableStatisticValueKHR; + }; +#endif + + // wrapper struct for struct VkPipelineExecutableStatisticKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineExecutableStatisticKHR.html + struct PipelineExecutableStatisticKHR + { + using NativeType = VkPipelineExecutableStatisticKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableStatisticKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticKHR( std::array const & name_ = {}, + std::array const & description_ = {}, + PipelineExecutableStatisticFormatKHR format_ = PipelineExecutableStatisticFormatKHR::eBool32, + PipelineExecutableStatisticValueKHR value_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , name{ name_ } + , description{ description_ } + , format{ format_ } + , value{ value_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticKHR( PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineExecutableStatisticKHR( *reinterpret_cast( &rhs ) ) + { + } + + PipelineExecutableStatisticKHR & operator=( PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineExecutableStatisticKHR & operator=( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPipelineExecutableStatisticKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutableStatisticKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineExecutableStatisticKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineExecutableStatisticKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + ArrayWrapper1D const &, + PipelineExecutableStatisticFormatKHR const &, + PipelineExecutableStatisticValueKHR const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, name, description, format, value ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineExecutableStatisticKHR; + void * pNext = {}; + ArrayWrapper1D name = {}; + ArrayWrapper1D description = {}; + PipelineExecutableStatisticFormatKHR format = PipelineExecutableStatisticFormatKHR::eBool32; + PipelineExecutableStatisticValueKHR value = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineExecutableStatisticKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineExecutableStatisticKHR; + }; + + // wrapper struct for struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineFragmentDensityMapLayeredCreateInfoVALVE.html + struct PipelineFragmentDensityMapLayeredCreateInfoVALVE + { + using NativeType = VkPipelineFragmentDensityMapLayeredCreateInfoVALVE; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineFragmentDensityMapLayeredCreateInfoVALVE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineFragmentDensityMapLayeredCreateInfoVALVE( uint32_t maxFragmentDensityMapLayers_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxFragmentDensityMapLayers{ maxFragmentDensityMapLayers_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineFragmentDensityMapLayeredCreateInfoVALVE( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineFragmentDensityMapLayeredCreateInfoVALVE( VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineFragmentDensityMapLayeredCreateInfoVALVE( *reinterpret_cast( &rhs ) ) + { + } + + PipelineFragmentDensityMapLayeredCreateInfoVALVE & operator=( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineFragmentDensityMapLayeredCreateInfoVALVE & operator=( VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentDensityMapLayeredCreateInfoVALVE & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentDensityMapLayeredCreateInfoVALVE && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentDensityMapLayeredCreateInfoVALVE & setMaxFragmentDensityMapLayers( uint32_t maxFragmentDensityMapLayers_ ) & + VULKAN_HPP_NOEXCEPT + { + maxFragmentDensityMapLayers = maxFragmentDensityMapLayers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentDensityMapLayeredCreateInfoVALVE && setMaxFragmentDensityMapLayers( uint32_t maxFragmentDensityMapLayers_ ) && + VULKAN_HPP_NOEXCEPT + { + maxFragmentDensityMapLayers = maxFragmentDensityMapLayers_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxFragmentDensityMapLayers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & ) const = default; +#else + bool operator==( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxFragmentDensityMapLayers == rhs.maxFragmentDensityMapLayers ); +# endif + } + + bool operator!=( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineFragmentDensityMapLayeredCreateInfoVALVE; + const void * pNext = {}; + uint32_t maxFragmentDensityMapLayers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineFragmentDensityMapLayeredCreateInfoVALVE; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineFragmentDensityMapLayeredCreateInfoVALVE; + }; + + // wrapper struct for struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.html + struct PipelineFragmentShadingRateEnumStateCreateInfoNV + { + using NativeType = VkPipelineFragmentShadingRateEnumStateCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineFragmentShadingRateEnumStateCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV( + FragmentShadingRateTypeNV shadingRateType_ = FragmentShadingRateTypeNV::eFragmentSize, + FragmentShadingRateNV shadingRate_ = FragmentShadingRateNV::e1InvocationPerPixel, + std::array const & combinerOps_ = { { FragmentShadingRateCombinerOpKHR::eKeep, + FragmentShadingRateCombinerOpKHR::eKeep } }, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shadingRateType{ shadingRateType_ } + , shadingRate{ shadingRate_ } + , combinerOps{ combinerOps_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + PipelineFragmentShadingRateEnumStateCreateInfoNV( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineFragmentShadingRateEnumStateCreateInfoNV( VkPipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineFragmentShadingRateEnumStateCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + PipelineFragmentShadingRateEnumStateCreateInfoNV & operator=( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineFragmentShadingRateEnumStateCreateInfoNV & operator=( VkPipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV & setShadingRateType( FragmentShadingRateTypeNV shadingRateType_ ) & + VULKAN_HPP_NOEXCEPT + { + shadingRateType = shadingRateType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV && setShadingRateType( FragmentShadingRateTypeNV shadingRateType_ ) && + VULKAN_HPP_NOEXCEPT + { + shadingRateType = shadingRateType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV & setShadingRate( FragmentShadingRateNV shadingRate_ ) & VULKAN_HPP_NOEXCEPT + { + shadingRate = shadingRate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV && setShadingRate( FragmentShadingRateNV shadingRate_ ) && VULKAN_HPP_NOEXCEPT + { + shadingRate = shadingRate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV & setCombinerOps( std::array combinerOps_ ) & + VULKAN_HPP_NOEXCEPT + { + combinerOps = combinerOps_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV && + setCombinerOps( std::array combinerOps_ ) && + VULKAN_HPP_NOEXCEPT + { + combinerOps = combinerOps_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateType, shadingRate, combinerOps ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineFragmentShadingRateEnumStateCreateInfoNV const & ) const = default; +#else + bool operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateType == rhs.shadingRateType ) && ( shadingRate == rhs.shadingRate ) && + ( combinerOps == rhs.combinerOps ); +# endif + } + + bool operator!=( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineFragmentShadingRateEnumStateCreateInfoNV; + const void * pNext = {}; + FragmentShadingRateTypeNV shadingRateType = FragmentShadingRateTypeNV::eFragmentSize; + FragmentShadingRateNV shadingRate = FragmentShadingRateNV::e1InvocationPerPixel; + ArrayWrapper1D combinerOps = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineFragmentShadingRateEnumStateCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineFragmentShadingRateEnumStateCreateInfoNV; + }; + + // wrapper struct for struct VkPipelineFragmentShadingRateStateCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineFragmentShadingRateStateCreateInfoKHR.html + struct PipelineFragmentShadingRateStateCreateInfoKHR + { + using NativeType = VkPipelineFragmentShadingRateStateCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineFragmentShadingRateStateCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR( + Extent2D fragmentSize_ = {}, + std::array const & combinerOps_ = { { FragmentShadingRateCombinerOpKHR::eKeep, + FragmentShadingRateCombinerOpKHR::eKeep } }, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fragmentSize{ fragmentSize_ } + , combinerOps{ combinerOps_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 + PipelineFragmentShadingRateStateCreateInfoKHR( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineFragmentShadingRateStateCreateInfoKHR( VkPipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineFragmentShadingRateStateCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + PipelineFragmentShadingRateStateCreateInfoKHR & operator=( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineFragmentShadingRateStateCreateInfoKHR & operator=( VkPipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR & setFragmentSize( Extent2D const & fragmentSize_ ) & VULKAN_HPP_NOEXCEPT + { + fragmentSize = fragmentSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR && setFragmentSize( Extent2D const & fragmentSize_ ) && VULKAN_HPP_NOEXCEPT + { + fragmentSize = fragmentSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR & setCombinerOps( std::array combinerOps_ ) & + VULKAN_HPP_NOEXCEPT + { + combinerOps = combinerOps_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR && setCombinerOps( std::array combinerOps_ ) && + VULKAN_HPP_NOEXCEPT + { + combinerOps = combinerOps_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineFragmentShadingRateStateCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineFragmentShadingRateStateCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineFragmentShadingRateStateCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineFragmentShadingRateStateCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentSize, combinerOps ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineFragmentShadingRateStateCreateInfoKHR const & ) const = default; +#else + bool operator==( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentSize == rhs.fragmentSize ) && ( combinerOps == rhs.combinerOps ); +# endif + } + + bool operator!=( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineFragmentShadingRateStateCreateInfoKHR; + const void * pNext = {}; + Extent2D fragmentSize = {}; + ArrayWrapper1D combinerOps = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineFragmentShadingRateStateCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineFragmentShadingRateStateCreateInfoKHR; + }; + + // wrapper struct for struct VkPipelineIndirectDeviceAddressInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineIndirectDeviceAddressInfoNV.html + struct PipelineIndirectDeviceAddressInfoNV + { + using NativeType = VkPipelineIndirectDeviceAddressInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineIndirectDeviceAddressInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineIndirectDeviceAddressInfoNV( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + Pipeline pipeline_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineBindPoint{ pipelineBindPoint_ } + , pipeline{ pipeline_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineIndirectDeviceAddressInfoNV( PipelineIndirectDeviceAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineIndirectDeviceAddressInfoNV( VkPipelineIndirectDeviceAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineIndirectDeviceAddressInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + PipelineIndirectDeviceAddressInfoNV & operator=( PipelineIndirectDeviceAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineIndirectDeviceAddressInfoNV & operator=( VkPipelineIndirectDeviceAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineIndirectDeviceAddressInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineIndirectDeviceAddressInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineIndirectDeviceAddressInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineIndirectDeviceAddressInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineBindPoint, pipeline ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineIndirectDeviceAddressInfoNV const & ) const = default; +#else + bool operator==( PipelineIndirectDeviceAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipeline == rhs.pipeline ); +# endif + } + + bool operator!=( PipelineIndirectDeviceAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineIndirectDeviceAddressInfoNV; + const void * pNext = {}; + PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; + Pipeline pipeline = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineIndirectDeviceAddressInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineIndirectDeviceAddressInfoNV; + }; + + // wrapper struct for struct VkPipelineInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineInfoKHR.html + struct PipelineInfoKHR + { + using NativeType = VkPipelineInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineInfoKHR( Pipeline pipeline_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipeline{ pipeline_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineInfoKHR( PipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineInfoKHR( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PipelineInfoKHR( *reinterpret_cast( &rhs ) ) {} + + PipelineInfoKHR & operator=( PipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineInfoKHR & operator=( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineInfoKHR & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineInfoKHR && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipeline ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineInfoKHR const & ) const = default; +#else + bool operator==( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ); +# endif + } + + bool operator!=( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineInfoKHR; + const void * pNext = {}; + Pipeline pipeline = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineInfoKHR; + }; + + using PipelineInfoEXT = PipelineInfoKHR; + + // wrapper struct for struct VkPipelineLayoutCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateInfo.html + struct PipelineLayoutCreateInfo + { + using NativeType = VkPipelineLayoutCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineLayoutCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = {}, + uint32_t setLayoutCount_ = {}, + const DescriptorSetLayout * pSetLayouts_ = {}, + uint32_t pushConstantRangeCount_ = {}, + const PushConstantRange * pPushConstantRanges_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , setLayoutCount{ setLayoutCount_ } + , pSetLayouts{ pSetLayouts_ } + , pushConstantRangeCount{ pushConstantRangeCount_ } + , pPushConstantRanges{ pPushConstantRanges_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( PipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineLayoutCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_, + ArrayProxyNoTemporaries const & setLayouts_, + ArrayProxyNoTemporaries const & pushConstantRanges_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , setLayoutCount( static_cast( setLayouts_.size() ) ) + , pSetLayouts( setLayouts_.data() ) + , pushConstantRangeCount( static_cast( pushConstantRanges_.size() ) ) + , pPushConstantRanges( pushConstantRanges_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineLayoutCreateInfo & operator=( PipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineLayoutCreateInfo & operator=( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setFlags( PipelineLayoutCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setFlags( PipelineLayoutCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setSetLayoutCount( uint32_t setLayoutCount_ ) & VULKAN_HPP_NOEXCEPT + { + setLayoutCount = setLayoutCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setSetLayoutCount( uint32_t setLayoutCount_ ) && VULKAN_HPP_NOEXCEPT + { + setLayoutCount = setLayoutCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) & VULKAN_HPP_NOEXCEPT + { + pSetLayouts = pSetLayouts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) && VULKAN_HPP_NOEXCEPT + { + pSetLayouts = pSetLayouts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineLayoutCreateInfo & setSetLayouts( ArrayProxyNoTemporaries const & setLayouts_ ) VULKAN_HPP_NOEXCEPT + { + setLayoutCount = static_cast( setLayouts_.size() ); + pSetLayouts = setLayouts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) & VULKAN_HPP_NOEXCEPT + { + pushConstantRangeCount = pushConstantRangeCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) && VULKAN_HPP_NOEXCEPT + { + pushConstantRangeCount = pushConstantRangeCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) & VULKAN_HPP_NOEXCEPT + { + pPushConstantRanges = pPushConstantRanges_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) && VULKAN_HPP_NOEXCEPT + { + pPushConstantRanges = pPushConstantRanges_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineLayoutCreateInfo & setPushConstantRanges( ArrayProxyNoTemporaries const & pushConstantRanges_ ) VULKAN_HPP_NOEXCEPT + { + pushConstantRangeCount = static_cast( pushConstantRanges_.size() ); + pPushConstantRanges = pushConstantRanges_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineLayoutCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineLayoutCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, setLayoutCount, pSetLayouts, pushConstantRangeCount, pPushConstantRanges ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineLayoutCreateInfo const & ) const = default; +#else + bool operator==( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( setLayoutCount == rhs.setLayoutCount ) && + ( pSetLayouts == rhs.pSetLayouts ) && ( pushConstantRangeCount == rhs.pushConstantRangeCount ) && + ( pPushConstantRanges == rhs.pPushConstantRanges ); +# endif + } + + bool operator!=( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineLayoutCreateInfo; + const void * pNext = {}; + PipelineLayoutCreateFlags flags = {}; + uint32_t setLayoutCount = {}; + const DescriptorSetLayout * pSetLayouts = {}; + uint32_t pushConstantRangeCount = {}; + const PushConstantRange * pPushConstantRanges = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineLayoutCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineLayoutCreateInfo; + }; + + // wrapper struct for struct VkPipelinePropertiesIdentifierEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelinePropertiesIdentifierEXT.html + struct PipelinePropertiesIdentifierEXT + { + using NativeType = VkPipelinePropertiesIdentifierEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelinePropertiesIdentifierEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PipelinePropertiesIdentifierEXT( std::array const & pipelineIdentifier_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipelineIdentifier{ pipelineIdentifier_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 PipelinePropertiesIdentifierEXT( PipelinePropertiesIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelinePropertiesIdentifierEXT( VkPipelinePropertiesIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelinePropertiesIdentifierEXT( *reinterpret_cast( &rhs ) ) + { + } + + PipelinePropertiesIdentifierEXT & operator=( PipelinePropertiesIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelinePropertiesIdentifierEXT & operator=( VkPipelinePropertiesIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPipelinePropertiesIdentifierEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelinePropertiesIdentifierEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelinePropertiesIdentifierEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelinePropertiesIdentifierEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipelineIdentifier ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelinePropertiesIdentifierEXT const & ) const = default; +#else + bool operator==( PipelinePropertiesIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineIdentifier == rhs.pipelineIdentifier ); +# endif + } + + bool operator!=( PipelinePropertiesIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelinePropertiesIdentifierEXT; + void * pNext = {}; + ArrayWrapper1D pipelineIdentifier = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelinePropertiesIdentifierEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelinePropertiesIdentifierEXT; + }; + + // wrapper struct for struct VkPipelineRasterizationConservativeStateCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationConservativeStateCreateInfoEXT.html + struct PipelineRasterizationConservativeStateCreateInfoEXT + { + using NativeType = VkPipelineRasterizationConservativeStateCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( + PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = {}, + ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled, + float extraPrimitiveOverestimationSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , conservativeRasterizationMode{ conservativeRasterizationMode_ } + , extraPrimitiveOverestimationSize{ extraPrimitiveOverestimationSize_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineRasterizationConservativeStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PipelineRasterizationConservativeStateCreateInfoEXT & + operator=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineRasterizationConservativeStateCreateInfoEXT & operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT & setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ ) & + VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT && setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ ) && + VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT & + setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ ) & + VULKAN_HPP_NOEXCEPT + { + conservativeRasterizationMode = conservativeRasterizationMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT && + setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ ) && + VULKAN_HPP_NOEXCEPT + { + conservativeRasterizationMode = conservativeRasterizationMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT & + setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ ) & + VULKAN_HPP_NOEXCEPT + { + extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT && + setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ ) && + VULKAN_HPP_NOEXCEPT + { + extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineRasterizationConservativeStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationConservativeStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationConservativeStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineRasterizationConservativeStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, conservativeRasterizationMode, extraPrimitiveOverestimationSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineRasterizationConservativeStateCreateInfoEXT const & ) const = default; +#else + bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( conservativeRasterizationMode == rhs.conservativeRasterizationMode ) && + ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize ); +# endif + } + + bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; + const void * pNext = {}; + PipelineRasterizationConservativeStateCreateFlagsEXT flags = {}; + ConservativeRasterizationModeEXT conservativeRasterizationMode = ConservativeRasterizationModeEXT::eDisabled; + float extraPrimitiveOverestimationSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineRasterizationConservativeStateCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineRasterizationConservativeStateCreateInfoEXT; + }; + + // wrapper struct for struct VkPipelineRasterizationDepthClipStateCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationDepthClipStateCreateInfoEXT.html + struct PipelineRasterizationDepthClipStateCreateInfoEXT + { + using NativeType = VkPipelineRasterizationDepthClipStateCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = {}, + Bool32 depthClipEnable_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , depthClipEnable{ depthClipEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineRasterizationDepthClipStateCreateInfoEXT( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineRasterizationDepthClipStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PipelineRasterizationDepthClipStateCreateInfoEXT & operator=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineRasterizationDepthClipStateCreateInfoEXT & operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT & setFlags( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ ) & + VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT && setFlags( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ ) && + VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT & setDepthClipEnable( Bool32 depthClipEnable_ ) & VULKAN_HPP_NOEXCEPT + { + depthClipEnable = depthClipEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT && setDepthClipEnable( Bool32 depthClipEnable_ ) && VULKAN_HPP_NOEXCEPT + { + depthClipEnable = depthClipEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationDepthClipStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineRasterizationDepthClipStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, depthClipEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineRasterizationDepthClipStateCreateInfoEXT const & ) const = default; +#else + bool operator==( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( depthClipEnable == rhs.depthClipEnable ); +# endif + } + + bool operator!=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; + const void * pNext = {}; + PipelineRasterizationDepthClipStateCreateFlagsEXT flags = {}; + Bool32 depthClipEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineRasterizationDepthClipStateCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineRasterizationDepthClipStateCreateInfoEXT; + }; + + // wrapper struct for struct VkPipelineRasterizationLineStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationLineStateCreateInfo.html + struct PipelineRasterizationLineStateCreateInfo + { + using NativeType = VkPipelineRasterizationLineStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationLineStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfo( LineRasterizationMode lineRasterizationMode_ = LineRasterizationMode::eDefault, + Bool32 stippledLineEnable_ = {}, + uint32_t lineStippleFactor_ = {}, + uint16_t lineStipplePattern_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , lineRasterizationMode{ lineRasterizationMode_ } + , stippledLineEnable{ stippledLineEnable_ } + , lineStippleFactor{ lineStippleFactor_ } + , lineStipplePattern{ lineStipplePattern_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfo( PipelineRasterizationLineStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineRasterizationLineStateCreateInfo( VkPipelineRasterizationLineStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineRasterizationLineStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PipelineRasterizationLineStateCreateInfo & operator=( PipelineRasterizationLineStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineRasterizationLineStateCreateInfo & operator=( VkPipelineRasterizationLineStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo & setLineRasterizationMode( LineRasterizationMode lineRasterizationMode_ ) & + VULKAN_HPP_NOEXCEPT + { + lineRasterizationMode = lineRasterizationMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo && setLineRasterizationMode( LineRasterizationMode lineRasterizationMode_ ) && + VULKAN_HPP_NOEXCEPT + { + lineRasterizationMode = lineRasterizationMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo & setStippledLineEnable( Bool32 stippledLineEnable_ ) & VULKAN_HPP_NOEXCEPT + { + stippledLineEnable = stippledLineEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo && setStippledLineEnable( Bool32 stippledLineEnable_ ) && VULKAN_HPP_NOEXCEPT + { + stippledLineEnable = stippledLineEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo & setLineStippleFactor( uint32_t lineStippleFactor_ ) & VULKAN_HPP_NOEXCEPT + { + lineStippleFactor = lineStippleFactor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo && setLineStippleFactor( uint32_t lineStippleFactor_ ) && VULKAN_HPP_NOEXCEPT + { + lineStippleFactor = lineStippleFactor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo & setLineStipplePattern( uint16_t lineStipplePattern_ ) & VULKAN_HPP_NOEXCEPT + { + lineStipplePattern = lineStipplePattern_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo && setLineStipplePattern( uint16_t lineStipplePattern_ ) && VULKAN_HPP_NOEXCEPT + { + lineStipplePattern = lineStipplePattern_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineRasterizationLineStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationLineStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationLineStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineRasterizationLineStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, lineRasterizationMode, stippledLineEnable, lineStippleFactor, lineStipplePattern ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineRasterizationLineStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineRasterizationLineStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lineRasterizationMode == rhs.lineRasterizationMode ) && + ( stippledLineEnable == rhs.stippledLineEnable ) && ( lineStippleFactor == rhs.lineStippleFactor ) && + ( lineStipplePattern == rhs.lineStipplePattern ); +# endif + } + + bool operator!=( PipelineRasterizationLineStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineRasterizationLineStateCreateInfo; + const void * pNext = {}; + LineRasterizationMode lineRasterizationMode = LineRasterizationMode::eDefault; + Bool32 stippledLineEnable = {}; + uint32_t lineStippleFactor = {}; + uint16_t lineStipplePattern = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineRasterizationLineStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineRasterizationLineStateCreateInfo; + }; + + using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfo; + using PipelineRasterizationLineStateCreateInfoKHR = PipelineRasterizationLineStateCreateInfo; + + // wrapper struct for struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.html + struct PipelineRasterizationProvokingVertexStateCreateInfoEXT + { + using NativeType = VkPipelineRasterizationProvokingVertexStateCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationProvokingVertexStateCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PipelineRasterizationProvokingVertexStateCreateInfoEXT( ProvokingVertexModeEXT provokingVertexMode_ = ProvokingVertexModeEXT::eFirstVertex, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , provokingVertexMode{ provokingVertexMode_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineRasterizationProvokingVertexStateCreateInfoEXT( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + PipelineRasterizationProvokingVertexStateCreateInfoEXT( VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineRasterizationProvokingVertexStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PipelineRasterizationProvokingVertexStateCreateInfoEXT & + operator=( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineRasterizationProvokingVertexStateCreateInfoEXT & + operator=( VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationProvokingVertexStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationProvokingVertexStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationProvokingVertexStateCreateInfoEXT & setProvokingVertexMode( ProvokingVertexModeEXT provokingVertexMode_ ) & + VULKAN_HPP_NOEXCEPT + { + provokingVertexMode = provokingVertexMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationProvokingVertexStateCreateInfoEXT && setProvokingVertexMode( ProvokingVertexModeEXT provokingVertexMode_ ) && + VULKAN_HPP_NOEXCEPT + { + provokingVertexMode = provokingVertexMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, provokingVertexMode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & ) const = default; +#else + bool operator==( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexMode == rhs.provokingVertexMode ); +# endif + } + + bool operator!=( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineRasterizationProvokingVertexStateCreateInfoEXT; + const void * pNext = {}; + ProvokingVertexModeEXT provokingVertexMode = ProvokingVertexModeEXT::eFirstVertex; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineRasterizationProvokingVertexStateCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineRasterizationProvokingVertexStateCreateInfoEXT; + }; + + // wrapper struct for struct VkPipelineRasterizationStateRasterizationOrderAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateRasterizationOrderAMD.html + struct PipelineRasterizationStateRasterizationOrderAMD + { + using NativeType = VkPipelineRasterizationStateRasterizationOrderAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rasterizationOrder{ rasterizationOrder_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineRasterizationStateRasterizationOrderAMD( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineRasterizationStateRasterizationOrderAMD( *reinterpret_cast( &rhs ) ) + { + } + + PipelineRasterizationStateRasterizationOrderAMD & operator=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineRasterizationStateRasterizationOrderAMD & operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateRasterizationOrderAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateRasterizationOrderAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateRasterizationOrderAMD & setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ ) & + VULKAN_HPP_NOEXCEPT + { + rasterizationOrder = rasterizationOrder_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateRasterizationOrderAMD && setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ ) && + VULKAN_HPP_NOEXCEPT + { + rasterizationOrder = rasterizationOrder_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineRasterizationStateRasterizationOrderAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateRasterizationOrderAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateRasterizationOrderAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateRasterizationOrderAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rasterizationOrder ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineRasterizationStateRasterizationOrderAMD const & ) const = default; +#else + bool operator==( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrder == rhs.rasterizationOrder ); +# endif + } + + bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; + const void * pNext = {}; + RasterizationOrderAMD rasterizationOrder = RasterizationOrderAMD::eStrict; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineRasterizationStateRasterizationOrderAMD; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineRasterizationStateRasterizationOrderAMD; + }; + + // wrapper struct for struct VkPipelineRasterizationStateStreamCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateStreamCreateInfoEXT.html + struct PipelineRasterizationStateStreamCreateInfoEXT + { + using NativeType = VkPipelineRasterizationStateStreamCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateFlagsEXT flags_ = {}, + uint32_t rasterizationStream_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , rasterizationStream{ rasterizationStream_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineRasterizationStateStreamCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PipelineRasterizationStateStreamCreateInfoEXT & operator=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineRasterizationStateStreamCreateInfoEXT & operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT & setFlags( PipelineRasterizationStateStreamCreateFlagsEXT flags_ ) & + VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT && setFlags( PipelineRasterizationStateStreamCreateFlagsEXT flags_ ) && + VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT & setRasterizationStream( uint32_t rasterizationStream_ ) & VULKAN_HPP_NOEXCEPT + { + rasterizationStream = rasterizationStream_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT && setRasterizationStream( uint32_t rasterizationStream_ ) && VULKAN_HPP_NOEXCEPT + { + rasterizationStream = rasterizationStream_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineRasterizationStateStreamCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateStreamCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateStreamCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineRasterizationStateStreamCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, rasterizationStream ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineRasterizationStateStreamCreateInfoEXT const & ) const = default; +#else + bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rasterizationStream == rhs.rasterizationStream ); +# endif + } + + bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; + const void * pNext = {}; + PipelineRasterizationStateStreamCreateFlagsEXT flags = {}; + uint32_t rasterizationStream = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineRasterizationStateStreamCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineRasterizationStateStreamCreateInfoEXT; + }; + + // wrapper struct for struct VkPipelineRenderingCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRenderingCreateInfo.html + struct PipelineRenderingCreateInfo + { + using NativeType = VkPipelineRenderingCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRenderingCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineRenderingCreateInfo( uint32_t viewMask_ = {}, + uint32_t colorAttachmentCount_ = {}, + const Format * pColorAttachmentFormats_ = {}, + Format depthAttachmentFormat_ = Format::eUndefined, + Format stencilAttachmentFormat_ = Format::eUndefined, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , viewMask{ viewMask_ } + , colorAttachmentCount{ colorAttachmentCount_ } + , pColorAttachmentFormats{ pColorAttachmentFormats_ } + , depthAttachmentFormat{ depthAttachmentFormat_ } + , stencilAttachmentFormat{ stencilAttachmentFormat_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineRenderingCreateInfo( PipelineRenderingCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineRenderingCreateInfo( VkPipelineRenderingCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineRenderingCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineRenderingCreateInfo( uint32_t viewMask_, + ArrayProxyNoTemporaries const & colorAttachmentFormats_, + Format depthAttachmentFormat_ = Format::eUndefined, + Format stencilAttachmentFormat_ = Format::eUndefined, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , viewMask( viewMask_ ) + , colorAttachmentCount( static_cast( colorAttachmentFormats_.size() ) ) + , pColorAttachmentFormats( colorAttachmentFormats_.data() ) + , depthAttachmentFormat( depthAttachmentFormat_ ) + , stencilAttachmentFormat( stencilAttachmentFormat_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineRenderingCreateInfo & operator=( PipelineRenderingCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineRenderingCreateInfo & operator=( VkPipelineRenderingCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setViewMask( uint32_t viewMask_ ) & VULKAN_HPP_NOEXCEPT + { + viewMask = viewMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setViewMask( uint32_t viewMask_ ) && VULKAN_HPP_NOEXCEPT + { + viewMask = viewMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) & VULKAN_HPP_NOEXCEPT + { + pColorAttachmentFormats = pColorAttachmentFormats_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) && VULKAN_HPP_NOEXCEPT + { + pColorAttachmentFormats = pColorAttachmentFormats_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineRenderingCreateInfo & setColorAttachmentFormats( ArrayProxyNoTemporaries const & colorAttachmentFormats_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( colorAttachmentFormats_.size() ); + pColorAttachmentFormats = colorAttachmentFormats_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setDepthAttachmentFormat( Format depthAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT + { + depthAttachmentFormat = depthAttachmentFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setDepthAttachmentFormat( Format depthAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT + { + depthAttachmentFormat = depthAttachmentFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT + { + stencilAttachmentFormat = stencilAttachmentFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT + { + stencilAttachmentFormat = stencilAttachmentFormat_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineRenderingCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRenderingCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRenderingCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineRenderingCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, viewMask, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineRenderingCreateInfo const & ) const = default; +#else + bool operator==( PipelineRenderingCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && + ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && + ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ); +# endif + } + + bool operator!=( PipelineRenderingCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineRenderingCreateInfo; + const void * pNext = {}; + uint32_t viewMask = {}; + uint32_t colorAttachmentCount = {}; + const Format * pColorAttachmentFormats = {}; + Format depthAttachmentFormat = Format::eUndefined; + Format stencilAttachmentFormat = Format::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineRenderingCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineRenderingCreateInfo; + }; + + using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo; + + // wrapper struct for struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRepresentativeFragmentTestStateCreateInfoNV.html + struct PipelineRepresentativeFragmentTestStateCreateInfoNV + { + using NativeType = VkPipelineRepresentativeFragmentTestStateCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( Bool32 representativeFragmentTestEnable_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , representativeFragmentTestEnable{ representativeFragmentTestEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineRepresentativeFragmentTestStateCreateInfoNV( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineRepresentativeFragmentTestStateCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + PipelineRepresentativeFragmentTestStateCreateInfoNV & + operator=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineRepresentativeFragmentTestStateCreateInfoNV & operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineRepresentativeFragmentTestStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRepresentativeFragmentTestStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRepresentativeFragmentTestStateCreateInfoNV & + setRepresentativeFragmentTestEnable( Bool32 representativeFragmentTestEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + representativeFragmentTestEnable = representativeFragmentTestEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRepresentativeFragmentTestStateCreateInfoNV && + setRepresentativeFragmentTestEnable( Bool32 representativeFragmentTestEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + representativeFragmentTestEnable = representativeFragmentTestEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, representativeFragmentTestEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineRepresentativeFragmentTestStateCreateInfoNV const & ) const = default; +#else + bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable ); +# endif + } + + bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; + const void * pNext = {}; + Bool32 representativeFragmentTestEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineRepresentativeFragmentTestStateCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineRepresentativeFragmentTestStateCreateInfoNV; + }; + + // wrapper struct for struct VkPipelineRobustnessCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRobustnessCreateInfo.html + struct PipelineRobustnessCreateInfo + { + using NativeType = VkPipelineRobustnessCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRobustnessCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineRobustnessCreateInfo( PipelineRobustnessBufferBehavior storageBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, + PipelineRobustnessBufferBehavior uniformBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, + PipelineRobustnessBufferBehavior vertexInputs_ = PipelineRobustnessBufferBehavior::eDeviceDefault, + PipelineRobustnessImageBehavior images_ = PipelineRobustnessImageBehavior::eDeviceDefault, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , storageBuffers{ storageBuffers_ } + , uniformBuffers{ uniformBuffers_ } + , vertexInputs{ vertexInputs_ } + , images{ images_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineRobustnessCreateInfo( PipelineRobustnessCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineRobustnessCreateInfo( VkPipelineRobustnessCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineRobustnessCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PipelineRobustnessCreateInfo & operator=( PipelineRobustnessCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineRobustnessCreateInfo & operator=( VkPipelineRobustnessCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo & setStorageBuffers( PipelineRobustnessBufferBehavior storageBuffers_ ) & VULKAN_HPP_NOEXCEPT + { + storageBuffers = storageBuffers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo && setStorageBuffers( PipelineRobustnessBufferBehavior storageBuffers_ ) && VULKAN_HPP_NOEXCEPT + { + storageBuffers = storageBuffers_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo & setUniformBuffers( PipelineRobustnessBufferBehavior uniformBuffers_ ) & VULKAN_HPP_NOEXCEPT + { + uniformBuffers = uniformBuffers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo && setUniformBuffers( PipelineRobustnessBufferBehavior uniformBuffers_ ) && VULKAN_HPP_NOEXCEPT + { + uniformBuffers = uniformBuffers_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo & setVertexInputs( PipelineRobustnessBufferBehavior vertexInputs_ ) & VULKAN_HPP_NOEXCEPT + { + vertexInputs = vertexInputs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo && setVertexInputs( PipelineRobustnessBufferBehavior vertexInputs_ ) && VULKAN_HPP_NOEXCEPT + { + vertexInputs = vertexInputs_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo & setImages( PipelineRobustnessImageBehavior images_ ) & VULKAN_HPP_NOEXCEPT + { + images = images_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo && setImages( PipelineRobustnessImageBehavior images_ ) && VULKAN_HPP_NOEXCEPT + { + images = images_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineRobustnessCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRobustnessCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineRobustnessCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineRobustnessCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, storageBuffers, uniformBuffers, vertexInputs, images ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineRobustnessCreateInfo const & ) const = default; +#else + bool operator==( PipelineRobustnessCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffers == rhs.storageBuffers ) && ( uniformBuffers == rhs.uniformBuffers ) && + ( vertexInputs == rhs.vertexInputs ) && ( images == rhs.images ); +# endif + } + + bool operator!=( PipelineRobustnessCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineRobustnessCreateInfo; + const void * pNext = {}; + PipelineRobustnessBufferBehavior storageBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; + PipelineRobustnessBufferBehavior uniformBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; + PipelineRobustnessBufferBehavior vertexInputs = PipelineRobustnessBufferBehavior::eDeviceDefault; + PipelineRobustnessImageBehavior images = PipelineRobustnessImageBehavior::eDeviceDefault; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineRobustnessCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineRobustnessCreateInfo; + }; + + using PipelineRobustnessCreateInfoEXT = PipelineRobustnessCreateInfo; + + // wrapper struct for struct VkPipelineSampleLocationsStateCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineSampleLocationsStateCreateInfoEXT.html + struct PipelineSampleLocationsStateCreateInfoEXT + { + using NativeType = VkPipelineSampleLocationsStateCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = {}, + SampleLocationsInfoEXT sampleLocationsInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , sampleLocationsEnable{ sampleLocationsEnable_ } + , sampleLocationsInfo{ sampleLocationsInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineSampleLocationsStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PipelineSampleLocationsStateCreateInfoEXT & operator=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineSampleLocationsStateCreateInfoEXT & operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsEnable( Bool32 sampleLocationsEnable_ ) & VULKAN_HPP_NOEXCEPT + { + sampleLocationsEnable = sampleLocationsEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT && setSampleLocationsEnable( Bool32 sampleLocationsEnable_ ) && VULKAN_HPP_NOEXCEPT + { + sampleLocationsEnable = sampleLocationsEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + sampleLocationsInfo = sampleLocationsInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT && setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + sampleLocationsInfo = sampleLocationsInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineSampleLocationsStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineSampleLocationsStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineSampleLocationsStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineSampleLocationsStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sampleLocationsEnable, sampleLocationsInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineSampleLocationsStateCreateInfoEXT const & ) const = default; +#else + bool operator==( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleLocationsEnable == rhs.sampleLocationsEnable ) && + ( sampleLocationsInfo == rhs.sampleLocationsInfo ); +# endif + } + + bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; + const void * pNext = {}; + Bool32 sampleLocationsEnable = {}; + SampleLocationsInfoEXT sampleLocationsInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineSampleLocationsStateCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineSampleLocationsStateCreateInfoEXT; + }; + + // wrapper struct for struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageModuleIdentifierCreateInfoEXT.html + struct PipelineShaderStageModuleIdentifierCreateInfoEXT + { + using NativeType = VkPipelineShaderStageModuleIdentifierCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineShaderStageModuleIdentifierCreateInfoEXT( uint32_t identifierSize_ = {}, + const uint8_t * pIdentifier_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , identifierSize{ identifierSize_ } + , pIdentifier{ pIdentifier_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineShaderStageModuleIdentifierCreateInfoEXT( PipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineShaderStageModuleIdentifierCreateInfoEXT( VkPipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineShaderStageModuleIdentifierCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineShaderStageModuleIdentifierCreateInfoEXT( ArrayProxyNoTemporaries const & identifier_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), identifierSize( static_cast( identifier_.size() ) ), pIdentifier( identifier_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineShaderStageModuleIdentifierCreateInfoEXT & operator=( PipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineShaderStageModuleIdentifierCreateInfoEXT & operator=( VkPipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT & setIdentifierSize( uint32_t identifierSize_ ) & VULKAN_HPP_NOEXCEPT + { + identifierSize = identifierSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT && setIdentifierSize( uint32_t identifierSize_ ) && VULKAN_HPP_NOEXCEPT + { + identifierSize = identifierSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT & setPIdentifier( const uint8_t * pIdentifier_ ) & VULKAN_HPP_NOEXCEPT + { + pIdentifier = pIdentifier_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT && setPIdentifier( const uint8_t * pIdentifier_ ) && VULKAN_HPP_NOEXCEPT + { + pIdentifier = pIdentifier_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineShaderStageModuleIdentifierCreateInfoEXT & setIdentifier( ArrayProxyNoTemporaries const & identifier_ ) VULKAN_HPP_NOEXCEPT + { + identifierSize = static_cast( identifier_.size() ); + pIdentifier = identifier_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineShaderStageModuleIdentifierCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineShaderStageModuleIdentifierCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineShaderStageModuleIdentifierCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineShaderStageModuleIdentifierCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, identifierSize, pIdentifier ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineShaderStageModuleIdentifierCreateInfoEXT const & ) const = default; +#else + bool operator==( PipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( identifierSize == rhs.identifierSize ) && ( pIdentifier == rhs.pIdentifier ); +# endif + } + + bool operator!=( PipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT; + const void * pNext = {}; + uint32_t identifierSize = {}; + const uint8_t * pIdentifier = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineShaderStageModuleIdentifierCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineShaderStageModuleIdentifierCreateInfoEXT; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkPipelineShaderStageNodeCreateInfoAMDX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageNodeCreateInfoAMDX.html + struct PipelineShaderStageNodeCreateInfoAMDX + { + using NativeType = VkPipelineShaderStageNodeCreateInfoAMDX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageNodeCreateInfoAMDX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PipelineShaderStageNodeCreateInfoAMDX( const char * pName_ = {}, uint32_t index_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pName{ pName_ } + , index{ index_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineShaderStageNodeCreateInfoAMDX( PipelineShaderStageNodeCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineShaderStageNodeCreateInfoAMDX( VkPipelineShaderStageNodeCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineShaderStageNodeCreateInfoAMDX( *reinterpret_cast( &rhs ) ) + { + } + + PipelineShaderStageNodeCreateInfoAMDX & operator=( PipelineShaderStageNodeCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineShaderStageNodeCreateInfoAMDX & operator=( VkPipelineShaderStageNodeCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT + { + index = index_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT + { + index = index_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineShaderStageNodeCreateInfoAMDX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineShaderStageNodeCreateInfoAMDX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineShaderStageNodeCreateInfoAMDX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineShaderStageNodeCreateInfoAMDX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pName, index ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PipelineShaderStageNodeCreateInfoAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( pName != rhs.pName ) + if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = index <=> rhs.index; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( PipelineShaderStageNodeCreateInfoAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( index == rhs.index ); + } + + bool operator!=( PipelineShaderStageNodeCreateInfoAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::ePipelineShaderStageNodeCreateInfoAMDX; + const void * pNext = {}; + const char * pName = {}; + uint32_t index = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineShaderStageNodeCreateInfoAMDX; + }; +# endif + + template <> + struct CppType + { + using Type = PipelineShaderStageNodeCreateInfoAMDX; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.html + struct PipelineShaderStageRequiredSubgroupSizeCreateInfo + { + using NativeType = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineShaderStageRequiredSubgroupSizeCreateInfo( uint32_t requiredSubgroupSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , requiredSubgroupSize{ requiredSubgroupSize_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineShaderStageRequiredSubgroupSizeCreateInfo( PipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineShaderStageRequiredSubgroupSizeCreateInfo( VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineShaderStageRequiredSubgroupSizeCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PipelineShaderStageRequiredSubgroupSizeCreateInfo & + operator=( PipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineShaderStageRequiredSubgroupSizeCreateInfo & operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageRequiredSubgroupSizeCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageRequiredSubgroupSizeCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageRequiredSubgroupSizeCreateInfo & setRequiredSubgroupSize( uint32_t requiredSubgroupSize_ ) & VULKAN_HPP_NOEXCEPT + { + requiredSubgroupSize = requiredSubgroupSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageRequiredSubgroupSizeCreateInfo && setRequiredSubgroupSize( uint32_t requiredSubgroupSize_ ) && + VULKAN_HPP_NOEXCEPT + { + requiredSubgroupSize = requiredSubgroupSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, requiredSubgroupSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineShaderStageRequiredSubgroupSizeCreateInfo const & ) const = default; +#else + bool operator==( PipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( requiredSubgroupSize == rhs.requiredSubgroupSize ); +# endif + } + + bool operator!=( PipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfo; + const void * pNext = {}; + uint32_t requiredSubgroupSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfo; + }; + + using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; + using ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; + + // wrapper struct for struct VkPipelineTessellationDomainOriginStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineTessellationDomainOriginStateCreateInfo.html + struct PipelineTessellationDomainOriginStateCreateInfo + { + using NativeType = VkPipelineTessellationDomainOriginStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( TessellationDomainOrigin domainOrigin_ = TessellationDomainOrigin::eUpperLeft, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , domainOrigin{ domainOrigin_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineTessellationDomainOriginStateCreateInfo( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineTessellationDomainOriginStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PipelineTessellationDomainOriginStateCreateInfo & operator=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineTessellationDomainOriginStateCreateInfo & operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineTessellationDomainOriginStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineTessellationDomainOriginStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineTessellationDomainOriginStateCreateInfo & setDomainOrigin( TessellationDomainOrigin domainOrigin_ ) & VULKAN_HPP_NOEXCEPT + { + domainOrigin = domainOrigin_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineTessellationDomainOriginStateCreateInfo && setDomainOrigin( TessellationDomainOrigin domainOrigin_ ) && VULKAN_HPP_NOEXCEPT + { + domainOrigin = domainOrigin_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineTessellationDomainOriginStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineTessellationDomainOriginStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineTessellationDomainOriginStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineTessellationDomainOriginStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, domainOrigin ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineTessellationDomainOriginStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( domainOrigin == rhs.domainOrigin ); +# endif + } + + bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; + const void * pNext = {}; + TessellationDomainOrigin domainOrigin = TessellationDomainOrigin::eUpperLeft; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineTessellationDomainOriginStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineTessellationDomainOriginStateCreateInfo; + }; + + using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo; + + // wrapper struct for struct VkVertexInputBindingDivisorDescription, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputBindingDivisorDescription.html + struct VertexInputBindingDivisorDescription + { + using NativeType = VkVertexInputBindingDivisorDescription; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VertexInputBindingDivisorDescription( uint32_t binding_ = {}, uint32_t divisor_ = {} ) VULKAN_HPP_NOEXCEPT + : binding{ binding_ } + , divisor{ divisor_ } + { + } + + VULKAN_HPP_CONSTEXPR VertexInputBindingDivisorDescription( VertexInputBindingDivisorDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VertexInputBindingDivisorDescription( VkVertexInputBindingDivisorDescription const & rhs ) VULKAN_HPP_NOEXCEPT + : VertexInputBindingDivisorDescription( *reinterpret_cast( &rhs ) ) + { + } + + VertexInputBindingDivisorDescription & operator=( VertexInputBindingDivisorDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VertexInputBindingDivisorDescription & operator=( VkVertexInputBindingDivisorDescription const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDivisorDescription & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDivisorDescription && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDivisorDescription & setDivisor( uint32_t divisor_ ) & VULKAN_HPP_NOEXCEPT + { + divisor = divisor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDivisorDescription && setDivisor( uint32_t divisor_ ) && VULKAN_HPP_NOEXCEPT + { + divisor = divisor_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVertexInputBindingDivisorDescription const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputBindingDivisorDescription &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputBindingDivisorDescription const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVertexInputBindingDivisorDescription *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( binding, divisor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VertexInputBindingDivisorDescription const & ) const = default; +#else + bool operator==( VertexInputBindingDivisorDescription const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( binding == rhs.binding ) && ( divisor == rhs.divisor ); +# endif + } + + bool operator!=( VertexInputBindingDivisorDescription const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t binding = {}; + uint32_t divisor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VertexInputBindingDivisorDescription; + }; +#endif + using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescription; + using VertexInputBindingDivisorDescriptionKHR = VertexInputBindingDivisorDescription; + + // wrapper struct for struct VkPipelineVertexInputDivisorStateCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineVertexInputDivisorStateCreateInfo.html + struct PipelineVertexInputDivisorStateCreateInfo + { + using NativeType = VkPipelineVertexInputDivisorStateCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineVertexInputDivisorStateCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfo( uint32_t vertexBindingDivisorCount_ = {}, + const VertexInputBindingDivisorDescription * pVertexBindingDivisors_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , vertexBindingDivisorCount{ vertexBindingDivisorCount_ } + , pVertexBindingDivisors{ pVertexBindingDivisors_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfo( PipelineVertexInputDivisorStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineVertexInputDivisorStateCreateInfo( VkPipelineVertexInputDivisorStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineVertexInputDivisorStateCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineVertexInputDivisorStateCreateInfo( ArrayProxyNoTemporaries const & vertexBindingDivisors_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , vertexBindingDivisorCount( static_cast( vertexBindingDivisors_.size() ) ) + , pVertexBindingDivisors( vertexBindingDivisors_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineVertexInputDivisorStateCreateInfo & operator=( PipelineVertexInputDivisorStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineVertexInputDivisorStateCreateInfo & operator=( VkPipelineVertexInputDivisorStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo & setVertexBindingDivisorCount( uint32_t vertexBindingDivisorCount_ ) & + VULKAN_HPP_NOEXCEPT + { + vertexBindingDivisorCount = vertexBindingDivisorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo && setVertexBindingDivisorCount( uint32_t vertexBindingDivisorCount_ ) && + VULKAN_HPP_NOEXCEPT + { + vertexBindingDivisorCount = vertexBindingDivisorCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo & + setPVertexBindingDivisors( const VertexInputBindingDivisorDescription * pVertexBindingDivisors_ ) & + VULKAN_HPP_NOEXCEPT + { + pVertexBindingDivisors = pVertexBindingDivisors_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo && + setPVertexBindingDivisors( const VertexInputBindingDivisorDescription * pVertexBindingDivisors_ ) && + VULKAN_HPP_NOEXCEPT + { + pVertexBindingDivisors = pVertexBindingDivisors_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineVertexInputDivisorStateCreateInfo & + setVertexBindingDivisors( ArrayProxyNoTemporaries const & vertexBindingDivisors_ ) VULKAN_HPP_NOEXCEPT + { + vertexBindingDivisorCount = static_cast( vertexBindingDivisors_.size() ); + pVertexBindingDivisors = vertexBindingDivisors_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineVertexInputDivisorStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineVertexInputDivisorStateCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineVertexInputDivisorStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineVertexInputDivisorStateCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, vertexBindingDivisorCount, pVertexBindingDivisors ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineVertexInputDivisorStateCreateInfo const & ) const = default; +#else + bool operator==( PipelineVertexInputDivisorStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount ) && + ( pVertexBindingDivisors == rhs.pVertexBindingDivisors ); +# endif + } + + bool operator!=( PipelineVertexInputDivisorStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfo; + const void * pNext = {}; + uint32_t vertexBindingDivisorCount = {}; + const VertexInputBindingDivisorDescription * pVertexBindingDivisors = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineVertexInputDivisorStateCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineVertexInputDivisorStateCreateInfo; + }; + + using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfo; + using PipelineVertexInputDivisorStateCreateInfoKHR = PipelineVertexInputDivisorStateCreateInfo; + + // wrapper struct for struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.html + struct PipelineViewportCoarseSampleOrderStateCreateInfoNV + { + using NativeType = VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( CoarseSampleOrderTypeNV sampleOrderType_ = CoarseSampleOrderTypeNV::eDefault, + uint32_t customSampleOrderCount_ = {}, + const CoarseSampleOrderCustomNV * pCustomSampleOrders_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , sampleOrderType{ sampleOrderType_ } + , customSampleOrderCount{ customSampleOrderCount_ } + , pCustomSampleOrders{ pCustomSampleOrders_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineViewportCoarseSampleOrderStateCreateInfoNV( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineViewportCoarseSampleOrderStateCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportCoarseSampleOrderStateCreateInfoNV( CoarseSampleOrderTypeNV sampleOrderType_, + ArrayProxyNoTemporaries const & customSampleOrders_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , sampleOrderType( sampleOrderType_ ) + , customSampleOrderCount( static_cast( customSampleOrders_.size() ) ) + , pCustomSampleOrders( customSampleOrders_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineViewportCoarseSampleOrderStateCreateInfoNV & + operator=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineViewportCoarseSampleOrderStateCreateInfoNV & operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV & setSampleOrderType( CoarseSampleOrderTypeNV sampleOrderType_ ) & + VULKAN_HPP_NOEXCEPT + { + sampleOrderType = sampleOrderType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV && setSampleOrderType( CoarseSampleOrderTypeNV sampleOrderType_ ) && + VULKAN_HPP_NOEXCEPT + { + sampleOrderType = sampleOrderType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV & setCustomSampleOrderCount( uint32_t customSampleOrderCount_ ) & + VULKAN_HPP_NOEXCEPT + { + customSampleOrderCount = customSampleOrderCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV && setCustomSampleOrderCount( uint32_t customSampleOrderCount_ ) && + VULKAN_HPP_NOEXCEPT + { + customSampleOrderCount = customSampleOrderCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV & + setPCustomSampleOrders( const CoarseSampleOrderCustomNV * pCustomSampleOrders_ ) & + VULKAN_HPP_NOEXCEPT + { + pCustomSampleOrders = pCustomSampleOrders_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV && + setPCustomSampleOrders( const CoarseSampleOrderCustomNV * pCustomSampleOrders_ ) && + VULKAN_HPP_NOEXCEPT + { + pCustomSampleOrders = pCustomSampleOrders_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportCoarseSampleOrderStateCreateInfoNV & + setCustomSampleOrders( ArrayProxyNoTemporaries const & customSampleOrders_ ) VULKAN_HPP_NOEXCEPT + { + customSampleOrderCount = static_cast( customSampleOrders_.size() ); + pCustomSampleOrders = customSampleOrders_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sampleOrderType, customSampleOrderCount, pCustomSampleOrders ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & ) const = default; +#else + bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleOrderType == rhs.sampleOrderType ) && + ( customSampleOrderCount == rhs.customSampleOrderCount ) && ( pCustomSampleOrders == rhs.pCustomSampleOrders ); +# endif + } + + bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; + const void * pNext = {}; + CoarseSampleOrderTypeNV sampleOrderType = CoarseSampleOrderTypeNV::eDefault; + uint32_t customSampleOrderCount = {}; + const CoarseSampleOrderCustomNV * pCustomSampleOrders = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineViewportCoarseSampleOrderStateCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineViewportCoarseSampleOrderStateCreateInfoNV; + }; + + // wrapper struct for struct VkPipelineViewportDepthClampControlCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportDepthClampControlCreateInfoEXT.html + struct PipelineViewportDepthClampControlCreateInfoEXT + { + using NativeType = VkPipelineViewportDepthClampControlCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportDepthClampControlCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineViewportDepthClampControlCreateInfoEXT( DepthClampModeEXT depthClampMode_ = DepthClampModeEXT::eViewportRange, + const DepthClampRangeEXT * pDepthClampRange_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , depthClampMode{ depthClampMode_ } + , pDepthClampRange{ pDepthClampRange_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineViewportDepthClampControlCreateInfoEXT( PipelineViewportDepthClampControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineViewportDepthClampControlCreateInfoEXT( VkPipelineViewportDepthClampControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineViewportDepthClampControlCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PipelineViewportDepthClampControlCreateInfoEXT & operator=( PipelineViewportDepthClampControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineViewportDepthClampControlCreateInfoEXT & operator=( VkPipelineViewportDepthClampControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT & setDepthClampMode( DepthClampModeEXT depthClampMode_ ) & VULKAN_HPP_NOEXCEPT + { + depthClampMode = depthClampMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT && setDepthClampMode( DepthClampModeEXT depthClampMode_ ) && VULKAN_HPP_NOEXCEPT + { + depthClampMode = depthClampMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT & setPDepthClampRange( const DepthClampRangeEXT * pDepthClampRange_ ) & + VULKAN_HPP_NOEXCEPT + { + pDepthClampRange = pDepthClampRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT && setPDepthClampRange( const DepthClampRangeEXT * pDepthClampRange_ ) && + VULKAN_HPP_NOEXCEPT + { + pDepthClampRange = pDepthClampRange_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineViewportDepthClampControlCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportDepthClampControlCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportDepthClampControlCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineViewportDepthClampControlCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthClampMode, pDepthClampRange ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineViewportDepthClampControlCreateInfoEXT const & ) const = default; +#else + bool operator==( PipelineViewportDepthClampControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClampMode == rhs.depthClampMode ) && ( pDepthClampRange == rhs.pDepthClampRange ); +# endif + } + + bool operator!=( PipelineViewportDepthClampControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineViewportDepthClampControlCreateInfoEXT; + const void * pNext = {}; + DepthClampModeEXT depthClampMode = DepthClampModeEXT::eViewportRange; + const DepthClampRangeEXT * pDepthClampRange = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineViewportDepthClampControlCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineViewportDepthClampControlCreateInfoEXT; + }; + + // wrapper struct for struct VkPipelineViewportDepthClipControlCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportDepthClipControlCreateInfoEXT.html + struct PipelineViewportDepthClipControlCreateInfoEXT + { + using NativeType = VkPipelineViewportDepthClipControlCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportDepthClipControlCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineViewportDepthClipControlCreateInfoEXT( Bool32 negativeOneToOne_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , negativeOneToOne{ negativeOneToOne_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineViewportDepthClipControlCreateInfoEXT( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineViewportDepthClipControlCreateInfoEXT( VkPipelineViewportDepthClipControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineViewportDepthClipControlCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PipelineViewportDepthClipControlCreateInfoEXT & operator=( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineViewportDepthClipControlCreateInfoEXT & operator=( VkPipelineViewportDepthClipControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClipControlCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClipControlCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClipControlCreateInfoEXT & setNegativeOneToOne( Bool32 negativeOneToOne_ ) & VULKAN_HPP_NOEXCEPT + { + negativeOneToOne = negativeOneToOne_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClipControlCreateInfoEXT && setNegativeOneToOne( Bool32 negativeOneToOne_ ) && VULKAN_HPP_NOEXCEPT + { + negativeOneToOne = negativeOneToOne_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineViewportDepthClipControlCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportDepthClipControlCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportDepthClipControlCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineViewportDepthClipControlCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, negativeOneToOne ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineViewportDepthClipControlCreateInfoEXT const & ) const = default; +#else + bool operator==( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( negativeOneToOne == rhs.negativeOneToOne ); +# endif + } + + bool operator!=( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineViewportDepthClipControlCreateInfoEXT; + const void * pNext = {}; + Bool32 negativeOneToOne = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineViewportDepthClipControlCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineViewportDepthClipControlCreateInfoEXT; + }; + + // wrapper struct for struct VkPipelineViewportExclusiveScissorStateCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportExclusiveScissorStateCreateInfoNV.html + struct PipelineViewportExclusiveScissorStateCreateInfoNV + { + using NativeType = VkPipelineViewportExclusiveScissorStateCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = {}, + const Rect2D * pExclusiveScissors_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , exclusiveScissorCount{ exclusiveScissorCount_ } + , pExclusiveScissors{ pExclusiveScissors_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineViewportExclusiveScissorStateCreateInfoNV( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineViewportExclusiveScissorStateCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportExclusiveScissorStateCreateInfoNV( ArrayProxyNoTemporaries const & exclusiveScissors_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), exclusiveScissorCount( static_cast( exclusiveScissors_.size() ) ), pExclusiveScissors( exclusiveScissors_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineViewportExclusiveScissorStateCreateInfoNV & + operator=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineViewportExclusiveScissorStateCreateInfoNV & operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV & setExclusiveScissorCount( uint32_t exclusiveScissorCount_ ) & + VULKAN_HPP_NOEXCEPT + { + exclusiveScissorCount = exclusiveScissorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV && setExclusiveScissorCount( uint32_t exclusiveScissorCount_ ) && + VULKAN_HPP_NOEXCEPT + { + exclusiveScissorCount = exclusiveScissorCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV & setPExclusiveScissors( const Rect2D * pExclusiveScissors_ ) & + VULKAN_HPP_NOEXCEPT + { + pExclusiveScissors = pExclusiveScissors_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV && setPExclusiveScissors( const Rect2D * pExclusiveScissors_ ) && + VULKAN_HPP_NOEXCEPT + { + pExclusiveScissors = pExclusiveScissors_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportExclusiveScissorStateCreateInfoNV & + setExclusiveScissors( ArrayProxyNoTemporaries const & exclusiveScissors_ ) VULKAN_HPP_NOEXCEPT + { + exclusiveScissorCount = static_cast( exclusiveScissors_.size() ); + pExclusiveScissors = exclusiveScissors_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineViewportExclusiveScissorStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, exclusiveScissorCount, pExclusiveScissors ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineViewportExclusiveScissorStateCreateInfoNV const & ) const = default; +#else + bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissorCount == rhs.exclusiveScissorCount ) && + ( pExclusiveScissors == rhs.pExclusiveScissors ); +# endif + } + + bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; + const void * pNext = {}; + uint32_t exclusiveScissorCount = {}; + const Rect2D * pExclusiveScissors = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineViewportExclusiveScissorStateCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineViewportExclusiveScissorStateCreateInfoNV; + }; + + // wrapper struct for struct VkShadingRatePaletteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShadingRatePaletteNV.html + struct ShadingRatePaletteNV + { + using NativeType = VkShadingRatePaletteNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = {}, + const ShadingRatePaletteEntryNV * pShadingRatePaletteEntries_ = {} ) VULKAN_HPP_NOEXCEPT + : shadingRatePaletteEntryCount{ shadingRatePaletteEntryCount_ } + , pShadingRatePaletteEntries{ pShadingRatePaletteEntries_ } + { + } + + VULKAN_HPP_CONSTEXPR ShadingRatePaletteNV( ShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ShadingRatePaletteNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ShadingRatePaletteNV( ArrayProxyNoTemporaries const & shadingRatePaletteEntries_ ) + : shadingRatePaletteEntryCount( static_cast( shadingRatePaletteEntries_.size() ) ) + , pShadingRatePaletteEntries( shadingRatePaletteEntries_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ShadingRatePaletteNV & operator=( ShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ShadingRatePaletteNV & operator=( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ShadingRatePaletteNV & setShadingRatePaletteEntryCount( uint32_t shadingRatePaletteEntryCount_ ) & VULKAN_HPP_NOEXCEPT + { + shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShadingRatePaletteNV && setShadingRatePaletteEntryCount( uint32_t shadingRatePaletteEntryCount_ ) && VULKAN_HPP_NOEXCEPT + { + shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShadingRatePaletteNV & setPShadingRatePaletteEntries( const ShadingRatePaletteEntryNV * pShadingRatePaletteEntries_ ) & + VULKAN_HPP_NOEXCEPT + { + pShadingRatePaletteEntries = pShadingRatePaletteEntries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShadingRatePaletteNV && setPShadingRatePaletteEntries( const ShadingRatePaletteEntryNV * pShadingRatePaletteEntries_ ) && + VULKAN_HPP_NOEXCEPT + { + pShadingRatePaletteEntries = pShadingRatePaletteEntries_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ShadingRatePaletteNV & + setShadingRatePaletteEntries( ArrayProxyNoTemporaries const & shadingRatePaletteEntries_ ) VULKAN_HPP_NOEXCEPT + { + shadingRatePaletteEntryCount = static_cast( shadingRatePaletteEntries_.size() ); + pShadingRatePaletteEntries = shadingRatePaletteEntries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkShadingRatePaletteNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShadingRatePaletteNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShadingRatePaletteNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkShadingRatePaletteNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( shadingRatePaletteEntryCount, pShadingRatePaletteEntries ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ShadingRatePaletteNV const & ) const = default; +#else + bool operator==( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount ) && ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries ); +# endif + } + + bool operator!=( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t shadingRatePaletteEntryCount = {}; + const ShadingRatePaletteEntryNV * pShadingRatePaletteEntries = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ShadingRatePaletteNV; + }; +#endif + + // wrapper struct for struct VkPipelineViewportShadingRateImageStateCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportShadingRateImageStateCreateInfoNV.html + struct PipelineViewportShadingRateImageStateCreateInfoNV + { + using NativeType = VkPipelineViewportShadingRateImageStateCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( Bool32 shadingRateImageEnable_ = {}, + uint32_t viewportCount_ = {}, + const ShadingRatePaletteNV * pShadingRatePalettes_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , shadingRateImageEnable{ shadingRateImageEnable_ } + , viewportCount{ viewportCount_ } + , pShadingRatePalettes{ pShadingRatePalettes_ } + { + } + + VULKAN_HPP_CONSTEXPR + PipelineViewportShadingRateImageStateCreateInfoNV( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineViewportShadingRateImageStateCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportShadingRateImageStateCreateInfoNV( Bool32 shadingRateImageEnable_, + ArrayProxyNoTemporaries const & shadingRatePalettes_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , shadingRateImageEnable( shadingRateImageEnable_ ) + , viewportCount( static_cast( shadingRatePalettes_.size() ) ) + , pShadingRatePalettes( shadingRatePalettes_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineViewportShadingRateImageStateCreateInfoNV & + operator=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineViewportShadingRateImageStateCreateInfoNV & operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV & setShadingRateImageEnable( Bool32 shadingRateImageEnable_ ) & + VULKAN_HPP_NOEXCEPT + { + shadingRateImageEnable = shadingRateImageEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV && setShadingRateImageEnable( Bool32 shadingRateImageEnable_ ) && + VULKAN_HPP_NOEXCEPT + { + shadingRateImageEnable = shadingRateImageEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV & setViewportCount( uint32_t viewportCount_ ) & VULKAN_HPP_NOEXCEPT + { + viewportCount = viewportCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV && setViewportCount( uint32_t viewportCount_ ) && VULKAN_HPP_NOEXCEPT + { + viewportCount = viewportCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV & setPShadingRatePalettes( const ShadingRatePaletteNV * pShadingRatePalettes_ ) & + VULKAN_HPP_NOEXCEPT + { + pShadingRatePalettes = pShadingRatePalettes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV && + setPShadingRatePalettes( const ShadingRatePaletteNV * pShadingRatePalettes_ ) && + VULKAN_HPP_NOEXCEPT + { + pShadingRatePalettes = pShadingRatePalettes_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportShadingRateImageStateCreateInfoNV & + setShadingRatePalettes( ArrayProxyNoTemporaries const & shadingRatePalettes_ ) VULKAN_HPP_NOEXCEPT + { + viewportCount = static_cast( shadingRatePalettes_.size() ); + pShadingRatePalettes = shadingRatePalettes_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineViewportShadingRateImageStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportShadingRateImageStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportShadingRateImageStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineViewportShadingRateImageStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shadingRateImageEnable, viewportCount, pShadingRatePalettes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineViewportShadingRateImageStateCreateInfoNV const & ) const = default; +#else + bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImageEnable == rhs.shadingRateImageEnable ) && + ( viewportCount == rhs.viewportCount ) && ( pShadingRatePalettes == rhs.pShadingRatePalettes ); +# endif + } + + bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; + const void * pNext = {}; + Bool32 shadingRateImageEnable = {}; + uint32_t viewportCount = {}; + const ShadingRatePaletteNV * pShadingRatePalettes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineViewportShadingRateImageStateCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineViewportShadingRateImageStateCreateInfoNV; + }; + + // wrapper struct for struct VkViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViewportSwizzleNV.html + struct ViewportSwizzleNV + { + using NativeType = VkViewportSwizzleNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ViewportSwizzleNV( ViewportCoordinateSwizzleNV x_ = ViewportCoordinateSwizzleNV::ePositiveX, + ViewportCoordinateSwizzleNV y_ = ViewportCoordinateSwizzleNV::ePositiveX, + ViewportCoordinateSwizzleNV z_ = ViewportCoordinateSwizzleNV::ePositiveX, + ViewportCoordinateSwizzleNV w_ = ViewportCoordinateSwizzleNV::ePositiveX ) VULKAN_HPP_NOEXCEPT + : x{ x_ } + , y{ y_ } + , z{ z_ } + , w{ w_ } + { + } + + VULKAN_HPP_CONSTEXPR ViewportSwizzleNV( ViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT : ViewportSwizzleNV( *reinterpret_cast( &rhs ) ) {} + + ViewportSwizzleNV & operator=( ViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ViewportSwizzleNV & operator=( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV & setX( ViewportCoordinateSwizzleNV x_ ) & VULKAN_HPP_NOEXCEPT + { + x = x_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV && setX( ViewportCoordinateSwizzleNV x_ ) && VULKAN_HPP_NOEXCEPT + { + x = x_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV & setY( ViewportCoordinateSwizzleNV y_ ) & VULKAN_HPP_NOEXCEPT + { + y = y_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV && setY( ViewportCoordinateSwizzleNV y_ ) && VULKAN_HPP_NOEXCEPT + { + y = y_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV & setZ( ViewportCoordinateSwizzleNV z_ ) & VULKAN_HPP_NOEXCEPT + { + z = z_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV && setZ( ViewportCoordinateSwizzleNV z_ ) && VULKAN_HPP_NOEXCEPT + { + z = z_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV & setW( ViewportCoordinateSwizzleNV w_ ) & VULKAN_HPP_NOEXCEPT + { + w = w_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV && setW( ViewportCoordinateSwizzleNV w_ ) && VULKAN_HPP_NOEXCEPT + { + w = w_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkViewportSwizzleNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkViewportSwizzleNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkViewportSwizzleNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkViewportSwizzleNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( x, y, z, w ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ViewportSwizzleNV const & ) const = default; +#else + bool operator==( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ) && ( w == rhs.w ); +# endif + } + + bool operator!=( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ViewportCoordinateSwizzleNV x = ViewportCoordinateSwizzleNV::ePositiveX; + ViewportCoordinateSwizzleNV y = ViewportCoordinateSwizzleNV::ePositiveX; + ViewportCoordinateSwizzleNV z = ViewportCoordinateSwizzleNV::ePositiveX; + ViewportCoordinateSwizzleNV w = ViewportCoordinateSwizzleNV::ePositiveX; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ViewportSwizzleNV; + }; +#endif + + // wrapper struct for struct VkPipelineViewportSwizzleStateCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportSwizzleStateCreateInfoNV.html + struct PipelineViewportSwizzleStateCreateInfoNV + { + using NativeType = VkPipelineViewportSwizzleStateCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = {}, + uint32_t viewportCount_ = {}, + const ViewportSwizzleNV * pViewportSwizzles_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , viewportCount{ viewportCount_ } + , pViewportSwizzles{ pViewportSwizzles_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineViewportSwizzleStateCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_, + ArrayProxyNoTemporaries const & viewportSwizzles_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), flags( flags_ ), viewportCount( static_cast( viewportSwizzles_.size() ) ), pViewportSwizzles( viewportSwizzles_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineViewportSwizzleStateCreateInfoNV & operator=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineViewportSwizzleStateCreateInfoNV & operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV & setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV && setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV & setViewportCount( uint32_t viewportCount_ ) & VULKAN_HPP_NOEXCEPT + { + viewportCount = viewportCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV && setViewportCount( uint32_t viewportCount_ ) && VULKAN_HPP_NOEXCEPT + { + viewportCount = viewportCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV & setPViewportSwizzles( const ViewportSwizzleNV * pViewportSwizzles_ ) & + VULKAN_HPP_NOEXCEPT + { + pViewportSwizzles = pViewportSwizzles_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV && setPViewportSwizzles( const ViewportSwizzleNV * pViewportSwizzles_ ) && + VULKAN_HPP_NOEXCEPT + { + pViewportSwizzles = pViewportSwizzles_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportSwizzleStateCreateInfoNV & + setViewportSwizzles( ArrayProxyNoTemporaries const & viewportSwizzles_ ) VULKAN_HPP_NOEXCEPT + { + viewportCount = static_cast( viewportSwizzles_.size() ); + pViewportSwizzles = viewportSwizzles_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineViewportSwizzleStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportSwizzleStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportSwizzleStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineViewportSwizzleStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, viewportCount, pViewportSwizzles ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineViewportSwizzleStateCreateInfoNV const & ) const = default; +#else + bool operator==( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( viewportCount == rhs.viewportCount ) && + ( pViewportSwizzles == rhs.pViewportSwizzles ); +# endif + } + + bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; + const void * pNext = {}; + PipelineViewportSwizzleStateCreateFlagsNV flags = {}; + uint32_t viewportCount = {}; + const ViewportSwizzleNV * pViewportSwizzles = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineViewportSwizzleStateCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineViewportSwizzleStateCreateInfoNV; + }; + + // wrapper struct for struct VkViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViewportWScalingNV.html + struct ViewportWScalingNV + { + using NativeType = VkViewportWScalingNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ViewportWScalingNV( float xcoeff_ = {}, float ycoeff_ = {} ) VULKAN_HPP_NOEXCEPT + : xcoeff{ xcoeff_ } + , ycoeff{ ycoeff_ } + { + } + + VULKAN_HPP_CONSTEXPR ViewportWScalingNV( ViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ViewportWScalingNV( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT : ViewportWScalingNV( *reinterpret_cast( &rhs ) ) {} + + ViewportWScalingNV & operator=( ViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ViewportWScalingNV & operator=( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ViewportWScalingNV & setXcoeff( float xcoeff_ ) & VULKAN_HPP_NOEXCEPT + { + xcoeff = xcoeff_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ViewportWScalingNV && setXcoeff( float xcoeff_ ) && VULKAN_HPP_NOEXCEPT + { + xcoeff = xcoeff_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ViewportWScalingNV & setYcoeff( float ycoeff_ ) & VULKAN_HPP_NOEXCEPT + { + ycoeff = ycoeff_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ViewportWScalingNV && setYcoeff( float ycoeff_ ) && VULKAN_HPP_NOEXCEPT + { + ycoeff = ycoeff_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkViewportWScalingNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkViewportWScalingNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkViewportWScalingNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkViewportWScalingNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( xcoeff, ycoeff ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ViewportWScalingNV const & ) const = default; +#else + bool operator==( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( xcoeff == rhs.xcoeff ) && ( ycoeff == rhs.ycoeff ); +# endif + } + + bool operator!=( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + float xcoeff = {}; + float ycoeff = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ViewportWScalingNV; + }; +#endif + + // wrapper struct for struct VkPipelineViewportWScalingStateCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportWScalingStateCreateInfoNV.html + struct PipelineViewportWScalingStateCreateInfoNV + { + using NativeType = VkPipelineViewportWScalingStateCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = {}, + uint32_t viewportCount_ = {}, + const ViewportWScalingNV * pViewportWScalings_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , viewportWScalingEnable{ viewportWScalingEnable_ } + , viewportCount{ viewportCount_ } + , pViewportWScalings{ pViewportWScalings_ } + { + } + + VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( PipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PipelineViewportWScalingStateCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_, + ArrayProxyNoTemporaries const & viewportWScalings_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , viewportWScalingEnable( viewportWScalingEnable_ ) + , viewportCount( static_cast( viewportWScalings_.size() ) ) + , pViewportWScalings( viewportWScalings_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PipelineViewportWScalingStateCreateInfoNV & operator=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PipelineViewportWScalingStateCreateInfoNV & operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV & setViewportWScalingEnable( Bool32 viewportWScalingEnable_ ) & VULKAN_HPP_NOEXCEPT + { + viewportWScalingEnable = viewportWScalingEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV && setViewportWScalingEnable( Bool32 viewportWScalingEnable_ ) && VULKAN_HPP_NOEXCEPT + { + viewportWScalingEnable = viewportWScalingEnable_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV & setViewportCount( uint32_t viewportCount_ ) & VULKAN_HPP_NOEXCEPT + { + viewportCount = viewportCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV && setViewportCount( uint32_t viewportCount_ ) && VULKAN_HPP_NOEXCEPT + { + viewportCount = viewportCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV & setPViewportWScalings( const ViewportWScalingNV * pViewportWScalings_ ) & + VULKAN_HPP_NOEXCEPT + { + pViewportWScalings = pViewportWScalings_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV && setPViewportWScalings( const ViewportWScalingNV * pViewportWScalings_ ) && + VULKAN_HPP_NOEXCEPT + { + pViewportWScalings = pViewportWScalings_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PipelineViewportWScalingStateCreateInfoNV & + setViewportWScalings( ArrayProxyNoTemporaries const & viewportWScalings_ ) VULKAN_HPP_NOEXCEPT + { + viewportCount = static_cast( viewportWScalings_.size() ); + pViewportWScalings = viewportWScalings_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPipelineViewportWScalingStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportWScalingStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPipelineViewportWScalingStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPipelineViewportWScalingStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, viewportWScalingEnable, viewportCount, pViewportWScalings ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PipelineViewportWScalingStateCreateInfoNV const & ) const = default; +#else + bool operator==( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportWScalingEnable == rhs.viewportWScalingEnable ) && + ( viewportCount == rhs.viewportCount ) && ( pViewportWScalings == rhs.pViewportWScalings ); +# endif + } + + bool operator!=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; + const void * pNext = {}; + Bool32 viewportWScalingEnable = {}; + uint32_t viewportCount = {}; + const ViewportWScalingNV * pViewportWScalings = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PipelineViewportWScalingStateCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PipelineViewportWScalingStateCreateInfoNV; + }; + +#if defined( VK_USE_PLATFORM_GGP ) + // wrapper struct for struct VkPresentFrameTokenGGP, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentFrameTokenGGP.html + struct PresentFrameTokenGGP + { + using NativeType = VkPresentFrameTokenGGP; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentFrameTokenGGP; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , frameToken{ frameToken_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( PresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT + : PresentFrameTokenGGP( *reinterpret_cast( &rhs ) ) + { + } + + PresentFrameTokenGGP & operator=( PresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentFrameTokenGGP & operator=( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentFrameTokenGGP & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentFrameTokenGGP && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentFrameTokenGGP & setFrameToken( GgpFrameToken frameToken_ ) & VULKAN_HPP_NOEXCEPT + { + frameToken = frameToken_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentFrameTokenGGP && setFrameToken( GgpFrameToken frameToken_ ) && VULKAN_HPP_NOEXCEPT + { + frameToken = frameToken_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentFrameTokenGGP const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentFrameTokenGGP &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentFrameTokenGGP const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentFrameTokenGGP *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, frameToken ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &frameToken, &rhs.frameToken, sizeof( GgpFrameToken ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &frameToken, &rhs.frameToken, sizeof( GgpFrameToken ) ) == 0 ); + } + + bool operator!=( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::ePresentFrameTokenGGP; + const void * pNext = {}; + GgpFrameToken frameToken = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentFrameTokenGGP; + }; +# endif + + template <> + struct CppType + { + using Type = PresentFrameTokenGGP; + }; +#endif /*VK_USE_PLATFORM_GGP*/ + + // wrapper struct for struct VkPresentId2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentId2KHR.html + struct PresentId2KHR + { + using NativeType = VkPresentId2KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentId2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentId2KHR( uint32_t swapchainCount_ = {}, const uint64_t * pPresentIds_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchainCount{ swapchainCount_ } + , pPresentIds{ pPresentIds_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentId2KHR( PresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentId2KHR( VkPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentId2KHR( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentId2KHR( ArrayProxyNoTemporaries const & presentIds_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), swapchainCount( static_cast( presentIds_.size() ) ), pPresentIds( presentIds_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PresentId2KHR & operator=( PresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentId2KHR & operator=( VkPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentId2KHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentId2KHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentId2KHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentId2KHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentId2KHR & setPPresentIds( const uint64_t * pPresentIds_ ) & VULKAN_HPP_NOEXCEPT + { + pPresentIds = pPresentIds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentId2KHR && setPPresentIds( const uint64_t * pPresentIds_ ) && VULKAN_HPP_NOEXCEPT + { + pPresentIds = pPresentIds_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentId2KHR & setPresentIds( ArrayProxyNoTemporaries const & presentIds_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( presentIds_.size() ); + pPresentIds = presentIds_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentId2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentId2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentId2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentId2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pPresentIds ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentId2KHR const & ) const = default; +#else + bool operator==( PresentId2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pPresentIds == rhs.pPresentIds ); +# endif + } + + bool operator!=( PresentId2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentId2KHR; + const void * pNext = {}; + uint32_t swapchainCount = {}; + const uint64_t * pPresentIds = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentId2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = PresentId2KHR; + }; + + // wrapper struct for struct VkPresentIdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentIdKHR.html + struct PresentIdKHR + { + using NativeType = VkPresentIdKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentIdKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentIdKHR( uint32_t swapchainCount_ = {}, const uint64_t * pPresentIds_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchainCount{ swapchainCount_ } + , pPresentIds{ pPresentIds_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentIdKHR( PresentIdKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentIdKHR( VkPresentIdKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentIdKHR( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentIdKHR( ArrayProxyNoTemporaries const & presentIds_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), swapchainCount( static_cast( presentIds_.size() ) ), pPresentIds( presentIds_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PresentIdKHR & operator=( PresentIdKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentIdKHR & operator=( VkPresentIdKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentIdKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentIdKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentIdKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentIdKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentIdKHR & setPPresentIds( const uint64_t * pPresentIds_ ) & VULKAN_HPP_NOEXCEPT + { + pPresentIds = pPresentIds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentIdKHR && setPPresentIds( const uint64_t * pPresentIds_ ) && VULKAN_HPP_NOEXCEPT + { + pPresentIds = pPresentIds_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentIdKHR & setPresentIds( ArrayProxyNoTemporaries const & presentIds_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( presentIds_.size() ); + pPresentIds = presentIds_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentIdKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentIdKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentIdKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentIdKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pPresentIds ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentIdKHR const & ) const = default; +#else + bool operator==( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pPresentIds == rhs.pPresentIds ); +# endif + } + + bool operator!=( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentIdKHR; + const void * pNext = {}; + uint32_t swapchainCount = {}; + const uint64_t * pPresentIds = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentIdKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PresentIdKHR; + }; + + // wrapper struct for struct VkPresentInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentInfoKHR.html + struct PresentInfoKHR + { + using NativeType = VkPresentInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = {}, + const Semaphore * pWaitSemaphores_ = {}, + uint32_t swapchainCount_ = {}, + const SwapchainKHR * pSwapchains_ = {}, + const uint32_t * pImageIndices_ = {}, + Result * pResults_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , waitSemaphoreCount{ waitSemaphoreCount_ } + , pWaitSemaphores{ pWaitSemaphores_ } + , swapchainCount{ swapchainCount_ } + , pSwapchains{ pSwapchains_ } + , pImageIndices{ pImageIndices_ } + , pResults{ pResults_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentInfoKHR( PresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentInfoKHR( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentInfoKHR( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentInfoKHR( ArrayProxyNoTemporaries const & waitSemaphores_, + ArrayProxyNoTemporaries const & swapchains_ = {}, + ArrayProxyNoTemporaries const & imageIndices_ = {}, + ArrayProxyNoTemporaries const & results_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , waitSemaphoreCount( static_cast( waitSemaphores_.size() ) ) + , pWaitSemaphores( waitSemaphores_.data() ) + , swapchainCount( static_cast( swapchains_.size() ) ) + , pSwapchains( swapchains_.data() ) + , pImageIndices( imageIndices_.data() ) + , pResults( results_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( swapchains_.size() == imageIndices_.size() ); + VULKAN_HPP_ASSERT( results_.empty() || ( swapchains_.size() == results_.size() ) ); + VULKAN_HPP_ASSERT( results_.empty() || ( imageIndices_.size() == results_.size() ) ); +# else + if ( swapchains_.size() != imageIndices_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::PresentInfoKHR::PresentInfoKHR: swapchains_.size() != imageIndices_.size()" ); + } + if ( !results_.empty() && ( swapchains_.size() != results_.size() ) ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::PresentInfoKHR::PresentInfoKHR: !results_.empty() && ( swapchains_.size() != results_.size() )" ); + } + if ( !results_.empty() && ( imageIndices_.size() != results_.size() ) ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::PresentInfoKHR::PresentInfoKHR: !results_.empty() && ( imageIndices_.size() != results_.size() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PresentInfoKHR & operator=( PresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentInfoKHR & operator=( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = waitSemaphoreCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = waitSemaphoreCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) & VULKAN_HPP_NOEXCEPT + { + pWaitSemaphores = pWaitSemaphores_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) && VULKAN_HPP_NOEXCEPT + { + pWaitSemaphores = pWaitSemaphores_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentInfoKHR & setWaitSemaphores( ArrayProxyNoTemporaries const & waitSemaphores_ ) VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = static_cast( waitSemaphores_.size() ); + pWaitSemaphores = waitSemaphores_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setPSwapchains( const SwapchainKHR * pSwapchains_ ) & VULKAN_HPP_NOEXCEPT + { + pSwapchains = pSwapchains_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setPSwapchains( const SwapchainKHR * pSwapchains_ ) && VULKAN_HPP_NOEXCEPT + { + pSwapchains = pSwapchains_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentInfoKHR & setSwapchains( ArrayProxyNoTemporaries const & swapchains_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( swapchains_.size() ); + pSwapchains = swapchains_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setPImageIndices( const uint32_t * pImageIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pImageIndices = pImageIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setPImageIndices( const uint32_t * pImageIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pImageIndices = pImageIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentInfoKHR & setImageIndices( ArrayProxyNoTemporaries const & imageIndices_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( imageIndices_.size() ); + pImageIndices = imageIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setPResults( Result * pResults_ ) & VULKAN_HPP_NOEXCEPT + { + pResults = pResults_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setPResults( Result * pResults_ ) && VULKAN_HPP_NOEXCEPT + { + pResults = pResults_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentInfoKHR & setResults( ArrayProxyNoTemporaries const & results_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( results_.size() ); + pResults = results_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, waitSemaphoreCount, pWaitSemaphores, swapchainCount, pSwapchains, pImageIndices, pResults ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentInfoKHR const & ) const = default; +#else + bool operator==( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && + ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( swapchainCount == rhs.swapchainCount ) && ( pSwapchains == rhs.pSwapchains ) && + ( pImageIndices == rhs.pImageIndices ) && ( pResults == rhs.pResults ); +# endif + } + + bool operator!=( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentInfoKHR; + const void * pNext = {}; + uint32_t waitSemaphoreCount = {}; + const Semaphore * pWaitSemaphores = {}; + uint32_t swapchainCount = {}; + const SwapchainKHR * pSwapchains = {}; + const uint32_t * pImageIndices = {}; + Result * pResults = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PresentInfoKHR; + }; + + // wrapper struct for struct VkRectLayerKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRectLayerKHR.html + struct RectLayerKHR + { + using NativeType = VkRectLayerKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RectLayerKHR( Offset2D offset_ = {}, Extent2D extent_ = {}, uint32_t layer_ = {} ) VULKAN_HPP_NOEXCEPT + : offset{ offset_ } + , extent{ extent_ } + , layer{ layer_ } + { + } + + VULKAN_HPP_CONSTEXPR RectLayerKHR( RectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RectLayerKHR( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT : RectLayerKHR( *reinterpret_cast( &rhs ) ) {} + + explicit RectLayerKHR( Rect2D const & rect2D, uint32_t layer_ = {} ) : offset( rect2D.offset ), extent( rect2D.extent ), layer( layer_ ) {} + + RectLayerKHR & operator=( RectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RectLayerKHR & operator=( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RectLayerKHR & setOffset( Offset2D const & offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RectLayerKHR && setOffset( Offset2D const & offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RectLayerKHR & setExtent( Extent2D const & extent_ ) & VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RectLayerKHR && setExtent( Extent2D const & extent_ ) && VULKAN_HPP_NOEXCEPT + { + extent = extent_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RectLayerKHR & setLayer( uint32_t layer_ ) & VULKAN_HPP_NOEXCEPT + { + layer = layer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RectLayerKHR && setLayer( uint32_t layer_ ) && VULKAN_HPP_NOEXCEPT + { + layer = layer_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRectLayerKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRectLayerKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRectLayerKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRectLayerKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( offset, extent, layer ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RectLayerKHR const & ) const = default; +#else + bool operator==( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( offset == rhs.offset ) && ( extent == rhs.extent ) && ( layer == rhs.layer ); +# endif + } + + bool operator!=( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Offset2D offset = {}; + Extent2D extent = {}; + uint32_t layer = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RectLayerKHR; + }; +#endif + + // wrapper struct for struct VkPresentRegionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentRegionKHR.html + struct PresentRegionKHR + { + using NativeType = VkPresentRegionKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentRegionKHR( uint32_t rectangleCount_ = {}, const RectLayerKHR * pRectangles_ = {} ) VULKAN_HPP_NOEXCEPT + : rectangleCount{ rectangleCount_ } + , pRectangles{ pRectangles_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentRegionKHR( PresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentRegionKHR( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentRegionKHR( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentRegionKHR( ArrayProxyNoTemporaries const & rectangles_ ) + : rectangleCount( static_cast( rectangles_.size() ) ), pRectangles( rectangles_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PresentRegionKHR & operator=( PresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentRegionKHR & operator=( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentRegionKHR & setRectangleCount( uint32_t rectangleCount_ ) & VULKAN_HPP_NOEXCEPT + { + rectangleCount = rectangleCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentRegionKHR && setRectangleCount( uint32_t rectangleCount_ ) && VULKAN_HPP_NOEXCEPT + { + rectangleCount = rectangleCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentRegionKHR & setPRectangles( const RectLayerKHR * pRectangles_ ) & VULKAN_HPP_NOEXCEPT + { + pRectangles = pRectangles_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentRegionKHR && setPRectangles( const RectLayerKHR * pRectangles_ ) && VULKAN_HPP_NOEXCEPT + { + pRectangles = pRectangles_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentRegionKHR & setRectangles( ArrayProxyNoTemporaries const & rectangles_ ) VULKAN_HPP_NOEXCEPT + { + rectangleCount = static_cast( rectangles_.size() ); + pRectangles = rectangles_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentRegionKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentRegionKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentRegionKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentRegionKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( rectangleCount, pRectangles ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentRegionKHR const & ) const = default; +#else + bool operator==( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( rectangleCount == rhs.rectangleCount ) && ( pRectangles == rhs.pRectangles ); +# endif + } + + bool operator!=( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t rectangleCount = {}; + const RectLayerKHR * pRectangles = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentRegionKHR; + }; +#endif + + // wrapper struct for struct VkPresentRegionsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentRegionsKHR.html + struct PresentRegionsKHR + { + using NativeType = VkPresentRegionsKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentRegionsKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PresentRegionsKHR( uint32_t swapchainCount_ = {}, const PresentRegionKHR * pRegions_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchainCount{ swapchainCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentRegionsKHR( PresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentRegionsKHR( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentRegionsKHR( ArrayProxyNoTemporaries const & regions_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), swapchainCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PresentRegionsKHR & operator=( PresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentRegionsKHR & operator=( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR & setPRegions( const PresentRegionKHR * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR && setPRegions( const PresentRegionKHR * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentRegionsKHR & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentRegionsKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentRegionsKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentRegionsKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentRegionsKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentRegionsKHR const & ) const = default; +#else + bool operator==( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentRegionsKHR; + const void * pNext = {}; + uint32_t swapchainCount = {}; + const PresentRegionKHR * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentRegionsKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PresentRegionsKHR; + }; + + // wrapper struct for struct VkPresentTimeGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimeGOOGLE.html + struct PresentTimeGOOGLE + { + using NativeType = VkPresentTimeGOOGLE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentTimeGOOGLE( uint32_t presentID_ = {}, uint64_t desiredPresentTime_ = {} ) VULKAN_HPP_NOEXCEPT + : presentID{ presentID_ } + , desiredPresentTime{ desiredPresentTime_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentTimeGOOGLE( PresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT : PresentTimeGOOGLE( *reinterpret_cast( &rhs ) ) {} + + PresentTimeGOOGLE & operator=( PresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentTimeGOOGLE & operator=( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentTimeGOOGLE & setPresentID( uint32_t presentID_ ) & VULKAN_HPP_NOEXCEPT + { + presentID = presentID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimeGOOGLE && setPresentID( uint32_t presentID_ ) && VULKAN_HPP_NOEXCEPT + { + presentID = presentID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimeGOOGLE & setDesiredPresentTime( uint64_t desiredPresentTime_ ) & VULKAN_HPP_NOEXCEPT + { + desiredPresentTime = desiredPresentTime_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimeGOOGLE && setDesiredPresentTime( uint64_t desiredPresentTime_ ) && VULKAN_HPP_NOEXCEPT + { + desiredPresentTime = desiredPresentTime_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentTimeGOOGLE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimeGOOGLE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimeGOOGLE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentTimeGOOGLE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( presentID, desiredPresentTime ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentTimeGOOGLE const & ) const = default; +#else + bool operator==( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ); +# endif + } + + bool operator!=( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t presentID = {}; + uint64_t desiredPresentTime = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentTimeGOOGLE; + }; +#endif + + // wrapper struct for struct VkPresentTimesInfoGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimesInfoGOOGLE.html + struct PresentTimesInfoGOOGLE + { + using NativeType = VkPresentTimesInfoGOOGLE; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimesInfoGOOGLE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = {}, const PresentTimeGOOGLE * pTimes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchainCount{ swapchainCount_ } + , pTimes{ pTimes_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( PresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT + : PresentTimesInfoGOOGLE( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentTimesInfoGOOGLE( ArrayProxyNoTemporaries const & times_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), swapchainCount( static_cast( times_.size() ) ), pTimes( times_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PresentTimesInfoGOOGLE & operator=( PresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentTimesInfoGOOGLE & operator=( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE & setPTimes( const PresentTimeGOOGLE * pTimes_ ) & VULKAN_HPP_NOEXCEPT + { + pTimes = pTimes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE && setPTimes( const PresentTimeGOOGLE * pTimes_ ) && VULKAN_HPP_NOEXCEPT + { + pTimes = pTimes_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentTimesInfoGOOGLE & setTimes( ArrayProxyNoTemporaries const & times_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( times_.size() ); + pTimes = times_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentTimesInfoGOOGLE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimesInfoGOOGLE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimesInfoGOOGLE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentTimesInfoGOOGLE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pTimes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentTimesInfoGOOGLE const & ) const = default; +#else + bool operator==( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pTimes == rhs.pTimes ); +# endif + } + + bool operator!=( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentTimesInfoGOOGLE; + const void * pNext = {}; + uint32_t swapchainCount = {}; + const PresentTimeGOOGLE * pTimes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentTimesInfoGOOGLE; + }; +#endif + + template <> + struct CppType + { + using Type = PresentTimesInfoGOOGLE; + }; + + // wrapper struct for struct VkPresentTimingInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingInfoEXT.html + struct PresentTimingInfoEXT + { + using NativeType = VkPresentTimingInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimingInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentTimingInfoEXT( PresentTimingInfoFlagsEXT flags_ = {}, + uint64_t targetTime_ = {}, + uint64_t timeDomainId_ = {}, + PresentStageFlagsEXT presentStageQueries_ = {}, + PresentStageFlagsEXT targetTimeDomainPresentStage_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , targetTime{ targetTime_ } + , timeDomainId{ timeDomainId_ } + , presentStageQueries{ presentStageQueries_ } + , targetTimeDomainPresentStage{ targetTimeDomainPresentStage_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentTimingInfoEXT( PresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentTimingInfoEXT( VkPresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PresentTimingInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + PresentTimingInfoEXT & operator=( PresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentTimingInfoEXT & operator=( VkPresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setFlags( PresentTimingInfoFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setFlags( PresentTimingInfoFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setTargetTime( uint64_t targetTime_ ) & VULKAN_HPP_NOEXCEPT + { + targetTime = targetTime_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setTargetTime( uint64_t targetTime_ ) && VULKAN_HPP_NOEXCEPT + { + targetTime = targetTime_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setTimeDomainId( uint64_t timeDomainId_ ) & VULKAN_HPP_NOEXCEPT + { + timeDomainId = timeDomainId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setTimeDomainId( uint64_t timeDomainId_ ) && VULKAN_HPP_NOEXCEPT + { + timeDomainId = timeDomainId_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setPresentStageQueries( PresentStageFlagsEXT presentStageQueries_ ) & VULKAN_HPP_NOEXCEPT + { + presentStageQueries = presentStageQueries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setPresentStageQueries( PresentStageFlagsEXT presentStageQueries_ ) && VULKAN_HPP_NOEXCEPT + { + presentStageQueries = presentStageQueries_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setTargetTimeDomainPresentStage( PresentStageFlagsEXT targetTimeDomainPresentStage_ ) & VULKAN_HPP_NOEXCEPT + { + targetTimeDomainPresentStage = targetTimeDomainPresentStage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setTargetTimeDomainPresentStage( PresentStageFlagsEXT targetTimeDomainPresentStage_ ) && VULKAN_HPP_NOEXCEPT + { + targetTimeDomainPresentStage = targetTimeDomainPresentStage_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentTimingInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentTimingInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, targetTime, timeDomainId, presentStageQueries, targetTimeDomainPresentStage ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentTimingInfoEXT const & ) const = default; +#else + bool operator==( PresentTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( targetTime == rhs.targetTime ) && + ( timeDomainId == rhs.timeDomainId ) && ( presentStageQueries == rhs.presentStageQueries ) && + ( targetTimeDomainPresentStage == rhs.targetTimeDomainPresentStage ); +# endif + } + + bool operator!=( PresentTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentTimingInfoEXT; + const void * pNext = {}; + PresentTimingInfoFlagsEXT flags = {}; + uint64_t targetTime = {}; + uint64_t timeDomainId = {}; + PresentStageFlagsEXT presentStageQueries = {}; + PresentStageFlagsEXT targetTimeDomainPresentStage = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentTimingInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PresentTimingInfoEXT; + }; + + // wrapper struct for struct VkPresentTimingSurfaceCapabilitiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingSurfaceCapabilitiesEXT.html + struct PresentTimingSurfaceCapabilitiesEXT + { + using NativeType = VkPresentTimingSurfaceCapabilitiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimingSurfaceCapabilitiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentTimingSurfaceCapabilitiesEXT( Bool32 presentTimingSupported_ = {}, + Bool32 presentAtAbsoluteTimeSupported_ = {}, + Bool32 presentAtRelativeTimeSupported_ = {}, + PresentStageFlagsEXT presentStageQueries_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentTimingSupported{ presentTimingSupported_ } + , presentAtAbsoluteTimeSupported{ presentAtAbsoluteTimeSupported_ } + , presentAtRelativeTimeSupported{ presentAtRelativeTimeSupported_ } + , presentStageQueries{ presentStageQueries_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentTimingSurfaceCapabilitiesEXT( PresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentTimingSurfaceCapabilitiesEXT( VkPresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PresentTimingSurfaceCapabilitiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PresentTimingSurfaceCapabilitiesEXT & operator=( PresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentTimingSurfaceCapabilitiesEXT & operator=( VkPresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPresentTimingSurfaceCapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingSurfaceCapabilitiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingSurfaceCapabilitiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentTimingSurfaceCapabilitiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentTimingSupported, presentAtAbsoluteTimeSupported, presentAtRelativeTimeSupported, presentStageQueries ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentTimingSurfaceCapabilitiesEXT const & ) const = default; +#else + bool operator==( PresentTimingSurfaceCapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentTimingSupported == rhs.presentTimingSupported ) && + ( presentAtAbsoluteTimeSupported == rhs.presentAtAbsoluteTimeSupported ) && + ( presentAtRelativeTimeSupported == rhs.presentAtRelativeTimeSupported ) && ( presentStageQueries == rhs.presentStageQueries ); +# endif + } + + bool operator!=( PresentTimingSurfaceCapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentTimingSurfaceCapabilitiesEXT; + void * pNext = {}; + Bool32 presentTimingSupported = {}; + Bool32 presentAtAbsoluteTimeSupported = {}; + Bool32 presentAtRelativeTimeSupported = {}; + PresentStageFlagsEXT presentStageQueries = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentTimingSurfaceCapabilitiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PresentTimingSurfaceCapabilitiesEXT; + }; + + // wrapper struct for struct VkPresentTimingsInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingsInfoEXT.html + struct PresentTimingsInfoEXT + { + using NativeType = VkPresentTimingsInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimingsInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + PresentTimingsInfoEXT( uint32_t swapchainCount_ = {}, const PresentTimingInfoEXT * pTimingInfos_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchainCount{ swapchainCount_ } + , pTimingInfos{ pTimingInfos_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentTimingsInfoEXT( PresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentTimingsInfoEXT( VkPresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PresentTimingsInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentTimingsInfoEXT( ArrayProxyNoTemporaries const & timingInfos_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), swapchainCount( static_cast( timingInfos_.size() ) ), pTimingInfos( timingInfos_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PresentTimingsInfoEXT & operator=( PresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentTimingsInfoEXT & operator=( VkPresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT & setPTimingInfos( const PresentTimingInfoEXT * pTimingInfos_ ) & VULKAN_HPP_NOEXCEPT + { + pTimingInfos = pTimingInfos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT && setPTimingInfos( const PresentTimingInfoEXT * pTimingInfos_ ) && VULKAN_HPP_NOEXCEPT + { + pTimingInfos = pTimingInfos_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PresentTimingsInfoEXT & setTimingInfos( ArrayProxyNoTemporaries const & timingInfos_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( timingInfos_.size() ); + pTimingInfos = timingInfos_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentTimingsInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingsInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentTimingsInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentTimingsInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pTimingInfos ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentTimingsInfoEXT const & ) const = default; +#else + bool operator==( PresentTimingsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pTimingInfos == rhs.pTimingInfos ); +# endif + } + + bool operator!=( PresentTimingsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentTimingsInfoEXT; + const void * pNext = {}; + uint32_t swapchainCount = {}; + const PresentTimingInfoEXT * pTimingInfos = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentTimingsInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PresentTimingsInfoEXT; + }; + + // wrapper struct for struct VkPresentWait2InfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentWait2InfoKHR.html + struct PresentWait2InfoKHR + { + using NativeType = VkPresentWait2InfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentWait2InfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PresentWait2InfoKHR( uint64_t presentId_ = {}, uint64_t timeout_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentId{ presentId_ } + , timeout{ timeout_ } + { + } + + VULKAN_HPP_CONSTEXPR PresentWait2InfoKHR( PresentWait2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PresentWait2InfoKHR( VkPresentWait2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentWait2InfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + PresentWait2InfoKHR & operator=( PresentWait2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PresentWait2InfoKHR & operator=( VkPresentWait2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR & setPresentId( uint64_t presentId_ ) & VULKAN_HPP_NOEXCEPT + { + presentId = presentId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR && setPresentId( uint64_t presentId_ ) && VULKAN_HPP_NOEXCEPT + { + presentId = presentId_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR & setTimeout( uint64_t timeout_ ) & VULKAN_HPP_NOEXCEPT + { + timeout = timeout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR && setTimeout( uint64_t timeout_ ) && VULKAN_HPP_NOEXCEPT + { + timeout = timeout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPresentWait2InfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentWait2InfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPresentWait2InfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPresentWait2InfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentId, timeout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PresentWait2InfoKHR const & ) const = default; +#else + bool operator==( PresentWait2InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId ) && ( timeout == rhs.timeout ); +# endif + } + + bool operator!=( PresentWait2InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePresentWait2InfoKHR; + const void * pNext = {}; + uint64_t presentId = {}; + uint64_t timeout = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PresentWait2InfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = PresentWait2InfoKHR; + }; + + // wrapper struct for struct VkPrivateDataSlotCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlotCreateInfo.html + struct PrivateDataSlotCreateInfo + { + using NativeType = VkPrivateDataSlotCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePrivateDataSlotCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PrivateDataSlotCreateInfo( PrivateDataSlotCreateFlags flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR PrivateDataSlotCreateInfo( PrivateDataSlotCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PrivateDataSlotCreateInfo( VkPrivateDataSlotCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PrivateDataSlotCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PrivateDataSlotCreateInfo & operator=( PrivateDataSlotCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PrivateDataSlotCreateInfo & operator=( VkPrivateDataSlotCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PrivateDataSlotCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PrivateDataSlotCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PrivateDataSlotCreateInfo & setFlags( PrivateDataSlotCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PrivateDataSlotCreateInfo && setFlags( PrivateDataSlotCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPrivateDataSlotCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPrivateDataSlotCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPrivateDataSlotCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPrivateDataSlotCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PrivateDataSlotCreateInfo const & ) const = default; +#else + bool operator==( PrivateDataSlotCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( PrivateDataSlotCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePrivateDataSlotCreateInfo; + const void * pNext = {}; + PrivateDataSlotCreateFlags flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PrivateDataSlotCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PrivateDataSlotCreateInfo; + }; + + using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo; + + // wrapper struct for struct VkProtectedSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkProtectedSubmitInfo.html + struct ProtectedSubmitInfo + { + using NativeType = VkProtectedSubmitInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eProtectedSubmitInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( Bool32 protectedSubmit_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , protectedSubmit{ protectedSubmit_ } + { + } + + VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( ProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT : ProtectedSubmitInfo( *reinterpret_cast( &rhs ) ) + { + } + + ProtectedSubmitInfo & operator=( ProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ProtectedSubmitInfo & operator=( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ProtectedSubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ProtectedSubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ProtectedSubmitInfo & setProtectedSubmit( Bool32 protectedSubmit_ ) & VULKAN_HPP_NOEXCEPT + { + protectedSubmit = protectedSubmit_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ProtectedSubmitInfo && setProtectedSubmit( Bool32 protectedSubmit_ ) && VULKAN_HPP_NOEXCEPT + { + protectedSubmit = protectedSubmit_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkProtectedSubmitInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkProtectedSubmitInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkProtectedSubmitInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkProtectedSubmitInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, protectedSubmit ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ProtectedSubmitInfo const & ) const = default; +#else + bool operator==( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedSubmit == rhs.protectedSubmit ); +# endif + } + + bool operator!=( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eProtectedSubmitInfo; + const void * pNext = {}; + Bool32 protectedSubmit = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ProtectedSubmitInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ProtectedSubmitInfo; + }; + + // wrapper struct for struct VkPushConstantBankInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushConstantBankInfoNV.html + struct PushConstantBankInfoNV + { + using NativeType = VkPushConstantBankInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePushConstantBankInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PushConstantBankInfoNV( uint32_t bank_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , bank{ bank_ } + { + } + + VULKAN_HPP_CONSTEXPR PushConstantBankInfoNV( PushConstantBankInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PushConstantBankInfoNV( VkPushConstantBankInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PushConstantBankInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + PushConstantBankInfoNV & operator=( PushConstantBankInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PushConstantBankInfoNV & operator=( VkPushConstantBankInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PushConstantBankInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantBankInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantBankInfoNV & setBank( uint32_t bank_ ) & VULKAN_HPP_NOEXCEPT + { + bank = bank_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantBankInfoNV && setBank( uint32_t bank_ ) && VULKAN_HPP_NOEXCEPT + { + bank = bank_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPushConstantBankInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushConstantBankInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushConstantBankInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPushConstantBankInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, bank ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PushConstantBankInfoNV const & ) const = default; +#else + bool operator==( PushConstantBankInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bank == rhs.bank ); +# endif + } + + bool operator!=( PushConstantBankInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePushConstantBankInfoNV; + const void * pNext = {}; + uint32_t bank = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PushConstantBankInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = PushConstantBankInfoNV; + }; + + // wrapper struct for struct VkPushConstantsInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushConstantsInfo.html + struct PushConstantsInfo + { + using NativeType = VkPushConstantsInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePushConstantsInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PushConstantsInfo( PipelineLayout layout_ = {}, + ShaderStageFlags stageFlags_ = {}, + uint32_t offset_ = {}, + uint32_t size_ = {}, + const void * pValues_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , layout{ layout_ } + , stageFlags{ stageFlags_ } + , offset{ offset_ } + , size{ size_ } + , pValues{ pValues_ } + { + } + + VULKAN_HPP_CONSTEXPR PushConstantsInfo( PushConstantsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PushConstantsInfo( VkPushConstantsInfo const & rhs ) VULKAN_HPP_NOEXCEPT : PushConstantsInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + PushConstantsInfo( + PipelineLayout layout_, ShaderStageFlags stageFlags_, uint32_t offset_, ArrayProxyNoTemporaries const & values_, const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , layout( layout_ ) + , stageFlags( stageFlags_ ) + , offset( offset_ ) + , size( static_cast( values_.size() * sizeof( T ) ) ) + , pValues( values_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PushConstantsInfo & operator=( PushConstantsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PushConstantsInfo & operator=( VkPushConstantsInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setPValues( const void * pValues_ ) & VULKAN_HPP_NOEXCEPT + { + pValues = pValues_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setPValues( const void * pValues_ ) && VULKAN_HPP_NOEXCEPT + { + pValues = pValues_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + PushConstantsInfo & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT + { + size = static_cast( values_.size() * sizeof( T ) ); + pValues = values_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPushConstantsInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushConstantsInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushConstantsInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPushConstantsInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, layout, stageFlags, offset, size, pValues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PushConstantsInfo const & ) const = default; +#else + bool operator==( PushConstantsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( layout == rhs.layout ) && ( stageFlags == rhs.stageFlags ) && ( offset == rhs.offset ) && + ( size == rhs.size ) && ( pValues == rhs.pValues ); +# endif + } + + bool operator!=( PushConstantsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePushConstantsInfo; + const void * pNext = {}; + PipelineLayout layout = {}; + ShaderStageFlags stageFlags = {}; + uint32_t offset = {}; + uint32_t size = {}; + const void * pValues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PushConstantsInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PushConstantsInfo; + }; + + using PushConstantsInfoKHR = PushConstantsInfo; + + // wrapper struct for struct VkPushDataInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushDataInfoEXT.html + struct PushDataInfoEXT + { + using NativeType = VkPushDataInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePushDataInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PushDataInfoEXT( uint32_t offset_ = {}, HostAddressRangeConstEXT data_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , offset{ offset_ } + , data{ data_ } + { + } + + VULKAN_HPP_CONSTEXPR PushDataInfoEXT( PushDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PushDataInfoEXT( VkPushDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : PushDataInfoEXT( *reinterpret_cast( &rhs ) ) {} + + PushDataInfoEXT & operator=( PushDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PushDataInfoEXT & operator=( VkPushDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT & setData( HostAddressRangeConstEXT const & data_ ) & VULKAN_HPP_NOEXCEPT + { + data = data_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT && setData( HostAddressRangeConstEXT const & data_ ) && VULKAN_HPP_NOEXCEPT + { + data = data_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPushDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushDataInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPushDataInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, offset, data ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PushDataInfoEXT const & ) const = default; +#else + bool operator==( PushDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( offset == rhs.offset ) && ( data == rhs.data ); +# endif + } + + bool operator!=( PushDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePushDataInfoEXT; + const void * pNext = {}; + uint32_t offset = {}; + HostAddressRangeConstEXT data = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PushDataInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = PushDataInfoEXT; + }; + + // wrapper struct for struct VkWriteDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSet.html + struct WriteDescriptorSet + { + using NativeType = VkWriteDescriptorSet; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSet; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR WriteDescriptorSet( DescriptorSet dstSet_ = {}, + uint32_t dstBinding_ = {}, + uint32_t dstArrayElement_ = {}, + uint32_t descriptorCount_ = {}, + DescriptorType descriptorType_ = DescriptorType::eSampler, + const DescriptorImageInfo * pImageInfo_ = {}, + const DescriptorBufferInfo * pBufferInfo_ = {}, + const BufferView * pTexelBufferView_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dstSet{ dstSet_ } + , dstBinding{ dstBinding_ } + , dstArrayElement{ dstArrayElement_ } + , descriptorCount{ descriptorCount_ } + , descriptorType{ descriptorType_ } + , pImageInfo{ pImageInfo_ } + , pBufferInfo{ pBufferInfo_ } + , pTexelBufferView{ pTexelBufferView_ } + { + } + + VULKAN_HPP_CONSTEXPR WriteDescriptorSet( WriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT : WriteDescriptorSet( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSet( DescriptorSet dstSet_, + uint32_t dstBinding_, + uint32_t dstArrayElement_, + DescriptorType descriptorType_, + ArrayProxyNoTemporaries const & imageInfo_, + ArrayProxyNoTemporaries const & bufferInfo_ = {}, + ArrayProxyNoTemporaries const & texelBufferView_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , dstSet( dstSet_ ) + , dstBinding( dstBinding_ ) + , dstArrayElement( dstArrayElement_ ) + , descriptorCount( static_cast( !imageInfo_.empty() ? imageInfo_.size() + : !bufferInfo_.empty() ? bufferInfo_.size() + : texelBufferView_.size() ) ) + , descriptorType( descriptorType_ ) + , pImageInfo( imageInfo_.data() ) + , pBufferInfo( bufferInfo_.data() ) + , pTexelBufferView( texelBufferView_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( ( !imageInfo_.empty() + !bufferInfo_.empty() + !texelBufferView_.empty() ) <= 1 ); +# else + if ( 1 < ( !imageInfo_.empty() + !bufferInfo_.empty() + !texelBufferView_.empty() ) ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::WriteDescriptorSet::WriteDescriptorSet: 1 < ( !imageInfo_.empty() + !bufferInfo_.empty() + !texelBufferView_.empty() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + WriteDescriptorSet & operator=( WriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + WriteDescriptorSet & operator=( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setDstSet( DescriptorSet dstSet_ ) & VULKAN_HPP_NOEXCEPT + { + dstSet = dstSet_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setDstSet( DescriptorSet dstSet_ ) && VULKAN_HPP_NOEXCEPT + { + dstSet = dstSet_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setDstBinding( uint32_t dstBinding_ ) & VULKAN_HPP_NOEXCEPT + { + dstBinding = dstBinding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setDstBinding( uint32_t dstBinding_ ) && VULKAN_HPP_NOEXCEPT + { + dstBinding = dstBinding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setDstArrayElement( uint32_t dstArrayElement_ ) & VULKAN_HPP_NOEXCEPT + { + dstArrayElement = dstArrayElement_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setDstArrayElement( uint32_t dstArrayElement_ ) && VULKAN_HPP_NOEXCEPT + { + dstArrayElement = dstArrayElement_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorCount = descriptorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorCount = descriptorCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setDescriptorType( DescriptorType descriptorType_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorType = descriptorType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setDescriptorType( DescriptorType descriptorType_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorType = descriptorType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setPImageInfo( const DescriptorImageInfo * pImageInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pImageInfo = pImageInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setPImageInfo( const DescriptorImageInfo * pImageInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pImageInfo = pImageInfo_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSet & setImageInfo( ArrayProxyNoTemporaries const & imageInfo_ ) VULKAN_HPP_NOEXCEPT + { + descriptorCount = static_cast( imageInfo_.size() ); + pImageInfo = imageInfo_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setPBufferInfo( const DescriptorBufferInfo * pBufferInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pBufferInfo = pBufferInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setPBufferInfo( const DescriptorBufferInfo * pBufferInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pBufferInfo = pBufferInfo_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSet & setBufferInfo( ArrayProxyNoTemporaries const & bufferInfo_ ) VULKAN_HPP_NOEXCEPT + { + descriptorCount = static_cast( bufferInfo_.size() ); + pBufferInfo = bufferInfo_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setPTexelBufferView( const BufferView * pTexelBufferView_ ) & VULKAN_HPP_NOEXCEPT + { + pTexelBufferView = pTexelBufferView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setPTexelBufferView( const BufferView * pTexelBufferView_ ) && VULKAN_HPP_NOEXCEPT + { + pTexelBufferView = pTexelBufferView_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSet & setTexelBufferView( ArrayProxyNoTemporaries const & texelBufferView_ ) VULKAN_HPP_NOEXCEPT + { + descriptorCount = static_cast( texelBufferView_.size() ); + pTexelBufferView = texelBufferView_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWriteDescriptorSet const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSet &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSet const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWriteDescriptorSet *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dstSet, dstBinding, dstArrayElement, descriptorCount, descriptorType, pImageInfo, pBufferInfo, pTexelBufferView ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( WriteDescriptorSet const & ) const = default; +#else + bool operator==( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dstSet == rhs.dstSet ) && ( dstBinding == rhs.dstBinding ) && + ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) && + ( pImageInfo == rhs.pImageInfo ) && ( pBufferInfo == rhs.pBufferInfo ) && ( pTexelBufferView == rhs.pTexelBufferView ); +# endif + } + + bool operator!=( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eWriteDescriptorSet; + const void * pNext = {}; + DescriptorSet dstSet = {}; + uint32_t dstBinding = {}; + uint32_t dstArrayElement = {}; + uint32_t descriptorCount = {}; + DescriptorType descriptorType = DescriptorType::eSampler; + const DescriptorImageInfo * pImageInfo = {}; + const DescriptorBufferInfo * pBufferInfo = {}; + const BufferView * pTexelBufferView = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = WriteDescriptorSet; + }; +#endif + + template <> + struct CppType + { + using Type = WriteDescriptorSet; + }; + + // wrapper struct for struct VkPushDescriptorSetInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushDescriptorSetInfo.html + struct PushDescriptorSetInfo + { + using NativeType = VkPushDescriptorSetInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePushDescriptorSetInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PushDescriptorSetInfo( ShaderStageFlags stageFlags_ = {}, + PipelineLayout layout_ = {}, + uint32_t set_ = {}, + uint32_t descriptorWriteCount_ = {}, + const WriteDescriptorSet * pDescriptorWrites_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stageFlags{ stageFlags_ } + , layout{ layout_ } + , set{ set_ } + , descriptorWriteCount{ descriptorWriteCount_ } + , pDescriptorWrites{ pDescriptorWrites_ } + { + } + + VULKAN_HPP_CONSTEXPR PushDescriptorSetInfo( PushDescriptorSetInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PushDescriptorSetInfo( VkPushDescriptorSetInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PushDescriptorSetInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PushDescriptorSetInfo( ShaderStageFlags stageFlags_, + PipelineLayout layout_, + uint32_t set_, + ArrayProxyNoTemporaries const & descriptorWrites_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , stageFlags( stageFlags_ ) + , layout( layout_ ) + , set( set_ ) + , descriptorWriteCount( static_cast( descriptorWrites_.size() ) ) + , pDescriptorWrites( descriptorWrites_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + PushDescriptorSetInfo & operator=( PushDescriptorSetInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PushDescriptorSetInfo & operator=( VkPushDescriptorSetInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT + { + set = set_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT + { + set = set_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setDescriptorWriteCount( uint32_t descriptorWriteCount_ ) & VULKAN_HPP_NOEXCEPT + { + descriptorWriteCount = descriptorWriteCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setDescriptorWriteCount( uint32_t descriptorWriteCount_ ) && VULKAN_HPP_NOEXCEPT + { + descriptorWriteCount = descriptorWriteCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setPDescriptorWrites( const WriteDescriptorSet * pDescriptorWrites_ ) & VULKAN_HPP_NOEXCEPT + { + pDescriptorWrites = pDescriptorWrites_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setPDescriptorWrites( const WriteDescriptorSet * pDescriptorWrites_ ) && VULKAN_HPP_NOEXCEPT + { + pDescriptorWrites = pDescriptorWrites_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + PushDescriptorSetInfo & setDescriptorWrites( ArrayProxyNoTemporaries const & descriptorWrites_ ) VULKAN_HPP_NOEXCEPT + { + descriptorWriteCount = static_cast( descriptorWrites_.size() ); + pDescriptorWrites = descriptorWrites_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPushDescriptorSetInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushDescriptorSetInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushDescriptorSetInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPushDescriptorSetInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stageFlags, layout, set, descriptorWriteCount, pDescriptorWrites ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PushDescriptorSetInfo const & ) const = default; +#else + bool operator==( PushDescriptorSetInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( set == rhs.set ) && + ( descriptorWriteCount == rhs.descriptorWriteCount ) && ( pDescriptorWrites == rhs.pDescriptorWrites ); +# endif + } + + bool operator!=( PushDescriptorSetInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePushDescriptorSetInfo; + const void * pNext = {}; + ShaderStageFlags stageFlags = {}; + PipelineLayout layout = {}; + uint32_t set = {}; + uint32_t descriptorWriteCount = {}; + const WriteDescriptorSet * pDescriptorWrites = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PushDescriptorSetInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PushDescriptorSetInfo; + }; + + using PushDescriptorSetInfoKHR = PushDescriptorSetInfo; + + // wrapper struct for struct VkPushDescriptorSetWithTemplateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushDescriptorSetWithTemplateInfo.html + struct PushDescriptorSetWithTemplateInfo + { + using NativeType = VkPushDescriptorSetWithTemplateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePushDescriptorSetWithTemplateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PushDescriptorSetWithTemplateInfo( DescriptorUpdateTemplate descriptorUpdateTemplate_ = {}, + PipelineLayout layout_ = {}, + uint32_t set_ = {}, + const void * pData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , descriptorUpdateTemplate{ descriptorUpdateTemplate_ } + , layout{ layout_ } + , set{ set_ } + , pData{ pData_ } + { + } + + VULKAN_HPP_CONSTEXPR PushDescriptorSetWithTemplateInfo( PushDescriptorSetWithTemplateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PushDescriptorSetWithTemplateInfo( VkPushDescriptorSetWithTemplateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : PushDescriptorSetWithTemplateInfo( *reinterpret_cast( &rhs ) ) + { + } + + PushDescriptorSetWithTemplateInfo & operator=( PushDescriptorSetWithTemplateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PushDescriptorSetWithTemplateInfo & operator=( VkPushDescriptorSetWithTemplateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo & setDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate_ ) & + VULKAN_HPP_NOEXCEPT + { + descriptorUpdateTemplate = descriptorUpdateTemplate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo && setDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate_ ) && + VULKAN_HPP_NOEXCEPT + { + descriptorUpdateTemplate = descriptorUpdateTemplate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT + { + set = set_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT + { + set = set_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo & setPData( const void * pData_ ) & VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo && setPData( const void * pData_ ) && VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPushDescriptorSetWithTemplateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushDescriptorSetWithTemplateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPushDescriptorSetWithTemplateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPushDescriptorSetWithTemplateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, descriptorUpdateTemplate, layout, set, pData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PushDescriptorSetWithTemplateInfo const & ) const = default; +#else + bool operator==( PushDescriptorSetWithTemplateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorUpdateTemplate == rhs.descriptorUpdateTemplate ) && ( layout == rhs.layout ) && + ( set == rhs.set ) && ( pData == rhs.pData ); +# endif + } + + bool operator!=( PushDescriptorSetWithTemplateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::ePushDescriptorSetWithTemplateInfo; + const void * pNext = {}; + DescriptorUpdateTemplate descriptorUpdateTemplate = {}; + PipelineLayout layout = {}; + uint32_t set = {}; + const void * pData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = PushDescriptorSetWithTemplateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = PushDescriptorSetWithTemplateInfo; + }; + + using PushDescriptorSetWithTemplateInfoKHR = PushDescriptorSetWithTemplateInfo; + + // wrapper struct for struct VkQueryLowLatencySupportNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryLowLatencySupportNV.html + struct QueryLowLatencySupportNV + { + using NativeType = VkQueryLowLatencySupportNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryLowLatencySupportNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueryLowLatencySupportNV( void * pQueriedLowLatencyData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pQueriedLowLatencyData{ pQueriedLowLatencyData_ } + { + } + + VULKAN_HPP_CONSTEXPR QueryLowLatencySupportNV( QueryLowLatencySupportNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueryLowLatencySupportNV( VkQueryLowLatencySupportNV const & rhs ) VULKAN_HPP_NOEXCEPT + : QueryLowLatencySupportNV( *reinterpret_cast( &rhs ) ) + { + } + + QueryLowLatencySupportNV & operator=( QueryLowLatencySupportNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueryLowLatencySupportNV & operator=( VkQueryLowLatencySupportNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 QueryLowLatencySupportNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryLowLatencySupportNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 QueryLowLatencySupportNV & setPQueriedLowLatencyData( void * pQueriedLowLatencyData_ ) & VULKAN_HPP_NOEXCEPT + { + pQueriedLowLatencyData = pQueriedLowLatencyData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryLowLatencySupportNV && setPQueriedLowLatencyData( void * pQueriedLowLatencyData_ ) && VULKAN_HPP_NOEXCEPT + { + pQueriedLowLatencyData = pQueriedLowLatencyData_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkQueryLowLatencySupportNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueryLowLatencySupportNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueryLowLatencySupportNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueryLowLatencySupportNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pQueriedLowLatencyData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueryLowLatencySupportNV const & ) const = default; +#else + bool operator==( QueryLowLatencySupportNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pQueriedLowLatencyData == rhs.pQueriedLowLatencyData ); +# endif + } + + bool operator!=( QueryLowLatencySupportNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueryLowLatencySupportNV; + const void * pNext = {}; + void * pQueriedLowLatencyData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueryLowLatencySupportNV; + }; +#endif + + template <> + struct CppType + { + using Type = QueryLowLatencySupportNV; + }; + + // wrapper struct for struct VkQueryPoolCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolCreateInfo.html + struct QueryPoolCreateInfo + { + using NativeType = VkQueryPoolCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = {}, + QueryType queryType_ = QueryType::eOcclusion, + uint32_t queryCount_ = {}, + QueryPipelineStatisticFlags pipelineStatistics_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , queryType{ queryType_ } + , queryCount{ queryCount_ } + , pipelineStatistics{ pipelineStatistics_ } + { + } + + VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( QueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : QueryPoolCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + QueryPoolCreateInfo & operator=( QueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueryPoolCreateInfo & operator=( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo & setFlags( QueryPoolCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo && setFlags( QueryPoolCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo & setQueryType( QueryType queryType_ ) & VULKAN_HPP_NOEXCEPT + { + queryType = queryType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo && setQueryType( QueryType queryType_ ) && VULKAN_HPP_NOEXCEPT + { + queryType = queryType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo & setQueryCount( uint32_t queryCount_ ) & VULKAN_HPP_NOEXCEPT + { + queryCount = queryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo && setQueryCount( uint32_t queryCount_ ) && VULKAN_HPP_NOEXCEPT + { + queryCount = queryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo & setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineStatistics = pipelineStatistics_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo && setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineStatistics = pipelineStatistics_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkQueryPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueryPoolCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueryPoolCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueryPoolCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, queryType, queryCount, pipelineStatistics ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueryPoolCreateInfo const & ) const = default; +#else + bool operator==( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queryType == rhs.queryType ) && ( queryCount == rhs.queryCount ) && + ( pipelineStatistics == rhs.pipelineStatistics ); +# endif + } + + bool operator!=( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueryPoolCreateInfo; + const void * pNext = {}; + QueryPoolCreateFlags flags = {}; + QueryType queryType = QueryType::eOcclusion; + uint32_t queryCount = {}; + QueryPipelineStatisticFlags pipelineStatistics = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueryPoolCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = QueryPoolCreateInfo; + }; + + // wrapper struct for struct VkQueryPoolPerformanceCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolPerformanceCreateInfoKHR.html + struct QueryPoolPerformanceCreateInfoKHR + { + using NativeType = VkQueryPoolPerformanceCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolPerformanceCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueryPoolPerformanceCreateInfoKHR( uint32_t queueFamilyIndex_ = {}, + uint32_t counterIndexCount_ = {}, + const uint32_t * pCounterIndices_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , queueFamilyIndex{ queueFamilyIndex_ } + , counterIndexCount{ counterIndexCount_ } + , pCounterIndices{ pCounterIndices_ } + { + } + + VULKAN_HPP_CONSTEXPR QueryPoolPerformanceCreateInfoKHR( QueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueryPoolPerformanceCreateInfoKHR( VkQueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : QueryPoolPerformanceCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + QueryPoolPerformanceCreateInfoKHR( uint32_t queueFamilyIndex_, + ArrayProxyNoTemporaries const & counterIndices_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , queueFamilyIndex( queueFamilyIndex_ ) + , counterIndexCount( static_cast( counterIndices_.size() ) ) + , pCounterIndices( counterIndices_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + QueryPoolPerformanceCreateInfoKHR & operator=( QueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueryPoolPerformanceCreateInfoKHR & operator=( VkQueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR & setCounterIndexCount( uint32_t counterIndexCount_ ) & VULKAN_HPP_NOEXCEPT + { + counterIndexCount = counterIndexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR && setCounterIndexCount( uint32_t counterIndexCount_ ) && VULKAN_HPP_NOEXCEPT + { + counterIndexCount = counterIndexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR & setPCounterIndices( const uint32_t * pCounterIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pCounterIndices = pCounterIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR && setPCounterIndices( const uint32_t * pCounterIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pCounterIndices = pCounterIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + QueryPoolPerformanceCreateInfoKHR & setCounterIndices( ArrayProxyNoTemporaries const & counterIndices_ ) VULKAN_HPP_NOEXCEPT + { + counterIndexCount = static_cast( counterIndices_.size() ); + pCounterIndices = counterIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkQueryPoolPerformanceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueryPoolPerformanceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueryPoolPerformanceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueryPoolPerformanceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queueFamilyIndex, counterIndexCount, pCounterIndices ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueryPoolPerformanceCreateInfoKHR const & ) const = default; +#else + bool operator==( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && + ( counterIndexCount == rhs.counterIndexCount ) && ( pCounterIndices == rhs.pCounterIndices ); +# endif + } + + bool operator!=( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueryPoolPerformanceCreateInfoKHR; + const void * pNext = {}; + uint32_t queueFamilyIndex = {}; + uint32_t counterIndexCount = {}; + const uint32_t * pCounterIndices = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueryPoolPerformanceCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = QueryPoolPerformanceCreateInfoKHR; + }; + + // wrapper struct for struct VkQueryPoolPerformanceQueryCreateInfoINTEL, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolPerformanceQueryCreateInfoINTEL.html + struct QueryPoolPerformanceQueryCreateInfoINTEL + { + using NativeType = VkQueryPoolPerformanceQueryCreateInfoINTEL; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + QueryPoolPerformanceQueryCreateInfoINTEL( QueryPoolSamplingModeINTEL performanceCountersSampling_ = QueryPoolSamplingModeINTEL::eManual, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , performanceCountersSampling{ performanceCountersSampling_ } + { + } + + VULKAN_HPP_CONSTEXPR QueryPoolPerformanceQueryCreateInfoINTEL( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueryPoolPerformanceQueryCreateInfoINTEL( VkQueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + : QueryPoolPerformanceQueryCreateInfoINTEL( *reinterpret_cast( &rhs ) ) + { + } + + QueryPoolPerformanceQueryCreateInfoINTEL & operator=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueryPoolPerformanceQueryCreateInfoINTEL & operator=( VkQueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceQueryCreateInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceQueryCreateInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceQueryCreateInfoINTEL & + setPerformanceCountersSampling( QueryPoolSamplingModeINTEL performanceCountersSampling_ ) & + VULKAN_HPP_NOEXCEPT + { + performanceCountersSampling = performanceCountersSampling_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceQueryCreateInfoINTEL && + setPerformanceCountersSampling( QueryPoolSamplingModeINTEL performanceCountersSampling_ ) && + VULKAN_HPP_NOEXCEPT + { + performanceCountersSampling = performanceCountersSampling_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkQueryPoolPerformanceQueryCreateInfoINTEL const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueryPoolPerformanceQueryCreateInfoINTEL &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueryPoolPerformanceQueryCreateInfoINTEL const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueryPoolPerformanceQueryCreateInfoINTEL *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, performanceCountersSampling ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueryPoolPerformanceQueryCreateInfoINTEL const & ) const = default; +#else + bool operator==( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( performanceCountersSampling == rhs.performanceCountersSampling ); +# endif + } + + bool operator!=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL; + const void * pNext = {}; + QueryPoolSamplingModeINTEL performanceCountersSampling = QueryPoolSamplingModeINTEL::eManual; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueryPoolPerformanceQueryCreateInfoINTEL; + }; +#endif + + template <> + struct CppType + { + using Type = QueryPoolPerformanceQueryCreateInfoINTEL; + }; + + using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL; + + // wrapper struct for struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolVideoEncodeFeedbackCreateInfoKHR.html + struct QueryPoolVideoEncodeFeedbackCreateInfoKHR + { + using NativeType = VkQueryPoolVideoEncodeFeedbackCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolVideoEncodeFeedbackCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueryPoolVideoEncodeFeedbackCreateInfoKHR( VideoEncodeFeedbackFlagsKHR encodeFeedbackFlags_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , encodeFeedbackFlags{ encodeFeedbackFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR QueryPoolVideoEncodeFeedbackCreateInfoKHR( QueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueryPoolVideoEncodeFeedbackCreateInfoKHR( VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : QueryPoolVideoEncodeFeedbackCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + QueryPoolVideoEncodeFeedbackCreateInfoKHR & operator=( QueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueryPoolVideoEncodeFeedbackCreateInfoKHR & operator=( VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 QueryPoolVideoEncodeFeedbackCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolVideoEncodeFeedbackCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolVideoEncodeFeedbackCreateInfoKHR & setEncodeFeedbackFlags( VideoEncodeFeedbackFlagsKHR encodeFeedbackFlags_ ) & + VULKAN_HPP_NOEXCEPT + { + encodeFeedbackFlags = encodeFeedbackFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 QueryPoolVideoEncodeFeedbackCreateInfoKHR && setEncodeFeedbackFlags( VideoEncodeFeedbackFlagsKHR encodeFeedbackFlags_ ) && + VULKAN_HPP_NOEXCEPT + { + encodeFeedbackFlags = encodeFeedbackFlags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueryPoolVideoEncodeFeedbackCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, encodeFeedbackFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueryPoolVideoEncodeFeedbackCreateInfoKHR const & ) const = default; +#else + bool operator==( QueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( encodeFeedbackFlags == rhs.encodeFeedbackFlags ); +# endif + } + + bool operator!=( QueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueryPoolVideoEncodeFeedbackCreateInfoKHR; + const void * pNext = {}; + VideoEncodeFeedbackFlagsKHR encodeFeedbackFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueryPoolVideoEncodeFeedbackCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = QueryPoolVideoEncodeFeedbackCreateInfoKHR; + }; + + // wrapper struct for struct VkQueueFamilyCheckpointProperties2NV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyCheckpointProperties2NV.html + struct QueueFamilyCheckpointProperties2NV + { + using NativeType = VkQueueFamilyCheckpointProperties2NV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyCheckpointProperties2NV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointProperties2NV( PipelineStageFlags2 checkpointExecutionStageMask_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , checkpointExecutionStageMask{ checkpointExecutionStageMask_ } + { + } + + VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointProperties2NV( QueueFamilyCheckpointProperties2NV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyCheckpointProperties2NV( VkQueueFamilyCheckpointProperties2NV const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyCheckpointProperties2NV( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyCheckpointProperties2NV & operator=( QueueFamilyCheckpointProperties2NV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyCheckpointProperties2NV & operator=( VkQueueFamilyCheckpointProperties2NV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyCheckpointProperties2NV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyCheckpointProperties2NV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyCheckpointProperties2NV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyCheckpointProperties2NV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, checkpointExecutionStageMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyCheckpointProperties2NV const & ) const = default; +#else + bool operator==( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask ); +# endif + } + + bool operator!=( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueueFamilyCheckpointProperties2NV; + void * pNext = {}; + PipelineStageFlags2 checkpointExecutionStageMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyCheckpointProperties2NV; + }; +#endif + + template <> + struct CppType + { + using Type = QueueFamilyCheckpointProperties2NV; + }; + + // wrapper struct for struct VkQueueFamilyCheckpointPropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyCheckpointPropertiesNV.html + struct QueueFamilyCheckpointPropertiesNV + { + using NativeType = VkQueueFamilyCheckpointPropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyCheckpointPropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointPropertiesNV( PipelineStageFlags checkpointExecutionStageMask_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , checkpointExecutionStageMask{ checkpointExecutionStageMask_ } + { + } + + VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointPropertiesNV( QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyCheckpointPropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyCheckpointPropertiesNV & operator=( QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyCheckpointPropertiesNV & operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyCheckpointPropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyCheckpointPropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyCheckpointPropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyCheckpointPropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, checkpointExecutionStageMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyCheckpointPropertiesNV const & ) const = default; +#else + bool operator==( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask ); +# endif + } + + bool operator!=( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV; + void * pNext = {}; + PipelineStageFlags checkpointExecutionStageMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyCheckpointPropertiesNV; + }; +#endif + + template <> + struct CppType + { + using Type = QueueFamilyCheckpointPropertiesNV; + }; + + // wrapper struct for struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyDataGraphProcessingEnginePropertiesARM.html + struct QueueFamilyDataGraphProcessingEnginePropertiesARM + { + using NativeType = VkQueueFamilyDataGraphProcessingEnginePropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyDataGraphProcessingEnginePropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueueFamilyDataGraphProcessingEnginePropertiesARM( ExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes_ = {}, + ExternalMemoryHandleTypeFlags foreignMemoryHandleTypes_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , foreignSemaphoreHandleTypes{ foreignSemaphoreHandleTypes_ } + , foreignMemoryHandleTypes{ foreignMemoryHandleTypes_ } + { + } + + VULKAN_HPP_CONSTEXPR + QueueFamilyDataGraphProcessingEnginePropertiesARM( QueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyDataGraphProcessingEnginePropertiesARM( VkQueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyDataGraphProcessingEnginePropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyDataGraphProcessingEnginePropertiesARM & + operator=( QueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyDataGraphProcessingEnginePropertiesARM & operator=( VkQueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyDataGraphProcessingEnginePropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyDataGraphProcessingEnginePropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyDataGraphProcessingEnginePropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyDataGraphProcessingEnginePropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, foreignSemaphoreHandleTypes, foreignMemoryHandleTypes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyDataGraphProcessingEnginePropertiesARM const & ) const = default; +#else + bool operator==( QueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( foreignSemaphoreHandleTypes == rhs.foreignSemaphoreHandleTypes ) && + ( foreignMemoryHandleTypes == rhs.foreignMemoryHandleTypes ); +# endif + } + + bool operator!=( QueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueueFamilyDataGraphProcessingEnginePropertiesARM; + void * pNext = {}; + ExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes = {}; + ExternalMemoryHandleTypeFlags foreignMemoryHandleTypes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyDataGraphProcessingEnginePropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = QueueFamilyDataGraphProcessingEnginePropertiesARM; + }; + + // wrapper struct for struct VkQueueFamilyDataGraphPropertiesARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyDataGraphPropertiesARM.html + struct QueueFamilyDataGraphPropertiesARM + { + using NativeType = VkQueueFamilyDataGraphPropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyDataGraphPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 QueueFamilyDataGraphPropertiesARM( PhysicalDeviceDataGraphProcessingEngineARM engine_ = {}, + PhysicalDeviceDataGraphOperationSupportARM operation_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , engine{ engine_ } + , operation{ operation_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 QueueFamilyDataGraphPropertiesARM( QueueFamilyDataGraphPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyDataGraphPropertiesARM( VkQueueFamilyDataGraphPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyDataGraphPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyDataGraphPropertiesARM & operator=( QueueFamilyDataGraphPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyDataGraphPropertiesARM & operator=( VkQueueFamilyDataGraphPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyDataGraphPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyDataGraphPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyDataGraphPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyDataGraphPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, engine, operation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyDataGraphPropertiesARM const & ) const = default; +#else + bool operator==( QueueFamilyDataGraphPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( engine == rhs.engine ) && ( operation == rhs.operation ); +# endif + } + + bool operator!=( QueueFamilyDataGraphPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueueFamilyDataGraphPropertiesARM; + void * pNext = {}; + PhysicalDeviceDataGraphProcessingEngineARM engine = {}; + PhysicalDeviceDataGraphOperationSupportARM operation = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyDataGraphPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = QueueFamilyDataGraphPropertiesARM; + }; + + // wrapper struct for struct VkQueueFamilyGlobalPriorityProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyGlobalPriorityProperties.html + struct QueueFamilyGlobalPriorityProperties + { + using NativeType = VkQueueFamilyGlobalPriorityProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyGlobalPriorityProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 + QueueFamilyGlobalPriorityProperties( uint32_t priorityCount_ = {}, + std::array const & priorities_ = { { QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow, + QueueGlobalPriority::eLow } }, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , priorityCount{ priorityCount_ } + , priorities{ priorities_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 QueueFamilyGlobalPriorityProperties( QueueFamilyGlobalPriorityProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyGlobalPriorityProperties( VkQueueFamilyGlobalPriorityProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyGlobalPriorityProperties( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyGlobalPriorityProperties & operator=( QueueFamilyGlobalPriorityProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyGlobalPriorityProperties & operator=( VkQueueFamilyGlobalPriorityProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyGlobalPriorityProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyGlobalPriorityProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyGlobalPriorityProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyGlobalPriorityProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, priorityCount, priorities ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( QueueFamilyGlobalPriorityProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = priorityCount <=> rhs.priorityCount; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < priorityCount; ++i ) + { + if ( auto cmp = priorities[i] <=> rhs.priorities[i]; cmp != 0 ) + return cmp; + } + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( QueueFamilyGlobalPriorityProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priorityCount == rhs.priorityCount ) && + ( memcmp( priorities, rhs.priorities, priorityCount * sizeof( QueueGlobalPriority ) ) == 0 ); + } + + bool operator!=( QueueFamilyGlobalPriorityProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eQueueFamilyGlobalPriorityProperties; + void * pNext = {}; + uint32_t priorityCount = {}; + ArrayWrapper1D priorities = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyGlobalPriorityProperties; + }; +#endif + + template <> + struct CppType + { + using Type = QueueFamilyGlobalPriorityProperties; + }; + + using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityProperties; + using QueueFamilyGlobalPriorityPropertiesKHR = QueueFamilyGlobalPriorityProperties; + + // wrapper struct for struct VkQueueFamilyOwnershipTransferPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyOwnershipTransferPropertiesKHR.html + struct QueueFamilyOwnershipTransferPropertiesKHR + { + using NativeType = VkQueueFamilyOwnershipTransferPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyOwnershipTransferPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueueFamilyOwnershipTransferPropertiesKHR( uint32_t optimalImageTransferToQueueFamilies_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , optimalImageTransferToQueueFamilies{ optimalImageTransferToQueueFamilies_ } + { + } + + VULKAN_HPP_CONSTEXPR QueueFamilyOwnershipTransferPropertiesKHR( QueueFamilyOwnershipTransferPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyOwnershipTransferPropertiesKHR( VkQueueFamilyOwnershipTransferPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyOwnershipTransferPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyOwnershipTransferPropertiesKHR & operator=( QueueFamilyOwnershipTransferPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyOwnershipTransferPropertiesKHR & operator=( VkQueueFamilyOwnershipTransferPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyOwnershipTransferPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyOwnershipTransferPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyOwnershipTransferPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyOwnershipTransferPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, optimalImageTransferToQueueFamilies ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyOwnershipTransferPropertiesKHR const & ) const = default; +#else + bool operator==( QueueFamilyOwnershipTransferPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( optimalImageTransferToQueueFamilies == rhs.optimalImageTransferToQueueFamilies ); +# endif + } + + bool operator!=( QueueFamilyOwnershipTransferPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueueFamilyOwnershipTransferPropertiesKHR; + void * pNext = {}; + uint32_t optimalImageTransferToQueueFamilies = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyOwnershipTransferPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = QueueFamilyOwnershipTransferPropertiesKHR; + }; + + // wrapper struct for struct VkQueueFamilyProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyProperties.html + struct QueueFamilyProperties + { + using NativeType = VkQueueFamilyProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueueFamilyProperties( QueueFlags queueFlags_ = {}, + uint32_t queueCount_ = {}, + uint32_t timestampValidBits_ = {}, + Extent3D minImageTransferGranularity_ = {} ) VULKAN_HPP_NOEXCEPT + : queueFlags{ queueFlags_ } + , queueCount{ queueCount_ } + , timestampValidBits{ timestampValidBits_ } + , minImageTransferGranularity{ minImageTransferGranularity_ } + { + } + + VULKAN_HPP_CONSTEXPR QueueFamilyProperties( QueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyProperties( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyProperties( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyProperties & operator=( QueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyProperties & operator=( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( queueFlags, queueCount, timestampValidBits, minImageTransferGranularity ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyProperties const & ) const = default; +#else + bool operator==( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( queueFlags == rhs.queueFlags ) && ( queueCount == rhs.queueCount ) && ( timestampValidBits == rhs.timestampValidBits ) && + ( minImageTransferGranularity == rhs.minImageTransferGranularity ); +# endif + } + + bool operator!=( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + QueueFlags queueFlags = {}; + uint32_t queueCount = {}; + uint32_t timestampValidBits = {}; + Extent3D minImageTransferGranularity = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyProperties; + }; +#endif + + // wrapper struct for struct VkQueueFamilyProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyProperties2.html + struct QueueFamilyProperties2 + { + using NativeType = VkQueueFamilyProperties2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyProperties2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueueFamilyProperties2( QueueFamilyProperties queueFamilyProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , queueFamilyProperties{ queueFamilyProperties_ } + { + } + + VULKAN_HPP_CONSTEXPR QueueFamilyProperties2( QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyProperties2( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyProperties2 & operator=( QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyProperties2 & operator=( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyProperties2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyProperties2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyProperties2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyProperties2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queueFamilyProperties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyProperties2 const & ) const = default; +#else + bool operator==( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyProperties == rhs.queueFamilyProperties ); +# endif + } + + bool operator!=( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueueFamilyProperties2; + void * pNext = {}; + QueueFamilyProperties queueFamilyProperties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyProperties2; + }; +#endif + + template <> + struct CppType + { + using Type = QueueFamilyProperties2; + }; + + using QueueFamilyProperties2KHR = QueueFamilyProperties2; + + // wrapper struct for struct VkQueueFamilyQueryResultStatusPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyQueryResultStatusPropertiesKHR.html + struct QueueFamilyQueryResultStatusPropertiesKHR + { + using NativeType = VkQueueFamilyQueryResultStatusPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyQueryResultStatusPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueueFamilyQueryResultStatusPropertiesKHR( Bool32 queryResultStatusSupport_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , queryResultStatusSupport{ queryResultStatusSupport_ } + { + } + + VULKAN_HPP_CONSTEXPR QueueFamilyQueryResultStatusPropertiesKHR( QueueFamilyQueryResultStatusPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyQueryResultStatusPropertiesKHR( VkQueueFamilyQueryResultStatusPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyQueryResultStatusPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyQueryResultStatusPropertiesKHR & operator=( QueueFamilyQueryResultStatusPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyQueryResultStatusPropertiesKHR & operator=( VkQueueFamilyQueryResultStatusPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyQueryResultStatusPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyQueryResultStatusPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyQueryResultStatusPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyQueryResultStatusPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queryResultStatusSupport ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyQueryResultStatusPropertiesKHR const & ) const = default; +#else + bool operator==( QueueFamilyQueryResultStatusPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queryResultStatusSupport == rhs.queryResultStatusSupport ); +# endif + } + + bool operator!=( QueueFamilyQueryResultStatusPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueueFamilyQueryResultStatusPropertiesKHR; + void * pNext = {}; + Bool32 queryResultStatusSupport = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyQueryResultStatusPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = QueueFamilyQueryResultStatusPropertiesKHR; + }; + + // wrapper struct for struct VkQueueFamilyVideoPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyVideoPropertiesKHR.html + struct QueueFamilyVideoPropertiesKHR + { + using NativeType = VkQueueFamilyVideoPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyVideoPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR QueueFamilyVideoPropertiesKHR( VideoCodecOperationFlagsKHR videoCodecOperations_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoCodecOperations{ videoCodecOperations_ } + { + } + + VULKAN_HPP_CONSTEXPR QueueFamilyVideoPropertiesKHR( QueueFamilyVideoPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + QueueFamilyVideoPropertiesKHR( VkQueueFamilyVideoPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : QueueFamilyVideoPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + QueueFamilyVideoPropertiesKHR & operator=( QueueFamilyVideoPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + QueueFamilyVideoPropertiesKHR & operator=( VkQueueFamilyVideoPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkQueueFamilyVideoPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyVideoPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkQueueFamilyVideoPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkQueueFamilyVideoPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoCodecOperations ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( QueueFamilyVideoPropertiesKHR const & ) const = default; +#else + bool operator==( QueueFamilyVideoPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperations == rhs.videoCodecOperations ); +# endif + } + + bool operator!=( QueueFamilyVideoPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eQueueFamilyVideoPropertiesKHR; + void * pNext = {}; + VideoCodecOperationFlagsKHR videoCodecOperations = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = QueueFamilyVideoPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = QueueFamilyVideoPropertiesKHR; + }; + + // wrapper struct for struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV.html + struct RayTracingPipelineClusterAccelerationStructureCreateInfoNV + { + using NativeType = VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineClusterAccelerationStructureCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RayTracingPipelineClusterAccelerationStructureCreateInfoNV( Bool32 allowClusterAccelerationStructure_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , allowClusterAccelerationStructure{ allowClusterAccelerationStructure_ } + { + } + + VULKAN_HPP_CONSTEXPR RayTracingPipelineClusterAccelerationStructureCreateInfoNV( RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + RayTracingPipelineClusterAccelerationStructureCreateInfoNV( VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : RayTracingPipelineClusterAccelerationStructureCreateInfoNV( + *reinterpret_cast( &rhs ) ) + { + } + + RayTracingPipelineClusterAccelerationStructureCreateInfoNV & + operator=( RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RayTracingPipelineClusterAccelerationStructureCreateInfoNV & + operator=( VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineClusterAccelerationStructureCreateInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineClusterAccelerationStructureCreateInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineClusterAccelerationStructureCreateInfoNV & + setAllowClusterAccelerationStructure( Bool32 allowClusterAccelerationStructure_ ) & + VULKAN_HPP_NOEXCEPT + { + allowClusterAccelerationStructure = allowClusterAccelerationStructure_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineClusterAccelerationStructureCreateInfoNV && + setAllowClusterAccelerationStructure( Bool32 allowClusterAccelerationStructure_ ) && + VULKAN_HPP_NOEXCEPT + { + allowClusterAccelerationStructure = allowClusterAccelerationStructure_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allowClusterAccelerationStructure ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & ) const = default; +#else + bool operator==( RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allowClusterAccelerationStructure == rhs.allowClusterAccelerationStructure ); +# endif + } + + bool operator!=( RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRayTracingPipelineClusterAccelerationStructureCreateInfoNV; + void * pNext = {}; + Bool32 allowClusterAccelerationStructure = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RayTracingPipelineClusterAccelerationStructureCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = RayTracingPipelineClusterAccelerationStructureCreateInfoNV; + }; + + // wrapper struct for struct VkRayTracingShaderGroupCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingShaderGroupCreateInfoKHR.html + struct RayTracingShaderGroupCreateInfoKHR + { + using NativeType = VkRayTracingShaderGroupCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingShaderGroupCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoKHR( RayTracingShaderGroupTypeKHR type_ = RayTracingShaderGroupTypeKHR::eGeneral, + uint32_t generalShader_ = ShaderUnusedKHR, + uint32_t closestHitShader_ = ShaderUnusedKHR, + uint32_t anyHitShader_ = ShaderUnusedKHR, + uint32_t intersectionShader_ = ShaderUnusedKHR, + const void * pShaderGroupCaptureReplayHandle_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , generalShader{ generalShader_ } + , closestHitShader{ closestHitShader_ } + , anyHitShader{ anyHitShader_ } + , intersectionShader{ intersectionShader_ } + , pShaderGroupCaptureReplayHandle{ pShaderGroupCaptureReplayHandle_ } + { + } + + VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoKHR( RayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RayTracingShaderGroupCreateInfoKHR( VkRayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : RayTracingShaderGroupCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + RayTracingShaderGroupCreateInfoKHR & operator=( RayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RayTracingShaderGroupCreateInfoKHR & operator=( VkRayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setType( RayTracingShaderGroupTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setType( RayTracingShaderGroupTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setGeneralShader( uint32_t generalShader_ ) & VULKAN_HPP_NOEXCEPT + { + generalShader = generalShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setGeneralShader( uint32_t generalShader_ ) && VULKAN_HPP_NOEXCEPT + { + generalShader = generalShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setClosestHitShader( uint32_t closestHitShader_ ) & VULKAN_HPP_NOEXCEPT + { + closestHitShader = closestHitShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setClosestHitShader( uint32_t closestHitShader_ ) && VULKAN_HPP_NOEXCEPT + { + closestHitShader = closestHitShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setAnyHitShader( uint32_t anyHitShader_ ) & VULKAN_HPP_NOEXCEPT + { + anyHitShader = anyHitShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setAnyHitShader( uint32_t anyHitShader_ ) && VULKAN_HPP_NOEXCEPT + { + anyHitShader = anyHitShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setIntersectionShader( uint32_t intersectionShader_ ) & VULKAN_HPP_NOEXCEPT + { + intersectionShader = intersectionShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setIntersectionShader( uint32_t intersectionShader_ ) && VULKAN_HPP_NOEXCEPT + { + intersectionShader = intersectionShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setPShaderGroupCaptureReplayHandle( const void * pShaderGroupCaptureReplayHandle_ ) & + VULKAN_HPP_NOEXCEPT + { + pShaderGroupCaptureReplayHandle = pShaderGroupCaptureReplayHandle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setPShaderGroupCaptureReplayHandle( const void * pShaderGroupCaptureReplayHandle_ ) && + VULKAN_HPP_NOEXCEPT + { + pShaderGroupCaptureReplayHandle = pShaderGroupCaptureReplayHandle_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRayTracingShaderGroupCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingShaderGroupCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingShaderGroupCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRayTracingShaderGroupCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader, pShaderGroupCaptureReplayHandle ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RayTracingShaderGroupCreateInfoKHR const & ) const = default; +#else + bool operator==( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( generalShader == rhs.generalShader ) && + ( closestHitShader == rhs.closestHitShader ) && ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ) && + ( pShaderGroupCaptureReplayHandle == rhs.pShaderGroupCaptureReplayHandle ); +# endif + } + + bool operator!=( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoKHR; + const void * pNext = {}; + RayTracingShaderGroupTypeKHR type = RayTracingShaderGroupTypeKHR::eGeneral; + uint32_t generalShader = ShaderUnusedKHR; + uint32_t closestHitShader = ShaderUnusedKHR; + uint32_t anyHitShader = ShaderUnusedKHR; + uint32_t intersectionShader = ShaderUnusedKHR; + const void * pShaderGroupCaptureReplayHandle = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RayTracingShaderGroupCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = RayTracingShaderGroupCreateInfoKHR; + }; + + // wrapper struct for struct VkRayTracingPipelineInterfaceCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingPipelineInterfaceCreateInfoKHR.html + struct RayTracingPipelineInterfaceCreateInfoKHR + { + using NativeType = VkRayTracingPipelineInterfaceCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineInterfaceCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RayTracingPipelineInterfaceCreateInfoKHR( uint32_t maxPipelineRayPayloadSize_ = {}, + uint32_t maxPipelineRayHitAttributeSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxPipelineRayPayloadSize{ maxPipelineRayPayloadSize_ } + , maxPipelineRayHitAttributeSize{ maxPipelineRayHitAttributeSize_ } + { + } + + VULKAN_HPP_CONSTEXPR RayTracingPipelineInterfaceCreateInfoKHR( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RayTracingPipelineInterfaceCreateInfoKHR( VkRayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : RayTracingPipelineInterfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + RayTracingPipelineInterfaceCreateInfoKHR & operator=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RayTracingPipelineInterfaceCreateInfoKHR & operator=( VkRayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR & setMaxPipelineRayPayloadSize( uint32_t maxPipelineRayPayloadSize_ ) & VULKAN_HPP_NOEXCEPT + { + maxPipelineRayPayloadSize = maxPipelineRayPayloadSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR && setMaxPipelineRayPayloadSize( uint32_t maxPipelineRayPayloadSize_ ) && + VULKAN_HPP_NOEXCEPT + { + maxPipelineRayPayloadSize = maxPipelineRayPayloadSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR & setMaxPipelineRayHitAttributeSize( uint32_t maxPipelineRayHitAttributeSize_ ) & + VULKAN_HPP_NOEXCEPT + { + maxPipelineRayHitAttributeSize = maxPipelineRayHitAttributeSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR && setMaxPipelineRayHitAttributeSize( uint32_t maxPipelineRayHitAttributeSize_ ) && + VULKAN_HPP_NOEXCEPT + { + maxPipelineRayHitAttributeSize = maxPipelineRayHitAttributeSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRayTracingPipelineInterfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingPipelineInterfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingPipelineInterfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRayTracingPipelineInterfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxPipelineRayPayloadSize, maxPipelineRayHitAttributeSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RayTracingPipelineInterfaceCreateInfoKHR const & ) const = default; +#else + bool operator==( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPipelineRayPayloadSize == rhs.maxPipelineRayPayloadSize ) && + ( maxPipelineRayHitAttributeSize == rhs.maxPipelineRayHitAttributeSize ); +# endif + } + + bool operator!=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRayTracingPipelineInterfaceCreateInfoKHR; + const void * pNext = {}; + uint32_t maxPipelineRayPayloadSize = {}; + uint32_t maxPipelineRayHitAttributeSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RayTracingPipelineInterfaceCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = RayTracingPipelineInterfaceCreateInfoKHR; + }; + + // wrapper struct for struct VkRayTracingPipelineCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingPipelineCreateInfoKHR.html + struct RayTracingPipelineCreateInfoKHR + { + using NativeType = VkRayTracingPipelineCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoKHR( PipelineCreateFlags flags_ = {}, + uint32_t stageCount_ = {}, + const PipelineShaderStageCreateInfo * pStages_ = {}, + uint32_t groupCount_ = {}, + const RayTracingShaderGroupCreateInfoKHR * pGroups_ = {}, + uint32_t maxPipelineRayRecursionDepth_ = {}, + const PipelineLibraryCreateInfoKHR * pLibraryInfo_ = {}, + const RayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface_ = {}, + const PipelineDynamicStateCreateInfo * pDynamicState_ = {}, + PipelineLayout layout_ = {}, + Pipeline basePipelineHandle_ = {}, + int32_t basePipelineIndex_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , stageCount{ stageCount_ } + , pStages{ pStages_ } + , groupCount{ groupCount_ } + , pGroups{ pGroups_ } + , maxPipelineRayRecursionDepth{ maxPipelineRayRecursionDepth_ } + , pLibraryInfo{ pLibraryInfo_ } + , pLibraryInterface{ pLibraryInterface_ } + , pDynamicState{ pDynamicState_ } + , layout{ layout_ } + , basePipelineHandle{ basePipelineHandle_ } + , basePipelineIndex{ basePipelineIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoKHR( RayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RayTracingPipelineCreateInfoKHR( VkRayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : RayTracingPipelineCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RayTracingPipelineCreateInfoKHR( PipelineCreateFlags flags_, + ArrayProxyNoTemporaries const & stages_, + ArrayProxyNoTemporaries const & groups_ = {}, + uint32_t maxPipelineRayRecursionDepth_ = {}, + const PipelineLibraryCreateInfoKHR * pLibraryInfo_ = {}, + const RayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface_ = {}, + const PipelineDynamicStateCreateInfo * pDynamicState_ = {}, + PipelineLayout layout_ = {}, + Pipeline basePipelineHandle_ = {}, + int32_t basePipelineIndex_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , stageCount( static_cast( stages_.size() ) ) + , pStages( stages_.data() ) + , groupCount( static_cast( groups_.size() ) ) + , pGroups( groups_.data() ) + , maxPipelineRayRecursionDepth( maxPipelineRayRecursionDepth_ ) + , pLibraryInfo( pLibraryInfo_ ) + , pLibraryInterface( pLibraryInterface_ ) + , pDynamicState( pDynamicState_ ) + , layout( layout_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RayTracingPipelineCreateInfoKHR & operator=( RayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RayTracingPipelineCreateInfoKHR & operator=( VkRayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setFlags( PipelineCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setFlags( PipelineCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setStageCount( uint32_t stageCount_ ) & VULKAN_HPP_NOEXCEPT + { + stageCount = stageCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setStageCount( uint32_t stageCount_ ) && VULKAN_HPP_NOEXCEPT + { + stageCount = stageCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPStages( const PipelineShaderStageCreateInfo * pStages_ ) & VULKAN_HPP_NOEXCEPT + { + pStages = pStages_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPStages( const PipelineShaderStageCreateInfo * pStages_ ) && VULKAN_HPP_NOEXCEPT + { + pStages = pStages_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RayTracingPipelineCreateInfoKHR & setStages( ArrayProxyNoTemporaries const & stages_ ) VULKAN_HPP_NOEXCEPT + { + stageCount = static_cast( stages_.size() ); + pStages = stages_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setGroupCount( uint32_t groupCount_ ) & VULKAN_HPP_NOEXCEPT + { + groupCount = groupCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setGroupCount( uint32_t groupCount_ ) && VULKAN_HPP_NOEXCEPT + { + groupCount = groupCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPGroups( const RayTracingShaderGroupCreateInfoKHR * pGroups_ ) & VULKAN_HPP_NOEXCEPT + { + pGroups = pGroups_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPGroups( const RayTracingShaderGroupCreateInfoKHR * pGroups_ ) && VULKAN_HPP_NOEXCEPT + { + pGroups = pGroups_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RayTracingPipelineCreateInfoKHR & setGroups( ArrayProxyNoTemporaries const & groups_ ) VULKAN_HPP_NOEXCEPT + { + groupCount = static_cast( groups_.size() ); + pGroups = groups_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setMaxPipelineRayRecursionDepth( uint32_t maxPipelineRayRecursionDepth_ ) & VULKAN_HPP_NOEXCEPT + { + maxPipelineRayRecursionDepth = maxPipelineRayRecursionDepth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setMaxPipelineRayRecursionDepth( uint32_t maxPipelineRayRecursionDepth_ ) && VULKAN_HPP_NOEXCEPT + { + maxPipelineRayRecursionDepth = maxPipelineRayRecursionDepth_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPLibraryInfo( const PipelineLibraryCreateInfoKHR * pLibraryInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pLibraryInfo = pLibraryInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPLibraryInfo( const PipelineLibraryCreateInfoKHR * pLibraryInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pLibraryInfo = pLibraryInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPLibraryInterface( const RayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface_ ) & + VULKAN_HPP_NOEXCEPT + { + pLibraryInterface = pLibraryInterface_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPLibraryInterface( const RayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface_ ) && + VULKAN_HPP_NOEXCEPT + { + pLibraryInterface = pLibraryInterface_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPDynamicState( const PipelineDynamicStateCreateInfo * pDynamicState_ ) & VULKAN_HPP_NOEXCEPT + { + pDynamicState = pDynamicState_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPDynamicState( const PipelineDynamicStateCreateInfo * pDynamicState_ ) && VULKAN_HPP_NOEXCEPT + { + pDynamicState = pDynamicState_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setBasePipelineHandle( Pipeline basePipelineHandle_ ) & VULKAN_HPP_NOEXCEPT + { + basePipelineHandle = basePipelineHandle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setBasePipelineHandle( Pipeline basePipelineHandle_ ) && VULKAN_HPP_NOEXCEPT + { + basePipelineHandle = basePipelineHandle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setBasePipelineIndex( int32_t basePipelineIndex_ ) & VULKAN_HPP_NOEXCEPT + { + basePipelineIndex = basePipelineIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setBasePipelineIndex( int32_t basePipelineIndex_ ) && VULKAN_HPP_NOEXCEPT + { + basePipelineIndex = basePipelineIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRayTracingPipelineCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingPipelineCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingPipelineCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRayTracingPipelineCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + stageCount, + pStages, + groupCount, + pGroups, + maxPipelineRayRecursionDepth, + pLibraryInfo, + pLibraryInterface, + pDynamicState, + layout, + basePipelineHandle, + basePipelineIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RayTracingPipelineCreateInfoKHR const & ) const = default; +#else + bool operator==( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && + ( groupCount == rhs.groupCount ) && ( pGroups == rhs.pGroups ) && ( maxPipelineRayRecursionDepth == rhs.maxPipelineRayRecursionDepth ) && + ( pLibraryInfo == rhs.pLibraryInfo ) && ( pLibraryInterface == rhs.pLibraryInterface ) && ( pDynamicState == rhs.pDynamicState ) && + ( layout == rhs.layout ) && ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex ); +# endif + } + + bool operator!=( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRayTracingPipelineCreateInfoKHR; + const void * pNext = {}; + PipelineCreateFlags flags = {}; + uint32_t stageCount = {}; + const PipelineShaderStageCreateInfo * pStages = {}; + uint32_t groupCount = {}; + const RayTracingShaderGroupCreateInfoKHR * pGroups = {}; + uint32_t maxPipelineRayRecursionDepth = {}; + const PipelineLibraryCreateInfoKHR * pLibraryInfo = {}; + const RayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface = {}; + const PipelineDynamicStateCreateInfo * pDynamicState = {}; + PipelineLayout layout = {}; + Pipeline basePipelineHandle = {}; + int32_t basePipelineIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RayTracingPipelineCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = RayTracingPipelineCreateInfoKHR; + }; + + // wrapper struct for struct VkRayTracingShaderGroupCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingShaderGroupCreateInfoNV.html + struct RayTracingShaderGroupCreateInfoNV + { + using NativeType = VkRayTracingShaderGroupCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingShaderGroupCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupTypeKHR type_ = RayTracingShaderGroupTypeKHR::eGeneral, + uint32_t generalShader_ = ShaderUnusedNV, + uint32_t closestHitShader_ = ShaderUnusedNV, + uint32_t anyHitShader_ = ShaderUnusedNV, + uint32_t intersectionShader_ = ShaderUnusedNV, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , generalShader{ generalShader_ } + , closestHitShader{ closestHitShader_ } + , anyHitShader{ anyHitShader_ } + , intersectionShader{ intersectionShader_ } + { + } + + VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : RayTracingShaderGroupCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + RayTracingShaderGroupCreateInfoNV & operator=( RayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RayTracingShaderGroupCreateInfoNV & operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setType( RayTracingShaderGroupTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setType( RayTracingShaderGroupTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setGeneralShader( uint32_t generalShader_ ) & VULKAN_HPP_NOEXCEPT + { + generalShader = generalShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setGeneralShader( uint32_t generalShader_ ) && VULKAN_HPP_NOEXCEPT + { + generalShader = generalShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setClosestHitShader( uint32_t closestHitShader_ ) & VULKAN_HPP_NOEXCEPT + { + closestHitShader = closestHitShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setClosestHitShader( uint32_t closestHitShader_ ) && VULKAN_HPP_NOEXCEPT + { + closestHitShader = closestHitShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setAnyHitShader( uint32_t anyHitShader_ ) & VULKAN_HPP_NOEXCEPT + { + anyHitShader = anyHitShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setAnyHitShader( uint32_t anyHitShader_ ) && VULKAN_HPP_NOEXCEPT + { + anyHitShader = anyHitShader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setIntersectionShader( uint32_t intersectionShader_ ) & VULKAN_HPP_NOEXCEPT + { + intersectionShader = intersectionShader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setIntersectionShader( uint32_t intersectionShader_ ) && VULKAN_HPP_NOEXCEPT + { + intersectionShader = intersectionShader_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRayTracingShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingShaderGroupCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRayTracingShaderGroupCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RayTracingShaderGroupCreateInfoNV const & ) const = default; +#else + bool operator==( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( generalShader == rhs.generalShader ) && + ( closestHitShader == rhs.closestHitShader ) && ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ); +# endif + } + + bool operator!=( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV; + const void * pNext = {}; + RayTracingShaderGroupTypeKHR type = RayTracingShaderGroupTypeKHR::eGeneral; + uint32_t generalShader = ShaderUnusedNV; + uint32_t closestHitShader = ShaderUnusedNV; + uint32_t anyHitShader = ShaderUnusedNV; + uint32_t intersectionShader = ShaderUnusedNV; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RayTracingShaderGroupCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = RayTracingShaderGroupCreateInfoNV; + }; + + // wrapper struct for struct VkRayTracingPipelineCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingPipelineCreateInfoNV.html + struct RayTracingPipelineCreateInfoNV + { + using NativeType = VkRayTracingPipelineCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( PipelineCreateFlags flags_ = {}, + uint32_t stageCount_ = {}, + const PipelineShaderStageCreateInfo * pStages_ = {}, + uint32_t groupCount_ = {}, + const RayTracingShaderGroupCreateInfoNV * pGroups_ = {}, + uint32_t maxRecursionDepth_ = {}, + PipelineLayout layout_ = {}, + Pipeline basePipelineHandle_ = {}, + int32_t basePipelineIndex_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , stageCount{ stageCount_ } + , pStages{ pStages_ } + , groupCount{ groupCount_ } + , pGroups{ pGroups_ } + , maxRecursionDepth{ maxRecursionDepth_ } + , layout{ layout_ } + , basePipelineHandle{ basePipelineHandle_ } + , basePipelineIndex{ basePipelineIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( RayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : RayTracingPipelineCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RayTracingPipelineCreateInfoNV( PipelineCreateFlags flags_, + ArrayProxyNoTemporaries const & stages_, + ArrayProxyNoTemporaries const & groups_ = {}, + uint32_t maxRecursionDepth_ = {}, + PipelineLayout layout_ = {}, + Pipeline basePipelineHandle_ = {}, + int32_t basePipelineIndex_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , stageCount( static_cast( stages_.size() ) ) + , pStages( stages_.data() ) + , groupCount( static_cast( groups_.size() ) ) + , pGroups( groups_.data() ) + , maxRecursionDepth( maxRecursionDepth_ ) + , layout( layout_ ) + , basePipelineHandle( basePipelineHandle_ ) + , basePipelineIndex( basePipelineIndex_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RayTracingPipelineCreateInfoNV & operator=( RayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RayTracingPipelineCreateInfoNV & operator=( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setFlags( PipelineCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setFlags( PipelineCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setStageCount( uint32_t stageCount_ ) & VULKAN_HPP_NOEXCEPT + { + stageCount = stageCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setStageCount( uint32_t stageCount_ ) && VULKAN_HPP_NOEXCEPT + { + stageCount = stageCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setPStages( const PipelineShaderStageCreateInfo * pStages_ ) & VULKAN_HPP_NOEXCEPT + { + pStages = pStages_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setPStages( const PipelineShaderStageCreateInfo * pStages_ ) && VULKAN_HPP_NOEXCEPT + { + pStages = pStages_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RayTracingPipelineCreateInfoNV & setStages( ArrayProxyNoTemporaries const & stages_ ) VULKAN_HPP_NOEXCEPT + { + stageCount = static_cast( stages_.size() ); + pStages = stages_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setGroupCount( uint32_t groupCount_ ) & VULKAN_HPP_NOEXCEPT + { + groupCount = groupCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setGroupCount( uint32_t groupCount_ ) && VULKAN_HPP_NOEXCEPT + { + groupCount = groupCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setPGroups( const RayTracingShaderGroupCreateInfoNV * pGroups_ ) & VULKAN_HPP_NOEXCEPT + { + pGroups = pGroups_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setPGroups( const RayTracingShaderGroupCreateInfoNV * pGroups_ ) && VULKAN_HPP_NOEXCEPT + { + pGroups = pGroups_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RayTracingPipelineCreateInfoNV & setGroups( ArrayProxyNoTemporaries const & groups_ ) VULKAN_HPP_NOEXCEPT + { + groupCount = static_cast( groups_.size() ); + pGroups = groups_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setMaxRecursionDepth( uint32_t maxRecursionDepth_ ) & VULKAN_HPP_NOEXCEPT + { + maxRecursionDepth = maxRecursionDepth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setMaxRecursionDepth( uint32_t maxRecursionDepth_ ) && VULKAN_HPP_NOEXCEPT + { + maxRecursionDepth = maxRecursionDepth_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setBasePipelineHandle( Pipeline basePipelineHandle_ ) & VULKAN_HPP_NOEXCEPT + { + basePipelineHandle = basePipelineHandle_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setBasePipelineHandle( Pipeline basePipelineHandle_ ) && VULKAN_HPP_NOEXCEPT + { + basePipelineHandle = basePipelineHandle_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setBasePipelineIndex( int32_t basePipelineIndex_ ) & VULKAN_HPP_NOEXCEPT + { + basePipelineIndex = basePipelineIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setBasePipelineIndex( int32_t basePipelineIndex_ ) && VULKAN_HPP_NOEXCEPT + { + basePipelineIndex = basePipelineIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRayTracingPipelineCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingPipelineCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRayTracingPipelineCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRayTracingPipelineCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, stageCount, pStages, groupCount, pGroups, maxRecursionDepth, layout, basePipelineHandle, basePipelineIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RayTracingPipelineCreateInfoNV const & ) const = default; +#else + bool operator==( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && + ( groupCount == rhs.groupCount ) && ( pGroups == rhs.pGroups ) && ( maxRecursionDepth == rhs.maxRecursionDepth ) && ( layout == rhs.layout ) && + ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex ); +# endif + } + + bool operator!=( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV; + const void * pNext = {}; + PipelineCreateFlags flags = {}; + uint32_t stageCount = {}; + const PipelineShaderStageCreateInfo * pStages = {}; + uint32_t groupCount = {}; + const RayTracingShaderGroupCreateInfoNV * pGroups = {}; + uint32_t maxRecursionDepth = {}; + PipelineLayout layout = {}; + Pipeline basePipelineHandle = {}; + int32_t basePipelineIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RayTracingPipelineCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = RayTracingPipelineCreateInfoNV; + }; + + // wrapper struct for struct VkRefreshCycleDurationGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRefreshCycleDurationGOOGLE.html + struct RefreshCycleDurationGOOGLE + { + using NativeType = VkRefreshCycleDurationGOOGLE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = {} ) VULKAN_HPP_NOEXCEPT : refreshDuration{ refreshDuration_ } {} + + VULKAN_HPP_CONSTEXPR RefreshCycleDurationGOOGLE( RefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT + : RefreshCycleDurationGOOGLE( *reinterpret_cast( &rhs ) ) + { + } + + RefreshCycleDurationGOOGLE & operator=( RefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RefreshCycleDurationGOOGLE & operator=( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkRefreshCycleDurationGOOGLE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRefreshCycleDurationGOOGLE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRefreshCycleDurationGOOGLE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRefreshCycleDurationGOOGLE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( refreshDuration ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RefreshCycleDurationGOOGLE const & ) const = default; +#else + bool operator==( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( refreshDuration == rhs.refreshDuration ); +# endif + } + + bool operator!=( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint64_t refreshDuration = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RefreshCycleDurationGOOGLE; + }; +#endif + + // wrapper struct for struct VkReleaseCapturedPipelineDataInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkReleaseCapturedPipelineDataInfoKHR.html + struct ReleaseCapturedPipelineDataInfoKHR + { + using NativeType = VkReleaseCapturedPipelineDataInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eReleaseCapturedPipelineDataInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ReleaseCapturedPipelineDataInfoKHR( Pipeline pipeline_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pipeline{ pipeline_ } + { + } + + VULKAN_HPP_CONSTEXPR ReleaseCapturedPipelineDataInfoKHR( ReleaseCapturedPipelineDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ReleaseCapturedPipelineDataInfoKHR( VkReleaseCapturedPipelineDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ReleaseCapturedPipelineDataInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ReleaseCapturedPipelineDataInfoKHR & operator=( ReleaseCapturedPipelineDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ReleaseCapturedPipelineDataInfoKHR & operator=( VkReleaseCapturedPipelineDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ReleaseCapturedPipelineDataInfoKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ReleaseCapturedPipelineDataInfoKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ReleaseCapturedPipelineDataInfoKHR & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ReleaseCapturedPipelineDataInfoKHR && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkReleaseCapturedPipelineDataInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkReleaseCapturedPipelineDataInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkReleaseCapturedPipelineDataInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkReleaseCapturedPipelineDataInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pipeline ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ReleaseCapturedPipelineDataInfoKHR const & ) const = default; +#else + bool operator==( ReleaseCapturedPipelineDataInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ); +# endif + } + + bool operator!=( ReleaseCapturedPipelineDataInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eReleaseCapturedPipelineDataInfoKHR; + void * pNext = {}; + Pipeline pipeline = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ReleaseCapturedPipelineDataInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = ReleaseCapturedPipelineDataInfoKHR; + }; + + // wrapper struct for struct VkReleaseSwapchainImagesInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkReleaseSwapchainImagesInfoKHR.html + struct ReleaseSwapchainImagesInfoKHR + { + using NativeType = VkReleaseSwapchainImagesInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eReleaseSwapchainImagesInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ReleaseSwapchainImagesInfoKHR( SwapchainKHR swapchain_ = {}, + uint32_t imageIndexCount_ = {}, + const uint32_t * pImageIndices_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchain{ swapchain_ } + , imageIndexCount{ imageIndexCount_ } + , pImageIndices{ pImageIndices_ } + { + } + + VULKAN_HPP_CONSTEXPR ReleaseSwapchainImagesInfoKHR( ReleaseSwapchainImagesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ReleaseSwapchainImagesInfoKHR( VkReleaseSwapchainImagesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ReleaseSwapchainImagesInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ReleaseSwapchainImagesInfoKHR( SwapchainKHR swapchain_, ArrayProxyNoTemporaries const & imageIndices_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), swapchain( swapchain_ ), imageIndexCount( static_cast( imageIndices_.size() ) ), pImageIndices( imageIndices_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ReleaseSwapchainImagesInfoKHR & operator=( ReleaseSwapchainImagesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ReleaseSwapchainImagesInfoKHR & operator=( VkReleaseSwapchainImagesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR & setImageIndexCount( uint32_t imageIndexCount_ ) & VULKAN_HPP_NOEXCEPT + { + imageIndexCount = imageIndexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR && setImageIndexCount( uint32_t imageIndexCount_ ) && VULKAN_HPP_NOEXCEPT + { + imageIndexCount = imageIndexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR & setPImageIndices( const uint32_t * pImageIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pImageIndices = pImageIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR && setPImageIndices( const uint32_t * pImageIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pImageIndices = pImageIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ReleaseSwapchainImagesInfoKHR & setImageIndices( ArrayProxyNoTemporaries const & imageIndices_ ) VULKAN_HPP_NOEXCEPT + { + imageIndexCount = static_cast( imageIndices_.size() ); + pImageIndices = imageIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkReleaseSwapchainImagesInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkReleaseSwapchainImagesInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkReleaseSwapchainImagesInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkReleaseSwapchainImagesInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain, imageIndexCount, pImageIndices ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ReleaseSwapchainImagesInfoKHR const & ) const = default; +#else + bool operator==( ReleaseSwapchainImagesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( imageIndexCount == rhs.imageIndexCount ) && + ( pImageIndices == rhs.pImageIndices ); +# endif + } + + bool operator!=( ReleaseSwapchainImagesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eReleaseSwapchainImagesInfoKHR; + const void * pNext = {}; + SwapchainKHR swapchain = {}; + uint32_t imageIndexCount = {}; + const uint32_t * pImageIndices = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ReleaseSwapchainImagesInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = ReleaseSwapchainImagesInfoKHR; + }; + + using ReleaseSwapchainImagesInfoEXT = ReleaseSwapchainImagesInfoKHR; + + // wrapper struct for struct VkRenderPassAttachmentBeginInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassAttachmentBeginInfo.html + struct RenderPassAttachmentBeginInfo + { + using NativeType = VkRenderPassAttachmentBeginInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassAttachmentBeginInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + RenderPassAttachmentBeginInfo( uint32_t attachmentCount_ = {}, const ImageView * pAttachments_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , attachmentCount{ attachmentCount_ } + , pAttachments{ pAttachments_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfo( RenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassAttachmentBeginInfo( VkRenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassAttachmentBeginInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassAttachmentBeginInfo( ArrayProxyNoTemporaries const & attachments_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), attachmentCount( static_cast( attachments_.size() ) ), pAttachments( attachments_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderPassAttachmentBeginInfo & operator=( RenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassAttachmentBeginInfo & operator=( VkRenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo & setPAttachments( const ImageView * pAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pAttachments = pAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo && setPAttachments( const ImageView * pAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pAttachments = pAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassAttachmentBeginInfo & setAttachments( ArrayProxyNoTemporaries const & attachments_ ) VULKAN_HPP_NOEXCEPT + { + attachmentCount = static_cast( attachments_.size() ); + pAttachments = attachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassAttachmentBeginInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassAttachmentBeginInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassAttachmentBeginInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassAttachmentBeginInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, attachmentCount, pAttachments ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassAttachmentBeginInfo const & ) const = default; +#else + bool operator==( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ); +# endif + } + + bool operator!=( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassAttachmentBeginInfo; + const void * pNext = {}; + uint32_t attachmentCount = {}; + const ImageView * pAttachments = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassAttachmentBeginInfo; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassAttachmentBeginInfo; + }; + + using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo; + + // wrapper struct for struct VkRenderPassBeginInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassBeginInfo.html + struct RenderPassBeginInfo + { + using NativeType = VkRenderPassBeginInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassBeginInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo( RenderPass renderPass_ = {}, + Framebuffer framebuffer_ = {}, + Rect2D renderArea_ = {}, + uint32_t clearValueCount_ = {}, + const ClearValue * pClearValues_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , renderPass{ renderPass_ } + , framebuffer{ framebuffer_ } + , renderArea{ renderArea_ } + , clearValueCount{ clearValueCount_ } + , pClearValues{ pClearValues_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo( RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT : RenderPassBeginInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassBeginInfo( RenderPass renderPass_, + Framebuffer framebuffer_, + Rect2D renderArea_, + ArrayProxyNoTemporaries const & clearValues_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , renderPass( renderPass_ ) + , framebuffer( framebuffer_ ) + , renderArea( renderArea_ ) + , clearValueCount( static_cast( clearValues_.size() ) ) + , pClearValues( clearValues_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderPassBeginInfo & operator=( RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassBeginInfo & operator=( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setRenderPass( RenderPass renderPass_ ) & VULKAN_HPP_NOEXCEPT + { + renderPass = renderPass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setRenderPass( RenderPass renderPass_ ) && VULKAN_HPP_NOEXCEPT + { + renderPass = renderPass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setFramebuffer( Framebuffer framebuffer_ ) & VULKAN_HPP_NOEXCEPT + { + framebuffer = framebuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setFramebuffer( Framebuffer framebuffer_ ) && VULKAN_HPP_NOEXCEPT + { + framebuffer = framebuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setRenderArea( Rect2D const & renderArea_ ) & VULKAN_HPP_NOEXCEPT + { + renderArea = renderArea_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setRenderArea( Rect2D const & renderArea_ ) && VULKAN_HPP_NOEXCEPT + { + renderArea = renderArea_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setClearValueCount( uint32_t clearValueCount_ ) & VULKAN_HPP_NOEXCEPT + { + clearValueCount = clearValueCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setClearValueCount( uint32_t clearValueCount_ ) && VULKAN_HPP_NOEXCEPT + { + clearValueCount = clearValueCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setPClearValues( const ClearValue * pClearValues_ ) & VULKAN_HPP_NOEXCEPT + { + pClearValues = pClearValues_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setPClearValues( const ClearValue * pClearValues_ ) && VULKAN_HPP_NOEXCEPT + { + pClearValues = pClearValues_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassBeginInfo & setClearValues( ArrayProxyNoTemporaries const & clearValues_ ) VULKAN_HPP_NOEXCEPT + { + clearValueCount = static_cast( clearValues_.size() ); + pClearValues = clearValues_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassBeginInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassBeginInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, renderPass, framebuffer, renderArea, clearValueCount, pClearValues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassBeginInfo const & ) const = default; +#else + bool operator==( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && ( framebuffer == rhs.framebuffer ) && + ( renderArea == rhs.renderArea ) && ( clearValueCount == rhs.clearValueCount ) && ( pClearValues == rhs.pClearValues ); +# endif + } + + bool operator!=( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassBeginInfo; + const void * pNext = {}; + RenderPass renderPass = {}; + Framebuffer framebuffer = {}; + Rect2D renderArea = {}; + uint32_t clearValueCount = {}; + const ClearValue * pClearValues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassBeginInfo; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassBeginInfo; + }; + + // wrapper struct for struct VkSubpassDescription, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescription.html + struct SubpassDescription + { + using NativeType = VkSubpassDescription; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubpassDescription( SubpassDescriptionFlags flags_ = {}, + PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + uint32_t inputAttachmentCount_ = {}, + const AttachmentReference * pInputAttachments_ = {}, + uint32_t colorAttachmentCount_ = {}, + const AttachmentReference * pColorAttachments_ = {}, + const AttachmentReference * pResolveAttachments_ = {}, + const AttachmentReference * pDepthStencilAttachment_ = {}, + uint32_t preserveAttachmentCount_ = {}, + const uint32_t * pPreserveAttachments_ = {} ) VULKAN_HPP_NOEXCEPT + : flags{ flags_ } + , pipelineBindPoint{ pipelineBindPoint_ } + , inputAttachmentCount{ inputAttachmentCount_ } + , pInputAttachments{ pInputAttachments_ } + , colorAttachmentCount{ colorAttachmentCount_ } + , pColorAttachments{ pColorAttachments_ } + , pResolveAttachments{ pResolveAttachments_ } + , pDepthStencilAttachment{ pDepthStencilAttachment_ } + , preserveAttachmentCount{ preserveAttachmentCount_ } + , pPreserveAttachments{ pPreserveAttachments_ } + { + } + + VULKAN_HPP_CONSTEXPR SubpassDescription( SubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassDescription( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassDescription( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassDescription( SubpassDescriptionFlags flags_, + PipelineBindPoint pipelineBindPoint_, + ArrayProxyNoTemporaries const & inputAttachments_, + ArrayProxyNoTemporaries const & colorAttachments_ = {}, + ArrayProxyNoTemporaries const & resolveAttachments_ = {}, + const AttachmentReference * pDepthStencilAttachment_ = {}, + ArrayProxyNoTemporaries const & preserveAttachments_ = {} ) + : flags( flags_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , inputAttachmentCount( static_cast( inputAttachments_.size() ) ) + , pInputAttachments( inputAttachments_.data() ) + , colorAttachmentCount( static_cast( colorAttachments_.size() ) ) + , pColorAttachments( colorAttachments_.data() ) + , pResolveAttachments( resolveAttachments_.data() ) + , pDepthStencilAttachment( pDepthStencilAttachment_ ) + , preserveAttachmentCount( static_cast( preserveAttachments_.size() ) ) + , pPreserveAttachments( preserveAttachments_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( resolveAttachments_.empty() || ( colorAttachments_.size() == resolveAttachments_.size() ) ); +# else + if ( !resolveAttachments_.empty() && ( colorAttachments_.size() != resolveAttachments_.size() ) ) + { + throw LogicError( + VULKAN_HPP_NAMESPACE_STRING + "::SubpassDescription::SubpassDescription: !resolveAttachments_.empty() && ( colorAttachments_.size() != resolveAttachments_.size() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SubpassDescription & operator=( SubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubpassDescription & operator=( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setFlags( SubpassDescriptionFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setFlags( SubpassDescriptionFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setInputAttachmentCount( uint32_t inputAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + inputAttachmentCount = inputAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setInputAttachmentCount( uint32_t inputAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + inputAttachmentCount = inputAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPInputAttachments( const AttachmentReference * pInputAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pInputAttachments = pInputAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPInputAttachments( const AttachmentReference * pInputAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pInputAttachments = pInputAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassDescription & setInputAttachments( ArrayProxyNoTemporaries const & inputAttachments_ ) VULKAN_HPP_NOEXCEPT + { + inputAttachmentCount = static_cast( inputAttachments_.size() ); + pInputAttachments = inputAttachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPColorAttachments( const AttachmentReference * pColorAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pColorAttachments = pColorAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPColorAttachments( const AttachmentReference * pColorAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pColorAttachments = pColorAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassDescription & setColorAttachments( ArrayProxyNoTemporaries const & colorAttachments_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( colorAttachments_.size() ); + pColorAttachments = colorAttachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPResolveAttachments( const AttachmentReference * pResolveAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pResolveAttachments = pResolveAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPResolveAttachments( const AttachmentReference * pResolveAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pResolveAttachments = pResolveAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassDescription & setResolveAttachments( ArrayProxyNoTemporaries const & resolveAttachments_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( resolveAttachments_.size() ); + pResolveAttachments = resolveAttachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPDepthStencilAttachment( const AttachmentReference * pDepthStencilAttachment_ ) & VULKAN_HPP_NOEXCEPT + { + pDepthStencilAttachment = pDepthStencilAttachment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPDepthStencilAttachment( const AttachmentReference * pDepthStencilAttachment_ ) && VULKAN_HPP_NOEXCEPT + { + pDepthStencilAttachment = pDepthStencilAttachment_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + preserveAttachmentCount = preserveAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + preserveAttachmentCount = preserveAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPPreserveAttachments( const uint32_t * pPreserveAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pPreserveAttachments = pPreserveAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPPreserveAttachments( const uint32_t * pPreserveAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pPreserveAttachments = pPreserveAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassDescription & setPreserveAttachments( ArrayProxyNoTemporaries const & preserveAttachments_ ) VULKAN_HPP_NOEXCEPT + { + preserveAttachmentCount = static_cast( preserveAttachments_.size() ); + pPreserveAttachments = preserveAttachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubpassDescription const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDescription &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDescription const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubpassDescription *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( flags, + pipelineBindPoint, + inputAttachmentCount, + pInputAttachments, + colorAttachmentCount, + pColorAttachments, + pResolveAttachments, + pDepthStencilAttachment, + preserveAttachmentCount, + pPreserveAttachments ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubpassDescription const & ) const = default; +#else + bool operator==( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( inputAttachmentCount == rhs.inputAttachmentCount ) && + ( pInputAttachments == rhs.pInputAttachments ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && + ( pColorAttachments == rhs.pColorAttachments ) && ( pResolveAttachments == rhs.pResolveAttachments ) && + ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) && ( preserveAttachmentCount == rhs.preserveAttachmentCount ) && + ( pPreserveAttachments == rhs.pPreserveAttachments ); +# endif + } + + bool operator!=( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + SubpassDescriptionFlags flags = {}; + PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; + uint32_t inputAttachmentCount = {}; + const AttachmentReference * pInputAttachments = {}; + uint32_t colorAttachmentCount = {}; + const AttachmentReference * pColorAttachments = {}; + const AttachmentReference * pResolveAttachments = {}; + const AttachmentReference * pDepthStencilAttachment = {}; + uint32_t preserveAttachmentCount = {}; + const uint32_t * pPreserveAttachments = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubpassDescription; + }; +#endif + + // wrapper struct for struct VkSubpassDependency, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDependency.html + struct SubpassDependency + { + using NativeType = VkSubpassDependency; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubpassDependency( uint32_t srcSubpass_ = {}, + uint32_t dstSubpass_ = {}, + PipelineStageFlags srcStageMask_ = {}, + PipelineStageFlags dstStageMask_ = {}, + AccessFlags srcAccessMask_ = {}, + AccessFlags dstAccessMask_ = {}, + DependencyFlags dependencyFlags_ = {} ) VULKAN_HPP_NOEXCEPT + : srcSubpass{ srcSubpass_ } + , dstSubpass{ dstSubpass_ } + , srcStageMask{ srcStageMask_ } + , dstStageMask{ dstStageMask_ } + , srcAccessMask{ srcAccessMask_ } + , dstAccessMask{ dstAccessMask_ } + , dependencyFlags{ dependencyFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR SubpassDependency( SubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassDependency( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassDependency( *reinterpret_cast( &rhs ) ) {} + + SubpassDependency & operator=( SubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubpassDependency & operator=( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setSrcSubpass( uint32_t srcSubpass_ ) & VULKAN_HPP_NOEXCEPT + { + srcSubpass = srcSubpass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setSrcSubpass( uint32_t srcSubpass_ ) && VULKAN_HPP_NOEXCEPT + { + srcSubpass = srcSubpass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setDstSubpass( uint32_t dstSubpass_ ) & VULKAN_HPP_NOEXCEPT + { + dstSubpass = dstSubpass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setDstSubpass( uint32_t dstSubpass_ ) && VULKAN_HPP_NOEXCEPT + { + dstSubpass = dstSubpass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setSrcStageMask( PipelineStageFlags srcStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setSrcStageMask( PipelineStageFlags srcStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setDstStageMask( PipelineStageFlags dstStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setDstStageMask( PipelineStageFlags dstStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setSrcAccessMask( AccessFlags srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setSrcAccessMask( AccessFlags srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setDstAccessMask( AccessFlags dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setDstAccessMask( AccessFlags dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setDependencyFlags( DependencyFlags dependencyFlags_ ) & VULKAN_HPP_NOEXCEPT + { + dependencyFlags = dependencyFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setDependencyFlags( DependencyFlags dependencyFlags_ ) && VULKAN_HPP_NOEXCEPT + { + dependencyFlags = dependencyFlags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubpassDependency const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDependency &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDependency const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubpassDependency *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( srcSubpass, dstSubpass, srcStageMask, dstStageMask, srcAccessMask, dstAccessMask, dependencyFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubpassDependency const & ) const = default; +#else + bool operator==( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( srcSubpass == rhs.srcSubpass ) && ( dstSubpass == rhs.dstSubpass ) && ( srcStageMask == rhs.srcStageMask ) && + ( dstStageMask == rhs.dstStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) && + ( dependencyFlags == rhs.dependencyFlags ); +# endif + } + + bool operator!=( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t srcSubpass = {}; + uint32_t dstSubpass = {}; + PipelineStageFlags srcStageMask = {}; + PipelineStageFlags dstStageMask = {}; + AccessFlags srcAccessMask = {}; + AccessFlags dstAccessMask = {}; + DependencyFlags dependencyFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubpassDependency; + }; +#endif + + // wrapper struct for struct VkRenderPassCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateInfo.html + struct RenderPassCreateInfo + { + using NativeType = VkRenderPassCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( RenderPassCreateFlags flags_ = {}, + uint32_t attachmentCount_ = {}, + const AttachmentDescription * pAttachments_ = {}, + uint32_t subpassCount_ = {}, + const SubpassDescription * pSubpasses_ = {}, + uint32_t dependencyCount_ = {}, + const SubpassDependency * pDependencies_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , attachmentCount{ attachmentCount_ } + , pAttachments{ pAttachments_ } + , subpassCount{ subpassCount_ } + , pSubpasses{ pSubpasses_ } + , dependencyCount{ dependencyCount_ } + , pDependencies{ pDependencies_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassCreateInfo( RenderPassCreateFlags flags_, + ArrayProxyNoTemporaries const & attachments_, + ArrayProxyNoTemporaries const & subpasses_ = {}, + ArrayProxyNoTemporaries const & dependencies_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , attachmentCount( static_cast( attachments_.size() ) ) + , pAttachments( attachments_.data() ) + , subpassCount( static_cast( subpasses_.size() ) ) + , pSubpasses( subpasses_.data() ) + , dependencyCount( static_cast( dependencies_.size() ) ) + , pDependencies( dependencies_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderPassCreateInfo & operator=( RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassCreateInfo & operator=( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setFlags( RenderPassCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setFlags( RenderPassCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setPAttachments( const AttachmentDescription * pAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pAttachments = pAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setPAttachments( const AttachmentDescription * pAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pAttachments = pAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassCreateInfo & setAttachments( ArrayProxyNoTemporaries const & attachments_ ) VULKAN_HPP_NOEXCEPT + { + attachmentCount = static_cast( attachments_.size() ); + pAttachments = attachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setSubpassCount( uint32_t subpassCount_ ) & VULKAN_HPP_NOEXCEPT + { + subpassCount = subpassCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setSubpassCount( uint32_t subpassCount_ ) && VULKAN_HPP_NOEXCEPT + { + subpassCount = subpassCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setPSubpasses( const SubpassDescription * pSubpasses_ ) & VULKAN_HPP_NOEXCEPT + { + pSubpasses = pSubpasses_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setPSubpasses( const SubpassDescription * pSubpasses_ ) && VULKAN_HPP_NOEXCEPT + { + pSubpasses = pSubpasses_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassCreateInfo & setSubpasses( ArrayProxyNoTemporaries const & subpasses_ ) VULKAN_HPP_NOEXCEPT + { + subpassCount = static_cast( subpasses_.size() ); + pSubpasses = subpasses_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setDependencyCount( uint32_t dependencyCount_ ) & VULKAN_HPP_NOEXCEPT + { + dependencyCount = dependencyCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setDependencyCount( uint32_t dependencyCount_ ) && VULKAN_HPP_NOEXCEPT + { + dependencyCount = dependencyCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setPDependencies( const SubpassDependency * pDependencies_ ) & VULKAN_HPP_NOEXCEPT + { + pDependencies = pDependencies_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setPDependencies( const SubpassDependency * pDependencies_ ) && VULKAN_HPP_NOEXCEPT + { + pDependencies = pDependencies_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassCreateInfo & setDependencies( ArrayProxyNoTemporaries const & dependencies_ ) VULKAN_HPP_NOEXCEPT + { + dependencyCount = static_cast( dependencies_.size() ); + pDependencies = dependencies_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, attachmentCount, pAttachments, subpassCount, pSubpasses, dependencyCount, pDependencies ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassCreateInfo const & ) const = default; +#else + bool operator==( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( attachmentCount == rhs.attachmentCount ) && + ( pAttachments == rhs.pAttachments ) && ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) && + ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies ); +# endif + } + + bool operator!=( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassCreateInfo; + const void * pNext = {}; + RenderPassCreateFlags flags = {}; + uint32_t attachmentCount = {}; + const AttachmentDescription * pAttachments = {}; + uint32_t subpassCount = {}; + const SubpassDescription * pSubpasses = {}; + uint32_t dependencyCount = {}; + const SubpassDependency * pDependencies = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassCreateInfo; + }; + + // wrapper struct for struct VkSubpassDescription2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescription2.html + struct SubpassDescription2 + { + using NativeType = VkSubpassDescription2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDescription2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubpassDescription2( SubpassDescriptionFlags flags_ = {}, + PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, + uint32_t viewMask_ = {}, + uint32_t inputAttachmentCount_ = {}, + const AttachmentReference2 * pInputAttachments_ = {}, + uint32_t colorAttachmentCount_ = {}, + const AttachmentReference2 * pColorAttachments_ = {}, + const AttachmentReference2 * pResolveAttachments_ = {}, + const AttachmentReference2 * pDepthStencilAttachment_ = {}, + uint32_t preserveAttachmentCount_ = {}, + const uint32_t * pPreserveAttachments_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , pipelineBindPoint{ pipelineBindPoint_ } + , viewMask{ viewMask_ } + , inputAttachmentCount{ inputAttachmentCount_ } + , pInputAttachments{ pInputAttachments_ } + , colorAttachmentCount{ colorAttachmentCount_ } + , pColorAttachments{ pColorAttachments_ } + , pResolveAttachments{ pResolveAttachments_ } + , pDepthStencilAttachment{ pDepthStencilAttachment_ } + , preserveAttachmentCount{ preserveAttachmentCount_ } + , pPreserveAttachments{ pPreserveAttachments_ } + { + } + + VULKAN_HPP_CONSTEXPR SubpassDescription2( SubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassDescription2( VkSubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassDescription2( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassDescription2( SubpassDescriptionFlags flags_, + PipelineBindPoint pipelineBindPoint_, + uint32_t viewMask_, + ArrayProxyNoTemporaries const & inputAttachments_, + ArrayProxyNoTemporaries const & colorAttachments_ = {}, + ArrayProxyNoTemporaries const & resolveAttachments_ = {}, + const AttachmentReference2 * pDepthStencilAttachment_ = {}, + ArrayProxyNoTemporaries const & preserveAttachments_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , pipelineBindPoint( pipelineBindPoint_ ) + , viewMask( viewMask_ ) + , inputAttachmentCount( static_cast( inputAttachments_.size() ) ) + , pInputAttachments( inputAttachments_.data() ) + , colorAttachmentCount( static_cast( colorAttachments_.size() ) ) + , pColorAttachments( colorAttachments_.data() ) + , pResolveAttachments( resolveAttachments_.data() ) + , pDepthStencilAttachment( pDepthStencilAttachment_ ) + , preserveAttachmentCount( static_cast( preserveAttachments_.size() ) ) + , pPreserveAttachments( preserveAttachments_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( resolveAttachments_.empty() || ( colorAttachments_.size() == resolveAttachments_.size() ) ); +# else + if ( !resolveAttachments_.empty() && ( colorAttachments_.size() != resolveAttachments_.size() ) ) + { + throw LogicError( + VULKAN_HPP_NAMESPACE_STRING + "::SubpassDescription2::SubpassDescription2: !resolveAttachments_.empty() && ( colorAttachments_.size() != resolveAttachments_.size() )" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SubpassDescription2 & operator=( SubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubpassDescription2 & operator=( VkSubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setFlags( SubpassDescriptionFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setFlags( SubpassDescriptionFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT + { + pipelineBindPoint = pipelineBindPoint_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setViewMask( uint32_t viewMask_ ) & VULKAN_HPP_NOEXCEPT + { + viewMask = viewMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setViewMask( uint32_t viewMask_ ) && VULKAN_HPP_NOEXCEPT + { + viewMask = viewMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setInputAttachmentCount( uint32_t inputAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + inputAttachmentCount = inputAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setInputAttachmentCount( uint32_t inputAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + inputAttachmentCount = inputAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPInputAttachments( const AttachmentReference2 * pInputAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pInputAttachments = pInputAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPInputAttachments( const AttachmentReference2 * pInputAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pInputAttachments = pInputAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassDescription2 & setInputAttachments( ArrayProxyNoTemporaries const & inputAttachments_ ) VULKAN_HPP_NOEXCEPT + { + inputAttachmentCount = static_cast( inputAttachments_.size() ); + pInputAttachments = inputAttachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPColorAttachments( const AttachmentReference2 * pColorAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pColorAttachments = pColorAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPColorAttachments( const AttachmentReference2 * pColorAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pColorAttachments = pColorAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassDescription2 & setColorAttachments( ArrayProxyNoTemporaries const & colorAttachments_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( colorAttachments_.size() ); + pColorAttachments = colorAttachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPResolveAttachments( const AttachmentReference2 * pResolveAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pResolveAttachments = pResolveAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPResolveAttachments( const AttachmentReference2 * pResolveAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pResolveAttachments = pResolveAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassDescription2 & setResolveAttachments( ArrayProxyNoTemporaries const & resolveAttachments_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( resolveAttachments_.size() ); + pResolveAttachments = resolveAttachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPDepthStencilAttachment( const AttachmentReference2 * pDepthStencilAttachment_ ) & VULKAN_HPP_NOEXCEPT + { + pDepthStencilAttachment = pDepthStencilAttachment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPDepthStencilAttachment( const AttachmentReference2 * pDepthStencilAttachment_ ) && VULKAN_HPP_NOEXCEPT + { + pDepthStencilAttachment = pDepthStencilAttachment_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + preserveAttachmentCount = preserveAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + preserveAttachmentCount = preserveAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPPreserveAttachments( const uint32_t * pPreserveAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pPreserveAttachments = pPreserveAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPPreserveAttachments( const uint32_t * pPreserveAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pPreserveAttachments = pPreserveAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubpassDescription2 & setPreserveAttachments( ArrayProxyNoTemporaries const & preserveAttachments_ ) VULKAN_HPP_NOEXCEPT + { + preserveAttachmentCount = static_cast( preserveAttachments_.size() ); + pPreserveAttachments = preserveAttachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubpassDescription2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDescription2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDescription2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubpassDescription2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + pipelineBindPoint, + viewMask, + inputAttachmentCount, + pInputAttachments, + colorAttachmentCount, + pColorAttachments, + pResolveAttachments, + pDepthStencilAttachment, + preserveAttachmentCount, + pPreserveAttachments ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubpassDescription2 const & ) const = default; +#else + bool operator==( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && + ( viewMask == rhs.viewMask ) && ( inputAttachmentCount == rhs.inputAttachmentCount ) && ( pInputAttachments == rhs.pInputAttachments ) && + ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) && + ( pResolveAttachments == rhs.pResolveAttachments ) && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) && + ( preserveAttachmentCount == rhs.preserveAttachmentCount ) && ( pPreserveAttachments == rhs.pPreserveAttachments ); +# endif + } + + bool operator!=( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubpassDescription2; + const void * pNext = {}; + SubpassDescriptionFlags flags = {}; + PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; + uint32_t viewMask = {}; + uint32_t inputAttachmentCount = {}; + const AttachmentReference2 * pInputAttachments = {}; + uint32_t colorAttachmentCount = {}; + const AttachmentReference2 * pColorAttachments = {}; + const AttachmentReference2 * pResolveAttachments = {}; + const AttachmentReference2 * pDepthStencilAttachment = {}; + uint32_t preserveAttachmentCount = {}; + const uint32_t * pPreserveAttachments = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubpassDescription2; + }; +#endif + + template <> + struct CppType + { + using Type = SubpassDescription2; + }; + + using SubpassDescription2KHR = SubpassDescription2; + + // wrapper struct for struct VkSubpassDependency2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDependency2.html + struct SubpassDependency2 + { + using NativeType = VkSubpassDependency2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDependency2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubpassDependency2( uint32_t srcSubpass_ = {}, + uint32_t dstSubpass_ = {}, + PipelineStageFlags srcStageMask_ = {}, + PipelineStageFlags dstStageMask_ = {}, + AccessFlags srcAccessMask_ = {}, + AccessFlags dstAccessMask_ = {}, + DependencyFlags dependencyFlags_ = {}, + int32_t viewOffset_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcSubpass{ srcSubpass_ } + , dstSubpass{ dstSubpass_ } + , srcStageMask{ srcStageMask_ } + , dstStageMask{ dstStageMask_ } + , srcAccessMask{ srcAccessMask_ } + , dstAccessMask{ dstAccessMask_ } + , dependencyFlags{ dependencyFlags_ } + , viewOffset{ viewOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR SubpassDependency2( SubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassDependency2( VkSubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassDependency2( *reinterpret_cast( &rhs ) ) {} + + SubpassDependency2 & operator=( SubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubpassDependency2 & operator=( VkSubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setSrcSubpass( uint32_t srcSubpass_ ) & VULKAN_HPP_NOEXCEPT + { + srcSubpass = srcSubpass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setSrcSubpass( uint32_t srcSubpass_ ) && VULKAN_HPP_NOEXCEPT + { + srcSubpass = srcSubpass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setDstSubpass( uint32_t dstSubpass_ ) & VULKAN_HPP_NOEXCEPT + { + dstSubpass = dstSubpass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setDstSubpass( uint32_t dstSubpass_ ) && VULKAN_HPP_NOEXCEPT + { + dstSubpass = dstSubpass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setSrcStageMask( PipelineStageFlags srcStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setSrcStageMask( PipelineStageFlags srcStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setDstStageMask( PipelineStageFlags dstStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setDstStageMask( PipelineStageFlags dstStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setSrcAccessMask( AccessFlags srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setSrcAccessMask( AccessFlags srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setDstAccessMask( AccessFlags dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setDstAccessMask( AccessFlags dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setDependencyFlags( DependencyFlags dependencyFlags_ ) & VULKAN_HPP_NOEXCEPT + { + dependencyFlags = dependencyFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setDependencyFlags( DependencyFlags dependencyFlags_ ) && VULKAN_HPP_NOEXCEPT + { + dependencyFlags = dependencyFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setViewOffset( int32_t viewOffset_ ) & VULKAN_HPP_NOEXCEPT + { + viewOffset = viewOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setViewOffset( int32_t viewOffset_ ) && VULKAN_HPP_NOEXCEPT + { + viewOffset = viewOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubpassDependency2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDependency2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDependency2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubpassDependency2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcSubpass, dstSubpass, srcStageMask, dstStageMask, srcAccessMask, dstAccessMask, dependencyFlags, viewOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubpassDependency2 const & ) const = default; +#else + bool operator==( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubpass == rhs.srcSubpass ) && ( dstSubpass == rhs.dstSubpass ) && + ( srcStageMask == rhs.srcStageMask ) && ( dstStageMask == rhs.dstStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && + ( dstAccessMask == rhs.dstAccessMask ) && ( dependencyFlags == rhs.dependencyFlags ) && ( viewOffset == rhs.viewOffset ); +# endif + } + + bool operator!=( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubpassDependency2; + const void * pNext = {}; + uint32_t srcSubpass = {}; + uint32_t dstSubpass = {}; + PipelineStageFlags srcStageMask = {}; + PipelineStageFlags dstStageMask = {}; + AccessFlags srcAccessMask = {}; + AccessFlags dstAccessMask = {}; + DependencyFlags dependencyFlags = {}; + int32_t viewOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubpassDependency2; + }; +#endif + + template <> + struct CppType + { + using Type = SubpassDependency2; + }; + + using SubpassDependency2KHR = SubpassDependency2; + + // wrapper struct for struct VkRenderPassCreateInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateInfo2.html + struct RenderPassCreateInfo2 + { + using NativeType = VkRenderPassCreateInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreateInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2( RenderPassCreateFlags flags_ = {}, + uint32_t attachmentCount_ = {}, + const AttachmentDescription2 * pAttachments_ = {}, + uint32_t subpassCount_ = {}, + const SubpassDescription2 * pSubpasses_ = {}, + uint32_t dependencyCount_ = {}, + const SubpassDependency2 * pDependencies_ = {}, + uint32_t correlatedViewMaskCount_ = {}, + const uint32_t * pCorrelatedViewMasks_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , attachmentCount{ attachmentCount_ } + , pAttachments{ pAttachments_ } + , subpassCount{ subpassCount_ } + , pSubpasses{ pSubpasses_ } + , dependencyCount{ dependencyCount_ } + , pDependencies{ pDependencies_ } + , correlatedViewMaskCount{ correlatedViewMaskCount_ } + , pCorrelatedViewMasks{ pCorrelatedViewMasks_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2( RenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassCreateInfo2( VkRenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassCreateInfo2( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassCreateInfo2( RenderPassCreateFlags flags_, + ArrayProxyNoTemporaries const & attachments_, + ArrayProxyNoTemporaries const & subpasses_ = {}, + ArrayProxyNoTemporaries const & dependencies_ = {}, + ArrayProxyNoTemporaries const & correlatedViewMasks_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , attachmentCount( static_cast( attachments_.size() ) ) + , pAttachments( attachments_.data() ) + , subpassCount( static_cast( subpasses_.size() ) ) + , pSubpasses( subpasses_.data() ) + , dependencyCount( static_cast( dependencies_.size() ) ) + , pDependencies( dependencies_.data() ) + , correlatedViewMaskCount( static_cast( correlatedViewMasks_.size() ) ) + , pCorrelatedViewMasks( correlatedViewMasks_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderPassCreateInfo2 & operator=( RenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassCreateInfo2 & operator=( VkRenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setFlags( RenderPassCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setFlags( RenderPassCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + attachmentCount = attachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setPAttachments( const AttachmentDescription2 * pAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pAttachments = pAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setPAttachments( const AttachmentDescription2 * pAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pAttachments = pAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassCreateInfo2 & setAttachments( ArrayProxyNoTemporaries const & attachments_ ) VULKAN_HPP_NOEXCEPT + { + attachmentCount = static_cast( attachments_.size() ); + pAttachments = attachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setSubpassCount( uint32_t subpassCount_ ) & VULKAN_HPP_NOEXCEPT + { + subpassCount = subpassCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setSubpassCount( uint32_t subpassCount_ ) && VULKAN_HPP_NOEXCEPT + { + subpassCount = subpassCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setPSubpasses( const SubpassDescription2 * pSubpasses_ ) & VULKAN_HPP_NOEXCEPT + { + pSubpasses = pSubpasses_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setPSubpasses( const SubpassDescription2 * pSubpasses_ ) && VULKAN_HPP_NOEXCEPT + { + pSubpasses = pSubpasses_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassCreateInfo2 & setSubpasses( ArrayProxyNoTemporaries const & subpasses_ ) VULKAN_HPP_NOEXCEPT + { + subpassCount = static_cast( subpasses_.size() ); + pSubpasses = subpasses_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setDependencyCount( uint32_t dependencyCount_ ) & VULKAN_HPP_NOEXCEPT + { + dependencyCount = dependencyCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setDependencyCount( uint32_t dependencyCount_ ) && VULKAN_HPP_NOEXCEPT + { + dependencyCount = dependencyCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setPDependencies( const SubpassDependency2 * pDependencies_ ) & VULKAN_HPP_NOEXCEPT + { + pDependencies = pDependencies_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setPDependencies( const SubpassDependency2 * pDependencies_ ) && VULKAN_HPP_NOEXCEPT + { + pDependencies = pDependencies_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassCreateInfo2 & setDependencies( ArrayProxyNoTemporaries const & dependencies_ ) VULKAN_HPP_NOEXCEPT + { + dependencyCount = static_cast( dependencies_.size() ); + pDependencies = dependencies_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setCorrelatedViewMaskCount( uint32_t correlatedViewMaskCount_ ) & VULKAN_HPP_NOEXCEPT + { + correlatedViewMaskCount = correlatedViewMaskCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setCorrelatedViewMaskCount( uint32_t correlatedViewMaskCount_ ) && VULKAN_HPP_NOEXCEPT + { + correlatedViewMaskCount = correlatedViewMaskCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setPCorrelatedViewMasks( const uint32_t * pCorrelatedViewMasks_ ) & VULKAN_HPP_NOEXCEPT + { + pCorrelatedViewMasks = pCorrelatedViewMasks_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setPCorrelatedViewMasks( const uint32_t * pCorrelatedViewMasks_ ) && VULKAN_HPP_NOEXCEPT + { + pCorrelatedViewMasks = pCorrelatedViewMasks_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassCreateInfo2 & setCorrelatedViewMasks( ArrayProxyNoTemporaries const & correlatedViewMasks_ ) VULKAN_HPP_NOEXCEPT + { + correlatedViewMaskCount = static_cast( correlatedViewMasks_.size() ); + pCorrelatedViewMasks = correlatedViewMasks_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassCreateInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreateInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreateInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassCreateInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + attachmentCount, + pAttachments, + subpassCount, + pSubpasses, + dependencyCount, + pDependencies, + correlatedViewMaskCount, + pCorrelatedViewMasks ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassCreateInfo2 const & ) const = default; +#else + bool operator==( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( attachmentCount == rhs.attachmentCount ) && + ( pAttachments == rhs.pAttachments ) && ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) && + ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies ) && + ( correlatedViewMaskCount == rhs.correlatedViewMaskCount ) && ( pCorrelatedViewMasks == rhs.pCorrelatedViewMasks ); +# endif + } + + bool operator!=( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassCreateInfo2; + const void * pNext = {}; + RenderPassCreateFlags flags = {}; + uint32_t attachmentCount = {}; + const AttachmentDescription2 * pAttachments = {}; + uint32_t subpassCount = {}; + const SubpassDescription2 * pSubpasses = {}; + uint32_t dependencyCount = {}; + const SubpassDependency2 * pDependencies = {}; + uint32_t correlatedViewMaskCount = {}; + const uint32_t * pCorrelatedViewMasks = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassCreateInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassCreateInfo2; + }; + + using RenderPassCreateInfo2KHR = RenderPassCreateInfo2; + + // wrapper struct for struct VkRenderPassCreationControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreationControlEXT.html + struct RenderPassCreationControlEXT + { + using NativeType = VkRenderPassCreationControlEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreationControlEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassCreationControlEXT( Bool32 disallowMerging_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , disallowMerging{ disallowMerging_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassCreationControlEXT( RenderPassCreationControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassCreationControlEXT( VkRenderPassCreationControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassCreationControlEXT( *reinterpret_cast( &rhs ) ) + { + } + + RenderPassCreationControlEXT & operator=( RenderPassCreationControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassCreationControlEXT & operator=( VkRenderPassCreationControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassCreationControlEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreationControlEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreationControlEXT & setDisallowMerging( Bool32 disallowMerging_ ) & VULKAN_HPP_NOEXCEPT + { + disallowMerging = disallowMerging_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreationControlEXT && setDisallowMerging( Bool32 disallowMerging_ ) && VULKAN_HPP_NOEXCEPT + { + disallowMerging = disallowMerging_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassCreationControlEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreationControlEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreationControlEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassCreationControlEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, disallowMerging ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassCreationControlEXT const & ) const = default; +#else + bool operator==( RenderPassCreationControlEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( disallowMerging == rhs.disallowMerging ); +# endif + } + + bool operator!=( RenderPassCreationControlEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassCreationControlEXT; + const void * pNext = {}; + Bool32 disallowMerging = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassCreationControlEXT; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassCreationControlEXT; + }; + + // wrapper struct for struct VkRenderPassCreationFeedbackInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreationFeedbackInfoEXT.html + struct RenderPassCreationFeedbackInfoEXT + { + using NativeType = VkRenderPassCreationFeedbackInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassCreationFeedbackInfoEXT( uint32_t postMergeSubpassCount_ = {} ) VULKAN_HPP_NOEXCEPT + : postMergeSubpassCount{ postMergeSubpassCount_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassCreationFeedbackInfoEXT( RenderPassCreationFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassCreationFeedbackInfoEXT( VkRenderPassCreationFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassCreationFeedbackInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + RenderPassCreationFeedbackInfoEXT & operator=( RenderPassCreationFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassCreationFeedbackInfoEXT & operator=( VkRenderPassCreationFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkRenderPassCreationFeedbackInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreationFeedbackInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreationFeedbackInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassCreationFeedbackInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( postMergeSubpassCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassCreationFeedbackInfoEXT const & ) const = default; +#else + bool operator==( RenderPassCreationFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( postMergeSubpassCount == rhs.postMergeSubpassCount ); +# endif + } + + bool operator!=( RenderPassCreationFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t postMergeSubpassCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassCreationFeedbackInfoEXT; + }; +#endif + + // wrapper struct for struct VkRenderPassCreationFeedbackCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreationFeedbackCreateInfoEXT.html + struct RenderPassCreationFeedbackCreateInfoEXT + { + using NativeType = VkRenderPassCreationFeedbackCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreationFeedbackCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassCreationFeedbackCreateInfoEXT( RenderPassCreationFeedbackInfoEXT * pRenderPassFeedback_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pRenderPassFeedback{ pRenderPassFeedback_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassCreationFeedbackCreateInfoEXT( RenderPassCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassCreationFeedbackCreateInfoEXT( VkRenderPassCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassCreationFeedbackCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + RenderPassCreationFeedbackCreateInfoEXT & operator=( RenderPassCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassCreationFeedbackCreateInfoEXT & operator=( VkRenderPassCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassCreationFeedbackCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreationFeedbackCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreationFeedbackCreateInfoEXT & setPRenderPassFeedback( RenderPassCreationFeedbackInfoEXT * pRenderPassFeedback_ ) & + VULKAN_HPP_NOEXCEPT + { + pRenderPassFeedback = pRenderPassFeedback_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassCreationFeedbackCreateInfoEXT && setPRenderPassFeedback( RenderPassCreationFeedbackInfoEXT * pRenderPassFeedback_ ) && + VULKAN_HPP_NOEXCEPT + { + pRenderPassFeedback = pRenderPassFeedback_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassCreationFeedbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreationFeedbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassCreationFeedbackCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassCreationFeedbackCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pRenderPassFeedback ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassCreationFeedbackCreateInfoEXT const & ) const = default; +#else + bool operator==( RenderPassCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pRenderPassFeedback == rhs.pRenderPassFeedback ); +# endif + } + + bool operator!=( RenderPassCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassCreationFeedbackCreateInfoEXT; + const void * pNext = {}; + RenderPassCreationFeedbackInfoEXT * pRenderPassFeedback = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassCreationFeedbackCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassCreationFeedbackCreateInfoEXT; + }; + + // wrapper struct for struct VkRenderPassFragmentDensityMapCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassFragmentDensityMapCreateInfoEXT.html + struct RenderPassFragmentDensityMapCreateInfoEXT + { + using NativeType = VkRenderPassFragmentDensityMapCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( AttachmentReference fragmentDensityMapAttachment_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fragmentDensityMapAttachment{ fragmentDensityMapAttachment_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassFragmentDensityMapCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + RenderPassFragmentDensityMapCreateInfoEXT & operator=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassFragmentDensityMapCreateInfoEXT & operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapCreateInfoEXT & + setFragmentDensityMapAttachment( AttachmentReference const & fragmentDensityMapAttachment_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapAttachment = fragmentDensityMapAttachment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapCreateInfoEXT && + setFragmentDensityMapAttachment( AttachmentReference const & fragmentDensityMapAttachment_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentDensityMapAttachment = fragmentDensityMapAttachment_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassFragmentDensityMapCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassFragmentDensityMapCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassFragmentDensityMapCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassFragmentDensityMapCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityMapAttachment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassFragmentDensityMapCreateInfoEXT const & ) const = default; +#else + bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment ); +# endif + } + + bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; + const void * pNext = {}; + AttachmentReference fragmentDensityMapAttachment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassFragmentDensityMapCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassFragmentDensityMapCreateInfoEXT; + }; + + // wrapper struct for struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassFragmentDensityMapOffsetEndInfoEXT.html + struct RenderPassFragmentDensityMapOffsetEndInfoEXT + { + using NativeType = VkRenderPassFragmentDensityMapOffsetEndInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapOffsetEndInfoEXT( uint32_t fragmentDensityOffsetCount_ = {}, + const Offset2D * pFragmentDensityOffsets_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fragmentDensityOffsetCount{ fragmentDensityOffsetCount_ } + , pFragmentDensityOffsets{ pFragmentDensityOffsets_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapOffsetEndInfoEXT( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassFragmentDensityMapOffsetEndInfoEXT( VkRenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassFragmentDensityMapOffsetEndInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassFragmentDensityMapOffsetEndInfoEXT( ArrayProxyNoTemporaries const & fragmentDensityOffsets_, const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , fragmentDensityOffsetCount( static_cast( fragmentDensityOffsets_.size() ) ) + , pFragmentDensityOffsets( fragmentDensityOffsets_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderPassFragmentDensityMapOffsetEndInfoEXT & operator=( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassFragmentDensityMapOffsetEndInfoEXT & operator=( VkRenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT & setFragmentDensityOffsetCount( uint32_t fragmentDensityOffsetCount_ ) & + VULKAN_HPP_NOEXCEPT + { + fragmentDensityOffsetCount = fragmentDensityOffsetCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT && setFragmentDensityOffsetCount( uint32_t fragmentDensityOffsetCount_ ) && + VULKAN_HPP_NOEXCEPT + { + fragmentDensityOffsetCount = fragmentDensityOffsetCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT & setPFragmentDensityOffsets( const Offset2D * pFragmentDensityOffsets_ ) & + VULKAN_HPP_NOEXCEPT + { + pFragmentDensityOffsets = pFragmentDensityOffsets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT && setPFragmentDensityOffsets( const Offset2D * pFragmentDensityOffsets_ ) && + VULKAN_HPP_NOEXCEPT + { + pFragmentDensityOffsets = pFragmentDensityOffsets_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassFragmentDensityMapOffsetEndInfoEXT & + setFragmentDensityOffsets( ArrayProxyNoTemporaries const & fragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT + { + fragmentDensityOffsetCount = static_cast( fragmentDensityOffsets_.size() ); + pFragmentDensityOffsets = fragmentDensityOffsets_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassFragmentDensityMapOffsetEndInfoEXT const & ) const = default; +#else + bool operator==( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityOffsetCount == rhs.fragmentDensityOffsetCount ) && + ( pFragmentDensityOffsets == rhs.pFragmentDensityOffsets ); +# endif + } + + bool operator!=( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT; + const void * pNext = {}; + uint32_t fragmentDensityOffsetCount = {}; + const Offset2D * pFragmentDensityOffsets = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassFragmentDensityMapOffsetEndInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassFragmentDensityMapOffsetEndInfoEXT; + }; + + using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT; + + // wrapper struct for struct VkRenderPassInputAttachmentAspectCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html + struct RenderPassInputAttachmentAspectCreateInfo + { + using NativeType = VkRenderPassInputAttachmentAspectCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = {}, + const InputAttachmentAspectReference * pAspectReferences_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , aspectReferenceCount{ aspectReferenceCount_ } + , pAspectReferences{ pAspectReferences_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassInputAttachmentAspectCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassInputAttachmentAspectCreateInfo( ArrayProxyNoTemporaries const & aspectReferences_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), aspectReferenceCount( static_cast( aspectReferences_.size() ) ), pAspectReferences( aspectReferences_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderPassInputAttachmentAspectCreateInfo & operator=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassInputAttachmentAspectCreateInfo & operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo & setAspectReferenceCount( uint32_t aspectReferenceCount_ ) & VULKAN_HPP_NOEXCEPT + { + aspectReferenceCount = aspectReferenceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo && setAspectReferenceCount( uint32_t aspectReferenceCount_ ) && VULKAN_HPP_NOEXCEPT + { + aspectReferenceCount = aspectReferenceCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo & setPAspectReferences( const InputAttachmentAspectReference * pAspectReferences_ ) & + VULKAN_HPP_NOEXCEPT + { + pAspectReferences = pAspectReferences_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo && setPAspectReferences( const InputAttachmentAspectReference * pAspectReferences_ ) && + VULKAN_HPP_NOEXCEPT + { + pAspectReferences = pAspectReferences_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassInputAttachmentAspectCreateInfo & + setAspectReferences( ArrayProxyNoTemporaries const & aspectReferences_ ) VULKAN_HPP_NOEXCEPT + { + aspectReferenceCount = static_cast( aspectReferences_.size() ); + pAspectReferences = aspectReferences_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassInputAttachmentAspectCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassInputAttachmentAspectCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassInputAttachmentAspectCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassInputAttachmentAspectCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, aspectReferenceCount, pAspectReferences ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassInputAttachmentAspectCreateInfo const & ) const = default; +#else + bool operator==( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aspectReferenceCount == rhs.aspectReferenceCount ) && + ( pAspectReferences == rhs.pAspectReferences ); +# endif + } + + bool operator!=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; + const void * pNext = {}; + uint32_t aspectReferenceCount = {}; + const InputAttachmentAspectReference * pAspectReferences = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassInputAttachmentAspectCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassInputAttachmentAspectCreateInfo; + }; + + using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo; + + // wrapper struct for struct VkRenderPassMultiviewCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassMultiviewCreateInfo.html + struct RenderPassMultiviewCreateInfo + { + using NativeType = VkRenderPassMultiviewCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassMultiviewCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = {}, + const uint32_t * pViewMasks_ = {}, + uint32_t dependencyCount_ = {}, + const int32_t * pViewOffsets_ = {}, + uint32_t correlationMaskCount_ = {}, + const uint32_t * pCorrelationMasks_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , subpassCount{ subpassCount_ } + , pViewMasks{ pViewMasks_ } + , dependencyCount{ dependencyCount_ } + , pViewOffsets{ pViewOffsets_ } + , correlationMaskCount{ correlationMaskCount_ } + , pCorrelationMasks{ pCorrelationMasks_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassMultiviewCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassMultiviewCreateInfo( ArrayProxyNoTemporaries const & viewMasks_, + ArrayProxyNoTemporaries const & viewOffsets_ = {}, + ArrayProxyNoTemporaries const & correlationMasks_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , subpassCount( static_cast( viewMasks_.size() ) ) + , pViewMasks( viewMasks_.data() ) + , dependencyCount( static_cast( viewOffsets_.size() ) ) + , pViewOffsets( viewOffsets_.data() ) + , correlationMaskCount( static_cast( correlationMasks_.size() ) ) + , pCorrelationMasks( correlationMasks_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderPassMultiviewCreateInfo & operator=( RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassMultiviewCreateInfo & operator=( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setSubpassCount( uint32_t subpassCount_ ) & VULKAN_HPP_NOEXCEPT + { + subpassCount = subpassCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setSubpassCount( uint32_t subpassCount_ ) && VULKAN_HPP_NOEXCEPT + { + subpassCount = subpassCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setPViewMasks( const uint32_t * pViewMasks_ ) & VULKAN_HPP_NOEXCEPT + { + pViewMasks = pViewMasks_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setPViewMasks( const uint32_t * pViewMasks_ ) && VULKAN_HPP_NOEXCEPT + { + pViewMasks = pViewMasks_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassMultiviewCreateInfo & setViewMasks( ArrayProxyNoTemporaries const & viewMasks_ ) VULKAN_HPP_NOEXCEPT + { + subpassCount = static_cast( viewMasks_.size() ); + pViewMasks = viewMasks_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setDependencyCount( uint32_t dependencyCount_ ) & VULKAN_HPP_NOEXCEPT + { + dependencyCount = dependencyCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setDependencyCount( uint32_t dependencyCount_ ) && VULKAN_HPP_NOEXCEPT + { + dependencyCount = dependencyCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setPViewOffsets( const int32_t * pViewOffsets_ ) & VULKAN_HPP_NOEXCEPT + { + pViewOffsets = pViewOffsets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setPViewOffsets( const int32_t * pViewOffsets_ ) && VULKAN_HPP_NOEXCEPT + { + pViewOffsets = pViewOffsets_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassMultiviewCreateInfo & setViewOffsets( ArrayProxyNoTemporaries const & viewOffsets_ ) VULKAN_HPP_NOEXCEPT + { + dependencyCount = static_cast( viewOffsets_.size() ); + pViewOffsets = viewOffsets_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setCorrelationMaskCount( uint32_t correlationMaskCount_ ) & VULKAN_HPP_NOEXCEPT + { + correlationMaskCount = correlationMaskCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setCorrelationMaskCount( uint32_t correlationMaskCount_ ) && VULKAN_HPP_NOEXCEPT + { + correlationMaskCount = correlationMaskCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setPCorrelationMasks( const uint32_t * pCorrelationMasks_ ) & VULKAN_HPP_NOEXCEPT + { + pCorrelationMasks = pCorrelationMasks_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setPCorrelationMasks( const uint32_t * pCorrelationMasks_ ) && VULKAN_HPP_NOEXCEPT + { + pCorrelationMasks = pCorrelationMasks_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassMultiviewCreateInfo & setCorrelationMasks( ArrayProxyNoTemporaries const & correlationMasks_ ) VULKAN_HPP_NOEXCEPT + { + correlationMaskCount = static_cast( correlationMasks_.size() ); + pCorrelationMasks = correlationMasks_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassMultiviewCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassMultiviewCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassMultiviewCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassMultiviewCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subpassCount, pViewMasks, dependencyCount, pViewOffsets, correlationMaskCount, pCorrelationMasks ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassMultiviewCreateInfo const & ) const = default; +#else + bool operator==( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassCount == rhs.subpassCount ) && ( pViewMasks == rhs.pViewMasks ) && + ( dependencyCount == rhs.dependencyCount ) && ( pViewOffsets == rhs.pViewOffsets ) && ( correlationMaskCount == rhs.correlationMaskCount ) && + ( pCorrelationMasks == rhs.pCorrelationMasks ); +# endif + } + + bool operator!=( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassMultiviewCreateInfo; + const void * pNext = {}; + uint32_t subpassCount = {}; + const uint32_t * pViewMasks = {}; + uint32_t dependencyCount = {}; + const int32_t * pViewOffsets = {}; + uint32_t correlationMaskCount = {}; + const uint32_t * pCorrelationMasks = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassMultiviewCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassMultiviewCreateInfo; + }; + + using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo; + + // wrapper struct for struct VkRenderPassPerformanceCountersByRegionBeginInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassPerformanceCountersByRegionBeginInfoARM.html + struct RenderPassPerformanceCountersByRegionBeginInfoARM + { + using NativeType = VkRenderPassPerformanceCountersByRegionBeginInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassPerformanceCountersByRegionBeginInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassPerformanceCountersByRegionBeginInfoARM( uint32_t counterAddressCount_ = {}, + const DeviceAddress * pCounterAddresses_ = {}, + Bool32 serializeRegions_ = {}, + uint32_t counterIndexCount_ = {}, + uint32_t * pCounterIndices_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , counterAddressCount{ counterAddressCount_ } + , pCounterAddresses{ pCounterAddresses_ } + , serializeRegions{ serializeRegions_ } + , counterIndexCount{ counterIndexCount_ } + , pCounterIndices{ pCounterIndices_ } + { + } + + VULKAN_HPP_CONSTEXPR + RenderPassPerformanceCountersByRegionBeginInfoARM( RenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassPerformanceCountersByRegionBeginInfoARM( VkRenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassPerformanceCountersByRegionBeginInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + RenderPassPerformanceCountersByRegionBeginInfoARM & + operator=( RenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassPerformanceCountersByRegionBeginInfoARM & operator=( VkRenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setCounterAddressCount( uint32_t counterAddressCount_ ) & VULKAN_HPP_NOEXCEPT + { + counterAddressCount = counterAddressCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setCounterAddressCount( uint32_t counterAddressCount_ ) && VULKAN_HPP_NOEXCEPT + { + counterAddressCount = counterAddressCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setPCounterAddresses( const DeviceAddress * pCounterAddresses_ ) & + VULKAN_HPP_NOEXCEPT + { + pCounterAddresses = pCounterAddresses_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setPCounterAddresses( const DeviceAddress * pCounterAddresses_ ) && + VULKAN_HPP_NOEXCEPT + { + pCounterAddresses = pCounterAddresses_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setSerializeRegions( Bool32 serializeRegions_ ) & VULKAN_HPP_NOEXCEPT + { + serializeRegions = serializeRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setSerializeRegions( Bool32 serializeRegions_ ) && VULKAN_HPP_NOEXCEPT + { + serializeRegions = serializeRegions_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setCounterIndexCount( uint32_t counterIndexCount_ ) & VULKAN_HPP_NOEXCEPT + { + counterIndexCount = counterIndexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setCounterIndexCount( uint32_t counterIndexCount_ ) && VULKAN_HPP_NOEXCEPT + { + counterIndexCount = counterIndexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setPCounterIndices( uint32_t * pCounterIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pCounterIndices = pCounterIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setPCounterIndices( uint32_t * pCounterIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pCounterIndices = pCounterIndices_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassPerformanceCountersByRegionBeginInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassPerformanceCountersByRegionBeginInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassPerformanceCountersByRegionBeginInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassPerformanceCountersByRegionBeginInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, counterAddressCount, pCounterAddresses, serializeRegions, counterIndexCount, pCounterIndices ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassPerformanceCountersByRegionBeginInfoARM const & ) const = default; +#else + bool operator==( RenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterAddressCount == rhs.counterAddressCount ) && + ( pCounterAddresses == rhs.pCounterAddresses ) && ( serializeRegions == rhs.serializeRegions ) && ( counterIndexCount == rhs.counterIndexCount ) && + ( pCounterIndices == rhs.pCounterIndices ); +# endif + } + + bool operator!=( RenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassPerformanceCountersByRegionBeginInfoARM; + void * pNext = {}; + uint32_t counterAddressCount = {}; + const DeviceAddress * pCounterAddresses = {}; + Bool32 serializeRegions = {}; + uint32_t counterIndexCount = {}; + uint32_t * pCounterIndices = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassPerformanceCountersByRegionBeginInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassPerformanceCountersByRegionBeginInfoARM; + }; + + // wrapper struct for struct VkSubpassSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassSampleLocationsEXT.html + struct SubpassSampleLocationsEXT + { + using NativeType = VkSubpassSampleLocationsEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( uint32_t subpassIndex_ = {}, SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT + : subpassIndex{ subpassIndex_ } + , sampleLocationsInfo{ sampleLocationsInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( SubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SubpassSampleLocationsEXT( *reinterpret_cast( &rhs ) ) + { + } + + SubpassSampleLocationsEXT & operator=( SubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubpassSampleLocationsEXT & operator=( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubpassSampleLocationsEXT & setSubpassIndex( uint32_t subpassIndex_ ) & VULKAN_HPP_NOEXCEPT + { + subpassIndex = subpassIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassSampleLocationsEXT && setSubpassIndex( uint32_t subpassIndex_ ) && VULKAN_HPP_NOEXCEPT + { + subpassIndex = subpassIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassSampleLocationsEXT & setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) & VULKAN_HPP_NOEXCEPT + { + sampleLocationsInfo = sampleLocationsInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassSampleLocationsEXT && setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) && VULKAN_HPP_NOEXCEPT + { + sampleLocationsInfo = sampleLocationsInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubpassSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassSampleLocationsEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubpassSampleLocationsEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( subpassIndex, sampleLocationsInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubpassSampleLocationsEXT const & ) const = default; +#else + bool operator==( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( subpassIndex == rhs.subpassIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); +# endif + } + + bool operator!=( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t subpassIndex = {}; + SampleLocationsInfoEXT sampleLocationsInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubpassSampleLocationsEXT; + }; +#endif + + // wrapper struct for struct VkRenderPassSampleLocationsBeginInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassSampleLocationsBeginInfoEXT.html + struct RenderPassSampleLocationsBeginInfoEXT + { + using NativeType = VkRenderPassSampleLocationsBeginInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = {}, + const AttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations_ = {}, + uint32_t postSubpassSampleLocationsCount_ = {}, + const SubpassSampleLocationsEXT * pPostSubpassSampleLocations_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , attachmentInitialSampleLocationsCount{ attachmentInitialSampleLocationsCount_ } + , pAttachmentInitialSampleLocations{ pAttachmentInitialSampleLocations_ } + , postSubpassSampleLocationsCount{ postSubpassSampleLocationsCount_ } + , pPostSubpassSampleLocations{ pPostSubpassSampleLocations_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassSampleLocationsBeginInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassSampleLocationsBeginInfoEXT( ArrayProxyNoTemporaries const & attachmentInitialSampleLocations_, + ArrayProxyNoTemporaries const & postSubpassSampleLocations_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , attachmentInitialSampleLocationsCount( static_cast( attachmentInitialSampleLocations_.size() ) ) + , pAttachmentInitialSampleLocations( attachmentInitialSampleLocations_.data() ) + , postSubpassSampleLocationsCount( static_cast( postSubpassSampleLocations_.size() ) ) + , pPostSubpassSampleLocations( postSubpassSampleLocations_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderPassSampleLocationsBeginInfoEXT & operator=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassSampleLocationsBeginInfoEXT & operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT & + setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ ) & + VULKAN_HPP_NOEXCEPT + { + attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT && + setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ ) && + VULKAN_HPP_NOEXCEPT + { + attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT & + setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations_ ) & + VULKAN_HPP_NOEXCEPT + { + pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT && + setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations_ ) && + VULKAN_HPP_NOEXCEPT + { + pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassSampleLocationsBeginInfoEXT & setAttachmentInitialSampleLocations( + ArrayProxyNoTemporaries const & attachmentInitialSampleLocations_ ) VULKAN_HPP_NOEXCEPT + { + attachmentInitialSampleLocationsCount = static_cast( attachmentInitialSampleLocations_.size() ); + pAttachmentInitialSampleLocations = attachmentInitialSampleLocations_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT & setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ ) & + VULKAN_HPP_NOEXCEPT + { + postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT && setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ ) && + VULKAN_HPP_NOEXCEPT + { + postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT & + setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT * pPostSubpassSampleLocations_ ) & + VULKAN_HPP_NOEXCEPT + { + pPostSubpassSampleLocations = pPostSubpassSampleLocations_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT && + setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT * pPostSubpassSampleLocations_ ) && + VULKAN_HPP_NOEXCEPT + { + pPostSubpassSampleLocations = pPostSubpassSampleLocations_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassSampleLocationsBeginInfoEXT & + setPostSubpassSampleLocations( ArrayProxyNoTemporaries const & postSubpassSampleLocations_ ) VULKAN_HPP_NOEXCEPT + { + postSubpassSampleLocationsCount = static_cast( postSubpassSampleLocations_.size() ); + pPostSubpassSampleLocations = postSubpassSampleLocations_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassSampleLocationsBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassSampleLocationsBeginInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassSampleLocationsBeginInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassSampleLocationsBeginInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, attachmentInitialSampleLocationsCount, pAttachmentInitialSampleLocations, postSubpassSampleLocationsCount, pPostSubpassSampleLocations ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassSampleLocationsBeginInfoEXT const & ) const = default; +#else + bool operator==( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) && + ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations ) && + ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount ) && ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations ); +# endif + } + + bool operator!=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; + const void * pNext = {}; + uint32_t attachmentInitialSampleLocationsCount = {}; + const AttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations = {}; + uint32_t postSubpassSampleLocationsCount = {}; + const SubpassSampleLocationsEXT * pPostSubpassSampleLocations = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassSampleLocationsBeginInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassSampleLocationsBeginInfoEXT; + }; + + // wrapper struct for struct VkRenderPassStripeInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassStripeInfoARM.html + struct RenderPassStripeInfoARM + { + using NativeType = VkRenderPassStripeInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassStripeInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassStripeInfoARM( Rect2D stripeArea_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stripeArea{ stripeArea_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassStripeInfoARM( RenderPassStripeInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassStripeInfoARM( VkRenderPassStripeInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassStripeInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + RenderPassStripeInfoARM & operator=( RenderPassStripeInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassStripeInfoARM & operator=( VkRenderPassStripeInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeInfoARM & setStripeArea( Rect2D const & stripeArea_ ) & VULKAN_HPP_NOEXCEPT + { + stripeArea = stripeArea_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeInfoARM && setStripeArea( Rect2D const & stripeArea_ ) && VULKAN_HPP_NOEXCEPT + { + stripeArea = stripeArea_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassStripeInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassStripeInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassStripeInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassStripeInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stripeArea ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassStripeInfoARM const & ) const = default; +#else + bool operator==( RenderPassStripeInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stripeArea == rhs.stripeArea ); +# endif + } + + bool operator!=( RenderPassStripeInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassStripeInfoARM; + const void * pNext = {}; + Rect2D stripeArea = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassStripeInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassStripeInfoARM; + }; + + // wrapper struct for struct VkRenderPassStripeBeginInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassStripeBeginInfoARM.html + struct RenderPassStripeBeginInfoARM + { + using NativeType = VkRenderPassStripeBeginInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassStripeBeginInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassStripeBeginInfoARM( uint32_t stripeInfoCount_ = {}, + const RenderPassStripeInfoARM * pStripeInfos_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stripeInfoCount{ stripeInfoCount_ } + , pStripeInfos{ pStripeInfos_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassStripeBeginInfoARM( RenderPassStripeBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassStripeBeginInfoARM( VkRenderPassStripeBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassStripeBeginInfoARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassStripeBeginInfoARM( ArrayProxyNoTemporaries const & stripeInfos_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), stripeInfoCount( static_cast( stripeInfos_.size() ) ), pStripeInfos( stripeInfos_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderPassStripeBeginInfoARM & operator=( RenderPassStripeBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassStripeBeginInfoARM & operator=( VkRenderPassStripeBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM & setStripeInfoCount( uint32_t stripeInfoCount_ ) & VULKAN_HPP_NOEXCEPT + { + stripeInfoCount = stripeInfoCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM && setStripeInfoCount( uint32_t stripeInfoCount_ ) && VULKAN_HPP_NOEXCEPT + { + stripeInfoCount = stripeInfoCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM & setPStripeInfos( const RenderPassStripeInfoARM * pStripeInfos_ ) & VULKAN_HPP_NOEXCEPT + { + pStripeInfos = pStripeInfos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM && setPStripeInfos( const RenderPassStripeInfoARM * pStripeInfos_ ) && VULKAN_HPP_NOEXCEPT + { + pStripeInfos = pStripeInfos_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassStripeBeginInfoARM & setStripeInfos( ArrayProxyNoTemporaries const & stripeInfos_ ) VULKAN_HPP_NOEXCEPT + { + stripeInfoCount = static_cast( stripeInfos_.size() ); + pStripeInfos = stripeInfos_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassStripeBeginInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassStripeBeginInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassStripeBeginInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassStripeBeginInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stripeInfoCount, pStripeInfos ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassStripeBeginInfoARM const & ) const = default; +#else + bool operator==( RenderPassStripeBeginInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stripeInfoCount == rhs.stripeInfoCount ) && ( pStripeInfos == rhs.pStripeInfos ); +# endif + } + + bool operator!=( RenderPassStripeBeginInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassStripeBeginInfoARM; + const void * pNext = {}; + uint32_t stripeInfoCount = {}; + const RenderPassStripeInfoARM * pStripeInfos = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassStripeBeginInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassStripeBeginInfoARM; + }; + + // wrapper struct for struct VkSemaphoreSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreSubmitInfo.html + struct SemaphoreSubmitInfo + { + using NativeType = VkSemaphoreSubmitInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreSubmitInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SemaphoreSubmitInfo( Semaphore semaphore_ = {}, + uint64_t value_ = {}, + PipelineStageFlags2 stageMask_ = {}, + uint32_t deviceIndex_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , semaphore{ semaphore_ } + , value{ value_ } + , stageMask{ stageMask_ } + , deviceIndex{ deviceIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR SemaphoreSubmitInfo( SemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SemaphoreSubmitInfo( VkSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SemaphoreSubmitInfo( *reinterpret_cast( &rhs ) ) + { + } + + SemaphoreSubmitInfo & operator=( SemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SemaphoreSubmitInfo & operator=( VkSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo & setValue( uint64_t value_ ) & VULKAN_HPP_NOEXCEPT + { + value = value_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo && setValue( uint64_t value_ ) && VULKAN_HPP_NOEXCEPT + { + value = value_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo & setStageMask( PipelineStageFlags2 stageMask_ ) & VULKAN_HPP_NOEXCEPT + { + stageMask = stageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo && setStageMask( PipelineStageFlags2 stageMask_ ) && VULKAN_HPP_NOEXCEPT + { + stageMask = stageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo & setDeviceIndex( uint32_t deviceIndex_ ) & VULKAN_HPP_NOEXCEPT + { + deviceIndex = deviceIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo && setDeviceIndex( uint32_t deviceIndex_ ) && VULKAN_HPP_NOEXCEPT + { + deviceIndex = deviceIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSemaphoreSubmitInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreSubmitInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreSubmitInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSemaphoreSubmitInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, value, stageMask, deviceIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SemaphoreSubmitInfo const & ) const = default; +#else + bool operator==( SemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( value == rhs.value ) && ( stageMask == rhs.stageMask ) && + ( deviceIndex == rhs.deviceIndex ); +# endif + } + + bool operator!=( SemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSemaphoreSubmitInfo; + const void * pNext = {}; + Semaphore semaphore = {}; + uint64_t value = {}; + PipelineStageFlags2 stageMask = {}; + uint32_t deviceIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SemaphoreSubmitInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SemaphoreSubmitInfo; + }; + + using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo; + + // wrapper struct for struct VkRenderPassStripeSubmitInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassStripeSubmitInfoARM.html + struct RenderPassStripeSubmitInfoARM + { + using NativeType = VkRenderPassStripeSubmitInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassStripeSubmitInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassStripeSubmitInfoARM( uint32_t stripeSemaphoreInfoCount_ = {}, + const SemaphoreSubmitInfo * pStripeSemaphoreInfos_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stripeSemaphoreInfoCount{ stripeSemaphoreInfoCount_ } + , pStripeSemaphoreInfos{ pStripeSemaphoreInfos_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassStripeSubmitInfoARM( RenderPassStripeSubmitInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassStripeSubmitInfoARM( VkRenderPassStripeSubmitInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassStripeSubmitInfoARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassStripeSubmitInfoARM( ArrayProxyNoTemporaries const & stripeSemaphoreInfos_, const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , stripeSemaphoreInfoCount( static_cast( stripeSemaphoreInfos_.size() ) ) + , pStripeSemaphoreInfos( stripeSemaphoreInfos_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderPassStripeSubmitInfoARM & operator=( RenderPassStripeSubmitInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassStripeSubmitInfoARM & operator=( VkRenderPassStripeSubmitInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM & setStripeSemaphoreInfoCount( uint32_t stripeSemaphoreInfoCount_ ) & VULKAN_HPP_NOEXCEPT + { + stripeSemaphoreInfoCount = stripeSemaphoreInfoCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM && setStripeSemaphoreInfoCount( uint32_t stripeSemaphoreInfoCount_ ) && VULKAN_HPP_NOEXCEPT + { + stripeSemaphoreInfoCount = stripeSemaphoreInfoCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM & setPStripeSemaphoreInfos( const SemaphoreSubmitInfo * pStripeSemaphoreInfos_ ) & VULKAN_HPP_NOEXCEPT + { + pStripeSemaphoreInfos = pStripeSemaphoreInfos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM && setPStripeSemaphoreInfos( const SemaphoreSubmitInfo * pStripeSemaphoreInfos_ ) && + VULKAN_HPP_NOEXCEPT + { + pStripeSemaphoreInfos = pStripeSemaphoreInfos_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderPassStripeSubmitInfoARM & + setStripeSemaphoreInfos( ArrayProxyNoTemporaries const & stripeSemaphoreInfos_ ) VULKAN_HPP_NOEXCEPT + { + stripeSemaphoreInfoCount = static_cast( stripeSemaphoreInfos_.size() ); + pStripeSemaphoreInfos = stripeSemaphoreInfos_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassStripeSubmitInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassStripeSubmitInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassStripeSubmitInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassStripeSubmitInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stripeSemaphoreInfoCount, pStripeSemaphoreInfos ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassStripeSubmitInfoARM const & ) const = default; +#else + bool operator==( RenderPassStripeSubmitInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stripeSemaphoreInfoCount == rhs.stripeSemaphoreInfoCount ) && + ( pStripeSemaphoreInfos == rhs.pStripeSemaphoreInfos ); +# endif + } + + bool operator!=( RenderPassStripeSubmitInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassStripeSubmitInfoARM; + const void * pNext = {}; + uint32_t stripeSemaphoreInfoCount = {}; + const SemaphoreSubmitInfo * pStripeSemaphoreInfos = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassStripeSubmitInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassStripeSubmitInfoARM; + }; + + // wrapper struct for struct VkRenderPassSubpassFeedbackInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassSubpassFeedbackInfoEXT.html + struct RenderPassSubpassFeedbackInfoEXT + { + using NativeType = VkRenderPassSubpassFeedbackInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackInfoEXT( SubpassMergeStatusEXT subpassMergeStatus_ = SubpassMergeStatusEXT::eMerged, + std::array const & description_ = {}, + uint32_t postMergeIndex_ = {} ) VULKAN_HPP_NOEXCEPT + : subpassMergeStatus{ subpassMergeStatus_ } + , description{ description_ } + , postMergeIndex{ postMergeIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackInfoEXT( RenderPassSubpassFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassSubpassFeedbackInfoEXT( VkRenderPassSubpassFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassSubpassFeedbackInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + RenderPassSubpassFeedbackInfoEXT & operator=( RenderPassSubpassFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassSubpassFeedbackInfoEXT & operator=( VkRenderPassSubpassFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkRenderPassSubpassFeedbackInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassSubpassFeedbackInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassSubpassFeedbackInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassSubpassFeedbackInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( subpassMergeStatus, description, postMergeIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( RenderPassSubpassFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = subpassMergeStatus <=> rhs.subpassMergeStatus; cmp != 0 ) + return cmp; + if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = postMergeIndex <=> rhs.postMergeIndex; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( RenderPassSubpassFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( subpassMergeStatus == rhs.subpassMergeStatus ) && ( strcmp( description, rhs.description ) == 0 ) && ( postMergeIndex == rhs.postMergeIndex ); + } + + bool operator!=( RenderPassSubpassFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + SubpassMergeStatusEXT subpassMergeStatus = SubpassMergeStatusEXT::eMerged; + ArrayWrapper1D description = {}; + uint32_t postMergeIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassSubpassFeedbackInfoEXT; + }; +#endif + + // wrapper struct for struct VkRenderPassSubpassFeedbackCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassSubpassFeedbackCreateInfoEXT.html + struct RenderPassSubpassFeedbackCreateInfoEXT + { + using NativeType = VkRenderPassSubpassFeedbackCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassSubpassFeedbackCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT( RenderPassSubpassFeedbackInfoEXT * pSubpassFeedback_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pSubpassFeedback{ pSubpassFeedback_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT( RenderPassSubpassFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassSubpassFeedbackCreateInfoEXT( VkRenderPassSubpassFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassSubpassFeedbackCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + RenderPassSubpassFeedbackCreateInfoEXT & operator=( RenderPassSubpassFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassSubpassFeedbackCreateInfoEXT & operator=( VkRenderPassSubpassFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT & setPSubpassFeedback( RenderPassSubpassFeedbackInfoEXT * pSubpassFeedback_ ) & + VULKAN_HPP_NOEXCEPT + { + pSubpassFeedback = pSubpassFeedback_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT && setPSubpassFeedback( RenderPassSubpassFeedbackInfoEXT * pSubpassFeedback_ ) && + VULKAN_HPP_NOEXCEPT + { + pSubpassFeedback = pSubpassFeedback_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassSubpassFeedbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassSubpassFeedbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassSubpassFeedbackCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassSubpassFeedbackCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pSubpassFeedback ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassSubpassFeedbackCreateInfoEXT const & ) const = default; +#else + bool operator==( RenderPassSubpassFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSubpassFeedback == rhs.pSubpassFeedback ); +# endif + } + + bool operator!=( RenderPassSubpassFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassSubpassFeedbackCreateInfoEXT; + const void * pNext = {}; + RenderPassSubpassFeedbackInfoEXT * pSubpassFeedback = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassSubpassFeedbackCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassSubpassFeedbackCreateInfoEXT; + }; + + // wrapper struct for struct VkRenderPassTileShadingCreateInfoQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassTileShadingCreateInfoQCOM.html + struct RenderPassTileShadingCreateInfoQCOM + { + using NativeType = VkRenderPassTileShadingCreateInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassTileShadingCreateInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassTileShadingCreateInfoQCOM( TileShadingRenderPassFlagsQCOM flags_ = {}, + Extent2D tileApronSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , tileApronSize{ tileApronSize_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassTileShadingCreateInfoQCOM( RenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassTileShadingCreateInfoQCOM( VkRenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassTileShadingCreateInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + RenderPassTileShadingCreateInfoQCOM & operator=( RenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassTileShadingCreateInfoQCOM & operator=( VkRenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM & setFlags( TileShadingRenderPassFlagsQCOM flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM && setFlags( TileShadingRenderPassFlagsQCOM flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM & setTileApronSize( Extent2D const & tileApronSize_ ) & VULKAN_HPP_NOEXCEPT + { + tileApronSize = tileApronSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM && setTileApronSize( Extent2D const & tileApronSize_ ) && VULKAN_HPP_NOEXCEPT + { + tileApronSize = tileApronSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassTileShadingCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassTileShadingCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassTileShadingCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassTileShadingCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, tileApronSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassTileShadingCreateInfoQCOM const & ) const = default; +#else + bool operator==( RenderPassTileShadingCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( tileApronSize == rhs.tileApronSize ); +# endif + } + + bool operator!=( RenderPassTileShadingCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassTileShadingCreateInfoQCOM; + const void * pNext = {}; + TileShadingRenderPassFlagsQCOM flags = {}; + Extent2D tileApronSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassTileShadingCreateInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassTileShadingCreateInfoQCOM; + }; + + // wrapper struct for struct VkRenderPassTransformBeginInfoQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassTransformBeginInfoQCOM.html + struct RenderPassTransformBeginInfoQCOM + { + using NativeType = VkRenderPassTransformBeginInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassTransformBeginInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassTransformBeginInfoQCOM( SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , transform{ transform_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassTransformBeginInfoQCOM( RenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassTransformBeginInfoQCOM( VkRenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassTransformBeginInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + RenderPassTransformBeginInfoQCOM & operator=( RenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassTransformBeginInfoQCOM & operator=( VkRenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassTransformBeginInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassTransformBeginInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassTransformBeginInfoQCOM & setTransform( SurfaceTransformFlagBitsKHR transform_ ) & VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassTransformBeginInfoQCOM && setTransform( SurfaceTransformFlagBitsKHR transform_ ) && VULKAN_HPP_NOEXCEPT + { + transform = transform_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassTransformBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassTransformBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassTransformBeginInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassTransformBeginInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, transform ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassTransformBeginInfoQCOM const & ) const = default; +#else + bool operator==( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ); +# endif + } + + bool operator!=( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderPassTransformBeginInfoQCOM; + const void * pNext = {}; + SurfaceTransformFlagBitsKHR transform = SurfaceTransformFlagBitsKHR::eIdentity; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderPassTransformBeginInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = RenderPassTransformBeginInfoQCOM; + }; + + // wrapper struct for struct VkRenderingAreaInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAreaInfo.html + struct RenderingAreaInfo + { + using NativeType = VkRenderingAreaInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingAreaInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderingAreaInfo( uint32_t viewMask_ = {}, + uint32_t colorAttachmentCount_ = {}, + const Format * pColorAttachmentFormats_ = {}, + Format depthAttachmentFormat_ = Format::eUndefined, + Format stencilAttachmentFormat_ = Format::eUndefined, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , viewMask{ viewMask_ } + , colorAttachmentCount{ colorAttachmentCount_ } + , pColorAttachmentFormats{ pColorAttachmentFormats_ } + , depthAttachmentFormat{ depthAttachmentFormat_ } + , stencilAttachmentFormat{ stencilAttachmentFormat_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderingAreaInfo( RenderingAreaInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderingAreaInfo( VkRenderingAreaInfo const & rhs ) VULKAN_HPP_NOEXCEPT : RenderingAreaInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderingAreaInfo( uint32_t viewMask_, + ArrayProxyNoTemporaries const & colorAttachmentFormats_, + Format depthAttachmentFormat_ = Format::eUndefined, + Format stencilAttachmentFormat_ = Format::eUndefined, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , viewMask( viewMask_ ) + , colorAttachmentCount( static_cast( colorAttachmentFormats_.size() ) ) + , pColorAttachmentFormats( colorAttachmentFormats_.data() ) + , depthAttachmentFormat( depthAttachmentFormat_ ) + , stencilAttachmentFormat( stencilAttachmentFormat_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderingAreaInfo & operator=( RenderingAreaInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderingAreaInfo & operator=( VkRenderingAreaInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setViewMask( uint32_t viewMask_ ) & VULKAN_HPP_NOEXCEPT + { + viewMask = viewMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setViewMask( uint32_t viewMask_ ) && VULKAN_HPP_NOEXCEPT + { + viewMask = viewMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) & VULKAN_HPP_NOEXCEPT + { + pColorAttachmentFormats = pColorAttachmentFormats_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) && VULKAN_HPP_NOEXCEPT + { + pColorAttachmentFormats = pColorAttachmentFormats_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderingAreaInfo & setColorAttachmentFormats( ArrayProxyNoTemporaries const & colorAttachmentFormats_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( colorAttachmentFormats_.size() ); + pColorAttachmentFormats = colorAttachmentFormats_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setDepthAttachmentFormat( Format depthAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT + { + depthAttachmentFormat = depthAttachmentFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setDepthAttachmentFormat( Format depthAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT + { + depthAttachmentFormat = depthAttachmentFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT + { + stencilAttachmentFormat = stencilAttachmentFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT + { + stencilAttachmentFormat = stencilAttachmentFormat_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderingAreaInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingAreaInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingAreaInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderingAreaInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, viewMask, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderingAreaInfo const & ) const = default; +#else + bool operator==( RenderingAreaInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && + ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && + ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ); +# endif + } + + bool operator!=( RenderingAreaInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderingAreaInfo; + const void * pNext = {}; + uint32_t viewMask = {}; + uint32_t colorAttachmentCount = {}; + const Format * pColorAttachmentFormats = {}; + Format depthAttachmentFormat = Format::eUndefined; + Format stencilAttachmentFormat = Format::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderingAreaInfo; + }; +#endif + + template <> + struct CppType + { + using Type = RenderingAreaInfo; + }; + + using RenderingAreaInfoKHR = RenderingAreaInfo; + + // wrapper struct for struct VkRenderingAttachmentFlagsInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentFlagsInfoKHR.html + struct RenderingAttachmentFlagsInfoKHR + { + using NativeType = VkRenderingAttachmentFlagsInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingAttachmentFlagsInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderingAttachmentFlagsInfoKHR( RenderingAttachmentFlagsKHR flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderingAttachmentFlagsInfoKHR( RenderingAttachmentFlagsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderingAttachmentFlagsInfoKHR( VkRenderingAttachmentFlagsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderingAttachmentFlagsInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + RenderingAttachmentFlagsInfoKHR & operator=( RenderingAttachmentFlagsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderingAttachmentFlagsInfoKHR & operator=( VkRenderingAttachmentFlagsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentFlagsInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentFlagsInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentFlagsInfoKHR & setFlags( RenderingAttachmentFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentFlagsInfoKHR && setFlags( RenderingAttachmentFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderingAttachmentFlagsInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingAttachmentFlagsInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingAttachmentFlagsInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderingAttachmentFlagsInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderingAttachmentFlagsInfoKHR const & ) const = default; +#else + bool operator==( RenderingAttachmentFlagsInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( RenderingAttachmentFlagsInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderingAttachmentFlagsInfoKHR; + const void * pNext = {}; + RenderingAttachmentFlagsKHR flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderingAttachmentFlagsInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = RenderingAttachmentFlagsInfoKHR; + }; + + // wrapper struct for struct VkRenderingAttachmentInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentInfo.html + struct RenderingAttachmentInfo + { + using NativeType = VkRenderingAttachmentInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingAttachmentInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo( ImageView imageView_ = {}, + ImageLayout imageLayout_ = ImageLayout::eUndefined, + ResolveModeFlagBits resolveMode_ = ResolveModeFlagBits::eNone, + ImageView resolveImageView_ = {}, + ImageLayout resolveImageLayout_ = ImageLayout::eUndefined, + AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, + AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, + ClearValue clearValue_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageView{ imageView_ } + , imageLayout{ imageLayout_ } + , resolveMode{ resolveMode_ } + , resolveImageView{ resolveImageView_ } + , resolveImageLayout{ resolveImageLayout_ } + , loadOp{ loadOp_ } + , storeOp{ storeOp_ } + , clearValue{ clearValue_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo( RenderingAttachmentInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderingAttachmentInfo( VkRenderingAttachmentInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderingAttachmentInfo( *reinterpret_cast( &rhs ) ) + { + } + + RenderingAttachmentInfo & operator=( RenderingAttachmentInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderingAttachmentInfo & operator=( VkRenderingAttachmentInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setImageLayout( ImageLayout imageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + imageLayout = imageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setImageLayout( ImageLayout imageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + imageLayout = imageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setResolveMode( ResolveModeFlagBits resolveMode_ ) & VULKAN_HPP_NOEXCEPT + { + resolveMode = resolveMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setResolveMode( ResolveModeFlagBits resolveMode_ ) && VULKAN_HPP_NOEXCEPT + { + resolveMode = resolveMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setResolveImageView( ImageView resolveImageView_ ) & VULKAN_HPP_NOEXCEPT + { + resolveImageView = resolveImageView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setResolveImageView( ImageView resolveImageView_ ) && VULKAN_HPP_NOEXCEPT + { + resolveImageView = resolveImageView_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setResolveImageLayout( ImageLayout resolveImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + resolveImageLayout = resolveImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setResolveImageLayout( ImageLayout resolveImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + resolveImageLayout = resolveImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setLoadOp( AttachmentLoadOp loadOp_ ) & VULKAN_HPP_NOEXCEPT + { + loadOp = loadOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setLoadOp( AttachmentLoadOp loadOp_ ) && VULKAN_HPP_NOEXCEPT + { + loadOp = loadOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setStoreOp( AttachmentStoreOp storeOp_ ) & VULKAN_HPP_NOEXCEPT + { + storeOp = storeOp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setStoreOp( AttachmentStoreOp storeOp_ ) && VULKAN_HPP_NOEXCEPT + { + storeOp = storeOp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setClearValue( ClearValue const & clearValue_ ) & VULKAN_HPP_NOEXCEPT + { + clearValue = clearValue_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setClearValue( ClearValue const & clearValue_ ) && VULKAN_HPP_NOEXCEPT + { + clearValue = clearValue_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderingAttachmentInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingAttachmentInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingAttachmentInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderingAttachmentInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageView, imageLayout, resolveMode, resolveImageView, resolveImageLayout, loadOp, storeOp, clearValue ); + } +#endif + + public: + StructureType sType = StructureType::eRenderingAttachmentInfo; + const void * pNext = {}; + ImageView imageView = {}; + ImageLayout imageLayout = ImageLayout::eUndefined; + ResolveModeFlagBits resolveMode = ResolveModeFlagBits::eNone; + ImageView resolveImageView = {}; + ImageLayout resolveImageLayout = ImageLayout::eUndefined; + AttachmentLoadOp loadOp = AttachmentLoadOp::eLoad; + AttachmentStoreOp storeOp = AttachmentStoreOp::eStore; + ClearValue clearValue = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderingAttachmentInfo; + }; +#endif + + template <> + struct CppType + { + using Type = RenderingAttachmentInfo; + }; + + using RenderingAttachmentInfoKHR = RenderingAttachmentInfo; + + // wrapper struct for struct VkRenderingAttachmentLocationInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentLocationInfo.html + struct RenderingAttachmentLocationInfo + { + using NativeType = VkRenderingAttachmentLocationInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingAttachmentLocationInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderingAttachmentLocationInfo( uint32_t colorAttachmentCount_ = {}, + const uint32_t * pColorAttachmentLocations_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , colorAttachmentCount{ colorAttachmentCount_ } + , pColorAttachmentLocations{ pColorAttachmentLocations_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderingAttachmentLocationInfo( RenderingAttachmentLocationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderingAttachmentLocationInfo( VkRenderingAttachmentLocationInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderingAttachmentLocationInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderingAttachmentLocationInfo( ArrayProxyNoTemporaries const & colorAttachmentLocations_, const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , colorAttachmentCount( static_cast( colorAttachmentLocations_.size() ) ) + , pColorAttachmentLocations( colorAttachmentLocations_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderingAttachmentLocationInfo & operator=( RenderingAttachmentLocationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderingAttachmentLocationInfo & operator=( VkRenderingAttachmentLocationInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo & setPColorAttachmentLocations( const uint32_t * pColorAttachmentLocations_ ) & VULKAN_HPP_NOEXCEPT + { + pColorAttachmentLocations = pColorAttachmentLocations_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo && setPColorAttachmentLocations( const uint32_t * pColorAttachmentLocations_ ) && + VULKAN_HPP_NOEXCEPT + { + pColorAttachmentLocations = pColorAttachmentLocations_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderingAttachmentLocationInfo & + setColorAttachmentLocations( ArrayProxyNoTemporaries const & colorAttachmentLocations_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( colorAttachmentLocations_.size() ); + pColorAttachmentLocations = colorAttachmentLocations_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderingAttachmentLocationInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingAttachmentLocationInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingAttachmentLocationInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderingAttachmentLocationInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentLocations ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderingAttachmentLocationInfo const & ) const = default; +#else + bool operator==( RenderingAttachmentLocationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && + ( pColorAttachmentLocations == rhs.pColorAttachmentLocations ); +# endif + } + + bool operator!=( RenderingAttachmentLocationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderingAttachmentLocationInfo; + const void * pNext = {}; + uint32_t colorAttachmentCount = {}; + const uint32_t * pColorAttachmentLocations = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderingAttachmentLocationInfo; + }; +#endif + + template <> + struct CppType + { + using Type = RenderingAttachmentLocationInfo; + }; + + using RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo; + + // wrapper struct for struct VkRenderingEndInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingEndInfoKHR.html + struct RenderingEndInfoKHR + { + using NativeType = VkRenderingEndInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingEndInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderingEndInfoKHR( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} + + VULKAN_HPP_CONSTEXPR RenderingEndInfoKHR( RenderingEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderingEndInfoKHR( VkRenderingEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : RenderingEndInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + RenderingEndInfoKHR & operator=( RenderingEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderingEndInfoKHR & operator=( VkRenderingEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderingEndInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingEndInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderingEndInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingEndInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingEndInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderingEndInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderingEndInfoKHR const & ) const = default; +#else + bool operator==( RenderingEndInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( RenderingEndInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderingEndInfoKHR; + const void * pNext = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderingEndInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = RenderingEndInfoKHR; + }; + + using RenderingEndInfoEXT = RenderingEndInfoKHR; + + // wrapper struct for struct VkRenderingFragmentDensityMapAttachmentInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFragmentDensityMapAttachmentInfoEXT.html + struct RenderingFragmentDensityMapAttachmentInfoEXT + { + using NativeType = VkRenderingFragmentDensityMapAttachmentInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingFragmentDensityMapAttachmentInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderingFragmentDensityMapAttachmentInfoEXT( ImageView imageView_ = {}, + ImageLayout imageLayout_ = ImageLayout::eUndefined, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageView{ imageView_ } + , imageLayout{ imageLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderingFragmentDensityMapAttachmentInfoEXT( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderingFragmentDensityMapAttachmentInfoEXT( VkRenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderingFragmentDensityMapAttachmentInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + RenderingFragmentDensityMapAttachmentInfoEXT & operator=( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderingFragmentDensityMapAttachmentInfoEXT & operator=( VkRenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT & setImageLayout( ImageLayout imageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + imageLayout = imageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT && setImageLayout( ImageLayout imageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + imageLayout = imageLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderingFragmentDensityMapAttachmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingFragmentDensityMapAttachmentInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingFragmentDensityMapAttachmentInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderingFragmentDensityMapAttachmentInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageView, imageLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderingFragmentDensityMapAttachmentInfoEXT const & ) const = default; +#else + bool operator==( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout ); +# endif + } + + bool operator!=( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderingFragmentDensityMapAttachmentInfoEXT; + const void * pNext = {}; + ImageView imageView = {}; + ImageLayout imageLayout = ImageLayout::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderingFragmentDensityMapAttachmentInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = RenderingFragmentDensityMapAttachmentInfoEXT; + }; + + // wrapper struct for struct VkRenderingFragmentShadingRateAttachmentInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFragmentShadingRateAttachmentInfoKHR.html + struct RenderingFragmentShadingRateAttachmentInfoKHR + { + using NativeType = VkRenderingFragmentShadingRateAttachmentInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingFragmentShadingRateAttachmentInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderingFragmentShadingRateAttachmentInfoKHR( ImageView imageView_ = {}, + ImageLayout imageLayout_ = ImageLayout::eUndefined, + Extent2D shadingRateAttachmentTexelSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , imageView{ imageView_ } + , imageLayout{ imageLayout_ } + , shadingRateAttachmentTexelSize{ shadingRateAttachmentTexelSize_ } + { + } + + VULKAN_HPP_CONSTEXPR + RenderingFragmentShadingRateAttachmentInfoKHR( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderingFragmentShadingRateAttachmentInfoKHR( VkRenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderingFragmentShadingRateAttachmentInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + RenderingFragmentShadingRateAttachmentInfoKHR & operator=( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderingFragmentShadingRateAttachmentInfoKHR & operator=( VkRenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT + { + imageView = imageView_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR & setImageLayout( ImageLayout imageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + imageLayout = imageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR && setImageLayout( ImageLayout imageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + imageLayout = imageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR & + setShadingRateAttachmentTexelSize( Extent2D const & shadingRateAttachmentTexelSize_ ) & + VULKAN_HPP_NOEXCEPT + { + shadingRateAttachmentTexelSize = shadingRateAttachmentTexelSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR && + setShadingRateAttachmentTexelSize( Extent2D const & shadingRateAttachmentTexelSize_ ) && + VULKAN_HPP_NOEXCEPT + { + shadingRateAttachmentTexelSize = shadingRateAttachmentTexelSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderingFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingFragmentShadingRateAttachmentInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderingFragmentShadingRateAttachmentInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, imageView, imageLayout, shadingRateAttachmentTexelSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderingFragmentShadingRateAttachmentInfoKHR const & ) const = default; +#else + bool operator==( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout ) && + ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize ); +# endif + } + + bool operator!=( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderingFragmentShadingRateAttachmentInfoKHR; + const void * pNext = {}; + ImageView imageView = {}; + ImageLayout imageLayout = ImageLayout::eUndefined; + Extent2D shadingRateAttachmentTexelSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderingFragmentShadingRateAttachmentInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = RenderingFragmentShadingRateAttachmentInfoKHR; + }; + + // wrapper struct for struct VkRenderingInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingInfo.html + struct RenderingInfo + { + using NativeType = VkRenderingInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 RenderingInfo( RenderingFlags flags_ = {}, + Rect2D renderArea_ = {}, + uint32_t layerCount_ = {}, + uint32_t viewMask_ = {}, + uint32_t colorAttachmentCount_ = {}, + const RenderingAttachmentInfo * pColorAttachments_ = {}, + const RenderingAttachmentInfo * pDepthAttachment_ = {}, + const RenderingAttachmentInfo * pStencilAttachment_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , renderArea{ renderArea_ } + , layerCount{ layerCount_ } + , viewMask{ viewMask_ } + , colorAttachmentCount{ colorAttachmentCount_ } + , pColorAttachments{ pColorAttachments_ } + , pDepthAttachment{ pDepthAttachment_ } + , pStencilAttachment{ pStencilAttachment_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo( RenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderingInfo( VkRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT : RenderingInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderingInfo( RenderingFlags flags_, + Rect2D renderArea_, + uint32_t layerCount_, + uint32_t viewMask_, + ArrayProxyNoTemporaries const & colorAttachments_, + const RenderingAttachmentInfo * pDepthAttachment_ = {}, + const RenderingAttachmentInfo * pStencilAttachment_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , renderArea( renderArea_ ) + , layerCount( layerCount_ ) + , viewMask( viewMask_ ) + , colorAttachmentCount( static_cast( colorAttachments_.size() ) ) + , pColorAttachments( colorAttachments_.data() ) + , pDepthAttachment( pDepthAttachment_ ) + , pStencilAttachment( pStencilAttachment_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderingInfo & operator=( RenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderingInfo & operator=( VkRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setFlags( RenderingFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setFlags( RenderingFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setRenderArea( Rect2D const & renderArea_ ) & VULKAN_HPP_NOEXCEPT + { + renderArea = renderArea_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setRenderArea( Rect2D const & renderArea_ ) && VULKAN_HPP_NOEXCEPT + { + renderArea = renderArea_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setViewMask( uint32_t viewMask_ ) & VULKAN_HPP_NOEXCEPT + { + viewMask = viewMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setViewMask( uint32_t viewMask_ ) && VULKAN_HPP_NOEXCEPT + { + viewMask = viewMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setPColorAttachments( const RenderingAttachmentInfo * pColorAttachments_ ) & VULKAN_HPP_NOEXCEPT + { + pColorAttachments = pColorAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setPColorAttachments( const RenderingAttachmentInfo * pColorAttachments_ ) && VULKAN_HPP_NOEXCEPT + { + pColorAttachments = pColorAttachments_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderingInfo & setColorAttachments( ArrayProxyNoTemporaries const & colorAttachments_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( colorAttachments_.size() ); + pColorAttachments = colorAttachments_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setPDepthAttachment( const RenderingAttachmentInfo * pDepthAttachment_ ) & VULKAN_HPP_NOEXCEPT + { + pDepthAttachment = pDepthAttachment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setPDepthAttachment( const RenderingAttachmentInfo * pDepthAttachment_ ) && VULKAN_HPP_NOEXCEPT + { + pDepthAttachment = pDepthAttachment_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setPStencilAttachment( const RenderingAttachmentInfo * pStencilAttachment_ ) & VULKAN_HPP_NOEXCEPT + { + pStencilAttachment = pStencilAttachment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setPStencilAttachment( const RenderingAttachmentInfo * pStencilAttachment_ ) && VULKAN_HPP_NOEXCEPT + { + pStencilAttachment = pStencilAttachment_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderingInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderingInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, renderArea, layerCount, viewMask, colorAttachmentCount, pColorAttachments, pDepthAttachment, pStencilAttachment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderingInfo const & ) const = default; +#else + bool operator==( RenderingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( renderArea == rhs.renderArea ) && + ( layerCount == rhs.layerCount ) && ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && + ( pColorAttachments == rhs.pColorAttachments ) && ( pDepthAttachment == rhs.pDepthAttachment ) && ( pStencilAttachment == rhs.pStencilAttachment ); +# endif + } + + bool operator!=( RenderingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderingInfo; + const void * pNext = {}; + RenderingFlags flags = {}; + Rect2D renderArea = {}; + uint32_t layerCount = {}; + uint32_t viewMask = {}; + uint32_t colorAttachmentCount = {}; + const RenderingAttachmentInfo * pColorAttachments = {}; + const RenderingAttachmentInfo * pDepthAttachment = {}; + const RenderingAttachmentInfo * pStencilAttachment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderingInfo; + }; +#endif + + template <> + struct CppType + { + using Type = RenderingInfo; + }; + + using RenderingInfoKHR = RenderingInfo; + + // wrapper struct for struct VkRenderingInputAttachmentIndexInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingInputAttachmentIndexInfo.html + struct RenderingInputAttachmentIndexInfo + { + using NativeType = VkRenderingInputAttachmentIndexInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingInputAttachmentIndexInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderingInputAttachmentIndexInfo( uint32_t colorAttachmentCount_ = {}, + const uint32_t * pColorAttachmentInputIndices_ = {}, + const uint32_t * pDepthInputAttachmentIndex_ = {}, + const uint32_t * pStencilInputAttachmentIndex_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , colorAttachmentCount{ colorAttachmentCount_ } + , pColorAttachmentInputIndices{ pColorAttachmentInputIndices_ } + , pDepthInputAttachmentIndex{ pDepthInputAttachmentIndex_ } + , pStencilInputAttachmentIndex{ pStencilInputAttachmentIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderingInputAttachmentIndexInfo( RenderingInputAttachmentIndexInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderingInputAttachmentIndexInfo( VkRenderingInputAttachmentIndexInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderingInputAttachmentIndexInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderingInputAttachmentIndexInfo( ArrayProxyNoTemporaries const & colorAttachmentInputIndices_, + const uint32_t * pDepthInputAttachmentIndex_ = {}, + const uint32_t * pStencilInputAttachmentIndex_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , colorAttachmentCount( static_cast( colorAttachmentInputIndices_.size() ) ) + , pColorAttachmentInputIndices( colorAttachmentInputIndices_.data() ) + , pDepthInputAttachmentIndex( pDepthInputAttachmentIndex_ ) + , pStencilInputAttachmentIndex( pStencilInputAttachmentIndex_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + RenderingInputAttachmentIndexInfo & operator=( RenderingInputAttachmentIndexInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderingInputAttachmentIndexInfo & operator=( VkRenderingInputAttachmentIndexInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = colorAttachmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo & setPColorAttachmentInputIndices( const uint32_t * pColorAttachmentInputIndices_ ) & + VULKAN_HPP_NOEXCEPT + { + pColorAttachmentInputIndices = pColorAttachmentInputIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo && setPColorAttachmentInputIndices( const uint32_t * pColorAttachmentInputIndices_ ) && + VULKAN_HPP_NOEXCEPT + { + pColorAttachmentInputIndices = pColorAttachmentInputIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + RenderingInputAttachmentIndexInfo & + setColorAttachmentInputIndices( ArrayProxyNoTemporaries const & colorAttachmentInputIndices_ ) VULKAN_HPP_NOEXCEPT + { + colorAttachmentCount = static_cast( colorAttachmentInputIndices_.size() ); + pColorAttachmentInputIndices = colorAttachmentInputIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo & setPDepthInputAttachmentIndex( const uint32_t * pDepthInputAttachmentIndex_ ) & + VULKAN_HPP_NOEXCEPT + { + pDepthInputAttachmentIndex = pDepthInputAttachmentIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo && setPDepthInputAttachmentIndex( const uint32_t * pDepthInputAttachmentIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + pDepthInputAttachmentIndex = pDepthInputAttachmentIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo & setPStencilInputAttachmentIndex( const uint32_t * pStencilInputAttachmentIndex_ ) & + VULKAN_HPP_NOEXCEPT + { + pStencilInputAttachmentIndex = pStencilInputAttachmentIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo && setPStencilInputAttachmentIndex( const uint32_t * pStencilInputAttachmentIndex_ ) && + VULKAN_HPP_NOEXCEPT + { + pStencilInputAttachmentIndex = pStencilInputAttachmentIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderingInputAttachmentIndexInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingInputAttachmentIndexInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderingInputAttachmentIndexInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderingInputAttachmentIndexInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentInputIndices, pDepthInputAttachmentIndex, pStencilInputAttachmentIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderingInputAttachmentIndexInfo const & ) const = default; +#else + bool operator==( RenderingInputAttachmentIndexInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && + ( pColorAttachmentInputIndices == rhs.pColorAttachmentInputIndices ) && ( pDepthInputAttachmentIndex == rhs.pDepthInputAttachmentIndex ) && + ( pStencilInputAttachmentIndex == rhs.pStencilInputAttachmentIndex ); +# endif + } + + bool operator!=( RenderingInputAttachmentIndexInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eRenderingInputAttachmentIndexInfo; + const void * pNext = {}; + uint32_t colorAttachmentCount = {}; + const uint32_t * pColorAttachmentInputIndices = {}; + const uint32_t * pDepthInputAttachmentIndex = {}; + const uint32_t * pStencilInputAttachmentIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = RenderingInputAttachmentIndexInfo; + }; +#endif + + template <> + struct CppType + { + using Type = RenderingInputAttachmentIndexInfo; + }; + + using RenderingInputAttachmentIndexInfoKHR = RenderingInputAttachmentIndexInfo; + + // wrapper struct for struct VkResolveImageInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveImageInfo2.html + struct ResolveImageInfo2 + { + using NativeType = VkResolveImageInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eResolveImageInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ResolveImageInfo2( Image srcImage_ = {}, + ImageLayout srcImageLayout_ = ImageLayout::eUndefined, + Image dstImage_ = {}, + ImageLayout dstImageLayout_ = ImageLayout::eUndefined, + uint32_t regionCount_ = {}, + const ImageResolve2 * pRegions_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcImage{ srcImage_ } + , srcImageLayout{ srcImageLayout_ } + , dstImage{ dstImage_ } + , dstImageLayout{ dstImageLayout_ } + , regionCount{ regionCount_ } + , pRegions{ pRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR ResolveImageInfo2( ResolveImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ResolveImageInfo2( VkResolveImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : ResolveImageInfo2( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ResolveImageInfo2( Image srcImage_, + ImageLayout srcImageLayout_, + Image dstImage_, + ImageLayout dstImageLayout_, + ArrayProxyNoTemporaries const & regions_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , srcImage( srcImage_ ) + , srcImageLayout( srcImageLayout_ ) + , dstImage( dstImage_ ) + , dstImageLayout( dstImageLayout_ ) + , regionCount( static_cast( regions_.size() ) ) + , pRegions( regions_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ResolveImageInfo2 & operator=( ResolveImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ResolveImageInfo2 & operator=( VkResolveImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT + { + srcImage = srcImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + srcImageLayout = srcImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT + { + dstImage = dstImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT + { + dstImageLayout = dstImageLayout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT + { + regionCount = regionCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setPRegions( const ImageResolve2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setPRegions( const ImageResolve2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT + { + pRegions = pRegions_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ResolveImageInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT + { + regionCount = static_cast( regions_.size() ); + pRegions = regions_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkResolveImageInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkResolveImageInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkResolveImageInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkResolveImageInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ResolveImageInfo2 const & ) const = default; +#else + bool operator==( ResolveImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) && + ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); +# endif + } + + bool operator!=( ResolveImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eResolveImageInfo2; + const void * pNext = {}; + Image srcImage = {}; + ImageLayout srcImageLayout = ImageLayout::eUndefined; + Image dstImage = {}; + ImageLayout dstImageLayout = ImageLayout::eUndefined; + uint32_t regionCount = {}; + const ImageResolve2 * pRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ResolveImageInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = ResolveImageInfo2; + }; + + using ResolveImageInfo2KHR = ResolveImageInfo2; + + // wrapper struct for struct VkResolveImageModeInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveImageModeInfoKHR.html + struct ResolveImageModeInfoKHR + { + using NativeType = VkResolveImageModeInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eResolveImageModeInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ResolveImageModeInfoKHR( ResolveImageFlagsKHR flags_ = {}, + ResolveModeFlagBits resolveMode_ = ResolveModeFlagBits::eNone, + ResolveModeFlagBits stencilResolveMode_ = ResolveModeFlagBits::eNone, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , resolveMode{ resolveMode_ } + , stencilResolveMode{ stencilResolveMode_ } + { + } + + VULKAN_HPP_CONSTEXPR ResolveImageModeInfoKHR( ResolveImageModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ResolveImageModeInfoKHR( VkResolveImageModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : ResolveImageModeInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + ResolveImageModeInfoKHR & operator=( ResolveImageModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ResolveImageModeInfoKHR & operator=( VkResolveImageModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR & setFlags( ResolveImageFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR && setFlags( ResolveImageFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR & setResolveMode( ResolveModeFlagBits resolveMode_ ) & VULKAN_HPP_NOEXCEPT + { + resolveMode = resolveMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR && setResolveMode( ResolveModeFlagBits resolveMode_ ) && VULKAN_HPP_NOEXCEPT + { + resolveMode = resolveMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR & setStencilResolveMode( ResolveModeFlagBits stencilResolveMode_ ) & VULKAN_HPP_NOEXCEPT + { + stencilResolveMode = stencilResolveMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR && setStencilResolveMode( ResolveModeFlagBits stencilResolveMode_ ) && VULKAN_HPP_NOEXCEPT + { + stencilResolveMode = stencilResolveMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkResolveImageModeInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkResolveImageModeInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkResolveImageModeInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkResolveImageModeInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, resolveMode, stencilResolveMode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ResolveImageModeInfoKHR const & ) const = default; +#else + bool operator==( ResolveImageModeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( resolveMode == rhs.resolveMode ) && + ( stencilResolveMode == rhs.stencilResolveMode ); +# endif + } + + bool operator!=( ResolveImageModeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eResolveImageModeInfoKHR; + const void * pNext = {}; + ResolveImageFlagsKHR flags = {}; + ResolveModeFlagBits resolveMode = ResolveModeFlagBits::eNone; + ResolveModeFlagBits stencilResolveMode = ResolveModeFlagBits::eNone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ResolveImageModeInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = ResolveImageModeInfoKHR; + }; + + // wrapper struct for struct VkTexelBufferDescriptorInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTexelBufferDescriptorInfoEXT.html + struct TexelBufferDescriptorInfoEXT + { + using NativeType = VkTexelBufferDescriptorInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTexelBufferDescriptorInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TexelBufferDescriptorInfoEXT( Format format_ = Format::eUndefined, + DeviceAddressRangeEXT addressRange_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , format{ format_ } + , addressRange{ addressRange_ } + { + } + + VULKAN_HPP_CONSTEXPR TexelBufferDescriptorInfoEXT( TexelBufferDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TexelBufferDescriptorInfoEXT( VkTexelBufferDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : TexelBufferDescriptorInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + TexelBufferDescriptorInfoEXT & operator=( TexelBufferDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TexelBufferDescriptorInfoEXT & operator=( VkTexelBufferDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT & setAddressRange( DeviceAddressRangeEXT const & addressRange_ ) & VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT && setAddressRange( DeviceAddressRangeEXT const & addressRange_ ) && VULKAN_HPP_NOEXCEPT + { + addressRange = addressRange_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTexelBufferDescriptorInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTexelBufferDescriptorInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTexelBufferDescriptorInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTexelBufferDescriptorInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format, addressRange ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TexelBufferDescriptorInfoEXT const & ) const = default; +#else + bool operator==( TexelBufferDescriptorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( addressRange == rhs.addressRange ); +# endif + } + + bool operator!=( TexelBufferDescriptorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTexelBufferDescriptorInfoEXT; + const void * pNext = {}; + Format format = Format::eUndefined; + DeviceAddressRangeEXT addressRange = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TexelBufferDescriptorInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = TexelBufferDescriptorInfoEXT; + }; + + // wrapper struct for struct VkTensorViewCreateInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateInfoARM.html + struct TensorViewCreateInfoARM + { + using NativeType = VkTensorViewCreateInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorViewCreateInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TensorViewCreateInfoARM( TensorViewCreateFlagsARM flags_ = {}, + TensorARM tensor_ = {}, + Format format_ = Format::eUndefined, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , tensor{ tensor_ } + , format{ format_ } + { + } + + VULKAN_HPP_CONSTEXPR TensorViewCreateInfoARM( TensorViewCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TensorViewCreateInfoARM( VkTensorViewCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : TensorViewCreateInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + TensorViewCreateInfoARM & operator=( TensorViewCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TensorViewCreateInfoARM & operator=( VkTensorViewCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM & setFlags( TensorViewCreateFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM && setFlags( TensorViewCreateFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTensorViewCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorViewCreateInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorViewCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTensorViewCreateInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, tensor, format ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TensorViewCreateInfoARM const & ) const = default; +#else + bool operator==( TensorViewCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( tensor == rhs.tensor ) && ( format == rhs.format ); +# endif + } + + bool operator!=( TensorViewCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTensorViewCreateInfoARM; + const void * pNext = {}; + TensorViewCreateFlagsARM flags = {}; + TensorARM tensor = {}; + Format format = Format::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TensorViewCreateInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = TensorViewCreateInfoARM; + }; + + union ResourceDescriptorDataEXT + { + using NativeType = VkResourceDescriptorDataEXT; +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT( const ImageDescriptorInfoEXT * pImage_ = {} ) : pImage( pImage_ ) {} + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT( const TexelBufferDescriptorInfoEXT * pTexelBuffer_ ) : pTexelBuffer( pTexelBuffer_ ) {} + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT( const DeviceAddressRangeEXT * pAddressRange_ ) : pAddressRange( pAddressRange_ ) {} + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT( const TensorViewCreateInfoARM * pTensorARM_ ) : pTensorARM( pTensorARM_ ) {} +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT & setPImage( const ImageDescriptorInfoEXT * pImage_ ) & VULKAN_HPP_NOEXCEPT + { + pImage = pImage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT && setPImage( const ImageDescriptorInfoEXT * pImage_ ) && VULKAN_HPP_NOEXCEPT + { + pImage = pImage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT & setPTexelBuffer( const TexelBufferDescriptorInfoEXT * pTexelBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + pTexelBuffer = pTexelBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT && setPTexelBuffer( const TexelBufferDescriptorInfoEXT * pTexelBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + pTexelBuffer = pTexelBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT & setPAddressRange( const DeviceAddressRangeEXT * pAddressRange_ ) & VULKAN_HPP_NOEXCEPT + { + pAddressRange = pAddressRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT && setPAddressRange( const DeviceAddressRangeEXT * pAddressRange_ ) && VULKAN_HPP_NOEXCEPT + { + pAddressRange = pAddressRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT & setPTensorARM( const TensorViewCreateInfoARM * pTensorARM_ ) & VULKAN_HPP_NOEXCEPT + { + pTensorARM = pTensorARM_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT && setPTensorARM( const TensorViewCreateInfoARM * pTensorARM_ ) && VULKAN_HPP_NOEXCEPT + { + pTensorARM = pTensorARM_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkResourceDescriptorDataEXT const &() const + { + return *reinterpret_cast( this ); + } + + operator VkResourceDescriptorDataEXT &() + { + return *reinterpret_cast( this ); + } + +#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS + const ImageDescriptorInfoEXT * pImage; + const TexelBufferDescriptorInfoEXT * pTexelBuffer; + const DeviceAddressRangeEXT * pAddressRange; + const TensorViewCreateInfoARM * pTensorARM; +#else + const VkImageDescriptorInfoEXT * pImage; + const VkTexelBufferDescriptorInfoEXT * pTexelBuffer; + const VkDeviceAddressRangeEXT * pAddressRange; + const VkTensorViewCreateInfoARM * pTensorARM; +#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ResourceDescriptorDataEXT; + }; +#endif + + // wrapper struct for struct VkResourceDescriptorInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResourceDescriptorInfoEXT.html + struct ResourceDescriptorInfoEXT + { + using NativeType = VkResourceDescriptorInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eResourceDescriptorInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT( DescriptorType type_ = DescriptorType::eSampler, + ResourceDescriptorDataEXT data_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , type{ type_ } + , data{ data_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT( ResourceDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ResourceDescriptorInfoEXT( VkResourceDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ResourceDescriptorInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ResourceDescriptorInfoEXT & operator=( ResourceDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ResourceDescriptorInfoEXT & operator=( VkResourceDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT & setType( DescriptorType type_ ) & VULKAN_HPP_NOEXCEPT + { + type = type_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT && setType( DescriptorType type_ ) && VULKAN_HPP_NOEXCEPT + { + type = type_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT & setData( ResourceDescriptorDataEXT const & data_ ) & VULKAN_HPP_NOEXCEPT + { + data = data_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT && setData( ResourceDescriptorDataEXT const & data_ ) && VULKAN_HPP_NOEXCEPT + { + data = data_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkResourceDescriptorInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkResourceDescriptorInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkResourceDescriptorInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkResourceDescriptorInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, type, data ); + } +#endif + + public: + StructureType sType = StructureType::eResourceDescriptorInfoEXT; + const void * pNext = {}; + DescriptorType type = DescriptorType::eSampler; + ResourceDescriptorDataEXT data = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ResourceDescriptorInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ResourceDescriptorInfoEXT; + }; + + // wrapper struct for struct VkSamplerBlockMatchWindowCreateInfoQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerBlockMatchWindowCreateInfoQCOM.html + struct SamplerBlockMatchWindowCreateInfoQCOM + { + using NativeType = VkSamplerBlockMatchWindowCreateInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerBlockMatchWindowCreateInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SamplerBlockMatchWindowCreateInfoQCOM( Extent2D windowExtent_ = {}, + BlockMatchWindowCompareModeQCOM windowCompareMode_ = BlockMatchWindowCompareModeQCOM::eMin, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , windowExtent{ windowExtent_ } + , windowCompareMode{ windowCompareMode_ } + { + } + + VULKAN_HPP_CONSTEXPR SamplerBlockMatchWindowCreateInfoQCOM( SamplerBlockMatchWindowCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerBlockMatchWindowCreateInfoQCOM( VkSamplerBlockMatchWindowCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : SamplerBlockMatchWindowCreateInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + SamplerBlockMatchWindowCreateInfoQCOM & operator=( SamplerBlockMatchWindowCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerBlockMatchWindowCreateInfoQCOM & operator=( VkSamplerBlockMatchWindowCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM & setWindowExtent( Extent2D const & windowExtent_ ) & VULKAN_HPP_NOEXCEPT + { + windowExtent = windowExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM && setWindowExtent( Extent2D const & windowExtent_ ) && VULKAN_HPP_NOEXCEPT + { + windowExtent = windowExtent_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM & setWindowCompareMode( BlockMatchWindowCompareModeQCOM windowCompareMode_ ) & + VULKAN_HPP_NOEXCEPT + { + windowCompareMode = windowCompareMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM && setWindowCompareMode( BlockMatchWindowCompareModeQCOM windowCompareMode_ ) && + VULKAN_HPP_NOEXCEPT + { + windowCompareMode = windowCompareMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSamplerBlockMatchWindowCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerBlockMatchWindowCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerBlockMatchWindowCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerBlockMatchWindowCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, windowExtent, windowCompareMode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SamplerBlockMatchWindowCreateInfoQCOM const & ) const = default; +#else + bool operator==( SamplerBlockMatchWindowCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( windowExtent == rhs.windowExtent ) && ( windowCompareMode == rhs.windowCompareMode ); +# endif + } + + bool operator!=( SamplerBlockMatchWindowCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerBlockMatchWindowCreateInfoQCOM; + const void * pNext = {}; + Extent2D windowExtent = {}; + BlockMatchWindowCompareModeQCOM windowCompareMode = BlockMatchWindowCompareModeQCOM::eMin; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerBlockMatchWindowCreateInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerBlockMatchWindowCreateInfoQCOM; + }; + + // wrapper struct for struct VkSamplerBorderColorComponentMappingCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerBorderColorComponentMappingCreateInfoEXT.html + struct SamplerBorderColorComponentMappingCreateInfoEXT + { + using NativeType = VkSamplerBorderColorComponentMappingCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + SamplerBorderColorComponentMappingCreateInfoEXT( ComponentMapping components_ = {}, Bool32 srgb_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , components{ components_ } + , srgb{ srgb_ } + { + } + + VULKAN_HPP_CONSTEXPR + SamplerBorderColorComponentMappingCreateInfoEXT( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerBorderColorComponentMappingCreateInfoEXT( VkSamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SamplerBorderColorComponentMappingCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + SamplerBorderColorComponentMappingCreateInfoEXT & operator=( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerBorderColorComponentMappingCreateInfoEXT & operator=( VkSamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT & setComponents( ComponentMapping const & components_ ) & VULKAN_HPP_NOEXCEPT + { + components = components_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT && setComponents( ComponentMapping const & components_ ) && VULKAN_HPP_NOEXCEPT + { + components = components_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT & setSrgb( Bool32 srgb_ ) & VULKAN_HPP_NOEXCEPT + { + srgb = srgb_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT && setSrgb( Bool32 srgb_ ) && VULKAN_HPP_NOEXCEPT + { + srgb = srgb_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSamplerBorderColorComponentMappingCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerBorderColorComponentMappingCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerBorderColorComponentMappingCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerBorderColorComponentMappingCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, components, srgb ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SamplerBorderColorComponentMappingCreateInfoEXT const & ) const = default; +#else + bool operator==( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( components == rhs.components ) && ( srgb == rhs.srgb ); +# endif + } + + bool operator!=( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT; + const void * pNext = {}; + ComponentMapping components = {}; + Bool32 srgb = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerBorderColorComponentMappingCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerBorderColorComponentMappingCreateInfoEXT; + }; + + // wrapper struct for struct VkSamplerCaptureDescriptorDataInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCaptureDescriptorDataInfoEXT.html + struct SamplerCaptureDescriptorDataInfoEXT + { + using NativeType = VkSamplerCaptureDescriptorDataInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCaptureDescriptorDataInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SamplerCaptureDescriptorDataInfoEXT( Sampler sampler_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , sampler{ sampler_ } + { + } + + VULKAN_HPP_CONSTEXPR SamplerCaptureDescriptorDataInfoEXT( SamplerCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerCaptureDescriptorDataInfoEXT( VkSamplerCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SamplerCaptureDescriptorDataInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + SamplerCaptureDescriptorDataInfoEXT & operator=( SamplerCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerCaptureDescriptorDataInfoEXT & operator=( VkSamplerCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SamplerCaptureDescriptorDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCaptureDescriptorDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCaptureDescriptorDataInfoEXT & setSampler( Sampler sampler_ ) & VULKAN_HPP_NOEXCEPT + { + sampler = sampler_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCaptureDescriptorDataInfoEXT && setSampler( Sampler sampler_ ) && VULKAN_HPP_NOEXCEPT + { + sampler = sampler_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSamplerCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sampler ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SamplerCaptureDescriptorDataInfoEXT const & ) const = default; +#else + bool operator==( SamplerCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampler == rhs.sampler ); +# endif + } + + bool operator!=( SamplerCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerCaptureDescriptorDataInfoEXT; + const void * pNext = {}; + Sampler sampler = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerCaptureDescriptorDataInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerCaptureDescriptorDataInfoEXT; + }; + + // wrapper struct for struct VkSamplerCubicWeightsCreateInfoQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCubicWeightsCreateInfoQCOM.html + struct SamplerCubicWeightsCreateInfoQCOM + { + using NativeType = VkSamplerCubicWeightsCreateInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCubicWeightsCreateInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SamplerCubicWeightsCreateInfoQCOM( CubicFilterWeightsQCOM cubicWeights_ = CubicFilterWeightsQCOM::eCatmullRom, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , cubicWeights{ cubicWeights_ } + { + } + + VULKAN_HPP_CONSTEXPR SamplerCubicWeightsCreateInfoQCOM( SamplerCubicWeightsCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerCubicWeightsCreateInfoQCOM( VkSamplerCubicWeightsCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : SamplerCubicWeightsCreateInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + SamplerCubicWeightsCreateInfoQCOM & operator=( SamplerCubicWeightsCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerCubicWeightsCreateInfoQCOM & operator=( VkSamplerCubicWeightsCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SamplerCubicWeightsCreateInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCubicWeightsCreateInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCubicWeightsCreateInfoQCOM & setCubicWeights( CubicFilterWeightsQCOM cubicWeights_ ) & VULKAN_HPP_NOEXCEPT + { + cubicWeights = cubicWeights_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCubicWeightsCreateInfoQCOM && setCubicWeights( CubicFilterWeightsQCOM cubicWeights_ ) && VULKAN_HPP_NOEXCEPT + { + cubicWeights = cubicWeights_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSamplerCubicWeightsCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerCubicWeightsCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerCubicWeightsCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerCubicWeightsCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, cubicWeights ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SamplerCubicWeightsCreateInfoQCOM const & ) const = default; +#else + bool operator==( SamplerCubicWeightsCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cubicWeights == rhs.cubicWeights ); +# endif + } + + bool operator!=( SamplerCubicWeightsCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerCubicWeightsCreateInfoQCOM; + const void * pNext = {}; + CubicFilterWeightsQCOM cubicWeights = CubicFilterWeightsQCOM::eCatmullRom; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerCubicWeightsCreateInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerCubicWeightsCreateInfoQCOM; + }; + + // wrapper struct for struct VkSamplerCustomBorderColorCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCustomBorderColorCreateInfoEXT.html + struct SamplerCustomBorderColorCreateInfoEXT + { + using NativeType = VkSamplerCustomBorderColorCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCustomBorderColorCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT( ClearColorValue customBorderColor_ = {}, + Format format_ = Format::eUndefined, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , customBorderColor{ customBorderColor_ } + , format{ format_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT( SamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerCustomBorderColorCreateInfoEXT( VkSamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SamplerCustomBorderColorCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + SamplerCustomBorderColorCreateInfoEXT & operator=( SamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerCustomBorderColorCreateInfoEXT & operator=( VkSamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT & setCustomBorderColor( ClearColorValue const & customBorderColor_ ) & VULKAN_HPP_NOEXCEPT + { + customBorderColor = customBorderColor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT && setCustomBorderColor( ClearColorValue const & customBorderColor_ ) && VULKAN_HPP_NOEXCEPT + { + customBorderColor = customBorderColor_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSamplerCustomBorderColorCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerCustomBorderColorCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerCustomBorderColorCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerCustomBorderColorCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, customBorderColor, format ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerCustomBorderColorCreateInfoEXT; + const void * pNext = {}; + ClearColorValue customBorderColor = {}; + Format format = Format::eUndefined; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerCustomBorderColorCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerCustomBorderColorCreateInfoEXT; + }; + + // wrapper struct for struct VkSamplerCustomBorderColorIndexCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCustomBorderColorIndexCreateInfoEXT.html + struct SamplerCustomBorderColorIndexCreateInfoEXT + { + using NativeType = VkSamplerCustomBorderColorIndexCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCustomBorderColorIndexCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SamplerCustomBorderColorIndexCreateInfoEXT( uint32_t index_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , index{ index_ } + { + } + + VULKAN_HPP_CONSTEXPR SamplerCustomBorderColorIndexCreateInfoEXT( SamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerCustomBorderColorIndexCreateInfoEXT( VkSamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SamplerCustomBorderColorIndexCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + SamplerCustomBorderColorIndexCreateInfoEXT & operator=( SamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerCustomBorderColorIndexCreateInfoEXT & operator=( VkSamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorIndexCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorIndexCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorIndexCreateInfoEXT & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT + { + index = index_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorIndexCreateInfoEXT && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT + { + index = index_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSamplerCustomBorderColorIndexCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerCustomBorderColorIndexCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerCustomBorderColorIndexCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerCustomBorderColorIndexCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, index ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SamplerCustomBorderColorIndexCreateInfoEXT const & ) const = default; +#else + bool operator==( SamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( index == rhs.index ); +# endif + } + + bool operator!=( SamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerCustomBorderColorIndexCreateInfoEXT; + const void * pNext = {}; + uint32_t index = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerCustomBorderColorIndexCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerCustomBorderColorIndexCreateInfoEXT; + }; + + // wrapper struct for struct VkSamplerReductionModeCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerReductionModeCreateInfo.html + struct SamplerReductionModeCreateInfo + { + using NativeType = VkSamplerReductionModeCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerReductionModeCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfo( SamplerReductionMode reductionMode_ = SamplerReductionMode::eWeightedAverage, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , reductionMode{ reductionMode_ } + { + } + + VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfo( SamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerReductionModeCreateInfo( VkSamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : SamplerReductionModeCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + SamplerReductionModeCreateInfo & operator=( SamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerReductionModeCreateInfo & operator=( VkSamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SamplerReductionModeCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerReductionModeCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerReductionModeCreateInfo & setReductionMode( SamplerReductionMode reductionMode_ ) & VULKAN_HPP_NOEXCEPT + { + reductionMode = reductionMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerReductionModeCreateInfo && setReductionMode( SamplerReductionMode reductionMode_ ) && VULKAN_HPP_NOEXCEPT + { + reductionMode = reductionMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSamplerReductionModeCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerReductionModeCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerReductionModeCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerReductionModeCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, reductionMode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SamplerReductionModeCreateInfo const & ) const = default; +#else + bool operator==( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reductionMode == rhs.reductionMode ); +# endif + } + + bool operator!=( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerReductionModeCreateInfo; + const void * pNext = {}; + SamplerReductionMode reductionMode = SamplerReductionMode::eWeightedAverage; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerReductionModeCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerReductionModeCreateInfo; + }; + + using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo; + + // wrapper struct for struct VkSamplerYcbcrConversionCreateInfo, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionCreateInfo.html + struct SamplerYcbcrConversionCreateInfo + { + using NativeType = VkSamplerYcbcrConversionCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( Format format_ = Format::eUndefined, + SamplerYcbcrModelConversion ycbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, + SamplerYcbcrRange ycbcrRange_ = SamplerYcbcrRange::eItuFull, + ComponentMapping components_ = {}, + ChromaLocation xChromaOffset_ = ChromaLocation::eCositedEven, + ChromaLocation yChromaOffset_ = ChromaLocation::eCositedEven, + Filter chromaFilter_ = Filter::eNearest, + Bool32 forceExplicitReconstruction_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , format{ format_ } + , ycbcrModel{ ycbcrModel_ } + , ycbcrRange{ ycbcrRange_ } + , components{ components_ } + , xChromaOffset{ xChromaOffset_ } + , yChromaOffset{ yChromaOffset_ } + , chromaFilter{ chromaFilter_ } + , forceExplicitReconstruction{ forceExplicitReconstruction_ } + { + } + + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( SamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : SamplerYcbcrConversionCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + SamplerYcbcrConversionCreateInfo & operator=( SamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerYcbcrConversionCreateInfo & operator=( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ ) & VULKAN_HPP_NOEXCEPT + { + ycbcrModel = ycbcrModel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ ) && VULKAN_HPP_NOEXCEPT + { + ycbcrModel = ycbcrModel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setYcbcrRange( SamplerYcbcrRange ycbcrRange_ ) & VULKAN_HPP_NOEXCEPT + { + ycbcrRange = ycbcrRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setYcbcrRange( SamplerYcbcrRange ycbcrRange_ ) && VULKAN_HPP_NOEXCEPT + { + ycbcrRange = ycbcrRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setComponents( ComponentMapping const & components_ ) & VULKAN_HPP_NOEXCEPT + { + components = components_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setComponents( ComponentMapping const & components_ ) && VULKAN_HPP_NOEXCEPT + { + components = components_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setXChromaOffset( ChromaLocation xChromaOffset_ ) & VULKAN_HPP_NOEXCEPT + { + xChromaOffset = xChromaOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setXChromaOffset( ChromaLocation xChromaOffset_ ) && VULKAN_HPP_NOEXCEPT + { + xChromaOffset = xChromaOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setYChromaOffset( ChromaLocation yChromaOffset_ ) & VULKAN_HPP_NOEXCEPT + { + yChromaOffset = yChromaOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setYChromaOffset( ChromaLocation yChromaOffset_ ) && VULKAN_HPP_NOEXCEPT + { + yChromaOffset = yChromaOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setChromaFilter( Filter chromaFilter_ ) & VULKAN_HPP_NOEXCEPT + { + chromaFilter = chromaFilter_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setChromaFilter( Filter chromaFilter_ ) && VULKAN_HPP_NOEXCEPT + { + chromaFilter = chromaFilter_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ ) & VULKAN_HPP_NOEXCEPT + { + forceExplicitReconstruction = forceExplicitReconstruction_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ ) && VULKAN_HPP_NOEXCEPT + { + forceExplicitReconstruction = forceExplicitReconstruction_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSamplerYcbcrConversionCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format, ycbcrModel, ycbcrRange, components, xChromaOffset, yChromaOffset, chromaFilter, forceExplicitReconstruction ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SamplerYcbcrConversionCreateInfo const & ) const = default; +#else + bool operator==( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( ycbcrModel == rhs.ycbcrModel ) && + ( ycbcrRange == rhs.ycbcrRange ) && ( components == rhs.components ) && ( xChromaOffset == rhs.xChromaOffset ) && + ( yChromaOffset == rhs.yChromaOffset ) && ( chromaFilter == rhs.chromaFilter ) && + ( forceExplicitReconstruction == rhs.forceExplicitReconstruction ); +# endif + } + + bool operator!=( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo; + const void * pNext = {}; + Format format = Format::eUndefined; + SamplerYcbcrModelConversion ycbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; + SamplerYcbcrRange ycbcrRange = SamplerYcbcrRange::eItuFull; + ComponentMapping components = {}; + ChromaLocation xChromaOffset = ChromaLocation::eCositedEven; + ChromaLocation yChromaOffset = ChromaLocation::eCositedEven; + Filter chromaFilter = Filter::eNearest; + Bool32 forceExplicitReconstruction = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerYcbcrConversionCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerYcbcrConversionCreateInfo; + }; + + using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; + + // wrapper struct for struct VkSamplerYcbcrConversionImageFormatProperties, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionImageFormatProperties.html + struct SamplerYcbcrConversionImageFormatProperties + { + using NativeType = VkSamplerYcbcrConversionImageFormatProperties; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionImageFormatProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionImageFormatProperties( uint32_t combinedImageSamplerDescriptorCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , combinedImageSamplerDescriptorCount{ combinedImageSamplerDescriptorCount_ } + { + } + + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionImageFormatProperties( SamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : SamplerYcbcrConversionImageFormatProperties( *reinterpret_cast( &rhs ) ) + { + } + + SamplerYcbcrConversionImageFormatProperties & operator=( SamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerYcbcrConversionImageFormatProperties & operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSamplerYcbcrConversionImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionImageFormatProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionImageFormatProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionImageFormatProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, combinedImageSamplerDescriptorCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SamplerYcbcrConversionImageFormatProperties const & ) const = default; +#else + bool operator==( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount ); +# endif + } + + bool operator!=( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties; + void * pNext = {}; + uint32_t combinedImageSamplerDescriptorCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerYcbcrConversionImageFormatProperties; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerYcbcrConversionImageFormatProperties; + }; + + using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties; + + // wrapper struct for struct VkSamplerYcbcrConversionInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionInfo.html + struct SamplerYcbcrConversionInfo + { + using NativeType = VkSamplerYcbcrConversionInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( SamplerYcbcrConversion conversion_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , conversion{ conversion_ } + { + } + + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( SamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : SamplerYcbcrConversionInfo( *reinterpret_cast( &rhs ) ) + { + } + + SamplerYcbcrConversionInfo & operator=( SamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerYcbcrConversionInfo & operator=( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionInfo & setConversion( SamplerYcbcrConversion conversion_ ) & VULKAN_HPP_NOEXCEPT + { + conversion = conversion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionInfo && setConversion( SamplerYcbcrConversion conversion_ ) && VULKAN_HPP_NOEXCEPT + { + conversion = conversion_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSamplerYcbcrConversionInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, conversion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SamplerYcbcrConversionInfo const & ) const = default; +#else + bool operator==( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conversion == rhs.conversion ); +# endif + } + + bool operator!=( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerYcbcrConversionInfo; + const void * pNext = {}; + SamplerYcbcrConversion conversion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerYcbcrConversionInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerYcbcrConversionInfo; + }; + + using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; + + // wrapper struct for struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.html + struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM + { + using NativeType = VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM( Bool32 enableYDegamma_ = {}, + Bool32 enableCbCrDegamma_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , enableYDegamma{ enableYDegamma_ } + , enableCbCrDegamma{ enableCbCrDegamma_ } + { + } + + VULKAN_HPP_CONSTEXPR + SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM( SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM( VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM & operator=( SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM & operator=( VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM & setEnableYDegamma( Bool32 enableYDegamma_ ) & VULKAN_HPP_NOEXCEPT + { + enableYDegamma = enableYDegamma_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM && setEnableYDegamma( Bool32 enableYDegamma_ ) && VULKAN_HPP_NOEXCEPT + { + enableYDegamma = enableYDegamma_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM & setEnableCbCrDegamma( Bool32 enableCbCrDegamma_ ) & VULKAN_HPP_NOEXCEPT + { + enableCbCrDegamma = enableCbCrDegamma_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM && setEnableCbCrDegamma( Bool32 enableCbCrDegamma_ ) && VULKAN_HPP_NOEXCEPT + { + enableCbCrDegamma = enableCbCrDegamma_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, enableYDegamma, enableCbCrDegamma ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & ) const = default; +#else + bool operator==( SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( enableYDegamma == rhs.enableYDegamma ) && ( enableCbCrDegamma == rhs.enableCbCrDegamma ); +# endif + } + + bool operator!=( SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; + void * pNext = {}; + Bool32 enableYDegamma = {}; + Bool32 enableCbCrDegamma = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; + }; + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + // wrapper struct for struct VkScreenBufferFormatPropertiesQNX, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkScreenBufferFormatPropertiesQNX.html + struct ScreenBufferFormatPropertiesQNX + { + using NativeType = VkScreenBufferFormatPropertiesQNX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eScreenBufferFormatPropertiesQNX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ScreenBufferFormatPropertiesQNX( Format format_ = Format::eUndefined, + uint64_t externalFormat_ = {}, + uint64_t screenUsage_ = {}, + FormatFeatureFlags formatFeatures_ = {}, + ComponentMapping samplerYcbcrConversionComponents_ = {}, + SamplerYcbcrModelConversion suggestedYcbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, + SamplerYcbcrRange suggestedYcbcrRange_ = SamplerYcbcrRange::eItuFull, + ChromaLocation suggestedXChromaOffset_ = ChromaLocation::eCositedEven, + ChromaLocation suggestedYChromaOffset_ = ChromaLocation::eCositedEven, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , format{ format_ } + , externalFormat{ externalFormat_ } + , screenUsage{ screenUsage_ } + , formatFeatures{ formatFeatures_ } + , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ } + , suggestedYcbcrModel{ suggestedYcbcrModel_ } + , suggestedYcbcrRange{ suggestedYcbcrRange_ } + , suggestedXChromaOffset{ suggestedXChromaOffset_ } + , suggestedYChromaOffset{ suggestedYChromaOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR ScreenBufferFormatPropertiesQNX( ScreenBufferFormatPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ScreenBufferFormatPropertiesQNX( VkScreenBufferFormatPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT + : ScreenBufferFormatPropertiesQNX( *reinterpret_cast( &rhs ) ) + { + } + + ScreenBufferFormatPropertiesQNX & operator=( ScreenBufferFormatPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ScreenBufferFormatPropertiesQNX & operator=( VkScreenBufferFormatPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkScreenBufferFormatPropertiesQNX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkScreenBufferFormatPropertiesQNX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkScreenBufferFormatPropertiesQNX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkScreenBufferFormatPropertiesQNX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + format, + externalFormat, + screenUsage, + formatFeatures, + samplerYcbcrConversionComponents, + suggestedYcbcrModel, + suggestedYcbcrRange, + suggestedXChromaOffset, + suggestedYChromaOffset ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ScreenBufferFormatPropertiesQNX const & ) const = default; +# else + bool operator==( ScreenBufferFormatPropertiesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) && + ( screenUsage == rhs.screenUsage ) && ( formatFeatures == rhs.formatFeatures ) && + ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && + ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && + ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); +# endif + } + + bool operator!=( ScreenBufferFormatPropertiesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eScreenBufferFormatPropertiesQNX; + void * pNext = {}; + Format format = Format::eUndefined; + uint64_t externalFormat = {}; + uint64_t screenUsage = {}; + FormatFeatureFlags formatFeatures = {}; + ComponentMapping samplerYcbcrConversionComponents = {}; + SamplerYcbcrModelConversion suggestedYcbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; + SamplerYcbcrRange suggestedYcbcrRange = SamplerYcbcrRange::eItuFull; + ChromaLocation suggestedXChromaOffset = ChromaLocation::eCositedEven; + ChromaLocation suggestedYChromaOffset = ChromaLocation::eCositedEven; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ScreenBufferFormatPropertiesQNX; + }; +# endif + + template <> + struct CppType + { + using Type = ScreenBufferFormatPropertiesQNX; + }; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + // wrapper struct for struct VkScreenBufferPropertiesQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkScreenBufferPropertiesQNX.html + struct ScreenBufferPropertiesQNX + { + using NativeType = VkScreenBufferPropertiesQNX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eScreenBufferPropertiesQNX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + ScreenBufferPropertiesQNX( DeviceSize allocationSize_ = {}, uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , allocationSize{ allocationSize_ } + , memoryTypeBits{ memoryTypeBits_ } + { + } + + VULKAN_HPP_CONSTEXPR ScreenBufferPropertiesQNX( ScreenBufferPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ScreenBufferPropertiesQNX( VkScreenBufferPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT + : ScreenBufferPropertiesQNX( *reinterpret_cast( &rhs ) ) + { + } + + ScreenBufferPropertiesQNX & operator=( ScreenBufferPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ScreenBufferPropertiesQNX & operator=( VkScreenBufferPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkScreenBufferPropertiesQNX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkScreenBufferPropertiesQNX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkScreenBufferPropertiesQNX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkScreenBufferPropertiesQNX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, allocationSize, memoryTypeBits ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ScreenBufferPropertiesQNX const & ) const = default; +# else + bool operator==( ScreenBufferPropertiesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeBits == rhs.memoryTypeBits ); +# endif + } + + bool operator!=( ScreenBufferPropertiesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eScreenBufferPropertiesQNX; + void * pNext = {}; + DeviceSize allocationSize = {}; + uint32_t memoryTypeBits = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ScreenBufferPropertiesQNX; + }; +# endif + + template <> + struct CppType + { + using Type = ScreenBufferPropertiesQNX; + }; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + // wrapper struct for struct VkScreenSurfaceCreateInfoQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkScreenSurfaceCreateInfoQNX.html + struct ScreenSurfaceCreateInfoQNX + { + using NativeType = VkScreenSurfaceCreateInfoQNX; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eScreenSurfaceCreateInfoQNX; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ScreenSurfaceCreateInfoQNX( ScreenSurfaceCreateFlagsQNX flags_ = {}, + struct _screen_context * context_ = {}, + struct _screen_window * window_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , context{ context_ } + , window{ window_ } + { + } + + VULKAN_HPP_CONSTEXPR ScreenSurfaceCreateInfoQNX( ScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ScreenSurfaceCreateInfoQNX( VkScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT + : ScreenSurfaceCreateInfoQNX( *reinterpret_cast( &rhs ) ) + { + } + + ScreenSurfaceCreateInfoQNX & operator=( ScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ScreenSurfaceCreateInfoQNX & operator=( VkScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX & setFlags( ScreenSurfaceCreateFlagsQNX flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX && setFlags( ScreenSurfaceCreateFlagsQNX flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX & setContext( struct _screen_context * context_ ) & VULKAN_HPP_NOEXCEPT + { + context = context_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX && setContext( struct _screen_context * context_ ) && VULKAN_HPP_NOEXCEPT + { + context = context_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX & setWindow( struct _screen_window * window_ ) & VULKAN_HPP_NOEXCEPT + { + window = window_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX && setWindow( struct _screen_window * window_ ) && VULKAN_HPP_NOEXCEPT + { + window = window_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkScreenSurfaceCreateInfoQNX const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkScreenSurfaceCreateInfoQNX &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkScreenSurfaceCreateInfoQNX const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkScreenSurfaceCreateInfoQNX *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, context, window ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ScreenSurfaceCreateInfoQNX const & ) const = default; +# else + bool operator==( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( context == rhs.context ) && ( window == rhs.window ); +# endif + } + + bool operator!=( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eScreenSurfaceCreateInfoQNX; + const void * pNext = {}; + ScreenSurfaceCreateFlagsQNX flags = {}; + struct _screen_context * context = {}; + struct _screen_window * window = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ScreenSurfaceCreateInfoQNX; + }; +# endif + + template <> + struct CppType + { + using Type = ScreenSurfaceCreateInfoQNX; + }; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + // wrapper struct for struct VkSemaphoreCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreCreateInfo.html + struct SemaphoreCreateInfo + { + using NativeType = VkSemaphoreCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( SemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SemaphoreCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + SemaphoreCreateInfo & operator=( SemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SemaphoreCreateInfo & operator=( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SemaphoreCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreCreateInfo & setFlags( SemaphoreCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreCreateInfo && setFlags( SemaphoreCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSemaphoreCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SemaphoreCreateInfo const & ) const = default; +#else + bool operator==( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSemaphoreCreateInfo; + const void * pNext = {}; + SemaphoreCreateFlags flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SemaphoreCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SemaphoreCreateInfo; + }; + + // wrapper struct for struct VkSemaphoreGetFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreGetFdInfoKHR.html + struct SemaphoreGetFdInfoKHR + { + using NativeType = VkSemaphoreGetFdInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetFdInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( Semaphore semaphore_ = {}, + ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , semaphore{ semaphore_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( SemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SemaphoreGetFdInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + SemaphoreGetFdInfoKHR & operator=( SemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SemaphoreGetFdInfoKHR & operator=( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSemaphoreGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreGetFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSemaphoreGetFdInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, handleType ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SemaphoreGetFdInfoKHR const & ) const = default; +#else + bool operator==( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSemaphoreGetFdInfoKHR; + const void * pNext = {}; + Semaphore semaphore = {}; + ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SemaphoreGetFdInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = SemaphoreGetFdInfoKHR; + }; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkSemaphoreGetWin32HandleInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreGetWin32HandleInfoKHR.html + struct SemaphoreGetWin32HandleInfoKHR + { + using NativeType = VkSemaphoreGetWin32HandleInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetWin32HandleInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = {}, + ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , semaphore{ semaphore_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( SemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SemaphoreGetWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + SemaphoreGetWin32HandleInfoKHR & operator=( SemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SemaphoreGetWin32HandleInfoKHR & operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSemaphoreGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreGetWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSemaphoreGetWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, handleType ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SemaphoreGetWin32HandleInfoKHR const & ) const = default; +# else + bool operator==( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR; + const void * pNext = {}; + Semaphore semaphore = {}; + ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SemaphoreGetWin32HandleInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = SemaphoreGetWin32HandleInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + // wrapper struct for struct VkSemaphoreGetZirconHandleInfoFUCHSIA, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreGetZirconHandleInfoFUCHSIA.html + struct SemaphoreGetZirconHandleInfoFUCHSIA + { + using NativeType = VkSemaphoreGetZirconHandleInfoFUCHSIA; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SemaphoreGetZirconHandleInfoFUCHSIA( Semaphore semaphore_ = {}, + ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , semaphore{ semaphore_ } + , handleType{ handleType_ } + { + } + + VULKAN_HPP_CONSTEXPR SemaphoreGetZirconHandleInfoFUCHSIA( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SemaphoreGetZirconHandleInfoFUCHSIA( VkSemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + : SemaphoreGetZirconHandleInfoFUCHSIA( *reinterpret_cast( &rhs ) ) + { + } + + SemaphoreGetZirconHandleInfoFUCHSIA & operator=( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SemaphoreGetZirconHandleInfoFUCHSIA & operator=( VkSemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT + { + handleType = handleType_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSemaphoreGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreGetZirconHandleInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSemaphoreGetZirconHandleInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, handleType ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SemaphoreGetZirconHandleInfoFUCHSIA const & ) const = default; +# else + bool operator==( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( handleType == rhs.handleType ); +# endif + } + + bool operator!=( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA; + const void * pNext = {}; + Semaphore semaphore = {}; + ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SemaphoreGetZirconHandleInfoFUCHSIA; + }; +# endif + + template <> + struct CppType + { + using Type = SemaphoreGetZirconHandleInfoFUCHSIA; + }; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + // wrapper struct for struct VkSemaphoreSignalInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreSignalInfo.html + struct SemaphoreSignalInfo + { + using NativeType = VkSemaphoreSignalInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreSignalInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SemaphoreSignalInfo( Semaphore semaphore_ = {}, uint64_t value_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , semaphore{ semaphore_ } + , value{ value_ } + { + } + + VULKAN_HPP_CONSTEXPR SemaphoreSignalInfo( SemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SemaphoreSignalInfo( VkSemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SemaphoreSignalInfo( *reinterpret_cast( &rhs ) ) + { + } + + SemaphoreSignalInfo & operator=( SemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SemaphoreSignalInfo & operator=( VkSemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT + { + semaphore = semaphore_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo & setValue( uint64_t value_ ) & VULKAN_HPP_NOEXCEPT + { + value = value_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo && setValue( uint64_t value_ ) && VULKAN_HPP_NOEXCEPT + { + value = value_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSemaphoreSignalInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreSignalInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreSignalInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSemaphoreSignalInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphore, value ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SemaphoreSignalInfo const & ) const = default; +#else + bool operator==( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( value == rhs.value ); +# endif + } + + bool operator!=( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSemaphoreSignalInfo; + const void * pNext = {}; + Semaphore semaphore = {}; + uint64_t value = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SemaphoreSignalInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SemaphoreSignalInfo; + }; + + using SemaphoreSignalInfoKHR = SemaphoreSignalInfo; + + // wrapper struct for struct VkSemaphoreTypeCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreTypeCreateInfo.html + struct SemaphoreTypeCreateInfo + { + using NativeType = VkSemaphoreTypeCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreTypeCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfo( SemaphoreType semaphoreType_ = SemaphoreType::eBinary, + uint64_t initialValue_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , semaphoreType{ semaphoreType_ } + , initialValue{ initialValue_ } + { + } + + VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfo( SemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SemaphoreTypeCreateInfo( VkSemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : SemaphoreTypeCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + + SemaphoreTypeCreateInfo & operator=( SemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SemaphoreTypeCreateInfo & operator=( VkSemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo & setSemaphoreType( SemaphoreType semaphoreType_ ) & VULKAN_HPP_NOEXCEPT + { + semaphoreType = semaphoreType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo && setSemaphoreType( SemaphoreType semaphoreType_ ) && VULKAN_HPP_NOEXCEPT + { + semaphoreType = semaphoreType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo & setInitialValue( uint64_t initialValue_ ) & VULKAN_HPP_NOEXCEPT + { + initialValue = initialValue_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo && setInitialValue( uint64_t initialValue_ ) && VULKAN_HPP_NOEXCEPT + { + initialValue = initialValue_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSemaphoreTypeCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreTypeCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreTypeCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSemaphoreTypeCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, semaphoreType, initialValue ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SemaphoreTypeCreateInfo const & ) const = default; +#else + bool operator==( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphoreType == rhs.semaphoreType ) && ( initialValue == rhs.initialValue ); +# endif + } + + bool operator!=( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSemaphoreTypeCreateInfo; + const void * pNext = {}; + SemaphoreType semaphoreType = SemaphoreType::eBinary; + uint64_t initialValue = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SemaphoreTypeCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SemaphoreTypeCreateInfo; + }; + + using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo; + + // wrapper struct for struct VkSemaphoreWaitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreWaitInfo.html + struct SemaphoreWaitInfo + { + using NativeType = VkSemaphoreWaitInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreWaitInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SemaphoreWaitInfo( SemaphoreWaitFlags flags_ = {}, + uint32_t semaphoreCount_ = {}, + const Semaphore * pSemaphores_ = {}, + const uint64_t * pValues_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , semaphoreCount{ semaphoreCount_ } + , pSemaphores{ pSemaphores_ } + , pValues{ pValues_ } + { + } + + VULKAN_HPP_CONSTEXPR SemaphoreWaitInfo( SemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SemaphoreWaitInfo( VkSemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SemaphoreWaitInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SemaphoreWaitInfo( SemaphoreWaitFlags flags_, + ArrayProxyNoTemporaries const & semaphores_, + ArrayProxyNoTemporaries const & values_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , semaphoreCount( static_cast( semaphores_.size() ) ) + , pSemaphores( semaphores_.data() ) + , pValues( values_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( semaphores_.size() == values_.size() ); +# else + if ( semaphores_.size() != values_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::SemaphoreWaitInfo::SemaphoreWaitInfo: semaphores_.size() != values_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SemaphoreWaitInfo & operator=( SemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SemaphoreWaitInfo & operator=( VkSemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo & setFlags( SemaphoreWaitFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo && setFlags( SemaphoreWaitFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo & setSemaphoreCount( uint32_t semaphoreCount_ ) & VULKAN_HPP_NOEXCEPT + { + semaphoreCount = semaphoreCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo && setSemaphoreCount( uint32_t semaphoreCount_ ) && VULKAN_HPP_NOEXCEPT + { + semaphoreCount = semaphoreCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo & setPSemaphores( const Semaphore * pSemaphores_ ) & VULKAN_HPP_NOEXCEPT + { + pSemaphores = pSemaphores_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo && setPSemaphores( const Semaphore * pSemaphores_ ) && VULKAN_HPP_NOEXCEPT + { + pSemaphores = pSemaphores_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SemaphoreWaitInfo & setSemaphores( ArrayProxyNoTemporaries const & semaphores_ ) VULKAN_HPP_NOEXCEPT + { + semaphoreCount = static_cast( semaphores_.size() ); + pSemaphores = semaphores_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo & setPValues( const uint64_t * pValues_ ) & VULKAN_HPP_NOEXCEPT + { + pValues = pValues_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo && setPValues( const uint64_t * pValues_ ) && VULKAN_HPP_NOEXCEPT + { + pValues = pValues_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SemaphoreWaitInfo & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT + { + semaphoreCount = static_cast( values_.size() ); + pValues = values_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSemaphoreWaitInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreWaitInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSemaphoreWaitInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSemaphoreWaitInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, semaphoreCount, pSemaphores, pValues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SemaphoreWaitInfo const & ) const = default; +#else + bool operator==( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( semaphoreCount == rhs.semaphoreCount ) && + ( pSemaphores == rhs.pSemaphores ) && ( pValues == rhs.pValues ); +# endif + } + + bool operator!=( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSemaphoreWaitInfo; + const void * pNext = {}; + SemaphoreWaitFlags flags = {}; + uint32_t semaphoreCount = {}; + const Semaphore * pSemaphores = {}; + const uint64_t * pValues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SemaphoreWaitInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SemaphoreWaitInfo; + }; + + using SemaphoreWaitInfoKHR = SemaphoreWaitInfo; + + // wrapper struct for struct VkSetDescriptorBufferOffsetsInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSetDescriptorBufferOffsetsInfoEXT.html + struct SetDescriptorBufferOffsetsInfoEXT + { + using NativeType = VkSetDescriptorBufferOffsetsInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSetDescriptorBufferOffsetsInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SetDescriptorBufferOffsetsInfoEXT( ShaderStageFlags stageFlags_ = {}, + PipelineLayout layout_ = {}, + uint32_t firstSet_ = {}, + uint32_t setCount_ = {}, + const uint32_t * pBufferIndices_ = {}, + const DeviceSize * pOffsets_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stageFlags{ stageFlags_ } + , layout{ layout_ } + , firstSet{ firstSet_ } + , setCount{ setCount_ } + , pBufferIndices{ pBufferIndices_ } + , pOffsets{ pOffsets_ } + { + } + + VULKAN_HPP_CONSTEXPR SetDescriptorBufferOffsetsInfoEXT( SetDescriptorBufferOffsetsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SetDescriptorBufferOffsetsInfoEXT( VkSetDescriptorBufferOffsetsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SetDescriptorBufferOffsetsInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SetDescriptorBufferOffsetsInfoEXT( ShaderStageFlags stageFlags_, + PipelineLayout layout_, + uint32_t firstSet_, + ArrayProxyNoTemporaries const & bufferIndices_, + ArrayProxyNoTemporaries const & offsets_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , stageFlags( stageFlags_ ) + , layout( layout_ ) + , firstSet( firstSet_ ) + , setCount( static_cast( bufferIndices_.size() ) ) + , pBufferIndices( bufferIndices_.data() ) + , pOffsets( offsets_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( bufferIndices_.size() == offsets_.size() ); +# else + if ( bufferIndices_.size() != offsets_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::SetDescriptorBufferOffsetsInfoEXT::SetDescriptorBufferOffsetsInfoEXT: bufferIndices_.size() != offsets_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SetDescriptorBufferOffsetsInfoEXT & operator=( SetDescriptorBufferOffsetsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SetDescriptorBufferOffsetsInfoEXT & operator=( VkSetDescriptorBufferOffsetsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT + { + stageFlags = stageFlags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT + { + layout = layout_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setFirstSet( uint32_t firstSet_ ) & VULKAN_HPP_NOEXCEPT + { + firstSet = firstSet_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setFirstSet( uint32_t firstSet_ ) && VULKAN_HPP_NOEXCEPT + { + firstSet = firstSet_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setSetCount( uint32_t setCount_ ) & VULKAN_HPP_NOEXCEPT + { + setCount = setCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setSetCount( uint32_t setCount_ ) && VULKAN_HPP_NOEXCEPT + { + setCount = setCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setPBufferIndices( const uint32_t * pBufferIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pBufferIndices = pBufferIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setPBufferIndices( const uint32_t * pBufferIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pBufferIndices = pBufferIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SetDescriptorBufferOffsetsInfoEXT & setBufferIndices( ArrayProxyNoTemporaries const & bufferIndices_ ) VULKAN_HPP_NOEXCEPT + { + setCount = static_cast( bufferIndices_.size() ); + pBufferIndices = bufferIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setPOffsets( const DeviceSize * pOffsets_ ) & VULKAN_HPP_NOEXCEPT + { + pOffsets = pOffsets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setPOffsets( const DeviceSize * pOffsets_ ) && VULKAN_HPP_NOEXCEPT + { + pOffsets = pOffsets_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SetDescriptorBufferOffsetsInfoEXT & setOffsets( ArrayProxyNoTemporaries const & offsets_ ) VULKAN_HPP_NOEXCEPT + { + setCount = static_cast( offsets_.size() ); + pOffsets = offsets_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSetDescriptorBufferOffsetsInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSetDescriptorBufferOffsetsInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSetDescriptorBufferOffsetsInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSetDescriptorBufferOffsetsInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stageFlags, layout, firstSet, setCount, pBufferIndices, pOffsets ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SetDescriptorBufferOffsetsInfoEXT const & ) const = default; +#else + bool operator==( SetDescriptorBufferOffsetsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( firstSet == rhs.firstSet ) && + ( setCount == rhs.setCount ) && ( pBufferIndices == rhs.pBufferIndices ) && ( pOffsets == rhs.pOffsets ); +# endif + } + + bool operator!=( SetDescriptorBufferOffsetsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSetDescriptorBufferOffsetsInfoEXT; + const void * pNext = {}; + ShaderStageFlags stageFlags = {}; + PipelineLayout layout = {}; + uint32_t firstSet = {}; + uint32_t setCount = {}; + const uint32_t * pBufferIndices = {}; + const DeviceSize * pOffsets = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SetDescriptorBufferOffsetsInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SetDescriptorBufferOffsetsInfoEXT; + }; + + // wrapper struct for struct VkSetLatencyMarkerInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSetLatencyMarkerInfoNV.html + struct SetLatencyMarkerInfoNV + { + using NativeType = VkSetLatencyMarkerInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSetLatencyMarkerInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SetLatencyMarkerInfoNV( uint64_t presentID_ = {}, + LatencyMarkerNV marker_ = LatencyMarkerNV::eSimulationStart, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentID{ presentID_ } + , marker{ marker_ } + { + } + + VULKAN_HPP_CONSTEXPR SetLatencyMarkerInfoNV( SetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SetLatencyMarkerInfoNV( VkSetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : SetLatencyMarkerInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + SetLatencyMarkerInfoNV & operator=( SetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SetLatencyMarkerInfoNV & operator=( VkSetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV & setPresentID( uint64_t presentID_ ) & VULKAN_HPP_NOEXCEPT + { + presentID = presentID_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV && setPresentID( uint64_t presentID_ ) && VULKAN_HPP_NOEXCEPT + { + presentID = presentID_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV & setMarker( LatencyMarkerNV marker_ ) & VULKAN_HPP_NOEXCEPT + { + marker = marker_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV && setMarker( LatencyMarkerNV marker_ ) && VULKAN_HPP_NOEXCEPT + { + marker = marker_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSetLatencyMarkerInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSetLatencyMarkerInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSetLatencyMarkerInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSetLatencyMarkerInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentID, marker ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SetLatencyMarkerInfoNV const & ) const = default; +#else + bool operator==( SetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID ) && ( marker == rhs.marker ); +# endif + } + + bool operator!=( SetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSetLatencyMarkerInfoNV; + const void * pNext = {}; + uint64_t presentID = {}; + LatencyMarkerNV marker = LatencyMarkerNV::eSimulationStart; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SetLatencyMarkerInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = SetLatencyMarkerInfoNV; + }; + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + // wrapper struct for struct VkSetPresentConfigNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSetPresentConfigNV.html + struct SetPresentConfigNV + { + using NativeType = VkSetPresentConfigNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSetPresentConfigNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + SetPresentConfigNV( uint32_t numFramesPerBatch_ = {}, uint32_t presentConfigFeedback_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , numFramesPerBatch{ numFramesPerBatch_ } + , presentConfigFeedback{ presentConfigFeedback_ } + { + } + + VULKAN_HPP_CONSTEXPR SetPresentConfigNV( SetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SetPresentConfigNV( VkSetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT : SetPresentConfigNV( *reinterpret_cast( &rhs ) ) {} + + SetPresentConfigNV & operator=( SetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SetPresentConfigNV & operator=( VkSetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV & setNumFramesPerBatch( uint32_t numFramesPerBatch_ ) & VULKAN_HPP_NOEXCEPT + { + numFramesPerBatch = numFramesPerBatch_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV && setNumFramesPerBatch( uint32_t numFramesPerBatch_ ) && VULKAN_HPP_NOEXCEPT + { + numFramesPerBatch = numFramesPerBatch_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV & setPresentConfigFeedback( uint32_t presentConfigFeedback_ ) & VULKAN_HPP_NOEXCEPT + { + presentConfigFeedback = presentConfigFeedback_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV && setPresentConfigFeedback( uint32_t presentConfigFeedback_ ) && VULKAN_HPP_NOEXCEPT + { + presentConfigFeedback = presentConfigFeedback_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSetPresentConfigNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSetPresentConfigNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSetPresentConfigNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSetPresentConfigNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, numFramesPerBatch, presentConfigFeedback ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SetPresentConfigNV const & ) const = default; +# else + bool operator==( SetPresentConfigNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( numFramesPerBatch == rhs.numFramesPerBatch ) && + ( presentConfigFeedback == rhs.presentConfigFeedback ); +# endif + } + + bool operator!=( SetPresentConfigNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eSetPresentConfigNV; + const void * pNext = {}; + uint32_t numFramesPerBatch = {}; + uint32_t presentConfigFeedback = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SetPresentConfigNV; + }; +# endif + + template <> + struct CppType + { + using Type = SetPresentConfigNV; + }; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + // wrapper struct for struct VkSetStateFlagsIndirectCommandNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSetStateFlagsIndirectCommandNV.html + struct SetStateFlagsIndirectCommandNV + { + using NativeType = VkSetStateFlagsIndirectCommandNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SetStateFlagsIndirectCommandNV( uint32_t data_ = {} ) VULKAN_HPP_NOEXCEPT : data{ data_ } {} + + VULKAN_HPP_CONSTEXPR SetStateFlagsIndirectCommandNV( SetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SetStateFlagsIndirectCommandNV( VkSetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + : SetStateFlagsIndirectCommandNV( *reinterpret_cast( &rhs ) ) + { + } + + SetStateFlagsIndirectCommandNV & operator=( SetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SetStateFlagsIndirectCommandNV & operator=( VkSetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SetStateFlagsIndirectCommandNV & setData( uint32_t data_ ) & VULKAN_HPP_NOEXCEPT + { + data = data_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SetStateFlagsIndirectCommandNV && setData( uint32_t data_ ) && VULKAN_HPP_NOEXCEPT + { + data = data_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSetStateFlagsIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSetStateFlagsIndirectCommandNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSetStateFlagsIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSetStateFlagsIndirectCommandNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( data ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SetStateFlagsIndirectCommandNV const & ) const = default; +#else + bool operator==( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( data == rhs.data ); +# endif + } + + bool operator!=( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t data = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SetStateFlagsIndirectCommandNV; + }; +#endif + + // wrapper struct for struct VkShaderCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCreateInfoEXT.html + struct ShaderCreateInfoEXT + { + using NativeType = VkShaderCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ShaderCreateInfoEXT( ShaderCreateFlagsEXT flags_ = {}, + ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, + ShaderStageFlags nextStage_ = {}, + ShaderCodeTypeEXT codeType_ = ShaderCodeTypeEXT::eBinary, + size_t codeSize_ = {}, + const void * pCode_ = {}, + const char * pName_ = {}, + uint32_t setLayoutCount_ = {}, + const DescriptorSetLayout * pSetLayouts_ = {}, + uint32_t pushConstantRangeCount_ = {}, + const PushConstantRange * pPushConstantRanges_ = {}, + const SpecializationInfo * pSpecializationInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , stage{ stage_ } + , nextStage{ nextStage_ } + , codeType{ codeType_ } + , codeSize{ codeSize_ } + , pCode{ pCode_ } + , pName{ pName_ } + , setLayoutCount{ setLayoutCount_ } + , pSetLayouts{ pSetLayouts_ } + , pushConstantRangeCount{ pushConstantRangeCount_ } + , pPushConstantRanges{ pPushConstantRanges_ } + , pSpecializationInfo{ pSpecializationInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR ShaderCreateInfoEXT( ShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ShaderCreateInfoEXT( VkShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : ShaderCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + ShaderCreateInfoEXT( ShaderCreateFlagsEXT flags_, + ShaderStageFlagBits stage_, + ShaderStageFlags nextStage_, + ShaderCodeTypeEXT codeType_, + ArrayProxyNoTemporaries const & code_, + const char * pName_ = {}, + ArrayProxyNoTemporaries const & setLayouts_ = {}, + ArrayProxyNoTemporaries const & pushConstantRanges_ = {}, + const SpecializationInfo * pSpecializationInfo_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , stage( stage_ ) + , nextStage( nextStage_ ) + , codeType( codeType_ ) + , codeSize( code_.size() * sizeof( T ) ) + , pCode( code_.data() ) + , pName( pName_ ) + , setLayoutCount( static_cast( setLayouts_.size() ) ) + , pSetLayouts( setLayouts_.data() ) + , pushConstantRangeCount( static_cast( pushConstantRanges_.size() ) ) + , pPushConstantRanges( pushConstantRanges_.data() ) + , pSpecializationInfo( pSpecializationInfo_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ShaderCreateInfoEXT & operator=( ShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ShaderCreateInfoEXT & operator=( VkShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setFlags( ShaderCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setFlags( ShaderCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setStage( ShaderStageFlagBits stage_ ) & VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setStage( ShaderStageFlagBits stage_ ) && VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setNextStage( ShaderStageFlags nextStage_ ) & VULKAN_HPP_NOEXCEPT + { + nextStage = nextStage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setNextStage( ShaderStageFlags nextStage_ ) && VULKAN_HPP_NOEXCEPT + { + nextStage = nextStage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setCodeType( ShaderCodeTypeEXT codeType_ ) & VULKAN_HPP_NOEXCEPT + { + codeType = codeType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setCodeType( ShaderCodeTypeEXT codeType_ ) && VULKAN_HPP_NOEXCEPT + { + codeType = codeType_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setCodeSize( size_t codeSize_ ) & VULKAN_HPP_NOEXCEPT + { + codeSize = codeSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setCodeSize( size_t codeSize_ ) && VULKAN_HPP_NOEXCEPT + { + codeSize = codeSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPCode( const void * pCode_ ) & VULKAN_HPP_NOEXCEPT + { + pCode = pCode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPCode( const void * pCode_ ) && VULKAN_HPP_NOEXCEPT + { + pCode = pCode_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + ShaderCreateInfoEXT & setCode( ArrayProxyNoTemporaries const & code_ ) VULKAN_HPP_NOEXCEPT + { + codeSize = code_.size() * sizeof( T ); + pCode = code_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setSetLayoutCount( uint32_t setLayoutCount_ ) & VULKAN_HPP_NOEXCEPT + { + setLayoutCount = setLayoutCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setSetLayoutCount( uint32_t setLayoutCount_ ) && VULKAN_HPP_NOEXCEPT + { + setLayoutCount = setLayoutCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) & VULKAN_HPP_NOEXCEPT + { + pSetLayouts = pSetLayouts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) && VULKAN_HPP_NOEXCEPT + { + pSetLayouts = pSetLayouts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ShaderCreateInfoEXT & setSetLayouts( ArrayProxyNoTemporaries const & setLayouts_ ) VULKAN_HPP_NOEXCEPT + { + setLayoutCount = static_cast( setLayouts_.size() ); + pSetLayouts = setLayouts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) & VULKAN_HPP_NOEXCEPT + { + pushConstantRangeCount = pushConstantRangeCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) && VULKAN_HPP_NOEXCEPT + { + pushConstantRangeCount = pushConstantRangeCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) & VULKAN_HPP_NOEXCEPT + { + pPushConstantRanges = pPushConstantRanges_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) && VULKAN_HPP_NOEXCEPT + { + pPushConstantRanges = pPushConstantRanges_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ShaderCreateInfoEXT & setPushConstantRanges( ArrayProxyNoTemporaries const & pushConstantRanges_ ) VULKAN_HPP_NOEXCEPT + { + pushConstantRangeCount = static_cast( pushConstantRanges_.size() ); + pPushConstantRanges = pushConstantRanges_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pSpecializationInfo = pSpecializationInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pSpecializationInfo = pSpecializationInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkShaderCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkShaderCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + stage, + nextStage, + codeType, + codeSize, + pCode, + pName, + setLayoutCount, + pSetLayouts, + pushConstantRangeCount, + pPushConstantRanges, + pSpecializationInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( ShaderCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = stage <=> rhs.stage; cmp != 0 ) + return cmp; + if ( auto cmp = nextStage <=> rhs.nextStage; cmp != 0 ) + return cmp; + if ( auto cmp = codeType <=> rhs.codeType; cmp != 0 ) + return cmp; + if ( auto cmp = codeSize <=> rhs.codeSize; cmp != 0 ) + return cmp; + if ( auto cmp = pCode <=> rhs.pCode; cmp != 0 ) + return cmp; + if ( pName != rhs.pName ) + if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = setLayoutCount <=> rhs.setLayoutCount; cmp != 0 ) + return cmp; + if ( auto cmp = pSetLayouts <=> rhs.pSetLayouts; cmp != 0 ) + return cmp; + if ( auto cmp = pushConstantRangeCount <=> rhs.pushConstantRangeCount; cmp != 0 ) + return cmp; + if ( auto cmp = pPushConstantRanges <=> rhs.pPushConstantRanges; cmp != 0 ) + return cmp; + if ( auto cmp = pSpecializationInfo <=> rhs.pSpecializationInfo; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( ShaderCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( nextStage == rhs.nextStage ) && + ( codeType == rhs.codeType ) && ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode ) && + ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( setLayoutCount == rhs.setLayoutCount ) && + ( pSetLayouts == rhs.pSetLayouts ) && ( pushConstantRangeCount == rhs.pushConstantRangeCount ) && + ( pPushConstantRanges == rhs.pPushConstantRanges ) && ( pSpecializationInfo == rhs.pSpecializationInfo ); + } + + bool operator!=( ShaderCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eShaderCreateInfoEXT; + const void * pNext = {}; + ShaderCreateFlagsEXT flags = {}; + ShaderStageFlagBits stage = ShaderStageFlagBits::eVertex; + ShaderStageFlags nextStage = {}; + ShaderCodeTypeEXT codeType = ShaderCodeTypeEXT::eBinary; + size_t codeSize = {}; + const void * pCode = {}; + const char * pName = {}; + uint32_t setLayoutCount = {}; + const DescriptorSetLayout * pSetLayouts = {}; + uint32_t pushConstantRangeCount = {}; + const PushConstantRange * pPushConstantRanges = {}; + const SpecializationInfo * pSpecializationInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ShaderCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ShaderCreateInfoEXT; + }; + + // wrapper struct for struct VkShaderDescriptorSetAndBindingMappingInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderDescriptorSetAndBindingMappingInfoEXT.html + struct ShaderDescriptorSetAndBindingMappingInfoEXT + { + using NativeType = VkShaderDescriptorSetAndBindingMappingInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderDescriptorSetAndBindingMappingInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ShaderDescriptorSetAndBindingMappingInfoEXT( uint32_t mappingCount_ = {}, + const DescriptorSetAndBindingMappingEXT * pMappings_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , mappingCount{ mappingCount_ } + , pMappings{ pMappings_ } + { + } + + VULKAN_HPP_CONSTEXPR ShaderDescriptorSetAndBindingMappingInfoEXT( ShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ShaderDescriptorSetAndBindingMappingInfoEXT( VkShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ShaderDescriptorSetAndBindingMappingInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ShaderDescriptorSetAndBindingMappingInfoEXT( ArrayProxyNoTemporaries const & mappings_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), mappingCount( static_cast( mappings_.size() ) ), pMappings( mappings_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ShaderDescriptorSetAndBindingMappingInfoEXT & operator=( ShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ShaderDescriptorSetAndBindingMappingInfoEXT & operator=( VkShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT & setMappingCount( uint32_t mappingCount_ ) & VULKAN_HPP_NOEXCEPT + { + mappingCount = mappingCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT && setMappingCount( uint32_t mappingCount_ ) && VULKAN_HPP_NOEXCEPT + { + mappingCount = mappingCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT & setPMappings( const DescriptorSetAndBindingMappingEXT * pMappings_ ) & + VULKAN_HPP_NOEXCEPT + { + pMappings = pMappings_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT && setPMappings( const DescriptorSetAndBindingMappingEXT * pMappings_ ) && + VULKAN_HPP_NOEXCEPT + { + pMappings = pMappings_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ShaderDescriptorSetAndBindingMappingInfoEXT & + setMappings( ArrayProxyNoTemporaries const & mappings_ ) VULKAN_HPP_NOEXCEPT + { + mappingCount = static_cast( mappings_.size() ); + pMappings = mappings_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkShaderDescriptorSetAndBindingMappingInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderDescriptorSetAndBindingMappingInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderDescriptorSetAndBindingMappingInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkShaderDescriptorSetAndBindingMappingInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, mappingCount, pMappings ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ShaderDescriptorSetAndBindingMappingInfoEXT const & ) const = default; +#else + bool operator==( ShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mappingCount == rhs.mappingCount ) && ( pMappings == rhs.pMappings ); +# endif + } + + bool operator!=( ShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eShaderDescriptorSetAndBindingMappingInfoEXT; + const void * pNext = {}; + uint32_t mappingCount = {}; + const DescriptorSetAndBindingMappingEXT * pMappings = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ShaderDescriptorSetAndBindingMappingInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ShaderDescriptorSetAndBindingMappingInfoEXT; + }; + + // wrapper struct for struct VkShaderModuleCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleCreateInfo.html + struct ShaderModuleCreateInfo + { + using NativeType = VkShaderModuleCreateInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderModuleCreateInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = {}, + size_t codeSize_ = {}, + const uint32_t * pCode_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , codeSize{ codeSize_ } + , pCode{ pCode_ } + { + } + + VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( ShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : ShaderModuleCreateInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_, ArrayProxyNoTemporaries const & code_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), flags( flags_ ), codeSize( code_.size() * 4 ), pCode( code_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ShaderModuleCreateInfo & operator=( ShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ShaderModuleCreateInfo & operator=( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo & setFlags( ShaderModuleCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo && setFlags( ShaderModuleCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo & setCodeSize( size_t codeSize_ ) & VULKAN_HPP_NOEXCEPT + { + codeSize = codeSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo && setCodeSize( size_t codeSize_ ) && VULKAN_HPP_NOEXCEPT + { + codeSize = codeSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo & setPCode( const uint32_t * pCode_ ) & VULKAN_HPP_NOEXCEPT + { + pCode = pCode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo && setPCode( const uint32_t * pCode_ ) && VULKAN_HPP_NOEXCEPT + { + pCode = pCode_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ShaderModuleCreateInfo & setCode( ArrayProxyNoTemporaries const & code_ ) VULKAN_HPP_NOEXCEPT + { + codeSize = code_.size() * 4; + pCode = code_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkShaderModuleCreateInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderModuleCreateInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderModuleCreateInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkShaderModuleCreateInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, codeSize, pCode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ShaderModuleCreateInfo const & ) const = default; +#else + bool operator==( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode ); +# endif + } + + bool operator!=( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eShaderModuleCreateInfo; + const void * pNext = {}; + ShaderModuleCreateFlags flags = {}; + size_t codeSize = {}; + const uint32_t * pCode = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ShaderModuleCreateInfo; + }; +#endif + + template <> + struct CppType + { + using Type = ShaderModuleCreateInfo; + }; + + // wrapper struct for struct VkShaderModuleIdentifierEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleIdentifierEXT.html + struct ShaderModuleIdentifierEXT + { + using NativeType = VkShaderModuleIdentifierEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderModuleIdentifierEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 ShaderModuleIdentifierEXT( uint32_t identifierSize_ = {}, + std::array const & identifier_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , identifierSize{ identifierSize_ } + , identifier{ identifier_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 ShaderModuleIdentifierEXT( ShaderModuleIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ShaderModuleIdentifierEXT( VkShaderModuleIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ShaderModuleIdentifierEXT( *reinterpret_cast( &rhs ) ) + { + } + + ShaderModuleIdentifierEXT & operator=( ShaderModuleIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ShaderModuleIdentifierEXT & operator=( VkShaderModuleIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkShaderModuleIdentifierEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderModuleIdentifierEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderModuleIdentifierEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkShaderModuleIdentifierEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, identifierSize, identifier ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( ShaderModuleIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = identifierSize <=> rhs.identifierSize; cmp != 0 ) + return cmp; + for ( size_t i = 0; i < identifierSize; ++i ) + { + if ( auto cmp = identifier[i] <=> rhs.identifier[i]; cmp != 0 ) + return cmp; + } + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( ShaderModuleIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( identifierSize == rhs.identifierSize ) && + ( memcmp( identifier, rhs.identifier, identifierSize * sizeof( uint8_t ) ) == 0 ); + } + + bool operator!=( ShaderModuleIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eShaderModuleIdentifierEXT; + void * pNext = {}; + uint32_t identifierSize = {}; + ArrayWrapper1D identifier = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ShaderModuleIdentifierEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ShaderModuleIdentifierEXT; + }; + + // wrapper struct for struct VkShaderModuleValidationCacheCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleValidationCacheCreateInfoEXT.html + struct ShaderModuleValidationCacheCreateInfoEXT + { + using NativeType = VkShaderModuleValidationCacheCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , validationCache{ validationCache_ } + { + } + + VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ShaderModuleValidationCacheCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + ShaderModuleValidationCacheCreateInfoEXT & operator=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ShaderModuleValidationCacheCreateInfoEXT & operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ShaderModuleValidationCacheCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderModuleValidationCacheCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ShaderModuleValidationCacheCreateInfoEXT & setValidationCache( ValidationCacheEXT validationCache_ ) & VULKAN_HPP_NOEXCEPT + { + validationCache = validationCache_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderModuleValidationCacheCreateInfoEXT && setValidationCache( ValidationCacheEXT validationCache_ ) && VULKAN_HPP_NOEXCEPT + { + validationCache = validationCache_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkShaderModuleValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderModuleValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderModuleValidationCacheCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkShaderModuleValidationCacheCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, validationCache ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ShaderModuleValidationCacheCreateInfoEXT const & ) const = default; +#else + bool operator==( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( validationCache == rhs.validationCache ); +# endif + } + + bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; + const void * pNext = {}; + ValidationCacheEXT validationCache = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ShaderModuleValidationCacheCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ShaderModuleValidationCacheCreateInfoEXT; + }; + + // wrapper struct for struct VkShaderResourceUsageAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderResourceUsageAMD.html + struct ShaderResourceUsageAMD + { + using NativeType = VkShaderResourceUsageAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ShaderResourceUsageAMD( uint32_t numUsedVgprs_ = {}, + uint32_t numUsedSgprs_ = {}, + uint32_t ldsSizePerLocalWorkGroup_ = {}, + size_t ldsUsageSizeInBytes_ = {}, + size_t scratchMemUsageInBytes_ = {} ) VULKAN_HPP_NOEXCEPT + : numUsedVgprs{ numUsedVgprs_ } + , numUsedSgprs{ numUsedSgprs_ } + , ldsSizePerLocalWorkGroup{ ldsSizePerLocalWorkGroup_ } + , ldsUsageSizeInBytes{ ldsUsageSizeInBytes_ } + , scratchMemUsageInBytes{ scratchMemUsageInBytes_ } + { + } + + VULKAN_HPP_CONSTEXPR ShaderResourceUsageAMD( ShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ShaderResourceUsageAMD( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : ShaderResourceUsageAMD( *reinterpret_cast( &rhs ) ) + { + } + + ShaderResourceUsageAMD & operator=( ShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ShaderResourceUsageAMD & operator=( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkShaderResourceUsageAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderResourceUsageAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderResourceUsageAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkShaderResourceUsageAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( numUsedVgprs, numUsedSgprs, ldsSizePerLocalWorkGroup, ldsUsageSizeInBytes, scratchMemUsageInBytes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ShaderResourceUsageAMD const & ) const = default; +#else + bool operator==( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( numUsedVgprs == rhs.numUsedVgprs ) && ( numUsedSgprs == rhs.numUsedSgprs ) && ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) && + ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) && ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes ); +# endif + } + + bool operator!=( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t numUsedVgprs = {}; + uint32_t numUsedSgprs = {}; + uint32_t ldsSizePerLocalWorkGroup = {}; + size_t ldsUsageSizeInBytes = {}; + size_t scratchMemUsageInBytes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ShaderResourceUsageAMD; + }; +#endif + + // wrapper struct for struct VkShaderStatisticsInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderStatisticsInfoAMD.html + struct ShaderStatisticsInfoAMD + { + using NativeType = VkShaderStatisticsInfoAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 ShaderStatisticsInfoAMD( ShaderStageFlags shaderStageMask_ = {}, + ShaderResourceUsageAMD resourceUsage_ = {}, + uint32_t numPhysicalVgprs_ = {}, + uint32_t numPhysicalSgprs_ = {}, + uint32_t numAvailableVgprs_ = {}, + uint32_t numAvailableSgprs_ = {}, + std::array const & computeWorkGroupSize_ = {} ) VULKAN_HPP_NOEXCEPT + : shaderStageMask{ shaderStageMask_ } + , resourceUsage{ resourceUsage_ } + , numPhysicalVgprs{ numPhysicalVgprs_ } + , numPhysicalSgprs{ numPhysicalSgprs_ } + , numAvailableVgprs{ numAvailableVgprs_ } + , numAvailableSgprs{ numAvailableSgprs_ } + , computeWorkGroupSize{ computeWorkGroupSize_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 ShaderStatisticsInfoAMD( ShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ShaderStatisticsInfoAMD( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : ShaderStatisticsInfoAMD( *reinterpret_cast( &rhs ) ) + { + } + + ShaderStatisticsInfoAMD & operator=( ShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ShaderStatisticsInfoAMD & operator=( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkShaderStatisticsInfoAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderStatisticsInfoAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderStatisticsInfoAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkShaderStatisticsInfoAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( shaderStageMask, resourceUsage, numPhysicalVgprs, numPhysicalSgprs, numAvailableVgprs, numAvailableSgprs, computeWorkGroupSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ShaderStatisticsInfoAMD const & ) const = default; +#else + bool operator==( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( shaderStageMask == rhs.shaderStageMask ) && ( resourceUsage == rhs.resourceUsage ) && ( numPhysicalVgprs == rhs.numPhysicalVgprs ) && + ( numPhysicalSgprs == rhs.numPhysicalSgprs ) && ( numAvailableVgprs == rhs.numAvailableVgprs ) && ( numAvailableSgprs == rhs.numAvailableSgprs ) && + ( computeWorkGroupSize == rhs.computeWorkGroupSize ); +# endif + } + + bool operator!=( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ShaderStageFlags shaderStageMask = {}; + ShaderResourceUsageAMD resourceUsage = {}; + uint32_t numPhysicalVgprs = {}; + uint32_t numPhysicalSgprs = {}; + uint32_t numAvailableVgprs = {}; + uint32_t numAvailableSgprs = {}; + ArrayWrapper1D computeWorkGroupSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ShaderStatisticsInfoAMD; + }; +#endif + + // wrapper struct for struct VkSharedPresentSurfaceCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSharedPresentSurfaceCapabilitiesKHR.html + struct SharedPresentSurfaceCapabilitiesKHR + { + using NativeType = VkSharedPresentSurfaceCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SharedPresentSurfaceCapabilitiesKHR( ImageUsageFlags sharedPresentSupportedUsageFlags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , sharedPresentSupportedUsageFlags{ sharedPresentSupportedUsageFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR SharedPresentSurfaceCapabilitiesKHR( SharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SharedPresentSurfaceCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + SharedPresentSurfaceCapabilitiesKHR & operator=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SharedPresentSurfaceCapabilitiesKHR & operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSharedPresentSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSharedPresentSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSharedPresentSurfaceCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSharedPresentSurfaceCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, sharedPresentSupportedUsageFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SharedPresentSurfaceCapabilitiesKHR const & ) const = default; +#else + bool operator==( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags ); +# endif + } + + bool operator!=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; + void * pNext = {}; + ImageUsageFlags sharedPresentSupportedUsageFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SharedPresentSurfaceCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = SharedPresentSurfaceCapabilitiesKHR; + }; + + // wrapper struct for struct VkSparseImageFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageFormatProperties.html + struct SparseImageFormatProperties + { + using NativeType = VkSparseImageFormatProperties; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + SparseImageFormatProperties( ImageAspectFlags aspectMask_ = {}, Extent3D imageGranularity_ = {}, SparseImageFormatFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT + : aspectMask{ aspectMask_ } + , imageGranularity{ imageGranularity_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR SparseImageFormatProperties( SparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SparseImageFormatProperties( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + : SparseImageFormatProperties( *reinterpret_cast( &rhs ) ) + { + } + + SparseImageFormatProperties & operator=( SparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SparseImageFormatProperties & operator=( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSparseImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageFormatProperties &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageFormatProperties const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSparseImageFormatProperties *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( aspectMask, imageGranularity, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SparseImageFormatProperties const & ) const = default; +#else + bool operator==( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( aspectMask == rhs.aspectMask ) && ( imageGranularity == rhs.imageGranularity ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + ImageAspectFlags aspectMask = {}; + Extent3D imageGranularity = {}; + SparseImageFormatFlags flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SparseImageFormatProperties; + }; +#endif + + // wrapper struct for struct VkSparseImageFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageFormatProperties2.html + struct SparseImageFormatProperties2 + { + using NativeType = VkSparseImageFormatProperties2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSparseImageFormatProperties2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SparseImageFormatProperties2( SparseImageFormatProperties properties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , properties{ properties_ } + { + } + + VULKAN_HPP_CONSTEXPR SparseImageFormatProperties2( SparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + : SparseImageFormatProperties2( *reinterpret_cast( &rhs ) ) + { + } + + SparseImageFormatProperties2 & operator=( SparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SparseImageFormatProperties2 & operator=( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSparseImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageFormatProperties2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSparseImageFormatProperties2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, properties ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SparseImageFormatProperties2 const & ) const = default; +#else + bool operator==( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); +# endif + } + + bool operator!=( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSparseImageFormatProperties2; + void * pNext = {}; + SparseImageFormatProperties properties = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SparseImageFormatProperties2; + }; +#endif + + template <> + struct CppType + { + using Type = SparseImageFormatProperties2; + }; + + using SparseImageFormatProperties2KHR = SparseImageFormatProperties2; + + // wrapper struct for struct VkSparseImageMemoryRequirements, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageMemoryRequirements.html + struct SparseImageMemoryRequirements + { + using NativeType = VkSparseImageMemoryRequirements; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements( SparseImageFormatProperties formatProperties_ = {}, + uint32_t imageMipTailFirstLod_ = {}, + DeviceSize imageMipTailSize_ = {}, + DeviceSize imageMipTailOffset_ = {}, + DeviceSize imageMipTailStride_ = {} ) VULKAN_HPP_NOEXCEPT + : formatProperties{ formatProperties_ } + , imageMipTailFirstLod{ imageMipTailFirstLod_ } + , imageMipTailSize{ imageMipTailSize_ } + , imageMipTailOffset{ imageMipTailOffset_ } + , imageMipTailStride{ imageMipTailStride_ } + { + } + + VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements( SparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SparseImageMemoryRequirements( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT + : SparseImageMemoryRequirements( *reinterpret_cast( &rhs ) ) + { + } + + SparseImageMemoryRequirements & operator=( SparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SparseImageMemoryRequirements & operator=( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSparseImageMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryRequirements &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryRequirements const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSparseImageMemoryRequirements *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( formatProperties, imageMipTailFirstLod, imageMipTailSize, imageMipTailOffset, imageMipTailStride ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SparseImageMemoryRequirements const & ) const = default; +#else + bool operator==( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( formatProperties == rhs.formatProperties ) && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) && + ( imageMipTailSize == rhs.imageMipTailSize ) && ( imageMipTailOffset == rhs.imageMipTailOffset ) && + ( imageMipTailStride == rhs.imageMipTailStride ); +# endif + } + + bool operator!=( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + SparseImageFormatProperties formatProperties = {}; + uint32_t imageMipTailFirstLod = {}; + DeviceSize imageMipTailSize = {}; + DeviceSize imageMipTailOffset = {}; + DeviceSize imageMipTailStride = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SparseImageMemoryRequirements; + }; +#endif + + // wrapper struct for struct VkSparseImageMemoryRequirements2, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageMemoryRequirements2.html + struct SparseImageMemoryRequirements2 + { + using NativeType = VkSparseImageMemoryRequirements2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSparseImageMemoryRequirements2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements2( SparseImageMemoryRequirements memoryRequirements_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryRequirements{ memoryRequirements_ } + { + } + + VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements2( SparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT + : SparseImageMemoryRequirements2( *reinterpret_cast( &rhs ) ) + { + } + + SparseImageMemoryRequirements2 & operator=( SparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SparseImageMemoryRequirements2 & operator=( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSparseImageMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSparseImageMemoryRequirements2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSparseImageMemoryRequirements2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryRequirements ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SparseImageMemoryRequirements2 const & ) const = default; +#else + bool operator==( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements ); +# endif + } + + bool operator!=( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSparseImageMemoryRequirements2; + void * pNext = {}; + SparseImageMemoryRequirements memoryRequirements = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SparseImageMemoryRequirements2; + }; +#endif + + template <> + struct CppType + { + using Type = SparseImageMemoryRequirements2; + }; + + using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; + +#if defined( VK_USE_PLATFORM_GGP ) + // wrapper struct for struct VkStreamDescriptorSurfaceCreateInfoGGP, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkStreamDescriptorSurfaceCreateInfoGGP.html + struct StreamDescriptorSurfaceCreateInfoGGP + { + using NativeType = VkStreamDescriptorSurfaceCreateInfoGGP; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( StreamDescriptorSurfaceCreateFlagsGGP flags_ = {}, + GgpStreamDescriptor streamDescriptor_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , streamDescriptor{ streamDescriptor_ } + { + } + + VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT + : StreamDescriptorSurfaceCreateInfoGGP( *reinterpret_cast( &rhs ) ) + { + } + + StreamDescriptorSurfaceCreateInfoGGP & operator=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + StreamDescriptorSurfaceCreateInfoGGP & operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP & setFlags( StreamDescriptorSurfaceCreateFlagsGGP flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP && setFlags( StreamDescriptorSurfaceCreateFlagsGGP flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP & setStreamDescriptor( GgpStreamDescriptor streamDescriptor_ ) & VULKAN_HPP_NOEXCEPT + { + streamDescriptor = streamDescriptor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP && setStreamDescriptor( GgpStreamDescriptor streamDescriptor_ ) && VULKAN_HPP_NOEXCEPT + { + streamDescriptor = streamDescriptor_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkStreamDescriptorSurfaceCreateInfoGGP const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStreamDescriptorSurfaceCreateInfoGGP &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkStreamDescriptorSurfaceCreateInfoGGP const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkStreamDescriptorSurfaceCreateInfoGGP *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, streamDescriptor ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &streamDescriptor, &rhs.streamDescriptor, sizeof( GgpStreamDescriptor ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( memcmp( &streamDescriptor, &rhs.streamDescriptor, sizeof( GgpStreamDescriptor ) ) == 0 ); + } + + bool operator!=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; + const void * pNext = {}; + StreamDescriptorSurfaceCreateFlagsGGP flags = {}; + GgpStreamDescriptor streamDescriptor = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = StreamDescriptorSurfaceCreateInfoGGP; + }; +# endif + + template <> + struct CppType + { + using Type = StreamDescriptorSurfaceCreateInfoGGP; + }; +#endif /*VK_USE_PLATFORM_GGP*/ + + // wrapper struct for struct VkSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitInfo.html + struct SubmitInfo + { + using NativeType = VkSubmitInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubmitInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = {}, + const Semaphore * pWaitSemaphores_ = {}, + const PipelineStageFlags * pWaitDstStageMask_ = {}, + uint32_t commandBufferCount_ = {}, + const CommandBuffer * pCommandBuffers_ = {}, + uint32_t signalSemaphoreCount_ = {}, + const Semaphore * pSignalSemaphores_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , waitSemaphoreCount{ waitSemaphoreCount_ } + , pWaitSemaphores{ pWaitSemaphores_ } + , pWaitDstStageMask{ pWaitDstStageMask_ } + , commandBufferCount{ commandBufferCount_ } + , pCommandBuffers{ pCommandBuffers_ } + , signalSemaphoreCount{ signalSemaphoreCount_ } + , pSignalSemaphores{ pSignalSemaphores_ } + { + } + + VULKAN_HPP_CONSTEXPR SubmitInfo( SubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubmitInfo( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SubmitInfo( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubmitInfo( ArrayProxyNoTemporaries const & waitSemaphores_, + ArrayProxyNoTemporaries const & waitDstStageMask_ = {}, + ArrayProxyNoTemporaries const & commandBuffers_ = {}, + ArrayProxyNoTemporaries const & signalSemaphores_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , waitSemaphoreCount( static_cast( waitSemaphores_.size() ) ) + , pWaitSemaphores( waitSemaphores_.data() ) + , pWaitDstStageMask( waitDstStageMask_.data() ) + , commandBufferCount( static_cast( commandBuffers_.size() ) ) + , pCommandBuffers( commandBuffers_.data() ) + , signalSemaphoreCount( static_cast( signalSemaphores_.size() ) ) + , pSignalSemaphores( signalSemaphores_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( waitSemaphores_.size() == waitDstStageMask_.size() ); +# else + if ( waitSemaphores_.size() != waitDstStageMask_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::SubmitInfo::SubmitInfo: waitSemaphores_.size() != waitDstStageMask_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SubmitInfo & operator=( SubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubmitInfo & operator=( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = waitSemaphoreCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = waitSemaphoreCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) & VULKAN_HPP_NOEXCEPT + { + pWaitSemaphores = pWaitSemaphores_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) && VULKAN_HPP_NOEXCEPT + { + pWaitSemaphores = pWaitSemaphores_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubmitInfo & setWaitSemaphores( ArrayProxyNoTemporaries const & waitSemaphores_ ) VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = static_cast( waitSemaphores_.size() ); + pWaitSemaphores = waitSemaphores_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setPWaitDstStageMask( const PipelineStageFlags * pWaitDstStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + pWaitDstStageMask = pWaitDstStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setPWaitDstStageMask( const PipelineStageFlags * pWaitDstStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + pWaitDstStageMask = pWaitDstStageMask_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubmitInfo & setWaitDstStageMask( ArrayProxyNoTemporaries const & waitDstStageMask_ ) VULKAN_HPP_NOEXCEPT + { + waitSemaphoreCount = static_cast( waitDstStageMask_.size() ); + pWaitDstStageMask = waitDstStageMask_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setCommandBufferCount( uint32_t commandBufferCount_ ) & VULKAN_HPP_NOEXCEPT + { + commandBufferCount = commandBufferCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setCommandBufferCount( uint32_t commandBufferCount_ ) && VULKAN_HPP_NOEXCEPT + { + commandBufferCount = commandBufferCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setPCommandBuffers( const CommandBuffer * pCommandBuffers_ ) & VULKAN_HPP_NOEXCEPT + { + pCommandBuffers = pCommandBuffers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setPCommandBuffers( const CommandBuffer * pCommandBuffers_ ) && VULKAN_HPP_NOEXCEPT + { + pCommandBuffers = pCommandBuffers_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubmitInfo & setCommandBuffers( ArrayProxyNoTemporaries const & commandBuffers_ ) VULKAN_HPP_NOEXCEPT + { + commandBufferCount = static_cast( commandBuffers_.size() ); + pCommandBuffers = commandBuffers_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT + { + signalSemaphoreCount = signalSemaphoreCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT + { + signalSemaphoreCount = signalSemaphoreCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setPSignalSemaphores( const Semaphore * pSignalSemaphores_ ) & VULKAN_HPP_NOEXCEPT + { + pSignalSemaphores = pSignalSemaphores_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setPSignalSemaphores( const Semaphore * pSignalSemaphores_ ) && VULKAN_HPP_NOEXCEPT + { + pSignalSemaphores = pSignalSemaphores_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubmitInfo & setSignalSemaphores( ArrayProxyNoTemporaries const & signalSemaphores_ ) VULKAN_HPP_NOEXCEPT + { + signalSemaphoreCount = static_cast( signalSemaphores_.size() ); + pSignalSemaphores = signalSemaphores_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubmitInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubmitInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubmitInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubmitInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, waitSemaphoreCount, pWaitSemaphores, pWaitDstStageMask, commandBufferCount, pCommandBuffers, signalSemaphoreCount, pSignalSemaphores ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubmitInfo const & ) const = default; +#else + bool operator==( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && + ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( pWaitDstStageMask == rhs.pWaitDstStageMask ) && ( commandBufferCount == rhs.commandBufferCount ) && + ( pCommandBuffers == rhs.pCommandBuffers ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && + ( pSignalSemaphores == rhs.pSignalSemaphores ); +# endif + } + + bool operator!=( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubmitInfo; + const void * pNext = {}; + uint32_t waitSemaphoreCount = {}; + const Semaphore * pWaitSemaphores = {}; + const PipelineStageFlags * pWaitDstStageMask = {}; + uint32_t commandBufferCount = {}; + const CommandBuffer * pCommandBuffers = {}; + uint32_t signalSemaphoreCount = {}; + const Semaphore * pSignalSemaphores = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubmitInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SubmitInfo; + }; + + // wrapper struct for struct VkSubmitInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitInfo2.html + struct SubmitInfo2 + { + using NativeType = VkSubmitInfo2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubmitInfo2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubmitInfo2( SubmitFlags flags_ = {}, + uint32_t waitSemaphoreInfoCount_ = {}, + const SemaphoreSubmitInfo * pWaitSemaphoreInfos_ = {}, + uint32_t commandBufferInfoCount_ = {}, + const CommandBufferSubmitInfo * pCommandBufferInfos_ = {}, + uint32_t signalSemaphoreInfoCount_ = {}, + const SemaphoreSubmitInfo * pSignalSemaphoreInfos_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , waitSemaphoreInfoCount{ waitSemaphoreInfoCount_ } + , pWaitSemaphoreInfos{ pWaitSemaphoreInfos_ } + , commandBufferInfoCount{ commandBufferInfoCount_ } + , pCommandBufferInfos{ pCommandBufferInfos_ } + , signalSemaphoreInfoCount{ signalSemaphoreInfoCount_ } + , pSignalSemaphoreInfos{ pSignalSemaphoreInfos_ } + { + } + + VULKAN_HPP_CONSTEXPR SubmitInfo2( SubmitInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubmitInfo2( VkSubmitInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : SubmitInfo2( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubmitInfo2( SubmitFlags flags_, + ArrayProxyNoTemporaries const & waitSemaphoreInfos_, + ArrayProxyNoTemporaries const & commandBufferInfos_ = {}, + ArrayProxyNoTemporaries const & signalSemaphoreInfos_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , waitSemaphoreInfoCount( static_cast( waitSemaphoreInfos_.size() ) ) + , pWaitSemaphoreInfos( waitSemaphoreInfos_.data() ) + , commandBufferInfoCount( static_cast( commandBufferInfos_.size() ) ) + , pCommandBufferInfos( commandBufferInfos_.data() ) + , signalSemaphoreInfoCount( static_cast( signalSemaphoreInfos_.size() ) ) + , pSignalSemaphoreInfos( signalSemaphoreInfos_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SubmitInfo2 & operator=( SubmitInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubmitInfo2 & operator=( VkSubmitInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setFlags( SubmitFlags flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setFlags( SubmitFlags flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setWaitSemaphoreInfoCount( uint32_t waitSemaphoreInfoCount_ ) & VULKAN_HPP_NOEXCEPT + { + waitSemaphoreInfoCount = waitSemaphoreInfoCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setWaitSemaphoreInfoCount( uint32_t waitSemaphoreInfoCount_ ) && VULKAN_HPP_NOEXCEPT + { + waitSemaphoreInfoCount = waitSemaphoreInfoCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setPWaitSemaphoreInfos( const SemaphoreSubmitInfo * pWaitSemaphoreInfos_ ) & VULKAN_HPP_NOEXCEPT + { + pWaitSemaphoreInfos = pWaitSemaphoreInfos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setPWaitSemaphoreInfos( const SemaphoreSubmitInfo * pWaitSemaphoreInfos_ ) && VULKAN_HPP_NOEXCEPT + { + pWaitSemaphoreInfos = pWaitSemaphoreInfos_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubmitInfo2 & setWaitSemaphoreInfos( ArrayProxyNoTemporaries const & waitSemaphoreInfos_ ) VULKAN_HPP_NOEXCEPT + { + waitSemaphoreInfoCount = static_cast( waitSemaphoreInfos_.size() ); + pWaitSemaphoreInfos = waitSemaphoreInfos_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setCommandBufferInfoCount( uint32_t commandBufferInfoCount_ ) & VULKAN_HPP_NOEXCEPT + { + commandBufferInfoCount = commandBufferInfoCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setCommandBufferInfoCount( uint32_t commandBufferInfoCount_ ) && VULKAN_HPP_NOEXCEPT + { + commandBufferInfoCount = commandBufferInfoCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setPCommandBufferInfos( const CommandBufferSubmitInfo * pCommandBufferInfos_ ) & VULKAN_HPP_NOEXCEPT + { + pCommandBufferInfos = pCommandBufferInfos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setPCommandBufferInfos( const CommandBufferSubmitInfo * pCommandBufferInfos_ ) && VULKAN_HPP_NOEXCEPT + { + pCommandBufferInfos = pCommandBufferInfos_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubmitInfo2 & setCommandBufferInfos( ArrayProxyNoTemporaries const & commandBufferInfos_ ) VULKAN_HPP_NOEXCEPT + { + commandBufferInfoCount = static_cast( commandBufferInfos_.size() ); + pCommandBufferInfos = commandBufferInfos_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setSignalSemaphoreInfoCount( uint32_t signalSemaphoreInfoCount_ ) & VULKAN_HPP_NOEXCEPT + { + signalSemaphoreInfoCount = signalSemaphoreInfoCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setSignalSemaphoreInfoCount( uint32_t signalSemaphoreInfoCount_ ) && VULKAN_HPP_NOEXCEPT + { + signalSemaphoreInfoCount = signalSemaphoreInfoCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setPSignalSemaphoreInfos( const SemaphoreSubmitInfo * pSignalSemaphoreInfos_ ) & VULKAN_HPP_NOEXCEPT + { + pSignalSemaphoreInfos = pSignalSemaphoreInfos_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setPSignalSemaphoreInfos( const SemaphoreSubmitInfo * pSignalSemaphoreInfos_ ) && VULKAN_HPP_NOEXCEPT + { + pSignalSemaphoreInfos = pSignalSemaphoreInfos_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SubmitInfo2 & setSignalSemaphoreInfos( ArrayProxyNoTemporaries const & signalSemaphoreInfos_ ) VULKAN_HPP_NOEXCEPT + { + signalSemaphoreInfoCount = static_cast( signalSemaphoreInfos_.size() ); + pSignalSemaphoreInfos = signalSemaphoreInfos_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubmitInfo2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubmitInfo2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubmitInfo2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubmitInfo2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + waitSemaphoreInfoCount, + pWaitSemaphoreInfos, + commandBufferInfoCount, + pCommandBufferInfos, + signalSemaphoreInfoCount, + pSignalSemaphoreInfos ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubmitInfo2 const & ) const = default; +#else + bool operator==( SubmitInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( waitSemaphoreInfoCount == rhs.waitSemaphoreInfoCount ) && + ( pWaitSemaphoreInfos == rhs.pWaitSemaphoreInfos ) && ( commandBufferInfoCount == rhs.commandBufferInfoCount ) && + ( pCommandBufferInfos == rhs.pCommandBufferInfos ) && ( signalSemaphoreInfoCount == rhs.signalSemaphoreInfoCount ) && + ( pSignalSemaphoreInfos == rhs.pSignalSemaphoreInfos ); +# endif + } + + bool operator!=( SubmitInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubmitInfo2; + const void * pNext = {}; + SubmitFlags flags = {}; + uint32_t waitSemaphoreInfoCount = {}; + const SemaphoreSubmitInfo * pWaitSemaphoreInfos = {}; + uint32_t commandBufferInfoCount = {}; + const CommandBufferSubmitInfo * pCommandBufferInfos = {}; + uint32_t signalSemaphoreInfoCount = {}; + const SemaphoreSubmitInfo * pSignalSemaphoreInfos = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubmitInfo2; + }; +#endif + + template <> + struct CppType + { + using Type = SubmitInfo2; + }; + + using SubmitInfo2KHR = SubmitInfo2; + + // wrapper struct for struct VkSubpassBeginInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassBeginInfo.html + struct SubpassBeginInfo + { + using NativeType = VkSubpassBeginInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassBeginInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubpassBeginInfo( SubpassContents contents_ = SubpassContents::eInline, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , contents{ contents_ } + { + } + + VULKAN_HPP_CONSTEXPR SubpassBeginInfo( SubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassBeginInfo( VkSubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassBeginInfo( *reinterpret_cast( &rhs ) ) {} + + SubpassBeginInfo & operator=( SubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubpassBeginInfo & operator=( VkSubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubpassBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassBeginInfo & setContents( SubpassContents contents_ ) & VULKAN_HPP_NOEXCEPT + { + contents = contents_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassBeginInfo && setContents( SubpassContents contents_ ) && VULKAN_HPP_NOEXCEPT + { + contents = contents_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubpassBeginInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassBeginInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassBeginInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubpassBeginInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, contents ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubpassBeginInfo const & ) const = default; +#else + bool operator==( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( contents == rhs.contents ); +# endif + } + + bool operator!=( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubpassBeginInfo; + const void * pNext = {}; + SubpassContents contents = SubpassContents::eInline; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubpassBeginInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SubpassBeginInfo; + }; + + using SubpassBeginInfoKHR = SubpassBeginInfo; + + // wrapper struct for struct VkSubpassDescriptionDepthStencilResolve, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescriptionDepthStencilResolve.html + struct SubpassDescriptionDepthStencilResolve + { + using NativeType = VkSubpassDescriptionDepthStencilResolve; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDescriptionDepthStencilResolve; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolve( ResolveModeFlagBits depthResolveMode_ = ResolveModeFlagBits::eNone, + ResolveModeFlagBits stencilResolveMode_ = ResolveModeFlagBits::eNone, + const AttachmentReference2 * pDepthStencilResolveAttachment_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , depthResolveMode{ depthResolveMode_ } + , stencilResolveMode{ stencilResolveMode_ } + , pDepthStencilResolveAttachment{ pDepthStencilResolveAttachment_ } + { + } + + VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolve( SubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassDescriptionDepthStencilResolve( VkSubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT + : SubpassDescriptionDepthStencilResolve( *reinterpret_cast( &rhs ) ) + { + } + + SubpassDescriptionDepthStencilResolve & operator=( SubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubpassDescriptionDepthStencilResolve & operator=( VkSubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve & setDepthResolveMode( ResolveModeFlagBits depthResolveMode_ ) & VULKAN_HPP_NOEXCEPT + { + depthResolveMode = depthResolveMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve && setDepthResolveMode( ResolveModeFlagBits depthResolveMode_ ) && VULKAN_HPP_NOEXCEPT + { + depthResolveMode = depthResolveMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve & setStencilResolveMode( ResolveModeFlagBits stencilResolveMode_ ) & VULKAN_HPP_NOEXCEPT + { + stencilResolveMode = stencilResolveMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve && setStencilResolveMode( ResolveModeFlagBits stencilResolveMode_ ) && VULKAN_HPP_NOEXCEPT + { + stencilResolveMode = stencilResolveMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve & + setPDepthStencilResolveAttachment( const AttachmentReference2 * pDepthStencilResolveAttachment_ ) & + VULKAN_HPP_NOEXCEPT + { + pDepthStencilResolveAttachment = pDepthStencilResolveAttachment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve && + setPDepthStencilResolveAttachment( const AttachmentReference2 * pDepthStencilResolveAttachment_ ) && + VULKAN_HPP_NOEXCEPT + { + pDepthStencilResolveAttachment = pDepthStencilResolveAttachment_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubpassDescriptionDepthStencilResolve const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDescriptionDepthStencilResolve &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassDescriptionDepthStencilResolve const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubpassDescriptionDepthStencilResolve *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, depthResolveMode, stencilResolveMode, pDepthStencilResolveAttachment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubpassDescriptionDepthStencilResolve const & ) const = default; +#else + bool operator==( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthResolveMode == rhs.depthResolveMode ) && + ( stencilResolveMode == rhs.stencilResolveMode ) && ( pDepthStencilResolveAttachment == rhs.pDepthStencilResolveAttachment ); +# endif + } + + bool operator!=( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolve; + const void * pNext = {}; + ResolveModeFlagBits depthResolveMode = ResolveModeFlagBits::eNone; + ResolveModeFlagBits stencilResolveMode = ResolveModeFlagBits::eNone; + const AttachmentReference2 * pDepthStencilResolveAttachment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubpassDescriptionDepthStencilResolve; + }; +#endif + + template <> + struct CppType + { + using Type = SubpassDescriptionDepthStencilResolve; + }; + + using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve; + + // wrapper struct for struct VkSubpassEndInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassEndInfo.html + struct SubpassEndInfo + { + using NativeType = VkSubpassEndInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassEndInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubpassEndInfo( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} + + VULKAN_HPP_CONSTEXPR SubpassEndInfo( SubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassEndInfo( VkSubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassEndInfo( *reinterpret_cast( &rhs ) ) {} + + SubpassEndInfo & operator=( SubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubpassEndInfo & operator=( VkSubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubpassEndInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassEndInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubpassEndInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassEndInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassEndInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubpassEndInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubpassEndInfo const & ) const = default; +#else + bool operator==( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubpassEndInfo; + const void * pNext = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubpassEndInfo; + }; +#endif + + template <> + struct CppType + { + using Type = SubpassEndInfo; + }; + + using SubpassEndInfoKHR = SubpassEndInfo; + + // wrapper struct for struct VkSubpassResolvePerformanceQueryEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassResolvePerformanceQueryEXT.html + struct SubpassResolvePerformanceQueryEXT + { + using NativeType = VkSubpassResolvePerformanceQueryEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassResolvePerformanceQueryEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubpassResolvePerformanceQueryEXT( Bool32 optimal_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , optimal{ optimal_ } + { + } + + VULKAN_HPP_CONSTEXPR SubpassResolvePerformanceQueryEXT( SubpassResolvePerformanceQueryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassResolvePerformanceQueryEXT( VkSubpassResolvePerformanceQueryEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SubpassResolvePerformanceQueryEXT( *reinterpret_cast( &rhs ) ) + { + } + + SubpassResolvePerformanceQueryEXT & operator=( SubpassResolvePerformanceQueryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubpassResolvePerformanceQueryEXT & operator=( VkSubpassResolvePerformanceQueryEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSubpassResolvePerformanceQueryEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassResolvePerformanceQueryEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassResolvePerformanceQueryEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubpassResolvePerformanceQueryEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, optimal ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubpassResolvePerformanceQueryEXT const & ) const = default; +#else + bool operator==( SubpassResolvePerformanceQueryEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( optimal == rhs.optimal ); +# endif + } + + bool operator!=( SubpassResolvePerformanceQueryEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubpassResolvePerformanceQueryEXT; + void * pNext = {}; + Bool32 optimal = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubpassResolvePerformanceQueryEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SubpassResolvePerformanceQueryEXT; + }; + + // wrapper struct for struct VkSubpassShadingPipelineCreateInfoHUAWEI, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassShadingPipelineCreateInfoHUAWEI.html + struct SubpassShadingPipelineCreateInfoHUAWEI + { + using NativeType = VkSubpassShadingPipelineCreateInfoHUAWEI; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassShadingPipelineCreateInfoHUAWEI; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + SubpassShadingPipelineCreateInfoHUAWEI( RenderPass renderPass_ = {}, uint32_t subpass_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , renderPass{ renderPass_ } + , subpass{ subpass_ } + { + } + + VULKAN_HPP_CONSTEXPR SubpassShadingPipelineCreateInfoHUAWEI( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubpassShadingPipelineCreateInfoHUAWEI( VkSubpassShadingPipelineCreateInfoHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + : SubpassShadingPipelineCreateInfoHUAWEI( *reinterpret_cast( &rhs ) ) + { + } + + SubpassShadingPipelineCreateInfoHUAWEI & operator=( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubpassShadingPipelineCreateInfoHUAWEI & operator=( VkSubpassShadingPipelineCreateInfoHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI & setRenderPass( RenderPass renderPass_ ) & VULKAN_HPP_NOEXCEPT + { + renderPass = renderPass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI && setRenderPass( RenderPass renderPass_ ) && VULKAN_HPP_NOEXCEPT + { + renderPass = renderPass_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI & setSubpass( uint32_t subpass_ ) & VULKAN_HPP_NOEXCEPT + { + subpass = subpass_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI && setSubpass( uint32_t subpass_ ) && VULKAN_HPP_NOEXCEPT + { + subpass = subpass_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubpassShadingPipelineCreateInfoHUAWEI const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassShadingPipelineCreateInfoHUAWEI &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubpassShadingPipelineCreateInfoHUAWEI const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubpassShadingPipelineCreateInfoHUAWEI *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, renderPass, subpass ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubpassShadingPipelineCreateInfoHUAWEI const & ) const = default; +#else + bool operator==( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && ( subpass == rhs.subpass ); +# endif + } + + bool operator!=( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubpassShadingPipelineCreateInfoHUAWEI; + void * pNext = {}; + RenderPass renderPass = {}; + uint32_t subpass = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubpassShadingPipelineCreateInfoHUAWEI; + }; +#endif + + template <> + struct CppType + { + using Type = SubpassShadingPipelineCreateInfoHUAWEI; + }; + + // wrapper struct for struct VkSubresourceHostMemcpySize, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubresourceHostMemcpySize.html + struct SubresourceHostMemcpySize + { + using NativeType = VkSubresourceHostMemcpySize; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubresourceHostMemcpySize; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubresourceHostMemcpySize( DeviceSize size_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR SubresourceHostMemcpySize( SubresourceHostMemcpySize const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubresourceHostMemcpySize( VkSubresourceHostMemcpySize const & rhs ) VULKAN_HPP_NOEXCEPT + : SubresourceHostMemcpySize( *reinterpret_cast( &rhs ) ) + { + } + + SubresourceHostMemcpySize & operator=( SubresourceHostMemcpySize const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubresourceHostMemcpySize & operator=( VkSubresourceHostMemcpySize const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSubresourceHostMemcpySize const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubresourceHostMemcpySize &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubresourceHostMemcpySize const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubresourceHostMemcpySize *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubresourceHostMemcpySize const & ) const = default; +#else + bool operator==( SubresourceHostMemcpySize const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( size == rhs.size ); +# endif + } + + bool operator!=( SubresourceHostMemcpySize const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubresourceHostMemcpySize; + void * pNext = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubresourceHostMemcpySize; + }; +#endif + + template <> + struct CppType + { + using Type = SubresourceHostMemcpySize; + }; + + using SubresourceHostMemcpySizeEXT = SubresourceHostMemcpySize; + + // wrapper struct for struct VkSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubresourceLayout2.html + struct SubresourceLayout2 + { + using NativeType = VkSubresourceLayout2; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubresourceLayout2; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubresourceLayout2( SubresourceLayout subresourceLayout_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , subresourceLayout{ subresourceLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR SubresourceLayout2( SubresourceLayout2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubresourceLayout2( VkSubresourceLayout2 const & rhs ) VULKAN_HPP_NOEXCEPT : SubresourceLayout2( *reinterpret_cast( &rhs ) ) {} + + SubresourceLayout2 & operator=( SubresourceLayout2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubresourceLayout2 & operator=( VkSubresourceLayout2 const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSubresourceLayout2 const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubresourceLayout2 &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubresourceLayout2 const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubresourceLayout2 *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subresourceLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubresourceLayout2 const & ) const = default; +#else + bool operator==( SubresourceLayout2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subresourceLayout == rhs.subresourceLayout ); +# endif + } + + bool operator!=( SubresourceLayout2 const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubresourceLayout2; + void * pNext = {}; + SubresourceLayout subresourceLayout = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubresourceLayout2; + }; +#endif + + template <> + struct CppType + { + using Type = SubresourceLayout2; + }; + + using SubresourceLayout2EXT = SubresourceLayout2; + using SubresourceLayout2KHR = SubresourceLayout2; + + // wrapper struct for struct VkSubsampledImageFormatPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubsampledImageFormatPropertiesEXT.html + struct SubsampledImageFormatPropertiesEXT + { + using NativeType = VkSubsampledImageFormatPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubsampledImageFormatPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SubsampledImageFormatPropertiesEXT( uint32_t subsampledImageDescriptorCount_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , subsampledImageDescriptorCount{ subsampledImageDescriptorCount_ } + { + } + + VULKAN_HPP_CONSTEXPR SubsampledImageFormatPropertiesEXT( SubsampledImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SubsampledImageFormatPropertiesEXT( VkSubsampledImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SubsampledImageFormatPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + SubsampledImageFormatPropertiesEXT & operator=( SubsampledImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SubsampledImageFormatPropertiesEXT & operator=( VkSubsampledImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SubsampledImageFormatPropertiesEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubsampledImageFormatPropertiesEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SubsampledImageFormatPropertiesEXT & setSubsampledImageDescriptorCount( uint32_t subsampledImageDescriptorCount_ ) & + VULKAN_HPP_NOEXCEPT + { + subsampledImageDescriptorCount = subsampledImageDescriptorCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SubsampledImageFormatPropertiesEXT && setSubsampledImageDescriptorCount( uint32_t subsampledImageDescriptorCount_ ) && + VULKAN_HPP_NOEXCEPT + { + subsampledImageDescriptorCount = subsampledImageDescriptorCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSubsampledImageFormatPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubsampledImageFormatPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSubsampledImageFormatPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSubsampledImageFormatPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, subsampledImageDescriptorCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SubsampledImageFormatPropertiesEXT const & ) const = default; +#else + bool operator==( SubsampledImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledImageDescriptorCount == rhs.subsampledImageDescriptorCount ); +# endif + } + + bool operator!=( SubsampledImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSubsampledImageFormatPropertiesEXT; + const void * pNext = {}; + uint32_t subsampledImageDescriptorCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SubsampledImageFormatPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SubsampledImageFormatPropertiesEXT; + }; + + // wrapper struct for struct VkSurfaceCapabilities2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilities2EXT.html + struct SurfaceCapabilities2EXT + { + using NativeType = VkSurfaceCapabilities2EXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilities2EXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceCapabilities2EXT( uint32_t minImageCount_ = {}, + uint32_t maxImageCount_ = {}, + Extent2D currentExtent_ = {}, + Extent2D minImageExtent_ = {}, + Extent2D maxImageExtent_ = {}, + uint32_t maxImageArrayLayers_ = {}, + SurfaceTransformFlagsKHR supportedTransforms_ = {}, + SurfaceTransformFlagBitsKHR currentTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, + CompositeAlphaFlagsKHR supportedCompositeAlpha_ = {}, + ImageUsageFlags supportedUsageFlags_ = {}, + SurfaceCounterFlagsEXT supportedSurfaceCounters_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minImageCount{ minImageCount_ } + , maxImageCount{ maxImageCount_ } + , currentExtent{ currentExtent_ } + , minImageExtent{ minImageExtent_ } + , maxImageExtent{ maxImageExtent_ } + , maxImageArrayLayers{ maxImageArrayLayers_ } + , supportedTransforms{ supportedTransforms_ } + , currentTransform{ currentTransform_ } + , supportedCompositeAlpha{ supportedCompositeAlpha_ } + , supportedUsageFlags{ supportedUsageFlags_ } + , supportedSurfaceCounters{ supportedSurfaceCounters_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceCapabilities2EXT( SurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfaceCapabilities2EXT( *reinterpret_cast( &rhs ) ) + { + } + + SurfaceCapabilities2EXT & operator=( SurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceCapabilities2EXT & operator=( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSurfaceCapabilities2EXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilities2EXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilities2EXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceCapabilities2EXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + minImageCount, + maxImageCount, + currentExtent, + minImageExtent, + maxImageExtent, + maxImageArrayLayers, + supportedTransforms, + currentTransform, + supportedCompositeAlpha, + supportedUsageFlags, + supportedSurfaceCounters ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceCapabilities2EXT const & ) const = default; +#else + bool operator==( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minImageCount == rhs.minImageCount ) && ( maxImageCount == rhs.maxImageCount ) && + ( currentExtent == rhs.currentExtent ) && ( minImageExtent == rhs.minImageExtent ) && ( maxImageExtent == rhs.maxImageExtent ) && + ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && ( supportedTransforms == rhs.supportedTransforms ) && + ( currentTransform == rhs.currentTransform ) && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) && + ( supportedUsageFlags == rhs.supportedUsageFlags ) && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters ); +# endif + } + + bool operator!=( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSurfaceCapabilities2EXT; + void * pNext = {}; + uint32_t minImageCount = {}; + uint32_t maxImageCount = {}; + Extent2D currentExtent = {}; + Extent2D minImageExtent = {}; + Extent2D maxImageExtent = {}; + uint32_t maxImageArrayLayers = {}; + SurfaceTransformFlagsKHR supportedTransforms = {}; + SurfaceTransformFlagBitsKHR currentTransform = SurfaceTransformFlagBitsKHR::eIdentity; + CompositeAlphaFlagsKHR supportedCompositeAlpha = {}; + ImageUsageFlags supportedUsageFlags = {}; + SurfaceCounterFlagsEXT supportedSurfaceCounters = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceCapabilities2EXT; + }; +#endif + + template <> + struct CppType + { + using Type = SurfaceCapabilities2EXT; + }; + + // wrapper struct for struct VkSurfaceCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesKHR.html + struct SurfaceCapabilitiesKHR + { + using NativeType = VkSurfaceCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesKHR( uint32_t minImageCount_ = {}, + uint32_t maxImageCount_ = {}, + Extent2D currentExtent_ = {}, + Extent2D minImageExtent_ = {}, + Extent2D maxImageExtent_ = {}, + uint32_t maxImageArrayLayers_ = {}, + SurfaceTransformFlagsKHR supportedTransforms_ = {}, + SurfaceTransformFlagBitsKHR currentTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, + CompositeAlphaFlagsKHR supportedCompositeAlpha_ = {}, + ImageUsageFlags supportedUsageFlags_ = {} ) VULKAN_HPP_NOEXCEPT + : minImageCount{ minImageCount_ } + , maxImageCount{ maxImageCount_ } + , currentExtent{ currentExtent_ } + , minImageExtent{ minImageExtent_ } + , maxImageExtent{ maxImageExtent_ } + , maxImageArrayLayers{ maxImageArrayLayers_ } + , supportedTransforms{ supportedTransforms_ } + , currentTransform{ currentTransform_ } + , supportedCompositeAlpha{ supportedCompositeAlpha_ } + , supportedUsageFlags{ supportedUsageFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesKHR( SurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceCapabilitiesKHR( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfaceCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + SurfaceCapabilitiesKHR & operator=( SurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceCapabilitiesKHR & operator=( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( minImageCount, + maxImageCount, + currentExtent, + minImageExtent, + maxImageExtent, + maxImageArrayLayers, + supportedTransforms, + currentTransform, + supportedCompositeAlpha, + supportedUsageFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceCapabilitiesKHR const & ) const = default; +#else + bool operator==( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( minImageCount == rhs.minImageCount ) && ( maxImageCount == rhs.maxImageCount ) && ( currentExtent == rhs.currentExtent ) && + ( minImageExtent == rhs.minImageExtent ) && ( maxImageExtent == rhs.maxImageExtent ) && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && + ( supportedTransforms == rhs.supportedTransforms ) && ( currentTransform == rhs.currentTransform ) && + ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) && ( supportedUsageFlags == rhs.supportedUsageFlags ); +# endif + } + + bool operator!=( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t minImageCount = {}; + uint32_t maxImageCount = {}; + Extent2D currentExtent = {}; + Extent2D minImageExtent = {}; + Extent2D maxImageExtent = {}; + uint32_t maxImageArrayLayers = {}; + SurfaceTransformFlagsKHR supportedTransforms = {}; + SurfaceTransformFlagBitsKHR currentTransform = SurfaceTransformFlagBitsKHR::eIdentity; + CompositeAlphaFlagsKHR supportedCompositeAlpha = {}; + ImageUsageFlags supportedUsageFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceCapabilitiesKHR; + }; +#endif + + // wrapper struct for struct VkSurfaceCapabilities2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilities2KHR.html + struct SurfaceCapabilities2KHR + { + using NativeType = VkSurfaceCapabilities2KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilities2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceCapabilities2KHR( SurfaceCapabilitiesKHR surfaceCapabilities_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , surfaceCapabilities{ surfaceCapabilities_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceCapabilities2KHR( SurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfaceCapabilities2KHR( *reinterpret_cast( &rhs ) ) + { + } + + SurfaceCapabilities2KHR & operator=( SurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceCapabilities2KHR & operator=( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSurfaceCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilities2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilities2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceCapabilities2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surfaceCapabilities ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceCapabilities2KHR const & ) const = default; +#else + bool operator==( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCapabilities == rhs.surfaceCapabilities ); +# endif + } + + bool operator!=( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSurfaceCapabilities2KHR; + void * pNext = {}; + SurfaceCapabilitiesKHR surfaceCapabilities = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceCapabilities2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = SurfaceCapabilities2KHR; + }; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkSurfaceCapabilitiesFullScreenExclusiveEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesFullScreenExclusiveEXT.html + struct SurfaceCapabilitiesFullScreenExclusiveEXT + { + using NativeType = VkSurfaceCapabilitiesFullScreenExclusiveEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( Bool32 fullScreenExclusiveSupported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fullScreenExclusiveSupported{ fullScreenExclusiveSupported_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfaceCapabilitiesFullScreenExclusiveEXT( *reinterpret_cast( &rhs ) ) + { + } + + SurfaceCapabilitiesFullScreenExclusiveEXT & operator=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceCapabilitiesFullScreenExclusiveEXT & operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesFullScreenExclusiveEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesFullScreenExclusiveEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fullScreenExclusiveSupported ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceCapabilitiesFullScreenExclusiveEXT const & ) const = default; +# else + bool operator==( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusiveSupported == rhs.fullScreenExclusiveSupported ); +# endif + } + + bool operator!=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; + void * pNext = {}; + Bool32 fullScreenExclusiveSupported = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceCapabilitiesFullScreenExclusiveEXT; + }; +# endif + + template <> + struct CppType + { + using Type = SurfaceCapabilitiesFullScreenExclusiveEXT; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + // wrapper struct for struct VkSurfaceCapabilitiesPresentBarrierNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesPresentBarrierNV.html + struct SurfaceCapabilitiesPresentBarrierNV + { + using NativeType = VkSurfaceCapabilitiesPresentBarrierNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilitiesPresentBarrierNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentBarrierNV( Bool32 presentBarrierSupported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentBarrierSupported{ presentBarrierSupported_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentBarrierNV( SurfaceCapabilitiesPresentBarrierNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceCapabilitiesPresentBarrierNV( VkSurfaceCapabilitiesPresentBarrierNV const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfaceCapabilitiesPresentBarrierNV( *reinterpret_cast( &rhs ) ) + { + } + + SurfaceCapabilitiesPresentBarrierNV & operator=( SurfaceCapabilitiesPresentBarrierNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceCapabilitiesPresentBarrierNV & operator=( VkSurfaceCapabilitiesPresentBarrierNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSurfaceCapabilitiesPresentBarrierNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesPresentBarrierNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesPresentBarrierNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesPresentBarrierNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentBarrierSupported ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceCapabilitiesPresentBarrierNV const & ) const = default; +#else + bool operator==( SurfaceCapabilitiesPresentBarrierNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentBarrierSupported == rhs.presentBarrierSupported ); +# endif + } + + bool operator!=( SurfaceCapabilitiesPresentBarrierNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSurfaceCapabilitiesPresentBarrierNV; + void * pNext = {}; + Bool32 presentBarrierSupported = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceCapabilitiesPresentBarrierNV; + }; +#endif + + template <> + struct CppType + { + using Type = SurfaceCapabilitiesPresentBarrierNV; + }; + + // wrapper struct for struct VkSurfaceCapabilitiesPresentId2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesPresentId2KHR.html + struct SurfaceCapabilitiesPresentId2KHR + { + using NativeType = VkSurfaceCapabilitiesPresentId2KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilitiesPresentId2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentId2KHR( Bool32 presentId2Supported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentId2Supported{ presentId2Supported_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentId2KHR( SurfaceCapabilitiesPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceCapabilitiesPresentId2KHR( VkSurfaceCapabilitiesPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfaceCapabilitiesPresentId2KHR( *reinterpret_cast( &rhs ) ) + { + } + + SurfaceCapabilitiesPresentId2KHR & operator=( SurfaceCapabilitiesPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceCapabilitiesPresentId2KHR & operator=( VkSurfaceCapabilitiesPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentId2KHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentId2KHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentId2KHR & setPresentId2Supported( Bool32 presentId2Supported_ ) & VULKAN_HPP_NOEXCEPT + { + presentId2Supported = presentId2Supported_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentId2KHR && setPresentId2Supported( Bool32 presentId2Supported_ ) && VULKAN_HPP_NOEXCEPT + { + presentId2Supported = presentId2Supported_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSurfaceCapabilitiesPresentId2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesPresentId2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesPresentId2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesPresentId2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentId2Supported ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceCapabilitiesPresentId2KHR const & ) const = default; +#else + bool operator==( SurfaceCapabilitiesPresentId2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId2Supported == rhs.presentId2Supported ); +# endif + } + + bool operator!=( SurfaceCapabilitiesPresentId2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSurfaceCapabilitiesPresentId2KHR; + void * pNext = {}; + Bool32 presentId2Supported = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceCapabilitiesPresentId2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = SurfaceCapabilitiesPresentId2KHR; + }; + + // wrapper struct for struct VkSurfaceCapabilitiesPresentWait2KHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesPresentWait2KHR.html + struct SurfaceCapabilitiesPresentWait2KHR + { + using NativeType = VkSurfaceCapabilitiesPresentWait2KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilitiesPresentWait2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentWait2KHR( Bool32 presentWait2Supported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentWait2Supported{ presentWait2Supported_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentWait2KHR( SurfaceCapabilitiesPresentWait2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceCapabilitiesPresentWait2KHR( VkSurfaceCapabilitiesPresentWait2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfaceCapabilitiesPresentWait2KHR( *reinterpret_cast( &rhs ) ) + { + } + + SurfaceCapabilitiesPresentWait2KHR & operator=( SurfaceCapabilitiesPresentWait2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceCapabilitiesPresentWait2KHR & operator=( VkSurfaceCapabilitiesPresentWait2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentWait2KHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentWait2KHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentWait2KHR & setPresentWait2Supported( Bool32 presentWait2Supported_ ) & VULKAN_HPP_NOEXCEPT + { + presentWait2Supported = presentWait2Supported_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentWait2KHR && setPresentWait2Supported( Bool32 presentWait2Supported_ ) && VULKAN_HPP_NOEXCEPT + { + presentWait2Supported = presentWait2Supported_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSurfaceCapabilitiesPresentWait2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesPresentWait2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesPresentWait2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceCapabilitiesPresentWait2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentWait2Supported ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceCapabilitiesPresentWait2KHR const & ) const = default; +#else + bool operator==( SurfaceCapabilitiesPresentWait2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait2Supported == rhs.presentWait2Supported ); +# endif + } + + bool operator!=( SurfaceCapabilitiesPresentWait2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSurfaceCapabilitiesPresentWait2KHR; + void * pNext = {}; + Bool32 presentWait2Supported = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceCapabilitiesPresentWait2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = SurfaceCapabilitiesPresentWait2KHR; + }; + +#if defined( VK_USE_PLATFORM_OHOS ) + // wrapper struct for struct VkSurfaceCreateInfoOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCreateInfoOHOS.html + struct SurfaceCreateInfoOHOS + { + using NativeType = VkSurfaceCreateInfoOHOS; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCreateInfoOHOS; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + SurfaceCreateInfoOHOS( SurfaceCreateFlagsOHOS flags_ = {}, OHNativeWindow * window_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , window{ window_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceCreateInfoOHOS( SurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceCreateInfoOHOS( VkSurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfaceCreateInfoOHOS( *reinterpret_cast( &rhs ) ) + { + } + + SurfaceCreateInfoOHOS & operator=( SurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceCreateInfoOHOS & operator=( VkSurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS & setFlags( SurfaceCreateFlagsOHOS flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS && setFlags( SurfaceCreateFlagsOHOS flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS & setWindow( OHNativeWindow * window_ ) & VULKAN_HPP_NOEXCEPT + { + window = window_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS && setWindow( OHNativeWindow * window_ ) && VULKAN_HPP_NOEXCEPT + { + window = window_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSurfaceCreateInfoOHOS const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCreateInfoOHOS &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceCreateInfoOHOS const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceCreateInfoOHOS *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, window ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceCreateInfoOHOS const & ) const = default; +# else + bool operator==( SurfaceCreateInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); +# endif + } + + bool operator!=( SurfaceCreateInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eSurfaceCreateInfoOHOS; + const void * pNext = {}; + SurfaceCreateFlagsOHOS flags = {}; + OHNativeWindow * window = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceCreateInfoOHOS; + }; +# endif + + template <> + struct CppType + { + using Type = SurfaceCreateInfoOHOS; + }; +#endif /*VK_USE_PLATFORM_OHOS*/ + + // wrapper struct for struct VkSurfaceFormatKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceFormatKHR.html + struct SurfaceFormatKHR + { + using NativeType = VkSurfaceFormatKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceFormatKHR( Format format_ = Format::eUndefined, ColorSpaceKHR colorSpace_ = ColorSpaceKHR::eSrgbNonlinear ) VULKAN_HPP_NOEXCEPT + : format{ format_ } + , colorSpace{ colorSpace_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceFormatKHR( SurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceFormatKHR( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT : SurfaceFormatKHR( *reinterpret_cast( &rhs ) ) {} + + SurfaceFormatKHR & operator=( SurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceFormatKHR & operator=( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSurfaceFormatKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFormatKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFormatKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceFormatKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( format, colorSpace ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceFormatKHR const & ) const = default; +#else + bool operator==( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( format == rhs.format ) && ( colorSpace == rhs.colorSpace ); +# endif + } + + bool operator!=( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + Format format = Format::eUndefined; + ColorSpaceKHR colorSpace = ColorSpaceKHR::eSrgbNonlinear; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceFormatKHR; + }; +#endif + + // wrapper struct for struct VkSurfaceFormat2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceFormat2KHR.html + struct SurfaceFormat2KHR + { + using NativeType = VkSurfaceFormat2KHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFormat2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceFormat2KHR( SurfaceFormatKHR surfaceFormat_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , surfaceFormat{ surfaceFormat_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceFormat2KHR( SurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT : SurfaceFormat2KHR( *reinterpret_cast( &rhs ) ) {} + + SurfaceFormat2KHR & operator=( SurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceFormat2KHR & operator=( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSurfaceFormat2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFormat2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFormat2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceFormat2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surfaceFormat ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceFormat2KHR const & ) const = default; +#else + bool operator==( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceFormat == rhs.surfaceFormat ); +# endif + } + + bool operator!=( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSurfaceFormat2KHR; + void * pNext = {}; + SurfaceFormatKHR surfaceFormat = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceFormat2KHR; + }; +#endif + + template <> + struct CppType + { + using Type = SurfaceFormat2KHR; + }; + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkSurfaceFullScreenExclusiveInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceFullScreenExclusiveInfoEXT.html + struct SurfaceFullScreenExclusiveInfoEXT + { + using NativeType = VkSurfaceFullScreenExclusiveInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( FullScreenExclusiveEXT fullScreenExclusive_ = FullScreenExclusiveEXT::eDefault, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , fullScreenExclusive{ fullScreenExclusive_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( SurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfaceFullScreenExclusiveInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + SurfaceFullScreenExclusiveInfoEXT & operator=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceFullScreenExclusiveInfoEXT & operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveInfoEXT & setFullScreenExclusive( FullScreenExclusiveEXT fullScreenExclusive_ ) & VULKAN_HPP_NOEXCEPT + { + fullScreenExclusive = fullScreenExclusive_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveInfoEXT && setFullScreenExclusive( FullScreenExclusiveEXT fullScreenExclusive_ ) && VULKAN_HPP_NOEXCEPT + { + fullScreenExclusive = fullScreenExclusive_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSurfaceFullScreenExclusiveInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFullScreenExclusiveInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFullScreenExclusiveInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceFullScreenExclusiveInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, fullScreenExclusive ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceFullScreenExclusiveInfoEXT const & ) const = default; +# else + bool operator==( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusive == rhs.fullScreenExclusive ); +# endif + } + + bool operator!=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; + void * pNext = {}; + FullScreenExclusiveEXT fullScreenExclusive = FullScreenExclusiveEXT::eDefault; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceFullScreenExclusiveInfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = SurfaceFullScreenExclusiveInfoEXT; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkSurfaceFullScreenExclusiveWin32InfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceFullScreenExclusiveWin32InfoEXT.html + struct SurfaceFullScreenExclusiveWin32InfoEXT + { + using NativeType = VkSurfaceFullScreenExclusiveWin32InfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , hmonitor{ hmonitor_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfaceFullScreenExclusiveWin32InfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + SurfaceFullScreenExclusiveWin32InfoEXT & operator=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceFullScreenExclusiveWin32InfoEXT & operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveWin32InfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveWin32InfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveWin32InfoEXT & setHmonitor( HMONITOR hmonitor_ ) & VULKAN_HPP_NOEXCEPT + { + hmonitor = hmonitor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveWin32InfoEXT && setHmonitor( HMONITOR hmonitor_ ) && VULKAN_HPP_NOEXCEPT + { + hmonitor = hmonitor_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSurfaceFullScreenExclusiveWin32InfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFullScreenExclusiveWin32InfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceFullScreenExclusiveWin32InfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceFullScreenExclusiveWin32InfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hmonitor ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceFullScreenExclusiveWin32InfoEXT const & ) const = default; +# else + bool operator==( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hmonitor == rhs.hmonitor ); +# endif + } + + bool operator!=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; + const void * pNext = {}; + HMONITOR hmonitor = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceFullScreenExclusiveWin32InfoEXT; + }; +# endif + + template <> + struct CppType + { + using Type = SurfaceFullScreenExclusiveWin32InfoEXT; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + // wrapper struct for struct VkSurfacePresentModeCompatibilityKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfacePresentModeCompatibilityKHR.html + struct SurfacePresentModeCompatibilityKHR + { + using NativeType = VkSurfacePresentModeCompatibilityKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfacePresentModeCompatibilityKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + SurfacePresentModeCompatibilityKHR( uint32_t presentModeCount_ = {}, PresentModeKHR * pPresentModes_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentModeCount{ presentModeCount_ } + , pPresentModes{ pPresentModes_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfacePresentModeCompatibilityKHR( SurfacePresentModeCompatibilityKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfacePresentModeCompatibilityKHR( VkSurfacePresentModeCompatibilityKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfacePresentModeCompatibilityKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SurfacePresentModeCompatibilityKHR( ArrayProxyNoTemporaries const & presentModes_, void * pNext_ = nullptr ) + : pNext( pNext_ ), presentModeCount( static_cast( presentModes_.size() ) ), pPresentModes( presentModes_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SurfacePresentModeCompatibilityKHR & operator=( SurfacePresentModeCompatibilityKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfacePresentModeCompatibilityKHR & operator=( VkSurfacePresentModeCompatibilityKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR & setPresentModeCount( uint32_t presentModeCount_ ) & VULKAN_HPP_NOEXCEPT + { + presentModeCount = presentModeCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR && setPresentModeCount( uint32_t presentModeCount_ ) && VULKAN_HPP_NOEXCEPT + { + presentModeCount = presentModeCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR & setPPresentModes( PresentModeKHR * pPresentModes_ ) & VULKAN_HPP_NOEXCEPT + { + pPresentModes = pPresentModes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR && setPPresentModes( PresentModeKHR * pPresentModes_ ) && VULKAN_HPP_NOEXCEPT + { + pPresentModes = pPresentModes_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SurfacePresentModeCompatibilityKHR & setPresentModes( ArrayProxyNoTemporaries const & presentModes_ ) VULKAN_HPP_NOEXCEPT + { + presentModeCount = static_cast( presentModes_.size() ); + pPresentModes = presentModes_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSurfacePresentModeCompatibilityKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfacePresentModeCompatibilityKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfacePresentModeCompatibilityKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfacePresentModeCompatibilityKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentModeCount, pPresentModes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfacePresentModeCompatibilityKHR const & ) const = default; +#else + bool operator==( SurfacePresentModeCompatibilityKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeCount == rhs.presentModeCount ) && ( pPresentModes == rhs.pPresentModes ); +# endif + } + + bool operator!=( SurfacePresentModeCompatibilityKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSurfacePresentModeCompatibilityKHR; + void * pNext = {}; + uint32_t presentModeCount = {}; + PresentModeKHR * pPresentModes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfacePresentModeCompatibilityKHR; + }; +#endif + + template <> + struct CppType + { + using Type = SurfacePresentModeCompatibilityKHR; + }; + + using SurfacePresentModeCompatibilityEXT = SurfacePresentModeCompatibilityKHR; + + // wrapper struct for struct VkSurfacePresentModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfacePresentModeKHR.html + struct SurfacePresentModeKHR + { + using NativeType = VkSurfacePresentModeKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfacePresentModeKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfacePresentModeKHR( PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentMode{ presentMode_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfacePresentModeKHR( SurfacePresentModeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfacePresentModeKHR( VkSurfacePresentModeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfacePresentModeKHR( *reinterpret_cast( &rhs ) ) + { + } + + SurfacePresentModeKHR & operator=( SurfacePresentModeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfacePresentModeKHR & operator=( VkSurfacePresentModeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeKHR & setPresentMode( PresentModeKHR presentMode_ ) & VULKAN_HPP_NOEXCEPT + { + presentMode = presentMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeKHR && setPresentMode( PresentModeKHR presentMode_ ) && VULKAN_HPP_NOEXCEPT + { + presentMode = presentMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSurfacePresentModeKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfacePresentModeKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfacePresentModeKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfacePresentModeKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentMode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfacePresentModeKHR const & ) const = default; +#else + bool operator==( SurfacePresentModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMode == rhs.presentMode ); +# endif + } + + bool operator!=( SurfacePresentModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSurfacePresentModeKHR; + void * pNext = {}; + PresentModeKHR presentMode = PresentModeKHR::eImmediate; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfacePresentModeKHR; + }; +#endif + + template <> + struct CppType + { + using Type = SurfacePresentModeKHR; + }; + + using SurfacePresentModeEXT = SurfacePresentModeKHR; + + // wrapper struct for struct VkSurfacePresentScalingCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfacePresentScalingCapabilitiesKHR.html + struct SurfacePresentScalingCapabilitiesKHR + { + using NativeType = VkSurfacePresentScalingCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfacePresentScalingCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfacePresentScalingCapabilitiesKHR( PresentScalingFlagsKHR supportedPresentScaling_ = {}, + PresentGravityFlagsKHR supportedPresentGravityX_ = {}, + PresentGravityFlagsKHR supportedPresentGravityY_ = {}, + Extent2D minScaledImageExtent_ = {}, + Extent2D maxScaledImageExtent_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , supportedPresentScaling{ supportedPresentScaling_ } + , supportedPresentGravityX{ supportedPresentGravityX_ } + , supportedPresentGravityY{ supportedPresentGravityY_ } + , minScaledImageExtent{ minScaledImageExtent_ } + , maxScaledImageExtent{ maxScaledImageExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfacePresentScalingCapabilitiesKHR( SurfacePresentScalingCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfacePresentScalingCapabilitiesKHR( VkSurfacePresentScalingCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfacePresentScalingCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + SurfacePresentScalingCapabilitiesKHR & operator=( SurfacePresentScalingCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfacePresentScalingCapabilitiesKHR & operator=( VkSurfacePresentScalingCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setSupportedPresentScaling( PresentScalingFlagsKHR supportedPresentScaling_ ) & + VULKAN_HPP_NOEXCEPT + { + supportedPresentScaling = supportedPresentScaling_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setSupportedPresentScaling( PresentScalingFlagsKHR supportedPresentScaling_ ) && + VULKAN_HPP_NOEXCEPT + { + supportedPresentScaling = supportedPresentScaling_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setSupportedPresentGravityX( PresentGravityFlagsKHR supportedPresentGravityX_ ) & + VULKAN_HPP_NOEXCEPT + { + supportedPresentGravityX = supportedPresentGravityX_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setSupportedPresentGravityX( PresentGravityFlagsKHR supportedPresentGravityX_ ) && + VULKAN_HPP_NOEXCEPT + { + supportedPresentGravityX = supportedPresentGravityX_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setSupportedPresentGravityY( PresentGravityFlagsKHR supportedPresentGravityY_ ) & + VULKAN_HPP_NOEXCEPT + { + supportedPresentGravityY = supportedPresentGravityY_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setSupportedPresentGravityY( PresentGravityFlagsKHR supportedPresentGravityY_ ) && + VULKAN_HPP_NOEXCEPT + { + supportedPresentGravityY = supportedPresentGravityY_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setMinScaledImageExtent( Extent2D const & minScaledImageExtent_ ) & VULKAN_HPP_NOEXCEPT + { + minScaledImageExtent = minScaledImageExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setMinScaledImageExtent( Extent2D const & minScaledImageExtent_ ) && VULKAN_HPP_NOEXCEPT + { + minScaledImageExtent = minScaledImageExtent_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setMaxScaledImageExtent( Extent2D const & maxScaledImageExtent_ ) & VULKAN_HPP_NOEXCEPT + { + maxScaledImageExtent = maxScaledImageExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setMaxScaledImageExtent( Extent2D const & maxScaledImageExtent_ ) && VULKAN_HPP_NOEXCEPT + { + maxScaledImageExtent = maxScaledImageExtent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSurfacePresentScalingCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfacePresentScalingCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfacePresentScalingCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfacePresentScalingCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supportedPresentScaling, supportedPresentGravityX, supportedPresentGravityY, minScaledImageExtent, maxScaledImageExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfacePresentScalingCapabilitiesKHR const & ) const = default; +#else + bool operator==( SurfacePresentScalingCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedPresentScaling == rhs.supportedPresentScaling ) && + ( supportedPresentGravityX == rhs.supportedPresentGravityX ) && ( supportedPresentGravityY == rhs.supportedPresentGravityY ) && + ( minScaledImageExtent == rhs.minScaledImageExtent ) && ( maxScaledImageExtent == rhs.maxScaledImageExtent ); +# endif + } + + bool operator!=( SurfacePresentScalingCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSurfacePresentScalingCapabilitiesKHR; + void * pNext = {}; + PresentScalingFlagsKHR supportedPresentScaling = {}; + PresentGravityFlagsKHR supportedPresentGravityX = {}; + PresentGravityFlagsKHR supportedPresentGravityY = {}; + Extent2D minScaledImageExtent = {}; + Extent2D maxScaledImageExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfacePresentScalingCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = SurfacePresentScalingCapabilitiesKHR; + }; + + using SurfacePresentScalingCapabilitiesEXT = SurfacePresentScalingCapabilitiesKHR; + + // wrapper struct for struct VkSurfaceProtectedCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceProtectedCapabilitiesKHR.html + struct SurfaceProtectedCapabilitiesKHR + { + using NativeType = VkSurfaceProtectedCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceProtectedCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( Bool32 supportsProtected_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , supportsProtected{ supportsProtected_ } + { + } + + VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( SurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SurfaceProtectedCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + SurfaceProtectedCapabilitiesKHR & operator=( SurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SurfaceProtectedCapabilitiesKHR & operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSurfaceProtectedCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceProtectedCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSurfaceProtectedCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSurfaceProtectedCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supportsProtected ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SurfaceProtectedCapabilitiesKHR const & ) const = default; +#else + bool operator==( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsProtected == rhs.supportsProtected ); +# endif + } + + bool operator!=( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR; + void * pNext = {}; + Bool32 supportsProtected = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SurfaceProtectedCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = SurfaceProtectedCapabilitiesKHR; + }; + + // wrapper struct for struct VkSwapchainCalibratedTimestampInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCalibratedTimestampInfoEXT.html + struct SwapchainCalibratedTimestampInfoEXT + { + using NativeType = VkSwapchainCalibratedTimestampInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCalibratedTimestampInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainCalibratedTimestampInfoEXT( SwapchainKHR swapchain_ = {}, + PresentStageFlagsEXT presentStage_ = {}, + uint64_t timeDomainId_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchain{ swapchain_ } + , presentStage{ presentStage_ } + , timeDomainId{ timeDomainId_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainCalibratedTimestampInfoEXT( SwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainCalibratedTimestampInfoEXT( VkSwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainCalibratedTimestampInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + SwapchainCalibratedTimestampInfoEXT & operator=( SwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainCalibratedTimestampInfoEXT & operator=( VkSwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT + { + swapchain = swapchain_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setPresentStage( PresentStageFlagsEXT presentStage_ ) & VULKAN_HPP_NOEXCEPT + { + presentStage = presentStage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT && setPresentStage( PresentStageFlagsEXT presentStage_ ) && VULKAN_HPP_NOEXCEPT + { + presentStage = presentStage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setTimeDomainId( uint64_t timeDomainId_ ) & VULKAN_HPP_NOEXCEPT + { + timeDomainId = timeDomainId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT && setTimeDomainId( uint64_t timeDomainId_ ) && VULKAN_HPP_NOEXCEPT + { + timeDomainId = timeDomainId_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainCalibratedTimestampInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainCalibratedTimestampInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainCalibratedTimestampInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainCalibratedTimestampInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchain, presentStage, timeDomainId ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainCalibratedTimestampInfoEXT const & ) const = default; +#else + bool operator==( SwapchainCalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( presentStage == rhs.presentStage ) && + ( timeDomainId == rhs.timeDomainId ); +# endif + } + + bool operator!=( SwapchainCalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainCalibratedTimestampInfoEXT; + const void * pNext = {}; + SwapchainKHR swapchain = {}; + PresentStageFlagsEXT presentStage = {}; + uint64_t timeDomainId = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainCalibratedTimestampInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainCalibratedTimestampInfoEXT; + }; + + // wrapper struct for struct VkSwapchainCounterCreateInfoEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCounterCreateInfoEXT.html + struct SwapchainCounterCreateInfoEXT + { + using NativeType = VkSwapchainCounterCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCounterCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , surfaceCounters{ surfaceCounters_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( SwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainCounterCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + + SwapchainCounterCreateInfoEXT & operator=( SwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainCounterCreateInfoEXT & operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainCounterCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCounterCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCounterCreateInfoEXT & setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ ) & VULKAN_HPP_NOEXCEPT + { + surfaceCounters = surfaceCounters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCounterCreateInfoEXT && setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ ) && VULKAN_HPP_NOEXCEPT + { + surfaceCounters = surfaceCounters_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainCounterCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainCounterCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainCounterCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainCounterCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, surfaceCounters ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainCounterCreateInfoEXT const & ) const = default; +#else + bool operator==( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCounters == rhs.surfaceCounters ); +# endif + } + + bool operator!=( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT; + const void * pNext = {}; + SurfaceCounterFlagsEXT surfaceCounters = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainCounterCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainCounterCreateInfoEXT; + }; + + // wrapper struct for struct VkSwapchainCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCreateInfoKHR.html + struct SwapchainCreateInfoKHR + { + using NativeType = VkSwapchainCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = {}, + SurfaceKHR surface_ = {}, + uint32_t minImageCount_ = {}, + Format imageFormat_ = Format::eUndefined, + ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear, + Extent2D imageExtent_ = {}, + uint32_t imageArrayLayers_ = {}, + ImageUsageFlags imageUsage_ = {}, + SharingMode imageSharingMode_ = SharingMode::eExclusive, + uint32_t queueFamilyIndexCount_ = {}, + const uint32_t * pQueueFamilyIndices_ = {}, + SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, + CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque, + PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, + Bool32 clipped_ = {}, + SwapchainKHR oldSwapchain_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , surface{ surface_ } + , minImageCount{ minImageCount_ } + , imageFormat{ imageFormat_ } + , imageColorSpace{ imageColorSpace_ } + , imageExtent{ imageExtent_ } + , imageArrayLayers{ imageArrayLayers_ } + , imageUsage{ imageUsage_ } + , imageSharingMode{ imageSharingMode_ } + , queueFamilyIndexCount{ queueFamilyIndexCount_ } + , pQueueFamilyIndices{ pQueueFamilyIndices_ } + , preTransform{ preTransform_ } + , compositeAlpha{ compositeAlpha_ } + , presentMode{ presentMode_ } + , clipped{ clipped_ } + , oldSwapchain{ oldSwapchain_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( SwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_, + SurfaceKHR surface_, + uint32_t minImageCount_, + Format imageFormat_, + ColorSpaceKHR imageColorSpace_, + Extent2D imageExtent_, + uint32_t imageArrayLayers_, + ImageUsageFlags imageUsage_, + SharingMode imageSharingMode_, + ArrayProxyNoTemporaries const & queueFamilyIndices_, + SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, + CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque, + PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, + Bool32 clipped_ = {}, + SwapchainKHR oldSwapchain_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , surface( surface_ ) + , minImageCount( minImageCount_ ) + , imageFormat( imageFormat_ ) + , imageColorSpace( imageColorSpace_ ) + , imageExtent( imageExtent_ ) + , imageArrayLayers( imageArrayLayers_ ) + , imageUsage( imageUsage_ ) + , imageSharingMode( imageSharingMode_ ) + , queueFamilyIndexCount( static_cast( queueFamilyIndices_.size() ) ) + , pQueueFamilyIndices( queueFamilyIndices_.data() ) + , preTransform( preTransform_ ) + , compositeAlpha( compositeAlpha_ ) + , presentMode( presentMode_ ) + , clipped( clipped_ ) + , oldSwapchain( oldSwapchain_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SwapchainCreateInfoKHR & operator=( SwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainCreateInfoKHR & operator=( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setFlags( SwapchainCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setFlags( SwapchainCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setSurface( SurfaceKHR surface_ ) & VULKAN_HPP_NOEXCEPT + { + surface = surface_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setSurface( SurfaceKHR surface_ ) && VULKAN_HPP_NOEXCEPT + { + surface = surface_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setMinImageCount( uint32_t minImageCount_ ) & VULKAN_HPP_NOEXCEPT + { + minImageCount = minImageCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setMinImageCount( uint32_t minImageCount_ ) && VULKAN_HPP_NOEXCEPT + { + minImageCount = minImageCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageFormat( Format imageFormat_ ) & VULKAN_HPP_NOEXCEPT + { + imageFormat = imageFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageFormat( Format imageFormat_ ) && VULKAN_HPP_NOEXCEPT + { + imageFormat = imageFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageColorSpace( ColorSpaceKHR imageColorSpace_ ) & VULKAN_HPP_NOEXCEPT + { + imageColorSpace = imageColorSpace_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageColorSpace( ColorSpaceKHR imageColorSpace_ ) && VULKAN_HPP_NOEXCEPT + { + imageColorSpace = imageColorSpace_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageExtent( Extent2D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageExtent( Extent2D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT + { + imageExtent = imageExtent_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageArrayLayers( uint32_t imageArrayLayers_ ) & VULKAN_HPP_NOEXCEPT + { + imageArrayLayers = imageArrayLayers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageArrayLayers( uint32_t imageArrayLayers_ ) && VULKAN_HPP_NOEXCEPT + { + imageArrayLayers = imageArrayLayers_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageUsage( ImageUsageFlags imageUsage_ ) & VULKAN_HPP_NOEXCEPT + { + imageUsage = imageUsage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageUsage( ImageUsageFlags imageUsage_ ) && VULKAN_HPP_NOEXCEPT + { + imageUsage = imageUsage_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageSharingMode( SharingMode imageSharingMode_ ) & VULKAN_HPP_NOEXCEPT + { + imageSharingMode = imageSharingMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageSharingMode( SharingMode imageSharingMode_ ) && VULKAN_HPP_NOEXCEPT + { + imageSharingMode = imageSharingMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) & VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) && VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = queueFamilyIndexCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) & VULKAN_HPP_NOEXCEPT + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) && VULKAN_HPP_NOEXCEPT + { + pQueueFamilyIndices = pQueueFamilyIndices_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SwapchainCreateInfoKHR & setQueueFamilyIndices( ArrayProxyNoTemporaries const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT + { + queueFamilyIndexCount = static_cast( queueFamilyIndices_.size() ); + pQueueFamilyIndices = queueFamilyIndices_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ ) & VULKAN_HPP_NOEXCEPT + { + preTransform = preTransform_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ ) && VULKAN_HPP_NOEXCEPT + { + preTransform = preTransform_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ ) & VULKAN_HPP_NOEXCEPT + { + compositeAlpha = compositeAlpha_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ ) && VULKAN_HPP_NOEXCEPT + { + compositeAlpha = compositeAlpha_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setPresentMode( PresentModeKHR presentMode_ ) & VULKAN_HPP_NOEXCEPT + { + presentMode = presentMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setPresentMode( PresentModeKHR presentMode_ ) && VULKAN_HPP_NOEXCEPT + { + presentMode = presentMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setClipped( Bool32 clipped_ ) & VULKAN_HPP_NOEXCEPT + { + clipped = clipped_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setClipped( Bool32 clipped_ ) && VULKAN_HPP_NOEXCEPT + { + clipped = clipped_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setOldSwapchain( SwapchainKHR oldSwapchain_ ) & VULKAN_HPP_NOEXCEPT + { + oldSwapchain = oldSwapchain_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setOldSwapchain( SwapchainKHR oldSwapchain_ ) && VULKAN_HPP_NOEXCEPT + { + oldSwapchain = oldSwapchain_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + surface, + minImageCount, + imageFormat, + imageColorSpace, + imageExtent, + imageArrayLayers, + imageUsage, + imageSharingMode, + queueFamilyIndexCount, + pQueueFamilyIndices, + preTransform, + compositeAlpha, + presentMode, + clipped, + oldSwapchain ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainCreateInfoKHR const & ) const = default; +#else + bool operator==( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( surface == rhs.surface ) && + ( minImageCount == rhs.minImageCount ) && ( imageFormat == rhs.imageFormat ) && ( imageColorSpace == rhs.imageColorSpace ) && + ( imageExtent == rhs.imageExtent ) && ( imageArrayLayers == rhs.imageArrayLayers ) && ( imageUsage == rhs.imageUsage ) && + ( imageSharingMode == rhs.imageSharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && + ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( preTransform == rhs.preTransform ) && ( compositeAlpha == rhs.compositeAlpha ) && + ( presentMode == rhs.presentMode ) && ( clipped == rhs.clipped ) && ( oldSwapchain == rhs.oldSwapchain ); +# endif + } + + bool operator!=( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainCreateInfoKHR; + const void * pNext = {}; + SwapchainCreateFlagsKHR flags = {}; + SurfaceKHR surface = {}; + uint32_t minImageCount = {}; + Format imageFormat = Format::eUndefined; + ColorSpaceKHR imageColorSpace = ColorSpaceKHR::eSrgbNonlinear; + Extent2D imageExtent = {}; + uint32_t imageArrayLayers = {}; + ImageUsageFlags imageUsage = {}; + SharingMode imageSharingMode = SharingMode::eExclusive; + uint32_t queueFamilyIndexCount = {}; + const uint32_t * pQueueFamilyIndices = {}; + SurfaceTransformFlagBitsKHR preTransform = SurfaceTransformFlagBitsKHR::eIdentity; + CompositeAlphaFlagBitsKHR compositeAlpha = CompositeAlphaFlagBitsKHR::eOpaque; + PresentModeKHR presentMode = PresentModeKHR::eImmediate; + Bool32 clipped = {}; + SwapchainKHR oldSwapchain = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainCreateInfoKHR; + }; + + // wrapper struct for struct VkSwapchainDisplayNativeHdrCreateInfoAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainDisplayNativeHdrCreateInfoAMD.html + struct SwapchainDisplayNativeHdrCreateInfoAMD + { + using NativeType = VkSwapchainDisplayNativeHdrCreateInfoAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( Bool32 localDimmingEnable_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , localDimmingEnable{ localDimmingEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainDisplayNativeHdrCreateInfoAMD( *reinterpret_cast( &rhs ) ) + { + } + + SwapchainDisplayNativeHdrCreateInfoAMD & operator=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainDisplayNativeHdrCreateInfoAMD & operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainDisplayNativeHdrCreateInfoAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainDisplayNativeHdrCreateInfoAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainDisplayNativeHdrCreateInfoAMD & setLocalDimmingEnable( Bool32 localDimmingEnable_ ) & VULKAN_HPP_NOEXCEPT + { + localDimmingEnable = localDimmingEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainDisplayNativeHdrCreateInfoAMD && setLocalDimmingEnable( Bool32 localDimmingEnable_ ) && VULKAN_HPP_NOEXCEPT + { + localDimmingEnable = localDimmingEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainDisplayNativeHdrCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainDisplayNativeHdrCreateInfoAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainDisplayNativeHdrCreateInfoAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainDisplayNativeHdrCreateInfoAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, localDimmingEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainDisplayNativeHdrCreateInfoAMD const & ) const = default; +#else + bool operator==( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingEnable == rhs.localDimmingEnable ); +# endif + } + + bool operator!=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; + const void * pNext = {}; + Bool32 localDimmingEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainDisplayNativeHdrCreateInfoAMD; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainDisplayNativeHdrCreateInfoAMD; + }; + + // wrapper struct for struct VkSwapchainLatencyCreateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainLatencyCreateInfoNV.html + struct SwapchainLatencyCreateInfoNV + { + using NativeType = VkSwapchainLatencyCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainLatencyCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainLatencyCreateInfoNV( Bool32 latencyModeEnable_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , latencyModeEnable{ latencyModeEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainLatencyCreateInfoNV( SwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainLatencyCreateInfoNV( VkSwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainLatencyCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + SwapchainLatencyCreateInfoNV & operator=( SwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainLatencyCreateInfoNV & operator=( VkSwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainLatencyCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainLatencyCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainLatencyCreateInfoNV & setLatencyModeEnable( Bool32 latencyModeEnable_ ) & VULKAN_HPP_NOEXCEPT + { + latencyModeEnable = latencyModeEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainLatencyCreateInfoNV && setLatencyModeEnable( Bool32 latencyModeEnable_ ) && VULKAN_HPP_NOEXCEPT + { + latencyModeEnable = latencyModeEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainLatencyCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainLatencyCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainLatencyCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainLatencyCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, latencyModeEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainLatencyCreateInfoNV const & ) const = default; +#else + bool operator==( SwapchainLatencyCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( latencyModeEnable == rhs.latencyModeEnable ); +# endif + } + + bool operator!=( SwapchainLatencyCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainLatencyCreateInfoNV; + const void * pNext = {}; + Bool32 latencyModeEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainLatencyCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainLatencyCreateInfoNV; + }; + + // wrapper struct for struct VkSwapchainPresentBarrierCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainPresentBarrierCreateInfoNV.html + struct SwapchainPresentBarrierCreateInfoNV + { + using NativeType = VkSwapchainPresentBarrierCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainPresentBarrierCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainPresentBarrierCreateInfoNV( Bool32 presentBarrierEnable_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentBarrierEnable{ presentBarrierEnable_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainPresentBarrierCreateInfoNV( SwapchainPresentBarrierCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainPresentBarrierCreateInfoNV( VkSwapchainPresentBarrierCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainPresentBarrierCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + SwapchainPresentBarrierCreateInfoNV & operator=( SwapchainPresentBarrierCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainPresentBarrierCreateInfoNV & operator=( VkSwapchainPresentBarrierCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentBarrierCreateInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentBarrierCreateInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentBarrierCreateInfoNV & setPresentBarrierEnable( Bool32 presentBarrierEnable_ ) & VULKAN_HPP_NOEXCEPT + { + presentBarrierEnable = presentBarrierEnable_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentBarrierCreateInfoNV && setPresentBarrierEnable( Bool32 presentBarrierEnable_ ) && VULKAN_HPP_NOEXCEPT + { + presentBarrierEnable = presentBarrierEnable_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainPresentBarrierCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainPresentBarrierCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainPresentBarrierCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainPresentBarrierCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentBarrierEnable ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainPresentBarrierCreateInfoNV const & ) const = default; +#else + bool operator==( SwapchainPresentBarrierCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentBarrierEnable == rhs.presentBarrierEnable ); +# endif + } + + bool operator!=( SwapchainPresentBarrierCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainPresentBarrierCreateInfoNV; + void * pNext = {}; + Bool32 presentBarrierEnable = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainPresentBarrierCreateInfoNV; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainPresentBarrierCreateInfoNV; + }; + + // wrapper struct for struct VkSwapchainPresentFenceInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainPresentFenceInfoKHR.html + struct SwapchainPresentFenceInfoKHR + { + using NativeType = VkSwapchainPresentFenceInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainPresentFenceInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + SwapchainPresentFenceInfoKHR( uint32_t swapchainCount_ = {}, const Fence * pFences_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchainCount{ swapchainCount_ } + , pFences{ pFences_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainPresentFenceInfoKHR( SwapchainPresentFenceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainPresentFenceInfoKHR( VkSwapchainPresentFenceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainPresentFenceInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SwapchainPresentFenceInfoKHR( ArrayProxyNoTemporaries const & fences_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), swapchainCount( static_cast( fences_.size() ) ), pFences( fences_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SwapchainPresentFenceInfoKHR & operator=( SwapchainPresentFenceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainPresentFenceInfoKHR & operator=( VkSwapchainPresentFenceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR & setPFences( const Fence * pFences_ ) & VULKAN_HPP_NOEXCEPT + { + pFences = pFences_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR && setPFences( const Fence * pFences_ ) && VULKAN_HPP_NOEXCEPT + { + pFences = pFences_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SwapchainPresentFenceInfoKHR & setFences( ArrayProxyNoTemporaries const & fences_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( fences_.size() ); + pFences = fences_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainPresentFenceInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainPresentFenceInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainPresentFenceInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainPresentFenceInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pFences ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainPresentFenceInfoKHR const & ) const = default; +#else + bool operator==( SwapchainPresentFenceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pFences == rhs.pFences ); +# endif + } + + bool operator!=( SwapchainPresentFenceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainPresentFenceInfoKHR; + const void * pNext = {}; + uint32_t swapchainCount = {}; + const Fence * pFences = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainPresentFenceInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainPresentFenceInfoKHR; + }; + + using SwapchainPresentFenceInfoEXT = SwapchainPresentFenceInfoKHR; + + // wrapper struct for struct VkSwapchainPresentModeInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainPresentModeInfoKHR.html + struct SwapchainPresentModeInfoKHR + { + using NativeType = VkSwapchainPresentModeInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainPresentModeInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainPresentModeInfoKHR( uint32_t swapchainCount_ = {}, + const PresentModeKHR * pPresentModes_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , swapchainCount{ swapchainCount_ } + , pPresentModes{ pPresentModes_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainPresentModeInfoKHR( SwapchainPresentModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainPresentModeInfoKHR( VkSwapchainPresentModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainPresentModeInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SwapchainPresentModeInfoKHR( ArrayProxyNoTemporaries const & presentModes_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), swapchainCount( static_cast( presentModes_.size() ) ), pPresentModes( presentModes_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SwapchainPresentModeInfoKHR & operator=( SwapchainPresentModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainPresentModeInfoKHR & operator=( VkSwapchainPresentModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT + { + swapchainCount = swapchainCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR & setPPresentModes( const PresentModeKHR * pPresentModes_ ) & VULKAN_HPP_NOEXCEPT + { + pPresentModes = pPresentModes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR && setPPresentModes( const PresentModeKHR * pPresentModes_ ) && VULKAN_HPP_NOEXCEPT + { + pPresentModes = pPresentModes_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SwapchainPresentModeInfoKHR & setPresentModes( ArrayProxyNoTemporaries const & presentModes_ ) VULKAN_HPP_NOEXCEPT + { + swapchainCount = static_cast( presentModes_.size() ); + pPresentModes = presentModes_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainPresentModeInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainPresentModeInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainPresentModeInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainPresentModeInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, swapchainCount, pPresentModes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainPresentModeInfoKHR const & ) const = default; +#else + bool operator==( SwapchainPresentModeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pPresentModes == rhs.pPresentModes ); +# endif + } + + bool operator!=( SwapchainPresentModeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainPresentModeInfoKHR; + const void * pNext = {}; + uint32_t swapchainCount = {}; + const PresentModeKHR * pPresentModes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainPresentModeInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainPresentModeInfoKHR; + }; + + using SwapchainPresentModeInfoEXT = SwapchainPresentModeInfoKHR; + + // wrapper struct for struct VkSwapchainPresentModesCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainPresentModesCreateInfoKHR.html + struct SwapchainPresentModesCreateInfoKHR + { + using NativeType = VkSwapchainPresentModesCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainPresentModesCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainPresentModesCreateInfoKHR( uint32_t presentModeCount_ = {}, + const PresentModeKHR * pPresentModes_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , presentModeCount{ presentModeCount_ } + , pPresentModes{ pPresentModes_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainPresentModesCreateInfoKHR( SwapchainPresentModesCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainPresentModesCreateInfoKHR( VkSwapchainPresentModesCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainPresentModesCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SwapchainPresentModesCreateInfoKHR( ArrayProxyNoTemporaries const & presentModes_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), presentModeCount( static_cast( presentModes_.size() ) ), pPresentModes( presentModes_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + SwapchainPresentModesCreateInfoKHR & operator=( SwapchainPresentModesCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainPresentModesCreateInfoKHR & operator=( VkSwapchainPresentModesCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR & setPresentModeCount( uint32_t presentModeCount_ ) & VULKAN_HPP_NOEXCEPT + { + presentModeCount = presentModeCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR && setPresentModeCount( uint32_t presentModeCount_ ) && VULKAN_HPP_NOEXCEPT + { + presentModeCount = presentModeCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR & setPPresentModes( const PresentModeKHR * pPresentModes_ ) & VULKAN_HPP_NOEXCEPT + { + pPresentModes = pPresentModes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR && setPPresentModes( const PresentModeKHR * pPresentModes_ ) && VULKAN_HPP_NOEXCEPT + { + pPresentModes = pPresentModes_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + SwapchainPresentModesCreateInfoKHR & setPresentModes( ArrayProxyNoTemporaries const & presentModes_ ) VULKAN_HPP_NOEXCEPT + { + presentModeCount = static_cast( presentModes_.size() ); + pPresentModes = presentModes_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainPresentModesCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainPresentModesCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainPresentModesCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainPresentModesCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, presentModeCount, pPresentModes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainPresentModesCreateInfoKHR const & ) const = default; +#else + bool operator==( SwapchainPresentModesCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeCount == rhs.presentModeCount ) && ( pPresentModes == rhs.pPresentModes ); +# endif + } + + bool operator!=( SwapchainPresentModesCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainPresentModesCreateInfoKHR; + const void * pNext = {}; + uint32_t presentModeCount = {}; + const PresentModeKHR * pPresentModes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainPresentModesCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainPresentModesCreateInfoKHR; + }; + + using SwapchainPresentModesCreateInfoEXT = SwapchainPresentModesCreateInfoKHR; + + // wrapper struct for struct VkSwapchainPresentScalingCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainPresentScalingCreateInfoKHR.html + struct SwapchainPresentScalingCreateInfoKHR + { + using NativeType = VkSwapchainPresentScalingCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainPresentScalingCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainPresentScalingCreateInfoKHR( PresentScalingFlagsKHR scalingBehavior_ = {}, + PresentGravityFlagsKHR presentGravityX_ = {}, + PresentGravityFlagsKHR presentGravityY_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , scalingBehavior{ scalingBehavior_ } + , presentGravityX{ presentGravityX_ } + , presentGravityY{ presentGravityY_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainPresentScalingCreateInfoKHR( SwapchainPresentScalingCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainPresentScalingCreateInfoKHR( VkSwapchainPresentScalingCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainPresentScalingCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + SwapchainPresentScalingCreateInfoKHR & operator=( SwapchainPresentScalingCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainPresentScalingCreateInfoKHR & operator=( VkSwapchainPresentScalingCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR & setScalingBehavior( PresentScalingFlagsKHR scalingBehavior_ ) & VULKAN_HPP_NOEXCEPT + { + scalingBehavior = scalingBehavior_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR && setScalingBehavior( PresentScalingFlagsKHR scalingBehavior_ ) && VULKAN_HPP_NOEXCEPT + { + scalingBehavior = scalingBehavior_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR & setPresentGravityX( PresentGravityFlagsKHR presentGravityX_ ) & VULKAN_HPP_NOEXCEPT + { + presentGravityX = presentGravityX_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR && setPresentGravityX( PresentGravityFlagsKHR presentGravityX_ ) && VULKAN_HPP_NOEXCEPT + { + presentGravityX = presentGravityX_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR & setPresentGravityY( PresentGravityFlagsKHR presentGravityY_ ) & VULKAN_HPP_NOEXCEPT + { + presentGravityY = presentGravityY_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR && setPresentGravityY( PresentGravityFlagsKHR presentGravityY_ ) && VULKAN_HPP_NOEXCEPT + { + presentGravityY = presentGravityY_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkSwapchainPresentScalingCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainPresentScalingCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainPresentScalingCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainPresentScalingCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, scalingBehavior, presentGravityX, presentGravityY ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainPresentScalingCreateInfoKHR const & ) const = default; +#else + bool operator==( SwapchainPresentScalingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalingBehavior == rhs.scalingBehavior ) && ( presentGravityX == rhs.presentGravityX ) && + ( presentGravityY == rhs.presentGravityY ); +# endif + } + + bool operator!=( SwapchainPresentScalingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainPresentScalingCreateInfoKHR; + const void * pNext = {}; + PresentScalingFlagsKHR scalingBehavior = {}; + PresentGravityFlagsKHR presentGravityX = {}; + PresentGravityFlagsKHR presentGravityY = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainPresentScalingCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainPresentScalingCreateInfoKHR; + }; + + using SwapchainPresentScalingCreateInfoEXT = SwapchainPresentScalingCreateInfoKHR; + + // wrapper struct for struct VkSwapchainTimeDomainPropertiesEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainTimeDomainPropertiesEXT.html + struct SwapchainTimeDomainPropertiesEXT + { + using NativeType = VkSwapchainTimeDomainPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainTimeDomainPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR SwapchainTimeDomainPropertiesEXT( uint32_t timeDomainCount_ = {}, + TimeDomainKHR * pTimeDomains_ = {}, + uint64_t * pTimeDomainIds_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , timeDomainCount{ timeDomainCount_ } + , pTimeDomains{ pTimeDomains_ } + , pTimeDomainIds{ pTimeDomainIds_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainTimeDomainPropertiesEXT( SwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainTimeDomainPropertiesEXT( VkSwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainTimeDomainPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + SwapchainTimeDomainPropertiesEXT & operator=( SwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainTimeDomainPropertiesEXT & operator=( VkSwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSwapchainTimeDomainPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainTimeDomainPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainTimeDomainPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainTimeDomainPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, timeDomainCount, pTimeDomains, pTimeDomainIds ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainTimeDomainPropertiesEXT const & ) const = default; +#else + bool operator==( SwapchainTimeDomainPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomainCount == rhs.timeDomainCount ) && ( pTimeDomains == rhs.pTimeDomains ) && + ( pTimeDomainIds == rhs.pTimeDomainIds ); +# endif + } + + bool operator!=( SwapchainTimeDomainPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainTimeDomainPropertiesEXT; + void * pNext = {}; + uint32_t timeDomainCount = {}; + TimeDomainKHR * pTimeDomains = {}; + uint64_t * pTimeDomainIds = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainTimeDomainPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainTimeDomainPropertiesEXT; + }; + + // wrapper struct for struct VkSwapchainTimingPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainTimingPropertiesEXT.html + struct SwapchainTimingPropertiesEXT + { + using NativeType = VkSwapchainTimingPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainTimingPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + SwapchainTimingPropertiesEXT( uint64_t refreshDuration_ = {}, uint64_t refreshInterval_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , refreshDuration{ refreshDuration_ } + , refreshInterval{ refreshInterval_ } + { + } + + VULKAN_HPP_CONSTEXPR SwapchainTimingPropertiesEXT( SwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + SwapchainTimingPropertiesEXT( VkSwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : SwapchainTimingPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + SwapchainTimingPropertiesEXT & operator=( SwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + SwapchainTimingPropertiesEXT & operator=( VkSwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkSwapchainTimingPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainTimingPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkSwapchainTimingPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkSwapchainTimingPropertiesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, refreshDuration, refreshInterval ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( SwapchainTimingPropertiesEXT const & ) const = default; +#else + bool operator==( SwapchainTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( refreshDuration == rhs.refreshDuration ) && ( refreshInterval == rhs.refreshInterval ); +# endif + } + + bool operator!=( SwapchainTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eSwapchainTimingPropertiesEXT; + void * pNext = {}; + uint64_t refreshDuration = {}; + uint64_t refreshInterval = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = SwapchainTimingPropertiesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = SwapchainTimingPropertiesEXT; + }; + + // wrapper struct for struct VkTensorCaptureDescriptorDataInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCaptureDescriptorDataInfoARM.html + struct TensorCaptureDescriptorDataInfoARM + { + using NativeType = VkTensorCaptureDescriptorDataInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorCaptureDescriptorDataInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TensorCaptureDescriptorDataInfoARM( TensorARM tensor_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensor{ tensor_ } + { + } + + VULKAN_HPP_CONSTEXPR TensorCaptureDescriptorDataInfoARM( TensorCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TensorCaptureDescriptorDataInfoARM( VkTensorCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : TensorCaptureDescriptorDataInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + TensorCaptureDescriptorDataInfoARM & operator=( TensorCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TensorCaptureDescriptorDataInfoARM & operator=( VkTensorCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TensorCaptureDescriptorDataInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCaptureDescriptorDataInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorCaptureDescriptorDataInfoARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorCaptureDescriptorDataInfoARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTensorCaptureDescriptorDataInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorCaptureDescriptorDataInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorCaptureDescriptorDataInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTensorCaptureDescriptorDataInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tensor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TensorCaptureDescriptorDataInfoARM const & ) const = default; +#else + bool operator==( TensorCaptureDescriptorDataInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensor == rhs.tensor ); +# endif + } + + bool operator!=( TensorCaptureDescriptorDataInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTensorCaptureDescriptorDataInfoARM; + const void * pNext = {}; + TensorARM tensor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TensorCaptureDescriptorDataInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = TensorCaptureDescriptorDataInfoARM; + }; + + // wrapper struct for struct VkTensorMemoryBarrierARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorMemoryBarrierARM.html + struct TensorMemoryBarrierARM + { + using NativeType = VkTensorMemoryBarrierARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorMemoryBarrierARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TensorMemoryBarrierARM( PipelineStageFlags2 srcStageMask_ = {}, + AccessFlags2 srcAccessMask_ = {}, + PipelineStageFlags2 dstStageMask_ = {}, + AccessFlags2 dstAccessMask_ = {}, + uint32_t srcQueueFamilyIndex_ = {}, + uint32_t dstQueueFamilyIndex_ = {}, + TensorARM tensor_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , srcStageMask{ srcStageMask_ } + , srcAccessMask{ srcAccessMask_ } + , dstStageMask{ dstStageMask_ } + , dstAccessMask{ dstAccessMask_ } + , srcQueueFamilyIndex{ srcQueueFamilyIndex_ } + , dstQueueFamilyIndex{ dstQueueFamilyIndex_ } + , tensor{ tensor_ } + { + } + + VULKAN_HPP_CONSTEXPR TensorMemoryBarrierARM( TensorMemoryBarrierARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TensorMemoryBarrierARM( VkTensorMemoryBarrierARM const & rhs ) VULKAN_HPP_NOEXCEPT + : TensorMemoryBarrierARM( *reinterpret_cast( &rhs ) ) + { + } + + TensorMemoryBarrierARM & operator=( TensorMemoryBarrierARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TensorMemoryBarrierARM & operator=( VkTensorMemoryBarrierARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcStageMask = srcStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + srcAccessMask = srcAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstStageMask = dstStageMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT + { + dstAccessMask = dstAccessMask_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + srcQueueFamilyIndex = srcQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + dstQueueFamilyIndex = dstQueueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTensorMemoryBarrierARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorMemoryBarrierARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorMemoryBarrierARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTensorMemoryBarrierARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, tensor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TensorMemoryBarrierARM const & ) const = default; +#else + bool operator==( TensorMemoryBarrierARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && + ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && + ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( tensor == rhs.tensor ); +# endif + } + + bool operator!=( TensorMemoryBarrierARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTensorMemoryBarrierARM; + const void * pNext = {}; + PipelineStageFlags2 srcStageMask = {}; + AccessFlags2 srcAccessMask = {}; + PipelineStageFlags2 dstStageMask = {}; + AccessFlags2 dstAccessMask = {}; + uint32_t srcQueueFamilyIndex = {}; + uint32_t dstQueueFamilyIndex = {}; + TensorARM tensor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TensorMemoryBarrierARM; + }; +#endif + + template <> + struct CppType + { + using Type = TensorMemoryBarrierARM; + }; + + // wrapper struct for struct VkTensorDependencyInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorDependencyInfoARM.html + struct TensorDependencyInfoARM + { + using NativeType = VkTensorDependencyInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorDependencyInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TensorDependencyInfoARM( uint32_t tensorMemoryBarrierCount_ = {}, + const TensorMemoryBarrierARM * pTensorMemoryBarriers_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensorMemoryBarrierCount{ tensorMemoryBarrierCount_ } + , pTensorMemoryBarriers{ pTensorMemoryBarriers_ } + { + } + + VULKAN_HPP_CONSTEXPR TensorDependencyInfoARM( TensorDependencyInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TensorDependencyInfoARM( VkTensorDependencyInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : TensorDependencyInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + TensorDependencyInfoARM & operator=( TensorDependencyInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TensorDependencyInfoARM & operator=( VkTensorDependencyInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM & setTensorMemoryBarrierCount( uint32_t tensorMemoryBarrierCount_ ) & VULKAN_HPP_NOEXCEPT + { + tensorMemoryBarrierCount = tensorMemoryBarrierCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM && setTensorMemoryBarrierCount( uint32_t tensorMemoryBarrierCount_ ) && VULKAN_HPP_NOEXCEPT + { + tensorMemoryBarrierCount = tensorMemoryBarrierCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM & setPTensorMemoryBarriers( const TensorMemoryBarrierARM * pTensorMemoryBarriers_ ) & VULKAN_HPP_NOEXCEPT + { + pTensorMemoryBarriers = pTensorMemoryBarriers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM && setPTensorMemoryBarriers( const TensorMemoryBarrierARM * pTensorMemoryBarriers_ ) && VULKAN_HPP_NOEXCEPT + { + pTensorMemoryBarriers = pTensorMemoryBarriers_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTensorDependencyInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorDependencyInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorDependencyInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTensorDependencyInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tensorMemoryBarrierCount, pTensorMemoryBarriers ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TensorDependencyInfoARM const & ) const = default; +#else + bool operator==( TensorDependencyInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorMemoryBarrierCount == rhs.tensorMemoryBarrierCount ) && + ( pTensorMemoryBarriers == rhs.pTensorMemoryBarriers ); +# endif + } + + bool operator!=( TensorDependencyInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTensorDependencyInfoARM; + const void * pNext = {}; + uint32_t tensorMemoryBarrierCount = {}; + const TensorMemoryBarrierARM * pTensorMemoryBarriers = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TensorDependencyInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = TensorDependencyInfoARM; + }; + + // wrapper struct for struct VkTensorFormatPropertiesARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorFormatPropertiesARM.html + struct TensorFormatPropertiesARM + { + using NativeType = VkTensorFormatPropertiesARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorFormatPropertiesARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TensorFormatPropertiesARM( FormatFeatureFlags2 optimalTilingTensorFeatures_ = {}, + FormatFeatureFlags2 linearTilingTensorFeatures_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , optimalTilingTensorFeatures{ optimalTilingTensorFeatures_ } + , linearTilingTensorFeatures{ linearTilingTensorFeatures_ } + { + } + + VULKAN_HPP_CONSTEXPR TensorFormatPropertiesARM( TensorFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TensorFormatPropertiesARM( VkTensorFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + : TensorFormatPropertiesARM( *reinterpret_cast( &rhs ) ) + { + } + + TensorFormatPropertiesARM & operator=( TensorFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TensorFormatPropertiesARM & operator=( VkTensorFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkTensorFormatPropertiesARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorFormatPropertiesARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorFormatPropertiesARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTensorFormatPropertiesARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, optimalTilingTensorFeatures, linearTilingTensorFeatures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TensorFormatPropertiesARM const & ) const = default; +#else + bool operator==( TensorFormatPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( optimalTilingTensorFeatures == rhs.optimalTilingTensorFeatures ) && + ( linearTilingTensorFeatures == rhs.linearTilingTensorFeatures ); +# endif + } + + bool operator!=( TensorFormatPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTensorFormatPropertiesARM; + void * pNext = {}; + FormatFeatureFlags2 optimalTilingTensorFeatures = {}; + FormatFeatureFlags2 linearTilingTensorFeatures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TensorFormatPropertiesARM; + }; +#endif + + template <> + struct CppType + { + using Type = TensorFormatPropertiesARM; + }; + + // wrapper struct for struct VkTensorMemoryRequirementsInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorMemoryRequirementsInfoARM.html + struct TensorMemoryRequirementsInfoARM + { + using NativeType = VkTensorMemoryRequirementsInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorMemoryRequirementsInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TensorMemoryRequirementsInfoARM( TensorARM tensor_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensor{ tensor_ } + { + } + + VULKAN_HPP_CONSTEXPR TensorMemoryRequirementsInfoARM( TensorMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TensorMemoryRequirementsInfoARM( VkTensorMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : TensorMemoryRequirementsInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + TensorMemoryRequirementsInfoARM & operator=( TensorMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TensorMemoryRequirementsInfoARM & operator=( VkTensorMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TensorMemoryRequirementsInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryRequirementsInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryRequirementsInfoARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorMemoryRequirementsInfoARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT + { + tensor = tensor_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTensorMemoryRequirementsInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorMemoryRequirementsInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorMemoryRequirementsInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTensorMemoryRequirementsInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tensor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TensorMemoryRequirementsInfoARM const & ) const = default; +#else + bool operator==( TensorMemoryRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensor == rhs.tensor ); +# endif + } + + bool operator!=( TensorMemoryRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTensorMemoryRequirementsInfoARM; + const void * pNext = {}; + TensorARM tensor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TensorMemoryRequirementsInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = TensorMemoryRequirementsInfoARM; + }; + + // wrapper struct for struct VkTensorViewCaptureDescriptorDataInfoARM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCaptureDescriptorDataInfoARM.html + struct TensorViewCaptureDescriptorDataInfoARM + { + using NativeType = VkTensorViewCaptureDescriptorDataInfoARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorViewCaptureDescriptorDataInfoARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TensorViewCaptureDescriptorDataInfoARM( TensorViewARM tensorView_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensorView{ tensorView_ } + { + } + + VULKAN_HPP_CONSTEXPR TensorViewCaptureDescriptorDataInfoARM( TensorViewCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TensorViewCaptureDescriptorDataInfoARM( VkTensorViewCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + : TensorViewCaptureDescriptorDataInfoARM( *reinterpret_cast( &rhs ) ) + { + } + + TensorViewCaptureDescriptorDataInfoARM & operator=( TensorViewCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TensorViewCaptureDescriptorDataInfoARM & operator=( VkTensorViewCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TensorViewCaptureDescriptorDataInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorViewCaptureDescriptorDataInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TensorViewCaptureDescriptorDataInfoARM & setTensorView( TensorViewARM tensorView_ ) & VULKAN_HPP_NOEXCEPT + { + tensorView = tensorView_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TensorViewCaptureDescriptorDataInfoARM && setTensorView( TensorViewARM tensorView_ ) && VULKAN_HPP_NOEXCEPT + { + tensorView = tensorView_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTensorViewCaptureDescriptorDataInfoARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorViewCaptureDescriptorDataInfoARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTensorViewCaptureDescriptorDataInfoARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTensorViewCaptureDescriptorDataInfoARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tensorView ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TensorViewCaptureDescriptorDataInfoARM const & ) const = default; +#else + bool operator==( TensorViewCaptureDescriptorDataInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorView == rhs.tensorView ); +# endif + } + + bool operator!=( TensorViewCaptureDescriptorDataInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTensorViewCaptureDescriptorDataInfoARM; + const void * pNext = {}; + TensorViewARM tensorView = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TensorViewCaptureDescriptorDataInfoARM; + }; +#endif + + template <> + struct CppType + { + using Type = TensorViewCaptureDescriptorDataInfoARM; + }; + + // wrapper struct for struct VkTextureLODGatherFormatPropertiesAMD, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTextureLODGatherFormatPropertiesAMD.html + struct TextureLODGatherFormatPropertiesAMD + { + using NativeType = VkTextureLODGatherFormatPropertiesAMD; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTextureLodGatherFormatPropertiesAMD; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TextureLODGatherFormatPropertiesAMD( Bool32 supportsTextureGatherLODBiasAMD_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , supportsTextureGatherLODBiasAMD{ supportsTextureGatherLODBiasAMD_ } + { + } + + VULKAN_HPP_CONSTEXPR TextureLODGatherFormatPropertiesAMD( TextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + : TextureLODGatherFormatPropertiesAMD( *reinterpret_cast( &rhs ) ) + { + } + + TextureLODGatherFormatPropertiesAMD & operator=( TextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TextureLODGatherFormatPropertiesAMD & operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkTextureLODGatherFormatPropertiesAMD const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTextureLODGatherFormatPropertiesAMD &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTextureLODGatherFormatPropertiesAMD const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTextureLODGatherFormatPropertiesAMD *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, supportsTextureGatherLODBiasAMD ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TextureLODGatherFormatPropertiesAMD const & ) const = default; +#else + bool operator==( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD ); +# endif + } + + bool operator!=( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD; + void * pNext = {}; + Bool32 supportsTextureGatherLODBiasAMD = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TextureLODGatherFormatPropertiesAMD; + }; +#endif + + template <> + struct CppType + { + using Type = TextureLODGatherFormatPropertiesAMD; + }; + + // wrapper struct for struct VkTileMemoryBindInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemoryBindInfoQCOM.html + struct TileMemoryBindInfoQCOM + { + using NativeType = VkTileMemoryBindInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemoryBindInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TileMemoryBindInfoQCOM( DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memory{ memory_ } + { + } + + VULKAN_HPP_CONSTEXPR TileMemoryBindInfoQCOM( TileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TileMemoryBindInfoQCOM( VkTileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : TileMemoryBindInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + TileMemoryBindInfoQCOM & operator=( TileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TileMemoryBindInfoQCOM & operator=( VkTileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT + { + memory = memory_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTileMemoryBindInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemoryBindInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemoryBindInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTileMemoryBindInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memory ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TileMemoryBindInfoQCOM const & ) const = default; +#else + bool operator==( TileMemoryBindInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); +# endif + } + + bool operator!=( TileMemoryBindInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTileMemoryBindInfoQCOM; + const void * pNext = {}; + DeviceMemory memory = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TileMemoryBindInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = TileMemoryBindInfoQCOM; + }; + + // wrapper struct for struct VkTileMemoryRequirementsQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemoryRequirementsQCOM.html + struct TileMemoryRequirementsQCOM + { + using NativeType = VkTileMemoryRequirementsQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemoryRequirementsQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TileMemoryRequirementsQCOM( DeviceSize size_ = {}, DeviceSize alignment_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , size{ size_ } + , alignment{ alignment_ } + { + } + + VULKAN_HPP_CONSTEXPR TileMemoryRequirementsQCOM( TileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TileMemoryRequirementsQCOM( VkTileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : TileMemoryRequirementsQCOM( *reinterpret_cast( &rhs ) ) + { + } + + TileMemoryRequirementsQCOM & operator=( TileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TileMemoryRequirementsQCOM & operator=( VkTileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setAlignment( DeviceSize alignment_ ) & VULKAN_HPP_NOEXCEPT + { + alignment = alignment_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM && setAlignment( DeviceSize alignment_ ) && VULKAN_HPP_NOEXCEPT + { + alignment = alignment_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTileMemoryRequirementsQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemoryRequirementsQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemoryRequirementsQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTileMemoryRequirementsQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, size, alignment ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TileMemoryRequirementsQCOM const & ) const = default; +#else + bool operator==( TileMemoryRequirementsQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( size == rhs.size ) && ( alignment == rhs.alignment ); +# endif + } + + bool operator!=( TileMemoryRequirementsQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTileMemoryRequirementsQCOM; + void * pNext = {}; + DeviceSize size = {}; + DeviceSize alignment = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TileMemoryRequirementsQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = TileMemoryRequirementsQCOM; + }; + + // wrapper struct for struct VkTileMemorySizeInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemorySizeInfoQCOM.html + struct TileMemorySizeInfoQCOM + { + using NativeType = VkTileMemorySizeInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemorySizeInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TileMemorySizeInfoQCOM( DeviceSize size_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , size{ size_ } + { + } + + VULKAN_HPP_CONSTEXPR TileMemorySizeInfoQCOM( TileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TileMemorySizeInfoQCOM( VkTileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : TileMemorySizeInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + TileMemorySizeInfoQCOM & operator=( TileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TileMemorySizeInfoQCOM & operator=( VkTileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT + { + size = size_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT + { + size = size_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTileMemorySizeInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemorySizeInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTileMemorySizeInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTileMemorySizeInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, size ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TileMemorySizeInfoQCOM const & ) const = default; +#else + bool operator==( TileMemorySizeInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( size == rhs.size ); +# endif + } + + bool operator!=( TileMemorySizeInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTileMemorySizeInfoQCOM; + const void * pNext = {}; + DeviceSize size = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TileMemorySizeInfoQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = TileMemorySizeInfoQCOM; + }; + + // wrapper struct for struct VkTilePropertiesQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTilePropertiesQCOM.html + struct TilePropertiesQCOM + { + using NativeType = VkTilePropertiesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTilePropertiesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + TilePropertiesQCOM( Extent3D tileSize_ = {}, Extent2D apronSize_ = {}, Offset2D origin_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tileSize{ tileSize_ } + , apronSize{ apronSize_ } + , origin{ origin_ } + { + } + + VULKAN_HPP_CONSTEXPR TilePropertiesQCOM( TilePropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TilePropertiesQCOM( VkTilePropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT : TilePropertiesQCOM( *reinterpret_cast( &rhs ) ) {} + + TilePropertiesQCOM & operator=( TilePropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TilePropertiesQCOM & operator=( VkTilePropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM & setTileSize( Extent3D const & tileSize_ ) & VULKAN_HPP_NOEXCEPT + { + tileSize = tileSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM && setTileSize( Extent3D const & tileSize_ ) && VULKAN_HPP_NOEXCEPT + { + tileSize = tileSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM & setApronSize( Extent2D const & apronSize_ ) & VULKAN_HPP_NOEXCEPT + { + apronSize = apronSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM && setApronSize( Extent2D const & apronSize_ ) && VULKAN_HPP_NOEXCEPT + { + apronSize = apronSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM & setOrigin( Offset2D const & origin_ ) & VULKAN_HPP_NOEXCEPT + { + origin = origin_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM && setOrigin( Offset2D const & origin_ ) && VULKAN_HPP_NOEXCEPT + { + origin = origin_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTilePropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTilePropertiesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTilePropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTilePropertiesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tileSize, apronSize, origin ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TilePropertiesQCOM const & ) const = default; +#else + bool operator==( TilePropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tileSize == rhs.tileSize ) && ( apronSize == rhs.apronSize ) && ( origin == rhs.origin ); +# endif + } + + bool operator!=( TilePropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTilePropertiesQCOM; + void * pNext = {}; + Extent3D tileSize = {}; + Extent2D apronSize = {}; + Offset2D origin = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TilePropertiesQCOM; + }; +#endif + + template <> + struct CppType + { + using Type = TilePropertiesQCOM; + }; + + // wrapper struct for struct VkTimelineSemaphoreSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTimelineSemaphoreSubmitInfo.html + struct TimelineSemaphoreSubmitInfo + { + using NativeType = VkTimelineSemaphoreSubmitInfo; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTimelineSemaphoreSubmitInfo; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfo( uint32_t waitSemaphoreValueCount_ = {}, + const uint64_t * pWaitSemaphoreValues_ = {}, + uint32_t signalSemaphoreValueCount_ = {}, + const uint64_t * pSignalSemaphoreValues_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , waitSemaphoreValueCount{ waitSemaphoreValueCount_ } + , pWaitSemaphoreValues{ pWaitSemaphoreValues_ } + , signalSemaphoreValueCount{ signalSemaphoreValueCount_ } + , pSignalSemaphoreValues{ pSignalSemaphoreValues_ } + { + } + + VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfo( TimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TimelineSemaphoreSubmitInfo( VkTimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + : TimelineSemaphoreSubmitInfo( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TimelineSemaphoreSubmitInfo( ArrayProxyNoTemporaries const & waitSemaphoreValues_, + ArrayProxyNoTemporaries const & signalSemaphoreValues_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , waitSemaphoreValueCount( static_cast( waitSemaphoreValues_.size() ) ) + , pWaitSemaphoreValues( waitSemaphoreValues_.data() ) + , signalSemaphoreValueCount( static_cast( signalSemaphoreValues_.size() ) ) + , pSignalSemaphoreValues( signalSemaphoreValues_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + TimelineSemaphoreSubmitInfo & operator=( TimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TimelineSemaphoreSubmitInfo & operator=( VkTimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo & setWaitSemaphoreValueCount( uint32_t waitSemaphoreValueCount_ ) & VULKAN_HPP_NOEXCEPT + { + waitSemaphoreValueCount = waitSemaphoreValueCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo && setWaitSemaphoreValueCount( uint32_t waitSemaphoreValueCount_ ) && VULKAN_HPP_NOEXCEPT + { + waitSemaphoreValueCount = waitSemaphoreValueCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo & setPWaitSemaphoreValues( const uint64_t * pWaitSemaphoreValues_ ) & VULKAN_HPP_NOEXCEPT + { + pWaitSemaphoreValues = pWaitSemaphoreValues_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo && setPWaitSemaphoreValues( const uint64_t * pWaitSemaphoreValues_ ) && VULKAN_HPP_NOEXCEPT + { + pWaitSemaphoreValues = pWaitSemaphoreValues_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TimelineSemaphoreSubmitInfo & setWaitSemaphoreValues( ArrayProxyNoTemporaries const & waitSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT + { + waitSemaphoreValueCount = static_cast( waitSemaphoreValues_.size() ); + pWaitSemaphoreValues = waitSemaphoreValues_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo & setSignalSemaphoreValueCount( uint32_t signalSemaphoreValueCount_ ) & VULKAN_HPP_NOEXCEPT + { + signalSemaphoreValueCount = signalSemaphoreValueCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo && setSignalSemaphoreValueCount( uint32_t signalSemaphoreValueCount_ ) && VULKAN_HPP_NOEXCEPT + { + signalSemaphoreValueCount = signalSemaphoreValueCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo & setPSignalSemaphoreValues( const uint64_t * pSignalSemaphoreValues_ ) & VULKAN_HPP_NOEXCEPT + { + pSignalSemaphoreValues = pSignalSemaphoreValues_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo && setPSignalSemaphoreValues( const uint64_t * pSignalSemaphoreValues_ ) && VULKAN_HPP_NOEXCEPT + { + pSignalSemaphoreValues = pSignalSemaphoreValues_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + TimelineSemaphoreSubmitInfo & setSignalSemaphoreValues( ArrayProxyNoTemporaries const & signalSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT + { + signalSemaphoreValueCount = static_cast( signalSemaphoreValues_.size() ); + pSignalSemaphoreValues = signalSemaphoreValues_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTimelineSemaphoreSubmitInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTimelineSemaphoreSubmitInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTimelineSemaphoreSubmitInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTimelineSemaphoreSubmitInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, waitSemaphoreValueCount, pWaitSemaphoreValues, signalSemaphoreValueCount, pSignalSemaphoreValues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TimelineSemaphoreSubmitInfo const & ) const = default; +#else + bool operator==( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreValueCount == rhs.waitSemaphoreValueCount ) && + ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) && ( signalSemaphoreValueCount == rhs.signalSemaphoreValueCount ) && + ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); +# endif + } + + bool operator!=( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eTimelineSemaphoreSubmitInfo; + const void * pNext = {}; + uint32_t waitSemaphoreValueCount = {}; + const uint64_t * pWaitSemaphoreValues = {}; + uint32_t signalSemaphoreValueCount = {}; + const uint64_t * pSignalSemaphoreValues = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TimelineSemaphoreSubmitInfo; + }; +#endif + + template <> + struct CppType + { + using Type = TimelineSemaphoreSubmitInfo; + }; + + using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo; + + // wrapper struct for struct VkTraceRaysIndirectCommand2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTraceRaysIndirectCommand2KHR.html + struct TraceRaysIndirectCommand2KHR + { + using NativeType = VkTraceRaysIndirectCommand2KHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommand2KHR( DeviceAddress raygenShaderRecordAddress_ = {}, + DeviceSize raygenShaderRecordSize_ = {}, + DeviceAddress missShaderBindingTableAddress_ = {}, + DeviceSize missShaderBindingTableSize_ = {}, + DeviceSize missShaderBindingTableStride_ = {}, + DeviceAddress hitShaderBindingTableAddress_ = {}, + DeviceSize hitShaderBindingTableSize_ = {}, + DeviceSize hitShaderBindingTableStride_ = {}, + DeviceAddress callableShaderBindingTableAddress_ = {}, + DeviceSize callableShaderBindingTableSize_ = {}, + DeviceSize callableShaderBindingTableStride_ = {}, + uint32_t width_ = {}, + uint32_t height_ = {}, + uint32_t depth_ = {} ) VULKAN_HPP_NOEXCEPT + : raygenShaderRecordAddress{ raygenShaderRecordAddress_ } + , raygenShaderRecordSize{ raygenShaderRecordSize_ } + , missShaderBindingTableAddress{ missShaderBindingTableAddress_ } + , missShaderBindingTableSize{ missShaderBindingTableSize_ } + , missShaderBindingTableStride{ missShaderBindingTableStride_ } + , hitShaderBindingTableAddress{ hitShaderBindingTableAddress_ } + , hitShaderBindingTableSize{ hitShaderBindingTableSize_ } + , hitShaderBindingTableStride{ hitShaderBindingTableStride_ } + , callableShaderBindingTableAddress{ callableShaderBindingTableAddress_ } + , callableShaderBindingTableSize{ callableShaderBindingTableSize_ } + , callableShaderBindingTableStride{ callableShaderBindingTableStride_ } + , width{ width_ } + , height{ height_ } + , depth{ depth_ } + { + } + + VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommand2KHR( TraceRaysIndirectCommand2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TraceRaysIndirectCommand2KHR( VkTraceRaysIndirectCommand2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + : TraceRaysIndirectCommand2KHR( *reinterpret_cast( &rhs ) ) + { + } + + TraceRaysIndirectCommand2KHR & operator=( TraceRaysIndirectCommand2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TraceRaysIndirectCommand2KHR & operator=( VkTraceRaysIndirectCommand2KHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setRaygenShaderRecordAddress( DeviceAddress raygenShaderRecordAddress_ ) & VULKAN_HPP_NOEXCEPT + { + raygenShaderRecordAddress = raygenShaderRecordAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setRaygenShaderRecordAddress( DeviceAddress raygenShaderRecordAddress_ ) && VULKAN_HPP_NOEXCEPT + { + raygenShaderRecordAddress = raygenShaderRecordAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setRaygenShaderRecordSize( DeviceSize raygenShaderRecordSize_ ) & VULKAN_HPP_NOEXCEPT + { + raygenShaderRecordSize = raygenShaderRecordSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setRaygenShaderRecordSize( DeviceSize raygenShaderRecordSize_ ) && VULKAN_HPP_NOEXCEPT + { + raygenShaderRecordSize = raygenShaderRecordSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setMissShaderBindingTableAddress( DeviceAddress missShaderBindingTableAddress_ ) & + VULKAN_HPP_NOEXCEPT + { + missShaderBindingTableAddress = missShaderBindingTableAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setMissShaderBindingTableAddress( DeviceAddress missShaderBindingTableAddress_ ) && + VULKAN_HPP_NOEXCEPT + { + missShaderBindingTableAddress = missShaderBindingTableAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setMissShaderBindingTableSize( DeviceSize missShaderBindingTableSize_ ) & VULKAN_HPP_NOEXCEPT + { + missShaderBindingTableSize = missShaderBindingTableSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setMissShaderBindingTableSize( DeviceSize missShaderBindingTableSize_ ) && VULKAN_HPP_NOEXCEPT + { + missShaderBindingTableSize = missShaderBindingTableSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setMissShaderBindingTableStride( DeviceSize missShaderBindingTableStride_ ) & VULKAN_HPP_NOEXCEPT + { + missShaderBindingTableStride = missShaderBindingTableStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setMissShaderBindingTableStride( DeviceSize missShaderBindingTableStride_ ) && VULKAN_HPP_NOEXCEPT + { + missShaderBindingTableStride = missShaderBindingTableStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setHitShaderBindingTableAddress( DeviceAddress hitShaderBindingTableAddress_ ) & VULKAN_HPP_NOEXCEPT + { + hitShaderBindingTableAddress = hitShaderBindingTableAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setHitShaderBindingTableAddress( DeviceAddress hitShaderBindingTableAddress_ ) && + VULKAN_HPP_NOEXCEPT + { + hitShaderBindingTableAddress = hitShaderBindingTableAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setHitShaderBindingTableSize( DeviceSize hitShaderBindingTableSize_ ) & VULKAN_HPP_NOEXCEPT + { + hitShaderBindingTableSize = hitShaderBindingTableSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setHitShaderBindingTableSize( DeviceSize hitShaderBindingTableSize_ ) && VULKAN_HPP_NOEXCEPT + { + hitShaderBindingTableSize = hitShaderBindingTableSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setHitShaderBindingTableStride( DeviceSize hitShaderBindingTableStride_ ) & VULKAN_HPP_NOEXCEPT + { + hitShaderBindingTableStride = hitShaderBindingTableStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setHitShaderBindingTableStride( DeviceSize hitShaderBindingTableStride_ ) && VULKAN_HPP_NOEXCEPT + { + hitShaderBindingTableStride = hitShaderBindingTableStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setCallableShaderBindingTableAddress( DeviceAddress callableShaderBindingTableAddress_ ) & + VULKAN_HPP_NOEXCEPT + { + callableShaderBindingTableAddress = callableShaderBindingTableAddress_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setCallableShaderBindingTableAddress( DeviceAddress callableShaderBindingTableAddress_ ) && + VULKAN_HPP_NOEXCEPT + { + callableShaderBindingTableAddress = callableShaderBindingTableAddress_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setCallableShaderBindingTableSize( DeviceSize callableShaderBindingTableSize_ ) & VULKAN_HPP_NOEXCEPT + { + callableShaderBindingTableSize = callableShaderBindingTableSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setCallableShaderBindingTableSize( DeviceSize callableShaderBindingTableSize_ ) && + VULKAN_HPP_NOEXCEPT + { + callableShaderBindingTableSize = callableShaderBindingTableSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setCallableShaderBindingTableStride( DeviceSize callableShaderBindingTableStride_ ) & + VULKAN_HPP_NOEXCEPT + { + callableShaderBindingTableStride = callableShaderBindingTableStride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setCallableShaderBindingTableStride( DeviceSize callableShaderBindingTableStride_ ) && + VULKAN_HPP_NOEXCEPT + { + callableShaderBindingTableStride = callableShaderBindingTableStride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT + { + width = width_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT + { + width = width_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT + { + height = height_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT + { + height = height_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setDepth( uint32_t depth_ ) & VULKAN_HPP_NOEXCEPT + { + depth = depth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setDepth( uint32_t depth_ ) && VULKAN_HPP_NOEXCEPT + { + depth = depth_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTraceRaysIndirectCommand2KHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTraceRaysIndirectCommand2KHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTraceRaysIndirectCommand2KHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTraceRaysIndirectCommand2KHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( raygenShaderRecordAddress, + raygenShaderRecordSize, + missShaderBindingTableAddress, + missShaderBindingTableSize, + missShaderBindingTableStride, + hitShaderBindingTableAddress, + hitShaderBindingTableSize, + hitShaderBindingTableStride, + callableShaderBindingTableAddress, + callableShaderBindingTableSize, + callableShaderBindingTableStride, + width, + height, + depth ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TraceRaysIndirectCommand2KHR const & ) const = default; +#else + bool operator==( TraceRaysIndirectCommand2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( raygenShaderRecordAddress == rhs.raygenShaderRecordAddress ) && ( raygenShaderRecordSize == rhs.raygenShaderRecordSize ) && + ( missShaderBindingTableAddress == rhs.missShaderBindingTableAddress ) && ( missShaderBindingTableSize == rhs.missShaderBindingTableSize ) && + ( missShaderBindingTableStride == rhs.missShaderBindingTableStride ) && ( hitShaderBindingTableAddress == rhs.hitShaderBindingTableAddress ) && + ( hitShaderBindingTableSize == rhs.hitShaderBindingTableSize ) && ( hitShaderBindingTableStride == rhs.hitShaderBindingTableStride ) && + ( callableShaderBindingTableAddress == rhs.callableShaderBindingTableAddress ) && + ( callableShaderBindingTableSize == rhs.callableShaderBindingTableSize ) && + ( callableShaderBindingTableStride == rhs.callableShaderBindingTableStride ) && ( width == rhs.width ) && ( height == rhs.height ) && + ( depth == rhs.depth ); +# endif + } + + bool operator!=( TraceRaysIndirectCommand2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + DeviceAddress raygenShaderRecordAddress = {}; + DeviceSize raygenShaderRecordSize = {}; + DeviceAddress missShaderBindingTableAddress = {}; + DeviceSize missShaderBindingTableSize = {}; + DeviceSize missShaderBindingTableStride = {}; + DeviceAddress hitShaderBindingTableAddress = {}; + DeviceSize hitShaderBindingTableSize = {}; + DeviceSize hitShaderBindingTableStride = {}; + DeviceAddress callableShaderBindingTableAddress = {}; + DeviceSize callableShaderBindingTableSize = {}; + DeviceSize callableShaderBindingTableStride = {}; + uint32_t width = {}; + uint32_t height = {}; + uint32_t depth = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TraceRaysIndirectCommand2KHR; + }; +#endif + + // wrapper struct for struct VkTraceRaysIndirectCommandKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTraceRaysIndirectCommandKHR.html + struct TraceRaysIndirectCommandKHR + { + using NativeType = VkTraceRaysIndirectCommandKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommandKHR( uint32_t width_ = {}, uint32_t height_ = {}, uint32_t depth_ = {} ) VULKAN_HPP_NOEXCEPT + : width{ width_ } + , height{ height_ } + , depth{ depth_ } + { + } + + VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommandKHR( TraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + TraceRaysIndirectCommandKHR( VkTraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : TraceRaysIndirectCommandKHR( *reinterpret_cast( &rhs ) ) + { + } + + explicit TraceRaysIndirectCommandKHR( Extent2D const & extent2D, uint32_t depth_ = {} ) + : width( extent2D.width ), height( extent2D.height ), depth( depth_ ) + { + } + + TraceRaysIndirectCommandKHR & operator=( TraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + TraceRaysIndirectCommandKHR & operator=( VkTraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT + { + width = width_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT + { + width = width_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT + { + height = height_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT + { + height = height_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR & setDepth( uint32_t depth_ ) & VULKAN_HPP_NOEXCEPT + { + depth = depth_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR && setDepth( uint32_t depth_ ) && VULKAN_HPP_NOEXCEPT + { + depth = depth_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkTraceRaysIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTraceRaysIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkTraceRaysIndirectCommandKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkTraceRaysIndirectCommandKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( width, height, depth ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( TraceRaysIndirectCommandKHR const & ) const = default; +#else + bool operator==( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth ); +# endif + } + + bool operator!=( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t width = {}; + uint32_t height = {}; + uint32_t depth = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = TraceRaysIndirectCommandKHR; + }; +#endif + + // wrapper struct for struct VkValidationCacheCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheCreateInfoEXT.html + struct ValidationCacheCreateInfoEXT + { + using NativeType = VkValidationCacheCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationCacheCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = {}, + size_t initialDataSize_ = {}, + const void * pInitialData_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , initialDataSize{ initialDataSize_ } + , pInitialData{ pInitialData_ } + { + } + + VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( ValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ValidationCacheCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_, ArrayProxyNoTemporaries const & initialData_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), flags( flags_ ), initialDataSize( initialData_.size() * sizeof( T ) ), pInitialData( initialData_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ValidationCacheCreateInfoEXT & operator=( ValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ValidationCacheCreateInfoEXT & operator=( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT & setFlags( ValidationCacheCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT && setFlags( ValidationCacheCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT & setInitialDataSize( size_t initialDataSize_ ) & VULKAN_HPP_NOEXCEPT + { + initialDataSize = initialDataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT && setInitialDataSize( size_t initialDataSize_ ) && VULKAN_HPP_NOEXCEPT + { + initialDataSize = initialDataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT & setPInitialData( const void * pInitialData_ ) & VULKAN_HPP_NOEXCEPT + { + pInitialData = pInitialData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT && setPInitialData( const void * pInitialData_ ) && VULKAN_HPP_NOEXCEPT + { + pInitialData = pInitialData_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + ValidationCacheCreateInfoEXT & setInitialData( ArrayProxyNoTemporaries const & initialData_ ) VULKAN_HPP_NOEXCEPT + { + initialDataSize = initialData_.size() * sizeof( T ); + pInitialData = initialData_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkValidationCacheCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkValidationCacheCreateInfoEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, initialDataSize, pInitialData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ValidationCacheCreateInfoEXT const & ) const = default; +#else + bool operator==( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( initialDataSize == rhs.initialDataSize ) && + ( pInitialData == rhs.pInitialData ); +# endif + } + + bool operator!=( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eValidationCacheCreateInfoEXT; + const void * pNext = {}; + ValidationCacheCreateFlagsEXT flags = {}; + size_t initialDataSize = {}; + const void * pInitialData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ValidationCacheCreateInfoEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ValidationCacheCreateInfoEXT; + }; + + // wrapper struct for struct VkValidationFeaturesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationFeaturesEXT.html + struct ValidationFeaturesEXT + { + using NativeType = VkValidationFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = {}, + const ValidationFeatureEnableEXT * pEnabledValidationFeatures_ = {}, + uint32_t disabledValidationFeatureCount_ = {}, + const ValidationFeatureDisableEXT * pDisabledValidationFeatures_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , enabledValidationFeatureCount{ enabledValidationFeatureCount_ } + , pEnabledValidationFeatures{ pEnabledValidationFeatures_ } + , disabledValidationFeatureCount{ disabledValidationFeatureCount_ } + , pDisabledValidationFeatures{ pDisabledValidationFeatures_ } + { + } + + VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( ValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : ValidationFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ValidationFeaturesEXT( ArrayProxyNoTemporaries const & enabledValidationFeatures_, + ArrayProxyNoTemporaries const & disabledValidationFeatures_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , enabledValidationFeatureCount( static_cast( enabledValidationFeatures_.size() ) ) + , pEnabledValidationFeatures( enabledValidationFeatures_.data() ) + , disabledValidationFeatureCount( static_cast( disabledValidationFeatures_.size() ) ) + , pDisabledValidationFeatures( disabledValidationFeatures_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ValidationFeaturesEXT & operator=( ValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ValidationFeaturesEXT & operator=( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT & setEnabledValidationFeatureCount( uint32_t enabledValidationFeatureCount_ ) & VULKAN_HPP_NOEXCEPT + { + enabledValidationFeatureCount = enabledValidationFeatureCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT && setEnabledValidationFeatureCount( uint32_t enabledValidationFeatureCount_ ) && VULKAN_HPP_NOEXCEPT + { + enabledValidationFeatureCount = enabledValidationFeatureCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT & setPEnabledValidationFeatures( const ValidationFeatureEnableEXT * pEnabledValidationFeatures_ ) & + VULKAN_HPP_NOEXCEPT + { + pEnabledValidationFeatures = pEnabledValidationFeatures_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT && setPEnabledValidationFeatures( const ValidationFeatureEnableEXT * pEnabledValidationFeatures_ ) && + VULKAN_HPP_NOEXCEPT + { + pEnabledValidationFeatures = pEnabledValidationFeatures_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ValidationFeaturesEXT & + setEnabledValidationFeatures( ArrayProxyNoTemporaries const & enabledValidationFeatures_ ) VULKAN_HPP_NOEXCEPT + { + enabledValidationFeatureCount = static_cast( enabledValidationFeatures_.size() ); + pEnabledValidationFeatures = enabledValidationFeatures_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT & setDisabledValidationFeatureCount( uint32_t disabledValidationFeatureCount_ ) & VULKAN_HPP_NOEXCEPT + { + disabledValidationFeatureCount = disabledValidationFeatureCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT && setDisabledValidationFeatureCount( uint32_t disabledValidationFeatureCount_ ) && VULKAN_HPP_NOEXCEPT + { + disabledValidationFeatureCount = disabledValidationFeatureCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT & setPDisabledValidationFeatures( const ValidationFeatureDisableEXT * pDisabledValidationFeatures_ ) & + VULKAN_HPP_NOEXCEPT + { + pDisabledValidationFeatures = pDisabledValidationFeatures_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT && setPDisabledValidationFeatures( const ValidationFeatureDisableEXT * pDisabledValidationFeatures_ ) && + VULKAN_HPP_NOEXCEPT + { + pDisabledValidationFeatures = pDisabledValidationFeatures_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ValidationFeaturesEXT & + setDisabledValidationFeatures( ArrayProxyNoTemporaries const & disabledValidationFeatures_ ) VULKAN_HPP_NOEXCEPT + { + disabledValidationFeatureCount = static_cast( disabledValidationFeatures_.size() ); + pDisabledValidationFeatures = disabledValidationFeatures_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkValidationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkValidationFeaturesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkValidationFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkValidationFeaturesEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, enabledValidationFeatureCount, pEnabledValidationFeatures, disabledValidationFeatureCount, pDisabledValidationFeatures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ValidationFeaturesEXT const & ) const = default; +#else + bool operator==( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( enabledValidationFeatureCount == rhs.enabledValidationFeatureCount ) && + ( pEnabledValidationFeatures == rhs.pEnabledValidationFeatures ) && ( disabledValidationFeatureCount == rhs.disabledValidationFeatureCount ) && + ( pDisabledValidationFeatures == rhs.pDisabledValidationFeatures ); +# endif + } + + bool operator!=( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eValidationFeaturesEXT; + const void * pNext = {}; + uint32_t enabledValidationFeatureCount = {}; + const ValidationFeatureEnableEXT * pEnabledValidationFeatures = {}; + uint32_t disabledValidationFeatureCount = {}; + const ValidationFeatureDisableEXT * pDisabledValidationFeatures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ValidationFeaturesEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ValidationFeaturesEXT; + }; + + // wrapper struct for struct VkValidationFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationFlagsEXT.html + struct ValidationFlagsEXT + { + using NativeType = VkValidationFlagsEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationFlagsEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = {}, + const ValidationCheckEXT * pDisabledValidationChecks_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , disabledValidationCheckCount{ disabledValidationCheckCount_ } + , pDisabledValidationChecks{ pDisabledValidationChecks_ } + { + } + + VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( ValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT : ValidationFlagsEXT( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ValidationFlagsEXT( ArrayProxyNoTemporaries const & disabledValidationChecks_, const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , disabledValidationCheckCount( static_cast( disabledValidationChecks_.size() ) ) + , pDisabledValidationChecks( disabledValidationChecks_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ValidationFlagsEXT & operator=( ValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ValidationFlagsEXT & operator=( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT & setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ ) & VULKAN_HPP_NOEXCEPT + { + disabledValidationCheckCount = disabledValidationCheckCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT && setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ ) && VULKAN_HPP_NOEXCEPT + { + disabledValidationCheckCount = disabledValidationCheckCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT & setPDisabledValidationChecks( const ValidationCheckEXT * pDisabledValidationChecks_ ) & VULKAN_HPP_NOEXCEPT + { + pDisabledValidationChecks = pDisabledValidationChecks_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT && setPDisabledValidationChecks( const ValidationCheckEXT * pDisabledValidationChecks_ ) && VULKAN_HPP_NOEXCEPT + { + pDisabledValidationChecks = pDisabledValidationChecks_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ValidationFlagsEXT & setDisabledValidationChecks( ArrayProxyNoTemporaries const & disabledValidationChecks_ ) VULKAN_HPP_NOEXCEPT + { + disabledValidationCheckCount = static_cast( disabledValidationChecks_.size() ); + pDisabledValidationChecks = disabledValidationChecks_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkValidationFlagsEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkValidationFlagsEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkValidationFlagsEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkValidationFlagsEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, disabledValidationCheckCount, pDisabledValidationChecks ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ValidationFlagsEXT const & ) const = default; +#else + bool operator==( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) && + ( pDisabledValidationChecks == rhs.pDisabledValidationChecks ); +# endif + } + + bool operator!=( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eValidationFlagsEXT; + const void * pNext = {}; + uint32_t disabledValidationCheckCount = {}; + const ValidationCheckEXT * pDisabledValidationChecks = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ValidationFlagsEXT; + }; +#endif + + template <> + struct CppType + { + using Type = ValidationFlagsEXT; + }; + + // wrapper struct for struct VkVertexInputAttributeDescription2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputAttributeDescription2EXT.html + struct VertexInputAttributeDescription2EXT + { + using NativeType = VkVertexInputAttributeDescription2EXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVertexInputAttributeDescription2EXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription2EXT( + uint32_t location_ = {}, uint32_t binding_ = {}, Format format_ = Format::eUndefined, uint32_t offset_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , location{ location_ } + , binding{ binding_ } + , format{ format_ } + , offset{ offset_ } + { + } + + VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription2EXT( VertexInputAttributeDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VertexInputAttributeDescription2EXT( VkVertexInputAttributeDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VertexInputAttributeDescription2EXT( *reinterpret_cast( &rhs ) ) + { + } + + VertexInputAttributeDescription2EXT & operator=( VertexInputAttributeDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VertexInputAttributeDescription2EXT & operator=( VkVertexInputAttributeDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT & setLocation( uint32_t location_ ) & VULKAN_HPP_NOEXCEPT + { + location = location_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT && setLocation( uint32_t location_ ) && VULKAN_HPP_NOEXCEPT + { + location = location_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT + { + format = format_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT + { + format = format_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT + { + offset = offset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVertexInputAttributeDescription2EXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputAttributeDescription2EXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputAttributeDescription2EXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVertexInputAttributeDescription2EXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, location, binding, format, offset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VertexInputAttributeDescription2EXT const & ) const = default; +#else + bool operator==( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( location == rhs.location ) && ( binding == rhs.binding ) && ( format == rhs.format ) && + ( offset == rhs.offset ); +# endif + } + + bool operator!=( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVertexInputAttributeDescription2EXT; + void * pNext = {}; + uint32_t location = {}; + uint32_t binding = {}; + Format format = Format::eUndefined; + uint32_t offset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VertexInputAttributeDescription2EXT; + }; +#endif + + template <> + struct CppType + { + using Type = VertexInputAttributeDescription2EXT; + }; + + // wrapper struct for struct VkVertexInputBindingDescription2EXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputBindingDescription2EXT.html + struct VertexInputBindingDescription2EXT + { + using NativeType = VkVertexInputBindingDescription2EXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVertexInputBindingDescription2EXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VertexInputBindingDescription2EXT( uint32_t binding_ = {}, + uint32_t stride_ = {}, + VertexInputRate inputRate_ = VertexInputRate::eVertex, + uint32_t divisor_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , binding{ binding_ } + , stride{ stride_ } + , inputRate{ inputRate_ } + , divisor{ divisor_ } + { + } + + VULKAN_HPP_CONSTEXPR VertexInputBindingDescription2EXT( VertexInputBindingDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VertexInputBindingDescription2EXT( VkVertexInputBindingDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + : VertexInputBindingDescription2EXT( *reinterpret_cast( &rhs ) ) + { + } + + VertexInputBindingDescription2EXT & operator=( VertexInputBindingDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VertexInputBindingDescription2EXT & operator=( VkVertexInputBindingDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT + { + binding = binding_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT + { + stride = stride_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT & setInputRate( VertexInputRate inputRate_ ) & VULKAN_HPP_NOEXCEPT + { + inputRate = inputRate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT && setInputRate( VertexInputRate inputRate_ ) && VULKAN_HPP_NOEXCEPT + { + inputRate = inputRate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT & setDivisor( uint32_t divisor_ ) & VULKAN_HPP_NOEXCEPT + { + divisor = divisor_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT && setDivisor( uint32_t divisor_ ) && VULKAN_HPP_NOEXCEPT + { + divisor = divisor_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVertexInputBindingDescription2EXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputBindingDescription2EXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVertexInputBindingDescription2EXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVertexInputBindingDescription2EXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, binding, stride, inputRate, divisor ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VertexInputBindingDescription2EXT const & ) const = default; +#else + bool operator==( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( binding == rhs.binding ) && ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ) && + ( divisor == rhs.divisor ); +# endif + } + + bool operator!=( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVertexInputBindingDescription2EXT; + void * pNext = {}; + uint32_t binding = {}; + uint32_t stride = {}; + VertexInputRate inputRate = VertexInputRate::eVertex; + uint32_t divisor = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VertexInputBindingDescription2EXT; + }; +#endif + + template <> + struct CppType + { + using Type = VertexInputBindingDescription2EXT; + }; + +#if defined( VK_USE_PLATFORM_VI_NN ) + // wrapper struct for struct VkViSurfaceCreateInfoNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViSurfaceCreateInfoNN.html + struct ViSurfaceCreateInfoNN + { + using NativeType = VkViSurfaceCreateInfoNN; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eViSurfaceCreateInfoNN; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = {}, void * window_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , window{ window_ } + { + } + + VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( ViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT + : ViSurfaceCreateInfoNN( *reinterpret_cast( &rhs ) ) + { + } + + ViSurfaceCreateInfoNN & operator=( ViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ViSurfaceCreateInfoNN & operator=( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN & setFlags( ViSurfaceCreateFlagsNN flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN && setFlags( ViSurfaceCreateFlagsNN flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN & setWindow( void * window_ ) & VULKAN_HPP_NOEXCEPT + { + window = window_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN && setWindow( void * window_ ) && VULKAN_HPP_NOEXCEPT + { + window = window_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkViSurfaceCreateInfoNN const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkViSurfaceCreateInfoNN &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkViSurfaceCreateInfoNN const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkViSurfaceCreateInfoNN *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, window ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ViSurfaceCreateInfoNN const & ) const = default; +# else + bool operator==( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); +# endif + } + + bool operator!=( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eViSurfaceCreateInfoNN; + const void * pNext = {}; + ViSurfaceCreateFlagsNN flags = {}; + void * window = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = ViSurfaceCreateInfoNN; + }; +# endif + + template <> + struct CppType + { + using Type = ViSurfaceCreateInfoNN; + }; +#endif /*VK_USE_PLATFORM_VI_NN*/ + + // wrapper struct for struct VkVideoPictureResourceInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoPictureResourceInfoKHR.html + struct VideoPictureResourceInfoKHR + { + using NativeType = VkVideoPictureResourceInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoPictureResourceInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoPictureResourceInfoKHR( Offset2D codedOffset_ = {}, + Extent2D codedExtent_ = {}, + uint32_t baseArrayLayer_ = {}, + ImageView imageViewBinding_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , codedOffset{ codedOffset_ } + , codedExtent{ codedExtent_ } + , baseArrayLayer{ baseArrayLayer_ } + , imageViewBinding{ imageViewBinding_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoPictureResourceInfoKHR( VideoPictureResourceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoPictureResourceInfoKHR( VkVideoPictureResourceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoPictureResourceInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoPictureResourceInfoKHR & operator=( VideoPictureResourceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoPictureResourceInfoKHR & operator=( VkVideoPictureResourceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR & setCodedOffset( Offset2D const & codedOffset_ ) & VULKAN_HPP_NOEXCEPT + { + codedOffset = codedOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR && setCodedOffset( Offset2D const & codedOffset_ ) && VULKAN_HPP_NOEXCEPT + { + codedOffset = codedOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR & setCodedExtent( Extent2D const & codedExtent_ ) & VULKAN_HPP_NOEXCEPT + { + codedExtent = codedExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR && setCodedExtent( Extent2D const & codedExtent_ ) && VULKAN_HPP_NOEXCEPT + { + codedExtent = codedExtent_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR & setBaseArrayLayer( uint32_t baseArrayLayer_ ) & VULKAN_HPP_NOEXCEPT + { + baseArrayLayer = baseArrayLayer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR && setBaseArrayLayer( uint32_t baseArrayLayer_ ) && VULKAN_HPP_NOEXCEPT + { + baseArrayLayer = baseArrayLayer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR & setImageViewBinding( ImageView imageViewBinding_ ) & VULKAN_HPP_NOEXCEPT + { + imageViewBinding = imageViewBinding_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR && setImageViewBinding( ImageView imageViewBinding_ ) && VULKAN_HPP_NOEXCEPT + { + imageViewBinding = imageViewBinding_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoPictureResourceInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoPictureResourceInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoPictureResourceInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoPictureResourceInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, codedOffset, codedExtent, baseArrayLayer, imageViewBinding ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoPictureResourceInfoKHR const & ) const = default; +#else + bool operator==( VideoPictureResourceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( codedOffset == rhs.codedOffset ) && ( codedExtent == rhs.codedExtent ) && + ( baseArrayLayer == rhs.baseArrayLayer ) && ( imageViewBinding == rhs.imageViewBinding ); +# endif + } + + bool operator!=( VideoPictureResourceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoPictureResourceInfoKHR; + const void * pNext = {}; + Offset2D codedOffset = {}; + Extent2D codedExtent = {}; + uint32_t baseArrayLayer = {}; + ImageView imageViewBinding = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoPictureResourceInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoPictureResourceInfoKHR; + }; + + // wrapper struct for struct VkVideoReferenceSlotInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoReferenceSlotInfoKHR.html + struct VideoReferenceSlotInfoKHR + { + using NativeType = VkVideoReferenceSlotInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoReferenceSlotInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoReferenceSlotInfoKHR( int32_t slotIndex_ = {}, + const VideoPictureResourceInfoKHR * pPictureResource_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , slotIndex{ slotIndex_ } + , pPictureResource{ pPictureResource_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoReferenceSlotInfoKHR( VideoReferenceSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoReferenceSlotInfoKHR( VkVideoReferenceSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoReferenceSlotInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoReferenceSlotInfoKHR & operator=( VideoReferenceSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoReferenceSlotInfoKHR & operator=( VkVideoReferenceSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR & setSlotIndex( int32_t slotIndex_ ) & VULKAN_HPP_NOEXCEPT + { + slotIndex = slotIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR && setSlotIndex( int32_t slotIndex_ ) && VULKAN_HPP_NOEXCEPT + { + slotIndex = slotIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR & setPPictureResource( const VideoPictureResourceInfoKHR * pPictureResource_ ) & VULKAN_HPP_NOEXCEPT + { + pPictureResource = pPictureResource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR && setPPictureResource( const VideoPictureResourceInfoKHR * pPictureResource_ ) && VULKAN_HPP_NOEXCEPT + { + pPictureResource = pPictureResource_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoReferenceSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoReferenceSlotInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoReferenceSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoReferenceSlotInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, slotIndex, pPictureResource ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoReferenceSlotInfoKHR const & ) const = default; +#else + bool operator==( VideoReferenceSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && ( pPictureResource == rhs.pPictureResource ); +# endif + } + + bool operator!=( VideoReferenceSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoReferenceSlotInfoKHR; + const void * pNext = {}; + int32_t slotIndex = {}; + const VideoPictureResourceInfoKHR * pPictureResource = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoReferenceSlotInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoReferenceSlotInfoKHR; + }; + + // wrapper struct for struct VkVideoBeginCodingInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoBeginCodingInfoKHR.html + struct VideoBeginCodingInfoKHR + { + using NativeType = VkVideoBeginCodingInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoBeginCodingInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoBeginCodingInfoKHR( VideoBeginCodingFlagsKHR flags_ = {}, + VideoSessionKHR videoSession_ = {}, + VideoSessionParametersKHR videoSessionParameters_ = {}, + uint32_t referenceSlotCount_ = {}, + const VideoReferenceSlotInfoKHR * pReferenceSlots_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , videoSession{ videoSession_ } + , videoSessionParameters{ videoSessionParameters_ } + , referenceSlotCount{ referenceSlotCount_ } + , pReferenceSlots{ pReferenceSlots_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoBeginCodingInfoKHR( VideoBeginCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoBeginCodingInfoKHR( VkVideoBeginCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoBeginCodingInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoBeginCodingInfoKHR( VideoBeginCodingFlagsKHR flags_, + VideoSessionKHR videoSession_, + VideoSessionParametersKHR videoSessionParameters_, + ArrayProxyNoTemporaries const & referenceSlots_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , videoSession( videoSession_ ) + , videoSessionParameters( videoSessionParameters_ ) + , referenceSlotCount( static_cast( referenceSlots_.size() ) ) + , pReferenceSlots( referenceSlots_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoBeginCodingInfoKHR & operator=( VideoBeginCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoBeginCodingInfoKHR & operator=( VkVideoBeginCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setFlags( VideoBeginCodingFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setFlags( VideoBeginCodingFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setVideoSession( VideoSessionKHR videoSession_ ) & VULKAN_HPP_NOEXCEPT + { + videoSession = videoSession_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setVideoSession( VideoSessionKHR videoSession_ ) && VULKAN_HPP_NOEXCEPT + { + videoSession = videoSession_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setVideoSessionParameters( VideoSessionParametersKHR videoSessionParameters_ ) & VULKAN_HPP_NOEXCEPT + { + videoSessionParameters = videoSessionParameters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setVideoSessionParameters( VideoSessionParametersKHR videoSessionParameters_ ) && VULKAN_HPP_NOEXCEPT + { + videoSessionParameters = videoSessionParameters_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setReferenceSlotCount( uint32_t referenceSlotCount_ ) & VULKAN_HPP_NOEXCEPT + { + referenceSlotCount = referenceSlotCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setReferenceSlotCount( uint32_t referenceSlotCount_ ) && VULKAN_HPP_NOEXCEPT + { + referenceSlotCount = referenceSlotCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) & VULKAN_HPP_NOEXCEPT + { + pReferenceSlots = pReferenceSlots_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) && VULKAN_HPP_NOEXCEPT + { + pReferenceSlots = pReferenceSlots_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoBeginCodingInfoKHR & setReferenceSlots( ArrayProxyNoTemporaries const & referenceSlots_ ) VULKAN_HPP_NOEXCEPT + { + referenceSlotCount = static_cast( referenceSlots_.size() ); + pReferenceSlots = referenceSlots_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoBeginCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoBeginCodingInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoBeginCodingInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoBeginCodingInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, videoSession, videoSessionParameters, referenceSlotCount, pReferenceSlots ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoBeginCodingInfoKHR const & ) const = default; +#else + bool operator==( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( videoSession == rhs.videoSession ) && + ( videoSessionParameters == rhs.videoSessionParameters ) && ( referenceSlotCount == rhs.referenceSlotCount ) && + ( pReferenceSlots == rhs.pReferenceSlots ); +# endif + } + + bool operator!=( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoBeginCodingInfoKHR; + const void * pNext = {}; + VideoBeginCodingFlagsKHR flags = {}; + VideoSessionKHR videoSession = {}; + VideoSessionParametersKHR videoSessionParameters = {}; + uint32_t referenceSlotCount = {}; + const VideoReferenceSlotInfoKHR * pReferenceSlots = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoBeginCodingInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoBeginCodingInfoKHR; + }; + + // wrapper struct for struct VkVideoCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCapabilitiesKHR.html + struct VideoCapabilitiesKHR + { + using NativeType = VkVideoCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 VideoCapabilitiesKHR( VideoCapabilityFlagsKHR flags_ = {}, + DeviceSize minBitstreamBufferOffsetAlignment_ = {}, + DeviceSize minBitstreamBufferSizeAlignment_ = {}, + Extent2D pictureAccessGranularity_ = {}, + Extent2D minCodedExtent_ = {}, + Extent2D maxCodedExtent_ = {}, + uint32_t maxDpbSlots_ = {}, + uint32_t maxActiveReferencePictures_ = {}, + ExtensionProperties stdHeaderVersion_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , minBitstreamBufferOffsetAlignment{ minBitstreamBufferOffsetAlignment_ } + , minBitstreamBufferSizeAlignment{ minBitstreamBufferSizeAlignment_ } + , pictureAccessGranularity{ pictureAccessGranularity_ } + , minCodedExtent{ minCodedExtent_ } + , maxCodedExtent{ maxCodedExtent_ } + , maxDpbSlots{ maxDpbSlots_ } + , maxActiveReferencePictures{ maxActiveReferencePictures_ } + , stdHeaderVersion{ stdHeaderVersion_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 VideoCapabilitiesKHR( VideoCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoCapabilitiesKHR( VkVideoCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoCapabilitiesKHR & operator=( VideoCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoCapabilitiesKHR & operator=( VkVideoCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + minBitstreamBufferOffsetAlignment, + minBitstreamBufferSizeAlignment, + pictureAccessGranularity, + minCodedExtent, + maxCodedExtent, + maxDpbSlots, + maxActiveReferencePictures, + stdHeaderVersion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoCapabilitiesKHR const & ) const = default; +#else + bool operator==( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( minBitstreamBufferOffsetAlignment == rhs.minBitstreamBufferOffsetAlignment ) && + ( minBitstreamBufferSizeAlignment == rhs.minBitstreamBufferSizeAlignment ) && ( pictureAccessGranularity == rhs.pictureAccessGranularity ) && + ( minCodedExtent == rhs.minCodedExtent ) && ( maxCodedExtent == rhs.maxCodedExtent ) && ( maxDpbSlots == rhs.maxDpbSlots ) && + ( maxActiveReferencePictures == rhs.maxActiveReferencePictures ) && ( stdHeaderVersion == rhs.stdHeaderVersion ); +# endif + } + + bool operator!=( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoCapabilitiesKHR; + void * pNext = {}; + VideoCapabilityFlagsKHR flags = {}; + DeviceSize minBitstreamBufferOffsetAlignment = {}; + DeviceSize minBitstreamBufferSizeAlignment = {}; + Extent2D pictureAccessGranularity = {}; + Extent2D minCodedExtent = {}; + Extent2D maxCodedExtent = {}; + uint32_t maxDpbSlots = {}; + uint32_t maxActiveReferencePictures = {}; + ExtensionProperties stdHeaderVersion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoCapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoCodingControlInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodingControlInfoKHR.html + struct VideoCodingControlInfoKHR + { + using NativeType = VkVideoCodingControlInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoCodingControlInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoCodingControlInfoKHR( VideoCodingControlFlagsKHR flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoCodingControlInfoKHR( VideoCodingControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoCodingControlInfoKHR( VkVideoCodingControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoCodingControlInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoCodingControlInfoKHR & operator=( VideoCodingControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoCodingControlInfoKHR & operator=( VkVideoCodingControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoCodingControlInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoCodingControlInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoCodingControlInfoKHR & setFlags( VideoCodingControlFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoCodingControlInfoKHR && setFlags( VideoCodingControlFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoCodingControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoCodingControlInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoCodingControlInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoCodingControlInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoCodingControlInfoKHR const & ) const = default; +#else + bool operator==( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoCodingControlInfoKHR; + const void * pNext = {}; + VideoCodingControlFlagsKHR flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoCodingControlInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoCodingControlInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeAV1CapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1CapabilitiesKHR.html + struct VideoDecodeAV1CapabilitiesKHR + { + using NativeType = VkVideoDecodeAV1CapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1CapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1CapabilitiesKHR( StdVideoAV1Level maxLevel_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxLevel{ maxLevel_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1CapabilitiesKHR( VideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1CapabilitiesKHR( VkVideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1CapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1CapabilitiesKHR & operator=( VideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeAV1CapabilitiesKHR & operator=( VkVideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoDecodeAV1CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxLevel ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ) == 0 ); + } + + bool operator!=( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoDecodeAv1CapabilitiesKHR; + void * pNext = {}; + StdVideoAV1Level maxLevel = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeAV1CapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeAV1CapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoDecodeAV1DpbSlotInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1DpbSlotInfoKHR.html + struct VideoDecodeAV1DpbSlotInfoKHR + { + using NativeType = VkVideoDecodeAV1DpbSlotInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1DpbSlotInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1DpbSlotInfoKHR( const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdReferenceInfo{ pStdReferenceInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1DpbSlotInfoKHR( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1DpbSlotInfoKHR( VkVideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1DpbSlotInfoKHR & operator=( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeAV1DpbSlotInfoKHR & operator=( VkVideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeAV1DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeAV1DpbSlotInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); +# endif + } + + bool operator!=( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeAv1DpbSlotInfoKHR; + const void * pNext = {}; + const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeAV1DpbSlotInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeAV1DpbSlotInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeAV1InlineSessionParametersInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1InlineSessionParametersInfoKHR.html + struct VideoDecodeAV1InlineSessionParametersInfoKHR + { + using NativeType = VkVideoDecodeAV1InlineSessionParametersInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1InlineSessionParametersInfoKHR( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdSequenceHeader{ pStdSequenceHeader_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1InlineSessionParametersInfoKHR( VideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1InlineSessionParametersInfoKHR( VkVideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1InlineSessionParametersInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1InlineSessionParametersInfoKHR & operator=( VideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeAV1InlineSessionParametersInfoKHR & operator=( VkVideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1InlineSessionParametersInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1InlineSessionParametersInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1InlineSessionParametersInfoKHR & setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdSequenceHeader = pStdSequenceHeader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1InlineSessionParametersInfoKHR && setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdSequenceHeader = pStdSequenceHeader_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeAV1InlineSessionParametersInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1InlineSessionParametersInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1InlineSessionParametersInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1InlineSessionParametersInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdSequenceHeader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeAV1InlineSessionParametersInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdSequenceHeader == rhs.pStdSequenceHeader ); +# endif + } + + bool operator!=( VideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR; + const void * pNext = {}; + const StdVideoAV1SequenceHeader * pStdSequenceHeader = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeAV1InlineSessionParametersInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeAV1InlineSessionParametersInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeAV1PictureInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1PictureInfoKHR.html + struct VideoDecodeAV1PictureInfoKHR + { + using NativeType = VkVideoDecodeAV1PictureInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1PictureInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_ = {}, + std::array const & referenceNameSlotIndices_ = {}, + uint32_t frameHeaderOffset_ = {}, + uint32_t tileCount_ = {}, + const uint32_t * pTileOffsets_ = {}, + const uint32_t * pTileSizes_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdPictureInfo{ pStdPictureInfo_ } + , referenceNameSlotIndices{ referenceNameSlotIndices_ } + , frameHeaderOffset{ frameHeaderOffset_ } + , tileCount{ tileCount_ } + , pTileOffsets{ pTileOffsets_ } + , pTileSizes{ pTileSizes_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR( VideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1PictureInfoKHR( VkVideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1PictureInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeAV1PictureInfoKHR( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_, + std::array const & referenceNameSlotIndices_, + uint32_t frameHeaderOffset_, + ArrayProxyNoTemporaries const & tileOffsets_, + ArrayProxyNoTemporaries const & tileSizes_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , pStdPictureInfo( pStdPictureInfo_ ) + , referenceNameSlotIndices( referenceNameSlotIndices_ ) + , frameHeaderOffset( frameHeaderOffset_ ) + , tileCount( static_cast( tileOffsets_.size() ) ) + , pTileOffsets( tileOffsets_.data() ) + , pTileSizes( tileSizes_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( tileOffsets_.size() == tileSizes_.size() ); +# else + if ( tileOffsets_.size() != tileSizes_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::VideoDecodeAV1PictureInfoKHR::VideoDecodeAV1PictureInfoKHR: tileOffsets_.size() != tileSizes_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoDecodeAV1PictureInfoKHR & operator=( VideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeAV1PictureInfoKHR & operator=( VkVideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPStdPictureInfo( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setPStdPictureInfo( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & + setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) & + VULKAN_HPP_NOEXCEPT + { + referenceNameSlotIndices = referenceNameSlotIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && + setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) && + VULKAN_HPP_NOEXCEPT + { + referenceNameSlotIndices = referenceNameSlotIndices_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setFrameHeaderOffset( uint32_t frameHeaderOffset_ ) & VULKAN_HPP_NOEXCEPT + { + frameHeaderOffset = frameHeaderOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setFrameHeaderOffset( uint32_t frameHeaderOffset_ ) && VULKAN_HPP_NOEXCEPT + { + frameHeaderOffset = frameHeaderOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setTileCount( uint32_t tileCount_ ) & VULKAN_HPP_NOEXCEPT + { + tileCount = tileCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setTileCount( uint32_t tileCount_ ) && VULKAN_HPP_NOEXCEPT + { + tileCount = tileCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPTileOffsets( const uint32_t * pTileOffsets_ ) & VULKAN_HPP_NOEXCEPT + { + pTileOffsets = pTileOffsets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setPTileOffsets( const uint32_t * pTileOffsets_ ) && VULKAN_HPP_NOEXCEPT + { + pTileOffsets = pTileOffsets_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeAV1PictureInfoKHR & setTileOffsets( ArrayProxyNoTemporaries const & tileOffsets_ ) VULKAN_HPP_NOEXCEPT + { + tileCount = static_cast( tileOffsets_.size() ); + pTileOffsets = tileOffsets_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPTileSizes( const uint32_t * pTileSizes_ ) & VULKAN_HPP_NOEXCEPT + { + pTileSizes = pTileSizes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setPTileSizes( const uint32_t * pTileSizes_ ) && VULKAN_HPP_NOEXCEPT + { + pTileSizes = pTileSizes_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeAV1PictureInfoKHR & setTileSizes( ArrayProxyNoTemporaries const & tileSizes_ ) VULKAN_HPP_NOEXCEPT + { + tileCount = static_cast( tileSizes_.size() ); + pTileSizes = tileSizes_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeAV1PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1PictureInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1PictureInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + uint32_t const &, + uint32_t const &, + const uint32_t * const &, + const uint32_t * const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdPictureInfo, referenceNameSlotIndices, frameHeaderOffset, tileCount, pTileOffsets, pTileSizes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeAV1PictureInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && + ( referenceNameSlotIndices == rhs.referenceNameSlotIndices ) && ( frameHeaderOffset == rhs.frameHeaderOffset ) && ( tileCount == rhs.tileCount ) && + ( pTileOffsets == rhs.pTileOffsets ) && ( pTileSizes == rhs.pTileSizes ); +# endif + } + + bool operator!=( VideoDecodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeAv1PictureInfoKHR; + const void * pNext = {}; + const StdVideoDecodeAV1PictureInfo * pStdPictureInfo = {}; + ArrayWrapper1D referenceNameSlotIndices = {}; + uint32_t frameHeaderOffset = {}; + uint32_t tileCount = {}; + const uint32_t * pTileOffsets = {}; + const uint32_t * pTileSizes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeAV1PictureInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeAV1PictureInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeAV1ProfileInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1ProfileInfoKHR.html + struct VideoDecodeAV1ProfileInfoKHR + { + using NativeType = VkVideoDecodeAV1ProfileInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1ProfileInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoDecodeAV1ProfileInfoKHR( StdVideoAV1Profile stdProfile_ = {}, Bool32 filmGrainSupport_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stdProfile{ stdProfile_ } + , filmGrainSupport{ filmGrainSupport_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1ProfileInfoKHR( VideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1ProfileInfoKHR( VkVideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1ProfileInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1ProfileInfoKHR & operator=( VideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeAV1ProfileInfoKHR & operator=( VkVideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setStdProfile( StdVideoAV1Profile stdProfile_ ) & VULKAN_HPP_NOEXCEPT + { + stdProfile = stdProfile_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR && setStdProfile( StdVideoAV1Profile stdProfile_ ) && VULKAN_HPP_NOEXCEPT + { + stdProfile = stdProfile_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setFilmGrainSupport( Bool32 filmGrainSupport_ ) & VULKAN_HPP_NOEXCEPT + { + filmGrainSupport = filmGrainSupport_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR && setFilmGrainSupport( Bool32 filmGrainSupport_ ) && VULKAN_HPP_NOEXCEPT + { + filmGrainSupport = filmGrainSupport_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeAV1ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfile, filmGrainSupport ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = filmGrainSupport <=> rhs.filmGrainSupport; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ) == 0 ) && + ( filmGrainSupport == rhs.filmGrainSupport ); + } + + bool operator!=( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoDecodeAv1ProfileInfoKHR; + const void * pNext = {}; + StdVideoAV1Profile stdProfile = {}; + Bool32 filmGrainSupport = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeAV1ProfileInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeAV1ProfileInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeAV1SessionParametersCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1SessionParametersCreateInfoKHR.html + struct VideoDecodeAV1SessionParametersCreateInfoKHR + { + using NativeType = VkVideoDecodeAV1SessionParametersCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeAV1SessionParametersCreateInfoKHR( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdSequenceHeader{ pStdSequenceHeader_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeAV1SessionParametersCreateInfoKHR( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeAV1SessionParametersCreateInfoKHR( VkVideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeAV1SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeAV1SessionParametersCreateInfoKHR & operator=( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeAV1SessionParametersCreateInfoKHR & operator=( VkVideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR & setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdSequenceHeader = pStdSequenceHeader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR && setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdSequenceHeader = pStdSequenceHeader_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeAV1SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeAV1SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdSequenceHeader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeAV1SessionParametersCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdSequenceHeader == rhs.pStdSequenceHeader ); +# endif + } + + bool operator!=( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR; + const void * pNext = {}; + const StdVideoAV1SequenceHeader * pStdSequenceHeader = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeAV1SessionParametersCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeAV1SessionParametersCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeCapabilitiesKHR.html + struct VideoDecodeCapabilitiesKHR + { + using NativeType = VkVideoDecodeCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeCapabilitiesKHR( VideoDecodeCapabilityFlagsKHR flags_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeCapabilitiesKHR( VideoDecodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeCapabilitiesKHR( VkVideoDecodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeCapabilitiesKHR & operator=( VideoDecodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeCapabilitiesKHR & operator=( VkVideoDecodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoDecodeCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeCapabilitiesKHR const & ) const = default; +#else + bool operator==( VideoDecodeCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( VideoDecodeCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeCapabilitiesKHR; + void * pNext = {}; + VideoDecodeCapabilityFlagsKHR flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeCapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoDecodeH264CapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264CapabilitiesKHR.html + struct VideoDecodeH264CapabilitiesKHR + { + using NativeType = VkVideoDecodeH264CapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264CapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH264CapabilitiesKHR( StdVideoH264LevelIdc maxLevelIdc_ = {}, + Offset2D fieldOffsetGranularity_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxLevelIdc{ maxLevelIdc_ } + , fieldOffsetGranularity{ fieldOffsetGranularity_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeH264CapabilitiesKHR( VideoDecodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH264CapabilitiesKHR( VkVideoDecodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH264CapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeH264CapabilitiesKHR & operator=( VideoDecodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH264CapabilitiesKHR & operator=( VkVideoDecodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoDecodeH264CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH264CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxLevelIdc, fieldOffsetGranularity ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = fieldOffsetGranularity <=> rhs.fieldOffsetGranularity; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ) == 0 ) && + ( fieldOffsetGranularity == rhs.fieldOffsetGranularity ); + } + + bool operator!=( VideoDecodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoDecodeH264CapabilitiesKHR; + void * pNext = {}; + StdVideoH264LevelIdc maxLevelIdc = {}; + Offset2D fieldOffsetGranularity = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH264CapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH264CapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoDecodeH264DpbSlotInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264DpbSlotInfoKHR.html + struct VideoDecodeH264DpbSlotInfoKHR + { + using NativeType = VkVideoDecodeH264DpbSlotInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264DpbSlotInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH264DpbSlotInfoKHR( const StdVideoDecodeH264ReferenceInfo * pStdReferenceInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdReferenceInfo{ pStdReferenceInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeH264DpbSlotInfoKHR( VideoDecodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH264DpbSlotInfoKHR( VkVideoDecodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH264DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeH264DpbSlotInfoKHR & operator=( VideoDecodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH264DpbSlotInfoKHR & operator=( VkVideoDecodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoDecodeH264ReferenceInfo * pStdReferenceInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoDecodeH264ReferenceInfo * pStdReferenceInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH264DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH264DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeH264DpbSlotInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeH264DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); +# endif + } + + bool operator!=( VideoDecodeH264DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeH264DpbSlotInfoKHR; + const void * pNext = {}; + const StdVideoDecodeH264ReferenceInfo * pStdReferenceInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH264DpbSlotInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH264DpbSlotInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeH264InlineSessionParametersInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264InlineSessionParametersInfoKHR.html + struct VideoDecodeH264InlineSessionParametersInfoKHR + { + using NativeType = VkVideoDecodeH264InlineSessionParametersInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH264InlineSessionParametersInfoKHR( const StdVideoH264SequenceParameterSet * pStdSPS_ = {}, + const StdVideoH264PictureParameterSet * pStdPPS_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdSPS{ pStdSPS_ } + , pStdPPS{ pStdPPS_ } + { + } + + VULKAN_HPP_CONSTEXPR + VideoDecodeH264InlineSessionParametersInfoKHR( VideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH264InlineSessionParametersInfoKHR( VkVideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH264InlineSessionParametersInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeH264InlineSessionParametersInfoKHR & operator=( VideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH264InlineSessionParametersInfoKHR & operator=( VkVideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR & setPStdSPS( const StdVideoH264SequenceParameterSet * pStdSPS_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdSPS = pStdSPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR && setPStdSPS( const StdVideoH264SequenceParameterSet * pStdSPS_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdSPS = pStdSPS_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR & setPStdPPS( const StdVideoH264PictureParameterSet * pStdPPS_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPPS = pStdPPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR && setPStdPPS( const StdVideoH264PictureParameterSet * pStdPPS_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdPPS = pStdPPS_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH264InlineSessionParametersInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264InlineSessionParametersInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264InlineSessionParametersInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH264InlineSessionParametersInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdSPS, pStdPPS ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeH264InlineSessionParametersInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdSPS == rhs.pStdSPS ) && ( pStdPPS == rhs.pStdPPS ); +# endif + } + + bool operator!=( VideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR; + const void * pNext = {}; + const StdVideoH264SequenceParameterSet * pStdSPS = {}; + const StdVideoH264PictureParameterSet * pStdPPS = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH264InlineSessionParametersInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH264InlineSessionParametersInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeH264PictureInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264PictureInfoKHR.html + struct VideoDecodeH264PictureInfoKHR + { + using NativeType = VkVideoDecodeH264PictureInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264PictureInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureInfoKHR( const StdVideoDecodeH264PictureInfo * pStdPictureInfo_ = {}, + uint32_t sliceCount_ = {}, + const uint32_t * pSliceOffsets_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdPictureInfo{ pStdPictureInfo_ } + , sliceCount{ sliceCount_ } + , pSliceOffsets{ pSliceOffsets_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureInfoKHR( VideoDecodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH264PictureInfoKHR( VkVideoDecodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH264PictureInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeH264PictureInfoKHR( const StdVideoDecodeH264PictureInfo * pStdPictureInfo_, + ArrayProxyNoTemporaries const & sliceOffsets_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ), pStdPictureInfo( pStdPictureInfo_ ), sliceCount( static_cast( sliceOffsets_.size() ) ), pSliceOffsets( sliceOffsets_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoDecodeH264PictureInfoKHR & operator=( VideoDecodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH264PictureInfoKHR & operator=( VkVideoDecodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR & setPStdPictureInfo( const StdVideoDecodeH264PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR && setPStdPictureInfo( const StdVideoDecodeH264PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR & setSliceCount( uint32_t sliceCount_ ) & VULKAN_HPP_NOEXCEPT + { + sliceCount = sliceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR && setSliceCount( uint32_t sliceCount_ ) && VULKAN_HPP_NOEXCEPT + { + sliceCount = sliceCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR & setPSliceOffsets( const uint32_t * pSliceOffsets_ ) & VULKAN_HPP_NOEXCEPT + { + pSliceOffsets = pSliceOffsets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR && setPSliceOffsets( const uint32_t * pSliceOffsets_ ) && VULKAN_HPP_NOEXCEPT + { + pSliceOffsets = pSliceOffsets_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeH264PictureInfoKHR & setSliceOffsets( ArrayProxyNoTemporaries const & sliceOffsets_ ) VULKAN_HPP_NOEXCEPT + { + sliceCount = static_cast( sliceOffsets_.size() ); + pSliceOffsets = sliceOffsets_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH264PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264PictureInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH264PictureInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdPictureInfo, sliceCount, pSliceOffsets ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeH264PictureInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeH264PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( sliceCount == rhs.sliceCount ) && + ( pSliceOffsets == rhs.pSliceOffsets ); +# endif + } + + bool operator!=( VideoDecodeH264PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeH264PictureInfoKHR; + const void * pNext = {}; + const StdVideoDecodeH264PictureInfo * pStdPictureInfo = {}; + uint32_t sliceCount = {}; + const uint32_t * pSliceOffsets = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH264PictureInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH264PictureInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeH264ProfileInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264ProfileInfoKHR.html + struct VideoDecodeH264ProfileInfoKHR + { + using NativeType = VkVideoDecodeH264ProfileInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264ProfileInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoDecodeH264ProfileInfoKHR( StdVideoH264ProfileIdc stdProfileIdc_ = {}, + VideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout_ = VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stdProfileIdc{ stdProfileIdc_ } + , pictureLayout{ pictureLayout_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeH264ProfileInfoKHR( VideoDecodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH264ProfileInfoKHR( VkVideoDecodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH264ProfileInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeH264ProfileInfoKHR & operator=( VideoDecodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH264ProfileInfoKHR & operator=( VkVideoDecodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR & setStdProfileIdc( StdVideoH264ProfileIdc stdProfileIdc_ ) & VULKAN_HPP_NOEXCEPT + { + stdProfileIdc = stdProfileIdc_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR && setStdProfileIdc( StdVideoH264ProfileIdc stdProfileIdc_ ) && VULKAN_HPP_NOEXCEPT + { + stdProfileIdc = stdProfileIdc_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR & setPictureLayout( VideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout_ ) & VULKAN_HPP_NOEXCEPT + { + pictureLayout = pictureLayout_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR && setPictureLayout( VideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout_ ) && VULKAN_HPP_NOEXCEPT + { + pictureLayout = pictureLayout_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH264ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH264ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc, pictureLayout ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = pictureLayout <=> rhs.pictureLayout; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) && + ( pictureLayout == rhs.pictureLayout ); + } + + bool operator!=( VideoDecodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoDecodeH264ProfileInfoKHR; + const void * pNext = {}; + StdVideoH264ProfileIdc stdProfileIdc = {}; + VideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout = VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH264ProfileInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH264ProfileInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeH264SessionParametersAddInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264SessionParametersAddInfoKHR.html + struct VideoDecodeH264SessionParametersAddInfoKHR + { + using NativeType = VkVideoDecodeH264SessionParametersAddInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264SessionParametersAddInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH264SessionParametersAddInfoKHR( uint32_t stdSPSCount_ = {}, + const StdVideoH264SequenceParameterSet * pStdSPSs_ = {}, + uint32_t stdPPSCount_ = {}, + const StdVideoH264PictureParameterSet * pStdPPSs_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stdSPSCount{ stdSPSCount_ } + , pStdSPSs{ pStdSPSs_ } + , stdPPSCount{ stdPPSCount_ } + , pStdPPSs{ pStdPPSs_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeH264SessionParametersAddInfoKHR( VideoDecodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH264SessionParametersAddInfoKHR( VkVideoDecodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH264SessionParametersAddInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeH264SessionParametersAddInfoKHR( ArrayProxyNoTemporaries const & stdSPSs_, + ArrayProxyNoTemporaries const & stdPPSs_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , stdSPSCount( static_cast( stdSPSs_.size() ) ) + , pStdSPSs( stdSPSs_.data() ) + , stdPPSCount( static_cast( stdPPSs_.size() ) ) + , pStdPPSs( stdPPSs_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoDecodeH264SessionParametersAddInfoKHR & operator=( VideoDecodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH264SessionParametersAddInfoKHR & operator=( VkVideoDecodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR & setStdSPSCount( uint32_t stdSPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + stdSPSCount = stdSPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR && setStdSPSCount( uint32_t stdSPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + stdSPSCount = stdSPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR & setPStdSPSs( const StdVideoH264SequenceParameterSet * pStdSPSs_ ) & VULKAN_HPP_NOEXCEPT + { + pStdSPSs = pStdSPSs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR && setPStdSPSs( const StdVideoH264SequenceParameterSet * pStdSPSs_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdSPSs = pStdSPSs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeH264SessionParametersAddInfoKHR & + setStdSPSs( ArrayProxyNoTemporaries const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT + { + stdSPSCount = static_cast( stdSPSs_.size() ); + pStdSPSs = stdSPSs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR & setStdPPSCount( uint32_t stdPPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + stdPPSCount = stdPPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR && setStdPPSCount( uint32_t stdPPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + stdPPSCount = stdPPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR & setPStdPPSs( const StdVideoH264PictureParameterSet * pStdPPSs_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPPSs = pStdPPSs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR && setPStdPPSs( const StdVideoH264PictureParameterSet * pStdPPSs_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdPPSs = pStdPPSs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeH264SessionParametersAddInfoKHR & + setStdPPSs( ArrayProxyNoTemporaries const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT + { + stdPPSCount = static_cast( stdPPSs_.size() ); + pStdPPSs = stdPPSs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH264SessionParametersAddInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264SessionParametersAddInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264SessionParametersAddInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH264SessionParametersAddInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeH264SessionParametersAddInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeH264SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && + ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs ); +# endif + } + + bool operator!=( VideoDecodeH264SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeH264SessionParametersAddInfoKHR; + const void * pNext = {}; + uint32_t stdSPSCount = {}; + const StdVideoH264SequenceParameterSet * pStdSPSs = {}; + uint32_t stdPPSCount = {}; + const StdVideoH264PictureParameterSet * pStdPPSs = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH264SessionParametersAddInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH264SessionParametersAddInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeH264SessionParametersCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264SessionParametersCreateInfoKHR.html + struct VideoDecodeH264SessionParametersCreateInfoKHR + { + using NativeType = VkVideoDecodeH264SessionParametersCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264SessionParametersCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH264SessionParametersCreateInfoKHR( uint32_t maxStdSPSCount_ = {}, + uint32_t maxStdPPSCount_ = {}, + const VideoDecodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxStdSPSCount{ maxStdSPSCount_ } + , maxStdPPSCount{ maxStdPPSCount_ } + , pParametersAddInfo{ pParametersAddInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR + VideoDecodeH264SessionParametersCreateInfoKHR( VideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH264SessionParametersCreateInfoKHR( VkVideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH264SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeH264SessionParametersCreateInfoKHR & operator=( VideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH264SessionParametersCreateInfoKHR & operator=( VkVideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxStdSPSCount = maxStdSPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR && setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxStdSPSCount = maxStdSPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxStdPPSCount = maxStdPPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR && setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxStdPPSCount = maxStdPPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR & + setPParametersAddInfo( const VideoDecodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pParametersAddInfo = pParametersAddInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR && + setPParametersAddInfo( const VideoDecodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pParametersAddInfo = pParametersAddInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH264SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH264SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH264SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeH264SessionParametersCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && ( maxStdPPSCount == rhs.maxStdPPSCount ) && + ( pParametersAddInfo == rhs.pParametersAddInfo ); +# endif + } + + bool operator!=( VideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeH264SessionParametersCreateInfoKHR; + const void * pNext = {}; + uint32_t maxStdSPSCount = {}; + uint32_t maxStdPPSCount = {}; + const VideoDecodeH264SessionParametersAddInfoKHR * pParametersAddInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH264SessionParametersCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH264SessionParametersCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeH265CapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265CapabilitiesKHR.html + struct VideoDecodeH265CapabilitiesKHR + { + using NativeType = VkVideoDecodeH265CapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265CapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH265CapabilitiesKHR( StdVideoH265LevelIdc maxLevelIdc_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxLevelIdc{ maxLevelIdc_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeH265CapabilitiesKHR( VideoDecodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH265CapabilitiesKHR( VkVideoDecodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH265CapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeH265CapabilitiesKHR & operator=( VideoDecodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH265CapabilitiesKHR & operator=( VkVideoDecodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoDecodeH265CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH265CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxLevelIdc ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ) == 0 ); + } + + bool operator!=( VideoDecodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoDecodeH265CapabilitiesKHR; + void * pNext = {}; + StdVideoH265LevelIdc maxLevelIdc = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH265CapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH265CapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoDecodeH265DpbSlotInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265DpbSlotInfoKHR.html + struct VideoDecodeH265DpbSlotInfoKHR + { + using NativeType = VkVideoDecodeH265DpbSlotInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265DpbSlotInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH265DpbSlotInfoKHR( const StdVideoDecodeH265ReferenceInfo * pStdReferenceInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdReferenceInfo{ pStdReferenceInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeH265DpbSlotInfoKHR( VideoDecodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH265DpbSlotInfoKHR( VkVideoDecodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH265DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeH265DpbSlotInfoKHR & operator=( VideoDecodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH265DpbSlotInfoKHR & operator=( VkVideoDecodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoDecodeH265ReferenceInfo * pStdReferenceInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoDecodeH265ReferenceInfo * pStdReferenceInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH265DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH265DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeH265DpbSlotInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeH265DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); +# endif + } + + bool operator!=( VideoDecodeH265DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeH265DpbSlotInfoKHR; + const void * pNext = {}; + const StdVideoDecodeH265ReferenceInfo * pStdReferenceInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH265DpbSlotInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH265DpbSlotInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeH265InlineSessionParametersInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265InlineSessionParametersInfoKHR.html + struct VideoDecodeH265InlineSessionParametersInfoKHR + { + using NativeType = VkVideoDecodeH265InlineSessionParametersInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH265InlineSessionParametersInfoKHR( const StdVideoH265VideoParameterSet * pStdVPS_ = {}, + const StdVideoH265SequenceParameterSet * pStdSPS_ = {}, + const StdVideoH265PictureParameterSet * pStdPPS_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdVPS{ pStdVPS_ } + , pStdSPS{ pStdSPS_ } + , pStdPPS{ pStdPPS_ } + { + } + + VULKAN_HPP_CONSTEXPR + VideoDecodeH265InlineSessionParametersInfoKHR( VideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH265InlineSessionParametersInfoKHR( VkVideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH265InlineSessionParametersInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeH265InlineSessionParametersInfoKHR & operator=( VideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH265InlineSessionParametersInfoKHR & operator=( VkVideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPStdVPS( const StdVideoH265VideoParameterSet * pStdVPS_ ) & VULKAN_HPP_NOEXCEPT + { + pStdVPS = pStdVPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR && setPStdVPS( const StdVideoH265VideoParameterSet * pStdVPS_ ) && VULKAN_HPP_NOEXCEPT + { + pStdVPS = pStdVPS_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPStdSPS( const StdVideoH265SequenceParameterSet * pStdSPS_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdSPS = pStdSPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR && setPStdSPS( const StdVideoH265SequenceParameterSet * pStdSPS_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdSPS = pStdSPS_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPStdPPS( const StdVideoH265PictureParameterSet * pStdPPS_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPPS = pStdPPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR && setPStdPPS( const StdVideoH265PictureParameterSet * pStdPPS_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdPPS = pStdPPS_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH265InlineSessionParametersInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265InlineSessionParametersInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265InlineSessionParametersInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH265InlineSessionParametersInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdVPS, pStdSPS, pStdPPS ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeH265InlineSessionParametersInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdVPS == rhs.pStdVPS ) && ( pStdSPS == rhs.pStdSPS ) && ( pStdPPS == rhs.pStdPPS ); +# endif + } + + bool operator!=( VideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR; + const void * pNext = {}; + const StdVideoH265VideoParameterSet * pStdVPS = {}; + const StdVideoH265SequenceParameterSet * pStdSPS = {}; + const StdVideoH265PictureParameterSet * pStdPPS = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH265InlineSessionParametersInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH265InlineSessionParametersInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeH265PictureInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265PictureInfoKHR.html + struct VideoDecodeH265PictureInfoKHR + { + using NativeType = VkVideoDecodeH265PictureInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265PictureInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH265PictureInfoKHR( const StdVideoDecodeH265PictureInfo * pStdPictureInfo_ = {}, + uint32_t sliceSegmentCount_ = {}, + const uint32_t * pSliceSegmentOffsets_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdPictureInfo{ pStdPictureInfo_ } + , sliceSegmentCount{ sliceSegmentCount_ } + , pSliceSegmentOffsets{ pSliceSegmentOffsets_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeH265PictureInfoKHR( VideoDecodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH265PictureInfoKHR( VkVideoDecodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH265PictureInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeH265PictureInfoKHR( const StdVideoDecodeH265PictureInfo * pStdPictureInfo_, + ArrayProxyNoTemporaries const & sliceSegmentOffsets_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , pStdPictureInfo( pStdPictureInfo_ ) + , sliceSegmentCount( static_cast( sliceSegmentOffsets_.size() ) ) + , pSliceSegmentOffsets( sliceSegmentOffsets_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoDecodeH265PictureInfoKHR & operator=( VideoDecodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH265PictureInfoKHR & operator=( VkVideoDecodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR & setPStdPictureInfo( const StdVideoDecodeH265PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR && setPStdPictureInfo( const StdVideoDecodeH265PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR & setSliceSegmentCount( uint32_t sliceSegmentCount_ ) & VULKAN_HPP_NOEXCEPT + { + sliceSegmentCount = sliceSegmentCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR && setSliceSegmentCount( uint32_t sliceSegmentCount_ ) && VULKAN_HPP_NOEXCEPT + { + sliceSegmentCount = sliceSegmentCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR & setPSliceSegmentOffsets( const uint32_t * pSliceSegmentOffsets_ ) & VULKAN_HPP_NOEXCEPT + { + pSliceSegmentOffsets = pSliceSegmentOffsets_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR && setPSliceSegmentOffsets( const uint32_t * pSliceSegmentOffsets_ ) && VULKAN_HPP_NOEXCEPT + { + pSliceSegmentOffsets = pSliceSegmentOffsets_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeH265PictureInfoKHR & setSliceSegmentOffsets( ArrayProxyNoTemporaries const & sliceSegmentOffsets_ ) VULKAN_HPP_NOEXCEPT + { + sliceSegmentCount = static_cast( sliceSegmentOffsets_.size() ); + pSliceSegmentOffsets = sliceSegmentOffsets_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH265PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265PictureInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH265PictureInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdPictureInfo, sliceSegmentCount, pSliceSegmentOffsets ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeH265PictureInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeH265PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( sliceSegmentCount == rhs.sliceSegmentCount ) && + ( pSliceSegmentOffsets == rhs.pSliceSegmentOffsets ); +# endif + } + + bool operator!=( VideoDecodeH265PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeH265PictureInfoKHR; + const void * pNext = {}; + const StdVideoDecodeH265PictureInfo * pStdPictureInfo = {}; + uint32_t sliceSegmentCount = {}; + const uint32_t * pSliceSegmentOffsets = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH265PictureInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH265PictureInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeH265ProfileInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265ProfileInfoKHR.html + struct VideoDecodeH265ProfileInfoKHR + { + using NativeType = VkVideoDecodeH265ProfileInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265ProfileInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH265ProfileInfoKHR( StdVideoH265ProfileIdc stdProfileIdc_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stdProfileIdc{ stdProfileIdc_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeH265ProfileInfoKHR( VideoDecodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH265ProfileInfoKHR( VkVideoDecodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH265ProfileInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeH265ProfileInfoKHR & operator=( VideoDecodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH265ProfileInfoKHR & operator=( VkVideoDecodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265ProfileInfoKHR & setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) & VULKAN_HPP_NOEXCEPT + { + stdProfileIdc = stdProfileIdc_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265ProfileInfoKHR && setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) && VULKAN_HPP_NOEXCEPT + { + stdProfileIdc = stdProfileIdc_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH265ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH265ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); + } + + bool operator!=( VideoDecodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoDecodeH265ProfileInfoKHR; + const void * pNext = {}; + StdVideoH265ProfileIdc stdProfileIdc = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH265ProfileInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH265ProfileInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeH265SessionParametersAddInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265SessionParametersAddInfoKHR.html + struct VideoDecodeH265SessionParametersAddInfoKHR + { + using NativeType = VkVideoDecodeH265SessionParametersAddInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265SessionParametersAddInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH265SessionParametersAddInfoKHR( uint32_t stdVPSCount_ = {}, + const StdVideoH265VideoParameterSet * pStdVPSs_ = {}, + uint32_t stdSPSCount_ = {}, + const StdVideoH265SequenceParameterSet * pStdSPSs_ = {}, + uint32_t stdPPSCount_ = {}, + const StdVideoH265PictureParameterSet * pStdPPSs_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stdVPSCount{ stdVPSCount_ } + , pStdVPSs{ pStdVPSs_ } + , stdSPSCount{ stdSPSCount_ } + , pStdSPSs{ pStdSPSs_ } + , stdPPSCount{ stdPPSCount_ } + , pStdPPSs{ pStdPPSs_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeH265SessionParametersAddInfoKHR( VideoDecodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH265SessionParametersAddInfoKHR( VkVideoDecodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH265SessionParametersAddInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeH265SessionParametersAddInfoKHR( ArrayProxyNoTemporaries const & stdVPSs_, + ArrayProxyNoTemporaries const & stdSPSs_ = {}, + ArrayProxyNoTemporaries const & stdPPSs_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , stdVPSCount( static_cast( stdVPSs_.size() ) ) + , pStdVPSs( stdVPSs_.data() ) + , stdSPSCount( static_cast( stdSPSs_.size() ) ) + , pStdSPSs( stdSPSs_.data() ) + , stdPPSCount( static_cast( stdPPSs_.size() ) ) + , pStdPPSs( stdPPSs_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoDecodeH265SessionParametersAddInfoKHR & operator=( VideoDecodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH265SessionParametersAddInfoKHR & operator=( VkVideoDecodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setStdVPSCount( uint32_t stdVPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + stdVPSCount = stdVPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setStdVPSCount( uint32_t stdVPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + stdVPSCount = stdVPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) & VULKAN_HPP_NOEXCEPT + { + pStdVPSs = pStdVPSs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) && VULKAN_HPP_NOEXCEPT + { + pStdVPSs = pStdVPSs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeH265SessionParametersAddInfoKHR & setStdVPSs( ArrayProxyNoTemporaries const & stdVPSs_ ) VULKAN_HPP_NOEXCEPT + { + stdVPSCount = static_cast( stdVPSs_.size() ); + pStdVPSs = stdVPSs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setStdSPSCount( uint32_t stdSPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + stdSPSCount = stdSPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setStdSPSCount( uint32_t stdSPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + stdSPSCount = stdSPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) & VULKAN_HPP_NOEXCEPT + { + pStdSPSs = pStdSPSs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdSPSs = pStdSPSs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeH265SessionParametersAddInfoKHR & + setStdSPSs( ArrayProxyNoTemporaries const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT + { + stdSPSCount = static_cast( stdSPSs_.size() ); + pStdSPSs = stdSPSs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setStdPPSCount( uint32_t stdPPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + stdPPSCount = stdPPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setStdPPSCount( uint32_t stdPPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + stdPPSCount = stdPPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPPSs = pStdPPSs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdPPSs = pStdPPSs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeH265SessionParametersAddInfoKHR & + setStdPPSs( ArrayProxyNoTemporaries const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT + { + stdPPSCount = static_cast( stdPPSs_.size() ); + pStdPPSs = stdPPSs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH265SessionParametersAddInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265SessionParametersAddInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265SessionParametersAddInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH265SessionParametersAddInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdVPSCount, pStdVPSs, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeH265SessionParametersAddInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeH265SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdVPSCount == rhs.stdVPSCount ) && ( pStdVPSs == rhs.pStdVPSs ) && + ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs ); +# endif + } + + bool operator!=( VideoDecodeH265SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeH265SessionParametersAddInfoKHR; + const void * pNext = {}; + uint32_t stdVPSCount = {}; + const StdVideoH265VideoParameterSet * pStdVPSs = {}; + uint32_t stdSPSCount = {}; + const StdVideoH265SequenceParameterSet * pStdSPSs = {}; + uint32_t stdPPSCount = {}; + const StdVideoH265PictureParameterSet * pStdPPSs = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH265SessionParametersAddInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH265SessionParametersAddInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeH265SessionParametersCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265SessionParametersCreateInfoKHR.html + struct VideoDecodeH265SessionParametersCreateInfoKHR + { + using NativeType = VkVideoDecodeH265SessionParametersCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeH265SessionParametersCreateInfoKHR( uint32_t maxStdVPSCount_ = {}, + uint32_t maxStdSPSCount_ = {}, + uint32_t maxStdPPSCount_ = {}, + const VideoDecodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxStdVPSCount{ maxStdVPSCount_ } + , maxStdSPSCount{ maxStdSPSCount_ } + , maxStdPPSCount{ maxStdPPSCount_ } + , pParametersAddInfo{ pParametersAddInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR + VideoDecodeH265SessionParametersCreateInfoKHR( VideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeH265SessionParametersCreateInfoKHR( VkVideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeH265SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeH265SessionParametersCreateInfoKHR & operator=( VideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeH265SessionParametersCreateInfoKHR & operator=( VkVideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR & setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxStdVPSCount = maxStdVPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR && setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxStdVPSCount = maxStdVPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxStdSPSCount = maxStdSPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR && setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxStdSPSCount = maxStdSPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxStdPPSCount = maxStdPPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR && setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxStdPPSCount = maxStdPPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR & + setPParametersAddInfo( const VideoDecodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pParametersAddInfo = pParametersAddInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR && + setPParametersAddInfo( const VideoDecodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pParametersAddInfo = pParametersAddInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeH265SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeH265SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeH265SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxStdVPSCount, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeH265SessionParametersCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdVPSCount == rhs.maxStdVPSCount ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && + ( maxStdPPSCount == rhs.maxStdPPSCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); +# endif + } + + bool operator!=( VideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR; + const void * pNext = {}; + uint32_t maxStdVPSCount = {}; + uint32_t maxStdSPSCount = {}; + uint32_t maxStdPPSCount = {}; + const VideoDecodeH265SessionParametersAddInfoKHR * pParametersAddInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeH265SessionParametersCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeH265SessionParametersCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeInfoKHR.html + struct VideoDecodeInfoKHR + { + using NativeType = VkVideoDecodeInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeInfoKHR( VideoDecodeFlagsKHR flags_ = {}, + Buffer srcBuffer_ = {}, + DeviceSize srcBufferOffset_ = {}, + DeviceSize srcBufferRange_ = {}, + VideoPictureResourceInfoKHR dstPictureResource_ = {}, + const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ = {}, + uint32_t referenceSlotCount_ = {}, + const VideoReferenceSlotInfoKHR * pReferenceSlots_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , srcBuffer{ srcBuffer_ } + , srcBufferOffset{ srcBufferOffset_ } + , srcBufferRange{ srcBufferRange_ } + , dstPictureResource{ dstPictureResource_ } + , pSetupReferenceSlot{ pSetupReferenceSlot_ } + , referenceSlotCount{ referenceSlotCount_ } + , pReferenceSlots{ pReferenceSlots_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeInfoKHR( VideoDecodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeInfoKHR( VkVideoDecodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoDecodeInfoKHR( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeInfoKHR( VideoDecodeFlagsKHR flags_, + Buffer srcBuffer_, + DeviceSize srcBufferOffset_, + DeviceSize srcBufferRange_, + VideoPictureResourceInfoKHR dstPictureResource_, + const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_, + ArrayProxyNoTemporaries const & referenceSlots_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , srcBuffer( srcBuffer_ ) + , srcBufferOffset( srcBufferOffset_ ) + , srcBufferRange( srcBufferRange_ ) + , dstPictureResource( dstPictureResource_ ) + , pSetupReferenceSlot( pSetupReferenceSlot_ ) + , referenceSlotCount( static_cast( referenceSlots_.size() ) ) + , pReferenceSlots( referenceSlots_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoDecodeInfoKHR & operator=( VideoDecodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeInfoKHR & operator=( VkVideoDecodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setFlags( VideoDecodeFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setFlags( VideoDecodeFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setSrcBuffer( Buffer srcBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + srcBuffer = srcBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setSrcBuffer( Buffer srcBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + srcBuffer = srcBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setSrcBufferOffset( DeviceSize srcBufferOffset_ ) & VULKAN_HPP_NOEXCEPT + { + srcBufferOffset = srcBufferOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setSrcBufferOffset( DeviceSize srcBufferOffset_ ) && VULKAN_HPP_NOEXCEPT + { + srcBufferOffset = srcBufferOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setSrcBufferRange( DeviceSize srcBufferRange_ ) & VULKAN_HPP_NOEXCEPT + { + srcBufferRange = srcBufferRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setSrcBufferRange( DeviceSize srcBufferRange_ ) && VULKAN_HPP_NOEXCEPT + { + srcBufferRange = srcBufferRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setDstPictureResource( VideoPictureResourceInfoKHR const & dstPictureResource_ ) & VULKAN_HPP_NOEXCEPT + { + dstPictureResource = dstPictureResource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setDstPictureResource( VideoPictureResourceInfoKHR const & dstPictureResource_ ) && VULKAN_HPP_NOEXCEPT + { + dstPictureResource = dstPictureResource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setPSetupReferenceSlot( const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) & VULKAN_HPP_NOEXCEPT + { + pSetupReferenceSlot = pSetupReferenceSlot_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setPSetupReferenceSlot( const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) && VULKAN_HPP_NOEXCEPT + { + pSetupReferenceSlot = pSetupReferenceSlot_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setReferenceSlotCount( uint32_t referenceSlotCount_ ) & VULKAN_HPP_NOEXCEPT + { + referenceSlotCount = referenceSlotCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setReferenceSlotCount( uint32_t referenceSlotCount_ ) && VULKAN_HPP_NOEXCEPT + { + referenceSlotCount = referenceSlotCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) & VULKAN_HPP_NOEXCEPT + { + pReferenceSlots = pReferenceSlots_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) && VULKAN_HPP_NOEXCEPT + { + pReferenceSlots = pReferenceSlots_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoDecodeInfoKHR & setReferenceSlots( ArrayProxyNoTemporaries const & referenceSlots_ ) VULKAN_HPP_NOEXCEPT + { + referenceSlotCount = static_cast( referenceSlots_.size() ); + pReferenceSlots = referenceSlots_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( + sType, pNext, flags, srcBuffer, srcBufferOffset, srcBufferRange, dstPictureResource, pSetupReferenceSlot, referenceSlotCount, pReferenceSlots ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcBuffer == rhs.srcBuffer ) && + ( srcBufferOffset == rhs.srcBufferOffset ) && ( srcBufferRange == rhs.srcBufferRange ) && ( dstPictureResource == rhs.dstPictureResource ) && + ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) && + ( pReferenceSlots == rhs.pReferenceSlots ); +# endif + } + + bool operator!=( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeInfoKHR; + const void * pNext = {}; + VideoDecodeFlagsKHR flags = {}; + Buffer srcBuffer = {}; + DeviceSize srcBufferOffset = {}; + DeviceSize srcBufferRange = {}; + VideoPictureResourceInfoKHR dstPictureResource = {}; + const VideoReferenceSlotInfoKHR * pSetupReferenceSlot = {}; + uint32_t referenceSlotCount = {}; + const VideoReferenceSlotInfoKHR * pReferenceSlots = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeUsageInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeUsageInfoKHR.html + struct VideoDecodeUsageInfoKHR + { + using NativeType = VkVideoDecodeUsageInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeUsageInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeUsageInfoKHR( VideoDecodeUsageFlagsKHR videoUsageHints_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoUsageHints{ videoUsageHints_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeUsageInfoKHR( VideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeUsageInfoKHR( VkVideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeUsageInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeUsageInfoKHR & operator=( VideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeUsageInfoKHR & operator=( VkVideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeUsageInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeUsageInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeUsageInfoKHR & setVideoUsageHints( VideoDecodeUsageFlagsKHR videoUsageHints_ ) & VULKAN_HPP_NOEXCEPT + { + videoUsageHints = videoUsageHints_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeUsageInfoKHR && setVideoUsageHints( VideoDecodeUsageFlagsKHR videoUsageHints_ ) && VULKAN_HPP_NOEXCEPT + { + videoUsageHints = videoUsageHints_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeUsageInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeUsageInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeUsageInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeUsageInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoUsageHints ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeUsageInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeUsageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoUsageHints == rhs.videoUsageHints ); +# endif + } + + bool operator!=( VideoDecodeUsageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeUsageInfoKHR; + const void * pNext = {}; + VideoDecodeUsageFlagsKHR videoUsageHints = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeUsageInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeUsageInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeVP9CapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeVP9CapabilitiesKHR.html + struct VideoDecodeVP9CapabilitiesKHR + { + using NativeType = VkVideoDecodeVP9CapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeVp9CapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeVP9CapabilitiesKHR( StdVideoVP9Level maxLevel_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxLevel{ maxLevel_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeVP9CapabilitiesKHR( VideoDecodeVP9CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeVP9CapabilitiesKHR( VkVideoDecodeVP9CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeVP9CapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeVP9CapabilitiesKHR & operator=( VideoDecodeVP9CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeVP9CapabilitiesKHR & operator=( VkVideoDecodeVP9CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoDecodeVP9CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeVP9CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeVP9CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeVP9CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxLevel ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeVP9CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoVP9Level ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeVP9CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoVP9Level ) ) == 0 ); + } + + bool operator!=( VideoDecodeVP9CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoDecodeVp9CapabilitiesKHR; + void * pNext = {}; + StdVideoVP9Level maxLevel = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeVP9CapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeVP9CapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoDecodeVP9PictureInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeVP9PictureInfoKHR.html + struct VideoDecodeVP9PictureInfoKHR + { + using NativeType = VkVideoDecodeVP9PictureInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeVp9PictureInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR( const StdVideoDecodeVP9PictureInfo * pStdPictureInfo_ = {}, + std::array const & referenceNameSlotIndices_ = {}, + uint32_t uncompressedHeaderOffset_ = {}, + uint32_t compressedHeaderOffset_ = {}, + uint32_t tilesOffset_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdPictureInfo{ pStdPictureInfo_ } + , referenceNameSlotIndices{ referenceNameSlotIndices_ } + , uncompressedHeaderOffset{ uncompressedHeaderOffset_ } + , compressedHeaderOffset{ compressedHeaderOffset_ } + , tilesOffset{ tilesOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR( VideoDecodeVP9PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeVP9PictureInfoKHR( VkVideoDecodeVP9PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeVP9PictureInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeVP9PictureInfoKHR & operator=( VideoDecodeVP9PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeVP9PictureInfoKHR & operator=( VkVideoDecodeVP9PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & setPStdPictureInfo( const StdVideoDecodeVP9PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && setPStdPictureInfo( const StdVideoDecodeVP9PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & + setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) & + VULKAN_HPP_NOEXCEPT + { + referenceNameSlotIndices = referenceNameSlotIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && + setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) && + VULKAN_HPP_NOEXCEPT + { + referenceNameSlotIndices = referenceNameSlotIndices_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & setUncompressedHeaderOffset( uint32_t uncompressedHeaderOffset_ ) & VULKAN_HPP_NOEXCEPT + { + uncompressedHeaderOffset = uncompressedHeaderOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && setUncompressedHeaderOffset( uint32_t uncompressedHeaderOffset_ ) && VULKAN_HPP_NOEXCEPT + { + uncompressedHeaderOffset = uncompressedHeaderOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & setCompressedHeaderOffset( uint32_t compressedHeaderOffset_ ) & VULKAN_HPP_NOEXCEPT + { + compressedHeaderOffset = compressedHeaderOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && setCompressedHeaderOffset( uint32_t compressedHeaderOffset_ ) && VULKAN_HPP_NOEXCEPT + { + compressedHeaderOffset = compressedHeaderOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & setTilesOffset( uint32_t tilesOffset_ ) & VULKAN_HPP_NOEXCEPT + { + tilesOffset = tilesOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && setTilesOffset( uint32_t tilesOffset_ ) && VULKAN_HPP_NOEXCEPT + { + tilesOffset = tilesOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeVP9PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeVP9PictureInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeVP9PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeVP9PictureInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + uint32_t const &, + uint32_t const &, + uint32_t const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdPictureInfo, referenceNameSlotIndices, uncompressedHeaderOffset, compressedHeaderOffset, tilesOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoDecodeVP9PictureInfoKHR const & ) const = default; +#else + bool operator==( VideoDecodeVP9PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && + ( referenceNameSlotIndices == rhs.referenceNameSlotIndices ) && ( uncompressedHeaderOffset == rhs.uncompressedHeaderOffset ) && + ( compressedHeaderOffset == rhs.compressedHeaderOffset ) && ( tilesOffset == rhs.tilesOffset ); +# endif + } + + bool operator!=( VideoDecodeVP9PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoDecodeVp9PictureInfoKHR; + const void * pNext = {}; + const StdVideoDecodeVP9PictureInfo * pStdPictureInfo = {}; + ArrayWrapper1D referenceNameSlotIndices = {}; + uint32_t uncompressedHeaderOffset = {}; + uint32_t compressedHeaderOffset = {}; + uint32_t tilesOffset = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeVP9PictureInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeVP9PictureInfoKHR; + }; + + // wrapper struct for struct VkVideoDecodeVP9ProfileInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeVP9ProfileInfoKHR.html + struct VideoDecodeVP9ProfileInfoKHR + { + using NativeType = VkVideoDecodeVP9ProfileInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeVp9ProfileInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoDecodeVP9ProfileInfoKHR( StdVideoVP9Profile stdProfile_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stdProfile{ stdProfile_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoDecodeVP9ProfileInfoKHR( VideoDecodeVP9ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoDecodeVP9ProfileInfoKHR( VkVideoDecodeVP9ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoDecodeVP9ProfileInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoDecodeVP9ProfileInfoKHR & operator=( VideoDecodeVP9ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoDecodeVP9ProfileInfoKHR & operator=( VkVideoDecodeVP9ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9ProfileInfoKHR & setStdProfile( StdVideoVP9Profile stdProfile_ ) & VULKAN_HPP_NOEXCEPT + { + stdProfile = stdProfile_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9ProfileInfoKHR && setStdProfile( StdVideoVP9Profile stdProfile_ ) && VULKAN_HPP_NOEXCEPT + { + stdProfile = stdProfile_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoDecodeVP9ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeVP9ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoDecodeVP9ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoDecodeVP9ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfile ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoDecodeVP9ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoVP9Profile ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoDecodeVP9ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoVP9Profile ) ) == 0 ); + } + + bool operator!=( VideoDecodeVP9ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoDecodeVp9ProfileInfoKHR; + const void * pNext = {}; + StdVideoVP9Profile stdProfile = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoDecodeVP9ProfileInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoDecodeVP9ProfileInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeAV1CapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1CapabilitiesKHR.html + struct VideoEncodeAV1CapabilitiesKHR + { + using NativeType = VkVideoEncodeAV1CapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1CapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeAV1CapabilitiesKHR( VideoEncodeAV1CapabilityFlagsKHR flags_ = {}, + StdVideoAV1Level maxLevel_ = {}, + Extent2D codedPictureAlignment_ = {}, + Extent2D maxTiles_ = {}, + Extent2D minTileSize_ = {}, + Extent2D maxTileSize_ = {}, + VideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes_ = {}, + uint32_t maxSingleReferenceCount_ = {}, + uint32_t singleReferenceNameMask_ = {}, + uint32_t maxUnidirectionalCompoundReferenceCount_ = {}, + uint32_t maxUnidirectionalCompoundGroup1ReferenceCount_ = {}, + uint32_t unidirectionalCompoundReferenceNameMask_ = {}, + uint32_t maxBidirectionalCompoundReferenceCount_ = {}, + uint32_t maxBidirectionalCompoundGroup1ReferenceCount_ = {}, + uint32_t maxBidirectionalCompoundGroup2ReferenceCount_ = {}, + uint32_t bidirectionalCompoundReferenceNameMask_ = {}, + uint32_t maxTemporalLayerCount_ = {}, + uint32_t maxSpatialLayerCount_ = {}, + uint32_t maxOperatingPoints_ = {}, + uint32_t minQIndex_ = {}, + uint32_t maxQIndex_ = {}, + Bool32 prefersGopRemainingFrames_ = {}, + Bool32 requiresGopRemainingFrames_ = {}, + VideoEncodeAV1StdFlagsKHR stdSyntaxFlags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , maxLevel{ maxLevel_ } + , codedPictureAlignment{ codedPictureAlignment_ } + , maxTiles{ maxTiles_ } + , minTileSize{ minTileSize_ } + , maxTileSize{ maxTileSize_ } + , superblockSizes{ superblockSizes_ } + , maxSingleReferenceCount{ maxSingleReferenceCount_ } + , singleReferenceNameMask{ singleReferenceNameMask_ } + , maxUnidirectionalCompoundReferenceCount{ maxUnidirectionalCompoundReferenceCount_ } + , maxUnidirectionalCompoundGroup1ReferenceCount{ maxUnidirectionalCompoundGroup1ReferenceCount_ } + , unidirectionalCompoundReferenceNameMask{ unidirectionalCompoundReferenceNameMask_ } + , maxBidirectionalCompoundReferenceCount{ maxBidirectionalCompoundReferenceCount_ } + , maxBidirectionalCompoundGroup1ReferenceCount{ maxBidirectionalCompoundGroup1ReferenceCount_ } + , maxBidirectionalCompoundGroup2ReferenceCount{ maxBidirectionalCompoundGroup2ReferenceCount_ } + , bidirectionalCompoundReferenceNameMask{ bidirectionalCompoundReferenceNameMask_ } + , maxTemporalLayerCount{ maxTemporalLayerCount_ } + , maxSpatialLayerCount{ maxSpatialLayerCount_ } + , maxOperatingPoints{ maxOperatingPoints_ } + , minQIndex{ minQIndex_ } + , maxQIndex{ maxQIndex_ } + , prefersGopRemainingFrames{ prefersGopRemainingFrames_ } + , requiresGopRemainingFrames{ requiresGopRemainingFrames_ } + , stdSyntaxFlags{ stdSyntaxFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1CapabilitiesKHR( VideoEncodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1CapabilitiesKHR( VkVideoEncodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1CapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1CapabilitiesKHR & operator=( VideoEncodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1CapabilitiesKHR & operator=( VkVideoEncodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeAV1CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + maxLevel, + codedPictureAlignment, + maxTiles, + minTileSize, + maxTileSize, + superblockSizes, + maxSingleReferenceCount, + singleReferenceNameMask, + maxUnidirectionalCompoundReferenceCount, + maxUnidirectionalCompoundGroup1ReferenceCount, + unidirectionalCompoundReferenceNameMask, + maxBidirectionalCompoundReferenceCount, + maxBidirectionalCompoundGroup1ReferenceCount, + maxBidirectionalCompoundGroup2ReferenceCount, + bidirectionalCompoundReferenceNameMask, + maxTemporalLayerCount, + maxSpatialLayerCount, + maxOperatingPoints, + minQIndex, + maxQIndex, + prefersGopRemainingFrames, + requiresGopRemainingFrames, + stdSyntaxFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoEncodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = codedPictureAlignment <=> rhs.codedPictureAlignment; cmp != 0 ) + return cmp; + if ( auto cmp = maxTiles <=> rhs.maxTiles; cmp != 0 ) + return cmp; + if ( auto cmp = minTileSize <=> rhs.minTileSize; cmp != 0 ) + return cmp; + if ( auto cmp = maxTileSize <=> rhs.maxTileSize; cmp != 0 ) + return cmp; + if ( auto cmp = superblockSizes <=> rhs.superblockSizes; cmp != 0 ) + return cmp; + if ( auto cmp = maxSingleReferenceCount <=> rhs.maxSingleReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = singleReferenceNameMask <=> rhs.singleReferenceNameMask; cmp != 0 ) + return cmp; + if ( auto cmp = maxUnidirectionalCompoundReferenceCount <=> rhs.maxUnidirectionalCompoundReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxUnidirectionalCompoundGroup1ReferenceCount <=> rhs.maxUnidirectionalCompoundGroup1ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = unidirectionalCompoundReferenceNameMask <=> rhs.unidirectionalCompoundReferenceNameMask; cmp != 0 ) + return cmp; + if ( auto cmp = maxBidirectionalCompoundReferenceCount <=> rhs.maxBidirectionalCompoundReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxBidirectionalCompoundGroup1ReferenceCount <=> rhs.maxBidirectionalCompoundGroup1ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxBidirectionalCompoundGroup2ReferenceCount <=> rhs.maxBidirectionalCompoundGroup2ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = bidirectionalCompoundReferenceNameMask <=> rhs.bidirectionalCompoundReferenceNameMask; cmp != 0 ) + return cmp; + if ( auto cmp = maxTemporalLayerCount <=> rhs.maxTemporalLayerCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxSpatialLayerCount <=> rhs.maxSpatialLayerCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxOperatingPoints <=> rhs.maxOperatingPoints; cmp != 0 ) + return cmp; + if ( auto cmp = minQIndex <=> rhs.minQIndex; cmp != 0 ) + return cmp; + if ( auto cmp = maxQIndex <=> rhs.maxQIndex; cmp != 0 ) + return cmp; + if ( auto cmp = prefersGopRemainingFrames <=> rhs.prefersGopRemainingFrames; cmp != 0 ) + return cmp; + if ( auto cmp = requiresGopRemainingFrames <=> rhs.requiresGopRemainingFrames; cmp != 0 ) + return cmp; + if ( auto cmp = stdSyntaxFlags <=> rhs.stdSyntaxFlags; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoEncodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ) == 0 ) && ( codedPictureAlignment == rhs.codedPictureAlignment ) && + ( maxTiles == rhs.maxTiles ) && ( minTileSize == rhs.minTileSize ) && ( maxTileSize == rhs.maxTileSize ) && + ( superblockSizes == rhs.superblockSizes ) && ( maxSingleReferenceCount == rhs.maxSingleReferenceCount ) && + ( singleReferenceNameMask == rhs.singleReferenceNameMask ) && + ( maxUnidirectionalCompoundReferenceCount == rhs.maxUnidirectionalCompoundReferenceCount ) && + ( maxUnidirectionalCompoundGroup1ReferenceCount == rhs.maxUnidirectionalCompoundGroup1ReferenceCount ) && + ( unidirectionalCompoundReferenceNameMask == rhs.unidirectionalCompoundReferenceNameMask ) && + ( maxBidirectionalCompoundReferenceCount == rhs.maxBidirectionalCompoundReferenceCount ) && + ( maxBidirectionalCompoundGroup1ReferenceCount == rhs.maxBidirectionalCompoundGroup1ReferenceCount ) && + ( maxBidirectionalCompoundGroup2ReferenceCount == rhs.maxBidirectionalCompoundGroup2ReferenceCount ) && + ( bidirectionalCompoundReferenceNameMask == rhs.bidirectionalCompoundReferenceNameMask ) && + ( maxTemporalLayerCount == rhs.maxTemporalLayerCount ) && ( maxSpatialLayerCount == rhs.maxSpatialLayerCount ) && + ( maxOperatingPoints == rhs.maxOperatingPoints ) && ( minQIndex == rhs.minQIndex ) && ( maxQIndex == rhs.maxQIndex ) && + ( prefersGopRemainingFrames == rhs.prefersGopRemainingFrames ) && ( requiresGopRemainingFrames == rhs.requiresGopRemainingFrames ) && + ( stdSyntaxFlags == rhs.stdSyntaxFlags ); + } + + bool operator!=( VideoEncodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoEncodeAv1CapabilitiesKHR; + void * pNext = {}; + VideoEncodeAV1CapabilityFlagsKHR flags = {}; + StdVideoAV1Level maxLevel = {}; + Extent2D codedPictureAlignment = {}; + Extent2D maxTiles = {}; + Extent2D minTileSize = {}; + Extent2D maxTileSize = {}; + VideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes = {}; + uint32_t maxSingleReferenceCount = {}; + uint32_t singleReferenceNameMask = {}; + uint32_t maxUnidirectionalCompoundReferenceCount = {}; + uint32_t maxUnidirectionalCompoundGroup1ReferenceCount = {}; + uint32_t unidirectionalCompoundReferenceNameMask = {}; + uint32_t maxBidirectionalCompoundReferenceCount = {}; + uint32_t maxBidirectionalCompoundGroup1ReferenceCount = {}; + uint32_t maxBidirectionalCompoundGroup2ReferenceCount = {}; + uint32_t bidirectionalCompoundReferenceNameMask = {}; + uint32_t maxTemporalLayerCount = {}; + uint32_t maxSpatialLayerCount = {}; + uint32_t maxOperatingPoints = {}; + uint32_t minQIndex = {}; + uint32_t maxQIndex = {}; + Bool32 prefersGopRemainingFrames = {}; + Bool32 requiresGopRemainingFrames = {}; + VideoEncodeAV1StdFlagsKHR stdSyntaxFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1CapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeAV1CapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeAV1DpbSlotInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1DpbSlotInfoKHR.html + struct VideoEncodeAV1DpbSlotInfoKHR + { + using NativeType = VkVideoEncodeAV1DpbSlotInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1DpbSlotInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeAV1DpbSlotInfoKHR( const StdVideoEncodeAV1ReferenceInfo * pStdReferenceInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdReferenceInfo{ pStdReferenceInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1DpbSlotInfoKHR( VideoEncodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1DpbSlotInfoKHR( VkVideoEncodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1DpbSlotInfoKHR & operator=( VideoEncodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1DpbSlotInfoKHR & operator=( VkVideoEncodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoEncodeAV1ReferenceInfo * pStdReferenceInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoEncodeAV1ReferenceInfo * pStdReferenceInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeAV1DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeAV1DpbSlotInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); +# endif + } + + bool operator!=( VideoEncodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeAv1DpbSlotInfoKHR; + const void * pNext = {}; + const StdVideoEncodeAV1ReferenceInfo * pStdReferenceInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1DpbSlotInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeAV1DpbSlotInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeAV1FrameSizeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1FrameSizeKHR.html + struct VideoEncodeAV1FrameSizeKHR + { + using NativeType = VkVideoEncodeAV1FrameSizeKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoEncodeAV1FrameSizeKHR( uint32_t intraFrameSize_ = {}, uint32_t predictiveFrameSize_ = {}, uint32_t bipredictiveFrameSize_ = {} ) VULKAN_HPP_NOEXCEPT + : intraFrameSize{ intraFrameSize_ } + , predictiveFrameSize{ predictiveFrameSize_ } + , bipredictiveFrameSize{ bipredictiveFrameSize_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1FrameSizeKHR( VideoEncodeAV1FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1FrameSizeKHR( VkVideoEncodeAV1FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1FrameSizeKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1FrameSizeKHR & operator=( VideoEncodeAV1FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1FrameSizeKHR & operator=( VkVideoEncodeAV1FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR & setIntraFrameSize( uint32_t intraFrameSize_ ) & VULKAN_HPP_NOEXCEPT + { + intraFrameSize = intraFrameSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR && setIntraFrameSize( uint32_t intraFrameSize_ ) && VULKAN_HPP_NOEXCEPT + { + intraFrameSize = intraFrameSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR & setPredictiveFrameSize( uint32_t predictiveFrameSize_ ) & VULKAN_HPP_NOEXCEPT + { + predictiveFrameSize = predictiveFrameSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR && setPredictiveFrameSize( uint32_t predictiveFrameSize_ ) && VULKAN_HPP_NOEXCEPT + { + predictiveFrameSize = predictiveFrameSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR & setBipredictiveFrameSize( uint32_t bipredictiveFrameSize_ ) & VULKAN_HPP_NOEXCEPT + { + bipredictiveFrameSize = bipredictiveFrameSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR && setBipredictiveFrameSize( uint32_t bipredictiveFrameSize_ ) && VULKAN_HPP_NOEXCEPT + { + bipredictiveFrameSize = bipredictiveFrameSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeAV1FrameSizeKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1FrameSizeKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1FrameSizeKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1FrameSizeKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( intraFrameSize, predictiveFrameSize, bipredictiveFrameSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeAV1FrameSizeKHR const & ) const = default; +#else + bool operator==( VideoEncodeAV1FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( intraFrameSize == rhs.intraFrameSize ) && ( predictiveFrameSize == rhs.predictiveFrameSize ) && + ( bipredictiveFrameSize == rhs.bipredictiveFrameSize ); +# endif + } + + bool operator!=( VideoEncodeAV1FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t intraFrameSize = {}; + uint32_t predictiveFrameSize = {}; + uint32_t bipredictiveFrameSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1FrameSizeKHR; + }; +#endif + + // wrapper struct for struct VkVideoEncodeAV1GopRemainingFrameInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1GopRemainingFrameInfoKHR.html + struct VideoEncodeAV1GopRemainingFrameInfoKHR + { + using NativeType = VkVideoEncodeAV1GopRemainingFrameInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1GopRemainingFrameInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeAV1GopRemainingFrameInfoKHR( Bool32 useGopRemainingFrames_ = {}, + uint32_t gopRemainingIntra_ = {}, + uint32_t gopRemainingPredictive_ = {}, + uint32_t gopRemainingBipredictive_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , useGopRemainingFrames{ useGopRemainingFrames_ } + , gopRemainingIntra{ gopRemainingIntra_ } + , gopRemainingPredictive{ gopRemainingPredictive_ } + , gopRemainingBipredictive{ gopRemainingBipredictive_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1GopRemainingFrameInfoKHR( VideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1GopRemainingFrameInfoKHR( VkVideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1GopRemainingFrameInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1GopRemainingFrameInfoKHR & operator=( VideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1GopRemainingFrameInfoKHR & operator=( VkVideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR & setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) & VULKAN_HPP_NOEXCEPT + { + useGopRemainingFrames = useGopRemainingFrames_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR && setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) && VULKAN_HPP_NOEXCEPT + { + useGopRemainingFrames = useGopRemainingFrames_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR & setGopRemainingIntra( uint32_t gopRemainingIntra_ ) & VULKAN_HPP_NOEXCEPT + { + gopRemainingIntra = gopRemainingIntra_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR && setGopRemainingIntra( uint32_t gopRemainingIntra_ ) && VULKAN_HPP_NOEXCEPT + { + gopRemainingIntra = gopRemainingIntra_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR & setGopRemainingPredictive( uint32_t gopRemainingPredictive_ ) & VULKAN_HPP_NOEXCEPT + { + gopRemainingPredictive = gopRemainingPredictive_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR && setGopRemainingPredictive( uint32_t gopRemainingPredictive_ ) && VULKAN_HPP_NOEXCEPT + { + gopRemainingPredictive = gopRemainingPredictive_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR & setGopRemainingBipredictive( uint32_t gopRemainingBipredictive_ ) & VULKAN_HPP_NOEXCEPT + { + gopRemainingBipredictive = gopRemainingBipredictive_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR && setGopRemainingBipredictive( uint32_t gopRemainingBipredictive_ ) && VULKAN_HPP_NOEXCEPT + { + gopRemainingBipredictive = gopRemainingBipredictive_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeAV1GopRemainingFrameInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1GopRemainingFrameInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1GopRemainingFrameInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1GopRemainingFrameInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, useGopRemainingFrames, gopRemainingIntra, gopRemainingPredictive, gopRemainingBipredictive ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeAV1GopRemainingFrameInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) && + ( gopRemainingIntra == rhs.gopRemainingIntra ) && ( gopRemainingPredictive == rhs.gopRemainingPredictive ) && + ( gopRemainingBipredictive == rhs.gopRemainingBipredictive ); +# endif + } + + bool operator!=( VideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeAv1GopRemainingFrameInfoKHR; + const void * pNext = {}; + Bool32 useGopRemainingFrames = {}; + uint32_t gopRemainingIntra = {}; + uint32_t gopRemainingPredictive = {}; + uint32_t gopRemainingBipredictive = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1GopRemainingFrameInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeAV1GopRemainingFrameInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeAV1PictureInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1PictureInfoKHR.html + struct VideoEncodeAV1PictureInfoKHR + { + using NativeType = VkVideoEncodeAV1PictureInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1PictureInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR( VideoEncodeAV1PredictionModeKHR predictionMode_ = VideoEncodeAV1PredictionModeKHR::eIntraOnly, + VideoEncodeAV1RateControlGroupKHR rateControlGroup_ = VideoEncodeAV1RateControlGroupKHR::eIntra, + uint32_t constantQIndex_ = {}, + const StdVideoEncodeAV1PictureInfo * pStdPictureInfo_ = {}, + std::array const & referenceNameSlotIndices_ = {}, + Bool32 primaryReferenceCdfOnly_ = {}, + Bool32 generateObuExtensionHeader_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , predictionMode{ predictionMode_ } + , rateControlGroup{ rateControlGroup_ } + , constantQIndex{ constantQIndex_ } + , pStdPictureInfo{ pStdPictureInfo_ } + , referenceNameSlotIndices{ referenceNameSlotIndices_ } + , primaryReferenceCdfOnly{ primaryReferenceCdfOnly_ } + , generateObuExtensionHeader{ generateObuExtensionHeader_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR( VideoEncodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1PictureInfoKHR( VkVideoEncodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1PictureInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1PictureInfoKHR & operator=( VideoEncodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1PictureInfoKHR & operator=( VkVideoEncodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setPredictionMode( VideoEncodeAV1PredictionModeKHR predictionMode_ ) & VULKAN_HPP_NOEXCEPT + { + predictionMode = predictionMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setPredictionMode( VideoEncodeAV1PredictionModeKHR predictionMode_ ) && VULKAN_HPP_NOEXCEPT + { + predictionMode = predictionMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setRateControlGroup( VideoEncodeAV1RateControlGroupKHR rateControlGroup_ ) & VULKAN_HPP_NOEXCEPT + { + rateControlGroup = rateControlGroup_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setRateControlGroup( VideoEncodeAV1RateControlGroupKHR rateControlGroup_ ) && VULKAN_HPP_NOEXCEPT + { + rateControlGroup = rateControlGroup_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setConstantQIndex( uint32_t constantQIndex_ ) & VULKAN_HPP_NOEXCEPT + { + constantQIndex = constantQIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setConstantQIndex( uint32_t constantQIndex_ ) && VULKAN_HPP_NOEXCEPT + { + constantQIndex = constantQIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setPStdPictureInfo( const StdVideoEncodeAV1PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setPStdPictureInfo( const StdVideoEncodeAV1PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & + setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) & + VULKAN_HPP_NOEXCEPT + { + referenceNameSlotIndices = referenceNameSlotIndices_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && + setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) && + VULKAN_HPP_NOEXCEPT + { + referenceNameSlotIndices = referenceNameSlotIndices_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setPrimaryReferenceCdfOnly( Bool32 primaryReferenceCdfOnly_ ) & VULKAN_HPP_NOEXCEPT + { + primaryReferenceCdfOnly = primaryReferenceCdfOnly_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setPrimaryReferenceCdfOnly( Bool32 primaryReferenceCdfOnly_ ) && VULKAN_HPP_NOEXCEPT + { + primaryReferenceCdfOnly = primaryReferenceCdfOnly_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setGenerateObuExtensionHeader( Bool32 generateObuExtensionHeader_ ) & VULKAN_HPP_NOEXCEPT + { + generateObuExtensionHeader = generateObuExtensionHeader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setGenerateObuExtensionHeader( Bool32 generateObuExtensionHeader_ ) && VULKAN_HPP_NOEXCEPT + { + generateObuExtensionHeader = generateObuExtensionHeader_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeAV1PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1PictureInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1PictureInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple const &, + Bool32 const &, + Bool32 const &> + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + predictionMode, + rateControlGroup, + constantQIndex, + pStdPictureInfo, + referenceNameSlotIndices, + primaryReferenceCdfOnly, + generateObuExtensionHeader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeAV1PictureInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( predictionMode == rhs.predictionMode ) && ( rateControlGroup == rhs.rateControlGroup ) && + ( constantQIndex == rhs.constantQIndex ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && + ( referenceNameSlotIndices == rhs.referenceNameSlotIndices ) && ( primaryReferenceCdfOnly == rhs.primaryReferenceCdfOnly ) && + ( generateObuExtensionHeader == rhs.generateObuExtensionHeader ); +# endif + } + + bool operator!=( VideoEncodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeAv1PictureInfoKHR; + const void * pNext = {}; + VideoEncodeAV1PredictionModeKHR predictionMode = VideoEncodeAV1PredictionModeKHR::eIntraOnly; + VideoEncodeAV1RateControlGroupKHR rateControlGroup = VideoEncodeAV1RateControlGroupKHR::eIntra; + uint32_t constantQIndex = {}; + const StdVideoEncodeAV1PictureInfo * pStdPictureInfo = {}; + ArrayWrapper1D referenceNameSlotIndices = {}; + Bool32 primaryReferenceCdfOnly = {}; + Bool32 generateObuExtensionHeader = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1PictureInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeAV1PictureInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeAV1ProfileInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1ProfileInfoKHR.html + struct VideoEncodeAV1ProfileInfoKHR + { + using NativeType = VkVideoEncodeAV1ProfileInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1ProfileInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeAV1ProfileInfoKHR( StdVideoAV1Profile stdProfile_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stdProfile{ stdProfile_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1ProfileInfoKHR( VideoEncodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1ProfileInfoKHR( VkVideoEncodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1ProfileInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1ProfileInfoKHR & operator=( VideoEncodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1ProfileInfoKHR & operator=( VkVideoEncodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1ProfileInfoKHR & setStdProfile( StdVideoAV1Profile stdProfile_ ) & VULKAN_HPP_NOEXCEPT + { + stdProfile = stdProfile_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1ProfileInfoKHR && setStdProfile( StdVideoAV1Profile stdProfile_ ) && VULKAN_HPP_NOEXCEPT + { + stdProfile = stdProfile_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeAV1ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfile ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoEncodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoEncodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ) == 0 ); + } + + bool operator!=( VideoEncodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoEncodeAv1ProfileInfoKHR; + const void * pNext = {}; + StdVideoAV1Profile stdProfile = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1ProfileInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeAV1ProfileInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeAV1QIndexKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1QIndexKHR.html + struct VideoEncodeAV1QIndexKHR + { + using NativeType = VkVideoEncodeAV1QIndexKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoEncodeAV1QIndexKHR( uint32_t intraQIndex_ = {}, uint32_t predictiveQIndex_ = {}, uint32_t bipredictiveQIndex_ = {} ) VULKAN_HPP_NOEXCEPT + : intraQIndex{ intraQIndex_ } + , predictiveQIndex{ predictiveQIndex_ } + , bipredictiveQIndex{ bipredictiveQIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1QIndexKHR( VideoEncodeAV1QIndexKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1QIndexKHR( VkVideoEncodeAV1QIndexKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1QIndexKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1QIndexKHR & operator=( VideoEncodeAV1QIndexKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1QIndexKHR & operator=( VkVideoEncodeAV1QIndexKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR & setIntraQIndex( uint32_t intraQIndex_ ) & VULKAN_HPP_NOEXCEPT + { + intraQIndex = intraQIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR && setIntraQIndex( uint32_t intraQIndex_ ) && VULKAN_HPP_NOEXCEPT + { + intraQIndex = intraQIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR & setPredictiveQIndex( uint32_t predictiveQIndex_ ) & VULKAN_HPP_NOEXCEPT + { + predictiveQIndex = predictiveQIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR && setPredictiveQIndex( uint32_t predictiveQIndex_ ) && VULKAN_HPP_NOEXCEPT + { + predictiveQIndex = predictiveQIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR & setBipredictiveQIndex( uint32_t bipredictiveQIndex_ ) & VULKAN_HPP_NOEXCEPT + { + bipredictiveQIndex = bipredictiveQIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR && setBipredictiveQIndex( uint32_t bipredictiveQIndex_ ) && VULKAN_HPP_NOEXCEPT + { + bipredictiveQIndex = bipredictiveQIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeAV1QIndexKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1QIndexKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1QIndexKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1QIndexKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( intraQIndex, predictiveQIndex, bipredictiveQIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeAV1QIndexKHR const & ) const = default; +#else + bool operator==( VideoEncodeAV1QIndexKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( intraQIndex == rhs.intraQIndex ) && ( predictiveQIndex == rhs.predictiveQIndex ) && ( bipredictiveQIndex == rhs.bipredictiveQIndex ); +# endif + } + + bool operator!=( VideoEncodeAV1QIndexKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t intraQIndex = {}; + uint32_t predictiveQIndex = {}; + uint32_t bipredictiveQIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1QIndexKHR; + }; +#endif + + // wrapper struct for struct VkVideoEncodeAV1QualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1QualityLevelPropertiesKHR.html + struct VideoEncodeAV1QualityLevelPropertiesKHR + { + using NativeType = VkVideoEncodeAV1QualityLevelPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1QualityLevelPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeAV1QualityLevelPropertiesKHR( VideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags_ = {}, + uint32_t preferredGopFrameCount_ = {}, + uint32_t preferredKeyFramePeriod_ = {}, + uint32_t preferredConsecutiveBipredictiveFrameCount_ = {}, + uint32_t preferredTemporalLayerCount_ = {}, + VideoEncodeAV1QIndexKHR preferredConstantQIndex_ = {}, + uint32_t preferredMaxSingleReferenceCount_ = {}, + uint32_t preferredSingleReferenceNameMask_ = {}, + uint32_t preferredMaxUnidirectionalCompoundReferenceCount_ = {}, + uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount_ = {}, + uint32_t preferredUnidirectionalCompoundReferenceNameMask_ = {}, + uint32_t preferredMaxBidirectionalCompoundReferenceCount_ = {}, + uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount_ = {}, + uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount_ = {}, + uint32_t preferredBidirectionalCompoundReferenceNameMask_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , preferredRateControlFlags{ preferredRateControlFlags_ } + , preferredGopFrameCount{ preferredGopFrameCount_ } + , preferredKeyFramePeriod{ preferredKeyFramePeriod_ } + , preferredConsecutiveBipredictiveFrameCount{ preferredConsecutiveBipredictiveFrameCount_ } + , preferredTemporalLayerCount{ preferredTemporalLayerCount_ } + , preferredConstantQIndex{ preferredConstantQIndex_ } + , preferredMaxSingleReferenceCount{ preferredMaxSingleReferenceCount_ } + , preferredSingleReferenceNameMask{ preferredSingleReferenceNameMask_ } + , preferredMaxUnidirectionalCompoundReferenceCount{ preferredMaxUnidirectionalCompoundReferenceCount_ } + , preferredMaxUnidirectionalCompoundGroup1ReferenceCount{ preferredMaxUnidirectionalCompoundGroup1ReferenceCount_ } + , preferredUnidirectionalCompoundReferenceNameMask{ preferredUnidirectionalCompoundReferenceNameMask_ } + , preferredMaxBidirectionalCompoundReferenceCount{ preferredMaxBidirectionalCompoundReferenceCount_ } + , preferredMaxBidirectionalCompoundGroup1ReferenceCount{ preferredMaxBidirectionalCompoundGroup1ReferenceCount_ } + , preferredMaxBidirectionalCompoundGroup2ReferenceCount{ preferredMaxBidirectionalCompoundGroup2ReferenceCount_ } + , preferredBidirectionalCompoundReferenceNameMask{ preferredBidirectionalCompoundReferenceNameMask_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1QualityLevelPropertiesKHR( VideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1QualityLevelPropertiesKHR( VkVideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1QualityLevelPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1QualityLevelPropertiesKHR & operator=( VideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1QualityLevelPropertiesKHR & operator=( VkVideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeAV1QualityLevelPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1QualityLevelPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1QualityLevelPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1QualityLevelPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + preferredRateControlFlags, + preferredGopFrameCount, + preferredKeyFramePeriod, + preferredConsecutiveBipredictiveFrameCount, + preferredTemporalLayerCount, + preferredConstantQIndex, + preferredMaxSingleReferenceCount, + preferredSingleReferenceNameMask, + preferredMaxUnidirectionalCompoundReferenceCount, + preferredMaxUnidirectionalCompoundGroup1ReferenceCount, + preferredUnidirectionalCompoundReferenceNameMask, + preferredMaxBidirectionalCompoundReferenceCount, + preferredMaxBidirectionalCompoundGroup1ReferenceCount, + preferredMaxBidirectionalCompoundGroup2ReferenceCount, + preferredBidirectionalCompoundReferenceNameMask ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeAV1QualityLevelPropertiesKHR const & ) const = default; +#else + bool operator==( VideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) && + ( preferredGopFrameCount == rhs.preferredGopFrameCount ) && ( preferredKeyFramePeriod == rhs.preferredKeyFramePeriod ) && + ( preferredConsecutiveBipredictiveFrameCount == rhs.preferredConsecutiveBipredictiveFrameCount ) && + ( preferredTemporalLayerCount == rhs.preferredTemporalLayerCount ) && ( preferredConstantQIndex == rhs.preferredConstantQIndex ) && + ( preferredMaxSingleReferenceCount == rhs.preferredMaxSingleReferenceCount ) && + ( preferredSingleReferenceNameMask == rhs.preferredSingleReferenceNameMask ) && + ( preferredMaxUnidirectionalCompoundReferenceCount == rhs.preferredMaxUnidirectionalCompoundReferenceCount ) && + ( preferredMaxUnidirectionalCompoundGroup1ReferenceCount == rhs.preferredMaxUnidirectionalCompoundGroup1ReferenceCount ) && + ( preferredUnidirectionalCompoundReferenceNameMask == rhs.preferredUnidirectionalCompoundReferenceNameMask ) && + ( preferredMaxBidirectionalCompoundReferenceCount == rhs.preferredMaxBidirectionalCompoundReferenceCount ) && + ( preferredMaxBidirectionalCompoundGroup1ReferenceCount == rhs.preferredMaxBidirectionalCompoundGroup1ReferenceCount ) && + ( preferredMaxBidirectionalCompoundGroup2ReferenceCount == rhs.preferredMaxBidirectionalCompoundGroup2ReferenceCount ) && + ( preferredBidirectionalCompoundReferenceNameMask == rhs.preferredBidirectionalCompoundReferenceNameMask ); +# endif + } + + bool operator!=( VideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeAv1QualityLevelPropertiesKHR; + void * pNext = {}; + VideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags = {}; + uint32_t preferredGopFrameCount = {}; + uint32_t preferredKeyFramePeriod = {}; + uint32_t preferredConsecutiveBipredictiveFrameCount = {}; + uint32_t preferredTemporalLayerCount = {}; + VideoEncodeAV1QIndexKHR preferredConstantQIndex = {}; + uint32_t preferredMaxSingleReferenceCount = {}; + uint32_t preferredSingleReferenceNameMask = {}; + uint32_t preferredMaxUnidirectionalCompoundReferenceCount = {}; + uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount = {}; + uint32_t preferredUnidirectionalCompoundReferenceNameMask = {}; + uint32_t preferredMaxBidirectionalCompoundReferenceCount = {}; + uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount = {}; + uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount = {}; + uint32_t preferredBidirectionalCompoundReferenceNameMask = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1QualityLevelPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeAV1QualityLevelPropertiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1QuantizationMapCapabilitiesKHR.html + struct VideoEncodeAV1QuantizationMapCapabilitiesKHR + { + using NativeType = VkVideoEncodeAV1QuantizationMapCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1QuantizationMapCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoEncodeAV1QuantizationMapCapabilitiesKHR( int32_t minQIndexDelta_ = {}, int32_t maxQIndexDelta_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minQIndexDelta{ minQIndexDelta_ } + , maxQIndexDelta{ maxQIndexDelta_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1QuantizationMapCapabilitiesKHR( VideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1QuantizationMapCapabilitiesKHR( VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1QuantizationMapCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1QuantizationMapCapabilitiesKHR & operator=( VideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1QuantizationMapCapabilitiesKHR & operator=( VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1QuantizationMapCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minQIndexDelta, maxQIndexDelta ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeAV1QuantizationMapCapabilitiesKHR const & ) const = default; +#else + bool operator==( VideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minQIndexDelta == rhs.minQIndexDelta ) && ( maxQIndexDelta == rhs.maxQIndexDelta ); +# endif + } + + bool operator!=( VideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeAv1QuantizationMapCapabilitiesKHR; + void * pNext = {}; + int32_t minQIndexDelta = {}; + int32_t maxQIndexDelta = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1QuantizationMapCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeAV1QuantizationMapCapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeAV1RateControlInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlInfoKHR.html + struct VideoEncodeAV1RateControlInfoKHR + { + using NativeType = VkVideoEncodeAV1RateControlInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1RateControlInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeAV1RateControlInfoKHR( VideoEncodeAV1RateControlFlagsKHR flags_ = {}, + uint32_t gopFrameCount_ = {}, + uint32_t keyFramePeriod_ = {}, + uint32_t consecutiveBipredictiveFrameCount_ = {}, + uint32_t temporalLayerCount_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , gopFrameCount{ gopFrameCount_ } + , keyFramePeriod{ keyFramePeriod_ } + , consecutiveBipredictiveFrameCount{ consecutiveBipredictiveFrameCount_ } + , temporalLayerCount{ temporalLayerCount_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1RateControlInfoKHR( VideoEncodeAV1RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1RateControlInfoKHR( VkVideoEncodeAV1RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1RateControlInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1RateControlInfoKHR & operator=( VideoEncodeAV1RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1RateControlInfoKHR & operator=( VkVideoEncodeAV1RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setFlags( VideoEncodeAV1RateControlFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setFlags( VideoEncodeAV1RateControlFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setGopFrameCount( uint32_t gopFrameCount_ ) & VULKAN_HPP_NOEXCEPT + { + gopFrameCount = gopFrameCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setGopFrameCount( uint32_t gopFrameCount_ ) && VULKAN_HPP_NOEXCEPT + { + gopFrameCount = gopFrameCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setKeyFramePeriod( uint32_t keyFramePeriod_ ) & VULKAN_HPP_NOEXCEPT + { + keyFramePeriod = keyFramePeriod_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setKeyFramePeriod( uint32_t keyFramePeriod_ ) && VULKAN_HPP_NOEXCEPT + { + keyFramePeriod = keyFramePeriod_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setConsecutiveBipredictiveFrameCount( uint32_t consecutiveBipredictiveFrameCount_ ) & + VULKAN_HPP_NOEXCEPT + { + consecutiveBipredictiveFrameCount = consecutiveBipredictiveFrameCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setConsecutiveBipredictiveFrameCount( uint32_t consecutiveBipredictiveFrameCount_ ) && + VULKAN_HPP_NOEXCEPT + { + consecutiveBipredictiveFrameCount = consecutiveBipredictiveFrameCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setTemporalLayerCount( uint32_t temporalLayerCount_ ) & VULKAN_HPP_NOEXCEPT + { + temporalLayerCount = temporalLayerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setTemporalLayerCount( uint32_t temporalLayerCount_ ) && VULKAN_HPP_NOEXCEPT + { + temporalLayerCount = temporalLayerCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeAV1RateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1RateControlInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1RateControlInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1RateControlInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, gopFrameCount, keyFramePeriod, consecutiveBipredictiveFrameCount, temporalLayerCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeAV1RateControlInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeAV1RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) && + ( keyFramePeriod == rhs.keyFramePeriod ) && ( consecutiveBipredictiveFrameCount == rhs.consecutiveBipredictiveFrameCount ) && + ( temporalLayerCount == rhs.temporalLayerCount ); +# endif + } + + bool operator!=( VideoEncodeAV1RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeAv1RateControlInfoKHR; + const void * pNext = {}; + VideoEncodeAV1RateControlFlagsKHR flags = {}; + uint32_t gopFrameCount = {}; + uint32_t keyFramePeriod = {}; + uint32_t consecutiveBipredictiveFrameCount = {}; + uint32_t temporalLayerCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1RateControlInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeAV1RateControlInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeAV1RateControlLayerInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlLayerInfoKHR.html + struct VideoEncodeAV1RateControlLayerInfoKHR + { + using NativeType = VkVideoEncodeAV1RateControlLayerInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1RateControlLayerInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeAV1RateControlLayerInfoKHR( Bool32 useMinQIndex_ = {}, + VideoEncodeAV1QIndexKHR minQIndex_ = {}, + Bool32 useMaxQIndex_ = {}, + VideoEncodeAV1QIndexKHR maxQIndex_ = {}, + Bool32 useMaxFrameSize_ = {}, + VideoEncodeAV1FrameSizeKHR maxFrameSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , useMinQIndex{ useMinQIndex_ } + , minQIndex{ minQIndex_ } + , useMaxQIndex{ useMaxQIndex_ } + , maxQIndex{ maxQIndex_ } + , useMaxFrameSize{ useMaxFrameSize_ } + , maxFrameSize{ maxFrameSize_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1RateControlLayerInfoKHR( VideoEncodeAV1RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1RateControlLayerInfoKHR( VkVideoEncodeAV1RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1RateControlLayerInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1RateControlLayerInfoKHR & operator=( VideoEncodeAV1RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1RateControlLayerInfoKHR & operator=( VkVideoEncodeAV1RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setUseMinQIndex( Bool32 useMinQIndex_ ) & VULKAN_HPP_NOEXCEPT + { + useMinQIndex = useMinQIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setUseMinQIndex( Bool32 useMinQIndex_ ) && VULKAN_HPP_NOEXCEPT + { + useMinQIndex = useMinQIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setMinQIndex( VideoEncodeAV1QIndexKHR const & minQIndex_ ) & VULKAN_HPP_NOEXCEPT + { + minQIndex = minQIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setMinQIndex( VideoEncodeAV1QIndexKHR const & minQIndex_ ) && VULKAN_HPP_NOEXCEPT + { + minQIndex = minQIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setUseMaxQIndex( Bool32 useMaxQIndex_ ) & VULKAN_HPP_NOEXCEPT + { + useMaxQIndex = useMaxQIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setUseMaxQIndex( Bool32 useMaxQIndex_ ) && VULKAN_HPP_NOEXCEPT + { + useMaxQIndex = useMaxQIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setMaxQIndex( VideoEncodeAV1QIndexKHR const & maxQIndex_ ) & VULKAN_HPP_NOEXCEPT + { + maxQIndex = maxQIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setMaxQIndex( VideoEncodeAV1QIndexKHR const & maxQIndex_ ) && VULKAN_HPP_NOEXCEPT + { + maxQIndex = maxQIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) & VULKAN_HPP_NOEXCEPT + { + useMaxFrameSize = useMaxFrameSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) && VULKAN_HPP_NOEXCEPT + { + useMaxFrameSize = useMaxFrameSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setMaxFrameSize( VideoEncodeAV1FrameSizeKHR const & maxFrameSize_ ) & VULKAN_HPP_NOEXCEPT + { + maxFrameSize = maxFrameSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setMaxFrameSize( VideoEncodeAV1FrameSizeKHR const & maxFrameSize_ ) && VULKAN_HPP_NOEXCEPT + { + maxFrameSize = maxFrameSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeAV1RateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1RateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1RateControlLayerInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1RateControlLayerInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, useMinQIndex, minQIndex, useMaxQIndex, maxQIndex, useMaxFrameSize, maxFrameSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeAV1RateControlLayerInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeAV1RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQIndex == rhs.useMinQIndex ) && ( minQIndex == rhs.minQIndex ) && + ( useMaxQIndex == rhs.useMaxQIndex ) && ( maxQIndex == rhs.maxQIndex ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && + ( maxFrameSize == rhs.maxFrameSize ); +# endif + } + + bool operator!=( VideoEncodeAV1RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeAv1RateControlLayerInfoKHR; + const void * pNext = {}; + Bool32 useMinQIndex = {}; + VideoEncodeAV1QIndexKHR minQIndex = {}; + Bool32 useMaxQIndex = {}; + VideoEncodeAV1QIndexKHR maxQIndex = {}; + Bool32 useMaxFrameSize = {}; + VideoEncodeAV1FrameSizeKHR maxFrameSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1RateControlLayerInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeAV1RateControlLayerInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeAV1SessionCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1SessionCreateInfoKHR.html + struct VideoEncodeAV1SessionCreateInfoKHR + { + using NativeType = VkVideoEncodeAV1SessionCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1SessionCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoEncodeAV1SessionCreateInfoKHR( Bool32 useMaxLevel_ = {}, StdVideoAV1Level maxLevel_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , useMaxLevel{ useMaxLevel_ } + , maxLevel{ maxLevel_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1SessionCreateInfoKHR( VideoEncodeAV1SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1SessionCreateInfoKHR( VkVideoEncodeAV1SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1SessionCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeAV1SessionCreateInfoKHR & operator=( VideoEncodeAV1SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1SessionCreateInfoKHR & operator=( VkVideoEncodeAV1SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR & setUseMaxLevel( Bool32 useMaxLevel_ ) & VULKAN_HPP_NOEXCEPT + { + useMaxLevel = useMaxLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR && setUseMaxLevel( Bool32 useMaxLevel_ ) && VULKAN_HPP_NOEXCEPT + { + useMaxLevel = useMaxLevel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR & setMaxLevel( StdVideoAV1Level maxLevel_ ) & VULKAN_HPP_NOEXCEPT + { + maxLevel = maxLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR && setMaxLevel( StdVideoAV1Level maxLevel_ ) && VULKAN_HPP_NOEXCEPT + { + maxLevel = maxLevel_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeAV1SessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1SessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1SessionCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1SessionCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, useMaxLevel, maxLevel ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoEncodeAV1SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = useMaxLevel <=> rhs.useMaxLevel; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoEncodeAV1SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevel == rhs.useMaxLevel ) && + ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ) == 0 ); + } + + bool operator!=( VideoEncodeAV1SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoEncodeAv1SessionCreateInfoKHR; + const void * pNext = {}; + Bool32 useMaxLevel = {}; + StdVideoAV1Level maxLevel = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1SessionCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeAV1SessionCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeAV1SessionParametersCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1SessionParametersCreateInfoKHR.html + struct VideoEncodeAV1SessionParametersCreateInfoKHR + { + using NativeType = VkVideoEncodeAV1SessionParametersCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1SessionParametersCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeAV1SessionParametersCreateInfoKHR( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ = {}, + const StdVideoEncodeAV1DecoderModelInfo * pStdDecoderModelInfo_ = {}, + uint32_t stdOperatingPointCount_ = {}, + const StdVideoEncodeAV1OperatingPointInfo * pStdOperatingPoints_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdSequenceHeader{ pStdSequenceHeader_ } + , pStdDecoderModelInfo{ pStdDecoderModelInfo_ } + , stdOperatingPointCount{ stdOperatingPointCount_ } + , pStdOperatingPoints{ pStdOperatingPoints_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeAV1SessionParametersCreateInfoKHR( VideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeAV1SessionParametersCreateInfoKHR( VkVideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeAV1SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeAV1SessionParametersCreateInfoKHR( const StdVideoAV1SequenceHeader * pStdSequenceHeader_, + const StdVideoEncodeAV1DecoderModelInfo * pStdDecoderModelInfo_, + ArrayProxyNoTemporaries const & stdOperatingPoints_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , pStdSequenceHeader( pStdSequenceHeader_ ) + , pStdDecoderModelInfo( pStdDecoderModelInfo_ ) + , stdOperatingPointCount( static_cast( stdOperatingPoints_.size() ) ) + , pStdOperatingPoints( stdOperatingPoints_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoEncodeAV1SessionParametersCreateInfoKHR & operator=( VideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeAV1SessionParametersCreateInfoKHR & operator=( VkVideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR & setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdSequenceHeader = pStdSequenceHeader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR && setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdSequenceHeader = pStdSequenceHeader_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR & + setPStdDecoderModelInfo( const StdVideoEncodeAV1DecoderModelInfo * pStdDecoderModelInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdDecoderModelInfo = pStdDecoderModelInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR && + setPStdDecoderModelInfo( const StdVideoEncodeAV1DecoderModelInfo * pStdDecoderModelInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdDecoderModelInfo = pStdDecoderModelInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR & setStdOperatingPointCount( uint32_t stdOperatingPointCount_ ) & VULKAN_HPP_NOEXCEPT + { + stdOperatingPointCount = stdOperatingPointCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR && setStdOperatingPointCount( uint32_t stdOperatingPointCount_ ) && VULKAN_HPP_NOEXCEPT + { + stdOperatingPointCount = stdOperatingPointCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR & + setPStdOperatingPoints( const StdVideoEncodeAV1OperatingPointInfo * pStdOperatingPoints_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdOperatingPoints = pStdOperatingPoints_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR && + setPStdOperatingPoints( const StdVideoEncodeAV1OperatingPointInfo * pStdOperatingPoints_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdOperatingPoints = pStdOperatingPoints_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeAV1SessionParametersCreateInfoKHR & + setStdOperatingPoints( ArrayProxyNoTemporaries const & stdOperatingPoints_ ) VULKAN_HPP_NOEXCEPT + { + stdOperatingPointCount = static_cast( stdOperatingPoints_.size() ); + pStdOperatingPoints = stdOperatingPoints_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeAV1SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeAV1SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdSequenceHeader, pStdDecoderModelInfo, stdOperatingPointCount, pStdOperatingPoints ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeAV1SessionParametersCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdSequenceHeader == rhs.pStdSequenceHeader ) && + ( pStdDecoderModelInfo == rhs.pStdDecoderModelInfo ) && ( stdOperatingPointCount == rhs.stdOperatingPointCount ) && + ( pStdOperatingPoints == rhs.pStdOperatingPoints ); +# endif + } + + bool operator!=( VideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeAv1SessionParametersCreateInfoKHR; + const void * pNext = {}; + const StdVideoAV1SequenceHeader * pStdSequenceHeader = {}; + const StdVideoEncodeAV1DecoderModelInfo * pStdDecoderModelInfo = {}; + uint32_t stdOperatingPointCount = {}; + const StdVideoEncodeAV1OperatingPointInfo * pStdOperatingPoints = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeAV1SessionParametersCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeAV1SessionParametersCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeCapabilitiesKHR.html + struct VideoEncodeCapabilitiesKHR + { + using NativeType = VkVideoEncodeCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeCapabilitiesKHR( VideoEncodeCapabilityFlagsKHR flags_ = {}, + VideoEncodeRateControlModeFlagsKHR rateControlModes_ = {}, + uint32_t maxRateControlLayers_ = {}, + uint64_t maxBitrate_ = {}, + uint32_t maxQualityLevels_ = {}, + Extent2D encodeInputPictureGranularity_ = {}, + VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , rateControlModes{ rateControlModes_ } + , maxRateControlLayers{ maxRateControlLayers_ } + , maxBitrate{ maxBitrate_ } + , maxQualityLevels{ maxQualityLevels_ } + , encodeInputPictureGranularity{ encodeInputPictureGranularity_ } + , supportedEncodeFeedbackFlags{ supportedEncodeFeedbackFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeCapabilitiesKHR( VideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeCapabilitiesKHR( VkVideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeCapabilitiesKHR & operator=( VideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeCapabilitiesKHR & operator=( VkVideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + rateControlModes, + maxRateControlLayers, + maxBitrate, + maxQualityLevels, + encodeInputPictureGranularity, + supportedEncodeFeedbackFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeCapabilitiesKHR const & ) const = default; +#else + bool operator==( VideoEncodeCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlModes == rhs.rateControlModes ) && + ( maxRateControlLayers == rhs.maxRateControlLayers ) && ( maxBitrate == rhs.maxBitrate ) && ( maxQualityLevels == rhs.maxQualityLevels ) && + ( encodeInputPictureGranularity == rhs.encodeInputPictureGranularity ) && ( supportedEncodeFeedbackFlags == rhs.supportedEncodeFeedbackFlags ); +# endif + } + + bool operator!=( VideoEncodeCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeCapabilitiesKHR; + void * pNext = {}; + VideoEncodeCapabilityFlagsKHR flags = {}; + VideoEncodeRateControlModeFlagsKHR rateControlModes = {}; + uint32_t maxRateControlLayers = {}; + uint64_t maxBitrate = {}; + uint32_t maxQualityLevels = {}; + Extent2D encodeInputPictureGranularity = {}; + VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeCapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264CapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264CapabilitiesKHR.html + struct VideoEncodeH264CapabilitiesKHR + { + using NativeType = VkVideoEncodeH264CapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264CapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesKHR( VideoEncodeH264CapabilityFlagsKHR flags_ = {}, + StdVideoH264LevelIdc maxLevelIdc_ = {}, + uint32_t maxSliceCount_ = {}, + uint32_t maxPPictureL0ReferenceCount_ = {}, + uint32_t maxBPictureL0ReferenceCount_ = {}, + uint32_t maxL1ReferenceCount_ = {}, + uint32_t maxTemporalLayerCount_ = {}, + Bool32 expectDyadicTemporalLayerPattern_ = {}, + int32_t minQp_ = {}, + int32_t maxQp_ = {}, + Bool32 prefersGopRemainingFrames_ = {}, + Bool32 requiresGopRemainingFrames_ = {}, + VideoEncodeH264StdFlagsKHR stdSyntaxFlags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , maxLevelIdc{ maxLevelIdc_ } + , maxSliceCount{ maxSliceCount_ } + , maxPPictureL0ReferenceCount{ maxPPictureL0ReferenceCount_ } + , maxBPictureL0ReferenceCount{ maxBPictureL0ReferenceCount_ } + , maxL1ReferenceCount{ maxL1ReferenceCount_ } + , maxTemporalLayerCount{ maxTemporalLayerCount_ } + , expectDyadicTemporalLayerPattern{ expectDyadicTemporalLayerPattern_ } + , minQp{ minQp_ } + , maxQp{ maxQp_ } + , prefersGopRemainingFrames{ prefersGopRemainingFrames_ } + , requiresGopRemainingFrames{ requiresGopRemainingFrames_ } + , stdSyntaxFlags{ stdSyntaxFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesKHR( VideoEncodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264CapabilitiesKHR( VkVideoEncodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264CapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264CapabilitiesKHR & operator=( VideoEncodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264CapabilitiesKHR & operator=( VkVideoEncodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeH264CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + maxLevelIdc, + maxSliceCount, + maxPPictureL0ReferenceCount, + maxBPictureL0ReferenceCount, + maxL1ReferenceCount, + maxTemporalLayerCount, + expectDyadicTemporalLayerPattern, + minQp, + maxQp, + prefersGopRemainingFrames, + requiresGopRemainingFrames, + stdSyntaxFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoEncodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = maxSliceCount <=> rhs.maxSliceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxPPictureL0ReferenceCount <=> rhs.maxPPictureL0ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxBPictureL0ReferenceCount <=> rhs.maxBPictureL0ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxL1ReferenceCount <=> rhs.maxL1ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxTemporalLayerCount <=> rhs.maxTemporalLayerCount; cmp != 0 ) + return cmp; + if ( auto cmp = expectDyadicTemporalLayerPattern <=> rhs.expectDyadicTemporalLayerPattern; cmp != 0 ) + return cmp; + if ( auto cmp = minQp <=> rhs.minQp; cmp != 0 ) + return cmp; + if ( auto cmp = maxQp <=> rhs.maxQp; cmp != 0 ) + return cmp; + if ( auto cmp = prefersGopRemainingFrames <=> rhs.prefersGopRemainingFrames; cmp != 0 ) + return cmp; + if ( auto cmp = requiresGopRemainingFrames <=> rhs.requiresGopRemainingFrames; cmp != 0 ) + return cmp; + if ( auto cmp = stdSyntaxFlags <=> rhs.stdSyntaxFlags; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoEncodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ) == 0 ) && ( maxSliceCount == rhs.maxSliceCount ) && + ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) && ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) && + ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) && ( maxTemporalLayerCount == rhs.maxTemporalLayerCount ) && + ( expectDyadicTemporalLayerPattern == rhs.expectDyadicTemporalLayerPattern ) && ( minQp == rhs.minQp ) && ( maxQp == rhs.maxQp ) && + ( prefersGopRemainingFrames == rhs.prefersGopRemainingFrames ) && ( requiresGopRemainingFrames == rhs.requiresGopRemainingFrames ) && + ( stdSyntaxFlags == rhs.stdSyntaxFlags ); + } + + bool operator!=( VideoEncodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoEncodeH264CapabilitiesKHR; + void * pNext = {}; + VideoEncodeH264CapabilityFlagsKHR flags = {}; + StdVideoH264LevelIdc maxLevelIdc = {}; + uint32_t maxSliceCount = {}; + uint32_t maxPPictureL0ReferenceCount = {}; + uint32_t maxBPictureL0ReferenceCount = {}; + uint32_t maxL1ReferenceCount = {}; + uint32_t maxTemporalLayerCount = {}; + Bool32 expectDyadicTemporalLayerPattern = {}; + int32_t minQp = {}; + int32_t maxQp = {}; + Bool32 prefersGopRemainingFrames = {}; + Bool32 requiresGopRemainingFrames = {}; + VideoEncodeH264StdFlagsKHR stdSyntaxFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264CapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264CapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264DpbSlotInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264DpbSlotInfoKHR.html + struct VideoEncodeH264DpbSlotInfoKHR + { + using NativeType = VkVideoEncodeH264DpbSlotInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264DpbSlotInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264DpbSlotInfoKHR( const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdReferenceInfo{ pStdReferenceInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264DpbSlotInfoKHR( VideoEncodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264DpbSlotInfoKHR( VkVideoEncodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264DpbSlotInfoKHR & operator=( VideoEncodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264DpbSlotInfoKHR & operator=( VkVideoEncodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264DpbSlotInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); +# endif + } + + bool operator!=( VideoEncodeH264DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264DpbSlotInfoKHR; + const void * pNext = {}; + const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264DpbSlotInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264DpbSlotInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264FrameSizeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264FrameSizeKHR.html + struct VideoEncodeH264FrameSizeKHR + { + using NativeType = VkVideoEncodeH264FrameSizeKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264FrameSizeKHR( uint32_t frameISize_ = {}, uint32_t framePSize_ = {}, uint32_t frameBSize_ = {} ) VULKAN_HPP_NOEXCEPT + : frameISize{ frameISize_ } + , framePSize{ framePSize_ } + , frameBSize{ frameBSize_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264FrameSizeKHR( VideoEncodeH264FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264FrameSizeKHR( VkVideoEncodeH264FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264FrameSizeKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264FrameSizeKHR & operator=( VideoEncodeH264FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264FrameSizeKHR & operator=( VkVideoEncodeH264FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR & setFrameISize( uint32_t frameISize_ ) & VULKAN_HPP_NOEXCEPT + { + frameISize = frameISize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR && setFrameISize( uint32_t frameISize_ ) && VULKAN_HPP_NOEXCEPT + { + frameISize = frameISize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR & setFramePSize( uint32_t framePSize_ ) & VULKAN_HPP_NOEXCEPT + { + framePSize = framePSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR && setFramePSize( uint32_t framePSize_ ) && VULKAN_HPP_NOEXCEPT + { + framePSize = framePSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR & setFrameBSize( uint32_t frameBSize_ ) & VULKAN_HPP_NOEXCEPT + { + frameBSize = frameBSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR && setFrameBSize( uint32_t frameBSize_ ) && VULKAN_HPP_NOEXCEPT + { + frameBSize = frameBSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264FrameSizeKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264FrameSizeKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264FrameSizeKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264FrameSizeKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( frameISize, framePSize, frameBSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264FrameSizeKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize ); +# endif + } + + bool operator!=( VideoEncodeH264FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t frameISize = {}; + uint32_t framePSize = {}; + uint32_t frameBSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264FrameSizeKHR; + }; +#endif + + // wrapper struct for struct VkVideoEncodeH264GopRemainingFrameInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264GopRemainingFrameInfoKHR.html + struct VideoEncodeH264GopRemainingFrameInfoKHR + { + using NativeType = VkVideoEncodeH264GopRemainingFrameInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264GopRemainingFrameInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264GopRemainingFrameInfoKHR( Bool32 useGopRemainingFrames_ = {}, + uint32_t gopRemainingI_ = {}, + uint32_t gopRemainingP_ = {}, + uint32_t gopRemainingB_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , useGopRemainingFrames{ useGopRemainingFrames_ } + , gopRemainingI{ gopRemainingI_ } + , gopRemainingP{ gopRemainingP_ } + , gopRemainingB{ gopRemainingB_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264GopRemainingFrameInfoKHR( VideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264GopRemainingFrameInfoKHR( VkVideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264GopRemainingFrameInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264GopRemainingFrameInfoKHR & operator=( VideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264GopRemainingFrameInfoKHR & operator=( VkVideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR & setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) & VULKAN_HPP_NOEXCEPT + { + useGopRemainingFrames = useGopRemainingFrames_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR && setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) && VULKAN_HPP_NOEXCEPT + { + useGopRemainingFrames = useGopRemainingFrames_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR & setGopRemainingI( uint32_t gopRemainingI_ ) & VULKAN_HPP_NOEXCEPT + { + gopRemainingI = gopRemainingI_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR && setGopRemainingI( uint32_t gopRemainingI_ ) && VULKAN_HPP_NOEXCEPT + { + gopRemainingI = gopRemainingI_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR & setGopRemainingP( uint32_t gopRemainingP_ ) & VULKAN_HPP_NOEXCEPT + { + gopRemainingP = gopRemainingP_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR && setGopRemainingP( uint32_t gopRemainingP_ ) && VULKAN_HPP_NOEXCEPT + { + gopRemainingP = gopRemainingP_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR & setGopRemainingB( uint32_t gopRemainingB_ ) & VULKAN_HPP_NOEXCEPT + { + gopRemainingB = gopRemainingB_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR && setGopRemainingB( uint32_t gopRemainingB_ ) && VULKAN_HPP_NOEXCEPT + { + gopRemainingB = gopRemainingB_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264GopRemainingFrameInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264GopRemainingFrameInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264GopRemainingFrameInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264GopRemainingFrameInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, useGopRemainingFrames, gopRemainingI, gopRemainingP, gopRemainingB ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264GopRemainingFrameInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) && + ( gopRemainingI == rhs.gopRemainingI ) && ( gopRemainingP == rhs.gopRemainingP ) && ( gopRemainingB == rhs.gopRemainingB ); +# endif + } + + bool operator!=( VideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264GopRemainingFrameInfoKHR; + const void * pNext = {}; + Bool32 useGopRemainingFrames = {}; + uint32_t gopRemainingI = {}; + uint32_t gopRemainingP = {}; + uint32_t gopRemainingB = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264GopRemainingFrameInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264GopRemainingFrameInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264NaluSliceInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264NaluSliceInfoKHR.html + struct VideoEncodeH264NaluSliceInfoKHR + { + using NativeType = VkVideoEncodeH264NaluSliceInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264NaluSliceInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264NaluSliceInfoKHR( int32_t constantQp_ = {}, + const StdVideoEncodeH264SliceHeader * pStdSliceHeader_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , constantQp{ constantQp_ } + , pStdSliceHeader{ pStdSliceHeader_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264NaluSliceInfoKHR( VideoEncodeH264NaluSliceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264NaluSliceInfoKHR( VkVideoEncodeH264NaluSliceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264NaluSliceInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264NaluSliceInfoKHR & operator=( VideoEncodeH264NaluSliceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264NaluSliceInfoKHR & operator=( VkVideoEncodeH264NaluSliceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR & setConstantQp( int32_t constantQp_ ) & VULKAN_HPP_NOEXCEPT + { + constantQp = constantQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR && setConstantQp( int32_t constantQp_ ) && VULKAN_HPP_NOEXCEPT + { + constantQp = constantQp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR & setPStdSliceHeader( const StdVideoEncodeH264SliceHeader * pStdSliceHeader_ ) & VULKAN_HPP_NOEXCEPT + { + pStdSliceHeader = pStdSliceHeader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR && setPStdSliceHeader( const StdVideoEncodeH264SliceHeader * pStdSliceHeader_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdSliceHeader = pStdSliceHeader_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264NaluSliceInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264NaluSliceInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264NaluSliceInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264NaluSliceInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, constantQp, pStdSliceHeader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264NaluSliceInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264NaluSliceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantQp == rhs.constantQp ) && ( pStdSliceHeader == rhs.pStdSliceHeader ); +# endif + } + + bool operator!=( VideoEncodeH264NaluSliceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264NaluSliceInfoKHR; + const void * pNext = {}; + int32_t constantQp = {}; + const StdVideoEncodeH264SliceHeader * pStdSliceHeader = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264NaluSliceInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264NaluSliceInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264PictureInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264PictureInfoKHR.html + struct VideoEncodeH264PictureInfoKHR + { + using NativeType = VkVideoEncodeH264PictureInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264PictureInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264PictureInfoKHR( uint32_t naluSliceEntryCount_ = {}, + const VideoEncodeH264NaluSliceInfoKHR * pNaluSliceEntries_ = {}, + const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {}, + Bool32 generatePrefixNalu_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , naluSliceEntryCount{ naluSliceEntryCount_ } + , pNaluSliceEntries{ pNaluSliceEntries_ } + , pStdPictureInfo{ pStdPictureInfo_ } + , generatePrefixNalu{ generatePrefixNalu_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264PictureInfoKHR( VideoEncodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264PictureInfoKHR( VkVideoEncodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264PictureInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH264PictureInfoKHR( ArrayProxyNoTemporaries const & naluSliceEntries_, + const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {}, + Bool32 generatePrefixNalu_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , naluSliceEntryCount( static_cast( naluSliceEntries_.size() ) ) + , pNaluSliceEntries( naluSliceEntries_.data() ) + , pStdPictureInfo( pStdPictureInfo_ ) + , generatePrefixNalu( generatePrefixNalu_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoEncodeH264PictureInfoKHR & operator=( VideoEncodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264PictureInfoKHR & operator=( VkVideoEncodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR & setNaluSliceEntryCount( uint32_t naluSliceEntryCount_ ) & VULKAN_HPP_NOEXCEPT + { + naluSliceEntryCount = naluSliceEntryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR && setNaluSliceEntryCount( uint32_t naluSliceEntryCount_ ) && VULKAN_HPP_NOEXCEPT + { + naluSliceEntryCount = naluSliceEntryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR & setPNaluSliceEntries( const VideoEncodeH264NaluSliceInfoKHR * pNaluSliceEntries_ ) & + VULKAN_HPP_NOEXCEPT + { + pNaluSliceEntries = pNaluSliceEntries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR && setPNaluSliceEntries( const VideoEncodeH264NaluSliceInfoKHR * pNaluSliceEntries_ ) && + VULKAN_HPP_NOEXCEPT + { + pNaluSliceEntries = pNaluSliceEntries_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH264PictureInfoKHR & + setNaluSliceEntries( ArrayProxyNoTemporaries const & naluSliceEntries_ ) VULKAN_HPP_NOEXCEPT + { + naluSliceEntryCount = static_cast( naluSliceEntries_.size() ); + pNaluSliceEntries = naluSliceEntries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR & setPStdPictureInfo( const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR && setPStdPictureInfo( const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR & setGeneratePrefixNalu( Bool32 generatePrefixNalu_ ) & VULKAN_HPP_NOEXCEPT + { + generatePrefixNalu = generatePrefixNalu_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR && setGeneratePrefixNalu( Bool32 generatePrefixNalu_ ) && VULKAN_HPP_NOEXCEPT + { + generatePrefixNalu = generatePrefixNalu_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264PictureInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264PictureInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, naluSliceEntryCount, pNaluSliceEntries, pStdPictureInfo, generatePrefixNalu ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264PictureInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && + ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( generatePrefixNalu == rhs.generatePrefixNalu ); +# endif + } + + bool operator!=( VideoEncodeH264PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264PictureInfoKHR; + const void * pNext = {}; + uint32_t naluSliceEntryCount = {}; + const VideoEncodeH264NaluSliceInfoKHR * pNaluSliceEntries = {}; + const StdVideoEncodeH264PictureInfo * pStdPictureInfo = {}; + Bool32 generatePrefixNalu = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264PictureInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264PictureInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264ProfileInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264ProfileInfoKHR.html + struct VideoEncodeH264ProfileInfoKHR + { + using NativeType = VkVideoEncodeH264ProfileInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264ProfileInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264ProfileInfoKHR( StdVideoH264ProfileIdc stdProfileIdc_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stdProfileIdc{ stdProfileIdc_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264ProfileInfoKHR( VideoEncodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264ProfileInfoKHR( VkVideoEncodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264ProfileInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264ProfileInfoKHR & operator=( VideoEncodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264ProfileInfoKHR & operator=( VkVideoEncodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ProfileInfoKHR & setStdProfileIdc( StdVideoH264ProfileIdc stdProfileIdc_ ) & VULKAN_HPP_NOEXCEPT + { + stdProfileIdc = stdProfileIdc_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ProfileInfoKHR && setStdProfileIdc( StdVideoH264ProfileIdc stdProfileIdc_ ) && VULKAN_HPP_NOEXCEPT + { + stdProfileIdc = stdProfileIdc_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoEncodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoEncodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ); + } + + bool operator!=( VideoEncodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoEncodeH264ProfileInfoKHR; + const void * pNext = {}; + StdVideoH264ProfileIdc stdProfileIdc = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264ProfileInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264ProfileInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264QpKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264QpKHR.html + struct VideoEncodeH264QpKHR + { + using NativeType = VkVideoEncodeH264QpKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264QpKHR( int32_t qpI_ = {}, int32_t qpP_ = {}, int32_t qpB_ = {} ) VULKAN_HPP_NOEXCEPT + : qpI{ qpI_ } + , qpP{ qpP_ } + , qpB{ qpB_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264QpKHR( VideoEncodeH264QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264QpKHR( VkVideoEncodeH264QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264QpKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264QpKHR & operator=( VideoEncodeH264QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264QpKHR & operator=( VkVideoEncodeH264QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR & setQpI( int32_t qpI_ ) & VULKAN_HPP_NOEXCEPT + { + qpI = qpI_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR && setQpI( int32_t qpI_ ) && VULKAN_HPP_NOEXCEPT + { + qpI = qpI_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR & setQpP( int32_t qpP_ ) & VULKAN_HPP_NOEXCEPT + { + qpP = qpP_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR && setQpP( int32_t qpP_ ) && VULKAN_HPP_NOEXCEPT + { + qpP = qpP_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR & setQpB( int32_t qpB_ ) & VULKAN_HPP_NOEXCEPT + { + qpB = qpB_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR && setQpB( int32_t qpB_ ) && VULKAN_HPP_NOEXCEPT + { + qpB = qpB_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264QpKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264QpKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264QpKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264QpKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( qpI, qpP, qpB ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264QpKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264QpKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); +# endif + } + + bool operator!=( VideoEncodeH264QpKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + int32_t qpI = {}; + int32_t qpP = {}; + int32_t qpB = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264QpKHR; + }; +#endif + + // wrapper struct for struct VkVideoEncodeH264QualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264QualityLevelPropertiesKHR.html + struct VideoEncodeH264QualityLevelPropertiesKHR + { + using NativeType = VkVideoEncodeH264QualityLevelPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264QualityLevelPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264QualityLevelPropertiesKHR( VideoEncodeH264RateControlFlagsKHR preferredRateControlFlags_ = {}, + uint32_t preferredGopFrameCount_ = {}, + uint32_t preferredIdrPeriod_ = {}, + uint32_t preferredConsecutiveBFrameCount_ = {}, + uint32_t preferredTemporalLayerCount_ = {}, + VideoEncodeH264QpKHR preferredConstantQp_ = {}, + uint32_t preferredMaxL0ReferenceCount_ = {}, + uint32_t preferredMaxL1ReferenceCount_ = {}, + Bool32 preferredStdEntropyCodingModeFlag_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , preferredRateControlFlags{ preferredRateControlFlags_ } + , preferredGopFrameCount{ preferredGopFrameCount_ } + , preferredIdrPeriod{ preferredIdrPeriod_ } + , preferredConsecutiveBFrameCount{ preferredConsecutiveBFrameCount_ } + , preferredTemporalLayerCount{ preferredTemporalLayerCount_ } + , preferredConstantQp{ preferredConstantQp_ } + , preferredMaxL0ReferenceCount{ preferredMaxL0ReferenceCount_ } + , preferredMaxL1ReferenceCount{ preferredMaxL1ReferenceCount_ } + , preferredStdEntropyCodingModeFlag{ preferredStdEntropyCodingModeFlag_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264QualityLevelPropertiesKHR( VideoEncodeH264QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264QualityLevelPropertiesKHR( VkVideoEncodeH264QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264QualityLevelPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264QualityLevelPropertiesKHR & operator=( VideoEncodeH264QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264QualityLevelPropertiesKHR & operator=( VkVideoEncodeH264QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeH264QualityLevelPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264QualityLevelPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264QualityLevelPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264QualityLevelPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + preferredRateControlFlags, + preferredGopFrameCount, + preferredIdrPeriod, + preferredConsecutiveBFrameCount, + preferredTemporalLayerCount, + preferredConstantQp, + preferredMaxL0ReferenceCount, + preferredMaxL1ReferenceCount, + preferredStdEntropyCodingModeFlag ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264QualityLevelPropertiesKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) && + ( preferredGopFrameCount == rhs.preferredGopFrameCount ) && ( preferredIdrPeriod == rhs.preferredIdrPeriod ) && + ( preferredConsecutiveBFrameCount == rhs.preferredConsecutiveBFrameCount ) && ( preferredTemporalLayerCount == rhs.preferredTemporalLayerCount ) && + ( preferredConstantQp == rhs.preferredConstantQp ) && ( preferredMaxL0ReferenceCount == rhs.preferredMaxL0ReferenceCount ) && + ( preferredMaxL1ReferenceCount == rhs.preferredMaxL1ReferenceCount ) && + ( preferredStdEntropyCodingModeFlag == rhs.preferredStdEntropyCodingModeFlag ); +# endif + } + + bool operator!=( VideoEncodeH264QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264QualityLevelPropertiesKHR; + void * pNext = {}; + VideoEncodeH264RateControlFlagsKHR preferredRateControlFlags = {}; + uint32_t preferredGopFrameCount = {}; + uint32_t preferredIdrPeriod = {}; + uint32_t preferredConsecutiveBFrameCount = {}; + uint32_t preferredTemporalLayerCount = {}; + VideoEncodeH264QpKHR preferredConstantQp = {}; + uint32_t preferredMaxL0ReferenceCount = {}; + uint32_t preferredMaxL1ReferenceCount = {}; + Bool32 preferredStdEntropyCodingModeFlag = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264QualityLevelPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264QualityLevelPropertiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264QuantizationMapCapabilitiesKHR.html + struct VideoEncodeH264QuantizationMapCapabilitiesKHR + { + using NativeType = VkVideoEncodeH264QuantizationMapCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264QuantizationMapCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoEncodeH264QuantizationMapCapabilitiesKHR( int32_t minQpDelta_ = {}, int32_t maxQpDelta_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minQpDelta{ minQpDelta_ } + , maxQpDelta{ maxQpDelta_ } + { + } + + VULKAN_HPP_CONSTEXPR + VideoEncodeH264QuantizationMapCapabilitiesKHR( VideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264QuantizationMapCapabilitiesKHR( VkVideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264QuantizationMapCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264QuantizationMapCapabilitiesKHR & operator=( VideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264QuantizationMapCapabilitiesKHR & operator=( VkVideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeH264QuantizationMapCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264QuantizationMapCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264QuantizationMapCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264QuantizationMapCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minQpDelta, maxQpDelta ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264QuantizationMapCapabilitiesKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minQpDelta == rhs.minQpDelta ) && ( maxQpDelta == rhs.maxQpDelta ); +# endif + } + + bool operator!=( VideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264QuantizationMapCapabilitiesKHR; + void * pNext = {}; + int32_t minQpDelta = {}; + int32_t maxQpDelta = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264QuantizationMapCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264QuantizationMapCapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264RateControlInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlInfoKHR.html + struct VideoEncodeH264RateControlInfoKHR + { + using NativeType = VkVideoEncodeH264RateControlInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264RateControlInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoKHR( VideoEncodeH264RateControlFlagsKHR flags_ = {}, + uint32_t gopFrameCount_ = {}, + uint32_t idrPeriod_ = {}, + uint32_t consecutiveBFrameCount_ = {}, + uint32_t temporalLayerCount_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , gopFrameCount{ gopFrameCount_ } + , idrPeriod{ idrPeriod_ } + , consecutiveBFrameCount{ consecutiveBFrameCount_ } + , temporalLayerCount{ temporalLayerCount_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoKHR( VideoEncodeH264RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264RateControlInfoKHR( VkVideoEncodeH264RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264RateControlInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264RateControlInfoKHR & operator=( VideoEncodeH264RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264RateControlInfoKHR & operator=( VkVideoEncodeH264RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setFlags( VideoEncodeH264RateControlFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setFlags( VideoEncodeH264RateControlFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setGopFrameCount( uint32_t gopFrameCount_ ) & VULKAN_HPP_NOEXCEPT + { + gopFrameCount = gopFrameCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setGopFrameCount( uint32_t gopFrameCount_ ) && VULKAN_HPP_NOEXCEPT + { + gopFrameCount = gopFrameCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setIdrPeriod( uint32_t idrPeriod_ ) & VULKAN_HPP_NOEXCEPT + { + idrPeriod = idrPeriod_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setIdrPeriod( uint32_t idrPeriod_ ) && VULKAN_HPP_NOEXCEPT + { + idrPeriod = idrPeriod_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) & VULKAN_HPP_NOEXCEPT + { + consecutiveBFrameCount = consecutiveBFrameCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) && VULKAN_HPP_NOEXCEPT + { + consecutiveBFrameCount = consecutiveBFrameCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setTemporalLayerCount( uint32_t temporalLayerCount_ ) & VULKAN_HPP_NOEXCEPT + { + temporalLayerCount = temporalLayerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setTemporalLayerCount( uint32_t temporalLayerCount_ ) && VULKAN_HPP_NOEXCEPT + { + temporalLayerCount = temporalLayerCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264RateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264RateControlInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264RateControlInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264RateControlInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, gopFrameCount, idrPeriod, consecutiveBFrameCount, temporalLayerCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264RateControlInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) && + ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( temporalLayerCount == rhs.temporalLayerCount ); +# endif + } + + bool operator!=( VideoEncodeH264RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264RateControlInfoKHR; + const void * pNext = {}; + VideoEncodeH264RateControlFlagsKHR flags = {}; + uint32_t gopFrameCount = {}; + uint32_t idrPeriod = {}; + uint32_t consecutiveBFrameCount = {}; + uint32_t temporalLayerCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264RateControlInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264RateControlInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264RateControlLayerInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlLayerInfoKHR.html + struct VideoEncodeH264RateControlLayerInfoKHR + { + using NativeType = VkVideoEncodeH264RateControlLayerInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264RateControlLayerInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlLayerInfoKHR( Bool32 useMinQp_ = {}, + VideoEncodeH264QpKHR minQp_ = {}, + Bool32 useMaxQp_ = {}, + VideoEncodeH264QpKHR maxQp_ = {}, + Bool32 useMaxFrameSize_ = {}, + VideoEncodeH264FrameSizeKHR maxFrameSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , useMinQp{ useMinQp_ } + , minQp{ minQp_ } + , useMaxQp{ useMaxQp_ } + , maxQp{ maxQp_ } + , useMaxFrameSize{ useMaxFrameSize_ } + , maxFrameSize{ maxFrameSize_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlLayerInfoKHR( VideoEncodeH264RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264RateControlLayerInfoKHR( VkVideoEncodeH264RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264RateControlLayerInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264RateControlLayerInfoKHR & operator=( VideoEncodeH264RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264RateControlLayerInfoKHR & operator=( VkVideoEncodeH264RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setUseMinQp( Bool32 useMinQp_ ) & VULKAN_HPP_NOEXCEPT + { + useMinQp = useMinQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setUseMinQp( Bool32 useMinQp_ ) && VULKAN_HPP_NOEXCEPT + { + useMinQp = useMinQp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setMinQp( VideoEncodeH264QpKHR const & minQp_ ) & VULKAN_HPP_NOEXCEPT + { + minQp = minQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setMinQp( VideoEncodeH264QpKHR const & minQp_ ) && VULKAN_HPP_NOEXCEPT + { + minQp = minQp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setUseMaxQp( Bool32 useMaxQp_ ) & VULKAN_HPP_NOEXCEPT + { + useMaxQp = useMaxQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setUseMaxQp( Bool32 useMaxQp_ ) && VULKAN_HPP_NOEXCEPT + { + useMaxQp = useMaxQp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setMaxQp( VideoEncodeH264QpKHR const & maxQp_ ) & VULKAN_HPP_NOEXCEPT + { + maxQp = maxQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setMaxQp( VideoEncodeH264QpKHR const & maxQp_ ) && VULKAN_HPP_NOEXCEPT + { + maxQp = maxQp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) & VULKAN_HPP_NOEXCEPT + { + useMaxFrameSize = useMaxFrameSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) && VULKAN_HPP_NOEXCEPT + { + useMaxFrameSize = useMaxFrameSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setMaxFrameSize( VideoEncodeH264FrameSizeKHR const & maxFrameSize_ ) & VULKAN_HPP_NOEXCEPT + { + maxFrameSize = maxFrameSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setMaxFrameSize( VideoEncodeH264FrameSizeKHR const & maxFrameSize_ ) && + VULKAN_HPP_NOEXCEPT + { + maxFrameSize = maxFrameSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264RateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264RateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264RateControlLayerInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264RateControlLayerInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264RateControlLayerInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && + ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && ( maxFrameSize == rhs.maxFrameSize ); +# endif + } + + bool operator!=( VideoEncodeH264RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264RateControlLayerInfoKHR; + const void * pNext = {}; + Bool32 useMinQp = {}; + VideoEncodeH264QpKHR minQp = {}; + Bool32 useMaxQp = {}; + VideoEncodeH264QpKHR maxQp = {}; + Bool32 useMaxFrameSize = {}; + VideoEncodeH264FrameSizeKHR maxFrameSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264RateControlLayerInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264RateControlLayerInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264SessionCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionCreateInfoKHR.html + struct VideoEncodeH264SessionCreateInfoKHR + { + using NativeType = VkVideoEncodeH264SessionCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionCreateInfoKHR( Bool32 useMaxLevelIdc_ = {}, + StdVideoH264LevelIdc maxLevelIdc_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , useMaxLevelIdc{ useMaxLevelIdc_ } + , maxLevelIdc{ maxLevelIdc_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionCreateInfoKHR( VideoEncodeH264SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264SessionCreateInfoKHR( VkVideoEncodeH264SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264SessionCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264SessionCreateInfoKHR & operator=( VideoEncodeH264SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264SessionCreateInfoKHR & operator=( VkVideoEncodeH264SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR & setUseMaxLevelIdc( Bool32 useMaxLevelIdc_ ) & VULKAN_HPP_NOEXCEPT + { + useMaxLevelIdc = useMaxLevelIdc_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR && setUseMaxLevelIdc( Bool32 useMaxLevelIdc_ ) && VULKAN_HPP_NOEXCEPT + { + useMaxLevelIdc = useMaxLevelIdc_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR & setMaxLevelIdc( StdVideoH264LevelIdc maxLevelIdc_ ) & VULKAN_HPP_NOEXCEPT + { + maxLevelIdc = maxLevelIdc_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR && setMaxLevelIdc( StdVideoH264LevelIdc maxLevelIdc_ ) && VULKAN_HPP_NOEXCEPT + { + maxLevelIdc = maxLevelIdc_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264SessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, useMaxLevelIdc, maxLevelIdc ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoEncodeH264SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = useMaxLevelIdc <=> rhs.useMaxLevelIdc; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoEncodeH264SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevelIdc == rhs.useMaxLevelIdc ) && + ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ) == 0 ); + } + + bool operator!=( VideoEncodeH264SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoEncodeH264SessionCreateInfoKHR; + const void * pNext = {}; + Bool32 useMaxLevelIdc = {}; + StdVideoH264LevelIdc maxLevelIdc = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264SessionCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264SessionCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264SessionParametersAddInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersAddInfoKHR.html + struct VideoEncodeH264SessionParametersAddInfoKHR + { + using NativeType = VkVideoEncodeH264SessionParametersAddInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersAddInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersAddInfoKHR( uint32_t stdSPSCount_ = {}, + const StdVideoH264SequenceParameterSet * pStdSPSs_ = {}, + uint32_t stdPPSCount_ = {}, + const StdVideoH264PictureParameterSet * pStdPPSs_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stdSPSCount{ stdSPSCount_ } + , pStdSPSs{ pStdSPSs_ } + , stdPPSCount{ stdPPSCount_ } + , pStdPPSs{ pStdPPSs_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersAddInfoKHR( VideoEncodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264SessionParametersAddInfoKHR( VkVideoEncodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264SessionParametersAddInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH264SessionParametersAddInfoKHR( ArrayProxyNoTemporaries const & stdSPSs_, + ArrayProxyNoTemporaries const & stdPPSs_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , stdSPSCount( static_cast( stdSPSs_.size() ) ) + , pStdSPSs( stdSPSs_.data() ) + , stdPPSCount( static_cast( stdPPSs_.size() ) ) + , pStdPPSs( stdPPSs_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoEncodeH264SessionParametersAddInfoKHR & operator=( VideoEncodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264SessionParametersAddInfoKHR & operator=( VkVideoEncodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR & setStdSPSCount( uint32_t stdSPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + stdSPSCount = stdSPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR && setStdSPSCount( uint32_t stdSPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + stdSPSCount = stdSPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR & setPStdSPSs( const StdVideoH264SequenceParameterSet * pStdSPSs_ ) & VULKAN_HPP_NOEXCEPT + { + pStdSPSs = pStdSPSs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR && setPStdSPSs( const StdVideoH264SequenceParameterSet * pStdSPSs_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdSPSs = pStdSPSs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH264SessionParametersAddInfoKHR & + setStdSPSs( ArrayProxyNoTemporaries const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT + { + stdSPSCount = static_cast( stdSPSs_.size() ); + pStdSPSs = stdSPSs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR & setStdPPSCount( uint32_t stdPPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + stdPPSCount = stdPPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR && setStdPPSCount( uint32_t stdPPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + stdPPSCount = stdPPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR & setPStdPPSs( const StdVideoH264PictureParameterSet * pStdPPSs_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPPSs = pStdPPSs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR && setPStdPPSs( const StdVideoH264PictureParameterSet * pStdPPSs_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdPPSs = pStdPPSs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH264SessionParametersAddInfoKHR & + setStdPPSs( ArrayProxyNoTemporaries const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT + { + stdPPSCount = static_cast( stdPPSs_.size() ); + pStdPPSs = stdPPSs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264SessionParametersAddInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersAddInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersAddInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersAddInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264SessionParametersAddInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && + ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs ); +# endif + } + + bool operator!=( VideoEncodeH264SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264SessionParametersAddInfoKHR; + const void * pNext = {}; + uint32_t stdSPSCount = {}; + const StdVideoH264SequenceParameterSet * pStdSPSs = {}; + uint32_t stdPPSCount = {}; + const StdVideoH264PictureParameterSet * pStdPPSs = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264SessionParametersAddInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264SessionParametersAddInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264SessionParametersCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersCreateInfoKHR.html + struct VideoEncodeH264SessionParametersCreateInfoKHR + { + using NativeType = VkVideoEncodeH264SessionParametersCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersCreateInfoKHR( uint32_t maxStdSPSCount_ = {}, + uint32_t maxStdPPSCount_ = {}, + const VideoEncodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxStdSPSCount{ maxStdSPSCount_ } + , maxStdPPSCount{ maxStdPPSCount_ } + , pParametersAddInfo{ pParametersAddInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR + VideoEncodeH264SessionParametersCreateInfoKHR( VideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264SessionParametersCreateInfoKHR( VkVideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264SessionParametersCreateInfoKHR & operator=( VideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264SessionParametersCreateInfoKHR & operator=( VkVideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxStdSPSCount = maxStdSPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR && setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxStdSPSCount = maxStdSPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxStdPPSCount = maxStdPPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR && setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxStdPPSCount = maxStdPPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR & + setPParametersAddInfo( const VideoEncodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pParametersAddInfo = pParametersAddInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR && + setPParametersAddInfo( const VideoEncodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pParametersAddInfo = pParametersAddInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264SessionParametersCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && ( maxStdPPSCount == rhs.maxStdPPSCount ) && + ( pParametersAddInfo == rhs.pParametersAddInfo ); +# endif + } + + bool operator!=( VideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264SessionParametersCreateInfoKHR; + const void * pNext = {}; + uint32_t maxStdSPSCount = {}; + uint32_t maxStdPPSCount = {}; + const VideoEncodeH264SessionParametersAddInfoKHR * pParametersAddInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264SessionParametersCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264SessionParametersCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersFeedbackInfoKHR.html + struct VideoEncodeH264SessionParametersFeedbackInfoKHR + { + using NativeType = VkVideoEncodeH264SessionParametersFeedbackInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersFeedbackInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersFeedbackInfoKHR( Bool32 hasStdSPSOverrides_ = {}, + Bool32 hasStdPPSOverrides_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , hasStdSPSOverrides{ hasStdSPSOverrides_ } + , hasStdPPSOverrides{ hasStdPPSOverrides_ } + { + } + + VULKAN_HPP_CONSTEXPR + VideoEncodeH264SessionParametersFeedbackInfoKHR( VideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264SessionParametersFeedbackInfoKHR( VkVideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264SessionParametersFeedbackInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264SessionParametersFeedbackInfoKHR & operator=( VideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264SessionParametersFeedbackInfoKHR & operator=( VkVideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeH264SessionParametersFeedbackInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersFeedbackInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersFeedbackInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersFeedbackInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hasStdSPSOverrides, hasStdPPSOverrides ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264SessionParametersFeedbackInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasStdSPSOverrides == rhs.hasStdSPSOverrides ) && + ( hasStdPPSOverrides == rhs.hasStdPPSOverrides ); +# endif + } + + bool operator!=( VideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264SessionParametersFeedbackInfoKHR; + void * pNext = {}; + Bool32 hasStdSPSOverrides = {}; + Bool32 hasStdPPSOverrides = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264SessionParametersFeedbackInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264SessionParametersFeedbackInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH264SessionParametersGetInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersGetInfoKHR.html + struct VideoEncodeH264SessionParametersGetInfoKHR + { + using NativeType = VkVideoEncodeH264SessionParametersGetInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersGetInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersGetInfoKHR( + Bool32 writeStdSPS_ = {}, Bool32 writeStdPPS_ = {}, uint32_t stdSPSId_ = {}, uint32_t stdPPSId_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , writeStdSPS{ writeStdSPS_ } + , writeStdPPS{ writeStdPPS_ } + , stdSPSId{ stdSPSId_ } + , stdPPSId{ stdPPSId_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersGetInfoKHR( VideoEncodeH264SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH264SessionParametersGetInfoKHR( VkVideoEncodeH264SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH264SessionParametersGetInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH264SessionParametersGetInfoKHR & operator=( VideoEncodeH264SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH264SessionParametersGetInfoKHR & operator=( VkVideoEncodeH264SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR & setWriteStdSPS( Bool32 writeStdSPS_ ) & VULKAN_HPP_NOEXCEPT + { + writeStdSPS = writeStdSPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR && setWriteStdSPS( Bool32 writeStdSPS_ ) && VULKAN_HPP_NOEXCEPT + { + writeStdSPS = writeStdSPS_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR & setWriteStdPPS( Bool32 writeStdPPS_ ) & VULKAN_HPP_NOEXCEPT + { + writeStdPPS = writeStdPPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR && setWriteStdPPS( Bool32 writeStdPPS_ ) && VULKAN_HPP_NOEXCEPT + { + writeStdPPS = writeStdPPS_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR & setStdSPSId( uint32_t stdSPSId_ ) & VULKAN_HPP_NOEXCEPT + { + stdSPSId = stdSPSId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR && setStdSPSId( uint32_t stdSPSId_ ) && VULKAN_HPP_NOEXCEPT + { + stdSPSId = stdSPSId_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR & setStdPPSId( uint32_t stdPPSId_ ) & VULKAN_HPP_NOEXCEPT + { + stdPPSId = stdPPSId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR && setStdPPSId( uint32_t stdPPSId_ ) && VULKAN_HPP_NOEXCEPT + { + stdPPSId = stdPPSId_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH264SessionParametersGetInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersGetInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersGetInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH264SessionParametersGetInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, writeStdSPS, writeStdPPS, stdSPSId, stdPPSId ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH264SessionParametersGetInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH264SessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( writeStdSPS == rhs.writeStdSPS ) && ( writeStdPPS == rhs.writeStdPPS ) && + ( stdSPSId == rhs.stdSPSId ) && ( stdPPSId == rhs.stdPPSId ); +# endif + } + + bool operator!=( VideoEncodeH264SessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH264SessionParametersGetInfoKHR; + const void * pNext = {}; + Bool32 writeStdSPS = {}; + Bool32 writeStdPPS = {}; + uint32_t stdSPSId = {}; + uint32_t stdPPSId = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH264SessionParametersGetInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH264SessionParametersGetInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265CapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilitiesKHR.html + struct VideoEncodeH265CapabilitiesKHR + { + using NativeType = VkVideoEncodeH265CapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265CapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesKHR( VideoEncodeH265CapabilityFlagsKHR flags_ = {}, + StdVideoH265LevelIdc maxLevelIdc_ = {}, + uint32_t maxSliceSegmentCount_ = {}, + Extent2D maxTiles_ = {}, + VideoEncodeH265CtbSizeFlagsKHR ctbSizes_ = {}, + VideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes_ = {}, + uint32_t maxPPictureL0ReferenceCount_ = {}, + uint32_t maxBPictureL0ReferenceCount_ = {}, + uint32_t maxL1ReferenceCount_ = {}, + uint32_t maxSubLayerCount_ = {}, + Bool32 expectDyadicTemporalSubLayerPattern_ = {}, + int32_t minQp_ = {}, + int32_t maxQp_ = {}, + Bool32 prefersGopRemainingFrames_ = {}, + Bool32 requiresGopRemainingFrames_ = {}, + VideoEncodeH265StdFlagsKHR stdSyntaxFlags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , maxLevelIdc{ maxLevelIdc_ } + , maxSliceSegmentCount{ maxSliceSegmentCount_ } + , maxTiles{ maxTiles_ } + , ctbSizes{ ctbSizes_ } + , transformBlockSizes{ transformBlockSizes_ } + , maxPPictureL0ReferenceCount{ maxPPictureL0ReferenceCount_ } + , maxBPictureL0ReferenceCount{ maxBPictureL0ReferenceCount_ } + , maxL1ReferenceCount{ maxL1ReferenceCount_ } + , maxSubLayerCount{ maxSubLayerCount_ } + , expectDyadicTemporalSubLayerPattern{ expectDyadicTemporalSubLayerPattern_ } + , minQp{ minQp_ } + , maxQp{ maxQp_ } + , prefersGopRemainingFrames{ prefersGopRemainingFrames_ } + , requiresGopRemainingFrames{ requiresGopRemainingFrames_ } + , stdSyntaxFlags{ stdSyntaxFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesKHR( VideoEncodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265CapabilitiesKHR( VkVideoEncodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265CapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265CapabilitiesKHR & operator=( VideoEncodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265CapabilitiesKHR & operator=( VkVideoEncodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeH265CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + maxLevelIdc, + maxSliceSegmentCount, + maxTiles, + ctbSizes, + transformBlockSizes, + maxPPictureL0ReferenceCount, + maxBPictureL0ReferenceCount, + maxL1ReferenceCount, + maxSubLayerCount, + expectDyadicTemporalSubLayerPattern, + minQp, + maxQp, + prefersGopRemainingFrames, + requiresGopRemainingFrames, + stdSyntaxFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoEncodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = maxSliceSegmentCount <=> rhs.maxSliceSegmentCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxTiles <=> rhs.maxTiles; cmp != 0 ) + return cmp; + if ( auto cmp = ctbSizes <=> rhs.ctbSizes; cmp != 0 ) + return cmp; + if ( auto cmp = transformBlockSizes <=> rhs.transformBlockSizes; cmp != 0 ) + return cmp; + if ( auto cmp = maxPPictureL0ReferenceCount <=> rhs.maxPPictureL0ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxBPictureL0ReferenceCount <=> rhs.maxBPictureL0ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxL1ReferenceCount <=> rhs.maxL1ReferenceCount; cmp != 0 ) + return cmp; + if ( auto cmp = maxSubLayerCount <=> rhs.maxSubLayerCount; cmp != 0 ) + return cmp; + if ( auto cmp = expectDyadicTemporalSubLayerPattern <=> rhs.expectDyadicTemporalSubLayerPattern; cmp != 0 ) + return cmp; + if ( auto cmp = minQp <=> rhs.minQp; cmp != 0 ) + return cmp; + if ( auto cmp = maxQp <=> rhs.maxQp; cmp != 0 ) + return cmp; + if ( auto cmp = prefersGopRemainingFrames <=> rhs.prefersGopRemainingFrames; cmp != 0 ) + return cmp; + if ( auto cmp = requiresGopRemainingFrames <=> rhs.requiresGopRemainingFrames; cmp != 0 ) + return cmp; + if ( auto cmp = stdSyntaxFlags <=> rhs.stdSyntaxFlags; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoEncodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ) == 0 ) && ( maxSliceSegmentCount == rhs.maxSliceSegmentCount ) && + ( maxTiles == rhs.maxTiles ) && ( ctbSizes == rhs.ctbSizes ) && ( transformBlockSizes == rhs.transformBlockSizes ) && + ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) && ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) && + ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) && ( maxSubLayerCount == rhs.maxSubLayerCount ) && + ( expectDyadicTemporalSubLayerPattern == rhs.expectDyadicTemporalSubLayerPattern ) && ( minQp == rhs.minQp ) && ( maxQp == rhs.maxQp ) && + ( prefersGopRemainingFrames == rhs.prefersGopRemainingFrames ) && ( requiresGopRemainingFrames == rhs.requiresGopRemainingFrames ) && + ( stdSyntaxFlags == rhs.stdSyntaxFlags ); + } + + bool operator!=( VideoEncodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoEncodeH265CapabilitiesKHR; + void * pNext = {}; + VideoEncodeH265CapabilityFlagsKHR flags = {}; + StdVideoH265LevelIdc maxLevelIdc = {}; + uint32_t maxSliceSegmentCount = {}; + Extent2D maxTiles = {}; + VideoEncodeH265CtbSizeFlagsKHR ctbSizes = {}; + VideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes = {}; + uint32_t maxPPictureL0ReferenceCount = {}; + uint32_t maxBPictureL0ReferenceCount = {}; + uint32_t maxL1ReferenceCount = {}; + uint32_t maxSubLayerCount = {}; + Bool32 expectDyadicTemporalSubLayerPattern = {}; + int32_t minQp = {}; + int32_t maxQp = {}; + Bool32 prefersGopRemainingFrames = {}; + Bool32 requiresGopRemainingFrames = {}; + VideoEncodeH265StdFlagsKHR stdSyntaxFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265CapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265CapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265DpbSlotInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265DpbSlotInfoKHR.html + struct VideoEncodeH265DpbSlotInfoKHR + { + using NativeType = VkVideoEncodeH265DpbSlotInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265DpbSlotInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265DpbSlotInfoKHR( const StdVideoEncodeH265ReferenceInfo * pStdReferenceInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , pStdReferenceInfo{ pStdReferenceInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265DpbSlotInfoKHR( VideoEncodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265DpbSlotInfoKHR( VkVideoEncodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265DpbSlotInfoKHR & operator=( VideoEncodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265DpbSlotInfoKHR & operator=( VkVideoEncodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoEncodeH265ReferenceInfo * pStdReferenceInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoEncodeH265ReferenceInfo * pStdReferenceInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdReferenceInfo = pStdReferenceInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, pStdReferenceInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265DpbSlotInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); +# endif + } + + bool operator!=( VideoEncodeH265DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265DpbSlotInfoKHR; + const void * pNext = {}; + const StdVideoEncodeH265ReferenceInfo * pStdReferenceInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265DpbSlotInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265DpbSlotInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265FrameSizeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265FrameSizeKHR.html + struct VideoEncodeH265FrameSizeKHR + { + using NativeType = VkVideoEncodeH265FrameSizeKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265FrameSizeKHR( uint32_t frameISize_ = {}, uint32_t framePSize_ = {}, uint32_t frameBSize_ = {} ) VULKAN_HPP_NOEXCEPT + : frameISize{ frameISize_ } + , framePSize{ framePSize_ } + , frameBSize{ frameBSize_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265FrameSizeKHR( VideoEncodeH265FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265FrameSizeKHR( VkVideoEncodeH265FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265FrameSizeKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265FrameSizeKHR & operator=( VideoEncodeH265FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265FrameSizeKHR & operator=( VkVideoEncodeH265FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR & setFrameISize( uint32_t frameISize_ ) & VULKAN_HPP_NOEXCEPT + { + frameISize = frameISize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR && setFrameISize( uint32_t frameISize_ ) && VULKAN_HPP_NOEXCEPT + { + frameISize = frameISize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR & setFramePSize( uint32_t framePSize_ ) & VULKAN_HPP_NOEXCEPT + { + framePSize = framePSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR && setFramePSize( uint32_t framePSize_ ) && VULKAN_HPP_NOEXCEPT + { + framePSize = framePSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR & setFrameBSize( uint32_t frameBSize_ ) & VULKAN_HPP_NOEXCEPT + { + frameBSize = frameBSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR && setFrameBSize( uint32_t frameBSize_ ) && VULKAN_HPP_NOEXCEPT + { + frameBSize = frameBSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265FrameSizeKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265FrameSizeKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265FrameSizeKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265FrameSizeKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( frameISize, framePSize, frameBSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265FrameSizeKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize ); +# endif + } + + bool operator!=( VideoEncodeH265FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + uint32_t frameISize = {}; + uint32_t framePSize = {}; + uint32_t frameBSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265FrameSizeKHR; + }; +#endif + + // wrapper struct for struct VkVideoEncodeH265GopRemainingFrameInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265GopRemainingFrameInfoKHR.html + struct VideoEncodeH265GopRemainingFrameInfoKHR + { + using NativeType = VkVideoEncodeH265GopRemainingFrameInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265GopRemainingFrameInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265GopRemainingFrameInfoKHR( Bool32 useGopRemainingFrames_ = {}, + uint32_t gopRemainingI_ = {}, + uint32_t gopRemainingP_ = {}, + uint32_t gopRemainingB_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , useGopRemainingFrames{ useGopRemainingFrames_ } + , gopRemainingI{ gopRemainingI_ } + , gopRemainingP{ gopRemainingP_ } + , gopRemainingB{ gopRemainingB_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265GopRemainingFrameInfoKHR( VideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265GopRemainingFrameInfoKHR( VkVideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265GopRemainingFrameInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265GopRemainingFrameInfoKHR & operator=( VideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265GopRemainingFrameInfoKHR & operator=( VkVideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR & setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) & VULKAN_HPP_NOEXCEPT + { + useGopRemainingFrames = useGopRemainingFrames_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR && setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) && VULKAN_HPP_NOEXCEPT + { + useGopRemainingFrames = useGopRemainingFrames_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR & setGopRemainingI( uint32_t gopRemainingI_ ) & VULKAN_HPP_NOEXCEPT + { + gopRemainingI = gopRemainingI_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR && setGopRemainingI( uint32_t gopRemainingI_ ) && VULKAN_HPP_NOEXCEPT + { + gopRemainingI = gopRemainingI_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR & setGopRemainingP( uint32_t gopRemainingP_ ) & VULKAN_HPP_NOEXCEPT + { + gopRemainingP = gopRemainingP_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR && setGopRemainingP( uint32_t gopRemainingP_ ) && VULKAN_HPP_NOEXCEPT + { + gopRemainingP = gopRemainingP_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR & setGopRemainingB( uint32_t gopRemainingB_ ) & VULKAN_HPP_NOEXCEPT + { + gopRemainingB = gopRemainingB_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR && setGopRemainingB( uint32_t gopRemainingB_ ) && VULKAN_HPP_NOEXCEPT + { + gopRemainingB = gopRemainingB_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265GopRemainingFrameInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265GopRemainingFrameInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265GopRemainingFrameInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265GopRemainingFrameInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, useGopRemainingFrames, gopRemainingI, gopRemainingP, gopRemainingB ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265GopRemainingFrameInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) && + ( gopRemainingI == rhs.gopRemainingI ) && ( gopRemainingP == rhs.gopRemainingP ) && ( gopRemainingB == rhs.gopRemainingB ); +# endif + } + + bool operator!=( VideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265GopRemainingFrameInfoKHR; + const void * pNext = {}; + Bool32 useGopRemainingFrames = {}; + uint32_t gopRemainingI = {}; + uint32_t gopRemainingP = {}; + uint32_t gopRemainingB = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265GopRemainingFrameInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265GopRemainingFrameInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265NaluSliceSegmentInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265NaluSliceSegmentInfoKHR.html + struct VideoEncodeH265NaluSliceSegmentInfoKHR + { + using NativeType = VkVideoEncodeH265NaluSliceSegmentInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoKHR( int32_t constantQp_ = {}, + const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , constantQp{ constantQp_ } + , pStdSliceSegmentHeader{ pStdSliceSegmentHeader_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoKHR( VideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265NaluSliceSegmentInfoKHR( VkVideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265NaluSliceSegmentInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265NaluSliceSegmentInfoKHR & operator=( VideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265NaluSliceSegmentInfoKHR & operator=( VkVideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR & setConstantQp( int32_t constantQp_ ) & VULKAN_HPP_NOEXCEPT + { + constantQp = constantQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR && setConstantQp( int32_t constantQp_ ) && VULKAN_HPP_NOEXCEPT + { + constantQp = constantQp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR & + setPStdSliceSegmentHeader( const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ ) & + VULKAN_HPP_NOEXCEPT + { + pStdSliceSegmentHeader = pStdSliceSegmentHeader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR && + setPStdSliceSegmentHeader( const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdSliceSegmentHeader = pStdSliceSegmentHeader_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265NaluSliceSegmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265NaluSliceSegmentInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265NaluSliceSegmentInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265NaluSliceSegmentInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, constantQp, pStdSliceSegmentHeader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265NaluSliceSegmentInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantQp == rhs.constantQp ) && ( pStdSliceSegmentHeader == rhs.pStdSliceSegmentHeader ); +# endif + } + + bool operator!=( VideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoKHR; + const void * pNext = {}; + int32_t constantQp = {}; + const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265NaluSliceSegmentInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265NaluSliceSegmentInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265PictureInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265PictureInfoKHR.html + struct VideoEncodeH265PictureInfoKHR + { + using NativeType = VkVideoEncodeH265PictureInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265PictureInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265PictureInfoKHR( uint32_t naluSliceSegmentEntryCount_ = {}, + const VideoEncodeH265NaluSliceSegmentInfoKHR * pNaluSliceSegmentEntries_ = {}, + const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , naluSliceSegmentEntryCount{ naluSliceSegmentEntryCount_ } + , pNaluSliceSegmentEntries{ pNaluSliceSegmentEntries_ } + , pStdPictureInfo{ pStdPictureInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265PictureInfoKHR( VideoEncodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265PictureInfoKHR( VkVideoEncodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265PictureInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH265PictureInfoKHR( ArrayProxyNoTemporaries const & naluSliceSegmentEntries_, + const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , naluSliceSegmentEntryCount( static_cast( naluSliceSegmentEntries_.size() ) ) + , pNaluSliceSegmentEntries( naluSliceSegmentEntries_.data() ) + , pStdPictureInfo( pStdPictureInfo_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoEncodeH265PictureInfoKHR & operator=( VideoEncodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265PictureInfoKHR & operator=( VkVideoEncodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR & setNaluSliceSegmentEntryCount( uint32_t naluSliceSegmentEntryCount_ ) & VULKAN_HPP_NOEXCEPT + { + naluSliceSegmentEntryCount = naluSliceSegmentEntryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR && setNaluSliceSegmentEntryCount( uint32_t naluSliceSegmentEntryCount_ ) && VULKAN_HPP_NOEXCEPT + { + naluSliceSegmentEntryCount = naluSliceSegmentEntryCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR & + setPNaluSliceSegmentEntries( const VideoEncodeH265NaluSliceSegmentInfoKHR * pNaluSliceSegmentEntries_ ) & + VULKAN_HPP_NOEXCEPT + { + pNaluSliceSegmentEntries = pNaluSliceSegmentEntries_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR && + setPNaluSliceSegmentEntries( const VideoEncodeH265NaluSliceSegmentInfoKHR * pNaluSliceSegmentEntries_ ) && + VULKAN_HPP_NOEXCEPT + { + pNaluSliceSegmentEntries = pNaluSliceSegmentEntries_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH265PictureInfoKHR & + setNaluSliceSegmentEntries( ArrayProxyNoTemporaries const & naluSliceSegmentEntries_ ) VULKAN_HPP_NOEXCEPT + { + naluSliceSegmentEntryCount = static_cast( naluSliceSegmentEntries_.size() ); + pNaluSliceSegmentEntries = naluSliceSegmentEntries_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR & setPStdPictureInfo( const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR && setPStdPictureInfo( const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT + { + pStdPictureInfo = pStdPictureInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265PictureInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265PictureInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, naluSliceSegmentEntryCount, pNaluSliceSegmentEntries, pStdPictureInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265PictureInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( naluSliceSegmentEntryCount == rhs.naluSliceSegmentEntryCount ) && + ( pNaluSliceSegmentEntries == rhs.pNaluSliceSegmentEntries ) && ( pStdPictureInfo == rhs.pStdPictureInfo ); +# endif + } + + bool operator!=( VideoEncodeH265PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265PictureInfoKHR; + const void * pNext = {}; + uint32_t naluSliceSegmentEntryCount = {}; + const VideoEncodeH265NaluSliceSegmentInfoKHR * pNaluSliceSegmentEntries = {}; + const StdVideoEncodeH265PictureInfo * pStdPictureInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265PictureInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265PictureInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265ProfileInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265ProfileInfoKHR.html + struct VideoEncodeH265ProfileInfoKHR + { + using NativeType = VkVideoEncodeH265ProfileInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265ProfileInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoKHR( StdVideoH265ProfileIdc stdProfileIdc_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stdProfileIdc{ stdProfileIdc_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoKHR( VideoEncodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265ProfileInfoKHR( VkVideoEncodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265ProfileInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265ProfileInfoKHR & operator=( VideoEncodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265ProfileInfoKHR & operator=( VkVideoEncodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoKHR & setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) & VULKAN_HPP_NOEXCEPT + { + stdProfileIdc = stdProfileIdc_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoKHR && setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) && VULKAN_HPP_NOEXCEPT + { + stdProfileIdc = stdProfileIdc_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdProfileIdc ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoEncodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoEncodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); + } + + bool operator!=( VideoEncodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoEncodeH265ProfileInfoKHR; + const void * pNext = {}; + StdVideoH265ProfileIdc stdProfileIdc = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265ProfileInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265ProfileInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265QpKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265QpKHR.html + struct VideoEncodeH265QpKHR + { + using NativeType = VkVideoEncodeH265QpKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265QpKHR( int32_t qpI_ = {}, int32_t qpP_ = {}, int32_t qpB_ = {} ) VULKAN_HPP_NOEXCEPT + : qpI{ qpI_ } + , qpP{ qpP_ } + , qpB{ qpB_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265QpKHR( VideoEncodeH265QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265QpKHR( VkVideoEncodeH265QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265QpKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265QpKHR & operator=( VideoEncodeH265QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265QpKHR & operator=( VkVideoEncodeH265QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR & setQpI( int32_t qpI_ ) & VULKAN_HPP_NOEXCEPT + { + qpI = qpI_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR && setQpI( int32_t qpI_ ) && VULKAN_HPP_NOEXCEPT + { + qpI = qpI_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR & setQpP( int32_t qpP_ ) & VULKAN_HPP_NOEXCEPT + { + qpP = qpP_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR && setQpP( int32_t qpP_ ) && VULKAN_HPP_NOEXCEPT + { + qpP = qpP_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR & setQpB( int32_t qpB_ ) & VULKAN_HPP_NOEXCEPT + { + qpB = qpB_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR && setQpB( int32_t qpB_ ) && VULKAN_HPP_NOEXCEPT + { + qpB = qpB_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265QpKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265QpKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265QpKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265QpKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( qpI, qpP, qpB ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265QpKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265QpKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); +# endif + } + + bool operator!=( VideoEncodeH265QpKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + int32_t qpI = {}; + int32_t qpP = {}; + int32_t qpB = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265QpKHR; + }; +#endif + + // wrapper struct for struct VkVideoEncodeH265QualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265QualityLevelPropertiesKHR.html + struct VideoEncodeH265QualityLevelPropertiesKHR + { + using NativeType = VkVideoEncodeH265QualityLevelPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265QualityLevelPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265QualityLevelPropertiesKHR( VideoEncodeH265RateControlFlagsKHR preferredRateControlFlags_ = {}, + uint32_t preferredGopFrameCount_ = {}, + uint32_t preferredIdrPeriod_ = {}, + uint32_t preferredConsecutiveBFrameCount_ = {}, + uint32_t preferredSubLayerCount_ = {}, + VideoEncodeH265QpKHR preferredConstantQp_ = {}, + uint32_t preferredMaxL0ReferenceCount_ = {}, + uint32_t preferredMaxL1ReferenceCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , preferredRateControlFlags{ preferredRateControlFlags_ } + , preferredGopFrameCount{ preferredGopFrameCount_ } + , preferredIdrPeriod{ preferredIdrPeriod_ } + , preferredConsecutiveBFrameCount{ preferredConsecutiveBFrameCount_ } + , preferredSubLayerCount{ preferredSubLayerCount_ } + , preferredConstantQp{ preferredConstantQp_ } + , preferredMaxL0ReferenceCount{ preferredMaxL0ReferenceCount_ } + , preferredMaxL1ReferenceCount{ preferredMaxL1ReferenceCount_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265QualityLevelPropertiesKHR( VideoEncodeH265QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265QualityLevelPropertiesKHR( VkVideoEncodeH265QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265QualityLevelPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265QualityLevelPropertiesKHR & operator=( VideoEncodeH265QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265QualityLevelPropertiesKHR & operator=( VkVideoEncodeH265QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeH265QualityLevelPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265QualityLevelPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265QualityLevelPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265QualityLevelPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + preferredRateControlFlags, + preferredGopFrameCount, + preferredIdrPeriod, + preferredConsecutiveBFrameCount, + preferredSubLayerCount, + preferredConstantQp, + preferredMaxL0ReferenceCount, + preferredMaxL1ReferenceCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265QualityLevelPropertiesKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) && + ( preferredGopFrameCount == rhs.preferredGopFrameCount ) && ( preferredIdrPeriod == rhs.preferredIdrPeriod ) && + ( preferredConsecutiveBFrameCount == rhs.preferredConsecutiveBFrameCount ) && ( preferredSubLayerCount == rhs.preferredSubLayerCount ) && + ( preferredConstantQp == rhs.preferredConstantQp ) && ( preferredMaxL0ReferenceCount == rhs.preferredMaxL0ReferenceCount ) && + ( preferredMaxL1ReferenceCount == rhs.preferredMaxL1ReferenceCount ); +# endif + } + + bool operator!=( VideoEncodeH265QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265QualityLevelPropertiesKHR; + void * pNext = {}; + VideoEncodeH265RateControlFlagsKHR preferredRateControlFlags = {}; + uint32_t preferredGopFrameCount = {}; + uint32_t preferredIdrPeriod = {}; + uint32_t preferredConsecutiveBFrameCount = {}; + uint32_t preferredSubLayerCount = {}; + VideoEncodeH265QpKHR preferredConstantQp = {}; + uint32_t preferredMaxL0ReferenceCount = {}; + uint32_t preferredMaxL1ReferenceCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265QualityLevelPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265QualityLevelPropertiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265QuantizationMapCapabilitiesKHR.html + struct VideoEncodeH265QuantizationMapCapabilitiesKHR + { + using NativeType = VkVideoEncodeH265QuantizationMapCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265QuantizationMapCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoEncodeH265QuantizationMapCapabilitiesKHR( int32_t minQpDelta_ = {}, int32_t maxQpDelta_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , minQpDelta{ minQpDelta_ } + , maxQpDelta{ maxQpDelta_ } + { + } + + VULKAN_HPP_CONSTEXPR + VideoEncodeH265QuantizationMapCapabilitiesKHR( VideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265QuantizationMapCapabilitiesKHR( VkVideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265QuantizationMapCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265QuantizationMapCapabilitiesKHR & operator=( VideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265QuantizationMapCapabilitiesKHR & operator=( VkVideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeH265QuantizationMapCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265QuantizationMapCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265QuantizationMapCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265QuantizationMapCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, minQpDelta, maxQpDelta ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265QuantizationMapCapabilitiesKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minQpDelta == rhs.minQpDelta ) && ( maxQpDelta == rhs.maxQpDelta ); +# endif + } + + bool operator!=( VideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265QuantizationMapCapabilitiesKHR; + void * pNext = {}; + int32_t minQpDelta = {}; + int32_t maxQpDelta = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265QuantizationMapCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265QuantizationMapCapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265RateControlInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlInfoKHR.html + struct VideoEncodeH265RateControlInfoKHR + { + using NativeType = VkVideoEncodeH265RateControlInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoKHR( VideoEncodeH265RateControlFlagsKHR flags_ = {}, + uint32_t gopFrameCount_ = {}, + uint32_t idrPeriod_ = {}, + uint32_t consecutiveBFrameCount_ = {}, + uint32_t subLayerCount_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , gopFrameCount{ gopFrameCount_ } + , idrPeriod{ idrPeriod_ } + , consecutiveBFrameCount{ consecutiveBFrameCount_ } + , subLayerCount{ subLayerCount_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoKHR( VideoEncodeH265RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265RateControlInfoKHR( VkVideoEncodeH265RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265RateControlInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265RateControlInfoKHR & operator=( VideoEncodeH265RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265RateControlInfoKHR & operator=( VkVideoEncodeH265RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setFlags( VideoEncodeH265RateControlFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setFlags( VideoEncodeH265RateControlFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setGopFrameCount( uint32_t gopFrameCount_ ) & VULKAN_HPP_NOEXCEPT + { + gopFrameCount = gopFrameCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setGopFrameCount( uint32_t gopFrameCount_ ) && VULKAN_HPP_NOEXCEPT + { + gopFrameCount = gopFrameCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setIdrPeriod( uint32_t idrPeriod_ ) & VULKAN_HPP_NOEXCEPT + { + idrPeriod = idrPeriod_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setIdrPeriod( uint32_t idrPeriod_ ) && VULKAN_HPP_NOEXCEPT + { + idrPeriod = idrPeriod_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) & VULKAN_HPP_NOEXCEPT + { + consecutiveBFrameCount = consecutiveBFrameCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) && VULKAN_HPP_NOEXCEPT + { + consecutiveBFrameCount = consecutiveBFrameCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setSubLayerCount( uint32_t subLayerCount_ ) & VULKAN_HPP_NOEXCEPT + { + subLayerCount = subLayerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setSubLayerCount( uint32_t subLayerCount_ ) && VULKAN_HPP_NOEXCEPT + { + subLayerCount = subLayerCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265RateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265RateControlInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265RateControlInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265RateControlInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, gopFrameCount, idrPeriod, consecutiveBFrameCount, subLayerCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265RateControlInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) && + ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( subLayerCount == rhs.subLayerCount ); +# endif + } + + bool operator!=( VideoEncodeH265RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265RateControlInfoKHR; + const void * pNext = {}; + VideoEncodeH265RateControlFlagsKHR flags = {}; + uint32_t gopFrameCount = {}; + uint32_t idrPeriod = {}; + uint32_t consecutiveBFrameCount = {}; + uint32_t subLayerCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265RateControlInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265RateControlInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265RateControlLayerInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlLayerInfoKHR.html + struct VideoEncodeH265RateControlLayerInfoKHR + { + using NativeType = VkVideoEncodeH265RateControlLayerInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlLayerInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoKHR( Bool32 useMinQp_ = {}, + VideoEncodeH265QpKHR minQp_ = {}, + Bool32 useMaxQp_ = {}, + VideoEncodeH265QpKHR maxQp_ = {}, + Bool32 useMaxFrameSize_ = {}, + VideoEncodeH265FrameSizeKHR maxFrameSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , useMinQp{ useMinQp_ } + , minQp{ minQp_ } + , useMaxQp{ useMaxQp_ } + , maxQp{ maxQp_ } + , useMaxFrameSize{ useMaxFrameSize_ } + , maxFrameSize{ maxFrameSize_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoKHR( VideoEncodeH265RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265RateControlLayerInfoKHR( VkVideoEncodeH265RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265RateControlLayerInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265RateControlLayerInfoKHR & operator=( VideoEncodeH265RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265RateControlLayerInfoKHR & operator=( VkVideoEncodeH265RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setUseMinQp( Bool32 useMinQp_ ) & VULKAN_HPP_NOEXCEPT + { + useMinQp = useMinQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setUseMinQp( Bool32 useMinQp_ ) && VULKAN_HPP_NOEXCEPT + { + useMinQp = useMinQp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setMinQp( VideoEncodeH265QpKHR const & minQp_ ) & VULKAN_HPP_NOEXCEPT + { + minQp = minQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setMinQp( VideoEncodeH265QpKHR const & minQp_ ) && VULKAN_HPP_NOEXCEPT + { + minQp = minQp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setUseMaxQp( Bool32 useMaxQp_ ) & VULKAN_HPP_NOEXCEPT + { + useMaxQp = useMaxQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setUseMaxQp( Bool32 useMaxQp_ ) && VULKAN_HPP_NOEXCEPT + { + useMaxQp = useMaxQp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setMaxQp( VideoEncodeH265QpKHR const & maxQp_ ) & VULKAN_HPP_NOEXCEPT + { + maxQp = maxQp_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setMaxQp( VideoEncodeH265QpKHR const & maxQp_ ) && VULKAN_HPP_NOEXCEPT + { + maxQp = maxQp_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) & VULKAN_HPP_NOEXCEPT + { + useMaxFrameSize = useMaxFrameSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) && VULKAN_HPP_NOEXCEPT + { + useMaxFrameSize = useMaxFrameSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setMaxFrameSize( VideoEncodeH265FrameSizeKHR const & maxFrameSize_ ) & VULKAN_HPP_NOEXCEPT + { + maxFrameSize = maxFrameSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setMaxFrameSize( VideoEncodeH265FrameSizeKHR const & maxFrameSize_ ) && + VULKAN_HPP_NOEXCEPT + { + maxFrameSize = maxFrameSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265RateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265RateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265RateControlLayerInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265RateControlLayerInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265RateControlLayerInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && + ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && ( maxFrameSize == rhs.maxFrameSize ); +# endif + } + + bool operator!=( VideoEncodeH265RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265RateControlLayerInfoKHR; + const void * pNext = {}; + Bool32 useMinQp = {}; + VideoEncodeH265QpKHR minQp = {}; + Bool32 useMaxQp = {}; + VideoEncodeH265QpKHR maxQp = {}; + Bool32 useMaxFrameSize = {}; + VideoEncodeH265FrameSizeKHR maxFrameSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265RateControlLayerInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265RateControlLayerInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265SessionCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionCreateInfoKHR.html + struct VideoEncodeH265SessionCreateInfoKHR + { + using NativeType = VkVideoEncodeH265SessionCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionCreateInfoKHR( Bool32 useMaxLevelIdc_ = {}, + StdVideoH265LevelIdc maxLevelIdc_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , useMaxLevelIdc{ useMaxLevelIdc_ } + , maxLevelIdc{ maxLevelIdc_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionCreateInfoKHR( VideoEncodeH265SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265SessionCreateInfoKHR( VkVideoEncodeH265SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265SessionCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265SessionCreateInfoKHR & operator=( VideoEncodeH265SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265SessionCreateInfoKHR & operator=( VkVideoEncodeH265SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR & setUseMaxLevelIdc( Bool32 useMaxLevelIdc_ ) & VULKAN_HPP_NOEXCEPT + { + useMaxLevelIdc = useMaxLevelIdc_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR && setUseMaxLevelIdc( Bool32 useMaxLevelIdc_ ) && VULKAN_HPP_NOEXCEPT + { + useMaxLevelIdc = useMaxLevelIdc_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR & setMaxLevelIdc( StdVideoH265LevelIdc maxLevelIdc_ ) & VULKAN_HPP_NOEXCEPT + { + maxLevelIdc = maxLevelIdc_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR && setMaxLevelIdc( StdVideoH265LevelIdc maxLevelIdc_ ) && VULKAN_HPP_NOEXCEPT + { + maxLevelIdc = maxLevelIdc_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265SessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, useMaxLevelIdc, maxLevelIdc ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( VideoEncodeH265SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = useMaxLevelIdc <=> rhs.useMaxLevelIdc; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( VideoEncodeH265SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevelIdc == rhs.useMaxLevelIdc ) && + ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ) == 0 ); + } + + bool operator!=( VideoEncodeH265SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eVideoEncodeH265SessionCreateInfoKHR; + const void * pNext = {}; + Bool32 useMaxLevelIdc = {}; + StdVideoH265LevelIdc maxLevelIdc = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265SessionCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265SessionCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265SessionParametersAddInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersAddInfoKHR.html + struct VideoEncodeH265SessionParametersAddInfoKHR + { + using NativeType = VkVideoEncodeH265SessionParametersAddInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersAddInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoKHR( uint32_t stdVPSCount_ = {}, + const StdVideoH265VideoParameterSet * pStdVPSs_ = {}, + uint32_t stdSPSCount_ = {}, + const StdVideoH265SequenceParameterSet * pStdSPSs_ = {}, + uint32_t stdPPSCount_ = {}, + const StdVideoH265PictureParameterSet * pStdPPSs_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , stdVPSCount{ stdVPSCount_ } + , pStdVPSs{ pStdVPSs_ } + , stdSPSCount{ stdSPSCount_ } + , pStdSPSs{ pStdSPSs_ } + , stdPPSCount{ stdPPSCount_ } + , pStdPPSs{ pStdPPSs_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoKHR( VideoEncodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265SessionParametersAddInfoKHR( VkVideoEncodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265SessionParametersAddInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH265SessionParametersAddInfoKHR( ArrayProxyNoTemporaries const & stdVPSs_, + ArrayProxyNoTemporaries const & stdSPSs_ = {}, + ArrayProxyNoTemporaries const & stdPPSs_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , stdVPSCount( static_cast( stdVPSs_.size() ) ) + , pStdVPSs( stdVPSs_.data() ) + , stdSPSCount( static_cast( stdSPSs_.size() ) ) + , pStdSPSs( stdSPSs_.data() ) + , stdPPSCount( static_cast( stdPPSs_.size() ) ) + , pStdPPSs( stdPPSs_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoEncodeH265SessionParametersAddInfoKHR & operator=( VideoEncodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265SessionParametersAddInfoKHR & operator=( VkVideoEncodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setStdVPSCount( uint32_t stdVPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + stdVPSCount = stdVPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setStdVPSCount( uint32_t stdVPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + stdVPSCount = stdVPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) & VULKAN_HPP_NOEXCEPT + { + pStdVPSs = pStdVPSs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) && VULKAN_HPP_NOEXCEPT + { + pStdVPSs = pStdVPSs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH265SessionParametersAddInfoKHR & setStdVPSs( ArrayProxyNoTemporaries const & stdVPSs_ ) VULKAN_HPP_NOEXCEPT + { + stdVPSCount = static_cast( stdVPSs_.size() ); + pStdVPSs = stdVPSs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setStdSPSCount( uint32_t stdSPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + stdSPSCount = stdSPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setStdSPSCount( uint32_t stdSPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + stdSPSCount = stdSPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) & VULKAN_HPP_NOEXCEPT + { + pStdSPSs = pStdSPSs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdSPSs = pStdSPSs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH265SessionParametersAddInfoKHR & + setStdSPSs( ArrayProxyNoTemporaries const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT + { + stdSPSCount = static_cast( stdSPSs_.size() ); + pStdSPSs = stdSPSs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setStdPPSCount( uint32_t stdPPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + stdPPSCount = stdPPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setStdPPSCount( uint32_t stdPPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + stdPPSCount = stdPPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) & VULKAN_HPP_NOEXCEPT + { + pStdPPSs = pStdPPSs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) && + VULKAN_HPP_NOEXCEPT + { + pStdPPSs = pStdPPSs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeH265SessionParametersAddInfoKHR & + setStdPPSs( ArrayProxyNoTemporaries const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT + { + stdPPSCount = static_cast( stdPPSs_.size() ); + pStdPPSs = stdPPSs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265SessionParametersAddInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersAddInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersAddInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersAddInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, stdVPSCount, pStdVPSs, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265SessionParametersAddInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdVPSCount == rhs.stdVPSCount ) && ( pStdVPSs == rhs.pStdVPSs ) && + ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs ); +# endif + } + + bool operator!=( VideoEncodeH265SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265SessionParametersAddInfoKHR; + const void * pNext = {}; + uint32_t stdVPSCount = {}; + const StdVideoH265VideoParameterSet * pStdVPSs = {}; + uint32_t stdSPSCount = {}; + const StdVideoH265SequenceParameterSet * pStdSPSs = {}; + uint32_t stdPPSCount = {}; + const StdVideoH265PictureParameterSet * pStdPPSs = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265SessionParametersAddInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265SessionParametersAddInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265SessionParametersCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersCreateInfoKHR.html + struct VideoEncodeH265SessionParametersCreateInfoKHR + { + using NativeType = VkVideoEncodeH265SessionParametersCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersCreateInfoKHR( uint32_t maxStdVPSCount_ = {}, + uint32_t maxStdSPSCount_ = {}, + uint32_t maxStdPPSCount_ = {}, + const VideoEncodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxStdVPSCount{ maxStdVPSCount_ } + , maxStdSPSCount{ maxStdSPSCount_ } + , maxStdPPSCount{ maxStdPPSCount_ } + , pParametersAddInfo{ pParametersAddInfo_ } + { + } + + VULKAN_HPP_CONSTEXPR + VideoEncodeH265SessionParametersCreateInfoKHR( VideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265SessionParametersCreateInfoKHR( VkVideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265SessionParametersCreateInfoKHR & operator=( VideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265SessionParametersCreateInfoKHR & operator=( VkVideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR & setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxStdVPSCount = maxStdVPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR && setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxStdVPSCount = maxStdVPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxStdSPSCount = maxStdSPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR && setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxStdSPSCount = maxStdSPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) & VULKAN_HPP_NOEXCEPT + { + maxStdPPSCount = maxStdPPSCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR && setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) && VULKAN_HPP_NOEXCEPT + { + maxStdPPSCount = maxStdPPSCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR & + setPParametersAddInfo( const VideoEncodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ ) & + VULKAN_HPP_NOEXCEPT + { + pParametersAddInfo = pParametersAddInfo_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR && + setPParametersAddInfo( const VideoEncodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ ) && + VULKAN_HPP_NOEXCEPT + { + pParametersAddInfo = pParametersAddInfo_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxStdVPSCount, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265SessionParametersCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdVPSCount == rhs.maxStdVPSCount ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && + ( maxStdPPSCount == rhs.maxStdPPSCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); +# endif + } + + bool operator!=( VideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265SessionParametersCreateInfoKHR; + const void * pNext = {}; + uint32_t maxStdVPSCount = {}; + uint32_t maxStdSPSCount = {}; + uint32_t maxStdPPSCount = {}; + const VideoEncodeH265SessionParametersAddInfoKHR * pParametersAddInfo = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265SessionParametersCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265SessionParametersCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersFeedbackInfoKHR.html + struct VideoEncodeH265SessionParametersFeedbackInfoKHR + { + using NativeType = VkVideoEncodeH265SessionParametersFeedbackInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersFeedbackInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersFeedbackInfoKHR( Bool32 hasStdVPSOverrides_ = {}, + Bool32 hasStdSPSOverrides_ = {}, + Bool32 hasStdPPSOverrides_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , hasStdVPSOverrides{ hasStdVPSOverrides_ } + , hasStdSPSOverrides{ hasStdSPSOverrides_ } + , hasStdPPSOverrides{ hasStdPPSOverrides_ } + { + } + + VULKAN_HPP_CONSTEXPR + VideoEncodeH265SessionParametersFeedbackInfoKHR( VideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265SessionParametersFeedbackInfoKHR( VkVideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265SessionParametersFeedbackInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265SessionParametersFeedbackInfoKHR & operator=( VideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265SessionParametersFeedbackInfoKHR & operator=( VkVideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeH265SessionParametersFeedbackInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersFeedbackInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersFeedbackInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersFeedbackInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hasStdVPSOverrides, hasStdSPSOverrides, hasStdPPSOverrides ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265SessionParametersFeedbackInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasStdVPSOverrides == rhs.hasStdVPSOverrides ) && + ( hasStdSPSOverrides == rhs.hasStdSPSOverrides ) && ( hasStdPPSOverrides == rhs.hasStdPPSOverrides ); +# endif + } + + bool operator!=( VideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265SessionParametersFeedbackInfoKHR; + void * pNext = {}; + Bool32 hasStdVPSOverrides = {}; + Bool32 hasStdSPSOverrides = {}; + Bool32 hasStdPPSOverrides = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265SessionParametersFeedbackInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265SessionParametersFeedbackInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeH265SessionParametersGetInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersGetInfoKHR.html + struct VideoEncodeH265SessionParametersGetInfoKHR + { + using NativeType = VkVideoEncodeH265SessionParametersGetInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersGetInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersGetInfoKHR( Bool32 writeStdVPS_ = {}, + Bool32 writeStdSPS_ = {}, + Bool32 writeStdPPS_ = {}, + uint32_t stdVPSId_ = {}, + uint32_t stdSPSId_ = {}, + uint32_t stdPPSId_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , writeStdVPS{ writeStdVPS_ } + , writeStdSPS{ writeStdSPS_ } + , writeStdPPS{ writeStdPPS_ } + , stdVPSId{ stdVPSId_ } + , stdSPSId{ stdSPSId_ } + , stdPPSId{ stdPPSId_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersGetInfoKHR( VideoEncodeH265SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeH265SessionParametersGetInfoKHR( VkVideoEncodeH265SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeH265SessionParametersGetInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeH265SessionParametersGetInfoKHR & operator=( VideoEncodeH265SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeH265SessionParametersGetInfoKHR & operator=( VkVideoEncodeH265SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setWriteStdVPS( Bool32 writeStdVPS_ ) & VULKAN_HPP_NOEXCEPT + { + writeStdVPS = writeStdVPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setWriteStdVPS( Bool32 writeStdVPS_ ) && VULKAN_HPP_NOEXCEPT + { + writeStdVPS = writeStdVPS_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setWriteStdSPS( Bool32 writeStdSPS_ ) & VULKAN_HPP_NOEXCEPT + { + writeStdSPS = writeStdSPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setWriteStdSPS( Bool32 writeStdSPS_ ) && VULKAN_HPP_NOEXCEPT + { + writeStdSPS = writeStdSPS_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setWriteStdPPS( Bool32 writeStdPPS_ ) & VULKAN_HPP_NOEXCEPT + { + writeStdPPS = writeStdPPS_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setWriteStdPPS( Bool32 writeStdPPS_ ) && VULKAN_HPP_NOEXCEPT + { + writeStdPPS = writeStdPPS_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setStdVPSId( uint32_t stdVPSId_ ) & VULKAN_HPP_NOEXCEPT + { + stdVPSId = stdVPSId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setStdVPSId( uint32_t stdVPSId_ ) && VULKAN_HPP_NOEXCEPT + { + stdVPSId = stdVPSId_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setStdSPSId( uint32_t stdSPSId_ ) & VULKAN_HPP_NOEXCEPT + { + stdSPSId = stdSPSId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setStdSPSId( uint32_t stdSPSId_ ) && VULKAN_HPP_NOEXCEPT + { + stdSPSId = stdSPSId_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setStdPPSId( uint32_t stdPPSId_ ) & VULKAN_HPP_NOEXCEPT + { + stdPPSId = stdPPSId_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setStdPPSId( uint32_t stdPPSId_ ) && VULKAN_HPP_NOEXCEPT + { + stdPPSId = stdPPSId_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeH265SessionParametersGetInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersGetInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersGetInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeH265SessionParametersGetInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, writeStdVPS, writeStdSPS, writeStdPPS, stdVPSId, stdSPSId, stdPPSId ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeH265SessionParametersGetInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeH265SessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( writeStdVPS == rhs.writeStdVPS ) && ( writeStdSPS == rhs.writeStdSPS ) && + ( writeStdPPS == rhs.writeStdPPS ) && ( stdVPSId == rhs.stdVPSId ) && ( stdSPSId == rhs.stdSPSId ) && ( stdPPSId == rhs.stdPPSId ); +# endif + } + + bool operator!=( VideoEncodeH265SessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeH265SessionParametersGetInfoKHR; + const void * pNext = {}; + Bool32 writeStdVPS = {}; + Bool32 writeStdSPS = {}; + Bool32 writeStdPPS = {}; + uint32_t stdVPSId = {}; + uint32_t stdSPSId = {}; + uint32_t stdPPSId = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeH265SessionParametersGetInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeH265SessionParametersGetInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeInfoKHR.html + struct VideoEncodeInfoKHR + { + using NativeType = VkVideoEncodeInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VideoEncodeFlagsKHR flags_ = {}, + Buffer dstBuffer_ = {}, + DeviceSize dstBufferOffset_ = {}, + DeviceSize dstBufferRange_ = {}, + VideoPictureResourceInfoKHR srcPictureResource_ = {}, + const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ = {}, + uint32_t referenceSlotCount_ = {}, + const VideoReferenceSlotInfoKHR * pReferenceSlots_ = {}, + uint32_t precedingExternallyEncodedBytes_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , dstBuffer{ dstBuffer_ } + , dstBufferOffset{ dstBufferOffset_ } + , dstBufferRange{ dstBufferRange_ } + , srcPictureResource{ srcPictureResource_ } + , pSetupReferenceSlot{ pSetupReferenceSlot_ } + , referenceSlotCount{ referenceSlotCount_ } + , pReferenceSlots{ pReferenceSlots_ } + , precedingExternallyEncodedBytes{ precedingExternallyEncodedBytes_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeInfoKHR( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoEncodeInfoKHR( *reinterpret_cast( &rhs ) ) {} + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeInfoKHR( VideoEncodeFlagsKHR flags_, + Buffer dstBuffer_, + DeviceSize dstBufferOffset_, + DeviceSize dstBufferRange_, + VideoPictureResourceInfoKHR srcPictureResource_, + const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_, + ArrayProxyNoTemporaries const & referenceSlots_, + uint32_t precedingExternallyEncodedBytes_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , dstBuffer( dstBuffer_ ) + , dstBufferOffset( dstBufferOffset_ ) + , dstBufferRange( dstBufferRange_ ) + , srcPictureResource( srcPictureResource_ ) + , pSetupReferenceSlot( pSetupReferenceSlot_ ) + , referenceSlotCount( static_cast( referenceSlots_.size() ) ) + , pReferenceSlots( referenceSlots_.data() ) + , precedingExternallyEncodedBytes( precedingExternallyEncodedBytes_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoEncodeInfoKHR & operator=( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeInfoKHR & operator=( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setFlags( VideoEncodeFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setFlags( VideoEncodeFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBuffer( Buffer dstBuffer_ ) & VULKAN_HPP_NOEXCEPT + { + dstBuffer = dstBuffer_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setDstBuffer( Buffer dstBuffer_ ) && VULKAN_HPP_NOEXCEPT + { + dstBuffer = dstBuffer_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferOffset( DeviceSize dstBufferOffset_ ) & VULKAN_HPP_NOEXCEPT + { + dstBufferOffset = dstBufferOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setDstBufferOffset( DeviceSize dstBufferOffset_ ) && VULKAN_HPP_NOEXCEPT + { + dstBufferOffset = dstBufferOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferRange( DeviceSize dstBufferRange_ ) & VULKAN_HPP_NOEXCEPT + { + dstBufferRange = dstBufferRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setDstBufferRange( DeviceSize dstBufferRange_ ) && VULKAN_HPP_NOEXCEPT + { + dstBufferRange = dstBufferRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setSrcPictureResource( VideoPictureResourceInfoKHR const & srcPictureResource_ ) & VULKAN_HPP_NOEXCEPT + { + srcPictureResource = srcPictureResource_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setSrcPictureResource( VideoPictureResourceInfoKHR const & srcPictureResource_ ) && VULKAN_HPP_NOEXCEPT + { + srcPictureResource = srcPictureResource_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPSetupReferenceSlot( const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) & VULKAN_HPP_NOEXCEPT + { + pSetupReferenceSlot = pSetupReferenceSlot_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setPSetupReferenceSlot( const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) && VULKAN_HPP_NOEXCEPT + { + pSetupReferenceSlot = pSetupReferenceSlot_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setReferenceSlotCount( uint32_t referenceSlotCount_ ) & VULKAN_HPP_NOEXCEPT + { + referenceSlotCount = referenceSlotCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setReferenceSlotCount( uint32_t referenceSlotCount_ ) && VULKAN_HPP_NOEXCEPT + { + referenceSlotCount = referenceSlotCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) & VULKAN_HPP_NOEXCEPT + { + pReferenceSlots = pReferenceSlots_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) && VULKAN_HPP_NOEXCEPT + { + pReferenceSlots = pReferenceSlots_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeInfoKHR & setReferenceSlots( ArrayProxyNoTemporaries const & referenceSlots_ ) VULKAN_HPP_NOEXCEPT + { + referenceSlotCount = static_cast( referenceSlots_.size() ); + pReferenceSlots = referenceSlots_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPrecedingExternallyEncodedBytes( uint32_t precedingExternallyEncodedBytes_ ) & VULKAN_HPP_NOEXCEPT + { + precedingExternallyEncodedBytes = precedingExternallyEncodedBytes_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setPrecedingExternallyEncodedBytes( uint32_t precedingExternallyEncodedBytes_ ) && VULKAN_HPP_NOEXCEPT + { + precedingExternallyEncodedBytes = precedingExternallyEncodedBytes_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + flags, + dstBuffer, + dstBufferOffset, + dstBufferRange, + srcPictureResource, + pSetupReferenceSlot, + referenceSlotCount, + pReferenceSlots, + precedingExternallyEncodedBytes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dstBuffer == rhs.dstBuffer ) && + ( dstBufferOffset == rhs.dstBufferOffset ) && ( dstBufferRange == rhs.dstBufferRange ) && ( srcPictureResource == rhs.srcPictureResource ) && + ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) && + ( pReferenceSlots == rhs.pReferenceSlots ) && ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes ); +# endif + } + + bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeInfoKHR; + const void * pNext = {}; + VideoEncodeFlagsKHR flags = {}; + Buffer dstBuffer = {}; + DeviceSize dstBufferOffset = {}; + DeviceSize dstBufferRange = {}; + VideoPictureResourceInfoKHR srcPictureResource = {}; + const VideoReferenceSlotInfoKHR * pSetupReferenceSlot = {}; + uint32_t referenceSlotCount = {}; + const VideoReferenceSlotInfoKHR * pReferenceSlots = {}; + uint32_t precedingExternallyEncodedBytes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeIntraRefreshCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeIntraRefreshCapabilitiesKHR.html + struct VideoEncodeIntraRefreshCapabilitiesKHR + { + using NativeType = VkVideoEncodeIntraRefreshCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeIntraRefreshCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeIntraRefreshCapabilitiesKHR( VideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes_ = {}, + uint32_t maxIntraRefreshCycleDuration_ = {}, + uint32_t maxIntraRefreshActiveReferencePictures_ = {}, + Bool32 partitionIndependentIntraRefreshRegions_ = {}, + Bool32 nonRectangularIntraRefreshRegions_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , intraRefreshModes{ intraRefreshModes_ } + , maxIntraRefreshCycleDuration{ maxIntraRefreshCycleDuration_ } + , maxIntraRefreshActiveReferencePictures{ maxIntraRefreshActiveReferencePictures_ } + , partitionIndependentIntraRefreshRegions{ partitionIndependentIntraRefreshRegions_ } + , nonRectangularIntraRefreshRegions{ nonRectangularIntraRefreshRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeIntraRefreshCapabilitiesKHR( VideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeIntraRefreshCapabilitiesKHR( VkVideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeIntraRefreshCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeIntraRefreshCapabilitiesKHR & operator=( VideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeIntraRefreshCapabilitiesKHR & operator=( VkVideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeIntraRefreshCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeIntraRefreshCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeIntraRefreshCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeIntraRefreshCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + intraRefreshModes, + maxIntraRefreshCycleDuration, + maxIntraRefreshActiveReferencePictures, + partitionIndependentIntraRefreshRegions, + nonRectangularIntraRefreshRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeIntraRefreshCapabilitiesKHR const & ) const = default; +#else + bool operator==( VideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( intraRefreshModes == rhs.intraRefreshModes ) && + ( maxIntraRefreshCycleDuration == rhs.maxIntraRefreshCycleDuration ) && + ( maxIntraRefreshActiveReferencePictures == rhs.maxIntraRefreshActiveReferencePictures ) && + ( partitionIndependentIntraRefreshRegions == rhs.partitionIndependentIntraRefreshRegions ) && + ( nonRectangularIntraRefreshRegions == rhs.nonRectangularIntraRefreshRegions ); +# endif + } + + bool operator!=( VideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeIntraRefreshCapabilitiesKHR; + void * pNext = {}; + VideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes = {}; + uint32_t maxIntraRefreshCycleDuration = {}; + uint32_t maxIntraRefreshActiveReferencePictures = {}; + Bool32 partitionIndependentIntraRefreshRegions = {}; + Bool32 nonRectangularIntraRefreshRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeIntraRefreshCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeIntraRefreshCapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeIntraRefreshInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeIntraRefreshInfoKHR.html + struct VideoEncodeIntraRefreshInfoKHR + { + using NativeType = VkVideoEncodeIntraRefreshInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeIntraRefreshInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeIntraRefreshInfoKHR( uint32_t intraRefreshCycleDuration_ = {}, + uint32_t intraRefreshIndex_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , intraRefreshCycleDuration{ intraRefreshCycleDuration_ } + , intraRefreshIndex{ intraRefreshIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeIntraRefreshInfoKHR( VideoEncodeIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeIntraRefreshInfoKHR( VkVideoEncodeIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeIntraRefreshInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeIntraRefreshInfoKHR & operator=( VideoEncodeIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeIntraRefreshInfoKHR & operator=( VkVideoEncodeIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR & setIntraRefreshCycleDuration( uint32_t intraRefreshCycleDuration_ ) & VULKAN_HPP_NOEXCEPT + { + intraRefreshCycleDuration = intraRefreshCycleDuration_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR && setIntraRefreshCycleDuration( uint32_t intraRefreshCycleDuration_ ) && VULKAN_HPP_NOEXCEPT + { + intraRefreshCycleDuration = intraRefreshCycleDuration_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR & setIntraRefreshIndex( uint32_t intraRefreshIndex_ ) & VULKAN_HPP_NOEXCEPT + { + intraRefreshIndex = intraRefreshIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR && setIntraRefreshIndex( uint32_t intraRefreshIndex_ ) && VULKAN_HPP_NOEXCEPT + { + intraRefreshIndex = intraRefreshIndex_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeIntraRefreshInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeIntraRefreshInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeIntraRefreshInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeIntraRefreshInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, intraRefreshCycleDuration, intraRefreshIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeIntraRefreshInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeIntraRefreshInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( intraRefreshCycleDuration == rhs.intraRefreshCycleDuration ) && + ( intraRefreshIndex == rhs.intraRefreshIndex ); +# endif + } + + bool operator!=( VideoEncodeIntraRefreshInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeIntraRefreshInfoKHR; + const void * pNext = {}; + uint32_t intraRefreshCycleDuration = {}; + uint32_t intraRefreshIndex = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeIntraRefreshInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeIntraRefreshInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeProfileRgbConversionInfoVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeProfileRgbConversionInfoVALVE.html + struct VideoEncodeProfileRgbConversionInfoVALVE + { + using NativeType = VkVideoEncodeProfileRgbConversionInfoVALVE; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeProfileRgbConversionInfoVALVE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeProfileRgbConversionInfoVALVE( Bool32 performEncodeRgbConversion_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , performEncodeRgbConversion{ performEncodeRgbConversion_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeProfileRgbConversionInfoVALVE( VideoEncodeProfileRgbConversionInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeProfileRgbConversionInfoVALVE( VkVideoEncodeProfileRgbConversionInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeProfileRgbConversionInfoVALVE( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeProfileRgbConversionInfoVALVE & operator=( VideoEncodeProfileRgbConversionInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeProfileRgbConversionInfoVALVE & operator=( VkVideoEncodeProfileRgbConversionInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeProfileRgbConversionInfoVALVE & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeProfileRgbConversionInfoVALVE && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeProfileRgbConversionInfoVALVE & setPerformEncodeRgbConversion( Bool32 performEncodeRgbConversion_ ) & VULKAN_HPP_NOEXCEPT + { + performEncodeRgbConversion = performEncodeRgbConversion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeProfileRgbConversionInfoVALVE && setPerformEncodeRgbConversion( Bool32 performEncodeRgbConversion_ ) && + VULKAN_HPP_NOEXCEPT + { + performEncodeRgbConversion = performEncodeRgbConversion_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeProfileRgbConversionInfoVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeProfileRgbConversionInfoVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeProfileRgbConversionInfoVALVE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeProfileRgbConversionInfoVALVE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, performEncodeRgbConversion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeProfileRgbConversionInfoVALVE const & ) const = default; +#else + bool operator==( VideoEncodeProfileRgbConversionInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( performEncodeRgbConversion == rhs.performEncodeRgbConversion ); +# endif + } + + bool operator!=( VideoEncodeProfileRgbConversionInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeProfileRgbConversionInfoVALVE; + const void * pNext = {}; + Bool32 performEncodeRgbConversion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeProfileRgbConversionInfoVALVE; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeProfileRgbConversionInfoVALVE; + }; + + // wrapper struct for struct VkVideoEncodeQualityLevelInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeQualityLevelInfoKHR.html + struct VideoEncodeQualityLevelInfoKHR + { + using NativeType = VkVideoEncodeQualityLevelInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQualityLevelInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelInfoKHR( uint32_t qualityLevel_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , qualityLevel{ qualityLevel_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelInfoKHR( VideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeQualityLevelInfoKHR( VkVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeQualityLevelInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeQualityLevelInfoKHR & operator=( VideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeQualityLevelInfoKHR & operator=( VkVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR & setQualityLevel( uint32_t qualityLevel_ ) & VULKAN_HPP_NOEXCEPT + { + qualityLevel = qualityLevel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR && setQualityLevel( uint32_t qualityLevel_ ) && VULKAN_HPP_NOEXCEPT + { + qualityLevel = qualityLevel_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeQualityLevelInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQualityLevelInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQualityLevelInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeQualityLevelInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, qualityLevel ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeQualityLevelInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( qualityLevel == rhs.qualityLevel ); +# endif + } + + bool operator!=( VideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeQualityLevelInfoKHR; + const void * pNext = {}; + uint32_t qualityLevel = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeQualityLevelInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeQualityLevelInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeQualityLevelPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeQualityLevelPropertiesKHR.html + struct VideoEncodeQualityLevelPropertiesKHR + { + using NativeType = VkVideoEncodeQualityLevelPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQualityLevelPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoEncodeQualityLevelPropertiesKHR( VideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode_ = VideoEncodeRateControlModeFlagBitsKHR::eDefault, + uint32_t preferredRateControlLayerCount_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , preferredRateControlMode{ preferredRateControlMode_ } + , preferredRateControlLayerCount{ preferredRateControlLayerCount_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelPropertiesKHR( VideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeQualityLevelPropertiesKHR( VkVideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeQualityLevelPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeQualityLevelPropertiesKHR & operator=( VideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeQualityLevelPropertiesKHR & operator=( VkVideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeQualityLevelPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQualityLevelPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQualityLevelPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeQualityLevelPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, preferredRateControlMode, preferredRateControlLayerCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeQualityLevelPropertiesKHR const & ) const = default; +#else + bool operator==( VideoEncodeQualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlMode == rhs.preferredRateControlMode ) && + ( preferredRateControlLayerCount == rhs.preferredRateControlLayerCount ); +# endif + } + + bool operator!=( VideoEncodeQualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeQualityLevelPropertiesKHR; + void * pNext = {}; + VideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode = VideoEncodeRateControlModeFlagBitsKHR::eDefault; + uint32_t preferredRateControlLayerCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeQualityLevelPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeQualityLevelPropertiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeQuantizationMapCapabilitiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeQuantizationMapCapabilitiesKHR.html + struct VideoEncodeQuantizationMapCapabilitiesKHR + { + using NativeType = VkVideoEncodeQuantizationMapCapabilitiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQuantizationMapCapabilitiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapCapabilitiesKHR( Extent2D maxQuantizationMapExtent_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxQuantizationMapExtent{ maxQuantizationMapExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapCapabilitiesKHR( VideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeQuantizationMapCapabilitiesKHR( VkVideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeQuantizationMapCapabilitiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeQuantizationMapCapabilitiesKHR & operator=( VideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeQuantizationMapCapabilitiesKHR & operator=( VkVideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeQuantizationMapCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQuantizationMapCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQuantizationMapCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeQuantizationMapCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxQuantizationMapExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeQuantizationMapCapabilitiesKHR const & ) const = default; +#else + bool operator==( VideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxQuantizationMapExtent == rhs.maxQuantizationMapExtent ); +# endif + } + + bool operator!=( VideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeQuantizationMapCapabilitiesKHR; + void * pNext = {}; + Extent2D maxQuantizationMapExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeQuantizationMapCapabilitiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeQuantizationMapCapabilitiesKHR; + }; + + // wrapper struct for struct VkVideoEncodeQuantizationMapInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeQuantizationMapInfoKHR.html + struct VideoEncodeQuantizationMapInfoKHR + { + using NativeType = VkVideoEncodeQuantizationMapInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQuantizationMapInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapInfoKHR( ImageView quantizationMap_ = {}, + Extent2D quantizationMapExtent_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , quantizationMap{ quantizationMap_ } + , quantizationMapExtent{ quantizationMapExtent_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapInfoKHR( VideoEncodeQuantizationMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeQuantizationMapInfoKHR( VkVideoEncodeQuantizationMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeQuantizationMapInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeQuantizationMapInfoKHR & operator=( VideoEncodeQuantizationMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeQuantizationMapInfoKHR & operator=( VkVideoEncodeQuantizationMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR & setQuantizationMap( ImageView quantizationMap_ ) & VULKAN_HPP_NOEXCEPT + { + quantizationMap = quantizationMap_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR && setQuantizationMap( ImageView quantizationMap_ ) && VULKAN_HPP_NOEXCEPT + { + quantizationMap = quantizationMap_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR & setQuantizationMapExtent( Extent2D const & quantizationMapExtent_ ) & VULKAN_HPP_NOEXCEPT + { + quantizationMapExtent = quantizationMapExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR && setQuantizationMapExtent( Extent2D const & quantizationMapExtent_ ) && VULKAN_HPP_NOEXCEPT + { + quantizationMapExtent = quantizationMapExtent_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeQuantizationMapInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQuantizationMapInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQuantizationMapInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeQuantizationMapInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, quantizationMap, quantizationMapExtent ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeQuantizationMapInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeQuantizationMapInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( quantizationMap == rhs.quantizationMap ) && + ( quantizationMapExtent == rhs.quantizationMapExtent ); +# endif + } + + bool operator!=( VideoEncodeQuantizationMapInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeQuantizationMapInfoKHR; + const void * pNext = {}; + ImageView quantizationMap = {}; + Extent2D quantizationMapExtent = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeQuantizationMapInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeQuantizationMapInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR.html + struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR + { + using NativeType = VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQuantizationMapSessionParametersCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapSessionParametersCreateInfoKHR( Extent2D quantizationMapTexelSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , quantizationMapTexelSize{ quantizationMapTexelSize_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapSessionParametersCreateInfoKHR( VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) + VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeQuantizationMapSessionParametersCreateInfoKHR( VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeQuantizationMapSessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeQuantizationMapSessionParametersCreateInfoKHR & + operator=( VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeQuantizationMapSessionParametersCreateInfoKHR & + operator=( VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapSessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapSessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapSessionParametersCreateInfoKHR & + setQuantizationMapTexelSize( Extent2D const & quantizationMapTexelSize_ ) & + VULKAN_HPP_NOEXCEPT + { + quantizationMapTexelSize = quantizationMapTexelSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapSessionParametersCreateInfoKHR && + setQuantizationMapTexelSize( Extent2D const & quantizationMapTexelSize_ ) && + VULKAN_HPP_NOEXCEPT + { + quantizationMapTexelSize = quantizationMapTexelSize_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, quantizationMapTexelSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( quantizationMapTexelSize == rhs.quantizationMapTexelSize ); +# endif + } + + bool operator!=( VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeQuantizationMapSessionParametersCreateInfoKHR; + const void * pNext = {}; + Extent2D quantizationMapTexelSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeQuantizationMapSessionParametersCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeQuantizationMapSessionParametersCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeRateControlLayerInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlLayerInfoKHR.html + struct VideoEncodeRateControlLayerInfoKHR + { + using NativeType = VkVideoEncodeRateControlLayerInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlLayerInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( uint64_t averageBitrate_ = {}, + uint64_t maxBitrate_ = {}, + uint32_t frameRateNumerator_ = {}, + uint32_t frameRateDenominator_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , averageBitrate{ averageBitrate_ } + , maxBitrate{ maxBitrate_ } + , frameRateNumerator{ frameRateNumerator_ } + , frameRateDenominator{ frameRateDenominator_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeRateControlLayerInfoKHR( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeRateControlLayerInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeRateControlLayerInfoKHR & operator=( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeRateControlLayerInfoKHR & operator=( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setAverageBitrate( uint64_t averageBitrate_ ) & VULKAN_HPP_NOEXCEPT + { + averageBitrate = averageBitrate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR && setAverageBitrate( uint64_t averageBitrate_ ) && VULKAN_HPP_NOEXCEPT + { + averageBitrate = averageBitrate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setMaxBitrate( uint64_t maxBitrate_ ) & VULKAN_HPP_NOEXCEPT + { + maxBitrate = maxBitrate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR && setMaxBitrate( uint64_t maxBitrate_ ) && VULKAN_HPP_NOEXCEPT + { + maxBitrate = maxBitrate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateNumerator( uint32_t frameRateNumerator_ ) & VULKAN_HPP_NOEXCEPT + { + frameRateNumerator = frameRateNumerator_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR && setFrameRateNumerator( uint32_t frameRateNumerator_ ) && VULKAN_HPP_NOEXCEPT + { + frameRateNumerator = frameRateNumerator_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateDenominator( uint32_t frameRateDenominator_ ) & VULKAN_HPP_NOEXCEPT + { + frameRateDenominator = frameRateDenominator_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR && setFrameRateDenominator( uint32_t frameRateDenominator_ ) && VULKAN_HPP_NOEXCEPT + { + frameRateDenominator = frameRateDenominator_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeRateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeRateControlLayerInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeRateControlLayerInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, averageBitrate, maxBitrate, frameRateNumerator, frameRateDenominator ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) && ( maxBitrate == rhs.maxBitrate ) && + ( frameRateNumerator == rhs.frameRateNumerator ) && ( frameRateDenominator == rhs.frameRateDenominator ); +# endif + } + + bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeRateControlLayerInfoKHR; + const void * pNext = {}; + uint64_t averageBitrate = {}; + uint64_t maxBitrate = {}; + uint32_t frameRateNumerator = {}; + uint32_t frameRateDenominator = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeRateControlLayerInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeRateControlLayerInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeRateControlInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlInfoKHR.html + struct VideoEncodeRateControlInfoKHR + { + using NativeType = VkVideoEncodeRateControlInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoEncodeRateControlInfoKHR( VideoEncodeRateControlFlagsKHR flags_ = {}, + VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ = VideoEncodeRateControlModeFlagBitsKHR::eDefault, + uint32_t layerCount_ = {}, + const VideoEncodeRateControlLayerInfoKHR * pLayers_ = {}, + uint32_t virtualBufferSizeInMs_ = {}, + uint32_t initialVirtualBufferSizeInMs_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , rateControlMode{ rateControlMode_ } + , layerCount{ layerCount_ } + , pLayers{ pLayers_ } + , virtualBufferSizeInMs{ virtualBufferSizeInMs_ } + , initialVirtualBufferSizeInMs{ initialVirtualBufferSizeInMs_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeRateControlInfoKHR( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeRateControlInfoKHR( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeRateControlInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeRateControlInfoKHR( VideoEncodeRateControlFlagsKHR flags_, + VideoEncodeRateControlModeFlagBitsKHR rateControlMode_, + ArrayProxyNoTemporaries const & layers_, + uint32_t virtualBufferSizeInMs_ = {}, + uint32_t initialVirtualBufferSizeInMs_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , rateControlMode( rateControlMode_ ) + , layerCount( static_cast( layers_.size() ) ) + , pLayers( layers_.data() ) + , virtualBufferSizeInMs( virtualBufferSizeInMs_ ) + , initialVirtualBufferSizeInMs( initialVirtualBufferSizeInMs_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoEncodeRateControlInfoKHR & operator=( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeRateControlInfoKHR & operator=( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setFlags( VideoEncodeRateControlFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setFlags( VideoEncodeRateControlFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setRateControlMode( VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ ) & VULKAN_HPP_NOEXCEPT + { + rateControlMode = rateControlMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setRateControlMode( VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ ) && VULKAN_HPP_NOEXCEPT + { + rateControlMode = rateControlMode_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT + { + layerCount = layerCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setPLayers( const VideoEncodeRateControlLayerInfoKHR * pLayers_ ) & VULKAN_HPP_NOEXCEPT + { + pLayers = pLayers_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setPLayers( const VideoEncodeRateControlLayerInfoKHR * pLayers_ ) && VULKAN_HPP_NOEXCEPT + { + pLayers = pLayers_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoEncodeRateControlInfoKHR & setLayers( ArrayProxyNoTemporaries const & layers_ ) VULKAN_HPP_NOEXCEPT + { + layerCount = static_cast( layers_.size() ); + pLayers = layers_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setVirtualBufferSizeInMs( uint32_t virtualBufferSizeInMs_ ) & VULKAN_HPP_NOEXCEPT + { + virtualBufferSizeInMs = virtualBufferSizeInMs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setVirtualBufferSizeInMs( uint32_t virtualBufferSizeInMs_ ) && VULKAN_HPP_NOEXCEPT + { + virtualBufferSizeInMs = virtualBufferSizeInMs_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setInitialVirtualBufferSizeInMs( uint32_t initialVirtualBufferSizeInMs_ ) & VULKAN_HPP_NOEXCEPT + { + initialVirtualBufferSizeInMs = initialVirtualBufferSizeInMs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setInitialVirtualBufferSizeInMs( uint32_t initialVirtualBufferSizeInMs_ ) && VULKAN_HPP_NOEXCEPT + { + initialVirtualBufferSizeInMs = initialVirtualBufferSizeInMs_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeRateControlInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeRateControlInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeRateControlInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayers, virtualBufferSizeInMs, initialVirtualBufferSizeInMs ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlMode == rhs.rateControlMode ) && + ( layerCount == rhs.layerCount ) && ( pLayers == rhs.pLayers ) && ( virtualBufferSizeInMs == rhs.virtualBufferSizeInMs ) && + ( initialVirtualBufferSizeInMs == rhs.initialVirtualBufferSizeInMs ); +# endif + } + + bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeRateControlInfoKHR; + const void * pNext = {}; + VideoEncodeRateControlFlagsKHR flags = {}; + VideoEncodeRateControlModeFlagBitsKHR rateControlMode = VideoEncodeRateControlModeFlagBitsKHR::eDefault; + uint32_t layerCount = {}; + const VideoEncodeRateControlLayerInfoKHR * pLayers = {}; + uint32_t virtualBufferSizeInMs = {}; + uint32_t initialVirtualBufferSizeInMs = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeRateControlInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeRateControlInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeRgbConversionCapabilitiesVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbConversionCapabilitiesVALVE.html + struct VideoEncodeRgbConversionCapabilitiesVALVE + { + using NativeType = VkVideoEncodeRgbConversionCapabilitiesVALVE; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRgbConversionCapabilitiesVALVE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeRgbConversionCapabilitiesVALVE( VideoEncodeRgbModelConversionFlagsVALVE rgbModels_ = {}, + VideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges_ = {}, + VideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets_ = {}, + VideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rgbModels{ rgbModels_ } + , rgbRanges{ rgbRanges_ } + , xChromaOffsets{ xChromaOffsets_ } + , yChromaOffsets{ yChromaOffsets_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeRgbConversionCapabilitiesVALVE( VideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeRgbConversionCapabilitiesVALVE( VkVideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeRgbConversionCapabilitiesVALVE( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeRgbConversionCapabilitiesVALVE & operator=( VideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeRgbConversionCapabilitiesVALVE & operator=( VkVideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeRgbConversionCapabilitiesVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeRgbConversionCapabilitiesVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeRgbConversionCapabilitiesVALVE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeRgbConversionCapabilitiesVALVE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rgbModels, rgbRanges, xChromaOffsets, yChromaOffsets ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeRgbConversionCapabilitiesVALVE const & ) const = default; +#else + bool operator==( VideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rgbModels == rhs.rgbModels ) && ( rgbRanges == rhs.rgbRanges ) && + ( xChromaOffsets == rhs.xChromaOffsets ) && ( yChromaOffsets == rhs.yChromaOffsets ); +# endif + } + + bool operator!=( VideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeRgbConversionCapabilitiesVALVE; + void * pNext = {}; + VideoEncodeRgbModelConversionFlagsVALVE rgbModels = {}; + VideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges = {}; + VideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets = {}; + VideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeRgbConversionCapabilitiesVALVE; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeRgbConversionCapabilitiesVALVE; + }; + + // wrapper struct for struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeSessionIntraRefreshCreateInfoKHR.html + struct VideoEncodeSessionIntraRefreshCreateInfoKHR + { + using NativeType = VkVideoEncodeSessionIntraRefreshCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionIntraRefreshCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoEncodeSessionIntraRefreshCreateInfoKHR( VideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode_ = VideoEncodeIntraRefreshModeFlagBitsKHR::eNone, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , intraRefreshMode{ intraRefreshMode_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeSessionIntraRefreshCreateInfoKHR( VideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeSessionIntraRefreshCreateInfoKHR( VkVideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeSessionIntraRefreshCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeSessionIntraRefreshCreateInfoKHR & operator=( VideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeSessionIntraRefreshCreateInfoKHR & operator=( VkVideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionIntraRefreshCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionIntraRefreshCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionIntraRefreshCreateInfoKHR & setIntraRefreshMode( VideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode_ ) & + VULKAN_HPP_NOEXCEPT + { + intraRefreshMode = intraRefreshMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionIntraRefreshCreateInfoKHR && setIntraRefreshMode( VideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode_ ) && + VULKAN_HPP_NOEXCEPT + { + intraRefreshMode = intraRefreshMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeSessionIntraRefreshCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionIntraRefreshCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionIntraRefreshCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionIntraRefreshCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, intraRefreshMode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeSessionIntraRefreshCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( intraRefreshMode == rhs.intraRefreshMode ); +# endif + } + + bool operator!=( VideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeSessionIntraRefreshCreateInfoKHR; + const void * pNext = {}; + VideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode = VideoEncodeIntraRefreshModeFlagBitsKHR::eNone; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeSessionIntraRefreshCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeSessionIntraRefreshCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeSessionParametersFeedbackInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeSessionParametersFeedbackInfoKHR.html + struct VideoEncodeSessionParametersFeedbackInfoKHR + { + using NativeType = VkVideoEncodeSessionParametersFeedbackInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersFeedbackInfoKHR( Bool32 hasOverrides_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , hasOverrides{ hasOverrides_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersFeedbackInfoKHR( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeSessionParametersFeedbackInfoKHR( VkVideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeSessionParametersFeedbackInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeSessionParametersFeedbackInfoKHR & operator=( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeSessionParametersFeedbackInfoKHR & operator=( VkVideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoEncodeSessionParametersFeedbackInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionParametersFeedbackInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionParametersFeedbackInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionParametersFeedbackInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, hasOverrides ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeSessionParametersFeedbackInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasOverrides == rhs.hasOverrides ); +# endif + } + + bool operator!=( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR; + void * pNext = {}; + Bool32 hasOverrides = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeSessionParametersFeedbackInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeSessionParametersFeedbackInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeSessionParametersGetInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeSessionParametersGetInfoKHR.html + struct VideoEncodeSessionParametersGetInfoKHR + { + using NativeType = VkVideoEncodeSessionParametersGetInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionParametersGetInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersGetInfoKHR( VideoSessionParametersKHR videoSessionParameters_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoSessionParameters{ videoSessionParameters_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersGetInfoKHR( VideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeSessionParametersGetInfoKHR( VkVideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeSessionParametersGetInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeSessionParametersGetInfoKHR & operator=( VideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeSessionParametersGetInfoKHR & operator=( VkVideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR & setVideoSessionParameters( VideoSessionParametersKHR videoSessionParameters_ ) & + VULKAN_HPP_NOEXCEPT + { + videoSessionParameters = videoSessionParameters_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR && setVideoSessionParameters( VideoSessionParametersKHR videoSessionParameters_ ) && + VULKAN_HPP_NOEXCEPT + { + videoSessionParameters = videoSessionParameters_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeSessionParametersGetInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionParametersGetInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionParametersGetInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionParametersGetInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoSessionParameters ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeSessionParametersGetInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeSessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoSessionParameters == rhs.videoSessionParameters ); +# endif + } + + bool operator!=( VideoEncodeSessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeSessionParametersGetInfoKHR; + const void * pNext = {}; + VideoSessionParametersKHR videoSessionParameters = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeSessionParametersGetInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeSessionParametersGetInfoKHR; + }; + + // wrapper struct for struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeSessionRgbConversionCreateInfoVALVE.html + struct VideoEncodeSessionRgbConversionCreateInfoVALVE + { + using NativeType = VkVideoEncodeSessionRgbConversionCreateInfoVALVE; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionRgbConversionCreateInfoVALVE; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeSessionRgbConversionCreateInfoVALVE( + VideoEncodeRgbModelConversionFlagBitsVALVE rgbModel_ = VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity, + VideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange_ = VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange, + VideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset_ = VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven, + VideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset_ = VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , rgbModel{ rgbModel_ } + , rgbRange{ rgbRange_ } + , xChromaOffset{ xChromaOffset_ } + , yChromaOffset{ yChromaOffset_ } + { + } + + VULKAN_HPP_CONSTEXPR + VideoEncodeSessionRgbConversionCreateInfoVALVE( VideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeSessionRgbConversionCreateInfoVALVE( VkVideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeSessionRgbConversionCreateInfoVALVE( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeSessionRgbConversionCreateInfoVALVE & operator=( VideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeSessionRgbConversionCreateInfoVALVE & operator=( VkVideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE & setRgbModel( VideoEncodeRgbModelConversionFlagBitsVALVE rgbModel_ ) & + VULKAN_HPP_NOEXCEPT + { + rgbModel = rgbModel_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE && setRgbModel( VideoEncodeRgbModelConversionFlagBitsVALVE rgbModel_ ) && + VULKAN_HPP_NOEXCEPT + { + rgbModel = rgbModel_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE & setRgbRange( VideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange_ ) & + VULKAN_HPP_NOEXCEPT + { + rgbRange = rgbRange_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE && setRgbRange( VideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange_ ) && + VULKAN_HPP_NOEXCEPT + { + rgbRange = rgbRange_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE & setXChromaOffset( VideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset_ ) & + VULKAN_HPP_NOEXCEPT + { + xChromaOffset = xChromaOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE && setXChromaOffset( VideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset_ ) && + VULKAN_HPP_NOEXCEPT + { + xChromaOffset = xChromaOffset_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE & setYChromaOffset( VideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset_ ) & + VULKAN_HPP_NOEXCEPT + { + yChromaOffset = yChromaOffset_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE && setYChromaOffset( VideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset_ ) && + VULKAN_HPP_NOEXCEPT + { + yChromaOffset = yChromaOffset_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeSessionRgbConversionCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionRgbConversionCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionRgbConversionCreateInfoVALVE const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeSessionRgbConversionCreateInfoVALVE *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, rgbModel, rgbRange, xChromaOffset, yChromaOffset ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeSessionRgbConversionCreateInfoVALVE const & ) const = default; +#else + bool operator==( VideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rgbModel == rhs.rgbModel ) && ( rgbRange == rhs.rgbRange ) && + ( xChromaOffset == rhs.xChromaOffset ) && ( yChromaOffset == rhs.yChromaOffset ); +# endif + } + + bool operator!=( VideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeSessionRgbConversionCreateInfoVALVE; + const void * pNext = {}; + VideoEncodeRgbModelConversionFlagBitsVALVE rgbModel = VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity; + VideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange = VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange; + VideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset = VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven; + VideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset = VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeSessionRgbConversionCreateInfoVALVE; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeSessionRgbConversionCreateInfoVALVE; + }; + + // wrapper struct for struct VkVideoEncodeUsageInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeUsageInfoKHR.html + struct VideoEncodeUsageInfoKHR + { + using NativeType = VkVideoEncodeUsageInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeUsageInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEncodeUsageInfoKHR( VideoEncodeUsageFlagsKHR videoUsageHints_ = {}, + VideoEncodeContentFlagsKHR videoContentHints_ = {}, + VideoEncodeTuningModeKHR tuningMode_ = VideoEncodeTuningModeKHR::eDefault, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , videoUsageHints{ videoUsageHints_ } + , videoContentHints{ videoContentHints_ } + , tuningMode{ tuningMode_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEncodeUsageInfoKHR( VideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEncodeUsageInfoKHR( VkVideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEncodeUsageInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEncodeUsageInfoKHR & operator=( VideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEncodeUsageInfoKHR & operator=( VkVideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR & setVideoUsageHints( VideoEncodeUsageFlagsKHR videoUsageHints_ ) & VULKAN_HPP_NOEXCEPT + { + videoUsageHints = videoUsageHints_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR && setVideoUsageHints( VideoEncodeUsageFlagsKHR videoUsageHints_ ) && VULKAN_HPP_NOEXCEPT + { + videoUsageHints = videoUsageHints_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR & setVideoContentHints( VideoEncodeContentFlagsKHR videoContentHints_ ) & VULKAN_HPP_NOEXCEPT + { + videoContentHints = videoContentHints_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR && setVideoContentHints( VideoEncodeContentFlagsKHR videoContentHints_ ) && VULKAN_HPP_NOEXCEPT + { + videoContentHints = videoContentHints_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR & setTuningMode( VideoEncodeTuningModeKHR tuningMode_ ) & VULKAN_HPP_NOEXCEPT + { + tuningMode = tuningMode_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR && setTuningMode( VideoEncodeTuningModeKHR tuningMode_ ) && VULKAN_HPP_NOEXCEPT + { + tuningMode = tuningMode_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEncodeUsageInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeUsageInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEncodeUsageInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEncodeUsageInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std:: + tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, videoUsageHints, videoContentHints, tuningMode ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEncodeUsageInfoKHR const & ) const = default; +#else + bool operator==( VideoEncodeUsageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoUsageHints == rhs.videoUsageHints ) && ( videoContentHints == rhs.videoContentHints ) && + ( tuningMode == rhs.tuningMode ); +# endif + } + + bool operator!=( VideoEncodeUsageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEncodeUsageInfoKHR; + const void * pNext = {}; + VideoEncodeUsageFlagsKHR videoUsageHints = {}; + VideoEncodeContentFlagsKHR videoContentHints = {}; + VideoEncodeTuningModeKHR tuningMode = VideoEncodeTuningModeKHR::eDefault; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEncodeUsageInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEncodeUsageInfoKHR; + }; + + // wrapper struct for struct VkVideoEndCodingInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEndCodingInfoKHR.html + struct VideoEndCodingInfoKHR + { + using NativeType = VkVideoEndCodingInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEndCodingInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoEndCodingInfoKHR( VideoEndCodingFlagsKHR flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoEndCodingInfoKHR( VideoEndCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoEndCodingInfoKHR( VkVideoEndCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoEndCodingInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoEndCodingInfoKHR & operator=( VideoEndCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoEndCodingInfoKHR & operator=( VkVideoEndCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoEndCodingInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEndCodingInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoEndCodingInfoKHR & setFlags( VideoEndCodingFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoEndCodingInfoKHR && setFlags( VideoEndCodingFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoEndCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEndCodingInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoEndCodingInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoEndCodingInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoEndCodingInfoKHR const & ) const = default; +#else + bool operator==( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); +# endif + } + + bool operator!=( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoEndCodingInfoKHR; + const void * pNext = {}; + VideoEndCodingFlagsKHR flags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoEndCodingInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoEndCodingInfoKHR; + }; + + // wrapper struct for struct VkVideoFormatAV1QuantizationMapPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoFormatAV1QuantizationMapPropertiesKHR.html + struct VideoFormatAV1QuantizationMapPropertiesKHR + { + using NativeType = VkVideoFormatAV1QuantizationMapPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoFormatAv1QuantizationMapPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoFormatAV1QuantizationMapPropertiesKHR( VideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , compatibleSuperblockSizes{ compatibleSuperblockSizes_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoFormatAV1QuantizationMapPropertiesKHR( VideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoFormatAV1QuantizationMapPropertiesKHR( VkVideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoFormatAV1QuantizationMapPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoFormatAV1QuantizationMapPropertiesKHR & operator=( VideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoFormatAV1QuantizationMapPropertiesKHR & operator=( VkVideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoFormatAV1QuantizationMapPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoFormatAV1QuantizationMapPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoFormatAV1QuantizationMapPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoFormatAV1QuantizationMapPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, compatibleSuperblockSizes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoFormatAV1QuantizationMapPropertiesKHR const & ) const = default; +#else + bool operator==( VideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compatibleSuperblockSizes == rhs.compatibleSuperblockSizes ); +# endif + } + + bool operator!=( VideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoFormatAv1QuantizationMapPropertiesKHR; + void * pNext = {}; + VideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoFormatAV1QuantizationMapPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoFormatAV1QuantizationMapPropertiesKHR; + }; + + // wrapper struct for struct VkVideoFormatH265QuantizationMapPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoFormatH265QuantizationMapPropertiesKHR.html + struct VideoFormatH265QuantizationMapPropertiesKHR + { + using NativeType = VkVideoFormatH265QuantizationMapPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoFormatH265QuantizationMapPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoFormatH265QuantizationMapPropertiesKHR( VideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , compatibleCtbSizes{ compatibleCtbSizes_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoFormatH265QuantizationMapPropertiesKHR( VideoFormatH265QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoFormatH265QuantizationMapPropertiesKHR( VkVideoFormatH265QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoFormatH265QuantizationMapPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoFormatH265QuantizationMapPropertiesKHR & operator=( VideoFormatH265QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoFormatH265QuantizationMapPropertiesKHR & operator=( VkVideoFormatH265QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoFormatH265QuantizationMapPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoFormatH265QuantizationMapPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoFormatH265QuantizationMapPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoFormatH265QuantizationMapPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, compatibleCtbSizes ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoFormatH265QuantizationMapPropertiesKHR const & ) const = default; +#else + bool operator==( VideoFormatH265QuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compatibleCtbSizes == rhs.compatibleCtbSizes ); +# endif + } + + bool operator!=( VideoFormatH265QuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoFormatH265QuantizationMapPropertiesKHR; + void * pNext = {}; + VideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoFormatH265QuantizationMapPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoFormatH265QuantizationMapPropertiesKHR; + }; + + // wrapper struct for struct VkVideoFormatPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoFormatPropertiesKHR.html + struct VideoFormatPropertiesKHR + { + using NativeType = VkVideoFormatPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoFormatPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoFormatPropertiesKHR( Format format_ = Format::eUndefined, + ComponentMapping componentMapping_ = {}, + ImageCreateFlags imageCreateFlags_ = {}, + ImageType imageType_ = ImageType::e1D, + ImageTiling imageTiling_ = ImageTiling::eOptimal, + ImageUsageFlags imageUsageFlags_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , format{ format_ } + , componentMapping{ componentMapping_ } + , imageCreateFlags{ imageCreateFlags_ } + , imageType{ imageType_ } + , imageTiling{ imageTiling_ } + , imageUsageFlags{ imageUsageFlags_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoFormatPropertiesKHR( VideoFormatPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoFormatPropertiesKHR( VkVideoFormatPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoFormatPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoFormatPropertiesKHR & operator=( VideoFormatPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoFormatPropertiesKHR & operator=( VkVideoFormatPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoFormatPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoFormatPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoFormatPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoFormatPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, format, componentMapping, imageCreateFlags, imageType, imageTiling, imageUsageFlags ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoFormatPropertiesKHR const & ) const = default; +#else + bool operator==( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( componentMapping == rhs.componentMapping ) && + ( imageCreateFlags == rhs.imageCreateFlags ) && ( imageType == rhs.imageType ) && ( imageTiling == rhs.imageTiling ) && + ( imageUsageFlags == rhs.imageUsageFlags ); +# endif + } + + bool operator!=( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoFormatPropertiesKHR; + void * pNext = {}; + Format format = Format::eUndefined; + ComponentMapping componentMapping = {}; + ImageCreateFlags imageCreateFlags = {}; + ImageType imageType = ImageType::e1D; + ImageTiling imageTiling = ImageTiling::eOptimal; + ImageUsageFlags imageUsageFlags = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoFormatPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoFormatPropertiesKHR; + }; + + // wrapper struct for struct VkVideoFormatQuantizationMapPropertiesKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoFormatQuantizationMapPropertiesKHR.html + struct VideoFormatQuantizationMapPropertiesKHR + { + using NativeType = VkVideoFormatQuantizationMapPropertiesKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoFormatQuantizationMapPropertiesKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoFormatQuantizationMapPropertiesKHR( Extent2D quantizationMapTexelSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , quantizationMapTexelSize{ quantizationMapTexelSize_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoFormatQuantizationMapPropertiesKHR( VideoFormatQuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoFormatQuantizationMapPropertiesKHR( VkVideoFormatQuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoFormatQuantizationMapPropertiesKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoFormatQuantizationMapPropertiesKHR & operator=( VideoFormatQuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoFormatQuantizationMapPropertiesKHR & operator=( VkVideoFormatQuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoFormatQuantizationMapPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoFormatQuantizationMapPropertiesKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoFormatQuantizationMapPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoFormatQuantizationMapPropertiesKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, quantizationMapTexelSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoFormatQuantizationMapPropertiesKHR const & ) const = default; +#else + bool operator==( VideoFormatQuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( quantizationMapTexelSize == rhs.quantizationMapTexelSize ); +# endif + } + + bool operator!=( VideoFormatQuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoFormatQuantizationMapPropertiesKHR; + void * pNext = {}; + Extent2D quantizationMapTexelSize = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoFormatQuantizationMapPropertiesKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoFormatQuantizationMapPropertiesKHR; + }; + + // wrapper struct for struct VkVideoInlineQueryInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoInlineQueryInfoKHR.html + struct VideoInlineQueryInfoKHR + { + using NativeType = VkVideoInlineQueryInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoInlineQueryInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoInlineQueryInfoKHR( QueryPool queryPool_ = {}, + uint32_t firstQuery_ = {}, + uint32_t queryCount_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , queryPool{ queryPool_ } + , firstQuery{ firstQuery_ } + , queryCount{ queryCount_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoInlineQueryInfoKHR( VideoInlineQueryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoInlineQueryInfoKHR( VkVideoInlineQueryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoInlineQueryInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoInlineQueryInfoKHR & operator=( VideoInlineQueryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoInlineQueryInfoKHR & operator=( VkVideoInlineQueryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR & setQueryPool( QueryPool queryPool_ ) & VULKAN_HPP_NOEXCEPT + { + queryPool = queryPool_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR && setQueryPool( QueryPool queryPool_ ) && VULKAN_HPP_NOEXCEPT + { + queryPool = queryPool_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR & setFirstQuery( uint32_t firstQuery_ ) & VULKAN_HPP_NOEXCEPT + { + firstQuery = firstQuery_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR && setFirstQuery( uint32_t firstQuery_ ) && VULKAN_HPP_NOEXCEPT + { + firstQuery = firstQuery_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR & setQueryCount( uint32_t queryCount_ ) & VULKAN_HPP_NOEXCEPT + { + queryCount = queryCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR && setQueryCount( uint32_t queryCount_ ) && VULKAN_HPP_NOEXCEPT + { + queryCount = queryCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoInlineQueryInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoInlineQueryInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoInlineQueryInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoInlineQueryInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, queryPool, firstQuery, queryCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoInlineQueryInfoKHR const & ) const = default; +#else + bool operator==( VideoInlineQueryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queryPool == rhs.queryPool ) && ( firstQuery == rhs.firstQuery ) && + ( queryCount == rhs.queryCount ); +# endif + } + + bool operator!=( VideoInlineQueryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoInlineQueryInfoKHR; + const void * pNext = {}; + QueryPool queryPool = {}; + uint32_t firstQuery = {}; + uint32_t queryCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoInlineQueryInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoInlineQueryInfoKHR; + }; + + // wrapper struct for struct VkVideoProfileListInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoProfileListInfoKHR.html + struct VideoProfileListInfoKHR + { + using NativeType = VkVideoProfileListInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoProfileListInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + VideoProfileListInfoKHR( uint32_t profileCount_ = {}, const VideoProfileInfoKHR * pProfiles_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , profileCount{ profileCount_ } + , pProfiles{ pProfiles_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoProfileListInfoKHR( VideoProfileListInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoProfileListInfoKHR( VkVideoProfileListInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoProfileListInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoProfileListInfoKHR( ArrayProxyNoTemporaries const & profiles_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), profileCount( static_cast( profiles_.size() ) ), pProfiles( profiles_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VideoProfileListInfoKHR & operator=( VideoProfileListInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoProfileListInfoKHR & operator=( VkVideoProfileListInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR & setProfileCount( uint32_t profileCount_ ) & VULKAN_HPP_NOEXCEPT + { + profileCount = profileCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR && setProfileCount( uint32_t profileCount_ ) && VULKAN_HPP_NOEXCEPT + { + profileCount = profileCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR & setPProfiles( const VideoProfileInfoKHR * pProfiles_ ) & VULKAN_HPP_NOEXCEPT + { + pProfiles = pProfiles_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR && setPProfiles( const VideoProfileInfoKHR * pProfiles_ ) && VULKAN_HPP_NOEXCEPT + { + pProfiles = pProfiles_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + VideoProfileListInfoKHR & setProfiles( ArrayProxyNoTemporaries const & profiles_ ) VULKAN_HPP_NOEXCEPT + { + profileCount = static_cast( profiles_.size() ); + pProfiles = profiles_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoProfileListInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoProfileListInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoProfileListInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoProfileListInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, profileCount, pProfiles ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoProfileListInfoKHR const & ) const = default; +#else + bool operator==( VideoProfileListInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( profileCount == rhs.profileCount ) && ( pProfiles == rhs.pProfiles ); +# endif + } + + bool operator!=( VideoProfileListInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoProfileListInfoKHR; + const void * pNext = {}; + uint32_t profileCount = {}; + const VideoProfileInfoKHR * pProfiles = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoProfileListInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoProfileListInfoKHR; + }; + + // wrapper struct for struct VkVideoReferenceIntraRefreshInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoReferenceIntraRefreshInfoKHR.html + struct VideoReferenceIntraRefreshInfoKHR + { + using NativeType = VkVideoReferenceIntraRefreshInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoReferenceIntraRefreshInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoReferenceIntraRefreshInfoKHR( uint32_t dirtyIntraRefreshRegions_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dirtyIntraRefreshRegions{ dirtyIntraRefreshRegions_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoReferenceIntraRefreshInfoKHR( VideoReferenceIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoReferenceIntraRefreshInfoKHR( VkVideoReferenceIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoReferenceIntraRefreshInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoReferenceIntraRefreshInfoKHR & operator=( VideoReferenceIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoReferenceIntraRefreshInfoKHR & operator=( VkVideoReferenceIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoReferenceIntraRefreshInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoReferenceIntraRefreshInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoReferenceIntraRefreshInfoKHR & setDirtyIntraRefreshRegions( uint32_t dirtyIntraRefreshRegions_ ) & VULKAN_HPP_NOEXCEPT + { + dirtyIntraRefreshRegions = dirtyIntraRefreshRegions_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoReferenceIntraRefreshInfoKHR && setDirtyIntraRefreshRegions( uint32_t dirtyIntraRefreshRegions_ ) && VULKAN_HPP_NOEXCEPT + { + dirtyIntraRefreshRegions = dirtyIntraRefreshRegions_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoReferenceIntraRefreshInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoReferenceIntraRefreshInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoReferenceIntraRefreshInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoReferenceIntraRefreshInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dirtyIntraRefreshRegions ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoReferenceIntraRefreshInfoKHR const & ) const = default; +#else + bool operator==( VideoReferenceIntraRefreshInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dirtyIntraRefreshRegions == rhs.dirtyIntraRefreshRegions ); +# endif + } + + bool operator!=( VideoReferenceIntraRefreshInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoReferenceIntraRefreshInfoKHR; + const void * pNext = {}; + uint32_t dirtyIntraRefreshRegions = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoReferenceIntraRefreshInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoReferenceIntraRefreshInfoKHR; + }; + + // wrapper struct for struct VkVideoSessionCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionCreateInfoKHR.html + struct VideoSessionCreateInfoKHR + { + using NativeType = VkVideoSessionCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoSessionCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR( uint32_t queueFamilyIndex_ = {}, + VideoSessionCreateFlagsKHR flags_ = {}, + const VideoProfileInfoKHR * pVideoProfile_ = {}, + Format pictureFormat_ = Format::eUndefined, + Extent2D maxCodedExtent_ = {}, + Format referencePictureFormat_ = Format::eUndefined, + uint32_t maxDpbSlots_ = {}, + uint32_t maxActiveReferencePictures_ = {}, + const ExtensionProperties * pStdHeaderVersion_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , queueFamilyIndex{ queueFamilyIndex_ } + , flags{ flags_ } + , pVideoProfile{ pVideoProfile_ } + , pictureFormat{ pictureFormat_ } + , maxCodedExtent{ maxCodedExtent_ } + , referencePictureFormat{ referencePictureFormat_ } + , maxDpbSlots{ maxDpbSlots_ } + , maxActiveReferencePictures{ maxActiveReferencePictures_ } + , pStdHeaderVersion{ pStdHeaderVersion_ } + { + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR( VideoSessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoSessionCreateInfoKHR( VkVideoSessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoSessionCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoSessionCreateInfoKHR & operator=( VideoSessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoSessionCreateInfoKHR & operator=( VkVideoSessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT + { + queueFamilyIndex = queueFamilyIndex_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setFlags( VideoSessionCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setFlags( VideoSessionCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setPVideoProfile( const VideoProfileInfoKHR * pVideoProfile_ ) & VULKAN_HPP_NOEXCEPT + { + pVideoProfile = pVideoProfile_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setPVideoProfile( const VideoProfileInfoKHR * pVideoProfile_ ) && VULKAN_HPP_NOEXCEPT + { + pVideoProfile = pVideoProfile_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setPictureFormat( Format pictureFormat_ ) & VULKAN_HPP_NOEXCEPT + { + pictureFormat = pictureFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setPictureFormat( Format pictureFormat_ ) && VULKAN_HPP_NOEXCEPT + { + pictureFormat = pictureFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setMaxCodedExtent( Extent2D const & maxCodedExtent_ ) & VULKAN_HPP_NOEXCEPT + { + maxCodedExtent = maxCodedExtent_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setMaxCodedExtent( Extent2D const & maxCodedExtent_ ) && VULKAN_HPP_NOEXCEPT + { + maxCodedExtent = maxCodedExtent_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setReferencePictureFormat( Format referencePictureFormat_ ) & VULKAN_HPP_NOEXCEPT + { + referencePictureFormat = referencePictureFormat_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setReferencePictureFormat( Format referencePictureFormat_ ) && VULKAN_HPP_NOEXCEPT + { + referencePictureFormat = referencePictureFormat_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setMaxDpbSlots( uint32_t maxDpbSlots_ ) & VULKAN_HPP_NOEXCEPT + { + maxDpbSlots = maxDpbSlots_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setMaxDpbSlots( uint32_t maxDpbSlots_ ) && VULKAN_HPP_NOEXCEPT + { + maxDpbSlots = maxDpbSlots_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setMaxActiveReferencePictures( uint32_t maxActiveReferencePictures_ ) & VULKAN_HPP_NOEXCEPT + { + maxActiveReferencePictures = maxActiveReferencePictures_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setMaxActiveReferencePictures( uint32_t maxActiveReferencePictures_ ) && VULKAN_HPP_NOEXCEPT + { + maxActiveReferencePictures = maxActiveReferencePictures_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setPStdHeaderVersion( const ExtensionProperties * pStdHeaderVersion_ ) & VULKAN_HPP_NOEXCEPT + { + pStdHeaderVersion = pStdHeaderVersion_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setPStdHeaderVersion( const ExtensionProperties * pStdHeaderVersion_ ) && VULKAN_HPP_NOEXCEPT + { + pStdHeaderVersion = pStdHeaderVersion_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoSessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoSessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoSessionCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoSessionCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + queueFamilyIndex, + flags, + pVideoProfile, + pictureFormat, + maxCodedExtent, + referencePictureFormat, + maxDpbSlots, + maxActiveReferencePictures, + pStdHeaderVersion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoSessionCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( flags == rhs.flags ) && + ( pVideoProfile == rhs.pVideoProfile ) && ( pictureFormat == rhs.pictureFormat ) && ( maxCodedExtent == rhs.maxCodedExtent ) && + ( referencePictureFormat == rhs.referencePictureFormat ) && ( maxDpbSlots == rhs.maxDpbSlots ) && + ( maxActiveReferencePictures == rhs.maxActiveReferencePictures ) && ( pStdHeaderVersion == rhs.pStdHeaderVersion ); +# endif + } + + bool operator!=( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoSessionCreateInfoKHR; + const void * pNext = {}; + uint32_t queueFamilyIndex = {}; + VideoSessionCreateFlagsKHR flags = {}; + const VideoProfileInfoKHR * pVideoProfile = {}; + Format pictureFormat = Format::eUndefined; + Extent2D maxCodedExtent = {}; + Format referencePictureFormat = Format::eUndefined; + uint32_t maxDpbSlots = {}; + uint32_t maxActiveReferencePictures = {}; + const ExtensionProperties * pStdHeaderVersion = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoSessionCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoSessionCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoSessionMemoryRequirementsKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionMemoryRequirementsKHR.html + struct VideoSessionMemoryRequirementsKHR + { + using NativeType = VkVideoSessionMemoryRequirementsKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoSessionMemoryRequirementsKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoSessionMemoryRequirementsKHR( uint32_t memoryBindIndex_ = {}, + MemoryRequirements memoryRequirements_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , memoryBindIndex{ memoryBindIndex_ } + , memoryRequirements{ memoryRequirements_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoSessionMemoryRequirementsKHR( VideoSessionMemoryRequirementsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoSessionMemoryRequirementsKHR( VkVideoSessionMemoryRequirementsKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoSessionMemoryRequirementsKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoSessionMemoryRequirementsKHR & operator=( VideoSessionMemoryRequirementsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoSessionMemoryRequirementsKHR & operator=( VkVideoSessionMemoryRequirementsKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkVideoSessionMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoSessionMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoSessionMemoryRequirementsKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoSessionMemoryRequirementsKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, memoryBindIndex, memoryRequirements ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoSessionMemoryRequirementsKHR const & ) const = default; +#else + bool operator==( VideoSessionMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && ( memoryRequirements == rhs.memoryRequirements ); +# endif + } + + bool operator!=( VideoSessionMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoSessionMemoryRequirementsKHR; + void * pNext = {}; + uint32_t memoryBindIndex = {}; + MemoryRequirements memoryRequirements = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoSessionMemoryRequirementsKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoSessionMemoryRequirementsKHR; + }; + + // wrapper struct for struct VkVideoSessionParametersCreateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersCreateInfoKHR.html + struct VideoSessionParametersCreateInfoKHR + { + using NativeType = VkVideoSessionParametersCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoSessionParametersCreateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoSessionParametersCreateInfoKHR( VideoSessionParametersCreateFlagsKHR flags_ = {}, + VideoSessionParametersKHR videoSessionParametersTemplate_ = {}, + VideoSessionKHR videoSession_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , videoSessionParametersTemplate{ videoSessionParametersTemplate_ } + , videoSession{ videoSession_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoSessionParametersCreateInfoKHR( VideoSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoSessionParametersCreateInfoKHR( VkVideoSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoSessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoSessionParametersCreateInfoKHR & operator=( VideoSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoSessionParametersCreateInfoKHR & operator=( VkVideoSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR & setFlags( VideoSessionParametersCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR && setFlags( VideoSessionParametersCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR & + setVideoSessionParametersTemplate( VideoSessionParametersKHR videoSessionParametersTemplate_ ) & + VULKAN_HPP_NOEXCEPT + { + videoSessionParametersTemplate = videoSessionParametersTemplate_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR && + setVideoSessionParametersTemplate( VideoSessionParametersKHR videoSessionParametersTemplate_ ) && + VULKAN_HPP_NOEXCEPT + { + videoSessionParametersTemplate = videoSessionParametersTemplate_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR & setVideoSession( VideoSessionKHR videoSession_ ) & VULKAN_HPP_NOEXCEPT + { + videoSession = videoSession_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR && setVideoSession( VideoSessionKHR videoSession_ ) && VULKAN_HPP_NOEXCEPT + { + videoSession = videoSession_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoSessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoSessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoSessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoSessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, videoSessionParametersTemplate, videoSession ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoSessionParametersCreateInfoKHR const & ) const = default; +#else + bool operator==( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && + ( videoSessionParametersTemplate == rhs.videoSessionParametersTemplate ) && ( videoSession == rhs.videoSession ); +# endif + } + + bool operator!=( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoSessionParametersCreateInfoKHR; + const void * pNext = {}; + VideoSessionParametersCreateFlagsKHR flags = {}; + VideoSessionParametersKHR videoSessionParametersTemplate = {}; + VideoSessionKHR videoSession = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoSessionParametersCreateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoSessionParametersCreateInfoKHR; + }; + + // wrapper struct for struct VkVideoSessionParametersUpdateInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersUpdateInfoKHR.html + struct VideoSessionParametersUpdateInfoKHR + { + using NativeType = VkVideoSessionParametersUpdateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoSessionParametersUpdateInfoKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR VideoSessionParametersUpdateInfoKHR( uint32_t updateSequenceCount_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , updateSequenceCount{ updateSequenceCount_ } + { + } + + VULKAN_HPP_CONSTEXPR VideoSessionParametersUpdateInfoKHR( VideoSessionParametersUpdateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + VideoSessionParametersUpdateInfoKHR( VkVideoSessionParametersUpdateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : VideoSessionParametersUpdateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + VideoSessionParametersUpdateInfoKHR & operator=( VideoSessionParametersUpdateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + VideoSessionParametersUpdateInfoKHR & operator=( VkVideoSessionParametersUpdateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersUpdateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersUpdateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersUpdateInfoKHR & setUpdateSequenceCount( uint32_t updateSequenceCount_ ) & VULKAN_HPP_NOEXCEPT + { + updateSequenceCount = updateSequenceCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersUpdateInfoKHR && setUpdateSequenceCount( uint32_t updateSequenceCount_ ) && VULKAN_HPP_NOEXCEPT + { + updateSequenceCount = updateSequenceCount_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkVideoSessionParametersUpdateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoSessionParametersUpdateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkVideoSessionParametersUpdateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkVideoSessionParametersUpdateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, updateSequenceCount ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( VideoSessionParametersUpdateInfoKHR const & ) const = default; +#else + bool operator==( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( updateSequenceCount == rhs.updateSequenceCount ); +# endif + } + + bool operator!=( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eVideoSessionParametersUpdateInfoKHR; + const void * pNext = {}; + uint32_t updateSequenceCount = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = VideoSessionParametersUpdateInfoKHR; + }; +#endif + + template <> + struct CppType + { + using Type = VideoSessionParametersUpdateInfoKHR; + }; + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + // wrapper struct for struct VkWaylandSurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWaylandSurfaceCreateInfoKHR.html + struct WaylandSurfaceCreateInfoKHR + { + using NativeType = VkWaylandSurfaceCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWaylandSurfaceCreateInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = {}, + struct wl_display * display_ = {}, + struct wl_surface * surface_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , display{ display_ } + , surface{ surface_ } + { + } + + VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : WaylandSurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + WaylandSurfaceCreateInfoKHR & operator=( WaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + WaylandSurfaceCreateInfoKHR & operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR & setFlags( WaylandSurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR && setFlags( WaylandSurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR & setDisplay( struct wl_display * display_ ) & VULKAN_HPP_NOEXCEPT + { + display = display_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR && setDisplay( struct wl_display * display_ ) && VULKAN_HPP_NOEXCEPT + { + display = display_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR & setSurface( struct wl_surface * surface_ ) & VULKAN_HPP_NOEXCEPT + { + surface = surface_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR && setSurface( struct wl_surface * surface_ ) && VULKAN_HPP_NOEXCEPT + { + surface = surface_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWaylandSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWaylandSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWaylandSurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWaylandSurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, display, surface ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( WaylandSurfaceCreateInfoKHR const & ) const = default; +# else + bool operator==( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( display == rhs.display ) && ( surface == rhs.surface ); +# endif + } + + bool operator!=( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR; + const void * pNext = {}; + WaylandSurfaceCreateFlagsKHR flags = {}; + struct wl_display * display = {}; + struct wl_surface * surface = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = WaylandSurfaceCreateInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = WaylandSurfaceCreateInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkWin32KeyedMutexAcquireReleaseInfoKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWin32KeyedMutexAcquireReleaseInfoKHR.html + struct Win32KeyedMutexAcquireReleaseInfoKHR + { + using NativeType = VkWin32KeyedMutexAcquireReleaseInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = {}, + const DeviceMemory * pAcquireSyncs_ = {}, + const uint64_t * pAcquireKeys_ = {}, + const uint32_t * pAcquireTimeouts_ = {}, + uint32_t releaseCount_ = {}, + const DeviceMemory * pReleaseSyncs_ = {}, + const uint64_t * pReleaseKeys_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , acquireCount{ acquireCount_ } + , pAcquireSyncs{ pAcquireSyncs_ } + , pAcquireKeys{ pAcquireKeys_ } + , pAcquireTimeouts{ pAcquireTimeouts_ } + , releaseCount{ releaseCount_ } + , pReleaseSyncs{ pReleaseSyncs_ } + , pReleaseKeys{ pReleaseKeys_ } + { + } + + VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : Win32KeyedMutexAcquireReleaseInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoKHR( ArrayProxyNoTemporaries const & acquireSyncs_, + ArrayProxyNoTemporaries const & acquireKeys_ = {}, + ArrayProxyNoTemporaries const & acquireTimeouts_ = {}, + ArrayProxyNoTemporaries const & releaseSyncs_ = {}, + ArrayProxyNoTemporaries const & releaseKeys_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , acquireCount( static_cast( acquireSyncs_.size() ) ) + , pAcquireSyncs( acquireSyncs_.data() ) + , pAcquireKeys( acquireKeys_.data() ) + , pAcquireTimeouts( acquireTimeouts_.data() ) + , releaseCount( static_cast( releaseSyncs_.size() ) ) + , pReleaseSyncs( releaseSyncs_.data() ) + , pReleaseKeys( releaseKeys_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( acquireSyncs_.size() == acquireKeys_.size() ); + VULKAN_HPP_ASSERT( acquireSyncs_.size() == acquireTimeouts_.size() ); + VULKAN_HPP_ASSERT( acquireKeys_.size() == acquireTimeouts_.size() ); +# else + if ( acquireSyncs_.size() != acquireKeys_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::Win32KeyedMutexAcquireReleaseInfoKHR::Win32KeyedMutexAcquireReleaseInfoKHR: acquireSyncs_.size() != acquireKeys_.size()" ); + } + if ( acquireSyncs_.size() != acquireTimeouts_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::Win32KeyedMutexAcquireReleaseInfoKHR::Win32KeyedMutexAcquireReleaseInfoKHR: acquireSyncs_.size() != acquireTimeouts_.size()" ); + } + if ( acquireKeys_.size() != acquireTimeouts_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::Win32KeyedMutexAcquireReleaseInfoKHR::Win32KeyedMutexAcquireReleaseInfoKHR: acquireKeys_.size() != acquireTimeouts_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( releaseSyncs_.size() == releaseKeys_.size() ); +# else + if ( releaseSyncs_.size() != releaseKeys_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::Win32KeyedMutexAcquireReleaseInfoKHR::Win32KeyedMutexAcquireReleaseInfoKHR: releaseSyncs_.size() != releaseKeys_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + Win32KeyedMutexAcquireReleaseInfoKHR & operator=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + Win32KeyedMutexAcquireReleaseInfoKHR & operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireCount( uint32_t acquireCount_ ) & VULKAN_HPP_NOEXCEPT + { + acquireCount = acquireCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setAcquireCount( uint32_t acquireCount_ ) && VULKAN_HPP_NOEXCEPT + { + acquireCount = acquireCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireSyncs( const DeviceMemory * pAcquireSyncs_ ) & VULKAN_HPP_NOEXCEPT + { + pAcquireSyncs = pAcquireSyncs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPAcquireSyncs( const DeviceMemory * pAcquireSyncs_ ) && VULKAN_HPP_NOEXCEPT + { + pAcquireSyncs = pAcquireSyncs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireSyncs( ArrayProxyNoTemporaries const & acquireSyncs_ ) VULKAN_HPP_NOEXCEPT + { + acquireCount = static_cast( acquireSyncs_.size() ); + pAcquireSyncs = acquireSyncs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireKeys( const uint64_t * pAcquireKeys_ ) & VULKAN_HPP_NOEXCEPT + { + pAcquireKeys = pAcquireKeys_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPAcquireKeys( const uint64_t * pAcquireKeys_ ) && VULKAN_HPP_NOEXCEPT + { + pAcquireKeys = pAcquireKeys_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireKeys( ArrayProxyNoTemporaries const & acquireKeys_ ) VULKAN_HPP_NOEXCEPT + { + acquireCount = static_cast( acquireKeys_.size() ); + pAcquireKeys = acquireKeys_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireTimeouts( const uint32_t * pAcquireTimeouts_ ) & VULKAN_HPP_NOEXCEPT + { + pAcquireTimeouts = pAcquireTimeouts_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPAcquireTimeouts( const uint32_t * pAcquireTimeouts_ ) && VULKAN_HPP_NOEXCEPT + { + pAcquireTimeouts = pAcquireTimeouts_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireTimeouts( ArrayProxyNoTemporaries const & acquireTimeouts_ ) VULKAN_HPP_NOEXCEPT + { + acquireCount = static_cast( acquireTimeouts_.size() ); + pAcquireTimeouts = acquireTimeouts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setReleaseCount( uint32_t releaseCount_ ) & VULKAN_HPP_NOEXCEPT + { + releaseCount = releaseCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setReleaseCount( uint32_t releaseCount_ ) && VULKAN_HPP_NOEXCEPT + { + releaseCount = releaseCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPReleaseSyncs( const DeviceMemory * pReleaseSyncs_ ) & VULKAN_HPP_NOEXCEPT + { + pReleaseSyncs = pReleaseSyncs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPReleaseSyncs( const DeviceMemory * pReleaseSyncs_ ) && VULKAN_HPP_NOEXCEPT + { + pReleaseSyncs = pReleaseSyncs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoKHR & setReleaseSyncs( ArrayProxyNoTemporaries const & releaseSyncs_ ) VULKAN_HPP_NOEXCEPT + { + releaseCount = static_cast( releaseSyncs_.size() ); + pReleaseSyncs = releaseSyncs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPReleaseKeys( const uint64_t * pReleaseKeys_ ) & VULKAN_HPP_NOEXCEPT + { + pReleaseKeys = pReleaseKeys_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPReleaseKeys( const uint64_t * pReleaseKeys_ ) && VULKAN_HPP_NOEXCEPT + { + pReleaseKeys = pReleaseKeys_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoKHR & setReleaseKeys( ArrayProxyNoTemporaries const & releaseKeys_ ) VULKAN_HPP_NOEXCEPT + { + releaseCount = static_cast( releaseKeys_.size() ); + pReleaseKeys = releaseKeys_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWin32KeyedMutexAcquireReleaseInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWin32KeyedMutexAcquireReleaseInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWin32KeyedMutexAcquireReleaseInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWin32KeyedMutexAcquireReleaseInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, acquireCount, pAcquireSyncs, pAcquireKeys, pAcquireTimeouts, releaseCount, pReleaseSyncs, pReleaseKeys ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( Win32KeyedMutexAcquireReleaseInfoKHR const & ) const = default; +# else + bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) && ( pAcquireSyncs == rhs.pAcquireSyncs ) && + ( pAcquireKeys == rhs.pAcquireKeys ) && ( pAcquireTimeouts == rhs.pAcquireTimeouts ) && ( releaseCount == rhs.releaseCount ) && + ( pReleaseSyncs == rhs.pReleaseSyncs ) && ( pReleaseKeys == rhs.pReleaseKeys ); +# endif + } + + bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; + const void * pNext = {}; + uint32_t acquireCount = {}; + const DeviceMemory * pAcquireSyncs = {}; + const uint64_t * pAcquireKeys = {}; + const uint32_t * pAcquireTimeouts = {}; + uint32_t releaseCount = {}; + const DeviceMemory * pReleaseSyncs = {}; + const uint64_t * pReleaseKeys = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = Win32KeyedMutexAcquireReleaseInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = Win32KeyedMutexAcquireReleaseInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkWin32KeyedMutexAcquireReleaseInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWin32KeyedMutexAcquireReleaseInfoNV.html + struct Win32KeyedMutexAcquireReleaseInfoNV + { + using NativeType = VkWin32KeyedMutexAcquireReleaseInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = {}, + const DeviceMemory * pAcquireSyncs_ = {}, + const uint64_t * pAcquireKeys_ = {}, + const uint32_t * pAcquireTimeoutMilliseconds_ = {}, + uint32_t releaseCount_ = {}, + const DeviceMemory * pReleaseSyncs_ = {}, + const uint64_t * pReleaseKeys_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , acquireCount{ acquireCount_ } + , pAcquireSyncs{ pAcquireSyncs_ } + , pAcquireKeys{ pAcquireKeys_ } + , pAcquireTimeoutMilliseconds{ pAcquireTimeoutMilliseconds_ } + , releaseCount{ releaseCount_ } + , pReleaseSyncs{ pReleaseSyncs_ } + , pReleaseKeys{ pReleaseKeys_ } + { + } + + VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : Win32KeyedMutexAcquireReleaseInfoNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoNV( ArrayProxyNoTemporaries const & acquireSyncs_, + ArrayProxyNoTemporaries const & acquireKeys_ = {}, + ArrayProxyNoTemporaries const & acquireTimeoutMilliseconds_ = {}, + ArrayProxyNoTemporaries const & releaseSyncs_ = {}, + ArrayProxyNoTemporaries const & releaseKeys_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , acquireCount( static_cast( acquireSyncs_.size() ) ) + , pAcquireSyncs( acquireSyncs_.data() ) + , pAcquireKeys( acquireKeys_.data() ) + , pAcquireTimeoutMilliseconds( acquireTimeoutMilliseconds_.data() ) + , releaseCount( static_cast( releaseSyncs_.size() ) ) + , pReleaseSyncs( releaseSyncs_.data() ) + , pReleaseKeys( releaseKeys_.data() ) + { +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( acquireSyncs_.size() == acquireKeys_.size() ); + VULKAN_HPP_ASSERT( acquireSyncs_.size() == acquireTimeoutMilliseconds_.size() ); + VULKAN_HPP_ASSERT( acquireKeys_.size() == acquireTimeoutMilliseconds_.size() ); +# else + if ( acquireSyncs_.size() != acquireKeys_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::Win32KeyedMutexAcquireReleaseInfoNV::Win32KeyedMutexAcquireReleaseInfoNV: acquireSyncs_.size() != acquireKeys_.size()" ); + } + if ( acquireSyncs_.size() != acquireTimeoutMilliseconds_.size() ) + { + throw LogicError( + VULKAN_HPP_NAMESPACE_STRING + "::Win32KeyedMutexAcquireReleaseInfoNV::Win32KeyedMutexAcquireReleaseInfoNV: acquireSyncs_.size() != acquireTimeoutMilliseconds_.size()" ); + } + if ( acquireKeys_.size() != acquireTimeoutMilliseconds_.size() ) + { + throw LogicError( + VULKAN_HPP_NAMESPACE_STRING + "::Win32KeyedMutexAcquireReleaseInfoNV::Win32KeyedMutexAcquireReleaseInfoNV: acquireKeys_.size() != acquireTimeoutMilliseconds_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( releaseSyncs_.size() == releaseKeys_.size() ); +# else + if ( releaseSyncs_.size() != releaseKeys_.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING + "::Win32KeyedMutexAcquireReleaseInfoNV::Win32KeyedMutexAcquireReleaseInfoNV: releaseSyncs_.size() != releaseKeys_.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + Win32KeyedMutexAcquireReleaseInfoNV & operator=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + Win32KeyedMutexAcquireReleaseInfoNV & operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setAcquireCount( uint32_t acquireCount_ ) & VULKAN_HPP_NOEXCEPT + { + acquireCount = acquireCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setAcquireCount( uint32_t acquireCount_ ) && VULKAN_HPP_NOEXCEPT + { + acquireCount = acquireCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireSyncs( const DeviceMemory * pAcquireSyncs_ ) & VULKAN_HPP_NOEXCEPT + { + pAcquireSyncs = pAcquireSyncs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPAcquireSyncs( const DeviceMemory * pAcquireSyncs_ ) && VULKAN_HPP_NOEXCEPT + { + pAcquireSyncs = pAcquireSyncs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoNV & setAcquireSyncs( ArrayProxyNoTemporaries const & acquireSyncs_ ) VULKAN_HPP_NOEXCEPT + { + acquireCount = static_cast( acquireSyncs_.size() ); + pAcquireSyncs = acquireSyncs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireKeys( const uint64_t * pAcquireKeys_ ) & VULKAN_HPP_NOEXCEPT + { + pAcquireKeys = pAcquireKeys_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPAcquireKeys( const uint64_t * pAcquireKeys_ ) && VULKAN_HPP_NOEXCEPT + { + pAcquireKeys = pAcquireKeys_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoNV & setAcquireKeys( ArrayProxyNoTemporaries const & acquireKeys_ ) VULKAN_HPP_NOEXCEPT + { + acquireCount = static_cast( acquireKeys_.size() ); + pAcquireKeys = acquireKeys_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireTimeoutMilliseconds( const uint32_t * pAcquireTimeoutMilliseconds_ ) & + VULKAN_HPP_NOEXCEPT + { + pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPAcquireTimeoutMilliseconds( const uint32_t * pAcquireTimeoutMilliseconds_ ) && + VULKAN_HPP_NOEXCEPT + { + pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoNV & + setAcquireTimeoutMilliseconds( ArrayProxyNoTemporaries const & acquireTimeoutMilliseconds_ ) VULKAN_HPP_NOEXCEPT + { + acquireCount = static_cast( acquireTimeoutMilliseconds_.size() ); + pAcquireTimeoutMilliseconds = acquireTimeoutMilliseconds_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setReleaseCount( uint32_t releaseCount_ ) & VULKAN_HPP_NOEXCEPT + { + releaseCount = releaseCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setReleaseCount( uint32_t releaseCount_ ) && VULKAN_HPP_NOEXCEPT + { + releaseCount = releaseCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPReleaseSyncs( const DeviceMemory * pReleaseSyncs_ ) & VULKAN_HPP_NOEXCEPT + { + pReleaseSyncs = pReleaseSyncs_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPReleaseSyncs( const DeviceMemory * pReleaseSyncs_ ) && VULKAN_HPP_NOEXCEPT + { + pReleaseSyncs = pReleaseSyncs_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoNV & setReleaseSyncs( ArrayProxyNoTemporaries const & releaseSyncs_ ) VULKAN_HPP_NOEXCEPT + { + releaseCount = static_cast( releaseSyncs_.size() ); + pReleaseSyncs = releaseSyncs_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPReleaseKeys( const uint64_t * pReleaseKeys_ ) & VULKAN_HPP_NOEXCEPT + { + pReleaseKeys = pReleaseKeys_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPReleaseKeys( const uint64_t * pReleaseKeys_ ) && VULKAN_HPP_NOEXCEPT + { + pReleaseKeys = pReleaseKeys_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + Win32KeyedMutexAcquireReleaseInfoNV & setReleaseKeys( ArrayProxyNoTemporaries const & releaseKeys_ ) VULKAN_HPP_NOEXCEPT + { + releaseCount = static_cast( releaseKeys_.size() ); + pReleaseKeys = releaseKeys_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWin32KeyedMutexAcquireReleaseInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWin32KeyedMutexAcquireReleaseInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWin32KeyedMutexAcquireReleaseInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWin32KeyedMutexAcquireReleaseInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, acquireCount, pAcquireSyncs, pAcquireKeys, pAcquireTimeoutMilliseconds, releaseCount, pReleaseSyncs, pReleaseKeys ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( Win32KeyedMutexAcquireReleaseInfoNV const & ) const = default; +# else + bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) && ( pAcquireSyncs == rhs.pAcquireSyncs ) && + ( pAcquireKeys == rhs.pAcquireKeys ) && ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds ) && + ( releaseCount == rhs.releaseCount ) && ( pReleaseSyncs == rhs.pReleaseSyncs ) && ( pReleaseKeys == rhs.pReleaseKeys ); +# endif + } + + bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; + const void * pNext = {}; + uint32_t acquireCount = {}; + const DeviceMemory * pAcquireSyncs = {}; + const uint64_t * pAcquireKeys = {}; + const uint32_t * pAcquireTimeoutMilliseconds = {}; + uint32_t releaseCount = {}; + const DeviceMemory * pReleaseSyncs = {}; + const uint64_t * pReleaseKeys = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = Win32KeyedMutexAcquireReleaseInfoNV; + }; +# endif + + template <> + struct CppType + { + using Type = Win32KeyedMutexAcquireReleaseInfoNV; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + // wrapper struct for struct VkWin32SurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWin32SurfaceCreateInfoKHR.html + struct Win32SurfaceCreateInfoKHR + { + using NativeType = VkWin32SurfaceCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32SurfaceCreateInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = {}, + HINSTANCE hinstance_ = {}, + HWND hwnd_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , hinstance{ hinstance_ } + , hwnd{ hwnd_ } + { + } + + VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( Win32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : Win32SurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + Win32SurfaceCreateInfoKHR & operator=( Win32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + Win32SurfaceCreateInfoKHR & operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR & setFlags( Win32SurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR && setFlags( Win32SurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR & setHinstance( HINSTANCE hinstance_ ) & VULKAN_HPP_NOEXCEPT + { + hinstance = hinstance_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR && setHinstance( HINSTANCE hinstance_ ) && VULKAN_HPP_NOEXCEPT + { + hinstance = hinstance_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR & setHwnd( HWND hwnd_ ) & VULKAN_HPP_NOEXCEPT + { + hwnd = hwnd_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR && setHwnd( HWND hwnd_ ) && VULKAN_HPP_NOEXCEPT + { + hwnd = hwnd_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWin32SurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWin32SurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWin32SurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWin32SurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, hinstance, hwnd ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( Win32SurfaceCreateInfoKHR const & ) const = default; +# else + bool operator==( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( hinstance == rhs.hinstance ) && ( hwnd == rhs.hwnd ); +# endif + } + + bool operator!=( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +# endif + + public: + StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR; + const void * pNext = {}; + Win32SurfaceCreateFlagsKHR flags = {}; + HINSTANCE hinstance = {}; + HWND hwnd = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = Win32SurfaceCreateInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = Win32SurfaceCreateInfoKHR; + }; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + // wrapper struct for struct VkWriteDescriptorSetAccelerationStructureKHR, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSetAccelerationStructureKHR.html + struct WriteDescriptorSetAccelerationStructureKHR + { + using NativeType = VkWriteDescriptorSetAccelerationStructureKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetAccelerationStructureKHR; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureKHR( uint32_t accelerationStructureCount_ = {}, + const AccelerationStructureKHR * pAccelerationStructures_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , accelerationStructureCount{ accelerationStructureCount_ } + , pAccelerationStructures{ pAccelerationStructures_ } + { + } + + VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureKHR( WriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + WriteDescriptorSetAccelerationStructureKHR( VkWriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : WriteDescriptorSetAccelerationStructureKHR( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSetAccelerationStructureKHR( ArrayProxyNoTemporaries const & accelerationStructures_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , accelerationStructureCount( static_cast( accelerationStructures_.size() ) ) + , pAccelerationStructures( accelerationStructures_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + WriteDescriptorSetAccelerationStructureKHR & operator=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + WriteDescriptorSetAccelerationStructureKHR & operator=( VkWriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR & setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructureCount = accelerationStructureCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR && setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructureCount = accelerationStructureCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR & + setPAccelerationStructures( const AccelerationStructureKHR * pAccelerationStructures_ ) & + VULKAN_HPP_NOEXCEPT + { + pAccelerationStructures = pAccelerationStructures_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR && + setPAccelerationStructures( const AccelerationStructureKHR * pAccelerationStructures_ ) && + VULKAN_HPP_NOEXCEPT + { + pAccelerationStructures = pAccelerationStructures_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSetAccelerationStructureKHR & + setAccelerationStructures( ArrayProxyNoTemporaries const & accelerationStructures_ ) VULKAN_HPP_NOEXCEPT + { + accelerationStructureCount = static_cast( accelerationStructures_.size() ); + pAccelerationStructures = accelerationStructures_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWriteDescriptorSetAccelerationStructureKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetAccelerationStructureKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetAccelerationStructureKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetAccelerationStructureKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( WriteDescriptorSetAccelerationStructureKHR const & ) const = default; +#else + bool operator==( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureCount == rhs.accelerationStructureCount ) && + ( pAccelerationStructures == rhs.pAccelerationStructures ); +# endif + } + + bool operator!=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureKHR; + const void * pNext = {}; + uint32_t accelerationStructureCount = {}; + const AccelerationStructureKHR * pAccelerationStructures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = WriteDescriptorSetAccelerationStructureKHR; + }; +#endif + + template <> + struct CppType + { + using Type = WriteDescriptorSetAccelerationStructureKHR; + }; + + // wrapper struct for struct VkWriteDescriptorSetAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSetAccelerationStructureNV.html + struct WriteDescriptorSetAccelerationStructureNV + { + using NativeType = VkWriteDescriptorSetAccelerationStructureNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetAccelerationStructureNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = {}, + const AccelerationStructureNV * pAccelerationStructures_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , accelerationStructureCount{ accelerationStructureCount_ } + , pAccelerationStructures{ pAccelerationStructures_ } + { + } + + VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( WriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT + : WriteDescriptorSetAccelerationStructureNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSetAccelerationStructureNV( ArrayProxyNoTemporaries const & accelerationStructures_, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , accelerationStructureCount( static_cast( accelerationStructures_.size() ) ) + , pAccelerationStructures( accelerationStructures_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + WriteDescriptorSetAccelerationStructureNV & operator=( WriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + WriteDescriptorSetAccelerationStructureNV & operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV & setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructureCount = accelerationStructureCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV && setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructureCount = accelerationStructureCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV & setPAccelerationStructures( const AccelerationStructureNV * pAccelerationStructures_ ) & + VULKAN_HPP_NOEXCEPT + { + pAccelerationStructures = pAccelerationStructures_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV && + setPAccelerationStructures( const AccelerationStructureNV * pAccelerationStructures_ ) && + VULKAN_HPP_NOEXCEPT + { + pAccelerationStructures = pAccelerationStructures_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSetAccelerationStructureNV & + setAccelerationStructures( ArrayProxyNoTemporaries const & accelerationStructures_ ) VULKAN_HPP_NOEXCEPT + { + accelerationStructureCount = static_cast( accelerationStructures_.size() ); + pAccelerationStructures = accelerationStructures_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWriteDescriptorSetAccelerationStructureNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetAccelerationStructureNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetAccelerationStructureNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetAccelerationStructureNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( WriteDescriptorSetAccelerationStructureNV const & ) const = default; +#else + bool operator==( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureCount == rhs.accelerationStructureCount ) && + ( pAccelerationStructures == rhs.pAccelerationStructures ); +# endif + } + + bool operator!=( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV; + const void * pNext = {}; + uint32_t accelerationStructureCount = {}; + const AccelerationStructureNV * pAccelerationStructures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = WriteDescriptorSetAccelerationStructureNV; + }; +#endif + + template <> + struct CppType + { + using Type = WriteDescriptorSetAccelerationStructureNV; + }; + + // wrapper struct for struct VkWriteDescriptorSetInlineUniformBlock, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSetInlineUniformBlock.html + struct WriteDescriptorSetInlineUniformBlock + { + using NativeType = VkWriteDescriptorSetInlineUniformBlock; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetInlineUniformBlock; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + WriteDescriptorSetInlineUniformBlock( uint32_t dataSize_ = {}, const void * pData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , dataSize{ dataSize_ } + , pData{ pData_ } + { + } + + VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlock( WriteDescriptorSetInlineUniformBlock const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + WriteDescriptorSetInlineUniformBlock( VkWriteDescriptorSetInlineUniformBlock const & rhs ) VULKAN_HPP_NOEXCEPT + : WriteDescriptorSetInlineUniformBlock( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + WriteDescriptorSetInlineUniformBlock( ArrayProxyNoTemporaries const & data_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), dataSize( static_cast( data_.size() * sizeof( T ) ) ), pData( data_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + WriteDescriptorSetInlineUniformBlock & operator=( WriteDescriptorSetInlineUniformBlock const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + WriteDescriptorSetInlineUniformBlock & operator=( VkWriteDescriptorSetInlineUniformBlock const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock & setDataSize( uint32_t dataSize_ ) & VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock && setDataSize( uint32_t dataSize_ ) && VULKAN_HPP_NOEXCEPT + { + dataSize = dataSize_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock & setPData( const void * pData_ ) & VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock && setPData( const void * pData_ ) && VULKAN_HPP_NOEXCEPT + { + pData = pData_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + WriteDescriptorSetInlineUniformBlock & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT + { + dataSize = static_cast( data_.size() * sizeof( T ) ); + pData = data_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWriteDescriptorSetInlineUniformBlock const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetInlineUniformBlock &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetInlineUniformBlock const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetInlineUniformBlock *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, dataSize, pData ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( WriteDescriptorSetInlineUniformBlock const & ) const = default; +#else + bool operator==( WriteDescriptorSetInlineUniformBlock const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); +# endif + } + + bool operator!=( WriteDescriptorSetInlineUniformBlock const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlock; + const void * pNext = {}; + uint32_t dataSize = {}; + const void * pData = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = WriteDescriptorSetInlineUniformBlock; + }; +#endif + + template <> + struct CppType + { + using Type = WriteDescriptorSetInlineUniformBlock; + }; + + using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock; + + // wrapper struct for struct VkWriteDescriptorSetPartitionedAccelerationStructureNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSetPartitionedAccelerationStructureNV.html + struct WriteDescriptorSetPartitionedAccelerationStructureNV + { + using NativeType = VkWriteDescriptorSetPartitionedAccelerationStructureNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetPartitionedAccelerationStructureNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR WriteDescriptorSetPartitionedAccelerationStructureNV( uint32_t accelerationStructureCount_ = {}, + const DeviceAddress * pAccelerationStructures_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , accelerationStructureCount{ accelerationStructureCount_ } + , pAccelerationStructures{ pAccelerationStructures_ } + { + } + + VULKAN_HPP_CONSTEXPR + WriteDescriptorSetPartitionedAccelerationStructureNV( WriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + WriteDescriptorSetPartitionedAccelerationStructureNV( VkWriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT + : WriteDescriptorSetPartitionedAccelerationStructureNV( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSetPartitionedAccelerationStructureNV( ArrayProxyNoTemporaries const & accelerationStructures_, + void * pNext_ = nullptr ) + : pNext( pNext_ ) + , accelerationStructureCount( static_cast( accelerationStructures_.size() ) ) + , pAccelerationStructures( accelerationStructures_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + WriteDescriptorSetPartitionedAccelerationStructureNV & + operator=( WriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + WriteDescriptorSetPartitionedAccelerationStructureNV & operator=( VkWriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV & setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) & + VULKAN_HPP_NOEXCEPT + { + accelerationStructureCount = accelerationStructureCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV && setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) && + VULKAN_HPP_NOEXCEPT + { + accelerationStructureCount = accelerationStructureCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV & + setPAccelerationStructures( const DeviceAddress * pAccelerationStructures_ ) & + VULKAN_HPP_NOEXCEPT + { + pAccelerationStructures = pAccelerationStructures_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV && + setPAccelerationStructures( const DeviceAddress * pAccelerationStructures_ ) && + VULKAN_HPP_NOEXCEPT + { + pAccelerationStructures = pAccelerationStructures_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSetPartitionedAccelerationStructureNV & + setAccelerationStructures( ArrayProxyNoTemporaries const & accelerationStructures_ ) VULKAN_HPP_NOEXCEPT + { + accelerationStructureCount = static_cast( accelerationStructures_.size() ); + pAccelerationStructures = accelerationStructures_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWriteDescriptorSetPartitionedAccelerationStructureNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetPartitionedAccelerationStructureNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetPartitionedAccelerationStructureNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetPartitionedAccelerationStructureNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( WriteDescriptorSetPartitionedAccelerationStructureNV const & ) const = default; +#else + bool operator==( WriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureCount == rhs.accelerationStructureCount ) && + ( pAccelerationStructures == rhs.pAccelerationStructures ); +# endif + } + + bool operator!=( WriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eWriteDescriptorSetPartitionedAccelerationStructureNV; + void * pNext = {}; + uint32_t accelerationStructureCount = {}; + const DeviceAddress * pAccelerationStructures = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = WriteDescriptorSetPartitionedAccelerationStructureNV; + }; +#endif + + template <> + struct CppType + { + using Type = WriteDescriptorSetPartitionedAccelerationStructureNV; + }; + + // wrapper struct for struct VkWriteDescriptorSetTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSetTensorARM.html + struct WriteDescriptorSetTensorARM + { + using NativeType = VkWriteDescriptorSetTensorARM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetTensorARM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + WriteDescriptorSetTensorARM( uint32_t tensorViewCount_ = {}, const TensorViewARM * pTensorViews_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tensorViewCount{ tensorViewCount_ } + , pTensorViews{ pTensorViews_ } + { + } + + VULKAN_HPP_CONSTEXPR WriteDescriptorSetTensorARM( WriteDescriptorSetTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + WriteDescriptorSetTensorARM( VkWriteDescriptorSetTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT + : WriteDescriptorSetTensorARM( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSetTensorARM( ArrayProxyNoTemporaries const & tensorViews_, const void * pNext_ = nullptr ) + : pNext( pNext_ ), tensorViewCount( static_cast( tensorViews_.size() ) ), pTensorViews( tensorViews_.data() ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + WriteDescriptorSetTensorARM & operator=( WriteDescriptorSetTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + WriteDescriptorSetTensorARM & operator=( VkWriteDescriptorSetTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM & setTensorViewCount( uint32_t tensorViewCount_ ) & VULKAN_HPP_NOEXCEPT + { + tensorViewCount = tensorViewCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM && setTensorViewCount( uint32_t tensorViewCount_ ) && VULKAN_HPP_NOEXCEPT + { + tensorViewCount = tensorViewCount_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM & setPTensorViews( const TensorViewARM * pTensorViews_ ) & VULKAN_HPP_NOEXCEPT + { + pTensorViews = pTensorViews_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM && setPTensorViews( const TensorViewARM * pTensorViews_ ) && VULKAN_HPP_NOEXCEPT + { + pTensorViews = pTensorViews_; + return std::move( *this ); + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + WriteDescriptorSetTensorARM & setTensorViews( ArrayProxyNoTemporaries const & tensorViews_ ) VULKAN_HPP_NOEXCEPT + { + tensorViewCount = static_cast( tensorViews_.size() ); + pTensorViews = tensorViews_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWriteDescriptorSetTensorARM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetTensorARM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetTensorARM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWriteDescriptorSetTensorARM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, tensorViewCount, pTensorViews ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( WriteDescriptorSetTensorARM const & ) const = default; +#else + bool operator==( WriteDescriptorSetTensorARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorViewCount == rhs.tensorViewCount ) && ( pTensorViews == rhs.pTensorViews ); +# endif + } + + bool operator!=( WriteDescriptorSetTensorARM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eWriteDescriptorSetTensorARM; + const void * pNext = {}; + uint32_t tensorViewCount = {}; + const TensorViewARM * pTensorViews = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = WriteDescriptorSetTensorARM; + }; +#endif + + template <> + struct CppType + { + using Type = WriteDescriptorSetTensorARM; + }; + + // wrapper struct for struct VkWriteIndirectExecutionSetPipelineEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteIndirectExecutionSetPipelineEXT.html + struct WriteIndirectExecutionSetPipelineEXT + { + using NativeType = VkWriteIndirectExecutionSetPipelineEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteIndirectExecutionSetPipelineEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR + WriteIndirectExecutionSetPipelineEXT( uint32_t index_ = {}, Pipeline pipeline_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , index{ index_ } + , pipeline{ pipeline_ } + { + } + + VULKAN_HPP_CONSTEXPR WriteIndirectExecutionSetPipelineEXT( WriteIndirectExecutionSetPipelineEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + WriteIndirectExecutionSetPipelineEXT( VkWriteIndirectExecutionSetPipelineEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : WriteIndirectExecutionSetPipelineEXT( *reinterpret_cast( &rhs ) ) + { + } + + WriteIndirectExecutionSetPipelineEXT & operator=( WriteIndirectExecutionSetPipelineEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + WriteIndirectExecutionSetPipelineEXT & operator=( VkWriteIndirectExecutionSetPipelineEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT + { + index = index_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT + { + index = index_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT + { + pipeline = pipeline_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWriteIndirectExecutionSetPipelineEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteIndirectExecutionSetPipelineEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteIndirectExecutionSetPipelineEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWriteIndirectExecutionSetPipelineEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, index, pipeline ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( WriteIndirectExecutionSetPipelineEXT const & ) const = default; +#else + bool operator==( WriteIndirectExecutionSetPipelineEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( index == rhs.index ) && ( pipeline == rhs.pipeline ); +# endif + } + + bool operator!=( WriteIndirectExecutionSetPipelineEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eWriteIndirectExecutionSetPipelineEXT; + const void * pNext = {}; + uint32_t index = {}; + Pipeline pipeline = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = WriteIndirectExecutionSetPipelineEXT; + }; +#endif + + template <> + struct CppType + { + using Type = WriteIndirectExecutionSetPipelineEXT; + }; + + // wrapper struct for struct VkWriteIndirectExecutionSetShaderEXT, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteIndirectExecutionSetShaderEXT.html + struct WriteIndirectExecutionSetShaderEXT + { + using NativeType = VkWriteIndirectExecutionSetShaderEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteIndirectExecutionSetShaderEXT; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR WriteIndirectExecutionSetShaderEXT( uint32_t index_ = {}, ShaderEXT shader_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , index{ index_ } + , shader{ shader_ } + { + } + + VULKAN_HPP_CONSTEXPR WriteIndirectExecutionSetShaderEXT( WriteIndirectExecutionSetShaderEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + WriteIndirectExecutionSetShaderEXT( VkWriteIndirectExecutionSetShaderEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : WriteIndirectExecutionSetShaderEXT( *reinterpret_cast( &rhs ) ) + { + } + + WriteIndirectExecutionSetShaderEXT & operator=( WriteIndirectExecutionSetShaderEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + WriteIndirectExecutionSetShaderEXT & operator=( VkWriteIndirectExecutionSetShaderEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT + { + index = index_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT + { + index = index_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT & setShader( ShaderEXT shader_ ) & VULKAN_HPP_NOEXCEPT + { + shader = shader_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT && setShader( ShaderEXT shader_ ) && VULKAN_HPP_NOEXCEPT + { + shader = shader_; + return std::move( *this ); + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkWriteIndirectExecutionSetShaderEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteIndirectExecutionSetShaderEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkWriteIndirectExecutionSetShaderEXT const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkWriteIndirectExecutionSetShaderEXT *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, index, shader ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( WriteIndirectExecutionSetShaderEXT const & ) const = default; +#else + bool operator==( WriteIndirectExecutionSetShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( index == rhs.index ) && ( shader == rhs.shader ); +# endif + } + + bool operator!=( WriteIndirectExecutionSetShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + StructureType sType = StructureType::eWriteIndirectExecutionSetShaderEXT; + const void * pNext = {}; + uint32_t index = {}; + ShaderEXT shader = {}; + }; + +#if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = WriteIndirectExecutionSetShaderEXT; + }; +#endif + + template <> + struct CppType + { + using Type = WriteIndirectExecutionSetShaderEXT; + }; + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + // wrapper struct for struct VkXcbSurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXcbSurfaceCreateInfoKHR.html + struct XcbSurfaceCreateInfoKHR + { + using NativeType = VkXcbSurfaceCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eXcbSurfaceCreateInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = {}, + xcb_connection_t * connection_ = {}, + xcb_window_t window_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , connection{ connection_ } + , window{ window_ } + { + } + + VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( XcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : XcbSurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + XcbSurfaceCreateInfoKHR & operator=( XcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + XcbSurfaceCreateInfoKHR & operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR & setFlags( XcbSurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR && setFlags( XcbSurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR & setConnection( xcb_connection_t * connection_ ) & VULKAN_HPP_NOEXCEPT + { + connection = connection_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR && setConnection( xcb_connection_t * connection_ ) && VULKAN_HPP_NOEXCEPT + { + connection = connection_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR & setWindow( xcb_window_t window_ ) & VULKAN_HPP_NOEXCEPT + { + window = window_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR && setWindow( xcb_window_t window_ ) && VULKAN_HPP_NOEXCEPT + { + window = window_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkXcbSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkXcbSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkXcbSurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkXcbSurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, connection, window ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = connection <=> rhs.connection; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &window, &rhs.window, sizeof( xcb_window_t ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( connection == rhs.connection ) && + ( memcmp( &window, &rhs.window, sizeof( xcb_window_t ) ) == 0 ); + } + + bool operator!=( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR; + const void * pNext = {}; + XcbSurfaceCreateFlagsKHR flags = {}; + xcb_connection_t * connection = {}; + xcb_window_t window = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = XcbSurfaceCreateInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = XcbSurfaceCreateInfoKHR; + }; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + // wrapper struct for struct VkXlibSurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXlibSurfaceCreateInfoKHR.html + struct XlibSurfaceCreateInfoKHR + { + using NativeType = VkXlibSurfaceCreateInfoKHR; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eXlibSurfaceCreateInfoKHR; + +# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = {}, + Display * dpy_ = {}, + Window window_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , dpy{ dpy_ } + , window{ window_ } + { + } + + VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( XlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + : XlibSurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) + { + } + + XlibSurfaceCreateInfoKHR & operator=( XlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; +# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + XlibSurfaceCreateInfoKHR & operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR & setFlags( XlibSurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR && setFlags( XlibSurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR & setDpy( Display * dpy_ ) & VULKAN_HPP_NOEXCEPT + { + dpy = dpy_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR && setDpy( Display * dpy_ ) && VULKAN_HPP_NOEXCEPT + { + dpy = dpy_; + return std::move( *this ); + } + + VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR & setWindow( Window window_ ) & VULKAN_HPP_NOEXCEPT + { + window = window_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR && setWindow( Window window_ ) && VULKAN_HPP_NOEXCEPT + { + window = window_; + return std::move( *this ); + } +# endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkXlibSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkXlibSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkXlibSurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkXlibSurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +# if defined( VULKAN_HPP_USE_REFLECT ) + std::tuple + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, dpy, window ); + } +# endif + +# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = dpy <=> rhs.dpy; cmp != 0 ) + return cmp; + if ( auto cmp = memcmp( &window, &rhs.window, sizeof( Window ) ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + + return std::strong_ordering::equivalent; + } +# endif + + bool operator==( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dpy == rhs.dpy ) && + ( memcmp( &window, &rhs.window, sizeof( Window ) ) == 0 ); + } + + bool operator!=( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR; + const void * pNext = {}; + XlibSurfaceCreateFlagsKHR flags = {}; + Display * dpy = {}; + Window window = {}; + }; + +# if 20 <= VULKAN_HPP_CPP_VERSION + template <> + struct CppType + { + using Type = XlibSurfaceCreateInfoKHR; + }; +# endif + + template <> + struct CppType + { + using Type = XlibSurfaceCreateInfoKHR; + }; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +} // namespace VULKAN_HPP_NAMESPACE +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_to_string.hpp b/lib/vulkan-headers/include/vulkan/vulkan_to_string.hpp new file mode 100644 index 00000000000..c14d520fa3a --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_to_string.hpp @@ -0,0 +1,11091 @@ +// Copyright 2015-2026 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_TO_STRING_HPP +#define VULKAN_TO_STRING_HPP + +#if !defined( VULKAN_HPP_CXX_MODULE ) +# include +#endif + +// ignore warnings on using deprecated enum values in this header +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wdeprecated-declarations" +#elif defined( _MSC_VER ) +# pragma warning( push ) +# pragma warning( disable : 4996 ) +#endif + +#if !defined( VULKAN_HPP_CXX_MODULE ) +# if defined( __cpp_lib_format ) +# include // std::format +# else +# include // std::stringstream +# endif +#endif + +namespace VULKAN_HPP_NAMESPACE +{ + + //========================== + //=== BITMASKs to_string === + //========================== + + //=== VK_VERSION_1_0 === + + VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags value ) + { + std::string result = "{"; + if ( value & FormatFeatureFlagBits::eSampledImage ) + result += " SampledImage |"; + if ( value & FormatFeatureFlagBits::eStorageImage ) + result += " StorageImage |"; + if ( value & FormatFeatureFlagBits::eStorageImageAtomic ) + result += " StorageImageAtomic |"; + if ( value & FormatFeatureFlagBits::eUniformTexelBuffer ) + result += " UniformTexelBuffer |"; + if ( value & FormatFeatureFlagBits::eStorageTexelBuffer ) + result += " StorageTexelBuffer |"; + if ( value & FormatFeatureFlagBits::eStorageTexelBufferAtomic ) + result += " StorageTexelBufferAtomic |"; + if ( value & FormatFeatureFlagBits::eVertexBuffer ) + result += " VertexBuffer |"; + if ( value & FormatFeatureFlagBits::eColorAttachment ) + result += " ColorAttachment |"; + if ( value & FormatFeatureFlagBits::eColorAttachmentBlend ) + result += " ColorAttachmentBlend |"; + if ( value & FormatFeatureFlagBits::eDepthStencilAttachment ) + result += " DepthStencilAttachment |"; + if ( value & FormatFeatureFlagBits::eBlitSrc ) + result += " BlitSrc |"; + if ( value & FormatFeatureFlagBits::eBlitDst ) + result += " BlitDst |"; + if ( value & FormatFeatureFlagBits::eSampledImageFilterLinear ) + result += " SampledImageFilterLinear |"; + if ( value & FormatFeatureFlagBits::eTransferSrc ) + result += " TransferSrc |"; + if ( value & FormatFeatureFlagBits::eTransferDst ) + result += " TransferDst |"; + if ( value & FormatFeatureFlagBits::eMidpointChromaSamples ) + result += " MidpointChromaSamples |"; + if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter ) + result += " SampledImageYcbcrConversionLinearFilter |"; + if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter ) + result += " SampledImageYcbcrConversionSeparateReconstructionFilter |"; + if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit ) + result += " SampledImageYcbcrConversionChromaReconstructionExplicit |"; + if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable ) + result += " SampledImageYcbcrConversionChromaReconstructionExplicitForceable |"; + if ( value & FormatFeatureFlagBits::eDisjoint ) + result += " Disjoint |"; + if ( value & FormatFeatureFlagBits::eCositedChromaSamples ) + result += " CositedChromaSamples |"; + if ( value & FormatFeatureFlagBits::eSampledImageFilterMinmax ) + result += " SampledImageFilterMinmax |"; + if ( value & FormatFeatureFlagBits::eVideoDecodeOutputKHR ) + result += " VideoDecodeOutputKHR |"; + if ( value & FormatFeatureFlagBits::eVideoDecodeDpbKHR ) + result += " VideoDecodeDpbKHR |"; + if ( value & FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR ) + result += " AccelerationStructureVertexBufferKHR |"; + if ( value & FormatFeatureFlagBits::eSampledImageFilterCubicEXT ) + result += " SampledImageFilterCubicEXT |"; + if ( value & FormatFeatureFlagBits::eFragmentDensityMapEXT ) + result += " FragmentDensityMapEXT |"; + if ( value & FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR ) + result += " FragmentShadingRateAttachmentKHR |"; + if ( value & FormatFeatureFlagBits::eVideoEncodeInputKHR ) + result += " VideoEncodeInputKHR |"; + if ( value & FormatFeatureFlagBits::eVideoEncodeDpbKHR ) + result += " VideoEncodeDpbKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ImageCreateFlags value ) + { + std::string result = "{"; + if ( value & ImageCreateFlagBits::eSparseBinding ) + result += " SparseBinding |"; + if ( value & ImageCreateFlagBits::eSparseResidency ) + result += " SparseResidency |"; + if ( value & ImageCreateFlagBits::eSparseAliased ) + result += " SparseAliased |"; + if ( value & ImageCreateFlagBits::eMutableFormat ) + result += " MutableFormat |"; + if ( value & ImageCreateFlagBits::eCubeCompatible ) + result += " CubeCompatible |"; + if ( value & ImageCreateFlagBits::eAlias ) + result += " Alias |"; + if ( value & ImageCreateFlagBits::eSplitInstanceBindRegions ) + result += " SplitInstanceBindRegions |"; + if ( value & ImageCreateFlagBits::e2DArrayCompatible ) + result += " 2DArrayCompatible |"; + if ( value & ImageCreateFlagBits::eBlockTexelViewCompatible ) + result += " BlockTexelViewCompatible |"; + if ( value & ImageCreateFlagBits::eExtendedUsage ) + result += " ExtendedUsage |"; + if ( value & ImageCreateFlagBits::eProtected ) + result += " Protected |"; + if ( value & ImageCreateFlagBits::eDisjoint ) + result += " Disjoint |"; + if ( value & ImageCreateFlagBits::eCornerSampledNV ) + result += " CornerSampledNV |"; + if ( value & ImageCreateFlagBits::eDescriptorHeapCaptureReplayEXT ) + result += " DescriptorHeapCaptureReplayEXT |"; + if ( value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT ) + result += " SampleLocationsCompatibleDepthEXT |"; + if ( value & ImageCreateFlagBits::eSubsampledEXT ) + result += " SubsampledEXT |"; + if ( value & ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT ) + result += " MultisampledRenderToSingleSampledEXT |"; + if ( value & ImageCreateFlagBits::e2DViewCompatibleEXT ) + result += " 2DViewCompatibleEXT |"; + if ( value & ImageCreateFlagBits::eVideoProfileIndependentKHR ) + result += " VideoProfileIndependentKHR |"; + if ( value & ImageCreateFlagBits::eFragmentDensityMapOffsetEXT ) + result += " FragmentDensityMapOffsetEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ImageUsageFlags value ) + { + std::string result = "{"; + if ( value & ImageUsageFlagBits::eTransferSrc ) + result += " TransferSrc |"; + if ( value & ImageUsageFlagBits::eTransferDst ) + result += " TransferDst |"; + if ( value & ImageUsageFlagBits::eSampled ) + result += " Sampled |"; + if ( value & ImageUsageFlagBits::eStorage ) + result += " Storage |"; + if ( value & ImageUsageFlagBits::eColorAttachment ) + result += " ColorAttachment |"; + if ( value & ImageUsageFlagBits::eDepthStencilAttachment ) + result += " DepthStencilAttachment |"; + if ( value & ImageUsageFlagBits::eTransientAttachment ) + result += " TransientAttachment |"; + if ( value & ImageUsageFlagBits::eInputAttachment ) + result += " InputAttachment |"; + if ( value & ImageUsageFlagBits::eHostTransfer ) + result += " HostTransfer |"; + if ( value & ImageUsageFlagBits::eVideoDecodeDstKHR ) + result += " VideoDecodeDstKHR |"; + if ( value & ImageUsageFlagBits::eVideoDecodeSrcKHR ) + result += " VideoDecodeSrcKHR |"; + if ( value & ImageUsageFlagBits::eVideoDecodeDpbKHR ) + result += " VideoDecodeDpbKHR |"; + if ( value & ImageUsageFlagBits::eFragmentDensityMapEXT ) + result += " FragmentDensityMapEXT |"; + if ( value & ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR ) + result += " FragmentShadingRateAttachmentKHR |"; + if ( value & ImageUsageFlagBits::eVideoEncodeDstKHR ) + result += " VideoEncodeDstKHR |"; + if ( value & ImageUsageFlagBits::eVideoEncodeSrcKHR ) + result += " VideoEncodeSrcKHR |"; + if ( value & ImageUsageFlagBits::eVideoEncodeDpbKHR ) + result += " VideoEncodeDpbKHR |"; + if ( value & ImageUsageFlagBits::eAttachmentFeedbackLoopEXT ) + result += " AttachmentFeedbackLoopEXT |"; + if ( value & ImageUsageFlagBits::eInvocationMaskHUAWEI ) + result += " InvocationMaskHUAWEI |"; + if ( value & ImageUsageFlagBits::eSampleWeightQCOM ) + result += " SampleWeightQCOM |"; + if ( value & ImageUsageFlagBits::eSampleBlockMatchQCOM ) + result += " SampleBlockMatchQCOM |"; + if ( value & ImageUsageFlagBits::eTensorAliasingARM ) + result += " TensorAliasingARM |"; + if ( value & ImageUsageFlagBits::eTileMemoryQCOM ) + result += " TileMemoryQCOM |"; + if ( value & ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR ) + result += " VideoEncodeQuantizationDeltaMapKHR |"; + if ( value & ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR ) + result += " VideoEncodeEmphasisMapKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlags value ) + { + std::string result = "{"; + if ( value & InstanceCreateFlagBits::eEnumeratePortabilityKHR ) + result += " EnumeratePortabilityKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlags value ) + { + std::string result = "{"; + if ( value & MemoryHeapFlagBits::eDeviceLocal ) + result += " DeviceLocal |"; + if ( value & MemoryHeapFlagBits::eMultiInstance ) + result += " MultiInstance |"; + if ( value & MemoryHeapFlagBits::eTileMemoryQCOM ) + result += " TileMemoryQCOM |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlags value ) + { + std::string result = "{"; + if ( value & MemoryPropertyFlagBits::eDeviceLocal ) + result += " DeviceLocal |"; + if ( value & MemoryPropertyFlagBits::eHostVisible ) + result += " HostVisible |"; + if ( value & MemoryPropertyFlagBits::eHostCoherent ) + result += " HostCoherent |"; + if ( value & MemoryPropertyFlagBits::eHostCached ) + result += " HostCached |"; + if ( value & MemoryPropertyFlagBits::eLazilyAllocated ) + result += " LazilyAllocated |"; + if ( value & MemoryPropertyFlagBits::eProtected ) + result += " Protected |"; + if ( value & MemoryPropertyFlagBits::eDeviceCoherentAMD ) + result += " DeviceCoherentAMD |"; + if ( value & MemoryPropertyFlagBits::eDeviceUncachedAMD ) + result += " DeviceUncachedAMD |"; + if ( value & MemoryPropertyFlagBits::eRdmaCapableNV ) + result += " RdmaCapableNV |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( QueueFlags value ) + { + std::string result = "{"; + if ( value & QueueFlagBits::eGraphics ) + result += " Graphics |"; + if ( value & QueueFlagBits::eCompute ) + result += " Compute |"; + if ( value & QueueFlagBits::eTransfer ) + result += " Transfer |"; + if ( value & QueueFlagBits::eSparseBinding ) + result += " SparseBinding |"; + if ( value & QueueFlagBits::eProtected ) + result += " Protected |"; + if ( value & QueueFlagBits::eVideoDecodeKHR ) + result += " VideoDecodeKHR |"; + if ( value & QueueFlagBits::eVideoEncodeKHR ) + result += " VideoEncodeKHR |"; + if ( value & QueueFlagBits::eOpticalFlowNV ) + result += " OpticalFlowNV |"; + if ( value & QueueFlagBits::eDataGraphARM ) + result += " DataGraphARM |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( SampleCountFlags value ) + { + std::string result = "{"; + if ( value & SampleCountFlagBits::e1 ) + result += " 1 |"; + if ( value & SampleCountFlagBits::e2 ) + result += " 2 |"; + if ( value & SampleCountFlagBits::e4 ) + result += " 4 |"; + if ( value & SampleCountFlagBits::e8 ) + result += " 8 |"; + if ( value & SampleCountFlagBits::e16 ) + result += " 16 |"; + if ( value & SampleCountFlagBits::e32 ) + result += " 32 |"; + if ( value & SampleCountFlagBits::e64 ) + result += " 64 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlags value ) + { + std::string result = "{"; + if ( value & DeviceQueueCreateFlagBits::eProtected ) + result += " Protected |"; + if ( value & DeviceQueueCreateFlagBits::eInternallySynchronizedKHR ) + result += " InternallySynchronizedKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags value ) + { + std::string result = "{"; + if ( value & PipelineStageFlagBits::eTopOfPipe ) + result += " TopOfPipe |"; + if ( value & PipelineStageFlagBits::eDrawIndirect ) + result += " DrawIndirect |"; + if ( value & PipelineStageFlagBits::eVertexInput ) + result += " VertexInput |"; + if ( value & PipelineStageFlagBits::eVertexShader ) + result += " VertexShader |"; + if ( value & PipelineStageFlagBits::eTessellationControlShader ) + result += " TessellationControlShader |"; + if ( value & PipelineStageFlagBits::eTessellationEvaluationShader ) + result += " TessellationEvaluationShader |"; + if ( value & PipelineStageFlagBits::eGeometryShader ) + result += " GeometryShader |"; + if ( value & PipelineStageFlagBits::eFragmentShader ) + result += " FragmentShader |"; + if ( value & PipelineStageFlagBits::eEarlyFragmentTests ) + result += " EarlyFragmentTests |"; + if ( value & PipelineStageFlagBits::eLateFragmentTests ) + result += " LateFragmentTests |"; + if ( value & PipelineStageFlagBits::eColorAttachmentOutput ) + result += " ColorAttachmentOutput |"; + if ( value & PipelineStageFlagBits::eComputeShader ) + result += " ComputeShader |"; + if ( value & PipelineStageFlagBits::eTransfer ) + result += " Transfer |"; + if ( value & PipelineStageFlagBits::eBottomOfPipe ) + result += " BottomOfPipe |"; + if ( value & PipelineStageFlagBits::eHost ) + result += " Host |"; + if ( value & PipelineStageFlagBits::eAllGraphics ) + result += " AllGraphics |"; + if ( value & PipelineStageFlagBits::eAllCommands ) + result += " AllCommands |"; + if ( value & PipelineStageFlagBits::eTransformFeedbackEXT ) + result += " TransformFeedbackEXT |"; + if ( value & PipelineStageFlagBits::eConditionalRenderingEXT ) + result += " ConditionalRenderingEXT |"; + if ( value & PipelineStageFlagBits::eAccelerationStructureBuildKHR ) + result += " AccelerationStructureBuildKHR |"; + if ( value & PipelineStageFlagBits::eRayTracingShaderKHR ) + result += " RayTracingShaderKHR |"; + if ( value & PipelineStageFlagBits::eFragmentDensityProcessEXT ) + result += " FragmentDensityProcessEXT |"; + if ( value & PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR ) + result += " FragmentShadingRateAttachmentKHR |"; + if ( value & PipelineStageFlagBits::eTaskShaderEXT ) + result += " TaskShaderEXT |"; + if ( value & PipelineStageFlagBits::eMeshShaderEXT ) + result += " MeshShaderEXT |"; + if ( value & PipelineStageFlagBits::eCommandPreprocessEXT ) + result += " CommandPreprocessEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "None"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags value ) + { + std::string result = "{"; + if ( value & MemoryMapFlagBits::ePlacedEXT ) + result += " PlacedEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value ) + { + std::string result = "{"; + if ( value & ImageAspectFlagBits::eColor ) + result += " Color |"; + if ( value & ImageAspectFlagBits::eDepth ) + result += " Depth |"; + if ( value & ImageAspectFlagBits::eStencil ) + result += " Stencil |"; + if ( value & ImageAspectFlagBits::eMetadata ) + result += " Metadata |"; + if ( value & ImageAspectFlagBits::ePlane0 ) + result += " Plane0 |"; + if ( value & ImageAspectFlagBits::ePlane1 ) + result += " Plane1 |"; + if ( value & ImageAspectFlagBits::ePlane2 ) + result += " Plane2 |"; + if ( value & ImageAspectFlagBits::eMemoryPlane0EXT ) + result += " MemoryPlane0EXT |"; + if ( value & ImageAspectFlagBits::eMemoryPlane1EXT ) + result += " MemoryPlane1EXT |"; + if ( value & ImageAspectFlagBits::eMemoryPlane2EXT ) + result += " MemoryPlane2EXT |"; + if ( value & ImageAspectFlagBits::eMemoryPlane3EXT ) + result += " MemoryPlane3EXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "None"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( SparseImageFormatFlags value ) + { + std::string result = "{"; + if ( value & SparseImageFormatFlagBits::eSingleMiptail ) + result += " SingleMiptail |"; + if ( value & SparseImageFormatFlagBits::eAlignedMipSize ) + result += " AlignedMipSize |"; + if ( value & SparseImageFormatFlagBits::eNonstandardBlockSize ) + result += " NonstandardBlockSize |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( SparseMemoryBindFlags value ) + { + std::string result = "{"; + if ( value & SparseMemoryBindFlagBits::eMetadata ) + result += " Metadata |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( FenceCreateFlags value ) + { + std::string result = "{"; + if ( value & FenceCreateFlagBits::eSignaled ) + result += " Signaled |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlags value ) + { + std::string result = "{"; + if ( value & QueryPoolCreateFlagBits::eResetKHR ) + result += " ResetKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( QueryResultFlags value ) + { + std::string result = "{"; + if ( value & QueryResultFlagBits::e64 ) + result += " 64 |"; + if ( value & QueryResultFlagBits::eWait ) + result += " Wait |"; + if ( value & QueryResultFlagBits::eWithAvailability ) + result += " WithAvailability |"; + if ( value & QueryResultFlagBits::ePartial ) + result += " Partial |"; + if ( value & QueryResultFlagBits::eWithStatusKHR ) + result += " WithStatusKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( BufferCreateFlags value ) + { + std::string result = "{"; + if ( value & BufferCreateFlagBits::eSparseBinding ) + result += " SparseBinding |"; + if ( value & BufferCreateFlagBits::eSparseResidency ) + result += " SparseResidency |"; + if ( value & BufferCreateFlagBits::eSparseAliased ) + result += " SparseAliased |"; + if ( value & BufferCreateFlagBits::eProtected ) + result += " Protected |"; + if ( value & BufferCreateFlagBits::eDeviceAddressCaptureReplay ) + result += " DeviceAddressCaptureReplay |"; + if ( value & BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT ) + result += " DescriptorBufferCaptureReplayEXT |"; + if ( value & BufferCreateFlagBits::eVideoProfileIndependentKHR ) + result += " VideoProfileIndependentKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags value ) + { + std::string result = "{"; + if ( value & BufferUsageFlagBits::eTransferSrc ) + result += " TransferSrc |"; + if ( value & BufferUsageFlagBits::eTransferDst ) + result += " TransferDst |"; + if ( value & BufferUsageFlagBits::eUniformTexelBuffer ) + result += " UniformTexelBuffer |"; + if ( value & BufferUsageFlagBits::eStorageTexelBuffer ) + result += " StorageTexelBuffer |"; + if ( value & BufferUsageFlagBits::eUniformBuffer ) + result += " UniformBuffer |"; + if ( value & BufferUsageFlagBits::eStorageBuffer ) + result += " StorageBuffer |"; + if ( value & BufferUsageFlagBits::eIndexBuffer ) + result += " IndexBuffer |"; + if ( value & BufferUsageFlagBits::eVertexBuffer ) + result += " VertexBuffer |"; + if ( value & BufferUsageFlagBits::eIndirectBuffer ) + result += " IndirectBuffer |"; + if ( value & BufferUsageFlagBits::eShaderDeviceAddress ) + result += " ShaderDeviceAddress |"; + if ( value & BufferUsageFlagBits::eVideoDecodeSrcKHR ) + result += " VideoDecodeSrcKHR |"; + if ( value & BufferUsageFlagBits::eVideoDecodeDstKHR ) + result += " VideoDecodeDstKHR |"; + if ( value & BufferUsageFlagBits::eTransformFeedbackBufferEXT ) + result += " TransformFeedbackBufferEXT |"; + if ( value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT ) + result += " TransformFeedbackCounterBufferEXT |"; + if ( value & BufferUsageFlagBits::eConditionalRenderingEXT ) + result += " ConditionalRenderingEXT |"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + if ( value & BufferUsageFlagBits::eExecutionGraphScratchAMDX ) + result += " ExecutionGraphScratchAMDX |"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + if ( value & BufferUsageFlagBits::eDescriptorHeapEXT ) + result += " DescriptorHeapEXT |"; + if ( value & BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR ) + result += " AccelerationStructureBuildInputReadOnlyKHR |"; + if ( value & BufferUsageFlagBits::eAccelerationStructureStorageKHR ) + result += " AccelerationStructureStorageKHR |"; + if ( value & BufferUsageFlagBits::eShaderBindingTableKHR ) + result += " ShaderBindingTableKHR |"; + if ( value & BufferUsageFlagBits::eVideoEncodeDstKHR ) + result += " VideoEncodeDstKHR |"; + if ( value & BufferUsageFlagBits::eVideoEncodeSrcKHR ) + result += " VideoEncodeSrcKHR |"; + if ( value & BufferUsageFlagBits::eSamplerDescriptorBufferEXT ) + result += " SamplerDescriptorBufferEXT |"; + if ( value & BufferUsageFlagBits::eResourceDescriptorBufferEXT ) + result += " ResourceDescriptorBufferEXT |"; + if ( value & BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT ) + result += " PushDescriptorsDescriptorBufferEXT |"; + if ( value & BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT ) + result += " MicromapBuildInputReadOnlyEXT |"; + if ( value & BufferUsageFlagBits::eMicromapStorageEXT ) + result += " MicromapStorageEXT |"; + if ( value & BufferUsageFlagBits::eTileMemoryQCOM ) + result += " TileMemoryQCOM |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlags value ) + { + std::string result = "{"; + if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT ) + result += " FragmentDensityMapDynamicEXT |"; + if ( value & ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT ) + result += " DescriptorBufferCaptureReplayEXT |"; + if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT ) + result += " FragmentDensityMapDeferredEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( AccessFlags value ) + { + std::string result = "{"; + if ( value & AccessFlagBits::eIndirectCommandRead ) + result += " IndirectCommandRead |"; + if ( value & AccessFlagBits::eIndexRead ) + result += " IndexRead |"; + if ( value & AccessFlagBits::eVertexAttributeRead ) + result += " VertexAttributeRead |"; + if ( value & AccessFlagBits::eUniformRead ) + result += " UniformRead |"; + if ( value & AccessFlagBits::eInputAttachmentRead ) + result += " InputAttachmentRead |"; + if ( value & AccessFlagBits::eShaderRead ) + result += " ShaderRead |"; + if ( value & AccessFlagBits::eShaderWrite ) + result += " ShaderWrite |"; + if ( value & AccessFlagBits::eColorAttachmentRead ) + result += " ColorAttachmentRead |"; + if ( value & AccessFlagBits::eColorAttachmentWrite ) + result += " ColorAttachmentWrite |"; + if ( value & AccessFlagBits::eDepthStencilAttachmentRead ) + result += " DepthStencilAttachmentRead |"; + if ( value & AccessFlagBits::eDepthStencilAttachmentWrite ) + result += " DepthStencilAttachmentWrite |"; + if ( value & AccessFlagBits::eTransferRead ) + result += " TransferRead |"; + if ( value & AccessFlagBits::eTransferWrite ) + result += " TransferWrite |"; + if ( value & AccessFlagBits::eHostRead ) + result += " HostRead |"; + if ( value & AccessFlagBits::eHostWrite ) + result += " HostWrite |"; + if ( value & AccessFlagBits::eMemoryRead ) + result += " MemoryRead |"; + if ( value & AccessFlagBits::eMemoryWrite ) + result += " MemoryWrite |"; + if ( value & AccessFlagBits::eTransformFeedbackWriteEXT ) + result += " TransformFeedbackWriteEXT |"; + if ( value & AccessFlagBits::eTransformFeedbackCounterReadEXT ) + result += " TransformFeedbackCounterReadEXT |"; + if ( value & AccessFlagBits::eTransformFeedbackCounterWriteEXT ) + result += " TransformFeedbackCounterWriteEXT |"; + if ( value & AccessFlagBits::eConditionalRenderingReadEXT ) + result += " ConditionalRenderingReadEXT |"; + if ( value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT ) + result += " ColorAttachmentReadNoncoherentEXT |"; + if ( value & AccessFlagBits::eAccelerationStructureReadKHR ) + result += " AccelerationStructureReadKHR |"; + if ( value & AccessFlagBits::eAccelerationStructureWriteKHR ) + result += " AccelerationStructureWriteKHR |"; + if ( value & AccessFlagBits::eFragmentDensityMapReadEXT ) + result += " FragmentDensityMapReadEXT |"; + if ( value & AccessFlagBits::eFragmentShadingRateAttachmentReadKHR ) + result += " FragmentShadingRateAttachmentReadKHR |"; + if ( value & AccessFlagBits::eCommandPreprocessReadEXT ) + result += " CommandPreprocessReadEXT |"; + if ( value & AccessFlagBits::eCommandPreprocessWriteEXT ) + result += " CommandPreprocessWriteEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "None"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( DependencyFlags value ) + { + std::string result = "{"; + if ( value & DependencyFlagBits::eByRegion ) + result += " ByRegion |"; + if ( value & DependencyFlagBits::eDeviceGroup ) + result += " DeviceGroup |"; + if ( value & DependencyFlagBits::eViewLocal ) + result += " ViewLocal |"; + if ( value & DependencyFlagBits::eFeedbackLoopEXT ) + result += " FeedbackLoopEXT |"; + if ( value & DependencyFlagBits::eQueueFamilyOwnershipTransferUseAllStagesKHR ) + result += " QueueFamilyOwnershipTransferUseAllStagesKHR |"; + if ( value & DependencyFlagBits::eAsymmetricEventKHR ) + result += " AsymmetricEventKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( CommandPoolCreateFlags value ) + { + std::string result = "{"; + if ( value & CommandPoolCreateFlagBits::eTransient ) + result += " Transient |"; + if ( value & CommandPoolCreateFlagBits::eResetCommandBuffer ) + result += " ResetCommandBuffer |"; + if ( value & CommandPoolCreateFlagBits::eProtected ) + result += " Protected |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlags value ) + { + std::string result = "{"; + if ( value & CommandPoolResetFlagBits::eReleaseResources ) + result += " ReleaseResources |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlags value ) + { + std::string result = "{"; + if ( value & CommandBufferResetFlagBits::eReleaseResources ) + result += " ReleaseResources |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( CommandBufferUsageFlags value ) + { + std::string result = "{"; + if ( value & CommandBufferUsageFlagBits::eOneTimeSubmit ) + result += " OneTimeSubmit |"; + if ( value & CommandBufferUsageFlagBits::eRenderPassContinue ) + result += " RenderPassContinue |"; + if ( value & CommandBufferUsageFlagBits::eSimultaneousUse ) + result += " SimultaneousUse |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( QueryControlFlags value ) + { + std::string result = "{"; + if ( value & QueryControlFlagBits::ePrecise ) + result += " Precise |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( EventCreateFlags value ) + { + std::string result = "{"; + if ( value & EventCreateFlagBits::eDeviceOnly ) + result += " DeviceOnly |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferViewCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderModuleCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlags value ) + { + std::string result = "{"; + if ( value & PipelineCacheCreateFlagBits::eExternallySynchronized ) + result += " ExternallySynchronized |"; + if ( value & PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR ) + result += " InternallySynchronizedMergeKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags value ) + { + std::string result = "{"; + if ( value & PipelineCreateFlagBits::eDisableOptimization ) + result += " DisableOptimization |"; + if ( value & PipelineCreateFlagBits::eAllowDerivatives ) + result += " AllowDerivatives |"; + if ( value & PipelineCreateFlagBits::eDerivative ) + result += " Derivative |"; + if ( value & PipelineCreateFlagBits::eDispatchBase ) + result += " DispatchBase |"; + if ( value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex ) + result += " ViewIndexFromDeviceIndex |"; + if ( value & PipelineCreateFlagBits::eFailOnPipelineCompileRequired ) + result += " FailOnPipelineCompileRequired |"; + if ( value & PipelineCreateFlagBits::eEarlyReturnOnFailure ) + result += " EarlyReturnOnFailure |"; + if ( value & PipelineCreateFlagBits::eNoProtectedAccess ) + result += " NoProtectedAccess |"; + if ( value & PipelineCreateFlagBits::eProtectedAccessOnly ) + result += " ProtectedAccessOnly |"; + if ( value & PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR ) + result += " RayTracingNoNullAnyHitShadersKHR |"; + if ( value & PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR ) + result += " RayTracingNoNullClosestHitShadersKHR |"; + if ( value & PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR ) + result += " RayTracingNoNullMissShadersKHR |"; + if ( value & PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR ) + result += " RayTracingNoNullIntersectionShadersKHR |"; + if ( value & PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR ) + result += " RayTracingSkipTrianglesKHR |"; + if ( value & PipelineCreateFlagBits::eRayTracingSkipAabbsKHR ) + result += " RayTracingSkipAabbsKHR |"; + if ( value & PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR ) + result += " RayTracingShaderGroupHandleCaptureReplayKHR |"; + if ( value & PipelineCreateFlagBits::eDeferCompileNV ) + result += " DeferCompileNV |"; + if ( value & PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT ) + result += " RenderingFragmentDensityMapAttachmentEXT |"; + if ( value & PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR ) + result += " RenderingFragmentShadingRateAttachmentKHR |"; + if ( value & PipelineCreateFlagBits::eCaptureStatisticsKHR ) + result += " CaptureStatisticsKHR |"; + if ( value & PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR ) + result += " CaptureInternalRepresentationsKHR |"; + if ( value & PipelineCreateFlagBits::eIndirectBindableNV ) + result += " IndirectBindableNV |"; + if ( value & PipelineCreateFlagBits::eLibraryKHR ) + result += " LibraryKHR |"; + if ( value & PipelineCreateFlagBits::eDescriptorBufferEXT ) + result += " DescriptorBufferEXT |"; + if ( value & PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT ) + result += " RetainLinkTimeOptimizationInfoEXT |"; + if ( value & PipelineCreateFlagBits::eLinkTimeOptimizationEXT ) + result += " LinkTimeOptimizationEXT |"; + if ( value & PipelineCreateFlagBits::eRayTracingAllowMotionNV ) + result += " RayTracingAllowMotionNV |"; + if ( value & PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT ) + result += " ColorAttachmentFeedbackLoopEXT |"; + if ( value & PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT ) + result += " DepthStencilAttachmentFeedbackLoopEXT |"; + if ( value & PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT ) + result += " RayTracingOpacityMicromapEXT |"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + if ( value & PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV ) + result += " RayTracingDisplacementMicromapNV |"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags value ) + { + std::string result = "{"; + if ( value & PipelineLayoutCreateFlagBits::eIndependentSetsEXT ) + result += " IndependentSetsEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags value ) + { + std::string result = "{"; + if ( value & PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize ) + result += " AllowVaryingSubgroupSize |"; + if ( value & PipelineShaderStageCreateFlagBits::eRequireFullSubgroups ) + result += " RequireFullSubgroups |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ShaderStageFlags value ) + { + std::string result = "{"; + if ( value & ShaderStageFlagBits::eVertex ) + result += " Vertex |"; + if ( value & ShaderStageFlagBits::eTessellationControl ) + result += " TessellationControl |"; + if ( value & ShaderStageFlagBits::eTessellationEvaluation ) + result += " TessellationEvaluation |"; + if ( value & ShaderStageFlagBits::eGeometry ) + result += " Geometry |"; + if ( value & ShaderStageFlagBits::eFragment ) + result += " Fragment |"; + if ( value & ShaderStageFlagBits::eCompute ) + result += " Compute |"; + if ( value & ShaderStageFlagBits::eRaygenKHR ) + result += " RaygenKHR |"; + if ( value & ShaderStageFlagBits::eAnyHitKHR ) + result += " AnyHitKHR |"; + if ( value & ShaderStageFlagBits::eClosestHitKHR ) + result += " ClosestHitKHR |"; + if ( value & ShaderStageFlagBits::eMissKHR ) + result += " MissKHR |"; + if ( value & ShaderStageFlagBits::eIntersectionKHR ) + result += " IntersectionKHR |"; + if ( value & ShaderStageFlagBits::eCallableKHR ) + result += " CallableKHR |"; + if ( value & ShaderStageFlagBits::eTaskEXT ) + result += " TaskEXT |"; + if ( value & ShaderStageFlagBits::eMeshEXT ) + result += " MeshEXT |"; + if ( value & ShaderStageFlagBits::eSubpassShadingHUAWEI ) + result += " SubpassShadingHUAWEI |"; + if ( value & ShaderStageFlagBits::eClusterCullingHUAWEI ) + result += " ClusterCullingHUAWEI |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlags value ) + { + std::string result = "{"; + if ( value & SamplerCreateFlagBits::eSubsampledEXT ) + result += " SubsampledEXT |"; + if ( value & SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT ) + result += " SubsampledCoarseReconstructionEXT |"; + if ( value & SamplerCreateFlagBits::eDescriptorBufferCaptureReplayEXT ) + result += " DescriptorBufferCaptureReplayEXT |"; + if ( value & SamplerCreateFlagBits::eNonSeamlessCubeMapEXT ) + result += " NonSeamlessCubeMapEXT |"; + if ( value & SamplerCreateFlagBits::eImageProcessingQCOM ) + result += " ImageProcessingQCOM |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlags value ) + { + std::string result = "{"; + if ( value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet ) + result += " FreeDescriptorSet |"; + if ( value & DescriptorPoolCreateFlagBits::eUpdateAfterBind ) + result += " UpdateAfterBind |"; + if ( value & DescriptorPoolCreateFlagBits::eHostOnlyEXT ) + result += " HostOnlyEXT |"; + if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV ) + result += " AllowOverallocationSetsNV |"; + if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV ) + result += " AllowOverallocationPoolsNV |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorPoolResetFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlags value ) + { + std::string result = "{"; + if ( value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool ) + result += " UpdateAfterBindPool |"; + if ( value & DescriptorSetLayoutCreateFlagBits::ePushDescriptor ) + result += " PushDescriptor |"; + if ( value & DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT ) + result += " DescriptorBufferEXT |"; + if ( value & DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT ) + result += " EmbeddedImmutableSamplersEXT |"; + if ( value & DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV ) + result += " IndirectBindableNV |"; + if ( value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT ) + result += " HostOnlyPoolEXT |"; + if ( value & DescriptorSetLayoutCreateFlagBits::ePerStageNV ) + result += " PerStageNV |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( QueryPipelineStatisticFlags value ) + { + std::string result = "{"; + if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices ) + result += " InputAssemblyVertices |"; + if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives ) + result += " InputAssemblyPrimitives |"; + if ( value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations ) + result += " VertexShaderInvocations |"; + if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations ) + result += " GeometryShaderInvocations |"; + if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives ) + result += " GeometryShaderPrimitives |"; + if ( value & QueryPipelineStatisticFlagBits::eClippingInvocations ) + result += " ClippingInvocations |"; + if ( value & QueryPipelineStatisticFlagBits::eClippingPrimitives ) + result += " ClippingPrimitives |"; + if ( value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations ) + result += " FragmentShaderInvocations |"; + if ( value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches ) + result += " TessellationControlShaderPatches |"; + if ( value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations ) + result += " TessellationEvaluationShaderInvocations |"; + if ( value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations ) + result += " ComputeShaderInvocations |"; + if ( value & QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT ) + result += " TaskShaderInvocationsEXT |"; + if ( value & QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT ) + result += " MeshShaderInvocationsEXT |"; + if ( value & QueryPipelineStatisticFlagBits::eClusterCullingShaderInvocationsHUAWEI ) + result += " ClusterCullingShaderInvocationsHUAWEI |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ColorComponentFlags value ) + { + std::string result = "{"; + if ( value & ColorComponentFlagBits::eR ) + result += " R |"; + if ( value & ColorComponentFlagBits::eG ) + result += " G |"; + if ( value & ColorComponentFlagBits::eB ) + result += " B |"; + if ( value & ColorComponentFlagBits::eA ) + result += " A |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( CullModeFlags value ) + { + std::string result = "{"; + if ( value & CullModeFlagBits::eFront ) + result += " Front |"; + if ( value & CullModeFlagBits::eBack ) + result += " Back |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "None"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags value ) + { + std::string result = "{"; + if ( value & PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT ) + result += " RasterizationOrderAttachmentAccessEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags value ) + { + std::string result = "{"; + if ( value & PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT ) + result += " RasterizationOrderAttachmentDepthAccessEXT |"; + if ( value & PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT ) + result += " RasterizationOrderAttachmentStencilAccessEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDynamicStateCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineInputAssemblyStateCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineMultisampleStateCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineTessellationStateCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineVertexInputStateCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportStateCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlags value ) + { + std::string result = "{"; + if ( value & AttachmentDescriptionFlagBits::eMayAlias ) + result += " MayAlias |"; + if ( value & AttachmentDescriptionFlagBits::eResolveSkipTransferFunctionKHR ) + result += " ResolveSkipTransferFunctionKHR |"; + if ( value & AttachmentDescriptionFlagBits::eResolveEnableTransferFunctionKHR ) + result += " ResolveEnableTransferFunctionKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags value ) + { + std::string result = "{"; + if ( value & FramebufferCreateFlagBits::eImageless ) + result += " Imageless |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlags value ) + { + std::string result = "{"; + if ( value & RenderPassCreateFlagBits::eTransformQCOM ) + result += " TransformQCOM |"; + if ( value & RenderPassCreateFlagBits::ePerLayerFragmentDensityVALVE ) + result += " PerLayerFragmentDensityVALVE |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlags value ) + { + std::string result = "{"; + if ( value & SubpassDescriptionFlagBits::ePerViewAttributesNVX ) + result += " PerViewAttributesNVX |"; + if ( value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX ) + result += " PerViewPositionXOnlyNVX |"; + if ( value & SubpassDescriptionFlagBits::eTileShadingApronQCOM ) + result += " TileShadingApronQCOM |"; + if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT ) + result += " RasterizationOrderAttachmentColorAccessEXT |"; + if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT ) + result += " RasterizationOrderAttachmentDepthAccessEXT |"; + if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT ) + result += " RasterizationOrderAttachmentStencilAccessEXT |"; + if ( value & SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT ) + result += " EnableLegacyDitheringEXT |"; + if ( value & SubpassDescriptionFlagBits::eFragmentRegionEXT ) + result += " FragmentRegionEXT |"; + if ( value & SubpassDescriptionFlagBits::eCustomResolveEXT ) + result += " CustomResolveEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( StencilFaceFlags value ) + { + std::string result = "{"; + if ( value & StencilFaceFlagBits::eFront ) + result += " Front |"; + if ( value & StencilFaceFlagBits::eBack ) + result += " Back |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_VERSION_1_1 === + + VULKAN_HPP_INLINE std::string to_string( PeerMemoryFeatureFlags value ) + { + std::string result = "{"; + if ( value & PeerMemoryFeatureFlagBits::eCopySrc ) + result += " CopySrc |"; + if ( value & PeerMemoryFeatureFlagBits::eCopyDst ) + result += " CopyDst |"; + if ( value & PeerMemoryFeatureFlagBits::eGenericSrc ) + result += " GenericSrc |"; + if ( value & PeerMemoryFeatureFlagBits::eGenericDst ) + result += " GenericDst |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlags value ) + { + std::string result = "{"; + if ( value & MemoryAllocateFlagBits::eDeviceMask ) + result += " DeviceMask |"; + if ( value & MemoryAllocateFlagBits::eDeviceAddress ) + result += " DeviceAddress |"; + if ( value & MemoryAllocateFlagBits::eDeviceAddressCaptureReplay ) + result += " DeviceAddressCaptureReplay |"; + if ( value & MemoryAllocateFlagBits::eZeroInitializeEXT ) + result += " ZeroInitializeEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolTrimFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlags value ) + { + std::string result = "{"; + if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) + result += " OpaqueFd |"; + if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 ) + result += " OpaqueWin32 |"; + if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt ) + result += " OpaqueWin32Kmt |"; + if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11Texture ) + result += " D3D11Texture |"; + if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt ) + result += " D3D11TextureKmt |"; + if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Heap ) + result += " D3D12Heap |"; + if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Resource ) + result += " D3D12Resource |"; + if ( value & ExternalMemoryHandleTypeFlagBits::eDmaBufEXT ) + result += " DmaBufEXT |"; +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + if ( value & ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID ) + result += " AndroidHardwareBufferANDROID |"; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + if ( value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT ) + result += " HostAllocationEXT |"; + if ( value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT ) + result += " HostMappedForeignMemoryEXT |"; +#if defined( VK_USE_PLATFORM_FUCHSIA ) + if ( value & ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA ) + result += " ZirconVmoFUCHSIA |"; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + if ( value & ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV ) + result += " RdmaAddressNV |"; +#if defined( VK_USE_PLATFORM_OHOS ) + if ( value & ExternalMemoryHandleTypeFlagBits::eOhNativeBufferOHOS ) + result += " OhNativeBufferOHOS |"; +#endif /*VK_USE_PLATFORM_OHOS*/ +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + if ( value & ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX ) + result += " ScreenBufferQNX |"; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ +#if defined( VK_USE_PLATFORM_METAL_EXT ) + if ( value & ExternalMemoryHandleTypeFlagBits::eMtlbufferEXT ) + result += " MtlbufferEXT |"; + if ( value & ExternalMemoryHandleTypeFlagBits::eMtltextureEXT ) + result += " MtltextureEXT |"; + if ( value & ExternalMemoryHandleTypeFlagBits::eMtlheapEXT ) + result += " MtlheapEXT |"; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlags value ) + { + std::string result = "{"; + if ( value & ExternalMemoryFeatureFlagBits::eDedicatedOnly ) + result += " DedicatedOnly |"; + if ( value & ExternalMemoryFeatureFlagBits::eExportable ) + result += " Exportable |"; + if ( value & ExternalMemoryFeatureFlagBits::eImportable ) + result += " Importable |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ExternalFenceHandleTypeFlags value ) + { + std::string result = "{"; + if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueFd ) + result += " OpaqueFd |"; + if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32 ) + result += " OpaqueWin32 |"; + if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt ) + result += " OpaqueWin32Kmt |"; + if ( value & ExternalFenceHandleTypeFlagBits::eSyncFd ) + result += " SyncFd |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlags value ) + { + std::string result = "{"; + if ( value & ExternalFenceFeatureFlagBits::eExportable ) + result += " Exportable |"; + if ( value & ExternalFenceFeatureFlagBits::eImportable ) + result += " Importable |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( FenceImportFlags value ) + { + std::string result = "{"; + if ( value & FenceImportFlagBits::eTemporary ) + result += " Temporary |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlags value ) + { + std::string result = "{"; + if ( value & SemaphoreImportFlagBits::eTemporary ) + result += " Temporary |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreHandleTypeFlags value ) + { + std::string result = "{"; + if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) + result += " OpaqueFd |"; + if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 ) + result += " OpaqueWin32 |"; + if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt ) + result += " OpaqueWin32Kmt |"; + if ( value & ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence ) + result += " D3D12Fence |"; + if ( value & ExternalSemaphoreHandleTypeFlagBits::eSyncFd ) + result += " SyncFd |"; +#if defined( VK_USE_PLATFORM_FUCHSIA ) + if ( value & ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA ) + result += " ZirconEventFUCHSIA |"; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlags value ) + { + std::string result = "{"; + if ( value & ExternalSemaphoreFeatureFlagBits::eExportable ) + result += " Exportable |"; + if ( value & ExternalSemaphoreFeatureFlagBits::eImportable ) + result += " Importable |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( SubgroupFeatureFlags value ) + { + std::string result = "{"; + if ( value & SubgroupFeatureFlagBits::eBasic ) + result += " Basic |"; + if ( value & SubgroupFeatureFlagBits::eVote ) + result += " Vote |"; + if ( value & SubgroupFeatureFlagBits::eArithmetic ) + result += " Arithmetic |"; + if ( value & SubgroupFeatureFlagBits::eBallot ) + result += " Ballot |"; + if ( value & SubgroupFeatureFlagBits::eShuffle ) + result += " Shuffle |"; + if ( value & SubgroupFeatureFlagBits::eShuffleRelative ) + result += " ShuffleRelative |"; + if ( value & SubgroupFeatureFlagBits::eClustered ) + result += " Clustered |"; + if ( value & SubgroupFeatureFlagBits::eQuad ) + result += " Quad |"; + if ( value & SubgroupFeatureFlagBits::eRotate ) + result += " Rotate |"; + if ( value & SubgroupFeatureFlagBits::eRotateClustered ) + result += " RotateClustered |"; + if ( value & SubgroupFeatureFlagBits::ePartitionedEXT ) + result += " PartitionedEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorUpdateTemplateCreateFlags ) + { + return "{}"; + } + + //=== VK_VERSION_1_2 === + + VULKAN_HPP_INLINE std::string to_string( SemaphoreWaitFlags value ) + { + std::string result = "{"; + if ( value & SemaphoreWaitFlagBits::eAny ) + result += " Any |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( DescriptorBindingFlags value ) + { + std::string result = "{"; + if ( value & DescriptorBindingFlagBits::eUpdateAfterBind ) + result += " UpdateAfterBind |"; + if ( value & DescriptorBindingFlagBits::eUpdateUnusedWhilePending ) + result += " UpdateUnusedWhilePending |"; + if ( value & DescriptorBindingFlagBits::ePartiallyBound ) + result += " PartiallyBound |"; + if ( value & DescriptorBindingFlagBits::eVariableDescriptorCount ) + result += " VariableDescriptorCount |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ResolveModeFlags value ) + { + std::string result = "{"; + if ( value & ResolveModeFlagBits::eSampleZero ) + result += " SampleZero |"; + if ( value & ResolveModeFlagBits::eAverage ) + result += " Average |"; + if ( value & ResolveModeFlagBits::eMin ) + result += " Min |"; + if ( value & ResolveModeFlagBits::eMax ) + result += " Max |"; +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + if ( value & ResolveModeFlagBits::eExternalFormatDownsampleANDROID ) + result += " ExternalFormatDownsampleANDROID |"; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + if ( value & ResolveModeFlagBits::eCustomEXT ) + result += " CustomEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "None"; + return result; + } + + //=== VK_VERSION_1_3 === + + VULKAN_HPP_INLINE std::string to_string( ToolPurposeFlags value ) + { + std::string result = "{"; + if ( value & ToolPurposeFlagBits::eValidation ) + result += " Validation |"; + if ( value & ToolPurposeFlagBits::eProfiling ) + result += " Profiling |"; + if ( value & ToolPurposeFlagBits::eTracing ) + result += " Tracing |"; + if ( value & ToolPurposeFlagBits::eAdditionalFeatures ) + result += " AdditionalFeatures |"; + if ( value & ToolPurposeFlagBits::eModifyingFeatures ) + result += " ModifyingFeatures |"; + if ( value & ToolPurposeFlagBits::eDebugReportingEXT ) + result += " DebugReportingEXT |"; + if ( value & ToolPurposeFlagBits::eDebugMarkersEXT ) + result += " DebugMarkersEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlags ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags2 value ) + { + std::string result = "{"; + if ( value & PipelineStageFlagBits2::eTopOfPipe ) + result += " TopOfPipe |"; + if ( value & PipelineStageFlagBits2::eDrawIndirect ) + result += " DrawIndirect |"; + if ( value & PipelineStageFlagBits2::eVertexInput ) + result += " VertexInput |"; + if ( value & PipelineStageFlagBits2::eVertexShader ) + result += " VertexShader |"; + if ( value & PipelineStageFlagBits2::eTessellationControlShader ) + result += " TessellationControlShader |"; + if ( value & PipelineStageFlagBits2::eTessellationEvaluationShader ) + result += " TessellationEvaluationShader |"; + if ( value & PipelineStageFlagBits2::eGeometryShader ) + result += " GeometryShader |"; + if ( value & PipelineStageFlagBits2::eFragmentShader ) + result += " FragmentShader |"; + if ( value & PipelineStageFlagBits2::eEarlyFragmentTests ) + result += " EarlyFragmentTests |"; + if ( value & PipelineStageFlagBits2::eLateFragmentTests ) + result += " LateFragmentTests |"; + if ( value & PipelineStageFlagBits2::eColorAttachmentOutput ) + result += " ColorAttachmentOutput |"; + if ( value & PipelineStageFlagBits2::eComputeShader ) + result += " ComputeShader |"; + if ( value & PipelineStageFlagBits2::eAllTransfer ) + result += " AllTransfer |"; + if ( value & PipelineStageFlagBits2::eBottomOfPipe ) + result += " BottomOfPipe |"; + if ( value & PipelineStageFlagBits2::eHost ) + result += " Host |"; + if ( value & PipelineStageFlagBits2::eAllGraphics ) + result += " AllGraphics |"; + if ( value & PipelineStageFlagBits2::eAllCommands ) + result += " AllCommands |"; + if ( value & PipelineStageFlagBits2::eCopy ) + result += " Copy |"; + if ( value & PipelineStageFlagBits2::eResolve ) + result += " Resolve |"; + if ( value & PipelineStageFlagBits2::eBlit ) + result += " Blit |"; + if ( value & PipelineStageFlagBits2::eClear ) + result += " Clear |"; + if ( value & PipelineStageFlagBits2::eIndexInput ) + result += " IndexInput |"; + if ( value & PipelineStageFlagBits2::eVertexAttributeInput ) + result += " VertexAttributeInput |"; + if ( value & PipelineStageFlagBits2::ePreRasterizationShaders ) + result += " PreRasterizationShaders |"; + if ( value & PipelineStageFlagBits2::eVideoDecodeKHR ) + result += " VideoDecodeKHR |"; + if ( value & PipelineStageFlagBits2::eVideoEncodeKHR ) + result += " VideoEncodeKHR |"; + if ( value & PipelineStageFlagBits2::eTransformFeedbackEXT ) + result += " TransformFeedbackEXT |"; + if ( value & PipelineStageFlagBits2::eConditionalRenderingEXT ) + result += " ConditionalRenderingEXT |"; + if ( value & PipelineStageFlagBits2::eCommandPreprocessEXT ) + result += " CommandPreprocessEXT |"; + if ( value & PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR ) + result += " FragmentShadingRateAttachmentKHR |"; + if ( value & PipelineStageFlagBits2::eAccelerationStructureBuildKHR ) + result += " AccelerationStructureBuildKHR |"; + if ( value & PipelineStageFlagBits2::eRayTracingShaderKHR ) + result += " RayTracingShaderKHR |"; + if ( value & PipelineStageFlagBits2::eFragmentDensityProcessEXT ) + result += " FragmentDensityProcessEXT |"; + if ( value & PipelineStageFlagBits2::eTaskShaderEXT ) + result += " TaskShaderEXT |"; + if ( value & PipelineStageFlagBits2::eMeshShaderEXT ) + result += " MeshShaderEXT |"; + if ( value & PipelineStageFlagBits2::eSubpassShaderHUAWEI ) + result += " SubpassShaderHUAWEI |"; + if ( value & PipelineStageFlagBits2::eInvocationMaskHUAWEI ) + result += " InvocationMaskHUAWEI |"; + if ( value & PipelineStageFlagBits2::eAccelerationStructureCopyKHR ) + result += " AccelerationStructureCopyKHR |"; + if ( value & PipelineStageFlagBits2::eMicromapBuildEXT ) + result += " MicromapBuildEXT |"; + if ( value & PipelineStageFlagBits2::eClusterCullingShaderHUAWEI ) + result += " ClusterCullingShaderHUAWEI |"; + if ( value & PipelineStageFlagBits2::eOpticalFlowNV ) + result += " OpticalFlowNV |"; + if ( value & PipelineStageFlagBits2::eConvertCooperativeVectorMatrixNV ) + result += " ConvertCooperativeVectorMatrixNV |"; + if ( value & PipelineStageFlagBits2::eDataGraphARM ) + result += " DataGraphARM |"; + if ( value & PipelineStageFlagBits2::eCopyIndirectKHR ) + result += " CopyIndirectKHR |"; + if ( value & PipelineStageFlagBits2::eMemoryDecompressionEXT ) + result += " MemoryDecompressionEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "None"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( AccessFlags2 value ) + { + std::string result = "{"; + if ( value & AccessFlagBits2::eIndirectCommandRead ) + result += " IndirectCommandRead |"; + if ( value & AccessFlagBits2::eIndexRead ) + result += " IndexRead |"; + if ( value & AccessFlagBits2::eVertexAttributeRead ) + result += " VertexAttributeRead |"; + if ( value & AccessFlagBits2::eUniformRead ) + result += " UniformRead |"; + if ( value & AccessFlagBits2::eInputAttachmentRead ) + result += " InputAttachmentRead |"; + if ( value & AccessFlagBits2::eShaderRead ) + result += " ShaderRead |"; + if ( value & AccessFlagBits2::eShaderWrite ) + result += " ShaderWrite |"; + if ( value & AccessFlagBits2::eColorAttachmentRead ) + result += " ColorAttachmentRead |"; + if ( value & AccessFlagBits2::eColorAttachmentWrite ) + result += " ColorAttachmentWrite |"; + if ( value & AccessFlagBits2::eDepthStencilAttachmentRead ) + result += " DepthStencilAttachmentRead |"; + if ( value & AccessFlagBits2::eDepthStencilAttachmentWrite ) + result += " DepthStencilAttachmentWrite |"; + if ( value & AccessFlagBits2::eTransferRead ) + result += " TransferRead |"; + if ( value & AccessFlagBits2::eTransferWrite ) + result += " TransferWrite |"; + if ( value & AccessFlagBits2::eHostRead ) + result += " HostRead |"; + if ( value & AccessFlagBits2::eHostWrite ) + result += " HostWrite |"; + if ( value & AccessFlagBits2::eMemoryRead ) + result += " MemoryRead |"; + if ( value & AccessFlagBits2::eMemoryWrite ) + result += " MemoryWrite |"; + if ( value & AccessFlagBits2::eShaderSampledRead ) + result += " ShaderSampledRead |"; + if ( value & AccessFlagBits2::eShaderStorageRead ) + result += " ShaderStorageRead |"; + if ( value & AccessFlagBits2::eShaderStorageWrite ) + result += " ShaderStorageWrite |"; + if ( value & AccessFlagBits2::eVideoDecodeReadKHR ) + result += " VideoDecodeReadKHR |"; + if ( value & AccessFlagBits2::eVideoDecodeWriteKHR ) + result += " VideoDecodeWriteKHR |"; + if ( value & AccessFlagBits2::eSamplerHeapReadEXT ) + result += " SamplerHeapReadEXT |"; + if ( value & AccessFlagBits2::eResourceHeapReadEXT ) + result += " ResourceHeapReadEXT |"; + if ( value & AccessFlagBits2::eVideoEncodeReadKHR ) + result += " VideoEncodeReadKHR |"; + if ( value & AccessFlagBits2::eVideoEncodeWriteKHR ) + result += " VideoEncodeWriteKHR |"; + if ( value & AccessFlagBits2::eShaderTileAttachmentReadQCOM ) + result += " ShaderTileAttachmentReadQCOM |"; + if ( value & AccessFlagBits2::eShaderTileAttachmentWriteQCOM ) + result += " ShaderTileAttachmentWriteQCOM |"; + if ( value & AccessFlagBits2::eTransformFeedbackWriteEXT ) + result += " TransformFeedbackWriteEXT |"; + if ( value & AccessFlagBits2::eTransformFeedbackCounterReadEXT ) + result += " TransformFeedbackCounterReadEXT |"; + if ( value & AccessFlagBits2::eTransformFeedbackCounterWriteEXT ) + result += " TransformFeedbackCounterWriteEXT |"; + if ( value & AccessFlagBits2::eConditionalRenderingReadEXT ) + result += " ConditionalRenderingReadEXT |"; + if ( value & AccessFlagBits2::eCommandPreprocessReadEXT ) + result += " CommandPreprocessReadEXT |"; + if ( value & AccessFlagBits2::eCommandPreprocessWriteEXT ) + result += " CommandPreprocessWriteEXT |"; + if ( value & AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR ) + result += " FragmentShadingRateAttachmentReadKHR |"; + if ( value & AccessFlagBits2::eAccelerationStructureReadKHR ) + result += " AccelerationStructureReadKHR |"; + if ( value & AccessFlagBits2::eAccelerationStructureWriteKHR ) + result += " AccelerationStructureWriteKHR |"; + if ( value & AccessFlagBits2::eFragmentDensityMapReadEXT ) + result += " FragmentDensityMapReadEXT |"; + if ( value & AccessFlagBits2::eColorAttachmentReadNoncoherentEXT ) + result += " ColorAttachmentReadNoncoherentEXT |"; + if ( value & AccessFlagBits2::eDescriptorBufferReadEXT ) + result += " DescriptorBufferReadEXT |"; + if ( value & AccessFlagBits2::eInvocationMaskReadHUAWEI ) + result += " InvocationMaskReadHUAWEI |"; + if ( value & AccessFlagBits2::eShaderBindingTableReadKHR ) + result += " ShaderBindingTableReadKHR |"; + if ( value & AccessFlagBits2::eMicromapReadEXT ) + result += " MicromapReadEXT |"; + if ( value & AccessFlagBits2::eMicromapWriteEXT ) + result += " MicromapWriteEXT |"; + if ( value & AccessFlagBits2::eOpticalFlowReadNV ) + result += " OpticalFlowReadNV |"; + if ( value & AccessFlagBits2::eOpticalFlowWriteNV ) + result += " OpticalFlowWriteNV |"; + if ( value & AccessFlagBits2::eDataGraphReadARM ) + result += " DataGraphReadARM |"; + if ( value & AccessFlagBits2::eDataGraphWriteARM ) + result += " DataGraphWriteARM |"; + if ( value & AccessFlagBits2::eMemoryDecompressionReadEXT ) + result += " MemoryDecompressionReadEXT |"; + if ( value & AccessFlagBits2::eMemoryDecompressionWriteEXT ) + result += " MemoryDecompressionWriteEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "None"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( SubmitFlags value ) + { + std::string result = "{"; + if ( value & SubmitFlagBits::eProtected ) + result += " Protected |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags2 value ) + { + std::string result = "{"; + if ( value & FormatFeatureFlagBits2::eSampledImage ) + result += " SampledImage |"; + if ( value & FormatFeatureFlagBits2::eStorageImage ) + result += " StorageImage |"; + if ( value & FormatFeatureFlagBits2::eStorageImageAtomic ) + result += " StorageImageAtomic |"; + if ( value & FormatFeatureFlagBits2::eUniformTexelBuffer ) + result += " UniformTexelBuffer |"; + if ( value & FormatFeatureFlagBits2::eStorageTexelBuffer ) + result += " StorageTexelBuffer |"; + if ( value & FormatFeatureFlagBits2::eStorageTexelBufferAtomic ) + result += " StorageTexelBufferAtomic |"; + if ( value & FormatFeatureFlagBits2::eVertexBuffer ) + result += " VertexBuffer |"; + if ( value & FormatFeatureFlagBits2::eColorAttachment ) + result += " ColorAttachment |"; + if ( value & FormatFeatureFlagBits2::eColorAttachmentBlend ) + result += " ColorAttachmentBlend |"; + if ( value & FormatFeatureFlagBits2::eDepthStencilAttachment ) + result += " DepthStencilAttachment |"; + if ( value & FormatFeatureFlagBits2::eBlitSrc ) + result += " BlitSrc |"; + if ( value & FormatFeatureFlagBits2::eBlitDst ) + result += " BlitDst |"; + if ( value & FormatFeatureFlagBits2::eSampledImageFilterLinear ) + result += " SampledImageFilterLinear |"; + if ( value & FormatFeatureFlagBits2::eTransferSrc ) + result += " TransferSrc |"; + if ( value & FormatFeatureFlagBits2::eTransferDst ) + result += " TransferDst |"; + if ( value & FormatFeatureFlagBits2::eSampledImageFilterMinmax ) + result += " SampledImageFilterMinmax |"; + if ( value & FormatFeatureFlagBits2::eMidpointChromaSamples ) + result += " MidpointChromaSamples |"; + if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter ) + result += " SampledImageYcbcrConversionLinearFilter |"; + if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter ) + result += " SampledImageYcbcrConversionSeparateReconstructionFilter |"; + if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit ) + result += " SampledImageYcbcrConversionChromaReconstructionExplicit |"; + if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable ) + result += " SampledImageYcbcrConversionChromaReconstructionExplicitForceable |"; + if ( value & FormatFeatureFlagBits2::eDisjoint ) + result += " Disjoint |"; + if ( value & FormatFeatureFlagBits2::eCositedChromaSamples ) + result += " CositedChromaSamples |"; + if ( value & FormatFeatureFlagBits2::eStorageReadWithoutFormat ) + result += " StorageReadWithoutFormat |"; + if ( value & FormatFeatureFlagBits2::eStorageWriteWithoutFormat ) + result += " StorageWriteWithoutFormat |"; + if ( value & FormatFeatureFlagBits2::eSampledImageDepthComparison ) + result += " SampledImageDepthComparison |"; + if ( value & FormatFeatureFlagBits2::eSampledImageFilterCubic ) + result += " SampledImageFilterCubic |"; + if ( value & FormatFeatureFlagBits2::eHostImageTransfer ) + result += " HostImageTransfer |"; + if ( value & FormatFeatureFlagBits2::eVideoDecodeOutputKHR ) + result += " VideoDecodeOutputKHR |"; + if ( value & FormatFeatureFlagBits2::eVideoDecodeDpbKHR ) + result += " VideoDecodeDpbKHR |"; + if ( value & FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR ) + result += " AccelerationStructureVertexBufferKHR |"; + if ( value & FormatFeatureFlagBits2::eFragmentDensityMapEXT ) + result += " FragmentDensityMapEXT |"; + if ( value & FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR ) + result += " FragmentShadingRateAttachmentKHR |"; + if ( value & FormatFeatureFlagBits2::eVideoEncodeInputKHR ) + result += " VideoEncodeInputKHR |"; + if ( value & FormatFeatureFlagBits2::eVideoEncodeDpbKHR ) + result += " VideoEncodeDpbKHR |"; + if ( value & FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV ) + result += " AccelerationStructureRadiusBufferNV |"; + if ( value & FormatFeatureFlagBits2::eLinearColorAttachmentNV ) + result += " LinearColorAttachmentNV |"; + if ( value & FormatFeatureFlagBits2::eWeightImageQCOM ) + result += " WeightImageQCOM |"; + if ( value & FormatFeatureFlagBits2::eWeightSampledImageQCOM ) + result += " WeightSampledImageQCOM |"; + if ( value & FormatFeatureFlagBits2::eBlockMatchingQCOM ) + result += " BlockMatchingQCOM |"; + if ( value & FormatFeatureFlagBits2::eBoxFilterSampledQCOM ) + result += " BoxFilterSampledQCOM |"; + if ( value & FormatFeatureFlagBits2::eTensorShaderARM ) + result += " TensorShaderARM |"; + if ( value & FormatFeatureFlagBits2::eTensorImageAliasingARM ) + result += " TensorImageAliasingARM |"; + if ( value & FormatFeatureFlagBits2::eOpticalFlowImageNV ) + result += " OpticalFlowImageNV |"; + if ( value & FormatFeatureFlagBits2::eOpticalFlowVectorNV ) + result += " OpticalFlowVectorNV |"; + if ( value & FormatFeatureFlagBits2::eOpticalFlowCostNV ) + result += " OpticalFlowCostNV |"; + if ( value & FormatFeatureFlagBits2::eTensorDataGraphARM ) + result += " TensorDataGraphARM |"; + if ( value & FormatFeatureFlagBits2::eCopyImageIndirectDstKHR ) + result += " CopyImageIndirectDstKHR |"; + if ( value & FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR ) + result += " VideoEncodeQuantizationDeltaMapKHR |"; + if ( value & FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR ) + result += " VideoEncodeEmphasisMapKHR |"; + if ( value & FormatFeatureFlagBits2::eDepthCopyOnComputeQueueKHR ) + result += " DepthCopyOnComputeQueueKHR |"; + if ( value & FormatFeatureFlagBits2::eDepthCopyOnTransferQueueKHR ) + result += " DepthCopyOnTransferQueueKHR |"; + if ( value & FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR ) + result += " StencilCopyOnComputeQueueKHR |"; + if ( value & FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR ) + result += " StencilCopyOnTransferQueueKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlags value ) + { + std::string result = "{"; + if ( value & PipelineCreationFeedbackFlagBits::eValid ) + result += " Valid |"; + if ( value & PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit ) + result += " ApplicationPipelineCacheHit |"; + if ( value & PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration ) + result += " BasePipelineAcceleration |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( RenderingFlags value ) + { + std::string result = "{"; + if ( value & RenderingFlagBits::eContentsSecondaryCommandBuffers ) + result += " ContentsSecondaryCommandBuffers |"; + if ( value & RenderingFlagBits::eSuspending ) + result += " Suspending |"; + if ( value & RenderingFlagBits::eResuming ) + result += " Resuming |"; + if ( value & RenderingFlagBits::eEnableLegacyDitheringEXT ) + result += " EnableLegacyDitheringEXT |"; + if ( value & RenderingFlagBits::eContentsInlineKHR ) + result += " ContentsInlineKHR |"; + if ( value & RenderingFlagBits::ePerLayerFragmentDensityVALVE ) + result += " PerLayerFragmentDensityVALVE |"; + if ( value & RenderingFlagBits::eFragmentRegionEXT ) + result += " FragmentRegionEXT |"; + if ( value & RenderingFlagBits::eCustomResolveEXT ) + result += " CustomResolveEXT |"; + if ( value & RenderingFlagBits::eLocalReadConcurrentAccessControlKHR ) + result += " LocalReadConcurrentAccessControlKHR |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_VERSION_1_4 === + + VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlags value ) + { + std::string result = "{"; + if ( value & MemoryUnmapFlagBits::eReserveEXT ) + result += " ReserveEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags2 value ) + { + std::string result = "{"; + if ( value & BufferUsageFlagBits2::eTransferSrc ) + result += " TransferSrc |"; + if ( value & BufferUsageFlagBits2::eTransferDst ) + result += " TransferDst |"; + if ( value & BufferUsageFlagBits2::eUniformTexelBuffer ) + result += " UniformTexelBuffer |"; + if ( value & BufferUsageFlagBits2::eStorageTexelBuffer ) + result += " StorageTexelBuffer |"; + if ( value & BufferUsageFlagBits2::eUniformBuffer ) + result += " UniformBuffer |"; + if ( value & BufferUsageFlagBits2::eStorageBuffer ) + result += " StorageBuffer |"; + if ( value & BufferUsageFlagBits2::eIndexBuffer ) + result += " IndexBuffer |"; + if ( value & BufferUsageFlagBits2::eVertexBuffer ) + result += " VertexBuffer |"; + if ( value & BufferUsageFlagBits2::eIndirectBuffer ) + result += " IndirectBuffer |"; + if ( value & BufferUsageFlagBits2::eShaderDeviceAddress ) + result += " ShaderDeviceAddress |"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + if ( value & BufferUsageFlagBits2::eExecutionGraphScratchAMDX ) + result += " ExecutionGraphScratchAMDX |"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + if ( value & BufferUsageFlagBits2::eDescriptorHeapEXT ) + result += " DescriptorHeapEXT |"; + if ( value & BufferUsageFlagBits2::eConditionalRenderingEXT ) + result += " ConditionalRenderingEXT |"; + if ( value & BufferUsageFlagBits2::eShaderBindingTableKHR ) + result += " ShaderBindingTableKHR |"; + if ( value & BufferUsageFlagBits2::eTransformFeedbackBufferEXT ) + result += " TransformFeedbackBufferEXT |"; + if ( value & BufferUsageFlagBits2::eTransformFeedbackCounterBufferEXT ) + result += " TransformFeedbackCounterBufferEXT |"; + if ( value & BufferUsageFlagBits2::eVideoDecodeSrcKHR ) + result += " VideoDecodeSrcKHR |"; + if ( value & BufferUsageFlagBits2::eVideoDecodeDstKHR ) + result += " VideoDecodeDstKHR |"; + if ( value & BufferUsageFlagBits2::eVideoEncodeDstKHR ) + result += " VideoEncodeDstKHR |"; + if ( value & BufferUsageFlagBits2::eVideoEncodeSrcKHR ) + result += " VideoEncodeSrcKHR |"; + if ( value & BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR ) + result += " AccelerationStructureBuildInputReadOnlyKHR |"; + if ( value & BufferUsageFlagBits2::eAccelerationStructureStorageKHR ) + result += " AccelerationStructureStorageKHR |"; + if ( value & BufferUsageFlagBits2::eSamplerDescriptorBufferEXT ) + result += " SamplerDescriptorBufferEXT |"; + if ( value & BufferUsageFlagBits2::eResourceDescriptorBufferEXT ) + result += " ResourceDescriptorBufferEXT |"; + if ( value & BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT ) + result += " PushDescriptorsDescriptorBufferEXT |"; + if ( value & BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT ) + result += " MicromapBuildInputReadOnlyEXT |"; + if ( value & BufferUsageFlagBits2::eMicromapStorageEXT ) + result += " MicromapStorageEXT |"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + if ( value & BufferUsageFlagBits2::eCompressedDataDgf1AMDX ) + result += " CompressedDataDgf1AMDX |"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + if ( value & BufferUsageFlagBits2::eDataGraphForeignDescriptorARM ) + result += " DataGraphForeignDescriptorARM |"; + if ( value & BufferUsageFlagBits2::eTileMemoryQCOM ) + result += " TileMemoryQCOM |"; + if ( value & BufferUsageFlagBits2::eMemoryDecompressionEXT ) + result += " MemoryDecompressionEXT |"; + if ( value & BufferUsageFlagBits2::ePreprocessBufferEXT ) + result += " PreprocessBufferEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( HostImageCopyFlags value ) + { + std::string result = "{"; + if ( value & HostImageCopyFlagBits::eMemcpy ) + result += " Memcpy |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags2 value ) + { + std::string result = "{"; + if ( value & PipelineCreateFlagBits2::eDisableOptimization ) + result += " DisableOptimization |"; + if ( value & PipelineCreateFlagBits2::eAllowDerivatives ) + result += " AllowDerivatives |"; + if ( value & PipelineCreateFlagBits2::eDerivative ) + result += " Derivative |"; + if ( value & PipelineCreateFlagBits2::eViewIndexFromDeviceIndex ) + result += " ViewIndexFromDeviceIndex |"; + if ( value & PipelineCreateFlagBits2::eDispatchBase ) + result += " DispatchBase |"; + if ( value & PipelineCreateFlagBits2::eFailOnPipelineCompileRequired ) + result += " FailOnPipelineCompileRequired |"; + if ( value & PipelineCreateFlagBits2::eEarlyReturnOnFailure ) + result += " EarlyReturnOnFailure |"; + if ( value & PipelineCreateFlagBits2::eNoProtectedAccess ) + result += " NoProtectedAccess |"; + if ( value & PipelineCreateFlagBits2::eProtectedAccessOnly ) + result += " ProtectedAccessOnly |"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + if ( value & PipelineCreateFlagBits2::eExecutionGraphAMDX ) + result += " ExecutionGraphAMDX |"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + if ( value & PipelineCreateFlagBits2::eDescriptorHeapEXT ) + result += " DescriptorHeapEXT |"; + if ( value & PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV ) + result += " RayTracingAllowSpheresAndLinearSweptSpheresNV |"; + if ( value & PipelineCreateFlagBits2::eEnableLegacyDitheringEXT ) + result += " EnableLegacyDitheringEXT |"; + if ( value & PipelineCreateFlagBits2::eDeferCompileNV ) + result += " DeferCompileNV |"; + if ( value & PipelineCreateFlagBits2::eCaptureStatisticsKHR ) + result += " CaptureStatisticsKHR |"; + if ( value & PipelineCreateFlagBits2::eCaptureInternalRepresentationsKHR ) + result += " CaptureInternalRepresentationsKHR |"; + if ( value & PipelineCreateFlagBits2::eLinkTimeOptimizationEXT ) + result += " LinkTimeOptimizationEXT |"; + if ( value & PipelineCreateFlagBits2::eRetainLinkTimeOptimizationInfoEXT ) + result += " RetainLinkTimeOptimizationInfoEXT |"; + if ( value & PipelineCreateFlagBits2::eLibraryKHR ) + result += " LibraryKHR |"; + if ( value & PipelineCreateFlagBits2::eRayTracingSkipTrianglesKHR ) + result += " RayTracingSkipTrianglesKHR |"; + if ( value & PipelineCreateFlagBits2::eRayTracingSkipAabbsKHR ) + result += " RayTracingSkipAabbsKHR |"; + if ( value & PipelineCreateFlagBits2::eRayTracingNoNullAnyHitShadersKHR ) + result += " RayTracingNoNullAnyHitShadersKHR |"; + if ( value & PipelineCreateFlagBits2::eRayTracingNoNullClosestHitShadersKHR ) + result += " RayTracingNoNullClosestHitShadersKHR |"; + if ( value & PipelineCreateFlagBits2::eRayTracingNoNullMissShadersKHR ) + result += " RayTracingNoNullMissShadersKHR |"; + if ( value & PipelineCreateFlagBits2::eRayTracingNoNullIntersectionShadersKHR ) + result += " RayTracingNoNullIntersectionShadersKHR |"; + if ( value & PipelineCreateFlagBits2::eRayTracingShaderGroupHandleCaptureReplayKHR ) + result += " RayTracingShaderGroupHandleCaptureReplayKHR |"; + if ( value & PipelineCreateFlagBits2::eIndirectBindableNV ) + result += " IndirectBindableNV |"; + if ( value & PipelineCreateFlagBits2::eRayTracingAllowMotionNV ) + result += " RayTracingAllowMotionNV |"; + if ( value & PipelineCreateFlagBits2::eRenderingFragmentShadingRateAttachmentKHR ) + result += " RenderingFragmentShadingRateAttachmentKHR |"; + if ( value & PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT ) + result += " RenderingFragmentDensityMapAttachmentEXT |"; + if ( value & PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT ) + result += " RayTracingOpacityMicromapEXT |"; + if ( value & PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT ) + result += " ColorAttachmentFeedbackLoopEXT |"; + if ( value & PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT ) + result += " DepthStencilAttachmentFeedbackLoopEXT |"; + if ( value & PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV ) + result += " RayTracingDisplacementMicromapNV |"; + if ( value & PipelineCreateFlagBits2::eDescriptorBufferEXT ) + result += " DescriptorBufferEXT |"; + if ( value & PipelineCreateFlagBits2::eDisallowOpacityMicromapARM ) + result += " DisallowOpacityMicromapARM |"; + if ( value & PipelineCreateFlagBits2::eCaptureDataKHR ) + result += " CaptureDataKHR |"; + if ( value & PipelineCreateFlagBits2::eIndirectBindableEXT ) + result += " IndirectBindableEXT |"; + if ( value & PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE ) + result += " PerLayerFragmentDensityVALVE |"; + if ( value & PipelineCreateFlagBits2::e64BitIndexingEXT ) + result += " 64BitIndexingEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_KHR_surface === + + VULKAN_HPP_INLINE std::string to_string( CompositeAlphaFlagsKHR value ) + { + std::string result = "{"; + if ( value & CompositeAlphaFlagBitsKHR::eOpaque ) + result += " Opaque |"; + if ( value & CompositeAlphaFlagBitsKHR::ePreMultiplied ) + result += " PreMultiplied |"; + if ( value & CompositeAlphaFlagBitsKHR::ePostMultiplied ) + result += " PostMultiplied |"; + if ( value & CompositeAlphaFlagBitsKHR::eInherit ) + result += " Inherit |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_KHR_swapchain === + + VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagsKHR value ) + { + std::string result = "{"; + if ( value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions ) + result += " SplitInstanceBindRegions |"; + if ( value & SwapchainCreateFlagBitsKHR::eProtected ) + result += " Protected |"; + if ( value & SwapchainCreateFlagBitsKHR::eMutableFormat ) + result += " MutableFormat |"; + if ( value & SwapchainCreateFlagBitsKHR::ePresentTimingEXT ) + result += " PresentTimingEXT |"; + if ( value & SwapchainCreateFlagBitsKHR::ePresentId2 ) + result += " PresentId2 |"; + if ( value & SwapchainCreateFlagBitsKHR::ePresentWait2 ) + result += " PresentWait2 |"; + if ( value & SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocation ) + result += " DeferredMemoryAllocation |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( DeviceGroupPresentModeFlagsKHR value ) + { + std::string result = "{"; + if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocal ) + result += " Local |"; + if ( value & DeviceGroupPresentModeFlagBitsKHR::eRemote ) + result += " Remote |"; + if ( value & DeviceGroupPresentModeFlagBitsKHR::eSum ) + result += " Sum |"; + if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice ) + result += " LocalMultiDevice |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_KHR_display === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayModeCreateFlagsKHR ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( DisplayPlaneAlphaFlagsKHR value ) + { + std::string result = "{"; + if ( value & DisplayPlaneAlphaFlagBitsKHR::eOpaque ) + result += " Opaque |"; + if ( value & DisplayPlaneAlphaFlagBitsKHR::eGlobal ) + result += " Global |"; + if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel ) + result += " PerPixel |"; + if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied ) + result += " PerPixelPremultiplied |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplaySurfaceCreateFlagsKHR ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( SurfaceTransformFlagsKHR value ) + { + std::string result = "{"; + if ( value & SurfaceTransformFlagBitsKHR::eIdentity ) + result += " Identity |"; + if ( value & SurfaceTransformFlagBitsKHR::eRotate90 ) + result += " Rotate90 |"; + if ( value & SurfaceTransformFlagBitsKHR::eRotate180 ) + result += " Rotate180 |"; + if ( value & SurfaceTransformFlagBitsKHR::eRotate270 ) + result += " Rotate270 |"; + if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirror ) + result += " HorizontalMirror |"; + if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 ) + result += " HorizontalMirrorRotate90 |"; + if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 ) + result += " HorizontalMirrorRotate180 |"; + if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 ) + result += " HorizontalMirrorRotate270 |"; + if ( value & SurfaceTransformFlagBitsKHR::eInherit ) + result += " Inherit |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XlibSurfaceCreateFlagsKHR ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XcbSurfaceCreateFlagsKHR ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( WaylandSurfaceCreateFlagsKHR ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AndroidSurfaceCreateFlagsKHR ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Win32SurfaceCreateFlagsKHR ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + + VULKAN_HPP_INLINE std::string to_string( DebugReportFlagsEXT value ) + { + std::string result = "{"; + if ( value & DebugReportFlagBitsEXT::eInformation ) + result += " Information |"; + if ( value & DebugReportFlagBitsEXT::eWarning ) + result += " Warning |"; + if ( value & DebugReportFlagBitsEXT::ePerformanceWarning ) + result += " PerformanceWarning |"; + if ( value & DebugReportFlagBitsEXT::eError ) + result += " Error |"; + if ( value & DebugReportFlagBitsEXT::eDebug ) + result += " Debug |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_KHR_video_queue === + + VULKAN_HPP_INLINE std::string to_string( VideoCodecOperationFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoCodecOperationFlagBitsKHR::eEncodeH264 ) + result += " EncodeH264 |"; + if ( value & VideoCodecOperationFlagBitsKHR::eEncodeH265 ) + result += " EncodeH265 |"; + if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH264 ) + result += " DecodeH264 |"; + if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH265 ) + result += " DecodeH265 |"; + if ( value & VideoCodecOperationFlagBitsKHR::eDecodeAv1 ) + result += " DecodeAv1 |"; + if ( value & VideoCodecOperationFlagBitsKHR::eEncodeAv1 ) + result += " EncodeAv1 |"; + if ( value & VideoCodecOperationFlagBitsKHR::eDecodeVp9 ) + result += " DecodeVp9 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "None"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoChromaSubsamplingFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoChromaSubsamplingFlagBitsKHR::eMonochrome ) + result += " Monochrome |"; + if ( value & VideoChromaSubsamplingFlagBitsKHR::e420 ) + result += " 420 |"; + if ( value & VideoChromaSubsamplingFlagBitsKHR::e422 ) + result += " 422 |"; + if ( value & VideoChromaSubsamplingFlagBitsKHR::e444 ) + result += " 444 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Invalid"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoComponentBitDepthFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoComponentBitDepthFlagBitsKHR::e8 ) + result += " 8 |"; + if ( value & VideoComponentBitDepthFlagBitsKHR::e10 ) + result += " 10 |"; + if ( value & VideoComponentBitDepthFlagBitsKHR::e12 ) + result += " 12 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Invalid"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoCapabilityFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoCapabilityFlagBitsKHR::eProtectedContent ) + result += " ProtectedContent |"; + if ( value & VideoCapabilityFlagBitsKHR::eSeparateReferenceImages ) + result += " SeparateReferenceImages |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoSessionCreateFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoSessionCreateFlagBitsKHR::eProtectedContent ) + result += " ProtectedContent |"; + if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations ) + result += " AllowEncodeParameterOptimizations |"; + if ( value & VideoSessionCreateFlagBitsKHR::eInlineQueries ) + result += " InlineQueries |"; + if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap ) + result += " AllowEncodeQuantizationDeltaMap |"; + if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap ) + result += " AllowEncodeEmphasisMap |"; + if ( value & VideoSessionCreateFlagBitsKHR::eInlineSessionParameters ) + result += " InlineSessionParameters |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoSessionParametersCreateFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible ) + result += " QuantizationMapCompatible |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoBeginCodingFlagsKHR ) + { + return "{}"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEndCodingFlagsKHR ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( VideoCodingControlFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoCodingControlFlagBitsKHR::eReset ) + result += " Reset |"; + if ( value & VideoCodingControlFlagBitsKHR::eEncodeRateControl ) + result += " EncodeRateControl |"; + if ( value & VideoCodingControlFlagBitsKHR::eEncodeQualityLevel ) + result += " EncodeQualityLevel |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_KHR_video_decode_queue === + + VULKAN_HPP_INLINE std::string to_string( VideoDecodeCapabilityFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide ) + result += " DpbAndOutputCoincide |"; + if ( value & VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct ) + result += " DpbAndOutputDistinct |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoDecodeUsageFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoDecodeUsageFlagBitsKHR::eTranscoding ) + result += " Transcoding |"; + if ( value & VideoDecodeUsageFlagBitsKHR::eOffline ) + result += " Offline |"; + if ( value & VideoDecodeUsageFlagBitsKHR::eStreaming ) + result += " Streaming |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Default"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeFlagsKHR ) + { + return "{}"; + } + + //=== VK_EXT_transform_feedback === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateStreamCreateFlagsEXT ) + { + return "{}"; + } + + //=== VK_KHR_video_encode_h264 === + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eHrdCompliance ) + result += " HrdCompliance |"; + if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePredictionWeightTableGenerated ) + result += " PredictionWeightTableGenerated |"; + if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eRowUnalignedSlice ) + result += " RowUnalignedSlice |"; + if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eDifferentSliceType ) + result += " DifferentSliceType |"; + if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL0List ) + result += " BFrameInL0List |"; + if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL1List ) + result += " BFrameInL1List |"; + if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp ) + result += " PerPictureTypeMinMaxQp |"; + if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp ) + result += " PerSliceConstantQp |"; + if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu ) + result += " GeneratePrefixNalu |"; + if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eBPictureIntraRefresh ) + result += " BPictureIntraRefresh |"; + if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound ) + result += " MbQpDiffWraparound |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264StdFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eSeparateColorPlaneFlagSet ) + result += " SeparateColorPlaneFlagSet |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eQpprimeYZeroTransformBypassFlagSet ) + result += " QpprimeYZeroTransformBypassFlagSet |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eScalingMatrixPresentFlagSet ) + result += " ScalingMatrixPresentFlagSet |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eChromaQpIndexOffset ) + result += " ChromaQpIndexOffset |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eSecondChromaQpIndexOffset ) + result += " SecondChromaQpIndexOffset |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::ePicInitQpMinus26 ) + result += " PicInitQpMinus26 |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedPredFlagSet ) + result += " WeightedPredFlagSet |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcExplicit ) + result += " WeightedBipredIdcExplicit |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcImplicit ) + result += " WeightedBipredIdcImplicit |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eTransform8X8ModeFlagSet ) + result += " Transform8X8ModeFlagSet |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eDirectSpatialMvPredFlagUnset ) + result += " DirectSpatialMvPredFlagUnset |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagUnset ) + result += " EntropyCodingModeFlagUnset |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagSet ) + result += " EntropyCodingModeFlagSet |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eDirect8X8InferenceFlagUnset ) + result += " Direct8X8InferenceFlagUnset |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eConstrainedIntraPredFlagSet ) + result += " ConstrainedIntraPredFlagSet |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterDisabled ) + result += " DeblockingFilterDisabled |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterEnabled ) + result += " DeblockingFilterEnabled |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterPartial ) + result += " DeblockingFilterPartial |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eSliceQpDelta ) + result += " SliceQpDelta |"; + if ( value & VideoEncodeH264StdFlagBitsKHR::eDifferentSliceQpDelta ) + result += " DifferentSliceQpDelta |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264RateControlFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeH264RateControlFlagBitsKHR::eAttemptHrdCompliance ) + result += " AttemptHrdCompliance |"; + if ( value & VideoEncodeH264RateControlFlagBitsKHR::eRegularGop ) + result += " RegularGop |"; + if ( value & VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternFlat ) + result += " ReferencePatternFlat |"; + if ( value & VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternDyadic ) + result += " ReferencePatternDyadic |"; + if ( value & VideoEncodeH264RateControlFlagBitsKHR::eTemporalLayerPatternDyadic ) + result += " TemporalLayerPatternDyadic |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_KHR_video_encode_h265 === + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CapabilityFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eHrdCompliance ) + result += " HrdCompliance |"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePredictionWeightTableGenerated ) + result += " PredictionWeightTableGenerated |"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eRowUnalignedSliceSegment ) + result += " RowUnalignedSliceSegment |"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eDifferentSliceSegmentType ) + result += " DifferentSliceSegmentType |"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL0List ) + result += " BFrameInL0List |"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL1List ) + result += " BFrameInL1List |"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp ) + result += " PerPictureTypeMinMaxQp |"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePerSliceSegmentConstantQp ) + result += " PerSliceSegmentConstantQp |"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eMultipleTilesPerSliceSegment ) + result += " MultipleTilesPerSliceSegment |"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile ) + result += " MultipleSliceSegmentsPerTile |"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eBPictureIntraRefresh ) + result += " BPictureIntraRefresh |"; + if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound ) + result += " CuQpDiffWraparound |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265StdFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eSeparateColorPlaneFlagSet ) + result += " SeparateColorPlaneFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eSampleAdaptiveOffsetEnabledFlagSet ) + result += " SampleAdaptiveOffsetEnabledFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eScalingListDataPresentFlagSet ) + result += " ScalingListDataPresentFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::ePcmEnabledFlagSet ) + result += " PcmEnabledFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eSpsTemporalMvpEnabledFlagSet ) + result += " SpsTemporalMvpEnabledFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eInitQpMinus26 ) + result += " InitQpMinus26 |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eWeightedPredFlagSet ) + result += " WeightedPredFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eWeightedBipredFlagSet ) + result += " WeightedBipredFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eLog2ParallelMergeLevelMinus2 ) + result += " Log2ParallelMergeLevelMinus2 |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eSignDataHidingEnabledFlagSet ) + result += " SignDataHidingEnabledFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagSet ) + result += " TransformSkipEnabledFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagUnset ) + result += " TransformSkipEnabledFlagUnset |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::ePpsSliceChromaQpOffsetsPresentFlagSet ) + result += " PpsSliceChromaQpOffsetsPresentFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eTransquantBypassEnabledFlagSet ) + result += " TransquantBypassEnabledFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eConstrainedIntraPredFlagSet ) + result += " ConstrainedIntraPredFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eEntropyCodingSyncEnabledFlagSet ) + result += " EntropyCodingSyncEnabledFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eDeblockingFilterOverrideEnabledFlagSet ) + result += " DeblockingFilterOverrideEnabledFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentsEnabledFlagSet ) + result += " DependentSliceSegmentsEnabledFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentFlagSet ) + result += " DependentSliceSegmentFlagSet |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eSliceQpDelta ) + result += " SliceQpDelta |"; + if ( value & VideoEncodeH265StdFlagBitsKHR::eDifferentSliceQpDelta ) + result += " DifferentSliceQpDelta |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CtbSizeFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e16 ) + result += " 16 |"; + if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e32 ) + result += " 32 |"; + if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e64 ) + result += " 64 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265TransformBlockSizeFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e4 ) + result += " 4 |"; + if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e8 ) + result += " 8 |"; + if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e16 ) + result += " 16 |"; + if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e32 ) + result += " 32 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265RateControlFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeH265RateControlFlagBitsKHR::eAttemptHrdCompliance ) + result += " AttemptHrdCompliance |"; + if ( value & VideoEncodeH265RateControlFlagBitsKHR::eRegularGop ) + result += " RegularGop |"; + if ( value & VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternFlat ) + result += " ReferencePatternFlat |"; + if ( value & VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternDyadic ) + result += " ReferencePatternDyadic |"; + if ( value & VideoEncodeH265RateControlFlagBitsKHR::eTemporalSubLayerPatternDyadic ) + result += " TemporalSubLayerPatternDyadic |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_KHR_video_decode_h264 === + + VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264PictureLayoutFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines ) + result += " InterlacedInterleavedLines |"; + if ( value & VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes ) + result += " InterlacedSeparatePlanes |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Progressive"; + return result; + } + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StreamDescriptorSurfaceCreateFlagsGGP ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + + VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlagsNV value ) + { + std::string result = "{"; + if ( value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 ) + result += " OpaqueWin32 |"; + if ( value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt ) + result += " OpaqueWin32Kmt |"; + if ( value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image ) + result += " D3D11Image |"; + if ( value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt ) + result += " D3D11ImageKmt |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlagsNV value ) + { + std::string result = "{"; + if ( value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly ) + result += " DedicatedOnly |"; + if ( value & ExternalMemoryFeatureFlagBitsNV::eExportable ) + result += " Exportable |"; + if ( value & ExternalMemoryFeatureFlagBitsNV::eImportable ) + result += " Importable |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ViSurfaceCreateFlagsNN ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_EXT_conditional_rendering === + + VULKAN_HPP_INLINE std::string to_string( ConditionalRenderingFlagsEXT value ) + { + std::string result = "{"; + if ( value & ConditionalRenderingFlagBitsEXT::eInverted ) + result += " Inverted |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_EXT_display_surface_counter === + + VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagsEXT value ) + { + std::string result = "{"; + if ( value & SurfaceCounterFlagBitsEXT::eVblank ) + result += " Vblank |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_NV_viewport_swizzle === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportSwizzleStateCreateFlagsNV ) + { + return "{}"; + } + + //=== VK_EXT_discard_rectangles === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDiscardRectangleStateCreateFlagsEXT ) + { + return "{}"; + } + + //=== VK_EXT_conservative_rasterization === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationConservativeStateCreateFlagsEXT ) + { + return "{}"; + } + + //=== VK_EXT_depth_clip_enable === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationDepthClipStateCreateFlagsEXT ) + { + return "{}"; + } + + //=== VK_KHR_performance_query === + + VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagsKHR value ) + { + std::string result = "{"; + if ( value & PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting ) + result += " PerformanceImpacting |"; + if ( value & PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted ) + result += " ConcurrentlyImpacted |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AcquireProfilingLockFlagsKHR ) + { + return "{}"; + } + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IOSSurfaceCreateFlagsMVK ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MacOSSurfaceCreateFlagsMVK ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + + VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageSeverityFlagsEXT value ) + { + std::string result = "{"; + if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eVerbose ) + result += " Verbose |"; + if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eInfo ) + result += " Info |"; + if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eWarning ) + result += " Warning |"; + if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eError ) + result += " Error |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageTypeFlagsEXT value ) + { + std::string result = "{"; + if ( value & DebugUtilsMessageTypeFlagBitsEXT::eGeneral ) + result += " General |"; + if ( value & DebugUtilsMessageTypeFlagBitsEXT::eValidation ) + result += " Validation |"; + if ( value & DebugUtilsMessageTypeFlagBitsEXT::ePerformance ) + result += " Performance |"; + if ( value & DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding ) + result += " DeviceAddressBinding |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCallbackDataFlagsEXT ) + { + return "{}"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCreateFlagsEXT ) + { + return "{}"; + } + + //=== VK_EXT_descriptor_heap === + + VULKAN_HPP_INLINE std::string to_string( SpirvResourceTypeFlagsEXT value ) + { + std::string result = "{"; + if ( value & SpirvResourceTypeFlagBitsEXT::eSampler ) + result += " Sampler |"; + if ( value & SpirvResourceTypeFlagBitsEXT::eSampledImage ) + result += " SampledImage |"; + if ( value & SpirvResourceTypeFlagBitsEXT::eReadOnlyImage ) + result += " ReadOnlyImage |"; + if ( value & SpirvResourceTypeFlagBitsEXT::eReadWriteImage ) + result += " ReadWriteImage |"; + if ( value & SpirvResourceTypeFlagBitsEXT::eCombinedSampledImage ) + result += " CombinedSampledImage |"; + if ( value & SpirvResourceTypeFlagBitsEXT::eUniformBuffer ) + result += " UniformBuffer |"; + if ( value & SpirvResourceTypeFlagBitsEXT::eReadOnlyStorageBuffer ) + result += " ReadOnlyStorageBuffer |"; + if ( value & SpirvResourceTypeFlagBitsEXT::eReadWriteStorageBuffer ) + result += " ReadWriteStorageBuffer |"; + if ( value & SpirvResourceTypeFlagBitsEXT::eAccelerationStructure ) + result += " AccelerationStructure |"; + if ( value & SpirvResourceTypeFlagBitsEXT::eTensorARM ) + result += " TensorARM |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( TensorViewCreateFlagsARM value ) + { + std::string result = "{"; + if ( value & TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay ) + result += " DescriptorBufferCaptureReplay |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_NV_fragment_coverage_to_color === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageToColorStateCreateFlagsNV ) + { + return "{}"; + } + + //=== VK_KHR_acceleration_structure === + + VULKAN_HPP_INLINE std::string to_string( GeometryFlagsKHR value ) + { + std::string result = "{"; + if ( value & GeometryFlagBitsKHR::eOpaque ) + result += " Opaque |"; + if ( value & GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation ) + result += " NoDuplicateAnyHitInvocation |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( GeometryInstanceFlagsKHR value ) + { + std::string result = "{"; + if ( value & GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable ) + result += " TriangleFacingCullDisable |"; + if ( value & GeometryInstanceFlagBitsKHR::eTriangleFlipFacing ) + result += " TriangleFlipFacing |"; + if ( value & GeometryInstanceFlagBitsKHR::eForceOpaque ) + result += " ForceOpaque |"; + if ( value & GeometryInstanceFlagBitsKHR::eForceNoOpaque ) + result += " ForceNoOpaque |"; + if ( value & GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT ) + result += " ForceOpacityMicromap2StateEXT |"; + if ( value & GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT ) + result += " DisableOpacityMicromapsEXT |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagsKHR value ) + { + std::string result = "{"; + if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowUpdate ) + result += " AllowUpdate |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowCompaction ) + result += " AllowCompaction |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace ) + result += " PreferFastTrace |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild ) + result += " PreferFastBuild |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::eLowMemory ) + result += " LowMemory |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::eMotionNV ) + result += " MotionNV |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT ) + result += " AllowOpacityMicromapUpdateEXT |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT ) + result += " AllowDisableOpacityMicromapsEXT |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT ) + result += " AllowOpacityMicromapDataUpdateEXT |"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV ) + result += " AllowDisplacementMicromapUpdateNV |"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess ) + result += " AllowDataAccess |"; + if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV ) + result += " AllowClusterOpacityMicromapsNV |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( AccelerationStructureCreateFlagsKHR value ) + { + std::string result = "{"; + if ( value & AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay ) + result += " DeviceAddressCaptureReplay |"; + if ( value & AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT ) + result += " DescriptorBufferCaptureReplayEXT |"; + if ( value & AccelerationStructureCreateFlagBitsKHR::eMotionNV ) + result += " MotionNV |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_NV_framebuffer_mixed_samples === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageModulationStateCreateFlagsNV ) + { + return "{}"; + } + + //=== VK_EXT_validation_cache === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCacheCreateFlagsEXT ) + { + return "{}"; + } + + //=== VK_AMD_pipeline_compiler_control === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCompilerControlFlagsAMD ) + { + return "{}"; + } + + //=== VK_EXT_present_timing === + + VULKAN_HPP_INLINE std::string to_string( PresentStageFlagsEXT value ) + { + std::string result = "{"; + if ( value & PresentStageFlagBitsEXT::eQueueOperationsEnd ) + result += " QueueOperationsEnd |"; + if ( value & PresentStageFlagBitsEXT::eRequestDequeued ) + result += " RequestDequeued |"; + if ( value & PresentStageFlagBitsEXT::eImageFirstPixelOut ) + result += " ImageFirstPixelOut |"; + if ( value & PresentStageFlagBitsEXT::eImageFirstPixelVisible ) + result += " ImageFirstPixelVisible |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PresentTimingInfoFlagsEXT value ) + { + std::string result = "{"; + if ( value & PresentTimingInfoFlagBitsEXT::ePresentAtRelativeTime ) + result += " PresentAtRelativeTime |"; + if ( value & PresentTimingInfoFlagBitsEXT::ePresentAtNearestRefreshCycle ) + result += " PresentAtNearestRefreshCycle |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PastPresentationTimingFlagsEXT value ) + { + std::string result = "{"; + if ( value & PastPresentationTimingFlagBitsEXT::eAllowPartialResults ) + result += " AllowPartialResults |"; + if ( value & PastPresentationTimingFlagBitsEXT::eAllowOutOfOrderResults ) + result += " AllowOutOfOrderResults |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImagePipeSurfaceCreateFlagsFUCHSIA ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MetalSurfaceCreateFlagsEXT ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_AMD_shader_core_properties2 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCorePropertiesFlagsAMD ) + { + return "{}"; + } + + //=== VK_NV_coverage_reduction_mode === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageReductionStateCreateFlagsNV ) + { + return "{}"; + } + + //=== VK_EXT_headless_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( HeadlessSurfaceCreateFlagsEXT ) + { + return "{}"; + } + + //=== VK_NV_device_generated_commands === + + VULKAN_HPP_INLINE std::string to_string( IndirectStateFlagsNV value ) + { + std::string result = "{"; + if ( value & IndirectStateFlagBitsNV::eFlagFrontface ) + result += " FlagFrontface |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsNV value ) + { + std::string result = "{"; + if ( value & IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess ) + result += " ExplicitPreprocess |"; + if ( value & IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences ) + result += " IndexedSequences |"; + if ( value & IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences ) + result += " UnorderedSequences |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_EXT_device_memory_report === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceMemoryReportFlagsEXT ) + { + return "{}"; + } + + //=== VK_KHR_video_encode_queue === + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeFlagBitsKHR::eIntraRefresh ) + result += " IntraRefresh |"; + if ( value & VideoEncodeFlagBitsKHR::eWithQuantizationDeltaMap ) + result += " WithQuantizationDeltaMap |"; + if ( value & VideoEncodeFlagBitsKHR::eWithEmphasisMap ) + result += " WithEmphasisMap |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeCapabilityFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes ) + result += " PrecedingExternallyEncodedBytes |"; + if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection ) + result += " InsufficientBitstreamBufferRangeDetection |"; + if ( value & VideoEncodeCapabilityFlagBitsKHR::eQuantizationDeltaMap ) + result += " QuantizationDeltaMap |"; + if ( value & VideoEncodeCapabilityFlagBitsKHR::eEmphasisMap ) + result += " EmphasisMap |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeFeedbackFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset ) + result += " BitstreamBufferOffset |"; + if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten ) + result += " BitstreamBytesWritten |"; + if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides ) + result += " BitstreamHasOverrides |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeUsageFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeUsageFlagBitsKHR::eTranscoding ) + result += " Transcoding |"; + if ( value & VideoEncodeUsageFlagBitsKHR::eStreaming ) + result += " Streaming |"; + if ( value & VideoEncodeUsageFlagBitsKHR::eRecording ) + result += " Recording |"; + if ( value & VideoEncodeUsageFlagBitsKHR::eConferencing ) + result += " Conferencing |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Default"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeContentFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeContentFlagBitsKHR::eCamera ) + result += " Camera |"; + if ( value & VideoEncodeContentFlagBitsKHR::eDesktop ) + result += " Desktop |"; + if ( value & VideoEncodeContentFlagBitsKHR::eRendered ) + result += " Rendered |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Default"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRateControlFlagsKHR ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeRateControlModeFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeRateControlModeFlagBitsKHR::eDisabled ) + result += " Disabled |"; + if ( value & VideoEncodeRateControlModeFlagBitsKHR::eCbr ) + result += " Cbr |"; + if ( value & VideoEncodeRateControlModeFlagBitsKHR::eVbr ) + result += " Vbr |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Default"; + return result; + } + + //=== VK_NV_device_diagnostics_config === + + VULKAN_HPP_INLINE std::string to_string( DeviceDiagnosticsConfigFlagsNV value ) + { + std::string result = "{"; + if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo ) + result += " EnableShaderDebugInfo |"; + if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking ) + result += " EnableResourceTracking |"; + if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints ) + result += " EnableAutomaticCheckpoints |"; + if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting ) + result += " EnableShaderErrorReporting |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_QCOM_tile_shading === + + VULKAN_HPP_INLINE std::string to_string( TileShadingRenderPassFlagsQCOM value ) + { + std::string result = "{"; + if ( value & TileShadingRenderPassFlagBitsQCOM::eEnable ) + result += " Enable |"; + if ( value & TileShadingRenderPassFlagBitsQCOM::ePerTileExecution ) + result += " PerTileExecution |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + + VULKAN_HPP_INLINE std::string to_string( ExportMetalObjectTypeFlagsEXT value ) + { + std::string result = "{"; + if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalDevice ) + result += " MetalDevice |"; + if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue ) + result += " MetalCommandQueue |"; + if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer ) + result += " MetalBuffer |"; + if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalTexture ) + result += " MetalTexture |"; + if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface ) + result += " MetalIosurface |"; + if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent ) + result += " MetalSharedEvent |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_graphics_pipeline_library === + + VULKAN_HPP_INLINE std::string to_string( GraphicsPipelineLibraryFlagsEXT value ) + { + std::string result = "{"; + if ( value & GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface ) + result += " VertexInputInterface |"; + if ( value & GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders ) + result += " PreRasterizationShaders |"; + if ( value & GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader ) + result += " FragmentShader |"; + if ( value & GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface ) + result += " FragmentOutputInterface |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_NV_ray_tracing_motion_blur === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInfoFlagsNV ) + { + return "{}"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInstanceFlagsNV ) + { + return "{}"; + } + + //=== VK_EXT_image_compression_control === + + VULKAN_HPP_INLINE std::string to_string( ImageCompressionFlagsEXT value ) + { + std::string result = "{"; + if ( value & ImageCompressionFlagBitsEXT::eFixedRateDefault ) + result += " FixedRateDefault |"; + if ( value & ImageCompressionFlagBitsEXT::eFixedRateExplicit ) + result += " FixedRateExplicit |"; + if ( value & ImageCompressionFlagBitsEXT::eDisabled ) + result += " Disabled |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Default"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ImageCompressionFixedRateFlagsEXT value ) + { + std::string result = "{"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e1Bpc ) + result += " 1Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e2Bpc ) + result += " 2Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e3Bpc ) + result += " 3Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e4Bpc ) + result += " 4Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e5Bpc ) + result += " 5Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e6Bpc ) + result += " 6Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e7Bpc ) + result += " 7Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e8Bpc ) + result += " 8Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e9Bpc ) + result += " 9Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e10Bpc ) + result += " 10Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e11Bpc ) + result += " 11Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e12Bpc ) + result += " 12Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e13Bpc ) + result += " 13Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e14Bpc ) + result += " 14Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e15Bpc ) + result += " 15Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e16Bpc ) + result += " 16Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e17Bpc ) + result += " 17Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e18Bpc ) + result += " 18Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e19Bpc ) + result += " 19Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e20Bpc ) + result += " 20Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e21Bpc ) + result += " 21Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e22Bpc ) + result += " 22Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e23Bpc ) + result += " 23Bpc |"; + if ( value & ImageCompressionFixedRateFlagBitsEXT::e24Bpc ) + result += " 24Bpc |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "None"; + return result; + } + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectFBSurfaceCreateFlagsEXT ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_device_address_binding_report === + + VULKAN_HPP_INLINE std::string to_string( DeviceAddressBindingFlagsEXT value ) + { + std::string result = "{"; + if ( value & DeviceAddressBindingFlagBitsEXT::eInternalObject ) + result += " InternalObject |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageFormatConstraintsFlagsFUCHSIA ) + { + return "{}"; + } + + VULKAN_HPP_INLINE std::string to_string( ImageConstraintsInfoFlagsFUCHSIA value ) + { + std::string result = "{"; + if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely ) + result += " CpuReadRarely |"; + if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften ) + result += " CpuReadOften |"; + if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely ) + result += " CpuWriteRarely |"; + if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften ) + result += " CpuWriteOften |"; + if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional ) + result += " ProtectedOptional |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_frame_boundary === + + VULKAN_HPP_INLINE std::string to_string( FrameBoundaryFlagsEXT value ) + { + std::string result = "{"; + if ( value & FrameBoundaryFlagBitsEXT::eFrameEnd ) + result += " FrameEnd |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ScreenSurfaceCreateFlagsQNX ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_VALVE_video_encode_rgb_conversion === + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbModelConversionFlagsVALVE value ) + { + std::string result = "{"; + if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity ) + result += " RgbIdentity |"; + if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcrIdentity ) + result += " YcbcrIdentity |"; + if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr709 ) + result += " Ycbcr709 |"; + if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr601 ) + result += " Ycbcr601 |"; + if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr2020 ) + result += " Ycbcr2020 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbRangeCompressionFlagsVALVE value ) + { + std::string result = "{"; + if ( value & VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange ) + result += " FullRange |"; + if ( value & VideoEncodeRgbRangeCompressionFlagBitsVALVE::eNarrowRange ) + result += " NarrowRange |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbChromaOffsetFlagsVALVE value ) + { + std::string result = "{"; + if ( value & VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven ) + result += " CositedEven |"; + if ( value & VideoEncodeRgbChromaOffsetFlagBitsVALVE::eMidpoint ) + result += " Midpoint |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_EXT_opacity_micromap === + + VULKAN_HPP_INLINE std::string to_string( BuildMicromapFlagsEXT value ) + { + std::string result = "{"; + if ( value & BuildMicromapFlagBitsEXT::ePreferFastTrace ) + result += " PreferFastTrace |"; + if ( value & BuildMicromapFlagBitsEXT::ePreferFastBuild ) + result += " PreferFastBuild |"; + if ( value & BuildMicromapFlagBitsEXT::eAllowCompaction ) + result += " AllowCompaction |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( MicromapCreateFlagsEXT value ) + { + std::string result = "{"; + if ( value & MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay ) + result += " DeviceAddressCaptureReplay |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_ARM_scheduling_controls === + + VULKAN_HPP_INLINE std::string to_string( PhysicalDeviceSchedulingControlsFlagsARM value ) + { + std::string result = "{"; + if ( value & PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount ) + result += " ShaderCoreCount |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_LUNARG_direct_driver_loading === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectDriverLoadingFlagsLUNARG ) + { + return "{}"; + } + + //=== VK_ARM_tensors === + + VULKAN_HPP_INLINE std::string to_string( TensorCreateFlagsARM value ) + { + std::string result = "{"; + if ( value & TensorCreateFlagBitsARM::eMutableFormat ) + result += " MutableFormat |"; + if ( value & TensorCreateFlagBitsARM::eProtected ) + result += " Protected |"; + if ( value & TensorCreateFlagBitsARM::eDescriptorHeapCaptureReplay ) + result += " DescriptorHeapCaptureReplay |"; + if ( value & TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay ) + result += " DescriptorBufferCaptureReplay |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( TensorUsageFlagsARM value ) + { + std::string result = "{"; + if ( value & TensorUsageFlagBitsARM::eShader ) + result += " Shader |"; + if ( value & TensorUsageFlagBitsARM::eTransferSrc ) + result += " TransferSrc |"; + if ( value & TensorUsageFlagBitsARM::eTransferDst ) + result += " TransferDst |"; + if ( value & TensorUsageFlagBitsARM::eImageAliasing ) + result += " ImageAliasing |"; + if ( value & TensorUsageFlagBitsARM::eDataGraph ) + result += " DataGraph |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_NV_optical_flow === + + VULKAN_HPP_INLINE std::string to_string( OpticalFlowUsageFlagsNV value ) + { + std::string result = "{"; + if ( value & OpticalFlowUsageFlagBitsNV::eInput ) + result += " Input |"; + if ( value & OpticalFlowUsageFlagBitsNV::eOutput ) + result += " Output |"; + if ( value & OpticalFlowUsageFlagBitsNV::eHint ) + result += " Hint |"; + if ( value & OpticalFlowUsageFlagBitsNV::eCost ) + result += " Cost |"; + if ( value & OpticalFlowUsageFlagBitsNV::eGlobalFlow ) + result += " GlobalFlow |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Unknown"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( OpticalFlowGridSizeFlagsNV value ) + { + std::string result = "{"; + if ( value & OpticalFlowGridSizeFlagBitsNV::e1X1 ) + result += " 1X1 |"; + if ( value & OpticalFlowGridSizeFlagBitsNV::e2X2 ) + result += " 2X2 |"; + if ( value & OpticalFlowGridSizeFlagBitsNV::e4X4 ) + result += " 4X4 |"; + if ( value & OpticalFlowGridSizeFlagBitsNV::e8X8 ) + result += " 8X8 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "Unknown"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( OpticalFlowSessionCreateFlagsNV value ) + { + std::string result = "{"; + if ( value & OpticalFlowSessionCreateFlagBitsNV::eEnableHint ) + result += " EnableHint |"; + if ( value & OpticalFlowSessionCreateFlagBitsNV::eEnableCost ) + result += " EnableCost |"; + if ( value & OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow ) + result += " EnableGlobalFlow |"; + if ( value & OpticalFlowSessionCreateFlagBitsNV::eAllowRegions ) + result += " AllowRegions |"; + if ( value & OpticalFlowSessionCreateFlagBitsNV::eBothDirections ) + result += " BothDirections |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( OpticalFlowExecuteFlagsNV value ) + { + std::string result = "{"; + if ( value & OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints ) + result += " DisableTemporalHints |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_EXT_shader_object === + + VULKAN_HPP_INLINE std::string to_string( ShaderCreateFlagsEXT value ) + { + std::string result = "{"; + if ( value & ShaderCreateFlagBitsEXT::eLinkStage ) + result += " LinkStage |"; + if ( value & ShaderCreateFlagBitsEXT::eDescriptorHeap ) + result += " DescriptorHeap |"; + if ( value & ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize ) + result += " AllowVaryingSubgroupSize |"; + if ( value & ShaderCreateFlagBitsEXT::eRequireFullSubgroups ) + result += " RequireFullSubgroups |"; + if ( value & ShaderCreateFlagBitsEXT::eNoTaskShader ) + result += " NoTaskShader |"; + if ( value & ShaderCreateFlagBitsEXT::eDispatchBase ) + result += " DispatchBase |"; + if ( value & ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment ) + result += " FragmentShadingRateAttachment |"; + if ( value & ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment ) + result += " FragmentDensityMapAttachment |"; + if ( value & ShaderCreateFlagBitsEXT::eIndirectBindable ) + result += " IndirectBindable |"; + if ( value & ShaderCreateFlagBitsEXT::e64BitIndexing ) + result += " 64BitIndexing |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_KHR_surface_maintenance1 === + + VULKAN_HPP_INLINE std::string to_string( PresentScalingFlagsKHR value ) + { + std::string result = "{"; + if ( value & PresentScalingFlagBitsKHR::eOneToOne ) + result += " OneToOne |"; + if ( value & PresentScalingFlagBitsKHR::eAspectRatioStretch ) + result += " AspectRatioStretch |"; + if ( value & PresentScalingFlagBitsKHR::eStretch ) + result += " Stretch |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( PresentGravityFlagsKHR value ) + { + std::string result = "{"; + if ( value & PresentGravityFlagBitsKHR::eMin ) + result += " Min |"; + if ( value & PresentGravityFlagBitsKHR::eMax ) + result += " Max |"; + if ( value & PresentGravityFlagBitsKHR::eCentered ) + result += " Centered |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_ARM_data_graph === + + VULKAN_HPP_INLINE std::string to_string( DataGraphPipelineSessionCreateFlagsARM value ) + { + std::string result = "{"; + if ( value & DataGraphPipelineSessionCreateFlagBitsARM::eProtected ) + result += " Protected |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineDispatchFlagsARM ) + { + return "{}"; + } + + //=== VK_KHR_video_encode_av1 === + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1CapabilityFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::ePerRateControlGroupMinMaxQIndex ) + result += " PerRateControlGroupMinMaxQIndex |"; + if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eGenerateObuExtensionHeader ) + result += " GenerateObuExtensionHeader |"; + if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::ePrimaryReferenceCdfOnly ) + result += " PrimaryReferenceCdfOnly |"; + if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eFrameSizeOverride ) + result += " FrameSizeOverride |"; + if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eMotionVectorScaling ) + result += " MotionVectorScaling |"; + if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eCompoundPredictionIntraRefresh ) + result += " CompoundPredictionIntraRefresh |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1StdFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeAV1StdFlagBitsKHR::eUniformTileSpacingFlagSet ) + result += " UniformTileSpacingFlagSet |"; + if ( value & VideoEncodeAV1StdFlagBitsKHR::eSkipModePresentUnset ) + result += " SkipModePresentUnset |"; + if ( value & VideoEncodeAV1StdFlagBitsKHR::ePrimaryRefFrame ) + result += " PrimaryRefFrame |"; + if ( value & VideoEncodeAV1StdFlagBitsKHR::eDeltaQ ) + result += " DeltaQ |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1SuperblockSizeFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeAV1SuperblockSizeFlagBitsKHR::e64 ) + result += " 64 |"; + if ( value & VideoEncodeAV1SuperblockSizeFlagBitsKHR::e128 ) + result += " 128 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1RateControlFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eRegularGop ) + result += " RegularGop |"; + if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eTemporalLayerPatternDyadic ) + result += " TemporalLayerPatternDyadic |"; + if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternFlat ) + result += " ReferencePatternFlat |"; + if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternDyadic ) + result += " ReferencePatternDyadic |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_KHR_copy_memory_indirect === + + VULKAN_HPP_INLINE std::string to_string( AddressCopyFlagsKHR value ) + { + std::string result = "{"; + if ( value & AddressCopyFlagBitsKHR::eDeviceLocal ) + result += " DeviceLocal |"; + if ( value & AddressCopyFlagBitsKHR::eSparse ) + result += " Sparse |"; + if ( value & AddressCopyFlagBitsKHR::eProtected ) + result += " Protected |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_EXT_memory_decompression === + + VULKAN_HPP_INLINE std::string to_string( MemoryDecompressionMethodFlagsEXT value ) + { + std::string result = "{"; + if ( value & MemoryDecompressionMethodFlagBitsEXT::eGdeflate10 ) + result += " Gdeflate10 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_KHR_video_encode_intra_refresh === + + VULKAN_HPP_INLINE std::string to_string( VideoEncodeIntraRefreshModeFlagsKHR value ) + { + std::string result = "{"; + if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::ePerPicturePartition ) + result += " PerPicturePartition |"; + if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockBased ) + result += " BlockBased |"; + if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockRowBased ) + result += " BlockRowBased |"; + if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockColumnBased ) + result += " BlockColumnBased |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "None"; + return result; + } + + //=== VK_NV_cluster_acceleration_structure === + + VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureClusterFlagsNV value ) + { + std::string result = "{"; + if ( value & ClusterAccelerationStructureClusterFlagBitsNV::eAllowDisableOpacityMicromaps ) + result += " AllowDisableOpacityMicromaps |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureGeometryFlagsNV value ) + { + std::string result = "{"; + if ( value & ClusterAccelerationStructureGeometryFlagBitsNV::eCullDisable ) + result += " CullDisable |"; + if ( value & ClusterAccelerationStructureGeometryFlagBitsNV::eNoDuplicateAnyhitInvocation ) + result += " NoDuplicateAnyhitInvocation |"; + if ( value & ClusterAccelerationStructureGeometryFlagBitsNV::eOpaque ) + result += " Opaque |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureAddressResolutionFlagsNV value ) + { + std::string result = "{"; + if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstImplicitData ) + result += " IndirectedDstImplicitData |"; + if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedScratchData ) + result += " IndirectedScratchData |"; + if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstAddressArray ) + result += " IndirectedDstAddressArray |"; + if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstSizesArray ) + result += " IndirectedDstSizesArray |"; + if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosArray ) + result += " IndirectedSrcInfosArray |"; + if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosCount ) + result += " IndirectedSrcInfosCount |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "None"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureIndexFormatFlagsNV value ) + { + std::string result = "{"; + if ( value & ClusterAccelerationStructureIndexFormatFlagBitsNV::e8 ) + result += " 8 |"; + if ( value & ClusterAccelerationStructureIndexFormatFlagBitsNV::e16 ) + result += " 16 |"; + if ( value & ClusterAccelerationStructureIndexFormatFlagBitsNV::e32 ) + result += " 32 |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_NV_partitioned_acceleration_structure === + + VULKAN_HPP_INLINE std::string to_string( PartitionedAccelerationStructureInstanceFlagsNV value ) + { + std::string result = "{"; + if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFacingCullDisable ) + result += " FlagTriangleFacingCullDisable |"; + if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFlipFacing ) + result += " FlagTriangleFlipFacing |"; + if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceOpaque ) + result += " FlagForceOpaque |"; + if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceNoOpaque ) + result += " FlagForceNoOpaque |"; + if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagEnableExplicitBoundingBox ) + result += " FlagEnableExplicitBoundingBox |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_EXT_device_generated_commands === + + VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsEXT value ) + { + std::string result = "{"; + if ( value & IndirectCommandsLayoutUsageFlagBitsEXT::eExplicitPreprocess ) + result += " ExplicitPreprocess |"; + if ( value & IndirectCommandsLayoutUsageFlagBitsEXT::eUnorderedSequences ) + result += " UnorderedSequences |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( IndirectCommandsInputModeFlagsEXT value ) + { + std::string result = "{"; + if ( value & IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer ) + result += " VulkanIndexBuffer |"; + if ( value & IndirectCommandsInputModeFlagBitsEXT::eDxgiIndexBuffer ) + result += " DxgiIndexBuffer |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //=== VK_KHR_maintenance8 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlags3KHR ) + { + return "None"; + } + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceCreateFlagsOHOS ) + { + return "{}"; + } +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_ARM_performance_counters_by_region === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagsARM ) + { + return "{}"; + } + + //=== VK_KHR_maintenance10 === + + VULKAN_HPP_INLINE std::string to_string( RenderingAttachmentFlagsKHR value ) + { + std::string result = "{"; + if ( value & RenderingAttachmentFlagBitsKHR::eInputAttachmentFeedback ) + result += " InputAttachmentFeedback |"; + if ( value & RenderingAttachmentFlagBitsKHR::eResolveSkipTransferFunction ) + result += " ResolveSkipTransferFunction |"; + if ( value & RenderingAttachmentFlagBitsKHR::eResolveEnableTransferFunction ) + result += " ResolveEnableTransferFunction |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + VULKAN_HPP_INLINE std::string to_string( ResolveImageFlagsKHR value ) + { + std::string result = "{"; + if ( value & ResolveImageFlagBitsKHR::eSkipTransferFunction ) + result += " SkipTransferFunction |"; + if ( value & ResolveImageFlagBitsKHR::eEnableTransferFunction ) + result += " EnableTransferFunction |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + + //======================= + //=== ENUMs to_string === + //======================= + + VULKAN_HPP_INLINE std::string toHexString( uint32_t value ) + { +#if __cpp_lib_format + return std::format( "{:x}", value ); +#else + std::stringstream stream; + stream << std::hex << value; + return stream.str(); +#endif + } + + //=== VK_VERSION_1_0 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Result value ) + { + switch ( value ) + { + case Result::eSuccess : return "Success"; + case Result::eNotReady : return "NotReady"; + case Result::eTimeout : return "Timeout"; + case Result::eEventSet : return "EventSet"; + case Result::eEventReset : return "EventReset"; + case Result::eIncomplete : return "Incomplete"; + case Result::eErrorOutOfHostMemory : return "ErrorOutOfHostMemory"; + case Result::eErrorOutOfDeviceMemory : return "ErrorOutOfDeviceMemory"; + case Result::eErrorInitializationFailed : return "ErrorInitializationFailed"; + case Result::eErrorDeviceLost : return "ErrorDeviceLost"; + case Result::eErrorMemoryMapFailed : return "ErrorMemoryMapFailed"; + case Result::eErrorLayerNotPresent : return "ErrorLayerNotPresent"; + case Result::eErrorExtensionNotPresent : return "ErrorExtensionNotPresent"; + case Result::eErrorFeatureNotPresent : return "ErrorFeatureNotPresent"; + case Result::eErrorIncompatibleDriver : return "ErrorIncompatibleDriver"; + case Result::eErrorTooManyObjects : return "ErrorTooManyObjects"; + case Result::eErrorFormatNotSupported : return "ErrorFormatNotSupported"; + case Result::eErrorFragmentedPool : return "ErrorFragmentedPool"; + case Result::eErrorUnknown : return "ErrorUnknown"; + case Result::eErrorValidationFailed : return "ErrorValidationFailed"; + case Result::eErrorOutOfPoolMemory : return "ErrorOutOfPoolMemory"; + case Result::eErrorInvalidExternalHandle : return "ErrorInvalidExternalHandle"; + case Result::eErrorInvalidOpaqueCaptureAddress : return "ErrorInvalidOpaqueCaptureAddress"; + case Result::eErrorFragmentation : return "ErrorFragmentation"; + case Result::ePipelineCompileRequired : return "PipelineCompileRequired"; + case Result::eErrorNotPermitted : return "ErrorNotPermitted"; + case Result::eErrorSurfaceLostKHR : return "ErrorSurfaceLostKHR"; + case Result::eErrorNativeWindowInUseKHR : return "ErrorNativeWindowInUseKHR"; + case Result::eSuboptimalKHR : return "SuboptimalKHR"; + case Result::eErrorOutOfDateKHR : return "ErrorOutOfDateKHR"; + case Result::eErrorIncompatibleDisplayKHR : return "ErrorIncompatibleDisplayKHR"; + case Result::eErrorInvalidShaderNV : return "ErrorInvalidShaderNV"; + case Result::eErrorImageUsageNotSupportedKHR : return "ErrorImageUsageNotSupportedKHR"; + case Result::eErrorVideoPictureLayoutNotSupportedKHR : return "ErrorVideoPictureLayoutNotSupportedKHR"; + case Result::eErrorVideoProfileOperationNotSupportedKHR : return "ErrorVideoProfileOperationNotSupportedKHR"; + case Result::eErrorVideoProfileFormatNotSupportedKHR : return "ErrorVideoProfileFormatNotSupportedKHR"; + case Result::eErrorVideoProfileCodecNotSupportedKHR : return "ErrorVideoProfileCodecNotSupportedKHR"; + case Result::eErrorVideoStdVersionNotSupportedKHR : return "ErrorVideoStdVersionNotSupportedKHR"; + case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT"; + case Result::eErrorPresentTimingQueueFullEXT : return "ErrorPresentTimingQueueFullEXT"; +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + case Result::eErrorFullScreenExclusiveModeLostEXT: return "ErrorFullScreenExclusiveModeLostEXT"; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + case Result::eThreadIdleKHR : return "ThreadIdleKHR"; + case Result::eThreadDoneKHR : return "ThreadDoneKHR"; + case Result::eOperationDeferredKHR : return "OperationDeferredKHR"; + case Result::eOperationNotDeferredKHR : return "OperationNotDeferredKHR"; + case Result::eErrorInvalidVideoStdParametersKHR: return "ErrorInvalidVideoStdParametersKHR"; + case Result::eErrorCompressionExhaustedEXT : return "ErrorCompressionExhaustedEXT"; + case Result::eIncompatibleShaderBinaryEXT : return "IncompatibleShaderBinaryEXT"; + case Result::ePipelineBinaryMissingKHR : return "PipelineBinaryMissingKHR"; + case Result::eErrorNotEnoughSpaceKHR : return "ErrorNotEnoughSpaceKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StructureType value ) + { + switch ( value ) + { + case StructureType::eApplicationInfo : return "ApplicationInfo"; + case StructureType::eInstanceCreateInfo : return "InstanceCreateInfo"; + case StructureType::eDeviceQueueCreateInfo : return "DeviceQueueCreateInfo"; + case StructureType::eDeviceCreateInfo : return "DeviceCreateInfo"; + case StructureType::eSubmitInfo : return "SubmitInfo"; + case StructureType::eMemoryAllocateInfo : return "MemoryAllocateInfo"; + case StructureType::eMappedMemoryRange : return "MappedMemoryRange"; + case StructureType::eBindSparseInfo : return "BindSparseInfo"; + case StructureType::eFenceCreateInfo : return "FenceCreateInfo"; + case StructureType::eSemaphoreCreateInfo : return "SemaphoreCreateInfo"; + case StructureType::eEventCreateInfo : return "EventCreateInfo"; + case StructureType::eQueryPoolCreateInfo : return "QueryPoolCreateInfo"; + case StructureType::eBufferCreateInfo : return "BufferCreateInfo"; + case StructureType::eBufferViewCreateInfo : return "BufferViewCreateInfo"; + case StructureType::eImageCreateInfo : return "ImageCreateInfo"; + case StructureType::eImageViewCreateInfo : return "ImageViewCreateInfo"; + case StructureType::eShaderModuleCreateInfo : return "ShaderModuleCreateInfo"; + case StructureType::ePipelineCacheCreateInfo : return "PipelineCacheCreateInfo"; + case StructureType::ePipelineShaderStageCreateInfo : return "PipelineShaderStageCreateInfo"; + case StructureType::ePipelineVertexInputStateCreateInfo : return "PipelineVertexInputStateCreateInfo"; + case StructureType::ePipelineInputAssemblyStateCreateInfo : return "PipelineInputAssemblyStateCreateInfo"; + case StructureType::ePipelineTessellationStateCreateInfo : return "PipelineTessellationStateCreateInfo"; + case StructureType::ePipelineViewportStateCreateInfo : return "PipelineViewportStateCreateInfo"; + case StructureType::ePipelineRasterizationStateCreateInfo : return "PipelineRasterizationStateCreateInfo"; + case StructureType::ePipelineMultisampleStateCreateInfo : return "PipelineMultisampleStateCreateInfo"; + case StructureType::ePipelineDepthStencilStateCreateInfo : return "PipelineDepthStencilStateCreateInfo"; + case StructureType::ePipelineColorBlendStateCreateInfo : return "PipelineColorBlendStateCreateInfo"; + case StructureType::ePipelineDynamicStateCreateInfo : return "PipelineDynamicStateCreateInfo"; + case StructureType::eGraphicsPipelineCreateInfo : return "GraphicsPipelineCreateInfo"; + case StructureType::eComputePipelineCreateInfo : return "ComputePipelineCreateInfo"; + case StructureType::ePipelineLayoutCreateInfo : return "PipelineLayoutCreateInfo"; + case StructureType::eSamplerCreateInfo : return "SamplerCreateInfo"; + case StructureType::eDescriptorSetLayoutCreateInfo : return "DescriptorSetLayoutCreateInfo"; + case StructureType::eDescriptorPoolCreateInfo : return "DescriptorPoolCreateInfo"; + case StructureType::eDescriptorSetAllocateInfo : return "DescriptorSetAllocateInfo"; + case StructureType::eWriteDescriptorSet : return "WriteDescriptorSet"; + case StructureType::eCopyDescriptorSet : return "CopyDescriptorSet"; + case StructureType::eFramebufferCreateInfo : return "FramebufferCreateInfo"; + case StructureType::eRenderPassCreateInfo : return "RenderPassCreateInfo"; + case StructureType::eCommandPoolCreateInfo : return "CommandPoolCreateInfo"; + case StructureType::eCommandBufferAllocateInfo : return "CommandBufferAllocateInfo"; + case StructureType::eCommandBufferInheritanceInfo : return "CommandBufferInheritanceInfo"; + case StructureType::eCommandBufferBeginInfo : return "CommandBufferBeginInfo"; + case StructureType::eRenderPassBeginInfo : return "RenderPassBeginInfo"; + case StructureType::eBufferMemoryBarrier : return "BufferMemoryBarrier"; + case StructureType::eImageMemoryBarrier : return "ImageMemoryBarrier"; + case StructureType::eMemoryBarrier : return "MemoryBarrier"; + case StructureType::eLoaderInstanceCreateInfo : return "LoaderInstanceCreateInfo"; + case StructureType::eLoaderDeviceCreateInfo : return "LoaderDeviceCreateInfo"; + case StructureType::eBindBufferMemoryInfo : return "BindBufferMemoryInfo"; + case StructureType::eBindImageMemoryInfo : return "BindImageMemoryInfo"; + case StructureType::eMemoryDedicatedRequirements : return "MemoryDedicatedRequirements"; + case StructureType::eMemoryDedicatedAllocateInfo : return "MemoryDedicatedAllocateInfo"; + case StructureType::eMemoryAllocateFlagsInfo : return "MemoryAllocateFlagsInfo"; + case StructureType::eDeviceGroupCommandBufferBeginInfo : return "DeviceGroupCommandBufferBeginInfo"; + case StructureType::eDeviceGroupSubmitInfo : return "DeviceGroupSubmitInfo"; + case StructureType::eDeviceGroupBindSparseInfo : return "DeviceGroupBindSparseInfo"; + case StructureType::eBindBufferMemoryDeviceGroupInfo : return "BindBufferMemoryDeviceGroupInfo"; + case StructureType::eBindImageMemoryDeviceGroupInfo : return "BindImageMemoryDeviceGroupInfo"; + case StructureType::ePhysicalDeviceGroupProperties : return "PhysicalDeviceGroupProperties"; + case StructureType::eDeviceGroupDeviceCreateInfo : return "DeviceGroupDeviceCreateInfo"; + case StructureType::eBufferMemoryRequirementsInfo2 : return "BufferMemoryRequirementsInfo2"; + case StructureType::eImageMemoryRequirementsInfo2 : return "ImageMemoryRequirementsInfo2"; + case StructureType::eImageSparseMemoryRequirementsInfo2 : return "ImageSparseMemoryRequirementsInfo2"; + case StructureType::eMemoryRequirements2 : return "MemoryRequirements2"; + case StructureType::eSparseImageMemoryRequirements2 : return "SparseImageMemoryRequirements2"; + case StructureType::ePhysicalDeviceFeatures2 : return "PhysicalDeviceFeatures2"; + case StructureType::ePhysicalDeviceProperties2 : return "PhysicalDeviceProperties2"; + case StructureType::eFormatProperties2 : return "FormatProperties2"; + case StructureType::eImageFormatProperties2 : return "ImageFormatProperties2"; + case StructureType::ePhysicalDeviceImageFormatInfo2 : return "PhysicalDeviceImageFormatInfo2"; + case StructureType::eQueueFamilyProperties2 : return "QueueFamilyProperties2"; + case StructureType::ePhysicalDeviceMemoryProperties2 : return "PhysicalDeviceMemoryProperties2"; + case StructureType::eSparseImageFormatProperties2 : return "SparseImageFormatProperties2"; + case StructureType::ePhysicalDeviceSparseImageFormatInfo2 : return "PhysicalDeviceSparseImageFormatInfo2"; + case StructureType::eImageViewUsageCreateInfo : return "ImageViewUsageCreateInfo"; + case StructureType::eProtectedSubmitInfo : return "ProtectedSubmitInfo"; + case StructureType::ePhysicalDeviceProtectedMemoryFeatures : return "PhysicalDeviceProtectedMemoryFeatures"; + case StructureType::ePhysicalDeviceProtectedMemoryProperties : return "PhysicalDeviceProtectedMemoryProperties"; + case StructureType::eDeviceQueueInfo2 : return "DeviceQueueInfo2"; + case StructureType::ePhysicalDeviceExternalImageFormatInfo : return "PhysicalDeviceExternalImageFormatInfo"; + case StructureType::eExternalImageFormatProperties : return "ExternalImageFormatProperties"; + case StructureType::ePhysicalDeviceExternalBufferInfo : return "PhysicalDeviceExternalBufferInfo"; + case StructureType::eExternalBufferProperties : return "ExternalBufferProperties"; + case StructureType::ePhysicalDeviceIdProperties : return "PhysicalDeviceIdProperties"; + case StructureType::eExternalMemoryBufferCreateInfo : return "ExternalMemoryBufferCreateInfo"; + case StructureType::eExternalMemoryImageCreateInfo : return "ExternalMemoryImageCreateInfo"; + case StructureType::eExportMemoryAllocateInfo : return "ExportMemoryAllocateInfo"; + case StructureType::ePhysicalDeviceExternalFenceInfo : return "PhysicalDeviceExternalFenceInfo"; + case StructureType::eExternalFenceProperties : return "ExternalFenceProperties"; + case StructureType::eExportFenceCreateInfo : return "ExportFenceCreateInfo"; + case StructureType::eExportSemaphoreCreateInfo : return "ExportSemaphoreCreateInfo"; + case StructureType::ePhysicalDeviceExternalSemaphoreInfo : return "PhysicalDeviceExternalSemaphoreInfo"; + case StructureType::eExternalSemaphoreProperties : return "ExternalSemaphoreProperties"; + case StructureType::ePhysicalDeviceSubgroupProperties : return "PhysicalDeviceSubgroupProperties"; + case StructureType::ePhysicalDevice16BitStorageFeatures : return "PhysicalDevice16BitStorageFeatures"; + case StructureType::ePhysicalDeviceVariablePointersFeatures : return "PhysicalDeviceVariablePointersFeatures"; + case StructureType::eDescriptorUpdateTemplateCreateInfo : return "DescriptorUpdateTemplateCreateInfo"; + case StructureType::ePhysicalDeviceMaintenance3Properties : return "PhysicalDeviceMaintenance3Properties"; + case StructureType::eDescriptorSetLayoutSupport : return "DescriptorSetLayoutSupport"; + case StructureType::eSamplerYcbcrConversionCreateInfo : return "SamplerYcbcrConversionCreateInfo"; + case StructureType::eSamplerYcbcrConversionInfo : return "SamplerYcbcrConversionInfo"; + case StructureType::eBindImagePlaneMemoryInfo : return "BindImagePlaneMemoryInfo"; + case StructureType::eImagePlaneMemoryRequirementsInfo : return "ImagePlaneMemoryRequirementsInfo"; + case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures : return "PhysicalDeviceSamplerYcbcrConversionFeatures"; + case StructureType::eSamplerYcbcrConversionImageFormatProperties : return "SamplerYcbcrConversionImageFormatProperties"; + case StructureType::eDeviceGroupRenderPassBeginInfo : return "DeviceGroupRenderPassBeginInfo"; + case StructureType::ePhysicalDevicePointClippingProperties : return "PhysicalDevicePointClippingProperties"; + case StructureType::eRenderPassInputAttachmentAspectCreateInfo : return "RenderPassInputAttachmentAspectCreateInfo"; + case StructureType::ePipelineTessellationDomainOriginStateCreateInfo : return "PipelineTessellationDomainOriginStateCreateInfo"; + case StructureType::eRenderPassMultiviewCreateInfo : return "RenderPassMultiviewCreateInfo"; + case StructureType::ePhysicalDeviceMultiviewFeatures : return "PhysicalDeviceMultiviewFeatures"; + case StructureType::ePhysicalDeviceMultiviewProperties : return "PhysicalDeviceMultiviewProperties"; + case StructureType::ePhysicalDeviceShaderDrawParametersFeatures : return "PhysicalDeviceShaderDrawParametersFeatures"; + case StructureType::ePhysicalDeviceVulkan11Features : return "PhysicalDeviceVulkan11Features"; + case StructureType::ePhysicalDeviceVulkan11Properties : return "PhysicalDeviceVulkan11Properties"; + case StructureType::ePhysicalDeviceVulkan12Features : return "PhysicalDeviceVulkan12Features"; + case StructureType::ePhysicalDeviceVulkan12Properties : return "PhysicalDeviceVulkan12Properties"; + case StructureType::eImageFormatListCreateInfo : return "ImageFormatListCreateInfo"; + case StructureType::ePhysicalDeviceDriverProperties : return "PhysicalDeviceDriverProperties"; + case StructureType::ePhysicalDeviceVulkanMemoryModelFeatures : return "PhysicalDeviceVulkanMemoryModelFeatures"; + case StructureType::ePhysicalDeviceHostQueryResetFeatures : return "PhysicalDeviceHostQueryResetFeatures"; + case StructureType::ePhysicalDeviceTimelineSemaphoreFeatures : return "PhysicalDeviceTimelineSemaphoreFeatures"; + case StructureType::ePhysicalDeviceTimelineSemaphoreProperties : return "PhysicalDeviceTimelineSemaphoreProperties"; + case StructureType::eSemaphoreTypeCreateInfo : return "SemaphoreTypeCreateInfo"; + case StructureType::eTimelineSemaphoreSubmitInfo : return "TimelineSemaphoreSubmitInfo"; + case StructureType::eSemaphoreWaitInfo : return "SemaphoreWaitInfo"; + case StructureType::eSemaphoreSignalInfo : return "SemaphoreSignalInfo"; + case StructureType::ePhysicalDeviceBufferDeviceAddressFeatures : return "PhysicalDeviceBufferDeviceAddressFeatures"; + case StructureType::eBufferDeviceAddressInfo : return "BufferDeviceAddressInfo"; + case StructureType::eBufferOpaqueCaptureAddressCreateInfo : return "BufferOpaqueCaptureAddressCreateInfo"; + case StructureType::eMemoryOpaqueCaptureAddressAllocateInfo : return "MemoryOpaqueCaptureAddressAllocateInfo"; + case StructureType::eDeviceMemoryOpaqueCaptureAddressInfo : return "DeviceMemoryOpaqueCaptureAddressInfo"; + case StructureType::ePhysicalDevice8BitStorageFeatures : return "PhysicalDevice8BitStorageFeatures"; + case StructureType::ePhysicalDeviceShaderAtomicInt64Features : return "PhysicalDeviceShaderAtomicInt64Features"; + case StructureType::ePhysicalDeviceShaderFloat16Int8Features : return "PhysicalDeviceShaderFloat16Int8Features"; + case StructureType::ePhysicalDeviceFloatControlsProperties : return "PhysicalDeviceFloatControlsProperties"; + case StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo : return "DescriptorSetLayoutBindingFlagsCreateInfo"; + case StructureType::ePhysicalDeviceDescriptorIndexingFeatures : return "PhysicalDeviceDescriptorIndexingFeatures"; + case StructureType::ePhysicalDeviceDescriptorIndexingProperties : return "PhysicalDeviceDescriptorIndexingProperties"; + case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo : return "DescriptorSetVariableDescriptorCountAllocateInfo"; + case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport : return "DescriptorSetVariableDescriptorCountLayoutSupport"; + case StructureType::ePhysicalDeviceScalarBlockLayoutFeatures : return "PhysicalDeviceScalarBlockLayoutFeatures"; + case StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties : return "PhysicalDeviceSamplerFilterMinmaxProperties"; + case StructureType::eSamplerReductionModeCreateInfo : return "SamplerReductionModeCreateInfo"; + case StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures : return "PhysicalDeviceUniformBufferStandardLayoutFeatures"; + case StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures : return "PhysicalDeviceShaderSubgroupExtendedTypesFeatures"; + case StructureType::eAttachmentDescription2 : return "AttachmentDescription2"; + case StructureType::eAttachmentReference2 : return "AttachmentReference2"; + case StructureType::eSubpassDescription2 : return "SubpassDescription2"; + case StructureType::eSubpassDependency2 : return "SubpassDependency2"; + case StructureType::eRenderPassCreateInfo2 : return "RenderPassCreateInfo2"; + case StructureType::eSubpassBeginInfo : return "SubpassBeginInfo"; + case StructureType::eSubpassEndInfo : return "SubpassEndInfo"; + case StructureType::ePhysicalDeviceDepthStencilResolveProperties : return "PhysicalDeviceDepthStencilResolveProperties"; + case StructureType::eSubpassDescriptionDepthStencilResolve : return "SubpassDescriptionDepthStencilResolve"; + case StructureType::eImageStencilUsageCreateInfo : return "ImageStencilUsageCreateInfo"; + case StructureType::ePhysicalDeviceImagelessFramebufferFeatures : return "PhysicalDeviceImagelessFramebufferFeatures"; + case StructureType::eFramebufferAttachmentsCreateInfo : return "FramebufferAttachmentsCreateInfo"; + case StructureType::eFramebufferAttachmentImageInfo : return "FramebufferAttachmentImageInfo"; + case StructureType::eRenderPassAttachmentBeginInfo : return "RenderPassAttachmentBeginInfo"; + case StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures : return "PhysicalDeviceSeparateDepthStencilLayoutsFeatures"; + case StructureType::eAttachmentReferenceStencilLayout : return "AttachmentReferenceStencilLayout"; + case StructureType::eAttachmentDescriptionStencilLayout : return "AttachmentDescriptionStencilLayout"; + case StructureType::ePhysicalDeviceVulkan13Features : return "PhysicalDeviceVulkan13Features"; + case StructureType::ePhysicalDeviceVulkan13Properties : return "PhysicalDeviceVulkan13Properties"; + case StructureType::ePhysicalDeviceToolProperties : return "PhysicalDeviceToolProperties"; + case StructureType::ePhysicalDevicePrivateDataFeatures : return "PhysicalDevicePrivateDataFeatures"; + case StructureType::eDevicePrivateDataCreateInfo : return "DevicePrivateDataCreateInfo"; + case StructureType::ePrivateDataSlotCreateInfo : return "PrivateDataSlotCreateInfo"; + case StructureType::eMemoryBarrier2 : return "MemoryBarrier2"; + case StructureType::eBufferMemoryBarrier2 : return "BufferMemoryBarrier2"; + case StructureType::eImageMemoryBarrier2 : return "ImageMemoryBarrier2"; + case StructureType::eDependencyInfo : return "DependencyInfo"; + case StructureType::eSubmitInfo2 : return "SubmitInfo2"; + case StructureType::eSemaphoreSubmitInfo : return "SemaphoreSubmitInfo"; + case StructureType::eCommandBufferSubmitInfo : return "CommandBufferSubmitInfo"; + case StructureType::ePhysicalDeviceSynchronization2Features : return "PhysicalDeviceSynchronization2Features"; + case StructureType::eCopyBufferInfo2 : return "CopyBufferInfo2"; + case StructureType::eCopyImageInfo2 : return "CopyImageInfo2"; + case StructureType::eCopyBufferToImageInfo2 : return "CopyBufferToImageInfo2"; + case StructureType::eCopyImageToBufferInfo2 : return "CopyImageToBufferInfo2"; + case StructureType::eBufferCopy2 : return "BufferCopy2"; + case StructureType::eImageCopy2 : return "ImageCopy2"; + case StructureType::eBufferImageCopy2 : return "BufferImageCopy2"; + case StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeatures : return "PhysicalDeviceTextureCompressionAstcHdrFeatures"; + case StructureType::eFormatProperties3 : return "FormatProperties3"; + case StructureType::ePhysicalDeviceMaintenance4Features : return "PhysicalDeviceMaintenance4Features"; + case StructureType::ePhysicalDeviceMaintenance4Properties : return "PhysicalDeviceMaintenance4Properties"; + case StructureType::eDeviceBufferMemoryRequirements : return "DeviceBufferMemoryRequirements"; + case StructureType::eDeviceImageMemoryRequirements : return "DeviceImageMemoryRequirements"; + case StructureType::ePipelineCreationFeedbackCreateInfo : return "PipelineCreationFeedbackCreateInfo"; + case StructureType::ePhysicalDeviceShaderTerminateInvocationFeatures : return "PhysicalDeviceShaderTerminateInvocationFeatures"; + case StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeatures: return "PhysicalDeviceShaderDemoteToHelperInvocationFeatures"; + case StructureType::ePhysicalDevicePipelineCreationCacheControlFeatures : return "PhysicalDevicePipelineCreationCacheControlFeatures"; + case StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures : return "PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures"; + case StructureType::ePhysicalDeviceImageRobustnessFeatures : return "PhysicalDeviceImageRobustnessFeatures"; + case StructureType::ePhysicalDeviceSubgroupSizeControlProperties : return "PhysicalDeviceSubgroupSizeControlProperties"; + case StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfo : return "PipelineShaderStageRequiredSubgroupSizeCreateInfo"; + case StructureType::ePhysicalDeviceSubgroupSizeControlFeatures : return "PhysicalDeviceSubgroupSizeControlFeatures"; + case StructureType::ePhysicalDeviceInlineUniformBlockFeatures : return "PhysicalDeviceInlineUniformBlockFeatures"; + case StructureType::ePhysicalDeviceInlineUniformBlockProperties : return "PhysicalDeviceInlineUniformBlockProperties"; + case StructureType::eWriteDescriptorSetInlineUniformBlock : return "WriteDescriptorSetInlineUniformBlock"; + case StructureType::eDescriptorPoolInlineUniformBlockCreateInfo : return "DescriptorPoolInlineUniformBlockCreateInfo"; + case StructureType::ePhysicalDeviceShaderIntegerDotProductFeatures : return "PhysicalDeviceShaderIntegerDotProductFeatures"; + case StructureType::ePhysicalDeviceShaderIntegerDotProductProperties : return "PhysicalDeviceShaderIntegerDotProductProperties"; + case StructureType::ePhysicalDeviceTexelBufferAlignmentProperties : return "PhysicalDeviceTexelBufferAlignmentProperties"; + case StructureType::eBlitImageInfo2 : return "BlitImageInfo2"; + case StructureType::eResolveImageInfo2 : return "ResolveImageInfo2"; + case StructureType::eImageBlit2 : return "ImageBlit2"; + case StructureType::eImageResolve2 : return "ImageResolve2"; + case StructureType::eRenderingInfo : return "RenderingInfo"; + case StructureType::eRenderingAttachmentInfo : return "RenderingAttachmentInfo"; + case StructureType::ePipelineRenderingCreateInfo : return "PipelineRenderingCreateInfo"; + case StructureType::ePhysicalDeviceDynamicRenderingFeatures : return "PhysicalDeviceDynamicRenderingFeatures"; + case StructureType::eCommandBufferInheritanceRenderingInfo : return "CommandBufferInheritanceRenderingInfo"; + case StructureType::ePhysicalDeviceVulkan14Features : return "PhysicalDeviceVulkan14Features"; + case StructureType::ePhysicalDeviceVulkan14Properties : return "PhysicalDeviceVulkan14Properties"; + case StructureType::eDeviceQueueGlobalPriorityCreateInfo : return "DeviceQueueGlobalPriorityCreateInfo"; + case StructureType::ePhysicalDeviceGlobalPriorityQueryFeatures : return "PhysicalDeviceGlobalPriorityQueryFeatures"; + case StructureType::eQueueFamilyGlobalPriorityProperties : return "QueueFamilyGlobalPriorityProperties"; + case StructureType::ePhysicalDeviceIndexTypeUint8Features : return "PhysicalDeviceIndexTypeUint8Features"; + case StructureType::eMemoryMapInfo : return "MemoryMapInfo"; + case StructureType::eMemoryUnmapInfo : return "MemoryUnmapInfo"; + case StructureType::ePhysicalDeviceMaintenance5Features : return "PhysicalDeviceMaintenance5Features"; + case StructureType::ePhysicalDeviceMaintenance5Properties : return "PhysicalDeviceMaintenance5Properties"; + case StructureType::eDeviceImageSubresourceInfo : return "DeviceImageSubresourceInfo"; + case StructureType::eSubresourceLayout2 : return "SubresourceLayout2"; + case StructureType::eImageSubresource2 : return "ImageSubresource2"; + case StructureType::eBufferUsageFlags2CreateInfo : return "BufferUsageFlags2CreateInfo"; + case StructureType::ePhysicalDeviceMaintenance6Features : return "PhysicalDeviceMaintenance6Features"; + case StructureType::ePhysicalDeviceMaintenance6Properties : return "PhysicalDeviceMaintenance6Properties"; + case StructureType::eBindMemoryStatus : return "BindMemoryStatus"; + case StructureType::ePhysicalDeviceHostImageCopyFeatures : return "PhysicalDeviceHostImageCopyFeatures"; + case StructureType::ePhysicalDeviceHostImageCopyProperties : return "PhysicalDeviceHostImageCopyProperties"; + case StructureType::eMemoryToImageCopy : return "MemoryToImageCopy"; + case StructureType::eImageToMemoryCopy : return "ImageToMemoryCopy"; + case StructureType::eCopyImageToMemoryInfo : return "CopyImageToMemoryInfo"; + case StructureType::eCopyMemoryToImageInfo : return "CopyMemoryToImageInfo"; + case StructureType::eHostImageLayoutTransitionInfo : return "HostImageLayoutTransitionInfo"; + case StructureType::eCopyImageToImageInfo : return "CopyImageToImageInfo"; + case StructureType::eSubresourceHostMemcpySize : return "SubresourceHostMemcpySize"; + case StructureType::eHostImageCopyDevicePerformanceQuery : return "HostImageCopyDevicePerformanceQuery"; + case StructureType::ePhysicalDeviceShaderSubgroupRotateFeatures : return "PhysicalDeviceShaderSubgroupRotateFeatures"; + case StructureType::ePhysicalDeviceShaderFloatControls2Features : return "PhysicalDeviceShaderFloatControls2Features"; + case StructureType::ePhysicalDeviceShaderExpectAssumeFeatures : return "PhysicalDeviceShaderExpectAssumeFeatures"; + case StructureType::ePipelineCreateFlags2CreateInfo : return "PipelineCreateFlags2CreateInfo"; + case StructureType::ePhysicalDevicePushDescriptorProperties : return "PhysicalDevicePushDescriptorProperties"; + case StructureType::eBindDescriptorSetsInfo : return "BindDescriptorSetsInfo"; + case StructureType::ePushConstantsInfo : return "PushConstantsInfo"; + case StructureType::ePushDescriptorSetInfo : return "PushDescriptorSetInfo"; + case StructureType::ePushDescriptorSetWithTemplateInfo : return "PushDescriptorSetWithTemplateInfo"; + case StructureType::ePhysicalDevicePipelineProtectedAccessFeatures : return "PhysicalDevicePipelineProtectedAccessFeatures"; + case StructureType::ePipelineRobustnessCreateInfo : return "PipelineRobustnessCreateInfo"; + case StructureType::ePhysicalDevicePipelineRobustnessFeatures : return "PhysicalDevicePipelineRobustnessFeatures"; + case StructureType::ePhysicalDevicePipelineRobustnessProperties : return "PhysicalDevicePipelineRobustnessProperties"; + case StructureType::ePhysicalDeviceLineRasterizationFeatures : return "PhysicalDeviceLineRasterizationFeatures"; + case StructureType::ePipelineRasterizationLineStateCreateInfo : return "PipelineRasterizationLineStateCreateInfo"; + case StructureType::ePhysicalDeviceLineRasterizationProperties : return "PhysicalDeviceLineRasterizationProperties"; + case StructureType::ePhysicalDeviceVertexAttributeDivisorProperties : return "PhysicalDeviceVertexAttributeDivisorProperties"; + case StructureType::ePipelineVertexInputDivisorStateCreateInfo : return "PipelineVertexInputDivisorStateCreateInfo"; + case StructureType::ePhysicalDeviceVertexAttributeDivisorFeatures : return "PhysicalDeviceVertexAttributeDivisorFeatures"; + case StructureType::eRenderingAreaInfo : return "RenderingAreaInfo"; + case StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeatures : return "PhysicalDeviceDynamicRenderingLocalReadFeatures"; + case StructureType::eRenderingAttachmentLocationInfo : return "RenderingAttachmentLocationInfo"; + case StructureType::eRenderingInputAttachmentIndexInfo : return "RenderingInputAttachmentIndexInfo"; + case StructureType::eSwapchainCreateInfoKHR : return "SwapchainCreateInfoKHR"; + case StructureType::ePresentInfoKHR : return "PresentInfoKHR"; + case StructureType::eDeviceGroupPresentCapabilitiesKHR : return "DeviceGroupPresentCapabilitiesKHR"; + case StructureType::eImageSwapchainCreateInfoKHR : return "ImageSwapchainCreateInfoKHR"; + case StructureType::eBindImageMemorySwapchainInfoKHR : return "BindImageMemorySwapchainInfoKHR"; + case StructureType::eAcquireNextImageInfoKHR : return "AcquireNextImageInfoKHR"; + case StructureType::eDeviceGroupPresentInfoKHR : return "DeviceGroupPresentInfoKHR"; + case StructureType::eDeviceGroupSwapchainCreateInfoKHR : return "DeviceGroupSwapchainCreateInfoKHR"; + case StructureType::eDisplayModeCreateInfoKHR : return "DisplayModeCreateInfoKHR"; + case StructureType::eDisplaySurfaceCreateInfoKHR : return "DisplaySurfaceCreateInfoKHR"; + case StructureType::eDisplayPresentInfoKHR : return "DisplayPresentInfoKHR"; +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR"; +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ +#if defined( VK_USE_PLATFORM_XCB_KHR ) + case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR"; +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR"; +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR"; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR"; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + case StructureType::eDebugReportCallbackCreateInfoEXT : return "DebugReportCallbackCreateInfoEXT"; + case StructureType::ePipelineRasterizationStateRasterizationOrderAMD: return "PipelineRasterizationStateRasterizationOrderAMD"; + case StructureType::eDebugMarkerObjectNameInfoEXT : return "DebugMarkerObjectNameInfoEXT"; + case StructureType::eDebugMarkerObjectTagInfoEXT : return "DebugMarkerObjectTagInfoEXT"; + case StructureType::eDebugMarkerMarkerInfoEXT : return "DebugMarkerMarkerInfoEXT"; + case StructureType::eVideoProfileInfoKHR : return "VideoProfileInfoKHR"; + case StructureType::eVideoCapabilitiesKHR : return "VideoCapabilitiesKHR"; + case StructureType::eVideoPictureResourceInfoKHR : return "VideoPictureResourceInfoKHR"; + case StructureType::eVideoSessionMemoryRequirementsKHR : return "VideoSessionMemoryRequirementsKHR"; + case StructureType::eBindVideoSessionMemoryInfoKHR : return "BindVideoSessionMemoryInfoKHR"; + case StructureType::eVideoSessionCreateInfoKHR : return "VideoSessionCreateInfoKHR"; + case StructureType::eVideoSessionParametersCreateInfoKHR : return "VideoSessionParametersCreateInfoKHR"; + case StructureType::eVideoSessionParametersUpdateInfoKHR : return "VideoSessionParametersUpdateInfoKHR"; + case StructureType::eVideoBeginCodingInfoKHR : return "VideoBeginCodingInfoKHR"; + case StructureType::eVideoEndCodingInfoKHR : return "VideoEndCodingInfoKHR"; + case StructureType::eVideoCodingControlInfoKHR : return "VideoCodingControlInfoKHR"; + case StructureType::eVideoReferenceSlotInfoKHR : return "VideoReferenceSlotInfoKHR"; + case StructureType::eQueueFamilyVideoPropertiesKHR : return "QueueFamilyVideoPropertiesKHR"; + case StructureType::eVideoProfileListInfoKHR : return "VideoProfileListInfoKHR"; + case StructureType::ePhysicalDeviceVideoFormatInfoKHR : return "PhysicalDeviceVideoFormatInfoKHR"; + case StructureType::eVideoFormatPropertiesKHR : return "VideoFormatPropertiesKHR"; + case StructureType::eQueueFamilyQueryResultStatusPropertiesKHR : return "QueueFamilyQueryResultStatusPropertiesKHR"; + case StructureType::eVideoDecodeInfoKHR : return "VideoDecodeInfoKHR"; + case StructureType::eVideoDecodeCapabilitiesKHR : return "VideoDecodeCapabilitiesKHR"; + case StructureType::eVideoDecodeUsageInfoKHR : return "VideoDecodeUsageInfoKHR"; + case StructureType::eDedicatedAllocationImageCreateInfoNV : return "DedicatedAllocationImageCreateInfoNV"; + case StructureType::eDedicatedAllocationBufferCreateInfoNV : return "DedicatedAllocationBufferCreateInfoNV"; + case StructureType::eDedicatedAllocationMemoryAllocateInfoNV : return "DedicatedAllocationMemoryAllocateInfoNV"; + case StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT : return "PhysicalDeviceTransformFeedbackFeaturesEXT"; + case StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT : return "PhysicalDeviceTransformFeedbackPropertiesEXT"; + case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT : return "PipelineRasterizationStateStreamCreateInfoEXT"; + case StructureType::eCuModuleCreateInfoNVX : return "CuModuleCreateInfoNVX"; + case StructureType::eCuFunctionCreateInfoNVX : return "CuFunctionCreateInfoNVX"; + case StructureType::eCuLaunchInfoNVX : return "CuLaunchInfoNVX"; + case StructureType::eCuModuleTexturingModeCreateInfoNVX : return "CuModuleTexturingModeCreateInfoNVX"; + case StructureType::eImageViewHandleInfoNVX : return "ImageViewHandleInfoNVX"; + case StructureType::eImageViewAddressPropertiesNVX : return "ImageViewAddressPropertiesNVX"; + case StructureType::eVideoEncodeH264CapabilitiesKHR : return "VideoEncodeH264CapabilitiesKHR"; + case StructureType::eVideoEncodeH264SessionParametersCreateInfoKHR : return "VideoEncodeH264SessionParametersCreateInfoKHR"; + case StructureType::eVideoEncodeH264SessionParametersAddInfoKHR : return "VideoEncodeH264SessionParametersAddInfoKHR"; + case StructureType::eVideoEncodeH264PictureInfoKHR : return "VideoEncodeH264PictureInfoKHR"; + case StructureType::eVideoEncodeH264DpbSlotInfoKHR : return "VideoEncodeH264DpbSlotInfoKHR"; + case StructureType::eVideoEncodeH264NaluSliceInfoKHR : return "VideoEncodeH264NaluSliceInfoKHR"; + case StructureType::eVideoEncodeH264GopRemainingFrameInfoKHR : return "VideoEncodeH264GopRemainingFrameInfoKHR"; + case StructureType::eVideoEncodeH264ProfileInfoKHR : return "VideoEncodeH264ProfileInfoKHR"; + case StructureType::eVideoEncodeH264RateControlInfoKHR : return "VideoEncodeH264RateControlInfoKHR"; + case StructureType::eVideoEncodeH264RateControlLayerInfoKHR : return "VideoEncodeH264RateControlLayerInfoKHR"; + case StructureType::eVideoEncodeH264SessionCreateInfoKHR : return "VideoEncodeH264SessionCreateInfoKHR"; + case StructureType::eVideoEncodeH264QualityLevelPropertiesKHR : return "VideoEncodeH264QualityLevelPropertiesKHR"; + case StructureType::eVideoEncodeH264SessionParametersGetInfoKHR : return "VideoEncodeH264SessionParametersGetInfoKHR"; + case StructureType::eVideoEncodeH264SessionParametersFeedbackInfoKHR: return "VideoEncodeH264SessionParametersFeedbackInfoKHR"; + case StructureType::eVideoEncodeH265CapabilitiesKHR : return "VideoEncodeH265CapabilitiesKHR"; + case StructureType::eVideoEncodeH265SessionParametersCreateInfoKHR : return "VideoEncodeH265SessionParametersCreateInfoKHR"; + case StructureType::eVideoEncodeH265SessionParametersAddInfoKHR : return "VideoEncodeH265SessionParametersAddInfoKHR"; + case StructureType::eVideoEncodeH265PictureInfoKHR : return "VideoEncodeH265PictureInfoKHR"; + case StructureType::eVideoEncodeH265DpbSlotInfoKHR : return "VideoEncodeH265DpbSlotInfoKHR"; + case StructureType::eVideoEncodeH265NaluSliceSegmentInfoKHR : return "VideoEncodeH265NaluSliceSegmentInfoKHR"; + case StructureType::eVideoEncodeH265GopRemainingFrameInfoKHR : return "VideoEncodeH265GopRemainingFrameInfoKHR"; + case StructureType::eVideoEncodeH265ProfileInfoKHR : return "VideoEncodeH265ProfileInfoKHR"; + case StructureType::eVideoEncodeH265RateControlInfoKHR : return "VideoEncodeH265RateControlInfoKHR"; + case StructureType::eVideoEncodeH265RateControlLayerInfoKHR : return "VideoEncodeH265RateControlLayerInfoKHR"; + case StructureType::eVideoEncodeH265SessionCreateInfoKHR : return "VideoEncodeH265SessionCreateInfoKHR"; + case StructureType::eVideoEncodeH265QualityLevelPropertiesKHR : return "VideoEncodeH265QualityLevelPropertiesKHR"; + case StructureType::eVideoEncodeH265SessionParametersGetInfoKHR : return "VideoEncodeH265SessionParametersGetInfoKHR"; + case StructureType::eVideoEncodeH265SessionParametersFeedbackInfoKHR: return "VideoEncodeH265SessionParametersFeedbackInfoKHR"; + case StructureType::eVideoDecodeH264CapabilitiesKHR : return "VideoDecodeH264CapabilitiesKHR"; + case StructureType::eVideoDecodeH264PictureInfoKHR : return "VideoDecodeH264PictureInfoKHR"; + case StructureType::eVideoDecodeH264ProfileInfoKHR : return "VideoDecodeH264ProfileInfoKHR"; + case StructureType::eVideoDecodeH264SessionParametersCreateInfoKHR : return "VideoDecodeH264SessionParametersCreateInfoKHR"; + case StructureType::eVideoDecodeH264SessionParametersAddInfoKHR : return "VideoDecodeH264SessionParametersAddInfoKHR"; + case StructureType::eVideoDecodeH264DpbSlotInfoKHR : return "VideoDecodeH264DpbSlotInfoKHR"; + case StructureType::eTextureLodGatherFormatPropertiesAMD : return "TextureLodGatherFormatPropertiesAMD"; +#if defined( VK_USE_PLATFORM_GGP ) + case StructureType::eStreamDescriptorSurfaceCreateInfoGGP: return "StreamDescriptorSurfaceCreateInfoGGP"; +#endif /*VK_USE_PLATFORM_GGP*/ + case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV: return "PhysicalDeviceCornerSampledImageFeaturesNV"; + case StructureType::eExternalMemoryImageCreateInfoNV : return "ExternalMemoryImageCreateInfoNV"; + case StructureType::eExportMemoryAllocateInfoNV : return "ExportMemoryAllocateInfoNV"; +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + case StructureType::eImportMemoryWin32HandleInfoNV : return "ImportMemoryWin32HandleInfoNV"; + case StructureType::eExportMemoryWin32HandleInfoNV : return "ExportMemoryWin32HandleInfoNV"; + case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV: return "Win32KeyedMutexAcquireReleaseInfoNV"; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT"; +#if defined( VK_USE_PLATFORM_VI_NN ) + case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN"; +#endif /*VK_USE_PLATFORM_VI_NN*/ + case StructureType::eImageViewAstcDecodeModeEXT : return "ImageViewAstcDecodeModeEXT"; + case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT: return "PhysicalDeviceAstcDecodeFeaturesEXT"; +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR"; + case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR"; + case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR"; + case StructureType::eMemoryGetWin32HandleInfoKHR : return "MemoryGetWin32HandleInfoKHR"; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR"; + case StructureType::eMemoryFdPropertiesKHR: return "MemoryFdPropertiesKHR"; + case StructureType::eMemoryGetFdInfoKHR : return "MemoryGetFdInfoKHR"; +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR: return "Win32KeyedMutexAcquireReleaseInfoKHR"; + case StructureType::eImportSemaphoreWin32HandleInfoKHR : return "ImportSemaphoreWin32HandleInfoKHR"; + case StructureType::eExportSemaphoreWin32HandleInfoKHR : return "ExportSemaphoreWin32HandleInfoKHR"; + case StructureType::eD3D12FenceSubmitInfoKHR : return "D3D12FenceSubmitInfoKHR"; + case StructureType::eSemaphoreGetWin32HandleInfoKHR : return "SemaphoreGetWin32HandleInfoKHR"; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + case StructureType::eImportSemaphoreFdInfoKHR : return "ImportSemaphoreFdInfoKHR"; + case StructureType::eSemaphoreGetFdInfoKHR : return "SemaphoreGetFdInfoKHR"; + case StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT : return "CommandBufferInheritanceConditionalRenderingInfoEXT"; + case StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT : return "PhysicalDeviceConditionalRenderingFeaturesEXT"; + case StructureType::eConditionalRenderingBeginInfoEXT : return "ConditionalRenderingBeginInfoEXT"; + case StructureType::ePresentRegionsKHR : return "PresentRegionsKHR"; + case StructureType::ePipelineViewportWScalingStateCreateInfoNV : return "PipelineViewportWScalingStateCreateInfoNV"; + case StructureType::eSurfaceCapabilities2EXT : return "SurfaceCapabilities2EXT"; + case StructureType::eDisplayPowerInfoEXT : return "DisplayPowerInfoEXT"; + case StructureType::eDeviceEventInfoEXT : return "DeviceEventInfoEXT"; + case StructureType::eDisplayEventInfoEXT : return "DisplayEventInfoEXT"; + case StructureType::eSwapchainCounterCreateInfoEXT : return "SwapchainCounterCreateInfoEXT"; + case StructureType::ePresentTimesInfoGOOGLE : return "PresentTimesInfoGOOGLE"; + case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX: return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"; + case StructureType::eMultiviewPerViewAttributesInfoNVX : return "MultiviewPerViewAttributesInfoNVX"; + case StructureType::ePipelineViewportSwizzleStateCreateInfoNV : return "PipelineViewportSwizzleStateCreateInfoNV"; + case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT : return "PhysicalDeviceDiscardRectanglePropertiesEXT"; + case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT : return "PipelineDiscardRectangleStateCreateInfoEXT"; + case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT : return "PhysicalDeviceConservativeRasterizationPropertiesEXT"; + case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT : return "PipelineRasterizationConservativeStateCreateInfoEXT"; + case StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT : return "PhysicalDeviceDepthClipEnableFeaturesEXT"; + case StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT : return "PipelineRasterizationDepthClipStateCreateInfoEXT"; + case StructureType::eHdrMetadataEXT : return "HdrMetadataEXT"; + case StructureType::ePhysicalDeviceRelaxedLineRasterizationFeaturesIMG : return "PhysicalDeviceRelaxedLineRasterizationFeaturesIMG"; + case StructureType::eSharedPresentSurfaceCapabilitiesKHR : return "SharedPresentSurfaceCapabilitiesKHR"; +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + case StructureType::eImportFenceWin32HandleInfoKHR: return "ImportFenceWin32HandleInfoKHR"; + case StructureType::eExportFenceWin32HandleInfoKHR: return "ExportFenceWin32HandleInfoKHR"; + case StructureType::eFenceGetWin32HandleInfoKHR : return "FenceGetWin32HandleInfoKHR"; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + case StructureType::eImportFenceFdInfoKHR : return "ImportFenceFdInfoKHR"; + case StructureType::eFenceGetFdInfoKHR : return "FenceGetFdInfoKHR"; + case StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR : return "PhysicalDevicePerformanceQueryFeaturesKHR"; + case StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR: return "PhysicalDevicePerformanceQueryPropertiesKHR"; + case StructureType::eQueryPoolPerformanceCreateInfoKHR : return "QueryPoolPerformanceCreateInfoKHR"; + case StructureType::ePerformanceQuerySubmitInfoKHR : return "PerformanceQuerySubmitInfoKHR"; + case StructureType::eAcquireProfilingLockInfoKHR : return "AcquireProfilingLockInfoKHR"; + case StructureType::ePerformanceCounterKHR : return "PerformanceCounterKHR"; + case StructureType::ePerformanceCounterDescriptionKHR : return "PerformanceCounterDescriptionKHR"; + case StructureType::ePhysicalDeviceSurfaceInfo2KHR : return "PhysicalDeviceSurfaceInfo2KHR"; + case StructureType::eSurfaceCapabilities2KHR : return "SurfaceCapabilities2KHR"; + case StructureType::eSurfaceFormat2KHR : return "SurfaceFormat2KHR"; + case StructureType::eDisplayProperties2KHR : return "DisplayProperties2KHR"; + case StructureType::eDisplayPlaneProperties2KHR : return "DisplayPlaneProperties2KHR"; + case StructureType::eDisplayModeProperties2KHR : return "DisplayModeProperties2KHR"; + case StructureType::eDisplayPlaneInfo2KHR : return "DisplayPlaneInfo2KHR"; + case StructureType::eDisplayPlaneCapabilities2KHR : return "DisplayPlaneCapabilities2KHR"; +#if defined( VK_USE_PLATFORM_IOS_MVK ) + case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK"; +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK"; +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + case StructureType::eDebugUtilsObjectNameInfoEXT : return "DebugUtilsObjectNameInfoEXT"; + case StructureType::eDebugUtilsObjectTagInfoEXT : return "DebugUtilsObjectTagInfoEXT"; + case StructureType::eDebugUtilsLabelEXT : return "DebugUtilsLabelEXT"; + case StructureType::eDebugUtilsMessengerCallbackDataEXT: return "DebugUtilsMessengerCallbackDataEXT"; + case StructureType::eDebugUtilsMessengerCreateInfoEXT : return "DebugUtilsMessengerCreateInfoEXT"; +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + case StructureType::eAndroidHardwareBufferUsageANDROID : return "AndroidHardwareBufferUsageANDROID"; + case StructureType::eAndroidHardwareBufferPropertiesANDROID : return "AndroidHardwareBufferPropertiesANDROID"; + case StructureType::eAndroidHardwareBufferFormatPropertiesANDROID : return "AndroidHardwareBufferFormatPropertiesANDROID"; + case StructureType::eImportAndroidHardwareBufferInfoANDROID : return "ImportAndroidHardwareBufferInfoANDROID"; + case StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID : return "MemoryGetAndroidHardwareBufferInfoANDROID"; + case StructureType::eExternalFormatANDROID : return "ExternalFormatANDROID"; + case StructureType::eAndroidHardwareBufferFormatProperties2ANDROID: return "AndroidHardwareBufferFormatProperties2ANDROID"; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case StructureType::ePhysicalDeviceShaderEnqueueFeaturesAMDX : return "PhysicalDeviceShaderEnqueueFeaturesAMDX"; + case StructureType::ePhysicalDeviceShaderEnqueuePropertiesAMDX: return "PhysicalDeviceShaderEnqueuePropertiesAMDX"; + case StructureType::eExecutionGraphPipelineScratchSizeAMDX : return "ExecutionGraphPipelineScratchSizeAMDX"; + case StructureType::eExecutionGraphPipelineCreateInfoAMDX : return "ExecutionGraphPipelineCreateInfoAMDX"; + case StructureType::ePipelineShaderStageNodeCreateInfoAMDX : return "PipelineShaderStageNodeCreateInfoAMDX"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case StructureType::eTexelBufferDescriptorInfoEXT : return "TexelBufferDescriptorInfoEXT"; + case StructureType::eImageDescriptorInfoEXT : return "ImageDescriptorInfoEXT"; + case StructureType::eResourceDescriptorInfoEXT : return "ResourceDescriptorInfoEXT"; + case StructureType::eBindHeapInfoEXT : return "BindHeapInfoEXT"; + case StructureType::ePushDataInfoEXT : return "PushDataInfoEXT"; + case StructureType::eDescriptorSetAndBindingMappingEXT : return "DescriptorSetAndBindingMappingEXT"; + case StructureType::eShaderDescriptorSetAndBindingMappingInfoEXT : return "ShaderDescriptorSetAndBindingMappingInfoEXT"; + case StructureType::eOpaqueCaptureDataCreateInfoEXT : return "OpaqueCaptureDataCreateInfoEXT"; + case StructureType::ePhysicalDeviceDescriptorHeapPropertiesEXT : return "PhysicalDeviceDescriptorHeapPropertiesEXT"; + case StructureType::ePhysicalDeviceDescriptorHeapFeaturesEXT : return "PhysicalDeviceDescriptorHeapFeaturesEXT"; + case StructureType::eCommandBufferInheritanceDescriptorHeapInfoEXT : return "CommandBufferInheritanceDescriptorHeapInfoEXT"; + case StructureType::eSamplerCustomBorderColorIndexCreateInfoEXT : return "SamplerCustomBorderColorIndexCreateInfoEXT"; + case StructureType::eIndirectCommandsLayoutPushDataTokenNV : return "IndirectCommandsLayoutPushDataTokenNV"; + case StructureType::eSubsampledImageFormatPropertiesEXT : return "SubsampledImageFormatPropertiesEXT"; + case StructureType::ePhysicalDeviceDescriptorHeapTensorPropertiesARM : return "PhysicalDeviceDescriptorHeapTensorPropertiesARM"; + case StructureType::eAttachmentSampleCountInfoAMD : return "AttachmentSampleCountInfoAMD"; + case StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR : return "PhysicalDeviceShaderBfloat16FeaturesKHR"; + case StructureType::eSampleLocationsInfoEXT : return "SampleLocationsInfoEXT"; + case StructureType::eRenderPassSampleLocationsBeginInfoEXT : return "RenderPassSampleLocationsBeginInfoEXT"; + case StructureType::ePipelineSampleLocationsStateCreateInfoEXT : return "PipelineSampleLocationsStateCreateInfoEXT"; + case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT : return "PhysicalDeviceSampleLocationsPropertiesEXT"; + case StructureType::eMultisamplePropertiesEXT : return "MultisamplePropertiesEXT"; + case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT : return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT"; + case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT: return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT"; + case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT : return "PipelineColorBlendAdvancedStateCreateInfoEXT"; + case StructureType::ePipelineCoverageToColorStateCreateInfoNV : return "PipelineCoverageToColorStateCreateInfoNV"; + case StructureType::eWriteDescriptorSetAccelerationStructureKHR : return "WriteDescriptorSetAccelerationStructureKHR"; + case StructureType::eAccelerationStructureBuildGeometryInfoKHR : return "AccelerationStructureBuildGeometryInfoKHR"; + case StructureType::eAccelerationStructureDeviceAddressInfoKHR : return "AccelerationStructureDeviceAddressInfoKHR"; + case StructureType::eAccelerationStructureGeometryAabbsDataKHR : return "AccelerationStructureGeometryAabbsDataKHR"; + case StructureType::eAccelerationStructureGeometryInstancesDataKHR : return "AccelerationStructureGeometryInstancesDataKHR"; + case StructureType::eAccelerationStructureGeometryTrianglesDataKHR : return "AccelerationStructureGeometryTrianglesDataKHR"; + case StructureType::eAccelerationStructureGeometryKHR : return "AccelerationStructureGeometryKHR"; + case StructureType::eAccelerationStructureVersionInfoKHR : return "AccelerationStructureVersionInfoKHR"; + case StructureType::eCopyAccelerationStructureInfoKHR : return "CopyAccelerationStructureInfoKHR"; + case StructureType::eCopyAccelerationStructureToMemoryInfoKHR : return "CopyAccelerationStructureToMemoryInfoKHR"; + case StructureType::eCopyMemoryToAccelerationStructureInfoKHR : return "CopyMemoryToAccelerationStructureInfoKHR"; + case StructureType::ePhysicalDeviceAccelerationStructureFeaturesKHR : return "PhysicalDeviceAccelerationStructureFeaturesKHR"; + case StructureType::ePhysicalDeviceAccelerationStructurePropertiesKHR : return "PhysicalDeviceAccelerationStructurePropertiesKHR"; + case StructureType::eAccelerationStructureCreateInfoKHR : return "AccelerationStructureCreateInfoKHR"; + case StructureType::eAccelerationStructureBuildSizesInfoKHR : return "AccelerationStructureBuildSizesInfoKHR"; + case StructureType::ePhysicalDeviceRayTracingPipelineFeaturesKHR : return "PhysicalDeviceRayTracingPipelineFeaturesKHR"; + case StructureType::ePhysicalDeviceRayTracingPipelinePropertiesKHR : return "PhysicalDeviceRayTracingPipelinePropertiesKHR"; + case StructureType::eRayTracingPipelineCreateInfoKHR : return "RayTracingPipelineCreateInfoKHR"; + case StructureType::eRayTracingShaderGroupCreateInfoKHR : return "RayTracingShaderGroupCreateInfoKHR"; + case StructureType::eRayTracingPipelineInterfaceCreateInfoKHR : return "RayTracingPipelineInterfaceCreateInfoKHR"; + case StructureType::ePhysicalDeviceRayQueryFeaturesKHR : return "PhysicalDeviceRayQueryFeaturesKHR"; + case StructureType::ePipelineCoverageModulationStateCreateInfoNV : return "PipelineCoverageModulationStateCreateInfoNV"; + case StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV : return "PhysicalDeviceShaderSmBuiltinsFeaturesNV"; + case StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV : return "PhysicalDeviceShaderSmBuiltinsPropertiesNV"; + case StructureType::eDrmFormatModifierPropertiesListEXT : return "DrmFormatModifierPropertiesListEXT"; + case StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT : return "PhysicalDeviceImageDrmFormatModifierInfoEXT"; + case StructureType::eImageDrmFormatModifierListCreateInfoEXT : return "ImageDrmFormatModifierListCreateInfoEXT"; + case StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT : return "ImageDrmFormatModifierExplicitCreateInfoEXT"; + case StructureType::eImageDrmFormatModifierPropertiesEXT : return "ImageDrmFormatModifierPropertiesEXT"; + case StructureType::eDrmFormatModifierPropertiesList2EXT : return "DrmFormatModifierPropertiesList2EXT"; + case StructureType::eValidationCacheCreateInfoEXT : return "ValidationCacheCreateInfoEXT"; + case StructureType::eShaderModuleValidationCacheCreateInfoEXT : return "ShaderModuleValidationCacheCreateInfoEXT"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case StructureType::ePhysicalDevicePortabilitySubsetFeaturesKHR : return "PhysicalDevicePortabilitySubsetFeaturesKHR"; + case StructureType::ePhysicalDevicePortabilitySubsetPropertiesKHR: return "PhysicalDevicePortabilitySubsetPropertiesKHR"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV : return "PipelineViewportShadingRateImageStateCreateInfoNV"; + case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV : return "PhysicalDeviceShadingRateImageFeaturesNV"; + case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV : return "PhysicalDeviceShadingRateImagePropertiesNV"; + case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV : return "PipelineViewportCoarseSampleOrderStateCreateInfoNV"; + case StructureType::eRayTracingPipelineCreateInfoNV : return "RayTracingPipelineCreateInfoNV"; + case StructureType::eAccelerationStructureCreateInfoNV : return "AccelerationStructureCreateInfoNV"; + case StructureType::eGeometryNV : return "GeometryNV"; + case StructureType::eGeometryTrianglesNV : return "GeometryTrianglesNV"; + case StructureType::eGeometryAabbNV : return "GeometryAabbNV"; + case StructureType::eBindAccelerationStructureMemoryInfoNV : return "BindAccelerationStructureMemoryInfoNV"; + case StructureType::eWriteDescriptorSetAccelerationStructureNV : return "WriteDescriptorSetAccelerationStructureNV"; + case StructureType::eAccelerationStructureMemoryRequirementsInfoNV : return "AccelerationStructureMemoryRequirementsInfoNV"; + case StructureType::ePhysicalDeviceRayTracingPropertiesNV : return "PhysicalDeviceRayTracingPropertiesNV"; + case StructureType::eRayTracingShaderGroupCreateInfoNV : return "RayTracingShaderGroupCreateInfoNV"; + case StructureType::eAccelerationStructureInfoNV : return "AccelerationStructureInfoNV"; + case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV : return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV"; + case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV: return "PipelineRepresentativeFragmentTestStateCreateInfoNV"; + case StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT : return "PhysicalDeviceImageViewImageFormatInfoEXT"; + case StructureType::eFilterCubicImageViewImageFormatPropertiesEXT : return "FilterCubicImageViewImageFormatPropertiesEXT"; + case StructureType::eImportMemoryHostPointerInfoEXT : return "ImportMemoryHostPointerInfoEXT"; + case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT"; + case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT"; + case StructureType::ePhysicalDeviceShaderClockFeaturesKHR : return "PhysicalDeviceShaderClockFeaturesKHR"; + case StructureType::ePipelineCompilerControlCreateInfoAMD : return "PipelineCompilerControlCreateInfoAMD"; + case StructureType::ePhysicalDeviceShaderCorePropertiesAMD : return "PhysicalDeviceShaderCorePropertiesAMD"; + case StructureType::eVideoDecodeH265CapabilitiesKHR : return "VideoDecodeH265CapabilitiesKHR"; + case StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR : return "VideoDecodeH265SessionParametersCreateInfoKHR"; + case StructureType::eVideoDecodeH265SessionParametersAddInfoKHR : return "VideoDecodeH265SessionParametersAddInfoKHR"; + case StructureType::eVideoDecodeH265ProfileInfoKHR : return "VideoDecodeH265ProfileInfoKHR"; + case StructureType::eVideoDecodeH265PictureInfoKHR : return "VideoDecodeH265PictureInfoKHR"; + case StructureType::eVideoDecodeH265DpbSlotInfoKHR : return "VideoDecodeH265DpbSlotInfoKHR"; + case StructureType::eDeviceMemoryOverallocationCreateInfoAMD : return "DeviceMemoryOverallocationCreateInfoAMD"; + case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT : return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT"; +#if defined( VK_USE_PLATFORM_GGP ) + case StructureType::ePresentFrameTokenGGP: return "PresentFrameTokenGGP"; +#endif /*VK_USE_PLATFORM_GGP*/ + case StructureType::ePhysicalDeviceMeshShaderFeaturesNV : return "PhysicalDeviceMeshShaderFeaturesNV"; + case StructureType::ePhysicalDeviceMeshShaderPropertiesNV : return "PhysicalDeviceMeshShaderPropertiesNV"; + case StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV : return "PhysicalDeviceShaderImageFootprintFeaturesNV"; + case StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV : return "PipelineViewportExclusiveScissorStateCreateInfoNV"; + case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV : return "PhysicalDeviceExclusiveScissorFeaturesNV"; + case StructureType::eCheckpointDataNV : return "CheckpointDataNV"; + case StructureType::eQueueFamilyCheckpointPropertiesNV : return "QueueFamilyCheckpointPropertiesNV"; + case StructureType::eQueueFamilyCheckpointProperties2NV : return "QueueFamilyCheckpointProperties2NV"; + case StructureType::eCheckpointData2NV : return "CheckpointData2NV"; + case StructureType::ePhysicalDevicePresentTimingFeaturesEXT : return "PhysicalDevicePresentTimingFeaturesEXT"; + case StructureType::eSwapchainTimingPropertiesEXT : return "SwapchainTimingPropertiesEXT"; + case StructureType::eSwapchainTimeDomainPropertiesEXT : return "SwapchainTimeDomainPropertiesEXT"; + case StructureType::ePresentTimingsInfoEXT : return "PresentTimingsInfoEXT"; + case StructureType::ePresentTimingInfoEXT : return "PresentTimingInfoEXT"; + case StructureType::ePastPresentationTimingInfoEXT : return "PastPresentationTimingInfoEXT"; + case StructureType::ePastPresentationTimingPropertiesEXT : return "PastPresentationTimingPropertiesEXT"; + case StructureType::ePastPresentationTimingEXT : return "PastPresentationTimingEXT"; + case StructureType::ePresentTimingSurfaceCapabilitiesEXT : return "PresentTimingSurfaceCapabilitiesEXT"; + case StructureType::eSwapchainCalibratedTimestampInfoEXT : return "SwapchainCalibratedTimestampInfoEXT"; + case StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL: return "PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL"; + case StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL : return "QueryPoolPerformanceQueryCreateInfoINTEL"; + case StructureType::eInitializePerformanceApiInfoINTEL : return "InitializePerformanceApiInfoINTEL"; + case StructureType::ePerformanceMarkerInfoINTEL : return "PerformanceMarkerInfoINTEL"; + case StructureType::ePerformanceStreamMarkerInfoINTEL : return "PerformanceStreamMarkerInfoINTEL"; + case StructureType::ePerformanceOverrideInfoINTEL : return "PerformanceOverrideInfoINTEL"; + case StructureType::ePerformanceConfigurationAcquireInfoINTEL : return "PerformanceConfigurationAcquireInfoINTEL"; + case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT : return "PhysicalDevicePciBusInfoPropertiesEXT"; + case StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD : return "DisplayNativeHdrSurfaceCapabilitiesAMD"; + case StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD : return "SwapchainDisplayNativeHdrCreateInfoAMD"; +#if defined( VK_USE_PLATFORM_FUCHSIA ) + case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA: return "ImagepipeSurfaceCreateInfoFUCHSIA"; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ +#if defined( VK_USE_PLATFORM_METAL_EXT ) + case StructureType::eMetalSurfaceCreateInfoEXT: return "MetalSurfaceCreateInfoEXT"; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + case StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT : return "PhysicalDeviceFragmentDensityMapFeaturesEXT"; + case StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT : return "PhysicalDeviceFragmentDensityMapPropertiesEXT"; + case StructureType::eRenderPassFragmentDensityMapCreateInfoEXT : return "RenderPassFragmentDensityMapCreateInfoEXT"; + case StructureType::eRenderingFragmentDensityMapAttachmentInfoEXT : return "RenderingFragmentDensityMapAttachmentInfoEXT"; + case StructureType::eFragmentShadingRateAttachmentInfoKHR : return "FragmentShadingRateAttachmentInfoKHR"; + case StructureType::ePipelineFragmentShadingRateStateCreateInfoKHR : return "PipelineFragmentShadingRateStateCreateInfoKHR"; + case StructureType::ePhysicalDeviceFragmentShadingRatePropertiesKHR : return "PhysicalDeviceFragmentShadingRatePropertiesKHR"; + case StructureType::ePhysicalDeviceFragmentShadingRateFeaturesKHR : return "PhysicalDeviceFragmentShadingRateFeaturesKHR"; + case StructureType::ePhysicalDeviceFragmentShadingRateKHR : return "PhysicalDeviceFragmentShadingRateKHR"; + case StructureType::eRenderingFragmentShadingRateAttachmentInfoKHR : return "RenderingFragmentShadingRateAttachmentInfoKHR"; + case StructureType::ePhysicalDeviceShaderCoreProperties2AMD : return "PhysicalDeviceShaderCoreProperties2AMD"; + case StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD : return "PhysicalDeviceCoherentMemoryFeaturesAMD"; + case StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT : return "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT"; + case StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR : return "PhysicalDeviceShaderQuadControlFeaturesKHR"; + case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT"; + case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT : return "PhysicalDeviceMemoryPriorityFeaturesEXT"; + case StructureType::eMemoryPriorityAllocateInfoEXT : return "MemoryPriorityAllocateInfoEXT"; + case StructureType::eSurfaceProtectedCapabilitiesKHR : return "SurfaceProtectedCapabilitiesKHR"; + case StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV: return "PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV"; + case StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT : return "PhysicalDeviceBufferDeviceAddressFeaturesEXT"; + case StructureType::eBufferDeviceAddressCreateInfoEXT : return "BufferDeviceAddressCreateInfoEXT"; + case StructureType::eValidationFeaturesEXT : return "ValidationFeaturesEXT"; + case StructureType::ePhysicalDevicePresentWaitFeaturesKHR : return "PhysicalDevicePresentWaitFeaturesKHR"; + case StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV : return "PhysicalDeviceCooperativeMatrixFeaturesNV"; + case StructureType::eCooperativeMatrixPropertiesNV : return "CooperativeMatrixPropertiesNV"; + case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV : return "PhysicalDeviceCooperativeMatrixPropertiesNV"; + case StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV : return "PhysicalDeviceCoverageReductionModeFeaturesNV"; + case StructureType::ePipelineCoverageReductionStateCreateInfoNV : return "PipelineCoverageReductionStateCreateInfoNV"; + case StructureType::eFramebufferMixedSamplesCombinationNV : return "FramebufferMixedSamplesCombinationNV"; + case StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT : return "PhysicalDeviceFragmentShaderInterlockFeaturesEXT"; + case StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT : return "PhysicalDeviceYcbcrImageArraysFeaturesEXT"; + case StructureType::ePhysicalDeviceProvokingVertexFeaturesEXT : return "PhysicalDeviceProvokingVertexFeaturesEXT"; + case StructureType::ePipelineRasterizationProvokingVertexStateCreateInfoEXT : return "PipelineRasterizationProvokingVertexStateCreateInfoEXT"; + case StructureType::ePhysicalDeviceProvokingVertexPropertiesEXT : return "PhysicalDeviceProvokingVertexPropertiesEXT"; +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + case StructureType::eSurfaceFullScreenExclusiveInfoEXT : return "SurfaceFullScreenExclusiveInfoEXT"; + case StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT: return "SurfaceCapabilitiesFullScreenExclusiveEXT"; + case StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT : return "SurfaceFullScreenExclusiveWin32InfoEXT"; +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + case StructureType::eHeadlessSurfaceCreateInfoEXT : return "HeadlessSurfaceCreateInfoEXT"; + case StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT : return "PhysicalDeviceShaderAtomicFloatFeaturesEXT"; + case StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT : return "PhysicalDeviceExtendedDynamicStateFeaturesEXT"; + case StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR: return "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR"; + case StructureType::ePipelineInfoKHR : return "PipelineInfoKHR"; + case StructureType::ePipelineExecutablePropertiesKHR : return "PipelineExecutablePropertiesKHR"; + case StructureType::ePipelineExecutableInfoKHR : return "PipelineExecutableInfoKHR"; + case StructureType::ePipelineExecutableStatisticKHR : return "PipelineExecutableStatisticKHR"; + case StructureType::ePipelineExecutableInternalRepresentationKHR : return "PipelineExecutableInternalRepresentationKHR"; + case StructureType::ePhysicalDeviceMapMemoryPlacedFeaturesEXT : return "PhysicalDeviceMapMemoryPlacedFeaturesEXT"; + case StructureType::ePhysicalDeviceMapMemoryPlacedPropertiesEXT : return "PhysicalDeviceMapMemoryPlacedPropertiesEXT"; + case StructureType::eMemoryMapPlacedInfoEXT : return "MemoryMapPlacedInfoEXT"; + case StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT : return "PhysicalDeviceShaderAtomicFloat2FeaturesEXT"; + case StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV : return "PhysicalDeviceDeviceGeneratedCommandsPropertiesNV"; + case StructureType::eGraphicsShaderGroupCreateInfoNV : return "GraphicsShaderGroupCreateInfoNV"; + case StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV : return "GraphicsPipelineShaderGroupsCreateInfoNV"; + case StructureType::eIndirectCommandsLayoutTokenNV : return "IndirectCommandsLayoutTokenNV"; + case StructureType::eIndirectCommandsLayoutCreateInfoNV : return "IndirectCommandsLayoutCreateInfoNV"; + case StructureType::eGeneratedCommandsInfoNV : return "GeneratedCommandsInfoNV"; + case StructureType::eGeneratedCommandsMemoryRequirementsInfoNV : return "GeneratedCommandsMemoryRequirementsInfoNV"; + case StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV : return "PhysicalDeviceDeviceGeneratedCommandsFeaturesNV"; + case StructureType::ePhysicalDeviceInheritedViewportScissorFeaturesNV : return "PhysicalDeviceInheritedViewportScissorFeaturesNV"; + case StructureType::eCommandBufferInheritanceViewportScissorInfoNV : return "CommandBufferInheritanceViewportScissorInfoNV"; + case StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT : return "PhysicalDeviceTexelBufferAlignmentFeaturesEXT"; + case StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM : return "CommandBufferInheritanceRenderPassTransformInfoQCOM"; + case StructureType::eRenderPassTransformBeginInfoQCOM : return "RenderPassTransformBeginInfoQCOM"; + case StructureType::ePhysicalDeviceDepthBiasControlFeaturesEXT : return "PhysicalDeviceDepthBiasControlFeaturesEXT"; + case StructureType::eDepthBiasInfoEXT : return "DepthBiasInfoEXT"; + case StructureType::eDepthBiasRepresentationInfoEXT : return "DepthBiasRepresentationInfoEXT"; + case StructureType::ePhysicalDeviceDeviceMemoryReportFeaturesEXT : return "PhysicalDeviceDeviceMemoryReportFeaturesEXT"; + case StructureType::eDeviceDeviceMemoryReportCreateInfoEXT : return "DeviceDeviceMemoryReportCreateInfoEXT"; + case StructureType::eDeviceMemoryReportCallbackDataEXT : return "DeviceMemoryReportCallbackDataEXT"; + case StructureType::eSamplerCustomBorderColorCreateInfoEXT : return "SamplerCustomBorderColorCreateInfoEXT"; + case StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT : return "PhysicalDeviceCustomBorderColorPropertiesEXT"; + case StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT : return "PhysicalDeviceCustomBorderColorFeaturesEXT"; + case StructureType::ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT : return "PhysicalDeviceTextureCompressionAstc3DFeaturesEXT"; + case StructureType::ePipelineLibraryCreateInfoKHR : return "PipelineLibraryCreateInfoKHR"; + case StructureType::ePhysicalDevicePresentBarrierFeaturesNV : return "PhysicalDevicePresentBarrierFeaturesNV"; + case StructureType::eSurfaceCapabilitiesPresentBarrierNV : return "SurfaceCapabilitiesPresentBarrierNV"; + case StructureType::eSwapchainPresentBarrierCreateInfoNV : return "SwapchainPresentBarrierCreateInfoNV"; + case StructureType::ePresentIdKHR : return "PresentIdKHR"; + case StructureType::ePhysicalDevicePresentIdFeaturesKHR : return "PhysicalDevicePresentIdFeaturesKHR"; + case StructureType::eVideoEncodeInfoKHR : return "VideoEncodeInfoKHR"; + case StructureType::eVideoEncodeRateControlInfoKHR : return "VideoEncodeRateControlInfoKHR"; + case StructureType::eVideoEncodeRateControlLayerInfoKHR : return "VideoEncodeRateControlLayerInfoKHR"; + case StructureType::eVideoEncodeCapabilitiesKHR : return "VideoEncodeCapabilitiesKHR"; + case StructureType::eVideoEncodeUsageInfoKHR : return "VideoEncodeUsageInfoKHR"; + case StructureType::eQueryPoolVideoEncodeFeedbackCreateInfoKHR : return "QueryPoolVideoEncodeFeedbackCreateInfoKHR"; + case StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR : return "PhysicalDeviceVideoEncodeQualityLevelInfoKHR"; + case StructureType::eVideoEncodeQualityLevelPropertiesKHR : return "VideoEncodeQualityLevelPropertiesKHR"; + case StructureType::eVideoEncodeQualityLevelInfoKHR : return "VideoEncodeQualityLevelInfoKHR"; + case StructureType::eVideoEncodeSessionParametersGetInfoKHR : return "VideoEncodeSessionParametersGetInfoKHR"; + case StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR : return "VideoEncodeSessionParametersFeedbackInfoKHR"; + case StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV : return "PhysicalDeviceDiagnosticsConfigFeaturesNV"; + case StructureType::eDeviceDiagnosticsConfigCreateInfoNV : return "DeviceDiagnosticsConfigCreateInfoNV"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case StructureType::eCudaModuleCreateInfoNV : return "CudaModuleCreateInfoNV"; + case StructureType::eCudaFunctionCreateInfoNV : return "CudaFunctionCreateInfoNV"; + case StructureType::eCudaLaunchInfoNV : return "CudaLaunchInfoNV"; + case StructureType::ePhysicalDeviceCudaKernelLaunchFeaturesNV : return "PhysicalDeviceCudaKernelLaunchFeaturesNV"; + case StructureType::ePhysicalDeviceCudaKernelLaunchPropertiesNV: return "PhysicalDeviceCudaKernelLaunchPropertiesNV"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case StructureType::ePhysicalDeviceTileShadingFeaturesQCOM : return "PhysicalDeviceTileShadingFeaturesQCOM"; + case StructureType::ePhysicalDeviceTileShadingPropertiesQCOM: return "PhysicalDeviceTileShadingPropertiesQCOM"; + case StructureType::eRenderPassTileShadingCreateInfoQCOM : return "RenderPassTileShadingCreateInfoQCOM"; + case StructureType::ePerTileBeginInfoQCOM : return "PerTileBeginInfoQCOM"; + case StructureType::ePerTileEndInfoQCOM : return "PerTileEndInfoQCOM"; + case StructureType::eDispatchTileInfoQCOM : return "DispatchTileInfoQCOM"; + case StructureType::eQueryLowLatencySupportNV : return "QueryLowLatencySupportNV"; +#if defined( VK_USE_PLATFORM_METAL_EXT ) + case StructureType::eExportMetalObjectCreateInfoEXT: return "ExportMetalObjectCreateInfoEXT"; + case StructureType::eExportMetalObjectsInfoEXT : return "ExportMetalObjectsInfoEXT"; + case StructureType::eExportMetalDeviceInfoEXT : return "ExportMetalDeviceInfoEXT"; + case StructureType::eExportMetalCommandQueueInfoEXT: return "ExportMetalCommandQueueInfoEXT"; + case StructureType::eExportMetalBufferInfoEXT : return "ExportMetalBufferInfoEXT"; + case StructureType::eImportMetalBufferInfoEXT : return "ImportMetalBufferInfoEXT"; + case StructureType::eExportMetalTextureInfoEXT : return "ExportMetalTextureInfoEXT"; + case StructureType::eImportMetalTextureInfoEXT : return "ImportMetalTextureInfoEXT"; + case StructureType::eExportMetalIoSurfaceInfoEXT : return "ExportMetalIoSurfaceInfoEXT"; + case StructureType::eImportMetalIoSurfaceInfoEXT : return "ImportMetalIoSurfaceInfoEXT"; + case StructureType::eExportMetalSharedEventInfoEXT : return "ExportMetalSharedEventInfoEXT"; + case StructureType::eImportMetalSharedEventInfoEXT : return "ImportMetalSharedEventInfoEXT"; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + case StructureType::ePhysicalDeviceDescriptorBufferPropertiesEXT : return "PhysicalDeviceDescriptorBufferPropertiesEXT"; + case StructureType::ePhysicalDeviceDescriptorBufferDensityMapPropertiesEXT : return "PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT"; + case StructureType::ePhysicalDeviceDescriptorBufferFeaturesEXT : return "PhysicalDeviceDescriptorBufferFeaturesEXT"; + case StructureType::eDescriptorAddressInfoEXT : return "DescriptorAddressInfoEXT"; + case StructureType::eDescriptorGetInfoEXT : return "DescriptorGetInfoEXT"; + case StructureType::eBufferCaptureDescriptorDataInfoEXT : return "BufferCaptureDescriptorDataInfoEXT"; + case StructureType::eImageCaptureDescriptorDataInfoEXT : return "ImageCaptureDescriptorDataInfoEXT"; + case StructureType::eImageViewCaptureDescriptorDataInfoEXT : return "ImageViewCaptureDescriptorDataInfoEXT"; + case StructureType::eSamplerCaptureDescriptorDataInfoEXT : return "SamplerCaptureDescriptorDataInfoEXT"; + case StructureType::eOpaqueCaptureDescriptorDataCreateInfoEXT : return "OpaqueCaptureDescriptorDataCreateInfoEXT"; + case StructureType::eDescriptorBufferBindingInfoEXT : return "DescriptorBufferBindingInfoEXT"; + case StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT : return "DescriptorBufferBindingPushDescriptorBufferHandleEXT"; + case StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT : return "AccelerationStructureCaptureDescriptorDataInfoEXT"; + case StructureType::ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT : return "PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT"; + case StructureType::ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT : return "PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT"; + case StructureType::eGraphicsPipelineLibraryCreateInfoEXT : return "GraphicsPipelineLibraryCreateInfoEXT"; + case StructureType::ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD : return "PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD"; + case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR : return "PhysicalDeviceFragmentShaderBarycentricFeaturesKHR"; + case StructureType::ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR : return "PhysicalDeviceFragmentShaderBarycentricPropertiesKHR"; + case StructureType::ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR: return "PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR"; + case StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV : return "PhysicalDeviceFragmentShadingRateEnumsPropertiesNV"; + case StructureType::ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV : return "PhysicalDeviceFragmentShadingRateEnumsFeaturesNV"; + case StructureType::ePipelineFragmentShadingRateEnumStateCreateInfoNV : return "PipelineFragmentShadingRateEnumStateCreateInfoNV"; + case StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV : return "AccelerationStructureGeometryMotionTrianglesDataNV"; + case StructureType::ePhysicalDeviceRayTracingMotionBlurFeaturesNV : return "PhysicalDeviceRayTracingMotionBlurFeaturesNV"; + case StructureType::eAccelerationStructureMotionInfoNV : return "AccelerationStructureMotionInfoNV"; + case StructureType::ePhysicalDeviceMeshShaderFeaturesEXT : return "PhysicalDeviceMeshShaderFeaturesEXT"; + case StructureType::ePhysicalDeviceMeshShaderPropertiesEXT : return "PhysicalDeviceMeshShaderPropertiesEXT"; + case StructureType::ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT : return "PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT"; + case StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT : return "PhysicalDeviceFragmentDensityMap2FeaturesEXT"; + case StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT : return "PhysicalDeviceFragmentDensityMap2PropertiesEXT"; + case StructureType::eCopyCommandTransformInfoQCOM : return "CopyCommandTransformInfoQCOM"; + case StructureType::ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR : return "PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR"; + case StructureType::ePhysicalDeviceImageCompressionControlFeaturesEXT : return "PhysicalDeviceImageCompressionControlFeaturesEXT"; + case StructureType::eImageCompressionControlEXT : return "ImageCompressionControlEXT"; + case StructureType::eImageCompressionPropertiesEXT : return "ImageCompressionPropertiesEXT"; + case StructureType::ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT : return "PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT"; + case StructureType::ePhysicalDevice4444FormatsFeaturesEXT : return "PhysicalDevice4444FormatsFeaturesEXT"; + case StructureType::ePhysicalDeviceFaultFeaturesEXT : return "PhysicalDeviceFaultFeaturesEXT"; + case StructureType::eDeviceFaultCountsEXT : return "DeviceFaultCountsEXT"; + case StructureType::eDeviceFaultInfoEXT : return "DeviceFaultInfoEXT"; + case StructureType::ePhysicalDeviceRgba10X6FormatsFeaturesEXT : return "PhysicalDeviceRgba10X6FormatsFeaturesEXT"; +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + case StructureType::eDirectfbSurfaceCreateInfoEXT: return "DirectfbSurfaceCreateInfoEXT"; +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + case StructureType::ePhysicalDeviceVertexInputDynamicStateFeaturesEXT : return "PhysicalDeviceVertexInputDynamicStateFeaturesEXT"; + case StructureType::eVertexInputBindingDescription2EXT : return "VertexInputBindingDescription2EXT"; + case StructureType::eVertexInputAttributeDescription2EXT : return "VertexInputAttributeDescription2EXT"; + case StructureType::ePhysicalDeviceDrmPropertiesEXT : return "PhysicalDeviceDrmPropertiesEXT"; + case StructureType::ePhysicalDeviceAddressBindingReportFeaturesEXT : return "PhysicalDeviceAddressBindingReportFeaturesEXT"; + case StructureType::eDeviceAddressBindingCallbackDataEXT : return "DeviceAddressBindingCallbackDataEXT"; + case StructureType::ePhysicalDeviceDepthClipControlFeaturesEXT : return "PhysicalDeviceDepthClipControlFeaturesEXT"; + case StructureType::ePipelineViewportDepthClipControlCreateInfoEXT : return "PipelineViewportDepthClipControlCreateInfoEXT"; + case StructureType::ePhysicalDevicePrimitiveTopologyListRestartFeaturesEXT: return "PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT"; +#if defined( VK_USE_PLATFORM_FUCHSIA ) + case StructureType::eImportMemoryZirconHandleInfoFUCHSIA : return "ImportMemoryZirconHandleInfoFUCHSIA"; + case StructureType::eMemoryZirconHandlePropertiesFUCHSIA : return "MemoryZirconHandlePropertiesFUCHSIA"; + case StructureType::eMemoryGetZirconHandleInfoFUCHSIA : return "MemoryGetZirconHandleInfoFUCHSIA"; + case StructureType::eImportSemaphoreZirconHandleInfoFUCHSIA : return "ImportSemaphoreZirconHandleInfoFUCHSIA"; + case StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA : return "SemaphoreGetZirconHandleInfoFUCHSIA"; + case StructureType::eBufferCollectionCreateInfoFUCHSIA : return "BufferCollectionCreateInfoFUCHSIA"; + case StructureType::eImportMemoryBufferCollectionFUCHSIA : return "ImportMemoryBufferCollectionFUCHSIA"; + case StructureType::eBufferCollectionImageCreateInfoFUCHSIA : return "BufferCollectionImageCreateInfoFUCHSIA"; + case StructureType::eBufferCollectionPropertiesFUCHSIA : return "BufferCollectionPropertiesFUCHSIA"; + case StructureType::eBufferConstraintsInfoFUCHSIA : return "BufferConstraintsInfoFUCHSIA"; + case StructureType::eBufferCollectionBufferCreateInfoFUCHSIA: return "BufferCollectionBufferCreateInfoFUCHSIA"; + case StructureType::eImageConstraintsInfoFUCHSIA : return "ImageConstraintsInfoFUCHSIA"; + case StructureType::eImageFormatConstraintsInfoFUCHSIA : return "ImageFormatConstraintsInfoFUCHSIA"; + case StructureType::eSysmemColorSpaceFUCHSIA : return "SysmemColorSpaceFUCHSIA"; + case StructureType::eBufferCollectionConstraintsInfoFUCHSIA : return "BufferCollectionConstraintsInfoFUCHSIA"; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + case StructureType::eSubpassShadingPipelineCreateInfoHUAWEI : return "SubpassShadingPipelineCreateInfoHUAWEI"; + case StructureType::ePhysicalDeviceSubpassShadingFeaturesHUAWEI : return "PhysicalDeviceSubpassShadingFeaturesHUAWEI"; + case StructureType::ePhysicalDeviceSubpassShadingPropertiesHUAWEI : return "PhysicalDeviceSubpassShadingPropertiesHUAWEI"; + case StructureType::ePhysicalDeviceInvocationMaskFeaturesHUAWEI : return "PhysicalDeviceInvocationMaskFeaturesHUAWEI"; + case StructureType::eMemoryGetRemoteAddressInfoNV : return "MemoryGetRemoteAddressInfoNV"; + case StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV : return "PhysicalDeviceExternalMemoryRdmaFeaturesNV"; + case StructureType::ePipelinePropertiesIdentifierEXT : return "PipelinePropertiesIdentifierEXT"; + case StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT : return "PhysicalDevicePipelinePropertiesFeaturesEXT"; + case StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT : return "PhysicalDeviceFrameBoundaryFeaturesEXT"; + case StructureType::eFrameBoundaryEXT : return "FrameBoundaryEXT"; + case StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT: return "PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT"; + case StructureType::eSubpassResolvePerformanceQueryEXT : return "SubpassResolvePerformanceQueryEXT"; + case StructureType::eMultisampledRenderToSingleSampledInfoEXT : return "MultisampledRenderToSingleSampledInfoEXT"; + case StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT : return "PhysicalDeviceExtendedDynamicState2FeaturesEXT"; +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + case StructureType::eScreenSurfaceCreateInfoQNX: return "ScreenSurfaceCreateInfoQNX"; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + case StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT : return "PhysicalDeviceColorWriteEnableFeaturesEXT"; + case StructureType::ePipelineColorWriteCreateInfoEXT : return "PipelineColorWriteCreateInfoEXT"; + case StructureType::ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT : return "PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT"; + case StructureType::ePhysicalDeviceRayTracingMaintenance1FeaturesKHR : return "PhysicalDeviceRayTracingMaintenance1FeaturesKHR"; + case StructureType::ePhysicalDeviceShaderUntypedPointersFeaturesKHR : return "PhysicalDeviceShaderUntypedPointersFeaturesKHR"; + case StructureType::ePhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE: return "PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE"; + case StructureType::eVideoEncodeRgbConversionCapabilitiesVALVE : return "VideoEncodeRgbConversionCapabilitiesVALVE"; + case StructureType::eVideoEncodeProfileRgbConversionInfoVALVE : return "VideoEncodeProfileRgbConversionInfoVALVE"; + case StructureType::eVideoEncodeSessionRgbConversionCreateInfoVALVE : return "VideoEncodeSessionRgbConversionCreateInfoVALVE"; + case StructureType::ePhysicalDeviceImageViewMinLodFeaturesEXT : return "PhysicalDeviceImageViewMinLodFeaturesEXT"; + case StructureType::eImageViewMinLodCreateInfoEXT : return "ImageViewMinLodCreateInfoEXT"; + case StructureType::ePhysicalDeviceMultiDrawFeaturesEXT : return "PhysicalDeviceMultiDrawFeaturesEXT"; + case StructureType::ePhysicalDeviceMultiDrawPropertiesEXT : return "PhysicalDeviceMultiDrawPropertiesEXT"; + case StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT : return "PhysicalDeviceImage2DViewOf3DFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT : return "PhysicalDeviceShaderTileImageFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT : return "PhysicalDeviceShaderTileImagePropertiesEXT"; + case StructureType::eMicromapBuildInfoEXT : return "MicromapBuildInfoEXT"; + case StructureType::eMicromapVersionInfoEXT : return "MicromapVersionInfoEXT"; + case StructureType::eCopyMicromapInfoEXT : return "CopyMicromapInfoEXT"; + case StructureType::eCopyMicromapToMemoryInfoEXT : return "CopyMicromapToMemoryInfoEXT"; + case StructureType::eCopyMemoryToMicromapInfoEXT : return "CopyMemoryToMicromapInfoEXT"; + case StructureType::ePhysicalDeviceOpacityMicromapFeaturesEXT : return "PhysicalDeviceOpacityMicromapFeaturesEXT"; + case StructureType::ePhysicalDeviceOpacityMicromapPropertiesEXT : return "PhysicalDeviceOpacityMicromapPropertiesEXT"; + case StructureType::eMicromapCreateInfoEXT : return "MicromapCreateInfoEXT"; + case StructureType::eMicromapBuildSizesInfoEXT : return "MicromapBuildSizesInfoEXT"; + case StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT : return "AccelerationStructureTrianglesOpacityMicromapEXT"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case StructureType::ePhysicalDeviceDisplacementMicromapFeaturesNV : return "PhysicalDeviceDisplacementMicromapFeaturesNV"; + case StructureType::ePhysicalDeviceDisplacementMicromapPropertiesNV : return "PhysicalDeviceDisplacementMicromapPropertiesNV"; + case StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV: return "AccelerationStructureTrianglesDisplacementMicromapNV"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case StructureType::ePhysicalDeviceClusterCullingShaderFeaturesHUAWEI : return "PhysicalDeviceClusterCullingShaderFeaturesHUAWEI"; + case StructureType::ePhysicalDeviceClusterCullingShaderPropertiesHUAWEI : return "PhysicalDeviceClusterCullingShaderPropertiesHUAWEI"; + case StructureType::ePhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI : return "PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI"; + case StructureType::ePhysicalDeviceBorderColorSwizzleFeaturesEXT : return "PhysicalDeviceBorderColorSwizzleFeaturesEXT"; + case StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT : return "SamplerBorderColorComponentMappingCreateInfoEXT"; + case StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT : return "PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderCorePropertiesARM : return "PhysicalDeviceShaderCorePropertiesARM"; + case StructureType::eDeviceQueueShaderCoreControlCreateInfoARM : return "DeviceQueueShaderCoreControlCreateInfoARM"; + case StructureType::ePhysicalDeviceSchedulingControlsFeaturesARM : return "PhysicalDeviceSchedulingControlsFeaturesARM"; + case StructureType::ePhysicalDeviceSchedulingControlsPropertiesARM : return "PhysicalDeviceSchedulingControlsPropertiesARM"; + case StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT : return "PhysicalDeviceImageSlicedViewOf3DFeaturesEXT"; + case StructureType::eImageViewSlicedCreateInfoEXT : return "ImageViewSlicedCreateInfoEXT"; + case StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE : return "PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE"; + case StructureType::eDescriptorSetBindingReferenceVALVE : return "DescriptorSetBindingReferenceVALVE"; + case StructureType::eDescriptorSetLayoutHostMappingInfoVALVE : return "DescriptorSetLayoutHostMappingInfoVALVE"; + case StructureType::ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT : return "PhysicalDeviceNonSeamlessCubeMapFeaturesEXT"; + case StructureType::ePhysicalDeviceRenderPassStripedFeaturesARM : return "PhysicalDeviceRenderPassStripedFeaturesARM"; + case StructureType::ePhysicalDeviceRenderPassStripedPropertiesARM : return "PhysicalDeviceRenderPassStripedPropertiesARM"; + case StructureType::eRenderPassStripeBeginInfoARM : return "RenderPassStripeBeginInfoARM"; + case StructureType::eRenderPassStripeInfoARM : return "RenderPassStripeInfoARM"; + case StructureType::eRenderPassStripeSubmitInfoARM : return "RenderPassStripeSubmitInfoARM"; + case StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesNV : return "PhysicalDeviceCopyMemoryIndirectFeaturesNV"; + case StructureType::ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV : return "PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV"; + case StructureType::eComputePipelineIndirectBufferInfoNV : return "ComputePipelineIndirectBufferInfoNV"; + case StructureType::ePipelineIndirectDeviceAddressInfoNV : return "PipelineIndirectDeviceAddressInfoNV"; + case StructureType::ePhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV : return "PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV"; + case StructureType::eAccelerationStructureGeometryLinearSweptSpheresDataNV : return "AccelerationStructureGeometryLinearSweptSpheresDataNV"; + case StructureType::eAccelerationStructureGeometrySpheresDataNV : return "AccelerationStructureGeometrySpheresDataNV"; + case StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV : return "PhysicalDeviceLinearColorAttachmentFeaturesNV"; + case StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR : return "PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR"; + case StructureType::ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT: return "PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT"; + case StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM : return "PhysicalDeviceImageProcessingFeaturesQCOM"; + case StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM : return "PhysicalDeviceImageProcessingPropertiesQCOM"; + case StructureType::eImageViewSampleWeightCreateInfoQCOM : return "ImageViewSampleWeightCreateInfoQCOM"; + case StructureType::ePhysicalDeviceNestedCommandBufferFeaturesEXT : return "PhysicalDeviceNestedCommandBufferFeaturesEXT"; + case StructureType::ePhysicalDeviceNestedCommandBufferPropertiesEXT : return "PhysicalDeviceNestedCommandBufferPropertiesEXT"; +#if defined( VK_USE_PLATFORM_OHOS ) + case StructureType::eNativeBufferUsageOHOS : return "NativeBufferUsageOHOS"; + case StructureType::eNativeBufferPropertiesOHOS : return "NativeBufferPropertiesOHOS"; + case StructureType::eNativeBufferFormatPropertiesOHOS: return "NativeBufferFormatPropertiesOHOS"; + case StructureType::eImportNativeBufferInfoOHOS : return "ImportNativeBufferInfoOHOS"; + case StructureType::eMemoryGetNativeBufferInfoOHOS : return "MemoryGetNativeBufferInfoOHOS"; + case StructureType::eExternalFormatOHOS : return "ExternalFormatOHOS"; +#endif /*VK_USE_PLATFORM_OHOS*/ + case StructureType::eExternalMemoryAcquireUnmodifiedEXT : return "ExternalMemoryAcquireUnmodifiedEXT"; + case StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT : return "PhysicalDeviceExtendedDynamicState3FeaturesEXT"; + case StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT : return "PhysicalDeviceExtendedDynamicState3PropertiesEXT"; + case StructureType::ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT : return "PhysicalDeviceSubpassMergeFeedbackFeaturesEXT"; + case StructureType::eRenderPassCreationControlEXT : return "RenderPassCreationControlEXT"; + case StructureType::eRenderPassCreationFeedbackCreateInfoEXT : return "RenderPassCreationFeedbackCreateInfoEXT"; + case StructureType::eRenderPassSubpassFeedbackCreateInfoEXT : return "RenderPassSubpassFeedbackCreateInfoEXT"; + case StructureType::eDirectDriverLoadingInfoLUNARG : return "DirectDriverLoadingInfoLUNARG"; + case StructureType::eDirectDriverLoadingListLUNARG : return "DirectDriverLoadingListLUNARG"; + case StructureType::eTensorCreateInfoARM : return "TensorCreateInfoARM"; + case StructureType::eTensorViewCreateInfoARM : return "TensorViewCreateInfoARM"; + case StructureType::eBindTensorMemoryInfoARM : return "BindTensorMemoryInfoARM"; + case StructureType::eWriteDescriptorSetTensorARM : return "WriteDescriptorSetTensorARM"; + case StructureType::ePhysicalDeviceTensorPropertiesARM : return "PhysicalDeviceTensorPropertiesARM"; + case StructureType::eTensorFormatPropertiesARM : return "TensorFormatPropertiesARM"; + case StructureType::eTensorDescriptionARM : return "TensorDescriptionARM"; + case StructureType::eTensorMemoryRequirementsInfoARM : return "TensorMemoryRequirementsInfoARM"; + case StructureType::eTensorMemoryBarrierARM : return "TensorMemoryBarrierARM"; + case StructureType::ePhysicalDeviceTensorFeaturesARM : return "PhysicalDeviceTensorFeaturesARM"; + case StructureType::eDeviceTensorMemoryRequirementsARM : return "DeviceTensorMemoryRequirementsARM"; + case StructureType::eCopyTensorInfoARM : return "CopyTensorInfoARM"; + case StructureType::eTensorCopyARM : return "TensorCopyARM"; + case StructureType::eTensorDependencyInfoARM : return "TensorDependencyInfoARM"; + case StructureType::eMemoryDedicatedAllocateInfoTensorARM : return "MemoryDedicatedAllocateInfoTensorARM"; + case StructureType::ePhysicalDeviceExternalTensorInfoARM : return "PhysicalDeviceExternalTensorInfoARM"; + case StructureType::eExternalTensorPropertiesARM : return "ExternalTensorPropertiesARM"; + case StructureType::eExternalMemoryTensorCreateInfoARM : return "ExternalMemoryTensorCreateInfoARM"; + case StructureType::ePhysicalDeviceDescriptorBufferTensorFeaturesARM : return "PhysicalDeviceDescriptorBufferTensorFeaturesARM"; + case StructureType::ePhysicalDeviceDescriptorBufferTensorPropertiesARM : return "PhysicalDeviceDescriptorBufferTensorPropertiesARM"; + case StructureType::eDescriptorGetTensorInfoARM : return "DescriptorGetTensorInfoARM"; + case StructureType::eTensorCaptureDescriptorDataInfoARM : return "TensorCaptureDescriptorDataInfoARM"; + case StructureType::eTensorViewCaptureDescriptorDataInfoARM : return "TensorViewCaptureDescriptorDataInfoARM"; + case StructureType::eFrameBoundaryTensorsARM : return "FrameBoundaryTensorsARM"; + case StructureType::ePhysicalDeviceShaderModuleIdentifierFeaturesEXT : return "PhysicalDeviceShaderModuleIdentifierFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT : return "PhysicalDeviceShaderModuleIdentifierPropertiesEXT"; + case StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT : return "PipelineShaderStageModuleIdentifierCreateInfoEXT"; + case StructureType::eShaderModuleIdentifierEXT : return "ShaderModuleIdentifierEXT"; + case StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT: return "PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT"; + case StructureType::ePhysicalDeviceOpticalFlowFeaturesNV : return "PhysicalDeviceOpticalFlowFeaturesNV"; + case StructureType::ePhysicalDeviceOpticalFlowPropertiesNV : return "PhysicalDeviceOpticalFlowPropertiesNV"; + case StructureType::eOpticalFlowImageFormatInfoNV : return "OpticalFlowImageFormatInfoNV"; + case StructureType::eOpticalFlowImageFormatPropertiesNV : return "OpticalFlowImageFormatPropertiesNV"; + case StructureType::eOpticalFlowSessionCreateInfoNV : return "OpticalFlowSessionCreateInfoNV"; + case StructureType::eOpticalFlowExecuteInfoNV : return "OpticalFlowExecuteInfoNV"; + case StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV : return "OpticalFlowSessionCreatePrivateDataInfoNV"; + case StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT : return "PhysicalDeviceLegacyDitheringFeaturesEXT"; +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + case StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID : return "PhysicalDeviceExternalFormatResolveFeaturesANDROID"; + case StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID: return "PhysicalDeviceExternalFormatResolvePropertiesANDROID"; + case StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID : return "AndroidHardwareBufferFormatResolvePropertiesANDROID"; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + case StructureType::ePhysicalDeviceAntiLagFeaturesAMD: return "PhysicalDeviceAntiLagFeaturesAMD"; + case StructureType::eAntiLagDataAMD : return "AntiLagDataAMD"; + case StructureType::eAntiLagPresentationInfoAMD : return "AntiLagPresentationInfoAMD"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case StructureType::ePhysicalDeviceDenseGeometryFormatFeaturesAMDX : return "PhysicalDeviceDenseGeometryFormatFeaturesAMDX"; + case StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX: return "AccelerationStructureDenseGeometryFormatTrianglesDataAMDX"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case StructureType::eSurfaceCapabilitiesPresentId2KHR : return "SurfaceCapabilitiesPresentId2KHR"; + case StructureType::ePresentId2KHR : return "PresentId2KHR"; + case StructureType::ePhysicalDevicePresentId2FeaturesKHR : return "PhysicalDevicePresentId2FeaturesKHR"; + case StructureType::eSurfaceCapabilitiesPresentWait2KHR : return "SurfaceCapabilitiesPresentWait2KHR"; + case StructureType::ePhysicalDevicePresentWait2FeaturesKHR : return "PhysicalDevicePresentWait2FeaturesKHR"; + case StructureType::ePresentWait2InfoKHR : return "PresentWait2InfoKHR"; + case StructureType::ePhysicalDeviceRayTracingPositionFetchFeaturesKHR : return "PhysicalDeviceRayTracingPositionFetchFeaturesKHR"; + case StructureType::ePhysicalDeviceShaderObjectFeaturesEXT : return "PhysicalDeviceShaderObjectFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderObjectPropertiesEXT : return "PhysicalDeviceShaderObjectPropertiesEXT"; + case StructureType::eShaderCreateInfoEXT : return "ShaderCreateInfoEXT"; + case StructureType::ePhysicalDevicePipelineBinaryFeaturesKHR : return "PhysicalDevicePipelineBinaryFeaturesKHR"; + case StructureType::ePipelineBinaryCreateInfoKHR : return "PipelineBinaryCreateInfoKHR"; + case StructureType::ePipelineBinaryInfoKHR : return "PipelineBinaryInfoKHR"; + case StructureType::ePipelineBinaryKeyKHR : return "PipelineBinaryKeyKHR"; + case StructureType::ePhysicalDevicePipelineBinaryPropertiesKHR : return "PhysicalDevicePipelineBinaryPropertiesKHR"; + case StructureType::eReleaseCapturedPipelineDataInfoKHR : return "ReleaseCapturedPipelineDataInfoKHR"; + case StructureType::ePipelineBinaryDataInfoKHR : return "PipelineBinaryDataInfoKHR"; + case StructureType::ePipelineCreateInfoKHR : return "PipelineCreateInfoKHR"; + case StructureType::eDevicePipelineBinaryInternalCacheControlKHR : return "DevicePipelineBinaryInternalCacheControlKHR"; + case StructureType::ePipelineBinaryHandlesInfoKHR : return "PipelineBinaryHandlesInfoKHR"; + case StructureType::ePhysicalDeviceTilePropertiesFeaturesQCOM : return "PhysicalDeviceTilePropertiesFeaturesQCOM"; + case StructureType::eTilePropertiesQCOM : return "TilePropertiesQCOM"; + case StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC : return "PhysicalDeviceAmigoProfilingFeaturesSEC"; + case StructureType::eAmigoProfilingSubmitInfoSEC : return "AmigoProfilingSubmitInfoSEC"; + case StructureType::eSurfacePresentModeKHR : return "SurfacePresentModeKHR"; + case StructureType::eSurfacePresentScalingCapabilitiesKHR : return "SurfacePresentScalingCapabilitiesKHR"; + case StructureType::eSurfacePresentModeCompatibilityKHR : return "SurfacePresentModeCompatibilityKHR"; + case StructureType::ePhysicalDeviceSwapchainMaintenance1FeaturesKHR : return "PhysicalDeviceSwapchainMaintenance1FeaturesKHR"; + case StructureType::eSwapchainPresentFenceInfoKHR : return "SwapchainPresentFenceInfoKHR"; + case StructureType::eSwapchainPresentModesCreateInfoKHR : return "SwapchainPresentModesCreateInfoKHR"; + case StructureType::eSwapchainPresentModeInfoKHR : return "SwapchainPresentModeInfoKHR"; + case StructureType::eSwapchainPresentScalingCreateInfoKHR : return "SwapchainPresentScalingCreateInfoKHR"; + case StructureType::eReleaseSwapchainImagesInfoKHR : return "ReleaseSwapchainImagesInfoKHR"; + case StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM : return "PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM"; + case StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV : return "PhysicalDeviceRayTracingInvocationReorderFeaturesNV"; + case StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV : return "PhysicalDeviceRayTracingInvocationReorderPropertiesNV"; + case StructureType::ePhysicalDeviceCooperativeVectorFeaturesNV : return "PhysicalDeviceCooperativeVectorFeaturesNV"; + case StructureType::ePhysicalDeviceCooperativeVectorPropertiesNV : return "PhysicalDeviceCooperativeVectorPropertiesNV"; + case StructureType::eCooperativeVectorPropertiesNV : return "CooperativeVectorPropertiesNV"; + case StructureType::eConvertCooperativeVectorMatrixInfoNV : return "ConvertCooperativeVectorMatrixInfoNV"; + case StructureType::ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV : return "PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV"; + case StructureType::ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV : return "PhysicalDeviceExtendedSparseAddressSpacePropertiesNV"; + case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT : return "PhysicalDeviceMutableDescriptorTypeFeaturesEXT"; + case StructureType::eMutableDescriptorTypeCreateInfoEXT : return "MutableDescriptorTypeCreateInfoEXT"; + case StructureType::ePhysicalDeviceLegacyVertexAttributesFeaturesEXT : return "PhysicalDeviceLegacyVertexAttributesFeaturesEXT"; + case StructureType::ePhysicalDeviceLegacyVertexAttributesPropertiesEXT : return "PhysicalDeviceLegacyVertexAttributesPropertiesEXT"; + case StructureType::eLayerSettingsCreateInfoEXT : return "LayerSettingsCreateInfoEXT"; + case StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM : return "PhysicalDeviceShaderCoreBuiltinsFeaturesARM"; + case StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM : return "PhysicalDeviceShaderCoreBuiltinsPropertiesARM"; + case StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT : return "PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT"; + case StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT : return "PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT"; + case StructureType::ePhysicalDeviceInternallySynchronizedQueuesFeaturesKHR : return "PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR"; + case StructureType::eLatencySleepModeInfoNV : return "LatencySleepModeInfoNV"; + case StructureType::eLatencySleepInfoNV : return "LatencySleepInfoNV"; + case StructureType::eSetLatencyMarkerInfoNV : return "SetLatencyMarkerInfoNV"; + case StructureType::eGetLatencyMarkerInfoNV : return "GetLatencyMarkerInfoNV"; + case StructureType::eLatencyTimingsFrameReportNV : return "LatencyTimingsFrameReportNV"; + case StructureType::eLatencySubmissionPresentIdNV : return "LatencySubmissionPresentIdNV"; + case StructureType::eOutOfBandQueueTypeInfoNV : return "OutOfBandQueueTypeInfoNV"; + case StructureType::eSwapchainLatencyCreateInfoNV : return "SwapchainLatencyCreateInfoNV"; + case StructureType::eLatencySurfaceCapabilitiesNV : return "LatencySurfaceCapabilitiesNV"; + case StructureType::ePhysicalDeviceCooperativeMatrixFeaturesKHR : return "PhysicalDeviceCooperativeMatrixFeaturesKHR"; + case StructureType::eCooperativeMatrixPropertiesKHR : return "CooperativeMatrixPropertiesKHR"; + case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR : return "PhysicalDeviceCooperativeMatrixPropertiesKHR"; + case StructureType::eDataGraphPipelineCreateInfoARM : return "DataGraphPipelineCreateInfoARM"; + case StructureType::eDataGraphPipelineSessionCreateInfoARM : return "DataGraphPipelineSessionCreateInfoARM"; + case StructureType::eDataGraphPipelineResourceInfoARM : return "DataGraphPipelineResourceInfoARM"; + case StructureType::eDataGraphPipelineConstantARM : return "DataGraphPipelineConstantARM"; + case StructureType::eDataGraphPipelineSessionMemoryRequirementsInfoARM : return "DataGraphPipelineSessionMemoryRequirementsInfoARM"; + case StructureType::eBindDataGraphPipelineSessionMemoryInfoARM : return "BindDataGraphPipelineSessionMemoryInfoARM"; + case StructureType::ePhysicalDeviceDataGraphFeaturesARM : return "PhysicalDeviceDataGraphFeaturesARM"; + case StructureType::eDataGraphPipelineShaderModuleCreateInfoARM : return "DataGraphPipelineShaderModuleCreateInfoARM"; + case StructureType::eDataGraphPipelinePropertyQueryResultARM : return "DataGraphPipelinePropertyQueryResultARM"; + case StructureType::eDataGraphPipelineInfoARM : return "DataGraphPipelineInfoARM"; + case StructureType::eDataGraphPipelineCompilerControlCreateInfoARM : return "DataGraphPipelineCompilerControlCreateInfoARM"; + case StructureType::eDataGraphPipelineSessionBindPointRequirementsInfoARM : return "DataGraphPipelineSessionBindPointRequirementsInfoARM"; + case StructureType::eDataGraphPipelineSessionBindPointRequirementARM : return "DataGraphPipelineSessionBindPointRequirementARM"; + case StructureType::eDataGraphPipelineIdentifierCreateInfoARM : return "DataGraphPipelineIdentifierCreateInfoARM"; + case StructureType::eDataGraphPipelineDispatchInfoARM : return "DataGraphPipelineDispatchInfoARM"; + case StructureType::eDataGraphProcessingEngineCreateInfoARM : return "DataGraphProcessingEngineCreateInfoARM"; + case StructureType::eQueueFamilyDataGraphProcessingEnginePropertiesARM : return "QueueFamilyDataGraphProcessingEnginePropertiesARM"; + case StructureType::eQueueFamilyDataGraphPropertiesARM : return "QueueFamilyDataGraphPropertiesARM"; + case StructureType::ePhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM : return "PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM"; + case StructureType::eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM: return "DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM"; + case StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM : return "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM"; + case StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM : return "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM"; + case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesKHR : return "PhysicalDeviceComputeShaderDerivativesFeaturesKHR"; + case StructureType::ePhysicalDeviceComputeShaderDerivativesPropertiesKHR : return "PhysicalDeviceComputeShaderDerivativesPropertiesKHR"; + case StructureType::eVideoDecodeAv1CapabilitiesKHR : return "VideoDecodeAv1CapabilitiesKHR"; + case StructureType::eVideoDecodeAv1PictureInfoKHR : return "VideoDecodeAv1PictureInfoKHR"; + case StructureType::eVideoDecodeAv1ProfileInfoKHR : return "VideoDecodeAv1ProfileInfoKHR"; + case StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR : return "VideoDecodeAv1SessionParametersCreateInfoKHR"; + case StructureType::eVideoDecodeAv1DpbSlotInfoKHR : return "VideoDecodeAv1DpbSlotInfoKHR"; + case StructureType::eVideoEncodeAv1CapabilitiesKHR : return "VideoEncodeAv1CapabilitiesKHR"; + case StructureType::eVideoEncodeAv1SessionParametersCreateInfoKHR : return "VideoEncodeAv1SessionParametersCreateInfoKHR"; + case StructureType::eVideoEncodeAv1PictureInfoKHR : return "VideoEncodeAv1PictureInfoKHR"; + case StructureType::eVideoEncodeAv1DpbSlotInfoKHR : return "VideoEncodeAv1DpbSlotInfoKHR"; + case StructureType::ePhysicalDeviceVideoEncodeAv1FeaturesKHR : return "PhysicalDeviceVideoEncodeAv1FeaturesKHR"; + case StructureType::eVideoEncodeAv1ProfileInfoKHR : return "VideoEncodeAv1ProfileInfoKHR"; + case StructureType::eVideoEncodeAv1RateControlInfoKHR : return "VideoEncodeAv1RateControlInfoKHR"; + case StructureType::eVideoEncodeAv1RateControlLayerInfoKHR : return "VideoEncodeAv1RateControlLayerInfoKHR"; + case StructureType::eVideoEncodeAv1QualityLevelPropertiesKHR : return "VideoEncodeAv1QualityLevelPropertiesKHR"; + case StructureType::eVideoEncodeAv1SessionCreateInfoKHR : return "VideoEncodeAv1SessionCreateInfoKHR"; + case StructureType::eVideoEncodeAv1GopRemainingFrameInfoKHR : return "VideoEncodeAv1GopRemainingFrameInfoKHR"; + case StructureType::ePhysicalDeviceVideoDecodeVp9FeaturesKHR : return "PhysicalDeviceVideoDecodeVp9FeaturesKHR"; + case StructureType::eVideoDecodeVp9CapabilitiesKHR : return "VideoDecodeVp9CapabilitiesKHR"; + case StructureType::eVideoDecodeVp9PictureInfoKHR : return "VideoDecodeVp9PictureInfoKHR"; + case StructureType::eVideoDecodeVp9ProfileInfoKHR : return "VideoDecodeVp9ProfileInfoKHR"; + case StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR : return "PhysicalDeviceVideoMaintenance1FeaturesKHR"; + case StructureType::eVideoInlineQueryInfoKHR : return "VideoInlineQueryInfoKHR"; + case StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV : return "PhysicalDevicePerStageDescriptorSetFeaturesNV"; + case StructureType::ePhysicalDeviceImageProcessing2FeaturesQCOM : return "PhysicalDeviceImageProcessing2FeaturesQCOM"; + case StructureType::ePhysicalDeviceImageProcessing2PropertiesQCOM : return "PhysicalDeviceImageProcessing2PropertiesQCOM"; + case StructureType::eSamplerBlockMatchWindowCreateInfoQCOM : return "SamplerBlockMatchWindowCreateInfoQCOM"; + case StructureType::eSamplerCubicWeightsCreateInfoQCOM : return "SamplerCubicWeightsCreateInfoQCOM"; + case StructureType::ePhysicalDeviceCubicWeightsFeaturesQCOM : return "PhysicalDeviceCubicWeightsFeaturesQCOM"; + case StructureType::eBlitImageCubicWeightsInfoQCOM : return "BlitImageCubicWeightsInfoQCOM"; + case StructureType::ePhysicalDeviceYcbcrDegammaFeaturesQCOM : return "PhysicalDeviceYcbcrDegammaFeaturesQCOM"; + case StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM : return "SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM"; + case StructureType::ePhysicalDeviceCubicClampFeaturesQCOM : return "PhysicalDeviceCubicClampFeaturesQCOM"; + case StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT : return "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT"; + case StructureType::ePhysicalDeviceUnifiedImageLayoutsFeaturesKHR : return "PhysicalDeviceUnifiedImageLayoutsFeaturesKHR"; + case StructureType::eAttachmentFeedbackLoopInfoEXT : return "AttachmentFeedbackLoopInfoEXT"; +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + case StructureType::eScreenBufferPropertiesQNX : return "ScreenBufferPropertiesQNX"; + case StructureType::eScreenBufferFormatPropertiesQNX : return "ScreenBufferFormatPropertiesQNX"; + case StructureType::eImportScreenBufferInfoQNX : return "ImportScreenBufferInfoQNX"; + case StructureType::eExternalFormatQNX : return "ExternalFormatQNX"; + case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX"; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + case StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT : return "PhysicalDeviceLayeredDriverPropertiesMSFT"; + case StructureType::eCalibratedTimestampInfoKHR : return "CalibratedTimestampInfoKHR"; + case StructureType::eSetDescriptorBufferOffsetsInfoEXT : return "SetDescriptorBufferOffsetsInfoEXT"; + case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT : return "BindDescriptorBufferEmbeddedSamplersInfoEXT"; + case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV : return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV"; + case StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM : return "PhysicalDeviceTileMemoryHeapFeaturesQCOM"; + case StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM : return "PhysicalDeviceTileMemoryHeapPropertiesQCOM"; + case StructureType::eTileMemoryRequirementsQCOM : return "TileMemoryRequirementsQCOM"; + case StructureType::eTileMemoryBindInfoQCOM : return "TileMemoryBindInfoQCOM"; + case StructureType::eTileMemorySizeInfoQCOM : return "TileMemorySizeInfoQCOM"; + case StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesKHR : return "PhysicalDeviceCopyMemoryIndirectFeaturesKHR"; + case StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesKHR : return "PhysicalDeviceCopyMemoryIndirectPropertiesKHR"; + case StructureType::eCopyMemoryIndirectInfoKHR : return "CopyMemoryIndirectInfoKHR"; + case StructureType::eCopyMemoryToImageIndirectInfoKHR : return "CopyMemoryToImageIndirectInfoKHR"; + case StructureType::ePhysicalDeviceMemoryDecompressionFeaturesEXT : return "PhysicalDeviceMemoryDecompressionFeaturesEXT"; + case StructureType::ePhysicalDeviceMemoryDecompressionPropertiesEXT : return "PhysicalDeviceMemoryDecompressionPropertiesEXT"; + case StructureType::eDecompressMemoryInfoEXT : return "DecompressMemoryInfoEXT"; + case StructureType::eDisplaySurfaceStereoCreateInfoNV : return "DisplaySurfaceStereoCreateInfoNV"; + case StructureType::eDisplayModeStereoPropertiesNV : return "DisplayModeStereoPropertiesNV"; + case StructureType::eVideoEncodeIntraRefreshCapabilitiesKHR : return "VideoEncodeIntraRefreshCapabilitiesKHR"; + case StructureType::eVideoEncodeSessionIntraRefreshCreateInfoKHR : return "VideoEncodeSessionIntraRefreshCreateInfoKHR"; + case StructureType::eVideoEncodeIntraRefreshInfoKHR : return "VideoEncodeIntraRefreshInfoKHR"; + case StructureType::eVideoReferenceIntraRefreshInfoKHR : return "VideoReferenceIntraRefreshInfoKHR"; + case StructureType::ePhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR : return "PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR"; + case StructureType::eVideoEncodeQuantizationMapCapabilitiesKHR : return "VideoEncodeQuantizationMapCapabilitiesKHR"; + case StructureType::eVideoFormatQuantizationMapPropertiesKHR : return "VideoFormatQuantizationMapPropertiesKHR"; + case StructureType::eVideoEncodeQuantizationMapInfoKHR : return "VideoEncodeQuantizationMapInfoKHR"; + case StructureType::eVideoEncodeQuantizationMapSessionParametersCreateInfoKHR : return "VideoEncodeQuantizationMapSessionParametersCreateInfoKHR"; + case StructureType::ePhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR : return "PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR"; + case StructureType::eVideoEncodeH264QuantizationMapCapabilitiesKHR : return "VideoEncodeH264QuantizationMapCapabilitiesKHR"; + case StructureType::eVideoEncodeH265QuantizationMapCapabilitiesKHR : return "VideoEncodeH265QuantizationMapCapabilitiesKHR"; + case StructureType::eVideoFormatH265QuantizationMapPropertiesKHR : return "VideoFormatH265QuantizationMapPropertiesKHR"; + case StructureType::eVideoEncodeAv1QuantizationMapCapabilitiesKHR : return "VideoEncodeAv1QuantizationMapCapabilitiesKHR"; + case StructureType::eVideoFormatAv1QuantizationMapPropertiesKHR : return "VideoFormatAv1QuantizationMapPropertiesKHR"; + case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV : return "PhysicalDeviceRawAccessChainsFeaturesNV"; + case StructureType::eExternalComputeQueueDeviceCreateInfoNV : return "ExternalComputeQueueDeviceCreateInfoNV"; + case StructureType::eExternalComputeQueueCreateInfoNV : return "ExternalComputeQueueCreateInfoNV"; + case StructureType::eExternalComputeQueueDataParamsNV : return "ExternalComputeQueueDataParamsNV"; + case StructureType::ePhysicalDeviceExternalComputeQueuePropertiesNV : return "PhysicalDeviceExternalComputeQueuePropertiesNV"; + case StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR : return "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR"; + case StructureType::ePhysicalDeviceCommandBufferInheritanceFeaturesNV : return "PhysicalDeviceCommandBufferInheritanceFeaturesNV"; + case StructureType::ePhysicalDeviceMaintenance7FeaturesKHR : return "PhysicalDeviceMaintenance7FeaturesKHR"; + case StructureType::ePhysicalDeviceMaintenance7PropertiesKHR : return "PhysicalDeviceMaintenance7PropertiesKHR"; + case StructureType::ePhysicalDeviceLayeredApiPropertiesListKHR : return "PhysicalDeviceLayeredApiPropertiesListKHR"; + case StructureType::ePhysicalDeviceLayeredApiPropertiesKHR : return "PhysicalDeviceLayeredApiPropertiesKHR"; + case StructureType::ePhysicalDeviceLayeredApiVulkanPropertiesKHR : return "PhysicalDeviceLayeredApiVulkanPropertiesKHR"; + case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV : return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV"; + case StructureType::ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT : return "PhysicalDeviceShaderReplicatedCompositesFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderFloat8FeaturesEXT : return "PhysicalDeviceShaderFloat8FeaturesEXT"; + case StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV : return "PhysicalDeviceRayTracingValidationFeaturesNV"; + case StructureType::ePhysicalDeviceClusterAccelerationStructureFeaturesNV : return "PhysicalDeviceClusterAccelerationStructureFeaturesNV"; + case StructureType::ePhysicalDeviceClusterAccelerationStructurePropertiesNV : return "PhysicalDeviceClusterAccelerationStructurePropertiesNV"; + case StructureType::eClusterAccelerationStructureClustersBottomLevelInputNV : return "ClusterAccelerationStructureClustersBottomLevelInputNV"; + case StructureType::eClusterAccelerationStructureTriangleClusterInputNV : return "ClusterAccelerationStructureTriangleClusterInputNV"; + case StructureType::eClusterAccelerationStructureMoveObjectsInputNV : return "ClusterAccelerationStructureMoveObjectsInputNV"; + case StructureType::eClusterAccelerationStructureInputInfoNV : return "ClusterAccelerationStructureInputInfoNV"; + case StructureType::eClusterAccelerationStructureCommandsInfoNV : return "ClusterAccelerationStructureCommandsInfoNV"; + case StructureType::eRayTracingPipelineClusterAccelerationStructureCreateInfoNV: return "RayTracingPipelineClusterAccelerationStructureCreateInfoNV"; + case StructureType::ePhysicalDevicePartitionedAccelerationStructureFeaturesNV : return "PhysicalDevicePartitionedAccelerationStructureFeaturesNV"; + case StructureType::ePhysicalDevicePartitionedAccelerationStructurePropertiesNV: return "PhysicalDevicePartitionedAccelerationStructurePropertiesNV"; + case StructureType::eWriteDescriptorSetPartitionedAccelerationStructureNV : return "WriteDescriptorSetPartitionedAccelerationStructureNV"; + case StructureType::ePartitionedAccelerationStructureInstancesInputNV : return "PartitionedAccelerationStructureInstancesInputNV"; + case StructureType::eBuildPartitionedAccelerationStructureInfoNV : return "BuildPartitionedAccelerationStructureInfoNV"; + case StructureType::ePartitionedAccelerationStructureFlagsNV : return "PartitionedAccelerationStructureFlagsNV"; + case StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesEXT : return "PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT"; + case StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesEXT : return "PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT"; + case StructureType::eGeneratedCommandsMemoryRequirementsInfoEXT : return "GeneratedCommandsMemoryRequirementsInfoEXT"; + case StructureType::eIndirectExecutionSetCreateInfoEXT : return "IndirectExecutionSetCreateInfoEXT"; + case StructureType::eGeneratedCommandsInfoEXT : return "GeneratedCommandsInfoEXT"; + case StructureType::eIndirectCommandsLayoutCreateInfoEXT : return "IndirectCommandsLayoutCreateInfoEXT"; + case StructureType::eIndirectCommandsLayoutTokenEXT : return "IndirectCommandsLayoutTokenEXT"; + case StructureType::eWriteIndirectExecutionSetPipelineEXT : return "WriteIndirectExecutionSetPipelineEXT"; + case StructureType::eWriteIndirectExecutionSetShaderEXT : return "WriteIndirectExecutionSetShaderEXT"; + case StructureType::eIndirectExecutionSetPipelineInfoEXT : return "IndirectExecutionSetPipelineInfoEXT"; + case StructureType::eIndirectExecutionSetShaderInfoEXT : return "IndirectExecutionSetShaderInfoEXT"; + case StructureType::eIndirectExecutionSetShaderLayoutInfoEXT : return "IndirectExecutionSetShaderLayoutInfoEXT"; + case StructureType::eGeneratedCommandsPipelineInfoEXT : return "GeneratedCommandsPipelineInfoEXT"; + case StructureType::eGeneratedCommandsShaderInfoEXT : return "GeneratedCommandsShaderInfoEXT"; + case StructureType::ePhysicalDeviceMaintenance8FeaturesKHR : return "PhysicalDeviceMaintenance8FeaturesKHR"; + case StructureType::eMemoryBarrierAccessFlags3KHR : return "MemoryBarrierAccessFlags3KHR"; + case StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA : return "PhysicalDeviceImageAlignmentControlFeaturesMESA"; + case StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA : return "PhysicalDeviceImageAlignmentControlPropertiesMESA"; + case StructureType::eImageAlignmentControlCreateInfoMESA : return "ImageAlignmentControlCreateInfoMESA"; + case StructureType::ePhysicalDeviceShaderFmaFeaturesKHR : return "PhysicalDeviceShaderFmaFeaturesKHR"; + case StructureType::ePushConstantBankInfoNV : return "PushConstantBankInfoNV"; + case StructureType::ePhysicalDevicePushConstantBankFeaturesNV : return "PhysicalDevicePushConstantBankFeaturesNV"; + case StructureType::ePhysicalDevicePushConstantBankPropertiesNV : return "PhysicalDevicePushConstantBankPropertiesNV"; + case StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesEXT : return "PhysicalDeviceRayTracingInvocationReorderFeaturesEXT"; + case StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesEXT : return "PhysicalDeviceRayTracingInvocationReorderPropertiesEXT"; + case StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT : return "PhysicalDeviceDepthClampControlFeaturesEXT"; + case StructureType::ePipelineViewportDepthClampControlCreateInfoEXT : return "PipelineViewportDepthClampControlCreateInfoEXT"; + case StructureType::ePhysicalDeviceMaintenance9FeaturesKHR : return "PhysicalDeviceMaintenance9FeaturesKHR"; + case StructureType::ePhysicalDeviceMaintenance9PropertiesKHR : return "PhysicalDeviceMaintenance9PropertiesKHR"; + case StructureType::eQueueFamilyOwnershipTransferPropertiesKHR : return "QueueFamilyOwnershipTransferPropertiesKHR"; + case StructureType::ePhysicalDeviceVideoMaintenance2FeaturesKHR : return "PhysicalDeviceVideoMaintenance2FeaturesKHR"; + case StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR : return "VideoDecodeH264InlineSessionParametersInfoKHR"; + case StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR : return "VideoDecodeH265InlineSessionParametersInfoKHR"; + case StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR : return "VideoDecodeAv1InlineSessionParametersInfoKHR"; +#if defined( VK_USE_PLATFORM_OHOS ) + case StructureType::eSurfaceCreateInfoOHOS: return "SurfaceCreateInfoOHOS"; +#endif /*VK_USE_PLATFORM_OHOS*/ + case StructureType::ePhysicalDeviceHdrVividFeaturesHUAWEI : return "PhysicalDeviceHdrVividFeaturesHUAWEI"; + case StructureType::eHdrVividDynamicMetadataHUAWEI : return "HdrVividDynamicMetadataHUAWEI"; + case StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV : return "PhysicalDeviceCooperativeMatrix2FeaturesNV"; + case StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV : return "CooperativeMatrixFlexibleDimensionsPropertiesNV"; + case StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV : return "PhysicalDeviceCooperativeMatrix2PropertiesNV"; + case StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM: return "PhysicalDevicePipelineOpacityMicromapFeaturesARM"; +#if defined( VK_USE_PLATFORM_METAL_EXT ) + case StructureType::eImportMemoryMetalHandleInfoEXT: return "ImportMemoryMetalHandleInfoEXT"; + case StructureType::eMemoryMetalHandlePropertiesEXT: return "MemoryMetalHandlePropertiesEXT"; + case StructureType::eMemoryGetMetalHandleInfoEXT : return "MemoryGetMetalHandleInfoEXT"; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR : return "PhysicalDeviceDepthClampZeroOneFeaturesKHR"; + case StructureType::ePhysicalDevicePerformanceCountersByRegionFeaturesARM : return "PhysicalDevicePerformanceCountersByRegionFeaturesARM"; + case StructureType::ePhysicalDevicePerformanceCountersByRegionPropertiesARM: return "PhysicalDevicePerformanceCountersByRegionPropertiesARM"; + case StructureType::ePerformanceCounterARM : return "PerformanceCounterARM"; + case StructureType::ePerformanceCounterDescriptionARM : return "PerformanceCounterDescriptionARM"; + case StructureType::eRenderPassPerformanceCountersByRegionBeginInfoARM : return "RenderPassPerformanceCountersByRegionBeginInfoARM"; + case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT : return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT"; + case StructureType::ePhysicalDeviceFormatPackFeaturesARM : return "PhysicalDeviceFormatPackFeaturesARM"; + case StructureType::ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE : return "PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE"; + case StructureType::ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE: return "PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE"; + case StructureType::ePipelineFragmentDensityMapLayeredCreateInfoVALVE : return "PipelineFragmentDensityMapLayeredCreateInfoVALVE"; + case StructureType::ePhysicalDeviceRobustness2FeaturesKHR : return "PhysicalDeviceRobustness2FeaturesKHR"; + case StructureType::ePhysicalDeviceRobustness2PropertiesKHR : return "PhysicalDeviceRobustness2PropertiesKHR"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case StructureType::eSetPresentConfigNV : return "SetPresentConfigNV"; + case StructureType::ePhysicalDevicePresentMeteringFeaturesNV: return "PhysicalDevicePresentMeteringFeaturesNV"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT : return "PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT"; + case StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT : return "PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT"; + case StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT : return "RenderPassFragmentDensityMapOffsetEndInfoEXT"; + case StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT : return "PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT"; + case StructureType::ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR : return "PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR"; + case StructureType::ePhysicalDeviceShader64BitIndexingFeaturesEXT : return "PhysicalDeviceShader64BitIndexingFeaturesEXT"; + case StructureType::ePhysicalDeviceCustomResolveFeaturesEXT : return "PhysicalDeviceCustomResolveFeaturesEXT"; + case StructureType::eBeginCustomResolveInfoEXT : return "BeginCustomResolveInfoEXT"; + case StructureType::eCustomResolveCreateInfoEXT : return "CustomResolveCreateInfoEXT"; + case StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM : return "PhysicalDeviceDataGraphModelFeaturesQCOM"; + case StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM : return "DataGraphPipelineBuiltinModelCreateInfoQCOM"; + case StructureType::ePhysicalDeviceMaintenance10FeaturesKHR : return "PhysicalDeviceMaintenance10FeaturesKHR"; + case StructureType::ePhysicalDeviceMaintenance10PropertiesKHR : return "PhysicalDeviceMaintenance10PropertiesKHR"; + case StructureType::eRenderingAttachmentFlagsInfoKHR : return "RenderingAttachmentFlagsInfoKHR"; + case StructureType::eRenderingEndInfoKHR : return "RenderingEndInfoKHR"; + case StructureType::eResolveImageModeInfoKHR : return "ResolveImageModeInfoKHR"; + case StructureType::ePhysicalDeviceShaderLongVectorFeaturesEXT : return "PhysicalDeviceShaderLongVectorFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderLongVectorPropertiesEXT : return "PhysicalDeviceShaderLongVectorPropertiesEXT"; + case StructureType::ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC : return "PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC"; + case StructureType::ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT: return "PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT"; + case StructureType::eComputeOccupancyPriorityParametersNV : return "ComputeOccupancyPriorityParametersNV"; + case StructureType::ePhysicalDeviceComputeOccupancyPriorityFeaturesNV : return "PhysicalDeviceComputeOccupancyPriorityFeaturesNV"; + case StructureType::ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT : return "PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ObjectType value ) + { + switch ( value ) + { + case ObjectType::eUnknown : return "Unknown"; + case ObjectType::eInstance : return "Instance"; + case ObjectType::ePhysicalDevice : return "PhysicalDevice"; + case ObjectType::eDevice : return "Device"; + case ObjectType::eQueue : return "Queue"; + case ObjectType::eSemaphore : return "Semaphore"; + case ObjectType::eCommandBuffer : return "CommandBuffer"; + case ObjectType::eFence : return "Fence"; + case ObjectType::eDeviceMemory : return "DeviceMemory"; + case ObjectType::eBuffer : return "Buffer"; + case ObjectType::eImage : return "Image"; + case ObjectType::eEvent : return "Event"; + case ObjectType::eQueryPool : return "QueryPool"; + case ObjectType::eBufferView : return "BufferView"; + case ObjectType::eImageView : return "ImageView"; + case ObjectType::eShaderModule : return "ShaderModule"; + case ObjectType::ePipelineCache : return "PipelineCache"; + case ObjectType::ePipelineLayout : return "PipelineLayout"; + case ObjectType::eRenderPass : return "RenderPass"; + case ObjectType::ePipeline : return "Pipeline"; + case ObjectType::eDescriptorSetLayout : return "DescriptorSetLayout"; + case ObjectType::eSampler : return "Sampler"; + case ObjectType::eDescriptorPool : return "DescriptorPool"; + case ObjectType::eDescriptorSet : return "DescriptorSet"; + case ObjectType::eFramebuffer : return "Framebuffer"; + case ObjectType::eCommandPool : return "CommandPool"; + case ObjectType::eDescriptorUpdateTemplate : return "DescriptorUpdateTemplate"; + case ObjectType::eSamplerYcbcrConversion : return "SamplerYcbcrConversion"; + case ObjectType::ePrivateDataSlot : return "PrivateDataSlot"; + case ObjectType::eSurfaceKHR : return "SurfaceKHR"; + case ObjectType::eSwapchainKHR : return "SwapchainKHR"; + case ObjectType::eDisplayKHR : return "DisplayKHR"; + case ObjectType::eDisplayModeKHR : return "DisplayModeKHR"; + case ObjectType::eDebugReportCallbackEXT : return "DebugReportCallbackEXT"; + case ObjectType::eVideoSessionKHR : return "VideoSessionKHR"; + case ObjectType::eVideoSessionParametersKHR : return "VideoSessionParametersKHR"; + case ObjectType::eCuModuleNVX : return "CuModuleNVX"; + case ObjectType::eCuFunctionNVX : return "CuFunctionNVX"; + case ObjectType::eDebugUtilsMessengerEXT : return "DebugUtilsMessengerEXT"; + case ObjectType::eAccelerationStructureKHR : return "AccelerationStructureKHR"; + case ObjectType::eValidationCacheEXT : return "ValidationCacheEXT"; + case ObjectType::eAccelerationStructureNV : return "AccelerationStructureNV"; + case ObjectType::ePerformanceConfigurationINTEL: return "PerformanceConfigurationINTEL"; + case ObjectType::eDeferredOperationKHR : return "DeferredOperationKHR"; + case ObjectType::eIndirectCommandsLayoutNV : return "IndirectCommandsLayoutNV"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case ObjectType::eCudaModuleNV : return "CudaModuleNV"; + case ObjectType::eCudaFunctionNV: return "CudaFunctionNV"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ +#if defined( VK_USE_PLATFORM_FUCHSIA ) + case ObjectType::eBufferCollectionFUCHSIA: return "BufferCollectionFUCHSIA"; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + case ObjectType::eMicromapEXT : return "MicromapEXT"; + case ObjectType::eTensorARM : return "TensorARM"; + case ObjectType::eTensorViewARM : return "TensorViewARM"; + case ObjectType::eOpticalFlowSessionNV : return "OpticalFlowSessionNV"; + case ObjectType::eShaderEXT : return "ShaderEXT"; + case ObjectType::ePipelineBinaryKHR : return "PipelineBinaryKHR"; + case ObjectType::eDataGraphPipelineSessionARM: return "DataGraphPipelineSessionARM"; + case ObjectType::eExternalComputeQueueNV : return "ExternalComputeQueueNV"; + case ObjectType::eIndirectCommandsLayoutEXT : return "IndirectCommandsLayoutEXT"; + case ObjectType::eIndirectExecutionSetEXT : return "IndirectExecutionSetEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VendorId value ) + { + switch ( value ) + { + case VendorId::eKhronos : return "Khronos"; + case VendorId::eVIV : return "VIV"; + case VendorId::eVSI : return "VSI"; + case VendorId::eKazan : return "Kazan"; + case VendorId::eCodeplay: return "Codeplay"; + case VendorId::eMESA : return "MESA"; + case VendorId::ePocl : return "Pocl"; + case VendorId::eMobileye: return "Mobileye"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Format value ) + { + switch ( value ) + { + case Format::eUndefined : return "Undefined"; + case Format::eR4G4UnormPack8 : return "R4G4UnormPack8"; + case Format::eR4G4B4A4UnormPack16 : return "R4G4B4A4UnormPack16"; + case Format::eB4G4R4A4UnormPack16 : return "B4G4R4A4UnormPack16"; + case Format::eR5G6B5UnormPack16 : return "R5G6B5UnormPack16"; + case Format::eB5G6R5UnormPack16 : return "B5G6R5UnormPack16"; + case Format::eR5G5B5A1UnormPack16 : return "R5G5B5A1UnormPack16"; + case Format::eB5G5R5A1UnormPack16 : return "B5G5R5A1UnormPack16"; + case Format::eA1R5G5B5UnormPack16 : return "A1R5G5B5UnormPack16"; + case Format::eR8Unorm : return "R8Unorm"; + case Format::eR8Snorm : return "R8Snorm"; + case Format::eR8Uscaled : return "R8Uscaled"; + case Format::eR8Sscaled : return "R8Sscaled"; + case Format::eR8Uint : return "R8Uint"; + case Format::eR8Sint : return "R8Sint"; + case Format::eR8Srgb : return "R8Srgb"; + case Format::eR8G8Unorm : return "R8G8Unorm"; + case Format::eR8G8Snorm : return "R8G8Snorm"; + case Format::eR8G8Uscaled : return "R8G8Uscaled"; + case Format::eR8G8Sscaled : return "R8G8Sscaled"; + case Format::eR8G8Uint : return "R8G8Uint"; + case Format::eR8G8Sint : return "R8G8Sint"; + case Format::eR8G8Srgb : return "R8G8Srgb"; + case Format::eR8G8B8Unorm : return "R8G8B8Unorm"; + case Format::eR8G8B8Snorm : return "R8G8B8Snorm"; + case Format::eR8G8B8Uscaled : return "R8G8B8Uscaled"; + case Format::eR8G8B8Sscaled : return "R8G8B8Sscaled"; + case Format::eR8G8B8Uint : return "R8G8B8Uint"; + case Format::eR8G8B8Sint : return "R8G8B8Sint"; + case Format::eR8G8B8Srgb : return "R8G8B8Srgb"; + case Format::eB8G8R8Unorm : return "B8G8R8Unorm"; + case Format::eB8G8R8Snorm : return "B8G8R8Snorm"; + case Format::eB8G8R8Uscaled : return "B8G8R8Uscaled"; + case Format::eB8G8R8Sscaled : return "B8G8R8Sscaled"; + case Format::eB8G8R8Uint : return "B8G8R8Uint"; + case Format::eB8G8R8Sint : return "B8G8R8Sint"; + case Format::eB8G8R8Srgb : return "B8G8R8Srgb"; + case Format::eR8G8B8A8Unorm : return "R8G8B8A8Unorm"; + case Format::eR8G8B8A8Snorm : return "R8G8B8A8Snorm"; + case Format::eR8G8B8A8Uscaled : return "R8G8B8A8Uscaled"; + case Format::eR8G8B8A8Sscaled : return "R8G8B8A8Sscaled"; + case Format::eR8G8B8A8Uint : return "R8G8B8A8Uint"; + case Format::eR8G8B8A8Sint : return "R8G8B8A8Sint"; + case Format::eR8G8B8A8Srgb : return "R8G8B8A8Srgb"; + case Format::eB8G8R8A8Unorm : return "B8G8R8A8Unorm"; + case Format::eB8G8R8A8Snorm : return "B8G8R8A8Snorm"; + case Format::eB8G8R8A8Uscaled : return "B8G8R8A8Uscaled"; + case Format::eB8G8R8A8Sscaled : return "B8G8R8A8Sscaled"; + case Format::eB8G8R8A8Uint : return "B8G8R8A8Uint"; + case Format::eB8G8R8A8Sint : return "B8G8R8A8Sint"; + case Format::eB8G8R8A8Srgb : return "B8G8R8A8Srgb"; + case Format::eA8B8G8R8UnormPack32 : return "A8B8G8R8UnormPack32"; + case Format::eA8B8G8R8SnormPack32 : return "A8B8G8R8SnormPack32"; + case Format::eA8B8G8R8UscaledPack32 : return "A8B8G8R8UscaledPack32"; + case Format::eA8B8G8R8SscaledPack32 : return "A8B8G8R8SscaledPack32"; + case Format::eA8B8G8R8UintPack32 : return "A8B8G8R8UintPack32"; + case Format::eA8B8G8R8SintPack32 : return "A8B8G8R8SintPack32"; + case Format::eA8B8G8R8SrgbPack32 : return "A8B8G8R8SrgbPack32"; + case Format::eA2R10G10B10UnormPack32 : return "A2R10G10B10UnormPack32"; + case Format::eA2R10G10B10SnormPack32 : return "A2R10G10B10SnormPack32"; + case Format::eA2R10G10B10UscaledPack32 : return "A2R10G10B10UscaledPack32"; + case Format::eA2R10G10B10SscaledPack32 : return "A2R10G10B10SscaledPack32"; + case Format::eA2R10G10B10UintPack32 : return "A2R10G10B10UintPack32"; + case Format::eA2R10G10B10SintPack32 : return "A2R10G10B10SintPack32"; + case Format::eA2B10G10R10UnormPack32 : return "A2B10G10R10UnormPack32"; + case Format::eA2B10G10R10SnormPack32 : return "A2B10G10R10SnormPack32"; + case Format::eA2B10G10R10UscaledPack32 : return "A2B10G10R10UscaledPack32"; + case Format::eA2B10G10R10SscaledPack32 : return "A2B10G10R10SscaledPack32"; + case Format::eA2B10G10R10UintPack32 : return "A2B10G10R10UintPack32"; + case Format::eA2B10G10R10SintPack32 : return "A2B10G10R10SintPack32"; + case Format::eR16Unorm : return "R16Unorm"; + case Format::eR16Snorm : return "R16Snorm"; + case Format::eR16Uscaled : return "R16Uscaled"; + case Format::eR16Sscaled : return "R16Sscaled"; + case Format::eR16Uint : return "R16Uint"; + case Format::eR16Sint : return "R16Sint"; + case Format::eR16Sfloat : return "R16Sfloat"; + case Format::eR16G16Unorm : return "R16G16Unorm"; + case Format::eR16G16Snorm : return "R16G16Snorm"; + case Format::eR16G16Uscaled : return "R16G16Uscaled"; + case Format::eR16G16Sscaled : return "R16G16Sscaled"; + case Format::eR16G16Uint : return "R16G16Uint"; + case Format::eR16G16Sint : return "R16G16Sint"; + case Format::eR16G16Sfloat : return "R16G16Sfloat"; + case Format::eR16G16B16Unorm : return "R16G16B16Unorm"; + case Format::eR16G16B16Snorm : return "R16G16B16Snorm"; + case Format::eR16G16B16Uscaled : return "R16G16B16Uscaled"; + case Format::eR16G16B16Sscaled : return "R16G16B16Sscaled"; + case Format::eR16G16B16Uint : return "R16G16B16Uint"; + case Format::eR16G16B16Sint : return "R16G16B16Sint"; + case Format::eR16G16B16Sfloat : return "R16G16B16Sfloat"; + case Format::eR16G16B16A16Unorm : return "R16G16B16A16Unorm"; + case Format::eR16G16B16A16Snorm : return "R16G16B16A16Snorm"; + case Format::eR16G16B16A16Uscaled : return "R16G16B16A16Uscaled"; + case Format::eR16G16B16A16Sscaled : return "R16G16B16A16Sscaled"; + case Format::eR16G16B16A16Uint : return "R16G16B16A16Uint"; + case Format::eR16G16B16A16Sint : return "R16G16B16A16Sint"; + case Format::eR16G16B16A16Sfloat : return "R16G16B16A16Sfloat"; + case Format::eR32Uint : return "R32Uint"; + case Format::eR32Sint : return "R32Sint"; + case Format::eR32Sfloat : return "R32Sfloat"; + case Format::eR32G32Uint : return "R32G32Uint"; + case Format::eR32G32Sint : return "R32G32Sint"; + case Format::eR32G32Sfloat : return "R32G32Sfloat"; + case Format::eR32G32B32Uint : return "R32G32B32Uint"; + case Format::eR32G32B32Sint : return "R32G32B32Sint"; + case Format::eR32G32B32Sfloat : return "R32G32B32Sfloat"; + case Format::eR32G32B32A32Uint : return "R32G32B32A32Uint"; + case Format::eR32G32B32A32Sint : return "R32G32B32A32Sint"; + case Format::eR32G32B32A32Sfloat : return "R32G32B32A32Sfloat"; + case Format::eR64Uint : return "R64Uint"; + case Format::eR64Sint : return "R64Sint"; + case Format::eR64Sfloat : return "R64Sfloat"; + case Format::eR64G64Uint : return "R64G64Uint"; + case Format::eR64G64Sint : return "R64G64Sint"; + case Format::eR64G64Sfloat : return "R64G64Sfloat"; + case Format::eR64G64B64Uint : return "R64G64B64Uint"; + case Format::eR64G64B64Sint : return "R64G64B64Sint"; + case Format::eR64G64B64Sfloat : return "R64G64B64Sfloat"; + case Format::eR64G64B64A64Uint : return "R64G64B64A64Uint"; + case Format::eR64G64B64A64Sint : return "R64G64B64A64Sint"; + case Format::eR64G64B64A64Sfloat : return "R64G64B64A64Sfloat"; + case Format::eB10G11R11UfloatPack32 : return "B10G11R11UfloatPack32"; + case Format::eE5B9G9R9UfloatPack32 : return "E5B9G9R9UfloatPack32"; + case Format::eD16Unorm : return "D16Unorm"; + case Format::eX8D24UnormPack32 : return "X8D24UnormPack32"; + case Format::eD32Sfloat : return "D32Sfloat"; + case Format::eS8Uint : return "S8Uint"; + case Format::eD16UnormS8Uint : return "D16UnormS8Uint"; + case Format::eD24UnormS8Uint : return "D24UnormS8Uint"; + case Format::eD32SfloatS8Uint : return "D32SfloatS8Uint"; + case Format::eBc1RgbUnormBlock : return "Bc1RgbUnormBlock"; + case Format::eBc1RgbSrgbBlock : return "Bc1RgbSrgbBlock"; + case Format::eBc1RgbaUnormBlock : return "Bc1RgbaUnormBlock"; + case Format::eBc1RgbaSrgbBlock : return "Bc1RgbaSrgbBlock"; + case Format::eBc2UnormBlock : return "Bc2UnormBlock"; + case Format::eBc2SrgbBlock : return "Bc2SrgbBlock"; + case Format::eBc3UnormBlock : return "Bc3UnormBlock"; + case Format::eBc3SrgbBlock : return "Bc3SrgbBlock"; + case Format::eBc4UnormBlock : return "Bc4UnormBlock"; + case Format::eBc4SnormBlock : return "Bc4SnormBlock"; + case Format::eBc5UnormBlock : return "Bc5UnormBlock"; + case Format::eBc5SnormBlock : return "Bc5SnormBlock"; + case Format::eBc6HUfloatBlock : return "Bc6HUfloatBlock"; + case Format::eBc6HSfloatBlock : return "Bc6HSfloatBlock"; + case Format::eBc7UnormBlock : return "Bc7UnormBlock"; + case Format::eBc7SrgbBlock : return "Bc7SrgbBlock"; + case Format::eEtc2R8G8B8UnormBlock : return "Etc2R8G8B8UnormBlock"; + case Format::eEtc2R8G8B8SrgbBlock : return "Etc2R8G8B8SrgbBlock"; + case Format::eEtc2R8G8B8A1UnormBlock : return "Etc2R8G8B8A1UnormBlock"; + case Format::eEtc2R8G8B8A1SrgbBlock : return "Etc2R8G8B8A1SrgbBlock"; + case Format::eEtc2R8G8B8A8UnormBlock : return "Etc2R8G8B8A8UnormBlock"; + case Format::eEtc2R8G8B8A8SrgbBlock : return "Etc2R8G8B8A8SrgbBlock"; + case Format::eEacR11UnormBlock : return "EacR11UnormBlock"; + case Format::eEacR11SnormBlock : return "EacR11SnormBlock"; + case Format::eEacR11G11UnormBlock : return "EacR11G11UnormBlock"; + case Format::eEacR11G11SnormBlock : return "EacR11G11SnormBlock"; + case Format::eAstc4x4UnormBlock : return "Astc4x4UnormBlock"; + case Format::eAstc4x4SrgbBlock : return "Astc4x4SrgbBlock"; + case Format::eAstc5x4UnormBlock : return "Astc5x4UnormBlock"; + case Format::eAstc5x4SrgbBlock : return "Astc5x4SrgbBlock"; + case Format::eAstc5x5UnormBlock : return "Astc5x5UnormBlock"; + case Format::eAstc5x5SrgbBlock : return "Astc5x5SrgbBlock"; + case Format::eAstc6x5UnormBlock : return "Astc6x5UnormBlock"; + case Format::eAstc6x5SrgbBlock : return "Astc6x5SrgbBlock"; + case Format::eAstc6x6UnormBlock : return "Astc6x6UnormBlock"; + case Format::eAstc6x6SrgbBlock : return "Astc6x6SrgbBlock"; + case Format::eAstc8x5UnormBlock : return "Astc8x5UnormBlock"; + case Format::eAstc8x5SrgbBlock : return "Astc8x5SrgbBlock"; + case Format::eAstc8x6UnormBlock : return "Astc8x6UnormBlock"; + case Format::eAstc8x6SrgbBlock : return "Astc8x6SrgbBlock"; + case Format::eAstc8x8UnormBlock : return "Astc8x8UnormBlock"; + case Format::eAstc8x8SrgbBlock : return "Astc8x8SrgbBlock"; + case Format::eAstc10x5UnormBlock : return "Astc10x5UnormBlock"; + case Format::eAstc10x5SrgbBlock : return "Astc10x5SrgbBlock"; + case Format::eAstc10x6UnormBlock : return "Astc10x6UnormBlock"; + case Format::eAstc10x6SrgbBlock : return "Astc10x6SrgbBlock"; + case Format::eAstc10x8UnormBlock : return "Astc10x8UnormBlock"; + case Format::eAstc10x8SrgbBlock : return "Astc10x8SrgbBlock"; + case Format::eAstc10x10UnormBlock : return "Astc10x10UnormBlock"; + case Format::eAstc10x10SrgbBlock : return "Astc10x10SrgbBlock"; + case Format::eAstc12x10UnormBlock : return "Astc12x10UnormBlock"; + case Format::eAstc12x10SrgbBlock : return "Astc12x10SrgbBlock"; + case Format::eAstc12x12UnormBlock : return "Astc12x12UnormBlock"; + case Format::eAstc12x12SrgbBlock : return "Astc12x12SrgbBlock"; + case Format::eG8B8G8R8422Unorm : return "G8B8G8R8422Unorm"; + case Format::eB8G8R8G8422Unorm : return "B8G8R8G8422Unorm"; + case Format::eG8B8R83Plane420Unorm : return "G8B8R83Plane420Unorm"; + case Format::eG8B8R82Plane420Unorm : return "G8B8R82Plane420Unorm"; + case Format::eG8B8R83Plane422Unorm : return "G8B8R83Plane422Unorm"; + case Format::eG8B8R82Plane422Unorm : return "G8B8R82Plane422Unorm"; + case Format::eG8B8R83Plane444Unorm : return "G8B8R83Plane444Unorm"; + case Format::eR10X6UnormPack16 : return "R10X6UnormPack16"; + case Format::eR10X6G10X6Unorm2Pack16 : return "R10X6G10X6Unorm2Pack16"; + case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return "R10X6G10X6B10X6A10X6Unorm4Pack16"; + case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return "G10X6B10X6G10X6R10X6422Unorm4Pack16"; + case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return "B10X6G10X6R10X6G10X6422Unorm4Pack16"; + case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return "G10X6B10X6R10X63Plane420Unorm3Pack16"; + case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return "G10X6B10X6R10X62Plane420Unorm3Pack16"; + case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return "G10X6B10X6R10X63Plane422Unorm3Pack16"; + case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return "G10X6B10X6R10X62Plane422Unorm3Pack16"; + case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return "G10X6B10X6R10X63Plane444Unorm3Pack16"; + case Format::eR12X4UnormPack16 : return "R12X4UnormPack16"; + case Format::eR12X4G12X4Unorm2Pack16 : return "R12X4G12X4Unorm2Pack16"; + case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return "R12X4G12X4B12X4A12X4Unorm4Pack16"; + case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return "G12X4B12X4G12X4R12X4422Unorm4Pack16"; + case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return "B12X4G12X4R12X4G12X4422Unorm4Pack16"; + case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return "G12X4B12X4R12X43Plane420Unorm3Pack16"; + case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return "G12X4B12X4R12X42Plane420Unorm3Pack16"; + case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return "G12X4B12X4R12X43Plane422Unorm3Pack16"; + case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return "G12X4B12X4R12X42Plane422Unorm3Pack16"; + case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return "G12X4B12X4R12X43Plane444Unorm3Pack16"; + case Format::eG16B16G16R16422Unorm : return "G16B16G16R16422Unorm"; + case Format::eB16G16R16G16422Unorm : return "B16G16R16G16422Unorm"; + case Format::eG16B16R163Plane420Unorm : return "G16B16R163Plane420Unorm"; + case Format::eG16B16R162Plane420Unorm : return "G16B16R162Plane420Unorm"; + case Format::eG16B16R163Plane422Unorm : return "G16B16R163Plane422Unorm"; + case Format::eG16B16R162Plane422Unorm : return "G16B16R162Plane422Unorm"; + case Format::eG16B16R163Plane444Unorm : return "G16B16R163Plane444Unorm"; + case Format::eG8B8R82Plane444Unorm : return "G8B8R82Plane444Unorm"; + case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return "G10X6B10X6R10X62Plane444Unorm3Pack16"; + case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return "G12X4B12X4R12X42Plane444Unorm3Pack16"; + case Format::eG16B16R162Plane444Unorm : return "G16B16R162Plane444Unorm"; + case Format::eA4R4G4B4UnormPack16 : return "A4R4G4B4UnormPack16"; + case Format::eA4B4G4R4UnormPack16 : return "A4B4G4R4UnormPack16"; + case Format::eAstc4x4SfloatBlock : return "Astc4x4SfloatBlock"; + case Format::eAstc5x4SfloatBlock : return "Astc5x4SfloatBlock"; + case Format::eAstc5x5SfloatBlock : return "Astc5x5SfloatBlock"; + case Format::eAstc6x5SfloatBlock : return "Astc6x5SfloatBlock"; + case Format::eAstc6x6SfloatBlock : return "Astc6x6SfloatBlock"; + case Format::eAstc8x5SfloatBlock : return "Astc8x5SfloatBlock"; + case Format::eAstc8x6SfloatBlock : return "Astc8x6SfloatBlock"; + case Format::eAstc8x8SfloatBlock : return "Astc8x8SfloatBlock"; + case Format::eAstc10x5SfloatBlock : return "Astc10x5SfloatBlock"; + case Format::eAstc10x6SfloatBlock : return "Astc10x6SfloatBlock"; + case Format::eAstc10x8SfloatBlock : return "Astc10x8SfloatBlock"; + case Format::eAstc10x10SfloatBlock : return "Astc10x10SfloatBlock"; + case Format::eAstc12x10SfloatBlock : return "Astc12x10SfloatBlock"; + case Format::eAstc12x12SfloatBlock : return "Astc12x12SfloatBlock"; + case Format::eA1B5G5R5UnormPack16 : return "A1B5G5R5UnormPack16"; + case Format::eA8Unorm : return "A8Unorm"; + case Format::ePvrtc12BppUnormBlockIMG : return "Pvrtc12BppUnormBlockIMG"; + case Format::ePvrtc14BppUnormBlockIMG : return "Pvrtc14BppUnormBlockIMG"; + case Format::ePvrtc22BppUnormBlockIMG : return "Pvrtc22BppUnormBlockIMG"; + case Format::ePvrtc24BppUnormBlockIMG : return "Pvrtc24BppUnormBlockIMG"; + case Format::ePvrtc12BppSrgbBlockIMG : return "Pvrtc12BppSrgbBlockIMG"; + case Format::ePvrtc14BppSrgbBlockIMG : return "Pvrtc14BppSrgbBlockIMG"; + case Format::ePvrtc22BppSrgbBlockIMG : return "Pvrtc22BppSrgbBlockIMG"; + case Format::ePvrtc24BppSrgbBlockIMG : return "Pvrtc24BppSrgbBlockIMG"; + case Format::eAstc3x3x3UnormBlockEXT : return "Astc3x3x3UnormBlockEXT"; + case Format::eAstc3x3x3SrgbBlockEXT : return "Astc3x3x3SrgbBlockEXT"; + case Format::eAstc3x3x3SfloatBlockEXT : return "Astc3x3x3SfloatBlockEXT"; + case Format::eAstc4x3x3UnormBlockEXT : return "Astc4x3x3UnormBlockEXT"; + case Format::eAstc4x3x3SrgbBlockEXT : return "Astc4x3x3SrgbBlockEXT"; + case Format::eAstc4x3x3SfloatBlockEXT : return "Astc4x3x3SfloatBlockEXT"; + case Format::eAstc4x4x3UnormBlockEXT : return "Astc4x4x3UnormBlockEXT"; + case Format::eAstc4x4x3SrgbBlockEXT : return "Astc4x4x3SrgbBlockEXT"; + case Format::eAstc4x4x3SfloatBlockEXT : return "Astc4x4x3SfloatBlockEXT"; + case Format::eAstc4x4x4UnormBlockEXT : return "Astc4x4x4UnormBlockEXT"; + case Format::eAstc4x4x4SrgbBlockEXT : return "Astc4x4x4SrgbBlockEXT"; + case Format::eAstc4x4x4SfloatBlockEXT : return "Astc4x4x4SfloatBlockEXT"; + case Format::eAstc5x4x4UnormBlockEXT : return "Astc5x4x4UnormBlockEXT"; + case Format::eAstc5x4x4SrgbBlockEXT : return "Astc5x4x4SrgbBlockEXT"; + case Format::eAstc5x4x4SfloatBlockEXT : return "Astc5x4x4SfloatBlockEXT"; + case Format::eAstc5x5x4UnormBlockEXT : return "Astc5x5x4UnormBlockEXT"; + case Format::eAstc5x5x4SrgbBlockEXT : return "Astc5x5x4SrgbBlockEXT"; + case Format::eAstc5x5x4SfloatBlockEXT : return "Astc5x5x4SfloatBlockEXT"; + case Format::eAstc5x5x5UnormBlockEXT : return "Astc5x5x5UnormBlockEXT"; + case Format::eAstc5x5x5SrgbBlockEXT : return "Astc5x5x5SrgbBlockEXT"; + case Format::eAstc5x5x5SfloatBlockEXT : return "Astc5x5x5SfloatBlockEXT"; + case Format::eAstc6x5x5UnormBlockEXT : return "Astc6x5x5UnormBlockEXT"; + case Format::eAstc6x5x5SrgbBlockEXT : return "Astc6x5x5SrgbBlockEXT"; + case Format::eAstc6x5x5SfloatBlockEXT : return "Astc6x5x5SfloatBlockEXT"; + case Format::eAstc6x6x5UnormBlockEXT : return "Astc6x6x5UnormBlockEXT"; + case Format::eAstc6x6x5SrgbBlockEXT : return "Astc6x6x5SrgbBlockEXT"; + case Format::eAstc6x6x5SfloatBlockEXT : return "Astc6x6x5SfloatBlockEXT"; + case Format::eAstc6x6x6UnormBlockEXT : return "Astc6x6x6UnormBlockEXT"; + case Format::eAstc6x6x6SrgbBlockEXT : return "Astc6x6x6SrgbBlockEXT"; + case Format::eAstc6x6x6SfloatBlockEXT : return "Astc6x6x6SfloatBlockEXT"; + case Format::eR8BoolARM : return "R8BoolARM"; + case Format::eR16G16Sfixed5NV : return "R16G16Sfixed5NV"; + case Format::eR10X6UintPack16ARM : return "R10X6UintPack16ARM"; + case Format::eR10X6G10X6Uint2Pack16ARM : return "R10X6G10X6Uint2Pack16ARM"; + case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return "R10X6G10X6B10X6A10X6Uint4Pack16ARM"; + case Format::eR12X4UintPack16ARM : return "R12X4UintPack16ARM"; + case Format::eR12X4G12X4Uint2Pack16ARM : return "R12X4G12X4Uint2Pack16ARM"; + case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return "R12X4G12X4B12X4A12X4Uint4Pack16ARM"; + case Format::eR14X2UintPack16ARM : return "R14X2UintPack16ARM"; + case Format::eR14X2G14X2Uint2Pack16ARM : return "R14X2G14X2Uint2Pack16ARM"; + case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return "R14X2G14X2B14X2A14X2Uint4Pack16ARM"; + case Format::eR14X2UnormPack16ARM : return "R14X2UnormPack16ARM"; + case Format::eR14X2G14X2Unorm2Pack16ARM : return "R14X2G14X2Unorm2Pack16ARM"; + case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return "R14X2G14X2B14X2A14X2Unorm4Pack16ARM"; + case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return "G14X2B14X2R14X22Plane420Unorm3Pack16ARM"; + case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return "G14X2B14X2R14X22Plane422Unorm3Pack16ARM"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FormatFeatureFlagBits value ) + { + switch ( value ) + { + case FormatFeatureFlagBits::eSampledImage : return "SampledImage"; + case FormatFeatureFlagBits::eStorageImage : return "StorageImage"; + case FormatFeatureFlagBits::eStorageImageAtomic : return "StorageImageAtomic"; + case FormatFeatureFlagBits::eUniformTexelBuffer : return "UniformTexelBuffer"; + case FormatFeatureFlagBits::eStorageTexelBuffer : return "StorageTexelBuffer"; + case FormatFeatureFlagBits::eStorageTexelBufferAtomic : return "StorageTexelBufferAtomic"; + case FormatFeatureFlagBits::eVertexBuffer : return "VertexBuffer"; + case FormatFeatureFlagBits::eColorAttachment : return "ColorAttachment"; + case FormatFeatureFlagBits::eColorAttachmentBlend : return "ColorAttachmentBlend"; + case FormatFeatureFlagBits::eDepthStencilAttachment : return "DepthStencilAttachment"; + case FormatFeatureFlagBits::eBlitSrc : return "BlitSrc"; + case FormatFeatureFlagBits::eBlitDst : return "BlitDst"; + case FormatFeatureFlagBits::eSampledImageFilterLinear : return "SampledImageFilterLinear"; + case FormatFeatureFlagBits::eTransferSrc : return "TransferSrc"; + case FormatFeatureFlagBits::eTransferDst : return "TransferDst"; + case FormatFeatureFlagBits::eMidpointChromaSamples : return "MidpointChromaSamples"; + case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter : return "SampledImageYcbcrConversionLinearFilter"; + case FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter: return "SampledImageYcbcrConversionSeparateReconstructionFilter"; + case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit: return "SampledImageYcbcrConversionChromaReconstructionExplicit"; + case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable: + return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable"; + case FormatFeatureFlagBits::eDisjoint : return "Disjoint"; + case FormatFeatureFlagBits::eCositedChromaSamples : return "CositedChromaSamples"; + case FormatFeatureFlagBits::eSampledImageFilterMinmax : return "SampledImageFilterMinmax"; + case FormatFeatureFlagBits::eVideoDecodeOutputKHR : return "VideoDecodeOutputKHR"; + case FormatFeatureFlagBits::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR"; + case FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR: return "AccelerationStructureVertexBufferKHR"; + case FormatFeatureFlagBits::eSampledImageFilterCubicEXT : return "SampledImageFilterCubicEXT"; + case FormatFeatureFlagBits::eFragmentDensityMapEXT : return "FragmentDensityMapEXT"; + case FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR"; + case FormatFeatureFlagBits::eVideoEncodeInputKHR : return "VideoEncodeInputKHR"; + case FormatFeatureFlagBits::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageCreateFlagBits value ) + { + switch ( value ) + { + case ImageCreateFlagBits::eSparseBinding : return "SparseBinding"; + case ImageCreateFlagBits::eSparseResidency : return "SparseResidency"; + case ImageCreateFlagBits::eSparseAliased : return "SparseAliased"; + case ImageCreateFlagBits::eMutableFormat : return "MutableFormat"; + case ImageCreateFlagBits::eCubeCompatible : return "CubeCompatible"; + case ImageCreateFlagBits::eAlias : return "Alias"; + case ImageCreateFlagBits::eSplitInstanceBindRegions : return "SplitInstanceBindRegions"; + case ImageCreateFlagBits::e2DArrayCompatible : return "2DArrayCompatible"; + case ImageCreateFlagBits::eBlockTexelViewCompatible : return "BlockTexelViewCompatible"; + case ImageCreateFlagBits::eExtendedUsage : return "ExtendedUsage"; + case ImageCreateFlagBits::eProtected : return "Protected"; + case ImageCreateFlagBits::eDisjoint : return "Disjoint"; + case ImageCreateFlagBits::eCornerSampledNV : return "CornerSampledNV"; + case ImageCreateFlagBits::eDescriptorHeapCaptureReplayEXT : return "DescriptorHeapCaptureReplayEXT"; + case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT : return "SampleLocationsCompatibleDepthEXT"; + case ImageCreateFlagBits::eSubsampledEXT : return "SubsampledEXT"; + case ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT: return "MultisampledRenderToSingleSampledEXT"; + case ImageCreateFlagBits::e2DViewCompatibleEXT : return "2DViewCompatibleEXT"; + case ImageCreateFlagBits::eVideoProfileIndependentKHR : return "VideoProfileIndependentKHR"; + case ImageCreateFlagBits::eFragmentDensityMapOffsetEXT : return "FragmentDensityMapOffsetEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageTiling value ) + { + switch ( value ) + { + case ImageTiling::eOptimal : return "Optimal"; + case ImageTiling::eLinear : return "Linear"; + case ImageTiling::eDrmFormatModifierEXT: return "DrmFormatModifierEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageType value ) + { + switch ( value ) + { + case ImageType::e1D: return "1D"; + case ImageType::e2D: return "2D"; + case ImageType::e3D: return "3D"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageUsageFlagBits value ) + { + switch ( value ) + { + case ImageUsageFlagBits::eTransferSrc : return "TransferSrc"; + case ImageUsageFlagBits::eTransferDst : return "TransferDst"; + case ImageUsageFlagBits::eSampled : return "Sampled"; + case ImageUsageFlagBits::eStorage : return "Storage"; + case ImageUsageFlagBits::eColorAttachment : return "ColorAttachment"; + case ImageUsageFlagBits::eDepthStencilAttachment : return "DepthStencilAttachment"; + case ImageUsageFlagBits::eTransientAttachment : return "TransientAttachment"; + case ImageUsageFlagBits::eInputAttachment : return "InputAttachment"; + case ImageUsageFlagBits::eHostTransfer : return "HostTransfer"; + case ImageUsageFlagBits::eVideoDecodeDstKHR : return "VideoDecodeDstKHR"; + case ImageUsageFlagBits::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR"; + case ImageUsageFlagBits::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR"; + case ImageUsageFlagBits::eFragmentDensityMapEXT : return "FragmentDensityMapEXT"; + case ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR"; + case ImageUsageFlagBits::eVideoEncodeDstKHR : return "VideoEncodeDstKHR"; + case ImageUsageFlagBits::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR"; + case ImageUsageFlagBits::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR"; + case ImageUsageFlagBits::eAttachmentFeedbackLoopEXT : return "AttachmentFeedbackLoopEXT"; + case ImageUsageFlagBits::eInvocationMaskHUAWEI : return "InvocationMaskHUAWEI"; + case ImageUsageFlagBits::eSampleWeightQCOM : return "SampleWeightQCOM"; + case ImageUsageFlagBits::eSampleBlockMatchQCOM : return "SampleBlockMatchQCOM"; + case ImageUsageFlagBits::eTensorAliasingARM : return "TensorAliasingARM"; + case ImageUsageFlagBits::eTileMemoryQCOM : return "TileMemoryQCOM"; + case ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR: return "VideoEncodeQuantizationDeltaMapKHR"; + case ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR : return "VideoEncodeEmphasisMapKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( InstanceCreateFlagBits value ) + { + switch ( value ) + { + case InstanceCreateFlagBits::eEnumeratePortabilityKHR: return "EnumeratePortabilityKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( InternalAllocationType value ) + { + switch ( value ) + { + case InternalAllocationType::eExecutable: return "Executable"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryHeapFlagBits value ) + { + switch ( value ) + { + case MemoryHeapFlagBits::eDeviceLocal : return "DeviceLocal"; + case MemoryHeapFlagBits::eMultiInstance : return "MultiInstance"; + case MemoryHeapFlagBits::eTileMemoryQCOM: return "TileMemoryQCOM"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryPropertyFlagBits value ) + { + switch ( value ) + { + case MemoryPropertyFlagBits::eDeviceLocal : return "DeviceLocal"; + case MemoryPropertyFlagBits::eHostVisible : return "HostVisible"; + case MemoryPropertyFlagBits::eHostCoherent : return "HostCoherent"; + case MemoryPropertyFlagBits::eHostCached : return "HostCached"; + case MemoryPropertyFlagBits::eLazilyAllocated : return "LazilyAllocated"; + case MemoryPropertyFlagBits::eProtected : return "Protected"; + case MemoryPropertyFlagBits::eDeviceCoherentAMD: return "DeviceCoherentAMD"; + case MemoryPropertyFlagBits::eDeviceUncachedAMD: return "DeviceUncachedAMD"; + case MemoryPropertyFlagBits::eRdmaCapableNV : return "RdmaCapableNV"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceType value ) + { + switch ( value ) + { + case PhysicalDeviceType::eOther : return "Other"; + case PhysicalDeviceType::eIntegratedGpu: return "IntegratedGpu"; + case PhysicalDeviceType::eDiscreteGpu : return "DiscreteGpu"; + case PhysicalDeviceType::eVirtualGpu : return "VirtualGpu"; + case PhysicalDeviceType::eCpu : return "Cpu"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueueFlagBits value ) + { + switch ( value ) + { + case QueueFlagBits::eGraphics : return "Graphics"; + case QueueFlagBits::eCompute : return "Compute"; + case QueueFlagBits::eTransfer : return "Transfer"; + case QueueFlagBits::eSparseBinding : return "SparseBinding"; + case QueueFlagBits::eProtected : return "Protected"; + case QueueFlagBits::eVideoDecodeKHR: return "VideoDecodeKHR"; + case QueueFlagBits::eVideoEncodeKHR: return "VideoEncodeKHR"; + case QueueFlagBits::eOpticalFlowNV : return "OpticalFlowNV"; + case QueueFlagBits::eDataGraphARM : return "DataGraphARM"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SampleCountFlagBits value ) + { + switch ( value ) + { + case SampleCountFlagBits::e1 : return "1"; + case SampleCountFlagBits::e2 : return "2"; + case SampleCountFlagBits::e4 : return "4"; + case SampleCountFlagBits::e8 : return "8"; + case SampleCountFlagBits::e16: return "16"; + case SampleCountFlagBits::e32: return "32"; + case SampleCountFlagBits::e64: return "64"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SystemAllocationScope value ) + { + switch ( value ) + { + case SystemAllocationScope::eCommand : return "Command"; + case SystemAllocationScope::eObject : return "Object"; + case SystemAllocationScope::eCache : return "Cache"; + case SystemAllocationScope::eDevice : return "Device"; + case SystemAllocationScope::eInstance: return "Instance"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceQueueCreateFlagBits value ) + { + switch ( value ) + { + case DeviceQueueCreateFlagBits::eProtected : return "Protected"; + case DeviceQueueCreateFlagBits::eInternallySynchronizedKHR: return "InternallySynchronizedKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineStageFlagBits value ) + { + switch ( value ) + { + case PipelineStageFlagBits::eTopOfPipe : return "TopOfPipe"; + case PipelineStageFlagBits::eDrawIndirect : return "DrawIndirect"; + case PipelineStageFlagBits::eVertexInput : return "VertexInput"; + case PipelineStageFlagBits::eVertexShader : return "VertexShader"; + case PipelineStageFlagBits::eTessellationControlShader : return "TessellationControlShader"; + case PipelineStageFlagBits::eTessellationEvaluationShader : return "TessellationEvaluationShader"; + case PipelineStageFlagBits::eGeometryShader : return "GeometryShader"; + case PipelineStageFlagBits::eFragmentShader : return "FragmentShader"; + case PipelineStageFlagBits::eEarlyFragmentTests : return "EarlyFragmentTests"; + case PipelineStageFlagBits::eLateFragmentTests : return "LateFragmentTests"; + case PipelineStageFlagBits::eColorAttachmentOutput : return "ColorAttachmentOutput"; + case PipelineStageFlagBits::eComputeShader : return "ComputeShader"; + case PipelineStageFlagBits::eTransfer : return "Transfer"; + case PipelineStageFlagBits::eBottomOfPipe : return "BottomOfPipe"; + case PipelineStageFlagBits::eHost : return "Host"; + case PipelineStageFlagBits::eAllGraphics : return "AllGraphics"; + case PipelineStageFlagBits::eAllCommands : return "AllCommands"; + case PipelineStageFlagBits::eNone : return "None"; + case PipelineStageFlagBits::eTransformFeedbackEXT : return "TransformFeedbackEXT"; + case PipelineStageFlagBits::eConditionalRenderingEXT : return "ConditionalRenderingEXT"; + case PipelineStageFlagBits::eAccelerationStructureBuildKHR : return "AccelerationStructureBuildKHR"; + case PipelineStageFlagBits::eRayTracingShaderKHR : return "RayTracingShaderKHR"; + case PipelineStageFlagBits::eFragmentDensityProcessEXT : return "FragmentDensityProcessEXT"; + case PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR: return "FragmentShadingRateAttachmentKHR"; + case PipelineStageFlagBits::eTaskShaderEXT : return "TaskShaderEXT"; + case PipelineStageFlagBits::eMeshShaderEXT : return "MeshShaderEXT"; + case PipelineStageFlagBits::eCommandPreprocessEXT : return "CommandPreprocessEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryMapFlagBits value ) + { + switch ( value ) + { + case MemoryMapFlagBits::ePlacedEXT: return "PlacedEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageAspectFlagBits value ) + { + switch ( value ) + { + case ImageAspectFlagBits::eColor : return "Color"; + case ImageAspectFlagBits::eDepth : return "Depth"; + case ImageAspectFlagBits::eStencil : return "Stencil"; + case ImageAspectFlagBits::eMetadata : return "Metadata"; + case ImageAspectFlagBits::ePlane0 : return "Plane0"; + case ImageAspectFlagBits::ePlane1 : return "Plane1"; + case ImageAspectFlagBits::ePlane2 : return "Plane2"; + case ImageAspectFlagBits::eNone : return "None"; + case ImageAspectFlagBits::eMemoryPlane0EXT: return "MemoryPlane0EXT"; + case ImageAspectFlagBits::eMemoryPlane1EXT: return "MemoryPlane1EXT"; + case ImageAspectFlagBits::eMemoryPlane2EXT: return "MemoryPlane2EXT"; + case ImageAspectFlagBits::eMemoryPlane3EXT: return "MemoryPlane3EXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SparseImageFormatFlagBits value ) + { + switch ( value ) + { + case SparseImageFormatFlagBits::eSingleMiptail : return "SingleMiptail"; + case SparseImageFormatFlagBits::eAlignedMipSize : return "AlignedMipSize"; + case SparseImageFormatFlagBits::eNonstandardBlockSize: return "NonstandardBlockSize"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SparseMemoryBindFlagBits value ) + { + switch ( value ) + { + case SparseMemoryBindFlagBits::eMetadata: return "Metadata"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FenceCreateFlagBits value ) + { + switch ( value ) + { + case FenceCreateFlagBits::eSignaled: return "Signaled"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryPoolCreateFlagBits value ) + { + switch ( value ) + { + case QueryPoolCreateFlagBits::eResetKHR: return "ResetKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryResultFlagBits value ) + { + switch ( value ) + { + case QueryResultFlagBits::e64 : return "64"; + case QueryResultFlagBits::eWait : return "Wait"; + case QueryResultFlagBits::eWithAvailability: return "WithAvailability"; + case QueryResultFlagBits::ePartial : return "Partial"; + case QueryResultFlagBits::eWithStatusKHR : return "WithStatusKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryType value ) + { + switch ( value ) + { + case QueryType::eOcclusion : return "Occlusion"; + case QueryType::ePipelineStatistics : return "PipelineStatistics"; + case QueryType::eTimestamp : return "Timestamp"; + case QueryType::eResultStatusOnlyKHR : return "ResultStatusOnlyKHR"; + case QueryType::eTransformFeedbackStreamEXT : return "TransformFeedbackStreamEXT"; + case QueryType::ePerformanceQueryKHR : return "PerformanceQueryKHR"; + case QueryType::eAccelerationStructureCompactedSizeKHR : return "AccelerationStructureCompactedSizeKHR"; + case QueryType::eAccelerationStructureSerializationSizeKHR : return "AccelerationStructureSerializationSizeKHR"; + case QueryType::eAccelerationStructureCompactedSizeNV : return "AccelerationStructureCompactedSizeNV"; + case QueryType::ePerformanceQueryINTEL : return "PerformanceQueryINTEL"; + case QueryType::eVideoEncodeFeedbackKHR : return "VideoEncodeFeedbackKHR"; + case QueryType::eMeshPrimitivesGeneratedEXT : return "MeshPrimitivesGeneratedEXT"; + case QueryType::ePrimitivesGeneratedEXT : return "PrimitivesGeneratedEXT"; + case QueryType::eAccelerationStructureSerializationBottomLevelPointersKHR: return "AccelerationStructureSerializationBottomLevelPointersKHR"; + case QueryType::eAccelerationStructureSizeKHR : return "AccelerationStructureSizeKHR"; + case QueryType::eMicromapSerializationSizeEXT : return "MicromapSerializationSizeEXT"; + case QueryType::eMicromapCompactedSizeEXT : return "MicromapCompactedSizeEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferCreateFlagBits value ) + { + switch ( value ) + { + case BufferCreateFlagBits::eSparseBinding : return "SparseBinding"; + case BufferCreateFlagBits::eSparseResidency : return "SparseResidency"; + case BufferCreateFlagBits::eSparseAliased : return "SparseAliased"; + case BufferCreateFlagBits::eProtected : return "Protected"; + case BufferCreateFlagBits::eDeviceAddressCaptureReplay : return "DeviceAddressCaptureReplay"; + case BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT: return "DescriptorBufferCaptureReplayEXT"; + case BufferCreateFlagBits::eVideoProfileIndependentKHR : return "VideoProfileIndependentKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferUsageFlagBits value ) + { + switch ( value ) + { + case BufferUsageFlagBits::eTransferSrc : return "TransferSrc"; + case BufferUsageFlagBits::eTransferDst : return "TransferDst"; + case BufferUsageFlagBits::eUniformTexelBuffer : return "UniformTexelBuffer"; + case BufferUsageFlagBits::eStorageTexelBuffer : return "StorageTexelBuffer"; + case BufferUsageFlagBits::eUniformBuffer : return "UniformBuffer"; + case BufferUsageFlagBits::eStorageBuffer : return "StorageBuffer"; + case BufferUsageFlagBits::eIndexBuffer : return "IndexBuffer"; + case BufferUsageFlagBits::eVertexBuffer : return "VertexBuffer"; + case BufferUsageFlagBits::eIndirectBuffer : return "IndirectBuffer"; + case BufferUsageFlagBits::eShaderDeviceAddress : return "ShaderDeviceAddress"; + case BufferUsageFlagBits::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR"; + case BufferUsageFlagBits::eVideoDecodeDstKHR : return "VideoDecodeDstKHR"; + case BufferUsageFlagBits::eTransformFeedbackBufferEXT : return "TransformFeedbackBufferEXT"; + case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT: return "TransformFeedbackCounterBufferEXT"; + case BufferUsageFlagBits::eConditionalRenderingEXT : return "ConditionalRenderingEXT"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case BufferUsageFlagBits::eExecutionGraphScratchAMDX: return "ExecutionGraphScratchAMDX"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case BufferUsageFlagBits::eDescriptorHeapEXT : return "DescriptorHeapEXT"; + case BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR: return "AccelerationStructureBuildInputReadOnlyKHR"; + case BufferUsageFlagBits::eAccelerationStructureStorageKHR : return "AccelerationStructureStorageKHR"; + case BufferUsageFlagBits::eShaderBindingTableKHR : return "ShaderBindingTableKHR"; + case BufferUsageFlagBits::eVideoEncodeDstKHR : return "VideoEncodeDstKHR"; + case BufferUsageFlagBits::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR"; + case BufferUsageFlagBits::eSamplerDescriptorBufferEXT : return "SamplerDescriptorBufferEXT"; + case BufferUsageFlagBits::eResourceDescriptorBufferEXT : return "ResourceDescriptorBufferEXT"; + case BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT : return "PushDescriptorsDescriptorBufferEXT"; + case BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT : return "MicromapBuildInputReadOnlyEXT"; + case BufferUsageFlagBits::eMicromapStorageEXT : return "MicromapStorageEXT"; + case BufferUsageFlagBits::eTileMemoryQCOM : return "TileMemoryQCOM"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SharingMode value ) + { + switch ( value ) + { + case SharingMode::eExclusive : return "Exclusive"; + case SharingMode::eConcurrent: return "Concurrent"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageLayout value ) + { + switch ( value ) + { + case ImageLayout::eUndefined : return "Undefined"; + case ImageLayout::eGeneral : return "General"; + case ImageLayout::eColorAttachmentOptimal : return "ColorAttachmentOptimal"; + case ImageLayout::eDepthStencilAttachmentOptimal : return "DepthStencilAttachmentOptimal"; + case ImageLayout::eDepthStencilReadOnlyOptimal : return "DepthStencilReadOnlyOptimal"; + case ImageLayout::eShaderReadOnlyOptimal : return "ShaderReadOnlyOptimal"; + case ImageLayout::eTransferSrcOptimal : return "TransferSrcOptimal"; + case ImageLayout::eTransferDstOptimal : return "TransferDstOptimal"; + case ImageLayout::ePreinitialized : return "Preinitialized"; + case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal : return "DepthReadOnlyStencilAttachmentOptimal"; + case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal : return "DepthAttachmentStencilReadOnlyOptimal"; + case ImageLayout::eDepthAttachmentOptimal : return "DepthAttachmentOptimal"; + case ImageLayout::eDepthReadOnlyOptimal : return "DepthReadOnlyOptimal"; + case ImageLayout::eStencilAttachmentOptimal : return "StencilAttachmentOptimal"; + case ImageLayout::eStencilReadOnlyOptimal : return "StencilReadOnlyOptimal"; + case ImageLayout::eReadOnlyOptimal : return "ReadOnlyOptimal"; + case ImageLayout::eAttachmentOptimal : return "AttachmentOptimal"; + case ImageLayout::eRenderingLocalRead : return "RenderingLocalRead"; + case ImageLayout::ePresentSrcKHR : return "PresentSrcKHR"; + case ImageLayout::eVideoDecodeDstKHR : return "VideoDecodeDstKHR"; + case ImageLayout::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR"; + case ImageLayout::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR"; + case ImageLayout::eSharedPresentKHR : return "SharedPresentKHR"; + case ImageLayout::eFragmentDensityMapOptimalEXT : return "FragmentDensityMapOptimalEXT"; + case ImageLayout::eFragmentShadingRateAttachmentOptimalKHR: return "FragmentShadingRateAttachmentOptimalKHR"; + case ImageLayout::eVideoEncodeDstKHR : return "VideoEncodeDstKHR"; + case ImageLayout::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR"; + case ImageLayout::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR"; + case ImageLayout::eAttachmentFeedbackLoopOptimalEXT : return "AttachmentFeedbackLoopOptimalEXT"; + case ImageLayout::eTensorAliasingARM : return "TensorAliasingARM"; + case ImageLayout::eVideoEncodeQuantizationMapKHR : return "VideoEncodeQuantizationMapKHR"; + case ImageLayout::eZeroInitializedEXT : return "ZeroInitializedEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ComponentSwizzle value ) + { + switch ( value ) + { + case ComponentSwizzle::eIdentity: return "Identity"; + case ComponentSwizzle::eZero : return "Zero"; + case ComponentSwizzle::eOne : return "One"; + case ComponentSwizzle::eR : return "R"; + case ComponentSwizzle::eG : return "G"; + case ComponentSwizzle::eB : return "B"; + case ComponentSwizzle::eA : return "A"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageViewCreateFlagBits value ) + { + switch ( value ) + { + case ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT : return "FragmentDensityMapDynamicEXT"; + case ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT: return "DescriptorBufferCaptureReplayEXT"; + case ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT : return "FragmentDensityMapDeferredEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageViewType value ) + { + switch ( value ) + { + case ImageViewType::e1D : return "1D"; + case ImageViewType::e2D : return "2D"; + case ImageViewType::e3D : return "3D"; + case ImageViewType::eCube : return "Cube"; + case ImageViewType::e1DArray : return "1DArray"; + case ImageViewType::e2DArray : return "2DArray"; + case ImageViewType::eCubeArray: return "CubeArray"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlagBits value ) + { + switch ( value ) + { + case AccessFlagBits::eIndirectCommandRead : return "IndirectCommandRead"; + case AccessFlagBits::eIndexRead : return "IndexRead"; + case AccessFlagBits::eVertexAttributeRead : return "VertexAttributeRead"; + case AccessFlagBits::eUniformRead : return "UniformRead"; + case AccessFlagBits::eInputAttachmentRead : return "InputAttachmentRead"; + case AccessFlagBits::eShaderRead : return "ShaderRead"; + case AccessFlagBits::eShaderWrite : return "ShaderWrite"; + case AccessFlagBits::eColorAttachmentRead : return "ColorAttachmentRead"; + case AccessFlagBits::eColorAttachmentWrite : return "ColorAttachmentWrite"; + case AccessFlagBits::eDepthStencilAttachmentRead : return "DepthStencilAttachmentRead"; + case AccessFlagBits::eDepthStencilAttachmentWrite : return "DepthStencilAttachmentWrite"; + case AccessFlagBits::eTransferRead : return "TransferRead"; + case AccessFlagBits::eTransferWrite : return "TransferWrite"; + case AccessFlagBits::eHostRead : return "HostRead"; + case AccessFlagBits::eHostWrite : return "HostWrite"; + case AccessFlagBits::eMemoryRead : return "MemoryRead"; + case AccessFlagBits::eMemoryWrite : return "MemoryWrite"; + case AccessFlagBits::eNone : return "None"; + case AccessFlagBits::eTransformFeedbackWriteEXT : return "TransformFeedbackWriteEXT"; + case AccessFlagBits::eTransformFeedbackCounterReadEXT : return "TransformFeedbackCounterReadEXT"; + case AccessFlagBits::eTransformFeedbackCounterWriteEXT : return "TransformFeedbackCounterWriteEXT"; + case AccessFlagBits::eConditionalRenderingReadEXT : return "ConditionalRenderingReadEXT"; + case AccessFlagBits::eColorAttachmentReadNoncoherentEXT : return "ColorAttachmentReadNoncoherentEXT"; + case AccessFlagBits::eAccelerationStructureReadKHR : return "AccelerationStructureReadKHR"; + case AccessFlagBits::eAccelerationStructureWriteKHR : return "AccelerationStructureWriteKHR"; + case AccessFlagBits::eFragmentDensityMapReadEXT : return "FragmentDensityMapReadEXT"; + case AccessFlagBits::eFragmentShadingRateAttachmentReadKHR: return "FragmentShadingRateAttachmentReadKHR"; + case AccessFlagBits::eCommandPreprocessReadEXT : return "CommandPreprocessReadEXT"; + case AccessFlagBits::eCommandPreprocessWriteEXT : return "CommandPreprocessWriteEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DependencyFlagBits value ) + { + switch ( value ) + { + case DependencyFlagBits::eByRegion : return "ByRegion"; + case DependencyFlagBits::eDeviceGroup : return "DeviceGroup"; + case DependencyFlagBits::eViewLocal : return "ViewLocal"; + case DependencyFlagBits::eFeedbackLoopEXT : return "FeedbackLoopEXT"; + case DependencyFlagBits::eQueueFamilyOwnershipTransferUseAllStagesKHR: return "QueueFamilyOwnershipTransferUseAllStagesKHR"; + case DependencyFlagBits::eAsymmetricEventKHR : return "AsymmetricEventKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolCreateFlagBits value ) + { + switch ( value ) + { + case CommandPoolCreateFlagBits::eTransient : return "Transient"; + case CommandPoolCreateFlagBits::eResetCommandBuffer: return "ResetCommandBuffer"; + case CommandPoolCreateFlagBits::eProtected : return "Protected"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolResetFlagBits value ) + { + switch ( value ) + { + case CommandPoolResetFlagBits::eReleaseResources: return "ReleaseResources"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandBufferLevel value ) + { + switch ( value ) + { + case CommandBufferLevel::ePrimary : return "Primary"; + case CommandBufferLevel::eSecondary: return "Secondary"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandBufferResetFlagBits value ) + { + switch ( value ) + { + case CommandBufferResetFlagBits::eReleaseResources: return "ReleaseResources"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandBufferUsageFlagBits value ) + { + switch ( value ) + { + case CommandBufferUsageFlagBits::eOneTimeSubmit : return "OneTimeSubmit"; + case CommandBufferUsageFlagBits::eRenderPassContinue: return "RenderPassContinue"; + case CommandBufferUsageFlagBits::eSimultaneousUse : return "SimultaneousUse"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryControlFlagBits value ) + { + switch ( value ) + { + case QueryControlFlagBits::ePrecise: return "Precise"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndexType value ) + { + switch ( value ) + { + case IndexType::eUint16 : return "Uint16"; + case IndexType::eUint32 : return "Uint32"; + case IndexType::eUint8 : return "Uint8"; + case IndexType::eNoneKHR: return "NoneKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCacheHeaderVersion value ) + { + switch ( value ) + { + case PipelineCacheHeaderVersion::eOne : return "One"; + case PipelineCacheHeaderVersion::eDataGraphQCOM: return "DataGraphQCOM"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( EventCreateFlagBits value ) + { + switch ( value ) + { + case EventCreateFlagBits::eDeviceOnly: return "DeviceOnly"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferViewCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderModuleCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCacheCreateFlagBits value ) + { + switch ( value ) + { + case PipelineCacheCreateFlagBits::eExternallySynchronized : return "ExternallySynchronized"; + case PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR: return "InternallySynchronizedMergeKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCreateFlagBits value ) + { + switch ( value ) + { + case PipelineCreateFlagBits::eDisableOptimization : return "DisableOptimization"; + case PipelineCreateFlagBits::eAllowDerivatives : return "AllowDerivatives"; + case PipelineCreateFlagBits::eDerivative : return "Derivative"; + case PipelineCreateFlagBits::eDispatchBase : return "DispatchBase"; + case PipelineCreateFlagBits::eViewIndexFromDeviceIndex : return "ViewIndexFromDeviceIndex"; + case PipelineCreateFlagBits::eFailOnPipelineCompileRequired : return "FailOnPipelineCompileRequired"; + case PipelineCreateFlagBits::eEarlyReturnOnFailure : return "EarlyReturnOnFailure"; + case PipelineCreateFlagBits::eNoProtectedAccess : return "NoProtectedAccess"; + case PipelineCreateFlagBits::eProtectedAccessOnly : return "ProtectedAccessOnly"; + case PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR : return "RayTracingNoNullAnyHitShadersKHR"; + case PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR : return "RayTracingNoNullClosestHitShadersKHR"; + case PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR : return "RayTracingNoNullMissShadersKHR"; + case PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR : return "RayTracingNoNullIntersectionShadersKHR"; + case PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR : return "RayTracingSkipTrianglesKHR"; + case PipelineCreateFlagBits::eRayTracingSkipAabbsKHR : return "RayTracingSkipAabbsKHR"; + case PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR: return "RayTracingShaderGroupHandleCaptureReplayKHR"; + case PipelineCreateFlagBits::eDeferCompileNV : return "DeferCompileNV"; + case PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT : return "RenderingFragmentDensityMapAttachmentEXT"; + case PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR : return "RenderingFragmentShadingRateAttachmentKHR"; + case PipelineCreateFlagBits::eCaptureStatisticsKHR : return "CaptureStatisticsKHR"; + case PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR : return "CaptureInternalRepresentationsKHR"; + case PipelineCreateFlagBits::eIndirectBindableNV : return "IndirectBindableNV"; + case PipelineCreateFlagBits::eLibraryKHR : return "LibraryKHR"; + case PipelineCreateFlagBits::eDescriptorBufferEXT : return "DescriptorBufferEXT"; + case PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT : return "RetainLinkTimeOptimizationInfoEXT"; + case PipelineCreateFlagBits::eLinkTimeOptimizationEXT : return "LinkTimeOptimizationEXT"; + case PipelineCreateFlagBits::eRayTracingAllowMotionNV : return "RayTracingAllowMotionNV"; + case PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT : return "ColorAttachmentFeedbackLoopEXT"; + case PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT : return "DepthStencilAttachmentFeedbackLoopEXT"; + case PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT : return "RayTracingOpacityMicromapEXT"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineShaderStageCreateFlagBits value ) + { + switch ( value ) + { + case PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize: return "AllowVaryingSubgroupSize"; + case PipelineShaderStageCreateFlagBits::eRequireFullSubgroups : return "RequireFullSubgroups"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderStageFlagBits value ) + { + switch ( value ) + { + case ShaderStageFlagBits::eVertex : return "Vertex"; + case ShaderStageFlagBits::eTessellationControl : return "TessellationControl"; + case ShaderStageFlagBits::eTessellationEvaluation: return "TessellationEvaluation"; + case ShaderStageFlagBits::eGeometry : return "Geometry"; + case ShaderStageFlagBits::eFragment : return "Fragment"; + case ShaderStageFlagBits::eCompute : return "Compute"; + case ShaderStageFlagBits::eAllGraphics : return "AllGraphics"; + case ShaderStageFlagBits::eAll : return "All"; + case ShaderStageFlagBits::eRaygenKHR : return "RaygenKHR"; + case ShaderStageFlagBits::eAnyHitKHR : return "AnyHitKHR"; + case ShaderStageFlagBits::eClosestHitKHR : return "ClosestHitKHR"; + case ShaderStageFlagBits::eMissKHR : return "MissKHR"; + case ShaderStageFlagBits::eIntersectionKHR : return "IntersectionKHR"; + case ShaderStageFlagBits::eCallableKHR : return "CallableKHR"; + case ShaderStageFlagBits::eTaskEXT : return "TaskEXT"; + case ShaderStageFlagBits::eMeshEXT : return "MeshEXT"; + case ShaderStageFlagBits::eSubpassShadingHUAWEI : return "SubpassShadingHUAWEI"; + case ShaderStageFlagBits::eClusterCullingHUAWEI : return "ClusterCullingHUAWEI"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineLayoutCreateFlagBits value ) + { + switch ( value ) + { + case PipelineLayoutCreateFlagBits::eIndependentSetsEXT: return "IndependentSetsEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BorderColor value ) + { + switch ( value ) + { + case BorderColor::eFloatTransparentBlack: return "FloatTransparentBlack"; + case BorderColor::eIntTransparentBlack : return "IntTransparentBlack"; + case BorderColor::eFloatOpaqueBlack : return "FloatOpaqueBlack"; + case BorderColor::eIntOpaqueBlack : return "IntOpaqueBlack"; + case BorderColor::eFloatOpaqueWhite : return "FloatOpaqueWhite"; + case BorderColor::eIntOpaqueWhite : return "IntOpaqueWhite"; + case BorderColor::eFloatCustomEXT : return "FloatCustomEXT"; + case BorderColor::eIntCustomEXT : return "IntCustomEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Filter value ) + { + switch ( value ) + { + case Filter::eNearest : return "Nearest"; + case Filter::eLinear : return "Linear"; + case Filter::eCubicEXT: return "CubicEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerAddressMode value ) + { + switch ( value ) + { + case SamplerAddressMode::eRepeat : return "Repeat"; + case SamplerAddressMode::eMirroredRepeat : return "MirroredRepeat"; + case SamplerAddressMode::eClampToEdge : return "ClampToEdge"; + case SamplerAddressMode::eClampToBorder : return "ClampToBorder"; + case SamplerAddressMode::eMirrorClampToEdge: return "MirrorClampToEdge"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerCreateFlagBits value ) + { + switch ( value ) + { + case SamplerCreateFlagBits::eSubsampledEXT : return "SubsampledEXT"; + case SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT: return "SubsampledCoarseReconstructionEXT"; + case SamplerCreateFlagBits::eDescriptorBufferCaptureReplayEXT : return "DescriptorBufferCaptureReplayEXT"; + case SamplerCreateFlagBits::eNonSeamlessCubeMapEXT : return "NonSeamlessCubeMapEXT"; + case SamplerCreateFlagBits::eImageProcessingQCOM : return "ImageProcessingQCOM"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerMipmapMode value ) + { + switch ( value ) + { + case SamplerMipmapMode::eNearest: return "Nearest"; + case SamplerMipmapMode::eLinear : return "Linear"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorPoolCreateFlagBits value ) + { + switch ( value ) + { + case DescriptorPoolCreateFlagBits::eFreeDescriptorSet : return "FreeDescriptorSet"; + case DescriptorPoolCreateFlagBits::eUpdateAfterBind : return "UpdateAfterBind"; + case DescriptorPoolCreateFlagBits::eHostOnlyEXT : return "HostOnlyEXT"; + case DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV : return "AllowOverallocationSetsNV"; + case DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV: return "AllowOverallocationPoolsNV"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorSetLayoutCreateFlagBits value ) + { + switch ( value ) + { + case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool : return "UpdateAfterBindPool"; + case DescriptorSetLayoutCreateFlagBits::ePushDescriptor : return "PushDescriptor"; + case DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT : return "DescriptorBufferEXT"; + case DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT: return "EmbeddedImmutableSamplersEXT"; + case DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV : return "IndirectBindableNV"; + case DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT : return "HostOnlyPoolEXT"; + case DescriptorSetLayoutCreateFlagBits::ePerStageNV : return "PerStageNV"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorType value ) + { + switch ( value ) + { + case DescriptorType::eSampler : return "Sampler"; + case DescriptorType::eCombinedImageSampler : return "CombinedImageSampler"; + case DescriptorType::eSampledImage : return "SampledImage"; + case DescriptorType::eStorageImage : return "StorageImage"; + case DescriptorType::eUniformTexelBuffer : return "UniformTexelBuffer"; + case DescriptorType::eStorageTexelBuffer : return "StorageTexelBuffer"; + case DescriptorType::eUniformBuffer : return "UniformBuffer"; + case DescriptorType::eStorageBuffer : return "StorageBuffer"; + case DescriptorType::eUniformBufferDynamic : return "UniformBufferDynamic"; + case DescriptorType::eStorageBufferDynamic : return "StorageBufferDynamic"; + case DescriptorType::eInputAttachment : return "InputAttachment"; + case DescriptorType::eInlineUniformBlock : return "InlineUniformBlock"; + case DescriptorType::eAccelerationStructureKHR : return "AccelerationStructureKHR"; + case DescriptorType::eAccelerationStructureNV : return "AccelerationStructureNV"; + case DescriptorType::eSampleWeightImageQCOM : return "SampleWeightImageQCOM"; + case DescriptorType::eBlockMatchImageQCOM : return "BlockMatchImageQCOM"; + case DescriptorType::eTensorARM : return "TensorARM"; + case DescriptorType::eMutableEXT : return "MutableEXT"; + case DescriptorType::ePartitionedAccelerationStructureNV: return "PartitionedAccelerationStructureNV"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorPoolResetFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryPipelineStatisticFlagBits value ) + { + switch ( value ) + { + case QueryPipelineStatisticFlagBits::eInputAssemblyVertices : return "InputAssemblyVertices"; + case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives : return "InputAssemblyPrimitives"; + case QueryPipelineStatisticFlagBits::eVertexShaderInvocations : return "VertexShaderInvocations"; + case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations : return "GeometryShaderInvocations"; + case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives : return "GeometryShaderPrimitives"; + case QueryPipelineStatisticFlagBits::eClippingInvocations : return "ClippingInvocations"; + case QueryPipelineStatisticFlagBits::eClippingPrimitives : return "ClippingPrimitives"; + case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations : return "FragmentShaderInvocations"; + case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches : return "TessellationControlShaderPatches"; + case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "TessellationEvaluationShaderInvocations"; + case QueryPipelineStatisticFlagBits::eComputeShaderInvocations : return "ComputeShaderInvocations"; + case QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT : return "TaskShaderInvocationsEXT"; + case QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT : return "MeshShaderInvocationsEXT"; + case QueryPipelineStatisticFlagBits::eClusterCullingShaderInvocationsHUAWEI : return "ClusterCullingShaderInvocationsHUAWEI"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineBindPoint value ) + { + switch ( value ) + { + case PipelineBindPoint::eGraphics: return "Graphics"; + case PipelineBindPoint::eCompute : return "Compute"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case PipelineBindPoint::eExecutionGraphAMDX: return "ExecutionGraphAMDX"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case PipelineBindPoint::eRayTracingKHR : return "RayTracingKHR"; + case PipelineBindPoint::eSubpassShadingHUAWEI: return "SubpassShadingHUAWEI"; + case PipelineBindPoint::eDataGraphARM : return "DataGraphARM"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlendFactor value ) + { + switch ( value ) + { + case BlendFactor::eZero : return "Zero"; + case BlendFactor::eOne : return "One"; + case BlendFactor::eSrcColor : return "SrcColor"; + case BlendFactor::eOneMinusSrcColor : return "OneMinusSrcColor"; + case BlendFactor::eDstColor : return "DstColor"; + case BlendFactor::eOneMinusDstColor : return "OneMinusDstColor"; + case BlendFactor::eSrcAlpha : return "SrcAlpha"; + case BlendFactor::eOneMinusSrcAlpha : return "OneMinusSrcAlpha"; + case BlendFactor::eDstAlpha : return "DstAlpha"; + case BlendFactor::eOneMinusDstAlpha : return "OneMinusDstAlpha"; + case BlendFactor::eConstantColor : return "ConstantColor"; + case BlendFactor::eOneMinusConstantColor: return "OneMinusConstantColor"; + case BlendFactor::eConstantAlpha : return "ConstantAlpha"; + case BlendFactor::eOneMinusConstantAlpha: return "OneMinusConstantAlpha"; + case BlendFactor::eSrcAlphaSaturate : return "SrcAlphaSaturate"; + case BlendFactor::eSrc1Color : return "Src1Color"; + case BlendFactor::eOneMinusSrc1Color : return "OneMinusSrc1Color"; + case BlendFactor::eSrc1Alpha : return "Src1Alpha"; + case BlendFactor::eOneMinusSrc1Alpha : return "OneMinusSrc1Alpha"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlendOp value ) + { + switch ( value ) + { + case BlendOp::eAdd : return "Add"; + case BlendOp::eSubtract : return "Subtract"; + case BlendOp::eReverseSubtract : return "ReverseSubtract"; + case BlendOp::eMin : return "Min"; + case BlendOp::eMax : return "Max"; + case BlendOp::eZeroEXT : return "ZeroEXT"; + case BlendOp::eSrcEXT : return "SrcEXT"; + case BlendOp::eDstEXT : return "DstEXT"; + case BlendOp::eSrcOverEXT : return "SrcOverEXT"; + case BlendOp::eDstOverEXT : return "DstOverEXT"; + case BlendOp::eSrcInEXT : return "SrcInEXT"; + case BlendOp::eDstInEXT : return "DstInEXT"; + case BlendOp::eSrcOutEXT : return "SrcOutEXT"; + case BlendOp::eDstOutEXT : return "DstOutEXT"; + case BlendOp::eSrcAtopEXT : return "SrcAtopEXT"; + case BlendOp::eDstAtopEXT : return "DstAtopEXT"; + case BlendOp::eXorEXT : return "XorEXT"; + case BlendOp::eMultiplyEXT : return "MultiplyEXT"; + case BlendOp::eScreenEXT : return "ScreenEXT"; + case BlendOp::eOverlayEXT : return "OverlayEXT"; + case BlendOp::eDarkenEXT : return "DarkenEXT"; + case BlendOp::eLightenEXT : return "LightenEXT"; + case BlendOp::eColordodgeEXT : return "ColordodgeEXT"; + case BlendOp::eColorburnEXT : return "ColorburnEXT"; + case BlendOp::eHardlightEXT : return "HardlightEXT"; + case BlendOp::eSoftlightEXT : return "SoftlightEXT"; + case BlendOp::eDifferenceEXT : return "DifferenceEXT"; + case BlendOp::eExclusionEXT : return "ExclusionEXT"; + case BlendOp::eInvertEXT : return "InvertEXT"; + case BlendOp::eInvertRgbEXT : return "InvertRgbEXT"; + case BlendOp::eLineardodgeEXT : return "LineardodgeEXT"; + case BlendOp::eLinearburnEXT : return "LinearburnEXT"; + case BlendOp::eVividlightEXT : return "VividlightEXT"; + case BlendOp::eLinearlightEXT : return "LinearlightEXT"; + case BlendOp::ePinlightEXT : return "PinlightEXT"; + case BlendOp::eHardmixEXT : return "HardmixEXT"; + case BlendOp::eHslHueEXT : return "HslHueEXT"; + case BlendOp::eHslSaturationEXT : return "HslSaturationEXT"; + case BlendOp::eHslColorEXT : return "HslColorEXT"; + case BlendOp::eHslLuminosityEXT : return "HslLuminosityEXT"; + case BlendOp::ePlusEXT : return "PlusEXT"; + case BlendOp::ePlusClampedEXT : return "PlusClampedEXT"; + case BlendOp::ePlusClampedAlphaEXT: return "PlusClampedAlphaEXT"; + case BlendOp::ePlusDarkerEXT : return "PlusDarkerEXT"; + case BlendOp::eMinusEXT : return "MinusEXT"; + case BlendOp::eMinusClampedEXT : return "MinusClampedEXT"; + case BlendOp::eContrastEXT : return "ContrastEXT"; + case BlendOp::eInvertOvgEXT : return "InvertOvgEXT"; + case BlendOp::eRedEXT : return "RedEXT"; + case BlendOp::eGreenEXT : return "GreenEXT"; + case BlendOp::eBlueEXT : return "BlueEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ColorComponentFlagBits value ) + { + switch ( value ) + { + case ColorComponentFlagBits::eR: return "R"; + case ColorComponentFlagBits::eG: return "G"; + case ColorComponentFlagBits::eB: return "B"; + case ColorComponentFlagBits::eA: return "A"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CompareOp value ) + { + switch ( value ) + { + case CompareOp::eNever : return "Never"; + case CompareOp::eLess : return "Less"; + case CompareOp::eEqual : return "Equal"; + case CompareOp::eLessOrEqual : return "LessOrEqual"; + case CompareOp::eGreater : return "Greater"; + case CompareOp::eNotEqual : return "NotEqual"; + case CompareOp::eGreaterOrEqual: return "GreaterOrEqual"; + case CompareOp::eAlways : return "Always"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CullModeFlagBits value ) + { + switch ( value ) + { + case CullModeFlagBits::eNone : return "None"; + case CullModeFlagBits::eFront : return "Front"; + case CullModeFlagBits::eBack : return "Back"; + case CullModeFlagBits::eFrontAndBack: return "FrontAndBack"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DynamicState value ) + { + switch ( value ) + { + case DynamicState::eViewport : return "Viewport"; + case DynamicState::eScissor : return "Scissor"; + case DynamicState::eLineWidth : return "LineWidth"; + case DynamicState::eDepthBias : return "DepthBias"; + case DynamicState::eBlendConstants : return "BlendConstants"; + case DynamicState::eDepthBounds : return "DepthBounds"; + case DynamicState::eStencilCompareMask : return "StencilCompareMask"; + case DynamicState::eStencilWriteMask : return "StencilWriteMask"; + case DynamicState::eStencilReference : return "StencilReference"; + case DynamicState::eCullMode : return "CullMode"; + case DynamicState::eFrontFace : return "FrontFace"; + case DynamicState::ePrimitiveTopology : return "PrimitiveTopology"; + case DynamicState::eViewportWithCount : return "ViewportWithCount"; + case DynamicState::eScissorWithCount : return "ScissorWithCount"; + case DynamicState::eVertexInputBindingStride : return "VertexInputBindingStride"; + case DynamicState::eDepthTestEnable : return "DepthTestEnable"; + case DynamicState::eDepthWriteEnable : return "DepthWriteEnable"; + case DynamicState::eDepthCompareOp : return "DepthCompareOp"; + case DynamicState::eDepthBoundsTestEnable : return "DepthBoundsTestEnable"; + case DynamicState::eStencilTestEnable : return "StencilTestEnable"; + case DynamicState::eStencilOp : return "StencilOp"; + case DynamicState::eRasterizerDiscardEnable : return "RasterizerDiscardEnable"; + case DynamicState::eDepthBiasEnable : return "DepthBiasEnable"; + case DynamicState::ePrimitiveRestartEnable : return "PrimitiveRestartEnable"; + case DynamicState::eLineStipple : return "LineStipple"; + case DynamicState::eViewportWScalingNV : return "ViewportWScalingNV"; + case DynamicState::eDiscardRectangleEXT : return "DiscardRectangleEXT"; + case DynamicState::eDiscardRectangleEnableEXT : return "DiscardRectangleEnableEXT"; + case DynamicState::eDiscardRectangleModeEXT : return "DiscardRectangleModeEXT"; + case DynamicState::eSampleLocationsEXT : return "SampleLocationsEXT"; + case DynamicState::eRayTracingPipelineStackSizeKHR : return "RayTracingPipelineStackSizeKHR"; + case DynamicState::eViewportShadingRatePaletteNV : return "ViewportShadingRatePaletteNV"; + case DynamicState::eViewportCoarseSampleOrderNV : return "ViewportCoarseSampleOrderNV"; + case DynamicState::eExclusiveScissorEnableNV : return "ExclusiveScissorEnableNV"; + case DynamicState::eExclusiveScissorNV : return "ExclusiveScissorNV"; + case DynamicState::eFragmentShadingRateKHR : return "FragmentShadingRateKHR"; + case DynamicState::eVertexInputEXT : return "VertexInputEXT"; + case DynamicState::ePatchControlPointsEXT : return "PatchControlPointsEXT"; + case DynamicState::eLogicOpEXT : return "LogicOpEXT"; + case DynamicState::eColorWriteEnableEXT : return "ColorWriteEnableEXT"; + case DynamicState::eDepthClampEnableEXT : return "DepthClampEnableEXT"; + case DynamicState::ePolygonModeEXT : return "PolygonModeEXT"; + case DynamicState::eRasterizationSamplesEXT : return "RasterizationSamplesEXT"; + case DynamicState::eSampleMaskEXT : return "SampleMaskEXT"; + case DynamicState::eAlphaToCoverageEnableEXT : return "AlphaToCoverageEnableEXT"; + case DynamicState::eAlphaToOneEnableEXT : return "AlphaToOneEnableEXT"; + case DynamicState::eLogicOpEnableEXT : return "LogicOpEnableEXT"; + case DynamicState::eColorBlendEnableEXT : return "ColorBlendEnableEXT"; + case DynamicState::eColorBlendEquationEXT : return "ColorBlendEquationEXT"; + case DynamicState::eColorWriteMaskEXT : return "ColorWriteMaskEXT"; + case DynamicState::eTessellationDomainOriginEXT : return "TessellationDomainOriginEXT"; + case DynamicState::eRasterizationStreamEXT : return "RasterizationStreamEXT"; + case DynamicState::eConservativeRasterizationModeEXT : return "ConservativeRasterizationModeEXT"; + case DynamicState::eExtraPrimitiveOverestimationSizeEXT: return "ExtraPrimitiveOverestimationSizeEXT"; + case DynamicState::eDepthClipEnableEXT : return "DepthClipEnableEXT"; + case DynamicState::eSampleLocationsEnableEXT : return "SampleLocationsEnableEXT"; + case DynamicState::eColorBlendAdvancedEXT : return "ColorBlendAdvancedEXT"; + case DynamicState::eProvokingVertexModeEXT : return "ProvokingVertexModeEXT"; + case DynamicState::eLineRasterizationModeEXT : return "LineRasterizationModeEXT"; + case DynamicState::eLineStippleEnableEXT : return "LineStippleEnableEXT"; + case DynamicState::eDepthClipNegativeOneToOneEXT : return "DepthClipNegativeOneToOneEXT"; + case DynamicState::eViewportWScalingEnableNV : return "ViewportWScalingEnableNV"; + case DynamicState::eViewportSwizzleNV : return "ViewportSwizzleNV"; + case DynamicState::eCoverageToColorEnableNV : return "CoverageToColorEnableNV"; + case DynamicState::eCoverageToColorLocationNV : return "CoverageToColorLocationNV"; + case DynamicState::eCoverageModulationModeNV : return "CoverageModulationModeNV"; + case DynamicState::eCoverageModulationTableEnableNV : return "CoverageModulationTableEnableNV"; + case DynamicState::eCoverageModulationTableNV : return "CoverageModulationTableNV"; + case DynamicState::eShadingRateImageEnableNV : return "ShadingRateImageEnableNV"; + case DynamicState::eRepresentativeFragmentTestEnableNV : return "RepresentativeFragmentTestEnableNV"; + case DynamicState::eCoverageReductionModeNV : return "CoverageReductionModeNV"; + case DynamicState::eAttachmentFeedbackLoopEnableEXT : return "AttachmentFeedbackLoopEnableEXT"; + case DynamicState::eDepthClampRangeEXT : return "DepthClampRangeEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FrontFace value ) + { + switch ( value ) + { + case FrontFace::eCounterClockwise: return "CounterClockwise"; + case FrontFace::eClockwise : return "Clockwise"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LogicOp value ) + { + switch ( value ) + { + case LogicOp::eClear : return "Clear"; + case LogicOp::eAnd : return "And"; + case LogicOp::eAndReverse : return "AndReverse"; + case LogicOp::eCopy : return "Copy"; + case LogicOp::eAndInverted : return "AndInverted"; + case LogicOp::eNoOp : return "NoOp"; + case LogicOp::eXor : return "Xor"; + case LogicOp::eOr : return "Or"; + case LogicOp::eNor : return "Nor"; + case LogicOp::eEquivalent : return "Equivalent"; + case LogicOp::eInvert : return "Invert"; + case LogicOp::eOrReverse : return "OrReverse"; + case LogicOp::eCopyInverted: return "CopyInverted"; + case LogicOp::eOrInverted : return "OrInverted"; + case LogicOp::eNand : return "Nand"; + case LogicOp::eSet : return "Set"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PolygonMode value ) + { + switch ( value ) + { + case PolygonMode::eFill : return "Fill"; + case PolygonMode::eLine : return "Line"; + case PolygonMode::ePoint : return "Point"; + case PolygonMode::eFillRectangleNV: return "FillRectangleNV"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrimitiveTopology value ) + { + switch ( value ) + { + case PrimitiveTopology::ePointList : return "PointList"; + case PrimitiveTopology::eLineList : return "LineList"; + case PrimitiveTopology::eLineStrip : return "LineStrip"; + case PrimitiveTopology::eTriangleList : return "TriangleList"; + case PrimitiveTopology::eTriangleStrip : return "TriangleStrip"; + case PrimitiveTopology::eTriangleFan : return "TriangleFan"; + case PrimitiveTopology::eLineListWithAdjacency : return "LineListWithAdjacency"; + case PrimitiveTopology::eLineStripWithAdjacency : return "LineStripWithAdjacency"; + case PrimitiveTopology::eTriangleListWithAdjacency : return "TriangleListWithAdjacency"; + case PrimitiveTopology::eTriangleStripWithAdjacency: return "TriangleStripWithAdjacency"; + case PrimitiveTopology::ePatchList : return "PatchList"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StencilOp value ) + { + switch ( value ) + { + case StencilOp::eKeep : return "Keep"; + case StencilOp::eZero : return "Zero"; + case StencilOp::eReplace : return "Replace"; + case StencilOp::eIncrementAndClamp: return "IncrementAndClamp"; + case StencilOp::eDecrementAndClamp: return "DecrementAndClamp"; + case StencilOp::eInvert : return "Invert"; + case StencilOp::eIncrementAndWrap : return "IncrementAndWrap"; + case StencilOp::eDecrementAndWrap : return "DecrementAndWrap"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VertexInputRate value ) + { + switch ( value ) + { + case VertexInputRate::eVertex : return "Vertex"; + case VertexInputRate::eInstance: return "Instance"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineColorBlendStateCreateFlagBits value ) + { + switch ( value ) + { + case PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT: return "RasterizationOrderAttachmentAccessEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDepthStencilStateCreateFlagBits value ) + { + switch ( value ) + { + case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT : return "RasterizationOrderAttachmentDepthAccessEXT"; + case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDynamicStateCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineInputAssemblyStateCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineMultisampleStateCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineTessellationStateCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineVertexInputStateCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportStateCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AttachmentDescriptionFlagBits value ) + { + switch ( value ) + { + case AttachmentDescriptionFlagBits::eMayAlias : return "MayAlias"; + case AttachmentDescriptionFlagBits::eResolveSkipTransferFunctionKHR : return "ResolveSkipTransferFunctionKHR"; + case AttachmentDescriptionFlagBits::eResolveEnableTransferFunctionKHR: return "ResolveEnableTransferFunctionKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AttachmentLoadOp value ) + { + switch ( value ) + { + case AttachmentLoadOp::eLoad : return "Load"; + case AttachmentLoadOp::eClear : return "Clear"; + case AttachmentLoadOp::eDontCare: return "DontCare"; + case AttachmentLoadOp::eNone : return "None"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AttachmentStoreOp value ) + { + switch ( value ) + { + case AttachmentStoreOp::eStore : return "Store"; + case AttachmentStoreOp::eDontCare: return "DontCare"; + case AttachmentStoreOp::eNone : return "None"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FramebufferCreateFlagBits value ) + { + switch ( value ) + { + case FramebufferCreateFlagBits::eImageless: return "Imageless"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderPassCreateFlagBits value ) + { + switch ( value ) + { + case RenderPassCreateFlagBits::eTransformQCOM : return "TransformQCOM"; + case RenderPassCreateFlagBits::ePerLayerFragmentDensityVALVE: return "PerLayerFragmentDensityVALVE"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubpassDescriptionFlagBits value ) + { + switch ( value ) + { + case SubpassDescriptionFlagBits::ePerViewAttributesNVX : return "PerViewAttributesNVX"; + case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX : return "PerViewPositionXOnlyNVX"; + case SubpassDescriptionFlagBits::eTileShadingApronQCOM : return "TileShadingApronQCOM"; + case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT : return "RasterizationOrderAttachmentColorAccessEXT"; + case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT : return "RasterizationOrderAttachmentDepthAccessEXT"; + case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT"; + case SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT : return "EnableLegacyDitheringEXT"; + case SubpassDescriptionFlagBits::eFragmentRegionEXT : return "FragmentRegionEXT"; + case SubpassDescriptionFlagBits::eCustomResolveEXT : return "CustomResolveEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StencilFaceFlagBits value ) + { + switch ( value ) + { + case StencilFaceFlagBits::eFront : return "Front"; + case StencilFaceFlagBits::eBack : return "Back"; + case StencilFaceFlagBits::eFrontAndBack: return "FrontAndBack"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubpassContents value ) + { + switch ( value ) + { + case SubpassContents::eInline : return "Inline"; + case SubpassContents::eSecondaryCommandBuffers : return "SecondaryCommandBuffers"; + case SubpassContents::eInlineAndSecondaryCommandBuffersKHR: return "InlineAndSecondaryCommandBuffersKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_VERSION_1_1 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PeerMemoryFeatureFlagBits value ) + { + switch ( value ) + { + case PeerMemoryFeatureFlagBits::eCopySrc : return "CopySrc"; + case PeerMemoryFeatureFlagBits::eCopyDst : return "CopyDst"; + case PeerMemoryFeatureFlagBits::eGenericSrc: return "GenericSrc"; + case PeerMemoryFeatureFlagBits::eGenericDst: return "GenericDst"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryAllocateFlagBits value ) + { + switch ( value ) + { + case MemoryAllocateFlagBits::eDeviceMask : return "DeviceMask"; + case MemoryAllocateFlagBits::eDeviceAddress : return "DeviceAddress"; + case MemoryAllocateFlagBits::eDeviceAddressCaptureReplay: return "DeviceAddressCaptureReplay"; + case MemoryAllocateFlagBits::eZeroInitializeEXT : return "ZeroInitializeEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolTrimFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryHandleTypeFlagBits value ) + { + switch ( value ) + { + case ExternalMemoryHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd"; + case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32"; + case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt : return "OpaqueWin32Kmt"; + case ExternalMemoryHandleTypeFlagBits::eD3D11Texture : return "D3D11Texture"; + case ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt: return "D3D11TextureKmt"; + case ExternalMemoryHandleTypeFlagBits::eD3D12Heap : return "D3D12Heap"; + case ExternalMemoryHandleTypeFlagBits::eD3D12Resource : return "D3D12Resource"; + case ExternalMemoryHandleTypeFlagBits::eDmaBufEXT : return "DmaBufEXT"; +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + case ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID: return "AndroidHardwareBufferANDROID"; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + case ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT : return "HostAllocationEXT"; + case ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT: return "HostMappedForeignMemoryEXT"; +#if defined( VK_USE_PLATFORM_FUCHSIA ) + case ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA: return "ZirconVmoFUCHSIA"; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + case ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV: return "RdmaAddressNV"; +#if defined( VK_USE_PLATFORM_OHOS ) + case ExternalMemoryHandleTypeFlagBits::eOhNativeBufferOHOS: return "OhNativeBufferOHOS"; +#endif /*VK_USE_PLATFORM_OHOS*/ +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + case ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX: return "ScreenBufferQNX"; +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ +#if defined( VK_USE_PLATFORM_METAL_EXT ) + case ExternalMemoryHandleTypeFlagBits::eMtlbufferEXT : return "MtlbufferEXT"; + case ExternalMemoryHandleTypeFlagBits::eMtltextureEXT: return "MtltextureEXT"; + case ExternalMemoryHandleTypeFlagBits::eMtlheapEXT : return "MtlheapEXT"; +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryFeatureFlagBits value ) + { + switch ( value ) + { + case ExternalMemoryFeatureFlagBits::eDedicatedOnly: return "DedicatedOnly"; + case ExternalMemoryFeatureFlagBits::eExportable : return "Exportable"; + case ExternalMemoryFeatureFlagBits::eImportable : return "Importable"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalFenceHandleTypeFlagBits value ) + { + switch ( value ) + { + case ExternalFenceHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd"; + case ExternalFenceHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32"; + case ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalFenceHandleTypeFlagBits::eSyncFd : return "SyncFd"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalFenceFeatureFlagBits value ) + { + switch ( value ) + { + case ExternalFenceFeatureFlagBits::eExportable: return "Exportable"; + case ExternalFenceFeatureFlagBits::eImportable: return "Importable"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FenceImportFlagBits value ) + { + switch ( value ) + { + case FenceImportFlagBits::eTemporary: return "Temporary"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreImportFlagBits value ) + { + switch ( value ) + { + case SemaphoreImportFlagBits::eTemporary: return "Temporary"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalSemaphoreHandleTypeFlagBits value ) + { + switch ( value ) + { + case ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd"; + case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32"; + case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence : return "D3D12Fence"; + case ExternalSemaphoreHandleTypeFlagBits::eSyncFd : return "SyncFd"; +#if defined( VK_USE_PLATFORM_FUCHSIA ) + case ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA: return "ZirconEventFUCHSIA"; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalSemaphoreFeatureFlagBits value ) + { + switch ( value ) + { + case ExternalSemaphoreFeatureFlagBits::eExportable: return "Exportable"; + case ExternalSemaphoreFeatureFlagBits::eImportable: return "Importable"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubgroupFeatureFlagBits value ) + { + switch ( value ) + { + case SubgroupFeatureFlagBits::eBasic : return "Basic"; + case SubgroupFeatureFlagBits::eVote : return "Vote"; + case SubgroupFeatureFlagBits::eArithmetic : return "Arithmetic"; + case SubgroupFeatureFlagBits::eBallot : return "Ballot"; + case SubgroupFeatureFlagBits::eShuffle : return "Shuffle"; + case SubgroupFeatureFlagBits::eShuffleRelative: return "ShuffleRelative"; + case SubgroupFeatureFlagBits::eClustered : return "Clustered"; + case SubgroupFeatureFlagBits::eQuad : return "Quad"; + case SubgroupFeatureFlagBits::eRotate : return "Rotate"; + case SubgroupFeatureFlagBits::eRotateClustered: return "RotateClustered"; + case SubgroupFeatureFlagBits::ePartitionedEXT : return "PartitionedEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorUpdateTemplateType value ) + { + switch ( value ) + { + case DescriptorUpdateTemplateType::eDescriptorSet : return "DescriptorSet"; + case DescriptorUpdateTemplateType::ePushDescriptors: return "PushDescriptors"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorUpdateTemplateCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerYcbcrModelConversion value ) + { + switch ( value ) + { + case SamplerYcbcrModelConversion::eRgbIdentity : return "RgbIdentity"; + case SamplerYcbcrModelConversion::eYcbcrIdentity: return "YcbcrIdentity"; + case SamplerYcbcrModelConversion::eYcbcr709 : return "Ycbcr709"; + case SamplerYcbcrModelConversion::eYcbcr601 : return "Ycbcr601"; + case SamplerYcbcrModelConversion::eYcbcr2020 : return "Ycbcr2020"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerYcbcrRange value ) + { + switch ( value ) + { + case SamplerYcbcrRange::eItuFull : return "ItuFull"; + case SamplerYcbcrRange::eItuNarrow: return "ItuNarrow"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ChromaLocation value ) + { + switch ( value ) + { + case ChromaLocation::eCositedEven: return "CositedEven"; + case ChromaLocation::eMidpoint : return "Midpoint"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PointClippingBehavior value ) + { + switch ( value ) + { + case PointClippingBehavior::eAllClipPlanes : return "AllClipPlanes"; + case PointClippingBehavior::eUserClipPlanesOnly: return "UserClipPlanesOnly"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TessellationDomainOrigin value ) + { + switch ( value ) + { + case TessellationDomainOrigin::eUpperLeft: return "UpperLeft"; + case TessellationDomainOrigin::eLowerLeft: return "LowerLeft"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_VERSION_1_2 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DriverId value ) + { + switch ( value ) + { + case DriverId::eAmdProprietary : return "AmdProprietary"; + case DriverId::eAmdOpenSource : return "AmdOpenSource"; + case DriverId::eMesaRadv : return "MesaRadv"; + case DriverId::eNvidiaProprietary : return "NvidiaProprietary"; + case DriverId::eIntelProprietaryWindows : return "IntelProprietaryWindows"; + case DriverId::eIntelOpenSourceMESA : return "IntelOpenSourceMESA"; + case DriverId::eImaginationProprietary : return "ImaginationProprietary"; + case DriverId::eQualcommProprietary : return "QualcommProprietary"; + case DriverId::eArmProprietary : return "ArmProprietary"; + case DriverId::eGoogleSwiftshader : return "GoogleSwiftshader"; + case DriverId::eGgpProprietary : return "GgpProprietary"; + case DriverId::eBroadcomProprietary : return "BroadcomProprietary"; + case DriverId::eMesaLlvmpipe : return "MesaLlvmpipe"; + case DriverId::eMoltenvk : return "Moltenvk"; + case DriverId::eCoreaviProprietary : return "CoreaviProprietary"; + case DriverId::eJuiceProprietary : return "JuiceProprietary"; + case DriverId::eVerisiliconProprietary : return "VerisiliconProprietary"; + case DriverId::eMesaTurnip : return "MesaTurnip"; + case DriverId::eMesaV3Dv : return "MesaV3Dv"; + case DriverId::eMesaPanvk : return "MesaPanvk"; + case DriverId::eSamsungProprietary : return "SamsungProprietary"; + case DriverId::eMesaVenus : return "MesaVenus"; + case DriverId::eMesaDozen : return "MesaDozen"; + case DriverId::eMesaNvk : return "MesaNvk"; + case DriverId::eImaginationOpenSourceMESA: return "ImaginationOpenSourceMESA"; + case DriverId::eMesaHoneykrisp : return "MesaHoneykrisp"; + case DriverId::eVulkanScEmulationOnVulkan: return "VulkanScEmulationOnVulkan"; + case DriverId::eMesaKosmickrisp : return "MesaKosmickrisp"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreType value ) + { + switch ( value ) + { + case SemaphoreType::eBinary : return "Binary"; + case SemaphoreType::eTimeline: return "Timeline"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreWaitFlagBits value ) + { + switch ( value ) + { + case SemaphoreWaitFlagBits::eAny: return "Any"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderFloatControlsIndependence value ) + { + switch ( value ) + { + case ShaderFloatControlsIndependence::e32BitOnly: return "32BitOnly"; + case ShaderFloatControlsIndependence::eAll : return "All"; + case ShaderFloatControlsIndependence::eNone : return "None"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorBindingFlagBits value ) + { + switch ( value ) + { + case DescriptorBindingFlagBits::eUpdateAfterBind : return "UpdateAfterBind"; + case DescriptorBindingFlagBits::eUpdateUnusedWhilePending: return "UpdateUnusedWhilePending"; + case DescriptorBindingFlagBits::ePartiallyBound : return "PartiallyBound"; + case DescriptorBindingFlagBits::eVariableDescriptorCount : return "VariableDescriptorCount"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerReductionMode value ) + { + switch ( value ) + { + case SamplerReductionMode::eWeightedAverage : return "WeightedAverage"; + case SamplerReductionMode::eMin : return "Min"; + case SamplerReductionMode::eMax : return "Max"; + case SamplerReductionMode::eWeightedAverageRangeclampQCOM: return "WeightedAverageRangeclampQCOM"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ResolveModeFlagBits value ) + { + switch ( value ) + { + case ResolveModeFlagBits::eNone : return "None"; + case ResolveModeFlagBits::eSampleZero: return "SampleZero"; + case ResolveModeFlagBits::eAverage : return "Average"; + case ResolveModeFlagBits::eMin : return "Min"; + case ResolveModeFlagBits::eMax : return "Max"; +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + case ResolveModeFlagBits::eExternalFormatDownsampleANDROID: return "ExternalFormatDownsampleANDROID"; +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + case ResolveModeFlagBits::eCustomEXT: return "CustomEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_VERSION_1_3 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ToolPurposeFlagBits value ) + { + switch ( value ) + { + case ToolPurposeFlagBits::eValidation : return "Validation"; + case ToolPurposeFlagBits::eProfiling : return "Profiling"; + case ToolPurposeFlagBits::eTracing : return "Tracing"; + case ToolPurposeFlagBits::eAdditionalFeatures: return "AdditionalFeatures"; + case ToolPurposeFlagBits::eModifyingFeatures : return "ModifyingFeatures"; + case ToolPurposeFlagBits::eDebugReportingEXT : return "DebugReportingEXT"; + case ToolPurposeFlagBits::eDebugMarkersEXT : return "DebugMarkersEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlagBits ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineStageFlagBits2 value ) + { + switch ( value ) + { + case PipelineStageFlagBits2::eNone : return "None"; + case PipelineStageFlagBits2::eTopOfPipe : return "TopOfPipe"; + case PipelineStageFlagBits2::eDrawIndirect : return "DrawIndirect"; + case PipelineStageFlagBits2::eVertexInput : return "VertexInput"; + case PipelineStageFlagBits2::eVertexShader : return "VertexShader"; + case PipelineStageFlagBits2::eTessellationControlShader : return "TessellationControlShader"; + case PipelineStageFlagBits2::eTessellationEvaluationShader : return "TessellationEvaluationShader"; + case PipelineStageFlagBits2::eGeometryShader : return "GeometryShader"; + case PipelineStageFlagBits2::eFragmentShader : return "FragmentShader"; + case PipelineStageFlagBits2::eEarlyFragmentTests : return "EarlyFragmentTests"; + case PipelineStageFlagBits2::eLateFragmentTests : return "LateFragmentTests"; + case PipelineStageFlagBits2::eColorAttachmentOutput : return "ColorAttachmentOutput"; + case PipelineStageFlagBits2::eComputeShader : return "ComputeShader"; + case PipelineStageFlagBits2::eAllTransfer : return "AllTransfer"; + case PipelineStageFlagBits2::eBottomOfPipe : return "BottomOfPipe"; + case PipelineStageFlagBits2::eHost : return "Host"; + case PipelineStageFlagBits2::eAllGraphics : return "AllGraphics"; + case PipelineStageFlagBits2::eAllCommands : return "AllCommands"; + case PipelineStageFlagBits2::eCopy : return "Copy"; + case PipelineStageFlagBits2::eResolve : return "Resolve"; + case PipelineStageFlagBits2::eBlit : return "Blit"; + case PipelineStageFlagBits2::eClear : return "Clear"; + case PipelineStageFlagBits2::eIndexInput : return "IndexInput"; + case PipelineStageFlagBits2::eVertexAttributeInput : return "VertexAttributeInput"; + case PipelineStageFlagBits2::ePreRasterizationShaders : return "PreRasterizationShaders"; + case PipelineStageFlagBits2::eVideoDecodeKHR : return "VideoDecodeKHR"; + case PipelineStageFlagBits2::eVideoEncodeKHR : return "VideoEncodeKHR"; + case PipelineStageFlagBits2::eTransformFeedbackEXT : return "TransformFeedbackEXT"; + case PipelineStageFlagBits2::eConditionalRenderingEXT : return "ConditionalRenderingEXT"; + case PipelineStageFlagBits2::eCommandPreprocessEXT : return "CommandPreprocessEXT"; + case PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR: return "FragmentShadingRateAttachmentKHR"; + case PipelineStageFlagBits2::eAccelerationStructureBuildKHR : return "AccelerationStructureBuildKHR"; + case PipelineStageFlagBits2::eRayTracingShaderKHR : return "RayTracingShaderKHR"; + case PipelineStageFlagBits2::eFragmentDensityProcessEXT : return "FragmentDensityProcessEXT"; + case PipelineStageFlagBits2::eTaskShaderEXT : return "TaskShaderEXT"; + case PipelineStageFlagBits2::eMeshShaderEXT : return "MeshShaderEXT"; + case PipelineStageFlagBits2::eSubpassShaderHUAWEI : return "SubpassShaderHUAWEI"; + case PipelineStageFlagBits2::eInvocationMaskHUAWEI : return "InvocationMaskHUAWEI"; + case PipelineStageFlagBits2::eAccelerationStructureCopyKHR : return "AccelerationStructureCopyKHR"; + case PipelineStageFlagBits2::eMicromapBuildEXT : return "MicromapBuildEXT"; + case PipelineStageFlagBits2::eClusterCullingShaderHUAWEI : return "ClusterCullingShaderHUAWEI"; + case PipelineStageFlagBits2::eOpticalFlowNV : return "OpticalFlowNV"; + case PipelineStageFlagBits2::eConvertCooperativeVectorMatrixNV: return "ConvertCooperativeVectorMatrixNV"; + case PipelineStageFlagBits2::eDataGraphARM : return "DataGraphARM"; + case PipelineStageFlagBits2::eCopyIndirectKHR : return "CopyIndirectKHR"; + case PipelineStageFlagBits2::eMemoryDecompressionEXT : return "MemoryDecompressionEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlagBits2 value ) + { + switch ( value ) + { + case AccessFlagBits2::eNone : return "None"; + case AccessFlagBits2::eIndirectCommandRead : return "IndirectCommandRead"; + case AccessFlagBits2::eIndexRead : return "IndexRead"; + case AccessFlagBits2::eVertexAttributeRead : return "VertexAttributeRead"; + case AccessFlagBits2::eUniformRead : return "UniformRead"; + case AccessFlagBits2::eInputAttachmentRead : return "InputAttachmentRead"; + case AccessFlagBits2::eShaderRead : return "ShaderRead"; + case AccessFlagBits2::eShaderWrite : return "ShaderWrite"; + case AccessFlagBits2::eColorAttachmentRead : return "ColorAttachmentRead"; + case AccessFlagBits2::eColorAttachmentWrite : return "ColorAttachmentWrite"; + case AccessFlagBits2::eDepthStencilAttachmentRead : return "DepthStencilAttachmentRead"; + case AccessFlagBits2::eDepthStencilAttachmentWrite : return "DepthStencilAttachmentWrite"; + case AccessFlagBits2::eTransferRead : return "TransferRead"; + case AccessFlagBits2::eTransferWrite : return "TransferWrite"; + case AccessFlagBits2::eHostRead : return "HostRead"; + case AccessFlagBits2::eHostWrite : return "HostWrite"; + case AccessFlagBits2::eMemoryRead : return "MemoryRead"; + case AccessFlagBits2::eMemoryWrite : return "MemoryWrite"; + case AccessFlagBits2::eShaderSampledRead : return "ShaderSampledRead"; + case AccessFlagBits2::eShaderStorageRead : return "ShaderStorageRead"; + case AccessFlagBits2::eShaderStorageWrite : return "ShaderStorageWrite"; + case AccessFlagBits2::eVideoDecodeReadKHR : return "VideoDecodeReadKHR"; + case AccessFlagBits2::eVideoDecodeWriteKHR : return "VideoDecodeWriteKHR"; + case AccessFlagBits2::eSamplerHeapReadEXT : return "SamplerHeapReadEXT"; + case AccessFlagBits2::eResourceHeapReadEXT : return "ResourceHeapReadEXT"; + case AccessFlagBits2::eVideoEncodeReadKHR : return "VideoEncodeReadKHR"; + case AccessFlagBits2::eVideoEncodeWriteKHR : return "VideoEncodeWriteKHR"; + case AccessFlagBits2::eShaderTileAttachmentReadQCOM : return "ShaderTileAttachmentReadQCOM"; + case AccessFlagBits2::eShaderTileAttachmentWriteQCOM : return "ShaderTileAttachmentWriteQCOM"; + case AccessFlagBits2::eTransformFeedbackWriteEXT : return "TransformFeedbackWriteEXT"; + case AccessFlagBits2::eTransformFeedbackCounterReadEXT : return "TransformFeedbackCounterReadEXT"; + case AccessFlagBits2::eTransformFeedbackCounterWriteEXT : return "TransformFeedbackCounterWriteEXT"; + case AccessFlagBits2::eConditionalRenderingReadEXT : return "ConditionalRenderingReadEXT"; + case AccessFlagBits2::eCommandPreprocessReadEXT : return "CommandPreprocessReadEXT"; + case AccessFlagBits2::eCommandPreprocessWriteEXT : return "CommandPreprocessWriteEXT"; + case AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR: return "FragmentShadingRateAttachmentReadKHR"; + case AccessFlagBits2::eAccelerationStructureReadKHR : return "AccelerationStructureReadKHR"; + case AccessFlagBits2::eAccelerationStructureWriteKHR : return "AccelerationStructureWriteKHR"; + case AccessFlagBits2::eFragmentDensityMapReadEXT : return "FragmentDensityMapReadEXT"; + case AccessFlagBits2::eColorAttachmentReadNoncoherentEXT : return "ColorAttachmentReadNoncoherentEXT"; + case AccessFlagBits2::eDescriptorBufferReadEXT : return "DescriptorBufferReadEXT"; + case AccessFlagBits2::eInvocationMaskReadHUAWEI : return "InvocationMaskReadHUAWEI"; + case AccessFlagBits2::eShaderBindingTableReadKHR : return "ShaderBindingTableReadKHR"; + case AccessFlagBits2::eMicromapReadEXT : return "MicromapReadEXT"; + case AccessFlagBits2::eMicromapWriteEXT : return "MicromapWriteEXT"; + case AccessFlagBits2::eOpticalFlowReadNV : return "OpticalFlowReadNV"; + case AccessFlagBits2::eOpticalFlowWriteNV : return "OpticalFlowWriteNV"; + case AccessFlagBits2::eDataGraphReadARM : return "DataGraphReadARM"; + case AccessFlagBits2::eDataGraphWriteARM : return "DataGraphWriteARM"; + case AccessFlagBits2::eMemoryDecompressionReadEXT : return "MemoryDecompressionReadEXT"; + case AccessFlagBits2::eMemoryDecompressionWriteEXT : return "MemoryDecompressionWriteEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubmitFlagBits value ) + { + switch ( value ) + { + case SubmitFlagBits::eProtected: return "Protected"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FormatFeatureFlagBits2 value ) + { + switch ( value ) + { + case FormatFeatureFlagBits2::eSampledImage : return "SampledImage"; + case FormatFeatureFlagBits2::eStorageImage : return "StorageImage"; + case FormatFeatureFlagBits2::eStorageImageAtomic : return "StorageImageAtomic"; + case FormatFeatureFlagBits2::eUniformTexelBuffer : return "UniformTexelBuffer"; + case FormatFeatureFlagBits2::eStorageTexelBuffer : return "StorageTexelBuffer"; + case FormatFeatureFlagBits2::eStorageTexelBufferAtomic : return "StorageTexelBufferAtomic"; + case FormatFeatureFlagBits2::eVertexBuffer : return "VertexBuffer"; + case FormatFeatureFlagBits2::eColorAttachment : return "ColorAttachment"; + case FormatFeatureFlagBits2::eColorAttachmentBlend : return "ColorAttachmentBlend"; + case FormatFeatureFlagBits2::eDepthStencilAttachment : return "DepthStencilAttachment"; + case FormatFeatureFlagBits2::eBlitSrc : return "BlitSrc"; + case FormatFeatureFlagBits2::eBlitDst : return "BlitDst"; + case FormatFeatureFlagBits2::eSampledImageFilterLinear : return "SampledImageFilterLinear"; + case FormatFeatureFlagBits2::eTransferSrc : return "TransferSrc"; + case FormatFeatureFlagBits2::eTransferDst : return "TransferDst"; + case FormatFeatureFlagBits2::eSampledImageFilterMinmax : return "SampledImageFilterMinmax"; + case FormatFeatureFlagBits2::eMidpointChromaSamples : return "MidpointChromaSamples"; + case FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter : return "SampledImageYcbcrConversionLinearFilter"; + case FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter: return "SampledImageYcbcrConversionSeparateReconstructionFilter"; + case FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit: return "SampledImageYcbcrConversionChromaReconstructionExplicit"; + case FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable: + return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable"; + case FormatFeatureFlagBits2::eDisjoint : return "Disjoint"; + case FormatFeatureFlagBits2::eCositedChromaSamples : return "CositedChromaSamples"; + case FormatFeatureFlagBits2::eStorageReadWithoutFormat : return "StorageReadWithoutFormat"; + case FormatFeatureFlagBits2::eStorageWriteWithoutFormat : return "StorageWriteWithoutFormat"; + case FormatFeatureFlagBits2::eSampledImageDepthComparison : return "SampledImageDepthComparison"; + case FormatFeatureFlagBits2::eSampledImageFilterCubic : return "SampledImageFilterCubic"; + case FormatFeatureFlagBits2::eHostImageTransfer : return "HostImageTransfer"; + case FormatFeatureFlagBits2::eVideoDecodeOutputKHR : return "VideoDecodeOutputKHR"; + case FormatFeatureFlagBits2::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR"; + case FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR: return "AccelerationStructureVertexBufferKHR"; + case FormatFeatureFlagBits2::eFragmentDensityMapEXT : return "FragmentDensityMapEXT"; + case FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR"; + case FormatFeatureFlagBits2::eVideoEncodeInputKHR : return "VideoEncodeInputKHR"; + case FormatFeatureFlagBits2::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR"; + case FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV : return "AccelerationStructureRadiusBufferNV"; + case FormatFeatureFlagBits2::eLinearColorAttachmentNV : return "LinearColorAttachmentNV"; + case FormatFeatureFlagBits2::eWeightImageQCOM : return "WeightImageQCOM"; + case FormatFeatureFlagBits2::eWeightSampledImageQCOM : return "WeightSampledImageQCOM"; + case FormatFeatureFlagBits2::eBlockMatchingQCOM : return "BlockMatchingQCOM"; + case FormatFeatureFlagBits2::eBoxFilterSampledQCOM : return "BoxFilterSampledQCOM"; + case FormatFeatureFlagBits2::eTensorShaderARM : return "TensorShaderARM"; + case FormatFeatureFlagBits2::eTensorImageAliasingARM : return "TensorImageAliasingARM"; + case FormatFeatureFlagBits2::eOpticalFlowImageNV : return "OpticalFlowImageNV"; + case FormatFeatureFlagBits2::eOpticalFlowVectorNV : return "OpticalFlowVectorNV"; + case FormatFeatureFlagBits2::eOpticalFlowCostNV : return "OpticalFlowCostNV"; + case FormatFeatureFlagBits2::eTensorDataGraphARM : return "TensorDataGraphARM"; + case FormatFeatureFlagBits2::eCopyImageIndirectDstKHR : return "CopyImageIndirectDstKHR"; + case FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR : return "VideoEncodeQuantizationDeltaMapKHR"; + case FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR : return "VideoEncodeEmphasisMapKHR"; + case FormatFeatureFlagBits2::eDepthCopyOnComputeQueueKHR : return "DepthCopyOnComputeQueueKHR"; + case FormatFeatureFlagBits2::eDepthCopyOnTransferQueueKHR : return "DepthCopyOnTransferQueueKHR"; + case FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR : return "StencilCopyOnComputeQueueKHR"; + case FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR : return "StencilCopyOnTransferQueueKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCreationFeedbackFlagBits value ) + { + switch ( value ) + { + case PipelineCreationFeedbackFlagBits::eValid : return "Valid"; + case PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit: return "ApplicationPipelineCacheHit"; + case PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration : return "BasePipelineAcceleration"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderingFlagBits value ) + { + switch ( value ) + { + case RenderingFlagBits::eContentsSecondaryCommandBuffers : return "ContentsSecondaryCommandBuffers"; + case RenderingFlagBits::eSuspending : return "Suspending"; + case RenderingFlagBits::eResuming : return "Resuming"; + case RenderingFlagBits::eEnableLegacyDitheringEXT : return "EnableLegacyDitheringEXT"; + case RenderingFlagBits::eContentsInlineKHR : return "ContentsInlineKHR"; + case RenderingFlagBits::ePerLayerFragmentDensityVALVE : return "PerLayerFragmentDensityVALVE"; + case RenderingFlagBits::eFragmentRegionEXT : return "FragmentRegionEXT"; + case RenderingFlagBits::eCustomResolveEXT : return "CustomResolveEXT"; + case RenderingFlagBits::eLocalReadConcurrentAccessControlKHR: return "LocalReadConcurrentAccessControlKHR"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_VERSION_1_4 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueueGlobalPriority value ) + { + switch ( value ) + { + case QueueGlobalPriority::eLow : return "Low"; + case QueueGlobalPriority::eMedium : return "Medium"; + case QueueGlobalPriority::eHigh : return "High"; + case QueueGlobalPriority::eRealtime: return "Realtime"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryUnmapFlagBits value ) + { + switch ( value ) + { + case MemoryUnmapFlagBits::eReserveEXT: return "ReserveEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferUsageFlagBits2 value ) + { + switch ( value ) + { + case BufferUsageFlagBits2::eTransferSrc : return "TransferSrc"; + case BufferUsageFlagBits2::eTransferDst : return "TransferDst"; + case BufferUsageFlagBits2::eUniformTexelBuffer : return "UniformTexelBuffer"; + case BufferUsageFlagBits2::eStorageTexelBuffer : return "StorageTexelBuffer"; + case BufferUsageFlagBits2::eUniformBuffer : return "UniformBuffer"; + case BufferUsageFlagBits2::eStorageBuffer : return "StorageBuffer"; + case BufferUsageFlagBits2::eIndexBuffer : return "IndexBuffer"; + case BufferUsageFlagBits2::eVertexBuffer : return "VertexBuffer"; + case BufferUsageFlagBits2::eIndirectBuffer : return "IndirectBuffer"; + case BufferUsageFlagBits2::eShaderDeviceAddress: return "ShaderDeviceAddress"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case BufferUsageFlagBits2::eExecutionGraphScratchAMDX: return "ExecutionGraphScratchAMDX"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case BufferUsageFlagBits2::eDescriptorHeapEXT : return "DescriptorHeapEXT"; + case BufferUsageFlagBits2::eConditionalRenderingEXT : return "ConditionalRenderingEXT"; + case BufferUsageFlagBits2::eShaderBindingTableKHR : return "ShaderBindingTableKHR"; + case BufferUsageFlagBits2::eTransformFeedbackBufferEXT : return "TransformFeedbackBufferEXT"; + case BufferUsageFlagBits2::eTransformFeedbackCounterBufferEXT : return "TransformFeedbackCounterBufferEXT"; + case BufferUsageFlagBits2::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR"; + case BufferUsageFlagBits2::eVideoDecodeDstKHR : return "VideoDecodeDstKHR"; + case BufferUsageFlagBits2::eVideoEncodeDstKHR : return "VideoEncodeDstKHR"; + case BufferUsageFlagBits2::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR"; + case BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR: return "AccelerationStructureBuildInputReadOnlyKHR"; + case BufferUsageFlagBits2::eAccelerationStructureStorageKHR : return "AccelerationStructureStorageKHR"; + case BufferUsageFlagBits2::eSamplerDescriptorBufferEXT : return "SamplerDescriptorBufferEXT"; + case BufferUsageFlagBits2::eResourceDescriptorBufferEXT : return "ResourceDescriptorBufferEXT"; + case BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT : return "PushDescriptorsDescriptorBufferEXT"; + case BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT : return "MicromapBuildInputReadOnlyEXT"; + case BufferUsageFlagBits2::eMicromapStorageEXT : return "MicromapStorageEXT"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case BufferUsageFlagBits2::eCompressedDataDgf1AMDX: return "CompressedDataDgf1AMDX"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case BufferUsageFlagBits2::eDataGraphForeignDescriptorARM: return "DataGraphForeignDescriptorARM"; + case BufferUsageFlagBits2::eTileMemoryQCOM : return "TileMemoryQCOM"; + case BufferUsageFlagBits2::eMemoryDecompressionEXT : return "MemoryDecompressionEXT"; + case BufferUsageFlagBits2::ePreprocessBufferEXT : return "PreprocessBufferEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( HostImageCopyFlagBits value ) + { + switch ( value ) + { + case HostImageCopyFlagBits::eMemcpy: return "Memcpy"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCreateFlagBits2 value ) + { + switch ( value ) + { + case PipelineCreateFlagBits2::eDisableOptimization : return "DisableOptimization"; + case PipelineCreateFlagBits2::eAllowDerivatives : return "AllowDerivatives"; + case PipelineCreateFlagBits2::eDerivative : return "Derivative"; + case PipelineCreateFlagBits2::eViewIndexFromDeviceIndex : return "ViewIndexFromDeviceIndex"; + case PipelineCreateFlagBits2::eDispatchBase : return "DispatchBase"; + case PipelineCreateFlagBits2::eFailOnPipelineCompileRequired: return "FailOnPipelineCompileRequired"; + case PipelineCreateFlagBits2::eEarlyReturnOnFailure : return "EarlyReturnOnFailure"; + case PipelineCreateFlagBits2::eNoProtectedAccess : return "NoProtectedAccess"; + case PipelineCreateFlagBits2::eProtectedAccessOnly : return "ProtectedAccessOnly"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case PipelineCreateFlagBits2::eExecutionGraphAMDX: return "ExecutionGraphAMDX"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case PipelineCreateFlagBits2::eDescriptorHeapEXT : return "DescriptorHeapEXT"; + case PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV: return "RayTracingAllowSpheresAndLinearSweptSpheresNV"; + case PipelineCreateFlagBits2::eEnableLegacyDitheringEXT : return "EnableLegacyDitheringEXT"; + case PipelineCreateFlagBits2::eDeferCompileNV : return "DeferCompileNV"; + case PipelineCreateFlagBits2::eCaptureStatisticsKHR : return "CaptureStatisticsKHR"; + case PipelineCreateFlagBits2::eCaptureInternalRepresentationsKHR : return "CaptureInternalRepresentationsKHR"; + case PipelineCreateFlagBits2::eLinkTimeOptimizationEXT : return "LinkTimeOptimizationEXT"; + case PipelineCreateFlagBits2::eRetainLinkTimeOptimizationInfoEXT : return "RetainLinkTimeOptimizationInfoEXT"; + case PipelineCreateFlagBits2::eLibraryKHR : return "LibraryKHR"; + case PipelineCreateFlagBits2::eRayTracingSkipTrianglesKHR : return "RayTracingSkipTrianglesKHR"; + case PipelineCreateFlagBits2::eRayTracingSkipAabbsKHR : return "RayTracingSkipAabbsKHR"; + case PipelineCreateFlagBits2::eRayTracingNoNullAnyHitShadersKHR : return "RayTracingNoNullAnyHitShadersKHR"; + case PipelineCreateFlagBits2::eRayTracingNoNullClosestHitShadersKHR : return "RayTracingNoNullClosestHitShadersKHR"; + case PipelineCreateFlagBits2::eRayTracingNoNullMissShadersKHR : return "RayTracingNoNullMissShadersKHR"; + case PipelineCreateFlagBits2::eRayTracingNoNullIntersectionShadersKHR : return "RayTracingNoNullIntersectionShadersKHR"; + case PipelineCreateFlagBits2::eRayTracingShaderGroupHandleCaptureReplayKHR : return "RayTracingShaderGroupHandleCaptureReplayKHR"; + case PipelineCreateFlagBits2::eIndirectBindableNV : return "IndirectBindableNV"; + case PipelineCreateFlagBits2::eRayTracingAllowMotionNV : return "RayTracingAllowMotionNV"; + case PipelineCreateFlagBits2::eRenderingFragmentShadingRateAttachmentKHR : return "RenderingFragmentShadingRateAttachmentKHR"; + case PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT : return "RenderingFragmentDensityMapAttachmentEXT"; + case PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT : return "RayTracingOpacityMicromapEXT"; + case PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT : return "ColorAttachmentFeedbackLoopEXT"; + case PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT : return "DepthStencilAttachmentFeedbackLoopEXT"; + case PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV : return "RayTracingDisplacementMicromapNV"; + case PipelineCreateFlagBits2::eDescriptorBufferEXT : return "DescriptorBufferEXT"; + case PipelineCreateFlagBits2::eDisallowOpacityMicromapARM : return "DisallowOpacityMicromapARM"; + case PipelineCreateFlagBits2::eCaptureDataKHR : return "CaptureDataKHR"; + case PipelineCreateFlagBits2::eIndirectBindableEXT : return "IndirectBindableEXT"; + case PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE : return "PerLayerFragmentDensityVALVE"; + case PipelineCreateFlagBits2::e64BitIndexingEXT : return "64BitIndexingEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRobustnessBufferBehavior value ) + { + switch ( value ) + { + case PipelineRobustnessBufferBehavior::eDeviceDefault : return "DeviceDefault"; + case PipelineRobustnessBufferBehavior::eDisabled : return "Disabled"; + case PipelineRobustnessBufferBehavior::eRobustBufferAccess : return "RobustBufferAccess"; + case PipelineRobustnessBufferBehavior::eRobustBufferAccess2: return "RobustBufferAccess2"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRobustnessImageBehavior value ) + { + switch ( value ) + { + case PipelineRobustnessImageBehavior::eDeviceDefault : return "DeviceDefault"; + case PipelineRobustnessImageBehavior::eDisabled : return "Disabled"; + case PipelineRobustnessImageBehavior::eRobustImageAccess : return "RobustImageAccess"; + case PipelineRobustnessImageBehavior::eRobustImageAccess2: return "RobustImageAccess2"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LineRasterizationMode value ) + { + switch ( value ) + { + case LineRasterizationMode::eDefault : return "Default"; + case LineRasterizationMode::eRectangular : return "Rectangular"; + case LineRasterizationMode::eBresenham : return "Bresenham"; + case LineRasterizationMode::eRectangularSmooth: return "RectangularSmooth"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceTransformFlagBitsKHR value ) + { + switch ( value ) + { + case SurfaceTransformFlagBitsKHR::eIdentity : return "Identity"; + case SurfaceTransformFlagBitsKHR::eRotate90 : return "Rotate90"; + case SurfaceTransformFlagBitsKHR::eRotate180 : return "Rotate180"; + case SurfaceTransformFlagBitsKHR::eRotate270 : return "Rotate270"; + case SurfaceTransformFlagBitsKHR::eHorizontalMirror : return "HorizontalMirror"; + case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 : return "HorizontalMirrorRotate90"; + case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180: return "HorizontalMirrorRotate180"; + case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270: return "HorizontalMirrorRotate270"; + case SurfaceTransformFlagBitsKHR::eInherit : return "Inherit"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentModeKHR value ) + { + switch ( value ) + { + case PresentModeKHR::eImmediate : return "Immediate"; + case PresentModeKHR::eMailbox : return "Mailbox"; + case PresentModeKHR::eFifo : return "Fifo"; + case PresentModeKHR::eFifoRelaxed : return "FifoRelaxed"; + case PresentModeKHR::eSharedDemandRefresh : return "SharedDemandRefresh"; + case PresentModeKHR::eSharedContinuousRefresh: return "SharedContinuousRefresh"; + case PresentModeKHR::eFifoLatestReady : return "FifoLatestReady"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ColorSpaceKHR value ) + { + switch ( value ) + { + case ColorSpaceKHR::eSrgbNonlinear : return "SrgbNonlinear"; + case ColorSpaceKHR::eDisplayP3NonlinearEXT : return "DisplayP3NonlinearEXT"; + case ColorSpaceKHR::eExtendedSrgbLinearEXT : return "ExtendedSrgbLinearEXT"; + case ColorSpaceKHR::eDisplayP3LinearEXT : return "DisplayP3LinearEXT"; + case ColorSpaceKHR::eDciP3NonlinearEXT : return "DciP3NonlinearEXT"; + case ColorSpaceKHR::eBt709LinearEXT : return "Bt709LinearEXT"; + case ColorSpaceKHR::eBt709NonlinearEXT : return "Bt709NonlinearEXT"; + case ColorSpaceKHR::eBt2020LinearEXT : return "Bt2020LinearEXT"; + case ColorSpaceKHR::eHdr10St2084EXT : return "Hdr10St2084EXT"; + case ColorSpaceKHR::eDolbyvisionEXT : return "DolbyvisionEXT"; + case ColorSpaceKHR::eHdr10HlgEXT : return "Hdr10HlgEXT"; + case ColorSpaceKHR::eAdobergbLinearEXT : return "AdobergbLinearEXT"; + case ColorSpaceKHR::eAdobergbNonlinearEXT : return "AdobergbNonlinearEXT"; + case ColorSpaceKHR::ePassThroughEXT : return "PassThroughEXT"; + case ColorSpaceKHR::eExtendedSrgbNonlinearEXT: return "ExtendedSrgbNonlinearEXT"; + case ColorSpaceKHR::eDisplayNativeAMD : return "DisplayNativeAMD"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CompositeAlphaFlagBitsKHR value ) + { + switch ( value ) + { + case CompositeAlphaFlagBitsKHR::eOpaque : return "Opaque"; + case CompositeAlphaFlagBitsKHR::ePreMultiplied : return "PreMultiplied"; + case CompositeAlphaFlagBitsKHR::ePostMultiplied: return "PostMultiplied"; + case CompositeAlphaFlagBitsKHR::eInherit : return "Inherit"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_swapchain === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SwapchainCreateFlagBitsKHR value ) + { + switch ( value ) + { + case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions: return "SplitInstanceBindRegions"; + case SwapchainCreateFlagBitsKHR::eProtected : return "Protected"; + case SwapchainCreateFlagBitsKHR::eMutableFormat : return "MutableFormat"; + case SwapchainCreateFlagBitsKHR::ePresentTimingEXT : return "PresentTimingEXT"; + case SwapchainCreateFlagBitsKHR::ePresentId2 : return "PresentId2"; + case SwapchainCreateFlagBitsKHR::ePresentWait2 : return "PresentWait2"; + case SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocation: return "DeferredMemoryAllocation"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceGroupPresentModeFlagBitsKHR value ) + { + switch ( value ) + { + case DeviceGroupPresentModeFlagBitsKHR::eLocal : return "Local"; + case DeviceGroupPresentModeFlagBitsKHR::eRemote : return "Remote"; + case DeviceGroupPresentModeFlagBitsKHR::eSum : return "Sum"; + case DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice: return "LocalMultiDevice"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_display === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayPlaneAlphaFlagBitsKHR value ) + { + switch ( value ) + { + case DisplayPlaneAlphaFlagBitsKHR::eOpaque : return "Opaque"; + case DisplayPlaneAlphaFlagBitsKHR::eGlobal : return "Global"; + case DisplayPlaneAlphaFlagBitsKHR::ePerPixel : return "PerPixel"; + case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied: return "PerPixelPremultiplied"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayModeCreateFlagBitsKHR ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplaySurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } + +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + //=== VK_KHR_xlib_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XlibSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ + +#if defined( VK_USE_PLATFORM_XCB_KHR ) + //=== VK_KHR_xcb_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XcbSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_XCB_KHR*/ + +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + //=== VK_KHR_wayland_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( WaylandSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ + +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + //=== VK_KHR_android_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AndroidSurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_KHR_win32_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Win32SurfaceCreateFlagBitsKHR ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_debug_report === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugReportFlagBitsEXT value ) + { + switch ( value ) + { + case DebugReportFlagBitsEXT::eInformation : return "Information"; + case DebugReportFlagBitsEXT::eWarning : return "Warning"; + case DebugReportFlagBitsEXT::ePerformanceWarning: return "PerformanceWarning"; + case DebugReportFlagBitsEXT::eError : return "Error"; + case DebugReportFlagBitsEXT::eDebug : return "Debug"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugReportObjectTypeEXT value ) + { + switch ( value ) + { + case DebugReportObjectTypeEXT::eUnknown : return "Unknown"; + case DebugReportObjectTypeEXT::eInstance : return "Instance"; + case DebugReportObjectTypeEXT::ePhysicalDevice : return "PhysicalDevice"; + case DebugReportObjectTypeEXT::eDevice : return "Device"; + case DebugReportObjectTypeEXT::eQueue : return "Queue"; + case DebugReportObjectTypeEXT::eSemaphore : return "Semaphore"; + case DebugReportObjectTypeEXT::eCommandBuffer : return "CommandBuffer"; + case DebugReportObjectTypeEXT::eFence : return "Fence"; + case DebugReportObjectTypeEXT::eDeviceMemory : return "DeviceMemory"; + case DebugReportObjectTypeEXT::eBuffer : return "Buffer"; + case DebugReportObjectTypeEXT::eImage : return "Image"; + case DebugReportObjectTypeEXT::eEvent : return "Event"; + case DebugReportObjectTypeEXT::eQueryPool : return "QueryPool"; + case DebugReportObjectTypeEXT::eBufferView : return "BufferView"; + case DebugReportObjectTypeEXT::eImageView : return "ImageView"; + case DebugReportObjectTypeEXT::eShaderModule : return "ShaderModule"; + case DebugReportObjectTypeEXT::ePipelineCache : return "PipelineCache"; + case DebugReportObjectTypeEXT::ePipelineLayout : return "PipelineLayout"; + case DebugReportObjectTypeEXT::eRenderPass : return "RenderPass"; + case DebugReportObjectTypeEXT::ePipeline : return "Pipeline"; + case DebugReportObjectTypeEXT::eDescriptorSetLayout : return "DescriptorSetLayout"; + case DebugReportObjectTypeEXT::eSampler : return "Sampler"; + case DebugReportObjectTypeEXT::eDescriptorPool : return "DescriptorPool"; + case DebugReportObjectTypeEXT::eDescriptorSet : return "DescriptorSet"; + case DebugReportObjectTypeEXT::eFramebuffer : return "Framebuffer"; + case DebugReportObjectTypeEXT::eCommandPool : return "CommandPool"; + case DebugReportObjectTypeEXT::eSurfaceKHR : return "SurfaceKHR"; + case DebugReportObjectTypeEXT::eSwapchainKHR : return "SwapchainKHR"; + case DebugReportObjectTypeEXT::eDebugReportCallbackEXT : return "DebugReportCallbackEXT"; + case DebugReportObjectTypeEXT::eDisplayKHR : return "DisplayKHR"; + case DebugReportObjectTypeEXT::eDisplayModeKHR : return "DisplayModeKHR"; + case DebugReportObjectTypeEXT::eValidationCacheEXT : return "ValidationCacheEXT"; + case DebugReportObjectTypeEXT::eSamplerYcbcrConversion : return "SamplerYcbcrConversion"; + case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate"; + case DebugReportObjectTypeEXT::eCuModuleNVX : return "CuModuleNVX"; + case DebugReportObjectTypeEXT::eCuFunctionNVX : return "CuFunctionNVX"; + case DebugReportObjectTypeEXT::eAccelerationStructureKHR: return "AccelerationStructureKHR"; + case DebugReportObjectTypeEXT::eAccelerationStructureNV : return "AccelerationStructureNV"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case DebugReportObjectTypeEXT::eCudaModuleNV : return "CudaModuleNV"; + case DebugReportObjectTypeEXT::eCudaFunctionNV: return "CudaFunctionNV"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ +#if defined( VK_USE_PLATFORM_FUCHSIA ) + case DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA: return "BufferCollectionFUCHSIA"; +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_AMD_rasterization_order === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RasterizationOrderAMD value ) + { + switch ( value ) + { + case RasterizationOrderAMD::eStrict : return "Strict"; + case RasterizationOrderAMD::eRelaxed: return "Relaxed"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_video_queue === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoCodecOperationFlagBitsKHR value ) + { + switch ( value ) + { + case VideoCodecOperationFlagBitsKHR::eNone : return "None"; + case VideoCodecOperationFlagBitsKHR::eEncodeH264: return "EncodeH264"; + case VideoCodecOperationFlagBitsKHR::eEncodeH265: return "EncodeH265"; + case VideoCodecOperationFlagBitsKHR::eDecodeH264: return "DecodeH264"; + case VideoCodecOperationFlagBitsKHR::eDecodeH265: return "DecodeH265"; + case VideoCodecOperationFlagBitsKHR::eDecodeAv1 : return "DecodeAv1"; + case VideoCodecOperationFlagBitsKHR::eEncodeAv1 : return "EncodeAv1"; + case VideoCodecOperationFlagBitsKHR::eDecodeVp9 : return "DecodeVp9"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoChromaSubsamplingFlagBitsKHR value ) + { + switch ( value ) + { + case VideoChromaSubsamplingFlagBitsKHR::eInvalid : return "Invalid"; + case VideoChromaSubsamplingFlagBitsKHR::eMonochrome: return "Monochrome"; + case VideoChromaSubsamplingFlagBitsKHR::e420 : return "420"; + case VideoChromaSubsamplingFlagBitsKHR::e422 : return "422"; + case VideoChromaSubsamplingFlagBitsKHR::e444 : return "444"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoComponentBitDepthFlagBitsKHR value ) + { + switch ( value ) + { + case VideoComponentBitDepthFlagBitsKHR::eInvalid: return "Invalid"; + case VideoComponentBitDepthFlagBitsKHR::e8 : return "8"; + case VideoComponentBitDepthFlagBitsKHR::e10 : return "10"; + case VideoComponentBitDepthFlagBitsKHR::e12 : return "12"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoCapabilityFlagBitsKHR value ) + { + switch ( value ) + { + case VideoCapabilityFlagBitsKHR::eProtectedContent : return "ProtectedContent"; + case VideoCapabilityFlagBitsKHR::eSeparateReferenceImages: return "SeparateReferenceImages"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoSessionCreateFlagBitsKHR value ) + { + switch ( value ) + { + case VideoSessionCreateFlagBitsKHR::eProtectedContent : return "ProtectedContent"; + case VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations: return "AllowEncodeParameterOptimizations"; + case VideoSessionCreateFlagBitsKHR::eInlineQueries : return "InlineQueries"; + case VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap : return "AllowEncodeQuantizationDeltaMap"; + case VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap : return "AllowEncodeEmphasisMap"; + case VideoSessionCreateFlagBitsKHR::eInlineSessionParameters : return "InlineSessionParameters"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoCodingControlFlagBitsKHR value ) + { + switch ( value ) + { + case VideoCodingControlFlagBitsKHR::eReset : return "Reset"; + case VideoCodingControlFlagBitsKHR::eEncodeRateControl : return "EncodeRateControl"; + case VideoCodingControlFlagBitsKHR::eEncodeQualityLevel: return "EncodeQualityLevel"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryResultStatusKHR value ) + { + switch ( value ) + { + case QueryResultStatusKHR::eError : return "Error"; + case QueryResultStatusKHR::eNotReady : return "NotReady"; + case QueryResultStatusKHR::eComplete : return "Complete"; + case QueryResultStatusKHR::eInsufficientBitstreamBufferRange: return "InsufficientBitstreamBufferRange"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoSessionParametersCreateFlagBitsKHR value ) + { + switch ( value ) + { + case VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible: return "QuantizationMapCompatible"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoBeginCodingFlagBitsKHR ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEndCodingFlagBitsKHR ) + { + return "(void)"; + } + + //=== VK_KHR_video_decode_queue === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeCapabilityFlagBitsKHR value ) + { + switch ( value ) + { + case VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide: return "DpbAndOutputCoincide"; + case VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct: return "DpbAndOutputDistinct"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeUsageFlagBitsKHR value ) + { + switch ( value ) + { + case VideoDecodeUsageFlagBitsKHR::eDefault : return "Default"; + case VideoDecodeUsageFlagBitsKHR::eTranscoding: return "Transcoding"; + case VideoDecodeUsageFlagBitsKHR::eOffline : return "Offline"; + case VideoDecodeUsageFlagBitsKHR::eStreaming : return "Streaming"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeFlagBitsKHR ) + { + return "(void)"; + } + + //=== VK_EXT_transform_feedback === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateStreamCreateFlagBitsEXT ) + { + return "(void)"; + } + + //=== VK_KHR_video_encode_h264 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH264CapabilityFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeH264CapabilityFlagBitsKHR::eHrdCompliance : return "HrdCompliance"; + case VideoEncodeH264CapabilityFlagBitsKHR::ePredictionWeightTableGenerated: return "PredictionWeightTableGenerated"; + case VideoEncodeH264CapabilityFlagBitsKHR::eRowUnalignedSlice : return "RowUnalignedSlice"; + case VideoEncodeH264CapabilityFlagBitsKHR::eDifferentSliceType : return "DifferentSliceType"; + case VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL0List : return "BFrameInL0List"; + case VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL1List : return "BFrameInL1List"; + case VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp : return "PerPictureTypeMinMaxQp"; + case VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp : return "PerSliceConstantQp"; + case VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu : return "GeneratePrefixNalu"; + case VideoEncodeH264CapabilityFlagBitsKHR::eBPictureIntraRefresh : return "BPictureIntraRefresh"; + case VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound : return "MbQpDiffWraparound"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH264StdFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeH264StdFlagBitsKHR::eSeparateColorPlaneFlagSet : return "SeparateColorPlaneFlagSet"; + case VideoEncodeH264StdFlagBitsKHR::eQpprimeYZeroTransformBypassFlagSet: return "QpprimeYZeroTransformBypassFlagSet"; + case VideoEncodeH264StdFlagBitsKHR::eScalingMatrixPresentFlagSet : return "ScalingMatrixPresentFlagSet"; + case VideoEncodeH264StdFlagBitsKHR::eChromaQpIndexOffset : return "ChromaQpIndexOffset"; + case VideoEncodeH264StdFlagBitsKHR::eSecondChromaQpIndexOffset : return "SecondChromaQpIndexOffset"; + case VideoEncodeH264StdFlagBitsKHR::ePicInitQpMinus26 : return "PicInitQpMinus26"; + case VideoEncodeH264StdFlagBitsKHR::eWeightedPredFlagSet : return "WeightedPredFlagSet"; + case VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcExplicit : return "WeightedBipredIdcExplicit"; + case VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcImplicit : return "WeightedBipredIdcImplicit"; + case VideoEncodeH264StdFlagBitsKHR::eTransform8X8ModeFlagSet : return "Transform8X8ModeFlagSet"; + case VideoEncodeH264StdFlagBitsKHR::eDirectSpatialMvPredFlagUnset : return "DirectSpatialMvPredFlagUnset"; + case VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagUnset : return "EntropyCodingModeFlagUnset"; + case VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagSet : return "EntropyCodingModeFlagSet"; + case VideoEncodeH264StdFlagBitsKHR::eDirect8X8InferenceFlagUnset : return "Direct8X8InferenceFlagUnset"; + case VideoEncodeH264StdFlagBitsKHR::eConstrainedIntraPredFlagSet : return "ConstrainedIntraPredFlagSet"; + case VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterDisabled : return "DeblockingFilterDisabled"; + case VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterEnabled : return "DeblockingFilterEnabled"; + case VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterPartial : return "DeblockingFilterPartial"; + case VideoEncodeH264StdFlagBitsKHR::eSliceQpDelta : return "SliceQpDelta"; + case VideoEncodeH264StdFlagBitsKHR::eDifferentSliceQpDelta : return "DifferentSliceQpDelta"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH264RateControlFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeH264RateControlFlagBitsKHR::eAttemptHrdCompliance : return "AttemptHrdCompliance"; + case VideoEncodeH264RateControlFlagBitsKHR::eRegularGop : return "RegularGop"; + case VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternFlat : return "ReferencePatternFlat"; + case VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternDyadic : return "ReferencePatternDyadic"; + case VideoEncodeH264RateControlFlagBitsKHR::eTemporalLayerPatternDyadic: return "TemporalLayerPatternDyadic"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_video_encode_h265 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265CapabilityFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeH265CapabilityFlagBitsKHR::eHrdCompliance : return "HrdCompliance"; + case VideoEncodeH265CapabilityFlagBitsKHR::ePredictionWeightTableGenerated: return "PredictionWeightTableGenerated"; + case VideoEncodeH265CapabilityFlagBitsKHR::eRowUnalignedSliceSegment : return "RowUnalignedSliceSegment"; + case VideoEncodeH265CapabilityFlagBitsKHR::eDifferentSliceSegmentType : return "DifferentSliceSegmentType"; + case VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL0List : return "BFrameInL0List"; + case VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL1List : return "BFrameInL1List"; + case VideoEncodeH265CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp : return "PerPictureTypeMinMaxQp"; + case VideoEncodeH265CapabilityFlagBitsKHR::ePerSliceSegmentConstantQp : return "PerSliceSegmentConstantQp"; + case VideoEncodeH265CapabilityFlagBitsKHR::eMultipleTilesPerSliceSegment : return "MultipleTilesPerSliceSegment"; + case VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile : return "MultipleSliceSegmentsPerTile"; + case VideoEncodeH265CapabilityFlagBitsKHR::eBPictureIntraRefresh : return "BPictureIntraRefresh"; + case VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound : return "CuQpDiffWraparound"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265StdFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeH265StdFlagBitsKHR::eSeparateColorPlaneFlagSet : return "SeparateColorPlaneFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eSampleAdaptiveOffsetEnabledFlagSet : return "SampleAdaptiveOffsetEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eScalingListDataPresentFlagSet : return "ScalingListDataPresentFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::ePcmEnabledFlagSet : return "PcmEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eSpsTemporalMvpEnabledFlagSet : return "SpsTemporalMvpEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eInitQpMinus26 : return "InitQpMinus26"; + case VideoEncodeH265StdFlagBitsKHR::eWeightedPredFlagSet : return "WeightedPredFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eWeightedBipredFlagSet : return "WeightedBipredFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eLog2ParallelMergeLevelMinus2 : return "Log2ParallelMergeLevelMinus2"; + case VideoEncodeH265StdFlagBitsKHR::eSignDataHidingEnabledFlagSet : return "SignDataHidingEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagSet : return "TransformSkipEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagUnset : return "TransformSkipEnabledFlagUnset"; + case VideoEncodeH265StdFlagBitsKHR::ePpsSliceChromaQpOffsetsPresentFlagSet : return "PpsSliceChromaQpOffsetsPresentFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eTransquantBypassEnabledFlagSet : return "TransquantBypassEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eConstrainedIntraPredFlagSet : return "ConstrainedIntraPredFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eEntropyCodingSyncEnabledFlagSet : return "EntropyCodingSyncEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eDeblockingFilterOverrideEnabledFlagSet: return "DeblockingFilterOverrideEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentsEnabledFlagSet : return "DependentSliceSegmentsEnabledFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentFlagSet : return "DependentSliceSegmentFlagSet"; + case VideoEncodeH265StdFlagBitsKHR::eSliceQpDelta : return "SliceQpDelta"; + case VideoEncodeH265StdFlagBitsKHR::eDifferentSliceQpDelta : return "DifferentSliceQpDelta"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265CtbSizeFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeH265CtbSizeFlagBitsKHR::e16: return "16"; + case VideoEncodeH265CtbSizeFlagBitsKHR::e32: return "32"; + case VideoEncodeH265CtbSizeFlagBitsKHR::e64: return "64"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265TransformBlockSizeFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e4 : return "4"; + case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e8 : return "8"; + case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e16: return "16"; + case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e32: return "32"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265RateControlFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeH265RateControlFlagBitsKHR::eAttemptHrdCompliance : return "AttemptHrdCompliance"; + case VideoEncodeH265RateControlFlagBitsKHR::eRegularGop : return "RegularGop"; + case VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternFlat : return "ReferencePatternFlat"; + case VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternDyadic : return "ReferencePatternDyadic"; + case VideoEncodeH265RateControlFlagBitsKHR::eTemporalSubLayerPatternDyadic: return "TemporalSubLayerPatternDyadic"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_video_decode_h264 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeH264PictureLayoutFlagBitsKHR value ) + { + switch ( value ) + { + case VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive : return "Progressive"; + case VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines: return "InterlacedInterleavedLines"; + case VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes : return "InterlacedSeparatePlanes"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_AMD_shader_info === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderInfoTypeAMD value ) + { + switch ( value ) + { + case ShaderInfoTypeAMD::eStatistics : return "Statistics"; + case ShaderInfoTypeAMD::eBinary : return "Binary"; + case ShaderInfoTypeAMD::eDisassembly: return "Disassembly"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +#if defined( VK_USE_PLATFORM_GGP ) + //=== VK_GGP_stream_descriptor_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StreamDescriptorSurfaceCreateFlagBitsGGP ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_GGP*/ + + //=== VK_NV_external_memory_capabilities === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryHandleTypeFlagBitsNV value ) + { + switch ( value ) + { + case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 : return "OpaqueWin32"; + case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; + case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image : return "D3D11Image"; + case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt : return "D3D11ImageKmt"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryFeatureFlagBitsNV value ) + { + switch ( value ) + { + case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly: return "DedicatedOnly"; + case ExternalMemoryFeatureFlagBitsNV::eExportable : return "Exportable"; + case ExternalMemoryFeatureFlagBitsNV::eImportable : return "Importable"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_validation_flags === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCheckEXT value ) + { + switch ( value ) + { + case ValidationCheckEXT::eAll : return "All"; + case ValidationCheckEXT::eShaders: return "Shaders"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +#if defined( VK_USE_PLATFORM_VI_NN ) + //=== VK_NN_vi_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ViSurfaceCreateFlagBitsNN ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_VI_NN*/ + + //=== VK_EXT_conditional_rendering === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ConditionalRenderingFlagBitsEXT value ) + { + switch ( value ) + { + case ConditionalRenderingFlagBitsEXT::eInverted: return "Inverted"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_display_surface_counter === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceCounterFlagBitsEXT value ) + { + switch ( value ) + { + case SurfaceCounterFlagBitsEXT::eVblank: return "Vblank"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_display_control === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayPowerStateEXT value ) + { + switch ( value ) + { + case DisplayPowerStateEXT::eOff : return "Off"; + case DisplayPowerStateEXT::eSuspend: return "Suspend"; + case DisplayPowerStateEXT::eOn : return "On"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceEventTypeEXT value ) + { + switch ( value ) + { + case DeviceEventTypeEXT::eDisplayHotplug: return "DisplayHotplug"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayEventTypeEXT value ) + { + switch ( value ) + { + case DisplayEventTypeEXT::eFirstPixelOut: return "FirstPixelOut"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_viewport_swizzle === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ViewportCoordinateSwizzleNV value ) + { + switch ( value ) + { + case ViewportCoordinateSwizzleNV::ePositiveX: return "PositiveX"; + case ViewportCoordinateSwizzleNV::eNegativeX: return "NegativeX"; + case ViewportCoordinateSwizzleNV::ePositiveY: return "PositiveY"; + case ViewportCoordinateSwizzleNV::eNegativeY: return "NegativeY"; + case ViewportCoordinateSwizzleNV::ePositiveZ: return "PositiveZ"; + case ViewportCoordinateSwizzleNV::eNegativeZ: return "NegativeZ"; + case ViewportCoordinateSwizzleNV::ePositiveW: return "PositiveW"; + case ViewportCoordinateSwizzleNV::eNegativeW: return "NegativeW"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportSwizzleStateCreateFlagBitsNV ) + { + return "(void)"; + } + + //=== VK_EXT_discard_rectangles === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DiscardRectangleModeEXT value ) + { + switch ( value ) + { + case DiscardRectangleModeEXT::eInclusive: return "Inclusive"; + case DiscardRectangleModeEXT::eExclusive: return "Exclusive"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDiscardRectangleStateCreateFlagBitsEXT ) + { + return "(void)"; + } + + //=== VK_EXT_conservative_rasterization === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ConservativeRasterizationModeEXT value ) + { + switch ( value ) + { + case ConservativeRasterizationModeEXT::eDisabled : return "Disabled"; + case ConservativeRasterizationModeEXT::eOverestimate : return "Overestimate"; + case ConservativeRasterizationModeEXT::eUnderestimate: return "Underestimate"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationConservativeStateCreateFlagBitsEXT ) + { + return "(void)"; + } + + //=== VK_EXT_depth_clip_enable === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationDepthClipStateCreateFlagBitsEXT ) + { + return "(void)"; + } + + //=== VK_KHR_performance_query === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagBitsKHR value ) + { + switch ( value ) + { + case PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting: return "PerformanceImpacting"; + case PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted: return "ConcurrentlyImpacted"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterScopeKHR value ) + { + switch ( value ) + { + case PerformanceCounterScopeKHR::eCommandBuffer: return "CommandBuffer"; + case PerformanceCounterScopeKHR::eRenderPass : return "RenderPass"; + case PerformanceCounterScopeKHR::eCommand : return "Command"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterStorageKHR value ) + { + switch ( value ) + { + case PerformanceCounterStorageKHR::eInt32 : return "Int32"; + case PerformanceCounterStorageKHR::eInt64 : return "Int64"; + case PerformanceCounterStorageKHR::eUint32 : return "Uint32"; + case PerformanceCounterStorageKHR::eUint64 : return "Uint64"; + case PerformanceCounterStorageKHR::eFloat32: return "Float32"; + case PerformanceCounterStorageKHR::eFloat64: return "Float64"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterUnitKHR value ) + { + switch ( value ) + { + case PerformanceCounterUnitKHR::eGeneric : return "Generic"; + case PerformanceCounterUnitKHR::ePercentage : return "Percentage"; + case PerformanceCounterUnitKHR::eNanoseconds : return "Nanoseconds"; + case PerformanceCounterUnitKHR::eBytes : return "Bytes"; + case PerformanceCounterUnitKHR::eBytesPerSecond: return "BytesPerSecond"; + case PerformanceCounterUnitKHR::eKelvin : return "Kelvin"; + case PerformanceCounterUnitKHR::eWatts : return "Watts"; + case PerformanceCounterUnitKHR::eVolts : return "Volts"; + case PerformanceCounterUnitKHR::eAmps : return "Amps"; + case PerformanceCounterUnitKHR::eHertz : return "Hertz"; + case PerformanceCounterUnitKHR::eCycles : return "Cycles"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AcquireProfilingLockFlagBitsKHR ) + { + return "(void)"; + } + +#if defined( VK_USE_PLATFORM_IOS_MVK ) + //=== VK_MVK_ios_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IOSSurfaceCreateFlagBitsMVK ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_IOS_MVK*/ + +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + //=== VK_MVK_macos_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MacOSSurfaceCreateFlagBitsMVK ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + + //=== VK_EXT_debug_utils === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessageSeverityFlagBitsEXT value ) + { + switch ( value ) + { + case DebugUtilsMessageSeverityFlagBitsEXT::eVerbose: return "Verbose"; + case DebugUtilsMessageSeverityFlagBitsEXT::eInfo : return "Info"; + case DebugUtilsMessageSeverityFlagBitsEXT::eWarning: return "Warning"; + case DebugUtilsMessageSeverityFlagBitsEXT::eError : return "Error"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessageTypeFlagBitsEXT value ) + { + switch ( value ) + { + case DebugUtilsMessageTypeFlagBitsEXT::eGeneral : return "General"; + case DebugUtilsMessageTypeFlagBitsEXT::eValidation : return "Validation"; + case DebugUtilsMessageTypeFlagBitsEXT::ePerformance : return "Performance"; + case DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding: return "DeviceAddressBinding"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCallbackDataFlagBitsEXT ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCreateFlagBitsEXT ) + { + return "(void)"; + } + + //=== VK_EXT_descriptor_heap === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorMappingSourceEXT value ) + { + switch ( value ) + { + case DescriptorMappingSourceEXT::eHeapWithConstantOffset : return "HeapWithConstantOffset"; + case DescriptorMappingSourceEXT::eHeapWithPushIndex : return "HeapWithPushIndex"; + case DescriptorMappingSourceEXT::eHeapWithIndirectIndex : return "HeapWithIndirectIndex"; + case DescriptorMappingSourceEXT::eHeapWithIndirectIndexArray: return "HeapWithIndirectIndexArray"; + case DescriptorMappingSourceEXT::eResourceHeapData : return "ResourceHeapData"; + case DescriptorMappingSourceEXT::ePushData : return "PushData"; + case DescriptorMappingSourceEXT::ePushAddress : return "PushAddress"; + case DescriptorMappingSourceEXT::eIndirectAddress : return "IndirectAddress"; + case DescriptorMappingSourceEXT::eHeapWithShaderRecordIndex : return "HeapWithShaderRecordIndex"; + case DescriptorMappingSourceEXT::eShaderRecordData : return "ShaderRecordData"; + case DescriptorMappingSourceEXT::eShaderRecordAddress : return "ShaderRecordAddress"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SpirvResourceTypeFlagBitsEXT value ) + { + switch ( value ) + { + case SpirvResourceTypeFlagBitsEXT::eAll : return "All"; + case SpirvResourceTypeFlagBitsEXT::eSampler : return "Sampler"; + case SpirvResourceTypeFlagBitsEXT::eSampledImage : return "SampledImage"; + case SpirvResourceTypeFlagBitsEXT::eReadOnlyImage : return "ReadOnlyImage"; + case SpirvResourceTypeFlagBitsEXT::eReadWriteImage : return "ReadWriteImage"; + case SpirvResourceTypeFlagBitsEXT::eCombinedSampledImage : return "CombinedSampledImage"; + case SpirvResourceTypeFlagBitsEXT::eUniformBuffer : return "UniformBuffer"; + case SpirvResourceTypeFlagBitsEXT::eReadOnlyStorageBuffer : return "ReadOnlyStorageBuffer"; + case SpirvResourceTypeFlagBitsEXT::eReadWriteStorageBuffer: return "ReadWriteStorageBuffer"; + case SpirvResourceTypeFlagBitsEXT::eAccelerationStructure : return "AccelerationStructure"; + case SpirvResourceTypeFlagBitsEXT::eTensorARM : return "TensorARM"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorViewCreateFlagBitsARM value ) + { + switch ( value ) + { + case TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay: return "DescriptorBufferCaptureReplay"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_blend_operation_advanced === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlendOverlapEXT value ) + { + switch ( value ) + { + case BlendOverlapEXT::eUncorrelated: return "Uncorrelated"; + case BlendOverlapEXT::eDisjoint : return "Disjoint"; + case BlendOverlapEXT::eConjoint : return "Conjoint"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_fragment_coverage_to_color === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageToColorStateCreateFlagBitsNV ) + { + return "(void)"; + } + + //=== VK_KHR_acceleration_structure === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureTypeKHR value ) + { + switch ( value ) + { + case AccelerationStructureTypeKHR::eTopLevel : return "TopLevel"; + case AccelerationStructureTypeKHR::eBottomLevel: return "BottomLevel"; + case AccelerationStructureTypeKHR::eGeneric : return "Generic"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureBuildTypeKHR value ) + { + switch ( value ) + { + case AccelerationStructureBuildTypeKHR::eHost : return "Host"; + case AccelerationStructureBuildTypeKHR::eDevice : return "Device"; + case AccelerationStructureBuildTypeKHR::eHostOrDevice: return "HostOrDevice"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GeometryFlagBitsKHR value ) + { + switch ( value ) + { + case GeometryFlagBitsKHR::eOpaque : return "Opaque"; + case GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation: return "NoDuplicateAnyHitInvocation"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GeometryInstanceFlagBitsKHR value ) + { + switch ( value ) + { + case GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable : return "TriangleFacingCullDisable"; + case GeometryInstanceFlagBitsKHR::eTriangleFlipFacing : return "TriangleFlipFacing"; + case GeometryInstanceFlagBitsKHR::eForceOpaque : return "ForceOpaque"; + case GeometryInstanceFlagBitsKHR::eForceNoOpaque : return "ForceNoOpaque"; + case GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT: return "ForceOpacityMicromap2StateEXT"; + case GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT : return "DisableOpacityMicromapsEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildAccelerationStructureFlagBitsKHR value ) + { + switch ( value ) + { + case BuildAccelerationStructureFlagBitsKHR::eAllowUpdate : return "AllowUpdate"; + case BuildAccelerationStructureFlagBitsKHR::eAllowCompaction : return "AllowCompaction"; + case BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace : return "PreferFastTrace"; + case BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild : return "PreferFastBuild"; + case BuildAccelerationStructureFlagBitsKHR::eLowMemory : return "LowMemory"; + case BuildAccelerationStructureFlagBitsKHR::eMotionNV : return "MotionNV"; + case BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT : return "AllowOpacityMicromapUpdateEXT"; + case BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT : return "AllowDisableOpacityMicromapsEXT"; + case BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT: return "AllowOpacityMicromapDataUpdateEXT"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV: return "AllowDisplacementMicromapUpdateNV"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess : return "AllowDataAccess"; + case BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV: return "AllowClusterOpacityMicromapsNV"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CopyAccelerationStructureModeKHR value ) + { + switch ( value ) + { + case CopyAccelerationStructureModeKHR::eClone : return "Clone"; + case CopyAccelerationStructureModeKHR::eCompact : return "Compact"; + case CopyAccelerationStructureModeKHR::eSerialize : return "Serialize"; + case CopyAccelerationStructureModeKHR::eDeserialize: return "Deserialize"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GeometryTypeKHR value ) + { + switch ( value ) + { + case GeometryTypeKHR::eTriangles : return "Triangles"; + case GeometryTypeKHR::eAabbs : return "Aabbs"; + case GeometryTypeKHR::eInstances : return "Instances"; + case GeometryTypeKHR::eSpheresNV : return "SpheresNV"; + case GeometryTypeKHR::eLinearSweptSpheresNV: return "LinearSweptSpheresNV"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case GeometryTypeKHR::eDenseGeometryFormatTrianglesAMDX: return "DenseGeometryFormatTrianglesAMDX"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureCompatibilityKHR value ) + { + switch ( value ) + { + case AccelerationStructureCompatibilityKHR::eCompatible : return "Compatible"; + case AccelerationStructureCompatibilityKHR::eIncompatible: return "Incompatible"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureCreateFlagBitsKHR value ) + { + switch ( value ) + { + case AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay : return "DeviceAddressCaptureReplay"; + case AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT: return "DescriptorBufferCaptureReplayEXT"; + case AccelerationStructureCreateFlagBitsKHR::eMotionNV : return "MotionNV"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildAccelerationStructureModeKHR value ) + { + switch ( value ) + { + case BuildAccelerationStructureModeKHR::eBuild : return "Build"; + case BuildAccelerationStructureModeKHR::eUpdate: return "Update"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_ray_tracing_pipeline === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingShaderGroupTypeKHR value ) + { + switch ( value ) + { + case RayTracingShaderGroupTypeKHR::eGeneral : return "General"; + case RayTracingShaderGroupTypeKHR::eTrianglesHitGroup : return "TrianglesHitGroup"; + case RayTracingShaderGroupTypeKHR::eProceduralHitGroup: return "ProceduralHitGroup"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderGroupShaderKHR value ) + { + switch ( value ) + { + case ShaderGroupShaderKHR::eGeneral : return "General"; + case ShaderGroupShaderKHR::eClosestHit : return "ClosestHit"; + case ShaderGroupShaderKHR::eAnyHit : return "AnyHit"; + case ShaderGroupShaderKHR::eIntersection: return "Intersection"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_framebuffer_mixed_samples === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CoverageModulationModeNV value ) + { + switch ( value ) + { + case CoverageModulationModeNV::eNone : return "None"; + case CoverageModulationModeNV::eRgb : return "Rgb"; + case CoverageModulationModeNV::eAlpha: return "Alpha"; + case CoverageModulationModeNV::eRgba : return "Rgba"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageModulationStateCreateFlagBitsNV ) + { + return "(void)"; + } + + //=== VK_EXT_validation_cache === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCacheHeaderVersionEXT value ) + { + switch ( value ) + { + case ValidationCacheHeaderVersionEXT::eOne: return "One"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCacheCreateFlagBitsEXT ) + { + return "(void)"; + } + + //=== VK_NV_shading_rate_image === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShadingRatePaletteEntryNV value ) + { + switch ( value ) + { + case ShadingRatePaletteEntryNV::eNoInvocations : return "NoInvocations"; + case ShadingRatePaletteEntryNV::e16InvocationsPerPixel : return "16InvocationsPerPixel"; + case ShadingRatePaletteEntryNV::e8InvocationsPerPixel : return "8InvocationsPerPixel"; + case ShadingRatePaletteEntryNV::e4InvocationsPerPixel : return "4InvocationsPerPixel"; + case ShadingRatePaletteEntryNV::e2InvocationsPerPixel : return "2InvocationsPerPixel"; + case ShadingRatePaletteEntryNV::e1InvocationPerPixel : return "1InvocationPerPixel"; + case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels: return "1InvocationPer2X1Pixels"; + case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels: return "1InvocationPer1X2Pixels"; + case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels: return "1InvocationPer2X2Pixels"; + case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels: return "1InvocationPer4X2Pixels"; + case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels: return "1InvocationPer2X4Pixels"; + case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels: return "1InvocationPer4X4Pixels"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CoarseSampleOrderTypeNV value ) + { + switch ( value ) + { + case CoarseSampleOrderTypeNV::eDefault : return "Default"; + case CoarseSampleOrderTypeNV::eCustom : return "Custom"; + case CoarseSampleOrderTypeNV::ePixelMajor : return "PixelMajor"; + case CoarseSampleOrderTypeNV::eSampleMajor: return "SampleMajor"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_ray_tracing === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMemoryRequirementsTypeNV value ) + { + switch ( value ) + { + case AccelerationStructureMemoryRequirementsTypeNV::eObject : return "Object"; + case AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch : return "BuildScratch"; + case AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch: return "UpdateScratch"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_AMD_pipeline_compiler_control === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCompilerControlFlagBitsAMD ) + { + return "(void)"; + } + + //=== VK_AMD_memory_overallocation_behavior === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryOverallocationBehaviorAMD value ) + { + switch ( value ) + { + case MemoryOverallocationBehaviorAMD::eDefault : return "Default"; + case MemoryOverallocationBehaviorAMD::eAllowed : return "Allowed"; + case MemoryOverallocationBehaviorAMD::eDisallowed: return "Disallowed"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_present_timing === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentStageFlagBitsEXT value ) + { + switch ( value ) + { + case PresentStageFlagBitsEXT::eQueueOperationsEnd : return "QueueOperationsEnd"; + case PresentStageFlagBitsEXT::eRequestDequeued : return "RequestDequeued"; + case PresentStageFlagBitsEXT::eImageFirstPixelOut : return "ImageFirstPixelOut"; + case PresentStageFlagBitsEXT::eImageFirstPixelVisible: return "ImageFirstPixelVisible"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentTimingInfoFlagBitsEXT value ) + { + switch ( value ) + { + case PresentTimingInfoFlagBitsEXT::ePresentAtRelativeTime : return "PresentAtRelativeTime"; + case PresentTimingInfoFlagBitsEXT::ePresentAtNearestRefreshCycle: return "PresentAtNearestRefreshCycle"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PastPresentationTimingFlagBitsEXT value ) + { + switch ( value ) + { + case PastPresentationTimingFlagBitsEXT::eAllowPartialResults : return "AllowPartialResults"; + case PastPresentationTimingFlagBitsEXT::eAllowOutOfOrderResults: return "AllowOutOfOrderResults"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_INTEL_performance_query === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceConfigurationTypeINTEL value ) + { + switch ( value ) + { + case PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated: return "CommandQueueMetricsDiscoveryActivated"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryPoolSamplingModeINTEL value ) + { + switch ( value ) + { + case QueryPoolSamplingModeINTEL::eManual: return "Manual"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceOverrideTypeINTEL value ) + { + switch ( value ) + { + case PerformanceOverrideTypeINTEL::eNullHardware : return "NullHardware"; + case PerformanceOverrideTypeINTEL::eFlushGpuCaches: return "FlushGpuCaches"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceParameterTypeINTEL value ) + { + switch ( value ) + { + case PerformanceParameterTypeINTEL::eHwCountersSupported : return "HwCountersSupported"; + case PerformanceParameterTypeINTEL::eStreamMarkerValidBits: return "StreamMarkerValidBits"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceValueTypeINTEL value ) + { + switch ( value ) + { + case PerformanceValueTypeINTEL::eUint32: return "Uint32"; + case PerformanceValueTypeINTEL::eUint64: return "Uint64"; + case PerformanceValueTypeINTEL::eFloat : return "Float"; + case PerformanceValueTypeINTEL::eBool : return "Bool"; + case PerformanceValueTypeINTEL::eString: return "String"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_imagepipe_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImagePipeSurfaceCreateFlagBitsFUCHSIA ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MetalSurfaceCreateFlagBitsEXT ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_KHR_fragment_shading_rate === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FragmentShadingRateCombinerOpKHR value ) + { + switch ( value ) + { + case FragmentShadingRateCombinerOpKHR::eKeep : return "Keep"; + case FragmentShadingRateCombinerOpKHR::eReplace: return "Replace"; + case FragmentShadingRateCombinerOpKHR::eMin : return "Min"; + case FragmentShadingRateCombinerOpKHR::eMax : return "Max"; + case FragmentShadingRateCombinerOpKHR::eMul : return "Mul"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_AMD_shader_core_properties2 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCorePropertiesFlagBitsAMD ) + { + return "(void)"; + } + + //=== VK_EXT_validation_features === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationFeatureEnableEXT value ) + { + switch ( value ) + { + case ValidationFeatureEnableEXT::eGpuAssisted : return "GpuAssisted"; + case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot: return "GpuAssistedReserveBindingSlot"; + case ValidationFeatureEnableEXT::eBestPractices : return "BestPractices"; + case ValidationFeatureEnableEXT::eDebugPrintf : return "DebugPrintf"; + case ValidationFeatureEnableEXT::eSynchronizationValidation : return "SynchronizationValidation"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationFeatureDisableEXT value ) + { + switch ( value ) + { + case ValidationFeatureDisableEXT::eAll : return "All"; + case ValidationFeatureDisableEXT::eShaders : return "Shaders"; + case ValidationFeatureDisableEXT::eThreadSafety : return "ThreadSafety"; + case ValidationFeatureDisableEXT::eApiParameters : return "ApiParameters"; + case ValidationFeatureDisableEXT::eObjectLifetimes : return "ObjectLifetimes"; + case ValidationFeatureDisableEXT::eCoreChecks : return "CoreChecks"; + case ValidationFeatureDisableEXT::eUniqueHandles : return "UniqueHandles"; + case ValidationFeatureDisableEXT::eShaderValidationCache: return "ShaderValidationCache"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_coverage_reduction_mode === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CoverageReductionModeNV value ) + { + switch ( value ) + { + case CoverageReductionModeNV::eMerge : return "Merge"; + case CoverageReductionModeNV::eTruncate: return "Truncate"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageReductionStateCreateFlagBitsNV ) + { + return "(void)"; + } + + //=== VK_EXT_provoking_vertex === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ProvokingVertexModeEXT value ) + { + switch ( value ) + { + case ProvokingVertexModeEXT::eFirstVertex: return "FirstVertex"; + case ProvokingVertexModeEXT::eLastVertex : return "LastVertex"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + //=== VK_EXT_full_screen_exclusive === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FullScreenExclusiveEXT value ) + { + switch ( value ) + { + case FullScreenExclusiveEXT::eDefault : return "Default"; + case FullScreenExclusiveEXT::eAllowed : return "Allowed"; + case FullScreenExclusiveEXT::eDisallowed : return "Disallowed"; + case FullScreenExclusiveEXT::eApplicationControlled: return "ApplicationControlled"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + + //=== VK_EXT_headless_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( HeadlessSurfaceCreateFlagBitsEXT ) + { + return "(void)"; + } + + //=== VK_KHR_pipeline_executable_properties === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineExecutableStatisticFormatKHR value ) + { + switch ( value ) + { + case PipelineExecutableStatisticFormatKHR::eBool32 : return "Bool32"; + case PipelineExecutableStatisticFormatKHR::eInt64 : return "Int64"; + case PipelineExecutableStatisticFormatKHR::eUint64 : return "Uint64"; + case PipelineExecutableStatisticFormatKHR::eFloat64: return "Float64"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_device_generated_commands === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectStateFlagBitsNV value ) + { + switch ( value ) + { + case IndirectStateFlagBitsNV::eFlagFrontface: return "FlagFrontface"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsTokenTypeNV value ) + { + switch ( value ) + { + case IndirectCommandsTokenTypeNV::eShaderGroup : return "ShaderGroup"; + case IndirectCommandsTokenTypeNV::eStateFlags : return "StateFlags"; + case IndirectCommandsTokenTypeNV::eIndexBuffer : return "IndexBuffer"; + case IndirectCommandsTokenTypeNV::eVertexBuffer : return "VertexBuffer"; + case IndirectCommandsTokenTypeNV::ePushConstant : return "PushConstant"; + case IndirectCommandsTokenTypeNV::eDrawIndexed : return "DrawIndexed"; + case IndirectCommandsTokenTypeNV::eDraw : return "Draw"; + case IndirectCommandsTokenTypeNV::eDrawTasks : return "DrawTasks"; + case IndirectCommandsTokenTypeNV::ePushData : return "PushData"; + case IndirectCommandsTokenTypeNV::eDrawMeshTasks: return "DrawMeshTasks"; + case IndirectCommandsTokenTypeNV::ePipeline : return "Pipeline"; + case IndirectCommandsTokenTypeNV::eDispatch : return "Dispatch"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsLayoutUsageFlagBitsNV value ) + { + switch ( value ) + { + case IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess: return "ExplicitPreprocess"; + case IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences : return "IndexedSequences"; + case IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences: return "UnorderedSequences"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_depth_bias_control === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DepthBiasRepresentationEXT value ) + { + switch ( value ) + { + case DepthBiasRepresentationEXT::eLeastRepresentableValueFormat : return "LeastRepresentableValueFormat"; + case DepthBiasRepresentationEXT::eLeastRepresentableValueForceUnorm: return "LeastRepresentableValueForceUnorm"; + case DepthBiasRepresentationEXT::eFloat : return "Float"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_device_memory_report === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceMemoryReportEventTypeEXT value ) + { + switch ( value ) + { + case DeviceMemoryReportEventTypeEXT::eAllocate : return "Allocate"; + case DeviceMemoryReportEventTypeEXT::eFree : return "Free"; + case DeviceMemoryReportEventTypeEXT::eImport : return "Import"; + case DeviceMemoryReportEventTypeEXT::eUnimport : return "Unimport"; + case DeviceMemoryReportEventTypeEXT::eAllocationFailed: return "AllocationFailed"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceMemoryReportFlagBitsEXT ) + { + return "(void)"; + } + + //=== VK_KHR_video_encode_queue === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeCapabilityFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes : return "PrecedingExternallyEncodedBytes"; + case VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection: return "InsufficientBitstreamBufferRangeDetection"; + case VideoEncodeCapabilityFlagBitsKHR::eQuantizationDeltaMap : return "QuantizationDeltaMap"; + case VideoEncodeCapabilityFlagBitsKHR::eEmphasisMap : return "EmphasisMap"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeFeedbackFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset: return "BitstreamBufferOffset"; + case VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten: return "BitstreamBytesWritten"; + case VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides: return "BitstreamHasOverrides"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeUsageFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeUsageFlagBitsKHR::eDefault : return "Default"; + case VideoEncodeUsageFlagBitsKHR::eTranscoding : return "Transcoding"; + case VideoEncodeUsageFlagBitsKHR::eStreaming : return "Streaming"; + case VideoEncodeUsageFlagBitsKHR::eRecording : return "Recording"; + case VideoEncodeUsageFlagBitsKHR::eConferencing: return "Conferencing"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeContentFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeContentFlagBitsKHR::eDefault : return "Default"; + case VideoEncodeContentFlagBitsKHR::eCamera : return "Camera"; + case VideoEncodeContentFlagBitsKHR::eDesktop : return "Desktop"; + case VideoEncodeContentFlagBitsKHR::eRendered: return "Rendered"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeTuningModeKHR value ) + { + switch ( value ) + { + case VideoEncodeTuningModeKHR::eDefault : return "Default"; + case VideoEncodeTuningModeKHR::eHighQuality : return "HighQuality"; + case VideoEncodeTuningModeKHR::eLowLatency : return "LowLatency"; + case VideoEncodeTuningModeKHR::eUltraLowLatency: return "UltraLowLatency"; + case VideoEncodeTuningModeKHR::eLossless : return "Lossless"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRateControlModeFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeRateControlModeFlagBitsKHR::eDefault : return "Default"; + case VideoEncodeRateControlModeFlagBitsKHR::eDisabled: return "Disabled"; + case VideoEncodeRateControlModeFlagBitsKHR::eCbr : return "Cbr"; + case VideoEncodeRateControlModeFlagBitsKHR::eVbr : return "Vbr"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeFlagBitsKHR::eIntraRefresh : return "IntraRefresh"; + case VideoEncodeFlagBitsKHR::eWithQuantizationDeltaMap: return "WithQuantizationDeltaMap"; + case VideoEncodeFlagBitsKHR::eWithEmphasisMap : return "WithEmphasisMap"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRateControlFlagBitsKHR ) + { + return "(void)"; + } + + //=== VK_NV_device_diagnostics_config === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceDiagnosticsConfigFlagBitsNV value ) + { + switch ( value ) + { + case DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo : return "EnableShaderDebugInfo"; + case DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking : return "EnableResourceTracking"; + case DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints: return "EnableAutomaticCheckpoints"; + case DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting: return "EnableShaderErrorReporting"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_QCOM_tile_shading === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TileShadingRenderPassFlagBitsQCOM value ) + { + switch ( value ) + { + case TileShadingRenderPassFlagBitsQCOM::eEnable : return "Enable"; + case TileShadingRenderPassFlagBitsQCOM::ePerTileExecution: return "PerTileExecution"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +#if defined( VK_USE_PLATFORM_METAL_EXT ) + //=== VK_EXT_metal_objects === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExportMetalObjectTypeFlagBitsEXT value ) + { + switch ( value ) + { + case ExportMetalObjectTypeFlagBitsEXT::eMetalDevice : return "MetalDevice"; + case ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue: return "MetalCommandQueue"; + case ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer : return "MetalBuffer"; + case ExportMetalObjectTypeFlagBitsEXT::eMetalTexture : return "MetalTexture"; + case ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface : return "MetalIosurface"; + case ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent : return "MetalSharedEvent"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + + //=== VK_EXT_graphics_pipeline_library === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GraphicsPipelineLibraryFlagBitsEXT value ) + { + switch ( value ) + { + case GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface : return "VertexInputInterface"; + case GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders: return "PreRasterizationShaders"; + case GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader : return "FragmentShader"; + case GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface: return "FragmentOutputInterface"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_fragment_shading_rate_enums === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FragmentShadingRateNV value ) + { + switch ( value ) + { + case FragmentShadingRateNV::e1InvocationPerPixel : return "1InvocationPerPixel"; + case FragmentShadingRateNV::e1InvocationPer1X2Pixels: return "1InvocationPer1X2Pixels"; + case FragmentShadingRateNV::e1InvocationPer2X1Pixels: return "1InvocationPer2X1Pixels"; + case FragmentShadingRateNV::e1InvocationPer2X2Pixels: return "1InvocationPer2X2Pixels"; + case FragmentShadingRateNV::e1InvocationPer2X4Pixels: return "1InvocationPer2X4Pixels"; + case FragmentShadingRateNV::e1InvocationPer4X2Pixels: return "1InvocationPer4X2Pixels"; + case FragmentShadingRateNV::e1InvocationPer4X4Pixels: return "1InvocationPer4X4Pixels"; + case FragmentShadingRateNV::e2InvocationsPerPixel : return "2InvocationsPerPixel"; + case FragmentShadingRateNV::e4InvocationsPerPixel : return "4InvocationsPerPixel"; + case FragmentShadingRateNV::e8InvocationsPerPixel : return "8InvocationsPerPixel"; + case FragmentShadingRateNV::e16InvocationsPerPixel : return "16InvocationsPerPixel"; + case FragmentShadingRateNV::eNoInvocations : return "NoInvocations"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FragmentShadingRateTypeNV value ) + { + switch ( value ) + { + case FragmentShadingRateTypeNV::eFragmentSize: return "FragmentSize"; + case FragmentShadingRateTypeNV::eEnums : return "Enums"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_ray_tracing_motion_blur === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInstanceTypeNV value ) + { + switch ( value ) + { + case AccelerationStructureMotionInstanceTypeNV::eStatic : return "Static"; + case AccelerationStructureMotionInstanceTypeNV::eMatrixMotion: return "MatrixMotion"; + case AccelerationStructureMotionInstanceTypeNV::eSrtMotion : return "SrtMotion"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInfoFlagBitsNV ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInstanceFlagBitsNV ) + { + return "(void)"; + } + + //=== VK_EXT_image_compression_control === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageCompressionFlagBitsEXT value ) + { + switch ( value ) + { + case ImageCompressionFlagBitsEXT::eDefault : return "Default"; + case ImageCompressionFlagBitsEXT::eFixedRateDefault : return "FixedRateDefault"; + case ImageCompressionFlagBitsEXT::eFixedRateExplicit: return "FixedRateExplicit"; + case ImageCompressionFlagBitsEXT::eDisabled : return "Disabled"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageCompressionFixedRateFlagBitsEXT value ) + { + switch ( value ) + { + case ImageCompressionFixedRateFlagBitsEXT::eNone : return "None"; + case ImageCompressionFixedRateFlagBitsEXT::e1Bpc : return "1Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e2Bpc : return "2Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e3Bpc : return "3Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e4Bpc : return "4Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e5Bpc : return "5Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e6Bpc : return "6Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e7Bpc : return "7Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e8Bpc : return "8Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e9Bpc : return "9Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e10Bpc: return "10Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e11Bpc: return "11Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e12Bpc: return "12Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e13Bpc: return "13Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e14Bpc: return "14Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e15Bpc: return "15Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e16Bpc: return "16Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e17Bpc: return "17Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e18Bpc: return "18Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e19Bpc: return "19Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e20Bpc: return "20Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e21Bpc: return "21Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e22Bpc: return "22Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e23Bpc: return "23Bpc"; + case ImageCompressionFixedRateFlagBitsEXT::e24Bpc: return "24Bpc"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_device_fault === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceFaultAddressTypeEXT value ) + { + switch ( value ) + { + case DeviceFaultAddressTypeEXT::eNone : return "None"; + case DeviceFaultAddressTypeEXT::eReadInvalid : return "ReadInvalid"; + case DeviceFaultAddressTypeEXT::eWriteInvalid : return "WriteInvalid"; + case DeviceFaultAddressTypeEXT::eExecuteInvalid : return "ExecuteInvalid"; + case DeviceFaultAddressTypeEXT::eInstructionPointerUnknown: return "InstructionPointerUnknown"; + case DeviceFaultAddressTypeEXT::eInstructionPointerInvalid: return "InstructionPointerInvalid"; + case DeviceFaultAddressTypeEXT::eInstructionPointerFault : return "InstructionPointerFault"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceFaultVendorBinaryHeaderVersionEXT value ) + { + switch ( value ) + { + case DeviceFaultVendorBinaryHeaderVersionEXT::eOne: return "One"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + //=== VK_EXT_directfb_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectFBSurfaceCreateFlagBitsEXT ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + + //=== VK_EXT_device_address_binding_report === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceAddressBindingFlagBitsEXT value ) + { + switch ( value ) + { + case DeviceAddressBindingFlagBitsEXT::eInternalObject: return "InternalObject"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceAddressBindingTypeEXT value ) + { + switch ( value ) + { + case DeviceAddressBindingTypeEXT::eBind : return "Bind"; + case DeviceAddressBindingTypeEXT::eUnbind: return "Unbind"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +#if defined( VK_USE_PLATFORM_FUCHSIA ) + //=== VK_FUCHSIA_buffer_collection === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageConstraintsInfoFlagBitsFUCHSIA value ) + { + switch ( value ) + { + case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely : return "CpuReadRarely"; + case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften : return "CpuReadOften"; + case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely : return "CpuWriteRarely"; + case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften : return "CpuWriteOften"; + case ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional: return "ProtectedOptional"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageFormatConstraintsFlagBitsFUCHSIA ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + + //=== VK_EXT_frame_boundary === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FrameBoundaryFlagBitsEXT value ) + { + switch ( value ) + { + case FrameBoundaryFlagBitsEXT::eFrameEnd: return "FrameEnd"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + //=== VK_QNX_screen_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ScreenSurfaceCreateFlagBitsQNX ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + + //=== VK_VALVE_video_encode_rgb_conversion === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbModelConversionFlagBitsVALVE value ) + { + switch ( value ) + { + case VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity : return "RgbIdentity"; + case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcrIdentity: return "YcbcrIdentity"; + case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr709 : return "Ycbcr709"; + case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr601 : return "Ycbcr601"; + case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr2020 : return "Ycbcr2020"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbRangeCompressionFlagBitsVALVE value ) + { + switch ( value ) + { + case VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange : return "FullRange"; + case VideoEncodeRgbRangeCompressionFlagBitsVALVE::eNarrowRange: return "NarrowRange"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbChromaOffsetFlagBitsVALVE value ) + { + switch ( value ) + { + case VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven: return "CositedEven"; + case VideoEncodeRgbChromaOffsetFlagBitsVALVE::eMidpoint : return "Midpoint"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_opacity_micromap === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MicromapTypeEXT value ) + { + switch ( value ) + { + case MicromapTypeEXT::eOpacityMicromap: return "OpacityMicromap"; +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + case MicromapTypeEXT::eDisplacementMicromapNV: return "DisplacementMicromapNV"; +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildMicromapFlagBitsEXT value ) + { + switch ( value ) + { + case BuildMicromapFlagBitsEXT::ePreferFastTrace: return "PreferFastTrace"; + case BuildMicromapFlagBitsEXT::ePreferFastBuild: return "PreferFastBuild"; + case BuildMicromapFlagBitsEXT::eAllowCompaction: return "AllowCompaction"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CopyMicromapModeEXT value ) + { + switch ( value ) + { + case CopyMicromapModeEXT::eClone : return "Clone"; + case CopyMicromapModeEXT::eSerialize : return "Serialize"; + case CopyMicromapModeEXT::eDeserialize: return "Deserialize"; + case CopyMicromapModeEXT::eCompact : return "Compact"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MicromapCreateFlagBitsEXT value ) + { + switch ( value ) + { + case MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay: return "DeviceAddressCaptureReplay"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildMicromapModeEXT value ) + { + switch ( value ) + { + case BuildMicromapModeEXT::eBuild: return "Build"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpacityMicromapFormatEXT value ) + { + switch ( value ) + { + case OpacityMicromapFormatEXT::e2State: return "2State"; + case OpacityMicromapFormatEXT::e4State: return "4State"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpacityMicromapSpecialIndexEXT value ) + { + switch ( value ) + { + case OpacityMicromapSpecialIndexEXT::eFullyTransparent : return "FullyTransparent"; + case OpacityMicromapSpecialIndexEXT::eFullyOpaque : return "FullyOpaque"; + case OpacityMicromapSpecialIndexEXT::eFullyUnknownTransparent : return "FullyUnknownTransparent"; + case OpacityMicromapSpecialIndexEXT::eFullyUnknownOpaque : return "FullyUnknownOpaque"; + case OpacityMicromapSpecialIndexEXT::eClusterGeometryDisableOpacityMicromapNV: return "ClusterGeometryDisableOpacityMicromapNV"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_NV_displacement_micromap === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplacementMicromapFormatNV value ) + { + switch ( value ) + { + case DisplacementMicromapFormatNV::e64Triangles64Bytes : return "64Triangles64Bytes"; + case DisplacementMicromapFormatNV::e256Triangles128Bytes : return "256Triangles128Bytes"; + case DisplacementMicromapFormatNV::e1024Triangles128Bytes: return "1024Triangles128Bytes"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_ARM_scheduling_controls === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceSchedulingControlsFlagBitsARM value ) + { + switch ( value ) + { + case PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount: return "ShaderCoreCount"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_ray_tracing_linear_swept_spheres === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingLssIndexingModeNV value ) + { + switch ( value ) + { + case RayTracingLssIndexingModeNV::eList : return "List"; + case RayTracingLssIndexingModeNV::eSuccessive: return "Successive"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingLssPrimitiveEndCapsModeNV value ) + { + switch ( value ) + { + case RayTracingLssPrimitiveEndCapsModeNV::eNone : return "None"; + case RayTracingLssPrimitiveEndCapsModeNV::eChained: return "Chained"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_subpass_merge_feedback === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubpassMergeStatusEXT value ) + { + switch ( value ) + { + case SubpassMergeStatusEXT::eMerged : return "Merged"; + case SubpassMergeStatusEXT::eDisallowed : return "Disallowed"; + case SubpassMergeStatusEXT::eNotMergedSideEffects : return "NotMergedSideEffects"; + case SubpassMergeStatusEXT::eNotMergedSamplesMismatch : return "NotMergedSamplesMismatch"; + case SubpassMergeStatusEXT::eNotMergedViewsMismatch : return "NotMergedViewsMismatch"; + case SubpassMergeStatusEXT::eNotMergedAliasing : return "NotMergedAliasing"; + case SubpassMergeStatusEXT::eNotMergedDependencies : return "NotMergedDependencies"; + case SubpassMergeStatusEXT::eNotMergedIncompatibleInputAttachment: return "NotMergedIncompatibleInputAttachment"; + case SubpassMergeStatusEXT::eNotMergedTooManyAttachments : return "NotMergedTooManyAttachments"; + case SubpassMergeStatusEXT::eNotMergedInsufficientStorage : return "NotMergedInsufficientStorage"; + case SubpassMergeStatusEXT::eNotMergedDepthStencilCount : return "NotMergedDepthStencilCount"; + case SubpassMergeStatusEXT::eNotMergedResolveAttachmentReuse : return "NotMergedResolveAttachmentReuse"; + case SubpassMergeStatusEXT::eNotMergedSingleSubpass : return "NotMergedSingleSubpass"; + case SubpassMergeStatusEXT::eNotMergedUnspecified : return "NotMergedUnspecified"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_LUNARG_direct_driver_loading === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectDriverLoadingModeLUNARG value ) + { + switch ( value ) + { + case DirectDriverLoadingModeLUNARG::eExclusive: return "Exclusive"; + case DirectDriverLoadingModeLUNARG::eInclusive: return "Inclusive"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectDriverLoadingFlagBitsLUNARG ) + { + return "(void)"; + } + + //=== VK_ARM_tensors === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorCreateFlagBitsARM value ) + { + switch ( value ) + { + case TensorCreateFlagBitsARM::eMutableFormat : return "MutableFormat"; + case TensorCreateFlagBitsARM::eProtected : return "Protected"; + case TensorCreateFlagBitsARM::eDescriptorHeapCaptureReplay : return "DescriptorHeapCaptureReplay"; + case TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay: return "DescriptorBufferCaptureReplay"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorUsageFlagBitsARM value ) + { + switch ( value ) + { + case TensorUsageFlagBitsARM::eShader : return "Shader"; + case TensorUsageFlagBitsARM::eTransferSrc : return "TransferSrc"; + case TensorUsageFlagBitsARM::eTransferDst : return "TransferDst"; + case TensorUsageFlagBitsARM::eImageAliasing: return "ImageAliasing"; + case TensorUsageFlagBitsARM::eDataGraph : return "DataGraph"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorTilingARM value ) + { + switch ( value ) + { + case TensorTilingARM::eOptimal: return "Optimal"; + case TensorTilingARM::eLinear : return "Linear"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_optical_flow === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowUsageFlagBitsNV value ) + { + switch ( value ) + { + case OpticalFlowUsageFlagBitsNV::eUnknown : return "Unknown"; + case OpticalFlowUsageFlagBitsNV::eInput : return "Input"; + case OpticalFlowUsageFlagBitsNV::eOutput : return "Output"; + case OpticalFlowUsageFlagBitsNV::eHint : return "Hint"; + case OpticalFlowUsageFlagBitsNV::eCost : return "Cost"; + case OpticalFlowUsageFlagBitsNV::eGlobalFlow: return "GlobalFlow"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowGridSizeFlagBitsNV value ) + { + switch ( value ) + { + case OpticalFlowGridSizeFlagBitsNV::eUnknown: return "Unknown"; + case OpticalFlowGridSizeFlagBitsNV::e1X1 : return "1X1"; + case OpticalFlowGridSizeFlagBitsNV::e2X2 : return "2X2"; + case OpticalFlowGridSizeFlagBitsNV::e4X4 : return "4X4"; + case OpticalFlowGridSizeFlagBitsNV::e8X8 : return "8X8"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowPerformanceLevelNV value ) + { + switch ( value ) + { + case OpticalFlowPerformanceLevelNV::eUnknown: return "Unknown"; + case OpticalFlowPerformanceLevelNV::eSlow : return "Slow"; + case OpticalFlowPerformanceLevelNV::eMedium : return "Medium"; + case OpticalFlowPerformanceLevelNV::eFast : return "Fast"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowSessionBindingPointNV value ) + { + switch ( value ) + { + case OpticalFlowSessionBindingPointNV::eUnknown : return "Unknown"; + case OpticalFlowSessionBindingPointNV::eInput : return "Input"; + case OpticalFlowSessionBindingPointNV::eReference : return "Reference"; + case OpticalFlowSessionBindingPointNV::eHint : return "Hint"; + case OpticalFlowSessionBindingPointNV::eFlowVector : return "FlowVector"; + case OpticalFlowSessionBindingPointNV::eBackwardFlowVector: return "BackwardFlowVector"; + case OpticalFlowSessionBindingPointNV::eCost : return "Cost"; + case OpticalFlowSessionBindingPointNV::eBackwardCost : return "BackwardCost"; + case OpticalFlowSessionBindingPointNV::eGlobalFlow : return "GlobalFlow"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowSessionCreateFlagBitsNV value ) + { + switch ( value ) + { + case OpticalFlowSessionCreateFlagBitsNV::eEnableHint : return "EnableHint"; + case OpticalFlowSessionCreateFlagBitsNV::eEnableCost : return "EnableCost"; + case OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow: return "EnableGlobalFlow"; + case OpticalFlowSessionCreateFlagBitsNV::eAllowRegions : return "AllowRegions"; + case OpticalFlowSessionCreateFlagBitsNV::eBothDirections : return "BothDirections"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowExecuteFlagBitsNV value ) + { + switch ( value ) + { + case OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints: return "DisableTemporalHints"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_AMD_anti_lag === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AntiLagModeAMD value ) + { + switch ( value ) + { + case AntiLagModeAMD::eDriverControl: return "DriverControl"; + case AntiLagModeAMD::eOn : return "On"; + case AntiLagModeAMD::eOff : return "Off"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AntiLagStageAMD value ) + { + switch ( value ) + { + case AntiLagStageAMD::eInput : return "Input"; + case AntiLagStageAMD::ePresent: return "Present"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + //=== VK_AMDX_dense_geometry_format === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CompressedTriangleFormatAMDX value ) + { + switch ( value ) + { + case CompressedTriangleFormatAMDX::eDgf1: return "Dgf1"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + + //=== VK_EXT_shader_object === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCreateFlagBitsEXT value ) + { + switch ( value ) + { + case ShaderCreateFlagBitsEXT::eLinkStage : return "LinkStage"; + case ShaderCreateFlagBitsEXT::eDescriptorHeap : return "DescriptorHeap"; + case ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize : return "AllowVaryingSubgroupSize"; + case ShaderCreateFlagBitsEXT::eRequireFullSubgroups : return "RequireFullSubgroups"; + case ShaderCreateFlagBitsEXT::eNoTaskShader : return "NoTaskShader"; + case ShaderCreateFlagBitsEXT::eDispatchBase : return "DispatchBase"; + case ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment: return "FragmentShadingRateAttachment"; + case ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment : return "FragmentDensityMapAttachment"; + case ShaderCreateFlagBitsEXT::eIndirectBindable : return "IndirectBindable"; + case ShaderCreateFlagBitsEXT::e64BitIndexing : return "64BitIndexing"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCodeTypeEXT value ) + { + switch ( value ) + { + case ShaderCodeTypeEXT::eBinary: return "Binary"; + case ShaderCodeTypeEXT::eSpirv : return "Spirv"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_surface_maintenance1 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentScalingFlagBitsKHR value ) + { + switch ( value ) + { + case PresentScalingFlagBitsKHR::eOneToOne : return "OneToOne"; + case PresentScalingFlagBitsKHR::eAspectRatioStretch: return "AspectRatioStretch"; + case PresentScalingFlagBitsKHR::eStretch : return "Stretch"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentGravityFlagBitsKHR value ) + { + switch ( value ) + { + case PresentGravityFlagBitsKHR::eMin : return "Min"; + case PresentGravityFlagBitsKHR::eMax : return "Max"; + case PresentGravityFlagBitsKHR::eCentered: return "Centered"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_cooperative_vector === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CooperativeVectorMatrixLayoutNV value ) + { + switch ( value ) + { + case CooperativeVectorMatrixLayoutNV::eRowMajor : return "RowMajor"; + case CooperativeVectorMatrixLayoutNV::eColumnMajor : return "ColumnMajor"; + case CooperativeVectorMatrixLayoutNV::eInferencingOptimal: return "InferencingOptimal"; + case CooperativeVectorMatrixLayoutNV::eTrainingOptimal : return "TrainingOptimal"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ComponentTypeKHR value ) + { + switch ( value ) + { + case ComponentTypeKHR::eFloat16 : return "Float16"; + case ComponentTypeKHR::eFloat32 : return "Float32"; + case ComponentTypeKHR::eFloat64 : return "Float64"; + case ComponentTypeKHR::eSint8 : return "Sint8"; + case ComponentTypeKHR::eSint16 : return "Sint16"; + case ComponentTypeKHR::eSint32 : return "Sint32"; + case ComponentTypeKHR::eSint64 : return "Sint64"; + case ComponentTypeKHR::eUint8 : return "Uint8"; + case ComponentTypeKHR::eUint16 : return "Uint16"; + case ComponentTypeKHR::eUint32 : return "Uint32"; + case ComponentTypeKHR::eUint64 : return "Uint64"; + case ComponentTypeKHR::eBfloat16 : return "Bfloat16"; + case ComponentTypeKHR::eSint8PackedNV: return "Sint8PackedNV"; + case ComponentTypeKHR::eUint8PackedNV: return "Uint8PackedNV"; + case ComponentTypeKHR::eFloat8E4M3EXT: return "Float8E4M3EXT"; + case ComponentTypeKHR::eFloat8E5M2EXT: return "Float8E5M2EXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_layer_settings === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LayerSettingTypeEXT value ) + { + switch ( value ) + { + case LayerSettingTypeEXT::eBool32 : return "Bool32"; + case LayerSettingTypeEXT::eInt32 : return "Int32"; + case LayerSettingTypeEXT::eInt64 : return "Int64"; + case LayerSettingTypeEXT::eUint32 : return "Uint32"; + case LayerSettingTypeEXT::eUint64 : return "Uint64"; + case LayerSettingTypeEXT::eFloat32: return "Float32"; + case LayerSettingTypeEXT::eFloat64: return "Float64"; + case LayerSettingTypeEXT::eString : return "String"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_low_latency2 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LatencyMarkerNV value ) + { + switch ( value ) + { + case LatencyMarkerNV::eSimulationStart : return "SimulationStart"; + case LatencyMarkerNV::eSimulationEnd : return "SimulationEnd"; + case LatencyMarkerNV::eRendersubmitStart : return "RendersubmitStart"; + case LatencyMarkerNV::eRendersubmitEnd : return "RendersubmitEnd"; + case LatencyMarkerNV::ePresentStart : return "PresentStart"; + case LatencyMarkerNV::ePresentEnd : return "PresentEnd"; + case LatencyMarkerNV::eInputSample : return "InputSample"; + case LatencyMarkerNV::eTriggerFlash : return "TriggerFlash"; + case LatencyMarkerNV::eOutOfBandRendersubmitStart: return "OutOfBandRendersubmitStart"; + case LatencyMarkerNV::eOutOfBandRendersubmitEnd : return "OutOfBandRendersubmitEnd"; + case LatencyMarkerNV::eOutOfBandPresentStart : return "OutOfBandPresentStart"; + case LatencyMarkerNV::eOutOfBandPresentEnd : return "OutOfBandPresentEnd"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OutOfBandQueueTypeNV value ) + { + switch ( value ) + { + case OutOfBandQueueTypeNV::eRender : return "Render"; + case OutOfBandQueueTypeNV::ePresent: return "Present"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_cooperative_matrix === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ScopeKHR value ) + { + switch ( value ) + { + case ScopeKHR::eDevice : return "Device"; + case ScopeKHR::eWorkgroup : return "Workgroup"; + case ScopeKHR::eSubgroup : return "Subgroup"; + case ScopeKHR::eQueueFamily: return "QueueFamily"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_ARM_data_graph === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineSessionBindPointARM value ) + { + switch ( value ) + { + case DataGraphPipelineSessionBindPointARM::eTransient: return "Transient"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineSessionBindPointTypeARM value ) + { + switch ( value ) + { + case DataGraphPipelineSessionBindPointTypeARM::eMemory: return "Memory"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineSessionCreateFlagBitsARM value ) + { + switch ( value ) + { + case DataGraphPipelineSessionCreateFlagBitsARM::eProtected: return "Protected"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelinePropertyARM value ) + { + switch ( value ) + { + case DataGraphPipelinePropertyARM::eCreationLog: return "CreationLog"; + case DataGraphPipelinePropertyARM::eIdentifier : return "Identifier"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineDispatchFlagBitsARM ) + { + return "(void)"; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceDataGraphProcessingEngineTypeARM value ) + { + switch ( value ) + { + case PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault : return "Default"; + case PhysicalDeviceDataGraphProcessingEngineTypeARM::eNeuralQCOM : return "NeuralQCOM"; + case PhysicalDeviceDataGraphProcessingEngineTypeARM::eComputeQCOM: return "ComputeQCOM"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceDataGraphOperationTypeARM value ) + { + switch ( value ) + { + case PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet: return "SpirvExtendedInstructionSet"; + case PhysicalDeviceDataGraphOperationTypeARM::eNeuralModelQCOM : return "NeuralModelQCOM"; + case PhysicalDeviceDataGraphOperationTypeARM::eBuiltinModelQCOM : return "BuiltinModelQCOM"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_video_encode_av1 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1PredictionModeKHR value ) + { + switch ( value ) + { + case VideoEncodeAV1PredictionModeKHR::eIntraOnly : return "IntraOnly"; + case VideoEncodeAV1PredictionModeKHR::eSingleReference : return "SingleReference"; + case VideoEncodeAV1PredictionModeKHR::eUnidirectionalCompound: return "UnidirectionalCompound"; + case VideoEncodeAV1PredictionModeKHR::eBidirectionalCompound : return "BidirectionalCompound"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1RateControlGroupKHR value ) + { + switch ( value ) + { + case VideoEncodeAV1RateControlGroupKHR::eIntra : return "Intra"; + case VideoEncodeAV1RateControlGroupKHR::ePredictive : return "Predictive"; + case VideoEncodeAV1RateControlGroupKHR::eBipredictive: return "Bipredictive"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1CapabilityFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeAV1CapabilityFlagBitsKHR::ePerRateControlGroupMinMaxQIndex: return "PerRateControlGroupMinMaxQIndex"; + case VideoEncodeAV1CapabilityFlagBitsKHR::eGenerateObuExtensionHeader : return "GenerateObuExtensionHeader"; + case VideoEncodeAV1CapabilityFlagBitsKHR::ePrimaryReferenceCdfOnly : return "PrimaryReferenceCdfOnly"; + case VideoEncodeAV1CapabilityFlagBitsKHR::eFrameSizeOverride : return "FrameSizeOverride"; + case VideoEncodeAV1CapabilityFlagBitsKHR::eMotionVectorScaling : return "MotionVectorScaling"; + case VideoEncodeAV1CapabilityFlagBitsKHR::eCompoundPredictionIntraRefresh : return "CompoundPredictionIntraRefresh"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1StdFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeAV1StdFlagBitsKHR::eUniformTileSpacingFlagSet: return "UniformTileSpacingFlagSet"; + case VideoEncodeAV1StdFlagBitsKHR::eSkipModePresentUnset : return "SkipModePresentUnset"; + case VideoEncodeAV1StdFlagBitsKHR::ePrimaryRefFrame : return "PrimaryRefFrame"; + case VideoEncodeAV1StdFlagBitsKHR::eDeltaQ : return "DeltaQ"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1SuperblockSizeFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeAV1SuperblockSizeFlagBitsKHR::e64 : return "64"; + case VideoEncodeAV1SuperblockSizeFlagBitsKHR::e128: return "128"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1RateControlFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeAV1RateControlFlagBitsKHR::eRegularGop : return "RegularGop"; + case VideoEncodeAV1RateControlFlagBitsKHR::eTemporalLayerPatternDyadic: return "TemporalLayerPatternDyadic"; + case VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternFlat : return "ReferencePatternFlat"; + case VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternDyadic : return "ReferencePatternDyadic"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_QCOM_image_processing2 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlockMatchWindowCompareModeQCOM value ) + { + switch ( value ) + { + case BlockMatchWindowCompareModeQCOM::eMin: return "Min"; + case BlockMatchWindowCompareModeQCOM::eMax: return "Max"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_QCOM_filter_cubic_weights === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CubicFilterWeightsQCOM value ) + { + switch ( value ) + { + case CubicFilterWeightsQCOM::eCatmullRom : return "CatmullRom"; + case CubicFilterWeightsQCOM::eZeroTangentCardinal: return "ZeroTangentCardinal"; + case CubicFilterWeightsQCOM::eBSpline : return "BSpline"; + case CubicFilterWeightsQCOM::eMitchellNetravali : return "MitchellNetravali"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_MSFT_layered_driver === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LayeredDriverUnderlyingApiMSFT value ) + { + switch ( value ) + { + case LayeredDriverUnderlyingApiMSFT::eNone : return "None"; + case LayeredDriverUnderlyingApiMSFT::eD3D12: return "D3D12"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_calibrated_timestamps === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TimeDomainKHR value ) + { + switch ( value ) + { + case TimeDomainKHR::eDevice : return "Device"; + case TimeDomainKHR::eClockMonotonic : return "ClockMonotonic"; + case TimeDomainKHR::eClockMonotonicRaw : return "ClockMonotonicRaw"; + case TimeDomainKHR::eQueryPerformanceCounter: return "QueryPerformanceCounter"; + case TimeDomainKHR::ePresentStageLocalEXT : return "PresentStageLocalEXT"; + case TimeDomainKHR::eSwapchainLocalEXT : return "SwapchainLocalEXT"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_copy_memory_indirect === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AddressCopyFlagBitsKHR value ) + { + switch ( value ) + { + case AddressCopyFlagBitsKHR::eDeviceLocal: return "DeviceLocal"; + case AddressCopyFlagBitsKHR::eSparse : return "Sparse"; + case AddressCopyFlagBitsKHR::eProtected : return "Protected"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_memory_decompression === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryDecompressionMethodFlagBitsEXT value ) + { + switch ( value ) + { + case MemoryDecompressionMethodFlagBitsEXT::eGdeflate10: return "Gdeflate10"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_display_stereo === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplaySurfaceStereoTypeNV value ) + { + switch ( value ) + { + case DisplaySurfaceStereoTypeNV::eNone : return "None"; + case DisplaySurfaceStereoTypeNV::eOnboardDin : return "OnboardDin"; + case DisplaySurfaceStereoTypeNV::eHdmi3D : return "Hdmi3D"; + case DisplaySurfaceStereoTypeNV::eInbandDisplayport: return "InbandDisplayport"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_video_encode_intra_refresh === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeIntraRefreshModeFlagBitsKHR value ) + { + switch ( value ) + { + case VideoEncodeIntraRefreshModeFlagBitsKHR::eNone : return "None"; + case VideoEncodeIntraRefreshModeFlagBitsKHR::ePerPicturePartition: return "PerPicturePartition"; + case VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockBased : return "BlockBased"; + case VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockRowBased : return "BlockRowBased"; + case VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockColumnBased : return "BlockColumnBased"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_maintenance7 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceLayeredApiKHR value ) + { + switch ( value ) + { + case PhysicalDeviceLayeredApiKHR::eVulkan : return "Vulkan"; + case PhysicalDeviceLayeredApiKHR::eD3D12 : return "D3D12"; + case PhysicalDeviceLayeredApiKHR::eMetal : return "Metal"; + case PhysicalDeviceLayeredApiKHR::eOpengl : return "Opengl"; + case PhysicalDeviceLayeredApiKHR::eOpengles: return "Opengles"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_cluster_acceleration_structure === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureClusterFlagBitsNV value ) + { + switch ( value ) + { + case ClusterAccelerationStructureClusterFlagBitsNV::eAllowDisableOpacityMicromaps: return "AllowDisableOpacityMicromaps"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureGeometryFlagBitsNV value ) + { + switch ( value ) + { + case ClusterAccelerationStructureGeometryFlagBitsNV::eCullDisable : return "CullDisable"; + case ClusterAccelerationStructureGeometryFlagBitsNV::eNoDuplicateAnyhitInvocation: return "NoDuplicateAnyhitInvocation"; + case ClusterAccelerationStructureGeometryFlagBitsNV::eOpaque : return "Opaque"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureAddressResolutionFlagBitsNV value ) + { + switch ( value ) + { + case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eNone : return "None"; + case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstImplicitData: return "IndirectedDstImplicitData"; + case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedScratchData : return "IndirectedScratchData"; + case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstAddressArray: return "IndirectedDstAddressArray"; + case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstSizesArray : return "IndirectedDstSizesArray"; + case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosArray : return "IndirectedSrcInfosArray"; + case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosCount : return "IndirectedSrcInfosCount"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureIndexFormatFlagBitsNV value ) + { + switch ( value ) + { + case ClusterAccelerationStructureIndexFormatFlagBitsNV::e8 : return "8"; + case ClusterAccelerationStructureIndexFormatFlagBitsNV::e16: return "16"; + case ClusterAccelerationStructureIndexFormatFlagBitsNV::e32: return "32"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureTypeNV value ) + { + switch ( value ) + { + case ClusterAccelerationStructureTypeNV::eClustersBottomLevel : return "ClustersBottomLevel"; + case ClusterAccelerationStructureTypeNV::eTriangleCluster : return "TriangleCluster"; + case ClusterAccelerationStructureTypeNV::eTriangleClusterTemplate: return "TriangleClusterTemplate"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureOpTypeNV value ) + { + switch ( value ) + { + case ClusterAccelerationStructureOpTypeNV::eMoveObjects : return "MoveObjects"; + case ClusterAccelerationStructureOpTypeNV::eBuildClustersBottomLevel : return "BuildClustersBottomLevel"; + case ClusterAccelerationStructureOpTypeNV::eBuildTriangleCluster : return "BuildTriangleCluster"; + case ClusterAccelerationStructureOpTypeNV::eBuildTriangleClusterTemplate: return "BuildTriangleClusterTemplate"; + case ClusterAccelerationStructureOpTypeNV::eInstantiateTriangleCluster : return "InstantiateTriangleCluster"; + case ClusterAccelerationStructureOpTypeNV::eGetClusterTemplateIndices : return "GetClusterTemplateIndices"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureOpModeNV value ) + { + switch ( value ) + { + case ClusterAccelerationStructureOpModeNV::eImplicitDestinations: return "ImplicitDestinations"; + case ClusterAccelerationStructureOpModeNV::eExplicitDestinations: return "ExplicitDestinations"; + case ClusterAccelerationStructureOpModeNV::eComputeSizes : return "ComputeSizes"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_NV_partitioned_acceleration_structure === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PartitionedAccelerationStructureOpTypeNV value ) + { + switch ( value ) + { + case PartitionedAccelerationStructureOpTypeNV::eWriteInstance : return "WriteInstance"; + case PartitionedAccelerationStructureOpTypeNV::eUpdateInstance : return "UpdateInstance"; + case PartitionedAccelerationStructureOpTypeNV::eWritePartitionTranslation: return "WritePartitionTranslation"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PartitionedAccelerationStructureInstanceFlagBitsNV value ) + { + switch ( value ) + { + case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFacingCullDisable: return "FlagTriangleFacingCullDisable"; + case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFlipFacing : return "FlagTriangleFlipFacing"; + case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceOpaque : return "FlagForceOpaque"; + case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceNoOpaque : return "FlagForceNoOpaque"; + case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagEnableExplicitBoundingBox: return "FlagEnableExplicitBoundingBox"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_device_generated_commands === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsTokenTypeEXT value ) + { + switch ( value ) + { + case IndirectCommandsTokenTypeEXT::eExecutionSet : return "ExecutionSet"; + case IndirectCommandsTokenTypeEXT::ePushConstant : return "PushConstant"; + case IndirectCommandsTokenTypeEXT::eSequenceIndex : return "SequenceIndex"; + case IndirectCommandsTokenTypeEXT::eIndexBuffer : return "IndexBuffer"; + case IndirectCommandsTokenTypeEXT::eVertexBuffer : return "VertexBuffer"; + case IndirectCommandsTokenTypeEXT::eDrawIndexed : return "DrawIndexed"; + case IndirectCommandsTokenTypeEXT::eDraw : return "Draw"; + case IndirectCommandsTokenTypeEXT::eDrawIndexedCount : return "DrawIndexedCount"; + case IndirectCommandsTokenTypeEXT::eDrawCount : return "DrawCount"; + case IndirectCommandsTokenTypeEXT::eDispatch : return "Dispatch"; + case IndirectCommandsTokenTypeEXT::ePushData : return "PushData"; + case IndirectCommandsTokenTypeEXT::ePushDataSequenceIndex: return "PushDataSequenceIndex"; + case IndirectCommandsTokenTypeEXT::eDrawMeshTasksNV : return "DrawMeshTasksNV"; + case IndirectCommandsTokenTypeEXT::eDrawMeshTasksCountNV : return "DrawMeshTasksCountNV"; + case IndirectCommandsTokenTypeEXT::eDrawMeshTasks : return "DrawMeshTasks"; + case IndirectCommandsTokenTypeEXT::eDrawMeshTasksCount : return "DrawMeshTasksCount"; + case IndirectCommandsTokenTypeEXT::eTraceRays2 : return "TraceRays2"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectExecutionSetInfoTypeEXT value ) + { + switch ( value ) + { + case IndirectExecutionSetInfoTypeEXT::ePipelines : return "Pipelines"; + case IndirectExecutionSetInfoTypeEXT::eShaderObjects: return "ShaderObjects"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsLayoutUsageFlagBitsEXT value ) + { + switch ( value ) + { + case IndirectCommandsLayoutUsageFlagBitsEXT::eExplicitPreprocess: return "ExplicitPreprocess"; + case IndirectCommandsLayoutUsageFlagBitsEXT::eUnorderedSequences: return "UnorderedSequences"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsInputModeFlagBitsEXT value ) + { + switch ( value ) + { + case IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer: return "VulkanIndexBuffer"; + case IndirectCommandsInputModeFlagBitsEXT::eDxgiIndexBuffer : return "DxgiIndexBuffer"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_maintenance8 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlagBits3KHR value ) + { + switch ( value ) + { + case AccessFlagBits3KHR::eNone: return "None"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_ray_tracing_invocation_reorder === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingInvocationReorderModeEXT value ) + { + switch ( value ) + { + case RayTracingInvocationReorderModeEXT::eNone : return "None"; + case RayTracingInvocationReorderModeEXT::eReorder: return "Reorder"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_EXT_depth_clamp_control === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DepthClampModeEXT value ) + { + switch ( value ) + { + case DepthClampModeEXT::eViewportRange : return "ViewportRange"; + case DepthClampModeEXT::eUserDefinedRange: return "UserDefinedRange"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_maintenance9 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DefaultVertexAttributeValueKHR value ) + { + switch ( value ) + { + case DefaultVertexAttributeValueKHR::eZeroZeroZeroZero: return "ZeroZeroZeroZero"; + case DefaultVertexAttributeValueKHR::eZeroZeroZeroOne : return "ZeroZeroZeroOne"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +#if defined( VK_USE_PLATFORM_OHOS ) + //=== VK_OHOS_surface === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceCreateFlagBitsOHOS ) + { + return "(void)"; + } +#endif /*VK_USE_PLATFORM_OHOS*/ + + //=== VK_ARM_performance_counters_by_region === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagBitsARM ) + { + return "(void)"; + } + + //=== VK_QCOM_data_graph_model === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphModelCacheTypeQCOM value ) + { + switch ( value ) + { + case DataGraphModelCacheTypeQCOM::eGenericBinary: return "GenericBinary"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + //=== VK_KHR_maintenance10 === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderingAttachmentFlagBitsKHR value ) + { + switch ( value ) + { + case RenderingAttachmentFlagBitsKHR::eInputAttachmentFeedback : return "InputAttachmentFeedback"; + case RenderingAttachmentFlagBitsKHR::eResolveSkipTransferFunction : return "ResolveSkipTransferFunction"; + case RenderingAttachmentFlagBitsKHR::eResolveEnableTransferFunction: return "ResolveEnableTransferFunction"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ResolveImageFlagBitsKHR value ) + { + switch ( value ) + { + case ResolveImageFlagBitsKHR::eSkipTransferFunction : return "SkipTransferFunction"; + case ResolveImageFlagBitsKHR::eEnableTransferFunction: return "EnableTransferFunction"; + default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; + } + } + +} // namespace VULKAN_HPP_NAMESPACE + +#if defined( __clang__ ) || defined( __GNUC__ ) +# pragma GCC diagnostic pop +#elif defined( _MSC_VER ) +# pragma warning( pop ) +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_vi.h b/lib/vulkan-headers/include/vulkan/vulkan_vi.h new file mode 100644 index 00000000000..97d1a3c5f9e --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_vi.h @@ -0,0 +1,50 @@ +#ifndef VULKAN_VI_H_ +#define VULKAN_VI_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_NN_vi_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_NN_vi_surface 1 +#define VK_NN_VI_SURFACE_SPEC_VERSION 1 +#define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface" +typedef VkFlags VkViSurfaceCreateFlagsNN; +typedef struct VkViSurfaceCreateInfoNN { + VkStructureType sType; + const void* pNext; + VkViSurfaceCreateFlagsNN flags; + void* window; +} VkViSurfaceCreateInfoNN; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( + VkInstance instance, + const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_video.cppm b/lib/vulkan-headers/include/vulkan/vulkan_video.cppm new file mode 100644 index 00000000000..7702ef27f43 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_video.cppm @@ -0,0 +1,324 @@ +// Copyright 2021-2026 The Khronos Group Inc. +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +module; + +#define VULKAN_HPP_CXX_MODULE 1 + +#include + +#if !defined( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) +# define VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING \ + "\n\tThe Vulkan-Hpp C++ named module is experimental. It is subject to change without prior notice.\n" \ + "\tTo silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n" \ + "\tFor feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues" + +VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) +#endif + +#include + +export module vulkan:video; + +export namespace VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE +{ + + //================= + //=== CONSTANTs === + //================= + +#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) + //=== vulkan_video_codec_h264std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CpbCntListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxChromaPlanes; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxNumListRef; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NoReferencePicture; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumLists; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) + //=== vulkan_video_codec_h264std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCountListSize; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) + //=== vulkan_video_codec_h265std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileColsListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileRowsListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265CpbCntListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxChromaPlanes; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDeltaPoc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDpbSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermPics; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermRefPicsSps; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxNumListRef; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxShortTermRefPicSets; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265NoReferencePicture; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteCompEntriesListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteComponentsListSize; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumElements; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SublayersListSize; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ ) + //=== vulkan_video_codec_h265std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265RefPicSetListSize; +#endif + +#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) + //=== vulkan_video_codec_vp9std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9LoopFilterAdjustments; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxRefFrames; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationPredProb; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationTreeProbs; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegments; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9NumRefFrames; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9RefsPerFrame; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9SegLvlMax; +#endif + +#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) + //=== vulkan_video_codec_av1std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1GlobalMotionParams; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1LoopFilterAdjustments; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxCdefFilterStrengths; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxLoopFilterStrengths; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCbPoints; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCrPoints; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPlanes; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosChroma; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosLuma; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumYPoints; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxSegments; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileCols; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileRows; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1NumRefFrames; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1PrimaryRefNone; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1RefsPerFrame; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SegLvlMax; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectIntegerMv; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectScreenContentTools; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SkipModeFrames; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1TotalRefsPerFrame; +#endif + + //============= + //=== ENUMs === + //============= + +#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) + //=== vulkan_video_codec_h264std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NonVclNaluType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) + //=== vulkan_video_codec_h264std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) + //=== vulkan_video_codec_h265std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType; +#endif + +#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) + //=== vulkan_video_codec_vp9std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Level; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ReferenceName; +#endif + +#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) + //=== vulkan_video_codec_av1std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameRestorationType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Level; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ReferenceName; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode; +#endif + + //=============== + //=== STRUCTS === + //=============== + +#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) + //=== vulkan_video_codec_h264std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) + //=== vulkan_video_codec_h264std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ ) + //=== vulkan_video_codec_h264std_encode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) + //=== vulkan_video_codec_h265std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ ) + //=== vulkan_video_codec_h265std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ ) + //=== vulkan_video_codec_h265std_encode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags; +#endif + +#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) + //=== vulkan_video_codec_vp9std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags; +#endif + +#if defined( VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ ) + //=== vulkan_video_codec_vp9std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags; +#endif + +#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) + //=== vulkan_video_codec_av1std === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags; +#endif + +#if defined( VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ ) + //=== vulkan_video_codec_av1std_decode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags; +#endif + +#if defined( VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ ) + //=== vulkan_video_codec_av1std_encode === + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1DecoderModelInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo; + using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags; +#endif + +} // namespace VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE diff --git a/lib/vulkan-headers/include/vulkan/vulkan_video.hpp b/lib/vulkan-headers/include/vulkan/vulkan_video.hpp new file mode 100644 index 00000000000..a513d86b80b --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_video.hpp @@ -0,0 +1,5529 @@ +// Copyright 2021-2026 The Khronos Group Inc. +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_VIDEO_HPP +#define VULKAN_VIDEO_HPP + +// here, we consider include files to be available when __has_include is not defined +#if !defined( __has_include ) +# define __has_include( x ) true +# define has_include_was_not_defined +#endif + +// clang-format off +#include +// clang-format on + +#if __has_include( ) +# include +#endif +#if __has_include( ) +# include +#endif +#if __has_include( ) +# include +#endif +#if __has_include( ) +# include +#endif +#if __has_include( ) +# include +#endif +#if __has_include( ) +# include +#endif +#if __has_include( ) +# include +#endif +#if __has_include( ) +# include +#endif +#if __has_include( ) +# include +#endif +#if __has_include( ) +# include +#endif +#if __has_include( ) +# include +#endif +#if __has_include( ) +# include +#endif + +#if !defined( VULKAN_HPP_VIDEO_NAMESPACE ) +# define VULKAN_HPP_VIDEO_NAMESPACE video +#endif + +namespace VULKAN_HPP_NAMESPACE +{ + namespace VULKAN_HPP_VIDEO_NAMESPACE + { + + //================= + //=== CONSTANTs === + //================= + +#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) + //=== vulkan_video_codec_h264std === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264CpbCntListSize = 32; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264MaxChromaPlanes = 2; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264MaxNumListRef = 32; + VULKAN_HPP_CONSTEXPR_INLINE uint8_t H264NoReferencePicture = 0xFF; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList4X4NumElements = 16; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList4X4NumLists = 6; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList8X8NumElements = 64; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList8X8NumLists = 6; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) + //=== vulkan_video_codec_h264std_decode === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t DecodeH264FieldOrderCountListSize = 2; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) + //=== vulkan_video_codec_h265std === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetListSize = 6; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetTileColsListSize = 19; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetTileRowsListSize = 21; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265CpbCntListSize = 32; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxChromaPlanes = 2; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxDeltaPoc = 48; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxDpbSize = 16; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxLongTermPics = 16; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxLongTermRefPicsSps = 32; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxNumListRef = 15; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxShortTermRefPicSets = 64; + VULKAN_HPP_CONSTEXPR_INLINE uint8_t H265NoReferencePicture = 0xFF; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265PredictorPaletteComponentsListSize = 3; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265PredictorPaletteCompEntriesListSize = 128; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList16X16NumElements = 64; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList16X16NumLists = 6; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList32X32NumElements = 64; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList32X32NumLists = 2; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList4X4NumElements = 16; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList4X4NumLists = 6; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList8X8NumElements = 64; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList8X8NumLists = 6; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265SublayersListSize = 7; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ ) + //=== vulkan_video_codec_h265std_decode === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t DecodeH265RefPicSetListSize = 8; +#endif + +#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) + //=== vulkan_video_codec_vp9std === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9LoopFilterAdjustments = 2; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxRefFrames = 4; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegmentationPredProb = 3; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegmentationTreeProbs = 7; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegments = 8; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9NumRefFrames = 8; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9RefsPerFrame = 3; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9SegLvlMax = 4; +#endif + +#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) + //=== vulkan_video_codec_av1std === + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1GlobalMotionParams = 6; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1LoopFilterAdjustments = 2; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxCdefFilterStrengths = 8; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxLoopFilterStrengths = 4; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumCbPoints = 10; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumCrPoints = 10; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPlanes = 3; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPosChroma = 25; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPosLuma = 24; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumYPoints = 14; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxSegments = 8; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxTileCols = 64; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxTileRows = 64; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1NumRefFrames = 8; + VULKAN_HPP_CONSTEXPR_INLINE uint8_t Av1PrimaryRefNone = 7; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1RefsPerFrame = 7; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SegLvlMax = 8; + VULKAN_HPP_CONSTEXPR_INLINE uint8_t Av1SelectIntegerMv = 2; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SelectScreenContentTools = 2; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SkipModeFrames = 2; + VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1TotalRefsPerFrame = 8; +#endif + + //============= + //=== ENUMs === + //============= + +#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) + //=== vulkan_video_codec_h264std === + + enum class H264ChromaFormatIdc + { + eMonochrome = STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME, + e420 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_420, + e422 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_422, + e444 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_444, + eInvalid = STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID + }; + + enum class H264ProfileIdc + { + eBaseline = STD_VIDEO_H264_PROFILE_IDC_BASELINE, + eMain = STD_VIDEO_H264_PROFILE_IDC_MAIN, + eHigh = STD_VIDEO_H264_PROFILE_IDC_HIGH, + eHigh444Predictive = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE, + eInvalid = STD_VIDEO_H264_PROFILE_IDC_INVALID + }; + + enum class H264LevelIdc + { + e1_0 = STD_VIDEO_H264_LEVEL_IDC_1_0, + e1_1 = STD_VIDEO_H264_LEVEL_IDC_1_1, + e1_2 = STD_VIDEO_H264_LEVEL_IDC_1_2, + e1_3 = STD_VIDEO_H264_LEVEL_IDC_1_3, + e2_0 = STD_VIDEO_H264_LEVEL_IDC_2_0, + e2_1 = STD_VIDEO_H264_LEVEL_IDC_2_1, + e2_2 = STD_VIDEO_H264_LEVEL_IDC_2_2, + e3_0 = STD_VIDEO_H264_LEVEL_IDC_3_0, + e3_1 = STD_VIDEO_H264_LEVEL_IDC_3_1, + e3_2 = STD_VIDEO_H264_LEVEL_IDC_3_2, + e4_0 = STD_VIDEO_H264_LEVEL_IDC_4_0, + e4_1 = STD_VIDEO_H264_LEVEL_IDC_4_1, + e4_2 = STD_VIDEO_H264_LEVEL_IDC_4_2, + e5_0 = STD_VIDEO_H264_LEVEL_IDC_5_0, + e5_1 = STD_VIDEO_H264_LEVEL_IDC_5_1, + e5_2 = STD_VIDEO_H264_LEVEL_IDC_5_2, + e6_0 = STD_VIDEO_H264_LEVEL_IDC_6_0, + e6_1 = STD_VIDEO_H264_LEVEL_IDC_6_1, + e6_2 = STD_VIDEO_H264_LEVEL_IDC_6_2, + eInvalid = STD_VIDEO_H264_LEVEL_IDC_INVALID + }; + + enum class H264PocType + { + e0 = STD_VIDEO_H264_POC_TYPE_0, + e1 = STD_VIDEO_H264_POC_TYPE_1, + e2 = STD_VIDEO_H264_POC_TYPE_2, + eInvalid = STD_VIDEO_H264_POC_TYPE_INVALID + }; + + enum class H264AspectRatioIdc + { + eUnspecified = STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED, + eSquare = STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE, + e12_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11, + e10_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11, + e16_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11, + e40_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33, + e24_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11, + e20_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11, + e32_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11, + e80_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33, + e18_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11, + e15_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11, + e64_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33, + e160_99 = STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99, + e4_3 = STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3, + e3_2 = STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2, + e2_1 = STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1, + eExtendedSar = STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR, + eInvalid = STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID + }; + + enum class H264WeightedBipredIdc + { + eDefault = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT, + eExplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT, + eImplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT, + eInvalid = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID + }; + + enum class H264ModificationOfPicNumsIdc + { + eShortTermSubtract = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT, + eShortTermAdd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD, + eLongTerm = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM, + eEnd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END, + eInvalid = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID + }; + + enum class H264MemMgmtControlOp + { + eEnd = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END, + eUnmarkShortTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM, + eUnmarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM, + eMarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM, + eSetMaxLongTermIndex = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX, + eUnmarkAll = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL, + eMarkCurrentAsLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM, + eInvalid = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID + }; + + enum class H264CabacInitIdc + { + e0 = STD_VIDEO_H264_CABAC_INIT_IDC_0, + e1 = STD_VIDEO_H264_CABAC_INIT_IDC_1, + e2 = STD_VIDEO_H264_CABAC_INIT_IDC_2, + eInvalid = STD_VIDEO_H264_CABAC_INIT_IDC_INVALID + }; + + enum class H264DisableDeblockingFilterIdc + { + eDisabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED, + eEnabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED, + ePartial = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL, + eInvalid = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID + }; + + enum class H264SliceType + { + eP = STD_VIDEO_H264_SLICE_TYPE_P, + eB = STD_VIDEO_H264_SLICE_TYPE_B, + eI = STD_VIDEO_H264_SLICE_TYPE_I, + eInvalid = STD_VIDEO_H264_SLICE_TYPE_INVALID + }; + + enum class H264PictureType + { + eP = STD_VIDEO_H264_PICTURE_TYPE_P, + eB = STD_VIDEO_H264_PICTURE_TYPE_B, + eI = STD_VIDEO_H264_PICTURE_TYPE_I, + eIdr = STD_VIDEO_H264_PICTURE_TYPE_IDR, + eInvalid = STD_VIDEO_H264_PICTURE_TYPE_INVALID + }; + + enum class H264NonVclNaluType + { + eSps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS, + ePps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS, + eAud = STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD, + ePrefix = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX, + eEndOfSequence = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE, + eEndOfStream = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM, + ePrecoded = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED, + eInvalid = STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) + //=== vulkan_video_codec_h264std_decode === + + enum class DecodeH264FieldOrderCount + { + eTop = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP, + eBottom = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM, + eInvalid = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) + //=== vulkan_video_codec_h265std === + + enum class H265ChromaFormatIdc + { + eMonochrome = STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME, + e420 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_420, + e422 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_422, + e444 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_444, + eInvalid = STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID + }; + + enum class H265ProfileIdc + { + eMain = STD_VIDEO_H265_PROFILE_IDC_MAIN, + eMain10 = STD_VIDEO_H265_PROFILE_IDC_MAIN_10, + eMainStillPicture = STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE, + eFormatRangeExtensions = STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS, + eSccExtensions = STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS, + eInvalid = STD_VIDEO_H265_PROFILE_IDC_INVALID + }; + + enum class H265LevelIdc + { + e1_0 = STD_VIDEO_H265_LEVEL_IDC_1_0, + e2_0 = STD_VIDEO_H265_LEVEL_IDC_2_0, + e2_1 = STD_VIDEO_H265_LEVEL_IDC_2_1, + e3_0 = STD_VIDEO_H265_LEVEL_IDC_3_0, + e3_1 = STD_VIDEO_H265_LEVEL_IDC_3_1, + e4_0 = STD_VIDEO_H265_LEVEL_IDC_4_0, + e4_1 = STD_VIDEO_H265_LEVEL_IDC_4_1, + e5_0 = STD_VIDEO_H265_LEVEL_IDC_5_0, + e5_1 = STD_VIDEO_H265_LEVEL_IDC_5_1, + e5_2 = STD_VIDEO_H265_LEVEL_IDC_5_2, + e6_0 = STD_VIDEO_H265_LEVEL_IDC_6_0, + e6_1 = STD_VIDEO_H265_LEVEL_IDC_6_1, + e6_2 = STD_VIDEO_H265_LEVEL_IDC_6_2, + eInvalid = STD_VIDEO_H265_LEVEL_IDC_INVALID + }; + + enum class H265SliceType + { + eB = STD_VIDEO_H265_SLICE_TYPE_B, + eP = STD_VIDEO_H265_SLICE_TYPE_P, + eI = STD_VIDEO_H265_SLICE_TYPE_I, + eInvalid = STD_VIDEO_H265_SLICE_TYPE_INVALID + }; + + enum class H265PictureType + { + eP = STD_VIDEO_H265_PICTURE_TYPE_P, + eB = STD_VIDEO_H265_PICTURE_TYPE_B, + eI = STD_VIDEO_H265_PICTURE_TYPE_I, + eIdr = STD_VIDEO_H265_PICTURE_TYPE_IDR, + eInvalid = STD_VIDEO_H265_PICTURE_TYPE_INVALID + }; + + enum class H265AspectRatioIdc + { + eUnspecified = STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED, + eSquare = STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE, + e12_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11, + e10_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11, + e16_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11, + e40_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33, + e24_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11, + e20_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11, + e32_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11, + e80_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33, + e18_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11, + e15_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11, + e64_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33, + e160_99 = STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99, + e4_3 = STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3, + e3_2 = STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2, + e2_1 = STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1, + eExtendedSar = STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR, + eInvalid = STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) + //=== vulkan_video_codec_vp9std === + + enum class VP9Profile + { + e0 = STD_VIDEO_VP9_PROFILE_0, + e1 = STD_VIDEO_VP9_PROFILE_1, + e2 = STD_VIDEO_VP9_PROFILE_2, + e3 = STD_VIDEO_VP9_PROFILE_3, + eInvalid = STD_VIDEO_VP9_PROFILE_INVALID + }; + + enum class VP9Level + { + e1_0 = STD_VIDEO_VP9_LEVEL_1_0, + e1_1 = STD_VIDEO_VP9_LEVEL_1_1, + e2_0 = STD_VIDEO_VP9_LEVEL_2_0, + e2_1 = STD_VIDEO_VP9_LEVEL_2_1, + e3_0 = STD_VIDEO_VP9_LEVEL_3_0, + e3_1 = STD_VIDEO_VP9_LEVEL_3_1, + e4_0 = STD_VIDEO_VP9_LEVEL_4_0, + e4_1 = STD_VIDEO_VP9_LEVEL_4_1, + e5_0 = STD_VIDEO_VP9_LEVEL_5_0, + e5_1 = STD_VIDEO_VP9_LEVEL_5_1, + e5_2 = STD_VIDEO_VP9_LEVEL_5_2, + e6_0 = STD_VIDEO_VP9_LEVEL_6_0, + e6_1 = STD_VIDEO_VP9_LEVEL_6_1, + e6_2 = STD_VIDEO_VP9_LEVEL_6_2, + eInvalid = STD_VIDEO_VP9_LEVEL_INVALID + }; + + enum class VP9FrameType + { + eKey = STD_VIDEO_VP9_FRAME_TYPE_KEY, + eNonKey = STD_VIDEO_VP9_FRAME_TYPE_NON_KEY, + eInvalid = STD_VIDEO_VP9_FRAME_TYPE_INVALID + }; + + enum class VP9ReferenceName + { + eIntraFrame = STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME, + eLastFrame = STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME, + eGoldenFrame = STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME, + eAltrefFrame = STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME, + eInvalid = STD_VIDEO_VP9_REFERENCE_NAME_INVALID + }; + + enum class VP9InterpolationFilter + { + eEighttap = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP, + eEighttapSmooth = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH, + eEighttapSharp = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP, + eBilinear = STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR, + eSwitchable = STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE, + eInvalid = STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID + }; + + enum class VP9ColorSpace + { + eUnknown = STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN, + eBt601 = STD_VIDEO_VP9_COLOR_SPACE_BT_601, + eBt709 = STD_VIDEO_VP9_COLOR_SPACE_BT_709, + eSmpte170 = STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170, + eSmpte240 = STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240, + eBt2020 = STD_VIDEO_VP9_COLOR_SPACE_BT_2020, + eReserved = STD_VIDEO_VP9_COLOR_SPACE_RESERVED, + eRgb = STD_VIDEO_VP9_COLOR_SPACE_RGB, + eInvalid = STD_VIDEO_VP9_COLOR_SPACE_INVALID + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) + //=== vulkan_video_codec_av1std === + + enum class AV1Profile + { + eMain = STD_VIDEO_AV1_PROFILE_MAIN, + eHigh = STD_VIDEO_AV1_PROFILE_HIGH, + eProfessional = STD_VIDEO_AV1_PROFILE_PROFESSIONAL, + eInvalid = STD_VIDEO_AV1_PROFILE_INVALID + }; + + enum class AV1Level + { + e2_0 = STD_VIDEO_AV1_LEVEL_2_0, + e2_1 = STD_VIDEO_AV1_LEVEL_2_1, + e2_2 = STD_VIDEO_AV1_LEVEL_2_2, + e2_3 = STD_VIDEO_AV1_LEVEL_2_3, + e3_0 = STD_VIDEO_AV1_LEVEL_3_0, + e3_1 = STD_VIDEO_AV1_LEVEL_3_1, + e3_2 = STD_VIDEO_AV1_LEVEL_3_2, + e3_3 = STD_VIDEO_AV1_LEVEL_3_3, + e4_0 = STD_VIDEO_AV1_LEVEL_4_0, + e4_1 = STD_VIDEO_AV1_LEVEL_4_1, + e4_2 = STD_VIDEO_AV1_LEVEL_4_2, + e4_3 = STD_VIDEO_AV1_LEVEL_4_3, + e5_0 = STD_VIDEO_AV1_LEVEL_5_0, + e5_1 = STD_VIDEO_AV1_LEVEL_5_1, + e5_2 = STD_VIDEO_AV1_LEVEL_5_2, + e5_3 = STD_VIDEO_AV1_LEVEL_5_3, + e6_0 = STD_VIDEO_AV1_LEVEL_6_0, + e6_1 = STD_VIDEO_AV1_LEVEL_6_1, + e6_2 = STD_VIDEO_AV1_LEVEL_6_2, + e6_3 = STD_VIDEO_AV1_LEVEL_6_3, + e7_0 = STD_VIDEO_AV1_LEVEL_7_0, + e7_1 = STD_VIDEO_AV1_LEVEL_7_1, + e7_2 = STD_VIDEO_AV1_LEVEL_7_2, + e7_3 = STD_VIDEO_AV1_LEVEL_7_3, + eInvalid = STD_VIDEO_AV1_LEVEL_INVALID + }; + + enum class AV1FrameType + { + eKey = STD_VIDEO_AV1_FRAME_TYPE_KEY, + eInter = STD_VIDEO_AV1_FRAME_TYPE_INTER, + eIntraOnly = STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY, + eSwitch = STD_VIDEO_AV1_FRAME_TYPE_SWITCH, + eInvalid = STD_VIDEO_AV1_FRAME_TYPE_INVALID + }; + + enum class AV1ReferenceName + { + eIntraFrame = STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME, + eLastFrame = STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME, + eLast2Frame = STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME, + eLast3Frame = STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME, + eGoldenFrame = STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME, + eBwdrefFrame = STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME, + eAltref2Frame = STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME, + eAltrefFrame = STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME, + eInvalid = STD_VIDEO_AV1_REFERENCE_NAME_INVALID + }; + + enum class AV1InterpolationFilter + { + eEighttap = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP, + eEighttapSmooth = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH, + eEighttapSharp = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP, + eBilinear = STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR, + eSwitchable = STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE, + eInvalid = STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID + }; + + enum class AV1TxMode + { + eOnly4X4 = STD_VIDEO_AV1_TX_MODE_ONLY_4X4, + eLargest = STD_VIDEO_AV1_TX_MODE_LARGEST, + eSelect = STD_VIDEO_AV1_TX_MODE_SELECT, + eInvalid = STD_VIDEO_AV1_TX_MODE_INVALID + }; + + enum class AV1FrameRestorationType + { + eNone = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE, + eWiener = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER, + eSgrproj = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ, + eSwitchable = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE, + eInvalid = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID + }; + + enum class AV1ColorPrimaries + { + eBt709 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709, + eUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED, + eBtUnspecified VULKAN_HPP_DEPRECATED_17( "eBtUnspecified is deprecated, eUnspecified should be used instead." ) = + STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED, + eBt470M = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M, + eBt470BG = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G, + eBt601 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601, + eSmpte240 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240, + eGenericFilm = STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM, + eBt2020 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020, + eXyz = STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ, + eSmpte431 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431, + eSmpte432 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432, + eEbu3213 = STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213, + eInvalid = STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID + }; + + enum class AV1TransferCharacteristics + { + eReserved0 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0, + eBt709 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709, + eUnspecified = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED, + eReserved3 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3, + eBt470M = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M, + eBt470BG = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G, + eBt601 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601, + eSmpte240 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240, + eLinear = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR, + eLog100 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100, + eLog100Sqrt10 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10, + eIec61966 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966, + eBt1361 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361, + eSrgb = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB, + eBt2020_10Bit = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT, + eBt2020_12Bit = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT, + eSmpte2084 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084, + eSmpte428 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428, + eHlg = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG, + eInvalid = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID + }; + + enum class AV1MatrixCoefficients + { + eIdentity = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY, + eBt709 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709, + eUnspecified = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED, + eReserved3 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3, + eFcc = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC, + eBt470BG = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G, + eBt601 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601, + eSmpte240 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240, + eSmpteYcgco = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO, + eBt2020Ncl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL, + eBt2020Cl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL, + eSmpte2085 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085, + eChromatNcl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL, + eChromatCl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL, + eIctcp = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP, + eInvalid = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID + }; + + enum class AV1ChromaSamplePosition + { + eUnknown = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN, + eVertical = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL, + eColocated = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED, + eReserved = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED, + eInvalid = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID + }; +#endif + + //=============== + //=== STRUCTS === + //=============== + +#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) + //=== vulkan_video_codec_h264std === + + struct H264SpsVuiFlags + { + using NativeType = StdVideoH264SpsVuiFlags; + + operator StdVideoH264SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264SpsVuiFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264SpsVuiFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH264SpsVuiFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && + ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && + ( video_full_range_flag == rhs.video_full_range_flag ) && ( color_description_present_flag == rhs.color_description_present_flag ) && + ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) && + ( fixed_frame_rate_flag == rhs.fixed_frame_rate_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && + ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) && + ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ); + } + + bool operator!=( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t color_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t timing_info_present_flag : 1; + uint32_t fixed_frame_rate_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; + }; + + struct H264HrdParameters + { + using NativeType = StdVideoH264HrdParameters; + + operator StdVideoH264HrdParameters const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264HrdParameters &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264HrdParameters const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH264HrdParameters *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && ( cpb_size_scale == rhs.cpb_size_scale ) && + ( reserved1 == rhs.reserved1 ) && ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && + ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && ( cbr_flag == rhs.cbr_flag ) && + ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && + ( cpb_removal_delay_length_minus1 == rhs.cpb_removal_delay_length_minus1 ) && + ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( time_offset_length == rhs.time_offset_length ); + } + + bool operator!=( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint8_t cpb_cnt_minus1 = {}; + uint8_t bit_rate_scale = {}; + uint8_t cpb_size_scale = {}; + uint8_t reserved1 = {}; + ArrayWrapper1D bit_rate_value_minus1 = {}; + ArrayWrapper1D cpb_size_value_minus1 = {}; + ArrayWrapper1D cbr_flag = {}; + uint32_t initial_cpb_removal_delay_length_minus1 = {}; + uint32_t cpb_removal_delay_length_minus1 = {}; + uint32_t dpb_output_delay_length_minus1 = {}; + uint32_t time_offset_length = {}; + }; + + struct H264SequenceParameterSetVui + { + using NativeType = StdVideoH264SequenceParameterSetVui; + + operator StdVideoH264SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264SequenceParameterSetVui const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH264SequenceParameterSetVui *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && + ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && + ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coefficients == rhs.matrix_coefficients ) && + ( num_units_in_tick == rhs.num_units_in_tick ) && ( time_scale == rhs.time_scale ) && ( max_num_reorder_frames == rhs.max_num_reorder_frames ) && + ( max_dec_frame_buffering == rhs.max_dec_frame_buffering ) && ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && + ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && + ( pHrdParameters == rhs.pHrdParameters ); + } + + bool operator!=( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc aspect_ratio_idc = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc::eUnspecified; + uint16_t sar_width = {}; + uint16_t sar_height = {}; + uint8_t video_format = {}; + uint8_t colour_primaries = {}; + uint8_t transfer_characteristics = {}; + uint8_t matrix_coefficients = {}; + uint32_t num_units_in_tick = {}; + uint32_t time_scale = {}; + uint8_t max_num_reorder_frames = {}; + uint8_t max_dec_frame_buffering = {}; + uint8_t chroma_sample_loc_type_top_field = {}; + uint8_t chroma_sample_loc_type_bottom_field = {}; + uint32_t reserved1 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters * pHrdParameters = {}; + }; + + struct H264SpsFlags + { + using NativeType = StdVideoH264SpsFlags; + + operator StdVideoH264SpsFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264SpsFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264SpsFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH264SpsFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( constraint_set0_flag == rhs.constraint_set0_flag ) && ( constraint_set1_flag == rhs.constraint_set1_flag ) && + ( constraint_set2_flag == rhs.constraint_set2_flag ) && ( constraint_set3_flag == rhs.constraint_set3_flag ) && + ( constraint_set4_flag == rhs.constraint_set4_flag ) && ( constraint_set5_flag == rhs.constraint_set5_flag ) && + ( direct_8x8_inference_flag == rhs.direct_8x8_inference_flag ) && ( mb_adaptive_frame_field_flag == rhs.mb_adaptive_frame_field_flag ) && + ( frame_mbs_only_flag == rhs.frame_mbs_only_flag ) && ( delta_pic_order_always_zero_flag == rhs.delta_pic_order_always_zero_flag ) && + ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && + ( gaps_in_frame_num_value_allowed_flag == rhs.gaps_in_frame_num_value_allowed_flag ) && + ( qpprime_y_zero_transform_bypass_flag == rhs.qpprime_y_zero_transform_bypass_flag ) && ( frame_cropping_flag == rhs.frame_cropping_flag ) && + ( seq_scaling_matrix_present_flag == rhs.seq_scaling_matrix_present_flag ) && ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ); + } + + bool operator!=( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t constraint_set0_flag : 1; + uint32_t constraint_set1_flag : 1; + uint32_t constraint_set2_flag : 1; + uint32_t constraint_set3_flag : 1; + uint32_t constraint_set4_flag : 1; + uint32_t constraint_set5_flag : 1; + uint32_t direct_8x8_inference_flag : 1; + uint32_t mb_adaptive_frame_field_flag : 1; + uint32_t frame_mbs_only_flag : 1; + uint32_t delta_pic_order_always_zero_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t gaps_in_frame_num_value_allowed_flag : 1; + uint32_t qpprime_y_zero_transform_bypass_flag : 1; + uint32_t frame_cropping_flag : 1; + uint32_t seq_scaling_matrix_present_flag : 1; + uint32_t vui_parameters_present_flag : 1; + }; + + struct H264ScalingLists + { + using NativeType = StdVideoH264ScalingLists; + + operator StdVideoH264ScalingLists const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264ScalingLists &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264ScalingLists const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH264ScalingLists *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( scaling_list_present_mask == rhs.scaling_list_present_mask ) && ( use_default_scaling_matrix_mask == rhs.use_default_scaling_matrix_mask ) && + ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ); + } + + bool operator!=( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint16_t scaling_list_present_mask = {}; + uint16_t use_default_scaling_matrix_mask = {}; + ArrayWrapper2D ScalingList4x4 = {}; + ArrayWrapper2D ScalingList8x8 = {}; + }; + + struct H264SequenceParameterSet + { + using NativeType = StdVideoH264SequenceParameterSet; + + operator StdVideoH264SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264SequenceParameterSet &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264SequenceParameterSet const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH264SequenceParameterSet *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( profile_idc == rhs.profile_idc ) && ( level_idc == rhs.level_idc ) && + ( chroma_format_idc == rhs.chroma_format_idc ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && + ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && + ( log2_max_frame_num_minus4 == rhs.log2_max_frame_num_minus4 ) && ( pic_order_cnt_type == rhs.pic_order_cnt_type ) && + ( offset_for_non_ref_pic == rhs.offset_for_non_ref_pic ) && ( offset_for_top_to_bottom_field == rhs.offset_for_top_to_bottom_field ) && + ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && + ( num_ref_frames_in_pic_order_cnt_cycle == rhs.num_ref_frames_in_pic_order_cnt_cycle ) && ( max_num_ref_frames == rhs.max_num_ref_frames ) && + ( reserved1 == rhs.reserved1 ) && ( pic_width_in_mbs_minus1 == rhs.pic_width_in_mbs_minus1 ) && + ( pic_height_in_map_units_minus1 == rhs.pic_height_in_map_units_minus1 ) && ( frame_crop_left_offset == rhs.frame_crop_left_offset ) && + ( frame_crop_right_offset == rhs.frame_crop_right_offset ) && ( frame_crop_top_offset == rhs.frame_crop_top_offset ) && + ( frame_crop_bottom_offset == rhs.frame_crop_bottom_offset ) && ( reserved2 == rhs.reserved2 ) && + ( pOffsetForRefFrame == rhs.pOffsetForRefFrame ) && ( pScalingLists == rhs.pScalingLists ) && + ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ); + } + + bool operator!=( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc profile_idc = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc::eBaseline; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc::e1_0; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc chroma_format_idc = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc::eMonochrome; + uint8_t seq_parameter_set_id = {}; + uint8_t bit_depth_luma_minus8 = {}; + uint8_t bit_depth_chroma_minus8 = {}; + uint8_t log2_max_frame_num_minus4 = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType pic_order_cnt_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType::e0; + int32_t offset_for_non_ref_pic = {}; + int32_t offset_for_top_to_bottom_field = {}; + uint8_t log2_max_pic_order_cnt_lsb_minus4 = {}; + uint8_t num_ref_frames_in_pic_order_cnt_cycle = {}; + uint8_t max_num_ref_frames = {}; + uint8_t reserved1 = {}; + uint32_t pic_width_in_mbs_minus1 = {}; + uint32_t pic_height_in_map_units_minus1 = {}; + uint32_t frame_crop_left_offset = {}; + uint32_t frame_crop_right_offset = {}; + uint32_t frame_crop_top_offset = {}; + uint32_t frame_crop_bottom_offset = {}; + uint32_t reserved2 = {}; + const int32_t * pOffsetForRefFrame = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui * pSequenceParameterSetVui = {}; + }; + + struct H264PpsFlags + { + using NativeType = StdVideoH264PpsFlags; + + operator StdVideoH264PpsFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264PpsFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264PpsFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH264PpsFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( transform_8x8_mode_flag == rhs.transform_8x8_mode_flag ) && ( redundant_pic_cnt_present_flag == rhs.redundant_pic_cnt_present_flag ) && + ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && + ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && ( weighted_pred_flag == rhs.weighted_pred_flag ) && + ( bottom_field_pic_order_in_frame_present_flag == rhs.bottom_field_pic_order_in_frame_present_flag ) && + ( entropy_coding_mode_flag == rhs.entropy_coding_mode_flag ) && ( pic_scaling_matrix_present_flag == rhs.pic_scaling_matrix_present_flag ); + } + + bool operator!=( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t transform_8x8_mode_flag : 1; + uint32_t redundant_pic_cnt_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t bottom_field_pic_order_in_frame_present_flag : 1; + uint32_t entropy_coding_mode_flag : 1; + uint32_t pic_scaling_matrix_present_flag : 1; + }; + + struct H264PictureParameterSet + { + using NativeType = StdVideoH264PictureParameterSet; + + operator StdVideoH264PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264PictureParameterSet &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH264PictureParameterSet const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH264PictureParameterSet *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && + ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && + ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( weighted_bipred_idc == rhs.weighted_bipred_idc ) && + ( pic_init_qp_minus26 == rhs.pic_init_qp_minus26 ) && ( pic_init_qs_minus26 == rhs.pic_init_qs_minus26 ) && + ( chroma_qp_index_offset == rhs.chroma_qp_index_offset ) && ( second_chroma_qp_index_offset == rhs.second_chroma_qp_index_offset ) && + ( pScalingLists == rhs.pScalingLists ); + } + + bool operator!=( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags flags = {}; + uint8_t seq_parameter_set_id = {}; + uint8_t pic_parameter_set_id = {}; + uint8_t num_ref_idx_l0_default_active_minus1 = {}; + uint8_t num_ref_idx_l1_default_active_minus1 = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc weighted_bipred_idc = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc::eDefault; + int8_t pic_init_qp_minus26 = {}; + int8_t pic_init_qs_minus26 = {}; + int8_t chroma_qp_index_offset = {}; + int8_t second_chroma_qp_index_offset = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {}; + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) + //=== vulkan_video_codec_h264std_decode === + + struct DecodeH264PictureInfoFlags + { + using NativeType = StdVideoDecodeH264PictureInfoFlags; + + operator StdVideoDecodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH264PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeH264PictureInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( field_pic_flag == rhs.field_pic_flag ) && ( is_intra == rhs.is_intra ) && ( IdrPicFlag == rhs.IdrPicFlag ) && + ( bottom_field_flag == rhs.bottom_field_flag ) && ( is_reference == rhs.is_reference ) && + ( complementary_field_pair == rhs.complementary_field_pair ); + } + + bool operator!=( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t field_pic_flag : 1; + uint32_t is_intra : 1; + uint32_t IdrPicFlag : 1; + uint32_t bottom_field_flag : 1; + uint32_t is_reference : 1; + uint32_t complementary_field_pair : 1; + }; + + struct DecodeH264PictureInfo + { + using NativeType = StdVideoDecodeH264PictureInfo; + + operator StdVideoDecodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH264PictureInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeH264PictureInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && + ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( frame_num == rhs.frame_num ) && ( idr_pic_id == rhs.idr_pic_id ) && + ( PicOrderCnt == rhs.PicOrderCnt ); + } + + bool operator!=( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags flags = {}; + uint8_t seq_parameter_set_id = {}; + uint8_t pic_parameter_set_id = {}; + uint8_t reserved1 = {}; + uint8_t reserved2 = {}; + uint16_t frame_num = {}; + uint16_t idr_pic_id = {}; + ArrayWrapper1D PicOrderCnt = {}; + }; + + struct DecodeH264ReferenceInfoFlags + { + using NativeType = StdVideoDecodeH264ReferenceInfoFlags; + + operator StdVideoDecodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH264ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeH264ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( top_field_flag == rhs.top_field_flag ) && ( bottom_field_flag == rhs.bottom_field_flag ) && + ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( is_non_existing == rhs.is_non_existing ); + } + + bool operator!=( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t top_field_flag : 1; + uint32_t bottom_field_flag : 1; + uint32_t used_for_long_term_reference : 1; + uint32_t is_non_existing : 1; + }; + + struct DecodeH264ReferenceInfo + { + using NativeType = StdVideoDecodeH264ReferenceInfo; + + operator StdVideoDecodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH264ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeH264ReferenceInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( FrameNum == rhs.FrameNum ) && ( reserved == rhs.reserved ) && ( PicOrderCnt == rhs.PicOrderCnt ); + } + + bool operator!=( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags flags = {}; + uint16_t FrameNum = {}; + uint16_t reserved = {}; + ArrayWrapper1D PicOrderCnt = {}; + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ ) + //=== vulkan_video_codec_h264std_encode === + + struct EncodeH264WeightTableFlags + { + using NativeType = StdVideoEncodeH264WeightTableFlags; + + operator StdVideoEncodeH264WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264WeightTableFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264WeightTableFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264WeightTableFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && + ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); + } + + bool operator!=( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t luma_weight_l0_flag = {}; + uint32_t chroma_weight_l0_flag = {}; + uint32_t luma_weight_l1_flag = {}; + uint32_t chroma_weight_l1_flag = {}; + }; + + struct EncodeH264WeightTable + { + using NativeType = StdVideoEncodeH264WeightTable; + + operator StdVideoEncodeH264WeightTable const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264WeightTable &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264WeightTable const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264WeightTable *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && + ( chroma_log2_weight_denom == rhs.chroma_log2_weight_denom ) && ( luma_weight_l0 == rhs.luma_weight_l0 ) && + ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( chroma_weight_l0 == rhs.chroma_weight_l0 ) && ( chroma_offset_l0 == rhs.chroma_offset_l0 ) && + ( luma_weight_l1 == rhs.luma_weight_l1 ) && ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( chroma_weight_l1 == rhs.chroma_weight_l1 ) && + ( chroma_offset_l1 == rhs.chroma_offset_l1 ); + } + + bool operator!=( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags flags = {}; + uint8_t luma_log2_weight_denom = {}; + uint8_t chroma_log2_weight_denom = {}; + ArrayWrapper1D luma_weight_l0 = {}; + ArrayWrapper1D luma_offset_l0 = {}; + ArrayWrapper2D chroma_weight_l0 = {}; + ArrayWrapper2D chroma_offset_l0 = {}; + ArrayWrapper1D luma_weight_l1 = {}; + ArrayWrapper1D luma_offset_l1 = {}; + ArrayWrapper2D chroma_weight_l1 = {}; + ArrayWrapper2D chroma_offset_l1 = {}; + }; + + struct EncodeH264SliceHeaderFlags + { + using NativeType = StdVideoEncodeH264SliceHeaderFlags; + + operator StdVideoEncodeH264SliceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264SliceHeaderFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264SliceHeaderFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264SliceHeaderFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( direct_spatial_mv_pred_flag == rhs.direct_spatial_mv_pred_flag ) && + ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && ( reserved == rhs.reserved ); + } + + bool operator!=( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t direct_spatial_mv_pred_flag : 1; + uint32_t num_ref_idx_active_override_flag : 1; + uint32_t reserved : 30; + }; + + struct EncodeH264PictureInfoFlags + { + using NativeType = StdVideoEncodeH264PictureInfoFlags; + + operator StdVideoEncodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264PictureInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( IdrPicFlag == rhs.IdrPicFlag ) && ( is_reference == rhs.is_reference ) && + ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && ( long_term_reference_flag == rhs.long_term_reference_flag ) && + ( adaptive_ref_pic_marking_mode_flag == rhs.adaptive_ref_pic_marking_mode_flag ) && ( reserved == rhs.reserved ); + } + + bool operator!=( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t IdrPicFlag : 1; + uint32_t is_reference : 1; + uint32_t no_output_of_prior_pics_flag : 1; + uint32_t long_term_reference_flag : 1; + uint32_t adaptive_ref_pic_marking_mode_flag : 1; + uint32_t reserved : 27; + }; + + struct EncodeH264ReferenceInfoFlags + { + using NativeType = StdVideoEncodeH264ReferenceInfoFlags; + + operator StdVideoEncodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( reserved == rhs.reserved ); + } + + bool operator!=( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t used_for_long_term_reference : 1; + uint32_t reserved : 31; + }; + + struct EncodeH264ReferenceListsInfoFlags + { + using NativeType = StdVideoEncodeH264ReferenceListsInfoFlags; + + operator StdVideoEncodeH264ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceListsInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceListsInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && + ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); + } + + bool operator!=( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t ref_pic_list_modification_flag_l0 : 1; + uint32_t ref_pic_list_modification_flag_l1 : 1; + uint32_t reserved : 30; + }; + + struct EncodeH264RefListModEntry + { + using NativeType = StdVideoEncodeH264RefListModEntry; + + operator StdVideoEncodeH264RefListModEntry const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264RefListModEntry &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264RefListModEntry const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264RefListModEntry *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( modification_of_pic_nums_idc == rhs.modification_of_pic_nums_idc ) && ( abs_diff_pic_num_minus1 == rhs.abs_diff_pic_num_minus1 ) && + ( long_term_pic_num == rhs.long_term_pic_num ); + } + + bool operator!=( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc modification_of_pic_nums_idc = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc::eShortTermSubtract; + uint16_t abs_diff_pic_num_minus1 = {}; + uint16_t long_term_pic_num = {}; + }; + + struct EncodeH264RefPicMarkingEntry + { + using NativeType = StdVideoEncodeH264RefPicMarkingEntry; + + operator StdVideoEncodeH264RefPicMarkingEntry const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264RefPicMarkingEntry &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264RefPicMarkingEntry const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264RefPicMarkingEntry *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( memory_management_control_operation == rhs.memory_management_control_operation ) && + ( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) && ( long_term_pic_num == rhs.long_term_pic_num ) && + ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 ); + } + + bool operator!=( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp memory_management_control_operation = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp::eEnd; + uint16_t difference_of_pic_nums_minus1 = {}; + uint16_t long_term_pic_num = {}; + uint16_t long_term_frame_idx = {}; + uint16_t max_long_term_frame_idx_plus1 = {}; + }; + + struct EncodeH264ReferenceListsInfo + { + using NativeType = StdVideoEncodeH264ReferenceListsInfo; + + operator StdVideoEncodeH264ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceListsInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceListsInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && + ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && + ( RefPicList1 == rhs.RefPicList1 ) && ( refList0ModOpCount == rhs.refList0ModOpCount ) && ( refList1ModOpCount == rhs.refList1ModOpCount ) && + ( refPicMarkingOpCount == rhs.refPicMarkingOpCount ) && ( reserved1 == rhs.reserved1 ) && + ( pRefList0ModOperations == rhs.pRefList0ModOperations ) && ( pRefList1ModOperations == rhs.pRefList1ModOperations ) && + ( pRefPicMarkingOperations == rhs.pRefPicMarkingOperations ); + } + + bool operator!=( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags flags = {}; + uint8_t num_ref_idx_l0_active_minus1 = {}; + uint8_t num_ref_idx_l1_active_minus1 = {}; + ArrayWrapper1D RefPicList0 = {}; + ArrayWrapper1D RefPicList1 = {}; + uint8_t refList0ModOpCount = {}; + uint8_t refList1ModOpCount = {}; + uint8_t refPicMarkingOpCount = {}; + ArrayWrapper1D reserved1 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList0ModOperations = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList1ModOperations = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry * pRefPicMarkingOperations = {}; + }; + + struct EncodeH264PictureInfo + { + using NativeType = StdVideoEncodeH264PictureInfo; + + operator StdVideoEncodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264PictureInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264PictureInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && + ( idr_pic_id == rhs.idr_pic_id ) && ( primary_pic_type == rhs.primary_pic_type ) && ( frame_num == rhs.frame_num ) && + ( PicOrderCnt == rhs.PicOrderCnt ) && ( temporal_id == rhs.temporal_id ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ); + } + + bool operator!=( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags flags = {}; + uint8_t seq_parameter_set_id = {}; + uint8_t pic_parameter_set_id = {}; + uint16_t idr_pic_id = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP; + uint32_t frame_num = {}; + int32_t PicOrderCnt = {}; + uint8_t temporal_id = {}; + ArrayWrapper1D reserved1 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo * pRefLists = {}; + }; + + struct EncodeH264ReferenceInfo + { + using NativeType = StdVideoEncodeH264ReferenceInfo; + + operator StdVideoEncodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264ReferenceInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( primary_pic_type == rhs.primary_pic_type ) && ( FrameNum == rhs.FrameNum ) && ( PicOrderCnt == rhs.PicOrderCnt ) && + ( long_term_pic_num == rhs.long_term_pic_num ) && ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( temporal_id == rhs.temporal_id ); + } + + bool operator!=( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP; + uint32_t FrameNum = {}; + int32_t PicOrderCnt = {}; + uint16_t long_term_pic_num = {}; + uint16_t long_term_frame_idx = {}; + uint8_t temporal_id = {}; + }; + + struct EncodeH264SliceHeader + { + using NativeType = StdVideoEncodeH264SliceHeader; + + operator StdVideoEncodeH264SliceHeader const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264SliceHeader &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH264SliceHeader const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH264SliceHeader *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( first_mb_in_slice == rhs.first_mb_in_slice ) && ( slice_type == rhs.slice_type ) && + ( slice_alpha_c0_offset_div2 == rhs.slice_alpha_c0_offset_div2 ) && ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && + ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && ( cabac_init_idc == rhs.cabac_init_idc ) && + ( disable_deblocking_filter_idc == rhs.disable_deblocking_filter_idc ) && ( pWeightTable == rhs.pWeightTable ); + } + + bool operator!=( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags flags = {}; + uint32_t first_mb_in_slice = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType::eP; + int8_t slice_alpha_c0_offset_div2 = {}; + int8_t slice_beta_offset_div2 = {}; + int8_t slice_qp_delta = {}; + uint8_t reserved1 = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc cabac_init_idc = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc::e0; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc disable_deblocking_filter_idc = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc::eDisabled; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable * pWeightTable = {}; + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) + //=== vulkan_video_codec_h265std === + + struct H265DecPicBufMgr + { + using NativeType = StdVideoH265DecPicBufMgr; + + operator StdVideoH265DecPicBufMgr const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265DecPicBufMgr &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265DecPicBufMgr const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265DecPicBufMgr *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( max_latency_increase_plus1 == rhs.max_latency_increase_plus1 ) && ( max_dec_pic_buffering_minus1 == rhs.max_dec_pic_buffering_minus1 ) && + ( max_num_reorder_pics == rhs.max_num_reorder_pics ); + } + + bool operator!=( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + ArrayWrapper1D max_latency_increase_plus1 = {}; + ArrayWrapper1D max_dec_pic_buffering_minus1 = {}; + ArrayWrapper1D max_num_reorder_pics = {}; + }; + + struct H265SubLayerHrdParameters + { + using NativeType = StdVideoH265SubLayerHrdParameters; + + operator StdVideoH265SubLayerHrdParameters const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265SubLayerHrdParameters &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265SubLayerHrdParameters const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265SubLayerHrdParameters *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && + ( cpb_size_du_value_minus1 == rhs.cpb_size_du_value_minus1 ) && ( bit_rate_du_value_minus1 == rhs.bit_rate_du_value_minus1 ) && + ( cbr_flag == rhs.cbr_flag ); + } + + bool operator!=( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + ArrayWrapper1D bit_rate_value_minus1 = {}; + ArrayWrapper1D cpb_size_value_minus1 = {}; + ArrayWrapper1D cpb_size_du_value_minus1 = {}; + ArrayWrapper1D bit_rate_du_value_minus1 = {}; + uint32_t cbr_flag = {}; + }; + + struct H265HrdFlags + { + using NativeType = StdVideoH265HrdFlags; + + operator StdVideoH265HrdFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265HrdFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265HrdFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265HrdFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) && + ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ) && + ( sub_pic_hrd_params_present_flag == rhs.sub_pic_hrd_params_present_flag ) && + ( sub_pic_cpb_params_in_pic_timing_sei_flag == rhs.sub_pic_cpb_params_in_pic_timing_sei_flag ) && + ( fixed_pic_rate_general_flag == rhs.fixed_pic_rate_general_flag ) && ( fixed_pic_rate_within_cvs_flag == rhs.fixed_pic_rate_within_cvs_flag ) && + ( low_delay_hrd_flag == rhs.low_delay_hrd_flag ); + } + + bool operator!=( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; + uint32_t sub_pic_hrd_params_present_flag : 1; + uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; + uint32_t fixed_pic_rate_general_flag : 8; + uint32_t fixed_pic_rate_within_cvs_flag : 8; + uint32_t low_delay_hrd_flag : 8; + }; + + struct H265HrdParameters + { + using NativeType = StdVideoH265HrdParameters; + + operator StdVideoH265HrdParameters const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265HrdParameters &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265HrdParameters const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265HrdParameters *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( tick_divisor_minus2 == rhs.tick_divisor_minus2 ) && + ( du_cpb_removal_delay_increment_length_minus1 == rhs.du_cpb_removal_delay_increment_length_minus1 ) && + ( dpb_output_delay_du_length_minus1 == rhs.dpb_output_delay_du_length_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && + ( cpb_size_scale == rhs.cpb_size_scale ) && ( cpb_size_du_scale == rhs.cpb_size_du_scale ) && + ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && + ( au_cpb_removal_delay_length_minus1 == rhs.au_cpb_removal_delay_length_minus1 ) && + ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && + ( elemental_duration_in_tc_minus1 == rhs.elemental_duration_in_tc_minus1 ) && ( reserved == rhs.reserved ) && + ( pSubLayerHrdParametersNal == rhs.pSubLayerHrdParametersNal ) && ( pSubLayerHrdParametersVcl == rhs.pSubLayerHrdParametersVcl ); + } + + bool operator!=( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags flags = {}; + uint8_t tick_divisor_minus2 = {}; + uint8_t du_cpb_removal_delay_increment_length_minus1 = {}; + uint8_t dpb_output_delay_du_length_minus1 = {}; + uint8_t bit_rate_scale = {}; + uint8_t cpb_size_scale = {}; + uint8_t cpb_size_du_scale = {}; + uint8_t initial_cpb_removal_delay_length_minus1 = {}; + uint8_t au_cpb_removal_delay_length_minus1 = {}; + uint8_t dpb_output_delay_length_minus1 = {}; + ArrayWrapper1D cpb_cnt_minus1 = {}; + ArrayWrapper1D elemental_duration_in_tc_minus1 = {}; + ArrayWrapper1D reserved = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersNal = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersVcl = {}; + }; + + struct H265VpsFlags + { + using NativeType = StdVideoH265VpsFlags; + + operator StdVideoH265VpsFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265VpsFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265VpsFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265VpsFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( vps_temporal_id_nesting_flag == rhs.vps_temporal_id_nesting_flag ) && + ( vps_sub_layer_ordering_info_present_flag == rhs.vps_sub_layer_ordering_info_present_flag ) && + ( vps_timing_info_present_flag == rhs.vps_timing_info_present_flag ) && + ( vps_poc_proportional_to_timing_flag == rhs.vps_poc_proportional_to_timing_flag ); + } + + bool operator!=( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t vps_temporal_id_nesting_flag : 1; + uint32_t vps_sub_layer_ordering_info_present_flag : 1; + uint32_t vps_timing_info_present_flag : 1; + uint32_t vps_poc_proportional_to_timing_flag : 1; + }; + + struct H265ProfileTierLevelFlags + { + using NativeType = StdVideoH265ProfileTierLevelFlags; + + operator StdVideoH265ProfileTierLevelFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265ProfileTierLevelFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265ProfileTierLevelFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265ProfileTierLevelFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( general_tier_flag == rhs.general_tier_flag ) && ( general_progressive_source_flag == rhs.general_progressive_source_flag ) && + ( general_interlaced_source_flag == rhs.general_interlaced_source_flag ) && + ( general_non_packed_constraint_flag == rhs.general_non_packed_constraint_flag ) && + ( general_frame_only_constraint_flag == rhs.general_frame_only_constraint_flag ); + } + + bool operator!=( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t general_tier_flag : 1; + uint32_t general_progressive_source_flag : 1; + uint32_t general_interlaced_source_flag : 1; + uint32_t general_non_packed_constraint_flag : 1; + uint32_t general_frame_only_constraint_flag : 1; + }; + + struct H265ProfileTierLevel + { + using NativeType = StdVideoH265ProfileTierLevel; + + operator StdVideoH265ProfileTierLevel const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265ProfileTierLevel &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265ProfileTierLevel const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265ProfileTierLevel *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( general_profile_idc == rhs.general_profile_idc ) && ( general_level_idc == rhs.general_level_idc ); + } + + bool operator!=( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc general_profile_idc = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc::eMain; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc general_level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc::e1_0; + }; + + struct H265VideoParameterSet + { + using NativeType = StdVideoH265VideoParameterSet; + + operator StdVideoH265VideoParameterSet const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265VideoParameterSet &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265VideoParameterSet const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265VideoParameterSet *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( vps_video_parameter_set_id == rhs.vps_video_parameter_set_id ) && + ( vps_max_sub_layers_minus1 == rhs.vps_max_sub_layers_minus1 ) && ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && + ( vps_num_units_in_tick == rhs.vps_num_units_in_tick ) && ( vps_time_scale == rhs.vps_time_scale ) && + ( vps_num_ticks_poc_diff_one_minus1 == rhs.vps_num_ticks_poc_diff_one_minus1 ) && ( reserved3 == rhs.reserved3 ) && + ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pHrdParameters == rhs.pHrdParameters ) && ( pProfileTierLevel == rhs.pProfileTierLevel ); + } + + bool operator!=( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags flags = {}; + uint8_t vps_video_parameter_set_id = {}; + uint8_t vps_max_sub_layers_minus1 = {}; + uint8_t reserved1 = {}; + uint8_t reserved2 = {}; + uint32_t vps_num_units_in_tick = {}; + uint32_t vps_time_scale = {}; + uint32_t vps_num_ticks_poc_diff_one_minus1 = {}; + uint32_t reserved3 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {}; + }; + + struct H265ScalingLists + { + using NativeType = StdVideoH265ScalingLists; + + operator StdVideoH265ScalingLists const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265ScalingLists &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265ScalingLists const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265ScalingLists *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ) && ( ScalingList16x16 == rhs.ScalingList16x16 ) && + ( ScalingList32x32 == rhs.ScalingList32x32 ) && ( ScalingListDCCoef16x16 == rhs.ScalingListDCCoef16x16 ) && + ( ScalingListDCCoef32x32 == rhs.ScalingListDCCoef32x32 ); + } + + bool operator!=( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + ArrayWrapper2D ScalingList4x4 = {}; + ArrayWrapper2D ScalingList8x8 = {}; + ArrayWrapper2D ScalingList16x16 = {}; + ArrayWrapper2D ScalingList32x32 = {}; + ArrayWrapper1D ScalingListDCCoef16x16 = {}; + ArrayWrapper1D ScalingListDCCoef32x32 = {}; + }; + + struct H265SpsVuiFlags + { + using NativeType = StdVideoH265SpsVuiFlags; + + operator StdVideoH265SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265SpsVuiFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265SpsVuiFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265SpsVuiFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && + ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && + ( video_full_range_flag == rhs.video_full_range_flag ) && ( colour_description_present_flag == rhs.colour_description_present_flag ) && + ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && + ( neutral_chroma_indication_flag == rhs.neutral_chroma_indication_flag ) && ( field_seq_flag == rhs.field_seq_flag ) && + ( frame_field_info_present_flag == rhs.frame_field_info_present_flag ) && ( default_display_window_flag == rhs.default_display_window_flag ) && + ( vui_timing_info_present_flag == rhs.vui_timing_info_present_flag ) && + ( vui_poc_proportional_to_timing_flag == rhs.vui_poc_proportional_to_timing_flag ) && + ( vui_hrd_parameters_present_flag == rhs.vui_hrd_parameters_present_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && + ( tiles_fixed_structure_flag == rhs.tiles_fixed_structure_flag ) && + ( motion_vectors_over_pic_boundaries_flag == rhs.motion_vectors_over_pic_boundaries_flag ) && + ( restricted_ref_pic_lists_flag == rhs.restricted_ref_pic_lists_flag ); + } + + bool operator!=( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t colour_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t neutral_chroma_indication_flag : 1; + uint32_t field_seq_flag : 1; + uint32_t frame_field_info_present_flag : 1; + uint32_t default_display_window_flag : 1; + uint32_t vui_timing_info_present_flag : 1; + uint32_t vui_poc_proportional_to_timing_flag : 1; + uint32_t vui_hrd_parameters_present_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t tiles_fixed_structure_flag : 1; + uint32_t motion_vectors_over_pic_boundaries_flag : 1; + uint32_t restricted_ref_pic_lists_flag : 1; + }; + + struct H265SequenceParameterSetVui + { + using NativeType = StdVideoH265SequenceParameterSetVui; + + operator StdVideoH265SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265SequenceParameterSetVui const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265SequenceParameterSetVui *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && + ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && + ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coeffs == rhs.matrix_coeffs ) && + ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && + ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && + ( reserved2 == rhs.reserved2 ) && ( def_disp_win_left_offset == rhs.def_disp_win_left_offset ) && + ( def_disp_win_right_offset == rhs.def_disp_win_right_offset ) && ( def_disp_win_top_offset == rhs.def_disp_win_top_offset ) && + ( def_disp_win_bottom_offset == rhs.def_disp_win_bottom_offset ) && ( vui_num_units_in_tick == rhs.vui_num_units_in_tick ) && + ( vui_time_scale == rhs.vui_time_scale ) && ( vui_num_ticks_poc_diff_one_minus1 == rhs.vui_num_ticks_poc_diff_one_minus1 ) && + ( min_spatial_segmentation_idc == rhs.min_spatial_segmentation_idc ) && ( reserved3 == rhs.reserved3 ) && + ( max_bytes_per_pic_denom == rhs.max_bytes_per_pic_denom ) && ( max_bits_per_min_cu_denom == rhs.max_bits_per_min_cu_denom ) && + ( log2_max_mv_length_horizontal == rhs.log2_max_mv_length_horizontal ) && ( log2_max_mv_length_vertical == rhs.log2_max_mv_length_vertical ) && + ( pHrdParameters == rhs.pHrdParameters ); + } + + bool operator!=( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc aspect_ratio_idc = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc::eUnspecified; + uint16_t sar_width = {}; + uint16_t sar_height = {}; + uint8_t video_format = {}; + uint8_t colour_primaries = {}; + uint8_t transfer_characteristics = {}; + uint8_t matrix_coeffs = {}; + uint8_t chroma_sample_loc_type_top_field = {}; + uint8_t chroma_sample_loc_type_bottom_field = {}; + uint8_t reserved1 = {}; + uint8_t reserved2 = {}; + uint16_t def_disp_win_left_offset = {}; + uint16_t def_disp_win_right_offset = {}; + uint16_t def_disp_win_top_offset = {}; + uint16_t def_disp_win_bottom_offset = {}; + uint32_t vui_num_units_in_tick = {}; + uint32_t vui_time_scale = {}; + uint32_t vui_num_ticks_poc_diff_one_minus1 = {}; + uint16_t min_spatial_segmentation_idc = {}; + uint16_t reserved3 = {}; + uint8_t max_bytes_per_pic_denom = {}; + uint8_t max_bits_per_min_cu_denom = {}; + uint8_t log2_max_mv_length_horizontal = {}; + uint8_t log2_max_mv_length_vertical = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {}; + }; + + struct H265PredictorPaletteEntries + { + using NativeType = StdVideoH265PredictorPaletteEntries; + + operator StdVideoH265PredictorPaletteEntries const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265PredictorPaletteEntries &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265PredictorPaletteEntries const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265PredictorPaletteEntries *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( PredictorPaletteEntries == rhs.PredictorPaletteEntries ); + } + + bool operator!=( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + ArrayWrapper2D + PredictorPaletteEntries = {}; + }; + + struct H265SpsFlags + { + using NativeType = StdVideoH265SpsFlags; + + operator StdVideoH265SpsFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265SpsFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265SpsFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265SpsFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sps_temporal_id_nesting_flag == rhs.sps_temporal_id_nesting_flag ) && ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && + ( conformance_window_flag == rhs.conformance_window_flag ) && + ( sps_sub_layer_ordering_info_present_flag == rhs.sps_sub_layer_ordering_info_present_flag ) && + ( scaling_list_enabled_flag == rhs.scaling_list_enabled_flag ) && + ( sps_scaling_list_data_present_flag == rhs.sps_scaling_list_data_present_flag ) && ( amp_enabled_flag == rhs.amp_enabled_flag ) && + ( sample_adaptive_offset_enabled_flag == rhs.sample_adaptive_offset_enabled_flag ) && ( pcm_enabled_flag == rhs.pcm_enabled_flag ) && + ( pcm_loop_filter_disabled_flag == rhs.pcm_loop_filter_disabled_flag ) && + ( long_term_ref_pics_present_flag == rhs.long_term_ref_pics_present_flag ) && + ( sps_temporal_mvp_enabled_flag == rhs.sps_temporal_mvp_enabled_flag ) && + ( strong_intra_smoothing_enabled_flag == rhs.strong_intra_smoothing_enabled_flag ) && + ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ) && ( sps_extension_present_flag == rhs.sps_extension_present_flag ) && + ( sps_range_extension_flag == rhs.sps_range_extension_flag ) && + ( transform_skip_rotation_enabled_flag == rhs.transform_skip_rotation_enabled_flag ) && + ( transform_skip_context_enabled_flag == rhs.transform_skip_context_enabled_flag ) && + ( implicit_rdpcm_enabled_flag == rhs.implicit_rdpcm_enabled_flag ) && ( explicit_rdpcm_enabled_flag == rhs.explicit_rdpcm_enabled_flag ) && + ( extended_precision_processing_flag == rhs.extended_precision_processing_flag ) && + ( intra_smoothing_disabled_flag == rhs.intra_smoothing_disabled_flag ) && + ( high_precision_offsets_enabled_flag == rhs.high_precision_offsets_enabled_flag ) && + ( persistent_rice_adaptation_enabled_flag == rhs.persistent_rice_adaptation_enabled_flag ) && + ( cabac_bypass_alignment_enabled_flag == rhs.cabac_bypass_alignment_enabled_flag ) && ( sps_scc_extension_flag == rhs.sps_scc_extension_flag ) && + ( sps_curr_pic_ref_enabled_flag == rhs.sps_curr_pic_ref_enabled_flag ) && ( palette_mode_enabled_flag == rhs.palette_mode_enabled_flag ) && + ( sps_palette_predictor_initializers_present_flag == rhs.sps_palette_predictor_initializers_present_flag ) && + ( intra_boundary_filtering_disabled_flag == rhs.intra_boundary_filtering_disabled_flag ); + } + + bool operator!=( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t sps_temporal_id_nesting_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t conformance_window_flag : 1; + uint32_t sps_sub_layer_ordering_info_present_flag : 1; + uint32_t scaling_list_enabled_flag : 1; + uint32_t sps_scaling_list_data_present_flag : 1; + uint32_t amp_enabled_flag : 1; + uint32_t sample_adaptive_offset_enabled_flag : 1; + uint32_t pcm_enabled_flag : 1; + uint32_t pcm_loop_filter_disabled_flag : 1; + uint32_t long_term_ref_pics_present_flag : 1; + uint32_t sps_temporal_mvp_enabled_flag : 1; + uint32_t strong_intra_smoothing_enabled_flag : 1; + uint32_t vui_parameters_present_flag : 1; + uint32_t sps_extension_present_flag : 1; + uint32_t sps_range_extension_flag : 1; + uint32_t transform_skip_rotation_enabled_flag : 1; + uint32_t transform_skip_context_enabled_flag : 1; + uint32_t implicit_rdpcm_enabled_flag : 1; + uint32_t explicit_rdpcm_enabled_flag : 1; + uint32_t extended_precision_processing_flag : 1; + uint32_t intra_smoothing_disabled_flag : 1; + uint32_t high_precision_offsets_enabled_flag : 1; + uint32_t persistent_rice_adaptation_enabled_flag : 1; + uint32_t cabac_bypass_alignment_enabled_flag : 1; + uint32_t sps_scc_extension_flag : 1; + uint32_t sps_curr_pic_ref_enabled_flag : 1; + uint32_t palette_mode_enabled_flag : 1; + uint32_t sps_palette_predictor_initializers_present_flag : 1; + uint32_t intra_boundary_filtering_disabled_flag : 1; + }; + + struct H265ShortTermRefPicSetFlags + { + using NativeType = StdVideoH265ShortTermRefPicSetFlags; + + operator StdVideoH265ShortTermRefPicSetFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265ShortTermRefPicSetFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265ShortTermRefPicSetFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265ShortTermRefPicSetFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( inter_ref_pic_set_prediction_flag == rhs.inter_ref_pic_set_prediction_flag ) && ( delta_rps_sign == rhs.delta_rps_sign ); + } + + bool operator!=( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t inter_ref_pic_set_prediction_flag : 1; + uint32_t delta_rps_sign : 1; + }; + + struct H265ShortTermRefPicSet + { + using NativeType = StdVideoH265ShortTermRefPicSet; + + operator StdVideoH265ShortTermRefPicSet const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265ShortTermRefPicSet &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265ShortTermRefPicSet const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265ShortTermRefPicSet *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( delta_idx_minus1 == rhs.delta_idx_minus1 ) && ( use_delta_flag == rhs.use_delta_flag ) && + ( abs_delta_rps_minus1 == rhs.abs_delta_rps_minus1 ) && ( used_by_curr_pic_flag == rhs.used_by_curr_pic_flag ) && + ( used_by_curr_pic_s0_flag == rhs.used_by_curr_pic_s0_flag ) && ( used_by_curr_pic_s1_flag == rhs.used_by_curr_pic_s1_flag ) && + ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( reserved3 == rhs.reserved3 ) && + ( num_negative_pics == rhs.num_negative_pics ) && ( num_positive_pics == rhs.num_positive_pics ) && + ( delta_poc_s0_minus1 == rhs.delta_poc_s0_minus1 ) && ( delta_poc_s1_minus1 == rhs.delta_poc_s1_minus1 ); + } + + bool operator!=( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags flags = {}; + uint32_t delta_idx_minus1 = {}; + uint16_t use_delta_flag = {}; + uint16_t abs_delta_rps_minus1 = {}; + uint16_t used_by_curr_pic_flag = {}; + uint16_t used_by_curr_pic_s0_flag = {}; + uint16_t used_by_curr_pic_s1_flag = {}; + uint16_t reserved1 = {}; + uint8_t reserved2 = {}; + uint8_t reserved3 = {}; + uint8_t num_negative_pics = {}; + uint8_t num_positive_pics = {}; + ArrayWrapper1D delta_poc_s0_minus1 = {}; + ArrayWrapper1D delta_poc_s1_minus1 = {}; + }; + + struct H265LongTermRefPicsSps + { + using NativeType = StdVideoH265LongTermRefPicsSps; + + operator StdVideoH265LongTermRefPicsSps const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265LongTermRefPicsSps &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265LongTermRefPicsSps const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265LongTermRefPicsSps *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( used_by_curr_pic_lt_sps_flag == rhs.used_by_curr_pic_lt_sps_flag ) && ( lt_ref_pic_poc_lsb_sps == rhs.lt_ref_pic_poc_lsb_sps ); + } + + bool operator!=( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t used_by_curr_pic_lt_sps_flag = {}; + ArrayWrapper1D lt_ref_pic_poc_lsb_sps = {}; + }; + + struct H265SequenceParameterSet + { + using NativeType = StdVideoH265SequenceParameterSet; + + operator StdVideoH265SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265SequenceParameterSet &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265SequenceParameterSet const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265SequenceParameterSet *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( chroma_format_idc == rhs.chroma_format_idc ) && ( pic_width_in_luma_samples == rhs.pic_width_in_luma_samples ) && + ( pic_height_in_luma_samples == rhs.pic_height_in_luma_samples ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && + ( sps_max_sub_layers_minus1 == rhs.sps_max_sub_layers_minus1 ) && ( sps_seq_parameter_set_id == rhs.sps_seq_parameter_set_id ) && + ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && + ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && + ( log2_min_luma_coding_block_size_minus3 == rhs.log2_min_luma_coding_block_size_minus3 ) && + ( log2_diff_max_min_luma_coding_block_size == rhs.log2_diff_max_min_luma_coding_block_size ) && + ( log2_min_luma_transform_block_size_minus2 == rhs.log2_min_luma_transform_block_size_minus2 ) && + ( log2_diff_max_min_luma_transform_block_size == rhs.log2_diff_max_min_luma_transform_block_size ) && + ( max_transform_hierarchy_depth_inter == rhs.max_transform_hierarchy_depth_inter ) && + ( max_transform_hierarchy_depth_intra == rhs.max_transform_hierarchy_depth_intra ) && + ( num_short_term_ref_pic_sets == rhs.num_short_term_ref_pic_sets ) && ( num_long_term_ref_pics_sps == rhs.num_long_term_ref_pics_sps ) && + ( pcm_sample_bit_depth_luma_minus1 == rhs.pcm_sample_bit_depth_luma_minus1 ) && + ( pcm_sample_bit_depth_chroma_minus1 == rhs.pcm_sample_bit_depth_chroma_minus1 ) && + ( log2_min_pcm_luma_coding_block_size_minus3 == rhs.log2_min_pcm_luma_coding_block_size_minus3 ) && + ( log2_diff_max_min_pcm_luma_coding_block_size == rhs.log2_diff_max_min_pcm_luma_coding_block_size ) && ( reserved1 == rhs.reserved1 ) && + ( reserved2 == rhs.reserved2 ) && ( palette_max_size == rhs.palette_max_size ) && + ( delta_palette_max_predictor_size == rhs.delta_palette_max_predictor_size ) && + ( motion_vector_resolution_control_idc == rhs.motion_vector_resolution_control_idc ) && + ( sps_num_palette_predictor_initializers_minus1 == rhs.sps_num_palette_predictor_initializers_minus1 ) && + ( conf_win_left_offset == rhs.conf_win_left_offset ) && ( conf_win_right_offset == rhs.conf_win_right_offset ) && + ( conf_win_top_offset == rhs.conf_win_top_offset ) && ( conf_win_bottom_offset == rhs.conf_win_bottom_offset ) && + ( pProfileTierLevel == rhs.pProfileTierLevel ) && ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pScalingLists == rhs.pScalingLists ) && + ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPicsSps == rhs.pLongTermRefPicsSps ) && + ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ) && ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); + } + + bool operator!=( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc chroma_format_idc = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc::eMonochrome; + uint32_t pic_width_in_luma_samples = {}; + uint32_t pic_height_in_luma_samples = {}; + uint8_t sps_video_parameter_set_id = {}; + uint8_t sps_max_sub_layers_minus1 = {}; + uint8_t sps_seq_parameter_set_id = {}; + uint8_t bit_depth_luma_minus8 = {}; + uint8_t bit_depth_chroma_minus8 = {}; + uint8_t log2_max_pic_order_cnt_lsb_minus4 = {}; + uint8_t log2_min_luma_coding_block_size_minus3 = {}; + uint8_t log2_diff_max_min_luma_coding_block_size = {}; + uint8_t log2_min_luma_transform_block_size_minus2 = {}; + uint8_t log2_diff_max_min_luma_transform_block_size = {}; + uint8_t max_transform_hierarchy_depth_inter = {}; + uint8_t max_transform_hierarchy_depth_intra = {}; + uint8_t num_short_term_ref_pic_sets = {}; + uint8_t num_long_term_ref_pics_sps = {}; + uint8_t pcm_sample_bit_depth_luma_minus1 = {}; + uint8_t pcm_sample_bit_depth_chroma_minus1 = {}; + uint8_t log2_min_pcm_luma_coding_block_size_minus3 = {}; + uint8_t log2_diff_max_min_pcm_luma_coding_block_size = {}; + uint8_t reserved1 = {}; + uint8_t reserved2 = {}; + uint8_t palette_max_size = {}; + uint8_t delta_palette_max_predictor_size = {}; + uint8_t motion_vector_resolution_control_idc = {}; + uint8_t sps_num_palette_predictor_initializers_minus1 = {}; + uint32_t conf_win_left_offset = {}; + uint32_t conf_win_right_offset = {}; + uint32_t conf_win_top_offset = {}; + uint32_t conf_win_bottom_offset = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps * pLongTermRefPicsSps = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui * pSequenceParameterSetVui = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {}; + }; + + struct H265PpsFlags + { + using NativeType = StdVideoH265PpsFlags; + + operator StdVideoH265PpsFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265PpsFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265PpsFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265PpsFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( dependent_slice_segments_enabled_flag == rhs.dependent_slice_segments_enabled_flag ) && + ( output_flag_present_flag == rhs.output_flag_present_flag ) && ( sign_data_hiding_enabled_flag == rhs.sign_data_hiding_enabled_flag ) && + ( cabac_init_present_flag == rhs.cabac_init_present_flag ) && ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && + ( transform_skip_enabled_flag == rhs.transform_skip_enabled_flag ) && ( cu_qp_delta_enabled_flag == rhs.cu_qp_delta_enabled_flag ) && + ( pps_slice_chroma_qp_offsets_present_flag == rhs.pps_slice_chroma_qp_offsets_present_flag ) && + ( weighted_pred_flag == rhs.weighted_pred_flag ) && ( weighted_bipred_flag == rhs.weighted_bipred_flag ) && + ( transquant_bypass_enabled_flag == rhs.transquant_bypass_enabled_flag ) && ( tiles_enabled_flag == rhs.tiles_enabled_flag ) && + ( entropy_coding_sync_enabled_flag == rhs.entropy_coding_sync_enabled_flag ) && ( uniform_spacing_flag == rhs.uniform_spacing_flag ) && + ( loop_filter_across_tiles_enabled_flag == rhs.loop_filter_across_tiles_enabled_flag ) && + ( pps_loop_filter_across_slices_enabled_flag == rhs.pps_loop_filter_across_slices_enabled_flag ) && + ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && + ( deblocking_filter_override_enabled_flag == rhs.deblocking_filter_override_enabled_flag ) && + ( pps_deblocking_filter_disabled_flag == rhs.pps_deblocking_filter_disabled_flag ) && + ( pps_scaling_list_data_present_flag == rhs.pps_scaling_list_data_present_flag ) && + ( lists_modification_present_flag == rhs.lists_modification_present_flag ) && + ( slice_segment_header_extension_present_flag == rhs.slice_segment_header_extension_present_flag ) && + ( pps_extension_present_flag == rhs.pps_extension_present_flag ) && + ( cross_component_prediction_enabled_flag == rhs.cross_component_prediction_enabled_flag ) && + ( chroma_qp_offset_list_enabled_flag == rhs.chroma_qp_offset_list_enabled_flag ) && + ( pps_curr_pic_ref_enabled_flag == rhs.pps_curr_pic_ref_enabled_flag ) && + ( residual_adaptive_colour_transform_enabled_flag == rhs.residual_adaptive_colour_transform_enabled_flag ) && + ( pps_slice_act_qp_offsets_present_flag == rhs.pps_slice_act_qp_offsets_present_flag ) && + ( pps_palette_predictor_initializers_present_flag == rhs.pps_palette_predictor_initializers_present_flag ) && + ( monochrome_palette_flag == rhs.monochrome_palette_flag ) && ( pps_range_extension_flag == rhs.pps_range_extension_flag ); + } + + bool operator!=( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t dependent_slice_segments_enabled_flag : 1; + uint32_t output_flag_present_flag : 1; + uint32_t sign_data_hiding_enabled_flag : 1; + uint32_t cabac_init_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t transform_skip_enabled_flag : 1; + uint32_t cu_qp_delta_enabled_flag : 1; + uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t weighted_bipred_flag : 1; + uint32_t transquant_bypass_enabled_flag : 1; + uint32_t tiles_enabled_flag : 1; + uint32_t entropy_coding_sync_enabled_flag : 1; + uint32_t uniform_spacing_flag : 1; + uint32_t loop_filter_across_tiles_enabled_flag : 1; + uint32_t pps_loop_filter_across_slices_enabled_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t deblocking_filter_override_enabled_flag : 1; + uint32_t pps_deblocking_filter_disabled_flag : 1; + uint32_t pps_scaling_list_data_present_flag : 1; + uint32_t lists_modification_present_flag : 1; + uint32_t slice_segment_header_extension_present_flag : 1; + uint32_t pps_extension_present_flag : 1; + uint32_t cross_component_prediction_enabled_flag : 1; + uint32_t chroma_qp_offset_list_enabled_flag : 1; + uint32_t pps_curr_pic_ref_enabled_flag : 1; + uint32_t residual_adaptive_colour_transform_enabled_flag : 1; + uint32_t pps_slice_act_qp_offsets_present_flag : 1; + uint32_t pps_palette_predictor_initializers_present_flag : 1; + uint32_t monochrome_palette_flag : 1; + uint32_t pps_range_extension_flag : 1; + }; + + struct H265PictureParameterSet + { + using NativeType = StdVideoH265PictureParameterSet; + + operator StdVideoH265PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265PictureParameterSet &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoH265PictureParameterSet const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoH265PictureParameterSet *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && + ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && + ( num_extra_slice_header_bits == rhs.num_extra_slice_header_bits ) && + ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && + ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( init_qp_minus26 == rhs.init_qp_minus26 ) && + ( diff_cu_qp_delta_depth == rhs.diff_cu_qp_delta_depth ) && ( pps_cb_qp_offset == rhs.pps_cb_qp_offset ) && + ( pps_cr_qp_offset == rhs.pps_cr_qp_offset ) && ( pps_beta_offset_div2 == rhs.pps_beta_offset_div2 ) && + ( pps_tc_offset_div2 == rhs.pps_tc_offset_div2 ) && ( log2_parallel_merge_level_minus2 == rhs.log2_parallel_merge_level_minus2 ) && + ( log2_max_transform_skip_block_size_minus2 == rhs.log2_max_transform_skip_block_size_minus2 ) && + ( diff_cu_chroma_qp_offset_depth == rhs.diff_cu_chroma_qp_offset_depth ) && + ( chroma_qp_offset_list_len_minus1 == rhs.chroma_qp_offset_list_len_minus1 ) && ( cb_qp_offset_list == rhs.cb_qp_offset_list ) && + ( cr_qp_offset_list == rhs.cr_qp_offset_list ) && ( log2_sao_offset_scale_luma == rhs.log2_sao_offset_scale_luma ) && + ( log2_sao_offset_scale_chroma == rhs.log2_sao_offset_scale_chroma ) && ( pps_act_y_qp_offset_plus5 == rhs.pps_act_y_qp_offset_plus5 ) && + ( pps_act_cb_qp_offset_plus5 == rhs.pps_act_cb_qp_offset_plus5 ) && ( pps_act_cr_qp_offset_plus3 == rhs.pps_act_cr_qp_offset_plus3 ) && + ( pps_num_palette_predictor_initializers == rhs.pps_num_palette_predictor_initializers ) && + ( luma_bit_depth_entry_minus8 == rhs.luma_bit_depth_entry_minus8 ) && ( chroma_bit_depth_entry_minus8 == rhs.chroma_bit_depth_entry_minus8 ) && + ( num_tile_columns_minus1 == rhs.num_tile_columns_minus1 ) && ( num_tile_rows_minus1 == rhs.num_tile_rows_minus1 ) && + ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( column_width_minus1 == rhs.column_width_minus1 ) && + ( row_height_minus1 == rhs.row_height_minus1 ) && ( reserved3 == rhs.reserved3 ) && ( pScalingLists == rhs.pScalingLists ) && + ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); + } + + bool operator!=( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags flags = {}; + uint8_t pps_pic_parameter_set_id = {}; + uint8_t pps_seq_parameter_set_id = {}; + uint8_t sps_video_parameter_set_id = {}; + uint8_t num_extra_slice_header_bits = {}; + uint8_t num_ref_idx_l0_default_active_minus1 = {}; + uint8_t num_ref_idx_l1_default_active_minus1 = {}; + int8_t init_qp_minus26 = {}; + uint8_t diff_cu_qp_delta_depth = {}; + int8_t pps_cb_qp_offset = {}; + int8_t pps_cr_qp_offset = {}; + int8_t pps_beta_offset_div2 = {}; + int8_t pps_tc_offset_div2 = {}; + uint8_t log2_parallel_merge_level_minus2 = {}; + uint8_t log2_max_transform_skip_block_size_minus2 = {}; + uint8_t diff_cu_chroma_qp_offset_depth = {}; + uint8_t chroma_qp_offset_list_len_minus1 = {}; + ArrayWrapper1D cb_qp_offset_list = {}; + ArrayWrapper1D cr_qp_offset_list = {}; + uint8_t log2_sao_offset_scale_luma = {}; + uint8_t log2_sao_offset_scale_chroma = {}; + int8_t pps_act_y_qp_offset_plus5 = {}; + int8_t pps_act_cb_qp_offset_plus5 = {}; + int8_t pps_act_cr_qp_offset_plus3 = {}; + uint8_t pps_num_palette_predictor_initializers = {}; + uint8_t luma_bit_depth_entry_minus8 = {}; + uint8_t chroma_bit_depth_entry_minus8 = {}; + uint8_t num_tile_columns_minus1 = {}; + uint8_t num_tile_rows_minus1 = {}; + uint8_t reserved1 = {}; + uint8_t reserved2 = {}; + ArrayWrapper1D column_width_minus1 = {}; + ArrayWrapper1D row_height_minus1 = {}; + uint32_t reserved3 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {}; + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ ) + //=== vulkan_video_codec_h265std_decode === + + struct DecodeH265PictureInfoFlags + { + using NativeType = StdVideoDecodeH265PictureInfoFlags; + + operator StdVideoDecodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH265PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeH265PictureInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( IrapPicFlag == rhs.IrapPicFlag ) && ( IdrPicFlag == rhs.IdrPicFlag ) && ( IsReference == rhs.IsReference ) && + ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ); + } + + bool operator!=( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t IrapPicFlag : 1; + uint32_t IdrPicFlag : 1; + uint32_t IsReference : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; + }; + + struct DecodeH265PictureInfo + { + using NativeType = StdVideoDecodeH265PictureInfo; + + operator StdVideoDecodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH265PictureInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeH265PictureInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && + ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && + ( NumDeltaPocsOfRefRpsIdx == rhs.NumDeltaPocsOfRefRpsIdx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && + ( NumBitsForSTRefPicSetInSlice == rhs.NumBitsForSTRefPicSetInSlice ) && ( reserved == rhs.reserved ) && + ( RefPicSetStCurrBefore == rhs.RefPicSetStCurrBefore ) && ( RefPicSetStCurrAfter == rhs.RefPicSetStCurrAfter ) && + ( RefPicSetLtCurr == rhs.RefPicSetLtCurr ); + } + + bool operator!=( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags flags = {}; + uint8_t sps_video_parameter_set_id = {}; + uint8_t pps_seq_parameter_set_id = {}; + uint8_t pps_pic_parameter_set_id = {}; + uint8_t NumDeltaPocsOfRefRpsIdx = {}; + int32_t PicOrderCntVal = {}; + uint16_t NumBitsForSTRefPicSetInSlice = {}; + uint16_t reserved = {}; + ArrayWrapper1D RefPicSetStCurrBefore = {}; + ArrayWrapper1D RefPicSetStCurrAfter = {}; + ArrayWrapper1D RefPicSetLtCurr = {}; + }; + + struct DecodeH265ReferenceInfoFlags + { + using NativeType = StdVideoDecodeH265ReferenceInfoFlags; + + operator StdVideoDecodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH265ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeH265ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ); + } + + bool operator!=( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t used_for_long_term_reference : 1; + uint32_t unused_for_reference : 1; + }; + + struct DecodeH265ReferenceInfo + { + using NativeType = StdVideoDecodeH265ReferenceInfo; + + operator StdVideoDecodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeH265ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeH265ReferenceInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( PicOrderCntVal == rhs.PicOrderCntVal ); + } + + bool operator!=( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags flags = {}; + int32_t PicOrderCntVal = {}; + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ ) + //=== vulkan_video_codec_h265std_encode === + + struct EncodeH265WeightTableFlags + { + using NativeType = StdVideoEncodeH265WeightTableFlags; + + operator StdVideoEncodeH265WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265WeightTableFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265WeightTableFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH265WeightTableFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && + ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); + } + + bool operator!=( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint16_t luma_weight_l0_flag = {}; + uint16_t chroma_weight_l0_flag = {}; + uint16_t luma_weight_l1_flag = {}; + uint16_t chroma_weight_l1_flag = {}; + }; + + struct EncodeH265WeightTable + { + using NativeType = StdVideoEncodeH265WeightTable; + + operator StdVideoEncodeH265WeightTable const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265WeightTable &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265WeightTable const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH265WeightTable *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && + ( delta_chroma_log2_weight_denom == rhs.delta_chroma_log2_weight_denom ) && ( delta_luma_weight_l0 == rhs.delta_luma_weight_l0 ) && + ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( delta_chroma_weight_l0 == rhs.delta_chroma_weight_l0 ) && + ( delta_chroma_offset_l0 == rhs.delta_chroma_offset_l0 ) && ( delta_luma_weight_l1 == rhs.delta_luma_weight_l1 ) && + ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( delta_chroma_weight_l1 == rhs.delta_chroma_weight_l1 ) && + ( delta_chroma_offset_l1 == rhs.delta_chroma_offset_l1 ); + } + + bool operator!=( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags flags = {}; + uint8_t luma_log2_weight_denom = {}; + int8_t delta_chroma_log2_weight_denom = {}; + ArrayWrapper1D delta_luma_weight_l0 = {}; + ArrayWrapper1D luma_offset_l0 = {}; + ArrayWrapper2D delta_chroma_weight_l0 = {}; + ArrayWrapper2D delta_chroma_offset_l0 = {}; + ArrayWrapper1D delta_luma_weight_l1 = {}; + ArrayWrapper1D luma_offset_l1 = {}; + ArrayWrapper2D delta_chroma_weight_l1 = {}; + ArrayWrapper2D delta_chroma_offset_l1 = {}; + }; + + struct EncodeH265SliceSegmentHeaderFlags + { + using NativeType = StdVideoEncodeH265SliceSegmentHeaderFlags; + + operator StdVideoEncodeH265SliceSegmentHeaderFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265SliceSegmentHeaderFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265SliceSegmentHeaderFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH265SliceSegmentHeaderFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( first_slice_segment_in_pic_flag == rhs.first_slice_segment_in_pic_flag ) && + ( dependent_slice_segment_flag == rhs.dependent_slice_segment_flag ) && ( slice_sao_luma_flag == rhs.slice_sao_luma_flag ) && + ( slice_sao_chroma_flag == rhs.slice_sao_chroma_flag ) && ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && + ( mvd_l1_zero_flag == rhs.mvd_l1_zero_flag ) && ( cabac_init_flag == rhs.cabac_init_flag ) && + ( cu_chroma_qp_offset_enabled_flag == rhs.cu_chroma_qp_offset_enabled_flag ) && + ( deblocking_filter_override_flag == rhs.deblocking_filter_override_flag ) && + ( slice_deblocking_filter_disabled_flag == rhs.slice_deblocking_filter_disabled_flag ) && + ( collocated_from_l0_flag == rhs.collocated_from_l0_flag ) && + ( slice_loop_filter_across_slices_enabled_flag == rhs.slice_loop_filter_across_slices_enabled_flag ) && ( reserved == rhs.reserved ); + } + + bool operator!=( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t first_slice_segment_in_pic_flag : 1; + uint32_t dependent_slice_segment_flag : 1; + uint32_t slice_sao_luma_flag : 1; + uint32_t slice_sao_chroma_flag : 1; + uint32_t num_ref_idx_active_override_flag : 1; + uint32_t mvd_l1_zero_flag : 1; + uint32_t cabac_init_flag : 1; + uint32_t cu_chroma_qp_offset_enabled_flag : 1; + uint32_t deblocking_filter_override_flag : 1; + uint32_t slice_deblocking_filter_disabled_flag : 1; + uint32_t collocated_from_l0_flag : 1; + uint32_t slice_loop_filter_across_slices_enabled_flag : 1; + uint32_t reserved : 20; + }; + + struct EncodeH265SliceSegmentHeader + { + using NativeType = StdVideoEncodeH265SliceSegmentHeader; + + operator StdVideoEncodeH265SliceSegmentHeader const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265SliceSegmentHeader &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265SliceSegmentHeader const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH265SliceSegmentHeader *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( slice_type == rhs.slice_type ) && ( slice_segment_address == rhs.slice_segment_address ) && + ( collocated_ref_idx == rhs.collocated_ref_idx ) && ( MaxNumMergeCand == rhs.MaxNumMergeCand ) && + ( slice_cb_qp_offset == rhs.slice_cb_qp_offset ) && ( slice_cr_qp_offset == rhs.slice_cr_qp_offset ) && + ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && ( slice_tc_offset_div2 == rhs.slice_tc_offset_div2 ) && + ( slice_act_y_qp_offset == rhs.slice_act_y_qp_offset ) && ( slice_act_cb_qp_offset == rhs.slice_act_cb_qp_offset ) && + ( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && + ( pWeightTable == rhs.pWeightTable ); + } + + bool operator!=( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType::eB; + uint32_t slice_segment_address = {}; + uint8_t collocated_ref_idx = {}; + uint8_t MaxNumMergeCand = {}; + int8_t slice_cb_qp_offset = {}; + int8_t slice_cr_qp_offset = {}; + int8_t slice_beta_offset_div2 = {}; + int8_t slice_tc_offset_div2 = {}; + int8_t slice_act_y_qp_offset = {}; + int8_t slice_act_cb_qp_offset = {}; + int8_t slice_act_cr_qp_offset = {}; + int8_t slice_qp_delta = {}; + uint16_t reserved1 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable * pWeightTable = {}; + }; + + struct EncodeH265ReferenceListsInfoFlags + { + using NativeType = StdVideoEncodeH265ReferenceListsInfoFlags; + + operator StdVideoEncodeH265ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceListsInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceListsInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && + ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); + } + + bool operator!=( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t ref_pic_list_modification_flag_l0 : 1; + uint32_t ref_pic_list_modification_flag_l1 : 1; + uint32_t reserved : 30; + }; + + struct EncodeH265ReferenceListsInfo + { + using NativeType = StdVideoEncodeH265ReferenceListsInfo; + + operator StdVideoEncodeH265ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceListsInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceListsInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && + ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && + ( RefPicList1 == rhs.RefPicList1 ) && ( list_entry_l0 == rhs.list_entry_l0 ) && ( list_entry_l1 == rhs.list_entry_l1 ); + } + + bool operator!=( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags flags = {}; + uint8_t num_ref_idx_l0_active_minus1 = {}; + uint8_t num_ref_idx_l1_active_minus1 = {}; + ArrayWrapper1D RefPicList0 = {}; + ArrayWrapper1D RefPicList1 = {}; + ArrayWrapper1D list_entry_l0 = {}; + ArrayWrapper1D list_entry_l1 = {}; + }; + + struct EncodeH265PictureInfoFlags + { + using NativeType = StdVideoEncodeH265PictureInfoFlags; + + operator StdVideoEncodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH265PictureInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( is_reference == rhs.is_reference ) && ( IrapPicFlag == rhs.IrapPicFlag ) && + ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( discardable_flag == rhs.discardable_flag ) && + ( cross_layer_bla_flag == rhs.cross_layer_bla_flag ) && ( pic_output_flag == rhs.pic_output_flag ) && + ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && + ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ) && + ( slice_temporal_mvp_enabled_flag == rhs.slice_temporal_mvp_enabled_flag ) && ( reserved == rhs.reserved ); + } + + bool operator!=( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t is_reference : 1; + uint32_t IrapPicFlag : 1; + uint32_t used_for_long_term_reference : 1; + uint32_t discardable_flag : 1; + uint32_t cross_layer_bla_flag : 1; + uint32_t pic_output_flag : 1; + uint32_t no_output_of_prior_pics_flag : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; + uint32_t slice_temporal_mvp_enabled_flag : 1; + uint32_t reserved : 23; + }; + + struct EncodeH265LongTermRefPics + { + using NativeType = StdVideoEncodeH265LongTermRefPics; + + operator StdVideoEncodeH265LongTermRefPics const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265LongTermRefPics &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265LongTermRefPics const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH265LongTermRefPics *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( num_long_term_sps == rhs.num_long_term_sps ) && ( num_long_term_pics == rhs.num_long_term_pics ) && ( lt_idx_sps == rhs.lt_idx_sps ) && + ( poc_lsb_lt == rhs.poc_lsb_lt ) && ( used_by_curr_pic_lt_flag == rhs.used_by_curr_pic_lt_flag ) && + ( delta_poc_msb_present_flag == rhs.delta_poc_msb_present_flag ) && ( delta_poc_msb_cycle_lt == rhs.delta_poc_msb_cycle_lt ); + } + + bool operator!=( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint8_t num_long_term_sps = {}; + uint8_t num_long_term_pics = {}; + ArrayWrapper1D lt_idx_sps = {}; + ArrayWrapper1D poc_lsb_lt = {}; + uint16_t used_by_curr_pic_lt_flag = {}; + ArrayWrapper1D delta_poc_msb_present_flag = {}; + ArrayWrapper1D delta_poc_msb_cycle_lt = {}; + }; + + struct EncodeH265PictureInfo + { + using NativeType = StdVideoEncodeH265PictureInfo; + + operator StdVideoEncodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265PictureInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH265PictureInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && + ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && + ( short_term_ref_pic_set_idx == rhs.short_term_ref_pic_set_idx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && + ( TemporalId == rhs.TemporalId ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ) && + ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPics == rhs.pLongTermRefPics ); + } + + bool operator!=( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP; + uint8_t sps_video_parameter_set_id = {}; + uint8_t pps_seq_parameter_set_id = {}; + uint8_t pps_pic_parameter_set_id = {}; + uint8_t short_term_ref_pic_set_idx = {}; + int32_t PicOrderCntVal = {}; + uint8_t TemporalId = {}; + ArrayWrapper1D reserved1 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics * pLongTermRefPics = {}; + }; + + struct EncodeH265ReferenceInfoFlags + { + using NativeType = StdVideoEncodeH265ReferenceInfoFlags; + + operator StdVideoEncodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ) && + ( reserved == rhs.reserved ); + } + + bool operator!=( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t used_for_long_term_reference : 1; + uint32_t unused_for_reference : 1; + uint32_t reserved : 30; + }; + + struct EncodeH265ReferenceInfo + { + using NativeType = StdVideoEncodeH265ReferenceInfo; + + operator StdVideoEncodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeH265ReferenceInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && ( TemporalId == rhs.TemporalId ); + } + + bool operator!=( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP; + int32_t PicOrderCntVal = {}; + uint8_t TemporalId = {}; + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) + //=== vulkan_video_codec_vp9std === + + struct VP9ColorConfigFlags + { + using NativeType = StdVideoVP9ColorConfigFlags; + + operator StdVideoVP9ColorConfigFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9ColorConfigFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9ColorConfigFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoVP9ColorConfigFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( VP9ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( color_range == rhs.color_range ) && ( reserved == rhs.reserved ); + } + + bool operator!=( VP9ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t color_range : 1; + uint32_t reserved : 31; + }; + + struct VP9ColorConfig + { + using NativeType = StdVideoVP9ColorConfig; + + operator StdVideoVP9ColorConfig const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9ColorConfig &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9ColorConfig const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoVP9ColorConfig *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) && + ( reserved1 == rhs.reserved1 ) && ( color_space == rhs.color_space ); + } + + bool operator!=( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags flags = {}; + uint8_t BitDepth = {}; + uint8_t subsampling_x = {}; + uint8_t subsampling_y = {}; + uint8_t reserved1 = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace color_space = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace::eUnknown; + }; + + struct VP9LoopFilterFlags + { + using NativeType = StdVideoVP9LoopFilterFlags; + + operator StdVideoVP9LoopFilterFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9LoopFilterFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9LoopFilterFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoVP9LoopFilterFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( VP9LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) && + ( reserved == rhs.reserved ); + } + + bool operator!=( VP9LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t loop_filter_delta_enabled : 1; + uint32_t loop_filter_delta_update : 1; + uint32_t reserved : 30; + }; + + struct VP9LoopFilter + { + using NativeType = StdVideoVP9LoopFilter; + + operator StdVideoVP9LoopFilter const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9LoopFilter &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9LoopFilter const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoVP9LoopFilter *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) && + ( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) && + ( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas ); + } + + bool operator!=( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags flags = {}; + uint8_t loop_filter_level = {}; + uint8_t loop_filter_sharpness = {}; + uint8_t update_ref_delta = {}; + ArrayWrapper1D loop_filter_ref_deltas = {}; + uint8_t update_mode_delta = {}; + ArrayWrapper1D loop_filter_mode_deltas = {}; + }; + + struct VP9SegmentationFlags + { + using NativeType = StdVideoVP9SegmentationFlags; + + operator StdVideoVP9SegmentationFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9SegmentationFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9SegmentationFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoVP9SegmentationFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( VP9SegmentationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( segmentation_update_map == rhs.segmentation_update_map ) && ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && + ( segmentation_update_data == rhs.segmentation_update_data ) && ( segmentation_abs_or_delta_update == rhs.segmentation_abs_or_delta_update ) && + ( reserved == rhs.reserved ); + } + + bool operator!=( VP9SegmentationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t segmentation_update_map : 1; + uint32_t segmentation_temporal_update : 1; + uint32_t segmentation_update_data : 1; + uint32_t segmentation_abs_or_delta_update : 1; + uint32_t reserved : 28; + }; + + struct VP9Segmentation + { + using NativeType = StdVideoVP9Segmentation; + + operator StdVideoVP9Segmentation const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9Segmentation &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoVP9Segmentation const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoVP9Segmentation *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( segmentation_tree_probs == rhs.segmentation_tree_probs ) && + ( segmentation_pred_prob == rhs.segmentation_pred_prob ) && ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData ); + } + + bool operator!=( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags flags = {}; + ArrayWrapper1D segmentation_tree_probs = {}; + ArrayWrapper1D segmentation_pred_prob = {}; + ArrayWrapper1D FeatureEnabled = {}; + ArrayWrapper2D FeatureData = {}; + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ ) + //=== vulkan_video_codec_vp9std_decode === + + struct DecodeVP9PictureInfoFlags + { + using NativeType = StdVideoDecodeVP9PictureInfoFlags; + + operator StdVideoDecodeVP9PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeVP9PictureInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeVP9PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeVP9PictureInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( error_resilient_mode == rhs.error_resilient_mode ) && ( intra_only == rhs.intra_only ) && + ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && ( refresh_frame_context == rhs.refresh_frame_context ) && + ( frame_parallel_decoding_mode == rhs.frame_parallel_decoding_mode ) && ( segmentation_enabled == rhs.segmentation_enabled ) && + ( show_frame == rhs.show_frame ) && ( UsePrevFrameMvs == rhs.UsePrevFrameMvs ) && ( reserved == rhs.reserved ); + } + + bool operator!=( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t error_resilient_mode : 1; + uint32_t intra_only : 1; + uint32_t allow_high_precision_mv : 1; + uint32_t refresh_frame_context : 1; + uint32_t frame_parallel_decoding_mode : 1; + uint32_t segmentation_enabled : 1; + uint32_t show_frame : 1; + uint32_t UsePrevFrameMvs : 1; + uint32_t reserved : 24; + }; + + struct DecodeVP9PictureInfo + { + using NativeType = StdVideoDecodeVP9PictureInfo; + + operator StdVideoDecodeVP9PictureInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeVP9PictureInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeVP9PictureInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeVP9PictureInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeVP9PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( profile == rhs.profile ) && ( frame_type == rhs.frame_type ) && ( frame_context_idx == rhs.frame_context_idx ) && + ( reset_frame_context == rhs.reset_frame_context ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) && + ( ref_frame_sign_bias_mask == rhs.ref_frame_sign_bias_mask ) && ( interpolation_filter == rhs.interpolation_filter ) && + ( base_q_idx == rhs.base_q_idx ) && ( delta_q_y_dc == rhs.delta_q_y_dc ) && ( delta_q_uv_dc == rhs.delta_q_uv_dc ) && + ( delta_q_uv_ac == rhs.delta_q_uv_ac ) && ( tile_cols_log2 == rhs.tile_cols_log2 ) && ( tile_rows_log2 == rhs.tile_rows_log2 ) && + ( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pLoopFilter == rhs.pLoopFilter ) && + ( pSegmentation == rhs.pSegmentation ); + } + + bool operator!=( DecodeVP9PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile profile = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile::e0; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType::eKey; + uint8_t frame_context_idx = {}; + uint8_t reset_frame_context = {}; + uint8_t refresh_frame_flags = {}; + uint8_t ref_frame_sign_bias_mask = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter interpolation_filter = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter::eEighttap; + uint8_t base_q_idx = {}; + int8_t delta_q_y_dc = {}; + int8_t delta_q_uv_dc = {}; + int8_t delta_q_uv_ac = {}; + uint8_t tile_cols_log2 = {}; + uint8_t tile_rows_log2 = {}; + ArrayWrapper1D reserved1 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig * pColorConfig = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter * pLoopFilter = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation * pSegmentation = {}; + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) + //=== vulkan_video_codec_av1std === + + struct AV1ColorConfigFlags + { + using NativeType = StdVideoAV1ColorConfigFlags; + + operator StdVideoAV1ColorConfigFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1ColorConfigFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1ColorConfigFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1ColorConfigFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( mono_chrome == rhs.mono_chrome ) && ( color_range == rhs.color_range ) && ( separate_uv_delta_q == rhs.separate_uv_delta_q ) && + ( color_description_present_flag == rhs.color_description_present_flag ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t mono_chrome : 1; + uint32_t color_range : 1; + uint32_t separate_uv_delta_q : 1; + uint32_t color_description_present_flag : 1; + uint32_t reserved : 28; + }; + + struct AV1ColorConfig + { + using NativeType = StdVideoAV1ColorConfig; + + operator StdVideoAV1ColorConfig const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1ColorConfig &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1ColorConfig const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1ColorConfig *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) && + ( reserved1 == rhs.reserved1 ) && ( color_primaries == rhs.color_primaries ) && ( transfer_characteristics == rhs.transfer_characteristics ) && + ( matrix_coefficients == rhs.matrix_coefficients ) && ( chroma_sample_position == rhs.chroma_sample_position ); + } + + bool operator!=( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags flags = {}; + uint8_t BitDepth = {}; + uint8_t subsampling_x = {}; + uint8_t subsampling_y = {}; + uint8_t reserved1 = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries color_primaries = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries::eBt709; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics transfer_characteristics = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics::eReserved0; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients matrix_coefficients = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients::eIdentity; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition chroma_sample_position = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition::eUnknown; + }; + + struct AV1TimingInfoFlags + { + using NativeType = StdVideoAV1TimingInfoFlags; + + operator StdVideoAV1TimingInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TimingInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TimingInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1TimingInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1TimingInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( equal_picture_interval == rhs.equal_picture_interval ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1TimingInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t equal_picture_interval : 1; + uint32_t reserved : 31; + }; + + struct AV1TimingInfo + { + using NativeType = StdVideoAV1TimingInfo; + + operator StdVideoAV1TimingInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TimingInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TimingInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1TimingInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( num_units_in_display_tick == rhs.num_units_in_display_tick ) && ( time_scale == rhs.time_scale ) && + ( num_ticks_per_picture_minus_1 == rhs.num_ticks_per_picture_minus_1 ); + } + + bool operator!=( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags flags = {}; + uint32_t num_units_in_display_tick = {}; + uint32_t time_scale = {}; + uint32_t num_ticks_per_picture_minus_1 = {}; + }; + + struct AV1LoopFilterFlags + { + using NativeType = StdVideoAV1LoopFilterFlags; + + operator StdVideoAV1LoopFilterFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1LoopFilterFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1LoopFilterFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1LoopFilterFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) && + ( reserved == rhs.reserved ); + } + + bool operator!=( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t loop_filter_delta_enabled : 1; + uint32_t loop_filter_delta_update : 1; + uint32_t reserved : 30; + }; + + struct AV1LoopFilter + { + using NativeType = StdVideoAV1LoopFilter; + + operator StdVideoAV1LoopFilter const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1LoopFilter &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1LoopFilter const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1LoopFilter *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) && + ( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) && + ( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas ); + } + + bool operator!=( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags flags = {}; + ArrayWrapper1D loop_filter_level = {}; + uint8_t loop_filter_sharpness = {}; + uint8_t update_ref_delta = {}; + ArrayWrapper1D loop_filter_ref_deltas = {}; + uint8_t update_mode_delta = {}; + ArrayWrapper1D loop_filter_mode_deltas = {}; + }; + + struct AV1QuantizationFlags + { + using NativeType = StdVideoAV1QuantizationFlags; + + operator StdVideoAV1QuantizationFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1QuantizationFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1QuantizationFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1QuantizationFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1QuantizationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( using_qmatrix == rhs.using_qmatrix ) && ( diff_uv_delta == rhs.diff_uv_delta ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1QuantizationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t using_qmatrix : 1; + uint32_t diff_uv_delta : 1; + uint32_t reserved : 30; + }; + + struct AV1Quantization + { + using NativeType = StdVideoAV1Quantization; + + operator StdVideoAV1Quantization const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1Quantization &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1Quantization const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1Quantization *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( base_q_idx == rhs.base_q_idx ) && ( DeltaQYDc == rhs.DeltaQYDc ) && ( DeltaQUDc == rhs.DeltaQUDc ) && + ( DeltaQUAc == rhs.DeltaQUAc ) && ( DeltaQVDc == rhs.DeltaQVDc ) && ( DeltaQVAc == rhs.DeltaQVAc ) && ( qm_y == rhs.qm_y ) && + ( qm_u == rhs.qm_u ) && ( qm_v == rhs.qm_v ); + } + + bool operator!=( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags flags = {}; + uint8_t base_q_idx = {}; + int8_t DeltaQYDc = {}; + int8_t DeltaQUDc = {}; + int8_t DeltaQUAc = {}; + int8_t DeltaQVDc = {}; + int8_t DeltaQVAc = {}; + uint8_t qm_y = {}; + uint8_t qm_u = {}; + uint8_t qm_v = {}; + }; + + struct AV1Segmentation + { + using NativeType = StdVideoAV1Segmentation; + + operator StdVideoAV1Segmentation const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1Segmentation &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1Segmentation const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1Segmentation *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData ); + } + + bool operator!=( AV1Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + ArrayWrapper1D FeatureEnabled = {}; + ArrayWrapper2D FeatureData = {}; + }; + + struct AV1TileInfoFlags + { + using NativeType = StdVideoAV1TileInfoFlags; + + operator StdVideoAV1TileInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TileInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TileInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1TileInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1TileInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( uniform_tile_spacing_flag == rhs.uniform_tile_spacing_flag ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1TileInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t uniform_tile_spacing_flag : 1; + uint32_t reserved : 31; + }; + + struct AV1TileInfo + { + using NativeType = StdVideoAV1TileInfo; + + operator StdVideoAV1TileInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TileInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1TileInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1TileInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( TileCols == rhs.TileCols ) && ( TileRows == rhs.TileRows ) && + ( context_update_tile_id == rhs.context_update_tile_id ) && ( tile_size_bytes_minus_1 == rhs.tile_size_bytes_minus_1 ) && + ( reserved1 == rhs.reserved1 ) && ( pMiColStarts == rhs.pMiColStarts ) && ( pMiRowStarts == rhs.pMiRowStarts ) && + ( pWidthInSbsMinus1 == rhs.pWidthInSbsMinus1 ) && ( pHeightInSbsMinus1 == rhs.pHeightInSbsMinus1 ); + } + + bool operator!=( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags flags = {}; + uint8_t TileCols = {}; + uint8_t TileRows = {}; + uint16_t context_update_tile_id = {}; + uint8_t tile_size_bytes_minus_1 = {}; + ArrayWrapper1D reserved1 = {}; + const uint16_t * pMiColStarts = {}; + const uint16_t * pMiRowStarts = {}; + const uint16_t * pWidthInSbsMinus1 = {}; + const uint16_t * pHeightInSbsMinus1 = {}; + }; + + struct AV1CDEF + { + using NativeType = StdVideoAV1CDEF; + + operator StdVideoAV1CDEF const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1CDEF &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1CDEF const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1CDEF *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( cdef_damping_minus_3 == rhs.cdef_damping_minus_3 ) && ( cdef_bits == rhs.cdef_bits ) && ( cdef_y_pri_strength == rhs.cdef_y_pri_strength ) && + ( cdef_y_sec_strength == rhs.cdef_y_sec_strength ) && ( cdef_uv_pri_strength == rhs.cdef_uv_pri_strength ) && + ( cdef_uv_sec_strength == rhs.cdef_uv_sec_strength ); + } + + bool operator!=( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint8_t cdef_damping_minus_3 = {}; + uint8_t cdef_bits = {}; + ArrayWrapper1D cdef_y_pri_strength = {}; + ArrayWrapper1D cdef_y_sec_strength = {}; + ArrayWrapper1D cdef_uv_pri_strength = {}; + ArrayWrapper1D cdef_uv_sec_strength = {}; + }; + + struct AV1LoopRestoration + { + using NativeType = StdVideoAV1LoopRestoration; + + operator StdVideoAV1LoopRestoration const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1LoopRestoration &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1LoopRestoration const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1LoopRestoration *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1LoopRestoration const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( FrameRestorationType == rhs.FrameRestorationType ) && ( LoopRestorationSize == rhs.LoopRestorationSize ); + } + + bool operator!=( AV1LoopRestoration const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + ArrayWrapper1D FrameRestorationType = {}; + ArrayWrapper1D LoopRestorationSize = {}; + }; + + struct AV1GlobalMotion + { + using NativeType = StdVideoAV1GlobalMotion; + + operator StdVideoAV1GlobalMotion const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1GlobalMotion &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1GlobalMotion const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1GlobalMotion *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1GlobalMotion const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( GmType == rhs.GmType ) && ( gm_params == rhs.gm_params ); + } + + bool operator!=( AV1GlobalMotion const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + ArrayWrapper1D GmType = {}; + ArrayWrapper2D gm_params = {}; + }; + + struct AV1FilmGrainFlags + { + using NativeType = StdVideoAV1FilmGrainFlags; + + operator StdVideoAV1FilmGrainFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1FilmGrainFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1FilmGrainFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1FilmGrainFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( chroma_scaling_from_luma == rhs.chroma_scaling_from_luma ) && ( overlap_flag == rhs.overlap_flag ) && + ( clip_to_restricted_range == rhs.clip_to_restricted_range ) && ( update_grain == rhs.update_grain ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t chroma_scaling_from_luma : 1; + uint32_t overlap_flag : 1; + uint32_t clip_to_restricted_range : 1; + uint32_t update_grain : 1; + uint32_t reserved : 28; + }; + + struct AV1FilmGrain + { + using NativeType = StdVideoAV1FilmGrain; + + operator StdVideoAV1FilmGrain const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1FilmGrain &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1FilmGrain const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1FilmGrain *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( grain_scaling_minus_8 == rhs.grain_scaling_minus_8 ) && ( ar_coeff_lag == rhs.ar_coeff_lag ) && + ( ar_coeff_shift_minus_6 == rhs.ar_coeff_shift_minus_6 ) && ( grain_scale_shift == rhs.grain_scale_shift ) && ( grain_seed == rhs.grain_seed ) && + ( film_grain_params_ref_idx == rhs.film_grain_params_ref_idx ) && ( num_y_points == rhs.num_y_points ) && + ( point_y_value == rhs.point_y_value ) && ( point_y_scaling == rhs.point_y_scaling ) && ( num_cb_points == rhs.num_cb_points ) && + ( point_cb_value == rhs.point_cb_value ) && ( point_cb_scaling == rhs.point_cb_scaling ) && ( num_cr_points == rhs.num_cr_points ) && + ( point_cr_value == rhs.point_cr_value ) && ( point_cr_scaling == rhs.point_cr_scaling ) && + ( ar_coeffs_y_plus_128 == rhs.ar_coeffs_y_plus_128 ) && ( ar_coeffs_cb_plus_128 == rhs.ar_coeffs_cb_plus_128 ) && + ( ar_coeffs_cr_plus_128 == rhs.ar_coeffs_cr_plus_128 ) && ( cb_mult == rhs.cb_mult ) && ( cb_luma_mult == rhs.cb_luma_mult ) && + ( cb_offset == rhs.cb_offset ) && ( cr_mult == rhs.cr_mult ) && ( cr_luma_mult == rhs.cr_luma_mult ) && ( cr_offset == rhs.cr_offset ); + } + + bool operator!=( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags flags = {}; + uint8_t grain_scaling_minus_8 = {}; + uint8_t ar_coeff_lag = {}; + uint8_t ar_coeff_shift_minus_6 = {}; + uint8_t grain_scale_shift = {}; + uint16_t grain_seed = {}; + uint8_t film_grain_params_ref_idx = {}; + uint8_t num_y_points = {}; + ArrayWrapper1D point_y_value = {}; + ArrayWrapper1D point_y_scaling = {}; + uint8_t num_cb_points = {}; + ArrayWrapper1D point_cb_value = {}; + ArrayWrapper1D point_cb_scaling = {}; + uint8_t num_cr_points = {}; + ArrayWrapper1D point_cr_value = {}; + ArrayWrapper1D point_cr_scaling = {}; + ArrayWrapper1D ar_coeffs_y_plus_128 = {}; + ArrayWrapper1D ar_coeffs_cb_plus_128 = {}; + ArrayWrapper1D ar_coeffs_cr_plus_128 = {}; + uint8_t cb_mult = {}; + uint8_t cb_luma_mult = {}; + uint16_t cb_offset = {}; + uint8_t cr_mult = {}; + uint8_t cr_luma_mult = {}; + uint16_t cr_offset = {}; + }; + + struct AV1SequenceHeaderFlags + { + using NativeType = StdVideoAV1SequenceHeaderFlags; + + operator StdVideoAV1SequenceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1SequenceHeaderFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1SequenceHeaderFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1SequenceHeaderFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( still_picture == rhs.still_picture ) && ( reduced_still_picture_header == rhs.reduced_still_picture_header ) && + ( use_128x128_superblock == rhs.use_128x128_superblock ) && ( enable_filter_intra == rhs.enable_filter_intra ) && + ( enable_intra_edge_filter == rhs.enable_intra_edge_filter ) && ( enable_interintra_compound == rhs.enable_interintra_compound ) && + ( enable_masked_compound == rhs.enable_masked_compound ) && ( enable_warped_motion == rhs.enable_warped_motion ) && + ( enable_dual_filter == rhs.enable_dual_filter ) && ( enable_order_hint == rhs.enable_order_hint ) && + ( enable_jnt_comp == rhs.enable_jnt_comp ) && ( enable_ref_frame_mvs == rhs.enable_ref_frame_mvs ) && + ( frame_id_numbers_present_flag == rhs.frame_id_numbers_present_flag ) && ( enable_superres == rhs.enable_superres ) && + ( enable_cdef == rhs.enable_cdef ) && ( enable_restoration == rhs.enable_restoration ) && + ( film_grain_params_present == rhs.film_grain_params_present ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) && + ( initial_display_delay_present_flag == rhs.initial_display_delay_present_flag ) && ( reserved == rhs.reserved ); + } + + bool operator!=( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t still_picture : 1; + uint32_t reduced_still_picture_header : 1; + uint32_t use_128x128_superblock : 1; + uint32_t enable_filter_intra : 1; + uint32_t enable_intra_edge_filter : 1; + uint32_t enable_interintra_compound : 1; + uint32_t enable_masked_compound : 1; + uint32_t enable_warped_motion : 1; + uint32_t enable_dual_filter : 1; + uint32_t enable_order_hint : 1; + uint32_t enable_jnt_comp : 1; + uint32_t enable_ref_frame_mvs : 1; + uint32_t frame_id_numbers_present_flag : 1; + uint32_t enable_superres : 1; + uint32_t enable_cdef : 1; + uint32_t enable_restoration : 1; + uint32_t film_grain_params_present : 1; + uint32_t timing_info_present_flag : 1; + uint32_t initial_display_delay_present_flag : 1; + uint32_t reserved : 13; + }; + + struct AV1SequenceHeader + { + using NativeType = StdVideoAV1SequenceHeader; + + operator StdVideoAV1SequenceHeader const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1SequenceHeader &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoAV1SequenceHeader const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoAV1SequenceHeader *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( seq_profile == rhs.seq_profile ) && ( frame_width_bits_minus_1 == rhs.frame_width_bits_minus_1 ) && + ( frame_height_bits_minus_1 == rhs.frame_height_bits_minus_1 ) && ( max_frame_width_minus_1 == rhs.max_frame_width_minus_1 ) && + ( max_frame_height_minus_1 == rhs.max_frame_height_minus_1 ) && ( delta_frame_id_length_minus_2 == rhs.delta_frame_id_length_minus_2 ) && + ( additional_frame_id_length_minus_1 == rhs.additional_frame_id_length_minus_1 ) && ( order_hint_bits_minus_1 == rhs.order_hint_bits_minus_1 ) && + ( seq_force_integer_mv == rhs.seq_force_integer_mv ) && ( seq_force_screen_content_tools == rhs.seq_force_screen_content_tools ) && + ( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pTimingInfo == rhs.pTimingInfo ); + } + + bool operator!=( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile seq_profile = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile::eMain; + uint8_t frame_width_bits_minus_1 = {}; + uint8_t frame_height_bits_minus_1 = {}; + uint16_t max_frame_width_minus_1 = {}; + uint16_t max_frame_height_minus_1 = {}; + uint8_t delta_frame_id_length_minus_2 = {}; + uint8_t additional_frame_id_length_minus_1 = {}; + uint8_t order_hint_bits_minus_1 = {}; + uint8_t seq_force_integer_mv = {}; + uint8_t seq_force_screen_content_tools = {}; + ArrayWrapper1D reserved1 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig * pColorConfig = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo * pTimingInfo = {}; + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ ) + //=== vulkan_video_codec_av1std_decode === + + struct DecodeAV1PictureInfoFlags + { + using NativeType = StdVideoDecodeAV1PictureInfoFlags; + + operator StdVideoDecodeAV1PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1PictureInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1PictureInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) && + ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) && + ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) && + ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) && + ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) && + ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && + ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) && + ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) && + ( reduced_tx_set == rhs.reduced_tx_set ) && ( reference_select == rhs.reference_select ) && ( skip_mode_present == rhs.skip_mode_present ) && + ( delta_q_present == rhs.delta_q_present ) && ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) && + ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) && + ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) && + ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( apply_grain == rhs.apply_grain ) && ( reserved == rhs.reserved ); + } + + bool operator!=( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t error_resilient_mode : 1; + uint32_t disable_cdf_update : 1; + uint32_t use_superres : 1; + uint32_t render_and_frame_size_different : 1; + uint32_t allow_screen_content_tools : 1; + uint32_t is_filter_switchable : 1; + uint32_t force_integer_mv : 1; + uint32_t frame_size_override_flag : 1; + uint32_t buffer_removal_time_present_flag : 1; + uint32_t allow_intrabc : 1; + uint32_t frame_refs_short_signaling : 1; + uint32_t allow_high_precision_mv : 1; + uint32_t is_motion_mode_switchable : 1; + uint32_t use_ref_frame_mvs : 1; + uint32_t disable_frame_end_update_cdf : 1; + uint32_t allow_warped_motion : 1; + uint32_t reduced_tx_set : 1; + uint32_t reference_select : 1; + uint32_t skip_mode_present : 1; + uint32_t delta_q_present : 1; + uint32_t delta_lf_present : 1; + uint32_t delta_lf_multi : 1; + uint32_t segmentation_enabled : 1; + uint32_t segmentation_update_map : 1; + uint32_t segmentation_temporal_update : 1; + uint32_t segmentation_update_data : 1; + uint32_t UsesLr : 1; + uint32_t usesChromaLr : 1; + uint32_t apply_grain : 1; + uint32_t reserved : 3; + }; + + struct DecodeAV1PictureInfo + { + using NativeType = StdVideoDecodeAV1PictureInfo; + + operator StdVideoDecodeAV1PictureInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1PictureInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1PictureInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1PictureInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( current_frame_id == rhs.current_frame_id ) && ( OrderHint == rhs.OrderHint ) && + ( primary_ref_frame == rhs.primary_ref_frame ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( reserved1 == rhs.reserved1 ) && + ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) && + ( delta_lf_res == rhs.delta_lf_res ) && ( SkipModeFrame == rhs.SkipModeFrame ) && ( coded_denom == rhs.coded_denom ) && + ( reserved2 == rhs.reserved2 ) && ( OrderHints == rhs.OrderHints ) && ( expectedFrameId == rhs.expectedFrameId ) && + ( pTileInfo == rhs.pTileInfo ) && ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && + ( pLoopFilter == rhs.pLoopFilter ) && ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && + ( pGlobalMotion == rhs.pGlobalMotion ) && ( pFilmGrain == rhs.pFilmGrain ); + } + + bool operator!=( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey; + uint32_t current_frame_id = {}; + uint8_t OrderHint = {}; + uint8_t primary_ref_frame = {}; + uint8_t refresh_frame_flags = {}; + uint8_t reserved1 = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter interpolation_filter = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter::eEighttap; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4; + uint8_t delta_q_res = {}; + uint8_t delta_lf_res = {}; + ArrayWrapper1D SkipModeFrame = {}; + uint8_t coded_denom = {}; + ArrayWrapper1D reserved2 = {}; + ArrayWrapper1D OrderHints = {}; + ArrayWrapper1D expectedFrameId = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter * pLoopFilter = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF * pCDEF = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration * pLoopRestoration = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion * pGlobalMotion = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain * pFilmGrain = {}; + }; + + struct DecodeAV1ReferenceInfoFlags + { + using NativeType = StdVideoDecodeAV1ReferenceInfoFlags; + + operator StdVideoDecodeAV1ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) && + ( reserved == rhs.reserved ); + } + + bool operator!=( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t disable_frame_end_update_cdf : 1; + uint32_t segmentation_enabled : 1; + uint32_t reserved : 30; + }; + + struct DecodeAV1ReferenceInfo + { + using NativeType = StdVideoDecodeAV1ReferenceInfo; + + operator StdVideoDecodeAV1ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1ReferenceInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoDecodeAV1ReferenceInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( RefFrameSignBias == rhs.RefFrameSignBias ) && ( OrderHint == rhs.OrderHint ) && + ( SavedOrderHints == rhs.SavedOrderHints ); + } + + bool operator!=( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags flags = {}; + uint8_t frame_type = {}; + uint8_t RefFrameSignBias = {}; + uint8_t OrderHint = {}; + ArrayWrapper1D SavedOrderHints = {}; + }; +#endif + +#if defined( VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ ) + //=== vulkan_video_codec_av1std_encode === + + struct EncodeAV1DecoderModelInfo + { + using NativeType = StdVideoEncodeAV1DecoderModelInfo; + + operator StdVideoEncodeAV1DecoderModelInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1DecoderModelInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1DecoderModelInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1DecoderModelInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( buffer_delay_length_minus_1 == rhs.buffer_delay_length_minus_1 ) && + ( buffer_removal_time_length_minus_1 == rhs.buffer_removal_time_length_minus_1 ) && + ( frame_presentation_time_length_minus_1 == rhs.frame_presentation_time_length_minus_1 ) && ( reserved1 == rhs.reserved1 ) && + ( num_units_in_decoding_tick == rhs.num_units_in_decoding_tick ); + } + + bool operator!=( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint8_t buffer_delay_length_minus_1 = {}; + uint8_t buffer_removal_time_length_minus_1 = {}; + uint8_t frame_presentation_time_length_minus_1 = {}; + uint8_t reserved1 = {}; + uint32_t num_units_in_decoding_tick = {}; + }; + + struct EncodeAV1ExtensionHeader + { + using NativeType = StdVideoEncodeAV1ExtensionHeader; + + operator StdVideoEncodeAV1ExtensionHeader const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1ExtensionHeader &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1ExtensionHeader const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1ExtensionHeader *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( temporal_id == rhs.temporal_id ) && ( spatial_id == rhs.spatial_id ); + } + + bool operator!=( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint8_t temporal_id = {}; + uint8_t spatial_id = {}; + }; + + struct EncodeAV1OperatingPointInfoFlags + { + using NativeType = StdVideoEncodeAV1OperatingPointInfoFlags; + + operator StdVideoEncodeAV1OperatingPointInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1OperatingPointInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1OperatingPointInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1OperatingPointInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( decoder_model_present_for_this_op == rhs.decoder_model_present_for_this_op ) && ( low_delay_mode_flag == rhs.low_delay_mode_flag ) && + ( initial_display_delay_present_for_this_op == rhs.initial_display_delay_present_for_this_op ) && ( reserved == rhs.reserved ); + } + + bool operator!=( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t decoder_model_present_for_this_op : 1; + uint32_t low_delay_mode_flag : 1; + uint32_t initial_display_delay_present_for_this_op : 1; + uint32_t reserved : 29; + }; + + struct EncodeAV1OperatingPointInfo + { + using NativeType = StdVideoEncodeAV1OperatingPointInfo; + + operator StdVideoEncodeAV1OperatingPointInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1OperatingPointInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1OperatingPointInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1OperatingPointInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( operating_point_idc == rhs.operating_point_idc ) && ( seq_level_idx == rhs.seq_level_idx ) && + ( seq_tier == rhs.seq_tier ) && ( decoder_buffer_delay == rhs.decoder_buffer_delay ) && ( encoder_buffer_delay == rhs.encoder_buffer_delay ) && + ( initial_display_delay_minus_1 == rhs.initial_display_delay_minus_1 ); + } + + bool operator!=( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags flags = {}; + uint16_t operating_point_idc = {}; + uint8_t seq_level_idx = {}; + uint8_t seq_tier = {}; + uint32_t decoder_buffer_delay = {}; + uint32_t encoder_buffer_delay = {}; + uint8_t initial_display_delay_minus_1 = {}; + }; + + struct EncodeAV1PictureInfoFlags + { + using NativeType = StdVideoEncodeAV1PictureInfoFlags; + + operator StdVideoEncodeAV1PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1PictureInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1PictureInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) && + ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) && + ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) && + ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) && + ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) && + ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && + ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) && + ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) && + ( reduced_tx_set == rhs.reduced_tx_set ) && ( skip_mode_present == rhs.skip_mode_present ) && ( delta_q_present == rhs.delta_q_present ) && + ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) && + ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) && + ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) && + ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( show_frame == rhs.show_frame ) && + ( showable_frame == rhs.showable_frame ) && ( reserved == rhs.reserved ); + } + + bool operator!=( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t error_resilient_mode : 1; + uint32_t disable_cdf_update : 1; + uint32_t use_superres : 1; + uint32_t render_and_frame_size_different : 1; + uint32_t allow_screen_content_tools : 1; + uint32_t is_filter_switchable : 1; + uint32_t force_integer_mv : 1; + uint32_t frame_size_override_flag : 1; + uint32_t buffer_removal_time_present_flag : 1; + uint32_t allow_intrabc : 1; + uint32_t frame_refs_short_signaling : 1; + uint32_t allow_high_precision_mv : 1; + uint32_t is_motion_mode_switchable : 1; + uint32_t use_ref_frame_mvs : 1; + uint32_t disable_frame_end_update_cdf : 1; + uint32_t allow_warped_motion : 1; + uint32_t reduced_tx_set : 1; + uint32_t skip_mode_present : 1; + uint32_t delta_q_present : 1; + uint32_t delta_lf_present : 1; + uint32_t delta_lf_multi : 1; + uint32_t segmentation_enabled : 1; + uint32_t segmentation_update_map : 1; + uint32_t segmentation_temporal_update : 1; + uint32_t segmentation_update_data : 1; + uint32_t UsesLr : 1; + uint32_t usesChromaLr : 1; + uint32_t show_frame : 1; + uint32_t showable_frame : 1; + uint32_t reserved : 3; + }; + + struct EncodeAV1PictureInfo + { + using NativeType = StdVideoEncodeAV1PictureInfo; + + operator StdVideoEncodeAV1PictureInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1PictureInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1PictureInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1PictureInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( frame_presentation_time == rhs.frame_presentation_time ) && + ( current_frame_id == rhs.current_frame_id ) && ( order_hint == rhs.order_hint ) && ( primary_ref_frame == rhs.primary_ref_frame ) && + ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( coded_denom == rhs.coded_denom ) && + ( render_width_minus_1 == rhs.render_width_minus_1 ) && ( render_height_minus_1 == rhs.render_height_minus_1 ) && + ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) && + ( delta_lf_res == rhs.delta_lf_res ) && ( ref_order_hint == rhs.ref_order_hint ) && ( ref_frame_idx == rhs.ref_frame_idx ) && + ( reserved1 == rhs.reserved1 ) && ( delta_frame_id_minus_1 == rhs.delta_frame_id_minus_1 ) && ( pTileInfo == rhs.pTileInfo ) && + ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && ( pLoopFilter == rhs.pLoopFilter ) && + ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && ( pGlobalMotion == rhs.pGlobalMotion ) && + ( pExtensionHeader == rhs.pExtensionHeader ) && ( pBufferRemovalTimes == rhs.pBufferRemovalTimes ); + } + + bool operator!=( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags flags = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey; + uint32_t frame_presentation_time = {}; + uint32_t current_frame_id = {}; + uint8_t order_hint = {}; + uint8_t primary_ref_frame = {}; + uint8_t refresh_frame_flags = {}; + uint8_t coded_denom = {}; + uint16_t render_width_minus_1 = {}; + uint16_t render_height_minus_1 = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter interpolation_filter = + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter::eEighttap; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4; + uint8_t delta_q_res = {}; + uint8_t delta_lf_res = {}; + ArrayWrapper1D ref_order_hint = {}; + ArrayWrapper1D ref_frame_idx = {}; + ArrayWrapper1D reserved1 = {}; + ArrayWrapper1D delta_frame_id_minus_1 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter * pLoopFilter = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF * pCDEF = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration * pLoopRestoration = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion * pGlobalMotion = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {}; + const uint32_t * pBufferRemovalTimes = {}; + }; + + struct EncodeAV1ReferenceInfoFlags + { + using NativeType = StdVideoEncodeAV1ReferenceInfoFlags; + + operator StdVideoEncodeAV1ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) && + ( reserved == rhs.reserved ); + } + + bool operator!=( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + uint32_t disable_frame_end_update_cdf : 1; + uint32_t segmentation_enabled : 1; + uint32_t reserved : 30; + }; + + struct EncodeAV1ReferenceInfo + { + using NativeType = StdVideoEncodeAV1ReferenceInfo; + + operator StdVideoEncodeAV1ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1ReferenceInfo &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator StdVideoEncodeAV1ReferenceInfo *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + bool operator==( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( flags == rhs.flags ) && ( RefFrameId == rhs.RefFrameId ) && ( frame_type == rhs.frame_type ) && ( OrderHint == rhs.OrderHint ) && + ( reserved1 == rhs.reserved1 ) && ( pExtensionHeader == rhs.pExtensionHeader ); + } + + bool operator!=( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags flags = {}; + uint32_t RefFrameId = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey; + uint8_t OrderHint = {}; + ArrayWrapper1D reserved1 = {}; + const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {}; + }; +#endif + + } // namespace VULKAN_HPP_VIDEO_NAMESPACE +} // namespace VULKAN_HPP_NAMESPACE + +#if defined( has_include_was_not_defined ) +# undef has_include_was_not_defined +# undef __has_include +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_wayland.h b/lib/vulkan-headers/include/vulkan/vulkan_wayland.h new file mode 100644 index 00000000000..41025db43b2 --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_wayland.h @@ -0,0 +1,59 @@ +#ifndef VULKAN_WAYLAND_H_ +#define VULKAN_WAYLAND_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_KHR_wayland_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_wayland_surface 1 +#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6 +#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" +typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; +typedef struct VkWaylandSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWaylandSurfaceCreateFlagsKHR flags; + struct wl_display* display; + struct wl_surface* surface; +} VkWaylandSurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( + VkInstance instance, + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_win32.h b/lib/vulkan-headers/include/vulkan/vulkan_win32.h new file mode 100644 index 00000000000..5c7e8bd6d7e --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_win32.h @@ -0,0 +1,372 @@ +#ifndef VULKAN_WIN32_H_ +#define VULKAN_WIN32_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_KHR_win32_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_win32_surface 1 +#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 +#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" +typedef VkFlags VkWin32SurfaceCreateFlagsKHR; +typedef struct VkWin32SurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkWin32SurfaceCreateFlagsKHR flags; + HINSTANCE hinstance; + HWND hwnd; +} VkWin32SurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( + VkInstance instance, + const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex); +#endif +#endif + + +// VK_KHR_external_memory_win32 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_memory_win32 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" +typedef struct VkImportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportMemoryWin32HandleInfoKHR; + +typedef struct VkExportMemoryWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportMemoryWin32HandleInfoKHR; + +typedef struct VkMemoryWin32HandlePropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryWin32HandlePropertiesKHR; + +typedef struct VkMemoryGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetWin32HandleInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); +#endif +#endif + + +// VK_KHR_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_win32_keyed_mutex 1 +#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 +#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" +typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeouts; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoKHR; + + + +// VK_KHR_external_semaphore_win32 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_semaphore_win32 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" +typedef struct VkImportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportSemaphoreWin32HandleInfoKHR; + +typedef struct VkExportSemaphoreWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportSemaphoreWin32HandleInfoKHR; + +typedef struct VkD3D12FenceSubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValuesCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValuesCount; + const uint64_t* pSignalSemaphoreValues; +} VkD3D12FenceSubmitInfoKHR; + +typedef struct VkSemaphoreGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetWin32HandleInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif +#endif + + +// VK_KHR_external_fence_win32 is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_external_fence_win32 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 +#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" +typedef struct VkImportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportFenceWin32HandleInfoKHR; + +typedef struct VkExportFenceWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportFenceWin32HandleInfoKHR; + +typedef struct VkFenceGetWin32HandleInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetWin32HandleInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); +typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif +#endif + + +// VK_NV_external_memory_win32 is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_external_memory_win32 1 +#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" +typedef struct VkImportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleType; + HANDLE handle; +} VkImportMemoryWin32HandleInfoNV; + +typedef struct VkExportMemoryWin32HandleInfoNV { + VkStructureType sType; + const void* pNext; + const SECURITY_ATTRIBUTES* pAttributes; + DWORD dwAccess; +} VkExportMemoryWin32HandleInfoNV; + +typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + HANDLE* pHandle); +#endif +#endif + + +// VK_NV_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_win32_keyed_mutex 1 +#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2 +#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" +typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t acquireCount; + const VkDeviceMemory* pAcquireSyncs; + const uint64_t* pAcquireKeys; + const uint32_t* pAcquireTimeoutMilliseconds; + uint32_t releaseCount; + const VkDeviceMemory* pReleaseSyncs; + const uint64_t* pReleaseKeys; +} VkWin32KeyedMutexAcquireReleaseInfoNV; + + + +// VK_EXT_full_screen_exclusive is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_full_screen_exclusive 1 +#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4 +#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive" + +typedef enum VkFullScreenExclusiveEXT { + VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0, + VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1, + VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2, + VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3, + VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkFullScreenExclusiveEXT; +typedef struct VkSurfaceFullScreenExclusiveInfoEXT { + VkStructureType sType; + void* pNext; + VkFullScreenExclusiveEXT fullScreenExclusive; +} VkSurfaceFullScreenExclusiveInfoEXT; + +typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT { + VkStructureType sType; + void* pNext; + VkBool32 fullScreenExclusiveSupported; +} VkSurfaceCapabilitiesFullScreenExclusiveEXT; + +typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT { + VkStructureType sType; + const void* pNext; + HMONITOR hmonitor; +} VkSurfaceFullScreenExclusiveWin32InfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); +typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain); +typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain); +typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT( + VkDevice device, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkDeviceGroupPresentModeFlagsKHR* pModes); +#endif +#endif + + +// VK_NV_acquire_winrt_display is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_acquire_winrt_display 1 +#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1 +#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display" +typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); +typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + uint32_t deviceRelativeId, + VkDisplayKHR* pDisplay); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_xcb.h b/lib/vulkan-headers/include/vulkan/vulkan_xcb.h new file mode 100644 index 00000000000..473f8c2887a --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_xcb.h @@ -0,0 +1,60 @@ +#ifndef VULKAN_XCB_H_ +#define VULKAN_XCB_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_KHR_xcb_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_xcb_surface 1 +#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" +typedef VkFlags VkXcbSurfaceCreateFlagsKHR; +typedef struct VkXcbSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXcbSurfaceCreateFlagsKHR flags; + xcb_connection_t* connection; + xcb_window_t window; +} VkXcbSurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( + VkInstance instance, + const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_xlib.h b/lib/vulkan-headers/include/vulkan/vulkan_xlib.h new file mode 100644 index 00000000000..dfd107c3e2f --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_xlib.h @@ -0,0 +1,60 @@ +#ifndef VULKAN_XLIB_H_ +#define VULKAN_XLIB_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_KHR_xlib_surface is a preprocessor guard. Do not pass it to API calls. +#define VK_KHR_xlib_surface 1 +#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 +#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" +typedef VkFlags VkXlibSurfaceCreateFlagsKHR; +typedef struct VkXlibSurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkXlibSurfaceCreateFlagsKHR flags; + Display* dpy; + Window window; +} VkXlibSurfaceCreateInfoKHR; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( + VkInstance instance, + const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display* dpy, + VisualID visualID); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_xlib_xrandr.h b/lib/vulkan-headers/include/vulkan/vulkan_xlib_xrandr.h new file mode 100644 index 00000000000..a272e246ceb --- /dev/null +++ b/lib/vulkan-headers/include/vulkan/vulkan_xlib_xrandr.h @@ -0,0 +1,50 @@ +#ifndef VULKAN_XLIB_XRANDR_H_ +#define VULKAN_XLIB_XRANDR_H_ 1 + +/* +** Copyright 2015-2026 The Khronos Group Inc. +** +** SPDX-License-Identifier: Apache-2.0 +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#ifdef __cplusplus +extern "C" { +#endif + + + +// VK_EXT_acquire_xlib_display is a preprocessor guard. Do not pass it to API calls. +#define VK_EXT_acquire_xlib_display 1 +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1 +#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display" +typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); +typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); + +#ifndef VK_NO_PROTOTYPES +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + VkDisplayKHR display); +#endif + +#ifndef VK_ONLY_EXPORTED_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + RROutput rrOutput, + VkDisplayKHR* pDisplay); +#endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif From 7bf1449f5f056c011c0ef680378ce6ec296d561d Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Wed, 22 Jul 2026 20:59:20 -0300 Subject: [PATCH 06/15] shaderc includes --- lib/shaderc-headers/include/shaderc/env.h | 73 ++ lib/shaderc-headers/include/shaderc/shaderc.h | 622 +++++++++++++++++ .../include/shaderc/shaderc.hpp | 624 ++++++++++++++++++ lib/shaderc-headers/include/shaderc/status.h | 39 ++ .../include/shaderc/visibility.h | 37 ++ 5 files changed, 1395 insertions(+) create mode 100644 lib/shaderc-headers/include/shaderc/env.h create mode 100644 lib/shaderc-headers/include/shaderc/shaderc.h create mode 100644 lib/shaderc-headers/include/shaderc/shaderc.hpp create mode 100644 lib/shaderc-headers/include/shaderc/status.h create mode 100644 lib/shaderc-headers/include/shaderc/visibility.h diff --git a/lib/shaderc-headers/include/shaderc/env.h b/lib/shaderc-headers/include/shaderc/env.h new file mode 100644 index 00000000000..3d32b2a9a06 --- /dev/null +++ b/lib/shaderc-headers/include/shaderc/env.h @@ -0,0 +1,73 @@ +// Copyright 2018 The Shaderc Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef SHADERC_ENV_H_ +#define SHADERC_ENV_H_ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + shaderc_target_env_vulkan, // SPIR-V under Vulkan semantics + shaderc_target_env_opengl, // SPIR-V under OpenGL semantics + // NOTE: SPIR-V code generation is not supported for shaders under OpenGL + // compatibility profile. + shaderc_target_env_opengl_compat, // SPIR-V under OpenGL semantics, + // including compatibility profile + // functions + shaderc_target_env_webgpu, // Deprecated, SPIR-V under WebGPU + // semantics + shaderc_target_env_default = shaderc_target_env_vulkan +} shaderc_target_env; + +typedef enum { + // For Vulkan, use Vulkan's mapping of version numbers to integers. + // See vulkan.h + shaderc_env_version_vulkan_1_0 = ((1u << 22)), + shaderc_env_version_vulkan_1_1 = ((1u << 22) | (1 << 12)), + shaderc_env_version_vulkan_1_2 = ((1u << 22) | (2 << 12)), + shaderc_env_version_vulkan_1_3 = ((1u << 22) | (3 << 12)), + shaderc_env_version_vulkan_1_4 = ((1u << 22) | (4 << 12)), + // For OpenGL, use the number from #version in shaders. + // TODO(dneto): Currently no difference between OpenGL 4.5 and 4.6. + // See glslang/Standalone/Standalone.cpp + // TODO(dneto): Glslang doesn't accept a OpenGL client version of 460. + shaderc_env_version_opengl_4_5 = 450, + shaderc_env_version_webgpu, // Deprecated, WebGPU env never defined versions +} shaderc_env_version; + +// The known versions of SPIR-V. +typedef enum { + // Use the values used for word 1 of a SPIR-V binary: + // - bits 24 to 31: zero + // - bits 16 to 23: major version number + // - bits 8 to 15: minor version number + // - bits 0 to 7: zero + shaderc_spirv_version_1_0 = 0x010000u, + shaderc_spirv_version_1_1 = 0x010100u, + shaderc_spirv_version_1_2 = 0x010200u, + shaderc_spirv_version_1_3 = 0x010300u, + shaderc_spirv_version_1_4 = 0x010400u, + shaderc_spirv_version_1_5 = 0x010500u, + shaderc_spirv_version_1_6 = 0x010600u +} shaderc_spirv_version; + +#ifdef __cplusplus +} +#endif // __cplusplus + +#endif // SHADERC_ENV_H_ diff --git a/lib/shaderc-headers/include/shaderc/shaderc.h b/lib/shaderc-headers/include/shaderc/shaderc.h new file mode 100644 index 00000000000..dd40744d0f5 --- /dev/null +++ b/lib/shaderc-headers/include/shaderc/shaderc.h @@ -0,0 +1,622 @@ +// Copyright 2015 The Shaderc Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef SHADERC_SHADERC_H_ +#define SHADERC_SHADERC_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +#include "shaderc/env.h" +#include "shaderc/status.h" +#include "shaderc/visibility.h" + +// Source language kind. +typedef enum { + shaderc_source_language_glsl, + shaderc_source_language_hlsl, +} shaderc_source_language; + +typedef enum { + // Forced shader kinds. These shader kinds force the compiler to compile the + // source code as the specified kind of shader. + shaderc_vertex_shader, + shaderc_fragment_shader, + shaderc_compute_shader, + shaderc_geometry_shader, + shaderc_tess_control_shader, + shaderc_tess_evaluation_shader, + + shaderc_glsl_vertex_shader = shaderc_vertex_shader, + shaderc_glsl_fragment_shader = shaderc_fragment_shader, + shaderc_glsl_compute_shader = shaderc_compute_shader, + shaderc_glsl_geometry_shader = shaderc_geometry_shader, + shaderc_glsl_tess_control_shader = shaderc_tess_control_shader, + shaderc_glsl_tess_evaluation_shader = shaderc_tess_evaluation_shader, + + // Deduce the shader kind from #pragma annotation in the source code. Compiler + // will emit error if #pragma annotation is not found. + shaderc_glsl_infer_from_source, + // Default shader kinds. Compiler will fall back to compile the source code as + // the specified kind of shader when #pragma annotation is not found in the + // source code. + shaderc_glsl_default_vertex_shader, + shaderc_glsl_default_fragment_shader, + shaderc_glsl_default_compute_shader, + shaderc_glsl_default_geometry_shader, + shaderc_glsl_default_tess_control_shader, + shaderc_glsl_default_tess_evaluation_shader, + shaderc_spirv_assembly, + shaderc_raygen_shader, + shaderc_anyhit_shader, + shaderc_closesthit_shader, + shaderc_miss_shader, + shaderc_intersection_shader, + shaderc_callable_shader, + shaderc_glsl_raygen_shader = shaderc_raygen_shader, + shaderc_glsl_anyhit_shader = shaderc_anyhit_shader, + shaderc_glsl_closesthit_shader = shaderc_closesthit_shader, + shaderc_glsl_miss_shader = shaderc_miss_shader, + shaderc_glsl_intersection_shader = shaderc_intersection_shader, + shaderc_glsl_callable_shader = shaderc_callable_shader, + shaderc_glsl_default_raygen_shader, + shaderc_glsl_default_anyhit_shader, + shaderc_glsl_default_closesthit_shader, + shaderc_glsl_default_miss_shader, + shaderc_glsl_default_intersection_shader, + shaderc_glsl_default_callable_shader, + shaderc_task_shader, + shaderc_mesh_shader, + shaderc_glsl_task_shader = shaderc_task_shader, + shaderc_glsl_mesh_shader = shaderc_mesh_shader, + shaderc_glsl_default_task_shader, + shaderc_glsl_default_mesh_shader, +} shaderc_shader_kind; + +typedef enum { + shaderc_profile_none, // Used if and only if GLSL version did not specify + // profiles. + shaderc_profile_core, + shaderc_profile_compatibility, // Disabled. This generates an error + shaderc_profile_es, +} shaderc_profile; + +// Optimization level. +typedef enum { + shaderc_optimization_level_zero, // no optimization + shaderc_optimization_level_size, // optimize towards reducing code size + shaderc_optimization_level_performance, // optimize towards performance +} shaderc_optimization_level; + +// Resource limits. +typedef enum { + shaderc_limit_max_lights, + shaderc_limit_max_clip_planes, + shaderc_limit_max_texture_units, + shaderc_limit_max_texture_coords, + shaderc_limit_max_vertex_attribs, + shaderc_limit_max_vertex_uniform_components, + shaderc_limit_max_varying_floats, + shaderc_limit_max_vertex_texture_image_units, + shaderc_limit_max_combined_texture_image_units, + shaderc_limit_max_texture_image_units, + shaderc_limit_max_fragment_uniform_components, + shaderc_limit_max_draw_buffers, + shaderc_limit_max_vertex_uniform_vectors, + shaderc_limit_max_varying_vectors, + shaderc_limit_max_fragment_uniform_vectors, + shaderc_limit_max_vertex_output_vectors, + shaderc_limit_max_fragment_input_vectors, + shaderc_limit_min_program_texel_offset, + shaderc_limit_max_program_texel_offset, + shaderc_limit_max_clip_distances, + shaderc_limit_max_compute_work_group_count_x, + shaderc_limit_max_compute_work_group_count_y, + shaderc_limit_max_compute_work_group_count_z, + shaderc_limit_max_compute_work_group_size_x, + shaderc_limit_max_compute_work_group_size_y, + shaderc_limit_max_compute_work_group_size_z, + shaderc_limit_max_compute_uniform_components, + shaderc_limit_max_compute_texture_image_units, + shaderc_limit_max_compute_image_uniforms, + shaderc_limit_max_compute_atomic_counters, + shaderc_limit_max_compute_atomic_counter_buffers, + shaderc_limit_max_varying_components, + shaderc_limit_max_vertex_output_components, + shaderc_limit_max_geometry_input_components, + shaderc_limit_max_geometry_output_components, + shaderc_limit_max_fragment_input_components, + shaderc_limit_max_image_units, + shaderc_limit_max_combined_image_units_and_fragment_outputs, + shaderc_limit_max_combined_shader_output_resources, + shaderc_limit_max_image_samples, + shaderc_limit_max_vertex_image_uniforms, + shaderc_limit_max_tess_control_image_uniforms, + shaderc_limit_max_tess_evaluation_image_uniforms, + shaderc_limit_max_geometry_image_uniforms, + shaderc_limit_max_fragment_image_uniforms, + shaderc_limit_max_combined_image_uniforms, + shaderc_limit_max_geometry_texture_image_units, + shaderc_limit_max_geometry_output_vertices, + shaderc_limit_max_geometry_total_output_components, + shaderc_limit_max_geometry_uniform_components, + shaderc_limit_max_geometry_varying_components, + shaderc_limit_max_tess_control_input_components, + shaderc_limit_max_tess_control_output_components, + shaderc_limit_max_tess_control_texture_image_units, + shaderc_limit_max_tess_control_uniform_components, + shaderc_limit_max_tess_control_total_output_components, + shaderc_limit_max_tess_evaluation_input_components, + shaderc_limit_max_tess_evaluation_output_components, + shaderc_limit_max_tess_evaluation_texture_image_units, + shaderc_limit_max_tess_evaluation_uniform_components, + shaderc_limit_max_tess_patch_components, + shaderc_limit_max_patch_vertices, + shaderc_limit_max_tess_gen_level, + shaderc_limit_max_viewports, + shaderc_limit_max_vertex_atomic_counters, + shaderc_limit_max_tess_control_atomic_counters, + shaderc_limit_max_tess_evaluation_atomic_counters, + shaderc_limit_max_geometry_atomic_counters, + shaderc_limit_max_fragment_atomic_counters, + shaderc_limit_max_combined_atomic_counters, + shaderc_limit_max_atomic_counter_bindings, + shaderc_limit_max_vertex_atomic_counter_buffers, + shaderc_limit_max_tess_control_atomic_counter_buffers, + shaderc_limit_max_tess_evaluation_atomic_counter_buffers, + shaderc_limit_max_geometry_atomic_counter_buffers, + shaderc_limit_max_fragment_atomic_counter_buffers, + shaderc_limit_max_combined_atomic_counter_buffers, + shaderc_limit_max_atomic_counter_buffer_size, + shaderc_limit_max_transform_feedback_buffers, + shaderc_limit_max_transform_feedback_interleaved_components, + shaderc_limit_max_cull_distances, + shaderc_limit_max_combined_clip_and_cull_distances, + shaderc_limit_max_samples, + shaderc_limit_max_mesh_output_vertices_nv, + shaderc_limit_max_mesh_output_primitives_nv, + shaderc_limit_max_mesh_work_group_size_x_nv, + shaderc_limit_max_mesh_work_group_size_y_nv, + shaderc_limit_max_mesh_work_group_size_z_nv, + shaderc_limit_max_task_work_group_size_x_nv, + shaderc_limit_max_task_work_group_size_y_nv, + shaderc_limit_max_task_work_group_size_z_nv, + shaderc_limit_max_mesh_view_count_nv, + shaderc_limit_max_mesh_output_vertices_ext, + shaderc_limit_max_mesh_output_primitives_ext, + shaderc_limit_max_mesh_work_group_size_x_ext, + shaderc_limit_max_mesh_work_group_size_y_ext, + shaderc_limit_max_mesh_work_group_size_z_ext, + shaderc_limit_max_task_work_group_size_x_ext, + shaderc_limit_max_task_work_group_size_y_ext, + shaderc_limit_max_task_work_group_size_z_ext, + shaderc_limit_max_mesh_view_count_ext, + shaderc_limit_max_dual_source_draw_buffers_ext, +} shaderc_limit; + +// Uniform resource kinds. +// In Vulkan, uniform resources are bound to the pipeline via descriptors +// with numbered bindings and sets. +typedef enum { + // Image and image buffer. + shaderc_uniform_kind_image, + // Pure sampler. + shaderc_uniform_kind_sampler, + // Sampled texture in GLSL, and Shader Resource View in HLSL. + shaderc_uniform_kind_texture, + // Uniform Buffer Object (UBO) in GLSL. Cbuffer in HLSL. + shaderc_uniform_kind_buffer, + // Shader Storage Buffer Object (SSBO) in GLSL. + shaderc_uniform_kind_storage_buffer, + // Unordered Access View, in HLSL. (Writable storage image or storage + // buffer.) + shaderc_uniform_kind_unordered_access_view, +} shaderc_uniform_kind; + +// Usage examples: +// +// Aggressively release compiler resources, but spend time in initialization +// for each new use. +// shaderc_compiler_t compiler = shaderc_compiler_initialize(); +// shaderc_compilation_result_t result = shaderc_compile_into_spv( +// compiler, "#version 450\nvoid main() {}", 27, +// shaderc_glsl_vertex_shader, "main.vert", "main", nullptr); +// // Do stuff with compilation results. +// shaderc_result_release(result); +// shaderc_compiler_release(compiler); +// +// Keep the compiler object around for a long time, but pay for extra space +// occupied. +// shaderc_compiler_t compiler = shaderc_compiler_initialize(); +// // On the same, other or multiple simultaneous threads. +// shaderc_compilation_result_t result = shaderc_compile_into_spv( +// compiler, "#version 450\nvoid main() {}", 27, +// shaderc_glsl_vertex_shader, "main.vert", "main", nullptr); +// // Do stuff with compilation results. +// shaderc_result_release(result); +// // Once no more compilations are to happen. +// shaderc_compiler_release(compiler); + +// An opaque handle to an object that manages all compiler state. +typedef struct shaderc_compiler* shaderc_compiler_t; + +// Returns a shaderc_compiler_t that can be used to compile modules. +// A return of NULL indicates that there was an error initializing the compiler. +// Any function operating on shaderc_compiler_t must offer the basic +// thread-safety guarantee. +// [http://herbsutter.com/2014/01/13/gotw-95-solution-thread-safety-and-synchronization/] +// That is: concurrent invocation of these functions on DIFFERENT objects needs +// no synchronization; concurrent invocation of these functions on the SAME +// object requires synchronization IF AND ONLY IF some of them take a non-const +// argument. +SHADERC_EXPORT shaderc_compiler_t shaderc_compiler_initialize(void); + +// Releases the resources held by the shaderc_compiler_t. +// After this call it is invalid to make any future calls to functions +// involving this shaderc_compiler_t. +SHADERC_EXPORT void shaderc_compiler_release(shaderc_compiler_t); + +// An opaque handle to an object that manages options to a single compilation +// result. +typedef struct shaderc_compile_options* shaderc_compile_options_t; + +// Returns a default-initialized shaderc_compile_options_t that can be used +// to modify the functionality of a compiled module. +// A return of NULL indicates that there was an error initializing the options. +// Any function operating on shaderc_compile_options_t must offer the +// basic thread-safety guarantee. +SHADERC_EXPORT shaderc_compile_options_t + shaderc_compile_options_initialize(void); + +// Returns a copy of the given shaderc_compile_options_t. +// If NULL is passed as the parameter the call is the same as +// shaderc_compile_options_init. +SHADERC_EXPORT shaderc_compile_options_t shaderc_compile_options_clone( + const shaderc_compile_options_t options); + +// Releases the compilation options. It is invalid to use the given +// shaderc_compile_options_t object in any future calls. It is safe to pass +// NULL to this function, and doing such will have no effect. +SHADERC_EXPORT void shaderc_compile_options_release( + shaderc_compile_options_t options); + +// Adds a predefined macro to the compilation options. This has the same +// effect as passing -Dname=value to the command-line compiler. If value +// is NULL, it has the same effect as passing -Dname to the command-line +// compiler. If a macro definition with the same name has previously been +// added, the value is replaced with the new value. The macro name and +// value are passed in with char pointers, which point to their data, and +// the lengths of their data. The strings that the name and value pointers +// point to must remain valid for the duration of the call, but can be +// modified or deleted after this function has returned. In case of adding +// a valueless macro, the value argument should be a null pointer or the +// value_length should be 0u. +SHADERC_EXPORT void shaderc_compile_options_add_macro_definition( + shaderc_compile_options_t options, const char* name, size_t name_length, + const char* value, size_t value_length); + +// Sets the source language. The default is GLSL. +SHADERC_EXPORT void shaderc_compile_options_set_source_language( + shaderc_compile_options_t options, shaderc_source_language lang); + +// Sets the compiler mode to generate debug information in the output. +SHADERC_EXPORT void shaderc_compile_options_set_generate_debug_info( + shaderc_compile_options_t options); + +// Sets the compiler optimization level to the given level. Only the last one +// takes effect if multiple calls of this function exist. +SHADERC_EXPORT void shaderc_compile_options_set_optimization_level( + shaderc_compile_options_t options, shaderc_optimization_level level); + +// Forces the GLSL language version and profile to a given pair. The version +// number is the same as would appear in the #version annotation in the source. +// Version and profile specified here overrides the #version annotation in the +// source. Use profile: 'shaderc_profile_none' for GLSL versions that do not +// define profiles, e.g. versions below 150. +SHADERC_EXPORT void shaderc_compile_options_set_forced_version_profile( + shaderc_compile_options_t options, int version, shaderc_profile profile); + +// Source text inclusion via #include is supported with a pair of callbacks +// to an "includer" on the client side. The first callback processes an +// inclusion request, and returns an include result. The includer owns +// the contents of the result, and those contents must remain valid until the +// second callback is invoked to release the result. Both callbacks take a +// user_data argument to specify the client context. +// To return an error, set the source_name to an empty string and put your +// error message in content. + +// An include result. +typedef struct shaderc_include_result { + // The name of the source file. The name should be fully resolved + // in the sense that it should be a unique name in the context of the + // includer. For example, if the includer maps source names to files in + // a filesystem, then this name should be the absolute path of the file. + // For a failed inclusion, this string is empty. + const char* source_name; + size_t source_name_length; + // The text contents of the source file in the normal case. + // For a failed inclusion, this contains the error message. + const char* content; + size_t content_length; + // User data to be passed along with this request. + void* user_data; +} shaderc_include_result; + +// The kinds of include requests. +enum shaderc_include_type { + shaderc_include_type_relative, // E.g. #include "source" + shaderc_include_type_standard // E.g. #include +}; + +// An includer callback type for mapping an #include request to an include +// result. The user_data parameter specifies the client context. The +// requested_source parameter specifies the name of the source being requested. +// The type parameter specifies the kind of inclusion request being made. +// The requesting_source parameter specifies the name of the source containing +// the #include request. The includer owns the result object and its contents, +// and both must remain valid until the release callback is called on the result +// object. +typedef shaderc_include_result* (*shaderc_include_resolve_fn)( + void* user_data, const char* requested_source, int type, + const char* requesting_source, size_t include_depth); + +// An includer callback type for destroying an include result. +typedef void (*shaderc_include_result_release_fn)( + void* user_data, shaderc_include_result* include_result); + +// Sets includer callback functions. +SHADERC_EXPORT void shaderc_compile_options_set_include_callbacks( + shaderc_compile_options_t options, shaderc_include_resolve_fn resolver, + shaderc_include_result_release_fn result_releaser, void* user_data); + +// Sets the compiler mode to suppress warnings, overriding warnings-as-errors +// mode. When both suppress-warnings and warnings-as-errors modes are +// turned on, warning messages will be inhibited, and will not be emitted +// as error messages. +SHADERC_EXPORT void shaderc_compile_options_set_suppress_warnings( + shaderc_compile_options_t options); + +// Sets the target shader environment, affecting which warnings or errors will +// be issued. The version will be for distinguishing between different versions +// of the target environment. The version value should be either 0 or +// a value listed in shaderc_env_version. The 0 value maps to Vulkan 1.0 if +// |target| is Vulkan, and it maps to OpenGL 4.5 if |target| is OpenGL. +SHADERC_EXPORT void shaderc_compile_options_set_target_env( + shaderc_compile_options_t options, + shaderc_target_env target, + uint32_t version); + +// Sets the target SPIR-V version. The generated module will use this version +// of SPIR-V. Each target environment determines what versions of SPIR-V +// it can consume. Defaults to the highest version of SPIR-V 1.0 which is +// required to be supported by the target environment. E.g. Default to SPIR-V +// 1.0 for Vulkan 1.0 and SPIR-V 1.3 for Vulkan 1.1. +SHADERC_EXPORT void shaderc_compile_options_set_target_spirv( + shaderc_compile_options_t options, shaderc_spirv_version version); + +// Sets the compiler mode to treat all warnings as errors. Note the +// suppress-warnings mode overrides this option, i.e. if both +// warning-as-errors and suppress-warnings modes are set, warnings will not +// be emitted as error messages. +SHADERC_EXPORT void shaderc_compile_options_set_warnings_as_errors( + shaderc_compile_options_t options); + +// Sets a resource limit. +SHADERC_EXPORT void shaderc_compile_options_set_limit( + shaderc_compile_options_t options, shaderc_limit limit, int value); + +// Sets whether the compiler should automatically assign bindings to uniforms +// that aren't already explicitly bound in the shader source. +SHADERC_EXPORT void shaderc_compile_options_set_auto_bind_uniforms( + shaderc_compile_options_t options, bool auto_bind); + +// Sets whether the compiler should automatically remove sampler variables +// and convert image variables to combined image-sampler variables. +SHADERC_EXPORT void shaderc_compile_options_set_auto_combined_image_sampler( + shaderc_compile_options_t options, bool upgrade); + +// Sets whether the compiler should use HLSL IO mapping rules for bindings. +// Defaults to false. +SHADERC_EXPORT void shaderc_compile_options_set_hlsl_io_mapping( + shaderc_compile_options_t options, bool hlsl_iomap); + +// Sets whether the compiler should determine block member offsets using HLSL +// packing rules instead of standard GLSL rules. Defaults to false. Only +// affects GLSL compilation. HLSL rules are always used when compiling HLSL. +SHADERC_EXPORT void shaderc_compile_options_set_hlsl_offsets( + shaderc_compile_options_t options, bool hlsl_offsets); + +// Sets the base binding number used for for a uniform resource type when +// automatically assigning bindings. For GLSL compilation, sets the lowest +// automatically assigned number. For HLSL compilation, the regsiter number +// assigned to the resource is added to this specified base. +SHADERC_EXPORT void shaderc_compile_options_set_binding_base( + shaderc_compile_options_t options, + shaderc_uniform_kind kind, + uint32_t base); + +// Like shaderc_compile_options_set_binding_base, but only takes effect when +// compiling a given shader stage. The stage is assumed to be one of vertex, +// fragment, tessellation evaluation, tesselation control, geometry, or compute. +SHADERC_EXPORT void shaderc_compile_options_set_binding_base_for_stage( + shaderc_compile_options_t options, shaderc_shader_kind shader_kind, + shaderc_uniform_kind kind, uint32_t base); + +// Sets whether the compiler should preserve all bindings, even when those +// bindings are not used. +SHADERC_EXPORT void shaderc_compile_options_set_preserve_bindings( + shaderc_compile_options_t options, bool preserve_bindings); + +SHADERC_EXPORT void shaderc_compile_options_set_max_id_bound( + shaderc_compile_options_t options, uint32_t max_id_bound); + +// Sets whether the compiler should automatically assign locations to +// uniform variables that don't have explicit locations in the shader source. +SHADERC_EXPORT void shaderc_compile_options_set_auto_map_locations( + shaderc_compile_options_t options, bool auto_map); + +// Sets a descriptor set and binding for an HLSL register in the given stage. +// This method keeps a copy of the string data. +SHADERC_EXPORT void shaderc_compile_options_set_hlsl_register_set_and_binding_for_stage( + shaderc_compile_options_t options, shaderc_shader_kind shader_kind, + const char* reg, const char* set, const char* binding); + +// Like shaderc_compile_options_set_hlsl_register_set_and_binding_for_stage, +// but affects all shader stages. +SHADERC_EXPORT void shaderc_compile_options_set_hlsl_register_set_and_binding( + shaderc_compile_options_t options, const char* reg, const char* set, + const char* binding); + +// Sets whether the compiler should enable extension +// SPV_GOOGLE_hlsl_functionality1. +SHADERC_EXPORT void shaderc_compile_options_set_hlsl_functionality1( + shaderc_compile_options_t options, bool enable); + +// Sets whether 16-bit types are supported in HLSL or not. +SHADERC_EXPORT void shaderc_compile_options_set_hlsl_16bit_types( + shaderc_compile_options_t options, bool enable); + +// Enables or disables relaxed Vulkan rules. +// +// This allows most OpenGL shaders to compile under Vulkan semantics. +SHADERC_EXPORT void shaderc_compile_options_set_vulkan_rules_relaxed( + shaderc_compile_options_t options, bool enable); + +// Sets whether the compiler should invert position.Y output in vertex shader. +SHADERC_EXPORT void shaderc_compile_options_set_invert_y( + shaderc_compile_options_t options, bool enable); + +// Sets whether the compiler generates code for max and min builtins which, +// if given a NaN operand, will return the other operand. Similarly, the clamp +// builtin will favour the non-NaN operands, as if clamp were implemented +// as a composition of max and min. +SHADERC_EXPORT void shaderc_compile_options_set_nan_clamp( + shaderc_compile_options_t options, bool enable); + +// An opaque handle to the results of a call to any shaderc_compile_into_*() +// function. +typedef struct shaderc_compilation_result* shaderc_compilation_result_t; + +// Takes a GLSL source string and the associated shader kind, input file +// name, compiles it according to the given additional_options. If the shader +// kind is not set to a specified kind, but shaderc_glslc_infer_from_source, +// the compiler will try to deduce the shader kind from the source +// string and a failure in deducing will generate an error. Currently only +// #pragma annotation is supported. If the shader kind is set to one of the +// default shader kinds, the compiler will fall back to the default shader +// kind in case it failed to deduce the shader kind from source string. +// The input_file_name is a null-termintated string. It is used as a tag to +// identify the source string in cases like emitting error messages. It +// doesn't have to be a 'file name'. +// The source string will be compiled into SPIR-V binary and a +// shaderc_compilation_result will be returned to hold the results. +// The entry_point_name null-terminated string defines the name of the entry +// point to associate with this GLSL source. If the additional_options +// parameter is not null, then the compilation is modified by any options +// present. May be safely called from multiple threads without explicit +// synchronization. If there was failure in allocating the compiler object, +// null will be returned. +SHADERC_EXPORT shaderc_compilation_result_t shaderc_compile_into_spv( + const shaderc_compiler_t compiler, const char* source_text, + size_t source_text_size, shaderc_shader_kind shader_kind, + const char* input_file_name, const char* entry_point_name, + const shaderc_compile_options_t additional_options); + +// Like shaderc_compile_into_spv, but the result contains SPIR-V assembly text +// instead of a SPIR-V binary module. The SPIR-V assembly syntax is as defined +// by the SPIRV-Tools open source project. +SHADERC_EXPORT shaderc_compilation_result_t shaderc_compile_into_spv_assembly( + const shaderc_compiler_t compiler, const char* source_text, + size_t source_text_size, shaderc_shader_kind shader_kind, + const char* input_file_name, const char* entry_point_name, + const shaderc_compile_options_t additional_options); + +// Like shaderc_compile_into_spv, but the result contains preprocessed source +// code instead of a SPIR-V binary module +SHADERC_EXPORT shaderc_compilation_result_t shaderc_compile_into_preprocessed_text( + const shaderc_compiler_t compiler, const char* source_text, + size_t source_text_size, shaderc_shader_kind shader_kind, + const char* input_file_name, const char* entry_point_name, + const shaderc_compile_options_t additional_options); + +// Takes an assembly string of the format defined in the SPIRV-Tools project +// (https://github.com/KhronosGroup/SPIRV-Tools/blob/master/syntax.md), +// assembles it into SPIR-V binary and a shaderc_compilation_result will be +// returned to hold the results. +// The assembling will pick options suitable for assembling specified in the +// additional_options parameter. +// May be safely called from multiple threads without explicit synchronization. +// If there was failure in allocating the compiler object, null will be +// returned. +SHADERC_EXPORT shaderc_compilation_result_t shaderc_assemble_into_spv( + const shaderc_compiler_t compiler, const char* source_assembly, + size_t source_assembly_size, + const shaderc_compile_options_t additional_options); + +// The following functions, operating on shaderc_compilation_result_t objects, +// offer only the basic thread-safety guarantee. + +// Releases the resources held by the result object. It is invalid to use the +// result object for any further operations. +SHADERC_EXPORT void shaderc_result_release(shaderc_compilation_result_t result); + +// Returns the number of bytes of the compilation output data in a result +// object. +SHADERC_EXPORT size_t shaderc_result_get_length(const shaderc_compilation_result_t result); + +// Returns the number of warnings generated during the compilation. +SHADERC_EXPORT size_t shaderc_result_get_num_warnings( + const shaderc_compilation_result_t result); + +// Returns the number of errors generated during the compilation. +SHADERC_EXPORT size_t shaderc_result_get_num_errors(const shaderc_compilation_result_t result); + +// Returns the compilation status, indicating whether the compilation succeeded, +// or failed due to some reasons, like invalid shader stage or compilation +// errors. +SHADERC_EXPORT shaderc_compilation_status shaderc_result_get_compilation_status( + const shaderc_compilation_result_t); + +// Returns a pointer to the start of the compilation output data bytes, either +// SPIR-V binary or char string. When the source string is compiled into SPIR-V +// binary, this is guaranteed to be castable to a uint32_t*. If the result +// contains assembly text or preprocessed source text, the pointer will point to +// the resulting array of characters. +SHADERC_EXPORT const char* shaderc_result_get_bytes(const shaderc_compilation_result_t result); + +// Returns a null-terminated string that contains any error messages generated +// during the compilation. +SHADERC_EXPORT const char* shaderc_result_get_error_message( + const shaderc_compilation_result_t result); + +// Provides the version & revision of the SPIR-V which will be produced +SHADERC_EXPORT void shaderc_get_spv_version(unsigned int* version, unsigned int* revision); + +// Parses the version and profile from a given null-terminated string +// containing both version and profile, like: '450core'. Returns false if +// the string can not be parsed. Returns true when the parsing succeeds. The +// parsed version and profile are returned through arguments. +SHADERC_EXPORT bool shaderc_parse_version_profile(const char* str, int* version, + shaderc_profile* profile); + +#ifdef __cplusplus +} +#endif // __cplusplus + +#endif // SHADERC_SHADERC_H_ diff --git a/lib/shaderc-headers/include/shaderc/shaderc.hpp b/lib/shaderc-headers/include/shaderc/shaderc.hpp new file mode 100644 index 00000000000..77ccd7a70ac --- /dev/null +++ b/lib/shaderc-headers/include/shaderc/shaderc.hpp @@ -0,0 +1,624 @@ +// Copyright 2015 The Shaderc Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef SHADERC_SHADERC_HPP_ +#define SHADERC_SHADERC_HPP_ + +#include +#include +#include + +#include "shaderc.h" + +namespace shaderc { +// A CompilationResult contains the compiler output, compilation status, +// and messages. +// +// The compiler output is stored as an array of elements and accessed +// via random access iterators provided by cbegin() and cend(). The iterators +// are contiguous in the sense of "Contiguous Iterators: A Refinement of +// Random Access Iterators", Nevin Liber, C++ Library Evolution Working +// Group Working Paper N3884. +// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3884.pdf +// +// Methods begin() and end() are also provided to enable range-based for. +// They are synonyms to cbegin() and cend(), respectively. +template +class CompilationResult { + public: + typedef OutputElementType element_type; + // The type used to describe the begin and end iterators on the + // compiler output. + typedef const OutputElementType* const_iterator; + + // Upon creation, the CompilationResult takes ownership of the + // shaderc_compilation_result instance. During destruction of the + // CompilationResult, the shaderc_compilation_result will be released. + explicit CompilationResult(shaderc_compilation_result_t compilation_result) + : compilation_result_(compilation_result) {} + CompilationResult() : compilation_result_(nullptr) {} + ~CompilationResult() { shaderc_result_release(compilation_result_); } + + CompilationResult(CompilationResult&& other) : compilation_result_(nullptr) { + *this = std::move(other); + } + + CompilationResult& operator=(CompilationResult&& other) { + if (compilation_result_) { + shaderc_result_release(compilation_result_); + } + compilation_result_ = other.compilation_result_; + other.compilation_result_ = nullptr; + return *this; + } + + // Returns any error message found during compilation. + std::string GetErrorMessage() const { + if (!compilation_result_) { + return ""; + } + return shaderc_result_get_error_message(compilation_result_); + } + + // Returns the compilation status, indicating whether the compilation + // succeeded, or failed due to some reasons, like invalid shader stage or + // compilation errors. + shaderc_compilation_status GetCompilationStatus() const { + if (!compilation_result_) { + return shaderc_compilation_status_null_result_object; + } + return shaderc_result_get_compilation_status(compilation_result_); + } + + // Returns a random access (contiguous) iterator pointing to the start + // of the compilation output. It is valid for the lifetime of this object. + // If there is no compilation result, then returns nullptr. + const_iterator cbegin() const { + if (!compilation_result_) return nullptr; + return reinterpret_cast( + shaderc_result_get_bytes(compilation_result_)); + } + + // Returns a random access (contiguous) iterator pointing to the end of + // the compilation output. It is valid for the lifetime of this object. + // If there is no compilation result, then returns nullptr. + const_iterator cend() const { + if (!compilation_result_) return nullptr; + return cbegin() + + shaderc_result_get_length(compilation_result_) / + sizeof(OutputElementType); + } + + // Returns the same iterator as cbegin(). + const_iterator begin() const { return cbegin(); } + // Returns the same iterator as cend(). + const_iterator end() const { return cend(); } + + // Returns the number of warnings generated during the compilation. + size_t GetNumWarnings() const { + if (!compilation_result_) { + return 0; + } + return shaderc_result_get_num_warnings(compilation_result_); + } + + // Returns the number of errors generated during the compilation. + size_t GetNumErrors() const { + if (!compilation_result_) { + return 0; + } + return shaderc_result_get_num_errors(compilation_result_); + } + + private: + CompilationResult(const CompilationResult& other) = delete; + CompilationResult& operator=(const CompilationResult& other) = delete; + + shaderc_compilation_result_t compilation_result_; +}; + +// A compilation result for a SPIR-V binary module, which is an array +// of uint32_t words. +using SpvCompilationResult = CompilationResult; +// A compilation result in SPIR-V assembly syntax. +using AssemblyCompilationResult = CompilationResult; +// Preprocessed source text. +using PreprocessedSourceCompilationResult = CompilationResult; + +// Contains any options that can have default values for a compilation. +class CompileOptions { + public: + CompileOptions() { options_ = shaderc_compile_options_initialize(); } + ~CompileOptions() { shaderc_compile_options_release(options_); } + CompileOptions(const CompileOptions& other) { + options_ = shaderc_compile_options_clone(other.options_); + } + CompileOptions(CompileOptions&& other) { + options_ = other.options_; + other.options_ = nullptr; + } + + // Adds a predefined macro to the compilation options. It behaves the same as + // shaderc_compile_options_add_macro_definition in shaderc.h. + void AddMacroDefinition(const char* name, size_t name_length, + const char* value, size_t value_length) { + shaderc_compile_options_add_macro_definition(options_, name, name_length, + value, value_length); + } + + // Adds a valueless predefined macro to the compilation options. + void AddMacroDefinition(const std::string& name) { + AddMacroDefinition(name.c_str(), name.size(), nullptr, 0u); + } + + // Adds a predefined macro to the compilation options. + void AddMacroDefinition(const std::string& name, const std::string& value) { + AddMacroDefinition(name.c_str(), name.size(), value.c_str(), value.size()); + } + + // Sets the compiler mode to generate debug information in the output. + void SetGenerateDebugInfo() { + shaderc_compile_options_set_generate_debug_info(options_); + } + + // Sets the compiler optimization level to the given level. Only the last one + // takes effect if multiple calls of this function exist. + void SetOptimizationLevel(shaderc_optimization_level level) { + shaderc_compile_options_set_optimization_level(options_, level); + } + + // A C++ version of the libshaderc includer interface. + class IncluderInterface { + public: + // Handles shaderc_include_resolver_fn callbacks. + virtual shaderc_include_result* GetInclude(const char* requested_source, + shaderc_include_type type, + const char* requesting_source, + size_t include_depth) = 0; + + // Handles shaderc_include_result_release_fn callbacks. + virtual void ReleaseInclude(shaderc_include_result* data) = 0; + + virtual ~IncluderInterface() = default; + }; + + // Sets the includer instance for libshaderc to call during compilation, as + // described in shaderc_compile_options_set_include_callbacks(). Callbacks + // are routed to this includer's methods. + void SetIncluder(std::unique_ptr&& includer) { + includer_ = std::move(includer); + shaderc_compile_options_set_include_callbacks( + options_, + [](void* user_data, const char* requested_source, int type, + const char* requesting_source, size_t include_depth) { + auto* sub_includer = static_cast(user_data); + return sub_includer->GetInclude( + requested_source, static_cast(type), + requesting_source, include_depth); + }, + [](void* user_data, shaderc_include_result* include_result) { + auto* sub_includer = static_cast(user_data); + return sub_includer->ReleaseInclude(include_result); + }, + includer_.get()); + } + + // Forces the GLSL language version and profile to a given pair. The version + // number is the same as would appear in the #version annotation in the + // source. Version and profile specified here overrides the #version + // annotation in the source. Use profile: 'shaderc_profile_none' for GLSL + // versions that do not define profiles, e.g. versions below 150. + void SetForcedVersionProfile(int version, shaderc_profile profile) { + shaderc_compile_options_set_forced_version_profile(options_, version, + profile); + } + + // Sets the compiler mode to suppress warnings. Note this option overrides + // warnings-as-errors mode. When both suppress-warnings and warnings-as-errors + // modes are turned on, warning messages will be inhibited, and will not be + // emitted as error message. + void SetSuppressWarnings() { + shaderc_compile_options_set_suppress_warnings(options_); + } + + // Sets the source language. The default is GLSL. + void SetSourceLanguage(shaderc_source_language lang) { + shaderc_compile_options_set_source_language(options_, lang); + } + + // Sets the target shader environment, affecting which warnings or errors will + // be issued. The version will be for distinguishing between different + // versions of the target environment. The version value should be either 0 + // or a value listed in shaderc_env_version. The 0 value maps to Vulkan 1.0 + // if |target| is Vulkan, and it maps to OpenGL 4.5 if |target| is OpenGL. + void SetTargetEnvironment(shaderc_target_env target, uint32_t version) { + shaderc_compile_options_set_target_env(options_, target, version); + } + + // Sets the target SPIR-V version. The generated module will use this version + // of SPIR-V. Each target environment determines what versions of SPIR-V + // it can consume. Defaults to the highest version of SPIR-V 1.0 which is + // required to be supported by the target environment. E.g. Default to SPIR-V + // 1.0 for Vulkan 1.0 and SPIR-V 1.3 for Vulkan 1.1. + void SetTargetSpirv(shaderc_spirv_version version) { + shaderc_compile_options_set_target_spirv(options_, version); + } + + // Sets the compiler mode to make all warnings into errors. Note the + // suppress-warnings mode overrides this option, i.e. if both + // warning-as-errors and suppress-warnings modes are set on, warnings will not + // be emitted as error message. + void SetWarningsAsErrors() { + shaderc_compile_options_set_warnings_as_errors(options_); + } + + // Sets a resource limit. + void SetLimit(shaderc_limit limit, int value) { + shaderc_compile_options_set_limit(options_, limit, value); + } + + // Sets whether the compiler should automatically assign bindings to uniforms + // that aren't already explicitly bound in the shader source. + void SetAutoBindUniforms(bool auto_bind) { + shaderc_compile_options_set_auto_bind_uniforms(options_, auto_bind); + } + + // Sets whether the compiler should automatically remove sampler variables + // and convert image variables to combined image sampler variables. + void SetAutoSampledTextures(bool auto_sampled) { + shaderc_compile_options_set_auto_combined_image_sampler(options_, + auto_sampled); + } + + // Sets whether the compiler should use HLSL IO mapping rules for bindings. + // Defaults to false. + void SetHlslIoMapping(bool hlsl_iomap) { + shaderc_compile_options_set_hlsl_io_mapping(options_, hlsl_iomap); + } + + // Sets whether the compiler should determine block member offsets using HLSL + // packing rules instead of standard GLSL rules. Defaults to false. Only + // affects GLSL compilation. HLSL rules are always used when compiling HLSL. + void SetHlslOffsets(bool hlsl_offsets) { + shaderc_compile_options_set_hlsl_offsets(options_, hlsl_offsets); + } + + // Sets the base binding number used for for a uniform resource type when + // automatically assigning bindings. For GLSL compilation, sets the lowest + // automatically assigned number. For HLSL compilation, the regsiter number + // assigned to the resource is added to this specified base. + void SetBindingBase(shaderc_uniform_kind kind, uint32_t base) { + shaderc_compile_options_set_binding_base(options_, kind, base); + } + + // Like SetBindingBase, but only takes effect when compiling a given shader + // stage. The stage is assumed to be one of vertex, fragment, tessellation + // evaluation, tesselation control, geometry, or compute. + void SetBindingBaseForStage(shaderc_shader_kind shader_kind, + shaderc_uniform_kind kind, uint32_t base) { + shaderc_compile_options_set_binding_base_for_stage(options_, shader_kind, + kind, base); + } + + // Sets whether the compiler should preserve all bindings, even when those + // bindings are not used. + void SetPreserveBindings(bool preserve_bindings) { + shaderc_compile_options_set_preserve_bindings(options_, preserve_bindings); + } + + void SetMaxIdBound(uint32_t max_id_bound) { + shaderc_compile_options_set_max_id_bound(options_, max_id_bound); + } + + // Sets whether the compiler automatically assigns locations to + // uniform variables that don't have explicit locations. + void SetAutoMapLocations(bool auto_map) { + shaderc_compile_options_set_auto_map_locations(options_, auto_map); + } + + // Sets a descriptor set and binding for an HLSL register in the given stage. + // Copies the parameter strings. + void SetHlslRegisterSetAndBindingForStage(shaderc_shader_kind shader_kind, + const std::string& reg, + const std::string& set, + const std::string& binding) { + shaderc_compile_options_set_hlsl_register_set_and_binding_for_stage( + options_, shader_kind, reg.c_str(), set.c_str(), binding.c_str()); + } + + // Sets a descriptor set and binding for an HLSL register in any stage. + // Copies the parameter strings. + void SetHlslRegisterSetAndBinding(const std::string& reg, + const std::string& set, + const std::string& binding) { + shaderc_compile_options_set_hlsl_register_set_and_binding( + options_, reg.c_str(), set.c_str(), binding.c_str()); + } + + // Sets whether the compiler should enable extension + // SPV_GOOGLE_hlsl_functionality1. + void SetHlslFunctionality1(bool enable) { + shaderc_compile_options_set_hlsl_functionality1(options_, enable); + } + + // Sets whether 16-bit types are supported in HLSL or not. + void SetHlsl16BitTypes(bool enable) { + shaderc_compile_options_set_hlsl_16bit_types(options_, enable); + } + + // Enables or disables relaxed Vulkan rules. + // + // This allows most OpenGL shaders to compile under Vulkan semantics. + void SetVulkanRulesRelaxed(bool enable) { + shaderc_compile_options_set_vulkan_rules_relaxed(options_, enable); + } + + // Sets whether the compiler should invert position.Y output in vertex shader. + void SetInvertY(bool enable) { + shaderc_compile_options_set_invert_y(options_, enable); + } + + // Sets whether the compiler should generate code for max and min which, + // if given a NaN operand, will return the other operand. Similarly, the + // clamp builtin will favour the non-NaN operands, as if clamp were + // implemented as a composition of max and min. + void SetNanClamp(bool enable) { + shaderc_compile_options_set_nan_clamp(options_, enable); + } + + private: + CompileOptions& operator=(const CompileOptions& other) = delete; + shaderc_compile_options_t options_; + std::unique_ptr includer_; + + friend class Compiler; +}; + +// The compilation context for compiling source to SPIR-V. +class Compiler { + public: + Compiler() : compiler_(shaderc_compiler_initialize()) {} + ~Compiler() { shaderc_compiler_release(compiler_); } + + Compiler(Compiler&& other) { + compiler_ = other.compiler_; + other.compiler_ = nullptr; + } + + bool IsValid() const { return compiler_ != nullptr; } + + // Compiles the given source GLSL and returns a SPIR-V binary module + // compilation result. + // The source_text parameter must be a valid pointer. + // The source_text_size parameter must be the length of the source text. + // The shader_kind parameter either forces the compilation to be done with a + // specified shader kind, or hint the compiler how to determine the exact + // shader kind. If the shader kind is set to shaderc_glslc_infer_from_source, + // the compiler will try to deduce the shader kind from the source string and + // a failure in this proess will generate an error. Currently only #pragma + // annotation is supported. If the shader kind is set to one of the default + // shader kinds, the compiler will fall back to the specified default shader + // kind in case it failed to deduce the shader kind from the source string. + // The input_file_name is a null-termintated string. It is used as a tag to + // identify the source string in cases like emitting error messages. It + // doesn't have to be a 'file name'. + // The entry_point_name parameter is a null-terminated string specifying + // the entry point name for HLSL compilation. For GLSL compilation, the + // entry point name is assumed to be "main". + // The compilation is passed any options specified in the CompileOptions + // parameter. + // It is valid for the returned CompilationResult object to outlive this + // compiler object. + // Note when the options_ has disassembly mode or preprocessing only mode set + // on, the returned CompilationResult will hold a text string, instead of a + // SPIR-V binary generated with default options. + SpvCompilationResult CompileGlslToSpv(const char* source_text, + size_t source_text_size, + shaderc_shader_kind shader_kind, + const char* input_file_name, + const char* entry_point_name, + const CompileOptions& options) const { + shaderc_compilation_result_t compilation_result = shaderc_compile_into_spv( + compiler_, source_text, source_text_size, shader_kind, input_file_name, + entry_point_name, options.options_); + return SpvCompilationResult(compilation_result); + } + + // Compiles the given source shader and returns a SPIR-V binary module + // compilation result. + // Like the first CompileGlslToSpv method but assumes the entry point name + // is "main". + SpvCompilationResult CompileGlslToSpv(const char* source_text, + size_t source_text_size, + shaderc_shader_kind shader_kind, + const char* input_file_name, + const CompileOptions& options) const { + return CompileGlslToSpv(source_text, source_text_size, shader_kind, + input_file_name, "main", options); + } + + // Compiles the given source GLSL and returns a SPIR-V binary module + // compilation result. + // Like the previous CompileGlslToSpv method but uses default options. + SpvCompilationResult CompileGlslToSpv(const char* source_text, + size_t source_text_size, + shaderc_shader_kind shader_kind, + const char* input_file_name) const { + shaderc_compilation_result_t compilation_result = + shaderc_compile_into_spv(compiler_, source_text, source_text_size, + shader_kind, input_file_name, "main", nullptr); + return SpvCompilationResult(compilation_result); + } + + // Compiles the given source shader and returns a SPIR-V binary module + // compilation result. + // Like the first CompileGlslToSpv method but the source is provided as + // a std::string, and we assume the entry point is "main". + SpvCompilationResult CompileGlslToSpv(const std::string& source_text, + shaderc_shader_kind shader_kind, + const char* input_file_name, + const CompileOptions& options) const { + return CompileGlslToSpv(source_text.data(), source_text.size(), shader_kind, + input_file_name, options); + } + + // Compiles the given source shader and returns a SPIR-V binary module + // compilation result. + // Like the first CompileGlslToSpv method but the source is provided as + // a std::string. + SpvCompilationResult CompileGlslToSpv(const std::string& source_text, + shaderc_shader_kind shader_kind, + const char* input_file_name, + const char* entry_point_name, + const CompileOptions& options) const { + return CompileGlslToSpv(source_text.data(), source_text.size(), shader_kind, + input_file_name, entry_point_name, options); + } + + // Compiles the given source GLSL and returns a SPIR-V binary module + // compilation result. + // Like the previous CompileGlslToSpv method but assumes the entry point + // name is "main". + SpvCompilationResult CompileGlslToSpv(const std::string& source_text, + shaderc_shader_kind shader_kind, + const char* input_file_name) const { + return CompileGlslToSpv(source_text.data(), source_text.size(), shader_kind, + input_file_name); + } + + // Assembles the given SPIR-V assembly and returns a SPIR-V binary module + // compilation result. + // The assembly should follow the syntax defined in the SPIRV-Tools project + // (https://github.com/KhronosGroup/SPIRV-Tools/blob/master/syntax.md). + // It is valid for the returned CompilationResult object to outlive this + // compiler object. + // The assembling will pick options suitable for assembling specified in the + // CompileOptions parameter. + SpvCompilationResult AssembleToSpv(const char* source_assembly, + size_t source_assembly_size, + const CompileOptions& options) const { + return SpvCompilationResult(shaderc_assemble_into_spv( + compiler_, source_assembly, source_assembly_size, options.options_)); + } + + // Assembles the given SPIR-V assembly and returns a SPIR-V binary module + // compilation result. + // Like the first AssembleToSpv method but uses the default compiler options. + SpvCompilationResult AssembleToSpv(const char* source_assembly, + size_t source_assembly_size) const { + return SpvCompilationResult(shaderc_assemble_into_spv( + compiler_, source_assembly, source_assembly_size, nullptr)); + } + + // Assembles the given SPIR-V assembly and returns a SPIR-V binary module + // compilation result. + // Like the first AssembleToSpv method but the source is provided as a + // std::string. + SpvCompilationResult AssembleToSpv(const std::string& source_assembly, + const CompileOptions& options) const { + return SpvCompilationResult( + shaderc_assemble_into_spv(compiler_, source_assembly.data(), + source_assembly.size(), options.options_)); + } + + // Assembles the given SPIR-V assembly and returns a SPIR-V binary module + // compilation result. + // Like the first AssembleToSpv method but the source is provided as a + // std::string and also uses default compiler options. + SpvCompilationResult AssembleToSpv(const std::string& source_assembly) const { + return SpvCompilationResult(shaderc_assemble_into_spv( + compiler_, source_assembly.data(), source_assembly.size(), nullptr)); + } + + // Compiles the given source GLSL and returns the SPIR-V assembly text + // compilation result. + // Options are similar to the first CompileToSpv method. + AssemblyCompilationResult CompileGlslToSpvAssembly( + const char* source_text, size_t source_text_size, + shaderc_shader_kind shader_kind, const char* input_file_name, + const char* entry_point_name, const CompileOptions& options) const { + shaderc_compilation_result_t compilation_result = + shaderc_compile_into_spv_assembly( + compiler_, source_text, source_text_size, shader_kind, + input_file_name, entry_point_name, options.options_); + return AssemblyCompilationResult(compilation_result); + } + + // Compiles the given source GLSL and returns the SPIR-V assembly text + // compilation result. + // Similare to the previous method, but assumes entry point name is "main". + AssemblyCompilationResult CompileGlslToSpvAssembly( + const char* source_text, size_t source_text_size, + shaderc_shader_kind shader_kind, const char* input_file_name, + const CompileOptions& options) const { + return CompileGlslToSpvAssembly(source_text, source_text_size, shader_kind, + input_file_name, "main", options); + } + + // Compiles the given source GLSL and returns the SPIR-V assembly text + // result. Like the first CompileGlslToSpvAssembly method but the source + // is provided as a std::string. Options are otherwise similar to + // the first CompileToSpv method. + AssemblyCompilationResult CompileGlslToSpvAssembly( + const std::string& source_text, shaderc_shader_kind shader_kind, + const char* input_file_name, const char* entry_point_name, + const CompileOptions& options) const { + return CompileGlslToSpvAssembly(source_text.data(), source_text.size(), + shader_kind, input_file_name, + entry_point_name, options); + } + + // Compiles the given source GLSL and returns the SPIR-V assembly text + // result. Like the previous CompileGlslToSpvAssembly method but assumes + // the entry point name is "main". + AssemblyCompilationResult CompileGlslToSpvAssembly( + const std::string& source_text, shaderc_shader_kind shader_kind, + const char* input_file_name, const CompileOptions& options) const { + return CompileGlslToSpvAssembly(source_text, shader_kind, input_file_name, + "main", options); + } + + // Preprocesses the given source GLSL and returns the preprocessed + // source text as a compilation result. + // Options are similar to the first CompileToSpv method. + PreprocessedSourceCompilationResult PreprocessGlsl( + const char* source_text, size_t source_text_size, + shaderc_shader_kind shader_kind, const char* input_file_name, + const CompileOptions& options) const { + shaderc_compilation_result_t compilation_result = + shaderc_compile_into_preprocessed_text( + compiler_, source_text, source_text_size, shader_kind, + input_file_name, "main", options.options_); + return PreprocessedSourceCompilationResult(compilation_result); + } + + // Preprocesses the given source GLSL and returns text result. Like the first + // PreprocessGlsl method but the source is provided as a std::string. + // Options are otherwise similar to the first CompileToSpv method. + PreprocessedSourceCompilationResult PreprocessGlsl( + const std::string& source_text, shaderc_shader_kind shader_kind, + const char* input_file_name, const CompileOptions& options) const { + return PreprocessGlsl(source_text.data(), source_text.size(), shader_kind, + input_file_name, options); + } + + private: + Compiler(const Compiler&) = delete; + Compiler& operator=(const Compiler& other) = delete; + + shaderc_compiler_t compiler_; +}; +} // namespace shaderc + +#endif // SHADERC_SHADERC_HPP_ diff --git a/lib/shaderc-headers/include/shaderc/status.h b/lib/shaderc-headers/include/shaderc/status.h new file mode 100644 index 00000000000..57ac70d7ef5 --- /dev/null +++ b/lib/shaderc-headers/include/shaderc/status.h @@ -0,0 +1,39 @@ +// Copyright 2018 The Shaderc Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef SHADERC_STATUS_H_ +#define SHADERC_STATUS_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +// Indicate the status of a compilation. +typedef enum { + shaderc_compilation_status_success = 0, + shaderc_compilation_status_invalid_stage = 1, // error stage deduction + shaderc_compilation_status_compilation_error = 2, + shaderc_compilation_status_internal_error = 3, // unexpected failure + shaderc_compilation_status_null_result_object = 4, + shaderc_compilation_status_invalid_assembly = 5, + shaderc_compilation_status_validation_error = 6, + shaderc_compilation_status_transformation_error = 7, + shaderc_compilation_status_configuration_error = 8, +} shaderc_compilation_status; + +#ifdef __cplusplus +} +#endif // __cplusplus + +#endif // SHADERC_STATUS_H_ diff --git a/lib/shaderc-headers/include/shaderc/visibility.h b/lib/shaderc-headers/include/shaderc/visibility.h new file mode 100644 index 00000000000..88ec151bfa9 --- /dev/null +++ b/lib/shaderc-headers/include/shaderc/visibility.h @@ -0,0 +1,37 @@ +// Copyright 2018 The Shaderc Authors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef SHADERC_VISIBILITY_H_ +#define SHADERC_VISIBILITY_H_ + +// SHADERC_EXPORT tags symbol that will be exposed by the shared libraries. +#if defined(SHADERC_SHAREDLIB) +#if defined(_WIN32) +#if defined(SHADERC_IMPLEMENTATION) +#define SHADERC_EXPORT __declspec(dllexport) +#else +#define SHADERC_EXPORT __declspec(dllimport) +#endif +#else +#if defined(SHADERC_IMPLEMENTATION) +#define SHADERC_EXPORT __attribute__((visibility("default"))) +#else +#define SHADERC_EXPORT +#endif +#endif +#else +#define SHADERC_EXPORT +#endif + +#endif // SHADERC_VISIBILITY_H_ From 28a16b7c8b1606b3877fa9056bb587e14ea43140 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Wed, 22 Jul 2026 21:08:58 -0300 Subject: [PATCH 07/15] remove headers --- lib/shaderc-headers/include/shaderc/env.h | 73 - lib/shaderc-headers/include/shaderc/shaderc.h | 622 - .../include/shaderc/shaderc.hpp | 624 - lib/shaderc-headers/include/shaderc/status.h | 39 - .../include/shaderc/visibility.h | 37 - .../vk_video/vulkan_video_codec_av1std.h | 394 - .../vulkan_video_codec_av1std_decode.h | 109 - .../vulkan_video_codec_av1std_encode.h | 143 - .../vk_video/vulkan_video_codec_h264std.h | 312 - .../vulkan_video_codec_h264std_decode.h | 77 - .../vulkan_video_codec_h264std_encode.h | 147 - .../vk_video/vulkan_video_codec_h265std.h | 446 - .../vulkan_video_codec_h265std_decode.h | 67 - .../vulkan_video_codec_h265std_encode.h | 157 - .../vk_video/vulkan_video_codec_vp9std.h | 151 - .../vulkan_video_codec_vp9std_decode.h | 68 - .../vk_video/vulkan_video_codecs_common.h | 36 - lib/vulkan-headers/include/vulkan/vk_icd.h | 245 - lib/vulkan-headers/include/vulkan/vk_layer.h | 192 - .../include/vulkan/vk_platform.h | 84 - lib/vulkan-headers/include/vulkan/vulkan.cppm | 10847 - lib/vulkan-headers/include/vulkan/vulkan.h | 103 - lib/vulkan-headers/include/vulkan/vulkan.hpp | 25659 -- .../include/vulkan/vulkan_android.h | 159 - .../include/vulkan/vulkan_beta.h | 375 - .../include/vulkan/vulkan_core.h | 25278 -- .../include/vulkan/vulkan_directfb.h | 59 - .../include/vulkan/vulkan_enums.hpp | 9806 - .../vulkan/vulkan_extension_inspection.hpp | 4155 - .../include/vulkan/vulkan_format_traits.hpp | 10576 - .../include/vulkan/vulkan_fuchsia.h | 282 - .../include/vulkan/vulkan_funcs.hpp | 32761 --- .../include/vulkan/vulkan_ggp.h | 62 - .../include/vulkan/vulkan_handles.hpp | 22749 -- .../include/vulkan/vulkan_hash.hpp | 21424 -- .../include/vulkan/vulkan_hpp_macros.hpp | 337 - .../include/vulkan/vulkan_ios.h | 50 - .../include/vulkan/vulkan_macos.h | 50 - .../include/vulkan/vulkan_metal.h | 244 - .../include/vulkan/vulkan_ohos.h | 120 - .../include/vulkan/vulkan_raii.hpp | 28565 -- .../include/vulkan/vulkan_screen.h | 114 - .../include/vulkan/vulkan_shared.hpp | 1197 - .../vulkan/vulkan_static_assertions.hpp | 9861 - .../include/vulkan/vulkan_structs.hpp | 206351 --------------- .../include/vulkan/vulkan_to_string.hpp | 11091 - lib/vulkan-headers/include/vulkan/vulkan_vi.h | 50 - .../include/vulkan/vulkan_video.cppm | 324 - .../include/vulkan/vulkan_video.hpp | 5529 - .../include/vulkan/vulkan_wayland.h | 59 - .../include/vulkan/vulkan_win32.h | 372 - .../include/vulkan/vulkan_xcb.h | 60 - .../include/vulkan/vulkan_xlib.h | 60 - .../include/vulkan/vulkan_xlib_xrandr.h | 50 - 54 files changed, 432802 deletions(-) delete mode 100644 lib/shaderc-headers/include/shaderc/env.h delete mode 100644 lib/shaderc-headers/include/shaderc/shaderc.h delete mode 100644 lib/shaderc-headers/include/shaderc/shaderc.hpp delete mode 100644 lib/shaderc-headers/include/shaderc/status.h delete mode 100644 lib/shaderc-headers/include/shaderc/visibility.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_decode.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_encode.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_decode.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_encode.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_decode.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_encode.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std_decode.h delete mode 100644 lib/vulkan-headers/include/vk_video/vulkan_video_codecs_common.h delete mode 100644 lib/vulkan-headers/include/vulkan/vk_icd.h delete mode 100644 lib/vulkan-headers/include/vulkan/vk_layer.h delete mode 100644 lib/vulkan-headers/include/vulkan/vk_platform.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan.cppm delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_android.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_beta.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_core.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_directfb.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_enums.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_extension_inspection.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_format_traits.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_fuchsia.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_funcs.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_ggp.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_handles.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_hash.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_hpp_macros.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_ios.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_macos.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_metal.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_ohos.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_raii.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_screen.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_shared.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_static_assertions.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_structs.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_to_string.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_vi.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_video.cppm delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_video.hpp delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_wayland.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_win32.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_xcb.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_xlib.h delete mode 100644 lib/vulkan-headers/include/vulkan/vulkan_xlib_xrandr.h diff --git a/lib/shaderc-headers/include/shaderc/env.h b/lib/shaderc-headers/include/shaderc/env.h deleted file mode 100644 index 3d32b2a9a06..00000000000 --- a/lib/shaderc-headers/include/shaderc/env.h +++ /dev/null @@ -1,73 +0,0 @@ -// Copyright 2018 The Shaderc Authors. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef SHADERC_ENV_H_ -#define SHADERC_ENV_H_ - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -typedef enum { - shaderc_target_env_vulkan, // SPIR-V under Vulkan semantics - shaderc_target_env_opengl, // SPIR-V under OpenGL semantics - // NOTE: SPIR-V code generation is not supported for shaders under OpenGL - // compatibility profile. - shaderc_target_env_opengl_compat, // SPIR-V under OpenGL semantics, - // including compatibility profile - // functions - shaderc_target_env_webgpu, // Deprecated, SPIR-V under WebGPU - // semantics - shaderc_target_env_default = shaderc_target_env_vulkan -} shaderc_target_env; - -typedef enum { - // For Vulkan, use Vulkan's mapping of version numbers to integers. - // See vulkan.h - shaderc_env_version_vulkan_1_0 = ((1u << 22)), - shaderc_env_version_vulkan_1_1 = ((1u << 22) | (1 << 12)), - shaderc_env_version_vulkan_1_2 = ((1u << 22) | (2 << 12)), - shaderc_env_version_vulkan_1_3 = ((1u << 22) | (3 << 12)), - shaderc_env_version_vulkan_1_4 = ((1u << 22) | (4 << 12)), - // For OpenGL, use the number from #version in shaders. - // TODO(dneto): Currently no difference between OpenGL 4.5 and 4.6. - // See glslang/Standalone/Standalone.cpp - // TODO(dneto): Glslang doesn't accept a OpenGL client version of 460. - shaderc_env_version_opengl_4_5 = 450, - shaderc_env_version_webgpu, // Deprecated, WebGPU env never defined versions -} shaderc_env_version; - -// The known versions of SPIR-V. -typedef enum { - // Use the values used for word 1 of a SPIR-V binary: - // - bits 24 to 31: zero - // - bits 16 to 23: major version number - // - bits 8 to 15: minor version number - // - bits 0 to 7: zero - shaderc_spirv_version_1_0 = 0x010000u, - shaderc_spirv_version_1_1 = 0x010100u, - shaderc_spirv_version_1_2 = 0x010200u, - shaderc_spirv_version_1_3 = 0x010300u, - shaderc_spirv_version_1_4 = 0x010400u, - shaderc_spirv_version_1_5 = 0x010500u, - shaderc_spirv_version_1_6 = 0x010600u -} shaderc_spirv_version; - -#ifdef __cplusplus -} -#endif // __cplusplus - -#endif // SHADERC_ENV_H_ diff --git a/lib/shaderc-headers/include/shaderc/shaderc.h b/lib/shaderc-headers/include/shaderc/shaderc.h deleted file mode 100644 index dd40744d0f5..00000000000 --- a/lib/shaderc-headers/include/shaderc/shaderc.h +++ /dev/null @@ -1,622 +0,0 @@ -// Copyright 2015 The Shaderc Authors. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef SHADERC_SHADERC_H_ -#define SHADERC_SHADERC_H_ - -#ifdef __cplusplus -extern "C" { -#endif - -#include -#include -#include - -#include "shaderc/env.h" -#include "shaderc/status.h" -#include "shaderc/visibility.h" - -// Source language kind. -typedef enum { - shaderc_source_language_glsl, - shaderc_source_language_hlsl, -} shaderc_source_language; - -typedef enum { - // Forced shader kinds. These shader kinds force the compiler to compile the - // source code as the specified kind of shader. - shaderc_vertex_shader, - shaderc_fragment_shader, - shaderc_compute_shader, - shaderc_geometry_shader, - shaderc_tess_control_shader, - shaderc_tess_evaluation_shader, - - shaderc_glsl_vertex_shader = shaderc_vertex_shader, - shaderc_glsl_fragment_shader = shaderc_fragment_shader, - shaderc_glsl_compute_shader = shaderc_compute_shader, - shaderc_glsl_geometry_shader = shaderc_geometry_shader, - shaderc_glsl_tess_control_shader = shaderc_tess_control_shader, - shaderc_glsl_tess_evaluation_shader = shaderc_tess_evaluation_shader, - - // Deduce the shader kind from #pragma annotation in the source code. Compiler - // will emit error if #pragma annotation is not found. - shaderc_glsl_infer_from_source, - // Default shader kinds. Compiler will fall back to compile the source code as - // the specified kind of shader when #pragma annotation is not found in the - // source code. - shaderc_glsl_default_vertex_shader, - shaderc_glsl_default_fragment_shader, - shaderc_glsl_default_compute_shader, - shaderc_glsl_default_geometry_shader, - shaderc_glsl_default_tess_control_shader, - shaderc_glsl_default_tess_evaluation_shader, - shaderc_spirv_assembly, - shaderc_raygen_shader, - shaderc_anyhit_shader, - shaderc_closesthit_shader, - shaderc_miss_shader, - shaderc_intersection_shader, - shaderc_callable_shader, - shaderc_glsl_raygen_shader = shaderc_raygen_shader, - shaderc_glsl_anyhit_shader = shaderc_anyhit_shader, - shaderc_glsl_closesthit_shader = shaderc_closesthit_shader, - shaderc_glsl_miss_shader = shaderc_miss_shader, - shaderc_glsl_intersection_shader = shaderc_intersection_shader, - shaderc_glsl_callable_shader = shaderc_callable_shader, - shaderc_glsl_default_raygen_shader, - shaderc_glsl_default_anyhit_shader, - shaderc_glsl_default_closesthit_shader, - shaderc_glsl_default_miss_shader, - shaderc_glsl_default_intersection_shader, - shaderc_glsl_default_callable_shader, - shaderc_task_shader, - shaderc_mesh_shader, - shaderc_glsl_task_shader = shaderc_task_shader, - shaderc_glsl_mesh_shader = shaderc_mesh_shader, - shaderc_glsl_default_task_shader, - shaderc_glsl_default_mesh_shader, -} shaderc_shader_kind; - -typedef enum { - shaderc_profile_none, // Used if and only if GLSL version did not specify - // profiles. - shaderc_profile_core, - shaderc_profile_compatibility, // Disabled. This generates an error - shaderc_profile_es, -} shaderc_profile; - -// Optimization level. -typedef enum { - shaderc_optimization_level_zero, // no optimization - shaderc_optimization_level_size, // optimize towards reducing code size - shaderc_optimization_level_performance, // optimize towards performance -} shaderc_optimization_level; - -// Resource limits. -typedef enum { - shaderc_limit_max_lights, - shaderc_limit_max_clip_planes, - shaderc_limit_max_texture_units, - shaderc_limit_max_texture_coords, - shaderc_limit_max_vertex_attribs, - shaderc_limit_max_vertex_uniform_components, - shaderc_limit_max_varying_floats, - shaderc_limit_max_vertex_texture_image_units, - shaderc_limit_max_combined_texture_image_units, - shaderc_limit_max_texture_image_units, - shaderc_limit_max_fragment_uniform_components, - shaderc_limit_max_draw_buffers, - shaderc_limit_max_vertex_uniform_vectors, - shaderc_limit_max_varying_vectors, - shaderc_limit_max_fragment_uniform_vectors, - shaderc_limit_max_vertex_output_vectors, - shaderc_limit_max_fragment_input_vectors, - shaderc_limit_min_program_texel_offset, - shaderc_limit_max_program_texel_offset, - shaderc_limit_max_clip_distances, - shaderc_limit_max_compute_work_group_count_x, - shaderc_limit_max_compute_work_group_count_y, - shaderc_limit_max_compute_work_group_count_z, - shaderc_limit_max_compute_work_group_size_x, - shaderc_limit_max_compute_work_group_size_y, - shaderc_limit_max_compute_work_group_size_z, - shaderc_limit_max_compute_uniform_components, - shaderc_limit_max_compute_texture_image_units, - shaderc_limit_max_compute_image_uniforms, - shaderc_limit_max_compute_atomic_counters, - shaderc_limit_max_compute_atomic_counter_buffers, - shaderc_limit_max_varying_components, - shaderc_limit_max_vertex_output_components, - shaderc_limit_max_geometry_input_components, - shaderc_limit_max_geometry_output_components, - shaderc_limit_max_fragment_input_components, - shaderc_limit_max_image_units, - shaderc_limit_max_combined_image_units_and_fragment_outputs, - shaderc_limit_max_combined_shader_output_resources, - shaderc_limit_max_image_samples, - shaderc_limit_max_vertex_image_uniforms, - shaderc_limit_max_tess_control_image_uniforms, - shaderc_limit_max_tess_evaluation_image_uniforms, - shaderc_limit_max_geometry_image_uniforms, - shaderc_limit_max_fragment_image_uniforms, - shaderc_limit_max_combined_image_uniforms, - shaderc_limit_max_geometry_texture_image_units, - shaderc_limit_max_geometry_output_vertices, - shaderc_limit_max_geometry_total_output_components, - shaderc_limit_max_geometry_uniform_components, - shaderc_limit_max_geometry_varying_components, - shaderc_limit_max_tess_control_input_components, - shaderc_limit_max_tess_control_output_components, - shaderc_limit_max_tess_control_texture_image_units, - shaderc_limit_max_tess_control_uniform_components, - shaderc_limit_max_tess_control_total_output_components, - shaderc_limit_max_tess_evaluation_input_components, - shaderc_limit_max_tess_evaluation_output_components, - shaderc_limit_max_tess_evaluation_texture_image_units, - shaderc_limit_max_tess_evaluation_uniform_components, - shaderc_limit_max_tess_patch_components, - shaderc_limit_max_patch_vertices, - shaderc_limit_max_tess_gen_level, - shaderc_limit_max_viewports, - shaderc_limit_max_vertex_atomic_counters, - shaderc_limit_max_tess_control_atomic_counters, - shaderc_limit_max_tess_evaluation_atomic_counters, - shaderc_limit_max_geometry_atomic_counters, - shaderc_limit_max_fragment_atomic_counters, - shaderc_limit_max_combined_atomic_counters, - shaderc_limit_max_atomic_counter_bindings, - shaderc_limit_max_vertex_atomic_counter_buffers, - shaderc_limit_max_tess_control_atomic_counter_buffers, - shaderc_limit_max_tess_evaluation_atomic_counter_buffers, - shaderc_limit_max_geometry_atomic_counter_buffers, - shaderc_limit_max_fragment_atomic_counter_buffers, - shaderc_limit_max_combined_atomic_counter_buffers, - shaderc_limit_max_atomic_counter_buffer_size, - shaderc_limit_max_transform_feedback_buffers, - shaderc_limit_max_transform_feedback_interleaved_components, - shaderc_limit_max_cull_distances, - shaderc_limit_max_combined_clip_and_cull_distances, - shaderc_limit_max_samples, - shaderc_limit_max_mesh_output_vertices_nv, - shaderc_limit_max_mesh_output_primitives_nv, - shaderc_limit_max_mesh_work_group_size_x_nv, - shaderc_limit_max_mesh_work_group_size_y_nv, - shaderc_limit_max_mesh_work_group_size_z_nv, - shaderc_limit_max_task_work_group_size_x_nv, - shaderc_limit_max_task_work_group_size_y_nv, - shaderc_limit_max_task_work_group_size_z_nv, - shaderc_limit_max_mesh_view_count_nv, - shaderc_limit_max_mesh_output_vertices_ext, - shaderc_limit_max_mesh_output_primitives_ext, - shaderc_limit_max_mesh_work_group_size_x_ext, - shaderc_limit_max_mesh_work_group_size_y_ext, - shaderc_limit_max_mesh_work_group_size_z_ext, - shaderc_limit_max_task_work_group_size_x_ext, - shaderc_limit_max_task_work_group_size_y_ext, - shaderc_limit_max_task_work_group_size_z_ext, - shaderc_limit_max_mesh_view_count_ext, - shaderc_limit_max_dual_source_draw_buffers_ext, -} shaderc_limit; - -// Uniform resource kinds. -// In Vulkan, uniform resources are bound to the pipeline via descriptors -// with numbered bindings and sets. -typedef enum { - // Image and image buffer. - shaderc_uniform_kind_image, - // Pure sampler. - shaderc_uniform_kind_sampler, - // Sampled texture in GLSL, and Shader Resource View in HLSL. - shaderc_uniform_kind_texture, - // Uniform Buffer Object (UBO) in GLSL. Cbuffer in HLSL. - shaderc_uniform_kind_buffer, - // Shader Storage Buffer Object (SSBO) in GLSL. - shaderc_uniform_kind_storage_buffer, - // Unordered Access View, in HLSL. (Writable storage image or storage - // buffer.) - shaderc_uniform_kind_unordered_access_view, -} shaderc_uniform_kind; - -// Usage examples: -// -// Aggressively release compiler resources, but spend time in initialization -// for each new use. -// shaderc_compiler_t compiler = shaderc_compiler_initialize(); -// shaderc_compilation_result_t result = shaderc_compile_into_spv( -// compiler, "#version 450\nvoid main() {}", 27, -// shaderc_glsl_vertex_shader, "main.vert", "main", nullptr); -// // Do stuff with compilation results. -// shaderc_result_release(result); -// shaderc_compiler_release(compiler); -// -// Keep the compiler object around for a long time, but pay for extra space -// occupied. -// shaderc_compiler_t compiler = shaderc_compiler_initialize(); -// // On the same, other or multiple simultaneous threads. -// shaderc_compilation_result_t result = shaderc_compile_into_spv( -// compiler, "#version 450\nvoid main() {}", 27, -// shaderc_glsl_vertex_shader, "main.vert", "main", nullptr); -// // Do stuff with compilation results. -// shaderc_result_release(result); -// // Once no more compilations are to happen. -// shaderc_compiler_release(compiler); - -// An opaque handle to an object that manages all compiler state. -typedef struct shaderc_compiler* shaderc_compiler_t; - -// Returns a shaderc_compiler_t that can be used to compile modules. -// A return of NULL indicates that there was an error initializing the compiler. -// Any function operating on shaderc_compiler_t must offer the basic -// thread-safety guarantee. -// [http://herbsutter.com/2014/01/13/gotw-95-solution-thread-safety-and-synchronization/] -// That is: concurrent invocation of these functions on DIFFERENT objects needs -// no synchronization; concurrent invocation of these functions on the SAME -// object requires synchronization IF AND ONLY IF some of them take a non-const -// argument. -SHADERC_EXPORT shaderc_compiler_t shaderc_compiler_initialize(void); - -// Releases the resources held by the shaderc_compiler_t. -// After this call it is invalid to make any future calls to functions -// involving this shaderc_compiler_t. -SHADERC_EXPORT void shaderc_compiler_release(shaderc_compiler_t); - -// An opaque handle to an object that manages options to a single compilation -// result. -typedef struct shaderc_compile_options* shaderc_compile_options_t; - -// Returns a default-initialized shaderc_compile_options_t that can be used -// to modify the functionality of a compiled module. -// A return of NULL indicates that there was an error initializing the options. -// Any function operating on shaderc_compile_options_t must offer the -// basic thread-safety guarantee. -SHADERC_EXPORT shaderc_compile_options_t - shaderc_compile_options_initialize(void); - -// Returns a copy of the given shaderc_compile_options_t. -// If NULL is passed as the parameter the call is the same as -// shaderc_compile_options_init. -SHADERC_EXPORT shaderc_compile_options_t shaderc_compile_options_clone( - const shaderc_compile_options_t options); - -// Releases the compilation options. It is invalid to use the given -// shaderc_compile_options_t object in any future calls. It is safe to pass -// NULL to this function, and doing such will have no effect. -SHADERC_EXPORT void shaderc_compile_options_release( - shaderc_compile_options_t options); - -// Adds a predefined macro to the compilation options. This has the same -// effect as passing -Dname=value to the command-line compiler. If value -// is NULL, it has the same effect as passing -Dname to the command-line -// compiler. If a macro definition with the same name has previously been -// added, the value is replaced with the new value. The macro name and -// value are passed in with char pointers, which point to their data, and -// the lengths of their data. The strings that the name and value pointers -// point to must remain valid for the duration of the call, but can be -// modified or deleted after this function has returned. In case of adding -// a valueless macro, the value argument should be a null pointer or the -// value_length should be 0u. -SHADERC_EXPORT void shaderc_compile_options_add_macro_definition( - shaderc_compile_options_t options, const char* name, size_t name_length, - const char* value, size_t value_length); - -// Sets the source language. The default is GLSL. -SHADERC_EXPORT void shaderc_compile_options_set_source_language( - shaderc_compile_options_t options, shaderc_source_language lang); - -// Sets the compiler mode to generate debug information in the output. -SHADERC_EXPORT void shaderc_compile_options_set_generate_debug_info( - shaderc_compile_options_t options); - -// Sets the compiler optimization level to the given level. Only the last one -// takes effect if multiple calls of this function exist. -SHADERC_EXPORT void shaderc_compile_options_set_optimization_level( - shaderc_compile_options_t options, shaderc_optimization_level level); - -// Forces the GLSL language version and profile to a given pair. The version -// number is the same as would appear in the #version annotation in the source. -// Version and profile specified here overrides the #version annotation in the -// source. Use profile: 'shaderc_profile_none' for GLSL versions that do not -// define profiles, e.g. versions below 150. -SHADERC_EXPORT void shaderc_compile_options_set_forced_version_profile( - shaderc_compile_options_t options, int version, shaderc_profile profile); - -// Source text inclusion via #include is supported with a pair of callbacks -// to an "includer" on the client side. The first callback processes an -// inclusion request, and returns an include result. The includer owns -// the contents of the result, and those contents must remain valid until the -// second callback is invoked to release the result. Both callbacks take a -// user_data argument to specify the client context. -// To return an error, set the source_name to an empty string and put your -// error message in content. - -// An include result. -typedef struct shaderc_include_result { - // The name of the source file. The name should be fully resolved - // in the sense that it should be a unique name in the context of the - // includer. For example, if the includer maps source names to files in - // a filesystem, then this name should be the absolute path of the file. - // For a failed inclusion, this string is empty. - const char* source_name; - size_t source_name_length; - // The text contents of the source file in the normal case. - // For a failed inclusion, this contains the error message. - const char* content; - size_t content_length; - // User data to be passed along with this request. - void* user_data; -} shaderc_include_result; - -// The kinds of include requests. -enum shaderc_include_type { - shaderc_include_type_relative, // E.g. #include "source" - shaderc_include_type_standard // E.g. #include -}; - -// An includer callback type for mapping an #include request to an include -// result. The user_data parameter specifies the client context. The -// requested_source parameter specifies the name of the source being requested. -// The type parameter specifies the kind of inclusion request being made. -// The requesting_source parameter specifies the name of the source containing -// the #include request. The includer owns the result object and its contents, -// and both must remain valid until the release callback is called on the result -// object. -typedef shaderc_include_result* (*shaderc_include_resolve_fn)( - void* user_data, const char* requested_source, int type, - const char* requesting_source, size_t include_depth); - -// An includer callback type for destroying an include result. -typedef void (*shaderc_include_result_release_fn)( - void* user_data, shaderc_include_result* include_result); - -// Sets includer callback functions. -SHADERC_EXPORT void shaderc_compile_options_set_include_callbacks( - shaderc_compile_options_t options, shaderc_include_resolve_fn resolver, - shaderc_include_result_release_fn result_releaser, void* user_data); - -// Sets the compiler mode to suppress warnings, overriding warnings-as-errors -// mode. When both suppress-warnings and warnings-as-errors modes are -// turned on, warning messages will be inhibited, and will not be emitted -// as error messages. -SHADERC_EXPORT void shaderc_compile_options_set_suppress_warnings( - shaderc_compile_options_t options); - -// Sets the target shader environment, affecting which warnings or errors will -// be issued. The version will be for distinguishing between different versions -// of the target environment. The version value should be either 0 or -// a value listed in shaderc_env_version. The 0 value maps to Vulkan 1.0 if -// |target| is Vulkan, and it maps to OpenGL 4.5 if |target| is OpenGL. -SHADERC_EXPORT void shaderc_compile_options_set_target_env( - shaderc_compile_options_t options, - shaderc_target_env target, - uint32_t version); - -// Sets the target SPIR-V version. The generated module will use this version -// of SPIR-V. Each target environment determines what versions of SPIR-V -// it can consume. Defaults to the highest version of SPIR-V 1.0 which is -// required to be supported by the target environment. E.g. Default to SPIR-V -// 1.0 for Vulkan 1.0 and SPIR-V 1.3 for Vulkan 1.1. -SHADERC_EXPORT void shaderc_compile_options_set_target_spirv( - shaderc_compile_options_t options, shaderc_spirv_version version); - -// Sets the compiler mode to treat all warnings as errors. Note the -// suppress-warnings mode overrides this option, i.e. if both -// warning-as-errors and suppress-warnings modes are set, warnings will not -// be emitted as error messages. -SHADERC_EXPORT void shaderc_compile_options_set_warnings_as_errors( - shaderc_compile_options_t options); - -// Sets a resource limit. -SHADERC_EXPORT void shaderc_compile_options_set_limit( - shaderc_compile_options_t options, shaderc_limit limit, int value); - -// Sets whether the compiler should automatically assign bindings to uniforms -// that aren't already explicitly bound in the shader source. -SHADERC_EXPORT void shaderc_compile_options_set_auto_bind_uniforms( - shaderc_compile_options_t options, bool auto_bind); - -// Sets whether the compiler should automatically remove sampler variables -// and convert image variables to combined image-sampler variables. -SHADERC_EXPORT void shaderc_compile_options_set_auto_combined_image_sampler( - shaderc_compile_options_t options, bool upgrade); - -// Sets whether the compiler should use HLSL IO mapping rules for bindings. -// Defaults to false. -SHADERC_EXPORT void shaderc_compile_options_set_hlsl_io_mapping( - shaderc_compile_options_t options, bool hlsl_iomap); - -// Sets whether the compiler should determine block member offsets using HLSL -// packing rules instead of standard GLSL rules. Defaults to false. Only -// affects GLSL compilation. HLSL rules are always used when compiling HLSL. -SHADERC_EXPORT void shaderc_compile_options_set_hlsl_offsets( - shaderc_compile_options_t options, bool hlsl_offsets); - -// Sets the base binding number used for for a uniform resource type when -// automatically assigning bindings. For GLSL compilation, sets the lowest -// automatically assigned number. For HLSL compilation, the regsiter number -// assigned to the resource is added to this specified base. -SHADERC_EXPORT void shaderc_compile_options_set_binding_base( - shaderc_compile_options_t options, - shaderc_uniform_kind kind, - uint32_t base); - -// Like shaderc_compile_options_set_binding_base, but only takes effect when -// compiling a given shader stage. The stage is assumed to be one of vertex, -// fragment, tessellation evaluation, tesselation control, geometry, or compute. -SHADERC_EXPORT void shaderc_compile_options_set_binding_base_for_stage( - shaderc_compile_options_t options, shaderc_shader_kind shader_kind, - shaderc_uniform_kind kind, uint32_t base); - -// Sets whether the compiler should preserve all bindings, even when those -// bindings are not used. -SHADERC_EXPORT void shaderc_compile_options_set_preserve_bindings( - shaderc_compile_options_t options, bool preserve_bindings); - -SHADERC_EXPORT void shaderc_compile_options_set_max_id_bound( - shaderc_compile_options_t options, uint32_t max_id_bound); - -// Sets whether the compiler should automatically assign locations to -// uniform variables that don't have explicit locations in the shader source. -SHADERC_EXPORT void shaderc_compile_options_set_auto_map_locations( - shaderc_compile_options_t options, bool auto_map); - -// Sets a descriptor set and binding for an HLSL register in the given stage. -// This method keeps a copy of the string data. -SHADERC_EXPORT void shaderc_compile_options_set_hlsl_register_set_and_binding_for_stage( - shaderc_compile_options_t options, shaderc_shader_kind shader_kind, - const char* reg, const char* set, const char* binding); - -// Like shaderc_compile_options_set_hlsl_register_set_and_binding_for_stage, -// but affects all shader stages. -SHADERC_EXPORT void shaderc_compile_options_set_hlsl_register_set_and_binding( - shaderc_compile_options_t options, const char* reg, const char* set, - const char* binding); - -// Sets whether the compiler should enable extension -// SPV_GOOGLE_hlsl_functionality1. -SHADERC_EXPORT void shaderc_compile_options_set_hlsl_functionality1( - shaderc_compile_options_t options, bool enable); - -// Sets whether 16-bit types are supported in HLSL or not. -SHADERC_EXPORT void shaderc_compile_options_set_hlsl_16bit_types( - shaderc_compile_options_t options, bool enable); - -// Enables or disables relaxed Vulkan rules. -// -// This allows most OpenGL shaders to compile under Vulkan semantics. -SHADERC_EXPORT void shaderc_compile_options_set_vulkan_rules_relaxed( - shaderc_compile_options_t options, bool enable); - -// Sets whether the compiler should invert position.Y output in vertex shader. -SHADERC_EXPORT void shaderc_compile_options_set_invert_y( - shaderc_compile_options_t options, bool enable); - -// Sets whether the compiler generates code for max and min builtins which, -// if given a NaN operand, will return the other operand. Similarly, the clamp -// builtin will favour the non-NaN operands, as if clamp were implemented -// as a composition of max and min. -SHADERC_EXPORT void shaderc_compile_options_set_nan_clamp( - shaderc_compile_options_t options, bool enable); - -// An opaque handle to the results of a call to any shaderc_compile_into_*() -// function. -typedef struct shaderc_compilation_result* shaderc_compilation_result_t; - -// Takes a GLSL source string and the associated shader kind, input file -// name, compiles it according to the given additional_options. If the shader -// kind is not set to a specified kind, but shaderc_glslc_infer_from_source, -// the compiler will try to deduce the shader kind from the source -// string and a failure in deducing will generate an error. Currently only -// #pragma annotation is supported. If the shader kind is set to one of the -// default shader kinds, the compiler will fall back to the default shader -// kind in case it failed to deduce the shader kind from source string. -// The input_file_name is a null-termintated string. It is used as a tag to -// identify the source string in cases like emitting error messages. It -// doesn't have to be a 'file name'. -// The source string will be compiled into SPIR-V binary and a -// shaderc_compilation_result will be returned to hold the results. -// The entry_point_name null-terminated string defines the name of the entry -// point to associate with this GLSL source. If the additional_options -// parameter is not null, then the compilation is modified by any options -// present. May be safely called from multiple threads without explicit -// synchronization. If there was failure in allocating the compiler object, -// null will be returned. -SHADERC_EXPORT shaderc_compilation_result_t shaderc_compile_into_spv( - const shaderc_compiler_t compiler, const char* source_text, - size_t source_text_size, shaderc_shader_kind shader_kind, - const char* input_file_name, const char* entry_point_name, - const shaderc_compile_options_t additional_options); - -// Like shaderc_compile_into_spv, but the result contains SPIR-V assembly text -// instead of a SPIR-V binary module. The SPIR-V assembly syntax is as defined -// by the SPIRV-Tools open source project. -SHADERC_EXPORT shaderc_compilation_result_t shaderc_compile_into_spv_assembly( - const shaderc_compiler_t compiler, const char* source_text, - size_t source_text_size, shaderc_shader_kind shader_kind, - const char* input_file_name, const char* entry_point_name, - const shaderc_compile_options_t additional_options); - -// Like shaderc_compile_into_spv, but the result contains preprocessed source -// code instead of a SPIR-V binary module -SHADERC_EXPORT shaderc_compilation_result_t shaderc_compile_into_preprocessed_text( - const shaderc_compiler_t compiler, const char* source_text, - size_t source_text_size, shaderc_shader_kind shader_kind, - const char* input_file_name, const char* entry_point_name, - const shaderc_compile_options_t additional_options); - -// Takes an assembly string of the format defined in the SPIRV-Tools project -// (https://github.com/KhronosGroup/SPIRV-Tools/blob/master/syntax.md), -// assembles it into SPIR-V binary and a shaderc_compilation_result will be -// returned to hold the results. -// The assembling will pick options suitable for assembling specified in the -// additional_options parameter. -// May be safely called from multiple threads without explicit synchronization. -// If there was failure in allocating the compiler object, null will be -// returned. -SHADERC_EXPORT shaderc_compilation_result_t shaderc_assemble_into_spv( - const shaderc_compiler_t compiler, const char* source_assembly, - size_t source_assembly_size, - const shaderc_compile_options_t additional_options); - -// The following functions, operating on shaderc_compilation_result_t objects, -// offer only the basic thread-safety guarantee. - -// Releases the resources held by the result object. It is invalid to use the -// result object for any further operations. -SHADERC_EXPORT void shaderc_result_release(shaderc_compilation_result_t result); - -// Returns the number of bytes of the compilation output data in a result -// object. -SHADERC_EXPORT size_t shaderc_result_get_length(const shaderc_compilation_result_t result); - -// Returns the number of warnings generated during the compilation. -SHADERC_EXPORT size_t shaderc_result_get_num_warnings( - const shaderc_compilation_result_t result); - -// Returns the number of errors generated during the compilation. -SHADERC_EXPORT size_t shaderc_result_get_num_errors(const shaderc_compilation_result_t result); - -// Returns the compilation status, indicating whether the compilation succeeded, -// or failed due to some reasons, like invalid shader stage or compilation -// errors. -SHADERC_EXPORT shaderc_compilation_status shaderc_result_get_compilation_status( - const shaderc_compilation_result_t); - -// Returns a pointer to the start of the compilation output data bytes, either -// SPIR-V binary or char string. When the source string is compiled into SPIR-V -// binary, this is guaranteed to be castable to a uint32_t*. If the result -// contains assembly text or preprocessed source text, the pointer will point to -// the resulting array of characters. -SHADERC_EXPORT const char* shaderc_result_get_bytes(const shaderc_compilation_result_t result); - -// Returns a null-terminated string that contains any error messages generated -// during the compilation. -SHADERC_EXPORT const char* shaderc_result_get_error_message( - const shaderc_compilation_result_t result); - -// Provides the version & revision of the SPIR-V which will be produced -SHADERC_EXPORT void shaderc_get_spv_version(unsigned int* version, unsigned int* revision); - -// Parses the version and profile from a given null-terminated string -// containing both version and profile, like: '450core'. Returns false if -// the string can not be parsed. Returns true when the parsing succeeds. The -// parsed version and profile are returned through arguments. -SHADERC_EXPORT bool shaderc_parse_version_profile(const char* str, int* version, - shaderc_profile* profile); - -#ifdef __cplusplus -} -#endif // __cplusplus - -#endif // SHADERC_SHADERC_H_ diff --git a/lib/shaderc-headers/include/shaderc/shaderc.hpp b/lib/shaderc-headers/include/shaderc/shaderc.hpp deleted file mode 100644 index 77ccd7a70ac..00000000000 --- a/lib/shaderc-headers/include/shaderc/shaderc.hpp +++ /dev/null @@ -1,624 +0,0 @@ -// Copyright 2015 The Shaderc Authors. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef SHADERC_SHADERC_HPP_ -#define SHADERC_SHADERC_HPP_ - -#include -#include -#include - -#include "shaderc.h" - -namespace shaderc { -// A CompilationResult contains the compiler output, compilation status, -// and messages. -// -// The compiler output is stored as an array of elements and accessed -// via random access iterators provided by cbegin() and cend(). The iterators -// are contiguous in the sense of "Contiguous Iterators: A Refinement of -// Random Access Iterators", Nevin Liber, C++ Library Evolution Working -// Group Working Paper N3884. -// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3884.pdf -// -// Methods begin() and end() are also provided to enable range-based for. -// They are synonyms to cbegin() and cend(), respectively. -template -class CompilationResult { - public: - typedef OutputElementType element_type; - // The type used to describe the begin and end iterators on the - // compiler output. - typedef const OutputElementType* const_iterator; - - // Upon creation, the CompilationResult takes ownership of the - // shaderc_compilation_result instance. During destruction of the - // CompilationResult, the shaderc_compilation_result will be released. - explicit CompilationResult(shaderc_compilation_result_t compilation_result) - : compilation_result_(compilation_result) {} - CompilationResult() : compilation_result_(nullptr) {} - ~CompilationResult() { shaderc_result_release(compilation_result_); } - - CompilationResult(CompilationResult&& other) : compilation_result_(nullptr) { - *this = std::move(other); - } - - CompilationResult& operator=(CompilationResult&& other) { - if (compilation_result_) { - shaderc_result_release(compilation_result_); - } - compilation_result_ = other.compilation_result_; - other.compilation_result_ = nullptr; - return *this; - } - - // Returns any error message found during compilation. - std::string GetErrorMessage() const { - if (!compilation_result_) { - return ""; - } - return shaderc_result_get_error_message(compilation_result_); - } - - // Returns the compilation status, indicating whether the compilation - // succeeded, or failed due to some reasons, like invalid shader stage or - // compilation errors. - shaderc_compilation_status GetCompilationStatus() const { - if (!compilation_result_) { - return shaderc_compilation_status_null_result_object; - } - return shaderc_result_get_compilation_status(compilation_result_); - } - - // Returns a random access (contiguous) iterator pointing to the start - // of the compilation output. It is valid for the lifetime of this object. - // If there is no compilation result, then returns nullptr. - const_iterator cbegin() const { - if (!compilation_result_) return nullptr; - return reinterpret_cast( - shaderc_result_get_bytes(compilation_result_)); - } - - // Returns a random access (contiguous) iterator pointing to the end of - // the compilation output. It is valid for the lifetime of this object. - // If there is no compilation result, then returns nullptr. - const_iterator cend() const { - if (!compilation_result_) return nullptr; - return cbegin() + - shaderc_result_get_length(compilation_result_) / - sizeof(OutputElementType); - } - - // Returns the same iterator as cbegin(). - const_iterator begin() const { return cbegin(); } - // Returns the same iterator as cend(). - const_iterator end() const { return cend(); } - - // Returns the number of warnings generated during the compilation. - size_t GetNumWarnings() const { - if (!compilation_result_) { - return 0; - } - return shaderc_result_get_num_warnings(compilation_result_); - } - - // Returns the number of errors generated during the compilation. - size_t GetNumErrors() const { - if (!compilation_result_) { - return 0; - } - return shaderc_result_get_num_errors(compilation_result_); - } - - private: - CompilationResult(const CompilationResult& other) = delete; - CompilationResult& operator=(const CompilationResult& other) = delete; - - shaderc_compilation_result_t compilation_result_; -}; - -// A compilation result for a SPIR-V binary module, which is an array -// of uint32_t words. -using SpvCompilationResult = CompilationResult; -// A compilation result in SPIR-V assembly syntax. -using AssemblyCompilationResult = CompilationResult; -// Preprocessed source text. -using PreprocessedSourceCompilationResult = CompilationResult; - -// Contains any options that can have default values for a compilation. -class CompileOptions { - public: - CompileOptions() { options_ = shaderc_compile_options_initialize(); } - ~CompileOptions() { shaderc_compile_options_release(options_); } - CompileOptions(const CompileOptions& other) { - options_ = shaderc_compile_options_clone(other.options_); - } - CompileOptions(CompileOptions&& other) { - options_ = other.options_; - other.options_ = nullptr; - } - - // Adds a predefined macro to the compilation options. It behaves the same as - // shaderc_compile_options_add_macro_definition in shaderc.h. - void AddMacroDefinition(const char* name, size_t name_length, - const char* value, size_t value_length) { - shaderc_compile_options_add_macro_definition(options_, name, name_length, - value, value_length); - } - - // Adds a valueless predefined macro to the compilation options. - void AddMacroDefinition(const std::string& name) { - AddMacroDefinition(name.c_str(), name.size(), nullptr, 0u); - } - - // Adds a predefined macro to the compilation options. - void AddMacroDefinition(const std::string& name, const std::string& value) { - AddMacroDefinition(name.c_str(), name.size(), value.c_str(), value.size()); - } - - // Sets the compiler mode to generate debug information in the output. - void SetGenerateDebugInfo() { - shaderc_compile_options_set_generate_debug_info(options_); - } - - // Sets the compiler optimization level to the given level. Only the last one - // takes effect if multiple calls of this function exist. - void SetOptimizationLevel(shaderc_optimization_level level) { - shaderc_compile_options_set_optimization_level(options_, level); - } - - // A C++ version of the libshaderc includer interface. - class IncluderInterface { - public: - // Handles shaderc_include_resolver_fn callbacks. - virtual shaderc_include_result* GetInclude(const char* requested_source, - shaderc_include_type type, - const char* requesting_source, - size_t include_depth) = 0; - - // Handles shaderc_include_result_release_fn callbacks. - virtual void ReleaseInclude(shaderc_include_result* data) = 0; - - virtual ~IncluderInterface() = default; - }; - - // Sets the includer instance for libshaderc to call during compilation, as - // described in shaderc_compile_options_set_include_callbacks(). Callbacks - // are routed to this includer's methods. - void SetIncluder(std::unique_ptr&& includer) { - includer_ = std::move(includer); - shaderc_compile_options_set_include_callbacks( - options_, - [](void* user_data, const char* requested_source, int type, - const char* requesting_source, size_t include_depth) { - auto* sub_includer = static_cast(user_data); - return sub_includer->GetInclude( - requested_source, static_cast(type), - requesting_source, include_depth); - }, - [](void* user_data, shaderc_include_result* include_result) { - auto* sub_includer = static_cast(user_data); - return sub_includer->ReleaseInclude(include_result); - }, - includer_.get()); - } - - // Forces the GLSL language version and profile to a given pair. The version - // number is the same as would appear in the #version annotation in the - // source. Version and profile specified here overrides the #version - // annotation in the source. Use profile: 'shaderc_profile_none' for GLSL - // versions that do not define profiles, e.g. versions below 150. - void SetForcedVersionProfile(int version, shaderc_profile profile) { - shaderc_compile_options_set_forced_version_profile(options_, version, - profile); - } - - // Sets the compiler mode to suppress warnings. Note this option overrides - // warnings-as-errors mode. When both suppress-warnings and warnings-as-errors - // modes are turned on, warning messages will be inhibited, and will not be - // emitted as error message. - void SetSuppressWarnings() { - shaderc_compile_options_set_suppress_warnings(options_); - } - - // Sets the source language. The default is GLSL. - void SetSourceLanguage(shaderc_source_language lang) { - shaderc_compile_options_set_source_language(options_, lang); - } - - // Sets the target shader environment, affecting which warnings or errors will - // be issued. The version will be for distinguishing between different - // versions of the target environment. The version value should be either 0 - // or a value listed in shaderc_env_version. The 0 value maps to Vulkan 1.0 - // if |target| is Vulkan, and it maps to OpenGL 4.5 if |target| is OpenGL. - void SetTargetEnvironment(shaderc_target_env target, uint32_t version) { - shaderc_compile_options_set_target_env(options_, target, version); - } - - // Sets the target SPIR-V version. The generated module will use this version - // of SPIR-V. Each target environment determines what versions of SPIR-V - // it can consume. Defaults to the highest version of SPIR-V 1.0 which is - // required to be supported by the target environment. E.g. Default to SPIR-V - // 1.0 for Vulkan 1.0 and SPIR-V 1.3 for Vulkan 1.1. - void SetTargetSpirv(shaderc_spirv_version version) { - shaderc_compile_options_set_target_spirv(options_, version); - } - - // Sets the compiler mode to make all warnings into errors. Note the - // suppress-warnings mode overrides this option, i.e. if both - // warning-as-errors and suppress-warnings modes are set on, warnings will not - // be emitted as error message. - void SetWarningsAsErrors() { - shaderc_compile_options_set_warnings_as_errors(options_); - } - - // Sets a resource limit. - void SetLimit(shaderc_limit limit, int value) { - shaderc_compile_options_set_limit(options_, limit, value); - } - - // Sets whether the compiler should automatically assign bindings to uniforms - // that aren't already explicitly bound in the shader source. - void SetAutoBindUniforms(bool auto_bind) { - shaderc_compile_options_set_auto_bind_uniforms(options_, auto_bind); - } - - // Sets whether the compiler should automatically remove sampler variables - // and convert image variables to combined image sampler variables. - void SetAutoSampledTextures(bool auto_sampled) { - shaderc_compile_options_set_auto_combined_image_sampler(options_, - auto_sampled); - } - - // Sets whether the compiler should use HLSL IO mapping rules for bindings. - // Defaults to false. - void SetHlslIoMapping(bool hlsl_iomap) { - shaderc_compile_options_set_hlsl_io_mapping(options_, hlsl_iomap); - } - - // Sets whether the compiler should determine block member offsets using HLSL - // packing rules instead of standard GLSL rules. Defaults to false. Only - // affects GLSL compilation. HLSL rules are always used when compiling HLSL. - void SetHlslOffsets(bool hlsl_offsets) { - shaderc_compile_options_set_hlsl_offsets(options_, hlsl_offsets); - } - - // Sets the base binding number used for for a uniform resource type when - // automatically assigning bindings. For GLSL compilation, sets the lowest - // automatically assigned number. For HLSL compilation, the regsiter number - // assigned to the resource is added to this specified base. - void SetBindingBase(shaderc_uniform_kind kind, uint32_t base) { - shaderc_compile_options_set_binding_base(options_, kind, base); - } - - // Like SetBindingBase, but only takes effect when compiling a given shader - // stage. The stage is assumed to be one of vertex, fragment, tessellation - // evaluation, tesselation control, geometry, or compute. - void SetBindingBaseForStage(shaderc_shader_kind shader_kind, - shaderc_uniform_kind kind, uint32_t base) { - shaderc_compile_options_set_binding_base_for_stage(options_, shader_kind, - kind, base); - } - - // Sets whether the compiler should preserve all bindings, even when those - // bindings are not used. - void SetPreserveBindings(bool preserve_bindings) { - shaderc_compile_options_set_preserve_bindings(options_, preserve_bindings); - } - - void SetMaxIdBound(uint32_t max_id_bound) { - shaderc_compile_options_set_max_id_bound(options_, max_id_bound); - } - - // Sets whether the compiler automatically assigns locations to - // uniform variables that don't have explicit locations. - void SetAutoMapLocations(bool auto_map) { - shaderc_compile_options_set_auto_map_locations(options_, auto_map); - } - - // Sets a descriptor set and binding for an HLSL register in the given stage. - // Copies the parameter strings. - void SetHlslRegisterSetAndBindingForStage(shaderc_shader_kind shader_kind, - const std::string& reg, - const std::string& set, - const std::string& binding) { - shaderc_compile_options_set_hlsl_register_set_and_binding_for_stage( - options_, shader_kind, reg.c_str(), set.c_str(), binding.c_str()); - } - - // Sets a descriptor set and binding for an HLSL register in any stage. - // Copies the parameter strings. - void SetHlslRegisterSetAndBinding(const std::string& reg, - const std::string& set, - const std::string& binding) { - shaderc_compile_options_set_hlsl_register_set_and_binding( - options_, reg.c_str(), set.c_str(), binding.c_str()); - } - - // Sets whether the compiler should enable extension - // SPV_GOOGLE_hlsl_functionality1. - void SetHlslFunctionality1(bool enable) { - shaderc_compile_options_set_hlsl_functionality1(options_, enable); - } - - // Sets whether 16-bit types are supported in HLSL or not. - void SetHlsl16BitTypes(bool enable) { - shaderc_compile_options_set_hlsl_16bit_types(options_, enable); - } - - // Enables or disables relaxed Vulkan rules. - // - // This allows most OpenGL shaders to compile under Vulkan semantics. - void SetVulkanRulesRelaxed(bool enable) { - shaderc_compile_options_set_vulkan_rules_relaxed(options_, enable); - } - - // Sets whether the compiler should invert position.Y output in vertex shader. - void SetInvertY(bool enable) { - shaderc_compile_options_set_invert_y(options_, enable); - } - - // Sets whether the compiler should generate code for max and min which, - // if given a NaN operand, will return the other operand. Similarly, the - // clamp builtin will favour the non-NaN operands, as if clamp were - // implemented as a composition of max and min. - void SetNanClamp(bool enable) { - shaderc_compile_options_set_nan_clamp(options_, enable); - } - - private: - CompileOptions& operator=(const CompileOptions& other) = delete; - shaderc_compile_options_t options_; - std::unique_ptr includer_; - - friend class Compiler; -}; - -// The compilation context for compiling source to SPIR-V. -class Compiler { - public: - Compiler() : compiler_(shaderc_compiler_initialize()) {} - ~Compiler() { shaderc_compiler_release(compiler_); } - - Compiler(Compiler&& other) { - compiler_ = other.compiler_; - other.compiler_ = nullptr; - } - - bool IsValid() const { return compiler_ != nullptr; } - - // Compiles the given source GLSL and returns a SPIR-V binary module - // compilation result. - // The source_text parameter must be a valid pointer. - // The source_text_size parameter must be the length of the source text. - // The shader_kind parameter either forces the compilation to be done with a - // specified shader kind, or hint the compiler how to determine the exact - // shader kind. If the shader kind is set to shaderc_glslc_infer_from_source, - // the compiler will try to deduce the shader kind from the source string and - // a failure in this proess will generate an error. Currently only #pragma - // annotation is supported. If the shader kind is set to one of the default - // shader kinds, the compiler will fall back to the specified default shader - // kind in case it failed to deduce the shader kind from the source string. - // The input_file_name is a null-termintated string. It is used as a tag to - // identify the source string in cases like emitting error messages. It - // doesn't have to be a 'file name'. - // The entry_point_name parameter is a null-terminated string specifying - // the entry point name for HLSL compilation. For GLSL compilation, the - // entry point name is assumed to be "main". - // The compilation is passed any options specified in the CompileOptions - // parameter. - // It is valid for the returned CompilationResult object to outlive this - // compiler object. - // Note when the options_ has disassembly mode or preprocessing only mode set - // on, the returned CompilationResult will hold a text string, instead of a - // SPIR-V binary generated with default options. - SpvCompilationResult CompileGlslToSpv(const char* source_text, - size_t source_text_size, - shaderc_shader_kind shader_kind, - const char* input_file_name, - const char* entry_point_name, - const CompileOptions& options) const { - shaderc_compilation_result_t compilation_result = shaderc_compile_into_spv( - compiler_, source_text, source_text_size, shader_kind, input_file_name, - entry_point_name, options.options_); - return SpvCompilationResult(compilation_result); - } - - // Compiles the given source shader and returns a SPIR-V binary module - // compilation result. - // Like the first CompileGlslToSpv method but assumes the entry point name - // is "main". - SpvCompilationResult CompileGlslToSpv(const char* source_text, - size_t source_text_size, - shaderc_shader_kind shader_kind, - const char* input_file_name, - const CompileOptions& options) const { - return CompileGlslToSpv(source_text, source_text_size, shader_kind, - input_file_name, "main", options); - } - - // Compiles the given source GLSL and returns a SPIR-V binary module - // compilation result. - // Like the previous CompileGlslToSpv method but uses default options. - SpvCompilationResult CompileGlslToSpv(const char* source_text, - size_t source_text_size, - shaderc_shader_kind shader_kind, - const char* input_file_name) const { - shaderc_compilation_result_t compilation_result = - shaderc_compile_into_spv(compiler_, source_text, source_text_size, - shader_kind, input_file_name, "main", nullptr); - return SpvCompilationResult(compilation_result); - } - - // Compiles the given source shader and returns a SPIR-V binary module - // compilation result. - // Like the first CompileGlslToSpv method but the source is provided as - // a std::string, and we assume the entry point is "main". - SpvCompilationResult CompileGlslToSpv(const std::string& source_text, - shaderc_shader_kind shader_kind, - const char* input_file_name, - const CompileOptions& options) const { - return CompileGlslToSpv(source_text.data(), source_text.size(), shader_kind, - input_file_name, options); - } - - // Compiles the given source shader and returns a SPIR-V binary module - // compilation result. - // Like the first CompileGlslToSpv method but the source is provided as - // a std::string. - SpvCompilationResult CompileGlslToSpv(const std::string& source_text, - shaderc_shader_kind shader_kind, - const char* input_file_name, - const char* entry_point_name, - const CompileOptions& options) const { - return CompileGlslToSpv(source_text.data(), source_text.size(), shader_kind, - input_file_name, entry_point_name, options); - } - - // Compiles the given source GLSL and returns a SPIR-V binary module - // compilation result. - // Like the previous CompileGlslToSpv method but assumes the entry point - // name is "main". - SpvCompilationResult CompileGlslToSpv(const std::string& source_text, - shaderc_shader_kind shader_kind, - const char* input_file_name) const { - return CompileGlslToSpv(source_text.data(), source_text.size(), shader_kind, - input_file_name); - } - - // Assembles the given SPIR-V assembly and returns a SPIR-V binary module - // compilation result. - // The assembly should follow the syntax defined in the SPIRV-Tools project - // (https://github.com/KhronosGroup/SPIRV-Tools/blob/master/syntax.md). - // It is valid for the returned CompilationResult object to outlive this - // compiler object. - // The assembling will pick options suitable for assembling specified in the - // CompileOptions parameter. - SpvCompilationResult AssembleToSpv(const char* source_assembly, - size_t source_assembly_size, - const CompileOptions& options) const { - return SpvCompilationResult(shaderc_assemble_into_spv( - compiler_, source_assembly, source_assembly_size, options.options_)); - } - - // Assembles the given SPIR-V assembly and returns a SPIR-V binary module - // compilation result. - // Like the first AssembleToSpv method but uses the default compiler options. - SpvCompilationResult AssembleToSpv(const char* source_assembly, - size_t source_assembly_size) const { - return SpvCompilationResult(shaderc_assemble_into_spv( - compiler_, source_assembly, source_assembly_size, nullptr)); - } - - // Assembles the given SPIR-V assembly and returns a SPIR-V binary module - // compilation result. - // Like the first AssembleToSpv method but the source is provided as a - // std::string. - SpvCompilationResult AssembleToSpv(const std::string& source_assembly, - const CompileOptions& options) const { - return SpvCompilationResult( - shaderc_assemble_into_spv(compiler_, source_assembly.data(), - source_assembly.size(), options.options_)); - } - - // Assembles the given SPIR-V assembly and returns a SPIR-V binary module - // compilation result. - // Like the first AssembleToSpv method but the source is provided as a - // std::string and also uses default compiler options. - SpvCompilationResult AssembleToSpv(const std::string& source_assembly) const { - return SpvCompilationResult(shaderc_assemble_into_spv( - compiler_, source_assembly.data(), source_assembly.size(), nullptr)); - } - - // Compiles the given source GLSL and returns the SPIR-V assembly text - // compilation result. - // Options are similar to the first CompileToSpv method. - AssemblyCompilationResult CompileGlslToSpvAssembly( - const char* source_text, size_t source_text_size, - shaderc_shader_kind shader_kind, const char* input_file_name, - const char* entry_point_name, const CompileOptions& options) const { - shaderc_compilation_result_t compilation_result = - shaderc_compile_into_spv_assembly( - compiler_, source_text, source_text_size, shader_kind, - input_file_name, entry_point_name, options.options_); - return AssemblyCompilationResult(compilation_result); - } - - // Compiles the given source GLSL and returns the SPIR-V assembly text - // compilation result. - // Similare to the previous method, but assumes entry point name is "main". - AssemblyCompilationResult CompileGlslToSpvAssembly( - const char* source_text, size_t source_text_size, - shaderc_shader_kind shader_kind, const char* input_file_name, - const CompileOptions& options) const { - return CompileGlslToSpvAssembly(source_text, source_text_size, shader_kind, - input_file_name, "main", options); - } - - // Compiles the given source GLSL and returns the SPIR-V assembly text - // result. Like the first CompileGlslToSpvAssembly method but the source - // is provided as a std::string. Options are otherwise similar to - // the first CompileToSpv method. - AssemblyCompilationResult CompileGlslToSpvAssembly( - const std::string& source_text, shaderc_shader_kind shader_kind, - const char* input_file_name, const char* entry_point_name, - const CompileOptions& options) const { - return CompileGlslToSpvAssembly(source_text.data(), source_text.size(), - shader_kind, input_file_name, - entry_point_name, options); - } - - // Compiles the given source GLSL and returns the SPIR-V assembly text - // result. Like the previous CompileGlslToSpvAssembly method but assumes - // the entry point name is "main". - AssemblyCompilationResult CompileGlslToSpvAssembly( - const std::string& source_text, shaderc_shader_kind shader_kind, - const char* input_file_name, const CompileOptions& options) const { - return CompileGlslToSpvAssembly(source_text, shader_kind, input_file_name, - "main", options); - } - - // Preprocesses the given source GLSL and returns the preprocessed - // source text as a compilation result. - // Options are similar to the first CompileToSpv method. - PreprocessedSourceCompilationResult PreprocessGlsl( - const char* source_text, size_t source_text_size, - shaderc_shader_kind shader_kind, const char* input_file_name, - const CompileOptions& options) const { - shaderc_compilation_result_t compilation_result = - shaderc_compile_into_preprocessed_text( - compiler_, source_text, source_text_size, shader_kind, - input_file_name, "main", options.options_); - return PreprocessedSourceCompilationResult(compilation_result); - } - - // Preprocesses the given source GLSL and returns text result. Like the first - // PreprocessGlsl method but the source is provided as a std::string. - // Options are otherwise similar to the first CompileToSpv method. - PreprocessedSourceCompilationResult PreprocessGlsl( - const std::string& source_text, shaderc_shader_kind shader_kind, - const char* input_file_name, const CompileOptions& options) const { - return PreprocessGlsl(source_text.data(), source_text.size(), shader_kind, - input_file_name, options); - } - - private: - Compiler(const Compiler&) = delete; - Compiler& operator=(const Compiler& other) = delete; - - shaderc_compiler_t compiler_; -}; -} // namespace shaderc - -#endif // SHADERC_SHADERC_HPP_ diff --git a/lib/shaderc-headers/include/shaderc/status.h b/lib/shaderc-headers/include/shaderc/status.h deleted file mode 100644 index 57ac70d7ef5..00000000000 --- a/lib/shaderc-headers/include/shaderc/status.h +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright 2018 The Shaderc Authors. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef SHADERC_STATUS_H_ -#define SHADERC_STATUS_H_ - -#ifdef __cplusplus -extern "C" { -#endif - -// Indicate the status of a compilation. -typedef enum { - shaderc_compilation_status_success = 0, - shaderc_compilation_status_invalid_stage = 1, // error stage deduction - shaderc_compilation_status_compilation_error = 2, - shaderc_compilation_status_internal_error = 3, // unexpected failure - shaderc_compilation_status_null_result_object = 4, - shaderc_compilation_status_invalid_assembly = 5, - shaderc_compilation_status_validation_error = 6, - shaderc_compilation_status_transformation_error = 7, - shaderc_compilation_status_configuration_error = 8, -} shaderc_compilation_status; - -#ifdef __cplusplus -} -#endif // __cplusplus - -#endif // SHADERC_STATUS_H_ diff --git a/lib/shaderc-headers/include/shaderc/visibility.h b/lib/shaderc-headers/include/shaderc/visibility.h deleted file mode 100644 index 88ec151bfa9..00000000000 --- a/lib/shaderc-headers/include/shaderc/visibility.h +++ /dev/null @@ -1,37 +0,0 @@ -// Copyright 2018 The Shaderc Authors. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef SHADERC_VISIBILITY_H_ -#define SHADERC_VISIBILITY_H_ - -// SHADERC_EXPORT tags symbol that will be exposed by the shared libraries. -#if defined(SHADERC_SHAREDLIB) -#if defined(_WIN32) -#if defined(SHADERC_IMPLEMENTATION) -#define SHADERC_EXPORT __declspec(dllexport) -#else -#define SHADERC_EXPORT __declspec(dllimport) -#endif -#else -#if defined(SHADERC_IMPLEMENTATION) -#define SHADERC_EXPORT __attribute__((visibility("default"))) -#else -#define SHADERC_EXPORT -#endif -#endif -#else -#define SHADERC_EXPORT -#endif - -#endif // SHADERC_VISIBILITY_H_ diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std.h deleted file mode 100644 index 75cebd74cbf..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std.h +++ /dev/null @@ -1,394 +0,0 @@ -#ifndef VULKAN_VIDEO_CODEC_AV1STD_H_ -#define VULKAN_VIDEO_CODEC_AV1STD_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codec_av1std is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codec_av1std 1 -#include "vulkan_video_codecs_common.h" -#define STD_VIDEO_AV1_NUM_REF_FRAMES 8U -#define STD_VIDEO_AV1_REFS_PER_FRAME 7U -#define STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME 8U -#define STD_VIDEO_AV1_MAX_TILE_COLS 64U -#define STD_VIDEO_AV1_MAX_TILE_ROWS 64U -#define STD_VIDEO_AV1_MAX_SEGMENTS 8U -#define STD_VIDEO_AV1_SEG_LVL_MAX 8U -#define STD_VIDEO_AV1_PRIMARY_REF_NONE 7U -#define STD_VIDEO_AV1_SELECT_INTEGER_MV 2U -#define STD_VIDEO_AV1_SELECT_SCREEN_CONTENT_TOOLS 2U -#define STD_VIDEO_AV1_SKIP_MODE_FRAMES 2U -#define STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS 4U -#define STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS 2U -#define STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS 8U -#define STD_VIDEO_AV1_MAX_NUM_PLANES 3U -#define STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS 6U -#define STD_VIDEO_AV1_MAX_NUM_Y_POINTS 14U -#define STD_VIDEO_AV1_MAX_NUM_CB_POINTS 10U -#define STD_VIDEO_AV1_MAX_NUM_CR_POINTS 10U -#define STD_VIDEO_AV1_MAX_NUM_POS_LUMA 24U -#define STD_VIDEO_AV1_MAX_NUM_POS_CHROMA 25U - -typedef enum StdVideoAV1Profile { - STD_VIDEO_AV1_PROFILE_MAIN = 0, - STD_VIDEO_AV1_PROFILE_HIGH = 1, - STD_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, - STD_VIDEO_AV1_PROFILE_INVALID = 0x7FFFFFFF, - STD_VIDEO_AV1_PROFILE_MAX_ENUM = 0x7FFFFFFF -} StdVideoAV1Profile; - -typedef enum StdVideoAV1Level { - STD_VIDEO_AV1_LEVEL_2_0 = 0, - STD_VIDEO_AV1_LEVEL_2_1 = 1, - STD_VIDEO_AV1_LEVEL_2_2 = 2, - STD_VIDEO_AV1_LEVEL_2_3 = 3, - STD_VIDEO_AV1_LEVEL_3_0 = 4, - STD_VIDEO_AV1_LEVEL_3_1 = 5, - STD_VIDEO_AV1_LEVEL_3_2 = 6, - STD_VIDEO_AV1_LEVEL_3_3 = 7, - STD_VIDEO_AV1_LEVEL_4_0 = 8, - STD_VIDEO_AV1_LEVEL_4_1 = 9, - STD_VIDEO_AV1_LEVEL_4_2 = 10, - STD_VIDEO_AV1_LEVEL_4_3 = 11, - STD_VIDEO_AV1_LEVEL_5_0 = 12, - STD_VIDEO_AV1_LEVEL_5_1 = 13, - STD_VIDEO_AV1_LEVEL_5_2 = 14, - STD_VIDEO_AV1_LEVEL_5_3 = 15, - STD_VIDEO_AV1_LEVEL_6_0 = 16, - STD_VIDEO_AV1_LEVEL_6_1 = 17, - STD_VIDEO_AV1_LEVEL_6_2 = 18, - STD_VIDEO_AV1_LEVEL_6_3 = 19, - STD_VIDEO_AV1_LEVEL_7_0 = 20, - STD_VIDEO_AV1_LEVEL_7_1 = 21, - STD_VIDEO_AV1_LEVEL_7_2 = 22, - STD_VIDEO_AV1_LEVEL_7_3 = 23, - STD_VIDEO_AV1_LEVEL_INVALID = 0x7FFFFFFF, - STD_VIDEO_AV1_LEVEL_MAX_ENUM = 0x7FFFFFFF -} StdVideoAV1Level; - -typedef enum StdVideoAV1FrameType { - STD_VIDEO_AV1_FRAME_TYPE_KEY = 0, - STD_VIDEO_AV1_FRAME_TYPE_INTER = 1, - STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY = 2, - STD_VIDEO_AV1_FRAME_TYPE_SWITCH = 3, - STD_VIDEO_AV1_FRAME_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_AV1_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoAV1FrameType; - -typedef enum StdVideoAV1ReferenceName { - STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME = 0, - STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME = 1, - STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME = 2, - STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME = 3, - STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME = 4, - STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME = 5, - STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME = 6, - STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME = 7, - STD_VIDEO_AV1_REFERENCE_NAME_INVALID = 0x7FFFFFFF, - STD_VIDEO_AV1_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF -} StdVideoAV1ReferenceName; - -typedef enum StdVideoAV1InterpolationFilter { - STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, - STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, - STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, - STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR = 3, - STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, - STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF, - STD_VIDEO_AV1_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF -} StdVideoAV1InterpolationFilter; - -typedef enum StdVideoAV1TxMode { - STD_VIDEO_AV1_TX_MODE_ONLY_4X4 = 0, - STD_VIDEO_AV1_TX_MODE_LARGEST = 1, - STD_VIDEO_AV1_TX_MODE_SELECT = 2, - STD_VIDEO_AV1_TX_MODE_INVALID = 0x7FFFFFFF, - STD_VIDEO_AV1_TX_MODE_MAX_ENUM = 0x7FFFFFFF -} StdVideoAV1TxMode; - -typedef enum StdVideoAV1FrameRestorationType { - STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE = 0, - STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER = 1, - STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ = 2, - STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE = 3, - STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoAV1FrameRestorationType; - -typedef enum StdVideoAV1ColorPrimaries { - STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709 = 1, - STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED = 2, - STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M = 4, - STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G = 5, - STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601 = 6, - STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240 = 7, - STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM = 8, - STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020 = 9, - STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ = 10, - STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431 = 11, - STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432 = 12, - STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213 = 22, - STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID = 0x7FFFFFFF, - // STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED is a legacy alias - STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED, - STD_VIDEO_AV1_COLOR_PRIMARIES_MAX_ENUM = 0x7FFFFFFF -} StdVideoAV1ColorPrimaries; - -typedef enum StdVideoAV1TransferCharacteristics { - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0 = 0, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709 = 1, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3 = 3, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M = 4, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G = 5, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601 = 6, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240 = 7, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR = 8, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100 = 9, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10 = 10, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966 = 11, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361 = 12, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB = 13, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT = 14, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT = 15, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084 = 16, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428 = 17, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG = 18, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID = 0x7FFFFFFF, - STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_MAX_ENUM = 0x7FFFFFFF -} StdVideoAV1TransferCharacteristics; - -typedef enum StdVideoAV1MatrixCoefficients { - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY = 0, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709 = 1, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED = 2, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3 = 3, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC = 4, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G = 5, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601 = 6, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240 = 7, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO = 8, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL = 9, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL = 10, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085 = 11, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL = 12, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL = 13, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP = 14, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID = 0x7FFFFFFF, - STD_VIDEO_AV1_MATRIX_COEFFICIENTS_MAX_ENUM = 0x7FFFFFFF -} StdVideoAV1MatrixCoefficients; - -typedef enum StdVideoAV1ChromaSamplePosition { - STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN = 0, - STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL = 1, - STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED = 2, - STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED = 3, - STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID = 0x7FFFFFFF, - STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_MAX_ENUM = 0x7FFFFFFF -} StdVideoAV1ChromaSamplePosition; -typedef struct StdVideoAV1ColorConfigFlags { - uint32_t mono_chrome : 1; - uint32_t color_range : 1; - uint32_t separate_uv_delta_q : 1; - uint32_t color_description_present_flag : 1; - uint32_t reserved : 28; -} StdVideoAV1ColorConfigFlags; - -typedef struct StdVideoAV1ColorConfig { - StdVideoAV1ColorConfigFlags flags; - uint8_t BitDepth; - uint8_t subsampling_x; - uint8_t subsampling_y; - uint8_t reserved1; - StdVideoAV1ColorPrimaries color_primaries; - StdVideoAV1TransferCharacteristics transfer_characteristics; - StdVideoAV1MatrixCoefficients matrix_coefficients; - StdVideoAV1ChromaSamplePosition chroma_sample_position; -} StdVideoAV1ColorConfig; - -typedef struct StdVideoAV1TimingInfoFlags { - uint32_t equal_picture_interval : 1; - uint32_t reserved : 31; -} StdVideoAV1TimingInfoFlags; - -typedef struct StdVideoAV1TimingInfo { - StdVideoAV1TimingInfoFlags flags; - uint32_t num_units_in_display_tick; - uint32_t time_scale; - uint32_t num_ticks_per_picture_minus_1; -} StdVideoAV1TimingInfo; - -typedef struct StdVideoAV1LoopFilterFlags { - uint32_t loop_filter_delta_enabled : 1; - uint32_t loop_filter_delta_update : 1; - uint32_t reserved : 30; -} StdVideoAV1LoopFilterFlags; - -typedef struct StdVideoAV1LoopFilter { - StdVideoAV1LoopFilterFlags flags; - uint8_t loop_filter_level[STD_VIDEO_AV1_MAX_LOOP_FILTER_STRENGTHS]; - uint8_t loop_filter_sharpness; - uint8_t update_ref_delta; - int8_t loop_filter_ref_deltas[STD_VIDEO_AV1_TOTAL_REFS_PER_FRAME]; - uint8_t update_mode_delta; - int8_t loop_filter_mode_deltas[STD_VIDEO_AV1_LOOP_FILTER_ADJUSTMENTS]; -} StdVideoAV1LoopFilter; - -typedef struct StdVideoAV1QuantizationFlags { - uint32_t using_qmatrix : 1; - uint32_t diff_uv_delta : 1; - uint32_t reserved : 30; -} StdVideoAV1QuantizationFlags; - -typedef struct StdVideoAV1Quantization { - StdVideoAV1QuantizationFlags flags; - uint8_t base_q_idx; - int8_t DeltaQYDc; - int8_t DeltaQUDc; - int8_t DeltaQUAc; - int8_t DeltaQVDc; - int8_t DeltaQVAc; - uint8_t qm_y; - uint8_t qm_u; - uint8_t qm_v; -} StdVideoAV1Quantization; - -typedef struct StdVideoAV1Segmentation { - uint8_t FeatureEnabled[STD_VIDEO_AV1_MAX_SEGMENTS]; - int16_t FeatureData[STD_VIDEO_AV1_MAX_SEGMENTS][STD_VIDEO_AV1_SEG_LVL_MAX]; -} StdVideoAV1Segmentation; - -typedef struct StdVideoAV1TileInfoFlags { - uint32_t uniform_tile_spacing_flag : 1; - uint32_t reserved : 31; -} StdVideoAV1TileInfoFlags; - -typedef struct StdVideoAV1TileInfo { - StdVideoAV1TileInfoFlags flags; - uint8_t TileCols; - uint8_t TileRows; - uint16_t context_update_tile_id; - uint8_t tile_size_bytes_minus_1; - uint8_t reserved1[7]; - const uint16_t* pMiColStarts; - const uint16_t* pMiRowStarts; - const uint16_t* pWidthInSbsMinus1; - const uint16_t* pHeightInSbsMinus1; -} StdVideoAV1TileInfo; - -typedef struct StdVideoAV1CDEF { - uint8_t cdef_damping_minus_3; - uint8_t cdef_bits; - uint8_t cdef_y_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; - uint8_t cdef_y_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; - uint8_t cdef_uv_pri_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; - uint8_t cdef_uv_sec_strength[STD_VIDEO_AV1_MAX_CDEF_FILTER_STRENGTHS]; -} StdVideoAV1CDEF; - -typedef struct StdVideoAV1LoopRestoration { - StdVideoAV1FrameRestorationType FrameRestorationType[STD_VIDEO_AV1_MAX_NUM_PLANES]; - uint16_t LoopRestorationSize[STD_VIDEO_AV1_MAX_NUM_PLANES]; -} StdVideoAV1LoopRestoration; - -typedef struct StdVideoAV1GlobalMotion { - uint8_t GmType[STD_VIDEO_AV1_NUM_REF_FRAMES]; - int32_t gm_params[STD_VIDEO_AV1_NUM_REF_FRAMES][STD_VIDEO_AV1_GLOBAL_MOTION_PARAMS]; -} StdVideoAV1GlobalMotion; - -typedef struct StdVideoAV1FilmGrainFlags { - uint32_t chroma_scaling_from_luma : 1; - uint32_t overlap_flag : 1; - uint32_t clip_to_restricted_range : 1; - uint32_t update_grain : 1; - uint32_t reserved : 28; -} StdVideoAV1FilmGrainFlags; - -typedef struct StdVideoAV1FilmGrain { - StdVideoAV1FilmGrainFlags flags; - uint8_t grain_scaling_minus_8; - uint8_t ar_coeff_lag; - uint8_t ar_coeff_shift_minus_6; - uint8_t grain_scale_shift; - uint16_t grain_seed; - uint8_t film_grain_params_ref_idx; - uint8_t num_y_points; - uint8_t point_y_value[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; - uint8_t point_y_scaling[STD_VIDEO_AV1_MAX_NUM_Y_POINTS]; - uint8_t num_cb_points; - uint8_t point_cb_value[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; - uint8_t point_cb_scaling[STD_VIDEO_AV1_MAX_NUM_CB_POINTS]; - uint8_t num_cr_points; - uint8_t point_cr_value[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; - uint8_t point_cr_scaling[STD_VIDEO_AV1_MAX_NUM_CR_POINTS]; - int8_t ar_coeffs_y_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_LUMA]; - int8_t ar_coeffs_cb_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; - int8_t ar_coeffs_cr_plus_128[STD_VIDEO_AV1_MAX_NUM_POS_CHROMA]; - uint8_t cb_mult; - uint8_t cb_luma_mult; - uint16_t cb_offset; - uint8_t cr_mult; - uint8_t cr_luma_mult; - uint16_t cr_offset; -} StdVideoAV1FilmGrain; - -typedef struct StdVideoAV1SequenceHeaderFlags { - uint32_t still_picture : 1; - uint32_t reduced_still_picture_header : 1; - uint32_t use_128x128_superblock : 1; - uint32_t enable_filter_intra : 1; - uint32_t enable_intra_edge_filter : 1; - uint32_t enable_interintra_compound : 1; - uint32_t enable_masked_compound : 1; - uint32_t enable_warped_motion : 1; - uint32_t enable_dual_filter : 1; - uint32_t enable_order_hint : 1; - uint32_t enable_jnt_comp : 1; - uint32_t enable_ref_frame_mvs : 1; - uint32_t frame_id_numbers_present_flag : 1; - uint32_t enable_superres : 1; - uint32_t enable_cdef : 1; - uint32_t enable_restoration : 1; - uint32_t film_grain_params_present : 1; - uint32_t timing_info_present_flag : 1; - uint32_t initial_display_delay_present_flag : 1; - uint32_t reserved : 13; -} StdVideoAV1SequenceHeaderFlags; - -typedef struct StdVideoAV1SequenceHeader { - StdVideoAV1SequenceHeaderFlags flags; - StdVideoAV1Profile seq_profile; - uint8_t frame_width_bits_minus_1; - uint8_t frame_height_bits_minus_1; - uint16_t max_frame_width_minus_1; - uint16_t max_frame_height_minus_1; - uint8_t delta_frame_id_length_minus_2; - uint8_t additional_frame_id_length_minus_1; - uint8_t order_hint_bits_minus_1; - uint8_t seq_force_integer_mv; - uint8_t seq_force_screen_content_tools; - uint8_t reserved1[5]; - const StdVideoAV1ColorConfig* pColorConfig; - const StdVideoAV1TimingInfo* pTimingInfo; -} StdVideoAV1SequenceHeader; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_decode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_decode.h deleted file mode 100644 index 60bf2c03987..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_decode.h +++ /dev/null @@ -1,109 +0,0 @@ -#ifndef VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ -#define VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codec_av1std_decode is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codec_av1std_decode 1 -#include "vulkan_video_codec_av1std.h" - -#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) - -#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_API_VERSION_1_0_0 -#define VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_decode" -typedef struct StdVideoDecodeAV1PictureInfoFlags { - uint32_t error_resilient_mode : 1; - uint32_t disable_cdf_update : 1; - uint32_t use_superres : 1; - uint32_t render_and_frame_size_different : 1; - uint32_t allow_screen_content_tools : 1; - uint32_t is_filter_switchable : 1; - uint32_t force_integer_mv : 1; - uint32_t frame_size_override_flag : 1; - uint32_t buffer_removal_time_present_flag : 1; - uint32_t allow_intrabc : 1; - uint32_t frame_refs_short_signaling : 1; - uint32_t allow_high_precision_mv : 1; - uint32_t is_motion_mode_switchable : 1; - uint32_t use_ref_frame_mvs : 1; - uint32_t disable_frame_end_update_cdf : 1; - uint32_t allow_warped_motion : 1; - uint32_t reduced_tx_set : 1; - uint32_t reference_select : 1; - uint32_t skip_mode_present : 1; - uint32_t delta_q_present : 1; - uint32_t delta_lf_present : 1; - uint32_t delta_lf_multi : 1; - uint32_t segmentation_enabled : 1; - uint32_t segmentation_update_map : 1; - uint32_t segmentation_temporal_update : 1; - uint32_t segmentation_update_data : 1; - uint32_t UsesLr : 1; - uint32_t usesChromaLr : 1; - uint32_t apply_grain : 1; - uint32_t reserved : 3; -} StdVideoDecodeAV1PictureInfoFlags; - -typedef struct StdVideoDecodeAV1PictureInfo { - StdVideoDecodeAV1PictureInfoFlags flags; - StdVideoAV1FrameType frame_type; - uint32_t current_frame_id; - uint8_t OrderHint; - uint8_t primary_ref_frame; - uint8_t refresh_frame_flags; - uint8_t reserved1; - StdVideoAV1InterpolationFilter interpolation_filter; - StdVideoAV1TxMode TxMode; - uint8_t delta_q_res; - uint8_t delta_lf_res; - uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES]; - uint8_t coded_denom; - uint8_t reserved2[3]; - uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; - uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES]; - const StdVideoAV1TileInfo* pTileInfo; - const StdVideoAV1Quantization* pQuantization; - const StdVideoAV1Segmentation* pSegmentation; - const StdVideoAV1LoopFilter* pLoopFilter; - const StdVideoAV1CDEF* pCDEF; - const StdVideoAV1LoopRestoration* pLoopRestoration; - const StdVideoAV1GlobalMotion* pGlobalMotion; - const StdVideoAV1FilmGrain* pFilmGrain; -} StdVideoDecodeAV1PictureInfo; - -typedef struct StdVideoDecodeAV1ReferenceInfoFlags { - uint32_t disable_frame_end_update_cdf : 1; - uint32_t segmentation_enabled : 1; - uint32_t reserved : 30; -} StdVideoDecodeAV1ReferenceInfoFlags; - -typedef struct StdVideoDecodeAV1ReferenceInfo { - StdVideoDecodeAV1ReferenceInfoFlags flags; - uint8_t frame_type; - uint8_t RefFrameSignBias; - uint8_t OrderHint; - uint8_t SavedOrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; -} StdVideoDecodeAV1ReferenceInfo; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_encode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_encode.h deleted file mode 100644 index 3602fe12502..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_av1std_encode.h +++ /dev/null @@ -1,143 +0,0 @@ -#ifndef VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ -#define VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codec_av1std_encode is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codec_av1std_encode 1 -#include "vulkan_video_codec_av1std.h" - -#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) - -#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_API_VERSION_1_0_0 -#define VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_av1_encode" -typedef struct StdVideoEncodeAV1DecoderModelInfo { - uint8_t buffer_delay_length_minus_1; - uint8_t buffer_removal_time_length_minus_1; - uint8_t frame_presentation_time_length_minus_1; - uint8_t reserved1; - uint32_t num_units_in_decoding_tick; -} StdVideoEncodeAV1DecoderModelInfo; - -typedef struct StdVideoEncodeAV1ExtensionHeader { - uint8_t temporal_id; - uint8_t spatial_id; -} StdVideoEncodeAV1ExtensionHeader; - -typedef struct StdVideoEncodeAV1OperatingPointInfoFlags { - uint32_t decoder_model_present_for_this_op : 1; - uint32_t low_delay_mode_flag : 1; - uint32_t initial_display_delay_present_for_this_op : 1; - uint32_t reserved : 29; -} StdVideoEncodeAV1OperatingPointInfoFlags; - -typedef struct StdVideoEncodeAV1OperatingPointInfo { - StdVideoEncodeAV1OperatingPointInfoFlags flags; - uint16_t operating_point_idc; - uint8_t seq_level_idx; - uint8_t seq_tier; - uint32_t decoder_buffer_delay; - uint32_t encoder_buffer_delay; - uint8_t initial_display_delay_minus_1; -} StdVideoEncodeAV1OperatingPointInfo; - -typedef struct StdVideoEncodeAV1PictureInfoFlags { - uint32_t error_resilient_mode : 1; - uint32_t disable_cdf_update : 1; - uint32_t use_superres : 1; - uint32_t render_and_frame_size_different : 1; - uint32_t allow_screen_content_tools : 1; - uint32_t is_filter_switchable : 1; - uint32_t force_integer_mv : 1; - uint32_t frame_size_override_flag : 1; - uint32_t buffer_removal_time_present_flag : 1; - uint32_t allow_intrabc : 1; - uint32_t frame_refs_short_signaling : 1; - uint32_t allow_high_precision_mv : 1; - uint32_t is_motion_mode_switchable : 1; - uint32_t use_ref_frame_mvs : 1; - uint32_t disable_frame_end_update_cdf : 1; - uint32_t allow_warped_motion : 1; - uint32_t reduced_tx_set : 1; - uint32_t skip_mode_present : 1; - uint32_t delta_q_present : 1; - uint32_t delta_lf_present : 1; - uint32_t delta_lf_multi : 1; - uint32_t segmentation_enabled : 1; - uint32_t segmentation_update_map : 1; - uint32_t segmentation_temporal_update : 1; - uint32_t segmentation_update_data : 1; - uint32_t UsesLr : 1; - uint32_t usesChromaLr : 1; - uint32_t show_frame : 1; - uint32_t showable_frame : 1; - uint32_t reserved : 3; -} StdVideoEncodeAV1PictureInfoFlags; - -typedef struct StdVideoEncodeAV1PictureInfo { - StdVideoEncodeAV1PictureInfoFlags flags; - StdVideoAV1FrameType frame_type; - uint32_t frame_presentation_time; - uint32_t current_frame_id; - uint8_t order_hint; - uint8_t primary_ref_frame; - uint8_t refresh_frame_flags; - uint8_t coded_denom; - uint16_t render_width_minus_1; - uint16_t render_height_minus_1; - StdVideoAV1InterpolationFilter interpolation_filter; - StdVideoAV1TxMode TxMode; - uint8_t delta_q_res; - uint8_t delta_lf_res; - uint8_t ref_order_hint[STD_VIDEO_AV1_NUM_REF_FRAMES]; - int8_t ref_frame_idx[STD_VIDEO_AV1_REFS_PER_FRAME]; - uint8_t reserved1[3]; - uint32_t delta_frame_id_minus_1[STD_VIDEO_AV1_REFS_PER_FRAME]; - const StdVideoAV1TileInfo* pTileInfo; - const StdVideoAV1Quantization* pQuantization; - const StdVideoAV1Segmentation* pSegmentation; - const StdVideoAV1LoopFilter* pLoopFilter; - const StdVideoAV1CDEF* pCDEF; - const StdVideoAV1LoopRestoration* pLoopRestoration; - const StdVideoAV1GlobalMotion* pGlobalMotion; - const StdVideoEncodeAV1ExtensionHeader* pExtensionHeader; - const uint32_t* pBufferRemovalTimes; -} StdVideoEncodeAV1PictureInfo; - -typedef struct StdVideoEncodeAV1ReferenceInfoFlags { - uint32_t disable_frame_end_update_cdf : 1; - uint32_t segmentation_enabled : 1; - uint32_t reserved : 30; -} StdVideoEncodeAV1ReferenceInfoFlags; - -typedef struct StdVideoEncodeAV1ReferenceInfo { - StdVideoEncodeAV1ReferenceInfoFlags flags; - uint32_t RefFrameId; - StdVideoAV1FrameType frame_type; - uint8_t OrderHint; - uint8_t reserved1[3]; - const StdVideoEncodeAV1ExtensionHeader* pExtensionHeader; -} StdVideoEncodeAV1ReferenceInfo; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std.h deleted file mode 100644 index 48621b6954d..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std.h +++ /dev/null @@ -1,312 +0,0 @@ -#ifndef VULKAN_VIDEO_CODEC_H264STD_H_ -#define VULKAN_VIDEO_CODEC_H264STD_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codec_h264std is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codec_h264std 1 -#include "vulkan_video_codecs_common.h" -#define STD_VIDEO_H264_CPB_CNT_LIST_SIZE 32U -#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS 6U -#define STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS 16U -#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS 6U -#define STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS 64U -#define STD_VIDEO_H264_MAX_NUM_LIST_REF 32U -#define STD_VIDEO_H264_MAX_CHROMA_PLANES 2U -#define STD_VIDEO_H264_NO_REFERENCE_PICTURE 0xFFU - -typedef enum StdVideoH264ChromaFormatIdc { - STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_420 = 1, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_422 = 2, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_444 = 3, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264ChromaFormatIdc; - -typedef enum StdVideoH264ProfileIdc { - STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66, - STD_VIDEO_H264_PROFILE_IDC_MAIN = 77, - STD_VIDEO_H264_PROFILE_IDC_HIGH = 100, - STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244, - STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264ProfileIdc; - -typedef enum StdVideoH264LevelIdc { - STD_VIDEO_H264_LEVEL_IDC_1_0 = 0, - STD_VIDEO_H264_LEVEL_IDC_1_1 = 1, - STD_VIDEO_H264_LEVEL_IDC_1_2 = 2, - STD_VIDEO_H264_LEVEL_IDC_1_3 = 3, - STD_VIDEO_H264_LEVEL_IDC_2_0 = 4, - STD_VIDEO_H264_LEVEL_IDC_2_1 = 5, - STD_VIDEO_H264_LEVEL_IDC_2_2 = 6, - STD_VIDEO_H264_LEVEL_IDC_3_0 = 7, - STD_VIDEO_H264_LEVEL_IDC_3_1 = 8, - STD_VIDEO_H264_LEVEL_IDC_3_2 = 9, - STD_VIDEO_H264_LEVEL_IDC_4_0 = 10, - STD_VIDEO_H264_LEVEL_IDC_4_1 = 11, - STD_VIDEO_H264_LEVEL_IDC_4_2 = 12, - STD_VIDEO_H264_LEVEL_IDC_5_0 = 13, - STD_VIDEO_H264_LEVEL_IDC_5_1 = 14, - STD_VIDEO_H264_LEVEL_IDC_5_2 = 15, - STD_VIDEO_H264_LEVEL_IDC_6_0 = 16, - STD_VIDEO_H264_LEVEL_IDC_6_1 = 17, - STD_VIDEO_H264_LEVEL_IDC_6_2 = 18, - STD_VIDEO_H264_LEVEL_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264LevelIdc; - -typedef enum StdVideoH264PocType { - STD_VIDEO_H264_POC_TYPE_0 = 0, - STD_VIDEO_H264_POC_TYPE_1 = 1, - STD_VIDEO_H264_POC_TYPE_2 = 2, - STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_POC_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264PocType; - -typedef enum StdVideoH264AspectRatioIdc { - STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED = 0, - STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE = 1, - STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11 = 2, - STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11 = 3, - STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11 = 4, - STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33 = 5, - STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11 = 6, - STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11 = 7, - STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11 = 8, - STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33 = 9, - STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11 = 10, - STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11 = 11, - STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33 = 12, - STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99 = 13, - STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3 = 14, - STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2 = 15, - STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1 = 16, - STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, - STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264AspectRatioIdc; - -typedef enum StdVideoH264WeightedBipredIdc { - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT = 0, - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT = 1, - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT = 2, - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264WeightedBipredIdc; - -typedef enum StdVideoH264ModificationOfPicNumsIdc { - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT = 0, - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD = 1, - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM = 2, - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END = 3, - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264ModificationOfPicNumsIdc; - -typedef enum StdVideoH264MemMgmtControlOp { - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END = 0, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM = 1, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM = 2, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM = 3, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX = 4, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL = 5, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM = 6, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264MemMgmtControlOp; - -typedef enum StdVideoH264CabacInitIdc { - STD_VIDEO_H264_CABAC_INIT_IDC_0 = 0, - STD_VIDEO_H264_CABAC_INIT_IDC_1 = 1, - STD_VIDEO_H264_CABAC_INIT_IDC_2 = 2, - STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_CABAC_INIT_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264CabacInitIdc; - -typedef enum StdVideoH264DisableDeblockingFilterIdc { - STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED = 0, - STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED = 1, - STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL = 2, - STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264DisableDeblockingFilterIdc; - -typedef enum StdVideoH264SliceType { - STD_VIDEO_H264_SLICE_TYPE_P = 0, - STD_VIDEO_H264_SLICE_TYPE_B = 1, - STD_VIDEO_H264_SLICE_TYPE_I = 2, - STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264SliceType; - -typedef enum StdVideoH264PictureType { - STD_VIDEO_H264_PICTURE_TYPE_P = 0, - STD_VIDEO_H264_PICTURE_TYPE_B = 1, - STD_VIDEO_H264_PICTURE_TYPE_I = 2, - STD_VIDEO_H264_PICTURE_TYPE_IDR = 5, - STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264PictureType; - -typedef enum StdVideoH264NonVclNaluType { - STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS = 0, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS = 1, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD = 2, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX = 3, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE = 4, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM = 5, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED = 6, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264NonVclNaluType; -typedef struct StdVideoH264SpsVuiFlags { - uint32_t aspect_ratio_info_present_flag : 1; - uint32_t overscan_info_present_flag : 1; - uint32_t overscan_appropriate_flag : 1; - uint32_t video_signal_type_present_flag : 1; - uint32_t video_full_range_flag : 1; - uint32_t color_description_present_flag : 1; - uint32_t chroma_loc_info_present_flag : 1; - uint32_t timing_info_present_flag : 1; - uint32_t fixed_frame_rate_flag : 1; - uint32_t bitstream_restriction_flag : 1; - uint32_t nal_hrd_parameters_present_flag : 1; - uint32_t vcl_hrd_parameters_present_flag : 1; -} StdVideoH264SpsVuiFlags; - -typedef struct StdVideoH264HrdParameters { - uint8_t cpb_cnt_minus1; - uint8_t bit_rate_scale; - uint8_t cpb_size_scale; - uint8_t reserved1; - uint32_t bit_rate_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; - uint32_t cpb_size_value_minus1[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; - uint8_t cbr_flag[STD_VIDEO_H264_CPB_CNT_LIST_SIZE]; - uint32_t initial_cpb_removal_delay_length_minus1; - uint32_t cpb_removal_delay_length_minus1; - uint32_t dpb_output_delay_length_minus1; - uint32_t time_offset_length; -} StdVideoH264HrdParameters; - -typedef struct StdVideoH264SequenceParameterSetVui { - StdVideoH264SpsVuiFlags flags; - StdVideoH264AspectRatioIdc aspect_ratio_idc; - uint16_t sar_width; - uint16_t sar_height; - uint8_t video_format; - uint8_t colour_primaries; - uint8_t transfer_characteristics; - uint8_t matrix_coefficients; - uint32_t num_units_in_tick; - uint32_t time_scale; - uint8_t max_num_reorder_frames; - uint8_t max_dec_frame_buffering; - uint8_t chroma_sample_loc_type_top_field; - uint8_t chroma_sample_loc_type_bottom_field; - uint32_t reserved1; - const StdVideoH264HrdParameters* pHrdParameters; -} StdVideoH264SequenceParameterSetVui; - -typedef struct StdVideoH264SpsFlags { - uint32_t constraint_set0_flag : 1; - uint32_t constraint_set1_flag : 1; - uint32_t constraint_set2_flag : 1; - uint32_t constraint_set3_flag : 1; - uint32_t constraint_set4_flag : 1; - uint32_t constraint_set5_flag : 1; - uint32_t direct_8x8_inference_flag : 1; - uint32_t mb_adaptive_frame_field_flag : 1; - uint32_t frame_mbs_only_flag : 1; - uint32_t delta_pic_order_always_zero_flag : 1; - uint32_t separate_colour_plane_flag : 1; - uint32_t gaps_in_frame_num_value_allowed_flag : 1; - uint32_t qpprime_y_zero_transform_bypass_flag : 1; - uint32_t frame_cropping_flag : 1; - uint32_t seq_scaling_matrix_present_flag : 1; - uint32_t vui_parameters_present_flag : 1; -} StdVideoH264SpsFlags; - -typedef struct StdVideoH264ScalingLists { - uint16_t scaling_list_present_mask; - uint16_t use_default_scaling_matrix_mask; - uint8_t ScalingList4x4[STD_VIDEO_H264_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_4X4_NUM_ELEMENTS]; - uint8_t ScalingList8x8[STD_VIDEO_H264_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H264_SCALING_LIST_8X8_NUM_ELEMENTS]; -} StdVideoH264ScalingLists; - -typedef struct StdVideoH264SequenceParameterSet { - StdVideoH264SpsFlags flags; - StdVideoH264ProfileIdc profile_idc; - StdVideoH264LevelIdc level_idc; - StdVideoH264ChromaFormatIdc chroma_format_idc; - uint8_t seq_parameter_set_id; - uint8_t bit_depth_luma_minus8; - uint8_t bit_depth_chroma_minus8; - uint8_t log2_max_frame_num_minus4; - StdVideoH264PocType pic_order_cnt_type; - int32_t offset_for_non_ref_pic; - int32_t offset_for_top_to_bottom_field; - uint8_t log2_max_pic_order_cnt_lsb_minus4; - uint8_t num_ref_frames_in_pic_order_cnt_cycle; - uint8_t max_num_ref_frames; - uint8_t reserved1; - uint32_t pic_width_in_mbs_minus1; - uint32_t pic_height_in_map_units_minus1; - uint32_t frame_crop_left_offset; - uint32_t frame_crop_right_offset; - uint32_t frame_crop_top_offset; - uint32_t frame_crop_bottom_offset; - uint32_t reserved2; - const int32_t* pOffsetForRefFrame; - const StdVideoH264ScalingLists* pScalingLists; - const StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; -} StdVideoH264SequenceParameterSet; - -typedef struct StdVideoH264PpsFlags { - uint32_t transform_8x8_mode_flag : 1; - uint32_t redundant_pic_cnt_present_flag : 1; - uint32_t constrained_intra_pred_flag : 1; - uint32_t deblocking_filter_control_present_flag : 1; - uint32_t weighted_pred_flag : 1; - uint32_t bottom_field_pic_order_in_frame_present_flag : 1; - uint32_t entropy_coding_mode_flag : 1; - uint32_t pic_scaling_matrix_present_flag : 1; -} StdVideoH264PpsFlags; - -typedef struct StdVideoH264PictureParameterSet { - StdVideoH264PpsFlags flags; - uint8_t seq_parameter_set_id; - uint8_t pic_parameter_set_id; - uint8_t num_ref_idx_l0_default_active_minus1; - uint8_t num_ref_idx_l1_default_active_minus1; - StdVideoH264WeightedBipredIdc weighted_bipred_idc; - int8_t pic_init_qp_minus26; - int8_t pic_init_qs_minus26; - int8_t chroma_qp_index_offset; - int8_t second_chroma_qp_index_offset; - const StdVideoH264ScalingLists* pScalingLists; -} StdVideoH264PictureParameterSet; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_decode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_decode.h deleted file mode 100644 index a6bfe9d8228..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_decode.h +++ /dev/null @@ -1,77 +0,0 @@ -#ifndef VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ -#define VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codec_h264std_decode is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codec_h264std_decode 1 -#include "vulkan_video_codec_h264std.h" - -#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) - -#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_API_VERSION_1_0_0 -#define VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_decode" -#define STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE 2U - -typedef enum StdVideoDecodeH264FieldOrderCount { - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM = 1, - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID = 0x7FFFFFFF, - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_MAX_ENUM = 0x7FFFFFFF -} StdVideoDecodeH264FieldOrderCount; -typedef struct StdVideoDecodeH264PictureInfoFlags { - uint32_t field_pic_flag : 1; - uint32_t is_intra : 1; - uint32_t IdrPicFlag : 1; - uint32_t bottom_field_flag : 1; - uint32_t is_reference : 1; - uint32_t complementary_field_pair : 1; -} StdVideoDecodeH264PictureInfoFlags; - -typedef struct StdVideoDecodeH264PictureInfo { - StdVideoDecodeH264PictureInfoFlags flags; - uint8_t seq_parameter_set_id; - uint8_t pic_parameter_set_id; - uint8_t reserved1; - uint8_t reserved2; - uint16_t frame_num; - uint16_t idr_pic_id; - int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; -} StdVideoDecodeH264PictureInfo; - -typedef struct StdVideoDecodeH264ReferenceInfoFlags { - uint32_t top_field_flag : 1; - uint32_t bottom_field_flag : 1; - uint32_t used_for_long_term_reference : 1; - uint32_t is_non_existing : 1; -} StdVideoDecodeH264ReferenceInfoFlags; - -typedef struct StdVideoDecodeH264ReferenceInfo { - StdVideoDecodeH264ReferenceInfoFlags flags; - uint16_t FrameNum; - uint16_t reserved; - int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE]; -} StdVideoDecodeH264ReferenceInfo; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_encode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_encode.h deleted file mode 100644 index 2d42ac321b8..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h264std_encode.h +++ /dev/null @@ -1,147 +0,0 @@ -#ifndef VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ -#define VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codec_h264std_encode is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codec_h264std_encode 1 -#include "vulkan_video_codec_h264std.h" - -#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) - -#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_API_VERSION_1_0_0 -#define VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h264_encode" -typedef struct StdVideoEncodeH264WeightTableFlags { - uint32_t luma_weight_l0_flag; - uint32_t chroma_weight_l0_flag; - uint32_t luma_weight_l1_flag; - uint32_t chroma_weight_l1_flag; -} StdVideoEncodeH264WeightTableFlags; - -typedef struct StdVideoEncodeH264WeightTable { - StdVideoEncodeH264WeightTableFlags flags; - uint8_t luma_log2_weight_denom; - uint8_t chroma_log2_weight_denom; - int8_t luma_weight_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; - int8_t luma_offset_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; - int8_t chroma_weight_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; - int8_t chroma_offset_l0[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; - int8_t luma_weight_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; - int8_t luma_offset_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; - int8_t chroma_weight_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; - int8_t chroma_offset_l1[STD_VIDEO_H264_MAX_NUM_LIST_REF][STD_VIDEO_H264_MAX_CHROMA_PLANES]; -} StdVideoEncodeH264WeightTable; - -typedef struct StdVideoEncodeH264SliceHeaderFlags { - uint32_t direct_spatial_mv_pred_flag : 1; - uint32_t num_ref_idx_active_override_flag : 1; - uint32_t reserved : 30; -} StdVideoEncodeH264SliceHeaderFlags; - -typedef struct StdVideoEncodeH264PictureInfoFlags { - uint32_t IdrPicFlag : 1; - uint32_t is_reference : 1; - uint32_t no_output_of_prior_pics_flag : 1; - uint32_t long_term_reference_flag : 1; - uint32_t adaptive_ref_pic_marking_mode_flag : 1; - uint32_t reserved : 27; -} StdVideoEncodeH264PictureInfoFlags; - -typedef struct StdVideoEncodeH264ReferenceInfoFlags { - uint32_t used_for_long_term_reference : 1; - uint32_t reserved : 31; -} StdVideoEncodeH264ReferenceInfoFlags; - -typedef struct StdVideoEncodeH264ReferenceListsInfoFlags { - uint32_t ref_pic_list_modification_flag_l0 : 1; - uint32_t ref_pic_list_modification_flag_l1 : 1; - uint32_t reserved : 30; -} StdVideoEncodeH264ReferenceListsInfoFlags; - -typedef struct StdVideoEncodeH264RefListModEntry { - StdVideoH264ModificationOfPicNumsIdc modification_of_pic_nums_idc; - uint16_t abs_diff_pic_num_minus1; - uint16_t long_term_pic_num; -} StdVideoEncodeH264RefListModEntry; - -typedef struct StdVideoEncodeH264RefPicMarkingEntry { - StdVideoH264MemMgmtControlOp memory_management_control_operation; - uint16_t difference_of_pic_nums_minus1; - uint16_t long_term_pic_num; - uint16_t long_term_frame_idx; - uint16_t max_long_term_frame_idx_plus1; -} StdVideoEncodeH264RefPicMarkingEntry; - -typedef struct StdVideoEncodeH264ReferenceListsInfo { - StdVideoEncodeH264ReferenceListsInfoFlags flags; - uint8_t num_ref_idx_l0_active_minus1; - uint8_t num_ref_idx_l1_active_minus1; - uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; - uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; - uint8_t refList0ModOpCount; - uint8_t refList1ModOpCount; - uint8_t refPicMarkingOpCount; - uint8_t reserved1[7]; - const StdVideoEncodeH264RefListModEntry* pRefList0ModOperations; - const StdVideoEncodeH264RefListModEntry* pRefList1ModOperations; - const StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations; -} StdVideoEncodeH264ReferenceListsInfo; - -typedef struct StdVideoEncodeH264PictureInfo { - StdVideoEncodeH264PictureInfoFlags flags; - uint8_t seq_parameter_set_id; - uint8_t pic_parameter_set_id; - uint16_t idr_pic_id; - StdVideoH264PictureType primary_pic_type; - uint32_t frame_num; - int32_t PicOrderCnt; - uint8_t temporal_id; - uint8_t reserved1[3]; - const StdVideoEncodeH264ReferenceListsInfo* pRefLists; -} StdVideoEncodeH264PictureInfo; - -typedef struct StdVideoEncodeH264ReferenceInfo { - StdVideoEncodeH264ReferenceInfoFlags flags; - StdVideoH264PictureType primary_pic_type; - uint32_t FrameNum; - int32_t PicOrderCnt; - uint16_t long_term_pic_num; - uint16_t long_term_frame_idx; - uint8_t temporal_id; -} StdVideoEncodeH264ReferenceInfo; - -typedef struct StdVideoEncodeH264SliceHeader { - StdVideoEncodeH264SliceHeaderFlags flags; - uint32_t first_mb_in_slice; - StdVideoH264SliceType slice_type; - int8_t slice_alpha_c0_offset_div2; - int8_t slice_beta_offset_div2; - int8_t slice_qp_delta; - uint8_t reserved1; - StdVideoH264CabacInitIdc cabac_init_idc; - StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; - const StdVideoEncodeH264WeightTable* pWeightTable; -} StdVideoEncodeH264SliceHeader; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std.h deleted file mode 100644 index 23617b8f962..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std.h +++ /dev/null @@ -1,446 +0,0 @@ -#ifndef VULKAN_VIDEO_CODEC_H265STD_H_ -#define VULKAN_VIDEO_CODEC_H265STD_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codec_h265std is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codec_h265std 1 -#include "vulkan_video_codecs_common.h" -#define STD_VIDEO_H265_CPB_CNT_LIST_SIZE 32U -#define STD_VIDEO_H265_SUBLAYERS_LIST_SIZE 7U -#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS 6U -#define STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS 16U -#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS 6U -#define STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS 64U -#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS 6U -#define STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS 64U -#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS 2U -#define STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS 64U -#define STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE 6U -#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE 19U -#define STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE 21U -#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE 3U -#define STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE 128U -#define STD_VIDEO_H265_MAX_NUM_LIST_REF 15U -#define STD_VIDEO_H265_MAX_CHROMA_PLANES 2U -#define STD_VIDEO_H265_MAX_SHORT_TERM_REF_PIC_SETS 64U -#define STD_VIDEO_H265_MAX_DPB_SIZE 16U -#define STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS 32U -#define STD_VIDEO_H265_MAX_LONG_TERM_PICS 16U -#define STD_VIDEO_H265_MAX_DELTA_POC 48U -#define STD_VIDEO_H265_NO_REFERENCE_PICTURE 0xFFU - -typedef enum StdVideoH265ChromaFormatIdc { - STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_420 = 1, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_422 = 2, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_444 = 3, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265ChromaFormatIdc; - -typedef enum StdVideoH265ProfileIdc { - STD_VIDEO_H265_PROFILE_IDC_MAIN = 1, - STD_VIDEO_H265_PROFILE_IDC_MAIN_10 = 2, - STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE = 3, - STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS = 4, - STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS = 9, - STD_VIDEO_H265_PROFILE_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265ProfileIdc; - -typedef enum StdVideoH265LevelIdc { - STD_VIDEO_H265_LEVEL_IDC_1_0 = 0, - STD_VIDEO_H265_LEVEL_IDC_2_0 = 1, - STD_VIDEO_H265_LEVEL_IDC_2_1 = 2, - STD_VIDEO_H265_LEVEL_IDC_3_0 = 3, - STD_VIDEO_H265_LEVEL_IDC_3_1 = 4, - STD_VIDEO_H265_LEVEL_IDC_4_0 = 5, - STD_VIDEO_H265_LEVEL_IDC_4_1 = 6, - STD_VIDEO_H265_LEVEL_IDC_5_0 = 7, - STD_VIDEO_H265_LEVEL_IDC_5_1 = 8, - STD_VIDEO_H265_LEVEL_IDC_5_2 = 9, - STD_VIDEO_H265_LEVEL_IDC_6_0 = 10, - STD_VIDEO_H265_LEVEL_IDC_6_1 = 11, - STD_VIDEO_H265_LEVEL_IDC_6_2 = 12, - STD_VIDEO_H265_LEVEL_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265LevelIdc; - -typedef enum StdVideoH265SliceType { - STD_VIDEO_H265_SLICE_TYPE_B = 0, - STD_VIDEO_H265_SLICE_TYPE_P = 1, - STD_VIDEO_H265_SLICE_TYPE_I = 2, - STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265SliceType; - -typedef enum StdVideoH265PictureType { - STD_VIDEO_H265_PICTURE_TYPE_P = 0, - STD_VIDEO_H265_PICTURE_TYPE_B = 1, - STD_VIDEO_H265_PICTURE_TYPE_I = 2, - STD_VIDEO_H265_PICTURE_TYPE_IDR = 3, - STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265PictureType; - -typedef enum StdVideoH265AspectRatioIdc { - STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED = 0, - STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE = 1, - STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11 = 2, - STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11 = 3, - STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11 = 4, - STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33 = 5, - STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11 = 6, - STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11 = 7, - STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11 = 8, - STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33 = 9, - STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11 = 10, - STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11 = 11, - STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33 = 12, - STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99 = 13, - STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3 = 14, - STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2 = 15, - STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1 = 16, - STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, - STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265AspectRatioIdc; -typedef struct StdVideoH265DecPicBufMgr { - uint32_t max_latency_increase_plus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; - uint8_t max_dec_pic_buffering_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; - uint8_t max_num_reorder_pics[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; -} StdVideoH265DecPicBufMgr; - -typedef struct StdVideoH265SubLayerHrdParameters { - uint32_t bit_rate_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; - uint32_t cpb_size_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; - uint32_t cpb_size_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; - uint32_t bit_rate_du_value_minus1[STD_VIDEO_H265_CPB_CNT_LIST_SIZE]; - uint32_t cbr_flag; -} StdVideoH265SubLayerHrdParameters; - -typedef struct StdVideoH265HrdFlags { - uint32_t nal_hrd_parameters_present_flag : 1; - uint32_t vcl_hrd_parameters_present_flag : 1; - uint32_t sub_pic_hrd_params_present_flag : 1; - uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; - uint32_t fixed_pic_rate_general_flag : 8; - uint32_t fixed_pic_rate_within_cvs_flag : 8; - uint32_t low_delay_hrd_flag : 8; -} StdVideoH265HrdFlags; - -typedef struct StdVideoH265HrdParameters { - StdVideoH265HrdFlags flags; - uint8_t tick_divisor_minus2; - uint8_t du_cpb_removal_delay_increment_length_minus1; - uint8_t dpb_output_delay_du_length_minus1; - uint8_t bit_rate_scale; - uint8_t cpb_size_scale; - uint8_t cpb_size_du_scale; - uint8_t initial_cpb_removal_delay_length_minus1; - uint8_t au_cpb_removal_delay_length_minus1; - uint8_t dpb_output_delay_length_minus1; - uint8_t cpb_cnt_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; - uint16_t elemental_duration_in_tc_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE]; - uint16_t reserved[3]; - const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal; - const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl; -} StdVideoH265HrdParameters; - -typedef struct StdVideoH265VpsFlags { - uint32_t vps_temporal_id_nesting_flag : 1; - uint32_t vps_sub_layer_ordering_info_present_flag : 1; - uint32_t vps_timing_info_present_flag : 1; - uint32_t vps_poc_proportional_to_timing_flag : 1; -} StdVideoH265VpsFlags; - -typedef struct StdVideoH265ProfileTierLevelFlags { - uint32_t general_tier_flag : 1; - uint32_t general_progressive_source_flag : 1; - uint32_t general_interlaced_source_flag : 1; - uint32_t general_non_packed_constraint_flag : 1; - uint32_t general_frame_only_constraint_flag : 1; -} StdVideoH265ProfileTierLevelFlags; - -typedef struct StdVideoH265ProfileTierLevel { - StdVideoH265ProfileTierLevelFlags flags; - StdVideoH265ProfileIdc general_profile_idc; - StdVideoH265LevelIdc general_level_idc; -} StdVideoH265ProfileTierLevel; - -typedef struct StdVideoH265VideoParameterSet { - StdVideoH265VpsFlags flags; - uint8_t vps_video_parameter_set_id; - uint8_t vps_max_sub_layers_minus1; - uint8_t reserved1; - uint8_t reserved2; - uint32_t vps_num_units_in_tick; - uint32_t vps_time_scale; - uint32_t vps_num_ticks_poc_diff_one_minus1; - uint32_t reserved3; - const StdVideoH265DecPicBufMgr* pDecPicBufMgr; - const StdVideoH265HrdParameters* pHrdParameters; - const StdVideoH265ProfileTierLevel* pProfileTierLevel; -} StdVideoH265VideoParameterSet; - -typedef struct StdVideoH265ScalingLists { - uint8_t ScalingList4x4[STD_VIDEO_H265_SCALING_LIST_4X4_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_4X4_NUM_ELEMENTS]; - uint8_t ScalingList8x8[STD_VIDEO_H265_SCALING_LIST_8X8_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_8X8_NUM_ELEMENTS]; - uint8_t ScalingList16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_16X16_NUM_ELEMENTS]; - uint8_t ScalingList32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS][STD_VIDEO_H265_SCALING_LIST_32X32_NUM_ELEMENTS]; - uint8_t ScalingListDCCoef16x16[STD_VIDEO_H265_SCALING_LIST_16X16_NUM_LISTS]; - uint8_t ScalingListDCCoef32x32[STD_VIDEO_H265_SCALING_LIST_32X32_NUM_LISTS]; -} StdVideoH265ScalingLists; - -typedef struct StdVideoH265SpsVuiFlags { - uint32_t aspect_ratio_info_present_flag : 1; - uint32_t overscan_info_present_flag : 1; - uint32_t overscan_appropriate_flag : 1; - uint32_t video_signal_type_present_flag : 1; - uint32_t video_full_range_flag : 1; - uint32_t colour_description_present_flag : 1; - uint32_t chroma_loc_info_present_flag : 1; - uint32_t neutral_chroma_indication_flag : 1; - uint32_t field_seq_flag : 1; - uint32_t frame_field_info_present_flag : 1; - uint32_t default_display_window_flag : 1; - uint32_t vui_timing_info_present_flag : 1; - uint32_t vui_poc_proportional_to_timing_flag : 1; - uint32_t vui_hrd_parameters_present_flag : 1; - uint32_t bitstream_restriction_flag : 1; - uint32_t tiles_fixed_structure_flag : 1; - uint32_t motion_vectors_over_pic_boundaries_flag : 1; - uint32_t restricted_ref_pic_lists_flag : 1; -} StdVideoH265SpsVuiFlags; - -typedef struct StdVideoH265SequenceParameterSetVui { - StdVideoH265SpsVuiFlags flags; - StdVideoH265AspectRatioIdc aspect_ratio_idc; - uint16_t sar_width; - uint16_t sar_height; - uint8_t video_format; - uint8_t colour_primaries; - uint8_t transfer_characteristics; - uint8_t matrix_coeffs; - uint8_t chroma_sample_loc_type_top_field; - uint8_t chroma_sample_loc_type_bottom_field; - uint8_t reserved1; - uint8_t reserved2; - uint16_t def_disp_win_left_offset; - uint16_t def_disp_win_right_offset; - uint16_t def_disp_win_top_offset; - uint16_t def_disp_win_bottom_offset; - uint32_t vui_num_units_in_tick; - uint32_t vui_time_scale; - uint32_t vui_num_ticks_poc_diff_one_minus1; - uint16_t min_spatial_segmentation_idc; - uint16_t reserved3; - uint8_t max_bytes_per_pic_denom; - uint8_t max_bits_per_min_cu_denom; - uint8_t log2_max_mv_length_horizontal; - uint8_t log2_max_mv_length_vertical; - const StdVideoH265HrdParameters* pHrdParameters; -} StdVideoH265SequenceParameterSetVui; - -typedef struct StdVideoH265PredictorPaletteEntries { - uint16_t PredictorPaletteEntries[STD_VIDEO_H265_PREDICTOR_PALETTE_COMPONENTS_LIST_SIZE][STD_VIDEO_H265_PREDICTOR_PALETTE_COMP_ENTRIES_LIST_SIZE]; -} StdVideoH265PredictorPaletteEntries; - -typedef struct StdVideoH265SpsFlags { - uint32_t sps_temporal_id_nesting_flag : 1; - uint32_t separate_colour_plane_flag : 1; - uint32_t conformance_window_flag : 1; - uint32_t sps_sub_layer_ordering_info_present_flag : 1; - uint32_t scaling_list_enabled_flag : 1; - uint32_t sps_scaling_list_data_present_flag : 1; - uint32_t amp_enabled_flag : 1; - uint32_t sample_adaptive_offset_enabled_flag : 1; - uint32_t pcm_enabled_flag : 1; - uint32_t pcm_loop_filter_disabled_flag : 1; - uint32_t long_term_ref_pics_present_flag : 1; - uint32_t sps_temporal_mvp_enabled_flag : 1; - uint32_t strong_intra_smoothing_enabled_flag : 1; - uint32_t vui_parameters_present_flag : 1; - uint32_t sps_extension_present_flag : 1; - uint32_t sps_range_extension_flag : 1; - uint32_t transform_skip_rotation_enabled_flag : 1; - uint32_t transform_skip_context_enabled_flag : 1; - uint32_t implicit_rdpcm_enabled_flag : 1; - uint32_t explicit_rdpcm_enabled_flag : 1; - uint32_t extended_precision_processing_flag : 1; - uint32_t intra_smoothing_disabled_flag : 1; - uint32_t high_precision_offsets_enabled_flag : 1; - uint32_t persistent_rice_adaptation_enabled_flag : 1; - uint32_t cabac_bypass_alignment_enabled_flag : 1; - uint32_t sps_scc_extension_flag : 1; - uint32_t sps_curr_pic_ref_enabled_flag : 1; - uint32_t palette_mode_enabled_flag : 1; - uint32_t sps_palette_predictor_initializers_present_flag : 1; - uint32_t intra_boundary_filtering_disabled_flag : 1; -} StdVideoH265SpsFlags; - -typedef struct StdVideoH265ShortTermRefPicSetFlags { - uint32_t inter_ref_pic_set_prediction_flag : 1; - uint32_t delta_rps_sign : 1; -} StdVideoH265ShortTermRefPicSetFlags; - -typedef struct StdVideoH265ShortTermRefPicSet { - StdVideoH265ShortTermRefPicSetFlags flags; - uint32_t delta_idx_minus1; - uint16_t use_delta_flag; - uint16_t abs_delta_rps_minus1; - uint16_t used_by_curr_pic_flag; - uint16_t used_by_curr_pic_s0_flag; - uint16_t used_by_curr_pic_s1_flag; - uint16_t reserved1; - uint8_t reserved2; - uint8_t reserved3; - uint8_t num_negative_pics; - uint8_t num_positive_pics; - uint16_t delta_poc_s0_minus1[STD_VIDEO_H265_MAX_DPB_SIZE]; - uint16_t delta_poc_s1_minus1[STD_VIDEO_H265_MAX_DPB_SIZE]; -} StdVideoH265ShortTermRefPicSet; - -typedef struct StdVideoH265LongTermRefPicsSps { - uint32_t used_by_curr_pic_lt_sps_flag; - uint32_t lt_ref_pic_poc_lsb_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]; -} StdVideoH265LongTermRefPicsSps; - -typedef struct StdVideoH265SequenceParameterSet { - StdVideoH265SpsFlags flags; - StdVideoH265ChromaFormatIdc chroma_format_idc; - uint32_t pic_width_in_luma_samples; - uint32_t pic_height_in_luma_samples; - uint8_t sps_video_parameter_set_id; - uint8_t sps_max_sub_layers_minus1; - uint8_t sps_seq_parameter_set_id; - uint8_t bit_depth_luma_minus8; - uint8_t bit_depth_chroma_minus8; - uint8_t log2_max_pic_order_cnt_lsb_minus4; - uint8_t log2_min_luma_coding_block_size_minus3; - uint8_t log2_diff_max_min_luma_coding_block_size; - uint8_t log2_min_luma_transform_block_size_minus2; - uint8_t log2_diff_max_min_luma_transform_block_size; - uint8_t max_transform_hierarchy_depth_inter; - uint8_t max_transform_hierarchy_depth_intra; - uint8_t num_short_term_ref_pic_sets; - uint8_t num_long_term_ref_pics_sps; - uint8_t pcm_sample_bit_depth_luma_minus1; - uint8_t pcm_sample_bit_depth_chroma_minus1; - uint8_t log2_min_pcm_luma_coding_block_size_minus3; - uint8_t log2_diff_max_min_pcm_luma_coding_block_size; - uint8_t reserved1; - uint8_t reserved2; - uint8_t palette_max_size; - uint8_t delta_palette_max_predictor_size; - uint8_t motion_vector_resolution_control_idc; - uint8_t sps_num_palette_predictor_initializers_minus1; - uint32_t conf_win_left_offset; - uint32_t conf_win_right_offset; - uint32_t conf_win_top_offset; - uint32_t conf_win_bottom_offset; - const StdVideoH265ProfileTierLevel* pProfileTierLevel; - const StdVideoH265DecPicBufMgr* pDecPicBufMgr; - const StdVideoH265ScalingLists* pScalingLists; - const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; - const StdVideoH265LongTermRefPicsSps* pLongTermRefPicsSps; - const StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; - const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; -} StdVideoH265SequenceParameterSet; - -typedef struct StdVideoH265PpsFlags { - uint32_t dependent_slice_segments_enabled_flag : 1; - uint32_t output_flag_present_flag : 1; - uint32_t sign_data_hiding_enabled_flag : 1; - uint32_t cabac_init_present_flag : 1; - uint32_t constrained_intra_pred_flag : 1; - uint32_t transform_skip_enabled_flag : 1; - uint32_t cu_qp_delta_enabled_flag : 1; - uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; - uint32_t weighted_pred_flag : 1; - uint32_t weighted_bipred_flag : 1; - uint32_t transquant_bypass_enabled_flag : 1; - uint32_t tiles_enabled_flag : 1; - uint32_t entropy_coding_sync_enabled_flag : 1; - uint32_t uniform_spacing_flag : 1; - uint32_t loop_filter_across_tiles_enabled_flag : 1; - uint32_t pps_loop_filter_across_slices_enabled_flag : 1; - uint32_t deblocking_filter_control_present_flag : 1; - uint32_t deblocking_filter_override_enabled_flag : 1; - uint32_t pps_deblocking_filter_disabled_flag : 1; - uint32_t pps_scaling_list_data_present_flag : 1; - uint32_t lists_modification_present_flag : 1; - uint32_t slice_segment_header_extension_present_flag : 1; - uint32_t pps_extension_present_flag : 1; - uint32_t cross_component_prediction_enabled_flag : 1; - uint32_t chroma_qp_offset_list_enabled_flag : 1; - uint32_t pps_curr_pic_ref_enabled_flag : 1; - uint32_t residual_adaptive_colour_transform_enabled_flag : 1; - uint32_t pps_slice_act_qp_offsets_present_flag : 1; - uint32_t pps_palette_predictor_initializers_present_flag : 1; - uint32_t monochrome_palette_flag : 1; - uint32_t pps_range_extension_flag : 1; -} StdVideoH265PpsFlags; - -typedef struct StdVideoH265PictureParameterSet { - StdVideoH265PpsFlags flags; - uint8_t pps_pic_parameter_set_id; - uint8_t pps_seq_parameter_set_id; - uint8_t sps_video_parameter_set_id; - uint8_t num_extra_slice_header_bits; - uint8_t num_ref_idx_l0_default_active_minus1; - uint8_t num_ref_idx_l1_default_active_minus1; - int8_t init_qp_minus26; - uint8_t diff_cu_qp_delta_depth; - int8_t pps_cb_qp_offset; - int8_t pps_cr_qp_offset; - int8_t pps_beta_offset_div2; - int8_t pps_tc_offset_div2; - uint8_t log2_parallel_merge_level_minus2; - uint8_t log2_max_transform_skip_block_size_minus2; - uint8_t diff_cu_chroma_qp_offset_depth; - uint8_t chroma_qp_offset_list_len_minus1; - int8_t cb_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; - int8_t cr_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE]; - uint8_t log2_sao_offset_scale_luma; - uint8_t log2_sao_offset_scale_chroma; - int8_t pps_act_y_qp_offset_plus5; - int8_t pps_act_cb_qp_offset_plus5; - int8_t pps_act_cr_qp_offset_plus3; - uint8_t pps_num_palette_predictor_initializers; - uint8_t luma_bit_depth_entry_minus8; - uint8_t chroma_bit_depth_entry_minus8; - uint8_t num_tile_columns_minus1; - uint8_t num_tile_rows_minus1; - uint8_t reserved1; - uint8_t reserved2; - uint16_t column_width_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE]; - uint16_t row_height_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE]; - uint32_t reserved3; - const StdVideoH265ScalingLists* pScalingLists; - const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; -} StdVideoH265PictureParameterSet; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_decode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_decode.h deleted file mode 100644 index 1758d4a88dd..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_decode.h +++ /dev/null @@ -1,67 +0,0 @@ -#ifndef VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ -#define VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codec_h265std_decode is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codec_h265std_decode 1 -#include "vulkan_video_codec_h265std.h" - -#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) - -#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_API_VERSION_1_0_0 -#define VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_decode" -#define STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE 8U -typedef struct StdVideoDecodeH265PictureInfoFlags { - uint32_t IrapPicFlag : 1; - uint32_t IdrPicFlag : 1; - uint32_t IsReference : 1; - uint32_t short_term_ref_pic_set_sps_flag : 1; -} StdVideoDecodeH265PictureInfoFlags; - -typedef struct StdVideoDecodeH265PictureInfo { - StdVideoDecodeH265PictureInfoFlags flags; - uint8_t sps_video_parameter_set_id; - uint8_t pps_seq_parameter_set_id; - uint8_t pps_pic_parameter_set_id; - uint8_t NumDeltaPocsOfRefRpsIdx; - int32_t PicOrderCntVal; - uint16_t NumBitsForSTRefPicSetInSlice; - uint16_t reserved; - uint8_t RefPicSetStCurrBefore[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; - uint8_t RefPicSetStCurrAfter[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; - uint8_t RefPicSetLtCurr[STD_VIDEO_DECODE_H265_REF_PIC_SET_LIST_SIZE]; -} StdVideoDecodeH265PictureInfo; - -typedef struct StdVideoDecodeH265ReferenceInfoFlags { - uint32_t used_for_long_term_reference : 1; - uint32_t unused_for_reference : 1; -} StdVideoDecodeH265ReferenceInfoFlags; - -typedef struct StdVideoDecodeH265ReferenceInfo { - StdVideoDecodeH265ReferenceInfoFlags flags; - int32_t PicOrderCntVal; -} StdVideoDecodeH265ReferenceInfo; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_encode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_encode.h deleted file mode 100644 index e584a7262b9..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_h265std_encode.h +++ /dev/null @@ -1,157 +0,0 @@ -#ifndef VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ -#define VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codec_h265std_encode is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codec_h265std_encode 1 -#include "vulkan_video_codec_h265std.h" - -#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) - -#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_API_VERSION_1_0_0 -#define VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_h265_encode" -typedef struct StdVideoEncodeH265WeightTableFlags { - uint16_t luma_weight_l0_flag; - uint16_t chroma_weight_l0_flag; - uint16_t luma_weight_l1_flag; - uint16_t chroma_weight_l1_flag; -} StdVideoEncodeH265WeightTableFlags; - -typedef struct StdVideoEncodeH265WeightTable { - StdVideoEncodeH265WeightTableFlags flags; - uint8_t luma_log2_weight_denom; - int8_t delta_chroma_log2_weight_denom; - int8_t delta_luma_weight_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; - int8_t luma_offset_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; - int8_t delta_chroma_weight_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; - int8_t delta_chroma_offset_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; - int8_t delta_luma_weight_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; - int8_t luma_offset_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; - int8_t delta_chroma_weight_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; - int8_t delta_chroma_offset_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF][STD_VIDEO_H265_MAX_CHROMA_PLANES]; -} StdVideoEncodeH265WeightTable; - -typedef struct StdVideoEncodeH265SliceSegmentHeaderFlags { - uint32_t first_slice_segment_in_pic_flag : 1; - uint32_t dependent_slice_segment_flag : 1; - uint32_t slice_sao_luma_flag : 1; - uint32_t slice_sao_chroma_flag : 1; - uint32_t num_ref_idx_active_override_flag : 1; - uint32_t mvd_l1_zero_flag : 1; - uint32_t cabac_init_flag : 1; - uint32_t cu_chroma_qp_offset_enabled_flag : 1; - uint32_t deblocking_filter_override_flag : 1; - uint32_t slice_deblocking_filter_disabled_flag : 1; - uint32_t collocated_from_l0_flag : 1; - uint32_t slice_loop_filter_across_slices_enabled_flag : 1; - uint32_t reserved : 20; -} StdVideoEncodeH265SliceSegmentHeaderFlags; - -typedef struct StdVideoEncodeH265SliceSegmentHeader { - StdVideoEncodeH265SliceSegmentHeaderFlags flags; - StdVideoH265SliceType slice_type; - uint32_t slice_segment_address; - uint8_t collocated_ref_idx; - uint8_t MaxNumMergeCand; - int8_t slice_cb_qp_offset; - int8_t slice_cr_qp_offset; - int8_t slice_beta_offset_div2; - int8_t slice_tc_offset_div2; - int8_t slice_act_y_qp_offset; - int8_t slice_act_cb_qp_offset; - int8_t slice_act_cr_qp_offset; - int8_t slice_qp_delta; - uint16_t reserved1; - const StdVideoEncodeH265WeightTable* pWeightTable; -} StdVideoEncodeH265SliceSegmentHeader; - -typedef struct StdVideoEncodeH265ReferenceListsInfoFlags { - uint32_t ref_pic_list_modification_flag_l0 : 1; - uint32_t ref_pic_list_modification_flag_l1 : 1; - uint32_t reserved : 30; -} StdVideoEncodeH265ReferenceListsInfoFlags; - -typedef struct StdVideoEncodeH265ReferenceListsInfo { - StdVideoEncodeH265ReferenceListsInfoFlags flags; - uint8_t num_ref_idx_l0_active_minus1; - uint8_t num_ref_idx_l1_active_minus1; - uint8_t RefPicList0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; - uint8_t RefPicList1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; - uint8_t list_entry_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF]; - uint8_t list_entry_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF]; -} StdVideoEncodeH265ReferenceListsInfo; - -typedef struct StdVideoEncodeH265PictureInfoFlags { - uint32_t is_reference : 1; - uint32_t IrapPicFlag : 1; - uint32_t used_for_long_term_reference : 1; - uint32_t discardable_flag : 1; - uint32_t cross_layer_bla_flag : 1; - uint32_t pic_output_flag : 1; - uint32_t no_output_of_prior_pics_flag : 1; - uint32_t short_term_ref_pic_set_sps_flag : 1; - uint32_t slice_temporal_mvp_enabled_flag : 1; - uint32_t reserved : 23; -} StdVideoEncodeH265PictureInfoFlags; - -typedef struct StdVideoEncodeH265LongTermRefPics { - uint8_t num_long_term_sps; - uint8_t num_long_term_pics; - uint8_t lt_idx_sps[STD_VIDEO_H265_MAX_LONG_TERM_REF_PICS_SPS]; - uint8_t poc_lsb_lt[STD_VIDEO_H265_MAX_LONG_TERM_PICS]; - uint16_t used_by_curr_pic_lt_flag; - uint8_t delta_poc_msb_present_flag[STD_VIDEO_H265_MAX_DELTA_POC]; - uint8_t delta_poc_msb_cycle_lt[STD_VIDEO_H265_MAX_DELTA_POC]; -} StdVideoEncodeH265LongTermRefPics; - -typedef struct StdVideoEncodeH265PictureInfo { - StdVideoEncodeH265PictureInfoFlags flags; - StdVideoH265PictureType pic_type; - uint8_t sps_video_parameter_set_id; - uint8_t pps_seq_parameter_set_id; - uint8_t pps_pic_parameter_set_id; - uint8_t short_term_ref_pic_set_idx; - int32_t PicOrderCntVal; - uint8_t TemporalId; - uint8_t reserved1[7]; - const StdVideoEncodeH265ReferenceListsInfo* pRefLists; - const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; - const StdVideoEncodeH265LongTermRefPics* pLongTermRefPics; -} StdVideoEncodeH265PictureInfo; - -typedef struct StdVideoEncodeH265ReferenceInfoFlags { - uint32_t used_for_long_term_reference : 1; - uint32_t unused_for_reference : 1; - uint32_t reserved : 30; -} StdVideoEncodeH265ReferenceInfoFlags; - -typedef struct StdVideoEncodeH265ReferenceInfo { - StdVideoEncodeH265ReferenceInfoFlags flags; - StdVideoH265PictureType pic_type; - int32_t PicOrderCntVal; - uint8_t TemporalId; -} StdVideoEncodeH265ReferenceInfo; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std.h deleted file mode 100644 index 3c62f287e76..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std.h +++ /dev/null @@ -1,151 +0,0 @@ -#ifndef VULKAN_VIDEO_CODEC_VP9STD_H_ -#define VULKAN_VIDEO_CODEC_VP9STD_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codec_vp9std is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codec_vp9std 1 -#include "vulkan_video_codecs_common.h" -#define STD_VIDEO_VP9_NUM_REF_FRAMES 8U -#define STD_VIDEO_VP9_REFS_PER_FRAME 3U -#define STD_VIDEO_VP9_MAX_REF_FRAMES 4U -#define STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS 2U -#define STD_VIDEO_VP9_MAX_SEGMENTS 8U -#define STD_VIDEO_VP9_SEG_LVL_MAX 4U -#define STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS 7U -#define STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB 3U - -typedef enum StdVideoVP9Profile { - STD_VIDEO_VP9_PROFILE_0 = 0, - STD_VIDEO_VP9_PROFILE_1 = 1, - STD_VIDEO_VP9_PROFILE_2 = 2, - STD_VIDEO_VP9_PROFILE_3 = 3, - STD_VIDEO_VP9_PROFILE_INVALID = 0x7FFFFFFF, - STD_VIDEO_VP9_PROFILE_MAX_ENUM = 0x7FFFFFFF -} StdVideoVP9Profile; - -typedef enum StdVideoVP9Level { - STD_VIDEO_VP9_LEVEL_1_0 = 0, - STD_VIDEO_VP9_LEVEL_1_1 = 1, - STD_VIDEO_VP9_LEVEL_2_0 = 2, - STD_VIDEO_VP9_LEVEL_2_1 = 3, - STD_VIDEO_VP9_LEVEL_3_0 = 4, - STD_VIDEO_VP9_LEVEL_3_1 = 5, - STD_VIDEO_VP9_LEVEL_4_0 = 6, - STD_VIDEO_VP9_LEVEL_4_1 = 7, - STD_VIDEO_VP9_LEVEL_5_0 = 8, - STD_VIDEO_VP9_LEVEL_5_1 = 9, - STD_VIDEO_VP9_LEVEL_5_2 = 10, - STD_VIDEO_VP9_LEVEL_6_0 = 11, - STD_VIDEO_VP9_LEVEL_6_1 = 12, - STD_VIDEO_VP9_LEVEL_6_2 = 13, - STD_VIDEO_VP9_LEVEL_INVALID = 0x7FFFFFFF, - STD_VIDEO_VP9_LEVEL_MAX_ENUM = 0x7FFFFFFF -} StdVideoVP9Level; - -typedef enum StdVideoVP9FrameType { - STD_VIDEO_VP9_FRAME_TYPE_KEY = 0, - STD_VIDEO_VP9_FRAME_TYPE_NON_KEY = 1, - STD_VIDEO_VP9_FRAME_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_VP9_FRAME_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoVP9FrameType; - -typedef enum StdVideoVP9ReferenceName { - STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME = 0, - STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME = 1, - STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME = 2, - STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME = 3, - STD_VIDEO_VP9_REFERENCE_NAME_INVALID = 0x7FFFFFFF, - STD_VIDEO_VP9_REFERENCE_NAME_MAX_ENUM = 0x7FFFFFFF -} StdVideoVP9ReferenceName; - -typedef enum StdVideoVP9InterpolationFilter { - STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP = 0, - STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, - STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, - STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR = 3, - STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE = 4, - STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID = 0x7FFFFFFF, - STD_VIDEO_VP9_INTERPOLATION_FILTER_MAX_ENUM = 0x7FFFFFFF -} StdVideoVP9InterpolationFilter; - -typedef enum StdVideoVP9ColorSpace { - STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN = 0, - STD_VIDEO_VP9_COLOR_SPACE_BT_601 = 1, - STD_VIDEO_VP9_COLOR_SPACE_BT_709 = 2, - STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170 = 3, - STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240 = 4, - STD_VIDEO_VP9_COLOR_SPACE_BT_2020 = 5, - STD_VIDEO_VP9_COLOR_SPACE_RESERVED = 6, - STD_VIDEO_VP9_COLOR_SPACE_RGB = 7, - STD_VIDEO_VP9_COLOR_SPACE_INVALID = 0x7FFFFFFF, - STD_VIDEO_VP9_COLOR_SPACE_MAX_ENUM = 0x7FFFFFFF -} StdVideoVP9ColorSpace; -typedef struct StdVideoVP9ColorConfigFlags { - uint32_t color_range : 1; - uint32_t reserved : 31; -} StdVideoVP9ColorConfigFlags; - -typedef struct StdVideoVP9ColorConfig { - StdVideoVP9ColorConfigFlags flags; - uint8_t BitDepth; - uint8_t subsampling_x; - uint8_t subsampling_y; - uint8_t reserved1; - StdVideoVP9ColorSpace color_space; -} StdVideoVP9ColorConfig; - -typedef struct StdVideoVP9LoopFilterFlags { - uint32_t loop_filter_delta_enabled : 1; - uint32_t loop_filter_delta_update : 1; - uint32_t reserved : 30; -} StdVideoVP9LoopFilterFlags; - -typedef struct StdVideoVP9LoopFilter { - StdVideoVP9LoopFilterFlags flags; - uint8_t loop_filter_level; - uint8_t loop_filter_sharpness; - uint8_t update_ref_delta; - int8_t loop_filter_ref_deltas[STD_VIDEO_VP9_MAX_REF_FRAMES]; - uint8_t update_mode_delta; - int8_t loop_filter_mode_deltas[STD_VIDEO_VP9_LOOP_FILTER_ADJUSTMENTS]; -} StdVideoVP9LoopFilter; - -typedef struct StdVideoVP9SegmentationFlags { - uint32_t segmentation_update_map : 1; - uint32_t segmentation_temporal_update : 1; - uint32_t segmentation_update_data : 1; - uint32_t segmentation_abs_or_delta_update : 1; - uint32_t reserved : 28; -} StdVideoVP9SegmentationFlags; - -typedef struct StdVideoVP9Segmentation { - StdVideoVP9SegmentationFlags flags; - uint8_t segmentation_tree_probs[STD_VIDEO_VP9_MAX_SEGMENTATION_TREE_PROBS]; - uint8_t segmentation_pred_prob[STD_VIDEO_VP9_MAX_SEGMENTATION_PRED_PROB]; - uint8_t FeatureEnabled[STD_VIDEO_VP9_MAX_SEGMENTS]; - int16_t FeatureData[STD_VIDEO_VP9_MAX_SEGMENTS][STD_VIDEO_VP9_SEG_LVL_MAX]; -} StdVideoVP9Segmentation; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std_decode.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std_decode.h deleted file mode 100644 index ac7fa7be8c6..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codec_vp9std_decode.h +++ /dev/null @@ -1,68 +0,0 @@ -#ifndef VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ -#define VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codec_vp9std_decode is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codec_vp9std_decode 1 -#include "vulkan_video_codec_vp9std.h" - -#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0 VK_MAKE_VIDEO_STD_VERSION(1, 0, 0) - -#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_SPEC_VERSION VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_API_VERSION_1_0_0 -#define VK_STD_VULKAN_VIDEO_CODEC_VP9_DECODE_EXTENSION_NAME "VK_STD_vulkan_video_codec_vp9_decode" -typedef struct StdVideoDecodeVP9PictureInfoFlags { - uint32_t error_resilient_mode : 1; - uint32_t intra_only : 1; - uint32_t allow_high_precision_mv : 1; - uint32_t refresh_frame_context : 1; - uint32_t frame_parallel_decoding_mode : 1; - uint32_t segmentation_enabled : 1; - uint32_t show_frame : 1; - uint32_t UsePrevFrameMvs : 1; - uint32_t reserved : 24; -} StdVideoDecodeVP9PictureInfoFlags; - -typedef struct StdVideoDecodeVP9PictureInfo { - StdVideoDecodeVP9PictureInfoFlags flags; - StdVideoVP9Profile profile; - StdVideoVP9FrameType frame_type; - uint8_t frame_context_idx; - uint8_t reset_frame_context; - uint8_t refresh_frame_flags; - uint8_t ref_frame_sign_bias_mask; - StdVideoVP9InterpolationFilter interpolation_filter; - uint8_t base_q_idx; - int8_t delta_q_y_dc; - int8_t delta_q_uv_dc; - int8_t delta_q_uv_ac; - uint8_t tile_cols_log2; - uint8_t tile_rows_log2; - uint16_t reserved1[3]; - const StdVideoVP9ColorConfig* pColorConfig; - const StdVideoVP9LoopFilter* pLoopFilter; - const StdVideoVP9Segmentation* pSegmentation; -} StdVideoDecodeVP9PictureInfo; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vk_video/vulkan_video_codecs_common.h b/lib/vulkan-headers/include/vk_video/vulkan_video_codecs_common.h deleted file mode 100644 index 3c4d0553d08..00000000000 --- a/lib/vulkan-headers/include/vk_video/vulkan_video_codecs_common.h +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef VULKAN_VIDEO_CODECS_COMMON_H_ -#define VULKAN_VIDEO_CODECS_COMMON_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// vulkan_video_codecs_common is a preprocessor guard. Do not pass it to API calls. -#define vulkan_video_codecs_common 1 -#if !defined(VK_NO_STDINT_H) - #include -#endif - -#define VK_MAKE_VIDEO_STD_VERSION(major, minor, patch) \ - ((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch))) - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vk_icd.h b/lib/vulkan-headers/include/vulkan/vk_icd.h deleted file mode 100644 index d71f5682abb..00000000000 --- a/lib/vulkan-headers/include/vulkan/vk_icd.h +++ /dev/null @@ -1,245 +0,0 @@ -/* - * Copyright 2015-2023 The Khronos Group Inc. - * Copyright 2015-2023 Valve Corporation - * Copyright 2015-2023 LunarG, Inc. - * - * SPDX-License-Identifier: Apache-2.0 - */ -#pragma once - -#include "vulkan.h" -#include - -// Loader-ICD version negotiation API. Versions add the following features: -// Version 0 - Initial. Doesn't support vk_icdGetInstanceProcAddr -// or vk_icdNegotiateLoaderICDInterfaceVersion. -// Version 1 - Add support for vk_icdGetInstanceProcAddr. -// Version 2 - Add Loader/ICD Interface version negotiation -// via vk_icdNegotiateLoaderICDInterfaceVersion. -// Version 3 - Add ICD creation/destruction of KHR_surface objects. -// Version 4 - Add unknown physical device extension querying via -// vk_icdGetPhysicalDeviceProcAddr. -// Version 5 - Tells ICDs that the loader is now paying attention to the -// application version of Vulkan passed into the ApplicationInfo -// structure during vkCreateInstance. This will tell the ICD -// that if the loader is older, it should automatically fail a -// call for any API version > 1.0. Otherwise, the loader will -// manually determine if it can support the expected version. -// Version 6 - Add support for vk_icdEnumerateAdapterPhysicalDevices. -// Version 7 - If an ICD supports any of the following functions, they must be -// queryable with vk_icdGetInstanceProcAddr: -// vk_icdNegotiateLoaderICDInterfaceVersion -// vk_icdGetPhysicalDeviceProcAddr -// vk_icdEnumerateAdapterPhysicalDevices (Windows only) -// In addition, these functions no longer need to be exported directly. -// This version allows drivers provided through the extension -// VK_LUNARG_direct_driver_loading be able to support the entire -// Driver-Loader interface. - -#define CURRENT_LOADER_ICD_INTERFACE_VERSION 7 -#define MIN_SUPPORTED_LOADER_ICD_INTERFACE_VERSION 0 -#define MIN_PHYS_DEV_EXTENSION_ICD_INTERFACE_VERSION 4 - -// Old typedefs that don't follow a proper naming convention but are preserved for compatibility -typedef VkResult(VKAPI_PTR *PFN_vkNegotiateLoaderICDInterfaceVersion)(uint32_t *pVersion); -// This is defined in vk_layer.h which will be found by the loader, but if an ICD is building against this -// file directly, it won't be found. -#ifndef IS_DEFINED_PFN_GetPhysicalDeviceProcAddr -typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char *pName); -#define IS_DEFINED_PFN_GetPhysicalDeviceProcAddr -#endif - -// Typedefs for loader/ICD interface -typedef VkResult (VKAPI_PTR *PFN_vk_icdNegotiateLoaderICDInterfaceVersion)(uint32_t* pVersion); -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetInstanceProcAddr)(VkInstance instance, const char* pName); -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vk_icdGetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); -#if defined(VK_USE_PLATFORM_WIN32_KHR) -typedef VkResult (VKAPI_PTR *PFN_vk_icdEnumerateAdapterPhysicalDevices)(VkInstance instance, LUID adapterLUID, - uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); -#endif - -// Prototypes for loader/ICD interface -#if !defined(VK_NO_PROTOTYPES) -#ifdef __cplusplus -extern "C" { -#endif - VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pVersion); - VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName); - VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance instance, const char* pName); -#if defined(VK_USE_PLATFORM_WIN32_KHR) - VKAPI_ATTR VkResult VKAPI_CALL vk_icdEnumerateAdapterPhysicalDevices(VkInstance instance, LUID adapterLUID, - uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); -#endif -#ifdef __cplusplus -} -#endif -#endif - -/* - * The ICD must reserve space for a pointer for the loader's dispatch - * table, at the start of . - * The ICD must initialize this variable using the SET_LOADER_MAGIC_VALUE macro. - */ - -#define ICD_LOADER_MAGIC 0x01CDC0DE - -typedef union { - uintptr_t loaderMagic; - void *loaderData; -} VK_LOADER_DATA; - -static inline void set_loader_magic_value(void *pNewObject) { - VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; - loader_info->loaderMagic = ICD_LOADER_MAGIC; -} - -static inline bool valid_loader_magic_value(void *pNewObject) { - const VK_LOADER_DATA *loader_info = (VK_LOADER_DATA *)pNewObject; - return (loader_info->loaderMagic & 0xffffffff) == ICD_LOADER_MAGIC; -} - -/* - * Windows and Linux ICDs will treat VkSurfaceKHR as a pointer to a struct that - * contains the platform-specific connection and surface information. - */ -typedef enum { - VK_ICD_WSI_PLATFORM_MIR, - VK_ICD_WSI_PLATFORM_WAYLAND, - VK_ICD_WSI_PLATFORM_WIN32, - VK_ICD_WSI_PLATFORM_XCB, - VK_ICD_WSI_PLATFORM_XLIB, - VK_ICD_WSI_PLATFORM_ANDROID, - VK_ICD_WSI_PLATFORM_MACOS, - VK_ICD_WSI_PLATFORM_IOS, - VK_ICD_WSI_PLATFORM_DISPLAY, - VK_ICD_WSI_PLATFORM_HEADLESS, - VK_ICD_WSI_PLATFORM_METAL, - VK_ICD_WSI_PLATFORM_DIRECTFB, - VK_ICD_WSI_PLATFORM_VI, - VK_ICD_WSI_PLATFORM_GGP, - VK_ICD_WSI_PLATFORM_SCREEN, - VK_ICD_WSI_PLATFORM_FUCHSIA, -} VkIcdWsiPlatform; - -typedef struct { - VkIcdWsiPlatform platform; -} VkIcdSurfaceBase; - -#ifdef VK_USE_PLATFORM_MIR_KHR -typedef struct { - VkIcdSurfaceBase base; - MirConnection *connection; - MirSurface *mirSurface; -} VkIcdSurfaceMir; -#endif // VK_USE_PLATFORM_MIR_KHR - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR -typedef struct { - VkIcdSurfaceBase base; - struct wl_display *display; - struct wl_surface *surface; -} VkIcdSurfaceWayland; -#endif // VK_USE_PLATFORM_WAYLAND_KHR - -#ifdef VK_USE_PLATFORM_WIN32_KHR -typedef struct { - VkIcdSurfaceBase base; - HINSTANCE hinstance; - HWND hwnd; -} VkIcdSurfaceWin32; -#endif // VK_USE_PLATFORM_WIN32_KHR - -#ifdef VK_USE_PLATFORM_XCB_KHR -typedef struct { - VkIcdSurfaceBase base; - xcb_connection_t *connection; - xcb_window_t window; -} VkIcdSurfaceXcb; -#endif // VK_USE_PLATFORM_XCB_KHR - -#ifdef VK_USE_PLATFORM_XLIB_KHR -typedef struct { - VkIcdSurfaceBase base; - Display *dpy; - Window window; -} VkIcdSurfaceXlib; -#endif // VK_USE_PLATFORM_XLIB_KHR - -#ifdef VK_USE_PLATFORM_DIRECTFB_EXT -typedef struct { - VkIcdSurfaceBase base; - IDirectFB *dfb; - IDirectFBSurface *surface; -} VkIcdSurfaceDirectFB; -#endif // VK_USE_PLATFORM_DIRECTFB_EXT - -#ifdef VK_USE_PLATFORM_ANDROID_KHR -typedef struct { - VkIcdSurfaceBase base; - struct ANativeWindow *window; -} VkIcdSurfaceAndroid; -#endif // VK_USE_PLATFORM_ANDROID_KHR - -#ifdef VK_USE_PLATFORM_MACOS_MVK -typedef struct { - VkIcdSurfaceBase base; - const void *pView; -} VkIcdSurfaceMacOS; -#endif // VK_USE_PLATFORM_MACOS_MVK - -#ifdef VK_USE_PLATFORM_IOS_MVK -typedef struct { - VkIcdSurfaceBase base; - const void *pView; -} VkIcdSurfaceIOS; -#endif // VK_USE_PLATFORM_IOS_MVK - -#ifdef VK_USE_PLATFORM_GGP -typedef struct { - VkIcdSurfaceBase base; - GgpStreamDescriptor streamDescriptor; -} VkIcdSurfaceGgp; -#endif // VK_USE_PLATFORM_GGP - -typedef struct { - VkIcdSurfaceBase base; - VkDisplayModeKHR displayMode; - uint32_t planeIndex; - uint32_t planeStackIndex; - VkSurfaceTransformFlagBitsKHR transform; - float globalAlpha; - VkDisplayPlaneAlphaFlagBitsKHR alphaMode; - VkExtent2D imageExtent; -} VkIcdSurfaceDisplay; - -typedef struct { - VkIcdSurfaceBase base; -} VkIcdSurfaceHeadless; - -#ifdef VK_USE_PLATFORM_METAL_EXT -typedef struct { - VkIcdSurfaceBase base; - const CAMetalLayer *pLayer; -} VkIcdSurfaceMetal; -#endif // VK_USE_PLATFORM_METAL_EXT - -#ifdef VK_USE_PLATFORM_VI_NN -typedef struct { - VkIcdSurfaceBase base; - void *window; -} VkIcdSurfaceVi; -#endif // VK_USE_PLATFORM_VI_NN - -#ifdef VK_USE_PLATFORM_SCREEN_QNX -typedef struct { - VkIcdSurfaceBase base; - struct _screen_context *context; - struct _screen_window *window; -} VkIcdSurfaceScreen; -#endif // VK_USE_PLATFORM_SCREEN_QNX - -#ifdef VK_USE_PLATFORM_FUCHSIA -typedef struct { - VkIcdSurfaceBase base; -} VkIcdSurfaceImagePipe; -#endif // VK_USE_PLATFORM_FUCHSIA diff --git a/lib/vulkan-headers/include/vulkan/vk_layer.h b/lib/vulkan-headers/include/vulkan/vk_layer.h deleted file mode 100644 index 19cf5880c82..00000000000 --- a/lib/vulkan-headers/include/vulkan/vk_layer.h +++ /dev/null @@ -1,192 +0,0 @@ -/* - * Copyright 2015-2023 The Khronos Group Inc. - * Copyright 2015-2023 Valve Corporation - * Copyright 2015-2023 LunarG, Inc. - * - * SPDX-License-Identifier: Apache-2.0 - */ -#pragma once - -/* Need to define dispatch table - * Core struct can then have ptr to dispatch table at the top - * Along with object ptrs for current and next OBJ - */ - -#include "vulkan_core.h" - -#define MAX_NUM_UNKNOWN_EXTS 250 - - // Loader-Layer version negotiation API. Versions add the following features: - // Versions 0/1 - Initial. Doesn't support vk_layerGetPhysicalDeviceProcAddr - // or vk_icdNegotiateLoaderLayerInterfaceVersion. - // Version 2 - Add support for vk_layerGetPhysicalDeviceProcAddr and - // vk_icdNegotiateLoaderLayerInterfaceVersion. -#define CURRENT_LOADER_LAYER_INTERFACE_VERSION 2 -#define MIN_SUPPORTED_LOADER_LAYER_INTERFACE_VERSION 1 - -#define VK_CURRENT_CHAIN_VERSION 1 - -// Typedef for use in the interfaces below -#ifndef IS_DEFINED_PFN_GetPhysicalDeviceProcAddr -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_GetPhysicalDeviceProcAddr)(VkInstance instance, const char* pName); -#define IS_DEFINED_PFN_GetPhysicalDeviceProcAddr -#endif - -// Version negotiation values -typedef enum VkNegotiateLayerStructType { - LAYER_NEGOTIATE_UNINTIALIZED = 0, - LAYER_NEGOTIATE_INTERFACE_STRUCT = 1, -} VkNegotiateLayerStructType; - -// Version negotiation structures -typedef struct VkNegotiateLayerInterface { - VkNegotiateLayerStructType sType; - void *pNext; - uint32_t loaderLayerInterfaceVersion; - PFN_vkGetInstanceProcAddr pfnGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr pfnGetDeviceProcAddr; - PFN_GetPhysicalDeviceProcAddr pfnGetPhysicalDeviceProcAddr; -} VkNegotiateLayerInterface; - -// Version negotiation functions -typedef VkResult (VKAPI_PTR *PFN_vkNegotiateLoaderLayerInterfaceVersion)(VkNegotiateLayerInterface *pVersionStruct); - -// Function prototype for unknown physical device extension command -typedef VkResult(VKAPI_PTR *PFN_PhysDevExt)(VkPhysicalDevice phys_device); - -// ------------------------------------------------------------------------------------------------ -// CreateInstance and CreateDevice support structures - -/* Sub type of structure for instance and device loader ext of CreateInfo. - * When sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO - * or sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - * then VkLayerFunction indicates struct type pointed to by pNext - */ -typedef enum VkLayerFunction_ { - VK_LAYER_LINK_INFO = 0, - VK_LOADER_DATA_CALLBACK = 1, - VK_LOADER_LAYER_CREATE_DEVICE_CALLBACK = 2, - VK_LOADER_FEATURES = 3, -} VkLayerFunction; - -typedef struct VkLayerInstanceLink_ { - struct VkLayerInstanceLink_ *pNext; - PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; - PFN_GetPhysicalDeviceProcAddr pfnNextGetPhysicalDeviceProcAddr; -} VkLayerInstanceLink; - -/* - * When creating the device chain the loader needs to pass - * down information about it's device structure needed at - * the end of the chain. Passing the data via the - * VkLayerDeviceInfo avoids issues with finding the - * exact instance being used. - */ -typedef struct VkLayerDeviceInfo_ { - void *device_info; - PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; -} VkLayerDeviceInfo; - -typedef VkResult (VKAPI_PTR *PFN_vkSetInstanceLoaderData)(VkInstance instance, - void *object); -typedef VkResult (VKAPI_PTR *PFN_vkSetDeviceLoaderData)(VkDevice device, - void *object); -typedef VkResult (VKAPI_PTR *PFN_vkLayerCreateDevice)(VkInstance instance, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, - const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, PFN_vkGetInstanceProcAddr layerGIPA, PFN_vkGetDeviceProcAddr *nextGDPA); -typedef void (VKAPI_PTR *PFN_vkLayerDestroyDevice)(VkDevice physicalDevice, const VkAllocationCallbacks *pAllocator, PFN_vkDestroyDevice destroyFunction); - -typedef enum VkLoaderFeastureFlagBits { - VK_LOADER_FEATURE_PHYSICAL_DEVICE_SORTING = 0x00000001, -} VkLoaderFlagBits; -typedef VkFlags VkLoaderFeatureFlags; - -typedef struct { - VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO - const void *pNext; - VkLayerFunction function; - union { - VkLayerInstanceLink *pLayerInfo; - PFN_vkSetInstanceLoaderData pfnSetInstanceLoaderData; - struct { - PFN_vkLayerCreateDevice pfnLayerCreateDevice; - PFN_vkLayerDestroyDevice pfnLayerDestroyDevice; - } layerDevice; - VkLoaderFeatureFlags loaderFeatures; - } u; -} VkLayerInstanceCreateInfo; - -typedef struct VkLayerDeviceLink_ { - struct VkLayerDeviceLink_ *pNext; - PFN_vkGetInstanceProcAddr pfnNextGetInstanceProcAddr; - PFN_vkGetDeviceProcAddr pfnNextGetDeviceProcAddr; -} VkLayerDeviceLink; - -typedef struct { - VkStructureType sType; // VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - const void *pNext; - VkLayerFunction function; - union { - VkLayerDeviceLink *pLayerInfo; - PFN_vkSetDeviceLoaderData pfnSetDeviceLoaderData; - } u; -} VkLayerDeviceCreateInfo; - -#ifdef __cplusplus -extern "C" { -#endif - -VKAPI_ATTR VkResult VKAPI_CALL vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *pVersionStruct); - -typedef enum VkChainType { - VK_CHAIN_TYPE_UNKNOWN = 0, - VK_CHAIN_TYPE_ENUMERATE_INSTANCE_EXTENSION_PROPERTIES = 1, - VK_CHAIN_TYPE_ENUMERATE_INSTANCE_LAYER_PROPERTIES = 2, - VK_CHAIN_TYPE_ENUMERATE_INSTANCE_VERSION = 3, -} VkChainType; - -typedef struct VkChainHeader { - VkChainType type; - uint32_t version; - uint32_t size; -} VkChainHeader; - -typedef struct VkEnumerateInstanceExtensionPropertiesChain { - VkChainHeader header; - VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceExtensionPropertiesChain *, const char *, uint32_t *, - VkExtensionProperties *); - const struct VkEnumerateInstanceExtensionPropertiesChain *pNextLink; - -#if defined(__cplusplus) - inline VkResult CallDown(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) const { - return pfnNextLayer(pNextLink, pLayerName, pPropertyCount, pProperties); - } -#endif -} VkEnumerateInstanceExtensionPropertiesChain; - -typedef struct VkEnumerateInstanceLayerPropertiesChain { - VkChainHeader header; - VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceLayerPropertiesChain *, uint32_t *, VkLayerProperties *); - const struct VkEnumerateInstanceLayerPropertiesChain *pNextLink; - -#if defined(__cplusplus) - inline VkResult CallDown(uint32_t *pPropertyCount, VkLayerProperties *pProperties) const { - return pfnNextLayer(pNextLink, pPropertyCount, pProperties); - } -#endif -} VkEnumerateInstanceLayerPropertiesChain; - -typedef struct VkEnumerateInstanceVersionChain { - VkChainHeader header; - VkResult(VKAPI_PTR *pfnNextLayer)(const struct VkEnumerateInstanceVersionChain *, uint32_t *); - const struct VkEnumerateInstanceVersionChain *pNextLink; - -#if defined(__cplusplus) - inline VkResult CallDown(uint32_t *pApiVersion) const { - return pfnNextLayer(pNextLink, pApiVersion); - } -#endif -} VkEnumerateInstanceVersionChain; - -#ifdef __cplusplus -} -#endif diff --git a/lib/vulkan-headers/include/vulkan/vk_platform.h b/lib/vulkan-headers/include/vulkan/vk_platform.h deleted file mode 100644 index e431c7631db..00000000000 --- a/lib/vulkan-headers/include/vulkan/vk_platform.h +++ /dev/null @@ -1,84 +0,0 @@ -// -// File: vk_platform.h -// -/* -** Copyright 2014-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - - -#ifndef VK_PLATFORM_H_ -#define VK_PLATFORM_H_ - -#ifdef __cplusplus -extern "C" -{ -#endif // __cplusplus - -/* -*************************************************************************************************** -* Platform-specific directives and type declarations -*************************************************************************************************** -*/ - -/* Platform-specific calling convention macros. - * - * Platforms should define these so that Vulkan clients call Vulkan commands - * with the same calling conventions that the Vulkan implementation expects. - * - * VKAPI_ATTR - Placed before the return type in function declarations. - * Useful for C++11 and GCC/Clang-style function attribute syntax. - * VKAPI_CALL - Placed after the return type in function declarations. - * Useful for MSVC-style calling convention syntax. - * VKAPI_PTR - Placed between the '(' and '*' in function pointer types. - * - * Function declaration: VKAPI_ATTR void VKAPI_CALL vkCommand(void); - * Function pointer type: typedef void (VKAPI_PTR *PFN_vkCommand)(void); - */ -#if defined(_WIN32) - // On Windows, Vulkan commands use the stdcall convention - #define VKAPI_ATTR - #define VKAPI_CALL __stdcall - #define VKAPI_PTR VKAPI_CALL -#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7 - #error "Vulkan is not supported for the 'armeabi' NDK ABI" -#elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE) - // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat" - // calling convention, i.e. float parameters are passed in registers. This - // is true even if the rest of the application passes floats on the stack, - // as it does by default when compiling for the armeabi-v7a NDK ABI. - #define VKAPI_ATTR __attribute__((pcs("aapcs-vfp"))) - #define VKAPI_CALL - #define VKAPI_PTR VKAPI_ATTR -#else - // On other platforms, use the default calling convention - #define VKAPI_ATTR - #define VKAPI_CALL - #define VKAPI_PTR -#endif - -#if !defined(VK_NO_STDDEF_H) - #include -#endif // !defined(VK_NO_STDDEF_H) - -#if !defined(VK_NO_STDINT_H) - #if defined(_MSC_VER) && (_MSC_VER < 1600) - typedef signed __int8 int8_t; - typedef unsigned __int8 uint8_t; - typedef signed __int16 int16_t; - typedef unsigned __int16 uint16_t; - typedef signed __int32 int32_t; - typedef unsigned __int32 uint32_t; - typedef signed __int64 int64_t; - typedef unsigned __int64 uint64_t; - #else - #include - #endif -#endif // !defined(VK_NO_STDINT_H) - -#ifdef __cplusplus -} // extern "C" -#endif // __cplusplus - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan.cppm b/lib/vulkan-headers/include/vulkan/vulkan.cppm deleted file mode 100644 index 0daf44b5558..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan.cppm +++ /dev/null @@ -1,10847 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -module; - -#define VULKAN_HPP_CXX_MODULE 1 - -#include - -#if !defined( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) -# define VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING \ - "\n\tThe Vulkan-Hpp C++ named module is experimental. It is subject to change without prior notice.\n" \ - "\tTo silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n" \ - "\tFor feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues" - -VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) -#endif - -#include -#include -#include -#include -#include -#include - -export module vulkan; -export import :video; -export import std; - -export namespace VULKAN_HPP_NAMESPACE -{ - //===================================== - //=== HARDCODED TYPEs AND FUNCTIONs === - //===================================== - using VULKAN_HPP_NAMESPACE::ArrayWrapper1D; - using VULKAN_HPP_NAMESPACE::ArrayWrapper2D; - using VULKAN_HPP_NAMESPACE::Flags; - using VULKAN_HPP_NAMESPACE::FlagTraits; - - namespace detail - { - using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase; - using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic; -#if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 - using VULKAN_HPP_NAMESPACE::detail::defaultDispatchLoaderDynamic; -#endif -#if !defined( VK_NO_PROTOTYPES ) - using VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic; - using VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic; -#endif /*VK_NO_PROTOTYPES*/ - using VULKAN_HPP_NAMESPACE::detail::createResultValueType; - using VULKAN_HPP_NAMESPACE::detail::resultCheck; - } // namespace detail -#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - namespace VULKAN_HPP_RAII_NAMESPACE - { - using VULKAN_HPP_RAII_NAMESPACE::operator==; - using VULKAN_HPP_RAII_NAMESPACE::operator!=; -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - using VULKAN_HPP_RAII_NAMESPACE::operator<=>; -# else - using VULKAN_HPP_RAII_NAMESPACE::operator<; -# endif - } // namespace VULKAN_HPP_RAII_NAMESPACE -#endif - using VULKAN_HPP_NAMESPACE::operator&; - using VULKAN_HPP_NAMESPACE::operator|; - using VULKAN_HPP_NAMESPACE::operator^; - using VULKAN_HPP_NAMESPACE::operator~; - using VULKAN_HPP_NAMESPACE::operator<; - using VULKAN_HPP_NAMESPACE::operator<=; - 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; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) - namespace detail - { - using VULKAN_HPP_NAMESPACE::detail::ObjectDestroy; - using VULKAN_HPP_NAMESPACE::detail::ObjectDestroyShared; - using VULKAN_HPP_NAMESPACE::detail::ObjectFree; - using VULKAN_HPP_NAMESPACE::detail::ObjectFreeShared; - using VULKAN_HPP_NAMESPACE::detail::ObjectRelease; - using VULKAN_HPP_NAMESPACE::detail::ObjectReleaseShared; - using VULKAN_HPP_NAMESPACE::detail::PoolFree; - using VULKAN_HPP_NAMESPACE::detail::PoolFreeShared; - } // namespace detail - - using VULKAN_HPP_NAMESPACE::SharedHandle; - using VULKAN_HPP_NAMESPACE::UniqueHandle; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - using VULKAN_HPP_NAMESPACE::exchange; - - //================== - //=== 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::DeviceQueueCreateFlagBits; - using VULKAN_HPP_NAMESPACE::DeviceQueueCreateFlags; - 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::PipelineCacheCreateFlagBits; - using VULKAN_HPP_NAMESPACE::PipelineCacheCreateFlags; - using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersion; - using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlagBits; - using VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateFlags; - using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits; - using VULKAN_HPP_NAMESPACE::PipelineCreateFlags; - using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlagBits; - using VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateFlags; - using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlagBits; - using VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateFlags; - using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlagBits; - using VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateFlags; - using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlagBits; - using VULKAN_HPP_NAMESPACE::PipelineLayoutCreateFlags; - 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::CommandPoolTrimFlagsKHR; - using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlagBits; - using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlags; - using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateFlagsKHR; - using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateType; - using VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateTypeKHR; - using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBits; - using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlags; - using VULKAN_HPP_NAMESPACE::ExternalFenceFeatureFlagsKHR; - using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBits; - using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlags; - using VULKAN_HPP_NAMESPACE::ExternalFenceHandleTypeFlagsKHR; - using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBits; - using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlags; - using VULKAN_HPP_NAMESPACE::ExternalMemoryFeatureFlagsKHR; - using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBits; - using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlags; - using VULKAN_HPP_NAMESPACE::ExternalMemoryHandleTypeFlagsKHR; - using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagBits; - using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlags; - using VULKAN_HPP_NAMESPACE::ExternalSemaphoreFeatureFlagsKHR; - using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBits; - using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlags; - using VULKAN_HPP_NAMESPACE::ExternalSemaphoreHandleTypeFlagsKHR; - using VULKAN_HPP_NAMESPACE::FenceImportFlagBits; - using VULKAN_HPP_NAMESPACE::FenceImportFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::FenceImportFlags; - using VULKAN_HPP_NAMESPACE::FenceImportFlagsKHR; - using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagBits; - using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::MemoryAllocateFlags; - using VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsKHR; - using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagBits; - using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlags; - using VULKAN_HPP_NAMESPACE::PeerMemoryFeatureFlagsKHR; - 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::SemaphoreImportFlagsKHR; - 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::DescriptorBindingFlagsEXT; - 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::ResolveModeFlagsKHR; - 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::SemaphoreWaitFlagsKHR; - 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::AccessFlags2KHR; - using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits2; - using VULKAN_HPP_NAMESPACE::FormatFeatureFlagBits2KHR; - using VULKAN_HPP_NAMESPACE::FormatFeatureFlags2; - using VULKAN_HPP_NAMESPACE::FormatFeatureFlags2KHR; - using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagBits; - using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlags; - using VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackFlagsEXT; - using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits2; - using VULKAN_HPP_NAMESPACE::PipelineStageFlagBits2KHR; - using VULKAN_HPP_NAMESPACE::PipelineStageFlags2; - using VULKAN_HPP_NAMESPACE::PipelineStageFlags2KHR; - using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagBits; - using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlags; - using VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateFlagsEXT; - using VULKAN_HPP_NAMESPACE::RenderingFlagBits; - using VULKAN_HPP_NAMESPACE::RenderingFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::RenderingFlags; - using VULKAN_HPP_NAMESPACE::RenderingFlagsKHR; - using VULKAN_HPP_NAMESPACE::SubmitFlagBits; - using VULKAN_HPP_NAMESPACE::SubmitFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::SubmitFlags; - using VULKAN_HPP_NAMESPACE::SubmitFlagsKHR; - using VULKAN_HPP_NAMESPACE::ToolPurposeFlagBits; - using VULKAN_HPP_NAMESPACE::ToolPurposeFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::ToolPurposeFlags; - using VULKAN_HPP_NAMESPACE::ToolPurposeFlagsEXT; - - //=== VK_VERSION_1_4 === - using VULKAN_HPP_NAMESPACE::BufferUsageFlagBits2; - using VULKAN_HPP_NAMESPACE::BufferUsageFlagBits2KHR; - using VULKAN_HPP_NAMESPACE::BufferUsageFlags2; - using VULKAN_HPP_NAMESPACE::BufferUsageFlags2KHR; - using VULKAN_HPP_NAMESPACE::HostImageCopyFlagBits; - using VULKAN_HPP_NAMESPACE::HostImageCopyFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::HostImageCopyFlags; - using VULKAN_HPP_NAMESPACE::HostImageCopyFlagsEXT; - using VULKAN_HPP_NAMESPACE::LineRasterizationMode; - using VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT; - using VULKAN_HPP_NAMESPACE::LineRasterizationModeKHR; - using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagBits; - using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::MemoryUnmapFlags; - using VULKAN_HPP_NAMESPACE::MemoryUnmapFlagsKHR; - using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits2; - using VULKAN_HPP_NAMESPACE::PipelineCreateFlagBits2KHR; - using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2; - using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2KHR; - using VULKAN_HPP_NAMESPACE::PipelineRobustnessBufferBehavior; - using VULKAN_HPP_NAMESPACE::PipelineRobustnessBufferBehaviorEXT; - using VULKAN_HPP_NAMESPACE::PipelineRobustnessImageBehavior; - using VULKAN_HPP_NAMESPACE::PipelineRobustnessImageBehaviorEXT; - using VULKAN_HPP_NAMESPACE::QueueGlobalPriority; - using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityEXT; - using VULKAN_HPP_NAMESPACE::QueueGlobalPriorityKHR; - - //=== 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; - - //=== VK_KHR_video_encode_h264 === - using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilityFlagsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlFlagsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264StdFlagsKHR; - - //=== VK_KHR_video_encode_h265 === - using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilityFlagsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265CtbSizeFlagsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlFlagsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265StdFlagsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265TransformBlockSizeFlagsKHR; - - //=== 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_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_descriptor_heap === - using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceEXT; - using VULKAN_HPP_NAMESPACE::SpirvResourceTypeFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::SpirvResourceTypeFlagsEXT; - using VULKAN_HPP_NAMESPACE::TensorViewCreateFlagBitsARM; - using VULKAN_HPP_NAMESPACE::TensorViewCreateFlagsARM; - - //=== 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::BuildAccelerationStructureFlagsNV; - 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::GeometryFlagsNV; - using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagBitsNV; - using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagsKHR; - using VULKAN_HPP_NAMESPACE::GeometryInstanceFlagsNV; - 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_AMD_memory_overallocation_behavior === - using VULKAN_HPP_NAMESPACE::MemoryOverallocationBehaviorAMD; - - //=== VK_EXT_present_timing === - using VULKAN_HPP_NAMESPACE::PastPresentationTimingFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::PastPresentationTimingFlagsEXT; - using VULKAN_HPP_NAMESPACE::PresentStageFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::PresentStageFlagsEXT; - using VULKAN_HPP_NAMESPACE::PresentTimingInfoFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::PresentTimingInfoFlagsEXT; - - //=== 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_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_KHR_pipeline_executable_properties === - using VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticFormatKHR; - - //=== 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_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; - - //=== VK_NV_device_diagnostics_config === - using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagBitsNV; - using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV; - - //=== VK_QCOM_tile_shading === - using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagBitsQCOM; - using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagsQCOM; - -#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; - - //=== 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*/ - - //=== VK_EXT_frame_boundary === - using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::FrameBoundaryFlagsEXT; - -#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_VALVE_video_encode_rgb_conversion === - using VULKAN_HPP_NAMESPACE::VideoEncodeRgbChromaOffsetFlagBitsVALVE; - using VULKAN_HPP_NAMESPACE::VideoEncodeRgbChromaOffsetFlagsVALVE; - using VULKAN_HPP_NAMESPACE::VideoEncodeRgbModelConversionFlagBitsVALVE; - using VULKAN_HPP_NAMESPACE::VideoEncodeRgbModelConversionFlagsVALVE; - using VULKAN_HPP_NAMESPACE::VideoEncodeRgbRangeCompressionFlagBitsVALVE; - using VULKAN_HPP_NAMESPACE::VideoEncodeRgbRangeCompressionFlagsVALVE; - - //=== 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_ARM_scheduling_controls === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFlagBitsARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFlagsARM; - - //=== VK_NV_ray_tracing_linear_swept_spheres === - using VULKAN_HPP_NAMESPACE::RayTracingLssIndexingModeNV; - using VULKAN_HPP_NAMESPACE::RayTracingLssPrimitiveEndCapsModeNV; - - //=== 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_ARM_tensors === - using VULKAN_HPP_NAMESPACE::TensorCreateFlagBitsARM; - using VULKAN_HPP_NAMESPACE::TensorCreateFlagsARM; - using VULKAN_HPP_NAMESPACE::TensorTilingARM; - using VULKAN_HPP_NAMESPACE::TensorUsageFlagBitsARM; - using VULKAN_HPP_NAMESPACE::TensorUsageFlagsARM; - - //=== 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_AMD_anti_lag === - using VULKAN_HPP_NAMESPACE::AntiLagModeAMD; - using VULKAN_HPP_NAMESPACE::AntiLagStageAMD; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_dense_geometry_format === - using VULKAN_HPP_NAMESPACE::CompressedTriangleFormatAMDX; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_shader_object === - using VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT; - using VULKAN_HPP_NAMESPACE::ShaderCreateFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::ShaderCreateFlagsEXT; - - //=== VK_KHR_surface_maintenance1 === - using VULKAN_HPP_NAMESPACE::PresentGravityFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::PresentGravityFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::PresentGravityFlagsEXT; - using VULKAN_HPP_NAMESPACE::PresentGravityFlagsKHR; - using VULKAN_HPP_NAMESPACE::PresentScalingFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::PresentScalingFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::PresentScalingFlagsEXT; - using VULKAN_HPP_NAMESPACE::PresentScalingFlagsKHR; - - //=== VK_NV_cooperative_vector === - using VULKAN_HPP_NAMESPACE::ComponentTypeKHR; - using VULKAN_HPP_NAMESPACE::ComponentTypeNV; - using VULKAN_HPP_NAMESPACE::CooperativeVectorMatrixLayoutNV; - - //=== VK_EXT_layer_settings === - using VULKAN_HPP_NAMESPACE::LayerSettingTypeEXT; - - //=== VK_NV_low_latency2 === - using VULKAN_HPP_NAMESPACE::LatencyMarkerNV; - using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeNV; - - //=== VK_KHR_cooperative_matrix === - using VULKAN_HPP_NAMESPACE::ScopeKHR; - using VULKAN_HPP_NAMESPACE::ScopeNV; - - //=== VK_ARM_data_graph === - using VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchFlagBitsARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchFlagsARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointTypeARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateFlagBitsARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateFlagsARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationTypeARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineTypeARM; - - //=== VK_KHR_video_encode_av1 === - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilityFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilityFlagsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1PredictionModeKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlFlagsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlGroupKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1StdFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1StdFlagsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SuperblockSizeFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SuperblockSizeFlagsKHR; - - //=== VK_QCOM_image_processing2 === - using VULKAN_HPP_NAMESPACE::BlockMatchWindowCompareModeQCOM; - - //=== VK_QCOM_filter_cubic_weights === - using VULKAN_HPP_NAMESPACE::CubicFilterWeightsQCOM; - - //=== VK_MSFT_layered_driver === - using VULKAN_HPP_NAMESPACE::LayeredDriverUnderlyingApiMSFT; - - //=== VK_KHR_calibrated_timestamps === - using VULKAN_HPP_NAMESPACE::TimeDomainEXT; - using VULKAN_HPP_NAMESPACE::TimeDomainKHR; - - //=== VK_KHR_copy_memory_indirect === - using VULKAN_HPP_NAMESPACE::AddressCopyFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::AddressCopyFlagsKHR; - - //=== VK_EXT_memory_decompression === - using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagBitsNV; - using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagsEXT; - using VULKAN_HPP_NAMESPACE::MemoryDecompressionMethodFlagsNV; - - //=== VK_NV_display_stereo === - using VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoTypeNV; - - //=== VK_KHR_video_encode_intra_refresh === - using VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshModeFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshModeFlagsKHR; - - //=== VK_KHR_maintenance7 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiKHR; - - //=== VK_NV_cluster_acceleration_structure === - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureAddressResolutionFlagBitsNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureAddressResolutionFlagsNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClusterFlagBitsNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClusterFlagsNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryFlagBitsNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryFlagsNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureIndexFormatFlagBitsNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureIndexFormatFlagsNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpModeNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpTypeNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTypeNV; - - //=== VK_NV_partitioned_acceleration_structure === - using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstanceFlagBitsNV; - using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstanceFlagsNV; - using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureOpTypeNV; - - //=== VK_EXT_device_generated_commands === - using VULKAN_HPP_NAMESPACE::IndirectCommandsInputModeFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsInputModeFlagsEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagBitsEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutUsageFlagsEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsTokenTypeEXT; - using VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoTypeEXT; - - //=== VK_KHR_maintenance8 === - using VULKAN_HPP_NAMESPACE::AccessFlagBits3KHR; - using VULKAN_HPP_NAMESPACE::AccessFlags3KHR; - - //=== VK_EXT_ray_tracing_invocation_reorder === - using VULKAN_HPP_NAMESPACE::RayTracingInvocationReorderModeEXT; - using VULKAN_HPP_NAMESPACE::RayTracingInvocationReorderModeNV; - - //=== VK_EXT_depth_clamp_control === - using VULKAN_HPP_NAMESPACE::DepthClampModeEXT; - - //=== VK_KHR_maintenance9 === - using VULKAN_HPP_NAMESPACE::DefaultVertexAttributeValueKHR; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - using VULKAN_HPP_NAMESPACE::SurfaceCreateFlagBitsOHOS; - using VULKAN_HPP_NAMESPACE::SurfaceCreateFlagsOHOS; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_ARM_performance_counters_by_region === - using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagBitsARM; - using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionFlagsARM; - - //=== VK_QCOM_data_graph_model === - using VULKAN_HPP_NAMESPACE::DataGraphModelCacheTypeQCOM; - - //=== VK_KHR_maintenance10 === - using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsKHR; - using VULKAN_HPP_NAMESPACE::ResolveImageFlagBitsKHR; - using VULKAN_HPP_NAMESPACE::ResolveImageFlagsKHR; - - //========================= - //=== 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::NotPermittedError; - using VULKAN_HPP_NAMESPACE::OutOfDateKHRError; - using VULKAN_HPP_NAMESPACE::OutOfDeviceMemoryError; - using VULKAN_HPP_NAMESPACE::OutOfHostMemoryError; - using VULKAN_HPP_NAMESPACE::OutOfPoolMemoryError; - using VULKAN_HPP_NAMESPACE::PresentTimingQueueFullEXTError; - using VULKAN_HPP_NAMESPACE::SurfaceLostKHRError; - using VULKAN_HPP_NAMESPACE::SystemError; - using VULKAN_HPP_NAMESPACE::TooManyObjectsError; - using VULKAN_HPP_NAMESPACE::UnknownError; - using VULKAN_HPP_NAMESPACE::ValidationFailedError; - 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*/ - - using VULKAN_HPP_NAMESPACE::CompressionExhaustedEXTError; - using VULKAN_HPP_NAMESPACE::InvalidVideoStdParametersKHRError; - using VULKAN_HPP_NAMESPACE::NotEnoughSpaceKHRError; -#endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - using VULKAN_HPP_NAMESPACE::ResultValue; - using VULKAN_HPP_NAMESPACE::ResultValueType; - - //=========================== - //=== CONSTEXPR CONSTANTs === - //=========================== - - //=== VK_VERSION_1_0 === - using VULKAN_HPP_NAMESPACE::AttachmentUnused; - using VULKAN_HPP_NAMESPACE::False; - using VULKAN_HPP_NAMESPACE::LodClampNone; - using VULKAN_HPP_NAMESPACE::MaxDescriptionSize; - using VULKAN_HPP_NAMESPACE::MaxExtensionNameSize; - using VULKAN_HPP_NAMESPACE::MaxMemoryHeaps; - using VULKAN_HPP_NAMESPACE::MaxMemoryTypes; - using VULKAN_HPP_NAMESPACE::MaxPhysicalDeviceNameSize; - using VULKAN_HPP_NAMESPACE::QueueFamilyIgnored; - using VULKAN_HPP_NAMESPACE::RemainingArrayLayers; - using VULKAN_HPP_NAMESPACE::RemainingMipLevels; - using VULKAN_HPP_NAMESPACE::SubpassExternal; - using VULKAN_HPP_NAMESPACE::True; - using VULKAN_HPP_NAMESPACE::UuidSize; - using VULKAN_HPP_NAMESPACE::WholeSize; - - //=== VK_VERSION_1_1 === - using VULKAN_HPP_NAMESPACE::LuidSize; - using VULKAN_HPP_NAMESPACE::MaxDeviceGroupSize; - using VULKAN_HPP_NAMESPACE::QueueFamilyExternal; - - //=== VK_VERSION_1_2 === - using VULKAN_HPP_NAMESPACE::MaxDriverInfoSize; - using VULKAN_HPP_NAMESPACE::MaxDriverNameSize; - - //=== VK_VERSION_1_4 === - using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySize; - - //=== VK_KHR_surface === - using VULKAN_HPP_NAMESPACE::KHRSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSurfaceSpecVersion; - - //=== VK_KHR_swapchain === - using VULKAN_HPP_NAMESPACE::KHRSwapchainExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSwapchainSpecVersion; - - //=== VK_KHR_display === - using VULKAN_HPP_NAMESPACE::KHRDisplayExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDisplaySpecVersion; - - //=== VK_KHR_display_swapchain === - using VULKAN_HPP_NAMESPACE::KHRDisplaySwapchainExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDisplaySwapchainSpecVersion; - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - using VULKAN_HPP_NAMESPACE::KHRXlibSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::KHRXlibSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - using VULKAN_HPP_NAMESPACE::KHRXcbSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::KHRXcbSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - using VULKAN_HPP_NAMESPACE::KHRWaylandSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::KHRWaylandSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - using VULKAN_HPP_NAMESPACE::KHRAndroidSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::KHRAndroidSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - using VULKAN_HPP_NAMESPACE::KHRWin32SurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::KHRWin32SurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - using VULKAN_HPP_NAMESPACE::EXTDebugReportExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDebugReportSpecVersion; - - //=== VK_NV_glsl_shader === - using VULKAN_HPP_NAMESPACE::NVGlslShaderExtensionName; - using VULKAN_HPP_NAMESPACE::NVGlslShaderSpecVersion; - - //=== VK_EXT_depth_range_unrestricted === - using VULKAN_HPP_NAMESPACE::EXTDepthRangeUnrestrictedExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDepthRangeUnrestrictedSpecVersion; - - //=== VK_KHR_sampler_mirror_clamp_to_edge === - using VULKAN_HPP_NAMESPACE::KHRSamplerMirrorClampToEdgeExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSamplerMirrorClampToEdgeSpecVersion; - - //=== VK_IMG_filter_cubic === - using VULKAN_HPP_NAMESPACE::IMGFilterCubicExtensionName; - using VULKAN_HPP_NAMESPACE::IMGFilterCubicSpecVersion; - - //=== VK_AMD_rasterization_order === - using VULKAN_HPP_NAMESPACE::AMDRasterizationOrderExtensionName; - using VULKAN_HPP_NAMESPACE::AMDRasterizationOrderSpecVersion; - - //=== VK_AMD_shader_trinary_minmax === - using VULKAN_HPP_NAMESPACE::AMDShaderTrinaryMinmaxExtensionName; - using VULKAN_HPP_NAMESPACE::AMDShaderTrinaryMinmaxSpecVersion; - - //=== VK_AMD_shader_explicit_vertex_parameter === - using VULKAN_HPP_NAMESPACE::AMDShaderExplicitVertexParameterExtensionName; - using VULKAN_HPP_NAMESPACE::AMDShaderExplicitVertexParameterSpecVersion; - - //=== VK_EXT_debug_marker === - using VULKAN_HPP_NAMESPACE::EXTDebugMarkerExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDebugMarkerSpecVersion; - - //=== VK_KHR_video_queue === - using VULKAN_HPP_NAMESPACE::KHRVideoQueueExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoQueueSpecVersion; - - //=== VK_KHR_video_decode_queue === - using VULKAN_HPP_NAMESPACE::KHRVideoDecodeQueueExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoDecodeQueueSpecVersion; - - //=== VK_AMD_gcn_shader === - using VULKAN_HPP_NAMESPACE::AMDGcnShaderExtensionName; - using VULKAN_HPP_NAMESPACE::AMDGcnShaderSpecVersion; - - //=== VK_NV_dedicated_allocation === - using VULKAN_HPP_NAMESPACE::NVDedicatedAllocationExtensionName; - using VULKAN_HPP_NAMESPACE::NVDedicatedAllocationSpecVersion; - - //=== VK_EXT_transform_feedback === - using VULKAN_HPP_NAMESPACE::EXTTransformFeedbackExtensionName; - using VULKAN_HPP_NAMESPACE::EXTTransformFeedbackSpecVersion; - - //=== VK_NVX_binary_import === - using VULKAN_HPP_NAMESPACE::NVXBinaryImportExtensionName; - using VULKAN_HPP_NAMESPACE::NVXBinaryImportSpecVersion; - - //=== VK_NVX_image_view_handle === - using VULKAN_HPP_NAMESPACE::NVXImageViewHandleExtensionName; - using VULKAN_HPP_NAMESPACE::NVXImageViewHandleSpecVersion; - - //=== VK_AMD_draw_indirect_count === - using VULKAN_HPP_NAMESPACE::AMDDrawIndirectCountExtensionName; - using VULKAN_HPP_NAMESPACE::AMDDrawIndirectCountSpecVersion; - - //=== VK_AMD_negative_viewport_height === - using VULKAN_HPP_NAMESPACE::AMDNegativeViewportHeightExtensionName; - using VULKAN_HPP_NAMESPACE::AMDNegativeViewportHeightSpecVersion; - - //=== VK_AMD_gpu_shader_half_float === - using VULKAN_HPP_NAMESPACE::AMDGpuShaderHalfFloatExtensionName; - using VULKAN_HPP_NAMESPACE::AMDGpuShaderHalfFloatSpecVersion; - - //=== VK_AMD_shader_ballot === - using VULKAN_HPP_NAMESPACE::AMDShaderBallotExtensionName; - using VULKAN_HPP_NAMESPACE::AMDShaderBallotSpecVersion; - - //=== VK_KHR_video_encode_h264 === - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeH264ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeH264SpecVersion; - - //=== VK_KHR_video_encode_h265 === - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeH265ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeH265SpecVersion; - - //=== VK_KHR_video_decode_h264 === - using VULKAN_HPP_NAMESPACE::KHRVideoDecodeH264ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoDecodeH264SpecVersion; - - //=== VK_AMD_texture_gather_bias_lod === - using VULKAN_HPP_NAMESPACE::AMDTextureGatherBiasLodExtensionName; - using VULKAN_HPP_NAMESPACE::AMDTextureGatherBiasLodSpecVersion; - - //=== VK_AMD_shader_info === - using VULKAN_HPP_NAMESPACE::AMDShaderInfoExtensionName; - using VULKAN_HPP_NAMESPACE::AMDShaderInfoSpecVersion; - - //=== VK_KHR_dynamic_rendering === - using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingSpecVersion; - - //=== VK_AMD_shader_image_load_store_lod === - using VULKAN_HPP_NAMESPACE::AMDShaderImageLoadStoreLodExtensionName; - using VULKAN_HPP_NAMESPACE::AMDShaderImageLoadStoreLodSpecVersion; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - using VULKAN_HPP_NAMESPACE::GGPStreamDescriptorSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::GGPStreamDescriptorSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_corner_sampled_image === - using VULKAN_HPP_NAMESPACE::NVCornerSampledImageExtensionName; - using VULKAN_HPP_NAMESPACE::NVCornerSampledImageSpecVersion; - - //=== VK_KHR_multiview === - using VULKAN_HPP_NAMESPACE::KHRMultiviewExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMultiviewSpecVersion; - - //=== VK_IMG_format_pvrtc === - using VULKAN_HPP_NAMESPACE::IMGFormatPvrtcExtensionName; - using VULKAN_HPP_NAMESPACE::IMGFormatPvrtcSpecVersion; - - //=== VK_NV_external_memory_capabilities === - using VULKAN_HPP_NAMESPACE::NVExternalMemoryCapabilitiesExtensionName; - using VULKAN_HPP_NAMESPACE::NVExternalMemoryCapabilitiesSpecVersion; - - //=== VK_NV_external_memory === - using VULKAN_HPP_NAMESPACE::NVExternalMemoryExtensionName; - using VULKAN_HPP_NAMESPACE::NVExternalMemorySpecVersion; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - using VULKAN_HPP_NAMESPACE::NVExternalMemoryWin32ExtensionName; - using VULKAN_HPP_NAMESPACE::NVExternalMemoryWin32SpecVersion; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_win32_keyed_mutex === - using VULKAN_HPP_NAMESPACE::NVWin32KeyedMutexExtensionName; - using VULKAN_HPP_NAMESPACE::NVWin32KeyedMutexSpecVersion; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_get_physical_device_properties2 === - using VULKAN_HPP_NAMESPACE::KHRGetPhysicalDeviceProperties2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRGetPhysicalDeviceProperties2SpecVersion; - - //=== VK_KHR_device_group === - using VULKAN_HPP_NAMESPACE::KHRDeviceGroupExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDeviceGroupSpecVersion; - - //=== VK_EXT_validation_flags === - using VULKAN_HPP_NAMESPACE::EXTValidationFlagsExtensionName; - using VULKAN_HPP_NAMESPACE::EXTValidationFlagsSpecVersion; - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - using VULKAN_HPP_NAMESPACE::NNViSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::NNViSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_shader_draw_parameters === - using VULKAN_HPP_NAMESPACE::KHRShaderDrawParametersExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderDrawParametersSpecVersion; - - //=== VK_EXT_shader_subgroup_ballot === - using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupBallotExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupBallotSpecVersion; - - //=== VK_EXT_shader_subgroup_vote === - using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupVoteExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupVoteSpecVersion; - - //=== VK_EXT_texture_compression_astc_hdr === - using VULKAN_HPP_NAMESPACE::EXTTextureCompressionAstcHdrExtensionName; - using VULKAN_HPP_NAMESPACE::EXTTextureCompressionAstcHdrSpecVersion; - - //=== VK_EXT_astc_decode_mode === - using VULKAN_HPP_NAMESPACE::EXTAstcDecodeModeExtensionName; - using VULKAN_HPP_NAMESPACE::EXTAstcDecodeModeSpecVersion; - - //=== VK_EXT_pipeline_robustness === - using VULKAN_HPP_NAMESPACE::EXTPipelineRobustnessExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPipelineRobustnessSpecVersion; - - //=== VK_KHR_maintenance1 === - using VULKAN_HPP_NAMESPACE::KHRMaintenance1ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMaintenance1SpecVersion; - - //=== VK_KHR_device_group_creation === - using VULKAN_HPP_NAMESPACE::KHRDeviceGroupCreationExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDeviceGroupCreationSpecVersion; - using VULKAN_HPP_NAMESPACE::MaxDeviceGroupSizeKHR; - - //=== VK_KHR_external_memory_capabilities === - using VULKAN_HPP_NAMESPACE::KHRExternalMemoryCapabilitiesExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalMemoryCapabilitiesSpecVersion; - using VULKAN_HPP_NAMESPACE::LuidSizeKHR; - - //=== VK_KHR_external_memory === - using VULKAN_HPP_NAMESPACE::KHRExternalMemoryExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalMemorySpecVersion; - using VULKAN_HPP_NAMESPACE::QueueFamilyExternalKHR; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - using VULKAN_HPP_NAMESPACE::KHRExternalMemoryWin32ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalMemoryWin32SpecVersion; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - using VULKAN_HPP_NAMESPACE::KHRExternalMemoryFdExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalMemoryFdSpecVersion; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_keyed_mutex === - using VULKAN_HPP_NAMESPACE::KHRWin32KeyedMutexExtensionName; - using VULKAN_HPP_NAMESPACE::KHRWin32KeyedMutexSpecVersion; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_capabilities === - using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreCapabilitiesExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreCapabilitiesSpecVersion; - - //=== VK_KHR_external_semaphore === - using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreSpecVersion; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreWin32ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreWin32SpecVersion; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreFdExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalSemaphoreFdSpecVersion; - - //=== VK_KHR_push_descriptor === - using VULKAN_HPP_NAMESPACE::KHRPushDescriptorExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPushDescriptorSpecVersion; - - //=== VK_EXT_conditional_rendering === - using VULKAN_HPP_NAMESPACE::EXTConditionalRenderingExtensionName; - using VULKAN_HPP_NAMESPACE::EXTConditionalRenderingSpecVersion; - - //=== VK_KHR_shader_float16_int8 === - using VULKAN_HPP_NAMESPACE::KHRShaderFloat16Int8ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderFloat16Int8SpecVersion; - - //=== VK_KHR_16bit_storage === - using VULKAN_HPP_NAMESPACE::KHR16BitStorageExtensionName; - using VULKAN_HPP_NAMESPACE::KHR16BitStorageSpecVersion; - - //=== VK_KHR_incremental_present === - using VULKAN_HPP_NAMESPACE::KHRIncrementalPresentExtensionName; - using VULKAN_HPP_NAMESPACE::KHRIncrementalPresentSpecVersion; - - //=== VK_KHR_descriptor_update_template === - using VULKAN_HPP_NAMESPACE::KHRDescriptorUpdateTemplateExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDescriptorUpdateTemplateSpecVersion; - - //=== VK_NV_clip_space_w_scaling === - using VULKAN_HPP_NAMESPACE::NVClipSpaceWScalingExtensionName; - using VULKAN_HPP_NAMESPACE::NVClipSpaceWScalingSpecVersion; - - //=== VK_EXT_direct_mode_display === - using VULKAN_HPP_NAMESPACE::EXTDirectModeDisplayExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDirectModeDisplaySpecVersion; - -#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - using VULKAN_HPP_NAMESPACE::EXTAcquireXlibDisplayExtensionName; - using VULKAN_HPP_NAMESPACE::EXTAcquireXlibDisplaySpecVersion; -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - using VULKAN_HPP_NAMESPACE::EXTDisplaySurfaceCounterExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDisplaySurfaceCounterSpecVersion; - - //=== VK_EXT_display_control === - using VULKAN_HPP_NAMESPACE::EXTDisplayControlExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDisplayControlSpecVersion; - - //=== VK_GOOGLE_display_timing === - using VULKAN_HPP_NAMESPACE::GOOGLEDisplayTimingExtensionName; - using VULKAN_HPP_NAMESPACE::GOOGLEDisplayTimingSpecVersion; - - //=== VK_NV_sample_mask_override_coverage === - using VULKAN_HPP_NAMESPACE::NVSampleMaskOverrideCoverageExtensionName; - using VULKAN_HPP_NAMESPACE::NVSampleMaskOverrideCoverageSpecVersion; - - //=== VK_NV_geometry_shader_passthrough === - using VULKAN_HPP_NAMESPACE::NVGeometryShaderPassthroughExtensionName; - using VULKAN_HPP_NAMESPACE::NVGeometryShaderPassthroughSpecVersion; - - //=== VK_NV_viewport_array2 === - using VULKAN_HPP_NAMESPACE::NVViewportArray2ExtensionName; - using VULKAN_HPP_NAMESPACE::NVViewportArray2SpecVersion; - - //=== VK_NVX_multiview_per_view_attributes === - using VULKAN_HPP_NAMESPACE::NVXMultiviewPerViewAttributesExtensionName; - using VULKAN_HPP_NAMESPACE::NVXMultiviewPerViewAttributesSpecVersion; - - //=== VK_NV_viewport_swizzle === - using VULKAN_HPP_NAMESPACE::NVViewportSwizzleExtensionName; - using VULKAN_HPP_NAMESPACE::NVViewportSwizzleSpecVersion; - - //=== VK_EXT_discard_rectangles === - using VULKAN_HPP_NAMESPACE::EXTDiscardRectanglesExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDiscardRectanglesSpecVersion; - - //=== VK_EXT_conservative_rasterization === - using VULKAN_HPP_NAMESPACE::EXTConservativeRasterizationExtensionName; - using VULKAN_HPP_NAMESPACE::EXTConservativeRasterizationSpecVersion; - - //=== VK_EXT_depth_clip_enable === - using VULKAN_HPP_NAMESPACE::EXTDepthClipEnableExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDepthClipEnableSpecVersion; - - //=== VK_EXT_swapchain_colorspace === - using VULKAN_HPP_NAMESPACE::EXTSwapchainColorSpaceExtensionName; - using VULKAN_HPP_NAMESPACE::EXTSwapchainColorSpaceSpecVersion; - - //=== VK_EXT_hdr_metadata === - using VULKAN_HPP_NAMESPACE::EXTHdrMetadataExtensionName; - using VULKAN_HPP_NAMESPACE::EXTHdrMetadataSpecVersion; - - //=== VK_KHR_imageless_framebuffer === - using VULKAN_HPP_NAMESPACE::KHRImagelessFramebufferExtensionName; - using VULKAN_HPP_NAMESPACE::KHRImagelessFramebufferSpecVersion; - - //=== VK_KHR_create_renderpass2 === - using VULKAN_HPP_NAMESPACE::KHRCreateRenderpass2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRCreateRenderpass2SpecVersion; - - //=== VK_IMG_relaxed_line_rasterization === - using VULKAN_HPP_NAMESPACE::IMGRelaxedLineRasterizationExtensionName; - using VULKAN_HPP_NAMESPACE::IMGRelaxedLineRasterizationSpecVersion; - - //=== VK_KHR_shared_presentable_image === - using VULKAN_HPP_NAMESPACE::KHRSharedPresentableImageExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSharedPresentableImageSpecVersion; - - //=== VK_KHR_external_fence_capabilities === - using VULKAN_HPP_NAMESPACE::KHRExternalFenceCapabilitiesExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalFenceCapabilitiesSpecVersion; - - //=== VK_KHR_external_fence === - using VULKAN_HPP_NAMESPACE::KHRExternalFenceExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalFenceSpecVersion; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - using VULKAN_HPP_NAMESPACE::KHRExternalFenceWin32ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalFenceWin32SpecVersion; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - using VULKAN_HPP_NAMESPACE::KHRExternalFenceFdExtensionName; - using VULKAN_HPP_NAMESPACE::KHRExternalFenceFdSpecVersion; - - //=== VK_KHR_performance_query === - using VULKAN_HPP_NAMESPACE::KHRPerformanceQueryExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPerformanceQuerySpecVersion; - - //=== VK_KHR_maintenance2 === - using VULKAN_HPP_NAMESPACE::KHRMaintenance2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMaintenance2SpecVersion; - - //=== VK_KHR_get_surface_capabilities2 === - using VULKAN_HPP_NAMESPACE::KHRGetSurfaceCapabilities2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRGetSurfaceCapabilities2SpecVersion; - - //=== VK_KHR_variable_pointers === - using VULKAN_HPP_NAMESPACE::KHRVariablePointersExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVariablePointersSpecVersion; - - //=== VK_KHR_get_display_properties2 === - using VULKAN_HPP_NAMESPACE::KHRGetDisplayProperties2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRGetDisplayProperties2SpecVersion; - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - using VULKAN_HPP_NAMESPACE::MVKIosSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::MVKIosSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - using VULKAN_HPP_NAMESPACE::MVKMacosSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::MVKMacosSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_external_memory_dma_buf === - using VULKAN_HPP_NAMESPACE::EXTExternalMemoryDmaBufExtensionName; - using VULKAN_HPP_NAMESPACE::EXTExternalMemoryDmaBufSpecVersion; - - //=== VK_EXT_queue_family_foreign === - using VULKAN_HPP_NAMESPACE::EXTQueueFamilyForeignExtensionName; - using VULKAN_HPP_NAMESPACE::EXTQueueFamilyForeignSpecVersion; - using VULKAN_HPP_NAMESPACE::QueueFamilyForeignEXT; - - //=== VK_KHR_dedicated_allocation === - using VULKAN_HPP_NAMESPACE::KHRDedicatedAllocationExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDedicatedAllocationSpecVersion; - - //=== VK_EXT_debug_utils === - using VULKAN_HPP_NAMESPACE::EXTDebugUtilsExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDebugUtilsSpecVersion; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - using VULKAN_HPP_NAMESPACE::ANDROIDExternalMemoryAndroidHardwareBufferExtensionName; - using VULKAN_HPP_NAMESPACE::ANDROIDExternalMemoryAndroidHardwareBufferSpecVersion; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - //=== VK_EXT_sampler_filter_minmax === - using VULKAN_HPP_NAMESPACE::EXTSamplerFilterMinmaxExtensionName; - using VULKAN_HPP_NAMESPACE::EXTSamplerFilterMinmaxSpecVersion; - - //=== VK_KHR_storage_buffer_storage_class === - using VULKAN_HPP_NAMESPACE::KHRStorageBufferStorageClassExtensionName; - using VULKAN_HPP_NAMESPACE::KHRStorageBufferStorageClassSpecVersion; - - //=== VK_AMD_gpu_shader_int16 === - using VULKAN_HPP_NAMESPACE::AMDGpuShaderInt16ExtensionName; - using VULKAN_HPP_NAMESPACE::AMDGpuShaderInt16SpecVersion; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - using VULKAN_HPP_NAMESPACE::AMDXShaderEnqueueExtensionName; - using VULKAN_HPP_NAMESPACE::AMDXShaderEnqueueSpecVersion; - using VULKAN_HPP_NAMESPACE::ShaderIndexUnusedAMDX; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - using VULKAN_HPP_NAMESPACE::EXTDescriptorHeapExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDescriptorHeapSpecVersion; - - //=== VK_AMD_mixed_attachment_samples === - using VULKAN_HPP_NAMESPACE::AMDMixedAttachmentSamplesExtensionName; - using VULKAN_HPP_NAMESPACE::AMDMixedAttachmentSamplesSpecVersion; - - //=== VK_AMD_shader_fragment_mask === - using VULKAN_HPP_NAMESPACE::AMDShaderFragmentMaskExtensionName; - using VULKAN_HPP_NAMESPACE::AMDShaderFragmentMaskSpecVersion; - - //=== VK_EXT_inline_uniform_block === - using VULKAN_HPP_NAMESPACE::EXTInlineUniformBlockExtensionName; - using VULKAN_HPP_NAMESPACE::EXTInlineUniformBlockSpecVersion; - - //=== VK_EXT_shader_stencil_export === - using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderStencilExportSpecVersion; - - //=== VK_KHR_shader_bfloat16 === - using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderBfloat16SpecVersion; - - //=== VK_EXT_sample_locations === - using VULKAN_HPP_NAMESPACE::EXTSampleLocationsExtensionName; - using VULKAN_HPP_NAMESPACE::EXTSampleLocationsSpecVersion; - - //=== VK_KHR_relaxed_block_layout === - using VULKAN_HPP_NAMESPACE::KHRRelaxedBlockLayoutExtensionName; - using VULKAN_HPP_NAMESPACE::KHRRelaxedBlockLayoutSpecVersion; - - //=== VK_KHR_get_memory_requirements2 === - using VULKAN_HPP_NAMESPACE::KHRGetMemoryRequirements2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRGetMemoryRequirements2SpecVersion; - - //=== VK_KHR_image_format_list === - using VULKAN_HPP_NAMESPACE::KHRImageFormatListExtensionName; - using VULKAN_HPP_NAMESPACE::KHRImageFormatListSpecVersion; - - //=== VK_EXT_blend_operation_advanced === - using VULKAN_HPP_NAMESPACE::EXTBlendOperationAdvancedExtensionName; - using VULKAN_HPP_NAMESPACE::EXTBlendOperationAdvancedSpecVersion; - - //=== VK_NV_fragment_coverage_to_color === - using VULKAN_HPP_NAMESPACE::NVFragmentCoverageToColorExtensionName; - using VULKAN_HPP_NAMESPACE::NVFragmentCoverageToColorSpecVersion; - - //=== VK_KHR_acceleration_structure === - using VULKAN_HPP_NAMESPACE::KHRAccelerationStructureExtensionName; - using VULKAN_HPP_NAMESPACE::KHRAccelerationStructureSpecVersion; - - //=== VK_KHR_ray_tracing_pipeline === - using VULKAN_HPP_NAMESPACE::KHRRayTracingPipelineExtensionName; - using VULKAN_HPP_NAMESPACE::KHRRayTracingPipelineSpecVersion; - using VULKAN_HPP_NAMESPACE::ShaderUnusedKHR; - - //=== VK_KHR_ray_query === - using VULKAN_HPP_NAMESPACE::KHRRayQueryExtensionName; - using VULKAN_HPP_NAMESPACE::KHRRayQuerySpecVersion; - - //=== VK_NV_framebuffer_mixed_samples === - using VULKAN_HPP_NAMESPACE::NVFramebufferMixedSamplesExtensionName; - using VULKAN_HPP_NAMESPACE::NVFramebufferMixedSamplesSpecVersion; - - //=== VK_NV_fill_rectangle === - using VULKAN_HPP_NAMESPACE::NVFillRectangleExtensionName; - using VULKAN_HPP_NAMESPACE::NVFillRectangleSpecVersion; - - //=== VK_NV_shader_sm_builtins === - using VULKAN_HPP_NAMESPACE::NVShaderSmBuiltinsExtensionName; - using VULKAN_HPP_NAMESPACE::NVShaderSmBuiltinsSpecVersion; - - //=== VK_EXT_post_depth_coverage === - using VULKAN_HPP_NAMESPACE::EXTPostDepthCoverageExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPostDepthCoverageSpecVersion; - - //=== VK_KHR_sampler_ycbcr_conversion === - using VULKAN_HPP_NAMESPACE::KHRSamplerYcbcrConversionExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSamplerYcbcrConversionSpecVersion; - - //=== VK_KHR_bind_memory2 === - using VULKAN_HPP_NAMESPACE::KHRBindMemory2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRBindMemory2SpecVersion; - - //=== VK_EXT_image_drm_format_modifier === - using VULKAN_HPP_NAMESPACE::EXTImageDrmFormatModifierExtensionName; - using VULKAN_HPP_NAMESPACE::EXTImageDrmFormatModifierSpecVersion; - - //=== VK_EXT_validation_cache === - using VULKAN_HPP_NAMESPACE::EXTValidationCacheExtensionName; - using VULKAN_HPP_NAMESPACE::EXTValidationCacheSpecVersion; - - //=== VK_EXT_descriptor_indexing === - using VULKAN_HPP_NAMESPACE::EXTDescriptorIndexingExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDescriptorIndexingSpecVersion; - - //=== VK_EXT_shader_viewport_index_layer === - using VULKAN_HPP_NAMESPACE::EXTShaderViewportIndexLayerExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderViewportIndexLayerSpecVersion; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_KHR_portability_subset === - using VULKAN_HPP_NAMESPACE::KHRPortabilitySubsetExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPortabilitySubsetSpecVersion; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_NV_shading_rate_image === - using VULKAN_HPP_NAMESPACE::NVShadingRateImageExtensionName; - using VULKAN_HPP_NAMESPACE::NVShadingRateImageSpecVersion; - - //=== VK_NV_ray_tracing === - using VULKAN_HPP_NAMESPACE::NVRayTracingExtensionName; - using VULKAN_HPP_NAMESPACE::NVRayTracingSpecVersion; - using VULKAN_HPP_NAMESPACE::ShaderUnusedNV; - - //=== VK_NV_representative_fragment_test === - using VULKAN_HPP_NAMESPACE::NVRepresentativeFragmentTestExtensionName; - using VULKAN_HPP_NAMESPACE::NVRepresentativeFragmentTestSpecVersion; - - //=== VK_KHR_maintenance3 === - using VULKAN_HPP_NAMESPACE::KHRMaintenance3ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMaintenance3SpecVersion; - - //=== VK_KHR_draw_indirect_count === - using VULKAN_HPP_NAMESPACE::KHRDrawIndirectCountExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDrawIndirectCountSpecVersion; - - //=== VK_EXT_filter_cubic === - using VULKAN_HPP_NAMESPACE::EXTFilterCubicExtensionName; - using VULKAN_HPP_NAMESPACE::EXTFilterCubicSpecVersion; - - //=== VK_QCOM_render_pass_shader_resolve === - using VULKAN_HPP_NAMESPACE::QCOMRenderPassShaderResolveExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMRenderPassShaderResolveSpecVersion; - - //=== VK_EXT_global_priority === - using VULKAN_HPP_NAMESPACE::EXTGlobalPriorityExtensionName; - using VULKAN_HPP_NAMESPACE::EXTGlobalPrioritySpecVersion; - - //=== VK_KHR_shader_subgroup_extended_types === - using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupExtendedTypesExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupExtendedTypesSpecVersion; - - //=== VK_KHR_8bit_storage === - using VULKAN_HPP_NAMESPACE::KHR8BitStorageExtensionName; - using VULKAN_HPP_NAMESPACE::KHR8BitStorageSpecVersion; - - //=== VK_EXT_external_memory_host === - using VULKAN_HPP_NAMESPACE::EXTExternalMemoryHostExtensionName; - using VULKAN_HPP_NAMESPACE::EXTExternalMemoryHostSpecVersion; - - //=== VK_AMD_buffer_marker === - using VULKAN_HPP_NAMESPACE::AMDBufferMarkerExtensionName; - using VULKAN_HPP_NAMESPACE::AMDBufferMarkerSpecVersion; - - //=== VK_KHR_shader_atomic_int64 === - using VULKAN_HPP_NAMESPACE::KHRShaderAtomicInt64ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderAtomicInt64SpecVersion; - - //=== VK_KHR_shader_clock === - using VULKAN_HPP_NAMESPACE::KHRShaderClockExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderClockSpecVersion; - - //=== VK_AMD_pipeline_compiler_control === - using VULKAN_HPP_NAMESPACE::AMDPipelineCompilerControlExtensionName; - using VULKAN_HPP_NAMESPACE::AMDPipelineCompilerControlSpecVersion; - - //=== VK_EXT_calibrated_timestamps === - using VULKAN_HPP_NAMESPACE::EXTCalibratedTimestampsExtensionName; - using VULKAN_HPP_NAMESPACE::EXTCalibratedTimestampsSpecVersion; - - //=== VK_AMD_shader_core_properties === - using VULKAN_HPP_NAMESPACE::AMDShaderCorePropertiesExtensionName; - using VULKAN_HPP_NAMESPACE::AMDShaderCorePropertiesSpecVersion; - - //=== VK_KHR_video_decode_h265 === - using VULKAN_HPP_NAMESPACE::KHRVideoDecodeH265ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoDecodeH265SpecVersion; - - //=== VK_KHR_global_priority === - using VULKAN_HPP_NAMESPACE::KHRGlobalPriorityExtensionName; - using VULKAN_HPP_NAMESPACE::KHRGlobalPrioritySpecVersion; - using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeKHR; - - //=== VK_AMD_memory_overallocation_behavior === - using VULKAN_HPP_NAMESPACE::AMDMemoryOverallocationBehaviorExtensionName; - using VULKAN_HPP_NAMESPACE::AMDMemoryOverallocationBehaviorSpecVersion; - - //=== VK_EXT_vertex_attribute_divisor === - using VULKAN_HPP_NAMESPACE::EXTVertexAttributeDivisorExtensionName; - using VULKAN_HPP_NAMESPACE::EXTVertexAttributeDivisorSpecVersion; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_frame_token === - using VULKAN_HPP_NAMESPACE::GGPFrameTokenExtensionName; - using VULKAN_HPP_NAMESPACE::GGPFrameTokenSpecVersion; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_EXT_pipeline_creation_feedback === - using VULKAN_HPP_NAMESPACE::EXTPipelineCreationFeedbackExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPipelineCreationFeedbackSpecVersion; - - //=== VK_KHR_driver_properties === - using VULKAN_HPP_NAMESPACE::KHRDriverPropertiesExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDriverPropertiesSpecVersion; - using VULKAN_HPP_NAMESPACE::MaxDriverInfoSizeKHR; - using VULKAN_HPP_NAMESPACE::MaxDriverNameSizeKHR; - - //=== VK_KHR_shader_float_controls === - using VULKAN_HPP_NAMESPACE::KHRShaderFloatControlsExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderFloatControlsSpecVersion; - - //=== VK_NV_shader_subgroup_partitioned === - using VULKAN_HPP_NAMESPACE::NVShaderSubgroupPartitionedExtensionName; - using VULKAN_HPP_NAMESPACE::NVShaderSubgroupPartitionedSpecVersion; - - //=== VK_KHR_depth_stencil_resolve === - using VULKAN_HPP_NAMESPACE::KHRDepthStencilResolveExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDepthStencilResolveSpecVersion; - - //=== VK_KHR_swapchain_mutable_format === - using VULKAN_HPP_NAMESPACE::KHRSwapchainMutableFormatExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSwapchainMutableFormatSpecVersion; - - //=== VK_NV_compute_shader_derivatives === - using VULKAN_HPP_NAMESPACE::NVComputeShaderDerivativesExtensionName; - using VULKAN_HPP_NAMESPACE::NVComputeShaderDerivativesSpecVersion; - - //=== VK_NV_mesh_shader === - using VULKAN_HPP_NAMESPACE::NVMeshShaderExtensionName; - using VULKAN_HPP_NAMESPACE::NVMeshShaderSpecVersion; - - //=== VK_NV_fragment_shader_barycentric === - using VULKAN_HPP_NAMESPACE::NVFragmentShaderBarycentricExtensionName; - using VULKAN_HPP_NAMESPACE::NVFragmentShaderBarycentricSpecVersion; - - //=== VK_NV_shader_image_footprint === - using VULKAN_HPP_NAMESPACE::NVShaderImageFootprintExtensionName; - using VULKAN_HPP_NAMESPACE::NVShaderImageFootprintSpecVersion; - - //=== VK_NV_scissor_exclusive === - using VULKAN_HPP_NAMESPACE::NVScissorExclusiveExtensionName; - using VULKAN_HPP_NAMESPACE::NVScissorExclusiveSpecVersion; - - //=== VK_NV_device_diagnostic_checkpoints === - using VULKAN_HPP_NAMESPACE::NVDeviceDiagnosticCheckpointsExtensionName; - using VULKAN_HPP_NAMESPACE::NVDeviceDiagnosticCheckpointsSpecVersion; - - //=== VK_KHR_timeline_semaphore === - using VULKAN_HPP_NAMESPACE::KHRTimelineSemaphoreExtensionName; - using VULKAN_HPP_NAMESPACE::KHRTimelineSemaphoreSpecVersion; - - //=== VK_EXT_present_timing === - using VULKAN_HPP_NAMESPACE::EXTPresentTimingExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPresentTimingSpecVersion; - - //=== VK_INTEL_shader_integer_functions2 === - using VULKAN_HPP_NAMESPACE::INTELShaderIntegerFunctions2ExtensionName; - using VULKAN_HPP_NAMESPACE::INTELShaderIntegerFunctions2SpecVersion; - - //=== VK_INTEL_performance_query === - using VULKAN_HPP_NAMESPACE::INTELPerformanceQueryExtensionName; - using VULKAN_HPP_NAMESPACE::INTELPerformanceQuerySpecVersion; - - //=== VK_KHR_vulkan_memory_model === - using VULKAN_HPP_NAMESPACE::KHRVulkanMemoryModelExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVulkanMemoryModelSpecVersion; - - //=== VK_EXT_pci_bus_info === - using VULKAN_HPP_NAMESPACE::EXTPciBusInfoExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPciBusInfoSpecVersion; - - //=== VK_AMD_display_native_hdr === - using VULKAN_HPP_NAMESPACE::AMDDisplayNativeHdrExtensionName; - using VULKAN_HPP_NAMESPACE::AMDDisplayNativeHdrSpecVersion; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - using VULKAN_HPP_NAMESPACE::FUCHSIAImagepipeSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::FUCHSIAImagepipeSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_KHR_shader_terminate_invocation === - using VULKAN_HPP_NAMESPACE::KHRShaderTerminateInvocationExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderTerminateInvocationSpecVersion; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - using VULKAN_HPP_NAMESPACE::EXTMetalSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::EXTMetalSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_fragment_density_map === - using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapExtensionName; - using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapSpecVersion; - - //=== VK_EXT_scalar_block_layout === - using VULKAN_HPP_NAMESPACE::EXTScalarBlockLayoutExtensionName; - using VULKAN_HPP_NAMESPACE::EXTScalarBlockLayoutSpecVersion; - - //=== VK_GOOGLE_hlsl_functionality1 === - using VULKAN_HPP_NAMESPACE::GOOGLEHlslFunctionality1ExtensionName; - using VULKAN_HPP_NAMESPACE::GOOGLEHlslFunctionality1SpecVersion; - - //=== VK_GOOGLE_decorate_string === - using VULKAN_HPP_NAMESPACE::GOOGLEDecorateStringExtensionName; - using VULKAN_HPP_NAMESPACE::GOOGLEDecorateStringSpecVersion; - - //=== VK_EXT_subgroup_size_control === - using VULKAN_HPP_NAMESPACE::EXTSubgroupSizeControlExtensionName; - using VULKAN_HPP_NAMESPACE::EXTSubgroupSizeControlSpecVersion; - - //=== VK_KHR_fragment_shading_rate === - using VULKAN_HPP_NAMESPACE::KHRFragmentShadingRateExtensionName; - using VULKAN_HPP_NAMESPACE::KHRFragmentShadingRateSpecVersion; - - //=== VK_AMD_shader_core_properties2 === - using VULKAN_HPP_NAMESPACE::AMDShaderCoreProperties2ExtensionName; - using VULKAN_HPP_NAMESPACE::AMDShaderCoreProperties2SpecVersion; - - //=== VK_AMD_device_coherent_memory === - using VULKAN_HPP_NAMESPACE::AMDDeviceCoherentMemoryExtensionName; - using VULKAN_HPP_NAMESPACE::AMDDeviceCoherentMemorySpecVersion; - - //=== VK_KHR_dynamic_rendering_local_read === - using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingLocalReadExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDynamicRenderingLocalReadSpecVersion; - - //=== VK_EXT_shader_image_atomic_int64 === - using VULKAN_HPP_NAMESPACE::EXTShaderImageAtomicInt64ExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderImageAtomicInt64SpecVersion; - - //=== VK_KHR_shader_quad_control === - using VULKAN_HPP_NAMESPACE::KHRShaderQuadControlExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderQuadControlSpecVersion; - - //=== VK_KHR_spirv_1_4 === - using VULKAN_HPP_NAMESPACE::KHRSpirv14ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSpirv14SpecVersion; - - //=== VK_EXT_memory_budget === - using VULKAN_HPP_NAMESPACE::EXTMemoryBudgetExtensionName; - using VULKAN_HPP_NAMESPACE::EXTMemoryBudgetSpecVersion; - - //=== VK_EXT_memory_priority === - using VULKAN_HPP_NAMESPACE::EXTMemoryPriorityExtensionName; - using VULKAN_HPP_NAMESPACE::EXTMemoryPrioritySpecVersion; - - //=== VK_KHR_surface_protected_capabilities === - using VULKAN_HPP_NAMESPACE::KHRSurfaceProtectedCapabilitiesExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSurfaceProtectedCapabilitiesSpecVersion; - - //=== VK_NV_dedicated_allocation_image_aliasing === - using VULKAN_HPP_NAMESPACE::NVDedicatedAllocationImageAliasingExtensionName; - using VULKAN_HPP_NAMESPACE::NVDedicatedAllocationImageAliasingSpecVersion; - - //=== VK_KHR_separate_depth_stencil_layouts === - using VULKAN_HPP_NAMESPACE::KHRSeparateDepthStencilLayoutsExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSeparateDepthStencilLayoutsSpecVersion; - - //=== VK_EXT_buffer_device_address === - using VULKAN_HPP_NAMESPACE::EXTBufferDeviceAddressExtensionName; - using VULKAN_HPP_NAMESPACE::EXTBufferDeviceAddressSpecVersion; - - //=== VK_EXT_tooling_info === - using VULKAN_HPP_NAMESPACE::EXTToolingInfoExtensionName; - using VULKAN_HPP_NAMESPACE::EXTToolingInfoSpecVersion; - - //=== VK_EXT_separate_stencil_usage === - using VULKAN_HPP_NAMESPACE::EXTSeparateStencilUsageExtensionName; - using VULKAN_HPP_NAMESPACE::EXTSeparateStencilUsageSpecVersion; - - //=== VK_EXT_validation_features === - using VULKAN_HPP_NAMESPACE::EXTValidationFeaturesExtensionName; - using VULKAN_HPP_NAMESPACE::EXTValidationFeaturesSpecVersion; - - //=== VK_KHR_present_wait === - using VULKAN_HPP_NAMESPACE::KHRPresentWaitExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPresentWaitSpecVersion; - - //=== VK_NV_cooperative_matrix === - using VULKAN_HPP_NAMESPACE::NVCooperativeMatrixExtensionName; - using VULKAN_HPP_NAMESPACE::NVCooperativeMatrixSpecVersion; - - //=== VK_NV_coverage_reduction_mode === - using VULKAN_HPP_NAMESPACE::NVCoverageReductionModeExtensionName; - using VULKAN_HPP_NAMESPACE::NVCoverageReductionModeSpecVersion; - - //=== VK_EXT_fragment_shader_interlock === - using VULKAN_HPP_NAMESPACE::EXTFragmentShaderInterlockExtensionName; - using VULKAN_HPP_NAMESPACE::EXTFragmentShaderInterlockSpecVersion; - - //=== VK_EXT_ycbcr_image_arrays === - using VULKAN_HPP_NAMESPACE::EXTYcbcrImageArraysExtensionName; - using VULKAN_HPP_NAMESPACE::EXTYcbcrImageArraysSpecVersion; - - //=== VK_KHR_uniform_buffer_standard_layout === - using VULKAN_HPP_NAMESPACE::KHRUniformBufferStandardLayoutExtensionName; - using VULKAN_HPP_NAMESPACE::KHRUniformBufferStandardLayoutSpecVersion; - - //=== VK_EXT_provoking_vertex === - using VULKAN_HPP_NAMESPACE::EXTProvokingVertexExtensionName; - using VULKAN_HPP_NAMESPACE::EXTProvokingVertexSpecVersion; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - using VULKAN_HPP_NAMESPACE::EXTFullScreenExclusiveExtensionName; - using VULKAN_HPP_NAMESPACE::EXTFullScreenExclusiveSpecVersion; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - using VULKAN_HPP_NAMESPACE::EXTHeadlessSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::EXTHeadlessSurfaceSpecVersion; - - //=== VK_KHR_buffer_device_address === - using VULKAN_HPP_NAMESPACE::KHRBufferDeviceAddressExtensionName; - using VULKAN_HPP_NAMESPACE::KHRBufferDeviceAddressSpecVersion; - - //=== VK_EXT_line_rasterization === - using VULKAN_HPP_NAMESPACE::EXTLineRasterizationExtensionName; - using VULKAN_HPP_NAMESPACE::EXTLineRasterizationSpecVersion; - - //=== VK_EXT_shader_atomic_float === - using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloatExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloatSpecVersion; - - //=== VK_EXT_host_query_reset === - using VULKAN_HPP_NAMESPACE::EXTHostQueryResetExtensionName; - using VULKAN_HPP_NAMESPACE::EXTHostQueryResetSpecVersion; - - //=== VK_EXT_index_type_uint8 === - using VULKAN_HPP_NAMESPACE::EXTIndexTypeUint8ExtensionName; - using VULKAN_HPP_NAMESPACE::EXTIndexTypeUint8SpecVersion; - - //=== VK_EXT_extended_dynamic_state === - using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicStateExtensionName; - using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicStateSpecVersion; - - //=== VK_KHR_deferred_host_operations === - using VULKAN_HPP_NAMESPACE::KHRDeferredHostOperationsExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDeferredHostOperationsSpecVersion; - - //=== VK_KHR_pipeline_executable_properties === - using VULKAN_HPP_NAMESPACE::KHRPipelineExecutablePropertiesExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPipelineExecutablePropertiesSpecVersion; - - //=== VK_EXT_host_image_copy === - using VULKAN_HPP_NAMESPACE::EXTHostImageCopyExtensionName; - using VULKAN_HPP_NAMESPACE::EXTHostImageCopySpecVersion; - - //=== VK_KHR_map_memory2 === - using VULKAN_HPP_NAMESPACE::KHRMapMemory2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMapMemory2SpecVersion; - - //=== VK_EXT_map_memory_placed === - using VULKAN_HPP_NAMESPACE::EXTMapMemoryPlacedExtensionName; - using VULKAN_HPP_NAMESPACE::EXTMapMemoryPlacedSpecVersion; - - //=== VK_EXT_shader_atomic_float2 === - using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloat2ExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderAtomicFloat2SpecVersion; - - //=== VK_EXT_surface_maintenance1 === - using VULKAN_HPP_NAMESPACE::EXTSurfaceMaintenance1ExtensionName; - using VULKAN_HPP_NAMESPACE::EXTSurfaceMaintenance1SpecVersion; - - //=== VK_EXT_swapchain_maintenance1 === - using VULKAN_HPP_NAMESPACE::EXTSwapchainMaintenance1ExtensionName; - using VULKAN_HPP_NAMESPACE::EXTSwapchainMaintenance1SpecVersion; - - //=== VK_EXT_shader_demote_to_helper_invocation === - using VULKAN_HPP_NAMESPACE::EXTShaderDemoteToHelperInvocationExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderDemoteToHelperInvocationSpecVersion; - - //=== VK_NV_device_generated_commands === - using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsExtensionName; - using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsSpecVersion; - - //=== VK_NV_inherited_viewport_scissor === - using VULKAN_HPP_NAMESPACE::NVInheritedViewportScissorExtensionName; - using VULKAN_HPP_NAMESPACE::NVInheritedViewportScissorSpecVersion; - - //=== VK_KHR_shader_integer_dot_product === - using VULKAN_HPP_NAMESPACE::KHRShaderIntegerDotProductExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderIntegerDotProductSpecVersion; - - //=== VK_EXT_texel_buffer_alignment === - using VULKAN_HPP_NAMESPACE::EXTTexelBufferAlignmentExtensionName; - using VULKAN_HPP_NAMESPACE::EXTTexelBufferAlignmentSpecVersion; - - //=== VK_QCOM_render_pass_transform === - using VULKAN_HPP_NAMESPACE::QCOMRenderPassTransformExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMRenderPassTransformSpecVersion; - - //=== VK_EXT_depth_bias_control === - using VULKAN_HPP_NAMESPACE::EXTDepthBiasControlExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDepthBiasControlSpecVersion; - - //=== VK_EXT_device_memory_report === - using VULKAN_HPP_NAMESPACE::EXTDeviceMemoryReportExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDeviceMemoryReportSpecVersion; - - //=== VK_EXT_acquire_drm_display === - using VULKAN_HPP_NAMESPACE::EXTAcquireDrmDisplayExtensionName; - using VULKAN_HPP_NAMESPACE::EXTAcquireDrmDisplaySpecVersion; - - //=== VK_EXT_robustness2 === - using VULKAN_HPP_NAMESPACE::EXTRobustness2ExtensionName; - using VULKAN_HPP_NAMESPACE::EXTRobustness2SpecVersion; - - //=== VK_EXT_custom_border_color === - using VULKAN_HPP_NAMESPACE::EXTCustomBorderColorExtensionName; - using VULKAN_HPP_NAMESPACE::EXTCustomBorderColorSpecVersion; - - //=== VK_EXT_texture_compression_astc_3d === - using VULKAN_HPP_NAMESPACE::EXTTextureCompressionAstc3DExtensionName; - using VULKAN_HPP_NAMESPACE::EXTTextureCompressionAstc3DSpecVersion; - - //=== VK_GOOGLE_user_type === - using VULKAN_HPP_NAMESPACE::GOOGLEUserTypeExtensionName; - using VULKAN_HPP_NAMESPACE::GOOGLEUserTypeSpecVersion; - - //=== VK_KHR_pipeline_library === - using VULKAN_HPP_NAMESPACE::KHRPipelineLibraryExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPipelineLibrarySpecVersion; - - //=== VK_NV_present_barrier === - using VULKAN_HPP_NAMESPACE::NVPresentBarrierExtensionName; - using VULKAN_HPP_NAMESPACE::NVPresentBarrierSpecVersion; - - //=== VK_KHR_shader_non_semantic_info === - using VULKAN_HPP_NAMESPACE::KHRShaderNonSemanticInfoExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderNonSemanticInfoSpecVersion; - - //=== VK_KHR_present_id === - using VULKAN_HPP_NAMESPACE::KHRPresentIdExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPresentIdSpecVersion; - - //=== VK_EXT_private_data === - using VULKAN_HPP_NAMESPACE::EXTPrivateDataExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPrivateDataSpecVersion; - - //=== VK_EXT_pipeline_creation_cache_control === - using VULKAN_HPP_NAMESPACE::EXTPipelineCreationCacheControlExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPipelineCreationCacheControlSpecVersion; - - //=== VK_KHR_video_encode_queue === - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeQueueExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeQueueSpecVersion; - - //=== VK_NV_device_diagnostics_config === - using VULKAN_HPP_NAMESPACE::NVDeviceDiagnosticsConfigExtensionName; - using VULKAN_HPP_NAMESPACE::NVDeviceDiagnosticsConfigSpecVersion; - - //=== VK_QCOM_render_pass_store_ops === - using VULKAN_HPP_NAMESPACE::QCOMRenderPassStoreOpsExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMRenderPassStoreOpsSpecVersion; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - using VULKAN_HPP_NAMESPACE::NVCudaKernelLaunchExtensionName; - using VULKAN_HPP_NAMESPACE::NVCudaKernelLaunchSpecVersion; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - using VULKAN_HPP_NAMESPACE::QCOMTileShadingExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMTileShadingSpecVersion; - - //=== VK_NV_low_latency === - using VULKAN_HPP_NAMESPACE::NVLowLatencyExtensionName; - using VULKAN_HPP_NAMESPACE::NVLowLatencySpecVersion; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - using VULKAN_HPP_NAMESPACE::EXTMetalObjectsExtensionName; - using VULKAN_HPP_NAMESPACE::EXTMetalObjectsSpecVersion; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_synchronization2 === - using VULKAN_HPP_NAMESPACE::KHRSynchronization2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSynchronization2SpecVersion; - - //=== VK_EXT_descriptor_buffer === - using VULKAN_HPP_NAMESPACE::EXTDescriptorBufferExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDescriptorBufferSpecVersion; - - //=== VK_EXT_graphics_pipeline_library === - using VULKAN_HPP_NAMESPACE::EXTGraphicsPipelineLibraryExtensionName; - using VULKAN_HPP_NAMESPACE::EXTGraphicsPipelineLibrarySpecVersion; - - //=== VK_AMD_shader_early_and_late_fragment_tests === - using VULKAN_HPP_NAMESPACE::AMDShaderEarlyAndLateFragmentTestsExtensionName; - using VULKAN_HPP_NAMESPACE::AMDShaderEarlyAndLateFragmentTestsSpecVersion; - - //=== VK_KHR_fragment_shader_barycentric === - using VULKAN_HPP_NAMESPACE::KHRFragmentShaderBarycentricExtensionName; - using VULKAN_HPP_NAMESPACE::KHRFragmentShaderBarycentricSpecVersion; - - //=== VK_KHR_shader_subgroup_uniform_control_flow === - using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupUniformControlFlowExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupUniformControlFlowSpecVersion; - - //=== VK_KHR_zero_initialize_workgroup_memory === - using VULKAN_HPP_NAMESPACE::KHRZeroInitializeWorkgroupMemoryExtensionName; - using VULKAN_HPP_NAMESPACE::KHRZeroInitializeWorkgroupMemorySpecVersion; - - //=== VK_NV_fragment_shading_rate_enums === - using VULKAN_HPP_NAMESPACE::NVFragmentShadingRateEnumsExtensionName; - using VULKAN_HPP_NAMESPACE::NVFragmentShadingRateEnumsSpecVersion; - - //=== VK_NV_ray_tracing_motion_blur === - using VULKAN_HPP_NAMESPACE::NVRayTracingMotionBlurExtensionName; - using VULKAN_HPP_NAMESPACE::NVRayTracingMotionBlurSpecVersion; - - //=== VK_EXT_mesh_shader === - using VULKAN_HPP_NAMESPACE::EXTMeshShaderExtensionName; - using VULKAN_HPP_NAMESPACE::EXTMeshShaderSpecVersion; - - //=== VK_EXT_ycbcr_2plane_444_formats === - using VULKAN_HPP_NAMESPACE::EXTYcbcr2Plane444FormatsExtensionName; - using VULKAN_HPP_NAMESPACE::EXTYcbcr2Plane444FormatsSpecVersion; - - //=== VK_EXT_fragment_density_map2 === - using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMap2ExtensionName; - using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMap2SpecVersion; - - //=== VK_QCOM_rotated_copy_commands === - using VULKAN_HPP_NAMESPACE::QCOMRotatedCopyCommandsExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMRotatedCopyCommandsSpecVersion; - - //=== VK_EXT_image_robustness === - using VULKAN_HPP_NAMESPACE::EXTImageRobustnessExtensionName; - using VULKAN_HPP_NAMESPACE::EXTImageRobustnessSpecVersion; - - //=== VK_KHR_workgroup_memory_explicit_layout === - using VULKAN_HPP_NAMESPACE::KHRWorkgroupMemoryExplicitLayoutExtensionName; - using VULKAN_HPP_NAMESPACE::KHRWorkgroupMemoryExplicitLayoutSpecVersion; - - //=== VK_KHR_copy_commands2 === - using VULKAN_HPP_NAMESPACE::KHRCopyCommands2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRCopyCommands2SpecVersion; - - //=== VK_EXT_image_compression_control === - using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlExtensionName; - using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlSpecVersion; - - //=== VK_EXT_attachment_feedback_loop_layout === - using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopLayoutExtensionName; - using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopLayoutSpecVersion; - - //=== VK_EXT_4444_formats === - using VULKAN_HPP_NAMESPACE::EXT4444FormatsExtensionName; - using VULKAN_HPP_NAMESPACE::EXT4444FormatsSpecVersion; - - //=== VK_EXT_device_fault === - using VULKAN_HPP_NAMESPACE::EXTDeviceFaultExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDeviceFaultSpecVersion; - - //=== VK_ARM_rasterization_order_attachment_access === - using VULKAN_HPP_NAMESPACE::ARMRasterizationOrderAttachmentAccessExtensionName; - using VULKAN_HPP_NAMESPACE::ARMRasterizationOrderAttachmentAccessSpecVersion; - - //=== VK_EXT_rgba10x6_formats === - using VULKAN_HPP_NAMESPACE::EXTRgba10X6FormatsExtensionName; - using VULKAN_HPP_NAMESPACE::EXTRgba10X6FormatsSpecVersion; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - using VULKAN_HPP_NAMESPACE::NVAcquireWinrtDisplayExtensionName; - using VULKAN_HPP_NAMESPACE::NVAcquireWinrtDisplaySpecVersion; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - using VULKAN_HPP_NAMESPACE::EXTDirectfbSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDirectfbSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_VALVE_mutable_descriptor_type === - using VULKAN_HPP_NAMESPACE::VALVEMutableDescriptorTypeExtensionName; - using VULKAN_HPP_NAMESPACE::VALVEMutableDescriptorTypeSpecVersion; - - //=== VK_EXT_vertex_input_dynamic_state === - using VULKAN_HPP_NAMESPACE::EXTVertexInputDynamicStateExtensionName; - using VULKAN_HPP_NAMESPACE::EXTVertexInputDynamicStateSpecVersion; - - //=== VK_EXT_physical_device_drm === - using VULKAN_HPP_NAMESPACE::EXTPhysicalDeviceDrmExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPhysicalDeviceDrmSpecVersion; - - //=== VK_EXT_device_address_binding_report === - using VULKAN_HPP_NAMESPACE::EXTDeviceAddressBindingReportExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDeviceAddressBindingReportSpecVersion; - - //=== VK_EXT_depth_clip_control === - using VULKAN_HPP_NAMESPACE::EXTDepthClipControlExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDepthClipControlSpecVersion; - - //=== VK_EXT_primitive_topology_list_restart === - using VULKAN_HPP_NAMESPACE::EXTPrimitiveTopologyListRestartExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPrimitiveTopologyListRestartSpecVersion; - - //=== VK_KHR_format_feature_flags2 === - using VULKAN_HPP_NAMESPACE::KHRFormatFeatureFlags2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRFormatFeatureFlags2SpecVersion; - - //=== VK_EXT_present_mode_fifo_latest_ready === - using VULKAN_HPP_NAMESPACE::EXTPresentModeFifoLatestReadyExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPresentModeFifoLatestReadySpecVersion; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - using VULKAN_HPP_NAMESPACE::FUCHSIAExternalMemoryExtensionName; - using VULKAN_HPP_NAMESPACE::FUCHSIAExternalMemorySpecVersion; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - using VULKAN_HPP_NAMESPACE::FUCHSIAExternalSemaphoreExtensionName; - using VULKAN_HPP_NAMESPACE::FUCHSIAExternalSemaphoreSpecVersion; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - using VULKAN_HPP_NAMESPACE::FUCHSIABufferCollectionExtensionName; - using VULKAN_HPP_NAMESPACE::FUCHSIABufferCollectionSpecVersion; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - using VULKAN_HPP_NAMESPACE::HUAWEISubpassShadingExtensionName; - using VULKAN_HPP_NAMESPACE::HUAWEISubpassShadingSpecVersion; - - //=== VK_HUAWEI_invocation_mask === - using VULKAN_HPP_NAMESPACE::HUAWEIInvocationMaskExtensionName; - using VULKAN_HPP_NAMESPACE::HUAWEIInvocationMaskSpecVersion; - - //=== VK_NV_external_memory_rdma === - using VULKAN_HPP_NAMESPACE::NVExternalMemoryRdmaExtensionName; - using VULKAN_HPP_NAMESPACE::NVExternalMemoryRdmaSpecVersion; - - //=== VK_EXT_pipeline_properties === - using VULKAN_HPP_NAMESPACE::EXTPipelinePropertiesExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPipelinePropertiesSpecVersion; - - //=== VK_EXT_frame_boundary === - using VULKAN_HPP_NAMESPACE::EXTFrameBoundaryExtensionName; - using VULKAN_HPP_NAMESPACE::EXTFrameBoundarySpecVersion; - - //=== VK_EXT_multisampled_render_to_single_sampled === - using VULKAN_HPP_NAMESPACE::EXTMultisampledRenderToSingleSampledExtensionName; - using VULKAN_HPP_NAMESPACE::EXTMultisampledRenderToSingleSampledSpecVersion; - - //=== VK_EXT_extended_dynamic_state2 === - using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicState2ExtensionName; - using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicState2SpecVersion; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - using VULKAN_HPP_NAMESPACE::QNXScreenSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::QNXScreenSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_EXT_color_write_enable === - using VULKAN_HPP_NAMESPACE::EXTColorWriteEnableExtensionName; - using VULKAN_HPP_NAMESPACE::EXTColorWriteEnableSpecVersion; - - //=== VK_EXT_primitives_generated_query === - using VULKAN_HPP_NAMESPACE::EXTPrimitivesGeneratedQueryExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPrimitivesGeneratedQuerySpecVersion; - - //=== VK_KHR_ray_tracing_maintenance1 === - using VULKAN_HPP_NAMESPACE::KHRRayTracingMaintenance1ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRRayTracingMaintenance1SpecVersion; - - //=== VK_KHR_shader_untyped_pointers === - using VULKAN_HPP_NAMESPACE::KHRShaderUntypedPointersExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderUntypedPointersSpecVersion; - - //=== VK_EXT_global_priority_query === - using VULKAN_HPP_NAMESPACE::EXTGlobalPriorityQueryExtensionName; - using VULKAN_HPP_NAMESPACE::EXTGlobalPriorityQuerySpecVersion; - using VULKAN_HPP_NAMESPACE::MaxGlobalPrioritySizeEXT; - - //=== VK_VALVE_video_encode_rgb_conversion === - using VULKAN_HPP_NAMESPACE::VALVEVideoEncodeRgbConversionExtensionName; - using VULKAN_HPP_NAMESPACE::VALVEVideoEncodeRgbConversionSpecVersion; - - //=== VK_EXT_image_view_min_lod === - using VULKAN_HPP_NAMESPACE::EXTImageViewMinLodExtensionName; - using VULKAN_HPP_NAMESPACE::EXTImageViewMinLodSpecVersion; - - //=== VK_EXT_multi_draw === - using VULKAN_HPP_NAMESPACE::EXTMultiDrawExtensionName; - using VULKAN_HPP_NAMESPACE::EXTMultiDrawSpecVersion; - - //=== VK_EXT_image_2d_view_of_3d === - using VULKAN_HPP_NAMESPACE::EXTImage2DViewOf3DExtensionName; - using VULKAN_HPP_NAMESPACE::EXTImage2DViewOf3DSpecVersion; - - //=== VK_KHR_portability_enumeration === - using VULKAN_HPP_NAMESPACE::KHRPortabilityEnumerationExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPortabilityEnumerationSpecVersion; - - //=== VK_EXT_shader_tile_image === - using VULKAN_HPP_NAMESPACE::EXTShaderTileImageExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderTileImageSpecVersion; - - //=== VK_EXT_opacity_micromap === - using VULKAN_HPP_NAMESPACE::EXTOpacityMicromapExtensionName; - using VULKAN_HPP_NAMESPACE::EXTOpacityMicromapSpecVersion; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_displacement_micromap === - using VULKAN_HPP_NAMESPACE::NVDisplacementMicromapExtensionName; - using VULKAN_HPP_NAMESPACE::NVDisplacementMicromapSpecVersion; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_load_store_op_none === - using VULKAN_HPP_NAMESPACE::EXTLoadStoreOpNoneExtensionName; - using VULKAN_HPP_NAMESPACE::EXTLoadStoreOpNoneSpecVersion; - - //=== VK_HUAWEI_cluster_culling_shader === - using VULKAN_HPP_NAMESPACE::HUAWEIClusterCullingShaderExtensionName; - using VULKAN_HPP_NAMESPACE::HUAWEIClusterCullingShaderSpecVersion; - - //=== VK_EXT_border_color_swizzle === - using VULKAN_HPP_NAMESPACE::EXTBorderColorSwizzleExtensionName; - using VULKAN_HPP_NAMESPACE::EXTBorderColorSwizzleSpecVersion; - - //=== VK_EXT_pageable_device_local_memory === - using VULKAN_HPP_NAMESPACE::EXTPageableDeviceLocalMemoryExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPageableDeviceLocalMemorySpecVersion; - - //=== VK_KHR_maintenance4 === - using VULKAN_HPP_NAMESPACE::KHRMaintenance4ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMaintenance4SpecVersion; - - //=== VK_ARM_shader_core_properties === - using VULKAN_HPP_NAMESPACE::ARMShaderCorePropertiesExtensionName; - using VULKAN_HPP_NAMESPACE::ARMShaderCorePropertiesSpecVersion; - - //=== VK_KHR_shader_subgroup_rotate === - using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupRotateExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderSubgroupRotateSpecVersion; - - //=== VK_ARM_scheduling_controls === - using VULKAN_HPP_NAMESPACE::ARMSchedulingControlsExtensionName; - using VULKAN_HPP_NAMESPACE::ARMSchedulingControlsSpecVersion; - - //=== VK_EXT_image_sliced_view_of_3d === - using VULKAN_HPP_NAMESPACE::EXTImageSlicedViewOf3DExtensionName; - using VULKAN_HPP_NAMESPACE::EXTImageSlicedViewOf3DSpecVersion; - using VULKAN_HPP_NAMESPACE::Remaining3DSlicesEXT; - - //=== VK_VALVE_descriptor_set_host_mapping === - using VULKAN_HPP_NAMESPACE::VALVEDescriptorSetHostMappingExtensionName; - using VULKAN_HPP_NAMESPACE::VALVEDescriptorSetHostMappingSpecVersion; - - //=== VK_EXT_depth_clamp_zero_one === - using VULKAN_HPP_NAMESPACE::EXTDepthClampZeroOneExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDepthClampZeroOneSpecVersion; - - //=== VK_EXT_non_seamless_cube_map === - using VULKAN_HPP_NAMESPACE::EXTNonSeamlessCubeMapExtensionName; - using VULKAN_HPP_NAMESPACE::EXTNonSeamlessCubeMapSpecVersion; - - //=== VK_ARM_render_pass_striped === - using VULKAN_HPP_NAMESPACE::ARMRenderPassStripedExtensionName; - using VULKAN_HPP_NAMESPACE::ARMRenderPassStripedSpecVersion; - - //=== VK_QCOM_fragment_density_map_offset === - using VULKAN_HPP_NAMESPACE::QCOMFragmentDensityMapOffsetExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMFragmentDensityMapOffsetSpecVersion; - - //=== VK_NV_copy_memory_indirect === - using VULKAN_HPP_NAMESPACE::NVCopyMemoryIndirectExtensionName; - using VULKAN_HPP_NAMESPACE::NVCopyMemoryIndirectSpecVersion; - - //=== VK_NV_memory_decompression === - using VULKAN_HPP_NAMESPACE::NVMemoryDecompressionExtensionName; - using VULKAN_HPP_NAMESPACE::NVMemoryDecompressionSpecVersion; - - //=== VK_NV_device_generated_commands_compute === - using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsComputeExtensionName; - using VULKAN_HPP_NAMESPACE::NVDeviceGeneratedCommandsComputeSpecVersion; - - //=== VK_NV_ray_tracing_linear_swept_spheres === - using VULKAN_HPP_NAMESPACE::NVRayTracingLinearSweptSpheresExtensionName; - using VULKAN_HPP_NAMESPACE::NVRayTracingLinearSweptSpheresSpecVersion; - - //=== VK_NV_linear_color_attachment === - using VULKAN_HPP_NAMESPACE::NVLinearColorAttachmentExtensionName; - using VULKAN_HPP_NAMESPACE::NVLinearColorAttachmentSpecVersion; - - //=== VK_GOOGLE_surfaceless_query === - using VULKAN_HPP_NAMESPACE::GOOGLESurfacelessQueryExtensionName; - using VULKAN_HPP_NAMESPACE::GOOGLESurfacelessQuerySpecVersion; - - //=== VK_KHR_shader_maximal_reconvergence === - using VULKAN_HPP_NAMESPACE::KHRShaderMaximalReconvergenceExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderMaximalReconvergenceSpecVersion; - - //=== VK_EXT_image_compression_control_swapchain === - using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlSwapchainExtensionName; - using VULKAN_HPP_NAMESPACE::EXTImageCompressionControlSwapchainSpecVersion; - - //=== VK_QCOM_image_processing === - using VULKAN_HPP_NAMESPACE::QCOMImageProcessingExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMImageProcessingSpecVersion; - - //=== VK_EXT_nested_command_buffer === - using VULKAN_HPP_NAMESPACE::EXTNestedCommandBufferExtensionName; - using VULKAN_HPP_NAMESPACE::EXTNestedCommandBufferSpecVersion; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - using VULKAN_HPP_NAMESPACE::OHOSExternalMemoryExtensionName; - using VULKAN_HPP_NAMESPACE::OHOSExternalMemorySpecVersion; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_external_memory_acquire_unmodified === - using VULKAN_HPP_NAMESPACE::EXTExternalMemoryAcquireUnmodifiedExtensionName; - using VULKAN_HPP_NAMESPACE::EXTExternalMemoryAcquireUnmodifiedSpecVersion; - - //=== VK_EXT_extended_dynamic_state3 === - using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicState3ExtensionName; - using VULKAN_HPP_NAMESPACE::EXTExtendedDynamicState3SpecVersion; - - //=== VK_EXT_subpass_merge_feedback === - using VULKAN_HPP_NAMESPACE::EXTSubpassMergeFeedbackExtensionName; - using VULKAN_HPP_NAMESPACE::EXTSubpassMergeFeedbackSpecVersion; - - //=== VK_LUNARG_direct_driver_loading === - using VULKAN_HPP_NAMESPACE::LUNARGDirectDriverLoadingExtensionName; - using VULKAN_HPP_NAMESPACE::LUNARGDirectDriverLoadingSpecVersion; - - //=== VK_ARM_tensors === - using VULKAN_HPP_NAMESPACE::ARMTensorsExtensionName; - using VULKAN_HPP_NAMESPACE::ARMTensorsSpecVersion; - - //=== VK_EXT_shader_module_identifier === - using VULKAN_HPP_NAMESPACE::EXTShaderModuleIdentifierExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderModuleIdentifierSpecVersion; - using VULKAN_HPP_NAMESPACE::MaxShaderModuleIdentifierSizeEXT; - - //=== VK_EXT_rasterization_order_attachment_access === - using VULKAN_HPP_NAMESPACE::EXTRasterizationOrderAttachmentAccessExtensionName; - using VULKAN_HPP_NAMESPACE::EXTRasterizationOrderAttachmentAccessSpecVersion; - - //=== VK_NV_optical_flow === - using VULKAN_HPP_NAMESPACE::NVOpticalFlowExtensionName; - using VULKAN_HPP_NAMESPACE::NVOpticalFlowSpecVersion; - - //=== VK_EXT_legacy_dithering === - using VULKAN_HPP_NAMESPACE::EXTLegacyDitheringExtensionName; - using VULKAN_HPP_NAMESPACE::EXTLegacyDitheringSpecVersion; - - //=== VK_EXT_pipeline_protected_access === - using VULKAN_HPP_NAMESPACE::EXTPipelineProtectedAccessExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPipelineProtectedAccessSpecVersion; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_format_resolve === - using VULKAN_HPP_NAMESPACE::ANDROIDExternalFormatResolveExtensionName; - using VULKAN_HPP_NAMESPACE::ANDROIDExternalFormatResolveSpecVersion; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - //=== VK_KHR_maintenance5 === - using VULKAN_HPP_NAMESPACE::KHRMaintenance5ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMaintenance5SpecVersion; - - //=== VK_AMD_anti_lag === - using VULKAN_HPP_NAMESPACE::AMDAntiLagExtensionName; - using VULKAN_HPP_NAMESPACE::AMDAntiLagSpecVersion; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_dense_geometry_format === - using VULKAN_HPP_NAMESPACE::AMDXDenseGeometryFormatExtensionName; - using VULKAN_HPP_NAMESPACE::AMDXDenseGeometryFormatSpecVersion; - using VULKAN_HPP_NAMESPACE::CompressedTriangleFormatDgf1ByteAlignmentAMDX; - using VULKAN_HPP_NAMESPACE::CompressedTriangleFormatDgf1ByteStrideAMDX; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_KHR_present_id2 === - using VULKAN_HPP_NAMESPACE::KHRPresentId2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPresentId2SpecVersion; - - //=== VK_KHR_present_wait2 === - using VULKAN_HPP_NAMESPACE::KHRPresentWait2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPresentWait2SpecVersion; - - //=== VK_KHR_ray_tracing_position_fetch === - using VULKAN_HPP_NAMESPACE::KHRRayTracingPositionFetchExtensionName; - using VULKAN_HPP_NAMESPACE::KHRRayTracingPositionFetchSpecVersion; - - //=== VK_EXT_shader_object === - using VULKAN_HPP_NAMESPACE::EXTShaderObjectExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderObjectSpecVersion; - - //=== VK_KHR_pipeline_binary === - using VULKAN_HPP_NAMESPACE::KHRPipelineBinaryExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPipelineBinarySpecVersion; - using VULKAN_HPP_NAMESPACE::MaxPipelineBinaryKeySizeKHR; - - //=== VK_QCOM_tile_properties === - using VULKAN_HPP_NAMESPACE::QCOMTilePropertiesExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMTilePropertiesSpecVersion; - - //=== VK_SEC_amigo_profiling === - using VULKAN_HPP_NAMESPACE::SECAmigoProfilingExtensionName; - using VULKAN_HPP_NAMESPACE::SECAmigoProfilingSpecVersion; - - //=== VK_KHR_surface_maintenance1 === - using VULKAN_HPP_NAMESPACE::KHRSurfaceMaintenance1ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSurfaceMaintenance1SpecVersion; - - //=== VK_KHR_swapchain_maintenance1 === - using VULKAN_HPP_NAMESPACE::KHRSwapchainMaintenance1ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRSwapchainMaintenance1SpecVersion; - - //=== VK_QCOM_multiview_per_view_viewports === - using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewViewportsExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewViewportsSpecVersion; - - //=== VK_NV_ray_tracing_invocation_reorder === - using VULKAN_HPP_NAMESPACE::NVRayTracingInvocationReorderExtensionName; - using VULKAN_HPP_NAMESPACE::NVRayTracingInvocationReorderSpecVersion; - - //=== VK_NV_cooperative_vector === - using VULKAN_HPP_NAMESPACE::NVCooperativeVectorExtensionName; - using VULKAN_HPP_NAMESPACE::NVCooperativeVectorSpecVersion; - - //=== VK_NV_extended_sparse_address_space === - using VULKAN_HPP_NAMESPACE::NVExtendedSparseAddressSpaceExtensionName; - using VULKAN_HPP_NAMESPACE::NVExtendedSparseAddressSpaceSpecVersion; - - //=== VK_EXT_mutable_descriptor_type === - using VULKAN_HPP_NAMESPACE::EXTMutableDescriptorTypeExtensionName; - using VULKAN_HPP_NAMESPACE::EXTMutableDescriptorTypeSpecVersion; - - //=== VK_EXT_legacy_vertex_attributes === - using VULKAN_HPP_NAMESPACE::EXTLegacyVertexAttributesExtensionName; - using VULKAN_HPP_NAMESPACE::EXTLegacyVertexAttributesSpecVersion; - - //=== VK_EXT_layer_settings === - using VULKAN_HPP_NAMESPACE::EXTLayerSettingsExtensionName; - using VULKAN_HPP_NAMESPACE::EXTLayerSettingsSpecVersion; - - //=== VK_ARM_shader_core_builtins === - using VULKAN_HPP_NAMESPACE::ARMShaderCoreBuiltinsExtensionName; - using VULKAN_HPP_NAMESPACE::ARMShaderCoreBuiltinsSpecVersion; - - //=== VK_EXT_pipeline_library_group_handles === - using VULKAN_HPP_NAMESPACE::EXTPipelineLibraryGroupHandlesExtensionName; - using VULKAN_HPP_NAMESPACE::EXTPipelineLibraryGroupHandlesSpecVersion; - - //=== VK_EXT_dynamic_rendering_unused_attachments === - using VULKAN_HPP_NAMESPACE::EXTDynamicRenderingUnusedAttachmentsExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDynamicRenderingUnusedAttachmentsSpecVersion; - - //=== VK_KHR_internally_synchronized_queues === - using VULKAN_HPP_NAMESPACE::KHRInternallySynchronizedQueuesExtensionName; - using VULKAN_HPP_NAMESPACE::KHRInternallySynchronizedQueuesSpecVersion; - - //=== VK_NV_low_latency2 === - using VULKAN_HPP_NAMESPACE::NVLowLatency2ExtensionName; - using VULKAN_HPP_NAMESPACE::NVLowLatency2SpecVersion; - - //=== VK_KHR_cooperative_matrix === - using VULKAN_HPP_NAMESPACE::KHRCooperativeMatrixExtensionName; - using VULKAN_HPP_NAMESPACE::KHRCooperativeMatrixSpecVersion; - - //=== VK_ARM_data_graph === - using VULKAN_HPP_NAMESPACE::ARMDataGraphExtensionName; - using VULKAN_HPP_NAMESPACE::ARMDataGraphSpecVersion; - using VULKAN_HPP_NAMESPACE::MaxPhysicalDeviceDataGraphOperationSetNameSizeARM; - - //=== VK_QCOM_multiview_per_view_render_areas === - using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMMultiviewPerViewRenderAreasSpecVersion; - - //=== VK_KHR_compute_shader_derivatives === - using VULKAN_HPP_NAMESPACE::KHRComputeShaderDerivativesExtensionName; - using VULKAN_HPP_NAMESPACE::KHRComputeShaderDerivativesSpecVersion; - - //=== VK_KHR_video_decode_av1 === - using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoDecodeAv1SpecVersion; - using VULKAN_HPP_NAMESPACE::MaxVideoAv1ReferencesPerFrameKHR; - - //=== VK_KHR_video_encode_av1 === - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeAv1ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeAv1SpecVersion; - - //=== VK_KHR_video_decode_vp9 === - using VULKAN_HPP_NAMESPACE::KHRVideoDecodeVp9ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoDecodeVp9SpecVersion; - using VULKAN_HPP_NAMESPACE::MaxVideoVp9ReferencesPerFrameKHR; - - //=== VK_KHR_video_maintenance1 === - using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance1SpecVersion; - - //=== VK_NV_per_stage_descriptor_set === - using VULKAN_HPP_NAMESPACE::NVPerStageDescriptorSetExtensionName; - using VULKAN_HPP_NAMESPACE::NVPerStageDescriptorSetSpecVersion; - - //=== VK_QCOM_image_processing2 === - using VULKAN_HPP_NAMESPACE::QCOMImageProcessing2ExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMImageProcessing2SpecVersion; - - //=== VK_QCOM_filter_cubic_weights === - using VULKAN_HPP_NAMESPACE::QCOMFilterCubicWeightsExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMFilterCubicWeightsSpecVersion; - - //=== VK_QCOM_ycbcr_degamma === - using VULKAN_HPP_NAMESPACE::QCOMYcbcrDegammaExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMYcbcrDegammaSpecVersion; - - //=== VK_QCOM_filter_cubic_clamp === - using VULKAN_HPP_NAMESPACE::QCOMFilterCubicClampExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMFilterCubicClampSpecVersion; - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopDynamicStateExtensionName; - using VULKAN_HPP_NAMESPACE::EXTAttachmentFeedbackLoopDynamicStateSpecVersion; - - //=== VK_KHR_vertex_attribute_divisor === - using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVertexAttributeDivisorSpecVersion; - - //=== VK_KHR_load_store_op_none === - using VULKAN_HPP_NAMESPACE::KHRLoadStoreOpNoneExtensionName; - using VULKAN_HPP_NAMESPACE::KHRLoadStoreOpNoneSpecVersion; - - //=== VK_KHR_unified_image_layouts === - using VULKAN_HPP_NAMESPACE::KHRUnifiedImageLayoutsExtensionName; - using VULKAN_HPP_NAMESPACE::KHRUnifiedImageLayoutsSpecVersion; - - //=== VK_KHR_shader_float_controls2 === - using VULKAN_HPP_NAMESPACE::KHRShaderFloatControls2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderFloatControls2SpecVersion; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - using VULKAN_HPP_NAMESPACE::QNXExternalMemoryScreenBufferExtensionName; - using VULKAN_HPP_NAMESPACE::QNXExternalMemoryScreenBufferSpecVersion; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_MSFT_layered_driver === - using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverExtensionName; - using VULKAN_HPP_NAMESPACE::MSFTLayeredDriverSpecVersion; - - //=== VK_KHR_index_type_uint8 === - using VULKAN_HPP_NAMESPACE::KHRIndexTypeUint8ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRIndexTypeUint8SpecVersion; - - //=== VK_KHR_line_rasterization === - using VULKAN_HPP_NAMESPACE::KHRLineRasterizationExtensionName; - using VULKAN_HPP_NAMESPACE::KHRLineRasterizationSpecVersion; - - //=== VK_KHR_calibrated_timestamps === - using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsExtensionName; - using VULKAN_HPP_NAMESPACE::KHRCalibratedTimestampsSpecVersion; - - //=== VK_KHR_shader_expect_assume === - using VULKAN_HPP_NAMESPACE::KHRShaderExpectAssumeExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderExpectAssumeSpecVersion; - - //=== VK_KHR_maintenance6 === - using VULKAN_HPP_NAMESPACE::KHRMaintenance6ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMaintenance6SpecVersion; - - //=== VK_NV_descriptor_pool_overallocation === - using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationExtensionName; - using VULKAN_HPP_NAMESPACE::NVDescriptorPoolOverallocationSpecVersion; - - //=== VK_QCOM_tile_memory_heap === - using VULKAN_HPP_NAMESPACE::QCOMTileMemoryHeapExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMTileMemoryHeapSpecVersion; - - //=== VK_KHR_copy_memory_indirect === - using VULKAN_HPP_NAMESPACE::KHRCopyMemoryIndirectExtensionName; - using VULKAN_HPP_NAMESPACE::KHRCopyMemoryIndirectSpecVersion; - - //=== VK_EXT_memory_decompression === - using VULKAN_HPP_NAMESPACE::EXTMemoryDecompressionExtensionName; - using VULKAN_HPP_NAMESPACE::EXTMemoryDecompressionSpecVersion; - - //=== VK_NV_display_stereo === - using VULKAN_HPP_NAMESPACE::NVDisplayStereoExtensionName; - using VULKAN_HPP_NAMESPACE::NVDisplayStereoSpecVersion; - - //=== VK_KHR_video_encode_intra_refresh === - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeIntraRefreshExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeIntraRefreshSpecVersion; - - //=== VK_KHR_video_encode_quantization_map === - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeQuantizationMapExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoEncodeQuantizationMapSpecVersion; - - //=== VK_NV_raw_access_chains === - using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName; - using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion; - - //=== VK_NV_external_compute_queue === - using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueExtensionName; - using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueSpecVersion; - - //=== VK_KHR_shader_relaxed_extended_instruction === - using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionSpecVersion; - - //=== VK_NV_command_buffer_inheritance === - using VULKAN_HPP_NAMESPACE::NVCommandBufferInheritanceExtensionName; - using VULKAN_HPP_NAMESPACE::NVCommandBufferInheritanceSpecVersion; - - //=== VK_KHR_maintenance7 === - using VULKAN_HPP_NAMESPACE::KHRMaintenance7ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMaintenance7SpecVersion; - - //=== VK_NV_shader_atomic_float16_vector === - using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorExtensionName; - using VULKAN_HPP_NAMESPACE::NVShaderAtomicFloat16VectorSpecVersion; - - //=== VK_EXT_shader_replicated_composites === - using VULKAN_HPP_NAMESPACE::EXTShaderReplicatedCompositesExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderReplicatedCompositesSpecVersion; - - //=== VK_EXT_shader_float8 === - using VULKAN_HPP_NAMESPACE::EXTShaderFloat8ExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderFloat8SpecVersion; - - //=== VK_NV_ray_tracing_validation === - using VULKAN_HPP_NAMESPACE::NVRayTracingValidationExtensionName; - using VULKAN_HPP_NAMESPACE::NVRayTracingValidationSpecVersion; - - //=== VK_NV_cluster_acceleration_structure === - using VULKAN_HPP_NAMESPACE::NVClusterAccelerationStructureExtensionName; - using VULKAN_HPP_NAMESPACE::NVClusterAccelerationStructureSpecVersion; - - //=== VK_NV_partitioned_acceleration_structure === - using VULKAN_HPP_NAMESPACE::NVPartitionedAccelerationStructureExtensionName; - using VULKAN_HPP_NAMESPACE::NVPartitionedAccelerationStructureSpecVersion; - using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructurePartitionIndexGlobalNV; - - //=== VK_EXT_device_generated_commands === - using VULKAN_HPP_NAMESPACE::EXTDeviceGeneratedCommandsExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDeviceGeneratedCommandsSpecVersion; - - //=== VK_KHR_maintenance8 === - using VULKAN_HPP_NAMESPACE::KHRMaintenance8ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMaintenance8SpecVersion; - - //=== VK_MESA_image_alignment_control === - using VULKAN_HPP_NAMESPACE::MESAImageAlignmentControlExtensionName; - using VULKAN_HPP_NAMESPACE::MESAImageAlignmentControlSpecVersion; - - //=== VK_KHR_shader_fma === - using VULKAN_HPP_NAMESPACE::KHRShaderFmaExtensionName; - using VULKAN_HPP_NAMESPACE::KHRShaderFmaSpecVersion; - - //=== VK_NV_push_constant_bank === - using VULKAN_HPP_NAMESPACE::NVPushConstantBankExtensionName; - using VULKAN_HPP_NAMESPACE::NVPushConstantBankSpecVersion; - - //=== VK_EXT_ray_tracing_invocation_reorder === - using VULKAN_HPP_NAMESPACE::EXTRayTracingInvocationReorderExtensionName; - using VULKAN_HPP_NAMESPACE::EXTRayTracingInvocationReorderSpecVersion; - - //=== VK_EXT_depth_clamp_control === - using VULKAN_HPP_NAMESPACE::EXTDepthClampControlExtensionName; - using VULKAN_HPP_NAMESPACE::EXTDepthClampControlSpecVersion; - - //=== VK_KHR_maintenance9 === - using VULKAN_HPP_NAMESPACE::KHRMaintenance9ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMaintenance9SpecVersion; - - //=== VK_KHR_video_maintenance2 === - using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRVideoMaintenance2SpecVersion; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - using VULKAN_HPP_NAMESPACE::OHOSSurfaceExtensionName; - using VULKAN_HPP_NAMESPACE::OHOSSurfaceSpecVersion; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_HUAWEI_hdr_vivid === - using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividExtensionName; - using VULKAN_HPP_NAMESPACE::HUAWEIHdrVividSpecVersion; - - //=== VK_NV_cooperative_matrix2 === - using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2ExtensionName; - using VULKAN_HPP_NAMESPACE::NVCooperativeMatrix2SpecVersion; - - //=== VK_ARM_pipeline_opacity_micromap === - using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapExtensionName; - using VULKAN_HPP_NAMESPACE::ARMPipelineOpacityMicromapSpecVersion; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - using VULKAN_HPP_NAMESPACE::EXTExternalMemoryMetalExtensionName; - using VULKAN_HPP_NAMESPACE::EXTExternalMemoryMetalSpecVersion; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_depth_clamp_zero_one === - using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneExtensionName; - using VULKAN_HPP_NAMESPACE::KHRDepthClampZeroOneSpecVersion; - - //=== VK_ARM_performance_counters_by_region === - using VULKAN_HPP_NAMESPACE::ARMPerformanceCountersByRegionExtensionName; - using VULKAN_HPP_NAMESPACE::ARMPerformanceCountersByRegionSpecVersion; - - //=== VK_EXT_vertex_attribute_robustness === - using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessExtensionName; - using VULKAN_HPP_NAMESPACE::EXTVertexAttributeRobustnessSpecVersion; - - //=== VK_ARM_format_pack === - using VULKAN_HPP_NAMESPACE::ARMFormatPackExtensionName; - using VULKAN_HPP_NAMESPACE::ARMFormatPackSpecVersion; - - //=== VK_VALVE_fragment_density_map_layered === - using VULKAN_HPP_NAMESPACE::VALVEFragmentDensityMapLayeredExtensionName; - using VULKAN_HPP_NAMESPACE::VALVEFragmentDensityMapLayeredSpecVersion; - - //=== VK_KHR_robustness2 === - using VULKAN_HPP_NAMESPACE::KHRRobustness2ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRRobustness2SpecVersion; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_present_metering === - using VULKAN_HPP_NAMESPACE::NVPresentMeteringExtensionName; - using VULKAN_HPP_NAMESPACE::NVPresentMeteringSpecVersion; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_fragment_density_map_offset === - using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetExtensionName; - using VULKAN_HPP_NAMESPACE::EXTFragmentDensityMapOffsetSpecVersion; - - //=== VK_EXT_zero_initialize_device_memory === - using VULKAN_HPP_NAMESPACE::EXTZeroInitializeDeviceMemoryExtensionName; - using VULKAN_HPP_NAMESPACE::EXTZeroInitializeDeviceMemorySpecVersion; - - //=== VK_KHR_present_mode_fifo_latest_ready === - using VULKAN_HPP_NAMESPACE::KHRPresentModeFifoLatestReadyExtensionName; - using VULKAN_HPP_NAMESPACE::KHRPresentModeFifoLatestReadySpecVersion; - - //=== VK_EXT_shader_64bit_indexing === - using VULKAN_HPP_NAMESPACE::EXTShader64BitIndexingExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShader64BitIndexingSpecVersion; - - //=== VK_EXT_custom_resolve === - using VULKAN_HPP_NAMESPACE::EXTCustomResolveExtensionName; - using VULKAN_HPP_NAMESPACE::EXTCustomResolveSpecVersion; - - //=== VK_QCOM_data_graph_model === - using VULKAN_HPP_NAMESPACE::DataGraphModelToolchainVersionLengthQCOM; - using VULKAN_HPP_NAMESPACE::QCOMDataGraphModelExtensionName; - using VULKAN_HPP_NAMESPACE::QCOMDataGraphModelSpecVersion; - - //=== VK_KHR_maintenance10 === - using VULKAN_HPP_NAMESPACE::KHRMaintenance10ExtensionName; - using VULKAN_HPP_NAMESPACE::KHRMaintenance10SpecVersion; - - //=== VK_EXT_shader_long_vector === - using VULKAN_HPP_NAMESPACE::EXTShaderLongVectorExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderLongVectorSpecVersion; - - //=== VK_SEC_pipeline_cache_incremental_mode === - using VULKAN_HPP_NAMESPACE::SECPipelineCacheIncrementalModeExtensionName; - using VULKAN_HPP_NAMESPACE::SECPipelineCacheIncrementalModeSpecVersion; - - //=== VK_EXT_shader_uniform_buffer_unsized_array === - using VULKAN_HPP_NAMESPACE::EXTShaderUniformBufferUnsizedArrayExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderUniformBufferUnsizedArraySpecVersion; - - //=== VK_NV_compute_occupancy_priority === - using VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityHighNV; - using VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityLowNV; - using VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityNormalNV; - using VULKAN_HPP_NAMESPACE::NVComputeOccupancyPriorityExtensionName; - using VULKAN_HPP_NAMESPACE::NVComputeOccupancyPrioritySpecVersion; - - //=== VK_EXT_shader_subgroup_partitioned === - using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupPartitionedExtensionName; - using VULKAN_HPP_NAMESPACE::EXTShaderSubgroupPartitionedSpecVersion; - - //======================== - //=== CONSTEXPR VALUEs === - //======================== - using VULKAN_HPP_NAMESPACE::HeaderVersion; - using VULKAN_HPP_NAMESPACE::Use64BitPtrDefines; - - //========================= - //=== CONSTEXPR CALLEEs === - //========================= - using VULKAN_HPP_NAMESPACE::apiVersionMajor; - using VULKAN_HPP_NAMESPACE::apiVersionMinor; - using VULKAN_HPP_NAMESPACE::apiVersionPatch; - using VULKAN_HPP_NAMESPACE::apiVersionVariant; - using VULKAN_HPP_NAMESPACE::makeApiVersion; - using VULKAN_HPP_NAMESPACE::makeVersion; - using VULKAN_HPP_NAMESPACE::versionMajor; - using VULKAN_HPP_NAMESPACE::versionMinor; - using VULKAN_HPP_NAMESPACE::versionPatch; - - //========================== - //=== CONSTEXPR CALLERs === - //========================== - 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::ApiVersion14; - using VULKAN_HPP_NAMESPACE::HeaderVersionComplete; - - //==================== - //=== FUNCPOINTERs === - //==================== - - //=== VK_VERSION_1_0 === - using VULKAN_HPP_NAMESPACE::PFN_AllocationFunction; - using VULKAN_HPP_NAMESPACE::PFN_FreeFunction; - using VULKAN_HPP_NAMESPACE::PFN_InternalAllocationNotification; - using VULKAN_HPP_NAMESPACE::PFN_InternalFreeNotification; - using VULKAN_HPP_NAMESPACE::PFN_ReallocationFunction; - using VULKAN_HPP_NAMESPACE::PFN_VoidFunction; - - //=== VK_EXT_debug_report === - using VULKAN_HPP_NAMESPACE::PFN_DebugReportCallbackEXT; - - //=== VK_EXT_debug_utils === - using VULKAN_HPP_NAMESPACE::PFN_DebugUtilsMessengerCallbackEXT; - - //=== VK_EXT_device_memory_report === - using VULKAN_HPP_NAMESPACE::PFN_DeviceMemoryReportCallbackEXT; - - //=== VK_LUNARG_direct_driver_loading === - using VULKAN_HPP_NAMESPACE::PFN_GetInstanceProcAddrLUNARG; - - //=============== - //=== 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_VERSION_1_4 === - using VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo; - using VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfoKHR; - using VULKAN_HPP_NAMESPACE::BindMemoryStatus; - using VULKAN_HPP_NAMESPACE::BindMemoryStatusKHR; - using VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfo; - using VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfoKHR; - using VULKAN_HPP_NAMESPACE::CopyImageToImageInfo; - using VULKAN_HPP_NAMESPACE::CopyImageToImageInfoEXT; - using VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo; - using VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfoEXT; - using VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo; - using VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfoEXT; - using VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo; - using VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfoKHR; - using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfo; - using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoEXT; - using VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQuery; - using VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQueryEXT; - using VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo; - using VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfoEXT; - using VULKAN_HPP_NAMESPACE::ImageSubresource2; - using VULKAN_HPP_NAMESPACE::ImageSubresource2EXT; - using VULKAN_HPP_NAMESPACE::ImageSubresource2KHR; - using VULKAN_HPP_NAMESPACE::ImageToMemoryCopy; - using VULKAN_HPP_NAMESPACE::ImageToMemoryCopyEXT; - using VULKAN_HPP_NAMESPACE::MemoryMapInfo; - using VULKAN_HPP_NAMESPACE::MemoryMapInfoKHR; - using VULKAN_HPP_NAMESPACE::MemoryToImageCopy; - using VULKAN_HPP_NAMESPACE::MemoryToImageCopyEXT; - using VULKAN_HPP_NAMESPACE::MemoryUnmapInfo; - using VULKAN_HPP_NAMESPACE::MemoryUnmapInfoKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeatures; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeatures; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeatures; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyProperties; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyPropertiesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8Features; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8FeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeatures; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationProperties; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationPropertiesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Features; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5FeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Properties; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5PropertiesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Features; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6FeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Properties; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6PropertiesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeatures; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeatures; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessProperties; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessPropertiesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorProperties; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorPropertiesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeatures; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2Features; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2FeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeatures; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeatures; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorProperties; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Features; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Properties; - using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfo; - using VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfoKHR; - using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfo; - using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoEXT; - using VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfo; - using VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfoEXT; - using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfo; - using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoEXT; - using VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::PushConstantsInfo; - using VULKAN_HPP_NAMESPACE::PushConstantsInfoKHR; - using VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo; - using VULKAN_HPP_NAMESPACE::PushDescriptorSetInfoKHR; - using VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo; - using VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfoKHR; - using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityProperties; - using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesEXT; - using VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityPropertiesKHR; - using VULKAN_HPP_NAMESPACE::RenderingAreaInfo; - using VULKAN_HPP_NAMESPACE::RenderingAreaInfoKHR; - using VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo; - using VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfoKHR; - using VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo; - using VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfoKHR; - using VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySize; - using VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySizeEXT; - using VULKAN_HPP_NAMESPACE::SubresourceLayout2; - using VULKAN_HPP_NAMESPACE::SubresourceLayout2EXT; - using VULKAN_HPP_NAMESPACE::SubresourceLayout2KHR; - using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescription; - using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionEXT; - using VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescriptionKHR; - - //=== 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; - using VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX; - - //=== VK_NVX_image_view_handle === - using VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX; - using VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX; - - //=== VK_KHR_video_encode_h264 === - using VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR; - - //=== VK_KHR_video_encode_h265 === - using VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR; - - //=== 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; - -#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; - -#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_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::MultiviewPerViewAttributesInfoNVX; - 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_IMG_relaxed_line_rasterization === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG; - - //=== 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*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - using VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstAMDX; - using VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX; - using VULKAN_HPP_NAMESPACE::DispatchGraphInfoAMDX; - using VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX; - using VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX; - using VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - using VULKAN_HPP_NAMESPACE::BindHeapInfoEXT; - using VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT; - using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT; - using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceDataEXT; - using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT; - using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT; - using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT; - using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT; - using VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT; - using VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT; - using VULKAN_HPP_NAMESPACE::DescriptorSetAndBindingMappingEXT; - using VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT; - using VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT; - using VULKAN_HPP_NAMESPACE::HostAddressRangeEXT; - using VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV; - using VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM; - using VULKAN_HPP_NAMESPACE::PushDataInfoEXT; - using VULKAN_HPP_NAMESPACE::ResourceDescriptorDataEXT; - using VULKAN_HPP_NAMESPACE::ResourceDescriptorInfoEXT; - using VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT; - using VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT; - using VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT; - using VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM; - using VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT; - - //=== VK_AMD_mixed_attachment_samples === - using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD; - using VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoNV; - - //=== VK_KHR_shader_bfloat16 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR; - - //=== 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_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_AMD_memory_overallocation_behavior === - using VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD; - - //=== VK_EXT_vertex_attribute_divisor === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_frame_token === - using VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== 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::CheckpointData2NV; - using VULKAN_HPP_NAMESPACE::CheckpointDataNV; - using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV; - using VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV; - - //=== VK_EXT_present_timing === - using VULKAN_HPP_NAMESPACE::PastPresentationTimingEXT; - using VULKAN_HPP_NAMESPACE::PastPresentationTimingInfoEXT; - using VULKAN_HPP_NAMESPACE::PastPresentationTimingPropertiesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentTimingFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PresentStageTimeEXT; - using VULKAN_HPP_NAMESPACE::PresentTimingInfoEXT; - using VULKAN_HPP_NAMESPACE::PresentTimingsInfoEXT; - using VULKAN_HPP_NAMESPACE::PresentTimingSurfaceCapabilitiesEXT; - using VULKAN_HPP_NAMESPACE::SwapchainCalibratedTimestampInfoEXT; - using VULKAN_HPP_NAMESPACE::SwapchainTimeDomainPropertiesEXT; - using VULKAN_HPP_NAMESPACE::SwapchainTimingPropertiesEXT; - - //=== 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::RenderingFragmentDensityMapAttachmentInfoEXT; - 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; - using VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR; - - //=== 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_KHR_shader_quad_control === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR; - - //=== 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_shader_atomic_float === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT; - - //=== 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_EXT_map_memory_placed === - using VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT; - - //=== VK_EXT_shader_atomic_float2 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT; - - //=== 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_custom_border_color === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT; - using VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorCreateInfoEXT; - - //=== VK_EXT_texture_compression_astc_3d === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT; - - //=== 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; - - //=== 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; - - //=== VK_NV_device_diagnostics_config === - using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - using VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV; - using VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV; - using VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - using VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM; - using VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM; - using VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM; - using VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM; - - //=== 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_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::PhysicalDeviceImageCompressionControlFeaturesEXT; - - //=== 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_frame_boundary === - using VULKAN_HPP_NAMESPACE::FrameBoundaryEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT; - - //=== 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_KHR_shader_untyped_pointers === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR; - - //=== VK_VALVE_video_encode_rgb_conversion === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; - using VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE; - using VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE; - using VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE; - - //=== 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; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; - - //=== 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_ARM_scheduling_controls === - using VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM; - - //=== 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_non_seamless_cube_map === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; - - //=== VK_ARM_render_pass_striped === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM; - using VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM; - using VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM; - using VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM; - - //=== VK_NV_copy_memory_indirect === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV; - - //=== VK_NV_memory_decompression === - using VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV; - - //=== VK_NV_device_generated_commands_compute === - using VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV; - using VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; - using VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV; - - //=== VK_NV_ray_tracing_linear_swept_spheres === - using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV; - using VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; - - //=== VK_NV_linear_color_attachment === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV; - - //=== VK_KHR_shader_maximal_reconvergence === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; - - //=== 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_nested_command_buffer === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - using VULKAN_HPP_NAMESPACE::ExternalFormatOHOS; - using VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS; - using VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS; - using VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS; - using VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS; - using VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== 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_ARM_tensors === - using VULKAN_HPP_NAMESPACE::BindTensorMemoryInfoARM; - using VULKAN_HPP_NAMESPACE::CopyTensorInfoARM; - using VULKAN_HPP_NAMESPACE::DescriptorGetTensorInfoARM; - using VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM; - using VULKAN_HPP_NAMESPACE::ExternalMemoryTensorCreateInfoARM; - using VULKAN_HPP_NAMESPACE::ExternalTensorPropertiesARM; - using VULKAN_HPP_NAMESPACE::FrameBoundaryTensorsARM; - using VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoTensorARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorFeaturesARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorPropertiesARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalTensorInfoARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorFeaturesARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorPropertiesARM; - using VULKAN_HPP_NAMESPACE::TensorCaptureDescriptorDataInfoARM; - using VULKAN_HPP_NAMESPACE::TensorCopyARM; - using VULKAN_HPP_NAMESPACE::TensorCreateInfoARM; - using VULKAN_HPP_NAMESPACE::TensorDependencyInfoARM; - using VULKAN_HPP_NAMESPACE::TensorDescriptionARM; - using VULKAN_HPP_NAMESPACE::TensorFormatPropertiesARM; - using VULKAN_HPP_NAMESPACE::TensorMemoryBarrierARM; - using VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM; - using VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM; - using VULKAN_HPP_NAMESPACE::WriteDescriptorSetTensorARM; - - //=== 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; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_format_resolve === - using VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - //=== VK_AMD_anti_lag === - using VULKAN_HPP_NAMESPACE::AntiLagDataAMD; - using VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_dense_geometry_format === - using VULKAN_HPP_NAMESPACE::AccelerationStructureDenseGeometryFormatTrianglesDataAMDX; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_KHR_present_id2 === - using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentId2FeaturesKHR; - using VULKAN_HPP_NAMESPACE::PresentId2KHR; - using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentId2KHR; - - //=== VK_KHR_present_wait2 === - using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWait2FeaturesKHR; - using VULKAN_HPP_NAMESPACE::PresentWait2InfoKHR; - using VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentWait2KHR; - - //=== 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_KHR_pipeline_binary === - using VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR; - using VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR; - using VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR; - using VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR; - using VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR; - using VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR; - using VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR; - using VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR; - - //=== 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_KHR_surface_maintenance1 === - using VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityEXT; - using VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityKHR; - using VULKAN_HPP_NAMESPACE::SurfacePresentModeEXT; - using VULKAN_HPP_NAMESPACE::SurfacePresentModeKHR; - using VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesEXT; - using VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesKHR; - - //=== VK_KHR_swapchain_maintenance1 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesKHR; - using VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoEXT; - using VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoKHR; - using VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoEXT; - using VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoKHR; - using VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoEXT; - using VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoKHR; - using VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoEXT; - using VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoEXT; - using VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoKHR; - - //=== 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_NV_cooperative_vector === - using VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV; - using VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV; - - //=== VK_NV_extended_sparse_address_space === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV; - - //=== 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_EXT_legacy_vertex_attributes === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT; - - //=== VK_EXT_layer_settings === - using VULKAN_HPP_NAMESPACE::LayerSettingEXT; - using VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT; - - //=== 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_internally_synchronized_queues === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; - - //=== VK_NV_low_latency2 === - using VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV; - using VULKAN_HPP_NAMESPACE::LatencySleepInfoNV; - using VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV; - using VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV; - using VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV; - using VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV; - using VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV; - using VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV; - using VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV; - - //=== VK_KHR_cooperative_matrix === - using VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR; - - //=== VK_ARM_data_graph === - using VULKAN_HPP_NAMESPACE::BindDataGraphPipelineSessionMemoryInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineCreateInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineIdentifierCreateInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyQueryResultARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementsInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionMemoryRequirementsInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphPipelineShaderModuleCreateInfoARM; - using VULKAN_HPP_NAMESPACE::DataGraphProcessingEngineCreateInfoARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphFeaturesARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineARM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; - using VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphProcessingEnginePropertiesARM; - using VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphPropertiesARM; - - //=== VK_QCOM_multiview_per_view_render_areas === - using VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; - - //=== VK_KHR_compute_shader_derivatives === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesPropertiesKHR; - - //=== VK_KHR_video_decode_av1 === - using VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR; - using VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR; - - //=== VK_KHR_video_encode_av1 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR; - - //=== VK_KHR_video_decode_vp9 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoDecodeVP9FeaturesKHR; - using VULKAN_HPP_NAMESPACE::VideoDecodeVP9CapabilitiesKHR; - using VULKAN_HPP_NAMESPACE::VideoDecodeVP9PictureInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoDecodeVP9ProfileInfoKHR; - - //=== VK_KHR_video_maintenance1 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR; - using VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR; - - //=== VK_NV_per_stage_descriptor_set === - using VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV; - - //=== VK_QCOM_image_processing2 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM; - using VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM; - - //=== VK_QCOM_filter_cubic_weights === - using VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM; - using VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM; - - //=== VK_QCOM_ycbcr_degamma === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM; - using VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; - - //=== VK_QCOM_filter_cubic_clamp === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM; - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; - - //=== VK_KHR_unified_image_layouts === - using VULKAN_HPP_NAMESPACE::AttachmentFeedbackLoopInfoEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceUnifiedImageLayoutsFeaturesKHR; - -#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*/ - - //=== VK_MSFT_layered_driver === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT; - - //=== VK_KHR_calibrated_timestamps === - using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoEXT; - using VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR; - - //=== VK_KHR_maintenance6 === - using VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT; - using VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT; - - //=== VK_NV_descriptor_pool_overallocation === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; - - //=== VK_QCOM_tile_memory_heap === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM; - using VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM; - using VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM; - using VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM; - - //=== VK_KHR_copy_memory_indirect === - using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR; - using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandNV; - using VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR; - using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR; - using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandNV; - using VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesNV; - using VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR; - - //=== VK_EXT_memory_decompression === - using VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT; - using VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesNV; - - //=== VK_NV_display_stereo === - using VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV; - using VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV; - - //=== VK_KHR_video_encode_intra_refresh === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshCapabilitiesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeSessionIntraRefreshCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoReferenceIntraRefreshInfoKHR; - - //=== VK_KHR_video_encode_quantization_map === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR; - using VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR; - using VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR; - - //=== VK_NV_raw_access_chains === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV; - - //=== VK_NV_external_compute_queue === - using VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV; - using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV; - using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV; - - //=== VK_KHR_shader_relaxed_extended_instruction === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; - - //=== VK_NV_command_buffer_inheritance === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCommandBufferInheritanceFeaturesNV; - - //=== VK_KHR_maintenance7 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR; - - //=== VK_NV_shader_atomic_float16_vector === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; - - //=== VK_EXT_shader_replicated_composites === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT; - - //=== VK_EXT_shader_float8 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat8FeaturesEXT; - - //=== VK_NV_ray_tracing_validation === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV; - - //=== VK_NV_cluster_acceleration_structure === - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGetTemplateIndicesInfoNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV; - using VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV; - using VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV; - using VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV; - - //=== VK_NV_partitioned_acceleration_structure === - using VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV; - using VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV; - using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV; - using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV; - using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV; - using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV; - using VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV; - using VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV; - - //=== VK_EXT_device_generated_commands === - using VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT; - using VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT; - using VULKAN_HPP_NAMESPACE::DrawIndirectCountIndirectCommandEXT; - using VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT; - using VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoEXT; - using VULKAN_HPP_NAMESPACE::GeneratedCommandsPipelineInfoEXT; - using VULKAN_HPP_NAMESPACE::GeneratedCommandsShaderInfoEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsExecutionSetTokenEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsIndexBufferTokenEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsPushConstantTokenEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsTokenDataEXT; - using VULKAN_HPP_NAMESPACE::IndirectCommandsVertexBufferTokenEXT; - using VULKAN_HPP_NAMESPACE::IndirectExecutionSetCreateInfoEXT; - using VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoEXT; - using VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT; - using VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT; - using VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; - using VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetPipelineEXT; - using VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT; - - //=== VK_KHR_maintenance8 === - using VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR; - - //=== VK_MESA_image_alignment_control === - using VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA; - - //=== VK_KHR_shader_fma === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR; - - //=== VK_NV_push_constant_bank === - using VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV; - using VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV; - - //=== VK_EXT_ray_tracing_invocation_reorder === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT; - - //=== VK_EXT_depth_clamp_control === - using VULKAN_HPP_NAMESPACE::DepthClampRangeEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT; - - //=== VK_KHR_maintenance9 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9FeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9PropertiesKHR; - using VULKAN_HPP_NAMESPACE::QueueFamilyOwnershipTransferPropertiesKHR; - - //=== VK_KHR_video_maintenance2 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR; - using VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR; - using VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - using VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_HUAWEI_hdr_vivid === - using VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI; - - //=== VK_NV_cooperative_matrix2 === - using VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV; - - //=== VK_ARM_pipeline_opacity_micromap === - using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - using VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT; - using VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT; - using VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_depth_clamp_zero_one === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR; - - //=== VK_ARM_performance_counters_by_region === - using VULKAN_HPP_NAMESPACE::PerformanceCounterARM; - using VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM; - using VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM; - - //=== VK_EXT_vertex_attribute_robustness === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT; - - //=== VK_ARM_format_pack === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM; - - //=== VK_VALVE_fragment_density_map_layered === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; - using VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE; - - //=== VK_KHR_robustness2 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_present_metering === - using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV; - using VULKAN_HPP_NAMESPACE::SetPresentConfigNV; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_fragment_density_map_offset === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; - using VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT; - using VULKAN_HPP_NAMESPACE::SubpassFragmentDensityMapOffsetEndInfoQCOM; - - //=== VK_EXT_zero_initialize_device_memory === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; - - //=== VK_KHR_present_mode_fifo_latest_ready === - using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; - - //=== VK_EXT_shader_64bit_indexing === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT; - - //=== VK_EXT_custom_resolve === - using VULKAN_HPP_NAMESPACE::BeginCustomResolveInfoEXT; - using VULKAN_HPP_NAMESPACE::CustomResolveCreateInfoEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomResolveFeaturesEXT; - - //=== VK_QCOM_data_graph_model === - using VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM; - using VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM; - - //=== VK_KHR_maintenance10 === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR; - using VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR; - using VULKAN_HPP_NAMESPACE::RenderingEndInfoEXT; - using VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR; - using VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR; - - //=== VK_EXT_shader_long_vector === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT; - - //=== VK_SEC_pipeline_cache_incremental_mode === - using VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; - - //=== VK_EXT_shader_uniform_buffer_unsized_array === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; - - //=== VK_NV_compute_occupancy_priority === - using VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityParametersNV; - using VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeOccupancyPriorityFeaturesNV; - - //=== VK_EXT_shader_subgroup_partitioned === - using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; - - //=============== - //=== 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_EXT_descriptor_heap === - using VULKAN_HPP_NAMESPACE::TensorARM; - - //=== 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_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - using VULKAN_HPP_NAMESPACE::CudaFunctionNV; - using VULKAN_HPP_NAMESPACE::CudaModuleNV; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#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_ARM_tensors === - using VULKAN_HPP_NAMESPACE::TensorARM; - using VULKAN_HPP_NAMESPACE::TensorViewARM; - - //=== VK_NV_optical_flow === - using VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV; - - //=== VK_EXT_shader_object === - using VULKAN_HPP_NAMESPACE::ShaderEXT; - - //=== VK_KHR_pipeline_binary === - using VULKAN_HPP_NAMESPACE::PipelineBinaryKHR; - - //=== VK_ARM_data_graph === - using VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM; - - //=== VK_NV_external_compute_queue === - using VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV; - - //=== VK_EXT_device_generated_commands === - using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT; - using VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT; - - //====================== - //=== 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_KHR_display === - using VULKAN_HPP_NAMESPACE::UniqueDisplayKHR; - - //=== 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_EXT_descriptor_heap === - using VULKAN_HPP_NAMESPACE::UniqueTensorARM; - - //=== 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_INTEL_performance_query === - using VULKAN_HPP_NAMESPACE::UniquePerformanceConfigurationINTEL; - - //=== VK_KHR_deferred_host_operations === - using VULKAN_HPP_NAMESPACE::UniqueDeferredOperationKHR; - - //=== VK_NV_device_generated_commands === - using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutNV; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - using VULKAN_HPP_NAMESPACE::UniqueCudaFunctionNV; - using VULKAN_HPP_NAMESPACE::UniqueCudaModuleNV; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# 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_ARM_tensors === - using VULKAN_HPP_NAMESPACE::UniqueTensorARM; - using VULKAN_HPP_NAMESPACE::UniqueTensorViewARM; - - //=== VK_NV_optical_flow === - using VULKAN_HPP_NAMESPACE::UniqueOpticalFlowSessionNV; - - //=== VK_EXT_shader_object === - using VULKAN_HPP_NAMESPACE::UniqueShaderEXT; - - //=== VK_KHR_pipeline_binary === - using VULKAN_HPP_NAMESPACE::UniquePipelineBinaryKHR; - - //=== VK_ARM_data_graph === - using VULKAN_HPP_NAMESPACE::UniqueDataGraphPipelineSessionARM; - - //=== VK_NV_external_compute_queue === - using VULKAN_HPP_NAMESPACE::UniqueExternalComputeQueueNV; - - //=== VK_EXT_device_generated_commands === - using VULKAN_HPP_NAMESPACE::UniqueHandleTraits; - using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutEXT; - using VULKAN_HPP_NAMESPACE::UniqueIndirectExecutionSetEXT; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - //====================== - //=== SHARED HANDLEs === - //====================== - -#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) - - //=== VK_VERSION_1_0 === - using VULKAN_HPP_NAMESPACE::SharedBuffer; - using VULKAN_HPP_NAMESPACE::SharedBufferView; - using VULKAN_HPP_NAMESPACE::SharedCommandBuffer; - using VULKAN_HPP_NAMESPACE::SharedCommandPool; - using VULKAN_HPP_NAMESPACE::SharedDescriptorPool; - using VULKAN_HPP_NAMESPACE::SharedDescriptorSet; - using VULKAN_HPP_NAMESPACE::SharedDescriptorSetLayout; - using VULKAN_HPP_NAMESPACE::SharedDevice; - using VULKAN_HPP_NAMESPACE::SharedDeviceMemory; - using VULKAN_HPP_NAMESPACE::SharedEvent; - using VULKAN_HPP_NAMESPACE::SharedFence; - using VULKAN_HPP_NAMESPACE::SharedFramebuffer; - using VULKAN_HPP_NAMESPACE::SharedImage; - using VULKAN_HPP_NAMESPACE::SharedImageView; - using VULKAN_HPP_NAMESPACE::SharedInstance; - using VULKAN_HPP_NAMESPACE::SharedPhysicalDevice; - using VULKAN_HPP_NAMESPACE::SharedPipeline; - using VULKAN_HPP_NAMESPACE::SharedPipelineCache; - using VULKAN_HPP_NAMESPACE::SharedPipelineLayout; - using VULKAN_HPP_NAMESPACE::SharedQueryPool; - using VULKAN_HPP_NAMESPACE::SharedQueue; - using VULKAN_HPP_NAMESPACE::SharedRenderPass; - using VULKAN_HPP_NAMESPACE::SharedSampler; - using VULKAN_HPP_NAMESPACE::SharedSemaphore; - using VULKAN_HPP_NAMESPACE::SharedShaderModule; - - //=== VK_VERSION_1_1 === - using VULKAN_HPP_NAMESPACE::SharedDescriptorUpdateTemplate; - using VULKAN_HPP_NAMESPACE::SharedSamplerYcbcrConversion; - - //=== VK_VERSION_1_3 === - using VULKAN_HPP_NAMESPACE::SharedPrivateDataSlot; - - //=== VK_KHR_surface === - using VULKAN_HPP_NAMESPACE::SharedSurfaceKHR; - - //=== VK_KHR_swapchain === - using VULKAN_HPP_NAMESPACE::SharedSwapchainKHR; - - //=== VK_KHR_display === - using VULKAN_HPP_NAMESPACE::SharedDisplayKHR; - using VULKAN_HPP_NAMESPACE::SharedDisplayModeKHR; - - //=== VK_EXT_debug_report === - using VULKAN_HPP_NAMESPACE::SharedDebugReportCallbackEXT; - - //=== VK_KHR_video_queue === - using VULKAN_HPP_NAMESPACE::SharedVideoSessionKHR; - using VULKAN_HPP_NAMESPACE::SharedVideoSessionParametersKHR; - - //=== VK_NVX_binary_import === - using VULKAN_HPP_NAMESPACE::SharedCuFunctionNVX; - using VULKAN_HPP_NAMESPACE::SharedCuModuleNVX; - - //=== VK_EXT_debug_utils === - using VULKAN_HPP_NAMESPACE::SharedDebugUtilsMessengerEXT; - - //=== VK_EXT_descriptor_heap === - using VULKAN_HPP_NAMESPACE::SharedTensorARM; - - //=== VK_KHR_acceleration_structure === - using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureKHR; - - //=== VK_EXT_validation_cache === - using VULKAN_HPP_NAMESPACE::SharedValidationCacheEXT; - - //=== VK_NV_ray_tracing === - using VULKAN_HPP_NAMESPACE::SharedAccelerationStructureNV; - - //=== VK_INTEL_performance_query === - using VULKAN_HPP_NAMESPACE::SharedPerformanceConfigurationINTEL; - - //=== VK_KHR_deferred_host_operations === - using VULKAN_HPP_NAMESPACE::SharedDeferredOperationKHR; - - //=== VK_NV_device_generated_commands === - using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutNV; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - using VULKAN_HPP_NAMESPACE::SharedCudaFunctionNV; - using VULKAN_HPP_NAMESPACE::SharedCudaModuleNV; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - using VULKAN_HPP_NAMESPACE::SharedBufferCollectionFUCHSIA; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_EXT_opacity_micromap === - using VULKAN_HPP_NAMESPACE::SharedMicromapEXT; - - //=== VK_ARM_tensors === - using VULKAN_HPP_NAMESPACE::SharedTensorARM; - using VULKAN_HPP_NAMESPACE::SharedTensorViewARM; - - //=== VK_NV_optical_flow === - using VULKAN_HPP_NAMESPACE::SharedOpticalFlowSessionNV; - - //=== VK_EXT_shader_object === - using VULKAN_HPP_NAMESPACE::SharedShaderEXT; - - //=== VK_KHR_pipeline_binary === - using VULKAN_HPP_NAMESPACE::SharedPipelineBinaryKHR; - - //=== VK_ARM_data_graph === - using VULKAN_HPP_NAMESPACE::SharedDataGraphPipelineSessionARM; - - //=== VK_NV_external_compute_queue === - using VULKAN_HPP_NAMESPACE::SharedExternalComputeQueueNV; - - //=== VK_EXT_device_generated_commands === - using VULKAN_HPP_NAMESPACE::SharedHandleTraits; - using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutEXT; - using VULKAN_HPP_NAMESPACE::SharedIndirectExecutionSetEXT; - - //=== VK_KHR_swapchain enum === - using VULKAN_HPP_NAMESPACE::SwapchainOwns; -#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 VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL - namespace detail - { - using VULKAN_HPP_NAMESPACE::detail::DynamicLoader; - } // namespace detail -#endif /*VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL*/ - - //===================== - //=== 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::getDepthFormats; - using VULKAN_HPP_NAMESPACE::getDepthStencilFormats; - using VULKAN_HPP_NAMESPACE::getStencilFormats; - using VULKAN_HPP_NAMESPACE::hasDepthComponent; - using VULKAN_HPP_NAMESPACE::hasStencilComponent; - 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; - -#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - namespace VULKAN_HPP_RAII_NAMESPACE - { - //====================== - //=== RAII HARDCODED === - //====================== - - using VULKAN_HPP_RAII_NAMESPACE::Context; - using VULKAN_HPP_RAII_NAMESPACE::isVulkanRAIIHandleType; - - namespace detail - { - using VULKAN_HPP_RAII_NAMESPACE::detail::ContextDispatcher; - using VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher; - using VULKAN_HPP_RAII_NAMESPACE::detail::InstanceDispatcher; - } // namespace detail - - //==================== - //=== 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_EXT_descriptor_heap === - using VULKAN_HPP_RAII_NAMESPACE::TensorARM; - - //=== 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_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - using VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV; - using VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# 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_ARM_tensors === - using VULKAN_HPP_RAII_NAMESPACE::TensorARM; - using VULKAN_HPP_RAII_NAMESPACE::TensorViewARM; - - //=== 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; - - //=== VK_KHR_pipeline_binary === - using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR; - using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHRs; - - //=== VK_ARM_data_graph === - using VULKAN_HPP_RAII_NAMESPACE::DataGraphPipelineSessionARM; - - //=== VK_NV_external_compute_queue === - using VULKAN_HPP_RAII_NAMESPACE::ExternalComputeQueueNV; - - //=== VK_EXT_device_generated_commands === - using VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutEXT; - using VULKAN_HPP_RAII_NAMESPACE::IndirectExecutionSetEXT; - - } // namespace VULKAN_HPP_RAII_NAMESPACE -#endif -} // namespace VULKAN_HPP_NAMESPACE - -export namespace std -{ - - //======================================= - //=== HASH specialization for Flags types === - //======================================= - - template - struct hash>; - - //======================================== - //=== HASH specializations for handles === - //======================================== - - //=== VK_VERSION_1_0 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_VERSION_1_1 === - template <> - struct hash; - template <> - struct hash; - - //=== VK_VERSION_1_3 === - template <> - struct hash; - - //=== VK_KHR_surface === - template <> - struct hash; - - //=== VK_KHR_swapchain === - template <> - struct hash; - - //=== VK_KHR_display === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_debug_report === - template <> - struct hash; - - //=== VK_KHR_video_queue === - template <> - struct hash; - template <> - struct hash; - - //=== VK_NVX_binary_import === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_debug_utils === - template <> - struct hash; - - //=== VK_EXT_descriptor_heap === - template <> - struct hash; - - //=== VK_KHR_acceleration_structure === - template <> - struct hash; - - //=== VK_EXT_validation_cache === - template <> - struct hash; - - //=== VK_NV_ray_tracing === - template <> - struct hash; - - //=== VK_INTEL_performance_query === - template <> - struct hash; - - //=== VK_KHR_deferred_host_operations === - template <> - struct hash; - - //=== VK_NV_device_generated_commands === - template <> - struct hash; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - template <> - struct hash; - template <> - struct hash; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_EXT_opacity_micromap === - template <> - struct hash; - - //=== VK_ARM_tensors === - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_optical_flow === - template <> - struct hash; - - //=== VK_EXT_shader_object === - template <> - struct hash; - - //=== VK_KHR_pipeline_binary === - template <> - struct hash; - - //=== VK_ARM_data_graph === - template <> - struct hash; - - //=== VK_NV_external_compute_queue === - template <> - struct hash; - - //=== VK_EXT_device_generated_commands === - template <> - struct hash; - template <> - struct hash; - - //======================================== - //=== HASH specializations for structs === - //======================================== - - //=== VK_VERSION_1_0 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_VERSION_1_1 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_VERSION_1_2 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_VERSION_1_3 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_VERSION_1_4 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_surface === - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_swapchain === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_display === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_display_swapchain === - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - template <> - struct hash; - - //=== VK_AMD_rasterization_order === - template <> - struct hash; - - //=== VK_EXT_debug_marker === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_queue === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_decode_queue === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_dedicated_allocation === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_transform_feedback === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NVX_binary_import === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NVX_image_view_handle === - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_encode_h264 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_encode_h265 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_decode_h264 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_AMD_texture_gather_bias_lod === - template <> - struct hash; - - //=== VK_AMD_shader_info === - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_corner_sampled_image === - template <> - struct hash; - - //=== VK_NV_external_memory_capabilities === - template <> - struct hash; - - //=== VK_NV_external_memory === - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_win32_keyed_mutex === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_device_group === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_validation_flags === - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_EXT_astc_decode_mode === - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_keyed_mutex === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_conditional_rendering === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_incremental_present === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_clip_space_w_scaling === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_display_surface_counter === - template <> - struct hash; - - //=== VK_EXT_display_control === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_GOOGLE_display_timing === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NVX_multiview_per_view_attributes === - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_viewport_swizzle === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_discard_rectangles === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_conservative_rasterization === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_depth_clip_enable === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_hdr_metadata === - template <> - struct hash; - template <> - struct hash; - - //=== VK_IMG_relaxed_line_rasterization === - template <> - struct hash; - - //=== VK_KHR_shared_presentable_image === - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_performance_query === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_get_surface_capabilities2 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_get_display_properties2 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_AMD_mixed_attachment_samples === - template <> - struct hash; - - //=== VK_KHR_shader_bfloat16 === - template <> - struct hash; - - //=== VK_EXT_sample_locations === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_blend_operation_advanced === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_fragment_coverage_to_color === - template <> - struct hash; - - //=== VK_KHR_acceleration_structure === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_ray_tracing_pipeline === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_ray_query === - template <> - struct hash; - - //=== VK_NV_framebuffer_mixed_samples === - template <> - struct hash; - - //=== VK_NV_shader_sm_builtins === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_image_drm_format_modifier === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_validation_cache === - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_KHR_portability_subset === - template <> - struct hash; - template <> - struct hash; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_NV_shading_rate_image === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_ray_tracing === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_representative_fragment_test === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_filter_cubic === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_external_memory_host === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_shader_clock === - template <> - struct hash; - - //=== VK_AMD_pipeline_compiler_control === - template <> - struct hash; - - //=== VK_AMD_shader_core_properties === - template <> - struct hash; - - //=== VK_KHR_video_decode_h265 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_AMD_memory_overallocation_behavior === - template <> - struct hash; - - //=== VK_EXT_vertex_attribute_divisor === - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_frame_token === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_mesh_shader === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_shader_image_footprint === - template <> - struct hash; - - //=== VK_NV_scissor_exclusive === - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_device_diagnostic_checkpoints === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_present_timing === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_INTEL_shader_integer_functions2 === - template <> - struct hash; - - //=== VK_INTEL_performance_query === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_pci_bus_info === - template <> - struct hash; - - //=== VK_AMD_display_native_hdr === - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_fragment_density_map === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_fragment_shading_rate === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_AMD_shader_core_properties2 === - template <> - struct hash; - - //=== VK_AMD_device_coherent_memory === - template <> - struct hash; - - //=== VK_EXT_shader_image_atomic_int64 === - template <> - struct hash; - - //=== VK_KHR_shader_quad_control === - template <> - struct hash; - - //=== VK_EXT_memory_budget === - template <> - struct hash; - - //=== VK_EXT_memory_priority === - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_surface_protected_capabilities === - template <> - struct hash; - - //=== VK_NV_dedicated_allocation_image_aliasing === - template <> - struct hash; - - //=== VK_EXT_buffer_device_address === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_validation_features === - template <> - struct hash; - - //=== VK_KHR_present_wait === - template <> - struct hash; - - //=== VK_NV_cooperative_matrix === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_coverage_reduction_mode === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_fragment_shader_interlock === - template <> - struct hash; - - //=== VK_EXT_ycbcr_image_arrays === - template <> - struct hash; - - //=== VK_EXT_provoking_vertex === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - template <> - struct hash; - - //=== VK_EXT_shader_atomic_float === - template <> - struct hash; - - //=== VK_EXT_extended_dynamic_state === - template <> - struct hash; - - //=== VK_KHR_pipeline_executable_properties === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_map_memory_placed === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_shader_atomic_float2 === - template <> - struct hash; - - //=== VK_NV_device_generated_commands === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_inherited_viewport_scissor === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_texel_buffer_alignment === - template <> - struct hash; - - //=== VK_QCOM_render_pass_transform === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_depth_bias_control === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_device_memory_report === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_custom_border_color === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_texture_compression_astc_3d === - template <> - struct hash; - - //=== VK_KHR_pipeline_library === - template <> - struct hash; - - //=== VK_NV_present_barrier === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_present_id === - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_encode_queue === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_device_diagnostics_config === - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_low_latency === - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_descriptor_buffer === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_graphics_pipeline_library === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_AMD_shader_early_and_late_fragment_tests === - template <> - struct hash; - - //=== VK_KHR_fragment_shader_barycentric === - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_shader_subgroup_uniform_control_flow === - template <> - struct hash; - - //=== VK_NV_fragment_shading_rate_enums === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_ray_tracing_motion_blur === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_mesh_shader === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_ycbcr_2plane_444_formats === - template <> - struct hash; - - //=== VK_EXT_fragment_density_map2 === - template <> - struct hash; - template <> - struct hash; - - //=== VK_QCOM_rotated_copy_commands === - template <> - struct hash; - - //=== VK_KHR_workgroup_memory_explicit_layout === - template <> - struct hash; - - //=== VK_EXT_image_compression_control === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_attachment_feedback_loop_layout === - template <> - struct hash; - - //=== VK_EXT_4444_formats === - template <> - struct hash; - - //=== VK_EXT_device_fault === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_rgba10x6_formats === - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_vertex_input_dynamic_state === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_physical_device_drm === - template <> - struct hash; - - //=== VK_EXT_device_address_binding_report === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_depth_clip_control === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_primitive_topology_list_restart === - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_HUAWEI_invocation_mask === - template <> - struct hash; - - //=== VK_NV_external_memory_rdma === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_pipeline_properties === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_frame_boundary === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_multisampled_render_to_single_sampled === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_extended_dynamic_state2 === - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_EXT_color_write_enable === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_primitives_generated_query === - template <> - struct hash; - - //=== VK_KHR_ray_tracing_maintenance1 === - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_shader_untyped_pointers === - template <> - struct hash; - - //=== VK_VALVE_video_encode_rgb_conversion === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_image_view_min_lod === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_multi_draw === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_image_2d_view_of_3d === - template <> - struct hash; - - //=== VK_EXT_shader_tile_image === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_opacity_micromap === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_displacement_micromap === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_HUAWEI_cluster_culling_shader === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_border_color_swizzle === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_pageable_device_local_memory === - template <> - struct hash; - - //=== VK_ARM_shader_core_properties === - template <> - struct hash; - - //=== VK_ARM_scheduling_controls === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_image_sliced_view_of_3d === - template <> - struct hash; - template <> - struct hash; - - //=== VK_VALVE_descriptor_set_host_mapping === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_non_seamless_cube_map === - template <> - struct hash; - - //=== VK_ARM_render_pass_striped === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_copy_memory_indirect === - template <> - struct hash; - - //=== VK_NV_memory_decompression === - template <> - struct hash; - - //=== VK_NV_device_generated_commands_compute === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_ray_tracing_linear_swept_spheres === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_linear_color_attachment === - template <> - struct hash; - - //=== VK_KHR_shader_maximal_reconvergence === - template <> - struct hash; - - //=== VK_EXT_image_compression_control_swapchain === - template <> - struct hash; - - //=== VK_QCOM_image_processing === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_nested_command_buffer === - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_external_memory_acquire_unmodified === - template <> - struct hash; - - //=== VK_EXT_extended_dynamic_state3 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_subpass_merge_feedback === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_LUNARG_direct_driver_loading === - template <> - struct hash; - template <> - struct hash; - - //=== VK_ARM_tensors === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_shader_module_identifier === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_rasterization_order_attachment_access === - template <> - struct hash; - - //=== VK_NV_optical_flow === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_legacy_dithering === - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_format_resolve === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - //=== VK_AMD_anti_lag === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_dense_geometry_format === - template <> - struct hash; - template <> - struct hash; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_KHR_present_id2 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_present_wait2 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_ray_tracing_position_fetch === - template <> - struct hash; - - //=== VK_EXT_shader_object === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_pipeline_binary === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_QCOM_tile_properties === - template <> - struct hash; - template <> - struct hash; - - //=== VK_SEC_amigo_profiling === - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_surface_maintenance1 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_swapchain_maintenance1 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_QCOM_multiview_per_view_viewports === - template <> - struct hash; - - //=== VK_NV_ray_tracing_invocation_reorder === - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_cooperative_vector === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_extended_sparse_address_space === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_mutable_descriptor_type === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_legacy_vertex_attributes === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_layer_settings === - template <> - struct hash; - template <> - struct hash; - - //=== VK_ARM_shader_core_builtins === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_pipeline_library_group_handles === - template <> - struct hash; - - //=== VK_EXT_dynamic_rendering_unused_attachments === - template <> - struct hash; - - //=== VK_KHR_internally_synchronized_queues === - template <> - struct hash; - - //=== VK_NV_low_latency2 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_cooperative_matrix === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_ARM_data_graph === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_QCOM_multiview_per_view_render_areas === - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_compute_shader_derivatives === - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_decode_av1 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_encode_av1 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_decode_vp9 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_maintenance1 === - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_per_stage_descriptor_set === - template <> - struct hash; - - //=== VK_QCOM_image_processing2 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_QCOM_filter_cubic_weights === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_QCOM_ycbcr_degamma === - template <> - struct hash; - template <> - struct hash; - - //=== VK_QCOM_filter_cubic_clamp === - template <> - struct hash; - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - template <> - struct hash; - - //=== VK_KHR_unified_image_layouts === - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_MSFT_layered_driver === - template <> - struct hash; - - //=== VK_KHR_calibrated_timestamps === - template <> - struct hash; - - //=== VK_KHR_maintenance6 === - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_descriptor_pool_overallocation === - template <> - struct hash; - - //=== VK_QCOM_tile_memory_heap === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_copy_memory_indirect === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_memory_decompression === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_display_stereo === - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_encode_intra_refresh === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_encode_quantization_map === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_raw_access_chains === - template <> - struct hash; - - //=== VK_NV_external_compute_queue === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_shader_relaxed_extended_instruction === - template <> - struct hash; - - //=== VK_NV_command_buffer_inheritance === - template <> - struct hash; - - //=== VK_KHR_maintenance7 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_shader_atomic_float16_vector === - template <> - struct hash; - - //=== VK_EXT_shader_replicated_composites === - template <> - struct hash; - - //=== VK_EXT_shader_float8 === - template <> - struct hash; - - //=== VK_NV_ray_tracing_validation === - template <> - struct hash; - - //=== VK_NV_cluster_acceleration_structure === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_partitioned_acceleration_structure === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_device_generated_commands === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_maintenance8 === - template <> - struct hash; - template <> - struct hash; - - //=== VK_MESA_image_alignment_control === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_shader_fma === - template <> - struct hash; - - //=== VK_NV_push_constant_bank === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_ray_tracing_invocation_reorder === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_depth_clamp_control === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_maintenance9 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_video_maintenance2 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - template <> - struct hash; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_HUAWEI_hdr_vivid === - template <> - struct hash; - template <> - struct hash; - - //=== VK_NV_cooperative_matrix2 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_ARM_pipeline_opacity_micromap === - template <> - struct hash; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_depth_clamp_zero_one === - template <> - struct hash; - - //=== VK_ARM_performance_counters_by_region === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_vertex_attribute_robustness === - template <> - struct hash; - - //=== VK_ARM_format_pack === - template <> - struct hash; - - //=== VK_VALVE_fragment_density_map_layered === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_robustness2 === - template <> - struct hash; - template <> - struct hash; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_present_metering === - template <> - struct hash; - template <> - struct hash; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_fragment_density_map_offset === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_zero_initialize_device_memory === - template <> - struct hash; - - //=== VK_KHR_present_mode_fifo_latest_ready === - template <> - struct hash; - - //=== VK_EXT_shader_64bit_indexing === - template <> - struct hash; - - //=== VK_EXT_custom_resolve === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_QCOM_data_graph_model === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_KHR_maintenance10 === - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_shader_long_vector === - template <> - struct hash; - template <> - struct hash; - - //=== VK_SEC_pipeline_cache_incremental_mode === - template <> - struct hash; - - //=== VK_EXT_shader_uniform_buffer_unsized_array === - template <> - struct hash; - - //=== VK_NV_compute_occupancy_priority === - template <> - struct hash; - template <> - struct hash; - - //=== VK_EXT_shader_subgroup_partitioned === - template <> - struct hash; - - //================================================================= - //=== Required exports for VULKAN_HPP_NAMESPACE::StructureChain === - //================================================================= - -#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - using std::tuple_element; - using std::tuple_size; -#endif -} // namespace std - -export -{ - // This VkFlags type is used as part of a bitfield in some structures. - // As it can't be mimicked by vk-data types, we need to export just that. - using ::VkGeometryInstanceFlagsKHR; - - //================== - //=== PFN TYPEs === - //================== - - //=== VK_VERSION_1_0 === - using ::PFN_vkAllocateCommandBuffers; - using ::PFN_vkAllocateDescriptorSets; - using ::PFN_vkAllocateMemory; - using ::PFN_vkBeginCommandBuffer; - using ::PFN_vkBindBufferMemory; - using ::PFN_vkBindImageMemory; - using ::PFN_vkCmdBeginQuery; - using ::PFN_vkCmdBeginRenderPass; - using ::PFN_vkCmdBindDescriptorSets; - using ::PFN_vkCmdBindIndexBuffer; - using ::PFN_vkCmdBindPipeline; - using ::PFN_vkCmdBindVertexBuffers; - using ::PFN_vkCmdBlitImage; - using ::PFN_vkCmdClearAttachments; - using ::PFN_vkCmdClearColorImage; - using ::PFN_vkCmdClearDepthStencilImage; - using ::PFN_vkCmdCopyBuffer; - using ::PFN_vkCmdCopyBufferToImage; - using ::PFN_vkCmdCopyImage; - using ::PFN_vkCmdCopyImageToBuffer; - using ::PFN_vkCmdCopyQueryPoolResults; - using ::PFN_vkCmdDispatch; - using ::PFN_vkCmdDispatchIndirect; - using ::PFN_vkCmdDraw; - using ::PFN_vkCmdDrawIndexed; - using ::PFN_vkCmdDrawIndexedIndirect; - using ::PFN_vkCmdDrawIndirect; - using ::PFN_vkCmdEndQuery; - using ::PFN_vkCmdEndRenderPass; - using ::PFN_vkCmdExecuteCommands; - using ::PFN_vkCmdFillBuffer; - using ::PFN_vkCmdNextSubpass; - using ::PFN_vkCmdPipelineBarrier; - using ::PFN_vkCmdPushConstants; - using ::PFN_vkCmdResetEvent; - using ::PFN_vkCmdResetQueryPool; - using ::PFN_vkCmdResolveImage; - using ::PFN_vkCmdSetBlendConstants; - using ::PFN_vkCmdSetDepthBias; - using ::PFN_vkCmdSetDepthBounds; - using ::PFN_vkCmdSetEvent; - using ::PFN_vkCmdSetLineWidth; - using ::PFN_vkCmdSetScissor; - using ::PFN_vkCmdSetStencilCompareMask; - using ::PFN_vkCmdSetStencilReference; - using ::PFN_vkCmdSetStencilWriteMask; - using ::PFN_vkCmdSetViewport; - using ::PFN_vkCmdUpdateBuffer; - using ::PFN_vkCmdWaitEvents; - using ::PFN_vkCmdWriteTimestamp; - using ::PFN_vkCreateBuffer; - using ::PFN_vkCreateBufferView; - using ::PFN_vkCreateCommandPool; - using ::PFN_vkCreateComputePipelines; - using ::PFN_vkCreateDescriptorPool; - using ::PFN_vkCreateDescriptorSetLayout; - using ::PFN_vkCreateDevice; - using ::PFN_vkCreateEvent; - using ::PFN_vkCreateFence; - using ::PFN_vkCreateFramebuffer; - using ::PFN_vkCreateGraphicsPipelines; - using ::PFN_vkCreateImage; - using ::PFN_vkCreateImageView; - using ::PFN_vkCreateInstance; - using ::PFN_vkCreatePipelineCache; - using ::PFN_vkCreatePipelineLayout; - using ::PFN_vkCreateQueryPool; - using ::PFN_vkCreateRenderPass; - using ::PFN_vkCreateSampler; - using ::PFN_vkCreateSemaphore; - using ::PFN_vkCreateShaderModule; - using ::PFN_vkDestroyBuffer; - using ::PFN_vkDestroyBufferView; - using ::PFN_vkDestroyCommandPool; - using ::PFN_vkDestroyDescriptorPool; - using ::PFN_vkDestroyDescriptorSetLayout; - using ::PFN_vkDestroyDevice; - using ::PFN_vkDestroyEvent; - using ::PFN_vkDestroyFence; - using ::PFN_vkDestroyFramebuffer; - using ::PFN_vkDestroyImage; - using ::PFN_vkDestroyImageView; - using ::PFN_vkDestroyInstance; - using ::PFN_vkDestroyPipeline; - using ::PFN_vkDestroyPipelineCache; - using ::PFN_vkDestroyPipelineLayout; - using ::PFN_vkDestroyQueryPool; - using ::PFN_vkDestroyRenderPass; - using ::PFN_vkDestroySampler; - using ::PFN_vkDestroySemaphore; - using ::PFN_vkDestroyShaderModule; - using ::PFN_vkDeviceWaitIdle; - using ::PFN_vkEndCommandBuffer; - using ::PFN_vkEnumerateDeviceExtensionProperties; - using ::PFN_vkEnumerateDeviceLayerProperties; - using ::PFN_vkEnumerateInstanceExtensionProperties; - using ::PFN_vkEnumerateInstanceLayerProperties; - using ::PFN_vkEnumeratePhysicalDevices; - using ::PFN_vkFlushMappedMemoryRanges; - using ::PFN_vkFreeCommandBuffers; - using ::PFN_vkFreeDescriptorSets; - using ::PFN_vkFreeMemory; - using ::PFN_vkGetBufferMemoryRequirements; - using ::PFN_vkGetDeviceMemoryCommitment; - using ::PFN_vkGetDeviceProcAddr; - using ::PFN_vkGetDeviceQueue; - using ::PFN_vkGetEventStatus; - using ::PFN_vkGetFenceStatus; - using ::PFN_vkGetImageMemoryRequirements; - using ::PFN_vkGetImageSparseMemoryRequirements; - using ::PFN_vkGetImageSubresourceLayout; - using ::PFN_vkGetInstanceProcAddr; - using ::PFN_vkGetPhysicalDeviceFeatures; - using ::PFN_vkGetPhysicalDeviceFormatProperties; - using ::PFN_vkGetPhysicalDeviceImageFormatProperties; - using ::PFN_vkGetPhysicalDeviceMemoryProperties; - using ::PFN_vkGetPhysicalDeviceProperties; - using ::PFN_vkGetPhysicalDeviceQueueFamilyProperties; - using ::PFN_vkGetPhysicalDeviceSparseImageFormatProperties; - using ::PFN_vkGetPipelineCacheData; - using ::PFN_vkGetQueryPoolResults; - using ::PFN_vkGetRenderAreaGranularity; - using ::PFN_vkInvalidateMappedMemoryRanges; - using ::PFN_vkMapMemory; - using ::PFN_vkMergePipelineCaches; - using ::PFN_vkQueueBindSparse; - using ::PFN_vkQueueSubmit; - using ::PFN_vkQueueWaitIdle; - using ::PFN_vkResetCommandBuffer; - using ::PFN_vkResetCommandPool; - using ::PFN_vkResetDescriptorPool; - using ::PFN_vkResetEvent; - using ::PFN_vkResetFences; - using ::PFN_vkSetEvent; - using ::PFN_vkUnmapMemory; - using ::PFN_vkUpdateDescriptorSets; - using ::PFN_vkWaitForFences; - - //=== VK_VERSION_1_1 === - using ::PFN_vkBindBufferMemory2; - using ::PFN_vkBindImageMemory2; - using ::PFN_vkCmdDispatchBase; - using ::PFN_vkCmdSetDeviceMask; - using ::PFN_vkCreateDescriptorUpdateTemplate; - using ::PFN_vkCreateSamplerYcbcrConversion; - using ::PFN_vkDestroyDescriptorUpdateTemplate; - using ::PFN_vkDestroySamplerYcbcrConversion; - using ::PFN_vkEnumerateInstanceVersion; - using ::PFN_vkEnumeratePhysicalDeviceGroups; - using ::PFN_vkGetBufferMemoryRequirements2; - using ::PFN_vkGetDescriptorSetLayoutSupport; - using ::PFN_vkGetDeviceGroupPeerMemoryFeatures; - using ::PFN_vkGetDeviceQueue2; - using ::PFN_vkGetImageMemoryRequirements2; - using ::PFN_vkGetImageSparseMemoryRequirements2; - using ::PFN_vkGetPhysicalDeviceExternalBufferProperties; - using ::PFN_vkGetPhysicalDeviceExternalFenceProperties; - using ::PFN_vkGetPhysicalDeviceExternalSemaphoreProperties; - using ::PFN_vkGetPhysicalDeviceFeatures2; - using ::PFN_vkGetPhysicalDeviceFormatProperties2; - using ::PFN_vkGetPhysicalDeviceImageFormatProperties2; - using ::PFN_vkGetPhysicalDeviceMemoryProperties2; - using ::PFN_vkGetPhysicalDeviceProperties2; - using ::PFN_vkGetPhysicalDeviceQueueFamilyProperties2; - using ::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2; - using ::PFN_vkTrimCommandPool; - using ::PFN_vkUpdateDescriptorSetWithTemplate; - - //=== VK_VERSION_1_2 === - using ::PFN_vkCmdBeginRenderPass2; - using ::PFN_vkCmdDrawIndexedIndirectCount; - using ::PFN_vkCmdDrawIndirectCount; - using ::PFN_vkCmdEndRenderPass2; - using ::PFN_vkCmdNextSubpass2; - using ::PFN_vkCreateRenderPass2; - using ::PFN_vkGetBufferDeviceAddress; - using ::PFN_vkGetBufferOpaqueCaptureAddress; - using ::PFN_vkGetDeviceMemoryOpaqueCaptureAddress; - using ::PFN_vkGetSemaphoreCounterValue; - using ::PFN_vkResetQueryPool; - using ::PFN_vkSignalSemaphore; - using ::PFN_vkWaitSemaphores; - - //=== VK_VERSION_1_3 === - using ::PFN_vkCmdBeginRendering; - using ::PFN_vkCmdBindVertexBuffers2; - using ::PFN_vkCmdBlitImage2; - using ::PFN_vkCmdCopyBuffer2; - using ::PFN_vkCmdCopyBufferToImage2; - using ::PFN_vkCmdCopyImage2; - using ::PFN_vkCmdCopyImageToBuffer2; - using ::PFN_vkCmdEndRendering; - using ::PFN_vkCmdPipelineBarrier2; - using ::PFN_vkCmdResetEvent2; - using ::PFN_vkCmdResolveImage2; - using ::PFN_vkCmdSetCullMode; - using ::PFN_vkCmdSetDepthBiasEnable; - using ::PFN_vkCmdSetDepthBoundsTestEnable; - using ::PFN_vkCmdSetDepthCompareOp; - using ::PFN_vkCmdSetDepthTestEnable; - using ::PFN_vkCmdSetDepthWriteEnable; - using ::PFN_vkCmdSetEvent2; - using ::PFN_vkCmdSetFrontFace; - using ::PFN_vkCmdSetPrimitiveRestartEnable; - using ::PFN_vkCmdSetPrimitiveTopology; - using ::PFN_vkCmdSetRasterizerDiscardEnable; - using ::PFN_vkCmdSetScissorWithCount; - using ::PFN_vkCmdSetStencilOp; - using ::PFN_vkCmdSetStencilTestEnable; - using ::PFN_vkCmdSetViewportWithCount; - using ::PFN_vkCmdWaitEvents2; - using ::PFN_vkCmdWriteTimestamp2; - using ::PFN_vkCreatePrivateDataSlot; - using ::PFN_vkDestroyPrivateDataSlot; - using ::PFN_vkGetDeviceBufferMemoryRequirements; - using ::PFN_vkGetDeviceImageMemoryRequirements; - using ::PFN_vkGetDeviceImageSparseMemoryRequirements; - using ::PFN_vkGetPhysicalDeviceToolProperties; - using ::PFN_vkGetPrivateData; - using ::PFN_vkQueueSubmit2; - using ::PFN_vkSetPrivateData; - - //=== VK_VERSION_1_4 === - using ::PFN_vkCmdBindDescriptorSets2; - using ::PFN_vkCmdBindIndexBuffer2; - using ::PFN_vkCmdPushConstants2; - using ::PFN_vkCmdPushDescriptorSet; - using ::PFN_vkCmdPushDescriptorSet2; - using ::PFN_vkCmdPushDescriptorSetWithTemplate; - using ::PFN_vkCmdPushDescriptorSetWithTemplate2; - using ::PFN_vkCmdSetLineStipple; - using ::PFN_vkCmdSetRenderingAttachmentLocations; - using ::PFN_vkCmdSetRenderingInputAttachmentIndices; - using ::PFN_vkCopyImageToImage; - using ::PFN_vkCopyImageToMemory; - using ::PFN_vkCopyMemoryToImage; - using ::PFN_vkGetDeviceImageSubresourceLayout; - using ::PFN_vkGetImageSubresourceLayout2; - using ::PFN_vkGetRenderingAreaGranularity; - using ::PFN_vkMapMemory2; - using ::PFN_vkTransitionImageLayout; - using ::PFN_vkUnmapMemory2; - - //=== VK_KHR_surface === - using ::PFN_vkDestroySurfaceKHR; - using ::PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR; - using ::PFN_vkGetPhysicalDeviceSurfaceFormatsKHR; - using ::PFN_vkGetPhysicalDeviceSurfacePresentModesKHR; - using ::PFN_vkGetPhysicalDeviceSurfaceSupportKHR; - - //=== VK_KHR_swapchain === - using ::PFN_vkAcquireNextImage2KHR; - using ::PFN_vkAcquireNextImageKHR; - using ::PFN_vkCreateSwapchainKHR; - using ::PFN_vkDestroySwapchainKHR; - using ::PFN_vkGetDeviceGroupPresentCapabilitiesKHR; - using ::PFN_vkGetDeviceGroupSurfacePresentModesKHR; - using ::PFN_vkGetPhysicalDevicePresentRectanglesKHR; - using ::PFN_vkGetSwapchainImagesKHR; - using ::PFN_vkQueuePresentKHR; - - //=== VK_KHR_display === - using ::PFN_vkCreateDisplayModeKHR; - using ::PFN_vkCreateDisplayPlaneSurfaceKHR; - using ::PFN_vkGetDisplayModePropertiesKHR; - using ::PFN_vkGetDisplayPlaneCapabilitiesKHR; - using ::PFN_vkGetDisplayPlaneSupportedDisplaysKHR; - using ::PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR; - using ::PFN_vkGetPhysicalDeviceDisplayPropertiesKHR; - - //=== VK_KHR_display_swapchain === - using ::PFN_vkCreateSharedSwapchainsKHR; - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - using ::PFN_vkCreateXlibSurfaceKHR; - using ::PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - using ::PFN_vkCreateXcbSurfaceKHR; - using ::PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - using ::PFN_vkCreateWaylandSurfaceKHR; - using ::PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - using ::PFN_vkCreateAndroidSurfaceKHR; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - using ::PFN_vkCreateWin32SurfaceKHR; - using ::PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - using ::PFN_vkCreateDebugReportCallbackEXT; - using ::PFN_vkDebugReportMessageEXT; - using ::PFN_vkDestroyDebugReportCallbackEXT; - - //=== VK_EXT_debug_marker === - using ::PFN_vkCmdDebugMarkerBeginEXT; - using ::PFN_vkCmdDebugMarkerEndEXT; - using ::PFN_vkCmdDebugMarkerInsertEXT; - using ::PFN_vkDebugMarkerSetObjectNameEXT; - using ::PFN_vkDebugMarkerSetObjectTagEXT; - - //=== VK_KHR_video_queue === - using ::PFN_vkBindVideoSessionMemoryKHR; - using ::PFN_vkCmdBeginVideoCodingKHR; - using ::PFN_vkCmdControlVideoCodingKHR; - using ::PFN_vkCmdEndVideoCodingKHR; - using ::PFN_vkCreateVideoSessionKHR; - using ::PFN_vkCreateVideoSessionParametersKHR; - using ::PFN_vkDestroyVideoSessionKHR; - using ::PFN_vkDestroyVideoSessionParametersKHR; - using ::PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR; - using ::PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR; - using ::PFN_vkGetVideoSessionMemoryRequirementsKHR; - using ::PFN_vkUpdateVideoSessionParametersKHR; - - //=== VK_KHR_video_decode_queue === - using ::PFN_vkCmdDecodeVideoKHR; - - //=== VK_EXT_transform_feedback === - using ::PFN_vkCmdBeginQueryIndexedEXT; - using ::PFN_vkCmdBeginTransformFeedbackEXT; - using ::PFN_vkCmdBindTransformFeedbackBuffersEXT; - using ::PFN_vkCmdDrawIndirectByteCountEXT; - using ::PFN_vkCmdEndQueryIndexedEXT; - using ::PFN_vkCmdEndTransformFeedbackEXT; - - //=== VK_NVX_binary_import === - using ::PFN_vkCmdCuLaunchKernelNVX; - using ::PFN_vkCreateCuFunctionNVX; - using ::PFN_vkCreateCuModuleNVX; - using ::PFN_vkDestroyCuFunctionNVX; - using ::PFN_vkDestroyCuModuleNVX; - - //=== VK_NVX_image_view_handle === - using ::PFN_vkGetDeviceCombinedImageSamplerIndexNVX; - using ::PFN_vkGetImageViewAddressNVX; - using ::PFN_vkGetImageViewHandle64NVX; - using ::PFN_vkGetImageViewHandleNVX; - - //=== VK_AMD_draw_indirect_count === - using ::PFN_vkCmdDrawIndexedIndirectCountAMD; - using ::PFN_vkCmdDrawIndirectCountAMD; - - //=== VK_AMD_shader_info === - using ::PFN_vkGetShaderInfoAMD; - - //=== VK_KHR_dynamic_rendering === - using ::PFN_vkCmdBeginRenderingKHR; - using ::PFN_vkCmdEndRenderingKHR; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - using ::PFN_vkCreateStreamDescriptorSurfaceGGP; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - using ::PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - using ::PFN_vkGetMemoryWin32HandleNV; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_get_physical_device_properties2 === - using ::PFN_vkGetPhysicalDeviceFeatures2KHR; - using ::PFN_vkGetPhysicalDeviceFormatProperties2KHR; - using ::PFN_vkGetPhysicalDeviceImageFormatProperties2KHR; - using ::PFN_vkGetPhysicalDeviceMemoryProperties2KHR; - using ::PFN_vkGetPhysicalDeviceProperties2KHR; - using ::PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR; - using ::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR; - - //=== VK_KHR_device_group === - using ::PFN_vkCmdDispatchBaseKHR; - using ::PFN_vkCmdSetDeviceMaskKHR; - using ::PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR; - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - using ::PFN_vkCreateViSurfaceNN; -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_maintenance1 === - using ::PFN_vkTrimCommandPoolKHR; - - //=== VK_KHR_device_group_creation === - using ::PFN_vkEnumeratePhysicalDeviceGroupsKHR; - - //=== VK_KHR_external_memory_capabilities === - using ::PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - using ::PFN_vkGetMemoryWin32HandleKHR; - using ::PFN_vkGetMemoryWin32HandlePropertiesKHR; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - using ::PFN_vkGetMemoryFdKHR; - using ::PFN_vkGetMemoryFdPropertiesKHR; - - //=== VK_KHR_external_semaphore_capabilities === - using ::PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - using ::PFN_vkGetSemaphoreWin32HandleKHR; - using ::PFN_vkImportSemaphoreWin32HandleKHR; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - using ::PFN_vkGetSemaphoreFdKHR; - using ::PFN_vkImportSemaphoreFdKHR; - - //=== VK_KHR_push_descriptor === - using ::PFN_vkCmdPushDescriptorSetKHR; - using ::PFN_vkCmdPushDescriptorSetWithTemplateKHR; - - //=== VK_EXT_conditional_rendering === - using ::PFN_vkCmdBeginConditionalRenderingEXT; - using ::PFN_vkCmdEndConditionalRenderingEXT; - - //=== VK_KHR_descriptor_update_template === - using ::PFN_vkCreateDescriptorUpdateTemplateKHR; - using ::PFN_vkDestroyDescriptorUpdateTemplateKHR; - using ::PFN_vkUpdateDescriptorSetWithTemplateKHR; - - //=== VK_NV_clip_space_w_scaling === - using ::PFN_vkCmdSetViewportWScalingNV; - - //=== VK_EXT_direct_mode_display === - using ::PFN_vkReleaseDisplayEXT; - -#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - using ::PFN_vkAcquireXlibDisplayEXT; - using ::PFN_vkGetRandROutputDisplayEXT; -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - using ::PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT; - - //=== VK_EXT_display_control === - using ::PFN_vkDisplayPowerControlEXT; - using ::PFN_vkGetSwapchainCounterEXT; - using ::PFN_vkRegisterDeviceEventEXT; - using ::PFN_vkRegisterDisplayEventEXT; - - //=== VK_GOOGLE_display_timing === - using ::PFN_vkGetPastPresentationTimingGOOGLE; - using ::PFN_vkGetRefreshCycleDurationGOOGLE; - - //=== VK_EXT_discard_rectangles === - using ::PFN_vkCmdSetDiscardRectangleEnableEXT; - using ::PFN_vkCmdSetDiscardRectangleEXT; - using ::PFN_vkCmdSetDiscardRectangleModeEXT; - - //=== VK_EXT_hdr_metadata === - using ::PFN_vkSetHdrMetadataEXT; - - //=== VK_KHR_create_renderpass2 === - using ::PFN_vkCmdBeginRenderPass2KHR; - using ::PFN_vkCmdEndRenderPass2KHR; - using ::PFN_vkCmdNextSubpass2KHR; - using ::PFN_vkCreateRenderPass2KHR; - - //=== VK_KHR_shared_presentable_image === - using ::PFN_vkGetSwapchainStatusKHR; - - //=== VK_KHR_external_fence_capabilities === - using ::PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - using ::PFN_vkGetFenceWin32HandleKHR; - using ::PFN_vkImportFenceWin32HandleKHR; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - using ::PFN_vkGetFenceFdKHR; - using ::PFN_vkImportFenceFdKHR; - - //=== VK_KHR_performance_query === - using ::PFN_vkAcquireProfilingLockKHR; - using ::PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR; - using ::PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR; - using ::PFN_vkReleaseProfilingLockKHR; - - //=== VK_KHR_get_surface_capabilities2 === - using ::PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR; - using ::PFN_vkGetPhysicalDeviceSurfaceFormats2KHR; - - //=== VK_KHR_get_display_properties2 === - using ::PFN_vkGetDisplayModeProperties2KHR; - using ::PFN_vkGetDisplayPlaneCapabilities2KHR; - using ::PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR; - using ::PFN_vkGetPhysicalDeviceDisplayProperties2KHR; - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - using ::PFN_vkCreateIOSSurfaceMVK; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - using ::PFN_vkCreateMacOSSurfaceMVK; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - using ::PFN_vkCmdBeginDebugUtilsLabelEXT; - using ::PFN_vkCmdEndDebugUtilsLabelEXT; - using ::PFN_vkCmdInsertDebugUtilsLabelEXT; - using ::PFN_vkCreateDebugUtilsMessengerEXT; - using ::PFN_vkDestroyDebugUtilsMessengerEXT; - using ::PFN_vkQueueBeginDebugUtilsLabelEXT; - using ::PFN_vkQueueEndDebugUtilsLabelEXT; - using ::PFN_vkQueueInsertDebugUtilsLabelEXT; - using ::PFN_vkSetDebugUtilsObjectNameEXT; - using ::PFN_vkSetDebugUtilsObjectTagEXT; - using ::PFN_vkSubmitDebugUtilsMessageEXT; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - using ::PFN_vkGetAndroidHardwareBufferPropertiesANDROID; - using ::PFN_vkGetMemoryAndroidHardwareBufferANDROID; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - using ::PFN_vkCmdDispatchGraphAMDX; - using ::PFN_vkCmdDispatchGraphIndirectAMDX; - using ::PFN_vkCmdDispatchGraphIndirectCountAMDX; - using ::PFN_vkCmdInitializeGraphScratchMemoryAMDX; - using ::PFN_vkCreateExecutionGraphPipelinesAMDX; - using ::PFN_vkGetExecutionGraphPipelineNodeIndexAMDX; - using ::PFN_vkGetExecutionGraphPipelineScratchSizeAMDX; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - using ::PFN_vkCmdBindResourceHeapEXT; - using ::PFN_vkCmdBindSamplerHeapEXT; - using ::PFN_vkCmdPushDataEXT; - using ::PFN_vkGetImageOpaqueCaptureDataEXT; - using ::PFN_vkGetPhysicalDeviceDescriptorSizeEXT; - using ::PFN_vkGetTensorOpaqueCaptureDataARM; - using ::PFN_vkRegisterCustomBorderColorEXT; - using ::PFN_vkUnregisterCustomBorderColorEXT; - using ::PFN_vkWriteResourceDescriptorsEXT; - using ::PFN_vkWriteSamplerDescriptorsEXT; - - //=== VK_EXT_sample_locations === - using ::PFN_vkCmdSetSampleLocationsEXT; - using ::PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT; - - //=== VK_KHR_get_memory_requirements2 === - using ::PFN_vkGetBufferMemoryRequirements2KHR; - using ::PFN_vkGetImageMemoryRequirements2KHR; - using ::PFN_vkGetImageSparseMemoryRequirements2KHR; - - //=== VK_KHR_acceleration_structure === - using ::PFN_vkBuildAccelerationStructuresKHR; - using ::PFN_vkCmdBuildAccelerationStructuresIndirectKHR; - using ::PFN_vkCmdBuildAccelerationStructuresKHR; - using ::PFN_vkCmdCopyAccelerationStructureKHR; - using ::PFN_vkCmdCopyAccelerationStructureToMemoryKHR; - using ::PFN_vkCmdCopyMemoryToAccelerationStructureKHR; - using ::PFN_vkCmdWriteAccelerationStructuresPropertiesKHR; - using ::PFN_vkCopyAccelerationStructureKHR; - using ::PFN_vkCopyAccelerationStructureToMemoryKHR; - using ::PFN_vkCopyMemoryToAccelerationStructureKHR; - using ::PFN_vkCreateAccelerationStructureKHR; - using ::PFN_vkDestroyAccelerationStructureKHR; - using ::PFN_vkGetAccelerationStructureBuildSizesKHR; - using ::PFN_vkGetAccelerationStructureDeviceAddressKHR; - using ::PFN_vkGetDeviceAccelerationStructureCompatibilityKHR; - using ::PFN_vkWriteAccelerationStructuresPropertiesKHR; - - //=== VK_KHR_ray_tracing_pipeline === - using ::PFN_vkCmdSetRayTracingPipelineStackSizeKHR; - using ::PFN_vkCmdTraceRaysIndirectKHR; - using ::PFN_vkCmdTraceRaysKHR; - using ::PFN_vkCreateRayTracingPipelinesKHR; - using ::PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR; - using ::PFN_vkGetRayTracingShaderGroupHandlesKHR; - using ::PFN_vkGetRayTracingShaderGroupStackSizeKHR; - - //=== VK_KHR_sampler_ycbcr_conversion === - using ::PFN_vkCreateSamplerYcbcrConversionKHR; - using ::PFN_vkDestroySamplerYcbcrConversionKHR; - - //=== VK_KHR_bind_memory2 === - using ::PFN_vkBindBufferMemory2KHR; - using ::PFN_vkBindImageMemory2KHR; - - //=== VK_EXT_image_drm_format_modifier === - using ::PFN_vkGetImageDrmFormatModifierPropertiesEXT; - - //=== VK_EXT_validation_cache === - using ::PFN_vkCreateValidationCacheEXT; - using ::PFN_vkDestroyValidationCacheEXT; - using ::PFN_vkGetValidationCacheDataEXT; - using ::PFN_vkMergeValidationCachesEXT; - - //=== VK_NV_shading_rate_image === - using ::PFN_vkCmdBindShadingRateImageNV; - using ::PFN_vkCmdSetCoarseSampleOrderNV; - using ::PFN_vkCmdSetViewportShadingRatePaletteNV; - - //=== VK_NV_ray_tracing === - using ::PFN_vkBindAccelerationStructureMemoryNV; - using ::PFN_vkCmdBuildAccelerationStructureNV; - using ::PFN_vkCmdCopyAccelerationStructureNV; - using ::PFN_vkCmdTraceRaysNV; - using ::PFN_vkCmdWriteAccelerationStructuresPropertiesNV; - using ::PFN_vkCompileDeferredNV; - using ::PFN_vkCreateAccelerationStructureNV; - using ::PFN_vkCreateRayTracingPipelinesNV; - using ::PFN_vkDestroyAccelerationStructureNV; - using ::PFN_vkGetAccelerationStructureHandleNV; - using ::PFN_vkGetAccelerationStructureMemoryRequirementsNV; - using ::PFN_vkGetRayTracingShaderGroupHandlesNV; - - //=== VK_KHR_maintenance3 === - using ::PFN_vkGetDescriptorSetLayoutSupportKHR; - - //=== VK_KHR_draw_indirect_count === - using ::PFN_vkCmdDrawIndexedIndirectCountKHR; - using ::PFN_vkCmdDrawIndirectCountKHR; - - //=== VK_EXT_external_memory_host === - using ::PFN_vkGetMemoryHostPointerPropertiesEXT; - - //=== VK_AMD_buffer_marker === - using ::PFN_vkCmdWriteBufferMarker2AMD; - using ::PFN_vkCmdWriteBufferMarkerAMD; - - //=== VK_EXT_calibrated_timestamps === - using ::PFN_vkGetCalibratedTimestampsEXT; - using ::PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; - - //=== VK_NV_mesh_shader === - using ::PFN_vkCmdDrawMeshTasksIndirectCountNV; - using ::PFN_vkCmdDrawMeshTasksIndirectNV; - using ::PFN_vkCmdDrawMeshTasksNV; - - //=== VK_NV_scissor_exclusive === - using ::PFN_vkCmdSetExclusiveScissorEnableNV; - using ::PFN_vkCmdSetExclusiveScissorNV; - - //=== VK_NV_device_diagnostic_checkpoints === - using ::PFN_vkCmdSetCheckpointNV; - using ::PFN_vkGetQueueCheckpointData2NV; - using ::PFN_vkGetQueueCheckpointDataNV; - - //=== VK_KHR_timeline_semaphore === - using ::PFN_vkGetSemaphoreCounterValueKHR; - using ::PFN_vkSignalSemaphoreKHR; - using ::PFN_vkWaitSemaphoresKHR; - - //=== VK_EXT_present_timing === - using ::PFN_vkGetPastPresentationTimingEXT; - using ::PFN_vkGetSwapchainTimeDomainPropertiesEXT; - using ::PFN_vkGetSwapchainTimingPropertiesEXT; - using ::PFN_vkSetSwapchainPresentTimingQueueSizeEXT; - - //=== VK_INTEL_performance_query === - using ::PFN_vkAcquirePerformanceConfigurationINTEL; - using ::PFN_vkCmdSetPerformanceMarkerINTEL; - using ::PFN_vkCmdSetPerformanceOverrideINTEL; - using ::PFN_vkCmdSetPerformanceStreamMarkerINTEL; - using ::PFN_vkGetPerformanceParameterINTEL; - using ::PFN_vkInitializePerformanceApiINTEL; - using ::PFN_vkQueueSetPerformanceConfigurationINTEL; - using ::PFN_vkReleasePerformanceConfigurationINTEL; - using ::PFN_vkUninitializePerformanceApiINTEL; - - //=== VK_AMD_display_native_hdr === - using ::PFN_vkSetLocalDimmingAMD; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - using ::PFN_vkCreateImagePipeSurfaceFUCHSIA; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - using ::PFN_vkCreateMetalSurfaceEXT; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_fragment_shading_rate === - using ::PFN_vkCmdSetFragmentShadingRateKHR; - using ::PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR; - - //=== VK_KHR_dynamic_rendering_local_read === - using ::PFN_vkCmdSetRenderingAttachmentLocationsKHR; - using ::PFN_vkCmdSetRenderingInputAttachmentIndicesKHR; - - //=== VK_EXT_buffer_device_address === - using ::PFN_vkGetBufferDeviceAddressEXT; - - //=== VK_EXT_tooling_info === - using ::PFN_vkGetPhysicalDeviceToolPropertiesEXT; - - //=== VK_KHR_present_wait === - using ::PFN_vkWaitForPresentKHR; - - //=== VK_NV_cooperative_matrix === - using ::PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV; - - //=== VK_NV_coverage_reduction_mode === - using ::PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - using ::PFN_vkAcquireFullScreenExclusiveModeEXT; - using ::PFN_vkGetDeviceGroupSurfacePresentModes2EXT; - using ::PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT; - using ::PFN_vkReleaseFullScreenExclusiveModeEXT; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - using ::PFN_vkCreateHeadlessSurfaceEXT; - - //=== VK_KHR_buffer_device_address === - using ::PFN_vkGetBufferDeviceAddressKHR; - using ::PFN_vkGetBufferOpaqueCaptureAddressKHR; - using ::PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR; - - //=== VK_EXT_line_rasterization === - using ::PFN_vkCmdSetLineStippleEXT; - - //=== VK_EXT_host_query_reset === - using ::PFN_vkResetQueryPoolEXT; - - //=== VK_EXT_extended_dynamic_state === - using ::PFN_vkCmdBindVertexBuffers2EXT; - using ::PFN_vkCmdSetCullModeEXT; - using ::PFN_vkCmdSetDepthBoundsTestEnableEXT; - using ::PFN_vkCmdSetDepthCompareOpEXT; - using ::PFN_vkCmdSetDepthTestEnableEXT; - using ::PFN_vkCmdSetDepthWriteEnableEXT; - using ::PFN_vkCmdSetFrontFaceEXT; - using ::PFN_vkCmdSetPrimitiveTopologyEXT; - using ::PFN_vkCmdSetScissorWithCountEXT; - using ::PFN_vkCmdSetStencilOpEXT; - using ::PFN_vkCmdSetStencilTestEnableEXT; - using ::PFN_vkCmdSetViewportWithCountEXT; - - //=== VK_KHR_deferred_host_operations === - using ::PFN_vkCreateDeferredOperationKHR; - using ::PFN_vkDeferredOperationJoinKHR; - using ::PFN_vkDestroyDeferredOperationKHR; - using ::PFN_vkGetDeferredOperationMaxConcurrencyKHR; - using ::PFN_vkGetDeferredOperationResultKHR; - - //=== VK_KHR_pipeline_executable_properties === - using ::PFN_vkGetPipelineExecutableInternalRepresentationsKHR; - using ::PFN_vkGetPipelineExecutablePropertiesKHR; - using ::PFN_vkGetPipelineExecutableStatisticsKHR; - - //=== VK_EXT_host_image_copy === - using ::PFN_vkCopyImageToImageEXT; - using ::PFN_vkCopyImageToMemoryEXT; - using ::PFN_vkCopyMemoryToImageEXT; - using ::PFN_vkGetImageSubresourceLayout2EXT; - using ::PFN_vkTransitionImageLayoutEXT; - - //=== VK_KHR_map_memory2 === - using ::PFN_vkMapMemory2KHR; - using ::PFN_vkUnmapMemory2KHR; - - //=== VK_EXT_swapchain_maintenance1 === - using ::PFN_vkReleaseSwapchainImagesEXT; - - //=== VK_NV_device_generated_commands === - using ::PFN_vkCmdBindPipelineShaderGroupNV; - using ::PFN_vkCmdExecuteGeneratedCommandsNV; - using ::PFN_vkCmdPreprocessGeneratedCommandsNV; - using ::PFN_vkCreateIndirectCommandsLayoutNV; - using ::PFN_vkDestroyIndirectCommandsLayoutNV; - using ::PFN_vkGetGeneratedCommandsMemoryRequirementsNV; - - //=== VK_EXT_depth_bias_control === - using ::PFN_vkCmdSetDepthBias2EXT; - - //=== VK_EXT_acquire_drm_display === - using ::PFN_vkAcquireDrmDisplayEXT; - using ::PFN_vkGetDrmDisplayEXT; - - //=== VK_EXT_private_data === - using ::PFN_vkCreatePrivateDataSlotEXT; - using ::PFN_vkDestroyPrivateDataSlotEXT; - using ::PFN_vkGetPrivateDataEXT; - using ::PFN_vkSetPrivateDataEXT; - - //=== VK_KHR_video_encode_queue === - using ::PFN_vkCmdEncodeVideoKHR; - using ::PFN_vkGetEncodedVideoSessionParametersKHR; - using ::PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - using ::PFN_vkCmdCudaLaunchKernelNV; - using ::PFN_vkCreateCudaFunctionNV; - using ::PFN_vkCreateCudaModuleNV; - using ::PFN_vkDestroyCudaFunctionNV; - using ::PFN_vkDestroyCudaModuleNV; - using ::PFN_vkGetCudaModuleCacheNV; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - using ::PFN_vkCmdBeginPerTileExecutionQCOM; - using ::PFN_vkCmdDispatchTileQCOM; - using ::PFN_vkCmdEndPerTileExecutionQCOM; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - using ::PFN_vkExportMetalObjectsEXT; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_synchronization2 === - using ::PFN_vkCmdPipelineBarrier2KHR; - using ::PFN_vkCmdResetEvent2KHR; - using ::PFN_vkCmdSetEvent2KHR; - using ::PFN_vkCmdWaitEvents2KHR; - using ::PFN_vkCmdWriteTimestamp2KHR; - using ::PFN_vkQueueSubmit2KHR; - - //=== VK_EXT_descriptor_buffer === - using ::PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT; - using ::PFN_vkCmdBindDescriptorBuffersEXT; - using ::PFN_vkCmdSetDescriptorBufferOffsetsEXT; - using ::PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT; - using ::PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT; - using ::PFN_vkGetDescriptorEXT; - using ::PFN_vkGetDescriptorSetLayoutBindingOffsetEXT; - using ::PFN_vkGetDescriptorSetLayoutSizeEXT; - using ::PFN_vkGetImageOpaqueCaptureDescriptorDataEXT; - using ::PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT; - using ::PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT; - - //=== VK_NV_fragment_shading_rate_enums === - using ::PFN_vkCmdSetFragmentShadingRateEnumNV; - - //=== VK_EXT_mesh_shader === - using ::PFN_vkCmdDrawMeshTasksEXT; - using ::PFN_vkCmdDrawMeshTasksIndirectCountEXT; - using ::PFN_vkCmdDrawMeshTasksIndirectEXT; - - //=== VK_KHR_copy_commands2 === - using ::PFN_vkCmdBlitImage2KHR; - using ::PFN_vkCmdCopyBuffer2KHR; - using ::PFN_vkCmdCopyBufferToImage2KHR; - using ::PFN_vkCmdCopyImage2KHR; - using ::PFN_vkCmdCopyImageToBuffer2KHR; - using ::PFN_vkCmdResolveImage2KHR; - - //=== VK_EXT_device_fault === - using ::PFN_vkGetDeviceFaultInfoEXT; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - using ::PFN_vkAcquireWinrtDisplayNV; - using ::PFN_vkGetWinrtDisplayNV; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - using ::PFN_vkCreateDirectFBSurfaceEXT; - using ::PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT; -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_vertex_input_dynamic_state === - using ::PFN_vkCmdSetVertexInputEXT; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - using ::PFN_vkGetMemoryZirconHandleFUCHSIA; - using ::PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - using ::PFN_vkGetSemaphoreZirconHandleFUCHSIA; - using ::PFN_vkImportSemaphoreZirconHandleFUCHSIA; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - using ::PFN_vkCreateBufferCollectionFUCHSIA; - using ::PFN_vkDestroyBufferCollectionFUCHSIA; - using ::PFN_vkGetBufferCollectionPropertiesFUCHSIA; - using ::PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA; - using ::PFN_vkSetBufferCollectionImageConstraintsFUCHSIA; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - using ::PFN_vkCmdSubpassShadingHUAWEI; - using ::PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI; - - //=== VK_HUAWEI_invocation_mask === - using ::PFN_vkCmdBindInvocationMaskHUAWEI; - - //=== VK_NV_external_memory_rdma === - using ::PFN_vkGetMemoryRemoteAddressNV; - - //=== VK_EXT_pipeline_properties === - using ::PFN_vkGetPipelinePropertiesEXT; - - //=== VK_EXT_extended_dynamic_state2 === - using ::PFN_vkCmdSetDepthBiasEnableEXT; - using ::PFN_vkCmdSetLogicOpEXT; - using ::PFN_vkCmdSetPatchControlPointsEXT; - using ::PFN_vkCmdSetPrimitiveRestartEnableEXT; - using ::PFN_vkCmdSetRasterizerDiscardEnableEXT; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - using ::PFN_vkCreateScreenSurfaceQNX; - using ::PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_EXT_color_write_enable === - using ::PFN_vkCmdSetColorWriteEnableEXT; - - //=== VK_KHR_ray_tracing_maintenance1 === - using ::PFN_vkCmdTraceRaysIndirect2KHR; - - //=== VK_EXT_multi_draw === - using ::PFN_vkCmdDrawMultiEXT; - using ::PFN_vkCmdDrawMultiIndexedEXT; - - //=== VK_EXT_opacity_micromap === - using ::PFN_vkBuildMicromapsEXT; - using ::PFN_vkCmdBuildMicromapsEXT; - using ::PFN_vkCmdCopyMemoryToMicromapEXT; - using ::PFN_vkCmdCopyMicromapEXT; - using ::PFN_vkCmdCopyMicromapToMemoryEXT; - using ::PFN_vkCmdWriteMicromapsPropertiesEXT; - using ::PFN_vkCopyMemoryToMicromapEXT; - using ::PFN_vkCopyMicromapEXT; - using ::PFN_vkCopyMicromapToMemoryEXT; - using ::PFN_vkCreateMicromapEXT; - using ::PFN_vkDestroyMicromapEXT; - using ::PFN_vkGetDeviceMicromapCompatibilityEXT; - using ::PFN_vkGetMicromapBuildSizesEXT; - using ::PFN_vkWriteMicromapsPropertiesEXT; - - //=== VK_HUAWEI_cluster_culling_shader === - using ::PFN_vkCmdDrawClusterHUAWEI; - using ::PFN_vkCmdDrawClusterIndirectHUAWEI; - - //=== VK_EXT_pageable_device_local_memory === - using ::PFN_vkSetDeviceMemoryPriorityEXT; - - //=== VK_KHR_maintenance4 === - using ::PFN_vkGetDeviceBufferMemoryRequirementsKHR; - using ::PFN_vkGetDeviceImageMemoryRequirementsKHR; - using ::PFN_vkGetDeviceImageSparseMemoryRequirementsKHR; - - //=== VK_VALVE_descriptor_set_host_mapping === - using ::PFN_vkGetDescriptorSetHostMappingVALVE; - using ::PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE; - - //=== VK_NV_copy_memory_indirect === - using ::PFN_vkCmdCopyMemoryIndirectNV; - using ::PFN_vkCmdCopyMemoryToImageIndirectNV; - - //=== VK_NV_memory_decompression === - using ::PFN_vkCmdDecompressMemoryIndirectCountNV; - using ::PFN_vkCmdDecompressMemoryNV; - - //=== VK_NV_device_generated_commands_compute === - using ::PFN_vkCmdUpdatePipelineIndirectBufferNV; - using ::PFN_vkGetPipelineIndirectDeviceAddressNV; - using ::PFN_vkGetPipelineIndirectMemoryRequirementsNV; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - using ::PFN_vkGetMemoryNativeBufferOHOS; - using ::PFN_vkGetNativeBufferPropertiesOHOS; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_extended_dynamic_state3 === - using ::PFN_vkCmdSetAlphaToCoverageEnableEXT; - using ::PFN_vkCmdSetAlphaToOneEnableEXT; - using ::PFN_vkCmdSetColorBlendAdvancedEXT; - using ::PFN_vkCmdSetColorBlendEnableEXT; - using ::PFN_vkCmdSetColorBlendEquationEXT; - using ::PFN_vkCmdSetColorWriteMaskEXT; - using ::PFN_vkCmdSetConservativeRasterizationModeEXT; - using ::PFN_vkCmdSetCoverageModulationModeNV; - using ::PFN_vkCmdSetCoverageModulationTableEnableNV; - using ::PFN_vkCmdSetCoverageModulationTableNV; - using ::PFN_vkCmdSetCoverageReductionModeNV; - using ::PFN_vkCmdSetCoverageToColorEnableNV; - using ::PFN_vkCmdSetCoverageToColorLocationNV; - using ::PFN_vkCmdSetDepthClampEnableEXT; - using ::PFN_vkCmdSetDepthClipEnableEXT; - using ::PFN_vkCmdSetDepthClipNegativeOneToOneEXT; - using ::PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT; - using ::PFN_vkCmdSetLineRasterizationModeEXT; - using ::PFN_vkCmdSetLineStippleEnableEXT; - using ::PFN_vkCmdSetLogicOpEnableEXT; - using ::PFN_vkCmdSetPolygonModeEXT; - using ::PFN_vkCmdSetProvokingVertexModeEXT; - using ::PFN_vkCmdSetRasterizationSamplesEXT; - using ::PFN_vkCmdSetRasterizationStreamEXT; - using ::PFN_vkCmdSetRepresentativeFragmentTestEnableNV; - using ::PFN_vkCmdSetSampleLocationsEnableEXT; - using ::PFN_vkCmdSetSampleMaskEXT; - using ::PFN_vkCmdSetShadingRateImageEnableNV; - using ::PFN_vkCmdSetTessellationDomainOriginEXT; - using ::PFN_vkCmdSetViewportSwizzleNV; - using ::PFN_vkCmdSetViewportWScalingEnableNV; - - //=== VK_ARM_tensors === - using ::PFN_vkBindTensorMemoryARM; - using ::PFN_vkCmdCopyTensorARM; - using ::PFN_vkCreateTensorARM; - using ::PFN_vkCreateTensorViewARM; - using ::PFN_vkDestroyTensorARM; - using ::PFN_vkDestroyTensorViewARM; - using ::PFN_vkGetDeviceTensorMemoryRequirementsARM; - using ::PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM; - using ::PFN_vkGetTensorMemoryRequirementsARM; - using ::PFN_vkGetTensorOpaqueCaptureDescriptorDataARM; - using ::PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM; - - //=== VK_EXT_shader_module_identifier === - using ::PFN_vkGetShaderModuleCreateInfoIdentifierEXT; - using ::PFN_vkGetShaderModuleIdentifierEXT; - - //=== VK_NV_optical_flow === - using ::PFN_vkBindOpticalFlowSessionImageNV; - using ::PFN_vkCmdOpticalFlowExecuteNV; - using ::PFN_vkCreateOpticalFlowSessionNV; - using ::PFN_vkDestroyOpticalFlowSessionNV; - using ::PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV; - - //=== VK_KHR_maintenance5 === - using ::PFN_vkCmdBindIndexBuffer2KHR; - using ::PFN_vkGetDeviceImageSubresourceLayoutKHR; - using ::PFN_vkGetImageSubresourceLayout2KHR; - using ::PFN_vkGetRenderingAreaGranularityKHR; - - //=== VK_AMD_anti_lag === - using ::PFN_vkAntiLagUpdateAMD; - - //=== VK_KHR_present_wait2 === - using ::PFN_vkWaitForPresent2KHR; - - //=== VK_EXT_shader_object === - using ::PFN_vkCmdBindShadersEXT; - using ::PFN_vkCmdSetDepthClampRangeEXT; - using ::PFN_vkCreateShadersEXT; - using ::PFN_vkDestroyShaderEXT; - using ::PFN_vkGetShaderBinaryDataEXT; - - //=== VK_KHR_pipeline_binary === - using ::PFN_vkCreatePipelineBinariesKHR; - using ::PFN_vkDestroyPipelineBinaryKHR; - using ::PFN_vkGetPipelineBinaryDataKHR; - using ::PFN_vkGetPipelineKeyKHR; - using ::PFN_vkReleaseCapturedPipelineDataKHR; - - //=== VK_QCOM_tile_properties === - using ::PFN_vkGetDynamicRenderingTilePropertiesQCOM; - using ::PFN_vkGetFramebufferTilePropertiesQCOM; - - //=== VK_KHR_swapchain_maintenance1 === - using ::PFN_vkReleaseSwapchainImagesKHR; - - //=== VK_NV_cooperative_vector === - using ::PFN_vkCmdConvertCooperativeVectorMatrixNV; - using ::PFN_vkConvertCooperativeVectorMatrixNV; - using ::PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV; - - //=== VK_NV_low_latency2 === - using ::PFN_vkGetLatencyTimingsNV; - using ::PFN_vkLatencySleepNV; - using ::PFN_vkQueueNotifyOutOfBandNV; - using ::PFN_vkSetLatencyMarkerNV; - using ::PFN_vkSetLatencySleepModeNV; - - //=== VK_KHR_cooperative_matrix === - using ::PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR; - - //=== VK_ARM_data_graph === - using ::PFN_vkBindDataGraphPipelineSessionMemoryARM; - using ::PFN_vkCmdDispatchDataGraphARM; - using ::PFN_vkCreateDataGraphPipelinesARM; - using ::PFN_vkCreateDataGraphPipelineSessionARM; - using ::PFN_vkDestroyDataGraphPipelineSessionARM; - using ::PFN_vkGetDataGraphPipelineAvailablePropertiesARM; - using ::PFN_vkGetDataGraphPipelinePropertiesARM; - using ::PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM; - using ::PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM; - using ::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM; - using ::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM; - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - using ::PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - using ::PFN_vkGetScreenBufferPropertiesQNX; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_KHR_line_rasterization === - using ::PFN_vkCmdSetLineStippleKHR; - - //=== VK_KHR_calibrated_timestamps === - using ::PFN_vkGetCalibratedTimestampsKHR; - using ::PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR; - - //=== VK_KHR_maintenance6 === - using ::PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT; - using ::PFN_vkCmdBindDescriptorSets2KHR; - using ::PFN_vkCmdPushConstants2KHR; - using ::PFN_vkCmdPushDescriptorSet2KHR; - using ::PFN_vkCmdPushDescriptorSetWithTemplate2KHR; - using ::PFN_vkCmdSetDescriptorBufferOffsets2EXT; - - //=== VK_QCOM_tile_memory_heap === - using ::PFN_vkCmdBindTileMemoryQCOM; - - //=== VK_KHR_copy_memory_indirect === - using ::PFN_vkCmdCopyMemoryIndirectKHR; - using ::PFN_vkCmdCopyMemoryToImageIndirectKHR; - - //=== VK_EXT_memory_decompression === - using ::PFN_vkCmdDecompressMemoryEXT; - using ::PFN_vkCmdDecompressMemoryIndirectCountEXT; - - //=== VK_NV_external_compute_queue === - using ::PFN_vkCreateExternalComputeQueueNV; - using ::PFN_vkDestroyExternalComputeQueueNV; - using ::PFN_vkGetExternalComputeQueueDataNV; - - //=== VK_NV_cluster_acceleration_structure === - using ::PFN_vkCmdBuildClusterAccelerationStructureIndirectNV; - using ::PFN_vkGetClusterAccelerationStructureBuildSizesNV; - - //=== VK_NV_partitioned_acceleration_structure === - using ::PFN_vkCmdBuildPartitionedAccelerationStructuresNV; - using ::PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV; - - //=== VK_EXT_device_generated_commands === - using ::PFN_vkCmdExecuteGeneratedCommandsEXT; - using ::PFN_vkCmdPreprocessGeneratedCommandsEXT; - using ::PFN_vkCreateIndirectCommandsLayoutEXT; - using ::PFN_vkCreateIndirectExecutionSetEXT; - using ::PFN_vkDestroyIndirectCommandsLayoutEXT; - using ::PFN_vkDestroyIndirectExecutionSetEXT; - using ::PFN_vkGetGeneratedCommandsMemoryRequirementsEXT; - using ::PFN_vkUpdateIndirectExecutionSetPipelineEXT; - using ::PFN_vkUpdateIndirectExecutionSetShaderEXT; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - using ::PFN_vkCreateSurfaceOHOS; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_NV_cooperative_matrix2 === - using ::PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - using ::PFN_vkGetMemoryMetalHandleEXT; - using ::PFN_vkGetMemoryMetalHandlePropertiesEXT; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_ARM_performance_counters_by_region === - using ::PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM; - - //=== VK_EXT_fragment_density_map_offset === - using ::PFN_vkCmdEndRendering2EXT; - - //=== VK_EXT_custom_resolve === - using ::PFN_vkCmdBeginCustomResolveEXT; - - //=== VK_KHR_maintenance10 === - using ::PFN_vkCmdEndRendering2KHR; - - //=== VK_NV_compute_occupancy_priority === - using ::PFN_vkCmdSetComputeOccupancyPriorityNV; -} diff --git a/lib/vulkan-headers/include/vulkan/vulkan.h b/lib/vulkan-headers/include/vulkan/vulkan.h deleted file mode 100644 index 2ed8d9c7abb..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan.h +++ /dev/null @@ -1,103 +0,0 @@ -#ifndef VULKAN_H_ -#define VULKAN_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -#include "vk_platform.h" -#include "vulkan_core.h" - -#ifdef VK_USE_PLATFORM_ANDROID_KHR -#include "vulkan_android.h" -#endif - -#ifdef VK_USE_PLATFORM_FUCHSIA -#include -#include "vulkan_fuchsia.h" -#endif - -#ifdef VK_USE_PLATFORM_IOS_MVK -#include "vulkan_ios.h" -#endif - - -#ifdef VK_USE_PLATFORM_MACOS_MVK -#include "vulkan_macos.h" -#endif - -#ifdef VK_USE_PLATFORM_METAL_EXT -#include "vulkan_metal.h" -#endif - -#ifdef VK_USE_PLATFORM_VI_NN -#include "vulkan_vi.h" -#endif - - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR -#include "vulkan_wayland.h" -#endif - - -#ifdef VK_USE_PLATFORM_WIN32_KHR -#include -#include "vulkan_win32.h" -#endif - - -#ifdef VK_USE_PLATFORM_XCB_KHR -#include -#include "vulkan_xcb.h" -#endif - - -#ifdef VK_USE_PLATFORM_XLIB_KHR -#include -#include "vulkan_xlib.h" -#endif - - -#ifdef VK_USE_PLATFORM_DIRECTFB_EXT -#include -#include "vulkan_directfb.h" -#endif - - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT -#include -#include -#include "vulkan_xlib_xrandr.h" -#endif - - -#ifdef VK_USE_PLATFORM_GGP -#include -#include "vulkan_ggp.h" -#endif - - -#ifdef VK_USE_PLATFORM_SCREEN_QNX -#include -#include "vulkan_screen.h" -#endif - - -#ifdef VK_USE_PLATFORM_SCI -#include -#include -#include "vulkan_sci.h" -#endif - - -#ifdef VK_ENABLE_BETA_EXTENSIONS -#include "vulkan_beta.h" -#endif - -#ifdef VK_USE_PLATFORM_OHOS -#include "vulkan_ohos.h" -#endif - -#endif // VULKAN_H_ diff --git a/lib/vulkan-headers/include/vulkan/vulkan.hpp b/lib/vulkan-headers/include/vulkan/vulkan.hpp deleted file mode 100644 index 4cd278cba29..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan.hpp +++ /dev/null @@ -1,25659 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_HPP -#define VULKAN_HPP - -#include -#if !defined( VULKAN_HPP_CXX_MODULE ) -// clang-format off -# include -// clang-format on -# include -# include // ArrayWrapperND -# include -# include // strnlen -# include // std::string -# include // std::exchange -# if 17 <= VULKAN_HPP_CPP_VERSION -# include -# endif -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) -# include // std::tie -# include // std::vector -# endif -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) -# include -# endif -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# include // std::is_error_code_enum -# endif -# if defined( VULKAN_HPP_SUPPORT_SPAN ) -# include -# endif -#else -# include -# include -import std; -#endif - -#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL == 1 -# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) -# include -# elif defined( _WIN32 ) && !defined( VULKAN_HPP_NO_WIN32_PROTOTYPES ) -using HINSTANCE = struct HINSTANCE__ *; -# if defined( _WIN64 ) -using FARPROC = int64_t( __stdcall * )(); -# else -using FARPROC = int( __stdcall * )(); -# endif -extern "C" __declspec( dllimport ) HINSTANCE __stdcall LoadLibraryA( char const * lpLibFileName ); -extern "C" __declspec( dllimport ) int __stdcall FreeLibrary( HINSTANCE hLibModule ); -extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE hModule, const char * lpProcName ); -# endif -#endif - -VULKAN_HPP_STATIC_ASSERT( VK_HEADER_VERSION == 341, "Wrong VK_HEADER_VERSION!" ); - -// includes through some other header -// this results in major(x) being resolved to gnu_dev_major(x) -// which is an expression in a constructor initializer list. -#if defined( major ) -# undef major -#endif -#if defined( minor ) -# undef minor -#endif - -// Windows defines MemoryBarrier which is deprecated and collides -// with the VULKAN_HPP_NAMESPACE::MemoryBarrier struct. -#if defined( MemoryBarrier ) -# undef MemoryBarrier -#endif - -// XLib.h defines True/False, which collides with our VULKAN_HPP_NAMESPACE::True/VULKAN_HPP_NAMESPACE::False -// -> undef them and provide some namepace-secure constexpr -#if defined( True ) -# undef True -constexpr int True = 1; -#endif -#if defined( False ) -# undef False -constexpr int False = 0; -#endif - -namespace VULKAN_HPP_NAMESPACE -{ - template - class ArrayWrapper1D : public std::array - { - public: - VULKAN_HPP_CONSTEXPR ArrayWrapper1D() VULKAN_HPP_NOEXCEPT : std::array() {} - - VULKAN_HPP_CONSTEXPR ArrayWrapper1D( std::array const & data ) VULKAN_HPP_NOEXCEPT : std::array( data ) {} - - template ::value, int>::type = 0> - VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string const & data ) VULKAN_HPP_NOEXCEPT - { - copy( data.data(), data.length() ); - } - -#if 17 <= VULKAN_HPP_CPP_VERSION - template ::value, int>::type = 0> - VULKAN_HPP_CONSTEXPR_14 ArrayWrapper1D( std::string_view data ) VULKAN_HPP_NOEXCEPT - { - copy( data.data(), data.length() ); - } -#endif - -#if ( VK_USE_64_BIT_PTR_DEFINES == 0 ) - // on 32 bit compiles, needs overloads on index type int to resolve ambiguities - VULKAN_HPP_CONSTEXPR T const & operator[]( int index ) const VULKAN_HPP_NOEXCEPT - { - return std::array::operator[]( index ); - } - - T & operator[]( int index ) VULKAN_HPP_NOEXCEPT - { - return std::array::operator[]( index ); - } -#endif - - operator T const *() const VULKAN_HPP_NOEXCEPT - { - return this->data(); - } - - operator T *() VULKAN_HPP_NOEXCEPT - { - return this->data(); - } - - template ::value, int>::type = 0> - operator std::string() const - { - return std::string( this->data(), strnlen( this->data(), N ) ); - } - -#if 17 <= VULKAN_HPP_CPP_VERSION - template ::value, int>::type = 0> - operator std::string_view() const - { - return std::string_view( this->data(), strnlen( this->data(), N ) ); - } -#endif - - private: - VULKAN_HPP_CONSTEXPR_14 void copy( char const * data, size_t len ) VULKAN_HPP_NOEXCEPT - { - size_t n = ( std::min )( N - 1, len ); - for ( size_t i = 0; i < n; ++i ) - { - ( *this )[i] = data[i]; - } - ( *this )[n] = 0; - } - }; - -// relational operators between ArrayWrapper1D of chars with potentially different sizes -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - template - std::strong_ordering operator<=>( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - int result = strcmp( lhs.data(), rhs.data() ); - return ( result < 0 ) ? std::strong_ordering::less : ( ( result > 0 ) ? std::strong_ordering::greater : std::strong_ordering::equal ); - } -#else - template - bool operator<( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return strcmp( lhs.data(), rhs.data() ) < 0; - } - - template - bool operator<=( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return strcmp( lhs.data(), rhs.data() ) <= 0; - } - - template - bool operator>( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return strcmp( lhs.data(), rhs.data() ) > 0; - } - - template - bool operator>=( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return strcmp( lhs.data(), rhs.data() ) >= 0; - } -#endif - - template - bool operator==( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return strcmp( lhs.data(), rhs.data() ) == 0; - } - - template - bool operator!=( ArrayWrapper1D const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return strcmp( lhs.data(), rhs.data() ) != 0; - } - -// specialization of relational operators between std::string and arrays of chars -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - template - std::strong_ordering operator<=>( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs <=> rhs.data(); - } -#else - template - bool operator<( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs < rhs.data(); - } - - template - bool operator<=( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs <= rhs.data(); - } - - template - bool operator>( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs > rhs.data(); - } - - template - bool operator>=( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs >= rhs.data(); - } -#endif - - template - bool operator==( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs == rhs.data(); - } - - template - bool operator!=( std::string const & lhs, ArrayWrapper1D const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs != rhs.data(); - } - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - template - std::strong_ordering operator<=>( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs.data() <=> rhs; - } -#else - template - bool operator<( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs.data() < rhs; - } - - template - bool operator<=( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs.data() <= rhs; - } - - template - bool operator>( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs.data() > rhs; - } - - template - bool operator>=( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs.data() >= rhs; - } -#endif - - template - bool operator==( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs.data() == rhs; - } - - template - bool operator!=( ArrayWrapper1D const & lhs, std::string const & rhs ) VULKAN_HPP_NOEXCEPT - { - return lhs.data() != rhs; - } - - template - class ArrayWrapper2D : public std::array, N> - { - public: - VULKAN_HPP_CONSTEXPR ArrayWrapper2D() VULKAN_HPP_NOEXCEPT : std::array, N>() {} - - VULKAN_HPP_CONSTEXPR ArrayWrapper2D( std::array, N> const & data ) VULKAN_HPP_NOEXCEPT - : std::array, N>( *reinterpret_cast, N> const *>( &data ) ) - { - } - }; - -#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - class ArrayProxy - { - public: - VULKAN_HPP_CONSTEXPR ArrayProxy() VULKAN_HPP_NOEXCEPT - : m_count( 0 ) - , m_ptr( nullptr ) - { - } - - VULKAN_HPP_CONSTEXPR ArrayProxy( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_count( 0 ) - , m_ptr( nullptr ) - { - } - - ArrayProxy( T const & value ) VULKAN_HPP_NOEXCEPT - : m_count( 1 ) - , m_ptr( &value ) - { - } - - ArrayProxy( uint32_t count, T const * ptr ) VULKAN_HPP_NOEXCEPT - : m_count( count ) - , m_ptr( ptr ) - { - } - - template - ArrayProxy( T const ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT - : m_count( C ) - , m_ptr( ptr ) - { - } - -# if __GNUC__ >= 9 -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Winit-list-lifetime" -# endif - - ArrayProxy( std::initializer_list const & list ) VULKAN_HPP_NOEXCEPT - : m_count( static_cast( list.size() ) ) - , m_ptr( list.begin() ) - { - } - - template ::value, int>::type = 0> - ArrayProxy( std::initializer_list::type> const & list ) VULKAN_HPP_NOEXCEPT - : m_count( static_cast( list.size() ) ) - , m_ptr( list.begin() ) - { - } - -# if __GNUC__ >= 9 -# pragma GCC diagnostic pop -# endif - - // Any type with a .data() return type implicitly convertible to T*, and a .size() return type implicitly - // convertible to size_t. The const version can capture temporaries, with lifetime ending at end of statement. - template ().data() ), T *>::value && - std::is_convertible().size() ), std::size_t>::value>::type * = nullptr> - ArrayProxy( V const & v ) VULKAN_HPP_NOEXCEPT - : m_count( static_cast( v.size() ) ) - , m_ptr( v.data() ) - { - } - - const T * begin() const VULKAN_HPP_NOEXCEPT - { - return m_ptr; - } - - const T * end() const VULKAN_HPP_NOEXCEPT - { - return m_ptr + m_count; - } - - const T & front() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_count && m_ptr ); - return *m_ptr; - } - - const T & back() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_count && m_ptr ); - return *( m_ptr + m_count - 1 ); - } - - bool empty() const VULKAN_HPP_NOEXCEPT - { - return ( m_count == 0 ); - } - - uint32_t size() const VULKAN_HPP_NOEXCEPT - { - return m_count; - } - - T const * data() const VULKAN_HPP_NOEXCEPT - { - return m_ptr; - } - - private: - uint32_t m_count; - T const * m_ptr; - }; - - template - class ArrayProxyNoTemporaries - { - public: - VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries() VULKAN_HPP_NOEXCEPT - : m_count( 0 ) - , m_ptr( nullptr ) - { - } - - VULKAN_HPP_CONSTEXPR ArrayProxyNoTemporaries( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - : m_count( 0 ) - , m_ptr( nullptr ) - { - } - - template ::value && std::is_lvalue_reference::value, int>::type = 0> - ArrayProxyNoTemporaries( B && value ) VULKAN_HPP_NOEXCEPT - : m_count( 1 ) - , m_ptr( &value ) - { - } - - ArrayProxyNoTemporaries( uint32_t count, T * ptr ) VULKAN_HPP_NOEXCEPT - : m_count( count ) - , m_ptr( ptr ) - { - } - - template - ArrayProxyNoTemporaries( T ( &ptr )[C] ) VULKAN_HPP_NOEXCEPT - : m_count( C ) - , m_ptr( ptr ) - { - } - - template - ArrayProxyNoTemporaries( T ( &&ptr )[C] ) = delete; - - // Any l-value reference with a .data() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t. - template ().begin() ), T *>::value && - std::is_convertible().data() ), T *>::value && - std::is_convertible().size() ), std::size_t>::value && std::is_lvalue_reference::value, - int>::type = 0> - ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT - : m_count( static_cast( v.size() ) ) - , m_ptr( v.data() ) - { - } - - // Any l-value reference with a .begin() return type implicitly convertible to T*, and a .size() return type implicitly convertible to size_t. - template ().begin() ), T *>::value && - std::is_convertible().size() ), std::size_t>::value && std::is_lvalue_reference::value, - int>::type = 0> - ArrayProxyNoTemporaries( V && v ) VULKAN_HPP_NOEXCEPT - : m_count( static_cast( v.size() ) ) - , m_ptr( v.begin() ) - { - } - - const T * begin() const VULKAN_HPP_NOEXCEPT - { - return m_ptr; - } - - const T * end() const VULKAN_HPP_NOEXCEPT - { - return m_ptr + m_count; - } - - const T & front() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_count && m_ptr ); - return *m_ptr; - } - - const T & back() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_count && m_ptr ); - return *( m_ptr + m_count - 1 ); - } - - bool empty() const VULKAN_HPP_NOEXCEPT - { - return ( m_count == 0 ); - } - - uint32_t size() const VULKAN_HPP_NOEXCEPT - { - return m_count; - } - - T * data() const VULKAN_HPP_NOEXCEPT - { - return m_ptr; - } - - private: - uint32_t m_count; - T * m_ptr; - }; - - template - class StridedArrayProxy : protected ArrayProxy - { - public: - using ArrayProxy::ArrayProxy; - - StridedArrayProxy( uint32_t count, T const * ptr, uint32_t stride ) VULKAN_HPP_NOEXCEPT - : ArrayProxy( count, ptr ) - , m_stride( stride ) - { - VULKAN_HPP_ASSERT( sizeof( T ) <= stride ); - } - - using ArrayProxy::begin; - - const T * end() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( static_cast( begin() ) + size() * m_stride ); - } - - using ArrayProxy::front; - - const T & back() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( begin() && size() ); - return *reinterpret_cast( static_cast( begin() ) + ( size() - 1 ) * m_stride ); - } - - using ArrayProxy::empty; - using ArrayProxy::size; - using ArrayProxy::data; - - uint32_t stride() const - { - return m_stride; - } - - private: - uint32_t m_stride = sizeof( T ); - }; - - template - class Optional - { - public: - Optional( RefType & reference ) VULKAN_HPP_NOEXCEPT - { - m_ptr = &reference; - } - - Optional( RefType * ptr ) VULKAN_HPP_NOEXCEPT - { - m_ptr = ptr; - } - - Optional( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_ptr = nullptr; - } - - operator RefType *() const VULKAN_HPP_NOEXCEPT - { - return m_ptr; - } - - RefType const * operator->() const VULKAN_HPP_NOEXCEPT - { - return m_ptr; - } - - RefType const * get() const VULKAN_HPP_NOEXCEPT - { - return m_ptr; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return !!m_ptr; - } - - private: - RefType * m_ptr; - }; - - template - struct StructExtends - { - enum - { - value = false - }; - }; - - template - struct IsPartOfStructureChain - { - static const bool valid = false; - }; - - template - struct IsPartOfStructureChain - { - static const bool valid = std::is_same::value || IsPartOfStructureChain::valid; - }; - - template - struct StructureChainContains - { - static const bool value = std::is_same>::type>::value || - StructureChainContains::value; - }; - - template - struct StructureChainContains<0, T, ChainElements...> - { - static const bool value = std::is_same>::type>::value; - }; - - template - struct StructureChainValidation - { - using TestType = typename std::tuple_element>::type; - static const bool valid = StructExtends>::type>::value && - ( TestType::allowDuplicate || !StructureChainContains::value ) && - StructureChainValidation::valid; - }; - - template - struct StructureChainValidation<0, ChainElements...> - { - static const bool valid = true; - }; - - template - class StructureChain : public std::tuple - { - // Note: StructureChain has no move constructor or move assignment operator, as it is not supposed to contain movable containers. - // In order to get a copy-operation on a move-operations, those functions are neither deleted nor defaulted. - public: - StructureChain() VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_STATIC_ASSERT( StructureChainValidation::valid, "The structure chain is not valid!" ); - link(); - } - - StructureChain( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT : std::tuple( rhs ) - { - VULKAN_HPP_STATIC_ASSERT( StructureChainValidation::valid, "The structure chain is not valid!" ); - link( &std::get<0>( *this ), - &std::get<0>( rhs ), - reinterpret_cast( &std::get<0>( *this ) ), - reinterpret_cast( &std::get<0>( rhs ) ) ); - } - - StructureChain( ChainElements const &... elems ) VULKAN_HPP_NOEXCEPT : std::tuple( elems... ) - { - VULKAN_HPP_STATIC_ASSERT( StructureChainValidation::valid, "The structure chain is not valid!" ); - link(); - } - - StructureChain & operator=( StructureChain const & rhs ) VULKAN_HPP_NOEXCEPT - { - std::tuple::operator=( rhs ); - link( &std::get<0>( *this ), - &std::get<0>( rhs ), - reinterpret_cast( &std::get<0>( *this ) ), - reinterpret_cast( &std::get<0>( rhs ) ) ); - return *this; - } - - template >::type, size_t Which = 0> - VULKAN_HPP_NODISCARD T & get() & VULKAN_HPP_NOEXCEPT - { - return std::get::value>( static_cast &>( *this ) ); - } - - template >::type, size_t Which = 0> - VULKAN_HPP_NODISCARD T const & get() const & VULKAN_HPP_NOEXCEPT - { - return std::get::value>( static_cast const &>( *this ) ); - } - - template >::type, size_t Which = 0> - VULKAN_HPP_NODISCARD T && get() && VULKAN_HPP_NOEXCEPT - { - return std::move( std::get::value>( static_cast &>( *this ) ) ); - } - - template - VULKAN_HPP_NODISCARD std::tuple get() & VULKAN_HPP_NOEXCEPT - { - return std::tie( get(), get(), get()... ); - } - - template - VULKAN_HPP_NODISCARD std::tuple get() const & VULKAN_HPP_NOEXCEPT - { - return std::tie( get(), get(), get()... ); - } - - template - VULKAN_HPP_NODISCARD std::tuple get() && VULKAN_HPP_NOEXCEPT - { - return std::forward_as_tuple( std::move( get() ), std::move( get() ), std::move( get() )... ); - } - - template - VULKAN_HPP_NODISCARD std::tuple get() const && VULKAN_HPP_NOEXCEPT - { - return std::forward_as_tuple( std::move( get() ), std::move( get() ), std::move( get() )... ); - } - - // assign a complete structure to the StructureChain without modifying the chaining - template >::type, size_t Which = 0> - StructureChain & assign( const T & rhs ) VULKAN_HPP_NOEXCEPT - { - T & lhs = get(); - auto pNext = lhs.pNext; - lhs = rhs; - lhs.pNext = pNext; - return *this; - } - - template - VULKAN_HPP_NODISCARD - typename std::enable_if>::type>::value && ( Which == 0 ), bool>::type - isLinked() const VULKAN_HPP_NOEXCEPT - { - return true; - } - - template - VULKAN_HPP_NODISCARD - typename std::enable_if>::type>::value || ( Which != 0 ), bool>::type - isLinked() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain::valid, "Can't unlink Structure that's not part of this StructureChain!" ); - return isLinked( reinterpret_cast( &get() ) ); - } - - template - typename std::enable_if>::type>::value || ( Which != 0 ), void>::type - relink() VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain::valid, "Can't relink Structure that's not part of this StructureChain!" ); - auto pNext = reinterpret_cast( &get() ); - VULKAN_HPP_ASSERT( !isLinked( pNext ) ); - auto & headElement = std::get<0>( static_cast &>( *this ) ); - pNext->pNext = reinterpret_cast( headElement.pNext ); - headElement.pNext = pNext; - } - - template - typename std::enable_if>::type>::value || ( Which != 0 ), void>::type - unlink() VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_STATIC_ASSERT( IsPartOfStructureChain::valid, "Can't unlink Structure that's not part of this StructureChain!" ); - unlink( reinterpret_cast( &get() ) ); - } - - private: - template - struct ChainElementIndex : ChainElementIndex - { - }; - - template - struct ChainElementIndex::value, void>::type, First, Types...> - : ChainElementIndex - { - }; - - template - struct ChainElementIndex::value, void>::type, First, Types...> - : ChainElementIndex - { - }; - - template - struct ChainElementIndex::value, void>::type, First, Types...> - : std::integral_constant - { - }; - - VULKAN_HPP_NODISCARD bool isLinked( VkBaseInStructure const * pNext ) const VULKAN_HPP_NOEXCEPT - { - VkBaseInStructure const * elementPtr = - reinterpret_cast( &std::get<0>( static_cast const &>( *this ) ) ); - while ( elementPtr ) - { - if ( elementPtr->pNext == pNext ) - { - return true; - } - elementPtr = elementPtr->pNext; - } - return false; - } - - template - typename std::enable_if::type link() VULKAN_HPP_NOEXCEPT - { - auto & x = std::get( static_cast &>( *this ) ); - x.pNext = &std::get( static_cast &>( *this ) ); - link(); - } - - template - typename std::enable_if::type link() VULKAN_HPP_NOEXCEPT - { - } - - void link( void * dstBase, void const * srcBase, VkBaseOutStructure * dst, VkBaseInStructure const * src ) - { - while ( src->pNext ) - { - std::ptrdiff_t offset = reinterpret_cast( src->pNext ) - reinterpret_cast( srcBase ); - dst->pNext = reinterpret_cast( reinterpret_cast( dstBase ) + offset ); - dst = dst->pNext; - src = src->pNext; - } - dst->pNext = nullptr; - } - - void unlink( VkBaseOutStructure const * pNext ) VULKAN_HPP_NOEXCEPT - { - VkBaseOutStructure * elementPtr = reinterpret_cast( &std::get<0>( static_cast &>( *this ) ) ); - while ( elementPtr && ( elementPtr->pNext != pNext ) ) - { - elementPtr = elementPtr->pNext; - } - if ( elementPtr ) - { - elementPtr->pNext = pNext->pNext; - } - else - { - VULKAN_HPP_ASSERT( false ); // fires, if the ClassType member has already been unlinked ! - } - } - }; - - // interupt the VULKAN_HPP_NAMESPACE for a moment to add specializations of std::tuple_size and std::tuple_element for the StructureChain! -} - -namespace std -{ - template - struct tuple_size> - { - static constexpr size_t value = std::tuple_size>::value; - }; - - template - struct tuple_element> - { - using type = typename std::tuple_element>::type; - }; -} // namespace std - -namespace VULKAN_HPP_NAMESPACE -{ - -# if !defined( VULKAN_HPP_NO_SMART_HANDLE ) - template - class UniqueHandleTraits; - - template - class UniqueHandle : public UniqueHandleTraits::deleter - { - private: - using Deleter = typename UniqueHandleTraits::deleter; - - public: - using element_type = Type; - - UniqueHandle() : Deleter(), m_value() {} - - explicit UniqueHandle( Type const & value, Deleter const & deleter = Deleter() ) VULKAN_HPP_NOEXCEPT - : Deleter( deleter ) - , m_value( value ) - { - } - - UniqueHandle( UniqueHandle const & ) = delete; - - UniqueHandle( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT - : Deleter( std::move( static_cast( other ) ) ) - , m_value( other.release() ) - { - } - - ~UniqueHandle() VULKAN_HPP_NOEXCEPT - { - if ( m_value ) - { - this->destroy( m_value ); - } - } - - UniqueHandle & operator=( UniqueHandle const & ) = delete; - - UniqueHandle & operator=( UniqueHandle && other ) VULKAN_HPP_NOEXCEPT - { - reset( other.release() ); - *static_cast( this ) = std::move( static_cast( other ) ); - return *this; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_value.operator bool(); - } - -# if defined( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST ) - operator Type() const VULKAN_HPP_NOEXCEPT - { - return m_value; - } -# endif - - Type const * operator->() const VULKAN_HPP_NOEXCEPT - { - return &m_value; - } - - Type * operator->() VULKAN_HPP_NOEXCEPT - { - return &m_value; - } - - Type const & operator*() const VULKAN_HPP_NOEXCEPT - { - return m_value; - } - - Type & operator*() VULKAN_HPP_NOEXCEPT - { - return m_value; - } - - const Type & get() const VULKAN_HPP_NOEXCEPT - { - return m_value; - } - - Type & get() VULKAN_HPP_NOEXCEPT - { - return m_value; - } - - void reset( Type const & value = Type() ) VULKAN_HPP_NOEXCEPT - { - if ( m_value != value ) - { - if ( m_value ) - { - this->destroy( m_value ); - } - m_value = value; - } - } - - Type release() VULKAN_HPP_NOEXCEPT - { - Type value = m_value; - m_value = nullptr; - return value; - } - - void swap( UniqueHandle & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_value, rhs.m_value ); - std::swap( static_cast( *this ), static_cast( rhs ) ); - } - - private: - Type m_value; - }; - - template - VULKAN_HPP_INLINE std::vector uniqueToRaw( std::vector const & handles ) - { - std::vector newBuffer( handles.size() ); - std::transform( handles.begin(), handles.end(), newBuffer.begin(), []( UniqueType const & handle ) { return handle.get(); } ); - return newBuffer; - } - - template - VULKAN_HPP_INLINE void swap( UniqueHandle & lhs, UniqueHandle & rhs ) VULKAN_HPP_NOEXCEPT - { - lhs.swap( rhs ); - } -# endif -#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE - - namespace detail - { - - //========================== - //=== Is Dispatched List === - //========================== - - // C++11-compatible void_t - template - struct voider - { - typedef void type; - }; - - template - using void_t = typename voider::type; - - // helper macro to declare a SFINAE-friendly has_ trait -#define DECLARE_IS_DISPATCHED( name ) \ - template \ - struct has_##name : std::false_type \ - { \ - }; \ - template \ - struct has_##name> : std::true_type \ - { \ - }; - - DECLARE_IS_DISPATCHED( vkAcquireDrmDisplayEXT ) - DECLARE_IS_DISPATCHED( vkAcquireFullScreenExclusiveModeEXT ) - DECLARE_IS_DISPATCHED( vkAcquireImageANDROID ) - DECLARE_IS_DISPATCHED( vkAcquireImageOHOS ) - DECLARE_IS_DISPATCHED( vkAcquireNextImage2KHR ) - DECLARE_IS_DISPATCHED( vkAcquireNextImageKHR ) - DECLARE_IS_DISPATCHED( vkAcquirePerformanceConfigurationINTEL ) - DECLARE_IS_DISPATCHED( vkAcquireProfilingLockKHR ) - DECLARE_IS_DISPATCHED( vkAcquireWinrtDisplayNV ) - DECLARE_IS_DISPATCHED( vkAcquireXlibDisplayEXT ) - DECLARE_IS_DISPATCHED( vkAllocateCommandBuffers ) - DECLARE_IS_DISPATCHED( vkAllocateDescriptorSets ) - DECLARE_IS_DISPATCHED( vkAllocateMemory ) - DECLARE_IS_DISPATCHED( vkAntiLagUpdateAMD ) - DECLARE_IS_DISPATCHED( vkBeginCommandBuffer ) - DECLARE_IS_DISPATCHED( vkBindAccelerationStructureMemoryNV ) - DECLARE_IS_DISPATCHED( vkBindBufferMemory ) - DECLARE_IS_DISPATCHED( vkBindBufferMemory2 ) - DECLARE_IS_DISPATCHED( vkBindBufferMemory2KHR ) - DECLARE_IS_DISPATCHED( vkBindDataGraphPipelineSessionMemoryARM ) - DECLARE_IS_DISPATCHED( vkBindImageMemory ) - DECLARE_IS_DISPATCHED( vkBindImageMemory2 ) - DECLARE_IS_DISPATCHED( vkBindImageMemory2KHR ) - DECLARE_IS_DISPATCHED( vkBindOpticalFlowSessionImageNV ) - DECLARE_IS_DISPATCHED( vkBindTensorMemoryARM ) - DECLARE_IS_DISPATCHED( vkBindVideoSessionMemoryKHR ) - DECLARE_IS_DISPATCHED( vkBuildAccelerationStructuresKHR ) - DECLARE_IS_DISPATCHED( vkBuildMicromapsEXT ) - DECLARE_IS_DISPATCHED( vkCmdBeginConditionalRenderingEXT ) - DECLARE_IS_DISPATCHED( vkCmdBeginCustomResolveEXT ) - DECLARE_IS_DISPATCHED( vkCmdBeginDebugUtilsLabelEXT ) - DECLARE_IS_DISPATCHED( vkCmdBeginPerTileExecutionQCOM ) - DECLARE_IS_DISPATCHED( vkCmdBeginQuery ) - DECLARE_IS_DISPATCHED( vkCmdBeginQueryIndexedEXT ) - DECLARE_IS_DISPATCHED( vkCmdBeginRenderPass ) - DECLARE_IS_DISPATCHED( vkCmdBeginRenderPass2 ) - DECLARE_IS_DISPATCHED( vkCmdBeginRenderPass2KHR ) - DECLARE_IS_DISPATCHED( vkCmdBeginRendering ) - DECLARE_IS_DISPATCHED( vkCmdBeginRenderingKHR ) - DECLARE_IS_DISPATCHED( vkCmdBeginTransformFeedbackEXT ) - DECLARE_IS_DISPATCHED( vkCmdBeginVideoCodingKHR ) - DECLARE_IS_DISPATCHED( vkCmdBindDescriptorBufferEmbeddedSamplers2EXT ) - DECLARE_IS_DISPATCHED( vkCmdBindDescriptorBufferEmbeddedSamplersEXT ) - DECLARE_IS_DISPATCHED( vkCmdBindDescriptorBuffersEXT ) - DECLARE_IS_DISPATCHED( vkCmdBindDescriptorSets ) - DECLARE_IS_DISPATCHED( vkCmdBindDescriptorSets2 ) - DECLARE_IS_DISPATCHED( vkCmdBindDescriptorSets2KHR ) - DECLARE_IS_DISPATCHED( vkCmdBindIndexBuffer ) - DECLARE_IS_DISPATCHED( vkCmdBindIndexBuffer2 ) - DECLARE_IS_DISPATCHED( vkCmdBindIndexBuffer2KHR ) - DECLARE_IS_DISPATCHED( vkCmdBindInvocationMaskHUAWEI ) - DECLARE_IS_DISPATCHED( vkCmdBindPipeline ) - DECLARE_IS_DISPATCHED( vkCmdBindPipelineShaderGroupNV ) - DECLARE_IS_DISPATCHED( vkCmdBindResourceHeapEXT ) - DECLARE_IS_DISPATCHED( vkCmdBindSamplerHeapEXT ) - DECLARE_IS_DISPATCHED( vkCmdBindShadersEXT ) - DECLARE_IS_DISPATCHED( vkCmdBindShadingRateImageNV ) - DECLARE_IS_DISPATCHED( vkCmdBindTileMemoryQCOM ) - DECLARE_IS_DISPATCHED( vkCmdBindTransformFeedbackBuffersEXT ) - DECLARE_IS_DISPATCHED( vkCmdBindVertexBuffers ) - DECLARE_IS_DISPATCHED( vkCmdBindVertexBuffers2 ) - DECLARE_IS_DISPATCHED( vkCmdBindVertexBuffers2EXT ) - DECLARE_IS_DISPATCHED( vkCmdBlitImage ) - DECLARE_IS_DISPATCHED( vkCmdBlitImage2 ) - DECLARE_IS_DISPATCHED( vkCmdBlitImage2KHR ) - DECLARE_IS_DISPATCHED( vkCmdBuildAccelerationStructureNV ) - DECLARE_IS_DISPATCHED( vkCmdBuildAccelerationStructuresIndirectKHR ) - DECLARE_IS_DISPATCHED( vkCmdBuildAccelerationStructuresKHR ) - DECLARE_IS_DISPATCHED( vkCmdBuildClusterAccelerationStructureIndirectNV ) - DECLARE_IS_DISPATCHED( vkCmdBuildMicromapsEXT ) - DECLARE_IS_DISPATCHED( vkCmdBuildPartitionedAccelerationStructuresNV ) - DECLARE_IS_DISPATCHED( vkCmdClearAttachments ) - DECLARE_IS_DISPATCHED( vkCmdClearColorImage ) - DECLARE_IS_DISPATCHED( vkCmdClearDepthStencilImage ) - DECLARE_IS_DISPATCHED( vkCmdControlVideoCodingKHR ) - DECLARE_IS_DISPATCHED( vkCmdConvertCooperativeVectorMatrixNV ) - DECLARE_IS_DISPATCHED( vkCmdCopyAccelerationStructureKHR ) - DECLARE_IS_DISPATCHED( vkCmdCopyAccelerationStructureNV ) - DECLARE_IS_DISPATCHED( vkCmdCopyAccelerationStructureToMemoryKHR ) - DECLARE_IS_DISPATCHED( vkCmdCopyBuffer ) - DECLARE_IS_DISPATCHED( vkCmdCopyBuffer2 ) - DECLARE_IS_DISPATCHED( vkCmdCopyBuffer2KHR ) - DECLARE_IS_DISPATCHED( vkCmdCopyBufferToImage ) - DECLARE_IS_DISPATCHED( vkCmdCopyBufferToImage2 ) - DECLARE_IS_DISPATCHED( vkCmdCopyBufferToImage2KHR ) - DECLARE_IS_DISPATCHED( vkCmdCopyImage ) - DECLARE_IS_DISPATCHED( vkCmdCopyImage2 ) - DECLARE_IS_DISPATCHED( vkCmdCopyImage2KHR ) - DECLARE_IS_DISPATCHED( vkCmdCopyImageToBuffer ) - DECLARE_IS_DISPATCHED( vkCmdCopyImageToBuffer2 ) - DECLARE_IS_DISPATCHED( vkCmdCopyImageToBuffer2KHR ) - DECLARE_IS_DISPATCHED( vkCmdCopyMemoryIndirectKHR ) - DECLARE_IS_DISPATCHED( vkCmdCopyMemoryIndirectNV ) - DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToAccelerationStructureKHR ) - DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToImageIndirectKHR ) - DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToImageIndirectNV ) - DECLARE_IS_DISPATCHED( vkCmdCopyMemoryToMicromapEXT ) - DECLARE_IS_DISPATCHED( vkCmdCopyMicromapEXT ) - DECLARE_IS_DISPATCHED( vkCmdCopyMicromapToMemoryEXT ) - DECLARE_IS_DISPATCHED( vkCmdCopyQueryPoolResults ) - DECLARE_IS_DISPATCHED( vkCmdCopyTensorARM ) - DECLARE_IS_DISPATCHED( vkCmdCuLaunchKernelNVX ) - DECLARE_IS_DISPATCHED( vkCmdCudaLaunchKernelNV ) - DECLARE_IS_DISPATCHED( vkCmdDebugMarkerBeginEXT ) - DECLARE_IS_DISPATCHED( vkCmdDebugMarkerEndEXT ) - DECLARE_IS_DISPATCHED( vkCmdDebugMarkerInsertEXT ) - DECLARE_IS_DISPATCHED( vkCmdDecodeVideoKHR ) - DECLARE_IS_DISPATCHED( vkCmdDecompressMemoryEXT ) - DECLARE_IS_DISPATCHED( vkCmdDecompressMemoryIndirectCountEXT ) - DECLARE_IS_DISPATCHED( vkCmdDecompressMemoryIndirectCountNV ) - DECLARE_IS_DISPATCHED( vkCmdDecompressMemoryNV ) - DECLARE_IS_DISPATCHED( vkCmdDispatch ) - DECLARE_IS_DISPATCHED( vkCmdDispatchBase ) - DECLARE_IS_DISPATCHED( vkCmdDispatchBaseKHR ) - DECLARE_IS_DISPATCHED( vkCmdDispatchDataGraphARM ) - DECLARE_IS_DISPATCHED( vkCmdDispatchGraphAMDX ) - DECLARE_IS_DISPATCHED( vkCmdDispatchGraphIndirectAMDX ) - DECLARE_IS_DISPATCHED( vkCmdDispatchGraphIndirectCountAMDX ) - DECLARE_IS_DISPATCHED( vkCmdDispatchIndirect ) - DECLARE_IS_DISPATCHED( vkCmdDispatchTileQCOM ) - DECLARE_IS_DISPATCHED( vkCmdDraw ) - DECLARE_IS_DISPATCHED( vkCmdDrawClusterHUAWEI ) - DECLARE_IS_DISPATCHED( vkCmdDrawClusterIndirectHUAWEI ) - DECLARE_IS_DISPATCHED( vkCmdDrawIndexed ) - DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirect ) - DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirectCount ) - DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirectCountAMD ) - DECLARE_IS_DISPATCHED( vkCmdDrawIndexedIndirectCountKHR ) - DECLARE_IS_DISPATCHED( vkCmdDrawIndirect ) - DECLARE_IS_DISPATCHED( vkCmdDrawIndirectByteCountEXT ) - DECLARE_IS_DISPATCHED( vkCmdDrawIndirectCount ) - DECLARE_IS_DISPATCHED( vkCmdDrawIndirectCountAMD ) - DECLARE_IS_DISPATCHED( vkCmdDrawIndirectCountKHR ) - DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksEXT ) - DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectCountEXT ) - DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectCountNV ) - DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectEXT ) - DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksIndirectNV ) - DECLARE_IS_DISPATCHED( vkCmdDrawMeshTasksNV ) - DECLARE_IS_DISPATCHED( vkCmdDrawMultiEXT ) - DECLARE_IS_DISPATCHED( vkCmdDrawMultiIndexedEXT ) - DECLARE_IS_DISPATCHED( vkCmdEncodeVideoKHR ) - DECLARE_IS_DISPATCHED( vkCmdEndConditionalRenderingEXT ) - DECLARE_IS_DISPATCHED( vkCmdEndDebugUtilsLabelEXT ) - DECLARE_IS_DISPATCHED( vkCmdEndPerTileExecutionQCOM ) - DECLARE_IS_DISPATCHED( vkCmdEndQuery ) - DECLARE_IS_DISPATCHED( vkCmdEndQueryIndexedEXT ) - DECLARE_IS_DISPATCHED( vkCmdEndRenderPass ) - DECLARE_IS_DISPATCHED( vkCmdEndRenderPass2 ) - DECLARE_IS_DISPATCHED( vkCmdEndRenderPass2KHR ) - DECLARE_IS_DISPATCHED( vkCmdEndRendering ) - DECLARE_IS_DISPATCHED( vkCmdEndRenderingKHR ) - DECLARE_IS_DISPATCHED( vkCmdEndRendering2KHR ) - DECLARE_IS_DISPATCHED( vkCmdEndRendering2EXT ) - DECLARE_IS_DISPATCHED( vkCmdEndTransformFeedbackEXT ) - DECLARE_IS_DISPATCHED( vkCmdEndVideoCodingKHR ) - DECLARE_IS_DISPATCHED( vkCmdExecuteCommands ) - DECLARE_IS_DISPATCHED( vkCmdExecuteGeneratedCommandsEXT ) - DECLARE_IS_DISPATCHED( vkCmdExecuteGeneratedCommandsNV ) - DECLARE_IS_DISPATCHED( vkCmdFillBuffer ) - DECLARE_IS_DISPATCHED( vkCmdInitializeGraphScratchMemoryAMDX ) - DECLARE_IS_DISPATCHED( vkCmdInsertDebugUtilsLabelEXT ) - DECLARE_IS_DISPATCHED( vkCmdNextSubpass ) - DECLARE_IS_DISPATCHED( vkCmdNextSubpass2 ) - DECLARE_IS_DISPATCHED( vkCmdNextSubpass2KHR ) - DECLARE_IS_DISPATCHED( vkCmdOpticalFlowExecuteNV ) - DECLARE_IS_DISPATCHED( vkCmdPipelineBarrier ) - DECLARE_IS_DISPATCHED( vkCmdPipelineBarrier2 ) - DECLARE_IS_DISPATCHED( vkCmdPipelineBarrier2KHR ) - DECLARE_IS_DISPATCHED( vkCmdPreprocessGeneratedCommandsEXT ) - DECLARE_IS_DISPATCHED( vkCmdPreprocessGeneratedCommandsNV ) - DECLARE_IS_DISPATCHED( vkCmdPushConstants ) - DECLARE_IS_DISPATCHED( vkCmdPushConstants2 ) - DECLARE_IS_DISPATCHED( vkCmdPushConstants2KHR ) - DECLARE_IS_DISPATCHED( vkCmdPushDataEXT ) - DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSet ) - DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSetKHR ) - DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSet2 ) - DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSet2KHR ) - DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSetWithTemplate ) - DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSetWithTemplateKHR ) - DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSetWithTemplate2 ) - DECLARE_IS_DISPATCHED( vkCmdPushDescriptorSetWithTemplate2KHR ) - DECLARE_IS_DISPATCHED( vkCmdRefreshObjectsKHR ) - DECLARE_IS_DISPATCHED( vkCmdResetEvent ) - DECLARE_IS_DISPATCHED( vkCmdResetEvent2 ) - DECLARE_IS_DISPATCHED( vkCmdResetEvent2KHR ) - DECLARE_IS_DISPATCHED( vkCmdResetQueryPool ) - DECLARE_IS_DISPATCHED( vkCmdResolveImage ) - DECLARE_IS_DISPATCHED( vkCmdResolveImage2 ) - DECLARE_IS_DISPATCHED( vkCmdResolveImage2KHR ) - DECLARE_IS_DISPATCHED( vkCmdSetAlphaToCoverageEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetAlphaToOneEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetAttachmentFeedbackLoopEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetBlendConstants ) - DECLARE_IS_DISPATCHED( vkCmdSetCheckpointNV ) - DECLARE_IS_DISPATCHED( vkCmdSetCoarseSampleOrderNV ) - DECLARE_IS_DISPATCHED( vkCmdSetColorBlendAdvancedEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetColorBlendEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetColorBlendEquationEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetColorWriteEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetColorWriteMaskEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetComputeOccupancyPriorityNV ) - DECLARE_IS_DISPATCHED( vkCmdSetConservativeRasterizationModeEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetCoverageModulationModeNV ) - DECLARE_IS_DISPATCHED( vkCmdSetCoverageModulationTableEnableNV ) - DECLARE_IS_DISPATCHED( vkCmdSetCoverageModulationTableNV ) - DECLARE_IS_DISPATCHED( vkCmdSetCoverageReductionModeNV ) - DECLARE_IS_DISPATCHED( vkCmdSetCoverageToColorEnableNV ) - DECLARE_IS_DISPATCHED( vkCmdSetCoverageToColorLocationNV ) - DECLARE_IS_DISPATCHED( vkCmdSetCullMode ) - DECLARE_IS_DISPATCHED( vkCmdSetCullModeEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthBias ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthBias2EXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthBiasEnable ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthBiasEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthBounds ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthBoundsTestEnable ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthBoundsTestEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthClampEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthClampRangeEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthClipEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthClipNegativeOneToOneEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthCompareOp ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthCompareOpEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthTestEnable ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthTestEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthWriteEnable ) - DECLARE_IS_DISPATCHED( vkCmdSetDepthWriteEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDescriptorBufferOffsets2EXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDescriptorBufferOffsetsEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDeviceMask ) - DECLARE_IS_DISPATCHED( vkCmdSetDeviceMaskKHR ) - DECLARE_IS_DISPATCHED( vkCmdSetDiscardRectangleEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDiscardRectangleEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetDiscardRectangleModeEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetEvent ) - DECLARE_IS_DISPATCHED( vkCmdSetEvent2 ) - DECLARE_IS_DISPATCHED( vkCmdSetEvent2KHR ) - DECLARE_IS_DISPATCHED( vkCmdSetExclusiveScissorEnableNV ) - DECLARE_IS_DISPATCHED( vkCmdSetExclusiveScissorNV ) - DECLARE_IS_DISPATCHED( vkCmdSetExtraPrimitiveOverestimationSizeEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetFragmentShadingRateEnumNV ) - DECLARE_IS_DISPATCHED( vkCmdSetFragmentShadingRateKHR ) - DECLARE_IS_DISPATCHED( vkCmdSetFrontFace ) - DECLARE_IS_DISPATCHED( vkCmdSetFrontFaceEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetLineRasterizationModeEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetLineStipple ) - DECLARE_IS_DISPATCHED( vkCmdSetLineStippleEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetLineStippleKHR ) - DECLARE_IS_DISPATCHED( vkCmdSetLineStippleEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetLineWidth ) - DECLARE_IS_DISPATCHED( vkCmdSetLogicOpEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetLogicOpEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetPatchControlPointsEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetPerformanceMarkerINTEL ) - DECLARE_IS_DISPATCHED( vkCmdSetPerformanceOverrideINTEL ) - DECLARE_IS_DISPATCHED( vkCmdSetPerformanceStreamMarkerINTEL ) - DECLARE_IS_DISPATCHED( vkCmdSetPolygonModeEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetPrimitiveRestartEnable ) - DECLARE_IS_DISPATCHED( vkCmdSetPrimitiveRestartEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetPrimitiveTopology ) - DECLARE_IS_DISPATCHED( vkCmdSetPrimitiveTopologyEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetProvokingVertexModeEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetRasterizationSamplesEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetRasterizationStreamEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetRasterizerDiscardEnable ) - DECLARE_IS_DISPATCHED( vkCmdSetRasterizerDiscardEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetRayTracingPipelineStackSizeKHR ) - DECLARE_IS_DISPATCHED( vkCmdSetRenderingAttachmentLocations ) - DECLARE_IS_DISPATCHED( vkCmdSetRenderingAttachmentLocationsKHR ) - DECLARE_IS_DISPATCHED( vkCmdSetRenderingInputAttachmentIndices ) - DECLARE_IS_DISPATCHED( vkCmdSetRenderingInputAttachmentIndicesKHR ) - DECLARE_IS_DISPATCHED( vkCmdSetRepresentativeFragmentTestEnableNV ) - DECLARE_IS_DISPATCHED( vkCmdSetSampleLocationsEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetSampleLocationsEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetSampleMaskEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetScissor ) - DECLARE_IS_DISPATCHED( vkCmdSetScissorWithCount ) - DECLARE_IS_DISPATCHED( vkCmdSetScissorWithCountEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetShadingRateImageEnableNV ) - DECLARE_IS_DISPATCHED( vkCmdSetStencilCompareMask ) - DECLARE_IS_DISPATCHED( vkCmdSetStencilOp ) - DECLARE_IS_DISPATCHED( vkCmdSetStencilOpEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetStencilReference ) - DECLARE_IS_DISPATCHED( vkCmdSetStencilTestEnable ) - DECLARE_IS_DISPATCHED( vkCmdSetStencilTestEnableEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetStencilWriteMask ) - DECLARE_IS_DISPATCHED( vkCmdSetTessellationDomainOriginEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetVertexInputEXT ) - DECLARE_IS_DISPATCHED( vkCmdSetViewport ) - DECLARE_IS_DISPATCHED( vkCmdSetViewportShadingRatePaletteNV ) - DECLARE_IS_DISPATCHED( vkCmdSetViewportSwizzleNV ) - DECLARE_IS_DISPATCHED( vkCmdSetViewportWScalingEnableNV ) - DECLARE_IS_DISPATCHED( vkCmdSetViewportWScalingNV ) - DECLARE_IS_DISPATCHED( vkCmdSetViewportWithCount ) - DECLARE_IS_DISPATCHED( vkCmdSetViewportWithCountEXT ) - DECLARE_IS_DISPATCHED( vkCmdSubpassShadingHUAWEI ) - DECLARE_IS_DISPATCHED( vkCmdTraceRaysIndirect2KHR ) - DECLARE_IS_DISPATCHED( vkCmdTraceRaysIndirectKHR ) - DECLARE_IS_DISPATCHED( vkCmdTraceRaysKHR ) - DECLARE_IS_DISPATCHED( vkCmdTraceRaysNV ) - DECLARE_IS_DISPATCHED( vkCmdUpdateBuffer ) - DECLARE_IS_DISPATCHED( vkCmdUpdatePipelineIndirectBufferNV ) - DECLARE_IS_DISPATCHED( vkCmdWaitEvents ) - DECLARE_IS_DISPATCHED( vkCmdWaitEvents2 ) - DECLARE_IS_DISPATCHED( vkCmdWaitEvents2KHR ) - DECLARE_IS_DISPATCHED( vkCmdWriteAccelerationStructuresPropertiesKHR ) - DECLARE_IS_DISPATCHED( vkCmdWriteAccelerationStructuresPropertiesNV ) - DECLARE_IS_DISPATCHED( vkCmdWriteBufferMarker2AMD ) - DECLARE_IS_DISPATCHED( vkCmdWriteBufferMarkerAMD ) - DECLARE_IS_DISPATCHED( vkCmdWriteMicromapsPropertiesEXT ) - DECLARE_IS_DISPATCHED( vkCmdWriteTimestamp ) - DECLARE_IS_DISPATCHED( vkCmdWriteTimestamp2 ) - DECLARE_IS_DISPATCHED( vkCmdWriteTimestamp2KHR ) - DECLARE_IS_DISPATCHED( vkCompileDeferredNV ) - DECLARE_IS_DISPATCHED( vkConvertCooperativeVectorMatrixNV ) - DECLARE_IS_DISPATCHED( vkCopyAccelerationStructureKHR ) - DECLARE_IS_DISPATCHED( vkCopyAccelerationStructureToMemoryKHR ) - DECLARE_IS_DISPATCHED( vkCopyImageToImage ) - DECLARE_IS_DISPATCHED( vkCopyImageToImageEXT ) - DECLARE_IS_DISPATCHED( vkCopyImageToMemory ) - DECLARE_IS_DISPATCHED( vkCopyImageToMemoryEXT ) - DECLARE_IS_DISPATCHED( vkCopyMemoryToAccelerationStructureKHR ) - DECLARE_IS_DISPATCHED( vkCopyMemoryToImage ) - DECLARE_IS_DISPATCHED( vkCopyMemoryToImageEXT ) - DECLARE_IS_DISPATCHED( vkCopyMemoryToMicromapEXT ) - DECLARE_IS_DISPATCHED( vkCopyMicromapEXT ) - DECLARE_IS_DISPATCHED( vkCopyMicromapToMemoryEXT ) - DECLARE_IS_DISPATCHED( vkCreateAccelerationStructureKHR ) - DECLARE_IS_DISPATCHED( vkCreateAccelerationStructureNV ) - DECLARE_IS_DISPATCHED( vkCreateAndroidSurfaceKHR ) - DECLARE_IS_DISPATCHED( vkCreateBuffer ) - DECLARE_IS_DISPATCHED( vkCreateBufferCollectionFUCHSIA ) - DECLARE_IS_DISPATCHED( vkCreateBufferView ) - DECLARE_IS_DISPATCHED( vkCreateCommandPool ) - DECLARE_IS_DISPATCHED( vkCreateComputePipelines ) - DECLARE_IS_DISPATCHED( vkCreateCuFunctionNVX ) - DECLARE_IS_DISPATCHED( vkCreateCuModuleNVX ) - DECLARE_IS_DISPATCHED( vkCreateCudaFunctionNV ) - DECLARE_IS_DISPATCHED( vkCreateCudaModuleNV ) - DECLARE_IS_DISPATCHED( vkCreateDataGraphPipelineSessionARM ) - DECLARE_IS_DISPATCHED( vkCreateDataGraphPipelinesARM ) - DECLARE_IS_DISPATCHED( vkCreateDebugReportCallbackEXT ) - DECLARE_IS_DISPATCHED( vkCreateDebugUtilsMessengerEXT ) - DECLARE_IS_DISPATCHED( vkCreateDeferredOperationKHR ) - DECLARE_IS_DISPATCHED( vkCreateDescriptorPool ) - DECLARE_IS_DISPATCHED( vkCreateDescriptorSetLayout ) - DECLARE_IS_DISPATCHED( vkCreateDescriptorUpdateTemplate ) - DECLARE_IS_DISPATCHED( vkCreateDescriptorUpdateTemplateKHR ) - DECLARE_IS_DISPATCHED( vkCreateDevice ) - DECLARE_IS_DISPATCHED( vkCreateDirectFBSurfaceEXT ) - DECLARE_IS_DISPATCHED( vkCreateDisplayModeKHR ) - DECLARE_IS_DISPATCHED( vkCreateDisplayPlaneSurfaceKHR ) - DECLARE_IS_DISPATCHED( vkCreateEvent ) - DECLARE_IS_DISPATCHED( vkCreateExecutionGraphPipelinesAMDX ) - DECLARE_IS_DISPATCHED( vkCreateExternalComputeQueueNV ) - DECLARE_IS_DISPATCHED( vkCreateFence ) - DECLARE_IS_DISPATCHED( vkCreateFramebuffer ) - DECLARE_IS_DISPATCHED( vkCreateGraphicsPipelines ) - DECLARE_IS_DISPATCHED( vkCreateHeadlessSurfaceEXT ) - DECLARE_IS_DISPATCHED( vkCreateIOSSurfaceMVK ) - DECLARE_IS_DISPATCHED( vkCreateImage ) - DECLARE_IS_DISPATCHED( vkCreateImagePipeSurfaceFUCHSIA ) - DECLARE_IS_DISPATCHED( vkCreateImageView ) - DECLARE_IS_DISPATCHED( vkCreateIndirectCommandsLayoutEXT ) - DECLARE_IS_DISPATCHED( vkCreateIndirectCommandsLayoutNV ) - DECLARE_IS_DISPATCHED( vkCreateIndirectExecutionSetEXT ) - DECLARE_IS_DISPATCHED( vkCreateInstance ) - DECLARE_IS_DISPATCHED( vkCreateMacOSSurfaceMVK ) - DECLARE_IS_DISPATCHED( vkCreateMetalSurfaceEXT ) - DECLARE_IS_DISPATCHED( vkCreateMicromapEXT ) - DECLARE_IS_DISPATCHED( vkCreateOpticalFlowSessionNV ) - DECLARE_IS_DISPATCHED( vkCreatePipelineBinariesKHR ) - DECLARE_IS_DISPATCHED( vkCreatePipelineCache ) - DECLARE_IS_DISPATCHED( vkCreatePipelineLayout ) - DECLARE_IS_DISPATCHED( vkCreatePrivateDataSlot ) - DECLARE_IS_DISPATCHED( vkCreatePrivateDataSlotEXT ) - DECLARE_IS_DISPATCHED( vkCreateQueryPool ) - DECLARE_IS_DISPATCHED( vkCreateRayTracingPipelinesKHR ) - DECLARE_IS_DISPATCHED( vkCreateRayTracingPipelinesNV ) - DECLARE_IS_DISPATCHED( vkCreateRenderPass ) - DECLARE_IS_DISPATCHED( vkCreateRenderPass2 ) - DECLARE_IS_DISPATCHED( vkCreateRenderPass2KHR ) - DECLARE_IS_DISPATCHED( vkCreateSampler ) - DECLARE_IS_DISPATCHED( vkCreateSamplerYcbcrConversion ) - DECLARE_IS_DISPATCHED( vkCreateSamplerYcbcrConversionKHR ) - DECLARE_IS_DISPATCHED( vkCreateScreenSurfaceQNX ) - DECLARE_IS_DISPATCHED( vkCreateSemaphore ) - DECLARE_IS_DISPATCHED( vkCreateSemaphoreSciSyncPoolNV ) - DECLARE_IS_DISPATCHED( vkCreateShaderModule ) - DECLARE_IS_DISPATCHED( vkCreateShadersEXT ) - DECLARE_IS_DISPATCHED( vkCreateSharedSwapchainsKHR ) - DECLARE_IS_DISPATCHED( vkCreateStreamDescriptorSurfaceGGP ) - DECLARE_IS_DISPATCHED( vkCreateSurfaceOHOS ) - DECLARE_IS_DISPATCHED( vkCreateSwapchainKHR ) - DECLARE_IS_DISPATCHED( vkCreateTensorARM ) - DECLARE_IS_DISPATCHED( vkCreateTensorViewARM ) - DECLARE_IS_DISPATCHED( vkCreateValidationCacheEXT ) - DECLARE_IS_DISPATCHED( vkCreateViSurfaceNN ) - DECLARE_IS_DISPATCHED( vkCreateVideoSessionKHR ) - DECLARE_IS_DISPATCHED( vkCreateVideoSessionParametersKHR ) - DECLARE_IS_DISPATCHED( vkCreateWaylandSurfaceKHR ) - DECLARE_IS_DISPATCHED( vkCreateWin32SurfaceKHR ) - DECLARE_IS_DISPATCHED( vkCreateXcbSurfaceKHR ) - DECLARE_IS_DISPATCHED( vkCreateXlibSurfaceKHR ) - DECLARE_IS_DISPATCHED( vkDebugMarkerSetObjectNameEXT ) - DECLARE_IS_DISPATCHED( vkDebugMarkerSetObjectTagEXT ) - DECLARE_IS_DISPATCHED( vkDebugReportMessageEXT ) - DECLARE_IS_DISPATCHED( vkDeferredOperationJoinKHR ) - DECLARE_IS_DISPATCHED( vkDestroyAccelerationStructureKHR ) - DECLARE_IS_DISPATCHED( vkDestroyAccelerationStructureNV ) - DECLARE_IS_DISPATCHED( vkDestroyBuffer ) - DECLARE_IS_DISPATCHED( vkDestroyBufferCollectionFUCHSIA ) - DECLARE_IS_DISPATCHED( vkDestroyBufferView ) - DECLARE_IS_DISPATCHED( vkDestroyCommandPool ) - DECLARE_IS_DISPATCHED( vkDestroyCuFunctionNVX ) - DECLARE_IS_DISPATCHED( vkDestroyCuModuleNVX ) - DECLARE_IS_DISPATCHED( vkDestroyCudaFunctionNV ) - DECLARE_IS_DISPATCHED( vkDestroyCudaModuleNV ) - DECLARE_IS_DISPATCHED( vkDestroyDataGraphPipelineSessionARM ) - DECLARE_IS_DISPATCHED( vkDestroyDebugReportCallbackEXT ) - DECLARE_IS_DISPATCHED( vkDestroyDebugUtilsMessengerEXT ) - DECLARE_IS_DISPATCHED( vkDestroyDeferredOperationKHR ) - DECLARE_IS_DISPATCHED( vkDestroyDescriptorPool ) - DECLARE_IS_DISPATCHED( vkDestroyDescriptorSetLayout ) - DECLARE_IS_DISPATCHED( vkDestroyDescriptorUpdateTemplate ) - DECLARE_IS_DISPATCHED( vkDestroyDescriptorUpdateTemplateKHR ) - DECLARE_IS_DISPATCHED( vkDestroyDevice ) - DECLARE_IS_DISPATCHED( vkDestroyEvent ) - DECLARE_IS_DISPATCHED( vkDestroyExternalComputeQueueNV ) - DECLARE_IS_DISPATCHED( vkDestroyFence ) - DECLARE_IS_DISPATCHED( vkDestroyFramebuffer ) - DECLARE_IS_DISPATCHED( vkDestroyImage ) - DECLARE_IS_DISPATCHED( vkDestroyImageView ) - DECLARE_IS_DISPATCHED( vkDestroyIndirectCommandsLayoutEXT ) - DECLARE_IS_DISPATCHED( vkDestroyIndirectCommandsLayoutNV ) - DECLARE_IS_DISPATCHED( vkDestroyIndirectExecutionSetEXT ) - DECLARE_IS_DISPATCHED( vkDestroyInstance ) - DECLARE_IS_DISPATCHED( vkDestroyMicromapEXT ) - DECLARE_IS_DISPATCHED( vkDestroyOpticalFlowSessionNV ) - DECLARE_IS_DISPATCHED( vkDestroyPipeline ) - DECLARE_IS_DISPATCHED( vkDestroyPipelineBinaryKHR ) - DECLARE_IS_DISPATCHED( vkDestroyPipelineCache ) - DECLARE_IS_DISPATCHED( vkDestroyPipelineLayout ) - DECLARE_IS_DISPATCHED( vkDestroyPrivateDataSlot ) - DECLARE_IS_DISPATCHED( vkDestroyPrivateDataSlotEXT ) - DECLARE_IS_DISPATCHED( vkDestroyQueryPool ) - DECLARE_IS_DISPATCHED( vkDestroyRenderPass ) - DECLARE_IS_DISPATCHED( vkDestroySampler ) - DECLARE_IS_DISPATCHED( vkDestroySamplerYcbcrConversion ) - DECLARE_IS_DISPATCHED( vkDestroySamplerYcbcrConversionKHR ) - DECLARE_IS_DISPATCHED( vkDestroySemaphore ) - DECLARE_IS_DISPATCHED( vkDestroySemaphoreSciSyncPoolNV ) - DECLARE_IS_DISPATCHED( vkDestroyShaderEXT ) - DECLARE_IS_DISPATCHED( vkDestroyShaderModule ) - DECLARE_IS_DISPATCHED( vkDestroySurfaceKHR ) - DECLARE_IS_DISPATCHED( vkDestroySwapchainKHR ) - DECLARE_IS_DISPATCHED( vkDestroyTensorARM ) - DECLARE_IS_DISPATCHED( vkDestroyTensorViewARM ) - DECLARE_IS_DISPATCHED( vkDestroyValidationCacheEXT ) - DECLARE_IS_DISPATCHED( vkDestroyVideoSessionKHR ) - DECLARE_IS_DISPATCHED( vkDestroyVideoSessionParametersKHR ) - DECLARE_IS_DISPATCHED( vkDeviceWaitIdle ) - DECLARE_IS_DISPATCHED( vkDisplayPowerControlEXT ) - DECLARE_IS_DISPATCHED( vkEndCommandBuffer ) - DECLARE_IS_DISPATCHED( vkEnumerateDeviceExtensionProperties ) - DECLARE_IS_DISPATCHED( vkEnumerateDeviceLayerProperties ) - DECLARE_IS_DISPATCHED( vkEnumerateInstanceExtensionProperties ) - DECLARE_IS_DISPATCHED( vkEnumerateInstanceLayerProperties ) - DECLARE_IS_DISPATCHED( vkEnumerateInstanceVersion ) - DECLARE_IS_DISPATCHED( vkEnumeratePhysicalDeviceGroups ) - DECLARE_IS_DISPATCHED( vkEnumeratePhysicalDeviceGroupsKHR ) - DECLARE_IS_DISPATCHED( vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM ) - DECLARE_IS_DISPATCHED( vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR ) - DECLARE_IS_DISPATCHED( vkEnumeratePhysicalDevices ) - DECLARE_IS_DISPATCHED( vkExportMetalObjectsEXT ) - DECLARE_IS_DISPATCHED( vkFlushMappedMemoryRanges ) - DECLARE_IS_DISPATCHED( vkFreeCommandBuffers ) - DECLARE_IS_DISPATCHED( vkFreeDescriptorSets ) - DECLARE_IS_DISPATCHED( vkFreeMemory ) - DECLARE_IS_DISPATCHED( vkGetAccelerationStructureBuildSizesKHR ) - DECLARE_IS_DISPATCHED( vkGetAccelerationStructureDeviceAddressKHR ) - DECLARE_IS_DISPATCHED( vkGetAccelerationStructureHandleNV ) - DECLARE_IS_DISPATCHED( vkGetAccelerationStructureMemoryRequirementsNV ) - DECLARE_IS_DISPATCHED( vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT ) - DECLARE_IS_DISPATCHED( vkGetAndroidHardwareBufferPropertiesANDROID ) - DECLARE_IS_DISPATCHED( vkGetBufferCollectionPropertiesFUCHSIA ) - DECLARE_IS_DISPATCHED( vkGetBufferDeviceAddress ) - DECLARE_IS_DISPATCHED( vkGetBufferDeviceAddressEXT ) - DECLARE_IS_DISPATCHED( vkGetBufferDeviceAddressKHR ) - DECLARE_IS_DISPATCHED( vkGetBufferMemoryRequirements ) - DECLARE_IS_DISPATCHED( vkGetBufferMemoryRequirements2 ) - DECLARE_IS_DISPATCHED( vkGetBufferMemoryRequirements2KHR ) - DECLARE_IS_DISPATCHED( vkGetBufferOpaqueCaptureAddress ) - DECLARE_IS_DISPATCHED( vkGetBufferOpaqueCaptureAddressKHR ) - DECLARE_IS_DISPATCHED( vkGetBufferOpaqueCaptureDescriptorDataEXT ) - DECLARE_IS_DISPATCHED( vkGetCalibratedTimestampsKHR ) - DECLARE_IS_DISPATCHED( vkGetCalibratedTimestampsEXT ) - DECLARE_IS_DISPATCHED( vkGetClusterAccelerationStructureBuildSizesNV ) - DECLARE_IS_DISPATCHED( vkGetCommandPoolMemoryConsumption ) - DECLARE_IS_DISPATCHED( vkGetCudaModuleCacheNV ) - DECLARE_IS_DISPATCHED( vkGetDataGraphPipelineAvailablePropertiesARM ) - DECLARE_IS_DISPATCHED( vkGetDataGraphPipelinePropertiesARM ) - DECLARE_IS_DISPATCHED( vkGetDataGraphPipelineSessionBindPointRequirementsARM ) - DECLARE_IS_DISPATCHED( vkGetDataGraphPipelineSessionMemoryRequirementsARM ) - DECLARE_IS_DISPATCHED( vkGetDeferredOperationMaxConcurrencyKHR ) - DECLARE_IS_DISPATCHED( vkGetDeferredOperationResultKHR ) - DECLARE_IS_DISPATCHED( vkGetDescriptorEXT ) - DECLARE_IS_DISPATCHED( vkGetDescriptorSetHostMappingVALVE ) - DECLARE_IS_DISPATCHED( vkGetDescriptorSetLayoutBindingOffsetEXT ) - DECLARE_IS_DISPATCHED( vkGetDescriptorSetLayoutHostMappingInfoVALVE ) - DECLARE_IS_DISPATCHED( vkGetDescriptorSetLayoutSizeEXT ) - DECLARE_IS_DISPATCHED( vkGetDescriptorSetLayoutSupport ) - DECLARE_IS_DISPATCHED( vkGetDescriptorSetLayoutSupportKHR ) - DECLARE_IS_DISPATCHED( vkGetDeviceAccelerationStructureCompatibilityKHR ) - DECLARE_IS_DISPATCHED( vkGetDeviceBufferMemoryRequirements ) - DECLARE_IS_DISPATCHED( vkGetDeviceBufferMemoryRequirementsKHR ) - DECLARE_IS_DISPATCHED( vkGetDeviceCombinedImageSamplerIndexNVX ) - DECLARE_IS_DISPATCHED( vkGetDeviceFaultInfoEXT ) - DECLARE_IS_DISPATCHED( vkGetDeviceGroupPeerMemoryFeatures ) - DECLARE_IS_DISPATCHED( vkGetDeviceGroupPeerMemoryFeaturesKHR ) - DECLARE_IS_DISPATCHED( vkGetDeviceGroupPresentCapabilitiesKHR ) - DECLARE_IS_DISPATCHED( vkGetDeviceGroupSurfacePresentModes2EXT ) - DECLARE_IS_DISPATCHED( vkGetDeviceGroupSurfacePresentModesKHR ) - DECLARE_IS_DISPATCHED( vkGetDeviceImageMemoryRequirements ) - DECLARE_IS_DISPATCHED( vkGetDeviceImageMemoryRequirementsKHR ) - DECLARE_IS_DISPATCHED( vkGetDeviceImageSparseMemoryRequirements ) - DECLARE_IS_DISPATCHED( vkGetDeviceImageSparseMemoryRequirementsKHR ) - DECLARE_IS_DISPATCHED( vkGetDeviceImageSubresourceLayout ) - DECLARE_IS_DISPATCHED( vkGetDeviceImageSubresourceLayoutKHR ) - DECLARE_IS_DISPATCHED( vkGetDeviceMemoryCommitment ) - DECLARE_IS_DISPATCHED( vkGetDeviceMemoryOpaqueCaptureAddress ) - DECLARE_IS_DISPATCHED( vkGetDeviceMemoryOpaqueCaptureAddressKHR ) - DECLARE_IS_DISPATCHED( vkGetDeviceMicromapCompatibilityEXT ) - DECLARE_IS_DISPATCHED( vkGetDeviceProcAddr ) - DECLARE_IS_DISPATCHED( vkGetDeviceQueue ) - DECLARE_IS_DISPATCHED( vkGetDeviceQueue2 ) - DECLARE_IS_DISPATCHED( vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI ) - DECLARE_IS_DISPATCHED( vkGetDeviceTensorMemoryRequirementsARM ) - DECLARE_IS_DISPATCHED( vkGetDisplayModeProperties2KHR ) - DECLARE_IS_DISPATCHED( vkGetDisplayModePropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetDisplayPlaneCapabilities2KHR ) - DECLARE_IS_DISPATCHED( vkGetDisplayPlaneCapabilitiesKHR ) - DECLARE_IS_DISPATCHED( vkGetDisplayPlaneSupportedDisplaysKHR ) - DECLARE_IS_DISPATCHED( vkGetDrmDisplayEXT ) - DECLARE_IS_DISPATCHED( vkGetDynamicRenderingTilePropertiesQCOM ) - DECLARE_IS_DISPATCHED( vkGetEncodedVideoSessionParametersKHR ) - DECLARE_IS_DISPATCHED( vkGetEventStatus ) - DECLARE_IS_DISPATCHED( vkGetExecutionGraphPipelineNodeIndexAMDX ) - DECLARE_IS_DISPATCHED( vkGetExecutionGraphPipelineScratchSizeAMDX ) - DECLARE_IS_DISPATCHED( vkGetExternalComputeQueueDataNV ) - DECLARE_IS_DISPATCHED( vkGetFaultData ) - DECLARE_IS_DISPATCHED( vkGetFenceFdKHR ) - DECLARE_IS_DISPATCHED( vkGetFenceSciSyncFenceNV ) - DECLARE_IS_DISPATCHED( vkGetFenceSciSyncObjNV ) - DECLARE_IS_DISPATCHED( vkGetFenceStatus ) - DECLARE_IS_DISPATCHED( vkGetFenceWin32HandleKHR ) - DECLARE_IS_DISPATCHED( vkGetFramebufferTilePropertiesQCOM ) - DECLARE_IS_DISPATCHED( vkGetGeneratedCommandsMemoryRequirementsEXT ) - DECLARE_IS_DISPATCHED( vkGetGeneratedCommandsMemoryRequirementsNV ) - DECLARE_IS_DISPATCHED( vkGetImageDrmFormatModifierPropertiesEXT ) - DECLARE_IS_DISPATCHED( vkGetImageMemoryRequirements ) - DECLARE_IS_DISPATCHED( vkGetImageMemoryRequirements2 ) - DECLARE_IS_DISPATCHED( vkGetImageMemoryRequirements2KHR ) - DECLARE_IS_DISPATCHED( vkGetImageOpaqueCaptureDataEXT ) - DECLARE_IS_DISPATCHED( vkGetImageOpaqueCaptureDescriptorDataEXT ) - DECLARE_IS_DISPATCHED( vkGetImageSparseMemoryRequirements ) - DECLARE_IS_DISPATCHED( vkGetImageSparseMemoryRequirements2 ) - DECLARE_IS_DISPATCHED( vkGetImageSparseMemoryRequirements2KHR ) - DECLARE_IS_DISPATCHED( vkGetImageSubresourceLayout ) - DECLARE_IS_DISPATCHED( vkGetImageSubresourceLayout2 ) - DECLARE_IS_DISPATCHED( vkGetImageSubresourceLayout2EXT ) - DECLARE_IS_DISPATCHED( vkGetImageSubresourceLayout2KHR ) - DECLARE_IS_DISPATCHED( vkGetImageViewAddressNVX ) - DECLARE_IS_DISPATCHED( vkGetImageViewHandle64NVX ) - DECLARE_IS_DISPATCHED( vkGetImageViewHandleNVX ) - DECLARE_IS_DISPATCHED( vkGetImageViewOpaqueCaptureDescriptorDataEXT ) - DECLARE_IS_DISPATCHED( vkGetInstanceProcAddr ) - DECLARE_IS_DISPATCHED( vkGetLatencyTimingsNV ) - DECLARE_IS_DISPATCHED( vkGetMemoryAndroidHardwareBufferANDROID ) - DECLARE_IS_DISPATCHED( vkGetMemoryFdKHR ) - DECLARE_IS_DISPATCHED( vkGetMemoryFdPropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetMemoryHostPointerPropertiesEXT ) - DECLARE_IS_DISPATCHED( vkGetMemoryMetalHandleEXT ) - DECLARE_IS_DISPATCHED( vkGetMemoryMetalHandlePropertiesEXT ) - DECLARE_IS_DISPATCHED( vkGetMemoryNativeBufferOHOS ) - DECLARE_IS_DISPATCHED( vkGetMemoryRemoteAddressNV ) - DECLARE_IS_DISPATCHED( vkGetMemorySciBufNV ) - DECLARE_IS_DISPATCHED( vkGetMemoryWin32HandleKHR ) - DECLARE_IS_DISPATCHED( vkGetMemoryWin32HandleNV ) - DECLARE_IS_DISPATCHED( vkGetMemoryWin32HandlePropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetMemoryZirconHandleFUCHSIA ) - DECLARE_IS_DISPATCHED( vkGetMemoryZirconHandlePropertiesFUCHSIA ) - DECLARE_IS_DISPATCHED( vkGetMicromapBuildSizesEXT ) - DECLARE_IS_DISPATCHED( vkGetNativeBufferPropertiesOHOS ) - DECLARE_IS_DISPATCHED( vkGetPartitionedAccelerationStructuresBuildSizesNV ) - DECLARE_IS_DISPATCHED( vkGetPastPresentationTimingEXT ) - DECLARE_IS_DISPATCHED( vkGetPastPresentationTimingGOOGLE ) - DECLARE_IS_DISPATCHED( vkGetPerformanceParameterINTEL ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCalibrateableTimeDomainsKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCalibrateableTimeDomainsEXT ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeMatrixPropertiesNV ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceCooperativeVectorPropertiesNV ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDescriptorSizeEXT ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDirectFBPresentationSupportEXT ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDisplayPlaneProperties2KHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDisplayPlanePropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDisplayProperties2KHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceDisplayPropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalBufferProperties ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalBufferPropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalFenceProperties ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalFencePropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalImageFormatPropertiesNV ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalSemaphoreProperties ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalSemaphorePropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceExternalTensorPropertiesARM ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFeatures ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFeatures2 ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFeatures2KHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFormatProperties ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFormatProperties2 ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFormatProperties2KHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceFragmentShadingRatesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceImageFormatProperties ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceImageFormatProperties2 ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceImageFormatProperties2KHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceMemoryProperties ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceMemoryProperties2 ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceMemoryProperties2KHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceMultisamplePropertiesEXT ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceOpticalFlowImageFormatsNV ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDevicePresentRectanglesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceProperties ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceProperties2 ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceProperties2KHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyProperties ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyProperties2 ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceQueueFamilyProperties2KHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceRefreshableObjectTypesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSciBufAttributesNV ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSciSyncAttributesNV ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceScreenPresentationSupportQNX ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSparseImageFormatProperties ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSparseImageFormatProperties2 ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSparseImageFormatProperties2KHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceCapabilities2EXT ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceCapabilities2KHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceCapabilitiesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceFormats2KHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceFormatsKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfacePresentModes2EXT ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfacePresentModesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceSurfaceSupportKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceToolProperties ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceToolPropertiesEXT ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceVideoCapabilitiesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceVideoFormatPropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceWaylandPresentationSupportKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceWin32PresentationSupportKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceXcbPresentationSupportKHR ) - DECLARE_IS_DISPATCHED( vkGetPhysicalDeviceXlibPresentationSupportKHR ) - DECLARE_IS_DISPATCHED( vkGetPipelineBinaryDataKHR ) - DECLARE_IS_DISPATCHED( vkGetPipelineCacheData ) - DECLARE_IS_DISPATCHED( vkGetPipelineExecutableInternalRepresentationsKHR ) - DECLARE_IS_DISPATCHED( vkGetPipelineExecutablePropertiesKHR ) - DECLARE_IS_DISPATCHED( vkGetPipelineExecutableStatisticsKHR ) - DECLARE_IS_DISPATCHED( vkGetPipelineIndirectDeviceAddressNV ) - DECLARE_IS_DISPATCHED( vkGetPipelineIndirectMemoryRequirementsNV ) - DECLARE_IS_DISPATCHED( vkGetPipelineKeyKHR ) - DECLARE_IS_DISPATCHED( vkGetPipelinePropertiesEXT ) - DECLARE_IS_DISPATCHED( vkGetPrivateData ) - DECLARE_IS_DISPATCHED( vkGetPrivateDataEXT ) - DECLARE_IS_DISPATCHED( vkGetQueryPoolResults ) - DECLARE_IS_DISPATCHED( vkGetQueueCheckpointData2NV ) - DECLARE_IS_DISPATCHED( vkGetQueueCheckpointDataNV ) - DECLARE_IS_DISPATCHED( vkGetRandROutputDisplayEXT ) - DECLARE_IS_DISPATCHED( vkGetRayTracingCaptureReplayShaderGroupHandlesKHR ) - DECLARE_IS_DISPATCHED( vkGetRayTracingShaderGroupHandlesKHR ) - DECLARE_IS_DISPATCHED( vkGetRayTracingShaderGroupHandlesNV ) - DECLARE_IS_DISPATCHED( vkGetRayTracingShaderGroupStackSizeKHR ) - DECLARE_IS_DISPATCHED( vkGetRefreshCycleDurationGOOGLE ) - DECLARE_IS_DISPATCHED( vkGetRenderAreaGranularity ) - DECLARE_IS_DISPATCHED( vkGetRenderingAreaGranularity ) - DECLARE_IS_DISPATCHED( vkGetRenderingAreaGranularityKHR ) - DECLARE_IS_DISPATCHED( vkGetSamplerOpaqueCaptureDescriptorDataEXT ) - DECLARE_IS_DISPATCHED( vkGetScreenBufferPropertiesQNX ) - DECLARE_IS_DISPATCHED( vkGetSemaphoreCounterValue ) - DECLARE_IS_DISPATCHED( vkGetSemaphoreCounterValueKHR ) - DECLARE_IS_DISPATCHED( vkGetSemaphoreFdKHR ) - DECLARE_IS_DISPATCHED( vkGetSemaphoreSciSyncObjNV ) - DECLARE_IS_DISPATCHED( vkGetSemaphoreWin32HandleKHR ) - DECLARE_IS_DISPATCHED( vkGetSemaphoreZirconHandleFUCHSIA ) - DECLARE_IS_DISPATCHED( vkGetShaderBinaryDataEXT ) - DECLARE_IS_DISPATCHED( vkGetShaderInfoAMD ) - DECLARE_IS_DISPATCHED( vkGetShaderModuleCreateInfoIdentifierEXT ) - DECLARE_IS_DISPATCHED( vkGetShaderModuleIdentifierEXT ) - DECLARE_IS_DISPATCHED( vkGetSwapchainCounterEXT ) - DECLARE_IS_DISPATCHED( vkGetSwapchainGrallocUsage2ANDROID ) - DECLARE_IS_DISPATCHED( vkGetSwapchainGrallocUsageANDROID ) - DECLARE_IS_DISPATCHED( vkGetSwapchainGrallocUsageOHOS ) - DECLARE_IS_DISPATCHED( vkGetSwapchainImagesKHR ) - DECLARE_IS_DISPATCHED( vkGetSwapchainStatusKHR ) - DECLARE_IS_DISPATCHED( vkGetSwapchainTimeDomainPropertiesEXT ) - DECLARE_IS_DISPATCHED( vkGetSwapchainTimingPropertiesEXT ) - DECLARE_IS_DISPATCHED( vkGetTensorMemoryRequirementsARM ) - DECLARE_IS_DISPATCHED( vkGetTensorOpaqueCaptureDataARM ) - DECLARE_IS_DISPATCHED( vkGetTensorOpaqueCaptureDescriptorDataARM ) - DECLARE_IS_DISPATCHED( vkGetTensorViewOpaqueCaptureDescriptorDataARM ) - DECLARE_IS_DISPATCHED( vkGetValidationCacheDataEXT ) - DECLARE_IS_DISPATCHED( vkGetVideoSessionMemoryRequirementsKHR ) - DECLARE_IS_DISPATCHED( vkGetWinrtDisplayNV ) - DECLARE_IS_DISPATCHED( vkImportFenceFdKHR ) - DECLARE_IS_DISPATCHED( vkImportFenceSciSyncFenceNV ) - DECLARE_IS_DISPATCHED( vkImportFenceSciSyncObjNV ) - DECLARE_IS_DISPATCHED( vkImportFenceWin32HandleKHR ) - DECLARE_IS_DISPATCHED( vkImportSemaphoreFdKHR ) - DECLARE_IS_DISPATCHED( vkImportSemaphoreSciSyncObjNV ) - DECLARE_IS_DISPATCHED( vkImportSemaphoreWin32HandleKHR ) - DECLARE_IS_DISPATCHED( vkImportSemaphoreZirconHandleFUCHSIA ) - DECLARE_IS_DISPATCHED( vkInitializePerformanceApiINTEL ) - DECLARE_IS_DISPATCHED( vkInvalidateMappedMemoryRanges ) - DECLARE_IS_DISPATCHED( vkLatencySleepNV ) - DECLARE_IS_DISPATCHED( vkMapMemory ) - DECLARE_IS_DISPATCHED( vkMapMemory2 ) - DECLARE_IS_DISPATCHED( vkMapMemory2KHR ) - DECLARE_IS_DISPATCHED( vkMergePipelineCaches ) - DECLARE_IS_DISPATCHED( vkMergeValidationCachesEXT ) - DECLARE_IS_DISPATCHED( vkQueueBeginDebugUtilsLabelEXT ) - DECLARE_IS_DISPATCHED( vkQueueBindSparse ) - DECLARE_IS_DISPATCHED( vkQueueEndDebugUtilsLabelEXT ) - DECLARE_IS_DISPATCHED( vkQueueInsertDebugUtilsLabelEXT ) - DECLARE_IS_DISPATCHED( vkQueueNotifyOutOfBandNV ) - DECLARE_IS_DISPATCHED( vkQueuePresentKHR ) - DECLARE_IS_DISPATCHED( vkQueueSetPerformanceConfigurationINTEL ) - DECLARE_IS_DISPATCHED( vkQueueSignalReleaseImageANDROID ) - DECLARE_IS_DISPATCHED( vkQueueSignalReleaseImageOHOS ) - DECLARE_IS_DISPATCHED( vkQueueSubmit ) - DECLARE_IS_DISPATCHED( vkQueueSubmit2 ) - DECLARE_IS_DISPATCHED( vkQueueSubmit2KHR ) - DECLARE_IS_DISPATCHED( vkQueueWaitIdle ) - DECLARE_IS_DISPATCHED( vkRegisterCustomBorderColorEXT ) - DECLARE_IS_DISPATCHED( vkRegisterDeviceEventEXT ) - DECLARE_IS_DISPATCHED( vkRegisterDisplayEventEXT ) - DECLARE_IS_DISPATCHED( vkReleaseCapturedPipelineDataKHR ) - DECLARE_IS_DISPATCHED( vkReleaseDisplayEXT ) - DECLARE_IS_DISPATCHED( vkReleaseFullScreenExclusiveModeEXT ) - DECLARE_IS_DISPATCHED( vkReleasePerformanceConfigurationINTEL ) - DECLARE_IS_DISPATCHED( vkReleaseProfilingLockKHR ) - DECLARE_IS_DISPATCHED( vkReleaseSwapchainImagesKHR ) - DECLARE_IS_DISPATCHED( vkReleaseSwapchainImagesEXT ) - DECLARE_IS_DISPATCHED( vkResetCommandBuffer ) - DECLARE_IS_DISPATCHED( vkResetCommandPool ) - DECLARE_IS_DISPATCHED( vkResetDescriptorPool ) - DECLARE_IS_DISPATCHED( vkResetEvent ) - DECLARE_IS_DISPATCHED( vkResetFences ) - DECLARE_IS_DISPATCHED( vkResetQueryPool ) - DECLARE_IS_DISPATCHED( vkResetQueryPoolEXT ) - DECLARE_IS_DISPATCHED( vkSetBufferCollectionBufferConstraintsFUCHSIA ) - DECLARE_IS_DISPATCHED( vkSetBufferCollectionImageConstraintsFUCHSIA ) - DECLARE_IS_DISPATCHED( vkSetDebugUtilsObjectNameEXT ) - DECLARE_IS_DISPATCHED( vkSetDebugUtilsObjectTagEXT ) - DECLARE_IS_DISPATCHED( vkSetDeviceMemoryPriorityEXT ) - DECLARE_IS_DISPATCHED( vkSetEvent ) - DECLARE_IS_DISPATCHED( vkSetHdrMetadataEXT ) - DECLARE_IS_DISPATCHED( vkSetLatencyMarkerNV ) - DECLARE_IS_DISPATCHED( vkSetLatencySleepModeNV ) - DECLARE_IS_DISPATCHED( vkSetLocalDimmingAMD ) - DECLARE_IS_DISPATCHED( vkSetPrivateData ) - DECLARE_IS_DISPATCHED( vkSetPrivateDataEXT ) - DECLARE_IS_DISPATCHED( vkSetSwapchainPresentTimingQueueSizeEXT ) - DECLARE_IS_DISPATCHED( vkSignalSemaphore ) - DECLARE_IS_DISPATCHED( vkSignalSemaphoreKHR ) - DECLARE_IS_DISPATCHED( vkSubmitDebugUtilsMessageEXT ) - DECLARE_IS_DISPATCHED( vkTransitionImageLayout ) - DECLARE_IS_DISPATCHED( vkTransitionImageLayoutEXT ) - DECLARE_IS_DISPATCHED( vkTrimCommandPool ) - DECLARE_IS_DISPATCHED( vkTrimCommandPoolKHR ) - DECLARE_IS_DISPATCHED( vkUninitializePerformanceApiINTEL ) - DECLARE_IS_DISPATCHED( vkUnmapMemory ) - DECLARE_IS_DISPATCHED( vkUnmapMemory2 ) - DECLARE_IS_DISPATCHED( vkUnmapMemory2KHR ) - DECLARE_IS_DISPATCHED( vkUnregisterCustomBorderColorEXT ) - DECLARE_IS_DISPATCHED( vkUpdateDescriptorSetWithTemplate ) - DECLARE_IS_DISPATCHED( vkUpdateDescriptorSetWithTemplateKHR ) - DECLARE_IS_DISPATCHED( vkUpdateDescriptorSets ) - DECLARE_IS_DISPATCHED( vkUpdateIndirectExecutionSetPipelineEXT ) - DECLARE_IS_DISPATCHED( vkUpdateIndirectExecutionSetShaderEXT ) - DECLARE_IS_DISPATCHED( vkUpdateVideoSessionParametersKHR ) - DECLARE_IS_DISPATCHED( vkWaitForFences ) - DECLARE_IS_DISPATCHED( vkWaitForPresent2KHR ) - DECLARE_IS_DISPATCHED( vkWaitForPresentKHR ) - DECLARE_IS_DISPATCHED( vkWaitSemaphores ) - DECLARE_IS_DISPATCHED( vkWaitSemaphoresKHR ) - DECLARE_IS_DISPATCHED( vkWriteAccelerationStructuresPropertiesKHR ) - DECLARE_IS_DISPATCHED( vkWriteMicromapsPropertiesEXT ) - DECLARE_IS_DISPATCHED( vkWriteResourceDescriptorsEXT ) - DECLARE_IS_DISPATCHED( vkWriteSamplerDescriptorsEXT ) - -#undef DECLARE_IS_DISPATCHED - -#define IS_DISPATCHED( name ) ::VULKAN_HPP_NAMESPACE::detail::has_##name::value - - class DispatchLoaderBase - { - public: - DispatchLoaderBase() = default; - DispatchLoaderBase( std::nullptr_t ) -#if !defined( NDEBUG ) - : m_valid( false ) -#endif - { - } - -#if !defined( NDEBUG ) - size_t getVkHeaderVersion() const - { - VULKAN_HPP_ASSERT( m_valid ); - return vkHeaderVersion; - } - - private: - size_t vkHeaderVersion = VK_HEADER_VERSION; - bool m_valid = true; -#endif - }; - -#if !defined( VK_NO_PROTOTYPES ) || ( defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC ) && ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 0 ) ) - class DispatchLoaderStatic : public DispatchLoaderBase - { - public: - //=== VK_VERSION_1_0 === - - VkResult - vkCreateInstance( const VkInstanceCreateInfo * pCreateInfo, const VkAllocationCallbacks * pAllocator, VkInstance * pInstance ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateInstance( pCreateInfo, pAllocator, pInstance ); - } - - void vkDestroyInstance( VkInstance instance, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyInstance( instance, pAllocator ); - } - - VkResult vkEnumeratePhysicalDevices( VkInstance instance, uint32_t * pPhysicalDeviceCount, VkPhysicalDevice * pPhysicalDevices ) const VULKAN_HPP_NOEXCEPT - { - return ::vkEnumeratePhysicalDevices( instance, pPhysicalDeviceCount, pPhysicalDevices ); - } - - void vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures * pFeatures ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceFeatures( physicalDevice, pFeatures ); - } - - void vkGetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties * pFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceFormatProperties( physicalDevice, format, pFormatProperties ); - } - - VkResult vkGetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkImageFormatProperties * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceImageFormatProperties( physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties ); - } - - void vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceProperties( physicalDevice, pProperties ); - } - - void vkGetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, - uint32_t * pQueueFamilyPropertyCount, - VkQueueFamilyProperties * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); - } - - void vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceMemoryProperties( physicalDevice, pMemoryProperties ); - } - - PFN_vkVoidFunction vkGetInstanceProcAddr( VkInstance instance, const char * pName ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetInstanceProcAddr( instance, pName ); - } - - PFN_vkVoidFunction vkGetDeviceProcAddr( VkDevice device, const char * pName ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceProcAddr( device, pName ); - } - - VkResult vkCreateDevice( VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkDevice * pDevice ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDevice( physicalDevice, pCreateInfo, pAllocator, pDevice ); - } - - void vkDestroyDevice( VkDevice device, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyDevice( device, pAllocator ); - } - - VkResult vkEnumerateInstanceExtensionProperties( const char * pLayerName, - uint32_t * pPropertyCount, - VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, pProperties ); - } - - VkResult vkEnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, - const char * pLayerName, - uint32_t * pPropertyCount, - VkExtensionProperties * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkEnumerateDeviceExtensionProperties( physicalDevice, pLayerName, pPropertyCount, pProperties ); - } - - VkResult vkEnumerateInstanceLayerProperties( uint32_t * pPropertyCount, VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkEnumerateInstanceLayerProperties( pPropertyCount, pProperties ); - } - - VkResult vkEnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, - uint32_t * pPropertyCount, - VkLayerProperties * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkEnumerateDeviceLayerProperties( physicalDevice, pPropertyCount, pProperties ); - } - - void vkGetDeviceQueue( VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceQueue( device, queueFamilyIndex, queueIndex, pQueue ); - } - - VkResult vkQueueSubmit( VkQueue queue, uint32_t submitCount, const VkSubmitInfo * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT - { - return ::vkQueueSubmit( queue, submitCount, pSubmits, fence ); - } - - VkResult vkQueueWaitIdle( VkQueue queue ) const VULKAN_HPP_NOEXCEPT - { - return ::vkQueueWaitIdle( queue ); - } - - VkResult vkDeviceWaitIdle( VkDevice device ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDeviceWaitIdle( device ); - } - - VkResult vkAllocateMemory( VkDevice device, - const VkMemoryAllocateInfo * pAllocateInfo, - const VkAllocationCallbacks * pAllocator, - VkDeviceMemory * pMemory ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAllocateMemory( device, pAllocateInfo, pAllocator, pMemory ); - } - - void vkFreeMemory( VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkFreeMemory( device, memory, pAllocator ); - } - - VkResult vkMapMemory( VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void ** ppData ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkMapMemory( device, memory, offset, size, flags, ppData ); - } - - void vkUnmapMemory( VkDevice device, VkDeviceMemory memory ) const VULKAN_HPP_NOEXCEPT - { - return ::vkUnmapMemory( device, memory ); - } - - VkResult vkFlushMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT - { - return ::vkFlushMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges ); - } - - VkResult vkInvalidateMappedMemoryRanges( VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange * pMemoryRanges ) const VULKAN_HPP_NOEXCEPT - { - return ::vkInvalidateMappedMemoryRanges( device, memoryRangeCount, pMemoryRanges ); - } - - void vkGetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize * pCommittedMemoryInBytes ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceMemoryCommitment( device, memory, pCommittedMemoryInBytes ); - } - - VkResult vkBindBufferMemory( VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBindBufferMemory( device, buffer, memory, memoryOffset ); - } - - VkResult vkBindImageMemory( VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBindImageMemory( device, image, memory, memoryOffset ); - } - - void vkGetBufferMemoryRequirements( VkDevice device, VkBuffer buffer, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetBufferMemoryRequirements( device, buffer, pMemoryRequirements ); - } - - void vkGetImageMemoryRequirements( VkDevice device, VkImage image, VkMemoryRequirements * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageMemoryRequirements( device, image, pMemoryRequirements ); - } - - void vkGetImageSparseMemoryRequirements( VkDevice device, - VkImage image, - uint32_t * pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageSparseMemoryRequirements( device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); - } - - void vkGetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkSampleCountFlagBits samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - uint32_t * pPropertyCount, - VkSparseImageFormatProperties * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSparseImageFormatProperties( physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties ); - } - - VkResult vkQueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo * pBindInfo, VkFence fence ) const VULKAN_HPP_NOEXCEPT - { - return ::vkQueueBindSparse( queue, bindInfoCount, pBindInfo, fence ); - } - - VkResult vkCreateFence( VkDevice device, - const VkFenceCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkFence * pFence ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateFence( device, pCreateInfo, pAllocator, pFence ); - } - - void vkDestroyFence( VkDevice device, VkFence fence, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyFence( device, fence, pAllocator ); - } - - VkResult vkResetFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences ) const VULKAN_HPP_NOEXCEPT - { - return ::vkResetFences( device, fenceCount, pFences ); - } - - VkResult vkGetFenceStatus( VkDevice device, VkFence fence ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetFenceStatus( device, fence ); - } - - VkResult vkWaitForFences( VkDevice device, uint32_t fenceCount, const VkFence * pFences, VkBool32 waitAll, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkWaitForFences( device, fenceCount, pFences, waitAll, timeout ); - } - - VkResult vkCreateSemaphore( VkDevice device, - const VkSemaphoreCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSemaphore * pSemaphore ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateSemaphore( device, pCreateInfo, pAllocator, pSemaphore ); - } - - void vkDestroySemaphore( VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroySemaphore( device, semaphore, pAllocator ); - } - - VkResult vkCreateQueryPool( VkDevice device, - const VkQueryPoolCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkQueryPool * pQueryPool ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateQueryPool( device, pCreateInfo, pAllocator, pQueryPool ); - } - - void vkDestroyQueryPool( VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyQueryPool( device, queryPool, pAllocator ); - } - - VkResult vkGetQueryPoolResults( VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - size_t dataSize, - void * pData, - VkDeviceSize stride, - VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetQueryPoolResults( device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags ); - } - - VkResult vkCreateBuffer( VkDevice device, - const VkBufferCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkBuffer * pBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateBuffer( device, pCreateInfo, pAllocator, pBuffer ); - } - - void vkDestroyBuffer( VkDevice device, VkBuffer buffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyBuffer( device, buffer, pAllocator ); - } - - VkResult vkCreateImage( VkDevice device, - const VkImageCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkImage * pImage ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateImage( device, pCreateInfo, pAllocator, pImage ); - } - - void vkDestroyImage( VkDevice device, VkImage image, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyImage( device, image, pAllocator ); - } - - void vkGetImageSubresourceLayout( VkDevice device, - VkImage image, - const VkImageSubresource * pSubresource, - VkSubresourceLayout * pLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageSubresourceLayout( device, image, pSubresource, pLayout ); - } - - VkResult vkCreateImageView( VkDevice device, - const VkImageViewCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkImageView * pView ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateImageView( device, pCreateInfo, pAllocator, pView ); - } - - void vkDestroyImageView( VkDevice device, VkImageView imageView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyImageView( device, imageView, pAllocator ); - } - - VkResult vkCreateCommandPool( VkDevice device, - const VkCommandPoolCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkCommandPool * pCommandPool ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateCommandPool( device, pCreateInfo, pAllocator, pCommandPool ); - } - - void vkDestroyCommandPool( VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyCommandPool( device, commandPool, pAllocator ); - } - - VkResult vkResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT - { - return ::vkResetCommandPool( device, commandPool, flags ); - } - - VkResult vkAllocateCommandBuffers( VkDevice device, - const VkCommandBufferAllocateInfo * pAllocateInfo, - VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAllocateCommandBuffers( device, pAllocateInfo, pCommandBuffers ); - } - - void vkFreeCommandBuffers( VkDevice device, - VkCommandPool commandPool, - uint32_t commandBufferCount, - const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT - { - return ::vkFreeCommandBuffers( device, commandPool, commandBufferCount, pCommandBuffers ); - } - - VkResult vkBeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo * pBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBeginCommandBuffer( commandBuffer, pBeginInfo ); - } - - VkResult vkEndCommandBuffer( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkEndCommandBuffer( commandBuffer ); - } - - VkResult vkResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags ) const VULKAN_HPP_NOEXCEPT - { - return ::vkResetCommandBuffer( commandBuffer, flags ); - } - - void vkCmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy * pRegions ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyBuffer( commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions ); - } - - void vkCmdCopyImage( VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); - } - - void vkCmdCopyBufferToImage( VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyBufferToImage( commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions ); - } - - void vkCmdCopyImageToBuffer( VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferImageCopy * pRegions ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyImageToBuffer( commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions ); - } - - void vkCmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void * pData ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkCmdUpdateBuffer( commandBuffer, dstBuffer, dstOffset, dataSize, pData ); - } - - void - vkCmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdFillBuffer( commandBuffer, dstBuffer, dstOffset, size, data ); - } - - void vkCmdPipelineBarrier( VkCommandBuffer commandBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkDependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, - const VkMemoryBarrier * pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier * pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPipelineBarrier( commandBuffer, - srcStageMask, - dstStageMask, - dependencyFlags, - memoryBarrierCount, - pMemoryBarriers, - bufferMemoryBarrierCount, - pBufferMemoryBarriers, - imageMemoryBarrierCount, - pImageMemoryBarriers ); - } - - void vkCmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginQuery( commandBuffer, queryPool, query, flags ); - } - - void vkCmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndQuery( commandBuffer, queryPool, query ); - } - - void vkCmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdResetQueryPool( commandBuffer, queryPool, firstQuery, queryCount ); - } - - void vkCmdWriteTimestamp( VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - uint32_t query ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdWriteTimestamp( commandBuffer, pipelineStage, queryPool, query ); - } - - void vkCmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize stride, - VkQueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyQueryPoolResults( commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags ); - } - - void vkCmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer * pCommandBuffers ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdExecuteCommands( commandBuffer, commandBufferCount, pCommandBuffers ); - } - - VkResult vkCreateEvent( VkDevice device, - const VkEventCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkEvent * pEvent ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateEvent( device, pCreateInfo, pAllocator, pEvent ); - } - - void vkDestroyEvent( VkDevice device, VkEvent event, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyEvent( device, event, pAllocator ); - } - - VkResult vkGetEventStatus( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetEventStatus( device, event ); - } - - VkResult vkSetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSetEvent( device, event ); - } - - VkResult vkResetEvent( VkDevice device, VkEvent event ) const VULKAN_HPP_NOEXCEPT - { - return ::vkResetEvent( device, event ); - } - - VkResult vkCreateBufferView( VkDevice device, - const VkBufferViewCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkBufferView * pView ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateBufferView( device, pCreateInfo, pAllocator, pView ); - } - - void vkDestroyBufferView( VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyBufferView( device, bufferView, pAllocator ); - } - - VkResult vkCreateShaderModule( VkDevice device, - const VkShaderModuleCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkShaderModule * pShaderModule ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateShaderModule( device, pCreateInfo, pAllocator, pShaderModule ); - } - - void vkDestroyShaderModule( VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyShaderModule( device, shaderModule, pAllocator ); - } - - VkResult vkCreatePipelineCache( VkDevice device, - const VkPipelineCacheCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkPipelineCache * pPipelineCache ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreatePipelineCache( device, pCreateInfo, pAllocator, pPipelineCache ); - } - - void vkDestroyPipelineCache( VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyPipelineCache( device, pipelineCache, pAllocator ); - } - - VkResult vkGetPipelineCacheData( VkDevice device, VkPipelineCache pipelineCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPipelineCacheData( device, pipelineCache, pDataSize, pData ); - } - - VkResult - vkMergePipelineCaches( VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache * pSrcCaches ) const VULKAN_HPP_NOEXCEPT - { - return ::vkMergePipelineCaches( device, dstCache, srcCacheCount, pSrcCaches ); - } - - VkResult vkCreateComputePipelines( VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkComputePipelineCreateInfo * pCreateInfos, - const VkAllocationCallbacks * pAllocator, - VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateComputePipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); - } - - void vkDestroyPipeline( VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyPipeline( device, pipeline, pAllocator ); - } - - VkResult vkCreatePipelineLayout( VkDevice device, - const VkPipelineLayoutCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkPipelineLayout * pPipelineLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreatePipelineLayout( device, pCreateInfo, pAllocator, pPipelineLayout ); - } - - void vkDestroyPipelineLayout( VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyPipelineLayout( device, pipelineLayout, pAllocator ); - } - - VkResult vkCreateSampler( VkDevice device, - const VkSamplerCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSampler * pSampler ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateSampler( device, pCreateInfo, pAllocator, pSampler ); - } - - void vkDestroySampler( VkDevice device, VkSampler sampler, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroySampler( device, sampler, pAllocator ); - } - - VkResult vkCreateDescriptorSetLayout( VkDevice device, - const VkDescriptorSetLayoutCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkDescriptorSetLayout * pSetLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDescriptorSetLayout( device, pCreateInfo, pAllocator, pSetLayout ); - } - - void vkDestroyDescriptorSetLayout( VkDevice device, - VkDescriptorSetLayout descriptorSetLayout, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyDescriptorSetLayout( device, descriptorSetLayout, pAllocator ); - } - - VkResult vkCreateDescriptorPool( VkDevice device, - const VkDescriptorPoolCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkDescriptorPool * pDescriptorPool ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDescriptorPool( device, pCreateInfo, pAllocator, pDescriptorPool ); - } - - void vkDestroyDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyDescriptorPool( device, descriptorPool, pAllocator ); - } - - VkResult vkResetDescriptorPool( VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags ) const VULKAN_HPP_NOEXCEPT - { - return ::vkResetDescriptorPool( device, descriptorPool, flags ); - } - - VkResult vkAllocateDescriptorSets( VkDevice device, - const VkDescriptorSetAllocateInfo * pAllocateInfo, - VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAllocateDescriptorSets( device, pAllocateInfo, pDescriptorSets ); - } - - VkResult vkFreeDescriptorSets( VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const VkDescriptorSet * pDescriptorSets ) const VULKAN_HPP_NOEXCEPT - { - return ::vkFreeDescriptorSets( device, descriptorPool, descriptorSetCount, pDescriptorSets ); - } - - void vkUpdateDescriptorSets( VkDevice device, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet * pDescriptorWrites, - uint32_t descriptorCopyCount, - const VkCopyDescriptorSet * pDescriptorCopies ) const VULKAN_HPP_NOEXCEPT - { - return ::vkUpdateDescriptorSets( device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies ); - } - - void vkCmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindPipeline( commandBuffer, pipelineBindPoint, pipeline ); - } - - void vkCmdBindDescriptorSets( VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t descriptorSetCount, - const VkDescriptorSet * pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t * pDynamicOffsets ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindDescriptorSets( - commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets ); - } - - void vkCmdClearColorImage( VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue * pColor, - uint32_t rangeCount, - const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdClearColorImage( commandBuffer, image, imageLayout, pColor, rangeCount, pRanges ); - } - - void vkCmdDispatch( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDispatch( commandBuffer, groupCountX, groupCountY, groupCountZ ); - } - - void vkCmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDispatchIndirect( commandBuffer, buffer, offset ); - } - - void vkCmdSetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetEvent( commandBuffer, event, stageMask ); - } - - void vkCmdResetEvent( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdResetEvent( commandBuffer, event, stageMask ); - } - - void vkCmdWaitEvents( VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent * pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const VkMemoryBarrier * pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier * pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier * pImageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdWaitEvents( commandBuffer, - eventCount, - pEvents, - srcStageMask, - dstStageMask, - memoryBarrierCount, - pMemoryBarriers, - bufferMemoryBarrierCount, - pBufferMemoryBarriers, - imageMemoryBarrierCount, - pImageMemoryBarriers ); - } - - void vkCmdPushConstants( VkCommandBuffer commandBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void * pValues ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushConstants( commandBuffer, layout, stageFlags, offset, size, pValues ); - } - - VkResult vkCreateGraphicsPipelines( VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkGraphicsPipelineCreateInfo * pCreateInfos, - const VkAllocationCallbacks * pAllocator, - VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateGraphicsPipelines( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); - } - - VkResult vkCreateFramebuffer( VkDevice device, - const VkFramebufferCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkFramebuffer * pFramebuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateFramebuffer( device, pCreateInfo, pAllocator, pFramebuffer ); - } - - void vkDestroyFramebuffer( VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyFramebuffer( device, framebuffer, pAllocator ); - } - - VkResult vkCreateRenderPass( VkDevice device, - const VkRenderPassCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateRenderPass( device, pCreateInfo, pAllocator, pRenderPass ); - } - - void vkDestroyRenderPass( VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyRenderPass( device, renderPass, pAllocator ); - } - - void vkGetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetRenderAreaGranularity( device, renderPass, pGranularity ); - } - - void vkCmdSetViewport( VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetViewport( commandBuffer, firstViewport, viewportCount, pViewports ); - } - - void vkCmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetScissor( commandBuffer, firstScissor, scissorCount, pScissors ); - } - - void vkCmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetLineWidth( commandBuffer, lineWidth ); - } - - void vkCmdSetDepthBias( VkCommandBuffer commandBuffer, - float depthBiasConstantFactor, - float depthBiasClamp, - float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthBias( commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); - } - - void vkCmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetBlendConstants( commandBuffer, blendConstants ); - } - - void vkCmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthBounds( commandBuffer, minDepthBounds, maxDepthBounds ); - } - - void vkCmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetStencilCompareMask( commandBuffer, faceMask, compareMask ); - } - - void vkCmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetStencilWriteMask( commandBuffer, faceMask, writeMask ); - } - - void vkCmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetStencilReference( commandBuffer, faceMask, reference ); - } - - void vkCmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindIndexBuffer( commandBuffer, buffer, offset, indexType ); - } - - void vkCmdBindVertexBuffers( VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer * pBuffers, - const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindVertexBuffers( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets ); - } - - void vkCmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDraw( commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance ); - } - - void vkCmdDrawIndexed( VkCommandBuffer commandBuffer, - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawIndexed( commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); - } - - void - vkCmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawIndirect( commandBuffer, buffer, offset, drawCount, stride ); - } - - void vkCmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawIndexedIndirect( commandBuffer, buffer, offset, drawCount, stride ); - } - - void vkCmdBlitImage( VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageBlit * pRegions, - VkFilter filter ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBlitImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter ); - } - - void vkCmdClearDepthStencilImage( VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue * pDepthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange * pRanges ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdClearDepthStencilImage( commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges ); - } - - void vkCmdClearAttachments( VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkClearAttachment * pAttachments, - uint32_t rectCount, - const VkClearRect * pRects ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdClearAttachments( commandBuffer, attachmentCount, pAttachments, rectCount, pRects ); - } - - void vkCmdResolveImage( VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageResolve * pRegions ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdResolveImage( commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); - } - - void vkCmdBeginRenderPass( VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo * pRenderPassBegin, - VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginRenderPass( commandBuffer, pRenderPassBegin, contents ); - } - - void vkCmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdNextSubpass( commandBuffer, contents ); - } - - void vkCmdEndRenderPass( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndRenderPass( commandBuffer ); - } - - //=== VK_VERSION_1_1 === - - VkResult vkEnumerateInstanceVersion( uint32_t * pApiVersion ) const VULKAN_HPP_NOEXCEPT - { - return ::vkEnumerateInstanceVersion( pApiVersion ); - } - - VkResult vkBindBufferMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBindBufferMemory2( device, bindInfoCount, pBindInfos ); - } - - VkResult vkBindImageMemory2( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBindImageMemory2( device, bindInfoCount, pBindInfos ); - } - - void vkGetDeviceGroupPeerMemoryFeatures( VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceGroupPeerMemoryFeatures( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures ); - } - - void vkCmdSetDeviceMask( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDeviceMask( commandBuffer, deviceMask ); - } - - VkResult vkEnumeratePhysicalDeviceGroups( VkInstance instance, - uint32_t * pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkEnumeratePhysicalDeviceGroups( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties ); - } - - void vkGetImageMemoryRequirements2( VkDevice device, - const VkImageMemoryRequirementsInfo2 * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageMemoryRequirements2( device, pInfo, pMemoryRequirements ); - } - - void vkGetBufferMemoryRequirements2( VkDevice device, - const VkBufferMemoryRequirementsInfo2 * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetBufferMemoryRequirements2( device, pInfo, pMemoryRequirements ); - } - - void vkGetImageSparseMemoryRequirements2( VkDevice device, - const VkImageSparseMemoryRequirementsInfo2 * pInfo, - uint32_t * pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageSparseMemoryRequirements2( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); - } - - void vkGetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceFeatures2( physicalDevice, pFeatures ); - } - - void vkGetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceProperties2( physicalDevice, pProperties ); - } - - void vkGetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceFormatProperties2( physicalDevice, format, pFormatProperties ); - } - - VkResult vkGetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, - VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceImageFormatProperties2( physicalDevice, pImageFormatInfo, pImageFormatProperties ); - } - - void vkGetPhysicalDeviceQueueFamilyProperties2( VkPhysicalDevice physicalDevice, - uint32_t * pQueueFamilyPropertyCount, - VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceQueueFamilyProperties2( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); - } - - void vkGetPhysicalDeviceMemoryProperties2( VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceMemoryProperties2( physicalDevice, pMemoryProperties ); - } - - void vkGetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, - uint32_t * pPropertyCount, - VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSparseImageFormatProperties2( physicalDevice, pFormatInfo, pPropertyCount, pProperties ); - } - - void vkTrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT - { - return ::vkTrimCommandPool( device, commandPool, flags ); - } - - void vkGetDeviceQueue2( VkDevice device, const VkDeviceQueueInfo2 * pQueueInfo, VkQueue * pQueue ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceQueue2( device, pQueueInfo, pQueue ); - } - - void vkGetPhysicalDeviceExternalBufferProperties( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, - VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceExternalBufferProperties( physicalDevice, pExternalBufferInfo, pExternalBufferProperties ); - } - - void vkGetPhysicalDeviceExternalFenceProperties( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, - VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceExternalFenceProperties( physicalDevice, pExternalFenceInfo, pExternalFenceProperties ); - } - - void vkGetPhysicalDeviceExternalSemaphoreProperties( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, - VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceExternalSemaphoreProperties( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties ); - } - - void vkCmdDispatchBase( VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDispatchBase( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); - } - - VkResult vkCreateDescriptorUpdateTemplate( VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDescriptorUpdateTemplate( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate ); - } - - void vkDestroyDescriptorUpdateTemplate( VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyDescriptorUpdateTemplate( device, descriptorUpdateTemplate, pAllocator ); - } - - void vkUpdateDescriptorSetWithTemplate( VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkUpdateDescriptorSetWithTemplate( device, descriptorSet, descriptorUpdateTemplate, pData ); - } - - void vkGetDescriptorSetLayoutSupport( VkDevice device, - const VkDescriptorSetLayoutCreateInfo * pCreateInfo, - VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDescriptorSetLayoutSupport( device, pCreateInfo, pSupport ); - } - - VkResult vkCreateSamplerYcbcrConversion( VkDevice device, - const VkSamplerYcbcrConversionCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateSamplerYcbcrConversion( device, pCreateInfo, pAllocator, pYcbcrConversion ); - } - - void vkDestroySamplerYcbcrConversion( VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroySamplerYcbcrConversion( device, ycbcrConversion, pAllocator ); - } - - //=== VK_VERSION_1_2 === - - void vkResetQueryPool( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT - { - return ::vkResetQueryPool( device, queryPool, firstQuery, queryCount ); - } - - VkResult vkGetSemaphoreCounterValue( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetSemaphoreCounterValue( device, semaphore, pValue ); - } - - VkResult vkWaitSemaphores( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkWaitSemaphores( device, pWaitInfo, timeout ); - } - - VkResult vkSignalSemaphore( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSignalSemaphore( device, pSignalInfo ); - } - - VkDeviceAddress vkGetBufferDeviceAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetBufferDeviceAddress( device, pInfo ); - } - - uint64_t vkGetBufferOpaqueCaptureAddress( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetBufferOpaqueCaptureAddress( device, pInfo ); - } - - uint64_t vkGetDeviceMemoryOpaqueCaptureAddress( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceMemoryOpaqueCaptureAddress( device, pInfo ); - } - - void vkCmdDrawIndirectCount( VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); - } - - void vkCmdDrawIndexedIndirectCount( VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawIndexedIndirectCount( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); - } - - VkResult vkCreateRenderPass2( VkDevice device, - const VkRenderPassCreateInfo2 * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateRenderPass2( device, pCreateInfo, pAllocator, pRenderPass ); - } - - void vkCmdBeginRenderPass2( VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo * pRenderPassBegin, - const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginRenderPass2( commandBuffer, pRenderPassBegin, pSubpassBeginInfo ); - } - - void vkCmdNextSubpass2( VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo * pSubpassBeginInfo, - const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdNextSubpass2( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo ); - } - - void vkCmdEndRenderPass2( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndRenderPass2( commandBuffer, pSubpassEndInfo ); - } - - //=== VK_VERSION_1_3 === - - VkResult vkGetPhysicalDeviceToolProperties( VkPhysicalDevice physicalDevice, - uint32_t * pToolCount, - VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceToolProperties( physicalDevice, pToolCount, pToolProperties ); - } - - VkResult vkCreatePrivateDataSlot( VkDevice device, - const VkPrivateDataSlotCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreatePrivateDataSlot( device, pCreateInfo, pAllocator, pPrivateDataSlot ); - } - - void vkDestroyPrivateDataSlot( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyPrivateDataSlot( device, privateDataSlot, pAllocator ); - } - - VkResult vkSetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkSetPrivateData( device, objectType, objectHandle, privateDataSlot, data ); - } - - void vkGetPrivateData( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkGetPrivateData( device, objectType, objectHandle, privateDataSlot, pData ); - } - - void vkCmdPipelineBarrier2( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPipelineBarrier2( commandBuffer, pDependencyInfo ); - } - - void vkCmdWriteTimestamp2( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdWriteTimestamp2( commandBuffer, stage, queryPool, query ); - } - - VkResult vkQueueSubmit2( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT - { - return ::vkQueueSubmit2( queue, submitCount, pSubmits, fence ); - } - - void vkCmdCopyBuffer2( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyBuffer2( commandBuffer, pCopyBufferInfo ); - } - - void vkCmdCopyImage2( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyImage2( commandBuffer, pCopyImageInfo ); - } - - void vkCmdCopyBufferToImage2( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyBufferToImage2( commandBuffer, pCopyBufferToImageInfo ); - } - - void vkCmdCopyImageToBuffer2( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyImageToBuffer2( commandBuffer, pCopyImageToBufferInfo ); - } - - void vkGetDeviceBufferMemoryRequirements( VkDevice device, - const VkDeviceBufferMemoryRequirements * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceBufferMemoryRequirements( device, pInfo, pMemoryRequirements ); - } - - void vkGetDeviceImageMemoryRequirements( VkDevice device, - const VkDeviceImageMemoryRequirements * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceImageMemoryRequirements( device, pInfo, pMemoryRequirements ); - } - - void vkGetDeviceImageSparseMemoryRequirements( VkDevice device, - const VkDeviceImageMemoryRequirements * pInfo, - uint32_t * pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceImageSparseMemoryRequirements( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); - } - - void vkCmdSetEvent2( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetEvent2( commandBuffer, event, pDependencyInfo ); - } - - void vkCmdResetEvent2( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdResetEvent2( commandBuffer, event, stageMask ); - } - - void vkCmdWaitEvents2( VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent * pEvents, - const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdWaitEvents2( commandBuffer, eventCount, pEvents, pDependencyInfos ); - } - - void vkCmdBlitImage2( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBlitImage2( commandBuffer, pBlitImageInfo ); - } - - void vkCmdResolveImage2( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdResolveImage2( commandBuffer, pResolveImageInfo ); - } - - void vkCmdBeginRendering( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginRendering( commandBuffer, pRenderingInfo ); - } - - void vkCmdEndRendering( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndRendering( commandBuffer ); - } - - void vkCmdSetCullMode( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetCullMode( commandBuffer, cullMode ); - } - - void vkCmdSetFrontFace( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetFrontFace( commandBuffer, frontFace ); - } - - void vkCmdSetPrimitiveTopology( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetPrimitiveTopology( commandBuffer, primitiveTopology ); - } - - void vkCmdSetViewportWithCount( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetViewportWithCount( commandBuffer, viewportCount, pViewports ); - } - - void vkCmdSetScissorWithCount( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetScissorWithCount( commandBuffer, scissorCount, pScissors ); - } - - void vkCmdBindVertexBuffers2( VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer * pBuffers, - const VkDeviceSize * pOffsets, - const VkDeviceSize * pSizes, - const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindVertexBuffers2( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides ); - } - - void vkCmdSetDepthTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthTestEnable( commandBuffer, depthTestEnable ); - } - - void vkCmdSetDepthWriteEnable( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthWriteEnable( commandBuffer, depthWriteEnable ); - } - - void vkCmdSetDepthCompareOp( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthCompareOp( commandBuffer, depthCompareOp ); - } - - void vkCmdSetDepthBoundsTestEnable( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthBoundsTestEnable( commandBuffer, depthBoundsTestEnable ); - } - - void vkCmdSetStencilTestEnable( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetStencilTestEnable( commandBuffer, stencilTestEnable ); - } - - void vkCmdSetStencilOp( VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetStencilOp( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp ); - } - - void vkCmdSetRasterizerDiscardEnable( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetRasterizerDiscardEnable( commandBuffer, rasterizerDiscardEnable ); - } - - void vkCmdSetDepthBiasEnable( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthBiasEnable( commandBuffer, depthBiasEnable ); - } - - void vkCmdSetPrimitiveRestartEnable( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetPrimitiveRestartEnable( commandBuffer, primitiveRestartEnable ); - } - - //=== VK_VERSION_1_4 === - - VkResult vkMapMemory2( VkDevice device, const VkMemoryMapInfo * pMemoryMapInfo, void ** ppData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkMapMemory2( device, pMemoryMapInfo, ppData ); - } - - VkResult vkUnmapMemory2( VkDevice device, const VkMemoryUnmapInfo * pMemoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkUnmapMemory2( device, pMemoryUnmapInfo ); - } - - void vkGetDeviceImageSubresourceLayout( VkDevice device, - const VkDeviceImageSubresourceInfo * pInfo, - VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceImageSubresourceLayout( device, pInfo, pLayout ); - } - - void vkGetImageSubresourceLayout2( VkDevice device, - VkImage image, - const VkImageSubresource2 * pSubresource, - VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageSubresourceLayout2( device, image, pSubresource, pLayout ); - } - - VkResult vkCopyMemoryToImage( VkDevice device, const VkCopyMemoryToImageInfo * pCopyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyMemoryToImage( device, pCopyMemoryToImageInfo ); - } - - VkResult vkCopyImageToMemory( VkDevice device, const VkCopyImageToMemoryInfo * pCopyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyImageToMemory( device, pCopyImageToMemoryInfo ); - } - - VkResult vkCopyImageToImage( VkDevice device, const VkCopyImageToImageInfo * pCopyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyImageToImage( device, pCopyImageToImageInfo ); - } - - VkResult - vkTransitionImageLayout( VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo * pTransitions ) const VULKAN_HPP_NOEXCEPT - { - return ::vkTransitionImageLayout( device, transitionCount, pTransitions ); - } - - void vkCmdPushDescriptorSet( VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushDescriptorSet( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites ); - } - - void vkCmdPushDescriptorSetWithTemplate( VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout layout, - uint32_t set, - const void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushDescriptorSetWithTemplate( commandBuffer, descriptorUpdateTemplate, layout, set, pData ); - } - - void vkCmdBindDescriptorSets2( VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo * pBindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindDescriptorSets2( commandBuffer, pBindDescriptorSetsInfo ); - } - - void vkCmdPushConstants2( VkCommandBuffer commandBuffer, const VkPushConstantsInfo * pPushConstantsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushConstants2( commandBuffer, pPushConstantsInfo ); - } - - void vkCmdPushDescriptorSet2( VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo * pPushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushDescriptorSet2( commandBuffer, pPushDescriptorSetInfo ); - } - - void vkCmdPushDescriptorSetWithTemplate2( VkCommandBuffer commandBuffer, - const VkPushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushDescriptorSetWithTemplate2( commandBuffer, pPushDescriptorSetWithTemplateInfo ); - } - - void vkCmdSetLineStipple( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetLineStipple( commandBuffer, lineStippleFactor, lineStipplePattern ); - } - - void vkCmdBindIndexBuffer2( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindIndexBuffer2( commandBuffer, buffer, offset, size, indexType ); - } - - void vkGetRenderingAreaGranularity( VkDevice device, const VkRenderingAreaInfo * pRenderingAreaInfo, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetRenderingAreaGranularity( device, pRenderingAreaInfo, pGranularity ); - } - - void vkCmdSetRenderingAttachmentLocations( VkCommandBuffer commandBuffer, - const VkRenderingAttachmentLocationInfo * pLocationInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetRenderingAttachmentLocations( commandBuffer, pLocationInfo ); - } - - void vkCmdSetRenderingInputAttachmentIndices( VkCommandBuffer commandBuffer, - const VkRenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetRenderingInputAttachmentIndices( commandBuffer, pInputAttachmentIndexInfo ); - } - - //=== VK_KHR_surface === - - void vkDestroySurfaceKHR( VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroySurfaceKHR( instance, surface, pAllocator ); - } - - VkResult vkGetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - VkSurfaceKHR surface, - VkBool32 * pSupported ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSurfaceSupportKHR( physicalDevice, queueFamilyIndex, surface, pSupported ); - } - - VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSurfaceCapabilitiesKHR( physicalDevice, surface, pSurfaceCapabilities ); - } - - VkResult vkGetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t * pSurfaceFormatCount, - VkSurfaceFormatKHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSurfaceFormatsKHR( physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats ); - } - - VkResult vkGetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t * pPresentModeCount, - VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSurfacePresentModesKHR( physicalDevice, surface, pPresentModeCount, pPresentModes ); - } - - //=== VK_KHR_swapchain === - - VkResult vkCreateSwapchainKHR( VkDevice device, - const VkSwapchainCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSwapchainKHR * pSwapchain ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateSwapchainKHR( device, pCreateInfo, pAllocator, pSwapchain ); - } - - void vkDestroySwapchainKHR( VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroySwapchainKHR( device, swapchain, pAllocator ); - } - - VkResult vkGetSwapchainImagesKHR( VkDevice device, - VkSwapchainKHR swapchain, - uint32_t * pSwapchainImageCount, - VkImage * pSwapchainImages ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetSwapchainImagesKHR( device, swapchain, pSwapchainImageCount, pSwapchainImages ); - } - - VkResult vkAcquireNextImageKHR( - VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAcquireNextImageKHR( device, swapchain, timeout, semaphore, fence, pImageIndex ); - } - - VkResult vkQueuePresentKHR( VkQueue queue, const VkPresentInfoKHR * pPresentInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkQueuePresentKHR( queue, pPresentInfo ); - } - - VkResult vkGetDeviceGroupPresentCapabilitiesKHR( VkDevice device, - VkDeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceGroupPresentCapabilitiesKHR( device, pDeviceGroupPresentCapabilities ); - } - - VkResult - vkGetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceGroupSurfacePresentModesKHR( device, surface, pModes ); - } - - VkResult vkGetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t * pRectCount, - VkRect2D * pRects ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDevicePresentRectanglesKHR( physicalDevice, surface, pRectCount, pRects ); - } - - VkResult vkAcquireNextImage2KHR( VkDevice device, const VkAcquireNextImageInfoKHR * pAcquireInfo, uint32_t * pImageIndex ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAcquireNextImage2KHR( device, pAcquireInfo, pImageIndex ); - } - - //=== VK_KHR_display === - - VkResult vkGetPhysicalDeviceDisplayPropertiesKHR( VkPhysicalDevice physicalDevice, - uint32_t * pPropertyCount, - VkDisplayPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceDisplayPropertiesKHR( physicalDevice, pPropertyCount, pProperties ); - } - - VkResult vkGetPhysicalDeviceDisplayPlanePropertiesKHR( VkPhysicalDevice physicalDevice, - uint32_t * pPropertyCount, - VkDisplayPlanePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceDisplayPlanePropertiesKHR( physicalDevice, pPropertyCount, pProperties ); - } - - VkResult vkGetDisplayPlaneSupportedDisplaysKHR( VkPhysicalDevice physicalDevice, - uint32_t planeIndex, - uint32_t * pDisplayCount, - VkDisplayKHR * pDisplays ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDisplayPlaneSupportedDisplaysKHR( physicalDevice, planeIndex, pDisplayCount, pDisplays ); - } - - VkResult vkGetDisplayModePropertiesKHR( VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t * pPropertyCount, - VkDisplayModePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDisplayModePropertiesKHR( physicalDevice, display, pPropertyCount, pProperties ); - } - - VkResult vkCreateDisplayModeKHR( VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - const VkDisplayModeCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkDisplayModeKHR * pMode ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDisplayModeKHR( physicalDevice, display, pCreateInfo, pAllocator, pMode ); - } - - VkResult vkGetDisplayPlaneCapabilitiesKHR( VkPhysicalDevice physicalDevice, - VkDisplayModeKHR mode, - uint32_t planeIndex, - VkDisplayPlaneCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDisplayPlaneCapabilitiesKHR( physicalDevice, mode, planeIndex, pCapabilities ); - } - - VkResult vkCreateDisplayPlaneSurfaceKHR( VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDisplayPlaneSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); - } - - //=== VK_KHR_display_swapchain === - - VkResult vkCreateSharedSwapchainsKHR( VkDevice device, - uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR * pCreateInfos, - const VkAllocationCallbacks * pAllocator, - VkSwapchainKHR * pSwapchains ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateSharedSwapchainsKHR( device, swapchainCount, pCreateInfos, pAllocator, pSwapchains ); - } - -# if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - - VkResult vkCreateXlibSurfaceKHR( VkInstance instance, - const VkXlibSurfaceCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateXlibSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); - } - - VkBool32 vkGetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - Display * dpy, - VisualID visualID ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceXlibPresentationSupportKHR( physicalDevice, queueFamilyIndex, dpy, visualID ); - } -# endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -# if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - - VkResult vkCreateXcbSurfaceKHR( VkInstance instance, - const VkXcbSurfaceCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateXcbSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); - } - - VkBool32 vkGetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - xcb_connection_t * connection, - xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceXcbPresentationSupportKHR( physicalDevice, queueFamilyIndex, connection, visual_id ); - } -# endif /*VK_USE_PLATFORM_XCB_KHR*/ - -# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - - VkResult vkCreateWaylandSurfaceKHR( VkInstance instance, - const VkWaylandSurfaceCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateWaylandSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); - } - - VkBool32 vkGetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct wl_display * display ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceWaylandPresentationSupportKHR( physicalDevice, queueFamilyIndex, display ); - } -# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - - VkResult vkCreateAndroidSurfaceKHR( VkInstance instance, - const VkAndroidSurfaceCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateAndroidSurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); - } -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - - VkResult vkCreateWin32SurfaceKHR( VkInstance instance, - const VkWin32SurfaceCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateWin32SurfaceKHR( instance, pCreateInfo, pAllocator, pSurface ); - } - - VkBool32 vkGetPhysicalDeviceWin32PresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceWin32PresentationSupportKHR( physicalDevice, queueFamilyIndex ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - - VkResult vkCreateDebugReportCallbackEXT( VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkDebugReportCallbackEXT * pCallback ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDebugReportCallbackEXT( instance, pCreateInfo, pAllocator, pCallback ); - } - - void vkDestroyDebugReportCallbackEXT( VkInstance instance, - VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyDebugReportCallbackEXT( instance, callback, pAllocator ); - } - - void vkDebugReportMessageEXT( VkInstance instance, - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char * pLayerPrefix, - const char * pMessage ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDebugReportMessageEXT( instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage ); - } - - //=== VK_EXT_debug_marker === - - VkResult vkDebugMarkerSetObjectTagEXT( VkDevice device, const VkDebugMarkerObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDebugMarkerSetObjectTagEXT( device, pTagInfo ); - } - - VkResult vkDebugMarkerSetObjectNameEXT( VkDevice device, const VkDebugMarkerObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDebugMarkerSetObjectNameEXT( device, pNameInfo ); - } - - void vkCmdDebugMarkerBeginEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDebugMarkerBeginEXT( commandBuffer, pMarkerInfo ); - } - - void vkCmdDebugMarkerEndEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDebugMarkerEndEXT( commandBuffer ); - } - - void vkCmdDebugMarkerInsertEXT( VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDebugMarkerInsertEXT( commandBuffer, pMarkerInfo ); - } - - //=== VK_KHR_video_queue === - - VkResult vkGetPhysicalDeviceVideoCapabilitiesKHR( VkPhysicalDevice physicalDevice, - const VkVideoProfileInfoKHR * pVideoProfile, - VkVideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceVideoCapabilitiesKHR( physicalDevice, pVideoProfile, pCapabilities ); - } - - VkResult vkGetPhysicalDeviceVideoFormatPropertiesKHR( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, - uint32_t * pVideoFormatPropertyCount, - VkVideoFormatPropertiesKHR * pVideoFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceVideoFormatPropertiesKHR( physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties ); - } - - VkResult vkCreateVideoSessionKHR( VkDevice device, - const VkVideoSessionCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkVideoSessionKHR * pVideoSession ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateVideoSessionKHR( device, pCreateInfo, pAllocator, pVideoSession ); - } - - void vkDestroyVideoSessionKHR( VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyVideoSessionKHR( device, videoSession, pAllocator ); - } - - VkResult vkGetVideoSessionMemoryRequirementsKHR( VkDevice device, - VkVideoSessionKHR videoSession, - uint32_t * pMemoryRequirementsCount, - VkVideoSessionMemoryRequirementsKHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetVideoSessionMemoryRequirementsKHR( device, videoSession, pMemoryRequirementsCount, pMemoryRequirements ); - } - - VkResult vkBindVideoSessionMemoryKHR( VkDevice device, - VkVideoSessionKHR videoSession, - uint32_t bindSessionMemoryInfoCount, - const VkBindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBindVideoSessionMemoryKHR( device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos ); - } - - VkResult vkCreateVideoSessionParametersKHR( VkDevice device, - const VkVideoSessionParametersCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkVideoSessionParametersKHR * pVideoSessionParameters ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateVideoSessionParametersKHR( device, pCreateInfo, pAllocator, pVideoSessionParameters ); - } - - VkResult vkUpdateVideoSessionParametersKHR( VkDevice device, - VkVideoSessionParametersKHR videoSessionParameters, - const VkVideoSessionParametersUpdateInfoKHR * pUpdateInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkUpdateVideoSessionParametersKHR( device, videoSessionParameters, pUpdateInfo ); - } - - void vkDestroyVideoSessionParametersKHR( VkDevice device, - VkVideoSessionParametersKHR videoSessionParameters, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyVideoSessionParametersKHR( device, videoSessionParameters, pAllocator ); - } - - void vkCmdBeginVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR * pBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginVideoCodingKHR( commandBuffer, pBeginInfo ); - } - - void vkCmdEndVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR * pEndCodingInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndVideoCodingKHR( commandBuffer, pEndCodingInfo ); - } - - void vkCmdControlVideoCodingKHR( VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR * pCodingControlInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdControlVideoCodingKHR( commandBuffer, pCodingControlInfo ); - } - - //=== VK_KHR_video_decode_queue === - - void vkCmdDecodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR * pDecodeInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDecodeVideoKHR( commandBuffer, pDecodeInfo ); - } - - //=== VK_EXT_transform_feedback === - - void vkCmdBindTransformFeedbackBuffersEXT( VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer * pBuffers, - const VkDeviceSize * pOffsets, - const VkDeviceSize * pSizes ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindTransformFeedbackBuffersEXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes ); - } - - void vkCmdBeginTransformFeedbackEXT( VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer * pCounterBuffers, - const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets ); - } - - void vkCmdEndTransformFeedbackEXT( VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer * pCounterBuffers, - const VkDeviceSize * pCounterBufferOffsets ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndTransformFeedbackEXT( commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets ); - } - - void vkCmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginQueryIndexedEXT( commandBuffer, queryPool, query, flags, index ); - } - - void vkCmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndQueryIndexedEXT( commandBuffer, queryPool, query, index ); - } - - void vkCmdDrawIndirectByteCountEXT( VkCommandBuffer commandBuffer, - uint32_t instanceCount, - uint32_t firstInstance, - VkBuffer counterBuffer, - VkDeviceSize counterBufferOffset, - uint32_t counterOffset, - uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawIndirectByteCountEXT( commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride ); - } - - //=== VK_NVX_binary_import === - - VkResult vkCreateCuModuleNVX( VkDevice device, - const VkCuModuleCreateInfoNVX * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkCuModuleNVX * pModule ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateCuModuleNVX( device, pCreateInfo, pAllocator, pModule ); - } - - VkResult vkCreateCuFunctionNVX( VkDevice device, - const VkCuFunctionCreateInfoNVX * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkCuFunctionNVX * pFunction ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateCuFunctionNVX( device, pCreateInfo, pAllocator, pFunction ); - } - - void vkDestroyCuModuleNVX( VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyCuModuleNVX( device, module, pAllocator ); - } - - void vkDestroyCuFunctionNVX( VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyCuFunctionNVX( device, function, pAllocator ); - } - - void vkCmdCuLaunchKernelNVX( VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCuLaunchKernelNVX( commandBuffer, pLaunchInfo ); - } - - //=== VK_NVX_image_view_handle === - - uint32_t vkGetImageViewHandleNVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageViewHandleNVX( device, pInfo ); - } - - uint64_t vkGetImageViewHandle64NVX( VkDevice device, const VkImageViewHandleInfoNVX * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageViewHandle64NVX( device, pInfo ); - } - - VkResult vkGetImageViewAddressNVX( VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageViewAddressNVX( device, imageView, pProperties ); - } - - uint64_t vkGetDeviceCombinedImageSamplerIndexNVX( VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceCombinedImageSamplerIndexNVX( device, imageViewIndex, samplerIndex ); - } - - //=== VK_AMD_draw_indirect_count === - - void vkCmdDrawIndirectCountAMD( VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); - } - - void vkCmdDrawIndexedIndirectCountAMD( VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawIndexedIndirectCountAMD( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); - } - - //=== VK_AMD_shader_info === - - VkResult vkGetShaderInfoAMD( VkDevice device, - VkPipeline pipeline, - VkShaderStageFlagBits shaderStage, - VkShaderInfoTypeAMD infoType, - size_t * pInfoSize, - void * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetShaderInfoAMD( device, pipeline, shaderStage, infoType, pInfoSize, pInfo ); - } - - //=== VK_KHR_dynamic_rendering === - - void vkCmdBeginRenderingKHR( VkCommandBuffer commandBuffer, const VkRenderingInfo * pRenderingInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginRenderingKHR( commandBuffer, pRenderingInfo ); - } - - void vkCmdEndRenderingKHR( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndRenderingKHR( commandBuffer ); - } - -# if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - - VkResult vkCreateStreamDescriptorSurfaceGGP( VkInstance instance, - const VkStreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateStreamDescriptorSurfaceGGP( instance, pCreateInfo, pAllocator, pSurface ); - } -# endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - - VkResult - vkGetPhysicalDeviceExternalImageFormatPropertiesNV( VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV * pExternalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceExternalImageFormatPropertiesNV( - physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties ); - } - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - - VkResult vkGetMemoryWin32HandleNV( VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagsNV handleType, - HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryWin32HandleNV( device, memory, handleType, pHandle ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_get_physical_device_properties2 === - - void vkGetPhysicalDeviceFeatures2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 * pFeatures ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceFeatures2KHR( physicalDevice, pFeatures ); - } - - void vkGetPhysicalDeviceProperties2KHR( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceProperties2KHR( physicalDevice, pProperties ); - } - - void vkGetPhysicalDeviceFormatProperties2KHR( VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2 * pFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceFormatProperties2KHR( physicalDevice, format, pFormatProperties ); - } - - VkResult vkGetPhysicalDeviceImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2 * pImageFormatInfo, - VkImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceImageFormatProperties2KHR( physicalDevice, pImageFormatInfo, pImageFormatProperties ); - } - - void vkGetPhysicalDeviceQueueFamilyProperties2KHR( VkPhysicalDevice physicalDevice, - uint32_t * pQueueFamilyPropertyCount, - VkQueueFamilyProperties2 * pQueueFamilyProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceQueueFamilyProperties2KHR( physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties ); - } - - void vkGetPhysicalDeviceMemoryProperties2KHR( VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2 * pMemoryProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceMemoryProperties2KHR( physicalDevice, pMemoryProperties ); - } - - void vkGetPhysicalDeviceSparseImageFormatProperties2KHR( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, - uint32_t * pPropertyCount, - VkSparseImageFormatProperties2 * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSparseImageFormatProperties2KHR( physicalDevice, pFormatInfo, pPropertyCount, pProperties ); - } - - //=== VK_KHR_device_group === - - void vkGetDeviceGroupPeerMemoryFeaturesKHR( VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags * pPeerMemoryFeatures ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceGroupPeerMemoryFeaturesKHR( device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures ); - } - - void vkCmdSetDeviceMaskKHR( VkCommandBuffer commandBuffer, uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDeviceMaskKHR( commandBuffer, deviceMask ); - } - - void vkCmdDispatchBaseKHR( VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDispatchBaseKHR( commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); - } - -# if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - - VkResult vkCreateViSurfaceNN( VkInstance instance, - const VkViSurfaceCreateInfoNN * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateViSurfaceNN( instance, pCreateInfo, pAllocator, pSurface ); - } -# endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_maintenance1 === - - void vkTrimCommandPoolKHR( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT - { - return ::vkTrimCommandPoolKHR( device, commandPool, flags ); - } - - //=== VK_KHR_device_group_creation === - - VkResult vkEnumeratePhysicalDeviceGroupsKHR( VkInstance instance, - uint32_t * pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkEnumeratePhysicalDeviceGroupsKHR( instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties ); - } - - //=== VK_KHR_external_memory_capabilities === - - void vkGetPhysicalDeviceExternalBufferPropertiesKHR( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo * pExternalBufferInfo, - VkExternalBufferProperties * pExternalBufferProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceExternalBufferPropertiesKHR( physicalDevice, pExternalBufferInfo, pExternalBufferProperties ); - } - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - - VkResult - vkGetMemoryWin32HandleKHR( VkDevice device, const VkMemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryWin32HandleKHR( device, pGetWin32HandleInfo, pHandle ); - } - - VkResult vkGetMemoryWin32HandlePropertiesKHR( VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - HANDLE handle, - VkMemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryWin32HandlePropertiesKHR( device, handleType, handle, pMemoryWin32HandleProperties ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - - VkResult vkGetMemoryFdKHR( VkDevice device, const VkMemoryGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryFdKHR( device, pGetFdInfo, pFd ); - } - - VkResult vkGetMemoryFdPropertiesKHR( VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - int fd, - VkMemoryFdPropertiesKHR * pMemoryFdProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryFdPropertiesKHR( device, handleType, fd, pMemoryFdProperties ); - } - - //=== VK_KHR_external_semaphore_capabilities === - - void vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, - VkExternalSemaphoreProperties * pExternalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties ); - } - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - - VkResult vkImportSemaphoreWin32HandleKHR( VkDevice device, - const VkImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkImportSemaphoreWin32HandleKHR( device, pImportSemaphoreWin32HandleInfo ); - } - - VkResult vkGetSemaphoreWin32HandleKHR( VkDevice device, - const VkSemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, - HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetSemaphoreWin32HandleKHR( device, pGetWin32HandleInfo, pHandle ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - - VkResult vkImportSemaphoreFdKHR( VkDevice device, const VkImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkImportSemaphoreFdKHR( device, pImportSemaphoreFdInfo ); - } - - VkResult vkGetSemaphoreFdKHR( VkDevice device, const VkSemaphoreGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetSemaphoreFdKHR( device, pGetFdInfo, pFd ); - } - - //=== VK_KHR_push_descriptor === - - void vkCmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet * pDescriptorWrites ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushDescriptorSetKHR( commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites ); - } - - void vkCmdPushDescriptorSetWithTemplateKHR( VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout layout, - uint32_t set, - const void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushDescriptorSetWithTemplateKHR( commandBuffer, descriptorUpdateTemplate, layout, set, pData ); - } - - //=== VK_EXT_conditional_rendering === - - void vkCmdBeginConditionalRenderingEXT( VkCommandBuffer commandBuffer, - const VkConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginConditionalRenderingEXT( commandBuffer, pConditionalRenderingBegin ); - } - - void vkCmdEndConditionalRenderingEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndConditionalRenderingEXT( commandBuffer ); - } - - //=== VK_KHR_descriptor_update_template === - - VkResult vkCreateDescriptorUpdateTemplateKHR( VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkDescriptorUpdateTemplate * pDescriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDescriptorUpdateTemplateKHR( device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate ); - } - - void vkDestroyDescriptorUpdateTemplateKHR( VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyDescriptorUpdateTemplateKHR( device, descriptorUpdateTemplate, pAllocator ); - } - - void vkUpdateDescriptorSetWithTemplateKHR( VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkUpdateDescriptorSetWithTemplateKHR( device, descriptorSet, descriptorUpdateTemplate, pData ); - } - - //=== VK_NV_clip_space_w_scaling === - - void vkCmdSetViewportWScalingNV( VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportWScalingNV * pViewportWScalings ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetViewportWScalingNV( commandBuffer, firstViewport, viewportCount, pViewportWScalings ); - } - - //=== VK_EXT_direct_mode_display === - - VkResult vkReleaseDisplayEXT( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT - { - return ::vkReleaseDisplayEXT( physicalDevice, display ); - } - -# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - - VkResult vkAcquireXlibDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAcquireXlibDisplayEXT( physicalDevice, dpy, display ); - } - - VkResult - vkGetRandROutputDisplayEXT( VkPhysicalDevice physicalDevice, Display * dpy, RROutput rrOutput, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetRandROutputDisplayEXT( physicalDevice, dpy, rrOutput, pDisplay ); - } -# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - - VkResult vkGetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSurfaceCapabilities2EXT( physicalDevice, surface, pSurfaceCapabilities ); - } - - //=== VK_EXT_display_control === - - VkResult vkDisplayPowerControlEXT( VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT * pDisplayPowerInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDisplayPowerControlEXT( device, display, pDisplayPowerInfo ); - } - - VkResult vkRegisterDeviceEventEXT( VkDevice device, - const VkDeviceEventInfoEXT * pDeviceEventInfo, - const VkAllocationCallbacks * pAllocator, - VkFence * pFence ) const VULKAN_HPP_NOEXCEPT - { - return ::vkRegisterDeviceEventEXT( device, pDeviceEventInfo, pAllocator, pFence ); - } - - VkResult vkRegisterDisplayEventEXT( VkDevice device, - VkDisplayKHR display, - const VkDisplayEventInfoEXT * pDisplayEventInfo, - const VkAllocationCallbacks * pAllocator, - VkFence * pFence ) const VULKAN_HPP_NOEXCEPT - { - return ::vkRegisterDisplayEventEXT( device, display, pDisplayEventInfo, pAllocator, pFence ); - } - - VkResult vkGetSwapchainCounterEXT( VkDevice device, - VkSwapchainKHR swapchain, - VkSurfaceCounterFlagBitsEXT counter, - uint64_t * pCounterValue ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetSwapchainCounterEXT( device, swapchain, counter, pCounterValue ); - } - - //=== VK_GOOGLE_display_timing === - - VkResult vkGetRefreshCycleDurationGOOGLE( VkDevice device, - VkSwapchainKHR swapchain, - VkRefreshCycleDurationGOOGLE * pDisplayTimingProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetRefreshCycleDurationGOOGLE( device, swapchain, pDisplayTimingProperties ); - } - - VkResult vkGetPastPresentationTimingGOOGLE( VkDevice device, - VkSwapchainKHR swapchain, - uint32_t * pPresentationTimingCount, - VkPastPresentationTimingGOOGLE * pPresentationTimings ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPastPresentationTimingGOOGLE( device, swapchain, pPresentationTimingCount, pPresentationTimings ); - } - - //=== VK_EXT_discard_rectangles === - - void vkCmdSetDiscardRectangleEXT( VkCommandBuffer commandBuffer, - uint32_t firstDiscardRectangle, - uint32_t discardRectangleCount, - const VkRect2D * pDiscardRectangles ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDiscardRectangleEXT( commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles ); - } - - void vkCmdSetDiscardRectangleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDiscardRectangleEnableEXT( commandBuffer, discardRectangleEnable ); - } - - void vkCmdSetDiscardRectangleModeEXT( VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDiscardRectangleModeEXT( commandBuffer, discardRectangleMode ); - } - - //=== VK_EXT_hdr_metadata === - - void vkSetHdrMetadataEXT( VkDevice device, - uint32_t swapchainCount, - const VkSwapchainKHR * pSwapchains, - const VkHdrMetadataEXT * pMetadata ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSetHdrMetadataEXT( device, swapchainCount, pSwapchains, pMetadata ); - } - - //=== VK_KHR_create_renderpass2 === - - VkResult vkCreateRenderPass2KHR( VkDevice device, - const VkRenderPassCreateInfo2 * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkRenderPass * pRenderPass ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateRenderPass2KHR( device, pCreateInfo, pAllocator, pRenderPass ); - } - - void vkCmdBeginRenderPass2KHR( VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo * pRenderPassBegin, - const VkSubpassBeginInfo * pSubpassBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginRenderPass2KHR( commandBuffer, pRenderPassBegin, pSubpassBeginInfo ); - } - - void vkCmdNextSubpass2KHR( VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo * pSubpassBeginInfo, - const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdNextSubpass2KHR( commandBuffer, pSubpassBeginInfo, pSubpassEndInfo ); - } - - void vkCmdEndRenderPass2KHR( VkCommandBuffer commandBuffer, const VkSubpassEndInfo * pSubpassEndInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndRenderPass2KHR( commandBuffer, pSubpassEndInfo ); - } - - //=== VK_KHR_shared_presentable_image === - - VkResult vkGetSwapchainStatusKHR( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetSwapchainStatusKHR( device, swapchain ); - } - - //=== VK_KHR_external_fence_capabilities === - - void vkGetPhysicalDeviceExternalFencePropertiesKHR( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo * pExternalFenceInfo, - VkExternalFenceProperties * pExternalFenceProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceExternalFencePropertiesKHR( physicalDevice, pExternalFenceInfo, pExternalFenceProperties ); - } - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - - VkResult vkImportFenceWin32HandleKHR( VkDevice device, const VkImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkImportFenceWin32HandleKHR( device, pImportFenceWin32HandleInfo ); - } - - VkResult vkGetFenceWin32HandleKHR( VkDevice device, const VkFenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, HANDLE * pHandle ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetFenceWin32HandleKHR( device, pGetWin32HandleInfo, pHandle ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - - VkResult vkImportFenceFdKHR( VkDevice device, const VkImportFenceFdInfoKHR * pImportFenceFdInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkImportFenceFdKHR( device, pImportFenceFdInfo ); - } - - VkResult vkGetFenceFdKHR( VkDevice device, const VkFenceGetFdInfoKHR * pGetFdInfo, int * pFd ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetFenceFdKHR( device, pGetFdInfo, pFd ); - } - - //=== VK_KHR_performance_query === - - VkResult - vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - uint32_t * pCounterCount, - VkPerformanceCounterKHR * pCounters, - VkPerformanceCounterDescriptionKHR * pCounterDescriptions ) const VULKAN_HPP_NOEXCEPT - { - return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions ); - } - - void vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( VkPhysicalDevice physicalDevice, - const VkQueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, - uint32_t * pNumPasses ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( physicalDevice, pPerformanceQueryCreateInfo, pNumPasses ); - } - - VkResult vkAcquireProfilingLockKHR( VkDevice device, const VkAcquireProfilingLockInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAcquireProfilingLockKHR( device, pInfo ); - } - - void vkReleaseProfilingLockKHR( VkDevice device ) const VULKAN_HPP_NOEXCEPT - { - return ::vkReleaseProfilingLockKHR( device ); - } - - //=== VK_KHR_get_surface_capabilities2 === - - VkResult vkGetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - VkSurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSurfaceCapabilities2KHR( physicalDevice, pSurfaceInfo, pSurfaceCapabilities ); - } - - VkResult vkGetPhysicalDeviceSurfaceFormats2KHR( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - uint32_t * pSurfaceFormatCount, - VkSurfaceFormat2KHR * pSurfaceFormats ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSurfaceFormats2KHR( physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats ); - } - - //=== VK_KHR_get_display_properties2 === - - VkResult vkGetPhysicalDeviceDisplayProperties2KHR( VkPhysicalDevice physicalDevice, - uint32_t * pPropertyCount, - VkDisplayProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceDisplayProperties2KHR( physicalDevice, pPropertyCount, pProperties ); - } - - VkResult vkGetPhysicalDeviceDisplayPlaneProperties2KHR( VkPhysicalDevice physicalDevice, - uint32_t * pPropertyCount, - VkDisplayPlaneProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceDisplayPlaneProperties2KHR( physicalDevice, pPropertyCount, pProperties ); - } - - VkResult vkGetDisplayModeProperties2KHR( VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t * pPropertyCount, - VkDisplayModeProperties2KHR * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDisplayModeProperties2KHR( physicalDevice, display, pPropertyCount, pProperties ); - } - - VkResult vkGetDisplayPlaneCapabilities2KHR( VkPhysicalDevice physicalDevice, - const VkDisplayPlaneInfo2KHR * pDisplayPlaneInfo, - VkDisplayPlaneCapabilities2KHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDisplayPlaneCapabilities2KHR( physicalDevice, pDisplayPlaneInfo, pCapabilities ); - } - -# if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - - VkResult vkCreateIOSSurfaceMVK( VkInstance instance, - const VkIOSSurfaceCreateInfoMVK * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateIOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface ); - } -# endif /*VK_USE_PLATFORM_IOS_MVK*/ - -# if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - - VkResult vkCreateMacOSSurfaceMVK( VkInstance instance, - const VkMacOSSurfaceCreateInfoMVK * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateMacOSSurfaceMVK( instance, pCreateInfo, pAllocator, pSurface ); - } -# endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - - VkResult vkSetDebugUtilsObjectNameEXT( VkDevice device, const VkDebugUtilsObjectNameInfoEXT * pNameInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSetDebugUtilsObjectNameEXT( device, pNameInfo ); - } - - VkResult vkSetDebugUtilsObjectTagEXT( VkDevice device, const VkDebugUtilsObjectTagInfoEXT * pTagInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSetDebugUtilsObjectTagEXT( device, pTagInfo ); - } - - void vkQueueBeginDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkQueueBeginDebugUtilsLabelEXT( queue, pLabelInfo ); - } - - void vkQueueEndDebugUtilsLabelEXT( VkQueue queue ) const VULKAN_HPP_NOEXCEPT - { - return ::vkQueueEndDebugUtilsLabelEXT( queue ); - } - - void vkQueueInsertDebugUtilsLabelEXT( VkQueue queue, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkQueueInsertDebugUtilsLabelEXT( queue, pLabelInfo ); - } - - void vkCmdBeginDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginDebugUtilsLabelEXT( commandBuffer, pLabelInfo ); - } - - void vkCmdEndDebugUtilsLabelEXT( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndDebugUtilsLabelEXT( commandBuffer ); - } - - void vkCmdInsertDebugUtilsLabelEXT( VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT * pLabelInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdInsertDebugUtilsLabelEXT( commandBuffer, pLabelInfo ); - } - - VkResult vkCreateDebugUtilsMessengerEXT( VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkDebugUtilsMessengerEXT * pMessenger ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDebugUtilsMessengerEXT( instance, pCreateInfo, pAllocator, pMessenger ); - } - - void vkDestroyDebugUtilsMessengerEXT( VkInstance instance, - VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyDebugUtilsMessengerEXT( instance, messenger, pAllocator ); - } - - void vkSubmitDebugUtilsMessageEXT( VkInstance instance, - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT * pCallbackData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSubmitDebugUtilsMessageEXT( instance, messageSeverity, messageTypes, pCallbackData ); - } - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - - VkResult vkGetAndroidHardwareBufferPropertiesANDROID( VkDevice device, - const struct AHardwareBuffer * buffer, - VkAndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetAndroidHardwareBufferPropertiesANDROID( device, buffer, pProperties ); - } - - VkResult vkGetMemoryAndroidHardwareBufferANDROID( VkDevice device, - const VkMemoryGetAndroidHardwareBufferInfoANDROID * pInfo, - struct AHardwareBuffer ** pBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryAndroidHardwareBufferANDROID( device, pInfo, pBuffer ); - } -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - - VkResult vkCreateExecutionGraphPipelinesAMDX( VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkExecutionGraphPipelineCreateInfoAMDX * pCreateInfos, - const VkAllocationCallbacks * pAllocator, - VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateExecutionGraphPipelinesAMDX( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); - } - - VkResult vkGetExecutionGraphPipelineScratchSizeAMDX( VkDevice device, - VkPipeline executionGraph, - VkExecutionGraphPipelineScratchSizeAMDX * pSizeInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetExecutionGraphPipelineScratchSizeAMDX( device, executionGraph, pSizeInfo ); - } - - VkResult vkGetExecutionGraphPipelineNodeIndexAMDX( VkDevice device, - VkPipeline executionGraph, - const VkPipelineShaderStageNodeCreateInfoAMDX * pNodeInfo, - uint32_t * pNodeIndex ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetExecutionGraphPipelineNodeIndexAMDX( device, executionGraph, pNodeInfo, pNodeIndex ); - } - - void vkCmdInitializeGraphScratchMemoryAMDX( VkCommandBuffer commandBuffer, - VkPipeline executionGraph, - VkDeviceAddress scratch, - VkDeviceSize scratchSize ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdInitializeGraphScratchMemoryAMDX( commandBuffer, executionGraph, scratch, scratchSize ); - } - - void vkCmdDispatchGraphAMDX( VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDispatchGraphAMDX( commandBuffer, scratch, scratchSize, pCountInfo ); - } - - void vkCmdDispatchGraphIndirectAMDX( VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - const VkDispatchGraphCountInfoAMDX * pCountInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDispatchGraphIndirectAMDX( commandBuffer, scratch, scratchSize, pCountInfo ); - } - - void vkCmdDispatchGraphIndirectCountAMDX( VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - VkDeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDispatchGraphIndirectCountAMDX( commandBuffer, scratch, scratchSize, countInfo ); - } -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - - VkResult vkWriteSamplerDescriptorsEXT( VkDevice device, - uint32_t samplerCount, - const VkSamplerCreateInfo * pSamplers, - const VkHostAddressRangeEXT * pDescriptors ) const VULKAN_HPP_NOEXCEPT - { - return ::vkWriteSamplerDescriptorsEXT( device, samplerCount, pSamplers, pDescriptors ); - } - - VkResult vkWriteResourceDescriptorsEXT( VkDevice device, - uint32_t resourceCount, - const VkResourceDescriptorInfoEXT * pResources, - const VkHostAddressRangeEXT * pDescriptors ) const VULKAN_HPP_NOEXCEPT - { - return ::vkWriteResourceDescriptorsEXT( device, resourceCount, pResources, pDescriptors ); - } - - void vkCmdBindSamplerHeapEXT( VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT * pBindInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindSamplerHeapEXT( commandBuffer, pBindInfo ); - } - - void vkCmdBindResourceHeapEXT( VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT * pBindInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindResourceHeapEXT( commandBuffer, pBindInfo ); - } - - void vkCmdPushDataEXT( VkCommandBuffer commandBuffer, const VkPushDataInfoEXT * pPushDataInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushDataEXT( commandBuffer, pPushDataInfo ); - } - - VkResult vkGetImageOpaqueCaptureDataEXT( VkDevice device, - uint32_t imageCount, - const VkImage * pImages, - VkHostAddressRangeEXT * pDatas ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageOpaqueCaptureDataEXT( device, imageCount, pImages, pDatas ); - } - - VkDeviceSize vkGetPhysicalDeviceDescriptorSizeEXT( VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceDescriptorSizeEXT( physicalDevice, descriptorType ); - } - - VkResult vkRegisterCustomBorderColorEXT( VkDevice device, - const VkSamplerCustomBorderColorCreateInfoEXT * pBorderColor, - VkBool32 requestIndex, - uint32_t * pIndex ) const VULKAN_HPP_NOEXCEPT - { - return ::vkRegisterCustomBorderColorEXT( device, pBorderColor, requestIndex, pIndex ); - } - - void vkUnregisterCustomBorderColorEXT( VkDevice device, uint32_t index ) const VULKAN_HPP_NOEXCEPT - { - return ::vkUnregisterCustomBorderColorEXT( device, index ); - } - - VkResult vkGetTensorOpaqueCaptureDataARM( VkDevice device, - uint32_t tensorCount, - const VkTensorARM * pTensors, - VkHostAddressRangeEXT * pDatas ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetTensorOpaqueCaptureDataARM( device, tensorCount, pTensors, pDatas ); - } - - //=== VK_EXT_sample_locations === - - void vkCmdSetSampleLocationsEXT( VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT * pSampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetSampleLocationsEXT( commandBuffer, pSampleLocationsInfo ); - } - - void vkGetPhysicalDeviceMultisamplePropertiesEXT( VkPhysicalDevice physicalDevice, - VkSampleCountFlagBits samples, - VkMultisamplePropertiesEXT * pMultisampleProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceMultisamplePropertiesEXT( physicalDevice, samples, pMultisampleProperties ); - } - - //=== VK_KHR_get_memory_requirements2 === - - void vkGetImageMemoryRequirements2KHR( VkDevice device, - const VkImageMemoryRequirementsInfo2 * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageMemoryRequirements2KHR( device, pInfo, pMemoryRequirements ); - } - - void vkGetBufferMemoryRequirements2KHR( VkDevice device, - const VkBufferMemoryRequirementsInfo2 * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetBufferMemoryRequirements2KHR( device, pInfo, pMemoryRequirements ); - } - - void vkGetImageSparseMemoryRequirements2KHR( VkDevice device, - const VkImageSparseMemoryRequirementsInfo2 * pInfo, - uint32_t * pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageSparseMemoryRequirements2KHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); - } - - //=== VK_KHR_acceleration_structure === - - VkResult vkCreateAccelerationStructureKHR( VkDevice device, - const VkAccelerationStructureCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkAccelerationStructureKHR * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateAccelerationStructureKHR( device, pCreateInfo, pAllocator, pAccelerationStructure ); - } - - void vkDestroyAccelerationStructureKHR( VkDevice device, - VkAccelerationStructureKHR accelerationStructure, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyAccelerationStructureKHR( device, accelerationStructure, pAllocator ); - } - - void vkCmdBuildAccelerationStructuresKHR( VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, - const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBuildAccelerationStructuresKHR( commandBuffer, infoCount, pInfos, ppBuildRangeInfos ); - } - - void vkCmdBuildAccelerationStructuresIndirectKHR( VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, - const VkDeviceAddress * pIndirectDeviceAddresses, - const uint32_t * pIndirectStrides, - const uint32_t * const * ppMaxPrimitiveCounts ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBuildAccelerationStructuresIndirectKHR( - commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts ); - } - - VkResult vkBuildAccelerationStructuresKHR( VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR * pInfos, - const VkAccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBuildAccelerationStructuresKHR( device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos ); - } - - VkResult vkCopyAccelerationStructureKHR( VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyAccelerationStructureKHR( device, deferredOperation, pInfo ); - } - - VkResult vkCopyAccelerationStructureToMemoryKHR( VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyAccelerationStructureToMemoryKHR( device, deferredOperation, pInfo ); - } - - VkResult vkCopyMemoryToAccelerationStructureKHR( VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyMemoryToAccelerationStructureKHR( device, deferredOperation, pInfo ); - } - - VkResult vkWriteAccelerationStructuresPropertiesKHR( VkDevice device, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR * pAccelerationStructures, - VkQueryType queryType, - size_t dataSize, - void * pData, - size_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkWriteAccelerationStructuresPropertiesKHR( device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride ); - } - - void vkCmdCopyAccelerationStructureKHR( VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyAccelerationStructureKHR( commandBuffer, pInfo ); - } - - void vkCmdCopyAccelerationStructureToMemoryKHR( VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureToMemoryInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyAccelerationStructureToMemoryKHR( commandBuffer, pInfo ); - } - - void vkCmdCopyMemoryToAccelerationStructureKHR( VkCommandBuffer commandBuffer, - const VkCopyMemoryToAccelerationStructureInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyMemoryToAccelerationStructureKHR( commandBuffer, pInfo ); - } - - VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR( VkDevice device, - const VkAccelerationStructureDeviceAddressInfoKHR * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetAccelerationStructureDeviceAddressKHR( device, pInfo ); - } - - void vkCmdWriteAccelerationStructuresPropertiesKHR( VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR * pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdWriteAccelerationStructuresPropertiesKHR( - commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery ); - } - - void vkGetDeviceAccelerationStructureCompatibilityKHR( VkDevice device, - const VkAccelerationStructureVersionInfoKHR * pVersionInfo, - VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceAccelerationStructureCompatibilityKHR( device, pVersionInfo, pCompatibility ); - } - - void vkGetAccelerationStructureBuildSizesKHR( VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkAccelerationStructureBuildGeometryInfoKHR * pBuildInfo, - const uint32_t * pMaxPrimitiveCounts, - VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetAccelerationStructureBuildSizesKHR( device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo ); - } - - //=== VK_KHR_ray_tracing_pipeline === - - void vkCmdTraceRaysKHR( VkCommandBuffer commandBuffer, - const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, - const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable, - const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable, - const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable, - uint32_t width, - uint32_t height, - uint32_t depth ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdTraceRaysKHR( - commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth ); - } - - VkResult vkCreateRayTracingPipelinesKHR( VkDevice device, - VkDeferredOperationKHR deferredOperation, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoKHR * pCreateInfos, - const VkAllocationCallbacks * pAllocator, - VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateRayTracingPipelinesKHR( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); - } - - VkResult vkGetRayTracingShaderGroupHandlesKHR( - VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetRayTracingShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData ); - } - - VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( - VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( device, pipeline, firstGroup, groupCount, dataSize, pData ); - } - - void vkCmdTraceRaysIndirectKHR( VkCommandBuffer commandBuffer, - const VkStridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, - const VkStridedDeviceAddressRegionKHR * pMissShaderBindingTable, - const VkStridedDeviceAddressRegionKHR * pHitShaderBindingTable, - const VkStridedDeviceAddressRegionKHR * pCallableShaderBindingTable, - VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdTraceRaysIndirectKHR( - commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress ); - } - - VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR( VkDevice device, - VkPipeline pipeline, - uint32_t group, - VkShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetRayTracingShaderGroupStackSizeKHR( device, pipeline, group, groupShader ); - } - - void vkCmdSetRayTracingPipelineStackSizeKHR( VkCommandBuffer commandBuffer, uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetRayTracingPipelineStackSizeKHR( commandBuffer, pipelineStackSize ); - } - - //=== VK_KHR_sampler_ycbcr_conversion === - - VkResult vkCreateSamplerYcbcrConversionKHR( VkDevice device, - const VkSamplerYcbcrConversionCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSamplerYcbcrConversion * pYcbcrConversion ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateSamplerYcbcrConversionKHR( device, pCreateInfo, pAllocator, pYcbcrConversion ); - } - - void vkDestroySamplerYcbcrConversionKHR( VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroySamplerYcbcrConversionKHR( device, ycbcrConversion, pAllocator ); - } - - //=== VK_KHR_bind_memory2 === - - VkResult vkBindBufferMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBindBufferMemory2KHR( device, bindInfoCount, pBindInfos ); - } - - VkResult vkBindImageMemory2KHR( VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo * pBindInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBindImageMemory2KHR( device, bindInfoCount, pBindInfos ); - } - - //=== VK_EXT_image_drm_format_modifier === - - VkResult vkGetImageDrmFormatModifierPropertiesEXT( VkDevice device, - VkImage image, - VkImageDrmFormatModifierPropertiesEXT * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageDrmFormatModifierPropertiesEXT( device, image, pProperties ); - } - - //=== VK_EXT_validation_cache === - - VkResult vkCreateValidationCacheEXT( VkDevice device, - const VkValidationCacheCreateInfoEXT * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkValidationCacheEXT * pValidationCache ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateValidationCacheEXT( device, pCreateInfo, pAllocator, pValidationCache ); - } - - void - vkDestroyValidationCacheEXT( VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyValidationCacheEXT( device, validationCache, pAllocator ); - } - - VkResult vkMergeValidationCachesEXT( VkDevice device, - VkValidationCacheEXT dstCache, - uint32_t srcCacheCount, - const VkValidationCacheEXT * pSrcCaches ) const VULKAN_HPP_NOEXCEPT - { - return ::vkMergeValidationCachesEXT( device, dstCache, srcCacheCount, pSrcCaches ); - } - - VkResult vkGetValidationCacheDataEXT( VkDevice device, VkValidationCacheEXT validationCache, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetValidationCacheDataEXT( device, validationCache, pDataSize, pData ); - } - - //=== VK_NV_shading_rate_image === - - void vkCmdBindShadingRateImageNV( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindShadingRateImageNV( commandBuffer, imageView, imageLayout ); - } - - void vkCmdSetViewportShadingRatePaletteNV( VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkShadingRatePaletteNV * pShadingRatePalettes ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetViewportShadingRatePaletteNV( commandBuffer, firstViewport, viewportCount, pShadingRatePalettes ); - } - - void vkCmdSetCoarseSampleOrderNV( VkCommandBuffer commandBuffer, - VkCoarseSampleOrderTypeNV sampleOrderType, - uint32_t customSampleOrderCount, - const VkCoarseSampleOrderCustomNV * pCustomSampleOrders ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetCoarseSampleOrderNV( commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders ); - } - - //=== VK_NV_ray_tracing === - - VkResult vkCreateAccelerationStructureNV( VkDevice device, - const VkAccelerationStructureCreateInfoNV * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkAccelerationStructureNV * pAccelerationStructure ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateAccelerationStructureNV( device, pCreateInfo, pAllocator, pAccelerationStructure ); - } - - void vkDestroyAccelerationStructureNV( VkDevice device, - VkAccelerationStructureNV accelerationStructure, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyAccelerationStructureNV( device, accelerationStructure, pAllocator ); - } - - void vkGetAccelerationStructureMemoryRequirementsNV( VkDevice device, - const VkAccelerationStructureMemoryRequirementsInfoNV * pInfo, - VkMemoryRequirements2KHR * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetAccelerationStructureMemoryRequirementsNV( device, pInfo, pMemoryRequirements ); - } - - VkResult vkBindAccelerationStructureMemoryNV( VkDevice device, - uint32_t bindInfoCount, - const VkBindAccelerationStructureMemoryInfoNV * pBindInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBindAccelerationStructureMemoryNV( device, bindInfoCount, pBindInfos ); - } - - void vkCmdBuildAccelerationStructureNV( VkCommandBuffer commandBuffer, - const VkAccelerationStructureInfoNV * pInfo, - VkBuffer instanceData, - VkDeviceSize instanceOffset, - VkBool32 update, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkBuffer scratch, - VkDeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBuildAccelerationStructureNV( commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset ); - } - - void vkCmdCopyAccelerationStructureNV( VkCommandBuffer commandBuffer, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkCopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyAccelerationStructureNV( commandBuffer, dst, src, mode ); - } - - void vkCmdTraceRaysNV( VkCommandBuffer commandBuffer, - VkBuffer raygenShaderBindingTableBuffer, - VkDeviceSize raygenShaderBindingOffset, - VkBuffer missShaderBindingTableBuffer, - VkDeviceSize missShaderBindingOffset, - VkDeviceSize missShaderBindingStride, - VkBuffer hitShaderBindingTableBuffer, - VkDeviceSize hitShaderBindingOffset, - VkDeviceSize hitShaderBindingStride, - VkBuffer callableShaderBindingTableBuffer, - VkDeviceSize callableShaderBindingOffset, - VkDeviceSize callableShaderBindingStride, - uint32_t width, - uint32_t height, - uint32_t depth ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdTraceRaysNV( commandBuffer, - raygenShaderBindingTableBuffer, - raygenShaderBindingOffset, - missShaderBindingTableBuffer, - missShaderBindingOffset, - missShaderBindingStride, - hitShaderBindingTableBuffer, - hitShaderBindingOffset, - hitShaderBindingStride, - callableShaderBindingTableBuffer, - callableShaderBindingOffset, - callableShaderBindingStride, - width, - height, - depth ); - } - - VkResult vkCreateRayTracingPipelinesNV( VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoNV * pCreateInfos, - const VkAllocationCallbacks * pAllocator, - VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateRayTracingPipelinesNV( device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); - } - - VkResult vkGetRayTracingShaderGroupHandlesNV( - VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetRayTracingShaderGroupHandlesNV( device, pipeline, firstGroup, groupCount, dataSize, pData ); - } - - VkResult vkGetAccelerationStructureHandleNV( VkDevice device, - VkAccelerationStructureNV accelerationStructure, - size_t dataSize, - void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetAccelerationStructureHandleNV( device, accelerationStructure, dataSize, pData ); - } - - void vkCmdWriteAccelerationStructuresPropertiesNV( VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureNV * pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdWriteAccelerationStructuresPropertiesNV( - commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery ); - } - - VkResult vkCompileDeferredNV( VkDevice device, VkPipeline pipeline, uint32_t shader ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCompileDeferredNV( device, pipeline, shader ); - } - - //=== VK_KHR_maintenance3 === - - void vkGetDescriptorSetLayoutSupportKHR( VkDevice device, - const VkDescriptorSetLayoutCreateInfo * pCreateInfo, - VkDescriptorSetLayoutSupport * pSupport ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDescriptorSetLayoutSupportKHR( device, pCreateInfo, pSupport ); - } - - //=== VK_KHR_draw_indirect_count === - - void vkCmdDrawIndirectCountKHR( VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); - } - - void vkCmdDrawIndexedIndirectCountKHR( VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawIndexedIndirectCountKHR( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); - } - - //=== VK_EXT_external_memory_host === - - VkResult vkGetMemoryHostPointerPropertiesEXT( VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - const void * pHostPointer, - VkMemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryHostPointerPropertiesEXT( device, handleType, pHostPointer, pMemoryHostPointerProperties ); - } - - //=== VK_AMD_buffer_marker === - - void vkCmdWriteBufferMarkerAMD( VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdWriteBufferMarkerAMD( commandBuffer, pipelineStage, dstBuffer, dstOffset, marker ); - } - - void vkCmdWriteBufferMarker2AMD( - VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdWriteBufferMarker2AMD( commandBuffer, stage, dstBuffer, dstOffset, marker ); - } - - //=== VK_EXT_calibrated_timestamps === - - VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( VkPhysicalDevice physicalDevice, - uint32_t * pTimeDomainCount, - VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( physicalDevice, pTimeDomainCount, pTimeDomains ); - } - - VkResult vkGetCalibratedTimestampsEXT( VkDevice device, - uint32_t timestampCount, - const VkCalibratedTimestampInfoKHR * pTimestampInfos, - uint64_t * pTimestamps, - uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetCalibratedTimestampsEXT( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation ); - } - - //=== VK_NV_mesh_shader === - - void vkCmdDrawMeshTasksNV( VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawMeshTasksNV( commandBuffer, taskCount, firstTask ); - } - - void vkCmdDrawMeshTasksIndirectNV( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawMeshTasksIndirectNV( commandBuffer, buffer, offset, drawCount, stride ); - } - - void vkCmdDrawMeshTasksIndirectCountNV( VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawMeshTasksIndirectCountNV( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); - } - - //=== VK_NV_scissor_exclusive === - - void vkCmdSetExclusiveScissorEnableNV( VkCommandBuffer commandBuffer, - uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const VkBool32 * pExclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetExclusiveScissorEnableNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables ); - } - - void vkCmdSetExclusiveScissorNV( VkCommandBuffer commandBuffer, - uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const VkRect2D * pExclusiveScissors ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetExclusiveScissorNV( commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors ); - } - - //=== VK_NV_device_diagnostic_checkpoints === - - void vkCmdSetCheckpointNV( VkCommandBuffer commandBuffer, const void * pCheckpointMarker ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetCheckpointNV( commandBuffer, pCheckpointMarker ); - } - - void vkGetQueueCheckpointDataNV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointDataNV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetQueueCheckpointDataNV( queue, pCheckpointDataCount, pCheckpointData ); - } - - void vkGetQueueCheckpointData2NV( VkQueue queue, uint32_t * pCheckpointDataCount, VkCheckpointData2NV * pCheckpointData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetQueueCheckpointData2NV( queue, pCheckpointDataCount, pCheckpointData ); - } - - //=== VK_KHR_timeline_semaphore === - - VkResult vkGetSemaphoreCounterValueKHR( VkDevice device, VkSemaphore semaphore, uint64_t * pValue ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetSemaphoreCounterValueKHR( device, semaphore, pValue ); - } - - VkResult vkWaitSemaphoresKHR( VkDevice device, const VkSemaphoreWaitInfo * pWaitInfo, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkWaitSemaphoresKHR( device, pWaitInfo, timeout ); - } - - VkResult vkSignalSemaphoreKHR( VkDevice device, const VkSemaphoreSignalInfo * pSignalInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSignalSemaphoreKHR( device, pSignalInfo ); - } - - //=== VK_EXT_present_timing === - - VkResult vkSetSwapchainPresentTimingQueueSizeEXT( VkDevice device, VkSwapchainKHR swapchain, uint32_t size ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSetSwapchainPresentTimingQueueSizeEXT( device, swapchain, size ); - } - - VkResult vkGetSwapchainTimingPropertiesEXT( VkDevice device, - VkSwapchainKHR swapchain, - VkSwapchainTimingPropertiesEXT * pSwapchainTimingProperties, - uint64_t * pSwapchainTimingPropertiesCounter ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetSwapchainTimingPropertiesEXT( device, swapchain, pSwapchainTimingProperties, pSwapchainTimingPropertiesCounter ); - } - - VkResult vkGetSwapchainTimeDomainPropertiesEXT( VkDevice device, - VkSwapchainKHR swapchain, - VkSwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, - uint64_t * pTimeDomainsCounter ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetSwapchainTimeDomainPropertiesEXT( device, swapchain, pSwapchainTimeDomainProperties, pTimeDomainsCounter ); - } - - VkResult vkGetPastPresentationTimingEXT( VkDevice device, - const VkPastPresentationTimingInfoEXT * pPastPresentationTimingInfo, - VkPastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPastPresentationTimingEXT( device, pPastPresentationTimingInfo, pPastPresentationTimingProperties ); - } - - //=== VK_INTEL_performance_query === - - VkResult vkInitializePerformanceApiINTEL( VkDevice device, const VkInitializePerformanceApiInfoINTEL * pInitializeInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkInitializePerformanceApiINTEL( device, pInitializeInfo ); - } - - void vkUninitializePerformanceApiINTEL( VkDevice device ) const VULKAN_HPP_NOEXCEPT - { - return ::vkUninitializePerformanceApiINTEL( device ); - } - - VkResult vkCmdSetPerformanceMarkerINTEL( VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetPerformanceMarkerINTEL( commandBuffer, pMarkerInfo ); - } - - VkResult vkCmdSetPerformanceStreamMarkerINTEL( VkCommandBuffer commandBuffer, - const VkPerformanceStreamMarkerInfoINTEL * pMarkerInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetPerformanceStreamMarkerINTEL( commandBuffer, pMarkerInfo ); - } - - VkResult vkCmdSetPerformanceOverrideINTEL( VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL * pOverrideInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetPerformanceOverrideINTEL( commandBuffer, pOverrideInfo ); - } - - VkResult vkAcquirePerformanceConfigurationINTEL( VkDevice device, - const VkPerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, - VkPerformanceConfigurationINTEL * pConfiguration ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAcquirePerformanceConfigurationINTEL( device, pAcquireInfo, pConfiguration ); - } - - VkResult vkReleasePerformanceConfigurationINTEL( VkDevice device, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT - { - return ::vkReleasePerformanceConfigurationINTEL( device, configuration ); - } - - VkResult vkQueueSetPerformanceConfigurationINTEL( VkQueue queue, VkPerformanceConfigurationINTEL configuration ) const VULKAN_HPP_NOEXCEPT - { - return ::vkQueueSetPerformanceConfigurationINTEL( queue, configuration ); - } - - VkResult - vkGetPerformanceParameterINTEL( VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL * pValue ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPerformanceParameterINTEL( device, parameter, pValue ); - } - - //=== VK_AMD_display_native_hdr === - - void vkSetLocalDimmingAMD( VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSetLocalDimmingAMD( device, swapChain, localDimmingEnable ); - } - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - - VkResult vkCreateImagePipeSurfaceFUCHSIA( VkInstance instance, - const VkImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateImagePipeSurfaceFUCHSIA( instance, pCreateInfo, pAllocator, pSurface ); - } -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - - VkResult vkCreateMetalSurfaceEXT( VkInstance instance, - const VkMetalSurfaceCreateInfoEXT * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateMetalSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface ); - } -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_fragment_shading_rate === - - VkResult vkGetPhysicalDeviceFragmentShadingRatesKHR( VkPhysicalDevice physicalDevice, - uint32_t * pFragmentShadingRateCount, - VkPhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceFragmentShadingRatesKHR( physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates ); - } - - void vkCmdSetFragmentShadingRateKHR( VkCommandBuffer commandBuffer, - const VkExtent2D * pFragmentSize, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetFragmentShadingRateKHR( commandBuffer, pFragmentSize, combinerOps ); - } - - //=== VK_KHR_dynamic_rendering_local_read === - - void vkCmdSetRenderingAttachmentLocationsKHR( VkCommandBuffer commandBuffer, - const VkRenderingAttachmentLocationInfo * pLocationInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetRenderingAttachmentLocationsKHR( commandBuffer, pLocationInfo ); - } - - void vkCmdSetRenderingInputAttachmentIndicesKHR( VkCommandBuffer commandBuffer, - const VkRenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetRenderingInputAttachmentIndicesKHR( commandBuffer, pInputAttachmentIndexInfo ); - } - - //=== VK_EXT_buffer_device_address === - - VkDeviceAddress vkGetBufferDeviceAddressEXT( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetBufferDeviceAddressEXT( device, pInfo ); - } - - //=== VK_EXT_tooling_info === - - VkResult vkGetPhysicalDeviceToolPropertiesEXT( VkPhysicalDevice physicalDevice, - uint32_t * pToolCount, - VkPhysicalDeviceToolProperties * pToolProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceToolPropertiesEXT( physicalDevice, pToolCount, pToolProperties ); - } - - //=== VK_KHR_present_wait === - - VkResult vkWaitForPresentKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkWaitForPresentKHR( device, swapchain, presentId, timeout ); - } - - //=== VK_NV_cooperative_matrix === - - VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDevice physicalDevice, - uint32_t * pPropertyCount, - VkCooperativeMatrixPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( physicalDevice, pPropertyCount, pProperties ); - } - - //=== VK_NV_coverage_reduction_mode === - - VkResult vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - VkPhysicalDevice physicalDevice, uint32_t * pCombinationCount, VkFramebufferMixedSamplesCombinationNV * pCombinations ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( physicalDevice, pCombinationCount, pCombinations ); - } - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - - VkResult vkGetPhysicalDeviceSurfacePresentModes2EXT( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - uint32_t * pPresentModeCount, - VkPresentModeKHR * pPresentModes ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceSurfacePresentModes2EXT( physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes ); - } - - VkResult vkAcquireFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAcquireFullScreenExclusiveModeEXT( device, swapchain ); - } - - VkResult vkReleaseFullScreenExclusiveModeEXT( VkDevice device, VkSwapchainKHR swapchain ) const VULKAN_HPP_NOEXCEPT - { - return ::vkReleaseFullScreenExclusiveModeEXT( device, swapchain ); - } - - VkResult vkGetDeviceGroupSurfacePresentModes2EXT( VkDevice device, - const VkPhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - VkDeviceGroupPresentModeFlagsKHR * pModes ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceGroupSurfacePresentModes2EXT( device, pSurfaceInfo, pModes ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - - VkResult vkCreateHeadlessSurfaceEXT( VkInstance instance, - const VkHeadlessSurfaceCreateInfoEXT * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateHeadlessSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface ); - } - - //=== VK_KHR_buffer_device_address === - - VkDeviceAddress vkGetBufferDeviceAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetBufferDeviceAddressKHR( device, pInfo ); - } - - uint64_t vkGetBufferOpaqueCaptureAddressKHR( VkDevice device, const VkBufferDeviceAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetBufferOpaqueCaptureAddressKHR( device, pInfo ); - } - - uint64_t vkGetDeviceMemoryOpaqueCaptureAddressKHR( VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceMemoryOpaqueCaptureAddressKHR( device, pInfo ); - } - - //=== VK_EXT_line_rasterization === - - void vkCmdSetLineStippleEXT( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetLineStippleEXT( commandBuffer, lineStippleFactor, lineStipplePattern ); - } - - //=== VK_EXT_host_query_reset === - - void vkResetQueryPoolEXT( VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT - { - return ::vkResetQueryPoolEXT( device, queryPool, firstQuery, queryCount ); - } - - //=== VK_EXT_extended_dynamic_state === - - void vkCmdSetCullModeEXT( VkCommandBuffer commandBuffer, VkCullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetCullModeEXT( commandBuffer, cullMode ); - } - - void vkCmdSetFrontFaceEXT( VkCommandBuffer commandBuffer, VkFrontFace frontFace ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetFrontFaceEXT( commandBuffer, frontFace ); - } - - void vkCmdSetPrimitiveTopologyEXT( VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetPrimitiveTopologyEXT( commandBuffer, primitiveTopology ); - } - - void vkCmdSetViewportWithCountEXT( VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport * pViewports ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetViewportWithCountEXT( commandBuffer, viewportCount, pViewports ); - } - - void vkCmdSetScissorWithCountEXT( VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D * pScissors ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetScissorWithCountEXT( commandBuffer, scissorCount, pScissors ); - } - - void vkCmdBindVertexBuffers2EXT( VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer * pBuffers, - const VkDeviceSize * pOffsets, - const VkDeviceSize * pSizes, - const VkDeviceSize * pStrides ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindVertexBuffers2EXT( commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides ); - } - - void vkCmdSetDepthTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthTestEnableEXT( commandBuffer, depthTestEnable ); - } - - void vkCmdSetDepthWriteEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthWriteEnableEXT( commandBuffer, depthWriteEnable ); - } - - void vkCmdSetDepthCompareOpEXT( VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthCompareOpEXT( commandBuffer, depthCompareOp ); - } - - void vkCmdSetDepthBoundsTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthBoundsTestEnableEXT( commandBuffer, depthBoundsTestEnable ); - } - - void vkCmdSetStencilTestEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetStencilTestEnableEXT( commandBuffer, stencilTestEnable ); - } - - void vkCmdSetStencilOpEXT( VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetStencilOpEXT( commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp ); - } - - //=== VK_KHR_deferred_host_operations === - - VkResult vkCreateDeferredOperationKHR( VkDevice device, - const VkAllocationCallbacks * pAllocator, - VkDeferredOperationKHR * pDeferredOperation ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDeferredOperationKHR( device, pAllocator, pDeferredOperation ); - } - - void - vkDestroyDeferredOperationKHR( VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyDeferredOperationKHR( device, operation, pAllocator ); - } - - uint32_t vkGetDeferredOperationMaxConcurrencyKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeferredOperationMaxConcurrencyKHR( device, operation ); - } - - VkResult vkGetDeferredOperationResultKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeferredOperationResultKHR( device, operation ); - } - - VkResult vkDeferredOperationJoinKHR( VkDevice device, VkDeferredOperationKHR operation ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDeferredOperationJoinKHR( device, operation ); - } - - //=== VK_KHR_pipeline_executable_properties === - - VkResult vkGetPipelineExecutablePropertiesKHR( VkDevice device, - const VkPipelineInfoKHR * pPipelineInfo, - uint32_t * pExecutableCount, - VkPipelineExecutablePropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPipelineExecutablePropertiesKHR( device, pPipelineInfo, pExecutableCount, pProperties ); - } - - VkResult vkGetPipelineExecutableStatisticsKHR( VkDevice device, - const VkPipelineExecutableInfoKHR * pExecutableInfo, - uint32_t * pStatisticCount, - VkPipelineExecutableStatisticKHR * pStatistics ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPipelineExecutableStatisticsKHR( device, pExecutableInfo, pStatisticCount, pStatistics ); - } - - VkResult - vkGetPipelineExecutableInternalRepresentationsKHR( VkDevice device, - const VkPipelineExecutableInfoKHR * pExecutableInfo, - uint32_t * pInternalRepresentationCount, - VkPipelineExecutableInternalRepresentationKHR * pInternalRepresentations ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPipelineExecutableInternalRepresentationsKHR( device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations ); - } - - //=== VK_EXT_host_image_copy === - - VkResult vkCopyMemoryToImageEXT( VkDevice device, const VkCopyMemoryToImageInfo * pCopyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyMemoryToImageEXT( device, pCopyMemoryToImageInfo ); - } - - VkResult vkCopyImageToMemoryEXT( VkDevice device, const VkCopyImageToMemoryInfo * pCopyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyImageToMemoryEXT( device, pCopyImageToMemoryInfo ); - } - - VkResult vkCopyImageToImageEXT( VkDevice device, const VkCopyImageToImageInfo * pCopyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyImageToImageEXT( device, pCopyImageToImageInfo ); - } - - VkResult - vkTransitionImageLayoutEXT( VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo * pTransitions ) const VULKAN_HPP_NOEXCEPT - { - return ::vkTransitionImageLayoutEXT( device, transitionCount, pTransitions ); - } - - void vkGetImageSubresourceLayout2EXT( VkDevice device, - VkImage image, - const VkImageSubresource2 * pSubresource, - VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageSubresourceLayout2EXT( device, image, pSubresource, pLayout ); - } - - //=== VK_KHR_map_memory2 === - - VkResult vkMapMemory2KHR( VkDevice device, const VkMemoryMapInfo * pMemoryMapInfo, void ** ppData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkMapMemory2KHR( device, pMemoryMapInfo, ppData ); - } - - VkResult vkUnmapMemory2KHR( VkDevice device, const VkMemoryUnmapInfo * pMemoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkUnmapMemory2KHR( device, pMemoryUnmapInfo ); - } - - //=== VK_EXT_swapchain_maintenance1 === - - VkResult vkReleaseSwapchainImagesEXT( VkDevice device, const VkReleaseSwapchainImagesInfoKHR * pReleaseInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkReleaseSwapchainImagesEXT( device, pReleaseInfo ); - } - - //=== VK_NV_device_generated_commands === - - void vkGetGeneratedCommandsMemoryRequirementsNV( VkDevice device, - const VkGeneratedCommandsMemoryRequirementsInfoNV * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetGeneratedCommandsMemoryRequirementsNV( device, pInfo, pMemoryRequirements ); - } - - void vkCmdPreprocessGeneratedCommandsNV( VkCommandBuffer commandBuffer, - const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPreprocessGeneratedCommandsNV( commandBuffer, pGeneratedCommandsInfo ); - } - - void vkCmdExecuteGeneratedCommandsNV( VkCommandBuffer commandBuffer, - VkBool32 isPreprocessed, - const VkGeneratedCommandsInfoNV * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdExecuteGeneratedCommandsNV( commandBuffer, isPreprocessed, pGeneratedCommandsInfo ); - } - - void vkCmdBindPipelineShaderGroupNV( VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline, - uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindPipelineShaderGroupNV( commandBuffer, pipelineBindPoint, pipeline, groupIndex ); - } - - VkResult vkCreateIndirectCommandsLayoutNV( VkDevice device, - const VkIndirectCommandsLayoutCreateInfoNV * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkIndirectCommandsLayoutNV * pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateIndirectCommandsLayoutNV( device, pCreateInfo, pAllocator, pIndirectCommandsLayout ); - } - - void vkDestroyIndirectCommandsLayoutNV( VkDevice device, - VkIndirectCommandsLayoutNV indirectCommandsLayout, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyIndirectCommandsLayoutNV( device, indirectCommandsLayout, pAllocator ); - } - - //=== VK_EXT_depth_bias_control === - - void vkCmdSetDepthBias2EXT( VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT * pDepthBiasInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthBias2EXT( commandBuffer, pDepthBiasInfo ); - } - - //=== VK_EXT_acquire_drm_display === - - VkResult vkAcquireDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAcquireDrmDisplayEXT( physicalDevice, drmFd, display ); - } - - VkResult vkGetDrmDisplayEXT( VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR * display ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDrmDisplayEXT( physicalDevice, drmFd, connectorId, display ); - } - - //=== VK_EXT_private_data === - - VkResult vkCreatePrivateDataSlotEXT( VkDevice device, - const VkPrivateDataSlotCreateInfo * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkPrivateDataSlot * pPrivateDataSlot ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreatePrivateDataSlotEXT( device, pCreateInfo, pAllocator, pPrivateDataSlot ); - } - - void vkDestroyPrivateDataSlotEXT( VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyPrivateDataSlotEXT( device, privateDataSlot, pAllocator ); - } - - VkResult vkSetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkSetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, data ); - } - - void vkGetPrivateDataEXT( VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t * pData ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkGetPrivateDataEXT( device, objectType, objectHandle, privateDataSlot, pData ); - } - - //=== VK_KHR_video_encode_queue === - - VkResult - vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, - VkVideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( physicalDevice, pQualityLevelInfo, pQualityLevelProperties ); - } - - VkResult vkGetEncodedVideoSessionParametersKHR( VkDevice device, - const VkVideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, - VkVideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, - size_t * pDataSize, - void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetEncodedVideoSessionParametersKHR( device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData ); - } - - void vkCmdEncodeVideoKHR( VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR * pEncodeInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEncodeVideoKHR( commandBuffer, pEncodeInfo ); - } - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - - VkResult vkCreateCudaModuleNV( VkDevice device, - const VkCudaModuleCreateInfoNV * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkCudaModuleNV * pModule ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateCudaModuleNV( device, pCreateInfo, pAllocator, pModule ); - } - - VkResult vkGetCudaModuleCacheNV( VkDevice device, VkCudaModuleNV module, size_t * pCacheSize, void * pCacheData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetCudaModuleCacheNV( device, module, pCacheSize, pCacheData ); - } - - VkResult vkCreateCudaFunctionNV( VkDevice device, - const VkCudaFunctionCreateInfoNV * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkCudaFunctionNV * pFunction ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateCudaFunctionNV( device, pCreateInfo, pAllocator, pFunction ); - } - - void vkDestroyCudaModuleNV( VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyCudaModuleNV( device, module, pAllocator ); - } - - void vkDestroyCudaFunctionNV( VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyCudaFunctionNV( device, function, pAllocator ); - } - - void vkCmdCudaLaunchKernelNV( VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV * pLaunchInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCudaLaunchKernelNV( commandBuffer, pLaunchInfo ); - } -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - - void vkCmdDispatchTileQCOM( VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM * pDispatchTileInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDispatchTileQCOM( commandBuffer, pDispatchTileInfo ); - } - - void vkCmdBeginPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM * pPerTileBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginPerTileExecutionQCOM( commandBuffer, pPerTileBeginInfo ); - } - - void vkCmdEndPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM * pPerTileEndInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndPerTileExecutionQCOM( commandBuffer, pPerTileEndInfo ); - } - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - - void vkExportMetalObjectsEXT( VkDevice device, VkExportMetalObjectsInfoEXT * pMetalObjectsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkExportMetalObjectsEXT( device, pMetalObjectsInfo ); - } -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_synchronization2 === - - void vkCmdSetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetEvent2KHR( commandBuffer, event, pDependencyInfo ); - } - - void vkCmdResetEvent2KHR( VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdResetEvent2KHR( commandBuffer, event, stageMask ); - } - - void vkCmdWaitEvents2KHR( VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent * pEvents, - const VkDependencyInfo * pDependencyInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdWaitEvents2KHR( commandBuffer, eventCount, pEvents, pDependencyInfos ); - } - - void vkCmdPipelineBarrier2KHR( VkCommandBuffer commandBuffer, const VkDependencyInfo * pDependencyInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPipelineBarrier2KHR( commandBuffer, pDependencyInfo ); - } - - void - vkCmdWriteTimestamp2KHR( VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdWriteTimestamp2KHR( commandBuffer, stage, queryPool, query ); - } - - VkResult vkQueueSubmit2KHR( VkQueue queue, uint32_t submitCount, const VkSubmitInfo2 * pSubmits, VkFence fence ) const VULKAN_HPP_NOEXCEPT - { - return ::vkQueueSubmit2KHR( queue, submitCount, pSubmits, fence ); - } - - //=== VK_EXT_descriptor_buffer === - - void vkGetDescriptorSetLayoutSizeEXT( VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize * pLayoutSizeInBytes ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDescriptorSetLayoutSizeEXT( device, layout, pLayoutSizeInBytes ); - } - - void vkGetDescriptorSetLayoutBindingOffsetEXT( VkDevice device, - VkDescriptorSetLayout layout, - uint32_t binding, - VkDeviceSize * pOffset ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDescriptorSetLayoutBindingOffsetEXT( device, layout, binding, pOffset ); - } - - void vkGetDescriptorEXT( VkDevice device, const VkDescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDescriptorEXT( device, pDescriptorInfo, dataSize, pDescriptor ); - } - - void vkCmdBindDescriptorBuffersEXT( VkCommandBuffer commandBuffer, - uint32_t bufferCount, - const VkDescriptorBufferBindingInfoEXT * pBindingInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindDescriptorBuffersEXT( commandBuffer, bufferCount, pBindingInfos ); - } - - void vkCmdSetDescriptorBufferOffsetsEXT( VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t setCount, - const uint32_t * pBufferIndices, - const VkDeviceSize * pOffsets ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDescriptorBufferOffsetsEXT( commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets ); - } - - void vkCmdBindDescriptorBufferEmbeddedSamplersEXT( VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindDescriptorBufferEmbeddedSamplersEXT( commandBuffer, pipelineBindPoint, layout, set ); - } - - VkResult - vkGetBufferOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetBufferOpaqueCaptureDescriptorDataEXT( device, pInfo, pData ); - } - - VkResult - vkGetImageOpaqueCaptureDescriptorDataEXT( VkDevice device, const VkImageCaptureDescriptorDataInfoEXT * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageOpaqueCaptureDescriptorDataEXT( device, pInfo, pData ); - } - - VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT( VkDevice device, - const VkImageViewCaptureDescriptorDataInfoEXT * pInfo, - void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageViewOpaqueCaptureDescriptorDataEXT( device, pInfo, pData ); - } - - VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT( VkDevice device, - const VkSamplerCaptureDescriptorDataInfoEXT * pInfo, - void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetSamplerOpaqueCaptureDescriptorDataEXT( device, pInfo, pData ); - } - - VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( VkDevice device, - const VkAccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, - void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( device, pInfo, pData ); - } - - //=== VK_NV_fragment_shading_rate_enums === - - void vkCmdSetFragmentShadingRateEnumNV( VkCommandBuffer commandBuffer, - VkFragmentShadingRateNV shadingRate, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetFragmentShadingRateEnumNV( commandBuffer, shadingRate, combinerOps ); - } - - //=== VK_EXT_mesh_shader === - - void vkCmdDrawMeshTasksEXT( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawMeshTasksEXT( commandBuffer, groupCountX, groupCountY, groupCountZ ); - } - - void vkCmdDrawMeshTasksIndirectEXT( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawMeshTasksIndirectEXT( commandBuffer, buffer, offset, drawCount, stride ); - } - - void vkCmdDrawMeshTasksIndirectCountEXT( VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawMeshTasksIndirectCountEXT( commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride ); - } - - //=== VK_KHR_copy_commands2 === - - void vkCmdCopyBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferInfo2 * pCopyBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyBuffer2KHR( commandBuffer, pCopyBufferInfo ); - } - - void vkCmdCopyImage2KHR( VkCommandBuffer commandBuffer, const VkCopyImageInfo2 * pCopyImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyImage2KHR( commandBuffer, pCopyImageInfo ); - } - - void vkCmdCopyBufferToImage2KHR( VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2 * pCopyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyBufferToImage2KHR( commandBuffer, pCopyBufferToImageInfo ); - } - - void vkCmdCopyImageToBuffer2KHR( VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2 * pCopyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyImageToBuffer2KHR( commandBuffer, pCopyImageToBufferInfo ); - } - - void vkCmdBlitImage2KHR( VkCommandBuffer commandBuffer, const VkBlitImageInfo2 * pBlitImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBlitImage2KHR( commandBuffer, pBlitImageInfo ); - } - - void vkCmdResolveImage2KHR( VkCommandBuffer commandBuffer, const VkResolveImageInfo2 * pResolveImageInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdResolveImage2KHR( commandBuffer, pResolveImageInfo ); - } - - //=== VK_EXT_device_fault === - - VkResult vkGetDeviceFaultInfoEXT( VkDevice device, VkDeviceFaultCountsEXT * pFaultCounts, VkDeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceFaultInfoEXT( device, pFaultCounts, pFaultInfo ); - } - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - - VkResult vkAcquireWinrtDisplayNV( VkPhysicalDevice physicalDevice, VkDisplayKHR display ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAcquireWinrtDisplayNV( physicalDevice, display ); - } - - VkResult vkGetWinrtDisplayNV( VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR * pDisplay ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetWinrtDisplayNV( physicalDevice, deviceRelativeId, pDisplay ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - - VkResult vkCreateDirectFBSurfaceEXT( VkInstance instance, - const VkDirectFBSurfaceCreateInfoEXT * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDirectFBSurfaceEXT( instance, pCreateInfo, pAllocator, pSurface ); - } - - VkBool32 vkGetPhysicalDeviceDirectFBPresentationSupportEXT( VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - IDirectFB * dfb ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceDirectFBPresentationSupportEXT( physicalDevice, queueFamilyIndex, dfb ); - } -# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_vertex_input_dynamic_state === - - void vkCmdSetVertexInputEXT( VkCommandBuffer commandBuffer, - uint32_t vertexBindingDescriptionCount, - const VkVertexInputBindingDescription2EXT * pVertexBindingDescriptions, - uint32_t vertexAttributeDescriptionCount, - const VkVertexInputAttributeDescription2EXT * pVertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetVertexInputEXT( - commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions ); - } - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - - VkResult vkGetMemoryZirconHandleFUCHSIA( VkDevice device, - const VkMemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, - zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle ); - } - - VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA( VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - zx_handle_t zirconHandle, - VkMemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryZirconHandlePropertiesFUCHSIA( device, handleType, zirconHandle, pMemoryZirconHandleProperties ); - } -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - - VkResult - vkImportSemaphoreZirconHandleFUCHSIA( VkDevice device, - const VkImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkImportSemaphoreZirconHandleFUCHSIA( device, pImportSemaphoreZirconHandleInfo ); - } - - VkResult vkGetSemaphoreZirconHandleFUCHSIA( VkDevice device, - const VkSemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, - zx_handle_t * pZirconHandle ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetSemaphoreZirconHandleFUCHSIA( device, pGetZirconHandleInfo, pZirconHandle ); - } -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - - VkResult vkCreateBufferCollectionFUCHSIA( VkDevice device, - const VkBufferCollectionCreateInfoFUCHSIA * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkBufferCollectionFUCHSIA * pCollection ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateBufferCollectionFUCHSIA( device, pCreateInfo, pAllocator, pCollection ); - } - - VkResult vkSetBufferCollectionImageConstraintsFUCHSIA( VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkImageConstraintsInfoFUCHSIA * pImageConstraintsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSetBufferCollectionImageConstraintsFUCHSIA( device, collection, pImageConstraintsInfo ); - } - - VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA( VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkBufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSetBufferCollectionBufferConstraintsFUCHSIA( device, collection, pBufferConstraintsInfo ); - } - - void vkDestroyBufferCollectionFUCHSIA( VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyBufferCollectionFUCHSIA( device, collection, pAllocator ); - } - - VkResult vkGetBufferCollectionPropertiesFUCHSIA( VkDevice device, - VkBufferCollectionFUCHSIA collection, - VkBufferCollectionPropertiesFUCHSIA * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetBufferCollectionPropertiesFUCHSIA( device, collection, pProperties ); - } -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - - VkResult - vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( VkDevice device, VkRenderPass renderpass, VkExtent2D * pMaxWorkgroupSize ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( device, renderpass, pMaxWorkgroupSize ); - } - - void vkCmdSubpassShadingHUAWEI( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSubpassShadingHUAWEI( commandBuffer ); - } - - //=== VK_HUAWEI_invocation_mask === - - void vkCmdBindInvocationMaskHUAWEI( VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindInvocationMaskHUAWEI( commandBuffer, imageView, imageLayout ); - } - - //=== VK_NV_external_memory_rdma === - - VkResult vkGetMemoryRemoteAddressNV( VkDevice device, - const VkMemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, - VkRemoteAddressNV * pAddress ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryRemoteAddressNV( device, pMemoryGetRemoteAddressInfo, pAddress ); - } - - //=== VK_EXT_pipeline_properties === - - VkResult vkGetPipelinePropertiesEXT( VkDevice device, - const VkPipelineInfoEXT * pPipelineInfo, - VkBaseOutStructure * pPipelineProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPipelinePropertiesEXT( device, pPipelineInfo, pPipelineProperties ); - } - - //=== VK_EXT_extended_dynamic_state2 === - - void vkCmdSetPatchControlPointsEXT( VkCommandBuffer commandBuffer, uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetPatchControlPointsEXT( commandBuffer, patchControlPoints ); - } - - void vkCmdSetRasterizerDiscardEnableEXT( VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetRasterizerDiscardEnableEXT( commandBuffer, rasterizerDiscardEnable ); - } - - void vkCmdSetDepthBiasEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthBiasEnableEXT( commandBuffer, depthBiasEnable ); - } - - void vkCmdSetLogicOpEXT( VkCommandBuffer commandBuffer, VkLogicOp logicOp ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetLogicOpEXT( commandBuffer, logicOp ); - } - - void vkCmdSetPrimitiveRestartEnableEXT( VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetPrimitiveRestartEnableEXT( commandBuffer, primitiveRestartEnable ); - } - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - - VkResult vkCreateScreenSurfaceQNX( VkInstance instance, - const VkScreenSurfaceCreateInfoQNX * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateScreenSurfaceQNX( instance, pCreateInfo, pAllocator, pSurface ); - } - - VkBool32 vkGetPhysicalDeviceScreenPresentationSupportQNX( VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct _screen_window * window ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceScreenPresentationSupportQNX( physicalDevice, queueFamilyIndex, window ); - } -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_EXT_color_write_enable === - - void vkCmdSetColorWriteEnableEXT( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32 * pColorWriteEnables ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetColorWriteEnableEXT( commandBuffer, attachmentCount, pColorWriteEnables ); - } - - //=== VK_KHR_ray_tracing_maintenance1 === - - void vkCmdTraceRaysIndirect2KHR( VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdTraceRaysIndirect2KHR( commandBuffer, indirectDeviceAddress ); - } - - //=== VK_EXT_multi_draw === - - void vkCmdDrawMultiEXT( VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawInfoEXT * pVertexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawMultiEXT( commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride ); - } - - void vkCmdDrawMultiIndexedEXT( VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawIndexedInfoEXT * pIndexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride, - const int32_t * pVertexOffset ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawMultiIndexedEXT( commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset ); - } - - //=== VK_EXT_opacity_micromap === - - VkResult vkCreateMicromapEXT( VkDevice device, - const VkMicromapCreateInfoEXT * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkMicromapEXT * pMicromap ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateMicromapEXT( device, pCreateInfo, pAllocator, pMicromap ); - } - - void vkDestroyMicromapEXT( VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyMicromapEXT( device, micromap, pAllocator ); - } - - void vkCmdBuildMicromapsEXT( VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBuildMicromapsEXT( commandBuffer, infoCount, pInfos ); - } - - VkResult vkBuildMicromapsEXT( VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkMicromapBuildInfoEXT * pInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBuildMicromapsEXT( device, deferredOperation, infoCount, pInfos ); - } - - VkResult vkCopyMicromapEXT( VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyMicromapEXT( device, deferredOperation, pInfo ); - } - - VkResult vkCopyMicromapToMemoryEXT( VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyMicromapToMemoryEXT( device, deferredOperation, pInfo ); - } - - VkResult vkCopyMemoryToMicromapEXT( VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCopyMemoryToMicromapEXT( device, deferredOperation, pInfo ); - } - - VkResult vkWriteMicromapsPropertiesEXT( VkDevice device, - uint32_t micromapCount, - const VkMicromapEXT * pMicromaps, - VkQueryType queryType, - size_t dataSize, - void * pData, - size_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkWriteMicromapsPropertiesEXT( device, micromapCount, pMicromaps, queryType, dataSize, pData, stride ); - } - - void vkCmdCopyMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyMicromapEXT( commandBuffer, pInfo ); - } - - void vkCmdCopyMicromapToMemoryEXT( VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyMicromapToMemoryEXT( commandBuffer, pInfo ); - } - - void vkCmdCopyMemoryToMicromapEXT( VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyMemoryToMicromapEXT( commandBuffer, pInfo ); - } - - void vkCmdWriteMicromapsPropertiesEXT( VkCommandBuffer commandBuffer, - uint32_t micromapCount, - const VkMicromapEXT * pMicromaps, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdWriteMicromapsPropertiesEXT( commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery ); - } - - void vkGetDeviceMicromapCompatibilityEXT( VkDevice device, - const VkMicromapVersionInfoEXT * pVersionInfo, - VkAccelerationStructureCompatibilityKHR * pCompatibility ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceMicromapCompatibilityEXT( device, pVersionInfo, pCompatibility ); - } - - void vkGetMicromapBuildSizesEXT( VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkMicromapBuildInfoEXT * pBuildInfo, - VkMicromapBuildSizesInfoEXT * pSizeInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMicromapBuildSizesEXT( device, buildType, pBuildInfo, pSizeInfo ); - } - - //=== VK_HUAWEI_cluster_culling_shader === - - void vkCmdDrawClusterHUAWEI( VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawClusterHUAWEI( commandBuffer, groupCountX, groupCountY, groupCountZ ); - } - - void vkCmdDrawClusterIndirectHUAWEI( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDrawClusterIndirectHUAWEI( commandBuffer, buffer, offset ); - } - - //=== VK_EXT_pageable_device_local_memory === - - void vkSetDeviceMemoryPriorityEXT( VkDevice device, VkDeviceMemory memory, float priority ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSetDeviceMemoryPriorityEXT( device, memory, priority ); - } - - //=== VK_KHR_maintenance4 === - - void vkGetDeviceBufferMemoryRequirementsKHR( VkDevice device, - const VkDeviceBufferMemoryRequirements * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceBufferMemoryRequirementsKHR( device, pInfo, pMemoryRequirements ); - } - - void vkGetDeviceImageMemoryRequirementsKHR( VkDevice device, - const VkDeviceImageMemoryRequirements * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceImageMemoryRequirementsKHR( device, pInfo, pMemoryRequirements ); - } - - void vkGetDeviceImageSparseMemoryRequirementsKHR( VkDevice device, - const VkDeviceImageMemoryRequirements * pInfo, - uint32_t * pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2 * pSparseMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceImageSparseMemoryRequirementsKHR( device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements ); - } - - //=== VK_VALVE_descriptor_set_host_mapping === - - void vkGetDescriptorSetLayoutHostMappingInfoVALVE( VkDevice device, - const VkDescriptorSetBindingReferenceVALVE * pBindingReference, - VkDescriptorSetLayoutHostMappingInfoVALVE * pHostMapping ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDescriptorSetLayoutHostMappingInfoVALVE( device, pBindingReference, pHostMapping ); - } - - void vkGetDescriptorSetHostMappingVALVE( VkDevice device, VkDescriptorSet descriptorSet, void ** ppData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDescriptorSetHostMappingVALVE( device, descriptorSet, ppData ); - } - - //=== VK_NV_copy_memory_indirect === - - void vkCmdCopyMemoryIndirectNV( VkCommandBuffer commandBuffer, - VkDeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyMemoryIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride ); - } - - void vkCmdCopyMemoryToImageIndirectNV( VkCommandBuffer commandBuffer, - VkDeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride, - VkImage dstImage, - VkImageLayout dstImageLayout, - const VkImageSubresourceLayers * pImageSubresources ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyMemoryToImageIndirectNV( commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources ); - } - - //=== VK_NV_memory_decompression === - - void vkCmdDecompressMemoryNV( VkCommandBuffer commandBuffer, - uint32_t decompressRegionCount, - const VkDecompressMemoryRegionNV * pDecompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDecompressMemoryNV( commandBuffer, decompressRegionCount, pDecompressMemoryRegions ); - } - - void vkCmdDecompressMemoryIndirectCountNV( VkCommandBuffer commandBuffer, - VkDeviceAddress indirectCommandsAddress, - VkDeviceAddress indirectCommandsCountAddress, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDecompressMemoryIndirectCountNV( commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride ); - } - - //=== VK_NV_device_generated_commands_compute === - - void vkGetPipelineIndirectMemoryRequirementsNV( VkDevice device, - const VkComputePipelineCreateInfo * pCreateInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPipelineIndirectMemoryRequirementsNV( device, pCreateInfo, pMemoryRequirements ); - } - - void vkCmdUpdatePipelineIndirectBufferNV( VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdUpdatePipelineIndirectBufferNV( commandBuffer, pipelineBindPoint, pipeline ); - } - - VkDeviceAddress vkGetPipelineIndirectDeviceAddressNV( VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPipelineIndirectDeviceAddressNV( device, pInfo ); - } - -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - - VkResult vkGetNativeBufferPropertiesOHOS( VkDevice device, - const struct OH_NativeBuffer * buffer, - VkNativeBufferPropertiesOHOS * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetNativeBufferPropertiesOHOS( device, buffer, pProperties ); - } - - VkResult vkGetMemoryNativeBufferOHOS( VkDevice device, - const VkMemoryGetNativeBufferInfoOHOS * pInfo, - struct OH_NativeBuffer ** pBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryNativeBufferOHOS( device, pInfo, pBuffer ); - } -# endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_extended_dynamic_state3 === - - void vkCmdSetDepthClampEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthClampEnableEXT( commandBuffer, depthClampEnable ); - } - - void vkCmdSetPolygonModeEXT( VkCommandBuffer commandBuffer, VkPolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetPolygonModeEXT( commandBuffer, polygonMode ); - } - - void vkCmdSetRasterizationSamplesEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetRasterizationSamplesEXT( commandBuffer, rasterizationSamples ); - } - - void vkCmdSetSampleMaskEXT( VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask * pSampleMask ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetSampleMaskEXT( commandBuffer, samples, pSampleMask ); - } - - void vkCmdSetAlphaToCoverageEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetAlphaToCoverageEnableEXT( commandBuffer, alphaToCoverageEnable ); - } - - void vkCmdSetAlphaToOneEnableEXT( VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetAlphaToOneEnableEXT( commandBuffer, alphaToOneEnable ); - } - - void vkCmdSetLogicOpEnableEXT( VkCommandBuffer commandBuffer, VkBool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetLogicOpEnableEXT( commandBuffer, logicOpEnable ); - } - - void vkCmdSetColorBlendEnableEXT( VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkBool32 * pColorBlendEnables ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetColorBlendEnableEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables ); - } - - void vkCmdSetColorBlendEquationEXT( VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorBlendEquationEXT * pColorBlendEquations ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetColorBlendEquationEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations ); - } - - void vkCmdSetColorWriteMaskEXT( VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorComponentFlags * pColorWriteMasks ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetColorWriteMaskEXT( commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks ); - } - - void vkCmdSetTessellationDomainOriginEXT( VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetTessellationDomainOriginEXT( commandBuffer, domainOrigin ); - } - - void vkCmdSetRasterizationStreamEXT( VkCommandBuffer commandBuffer, uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetRasterizationStreamEXT( commandBuffer, rasterizationStream ); - } - - void vkCmdSetConservativeRasterizationModeEXT( VkCommandBuffer commandBuffer, - VkConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetConservativeRasterizationModeEXT( commandBuffer, conservativeRasterizationMode ); - } - - void vkCmdSetExtraPrimitiveOverestimationSizeEXT( VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetExtraPrimitiveOverestimationSizeEXT( commandBuffer, extraPrimitiveOverestimationSize ); - } - - void vkCmdSetDepthClipEnableEXT( VkCommandBuffer commandBuffer, VkBool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthClipEnableEXT( commandBuffer, depthClipEnable ); - } - - void vkCmdSetSampleLocationsEnableEXT( VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetSampleLocationsEnableEXT( commandBuffer, sampleLocationsEnable ); - } - - void vkCmdSetColorBlendAdvancedEXT( VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorBlendAdvancedEXT * pColorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetColorBlendAdvancedEXT( commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced ); - } - - void vkCmdSetProvokingVertexModeEXT( VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetProvokingVertexModeEXT( commandBuffer, provokingVertexMode ); - } - - void vkCmdSetLineRasterizationModeEXT( VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetLineRasterizationModeEXT( commandBuffer, lineRasterizationMode ); - } - - void vkCmdSetLineStippleEnableEXT( VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetLineStippleEnableEXT( commandBuffer, stippledLineEnable ); - } - - void vkCmdSetDepthClipNegativeOneToOneEXT( VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthClipNegativeOneToOneEXT( commandBuffer, negativeOneToOne ); - } - - void vkCmdSetViewportWScalingEnableNV( VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetViewportWScalingEnableNV( commandBuffer, viewportWScalingEnable ); - } - - void vkCmdSetViewportSwizzleNV( VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportSwizzleNV * pViewportSwizzles ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetViewportSwizzleNV( commandBuffer, firstViewport, viewportCount, pViewportSwizzles ); - } - - void vkCmdSetCoverageToColorEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetCoverageToColorEnableNV( commandBuffer, coverageToColorEnable ); - } - - void vkCmdSetCoverageToColorLocationNV( VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetCoverageToColorLocationNV( commandBuffer, coverageToColorLocation ); - } - - void vkCmdSetCoverageModulationModeNV( VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetCoverageModulationModeNV( commandBuffer, coverageModulationMode ); - } - - void vkCmdSetCoverageModulationTableEnableNV( VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetCoverageModulationTableEnableNV( commandBuffer, coverageModulationTableEnable ); - } - - void vkCmdSetCoverageModulationTableNV( VkCommandBuffer commandBuffer, - uint32_t coverageModulationTableCount, - const float * pCoverageModulationTable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetCoverageModulationTableNV( commandBuffer, coverageModulationTableCount, pCoverageModulationTable ); - } - - void vkCmdSetShadingRateImageEnableNV( VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetShadingRateImageEnableNV( commandBuffer, shadingRateImageEnable ); - } - - void vkCmdSetRepresentativeFragmentTestEnableNV( VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetRepresentativeFragmentTestEnableNV( commandBuffer, representativeFragmentTestEnable ); - } - - void vkCmdSetCoverageReductionModeNV( VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetCoverageReductionModeNV( commandBuffer, coverageReductionMode ); - } - - //=== VK_ARM_tensors === - - VkResult vkCreateTensorARM( VkDevice device, - const VkTensorCreateInfoARM * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkTensorARM * pTensor ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateTensorARM( device, pCreateInfo, pAllocator, pTensor ); - } - - void vkDestroyTensorARM( VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyTensorARM( device, tensor, pAllocator ); - } - - VkResult vkCreateTensorViewARM( VkDevice device, - const VkTensorViewCreateInfoARM * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkTensorViewARM * pView ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateTensorViewARM( device, pCreateInfo, pAllocator, pView ); - } - - void vkDestroyTensorViewARM( VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyTensorViewARM( device, tensorView, pAllocator ); - } - - void vkGetTensorMemoryRequirementsARM( VkDevice device, - const VkTensorMemoryRequirementsInfoARM * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetTensorMemoryRequirementsARM( device, pInfo, pMemoryRequirements ); - } - - VkResult vkBindTensorMemoryARM( VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM * pBindInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBindTensorMemoryARM( device, bindInfoCount, pBindInfos ); - } - - void vkGetDeviceTensorMemoryRequirementsARM( VkDevice device, - const VkDeviceTensorMemoryRequirementsARM * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceTensorMemoryRequirementsARM( device, pInfo, pMemoryRequirements ); - } - - void vkCmdCopyTensorARM( VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM * pCopyTensorInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyTensorARM( commandBuffer, pCopyTensorInfo ); - } - - void vkGetPhysicalDeviceExternalTensorPropertiesARM( VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo, - VkExternalTensorPropertiesARM * pExternalTensorProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceExternalTensorPropertiesARM( physicalDevice, pExternalTensorInfo, pExternalTensorProperties ); - } - - VkResult - vkGetTensorOpaqueCaptureDescriptorDataARM( VkDevice device, const VkTensorCaptureDescriptorDataInfoARM * pInfo, void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetTensorOpaqueCaptureDescriptorDataARM( device, pInfo, pData ); - } - - VkResult vkGetTensorViewOpaqueCaptureDescriptorDataARM( VkDevice device, - const VkTensorViewCaptureDescriptorDataInfoARM * pInfo, - void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetTensorViewOpaqueCaptureDescriptorDataARM( device, pInfo, pData ); - } - - //=== VK_EXT_shader_module_identifier === - - void vkGetShaderModuleIdentifierEXT( VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetShaderModuleIdentifierEXT( device, shaderModule, pIdentifier ); - } - - void vkGetShaderModuleCreateInfoIdentifierEXT( VkDevice device, - const VkShaderModuleCreateInfo * pCreateInfo, - VkShaderModuleIdentifierEXT * pIdentifier ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetShaderModuleCreateInfoIdentifierEXT( device, pCreateInfo, pIdentifier ); - } - - //=== VK_NV_optical_flow === - - VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV( VkPhysicalDevice physicalDevice, - const VkOpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo, - uint32_t * pFormatCount, - VkOpticalFlowImageFormatPropertiesNV * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceOpticalFlowImageFormatsNV( physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties ); - } - - VkResult vkCreateOpticalFlowSessionNV( VkDevice device, - const VkOpticalFlowSessionCreateInfoNV * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkOpticalFlowSessionNV * pSession ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateOpticalFlowSessionNV( device, pCreateInfo, pAllocator, pSession ); - } - - void vkDestroyOpticalFlowSessionNV( VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyOpticalFlowSessionNV( device, session, pAllocator ); - } - - VkResult vkBindOpticalFlowSessionImageNV( VkDevice device, - VkOpticalFlowSessionNV session, - VkOpticalFlowSessionBindingPointNV bindingPoint, - VkImageView view, - VkImageLayout layout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBindOpticalFlowSessionImageNV( device, session, bindingPoint, view, layout ); - } - - void vkCmdOpticalFlowExecuteNV( VkCommandBuffer commandBuffer, - VkOpticalFlowSessionNV session, - const VkOpticalFlowExecuteInfoNV * pExecuteInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdOpticalFlowExecuteNV( commandBuffer, session, pExecuteInfo ); - } - - //=== VK_KHR_maintenance5 === - - void vkCmdBindIndexBuffer2KHR( VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindIndexBuffer2KHR( commandBuffer, buffer, offset, size, indexType ); - } - - void - vkGetRenderingAreaGranularityKHR( VkDevice device, const VkRenderingAreaInfo * pRenderingAreaInfo, VkExtent2D * pGranularity ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetRenderingAreaGranularityKHR( device, pRenderingAreaInfo, pGranularity ); - } - - void vkGetDeviceImageSubresourceLayoutKHR( VkDevice device, - const VkDeviceImageSubresourceInfo * pInfo, - VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDeviceImageSubresourceLayoutKHR( device, pInfo, pLayout ); - } - - void vkGetImageSubresourceLayout2KHR( VkDevice device, - VkImage image, - const VkImageSubresource2 * pSubresource, - VkSubresourceLayout2 * pLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetImageSubresourceLayout2KHR( device, image, pSubresource, pLayout ); - } - - //=== VK_AMD_anti_lag === - - void vkAntiLagUpdateAMD( VkDevice device, const VkAntiLagDataAMD * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkAntiLagUpdateAMD( device, pData ); - } - - //=== VK_KHR_present_wait2 === - - VkResult vkWaitForPresent2KHR( VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR * pPresentWait2Info ) const VULKAN_HPP_NOEXCEPT - { - return ::vkWaitForPresent2KHR( device, swapchain, pPresentWait2Info ); - } - - //=== VK_EXT_shader_object === - - VkResult vkCreateShadersEXT( VkDevice device, - uint32_t createInfoCount, - const VkShaderCreateInfoEXT * pCreateInfos, - const VkAllocationCallbacks * pAllocator, - VkShaderEXT * pShaders ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateShadersEXT( device, createInfoCount, pCreateInfos, pAllocator, pShaders ); - } - - void vkDestroyShaderEXT( VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyShaderEXT( device, shader, pAllocator ); - } - - VkResult vkGetShaderBinaryDataEXT( VkDevice device, VkShaderEXT shader, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetShaderBinaryDataEXT( device, shader, pDataSize, pData ); - } - - void vkCmdBindShadersEXT( VkCommandBuffer commandBuffer, - uint32_t stageCount, - const VkShaderStageFlagBits * pStages, - const VkShaderEXT * pShaders ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindShadersEXT( commandBuffer, stageCount, pStages, pShaders ); - } - - void vkCmdSetDepthClampRangeEXT( VkCommandBuffer commandBuffer, - VkDepthClampModeEXT depthClampMode, - const VkDepthClampRangeEXT * pDepthClampRange ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDepthClampRangeEXT( commandBuffer, depthClampMode, pDepthClampRange ); - } - - //=== VK_KHR_pipeline_binary === - - VkResult vkCreatePipelineBinariesKHR( VkDevice device, - const VkPipelineBinaryCreateInfoKHR * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkPipelineBinaryHandlesInfoKHR * pBinaries ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreatePipelineBinariesKHR( device, pCreateInfo, pAllocator, pBinaries ); - } - - void vkDestroyPipelineBinaryKHR( VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyPipelineBinaryKHR( device, pipelineBinary, pAllocator ); - } - - VkResult vkGetPipelineKeyKHR( VkDevice device, - const VkPipelineCreateInfoKHR * pPipelineCreateInfo, - VkPipelineBinaryKeyKHR * pPipelineKey ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPipelineKeyKHR( device, pPipelineCreateInfo, pPipelineKey ); - } - - VkResult vkGetPipelineBinaryDataKHR( VkDevice device, - const VkPipelineBinaryDataInfoKHR * pInfo, - VkPipelineBinaryKeyKHR * pPipelineBinaryKey, - size_t * pPipelineBinaryDataSize, - void * pPipelineBinaryData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPipelineBinaryDataKHR( device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData ); - } - - VkResult vkReleaseCapturedPipelineDataKHR( VkDevice device, - const VkReleaseCapturedPipelineDataInfoKHR * pInfo, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkReleaseCapturedPipelineDataKHR( device, pInfo, pAllocator ); - } - - //=== VK_QCOM_tile_properties === - - VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice device, - VkFramebuffer framebuffer, - uint32_t * pPropertiesCount, - VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetFramebufferTilePropertiesQCOM( device, framebuffer, pPropertiesCount, pProperties ); - } - - VkResult vkGetDynamicRenderingTilePropertiesQCOM( VkDevice device, - const VkRenderingInfo * pRenderingInfo, - VkTilePropertiesQCOM * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDynamicRenderingTilePropertiesQCOM( device, pRenderingInfo, pProperties ); - } - - //=== VK_KHR_swapchain_maintenance1 === - - VkResult vkReleaseSwapchainImagesKHR( VkDevice device, const VkReleaseSwapchainImagesInfoKHR * pReleaseInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkReleaseSwapchainImagesKHR( device, pReleaseInfo ); - } - - //=== VK_NV_cooperative_vector === - - VkResult vkGetPhysicalDeviceCooperativeVectorPropertiesNV( VkPhysicalDevice physicalDevice, - uint32_t * pPropertyCount, - VkCooperativeVectorPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceCooperativeVectorPropertiesNV( physicalDevice, pPropertyCount, pProperties ); - } - - VkResult vkConvertCooperativeVectorMatrixNV( VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkConvertCooperativeVectorMatrixNV( device, pInfo ); - } - - void vkCmdConvertCooperativeVectorMatrixNV( VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkConvertCooperativeVectorMatrixInfoNV * pInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdConvertCooperativeVectorMatrixNV( commandBuffer, infoCount, pInfos ); - } - - //=== VK_NV_low_latency2 === - - VkResult vkSetLatencySleepModeNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV * pSleepModeInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSetLatencySleepModeNV( device, swapchain, pSleepModeInfo ); - } - - VkResult vkLatencySleepNV( VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV * pSleepInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkLatencySleepNV( device, swapchain, pSleepInfo ); - } - - void vkSetLatencyMarkerNV( VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkSetLatencyMarkerNV( device, swapchain, pLatencyMarkerInfo ); - } - - void vkGetLatencyTimingsNV( VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV * pLatencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetLatencyTimingsNV( device, swapchain, pLatencyMarkerInfo ); - } - - void vkQueueNotifyOutOfBandNV( VkQueue queue, const VkOutOfBandQueueTypeInfoNV * pQueueTypeInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkQueueNotifyOutOfBandNV( queue, pQueueTypeInfo ); - } - - //=== VK_KHR_cooperative_matrix === - - VkResult vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDevice physicalDevice, - uint32_t * pPropertyCount, - VkCooperativeMatrixPropertiesKHR * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( physicalDevice, pPropertyCount, pProperties ); - } - - //=== VK_ARM_data_graph === - - VkResult vkCreateDataGraphPipelinesARM( VkDevice device, - VkDeferredOperationKHR deferredOperation, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkDataGraphPipelineCreateInfoARM * pCreateInfos, - const VkAllocationCallbacks * pAllocator, - VkPipeline * pPipelines ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDataGraphPipelinesARM( device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines ); - } - - VkResult vkCreateDataGraphPipelineSessionARM( VkDevice device, - const VkDataGraphPipelineSessionCreateInfoARM * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkDataGraphPipelineSessionARM * pSession ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateDataGraphPipelineSessionARM( device, pCreateInfo, pAllocator, pSession ); - } - - VkResult vkGetDataGraphPipelineSessionBindPointRequirementsARM( VkDevice device, - const VkDataGraphPipelineSessionBindPointRequirementsInfoARM * pInfo, - uint32_t * pBindPointRequirementCount, - VkDataGraphPipelineSessionBindPointRequirementARM * pBindPointRequirements ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkGetDataGraphPipelineSessionBindPointRequirementsARM( device, pInfo, pBindPointRequirementCount, pBindPointRequirements ); - } - - void vkGetDataGraphPipelineSessionMemoryRequirementsARM( VkDevice device, - const VkDataGraphPipelineSessionMemoryRequirementsInfoARM * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDataGraphPipelineSessionMemoryRequirementsARM( device, pInfo, pMemoryRequirements ); - } - - VkResult vkBindDataGraphPipelineSessionMemoryARM( VkDevice device, - uint32_t bindInfoCount, - const VkBindDataGraphPipelineSessionMemoryInfoARM * pBindInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkBindDataGraphPipelineSessionMemoryARM( device, bindInfoCount, pBindInfos ); - } - - void vkDestroyDataGraphPipelineSessionARM( VkDevice device, - VkDataGraphPipelineSessionARM session, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyDataGraphPipelineSessionARM( device, session, pAllocator ); - } - - void vkCmdDispatchDataGraphARM( VkCommandBuffer commandBuffer, - VkDataGraphPipelineSessionARM session, - const VkDataGraphPipelineDispatchInfoARM * pInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDispatchDataGraphARM( commandBuffer, session, pInfo ); - } - - VkResult vkGetDataGraphPipelineAvailablePropertiesARM( VkDevice device, - const VkDataGraphPipelineInfoARM * pPipelineInfo, - uint32_t * pPropertiesCount, - VkDataGraphPipelinePropertyARM * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDataGraphPipelineAvailablePropertiesARM( device, pPipelineInfo, pPropertiesCount, pProperties ); - } - - VkResult vkGetDataGraphPipelinePropertiesARM( VkDevice device, - const VkDataGraphPipelineInfoARM * pPipelineInfo, - uint32_t propertiesCount, - VkDataGraphPipelinePropertyQueryResultARM * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetDataGraphPipelinePropertiesARM( device, pPipelineInfo, propertiesCount, pProperties ); - } - - VkResult - vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - uint32_t * pQueueFamilyDataGraphPropertyCount, - VkQueueFamilyDataGraphPropertiesARM * pQueueFamilyDataGraphProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( - physicalDevice, queueFamilyIndex, pQueueFamilyDataGraphPropertyCount, pQueueFamilyDataGraphProperties ); - } - - void vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM * pQueueFamilyDataGraphProcessingEngineInfo, - VkQueueFamilyDataGraphProcessingEnginePropertiesARM * pQueueFamilyDataGraphProcessingEngineProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( - physicalDevice, pQueueFamilyDataGraphProcessingEngineInfo, pQueueFamilyDataGraphProcessingEngineProperties ); - } - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - - void vkCmdSetAttachmentFeedbackLoopEnableEXT( VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetAttachmentFeedbackLoopEnableEXT( commandBuffer, aspectMask ); - } - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - - VkResult vkGetScreenBufferPropertiesQNX( VkDevice device, - const struct _screen_buffer * buffer, - VkScreenBufferPropertiesQNX * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetScreenBufferPropertiesQNX( device, buffer, pProperties ); - } -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_KHR_line_rasterization === - - void vkCmdSetLineStippleKHR( VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetLineStippleKHR( commandBuffer, lineStippleFactor, lineStipplePattern ); - } - - //=== VK_KHR_calibrated_timestamps === - - VkResult vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( VkPhysicalDevice physicalDevice, - uint32_t * pTimeDomainCount, - VkTimeDomainKHR * pTimeDomains ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( physicalDevice, pTimeDomainCount, pTimeDomains ); - } - - VkResult vkGetCalibratedTimestampsKHR( VkDevice device, - uint32_t timestampCount, - const VkCalibratedTimestampInfoKHR * pTimestampInfos, - uint64_t * pTimestamps, - uint64_t * pMaxDeviation ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetCalibratedTimestampsKHR( device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation ); - } - - //=== VK_KHR_maintenance6 === - - void vkCmdBindDescriptorSets2KHR( VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo * pBindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindDescriptorSets2KHR( commandBuffer, pBindDescriptorSetsInfo ); - } - - void vkCmdPushConstants2KHR( VkCommandBuffer commandBuffer, const VkPushConstantsInfo * pPushConstantsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushConstants2KHR( commandBuffer, pPushConstantsInfo ); - } - - void vkCmdPushDescriptorSet2KHR( VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo * pPushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushDescriptorSet2KHR( commandBuffer, pPushDescriptorSetInfo ); - } - - void vkCmdPushDescriptorSetWithTemplate2KHR( VkCommandBuffer commandBuffer, - const VkPushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPushDescriptorSetWithTemplate2KHR( commandBuffer, pPushDescriptorSetWithTemplateInfo ); - } - - void vkCmdSetDescriptorBufferOffsets2EXT( VkCommandBuffer commandBuffer, - const VkSetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetDescriptorBufferOffsets2EXT( commandBuffer, pSetDescriptorBufferOffsetsInfo ); - } - - void vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( - VkCommandBuffer commandBuffer, - const VkBindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo ); - } - - //=== VK_QCOM_tile_memory_heap === - - void vkCmdBindTileMemoryQCOM( VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM * pTileMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBindTileMemoryQCOM( commandBuffer, pTileMemoryBindInfo ); - } - - //=== VK_KHR_copy_memory_indirect === - - void vkCmdCopyMemoryIndirectKHR( VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyMemoryIndirectKHR( commandBuffer, pCopyMemoryIndirectInfo ); - } - - void vkCmdCopyMemoryToImageIndirectKHR( VkCommandBuffer commandBuffer, - const VkCopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdCopyMemoryToImageIndirectKHR( commandBuffer, pCopyMemoryToImageIndirectInfo ); - } - - //=== VK_EXT_memory_decompression === - - void vkCmdDecompressMemoryEXT( VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT * pDecompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDecompressMemoryEXT( commandBuffer, pDecompressMemoryInfoEXT ); - } - - void vkCmdDecompressMemoryIndirectCountEXT( VkCommandBuffer commandBuffer, - VkMemoryDecompressionMethodFlagsEXT decompressionMethod, - VkDeviceAddress indirectCommandsAddress, - VkDeviceAddress indirectCommandsCountAddress, - uint32_t maxDecompressionCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdDecompressMemoryIndirectCountEXT( - commandBuffer, decompressionMethod, indirectCommandsAddress, indirectCommandsCountAddress, maxDecompressionCount, stride ); - } - - //=== VK_NV_external_compute_queue === - - VkResult vkCreateExternalComputeQueueNV( VkDevice device, - const VkExternalComputeQueueCreateInfoNV * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkExternalComputeQueueNV * pExternalQueue ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateExternalComputeQueueNV( device, pCreateInfo, pAllocator, pExternalQueue ); - } - - void vkDestroyExternalComputeQueueNV( VkDevice device, - VkExternalComputeQueueNV externalQueue, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyExternalComputeQueueNV( device, externalQueue, pAllocator ); - } - - void vkGetExternalComputeQueueDataNV( VkExternalComputeQueueNV externalQueue, - VkExternalComputeQueueDataParamsNV * params, - void * pData ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetExternalComputeQueueDataNV( externalQueue, params, pData ); - } - - //=== VK_NV_cluster_acceleration_structure === - - void vkGetClusterAccelerationStructureBuildSizesNV( VkDevice device, - const VkClusterAccelerationStructureInputInfoNV * pInfo, - VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetClusterAccelerationStructureBuildSizesNV( device, pInfo, pSizeInfo ); - } - - void vkCmdBuildClusterAccelerationStructureIndirectNV( VkCommandBuffer commandBuffer, - const VkClusterAccelerationStructureCommandsInfoNV * pCommandInfos ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBuildClusterAccelerationStructureIndirectNV( commandBuffer, pCommandInfos ); - } - - //=== VK_NV_partitioned_acceleration_structure === - - void vkGetPartitionedAccelerationStructuresBuildSizesNV( VkDevice device, - const VkPartitionedAccelerationStructureInstancesInputNV * pInfo, - VkAccelerationStructureBuildSizesInfoKHR * pSizeInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPartitionedAccelerationStructuresBuildSizesNV( device, pInfo, pSizeInfo ); - } - - void vkCmdBuildPartitionedAccelerationStructuresNV( VkCommandBuffer commandBuffer, - const VkBuildPartitionedAccelerationStructureInfoNV * pBuildInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBuildPartitionedAccelerationStructuresNV( commandBuffer, pBuildInfo ); - } - - //=== VK_EXT_device_generated_commands === - - void vkGetGeneratedCommandsMemoryRequirementsEXT( VkDevice device, - const VkGeneratedCommandsMemoryRequirementsInfoEXT * pInfo, - VkMemoryRequirements2 * pMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetGeneratedCommandsMemoryRequirementsEXT( device, pInfo, pMemoryRequirements ); - } - - void vkCmdPreprocessGeneratedCommandsEXT( VkCommandBuffer commandBuffer, - const VkGeneratedCommandsInfoEXT * pGeneratedCommandsInfo, - VkCommandBuffer stateCommandBuffer ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdPreprocessGeneratedCommandsEXT( commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer ); - } - - void vkCmdExecuteGeneratedCommandsEXT( VkCommandBuffer commandBuffer, - VkBool32 isPreprocessed, - const VkGeneratedCommandsInfoEXT * pGeneratedCommandsInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdExecuteGeneratedCommandsEXT( commandBuffer, isPreprocessed, pGeneratedCommandsInfo ); - } - - VkResult vkCreateIndirectCommandsLayoutEXT( VkDevice device, - const VkIndirectCommandsLayoutCreateInfoEXT * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkIndirectCommandsLayoutEXT * pIndirectCommandsLayout ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateIndirectCommandsLayoutEXT( device, pCreateInfo, pAllocator, pIndirectCommandsLayout ); - } - - void vkDestroyIndirectCommandsLayoutEXT( VkDevice device, - VkIndirectCommandsLayoutEXT indirectCommandsLayout, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyIndirectCommandsLayoutEXT( device, indirectCommandsLayout, pAllocator ); - } - - VkResult vkCreateIndirectExecutionSetEXT( VkDevice device, - const VkIndirectExecutionSetCreateInfoEXT * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkIndirectExecutionSetEXT * pIndirectExecutionSet ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateIndirectExecutionSetEXT( device, pCreateInfo, pAllocator, pIndirectExecutionSet ); - } - - void vkDestroyIndirectExecutionSetEXT( VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT - { - return ::vkDestroyIndirectExecutionSetEXT( device, indirectExecutionSet, pAllocator ); - } - - void vkUpdateIndirectExecutionSetPipelineEXT( VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, - const VkWriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites ) const VULKAN_HPP_NOEXCEPT - { - return ::vkUpdateIndirectExecutionSetPipelineEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites ); - } - - void vkUpdateIndirectExecutionSetShaderEXT( VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, - const VkWriteIndirectExecutionSetShaderEXT * pExecutionSetWrites ) const VULKAN_HPP_NOEXCEPT - { - return ::vkUpdateIndirectExecutionSetShaderEXT( device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites ); - } - -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - - VkResult vkCreateSurfaceOHOS( VkInstance instance, - const VkSurfaceCreateInfoOHOS * pCreateInfo, - const VkAllocationCallbacks * pAllocator, - VkSurfaceKHR * pSurface ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCreateSurfaceOHOS( instance, pCreateInfo, pAllocator, pSurface ); - } -# endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_NV_cooperative_matrix2 === - - VkResult vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( - VkPhysicalDevice physicalDevice, uint32_t * pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( physicalDevice, pPropertyCount, pProperties ); - } - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - - VkResult - vkGetMemoryMetalHandleEXT( VkDevice device, const VkMemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo, void ** pHandle ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryMetalHandleEXT( device, pGetMetalHandleInfo, pHandle ); - } - - VkResult vkGetMemoryMetalHandlePropertiesEXT( VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - const void * pHandle, - VkMemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties ) const VULKAN_HPP_NOEXCEPT - { - return ::vkGetMemoryMetalHandlePropertiesEXT( device, handleType, pHandle, pMemoryMetalHandleProperties ); - } -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_ARM_performance_counters_by_region === - - VkResult vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - uint32_t * pCounterCount, - VkPerformanceCounterARM * pCounters, - VkPerformanceCounterDescriptionARM * pCounterDescriptions ) const - VULKAN_HPP_NOEXCEPT - { - return ::vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( - physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions ); - } - - //=== VK_EXT_fragment_density_map_offset === - - void vkCmdEndRendering2EXT( VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR * pRenderingEndInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndRendering2EXT( commandBuffer, pRenderingEndInfo ); - } - - //=== VK_EXT_custom_resolve === - - void vkCmdBeginCustomResolveEXT( VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT * pBeginCustomResolveInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdBeginCustomResolveEXT( commandBuffer, pBeginCustomResolveInfo ); - } - - //=== VK_KHR_maintenance10 === - - void vkCmdEndRendering2KHR( VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR * pRenderingEndInfo ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdEndRendering2KHR( commandBuffer, pRenderingEndInfo ); - } - - //=== VK_NV_compute_occupancy_priority === - - void vkCmdSetComputeOccupancyPriorityNV( VkCommandBuffer commandBuffer, - const VkComputeOccupancyPriorityParametersNV * pParameters ) const VULKAN_HPP_NOEXCEPT - { - return ::vkCmdSetComputeOccupancyPriorityNV( commandBuffer, pParameters ); - } - }; - - inline DispatchLoaderStatic & getDispatchLoaderStatic() - { - static DispatchLoaderStatic dls; - return dls; - } -#endif - - } // namespace detail -#if ( 14 <= VULKAN_HPP_CPP_VERSION ) - using std::exchange; -#else - template - VULKAN_HPP_CONSTEXPR_14 VULKAN_HPP_INLINE T exchange( T & obj, U && newValue ) - { - T oldValue = std::move( obj ); - obj = std::forward( newValue ); - return oldValue; - } -#endif - - struct AllocationCallbacks; - -#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) - - namespace detail - { - template - class ObjectDestroy - { - public: - ObjectDestroy() = default; - - ObjectDestroy( OwnerType owner, - Optional allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT - : m_owner( owner ) - , m_allocationCallbacks( allocationCallbacks ) - , m_dispatch( &dispatch ) - { - } - - OwnerType getOwner() const VULKAN_HPP_NOEXCEPT - { - return m_owner; - } - - Optional getAllocator() const VULKAN_HPP_NOEXCEPT - { - return m_allocationCallbacks; - } - - Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT - { - return *m_dispatch; - } - - protected: - template - void destroy( T t ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_owner && m_dispatch ); - m_owner.destroy( t, m_allocationCallbacks, *m_dispatch ); - } - - private: - OwnerType m_owner = {}; - Optional m_allocationCallbacks = nullptr; - Dispatch const * m_dispatch = nullptr; - }; - - class NoParent; - - template - class ObjectDestroy - { - public: - ObjectDestroy() = default; - - ObjectDestroy( Optional allocationCallbacks, - Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT - : m_allocationCallbacks( allocationCallbacks ) - , m_dispatch( &dispatch ) - { - } - - Optional getAllocator() const VULKAN_HPP_NOEXCEPT - { - return m_allocationCallbacks; - } - - Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT - { - return *m_dispatch; - } - - protected: - template - void destroy( T t ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_dispatch ); - t.destroy( m_allocationCallbacks, *m_dispatch ); - } - - private: - Optional m_allocationCallbacks = nullptr; - Dispatch const * m_dispatch = nullptr; - }; - - template - class ObjectFree - { - public: - ObjectFree() = default; - - ObjectFree( OwnerType owner, - Optional allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT - : m_owner( owner ) - , m_allocationCallbacks( allocationCallbacks ) - , m_dispatch( &dispatch ) - { - } - - OwnerType getOwner() const VULKAN_HPP_NOEXCEPT - { - return m_owner; - } - - Optional getAllocator() const VULKAN_HPP_NOEXCEPT - { - return m_allocationCallbacks; - } - - Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT - { - return *m_dispatch; - } - - protected: - template - void destroy( T t ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_owner && m_dispatch ); - ( m_owner.free )( t, m_allocationCallbacks, *m_dispatch ); - } - - private: - OwnerType m_owner = {}; - Optional m_allocationCallbacks = nullptr; - Dispatch const * m_dispatch = nullptr; - }; - - template - class ObjectRelease - { - public: - ObjectRelease() = default; - - ObjectRelease( OwnerType owner, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT - : m_owner( owner ) - , m_dispatch( &dispatch ) - { - } - - OwnerType getOwner() const VULKAN_HPP_NOEXCEPT - { - return m_owner; - } - - Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT - { - return *m_dispatch; - } - - protected: - template - void destroy( T t ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_owner && m_dispatch ); - m_owner.release( t, *m_dispatch ); - } - - private: - OwnerType m_owner = {}; - Dispatch const * m_dispatch = nullptr; - }; - - template - class PoolFree - { - public: - PoolFree() = default; - - PoolFree( OwnerType owner, PoolType pool, Dispatch const & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT - : m_owner( owner ) - , m_pool( pool ) - , m_dispatch( &dispatch ) - { - } - - OwnerType getOwner() const VULKAN_HPP_NOEXCEPT - { - return m_owner; - } - - PoolType getPool() const VULKAN_HPP_NOEXCEPT - { - return m_pool; - } - - Dispatch const & getDispatch() const VULKAN_HPP_NOEXCEPT - { - return *m_dispatch; - } - - protected: - template - void destroy( T t ) VULKAN_HPP_NOEXCEPT - { - ( m_owner.free )( m_pool, t, *m_dispatch ); - } - - private: - OwnerType m_owner = OwnerType(); - PoolType m_pool = PoolType(); - Dispatch const * m_dispatch = nullptr; - }; - - } // namespace detail -#endif // !VULKAN_HPP_NO_SMART_HANDLE - - //================== - //=== BASE TYPEs === - //================== - - using Bool32 = uint32_t; - using DeviceAddress = uint64_t; - using DeviceSize = uint64_t; - using RemoteAddressNV = void *; - using SampleMask = uint32_t; - - template - struct CppType - { - }; -} // namespace VULKAN_HPP_NAMESPACE - -#include -#if !defined( VULKAN_HPP_NO_TO_STRING ) -# include -#endif - -#ifndef VULKAN_HPP_NO_EXCEPTIONS -namespace std -{ - template <> - struct is_error_code_enum : public true_type - { - }; -} // namespace std -#endif - -namespace VULKAN_HPP_NAMESPACE -{ -#ifndef VULKAN_HPP_NO_EXCEPTIONS - class ErrorCategoryImpl : public std::error_category - { - public: - virtual const char * name() const VULKAN_HPP_NOEXCEPT override - { - return VULKAN_HPP_NAMESPACE_STRING "::Result"; - } - - virtual std::string message( int ev ) const override - { -# if defined( VULKAN_HPP_NO_TO_STRING ) - return std::to_string( ev ); -# else - return to_string( static_cast( ev ) ); -# endif - } - }; - - class Error - { - public: - Error() VULKAN_HPP_NOEXCEPT = default; - Error( const Error & ) VULKAN_HPP_NOEXCEPT = default; - virtual ~Error() VULKAN_HPP_NOEXCEPT = default; - - virtual const char * what() const VULKAN_HPP_NOEXCEPT = 0; - }; - - class LogicError - : public Error - , public std::logic_error - { - public: - explicit LogicError( const std::string & what ) : Error(), std::logic_error( what ) {} - - explicit LogicError( char const * what ) : Error(), std::logic_error( what ) {} - - virtual const char * what() const VULKAN_HPP_NOEXCEPT - { - return std::logic_error::what(); - } - }; - - class SystemError - : public Error - , public std::system_error - { - public: - SystemError( std::error_code ec ) : Error(), std::system_error( ec ) {} - - SystemError( std::error_code ec, std::string const & what ) : Error(), std::system_error( ec, what ) {} - - SystemError( std::error_code ec, char const * what ) : Error(), std::system_error( ec, what ) {} - - SystemError( int ev, std::error_category const & ecat ) : Error(), std::system_error( ev, ecat ) {} - - SystemError( int ev, std::error_category const & ecat, std::string const & what ) : Error(), std::system_error( ev, ecat, what ) {} - - SystemError( int ev, std::error_category const & ecat, char const * what ) : Error(), std::system_error( ev, ecat, what ) {} - - virtual const char * what() const VULKAN_HPP_NOEXCEPT - { - return std::system_error::what(); - } - }; - - VULKAN_HPP_INLINE const std::error_category & errorCategory() VULKAN_HPP_NOEXCEPT - { - static ErrorCategoryImpl instance; - return instance; - } - - VULKAN_HPP_INLINE std::error_code make_error_code( Result e ) VULKAN_HPP_NOEXCEPT - { - return std::error_code( static_cast( e ), errorCategory() ); - } - - VULKAN_HPP_INLINE std::error_condition make_error_condition( Result e ) VULKAN_HPP_NOEXCEPT - { - return std::error_condition( static_cast( e ), errorCategory() ); - } - - class OutOfHostMemoryError : public SystemError - { - public: - OutOfHostMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} - - OutOfHostMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfHostMemory ), message ) {} - }; - - class OutOfDeviceMemoryError : public SystemError - { - public: - OutOfDeviceMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} - - OutOfDeviceMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfDeviceMemory ), message ) {} - }; - - class InitializationFailedError : public SystemError - { - public: - InitializationFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} - - InitializationFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorInitializationFailed ), message ) {} - }; - - class DeviceLostError : public SystemError - { - public: - DeviceLostError( std::string const & message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} - - DeviceLostError( char const * message ) : SystemError( make_error_code( Result::eErrorDeviceLost ), message ) {} - }; - - class MemoryMapFailedError : public SystemError - { - public: - MemoryMapFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} - - MemoryMapFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorMemoryMapFailed ), message ) {} - }; - - class LayerNotPresentError : public SystemError - { - public: - LayerNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} - - LayerNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorLayerNotPresent ), message ) {} - }; - - class ExtensionNotPresentError : public SystemError - { - public: - ExtensionNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} - - ExtensionNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorExtensionNotPresent ), message ) {} - }; - - class FeatureNotPresentError : public SystemError - { - public: - FeatureNotPresentError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} - - FeatureNotPresentError( char const * message ) : SystemError( make_error_code( Result::eErrorFeatureNotPresent ), message ) {} - }; - - class IncompatibleDriverError : public SystemError - { - public: - IncompatibleDriverError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} - - IncompatibleDriverError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDriver ), message ) {} - }; - - class TooManyObjectsError : public SystemError - { - public: - TooManyObjectsError( std::string const & message ) : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} - - TooManyObjectsError( char const * message ) : SystemError( make_error_code( Result::eErrorTooManyObjects ), message ) {} - }; - - class FormatNotSupportedError : public SystemError - { - public: - FormatNotSupportedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} - - FormatNotSupportedError( char const * message ) : SystemError( make_error_code( Result::eErrorFormatNotSupported ), message ) {} - }; - - class FragmentedPoolError : public SystemError - { - public: - FragmentedPoolError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} - - FragmentedPoolError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentedPool ), message ) {} - }; - - class UnknownError : public SystemError - { - public: - UnknownError( std::string const & message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {} - - UnknownError( char const * message ) : SystemError( make_error_code( Result::eErrorUnknown ), message ) {} - }; - - class ValidationFailedError : public SystemError - { - public: - ValidationFailedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorValidationFailed ), message ) {} - - ValidationFailedError( char const * message ) : SystemError( make_error_code( Result::eErrorValidationFailed ), message ) {} - }; - - class OutOfPoolMemoryError : public SystemError - { - public: - OutOfPoolMemoryError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {} - - OutOfPoolMemoryError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfPoolMemory ), message ) {} - }; - - class InvalidExternalHandleError : public SystemError - { - public: - InvalidExternalHandleError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {} - - InvalidExternalHandleError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidExternalHandle ), message ) {} - }; - - class InvalidOpaqueCaptureAddressError : public SystemError - { - public: - InvalidOpaqueCaptureAddressError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {} - - InvalidOpaqueCaptureAddressError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidOpaqueCaptureAddress ), message ) {} - }; - - class FragmentationError : public SystemError - { - public: - FragmentationError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {} - - FragmentationError( char const * message ) : SystemError( make_error_code( Result::eErrorFragmentation ), message ) {} - }; - - class NotPermittedError : public SystemError - { - public: - NotPermittedError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNotPermitted ), message ) {} - - NotPermittedError( char const * message ) : SystemError( make_error_code( Result::eErrorNotPermitted ), message ) {} - }; - - class SurfaceLostKHRError : public SystemError - { - public: - SurfaceLostKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} - - SurfaceLostKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorSurfaceLostKHR ), message ) {} - }; - - class NativeWindowInUseKHRError : public SystemError - { - public: - NativeWindowInUseKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} - - NativeWindowInUseKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNativeWindowInUseKHR ), message ) {} - }; - - class OutOfDateKHRError : public SystemError - { - public: - OutOfDateKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} - - OutOfDateKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorOutOfDateKHR ), message ) {} - }; - - class IncompatibleDisplayKHRError : public SystemError - { - public: - IncompatibleDisplayKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} - - IncompatibleDisplayKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleDisplayKHR ), message ) {} - }; - - class InvalidShaderNVError : public SystemError - { - public: - InvalidShaderNVError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} - - InvalidShaderNVError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidShaderNV ), message ) {} - }; - - class ImageUsageNotSupportedKHRError : public SystemError - { - public: - ImageUsageNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {} - - ImageUsageNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorImageUsageNotSupportedKHR ), message ) {} - }; - - class VideoPictureLayoutNotSupportedKHRError : public SystemError - { - public: - VideoPictureLayoutNotSupportedKHRError( std::string const & message ) - : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message ) - { - } - - VideoPictureLayoutNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoPictureLayoutNotSupportedKHR ), message ) - { - } - }; - - class VideoProfileOperationNotSupportedKHRError : public SystemError - { - public: - VideoProfileOperationNotSupportedKHRError( std::string const & message ) - : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message ) - { - } - - VideoProfileOperationNotSupportedKHRError( char const * message ) - : SystemError( make_error_code( Result::eErrorVideoProfileOperationNotSupportedKHR ), message ) - { - } - }; - - class VideoProfileFormatNotSupportedKHRError : public SystemError - { - public: - VideoProfileFormatNotSupportedKHRError( std::string const & message ) - : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message ) - { - } - - VideoProfileFormatNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileFormatNotSupportedKHR ), message ) - { - } - }; - - class VideoProfileCodecNotSupportedKHRError : public SystemError - { - public: - VideoProfileCodecNotSupportedKHRError( std::string const & message ) - : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message ) - { - } - - VideoProfileCodecNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoProfileCodecNotSupportedKHR ), message ) {} - }; - - class VideoStdVersionNotSupportedKHRError : public SystemError - { - public: - VideoStdVersionNotSupportedKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message ) - { - } - - VideoStdVersionNotSupportedKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorVideoStdVersionNotSupportedKHR ), message ) {} - }; - - class InvalidDrmFormatModifierPlaneLayoutEXTError : public SystemError - { - public: - InvalidDrmFormatModifierPlaneLayoutEXTError( std::string const & message ) - : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) - { - } - - InvalidDrmFormatModifierPlaneLayoutEXTError( char const * message ) - : SystemError( make_error_code( Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT ), message ) - { - } - }; - - class PresentTimingQueueFullEXTError : public SystemError - { - public: - PresentTimingQueueFullEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorPresentTimingQueueFullEXT ), message ) {} - - PresentTimingQueueFullEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorPresentTimingQueueFullEXT ), message ) {} - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - class FullScreenExclusiveModeLostEXTError : public SystemError - { - public: - FullScreenExclusiveModeLostEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) - { - } - - FullScreenExclusiveModeLostEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorFullScreenExclusiveModeLostEXT ), message ) {} - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - class InvalidVideoStdParametersKHRError : public SystemError - { - public: - InvalidVideoStdParametersKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorInvalidVideoStdParametersKHR ), message ) {} - - InvalidVideoStdParametersKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorInvalidVideoStdParametersKHR ), message ) {} - }; - - class CompressionExhaustedEXTError : public SystemError - { - public: - CompressionExhaustedEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {} - - CompressionExhaustedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {} - }; - - class NotEnoughSpaceKHRError : public SystemError - { - public: - NotEnoughSpaceKHRError( std::string const & message ) : SystemError( make_error_code( Result::eErrorNotEnoughSpaceKHR ), message ) {} - - NotEnoughSpaceKHRError( char const * message ) : SystemError( make_error_code( Result::eErrorNotEnoughSpaceKHR ), message ) {} - }; - - namespace detail - { - [[noreturn]] VULKAN_HPP_INLINE void throwResultException( Result result, char const * message ) - { - switch ( result ) - { - case Result::eErrorOutOfHostMemory : throw OutOfHostMemoryError( message ); - case Result::eErrorOutOfDeviceMemory : throw OutOfDeviceMemoryError( message ); - case Result::eErrorInitializationFailed : throw InitializationFailedError( message ); - case Result::eErrorDeviceLost : throw DeviceLostError( message ); - case Result::eErrorMemoryMapFailed : throw MemoryMapFailedError( message ); - case Result::eErrorLayerNotPresent : throw LayerNotPresentError( message ); - case Result::eErrorExtensionNotPresent : throw ExtensionNotPresentError( message ); - case Result::eErrorFeatureNotPresent : throw FeatureNotPresentError( message ); - case Result::eErrorIncompatibleDriver : throw IncompatibleDriverError( message ); - case Result::eErrorTooManyObjects : throw TooManyObjectsError( message ); - case Result::eErrorFormatNotSupported : throw FormatNotSupportedError( message ); - case Result::eErrorFragmentedPool : throw FragmentedPoolError( message ); - case Result::eErrorUnknown : throw UnknownError( message ); - case Result::eErrorValidationFailed : throw ValidationFailedError( message ); - case Result::eErrorOutOfPoolMemory : throw OutOfPoolMemoryError( message ); - case Result::eErrorInvalidExternalHandle : throw InvalidExternalHandleError( message ); - case Result::eErrorInvalidOpaqueCaptureAddress : throw InvalidOpaqueCaptureAddressError( message ); - case Result::eErrorFragmentation : throw FragmentationError( message ); - case Result::eErrorNotPermitted : throw NotPermittedError( message ); - case Result::eErrorSurfaceLostKHR : throw SurfaceLostKHRError( message ); - case Result::eErrorNativeWindowInUseKHR : throw NativeWindowInUseKHRError( message ); - case Result::eErrorOutOfDateKHR : throw OutOfDateKHRError( message ); - case Result::eErrorIncompatibleDisplayKHR : throw IncompatibleDisplayKHRError( message ); - case Result::eErrorInvalidShaderNV : throw InvalidShaderNVError( message ); - case Result::eErrorImageUsageNotSupportedKHR : throw ImageUsageNotSupportedKHRError( message ); - case Result::eErrorVideoPictureLayoutNotSupportedKHR : throw VideoPictureLayoutNotSupportedKHRError( message ); - case Result::eErrorVideoProfileOperationNotSupportedKHR : throw VideoProfileOperationNotSupportedKHRError( message ); - case Result::eErrorVideoProfileFormatNotSupportedKHR : throw VideoProfileFormatNotSupportedKHRError( message ); - case Result::eErrorVideoProfileCodecNotSupportedKHR : throw VideoProfileCodecNotSupportedKHRError( message ); - case Result::eErrorVideoStdVersionNotSupportedKHR : throw VideoStdVersionNotSupportedKHRError( message ); - case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: throw InvalidDrmFormatModifierPlaneLayoutEXTError( message ); - case Result::eErrorPresentTimingQueueFullEXT : throw PresentTimingQueueFullEXTError( message ); -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - case Result::eErrorFullScreenExclusiveModeLostEXT: throw FullScreenExclusiveModeLostEXTError( message ); -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - case Result::eErrorInvalidVideoStdParametersKHR: throw InvalidVideoStdParametersKHRError( message ); - case Result::eErrorCompressionExhaustedEXT : throw CompressionExhaustedEXTError( message ); - case Result::eErrorNotEnoughSpaceKHR : throw NotEnoughSpaceKHRError( message ); - default : throw SystemError( make_error_code( result ), message ); - } - } - } // namespace detail -#endif - - template - struct ResultValue - { -#ifdef VULKAN_HPP_HAS_NOEXCEPT - ResultValue( Result r, T & v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( v ) ) ) -#else - ResultValue( Result r, T & v ) -#endif - : result( r ), value( v ) - { - } - -#ifdef VULKAN_HPP_HAS_NOEXCEPT - ResultValue( Result r, T && v ) VULKAN_HPP_NOEXCEPT( VULKAN_HPP_NOEXCEPT( T( std::move( v ) ) ) ) -#else - ResultValue( Result r, T && v ) -#endif - : result( r ), value( std::move( v ) ) - { - } - - Result result; - T value; - - operator std::tuple() VULKAN_HPP_NOEXCEPT - { - return std::tuple( result, value ); - } - - // std::expected-look alike - bool has_value() const VULKAN_HPP_NOEXCEPT - { - return result == vk::Result::eSuccess; - } - - T const * operator->() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( has_value() ); - return &value; - } - - T * operator->() VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( has_value() ); - return &value; - } - - T const & operator*() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( has_value() ); - return value; - } - - T & operator*() VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( has_value() ); - return value; - } - }; - -#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) - template - struct ResultValue> - { -# ifdef VULKAN_HPP_HAS_NOEXCEPT - ResultValue( Result r, UniqueHandle && v ) VULKAN_HPP_NOEXCEPT -# else - ResultValue( Result r, UniqueHandle && v ) -# endif - : result( r ) - , value( std::move( v ) ) - { - } - - VULKAN_HPP_DEPRECATED( - "asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." ) - - std::tuple> asTuple() & - { - return std::make_tuple( result, std::move( value ) ); - } - - std::tuple> asTuple() && - { - return std::make_tuple( result, std::move( value ) ); - } - - Result result; - UniqueHandle value; - }; - - template - struct ResultValue>> - { -# ifdef VULKAN_HPP_HAS_NOEXCEPT - ResultValue( Result r, std::vector> && v ) VULKAN_HPP_NOEXCEPT -# else - ResultValue( Result r, std::vector> && v ) -# endif - : result( r ) - , value( std::move( v ) ) - { - } - - VULKAN_HPP_DEPRECATED( - "asTuple() on an l-value is deprecated, as it implicitly moves the UniqueHandle out of the ResultValue. Use asTuple() on an r-value instead, requiring to explicitly move the UniqueHandle." ) - - std::tuple>> asTuple() & - { - return std::make_tuple( result, std::move( value ) ); - } - - std::tuple>> asTuple() && - { - return std::make_tuple( result, std::move( value ) ); - } - - Result result; - std::vector> value; - }; -#endif - - template - struct ResultValueType - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS -# ifdef VULKAN_HPP_EXPECTED - using type = VULKAN_HPP_EXPECTED; -# else - using type = ResultValue; -# endif -#else - using type = T; -#endif - }; - - template <> - struct ResultValueType - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS -# ifdef VULKAN_HPP_EXPECTED - using type = VULKAN_HPP_EXPECTED; -# else - using type = Result; -# endif -#else - using type = void; -#endif - }; - - namespace detail - { - template - VULKAN_HPP_CONSTEXPR bool ignore( T const & ) VULKAN_HPP_NOEXCEPT - { - return true; - } - - VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result ) - { -#if defined( VULKAN_HPP_NO_EXCEPTIONS ) -# ifdef VULKAN_HPP_UNEXPECTED - if ( result == Result::eSuccess ) - { - return {}; - } - return VULKAN_HPP_UNEXPECTED( result ); -# else - return result; -# endif -#else - ignore( result ); -#endif - } - - template - VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result, T & data ) - { -#if defined( VULKAN_HPP_NO_EXCEPTIONS ) -# ifdef VULKAN_HPP_EXPECTED - if ( result == Result::eSuccess ) - { - return data; - } - return VULKAN_HPP_UNEXPECTED( data ); -# else - return ResultValue( result, data ); -# endif -#else - ignore( result ); - return data; -#endif - } - - template - VULKAN_HPP_INLINE typename ResultValueType::type createResultValueType( Result result, T && data ) - { -#if defined( VULKAN_HPP_NO_EXCEPTIONS ) -# ifdef VULKAN_HPP_EXPECTED - if ( result == Result::eSuccess ) - { - return std::move( data ); - } - return VULKAN_HPP_UNEXPECTED( result ); -# else - return ResultValue( result, std::move( data ) ); -# endif -#else - ignore( result ); - return std::move( data ); -#endif - } - } // namespace detail - - namespace detail - { - VULKAN_HPP_INLINE void resultCheck( Result result, char const * message ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty - ignore( message ); - VULKAN_HPP_ASSERT_ON_RESULT( result == Result::eSuccess ); -#else - if ( result != Result::eSuccess ) - { - throwResultException( result, message ); - } -#endif - } - - VULKAN_HPP_INLINE void resultCheck( Result result, char const * message, std::initializer_list successCodes ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty - ignore( message ); - ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty - VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); -#else - if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) - { - throwResultException( result, message ); - } -#endif - } - - template - VULKAN_HPP_INLINE void resultCheck( Result result, - char const * message, - std::initializer_list successCodes, - VkDevice device, - std::vector const & pipelines, - AllocationCallbacks const * pAllocator, - Dispatch const & d ) - { -#ifdef VULKAN_HPP_NO_EXCEPTIONS - ignore( result ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty - ignore( message ); - ignore( successCodes ); // just in case VULKAN_HPP_ASSERT_ON_RESULT is empty - ignore( device ); - ignore( pipelines ); - ignore( pAllocator ); - ignore( d ); - VULKAN_HPP_ASSERT_ON_RESULT( std::find( successCodes.begin(), successCodes.end(), result ) != successCodes.end() ); -#else - if ( std::find( successCodes.begin(), successCodes.end(), result ) == successCodes.end() ) - { - for ( HandleType pipeline : pipelines ) - { - d.vkDestroyPipeline( device, static_cast( pipeline ), reinterpret_cast( pAllocator ) ); - } - throwResultException( result, message ); - } -#endif - } - } // namespace detail - - //=========================== - //=== CONSTEXPR CONSTANTs === - //=========================== - - //=== VK_VERSION_1_0 === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t False = VK_FALSE; - VULKAN_HPP_CONSTEXPR_INLINE float LodClampNone = VK_LOD_CLAMP_NONE; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyIgnored = VK_QUEUE_FAMILY_IGNORED; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t RemainingArrayLayers = VK_REMAINING_ARRAY_LAYERS; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t RemainingMipLevels = VK_REMAINING_MIP_LEVELS; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t True = VK_TRUE; - VULKAN_HPP_CONSTEXPR_INLINE uint64_t WholeSize = VK_WHOLE_SIZE; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxMemoryTypes = VK_MAX_MEMORY_TYPES; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPhysicalDeviceNameSize = VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t UuidSize = VK_UUID_SIZE; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxExtensionNameSize = VK_MAX_EXTENSION_NAME_SIZE; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDescriptionSize = VK_MAX_DESCRIPTION_SIZE; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxMemoryHeaps = VK_MAX_MEMORY_HEAPS; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t AttachmentUnused = VK_ATTACHMENT_UNUSED; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t SubpassExternal = VK_SUBPASS_EXTERNAL; - - //=== VK_VERSION_1_1 === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDeviceGroupSize = VK_MAX_DEVICE_GROUP_SIZE; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t LuidSize = VK_LUID_SIZE; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyExternal = VK_QUEUE_FAMILY_EXTERNAL; - - //=== VK_VERSION_1_2 === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverNameSize = VK_MAX_DRIVER_NAME_SIZE; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSize = VK_MAX_DRIVER_INFO_SIZE; - - //=== VK_VERSION_1_4 === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySize = VK_MAX_GLOBAL_PRIORITY_SIZE; - - //=== VK_KHR_device_group_creation === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDeviceGroupSizeKHR = VK_MAX_DEVICE_GROUP_SIZE_KHR; - - //=== VK_KHR_external_memory_capabilities === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t LuidSizeKHR = VK_LUID_SIZE_KHR; - - //=== VK_KHR_external_memory === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyExternalKHR = VK_QUEUE_FAMILY_EXTERNAL_KHR; - - //=== VK_EXT_queue_family_foreign === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t QueueFamilyForeignEXT = VK_QUEUE_FAMILY_FOREIGN_EXT; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderIndexUnusedAMDX = VK_SHADER_INDEX_UNUSED_AMDX; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_KHR_ray_tracing_pipeline === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedKHR = VK_SHADER_UNUSED_KHR; - - //=== VK_NV_ray_tracing === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t ShaderUnusedNV = VK_SHADER_UNUSED_NV; - - //=== VK_KHR_global_priority === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeKHR = VK_MAX_GLOBAL_PRIORITY_SIZE_KHR; - - //=== VK_KHR_driver_properties === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverNameSizeKHR = VK_MAX_DRIVER_NAME_SIZE_KHR; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxDriverInfoSizeKHR = VK_MAX_DRIVER_INFO_SIZE_KHR; - - //=== VK_EXT_global_priority_query === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxGlobalPrioritySizeEXT = VK_MAX_GLOBAL_PRIORITY_SIZE_EXT; - - //=== VK_EXT_image_sliced_view_of_3d === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Remaining3DSlicesEXT = VK_REMAINING_3D_SLICES_EXT; - - //=== VK_EXT_shader_module_identifier === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxShaderModuleIdentifierSizeEXT = VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_dense_geometry_format === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t CompressedTriangleFormatDgf1ByteAlignmentAMDX = VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t CompressedTriangleFormatDgf1ByteStrideAMDX = VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_KHR_pipeline_binary === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPipelineBinaryKeySizeKHR = VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; - - //=== VK_ARM_data_graph === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxPhysicalDeviceDataGraphOperationSetNameSizeARM = VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM; - - //=== VK_KHR_video_decode_av1 === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxVideoAv1ReferencesPerFrameKHR = VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; - - //=== VK_KHR_video_decode_vp9 === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t MaxVideoVp9ReferencesPerFrameKHR = VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; - - //=== VK_NV_partitioned_acceleration_structure === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t PartitionedAccelerationStructurePartitionIndexGlobalNV = VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV; - - //=== VK_QCOM_data_graph_model === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t DataGraphModelToolchainVersionLengthQCOM = VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM; - - //=== VK_NV_compute_occupancy_priority === - VULKAN_HPP_CONSTEXPR_INLINE float ComputeOccupancyPriorityLowNV = VK_COMPUTE_OCCUPANCY_PRIORITY_LOW_NV; - VULKAN_HPP_CONSTEXPR_INLINE float ComputeOccupancyPriorityNormalNV = VK_COMPUTE_OCCUPANCY_PRIORITY_NORMAL_NV; - VULKAN_HPP_CONSTEXPR_INLINE float ComputeOccupancyPriorityHighNV = VK_COMPUTE_OCCUPANCY_PRIORITY_HIGH_NV; - - //======================== - //=== CONSTEXPR VALUEs === - //======================== - VULKAN_HPP_CONSTEXPR_INLINE uint32_t HeaderVersion = VK_HEADER_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Use64BitPtrDefines = VK_USE_64_BIT_PTR_DEFINES; - - //========================= - //=== CONSTEXPR CALLEEs === - //========================= - 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_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_CONSTEXPR uint32_t versionMajor( T const version ) - { - return ( (uint32_t)( version ) >> 22U ); - } - - template ::value>::type> - VULKAN_HPP_CONSTEXPR uint32_t versionMinor( T const version ) - { - return ( ( (uint32_t)( version ) >> 12U ) & 0x3FFU ); - } - - template ::value>::type> - VULKAN_HPP_CONSTEXPR uint32_t versionPatch( T const version ) - { - return ( (uint32_t)( version ) & 0xFFFU ); - } - - //========================= - //=== CONSTEXPR CALLERs === - //========================= - VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion = makeApiVersion( 0, 1, 0, 0 ); - VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion10 = makeApiVersion( 0, 1, 0, 0 ); - VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion11 = makeApiVersion( 0, 1, 1, 0 ); - VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion12 = makeApiVersion( 0, 1, 2, 0 ); - VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion13 = makeApiVersion( 0, 1, 3, 0 ); - VULKAN_HPP_CONSTEXPR_INLINE auto ApiVersion14 = makeApiVersion( 0, 1, 4, 0 ); - VULKAN_HPP_CONSTEXPR_INLINE auto HeaderVersionComplete = makeApiVersion( 0, 1, 4, VK_HEADER_VERSION ); - - //================================= - //=== CONSTEXPR EXTENSION NAMEs === - //================================= - - //=== VK_KHR_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceSpecVersion = VK_KHR_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceExtensionName = VK_KHR_SURFACE_EXTENSION_NAME; - - //=== VK_KHR_swapchain === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainSpecVersion = VK_KHR_SWAPCHAIN_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainExtensionName = VK_KHR_SWAPCHAIN_EXTENSION_NAME; - - //=== VK_KHR_display === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySpecVersion = VK_KHR_DISPLAY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplayExtensionName = VK_KHR_DISPLAY_EXTENSION_NAME; - - //=== VK_KHR_display_swapchain === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySwapchainSpecVersion = VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDisplaySwapchainExtensionName = VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRXlibSurfaceSpecVersion = VK_KHR_XLIB_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRXlibSurfaceExtensionName = VK_KHR_XLIB_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRXcbSurfaceSpecVersion = VK_KHR_XCB_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRXcbSurfaceExtensionName = VK_KHR_XCB_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRWaylandSurfaceSpecVersion = VK_KHR_WAYLAND_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRWaylandSurfaceExtensionName = VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRAndroidSurfaceSpecVersion = VK_KHR_ANDROID_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRAndroidSurfaceExtensionName = VK_KHR_ANDROID_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32SurfaceSpecVersion = VK_KHR_WIN32_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32SurfaceExtensionName = VK_KHR_WIN32_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - VULKAN_HPP_DEPRECATED( "The VK_EXT_debug_report extension has been deprecated by VK_EXT_debug_utils." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugReportSpecVersion = VK_EXT_DEBUG_REPORT_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_EXT_debug_report extension has been deprecated by VK_EXT_debug_utils." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugReportExtensionName = VK_EXT_DEBUG_REPORT_EXTENSION_NAME; - - //=== VK_NV_glsl_shader === - VULKAN_HPP_DEPRECATED( "The VK_NV_glsl_shader extension has been deprecated." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVGlslShaderSpecVersion = VK_NV_GLSL_SHADER_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_NV_glsl_shader extension has been deprecated." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVGlslShaderExtensionName = VK_NV_GLSL_SHADER_EXTENSION_NAME; - - //=== VK_EXT_depth_range_unrestricted === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthRangeUnrestrictedSpecVersion = VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthRangeUnrestrictedExtensionName = VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME; - - //=== VK_KHR_sampler_mirror_clamp_to_edge === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerMirrorClampToEdgeSpecVersion = VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerMirrorClampToEdgeExtensionName = VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME; - - //=== VK_IMG_filter_cubic === - VULKAN_HPP_CONSTEXPR_INLINE auto IMGFilterCubicSpecVersion = VK_IMG_FILTER_CUBIC_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto IMGFilterCubicExtensionName = VK_IMG_FILTER_CUBIC_EXTENSION_NAME; - - //=== VK_AMD_rasterization_order === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDRasterizationOrderSpecVersion = VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDRasterizationOrderExtensionName = VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME; - - //=== VK_AMD_shader_trinary_minmax === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderTrinaryMinmaxSpecVersion = VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderTrinaryMinmaxExtensionName = VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME; - - //=== VK_AMD_shader_explicit_vertex_parameter === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderExplicitVertexParameterSpecVersion = VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderExplicitVertexParameterExtensionName = VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME; - - //=== VK_EXT_debug_marker === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugMarkerSpecVersion = VK_EXT_DEBUG_MARKER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugMarkerExtensionName = VK_EXT_DEBUG_MARKER_EXTENSION_NAME; - - //=== VK_KHR_video_queue === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoQueueSpecVersion = VK_KHR_VIDEO_QUEUE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoQueueExtensionName = VK_KHR_VIDEO_QUEUE_EXTENSION_NAME; - - //=== VK_KHR_video_decode_queue === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeQueueSpecVersion = VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeQueueExtensionName = VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME; - - //=== VK_AMD_gcn_shader === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDGcnShaderSpecVersion = VK_AMD_GCN_SHADER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDGcnShaderExtensionName = VK_AMD_GCN_SHADER_EXTENSION_NAME; - - //=== VK_NV_dedicated_allocation === - VULKAN_HPP_DEPRECATED( "The VK_NV_dedicated_allocation extension has been deprecated by VK_KHR_dedicated_allocation." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationSpecVersion = VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_NV_dedicated_allocation extension has been deprecated by VK_KHR_dedicated_allocation." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationExtensionName = VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME; - - //=== VK_EXT_transform_feedback === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTTransformFeedbackSpecVersion = VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTTransformFeedbackExtensionName = VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME; - - //=== VK_NVX_binary_import === - VULKAN_HPP_CONSTEXPR_INLINE auto NVXBinaryImportSpecVersion = VK_NVX_BINARY_IMPORT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVXBinaryImportExtensionName = VK_NVX_BINARY_IMPORT_EXTENSION_NAME; - - //=== VK_NVX_image_view_handle === - VULKAN_HPP_CONSTEXPR_INLINE auto NVXImageViewHandleSpecVersion = VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVXImageViewHandleExtensionName = VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME; - - //=== VK_AMD_draw_indirect_count === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDDrawIndirectCountSpecVersion = VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDDrawIndirectCountExtensionName = VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME; - - //=== VK_AMD_negative_viewport_height === - VULKAN_HPP_DEPRECATED( "The VK_AMD_negative_viewport_height extension has been obsoleted by VK_KHR_maintenance1." ) - VULKAN_HPP_CONSTEXPR_INLINE auto AMDNegativeViewportHeightSpecVersion = VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_AMD_negative_viewport_height extension has been obsoleted by VK_KHR_maintenance1." ) - VULKAN_HPP_CONSTEXPR_INLINE auto AMDNegativeViewportHeightExtensionName = VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME; - - //=== VK_AMD_gpu_shader_half_float === - VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_half_float extension has been deprecated by VK_KHR_shader_float16_int8." ) - VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderHalfFloatSpecVersion = VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_half_float extension has been deprecated by VK_KHR_shader_float16_int8." ) - VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderHalfFloatExtensionName = VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME; - - //=== VK_AMD_shader_ballot === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderBallotSpecVersion = VK_AMD_SHADER_BALLOT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderBallotExtensionName = VK_AMD_SHADER_BALLOT_EXTENSION_NAME; - - //=== VK_KHR_video_encode_h264 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH264SpecVersion = VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH264ExtensionName = VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME; - - //=== VK_KHR_video_encode_h265 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH265SpecVersion = VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeH265ExtensionName = VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME; - - //=== VK_KHR_video_decode_h264 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH264SpecVersion = VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH264ExtensionName = VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME; - - //=== VK_AMD_texture_gather_bias_lod === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDTextureGatherBiasLodSpecVersion = VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDTextureGatherBiasLodExtensionName = VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME; - - //=== VK_AMD_shader_info === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderInfoSpecVersion = VK_AMD_SHADER_INFO_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderInfoExtensionName = VK_AMD_SHADER_INFO_EXTENSION_NAME; - - //=== VK_KHR_dynamic_rendering === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingSpecVersion = VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingExtensionName = VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME; - - //=== VK_AMD_shader_image_load_store_lod === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderImageLoadStoreLodSpecVersion = VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderImageLoadStoreLodExtensionName = VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto GGPStreamDescriptorSurfaceSpecVersion = VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto GGPStreamDescriptorSurfaceExtensionName = VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_corner_sampled_image === - VULKAN_HPP_CONSTEXPR_INLINE auto NVCornerSampledImageSpecVersion = VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVCornerSampledImageExtensionName = VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME; - - //=== VK_KHR_multiview === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMultiviewSpecVersion = VK_KHR_MULTIVIEW_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMultiviewExtensionName = VK_KHR_MULTIVIEW_EXTENSION_NAME; - - //=== VK_IMG_format_pvrtc === - VULKAN_HPP_DEPRECATED( "The VK_IMG_format_pvrtc extension has been deprecated." ) - VULKAN_HPP_CONSTEXPR_INLINE auto IMGFormatPvrtcSpecVersion = VK_IMG_FORMAT_PVRTC_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_IMG_format_pvrtc extension has been deprecated." ) - VULKAN_HPP_CONSTEXPR_INLINE auto IMGFormatPvrtcExtensionName = VK_IMG_FORMAT_PVRTC_EXTENSION_NAME; - - //=== VK_NV_external_memory_capabilities === - VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_capabilities extension has been deprecated by VK_KHR_external_memory_capabilities." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryCapabilitiesSpecVersion = VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_capabilities extension has been deprecated by VK_KHR_external_memory_capabilities." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryCapabilitiesExtensionName = VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME; - - //=== VK_NV_external_memory === - VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory extension has been deprecated by VK_KHR_external_memory." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemorySpecVersion = VK_NV_EXTERNAL_MEMORY_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory extension has been deprecated by VK_KHR_external_memory." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryExtensionName = VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_win32 extension has been deprecated by VK_KHR_external_memory_win32." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryWin32SpecVersion = VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_NV_external_memory_win32 extension has been deprecated by VK_KHR_external_memory_win32." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryWin32ExtensionName = VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_win32_keyed_mutex === - VULKAN_HPP_CONSTEXPR_INLINE auto NVWin32KeyedMutexSpecVersion = VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVWin32KeyedMutexExtensionName = VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_get_physical_device_properties2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetPhysicalDeviceProperties2SpecVersion = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetPhysicalDeviceProperties2ExtensionName = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME; - - //=== VK_KHR_device_group === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupSpecVersion = VK_KHR_DEVICE_GROUP_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupExtensionName = VK_KHR_DEVICE_GROUP_EXTENSION_NAME; - - //=== VK_EXT_validation_flags === - VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_flags extension has been deprecated by VK_EXT_layer_settings." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFlagsSpecVersion = VK_EXT_VALIDATION_FLAGS_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_flags extension has been deprecated by VK_EXT_layer_settings." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFlagsExtensionName = VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto NNViSurfaceSpecVersion = VK_NN_VI_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NNViSurfaceExtensionName = VK_NN_VI_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_shader_draw_parameters === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderDrawParametersSpecVersion = VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderDrawParametersExtensionName = VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME; - - //=== VK_EXT_shader_subgroup_ballot === - VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_ballot extension has been deprecated by VK_VERSION_1_2." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupBallotSpecVersion = VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_ballot extension has been deprecated by VK_VERSION_1_2." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupBallotExtensionName = VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME; - - //=== VK_EXT_shader_subgroup_vote === - VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_vote extension has been deprecated by VK_VERSION_1_1." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupVoteSpecVersion = VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_EXT_shader_subgroup_vote extension has been deprecated by VK_VERSION_1_1." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupVoteExtensionName = VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME; - - //=== VK_EXT_texture_compression_astc_hdr === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstcHdrSpecVersion = VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstcHdrExtensionName = VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME; - - //=== VK_EXT_astc_decode_mode === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTAstcDecodeModeSpecVersion = VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTAstcDecodeModeExtensionName = VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME; - - //=== VK_EXT_pipeline_robustness === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineRobustnessSpecVersion = VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineRobustnessExtensionName = VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME; - - //=== VK_KHR_maintenance1 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance1SpecVersion = VK_KHR_MAINTENANCE_1_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance1ExtensionName = VK_KHR_MAINTENANCE_1_EXTENSION_NAME; - - //=== VK_KHR_device_group_creation === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupCreationSpecVersion = VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeviceGroupCreationExtensionName = VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME; - - //=== VK_KHR_external_memory_capabilities === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryCapabilitiesSpecVersion = VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryCapabilitiesExtensionName = VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME; - - //=== VK_KHR_external_memory === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemorySpecVersion = VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryExtensionName = VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryWin32SpecVersion = VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryWin32ExtensionName = VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryFdSpecVersion = VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalMemoryFdExtensionName = VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_keyed_mutex === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32KeyedMutexSpecVersion = VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRWin32KeyedMutexExtensionName = VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_capabilities === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreCapabilitiesSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreCapabilitiesExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME; - - //=== VK_KHR_external_semaphore === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreWin32SpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreWin32ExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreFdSpecVersion = VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalSemaphoreFdExtensionName = VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME; - - //=== VK_KHR_push_descriptor === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPushDescriptorSpecVersion = VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPushDescriptorExtensionName = VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME; - - //=== VK_EXT_conditional_rendering === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTConditionalRenderingSpecVersion = VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTConditionalRenderingExtensionName = VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME; - - //=== VK_KHR_shader_float16_int8 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloat16Int8SpecVersion = VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloat16Int8ExtensionName = VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME; - - //=== VK_KHR_16bit_storage === - VULKAN_HPP_CONSTEXPR_INLINE auto KHR16BitStorageSpecVersion = VK_KHR_16BIT_STORAGE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHR16BitStorageExtensionName = VK_KHR_16BIT_STORAGE_EXTENSION_NAME; - - //=== VK_KHR_incremental_present === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRIncrementalPresentSpecVersion = VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRIncrementalPresentExtensionName = VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME; - - //=== VK_KHR_descriptor_update_template === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDescriptorUpdateTemplateSpecVersion = VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDescriptorUpdateTemplateExtensionName = VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME; - - //=== VK_NV_clip_space_w_scaling === - VULKAN_HPP_CONSTEXPR_INLINE auto NVClipSpaceWScalingSpecVersion = VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVClipSpaceWScalingExtensionName = VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME; - - //=== VK_EXT_direct_mode_display === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectModeDisplaySpecVersion = VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectModeDisplayExtensionName = VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireXlibDisplaySpecVersion = VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireXlibDisplayExtensionName = VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplaySurfaceCounterSpecVersion = VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplaySurfaceCounterExtensionName = VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME; - - //=== VK_EXT_display_control === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplayControlSpecVersion = VK_EXT_DISPLAY_CONTROL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDisplayControlExtensionName = VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME; - - //=== VK_GOOGLE_display_timing === - VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDisplayTimingSpecVersion = VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDisplayTimingExtensionName = VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME; - - //=== VK_NV_sample_mask_override_coverage === - VULKAN_HPP_CONSTEXPR_INLINE auto NVSampleMaskOverrideCoverageSpecVersion = VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVSampleMaskOverrideCoverageExtensionName = VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME; - - //=== VK_NV_geometry_shader_passthrough === - VULKAN_HPP_CONSTEXPR_INLINE auto NVGeometryShaderPassthroughSpecVersion = VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVGeometryShaderPassthroughExtensionName = VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME; - - //=== VK_NV_viewport_array2 === - VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportArray2SpecVersion = VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportArray2ExtensionName = VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME; - - //=== VK_NVX_multiview_per_view_attributes === - VULKAN_HPP_CONSTEXPR_INLINE auto NVXMultiviewPerViewAttributesSpecVersion = VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVXMultiviewPerViewAttributesExtensionName = VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME; - - //=== VK_NV_viewport_swizzle === - VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportSwizzleSpecVersion = VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVViewportSwizzleExtensionName = VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME; - - //=== VK_EXT_discard_rectangles === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDiscardRectanglesSpecVersion = VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDiscardRectanglesExtensionName = VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME; - - //=== VK_EXT_conservative_rasterization === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTConservativeRasterizationSpecVersion = VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTConservativeRasterizationExtensionName = VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME; - - //=== VK_EXT_depth_clip_enable === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipEnableSpecVersion = VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipEnableExtensionName = VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME; - - //=== VK_EXT_swapchain_colorspace === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainColorSpaceSpecVersion = VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainColorSpaceExtensionName = VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME; - - //=== VK_EXT_hdr_metadata === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTHdrMetadataSpecVersion = VK_EXT_HDR_METADATA_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTHdrMetadataExtensionName = VK_EXT_HDR_METADATA_EXTENSION_NAME; - - //=== VK_KHR_imageless_framebuffer === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRImagelessFramebufferSpecVersion = VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRImagelessFramebufferExtensionName = VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME; - - //=== VK_KHR_create_renderpass2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRCreateRenderpass2SpecVersion = VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRCreateRenderpass2ExtensionName = VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME; - - //=== VK_IMG_relaxed_line_rasterization === - VULKAN_HPP_CONSTEXPR_INLINE auto IMGRelaxedLineRasterizationSpecVersion = VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto IMGRelaxedLineRasterizationExtensionName = VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME; - - //=== VK_KHR_shared_presentable_image === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSharedPresentableImageSpecVersion = VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSharedPresentableImageExtensionName = VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME; - - //=== VK_KHR_external_fence_capabilities === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceCapabilitiesSpecVersion = VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceCapabilitiesExtensionName = VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME; - - //=== VK_KHR_external_fence === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceSpecVersion = VK_KHR_EXTERNAL_FENCE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceExtensionName = VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceWin32SpecVersion = VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceWin32ExtensionName = VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceFdSpecVersion = VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRExternalFenceFdExtensionName = VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME; - - //=== VK_KHR_performance_query === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPerformanceQuerySpecVersion = VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPerformanceQueryExtensionName = VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME; - - //=== VK_KHR_maintenance2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance2SpecVersion = VK_KHR_MAINTENANCE_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance2ExtensionName = VK_KHR_MAINTENANCE_2_EXTENSION_NAME; - - //=== VK_KHR_get_surface_capabilities2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetSurfaceCapabilities2SpecVersion = VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetSurfaceCapabilities2ExtensionName = VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME; - - //=== VK_KHR_variable_pointers === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVariablePointersSpecVersion = VK_KHR_VARIABLE_POINTERS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVariablePointersExtensionName = VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME; - - //=== VK_KHR_get_display_properties2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetDisplayProperties2SpecVersion = VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetDisplayProperties2ExtensionName = VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - VULKAN_HPP_DEPRECATED( "The VK_MVK_ios_surface extension has been deprecated by VK_EXT_metal_surface." ) - VULKAN_HPP_CONSTEXPR_INLINE auto MVKIosSurfaceSpecVersion = VK_MVK_IOS_SURFACE_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_MVK_ios_surface extension has been deprecated by VK_EXT_metal_surface." ) - VULKAN_HPP_CONSTEXPR_INLINE auto MVKIosSurfaceExtensionName = VK_MVK_IOS_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - VULKAN_HPP_DEPRECATED( "The VK_MVK_macos_surface extension has been deprecated by VK_EXT_metal_surface." ) - VULKAN_HPP_CONSTEXPR_INLINE auto MVKMacosSurfaceSpecVersion = VK_MVK_MACOS_SURFACE_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_MVK_macos_surface extension has been deprecated by VK_EXT_metal_surface." ) - VULKAN_HPP_CONSTEXPR_INLINE auto MVKMacosSurfaceExtensionName = VK_MVK_MACOS_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_external_memory_dma_buf === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryDmaBufSpecVersion = VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryDmaBufExtensionName = VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME; - - //=== VK_EXT_queue_family_foreign === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTQueueFamilyForeignSpecVersion = VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTQueueFamilyForeignExtensionName = VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME; - - //=== VK_KHR_dedicated_allocation === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDedicatedAllocationSpecVersion = VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDedicatedAllocationExtensionName = VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME; - - //=== VK_EXT_debug_utils === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugUtilsSpecVersion = VK_EXT_DEBUG_UTILS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDebugUtilsExtensionName = VK_EXT_DEBUG_UTILS_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalMemoryAndroidHardwareBufferSpecVersion = VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalMemoryAndroidHardwareBufferExtensionName = VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - //=== VK_EXT_sampler_filter_minmax === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSamplerFilterMinmaxSpecVersion = VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSamplerFilterMinmaxExtensionName = VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME; - - //=== VK_KHR_storage_buffer_storage_class === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRStorageBufferStorageClassSpecVersion = VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRStorageBufferStorageClassExtensionName = VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME; - - //=== VK_AMD_gpu_shader_int16 === - VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_int16 extension has been deprecated by VK_KHR_shader_float16_int8." ) - VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderInt16SpecVersion = VK_AMD_GPU_SHADER_INT16_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_AMD_gpu_shader_int16 extension has been deprecated by VK_KHR_shader_float16_int8." ) - VULKAN_HPP_CONSTEXPR_INLINE auto AMDGpuShaderInt16ExtensionName = VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDXShaderEnqueueSpecVersion = VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDXShaderEnqueueExtensionName = VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorHeapSpecVersion = VK_EXT_DESCRIPTOR_HEAP_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorHeapExtensionName = VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME; - - //=== VK_AMD_mixed_attachment_samples === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDMixedAttachmentSamplesSpecVersion = VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDMixedAttachmentSamplesExtensionName = VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME; - - //=== VK_AMD_shader_fragment_mask === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderFragmentMaskSpecVersion = VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderFragmentMaskExtensionName = VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME; - - //=== VK_EXT_inline_uniform_block === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTInlineUniformBlockSpecVersion = VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTInlineUniformBlockExtensionName = VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME; - - //=== VK_EXT_shader_stencil_export === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportSpecVersion = VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderStencilExportExtensionName = VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME; - - //=== VK_KHR_shader_bfloat16 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16SpecVersion = VK_KHR_SHADER_BFLOAT16_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderBfloat16ExtensionName = VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME; - - //=== VK_EXT_sample_locations === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsSpecVersion = VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSampleLocationsExtensionName = VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME; - - //=== VK_KHR_relaxed_block_layout === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRelaxedBlockLayoutSpecVersion = VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRelaxedBlockLayoutExtensionName = VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME; - - //=== VK_KHR_get_memory_requirements2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetMemoryRequirements2SpecVersion = VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRGetMemoryRequirements2ExtensionName = VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME; - - //=== VK_KHR_image_format_list === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRImageFormatListSpecVersion = VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRImageFormatListExtensionName = VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME; - - //=== VK_EXT_blend_operation_advanced === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTBlendOperationAdvancedSpecVersion = VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTBlendOperationAdvancedExtensionName = VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME; - - //=== VK_NV_fragment_coverage_to_color === - VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentCoverageToColorSpecVersion = VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentCoverageToColorExtensionName = VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME; - - //=== VK_KHR_acceleration_structure === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRAccelerationStructureSpecVersion = VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRAccelerationStructureExtensionName = VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME; - - //=== VK_KHR_ray_tracing_pipeline === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPipelineSpecVersion = VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPipelineExtensionName = VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME; - - //=== VK_KHR_ray_query === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayQuerySpecVersion = VK_KHR_RAY_QUERY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayQueryExtensionName = VK_KHR_RAY_QUERY_EXTENSION_NAME; - - //=== VK_NV_framebuffer_mixed_samples === - VULKAN_HPP_CONSTEXPR_INLINE auto NVFramebufferMixedSamplesSpecVersion = VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVFramebufferMixedSamplesExtensionName = VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME; - - //=== VK_NV_fill_rectangle === - VULKAN_HPP_CONSTEXPR_INLINE auto NVFillRectangleSpecVersion = VK_NV_FILL_RECTANGLE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVFillRectangleExtensionName = VK_NV_FILL_RECTANGLE_EXTENSION_NAME; - - //=== VK_NV_shader_sm_builtins === - VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSmBuiltinsSpecVersion = VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSmBuiltinsExtensionName = VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME; - - //=== VK_EXT_post_depth_coverage === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPostDepthCoverageSpecVersion = VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPostDepthCoverageExtensionName = VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME; - - //=== VK_KHR_sampler_ycbcr_conversion === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerYcbcrConversionSpecVersion = VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSamplerYcbcrConversionExtensionName = VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME; - - //=== VK_KHR_bind_memory2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRBindMemory2SpecVersion = VK_KHR_BIND_MEMORY_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRBindMemory2ExtensionName = VK_KHR_BIND_MEMORY_2_EXTENSION_NAME; - - //=== VK_EXT_image_drm_format_modifier === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageDrmFormatModifierSpecVersion = VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageDrmFormatModifierExtensionName = VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME; - - //=== VK_EXT_validation_cache === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationCacheSpecVersion = VK_EXT_VALIDATION_CACHE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationCacheExtensionName = VK_EXT_VALIDATION_CACHE_EXTENSION_NAME; - - //=== VK_EXT_descriptor_indexing === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorIndexingSpecVersion = VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorIndexingExtensionName = VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME; - - //=== VK_EXT_shader_viewport_index_layer === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderViewportIndexLayerSpecVersion = VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderViewportIndexLayerExtensionName = VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_KHR_portability_subset === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilitySubsetSpecVersion = VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilitySubsetExtensionName = VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_NV_shading_rate_image === - VULKAN_HPP_CONSTEXPR_INLINE auto NVShadingRateImageSpecVersion = VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVShadingRateImageExtensionName = VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME; - - //=== VK_NV_ray_tracing === - VULKAN_HPP_DEPRECATED( "The VK_NV_ray_tracing extension has been deprecated by VK_KHR_ray_tracing_pipeline." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingSpecVersion = VK_NV_RAY_TRACING_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_NV_ray_tracing extension has been deprecated by VK_KHR_ray_tracing_pipeline." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingExtensionName = VK_NV_RAY_TRACING_EXTENSION_NAME; - - //=== VK_NV_representative_fragment_test === - VULKAN_HPP_CONSTEXPR_INLINE auto NVRepresentativeFragmentTestSpecVersion = VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVRepresentativeFragmentTestExtensionName = VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME; - - //=== VK_KHR_maintenance3 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance3SpecVersion = VK_KHR_MAINTENANCE_3_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance3ExtensionName = VK_KHR_MAINTENANCE_3_EXTENSION_NAME; - - //=== VK_KHR_draw_indirect_count === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDrawIndirectCountSpecVersion = VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDrawIndirectCountExtensionName = VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME; - - //=== VK_EXT_filter_cubic === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicSpecVersion = VK_EXT_FILTER_CUBIC_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFilterCubicExtensionName = VK_EXT_FILTER_CUBIC_EXTENSION_NAME; - - //=== VK_QCOM_render_pass_shader_resolve === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassShaderResolveSpecVersion = VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassShaderResolveExtensionName = VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME; - - //=== VK_EXT_global_priority === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPrioritySpecVersion = VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityExtensionName = VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME; - - //=== VK_KHR_shader_subgroup_extended_types === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupExtendedTypesSpecVersion = VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupExtendedTypesExtensionName = VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME; - - //=== VK_KHR_8bit_storage === - VULKAN_HPP_CONSTEXPR_INLINE auto KHR8BitStorageSpecVersion = VK_KHR_8BIT_STORAGE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHR8BitStorageExtensionName = VK_KHR_8BIT_STORAGE_EXTENSION_NAME; - - //=== VK_EXT_external_memory_host === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostSpecVersion = VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryHostExtensionName = VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME; - - //=== VK_AMD_buffer_marker === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDBufferMarkerSpecVersion = VK_AMD_BUFFER_MARKER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDBufferMarkerExtensionName = VK_AMD_BUFFER_MARKER_EXTENSION_NAME; - - //=== VK_KHR_shader_atomic_int64 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderAtomicInt64SpecVersion = VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderAtomicInt64ExtensionName = VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME; - - //=== VK_KHR_shader_clock === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockSpecVersion = VK_KHR_SHADER_CLOCK_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderClockExtensionName = VK_KHR_SHADER_CLOCK_EXTENSION_NAME; - - //=== VK_AMD_pipeline_compiler_control === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDPipelineCompilerControlSpecVersion = VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDPipelineCompilerControlExtensionName = VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME; - - //=== VK_EXT_calibrated_timestamps === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsSpecVersion = VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTCalibratedTimestampsExtensionName = VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME; - - //=== VK_AMD_shader_core_properties === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCorePropertiesSpecVersion = VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCorePropertiesExtensionName = VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME; - - //=== VK_KHR_video_decode_h265 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH265SpecVersion = VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeH265ExtensionName = VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME; - - //=== VK_KHR_global_priority === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRGlobalPrioritySpecVersion = VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRGlobalPriorityExtensionName = VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME; - - //=== VK_AMD_memory_overallocation_behavior === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDMemoryOverallocationBehaviorSpecVersion = VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDMemoryOverallocationBehaviorExtensionName = VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME; - - //=== VK_EXT_vertex_attribute_divisor === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeDivisorExtensionName = VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_frame_token === - VULKAN_HPP_CONSTEXPR_INLINE auto GGPFrameTokenSpecVersion = VK_GGP_FRAME_TOKEN_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto GGPFrameTokenExtensionName = VK_GGP_FRAME_TOKEN_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_EXT_pipeline_creation_feedback === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationFeedbackSpecVersion = VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationFeedbackExtensionName = VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME; - - //=== VK_KHR_driver_properties === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDriverPropertiesSpecVersion = VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDriverPropertiesExtensionName = VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME; - - //=== VK_KHR_shader_float_controls === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControlsSpecVersion = VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControlsExtensionName = VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME; - - //=== VK_NV_shader_subgroup_partitioned === - VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSubgroupPartitionedSpecVersion = VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderSubgroupPartitionedExtensionName = VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME; - - //=== VK_KHR_depth_stencil_resolve === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthStencilResolveSpecVersion = VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthStencilResolveExtensionName = VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME; - - //=== VK_KHR_swapchain_mutable_format === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMutableFormatSpecVersion = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMutableFormatExtensionName = VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME; - - //=== VK_NV_compute_shader_derivatives === - VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeShaderDerivativesSpecVersion = VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeShaderDerivativesExtensionName = VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME; - - //=== VK_NV_mesh_shader === - VULKAN_HPP_CONSTEXPR_INLINE auto NVMeshShaderSpecVersion = VK_NV_MESH_SHADER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVMeshShaderExtensionName = VK_NV_MESH_SHADER_EXTENSION_NAME; - - //=== VK_NV_fragment_shader_barycentric === - VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShaderBarycentricSpecVersion = VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShaderBarycentricExtensionName = VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME; - - //=== VK_NV_shader_image_footprint === - VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderImageFootprintSpecVersion = VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderImageFootprintExtensionName = VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME; - - //=== VK_NV_scissor_exclusive === - VULKAN_HPP_CONSTEXPR_INLINE auto NVScissorExclusiveSpecVersion = VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVScissorExclusiveExtensionName = VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME; - - //=== VK_NV_device_diagnostic_checkpoints === - VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticCheckpointsSpecVersion = VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticCheckpointsExtensionName = VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME; - - //=== VK_KHR_timeline_semaphore === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRTimelineSemaphoreSpecVersion = VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRTimelineSemaphoreExtensionName = VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME; - - //=== VK_EXT_present_timing === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentTimingSpecVersion = VK_EXT_PRESENT_TIMING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentTimingExtensionName = VK_EXT_PRESENT_TIMING_EXTENSION_NAME; - - //=== VK_INTEL_shader_integer_functions2 === - VULKAN_HPP_CONSTEXPR_INLINE auto INTELShaderIntegerFunctions2SpecVersion = VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto INTELShaderIntegerFunctions2ExtensionName = VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME; - - //=== VK_INTEL_performance_query === - VULKAN_HPP_CONSTEXPR_INLINE auto INTELPerformanceQuerySpecVersion = VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto INTELPerformanceQueryExtensionName = VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME; - - //=== VK_KHR_vulkan_memory_model === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVulkanMemoryModelSpecVersion = VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVulkanMemoryModelExtensionName = VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME; - - //=== VK_EXT_pci_bus_info === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPciBusInfoSpecVersion = VK_EXT_PCI_BUS_INFO_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPciBusInfoExtensionName = VK_EXT_PCI_BUS_INFO_EXTENSION_NAME; - - //=== VK_AMD_display_native_hdr === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDDisplayNativeHdrSpecVersion = VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDDisplayNativeHdrExtensionName = VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAImagepipeSurfaceSpecVersion = VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAImagepipeSurfaceExtensionName = VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_KHR_shader_terminate_invocation === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderTerminateInvocationSpecVersion = VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderTerminateInvocationExtensionName = VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalSurfaceSpecVersion = VK_EXT_METAL_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalSurfaceExtensionName = VK_EXT_METAL_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_fragment_density_map === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapSpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME; - - //=== VK_EXT_scalar_block_layout === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTScalarBlockLayoutSpecVersion = VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTScalarBlockLayoutExtensionName = VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME; - - //=== VK_GOOGLE_hlsl_functionality1 === - VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEHlslFunctionality1SpecVersion = VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEHlslFunctionality1ExtensionName = VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME; - - //=== VK_GOOGLE_decorate_string === - VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDecorateStringSpecVersion = VK_GOOGLE_DECORATE_STRING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEDecorateStringExtensionName = VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME; - - //=== VK_EXT_subgroup_size_control === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubgroupSizeControlSpecVersion = VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubgroupSizeControlExtensionName = VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME; - - //=== VK_KHR_fragment_shading_rate === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShadingRateSpecVersion = VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShadingRateExtensionName = VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME; - - //=== VK_AMD_shader_core_properties2 === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCoreProperties2SpecVersion = VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderCoreProperties2ExtensionName = VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME; - - //=== VK_AMD_device_coherent_memory === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemorySpecVersion = VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDDeviceCoherentMemoryExtensionName = VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME; - - //=== VK_KHR_dynamic_rendering_local_read === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadSpecVersion = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDynamicRenderingLocalReadExtensionName = VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME; - - //=== VK_EXT_shader_image_atomic_int64 === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64SpecVersion = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderImageAtomicInt64ExtensionName = VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME; - - //=== VK_KHR_shader_quad_control === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderQuadControlSpecVersion = VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderQuadControlExtensionName = VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME; - - //=== VK_KHR_spirv_1_4 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSpirv14SpecVersion = VK_KHR_SPIRV_1_4_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSpirv14ExtensionName = VK_KHR_SPIRV_1_4_EXTENSION_NAME; - - //=== VK_EXT_memory_budget === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryBudgetSpecVersion = VK_EXT_MEMORY_BUDGET_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryBudgetExtensionName = VK_EXT_MEMORY_BUDGET_EXTENSION_NAME; - - //=== VK_EXT_memory_priority === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryPrioritySpecVersion = VK_EXT_MEMORY_PRIORITY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryPriorityExtensionName = VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME; - - //=== VK_KHR_surface_protected_capabilities === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceProtectedCapabilitiesSpecVersion = VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceProtectedCapabilitiesExtensionName = VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME; - - //=== VK_NV_dedicated_allocation_image_aliasing === - VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationImageAliasingSpecVersion = VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVDedicatedAllocationImageAliasingExtensionName = VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME; - - //=== VK_KHR_separate_depth_stencil_layouts === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSeparateDepthStencilLayoutsSpecVersion = VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSeparateDepthStencilLayoutsExtensionName = VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME; - - //=== VK_EXT_buffer_device_address === - VULKAN_HPP_DEPRECATED( "The VK_EXT_buffer_device_address extension has been deprecated by VK_KHR_buffer_device_address." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTBufferDeviceAddressSpecVersion = VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_EXT_buffer_device_address extension has been deprecated by VK_KHR_buffer_device_address." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTBufferDeviceAddressExtensionName = VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME; - - //=== VK_EXT_tooling_info === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTToolingInfoSpecVersion = VK_EXT_TOOLING_INFO_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTToolingInfoExtensionName = VK_EXT_TOOLING_INFO_EXTENSION_NAME; - - //=== VK_EXT_separate_stencil_usage === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSeparateStencilUsageSpecVersion = VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSeparateStencilUsageExtensionName = VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME; - - //=== VK_EXT_validation_features === - VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_features extension has been deprecated by VK_EXT_layer_settings." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFeaturesSpecVersion = VK_EXT_VALIDATION_FEATURES_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_EXT_validation_features extension has been deprecated by VK_EXT_layer_settings." ) - VULKAN_HPP_CONSTEXPR_INLINE auto EXTValidationFeaturesExtensionName = VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME; - - //=== VK_KHR_present_wait === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWaitSpecVersion = VK_KHR_PRESENT_WAIT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWaitExtensionName = VK_KHR_PRESENT_WAIT_EXTENSION_NAME; - - //=== VK_NV_cooperative_matrix === - VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixSpecVersion = VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrixExtensionName = VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME; - - //=== VK_NV_coverage_reduction_mode === - VULKAN_HPP_CONSTEXPR_INLINE auto NVCoverageReductionModeSpecVersion = VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVCoverageReductionModeExtensionName = VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME; - - //=== VK_EXT_fragment_shader_interlock === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentShaderInterlockSpecVersion = VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentShaderInterlockExtensionName = VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME; - - //=== VK_EXT_ycbcr_image_arrays === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcrImageArraysSpecVersion = VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcrImageArraysExtensionName = VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME; - - //=== VK_KHR_uniform_buffer_standard_layout === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRUniformBufferStandardLayoutSpecVersion = VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRUniformBufferStandardLayoutExtensionName = VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME; - - //=== VK_EXT_provoking_vertex === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTProvokingVertexSpecVersion = VK_EXT_PROVOKING_VERTEX_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTProvokingVertexExtensionName = VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFullScreenExclusiveSpecVersion = VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFullScreenExclusiveExtensionName = VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTHeadlessSurfaceSpecVersion = VK_EXT_HEADLESS_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTHeadlessSurfaceExtensionName = VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME; - - //=== VK_KHR_buffer_device_address === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRBufferDeviceAddressSpecVersion = VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRBufferDeviceAddressExtensionName = VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME; - - //=== VK_EXT_line_rasterization === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationSpecVersion = VK_EXT_LINE_RASTERIZATION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLineRasterizationExtensionName = VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME; - - //=== VK_EXT_shader_atomic_float === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatSpecVersion = VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloatExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME; - - //=== VK_EXT_host_query_reset === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostQueryResetSpecVersion = VK_EXT_HOST_QUERY_RESET_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostQueryResetExtensionName = VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME; - - //=== VK_EXT_index_type_uint8 === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8SpecVersion = VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTIndexTypeUint8ExtensionName = VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME; - - //=== VK_EXT_extended_dynamic_state === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicStateSpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicStateExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME; - - //=== VK_KHR_deferred_host_operations === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeferredHostOperationsSpecVersion = VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDeferredHostOperationsExtensionName = VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME; - - //=== VK_KHR_pipeline_executable_properties === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineExecutablePropertiesSpecVersion = VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineExecutablePropertiesExtensionName = VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME; - - //=== VK_EXT_host_image_copy === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostImageCopySpecVersion = VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTHostImageCopyExtensionName = VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME; - - //=== VK_KHR_map_memory2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMapMemory2SpecVersion = VK_KHR_MAP_MEMORY_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMapMemory2ExtensionName = VK_KHR_MAP_MEMORY_2_EXTENSION_NAME; - - //=== VK_EXT_map_memory_placed === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMapMemoryPlacedSpecVersion = VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMapMemoryPlacedExtensionName = VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME; - - //=== VK_EXT_shader_atomic_float2 === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloat2SpecVersion = VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderAtomicFloat2ExtensionName = VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME; - - //=== VK_EXT_surface_maintenance1 === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSurfaceMaintenance1SpecVersion = VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSurfaceMaintenance1ExtensionName = VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME; - - //=== VK_EXT_swapchain_maintenance1 === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainMaintenance1SpecVersion = VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSwapchainMaintenance1ExtensionName = VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME; - - //=== VK_EXT_shader_demote_to_helper_invocation === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderDemoteToHelperInvocationSpecVersion = VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderDemoteToHelperInvocationExtensionName = VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME; - - //=== VK_NV_device_generated_commands === - VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsSpecVersion = VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsExtensionName = VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME; - - //=== VK_NV_inherited_viewport_scissor === - VULKAN_HPP_CONSTEXPR_INLINE auto NVInheritedViewportScissorSpecVersion = VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVInheritedViewportScissorExtensionName = VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME; - - //=== VK_KHR_shader_integer_dot_product === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderIntegerDotProductSpecVersion = VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderIntegerDotProductExtensionName = VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME; - - //=== VK_EXT_texel_buffer_alignment === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTTexelBufferAlignmentSpecVersion = VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTTexelBufferAlignmentExtensionName = VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME; - - //=== VK_QCOM_render_pass_transform === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassTransformSpecVersion = VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassTransformExtensionName = VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME; - - //=== VK_EXT_depth_bias_control === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthBiasControlSpecVersion = VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthBiasControlExtensionName = VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME; - - //=== VK_EXT_device_memory_report === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceMemoryReportSpecVersion = VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceMemoryReportExtensionName = VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME; - - //=== VK_EXT_acquire_drm_display === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireDrmDisplaySpecVersion = VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTAcquireDrmDisplayExtensionName = VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME; - - //=== VK_EXT_robustness2 === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTRobustness2SpecVersion = VK_EXT_ROBUSTNESS_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTRobustness2ExtensionName = VK_EXT_ROBUSTNESS_2_EXTENSION_NAME; - - //=== VK_EXT_custom_border_color === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorSpecVersion = VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomBorderColorExtensionName = VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME; - - //=== VK_EXT_texture_compression_astc_3d === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstc3DSpecVersion = VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTTextureCompressionAstc3DExtensionName = VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME; - - //=== VK_GOOGLE_user_type === - VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEUserTypeSpecVersion = VK_GOOGLE_USER_TYPE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLEUserTypeExtensionName = VK_GOOGLE_USER_TYPE_EXTENSION_NAME; - - //=== VK_KHR_pipeline_library === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineLibrarySpecVersion = VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineLibraryExtensionName = VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME; - - //=== VK_NV_present_barrier === - VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentBarrierSpecVersion = VK_NV_PRESENT_BARRIER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentBarrierExtensionName = VK_NV_PRESENT_BARRIER_EXTENSION_NAME; - - //=== VK_KHR_shader_non_semantic_info === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderNonSemanticInfoSpecVersion = VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderNonSemanticInfoExtensionName = VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME; - - //=== VK_KHR_present_id === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentIdSpecVersion = VK_KHR_PRESENT_ID_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentIdExtensionName = VK_KHR_PRESENT_ID_EXTENSION_NAME; - - //=== VK_EXT_private_data === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrivateDataSpecVersion = VK_EXT_PRIVATE_DATA_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrivateDataExtensionName = VK_EXT_PRIVATE_DATA_EXTENSION_NAME; - - //=== VK_EXT_pipeline_creation_cache_control === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationCacheControlSpecVersion = VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineCreationCacheControlExtensionName = VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME; - - //=== VK_KHR_video_encode_queue === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQueueSpecVersion = VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQueueExtensionName = VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME; - - //=== VK_NV_device_diagnostics_config === - VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticsConfigSpecVersion = VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceDiagnosticsConfigExtensionName = VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME; - - //=== VK_QCOM_render_pass_store_ops === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassStoreOpsSpecVersion = VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRenderPassStoreOpsExtensionName = VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchSpecVersion = VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchExtensionName = VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingSpecVersion = VK_QCOM_TILE_SHADING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingExtensionName = VK_QCOM_TILE_SHADING_EXTENSION_NAME; - - //=== VK_NV_low_latency === - VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencySpecVersion = VK_NV_LOW_LATENCY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencyExtensionName = VK_NV_LOW_LATENCY_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalObjectsSpecVersion = VK_EXT_METAL_OBJECTS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMetalObjectsExtensionName = VK_EXT_METAL_OBJECTS_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_synchronization2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSynchronization2SpecVersion = VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSynchronization2ExtensionName = VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME; - - //=== VK_EXT_descriptor_buffer === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferSpecVersion = VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDescriptorBufferExtensionName = VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME; - - //=== VK_EXT_graphics_pipeline_library === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTGraphicsPipelineLibrarySpecVersion = VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTGraphicsPipelineLibraryExtensionName = VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME; - - //=== VK_AMD_shader_early_and_late_fragment_tests === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderEarlyAndLateFragmentTestsSpecVersion = VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDShaderEarlyAndLateFragmentTestsExtensionName = VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME; - - //=== VK_KHR_fragment_shader_barycentric === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShaderBarycentricSpecVersion = VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRFragmentShaderBarycentricExtensionName = VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME; - - //=== VK_KHR_shader_subgroup_uniform_control_flow === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupUniformControlFlowSpecVersion = VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupUniformControlFlowExtensionName = VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME; - - //=== VK_KHR_zero_initialize_workgroup_memory === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRZeroInitializeWorkgroupMemorySpecVersion = VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRZeroInitializeWorkgroupMemoryExtensionName = VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME; - - //=== VK_NV_fragment_shading_rate_enums === - VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShadingRateEnumsSpecVersion = VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVFragmentShadingRateEnumsExtensionName = VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME; - - //=== VK_NV_ray_tracing_motion_blur === - VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingMotionBlurSpecVersion = VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingMotionBlurExtensionName = VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME; - - //=== VK_EXT_mesh_shader === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMeshShaderSpecVersion = VK_EXT_MESH_SHADER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMeshShaderExtensionName = VK_EXT_MESH_SHADER_EXTENSION_NAME; - - //=== VK_EXT_ycbcr_2plane_444_formats === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcr2Plane444FormatsSpecVersion = VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTYcbcr2Plane444FormatsExtensionName = VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME; - - //=== VK_EXT_fragment_density_map2 === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMap2SpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMap2ExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME; - - //=== VK_QCOM_rotated_copy_commands === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRotatedCopyCommandsSpecVersion = VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMRotatedCopyCommandsExtensionName = VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME; - - //=== VK_EXT_image_robustness === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageRobustnessSpecVersion = VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageRobustnessExtensionName = VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME; - - //=== VK_KHR_workgroup_memory_explicit_layout === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRWorkgroupMemoryExplicitLayoutSpecVersion = VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRWorkgroupMemoryExplicitLayoutExtensionName = VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME; - - //=== VK_KHR_copy_commands2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyCommands2SpecVersion = VK_KHR_COPY_COMMANDS_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyCommands2ExtensionName = VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME; - - //=== VK_EXT_image_compression_control === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSpecVersion = VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlExtensionName = VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME; - - //=== VK_EXT_attachment_feedback_loop_layout === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopLayoutSpecVersion = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopLayoutExtensionName = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME; - - //=== VK_EXT_4444_formats === - VULKAN_HPP_CONSTEXPR_INLINE auto EXT4444FormatsSpecVersion = VK_EXT_4444_FORMATS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXT4444FormatsExtensionName = VK_EXT_4444_FORMATS_EXTENSION_NAME; - - //=== VK_EXT_device_fault === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceFaultSpecVersion = VK_EXT_DEVICE_FAULT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceFaultExtensionName = VK_EXT_DEVICE_FAULT_EXTENSION_NAME; - - //=== VK_ARM_rasterization_order_attachment_access === - VULKAN_HPP_CONSTEXPR_INLINE auto ARMRasterizationOrderAttachmentAccessSpecVersion = VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ARMRasterizationOrderAttachmentAccessExtensionName = VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME; - - //=== VK_EXT_rgba10x6_formats === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTRgba10X6FormatsSpecVersion = VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTRgba10X6FormatsExtensionName = VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - VULKAN_HPP_CONSTEXPR_INLINE auto NVAcquireWinrtDisplaySpecVersion = VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVAcquireWinrtDisplayExtensionName = VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectfbSurfaceSpecVersion = VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDirectfbSurfaceExtensionName = VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_VALVE_mutable_descriptor_type === - VULKAN_HPP_CONSTEXPR_INLINE auto VALVEMutableDescriptorTypeSpecVersion = VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto VALVEMutableDescriptorTypeExtensionName = VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME; - - //=== VK_EXT_vertex_input_dynamic_state === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateSpecVersion = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexInputDynamicStateExtensionName = VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME; - - //=== VK_EXT_physical_device_drm === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPhysicalDeviceDrmSpecVersion = VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPhysicalDeviceDrmExtensionName = VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME; - - //=== VK_EXT_device_address_binding_report === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceAddressBindingReportSpecVersion = VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceAddressBindingReportExtensionName = VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME; - - //=== VK_EXT_depth_clip_control === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipControlSpecVersion = VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClipControlExtensionName = VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME; - - //=== VK_EXT_primitive_topology_list_restart === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitiveTopologyListRestartSpecVersion = VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitiveTopologyListRestartExtensionName = VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME; - - //=== VK_KHR_format_feature_flags2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRFormatFeatureFlags2SpecVersion = VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRFormatFeatureFlags2ExtensionName = VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME; - - //=== VK_EXT_present_mode_fifo_latest_ready === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentModeFifoLatestReadySpecVersion = VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPresentModeFifoLatestReadyExtensionName = VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalMemorySpecVersion = VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalMemoryExtensionName = VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalSemaphoreSpecVersion = VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIAExternalSemaphoreExtensionName = VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIABufferCollectionSpecVersion = VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto FUCHSIABufferCollectionExtensionName = VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEISubpassShadingSpecVersion = VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEISubpassShadingExtensionName = VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME; - - //=== VK_HUAWEI_invocation_mask === - VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIInvocationMaskSpecVersion = VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIInvocationMaskExtensionName = VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME; - - //=== VK_NV_external_memory_rdma === - VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryRdmaSpecVersion = VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalMemoryRdmaExtensionName = VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME; - - //=== VK_EXT_pipeline_properties === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelinePropertiesSpecVersion = VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelinePropertiesExtensionName = VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME; - - //=== VK_EXT_frame_boundary === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFrameBoundarySpecVersion = VK_EXT_FRAME_BOUNDARY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFrameBoundaryExtensionName = VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME; - - //=== VK_EXT_multisampled_render_to_single_sampled === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultisampledRenderToSingleSampledSpecVersion = VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultisampledRenderToSingleSampledExtensionName = VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME; - - //=== VK_EXT_extended_dynamic_state2 === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState2SpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState2ExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto QNXScreenSurfaceSpecVersion = VK_QNX_SCREEN_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QNXScreenSurfaceExtensionName = VK_QNX_SCREEN_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_EXT_color_write_enable === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTColorWriteEnableSpecVersion = VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTColorWriteEnableExtensionName = VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME; - - //=== VK_EXT_primitives_generated_query === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitivesGeneratedQuerySpecVersion = VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPrimitivesGeneratedQueryExtensionName = VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME; - - //=== VK_KHR_ray_tracing_maintenance1 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingMaintenance1SpecVersion = VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingMaintenance1ExtensionName = VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME; - - //=== VK_KHR_shader_untyped_pointers === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderUntypedPointersSpecVersion = VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderUntypedPointersExtensionName = VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME; - - //=== VK_EXT_global_priority_query === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQuerySpecVersion = VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTGlobalPriorityQueryExtensionName = VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME; - - //=== VK_VALVE_video_encode_rgb_conversion === - VULKAN_HPP_CONSTEXPR_INLINE auto VALVEVideoEncodeRgbConversionSpecVersion = VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto VALVEVideoEncodeRgbConversionExtensionName = VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME; - - //=== VK_EXT_image_view_min_lod === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodSpecVersion = VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageViewMinLodExtensionName = VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME; - - //=== VK_EXT_multi_draw === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultiDrawSpecVersion = VK_EXT_MULTI_DRAW_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMultiDrawExtensionName = VK_EXT_MULTI_DRAW_EXTENSION_NAME; - - //=== VK_EXT_image_2d_view_of_3d === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImage2DViewOf3DSpecVersion = VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImage2DViewOf3DExtensionName = VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME; - - //=== VK_KHR_portability_enumeration === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilityEnumerationSpecVersion = VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPortabilityEnumerationExtensionName = VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME; - - //=== VK_EXT_shader_tile_image === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderTileImageSpecVersion = VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderTileImageExtensionName = VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME; - - //=== VK_EXT_opacity_micromap === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTOpacityMicromapSpecVersion = VK_EXT_OPACITY_MICROMAP_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTOpacityMicromapExtensionName = VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_displacement_micromap === - VULKAN_HPP_DEPRECATED( "The VK_NV_displacement_micromap extension has been deprecated by VK_NV_cluster_acceleration_structure." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapSpecVersion = VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION; - VULKAN_HPP_DEPRECATED( "The VK_NV_displacement_micromap extension has been deprecated by VK_NV_cluster_acceleration_structure." ) - VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplacementMicromapExtensionName = VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_load_store_op_none === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLoadStoreOpNoneSpecVersion = VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLoadStoreOpNoneExtensionName = VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME; - - //=== VK_HUAWEI_cluster_culling_shader === - VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIClusterCullingShaderSpecVersion = VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIClusterCullingShaderExtensionName = VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME; - - //=== VK_EXT_border_color_swizzle === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTBorderColorSwizzleSpecVersion = VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTBorderColorSwizzleExtensionName = VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME; - - //=== VK_EXT_pageable_device_local_memory === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPageableDeviceLocalMemorySpecVersion = VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPageableDeviceLocalMemoryExtensionName = VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME; - - //=== VK_KHR_maintenance4 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance4SpecVersion = VK_KHR_MAINTENANCE_4_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance4ExtensionName = VK_KHR_MAINTENANCE_4_EXTENSION_NAME; - - //=== VK_ARM_shader_core_properties === - VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCorePropertiesSpecVersion = VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCorePropertiesExtensionName = VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME; - - //=== VK_KHR_shader_subgroup_rotate === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupRotateSpecVersion = VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderSubgroupRotateExtensionName = VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME; - - //=== VK_ARM_scheduling_controls === - VULKAN_HPP_CONSTEXPR_INLINE auto ARMSchedulingControlsSpecVersion = VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ARMSchedulingControlsExtensionName = VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME; - - //=== VK_EXT_image_sliced_view_of_3d === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageSlicedViewOf3DSpecVersion = VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageSlicedViewOf3DExtensionName = VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME; - - //=== VK_VALVE_descriptor_set_host_mapping === - VULKAN_HPP_CONSTEXPR_INLINE auto VALVEDescriptorSetHostMappingSpecVersion = VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto VALVEDescriptorSetHostMappingExtensionName = VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME; - - //=== VK_EXT_depth_clamp_zero_one === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampZeroOneSpecVersion = VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampZeroOneExtensionName = VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME; - - //=== VK_EXT_non_seamless_cube_map === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTNonSeamlessCubeMapSpecVersion = VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTNonSeamlessCubeMapExtensionName = VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME; - - //=== VK_ARM_render_pass_striped === - VULKAN_HPP_CONSTEXPR_INLINE auto ARMRenderPassStripedSpecVersion = VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ARMRenderPassStripedExtensionName = VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME; - - //=== VK_QCOM_fragment_density_map_offset === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFragmentDensityMapOffsetSpecVersion = VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFragmentDensityMapOffsetExtensionName = VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME; - - //=== VK_NV_copy_memory_indirect === - VULKAN_HPP_CONSTEXPR_INLINE auto NVCopyMemoryIndirectSpecVersion = VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVCopyMemoryIndirectExtensionName = VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME; - - //=== VK_NV_memory_decompression === - VULKAN_HPP_CONSTEXPR_INLINE auto NVMemoryDecompressionSpecVersion = VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVMemoryDecompressionExtensionName = VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME; - - //=== VK_NV_device_generated_commands_compute === - VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsComputeSpecVersion = VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVDeviceGeneratedCommandsComputeExtensionName = VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME; - - //=== VK_NV_ray_tracing_linear_swept_spheres === - VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingLinearSweptSpheresSpecVersion = VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingLinearSweptSpheresExtensionName = VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_EXTENSION_NAME; - - //=== VK_NV_linear_color_attachment === - VULKAN_HPP_CONSTEXPR_INLINE auto NVLinearColorAttachmentSpecVersion = VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVLinearColorAttachmentExtensionName = VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME; - - //=== VK_GOOGLE_surfaceless_query === - VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLESurfacelessQuerySpecVersion = VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto GOOGLESurfacelessQueryExtensionName = VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME; - - //=== VK_KHR_shader_maximal_reconvergence === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderMaximalReconvergenceSpecVersion = VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderMaximalReconvergenceExtensionName = VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME; - - //=== VK_EXT_image_compression_control_swapchain === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSwapchainSpecVersion = VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTImageCompressionControlSwapchainExtensionName = VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME; - - //=== VK_QCOM_image_processing === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessingSpecVersion = VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessingExtensionName = VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME; - - //=== VK_EXT_nested_command_buffer === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTNestedCommandBufferSpecVersion = VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTNestedCommandBufferExtensionName = VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - VULKAN_HPP_CONSTEXPR_INLINE auto OHOSExternalMemorySpecVersion = VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto OHOSExternalMemoryExtensionName = VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_external_memory_acquire_unmodified === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryAcquireUnmodifiedSpecVersion = VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryAcquireUnmodifiedExtensionName = VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME; - - //=== VK_EXT_extended_dynamic_state3 === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState3SpecVersion = VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExtendedDynamicState3ExtensionName = VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME; - - //=== VK_EXT_subpass_merge_feedback === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubpassMergeFeedbackSpecVersion = VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTSubpassMergeFeedbackExtensionName = VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME; - - //=== VK_LUNARG_direct_driver_loading === - VULKAN_HPP_CONSTEXPR_INLINE auto LUNARGDirectDriverLoadingSpecVersion = VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto LUNARGDirectDriverLoadingExtensionName = VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME; - - //=== VK_ARM_tensors === - VULKAN_HPP_CONSTEXPR_INLINE auto ARMTensorsSpecVersion = VK_ARM_TENSORS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ARMTensorsExtensionName = VK_ARM_TENSORS_EXTENSION_NAME; - - //=== VK_EXT_shader_module_identifier === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderModuleIdentifierSpecVersion = VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderModuleIdentifierExtensionName = VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME; - - //=== VK_EXT_rasterization_order_attachment_access === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTRasterizationOrderAttachmentAccessSpecVersion = VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTRasterizationOrderAttachmentAccessExtensionName = VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME; - - //=== VK_NV_optical_flow === - VULKAN_HPP_CONSTEXPR_INLINE auto NVOpticalFlowSpecVersion = VK_NV_OPTICAL_FLOW_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVOpticalFlowExtensionName = VK_NV_OPTICAL_FLOW_EXTENSION_NAME; - - //=== VK_EXT_legacy_dithering === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyDitheringSpecVersion = VK_EXT_LEGACY_DITHERING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyDitheringExtensionName = VK_EXT_LEGACY_DITHERING_EXTENSION_NAME; - - //=== VK_EXT_pipeline_protected_access === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineProtectedAccessSpecVersion = VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineProtectedAccessExtensionName = VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_format_resolve === - VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalFormatResolveSpecVersion = VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ANDROIDExternalFormatResolveExtensionName = VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - //=== VK_KHR_maintenance5 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance5SpecVersion = VK_KHR_MAINTENANCE_5_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance5ExtensionName = VK_KHR_MAINTENANCE_5_EXTENSION_NAME; - - //=== VK_AMD_anti_lag === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagSpecVersion = VK_AMD_ANTI_LAG_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDAntiLagExtensionName = VK_AMD_ANTI_LAG_EXTENSION_NAME; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_dense_geometry_format === - VULKAN_HPP_CONSTEXPR_INLINE auto AMDXDenseGeometryFormatSpecVersion = VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto AMDXDenseGeometryFormatExtensionName = VK_AMDX_DENSE_GEOMETRY_FORMAT_EXTENSION_NAME; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_KHR_present_id2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentId2SpecVersion = VK_KHR_PRESENT_ID_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentId2ExtensionName = VK_KHR_PRESENT_ID_2_EXTENSION_NAME; - - //=== VK_KHR_present_wait2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWait2SpecVersion = VK_KHR_PRESENT_WAIT_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentWait2ExtensionName = VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME; - - //=== VK_KHR_ray_tracing_position_fetch === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPositionFetchSpecVersion = VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRayTracingPositionFetchExtensionName = VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME; - - //=== VK_EXT_shader_object === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectSpecVersion = VK_EXT_SHADER_OBJECT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderObjectExtensionName = VK_EXT_SHADER_OBJECT_EXTENSION_NAME; - - //=== VK_KHR_pipeline_binary === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineBinarySpecVersion = VK_KHR_PIPELINE_BINARY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPipelineBinaryExtensionName = VK_KHR_PIPELINE_BINARY_EXTENSION_NAME; - - //=== VK_QCOM_tile_properties === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesSpecVersion = VK_QCOM_TILE_PROPERTIES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTilePropertiesExtensionName = VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME; - - //=== VK_SEC_amigo_profiling === - VULKAN_HPP_CONSTEXPR_INLINE auto SECAmigoProfilingSpecVersion = VK_SEC_AMIGO_PROFILING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto SECAmigoProfilingExtensionName = VK_SEC_AMIGO_PROFILING_EXTENSION_NAME; - - //=== VK_KHR_surface_maintenance1 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceMaintenance1SpecVersion = VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSurfaceMaintenance1ExtensionName = VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME; - - //=== VK_KHR_swapchain_maintenance1 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMaintenance1SpecVersion = VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRSwapchainMaintenance1ExtensionName = VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME; - - //=== VK_QCOM_multiview_per_view_viewports === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewViewportsSpecVersion = VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewViewportsExtensionName = VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME; - - //=== VK_NV_ray_tracing_invocation_reorder === - VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingInvocationReorderSpecVersion = VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingInvocationReorderExtensionName = VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME; - - //=== VK_NV_cooperative_vector === - VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeVectorSpecVersion = VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeVectorExtensionName = VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME; - - //=== VK_NV_extended_sparse_address_space === - VULKAN_HPP_CONSTEXPR_INLINE auto NVExtendedSparseAddressSpaceSpecVersion = VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVExtendedSparseAddressSpaceExtensionName = VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME; - - //=== VK_EXT_mutable_descriptor_type === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMutableDescriptorTypeSpecVersion = VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMutableDescriptorTypeExtensionName = VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME; - - //=== VK_EXT_legacy_vertex_attributes === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyVertexAttributesSpecVersion = VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLegacyVertexAttributesExtensionName = VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME; - - //=== VK_EXT_layer_settings === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLayerSettingsSpecVersion = VK_EXT_LAYER_SETTINGS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTLayerSettingsExtensionName = VK_EXT_LAYER_SETTINGS_EXTENSION_NAME; - - //=== VK_ARM_shader_core_builtins === - VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCoreBuiltinsSpecVersion = VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ARMShaderCoreBuiltinsExtensionName = VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME; - - //=== VK_EXT_pipeline_library_group_handles === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineLibraryGroupHandlesSpecVersion = VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTPipelineLibraryGroupHandlesExtensionName = VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME; - - //=== VK_EXT_dynamic_rendering_unused_attachments === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDynamicRenderingUnusedAttachmentsSpecVersion = VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDynamicRenderingUnusedAttachmentsExtensionName = VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME; - - //=== VK_KHR_internally_synchronized_queues === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRInternallySynchronizedQueuesSpecVersion = VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRInternallySynchronizedQueuesExtensionName = VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME; - - //=== VK_NV_low_latency2 === - VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatency2SpecVersion = VK_NV_LOW_LATENCY_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatency2ExtensionName = VK_NV_LOW_LATENCY_2_EXTENSION_NAME; - - //=== VK_KHR_cooperative_matrix === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRCooperativeMatrixSpecVersion = VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRCooperativeMatrixExtensionName = VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME; - - //=== VK_ARM_data_graph === - VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphSpecVersion = VK_ARM_DATA_GRAPH_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ARMDataGraphExtensionName = VK_ARM_DATA_GRAPH_EXTENSION_NAME; - - //=== VK_QCOM_multiview_per_view_render_areas === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasSpecVersion = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMMultiviewPerViewRenderAreasExtensionName = VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME; - - //=== VK_KHR_compute_shader_derivatives === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRComputeShaderDerivativesSpecVersion = VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRComputeShaderDerivativesExtensionName = VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME; - - //=== VK_KHR_video_decode_av1 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1SpecVersion = VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeAv1ExtensionName = VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME; - - //=== VK_KHR_video_encode_av1 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeAv1SpecVersion = VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeAv1ExtensionName = VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME; - - //=== VK_KHR_video_decode_vp9 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeVp9SpecVersion = VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoDecodeVp9ExtensionName = VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME; - - //=== VK_KHR_video_maintenance1 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1SpecVersion = VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance1ExtensionName = VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME; - - //=== VK_NV_per_stage_descriptor_set === - VULKAN_HPP_CONSTEXPR_INLINE auto NVPerStageDescriptorSetSpecVersion = VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVPerStageDescriptorSetExtensionName = VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME; - - //=== VK_QCOM_image_processing2 === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessing2SpecVersion = VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMImageProcessing2ExtensionName = VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME; - - //=== VK_QCOM_filter_cubic_weights === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicWeightsSpecVersion = VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicWeightsExtensionName = VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME; - - //=== VK_QCOM_ycbcr_degamma === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMYcbcrDegammaSpecVersion = VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMYcbcrDegammaExtensionName = VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME; - - //=== VK_QCOM_filter_cubic_clamp === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicClampSpecVersion = VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMFilterCubicClampExtensionName = VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME; - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopDynamicStateSpecVersion = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTAttachmentFeedbackLoopDynamicStateExtensionName = VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME; - - //=== VK_KHR_vertex_attribute_divisor === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorSpecVersion = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVertexAttributeDivisorExtensionName = VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME; - - //=== VK_KHR_load_store_op_none === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneSpecVersion = VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRLoadStoreOpNoneExtensionName = VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME; - - //=== VK_KHR_unified_image_layouts === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRUnifiedImageLayoutsSpecVersion = VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRUnifiedImageLayoutsExtensionName = VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME; - - //=== VK_KHR_shader_float_controls2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2SpecVersion = VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFloatControls2ExtensionName = VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferSpecVersion = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QNXExternalMemoryScreenBufferExtensionName = VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_MSFT_layered_driver === - VULKAN_HPP_CONSTEXPR_INLINE auto MSFTLayeredDriverSpecVersion = VK_MSFT_LAYERED_DRIVER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto MSFTLayeredDriverExtensionName = VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME; - - //=== VK_KHR_index_type_uint8 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8SpecVersion = VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRIndexTypeUint8ExtensionName = VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME; - - //=== VK_KHR_line_rasterization === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationSpecVersion = VK_KHR_LINE_RASTERIZATION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRLineRasterizationExtensionName = VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME; - - //=== VK_KHR_calibrated_timestamps === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsSpecVersion = VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRCalibratedTimestampsExtensionName = VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME; - - //=== VK_KHR_shader_expect_assume === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderExpectAssumeSpecVersion = VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderExpectAssumeExtensionName = VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME; - - //=== VK_KHR_maintenance6 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance6SpecVersion = VK_KHR_MAINTENANCE_6_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance6ExtensionName = VK_KHR_MAINTENANCE_6_EXTENSION_NAME; - - //=== VK_NV_descriptor_pool_overallocation === - VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationSpecVersion = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVDescriptorPoolOverallocationExtensionName = VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME; - - //=== VK_QCOM_tile_memory_heap === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapSpecVersion = VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileMemoryHeapExtensionName = VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME; - - //=== VK_KHR_copy_memory_indirect === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyMemoryIndirectSpecVersion = VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRCopyMemoryIndirectExtensionName = VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME; - - //=== VK_EXT_memory_decompression === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryDecompressionSpecVersion = VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTMemoryDecompressionExtensionName = VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME; - - //=== VK_NV_display_stereo === - VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoSpecVersion = VK_NV_DISPLAY_STEREO_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVDisplayStereoExtensionName = VK_NV_DISPLAY_STEREO_EXTENSION_NAME; - - //=== VK_KHR_video_encode_intra_refresh === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeIntraRefreshSpecVersion = VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeIntraRefreshExtensionName = VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME; - - //=== VK_KHR_video_encode_quantization_map === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQuantizationMapSpecVersion = VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoEncodeQuantizationMapExtensionName = VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME; - - //=== VK_NV_raw_access_chains === - VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsSpecVersion = VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsExtensionName = VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME; - - //=== VK_NV_external_compute_queue === - VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueSpecVersion = VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueExtensionName = VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME; - - //=== VK_KHR_shader_relaxed_extended_instruction === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionSpecVersion = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionExtensionName = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME; - - //=== VK_NV_command_buffer_inheritance === - VULKAN_HPP_CONSTEXPR_INLINE auto NVCommandBufferInheritanceSpecVersion = VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVCommandBufferInheritanceExtensionName = VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME; - - //=== VK_KHR_maintenance7 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7SpecVersion = VK_KHR_MAINTENANCE_7_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance7ExtensionName = VK_KHR_MAINTENANCE_7_EXTENSION_NAME; - - //=== VK_NV_shader_atomic_float16_vector === - VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorSpecVersion = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVShaderAtomicFloat16VectorExtensionName = VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME; - - //=== VK_EXT_shader_replicated_composites === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderReplicatedCompositesSpecVersion = VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderReplicatedCompositesExtensionName = VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME; - - //=== VK_EXT_shader_float8 === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderFloat8SpecVersion = VK_EXT_SHADER_FLOAT8_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderFloat8ExtensionName = VK_EXT_SHADER_FLOAT8_EXTENSION_NAME; - - //=== VK_NV_ray_tracing_validation === - VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationSpecVersion = VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVRayTracingValidationExtensionName = VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME; - - //=== VK_NV_cluster_acceleration_structure === - VULKAN_HPP_CONSTEXPR_INLINE auto NVClusterAccelerationStructureSpecVersion = VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVClusterAccelerationStructureExtensionName = VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME; - - //=== VK_NV_partitioned_acceleration_structure === - VULKAN_HPP_CONSTEXPR_INLINE auto NVPartitionedAccelerationStructureSpecVersion = VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVPartitionedAccelerationStructureExtensionName = VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME; - - //=== VK_EXT_device_generated_commands === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceGeneratedCommandsSpecVersion = VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDeviceGeneratedCommandsExtensionName = VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME; - - //=== VK_KHR_maintenance8 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance8SpecVersion = VK_KHR_MAINTENANCE_8_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance8ExtensionName = VK_KHR_MAINTENANCE_8_EXTENSION_NAME; - - //=== VK_MESA_image_alignment_control === - VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlSpecVersion = VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto MESAImageAlignmentControlExtensionName = VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME; - - //=== VK_KHR_shader_fma === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaSpecVersion = VK_KHR_SHADER_FMA_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderFmaExtensionName = VK_KHR_SHADER_FMA_EXTENSION_NAME; - - //=== VK_NV_push_constant_bank === - VULKAN_HPP_CONSTEXPR_INLINE auto NVPushConstantBankSpecVersion = VK_NV_PUSH_CONSTANT_BANK_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVPushConstantBankExtensionName = VK_NV_PUSH_CONSTANT_BANK_EXTENSION_NAME; - - //=== VK_EXT_ray_tracing_invocation_reorder === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTRayTracingInvocationReorderSpecVersion = VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTRayTracingInvocationReorderExtensionName = VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME; - - //=== VK_EXT_depth_clamp_control === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlSpecVersion = VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTDepthClampControlExtensionName = VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME; - - //=== VK_KHR_maintenance9 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance9SpecVersion = VK_KHR_MAINTENANCE_9_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance9ExtensionName = VK_KHR_MAINTENANCE_9_EXTENSION_NAME; - - //=== VK_KHR_video_maintenance2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance2SpecVersion = VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRVideoMaintenance2ExtensionName = VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - VULKAN_HPP_CONSTEXPR_INLINE auto OHOSSurfaceSpecVersion = VK_OHOS_SURFACE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto OHOSSurfaceExtensionName = VK_OHOS_SURFACE_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_HUAWEI_hdr_vivid === - VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividSpecVersion = VK_HUAWEI_HDR_VIVID_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto HUAWEIHdrVividExtensionName = VK_HUAWEI_HDR_VIVID_EXTENSION_NAME; - - //=== VK_NV_cooperative_matrix2 === - VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2SpecVersion = VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVCooperativeMatrix2ExtensionName = VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME; - - //=== VK_ARM_pipeline_opacity_micromap === - VULKAN_HPP_CONSTEXPR_INLINE auto ARMPipelineOpacityMicromapSpecVersion = VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ARMPipelineOpacityMicromapExtensionName = VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryMetalSpecVersion = VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTExternalMemoryMetalExtensionName = VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_depth_clamp_zero_one === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthClampZeroOneSpecVersion = VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRDepthClampZeroOneExtensionName = VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME; - - //=== VK_ARM_performance_counters_by_region === - VULKAN_HPP_CONSTEXPR_INLINE auto ARMPerformanceCountersByRegionSpecVersion = VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ARMPerformanceCountersByRegionExtensionName = VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_EXTENSION_NAME; - - //=== VK_EXT_vertex_attribute_robustness === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessSpecVersion = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTVertexAttributeRobustnessExtensionName = VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME; - - //=== VK_ARM_format_pack === - VULKAN_HPP_CONSTEXPR_INLINE auto ARMFormatPackSpecVersion = VK_ARM_FORMAT_PACK_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto ARMFormatPackExtensionName = VK_ARM_FORMAT_PACK_EXTENSION_NAME; - - //=== VK_VALVE_fragment_density_map_layered === - VULKAN_HPP_CONSTEXPR_INLINE auto VALVEFragmentDensityMapLayeredSpecVersion = VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto VALVEFragmentDensityMapLayeredExtensionName = VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME; - - //=== VK_KHR_robustness2 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2SpecVersion = VK_KHR_ROBUSTNESS_2_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRRobustness2ExtensionName = VK_KHR_ROBUSTNESS_2_EXTENSION_NAME; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_present_metering === - VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringSpecVersion = VK_NV_PRESENT_METERING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVPresentMeteringExtensionName = VK_NV_PRESENT_METERING_EXTENSION_NAME; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_fragment_density_map_offset === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetSpecVersion = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTFragmentDensityMapOffsetExtensionName = VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME; - - //=== VK_EXT_zero_initialize_device_memory === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTZeroInitializeDeviceMemorySpecVersion = VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTZeroInitializeDeviceMemoryExtensionName = VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME; - - //=== VK_KHR_present_mode_fifo_latest_ready === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentModeFifoLatestReadySpecVersion = VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRPresentModeFifoLatestReadyExtensionName = VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME; - - //=== VK_EXT_shader_64bit_indexing === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingSpecVersion = VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShader64BitIndexingExtensionName = VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME; - - //=== VK_EXT_custom_resolve === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomResolveSpecVersion = VK_EXT_CUSTOM_RESOLVE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTCustomResolveExtensionName = VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME; - - //=== VK_QCOM_data_graph_model === - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelSpecVersion = VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto QCOMDataGraphModelExtensionName = VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME; - - //=== VK_KHR_maintenance10 === - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10SpecVersion = VK_KHR_MAINTENANCE_10_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto KHRMaintenance10ExtensionName = VK_KHR_MAINTENANCE_10_EXTENSION_NAME; - - //=== VK_EXT_shader_long_vector === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderLongVectorSpecVersion = VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderLongVectorExtensionName = VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME; - - //=== VK_SEC_pipeline_cache_incremental_mode === - VULKAN_HPP_CONSTEXPR_INLINE auto SECPipelineCacheIncrementalModeSpecVersion = VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto SECPipelineCacheIncrementalModeExtensionName = VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME; - - //=== VK_EXT_shader_uniform_buffer_unsized_array === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderUniformBufferUnsizedArraySpecVersion = VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderUniformBufferUnsizedArrayExtensionName = VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME; - - //=== VK_NV_compute_occupancy_priority === - VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeOccupancyPrioritySpecVersion = VK_NV_COMPUTE_OCCUPANCY_PRIORITY_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto NVComputeOccupancyPriorityExtensionName = VK_NV_COMPUTE_OCCUPANCY_PRIORITY_EXTENSION_NAME; - - //=== VK_EXT_shader_subgroup_partitioned === - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupPartitionedSpecVersion = VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION; - VULKAN_HPP_CONSTEXPR_INLINE auto EXTShaderSubgroupPartitionedExtensionName = VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME; - -} // namespace VULKAN_HPP_NAMESPACE - -// clang-format off -#include -#include -#include -// clang-format on - -namespace VULKAN_HPP_NAMESPACE -{ -#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - - //======================= - //=== STRUCTS EXTENDS === - //======================= - - //=== VK_VERSION_1_0 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_VERSION_1_1 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_VERSION_1_2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_VERSION_1_3 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_VERSION_1_4 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_swapchain === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_display_swapchain === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_debug_report === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_AMD_rasterization_order === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_queue === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_decode_queue === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_dedicated_allocation === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_transform_feedback === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NVX_binary_import === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_encode_h264 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_encode_h265 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_decode_h264 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_AMD_texture_gather_bias_lod === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_corner_sampled_image === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_external_memory === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_win32_keyed_mutex === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_validation_flags === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_astc_decode_mode === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_keyed_mutex === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_conditional_rendering === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_incremental_present === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_clip_space_w_scaling === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_display_control === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_GOOGLE_display_timing === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NVX_multiview_per_view_attributes === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_viewport_swizzle === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_discard_rectangles === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_conservative_rasterization === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_depth_clip_enable === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_IMG_relaxed_line_rasterization === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_shared_presentable_image === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_performance_query === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_debug_utils === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_AMD_mixed_attachment_samples === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_shader_bfloat16 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_sample_locations === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_blend_operation_advanced === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_fragment_coverage_to_color === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_acceleration_structure === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_ray_tracing_pipeline === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_ray_query === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_framebuffer_mixed_samples === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_shader_sm_builtins === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_image_drm_format_modifier === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_validation_cache === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_KHR_portability_subset === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_NV_shading_rate_image === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_ray_tracing === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_representative_fragment_test === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_filter_cubic === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_external_memory_host === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_shader_clock === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_AMD_pipeline_compiler_control === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_AMD_shader_core_properties === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_decode_h265 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_AMD_memory_overallocation_behavior === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_vertex_attribute_divisor === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_frame_token === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_mesh_shader === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_shader_image_footprint === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_scissor_exclusive === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_device_diagnostic_checkpoints === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_present_timing === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_INTEL_shader_integer_functions2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_INTEL_performance_query === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_pci_bus_info === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_AMD_display_native_hdr === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_fragment_density_map === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_fragment_shading_rate === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_AMD_shader_core_properties2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_AMD_device_coherent_memory === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_shader_image_atomic_int64 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_shader_quad_control === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_memory_budget === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_memory_priority === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_surface_protected_capabilities === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_dedicated_allocation_image_aliasing === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_buffer_device_address === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_validation_features === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_present_wait === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_cooperative_matrix === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_coverage_reduction_mode === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_fragment_shader_interlock === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_ycbcr_image_arrays === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_provoking_vertex === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_shader_atomic_float === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_extended_dynamic_state === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_pipeline_executable_properties === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_map_memory_placed === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_shader_atomic_float2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_device_generated_commands === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_inherited_viewport_scissor === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_texel_buffer_alignment === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_render_pass_transform === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_depth_bias_control === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_device_memory_report === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_custom_border_color === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_texture_compression_astc_3d === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_pipeline_library === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_present_barrier === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_present_id === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_encode_queue === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_device_diagnostics_config === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_low_latency === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_descriptor_buffer === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_graphics_pipeline_library === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_AMD_shader_early_and_late_fragment_tests === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_fragment_shader_barycentric === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_shader_subgroup_uniform_control_flow === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_fragment_shading_rate_enums === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_ray_tracing_motion_blur === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_mesh_shader === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_ycbcr_2plane_444_formats === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_fragment_density_map2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_rotated_copy_commands === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_workgroup_memory_explicit_layout === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_image_compression_control === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_attachment_feedback_loop_layout === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_4444_formats === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_device_fault === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_rgba10x6_formats === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_vertex_input_dynamic_state === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_physical_device_drm === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_device_address_binding_report === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_depth_clip_control === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_primitive_topology_list_restart === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_HUAWEI_invocation_mask === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_external_memory_rdma === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_pipeline_properties === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_frame_boundary === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_multisampled_render_to_single_sampled === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_extended_dynamic_state2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_color_write_enable === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_primitives_generated_query === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_ray_tracing_maintenance1 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_shader_untyped_pointers === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_VALVE_video_encode_rgb_conversion === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_image_view_min_lod === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_multi_draw === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_image_2d_view_of_3d === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_shader_tile_image === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_opacity_micromap === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_displacement_micromap === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_HUAWEI_cluster_culling_shader === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_border_color_swizzle === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_pageable_device_local_memory === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_ARM_shader_core_properties === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_ARM_scheduling_controls === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_image_sliced_view_of_3d === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_VALVE_descriptor_set_host_mapping === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_non_seamless_cube_map === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_ARM_render_pass_striped === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_copy_memory_indirect === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_device_generated_commands_compute === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_ray_tracing_linear_swept_spheres === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_linear_color_attachment === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_shader_maximal_reconvergence === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_image_compression_control_swapchain === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_image_processing === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_nested_command_buffer === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_external_memory_acquire_unmodified === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_extended_dynamic_state3 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_subpass_merge_feedback === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_LUNARG_direct_driver_loading === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_ARM_tensors === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_shader_module_identifier === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_rasterization_order_attachment_access === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_optical_flow === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_legacy_dithering === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_format_resolve === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - //=== VK_AMD_anti_lag === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_dense_geometry_format === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_KHR_present_id2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_present_wait2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_ray_tracing_position_fetch === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_shader_object === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_pipeline_binary === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_tile_properties === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_SEC_amigo_profiling === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_surface_maintenance1 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_swapchain_maintenance1 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_multiview_per_view_viewports === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_ray_tracing_invocation_reorder === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_cooperative_vector === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_extended_sparse_address_space === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_mutable_descriptor_type === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_legacy_vertex_attributes === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_layer_settings === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_ARM_shader_core_builtins === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_pipeline_library_group_handles === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_dynamic_rendering_unused_attachments === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_internally_synchronized_queues === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_low_latency2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_cooperative_matrix === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_ARM_data_graph === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_multiview_per_view_render_areas === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_compute_shader_derivatives === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_decode_av1 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_encode_av1 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_decode_vp9 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_maintenance1 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_per_stage_descriptor_set === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_image_processing2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_filter_cubic_weights === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_ycbcr_degamma === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_filter_cubic_clamp === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_unified_image_layouts === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_MSFT_layered_driver === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_descriptor_pool_overallocation === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_tile_memory_heap === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_copy_memory_indirect === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_memory_decompression === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_display_stereo === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_encode_intra_refresh === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_encode_quantization_map === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_raw_access_chains === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_external_compute_queue === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_shader_relaxed_extended_instruction === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_command_buffer_inheritance === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_maintenance7 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_shader_atomic_float16_vector === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_shader_replicated_composites === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_shader_float8 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_ray_tracing_validation === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_cluster_acceleration_structure === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_partitioned_acceleration_structure === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_device_generated_commands === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_maintenance8 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_MESA_image_alignment_control === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_shader_fma === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_push_constant_bank === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_ray_tracing_invocation_reorder === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_depth_clamp_control === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_maintenance9 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_video_maintenance2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_HUAWEI_hdr_vivid === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_cooperative_matrix2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_ARM_pipeline_opacity_micromap === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_depth_clamp_zero_one === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_ARM_performance_counters_by_region === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_vertex_attribute_robustness === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_ARM_format_pack === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_VALVE_fragment_density_map_layered === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_robustness2 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_present_metering === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_fragment_density_map_offset === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_zero_initialize_device_memory === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_present_mode_fifo_latest_ready === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_shader_64bit_indexing === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_custom_resolve === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_QCOM_data_graph_model === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_KHR_maintenance10 === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_shader_long_vector === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_SEC_pipeline_cache_incremental_mode === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_shader_uniform_buffer_unsized_array === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_NV_compute_occupancy_priority === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - //=== VK_EXT_shader_subgroup_partitioned === - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - - template <> - struct StructExtends - { - enum - { - value = true - }; - }; - -#endif // VULKAN_HPP_DISABLE_ENHANCED_MODE - - namespace detail - { -#if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL - class DynamicLoader - { - public: -# ifdef VULKAN_HPP_NO_EXCEPTIONS - DynamicLoader( std::string const & vulkanLibraryName = {} ) VULKAN_HPP_NOEXCEPT -# else - DynamicLoader( std::string const & vulkanLibraryName = {} ) -# endif - { - if ( !vulkanLibraryName.empty() ) - { -# if defined( _WIN32 ) - m_library = ::LoadLibraryA( vulkanLibraryName.c_str() ); -# elif defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) - m_library = dlopen( vulkanLibraryName.c_str(), RTLD_NOW | RTLD_LOCAL ); -# else -# error unsupported platform -# endif - } - else - { -# if defined( _WIN32 ) - m_library = ::LoadLibraryA( "vulkan-1.dll" ); -# elif defined( __APPLE__ ) - m_library = dlopen( "libvulkan.dylib", RTLD_NOW | RTLD_LOCAL ); - if ( !m_library ) - { - m_library = dlopen( "libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL ); - } - // modern versions of macOS don't search /usr/local/lib automatically contrary to what man dlopen says - // Vulkan SDK uses this as the system-wide installation location, so we're going to fallback to this if all else fails - if ( !m_library && ( std::getenv( "DYLD_FALLBACK_LIBRARY_PATH" ) == NULL ) ) - { - m_library = dlopen( "/usr/local/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL ); - } - // for Homebrew installations on Apple Silicon - if ( !m_library ) - { - m_library = dlopen( "/opt/homebrew/lib/libvulkan.dylib", RTLD_NOW | RTLD_LOCAL ); - } - if ( !m_library ) - { - m_library = dlopen( "libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL ); - } - // Add support for using Vulkan and MoltenVK in a Framework. App store rules for iOS - // strictly enforce no .dylib's. If they aren't found it just falls through - if ( !m_library ) - { - m_library = dlopen( "vulkan.framework/vulkan", RTLD_NOW | RTLD_LOCAL ); - } - if ( !m_library ) - { - m_library = dlopen( "MoltenVK.framework/MoltenVK", RTLD_NOW | RTLD_LOCAL ); - } -# elif defined( __unix__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) - m_library = dlopen( "libvulkan.so", RTLD_NOW | RTLD_LOCAL ); - if ( !m_library ) - { - m_library = dlopen( "libvulkan.so.1", RTLD_NOW | RTLD_LOCAL ); - } -# else -# error unsupported platform -# endif - } - -# ifndef VULKAN_HPP_NO_EXCEPTIONS - if ( !m_library ) - { - // NOTE there should be an InitializationFailedError, but msvc insists on the symbol does not exist within the scope of this function. - throw std::runtime_error( "Failed to load vulkan library!" ); - } -# endif - } - - DynamicLoader( DynamicLoader const & ) = delete; - - DynamicLoader( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT : m_library( other.m_library ) - { - other.m_library = nullptr; - } - - DynamicLoader & operator=( DynamicLoader const & ) = delete; - - DynamicLoader & operator=( DynamicLoader && other ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_library, other.m_library ); - return *this; - } - - ~DynamicLoader() VULKAN_HPP_NOEXCEPT - { - if ( m_library ) - { -# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) - dlclose( m_library ); -# elif defined( _WIN32 ) - ::FreeLibrary( m_library ); -# else -# error unsupported platform -# endif - } - } - - template - T getProcAddress( const char * function ) const VULKAN_HPP_NOEXCEPT - { -# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) - return (T)(void *)dlsym( m_library, function ); -# elif defined( _WIN32 ) - return (T)(void *)::GetProcAddress( m_library, function ); -# else -# error unsupported platform -# endif - } - - bool success() const VULKAN_HPP_NOEXCEPT - { - return m_library != nullptr; - } - - private: -# if defined( __unix__ ) || defined( __APPLE__ ) || defined( __QNX__ ) || defined( __Fuchsia__ ) - void * m_library; -# elif defined( _WIN32 ) - ::HINSTANCE m_library; -# else -# error unsupported platform -# endif - }; -#endif - - using PFN_dummy = void ( * )(); - - class DispatchLoaderDynamic : public DispatchLoaderBase - { - public: - //=== VK_VERSION_1_0 === - PFN_vkCreateInstance vkCreateInstance = 0; - PFN_vkDestroyInstance vkDestroyInstance = 0; - PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; - PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0; - PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; - PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0; - PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; - PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; - PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; - PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; - PFN_vkCreateDevice vkCreateDevice = 0; - PFN_vkDestroyDevice vkDestroyDevice = 0; - PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; - PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; - PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; - PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; - PFN_vkGetDeviceQueue vkGetDeviceQueue = 0; - PFN_vkQueueSubmit vkQueueSubmit = 0; - PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; - PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; - PFN_vkAllocateMemory vkAllocateMemory = 0; - PFN_vkFreeMemory vkFreeMemory = 0; - PFN_vkMapMemory vkMapMemory = 0; - PFN_vkUnmapMemory vkUnmapMemory = 0; - PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; - PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; - PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; - PFN_vkBindBufferMemory vkBindBufferMemory = 0; - PFN_vkBindImageMemory vkBindImageMemory = 0; - PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; - PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; - PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; - PFN_vkQueueBindSparse vkQueueBindSparse = 0; - PFN_vkCreateFence vkCreateFence = 0; - PFN_vkDestroyFence vkDestroyFence = 0; - PFN_vkResetFences vkResetFences = 0; - PFN_vkGetFenceStatus vkGetFenceStatus = 0; - PFN_vkWaitForFences vkWaitForFences = 0; - PFN_vkCreateSemaphore vkCreateSemaphore = 0; - PFN_vkDestroySemaphore vkDestroySemaphore = 0; - PFN_vkCreateQueryPool vkCreateQueryPool = 0; - PFN_vkDestroyQueryPool vkDestroyQueryPool = 0; - PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; - PFN_vkCreateBuffer vkCreateBuffer = 0; - PFN_vkDestroyBuffer vkDestroyBuffer = 0; - PFN_vkCreateImage vkCreateImage = 0; - PFN_vkDestroyImage vkDestroyImage = 0; - PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0; - PFN_vkCreateImageView vkCreateImageView = 0; - PFN_vkDestroyImageView vkDestroyImageView = 0; - PFN_vkCreateCommandPool vkCreateCommandPool = 0; - PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; - PFN_vkResetCommandPool vkResetCommandPool = 0; - PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; - PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; - PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; - PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; - PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; - PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; - PFN_vkCmdCopyImage vkCmdCopyImage = 0; - PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; - PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0; - PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; - PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; - PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; - PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; - PFN_vkCmdEndQuery vkCmdEndQuery = 0; - PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0; - PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; - PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; - PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; - PFN_vkCreateEvent vkCreateEvent = 0; - PFN_vkDestroyEvent vkDestroyEvent = 0; - PFN_vkGetEventStatus vkGetEventStatus = 0; - PFN_vkSetEvent vkSetEvent = 0; - PFN_vkResetEvent vkResetEvent = 0; - PFN_vkCreateBufferView vkCreateBufferView = 0; - PFN_vkDestroyBufferView vkDestroyBufferView = 0; - PFN_vkCreateShaderModule vkCreateShaderModule = 0; - PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; - PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; - PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0; - PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; - PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; - PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; - PFN_vkDestroyPipeline vkDestroyPipeline = 0; - PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; - PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; - PFN_vkCreateSampler vkCreateSampler = 0; - PFN_vkDestroySampler vkDestroySampler = 0; - PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; - PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; - PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; - PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; - PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; - PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; - PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; - PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; - PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; - PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; - PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; - PFN_vkCmdDispatch vkCmdDispatch = 0; - PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0; - PFN_vkCmdSetEvent vkCmdSetEvent = 0; - PFN_vkCmdResetEvent vkCmdResetEvent = 0; - PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; - PFN_vkCmdPushConstants vkCmdPushConstants = 0; - PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; - PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; - PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; - PFN_vkCreateRenderPass vkCreateRenderPass = 0; - PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; - PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; - PFN_vkCmdSetViewport vkCmdSetViewport = 0; - PFN_vkCmdSetScissor vkCmdSetScissor = 0; - PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; - PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; - PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0; - PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; - PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; - PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0; - PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0; - PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; - PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; - PFN_vkCmdDraw vkCmdDraw = 0; - PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; - PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0; - PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0; - PFN_vkCmdBlitImage vkCmdBlitImage = 0; - PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; - PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; - PFN_vkCmdResolveImage vkCmdResolveImage = 0; - PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; - PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; - PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; - - //=== VK_VERSION_1_1 === - PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; - PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; - PFN_vkBindImageMemory2 vkBindImageMemory2 = 0; - PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; - PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0; - PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; - PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0; - PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; - PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0; - PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0; - PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; - PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0; - PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; - PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; - PFN_vkTrimCommandPool vkTrimCommandPool = 0; - PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0; - PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0; - PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0; - PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0; - PFN_vkCmdDispatchBase vkCmdDispatchBase = 0; - PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; - PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0; - PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; - PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0; - PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; - PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0; - - //=== VK_VERSION_1_2 === - PFN_vkResetQueryPool vkResetQueryPool = 0; - PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0; - PFN_vkWaitSemaphores vkWaitSemaphores = 0; - PFN_vkSignalSemaphore vkSignalSemaphore = 0; - PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0; - PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0; - PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0; - PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0; - PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0; - PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0; - PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0; - PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0; - PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0; - - //=== VK_VERSION_1_3 === - PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0; - PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0; - PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0; - PFN_vkSetPrivateData vkSetPrivateData = 0; - PFN_vkGetPrivateData vkGetPrivateData = 0; - PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0; - PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0; - PFN_vkQueueSubmit2 vkQueueSubmit2 = 0; - PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0; - PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0; - PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0; - PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0; - PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0; - PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0; - PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0; - PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0; - PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0; - PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0; - PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0; - PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0; - PFN_vkCmdBeginRendering vkCmdBeginRendering = 0; - PFN_vkCmdEndRendering vkCmdEndRendering = 0; - PFN_vkCmdSetCullMode vkCmdSetCullMode = 0; - PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0; - PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0; - PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0; - PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0; - PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0; - PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0; - PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0; - PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0; - PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0; - PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0; - PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0; - PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0; - PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0; - PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0; - - //=== VK_VERSION_1_4 === - PFN_vkMapMemory2 vkMapMemory2 = 0; - PFN_vkUnmapMemory2 vkUnmapMemory2 = 0; - PFN_vkGetDeviceImageSubresourceLayout vkGetDeviceImageSubresourceLayout = 0; - PFN_vkGetImageSubresourceLayout2 vkGetImageSubresourceLayout2 = 0; - PFN_vkCopyMemoryToImage vkCopyMemoryToImage = 0; - PFN_vkCopyImageToMemory vkCopyImageToMemory = 0; - PFN_vkCopyImageToImage vkCopyImageToImage = 0; - PFN_vkTransitionImageLayout vkTransitionImageLayout = 0; - PFN_vkCmdPushDescriptorSet vkCmdPushDescriptorSet = 0; - PFN_vkCmdPushDescriptorSetWithTemplate vkCmdPushDescriptorSetWithTemplate = 0; - PFN_vkCmdBindDescriptorSets2 vkCmdBindDescriptorSets2 = 0; - PFN_vkCmdPushConstants2 vkCmdPushConstants2 = 0; - PFN_vkCmdPushDescriptorSet2 vkCmdPushDescriptorSet2 = 0; - PFN_vkCmdPushDescriptorSetWithTemplate2 vkCmdPushDescriptorSetWithTemplate2 = 0; - PFN_vkCmdSetLineStipple vkCmdSetLineStipple = 0; - PFN_vkCmdBindIndexBuffer2 vkCmdBindIndexBuffer2 = 0; - PFN_vkGetRenderingAreaGranularity vkGetRenderingAreaGranularity = 0; - PFN_vkCmdSetRenderingAttachmentLocations vkCmdSetRenderingAttachmentLocations = 0; - PFN_vkCmdSetRenderingInputAttachmentIndices vkCmdSetRenderingInputAttachmentIndices = 0; - - //=== VK_KHR_surface === - PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; - PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; - PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; - PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; - PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; - - //=== VK_KHR_swapchain === - PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0; - PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; - PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; - PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; - PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; - PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; - PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; - PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; - PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; - - //=== VK_KHR_display === - PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0; - PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0; - PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; - PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; - PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; - PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; - PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; - - //=== VK_KHR_display_swapchain === - PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; - PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; -#else - PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; - PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; -#else - PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; - PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; -#else - PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; -#else - PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; - PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; -#else - PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; - PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; - PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; - - //=== VK_EXT_debug_marker === - PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; - PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; - PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; - PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; - PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; - - //=== VK_KHR_video_queue === - PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0; - PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0; - PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0; - PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0; - PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0; - PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0; - PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0; - PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0; - PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0; - PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0; - PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0; - PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0; - - //=== VK_KHR_video_decode_queue === - PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0; - - //=== VK_EXT_transform_feedback === - PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0; - PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0; - PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0; - PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0; - PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0; - PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0; - - //=== VK_NVX_binary_import === - PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0; - PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0; - PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0; - PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0; - PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0; - - //=== VK_NVX_image_view_handle === - PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0; - PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX = 0; - PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0; - PFN_vkGetDeviceCombinedImageSamplerIndexNVX vkGetDeviceCombinedImageSamplerIndexNVX = 0; - - //=== VK_AMD_draw_indirect_count === - PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; - PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0; - - //=== VK_AMD_shader_info === - PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0; - - //=== VK_KHR_dynamic_rendering === - PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0; - PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; -#else - PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; -#else - PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_get_physical_device_properties2 === - PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0; - PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; - PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0; - PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; - PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; - - //=== VK_KHR_device_group === - PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; - PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0; - PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0; - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; -#else - PFN_dummy vkCreateViSurfaceNN_placeholder = 0; -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_maintenance1 === - PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; - - //=== VK_KHR_device_group_creation === - PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; - - //=== VK_KHR_external_memory_capabilities === - PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; - PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; -#else - PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0; - PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0; - - //=== VK_KHR_external_semaphore_capabilities === - PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; - PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; -#else - PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0; - PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; - - //=== VK_KHR_push_descriptor === - PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0; - PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0; - - //=== VK_EXT_conditional_rendering === - PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0; - PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0; - - //=== VK_KHR_descriptor_update_template === - PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; - PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0; - PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0; - - //=== VK_NV_clip_space_w_scaling === - PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; - - //=== VK_EXT_direct_mode_display === - PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; - -#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; - PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; -#else - PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; - PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; - - //=== VK_EXT_display_control === - PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; - PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; - PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; - PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0; - - //=== VK_GOOGLE_display_timing === - PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; - PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; - - //=== VK_EXT_discard_rectangles === - PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; - PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT = 0; - PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT = 0; - - //=== VK_EXT_hdr_metadata === - PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; - - //=== VK_KHR_create_renderpass2 === - PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0; - PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0; - PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0; - PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0; - - //=== VK_KHR_shared_presentable_image === - PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; - - //=== VK_KHR_external_fence_capabilities === - PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; - PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; -#else - PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; - PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0; - - //=== VK_KHR_performance_query === - PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0; - PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; - PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; - PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0; - - //=== VK_KHR_get_surface_capabilities2 === - PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; - PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; - - //=== VK_KHR_get_display_properties2 === - PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0; - PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0; - PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; - PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; -#else - PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; -#else - PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; - PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; - PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0; - PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; - PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; - PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; - PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; - PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; - PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; - PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; - PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; - PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; -#else - PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; - PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX = 0; - PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX = 0; - PFN_vkGetExecutionGraphPipelineNodeIndexAMDX vkGetExecutionGraphPipelineNodeIndexAMDX = 0; - PFN_vkCmdInitializeGraphScratchMemoryAMDX vkCmdInitializeGraphScratchMemoryAMDX = 0; - PFN_vkCmdDispatchGraphAMDX vkCmdDispatchGraphAMDX = 0; - PFN_vkCmdDispatchGraphIndirectAMDX vkCmdDispatchGraphIndirectAMDX = 0; - PFN_vkCmdDispatchGraphIndirectCountAMDX vkCmdDispatchGraphIndirectCountAMDX = 0; -#else - PFN_dummy vkCreateExecutionGraphPipelinesAMDX_placeholder = 0; - PFN_dummy vkGetExecutionGraphPipelineScratchSizeAMDX_placeholder = 0; - PFN_dummy vkGetExecutionGraphPipelineNodeIndexAMDX_placeholder = 0; - PFN_dummy vkCmdInitializeGraphScratchMemoryAMDX_placeholder = 0; - PFN_dummy vkCmdDispatchGraphAMDX_placeholder = 0; - PFN_dummy vkCmdDispatchGraphIndirectAMDX_placeholder = 0; - PFN_dummy vkCmdDispatchGraphIndirectCountAMDX_placeholder = 0; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - PFN_vkWriteSamplerDescriptorsEXT vkWriteSamplerDescriptorsEXT = 0; - PFN_vkWriteResourceDescriptorsEXT vkWriteResourceDescriptorsEXT = 0; - PFN_vkCmdBindSamplerHeapEXT vkCmdBindSamplerHeapEXT = 0; - PFN_vkCmdBindResourceHeapEXT vkCmdBindResourceHeapEXT = 0; - PFN_vkCmdPushDataEXT vkCmdPushDataEXT = 0; - PFN_vkGetImageOpaqueCaptureDataEXT vkGetImageOpaqueCaptureDataEXT = 0; - PFN_vkGetPhysicalDeviceDescriptorSizeEXT vkGetPhysicalDeviceDescriptorSizeEXT = 0; - PFN_vkRegisterCustomBorderColorEXT vkRegisterCustomBorderColorEXT = 0; - PFN_vkUnregisterCustomBorderColorEXT vkUnregisterCustomBorderColorEXT = 0; - PFN_vkGetTensorOpaqueCaptureDataARM vkGetTensorOpaqueCaptureDataARM = 0; - - //=== VK_EXT_sample_locations === - PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; - PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; - - //=== VK_KHR_get_memory_requirements2 === - PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0; - PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; - PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0; - - //=== VK_KHR_acceleration_structure === - PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0; - PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0; - PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0; - PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0; - PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0; - PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0; - PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0; - PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0; - PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0; - PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0; - PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0; - PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0; - PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0; - PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0; - PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0; - PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0; - - //=== VK_KHR_ray_tracing_pipeline === - PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0; - PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0; - PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0; - PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0; - PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0; - PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0; - PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0; - - //=== VK_KHR_sampler_ycbcr_conversion === - PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; - PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0; - - //=== VK_KHR_bind_memory2 === - PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; - PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0; - - //=== VK_EXT_image_drm_format_modifier === - PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0; - - //=== VK_EXT_validation_cache === - PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0; - PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; - PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0; - PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; - - //=== VK_NV_shading_rate_image === - PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0; - PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0; - PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0; - - //=== VK_NV_ray_tracing === - PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0; - PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0; - PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0; - PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0; - PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0; - PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0; - PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0; - PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0; - PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; - PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0; - PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0; - PFN_vkCompileDeferredNV vkCompileDeferredNV = 0; - - //=== VK_KHR_maintenance3 === - PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0; - - //=== VK_KHR_draw_indirect_count === - PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; - PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0; - - //=== VK_EXT_external_memory_host === - PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0; - - //=== VK_AMD_buffer_marker === - PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; - PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0; - - //=== VK_EXT_calibrated_timestamps === - PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0; - PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0; - - //=== VK_NV_mesh_shader === - PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0; - PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0; - PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0; - - //=== VK_NV_scissor_exclusive === - PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV = 0; - PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0; - - //=== VK_NV_device_diagnostic_checkpoints === - PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0; - PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0; - PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0; - - //=== VK_KHR_timeline_semaphore === - PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0; - PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0; - PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0; - - //=== VK_EXT_present_timing === - PFN_vkSetSwapchainPresentTimingQueueSizeEXT vkSetSwapchainPresentTimingQueueSizeEXT = 0; - PFN_vkGetSwapchainTimingPropertiesEXT vkGetSwapchainTimingPropertiesEXT = 0; - PFN_vkGetSwapchainTimeDomainPropertiesEXT vkGetSwapchainTimeDomainPropertiesEXT = 0; - PFN_vkGetPastPresentationTimingEXT vkGetPastPresentationTimingEXT = 0; - - //=== VK_INTEL_performance_query === - PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; - PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; - PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; - PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0; - PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; - PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; - PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0; - PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0; - PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0; - - //=== VK_AMD_display_native_hdr === - PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; -#else - PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; -#else - PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_fragment_shading_rate === - PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0; - PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0; - - //=== VK_KHR_dynamic_rendering_local_read === - PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR = 0; - PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR = 0; - - //=== VK_EXT_buffer_device_address === - PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0; - - //=== VK_EXT_tooling_info === - PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0; - - //=== VK_KHR_present_wait === - PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0; - - //=== VK_NV_cooperative_matrix === - PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0; - - //=== VK_NV_coverage_reduction_mode === - PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; - PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0; - PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; - PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; -#else - PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; - PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; - PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; - PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0; - - //=== VK_KHR_buffer_device_address === - PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0; - PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0; - PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0; - - //=== VK_EXT_line_rasterization === - PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0; - - //=== VK_EXT_host_query_reset === - PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0; - - //=== VK_EXT_extended_dynamic_state === - PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0; - PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0; - PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0; - PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0; - PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0; - PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0; - PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0; - PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0; - PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0; - PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0; - PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0; - PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0; - - //=== VK_KHR_deferred_host_operations === - PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0; - PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0; - PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0; - PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0; - PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0; - - //=== VK_KHR_pipeline_executable_properties === - PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0; - PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0; - PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0; - - //=== VK_EXT_host_image_copy === - PFN_vkCopyMemoryToImageEXT vkCopyMemoryToImageEXT = 0; - PFN_vkCopyImageToMemoryEXT vkCopyImageToMemoryEXT = 0; - PFN_vkCopyImageToImageEXT vkCopyImageToImageEXT = 0; - PFN_vkTransitionImageLayoutEXT vkTransitionImageLayoutEXT = 0; - PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT = 0; - - //=== VK_KHR_map_memory2 === - PFN_vkMapMemory2KHR vkMapMemory2KHR = 0; - PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR = 0; - - //=== VK_EXT_swapchain_maintenance1 === - PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT = 0; - - //=== VK_NV_device_generated_commands === - PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0; - PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0; - PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0; - PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0; - PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0; - PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0; - - //=== VK_EXT_depth_bias_control === - PFN_vkCmdSetDepthBias2EXT vkCmdSetDepthBias2EXT = 0; - - //=== VK_EXT_acquire_drm_display === - PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0; - PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0; - - //=== VK_EXT_private_data === - PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0; - PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0; - PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0; - PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0; - - //=== VK_KHR_video_encode_queue === - PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 0; - PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR = 0; - PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - PFN_vkCreateCudaModuleNV vkCreateCudaModuleNV = 0; - PFN_vkGetCudaModuleCacheNV vkGetCudaModuleCacheNV = 0; - PFN_vkCreateCudaFunctionNV vkCreateCudaFunctionNV = 0; - PFN_vkDestroyCudaModuleNV vkDestroyCudaModuleNV = 0; - PFN_vkDestroyCudaFunctionNV vkDestroyCudaFunctionNV = 0; - PFN_vkCmdCudaLaunchKernelNV vkCmdCudaLaunchKernelNV = 0; -#else - PFN_dummy vkCreateCudaModuleNV_placeholder = 0; - PFN_dummy vkGetCudaModuleCacheNV_placeholder = 0; - PFN_dummy vkCreateCudaFunctionNV_placeholder = 0; - PFN_dummy vkDestroyCudaModuleNV_placeholder = 0; - PFN_dummy vkDestroyCudaFunctionNV_placeholder = 0; - PFN_dummy vkCmdCudaLaunchKernelNV_placeholder = 0; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - PFN_vkCmdDispatchTileQCOM vkCmdDispatchTileQCOM = 0; - PFN_vkCmdBeginPerTileExecutionQCOM vkCmdBeginPerTileExecutionQCOM = 0; - PFN_vkCmdEndPerTileExecutionQCOM vkCmdEndPerTileExecutionQCOM = 0; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0; -#else - PFN_dummy vkExportMetalObjectsEXT_placeholder = 0; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_synchronization2 === - PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0; - PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0; - PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0; - PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0; - PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0; - PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0; - - //=== VK_EXT_descriptor_buffer === - PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT = 0; - PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT = 0; - PFN_vkGetDescriptorEXT vkGetDescriptorEXT = 0; - PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT = 0; - PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT = 0; - PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 0; - PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT = 0; - PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT = 0; - PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT = 0; - PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT = 0; - PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 0; - - //=== VK_NV_fragment_shading_rate_enums === - PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0; - - //=== VK_EXT_mesh_shader === - PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT = 0; - PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT = 0; - PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = 0; - - //=== VK_KHR_copy_commands2 === - PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0; - PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0; - PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0; - PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0; - PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0; - PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0; - - //=== VK_EXT_device_fault === - PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT = 0; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; - PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; -#else - PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; - PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0; - PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0; -#else - PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_vertex_input_dynamic_state === - PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0; - PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0; -#else - PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; - PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0; - PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0; -#else - PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; - PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0; - PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0; - PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0; - PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0; - PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0; -#else - PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; - PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; - PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; - PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; - PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0; - PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0; - - //=== VK_HUAWEI_invocation_mask === - PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0; - - //=== VK_NV_external_memory_rdma === - PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0; - - //=== VK_EXT_pipeline_properties === - PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT = 0; - - //=== VK_EXT_extended_dynamic_state2 === - PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0; - PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0; - PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0; - PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0; - PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; - PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; -#else - PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_EXT_color_write_enable === - PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0; - - //=== VK_KHR_ray_tracing_maintenance1 === - PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR = 0; - - //=== VK_EXT_multi_draw === - PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0; - PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0; - - //=== VK_EXT_opacity_micromap === - PFN_vkCreateMicromapEXT vkCreateMicromapEXT = 0; - PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT = 0; - PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT = 0; - PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT = 0; - PFN_vkCopyMicromapEXT vkCopyMicromapEXT = 0; - PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT = 0; - PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT = 0; - PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT = 0; - PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT = 0; - PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT = 0; - PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT = 0; - PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT = 0; - PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT = 0; - PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT = 0; - - //=== VK_HUAWEI_cluster_culling_shader === - PFN_vkCmdDrawClusterHUAWEI vkCmdDrawClusterHUAWEI = 0; - PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI = 0; - - //=== VK_EXT_pageable_device_local_memory === - PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0; - - //=== VK_KHR_maintenance4 === - PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0; - PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0; - PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0; - - //=== VK_VALVE_descriptor_set_host_mapping === - PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0; - PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE = 0; - - //=== VK_NV_copy_memory_indirect === - PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV = 0; - PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV = 0; - - //=== VK_NV_memory_decompression === - PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV = 0; - PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV = 0; - - //=== VK_NV_device_generated_commands_compute === - PFN_vkGetPipelineIndirectMemoryRequirementsNV vkGetPipelineIndirectMemoryRequirementsNV = 0; - PFN_vkCmdUpdatePipelineIndirectBufferNV vkCmdUpdatePipelineIndirectBufferNV = 0; - PFN_vkGetPipelineIndirectDeviceAddressNV vkGetPipelineIndirectDeviceAddressNV = 0; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - PFN_vkGetNativeBufferPropertiesOHOS vkGetNativeBufferPropertiesOHOS = 0; - PFN_vkGetMemoryNativeBufferOHOS vkGetMemoryNativeBufferOHOS = 0; -#else - PFN_dummy vkGetNativeBufferPropertiesOHOS_placeholder = 0; - PFN_dummy vkGetMemoryNativeBufferOHOS_placeholder = 0; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_extended_dynamic_state3 === - PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT = 0; - PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT = 0; - PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT = 0; - PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT = 0; - PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT = 0; - PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT = 0; - PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT = 0; - PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT = 0; - PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT = 0; - PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT = 0; - PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT = 0; - PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT = 0; - PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT = 0; - PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT = 0; - PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT = 0; - PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT = 0; - PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT = 0; - PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT = 0; - PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT = 0; - PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT = 0; - PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT = 0; - PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV = 0; - PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV = 0; - PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV = 0; - PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV = 0; - PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV = 0; - PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV = 0; - PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV = 0; - PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV = 0; - PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV = 0; - PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV = 0; - - //=== VK_ARM_tensors === - PFN_vkCreateTensorARM vkCreateTensorARM = 0; - PFN_vkDestroyTensorARM vkDestroyTensorARM = 0; - PFN_vkCreateTensorViewARM vkCreateTensorViewARM = 0; - PFN_vkDestroyTensorViewARM vkDestroyTensorViewARM = 0; - PFN_vkGetTensorMemoryRequirementsARM vkGetTensorMemoryRequirementsARM = 0; - PFN_vkBindTensorMemoryARM vkBindTensorMemoryARM = 0; - PFN_vkGetDeviceTensorMemoryRequirementsARM vkGetDeviceTensorMemoryRequirementsARM = 0; - PFN_vkCmdCopyTensorARM vkCmdCopyTensorARM = 0; - PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM vkGetPhysicalDeviceExternalTensorPropertiesARM = 0; - PFN_vkGetTensorOpaqueCaptureDescriptorDataARM vkGetTensorOpaqueCaptureDescriptorDataARM = 0; - PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM vkGetTensorViewOpaqueCaptureDescriptorDataARM = 0; - - //=== VK_EXT_shader_module_identifier === - PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT = 0; - PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT = 0; - - //=== VK_NV_optical_flow === - PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 0; - PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV = 0; - PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV = 0; - PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV = 0; - PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV = 0; - - //=== VK_KHR_maintenance5 === - PFN_vkCmdBindIndexBuffer2KHR vkCmdBindIndexBuffer2KHR = 0; - PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR = 0; - PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR = 0; - PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR = 0; - - //=== VK_AMD_anti_lag === - PFN_vkAntiLagUpdateAMD vkAntiLagUpdateAMD = 0; - - //=== VK_KHR_present_wait2 === - PFN_vkWaitForPresent2KHR vkWaitForPresent2KHR = 0; - - //=== VK_EXT_shader_object === - PFN_vkCreateShadersEXT vkCreateShadersEXT = 0; - PFN_vkDestroyShaderEXT vkDestroyShaderEXT = 0; - PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0; - PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 0; - PFN_vkCmdSetDepthClampRangeEXT vkCmdSetDepthClampRangeEXT = 0; - - //=== VK_KHR_pipeline_binary === - PFN_vkCreatePipelineBinariesKHR vkCreatePipelineBinariesKHR = 0; - PFN_vkDestroyPipelineBinaryKHR vkDestroyPipelineBinaryKHR = 0; - PFN_vkGetPipelineKeyKHR vkGetPipelineKeyKHR = 0; - PFN_vkGetPipelineBinaryDataKHR vkGetPipelineBinaryDataKHR = 0; - PFN_vkReleaseCapturedPipelineDataKHR vkReleaseCapturedPipelineDataKHR = 0; - - //=== VK_QCOM_tile_properties === - PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0; - PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0; - - //=== VK_KHR_swapchain_maintenance1 === - PFN_vkReleaseSwapchainImagesKHR vkReleaseSwapchainImagesKHR = 0; - - //=== VK_NV_cooperative_vector === - PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV vkGetPhysicalDeviceCooperativeVectorPropertiesNV = 0; - PFN_vkConvertCooperativeVectorMatrixNV vkConvertCooperativeVectorMatrixNV = 0; - PFN_vkCmdConvertCooperativeVectorMatrixNV vkCmdConvertCooperativeVectorMatrixNV = 0; - - //=== VK_NV_low_latency2 === - PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV = 0; - PFN_vkLatencySleepNV vkLatencySleepNV = 0; - PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV = 0; - PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV = 0; - PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV = 0; - - //=== VK_KHR_cooperative_matrix === - PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 0; - - //=== VK_ARM_data_graph === - PFN_vkCreateDataGraphPipelinesARM vkCreateDataGraphPipelinesARM = 0; - PFN_vkCreateDataGraphPipelineSessionARM vkCreateDataGraphPipelineSessionARM = 0; - PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM vkGetDataGraphPipelineSessionBindPointRequirementsARM = 0; - PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM vkGetDataGraphPipelineSessionMemoryRequirementsARM = 0; - PFN_vkBindDataGraphPipelineSessionMemoryARM vkBindDataGraphPipelineSessionMemoryARM = 0; - PFN_vkDestroyDataGraphPipelineSessionARM vkDestroyDataGraphPipelineSessionARM = 0; - PFN_vkCmdDispatchDataGraphARM vkCmdDispatchDataGraphARM = 0; - PFN_vkGetDataGraphPipelineAvailablePropertiesARM vkGetDataGraphPipelineAvailablePropertiesARM = 0; - PFN_vkGetDataGraphPipelinePropertiesARM vkGetDataGraphPipelinePropertiesARM = 0; - PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = 0; - PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = 0; - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT = 0; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX = 0; -#else - PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder = 0; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_KHR_line_rasterization === - PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0; - - //=== VK_KHR_calibrated_timestamps === - PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0; - PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR = 0; - - //=== VK_KHR_maintenance6 === - PFN_vkCmdBindDescriptorSets2KHR vkCmdBindDescriptorSets2KHR = 0; - PFN_vkCmdPushConstants2KHR vkCmdPushConstants2KHR = 0; - PFN_vkCmdPushDescriptorSet2KHR vkCmdPushDescriptorSet2KHR = 0; - PFN_vkCmdPushDescriptorSetWithTemplate2KHR vkCmdPushDescriptorSetWithTemplate2KHR = 0; - PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0; - PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0; - - //=== VK_QCOM_tile_memory_heap === - PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM = 0; - - //=== VK_KHR_copy_memory_indirect === - PFN_vkCmdCopyMemoryIndirectKHR vkCmdCopyMemoryIndirectKHR = 0; - PFN_vkCmdCopyMemoryToImageIndirectKHR vkCmdCopyMemoryToImageIndirectKHR = 0; - - //=== VK_EXT_memory_decompression === - PFN_vkCmdDecompressMemoryEXT vkCmdDecompressMemoryEXT = 0; - PFN_vkCmdDecompressMemoryIndirectCountEXT vkCmdDecompressMemoryIndirectCountEXT = 0; - - //=== VK_NV_external_compute_queue === - PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0; - PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0; - PFN_vkGetExternalComputeQueueDataNV vkGetExternalComputeQueueDataNV = 0; - - //=== VK_NV_cluster_acceleration_structure === - PFN_vkGetClusterAccelerationStructureBuildSizesNV vkGetClusterAccelerationStructureBuildSizesNV = 0; - PFN_vkCmdBuildClusterAccelerationStructureIndirectNV vkCmdBuildClusterAccelerationStructureIndirectNV = 0; - - //=== VK_NV_partitioned_acceleration_structure === - PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV vkGetPartitionedAccelerationStructuresBuildSizesNV = 0; - PFN_vkCmdBuildPartitionedAccelerationStructuresNV vkCmdBuildPartitionedAccelerationStructuresNV = 0; - - //=== VK_EXT_device_generated_commands === - PFN_vkGetGeneratedCommandsMemoryRequirementsEXT vkGetGeneratedCommandsMemoryRequirementsEXT = 0; - PFN_vkCmdPreprocessGeneratedCommandsEXT vkCmdPreprocessGeneratedCommandsEXT = 0; - PFN_vkCmdExecuteGeneratedCommandsEXT vkCmdExecuteGeneratedCommandsEXT = 0; - PFN_vkCreateIndirectCommandsLayoutEXT vkCreateIndirectCommandsLayoutEXT = 0; - PFN_vkDestroyIndirectCommandsLayoutEXT vkDestroyIndirectCommandsLayoutEXT = 0; - PFN_vkCreateIndirectExecutionSetEXT vkCreateIndirectExecutionSetEXT = 0; - PFN_vkDestroyIndirectExecutionSetEXT vkDestroyIndirectExecutionSetEXT = 0; - PFN_vkUpdateIndirectExecutionSetPipelineEXT vkUpdateIndirectExecutionSetPipelineEXT = 0; - PFN_vkUpdateIndirectExecutionSetShaderEXT vkUpdateIndirectExecutionSetShaderEXT = 0; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS = 0; -#else - PFN_dummy vkCreateSurfaceOHOS_placeholder = 0; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_NV_cooperative_matrix2 === - PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = 0; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - PFN_vkGetMemoryMetalHandleEXT vkGetMemoryMetalHandleEXT = 0; - PFN_vkGetMemoryMetalHandlePropertiesEXT vkGetMemoryMetalHandlePropertiesEXT = 0; -#else - PFN_dummy vkGetMemoryMetalHandleEXT_placeholder = 0; - PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder = 0; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_ARM_performance_counters_by_region === - PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = 0; - - //=== VK_EXT_fragment_density_map_offset === - PFN_vkCmdEndRendering2EXT vkCmdEndRendering2EXT = 0; - - //=== VK_EXT_custom_resolve === - PFN_vkCmdBeginCustomResolveEXT vkCmdBeginCustomResolveEXT = 0; - - //=== VK_KHR_maintenance10 === - PFN_vkCmdEndRendering2KHR vkCmdEndRendering2KHR = 0; - - //=== VK_NV_compute_occupancy_priority === - PFN_vkCmdSetComputeOccupancyPriorityNV vkCmdSetComputeOccupancyPriorityNV = 0; - - public: - DispatchLoaderDynamic() VULKAN_HPP_NOEXCEPT = default; - DispatchLoaderDynamic( DispatchLoaderDynamic const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DispatchLoaderDynamic( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT - { - init( getInstanceProcAddr ); - } - - // This interface does not require a linked vulkan library. - DispatchLoaderDynamic( VkInstance instance, - PFN_vkGetInstanceProcAddr getInstanceProcAddr, - VkDevice device = {}, - PFN_vkGetDeviceProcAddr getDeviceProcAddr = nullptr ) VULKAN_HPP_NOEXCEPT - { - init( instance, getInstanceProcAddr, device, getDeviceProcAddr ); - } - - template - void init() - { - static DynamicLoader dl; - init( dl ); - } - - template - void init( DynamicLoader const & dl ) VULKAN_HPP_NOEXCEPT - { - PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress( "vkGetInstanceProcAddr" ); - init( getInstanceProcAddr ); - } - - void init( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getInstanceProcAddr ); - - vkGetInstanceProcAddr = getInstanceProcAddr; - - //=== VK_VERSION_1_0 === - vkCreateInstance = PFN_vkCreateInstance( vkGetInstanceProcAddr( NULL, "vkCreateInstance" ) ); - vkEnumerateInstanceExtensionProperties = - PFN_vkEnumerateInstanceExtensionProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) ); - vkEnumerateInstanceLayerProperties = PFN_vkEnumerateInstanceLayerProperties( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) ); - - //=== VK_VERSION_1_1 === - vkEnumerateInstanceVersion = PFN_vkEnumerateInstanceVersion( vkGetInstanceProcAddr( NULL, "vkEnumerateInstanceVersion" ) ); - } - - // This interface does not require a linked vulkan library. - void init( VkInstance instance, - PFN_vkGetInstanceProcAddr getInstanceProcAddr, - VkDevice device = {}, - PFN_vkGetDeviceProcAddr /*getDeviceProcAddr*/ = nullptr ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( instance && getInstanceProcAddr ); - vkGetInstanceProcAddr = getInstanceProcAddr; - init( Instance( instance ) ); - if ( device ) - { - init( Device( device ) ); - } - } - - void init( Instance instanceCpp ) VULKAN_HPP_NOEXCEPT - { - VkInstance instance = static_cast( instanceCpp ); - - //=== VK_VERSION_1_0 === - vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) ); - vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) ); - vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) ); - vkGetPhysicalDeviceFormatProperties = - PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) ); - vkGetPhysicalDeviceImageFormatProperties = - PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) ); - vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) ); - vkGetPhysicalDeviceQueueFamilyProperties = - PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) ); - vkGetPhysicalDeviceMemoryProperties = - PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) ); - vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) ); - vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) ); - vkDestroyDevice = PFN_vkDestroyDevice( vkGetInstanceProcAddr( instance, "vkDestroyDevice" ) ); - vkEnumerateDeviceExtensionProperties = - PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) ); - vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) ); - vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue" ) ); - vkQueueSubmit = PFN_vkQueueSubmit( vkGetInstanceProcAddr( instance, "vkQueueSubmit" ) ); - vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetInstanceProcAddr( instance, "vkQueueWaitIdle" ) ); - vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetInstanceProcAddr( instance, "vkDeviceWaitIdle" ) ); - vkAllocateMemory = PFN_vkAllocateMemory( vkGetInstanceProcAddr( instance, "vkAllocateMemory" ) ); - vkFreeMemory = PFN_vkFreeMemory( vkGetInstanceProcAddr( instance, "vkFreeMemory" ) ); - vkMapMemory = PFN_vkMapMemory( vkGetInstanceProcAddr( instance, "vkMapMemory" ) ); - vkUnmapMemory = PFN_vkUnmapMemory( vkGetInstanceProcAddr( instance, "vkUnmapMemory" ) ); - vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkFlushMappedMemoryRanges" ) ); - vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetInstanceProcAddr( instance, "vkInvalidateMappedMemoryRanges" ) ); - vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryCommitment" ) ); - vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetInstanceProcAddr( instance, "vkBindBufferMemory" ) ); - vkBindImageMemory = PFN_vkBindImageMemory( vkGetInstanceProcAddr( instance, "vkBindImageMemory" ) ); - vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements" ) ); - vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements" ) ); - vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements" ) ); - vkGetPhysicalDeviceSparseImageFormatProperties = - PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) ); - vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetInstanceProcAddr( instance, "vkQueueBindSparse" ) ); - vkCreateFence = PFN_vkCreateFence( vkGetInstanceProcAddr( instance, "vkCreateFence" ) ); - vkDestroyFence = PFN_vkDestroyFence( vkGetInstanceProcAddr( instance, "vkDestroyFence" ) ); - vkResetFences = PFN_vkResetFences( vkGetInstanceProcAddr( instance, "vkResetFences" ) ); - vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetInstanceProcAddr( instance, "vkGetFenceStatus" ) ); - vkWaitForFences = PFN_vkWaitForFences( vkGetInstanceProcAddr( instance, "vkWaitForFences" ) ); - vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetInstanceProcAddr( instance, "vkCreateSemaphore" ) ); - vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetInstanceProcAddr( instance, "vkDestroySemaphore" ) ); - vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetInstanceProcAddr( instance, "vkCreateQueryPool" ) ); - vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetInstanceProcAddr( instance, "vkDestroyQueryPool" ) ); - vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetInstanceProcAddr( instance, "vkGetQueryPoolResults" ) ); - vkCreateBuffer = PFN_vkCreateBuffer( vkGetInstanceProcAddr( instance, "vkCreateBuffer" ) ); - vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetInstanceProcAddr( instance, "vkDestroyBuffer" ) ); - vkCreateImage = PFN_vkCreateImage( vkGetInstanceProcAddr( instance, "vkCreateImage" ) ); - vkDestroyImage = PFN_vkDestroyImage( vkGetInstanceProcAddr( instance, "vkDestroyImage" ) ); - vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout" ) ); - vkCreateImageView = PFN_vkCreateImageView( vkGetInstanceProcAddr( instance, "vkCreateImageView" ) ); - vkDestroyImageView = PFN_vkDestroyImageView( vkGetInstanceProcAddr( instance, "vkDestroyImageView" ) ); - vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetInstanceProcAddr( instance, "vkCreateCommandPool" ) ); - vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetInstanceProcAddr( instance, "vkDestroyCommandPool" ) ); - vkResetCommandPool = PFN_vkResetCommandPool( vkGetInstanceProcAddr( instance, "vkResetCommandPool" ) ); - vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetInstanceProcAddr( instance, "vkAllocateCommandBuffers" ) ); - vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetInstanceProcAddr( instance, "vkFreeCommandBuffers" ) ); - vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetInstanceProcAddr( instance, "vkBeginCommandBuffer" ) ); - vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetInstanceProcAddr( instance, "vkEndCommandBuffer" ) ); - vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetInstanceProcAddr( instance, "vkResetCommandBuffer" ) ); - vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer" ) ); - vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetInstanceProcAddr( instance, "vkCmdCopyImage" ) ); - vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage" ) ); - vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer" ) ); - vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetInstanceProcAddr( instance, "vkCmdUpdateBuffer" ) ); - vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetInstanceProcAddr( instance, "vkCmdFillBuffer" ) ); - vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier" ) ); - vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetInstanceProcAddr( instance, "vkCmdBeginQuery" ) ); - vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetInstanceProcAddr( instance, "vkCmdEndQuery" ) ); - vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetInstanceProcAddr( instance, "vkCmdResetQueryPool" ) ); - vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp" ) ); - vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetInstanceProcAddr( instance, "vkCmdCopyQueryPoolResults" ) ); - vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetInstanceProcAddr( instance, "vkCmdExecuteCommands" ) ); - vkCreateEvent = PFN_vkCreateEvent( vkGetInstanceProcAddr( instance, "vkCreateEvent" ) ); - vkDestroyEvent = PFN_vkDestroyEvent( vkGetInstanceProcAddr( instance, "vkDestroyEvent" ) ); - vkGetEventStatus = PFN_vkGetEventStatus( vkGetInstanceProcAddr( instance, "vkGetEventStatus" ) ); - vkSetEvent = PFN_vkSetEvent( vkGetInstanceProcAddr( instance, "vkSetEvent" ) ); - vkResetEvent = PFN_vkResetEvent( vkGetInstanceProcAddr( instance, "vkResetEvent" ) ); - vkCreateBufferView = PFN_vkCreateBufferView( vkGetInstanceProcAddr( instance, "vkCreateBufferView" ) ); - vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetInstanceProcAddr( instance, "vkDestroyBufferView" ) ); - vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetInstanceProcAddr( instance, "vkCreateShaderModule" ) ); - vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetInstanceProcAddr( instance, "vkDestroyShaderModule" ) ); - vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetInstanceProcAddr( instance, "vkCreatePipelineCache" ) ); - vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetInstanceProcAddr( instance, "vkDestroyPipelineCache" ) ); - vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetInstanceProcAddr( instance, "vkGetPipelineCacheData" ) ); - vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetInstanceProcAddr( instance, "vkMergePipelineCaches" ) ); - vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetInstanceProcAddr( instance, "vkCreateComputePipelines" ) ); - vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetInstanceProcAddr( instance, "vkDestroyPipeline" ) ); - vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetInstanceProcAddr( instance, "vkCreatePipelineLayout" ) ); - vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetInstanceProcAddr( instance, "vkDestroyPipelineLayout" ) ); - vkCreateSampler = PFN_vkCreateSampler( vkGetInstanceProcAddr( instance, "vkCreateSampler" ) ); - vkDestroySampler = PFN_vkDestroySampler( vkGetInstanceProcAddr( instance, "vkDestroySampler" ) ); - vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkCreateDescriptorSetLayout" ) ); - vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorSetLayout" ) ); - vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetInstanceProcAddr( instance, "vkCreateDescriptorPool" ) ); - vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorPool" ) ); - vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetInstanceProcAddr( instance, "vkResetDescriptorPool" ) ); - vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetInstanceProcAddr( instance, "vkAllocateDescriptorSets" ) ); - vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetInstanceProcAddr( instance, "vkFreeDescriptorSets" ) ); - vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSets" ) ); - vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetInstanceProcAddr( instance, "vkCmdBindPipeline" ) ); - vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets" ) ); - vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetInstanceProcAddr( instance, "vkCmdClearColorImage" ) ); - vkCmdDispatch = PFN_vkCmdDispatch( vkGetInstanceProcAddr( instance, "vkCmdDispatch" ) ); - vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetInstanceProcAddr( instance, "vkCmdDispatchIndirect" ) ); - vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetInstanceProcAddr( instance, "vkCmdSetEvent" ) ); - vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetInstanceProcAddr( instance, "vkCmdResetEvent" ) ); - vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents" ) ); - vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetInstanceProcAddr( instance, "vkCmdPushConstants" ) ); - vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetInstanceProcAddr( instance, "vkCreateGraphicsPipelines" ) ); - vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetInstanceProcAddr( instance, "vkCreateFramebuffer" ) ); - vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetInstanceProcAddr( instance, "vkDestroyFramebuffer" ) ); - vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetInstanceProcAddr( instance, "vkCreateRenderPass" ) ); - vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetInstanceProcAddr( instance, "vkDestroyRenderPass" ) ); - vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderAreaGranularity" ) ); - vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetInstanceProcAddr( instance, "vkCmdSetViewport" ) ); - vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetInstanceProcAddr( instance, "vkCmdSetScissor" ) ); - vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetInstanceProcAddr( instance, "vkCmdSetLineWidth" ) ); - vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias" ) ); - vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetInstanceProcAddr( instance, "vkCmdSetBlendConstants" ) ); - vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBounds" ) ); - vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilCompareMask" ) ); - vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetInstanceProcAddr( instance, "vkCmdSetStencilWriteMask" ) ); - vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetInstanceProcAddr( instance, "vkCmdSetStencilReference" ) ); - vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer" ) ); - vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers" ) ); - vkCmdDraw = PFN_vkCmdDraw( vkGetInstanceProcAddr( instance, "vkCmdDraw" ) ); - vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexed" ) ); - vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirect" ) ); - vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirect" ) ); - vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetInstanceProcAddr( instance, "vkCmdBlitImage" ) ); - vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetInstanceProcAddr( instance, "vkCmdClearDepthStencilImage" ) ); - vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetInstanceProcAddr( instance, "vkCmdClearAttachments" ) ); - vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetInstanceProcAddr( instance, "vkCmdResolveImage" ) ); - vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass" ) ); - vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass" ) ); - vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass" ) ); - - //=== VK_VERSION_1_1 === - vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2" ) ); - vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetInstanceProcAddr( instance, "vkBindImageMemory2" ) ); - vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeatures" ) ); - vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMask" ) ); - vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) ); - vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2" ) ); - vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2" ) ); - vkGetImageSparseMemoryRequirements2 = - PFN_vkGetImageSparseMemoryRequirements2( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2" ) ); - vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) ); - vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) ); - vkGetPhysicalDeviceFormatProperties2 = - PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) ); - vkGetPhysicalDeviceImageFormatProperties2 = - PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) ); - vkGetPhysicalDeviceQueueFamilyProperties2 = - PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) ); - vkGetPhysicalDeviceMemoryProperties2 = - PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) ); - vkGetPhysicalDeviceSparseImageFormatProperties2 = - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) ); - vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetInstanceProcAddr( instance, "vkTrimCommandPool" ) ); - vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetInstanceProcAddr( instance, "vkGetDeviceQueue2" ) ); - vkGetPhysicalDeviceExternalBufferProperties = - PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) ); - vkGetPhysicalDeviceExternalFenceProperties = - PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) ); - vkGetPhysicalDeviceExternalSemaphoreProperties = - PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) ); - vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetInstanceProcAddr( instance, "vkCmdDispatchBase" ) ); - vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplate" ) ); - vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplate" ) ); - vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplate" ) ); - vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupport" ) ); - vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversion" ) ); - vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversion" ) ); - - //=== VK_VERSION_1_2 === - vkResetQueryPool = PFN_vkResetQueryPool( vkGetInstanceProcAddr( instance, "vkResetQueryPool" ) ); - vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValue" ) ); - vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetInstanceProcAddr( instance, "vkWaitSemaphores" ) ); - vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetInstanceProcAddr( instance, "vkSignalSemaphore" ) ); - vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddress" ) ); - vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddress" ) ); - vkGetDeviceMemoryOpaqueCaptureAddress = - PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddress" ) ); - vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCount" ) ); - vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCount" ) ); - vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2" ) ); - vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2" ) ); - vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2" ) ); - vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2" ) ); - - //=== VK_VERSION_1_3 === - vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) ); - vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlot" ) ); - vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlot" ) ); - vkSetPrivateData = PFN_vkSetPrivateData( vkGetInstanceProcAddr( instance, "vkSetPrivateData" ) ); - vkGetPrivateData = PFN_vkGetPrivateData( vkGetInstanceProcAddr( instance, "vkGetPrivateData" ) ); - vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2" ) ); - vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2" ) ); - vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetInstanceProcAddr( instance, "vkQueueSubmit2" ) ); - vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2" ) ); - vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2" ) ); - vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2" ) ); - vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2" ) ); - vkGetDeviceBufferMemoryRequirements = - PFN_vkGetDeviceBufferMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirements" ) ); - vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirements" ) ); - vkGetDeviceImageSparseMemoryRequirements = - PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirements" ) ); - vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2" ) ); - vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2" ) ); - vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2" ) ); - vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2" ) ); - vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2" ) ); - vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetInstanceProcAddr( instance, "vkCmdBeginRendering" ) ); - vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetInstanceProcAddr( instance, "vkCmdEndRendering" ) ); - vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetInstanceProcAddr( instance, "vkCmdSetCullMode" ) ); - vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFace" ) ); - vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopology" ) ); - vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCount" ) ); - vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCount" ) ); - vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2" ) ); - vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnable" ) ); - vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnable" ) ); - vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOp" ) ); - vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnable" ) ); - vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnable" ) ); - vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOp" ) ); - vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnable" ) ); - vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnable" ) ); - vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnable" ) ); - - //=== VK_VERSION_1_4 === - vkMapMemory2 = PFN_vkMapMemory2( vkGetInstanceProcAddr( instance, "vkMapMemory2" ) ); - vkUnmapMemory2 = PFN_vkUnmapMemory2( vkGetInstanceProcAddr( instance, "vkUnmapMemory2" ) ); - vkGetDeviceImageSubresourceLayout = PFN_vkGetDeviceImageSubresourceLayout( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSubresourceLayout" ) ); - vkGetImageSubresourceLayout2 = PFN_vkGetImageSubresourceLayout2( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2" ) ); - vkCopyMemoryToImage = PFN_vkCopyMemoryToImage( vkGetInstanceProcAddr( instance, "vkCopyMemoryToImage" ) ); - vkCopyImageToMemory = PFN_vkCopyImageToMemory( vkGetInstanceProcAddr( instance, "vkCopyImageToMemory" ) ); - vkCopyImageToImage = PFN_vkCopyImageToImage( vkGetInstanceProcAddr( instance, "vkCopyImageToImage" ) ); - vkTransitionImageLayout = PFN_vkTransitionImageLayout( vkGetInstanceProcAddr( instance, "vkTransitionImageLayout" ) ); - vkCmdPushDescriptorSet = PFN_vkCmdPushDescriptorSet( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSet" ) ); - vkCmdPushDescriptorSetWithTemplate = PFN_vkCmdPushDescriptorSetWithTemplate( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplate" ) ); - vkCmdBindDescriptorSets2 = PFN_vkCmdBindDescriptorSets2( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets2" ) ); - vkCmdPushConstants2 = PFN_vkCmdPushConstants2( vkGetInstanceProcAddr( instance, "vkCmdPushConstants2" ) ); - vkCmdPushDescriptorSet2 = PFN_vkCmdPushDescriptorSet2( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSet2" ) ); - vkCmdPushDescriptorSetWithTemplate2 = - PFN_vkCmdPushDescriptorSetWithTemplate2( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplate2" ) ); - vkCmdSetLineStipple = PFN_vkCmdSetLineStipple( vkGetInstanceProcAddr( instance, "vkCmdSetLineStipple" ) ); - vkCmdBindIndexBuffer2 = PFN_vkCmdBindIndexBuffer2( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer2" ) ); - vkGetRenderingAreaGranularity = PFN_vkGetRenderingAreaGranularity( vkGetInstanceProcAddr( instance, "vkGetRenderingAreaGranularity" ) ); - vkCmdSetRenderingAttachmentLocations = - PFN_vkCmdSetRenderingAttachmentLocations( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingAttachmentLocations" ) ); - vkCmdSetRenderingInputAttachmentIndices = - PFN_vkCmdSetRenderingInputAttachmentIndices( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingInputAttachmentIndices" ) ); - - //=== VK_KHR_surface === - vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) ); - vkGetPhysicalDeviceSurfaceSupportKHR = - PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) ); - vkGetPhysicalDeviceSurfaceCapabilitiesKHR = - PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) ); - vkGetPhysicalDeviceSurfaceFormatsKHR = - PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) ); - vkGetPhysicalDeviceSurfacePresentModesKHR = - PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) ); - - //=== VK_KHR_swapchain === - vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetInstanceProcAddr( instance, "vkCreateSwapchainKHR" ) ); - vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetInstanceProcAddr( instance, "vkDestroySwapchainKHR" ) ); - vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainImagesKHR" ) ); - vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImageKHR" ) ); - vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetInstanceProcAddr( instance, "vkQueuePresentKHR" ) ); - vkGetDeviceGroupPresentCapabilitiesKHR = - PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); - vkGetDeviceGroupSurfacePresentModesKHR = - PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); - vkGetPhysicalDevicePresentRectanglesKHR = - PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) ); - vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetInstanceProcAddr( instance, "vkAcquireNextImage2KHR" ) ); - - //=== VK_KHR_display === - vkGetPhysicalDeviceDisplayPropertiesKHR = - PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) ); - vkGetPhysicalDeviceDisplayPlanePropertiesKHR = - PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) ); - vkGetDisplayPlaneSupportedDisplaysKHR = - PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) ); - vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) ); - vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) ); - vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) ); - vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) ); - - //=== VK_KHR_display_swapchain === - vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetInstanceProcAddr( instance, "vkCreateSharedSwapchainsKHR" ) ); - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) ); - vkGetPhysicalDeviceXlibPresentationSupportKHR = - PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) ); -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) ); - vkGetPhysicalDeviceXcbPresentationSupportKHR = - PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) ); -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) ); - vkGetPhysicalDeviceWaylandPresentationSupportKHR = - PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) ); -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) ); -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) ); - vkGetPhysicalDeviceWin32PresentationSupportKHR = - PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) ); - vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) ); - vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) ); - - //=== VK_EXT_debug_marker === - vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectTagEXT" ) ); - vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetInstanceProcAddr( instance, "vkDebugMarkerSetObjectNameEXT" ) ); - vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerBeginEXT" ) ); - vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerEndEXT" ) ); - vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetInstanceProcAddr( instance, "vkCmdDebugMarkerInsertEXT" ) ); - - //=== VK_KHR_video_queue === - vkGetPhysicalDeviceVideoCapabilitiesKHR = - PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) ); - vkGetPhysicalDeviceVideoFormatPropertiesKHR = - PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) ); - vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionKHR" ) ); - vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionKHR" ) ); - vkGetVideoSessionMemoryRequirementsKHR = - PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetVideoSessionMemoryRequirementsKHR" ) ); - vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetInstanceProcAddr( instance, "vkBindVideoSessionMemoryKHR" ) ); - vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkCreateVideoSessionParametersKHR" ) ); - vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkUpdateVideoSessionParametersKHR" ) ); - vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkDestroyVideoSessionParametersKHR" ) ); - vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginVideoCodingKHR" ) ); - vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndVideoCodingKHR" ) ); - vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetInstanceProcAddr( instance, "vkCmdControlVideoCodingKHR" ) ); - - //=== VK_KHR_video_decode_queue === - vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdDecodeVideoKHR" ) ); - - //=== VK_EXT_transform_feedback === - vkCmdBindTransformFeedbackBuffersEXT = - PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindTransformFeedbackBuffersEXT" ) ); - vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginTransformFeedbackEXT" ) ); - vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetInstanceProcAddr( instance, "vkCmdEndTransformFeedbackEXT" ) ); - vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginQueryIndexedEXT" ) ); - vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdEndQueryIndexedEXT" ) ); - vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectByteCountEXT" ) ); - - //=== VK_NVX_binary_import === - vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetInstanceProcAddr( instance, "vkCreateCuModuleNVX" ) ); - vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkCreateCuFunctionNVX" ) ); - vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuModuleNVX" ) ); - vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetInstanceProcAddr( instance, "vkDestroyCuFunctionNVX" ) ); - vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetInstanceProcAddr( instance, "vkCmdCuLaunchKernelNVX" ) ); - - //=== VK_NVX_image_view_handle === - vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandleNVX" ) ); - vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetInstanceProcAddr( instance, "vkGetImageViewHandle64NVX" ) ); - vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetInstanceProcAddr( instance, "vkGetImageViewAddressNVX" ) ); - vkGetDeviceCombinedImageSamplerIndexNVX = - PFN_vkGetDeviceCombinedImageSamplerIndexNVX( vkGetInstanceProcAddr( instance, "vkGetDeviceCombinedImageSamplerIndexNVX" ) ); - - //=== VK_AMD_draw_indirect_count === - vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountAMD" ) ); - if ( !vkCmdDrawIndirectCount ) - vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; - vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountAMD" ) ); - if ( !vkCmdDrawIndexedIndirectCount ) - vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; - - //=== VK_AMD_shader_info === - vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetInstanceProcAddr( instance, "vkGetShaderInfoAMD" ) ); - - //=== VK_KHR_dynamic_rendering === - vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderingKHR" ) ); - if ( !vkCmdBeginRendering ) - vkCmdBeginRendering = vkCmdBeginRenderingKHR; - vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderingKHR" ) ); - if ( !vkCmdEndRendering ) - vkCmdEndRendering = vkCmdEndRenderingKHR; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - vkCreateStreamDescriptorSurfaceGGP = PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) ); -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - vkGetPhysicalDeviceExternalImageFormatPropertiesNV = - PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) ); - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleNV" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_get_physical_device_properties2 === - vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) ); - if ( !vkGetPhysicalDeviceFeatures2 ) - vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR; - vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceProperties2 ) - vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR; - vkGetPhysicalDeviceFormatProperties2KHR = - PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceFormatProperties2 ) - vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR; - vkGetPhysicalDeviceImageFormatProperties2KHR = - PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceImageFormatProperties2 ) - vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR; - vkGetPhysicalDeviceQueueFamilyProperties2KHR = - PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceQueueFamilyProperties2 ) - vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR; - vkGetPhysicalDeviceMemoryProperties2KHR = - PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceMemoryProperties2 ) - vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR; - vkGetPhysicalDeviceSparseImageFormatProperties2KHR = - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceSparseImageFormatProperties2 ) - vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR; - - //=== VK_KHR_device_group === - vkGetDeviceGroupPeerMemoryFeaturesKHR = - PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); - if ( !vkGetDeviceGroupPeerMemoryFeatures ) - vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; - vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetInstanceProcAddr( instance, "vkCmdSetDeviceMaskKHR" ) ); - if ( !vkCmdSetDeviceMask ) - vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; - vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetInstanceProcAddr( instance, "vkCmdDispatchBaseKHR" ) ); - if ( !vkCmdDispatchBase ) - vkCmdDispatchBase = vkCmdDispatchBaseKHR; - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) ); -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_maintenance1 === - vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetInstanceProcAddr( instance, "vkTrimCommandPoolKHR" ) ); - if ( !vkTrimCommandPool ) - vkTrimCommandPool = vkTrimCommandPoolKHR; - - //=== VK_KHR_device_group_creation === - vkEnumeratePhysicalDeviceGroupsKHR = PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) ); - if ( !vkEnumeratePhysicalDeviceGroups ) - vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR; - - //=== VK_KHR_external_memory_capabilities === - vkGetPhysicalDeviceExternalBufferPropertiesKHR = - PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) ); - if ( !vkGetPhysicalDeviceExternalBufferProperties ) - vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandleKHR" ) ); - vkGetMemoryWin32HandlePropertiesKHR = - PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryWin32HandlePropertiesKHR" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdKHR" ) ); - vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetMemoryFdPropertiesKHR" ) ); - - //=== VK_KHR_external_semaphore_capabilities === - vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = - PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) ); - if ( !vkGetPhysicalDeviceExternalSemaphoreProperties ) - vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreWin32HandleKHR" ) ); - vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreWin32HandleKHR" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkImportSemaphoreFdKHR" ) ); - vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreFdKHR" ) ); - - //=== VK_KHR_push_descriptor === - vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetKHR" ) ); - if ( !vkCmdPushDescriptorSet ) - vkCmdPushDescriptorSet = vkCmdPushDescriptorSetKHR; - vkCmdPushDescriptorSetWithTemplateKHR = - PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplateKHR" ) ); - if ( !vkCmdPushDescriptorSetWithTemplate ) - vkCmdPushDescriptorSetWithTemplate = vkCmdPushDescriptorSetWithTemplateKHR; - - //=== VK_EXT_conditional_rendering === - vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginConditionalRenderingEXT" ) ); - vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetInstanceProcAddr( instance, "vkCmdEndConditionalRenderingEXT" ) ); - - //=== VK_KHR_descriptor_update_template === - vkCreateDescriptorUpdateTemplateKHR = - PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkCreateDescriptorUpdateTemplateKHR" ) ); - if ( !vkCreateDescriptorUpdateTemplate ) - vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; - vkDestroyDescriptorUpdateTemplateKHR = - PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetInstanceProcAddr( instance, "vkDestroyDescriptorUpdateTemplateKHR" ) ); - if ( !vkDestroyDescriptorUpdateTemplate ) - vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; - vkUpdateDescriptorSetWithTemplateKHR = - PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetInstanceProcAddr( instance, "vkUpdateDescriptorSetWithTemplateKHR" ) ); - if ( !vkUpdateDescriptorSetWithTemplate ) - vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; - - //=== VK_NV_clip_space_w_scaling === - vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingNV" ) ); - - //=== VK_EXT_direct_mode_display === - vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) ); - -#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) ); - vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) ); -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - vkGetPhysicalDeviceSurfaceCapabilities2EXT = - PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) ); - - //=== VK_EXT_display_control === - vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetInstanceProcAddr( instance, "vkDisplayPowerControlEXT" ) ); - vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDeviceEventEXT" ) ); - vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetInstanceProcAddr( instance, "vkRegisterDisplayEventEXT" ) ); - vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainCounterEXT" ) ); - - //=== VK_GOOGLE_display_timing === - vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetInstanceProcAddr( instance, "vkGetRefreshCycleDurationGOOGLE" ) ); - vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingGOOGLE" ) ); - - //=== VK_EXT_discard_rectangles === - vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEXT" ) ); - vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleEnableEXT" ) ); - vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDiscardRectangleModeEXT" ) ); - - //=== VK_EXT_hdr_metadata === - vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetInstanceProcAddr( instance, "vkSetHdrMetadataEXT" ) ); - - //=== VK_KHR_create_renderpass2 === - vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCreateRenderPass2KHR" ) ); - if ( !vkCreateRenderPass2 ) - vkCreateRenderPass2 = vkCreateRenderPass2KHR; - vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdBeginRenderPass2KHR" ) ); - if ( !vkCmdBeginRenderPass2 ) - vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; - vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetInstanceProcAddr( instance, "vkCmdNextSubpass2KHR" ) ); - if ( !vkCmdNextSubpass2 ) - vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; - vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRenderPass2KHR" ) ); - if ( !vkCmdEndRenderPass2 ) - vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; - - //=== VK_KHR_shared_presentable_image === - vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetInstanceProcAddr( instance, "vkGetSwapchainStatusKHR" ) ); - - //=== VK_KHR_external_fence_capabilities === - vkGetPhysicalDeviceExternalFencePropertiesKHR = - PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) ); - if ( !vkGetPhysicalDeviceExternalFenceProperties ) - vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkImportFenceWin32HandleKHR" ) ); - vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetInstanceProcAddr( instance, "vkGetFenceWin32HandleKHR" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetInstanceProcAddr( instance, "vkImportFenceFdKHR" ) ); - vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetInstanceProcAddr( instance, "vkGetFenceFdKHR" ) ); - - //=== VK_KHR_performance_query === - vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) ); - vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( - vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) ); - vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkAcquireProfilingLockKHR" ) ); - vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetInstanceProcAddr( instance, "vkReleaseProfilingLockKHR" ) ); - - //=== VK_KHR_get_surface_capabilities2 === - vkGetPhysicalDeviceSurfaceCapabilities2KHR = - PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) ); - vkGetPhysicalDeviceSurfaceFormats2KHR = - PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) ); - - //=== VK_KHR_get_display_properties2 === - vkGetPhysicalDeviceDisplayProperties2KHR = - PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) ); - vkGetPhysicalDeviceDisplayPlaneProperties2KHR = - PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) ); - vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) ); - vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) ); - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) ); -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) ); -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectNameEXT" ) ); - vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetInstanceProcAddr( instance, "vkSetDebugUtilsObjectTagEXT" ) ); - vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueBeginDebugUtilsLabelEXT" ) ); - vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueEndDebugUtilsLabelEXT" ) ); - vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkQueueInsertDebugUtilsLabelEXT" ) ); - vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginDebugUtilsLabelEXT" ) ); - vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdEndDebugUtilsLabelEXT" ) ); - vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetInstanceProcAddr( instance, "vkCmdInsertDebugUtilsLabelEXT" ) ); - vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) ); - vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) ); - vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) ); - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - vkGetAndroidHardwareBufferPropertiesANDROID = - PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetInstanceProcAddr( instance, "vkGetAndroidHardwareBufferPropertiesANDROID" ) ); - vkGetMemoryAndroidHardwareBufferANDROID = - PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetInstanceProcAddr( instance, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - vkCreateExecutionGraphPipelinesAMDX = - PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetInstanceProcAddr( instance, "vkCreateExecutionGraphPipelinesAMDX" ) ); - vkGetExecutionGraphPipelineScratchSizeAMDX = - PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetInstanceProcAddr( instance, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) ); - vkGetExecutionGraphPipelineNodeIndexAMDX = - PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetInstanceProcAddr( instance, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) ); - vkCmdInitializeGraphScratchMemoryAMDX = - PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetInstanceProcAddr( instance, "vkCmdInitializeGraphScratchMemoryAMDX" ) ); - vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphAMDX" ) ); - vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphIndirectAMDX" ) ); - vkCmdDispatchGraphIndirectCountAMDX = - PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetInstanceProcAddr( instance, "vkCmdDispatchGraphIndirectCountAMDX" ) ); -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - vkWriteSamplerDescriptorsEXT = PFN_vkWriteSamplerDescriptorsEXT( vkGetInstanceProcAddr( instance, "vkWriteSamplerDescriptorsEXT" ) ); - vkWriteResourceDescriptorsEXT = PFN_vkWriteResourceDescriptorsEXT( vkGetInstanceProcAddr( instance, "vkWriteResourceDescriptorsEXT" ) ); - vkCmdBindSamplerHeapEXT = PFN_vkCmdBindSamplerHeapEXT( vkGetInstanceProcAddr( instance, "vkCmdBindSamplerHeapEXT" ) ); - vkCmdBindResourceHeapEXT = PFN_vkCmdBindResourceHeapEXT( vkGetInstanceProcAddr( instance, "vkCmdBindResourceHeapEXT" ) ); - vkCmdPushDataEXT = PFN_vkCmdPushDataEXT( vkGetInstanceProcAddr( instance, "vkCmdPushDataEXT" ) ); - vkGetImageOpaqueCaptureDataEXT = PFN_vkGetImageOpaqueCaptureDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageOpaqueCaptureDataEXT" ) ); - vkGetPhysicalDeviceDescriptorSizeEXT = - PFN_vkGetPhysicalDeviceDescriptorSizeEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDescriptorSizeEXT" ) ); - vkRegisterCustomBorderColorEXT = PFN_vkRegisterCustomBorderColorEXT( vkGetInstanceProcAddr( instance, "vkRegisterCustomBorderColorEXT" ) ); - vkUnregisterCustomBorderColorEXT = PFN_vkUnregisterCustomBorderColorEXT( vkGetInstanceProcAddr( instance, "vkUnregisterCustomBorderColorEXT" ) ); - vkGetTensorOpaqueCaptureDataARM = PFN_vkGetTensorOpaqueCaptureDataARM( vkGetInstanceProcAddr( instance, "vkGetTensorOpaqueCaptureDataARM" ) ); - - //=== VK_EXT_sample_locations === - vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEXT" ) ); - vkGetPhysicalDeviceMultisamplePropertiesEXT = - PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) ); - - //=== VK_KHR_get_memory_requirements2 === - vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageMemoryRequirements2KHR" ) ); - if ( !vkGetImageMemoryRequirements2 ) - vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; - vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetBufferMemoryRequirements2KHR" ) ); - if ( !vkGetBufferMemoryRequirements2 ) - vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; - vkGetImageSparseMemoryRequirements2KHR = - PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSparseMemoryRequirements2KHR" ) ); - if ( !vkGetImageSparseMemoryRequirements2 ) - vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; - - //=== VK_KHR_acceleration_structure === - vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureKHR" ) ); - vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureKHR" ) ); - vkCmdBuildAccelerationStructuresKHR = - PFN_vkCmdBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresKHR" ) ); - vkCmdBuildAccelerationStructuresIndirectKHR = - PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructuresIndirectKHR" ) ); - vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetInstanceProcAddr( instance, "vkBuildAccelerationStructuresKHR" ) ); - vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureKHR" ) ); - vkCopyAccelerationStructureToMemoryKHR = - PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCopyAccelerationStructureToMemoryKHR" ) ); - vkCopyMemoryToAccelerationStructureKHR = - PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCopyMemoryToAccelerationStructureKHR" ) ); - vkWriteAccelerationStructuresPropertiesKHR = - PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkWriteAccelerationStructuresPropertiesKHR" ) ); - vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureKHR" ) ); - vkCmdCopyAccelerationStructureToMemoryKHR = - PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureToMemoryKHR" ) ); - vkCmdCopyMemoryToAccelerationStructureKHR = - PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToAccelerationStructureKHR" ) ); - vkGetAccelerationStructureDeviceAddressKHR = - PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureDeviceAddressKHR" ) ); - vkCmdWriteAccelerationStructuresPropertiesKHR = - PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) ); - vkGetDeviceAccelerationStructureCompatibilityKHR = - PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) ); - vkGetAccelerationStructureBuildSizesKHR = - PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureBuildSizesKHR" ) ); - - //=== VK_KHR_ray_tracing_pipeline === - vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysKHR" ) ); - vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesKHR" ) ); - vkGetRayTracingShaderGroupHandlesKHR = - PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesKHR" ) ); - vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = - PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) ); - vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirectKHR" ) ); - vkGetRayTracingShaderGroupStackSizeKHR = - PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupStackSizeKHR" ) ); - vkCmdSetRayTracingPipelineStackSizeKHR = - PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); - - //=== VK_KHR_sampler_ycbcr_conversion === - vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkCreateSamplerYcbcrConversionKHR" ) ); - if ( !vkCreateSamplerYcbcrConversion ) - vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; - vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetInstanceProcAddr( instance, "vkDestroySamplerYcbcrConversionKHR" ) ); - if ( !vkDestroySamplerYcbcrConversion ) - vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; - - //=== VK_KHR_bind_memory2 === - vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindBufferMemory2KHR" ) ); - if ( !vkBindBufferMemory2 ) - vkBindBufferMemory2 = vkBindBufferMemory2KHR; - vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetInstanceProcAddr( instance, "vkBindImageMemory2KHR" ) ); - if ( !vkBindImageMemory2 ) - vkBindImageMemory2 = vkBindImageMemory2KHR; - - //=== VK_EXT_image_drm_format_modifier === - vkGetImageDrmFormatModifierPropertiesEXT = - PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetImageDrmFormatModifierPropertiesEXT" ) ); - - //=== VK_EXT_validation_cache === - vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkCreateValidationCacheEXT" ) ); - vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetInstanceProcAddr( instance, "vkDestroyValidationCacheEXT" ) ); - vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetInstanceProcAddr( instance, "vkMergeValidationCachesEXT" ) ); - vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetInstanceProcAddr( instance, "vkGetValidationCacheDataEXT" ) ); - - //=== VK_NV_shading_rate_image === - vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetInstanceProcAddr( instance, "vkCmdBindShadingRateImageNV" ) ); - vkCmdSetViewportShadingRatePaletteNV = - PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportShadingRatePaletteNV" ) ); - vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoarseSampleOrderNV" ) ); - - //=== VK_NV_ray_tracing === - vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCreateAccelerationStructureNV" ) ); - vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkDestroyAccelerationStructureNV" ) ); - vkGetAccelerationStructureMemoryRequirementsNV = - PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureMemoryRequirementsNV" ) ); - vkBindAccelerationStructureMemoryNV = - PFN_vkBindAccelerationStructureMemoryNV( vkGetInstanceProcAddr( instance, "vkBindAccelerationStructureMemoryNV" ) ); - vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdBuildAccelerationStructureNV" ) ); - vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetInstanceProcAddr( instance, "vkCmdCopyAccelerationStructureNV" ) ); - vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysNV" ) ); - vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetInstanceProcAddr( instance, "vkCreateRayTracingPipelinesNV" ) ); - vkGetRayTracingShaderGroupHandlesNV = - PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetInstanceProcAddr( instance, "vkGetRayTracingShaderGroupHandlesNV" ) ); - if ( !vkGetRayTracingShaderGroupHandlesKHR ) - vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; - vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureHandleNV" ) ); - vkCmdWriteAccelerationStructuresPropertiesNV = - PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetInstanceProcAddr( instance, "vkCmdWriteAccelerationStructuresPropertiesNV" ) ); - vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetInstanceProcAddr( instance, "vkCompileDeferredNV" ) ); - - //=== VK_KHR_maintenance3 === - vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSupportKHR" ) ); - if ( !vkGetDescriptorSetLayoutSupport ) - vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; - - //=== VK_KHR_draw_indirect_count === - vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndirectCountKHR" ) ); - if ( !vkCmdDrawIndirectCount ) - vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; - vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetInstanceProcAddr( instance, "vkCmdDrawIndexedIndirectCountKHR" ) ); - if ( !vkCmdDrawIndexedIndirectCount ) - vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; - - //=== VK_EXT_external_memory_host === - vkGetMemoryHostPointerPropertiesEXT = - PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryHostPointerPropertiesEXT" ) ); - - //=== VK_AMD_buffer_marker === - vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarkerAMD" ) ); - vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetInstanceProcAddr( instance, "vkCmdWriteBufferMarker2AMD" ) ); - - //=== VK_EXT_calibrated_timestamps === - vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = - PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) ); - if ( !vkGetPhysicalDeviceCalibrateableTimeDomainsKHR ) - vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; - vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsEXT" ) ); - if ( !vkGetCalibratedTimestampsKHR ) - vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT; - - //=== VK_NV_mesh_shader === - vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksNV" ) ); - vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectNV" ) ); - vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountNV" ) ); - - //=== VK_NV_scissor_exclusive === - vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorEnableNV" ) ); - vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetInstanceProcAddr( instance, "vkCmdSetExclusiveScissorNV" ) ); - - //=== VK_NV_device_diagnostic_checkpoints === - vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetInstanceProcAddr( instance, "vkCmdSetCheckpointNV" ) ); - vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointDataNV" ) ); - vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetInstanceProcAddr( instance, "vkGetQueueCheckpointData2NV" ) ); - - //=== VK_KHR_timeline_semaphore === - vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetInstanceProcAddr( instance, "vkGetSemaphoreCounterValueKHR" ) ); - if ( !vkGetSemaphoreCounterValue ) - vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; - vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetInstanceProcAddr( instance, "vkWaitSemaphoresKHR" ) ); - if ( !vkWaitSemaphores ) - vkWaitSemaphores = vkWaitSemaphoresKHR; - vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetInstanceProcAddr( instance, "vkSignalSemaphoreKHR" ) ); - if ( !vkSignalSemaphore ) - vkSignalSemaphore = vkSignalSemaphoreKHR; - - //=== VK_EXT_present_timing === - vkSetSwapchainPresentTimingQueueSizeEXT = - PFN_vkSetSwapchainPresentTimingQueueSizeEXT( vkGetInstanceProcAddr( instance, "vkSetSwapchainPresentTimingQueueSizeEXT" ) ); - vkGetSwapchainTimingPropertiesEXT = PFN_vkGetSwapchainTimingPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainTimingPropertiesEXT" ) ); - vkGetSwapchainTimeDomainPropertiesEXT = - PFN_vkGetSwapchainTimeDomainPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetSwapchainTimeDomainPropertiesEXT" ) ); - vkGetPastPresentationTimingEXT = PFN_vkGetPastPresentationTimingEXT( vkGetInstanceProcAddr( instance, "vkGetPastPresentationTimingEXT" ) ); - - //=== VK_INTEL_performance_query === - vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkInitializePerformanceApiINTEL" ) ); - vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetInstanceProcAddr( instance, "vkUninitializePerformanceApiINTEL" ) ); - vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceMarkerINTEL" ) ); - vkCmdSetPerformanceStreamMarkerINTEL = - PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); - vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetInstanceProcAddr( instance, "vkCmdSetPerformanceOverrideINTEL" ) ); - vkAcquirePerformanceConfigurationINTEL = - PFN_vkAcquirePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkAcquirePerformanceConfigurationINTEL" ) ); - vkReleasePerformanceConfigurationINTEL = - PFN_vkReleasePerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkReleasePerformanceConfigurationINTEL" ) ); - vkQueueSetPerformanceConfigurationINTEL = - PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetInstanceProcAddr( instance, "vkQueueSetPerformanceConfigurationINTEL" ) ); - vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetInstanceProcAddr( instance, "vkGetPerformanceParameterINTEL" ) ); - - //=== VK_AMD_display_native_hdr === - vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetInstanceProcAddr( instance, "vkSetLocalDimmingAMD" ) ); - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) ); -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) ); -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_fragment_shading_rate === - vkGetPhysicalDeviceFragmentShadingRatesKHR = - PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) ); - vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateKHR" ) ); - - //=== VK_KHR_dynamic_rendering_local_read === - vkCmdSetRenderingAttachmentLocationsKHR = - PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingAttachmentLocationsKHR" ) ); - if ( !vkCmdSetRenderingAttachmentLocations ) - vkCmdSetRenderingAttachmentLocations = vkCmdSetRenderingAttachmentLocationsKHR; - vkCmdSetRenderingInputAttachmentIndicesKHR = - PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetInstanceProcAddr( instance, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) ); - if ( !vkCmdSetRenderingInputAttachmentIndices ) - vkCmdSetRenderingInputAttachmentIndices = vkCmdSetRenderingInputAttachmentIndicesKHR; - - //=== VK_EXT_buffer_device_address === - vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressEXT" ) ); - if ( !vkGetBufferDeviceAddress ) - vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; - - //=== VK_EXT_tooling_info === - vkGetPhysicalDeviceToolPropertiesEXT = - PFN_vkGetPhysicalDeviceToolPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) ); - if ( !vkGetPhysicalDeviceToolProperties ) - vkGetPhysicalDeviceToolProperties = vkGetPhysicalDeviceToolPropertiesEXT; - - //=== VK_KHR_present_wait === - vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetInstanceProcAddr( instance, "vkWaitForPresentKHR" ) ); - - //=== VK_NV_cooperative_matrix === - vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = - PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) ); - - //=== VK_NV_coverage_reduction_mode === - vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) ); - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - vkGetPhysicalDeviceSurfacePresentModes2EXT = - PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) ); - vkAcquireFullScreenExclusiveModeEXT = - PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkAcquireFullScreenExclusiveModeEXT" ) ); - vkReleaseFullScreenExclusiveModeEXT = - PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetInstanceProcAddr( instance, "vkReleaseFullScreenExclusiveModeEXT" ) ); - vkGetDeviceGroupSurfacePresentModes2EXT = - PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) ); - - //=== VK_KHR_buffer_device_address === - vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferDeviceAddressKHR" ) ); - if ( !vkGetBufferDeviceAddress ) - vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; - vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureAddressKHR" ) ); - if ( !vkGetBufferOpaqueCaptureAddress ) - vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; - vkGetDeviceMemoryOpaqueCaptureAddressKHR = - PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) ); - if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) - vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; - - //=== VK_EXT_line_rasterization === - vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEXT" ) ); - if ( !vkCmdSetLineStipple ) - vkCmdSetLineStipple = vkCmdSetLineStippleEXT; - - //=== VK_EXT_host_query_reset === - vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetInstanceProcAddr( instance, "vkResetQueryPoolEXT" ) ); - if ( !vkResetQueryPool ) - vkResetQueryPool = vkResetQueryPoolEXT; - - //=== VK_EXT_extended_dynamic_state === - vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetCullModeEXT" ) ); - if ( !vkCmdSetCullMode ) - vkCmdSetCullMode = vkCmdSetCullModeEXT; - vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetInstanceProcAddr( instance, "vkCmdSetFrontFaceEXT" ) ); - if ( !vkCmdSetFrontFace ) - vkCmdSetFrontFace = vkCmdSetFrontFaceEXT; - vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveTopologyEXT" ) ); - if ( !vkCmdSetPrimitiveTopology ) - vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT; - vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWithCountEXT" ) ); - if ( !vkCmdSetViewportWithCount ) - vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT; - vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetInstanceProcAddr( instance, "vkCmdSetScissorWithCountEXT" ) ); - if ( !vkCmdSetScissorWithCount ) - vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT; - vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindVertexBuffers2EXT" ) ); - if ( !vkCmdBindVertexBuffers2 ) - vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT; - vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthTestEnableEXT" ) ); - if ( !vkCmdSetDepthTestEnable ) - vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT; - vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthWriteEnableEXT" ) ); - if ( !vkCmdSetDepthWriteEnable ) - vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT; - vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthCompareOpEXT" ) ); - if ( !vkCmdSetDepthCompareOp ) - vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT; - vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBoundsTestEnableEXT" ) ); - if ( !vkCmdSetDepthBoundsTestEnable ) - vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT; - vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilTestEnableEXT" ) ); - if ( !vkCmdSetStencilTestEnable ) - vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT; - vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetStencilOpEXT" ) ); - if ( !vkCmdSetStencilOp ) - vkCmdSetStencilOp = vkCmdSetStencilOpEXT; - - //=== VK_KHR_deferred_host_operations === - vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkCreateDeferredOperationKHR" ) ); - vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetInstanceProcAddr( instance, "vkDestroyDeferredOperationKHR" ) ); - vkGetDeferredOperationMaxConcurrencyKHR = - PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationMaxConcurrencyKHR" ) ); - vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetInstanceProcAddr( instance, "vkGetDeferredOperationResultKHR" ) ); - vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetInstanceProcAddr( instance, "vkDeferredOperationJoinKHR" ) ); - - //=== VK_KHR_pipeline_executable_properties === - vkGetPipelineExecutablePropertiesKHR = - PFN_vkGetPipelineExecutablePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutablePropertiesKHR" ) ); - vkGetPipelineExecutableStatisticsKHR = - PFN_vkGetPipelineExecutableStatisticsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableStatisticsKHR" ) ); - vkGetPipelineExecutableInternalRepresentationsKHR = - PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineExecutableInternalRepresentationsKHR" ) ); - - //=== VK_EXT_host_image_copy === - vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetInstanceProcAddr( instance, "vkCopyMemoryToImageEXT" ) ); - if ( !vkCopyMemoryToImage ) - vkCopyMemoryToImage = vkCopyMemoryToImageEXT; - vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCopyImageToMemoryEXT" ) ); - if ( !vkCopyImageToMemory ) - vkCopyImageToMemory = vkCopyImageToMemoryEXT; - vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetInstanceProcAddr( instance, "vkCopyImageToImageEXT" ) ); - if ( !vkCopyImageToImage ) - vkCopyImageToImage = vkCopyImageToImageEXT; - vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetInstanceProcAddr( instance, "vkTransitionImageLayoutEXT" ) ); - if ( !vkTransitionImageLayout ) - vkTransitionImageLayout = vkTransitionImageLayoutEXT; - vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2EXT" ) ); - if ( !vkGetImageSubresourceLayout2 ) - vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2EXT; - - //=== VK_KHR_map_memory2 === - vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetInstanceProcAddr( instance, "vkMapMemory2KHR" ) ); - if ( !vkMapMemory2 ) - vkMapMemory2 = vkMapMemory2KHR; - vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetInstanceProcAddr( instance, "vkUnmapMemory2KHR" ) ); - if ( !vkUnmapMemory2 ) - vkUnmapMemory2 = vkUnmapMemory2KHR; - - //=== VK_EXT_swapchain_maintenance1 === - vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetInstanceProcAddr( instance, "vkReleaseSwapchainImagesEXT" ) ); - if ( !vkReleaseSwapchainImagesKHR ) - vkReleaseSwapchainImagesKHR = vkReleaseSwapchainImagesEXT; - - //=== VK_NV_device_generated_commands === - vkGetGeneratedCommandsMemoryRequirementsNV = - PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetGeneratedCommandsMemoryRequirementsNV" ) ); - vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdPreprocessGeneratedCommandsNV" ) ); - vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetInstanceProcAddr( instance, "vkCmdExecuteGeneratedCommandsNV" ) ); - vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetInstanceProcAddr( instance, "vkCmdBindPipelineShaderGroupNV" ) ); - vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutNV" ) ); - vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutNV" ) ); - - //=== VK_EXT_depth_bias_control === - vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBias2EXT" ) ); - - //=== VK_EXT_acquire_drm_display === - vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) ); - vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) ); - - //=== VK_EXT_private_data === - vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkCreatePrivateDataSlotEXT" ) ); - if ( !vkCreatePrivateDataSlot ) - vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT; - vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetInstanceProcAddr( instance, "vkDestroyPrivateDataSlotEXT" ) ); - if ( !vkDestroyPrivateDataSlot ) - vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT; - vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkSetPrivateDataEXT" ) ); - if ( !vkSetPrivateData ) - vkSetPrivateData = vkSetPrivateDataEXT; - vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetInstanceProcAddr( instance, "vkGetPrivateDataEXT" ) ); - if ( !vkGetPrivateData ) - vkGetPrivateData = vkGetPrivateDataEXT; - - //=== VK_KHR_video_encode_queue === - vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( - vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR" ) ); - vkGetEncodedVideoSessionParametersKHR = - PFN_vkGetEncodedVideoSessionParametersKHR( vkGetInstanceProcAddr( instance, "vkGetEncodedVideoSessionParametersKHR" ) ); - vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetInstanceProcAddr( instance, "vkCmdEncodeVideoKHR" ) ); - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetInstanceProcAddr( instance, "vkCreateCudaModuleNV" ) ); - vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetInstanceProcAddr( instance, "vkGetCudaModuleCacheNV" ) ); - vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetInstanceProcAddr( instance, "vkCreateCudaFunctionNV" ) ); - vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetInstanceProcAddr( instance, "vkDestroyCudaModuleNV" ) ); - vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetInstanceProcAddr( instance, "vkDestroyCudaFunctionNV" ) ); - vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetInstanceProcAddr( instance, "vkCmdCudaLaunchKernelNV" ) ); -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - vkCmdDispatchTileQCOM = PFN_vkCmdDispatchTileQCOM( vkGetInstanceProcAddr( instance, "vkCmdDispatchTileQCOM" ) ); - vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetInstanceProcAddr( instance, "vkCmdBeginPerTileExecutionQCOM" ) ); - vkCmdEndPerTileExecutionQCOM = PFN_vkCmdEndPerTileExecutionQCOM( vkGetInstanceProcAddr( instance, "vkCmdEndPerTileExecutionQCOM" ) ); - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetInstanceProcAddr( instance, "vkExportMetalObjectsEXT" ) ); -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_synchronization2 === - vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdSetEvent2KHR" ) ); - if ( !vkCmdSetEvent2 ) - vkCmdSetEvent2 = vkCmdSetEvent2KHR; - vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetInstanceProcAddr( instance, "vkCmdResetEvent2KHR" ) ); - if ( !vkCmdResetEvent2 ) - vkCmdResetEvent2 = vkCmdResetEvent2KHR; - vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetInstanceProcAddr( instance, "vkCmdWaitEvents2KHR" ) ); - if ( !vkCmdWaitEvents2 ) - vkCmdWaitEvents2 = vkCmdWaitEvents2KHR; - vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetInstanceProcAddr( instance, "vkCmdPipelineBarrier2KHR" ) ); - if ( !vkCmdPipelineBarrier2 ) - vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR; - vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetInstanceProcAddr( instance, "vkCmdWriteTimestamp2KHR" ) ); - if ( !vkCmdWriteTimestamp2 ) - vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR; - vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetInstanceProcAddr( instance, "vkQueueSubmit2KHR" ) ); - if ( !vkQueueSubmit2 ) - vkQueueSubmit2 = vkQueueSubmit2KHR; - - //=== VK_EXT_descriptor_buffer === - vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutSizeEXT" ) ); - vkGetDescriptorSetLayoutBindingOffsetEXT = - PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) ); - vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetInstanceProcAddr( instance, "vkGetDescriptorEXT" ) ); - vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBuffersEXT" ) ); - vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDescriptorBufferOffsetsEXT" ) ); - vkCmdBindDescriptorBufferEmbeddedSamplersEXT = - PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) ); - vkGetBufferOpaqueCaptureDescriptorDataEXT = - PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) ); - vkGetImageOpaqueCaptureDescriptorDataEXT = - PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) ); - vkGetImageViewOpaqueCaptureDescriptorDataEXT = - PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) ); - vkGetSamplerOpaqueCaptureDescriptorDataEXT = - PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetInstanceProcAddr( instance, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) ); - vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( - vkGetInstanceProcAddr( instance, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) ); - - //=== VK_NV_fragment_shading_rate_enums === - vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetInstanceProcAddr( instance, "vkCmdSetFragmentShadingRateEnumNV" ) ); - - //=== VK_EXT_mesh_shader === - vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksEXT" ) ); - vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectEXT" ) ); - vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMeshTasksIndirectCountEXT" ) ); - - //=== VK_KHR_copy_commands2 === - vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBuffer2KHR" ) ); - if ( !vkCmdCopyBuffer2 ) - vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR; - vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImage2KHR" ) ); - if ( !vkCmdCopyImage2 ) - vkCmdCopyImage2 = vkCmdCopyImage2KHR; - vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyBufferToImage2KHR" ) ); - if ( !vkCmdCopyBufferToImage2 ) - vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR; - vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdCopyImageToBuffer2KHR" ) ); - if ( !vkCmdCopyImageToBuffer2 ) - vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR; - vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdBlitImage2KHR" ) ); - if ( !vkCmdBlitImage2 ) - vkCmdBlitImage2 = vkCmdBlitImage2KHR; - vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetInstanceProcAddr( instance, "vkCmdResolveImage2KHR" ) ); - if ( !vkCmdResolveImage2 ) - vkCmdResolveImage2 = vkCmdResolveImage2KHR; - - //=== VK_EXT_device_fault === - vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceFaultInfoEXT" ) ); - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) ); - vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) ); - vkGetPhysicalDeviceDirectFBPresentationSupportEXT = - PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) ); -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_vertex_input_dynamic_state === - vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetInstanceProcAddr( instance, "vkCmdSetVertexInputEXT" ) ); - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandleFUCHSIA" ) ); - vkGetMemoryZirconHandlePropertiesFUCHSIA = - PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) ); -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - vkImportSemaphoreZirconHandleFUCHSIA = - PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkImportSemaphoreZirconHandleFUCHSIA" ) ); - vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetSemaphoreZirconHandleFUCHSIA" ) ); -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateBufferCollectionFUCHSIA" ) ); - vkSetBufferCollectionImageConstraintsFUCHSIA = - PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) ); - vkSetBufferCollectionBufferConstraintsFUCHSIA = - PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetInstanceProcAddr( instance, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) ); - vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetInstanceProcAddr( instance, "vkDestroyBufferCollectionFUCHSIA" ) ); - vkGetBufferCollectionPropertiesFUCHSIA = - PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetInstanceProcAddr( instance, "vkGetBufferCollectionPropertiesFUCHSIA" ) ); -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = - PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetInstanceProcAddr( instance, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) ); - vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdSubpassShadingHUAWEI" ) ); - - //=== VK_HUAWEI_invocation_mask === - vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdBindInvocationMaskHUAWEI" ) ); - - //=== VK_NV_external_memory_rdma === - vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetInstanceProcAddr( instance, "vkGetMemoryRemoteAddressNV" ) ); - - //=== VK_EXT_pipeline_properties === - vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPipelinePropertiesEXT" ) ); - - //=== VK_EXT_extended_dynamic_state2 === - vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPatchControlPointsEXT" ) ); - vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizerDiscardEnableEXT" ) ); - if ( !vkCmdSetRasterizerDiscardEnable ) - vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT; - vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthBiasEnableEXT" ) ); - if ( !vkCmdSetDepthBiasEnable ) - vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT; - vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEXT" ) ); - vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPrimitiveRestartEnableEXT" ) ); - if ( !vkCmdSetPrimitiveRestartEnable ) - vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) ); - vkGetPhysicalDeviceScreenPresentationSupportQNX = - PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) ); -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_EXT_color_write_enable === - vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteEnableEXT" ) ); - - //=== VK_KHR_ray_tracing_maintenance1 === - vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetInstanceProcAddr( instance, "vkCmdTraceRaysIndirect2KHR" ) ); - - //=== VK_EXT_multi_draw === - vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiEXT" ) ); - vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetInstanceProcAddr( instance, "vkCmdDrawMultiIndexedEXT" ) ); - - //=== VK_EXT_opacity_micromap === - vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetInstanceProcAddr( instance, "vkCreateMicromapEXT" ) ); - vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetInstanceProcAddr( instance, "vkDestroyMicromapEXT" ) ); - vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkCmdBuildMicromapsEXT" ) ); - vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetInstanceProcAddr( instance, "vkBuildMicromapsEXT" ) ); - vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapEXT" ) ); - vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCopyMicromapToMemoryEXT" ) ); - vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCopyMemoryToMicromapEXT" ) ); - vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkWriteMicromapsPropertiesEXT" ) ); - vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapEXT" ) ); - vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMicromapToMemoryEXT" ) ); - vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToMicromapEXT" ) ); - vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetInstanceProcAddr( instance, "vkCmdWriteMicromapsPropertiesEXT" ) ); - vkGetDeviceMicromapCompatibilityEXT = - PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetInstanceProcAddr( instance, "vkGetDeviceMicromapCompatibilityEXT" ) ); - vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetInstanceProcAddr( instance, "vkGetMicromapBuildSizesEXT" ) ); - - //=== VK_HUAWEI_cluster_culling_shader === - vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdDrawClusterHUAWEI" ) ); - vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetInstanceProcAddr( instance, "vkCmdDrawClusterIndirectHUAWEI" ) ); - - //=== VK_EXT_pageable_device_local_memory === - vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetInstanceProcAddr( instance, "vkSetDeviceMemoryPriorityEXT" ) ); - - //=== VK_KHR_maintenance4 === - vkGetDeviceBufferMemoryRequirementsKHR = - PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceBufferMemoryRequirementsKHR" ) ); - if ( !vkGetDeviceBufferMemoryRequirements ) - vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR; - vkGetDeviceImageMemoryRequirementsKHR = - PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageMemoryRequirementsKHR" ) ); - if ( !vkGetDeviceImageMemoryRequirements ) - vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR; - vkGetDeviceImageSparseMemoryRequirementsKHR = - PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) ); - if ( !vkGetDeviceImageSparseMemoryRequirements ) - vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR; - - //=== VK_VALVE_descriptor_set_host_mapping === - vkGetDescriptorSetLayoutHostMappingInfoVALVE = - PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) ); - vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetInstanceProcAddr( instance, "vkGetDescriptorSetHostMappingVALVE" ) ); - - //=== VK_NV_copy_memory_indirect === - vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryIndirectNV" ) ); - vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToImageIndirectNV" ) ); - - //=== VK_NV_memory_decompression === - vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryNV" ) ); - vkCmdDecompressMemoryIndirectCountNV = - PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryIndirectCountNV" ) ); - - //=== VK_NV_device_generated_commands_compute === - vkGetPipelineIndirectMemoryRequirementsNV = - PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetInstanceProcAddr( instance, "vkGetPipelineIndirectMemoryRequirementsNV" ) ); - vkCmdUpdatePipelineIndirectBufferNV = - PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetInstanceProcAddr( instance, "vkCmdUpdatePipelineIndirectBufferNV" ) ); - vkGetPipelineIndirectDeviceAddressNV = - PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetInstanceProcAddr( instance, "vkGetPipelineIndirectDeviceAddressNV" ) ); - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - vkGetNativeBufferPropertiesOHOS = PFN_vkGetNativeBufferPropertiesOHOS( vkGetInstanceProcAddr( instance, "vkGetNativeBufferPropertiesOHOS" ) ); - vkGetMemoryNativeBufferOHOS = PFN_vkGetMemoryNativeBufferOHOS( vkGetInstanceProcAddr( instance, "vkGetMemoryNativeBufferOHOS" ) ); -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_extended_dynamic_state3 === - vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClampEnableEXT" ) ); - vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetPolygonModeEXT" ) ); - vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationSamplesEXT" ) ); - vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleMaskEXT" ) ); - vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToCoverageEnableEXT" ) ); - vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAlphaToOneEnableEXT" ) ); - vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLogicOpEnableEXT" ) ); - vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEnableEXT" ) ); - vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendEquationEXT" ) ); - vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorWriteMaskEXT" ) ); - vkCmdSetTessellationDomainOriginEXT = - PFN_vkCmdSetTessellationDomainOriginEXT( vkGetInstanceProcAddr( instance, "vkCmdSetTessellationDomainOriginEXT" ) ); - vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetInstanceProcAddr( instance, "vkCmdSetRasterizationStreamEXT" ) ); - vkCmdSetConservativeRasterizationModeEXT = - PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetConservativeRasterizationModeEXT" ) ); - vkCmdSetExtraPrimitiveOverestimationSizeEXT = - PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) ); - vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipEnableEXT" ) ); - vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetSampleLocationsEnableEXT" ) ); - vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetInstanceProcAddr( instance, "vkCmdSetColorBlendAdvancedEXT" ) ); - vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetProvokingVertexModeEXT" ) ); - vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineRasterizationModeEXT" ) ); - vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleEnableEXT" ) ); - vkCmdSetDepthClipNegativeOneToOneEXT = - PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClipNegativeOneToOneEXT" ) ); - vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportWScalingEnableNV" ) ); - vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetInstanceProcAddr( instance, "vkCmdSetViewportSwizzleNV" ) ); - vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorEnableNV" ) ); - vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageToColorLocationNV" ) ); - vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationModeNV" ) ); - vkCmdSetCoverageModulationTableEnableNV = - PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableEnableNV" ) ); - vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageModulationTableNV" ) ); - vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetShadingRateImageEnableNV" ) ); - vkCmdSetRepresentativeFragmentTestEnableNV = - PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetInstanceProcAddr( instance, "vkCmdSetRepresentativeFragmentTestEnableNV" ) ); - vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetInstanceProcAddr( instance, "vkCmdSetCoverageReductionModeNV" ) ); - - //=== VK_ARM_tensors === - vkCreateTensorARM = PFN_vkCreateTensorARM( vkGetInstanceProcAddr( instance, "vkCreateTensorARM" ) ); - vkDestroyTensorARM = PFN_vkDestroyTensorARM( vkGetInstanceProcAddr( instance, "vkDestroyTensorARM" ) ); - vkCreateTensorViewARM = PFN_vkCreateTensorViewARM( vkGetInstanceProcAddr( instance, "vkCreateTensorViewARM" ) ); - vkDestroyTensorViewARM = PFN_vkDestroyTensorViewARM( vkGetInstanceProcAddr( instance, "vkDestroyTensorViewARM" ) ); - vkGetTensorMemoryRequirementsARM = PFN_vkGetTensorMemoryRequirementsARM( vkGetInstanceProcAddr( instance, "vkGetTensorMemoryRequirementsARM" ) ); - vkBindTensorMemoryARM = PFN_vkBindTensorMemoryARM( vkGetInstanceProcAddr( instance, "vkBindTensorMemoryARM" ) ); - vkGetDeviceTensorMemoryRequirementsARM = - PFN_vkGetDeviceTensorMemoryRequirementsARM( vkGetInstanceProcAddr( instance, "vkGetDeviceTensorMemoryRequirementsARM" ) ); - vkCmdCopyTensorARM = PFN_vkCmdCopyTensorARM( vkGetInstanceProcAddr( instance, "vkCmdCopyTensorARM" ) ); - vkGetPhysicalDeviceExternalTensorPropertiesARM = - PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalTensorPropertiesARM" ) ); - vkGetTensorOpaqueCaptureDescriptorDataARM = - PFN_vkGetTensorOpaqueCaptureDescriptorDataARM( vkGetInstanceProcAddr( instance, "vkGetTensorOpaqueCaptureDescriptorDataARM" ) ); - vkGetTensorViewOpaqueCaptureDescriptorDataARM = - PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM( vkGetInstanceProcAddr( instance, "vkGetTensorViewOpaqueCaptureDescriptorDataARM" ) ); - - //=== VK_EXT_shader_module_identifier === - vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleIdentifierEXT" ) ); - vkGetShaderModuleCreateInfoIdentifierEXT = - PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetInstanceProcAddr( instance, "vkGetShaderModuleCreateInfoIdentifierEXT" ) ); - - //=== VK_NV_optical_flow === - vkGetPhysicalDeviceOpticalFlowImageFormatsNV = - PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV" ) ); - vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkCreateOpticalFlowSessionNV" ) ); - vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetInstanceProcAddr( instance, "vkDestroyOpticalFlowSessionNV" ) ); - vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetInstanceProcAddr( instance, "vkBindOpticalFlowSessionImageNV" ) ); - vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetInstanceProcAddr( instance, "vkCmdOpticalFlowExecuteNV" ) ); - - //=== VK_KHR_maintenance5 === - vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetInstanceProcAddr( instance, "vkCmdBindIndexBuffer2KHR" ) ); - if ( !vkCmdBindIndexBuffer2 ) - vkCmdBindIndexBuffer2 = vkCmdBindIndexBuffer2KHR; - vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetInstanceProcAddr( instance, "vkGetRenderingAreaGranularityKHR" ) ); - if ( !vkGetRenderingAreaGranularity ) - vkGetRenderingAreaGranularity = vkGetRenderingAreaGranularityKHR; - vkGetDeviceImageSubresourceLayoutKHR = - PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetInstanceProcAddr( instance, "vkGetDeviceImageSubresourceLayoutKHR" ) ); - if ( !vkGetDeviceImageSubresourceLayout ) - vkGetDeviceImageSubresourceLayout = vkGetDeviceImageSubresourceLayoutKHR; - vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetInstanceProcAddr( instance, "vkGetImageSubresourceLayout2KHR" ) ); - if ( !vkGetImageSubresourceLayout2 ) - vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2KHR; - - //=== VK_AMD_anti_lag === - vkAntiLagUpdateAMD = PFN_vkAntiLagUpdateAMD( vkGetInstanceProcAddr( instance, "vkAntiLagUpdateAMD" ) ); - - //=== VK_KHR_present_wait2 === - vkWaitForPresent2KHR = PFN_vkWaitForPresent2KHR( vkGetInstanceProcAddr( instance, "vkWaitForPresent2KHR" ) ); - - //=== VK_EXT_shader_object === - vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetInstanceProcAddr( instance, "vkCreateShadersEXT" ) ); - vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetInstanceProcAddr( instance, "vkDestroyShaderEXT" ) ); - vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetInstanceProcAddr( instance, "vkGetShaderBinaryDataEXT" ) ); - vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindShadersEXT" ) ); - vkCmdSetDepthClampRangeEXT = PFN_vkCmdSetDepthClampRangeEXT( vkGetInstanceProcAddr( instance, "vkCmdSetDepthClampRangeEXT" ) ); - - //=== VK_KHR_pipeline_binary === - vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetInstanceProcAddr( instance, "vkCreatePipelineBinariesKHR" ) ); - vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetInstanceProcAddr( instance, "vkDestroyPipelineBinaryKHR" ) ); - vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineKeyKHR" ) ); - vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetInstanceProcAddr( instance, "vkGetPipelineBinaryDataKHR" ) ); - vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetInstanceProcAddr( instance, "vkReleaseCapturedPipelineDataKHR" ) ); - - //=== VK_QCOM_tile_properties === - vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetFramebufferTilePropertiesQCOM" ) ); - vkGetDynamicRenderingTilePropertiesQCOM = - PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetDynamicRenderingTilePropertiesQCOM" ) ); - - //=== VK_KHR_swapchain_maintenance1 === - vkReleaseSwapchainImagesKHR = PFN_vkReleaseSwapchainImagesKHR( vkGetInstanceProcAddr( instance, "vkReleaseSwapchainImagesKHR" ) ); - - //=== VK_NV_cooperative_vector === - vkGetPhysicalDeviceCooperativeVectorPropertiesNV = - PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV" ) ); - vkConvertCooperativeVectorMatrixNV = PFN_vkConvertCooperativeVectorMatrixNV( vkGetInstanceProcAddr( instance, "vkConvertCooperativeVectorMatrixNV" ) ); - vkCmdConvertCooperativeVectorMatrixNV = - PFN_vkCmdConvertCooperativeVectorMatrixNV( vkGetInstanceProcAddr( instance, "vkCmdConvertCooperativeVectorMatrixNV" ) ); - - //=== VK_NV_low_latency2 === - vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetInstanceProcAddr( instance, "vkSetLatencySleepModeNV" ) ); - vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetInstanceProcAddr( instance, "vkLatencySleepNV" ) ); - vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetInstanceProcAddr( instance, "vkSetLatencyMarkerNV" ) ); - vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetInstanceProcAddr( instance, "vkGetLatencyTimingsNV" ) ); - vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetInstanceProcAddr( instance, "vkQueueNotifyOutOfBandNV" ) ); - - //=== VK_KHR_cooperative_matrix === - vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = - PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR" ) ); - - //=== VK_ARM_data_graph === - vkCreateDataGraphPipelinesARM = PFN_vkCreateDataGraphPipelinesARM( vkGetInstanceProcAddr( instance, "vkCreateDataGraphPipelinesARM" ) ); - vkCreateDataGraphPipelineSessionARM = - PFN_vkCreateDataGraphPipelineSessionARM( vkGetInstanceProcAddr( instance, "vkCreateDataGraphPipelineSessionARM" ) ); - vkGetDataGraphPipelineSessionBindPointRequirementsARM = PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM( - vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelineSessionBindPointRequirementsARM" ) ); - vkGetDataGraphPipelineSessionMemoryRequirementsARM = - PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM( vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelineSessionMemoryRequirementsARM" ) ); - vkBindDataGraphPipelineSessionMemoryARM = - PFN_vkBindDataGraphPipelineSessionMemoryARM( vkGetInstanceProcAddr( instance, "vkBindDataGraphPipelineSessionMemoryARM" ) ); - vkDestroyDataGraphPipelineSessionARM = - PFN_vkDestroyDataGraphPipelineSessionARM( vkGetInstanceProcAddr( instance, "vkDestroyDataGraphPipelineSessionARM" ) ); - vkCmdDispatchDataGraphARM = PFN_vkCmdDispatchDataGraphARM( vkGetInstanceProcAddr( instance, "vkCmdDispatchDataGraphARM" ) ); - vkGetDataGraphPipelineAvailablePropertiesARM = - PFN_vkGetDataGraphPipelineAvailablePropertiesARM( vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelineAvailablePropertiesARM" ) ); - vkGetDataGraphPipelinePropertiesARM = - PFN_vkGetDataGraphPipelinePropertiesARM( vkGetInstanceProcAddr( instance, "vkGetDataGraphPipelinePropertiesARM" ) ); - vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = - PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM" ) ); - vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( - vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM" ) ); - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - vkCmdSetAttachmentFeedbackLoopEnableEXT = - PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetInstanceProcAddr( instance, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) ); - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetInstanceProcAddr( instance, "vkGetScreenBufferPropertiesQNX" ) ); -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_KHR_line_rasterization === - vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetInstanceProcAddr( instance, "vkCmdSetLineStippleKHR" ) ); - if ( !vkCmdSetLineStipple ) - vkCmdSetLineStipple = vkCmdSetLineStippleKHR; - - //=== VK_KHR_calibrated_timestamps === - vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = - PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) ); - vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetInstanceProcAddr( instance, "vkGetCalibratedTimestampsKHR" ) ); - - //=== VK_KHR_maintenance6 === - vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorSets2KHR" ) ); - if ( !vkCmdBindDescriptorSets2 ) - vkCmdBindDescriptorSets2 = vkCmdBindDescriptorSets2KHR; - vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushConstants2KHR" ) ); - if ( !vkCmdPushConstants2 ) - vkCmdPushConstants2 = vkCmdPushConstants2KHR; - vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSet2KHR" ) ); - if ( !vkCmdPushDescriptorSet2 ) - vkCmdPushDescriptorSet2 = vkCmdPushDescriptorSet2KHR; - vkCmdPushDescriptorSetWithTemplate2KHR = - PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetInstanceProcAddr( instance, "vkCmdPushDescriptorSetWithTemplate2KHR" ) ); - if ( !vkCmdPushDescriptorSetWithTemplate2 ) - vkCmdPushDescriptorSetWithTemplate2 = vkCmdPushDescriptorSetWithTemplate2KHR; - vkCmdSetDescriptorBufferOffsets2EXT = - PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetInstanceProcAddr( instance, "vkCmdSetDescriptorBufferOffsets2EXT" ) ); - vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = - PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); - - //=== VK_QCOM_tile_memory_heap === - vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetInstanceProcAddr( instance, "vkCmdBindTileMemoryQCOM" ) ); - - //=== VK_KHR_copy_memory_indirect === - vkCmdCopyMemoryIndirectKHR = PFN_vkCmdCopyMemoryIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryIndirectKHR" ) ); - vkCmdCopyMemoryToImageIndirectKHR = PFN_vkCmdCopyMemoryToImageIndirectKHR( vkGetInstanceProcAddr( instance, "vkCmdCopyMemoryToImageIndirectKHR" ) ); - - //=== VK_EXT_memory_decompression === - vkCmdDecompressMemoryEXT = PFN_vkCmdDecompressMemoryEXT( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryEXT" ) ); - vkCmdDecompressMemoryIndirectCountEXT = - PFN_vkCmdDecompressMemoryIndirectCountEXT( vkGetInstanceProcAddr( instance, "vkCmdDecompressMemoryIndirectCountEXT" ) ); - - //=== VK_NV_external_compute_queue === - vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkCreateExternalComputeQueueNV" ) ); - vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkDestroyExternalComputeQueueNV" ) ); - vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetInstanceProcAddr( instance, "vkGetExternalComputeQueueDataNV" ) ); - - //=== VK_NV_cluster_acceleration_structure === - vkGetClusterAccelerationStructureBuildSizesNV = - PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetInstanceProcAddr( instance, "vkGetClusterAccelerationStructureBuildSizesNV" ) ); - vkCmdBuildClusterAccelerationStructureIndirectNV = - PFN_vkCmdBuildClusterAccelerationStructureIndirectNV( vkGetInstanceProcAddr( instance, "vkCmdBuildClusterAccelerationStructureIndirectNV" ) ); - - //=== VK_NV_partitioned_acceleration_structure === - vkGetPartitionedAccelerationStructuresBuildSizesNV = - PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV( vkGetInstanceProcAddr( instance, "vkGetPartitionedAccelerationStructuresBuildSizesNV" ) ); - vkCmdBuildPartitionedAccelerationStructuresNV = - PFN_vkCmdBuildPartitionedAccelerationStructuresNV( vkGetInstanceProcAddr( instance, "vkCmdBuildPartitionedAccelerationStructuresNV" ) ); - - //=== VK_EXT_device_generated_commands === - vkGetGeneratedCommandsMemoryRequirementsEXT = - PFN_vkGetGeneratedCommandsMemoryRequirementsEXT( vkGetInstanceProcAddr( instance, "vkGetGeneratedCommandsMemoryRequirementsEXT" ) ); - vkCmdPreprocessGeneratedCommandsEXT = - PFN_vkCmdPreprocessGeneratedCommandsEXT( vkGetInstanceProcAddr( instance, "vkCmdPreprocessGeneratedCommandsEXT" ) ); - vkCmdExecuteGeneratedCommandsEXT = PFN_vkCmdExecuteGeneratedCommandsEXT( vkGetInstanceProcAddr( instance, "vkCmdExecuteGeneratedCommandsEXT" ) ); - vkCreateIndirectCommandsLayoutEXT = PFN_vkCreateIndirectCommandsLayoutEXT( vkGetInstanceProcAddr( instance, "vkCreateIndirectCommandsLayoutEXT" ) ); - vkDestroyIndirectCommandsLayoutEXT = PFN_vkDestroyIndirectCommandsLayoutEXT( vkGetInstanceProcAddr( instance, "vkDestroyIndirectCommandsLayoutEXT" ) ); - vkCreateIndirectExecutionSetEXT = PFN_vkCreateIndirectExecutionSetEXT( vkGetInstanceProcAddr( instance, "vkCreateIndirectExecutionSetEXT" ) ); - vkDestroyIndirectExecutionSetEXT = PFN_vkDestroyIndirectExecutionSetEXT( vkGetInstanceProcAddr( instance, "vkDestroyIndirectExecutionSetEXT" ) ); - vkUpdateIndirectExecutionSetPipelineEXT = - PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetInstanceProcAddr( instance, "vkUpdateIndirectExecutionSetPipelineEXT" ) ); - vkUpdateIndirectExecutionSetShaderEXT = - PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetInstanceProcAddr( instance, "vkUpdateIndirectExecutionSetShaderEXT" ) ); - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - vkCreateSurfaceOHOS = PFN_vkCreateSurfaceOHOS( vkGetInstanceProcAddr( instance, "vkCreateSurfaceOHOS" ) ); -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_NV_cooperative_matrix2 === - vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( - vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV" ) ); - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryMetalHandleEXT" ) ); - vkGetMemoryMetalHandlePropertiesEXT = - PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetMemoryMetalHandlePropertiesEXT" ) ); -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_ARM_performance_counters_by_region === - vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( - vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM" ) ); - - //=== VK_EXT_fragment_density_map_offset === - vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetInstanceProcAddr( instance, "vkCmdEndRendering2EXT" ) ); - if ( !vkCmdEndRendering2KHR ) - vkCmdEndRendering2KHR = vkCmdEndRendering2EXT; - - //=== VK_EXT_custom_resolve === - vkCmdBeginCustomResolveEXT = PFN_vkCmdBeginCustomResolveEXT( vkGetInstanceProcAddr( instance, "vkCmdBeginCustomResolveEXT" ) ); - - //=== VK_KHR_maintenance10 === - vkCmdEndRendering2KHR = PFN_vkCmdEndRendering2KHR( vkGetInstanceProcAddr( instance, "vkCmdEndRendering2KHR" ) ); - - //=== VK_NV_compute_occupancy_priority === - vkCmdSetComputeOccupancyPriorityNV = PFN_vkCmdSetComputeOccupancyPriorityNV( vkGetInstanceProcAddr( instance, "vkCmdSetComputeOccupancyPriorityNV" ) ); - } - - void init( Device deviceCpp ) VULKAN_HPP_NOEXCEPT - { - VkDevice device = static_cast( deviceCpp ); - - //=== VK_VERSION_1_0 === - vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) ); - vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) ); - vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) ); - vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) ); - vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) ); - vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) ); - vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) ); - vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) ); - vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) ); - vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) ); - vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) ); - vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) ); - vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) ); - vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) ); - vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) ); - vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) ); - vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) ); - vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) ); - vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) ); - vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) ); - vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) ); - vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) ); - vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) ); - vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) ); - vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) ); - vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) ); - vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) ); - vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) ); - vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) ); - vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) ); - vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) ); - vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) ); - vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) ); - vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) ); - vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) ); - vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) ); - vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) ); - vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) ); - vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) ); - vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) ); - vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) ); - vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) ); - vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) ); - vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) ); - vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) ); - vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) ); - vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) ); - vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) ); - vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) ); - vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) ); - vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) ); - vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) ); - vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) ); - vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) ); - vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) ); - vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) ); - vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) ); - vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) ); - vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) ); - vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) ); - vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) ); - vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) ); - vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) ); - vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) ); - vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) ); - vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) ); - vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) ); - vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) ); - vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) ); - vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) ); - vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) ); - vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) ); - vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) ); - vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) ); - vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) ); - vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) ); - vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) ); - vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) ); - vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) ); - vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) ); - vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) ); - vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) ); - vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) ); - vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) ); - vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) ); - vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) ); - vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) ); - vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) ); - vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) ); - vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) ); - vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) ); - vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) ); - vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) ); - vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) ); - vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) ); - vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) ); - vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) ); - vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) ); - vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) ); - vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) ); - vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) ); - vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) ); - vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) ); - vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) ); - vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) ); - vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) ); - vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) ); - vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) ); - vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) ); - vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) ); - vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) ); - vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) ); - vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) ); - vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) ); - vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) ); - vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) ); - vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) ); - vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) ); - vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) ); - vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) ); - vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) ); - - //=== VK_VERSION_1_1 === - vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) ); - vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) ); - vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) ); - vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) ); - vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) ); - vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) ); - vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) ); - vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) ); - vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) ); - vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) ); - vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) ); - vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) ); - vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) ); - vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) ); - vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) ); - vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) ); - - //=== VK_VERSION_1_2 === - vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) ); - vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) ); - vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) ); - vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) ); - vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) ); - vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) ); - vkGetDeviceMemoryOpaqueCaptureAddress = - PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) ); - vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) ); - vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) ); - vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) ); - vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) ); - vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) ); - vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) ); - - //=== VK_VERSION_1_3 === - vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) ); - vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) ); - vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) ); - vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) ); - vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) ); - vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) ); - vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) ); - vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) ); - vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) ); - vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) ); - vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) ); - vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) ); - vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) ); - vkGetDeviceImageSparseMemoryRequirements = - PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) ); - vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) ); - vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) ); - vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) ); - vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) ); - vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) ); - vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) ); - vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) ); - vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) ); - vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) ); - vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) ); - vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) ); - vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) ); - vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) ); - vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) ); - vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) ); - vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) ); - vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) ); - vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) ); - vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) ); - vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) ); - vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) ); - vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) ); - - //=== VK_VERSION_1_4 === - vkMapMemory2 = PFN_vkMapMemory2( vkGetDeviceProcAddr( device, "vkMapMemory2" ) ); - vkUnmapMemory2 = PFN_vkUnmapMemory2( vkGetDeviceProcAddr( device, "vkUnmapMemory2" ) ); - vkGetDeviceImageSubresourceLayout = PFN_vkGetDeviceImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayout" ) ); - vkGetImageSubresourceLayout2 = PFN_vkGetImageSubresourceLayout2( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2" ) ); - vkCopyMemoryToImage = PFN_vkCopyMemoryToImage( vkGetDeviceProcAddr( device, "vkCopyMemoryToImage" ) ); - vkCopyImageToMemory = PFN_vkCopyImageToMemory( vkGetDeviceProcAddr( device, "vkCopyImageToMemory" ) ); - vkCopyImageToImage = PFN_vkCopyImageToImage( vkGetDeviceProcAddr( device, "vkCopyImageToImage" ) ); - vkTransitionImageLayout = PFN_vkTransitionImageLayout( vkGetDeviceProcAddr( device, "vkTransitionImageLayout" ) ); - vkCmdPushDescriptorSet = PFN_vkCmdPushDescriptorSet( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet" ) ); - vkCmdPushDescriptorSetWithTemplate = PFN_vkCmdPushDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate" ) ); - vkCmdBindDescriptorSets2 = PFN_vkCmdBindDescriptorSets2( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2" ) ); - vkCmdPushConstants2 = PFN_vkCmdPushConstants2( vkGetDeviceProcAddr( device, "vkCmdPushConstants2" ) ); - vkCmdPushDescriptorSet2 = PFN_vkCmdPushDescriptorSet2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2" ) ); - vkCmdPushDescriptorSetWithTemplate2 = PFN_vkCmdPushDescriptorSetWithTemplate2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2" ) ); - vkCmdSetLineStipple = PFN_vkCmdSetLineStipple( vkGetDeviceProcAddr( device, "vkCmdSetLineStipple" ) ); - vkCmdBindIndexBuffer2 = PFN_vkCmdBindIndexBuffer2( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2" ) ); - vkGetRenderingAreaGranularity = PFN_vkGetRenderingAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularity" ) ); - vkCmdSetRenderingAttachmentLocations = - PFN_vkCmdSetRenderingAttachmentLocations( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocations" ) ); - vkCmdSetRenderingInputAttachmentIndices = - PFN_vkCmdSetRenderingInputAttachmentIndices( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndices" ) ); - - //=== VK_KHR_swapchain === - vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) ); - vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) ); - vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) ); - vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) ); - vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) ); - vkGetDeviceGroupPresentCapabilitiesKHR = - PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); - vkGetDeviceGroupSurfacePresentModesKHR = - PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); - vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) ); - - //=== VK_KHR_display_swapchain === - vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) ); - - //=== VK_EXT_debug_marker === - vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) ); - vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) ); - vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) ); - vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) ); - vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) ); - - //=== VK_KHR_video_queue === - vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) ); - vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) ); - vkGetVideoSessionMemoryRequirementsKHR = - PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) ); - vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) ); - vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) ); - vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) ); - vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) ); - vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) ); - vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) ); - vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) ); - - //=== VK_KHR_video_decode_queue === - vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) ); - - //=== VK_EXT_transform_feedback === - vkCmdBindTransformFeedbackBuffersEXT = - PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) ); - vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) ); - vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) ); - vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) ); - vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) ); - vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) ); - - //=== VK_NVX_binary_import === - vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) ); - vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) ); - vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) ); - vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) ); - vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) ); - - //=== VK_NVX_image_view_handle === - vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) ); - vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandle64NVX" ) ); - vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) ); - vkGetDeviceCombinedImageSamplerIndexNVX = - PFN_vkGetDeviceCombinedImageSamplerIndexNVX( vkGetDeviceProcAddr( device, "vkGetDeviceCombinedImageSamplerIndexNVX" ) ); - - //=== VK_AMD_draw_indirect_count === - vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) ); - if ( !vkCmdDrawIndirectCount ) - vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; - vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) ); - if ( !vkCmdDrawIndexedIndirectCount ) - vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; - - //=== VK_AMD_shader_info === - vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) ); - - //=== VK_KHR_dynamic_rendering === - vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) ); - if ( !vkCmdBeginRendering ) - vkCmdBeginRendering = vkCmdBeginRenderingKHR; - vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) ); - if ( !vkCmdEndRendering ) - vkCmdEndRendering = vkCmdEndRenderingKHR; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_device_group === - vkGetDeviceGroupPeerMemoryFeaturesKHR = - PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); - if ( !vkGetDeviceGroupPeerMemoryFeatures ) - vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; - vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) ); - if ( !vkCmdSetDeviceMask ) - vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; - vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) ); - if ( !vkCmdDispatchBase ) - vkCmdDispatchBase = vkCmdDispatchBaseKHR; - - //=== VK_KHR_maintenance1 === - vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) ); - if ( !vkTrimCommandPool ) - vkTrimCommandPool = vkTrimCommandPoolKHR; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) ); - vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) ); - vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) ); - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) ); - vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) ); - vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) ); - - //=== VK_KHR_push_descriptor === - vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) ); - if ( !vkCmdPushDescriptorSet ) - vkCmdPushDescriptorSet = vkCmdPushDescriptorSetKHR; - vkCmdPushDescriptorSetWithTemplateKHR = - PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) ); - if ( !vkCmdPushDescriptorSetWithTemplate ) - vkCmdPushDescriptorSetWithTemplate = vkCmdPushDescriptorSetWithTemplateKHR; - - //=== VK_EXT_conditional_rendering === - vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) ); - vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) ); - - //=== VK_KHR_descriptor_update_template === - vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) ); - if ( !vkCreateDescriptorUpdateTemplate ) - vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; - vkDestroyDescriptorUpdateTemplateKHR = - PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) ); - if ( !vkDestroyDescriptorUpdateTemplate ) - vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; - vkUpdateDescriptorSetWithTemplateKHR = - PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) ); - if ( !vkUpdateDescriptorSetWithTemplate ) - vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; - - //=== VK_NV_clip_space_w_scaling === - vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) ); - - //=== VK_EXT_display_control === - vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) ); - vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) ); - vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) ); - vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) ); - - //=== VK_GOOGLE_display_timing === - vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) ); - vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) ); - - //=== VK_EXT_discard_rectangles === - vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) ); - vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEnableEXT" ) ); - vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleModeEXT" ) ); - - //=== VK_EXT_hdr_metadata === - vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) ); - - //=== VK_KHR_create_renderpass2 === - vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) ); - if ( !vkCreateRenderPass2 ) - vkCreateRenderPass2 = vkCreateRenderPass2KHR; - vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) ); - if ( !vkCmdBeginRenderPass2 ) - vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; - vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) ); - if ( !vkCmdNextSubpass2 ) - vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; - vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) ); - if ( !vkCmdEndRenderPass2 ) - vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; - - //=== VK_KHR_shared_presentable_image === - vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) ); - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) ); - vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) ); - vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) ); - - //=== VK_KHR_performance_query === - vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) ); - vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) ); - - //=== VK_EXT_debug_utils === - vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) ); - vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) ); - vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) ); - vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) ); - vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) ); - vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) ); - vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) ); - vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) ); - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - vkGetAndroidHardwareBufferPropertiesANDROID = - PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) ); - vkGetMemoryAndroidHardwareBufferANDROID = - PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - vkCreateExecutionGraphPipelinesAMDX = PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetDeviceProcAddr( device, "vkCreateExecutionGraphPipelinesAMDX" ) ); - vkGetExecutionGraphPipelineScratchSizeAMDX = - PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) ); - vkGetExecutionGraphPipelineNodeIndexAMDX = - PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) ); - vkCmdInitializeGraphScratchMemoryAMDX = - PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetDeviceProcAddr( device, "vkCmdInitializeGraphScratchMemoryAMDX" ) ); - vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphAMDX" ) ); - vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectAMDX" ) ); - vkCmdDispatchGraphIndirectCountAMDX = PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectCountAMDX" ) ); -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - vkWriteSamplerDescriptorsEXT = PFN_vkWriteSamplerDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteSamplerDescriptorsEXT" ) ); - vkWriteResourceDescriptorsEXT = PFN_vkWriteResourceDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteResourceDescriptorsEXT" ) ); - vkCmdBindSamplerHeapEXT = PFN_vkCmdBindSamplerHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindSamplerHeapEXT" ) ); - vkCmdBindResourceHeapEXT = PFN_vkCmdBindResourceHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindResourceHeapEXT" ) ); - vkCmdPushDataEXT = PFN_vkCmdPushDataEXT( vkGetDeviceProcAddr( device, "vkCmdPushDataEXT" ) ); - vkGetImageOpaqueCaptureDataEXT = PFN_vkGetImageOpaqueCaptureDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDataEXT" ) ); - vkRegisterCustomBorderColorEXT = PFN_vkRegisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkRegisterCustomBorderColorEXT" ) ); - vkUnregisterCustomBorderColorEXT = PFN_vkUnregisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkUnregisterCustomBorderColorEXT" ) ); - vkGetTensorOpaqueCaptureDataARM = PFN_vkGetTensorOpaqueCaptureDataARM( vkGetDeviceProcAddr( device, "vkGetTensorOpaqueCaptureDataARM" ) ); - - //=== VK_EXT_sample_locations === - vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) ); - - //=== VK_KHR_get_memory_requirements2 === - vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) ); - if ( !vkGetImageMemoryRequirements2 ) - vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; - vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) ); - if ( !vkGetBufferMemoryRequirements2 ) - vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; - vkGetImageSparseMemoryRequirements2KHR = - PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) ); - if ( !vkGetImageSparseMemoryRequirements2 ) - vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; - - //=== VK_KHR_acceleration_structure === - vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) ); - vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) ); - vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) ); - vkCmdBuildAccelerationStructuresIndirectKHR = - PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) ); - vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) ); - vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) ); - vkCopyAccelerationStructureToMemoryKHR = - PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) ); - vkCopyMemoryToAccelerationStructureKHR = - PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) ); - vkWriteAccelerationStructuresPropertiesKHR = - PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) ); - vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) ); - vkCmdCopyAccelerationStructureToMemoryKHR = - PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) ); - vkCmdCopyMemoryToAccelerationStructureKHR = - PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) ); - vkGetAccelerationStructureDeviceAddressKHR = - PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) ); - vkCmdWriteAccelerationStructuresPropertiesKHR = - PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) ); - vkGetDeviceAccelerationStructureCompatibilityKHR = - PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) ); - vkGetAccelerationStructureBuildSizesKHR = - PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) ); - - //=== VK_KHR_ray_tracing_pipeline === - vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) ); - vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) ); - vkGetRayTracingShaderGroupHandlesKHR = - PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) ); - vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = - PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) ); - vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) ); - vkGetRayTracingShaderGroupStackSizeKHR = - PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) ); - vkCmdSetRayTracingPipelineStackSizeKHR = - PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); - - //=== VK_KHR_sampler_ycbcr_conversion === - vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) ); - if ( !vkCreateSamplerYcbcrConversion ) - vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; - vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) ); - if ( !vkDestroySamplerYcbcrConversion ) - vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; - - //=== VK_KHR_bind_memory2 === - vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) ); - if ( !vkBindBufferMemory2 ) - vkBindBufferMemory2 = vkBindBufferMemory2KHR; - vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) ); - if ( !vkBindImageMemory2 ) - vkBindImageMemory2 = vkBindImageMemory2KHR; - - //=== VK_EXT_image_drm_format_modifier === - vkGetImageDrmFormatModifierPropertiesEXT = - PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) ); - - //=== VK_EXT_validation_cache === - vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) ); - vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) ); - vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) ); - vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) ); - - //=== VK_NV_shading_rate_image === - vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) ); - vkCmdSetViewportShadingRatePaletteNV = - PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) ); - vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) ); - - //=== VK_NV_ray_tracing === - vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) ); - vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) ); - vkGetAccelerationStructureMemoryRequirementsNV = - PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) ); - vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) ); - vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) ); - vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) ); - vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) ); - vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) ); - vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) ); - if ( !vkGetRayTracingShaderGroupHandlesKHR ) - vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; - vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) ); - vkCmdWriteAccelerationStructuresPropertiesNV = - PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) ); - vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) ); - - //=== VK_KHR_maintenance3 === - vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) ); - if ( !vkGetDescriptorSetLayoutSupport ) - vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; - - //=== VK_KHR_draw_indirect_count === - vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) ); - if ( !vkCmdDrawIndirectCount ) - vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; - vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) ); - if ( !vkCmdDrawIndexedIndirectCount ) - vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; - - //=== VK_EXT_external_memory_host === - vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) ); - - //=== VK_AMD_buffer_marker === - vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) ); - vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) ); - - //=== VK_EXT_calibrated_timestamps === - vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) ); - if ( !vkGetCalibratedTimestampsKHR ) - vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT; - - //=== VK_NV_mesh_shader === - vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) ); - vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) ); - vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) ); - - //=== VK_NV_scissor_exclusive === - vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorEnableNV" ) ); - vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) ); - - //=== VK_NV_device_diagnostic_checkpoints === - vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) ); - vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) ); - vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) ); - - //=== VK_KHR_timeline_semaphore === - vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) ); - if ( !vkGetSemaphoreCounterValue ) - vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; - vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) ); - if ( !vkWaitSemaphores ) - vkWaitSemaphores = vkWaitSemaphoresKHR; - vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) ); - if ( !vkSignalSemaphore ) - vkSignalSemaphore = vkSignalSemaphoreKHR; - - //=== VK_EXT_present_timing === - vkSetSwapchainPresentTimingQueueSizeEXT = - PFN_vkSetSwapchainPresentTimingQueueSizeEXT( vkGetDeviceProcAddr( device, "vkSetSwapchainPresentTimingQueueSizeEXT" ) ); - vkGetSwapchainTimingPropertiesEXT = PFN_vkGetSwapchainTimingPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimingPropertiesEXT" ) ); - vkGetSwapchainTimeDomainPropertiesEXT = - PFN_vkGetSwapchainTimeDomainPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimeDomainPropertiesEXT" ) ); - vkGetPastPresentationTimingEXT = PFN_vkGetPastPresentationTimingEXT( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingEXT" ) ); - - //=== VK_INTEL_performance_query === - vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) ); - vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) ); - vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) ); - vkCmdSetPerformanceStreamMarkerINTEL = - PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); - vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) ); - vkAcquirePerformanceConfigurationINTEL = - PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) ); - vkReleasePerformanceConfigurationINTEL = - PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) ); - vkQueueSetPerformanceConfigurationINTEL = - PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) ); - vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) ); - - //=== VK_AMD_display_native_hdr === - vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) ); - - //=== VK_KHR_fragment_shading_rate === - vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) ); - - //=== VK_KHR_dynamic_rendering_local_read === - vkCmdSetRenderingAttachmentLocationsKHR = - PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocationsKHR" ) ); - if ( !vkCmdSetRenderingAttachmentLocations ) - vkCmdSetRenderingAttachmentLocations = vkCmdSetRenderingAttachmentLocationsKHR; - vkCmdSetRenderingInputAttachmentIndicesKHR = - PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) ); - if ( !vkCmdSetRenderingInputAttachmentIndices ) - vkCmdSetRenderingInputAttachmentIndices = vkCmdSetRenderingInputAttachmentIndicesKHR; - - //=== VK_EXT_buffer_device_address === - vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) ); - if ( !vkGetBufferDeviceAddress ) - vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; - - //=== VK_KHR_present_wait === - vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) ); - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) ); - vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) ); - vkGetDeviceGroupSurfacePresentModes2EXT = - PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_buffer_device_address === - vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) ); - if ( !vkGetBufferDeviceAddress ) - vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; - vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) ); - if ( !vkGetBufferOpaqueCaptureAddress ) - vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; - vkGetDeviceMemoryOpaqueCaptureAddressKHR = - PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) ); - if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) - vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; - - //=== VK_EXT_line_rasterization === - vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) ); - if ( !vkCmdSetLineStipple ) - vkCmdSetLineStipple = vkCmdSetLineStippleEXT; - - //=== VK_EXT_host_query_reset === - vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) ); - if ( !vkResetQueryPool ) - vkResetQueryPool = vkResetQueryPoolEXT; - - //=== VK_EXT_extended_dynamic_state === - vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) ); - if ( !vkCmdSetCullMode ) - vkCmdSetCullMode = vkCmdSetCullModeEXT; - vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) ); - if ( !vkCmdSetFrontFace ) - vkCmdSetFrontFace = vkCmdSetFrontFaceEXT; - vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) ); - if ( !vkCmdSetPrimitiveTopology ) - vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT; - vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) ); - if ( !vkCmdSetViewportWithCount ) - vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT; - vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) ); - if ( !vkCmdSetScissorWithCount ) - vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT; - vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) ); - if ( !vkCmdBindVertexBuffers2 ) - vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT; - vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) ); - if ( !vkCmdSetDepthTestEnable ) - vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT; - vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) ); - if ( !vkCmdSetDepthWriteEnable ) - vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT; - vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) ); - if ( !vkCmdSetDepthCompareOp ) - vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT; - vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) ); - if ( !vkCmdSetDepthBoundsTestEnable ) - vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT; - vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) ); - if ( !vkCmdSetStencilTestEnable ) - vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT; - vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) ); - if ( !vkCmdSetStencilOp ) - vkCmdSetStencilOp = vkCmdSetStencilOpEXT; - - //=== VK_KHR_deferred_host_operations === - vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) ); - vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) ); - vkGetDeferredOperationMaxConcurrencyKHR = - PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) ); - vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) ); - vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) ); - - //=== VK_KHR_pipeline_executable_properties === - vkGetPipelineExecutablePropertiesKHR = - PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) ); - vkGetPipelineExecutableStatisticsKHR = - PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) ); - vkGetPipelineExecutableInternalRepresentationsKHR = - PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) ); - - //=== VK_EXT_host_image_copy === - vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToImageEXT" ) ); - if ( !vkCopyMemoryToImage ) - vkCopyMemoryToImage = vkCopyMemoryToImageEXT; - vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyImageToMemoryEXT" ) ); - if ( !vkCopyImageToMemory ) - vkCopyImageToMemory = vkCopyImageToMemoryEXT; - vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetDeviceProcAddr( device, "vkCopyImageToImageEXT" ) ); - if ( !vkCopyImageToImage ) - vkCopyImageToImage = vkCopyImageToImageEXT; - vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetDeviceProcAddr( device, "vkTransitionImageLayoutEXT" ) ); - if ( !vkTransitionImageLayout ) - vkTransitionImageLayout = vkTransitionImageLayoutEXT; - vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) ); - if ( !vkGetImageSubresourceLayout2 ) - vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2EXT; - - //=== VK_KHR_map_memory2 === - vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetDeviceProcAddr( device, "vkMapMemory2KHR" ) ); - if ( !vkMapMemory2 ) - vkMapMemory2 = vkMapMemory2KHR; - vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetDeviceProcAddr( device, "vkUnmapMemory2KHR" ) ); - if ( !vkUnmapMemory2 ) - vkUnmapMemory2 = vkUnmapMemory2KHR; - - //=== VK_EXT_swapchain_maintenance1 === - vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesEXT" ) ); - if ( !vkReleaseSwapchainImagesKHR ) - vkReleaseSwapchainImagesKHR = vkReleaseSwapchainImagesEXT; - - //=== VK_NV_device_generated_commands === - vkGetGeneratedCommandsMemoryRequirementsNV = - PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) ); - vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) ); - vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) ); - vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) ); - vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) ); - vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) ); - - //=== VK_EXT_depth_bias_control === - vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias2EXT" ) ); - - //=== VK_EXT_private_data === - vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) ); - if ( !vkCreatePrivateDataSlot ) - vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT; - vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) ); - if ( !vkDestroyPrivateDataSlot ) - vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT; - vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) ); - if ( !vkSetPrivateData ) - vkSetPrivateData = vkSetPrivateDataEXT; - vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) ); - if ( !vkGetPrivateData ) - vkGetPrivateData = vkGetPrivateDataEXT; - - //=== VK_KHR_video_encode_queue === - vkGetEncodedVideoSessionParametersKHR = - PFN_vkGetEncodedVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkGetEncodedVideoSessionParametersKHR" ) ); - vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) ); - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetDeviceProcAddr( device, "vkCreateCudaModuleNV" ) ); - vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetDeviceProcAddr( device, "vkGetCudaModuleCacheNV" ) ); - vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetDeviceProcAddr( device, "vkCreateCudaFunctionNV" ) ); - vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetDeviceProcAddr( device, "vkDestroyCudaModuleNV" ) ); - vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetDeviceProcAddr( device, "vkDestroyCudaFunctionNV" ) ); - vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetDeviceProcAddr( device, "vkCmdCudaLaunchKernelNV" ) ); -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - vkCmdDispatchTileQCOM = PFN_vkCmdDispatchTileQCOM( vkGetDeviceProcAddr( device, "vkCmdDispatchTileQCOM" ) ); - vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdBeginPerTileExecutionQCOM" ) ); - vkCmdEndPerTileExecutionQCOM = PFN_vkCmdEndPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdEndPerTileExecutionQCOM" ) ); - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) ); -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_synchronization2 === - vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) ); - if ( !vkCmdSetEvent2 ) - vkCmdSetEvent2 = vkCmdSetEvent2KHR; - vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) ); - if ( !vkCmdResetEvent2 ) - vkCmdResetEvent2 = vkCmdResetEvent2KHR; - vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) ); - if ( !vkCmdWaitEvents2 ) - vkCmdWaitEvents2 = vkCmdWaitEvents2KHR; - vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) ); - if ( !vkCmdPipelineBarrier2 ) - vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR; - vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) ); - if ( !vkCmdWriteTimestamp2 ) - vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR; - vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) ); - if ( !vkQueueSubmit2 ) - vkQueueSubmit2 = vkQueueSubmit2KHR; - - //=== VK_EXT_descriptor_buffer === - vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSizeEXT" ) ); - vkGetDescriptorSetLayoutBindingOffsetEXT = - PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) ); - vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorEXT" ) ); - vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBuffersEXT" ) ); - vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsetsEXT" ) ); - vkCmdBindDescriptorBufferEmbeddedSamplersEXT = - PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) ); - vkGetBufferOpaqueCaptureDescriptorDataEXT = - PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) ); - vkGetImageOpaqueCaptureDescriptorDataEXT = - PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) ); - vkGetImageViewOpaqueCaptureDescriptorDataEXT = - PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) ); - vkGetSamplerOpaqueCaptureDescriptorDataEXT = - PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) ); - vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( - vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) ); - - //=== VK_NV_fragment_shading_rate_enums === - vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) ); - - //=== VK_EXT_mesh_shader === - vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) ); - vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) ); - vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) ); - - //=== VK_KHR_copy_commands2 === - vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) ); - if ( !vkCmdCopyBuffer2 ) - vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR; - vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) ); - if ( !vkCmdCopyImage2 ) - vkCmdCopyImage2 = vkCmdCopyImage2KHR; - vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) ); - if ( !vkCmdCopyBufferToImage2 ) - vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR; - vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) ); - if ( !vkCmdCopyImageToBuffer2 ) - vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR; - vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) ); - if ( !vkCmdBlitImage2 ) - vkCmdBlitImage2 = vkCmdBlitImage2KHR; - vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) ); - if ( !vkCmdResolveImage2 ) - vkCmdResolveImage2 = vkCmdResolveImage2KHR; - - //=== VK_EXT_device_fault === - vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) ); - - //=== VK_EXT_vertex_input_dynamic_state === - vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) ); - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) ); - vkGetMemoryZirconHandlePropertiesFUCHSIA = - PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) ); -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - vkImportSemaphoreZirconHandleFUCHSIA = - PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) ); - vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) ); -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) ); - vkSetBufferCollectionImageConstraintsFUCHSIA = - PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) ); - vkSetBufferCollectionBufferConstraintsFUCHSIA = - PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) ); - vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) ); - vkGetBufferCollectionPropertiesFUCHSIA = - PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) ); -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = - PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) ); - vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) ); - - //=== VK_HUAWEI_invocation_mask === - vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) ); - - //=== VK_NV_external_memory_rdma === - vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) ); - - //=== VK_EXT_pipeline_properties === - vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) ); - - //=== VK_EXT_extended_dynamic_state2 === - vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) ); - vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) ); - if ( !vkCmdSetRasterizerDiscardEnable ) - vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT; - vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) ); - if ( !vkCmdSetDepthBiasEnable ) - vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT; - vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) ); - vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) ); - if ( !vkCmdSetPrimitiveRestartEnable ) - vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT; - - //=== VK_EXT_color_write_enable === - vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) ); - - //=== VK_KHR_ray_tracing_maintenance1 === - vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) ); - - //=== VK_EXT_multi_draw === - vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) ); - vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) ); - - //=== VK_EXT_opacity_micromap === - vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetDeviceProcAddr( device, "vkCreateMicromapEXT" ) ); - vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetDeviceProcAddr( device, "vkDestroyMicromapEXT" ) ); - vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkCmdBuildMicromapsEXT" ) ); - vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkBuildMicromapsEXT" ) ); - vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapEXT" ) ); - vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapToMemoryEXT" ) ); - vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToMicromapEXT" ) ); - vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkWriteMicromapsPropertiesEXT" ) ); - vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapEXT" ) ); - vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapToMemoryEXT" ) ); - vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToMicromapEXT" ) ); - vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkCmdWriteMicromapsPropertiesEXT" ) ); - vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetDeviceProcAddr( device, "vkGetDeviceMicromapCompatibilityEXT" ) ); - vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetDeviceProcAddr( device, "vkGetMicromapBuildSizesEXT" ) ); - - //=== VK_HUAWEI_cluster_culling_shader === - vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterHUAWEI" ) ); - vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterIndirectHUAWEI" ) ); - - //=== VK_EXT_pageable_device_local_memory === - vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) ); - - //=== VK_KHR_maintenance4 === - vkGetDeviceBufferMemoryRequirementsKHR = - PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) ); - if ( !vkGetDeviceBufferMemoryRequirements ) - vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR; - vkGetDeviceImageMemoryRequirementsKHR = - PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) ); - if ( !vkGetDeviceImageMemoryRequirements ) - vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR; - vkGetDeviceImageSparseMemoryRequirementsKHR = - PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) ); - if ( !vkGetDeviceImageSparseMemoryRequirements ) - vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR; - - //=== VK_VALVE_descriptor_set_host_mapping === - vkGetDescriptorSetLayoutHostMappingInfoVALVE = - PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) ); - vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetHostMappingVALVE" ) ); - - //=== VK_NV_copy_memory_indirect === - vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectNV" ) ); - vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectNV" ) ); - - //=== VK_NV_memory_decompression === - vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryNV" ) ); - vkCmdDecompressMemoryIndirectCountNV = - PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountNV" ) ); - - //=== VK_NV_device_generated_commands_compute === - vkGetPipelineIndirectMemoryRequirementsNV = - PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectMemoryRequirementsNV" ) ); - vkCmdUpdatePipelineIndirectBufferNV = PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetDeviceProcAddr( device, "vkCmdUpdatePipelineIndirectBufferNV" ) ); - vkGetPipelineIndirectDeviceAddressNV = - PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectDeviceAddressNV" ) ); - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - vkGetNativeBufferPropertiesOHOS = PFN_vkGetNativeBufferPropertiesOHOS( vkGetDeviceProcAddr( device, "vkGetNativeBufferPropertiesOHOS" ) ); - vkGetMemoryNativeBufferOHOS = PFN_vkGetMemoryNativeBufferOHOS( vkGetDeviceProcAddr( device, "vkGetMemoryNativeBufferOHOS" ) ); -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_extended_dynamic_state3 === - vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) ); - vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) ); - vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) ); - vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleMaskEXT" ) ); - vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToCoverageEnableEXT" ) ); - vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToOneEnableEXT" ) ); - vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEnableEXT" ) ); - vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) ); - vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) ); - vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) ); - vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) ); - vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) ); - vkCmdSetConservativeRasterizationModeEXT = - PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) ); - vkCmdSetExtraPrimitiveOverestimationSizeEXT = - PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetDeviceProcAddr( device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) ); - vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipEnableEXT" ) ); - vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEnableEXT" ) ); - vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendAdvancedEXT" ) ); - vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetProvokingVertexModeEXT" ) ); - vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineRasterizationModeEXT" ) ); - vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEnableEXT" ) ); - vkCmdSetDepthClipNegativeOneToOneEXT = - PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipNegativeOneToOneEXT" ) ); - vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingEnableNV" ) ); - vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportSwizzleNV" ) ); - vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorEnableNV" ) ); - vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorLocationNV" ) ); - vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationModeNV" ) ); - vkCmdSetCoverageModulationTableEnableNV = - PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableEnableNV" ) ); - vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableNV" ) ); - vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetShadingRateImageEnableNV" ) ); - vkCmdSetRepresentativeFragmentTestEnableNV = - PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetRepresentativeFragmentTestEnableNV" ) ); - vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageReductionModeNV" ) ); - - //=== VK_ARM_tensors === - vkCreateTensorARM = PFN_vkCreateTensorARM( vkGetDeviceProcAddr( device, "vkCreateTensorARM" ) ); - vkDestroyTensorARM = PFN_vkDestroyTensorARM( vkGetDeviceProcAddr( device, "vkDestroyTensorARM" ) ); - vkCreateTensorViewARM = PFN_vkCreateTensorViewARM( vkGetDeviceProcAddr( device, "vkCreateTensorViewARM" ) ); - vkDestroyTensorViewARM = PFN_vkDestroyTensorViewARM( vkGetDeviceProcAddr( device, "vkDestroyTensorViewARM" ) ); - vkGetTensorMemoryRequirementsARM = PFN_vkGetTensorMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetTensorMemoryRequirementsARM" ) ); - vkBindTensorMemoryARM = PFN_vkBindTensorMemoryARM( vkGetDeviceProcAddr( device, "vkBindTensorMemoryARM" ) ); - vkGetDeviceTensorMemoryRequirementsARM = - PFN_vkGetDeviceTensorMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDeviceTensorMemoryRequirementsARM" ) ); - vkCmdCopyTensorARM = PFN_vkCmdCopyTensorARM( vkGetDeviceProcAddr( device, "vkCmdCopyTensorARM" ) ); - vkGetTensorOpaqueCaptureDescriptorDataARM = - PFN_vkGetTensorOpaqueCaptureDescriptorDataARM( vkGetDeviceProcAddr( device, "vkGetTensorOpaqueCaptureDescriptorDataARM" ) ); - vkGetTensorViewOpaqueCaptureDescriptorDataARM = - PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM( vkGetDeviceProcAddr( device, "vkGetTensorViewOpaqueCaptureDescriptorDataARM" ) ); - - //=== VK_EXT_shader_module_identifier === - vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleIdentifierEXT" ) ); - vkGetShaderModuleCreateInfoIdentifierEXT = - PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleCreateInfoIdentifierEXT" ) ); - - //=== VK_NV_optical_flow === - vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkCreateOpticalFlowSessionNV" ) ); - vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkDestroyOpticalFlowSessionNV" ) ); - vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) ); - vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) ); - - //=== VK_KHR_maintenance5 === - vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2KHR" ) ); - if ( !vkCmdBindIndexBuffer2 ) - vkCmdBindIndexBuffer2 = vkCmdBindIndexBuffer2KHR; - vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularityKHR" ) ); - if ( !vkGetRenderingAreaGranularity ) - vkGetRenderingAreaGranularity = vkGetRenderingAreaGranularityKHR; - vkGetDeviceImageSubresourceLayoutKHR = - PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayoutKHR" ) ); - if ( !vkGetDeviceImageSubresourceLayout ) - vkGetDeviceImageSubresourceLayout = vkGetDeviceImageSubresourceLayoutKHR; - vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2KHR" ) ); - if ( !vkGetImageSubresourceLayout2 ) - vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2KHR; - - //=== VK_AMD_anti_lag === - vkAntiLagUpdateAMD = PFN_vkAntiLagUpdateAMD( vkGetDeviceProcAddr( device, "vkAntiLagUpdateAMD" ) ); - - //=== VK_KHR_present_wait2 === - vkWaitForPresent2KHR = PFN_vkWaitForPresent2KHR( vkGetDeviceProcAddr( device, "vkWaitForPresent2KHR" ) ); - - //=== VK_EXT_shader_object === - vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetDeviceProcAddr( device, "vkCreateShadersEXT" ) ); - vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetDeviceProcAddr( device, "vkDestroyShaderEXT" ) ); - vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) ); - vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) ); - vkCmdSetDepthClampRangeEXT = PFN_vkCmdSetDepthClampRangeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampRangeEXT" ) ); - - //=== VK_KHR_pipeline_binary === - vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetDeviceProcAddr( device, "vkCreatePipelineBinariesKHR" ) ); - vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetDeviceProcAddr( device, "vkDestroyPipelineBinaryKHR" ) ); - vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetDeviceProcAddr( device, "vkGetPipelineKeyKHR" ) ); - vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetDeviceProcAddr( device, "vkGetPipelineBinaryDataKHR" ) ); - vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetDeviceProcAddr( device, "vkReleaseCapturedPipelineDataKHR" ) ); - - //=== VK_QCOM_tile_properties === - vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) ); - vkGetDynamicRenderingTilePropertiesQCOM = - PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) ); - - //=== VK_KHR_swapchain_maintenance1 === - vkReleaseSwapchainImagesKHR = PFN_vkReleaseSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesKHR" ) ); - - //=== VK_NV_cooperative_vector === - vkConvertCooperativeVectorMatrixNV = PFN_vkConvertCooperativeVectorMatrixNV( vkGetDeviceProcAddr( device, "vkConvertCooperativeVectorMatrixNV" ) ); - vkCmdConvertCooperativeVectorMatrixNV = - PFN_vkCmdConvertCooperativeVectorMatrixNV( vkGetDeviceProcAddr( device, "vkCmdConvertCooperativeVectorMatrixNV" ) ); - - //=== VK_NV_low_latency2 === - vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetDeviceProcAddr( device, "vkSetLatencySleepModeNV" ) ); - vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetDeviceProcAddr( device, "vkLatencySleepNV" ) ); - vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetDeviceProcAddr( device, "vkSetLatencyMarkerNV" ) ); - vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetDeviceProcAddr( device, "vkGetLatencyTimingsNV" ) ); - vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetDeviceProcAddr( device, "vkQueueNotifyOutOfBandNV" ) ); - - //=== VK_ARM_data_graph === - vkCreateDataGraphPipelinesARM = PFN_vkCreateDataGraphPipelinesARM( vkGetDeviceProcAddr( device, "vkCreateDataGraphPipelinesARM" ) ); - vkCreateDataGraphPipelineSessionARM = PFN_vkCreateDataGraphPipelineSessionARM( vkGetDeviceProcAddr( device, "vkCreateDataGraphPipelineSessionARM" ) ); - vkGetDataGraphPipelineSessionBindPointRequirementsARM = - PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineSessionBindPointRequirementsARM" ) ); - vkGetDataGraphPipelineSessionMemoryRequirementsARM = - PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineSessionMemoryRequirementsARM" ) ); - vkBindDataGraphPipelineSessionMemoryARM = - PFN_vkBindDataGraphPipelineSessionMemoryARM( vkGetDeviceProcAddr( device, "vkBindDataGraphPipelineSessionMemoryARM" ) ); - vkDestroyDataGraphPipelineSessionARM = - PFN_vkDestroyDataGraphPipelineSessionARM( vkGetDeviceProcAddr( device, "vkDestroyDataGraphPipelineSessionARM" ) ); - vkCmdDispatchDataGraphARM = PFN_vkCmdDispatchDataGraphARM( vkGetDeviceProcAddr( device, "vkCmdDispatchDataGraphARM" ) ); - vkGetDataGraphPipelineAvailablePropertiesARM = - PFN_vkGetDataGraphPipelineAvailablePropertiesARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineAvailablePropertiesARM" ) ); - vkGetDataGraphPipelinePropertiesARM = PFN_vkGetDataGraphPipelinePropertiesARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelinePropertiesARM" ) ); - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - vkCmdSetAttachmentFeedbackLoopEnableEXT = - PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) ); - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) ); -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_KHR_line_rasterization === - vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleKHR" ) ); - if ( !vkCmdSetLineStipple ) - vkCmdSetLineStipple = vkCmdSetLineStippleKHR; - - //=== VK_KHR_calibrated_timestamps === - vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) ); - - //=== VK_KHR_maintenance6 === - vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2KHR" ) ); - if ( !vkCmdBindDescriptorSets2 ) - vkCmdBindDescriptorSets2 = vkCmdBindDescriptorSets2KHR; - vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetDeviceProcAddr( device, "vkCmdPushConstants2KHR" ) ); - if ( !vkCmdPushConstants2 ) - vkCmdPushConstants2 = vkCmdPushConstants2KHR; - vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2KHR" ) ); - if ( !vkCmdPushDescriptorSet2 ) - vkCmdPushDescriptorSet2 = vkCmdPushDescriptorSet2KHR; - vkCmdPushDescriptorSetWithTemplate2KHR = - PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2KHR" ) ); - if ( !vkCmdPushDescriptorSetWithTemplate2 ) - vkCmdPushDescriptorSetWithTemplate2 = vkCmdPushDescriptorSetWithTemplate2KHR; - vkCmdSetDescriptorBufferOffsets2EXT = PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsets2EXT" ) ); - vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = - PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); - - //=== VK_QCOM_tile_memory_heap === - vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetDeviceProcAddr( device, "vkCmdBindTileMemoryQCOM" ) ); - - //=== VK_KHR_copy_memory_indirect === - vkCmdCopyMemoryIndirectKHR = PFN_vkCmdCopyMemoryIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectKHR" ) ); - vkCmdCopyMemoryToImageIndirectKHR = PFN_vkCmdCopyMemoryToImageIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectKHR" ) ); - - //=== VK_EXT_memory_decompression === - vkCmdDecompressMemoryEXT = PFN_vkCmdDecompressMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryEXT" ) ); - vkCmdDecompressMemoryIndirectCountEXT = - PFN_vkCmdDecompressMemoryIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountEXT" ) ); - - //=== VK_NV_external_compute_queue === - vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) ); - vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) ); - vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetDeviceProcAddr( device, "vkGetExternalComputeQueueDataNV" ) ); - - //=== VK_NV_cluster_acceleration_structure === - vkGetClusterAccelerationStructureBuildSizesNV = - PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetClusterAccelerationStructureBuildSizesNV" ) ); - vkCmdBuildClusterAccelerationStructureIndirectNV = - PFN_vkCmdBuildClusterAccelerationStructureIndirectNV( vkGetDeviceProcAddr( device, "vkCmdBuildClusterAccelerationStructureIndirectNV" ) ); - - //=== VK_NV_partitioned_acceleration_structure === - vkGetPartitionedAccelerationStructuresBuildSizesNV = - PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetPartitionedAccelerationStructuresBuildSizesNV" ) ); - vkCmdBuildPartitionedAccelerationStructuresNV = - PFN_vkCmdBuildPartitionedAccelerationStructuresNV( vkGetDeviceProcAddr( device, "vkCmdBuildPartitionedAccelerationStructuresNV" ) ); - - //=== VK_EXT_device_generated_commands === - vkGetGeneratedCommandsMemoryRequirementsEXT = - PFN_vkGetGeneratedCommandsMemoryRequirementsEXT( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsEXT" ) ); - vkCmdPreprocessGeneratedCommandsEXT = PFN_vkCmdPreprocessGeneratedCommandsEXT( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsEXT" ) ); - vkCmdExecuteGeneratedCommandsEXT = PFN_vkCmdExecuteGeneratedCommandsEXT( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsEXT" ) ); - vkCreateIndirectCommandsLayoutEXT = PFN_vkCreateIndirectCommandsLayoutEXT( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutEXT" ) ); - vkDestroyIndirectCommandsLayoutEXT = PFN_vkDestroyIndirectCommandsLayoutEXT( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutEXT" ) ); - vkCreateIndirectExecutionSetEXT = PFN_vkCreateIndirectExecutionSetEXT( vkGetDeviceProcAddr( device, "vkCreateIndirectExecutionSetEXT" ) ); - vkDestroyIndirectExecutionSetEXT = PFN_vkDestroyIndirectExecutionSetEXT( vkGetDeviceProcAddr( device, "vkDestroyIndirectExecutionSetEXT" ) ); - vkUpdateIndirectExecutionSetPipelineEXT = - PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetPipelineEXT" ) ); - vkUpdateIndirectExecutionSetShaderEXT = - PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetShaderEXT" ) ); - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) ); - vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) ); -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_fragment_density_map_offset === - vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdEndRendering2EXT" ) ); - if ( !vkCmdEndRendering2KHR ) - vkCmdEndRendering2KHR = vkCmdEndRendering2EXT; - - //=== VK_EXT_custom_resolve === - vkCmdBeginCustomResolveEXT = PFN_vkCmdBeginCustomResolveEXT( vkGetDeviceProcAddr( device, "vkCmdBeginCustomResolveEXT" ) ); - - //=== VK_KHR_maintenance10 === - vkCmdEndRendering2KHR = PFN_vkCmdEndRendering2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRendering2KHR" ) ); - - //=== VK_NV_compute_occupancy_priority === - vkCmdSetComputeOccupancyPriorityNV = PFN_vkCmdSetComputeOccupancyPriorityNV( vkGetDeviceProcAddr( device, "vkCmdSetComputeOccupancyPriorityNV" ) ); - } - - template - void init( Instance const & instance, Device const & device, DynamicLoader const & dl ) VULKAN_HPP_NOEXCEPT - { - PFN_vkGetInstanceProcAddr getInstanceProcAddr = dl.template getProcAddress( "vkGetInstanceProcAddr" ); - PFN_vkGetDeviceProcAddr getDeviceProcAddr = dl.template getProcAddress( "vkGetDeviceProcAddr" ); - init( static_cast( instance ), getInstanceProcAddr, static_cast( device ), device ? getDeviceProcAddr : nullptr ); - } - - template - void init( Instance const & instance, Device const & device ) VULKAN_HPP_NOEXCEPT - { - static DynamicLoader dl; - init( instance, device, dl ); - } - }; - - } // namespace detail -} // namespace VULKAN_HPP_NAMESPACE -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_android.h b/lib/vulkan-headers/include/vulkan/vulkan_android.h deleted file mode 100644 index 1d8265e87e7..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_android.h +++ /dev/null @@ -1,159 +0,0 @@ -#ifndef VULKAN_ANDROID_H_ -#define VULKAN_ANDROID_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_KHR_android_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_android_surface 1 -struct ANativeWindow; -#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6 -#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface" -typedef VkFlags VkAndroidSurfaceCreateFlagsKHR; -typedef struct VkAndroidSurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkAndroidSurfaceCreateFlagsKHR flags; - struct ANativeWindow* window; -} VkAndroidSurfaceCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( - VkInstance instance, - const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif -#endif - - -// VK_ANDROID_external_memory_android_hardware_buffer is a preprocessor guard. Do not pass it to API calls. -#define VK_ANDROID_external_memory_android_hardware_buffer 1 -struct AHardwareBuffer; -#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION 5 -#define VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME "VK_ANDROID_external_memory_android_hardware_buffer" -typedef struct VkAndroidHardwareBufferUsageANDROID { - VkStructureType sType; - void* pNext; - uint64_t androidHardwareBufferUsage; -} VkAndroidHardwareBufferUsageANDROID; - -typedef struct VkAndroidHardwareBufferPropertiesANDROID { - VkStructureType sType; - void* pNext; - VkDeviceSize allocationSize; - uint32_t memoryTypeBits; -} VkAndroidHardwareBufferPropertiesANDROID; - -typedef struct VkAndroidHardwareBufferFormatPropertiesANDROID { - VkStructureType sType; - void* pNext; - VkFormat format; - uint64_t externalFormat; - VkFormatFeatureFlags formatFeatures; - VkComponentMapping samplerYcbcrConversionComponents; - VkSamplerYcbcrModelConversion suggestedYcbcrModel; - VkSamplerYcbcrRange suggestedYcbcrRange; - VkChromaLocation suggestedXChromaOffset; - VkChromaLocation suggestedYChromaOffset; -} VkAndroidHardwareBufferFormatPropertiesANDROID; - -typedef struct VkImportAndroidHardwareBufferInfoANDROID { - VkStructureType sType; - const void* pNext; - struct AHardwareBuffer* buffer; -} VkImportAndroidHardwareBufferInfoANDROID; - -typedef struct VkMemoryGetAndroidHardwareBufferInfoANDROID { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; -} VkMemoryGetAndroidHardwareBufferInfoANDROID; - -typedef struct VkExternalFormatANDROID { - VkStructureType sType; - void* pNext; - uint64_t externalFormat; -} VkExternalFormatANDROID; - -typedef struct VkAndroidHardwareBufferFormatProperties2ANDROID { - VkStructureType sType; - void* pNext; - VkFormat format; - uint64_t externalFormat; - VkFormatFeatureFlags2 formatFeatures; - VkComponentMapping samplerYcbcrConversionComponents; - VkSamplerYcbcrModelConversion suggestedYcbcrModel; - VkSamplerYcbcrRange suggestedYcbcrRange; - VkChromaLocation suggestedXChromaOffset; - VkChromaLocation suggestedYChromaOffset; -} VkAndroidHardwareBufferFormatProperties2ANDROID; - -typedef VkResult (VKAPI_PTR *PFN_vkGetAndroidHardwareBufferPropertiesANDROID)(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryAndroidHardwareBufferANDROID)(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetAndroidHardwareBufferPropertiesANDROID( - VkDevice device, - const struct AHardwareBuffer* buffer, - VkAndroidHardwareBufferPropertiesANDROID* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryAndroidHardwareBufferANDROID( - VkDevice device, - const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, - struct AHardwareBuffer** pBuffer); -#endif -#endif - - -// VK_ANDROID_external_format_resolve is a preprocessor guard. Do not pass it to API calls. -#define VK_ANDROID_external_format_resolve 1 -#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION 1 -#define VK_ANDROID_EXTERNAL_FORMAT_RESOLVE_EXTENSION_NAME "VK_ANDROID_external_format_resolve" -typedef struct VkPhysicalDeviceExternalFormatResolveFeaturesANDROID { - VkStructureType sType; - void* pNext; - VkBool32 externalFormatResolve; -} VkPhysicalDeviceExternalFormatResolveFeaturesANDROID; - -typedef struct VkPhysicalDeviceExternalFormatResolvePropertiesANDROID { - VkStructureType sType; - void* pNext; - VkBool32 nullColorAttachmentWithExternalFormatResolve; - VkChromaLocation externalFormatResolveChromaOffsetX; - VkChromaLocation externalFormatResolveChromaOffsetY; -} VkPhysicalDeviceExternalFormatResolvePropertiesANDROID; - -typedef struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID { - VkStructureType sType; - void* pNext; - VkFormat colorAttachmentFormat; -} VkAndroidHardwareBufferFormatResolvePropertiesANDROID; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_beta.h b/lib/vulkan-headers/include/vulkan/vulkan_beta.h deleted file mode 100644 index 147a3f3cc1f..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_beta.h +++ /dev/null @@ -1,375 +0,0 @@ -#ifndef VULKAN_BETA_H_ -#define VULKAN_BETA_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_KHR_portability_subset is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_portability_subset 1 -#define VK_KHR_PORTABILITY_SUBSET_SPEC_VERSION 1 -#define VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME "VK_KHR_portability_subset" -typedef struct VkPhysicalDevicePortabilitySubsetFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 constantAlphaColorBlendFactors; - VkBool32 events; - VkBool32 imageViewFormatReinterpretation; - VkBool32 imageViewFormatSwizzle; - VkBool32 imageView2DOn3DImage; - VkBool32 multisampleArrayImage; - VkBool32 mutableComparisonSamplers; - VkBool32 pointPolygons; - VkBool32 samplerMipLodBias; - VkBool32 separateStencilMaskRef; - VkBool32 shaderSampleRateInterpolationFunctions; - VkBool32 tessellationIsolines; - VkBool32 tessellationPointMode; - VkBool32 triangleFans; - VkBool32 vertexAttributeAccessBeyondStride; -} VkPhysicalDevicePortabilitySubsetFeaturesKHR; - -typedef struct VkPhysicalDevicePortabilitySubsetPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t minVertexInputBindingStrideAlignment; -} VkPhysicalDevicePortabilitySubsetPropertiesKHR; - - - -// VK_AMDX_shader_enqueue is a preprocessor guard. Do not pass it to API calls. -#define VK_AMDX_shader_enqueue 1 -#define VK_AMDX_SHADER_ENQUEUE_SPEC_VERSION 2 -#define VK_AMDX_SHADER_ENQUEUE_EXTENSION_NAME "VK_AMDX_shader_enqueue" -#define VK_SHADER_INDEX_UNUSED_AMDX (~0U) -typedef struct VkPhysicalDeviceShaderEnqueueFeaturesAMDX { - VkStructureType sType; - void* pNext; - VkBool32 shaderEnqueue; - VkBool32 shaderMeshEnqueue; -} VkPhysicalDeviceShaderEnqueueFeaturesAMDX; - -typedef struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX { - VkStructureType sType; - void* pNext; - uint32_t maxExecutionGraphDepth; - uint32_t maxExecutionGraphShaderOutputNodes; - uint32_t maxExecutionGraphShaderPayloadSize; - uint32_t maxExecutionGraphShaderPayloadCount; - uint32_t executionGraphDispatchAddressAlignment; - uint32_t maxExecutionGraphWorkgroupCount[3]; - uint32_t maxExecutionGraphWorkgroups; -} VkPhysicalDeviceShaderEnqueuePropertiesAMDX; - -typedef struct VkExecutionGraphPipelineScratchSizeAMDX { - VkStructureType sType; - void* pNext; - VkDeviceSize minSize; - VkDeviceSize maxSize; - VkDeviceSize sizeGranularity; -} VkExecutionGraphPipelineScratchSizeAMDX; - -typedef struct VkExecutionGraphPipelineCreateInfoAMDX { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const VkPipelineLibraryCreateInfoKHR* pLibraryInfo; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkExecutionGraphPipelineCreateInfoAMDX; - -typedef union VkDeviceOrHostAddressConstAMDX { - VkDeviceAddress deviceAddress; - const void* hostAddress; -} VkDeviceOrHostAddressConstAMDX; - -typedef struct VkDispatchGraphInfoAMDX { - uint32_t nodeIndex; - uint32_t payloadCount; - VkDeviceOrHostAddressConstAMDX payloads; - uint64_t payloadStride; -} VkDispatchGraphInfoAMDX; - -typedef struct VkDispatchGraphCountInfoAMDX { - uint32_t count; - VkDeviceOrHostAddressConstAMDX infos; - uint64_t stride; -} VkDispatchGraphCountInfoAMDX; - -typedef struct VkPipelineShaderStageNodeCreateInfoAMDX { - VkStructureType sType; - const void* pNext; - const char* pName; - uint32_t index; -} VkPipelineShaderStageNodeCreateInfoAMDX; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateExecutionGraphPipelinesAMDX)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineScratchSizeAMDX)(VkDevice device, VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetExecutionGraphPipelineNodeIndexAMDX)(VkDevice device, VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex); -typedef void (VKAPI_PTR *PFN_vkCmdInitializeGraphScratchMemoryAMDX)(VkCommandBuffer commandBuffer, VkPipeline executionGraph, VkDeviceAddress scratch, VkDeviceSize scratchSize); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphAMDX)(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectAMDX)(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, const VkDispatchGraphCountInfoAMDX* pCountInfo); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchGraphIndirectCountAMDX)(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceSize scratchSize, VkDeviceAddress countInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateExecutionGraphPipelinesAMDX( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineScratchSizeAMDX( - VkDevice device, - VkPipeline executionGraph, - VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetExecutionGraphPipelineNodeIndexAMDX( - VkDevice device, - VkPipeline executionGraph, - const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, - uint32_t* pNodeIndex); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdInitializeGraphScratchMemoryAMDX( - VkCommandBuffer commandBuffer, - VkPipeline executionGraph, - VkDeviceAddress scratch, - VkDeviceSize scratchSize); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphAMDX( - VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - const VkDispatchGraphCountInfoAMDX* pCountInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectAMDX( - VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - const VkDispatchGraphCountInfoAMDX* pCountInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchGraphIndirectCountAMDX( - VkCommandBuffer commandBuffer, - VkDeviceAddress scratch, - VkDeviceSize scratchSize, - VkDeviceAddress countInfo); -#endif -#endif - - -// VK_NV_cuda_kernel_launch is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_cuda_kernel_launch 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaModuleNV) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCudaFunctionNV) -#define VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION 2 -#define VK_NV_CUDA_KERNEL_LAUNCH_EXTENSION_NAME "VK_NV_cuda_kernel_launch" -typedef struct VkCudaModuleCreateInfoNV { - VkStructureType sType; - const void* pNext; - size_t dataSize; - const void* pData; -} VkCudaModuleCreateInfoNV; - -typedef struct VkCudaFunctionCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkCudaModuleNV module; - const char* pName; -} VkCudaFunctionCreateInfoNV; - -typedef struct VkCudaLaunchInfoNV { - VkStructureType sType; - const void* pNext; - VkCudaFunctionNV function; - uint32_t gridDimX; - uint32_t gridDimY; - uint32_t gridDimZ; - uint32_t blockDimX; - uint32_t blockDimY; - uint32_t blockDimZ; - uint32_t sharedMemBytes; - size_t paramCount; - const void* const * pParams; - size_t extraCount; - const void* const * pExtras; -} VkCudaLaunchInfoNV; - -typedef struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 cudaKernelLaunchFeatures; -} VkPhysicalDeviceCudaKernelLaunchFeaturesNV; - -typedef struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t computeCapabilityMinor; - uint32_t computeCapabilityMajor; -} VkPhysicalDeviceCudaKernelLaunchPropertiesNV; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaModuleNV)(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule); -typedef VkResult (VKAPI_PTR *PFN_vkGetCudaModuleCacheNV)(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData); -typedef VkResult (VKAPI_PTR *PFN_vkCreateCudaFunctionNV)(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction); -typedef void (VKAPI_PTR *PFN_vkDestroyCudaModuleNV)(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkDestroyCudaFunctionNV)(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkCmdCudaLaunchKernelNV)(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaModuleNV( - VkDevice device, - const VkCudaModuleCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCudaModuleNV* pModule); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetCudaModuleCacheNV( - VkDevice device, - VkCudaModuleNV module, - size_t* pCacheSize, - void* pCacheData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCudaFunctionNV( - VkDevice device, - const VkCudaFunctionCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCudaFunctionNV* pFunction); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyCudaModuleNV( - VkDevice device, - VkCudaModuleNV module, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyCudaFunctionNV( - VkDevice device, - VkCudaFunctionNV function, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV( - VkCommandBuffer commandBuffer, - const VkCudaLaunchInfoNV* pLaunchInfo); -#endif -#endif - - -// VK_NV_displacement_micromap is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_displacement_micromap 1 -#define VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION 2 -#define VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME "VK_NV_displacement_micromap" - -typedef enum VkDisplacementMicromapFormatNV { - VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV = 1, - VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV = 2, - VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV = 3, - VK_DISPLACEMENT_MICROMAP_FORMAT_MAX_ENUM_NV = 0x7FFFFFFF -} VkDisplacementMicromapFormatNV; -typedef struct VkPhysicalDeviceDisplacementMicromapFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 displacementMicromap; -} VkPhysicalDeviceDisplacementMicromapFeaturesNV; - -typedef struct VkPhysicalDeviceDisplacementMicromapPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t maxDisplacementMicromapSubdivisionLevel; -} VkPhysicalDeviceDisplacementMicromapPropertiesNV; - -typedef struct VkAccelerationStructureTrianglesDisplacementMicromapNV { - VkStructureType sType; - void* pNext; - VkFormat displacementBiasAndScaleFormat; - VkFormat displacementVectorFormat; - VkDeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer; - VkDeviceSize displacementBiasAndScaleStride; - VkDeviceOrHostAddressConstKHR displacementVectorBuffer; - VkDeviceSize displacementVectorStride; - VkDeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags; - VkDeviceSize displacedMicromapPrimitiveFlagsStride; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR indexBuffer; - VkDeviceSize indexStride; - uint32_t baseTriangle; - uint32_t usageCountsCount; - const VkMicromapUsageEXT* pUsageCounts; - const VkMicromapUsageEXT* const* ppUsageCounts; - VkMicromapEXT micromap; -} VkAccelerationStructureTrianglesDisplacementMicromapNV; - - - -// VK_AMDX_dense_geometry_format is a preprocessor guard. Do not pass it to API calls. -#define VK_AMDX_dense_geometry_format 1 -#define VK_AMDX_DENSE_GEOMETRY_FORMAT_SPEC_VERSION 1 -#define VK_AMDX_DENSE_GEOMETRY_FORMAT_EXTENSION_NAME "VK_AMDX_dense_geometry_format" -#define VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_ALIGNMENT_AMDX 128U -#define VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_BYTE_STRIDE_AMDX 128U - -typedef enum VkCompressedTriangleFormatAMDX { - VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX = 0, - VK_COMPRESSED_TRIANGLE_FORMAT_MAX_ENUM_AMDX = 0x7FFFFFFF -} VkCompressedTriangleFormatAMDX; -typedef struct VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX { - VkStructureType sType; - void* pNext; - VkBool32 denseGeometryFormat; -} VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX; - -typedef struct VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR compressedData; - VkDeviceSize dataSize; - uint32_t numTriangles; - uint32_t numVertices; - uint32_t maxPrimitiveIndex; - uint32_t maxGeometryIndex; - VkCompressedTriangleFormatAMDX format; -} VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_core.h b/lib/vulkan-headers/include/vulkan/vulkan_core.h deleted file mode 100644 index 32507d29ebc..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_core.h +++ /dev/null @@ -1,25278 +0,0 @@ -#ifndef VULKAN_CORE_H_ -#define VULKAN_CORE_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_VERSION_1_0 is a preprocessor guard. Do not pass it to API calls. -#define VK_VERSION_1_0 1 -#include "vk_platform.h" - -#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object; - - -#ifndef VK_USE_64_BIT_PTR_DEFINES - #if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__) || (defined(__riscv) && __riscv_xlen == 64) - #define VK_USE_64_BIT_PTR_DEFINES 1 - #else - #define VK_USE_64_BIT_PTR_DEFINES 0 - #endif -#endif - - -#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE - #if (VK_USE_64_BIT_PTR_DEFINES==1) - #if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L)) - #define VK_NULL_HANDLE nullptr - #else - #define VK_NULL_HANDLE ((void*)0) - #endif - #else - #define VK_NULL_HANDLE 0ULL - #endif -#endif -#ifndef VK_NULL_HANDLE - #define VK_NULL_HANDLE 0 -#endif - - -#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE - #if (VK_USE_64_BIT_PTR_DEFINES==1) - #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object; - #else - #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object; - #endif -#endif - -#define VK_MAKE_API_VERSION(variant, major, minor, patch) \ - ((((uint32_t)(variant)) << 29U) | (((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch))) - - -//#define VK_API_VERSION VK_MAKE_API_VERSION(0, 1, 0, 0) // Patch version should always be set to 0 - -// Version of this file -#define VK_HEADER_VERSION 341 - -// Complete version of this file -#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) - - -#define VK_MAKE_VERSION(major, minor, patch) \ - ((((uint32_t)(major)) << 22U) | (((uint32_t)(minor)) << 12U) | ((uint32_t)(patch))) - - -#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22U) - - -#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) - - -#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) - -#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29U) -#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22U) & 0x7FU) -#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12U) & 0x3FFU) -#define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU) -// Vulkan 1.0 version number -#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 - -typedef uint32_t VkBool32; -typedef uint64_t VkDeviceAddress; -typedef uint64_t VkDeviceSize; -typedef uint32_t VkFlags; -typedef uint32_t VkSampleMask; -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage) -VK_DEFINE_HANDLE(VkInstance) -VK_DEFINE_HANDLE(VkPhysicalDevice) -VK_DEFINE_HANDLE(VkDevice) -VK_DEFINE_HANDLE(VkQueue) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore) -VK_DEFINE_HANDLE(VkCommandBuffer) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool) -#define VK_FALSE 0U -#define VK_LOD_CLAMP_NONE 1000.0F -#define VK_QUEUE_FAMILY_IGNORED (~0U) -#define VK_REMAINING_ARRAY_LAYERS (~0U) -#define VK_REMAINING_MIP_LEVELS (~0U) -#define VK_TRUE 1U -#define VK_WHOLE_SIZE (~0ULL) -#define VK_MAX_MEMORY_TYPES 32U -#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256U -#define VK_UUID_SIZE 16U -#define VK_MAX_EXTENSION_NAME_SIZE 256U -#define VK_MAX_DESCRIPTION_SIZE 256U -#define VK_MAX_MEMORY_HEAPS 16U -#define VK_ATTACHMENT_UNUSED (~0U) -#define VK_SUBPASS_EXTERNAL (~0U) - -typedef enum VkResult { - VK_SUCCESS = 0, - VK_NOT_READY = 1, - VK_TIMEOUT = 2, - VK_EVENT_SET = 3, - VK_EVENT_RESET = 4, - VK_INCOMPLETE = 5, - VK_ERROR_OUT_OF_HOST_MEMORY = -1, - VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, - VK_ERROR_INITIALIZATION_FAILED = -3, - VK_ERROR_DEVICE_LOST = -4, - VK_ERROR_MEMORY_MAP_FAILED = -5, - VK_ERROR_LAYER_NOT_PRESENT = -6, - VK_ERROR_EXTENSION_NOT_PRESENT = -7, - VK_ERROR_FEATURE_NOT_PRESENT = -8, - VK_ERROR_INCOMPATIBLE_DRIVER = -9, - VK_ERROR_TOO_MANY_OBJECTS = -10, - VK_ERROR_FORMAT_NOT_SUPPORTED = -11, - VK_ERROR_FRAGMENTED_POOL = -12, - VK_ERROR_UNKNOWN = -13, - VK_ERROR_VALIDATION_FAILED = -1000011001, - VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, - VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, - VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, - VK_ERROR_FRAGMENTATION = -1000161000, - VK_PIPELINE_COMPILE_REQUIRED = 1000297000, - VK_ERROR_NOT_PERMITTED = -1000174001, - VK_ERROR_SURFACE_LOST_KHR = -1000000000, - VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, - VK_SUBOPTIMAL_KHR = 1000001003, - VK_ERROR_OUT_OF_DATE_KHR = -1000001004, - VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, - VK_ERROR_INVALID_SHADER_NV = -1000012000, - VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000, - VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001, - VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR = -1000023002, - VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR = -1000023003, - VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004, - VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005, - VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, - VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT = -1000208000, - VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, - VK_THREAD_IDLE_KHR = 1000268000, - VK_THREAD_DONE_KHR = 1000268001, - VK_OPERATION_DEFERRED_KHR = 1000268002, - VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, - VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000, - VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, - VK_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, - VK_PIPELINE_BINARY_MISSING_KHR = 1000483000, - VK_ERROR_NOT_ENOUGH_SPACE_KHR = -1000483000, - VK_ERROR_VALIDATION_FAILED_EXT = VK_ERROR_VALIDATION_FAILED, - VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, - VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, - VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, - VK_ERROR_NOT_PERMITTED_EXT = VK_ERROR_NOT_PERMITTED, - VK_ERROR_NOT_PERMITTED_KHR = VK_ERROR_NOT_PERMITTED, - VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, - VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, - VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, - VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, - // VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT is a legacy alias - VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT, - VK_RESULT_MAX_ENUM = 0x7FFFFFFF -} VkResult; - -typedef enum VkStructureType { - VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, - VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, - VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, - VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, - VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, - VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, - VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, - VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, - VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, - VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, - VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, - VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, - VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, - VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, - VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, - VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, - VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, - VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, - VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, - VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, - VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, - VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, - VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, - VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, - VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, - VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, - VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, - VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, - VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, - VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, - VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, - VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, - VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, - VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, - VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, - VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000, - VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001, - VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002, - VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 = 1000314002, - VK_STRUCTURE_TYPE_DEPENDENCY_INFO = 1000314003, - VK_STRUCTURE_TYPE_SUBMIT_INFO_2 = 1000314004, - VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO = 1000314005, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO = 1000314006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007, - VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 = 1000337000, - VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 = 1000337001, - VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002, - VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003, - VK_STRUCTURE_TYPE_BUFFER_COPY_2 = 1000337006, - VK_STRUCTURE_TYPE_IMAGE_COPY_2 = 1000337007, - VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 = 1000337009, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001, - VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, - VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, - VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001, - VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004, - VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005, - VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008, - VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010, - VK_STRUCTURE_TYPE_RENDERING_INFO = 1000044000, - VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO = 1000044001, - VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO = 1000044002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES = 55, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES = 56, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO = 1000174000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES = 1000388000, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES = 1000388001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES = 1000265000, - VK_STRUCTURE_TYPE_MEMORY_MAP_INFO = 1000271000, - VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO = 1000271001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES = 1000470000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES = 1000470001, - VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO = 1000470004, - VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2 = 1000338002, - VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2 = 1000338003, - VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO = 1000470006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES = 1000545000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES = 1000545001, - VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS = 1000545002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES = 1000270000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES = 1000270001, - VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY = 1000270002, - VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY = 1000270003, - VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO = 1000270004, - VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO = 1000270005, - VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO = 1000270006, - VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO = 1000270007, - VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE = 1000270008, - VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY = 1000270009, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES = 1000416000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES = 1000528000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES = 1000544000, - VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO = 1000470005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES = 1000080000, - VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO = 1000545003, - VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO = 1000545004, - VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO = 1000545005, - VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO = 1000545006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES = 1000466000, - VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO = 1000068000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES = 1000068001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES = 1000068002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES = 1000259000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO = 1000259001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES = 1000259002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES = 1000525000, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO = 1000190001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES = 1000190002, - VK_STRUCTURE_TYPE_RENDERING_AREA_INFO = 1000470003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES = 1000232000, - VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO = 1000232001, - VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO = 1000232002, - VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, - VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, - VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, - VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, - VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, - VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, - VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, - VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, - VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, - VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, - VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, - VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, - VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, - VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, - VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, - VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, - VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, - VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, - VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR = 1000023000, - VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001, - VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002, - VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003, - VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004, - VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005, - VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006, - VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007, - VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008, - VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009, - VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010, - VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012, - VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR = 1000023013, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014, - VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016, - VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001, - VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR = 1000024002, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, - VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000, - VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001, - VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002, - VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX = 1000029004, - VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, - VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR = 1000038000, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000038001, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000038002, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR = 1000038003, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR = 1000038004, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR = 1000038005, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR = 1000038006, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR = 1000038007, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR = 1000038008, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR = 1000038009, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR = 1000038010, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR = 1000038011, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR = 1000038012, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000038013, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR = 1000039000, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000039001, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000039002, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR = 1000039003, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR = 1000039004, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR = 1000039005, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR = 1000039006, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR = 1000039007, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR = 1000039009, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR = 1000039010, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR = 1000039011, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR = 1000039012, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR = 1000039013, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000039014, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000040004, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000040005, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR = 1000040006, - VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, - VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, - VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, - VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, - VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, - VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, - VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, - VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, - VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, - VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, - VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, - VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, - VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, - VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, - VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, - VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, - VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, - VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, - VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, - VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, - VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, - VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG = 1000110000, - VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, - VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, - VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, - VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, - VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, - VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, - VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, - VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, - VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, - VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, - VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, - VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, - VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, - VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, - VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, - VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, - VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, - VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, - VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, - VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, - VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, - VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, - VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX = 1000134000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX = 1000134001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX = 1000134002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX = 1000134003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX = 1000134004, -#endif - VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT = 1000135000, - VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT = 1000135001, - VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT = 1000135002, - VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT = 1000135003, - VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT = 1000135004, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT = 1000135005, - VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT = 1000135006, - VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT = 1000135007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT = 1000135008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT = 1000135009, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT = 1000135010, - VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT = 1000135011, - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV = 1000135012, - VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT = 1000135013, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM = 1000135014, - VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR = 1000141000, - VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, - VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, - VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, - VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009, - VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010, - VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011, - VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001, - VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015, - VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016, - VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013, - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001, - VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, - VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, - VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, - VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001, -#endif - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, - VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, - VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, - VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, - VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, - VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, - VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, - VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, - VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, - VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, - VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000187002, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR = 1000187003, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR = 1000187004, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR = 1000187005, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, - VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, - VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, - VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT = 1000208000, - VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT = 1000208001, - VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT = 1000208002, - VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT = 1000208003, - VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT = 1000208004, - VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT = 1000208005, - VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT = 1000208006, - VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT = 1000208007, - VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT = 1000208008, - VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT = 1000208009, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, - VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, - VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, - VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002, - VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003, - VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004, - VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, - VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000, - VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001, - VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, - VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, - VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, - VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, - VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, - VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, - VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR = 1000235000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, - VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, - VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, - VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, - VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000, - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001, - VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002, - VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, - VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, - VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, - VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT = 1000272000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT = 1000272001, - VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT = 1000272002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, - VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003, - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004, - VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005, - VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000, - VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT = 1000283000, - VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT = 1000283001, - VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT = 1000283002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, - VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, - VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT = 1000288000, - VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002, - VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR = 1000299004, - VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR = 1000299005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299006, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR = 1000299007, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR = 1000299008, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR = 1000299009, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR = 1000299010, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, - VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV = 1000307000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV = 1000307001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV = 1000307002, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV = 1000307003, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV = 1000307004, -#endif - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM = 1000309000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM = 1000309001, - VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM = 1000309002, - VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM = 1000309003, - VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM = 1000309004, - VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM = 1000309005, - VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000, - VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000, - VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001, - VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT = 1000311002, - VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT = 1000311003, - VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT = 1000311004, - VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT = 1000311005, - VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT = 1000311006, - VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT = 1000311007, - VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT = 1000311008, - VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT = 1000311009, - VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311010, - VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311011, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002, - VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003, - VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT = 1000316004, - VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005, - VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007, - VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008, - VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010, - VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011, - VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD = 1000321000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR = 1000203000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR = 1000322000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, - VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT = 1000328000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT = 1000328001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, - VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT = 1000338000, - VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT = 1000338001, - VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000, - VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT = 1000341001, - VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT = 1000341002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000, - VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, - VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, - VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000, - VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000, - VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001, - VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003, - VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005, - VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007, - VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009, - VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000, - VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001, - VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT = 1000375000, - VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT = 1000375001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000, - VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001, - VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, - VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR = 1000387000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE = 1000390000, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE = 1000390001, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE = 1000390002, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE = 1000390003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000, - VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT = 1000395000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT = 1000395001, - VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000, - VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001, - VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002, - VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003, - VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006, - VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT = 1000396007, - VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV = 1000397000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV = 1000397001, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV = 1000397002, -#endif - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI = 1000404002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, - VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000, - VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM = 1000424000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM = 1000424001, - VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM = 1000424002, - VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM = 1000424003, - VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM = 1000424004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV = 1000428000, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001, - VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV = 1000429008, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV = 1000429009, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV = 1000429010, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR = 1000434000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001, - VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT = 1000451000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT = 1000451001, - VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS = 1000452000, - VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS = 1000452001, - VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS = 1000452002, - VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS = 1000452003, - VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS = 1000452004, - VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS = 1000452005, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT = 1000453000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002, - VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003, - VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG = 1000459000, - VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG = 1000459001, - VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM = 1000460000, - VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM = 1000460001, - VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM = 1000460002, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM = 1000460003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM = 1000460004, - VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM = 1000460005, - VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM = 1000460006, - VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM = 1000460007, - VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM = 1000460008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM = 1000460009, - VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM = 1000460010, - VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM = 1000460011, - VK_STRUCTURE_TYPE_TENSOR_COPY_ARM = 1000460012, - VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM = 1000460013, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM = 1000460014, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM = 1000460015, - VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM = 1000460016, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM = 1000460017, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM = 1000460018, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM = 1000460019, - VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM = 1000460020, - VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM = 1000460021, - VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM = 1000460022, - VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM = 1000460023, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002, - VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT = 1000462003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001, - VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002, - VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003, - VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004, - VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005, - VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID = 1000468000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468001, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD = 1000476000, - VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD = 1000476001, - VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD = 1000476002, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX = 1000478000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX = 1000478001, -#endif - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR = 1000479000, - VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR = 1000479001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR = 1000479002, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR = 1000480000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR = 1000480001, - VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR = 1000480002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR = 1000481000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001, - VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT = 1000482002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR = 1000483000, - VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR = 1000483001, - VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR = 1000483002, - VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR = 1000483003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR = 1000483004, - VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR = 1000483005, - VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR = 1000483006, - VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR = 1000483007, - VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR = 1000483008, - VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR = 1000483009, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000, - VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000, - VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC = 1000485001, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR = 1000274000, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR = 1000274001, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR = 1000274002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR = 1000275000, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR = 1000275001, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR = 1000275002, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR = 1000275003, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR = 1000275004, - VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR = 1000275005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV = 1000491000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV = 1000491001, - VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV = 1000491002, - VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV = 1000491004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV = 1000492000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV = 1000492001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000, - VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT = 1000495000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT = 1000495001, - VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT = 1000496000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT = 1000499000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR = 1000504000, - VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV = 1000505000, - VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV = 1000505001, - VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV = 1000505002, - VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV = 1000505003, - VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV = 1000505004, - VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV = 1000505005, - VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV = 1000505006, - VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV = 1000505007, - VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV = 1000505008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000, - VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM = 1000507000, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM = 1000507001, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM = 1000507002, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM = 1000507003, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM = 1000507004, - VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM = 1000507005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM = 1000507006, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM = 1000507007, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM = 1000507008, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM = 1000507009, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM = 1000507010, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM = 1000507011, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM = 1000507012, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM = 1000507013, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM = 1000507014, - VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM = 1000507016, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM = 1000507017, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM = 1000507018, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM = 1000507019, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM = 1000507015, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, - VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR = 1000201000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR = 1000511000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR = 1000512000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR = 1000512001, - VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR = 1000512003, - VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000512004, - VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR = 1000512005, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR = 1000513000, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000513001, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR = 1000513002, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR = 1000513003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR = 1000513004, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR = 1000513005, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR = 1000513006, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR = 1000513007, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR = 1000513008, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR = 1000513009, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR = 1000513010, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR = 1000514000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR = 1000514001, - VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR = 1000514002, - VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR = 1000514003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR = 1000515000, - VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR = 1000515001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV = 1000516000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM = 1000518000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM = 1000518001, - VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM = 1000518002, - VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM = 1000519000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM = 1000519001, - VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM = 1000519002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM = 1000520000, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM = 1000520001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR = 1000527000, - VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT = 1000527001, - VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000, - VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001, - VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002, - VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000, - VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR = 1000184000, - VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT = 1000545007, - VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT = 1000545008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM = 1000547000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM = 1000547001, - VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM = 1000547002, - VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM = 1000547003, - VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM = 1000547004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR = 1000549000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR = 1000426001, - VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR = 1000549002, - VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR = 1000549003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT = 1000427000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT = 1000427001, - VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT = 1000550002, - VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV = 1000551000, - VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV = 1000551001, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR = 1000552000, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR = 1000552001, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR = 1000552002, - VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR = 1000552003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR = 1000552004, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553000, - VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553001, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR = 1000553002, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000553005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR = 1000553009, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553003, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553004, - VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553006, - VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553007, - VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000, - VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV = 1000556000, - VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV = 1000556001, - VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV = 1000556002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV = 1000556003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR = 1000558000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV = 1000559000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR = 1000562000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR = 1000562001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR = 1000562002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR = 1000562003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR = 1000562004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV = 1000563000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT = 1000564000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT = 1000567000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV = 1000568000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV = 1000569000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV = 1000569001, - VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV = 1000569002, - VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV = 1000569003, - VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV = 1000569004, - VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV = 1000569005, - VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV = 1000569006, - VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000569007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV = 1000570000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV = 1000570001, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570002, - VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV = 1000570003, - VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV = 1000570004, - VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV = 1000570005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT = 1000572000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT = 1000572001, - VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT = 1000572002, - VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT = 1000572003, - VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT = 1000572004, - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT = 1000572006, - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT = 1000572007, - VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT = 1000572008, - VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT = 1000572009, - VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT = 1000572010, - VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT = 1000572011, - VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT = 1000572012, - VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT = 1000572013, - VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT = 1000572014, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR = 1000574000, - VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR = 1000574002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA = 1000575000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA = 1000575001, - VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA = 1000575002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR = 1000579000, - VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV = 1000580000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV = 1000580001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV = 1000580002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT = 1000581000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT = 1000581001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT = 1000582000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT = 1000582001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR = 1000584000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR = 1000584001, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR = 1000584002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR = 1000586000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586001, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586002, - VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR = 1000586003, - VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS = 1000685000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI = 1000590000, - VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI = 1000590001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV = 1000593000, - VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV = 1000593001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV = 1000593002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM = 1000596000, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT = 1000602000, - VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT = 1000602001, - VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT = 1000602002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR = 1000421000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM = 1000605000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM = 1000605001, - VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM = 1000605002, - VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM = 1000605003, - VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM = 1000605004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT = 1000608000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM = 1000609000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE = 1000611000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE = 1000611001, - VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE = 1000611002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR = 1000286000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR = 1000286001, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV = 1000613000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV = 1000613001, -#endif - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT = 1000425000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT = 1000425001, - VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT = 1000425002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT = 1000620000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR = 1000361000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT = 1000627000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT = 1000628000, - VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT = 1000628001, - VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT = 1000628002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM = 1000629000, - VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM = 1000629001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR = 1000630000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR = 1000630001, - VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR = 1000630002, - VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR = 1000619003, - VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR = 1000630004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT = 1000635000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT = 1000635001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC = 1000637000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT = 1000642000, - VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV = 1000645000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV = 1000645001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT = 1000662000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, - // VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT is a legacy alias - VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, - VK_STRUCTURE_TYPE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_INFO, - VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, - VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, - VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, - VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, - VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, - VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, - // VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT is a legacy alias - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, - VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, - VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, - VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, - VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, - VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, - VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, - VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, - VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, - VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, - VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, - VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, - VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, - VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, - VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, - VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, - // VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL is a legacy alias - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES, - VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO, - VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES, - VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, - VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, - VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES, - VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY, - VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY, - VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO, - VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO, - VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO, - VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO, - VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE, - VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY, - VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO, - VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR, - VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, - VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, - VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, - VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, - VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, - VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, - VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, - VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, - VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2, - VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, - VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, - VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, - VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, - VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2, - VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2, - VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, - VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, - VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, - VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2, - VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, - VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, - VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, - VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, - VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT, - VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES, - VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO, - VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO, - VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2, - VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2, - VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO, - VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO, - VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES, - VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS, - VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO, - VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO, - VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO, - VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO, - VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR, - VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkStructureType; - -typedef enum VkImageLayout { - VK_IMAGE_LAYOUT_UNDEFINED = 0, - VK_IMAGE_LAYOUT_GENERAL = 1, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, - VK_IMAGE_LAYOUT_PREINITIALIZED = 8, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, - VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, - VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, - VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000, - VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001, - VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ = 1000232000, - VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, - VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000, - VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001, - VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002, - VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, - VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, - VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, - VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000, - VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001, - VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002, - VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, - VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM = 1000460000, - VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR = 1000553000, - VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT = 1000620000, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, - VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF -} VkImageLayout; - -typedef enum VkObjectType { - VK_OBJECT_TYPE_UNKNOWN = 0, - VK_OBJECT_TYPE_INSTANCE = 1, - VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, - VK_OBJECT_TYPE_DEVICE = 3, - VK_OBJECT_TYPE_QUEUE = 4, - VK_OBJECT_TYPE_SEMAPHORE = 5, - VK_OBJECT_TYPE_COMMAND_BUFFER = 6, - VK_OBJECT_TYPE_FENCE = 7, - VK_OBJECT_TYPE_DEVICE_MEMORY = 8, - VK_OBJECT_TYPE_BUFFER = 9, - VK_OBJECT_TYPE_IMAGE = 10, - VK_OBJECT_TYPE_EVENT = 11, - VK_OBJECT_TYPE_QUERY_POOL = 12, - VK_OBJECT_TYPE_BUFFER_VIEW = 13, - VK_OBJECT_TYPE_IMAGE_VIEW = 14, - VK_OBJECT_TYPE_SHADER_MODULE = 15, - VK_OBJECT_TYPE_PIPELINE_CACHE = 16, - VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, - VK_OBJECT_TYPE_RENDER_PASS = 18, - VK_OBJECT_TYPE_PIPELINE = 19, - VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, - VK_OBJECT_TYPE_SAMPLER = 21, - VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, - VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, - VK_OBJECT_TYPE_FRAMEBUFFER = 24, - VK_OBJECT_TYPE_COMMAND_POOL = 25, - VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, - VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, - VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000, - VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, - VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, - VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, - VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, - VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, - VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000, - VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001, - VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000, - VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, - VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, - VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, - VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, - VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, - VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000, - VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000, - VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_OBJECT_TYPE_CUDA_MODULE_NV = 1000307000, -#endif -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_OBJECT_TYPE_CUDA_FUNCTION_NV = 1000307001, -#endif - VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000, - VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, - VK_OBJECT_TYPE_TENSOR_ARM = 1000460000, - VK_OBJECT_TYPE_TENSOR_VIEW_ARM = 1000460001, - VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, - VK_OBJECT_TYPE_SHADER_EXT = 1000482000, - VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000, - VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM = 1000507000, - VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV = 1000556000, - VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000, - VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001, - VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, - VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, - VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, - VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkObjectType; - -typedef enum VkVendorId { - VK_VENDOR_ID_KHRONOS = 0x10000, - VK_VENDOR_ID_VIV = 0x10001, - VK_VENDOR_ID_VSI = 0x10002, - VK_VENDOR_ID_KAZAN = 0x10003, - VK_VENDOR_ID_CODEPLAY = 0x10004, - VK_VENDOR_ID_MESA = 0x10005, - VK_VENDOR_ID_POCL = 0x10006, - VK_VENDOR_ID_MOBILEYE = 0x10007, - VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF -} VkVendorId; - -typedef enum VkSystemAllocationScope { - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, - VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, - VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, - VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF -} VkSystemAllocationScope; - -typedef enum VkInternalAllocationType { - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, - VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkInternalAllocationType; - -typedef enum VkFormat { - VK_FORMAT_UNDEFINED = 0, - VK_FORMAT_R4G4_UNORM_PACK8 = 1, - VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, - VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, - VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, - VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, - VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, - VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, - VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, - VK_FORMAT_R8_UNORM = 9, - VK_FORMAT_R8_SNORM = 10, - VK_FORMAT_R8_USCALED = 11, - VK_FORMAT_R8_SSCALED = 12, - VK_FORMAT_R8_UINT = 13, - VK_FORMAT_R8_SINT = 14, - VK_FORMAT_R8_SRGB = 15, - VK_FORMAT_R8G8_UNORM = 16, - VK_FORMAT_R8G8_SNORM = 17, - VK_FORMAT_R8G8_USCALED = 18, - VK_FORMAT_R8G8_SSCALED = 19, - VK_FORMAT_R8G8_UINT = 20, - VK_FORMAT_R8G8_SINT = 21, - VK_FORMAT_R8G8_SRGB = 22, - VK_FORMAT_R8G8B8_UNORM = 23, - VK_FORMAT_R8G8B8_SNORM = 24, - VK_FORMAT_R8G8B8_USCALED = 25, - VK_FORMAT_R8G8B8_SSCALED = 26, - VK_FORMAT_R8G8B8_UINT = 27, - VK_FORMAT_R8G8B8_SINT = 28, - VK_FORMAT_R8G8B8_SRGB = 29, - VK_FORMAT_B8G8R8_UNORM = 30, - VK_FORMAT_B8G8R8_SNORM = 31, - VK_FORMAT_B8G8R8_USCALED = 32, - VK_FORMAT_B8G8R8_SSCALED = 33, - VK_FORMAT_B8G8R8_UINT = 34, - VK_FORMAT_B8G8R8_SINT = 35, - VK_FORMAT_B8G8R8_SRGB = 36, - VK_FORMAT_R8G8B8A8_UNORM = 37, - VK_FORMAT_R8G8B8A8_SNORM = 38, - VK_FORMAT_R8G8B8A8_USCALED = 39, - VK_FORMAT_R8G8B8A8_SSCALED = 40, - VK_FORMAT_R8G8B8A8_UINT = 41, - VK_FORMAT_R8G8B8A8_SINT = 42, - VK_FORMAT_R8G8B8A8_SRGB = 43, - VK_FORMAT_B8G8R8A8_UNORM = 44, - VK_FORMAT_B8G8R8A8_SNORM = 45, - VK_FORMAT_B8G8R8A8_USCALED = 46, - VK_FORMAT_B8G8R8A8_SSCALED = 47, - VK_FORMAT_B8G8R8A8_UINT = 48, - VK_FORMAT_B8G8R8A8_SINT = 49, - VK_FORMAT_B8G8R8A8_SRGB = 50, - VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, - VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, - VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, - VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, - VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, - VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, - VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, - VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, - VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, - VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, - VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, - VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, - VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, - VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, - VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, - VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, - VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, - VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, - VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, - VK_FORMAT_R16_UNORM = 70, - VK_FORMAT_R16_SNORM = 71, - VK_FORMAT_R16_USCALED = 72, - VK_FORMAT_R16_SSCALED = 73, - VK_FORMAT_R16_UINT = 74, - VK_FORMAT_R16_SINT = 75, - VK_FORMAT_R16_SFLOAT = 76, - VK_FORMAT_R16G16_UNORM = 77, - VK_FORMAT_R16G16_SNORM = 78, - VK_FORMAT_R16G16_USCALED = 79, - VK_FORMAT_R16G16_SSCALED = 80, - VK_FORMAT_R16G16_UINT = 81, - VK_FORMAT_R16G16_SINT = 82, - VK_FORMAT_R16G16_SFLOAT = 83, - VK_FORMAT_R16G16B16_UNORM = 84, - VK_FORMAT_R16G16B16_SNORM = 85, - VK_FORMAT_R16G16B16_USCALED = 86, - VK_FORMAT_R16G16B16_SSCALED = 87, - VK_FORMAT_R16G16B16_UINT = 88, - VK_FORMAT_R16G16B16_SINT = 89, - VK_FORMAT_R16G16B16_SFLOAT = 90, - VK_FORMAT_R16G16B16A16_UNORM = 91, - VK_FORMAT_R16G16B16A16_SNORM = 92, - VK_FORMAT_R16G16B16A16_USCALED = 93, - VK_FORMAT_R16G16B16A16_SSCALED = 94, - VK_FORMAT_R16G16B16A16_UINT = 95, - VK_FORMAT_R16G16B16A16_SINT = 96, - VK_FORMAT_R16G16B16A16_SFLOAT = 97, - VK_FORMAT_R32_UINT = 98, - VK_FORMAT_R32_SINT = 99, - VK_FORMAT_R32_SFLOAT = 100, - VK_FORMAT_R32G32_UINT = 101, - VK_FORMAT_R32G32_SINT = 102, - VK_FORMAT_R32G32_SFLOAT = 103, - VK_FORMAT_R32G32B32_UINT = 104, - VK_FORMAT_R32G32B32_SINT = 105, - VK_FORMAT_R32G32B32_SFLOAT = 106, - VK_FORMAT_R32G32B32A32_UINT = 107, - VK_FORMAT_R32G32B32A32_SINT = 108, - VK_FORMAT_R32G32B32A32_SFLOAT = 109, - VK_FORMAT_R64_UINT = 110, - VK_FORMAT_R64_SINT = 111, - VK_FORMAT_R64_SFLOAT = 112, - VK_FORMAT_R64G64_UINT = 113, - VK_FORMAT_R64G64_SINT = 114, - VK_FORMAT_R64G64_SFLOAT = 115, - VK_FORMAT_R64G64B64_UINT = 116, - VK_FORMAT_R64G64B64_SINT = 117, - VK_FORMAT_R64G64B64_SFLOAT = 118, - VK_FORMAT_R64G64B64A64_UINT = 119, - VK_FORMAT_R64G64B64A64_SINT = 120, - VK_FORMAT_R64G64B64A64_SFLOAT = 121, - VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, - VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, - VK_FORMAT_D16_UNORM = 124, - VK_FORMAT_X8_D24_UNORM_PACK32 = 125, - VK_FORMAT_D32_SFLOAT = 126, - VK_FORMAT_S8_UINT = 127, - VK_FORMAT_D16_UNORM_S8_UINT = 128, - VK_FORMAT_D24_UNORM_S8_UINT = 129, - VK_FORMAT_D32_SFLOAT_S8_UINT = 130, - VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, - VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, - VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, - VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, - VK_FORMAT_BC2_UNORM_BLOCK = 135, - VK_FORMAT_BC2_SRGB_BLOCK = 136, - VK_FORMAT_BC3_UNORM_BLOCK = 137, - VK_FORMAT_BC3_SRGB_BLOCK = 138, - VK_FORMAT_BC4_UNORM_BLOCK = 139, - VK_FORMAT_BC4_SNORM_BLOCK = 140, - VK_FORMAT_BC5_UNORM_BLOCK = 141, - VK_FORMAT_BC5_SNORM_BLOCK = 142, - VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, - VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, - VK_FORMAT_BC7_UNORM_BLOCK = 145, - VK_FORMAT_BC7_SRGB_BLOCK = 146, - VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, - VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, - VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, - VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, - VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, - VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, - VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, - VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, - VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, - VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, - VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, - VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, - VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, - VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, - VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, - VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, - VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, - VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, - VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, - VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, - VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, - VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, - VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, - VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, - VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, - VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, - VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, - VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, - VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, - VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, - VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, - VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, - VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, - VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, - VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, - VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, - VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, - VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, - VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, - VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, - VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, - VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, - VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, - VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, - VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, - VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, - VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, - VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, - VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, - VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, - VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, - VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, - VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, - VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, - VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, - VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, - VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, - VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, - VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, - VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, - VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, - VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, - VK_FORMAT_G8_B8R8_2PLANE_444_UNORM = 1000330000, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002, - VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003, - VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000, - VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001, - VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000, - VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001, - VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002, - VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003, - VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004, - VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005, - VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006, - VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007, - VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008, - VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009, - VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010, - VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011, - VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012, - VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013, - VK_FORMAT_A1B5G5R5_UNORM_PACK16 = 1000470000, - VK_FORMAT_A8_UNORM = 1000470001, - VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, - VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, - VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, - VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, - VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, - VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, - VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, - VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, - VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT = 1000288000, - VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT = 1000288001, - VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT = 1000288002, - VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT = 1000288003, - VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT = 1000288004, - VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT = 1000288005, - VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT = 1000288006, - VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT = 1000288007, - VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT = 1000288008, - VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT = 1000288009, - VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT = 1000288010, - VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT = 1000288011, - VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT = 1000288012, - VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT = 1000288013, - VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT = 1000288014, - VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT = 1000288015, - VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT = 1000288016, - VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT = 1000288017, - VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT = 1000288018, - VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT = 1000288019, - VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT = 1000288020, - VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT = 1000288021, - VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT = 1000288022, - VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT = 1000288023, - VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT = 1000288024, - VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT = 1000288025, - VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT = 1000288026, - VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT = 1000288027, - VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT = 1000288028, - VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT = 1000288029, - VK_FORMAT_R8_BOOL_ARM = 1000460000, - VK_FORMAT_R16G16_SFIXED5_NV = 1000464000, - VK_FORMAT_R10X6_UINT_PACK16_ARM = 1000609000, - VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM = 1000609001, - VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM = 1000609002, - VK_FORMAT_R12X4_UINT_PACK16_ARM = 1000609003, - VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM = 1000609004, - VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM = 1000609005, - VK_FORMAT_R14X2_UINT_PACK16_ARM = 1000609006, - VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM = 1000609007, - VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM = 1000609008, - VK_FORMAT_R14X2_UNORM_PACK16_ARM = 1000609009, - VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM = 1000609010, - VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM = 1000609011, - VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM = 1000609012, - VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM = 1000609013, - VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, - VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, - VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, - VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK, - VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK, - VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK, - VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK, - VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK, - VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK, - VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK, - VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK, - VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK, - VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK, - VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, - VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, - VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, - VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, - VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, - VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, - VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, - VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, - VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, - VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, - VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, - VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, - VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, - VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, - VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, - VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, - VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, - VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, - VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, - VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, - VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, - VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16, - VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16, - // VK_FORMAT_R16G16_S10_5_NV is a legacy alias - VK_FORMAT_R16G16_S10_5_NV = VK_FORMAT_R16G16_SFIXED5_NV, - VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR = VK_FORMAT_A1B5G5R5_UNORM_PACK16, - VK_FORMAT_A8_UNORM_KHR = VK_FORMAT_A8_UNORM, - VK_FORMAT_MAX_ENUM = 0x7FFFFFFF -} VkFormat; - -typedef enum VkImageTiling { - VK_IMAGE_TILING_OPTIMAL = 0, - VK_IMAGE_TILING_LINEAR = 1, - VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, - VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF -} VkImageTiling; - -typedef enum VkImageType { - VK_IMAGE_TYPE_1D = 0, - VK_IMAGE_TYPE_2D = 1, - VK_IMAGE_TYPE_3D = 2, - VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageType; - -typedef enum VkPhysicalDeviceType { - VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, - VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, - VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, - VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, - VK_PHYSICAL_DEVICE_TYPE_CPU = 4, - VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkPhysicalDeviceType; - -typedef enum VkQueryType { - VK_QUERY_TYPE_OCCLUSION = 0, - VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, - VK_QUERY_TYPE_TIMESTAMP = 2, - VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000, - VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, - VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, - VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, - VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR = 1000299000, - VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000, - VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR = 1000386001, - VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT = 1000396000, - VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT = 1000396001, - VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkQueryType; - -typedef enum VkSharingMode { - VK_SHARING_MODE_EXCLUSIVE = 0, - VK_SHARING_MODE_CONCURRENT = 1, - VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSharingMode; - -typedef enum VkComponentSwizzle { - VK_COMPONENT_SWIZZLE_IDENTITY = 0, - VK_COMPONENT_SWIZZLE_ZERO = 1, - VK_COMPONENT_SWIZZLE_ONE = 2, - VK_COMPONENT_SWIZZLE_R = 3, - VK_COMPONENT_SWIZZLE_G = 4, - VK_COMPONENT_SWIZZLE_B = 5, - VK_COMPONENT_SWIZZLE_A = 6, - VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF -} VkComponentSwizzle; - -typedef enum VkImageViewType { - VK_IMAGE_VIEW_TYPE_1D = 0, - VK_IMAGE_VIEW_TYPE_2D = 1, - VK_IMAGE_VIEW_TYPE_3D = 2, - VK_IMAGE_VIEW_TYPE_CUBE = 3, - VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, - VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, - VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, - VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageViewType; - -typedef enum VkCommandBufferLevel { - VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, - VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, - VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferLevel; - -typedef enum VkIndexType { - VK_INDEX_TYPE_UINT16 = 0, - VK_INDEX_TYPE_UINT32 = 1, - VK_INDEX_TYPE_UINT8 = 1000265000, - VK_INDEX_TYPE_NONE_KHR = 1000165000, - VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR, - VK_INDEX_TYPE_UINT8_EXT = VK_INDEX_TYPE_UINT8, - VK_INDEX_TYPE_UINT8_KHR = VK_INDEX_TYPE_UINT8, - VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkIndexType; - -typedef enum VkPipelineCacheHeaderVersion { - VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, - VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM = 1000629000, - VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCacheHeaderVersion; - -typedef enum VkBorderColor { - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, - VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, - VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, - VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, - VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, - VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, - VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, - VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, - VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF -} VkBorderColor; - -typedef enum VkFilter { - VK_FILTER_NEAREST = 0, - VK_FILTER_LINEAR = 1, - VK_FILTER_CUBIC_EXT = 1000015000, - VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT, - VK_FILTER_MAX_ENUM = 0x7FFFFFFF -} VkFilter; - -typedef enum VkSamplerAddressMode { - VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, - VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, - VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, - // VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR is a legacy alias - VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, - VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerAddressMode; - -typedef enum VkSamplerMipmapMode { - VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, - VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, - VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerMipmapMode; - -typedef enum VkCompareOp { - VK_COMPARE_OP_NEVER = 0, - VK_COMPARE_OP_LESS = 1, - VK_COMPARE_OP_EQUAL = 2, - VK_COMPARE_OP_LESS_OR_EQUAL = 3, - VK_COMPARE_OP_GREATER = 4, - VK_COMPARE_OP_NOT_EQUAL = 5, - VK_COMPARE_OP_GREATER_OR_EQUAL = 6, - VK_COMPARE_OP_ALWAYS = 7, - VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF -} VkCompareOp; - -typedef enum VkDescriptorType { - VK_DESCRIPTOR_TYPE_SAMPLER = 0, - VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, - VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, - VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, - VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, - VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, - VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, - VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000, - VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, - VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, - VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000, - VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001, - VK_DESCRIPTOR_TYPE_TENSOR_ARM = 1000460000, - VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000, - VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV = 1000570000, - VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, - VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = VK_DESCRIPTOR_TYPE_MUTABLE_EXT, - VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorType; - -typedef enum VkPipelineBindPoint { - VK_PIPELINE_BIND_POINT_GRAPHICS = 0, - VK_PIPELINE_BIND_POINT_COMPUTE = 1, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX = 1000134000, -#endif - VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000, - VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003, - VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM = 1000507000, - VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, - VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF -} VkPipelineBindPoint; - -typedef enum VkBlendFactor { - VK_BLEND_FACTOR_ZERO = 0, - VK_BLEND_FACTOR_ONE = 1, - VK_BLEND_FACTOR_SRC_COLOR = 2, - VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, - VK_BLEND_FACTOR_DST_COLOR = 4, - VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, - VK_BLEND_FACTOR_SRC_ALPHA = 6, - VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, - VK_BLEND_FACTOR_DST_ALPHA = 8, - VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, - VK_BLEND_FACTOR_CONSTANT_COLOR = 10, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, - VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, - VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, - VK_BLEND_FACTOR_SRC1_COLOR = 15, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, - VK_BLEND_FACTOR_SRC1_ALPHA = 17, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, - VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF -} VkBlendFactor; - -typedef enum VkBlendOp { - VK_BLEND_OP_ADD = 0, - VK_BLEND_OP_SUBTRACT = 1, - VK_BLEND_OP_REVERSE_SUBTRACT = 2, - VK_BLEND_OP_MIN = 3, - VK_BLEND_OP_MAX = 4, - VK_BLEND_OP_ZERO_EXT = 1000148000, - VK_BLEND_OP_SRC_EXT = 1000148001, - VK_BLEND_OP_DST_EXT = 1000148002, - VK_BLEND_OP_SRC_OVER_EXT = 1000148003, - VK_BLEND_OP_DST_OVER_EXT = 1000148004, - VK_BLEND_OP_SRC_IN_EXT = 1000148005, - VK_BLEND_OP_DST_IN_EXT = 1000148006, - VK_BLEND_OP_SRC_OUT_EXT = 1000148007, - VK_BLEND_OP_DST_OUT_EXT = 1000148008, - VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, - VK_BLEND_OP_DST_ATOP_EXT = 1000148010, - VK_BLEND_OP_XOR_EXT = 1000148011, - VK_BLEND_OP_MULTIPLY_EXT = 1000148012, - VK_BLEND_OP_SCREEN_EXT = 1000148013, - VK_BLEND_OP_OVERLAY_EXT = 1000148014, - VK_BLEND_OP_DARKEN_EXT = 1000148015, - VK_BLEND_OP_LIGHTEN_EXT = 1000148016, - VK_BLEND_OP_COLORDODGE_EXT = 1000148017, - VK_BLEND_OP_COLORBURN_EXT = 1000148018, - VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, - VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, - VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, - VK_BLEND_OP_EXCLUSION_EXT = 1000148022, - VK_BLEND_OP_INVERT_EXT = 1000148023, - VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, - VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, - VK_BLEND_OP_LINEARBURN_EXT = 1000148026, - VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, - VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, - VK_BLEND_OP_PINLIGHT_EXT = 1000148029, - VK_BLEND_OP_HARDMIX_EXT = 1000148030, - VK_BLEND_OP_HSL_HUE_EXT = 1000148031, - VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, - VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, - VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, - VK_BLEND_OP_PLUS_EXT = 1000148035, - VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, - VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, - VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, - VK_BLEND_OP_MINUS_EXT = 1000148039, - VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, - VK_BLEND_OP_CONTRAST_EXT = 1000148041, - VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, - VK_BLEND_OP_RED_EXT = 1000148043, - VK_BLEND_OP_GREEN_EXT = 1000148044, - VK_BLEND_OP_BLUE_EXT = 1000148045, - VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF -} VkBlendOp; - -typedef enum VkDynamicState { - VK_DYNAMIC_STATE_VIEWPORT = 0, - VK_DYNAMIC_STATE_SCISSOR = 1, - VK_DYNAMIC_STATE_LINE_WIDTH = 2, - VK_DYNAMIC_STATE_DEPTH_BIAS = 3, - VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, - VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, - VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, - VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, - VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, - VK_DYNAMIC_STATE_CULL_MODE = 1000267000, - VK_DYNAMIC_STATE_FRONT_FACE = 1000267001, - VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002, - VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT = 1000267003, - VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT = 1000267004, - VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE = 1000267005, - VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE = 1000267006, - VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE = 1000267007, - VK_DYNAMIC_STATE_DEPTH_COMPARE_OP = 1000267008, - VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE = 1000267009, - VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE = 1000267010, - VK_DYNAMIC_STATE_STENCIL_OP = 1000267011, - VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE = 1000377001, - VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE = 1000377002, - VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004, - VK_DYNAMIC_STATE_LINE_STIPPLE = 1000259000, - VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, - VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, - VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT = 1000099001, - VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT = 1000099002, - VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, - VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000, - VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, - VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, - VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000, - VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, - VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, - VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, - VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, - VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, - VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, - VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003, - VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004, - VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005, - VK_DYNAMIC_STATE_SAMPLE_MASK_EXT = 1000455006, - VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007, - VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT = 1000455008, - VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT = 1000455009, - VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010, - VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011, - VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012, - VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002, - VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013, - VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014, - VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015, - VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016, - VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017, - VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018, - VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019, - VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020, - VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021, - VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022, - VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023, - VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024, - VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025, - VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026, - VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027, - VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028, - VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029, - VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030, - VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031, - VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032, - VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000, - VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT = 1000582000, - VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = VK_DYNAMIC_STATE_LINE_STIPPLE, - VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE, - VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE, - VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, - VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, - VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, - VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE, - VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE, - VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE, - VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP, - VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE, - VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE, - VK_DYNAMIC_STATE_STENCIL_OP_EXT = VK_DYNAMIC_STATE_STENCIL_OP, - VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE, - VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE, - VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE, - VK_DYNAMIC_STATE_LINE_STIPPLE_KHR = VK_DYNAMIC_STATE_LINE_STIPPLE, - VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF -} VkDynamicState; - -typedef enum VkFrontFace { - VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, - VK_FRONT_FACE_CLOCKWISE = 1, - VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF -} VkFrontFace; - -typedef enum VkVertexInputRate { - VK_VERTEX_INPUT_RATE_VERTEX = 0, - VK_VERTEX_INPUT_RATE_INSTANCE = 1, - VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF -} VkVertexInputRate; - -typedef enum VkPrimitiveTopology { - VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, - VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, - VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF -} VkPrimitiveTopology; - -typedef enum VkPolygonMode { - VK_POLYGON_MODE_FILL = 0, - VK_POLYGON_MODE_LINE = 1, - VK_POLYGON_MODE_POINT = 2, - VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, - VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF -} VkPolygonMode; - -typedef enum VkStencilOp { - VK_STENCIL_OP_KEEP = 0, - VK_STENCIL_OP_ZERO = 1, - VK_STENCIL_OP_REPLACE = 2, - VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, - VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, - VK_STENCIL_OP_INVERT = 5, - VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, - VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, - VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF -} VkStencilOp; - -typedef enum VkLogicOp { - VK_LOGIC_OP_CLEAR = 0, - VK_LOGIC_OP_AND = 1, - VK_LOGIC_OP_AND_REVERSE = 2, - VK_LOGIC_OP_COPY = 3, - VK_LOGIC_OP_AND_INVERTED = 4, - VK_LOGIC_OP_NO_OP = 5, - VK_LOGIC_OP_XOR = 6, - VK_LOGIC_OP_OR = 7, - VK_LOGIC_OP_NOR = 8, - VK_LOGIC_OP_EQUIVALENT = 9, - VK_LOGIC_OP_INVERT = 10, - VK_LOGIC_OP_OR_REVERSE = 11, - VK_LOGIC_OP_COPY_INVERTED = 12, - VK_LOGIC_OP_OR_INVERTED = 13, - VK_LOGIC_OP_NAND = 14, - VK_LOGIC_OP_SET = 15, - VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF -} VkLogicOp; - -typedef enum VkAttachmentLoadOp { - VK_ATTACHMENT_LOAD_OP_LOAD = 0, - VK_ATTACHMENT_LOAD_OP_CLEAR = 1, - VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, - VK_ATTACHMENT_LOAD_OP_NONE = 1000400000, - VK_ATTACHMENT_LOAD_OP_NONE_EXT = VK_ATTACHMENT_LOAD_OP_NONE, - VK_ATTACHMENT_LOAD_OP_NONE_KHR = VK_ATTACHMENT_LOAD_OP_NONE, - VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentLoadOp; - -typedef enum VkAttachmentStoreOp { - VK_ATTACHMENT_STORE_OP_STORE = 0, - VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, - VK_ATTACHMENT_STORE_OP_NONE = 1000301000, - VK_ATTACHMENT_STORE_OP_NONE_KHR = VK_ATTACHMENT_STORE_OP_NONE, - VK_ATTACHMENT_STORE_OP_NONE_QCOM = VK_ATTACHMENT_STORE_OP_NONE, - VK_ATTACHMENT_STORE_OP_NONE_EXT = VK_ATTACHMENT_STORE_OP_NONE, - VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentStoreOp; - -typedef enum VkSubpassContents { - VK_SUBPASS_CONTENTS_INLINE = 0, - VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, - VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR = 1000451000, - VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR, - VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF -} VkSubpassContents; - -typedef enum VkAccessFlagBits { - VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, - VK_ACCESS_INDEX_READ_BIT = 0x00000002, - VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, - VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, - VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, - VK_ACCESS_SHADER_READ_BIT = 0x00000020, - VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, - VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, - VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, - VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, - VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, - VK_ACCESS_HOST_READ_BIT = 0x00002000, - VK_ACCESS_HOST_WRITE_BIT = 0x00004000, - VK_ACCESS_MEMORY_READ_BIT = 0x00008000, - VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, - VK_ACCESS_NONE = 0, - VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000, - VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000, - VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000, - VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, - VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, - VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000, - VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000, - VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000, - VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000, - VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT = 0x00020000, - VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT = 0x00040000, - VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, - VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, - VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, - VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT, - VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT, - VK_ACCESS_NONE_KHR = VK_ACCESS_NONE, - VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkAccessFlagBits; -typedef VkFlags VkAccessFlags; - -typedef enum VkImageAspectFlagBits { - VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, - VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, - VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, - VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, - VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, - VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, - VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, - VK_IMAGE_ASPECT_NONE = 0, - VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080, - VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, - VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, - VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, - VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, - VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, - VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, - VK_IMAGE_ASPECT_NONE_KHR = VK_IMAGE_ASPECT_NONE, - VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageAspectFlagBits; -typedef VkFlags VkImageAspectFlags; - -typedef enum VkFormatFeatureFlagBits { - VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, - VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, - VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, - VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, - VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, - VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, - VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, - VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, - VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, - VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, - VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, - VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, - VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000, - VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000, - VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000, - VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000, - VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000, - VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000, - VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000, - VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, - VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, - VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, - VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, - VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, - VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, - VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFormatFeatureFlagBits; -typedef VkFlags VkFormatFeatureFlags; - -typedef enum VkImageCreateFlagBits { - VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, - VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, - VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, - VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, - VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, - VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, - VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, - VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, - VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, - VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT = 0x00010000, - VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, - VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, - VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000, - VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000, - VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00100000, - VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT = 0x00008000, - VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, - VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, - VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, - VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, - VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, - VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT, - VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT, - VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageCreateFlagBits; -typedef VkFlags VkImageCreateFlags; - -typedef enum VkSampleCountFlagBits { - VK_SAMPLE_COUNT_1_BIT = 0x00000001, - VK_SAMPLE_COUNT_2_BIT = 0x00000002, - VK_SAMPLE_COUNT_4_BIT = 0x00000004, - VK_SAMPLE_COUNT_8_BIT = 0x00000008, - VK_SAMPLE_COUNT_16_BIT = 0x00000010, - VK_SAMPLE_COUNT_32_BIT = 0x00000020, - VK_SAMPLE_COUNT_64_BIT = 0x00000040, - VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSampleCountFlagBits; -typedef VkFlags VkSampleCountFlags; - -typedef enum VkImageUsageFlagBits { - VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, - VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, - VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, - VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, - VK_IMAGE_USAGE_HOST_TRANSFER_BIT = 0x00400000, - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400, - VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800, - VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000, - VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, - VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100, - VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000, - VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000, - VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000, - VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000, - VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, - VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, - VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, - VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM = 0x00800000, - VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM = 0x08000000, - VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x02000000, - VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x04000000, - VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = VK_IMAGE_USAGE_HOST_TRANSFER_BIT, - VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageUsageFlagBits; -typedef VkFlags VkImageUsageFlags; - -typedef enum VkInstanceCreateFlagBits { - VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR = 0x00000001, - VK_INSTANCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkInstanceCreateFlagBits; -typedef VkFlags VkInstanceCreateFlags; - -typedef enum VkMemoryHeapFlagBits { - VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, - VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, - VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM = 0x00000008, - VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, - VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryHeapFlagBits; -typedef VkFlags VkMemoryHeapFlags; - -typedef enum VkMemoryPropertyFlagBits { - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, - VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, - VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, - VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, - VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, - VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040, - VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080, - VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0x00000100, - VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryPropertyFlagBits; -typedef VkFlags VkMemoryPropertyFlags; - -typedef enum VkQueueFlagBits { - VK_QUEUE_GRAPHICS_BIT = 0x00000001, - VK_QUEUE_COMPUTE_BIT = 0x00000002, - VK_QUEUE_TRANSFER_BIT = 0x00000004, - VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, - VK_QUEUE_PROTECTED_BIT = 0x00000010, - VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020, - VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040, - VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100, - VK_QUEUE_DATA_GRAPH_BIT_ARM = 0x00000400, - VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueueFlagBits; -typedef VkFlags VkQueueFlags; -typedef VkFlags VkDeviceCreateFlags; - -typedef enum VkDeviceQueueCreateFlagBits { - VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, - VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR = 0x00000004, - VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDeviceQueueCreateFlagBits; -typedef VkFlags VkDeviceQueueCreateFlags; - -typedef enum VkPipelineStageFlagBits { - VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, - VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, - VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, - VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, - VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, - VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, - VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, - VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, - VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, - VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, - VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, - VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, - VK_PIPELINE_STAGE_NONE = 0, - VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000, - VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, - VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000, - VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000, - VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, - VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000, - VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT = 0x00080000, - VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT = 0x00100000, - VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT = 0x00020000, - VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, - VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, - VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, - VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, - VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT, - VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE, - VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineStageFlagBits; -typedef VkFlags VkPipelineStageFlags; - -typedef enum VkMemoryMapFlagBits { - VK_MEMORY_MAP_PLACED_BIT_EXT = 0x00000001, - VK_MEMORY_MAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryMapFlagBits; -typedef VkFlags VkMemoryMapFlags; - -typedef enum VkSparseMemoryBindFlagBits { - VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, - VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSparseMemoryBindFlagBits; -typedef VkFlags VkSparseMemoryBindFlags; - -typedef enum VkSparseImageFormatFlagBits { - VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, - VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, - VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, - VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSparseImageFormatFlagBits; -typedef VkFlags VkSparseImageFormatFlags; - -typedef enum VkFenceCreateFlagBits { - VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, - VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFenceCreateFlagBits; -typedef VkFlags VkFenceCreateFlags; -typedef VkFlags VkSemaphoreCreateFlags; - -typedef enum VkQueryPoolCreateFlagBits { - VK_QUERY_POOL_CREATE_RESET_BIT_KHR = 0x00000001, - VK_QUERY_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryPoolCreateFlagBits; -typedef VkFlags VkQueryPoolCreateFlags; - -typedef enum VkQueryPipelineStatisticFlagBits { - VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, - VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, - VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, - VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, - VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, - VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, - VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, - VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, - VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, - VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, - VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, - VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT = 0x00000800, - VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT = 0x00001000, - VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI = 0x00002000, - VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryPipelineStatisticFlagBits; -typedef VkFlags VkQueryPipelineStatisticFlags; - -typedef enum VkQueryResultFlagBits { - VK_QUERY_RESULT_64_BIT = 0x00000001, - VK_QUERY_RESULT_WAIT_BIT = 0x00000002, - VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, - VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, - VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010, - VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryResultFlagBits; -typedef VkFlags VkQueryResultFlags; - -typedef enum VkBufferCreateFlagBits { - VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, - VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, - VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, - VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010, - VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000020, - VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR = 0x00000040, - VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, - VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, - VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkBufferCreateFlagBits; -typedef VkFlags VkBufferCreateFlags; - -typedef enum VkBufferUsageFlagBits { - VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, - VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, - VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, - VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, - VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, - VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, - VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, - VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000, - VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000, - VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000, - VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800, - VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, - VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX = 0x02000000, -#endif - VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT = 0x10000000, - VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000, - VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000, - VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400, - VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000, - VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000, - VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000, - VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000, - VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000, - VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000, - VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000, - VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM = 0x08000000, - VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, - VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, - VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, - VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkBufferUsageFlagBits; -typedef VkFlags VkBufferUsageFlags; - -typedef enum VkImageViewCreateFlagBits { - VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, - VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000004, - VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002, - VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageViewCreateFlagBits; -typedef VkFlags VkImageViewCreateFlags; - -typedef enum VkDependencyFlagBits { - VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, - VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, - VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, - VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0x00000008, - VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR = 0x00000020, - VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR = 0x00000040, - VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, - VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, - VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDependencyFlagBits; -typedef VkFlags VkDependencyFlags; - -typedef enum VkCommandPoolCreateFlagBits { - VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, - VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, - VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, - VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandPoolCreateFlagBits; -typedef VkFlags VkCommandPoolCreateFlags; - -typedef enum VkCommandPoolResetFlagBits { - VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, - VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandPoolResetFlagBits; -typedef VkFlags VkCommandPoolResetFlags; - -typedef enum VkCommandBufferUsageFlagBits { - VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, - VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, - VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, - VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferUsageFlagBits; -typedef VkFlags VkCommandBufferUsageFlags; - -typedef enum VkQueryControlFlagBits { - VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, - VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryControlFlagBits; -typedef VkFlags VkQueryControlFlags; - -typedef enum VkCommandBufferResetFlagBits { - VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, - VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferResetFlagBits; -typedef VkFlags VkCommandBufferResetFlags; - -typedef enum VkEventCreateFlagBits { - VK_EVENT_CREATE_DEVICE_ONLY_BIT = 0x00000001, - VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT, - VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkEventCreateFlagBits; -typedef VkFlags VkEventCreateFlags; -typedef VkFlags VkBufferViewCreateFlags; -typedef VkFlags VkShaderModuleCreateFlags; - -typedef enum VkPipelineCacheCreateFlagBits { - VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001, - VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR = 0x00000008, - VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, - VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCacheCreateFlagBits; -typedef VkFlags VkPipelineCacheCreateFlags; - -typedef enum VkPipelineCreateFlagBits { - VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, - VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, - VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, - VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010, - VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, - VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100, - VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200, - VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT = 0x08000000, - VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT = 0x40000000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000, - VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000, - VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000, - VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000, - VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020, - VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000, - VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000, - VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040, - VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080, - VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000, - VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800, - VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000, - VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000, - VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400, - VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000, - VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000, - VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000, - VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000, -#endif - // VK_PIPELINE_CREATE_DISPATCH_BASE is a legacy alias - VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, - VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, - VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, - // VK_PIPELINE_CREATE_DISPATCH_BASE_KHR is a legacy alias - VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, - // VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT is a legacy alias - VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, - // VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR is a legacy alias - VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, - VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, - VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, - VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, - VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCreateFlagBits; -typedef VkFlags VkPipelineCreateFlags; - -typedef enum VkPipelineShaderStageCreateFlagBits { - VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 0x00000001, - VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 0x00000002, - VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, - VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, - VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineShaderStageCreateFlagBits; -typedef VkFlags VkPipelineShaderStageCreateFlags; - -typedef enum VkShaderStageFlagBits { - VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, - VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, - VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, - VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, - VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, - VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, - VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, - VK_SHADER_STAGE_ALL = 0x7FFFFFFF, - VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100, - VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200, - VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400, - VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800, - VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000, - VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000, - VK_SHADER_STAGE_TASK_BIT_EXT = 0x00000040, - VK_SHADER_STAGE_MESH_BIT_EXT = 0x00000080, - VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000, - VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI = 0x00080000, - VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR, - VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR, - VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, - VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR, - VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR, - VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR, - VK_SHADER_STAGE_TASK_BIT_NV = VK_SHADER_STAGE_TASK_BIT_EXT, - VK_SHADER_STAGE_MESH_BIT_NV = VK_SHADER_STAGE_MESH_BIT_EXT, - VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkShaderStageFlagBits; - -typedef enum VkPipelineLayoutCreateFlagBits { - VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 0x00000002, - VK_PIPELINE_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineLayoutCreateFlagBits; -typedef VkFlags VkPipelineLayoutCreateFlags; -typedef VkFlags VkShaderStageFlags; - -typedef enum VkSamplerCreateFlagBits { - VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001, - VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002, - VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, - VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT = 0x00000004, - VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM = 0x00000010, - VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSamplerCreateFlagBits; -typedef VkFlags VkSamplerCreateFlags; - -typedef enum VkDescriptorPoolCreateFlagBits { - VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, - VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002, - VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT = 0x00000004, - VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV = 0x00000008, - VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV = 0x00000010, - VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, - VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT, - VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorPoolCreateFlagBits; -typedef VkFlags VkDescriptorPoolCreateFlags; -typedef VkFlags VkDescriptorPoolResetFlags; - -typedef enum VkDescriptorSetLayoutCreateFlagBits { - VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT = 0x00000001, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00000010, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0x00000020, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00000080, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0x00000004, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV = 0x00000040, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorSetLayoutCreateFlagBits; -typedef VkFlags VkDescriptorSetLayoutCreateFlags; - -typedef enum VkColorComponentFlagBits { - VK_COLOR_COMPONENT_R_BIT = 0x00000001, - VK_COLOR_COMPONENT_G_BIT = 0x00000002, - VK_COLOR_COMPONENT_B_BIT = 0x00000004, - VK_COLOR_COMPONENT_A_BIT = 0x00000008, - VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkColorComponentFlagBits; -typedef VkFlags VkColorComponentFlags; - -typedef enum VkCullModeFlagBits { - VK_CULL_MODE_NONE = 0, - VK_CULL_MODE_FRONT_BIT = 0x00000001, - VK_CULL_MODE_BACK_BIT = 0x00000002, - VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, - VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCullModeFlagBits; -typedef VkFlags VkCullModeFlags; -typedef VkFlags VkPipelineVertexInputStateCreateFlags; -typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; -typedef VkFlags VkPipelineTessellationStateCreateFlags; -typedef VkFlags VkPipelineViewportStateCreateFlags; -typedef VkFlags VkPipelineRasterizationStateCreateFlags; -typedef VkFlags VkPipelineMultisampleStateCreateFlags; - -typedef enum VkPipelineDepthStencilStateCreateFlagBits { - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000001, - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000002, - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineDepthStencilStateCreateFlagBits; -typedef VkFlags VkPipelineDepthStencilStateCreateFlags; - -typedef enum VkPipelineColorBlendStateCreateFlagBits { - VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT = 0x00000001, - VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT, - VK_PIPELINE_COLOR_BLEND_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineColorBlendStateCreateFlagBits; -typedef VkFlags VkPipelineColorBlendStateCreateFlags; -typedef VkFlags VkPipelineDynamicStateCreateFlags; - -typedef enum VkAttachmentDescriptionFlagBits { - VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, - VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 0x00000002, - VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 0x00000004, - VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentDescriptionFlagBits; -typedef VkFlags VkAttachmentDescriptionFlags; - -typedef enum VkFramebufferCreateFlagBits { - VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001, - VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, - VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFramebufferCreateFlagBits; -typedef VkFlags VkFramebufferCreateFlags; - -typedef enum VkRenderPassCreateFlagBits { - VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002, - VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x00000004, - VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkRenderPassCreateFlagBits; -typedef VkFlags VkRenderPassCreateFlags; - -typedef enum VkSubpassDescriptionFlagBits { - VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, - VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, - VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM = 0x00000100, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT = 0x00000010, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000020, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000040, - VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000080, - VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT = 0x00000004, - VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT = 0x00000008, - VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT, - VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, - VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSubpassDescriptionFlagBits; -typedef VkFlags VkSubpassDescriptionFlags; - -typedef enum VkStencilFaceFlagBits { - VK_STENCIL_FACE_FRONT_BIT = 0x00000001, - VK_STENCIL_FACE_BACK_BIT = 0x00000002, - VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, - // VK_STENCIL_FRONT_AND_BACK is a legacy alias - VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK, - VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkStencilFaceFlagBits; -typedef VkFlags VkStencilFaceFlags; -typedef struct VkExtent2D { - uint32_t width; - uint32_t height; -} VkExtent2D; - -typedef struct VkExtent3D { - uint32_t width; - uint32_t height; - uint32_t depth; -} VkExtent3D; - -typedef struct VkOffset2D { - int32_t x; - int32_t y; -} VkOffset2D; - -typedef struct VkOffset3D { - int32_t x; - int32_t y; - int32_t z; -} VkOffset3D; - -typedef struct VkRect2D { - VkOffset2D offset; - VkExtent2D extent; -} VkRect2D; - -typedef struct VkBaseInStructure { - VkStructureType sType; - const struct VkBaseInStructure* pNext; -} VkBaseInStructure; - -typedef struct VkBaseOutStructure { - VkStructureType sType; - struct VkBaseOutStructure* pNext; -} VkBaseOutStructure; - -typedef struct VkBufferMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; -} VkBufferMemoryBarrier; - -typedef struct VkImageSubresourceRange { - VkImageAspectFlags aspectMask; - uint32_t baseMipLevel; - uint32_t levelCount; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkImageSubresourceRange; - -typedef struct VkImageMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkImage image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier; - -typedef struct VkMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; -} VkMemoryBarrier; - -typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)( - void* pUserData, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - -typedef void (VKAPI_PTR *PFN_vkFreeFunction)( - void* pUserData, - void* pMemory); - -typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - -typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - -typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)( - void* pUserData, - void* pOriginal, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - -typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void); -typedef struct VkAllocationCallbacks { - void* pUserData; - PFN_vkAllocationFunction pfnAllocation; - PFN_vkReallocationFunction pfnReallocation; - PFN_vkFreeFunction pfnFree; - PFN_vkInternalAllocationNotification pfnInternalAllocation; - PFN_vkInternalFreeNotification pfnInternalFree; -} VkAllocationCallbacks; - -typedef struct VkApplicationInfo { - VkStructureType sType; - const void* pNext; - const char* pApplicationName; - uint32_t applicationVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; -} VkApplicationInfo; - -typedef struct VkFormatProperties { - VkFormatFeatureFlags linearTilingFeatures; - VkFormatFeatureFlags optimalTilingFeatures; - VkFormatFeatureFlags bufferFeatures; -} VkFormatProperties; - -typedef struct VkImageFormatProperties { - VkExtent3D maxExtent; - uint32_t maxMipLevels; - uint32_t maxArrayLayers; - VkSampleCountFlags sampleCounts; - VkDeviceSize maxResourceSize; -} VkImageFormatProperties; - -typedef struct VkInstanceCreateInfo { - VkStructureType sType; - const void* pNext; - VkInstanceCreateFlags flags; - const VkApplicationInfo* pApplicationInfo; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; -} VkInstanceCreateInfo; - -typedef struct VkMemoryHeap { - VkDeviceSize size; - VkMemoryHeapFlags flags; -} VkMemoryHeap; - -typedef struct VkMemoryType { - VkMemoryPropertyFlags propertyFlags; - uint32_t heapIndex; -} VkMemoryType; - -typedef struct VkPhysicalDeviceFeatures { - VkBool32 robustBufferAccess; - VkBool32 fullDrawIndexUint32; - VkBool32 imageCubeArray; - VkBool32 independentBlend; - VkBool32 geometryShader; - VkBool32 tessellationShader; - VkBool32 sampleRateShading; - VkBool32 dualSrcBlend; - VkBool32 logicOp; - VkBool32 multiDrawIndirect; - VkBool32 drawIndirectFirstInstance; - VkBool32 depthClamp; - VkBool32 depthBiasClamp; - VkBool32 fillModeNonSolid; - VkBool32 depthBounds; - VkBool32 wideLines; - VkBool32 largePoints; - VkBool32 alphaToOne; - VkBool32 multiViewport; - VkBool32 samplerAnisotropy; - VkBool32 textureCompressionETC2; - VkBool32 textureCompressionASTC_LDR; - VkBool32 textureCompressionBC; - VkBool32 occlusionQueryPrecise; - VkBool32 pipelineStatisticsQuery; - VkBool32 vertexPipelineStoresAndAtomics; - VkBool32 fragmentStoresAndAtomics; - VkBool32 shaderTessellationAndGeometryPointSize; - VkBool32 shaderImageGatherExtended; - VkBool32 shaderStorageImageExtendedFormats; - VkBool32 shaderStorageImageMultisample; - VkBool32 shaderStorageImageReadWithoutFormat; - VkBool32 shaderStorageImageWriteWithoutFormat; - VkBool32 shaderUniformBufferArrayDynamicIndexing; - VkBool32 shaderSampledImageArrayDynamicIndexing; - VkBool32 shaderStorageBufferArrayDynamicIndexing; - VkBool32 shaderStorageImageArrayDynamicIndexing; - VkBool32 shaderClipDistance; - VkBool32 shaderCullDistance; - VkBool32 shaderFloat64; - VkBool32 shaderInt64; - VkBool32 shaderInt16; - VkBool32 shaderResourceResidency; - VkBool32 shaderResourceMinLod; - VkBool32 sparseBinding; - VkBool32 sparseResidencyBuffer; - VkBool32 sparseResidencyImage2D; - VkBool32 sparseResidencyImage3D; - VkBool32 sparseResidency2Samples; - VkBool32 sparseResidency4Samples; - VkBool32 sparseResidency8Samples; - VkBool32 sparseResidency16Samples; - VkBool32 sparseResidencyAliased; - VkBool32 variableMultisampleRate; - VkBool32 inheritedQueries; -} VkPhysicalDeviceFeatures; - -typedef struct VkPhysicalDeviceLimits { - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - uint32_t maxTexelBufferElements; - uint32_t maxUniformBufferRange; - uint32_t maxStorageBufferRange; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - uint32_t maxSamplerAllocationCount; - VkDeviceSize bufferImageGranularity; - VkDeviceSize sparseAddressSpaceSize; - uint32_t maxBoundDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxPerStageDescriptorInputAttachments; - uint32_t maxPerStageResources; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetUniformBuffersDynamic; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetStorageBuffersDynamic; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxDescriptorSetInputAttachments; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputBindings; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessellationGenerationLevel; - uint32_t maxTessellationPatchSize; - uint32_t maxTessellationControlPerVertexInputComponents; - uint32_t maxTessellationControlPerVertexOutputComponents; - uint32_t maxTessellationControlPerPatchOutputComponents; - uint32_t maxTessellationControlTotalOutputComponents; - uint32_t maxTessellationEvaluationInputComponents; - uint32_t maxTessellationEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputAttachments; - uint32_t maxFragmentDualSrcAttachments; - uint32_t maxFragmentCombinedOutputResources; - uint32_t maxComputeSharedMemorySize; - uint32_t maxComputeWorkGroupCount[3]; - uint32_t maxComputeWorkGroupInvocations; - uint32_t maxComputeWorkGroupSize[3]; - uint32_t subPixelPrecisionBits; - uint32_t subTexelPrecisionBits; - uint32_t mipmapPrecisionBits; - uint32_t maxDrawIndexedIndexValue; - uint32_t maxDrawIndirectCount; - float maxSamplerLodBias; - float maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - size_t minMemoryMapAlignment; - VkDeviceSize minTexelBufferOffsetAlignment; - VkDeviceSize minUniformBufferOffsetAlignment; - VkDeviceSize minStorageBufferOffsetAlignment; - int32_t minTexelOffset; - uint32_t maxTexelOffset; - int32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - VkSampleCountFlags framebufferColorSampleCounts; - VkSampleCountFlags framebufferDepthSampleCounts; - VkSampleCountFlags framebufferStencilSampleCounts; - VkSampleCountFlags framebufferNoAttachmentsSampleCounts; - uint32_t maxColorAttachments; - VkSampleCountFlags sampledImageColorSampleCounts; - VkSampleCountFlags sampledImageIntegerSampleCounts; - VkSampleCountFlags sampledImageDepthSampleCounts; - VkSampleCountFlags sampledImageStencilSampleCounts; - VkSampleCountFlags storageImageSampleCounts; - uint32_t maxSampleMaskWords; - VkBool32 timestampComputeAndGraphics; - float timestampPeriod; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - uint32_t discreteQueuePriorities; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; - VkBool32 strictLines; - VkBool32 standardSampleLocations; - VkDeviceSize optimalBufferCopyOffsetAlignment; - VkDeviceSize optimalBufferCopyRowPitchAlignment; - VkDeviceSize nonCoherentAtomSize; -} VkPhysicalDeviceLimits; - -typedef struct VkPhysicalDeviceMemoryProperties { - uint32_t memoryTypeCount; - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryProperties; - -typedef struct VkPhysicalDeviceSparseProperties { - VkBool32 residencyStandard2DBlockShape; - VkBool32 residencyStandard2DMultisampleBlockShape; - VkBool32 residencyStandard3DBlockShape; - VkBool32 residencyAlignedMipSize; - VkBool32 residencyNonResidentStrict; -} VkPhysicalDeviceSparseProperties; - -typedef struct VkPhysicalDeviceProperties { - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorID; - uint32_t deviceID; - VkPhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; - VkPhysicalDeviceLimits limits; - VkPhysicalDeviceSparseProperties sparseProperties; -} VkPhysicalDeviceProperties; - -typedef struct VkQueueFamilyProperties { - VkQueueFlags queueFlags; - uint32_t queueCount; - uint32_t timestampValidBits; - VkExtent3D minImageTransferGranularity; -} VkQueueFamilyProperties; - -typedef struct VkDeviceQueueCreateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueCount; - const float* pQueuePriorities; -} VkDeviceQueueCreateInfo; - -typedef struct VkDeviceCreateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceCreateFlags flags; - uint32_t queueCreateInfoCount; - const VkDeviceQueueCreateInfo* pQueueCreateInfos; - // enabledLayerCount is legacy and should not be used - uint32_t enabledLayerCount; - // ppEnabledLayerNames is legacy and should not be used - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - const VkPhysicalDeviceFeatures* pEnabledFeatures; -} VkDeviceCreateInfo; - -typedef struct VkExtensionProperties { - char extensionName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; -} VkExtensionProperties; - -typedef struct VkLayerProperties { - char layerName[VK_MAX_EXTENSION_NAME_SIZE]; - uint32_t specVersion; - uint32_t implementationVersion; - char description[VK_MAX_DESCRIPTION_SIZE]; -} VkLayerProperties; - -typedef struct VkSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - const VkPipelineStageFlags* pWaitDstStageMask; - uint32_t commandBufferCount; - const VkCommandBuffer* pCommandBuffers; - uint32_t signalSemaphoreCount; - const VkSemaphore* pSignalSemaphores; -} VkSubmitInfo; - -typedef struct VkMappedMemoryRange { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkDeviceSize offset; - VkDeviceSize size; -} VkMappedMemoryRange; - -typedef struct VkMemoryAllocateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceSize allocationSize; - uint32_t memoryTypeIndex; -} VkMemoryAllocateInfo; - -typedef struct VkMemoryRequirements { - VkDeviceSize size; - VkDeviceSize alignment; - uint32_t memoryTypeBits; -} VkMemoryRequirements; - -typedef struct VkSparseMemoryBind { - VkDeviceSize resourceOffset; - VkDeviceSize size; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - VkSparseMemoryBindFlags flags; -} VkSparseMemoryBind; - -typedef struct VkSparseBufferMemoryBindInfo { - VkBuffer buffer; - uint32_t bindCount; - const VkSparseMemoryBind* pBinds; -} VkSparseBufferMemoryBindInfo; - -typedef struct VkSparseImageOpaqueMemoryBindInfo { - VkImage image; - uint32_t bindCount; - const VkSparseMemoryBind* pBinds; -} VkSparseImageOpaqueMemoryBindInfo; - -typedef struct VkImageSubresource { - VkImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t arrayLayer; -} VkImageSubresource; - -typedef struct VkSparseImageMemoryBind { - VkImageSubresource subresource; - VkOffset3D offset; - VkExtent3D extent; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - VkSparseMemoryBindFlags flags; -} VkSparseImageMemoryBind; - -typedef struct VkSparseImageMemoryBindInfo { - VkImage image; - uint32_t bindCount; - const VkSparseImageMemoryBind* pBinds; -} VkSparseImageMemoryBindInfo; - -typedef struct VkBindSparseInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - uint32_t bufferBindCount; - const VkSparseBufferMemoryBindInfo* pBufferBinds; - uint32_t imageOpaqueBindCount; - const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; - uint32_t imageBindCount; - const VkSparseImageMemoryBindInfo* pImageBinds; - uint32_t signalSemaphoreCount; - const VkSemaphore* pSignalSemaphores; -} VkBindSparseInfo; - -typedef struct VkSparseImageFormatProperties { - VkImageAspectFlags aspectMask; - VkExtent3D imageGranularity; - VkSparseImageFormatFlags flags; -} VkSparseImageFormatProperties; - -typedef struct VkSparseImageMemoryRequirements { - VkSparseImageFormatProperties formatProperties; - uint32_t imageMipTailFirstLod; - VkDeviceSize imageMipTailSize; - VkDeviceSize imageMipTailOffset; - VkDeviceSize imageMipTailStride; -} VkSparseImageMemoryRequirements; - -typedef struct VkFenceCreateInfo { - VkStructureType sType; - const void* pNext; - VkFenceCreateFlags flags; -} VkFenceCreateInfo; - -typedef struct VkSemaphoreCreateInfo { - VkStructureType sType; - const void* pNext; - VkSemaphoreCreateFlags flags; -} VkSemaphoreCreateInfo; - -typedef struct VkQueryPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkQueryPoolCreateFlags flags; - VkQueryType queryType; - uint32_t queryCount; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkQueryPoolCreateInfo; - -typedef struct VkBufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkBufferCreateFlags flags; - VkDeviceSize size; - VkBufferUsageFlags usage; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; -} VkBufferCreateInfo; - -typedef struct VkImageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageCreateFlags flags; - VkImageType imageType; - VkFormat format; - VkExtent3D extent; - uint32_t mipLevels; - uint32_t arrayLayers; - VkSampleCountFlagBits samples; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - VkImageLayout initialLayout; -} VkImageCreateInfo; - -typedef struct VkSubresourceLayout { - VkDeviceSize offset; - VkDeviceSize size; - VkDeviceSize rowPitch; - VkDeviceSize arrayPitch; - VkDeviceSize depthPitch; -} VkSubresourceLayout; - -typedef struct VkComponentMapping { - VkComponentSwizzle r; - VkComponentSwizzle g; - VkComponentSwizzle b; - VkComponentSwizzle a; -} VkComponentMapping; - -typedef struct VkImageViewCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageViewCreateFlags flags; - VkImage image; - VkImageViewType viewType; - VkFormat format; - VkComponentMapping components; - VkImageSubresourceRange subresourceRange; -} VkImageViewCreateInfo; - -typedef struct VkCommandPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkCommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; -} VkCommandPoolCreateInfo; - -typedef struct VkCommandBufferAllocateInfo { - VkStructureType sType; - const void* pNext; - VkCommandPool commandPool; - VkCommandBufferLevel level; - uint32_t commandBufferCount; -} VkCommandBufferAllocateInfo; - -typedef struct VkCommandBufferInheritanceInfo { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - uint32_t subpass; - VkFramebuffer framebuffer; - VkBool32 occlusionQueryEnable; - VkQueryControlFlags queryFlags; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkCommandBufferInheritanceInfo; - -typedef struct VkCommandBufferBeginInfo { - VkStructureType sType; - const void* pNext; - VkCommandBufferUsageFlags flags; - const VkCommandBufferInheritanceInfo* pInheritanceInfo; -} VkCommandBufferBeginInfo; - -typedef struct VkBufferCopy { - VkDeviceSize srcOffset; - VkDeviceSize dstOffset; - VkDeviceSize size; -} VkBufferCopy; - -typedef struct VkImageSubresourceLayers { - VkImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkImageSubresourceLayers; - -typedef struct VkBufferImageCopy { - VkDeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy; - -typedef struct VkImageCopy { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageCopy; - -typedef struct VkDispatchIndirectCommand { - uint32_t x; - uint32_t y; - uint32_t z; -} VkDispatchIndirectCommand; - -typedef struct VkPipelineCacheHeaderVersionOne { - uint32_t headerSize; - VkPipelineCacheHeaderVersion headerVersion; - uint32_t vendorID; - uint32_t deviceID; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; -} VkPipelineCacheHeaderVersionOne; - -typedef struct VkEventCreateInfo { - VkStructureType sType; - const void* pNext; - VkEventCreateFlags flags; -} VkEventCreateInfo; - -typedef struct VkBufferViewCreateInfo { - VkStructureType sType; - const void* pNext; - VkBufferViewCreateFlags flags; - VkBuffer buffer; - VkFormat format; - VkDeviceSize offset; - VkDeviceSize range; -} VkBufferViewCreateInfo; - -typedef struct VkShaderModuleCreateInfo { - VkStructureType sType; - const void* pNext; - VkShaderModuleCreateFlags flags; - size_t codeSize; - const uint32_t* pCode; -} VkShaderModuleCreateInfo; - -typedef struct VkPipelineCacheCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCacheCreateFlags flags; - size_t initialDataSize; - const void* pInitialData; -} VkPipelineCacheCreateInfo; - -typedef struct VkSpecializationMapEntry { - uint32_t constantID; - uint32_t offset; - size_t size; -} VkSpecializationMapEntry; - -typedef struct VkSpecializationInfo { - uint32_t mapEntryCount; - const VkSpecializationMapEntry* pMapEntries; - size_t dataSize; - const void* pData; -} VkSpecializationInfo; - -typedef struct VkPipelineShaderStageCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineShaderStageCreateFlags flags; - VkShaderStageFlagBits stage; - VkShaderModule module; - const char* pName; - const VkSpecializationInfo* pSpecializationInfo; -} VkPipelineShaderStageCreateInfo; - -typedef struct VkComputePipelineCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - VkPipelineShaderStageCreateInfo stage; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkComputePipelineCreateInfo; - -typedef struct VkPushConstantRange { - VkShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; -} VkPushConstantRange; - -typedef struct VkPipelineLayoutCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const VkDescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange* pPushConstantRanges; -} VkPipelineLayoutCreateInfo; - -typedef struct VkSamplerCreateInfo { - VkStructureType sType; - const void* pNext; - VkSamplerCreateFlags flags; - VkFilter magFilter; - VkFilter minFilter; - VkSamplerMipmapMode mipmapMode; - VkSamplerAddressMode addressModeU; - VkSamplerAddressMode addressModeV; - VkSamplerAddressMode addressModeW; - float mipLodBias; - VkBool32 anisotropyEnable; - float maxAnisotropy; - VkBool32 compareEnable; - VkCompareOp compareOp; - float minLod; - float maxLod; - VkBorderColor borderColor; - VkBool32 unnormalizedCoordinates; -} VkSamplerCreateInfo; - -typedef struct VkCopyDescriptorSet { - VkStructureType sType; - const void* pNext; - VkDescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - VkDescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; -} VkCopyDescriptorSet; - -typedef struct VkDescriptorBufferInfo { - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize range; -} VkDescriptorBufferInfo; - -typedef struct VkDescriptorImageInfo { - VkSampler sampler; - VkImageView imageView; - VkImageLayout imageLayout; -} VkDescriptorImageInfo; - -typedef struct VkDescriptorPoolSize { - VkDescriptorType type; - uint32_t descriptorCount; -} VkDescriptorPoolSize; - -typedef struct VkDescriptorPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - const VkDescriptorPoolSize* pPoolSizes; -} VkDescriptorPoolCreateInfo; - -typedef struct VkDescriptorSetAllocateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorPool descriptorPool; - uint32_t descriptorSetCount; - const VkDescriptorSetLayout* pSetLayouts; -} VkDescriptorSetAllocateInfo; - -typedef struct VkDescriptorSetLayoutBinding { - uint32_t binding; - VkDescriptorType descriptorType; - uint32_t descriptorCount; - VkShaderStageFlags stageFlags; - const VkSampler* pImmutableSamplers; -} VkDescriptorSetLayoutBinding; - -typedef struct VkDescriptorSetLayoutCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorSetLayoutCreateFlags flags; - uint32_t bindingCount; - const VkDescriptorSetLayoutBinding* pBindings; -} VkDescriptorSetLayoutCreateInfo; - -typedef struct VkWriteDescriptorSet { - VkStructureType sType; - const void* pNext; - VkDescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - const VkDescriptorImageInfo* pImageInfo; - const VkDescriptorBufferInfo* pBufferInfo; - const VkBufferView* pTexelBufferView; -} VkWriteDescriptorSet; - -typedef union VkClearColorValue { - float float32[4]; - int32_t int32[4]; - uint32_t uint32[4]; -} VkClearColorValue; - -typedef struct VkDrawIndexedIndirectCommand { - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VkDrawIndexedIndirectCommand; - -typedef struct VkDrawIndirectCommand { - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; -} VkDrawIndirectCommand; - -typedef struct VkVertexInputBindingDescription { - uint32_t binding; - uint32_t stride; - VkVertexInputRate inputRate; -} VkVertexInputBindingDescription; - -typedef struct VkVertexInputAttributeDescription { - uint32_t location; - uint32_t binding; - VkFormat format; - uint32_t offset; -} VkVertexInputAttributeDescription; - -typedef struct VkPipelineVertexInputStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineVertexInputStateCreateFlags flags; - uint32_t vertexBindingDescriptionCount; - const VkVertexInputBindingDescription* pVertexBindingDescriptions; - uint32_t vertexAttributeDescriptionCount; - const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; -} VkPipelineVertexInputStateCreateInfo; - -typedef struct VkPipelineInputAssemblyStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineInputAssemblyStateCreateFlags flags; - VkPrimitiveTopology topology; - VkBool32 primitiveRestartEnable; -} VkPipelineInputAssemblyStateCreateInfo; - -typedef struct VkPipelineTessellationStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineTessellationStateCreateFlags flags; - uint32_t patchControlPoints; -} VkPipelineTessellationStateCreateInfo; - -typedef struct VkViewport { - float x; - float y; - float width; - float height; - float minDepth; - float maxDepth; -} VkViewport; - -typedef struct VkPipelineViewportStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineViewportStateCreateFlags flags; - uint32_t viewportCount; - const VkViewport* pViewports; - uint32_t scissorCount; - const VkRect2D* pScissors; -} VkPipelineViewportStateCreateInfo; - -typedef struct VkPipelineRasterizationStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationStateCreateFlags flags; - VkBool32 depthClampEnable; - VkBool32 rasterizerDiscardEnable; - VkPolygonMode polygonMode; - VkCullModeFlags cullMode; - VkFrontFace frontFace; - VkBool32 depthBiasEnable; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; - float lineWidth; -} VkPipelineRasterizationStateCreateInfo; - -typedef struct VkPipelineMultisampleStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineMultisampleStateCreateFlags flags; - VkSampleCountFlagBits rasterizationSamples; - VkBool32 sampleShadingEnable; - float minSampleShading; - const VkSampleMask* pSampleMask; - VkBool32 alphaToCoverageEnable; - VkBool32 alphaToOneEnable; -} VkPipelineMultisampleStateCreateInfo; - -typedef struct VkStencilOpState { - VkStencilOp failOp; - VkStencilOp passOp; - VkStencilOp depthFailOp; - VkCompareOp compareOp; - uint32_t compareMask; - uint32_t writeMask; - uint32_t reference; -} VkStencilOpState; - -typedef struct VkPipelineDepthStencilStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineDepthStencilStateCreateFlags flags; - VkBool32 depthTestEnable; - VkBool32 depthWriteEnable; - VkCompareOp depthCompareOp; - VkBool32 depthBoundsTestEnable; - VkBool32 stencilTestEnable; - VkStencilOpState front; - VkStencilOpState back; - float minDepthBounds; - float maxDepthBounds; -} VkPipelineDepthStencilStateCreateInfo; - -typedef struct VkPipelineColorBlendAttachmentState { - VkBool32 blendEnable; - VkBlendFactor srcColorBlendFactor; - VkBlendFactor dstColorBlendFactor; - VkBlendOp colorBlendOp; - VkBlendFactor srcAlphaBlendFactor; - VkBlendFactor dstAlphaBlendFactor; - VkBlendOp alphaBlendOp; - VkColorComponentFlags colorWriteMask; -} VkPipelineColorBlendAttachmentState; - -typedef struct VkPipelineColorBlendStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineColorBlendStateCreateFlags flags; - VkBool32 logicOpEnable; - VkLogicOp logicOp; - uint32_t attachmentCount; - const VkPipelineColorBlendAttachmentState* pAttachments; - float blendConstants[4]; -} VkPipelineColorBlendStateCreateInfo; - -typedef struct VkPipelineDynamicStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineDynamicStateCreateFlags flags; - uint32_t dynamicStateCount; - const VkDynamicState* pDynamicStates; -} VkPipelineDynamicStateCreateInfo; - -typedef struct VkGraphicsPipelineCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const VkPipelineVertexInputStateCreateInfo* pVertexInputState; - const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; - const VkPipelineTessellationStateCreateInfo* pTessellationState; - const VkPipelineViewportStateCreateInfo* pViewportState; - const VkPipelineRasterizationStateCreateInfo* pRasterizationState; - const VkPipelineMultisampleStateCreateInfo* pMultisampleState; - const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; - const VkPipelineColorBlendStateCreateInfo* pColorBlendState; - const VkPipelineDynamicStateCreateInfo* pDynamicState; - VkPipelineLayout layout; - VkRenderPass renderPass; - uint32_t subpass; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkGraphicsPipelineCreateInfo; - -typedef struct VkAttachmentDescription { - VkAttachmentDescriptionFlags flags; - VkFormat format; - VkSampleCountFlagBits samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription; - -typedef struct VkAttachmentReference { - uint32_t attachment; - VkImageLayout layout; -} VkAttachmentReference; - -typedef struct VkFramebufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkFramebufferCreateFlags flags; - VkRenderPass renderPass; - uint32_t attachmentCount; - const VkImageView* pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; -} VkFramebufferCreateInfo; - -typedef struct VkSubpassDescription { - VkSubpassDescriptionFlags flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t inputAttachmentCount; - const VkAttachmentReference* pInputAttachments; - uint32_t colorAttachmentCount; - const VkAttachmentReference* pColorAttachments; - const VkAttachmentReference* pResolveAttachments; - const VkAttachmentReference* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; -} VkSubpassDescription; - -typedef struct VkSubpassDependency { - uint32_t srcSubpass; - uint32_t dstSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags dstStageMask; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkDependencyFlags dependencyFlags; -} VkSubpassDependency; - -typedef struct VkRenderPassCreateInfo { - VkStructureType sType; - const void* pNext; - VkRenderPassCreateFlags flags; - uint32_t attachmentCount; - const VkAttachmentDescription* pAttachments; - uint32_t subpassCount; - const VkSubpassDescription* pSubpasses; - uint32_t dependencyCount; - const VkSubpassDependency* pDependencies; -} VkRenderPassCreateInfo; - -typedef struct VkClearDepthStencilValue { - float depth; - uint32_t stencil; -} VkClearDepthStencilValue; - -typedef union VkClearValue { - VkClearColorValue color; - VkClearDepthStencilValue depthStencil; -} VkClearValue; - -typedef struct VkClearAttachment { - VkImageAspectFlags aspectMask; - uint32_t colorAttachment; - VkClearValue clearValue; -} VkClearAttachment; - -typedef struct VkClearRect { - VkRect2D rect; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkClearRect; - -typedef struct VkImageBlit { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffsets[2]; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffsets[2]; -} VkImageBlit; - -typedef struct VkImageResolve { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageResolve; - -typedef struct VkRenderPassBeginInfo { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - VkFramebuffer framebuffer; - VkRect2D renderArea; - uint32_t clearValueCount; - const VkClearValue* pClearValues; -} VkRenderPassBeginInfo; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); -typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); -typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); -typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); -typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue); -typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device); -typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); -typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); -typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); -typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); -typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); -typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); -typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); -typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); -typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); -typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); -typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); -typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); -typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); -typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); -typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); -typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); -typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); -typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); -typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); -typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); -typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); -typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); -typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); -typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); -typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); -typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); -typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); -typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); -typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); -typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); -typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event); -typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); -typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); -typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); -typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); -typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); -typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); -typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); -typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); -typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); -typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); -typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); -typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); -typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); -typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); -typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); -typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); -typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); -typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); -typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); -typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); -typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); -typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); -typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); -typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); -typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); -typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); -typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance); - -VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( - VkInstance instance, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( - VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties* pFormatProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkImageFormatProperties* pImageFormatProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties* pQueueFamilyProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperties); - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr( - VkInstance instance, - const char* pName); - -VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr( - VkDevice device, - const char* pName); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDevice* pDevice); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDevice( - VkDevice device, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties( - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties( - uint32_t* pPropertyCount, - VkLayerProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkLayerProperties* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue( - VkDevice device, - uint32_t queueFamilyIndex, - uint32_t queueIndex, - VkQueue* pQueue); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo* pSubmits, - VkFence fence); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle( - VkQueue queue); - -VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle( - VkDevice device); - -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory( - VkDevice device, - const VkMemoryAllocateInfo* pAllocateInfo, - const VkAllocationCallbacks* pAllocator, - VkDeviceMemory* pMemory); - -VKAPI_ATTR void VKAPI_CALL vkFreeMemory( - VkDevice device, - VkDeviceMemory memory, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData); - -VKAPI_ATTR void VKAPI_CALL vkUnmapMemory( - VkDevice device, - VkDeviceMemory memory); - -VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges); - -VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize* pCommittedMemoryInBytes); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory( - VkDevice device, - VkBuffer buffer, - VkDeviceMemory memory, - VkDeviceSize memoryOffset); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory( - VkDevice device, - VkImage image, - VkDeviceMemory memory, - VkDeviceSize memoryOffset); - -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements( - VkDevice device, - VkBuffer buffer, - VkMemoryRequirements* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements( - VkDevice device, - VkImage image, - VkMemoryRequirements* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( - VkDevice device, - VkImage image, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements* pSparseMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkSampleCountFlagBits samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties* pProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse( - VkQueue queue, - uint32_t bindInfoCount, - const VkBindSparseInfo* pBindInfo, - VkFence fence); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence( - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); - -VKAPI_ATTR void VKAPI_CALL vkDestroyFence( - VkDevice device, - VkFence fence, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus( - VkDevice device, - VkFence fence); - -VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences, - VkBool32 waitAll, - uint64_t timeout); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSemaphore* pSemaphore); - -VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore( - VkDevice device, - VkSemaphore semaphore, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkQueryPool* pQueryPool); - -VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool( - VkDevice device, - VkQueryPool queryPool, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - size_t dataSize, - void* pData, - VkDeviceSize stride, - VkQueryResultFlags flags); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer( - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBuffer* pBuffer); - -VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer( - VkDevice device, - VkBuffer buffer, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage( - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImage* pImage); - -VKAPI_ATTR void VKAPI_CALL vkDestroyImage( - VkDevice device, - VkImage image, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView( - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImageView* pView); - -VKAPI_ATTR void VKAPI_CALL vkDestroyImageView( - VkDevice device, - VkImageView imageView, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool( - VkDevice device, - const VkCommandPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCommandPool* pCommandPool); - -VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool( - VkDevice device, - VkCommandPool commandPool, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolResetFlags flags); - -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( - VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers); - -VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( - VkDevice device, - VkCommandPool commandPool, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers); - -VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer( - VkCommandBuffer commandBuffer, - const VkCommandBufferBeginInfo* pBeginInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer( - VkCommandBuffer commandBuffer); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer( - VkCommandBuffer commandBuffer, - VkCommandBufferResetFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize dataSize, - const void* pData); - -VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize size, - uint32_t data); - -VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkDependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query); - -VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); - -VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - uint32_t query); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize stride, - VkQueryResultFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands( - VkCommandBuffer commandBuffer, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkEvent* pEvent); - -VKAPI_ATTR void VKAPI_CALL vkDestroyEvent( - VkDevice device, - VkEvent event, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus( - VkDevice device, - VkEvent event); - -VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent( - VkDevice device, - VkEvent event); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent( - VkDevice device, - VkEvent event); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBufferView* pView); - -VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView( - VkDevice device, - VkBufferView bufferView, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkShaderModule* pShaderModule); - -VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule( - VkDevice device, - VkShaderModule shaderModule, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache( - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineCache* pPipelineCache); - -VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache( - VkDevice device, - VkPipelineCache pipelineCache, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData( - VkDevice device, - VkPipelineCache pipelineCache, - size_t* pDataSize, - void* pData); - -VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches( - VkDevice device, - VkPipelineCache dstCache, - uint32_t srcCacheCount, - const VkPipelineCache* pSrcCaches); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkComputePipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); - -VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline( - VkDevice device, - VkPipeline pipeline, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineLayout* pPipelineLayout); - -VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout( - VkDevice device, - VkPipelineLayout pipelineLayout, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSampler* pSampler); - -VKAPI_ATTR void VKAPI_CALL vkDestroySampler( - VkDevice device, - VkSampler sampler, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorSetLayout* pSetLayout); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout( - VkDevice device, - VkDescriptorSetLayout descriptorSetLayout, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool( - VkDevice device, - const VkDescriptorPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorPool* pDescriptorPool); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorPoolResetFlags flags); - -VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets( - VkDevice device, - const VkDescriptorSetAllocateInfo* pAllocateInfo, - VkDescriptorSet* pDescriptorSets); - -VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets); - -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets( - VkDevice device, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t descriptorCopyCount, - const VkCopyDescriptorSet* pDescriptorCopies); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t* pDynamicOffsets); - -VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatch( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers); - -VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants( - VkCommandBuffer commandBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void* pValues); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFramebuffer* pFramebuffer); - -VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer( - VkDevice device, - VkFramebuffer framebuffer, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass); - -VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass( - VkDevice device, - VkRenderPass renderPass, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity( - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewport* pViewports); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor( - VkCommandBuffer commandBuffer, - uint32_t firstScissor, - uint32_t scissorCount, - const VkRect2D* pScissors); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth( - VkCommandBuffer commandBuffer, - float lineWidth); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias( - VkCommandBuffer commandBuffer, - float depthBiasConstantFactor, - float depthBiasClamp, - float depthBiasSlopeFactor); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants( - VkCommandBuffer commandBuffer, - const float blendConstants[4]); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds( - VkCommandBuffer commandBuffer, - float minDepthBounds, - float maxDepthBounds); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t compareMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t writeMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t reference); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets); - -VKAPI_ATTR void VKAPI_CALL vkCmdDraw( - VkCommandBuffer commandBuffer, - uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed( - VkCommandBuffer commandBuffer, - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageBlit* pRegions, - VkFilter filter); - -VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges); - -VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkClearAttachment* pAttachments, - uint32_t rectCount, - const VkClearRect* pRects); - -VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - VkSubpassContents contents); - -VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass( - VkCommandBuffer commandBuffer, - VkSubpassContents contents); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass( - VkCommandBuffer commandBuffer); -#endif - - -// VK_VERSION_1_1 is a preprocessor guard. Do not pass it to API calls. -#define VK_VERSION_1_1 1 -// Vulkan 1.1 version number -#define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0 - -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion) -#define VK_MAX_DEVICE_GROUP_SIZE 32U -#define VK_LUID_SIZE 8U -#define VK_QUEUE_FAMILY_EXTERNAL (~1U) - -typedef enum VkDescriptorUpdateTemplateType { - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS = 1, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorUpdateTemplateType; - -typedef enum VkSamplerYcbcrModelConversion { - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF -} VkSamplerYcbcrModelConversion; - -typedef enum VkSamplerYcbcrRange { - VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, - VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, - VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, - VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, - VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerYcbcrRange; - -typedef enum VkChromaLocation { - VK_CHROMA_LOCATION_COSITED_EVEN = 0, - VK_CHROMA_LOCATION_MIDPOINT = 1, - VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN, - VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT, - VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF -} VkChromaLocation; - -typedef enum VkPointClippingBehavior { - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, - VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF -} VkPointClippingBehavior; - -typedef enum VkTessellationDomainOrigin { - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF -} VkTessellationDomainOrigin; - -typedef enum VkPeerMemoryFeatureFlagBits { - VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, - VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, - VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, - VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, - VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, - VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, - VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, - VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, - VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPeerMemoryFeatureFlagBits; -typedef VkFlags VkPeerMemoryFeatureFlags; - -typedef enum VkMemoryAllocateFlagBits { - VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004, - VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT = 0x00000008, - VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, - VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryAllocateFlagBits; -typedef VkFlags VkMemoryAllocateFlags; -typedef VkFlags VkCommandPoolTrimFlags; - -typedef enum VkExternalMemoryHandleTypeFlagBits { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS = 0x00008000, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX = 0x00004000, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT = 0x00010000, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT = 0x00020000, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT = 0x00040000, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalMemoryHandleTypeFlagBits; -typedef VkFlags VkExternalMemoryHandleTypeFlags; - -typedef enum VkExternalMemoryFeatureFlagBits { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalMemoryFeatureFlagBits; -typedef VkFlags VkExternalMemoryFeatureFlags; - -typedef enum VkExternalFenceHandleTypeFlagBits { - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalFenceHandleTypeFlagBits; -typedef VkFlags VkExternalFenceHandleTypeFlags; - -typedef enum VkExternalFenceFeatureFlagBits { - VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, - VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalFenceFeatureFlagBits; -typedef VkFlags VkExternalFenceFeatureFlags; - -typedef enum VkFenceImportFlagBits { - VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, - VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT, - VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFenceImportFlagBits; -typedef VkFlags VkFenceImportFlags; - -typedef enum VkSemaphoreImportFlagBits { - VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, - VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, - VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreImportFlagBits; -typedef VkFlags VkSemaphoreImportFlags; - -typedef enum VkExternalSemaphoreHandleTypeFlagBits { - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0x00000080, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalSemaphoreHandleTypeFlagBits; -typedef VkFlags VkExternalSemaphoreHandleTypeFlags; - -typedef enum VkExternalSemaphoreFeatureFlagBits { - VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalSemaphoreFeatureFlagBits; -typedef VkFlags VkExternalSemaphoreFeatureFlags; - -typedef enum VkSubgroupFeatureFlagBits { - VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, - VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, - VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, - VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, - VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, - VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, - VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, - VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, - VK_SUBGROUP_FEATURE_ROTATE_BIT = 0x00000200, - VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT = 0x00000400, - VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT = 0x00000100, - VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT, - VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_BIT, - VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT, - VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSubgroupFeatureFlagBits; -typedef VkFlags VkSubgroupFeatureFlags; -typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; -typedef struct VkBindBufferMemoryInfo { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; -} VkBindBufferMemoryInfo; - -typedef struct VkBindImageMemoryInfo { - VkStructureType sType; - const void* pNext; - VkImage image; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; -} VkBindImageMemoryInfo; - -typedef struct VkMemoryDedicatedRequirements { - VkStructureType sType; - void* pNext; - VkBool32 prefersDedicatedAllocation; - VkBool32 requiresDedicatedAllocation; -} VkMemoryDedicatedRequirements; - -typedef struct VkMemoryDedicatedAllocateInfo { - VkStructureType sType; - const void* pNext; - VkImage image; - VkBuffer buffer; -} VkMemoryDedicatedAllocateInfo; - -typedef struct VkMemoryAllocateFlagsInfo { - VkStructureType sType; - const void* pNext; - VkMemoryAllocateFlags flags; - uint32_t deviceMask; -} VkMemoryAllocateFlagsInfo; - -typedef struct VkDeviceGroupCommandBufferBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceMask; -} VkDeviceGroupCommandBufferBeginInfo; - -typedef struct VkDeviceGroupSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const uint32_t* pWaitSemaphoreDeviceIndices; - uint32_t commandBufferCount; - const uint32_t* pCommandBufferDeviceMasks; - uint32_t signalSemaphoreCount; - const uint32_t* pSignalSemaphoreDeviceIndices; -} VkDeviceGroupSubmitInfo; - -typedef struct VkDeviceGroupBindSparseInfo { - VkStructureType sType; - const void* pNext; - uint32_t resourceDeviceIndex; - uint32_t memoryDeviceIndex; -} VkDeviceGroupBindSparseInfo; - -typedef struct VkBindBufferMemoryDeviceGroupInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; -} VkBindBufferMemoryDeviceGroupInfo; - -typedef struct VkBindImageMemoryDeviceGroupInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - uint32_t splitInstanceBindRegionCount; - const VkRect2D* pSplitInstanceBindRegions; -} VkBindImageMemoryDeviceGroupInfo; - -typedef struct VkPhysicalDeviceGroupProperties { - VkStructureType sType; - void* pNext; - uint32_t physicalDeviceCount; - VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; - VkBool32 subsetAllocation; -} VkPhysicalDeviceGroupProperties; - -typedef struct VkDeviceGroupDeviceCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t physicalDeviceCount; - const VkPhysicalDevice* pPhysicalDevices; -} VkDeviceGroupDeviceCreateInfo; - -typedef struct VkBufferMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferMemoryRequirementsInfo2; - -typedef struct VkImageMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkImage image; -} VkImageMemoryRequirementsInfo2; - -typedef struct VkImageSparseMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkImage image; -} VkImageSparseMemoryRequirementsInfo2; - -typedef struct VkMemoryRequirements2 { - VkStructureType sType; - void* pNext; - VkMemoryRequirements memoryRequirements; -} VkMemoryRequirements2; - -typedef struct VkSparseImageMemoryRequirements2 { - VkStructureType sType; - void* pNext; - VkSparseImageMemoryRequirements memoryRequirements; -} VkSparseImageMemoryRequirements2; - -typedef struct VkPhysicalDeviceFeatures2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceFeatures features; -} VkPhysicalDeviceFeatures2; - -typedef struct VkPhysicalDeviceProperties2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceProperties properties; -} VkPhysicalDeviceProperties2; - -typedef struct VkFormatProperties2 { - VkStructureType sType; - void* pNext; - VkFormatProperties formatProperties; -} VkFormatProperties2; - -typedef struct VkImageFormatProperties2 { - VkStructureType sType; - void* pNext; - VkImageFormatProperties imageFormatProperties; -} VkImageFormatProperties2; - -typedef struct VkPhysicalDeviceImageFormatInfo2 { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkImageType type; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkImageCreateFlags flags; -} VkPhysicalDeviceImageFormatInfo2; - -typedef struct VkQueueFamilyProperties2 { - VkStructureType sType; - void* pNext; - VkQueueFamilyProperties queueFamilyProperties; -} VkQueueFamilyProperties2; - -typedef struct VkPhysicalDeviceMemoryProperties2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceMemoryProperties memoryProperties; -} VkPhysicalDeviceMemoryProperties2; - -typedef struct VkSparseImageFormatProperties2 { - VkStructureType sType; - void* pNext; - VkSparseImageFormatProperties properties; -} VkSparseImageFormatProperties2; - -typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkImageType type; - VkSampleCountFlagBits samples; - VkImageUsageFlags usage; - VkImageTiling tiling; -} VkPhysicalDeviceSparseImageFormatInfo2; - -typedef struct VkImageViewUsageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageUsageFlags usage; -} VkImageViewUsageCreateInfo; - -typedef struct VkPhysicalDeviceProtectedMemoryFeatures { - VkStructureType sType; - void* pNext; - VkBool32 protectedMemory; -} VkPhysicalDeviceProtectedMemoryFeatures; - -typedef struct VkPhysicalDeviceProtectedMemoryProperties { - VkStructureType sType; - void* pNext; - VkBool32 protectedNoFault; -} VkPhysicalDeviceProtectedMemoryProperties; - -typedef struct VkDeviceQueueInfo2 { - VkStructureType sType; - const void* pNext; - VkDeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueIndex; -} VkDeviceQueueInfo2; - -typedef struct VkProtectedSubmitInfo { - VkStructureType sType; - const void* pNext; - VkBool32 protectedSubmit; -} VkProtectedSubmitInfo; - -typedef struct VkBindImagePlaneMemoryInfo { - VkStructureType sType; - const void* pNext; - VkImageAspectFlagBits planeAspect; -} VkBindImagePlaneMemoryInfo; - -typedef struct VkImagePlaneMemoryRequirementsInfo { - VkStructureType sType; - const void* pNext; - VkImageAspectFlagBits planeAspect; -} VkImagePlaneMemoryRequirementsInfo; - -typedef struct VkExternalMemoryProperties { - VkExternalMemoryFeatureFlags externalMemoryFeatures; - VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; - VkExternalMemoryHandleTypeFlags compatibleHandleTypes; -} VkExternalMemoryProperties; - -typedef struct VkPhysicalDeviceExternalImageFormatInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalImageFormatInfo; - -typedef struct VkExternalImageFormatProperties { - VkStructureType sType; - void* pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalImageFormatProperties; - -typedef struct VkPhysicalDeviceExternalBufferInfo { - VkStructureType sType; - const void* pNext; - VkBufferCreateFlags flags; - VkBufferUsageFlags usage; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalBufferInfo; - -typedef struct VkExternalBufferProperties { - VkStructureType sType; - void* pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalBufferProperties; - -typedef struct VkPhysicalDeviceIDProperties { - VkStructureType sType; - void* pNext; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE]; - uint32_t deviceNodeMask; - VkBool32 deviceLUIDValid; -} VkPhysicalDeviceIDProperties; - -typedef struct VkExternalMemoryImageCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryImageCreateInfo; - -typedef struct VkExternalMemoryBufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryBufferCreateInfo; - -typedef struct VkExportMemoryAllocateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExportMemoryAllocateInfo; - -typedef struct VkPhysicalDeviceExternalFenceInfo { - VkStructureType sType; - const void* pNext; - VkExternalFenceHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalFenceInfo; - -typedef struct VkExternalFenceProperties { - VkStructureType sType; - void* pNext; - VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; - VkExternalFenceHandleTypeFlags compatibleHandleTypes; - VkExternalFenceFeatureFlags externalFenceFeatures; -} VkExternalFenceProperties; - -typedef struct VkExportFenceCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalFenceHandleTypeFlags handleTypes; -} VkExportFenceCreateInfo; - -typedef struct VkExportSemaphoreCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalSemaphoreHandleTypeFlags handleTypes; -} VkExportSemaphoreCreateInfo; - -typedef struct VkPhysicalDeviceExternalSemaphoreInfo { - VkStructureType sType; - const void* pNext; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalSemaphoreInfo; - -typedef struct VkExternalSemaphoreProperties { - VkStructureType sType; - void* pNext; - VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; - VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; - VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; -} VkExternalSemaphoreProperties; - -typedef struct VkPhysicalDeviceSubgroupProperties { - VkStructureType sType; - void* pNext; - uint32_t subgroupSize; - VkShaderStageFlags supportedStages; - VkSubgroupFeatureFlags supportedOperations; - VkBool32 quadOperationsInAllStages; -} VkPhysicalDeviceSubgroupProperties; - -typedef struct VkPhysicalDevice16BitStorageFeatures { - VkStructureType sType; - void* pNext; - VkBool32 storageBuffer16BitAccess; - VkBool32 uniformAndStorageBuffer16BitAccess; - VkBool32 storagePushConstant16; - VkBool32 storageInputOutput16; -} VkPhysicalDevice16BitStorageFeatures; - -typedef struct VkPhysicalDeviceVariablePointersFeatures { - VkStructureType sType; - void* pNext; - VkBool32 variablePointersStorageBuffer; - VkBool32 variablePointers; -} VkPhysicalDeviceVariablePointersFeatures; - -typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; - -typedef struct VkDescriptorUpdateTemplateEntry { - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - size_t offset; - size_t stride; -} VkDescriptorUpdateTemplateEntry; - -typedef struct VkDescriptorUpdateTemplateCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorUpdateTemplateCreateFlags flags; - uint32_t descriptorUpdateEntryCount; - const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; - VkDescriptorUpdateTemplateType templateType; - VkDescriptorSetLayout descriptorSetLayout; - VkPipelineBindPoint pipelineBindPoint; - VkPipelineLayout pipelineLayout; - uint32_t set; -} VkDescriptorUpdateTemplateCreateInfo; - -typedef struct VkPhysicalDeviceMaintenance3Properties { - VkStructureType sType; - void* pNext; - uint32_t maxPerSetDescriptors; - VkDeviceSize maxMemoryAllocationSize; -} VkPhysicalDeviceMaintenance3Properties; - -typedef struct VkDescriptorSetLayoutSupport { - VkStructureType sType; - void* pNext; - VkBool32 supported; -} VkDescriptorSetLayoutSupport; - -typedef struct VkSamplerYcbcrConversionCreateInfo { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkSamplerYcbcrModelConversion ycbcrModel; - VkSamplerYcbcrRange ycbcrRange; - VkComponentMapping components; - VkChromaLocation xChromaOffset; - VkChromaLocation yChromaOffset; - VkFilter chromaFilter; - VkBool32 forceExplicitReconstruction; -} VkSamplerYcbcrConversionCreateInfo; - -typedef struct VkSamplerYcbcrConversionInfo { - VkStructureType sType; - const void* pNext; - VkSamplerYcbcrConversion conversion; -} VkSamplerYcbcrConversionInfo; - -typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { - VkStructureType sType; - void* pNext; - VkBool32 samplerYcbcrConversion; -} VkPhysicalDeviceSamplerYcbcrConversionFeatures; - -typedef struct VkSamplerYcbcrConversionImageFormatProperties { - VkStructureType sType; - void* pNext; - uint32_t combinedImageSamplerDescriptorCount; -} VkSamplerYcbcrConversionImageFormatProperties; - -typedef struct VkDeviceGroupRenderPassBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceMask; - uint32_t deviceRenderAreaCount; - const VkRect2D* pDeviceRenderAreas; -} VkDeviceGroupRenderPassBeginInfo; - -typedef struct VkPhysicalDevicePointClippingProperties { - VkStructureType sType; - void* pNext; - VkPointClippingBehavior pointClippingBehavior; -} VkPhysicalDevicePointClippingProperties; - -typedef struct VkInputAttachmentAspectReference { - uint32_t subpass; - uint32_t inputAttachmentIndex; - VkImageAspectFlags aspectMask; -} VkInputAttachmentAspectReference; - -typedef struct VkRenderPassInputAttachmentAspectCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t aspectReferenceCount; - const VkInputAttachmentAspectReference* pAspectReferences; -} VkRenderPassInputAttachmentAspectCreateInfo; - -typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkTessellationDomainOrigin domainOrigin; -} VkPipelineTessellationDomainOriginStateCreateInfo; - -typedef struct VkRenderPassMultiviewCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t subpassCount; - const uint32_t* pViewMasks; - uint32_t dependencyCount; - const int32_t* pViewOffsets; - uint32_t correlationMaskCount; - const uint32_t* pCorrelationMasks; -} VkRenderPassMultiviewCreateInfo; - -typedef struct VkPhysicalDeviceMultiviewFeatures { - VkStructureType sType; - void* pNext; - VkBool32 multiview; - VkBool32 multiviewGeometryShader; - VkBool32 multiviewTessellationShader; -} VkPhysicalDeviceMultiviewFeatures; - -typedef struct VkPhysicalDeviceMultiviewProperties { - VkStructureType sType; - void* pNext; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; -} VkPhysicalDeviceMultiviewProperties; - -typedef struct VkPhysicalDeviceShaderDrawParametersFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderDrawParameters; -} VkPhysicalDeviceShaderDrawParametersFeatures; - -typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; - -typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); -typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); -typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); -typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); -typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); -typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); -typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion( - uint32_t* pApiVersion); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos); - -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask( - VkCommandBuffer commandBuffer, - uint32_t deviceMask); - -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties); - -VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2( - VkDevice device, - const VkDeviceQueueInfo2* pQueueInfo, - VkQueue* pQueue); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties); - -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties); - -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); - -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData); - -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion); - -VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator); -#endif - - -// VK_VERSION_1_2 is a preprocessor guard. Do not pass it to API calls. -#define VK_VERSION_1_2 1 -// Vulkan 1.2 version number -#define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0 - -#define VK_MAX_DRIVER_NAME_SIZE 256U -#define VK_MAX_DRIVER_INFO_SIZE 256U - -typedef enum VkDriverId { - VK_DRIVER_ID_AMD_PROPRIETARY = 1, - VK_DRIVER_ID_AMD_OPEN_SOURCE = 2, - VK_DRIVER_ID_MESA_RADV = 3, - VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4, - VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5, - VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6, - VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7, - VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8, - VK_DRIVER_ID_ARM_PROPRIETARY = 9, - VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10, - VK_DRIVER_ID_GGP_PROPRIETARY = 11, - VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12, - VK_DRIVER_ID_MESA_LLVMPIPE = 13, - VK_DRIVER_ID_MOLTENVK = 14, - VK_DRIVER_ID_COREAVI_PROPRIETARY = 15, - VK_DRIVER_ID_JUICE_PROPRIETARY = 16, - VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17, - VK_DRIVER_ID_MESA_TURNIP = 18, - VK_DRIVER_ID_MESA_V3DV = 19, - VK_DRIVER_ID_MESA_PANVK = 20, - VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21, - VK_DRIVER_ID_MESA_VENUS = 22, - VK_DRIVER_ID_MESA_DOZEN = 23, - VK_DRIVER_ID_MESA_NVK = 24, - VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25, - VK_DRIVER_ID_MESA_HONEYKRISP = 26, - VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN = 27, - VK_DRIVER_ID_MESA_KOSMICKRISP = 28, - VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY, - VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE, - VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV, - VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY, - VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS, - VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA, - VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY, - VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY, - VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY, - VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER, - VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY, - VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY, - VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF -} VkDriverId; - -typedef enum VkShaderFloatControlsIndependence { - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF -} VkShaderFloatControlsIndependence; - -typedef enum VkSemaphoreType { - VK_SEMAPHORE_TYPE_BINARY = 0, - VK_SEMAPHORE_TYPE_TIMELINE = 1, - VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY, - VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE, - VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreType; - -typedef enum VkSamplerReductionMode { - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, - VK_SAMPLER_REDUCTION_MODE_MIN = 1, - VK_SAMPLER_REDUCTION_MODE_MAX = 2, - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM = 1000521000, - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, - VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN, - VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX, - VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerReductionMode; - -typedef enum VkResolveModeFlagBits { - VK_RESOLVE_MODE_NONE = 0, - VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001, - VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002, - VK_RESOLVE_MODE_MIN_BIT = 0x00000004, - VK_RESOLVE_MODE_MAX_BIT = 0x00000008, - VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID = 0x00000010, - VK_RESOLVE_MODE_CUSTOM_BIT_EXT = 0x00000020, - VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE, - VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, - VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT, - VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT, - VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT, - // VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID is a legacy alias - VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID = VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID, - VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkResolveModeFlagBits; -typedef VkFlags VkResolveModeFlags; - -typedef enum VkSemaphoreWaitFlagBits { - VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001, - VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT, - VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreWaitFlagBits; -typedef VkFlags VkSemaphoreWaitFlags; - -typedef enum VkDescriptorBindingFlagBits { - VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001, - VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002, - VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004, - VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008, - VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, - VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, - VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, - VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, - VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorBindingFlagBits; -typedef VkFlags VkDescriptorBindingFlags; -typedef struct VkPhysicalDeviceVulkan11Features { - VkStructureType sType; - void* pNext; - VkBool32 storageBuffer16BitAccess; - VkBool32 uniformAndStorageBuffer16BitAccess; - VkBool32 storagePushConstant16; - VkBool32 storageInputOutput16; - VkBool32 multiview; - VkBool32 multiviewGeometryShader; - VkBool32 multiviewTessellationShader; - VkBool32 variablePointersStorageBuffer; - VkBool32 variablePointers; - VkBool32 protectedMemory; - VkBool32 samplerYcbcrConversion; - VkBool32 shaderDrawParameters; -} VkPhysicalDeviceVulkan11Features; - -typedef struct VkPhysicalDeviceVulkan11Properties { - VkStructureType sType; - void* pNext; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE]; - uint32_t deviceNodeMask; - VkBool32 deviceLUIDValid; - uint32_t subgroupSize; - VkShaderStageFlags subgroupSupportedStages; - VkSubgroupFeatureFlags subgroupSupportedOperations; - VkBool32 subgroupQuadOperationsInAllStages; - VkPointClippingBehavior pointClippingBehavior; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; - VkBool32 protectedNoFault; - uint32_t maxPerSetDescriptors; - VkDeviceSize maxMemoryAllocationSize; -} VkPhysicalDeviceVulkan11Properties; - -typedef struct VkPhysicalDeviceVulkan12Features { - VkStructureType sType; - void* pNext; - VkBool32 samplerMirrorClampToEdge; - VkBool32 drawIndirectCount; - VkBool32 storageBuffer8BitAccess; - VkBool32 uniformAndStorageBuffer8BitAccess; - VkBool32 storagePushConstant8; - VkBool32 shaderBufferInt64Atomics; - VkBool32 shaderSharedInt64Atomics; - VkBool32 shaderFloat16; - VkBool32 shaderInt8; - VkBool32 descriptorIndexing; - VkBool32 shaderInputAttachmentArrayDynamicIndexing; - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; - VkBool32 shaderUniformBufferArrayNonUniformIndexing; - VkBool32 shaderSampledImageArrayNonUniformIndexing; - VkBool32 shaderStorageBufferArrayNonUniformIndexing; - VkBool32 shaderStorageImageArrayNonUniformIndexing; - VkBool32 shaderInputAttachmentArrayNonUniformIndexing; - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; - VkBool32 descriptorBindingUniformBufferUpdateAfterBind; - VkBool32 descriptorBindingSampledImageUpdateAfterBind; - VkBool32 descriptorBindingStorageImageUpdateAfterBind; - VkBool32 descriptorBindingStorageBufferUpdateAfterBind; - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingUpdateUnusedWhilePending; - VkBool32 descriptorBindingPartiallyBound; - VkBool32 descriptorBindingVariableDescriptorCount; - VkBool32 runtimeDescriptorArray; - VkBool32 samplerFilterMinmax; - VkBool32 scalarBlockLayout; - VkBool32 imagelessFramebuffer; - VkBool32 uniformBufferStandardLayout; - VkBool32 shaderSubgroupExtendedTypes; - VkBool32 separateDepthStencilLayouts; - VkBool32 hostQueryReset; - VkBool32 timelineSemaphore; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; - VkBool32 vulkanMemoryModel; - VkBool32 vulkanMemoryModelDeviceScope; - VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; - VkBool32 shaderOutputViewportIndex; - VkBool32 shaderOutputLayer; - VkBool32 subgroupBroadcastDynamicId; -} VkPhysicalDeviceVulkan12Features; - -typedef struct VkConformanceVersion { - uint8_t major; - uint8_t minor; - uint8_t subminor; - uint8_t patch; -} VkConformanceVersion; - -typedef struct VkPhysicalDeviceVulkan12Properties { - VkStructureType sType; - void* pNext; - VkDriverId driverID; - char driverName[VK_MAX_DRIVER_NAME_SIZE]; - char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; - VkConformanceVersion conformanceVersion; - VkShaderFloatControlsIndependence denormBehaviorIndependence; - VkShaderFloatControlsIndependence roundingModeIndependence; - VkBool32 shaderSignedZeroInfNanPreserveFloat16; - VkBool32 shaderSignedZeroInfNanPreserveFloat32; - VkBool32 shaderSignedZeroInfNanPreserveFloat64; - VkBool32 shaderDenormPreserveFloat16; - VkBool32 shaderDenormPreserveFloat32; - VkBool32 shaderDenormPreserveFloat64; - VkBool32 shaderDenormFlushToZeroFloat16; - VkBool32 shaderDenormFlushToZeroFloat32; - VkBool32 shaderDenormFlushToZeroFloat64; - VkBool32 shaderRoundingModeRTEFloat16; - VkBool32 shaderRoundingModeRTEFloat32; - VkBool32 shaderRoundingModeRTEFloat64; - VkBool32 shaderRoundingModeRTZFloat16; - VkBool32 shaderRoundingModeRTZFloat32; - VkBool32 shaderRoundingModeRTZFloat64; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; - VkBool32 shaderSampledImageArrayNonUniformIndexingNative; - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; - VkBool32 shaderStorageImageArrayNonUniformIndexingNative; - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; - VkBool32 robustBufferAccessUpdateAfterBind; - VkBool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; - VkResolveModeFlags supportedDepthResolveModes; - VkResolveModeFlags supportedStencilResolveModes; - VkBool32 independentResolveNone; - VkBool32 independentResolve; - VkBool32 filterMinmaxSingleComponentFormats; - VkBool32 filterMinmaxImageComponentMapping; - uint64_t maxTimelineSemaphoreValueDifference; - VkSampleCountFlags framebufferIntegerColorSampleCounts; -} VkPhysicalDeviceVulkan12Properties; - -typedef struct VkImageFormatListCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t viewFormatCount; - const VkFormat* pViewFormats; -} VkImageFormatListCreateInfo; - -typedef struct VkPhysicalDeviceDriverProperties { - VkStructureType sType; - void* pNext; - VkDriverId driverID; - char driverName[VK_MAX_DRIVER_NAME_SIZE]; - char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; - VkConformanceVersion conformanceVersion; -} VkPhysicalDeviceDriverProperties; - -typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures { - VkStructureType sType; - void* pNext; - VkBool32 vulkanMemoryModel; - VkBool32 vulkanMemoryModelDeviceScope; - VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; -} VkPhysicalDeviceVulkanMemoryModelFeatures; - -typedef struct VkPhysicalDeviceHostQueryResetFeatures { - VkStructureType sType; - void* pNext; - VkBool32 hostQueryReset; -} VkPhysicalDeviceHostQueryResetFeatures; - -typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures { - VkStructureType sType; - void* pNext; - VkBool32 timelineSemaphore; -} VkPhysicalDeviceTimelineSemaphoreFeatures; - -typedef struct VkPhysicalDeviceTimelineSemaphoreProperties { - VkStructureType sType; - void* pNext; - uint64_t maxTimelineSemaphoreValueDifference; -} VkPhysicalDeviceTimelineSemaphoreProperties; - -typedef struct VkSemaphoreTypeCreateInfo { - VkStructureType sType; - const void* pNext; - VkSemaphoreType semaphoreType; - uint64_t initialValue; -} VkSemaphoreTypeCreateInfo; - -typedef struct VkTimelineSemaphoreSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreValueCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValueCount; - const uint64_t* pSignalSemaphoreValues; -} VkTimelineSemaphoreSubmitInfo; - -typedef struct VkSemaphoreWaitInfo { - VkStructureType sType; - const void* pNext; - VkSemaphoreWaitFlags flags; - uint32_t semaphoreCount; - const VkSemaphore* pSemaphores; - const uint64_t* pValues; -} VkSemaphoreWaitInfo; - -typedef struct VkSemaphoreSignalInfo { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - uint64_t value; -} VkSemaphoreSignalInfo; - -typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures { - VkStructureType sType; - void* pNext; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; -} VkPhysicalDeviceBufferDeviceAddressFeatures; - -typedef struct VkBufferDeviceAddressInfo { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferDeviceAddressInfo; - -typedef struct VkBufferOpaqueCaptureAddressCreateInfo { - VkStructureType sType; - const void* pNext; - uint64_t opaqueCaptureAddress; -} VkBufferOpaqueCaptureAddressCreateInfo; - -typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { - VkStructureType sType; - const void* pNext; - uint64_t opaqueCaptureAddress; -} VkMemoryOpaqueCaptureAddressAllocateInfo; - -typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; -} VkDeviceMemoryOpaqueCaptureAddressInfo; - -typedef struct VkPhysicalDevice8BitStorageFeatures { - VkStructureType sType; - void* pNext; - VkBool32 storageBuffer8BitAccess; - VkBool32 uniformAndStorageBuffer8BitAccess; - VkBool32 storagePushConstant8; -} VkPhysicalDevice8BitStorageFeatures; - -typedef struct VkPhysicalDeviceShaderAtomicInt64Features { - VkStructureType sType; - void* pNext; - VkBool32 shaderBufferInt64Atomics; - VkBool32 shaderSharedInt64Atomics; -} VkPhysicalDeviceShaderAtomicInt64Features; - -typedef struct VkPhysicalDeviceShaderFloat16Int8Features { - VkStructureType sType; - void* pNext; - VkBool32 shaderFloat16; - VkBool32 shaderInt8; -} VkPhysicalDeviceShaderFloat16Int8Features; - -typedef struct VkPhysicalDeviceFloatControlsProperties { - VkStructureType sType; - void* pNext; - VkShaderFloatControlsIndependence denormBehaviorIndependence; - VkShaderFloatControlsIndependence roundingModeIndependence; - VkBool32 shaderSignedZeroInfNanPreserveFloat16; - VkBool32 shaderSignedZeroInfNanPreserveFloat32; - VkBool32 shaderSignedZeroInfNanPreserveFloat64; - VkBool32 shaderDenormPreserveFloat16; - VkBool32 shaderDenormPreserveFloat32; - VkBool32 shaderDenormPreserveFloat64; - VkBool32 shaderDenormFlushToZeroFloat16; - VkBool32 shaderDenormFlushToZeroFloat32; - VkBool32 shaderDenormFlushToZeroFloat64; - VkBool32 shaderRoundingModeRTEFloat16; - VkBool32 shaderRoundingModeRTEFloat32; - VkBool32 shaderRoundingModeRTEFloat64; - VkBool32 shaderRoundingModeRTZFloat16; - VkBool32 shaderRoundingModeRTZFloat32; - VkBool32 shaderRoundingModeRTZFloat64; -} VkPhysicalDeviceFloatControlsProperties; - -typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t bindingCount; - const VkDescriptorBindingFlags* pBindingFlags; -} VkDescriptorSetLayoutBindingFlagsCreateInfo; - -typedef struct VkPhysicalDeviceDescriptorIndexingFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderInputAttachmentArrayDynamicIndexing; - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; - VkBool32 shaderUniformBufferArrayNonUniformIndexing; - VkBool32 shaderSampledImageArrayNonUniformIndexing; - VkBool32 shaderStorageBufferArrayNonUniformIndexing; - VkBool32 shaderStorageImageArrayNonUniformIndexing; - VkBool32 shaderInputAttachmentArrayNonUniformIndexing; - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; - VkBool32 descriptorBindingUniformBufferUpdateAfterBind; - VkBool32 descriptorBindingSampledImageUpdateAfterBind; - VkBool32 descriptorBindingStorageImageUpdateAfterBind; - VkBool32 descriptorBindingStorageBufferUpdateAfterBind; - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingUpdateUnusedWhilePending; - VkBool32 descriptorBindingPartiallyBound; - VkBool32 descriptorBindingVariableDescriptorCount; - VkBool32 runtimeDescriptorArray; -} VkPhysicalDeviceDescriptorIndexingFeatures; - -typedef struct VkPhysicalDeviceDescriptorIndexingProperties { - VkStructureType sType; - void* pNext; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; - VkBool32 shaderSampledImageArrayNonUniformIndexingNative; - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; - VkBool32 shaderStorageImageArrayNonUniformIndexingNative; - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; - VkBool32 robustBufferAccessUpdateAfterBind; - VkBool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; -} VkPhysicalDeviceDescriptorIndexingProperties; - -typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo { - VkStructureType sType; - const void* pNext; - uint32_t descriptorSetCount; - const uint32_t* pDescriptorCounts; -} VkDescriptorSetVariableDescriptorCountAllocateInfo; - -typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport { - VkStructureType sType; - void* pNext; - uint32_t maxVariableDescriptorCount; -} VkDescriptorSetVariableDescriptorCountLayoutSupport; - -typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures { - VkStructureType sType; - void* pNext; - VkBool32 scalarBlockLayout; -} VkPhysicalDeviceScalarBlockLayoutFeatures; - -typedef struct VkSamplerReductionModeCreateInfo { - VkStructureType sType; - const void* pNext; - VkSamplerReductionMode reductionMode; -} VkSamplerReductionModeCreateInfo; - -typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties { - VkStructureType sType; - void* pNext; - VkBool32 filterMinmaxSingleComponentFormats; - VkBool32 filterMinmaxImageComponentMapping; -} VkPhysicalDeviceSamplerFilterMinmaxProperties; - -typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures { - VkStructureType sType; - void* pNext; - VkBool32 uniformBufferStandardLayout; -} VkPhysicalDeviceUniformBufferStandardLayoutFeatures; - -typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderSubgroupExtendedTypes; -} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; - -typedef struct VkAttachmentDescription2 { - VkStructureType sType; - const void* pNext; - VkAttachmentDescriptionFlags flags; - VkFormat format; - VkSampleCountFlagBits samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription2; - -typedef struct VkAttachmentReference2 { - VkStructureType sType; - const void* pNext; - uint32_t attachment; - VkImageLayout layout; - VkImageAspectFlags aspectMask; -} VkAttachmentReference2; - -typedef struct VkSubpassDescription2 { - VkStructureType sType; - const void* pNext; - VkSubpassDescriptionFlags flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t viewMask; - uint32_t inputAttachmentCount; - const VkAttachmentReference2* pInputAttachments; - uint32_t colorAttachmentCount; - const VkAttachmentReference2* pColorAttachments; - const VkAttachmentReference2* pResolveAttachments; - const VkAttachmentReference2* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; -} VkSubpassDescription2; - -typedef struct VkSubpassDependency2 { - VkStructureType sType; - const void* pNext; - uint32_t srcSubpass; - uint32_t dstSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags dstStageMask; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkDependencyFlags dependencyFlags; - int32_t viewOffset; -} VkSubpassDependency2; - -typedef struct VkRenderPassCreateInfo2 { - VkStructureType sType; - const void* pNext; - VkRenderPassCreateFlags flags; - uint32_t attachmentCount; - const VkAttachmentDescription2* pAttachments; - uint32_t subpassCount; - const VkSubpassDescription2* pSubpasses; - uint32_t dependencyCount; - const VkSubpassDependency2* pDependencies; - uint32_t correlatedViewMaskCount; - const uint32_t* pCorrelatedViewMasks; -} VkRenderPassCreateInfo2; - -typedef struct VkSubpassBeginInfo { - VkStructureType sType; - const void* pNext; - VkSubpassContents contents; -} VkSubpassBeginInfo; - -typedef struct VkSubpassEndInfo { - VkStructureType sType; - const void* pNext; -} VkSubpassEndInfo; - -typedef struct VkSubpassDescriptionDepthStencilResolve { - VkStructureType sType; - const void* pNext; - VkResolveModeFlagBits depthResolveMode; - VkResolveModeFlagBits stencilResolveMode; - const VkAttachmentReference2* pDepthStencilResolveAttachment; -} VkSubpassDescriptionDepthStencilResolve; - -typedef struct VkPhysicalDeviceDepthStencilResolveProperties { - VkStructureType sType; - void* pNext; - VkResolveModeFlags supportedDepthResolveModes; - VkResolveModeFlags supportedStencilResolveModes; - VkBool32 independentResolveNone; - VkBool32 independentResolve; -} VkPhysicalDeviceDepthStencilResolveProperties; - -typedef struct VkImageStencilUsageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageUsageFlags stencilUsage; -} VkImageStencilUsageCreateInfo; - -typedef struct VkPhysicalDeviceImagelessFramebufferFeatures { - VkStructureType sType; - void* pNext; - VkBool32 imagelessFramebuffer; -} VkPhysicalDeviceImagelessFramebufferFeatures; - -typedef struct VkFramebufferAttachmentImageInfo { - VkStructureType sType; - const void* pNext; - VkImageCreateFlags flags; - VkImageUsageFlags usage; - uint32_t width; - uint32_t height; - uint32_t layerCount; - uint32_t viewFormatCount; - const VkFormat* pViewFormats; -} VkFramebufferAttachmentImageInfo; - -typedef struct VkFramebufferAttachmentsCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t attachmentImageInfoCount; - const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos; -} VkFramebufferAttachmentsCreateInfo; - -typedef struct VkRenderPassAttachmentBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t attachmentCount; - const VkImageView* pAttachments; -} VkRenderPassAttachmentBeginInfo; - -typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { - VkStructureType sType; - void* pNext; - VkBool32 separateDepthStencilLayouts; -} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; - -typedef struct VkAttachmentReferenceStencilLayout { - VkStructureType sType; - void* pNext; - VkImageLayout stencilLayout; -} VkAttachmentReferenceStencilLayout; - -typedef struct VkAttachmentDescriptionStencilLayout { - VkStructureType sType; - void* pNext; - VkImageLayout stencilInitialLayout; - VkImageLayout stencilFinalLayout; -} VkAttachmentDescriptionStencilLayout; - -typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); -typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); -typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); -typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); -typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkResetQueryPool( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); - -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue( - VkDevice device, - VkSemaphore semaphore, - uint64_t* pValue); - -VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores( - VkDevice device, - const VkSemaphoreWaitInfo* pWaitInfo, - uint64_t timeout); - -VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore( - VkDevice device, - const VkSemaphoreSignalInfo* pSignalInfo); - -VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); - -VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); - -VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress( - VkDevice device, - const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2( - VkDevice device, - const VkRenderPassCreateInfo2* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - const VkSubpassBeginInfo* pSubpassBeginInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo* pSubpassBeginInfo, - const VkSubpassEndInfo* pSubpassEndInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfo* pSubpassEndInfo); -#endif - - -// VK_VERSION_1_3 is a preprocessor guard. Do not pass it to API calls. -#define VK_VERSION_1_3 1 -// Vulkan 1.3 version number -#define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0)// Patch version should always be set to 0 - -typedef uint64_t VkFlags64; -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlot) - -typedef enum VkToolPurposeFlagBits { - VK_TOOL_PURPOSE_VALIDATION_BIT = 0x00000001, - VK_TOOL_PURPOSE_PROFILING_BIT = 0x00000002, - VK_TOOL_PURPOSE_TRACING_BIT = 0x00000004, - VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT = 0x00000008, - VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT = 0x00000010, - VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020, - VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040, - VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = VK_TOOL_PURPOSE_VALIDATION_BIT, - VK_TOOL_PURPOSE_PROFILING_BIT_EXT = VK_TOOL_PURPOSE_PROFILING_BIT, - VK_TOOL_PURPOSE_TRACING_BIT_EXT = VK_TOOL_PURPOSE_TRACING_BIT, - VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, - VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT, - VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkToolPurposeFlagBits; -typedef VkFlags VkToolPurposeFlags; -typedef VkFlags VkPrivateDataSlotCreateFlags; -typedef VkFlags64 VkPipelineStageFlags2; - -// Flag bits for VkPipelineStageFlagBits2 -typedef VkFlags64 VkPipelineStageFlagBits2; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE = 0ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 0x00000001ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 0x00000002ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 0x00000004ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 0x00000008ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 0x00000040ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 0x00000080ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 0x00000100ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 0x00000200ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 0x00000800ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 0x00001000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT = 0x00001000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 0x00002000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT = 0x00004000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 0x00008000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 0x00010000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT = 0x100000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT = 0x200000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT = 0x400000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT = 0x800000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 0x1000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 0x2000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT = 0x00020000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 0x00080000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT = 0x00100000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI = 0x8000000000ULL; -// VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI is a legacy alias -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR = 0x10000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 0x40000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0x20000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0x20000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV = 0x100000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM = 0x40000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR = 0x400000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT = 0x200000000000ULL; - -typedef VkFlags64 VkAccessFlags2; - -// Flag bits for VkAccessFlagBits2 -typedef VkFlags64 VkAccessFlagBits2; -static const VkAccessFlagBits2 VK_ACCESS_2_NONE = 0ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 0x00000001ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT = 0x00000002ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT = 0x00000008ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 0x00000010ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT = 0x00000020ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT = 0x00000040ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 0x00000080ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT = 0x00000800ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT = 0x00001000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT = 0x00002000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT = 0x00004000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT = 0x00008000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT = 0x00010000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 0x100000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 0x200000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x400000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT = 0x200000000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT = 0x400000000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM = 0x8000000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM = 0x10000000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_NONE_KHR = 0ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT = 0x00020000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT = 0x00040000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT = 0x20000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 0x10000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0x100000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 0x200000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0x40000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0x80000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM = 0x800000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM = 0x1000000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT = 0x80000000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT = 0x100000000000000ULL; - - -typedef enum VkSubmitFlagBits { - VK_SUBMIT_PROTECTED_BIT = 0x00000001, - VK_SUBMIT_PROTECTED_BIT_KHR = VK_SUBMIT_PROTECTED_BIT, - VK_SUBMIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSubmitFlagBits; -typedef VkFlags VkSubmitFlags; -typedef VkFlags64 VkFormatFeatureFlags2; - -// Flag bits for VkFormatFeatureFlagBits2 -typedef VkFlags64 VkFormatFeatureFlagBits2; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 0x00000001ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 0x00000002ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 0x00000010ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 0x00000040ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 0x00000080ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 0x00000400ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 0x00000800ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 0x00004000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 0x00008000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT = 0x00400000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 0x00800000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 0x80000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 0x100000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 0x200000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 0x00002000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT = 0x400000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000010ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 0x00000020ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 0x00000040ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000080ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 0x00000100ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000200ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 0x00000400ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 0x00000800ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 0x00001000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 0x00004000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 0x00008000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 0x00400000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 0x80000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 0x100000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV = 0x8000000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0x400000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0x800000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 0x1000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 0x2000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM = 0x8000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM = 0x80000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0x10000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM = 0x1000000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR = 0x800000000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x2000000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x4000000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 0x10000000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 0x20000000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR = 0x40000000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR = 0x80000000000000ULL; - - -typedef enum VkPipelineCreationFeedbackFlagBits { - VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0x00000001, - VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0x00000002, - VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0x00000004, - VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, - VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, - VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT, - VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCreationFeedbackFlagBits; -typedef VkFlags VkPipelineCreationFeedbackFlags; - -typedef enum VkRenderingFlagBits { - VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0x00000001, - VK_RENDERING_SUSPENDING_BIT = 0x00000002, - VK_RENDERING_RESUMING_BIT = 0x00000004, - VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008, - VK_RENDERING_CONTENTS_INLINE_BIT_KHR = 0x00000010, - VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x00000020, - VK_RENDERING_FRAGMENT_REGION_BIT_EXT = 0x00000040, - VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT = 0x00000080, - VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR = 0x00000100, - VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, - VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT, - VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT, - VK_RENDERING_CONTENTS_INLINE_BIT_EXT = VK_RENDERING_CONTENTS_INLINE_BIT_KHR, - VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkRenderingFlagBits; -typedef VkFlags VkRenderingFlags; -typedef struct VkPhysicalDeviceVulkan13Features { - VkStructureType sType; - void* pNext; - VkBool32 robustImageAccess; - VkBool32 inlineUniformBlock; - VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; - VkBool32 pipelineCreationCacheControl; - VkBool32 privateData; - VkBool32 shaderDemoteToHelperInvocation; - VkBool32 shaderTerminateInvocation; - VkBool32 subgroupSizeControl; - VkBool32 computeFullSubgroups; - VkBool32 synchronization2; - VkBool32 textureCompressionASTC_HDR; - VkBool32 shaderZeroInitializeWorkgroupMemory; - VkBool32 dynamicRendering; - VkBool32 shaderIntegerDotProduct; - VkBool32 maintenance4; -} VkPhysicalDeviceVulkan13Features; - -typedef struct VkPhysicalDeviceVulkan13Properties { - VkStructureType sType; - void* pNext; - uint32_t minSubgroupSize; - uint32_t maxSubgroupSize; - uint32_t maxComputeWorkgroupSubgroups; - VkShaderStageFlags requiredSubgroupSizeStages; - uint32_t maxInlineUniformBlockSize; - uint32_t maxPerStageDescriptorInlineUniformBlocks; - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; - uint32_t maxDescriptorSetInlineUniformBlocks; - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; - uint32_t maxInlineUniformTotalSize; - VkBool32 integerDotProduct8BitUnsignedAccelerated; - VkBool32 integerDotProduct8BitSignedAccelerated; - VkBool32 integerDotProduct8BitMixedSignednessAccelerated; - VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProduct16BitUnsignedAccelerated; - VkBool32 integerDotProduct16BitSignedAccelerated; - VkBool32 integerDotProduct16BitMixedSignednessAccelerated; - VkBool32 integerDotProduct32BitUnsignedAccelerated; - VkBool32 integerDotProduct32BitSignedAccelerated; - VkBool32 integerDotProduct32BitMixedSignednessAccelerated; - VkBool32 integerDotProduct64BitUnsignedAccelerated; - VkBool32 integerDotProduct64BitSignedAccelerated; - VkBool32 integerDotProduct64BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; - VkDeviceSize storageTexelBufferOffsetAlignmentBytes; - VkBool32 storageTexelBufferOffsetSingleTexelAlignment; - VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; - VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; - VkDeviceSize maxBufferSize; -} VkPhysicalDeviceVulkan13Properties; - -typedef struct VkPhysicalDeviceToolProperties { - VkStructureType sType; - void* pNext; - char name[VK_MAX_EXTENSION_NAME_SIZE]; - char version[VK_MAX_EXTENSION_NAME_SIZE]; - VkToolPurposeFlags purposes; - char description[VK_MAX_DESCRIPTION_SIZE]; - char layer[VK_MAX_EXTENSION_NAME_SIZE]; -} VkPhysicalDeviceToolProperties; - -typedef struct VkPhysicalDevicePrivateDataFeatures { - VkStructureType sType; - void* pNext; - VkBool32 privateData; -} VkPhysicalDevicePrivateDataFeatures; - -typedef struct VkDevicePrivateDataCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t privateDataSlotRequestCount; -} VkDevicePrivateDataCreateInfo; - -typedef struct VkPrivateDataSlotCreateInfo { - VkStructureType sType; - const void* pNext; - VkPrivateDataSlotCreateFlags flags; -} VkPrivateDataSlotCreateInfo; - -typedef struct VkMemoryBarrier2 { - VkStructureType sType; - const void* pNext; - VkPipelineStageFlags2 srcStageMask; - VkAccessFlags2 srcAccessMask; - VkPipelineStageFlags2 dstStageMask; - VkAccessFlags2 dstAccessMask; -} VkMemoryBarrier2; - -typedef struct VkBufferMemoryBarrier2 { - VkStructureType sType; - const void* pNext; - VkPipelineStageFlags2 srcStageMask; - VkAccessFlags2 srcAccessMask; - VkPipelineStageFlags2 dstStageMask; - VkAccessFlags2 dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; -} VkBufferMemoryBarrier2; - -typedef struct VkImageMemoryBarrier2 { - VkStructureType sType; - const void* pNext; - VkPipelineStageFlags2 srcStageMask; - VkAccessFlags2 srcAccessMask; - VkPipelineStageFlags2 dstStageMask; - VkAccessFlags2 dstAccessMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkImage image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier2; - -typedef struct VkDependencyInfo { - VkStructureType sType; - const void* pNext; - VkDependencyFlags dependencyFlags; - uint32_t memoryBarrierCount; - const VkMemoryBarrier2* pMemoryBarriers; - uint32_t bufferMemoryBarrierCount; - const VkBufferMemoryBarrier2* pBufferMemoryBarriers; - uint32_t imageMemoryBarrierCount; - const VkImageMemoryBarrier2* pImageMemoryBarriers; -} VkDependencyInfo; - -typedef struct VkSemaphoreSubmitInfo { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - uint64_t value; - VkPipelineStageFlags2 stageMask; - uint32_t deviceIndex; -} VkSemaphoreSubmitInfo; - -typedef struct VkCommandBufferSubmitInfo { - VkStructureType sType; - const void* pNext; - VkCommandBuffer commandBuffer; - uint32_t deviceMask; -} VkCommandBufferSubmitInfo; - -typedef struct VkSubmitInfo2 { - VkStructureType sType; - const void* pNext; - VkSubmitFlags flags; - uint32_t waitSemaphoreInfoCount; - const VkSemaphoreSubmitInfo* pWaitSemaphoreInfos; - uint32_t commandBufferInfoCount; - const VkCommandBufferSubmitInfo* pCommandBufferInfos; - uint32_t signalSemaphoreInfoCount; - const VkSemaphoreSubmitInfo* pSignalSemaphoreInfos; -} VkSubmitInfo2; - -typedef struct VkPhysicalDeviceSynchronization2Features { - VkStructureType sType; - void* pNext; - VkBool32 synchronization2; -} VkPhysicalDeviceSynchronization2Features; - -typedef struct VkBufferCopy2 { - VkStructureType sType; - const void* pNext; - VkDeviceSize srcOffset; - VkDeviceSize dstOffset; - VkDeviceSize size; -} VkBufferCopy2; - -typedef struct VkCopyBufferInfo2 { - VkStructureType sType; - const void* pNext; - VkBuffer srcBuffer; - VkBuffer dstBuffer; - uint32_t regionCount; - const VkBufferCopy2* pRegions; -} VkCopyBufferInfo2; - -typedef struct VkImageCopy2 { - VkStructureType sType; - const void* pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageCopy2; - -typedef struct VkCopyImageInfo2 { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageCopy2* pRegions; -} VkCopyImageInfo2; - -typedef struct VkBufferImageCopy2 { - VkStructureType sType; - const void* pNext; - VkDeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy2; - -typedef struct VkCopyBufferToImageInfo2 { - VkStructureType sType; - const void* pNext; - VkBuffer srcBuffer; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkBufferImageCopy2* pRegions; -} VkCopyBufferToImageInfo2; - -typedef struct VkCopyImageToBufferInfo2 { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkBuffer dstBuffer; - uint32_t regionCount; - const VkBufferImageCopy2* pRegions; -} VkCopyImageToBufferInfo2; - -typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures { - VkStructureType sType; - void* pNext; - VkBool32 textureCompressionASTC_HDR; -} VkPhysicalDeviceTextureCompressionASTCHDRFeatures; - -typedef struct VkFormatProperties3 { - VkStructureType sType; - void* pNext; - VkFormatFeatureFlags2 linearTilingFeatures; - VkFormatFeatureFlags2 optimalTilingFeatures; - VkFormatFeatureFlags2 bufferFeatures; -} VkFormatProperties3; - -typedef struct VkPhysicalDeviceMaintenance4Features { - VkStructureType sType; - void* pNext; - VkBool32 maintenance4; -} VkPhysicalDeviceMaintenance4Features; - -typedef struct VkPhysicalDeviceMaintenance4Properties { - VkStructureType sType; - void* pNext; - VkDeviceSize maxBufferSize; -} VkPhysicalDeviceMaintenance4Properties; - -typedef struct VkDeviceBufferMemoryRequirements { - VkStructureType sType; - const void* pNext; - const VkBufferCreateInfo* pCreateInfo; -} VkDeviceBufferMemoryRequirements; - -typedef struct VkDeviceImageMemoryRequirements { - VkStructureType sType; - const void* pNext; - const VkImageCreateInfo* pCreateInfo; - VkImageAspectFlagBits planeAspect; -} VkDeviceImageMemoryRequirements; - -typedef struct VkPipelineCreationFeedback { - VkPipelineCreationFeedbackFlags flags; - uint64_t duration; -} VkPipelineCreationFeedback; - -typedef struct VkPipelineCreationFeedbackCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreationFeedback* pPipelineCreationFeedback; - uint32_t pipelineStageCreationFeedbackCount; - VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks; -} VkPipelineCreationFeedbackCreateInfo; - -typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderTerminateInvocation; -} VkPhysicalDeviceShaderTerminateInvocationFeatures; - -typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderDemoteToHelperInvocation; -} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures; - -typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures { - VkStructureType sType; - void* pNext; - VkBool32 pipelineCreationCacheControl; -} VkPhysicalDevicePipelineCreationCacheControlFeatures; - -typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderZeroInitializeWorkgroupMemory; -} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - -typedef struct VkPhysicalDeviceImageRobustnessFeatures { - VkStructureType sType; - void* pNext; - VkBool32 robustImageAccess; -} VkPhysicalDeviceImageRobustnessFeatures; - -typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures { - VkStructureType sType; - void* pNext; - VkBool32 subgroupSizeControl; - VkBool32 computeFullSubgroups; -} VkPhysicalDeviceSubgroupSizeControlFeatures; - -typedef struct VkPhysicalDeviceSubgroupSizeControlProperties { - VkStructureType sType; - void* pNext; - uint32_t minSubgroupSize; - uint32_t maxSubgroupSize; - uint32_t maxComputeWorkgroupSubgroups; - VkShaderStageFlags requiredSubgroupSizeStages; -} VkPhysicalDeviceSubgroupSizeControlProperties; - -typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t requiredSubgroupSize; -} VkPipelineShaderStageRequiredSubgroupSizeCreateInfo; - -typedef struct VkPhysicalDeviceInlineUniformBlockFeatures { - VkStructureType sType; - void* pNext; - VkBool32 inlineUniformBlock; - VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; -} VkPhysicalDeviceInlineUniformBlockFeatures; - -typedef struct VkPhysicalDeviceInlineUniformBlockProperties { - VkStructureType sType; - void* pNext; - uint32_t maxInlineUniformBlockSize; - uint32_t maxPerStageDescriptorInlineUniformBlocks; - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; - uint32_t maxDescriptorSetInlineUniformBlocks; - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; -} VkPhysicalDeviceInlineUniformBlockProperties; - -typedef struct VkWriteDescriptorSetInlineUniformBlock { - VkStructureType sType; - const void* pNext; - uint32_t dataSize; - const void* pData; -} VkWriteDescriptorSetInlineUniformBlock; - -typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t maxInlineUniformBlockBindings; -} VkDescriptorPoolInlineUniformBlockCreateInfo; - -typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderIntegerDotProduct; -} VkPhysicalDeviceShaderIntegerDotProductFeatures; - -typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties { - VkStructureType sType; - void* pNext; - VkBool32 integerDotProduct8BitUnsignedAccelerated; - VkBool32 integerDotProduct8BitSignedAccelerated; - VkBool32 integerDotProduct8BitMixedSignednessAccelerated; - VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProduct16BitUnsignedAccelerated; - VkBool32 integerDotProduct16BitSignedAccelerated; - VkBool32 integerDotProduct16BitMixedSignednessAccelerated; - VkBool32 integerDotProduct32BitUnsignedAccelerated; - VkBool32 integerDotProduct32BitSignedAccelerated; - VkBool32 integerDotProduct32BitMixedSignednessAccelerated; - VkBool32 integerDotProduct64BitUnsignedAccelerated; - VkBool32 integerDotProduct64BitSignedAccelerated; - VkBool32 integerDotProduct64BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; -} VkPhysicalDeviceShaderIntegerDotProductProperties; - -typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties { - VkStructureType sType; - void* pNext; - VkDeviceSize storageTexelBufferOffsetAlignmentBytes; - VkBool32 storageTexelBufferOffsetSingleTexelAlignment; - VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; - VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; -} VkPhysicalDeviceTexelBufferAlignmentProperties; - -typedef struct VkImageBlit2 { - VkStructureType sType; - const void* pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffsets[2]; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffsets[2]; -} VkImageBlit2; - -typedef struct VkBlitImageInfo2 { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageBlit2* pRegions; - VkFilter filter; -} VkBlitImageInfo2; - -typedef struct VkImageResolve2 { - VkStructureType sType; - const void* pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageResolve2; - -typedef struct VkResolveImageInfo2 { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageResolve2* pRegions; -} VkResolveImageInfo2; - -typedef struct VkRenderingAttachmentInfo { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkImageLayout imageLayout; - VkResolveModeFlagBits resolveMode; - VkImageView resolveImageView; - VkImageLayout resolveImageLayout; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkClearValue clearValue; -} VkRenderingAttachmentInfo; - -typedef struct VkRenderingInfo { - VkStructureType sType; - const void* pNext; - VkRenderingFlags flags; - VkRect2D renderArea; - uint32_t layerCount; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkRenderingAttachmentInfo* pColorAttachments; - const VkRenderingAttachmentInfo* pDepthAttachment; - const VkRenderingAttachmentInfo* pStencilAttachment; -} VkRenderingInfo; - -typedef struct VkPipelineRenderingCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; -} VkPipelineRenderingCreateInfo; - -typedef struct VkPhysicalDeviceDynamicRenderingFeatures { - VkStructureType sType; - void* pNext; - VkBool32 dynamicRendering; -} VkPhysicalDeviceDynamicRenderingFeatures; - -typedef struct VkCommandBufferInheritanceRenderingInfo { - VkStructureType sType; - const void* pNext; - VkRenderingFlags flags; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; - VkSampleCountFlagBits rasterizationSamples; -} VkCommandBufferInheritanceRenderingInfo; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); -typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); -typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); -typedef void (VKAPI_PTR *PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); -typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); -typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); -typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); -typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); -typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); -typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); -typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer); -typedef void (VKAPI_PTR *PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); -typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); -typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); -typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCount)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); -typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCount)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); -typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); -typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pToolCount, - VkPhysicalDeviceToolProperties* pToolProperties); - -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlot( - VkDevice device, - const VkPrivateDataSlotCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPrivateDataSlot* pPrivateDataSlot); - -VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlot( - VkDevice device, - VkPrivateDataSlot privateDataSlot, - const VkAllocationCallbacks* pAllocator); - -VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateData( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t data); - -VKAPI_ATTR void VKAPI_CALL vkGetPrivateData( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t* pData); - -VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2( - VkCommandBuffer commandBuffer, - const VkDependencyInfo* pDependencyInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkQueryPool queryPool, - uint32_t query); - -VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo2* pSubmits, - VkFence fence); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2( - VkCommandBuffer commandBuffer, - const VkCopyBufferInfo2* pCopyBufferInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2( - VkCommandBuffer commandBuffer, - const VkCopyImageInfo2* pCopyImageInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2( - VkCommandBuffer commandBuffer, - const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2( - VkCommandBuffer commandBuffer, - const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements( - VkDevice device, - const VkDeviceBufferMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2( - VkCommandBuffer commandBuffer, - VkEvent event, - const VkDependencyInfo* pDependencyInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags2 stageMask); - -VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - const VkDependencyInfo* pDependencyInfos); - -VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2( - VkCommandBuffer commandBuffer, - const VkBlitImageInfo2* pBlitImageInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2( - VkCommandBuffer commandBuffer, - const VkResolveImageInfo2* pResolveImageInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdBeginRendering( - VkCommandBuffer commandBuffer, - const VkRenderingInfo* pRenderingInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering( - VkCommandBuffer commandBuffer); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetCullMode( - VkCommandBuffer commandBuffer, - VkCullModeFlags cullMode); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFace( - VkCommandBuffer commandBuffer, - VkFrontFace frontFace); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopology( - VkCommandBuffer commandBuffer, - VkPrimitiveTopology primitiveTopology); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCount( - VkCommandBuffer commandBuffer, - uint32_t viewportCount, - const VkViewport* pViewports); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCount( - VkCommandBuffer commandBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes, - const VkDeviceSize* pStrides); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthTestEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthWriteEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOp( - VkCommandBuffer commandBuffer, - VkCompareOp depthCompareOp); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthBoundsTestEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 stencilTestEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOp( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnable( - VkCommandBuffer commandBuffer, - VkBool32 rasterizerDiscardEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthBiasEnable); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnable( - VkCommandBuffer commandBuffer, - VkBool32 primitiveRestartEnable); -#endif - - -// VK_VERSION_1_4 is a preprocessor guard. Do not pass it to API calls. -#define VK_VERSION_1_4 1 -// Vulkan 1.4 version number -#define VK_API_VERSION_1_4 VK_MAKE_API_VERSION(0, 1, 4, 0)// Patch version should always be set to 0 - -#define VK_MAX_GLOBAL_PRIORITY_SIZE 16U - -typedef enum VkPipelineRobustnessBufferBehavior { - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT = 0, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED = 1, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS = 2, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 = 3, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF -} VkPipelineRobustnessBufferBehavior; - -typedef enum VkPipelineRobustnessImageBehavior { - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT = 0, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED = 1, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS = 2, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2 = 3, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF -} VkPipelineRobustnessImageBehavior; - -typedef enum VkQueueGlobalPriority { - VK_QUEUE_GLOBAL_PRIORITY_LOW = 128, - VK_QUEUE_GLOBAL_PRIORITY_MEDIUM = 256, - VK_QUEUE_GLOBAL_PRIORITY_HIGH = 512, - VK_QUEUE_GLOBAL_PRIORITY_REALTIME = 1024, - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW, - VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, - VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = VK_QUEUE_GLOBAL_PRIORITY_HIGH, - VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, - VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR = VK_QUEUE_GLOBAL_PRIORITY_LOW, - VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, - VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = VK_QUEUE_GLOBAL_PRIORITY_HIGH, - VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, - VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM = 0x7FFFFFFF -} VkQueueGlobalPriority; - -typedef enum VkLineRasterizationMode { - VK_LINE_RASTERIZATION_MODE_DEFAULT = 0, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR = 1, - VK_LINE_RASTERIZATION_MODE_BRESENHAM = 2, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH = 3, - VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = VK_LINE_RASTERIZATION_MODE_DEFAULT, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, - VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = VK_LINE_RASTERIZATION_MODE_BRESENHAM, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, - VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR = VK_LINE_RASTERIZATION_MODE_DEFAULT, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, - VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR = VK_LINE_RASTERIZATION_MODE_BRESENHAM, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, - VK_LINE_RASTERIZATION_MODE_MAX_ENUM = 0x7FFFFFFF -} VkLineRasterizationMode; - -typedef enum VkMemoryUnmapFlagBits { - VK_MEMORY_UNMAP_RESERVE_BIT_EXT = 0x00000001, - VK_MEMORY_UNMAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryUnmapFlagBits; -typedef VkFlags VkMemoryUnmapFlags; -typedef VkFlags64 VkBufferUsageFlags2; - -// Flag bits for VkBufferUsageFlagBits2 -typedef VkFlags64 VkBufferUsageFlagBits2; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT = 0x00000001ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_DST_BIT = 0x00000002ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT = 0x00000008ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT = 0x00000010ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT = 0x00000020ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT = 0x00000040ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT = 0x00000080ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT = 0x00000100ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT = 0x00020000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX = 0x02000000ULL; -#endif -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT = 0x10000000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR = 0x00000001ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR = 0x00000002ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000004ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR = 0x00000010ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR = 0x00000020ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR = 0x00000040ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR = 0x00000080ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR = 0x00000100ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV = 0x00000400ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR = 0x00004000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX = 0x200000000ULL; -#endif -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM = 0x20000000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM = 0x08000000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT = 0x100000000ULL; -static const VkBufferUsageFlagBits2 VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT = 0x80000000ULL; - - -typedef enum VkHostImageCopyFlagBits { - VK_HOST_IMAGE_COPY_MEMCPY_BIT = 0x00000001, - // VK_HOST_IMAGE_COPY_MEMCPY is a legacy alias - VK_HOST_IMAGE_COPY_MEMCPY = VK_HOST_IMAGE_COPY_MEMCPY_BIT, - VK_HOST_IMAGE_COPY_MEMCPY_BIT_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT, - // VK_HOST_IMAGE_COPY_MEMCPY_EXT is a legacy alias - VK_HOST_IMAGE_COPY_MEMCPY_EXT = VK_HOST_IMAGE_COPY_MEMCPY_BIT, - VK_HOST_IMAGE_COPY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkHostImageCopyFlagBits; -typedef VkFlags VkHostImageCopyFlags; -typedef VkFlags64 VkPipelineCreateFlags2; - -// Flag bits for VkPipelineCreateFlagBits2 -typedef VkFlags64 VkPipelineCreateFlagBits2; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT = 0x00000001ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT = 0x00000002ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DERIVATIVE_BIT = 0x00000004ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT = 0x00000010ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT = 0x08000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT = 0x40000000ULL; -#ifdef VK_ENABLE_BETA_EXTENSIONS -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX = 0x100000000ULL; -#endif -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT = 0x1000000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR = 0x00001000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV = 0x200000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x400000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = 0x00000002ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR = 0x00000004ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR = 0x00000010ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV = 0x00000020ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR = 0x00000040ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR = 0x00000100ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR = 0x00000200ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR = 0x00000800ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV = 0x00040000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM = 0x2000000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR = 0x80000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT = 0x4000000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE = 0x10000000000ULL; -static const VkPipelineCreateFlagBits2 VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT = 0x80000000000ULL; - -typedef struct VkPhysicalDeviceVulkan14Features { - VkStructureType sType; - void* pNext; - VkBool32 globalPriorityQuery; - VkBool32 shaderSubgroupRotate; - VkBool32 shaderSubgroupRotateClustered; - VkBool32 shaderFloatControls2; - VkBool32 shaderExpectAssume; - VkBool32 rectangularLines; - VkBool32 bresenhamLines; - VkBool32 smoothLines; - VkBool32 stippledRectangularLines; - VkBool32 stippledBresenhamLines; - VkBool32 stippledSmoothLines; - VkBool32 vertexAttributeInstanceRateDivisor; - VkBool32 vertexAttributeInstanceRateZeroDivisor; - VkBool32 indexTypeUint8; - VkBool32 dynamicRenderingLocalRead; - VkBool32 maintenance5; - VkBool32 maintenance6; - VkBool32 pipelineProtectedAccess; - VkBool32 pipelineRobustness; - VkBool32 hostImageCopy; - VkBool32 pushDescriptor; -} VkPhysicalDeviceVulkan14Features; - -typedef struct VkPhysicalDeviceVulkan14Properties { - VkStructureType sType; - void* pNext; - uint32_t lineSubPixelPrecisionBits; - uint32_t maxVertexAttribDivisor; - VkBool32 supportsNonZeroFirstInstance; - uint32_t maxPushDescriptors; - VkBool32 dynamicRenderingLocalReadDepthStencilAttachments; - VkBool32 dynamicRenderingLocalReadMultisampledAttachments; - VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; - VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; - VkBool32 depthStencilSwizzleOneSupport; - VkBool32 polygonModePointSize; - VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; - VkBool32 nonStrictWideLinesUseParallelogram; - VkBool32 blockTexelViewCompatibleMultipleLayers; - uint32_t maxCombinedImageSamplerDescriptorCount; - VkBool32 fragmentShadingRateClampCombinerInputs; - VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers; - VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers; - VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs; - VkPipelineRobustnessImageBehavior defaultRobustnessImages; - uint32_t copySrcLayoutCount; - VkImageLayout* pCopySrcLayouts; - uint32_t copyDstLayoutCount; - VkImageLayout* pCopyDstLayouts; - uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; - VkBool32 identicalMemoryTypeRequirements; -} VkPhysicalDeviceVulkan14Properties; - -typedef struct VkDeviceQueueGlobalPriorityCreateInfo { - VkStructureType sType; - const void* pNext; - VkQueueGlobalPriority globalPriority; -} VkDeviceQueueGlobalPriorityCreateInfo; - -typedef struct VkPhysicalDeviceGlobalPriorityQueryFeatures { - VkStructureType sType; - void* pNext; - VkBool32 globalPriorityQuery; -} VkPhysicalDeviceGlobalPriorityQueryFeatures; - -typedef struct VkQueueFamilyGlobalPriorityProperties { - VkStructureType sType; - void* pNext; - uint32_t priorityCount; - VkQueueGlobalPriority priorities[VK_MAX_GLOBAL_PRIORITY_SIZE]; -} VkQueueFamilyGlobalPriorityProperties; - -typedef struct VkPhysicalDeviceIndexTypeUint8Features { - VkStructureType sType; - void* pNext; - VkBool32 indexTypeUint8; -} VkPhysicalDeviceIndexTypeUint8Features; - -typedef struct VkMemoryMapInfo { - VkStructureType sType; - const void* pNext; - VkMemoryMapFlags flags; - VkDeviceMemory memory; - VkDeviceSize offset; - VkDeviceSize size; -} VkMemoryMapInfo; - -typedef struct VkMemoryUnmapInfo { - VkStructureType sType; - const void* pNext; - VkMemoryUnmapFlags flags; - VkDeviceMemory memory; -} VkMemoryUnmapInfo; - -typedef struct VkPhysicalDeviceMaintenance5Features { - VkStructureType sType; - void* pNext; - VkBool32 maintenance5; -} VkPhysicalDeviceMaintenance5Features; - -typedef struct VkPhysicalDeviceMaintenance5Properties { - VkStructureType sType; - void* pNext; - VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; - VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; - VkBool32 depthStencilSwizzleOneSupport; - VkBool32 polygonModePointSize; - VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; - VkBool32 nonStrictWideLinesUseParallelogram; -} VkPhysicalDeviceMaintenance5Properties; - -typedef struct VkImageSubresource2 { - VkStructureType sType; - void* pNext; - VkImageSubresource imageSubresource; -} VkImageSubresource2; - -typedef struct VkDeviceImageSubresourceInfo { - VkStructureType sType; - const void* pNext; - const VkImageCreateInfo* pCreateInfo; - const VkImageSubresource2* pSubresource; -} VkDeviceImageSubresourceInfo; - -typedef struct VkSubresourceLayout2 { - VkStructureType sType; - void* pNext; - VkSubresourceLayout subresourceLayout; -} VkSubresourceLayout2; - -typedef struct VkBufferUsageFlags2CreateInfo { - VkStructureType sType; - const void* pNext; - VkBufferUsageFlags2 usage; -} VkBufferUsageFlags2CreateInfo; - -typedef struct VkPhysicalDeviceMaintenance6Features { - VkStructureType sType; - void* pNext; - VkBool32 maintenance6; -} VkPhysicalDeviceMaintenance6Features; - -typedef struct VkPhysicalDeviceMaintenance6Properties { - VkStructureType sType; - void* pNext; - VkBool32 blockTexelViewCompatibleMultipleLayers; - uint32_t maxCombinedImageSamplerDescriptorCount; - VkBool32 fragmentShadingRateClampCombinerInputs; -} VkPhysicalDeviceMaintenance6Properties; - -typedef struct VkBindMemoryStatus { - VkStructureType sType; - const void* pNext; - VkResult* pResult; -} VkBindMemoryStatus; - -typedef struct VkPhysicalDeviceHostImageCopyFeatures { - VkStructureType sType; - void* pNext; - VkBool32 hostImageCopy; -} VkPhysicalDeviceHostImageCopyFeatures; - -typedef struct VkPhysicalDeviceHostImageCopyProperties { - VkStructureType sType; - void* pNext; - uint32_t copySrcLayoutCount; - VkImageLayout* pCopySrcLayouts; - uint32_t copyDstLayoutCount; - VkImageLayout* pCopyDstLayouts; - uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; - VkBool32 identicalMemoryTypeRequirements; -} VkPhysicalDeviceHostImageCopyProperties; - -typedef struct VkMemoryToImageCopy { - VkStructureType sType; - const void* pNext; - const void* pHostPointer; - uint32_t memoryRowLength; - uint32_t memoryImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkMemoryToImageCopy; - -typedef struct VkImageToMemoryCopy { - VkStructureType sType; - const void* pNext; - void* pHostPointer; - uint32_t memoryRowLength; - uint32_t memoryImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkImageToMemoryCopy; - -typedef struct VkCopyMemoryToImageInfo { - VkStructureType sType; - const void* pNext; - VkHostImageCopyFlags flags; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkMemoryToImageCopy* pRegions; -} VkCopyMemoryToImageInfo; - -typedef struct VkCopyImageToMemoryInfo { - VkStructureType sType; - const void* pNext; - VkHostImageCopyFlags flags; - VkImage srcImage; - VkImageLayout srcImageLayout; - uint32_t regionCount; - const VkImageToMemoryCopy* pRegions; -} VkCopyImageToMemoryInfo; - -typedef struct VkCopyImageToImageInfo { - VkStructureType sType; - const void* pNext; - VkHostImageCopyFlags flags; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageCopy2* pRegions; -} VkCopyImageToImageInfo; - -typedef struct VkHostImageLayoutTransitionInfo { - VkStructureType sType; - const void* pNext; - VkImage image; - VkImageLayout oldLayout; - VkImageLayout newLayout; - VkImageSubresourceRange subresourceRange; -} VkHostImageLayoutTransitionInfo; - -typedef struct VkSubresourceHostMemcpySize { - VkStructureType sType; - void* pNext; - VkDeviceSize size; -} VkSubresourceHostMemcpySize; - -typedef struct VkHostImageCopyDevicePerformanceQuery { - VkStructureType sType; - void* pNext; - VkBool32 optimalDeviceAccess; - VkBool32 identicalMemoryLayout; -} VkHostImageCopyDevicePerformanceQuery; - -typedef struct VkPhysicalDeviceShaderSubgroupRotateFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderSubgroupRotate; - VkBool32 shaderSubgroupRotateClustered; -} VkPhysicalDeviceShaderSubgroupRotateFeatures; - -typedef struct VkPhysicalDeviceShaderFloatControls2Features { - VkStructureType sType; - void* pNext; - VkBool32 shaderFloatControls2; -} VkPhysicalDeviceShaderFloatControls2Features; - -typedef struct VkPhysicalDeviceShaderExpectAssumeFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderExpectAssume; -} VkPhysicalDeviceShaderExpectAssumeFeatures; - -typedef struct VkPipelineCreateFlags2CreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags2 flags; -} VkPipelineCreateFlags2CreateInfo; - -typedef struct VkPhysicalDevicePushDescriptorProperties { - VkStructureType sType; - void* pNext; - uint32_t maxPushDescriptors; -} VkPhysicalDevicePushDescriptorProperties; - -typedef struct VkBindDescriptorSetsInfo { - VkStructureType sType; - const void* pNext; - VkShaderStageFlags stageFlags; - VkPipelineLayout layout; - uint32_t firstSet; - uint32_t descriptorSetCount; - const VkDescriptorSet* pDescriptorSets; - uint32_t dynamicOffsetCount; - const uint32_t* pDynamicOffsets; -} VkBindDescriptorSetsInfo; - -typedef struct VkPushConstantsInfo { - VkStructureType sType; - const void* pNext; - VkPipelineLayout layout; - VkShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; - const void* pValues; -} VkPushConstantsInfo; - -typedef struct VkPushDescriptorSetInfo { - VkStructureType sType; - const void* pNext; - VkShaderStageFlags stageFlags; - VkPipelineLayout layout; - uint32_t set; - uint32_t descriptorWriteCount; - const VkWriteDescriptorSet* pDescriptorWrites; -} VkPushDescriptorSetInfo; - -typedef struct VkPushDescriptorSetWithTemplateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorUpdateTemplate descriptorUpdateTemplate; - VkPipelineLayout layout; - uint32_t set; - const void* pData; -} VkPushDescriptorSetWithTemplateInfo; - -typedef struct VkPhysicalDevicePipelineProtectedAccessFeatures { - VkStructureType sType; - void* pNext; - VkBool32 pipelineProtectedAccess; -} VkPhysicalDevicePipelineProtectedAccessFeatures; - -typedef struct VkPhysicalDevicePipelineRobustnessFeatures { - VkStructureType sType; - void* pNext; - VkBool32 pipelineRobustness; -} VkPhysicalDevicePipelineRobustnessFeatures; - -typedef struct VkPhysicalDevicePipelineRobustnessProperties { - VkStructureType sType; - void* pNext; - VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers; - VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers; - VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs; - VkPipelineRobustnessImageBehavior defaultRobustnessImages; -} VkPhysicalDevicePipelineRobustnessProperties; - -typedef struct VkPipelineRobustnessCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineRobustnessBufferBehavior storageBuffers; - VkPipelineRobustnessBufferBehavior uniformBuffers; - VkPipelineRobustnessBufferBehavior vertexInputs; - VkPipelineRobustnessImageBehavior images; -} VkPipelineRobustnessCreateInfo; - -typedef struct VkPhysicalDeviceLineRasterizationFeatures { - VkStructureType sType; - void* pNext; - VkBool32 rectangularLines; - VkBool32 bresenhamLines; - VkBool32 smoothLines; - VkBool32 stippledRectangularLines; - VkBool32 stippledBresenhamLines; - VkBool32 stippledSmoothLines; -} VkPhysicalDeviceLineRasterizationFeatures; - -typedef struct VkPhysicalDeviceLineRasterizationProperties { - VkStructureType sType; - void* pNext; - uint32_t lineSubPixelPrecisionBits; -} VkPhysicalDeviceLineRasterizationProperties; - -typedef struct VkPipelineRasterizationLineStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkLineRasterizationMode lineRasterizationMode; - VkBool32 stippledLineEnable; - uint32_t lineStippleFactor; - uint16_t lineStipplePattern; -} VkPipelineRasterizationLineStateCreateInfo; - -typedef struct VkPhysicalDeviceVertexAttributeDivisorProperties { - VkStructureType sType; - void* pNext; - uint32_t maxVertexAttribDivisor; - VkBool32 supportsNonZeroFirstInstance; -} VkPhysicalDeviceVertexAttributeDivisorProperties; - -typedef struct VkVertexInputBindingDivisorDescription { - uint32_t binding; - uint32_t divisor; -} VkVertexInputBindingDivisorDescription; - -typedef struct VkPipelineVertexInputDivisorStateCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t vertexBindingDivisorCount; - const VkVertexInputBindingDivisorDescription* pVertexBindingDivisors; -} VkPipelineVertexInputDivisorStateCreateInfo; - -typedef struct VkPhysicalDeviceVertexAttributeDivisorFeatures { - VkStructureType sType; - void* pNext; - VkBool32 vertexAttributeInstanceRateDivisor; - VkBool32 vertexAttributeInstanceRateZeroDivisor; -} VkPhysicalDeviceVertexAttributeDivisorFeatures; - -typedef struct VkRenderingAreaInfo { - VkStructureType sType; - const void* pNext; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; -} VkRenderingAreaInfo; - -typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures { - VkStructureType sType; - void* pNext; - VkBool32 dynamicRenderingLocalRead; -} VkPhysicalDeviceDynamicRenderingLocalReadFeatures; - -typedef struct VkRenderingAttachmentLocationInfo { - VkStructureType sType; - const void* pNext; - uint32_t colorAttachmentCount; - const uint32_t* pColorAttachmentLocations; -} VkRenderingAttachmentLocationInfo; - -typedef struct VkRenderingInputAttachmentIndexInfo { - VkStructureType sType; - const void* pNext; - uint32_t colorAttachmentCount; - const uint32_t* pColorAttachmentInputIndices; - const uint32_t* pDepthInputAttachmentIndex; - const uint32_t* pStencilInputAttachmentIndex; -} VkRenderingInputAttachmentIndexInfo; - -typedef VkResult (VKAPI_PTR *PFN_vkMapMemory2)(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData); -typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2)(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo); -typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSubresourceLayout)(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout); -typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2)(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToImage)(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToMemory)(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToImage)(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo); -typedef VkResult (VKAPI_PTR *PFN_vkTransitionImageLayout)(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions); -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSet)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplate)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets2)(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); -typedef void (VKAPI_PTR *PFN_vkCmdPushConstants2)(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo); -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSet2)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplate2)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); -typedef void (VKAPI_PTR *PFN_vkCmdSetLineStipple)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); -typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer2)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType); -typedef void (VKAPI_PTR *PFN_vkGetRenderingAreaGranularity)(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity); -typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocations)(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo); -typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndices)(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); - -#ifndef VK_NO_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2( - VkDevice device, - const VkMemoryMapInfo* pMemoryMapInfo, - void** ppData); - -VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2( - VkDevice device, - const VkMemoryUnmapInfo* pMemoryUnmapInfo); - -VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayout( - VkDevice device, - const VkDeviceImageSubresourceInfo* pInfo, - VkSubresourceLayout2* pLayout); - -VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2( - VkDevice device, - VkImage image, - const VkImageSubresource2* pSubresource, - VkSubresourceLayout2* pLayout); - -VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImage( - VkDevice device, - const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemory( - VkDevice device, - const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImage( - VkDevice device, - const VkCopyImageToImageInfo* pCopyImageToImageInfo); - -VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayout( - VkDevice device, - uint32_t transitionCount, - const VkHostImageLayoutTransitionInfo* pTransitions); - -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites); - -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate( - VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout layout, - uint32_t set, - const void* pData); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2( - VkCommandBuffer commandBuffer, - const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2( - VkCommandBuffer commandBuffer, - const VkPushConstantsInfo* pPushConstantsInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStipple( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern); - -VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkDeviceSize size, - VkIndexType indexType); - -VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularity( - VkDevice device, - const VkRenderingAreaInfo* pRenderingAreaInfo, - VkExtent2D* pGranularity); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocations( - VkCommandBuffer commandBuffer, - const VkRenderingAttachmentLocationInfo* pLocationInfo); - -VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndices( - VkCommandBuffer commandBuffer, - const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); -#endif - - -// VK_KHR_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_surface 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR) -#define VK_KHR_SURFACE_SPEC_VERSION 25 -#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface" - -typedef enum VkPresentModeKHR { - VK_PRESENT_MODE_IMMEDIATE_KHR = 0, - VK_PRESENT_MODE_MAILBOX_KHR = 1, - VK_PRESENT_MODE_FIFO_KHR = 2, - VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, - VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, - VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, - VK_PRESENT_MODE_FIFO_LATEST_READY_KHR = 1000361000, - VK_PRESENT_MODE_FIFO_LATEST_READY_EXT = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR, - VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPresentModeKHR; - -typedef enum VkColorSpaceKHR { - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, - VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, - VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, - VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003, - VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, - VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, - VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, - VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, - VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, - // VK_COLOR_SPACE_DOLBYVISION_EXT is legacy, but no reason was given in the API XML - VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, - VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, - VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, - VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, - VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, - VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, - VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000, - // VK_COLORSPACE_SRGB_NONLINEAR_KHR is a legacy alias - VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - // VK_COLOR_SPACE_DCI_P3_LINEAR_EXT is a legacy alias - VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, - VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkColorSpaceKHR; - -typedef enum VkSurfaceTransformFlagBitsKHR { - VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, - VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, - VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, - VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, - VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, - VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkSurfaceTransformFlagBitsKHR; - -typedef enum VkCompositeAlphaFlagBitsKHR { - VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, - VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, - VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, - VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, - VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkCompositeAlphaFlagBitsKHR; -typedef VkFlags VkCompositeAlphaFlagsKHR; -typedef VkFlags VkSurfaceTransformFlagsKHR; -typedef struct VkSurfaceCapabilitiesKHR { - uint32_t minImageCount; - uint32_t maxImageCount; - VkExtent2D currentExtent; - VkExtent2D minImageExtent; - VkExtent2D maxImageExtent; - uint32_t maxImageArrayLayers; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkSurfaceTransformFlagBitsKHR currentTransform; - VkCompositeAlphaFlagsKHR supportedCompositeAlpha; - VkImageUsageFlags supportedUsageFlags; -} VkSurfaceCapabilitiesKHR; - -typedef struct VkSurfaceFormatKHR { - VkFormat format; - VkColorSpaceKHR colorSpace; -} VkSurfaceFormatKHR; - -typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( - VkInstance instance, - VkSurfaceKHR surface, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - VkSurfaceKHR surface, - VkBool32* pSupported); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormatKHR* pSurfaceFormats); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes); -#endif -#endif - - -// VK_KHR_swapchain is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_swapchain 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) -#define VK_KHR_SWAPCHAIN_SPEC_VERSION 70 -#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" - -typedef enum VkSwapchainCreateFlagBitsKHR { - VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, - VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, - VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, - VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT = 0x00000200, - VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR = 0x00000040, - VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR = 0x00000080, - VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR = 0x00000008, - VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, - VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkSwapchainCreateFlagBitsKHR; -typedef VkFlags VkSwapchainCreateFlagsKHR; - -typedef enum VkDeviceGroupPresentModeFlagBitsKHR { - VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, - VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, - VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, - VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, - VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkDeviceGroupPresentModeFlagBitsKHR; -typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; -typedef struct VkSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainCreateFlagsKHR flags; - VkSurfaceKHR surface; - uint32_t minImageCount; - VkFormat imageFormat; - VkColorSpaceKHR imageColorSpace; - VkExtent2D imageExtent; - uint32_t imageArrayLayers; - VkImageUsageFlags imageUsage; - VkSharingMode imageSharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - VkSurfaceTransformFlagBitsKHR preTransform; - VkCompositeAlphaFlagBitsKHR compositeAlpha; - VkPresentModeKHR presentMode; - VkBool32 clipped; - VkSwapchainKHR oldSwapchain; -} VkSwapchainCreateInfoKHR; - -typedef struct VkPresentInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - uint32_t swapchainCount; - const VkSwapchainKHR* pSwapchains; - const uint32_t* pImageIndices; - VkResult* pResults; -} VkPresentInfoKHR; - -typedef struct VkImageSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; -} VkImageSwapchainCreateInfoKHR; - -typedef struct VkBindImageMemorySwapchainInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - uint32_t imageIndex; -} VkBindImageMemorySwapchainInfoKHR; - -typedef struct VkAcquireNextImageInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - uint64_t timeout; - VkSemaphore semaphore; - VkFence fence; - uint32_t deviceMask; -} VkAcquireNextImageInfoKHR; - -typedef struct VkDeviceGroupPresentCapabilitiesKHR { - VkStructureType sType; - void* pNext; - uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; - VkDeviceGroupPresentModeFlagsKHR modes; -} VkDeviceGroupPresentCapabilitiesKHR; - -typedef struct VkDeviceGroupPresentInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const uint32_t* pDeviceMasks; - VkDeviceGroupPresentModeFlagBitsKHR mode; -} VkDeviceGroupPresentInfoKHR; - -typedef struct VkDeviceGroupSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceGroupPresentModeFlagsKHR modes; -} VkDeviceGroupSwapchainCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); -typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); -typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); -typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); -typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR( - VkDevice device, - const VkSwapchainCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchain); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR( - VkDevice device, - VkSwapchainKHR swapchain, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pSwapchainImageCount, - VkImage* pSwapchainImages); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t timeout, - VkSemaphore semaphore, - VkFence fence, - uint32_t* pImageIndex); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR( - VkQueue queue, - const VkPresentInfoKHR* pPresentInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR( - VkDevice device, - VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( - VkDevice device, - VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHR* pModes); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pRectCount, - VkRect2D* pRects); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR( - VkDevice device, - const VkAcquireNextImageInfoKHR* pAcquireInfo, - uint32_t* pImageIndex); -#endif -#endif - - -// VK_KHR_display is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_display 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR) -#define VK_KHR_DISPLAY_SPEC_VERSION 23 -#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display" -typedef VkFlags VkDisplayModeCreateFlagsKHR; - -typedef enum VkDisplayPlaneAlphaFlagBitsKHR { - VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, - VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, - VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkDisplayPlaneAlphaFlagBitsKHR; -typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; -typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; -typedef struct VkDisplayModeParametersKHR { - VkExtent2D visibleRegion; - uint32_t refreshRate; -} VkDisplayModeParametersKHR; - -typedef struct VkDisplayModeCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDisplayModeCreateFlagsKHR flags; - VkDisplayModeParametersKHR parameters; -} VkDisplayModeCreateInfoKHR; - -typedef struct VkDisplayModePropertiesKHR { - VkDisplayModeKHR displayMode; - VkDisplayModeParametersKHR parameters; -} VkDisplayModePropertiesKHR; - -typedef struct VkDisplayPlaneCapabilitiesKHR { - VkDisplayPlaneAlphaFlagsKHR supportedAlpha; - VkOffset2D minSrcPosition; - VkOffset2D maxSrcPosition; - VkExtent2D minSrcExtent; - VkExtent2D maxSrcExtent; - VkOffset2D minDstPosition; - VkOffset2D maxDstPosition; - VkExtent2D minDstExtent; - VkExtent2D maxDstExtent; -} VkDisplayPlaneCapabilitiesKHR; - -typedef struct VkDisplayPlanePropertiesKHR { - VkDisplayKHR currentDisplay; - uint32_t currentStackIndex; -} VkDisplayPlanePropertiesKHR; - -typedef struct VkDisplayPropertiesKHR { - VkDisplayKHR display; - const char* displayName; - VkExtent2D physicalDimensions; - VkExtent2D physicalResolution; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkBool32 planeReorderPossible; - VkBool32 persistentContent; -} VkDisplayPropertiesKHR; - -typedef struct VkDisplaySurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDisplaySurfaceCreateFlagsKHR flags; - VkDisplayModeKHR displayMode; - uint32_t planeIndex; - uint32_t planeStackIndex; - VkSurfaceTransformFlagBitsKHR transform; - float globalAlpha; - VkDisplayPlaneAlphaFlagBitsKHR alphaMode; - VkExtent2D imageExtent; -} VkDisplaySurfaceCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPropertiesKHR* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlanePropertiesKHR* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR( - VkPhysicalDevice physicalDevice, - uint32_t planeIndex, - uint32_t* pDisplayCount, - VkDisplayKHR* pDisplays); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModePropertiesKHR* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - const VkDisplayModeCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDisplayModeKHR* pMode); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayModeKHR mode, - uint32_t planeIndex, - VkDisplayPlaneCapabilitiesKHR* pCapabilities); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( - VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif -#endif - - -// VK_KHR_display_swapchain is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_display_swapchain 1 -#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10 -#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain" -typedef struct VkDisplayPresentInfoKHR { - VkStructureType sType; - const void* pNext; - VkRect2D srcRect; - VkRect2D dstRect; - VkBool32 persistent; -} VkDisplayPresentInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchains); -#endif -#endif - - -// VK_KHR_sampler_mirror_clamp_to_edge is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_sampler_mirror_clamp_to_edge 1 -#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3 -#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge" - - -// VK_KHR_video_queue is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_queue 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionKHR) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkVideoSessionParametersKHR) -#define VK_KHR_VIDEO_QUEUE_SPEC_VERSION 8 -#define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue" - -typedef enum VkQueryResultStatusKHR { - VK_QUERY_RESULT_STATUS_ERROR_KHR = -1, - VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0, - VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1, - VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR = -1000299000, - VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkQueryResultStatusKHR; - -typedef enum VkVideoCodecOperationFlagBitsKHR { - VK_VIDEO_CODEC_OPERATION_NONE_KHR = 0, - VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR = 0x00010000, - VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR = 0x00020000, - VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001, - VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002, - VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR = 0x00000004, - VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR = 0x00040000, - VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR = 0x00000008, - VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoCodecOperationFlagBitsKHR; -typedef VkFlags VkVideoCodecOperationFlagsKHR; - -typedef enum VkVideoChromaSubsamplingFlagBitsKHR { - VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR = 0, - VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001, - VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002, - VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004, - VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008, - VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoChromaSubsamplingFlagBitsKHR; -typedef VkFlags VkVideoChromaSubsamplingFlagsKHR; - -typedef enum VkVideoComponentBitDepthFlagBitsKHR { - VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0, - VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001, - VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004, - VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010, - VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoComponentBitDepthFlagBitsKHR; -typedef VkFlags VkVideoComponentBitDepthFlagsKHR; - -typedef enum VkVideoCapabilityFlagBitsKHR { - VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0x00000001, - VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002, - VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoCapabilityFlagBitsKHR; -typedef VkFlags VkVideoCapabilityFlagsKHR; - -typedef enum VkVideoSessionCreateFlagBitsKHR { - VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, - VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR = 0x00000002, - VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR = 0x00000004, - VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000008, - VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR = 0x00000010, - VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR = 0x00000020, - VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoSessionCreateFlagBitsKHR; -typedef VkFlags VkVideoSessionCreateFlagsKHR; - -typedef enum VkVideoSessionParametersCreateFlagBitsKHR { - VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR = 0x00000001, - VK_VIDEO_SESSION_PARAMETERS_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoSessionParametersCreateFlagBitsKHR; -typedef VkFlags VkVideoSessionParametersCreateFlagsKHR; -typedef VkFlags VkVideoBeginCodingFlagsKHR; -typedef VkFlags VkVideoEndCodingFlagsKHR; - -typedef enum VkVideoCodingControlFlagBitsKHR { - VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001, - VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR = 0x00000002, - VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR = 0x00000004, - VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoCodingControlFlagBitsKHR; -typedef VkFlags VkVideoCodingControlFlagsKHR; -typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 queryResultStatusSupport; -} VkQueueFamilyQueryResultStatusPropertiesKHR; - -typedef struct VkQueueFamilyVideoPropertiesKHR { - VkStructureType sType; - void* pNext; - VkVideoCodecOperationFlagsKHR videoCodecOperations; -} VkQueueFamilyVideoPropertiesKHR; - -typedef struct VkVideoProfileInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoCodecOperationFlagBitsKHR videoCodecOperation; - VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; - VkVideoComponentBitDepthFlagsKHR lumaBitDepth; - VkVideoComponentBitDepthFlagsKHR chromaBitDepth; -} VkVideoProfileInfoKHR; - -typedef struct VkVideoProfileListInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t profileCount; - const VkVideoProfileInfoKHR* pProfiles; -} VkVideoProfileListInfoKHR; - -typedef struct VkVideoCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkVideoCapabilityFlagsKHR flags; - VkDeviceSize minBitstreamBufferOffsetAlignment; - VkDeviceSize minBitstreamBufferSizeAlignment; - VkExtent2D pictureAccessGranularity; - VkExtent2D minCodedExtent; - VkExtent2D maxCodedExtent; - uint32_t maxDpbSlots; - uint32_t maxActiveReferencePictures; - VkExtensionProperties stdHeaderVersion; -} VkVideoCapabilitiesKHR; - -typedef struct VkPhysicalDeviceVideoFormatInfoKHR { - VkStructureType sType; - const void* pNext; - VkImageUsageFlags imageUsage; -} VkPhysicalDeviceVideoFormatInfoKHR; - -typedef struct VkVideoFormatPropertiesKHR { - VkStructureType sType; - void* pNext; - VkFormat format; - VkComponentMapping componentMapping; - VkImageCreateFlags imageCreateFlags; - VkImageType imageType; - VkImageTiling imageTiling; - VkImageUsageFlags imageUsageFlags; -} VkVideoFormatPropertiesKHR; - -typedef struct VkVideoPictureResourceInfoKHR { - VkStructureType sType; - const void* pNext; - VkOffset2D codedOffset; - VkExtent2D codedExtent; - uint32_t baseArrayLayer; - VkImageView imageViewBinding; -} VkVideoPictureResourceInfoKHR; - -typedef struct VkVideoReferenceSlotInfoKHR { - VkStructureType sType; - const void* pNext; - int32_t slotIndex; - const VkVideoPictureResourceInfoKHR* pPictureResource; -} VkVideoReferenceSlotInfoKHR; - -typedef struct VkVideoSessionMemoryRequirementsKHR { - VkStructureType sType; - void* pNext; - uint32_t memoryBindIndex; - VkMemoryRequirements memoryRequirements; -} VkVideoSessionMemoryRequirementsKHR; - -typedef struct VkBindVideoSessionMemoryInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t memoryBindIndex; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - VkDeviceSize memorySize; -} VkBindVideoSessionMemoryInfoKHR; - -typedef struct VkVideoSessionCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t queueFamilyIndex; - VkVideoSessionCreateFlagsKHR flags; - const VkVideoProfileInfoKHR* pVideoProfile; - VkFormat pictureFormat; - VkExtent2D maxCodedExtent; - VkFormat referencePictureFormat; - uint32_t maxDpbSlots; - uint32_t maxActiveReferencePictures; - const VkExtensionProperties* pStdHeaderVersion; -} VkVideoSessionCreateInfoKHR; - -typedef struct VkVideoSessionParametersCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoSessionParametersCreateFlagsKHR flags; - VkVideoSessionParametersKHR videoSessionParametersTemplate; - VkVideoSessionKHR videoSession; -} VkVideoSessionParametersCreateInfoKHR; - -typedef struct VkVideoSessionParametersUpdateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t updateSequenceCount; -} VkVideoSessionParametersUpdateInfoKHR; - -typedef struct VkVideoBeginCodingInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoBeginCodingFlagsKHR flags; - VkVideoSessionKHR videoSession; - VkVideoSessionParametersKHR videoSessionParameters; - uint32_t referenceSlotCount; - const VkVideoReferenceSlotInfoKHR* pReferenceSlots; -} VkVideoBeginCodingInfoKHR; - -typedef struct VkVideoEndCodingInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEndCodingFlagsKHR flags; -} VkVideoEndCodingInfoKHR; - -typedef struct VkVideoCodingControlInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoCodingControlFlagsKHR flags; -} VkVideoCodingControlInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession); -typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); -typedef VkResult (VKAPI_PTR *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); -typedef VkResult (VKAPI_PTR *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters); -typedef VkResult (VKAPI_PTR *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); -typedef void (VKAPI_PTR *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); -typedef void (VKAPI_PTR *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - const VkVideoProfileInfoKHR* pVideoProfile, - VkVideoCapabilitiesKHR* pCapabilities); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoFormatPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, - uint32_t* pVideoFormatPropertyCount, - VkVideoFormatPropertiesKHR* pVideoFormatProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionKHR( - VkDevice device, - const VkVideoSessionCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkVideoSessionKHR* pVideoSession); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetVideoSessionMemoryRequirementsKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - uint32_t* pMemoryRequirementsCount, - VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkBindVideoSessionMemoryKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - uint32_t bindSessionMemoryInfoCount, - const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateVideoSessionParametersKHR( - VkDevice device, - const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkVideoSessionParametersKHR* pVideoSessionParameters); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkUpdateVideoSessionParametersKHR( - VkDevice device, - VkVideoSessionParametersKHR videoSessionParameters, - const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyVideoSessionParametersKHR( - VkDevice device, - VkVideoSessionParametersKHR videoSessionParameters, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBeginVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoBeginCodingInfoKHR* pBeginInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdEndVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoEndCodingInfoKHR* pEndCodingInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdControlVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoCodingControlInfoKHR* pCodingControlInfo); -#endif -#endif - - -// VK_KHR_video_decode_queue is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_decode_queue 1 -#define VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION 8 -#define VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME "VK_KHR_video_decode_queue" - -typedef enum VkVideoDecodeCapabilityFlagBitsKHR { - VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 0x00000001, - VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 0x00000002, - VK_VIDEO_DECODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoDecodeCapabilityFlagBitsKHR; -typedef VkFlags VkVideoDecodeCapabilityFlagsKHR; - -typedef enum VkVideoDecodeUsageFlagBitsKHR { - VK_VIDEO_DECODE_USAGE_DEFAULT_KHR = 0, - VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, - VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR = 0x00000002, - VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR = 0x00000004, - VK_VIDEO_DECODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoDecodeUsageFlagBitsKHR; -typedef VkFlags VkVideoDecodeUsageFlagsKHR; -typedef VkFlags VkVideoDecodeFlagsKHR; -typedef struct VkVideoDecodeCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkVideoDecodeCapabilityFlagsKHR flags; -} VkVideoDecodeCapabilitiesKHR; - -typedef struct VkVideoDecodeUsageInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoDecodeUsageFlagsKHR videoUsageHints; -} VkVideoDecodeUsageInfoKHR; - -typedef struct VkVideoDecodeInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoDecodeFlagsKHR flags; - VkBuffer srcBuffer; - VkDeviceSize srcBufferOffset; - VkDeviceSize srcBufferRange; - VkVideoPictureResourceInfoKHR dstPictureResource; - const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; - uint32_t referenceSlotCount; - const VkVideoReferenceSlotInfoKHR* pReferenceSlots; -} VkVideoDecodeInfoKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDecodeVideoKHR( - VkCommandBuffer commandBuffer, - const VkVideoDecodeInfoKHR* pDecodeInfo); -#endif -#endif - - -// VK_KHR_video_encode_h264 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_encode_h264 1 -#include "vk_video/vulkan_video_codec_h264std.h" -#include "vk_video/vulkan_video_codec_h264std_encode.h" -#define VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION 14 -#define VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_KHR_video_encode_h264" - -typedef enum VkVideoEncodeH264CapabilityFlagBitsKHR { - VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR = 0x00000010, - VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR = 0x00000020, - VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 0x00000040, - VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR = 0x00000080, - VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR = 0x00000100, - VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR = 0x00000400, - VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR = 0x00000200, - VK_VIDEO_ENCODE_H264_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeH264CapabilityFlagBitsKHR; -typedef VkFlags VkVideoEncodeH264CapabilityFlagsKHR; - -typedef enum VkVideoEncodeH264StdFlagBitsKHR { - VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR = 0x00000010, - VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR = 0x00000020, - VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR = 0x00000040, - VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR = 0x00000080, - VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR = 0x00000100, - VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR = 0x00000200, - VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR = 0x00000400, - VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR = 0x00000800, - VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR = 0x00001000, - VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR = 0x00002000, - VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR = 0x00004000, - VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR = 0x00008000, - VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR = 0x00010000, - VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR = 0x00020000, - VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR = 0x00080000, - VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR = 0x00100000, - VK_VIDEO_ENCODE_H264_STD_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeH264StdFlagBitsKHR; -typedef VkFlags VkVideoEncodeH264StdFlagsKHR; - -typedef enum VkVideoEncodeH264RateControlFlagBitsKHR { - VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR = 0x00000010, - VK_VIDEO_ENCODE_H264_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeH264RateControlFlagBitsKHR; -typedef VkFlags VkVideoEncodeH264RateControlFlagsKHR; -typedef struct VkVideoEncodeH264CapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeH264CapabilityFlagsKHR flags; - StdVideoH264LevelIdc maxLevelIdc; - uint32_t maxSliceCount; - uint32_t maxPPictureL0ReferenceCount; - uint32_t maxBPictureL0ReferenceCount; - uint32_t maxL1ReferenceCount; - uint32_t maxTemporalLayerCount; - VkBool32 expectDyadicTemporalLayerPattern; - int32_t minQp; - int32_t maxQp; - VkBool32 prefersGopRemainingFrames; - VkBool32 requiresGopRemainingFrames; - VkVideoEncodeH264StdFlagsKHR stdSyntaxFlags; -} VkVideoEncodeH264CapabilitiesKHR; - -typedef struct VkVideoEncodeH264QpKHR { - int32_t qpI; - int32_t qpP; - int32_t qpB; -} VkVideoEncodeH264QpKHR; - -typedef struct VkVideoEncodeH264QualityLevelPropertiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeH264RateControlFlagsKHR preferredRateControlFlags; - uint32_t preferredGopFrameCount; - uint32_t preferredIdrPeriod; - uint32_t preferredConsecutiveBFrameCount; - uint32_t preferredTemporalLayerCount; - VkVideoEncodeH264QpKHR preferredConstantQp; - uint32_t preferredMaxL0ReferenceCount; - uint32_t preferredMaxL1ReferenceCount; - VkBool32 preferredStdEntropyCodingModeFlag; -} VkVideoEncodeH264QualityLevelPropertiesKHR; - -typedef struct VkVideoEncodeH264SessionCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkBool32 useMaxLevelIdc; - StdVideoH264LevelIdc maxLevelIdc; -} VkVideoEncodeH264SessionCreateInfoKHR; - -typedef struct VkVideoEncodeH264SessionParametersAddInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t stdSPSCount; - const StdVideoH264SequenceParameterSet* pStdSPSs; - uint32_t stdPPSCount; - const StdVideoH264PictureParameterSet* pStdPPSs; -} VkVideoEncodeH264SessionParametersAddInfoKHR; - -typedef struct VkVideoEncodeH264SessionParametersCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - const VkVideoEncodeH264SessionParametersAddInfoKHR* pParametersAddInfo; -} VkVideoEncodeH264SessionParametersCreateInfoKHR; - -typedef struct VkVideoEncodeH264SessionParametersGetInfoKHR { - VkStructureType sType; - const void* pNext; - VkBool32 writeStdSPS; - VkBool32 writeStdPPS; - uint32_t stdSPSId; - uint32_t stdPPSId; -} VkVideoEncodeH264SessionParametersGetInfoKHR; - -typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR { - VkStructureType sType; - void* pNext; - VkBool32 hasStdSPSOverrides; - VkBool32 hasStdPPSOverrides; -} VkVideoEncodeH264SessionParametersFeedbackInfoKHR; - -typedef struct VkVideoEncodeH264NaluSliceInfoKHR { - VkStructureType sType; - const void* pNext; - int32_t constantQp; - const StdVideoEncodeH264SliceHeader* pStdSliceHeader; -} VkVideoEncodeH264NaluSliceInfoKHR; - -typedef struct VkVideoEncodeH264PictureInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t naluSliceEntryCount; - const VkVideoEncodeH264NaluSliceInfoKHR* pNaluSliceEntries; - const StdVideoEncodeH264PictureInfo* pStdPictureInfo; - VkBool32 generatePrefixNalu; -} VkVideoEncodeH264PictureInfoKHR; - -typedef struct VkVideoEncodeH264DpbSlotInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo; -} VkVideoEncodeH264DpbSlotInfoKHR; - -typedef struct VkVideoEncodeH264ProfileInfoKHR { - VkStructureType sType; - const void* pNext; - StdVideoH264ProfileIdc stdProfileIdc; -} VkVideoEncodeH264ProfileInfoKHR; - -typedef struct VkVideoEncodeH264RateControlInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeH264RateControlFlagsKHR flags; - uint32_t gopFrameCount; - uint32_t idrPeriod; - uint32_t consecutiveBFrameCount; - uint32_t temporalLayerCount; -} VkVideoEncodeH264RateControlInfoKHR; - -typedef struct VkVideoEncodeH264FrameSizeKHR { - uint32_t frameISize; - uint32_t framePSize; - uint32_t frameBSize; -} VkVideoEncodeH264FrameSizeKHR; - -typedef struct VkVideoEncodeH264RateControlLayerInfoKHR { - VkStructureType sType; - const void* pNext; - VkBool32 useMinQp; - VkVideoEncodeH264QpKHR minQp; - VkBool32 useMaxQp; - VkVideoEncodeH264QpKHR maxQp; - VkBool32 useMaxFrameSize; - VkVideoEncodeH264FrameSizeKHR maxFrameSize; -} VkVideoEncodeH264RateControlLayerInfoKHR; - -typedef struct VkVideoEncodeH264GopRemainingFrameInfoKHR { - VkStructureType sType; - const void* pNext; - VkBool32 useGopRemainingFrames; - uint32_t gopRemainingI; - uint32_t gopRemainingP; - uint32_t gopRemainingB; -} VkVideoEncodeH264GopRemainingFrameInfoKHR; - - - -// VK_KHR_video_encode_h265 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_encode_h265 1 -#include "vk_video/vulkan_video_codec_h265std.h" -#include "vk_video/vulkan_video_codec_h265std_encode.h" -#define VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION 14 -#define VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME "VK_KHR_video_encode_h265" - -typedef enum VkVideoEncodeH265CapabilityFlagBitsKHR { - VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR = 0x00000010, - VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR = 0x00000020, - VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR = 0x00000040, - VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR = 0x00000080, - VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR = 0x00000100, - VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR = 0x00000200, - VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR = 0x00000800, - VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR = 0x00000400, - VK_VIDEO_ENCODE_H265_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeH265CapabilityFlagBitsKHR; -typedef VkFlags VkVideoEncodeH265CapabilityFlagsKHR; - -typedef enum VkVideoEncodeH265StdFlagBitsKHR { - VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR = 0x00000010, - VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR = 0x00000020, - VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR = 0x00000040, - VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR = 0x00000080, - VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR = 0x00000100, - VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR = 0x00000200, - VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR = 0x00000400, - VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR = 0x00000800, - VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR = 0x00001000, - VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR = 0x00002000, - VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR = 0x00004000, - VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR = 0x00008000, - VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR = 0x00010000, - VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR = 0x00020000, - VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR = 0x00040000, - VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR = 0x00080000, - VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR = 0x00100000, - VK_VIDEO_ENCODE_H265_STD_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeH265StdFlagBitsKHR; -typedef VkFlags VkVideoEncodeH265StdFlagsKHR; - -typedef enum VkVideoEncodeH265CtbSizeFlagBitsKHR { - VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_H265_CTB_SIZE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeH265CtbSizeFlagBitsKHR; -typedef VkFlags VkVideoEncodeH265CtbSizeFlagsKHR; - -typedef enum VkVideoEncodeH265TransformBlockSizeFlagBitsKHR { - VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeH265TransformBlockSizeFlagBitsKHR; -typedef VkFlags VkVideoEncodeH265TransformBlockSizeFlagsKHR; - -typedef enum VkVideoEncodeH265RateControlFlagBitsKHR { - VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR = 0x00000010, - VK_VIDEO_ENCODE_H265_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeH265RateControlFlagBitsKHR; -typedef VkFlags VkVideoEncodeH265RateControlFlagsKHR; -typedef struct VkVideoEncodeH265CapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeH265CapabilityFlagsKHR flags; - StdVideoH265LevelIdc maxLevelIdc; - uint32_t maxSliceSegmentCount; - VkExtent2D maxTiles; - VkVideoEncodeH265CtbSizeFlagsKHR ctbSizes; - VkVideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes; - uint32_t maxPPictureL0ReferenceCount; - uint32_t maxBPictureL0ReferenceCount; - uint32_t maxL1ReferenceCount; - uint32_t maxSubLayerCount; - VkBool32 expectDyadicTemporalSubLayerPattern; - int32_t minQp; - int32_t maxQp; - VkBool32 prefersGopRemainingFrames; - VkBool32 requiresGopRemainingFrames; - VkVideoEncodeH265StdFlagsKHR stdSyntaxFlags; -} VkVideoEncodeH265CapabilitiesKHR; - -typedef struct VkVideoEncodeH265SessionCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkBool32 useMaxLevelIdc; - StdVideoH265LevelIdc maxLevelIdc; -} VkVideoEncodeH265SessionCreateInfoKHR; - -typedef struct VkVideoEncodeH265QpKHR { - int32_t qpI; - int32_t qpP; - int32_t qpB; -} VkVideoEncodeH265QpKHR; - -typedef struct VkVideoEncodeH265QualityLevelPropertiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeH265RateControlFlagsKHR preferredRateControlFlags; - uint32_t preferredGopFrameCount; - uint32_t preferredIdrPeriod; - uint32_t preferredConsecutiveBFrameCount; - uint32_t preferredSubLayerCount; - VkVideoEncodeH265QpKHR preferredConstantQp; - uint32_t preferredMaxL0ReferenceCount; - uint32_t preferredMaxL1ReferenceCount; -} VkVideoEncodeH265QualityLevelPropertiesKHR; - -typedef struct VkVideoEncodeH265SessionParametersAddInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t stdVPSCount; - const StdVideoH265VideoParameterSet* pStdVPSs; - uint32_t stdSPSCount; - const StdVideoH265SequenceParameterSet* pStdSPSs; - uint32_t stdPPSCount; - const StdVideoH265PictureParameterSet* pStdPPSs; -} VkVideoEncodeH265SessionParametersAddInfoKHR; - -typedef struct VkVideoEncodeH265SessionParametersCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t maxStdVPSCount; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - const VkVideoEncodeH265SessionParametersAddInfoKHR* pParametersAddInfo; -} VkVideoEncodeH265SessionParametersCreateInfoKHR; - -typedef struct VkVideoEncodeH265SessionParametersGetInfoKHR { - VkStructureType sType; - const void* pNext; - VkBool32 writeStdVPS; - VkBool32 writeStdSPS; - VkBool32 writeStdPPS; - uint32_t stdVPSId; - uint32_t stdSPSId; - uint32_t stdPPSId; -} VkVideoEncodeH265SessionParametersGetInfoKHR; - -typedef struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR { - VkStructureType sType; - void* pNext; - VkBool32 hasStdVPSOverrides; - VkBool32 hasStdSPSOverrides; - VkBool32 hasStdPPSOverrides; -} VkVideoEncodeH265SessionParametersFeedbackInfoKHR; - -typedef struct VkVideoEncodeH265NaluSliceSegmentInfoKHR { - VkStructureType sType; - const void* pNext; - int32_t constantQp; - const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader; -} VkVideoEncodeH265NaluSliceSegmentInfoKHR; - -typedef struct VkVideoEncodeH265PictureInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t naluSliceSegmentEntryCount; - const VkVideoEncodeH265NaluSliceSegmentInfoKHR* pNaluSliceSegmentEntries; - const StdVideoEncodeH265PictureInfo* pStdPictureInfo; -} VkVideoEncodeH265PictureInfoKHR; - -typedef struct VkVideoEncodeH265DpbSlotInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo; -} VkVideoEncodeH265DpbSlotInfoKHR; - -typedef struct VkVideoEncodeH265ProfileInfoKHR { - VkStructureType sType; - const void* pNext; - StdVideoH265ProfileIdc stdProfileIdc; -} VkVideoEncodeH265ProfileInfoKHR; - -typedef struct VkVideoEncodeH265RateControlInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeH265RateControlFlagsKHR flags; - uint32_t gopFrameCount; - uint32_t idrPeriod; - uint32_t consecutiveBFrameCount; - uint32_t subLayerCount; -} VkVideoEncodeH265RateControlInfoKHR; - -typedef struct VkVideoEncodeH265FrameSizeKHR { - uint32_t frameISize; - uint32_t framePSize; - uint32_t frameBSize; -} VkVideoEncodeH265FrameSizeKHR; - -typedef struct VkVideoEncodeH265RateControlLayerInfoKHR { - VkStructureType sType; - const void* pNext; - VkBool32 useMinQp; - VkVideoEncodeH265QpKHR minQp; - VkBool32 useMaxQp; - VkVideoEncodeH265QpKHR maxQp; - VkBool32 useMaxFrameSize; - VkVideoEncodeH265FrameSizeKHR maxFrameSize; -} VkVideoEncodeH265RateControlLayerInfoKHR; - -typedef struct VkVideoEncodeH265GopRemainingFrameInfoKHR { - VkStructureType sType; - const void* pNext; - VkBool32 useGopRemainingFrames; - uint32_t gopRemainingI; - uint32_t gopRemainingP; - uint32_t gopRemainingB; -} VkVideoEncodeH265GopRemainingFrameInfoKHR; - - - -// VK_KHR_video_decode_h264 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_decode_h264 1 -#include "vk_video/vulkan_video_codec_h264std_decode.h" -#define VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION 9 -#define VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME "VK_KHR_video_decode_h264" - -typedef enum VkVideoDecodeH264PictureLayoutFlagBitsKHR { - VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR = 0, - VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR = 0x00000001, - VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR = 0x00000002, - VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoDecodeH264PictureLayoutFlagBitsKHR; -typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsKHR; -typedef struct VkVideoDecodeH264ProfileInfoKHR { - VkStructureType sType; - const void* pNext; - StdVideoH264ProfileIdc stdProfileIdc; - VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout; -} VkVideoDecodeH264ProfileInfoKHR; - -typedef struct VkVideoDecodeH264CapabilitiesKHR { - VkStructureType sType; - void* pNext; - StdVideoH264LevelIdc maxLevelIdc; - VkOffset2D fieldOffsetGranularity; -} VkVideoDecodeH264CapabilitiesKHR; - -typedef struct VkVideoDecodeH264SessionParametersAddInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t stdSPSCount; - const StdVideoH264SequenceParameterSet* pStdSPSs; - uint32_t stdPPSCount; - const StdVideoH264PictureParameterSet* pStdPPSs; -} VkVideoDecodeH264SessionParametersAddInfoKHR; - -typedef struct VkVideoDecodeH264SessionParametersCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - const VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo; -} VkVideoDecodeH264SessionParametersCreateInfoKHR; - -typedef struct VkVideoDecodeH264PictureInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoDecodeH264PictureInfo* pStdPictureInfo; - uint32_t sliceCount; - const uint32_t* pSliceOffsets; -} VkVideoDecodeH264PictureInfoKHR; - -typedef struct VkVideoDecodeH264DpbSlotInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo; -} VkVideoDecodeH264DpbSlotInfoKHR; - - - -// VK_KHR_dynamic_rendering is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_dynamic_rendering 1 -#define VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION 1 -#define VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME "VK_KHR_dynamic_rendering" -typedef VkRenderingFlags VkRenderingFlagsKHR; - -typedef VkRenderingFlagBits VkRenderingFlagBitsKHR; - -typedef VkRenderingInfo VkRenderingInfoKHR; - -typedef VkRenderingAttachmentInfo VkRenderingAttachmentInfoKHR; - -typedef VkPipelineRenderingCreateInfo VkPipelineRenderingCreateInfoKHR; - -typedef VkPhysicalDeviceDynamicRenderingFeatures VkPhysicalDeviceDynamicRenderingFeaturesKHR; - -typedef VkCommandBufferInheritanceRenderingInfo VkCommandBufferInheritanceRenderingInfoKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR( - VkCommandBuffer commandBuffer, - const VkRenderingInfo* pRenderingInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR( - VkCommandBuffer commandBuffer); -#endif -#endif - - -// VK_KHR_multiview is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_multiview 1 -#define VK_KHR_MULTIVIEW_SPEC_VERSION 1 -#define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview" -typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR; - -typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR; - -typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR; - - - -// VK_KHR_get_physical_device_properties2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_get_physical_device_properties2 1 -#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2 -#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2" -typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR; - -typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR; - -typedef VkFormatProperties2 VkFormatProperties2KHR; - -typedef VkImageFormatProperties2 VkImageFormatProperties2KHR; - -typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR; - -typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR; - -typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR; - -typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR; - -typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR; - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties); -#endif -#endif - - -// VK_KHR_device_group is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_device_group 1 -#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 4 -#define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group" -typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; - -typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR; - -typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR; - -typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR; - -typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR; - -typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR; - -typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR; - -typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR; - -typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR; - -typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR; - -typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR; - -typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR( - VkCommandBuffer commandBuffer, - uint32_t deviceMask); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR( - VkCommandBuffer commandBuffer, - uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); -#endif -#endif - - -// VK_KHR_shader_draw_parameters is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_draw_parameters 1 -#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1 -#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters" - - -// VK_KHR_maintenance1 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_maintenance1 1 -#define VK_KHR_MAINTENANCE_1_SPEC_VERSION 2 -#define VK_KHR_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_maintenance1" -// VK_KHR_MAINTENANCE1_SPEC_VERSION is a legacy alias -#define VK_KHR_MAINTENANCE1_SPEC_VERSION VK_KHR_MAINTENANCE_1_SPEC_VERSION -// VK_KHR_MAINTENANCE1_EXTENSION_NAME is a legacy alias -#define VK_KHR_MAINTENANCE1_EXTENSION_NAME VK_KHR_MAINTENANCE_1_EXTENSION_NAME -typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; - -typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags); -#endif -#endif - - -// VK_KHR_device_group_creation is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_device_group_creation 1 -#define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1 -#define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation" -#define VK_MAX_DEVICE_GROUP_SIZE_KHR VK_MAX_DEVICE_GROUP_SIZE -typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR; - -typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -#endif -#endif - - -// VK_KHR_external_memory_capabilities is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_memory_capabilities 1 -#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities" -#define VK_LUID_SIZE_KHR VK_LUID_SIZE -typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR; - -typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR; - -typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR; - -typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR; - -typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR; - -typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR; - -typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR; - -typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR; - -typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR; - -typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR; - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties); -#endif -#endif - - -// VK_KHR_external_memory is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_memory 1 -#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory" -#define VK_QUEUE_FAMILY_EXTERNAL_KHR VK_QUEUE_FAMILY_EXTERNAL -typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR; - -typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR; - -typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR; - - - -// VK_KHR_external_memory_fd is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_memory_fd 1 -#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd" -typedef struct VkImportMemoryFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - int fd; -} VkImportMemoryFdInfoKHR; - -typedef struct VkMemoryFdPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryFdPropertiesKHR; - -typedef struct VkMemoryGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkMemoryGetFdInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR( - VkDevice device, - const VkMemoryGetFdInfoKHR* pGetFdInfo, - int* pFd); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - int fd, - VkMemoryFdPropertiesKHR* pMemoryFdProperties); -#endif -#endif - - -// VK_KHR_external_semaphore_capabilities is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_semaphore_capabilities 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities" -typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR; - -typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR; - -typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR; - -typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR; - -typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR; - -typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties); -#endif -#endif - - -// VK_KHR_external_semaphore is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_semaphore 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore" -typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR; - -typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR; - -typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR; - - - -// VK_KHR_external_semaphore_fd is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_semaphore_fd 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd" -typedef struct VkImportSemaphoreFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkSemaphoreImportFlags flags; - VkExternalSemaphoreHandleTypeFlagBits handleType; - int fd; -} VkImportSemaphoreFdInfoKHR; - -typedef struct VkSemaphoreGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkSemaphoreGetFdInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR( - VkDevice device, - const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR( - VkDevice device, - const VkSemaphoreGetFdInfoKHR* pGetFdInfo, - int* pFd); -#endif -#endif - - -// VK_KHR_push_descriptor is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_push_descriptor 1 -#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2 -#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor" -typedef VkPhysicalDevicePushDescriptorProperties VkPhysicalDevicePushDescriptorPropertiesKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR( - VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout layout, - uint32_t set, - const void* pData); -#endif -#endif - - -// VK_KHR_shader_float16_int8 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_float16_int8 1 -#define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1 -#define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8" -typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR; - -typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR; - - - -// VK_KHR_16bit_storage is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_16bit_storage 1 -#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1 -#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage" -typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR; - - - -// VK_KHR_incremental_present is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_incremental_present 1 -#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2 -#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present" -typedef struct VkRectLayerKHR { - VkOffset2D offset; - VkExtent2D extent; - uint32_t layer; -} VkRectLayerKHR; - -typedef struct VkPresentRegionKHR { - uint32_t rectangleCount; - const VkRectLayerKHR* pRectangles; -} VkPresentRegionKHR; - -typedef struct VkPresentRegionsKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentRegionKHR* pRegions; -} VkPresentRegionsKHR; - - - -// VK_KHR_descriptor_update_template is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_descriptor_update_template 1 -typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR; - -#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1 -#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template" -typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR; - -typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR; - -typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR; - -typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData); -#endif -#endif - - -// VK_KHR_imageless_framebuffer is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_imageless_framebuffer 1 -#define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1 -#define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer" -typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR; - -typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR; - -typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR; - -typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR; - - - -// VK_KHR_create_renderpass2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_create_renderpass2 1 -#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1 -#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2" -typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR; - -typedef VkAttachmentDescription2 VkAttachmentDescription2KHR; - -typedef VkAttachmentReference2 VkAttachmentReference2KHR; - -typedef VkSubpassDescription2 VkSubpassDescription2KHR; - -typedef VkSubpassDependency2 VkSubpassDependency2KHR; - -typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR; - -typedef VkSubpassEndInfo VkSubpassEndInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); -typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR( - VkDevice device, - const VkRenderPassCreateInfo2* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - const VkSubpassBeginInfo* pSubpassBeginInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo* pSubpassBeginInfo, - const VkSubpassEndInfo* pSubpassEndInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfo* pSubpassEndInfo); -#endif -#endif - - -// VK_KHR_shared_presentable_image is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shared_presentable_image 1 -#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1 -#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image" -typedef struct VkSharedPresentSurfaceCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkImageUsageFlags sharedPresentSupportedUsageFlags; -} VkSharedPresentSurfaceCapabilitiesKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR( - VkDevice device, - VkSwapchainKHR swapchain); -#endif -#endif - - -// VK_KHR_external_fence_capabilities is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_fence_capabilities 1 -#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities" -typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR; - -typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR; - -typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR; - -typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR; - -typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR; - -typedef VkExternalFenceProperties VkExternalFencePropertiesKHR; - -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties); -#endif -#endif - - -// VK_KHR_external_fence is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_fence 1 -#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence" -typedef VkFenceImportFlags VkFenceImportFlagsKHR; - -typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR; - -typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR; - - - -// VK_KHR_external_fence_fd is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_fence_fd 1 -#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd" -typedef struct VkImportFenceFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkFenceImportFlags flags; - VkExternalFenceHandleTypeFlagBits handleType; - int fd; -} VkImportFenceFdInfoKHR; - -typedef struct VkFenceGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkExternalFenceHandleTypeFlagBits handleType; -} VkFenceGetFdInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR( - VkDevice device, - const VkImportFenceFdInfoKHR* pImportFenceFdInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR( - VkDevice device, - const VkFenceGetFdInfoKHR* pGetFdInfo, - int* pFd); -#endif -#endif - - -// VK_KHR_performance_query is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_performance_query 1 -#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1 -#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query" - -typedef enum VkPerformanceCounterUnitKHR { - VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, - VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, - VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, - VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, - VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, - VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, - VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, - VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, - VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, - VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, - VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, - VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterUnitKHR; - -typedef enum VkPerformanceCounterScopeKHR { - VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0, - VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1, - VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2, - // VK_QUERY_SCOPE_COMMAND_BUFFER_KHR is a legacy alias - VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, - // VK_QUERY_SCOPE_RENDER_PASS_KHR is a legacy alias - VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, - // VK_QUERY_SCOPE_COMMAND_KHR is a legacy alias - VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, - VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterScopeKHR; - -typedef enum VkPerformanceCounterStorageKHR { - VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, - VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, - VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, - VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, - VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, - VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, - VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterStorageKHR; - -typedef enum VkPerformanceCounterDescriptionFlagBitsKHR { - VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001, - VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002, - // VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR is a legacy alias - VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, - // VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR is a legacy alias - VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR, - VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterDescriptionFlagBitsKHR; -typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; - -typedef enum VkAcquireProfilingLockFlagBitsKHR { - VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAcquireProfilingLockFlagBitsKHR; -typedef VkFlags VkAcquireProfilingLockFlagsKHR; -typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 performanceCounterQueryPools; - VkBool32 performanceCounterMultipleQueryPools; -} VkPhysicalDevicePerformanceQueryFeaturesKHR; - -typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 allowCommandBufferQueryCopies; -} VkPhysicalDevicePerformanceQueryPropertiesKHR; - -typedef struct VkPerformanceCounterKHR { - VkStructureType sType; - void* pNext; - VkPerformanceCounterUnitKHR unit; - VkPerformanceCounterScopeKHR scope; - VkPerformanceCounterStorageKHR storage; - uint8_t uuid[VK_UUID_SIZE]; -} VkPerformanceCounterKHR; - -typedef struct VkPerformanceCounterDescriptionKHR { - VkStructureType sType; - void* pNext; - VkPerformanceCounterDescriptionFlagsKHR flags; - char name[VK_MAX_DESCRIPTION_SIZE]; - char category[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; -} VkPerformanceCounterDescriptionKHR; - -typedef struct VkQueryPoolPerformanceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t queueFamilyIndex; - uint32_t counterIndexCount; - const uint32_t* pCounterIndices; -} VkQueryPoolPerformanceCreateInfoKHR; - -typedef union VkPerformanceCounterResultKHR { - int32_t int32; - int64_t int64; - uint32_t uint32; - uint64_t uint64; - float float32; - double float64; -} VkPerformanceCounterResultKHR; - -typedef struct VkAcquireProfilingLockInfoKHR { - VkStructureType sType; - const void* pNext; - VkAcquireProfilingLockFlagsKHR flags; - uint64_t timeout; -} VkAcquireProfilingLockInfoKHR; - -typedef struct VkPerformanceQuerySubmitInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t counterPassIndex; -} VkPerformanceQuerySubmitInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); -typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); -typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - uint32_t* pCounterCount, - VkPerformanceCounterKHR* pCounters, - VkPerformanceCounterDescriptionKHR* pCounterDescriptions); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( - VkPhysicalDevice physicalDevice, - const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, - uint32_t* pNumPasses); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR( - VkDevice device, - const VkAcquireProfilingLockInfoKHR* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR( - VkDevice device); -#endif -#endif - - -// VK_KHR_maintenance2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_maintenance2 1 -#define VK_KHR_MAINTENANCE_2_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_maintenance2" -// VK_KHR_MAINTENANCE2_SPEC_VERSION is a legacy alias -#define VK_KHR_MAINTENANCE2_SPEC_VERSION VK_KHR_MAINTENANCE_2_SPEC_VERSION -// VK_KHR_MAINTENANCE2_EXTENSION_NAME is a legacy alias -#define VK_KHR_MAINTENANCE2_EXTENSION_NAME VK_KHR_MAINTENANCE_2_EXTENSION_NAME -typedef VkPointClippingBehavior VkPointClippingBehaviorKHR; - -typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR; - -typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR; - -typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR; - -typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR; - -typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR; - -typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR; - - - -// VK_KHR_get_surface_capabilities2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_get_surface_capabilities2 1 -#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1 -#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2" -typedef struct VkPhysicalDeviceSurfaceInfo2KHR { - VkStructureType sType; - const void* pNext; - VkSurfaceKHR surface; -} VkPhysicalDeviceSurfaceInfo2KHR; - -typedef struct VkSurfaceCapabilities2KHR { - VkStructureType sType; - void* pNext; - VkSurfaceCapabilitiesKHR surfaceCapabilities; -} VkSurfaceCapabilities2KHR; - -typedef struct VkSurfaceFormat2KHR { - VkStructureType sType; - void* pNext; - VkSurfaceFormatKHR surfaceFormat; -} VkSurfaceFormat2KHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkSurfaceCapabilities2KHR* pSurfaceCapabilities); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormat2KHR* pSurfaceFormats); -#endif -#endif - - -// VK_KHR_variable_pointers is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_variable_pointers 1 -#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1 -#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers" -typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; - -typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR; - - - -// VK_KHR_get_display_properties2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_get_display_properties2 1 -#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1 -#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2" -typedef struct VkDisplayProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPropertiesKHR displayProperties; -} VkDisplayProperties2KHR; - -typedef struct VkDisplayPlaneProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPlanePropertiesKHR displayPlaneProperties; -} VkDisplayPlaneProperties2KHR; - -typedef struct VkDisplayModeProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayModePropertiesKHR displayModeProperties; -} VkDisplayModeProperties2KHR; - -typedef struct VkDisplayPlaneInfo2KHR { - VkStructureType sType; - const void* pNext; - VkDisplayModeKHR mode; - uint32_t planeIndex; -} VkDisplayPlaneInfo2KHR; - -typedef struct VkDisplayPlaneCapabilities2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPlaneCapabilitiesKHR capabilities; -} VkDisplayPlaneCapabilities2KHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayProperties2KHR* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlaneProperties2KHR* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModeProperties2KHR* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, - VkDisplayPlaneCapabilities2KHR* pCapabilities); -#endif -#endif - - -// VK_KHR_dedicated_allocation is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_dedicated_allocation 1 -#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3 -#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation" -typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR; - -typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR; - - - -// VK_KHR_storage_buffer_storage_class is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_storage_buffer_storage_class 1 -#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1 -#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class" - - -// VK_KHR_shader_bfloat16 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_bfloat16 1 -#define VK_KHR_SHADER_BFLOAT16_SPEC_VERSION 1 -#define VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME "VK_KHR_shader_bfloat16" -typedef struct VkPhysicalDeviceShaderBfloat16FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderBFloat16Type; - VkBool32 shaderBFloat16DotProduct; - VkBool32 shaderBFloat16CooperativeMatrix; -} VkPhysicalDeviceShaderBfloat16FeaturesKHR; - - - -// VK_KHR_relaxed_block_layout is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_relaxed_block_layout 1 -#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1 -#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout" - - -// VK_KHR_get_memory_requirements2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_get_memory_requirements2 1 -#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1 -#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2" -typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR; - -typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR; - -typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR; - -typedef VkMemoryRequirements2 VkMemoryRequirements2KHR; - -typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR; - -typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -#endif -#endif - - -// VK_KHR_image_format_list is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_image_format_list 1 -#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1 -#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list" -typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR; - - - -// VK_KHR_sampler_ycbcr_conversion is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_sampler_ycbcr_conversion 1 -typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR; - -#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14 -#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion" -typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR; - -typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR; - -typedef VkChromaLocation VkChromaLocationKHR; - -typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR; - -typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR; - -typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR; - -typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR; - -typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; - -typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); -typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator); -#endif -#endif - - -// VK_KHR_bind_memory2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_bind_memory2 1 -#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1 -#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2" -typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR; - -typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); -typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos); -#endif -#endif - - -// VK_KHR_maintenance3 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_maintenance3 1 -#define VK_KHR_MAINTENANCE_3_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_3_EXTENSION_NAME "VK_KHR_maintenance3" -// VK_KHR_MAINTENANCE3_SPEC_VERSION is a legacy alias -#define VK_KHR_MAINTENANCE3_SPEC_VERSION VK_KHR_MAINTENANCE_3_SPEC_VERSION -// VK_KHR_MAINTENANCE3_EXTENSION_NAME is a legacy alias -#define VK_KHR_MAINTENANCE3_EXTENSION_NAME VK_KHR_MAINTENANCE_3_EXTENSION_NAME -typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR; - -typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR; - -typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport); -#endif -#endif - - -// VK_KHR_draw_indirect_count is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_draw_indirect_count 1 -#define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1 -#define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count" -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); -#endif -#endif - - -// VK_KHR_shader_subgroup_extended_types is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_subgroup_extended_types 1 -#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1 -#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types" -typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; - - - -// VK_KHR_8bit_storage is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_8bit_storage 1 -#define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1 -#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage" -typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR; - - - -// VK_KHR_shader_atomic_int64 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_atomic_int64 1 -#define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1 -#define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64" -typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR; - - - -// VK_KHR_shader_clock is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_clock 1 -#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1 -#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock" -typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderSubgroupClock; - VkBool32 shaderDeviceClock; -} VkPhysicalDeviceShaderClockFeaturesKHR; - - - -// VK_KHR_video_decode_h265 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_decode_h265 1 -#include "vk_video/vulkan_video_codec_h265std_decode.h" -#define VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION 8 -#define VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME "VK_KHR_video_decode_h265" -typedef struct VkVideoDecodeH265ProfileInfoKHR { - VkStructureType sType; - const void* pNext; - StdVideoH265ProfileIdc stdProfileIdc; -} VkVideoDecodeH265ProfileInfoKHR; - -typedef struct VkVideoDecodeH265CapabilitiesKHR { - VkStructureType sType; - void* pNext; - StdVideoH265LevelIdc maxLevelIdc; -} VkVideoDecodeH265CapabilitiesKHR; - -typedef struct VkVideoDecodeH265SessionParametersAddInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t stdVPSCount; - const StdVideoH265VideoParameterSet* pStdVPSs; - uint32_t stdSPSCount; - const StdVideoH265SequenceParameterSet* pStdSPSs; - uint32_t stdPPSCount; - const StdVideoH265PictureParameterSet* pStdPPSs; -} VkVideoDecodeH265SessionParametersAddInfoKHR; - -typedef struct VkVideoDecodeH265SessionParametersCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t maxStdVPSCount; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - const VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo; -} VkVideoDecodeH265SessionParametersCreateInfoKHR; - -typedef struct VkVideoDecodeH265PictureInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoDecodeH265PictureInfo* pStdPictureInfo; - uint32_t sliceSegmentCount; - const uint32_t* pSliceSegmentOffsets; -} VkVideoDecodeH265PictureInfoKHR; - -typedef struct VkVideoDecodeH265DpbSlotInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo; -} VkVideoDecodeH265DpbSlotInfoKHR; - - - -// VK_KHR_global_priority is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_global_priority 1 -#define VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION 1 -#define VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME "VK_KHR_global_priority" -#define VK_MAX_GLOBAL_PRIORITY_SIZE_KHR VK_MAX_GLOBAL_PRIORITY_SIZE -typedef VkQueueGlobalPriority VkQueueGlobalPriorityKHR; - -typedef VkDeviceQueueGlobalPriorityCreateInfo VkDeviceQueueGlobalPriorityCreateInfoKHR; - -typedef VkPhysicalDeviceGlobalPriorityQueryFeatures VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR; - -typedef VkQueueFamilyGlobalPriorityProperties VkQueueFamilyGlobalPriorityPropertiesKHR; - - - -// VK_KHR_driver_properties is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_driver_properties 1 -#define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1 -#define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties" -#define VK_MAX_DRIVER_NAME_SIZE_KHR VK_MAX_DRIVER_NAME_SIZE -#define VK_MAX_DRIVER_INFO_SIZE_KHR VK_MAX_DRIVER_INFO_SIZE -typedef VkDriverId VkDriverIdKHR; - -typedef VkConformanceVersion VkConformanceVersionKHR; - -typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR; - - - -// VK_KHR_shader_float_controls is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_float_controls 1 -#define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4 -#define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls" -typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR; - -typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR; - - - -// VK_KHR_depth_stencil_resolve is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_depth_stencil_resolve 1 -#define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1 -#define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve" -typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR; - -typedef VkResolveModeFlags VkResolveModeFlagsKHR; - -typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR; - -typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR; - - - -// VK_KHR_swapchain_mutable_format is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_swapchain_mutable_format 1 -#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1 -#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format" - - -// VK_KHR_timeline_semaphore is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_timeline_semaphore 1 -#define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2 -#define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore" -typedef VkSemaphoreType VkSemaphoreTypeKHR; - -typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR; - -typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR; - -typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR; - -typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR; - -typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR; - -typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR; - -typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR; - -typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); -typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); -typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR( - VkDevice device, - VkSemaphore semaphore, - uint64_t* pValue); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR( - VkDevice device, - const VkSemaphoreWaitInfo* pWaitInfo, - uint64_t timeout); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR( - VkDevice device, - const VkSemaphoreSignalInfo* pSignalInfo); -#endif -#endif - - -// VK_KHR_vulkan_memory_model is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_vulkan_memory_model 1 -#define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3 -#define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model" -typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR; - - - -// VK_KHR_shader_terminate_invocation is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_terminate_invocation 1 -#define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1 -#define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation" -typedef VkPhysicalDeviceShaderTerminateInvocationFeatures VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR; - - - -// VK_KHR_fragment_shading_rate is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_fragment_shading_rate 1 -#define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 2 -#define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate" - -typedef enum VkFragmentShadingRateCombinerOpKHR { - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF -} VkFragmentShadingRateCombinerOpKHR; -typedef struct VkFragmentShadingRateAttachmentInfoKHR { - VkStructureType sType; - const void* pNext; - const VkAttachmentReference2* pFragmentShadingRateAttachment; - VkExtent2D shadingRateAttachmentTexelSize; -} VkFragmentShadingRateAttachmentInfoKHR; - -typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkExtent2D fragmentSize; - VkFragmentShadingRateCombinerOpKHR combinerOps[2]; -} VkPipelineFragmentShadingRateStateCreateInfoKHR; - -typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 pipelineFragmentShadingRate; - VkBool32 primitiveFragmentShadingRate; - VkBool32 attachmentFragmentShadingRate; -} VkPhysicalDeviceFragmentShadingRateFeaturesKHR; - -typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR { - VkStructureType sType; - void* pNext; - VkExtent2D minFragmentShadingRateAttachmentTexelSize; - VkExtent2D maxFragmentShadingRateAttachmentTexelSize; - uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; - VkBool32 primitiveFragmentShadingRateWithMultipleViewports; - VkBool32 layeredShadingRateAttachments; - VkBool32 fragmentShadingRateNonTrivialCombinerOps; - VkExtent2D maxFragmentSize; - uint32_t maxFragmentSizeAspectRatio; - uint32_t maxFragmentShadingRateCoverageSamples; - VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; - VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; - VkBool32 fragmentShadingRateWithSampleMask; - VkBool32 fragmentShadingRateWithShaderSampleMask; - VkBool32 fragmentShadingRateWithConservativeRasterization; - VkBool32 fragmentShadingRateWithFragmentShaderInterlock; - VkBool32 fragmentShadingRateWithCustomSampleLocations; - VkBool32 fragmentShadingRateStrictMultiplyCombiner; -} VkPhysicalDeviceFragmentShadingRatePropertiesKHR; - -typedef struct VkPhysicalDeviceFragmentShadingRateKHR { - VkStructureType sType; - void* pNext; - VkSampleCountFlags sampleCounts; - VkExtent2D fragmentSize; -} VkPhysicalDeviceFragmentShadingRateKHR; - -typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkImageLayout imageLayout; - VkExtent2D shadingRateAttachmentTexelSize; -} VkRenderingFragmentShadingRateAttachmentInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); -typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pFragmentShadingRateCount, - VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR( - VkCommandBuffer commandBuffer, - const VkExtent2D* pFragmentSize, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); -#endif -#endif - - -// VK_KHR_dynamic_rendering_local_read is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_dynamic_rendering_local_read 1 -#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION 1 -#define VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME "VK_KHR_dynamic_rendering_local_read" -typedef VkPhysicalDeviceDynamicRenderingLocalReadFeatures VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR; - -typedef VkRenderingAttachmentLocationInfo VkRenderingAttachmentLocationInfoKHR; - -typedef VkRenderingInputAttachmentIndexInfo VkRenderingInputAttachmentIndexInfoKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingAttachmentLocationsKHR)(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfo* pLocationInfo); -typedef void (VKAPI_PTR *PFN_vkCmdSetRenderingInputAttachmentIndicesKHR)(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingAttachmentLocationsKHR( - VkCommandBuffer commandBuffer, - const VkRenderingAttachmentLocationInfo* pLocationInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetRenderingInputAttachmentIndicesKHR( - VkCommandBuffer commandBuffer, - const VkRenderingInputAttachmentIndexInfo* pInputAttachmentIndexInfo); -#endif -#endif - - -// VK_KHR_shader_quad_control is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_quad_control 1 -#define VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION 1 -#define VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME "VK_KHR_shader_quad_control" -typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderQuadControl; -} VkPhysicalDeviceShaderQuadControlFeaturesKHR; - - - -// VK_KHR_spirv_1_4 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_spirv_1_4 1 -#define VK_KHR_SPIRV_1_4_SPEC_VERSION 1 -#define VK_KHR_SPIRV_1_4_EXTENSION_NAME "VK_KHR_spirv_1_4" - - -// VK_KHR_surface_protected_capabilities is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_surface_protected_capabilities 1 -#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1 -#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities" -typedef struct VkSurfaceProtectedCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 supportsProtected; -} VkSurfaceProtectedCapabilitiesKHR; - - - -// VK_KHR_separate_depth_stencil_layouts is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_separate_depth_stencil_layouts 1 -#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1 -#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts" -typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR; - -typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR; - -typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR; - - - -// VK_KHR_present_wait is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_present_wait 1 -#define VK_KHR_PRESENT_WAIT_SPEC_VERSION 1 -#define VK_KHR_PRESENT_WAIT_EXTENSION_NAME "VK_KHR_present_wait" -typedef struct VkPhysicalDevicePresentWaitFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 presentWait; -} VkPhysicalDevicePresentWaitFeaturesKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t presentId, - uint64_t timeout); -#endif -#endif - - -// VK_KHR_uniform_buffer_standard_layout is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_uniform_buffer_standard_layout 1 -#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1 -#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout" -typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; - - - -// VK_KHR_buffer_device_address is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_buffer_device_address 1 -#define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1 -#define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address" -typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR; - -typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR; - -typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR; - -typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR; - -typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR; - -typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR( - VkDevice device, - const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); -#endif -#endif - - -// VK_KHR_deferred_host_operations is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_deferred_host_operations 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR) -#define VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION 4 -#define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations" -typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation); -typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator); -typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation); -typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation); -typedef VkResult (VKAPI_PTR *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR( - VkDevice device, - const VkAllocationCallbacks* pAllocator, - VkDeferredOperationKHR* pDeferredOperation); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR( - VkDevice device, - VkDeferredOperationKHR operation, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR( - VkDevice device, - VkDeferredOperationKHR operation); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR( - VkDevice device, - VkDeferredOperationKHR operation); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR( - VkDevice device, - VkDeferredOperationKHR operation); -#endif -#endif - - -// VK_KHR_pipeline_executable_properties is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_pipeline_executable_properties 1 -#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1 -#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties" - -typedef enum VkPipelineExecutableStatisticFormatKHR { - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPipelineExecutableStatisticFormatKHR; -typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 pipelineExecutableInfo; -} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - -typedef struct VkPipelineInfoKHR { - VkStructureType sType; - const void* pNext; - VkPipeline pipeline; -} VkPipelineInfoKHR; - -typedef struct VkPipelineExecutablePropertiesKHR { - VkStructureType sType; - void* pNext; - VkShaderStageFlags stages; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - uint32_t subgroupSize; -} VkPipelineExecutablePropertiesKHR; - -typedef struct VkPipelineExecutableInfoKHR { - VkStructureType sType; - const void* pNext; - VkPipeline pipeline; - uint32_t executableIndex; -} VkPipelineExecutableInfoKHR; - -typedef union VkPipelineExecutableStatisticValueKHR { - VkBool32 b32; - int64_t i64; - uint64_t u64; - double f64; -} VkPipelineExecutableStatisticValueKHR; - -typedef struct VkPipelineExecutableStatisticKHR { - VkStructureType sType; - void* pNext; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - VkPipelineExecutableStatisticFormatKHR format; - VkPipelineExecutableStatisticValueKHR value; -} VkPipelineExecutableStatisticKHR; - -typedef struct VkPipelineExecutableInternalRepresentationKHR { - VkStructureType sType; - void* pNext; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - VkBool32 isText; - size_t dataSize; - void* pData; -} VkPipelineExecutableInternalRepresentationKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics); -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR( - VkDevice device, - const VkPipelineInfoKHR* pPipelineInfo, - uint32_t* pExecutableCount, - VkPipelineExecutablePropertiesKHR* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR( - VkDevice device, - const VkPipelineExecutableInfoKHR* pExecutableInfo, - uint32_t* pStatisticCount, - VkPipelineExecutableStatisticKHR* pStatistics); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR( - VkDevice device, - const VkPipelineExecutableInfoKHR* pExecutableInfo, - uint32_t* pInternalRepresentationCount, - VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); -#endif -#endif - - -// VK_KHR_map_memory2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_map_memory2 1 -#define VK_KHR_MAP_MEMORY_2_SPEC_VERSION 1 -#define VK_KHR_MAP_MEMORY_2_EXTENSION_NAME "VK_KHR_map_memory2" -typedef VkMemoryUnmapFlagBits VkMemoryUnmapFlagBitsKHR; - -typedef VkMemoryUnmapFlags VkMemoryUnmapFlagsKHR; - -typedef VkMemoryMapInfo VkMemoryMapInfoKHR; - -typedef VkMemoryUnmapInfo VkMemoryUnmapInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkMapMemory2KHR)(VkDevice device, const VkMemoryMapInfo* pMemoryMapInfo, void** ppData); -typedef VkResult (VKAPI_PTR *PFN_vkUnmapMemory2KHR)(VkDevice device, const VkMemoryUnmapInfo* pMemoryUnmapInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory2KHR( - VkDevice device, - const VkMemoryMapInfo* pMemoryMapInfo, - void** ppData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkUnmapMemory2KHR( - VkDevice device, - const VkMemoryUnmapInfo* pMemoryUnmapInfo); -#endif -#endif - - -// VK_KHR_shader_integer_dot_product is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_integer_dot_product 1 -#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION 1 -#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME "VK_KHR_shader_integer_dot_product" -typedef VkPhysicalDeviceShaderIntegerDotProductFeatures VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR; - -typedef VkPhysicalDeviceShaderIntegerDotProductProperties VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR; - - - -// VK_KHR_pipeline_library is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_pipeline_library 1 -#define VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION 1 -#define VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME "VK_KHR_pipeline_library" -typedef struct VkPipelineLibraryCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t libraryCount; - const VkPipeline* pLibraries; -} VkPipelineLibraryCreateInfoKHR; - - - -// VK_KHR_shader_non_semantic_info is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_non_semantic_info 1 -#define VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION 1 -#define VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME "VK_KHR_shader_non_semantic_info" - - -// VK_KHR_present_id is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_present_id 1 -#define VK_KHR_PRESENT_ID_SPEC_VERSION 1 -#define VK_KHR_PRESENT_ID_EXTENSION_NAME "VK_KHR_present_id" -typedef struct VkPresentIdKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const uint64_t* pPresentIds; -} VkPresentIdKHR; - -typedef struct VkPhysicalDevicePresentIdFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 presentId; -} VkPhysicalDevicePresentIdFeaturesKHR; - - - -// VK_KHR_video_encode_queue is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_encode_queue 1 -#define VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION 12 -#define VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME "VK_KHR_video_encode_queue" - -typedef enum VkVideoEncodeTuningModeKHR { - VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR = 0, - VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR = 1, - VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR = 2, - VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR = 3, - VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR = 4, - VK_VIDEO_ENCODE_TUNING_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeTuningModeKHR; - -typedef enum VkVideoEncodeFlagBitsKHR { - VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeFlagBitsKHR; -typedef VkFlags VkVideoEncodeFlagsKHR; - -typedef enum VkVideoEncodeCapabilityFlagBitsKHR { - VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeCapabilityFlagBitsKHR; -typedef VkFlags VkVideoEncodeCapabilityFlagsKHR; - -typedef enum VkVideoEncodeRateControlModeFlagBitsKHR { - VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR = 0, - VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_RATE_CONTROL_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeRateControlModeFlagBitsKHR; -typedef VkFlags VkVideoEncodeRateControlModeFlagsKHR; - -typedef enum VkVideoEncodeFeedbackFlagBitsKHR { - VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_FEEDBACK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeFeedbackFlagBitsKHR; -typedef VkFlags VkVideoEncodeFeedbackFlagsKHR; - -typedef enum VkVideoEncodeUsageFlagBitsKHR { - VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR = 0, - VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeUsageFlagBitsKHR; -typedef VkFlags VkVideoEncodeUsageFlagsKHR; - -typedef enum VkVideoEncodeContentFlagBitsKHR { - VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR = 0, - VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_CONTENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeContentFlagBitsKHR; -typedef VkFlags VkVideoEncodeContentFlagsKHR; -typedef VkFlags VkVideoEncodeRateControlFlagsKHR; -typedef struct VkVideoEncodeInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeFlagsKHR flags; - VkBuffer dstBuffer; - VkDeviceSize dstBufferOffset; - VkDeviceSize dstBufferRange; - VkVideoPictureResourceInfoKHR srcPictureResource; - const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; - uint32_t referenceSlotCount; - const VkVideoReferenceSlotInfoKHR* pReferenceSlots; - uint32_t precedingExternallyEncodedBytes; -} VkVideoEncodeInfoKHR; - -typedef struct VkVideoEncodeCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeCapabilityFlagsKHR flags; - VkVideoEncodeRateControlModeFlagsKHR rateControlModes; - uint32_t maxRateControlLayers; - uint64_t maxBitrate; - uint32_t maxQualityLevels; - VkExtent2D encodeInputPictureGranularity; - VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; -} VkVideoEncodeCapabilitiesKHR; - -typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; -} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR; - -typedef struct VkVideoEncodeUsageInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeUsageFlagsKHR videoUsageHints; - VkVideoEncodeContentFlagsKHR videoContentHints; - VkVideoEncodeTuningModeKHR tuningMode; -} VkVideoEncodeUsageInfoKHR; - -typedef struct VkVideoEncodeRateControlLayerInfoKHR { - VkStructureType sType; - const void* pNext; - uint64_t averageBitrate; - uint64_t maxBitrate; - uint32_t frameRateNumerator; - uint32_t frameRateDenominator; -} VkVideoEncodeRateControlLayerInfoKHR; - -typedef struct VkVideoEncodeRateControlInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeRateControlFlagsKHR flags; - VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; - uint32_t layerCount; - const VkVideoEncodeRateControlLayerInfoKHR* pLayers; - uint32_t virtualBufferSizeInMs; - uint32_t initialVirtualBufferSizeInMs; -} VkVideoEncodeRateControlInfoKHR; - -typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR { - VkStructureType sType; - const void* pNext; - const VkVideoProfileInfoKHR* pVideoProfile; - uint32_t qualityLevel; -} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR; - -typedef struct VkVideoEncodeQualityLevelPropertiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode; - uint32_t preferredRateControlLayerCount; -} VkVideoEncodeQualityLevelPropertiesKHR; - -typedef struct VkVideoEncodeQualityLevelInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t qualityLevel; -} VkVideoEncodeQualityLevelInfoKHR; - -typedef struct VkVideoEncodeSessionParametersGetInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoSessionParametersKHR videoSessionParameters; -} VkVideoEncodeSessionParametersGetInfoKHR; - -typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR { - VkStructureType sType; - void* pNext; - VkBool32 hasOverrides; -} VkVideoEncodeSessionParametersFeedbackInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetEncodedVideoSessionParametersKHR)(VkDevice device, const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdEncodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, - VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetEncodedVideoSessionParametersKHR( - VkDevice device, - const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, - VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, - size_t* pDataSize, - void* pData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdEncodeVideoKHR( - VkCommandBuffer commandBuffer, - const VkVideoEncodeInfoKHR* pEncodeInfo); -#endif -#endif - - -// VK_KHR_synchronization2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_synchronization2 1 -#define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1 -#define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2" -typedef VkPipelineStageFlags2 VkPipelineStageFlags2KHR; - -typedef VkPipelineStageFlagBits2 VkPipelineStageFlagBits2KHR; - -typedef VkAccessFlags2 VkAccessFlags2KHR; - -typedef VkAccessFlagBits2 VkAccessFlagBits2KHR; - -typedef VkSubmitFlagBits VkSubmitFlagBitsKHR; - -typedef VkSubmitFlags VkSubmitFlagsKHR; - -typedef VkMemoryBarrier2 VkMemoryBarrier2KHR; - -typedef VkBufferMemoryBarrier2 VkBufferMemoryBarrier2KHR; - -typedef VkImageMemoryBarrier2 VkImageMemoryBarrier2KHR; - -typedef VkDependencyInfo VkDependencyInfoKHR; - -typedef VkSubmitInfo2 VkSubmitInfo2KHR; - -typedef VkSemaphoreSubmitInfo VkSemaphoreSubmitInfoKHR; - -typedef VkCommandBufferSubmitInfo VkCommandBufferSubmitInfoKHR; - -typedef VkPhysicalDeviceSynchronization2Features VkPhysicalDeviceSynchronization2FeaturesKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); -typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); -typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); -typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); -typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); -typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR( - VkCommandBuffer commandBuffer, - VkEvent event, - const VkDependencyInfo* pDependencyInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags2 stageMask); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - const VkDependencyInfo* pDependencyInfos); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR( - VkCommandBuffer commandBuffer, - const VkDependencyInfo* pDependencyInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkQueryPool queryPool, - uint32_t query); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo2* pSubmits, - VkFence fence); -#endif -#endif - - -// VK_KHR_fragment_shader_barycentric is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_fragment_shader_barycentric 1 -#define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 -#define VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_KHR_fragment_shader_barycentric" -typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 fragmentShaderBarycentric; -} VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR; - -typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 triStripVertexOrderIndependentOfProvokingVertex; -} VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR; - - - -// VK_KHR_shader_subgroup_uniform_control_flow is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_subgroup_uniform_control_flow 1 -#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION 1 -#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME "VK_KHR_shader_subgroup_uniform_control_flow" -typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderSubgroupUniformControlFlow; -} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; - - - -// VK_KHR_zero_initialize_workgroup_memory is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_zero_initialize_workgroup_memory 1 -#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION 1 -#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME "VK_KHR_zero_initialize_workgroup_memory" -typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR; - - - -// VK_KHR_workgroup_memory_explicit_layout is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_workgroup_memory_explicit_layout 1 -#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION 1 -#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME "VK_KHR_workgroup_memory_explicit_layout" -typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 workgroupMemoryExplicitLayout; - VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout; - VkBool32 workgroupMemoryExplicitLayout8BitAccess; - VkBool32 workgroupMemoryExplicitLayout16BitAccess; -} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; - - - -// VK_KHR_copy_commands2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_copy_commands2 1 -#define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1 -#define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2" -typedef VkCopyBufferInfo2 VkCopyBufferInfo2KHR; - -typedef VkCopyImageInfo2 VkCopyImageInfo2KHR; - -typedef VkCopyBufferToImageInfo2 VkCopyBufferToImageInfo2KHR; - -typedef VkCopyImageToBufferInfo2 VkCopyImageToBufferInfo2KHR; - -typedef VkBlitImageInfo2 VkBlitImageInfo2KHR; - -typedef VkResolveImageInfo2 VkResolveImageInfo2KHR; - -typedef VkBufferCopy2 VkBufferCopy2KHR; - -typedef VkImageCopy2 VkImageCopy2KHR; - -typedef VkImageBlit2 VkImageBlit2KHR; - -typedef VkBufferImageCopy2 VkBufferImageCopy2KHR; - -typedef VkImageResolve2 VkImageResolve2KHR; - -typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); -typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferInfo2* pCopyBufferInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageInfo2* pCopyImageInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR( - VkCommandBuffer commandBuffer, - const VkBlitImageInfo2* pBlitImageInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR( - VkCommandBuffer commandBuffer, - const VkResolveImageInfo2* pResolveImageInfo); -#endif -#endif - - -// VK_KHR_format_feature_flags2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_format_feature_flags2 1 -#define VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION 2 -#define VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME "VK_KHR_format_feature_flags2" -typedef VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR; - -typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR; - -typedef VkFormatProperties3 VkFormatProperties3KHR; - - - -// VK_KHR_ray_tracing_maintenance1 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_ray_tracing_maintenance1 1 -#define VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION 1 -#define VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_ray_tracing_maintenance1" -typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingMaintenance1; - VkBool32 rayTracingPipelineTraceRaysIndirect2; -} VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR; - -typedef struct VkTraceRaysIndirectCommand2KHR { - VkDeviceAddress raygenShaderRecordAddress; - VkDeviceSize raygenShaderRecordSize; - VkDeviceAddress missShaderBindingTableAddress; - VkDeviceSize missShaderBindingTableSize; - VkDeviceSize missShaderBindingTableStride; - VkDeviceAddress hitShaderBindingTableAddress; - VkDeviceSize hitShaderBindingTableSize; - VkDeviceSize hitShaderBindingTableStride; - VkDeviceAddress callableShaderBindingTableAddress; - VkDeviceSize callableShaderBindingTableSize; - VkDeviceSize callableShaderBindingTableStride; - uint32_t width; - uint32_t height; - uint32_t depth; -} VkTraceRaysIndirectCommand2KHR; - -typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirect2KHR( - VkCommandBuffer commandBuffer, - VkDeviceAddress indirectDeviceAddress); -#endif -#endif - - -// VK_KHR_shader_untyped_pointers is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_untyped_pointers 1 -#define VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION 1 -#define VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME "VK_KHR_shader_untyped_pointers" -typedef struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderUntypedPointers; -} VkPhysicalDeviceShaderUntypedPointersFeaturesKHR; - - - -// VK_KHR_portability_enumeration is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_portability_enumeration 1 -#define VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION 1 -#define VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME "VK_KHR_portability_enumeration" - - -// VK_KHR_maintenance4 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_maintenance4 1 -#define VK_KHR_MAINTENANCE_4_SPEC_VERSION 2 -#define VK_KHR_MAINTENANCE_4_EXTENSION_NAME "VK_KHR_maintenance4" -typedef VkPhysicalDeviceMaintenance4Features VkPhysicalDeviceMaintenance4FeaturesKHR; - -typedef VkPhysicalDeviceMaintenance4Properties VkPhysicalDeviceMaintenance4PropertiesKHR; - -typedef VkDeviceBufferMemoryRequirements VkDeviceBufferMemoryRequirementsKHR; - -typedef VkDeviceImageMemoryRequirements VkDeviceImageMemoryRequirementsKHR; - -typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR( - VkDevice device, - const VkDeviceBufferMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -#endif -#endif - - -// VK_KHR_shader_subgroup_rotate is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_subgroup_rotate 1 -#define VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION 2 -#define VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME "VK_KHR_shader_subgroup_rotate" -typedef VkPhysicalDeviceShaderSubgroupRotateFeatures VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR; - - - -// VK_KHR_shader_maximal_reconvergence is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_maximal_reconvergence 1 -#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION 1 -#define VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME "VK_KHR_shader_maximal_reconvergence" -typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderMaximalReconvergence; -} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; - - - -// VK_KHR_maintenance5 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_maintenance5 1 -#define VK_KHR_MAINTENANCE_5_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_5_EXTENSION_NAME "VK_KHR_maintenance5" -typedef VkPipelineCreateFlags2 VkPipelineCreateFlags2KHR; - -typedef VkPipelineCreateFlagBits2 VkPipelineCreateFlagBits2KHR; - -typedef VkBufferUsageFlags2 VkBufferUsageFlags2KHR; - -typedef VkBufferUsageFlagBits2 VkBufferUsageFlagBits2KHR; - -typedef VkPhysicalDeviceMaintenance5Features VkPhysicalDeviceMaintenance5FeaturesKHR; - -typedef VkPhysicalDeviceMaintenance5Properties VkPhysicalDeviceMaintenance5PropertiesKHR; - -typedef VkRenderingAreaInfo VkRenderingAreaInfoKHR; - -typedef VkDeviceImageSubresourceInfo VkDeviceImageSubresourceInfoKHR; - -typedef VkImageSubresource2 VkImageSubresource2KHR; - -typedef VkSubresourceLayout2 VkSubresourceLayout2KHR; - -typedef VkPipelineCreateFlags2CreateInfo VkPipelineCreateFlags2CreateInfoKHR; - -typedef VkBufferUsageFlags2CreateInfo VkBufferUsageFlags2CreateInfoKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer2KHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType); -typedef void (VKAPI_PTR *PFN_vkGetRenderingAreaGranularityKHR)(VkDevice device, const VkRenderingAreaInfo* pRenderingAreaInfo, VkExtent2D* pGranularity); -typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSubresourceLayoutKHR)(VkDevice device, const VkDeviceImageSubresourceInfo* pInfo, VkSubresourceLayout2* pLayout); -typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2KHR)(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer2KHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkDeviceSize size, - VkIndexType indexType); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetRenderingAreaGranularityKHR( - VkDevice device, - const VkRenderingAreaInfo* pRenderingAreaInfo, - VkExtent2D* pGranularity); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSubresourceLayoutKHR( - VkDevice device, - const VkDeviceImageSubresourceInfo* pInfo, - VkSubresourceLayout2* pLayout); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2KHR( - VkDevice device, - VkImage image, - const VkImageSubresource2* pSubresource, - VkSubresourceLayout2* pLayout); -#endif -#endif - - -// VK_KHR_present_id2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_present_id2 1 -#define VK_KHR_PRESENT_ID_2_SPEC_VERSION 1 -#define VK_KHR_PRESENT_ID_2_EXTENSION_NAME "VK_KHR_present_id2" -typedef struct VkSurfaceCapabilitiesPresentId2KHR { - VkStructureType sType; - void* pNext; - VkBool32 presentId2Supported; -} VkSurfaceCapabilitiesPresentId2KHR; - -typedef struct VkPresentId2KHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const uint64_t* pPresentIds; -} VkPresentId2KHR; - -typedef struct VkPhysicalDevicePresentId2FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 presentId2; -} VkPhysicalDevicePresentId2FeaturesKHR; - - - -// VK_KHR_present_wait2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_present_wait2 1 -#define VK_KHR_PRESENT_WAIT_2_SPEC_VERSION 1 -#define VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME "VK_KHR_present_wait2" -typedef struct VkSurfaceCapabilitiesPresentWait2KHR { - VkStructureType sType; - void* pNext; - VkBool32 presentWait2Supported; -} VkSurfaceCapabilitiesPresentWait2KHR; - -typedef struct VkPhysicalDevicePresentWait2FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 presentWait2; -} VkPhysicalDevicePresentWait2FeaturesKHR; - -typedef struct VkPresentWait2InfoKHR { - VkStructureType sType; - const void* pNext; - uint64_t presentId; - uint64_t timeout; -} VkPresentWait2InfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresent2KHR)(VkDevice device, VkSwapchainKHR swapchain, const VkPresentWait2InfoKHR* pPresentWait2Info); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresent2KHR( - VkDevice device, - VkSwapchainKHR swapchain, - const VkPresentWait2InfoKHR* pPresentWait2Info); -#endif -#endif - - -// VK_KHR_ray_tracing_position_fetch is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_ray_tracing_position_fetch 1 -#define VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION 1 -#define VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME "VK_KHR_ray_tracing_position_fetch" -typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingPositionFetch; -} VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR; - - - -// VK_KHR_pipeline_binary is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_pipeline_binary 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineBinaryKHR) -#define VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR 32U -#define VK_KHR_PIPELINE_BINARY_SPEC_VERSION 1 -#define VK_KHR_PIPELINE_BINARY_EXTENSION_NAME "VK_KHR_pipeline_binary" -typedef struct VkPhysicalDevicePipelineBinaryFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 pipelineBinaries; -} VkPhysicalDevicePipelineBinaryFeaturesKHR; - -typedef struct VkPhysicalDevicePipelineBinaryPropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 pipelineBinaryInternalCache; - VkBool32 pipelineBinaryInternalCacheControl; - VkBool32 pipelineBinaryPrefersInternalCache; - VkBool32 pipelineBinaryPrecompiledInternalCache; - VkBool32 pipelineBinaryCompressedData; -} VkPhysicalDevicePipelineBinaryPropertiesKHR; - -typedef struct VkDevicePipelineBinaryInternalCacheControlKHR { - VkStructureType sType; - const void* pNext; - VkBool32 disableInternalCache; -} VkDevicePipelineBinaryInternalCacheControlKHR; - -typedef struct VkPipelineBinaryKeyKHR { - VkStructureType sType; - void* pNext; - uint32_t keySize; - uint8_t key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR]; -} VkPipelineBinaryKeyKHR; - -typedef struct VkPipelineBinaryDataKHR { - size_t dataSize; - void* pData; -} VkPipelineBinaryDataKHR; - -typedef struct VkPipelineBinaryKeysAndDataKHR { - uint32_t binaryCount; - const VkPipelineBinaryKeyKHR* pPipelineBinaryKeys; - const VkPipelineBinaryDataKHR* pPipelineBinaryData; -} VkPipelineBinaryKeysAndDataKHR; - -typedef struct VkPipelineCreateInfoKHR { - VkStructureType sType; - void* pNext; -} VkPipelineCreateInfoKHR; - -typedef struct VkPipelineBinaryCreateInfoKHR { - VkStructureType sType; - const void* pNext; - const VkPipelineBinaryKeysAndDataKHR* pKeysAndDataInfo; - VkPipeline pipeline; - const VkPipelineCreateInfoKHR* pPipelineCreateInfo; -} VkPipelineBinaryCreateInfoKHR; - -typedef struct VkPipelineBinaryInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t binaryCount; - const VkPipelineBinaryKHR* pPipelineBinaries; -} VkPipelineBinaryInfoKHR; - -typedef struct VkReleaseCapturedPipelineDataInfoKHR { - VkStructureType sType; - void* pNext; - VkPipeline pipeline; -} VkReleaseCapturedPipelineDataInfoKHR; - -typedef struct VkPipelineBinaryDataInfoKHR { - VkStructureType sType; - void* pNext; - VkPipelineBinaryKHR pipelineBinary; -} VkPipelineBinaryDataInfoKHR; - -typedef struct VkPipelineBinaryHandlesInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t pipelineBinaryCount; - VkPipelineBinaryKHR* pPipelineBinaries; -} VkPipelineBinaryHandlesInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineBinariesKHR)(VkDevice device, const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries); -typedef void (VKAPI_PTR *PFN_vkDestroyPipelineBinaryKHR)(VkDevice device, VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineKeyKHR)(VkDevice device, const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey); -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineBinaryDataKHR)(VkDevice device, const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData); -typedef VkResult (VKAPI_PTR *PFN_vkReleaseCapturedPipelineDataKHR)(VkDevice device, const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineBinariesKHR( - VkDevice device, - const VkPipelineBinaryCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineBinaryHandlesInfoKHR* pBinaries); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineBinaryKHR( - VkDevice device, - VkPipelineBinaryKHR pipelineBinary, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineKeyKHR( - VkDevice device, - const VkPipelineCreateInfoKHR* pPipelineCreateInfo, - VkPipelineBinaryKeyKHR* pPipelineKey); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineBinaryDataKHR( - VkDevice device, - const VkPipelineBinaryDataInfoKHR* pInfo, - VkPipelineBinaryKeyKHR* pPipelineBinaryKey, - size_t* pPipelineBinaryDataSize, - void* pPipelineBinaryData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkReleaseCapturedPipelineDataKHR( - VkDevice device, - const VkReleaseCapturedPipelineDataInfoKHR* pInfo, - const VkAllocationCallbacks* pAllocator); -#endif -#endif - - -// VK_KHR_surface_maintenance1 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_surface_maintenance1 1 -#define VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION 1 -#define VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_surface_maintenance1" - -typedef enum VkPresentScalingFlagBitsKHR { - VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR = 0x00000001, - VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR = 0x00000002, - VK_PRESENT_SCALING_STRETCH_BIT_KHR = 0x00000004, - VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR, - VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR, - VK_PRESENT_SCALING_STRETCH_BIT_EXT = VK_PRESENT_SCALING_STRETCH_BIT_KHR, - VK_PRESENT_SCALING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPresentScalingFlagBitsKHR; -typedef VkFlags VkPresentScalingFlagsKHR; - -typedef enum VkPresentGravityFlagBitsKHR { - VK_PRESENT_GRAVITY_MIN_BIT_KHR = 0x00000001, - VK_PRESENT_GRAVITY_MAX_BIT_KHR = 0x00000002, - VK_PRESENT_GRAVITY_CENTERED_BIT_KHR = 0x00000004, - VK_PRESENT_GRAVITY_MIN_BIT_EXT = VK_PRESENT_GRAVITY_MIN_BIT_KHR, - VK_PRESENT_GRAVITY_MAX_BIT_EXT = VK_PRESENT_GRAVITY_MAX_BIT_KHR, - VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR, - VK_PRESENT_GRAVITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPresentGravityFlagBitsKHR; -typedef VkFlags VkPresentGravityFlagsKHR; -typedef struct VkSurfacePresentModeKHR { - VkStructureType sType; - void* pNext; - VkPresentModeKHR presentMode; -} VkSurfacePresentModeKHR; - -typedef struct VkSurfacePresentScalingCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkPresentScalingFlagsKHR supportedPresentScaling; - VkPresentGravityFlagsKHR supportedPresentGravityX; - VkPresentGravityFlagsKHR supportedPresentGravityY; - VkExtent2D minScaledImageExtent; - VkExtent2D maxScaledImageExtent; -} VkSurfacePresentScalingCapabilitiesKHR; - -typedef struct VkSurfacePresentModeCompatibilityKHR { - VkStructureType sType; - void* pNext; - uint32_t presentModeCount; - VkPresentModeKHR* pPresentModes; -} VkSurfacePresentModeCompatibilityKHR; - - - -// VK_KHR_swapchain_maintenance1 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_swapchain_maintenance1 1 -#define VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION 1 -#define VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_swapchain_maintenance1" -typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 swapchainMaintenance1; -} VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR; - -typedef struct VkSwapchainPresentFenceInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkFence* pFences; -} VkSwapchainPresentFenceInfoKHR; - -typedef struct VkSwapchainPresentModesCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t presentModeCount; - const VkPresentModeKHR* pPresentModes; -} VkSwapchainPresentModesCreateInfoKHR; - -typedef struct VkSwapchainPresentModeInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentModeKHR* pPresentModes; -} VkSwapchainPresentModeInfoKHR; - -typedef struct VkSwapchainPresentScalingCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkPresentScalingFlagsKHR scalingBehavior; - VkPresentGravityFlagsKHR presentGravityX; - VkPresentGravityFlagsKHR presentGravityY; -} VkSwapchainPresentScalingCreateInfoKHR; - -typedef struct VkReleaseSwapchainImagesInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - uint32_t imageIndexCount; - const uint32_t* pImageIndices; -} VkReleaseSwapchainImagesInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesKHR)(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesKHR( - VkDevice device, - const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); -#endif -#endif - - -// VK_KHR_internally_synchronized_queues is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_internally_synchronized_queues 1 -#define VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_SPEC_VERSION 1 -#define VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME "VK_KHR_internally_synchronized_queues" -typedef struct VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 internallySynchronizedQueues; -} VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; - - - -// VK_KHR_cooperative_matrix is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_cooperative_matrix 1 -#define VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION 2 -#define VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_KHR_cooperative_matrix" - -typedef enum VkComponentTypeKHR { - VK_COMPONENT_TYPE_FLOAT16_KHR = 0, - VK_COMPONENT_TYPE_FLOAT32_KHR = 1, - VK_COMPONENT_TYPE_FLOAT64_KHR = 2, - VK_COMPONENT_TYPE_SINT8_KHR = 3, - VK_COMPONENT_TYPE_SINT16_KHR = 4, - VK_COMPONENT_TYPE_SINT32_KHR = 5, - VK_COMPONENT_TYPE_SINT64_KHR = 6, - VK_COMPONENT_TYPE_UINT8_KHR = 7, - VK_COMPONENT_TYPE_UINT16_KHR = 8, - VK_COMPONENT_TYPE_UINT32_KHR = 9, - VK_COMPONENT_TYPE_UINT64_KHR = 10, - VK_COMPONENT_TYPE_BFLOAT16_KHR = 1000141000, - VK_COMPONENT_TYPE_SINT8_PACKED_NV = 1000491000, - VK_COMPONENT_TYPE_UINT8_PACKED_NV = 1000491001, - VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT = 1000491002, - VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT = 1000491003, - VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR, - VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR, - VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR, - VK_COMPONENT_TYPE_SINT8_NV = VK_COMPONENT_TYPE_SINT8_KHR, - VK_COMPONENT_TYPE_SINT16_NV = VK_COMPONENT_TYPE_SINT16_KHR, - VK_COMPONENT_TYPE_SINT32_NV = VK_COMPONENT_TYPE_SINT32_KHR, - VK_COMPONENT_TYPE_SINT64_NV = VK_COMPONENT_TYPE_SINT64_KHR, - VK_COMPONENT_TYPE_UINT8_NV = VK_COMPONENT_TYPE_UINT8_KHR, - VK_COMPONENT_TYPE_UINT16_NV = VK_COMPONENT_TYPE_UINT16_KHR, - VK_COMPONENT_TYPE_UINT32_NV = VK_COMPONENT_TYPE_UINT32_KHR, - VK_COMPONENT_TYPE_UINT64_NV = VK_COMPONENT_TYPE_UINT64_KHR, - VK_COMPONENT_TYPE_FLOAT_E4M3_NV = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT, - VK_COMPONENT_TYPE_FLOAT_E5M2_NV = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT, - VK_COMPONENT_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkComponentTypeKHR; - -typedef enum VkScopeKHR { - VK_SCOPE_DEVICE_KHR = 1, - VK_SCOPE_WORKGROUP_KHR = 2, - VK_SCOPE_SUBGROUP_KHR = 3, - VK_SCOPE_QUEUE_FAMILY_KHR = 5, - VK_SCOPE_DEVICE_NV = VK_SCOPE_DEVICE_KHR, - VK_SCOPE_WORKGROUP_NV = VK_SCOPE_WORKGROUP_KHR, - VK_SCOPE_SUBGROUP_NV = VK_SCOPE_SUBGROUP_KHR, - VK_SCOPE_QUEUE_FAMILY_NV = VK_SCOPE_QUEUE_FAMILY_KHR, - VK_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkScopeKHR; -typedef struct VkCooperativeMatrixPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t MSize; - uint32_t NSize; - uint32_t KSize; - VkComponentTypeKHR AType; - VkComponentTypeKHR BType; - VkComponentTypeKHR CType; - VkComponentTypeKHR ResultType; - VkBool32 saturatingAccumulation; - VkScopeKHR scope; -} VkCooperativeMatrixPropertiesKHR; - -typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 cooperativeMatrix; - VkBool32 cooperativeMatrixRobustBufferAccess; -} VkPhysicalDeviceCooperativeMatrixFeaturesKHR; - -typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR { - VkStructureType sType; - void* pNext; - VkShaderStageFlags cooperativeMatrixSupportedStages; -} VkPhysicalDeviceCooperativeMatrixPropertiesKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeMatrixPropertiesKHR* pProperties); -#endif -#endif - - -// VK_KHR_compute_shader_derivatives is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_compute_shader_derivatives 1 -#define VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 -#define VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_KHR_compute_shader_derivatives" -typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 computeDerivativeGroupQuads; - VkBool32 computeDerivativeGroupLinear; -} VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR; - -typedef struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 meshAndTaskShaderDerivatives; -} VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR; - - - -// VK_KHR_video_decode_av1 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_decode_av1 1 -#include "vk_video/vulkan_video_codec_av1std.h" -#include "vk_video/vulkan_video_codec_av1std_decode.h" -#define VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR 7U -#define VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION 1 -#define VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME "VK_KHR_video_decode_av1" -typedef struct VkVideoDecodeAV1ProfileInfoKHR { - VkStructureType sType; - const void* pNext; - StdVideoAV1Profile stdProfile; - VkBool32 filmGrainSupport; -} VkVideoDecodeAV1ProfileInfoKHR; - -typedef struct VkVideoDecodeAV1CapabilitiesKHR { - VkStructureType sType; - void* pNext; - StdVideoAV1Level maxLevel; -} VkVideoDecodeAV1CapabilitiesKHR; - -typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoAV1SequenceHeader* pStdSequenceHeader; -} VkVideoDecodeAV1SessionParametersCreateInfoKHR; - -typedef struct VkVideoDecodeAV1PictureInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoDecodeAV1PictureInfo* pStdPictureInfo; - int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; - uint32_t frameHeaderOffset; - uint32_t tileCount; - const uint32_t* pTileOffsets; - const uint32_t* pTileSizes; -} VkVideoDecodeAV1PictureInfoKHR; - -typedef struct VkVideoDecodeAV1DpbSlotInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoDecodeAV1ReferenceInfo* pStdReferenceInfo; -} VkVideoDecodeAV1DpbSlotInfoKHR; - - - -// VK_KHR_video_encode_av1 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_encode_av1 1 -#include "vk_video/vulkan_video_codec_av1std_encode.h" -#define VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION 1 -#define VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME "VK_KHR_video_encode_av1" - -typedef enum VkVideoEncodeAV1PredictionModeKHR { - VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR = 0, - VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR = 1, - VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR = 2, - VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR = 3, - VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeAV1PredictionModeKHR; - -typedef enum VkVideoEncodeAV1RateControlGroupKHR { - VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR = 0, - VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR = 1, - VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR = 2, - VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeAV1RateControlGroupKHR; - -typedef enum VkVideoEncodeAV1CapabilityFlagBitsKHR { - VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR = 0x00000010, - VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR = 0x00000020, - VK_VIDEO_ENCODE_AV1_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeAV1CapabilityFlagBitsKHR; -typedef VkFlags VkVideoEncodeAV1CapabilityFlagsKHR; - -typedef enum VkVideoEncodeAV1StdFlagBitsKHR { - VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_AV1_STD_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeAV1StdFlagBitsKHR; -typedef VkFlags VkVideoEncodeAV1StdFlagsKHR; - -typedef enum VkVideoEncodeAV1SuperblockSizeFlagBitsKHR { - VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeAV1SuperblockSizeFlagBitsKHR; -typedef VkFlags VkVideoEncodeAV1SuperblockSizeFlagsKHR; - -typedef enum VkVideoEncodeAV1RateControlFlagBitsKHR { - VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_AV1_RATE_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeAV1RateControlFlagBitsKHR; -typedef VkFlags VkVideoEncodeAV1RateControlFlagsKHR; -typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 videoEncodeAV1; -} VkPhysicalDeviceVideoEncodeAV1FeaturesKHR; - -typedef struct VkVideoEncodeAV1CapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeAV1CapabilityFlagsKHR flags; - StdVideoAV1Level maxLevel; - VkExtent2D codedPictureAlignment; - VkExtent2D maxTiles; - VkExtent2D minTileSize; - VkExtent2D maxTileSize; - VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes; - uint32_t maxSingleReferenceCount; - uint32_t singleReferenceNameMask; - uint32_t maxUnidirectionalCompoundReferenceCount; - uint32_t maxUnidirectionalCompoundGroup1ReferenceCount; - uint32_t unidirectionalCompoundReferenceNameMask; - uint32_t maxBidirectionalCompoundReferenceCount; - uint32_t maxBidirectionalCompoundGroup1ReferenceCount; - uint32_t maxBidirectionalCompoundGroup2ReferenceCount; - uint32_t bidirectionalCompoundReferenceNameMask; - uint32_t maxTemporalLayerCount; - uint32_t maxSpatialLayerCount; - uint32_t maxOperatingPoints; - uint32_t minQIndex; - uint32_t maxQIndex; - VkBool32 prefersGopRemainingFrames; - VkBool32 requiresGopRemainingFrames; - VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags; -} VkVideoEncodeAV1CapabilitiesKHR; - -typedef struct VkVideoEncodeAV1QIndexKHR { - uint32_t intraQIndex; - uint32_t predictiveQIndex; - uint32_t bipredictiveQIndex; -} VkVideoEncodeAV1QIndexKHR; - -typedef struct VkVideoEncodeAV1QualityLevelPropertiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags; - uint32_t preferredGopFrameCount; - uint32_t preferredKeyFramePeriod; - uint32_t preferredConsecutiveBipredictiveFrameCount; - uint32_t preferredTemporalLayerCount; - VkVideoEncodeAV1QIndexKHR preferredConstantQIndex; - uint32_t preferredMaxSingleReferenceCount; - uint32_t preferredSingleReferenceNameMask; - uint32_t preferredMaxUnidirectionalCompoundReferenceCount; - uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount; - uint32_t preferredUnidirectionalCompoundReferenceNameMask; - uint32_t preferredMaxBidirectionalCompoundReferenceCount; - uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount; - uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount; - uint32_t preferredBidirectionalCompoundReferenceNameMask; -} VkVideoEncodeAV1QualityLevelPropertiesKHR; - -typedef struct VkVideoEncodeAV1SessionCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkBool32 useMaxLevel; - StdVideoAV1Level maxLevel; -} VkVideoEncodeAV1SessionCreateInfoKHR; - -typedef struct VkVideoEncodeAV1SessionParametersCreateInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoAV1SequenceHeader* pStdSequenceHeader; - const StdVideoEncodeAV1DecoderModelInfo* pStdDecoderModelInfo; - uint32_t stdOperatingPointCount; - const StdVideoEncodeAV1OperatingPointInfo* pStdOperatingPoints; -} VkVideoEncodeAV1SessionParametersCreateInfoKHR; - -typedef struct VkVideoEncodeAV1PictureInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeAV1PredictionModeKHR predictionMode; - VkVideoEncodeAV1RateControlGroupKHR rateControlGroup; - uint32_t constantQIndex; - const StdVideoEncodeAV1PictureInfo* pStdPictureInfo; - int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; - VkBool32 primaryReferenceCdfOnly; - VkBool32 generateObuExtensionHeader; -} VkVideoEncodeAV1PictureInfoKHR; - -typedef struct VkVideoEncodeAV1DpbSlotInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoEncodeAV1ReferenceInfo* pStdReferenceInfo; -} VkVideoEncodeAV1DpbSlotInfoKHR; - -typedef struct VkVideoEncodeAV1ProfileInfoKHR { - VkStructureType sType; - const void* pNext; - StdVideoAV1Profile stdProfile; -} VkVideoEncodeAV1ProfileInfoKHR; - -typedef struct VkVideoEncodeAV1FrameSizeKHR { - uint32_t intraFrameSize; - uint32_t predictiveFrameSize; - uint32_t bipredictiveFrameSize; -} VkVideoEncodeAV1FrameSizeKHR; - -typedef struct VkVideoEncodeAV1GopRemainingFrameInfoKHR { - VkStructureType sType; - const void* pNext; - VkBool32 useGopRemainingFrames; - uint32_t gopRemainingIntra; - uint32_t gopRemainingPredictive; - uint32_t gopRemainingBipredictive; -} VkVideoEncodeAV1GopRemainingFrameInfoKHR; - -typedef struct VkVideoEncodeAV1RateControlInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeAV1RateControlFlagsKHR flags; - uint32_t gopFrameCount; - uint32_t keyFramePeriod; - uint32_t consecutiveBipredictiveFrameCount; - uint32_t temporalLayerCount; -} VkVideoEncodeAV1RateControlInfoKHR; - -typedef struct VkVideoEncodeAV1RateControlLayerInfoKHR { - VkStructureType sType; - const void* pNext; - VkBool32 useMinQIndex; - VkVideoEncodeAV1QIndexKHR minQIndex; - VkBool32 useMaxQIndex; - VkVideoEncodeAV1QIndexKHR maxQIndex; - VkBool32 useMaxFrameSize; - VkVideoEncodeAV1FrameSizeKHR maxFrameSize; -} VkVideoEncodeAV1RateControlLayerInfoKHR; - - - -// VK_KHR_video_decode_vp9 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_decode_vp9 1 -#include "vk_video/vulkan_video_codec_vp9std.h" -#include "vk_video/vulkan_video_codec_vp9std_decode.h" -#define VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR 3U -#define VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION 1 -#define VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME "VK_KHR_video_decode_vp9" -typedef struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 videoDecodeVP9; -} VkPhysicalDeviceVideoDecodeVP9FeaturesKHR; - -typedef struct VkVideoDecodeVP9ProfileInfoKHR { - VkStructureType sType; - const void* pNext; - StdVideoVP9Profile stdProfile; -} VkVideoDecodeVP9ProfileInfoKHR; - -typedef struct VkVideoDecodeVP9CapabilitiesKHR { - VkStructureType sType; - void* pNext; - StdVideoVP9Level maxLevel; -} VkVideoDecodeVP9CapabilitiesKHR; - -typedef struct VkVideoDecodeVP9PictureInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoDecodeVP9PictureInfo* pStdPictureInfo; - int32_t referenceNameSlotIndices[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR]; - uint32_t uncompressedHeaderOffset; - uint32_t compressedHeaderOffset; - uint32_t tilesOffset; -} VkVideoDecodeVP9PictureInfoKHR; - - - -// VK_KHR_video_maintenance1 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_maintenance1 1 -#define VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION 1 -#define VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_video_maintenance1" -typedef struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 videoMaintenance1; -} VkPhysicalDeviceVideoMaintenance1FeaturesKHR; - -typedef struct VkVideoInlineQueryInfoKHR { - VkStructureType sType; - const void* pNext; - VkQueryPool queryPool; - uint32_t firstQuery; - uint32_t queryCount; -} VkVideoInlineQueryInfoKHR; - - - -// VK_KHR_vertex_attribute_divisor is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_vertex_attribute_divisor 1 -#define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 1 -#define VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_KHR_vertex_attribute_divisor" -typedef VkPhysicalDeviceVertexAttributeDivisorProperties VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR; - -typedef VkVertexInputBindingDivisorDescription VkVertexInputBindingDivisorDescriptionKHR; - -typedef VkPipelineVertexInputDivisorStateCreateInfo VkPipelineVertexInputDivisorStateCreateInfoKHR; - -typedef VkPhysicalDeviceVertexAttributeDivisorFeatures VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR; - - - -// VK_KHR_load_store_op_none is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_load_store_op_none 1 -#define VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION 1 -#define VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_KHR_load_store_op_none" - - -// VK_KHR_unified_image_layouts is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_unified_image_layouts 1 -#define VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION 1 -#define VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME "VK_KHR_unified_image_layouts" -typedef struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 unifiedImageLayouts; - VkBool32 unifiedImageLayoutsVideo; -} VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR; - -typedef struct VkAttachmentFeedbackLoopInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 feedbackLoopEnable; -} VkAttachmentFeedbackLoopInfoEXT; - - - -// VK_KHR_shader_float_controls2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_float_controls2 1 -#define VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION 1 -#define VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME "VK_KHR_shader_float_controls2" -typedef VkPhysicalDeviceShaderFloatControls2Features VkPhysicalDeviceShaderFloatControls2FeaturesKHR; - - - -// VK_KHR_index_type_uint8 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_index_type_uint8 1 -#define VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION 1 -#define VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_KHR_index_type_uint8" -typedef VkPhysicalDeviceIndexTypeUint8Features VkPhysicalDeviceIndexTypeUint8FeaturesKHR; - - - -// VK_KHR_line_rasterization is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_line_rasterization 1 -#define VK_KHR_LINE_RASTERIZATION_SPEC_VERSION 1 -#define VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME "VK_KHR_line_rasterization" -typedef VkLineRasterizationMode VkLineRasterizationModeKHR; - -typedef VkPhysicalDeviceLineRasterizationFeatures VkPhysicalDeviceLineRasterizationFeaturesKHR; - -typedef VkPhysicalDeviceLineRasterizationProperties VkPhysicalDeviceLineRasterizationPropertiesKHR; - -typedef VkPipelineRasterizationLineStateCreateInfo VkPipelineRasterizationLineStateCreateInfoKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleKHR)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleKHR( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern); -#endif -#endif - - -// VK_KHR_calibrated_timestamps is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_calibrated_timestamps 1 -#define VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION 1 -#define VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_KHR_calibrated_timestamps" - -typedef enum VkTimeDomainKHR { - VK_TIME_DOMAIN_DEVICE_KHR = 0, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR = 1, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR = 2, - VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR = 3, - VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT = 1000208000, - VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT = 1000208001, - VK_TIME_DOMAIN_DEVICE_EXT = VK_TIME_DOMAIN_DEVICE_KHR, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR, - VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR, - VK_TIME_DOMAIN_MAX_ENUM_KHR = 0x7FFFFFFF -} VkTimeDomainKHR; -typedef struct VkCalibratedTimestampInfoKHR { - VkStructureType sType; - const void* pNext; - VkTimeDomainKHR timeDomain; -} VkCalibratedTimestampInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains); -typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsKHR)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pTimeDomainCount, - VkTimeDomainKHR* pTimeDomains); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsKHR( - VkDevice device, - uint32_t timestampCount, - const VkCalibratedTimestampInfoKHR* pTimestampInfos, - uint64_t* pTimestamps, - uint64_t* pMaxDeviation); -#endif -#endif - - -// VK_KHR_shader_expect_assume is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_expect_assume 1 -#define VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION 1 -#define VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME "VK_KHR_shader_expect_assume" -typedef VkPhysicalDeviceShaderExpectAssumeFeatures VkPhysicalDeviceShaderExpectAssumeFeaturesKHR; - - - -// VK_KHR_maintenance6 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_maintenance6 1 -#define VK_KHR_MAINTENANCE_6_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_6_EXTENSION_NAME "VK_KHR_maintenance6" -typedef VkPhysicalDeviceMaintenance6Features VkPhysicalDeviceMaintenance6FeaturesKHR; - -typedef VkPhysicalDeviceMaintenance6Properties VkPhysicalDeviceMaintenance6PropertiesKHR; - -typedef VkBindMemoryStatus VkBindMemoryStatusKHR; - -typedef VkBindDescriptorSetsInfo VkBindDescriptorSetsInfoKHR; - -typedef VkPushConstantsInfo VkPushConstantsInfoKHR; - -typedef VkPushDescriptorSetInfo VkPushDescriptorSetInfoKHR; - -typedef VkPushDescriptorSetWithTemplateInfo VkPushDescriptorSetWithTemplateInfoKHR; - -typedef struct VkSetDescriptorBufferOffsetsInfoEXT { - VkStructureType sType; - const void* pNext; - VkShaderStageFlags stageFlags; - VkPipelineLayout layout; - uint32_t firstSet; - uint32_t setCount; - const uint32_t* pBufferIndices; - const VkDeviceSize* pOffsets; -} VkSetDescriptorBufferOffsetsInfoEXT; - -typedef struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT { - VkStructureType sType; - const void* pNext; - VkShaderStageFlags stageFlags; - VkPipelineLayout layout; - uint32_t set; -} VkBindDescriptorBufferEmbeddedSamplersInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets2KHR)(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); -typedef void (VKAPI_PTR *PFN_vkCmdPushConstants2KHR)(VkCommandBuffer commandBuffer, const VkPushConstantsInfo* pPushConstantsInfo); -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSet2KHR)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); -typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplate2KHR)(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); -typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsets2EXT)(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT)(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets2KHR( - VkCommandBuffer commandBuffer, - const VkBindDescriptorSetsInfo* pBindDescriptorSetsInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants2KHR( - VkCommandBuffer commandBuffer, - const VkPushConstantsInfo* pPushConstantsInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSet2KHR( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetInfo* pPushDescriptorSetInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplate2KHR( - VkCommandBuffer commandBuffer, - const VkPushDescriptorSetWithTemplateInfo* pPushDescriptorSetWithTemplateInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsets2EXT( - VkCommandBuffer commandBuffer, - const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( - VkCommandBuffer commandBuffer, - const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo); -#endif -#endif - - -// VK_KHR_copy_memory_indirect is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_copy_memory_indirect 1 -#define VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION 1 -#define VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_KHR_copy_memory_indirect" - -typedef enum VkAddressCopyFlagBitsKHR { - VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR = 0x00000001, - VK_ADDRESS_COPY_SPARSE_BIT_KHR = 0x00000002, - VK_ADDRESS_COPY_PROTECTED_BIT_KHR = 0x00000004, - VK_ADDRESS_COPY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAddressCopyFlagBitsKHR; -typedef VkFlags VkAddressCopyFlagsKHR; -typedef struct VkStridedDeviceAddressRangeKHR { - VkDeviceAddress address; - VkDeviceSize size; - VkDeviceSize stride; -} VkStridedDeviceAddressRangeKHR; - -typedef struct VkCopyMemoryIndirectCommandKHR { - VkDeviceAddress srcAddress; - VkDeviceAddress dstAddress; - VkDeviceSize size; -} VkCopyMemoryIndirectCommandKHR; - -typedef struct VkCopyMemoryIndirectInfoKHR { - VkStructureType sType; - const void* pNext; - VkAddressCopyFlagsKHR srcCopyFlags; - VkAddressCopyFlagsKHR dstCopyFlags; - uint32_t copyCount; - VkStridedDeviceAddressRangeKHR copyAddressRange; -} VkCopyMemoryIndirectInfoKHR; - -typedef struct VkCopyMemoryToImageIndirectCommandKHR { - VkDeviceAddress srcAddress; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkCopyMemoryToImageIndirectCommandKHR; - -typedef struct VkCopyMemoryToImageIndirectInfoKHR { - VkStructureType sType; - const void* pNext; - VkAddressCopyFlagsKHR srcCopyFlags; - uint32_t copyCount; - VkStridedDeviceAddressRangeKHR copyAddressRange; - VkImage dstImage; - VkImageLayout dstImageLayout; - const VkImageSubresourceLayers* pImageSubresources; -} VkCopyMemoryToImageIndirectInfoKHR; - -typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 indirectMemoryCopy; - VkBool32 indirectMemoryToImageCopy; -} VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR; - -typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR { - VkStructureType sType; - void* pNext; - VkQueueFlags supportedQueues; -} VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectKHR( - VkCommandBuffer commandBuffer, - const VkCopyMemoryIndirectInfoKHR* pCopyMemoryIndirectInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectKHR( - VkCommandBuffer commandBuffer, - const VkCopyMemoryToImageIndirectInfoKHR* pCopyMemoryToImageIndirectInfo); -#endif -#endif - - -// VK_KHR_video_encode_intra_refresh is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_encode_intra_refresh 1 -#define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION 1 -#define VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME "VK_KHR_video_encode_intra_refresh" - -typedef enum VkVideoEncodeIntraRefreshModeFlagBitsKHR { - VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR = 0, - VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR = 0x00000001, - VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR = 0x00000002, - VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR = 0x00000004, - VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR = 0x00000008, - VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoEncodeIntraRefreshModeFlagBitsKHR; -typedef VkFlags VkVideoEncodeIntraRefreshModeFlagsKHR; -typedef struct VkVideoEncodeIntraRefreshCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes; - uint32_t maxIntraRefreshCycleDuration; - uint32_t maxIntraRefreshActiveReferencePictures; - VkBool32 partitionIndependentIntraRefreshRegions; - VkBool32 nonRectangularIntraRefreshRegions; -} VkVideoEncodeIntraRefreshCapabilitiesKHR; - -typedef struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode; -} VkVideoEncodeSessionIntraRefreshCreateInfoKHR; - -typedef struct VkVideoEncodeIntraRefreshInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t intraRefreshCycleDuration; - uint32_t intraRefreshIndex; -} VkVideoEncodeIntraRefreshInfoKHR; - -typedef struct VkVideoReferenceIntraRefreshInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t dirtyIntraRefreshRegions; -} VkVideoReferenceIntraRefreshInfoKHR; - -typedef struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 videoEncodeIntraRefresh; -} VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; - - - -// VK_KHR_video_encode_quantization_map is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_encode_quantization_map 1 -#define VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION 2 -#define VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME "VK_KHR_video_encode_quantization_map" -typedef struct VkVideoEncodeQuantizationMapCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkExtent2D maxQuantizationMapExtent; -} VkVideoEncodeQuantizationMapCapabilitiesKHR; - -typedef struct VkVideoFormatQuantizationMapPropertiesKHR { - VkStructureType sType; - void* pNext; - VkExtent2D quantizationMapTexelSize; -} VkVideoFormatQuantizationMapPropertiesKHR; - -typedef struct VkVideoEncodeQuantizationMapInfoKHR { - VkStructureType sType; - const void* pNext; - VkImageView quantizationMap; - VkExtent2D quantizationMapExtent; -} VkVideoEncodeQuantizationMapInfoKHR; - -typedef struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkExtent2D quantizationMapTexelSize; -} VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR; - -typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 videoEncodeQuantizationMap; -} VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; - -typedef struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR { - VkStructureType sType; - void* pNext; - int32_t minQpDelta; - int32_t maxQpDelta; -} VkVideoEncodeH264QuantizationMapCapabilitiesKHR; - -typedef struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR { - VkStructureType sType; - void* pNext; - int32_t minQpDelta; - int32_t maxQpDelta; -} VkVideoEncodeH265QuantizationMapCapabilitiesKHR; - -typedef struct VkVideoFormatH265QuantizationMapPropertiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes; -} VkVideoFormatH265QuantizationMapPropertiesKHR; - -typedef struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR { - VkStructureType sType; - void* pNext; - int32_t minQIndexDelta; - int32_t maxQIndexDelta; -} VkVideoEncodeAV1QuantizationMapCapabilitiesKHR; - -typedef struct VkVideoFormatAV1QuantizationMapPropertiesKHR { - VkStructureType sType; - void* pNext; - VkVideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes; -} VkVideoFormatAV1QuantizationMapPropertiesKHR; - - - -// VK_KHR_shader_relaxed_extended_instruction is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_relaxed_extended_instruction 1 -#define VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION 1 -#define VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME "VK_KHR_shader_relaxed_extended_instruction" -typedef struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderRelaxedExtendedInstruction; -} VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; - - - -// VK_KHR_maintenance7 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_maintenance7 1 -#define VK_KHR_MAINTENANCE_7_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_7_EXTENSION_NAME "VK_KHR_maintenance7" - -typedef enum VkPhysicalDeviceLayeredApiKHR { - VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR = 0, - VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR = 1, - VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR = 2, - VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR = 3, - VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR = 4, - VK_PHYSICAL_DEVICE_LAYERED_API_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPhysicalDeviceLayeredApiKHR; -typedef struct VkPhysicalDeviceMaintenance7FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 maintenance7; -} VkPhysicalDeviceMaintenance7FeaturesKHR; - -typedef struct VkPhysicalDeviceMaintenance7PropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 robustFragmentShadingRateAttachmentAccess; - VkBool32 separateDepthStencilAttachmentAccess; - uint32_t maxDescriptorSetTotalUniformBuffersDynamic; - uint32_t maxDescriptorSetTotalStorageBuffersDynamic; - uint32_t maxDescriptorSetTotalBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindTotalBuffersDynamic; -} VkPhysicalDeviceMaintenance7PropertiesKHR; - -typedef struct VkPhysicalDeviceLayeredApiPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t vendorID; - uint32_t deviceID; - VkPhysicalDeviceLayeredApiKHR layeredAPI; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; -} VkPhysicalDeviceLayeredApiPropertiesKHR; - -typedef struct VkPhysicalDeviceLayeredApiPropertiesListKHR { - VkStructureType sType; - void* pNext; - uint32_t layeredApiCount; - VkPhysicalDeviceLayeredApiPropertiesKHR* pLayeredApis; -} VkPhysicalDeviceLayeredApiPropertiesListKHR; - -typedef struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceProperties2 properties; -} VkPhysicalDeviceLayeredApiVulkanPropertiesKHR; - - - -// VK_KHR_maintenance8 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_maintenance8 1 -#define VK_KHR_MAINTENANCE_8_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_8_EXTENSION_NAME "VK_KHR_maintenance8" -typedef VkFlags64 VkAccessFlags3KHR; - -// Flag bits for VkAccessFlagBits3KHR -typedef VkFlags64 VkAccessFlagBits3KHR; -static const VkAccessFlagBits3KHR VK_ACCESS_3_NONE_KHR = 0ULL; - -typedef struct VkMemoryBarrierAccessFlags3KHR { - VkStructureType sType; - const void* pNext; - VkAccessFlags3KHR srcAccessMask3; - VkAccessFlags3KHR dstAccessMask3; -} VkMemoryBarrierAccessFlags3KHR; - -typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 maintenance8; -} VkPhysicalDeviceMaintenance8FeaturesKHR; - - - -// VK_KHR_shader_fma is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_shader_fma 1 -#define VK_KHR_SHADER_FMA_SPEC_VERSION 1 -#define VK_KHR_SHADER_FMA_EXTENSION_NAME "VK_KHR_shader_fma" -typedef struct VkPhysicalDeviceShaderFmaFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderFmaFloat16; - VkBool32 shaderFmaFloat32; - VkBool32 shaderFmaFloat64; -} VkPhysicalDeviceShaderFmaFeaturesKHR; - - - -// VK_KHR_maintenance9 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_maintenance9 1 -#define VK_KHR_MAINTENANCE_9_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_9_EXTENSION_NAME "VK_KHR_maintenance9" - -typedef enum VkDefaultVertexAttributeValueKHR { - VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR = 0, - VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR = 1, - VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkDefaultVertexAttributeValueKHR; -typedef struct VkPhysicalDeviceMaintenance9FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 maintenance9; -} VkPhysicalDeviceMaintenance9FeaturesKHR; - -typedef struct VkPhysicalDeviceMaintenance9PropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 image2DViewOf3DSparse; - VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue; -} VkPhysicalDeviceMaintenance9PropertiesKHR; - -typedef struct VkQueueFamilyOwnershipTransferPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t optimalImageTransferToQueueFamilies; -} VkQueueFamilyOwnershipTransferPropertiesKHR; - - - -// VK_KHR_video_maintenance2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_video_maintenance2 1 -#define VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION 1 -#define VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_video_maintenance2" -typedef struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 videoMaintenance2; -} VkPhysicalDeviceVideoMaintenance2FeaturesKHR; - -typedef struct VkVideoDecodeH264InlineSessionParametersInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoH264SequenceParameterSet* pStdSPS; - const StdVideoH264PictureParameterSet* pStdPPS; -} VkVideoDecodeH264InlineSessionParametersInfoKHR; - -typedef struct VkVideoDecodeH265InlineSessionParametersInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoH265VideoParameterSet* pStdVPS; - const StdVideoH265SequenceParameterSet* pStdSPS; - const StdVideoH265PictureParameterSet* pStdPPS; -} VkVideoDecodeH265InlineSessionParametersInfoKHR; - -typedef struct VkVideoDecodeAV1InlineSessionParametersInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoAV1SequenceHeader* pStdSequenceHeader; -} VkVideoDecodeAV1InlineSessionParametersInfoKHR; - - - -// VK_KHR_depth_clamp_zero_one is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_depth_clamp_zero_one 1 -#define VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1 -#define VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_KHR_depth_clamp_zero_one" -typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 depthClampZeroOne; -} VkPhysicalDeviceDepthClampZeroOneFeaturesKHR; - - - -// VK_KHR_robustness2 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_robustness2 1 -#define VK_KHR_ROBUSTNESS_2_SPEC_VERSION 1 -#define VK_KHR_ROBUSTNESS_2_EXTENSION_NAME "VK_KHR_robustness2" -typedef struct VkPhysicalDeviceRobustness2FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 robustBufferAccess2; - VkBool32 robustImageAccess2; - VkBool32 nullDescriptor; -} VkPhysicalDeviceRobustness2FeaturesKHR; - -typedef struct VkPhysicalDeviceRobustness2PropertiesKHR { - VkStructureType sType; - void* pNext; - VkDeviceSize robustStorageBufferAccessSizeAlignment; - VkDeviceSize robustUniformBufferAccessSizeAlignment; -} VkPhysicalDeviceRobustness2PropertiesKHR; - - - -// VK_KHR_present_mode_fifo_latest_ready is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_present_mode_fifo_latest_ready 1 -#define VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION 1 -#define VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME "VK_KHR_present_mode_fifo_latest_ready" -typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 presentModeFifoLatestReady; -} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; - - - -// VK_KHR_maintenance10 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_maintenance10 1 -#define VK_KHR_MAINTENANCE_10_SPEC_VERSION 1 -#define VK_KHR_MAINTENANCE_10_EXTENSION_NAME "VK_KHR_maintenance10" - -typedef enum VkRenderingAttachmentFlagBitsKHR { - VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR = 0x00000001, - VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 0x00000002, - VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 0x00000004, - VK_RENDERING_ATTACHMENT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkRenderingAttachmentFlagBitsKHR; -typedef VkFlags VkRenderingAttachmentFlagsKHR; - -typedef enum VkResolveImageFlagBitsKHR { - VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR = 0x00000001, - VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR = 0x00000002, - VK_RESOLVE_IMAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkResolveImageFlagBitsKHR; -typedef VkFlags VkResolveImageFlagsKHR; -typedef struct VkPhysicalDeviceMaintenance10FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 maintenance10; -} VkPhysicalDeviceMaintenance10FeaturesKHR; - -typedef struct VkPhysicalDeviceMaintenance10PropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 rgba4OpaqueBlackSwizzled; - VkBool32 resolveSrgbFormatAppliesTransferFunction; - VkBool32 resolveSrgbFormatSupportsTransferFunctionControl; -} VkPhysicalDeviceMaintenance10PropertiesKHR; - -typedef struct VkRenderingEndInfoKHR { - VkStructureType sType; - const void* pNext; -} VkRenderingEndInfoKHR; - -typedef struct VkRenderingAttachmentFlagsInfoKHR { - VkStructureType sType; - const void* pNext; - VkRenderingAttachmentFlagsKHR flags; -} VkRenderingAttachmentFlagsInfoKHR; - -typedef struct VkResolveImageModeInfoKHR { - VkStructureType sType; - const void* pNext; - VkResolveImageFlagsKHR flags; - VkResolveModeFlagBits resolveMode; - VkResolveModeFlagBits stencilResolveMode; -} VkResolveImageModeInfoKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdEndRendering2KHR)(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2KHR( - VkCommandBuffer commandBuffer, - const VkRenderingEndInfoKHR* pRenderingEndInfo); -#endif -#endif - - -// VK_EXT_debug_report is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_debug_report 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT) -#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 10 -#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report" - -typedef enum VkDebugReportObjectTypeEXT { - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, - VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, - VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, - VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, - VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, - VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, - VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, - VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, - VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, - VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, - VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, - VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, - VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, - VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, - VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, - VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, - VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000, - VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001, - VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000, - VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000, - VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT = 1000307000, - VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT = 1000307001, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1000366000, - // VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT is a legacy alias - VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, - // VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT is a legacy alias - VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugReportObjectTypeEXT; - -typedef enum VkDebugReportFlagBitsEXT { - VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, - VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, - VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, - VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, - VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, - VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugReportFlagBitsEXT; -typedef VkFlags VkDebugReportFlagsEXT; -typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)( - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char* pLayerPrefix, - const char* pMessage, - void* pUserData); - -typedef struct VkDebugReportCallbackCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportFlagsEXT flags; - PFN_vkDebugReportCallbackEXT pfnCallback; - void* pUserData; -} VkDebugReportCallbackCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); -typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT( - VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugReportCallbackEXT* pCallback); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT( - VkInstance instance, - VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( - VkInstance instance, - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char* pLayerPrefix, - const char* pMessage); -#endif -#endif - - -// VK_NV_glsl_shader is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_glsl_shader 1 -#define VK_NV_GLSL_SHADER_SPEC_VERSION 1 -#define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader" - - -// VK_EXT_depth_range_unrestricted is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_depth_range_unrestricted 1 -#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1 -#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted" - - -// VK_IMG_filter_cubic is a preprocessor guard. Do not pass it to API calls. -#define VK_IMG_filter_cubic 1 -#define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1 -#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" - - -// VK_AMD_rasterization_order is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_rasterization_order 1 -#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 -#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order" - -typedef enum VkRasterizationOrderAMD { - VK_RASTERIZATION_ORDER_STRICT_AMD = 0, - VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, - VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF -} VkRasterizationOrderAMD; -typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { - VkStructureType sType; - const void* pNext; - VkRasterizationOrderAMD rasterizationOrder; -} VkPipelineRasterizationStateRasterizationOrderAMD; - - - -// VK_AMD_shader_trinary_minmax is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_shader_trinary_minmax 1 -#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1 -#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax" - - -// VK_AMD_shader_explicit_vertex_parameter is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_shader_explicit_vertex_parameter 1 -#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1 -#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter" - - -// VK_EXT_debug_marker is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_debug_marker 1 -#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4 -#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" -typedef struct VkDebugMarkerObjectNameInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportObjectTypeEXT objectType; - uint64_t object; - const char* pObjectName; -} VkDebugMarkerObjectNameInfoEXT; - -typedef struct VkDebugMarkerObjectTagInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportObjectTypeEXT objectType; - uint64_t object; - uint64_t tagName; - size_t tagSize; - const void* pTag; -} VkDebugMarkerObjectTagInfoEXT; - -typedef struct VkDebugMarkerMarkerInfoEXT { - VkStructureType sType; - const void* pNext; - const char* pMarkerName; - float color[4]; -} VkDebugMarkerMarkerInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); -typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); -typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( - VkDevice device, - const VkDebugMarkerObjectTagInfoEXT* pTagInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( - VkDevice device, - const VkDebugMarkerObjectNameInfoEXT* pNameInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( - VkCommandBuffer commandBuffer); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); -#endif -#endif - - -// VK_AMD_gcn_shader is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_gcn_shader 1 -#define VK_AMD_GCN_SHADER_SPEC_VERSION 1 -#define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader" - - -// VK_NV_dedicated_allocation is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_dedicated_allocation 1 -#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1 -#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation" -typedef struct VkDedicatedAllocationImageCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 dedicatedAllocation; -} VkDedicatedAllocationImageCreateInfoNV; - -typedef struct VkDedicatedAllocationBufferCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 dedicatedAllocation; -} VkDedicatedAllocationBufferCreateInfoNV; - -typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { - VkStructureType sType; - const void* pNext; - VkImage image; - VkBuffer buffer; -} VkDedicatedAllocationMemoryAllocateInfoNV; - - - -// VK_EXT_transform_feedback is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_transform_feedback 1 -#define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1 -#define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback" -typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT; -typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 transformFeedback; - VkBool32 geometryStreams; -} VkPhysicalDeviceTransformFeedbackFeaturesEXT; - -typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxTransformFeedbackStreams; - uint32_t maxTransformFeedbackBuffers; - VkDeviceSize maxTransformFeedbackBufferSize; - uint32_t maxTransformFeedbackStreamDataSize; - uint32_t maxTransformFeedbackBufferDataSize; - uint32_t maxTransformFeedbackBufferDataStride; - VkBool32 transformFeedbackQueries; - VkBool32 transformFeedbackStreamsLinesTriangles; - VkBool32 transformFeedbackRasterizationStreamSelect; - VkBool32 transformFeedbackDraw; -} VkPhysicalDeviceTransformFeedbackPropertiesEXT; - -typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationStateStreamCreateFlagsEXT flags; - uint32_t rasterizationStream; -} VkPipelineRasterizationStateStreamCreateInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); -typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); -typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); -typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); -typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags, - uint32_t index); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - uint32_t index); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT( - VkCommandBuffer commandBuffer, - uint32_t instanceCount, - uint32_t firstInstance, - VkBuffer counterBuffer, - VkDeviceSize counterBufferOffset, - uint32_t counterOffset, - uint32_t vertexStride); -#endif -#endif - - -// VK_NVX_binary_import is a preprocessor guard. Do not pass it to API calls. -#define VK_NVX_binary_import 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX) -#define VK_NVX_BINARY_IMPORT_SPEC_VERSION 2 -#define VK_NVX_BINARY_IMPORT_EXTENSION_NAME "VK_NVX_binary_import" -typedef struct VkCuModuleCreateInfoNVX { - VkStructureType sType; - const void* pNext; - size_t dataSize; - const void* pData; -} VkCuModuleCreateInfoNVX; - -typedef struct VkCuModuleTexturingModeCreateInfoNVX { - VkStructureType sType; - const void* pNext; - VkBool32 use64bitTexturing; -} VkCuModuleTexturingModeCreateInfoNVX; - -typedef struct VkCuFunctionCreateInfoNVX { - VkStructureType sType; - const void* pNext; - VkCuModuleNVX module; - const char* pName; -} VkCuFunctionCreateInfoNVX; - -typedef struct VkCuLaunchInfoNVX { - VkStructureType sType; - const void* pNext; - VkCuFunctionNVX function; - uint32_t gridDimX; - uint32_t gridDimY; - uint32_t gridDimZ; - uint32_t blockDimX; - uint32_t blockDimY; - uint32_t blockDimZ; - uint32_t sharedMemBytes; - size_t paramCount; - const void* const * pParams; - size_t extraCount; - const void* const * pExtras; -} VkCuLaunchInfoNVX; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule); -typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction); -typedef void (VKAPI_PTR *PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX( - VkDevice device, - const VkCuModuleCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCuModuleNVX* pModule); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX( - VkDevice device, - const VkCuFunctionCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCuFunctionNVX* pFunction); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX( - VkDevice device, - VkCuModuleNVX module, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX( - VkDevice device, - VkCuFunctionNVX function, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX( - VkCommandBuffer commandBuffer, - const VkCuLaunchInfoNVX* pLaunchInfo); -#endif -#endif - - -// VK_NVX_image_view_handle is a preprocessor guard. Do not pass it to API calls. -#define VK_NVX_image_view_handle 1 -#define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 4 -#define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle" -typedef struct VkImageViewHandleInfoNVX { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkDescriptorType descriptorType; - VkSampler sampler; -} VkImageViewHandleInfoNVX; - -typedef struct VkImageViewAddressPropertiesNVX { - VkStructureType sType; - void* pNext; - VkDeviceAddress deviceAddress; - VkDeviceSize size; -} VkImageViewAddressPropertiesNVX; - -typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo); -typedef uint64_t (VKAPI_PTR *PFN_vkGetImageViewHandle64NVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties); -typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceCombinedImageSamplerIndexNVX)(VkDevice device, uint64_t imageViewIndex, uint64_t samplerIndex); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX( - VkDevice device, - const VkImageViewHandleInfoNVX* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR uint64_t VKAPI_CALL vkGetImageViewHandle64NVX( - VkDevice device, - const VkImageViewHandleInfoNVX* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX( - VkDevice device, - VkImageView imageView, - VkImageViewAddressPropertiesNVX* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceCombinedImageSamplerIndexNVX( - VkDevice device, - uint64_t imageViewIndex, - uint64_t samplerIndex); -#endif -#endif - - -// VK_AMD_draw_indirect_count is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_draw_indirect_count 1 -#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2 -#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count" -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); -#endif -#endif - - -// VK_AMD_negative_viewport_height is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_negative_viewport_height 1 -#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1 -#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height" - - -// VK_AMD_gpu_shader_half_float is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_gpu_shader_half_float 1 -#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2 -#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float" - - -// VK_AMD_shader_ballot is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_shader_ballot 1 -#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1 -#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot" - - -// VK_AMD_texture_gather_bias_lod is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_texture_gather_bias_lod 1 -#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1 -#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod" -typedef struct VkTextureLODGatherFormatPropertiesAMD { - VkStructureType sType; - void* pNext; - VkBool32 supportsTextureGatherLODBiasAMD; -} VkTextureLODGatherFormatPropertiesAMD; - - - -// VK_AMD_shader_info is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_shader_info 1 -#define VK_AMD_SHADER_INFO_SPEC_VERSION 1 -#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info" - -typedef enum VkShaderInfoTypeAMD { - VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, - VK_SHADER_INFO_TYPE_BINARY_AMD = 1, - VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, - VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF -} VkShaderInfoTypeAMD; -typedef struct VkShaderResourceUsageAMD { - uint32_t numUsedVgprs; - uint32_t numUsedSgprs; - uint32_t ldsSizePerLocalWorkGroup; - size_t ldsUsageSizeInBytes; - size_t scratchMemUsageInBytes; -} VkShaderResourceUsageAMD; - -typedef struct VkShaderStatisticsInfoAMD { - VkShaderStageFlags shaderStageMask; - VkShaderResourceUsageAMD resourceUsage; - uint32_t numPhysicalVgprs; - uint32_t numPhysicalSgprs; - uint32_t numAvailableVgprs; - uint32_t numAvailableSgprs; - uint32_t computeWorkGroupSize[3]; -} VkShaderStatisticsInfoAMD; - -typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD( - VkDevice device, - VkPipeline pipeline, - VkShaderStageFlagBits shaderStage, - VkShaderInfoTypeAMD infoType, - size_t* pInfoSize, - void* pInfo); -#endif -#endif - - -// VK_AMD_shader_image_load_store_lod is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_shader_image_load_store_lod 1 -#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1 -#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod" - - -// VK_NV_corner_sampled_image is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_corner_sampled_image 1 -#define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2 -#define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image" -typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 cornerSampledImage; -} VkPhysicalDeviceCornerSampledImageFeaturesNV; - - - -// VK_IMG_format_pvrtc is a preprocessor guard. Do not pass it to API calls. -#define VK_IMG_format_pvrtc 1 -#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1 -#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc" - - -// VK_NV_external_memory_capabilities is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_external_memory_capabilities 1 -#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1 -#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities" - -typedef enum VkExternalMemoryHandleTypeFlagBitsNV { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkExternalMemoryHandleTypeFlagBitsNV; -typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; - -typedef enum VkExternalMemoryFeatureFlagBitsNV { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, - VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkExternalMemoryFeatureFlagBitsNV; -typedef VkFlags VkExternalMemoryFeatureFlagsNV; -typedef struct VkExternalImageFormatPropertiesNV { - VkImageFormatProperties imageFormatProperties; - VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; - VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; - VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; -} VkExternalImageFormatPropertiesNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkExternalMemoryHandleTypeFlagsNV externalHandleType, - VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); -#endif -#endif - - -// VK_NV_external_memory is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_external_memory 1 -#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1 -#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory" -typedef struct VkExternalMemoryImageCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsNV handleTypes; -} VkExternalMemoryImageCreateInfoNV; - -typedef struct VkExportMemoryAllocateInfoNV { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsNV handleTypes; -} VkExportMemoryAllocateInfoNV; - - - -// VK_EXT_validation_flags is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_validation_flags 1 -#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 3 -#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags" - -typedef enum VkValidationCheckEXT { - VK_VALIDATION_CHECK_ALL_EXT = 0, - VK_VALIDATION_CHECK_SHADERS_EXT = 1, - VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationCheckEXT; -typedef struct VkValidationFlagsEXT { - VkStructureType sType; - const void* pNext; - uint32_t disabledValidationCheckCount; - const VkValidationCheckEXT* pDisabledValidationChecks; -} VkValidationFlagsEXT; - - - -// VK_EXT_shader_subgroup_ballot is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_subgroup_ballot 1 -#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1 -#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot" - - -// VK_EXT_shader_subgroup_vote is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_subgroup_vote 1 -#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1 -#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote" - - -// VK_EXT_texture_compression_astc_hdr is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_texture_compression_astc_hdr 1 -#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1 -#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr" -typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; - - - -// VK_EXT_astc_decode_mode is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_astc_decode_mode 1 -#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1 -#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode" -typedef struct VkImageViewASTCDecodeModeEXT { - VkStructureType sType; - const void* pNext; - VkFormat decodeMode; -} VkImageViewASTCDecodeModeEXT; - -typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 decodeModeSharedExponent; -} VkPhysicalDeviceASTCDecodeFeaturesEXT; - - - -// VK_EXT_pipeline_robustness is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_pipeline_robustness 1 -#define VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION 1 -#define VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_pipeline_robustness" -typedef VkPipelineRobustnessBufferBehavior VkPipelineRobustnessBufferBehaviorEXT; - -typedef VkPipelineRobustnessImageBehavior VkPipelineRobustnessImageBehaviorEXT; - -typedef VkPhysicalDevicePipelineRobustnessFeatures VkPhysicalDevicePipelineRobustnessFeaturesEXT; - -typedef VkPhysicalDevicePipelineRobustnessProperties VkPhysicalDevicePipelineRobustnessPropertiesEXT; - -typedef VkPipelineRobustnessCreateInfo VkPipelineRobustnessCreateInfoEXT; - - - -// VK_EXT_conditional_rendering is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_conditional_rendering 1 -#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2 -#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering" - -typedef enum VkConditionalRenderingFlagBitsEXT { - VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, - VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkConditionalRenderingFlagBitsEXT; -typedef VkFlags VkConditionalRenderingFlagsEXT; -typedef struct VkConditionalRenderingBeginInfoEXT { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; - VkDeviceSize offset; - VkConditionalRenderingFlagsEXT flags; -} VkConditionalRenderingBeginInfoEXT; - -typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 conditionalRendering; - VkBool32 inheritedConditionalRendering; -} VkPhysicalDeviceConditionalRenderingFeaturesEXT; - -typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 conditionalRenderingEnable; -} VkCommandBufferInheritanceConditionalRenderingInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); -typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT( - VkCommandBuffer commandBuffer, - const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT( - VkCommandBuffer commandBuffer); -#endif -#endif - - -// VK_NV_clip_space_w_scaling is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_clip_space_w_scaling 1 -#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1 -#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling" -typedef struct VkViewportWScalingNV { - float xcoeff; - float ycoeff; -} VkViewportWScalingNV; - -typedef struct VkPipelineViewportWScalingStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 viewportWScalingEnable; - uint32_t viewportCount; - const VkViewportWScalingNV* pViewportWScalings; -} VkPipelineViewportWScalingStateCreateInfoNV; - -typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportWScalingNV* pViewportWScalings); -#endif -#endif - - -// VK_EXT_direct_mode_display is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_direct_mode_display 1 -#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1 -#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display" -typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display); -#endif -#endif - - -// VK_EXT_display_surface_counter is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_display_surface_counter 1 -#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1 -#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter" - -typedef enum VkSurfaceCounterFlagBitsEXT { - VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001, - // VK_SURFACE_COUNTER_VBLANK_EXT is a legacy alias - VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT, - VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkSurfaceCounterFlagBitsEXT; -typedef VkFlags VkSurfaceCounterFlagsEXT; -typedef struct VkSurfaceCapabilities2EXT { - VkStructureType sType; - void* pNext; - uint32_t minImageCount; - uint32_t maxImageCount; - VkExtent2D currentExtent; - VkExtent2D minImageExtent; - VkExtent2D maxImageExtent; - uint32_t maxImageArrayLayers; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkSurfaceTransformFlagBitsKHR currentTransform; - VkCompositeAlphaFlagsKHR supportedCompositeAlpha; - VkImageUsageFlags supportedUsageFlags; - VkSurfaceCounterFlagsEXT supportedSurfaceCounters; -} VkSurfaceCapabilities2EXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities); -#endif -#endif - - -// VK_EXT_display_control is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_display_control 1 -#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1 -#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control" - -typedef enum VkDisplayPowerStateEXT { - VK_DISPLAY_POWER_STATE_OFF_EXT = 0, - VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, - VK_DISPLAY_POWER_STATE_ON_EXT = 2, - VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDisplayPowerStateEXT; - -typedef enum VkDeviceEventTypeEXT { - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, - VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceEventTypeEXT; - -typedef enum VkDisplayEventTypeEXT { - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, - VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDisplayEventTypeEXT; -typedef struct VkDisplayPowerInfoEXT { - VkStructureType sType; - const void* pNext; - VkDisplayPowerStateEXT powerState; -} VkDisplayPowerInfoEXT; - -typedef struct VkDeviceEventInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceEventTypeEXT deviceEvent; -} VkDeviceEventInfoEXT; - -typedef struct VkDisplayEventInfoEXT { - VkStructureType sType; - const void* pNext; - VkDisplayEventTypeEXT displayEvent; -} VkDisplayEventInfoEXT; - -typedef struct VkSwapchainCounterCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkSurfaceCounterFlagsEXT surfaceCounters; -} VkSwapchainCounterCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); -typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayPowerInfoEXT* pDisplayPowerInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT( - VkDevice device, - const VkDeviceEventInfoEXT* pDeviceEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayEventInfoEXT* pDisplayEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT( - VkDevice device, - VkSwapchainKHR swapchain, - VkSurfaceCounterFlagBitsEXT counter, - uint64_t* pCounterValue); -#endif -#endif - - -// VK_GOOGLE_display_timing is a preprocessor guard. Do not pass it to API calls. -#define VK_GOOGLE_display_timing 1 -#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1 -#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing" -typedef struct VkRefreshCycleDurationGOOGLE { - uint64_t refreshDuration; -} VkRefreshCycleDurationGOOGLE; - -typedef struct VkPastPresentationTimingGOOGLE { - uint32_t presentID; - uint64_t desiredPresentTime; - uint64_t actualPresentTime; - uint64_t earliestPresentTime; - uint64_t presentMargin; -} VkPastPresentationTimingGOOGLE; - -typedef struct VkPresentTimeGOOGLE { - uint32_t presentID; - uint64_t desiredPresentTime; -} VkPresentTimeGOOGLE; - -typedef struct VkPresentTimesInfoGOOGLE { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentTimeGOOGLE* pTimes; -} VkPresentTimesInfoGOOGLE; - -typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pPresentationTimingCount, - VkPastPresentationTimingGOOGLE* pPresentationTimings); -#endif -#endif - - -// VK_NV_sample_mask_override_coverage is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_sample_mask_override_coverage 1 -#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1 -#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage" - - -// VK_NV_geometry_shader_passthrough is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_geometry_shader_passthrough 1 -#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1 -#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough" - - -// VK_NV_viewport_array2 is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_viewport_array2 1 -#define VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION 1 -#define VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME "VK_NV_viewport_array2" -// VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION is a legacy alias -#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION -// VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME is a legacy alias -#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME - - -// VK_NVX_multiview_per_view_attributes is a preprocessor guard. Do not pass it to API calls. -#define VK_NVX_multiview_per_view_attributes 1 -#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1 -#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes" -typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { - VkStructureType sType; - void* pNext; - VkBool32 perViewPositionAllComponents; -} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - -typedef struct VkMultiviewPerViewAttributesInfoNVX { - VkStructureType sType; - const void* pNext; - VkBool32 perViewAttributes; - VkBool32 perViewAttributesPositionXOnly; -} VkMultiviewPerViewAttributesInfoNVX; - - - -// VK_NV_viewport_swizzle is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_viewport_swizzle 1 -#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1 -#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle" - -typedef enum VkViewportCoordinateSwizzleNV { - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, - VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF -} VkViewportCoordinateSwizzleNV; -typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; -typedef struct VkViewportSwizzleNV { - VkViewportCoordinateSwizzleNV x; - VkViewportCoordinateSwizzleNV y; - VkViewportCoordinateSwizzleNV z; - VkViewportCoordinateSwizzleNV w; -} VkViewportSwizzleNV; - -typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineViewportSwizzleStateCreateFlagsNV flags; - uint32_t viewportCount; - const VkViewportSwizzleNV* pViewportSwizzles; -} VkPipelineViewportSwizzleStateCreateInfoNV; - - - -// VK_EXT_discard_rectangles is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_discard_rectangles 1 -#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 2 -#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles" - -typedef enum VkDiscardRectangleModeEXT { - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, - VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, - VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDiscardRectangleModeEXT; -typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; -typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxDiscardRectangles; -} VkPhysicalDeviceDiscardRectanglePropertiesEXT; - -typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineDiscardRectangleStateCreateFlagsEXT flags; - VkDiscardRectangleModeEXT discardRectangleMode; - uint32_t discardRectangleCount; - const VkRect2D* pDiscardRectangles; -} VkPipelineDiscardRectangleStateCreateInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); -typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleModeEXT)(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT( - VkCommandBuffer commandBuffer, - uint32_t firstDiscardRectangle, - uint32_t discardRectangleCount, - const VkRect2D* pDiscardRectangles); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 discardRectangleEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleModeEXT( - VkCommandBuffer commandBuffer, - VkDiscardRectangleModeEXT discardRectangleMode); -#endif -#endif - - -// VK_EXT_conservative_rasterization is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_conservative_rasterization 1 -#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1 -#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization" - -typedef enum VkConservativeRasterizationModeEXT { - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, - VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, - VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, - VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkConservativeRasterizationModeEXT; -typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; -typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { - VkStructureType sType; - void* pNext; - float primitiveOverestimationSize; - float maxExtraPrimitiveOverestimationSize; - float extraPrimitiveOverestimationSizeGranularity; - VkBool32 primitiveUnderestimation; - VkBool32 conservativePointAndLineRasterization; - VkBool32 degenerateTrianglesRasterized; - VkBool32 degenerateLinesRasterized; - VkBool32 fullyCoveredFragmentShaderInputVariable; - VkBool32 conservativeRasterizationPostDepthCoverage; -} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; - -typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; - VkConservativeRasterizationModeEXT conservativeRasterizationMode; - float extraPrimitiveOverestimationSize; -} VkPipelineRasterizationConservativeStateCreateInfoEXT; - - - -// VK_EXT_depth_clip_enable is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_depth_clip_enable 1 -#define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1 -#define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable" -typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; -typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 depthClipEnable; -} VkPhysicalDeviceDepthClipEnableFeaturesEXT; - -typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; - VkBool32 depthClipEnable; -} VkPipelineRasterizationDepthClipStateCreateInfoEXT; - - - -// VK_EXT_swapchain_colorspace is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_swapchain_colorspace 1 -#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 5 -#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace" - - -// VK_EXT_hdr_metadata is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_hdr_metadata 1 -#define VK_EXT_HDR_METADATA_SPEC_VERSION 3 -#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata" -typedef struct VkXYColorEXT { - float x; - float y; -} VkXYColorEXT; - -typedef struct VkHdrMetadataEXT { - VkStructureType sType; - const void* pNext; - VkXYColorEXT displayPrimaryRed; - VkXYColorEXT displayPrimaryGreen; - VkXYColorEXT displayPrimaryBlue; - VkXYColorEXT whitePoint; - float maxLuminance; - float minLuminance; - float maxContentLightLevel; - float maxFrameAverageLightLevel; -} VkHdrMetadataEXT; - -typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainKHR* pSwapchains, - const VkHdrMetadataEXT* pMetadata); -#endif -#endif - - -// VK_IMG_relaxed_line_rasterization is a preprocessor guard. Do not pass it to API calls. -#define VK_IMG_relaxed_line_rasterization 1 -#define VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION 1 -#define VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME "VK_IMG_relaxed_line_rasterization" -typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG { - VkStructureType sType; - void* pNext; - VkBool32 relaxedLineRasterization; -} VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG; - - - -// VK_EXT_external_memory_dma_buf is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_external_memory_dma_buf 1 -#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1 -#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf" - - -// VK_EXT_queue_family_foreign is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_queue_family_foreign 1 -#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1 -#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign" -#define VK_QUEUE_FAMILY_FOREIGN_EXT (~2U) - - -// VK_EXT_debug_utils is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_debug_utils 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT) -#define VK_EXT_DEBUG_UTILS_SPEC_VERSION 2 -#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils" -typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; - -typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT { - VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugUtilsMessageSeverityFlagBitsEXT; - -typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { - VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, - VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, - VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, - VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT = 0x00000008, - VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugUtilsMessageTypeFlagBitsEXT; -typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; -typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; -typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; -typedef struct VkDebugUtilsLabelEXT { - VkStructureType sType; - const void* pNext; - const char* pLabelName; - float color[4]; -} VkDebugUtilsLabelEXT; - -typedef struct VkDebugUtilsObjectNameInfoEXT { - VkStructureType sType; - const void* pNext; - VkObjectType objectType; - uint64_t objectHandle; - const char* pObjectName; -} VkDebugUtilsObjectNameInfoEXT; - -typedef struct VkDebugUtilsMessengerCallbackDataEXT { - VkStructureType sType; - const void* pNext; - VkDebugUtilsMessengerCallbackDataFlagsEXT flags; - const char* pMessageIdName; - int32_t messageIdNumber; - const char* pMessage; - uint32_t queueLabelCount; - const VkDebugUtilsLabelEXT* pQueueLabels; - uint32_t cmdBufLabelCount; - const VkDebugUtilsLabelEXT* pCmdBufLabels; - uint32_t objectCount; - const VkDebugUtilsObjectNameInfoEXT* pObjects; -} VkDebugUtilsMessengerCallbackDataEXT; - -typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)( - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, - void* pUserData); - -typedef struct VkDebugUtilsMessengerCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugUtilsMessengerCreateFlagsEXT flags; - VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; - VkDebugUtilsMessageTypeFlagsEXT messageType; - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; - void* pUserData; -} VkDebugUtilsMessengerCreateInfoEXT; - -typedef struct VkDebugUtilsObjectTagInfoEXT { - VkStructureType sType; - const void* pNext; - VkObjectType objectType; - uint64_t objectHandle; - uint64_t tagName; - size_t tagSize; - const void* pTag; -} VkDebugUtilsObjectTagInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); -typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); -typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); -typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); -typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); -typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT( - VkDevice device, - const VkDebugUtilsObjectNameInfoEXT* pNameInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT( - VkDevice device, - const VkDebugUtilsObjectTagInfoEXT* pTagInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT( - VkQueue queue); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT( - VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugUtilsMessengerEXT* pMessenger); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT( - VkInstance instance, - VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT( - VkInstance instance, - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); -#endif -#endif - - -// VK_EXT_sampler_filter_minmax is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_sampler_filter_minmax 1 -#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2 -#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax" -typedef VkSamplerReductionMode VkSamplerReductionModeEXT; - -typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT; - -typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; - - - -// VK_AMD_gpu_shader_int16 is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_gpu_shader_int16 1 -#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 2 -#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16" - - -// VK_EXT_descriptor_heap is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_descriptor_heap 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkTensorARM) -#define VK_EXT_DESCRIPTOR_HEAP_SPEC_VERSION 1 -#define VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME "VK_EXT_descriptor_heap" - -typedef enum VkDescriptorMappingSourceEXT { - VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT = 0, - VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT = 1, - VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT = 2, - VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT = 3, - VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT = 4, - VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT = 5, - VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT = 6, - VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT = 7, - VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT = 8, - VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT = 9, - VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT = 10, - VK_DESCRIPTOR_MAPPING_SOURCE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDescriptorMappingSourceEXT; -typedef VkFlags64 VkTensorViewCreateFlagsARM; - -// Flag bits for VkTensorViewCreateFlagBitsARM -typedef VkFlags64 VkTensorViewCreateFlagBitsARM; -static const VkTensorViewCreateFlagBitsARM VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM = 0x00000001ULL; - - -typedef enum VkSpirvResourceTypeFlagBitsEXT { - VK_SPIRV_RESOURCE_TYPE_ALL_EXT = 0x7FFFFFFF, - VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT = 0x00000001, - VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT = 0x00000002, - VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT = 0x00000004, - VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT = 0x00000008, - VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT = 0x00000010, - VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT = 0x00000020, - VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT = 0x00000040, - VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT = 0x00000080, - VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT = 0x00000100, - VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM = 0x00000200, - VK_SPIRV_RESOURCE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkSpirvResourceTypeFlagBitsEXT; -typedef VkFlags VkSpirvResourceTypeFlagsEXT; -typedef struct VkHostAddressRangeEXT { - void* address; - size_t size; -} VkHostAddressRangeEXT; - -typedef struct VkHostAddressRangeConstEXT { - const void* address; - size_t size; -} VkHostAddressRangeConstEXT; - -typedef struct VkDeviceAddressRangeEXT { - VkDeviceAddress address; - VkDeviceSize size; -} VkDeviceAddressRangeEXT; - -typedef struct VkTexelBufferDescriptorInfoEXT { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkDeviceAddressRangeEXT addressRange; -} VkTexelBufferDescriptorInfoEXT; - -typedef struct VkImageDescriptorInfoEXT { - VkStructureType sType; - const void* pNext; - const VkImageViewCreateInfo* pView; - VkImageLayout layout; -} VkImageDescriptorInfoEXT; - -typedef struct VkTensorViewCreateInfoARM { - VkStructureType sType; - const void* pNext; - VkTensorViewCreateFlagsARM flags; - VkTensorARM tensor; - VkFormat format; -} VkTensorViewCreateInfoARM; - -typedef union VkResourceDescriptorDataEXT { - const VkImageDescriptorInfoEXT* pImage; - const VkTexelBufferDescriptorInfoEXT* pTexelBuffer; - const VkDeviceAddressRangeEXT* pAddressRange; - const VkTensorViewCreateInfoARM* pTensorARM; -} VkResourceDescriptorDataEXT; - -typedef struct VkResourceDescriptorInfoEXT { - VkStructureType sType; - const void* pNext; - VkDescriptorType type; - VkResourceDescriptorDataEXT data; -} VkResourceDescriptorInfoEXT; - -typedef struct VkBindHeapInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceAddressRangeEXT heapRange; - VkDeviceSize reservedRangeOffset; - VkDeviceSize reservedRangeSize; -} VkBindHeapInfoEXT; - -typedef struct VkPushDataInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t offset; - VkHostAddressRangeConstEXT data; -} VkPushDataInfoEXT; - -typedef struct VkDescriptorMappingSourceConstantOffsetEXT { - uint32_t heapOffset; - uint32_t heapArrayStride; - const VkSamplerCreateInfo* pEmbeddedSampler; - uint32_t samplerHeapOffset; - uint32_t samplerHeapArrayStride; -} VkDescriptorMappingSourceConstantOffsetEXT; - -typedef struct VkDescriptorMappingSourcePushIndexEXT { - uint32_t heapOffset; - uint32_t pushOffset; - uint32_t heapIndexStride; - uint32_t heapArrayStride; - const VkSamplerCreateInfo* pEmbeddedSampler; - VkBool32 useCombinedImageSamplerIndex; - uint32_t samplerHeapOffset; - uint32_t samplerPushOffset; - uint32_t samplerHeapIndexStride; - uint32_t samplerHeapArrayStride; -} VkDescriptorMappingSourcePushIndexEXT; - -typedef struct VkDescriptorMappingSourceIndirectIndexEXT { - uint32_t heapOffset; - uint32_t pushOffset; - uint32_t addressOffset; - uint32_t heapIndexStride; - uint32_t heapArrayStride; - const VkSamplerCreateInfo* pEmbeddedSampler; - VkBool32 useCombinedImageSamplerIndex; - uint32_t samplerHeapOffset; - uint32_t samplerPushOffset; - uint32_t samplerAddressOffset; - uint32_t samplerHeapIndexStride; - uint32_t samplerHeapArrayStride; -} VkDescriptorMappingSourceIndirectIndexEXT; - -typedef struct VkDescriptorMappingSourceHeapDataEXT { - uint32_t heapOffset; - uint32_t pushOffset; -} VkDescriptorMappingSourceHeapDataEXT; - -typedef struct VkDescriptorMappingSourceIndirectAddressEXT { - uint32_t pushOffset; - uint32_t addressOffset; -} VkDescriptorMappingSourceIndirectAddressEXT; - -typedef struct VkDescriptorMappingSourceShaderRecordIndexEXT { - uint32_t heapOffset; - uint32_t shaderRecordOffset; - uint32_t heapIndexStride; - uint32_t heapArrayStride; - const VkSamplerCreateInfo* pEmbeddedSampler; - VkBool32 useCombinedImageSamplerIndex; - uint32_t samplerHeapOffset; - uint32_t samplerShaderRecordOffset; - uint32_t samplerHeapIndexStride; - uint32_t samplerHeapArrayStride; -} VkDescriptorMappingSourceShaderRecordIndexEXT; - -typedef struct VkDescriptorMappingSourceIndirectIndexArrayEXT { - uint32_t heapOffset; - uint32_t pushOffset; - uint32_t addressOffset; - uint32_t heapIndexStride; - const VkSamplerCreateInfo* pEmbeddedSampler; - VkBool32 useCombinedImageSamplerIndex; - uint32_t samplerHeapOffset; - uint32_t samplerPushOffset; - uint32_t samplerAddressOffset; - uint32_t samplerHeapIndexStride; -} VkDescriptorMappingSourceIndirectIndexArrayEXT; - -typedef union VkDescriptorMappingSourceDataEXT { - VkDescriptorMappingSourceConstantOffsetEXT constantOffset; - VkDescriptorMappingSourcePushIndexEXT pushIndex; - VkDescriptorMappingSourceIndirectIndexEXT indirectIndex; - VkDescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray; - VkDescriptorMappingSourceHeapDataEXT heapData; - uint32_t pushDataOffset; - uint32_t pushAddressOffset; - VkDescriptorMappingSourceIndirectAddressEXT indirectAddress; - VkDescriptorMappingSourceShaderRecordIndexEXT shaderRecordIndex; - uint32_t shaderRecordDataOffset; - uint32_t shaderRecordAddressOffset; -} VkDescriptorMappingSourceDataEXT; - -typedef struct VkDescriptorSetAndBindingMappingEXT { - VkStructureType sType; - const void* pNext; - uint32_t descriptorSet; - uint32_t firstBinding; - uint32_t bindingCount; - VkSpirvResourceTypeFlagsEXT resourceMask; - VkDescriptorMappingSourceEXT source; - VkDescriptorMappingSourceDataEXT sourceData; -} VkDescriptorSetAndBindingMappingEXT; - -typedef struct VkShaderDescriptorSetAndBindingMappingInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t mappingCount; - const VkDescriptorSetAndBindingMappingEXT* pMappings; -} VkShaderDescriptorSetAndBindingMappingInfoEXT; - -typedef struct VkOpaqueCaptureDataCreateInfoEXT { - VkStructureType sType; - const void* pNext; - const VkHostAddressRangeConstEXT* pData; -} VkOpaqueCaptureDataCreateInfoEXT; - -typedef struct VkPhysicalDeviceDescriptorHeapFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 descriptorHeap; - VkBool32 descriptorHeapCaptureReplay; -} VkPhysicalDeviceDescriptorHeapFeaturesEXT; - -typedef struct VkPhysicalDeviceDescriptorHeapPropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize samplerHeapAlignment; - VkDeviceSize resourceHeapAlignment; - VkDeviceSize maxSamplerHeapSize; - VkDeviceSize maxResourceHeapSize; - VkDeviceSize minSamplerHeapReservedRange; - VkDeviceSize minSamplerHeapReservedRangeWithEmbedded; - VkDeviceSize minResourceHeapReservedRange; - VkDeviceSize samplerDescriptorSize; - VkDeviceSize imageDescriptorSize; - VkDeviceSize bufferDescriptorSize; - VkDeviceSize samplerDescriptorAlignment; - VkDeviceSize imageDescriptorAlignment; - VkDeviceSize bufferDescriptorAlignment; - VkDeviceSize maxPushDataSize; - size_t imageCaptureReplayOpaqueDataSize; - uint32_t maxDescriptorHeapEmbeddedSamplers; - uint32_t samplerYcbcrConversionCount; - VkBool32 sparseDescriptorHeaps; - VkBool32 protectedDescriptorHeaps; -} VkPhysicalDeviceDescriptorHeapPropertiesEXT; - -typedef struct VkCommandBufferInheritanceDescriptorHeapInfoEXT { - VkStructureType sType; - const void* pNext; - const VkBindHeapInfoEXT* pSamplerHeapBindInfo; - const VkBindHeapInfoEXT* pResourceHeapBindInfo; -} VkCommandBufferInheritanceDescriptorHeapInfoEXT; - -typedef struct VkSamplerCustomBorderColorIndexCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t index; -} VkSamplerCustomBorderColorIndexCreateInfoEXT; - -typedef struct VkSamplerCustomBorderColorCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkClearColorValue customBorderColor; - VkFormat format; -} VkSamplerCustomBorderColorCreateInfoEXT; - -typedef struct VkIndirectCommandsLayoutPushDataTokenNV { - VkStructureType sType; - const void* pNext; - uint32_t pushDataOffset; - uint32_t pushDataSize; -} VkIndirectCommandsLayoutPushDataTokenNV; - -typedef struct VkSubsampledImageFormatPropertiesEXT { - VkStructureType sType; - const void* pNext; - uint32_t subsampledImageDescriptorCount; -} VkSubsampledImageFormatPropertiesEXT; - -typedef struct VkPhysicalDeviceDescriptorHeapTensorPropertiesARM { - VkStructureType sType; - void* pNext; - VkDeviceSize tensorDescriptorSize; - VkDeviceSize tensorDescriptorAlignment; - size_t tensorCaptureReplayOpaqueDataSize; -} VkPhysicalDeviceDescriptorHeapTensorPropertiesARM; - -typedef VkResult (VKAPI_PTR *PFN_vkWriteSamplerDescriptorsEXT)(VkDevice device, uint32_t samplerCount, const VkSamplerCreateInfo* pSamplers, const VkHostAddressRangeEXT* pDescriptors); -typedef VkResult (VKAPI_PTR *PFN_vkWriteResourceDescriptorsEXT)(VkDevice device, uint32_t resourceCount, const VkResourceDescriptorInfoEXT* pResources, const VkHostAddressRangeEXT* pDescriptors); -typedef void (VKAPI_PTR *PFN_vkCmdBindSamplerHeapEXT)(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBindResourceHeapEXT)(VkCommandBuffer commandBuffer, const VkBindHeapInfoEXT* pBindInfo); -typedef void (VKAPI_PTR *PFN_vkCmdPushDataEXT)(VkCommandBuffer commandBuffer, const VkPushDataInfoEXT* pPushDataInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetImageOpaqueCaptureDataEXT)(VkDevice device, uint32_t imageCount, const VkImage* pImages, VkHostAddressRangeEXT* pDatas); -typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetPhysicalDeviceDescriptorSizeEXT)(VkPhysicalDevice physicalDevice, VkDescriptorType descriptorType); -typedef VkResult (VKAPI_PTR *PFN_vkRegisterCustomBorderColorEXT)(VkDevice device, const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, VkBool32 requestIndex, uint32_t* pIndex); -typedef void (VKAPI_PTR *PFN_vkUnregisterCustomBorderColorEXT)(VkDevice device, uint32_t index); -typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDataARM)(VkDevice device, uint32_t tensorCount, const VkTensorARM* pTensors, VkHostAddressRangeEXT* pDatas); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkWriteSamplerDescriptorsEXT( - VkDevice device, - uint32_t samplerCount, - const VkSamplerCreateInfo* pSamplers, - const VkHostAddressRangeEXT* pDescriptors); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkWriteResourceDescriptorsEXT( - VkDevice device, - uint32_t resourceCount, - const VkResourceDescriptorInfoEXT* pResources, - const VkHostAddressRangeEXT* pDescriptors); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindSamplerHeapEXT( - VkCommandBuffer commandBuffer, - const VkBindHeapInfoEXT* pBindInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindResourceHeapEXT( - VkCommandBuffer commandBuffer, - const VkBindHeapInfoEXT* pBindInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdPushDataEXT( - VkCommandBuffer commandBuffer, - const VkPushDataInfoEXT* pPushDataInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDataEXT( - VkDevice device, - uint32_t imageCount, - const VkImage* pImages, - VkHostAddressRangeEXT* pDatas); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetPhysicalDeviceDescriptorSizeEXT( - VkPhysicalDevice physicalDevice, - VkDescriptorType descriptorType); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkRegisterCustomBorderColorEXT( - VkDevice device, - const VkSamplerCustomBorderColorCreateInfoEXT* pBorderColor, - VkBool32 requestIndex, - uint32_t* pIndex); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkUnregisterCustomBorderColorEXT( - VkDevice device, - uint32_t index); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDataARM( - VkDevice device, - uint32_t tensorCount, - const VkTensorARM* pTensors, - VkHostAddressRangeEXT* pDatas); -#endif -#endif - - -// VK_AMD_mixed_attachment_samples is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_mixed_attachment_samples 1 -#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1 -#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples" -typedef struct VkAttachmentSampleCountInfoAMD { - VkStructureType sType; - const void* pNext; - uint32_t colorAttachmentCount; - const VkSampleCountFlagBits* pColorAttachmentSamples; - VkSampleCountFlagBits depthStencilAttachmentSamples; -} VkAttachmentSampleCountInfoAMD; - - - -// VK_AMD_shader_fragment_mask is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_shader_fragment_mask 1 -#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1 -#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask" - - -// VK_EXT_inline_uniform_block is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_inline_uniform_block 1 -#define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1 -#define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block" -typedef VkPhysicalDeviceInlineUniformBlockFeatures VkPhysicalDeviceInlineUniformBlockFeaturesEXT; - -typedef VkPhysicalDeviceInlineUniformBlockProperties VkPhysicalDeviceInlineUniformBlockPropertiesEXT; - -typedef VkWriteDescriptorSetInlineUniformBlock VkWriteDescriptorSetInlineUniformBlockEXT; - -typedef VkDescriptorPoolInlineUniformBlockCreateInfo VkDescriptorPoolInlineUniformBlockCreateInfoEXT; - - - -// VK_EXT_shader_stencil_export is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_stencil_export 1 -#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1 -#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export" - - -// VK_EXT_sample_locations is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_sample_locations 1 -#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1 -#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations" -typedef struct VkSampleLocationEXT { - float x; - float y; -} VkSampleLocationEXT; - -typedef struct VkSampleLocationsInfoEXT { - VkStructureType sType; - const void* pNext; - VkSampleCountFlagBits sampleLocationsPerPixel; - VkExtent2D sampleLocationGridSize; - uint32_t sampleLocationsCount; - const VkSampleLocationEXT* pSampleLocations; -} VkSampleLocationsInfoEXT; - -typedef struct VkAttachmentSampleLocationsEXT { - uint32_t attachmentIndex; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkAttachmentSampleLocationsEXT; - -typedef struct VkSubpassSampleLocationsEXT { - uint32_t subpassIndex; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkSubpassSampleLocationsEXT; - -typedef struct VkRenderPassSampleLocationsBeginInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t attachmentInitialSampleLocationsCount; - const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; - uint32_t postSubpassSampleLocationsCount; - const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; -} VkRenderPassSampleLocationsBeginInfoEXT; - -typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 sampleLocationsEnable; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkPipelineSampleLocationsStateCreateInfoEXT; - -typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { - VkStructureType sType; - void* pNext; - VkSampleCountFlags sampleLocationSampleCounts; - VkExtent2D maxSampleLocationGridSize; - float sampleLocationCoordinateRange[2]; - uint32_t sampleLocationSubPixelBits; - VkBool32 variableSampleLocations; -} VkPhysicalDeviceSampleLocationsPropertiesEXT; - -typedef struct VkMultisamplePropertiesEXT { - VkStructureType sType; - void* pNext; - VkExtent2D maxSampleLocationGridSize; -} VkMultisamplePropertiesEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT( - VkCommandBuffer commandBuffer, - const VkSampleLocationsInfoEXT* pSampleLocationsInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT( - VkPhysicalDevice physicalDevice, - VkSampleCountFlagBits samples, - VkMultisamplePropertiesEXT* pMultisampleProperties); -#endif -#endif - - -// VK_EXT_blend_operation_advanced is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_blend_operation_advanced 1 -#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2 -#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced" - -typedef enum VkBlendOverlapEXT { - VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, - VK_BLEND_OVERLAP_DISJOINT_EXT = 1, - VK_BLEND_OVERLAP_CONJOINT_EXT = 2, - VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF -} VkBlendOverlapEXT; -typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 advancedBlendCoherentOperations; -} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; - -typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t advancedBlendMaxColorAttachments; - VkBool32 advancedBlendIndependentBlend; - VkBool32 advancedBlendNonPremultipliedSrcColor; - VkBool32 advancedBlendNonPremultipliedDstColor; - VkBool32 advancedBlendCorrelatedOverlap; - VkBool32 advancedBlendAllOperations; -} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; - -typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 srcPremultiplied; - VkBool32 dstPremultiplied; - VkBlendOverlapEXT blendOverlap; -} VkPipelineColorBlendAdvancedStateCreateInfoEXT; - - - -// VK_NV_fragment_coverage_to_color is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_fragment_coverage_to_color 1 -#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1 -#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color" -typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; -typedef struct VkPipelineCoverageToColorStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCoverageToColorStateCreateFlagsNV flags; - VkBool32 coverageToColorEnable; - uint32_t coverageToColorLocation; -} VkPipelineCoverageToColorStateCreateInfoNV; - - - -// VK_NV_framebuffer_mixed_samples is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_framebuffer_mixed_samples 1 -#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1 -#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples" - -typedef enum VkCoverageModulationModeNV { - VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, - VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, - VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, - VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, - VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF -} VkCoverageModulationModeNV; -typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; -typedef struct VkPipelineCoverageModulationStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCoverageModulationStateCreateFlagsNV flags; - VkCoverageModulationModeNV coverageModulationMode; - VkBool32 coverageModulationTableEnable; - uint32_t coverageModulationTableCount; - const float* pCoverageModulationTable; -} VkPipelineCoverageModulationStateCreateInfoNV; - -typedef VkAttachmentSampleCountInfoAMD VkAttachmentSampleCountInfoNV; - - - -// VK_NV_fill_rectangle is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_fill_rectangle 1 -#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1 -#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle" - - -// VK_NV_shader_sm_builtins is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_shader_sm_builtins 1 -#define VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION 1 -#define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins" -typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t shaderSMCount; - uint32_t shaderWarpsPerSM; -} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV; - -typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 shaderSMBuiltins; -} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV; - - - -// VK_EXT_post_depth_coverage is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_post_depth_coverage 1 -#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1 -#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage" - - -// VK_EXT_image_drm_format_modifier is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_image_drm_format_modifier 1 -#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 2 -#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier" -typedef struct VkDrmFormatModifierPropertiesEXT { - uint64_t drmFormatModifier; - uint32_t drmFormatModifierPlaneCount; - VkFormatFeatureFlags drmFormatModifierTilingFeatures; -} VkDrmFormatModifierPropertiesEXT; - -typedef struct VkDrmFormatModifierPropertiesListEXT { - VkStructureType sType; - void* pNext; - uint32_t drmFormatModifierCount; - VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; -} VkDrmFormatModifierPropertiesListEXT; - -typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT { - VkStructureType sType; - const void* pNext; - uint64_t drmFormatModifier; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; -} VkPhysicalDeviceImageDrmFormatModifierInfoEXT; - -typedef struct VkImageDrmFormatModifierListCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t drmFormatModifierCount; - const uint64_t* pDrmFormatModifiers; -} VkImageDrmFormatModifierListCreateInfoEXT; - -typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint64_t drmFormatModifier; - uint32_t drmFormatModifierPlaneCount; - const VkSubresourceLayout* pPlaneLayouts; -} VkImageDrmFormatModifierExplicitCreateInfoEXT; - -typedef struct VkImageDrmFormatModifierPropertiesEXT { - VkStructureType sType; - void* pNext; - uint64_t drmFormatModifier; -} VkImageDrmFormatModifierPropertiesEXT; - -typedef struct VkDrmFormatModifierProperties2EXT { - uint64_t drmFormatModifier; - uint32_t drmFormatModifierPlaneCount; - VkFormatFeatureFlags2 drmFormatModifierTilingFeatures; -} VkDrmFormatModifierProperties2EXT; - -typedef struct VkDrmFormatModifierPropertiesList2EXT { - VkStructureType sType; - void* pNext; - uint32_t drmFormatModifierCount; - VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties; -} VkDrmFormatModifierPropertiesList2EXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT( - VkDevice device, - VkImage image, - VkImageDrmFormatModifierPropertiesEXT* pProperties); -#endif -#endif - - -// VK_EXT_validation_cache is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_validation_cache 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT) -#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1 -#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache" - -typedef enum VkValidationCacheHeaderVersionEXT { - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, - VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationCacheHeaderVersionEXT; -typedef VkFlags VkValidationCacheCreateFlagsEXT; -typedef struct VkValidationCacheCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkValidationCacheCreateFlagsEXT flags; - size_t initialDataSize; - const void* pInitialData; -} VkValidationCacheCreateInfoEXT; - -typedef struct VkShaderModuleValidationCacheCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkValidationCacheEXT validationCache; -} VkShaderModuleValidationCacheCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); -typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); -typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT( - VkDevice device, - const VkValidationCacheCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkValidationCacheEXT* pValidationCache); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT( - VkDevice device, - VkValidationCacheEXT dstCache, - uint32_t srcCacheCount, - const VkValidationCacheEXT* pSrcCaches); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - size_t* pDataSize, - void* pData); -#endif -#endif - - -// VK_EXT_descriptor_indexing is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_descriptor_indexing 1 -#define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2 -#define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing" -typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT; - -typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT; - -typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; - -typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT; - -typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT; - -typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; - -typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; - - - -// VK_EXT_shader_viewport_index_layer is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_viewport_index_layer 1 -#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1 -#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer" - - -// VK_NV_shading_rate_image is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_shading_rate_image 1 -#define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3 -#define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image" - -typedef enum VkShadingRatePaletteEntryNV { - VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0, - VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1, - VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2, - VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3, - VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11, - VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF -} VkShadingRatePaletteEntryNV; - -typedef enum VkCoarseSampleOrderTypeNV { - VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0, - VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1, - VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2, - VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3, - VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkCoarseSampleOrderTypeNV; -typedef struct VkShadingRatePaletteNV { - uint32_t shadingRatePaletteEntryCount; - const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries; -} VkShadingRatePaletteNV; - -typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 shadingRateImageEnable; - uint32_t viewportCount; - const VkShadingRatePaletteNV* pShadingRatePalettes; -} VkPipelineViewportShadingRateImageStateCreateInfoNV; - -typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 shadingRateImage; - VkBool32 shadingRateCoarseSampleOrder; -} VkPhysicalDeviceShadingRateImageFeaturesNV; - -typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV { - VkStructureType sType; - void* pNext; - VkExtent2D shadingRateTexelSize; - uint32_t shadingRatePaletteSize; - uint32_t shadingRateMaxCoarseSamples; -} VkPhysicalDeviceShadingRateImagePropertiesNV; - -typedef struct VkCoarseSampleLocationNV { - uint32_t pixelX; - uint32_t pixelY; - uint32_t sample; -} VkCoarseSampleLocationNV; - -typedef struct VkCoarseSampleOrderCustomNV { - VkShadingRatePaletteEntryNV shadingRate; - uint32_t sampleCount; - uint32_t sampleLocationCount; - const VkCoarseSampleLocationNV* pSampleLocations; -} VkCoarseSampleOrderCustomNV; - -typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkCoarseSampleOrderTypeNV sampleOrderType; - uint32_t customSampleOrderCount; - const VkCoarseSampleOrderCustomNV* pCustomSampleOrders; -} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; - -typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); -typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes); -typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV( - VkCommandBuffer commandBuffer, - VkImageView imageView, - VkImageLayout imageLayout); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkShadingRatePaletteNV* pShadingRatePalettes); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV( - VkCommandBuffer commandBuffer, - VkCoarseSampleOrderTypeNV sampleOrderType, - uint32_t customSampleOrderCount, - const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); -#endif -#endif - - -// VK_NV_ray_tracing is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_ray_tracing 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV) -#define VK_NV_RAY_TRACING_SPEC_VERSION 3 -#define VK_NV_RAY_TRACING_EXTENSION_NAME "VK_NV_ray_tracing" -#define VK_SHADER_UNUSED_KHR (~0U) -#define VK_SHADER_UNUSED_NV VK_SHADER_UNUSED_KHR - -typedef enum VkRayTracingShaderGroupTypeKHR { - VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0, - VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1, - VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2, - VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR, - VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR, - VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR, - VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkRayTracingShaderGroupTypeKHR; -typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV; - - -typedef enum VkGeometryTypeKHR { - VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0, - VK_GEOMETRY_TYPE_AABBS_KHR = 1, - VK_GEOMETRY_TYPE_INSTANCES_KHR = 2, - VK_GEOMETRY_TYPE_SPHERES_NV = 1000429004, - VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV = 1000429005, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX = 1000478000, -#endif - VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR, - VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR, - VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkGeometryTypeKHR; -typedef VkGeometryTypeKHR VkGeometryTypeNV; - - -typedef enum VkAccelerationStructureTypeKHR { - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, - VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, - VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureTypeKHR; -typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV; - - -typedef enum VkCopyAccelerationStructureModeKHR { - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0, - VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1, - VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2, - VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3, - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR, - VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, - VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkCopyAccelerationStructureModeKHR; -typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV; - - -typedef enum VkAccelerationStructureMemoryRequirementsTypeNV { - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0, - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1, - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2, - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkAccelerationStructureMemoryRequirementsTypeNV; - -typedef enum VkGeometryFlagBitsKHR { - VK_GEOMETRY_OPAQUE_BIT_KHR = 0x00000001, - VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0x00000002, - VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR, - VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR, - VK_GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkGeometryFlagBitsKHR; -typedef VkFlags VkGeometryFlagsKHR; -typedef VkGeometryFlagsKHR VkGeometryFlagsNV; - -typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV; - - -typedef enum VkGeometryInstanceFlagBitsKHR { - VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0x00000001, - VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002, - VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004, - VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008, - VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT = 0x00000010, - VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000020, - VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, - VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, - VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, - VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, - VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, - // VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT is a legacy alias - VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, - // VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT is a legacy alias - VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT, - VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkGeometryInstanceFlagBitsKHR; -typedef VkFlags VkGeometryInstanceFlagsKHR; -typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV; - -typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV; - - -typedef enum VkBuildAccelerationStructureFlagBitsKHR { - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0x00000001, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0x00000002, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0x00000004, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008, - VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010, - VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT = 0x00000040, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT = 0x00000080, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT = 0x00000100, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV = 0x00000200, -#endif - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR = 0x00000800, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV = 0x00001000, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, - // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT is a legacy alias - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, - // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT is a legacy alias - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, - // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT is a legacy alias - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT, -#ifdef VK_ENABLE_BETA_EXTENSIONS - // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV is a legacy alias - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV, -#endif - // VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR is a legacy alias - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkBuildAccelerationStructureFlagBitsKHR; -typedef VkFlags VkBuildAccelerationStructureFlagsKHR; -typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV; - -typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV; - -typedef struct VkRayTracingShaderGroupCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkRayTracingShaderGroupTypeKHR type; - uint32_t generalShader; - uint32_t closestHitShader; - uint32_t anyHitShader; - uint32_t intersectionShader; -} VkRayTracingShaderGroupCreateInfoNV; - -typedef struct VkRayTracingPipelineCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - uint32_t groupCount; - const VkRayTracingShaderGroupCreateInfoNV* pGroups; - uint32_t maxRecursionDepth; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkRayTracingPipelineCreateInfoNV; - -typedef struct VkGeometryTrianglesNV { - VkStructureType sType; - const void* pNext; - VkBuffer vertexData; - VkDeviceSize vertexOffset; - uint32_t vertexCount; - VkDeviceSize vertexStride; - VkFormat vertexFormat; - VkBuffer indexData; - VkDeviceSize indexOffset; - uint32_t indexCount; - VkIndexType indexType; - VkBuffer transformData; - VkDeviceSize transformOffset; -} VkGeometryTrianglesNV; - -typedef struct VkGeometryAABBNV { - VkStructureType sType; - const void* pNext; - VkBuffer aabbData; - uint32_t numAABBs; - uint32_t stride; - VkDeviceSize offset; -} VkGeometryAABBNV; - -typedef struct VkGeometryDataNV { - VkGeometryTrianglesNV triangles; - VkGeometryAABBNV aabbs; -} VkGeometryDataNV; - -typedef struct VkGeometryNV { - VkStructureType sType; - const void* pNext; - VkGeometryTypeKHR geometryType; - VkGeometryDataNV geometry; - VkGeometryFlagsKHR flags; -} VkGeometryNV; - -typedef struct VkAccelerationStructureInfoNV { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureTypeNV type; - VkBuildAccelerationStructureFlagsNV flags; - uint32_t instanceCount; - uint32_t geometryCount; - const VkGeometryNV* pGeometries; -} VkAccelerationStructureInfoNV; - -typedef struct VkAccelerationStructureCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkDeviceSize compactedSize; - VkAccelerationStructureInfoNV info; -} VkAccelerationStructureCreateInfoNV; - -typedef struct VkBindAccelerationStructureMemoryInfoNV { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureNV accelerationStructure; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; -} VkBindAccelerationStructureMemoryInfoNV; - -typedef struct VkWriteDescriptorSetAccelerationStructureNV { - VkStructureType sType; - const void* pNext; - uint32_t accelerationStructureCount; - const VkAccelerationStructureNV* pAccelerationStructures; -} VkWriteDescriptorSetAccelerationStructureNV; - -typedef struct VkAccelerationStructureMemoryRequirementsInfoNV { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureMemoryRequirementsTypeNV type; - VkAccelerationStructureNV accelerationStructure; -} VkAccelerationStructureMemoryRequirementsInfoNV; - -typedef struct VkPhysicalDeviceRayTracingPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t shaderGroupHandleSize; - uint32_t maxRecursionDepth; - uint32_t maxShaderGroupStride; - uint32_t shaderGroupBaseAlignment; - uint64_t maxGeometryCount; - uint64_t maxInstanceCount; - uint64_t maxTriangleCount; - uint32_t maxDescriptorSetAccelerationStructures; -} VkPhysicalDeviceRayTracingPropertiesNV; - -typedef struct VkTransformMatrixKHR { - float matrix[3][4]; -} VkTransformMatrixKHR; - -typedef VkTransformMatrixKHR VkTransformMatrixNV; - -typedef struct VkAabbPositionsKHR { - float minX; - float minY; - float minZ; - float maxX; - float maxY; - float maxZ; -} VkAabbPositionsKHR; - -typedef VkAabbPositionsKHR VkAabbPositionsNV; - -typedef struct VkAccelerationStructureInstanceKHR { - VkTransformMatrixKHR transform; - uint32_t instanceCustomIndex:24; - uint32_t mask:8; - uint32_t instanceShaderBindingTableRecordOffset:24; - VkGeometryInstanceFlagsKHR flags:8; - uint64_t accelerationStructureReference; -} VkAccelerationStructureInstanceKHR; - -typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure); -typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); -typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); -typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); -typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode); -typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth); -typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV( - VkDevice device, - const VkAccelerationStructureCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureNV* pAccelerationStructure); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV( - VkDevice device, - const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2KHR* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV( - VkDevice device, - uint32_t bindInfoCount, - const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV( - VkCommandBuffer commandBuffer, - const VkAccelerationStructureInfoNV* pInfo, - VkBuffer instanceData, - VkDeviceSize instanceOffset, - VkBool32 update, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkBuffer scratch, - VkDeviceSize scratchOffset); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV( - VkCommandBuffer commandBuffer, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkCopyAccelerationStructureModeKHR mode); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV( - VkCommandBuffer commandBuffer, - VkBuffer raygenShaderBindingTableBuffer, - VkDeviceSize raygenShaderBindingOffset, - VkBuffer missShaderBindingTableBuffer, - VkDeviceSize missShaderBindingOffset, - VkDeviceSize missShaderBindingStride, - VkBuffer hitShaderBindingTableBuffer, - VkDeviceSize hitShaderBindingOffset, - VkDeviceSize hitShaderBindingStride, - VkBuffer callableShaderBindingTableBuffer, - VkDeviceSize callableShaderBindingOffset, - VkDeviceSize callableShaderBindingStride, - uint32_t width, - uint32_t height, - uint32_t depth); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoNV* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - size_t dataSize, - void* pData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV( - VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureNV* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV( - VkDevice device, - VkPipeline pipeline, - uint32_t shader); -#endif -#endif - - -// VK_NV_representative_fragment_test is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_representative_fragment_test 1 -#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2 -#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test" -typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 representativeFragmentTest; -} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; - -typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 representativeFragmentTestEnable; -} VkPipelineRepresentativeFragmentTestStateCreateInfoNV; - - - -// VK_EXT_filter_cubic is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_filter_cubic 1 -#define VK_EXT_FILTER_CUBIC_SPEC_VERSION 3 -#define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic" -typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT { - VkStructureType sType; - void* pNext; - VkImageViewType imageViewType; -} VkPhysicalDeviceImageViewImageFormatInfoEXT; - -typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 filterCubic; - VkBool32 filterCubicMinmax; -} VkFilterCubicImageViewImageFormatPropertiesEXT; - - - -// VK_QCOM_render_pass_shader_resolve is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_render_pass_shader_resolve 1 -#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION 4 -#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME "VK_QCOM_render_pass_shader_resolve" - - -// VK_EXT_global_priority is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_global_priority 1 -#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2 -#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority" -typedef VkQueueGlobalPriority VkQueueGlobalPriorityEXT; - -typedef VkDeviceQueueGlobalPriorityCreateInfo VkDeviceQueueGlobalPriorityCreateInfoEXT; - - - -// VK_EXT_external_memory_host is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_external_memory_host 1 -#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1 -#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host" -typedef struct VkImportMemoryHostPointerInfoEXT { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - void* pHostPointer; -} VkImportMemoryHostPointerInfoEXT; - -typedef struct VkMemoryHostPointerPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryHostPointerPropertiesEXT; - -typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize minImportedHostPointerAlignment; -} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - const void* pHostPointer, - VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); -#endif -#endif - - -// VK_AMD_buffer_marker is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_buffer_marker 1 -#define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1 -#define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker" -typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); -typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker); -#endif -#endif - - -// VK_AMD_pipeline_compiler_control is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_pipeline_compiler_control 1 -#define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1 -#define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control" - -typedef enum VkPipelineCompilerControlFlagBitsAMD { - VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF -} VkPipelineCompilerControlFlagBitsAMD; -typedef VkFlags VkPipelineCompilerControlFlagsAMD; -typedef struct VkPipelineCompilerControlCreateInfoAMD { - VkStructureType sType; - const void* pNext; - VkPipelineCompilerControlFlagsAMD compilerControlFlags; -} VkPipelineCompilerControlCreateInfoAMD; - - - -// VK_EXT_calibrated_timestamps is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_calibrated_timestamps 1 -#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2 -#define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps" -typedef VkTimeDomainKHR VkTimeDomainEXT; - -typedef VkCalibratedTimestampInfoKHR VkCalibratedTimestampInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainKHR* pTimeDomains); -typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoKHR* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( - VkPhysicalDevice physicalDevice, - uint32_t* pTimeDomainCount, - VkTimeDomainKHR* pTimeDomains); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT( - VkDevice device, - uint32_t timestampCount, - const VkCalibratedTimestampInfoKHR* pTimestampInfos, - uint64_t* pTimestamps, - uint64_t* pMaxDeviation); -#endif -#endif - - -// VK_AMD_shader_core_properties is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_shader_core_properties 1 -#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2 -#define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties" -typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { - VkStructureType sType; - void* pNext; - uint32_t shaderEngineCount; - uint32_t shaderArraysPerEngineCount; - uint32_t computeUnitsPerShaderArray; - uint32_t simdPerComputeUnit; - uint32_t wavefrontsPerSimd; - uint32_t wavefrontSize; - uint32_t sgprsPerSimd; - uint32_t minSgprAllocation; - uint32_t maxSgprAllocation; - uint32_t sgprAllocationGranularity; - uint32_t vgprsPerSimd; - uint32_t minVgprAllocation; - uint32_t maxVgprAllocation; - uint32_t vgprAllocationGranularity; -} VkPhysicalDeviceShaderCorePropertiesAMD; - - - -// VK_AMD_memory_overallocation_behavior is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_memory_overallocation_behavior 1 -#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1 -#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior" - -typedef enum VkMemoryOverallocationBehaviorAMD { - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0, - VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1, - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2, - VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF -} VkMemoryOverallocationBehaviorAMD; -typedef struct VkDeviceMemoryOverallocationCreateInfoAMD { - VkStructureType sType; - const void* pNext; - VkMemoryOverallocationBehaviorAMD overallocationBehavior; -} VkDeviceMemoryOverallocationCreateInfoAMD; - - - -// VK_EXT_vertex_attribute_divisor is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_vertex_attribute_divisor 1 -#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3 -#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor" -typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxVertexAttribDivisor; -} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; - -typedef VkVertexInputBindingDivisorDescription VkVertexInputBindingDivisorDescriptionEXT; - -typedef VkPipelineVertexInputDivisorStateCreateInfo VkPipelineVertexInputDivisorStateCreateInfoEXT; - -typedef VkPhysicalDeviceVertexAttributeDivisorFeatures VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; - - - -// VK_EXT_pipeline_creation_feedback is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_pipeline_creation_feedback 1 -#define VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION 1 -#define VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME "VK_EXT_pipeline_creation_feedback" -typedef VkPipelineCreationFeedbackFlagBits VkPipelineCreationFeedbackFlagBitsEXT; - -typedef VkPipelineCreationFeedbackFlags VkPipelineCreationFeedbackFlagsEXT; - -typedef VkPipelineCreationFeedbackCreateInfo VkPipelineCreationFeedbackCreateInfoEXT; - -typedef VkPipelineCreationFeedback VkPipelineCreationFeedbackEXT; - - - -// VK_NV_shader_subgroup_partitioned is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_shader_subgroup_partitioned 1 -#define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1 -#define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned" - - -// VK_NV_compute_shader_derivatives is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_compute_shader_derivatives 1 -#define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1 -#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives" -typedef VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; - - - -// VK_NV_mesh_shader is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_mesh_shader 1 -#define VK_NV_MESH_SHADER_SPEC_VERSION 1 -#define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader" -typedef struct VkPhysicalDeviceMeshShaderFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 taskShader; - VkBool32 meshShader; -} VkPhysicalDeviceMeshShaderFeaturesNV; - -typedef struct VkPhysicalDeviceMeshShaderPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t maxDrawMeshTasksCount; - uint32_t maxTaskWorkGroupInvocations; - uint32_t maxTaskWorkGroupSize[3]; - uint32_t maxTaskTotalMemorySize; - uint32_t maxTaskOutputCount; - uint32_t maxMeshWorkGroupInvocations; - uint32_t maxMeshWorkGroupSize[3]; - uint32_t maxMeshTotalMemorySize; - uint32_t maxMeshOutputVertices; - uint32_t maxMeshOutputPrimitives; - uint32_t maxMeshMultiviewViewCount; - uint32_t meshOutputPerVertexGranularity; - uint32_t meshOutputPerPrimitiveGranularity; -} VkPhysicalDeviceMeshShaderPropertiesNV; - -typedef struct VkDrawMeshTasksIndirectCommandNV { - uint32_t taskCount; - uint32_t firstTask; -} VkDrawMeshTasksIndirectCommandNV; - -typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); -typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV( - VkCommandBuffer commandBuffer, - uint32_t taskCount, - uint32_t firstTask); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); -#endif -#endif - - -// VK_NV_fragment_shader_barycentric is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_fragment_shader_barycentric 1 -#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1 -#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric" -typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; - - - -// VK_NV_shader_image_footprint is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_shader_image_footprint 1 -#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2 -#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint" -typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 imageFootprint; -} VkPhysicalDeviceShaderImageFootprintFeaturesNV; - - - -// VK_NV_scissor_exclusive is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_scissor_exclusive 1 -#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 2 -#define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive" -typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t exclusiveScissorCount; - const VkRect2D* pExclusiveScissors; -} VkPipelineViewportExclusiveScissorStateCreateInfoNV; - -typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 exclusiveScissor; -} VkPhysicalDeviceExclusiveScissorFeaturesNV; - -typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorEnableNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables); -typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorEnableNV( - VkCommandBuffer commandBuffer, - uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const VkBool32* pExclusiveScissorEnables); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV( - VkCommandBuffer commandBuffer, - uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const VkRect2D* pExclusiveScissors); -#endif -#endif - - -// VK_NV_device_diagnostic_checkpoints is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_device_diagnostic_checkpoints 1 -#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2 -#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints" -typedef struct VkQueueFamilyCheckpointPropertiesNV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlags checkpointExecutionStageMask; -} VkQueueFamilyCheckpointPropertiesNV; - -typedef struct VkCheckpointDataNV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlagBits stage; - void* pCheckpointMarker; -} VkCheckpointDataNV; - -typedef struct VkQueueFamilyCheckpointProperties2NV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlags2 checkpointExecutionStageMask; -} VkQueueFamilyCheckpointProperties2NV; - -typedef struct VkCheckpointData2NV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlags2 stage; - void* pCheckpointMarker; -} VkCheckpointData2NV; - -typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker); -typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData); -typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV( - VkCommandBuffer commandBuffer, - const void* pCheckpointMarker); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV( - VkQueue queue, - uint32_t* pCheckpointDataCount, - VkCheckpointDataNV* pCheckpointData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV( - VkQueue queue, - uint32_t* pCheckpointDataCount, - VkCheckpointData2NV* pCheckpointData); -#endif -#endif - - -// VK_EXT_present_timing is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_present_timing 1 -#define VK_EXT_PRESENT_TIMING_SPEC_VERSION 3 -#define VK_EXT_PRESENT_TIMING_EXTENSION_NAME "VK_EXT_present_timing" - -typedef enum VkPresentStageFlagBitsEXT { - VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT = 0x00000001, - VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT = 0x00000002, - VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT = 0x00000004, - VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT = 0x00000008, - VK_PRESENT_STAGE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkPresentStageFlagBitsEXT; -typedef VkFlags VkPresentStageFlagsEXT; - -typedef enum VkPastPresentationTimingFlagBitsEXT { - VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT = 0x00000001, - VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT = 0x00000002, - VK_PAST_PRESENTATION_TIMING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkPastPresentationTimingFlagBitsEXT; -typedef VkFlags VkPastPresentationTimingFlagsEXT; - -typedef enum VkPresentTimingInfoFlagBitsEXT { - VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT = 0x00000001, - VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT = 0x00000002, - VK_PRESENT_TIMING_INFO_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkPresentTimingInfoFlagBitsEXT; -typedef VkFlags VkPresentTimingInfoFlagsEXT; -typedef struct VkPhysicalDevicePresentTimingFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 presentTiming; - VkBool32 presentAtAbsoluteTime; - VkBool32 presentAtRelativeTime; -} VkPhysicalDevicePresentTimingFeaturesEXT; - -typedef struct VkPresentTimingSurfaceCapabilitiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 presentTimingSupported; - VkBool32 presentAtAbsoluteTimeSupported; - VkBool32 presentAtRelativeTimeSupported; - VkPresentStageFlagsEXT presentStageQueries; -} VkPresentTimingSurfaceCapabilitiesEXT; - -typedef struct VkSwapchainCalibratedTimestampInfoEXT { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - VkPresentStageFlagsEXT presentStage; - uint64_t timeDomainId; -} VkSwapchainCalibratedTimestampInfoEXT; - -typedef struct VkSwapchainTimingPropertiesEXT { - VkStructureType sType; - void* pNext; - uint64_t refreshDuration; - uint64_t refreshInterval; -} VkSwapchainTimingPropertiesEXT; - -typedef struct VkSwapchainTimeDomainPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t timeDomainCount; - VkTimeDomainKHR* pTimeDomains; - uint64_t* pTimeDomainIds; -} VkSwapchainTimeDomainPropertiesEXT; - -typedef struct VkPastPresentationTimingInfoEXT { - VkStructureType sType; - const void* pNext; - VkPastPresentationTimingFlagsEXT flags; - VkSwapchainKHR swapchain; -} VkPastPresentationTimingInfoEXT; - -typedef struct VkPresentStageTimeEXT { - VkPresentStageFlagsEXT stage; - uint64_t time; -} VkPresentStageTimeEXT; - -typedef struct VkPastPresentationTimingEXT { - VkStructureType sType; - void* pNext; - uint64_t presentId; - uint64_t targetTime; - uint32_t presentStageCount; - VkPresentStageTimeEXT* pPresentStages; - VkTimeDomainKHR timeDomain; - uint64_t timeDomainId; - VkBool32 reportComplete; -} VkPastPresentationTimingEXT; - -typedef struct VkPastPresentationTimingPropertiesEXT { - VkStructureType sType; - void* pNext; - uint64_t timingPropertiesCounter; - uint64_t timeDomainsCounter; - uint32_t presentationTimingCount; - VkPastPresentationTimingEXT* pPresentationTimings; -} VkPastPresentationTimingPropertiesEXT; - -typedef struct VkPresentTimingInfoEXT { - VkStructureType sType; - const void* pNext; - VkPresentTimingInfoFlagsEXT flags; - uint64_t targetTime; - uint64_t timeDomainId; - VkPresentStageFlagsEXT presentStageQueries; - VkPresentStageFlagsEXT targetTimeDomainPresentStage; -} VkPresentTimingInfoEXT; - -typedef struct VkPresentTimingsInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentTimingInfoEXT* pTimingInfos; -} VkPresentTimingsInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkSetSwapchainPresentTimingQueueSizeEXT)(VkDevice device, VkSwapchainKHR swapchain, uint32_t size); -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainTimingPropertiesEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, uint64_t* pSwapchainTimingPropertiesCounter); -typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainTimeDomainPropertiesEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, uint64_t* pTimeDomainsCounter); -typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingEXT)(VkDevice device, const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkSetSwapchainPresentTimingQueueSizeEXT( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t size); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimingPropertiesEXT( - VkDevice device, - VkSwapchainKHR swapchain, - VkSwapchainTimingPropertiesEXT* pSwapchainTimingProperties, - uint64_t* pSwapchainTimingPropertiesCounter); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainTimeDomainPropertiesEXT( - VkDevice device, - VkSwapchainKHR swapchain, - VkSwapchainTimeDomainPropertiesEXT* pSwapchainTimeDomainProperties, - uint64_t* pTimeDomainsCounter); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingEXT( - VkDevice device, - const VkPastPresentationTimingInfoEXT* pPastPresentationTimingInfo, - VkPastPresentationTimingPropertiesEXT* pPastPresentationTimingProperties); -#endif -#endif - - -// VK_INTEL_shader_integer_functions2 is a preprocessor guard. Do not pass it to API calls. -#define VK_INTEL_shader_integer_functions2 1 -#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1 -#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2" -typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { - VkStructureType sType; - void* pNext; - VkBool32 shaderIntegerFunctions2; -} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - - - -// VK_INTEL_performance_query is a preprocessor guard. Do not pass it to API calls. -#define VK_INTEL_performance_query 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL) -#define VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION 2 -#define VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME "VK_INTEL_performance_query" - -typedef enum VkPerformanceConfigurationTypeINTEL { - VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0, - VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceConfigurationTypeINTEL; - -typedef enum VkQueryPoolSamplingModeINTEL { - VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0, - VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkQueryPoolSamplingModeINTEL; - -typedef enum VkPerformanceOverrideTypeINTEL { - VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0, - VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1, - VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceOverrideTypeINTEL; - -typedef enum VkPerformanceParameterTypeINTEL { - VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0, - VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1, - VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceParameterTypeINTEL; - -typedef enum VkPerformanceValueTypeINTEL { - VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0, - VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1, - VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2, - VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3, - VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4, - VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceValueTypeINTEL; -typedef union VkPerformanceValueDataINTEL { - uint32_t value32; - uint64_t value64; - float valueFloat; - VkBool32 valueBool; - const char* valueString; -} VkPerformanceValueDataINTEL; - -typedef struct VkPerformanceValueINTEL { - VkPerformanceValueTypeINTEL type; - VkPerformanceValueDataINTEL data; -} VkPerformanceValueINTEL; - -typedef struct VkInitializePerformanceApiInfoINTEL { - VkStructureType sType; - const void* pNext; - void* pUserData; -} VkInitializePerformanceApiInfoINTEL; - -typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL { - VkStructureType sType; - const void* pNext; - VkQueryPoolSamplingModeINTEL performanceCountersSampling; -} VkQueryPoolPerformanceQueryCreateInfoINTEL; - -typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL; - -typedef struct VkPerformanceMarkerInfoINTEL { - VkStructureType sType; - const void* pNext; - uint64_t marker; -} VkPerformanceMarkerInfoINTEL; - -typedef struct VkPerformanceStreamMarkerInfoINTEL { - VkStructureType sType; - const void* pNext; - uint32_t marker; -} VkPerformanceStreamMarkerInfoINTEL; - -typedef struct VkPerformanceOverrideInfoINTEL { - VkStructureType sType; - const void* pNext; - VkPerformanceOverrideTypeINTEL type; - VkBool32 enable; - uint64_t parameter; -} VkPerformanceOverrideInfoINTEL; - -typedef struct VkPerformanceConfigurationAcquireInfoINTEL { - VkStructureType sType; - const void* pNext; - VkPerformanceConfigurationTypeINTEL type; -} VkPerformanceConfigurationAcquireInfoINTEL; - -typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); -typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device); -typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo); -typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration); -typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration); -typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration); -typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL( - VkDevice device, - const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL( - VkDevice device); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceMarkerInfoINTEL* pMarkerInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceOverrideInfoINTEL* pOverrideInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL( - VkDevice device, - const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, - VkPerformanceConfigurationINTEL* pConfiguration); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL( - VkDevice device, - VkPerformanceConfigurationINTEL configuration); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL( - VkQueue queue, - VkPerformanceConfigurationINTEL configuration); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL( - VkDevice device, - VkPerformanceParameterTypeINTEL parameter, - VkPerformanceValueINTEL* pValue); -#endif -#endif - - -// VK_EXT_pci_bus_info is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_pci_bus_info 1 -#define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2 -#define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info" -typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t pciDomain; - uint32_t pciBus; - uint32_t pciDevice; - uint32_t pciFunction; -} VkPhysicalDevicePCIBusInfoPropertiesEXT; - - - -// VK_AMD_display_native_hdr is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_display_native_hdr 1 -#define VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION 1 -#define VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME "VK_AMD_display_native_hdr" -typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD { - VkStructureType sType; - void* pNext; - VkBool32 localDimmingSupport; -} VkDisplayNativeHdrSurfaceCapabilitiesAMD; - -typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD { - VkStructureType sType; - const void* pNext; - VkBool32 localDimmingEnable; -} VkSwapchainDisplayNativeHdrCreateInfoAMD; - -typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD( - VkDevice device, - VkSwapchainKHR swapChain, - VkBool32 localDimmingEnable); -#endif -#endif - - -// VK_EXT_fragment_density_map is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_fragment_density_map 1 -#define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 3 -#define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map" -typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 fragmentDensityMap; - VkBool32 fragmentDensityMapDynamic; - VkBool32 fragmentDensityMapNonSubsampledImages; -} VkPhysicalDeviceFragmentDensityMapFeaturesEXT; - -typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT { - VkStructureType sType; - void* pNext; - VkExtent2D minFragmentDensityTexelSize; - VkExtent2D maxFragmentDensityTexelSize; - VkBool32 fragmentDensityInvocations; -} VkPhysicalDeviceFragmentDensityMapPropertiesEXT; - -typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkAttachmentReference fragmentDensityMapAttachment; -} VkRenderPassFragmentDensityMapCreateInfoEXT; - -typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkImageLayout imageLayout; -} VkRenderingFragmentDensityMapAttachmentInfoEXT; - - - -// VK_EXT_scalar_block_layout is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_scalar_block_layout 1 -#define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1 -#define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout" -typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT; - - - -// VK_GOOGLE_hlsl_functionality1 is a preprocessor guard. Do not pass it to API calls. -#define VK_GOOGLE_hlsl_functionality1 1 -#define VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION 1 -#define VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1" -// VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION is a legacy alias -#define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION -// VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME is a legacy alias -#define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME - - -// VK_GOOGLE_decorate_string is a preprocessor guard. Do not pass it to API calls. -#define VK_GOOGLE_decorate_string 1 -#define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1 -#define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string" - - -// VK_EXT_subgroup_size_control is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_subgroup_size_control 1 -#define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2 -#define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control" -typedef VkPhysicalDeviceSubgroupSizeControlFeatures VkPhysicalDeviceSubgroupSizeControlFeaturesEXT; - -typedef VkPhysicalDeviceSubgroupSizeControlProperties VkPhysicalDeviceSubgroupSizeControlPropertiesEXT; - -typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; - - - -// VK_AMD_shader_core_properties2 is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_shader_core_properties2 1 -#define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1 -#define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2" - -typedef enum VkShaderCorePropertiesFlagBitsAMD { - VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF -} VkShaderCorePropertiesFlagBitsAMD; -typedef VkFlags VkShaderCorePropertiesFlagsAMD; -typedef struct VkPhysicalDeviceShaderCoreProperties2AMD { - VkStructureType sType; - void* pNext; - VkShaderCorePropertiesFlagsAMD shaderCoreFeatures; - uint32_t activeComputeUnitCount; -} VkPhysicalDeviceShaderCoreProperties2AMD; - - - -// VK_AMD_device_coherent_memory is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_device_coherent_memory 1 -#define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1 -#define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory" -typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD { - VkStructureType sType; - void* pNext; - VkBool32 deviceCoherentMemory; -} VkPhysicalDeviceCoherentMemoryFeaturesAMD; - - - -// VK_EXT_shader_image_atomic_int64 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_image_atomic_int64 1 -#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1 -#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64" -typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderImageInt64Atomics; - VkBool32 sparseImageInt64Atomics; -} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; - - - -// VK_EXT_memory_budget is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_memory_budget 1 -#define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1 -#define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget" -typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS]; - VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryBudgetPropertiesEXT; - - - -// VK_EXT_memory_priority is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_memory_priority 1 -#define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1 -#define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority" -typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 memoryPriority; -} VkPhysicalDeviceMemoryPriorityFeaturesEXT; - -typedef struct VkMemoryPriorityAllocateInfoEXT { - VkStructureType sType; - const void* pNext; - float priority; -} VkMemoryPriorityAllocateInfoEXT; - - - -// VK_NV_dedicated_allocation_image_aliasing is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_dedicated_allocation_image_aliasing 1 -#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1 -#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing" -typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 dedicatedAllocationImageAliasing; -} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - - - -// VK_EXT_buffer_device_address is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_buffer_device_address 1 -#define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2 -#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address" -typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; -} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT; - -typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT; - -typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT; - -typedef struct VkBufferDeviceAddressCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceAddress deviceAddress; -} VkBufferDeviceAddressCreateInfoEXT; - -typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo); -#endif -#endif - - -// VK_EXT_tooling_info is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_tooling_info 1 -#define VK_EXT_TOOLING_INFO_SPEC_VERSION 1 -#define VK_EXT_TOOLING_INFO_EXTENSION_NAME "VK_EXT_tooling_info" -typedef VkToolPurposeFlagBits VkToolPurposeFlagBitsEXT; - -typedef VkToolPurposeFlags VkToolPurposeFlagsEXT; - -typedef VkPhysicalDeviceToolProperties VkPhysicalDeviceToolPropertiesEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT( - VkPhysicalDevice physicalDevice, - uint32_t* pToolCount, - VkPhysicalDeviceToolProperties* pToolProperties); -#endif -#endif - - -// VK_EXT_separate_stencil_usage is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_separate_stencil_usage 1 -#define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1 -#define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage" -typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT; - - - -// VK_EXT_validation_features is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_validation_features 1 -#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 6 -#define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features" - -typedef enum VkValidationFeatureEnableEXT { - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0, - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1, - VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2, - VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3, - VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4, - VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationFeatureEnableEXT; - -typedef enum VkValidationFeatureDisableEXT { - VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0, - VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1, - VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2, - VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3, - VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4, - VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5, - VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6, - VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7, - VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationFeatureDisableEXT; -typedef struct VkValidationFeaturesEXT { - VkStructureType sType; - const void* pNext; - uint32_t enabledValidationFeatureCount; - const VkValidationFeatureEnableEXT* pEnabledValidationFeatures; - uint32_t disabledValidationFeatureCount; - const VkValidationFeatureDisableEXT* pDisabledValidationFeatures; -} VkValidationFeaturesEXT; - - - -// VK_NV_cooperative_matrix is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_cooperative_matrix 1 -#define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1 -#define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix" -typedef VkComponentTypeKHR VkComponentTypeNV; - -typedef VkScopeKHR VkScopeNV; - -typedef struct VkCooperativeMatrixPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t MSize; - uint32_t NSize; - uint32_t KSize; - VkComponentTypeNV AType; - VkComponentTypeNV BType; - VkComponentTypeNV CType; - VkComponentTypeNV DType; - VkScopeNV scope; -} VkCooperativeMatrixPropertiesNV; - -typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 cooperativeMatrix; - VkBool32 cooperativeMatrixRobustBufferAccess; -} VkPhysicalDeviceCooperativeMatrixFeaturesNV; - -typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV { - VkStructureType sType; - void* pNext; - VkShaderStageFlags cooperativeMatrixSupportedStages; -} VkPhysicalDeviceCooperativeMatrixPropertiesNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeMatrixPropertiesNV* pProperties); -#endif -#endif - - -// VK_NV_coverage_reduction_mode is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_coverage_reduction_mode 1 -#define VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION 1 -#define VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME "VK_NV_coverage_reduction_mode" - -typedef enum VkCoverageReductionModeNV { - VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0, - VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1, - VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF -} VkCoverageReductionModeNV; -typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV; -typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 coverageReductionMode; -} VkPhysicalDeviceCoverageReductionModeFeaturesNV; - -typedef struct VkPipelineCoverageReductionStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCoverageReductionStateCreateFlagsNV flags; - VkCoverageReductionModeNV coverageReductionMode; -} VkPipelineCoverageReductionStateCreateInfoNV; - -typedef struct VkFramebufferMixedSamplesCombinationNV { - VkStructureType sType; - void* pNext; - VkCoverageReductionModeNV coverageReductionMode; - VkSampleCountFlagBits rasterizationSamples; - VkSampleCountFlags depthStencilSamples; - VkSampleCountFlags colorSamples; -} VkFramebufferMixedSamplesCombinationNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - VkPhysicalDevice physicalDevice, - uint32_t* pCombinationCount, - VkFramebufferMixedSamplesCombinationNV* pCombinations); -#endif -#endif - - -// VK_EXT_fragment_shader_interlock is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_fragment_shader_interlock 1 -#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1 -#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock" -typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 fragmentShaderSampleInterlock; - VkBool32 fragmentShaderPixelInterlock; - VkBool32 fragmentShaderShadingRateInterlock; -} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; - - - -// VK_EXT_ycbcr_image_arrays is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_ycbcr_image_arrays 1 -#define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1 -#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays" -typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 ycbcrImageArrays; -} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; - - - -// VK_EXT_provoking_vertex is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_provoking_vertex 1 -#define VK_EXT_PROVOKING_VERTEX_SPEC_VERSION 1 -#define VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME "VK_EXT_provoking_vertex" - -typedef enum VkProvokingVertexModeEXT { - VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0, - VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1, - VK_PROVOKING_VERTEX_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkProvokingVertexModeEXT; -typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 provokingVertexLast; - VkBool32 transformFeedbackPreservesProvokingVertex; -} VkPhysicalDeviceProvokingVertexFeaturesEXT; - -typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 provokingVertexModePerPipeline; - VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex; -} VkPhysicalDeviceProvokingVertexPropertiesEXT; - -typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkProvokingVertexModeEXT provokingVertexMode; -} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT; - - - -// VK_EXT_headless_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_headless_surface 1 -#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1 -#define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface" -typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; -typedef struct VkHeadlessSurfaceCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkHeadlessSurfaceCreateFlagsEXT flags; -} VkHeadlessSurfaceCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT( - VkInstance instance, - const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif -#endif - - -// VK_EXT_line_rasterization is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_line_rasterization 1 -#define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1 -#define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization" -typedef VkLineRasterizationMode VkLineRasterizationModeEXT; - -typedef VkPhysicalDeviceLineRasterizationFeatures VkPhysicalDeviceLineRasterizationFeaturesEXT; - -typedef VkPhysicalDeviceLineRasterizationProperties VkPhysicalDeviceLineRasterizationPropertiesEXT; - -typedef VkPipelineRasterizationLineStateCreateInfo VkPipelineRasterizationLineStateCreateInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern); -#endif -#endif - - -// VK_EXT_shader_atomic_float is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_atomic_float 1 -#define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1 -#define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float" -typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderBufferFloat32Atomics; - VkBool32 shaderBufferFloat32AtomicAdd; - VkBool32 shaderBufferFloat64Atomics; - VkBool32 shaderBufferFloat64AtomicAdd; - VkBool32 shaderSharedFloat32Atomics; - VkBool32 shaderSharedFloat32AtomicAdd; - VkBool32 shaderSharedFloat64Atomics; - VkBool32 shaderSharedFloat64AtomicAdd; - VkBool32 shaderImageFloat32Atomics; - VkBool32 shaderImageFloat32AtomicAdd; - VkBool32 sparseImageFloat32Atomics; - VkBool32 sparseImageFloat32AtomicAdd; -} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; - - - -// VK_EXT_host_query_reset is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_host_query_reset 1 -#define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1 -#define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset" -typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT; - -typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount); -#endif -#endif - - -// VK_EXT_index_type_uint8 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_index_type_uint8 1 -#define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1 -#define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8" -typedef VkPhysicalDeviceIndexTypeUint8Features VkPhysicalDeviceIndexTypeUint8FeaturesEXT; - - - -// VK_EXT_extended_dynamic_state is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_extended_dynamic_state 1 -#define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1 -#define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state" -typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 extendedDynamicState; -} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); -typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); -typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); -typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); -typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); -typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT( - VkCommandBuffer commandBuffer, - VkCullModeFlags cullMode); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT( - VkCommandBuffer commandBuffer, - VkFrontFace frontFace); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT( - VkCommandBuffer commandBuffer, - VkPrimitiveTopology primitiveTopology); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t viewportCount, - const VkViewport* pViewports); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes, - const VkDeviceSize* pStrides); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthTestEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthWriteEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT( - VkCommandBuffer commandBuffer, - VkCompareOp depthCompareOp); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBoundsTestEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 stencilTestEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp); -#endif -#endif - - -// VK_EXT_host_image_copy is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_host_image_copy 1 -#define VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION 1 -#define VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME "VK_EXT_host_image_copy" -typedef VkHostImageCopyFlagBits VkHostImageCopyFlagBitsEXT; - -typedef VkHostImageCopyFlags VkHostImageCopyFlagsEXT; - -typedef VkPhysicalDeviceHostImageCopyFeatures VkPhysicalDeviceHostImageCopyFeaturesEXT; - -typedef VkPhysicalDeviceHostImageCopyProperties VkPhysicalDeviceHostImageCopyPropertiesEXT; - -typedef VkMemoryToImageCopy VkMemoryToImageCopyEXT; - -typedef VkImageToMemoryCopy VkImageToMemoryCopyEXT; - -typedef VkCopyMemoryToImageInfo VkCopyMemoryToImageInfoEXT; - -typedef VkCopyImageToMemoryInfo VkCopyImageToMemoryInfoEXT; - -typedef VkCopyImageToImageInfo VkCopyImageToImageInfoEXT; - -typedef VkHostImageLayoutTransitionInfo VkHostImageLayoutTransitionInfoEXT; - -typedef VkSubresourceHostMemcpySize VkSubresourceHostMemcpySizeEXT; - -typedef VkHostImageCopyDevicePerformanceQuery VkHostImageCopyDevicePerformanceQueryEXT; - -typedef VkSubresourceLayout2 VkSubresourceLayout2EXT; - -typedef VkImageSubresource2 VkImageSubresource2EXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToImageEXT)(VkDevice device, const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToMemoryEXT)(VkDevice device, const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyImageToImageEXT)(VkDevice device, const VkCopyImageToImageInfo* pCopyImageToImageInfo); -typedef VkResult (VKAPI_PTR *PFN_vkTransitionImageLayoutEXT)(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfo* pTransitions); -typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2* pSubresource, VkSubresourceLayout2* pLayout); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToImageEXT( - VkDevice device, - const VkCopyMemoryToImageInfo* pCopyMemoryToImageInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToMemoryEXT( - VkDevice device, - const VkCopyImageToMemoryInfo* pCopyImageToMemoryInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCopyImageToImageEXT( - VkDevice device, - const VkCopyImageToImageInfo* pCopyImageToImageInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkTransitionImageLayoutEXT( - VkDevice device, - uint32_t transitionCount, - const VkHostImageLayoutTransitionInfo* pTransitions); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout2EXT( - VkDevice device, - VkImage image, - const VkImageSubresource2* pSubresource, - VkSubresourceLayout2* pLayout); -#endif -#endif - - -// VK_EXT_map_memory_placed is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_map_memory_placed 1 -#define VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION 1 -#define VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME "VK_EXT_map_memory_placed" -typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 memoryMapPlaced; - VkBool32 memoryMapRangePlaced; - VkBool32 memoryUnmapReserve; -} VkPhysicalDeviceMapMemoryPlacedFeaturesEXT; - -typedef struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize minPlacedMemoryMapAlignment; -} VkPhysicalDeviceMapMemoryPlacedPropertiesEXT; - -typedef struct VkMemoryMapPlacedInfoEXT { - VkStructureType sType; - const void* pNext; - void* pPlacedAddress; -} VkMemoryMapPlacedInfoEXT; - - - -// VK_EXT_shader_atomic_float2 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_atomic_float2 1 -#define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1 -#define VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME "VK_EXT_shader_atomic_float2" -typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderBufferFloat16Atomics; - VkBool32 shaderBufferFloat16AtomicAdd; - VkBool32 shaderBufferFloat16AtomicMinMax; - VkBool32 shaderBufferFloat32AtomicMinMax; - VkBool32 shaderBufferFloat64AtomicMinMax; - VkBool32 shaderSharedFloat16Atomics; - VkBool32 shaderSharedFloat16AtomicAdd; - VkBool32 shaderSharedFloat16AtomicMinMax; - VkBool32 shaderSharedFloat32AtomicMinMax; - VkBool32 shaderSharedFloat64AtomicMinMax; - VkBool32 shaderImageFloat32AtomicMinMax; - VkBool32 sparseImageFloat32AtomicMinMax; -} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; - - - -// VK_EXT_surface_maintenance1 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_surface_maintenance1 1 -#define VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION 1 -#define VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME "VK_EXT_surface_maintenance1" -typedef VkPresentScalingFlagBitsKHR VkPresentScalingFlagBitsEXT; - -typedef VkPresentScalingFlagsKHR VkPresentScalingFlagsEXT; - -typedef VkPresentGravityFlagBitsKHR VkPresentGravityFlagBitsEXT; - -typedef VkPresentGravityFlagsKHR VkPresentGravityFlagsEXT; - -typedef VkSurfacePresentModeKHR VkSurfacePresentModeEXT; - -typedef VkSurfacePresentScalingCapabilitiesKHR VkSurfacePresentScalingCapabilitiesEXT; - -typedef VkSurfacePresentModeCompatibilityKHR VkSurfacePresentModeCompatibilityEXT; - - - -// VK_EXT_swapchain_maintenance1 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_swapchain_maintenance1 1 -#define VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION 1 -#define VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME "VK_EXT_swapchain_maintenance1" -typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT; - -typedef VkSwapchainPresentFenceInfoKHR VkSwapchainPresentFenceInfoEXT; - -typedef VkSwapchainPresentModesCreateInfoKHR VkSwapchainPresentModesCreateInfoEXT; - -typedef VkSwapchainPresentModeInfoKHR VkSwapchainPresentModeInfoEXT; - -typedef VkSwapchainPresentScalingCreateInfoKHR VkSwapchainPresentScalingCreateInfoEXT; - -typedef VkReleaseSwapchainImagesInfoKHR VkReleaseSwapchainImagesInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkReleaseSwapchainImagesEXT)(VkDevice device, const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkReleaseSwapchainImagesEXT( - VkDevice device, - const VkReleaseSwapchainImagesInfoKHR* pReleaseInfo); -#endif -#endif - - -// VK_EXT_shader_demote_to_helper_invocation is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_demote_to_helper_invocation 1 -#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1 -#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation" -typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; - - - -// VK_NV_device_generated_commands is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_device_generated_commands 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV) -#define VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3 -#define VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NV_device_generated_commands" - -typedef enum VkIndirectCommandsTokenTypeNV { - VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV = 1000135000, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV = 1000328000, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV = 1000428003, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV = 1000428004, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkIndirectCommandsTokenTypeNV; - -typedef enum VkIndirectStateFlagBitsNV { - VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001, - VK_INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkIndirectStateFlagBitsNV; -typedef VkFlags VkIndirectStateFlagsNV; - -typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV { - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0x00000002, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0x00000004, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkIndirectCommandsLayoutUsageFlagBitsNV; -typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV; -typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t maxGraphicsShaderGroupCount; - uint32_t maxIndirectSequenceCount; - uint32_t maxIndirectCommandsTokenCount; - uint32_t maxIndirectCommandsStreamCount; - uint32_t maxIndirectCommandsTokenOffset; - uint32_t maxIndirectCommandsStreamStride; - uint32_t minSequencesCountBufferOffsetAlignment; - uint32_t minSequencesIndexBufferOffsetAlignment; - uint32_t minIndirectCommandsBufferOffsetAlignment; -} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV; - -typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 deviceGeneratedCommands; -} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV; - -typedef struct VkGraphicsShaderGroupCreateInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const VkPipelineVertexInputStateCreateInfo* pVertexInputState; - const VkPipelineTessellationStateCreateInfo* pTessellationState; -} VkGraphicsShaderGroupCreateInfoNV; - -typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t groupCount; - const VkGraphicsShaderGroupCreateInfoNV* pGroups; - uint32_t pipelineCount; - const VkPipeline* pPipelines; -} VkGraphicsPipelineShaderGroupsCreateInfoNV; - -typedef struct VkBindShaderGroupIndirectCommandNV { - uint32_t groupIndex; -} VkBindShaderGroupIndirectCommandNV; - -typedef struct VkBindIndexBufferIndirectCommandNV { - VkDeviceAddress bufferAddress; - uint32_t size; - VkIndexType indexType; -} VkBindIndexBufferIndirectCommandNV; - -typedef struct VkBindVertexBufferIndirectCommandNV { - VkDeviceAddress bufferAddress; - uint32_t size; - uint32_t stride; -} VkBindVertexBufferIndirectCommandNV; - -typedef struct VkSetStateFlagsIndirectCommandNV { - uint32_t data; -} VkSetStateFlagsIndirectCommandNV; - -typedef struct VkIndirectCommandsStreamNV { - VkBuffer buffer; - VkDeviceSize offset; -} VkIndirectCommandsStreamNV; - -typedef struct VkIndirectCommandsLayoutTokenNV { - VkStructureType sType; - const void* pNext; - VkIndirectCommandsTokenTypeNV tokenType; - uint32_t stream; - uint32_t offset; - uint32_t vertexBindingUnit; - VkBool32 vertexDynamicStride; - VkPipelineLayout pushconstantPipelineLayout; - VkShaderStageFlags pushconstantShaderStageFlags; - uint32_t pushconstantOffset; - uint32_t pushconstantSize; - VkIndirectStateFlagsNV indirectStateFlags; - uint32_t indexTypeCount; - const VkIndexType* pIndexTypes; - const uint32_t* pIndexTypeValues; -} VkIndirectCommandsLayoutTokenNV; - -typedef struct VkIndirectCommandsLayoutCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkIndirectCommandsLayoutUsageFlagsNV flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t tokenCount; - const VkIndirectCommandsLayoutTokenNV* pTokens; - uint32_t streamCount; - const uint32_t* pStreamStrides; -} VkIndirectCommandsLayoutCreateInfoNV; - -typedef struct VkGeneratedCommandsInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineBindPoint pipelineBindPoint; - VkPipeline pipeline; - VkIndirectCommandsLayoutNV indirectCommandsLayout; - uint32_t streamCount; - const VkIndirectCommandsStreamNV* pStreams; - uint32_t sequencesCount; - VkBuffer preprocessBuffer; - VkDeviceSize preprocessOffset; - VkDeviceSize preprocessSize; - VkBuffer sequencesCountBuffer; - VkDeviceSize sequencesCountOffset; - VkBuffer sequencesIndexBuffer; - VkDeviceSize sequencesIndexOffset; -} VkGeneratedCommandsInfoNV; - -typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineBindPoint pipelineBindPoint; - VkPipeline pipeline; - VkIndirectCommandsLayoutNV indirectCommandsLayout; - uint32_t maxSequencesCount; -} VkGeneratedCommandsMemoryRequirementsInfoNV; - -typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); -typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex); -typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); -typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV( - VkDevice device, - const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV( - VkCommandBuffer commandBuffer, - const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV( - VkCommandBuffer commandBuffer, - VkBool32 isPreprocessed, - const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline, - uint32_t groupIndex); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV( - VkDevice device, - const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV( - VkDevice device, - VkIndirectCommandsLayoutNV indirectCommandsLayout, - const VkAllocationCallbacks* pAllocator); -#endif -#endif - - -// VK_NV_inherited_viewport_scissor is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_inherited_viewport_scissor 1 -#define VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION 1 -#define VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME "VK_NV_inherited_viewport_scissor" -typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 inheritedViewportScissor2D; -} VkPhysicalDeviceInheritedViewportScissorFeaturesNV; - -typedef struct VkCommandBufferInheritanceViewportScissorInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 viewportScissor2D; - uint32_t viewportDepthCount; - const VkViewport* pViewportDepths; -} VkCommandBufferInheritanceViewportScissorInfoNV; - - - -// VK_EXT_texel_buffer_alignment is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_texel_buffer_alignment 1 -#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1 -#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment" -typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 texelBufferAlignment; -} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; - -typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT; - - - -// VK_QCOM_render_pass_transform is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_render_pass_transform 1 -#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 5 -#define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform" -typedef struct VkRenderPassTransformBeginInfoQCOM { - VkStructureType sType; - const void* pNext; - VkSurfaceTransformFlagBitsKHR transform; -} VkRenderPassTransformBeginInfoQCOM; - -typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM { - VkStructureType sType; - const void* pNext; - VkSurfaceTransformFlagBitsKHR transform; - VkRect2D renderArea; -} VkCommandBufferInheritanceRenderPassTransformInfoQCOM; - - - -// VK_EXT_depth_bias_control is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_depth_bias_control 1 -#define VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION 1 -#define VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME "VK_EXT_depth_bias_control" - -typedef enum VkDepthBiasRepresentationEXT { - VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT = 0, - VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT = 1, - VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT = 2, - VK_DEPTH_BIAS_REPRESENTATION_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDepthBiasRepresentationEXT; -typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 depthBiasControl; - VkBool32 leastRepresentableValueForceUnormRepresentation; - VkBool32 floatRepresentation; - VkBool32 depthBiasExact; -} VkPhysicalDeviceDepthBiasControlFeaturesEXT; - -typedef struct VkDepthBiasInfoEXT { - VkStructureType sType; - const void* pNext; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; -} VkDepthBiasInfoEXT; - -typedef struct VkDepthBiasRepresentationInfoEXT { - VkStructureType sType; - const void* pNext; - VkDepthBiasRepresentationEXT depthBiasRepresentation; - VkBool32 depthBiasExact; -} VkDepthBiasRepresentationInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias2EXT)(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias2EXT( - VkCommandBuffer commandBuffer, - const VkDepthBiasInfoEXT* pDepthBiasInfo); -#endif -#endif - - -// VK_EXT_device_memory_report is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_device_memory_report 1 -#define VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION 2 -#define VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME "VK_EXT_device_memory_report" - -typedef enum VkDeviceMemoryReportEventTypeEXT { - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceMemoryReportEventTypeEXT; -typedef VkFlags VkDeviceMemoryReportFlagsEXT; -typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 deviceMemoryReport; -} VkPhysicalDeviceDeviceMemoryReportFeaturesEXT; - -typedef struct VkDeviceMemoryReportCallbackDataEXT { - VkStructureType sType; - void* pNext; - VkDeviceMemoryReportFlagsEXT flags; - VkDeviceMemoryReportEventTypeEXT type; - uint64_t memoryObjectId; - VkDeviceSize size; - VkObjectType objectType; - uint64_t objectHandle; - uint32_t heapIndex; -} VkDeviceMemoryReportCallbackDataEXT; - -typedef void (VKAPI_PTR *PFN_vkDeviceMemoryReportCallbackEXT)( - const VkDeviceMemoryReportCallbackDataEXT* pCallbackData, - void* pUserData); - -typedef struct VkDeviceDeviceMemoryReportCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceMemoryReportFlagsEXT flags; - PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback; - void* pUserData; -} VkDeviceDeviceMemoryReportCreateInfoEXT; - - - -// VK_EXT_acquire_drm_display is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_acquire_drm_display 1 -#define VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION 1 -#define VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_drm_display" -typedef VkResult (VKAPI_PTR *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display); -typedef VkResult (VKAPI_PTR *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT( - VkPhysicalDevice physicalDevice, - int32_t drmFd, - VkDisplayKHR display); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT( - VkPhysicalDevice physicalDevice, - int32_t drmFd, - uint32_t connectorId, - VkDisplayKHR* display); -#endif -#endif - - -// VK_EXT_robustness2 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_robustness2 1 -#define VK_EXT_ROBUSTNESS_2_SPEC_VERSION 1 -#define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2" -typedef VkPhysicalDeviceRobustness2FeaturesKHR VkPhysicalDeviceRobustness2FeaturesEXT; - -typedef VkPhysicalDeviceRobustness2PropertiesKHR VkPhysicalDeviceRobustness2PropertiesEXT; - - - -// VK_EXT_custom_border_color is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_custom_border_color 1 -#define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12 -#define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color" -typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxCustomBorderColorSamplers; -} VkPhysicalDeviceCustomBorderColorPropertiesEXT; - -typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 customBorderColors; - VkBool32 customBorderColorWithoutFormat; -} VkPhysicalDeviceCustomBorderColorFeaturesEXT; - - - -// VK_EXT_texture_compression_astc_3d is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_texture_compression_astc_3d 1 -#define VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_SPEC_VERSION 1 -#define VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME "VK_EXT_texture_compression_astc_3d" -typedef struct VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 textureCompressionASTC_3D; -} VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT; - - - -// VK_GOOGLE_user_type is a preprocessor guard. Do not pass it to API calls. -#define VK_GOOGLE_user_type 1 -#define VK_GOOGLE_USER_TYPE_SPEC_VERSION 1 -#define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type" - - -// VK_NV_present_barrier is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_present_barrier 1 -#define VK_NV_PRESENT_BARRIER_SPEC_VERSION 1 -#define VK_NV_PRESENT_BARRIER_EXTENSION_NAME "VK_NV_present_barrier" -typedef struct VkPhysicalDevicePresentBarrierFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 presentBarrier; -} VkPhysicalDevicePresentBarrierFeaturesNV; - -typedef struct VkSurfaceCapabilitiesPresentBarrierNV { - VkStructureType sType; - void* pNext; - VkBool32 presentBarrierSupported; -} VkSurfaceCapabilitiesPresentBarrierNV; - -typedef struct VkSwapchainPresentBarrierCreateInfoNV { - VkStructureType sType; - void* pNext; - VkBool32 presentBarrierEnable; -} VkSwapchainPresentBarrierCreateInfoNV; - - - -// VK_EXT_private_data is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_private_data 1 -typedef VkPrivateDataSlot VkPrivateDataSlotEXT; - -#define VK_EXT_PRIVATE_DATA_SPEC_VERSION 1 -#define VK_EXT_PRIVATE_DATA_EXTENSION_NAME "VK_EXT_private_data" -typedef VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT; - -typedef VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataFeaturesEXT; - -typedef VkDevicePrivateDataCreateInfo VkDevicePrivateDataCreateInfoEXT; - -typedef VkPrivateDataSlotCreateInfo VkPrivateDataSlotCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); -typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); -typedef void (VKAPI_PTR *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT( - VkDevice device, - const VkPrivateDataSlotCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPrivateDataSlot* pPrivateDataSlot); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT( - VkDevice device, - VkPrivateDataSlot privateDataSlot, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t data); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t* pData); -#endif -#endif - - -// VK_EXT_pipeline_creation_cache_control is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_pipeline_creation_cache_control 1 -#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION 3 -#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME "VK_EXT_pipeline_creation_cache_control" -typedef VkPhysicalDevicePipelineCreationCacheControlFeatures VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT; - - - -// VK_NV_device_diagnostics_config is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_device_diagnostics_config 1 -#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION 2 -#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config" - -typedef enum VkDeviceDiagnosticsConfigFlagBitsNV { - VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001, - VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0x00000002, - VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0x00000004, - VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV = 0x00000008, - VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkDeviceDiagnosticsConfigFlagBitsNV; -typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV; -typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 diagnosticsConfig; -} VkPhysicalDeviceDiagnosticsConfigFeaturesNV; - -typedef struct VkDeviceDiagnosticsConfigCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkDeviceDiagnosticsConfigFlagsNV flags; -} VkDeviceDiagnosticsConfigCreateInfoNV; - - - -// VK_QCOM_render_pass_store_ops is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_render_pass_store_ops 1 -#define VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION 2 -#define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops" - - -// VK_QCOM_tile_shading is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_tile_shading 1 -#define VK_QCOM_TILE_SHADING_SPEC_VERSION 2 -#define VK_QCOM_TILE_SHADING_EXTENSION_NAME "VK_QCOM_tile_shading" - -typedef enum VkTileShadingRenderPassFlagBitsQCOM { - VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM = 0x00000001, - VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM = 0x00000002, - VK_TILE_SHADING_RENDER_PASS_FLAG_BITS_MAX_ENUM_QCOM = 0x7FFFFFFF -} VkTileShadingRenderPassFlagBitsQCOM; -typedef VkFlags VkTileShadingRenderPassFlagsQCOM; -typedef struct VkPhysicalDeviceTileShadingFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 tileShading; - VkBool32 tileShadingFragmentStage; - VkBool32 tileShadingColorAttachments; - VkBool32 tileShadingDepthAttachments; - VkBool32 tileShadingStencilAttachments; - VkBool32 tileShadingInputAttachments; - VkBool32 tileShadingSampledAttachments; - VkBool32 tileShadingPerTileDraw; - VkBool32 tileShadingPerTileDispatch; - VkBool32 tileShadingDispatchTile; - VkBool32 tileShadingApron; - VkBool32 tileShadingAnisotropicApron; - VkBool32 tileShadingAtomicOps; - VkBool32 tileShadingImageProcessing; -} VkPhysicalDeviceTileShadingFeaturesQCOM; - -typedef struct VkPhysicalDeviceTileShadingPropertiesQCOM { - VkStructureType sType; - void* pNext; - uint32_t maxApronSize; - VkBool32 preferNonCoherent; - VkExtent2D tileGranularity; - VkExtent2D maxTileShadingRate; -} VkPhysicalDeviceTileShadingPropertiesQCOM; - -typedef struct VkRenderPassTileShadingCreateInfoQCOM { - VkStructureType sType; - const void* pNext; - VkTileShadingRenderPassFlagsQCOM flags; - VkExtent2D tileApronSize; -} VkRenderPassTileShadingCreateInfoQCOM; - -typedef struct VkPerTileBeginInfoQCOM { - VkStructureType sType; - const void* pNext; -} VkPerTileBeginInfoQCOM; - -typedef struct VkPerTileEndInfoQCOM { - VkStructureType sType; - const void* pNext; -} VkPerTileEndInfoQCOM; - -typedef struct VkDispatchTileInfoQCOM { - VkStructureType sType; - const void* pNext; -} VkDispatchTileInfoQCOM; - -typedef void (VKAPI_PTR *PFN_vkCmdDispatchTileQCOM)(VkCommandBuffer commandBuffer, const VkDispatchTileInfoQCOM* pDispatchTileInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBeginPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo); -typedef void (VKAPI_PTR *PFN_vkCmdEndPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM( - VkCommandBuffer commandBuffer, - const VkDispatchTileInfoQCOM* pDispatchTileInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM( - VkCommandBuffer commandBuffer, - const VkPerTileBeginInfoQCOM* pPerTileBeginInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdEndPerTileExecutionQCOM( - VkCommandBuffer commandBuffer, - const VkPerTileEndInfoQCOM* pPerTileEndInfo); -#endif -#endif - - -// VK_NV_low_latency is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_low_latency 1 -#define VK_NV_LOW_LATENCY_SPEC_VERSION 1 -#define VK_NV_LOW_LATENCY_EXTENSION_NAME "VK_NV_low_latency" -typedef struct VkQueryLowLatencySupportNV { - VkStructureType sType; - const void* pNext; - void* pQueriedLowLatencyData; -} VkQueryLowLatencySupportNV; - - - -// VK_EXT_descriptor_buffer is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_descriptor_buffer 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR) -#define VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION 1 -#define VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME "VK_EXT_descriptor_buffer" -typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 combinedImageSamplerDescriptorSingleArray; - VkBool32 bufferlessPushDescriptors; - VkBool32 allowSamplerImageViewPostSubmitCreation; - VkDeviceSize descriptorBufferOffsetAlignment; - uint32_t maxDescriptorBufferBindings; - uint32_t maxResourceDescriptorBufferBindings; - uint32_t maxSamplerDescriptorBufferBindings; - uint32_t maxEmbeddedImmutableSamplerBindings; - uint32_t maxEmbeddedImmutableSamplers; - size_t bufferCaptureReplayDescriptorDataSize; - size_t imageCaptureReplayDescriptorDataSize; - size_t imageViewCaptureReplayDescriptorDataSize; - size_t samplerCaptureReplayDescriptorDataSize; - size_t accelerationStructureCaptureReplayDescriptorDataSize; - size_t samplerDescriptorSize; - size_t combinedImageSamplerDescriptorSize; - size_t sampledImageDescriptorSize; - size_t storageImageDescriptorSize; - size_t uniformTexelBufferDescriptorSize; - size_t robustUniformTexelBufferDescriptorSize; - size_t storageTexelBufferDescriptorSize; - size_t robustStorageTexelBufferDescriptorSize; - size_t uniformBufferDescriptorSize; - size_t robustUniformBufferDescriptorSize; - size_t storageBufferDescriptorSize; - size_t robustStorageBufferDescriptorSize; - size_t inputAttachmentDescriptorSize; - size_t accelerationStructureDescriptorSize; - VkDeviceSize maxSamplerDescriptorBufferRange; - VkDeviceSize maxResourceDescriptorBufferRange; - VkDeviceSize samplerDescriptorBufferAddressSpaceSize; - VkDeviceSize resourceDescriptorBufferAddressSpaceSize; - VkDeviceSize descriptorBufferAddressSpaceSize; -} VkPhysicalDeviceDescriptorBufferPropertiesEXT; - -typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { - VkStructureType sType; - void* pNext; - size_t combinedImageSamplerDensityMapDescriptorSize; -} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; - -typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 descriptorBuffer; - VkBool32 descriptorBufferCaptureReplay; - VkBool32 descriptorBufferImageLayoutIgnored; - VkBool32 descriptorBufferPushDescriptors; -} VkPhysicalDeviceDescriptorBufferFeaturesEXT; - -typedef struct VkDescriptorAddressInfoEXT { - VkStructureType sType; - void* pNext; - VkDeviceAddress address; - VkDeviceSize range; - VkFormat format; -} VkDescriptorAddressInfoEXT; - -typedef struct VkDescriptorBufferBindingInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceAddress address; - VkBufferUsageFlags usage; -} VkDescriptorBufferBindingInfoEXT; - -typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT; - -typedef union VkDescriptorDataEXT { - const VkSampler* pSampler; - const VkDescriptorImageInfo* pCombinedImageSampler; - const VkDescriptorImageInfo* pInputAttachmentImage; - const VkDescriptorImageInfo* pSampledImage; - const VkDescriptorImageInfo* pStorageImage; - const VkDescriptorAddressInfoEXT* pUniformTexelBuffer; - const VkDescriptorAddressInfoEXT* pStorageTexelBuffer; - const VkDescriptorAddressInfoEXT* pUniformBuffer; - const VkDescriptorAddressInfoEXT* pStorageBuffer; - VkDeviceAddress accelerationStructure; -} VkDescriptorDataEXT; - -typedef struct VkDescriptorGetInfoEXT { - VkStructureType sType; - const void* pNext; - VkDescriptorType type; - VkDescriptorDataEXT data; -} VkDescriptorGetInfoEXT; - -typedef struct VkBufferCaptureDescriptorDataInfoEXT { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferCaptureDescriptorDataInfoEXT; - -typedef struct VkImageCaptureDescriptorDataInfoEXT { - VkStructureType sType; - const void* pNext; - VkImage image; -} VkImageCaptureDescriptorDataInfoEXT; - -typedef struct VkImageViewCaptureDescriptorDataInfoEXT { - VkStructureType sType; - const void* pNext; - VkImageView imageView; -} VkImageViewCaptureDescriptorDataInfoEXT; - -typedef struct VkSamplerCaptureDescriptorDataInfoEXT { - VkStructureType sType; - const void* pNext; - VkSampler sampler; -} VkSamplerCaptureDescriptorDataInfoEXT; - -typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT { - VkStructureType sType; - const void* pNext; - const void* opaqueCaptureDescriptorData; -} VkOpaqueCaptureDescriptorDataCreateInfoEXT; - -typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureKHR accelerationStructure; - VkAccelerationStructureNV accelerationStructureNV; -} VkAccelerationStructureCaptureDescriptorDataInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes); -typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset); -typedef void (VKAPI_PTR *PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor); -typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos); -typedef void (VKAPI_PTR *PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets); -typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set); -typedef VkResult (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSizeEXT( - VkDevice device, - VkDescriptorSetLayout layout, - VkDeviceSize* pLayoutSizeInBytes); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutBindingOffsetEXT( - VkDevice device, - VkDescriptorSetLayout layout, - uint32_t binding, - VkDeviceSize* pOffset); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorEXT( - VkDevice device, - const VkDescriptorGetInfoEXT* pDescriptorInfo, - size_t dataSize, - void* pDescriptor); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBuffersEXT( - VkCommandBuffer commandBuffer, - uint32_t bufferCount, - const VkDescriptorBufferBindingInfoEXT* pBindingInfos); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDescriptorBufferOffsetsEXT( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t firstSet, - uint32_t setCount, - const uint32_t* pBufferIndices, - const VkDeviceSize* pOffsets); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorBufferEmbeddedSamplersEXT( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkBufferCaptureDescriptorDataInfoEXT* pInfo, - void* pData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetImageOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkImageCaptureDescriptorDataInfoEXT* pInfo, - void* pData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, - void* pData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSamplerOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, - void* pData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, - void* pData); -#endif -#endif - - -// VK_EXT_graphics_pipeline_library is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_graphics_pipeline_library 1 -#define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION 1 -#define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME "VK_EXT_graphics_pipeline_library" - -typedef enum VkGraphicsPipelineLibraryFlagBitsEXT { - VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT = 0x00000001, - VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT = 0x00000002, - VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT = 0x00000004, - VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT = 0x00000008, - VK_GRAPHICS_PIPELINE_LIBRARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkGraphicsPipelineLibraryFlagBitsEXT; -typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT; -typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 graphicsPipelineLibrary; -} VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; - -typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 graphicsPipelineLibraryFastLinking; - VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration; -} VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; - -typedef struct VkGraphicsPipelineLibraryCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkGraphicsPipelineLibraryFlagsEXT flags; -} VkGraphicsPipelineLibraryCreateInfoEXT; - - - -// VK_AMD_shader_early_and_late_fragment_tests is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_shader_early_and_late_fragment_tests 1 -#define VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION 1 -#define VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME "VK_AMD_shader_early_and_late_fragment_tests" -typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { - VkStructureType sType; - void* pNext; - VkBool32 shaderEarlyAndLateFragmentTests; -} VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; - - - -// VK_NV_fragment_shading_rate_enums is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_fragment_shading_rate_enums 1 -#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION 1 -#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME "VK_NV_fragment_shading_rate_enums" - -typedef enum VkFragmentShadingRateTypeNV { - VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0, - VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1, - VK_FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkFragmentShadingRateTypeNV; - -typedef enum VkFragmentShadingRateNV { - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10, - VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11, - VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12, - VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13, - VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14, - VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15, - VK_FRAGMENT_SHADING_RATE_MAX_ENUM_NV = 0x7FFFFFFF -} VkFragmentShadingRateNV; -typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 fragmentShadingRateEnums; - VkBool32 supersampleFragmentShadingRates; - VkBool32 noInvocationFragmentShadingRates; -} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV; - -typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV { - VkStructureType sType; - void* pNext; - VkSampleCountFlagBits maxFragmentShadingRateInvocationCount; -} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV; - -typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkFragmentShadingRateTypeNV shadingRateType; - VkFragmentShadingRateNV shadingRate; - VkFragmentShadingRateCombinerOpKHR combinerOps[2]; -} VkPipelineFragmentShadingRateEnumStateCreateInfoNV; - -typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV( - VkCommandBuffer commandBuffer, - VkFragmentShadingRateNV shadingRate, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); -#endif -#endif - - -// VK_NV_ray_tracing_motion_blur is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_ray_tracing_motion_blur 1 -#define VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION 1 -#define VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME "VK_NV_ray_tracing_motion_blur" - -typedef enum VkAccelerationStructureMotionInstanceTypeNV { - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0, - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1, - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2, - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkAccelerationStructureMotionInstanceTypeNV; -typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV; -typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV; -typedef union VkDeviceOrHostAddressConstKHR { - VkDeviceAddress deviceAddress; - const void* hostAddress; -} VkDeviceOrHostAddressConstKHR; - -typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR vertexData; -} VkAccelerationStructureGeometryMotionTrianglesDataNV; - -typedef struct VkAccelerationStructureMotionInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t maxInstances; - VkAccelerationStructureMotionInfoFlagsNV flags; -} VkAccelerationStructureMotionInfoNV; - -typedef struct VkAccelerationStructureMatrixMotionInstanceNV { - VkTransformMatrixKHR transformT0; - VkTransformMatrixKHR transformT1; - uint32_t instanceCustomIndex:24; - uint32_t mask:8; - uint32_t instanceShaderBindingTableRecordOffset:24; - VkGeometryInstanceFlagsKHR flags:8; - uint64_t accelerationStructureReference; -} VkAccelerationStructureMatrixMotionInstanceNV; - -typedef struct VkSRTDataNV { - float sx; - float a; - float b; - float pvx; - float sy; - float c; - float pvy; - float sz; - float pvz; - float qx; - float qy; - float qz; - float qw; - float tx; - float ty; - float tz; -} VkSRTDataNV; - -typedef struct VkAccelerationStructureSRTMotionInstanceNV { - VkSRTDataNV transformT0; - VkSRTDataNV transformT1; - uint32_t instanceCustomIndex:24; - uint32_t mask:8; - uint32_t instanceShaderBindingTableRecordOffset:24; - VkGeometryInstanceFlagsKHR flags:8; - uint64_t accelerationStructureReference; -} VkAccelerationStructureSRTMotionInstanceNV; - -typedef union VkAccelerationStructureMotionInstanceDataNV { - VkAccelerationStructureInstanceKHR staticInstance; - VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance; - VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance; -} VkAccelerationStructureMotionInstanceDataNV; - -typedef struct VkAccelerationStructureMotionInstanceNV { - VkAccelerationStructureMotionInstanceTypeNV type; - VkAccelerationStructureMotionInstanceFlagsNV flags; - VkAccelerationStructureMotionInstanceDataNV data; -} VkAccelerationStructureMotionInstanceNV; - -typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingMotionBlur; - VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect; -} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV; - - - -// VK_EXT_ycbcr_2plane_444_formats is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_ycbcr_2plane_444_formats 1 -#define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1 -#define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats" -typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 ycbcr2plane444Formats; -} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; - - - -// VK_EXT_fragment_density_map2 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_fragment_density_map2 1 -#define VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION 1 -#define VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME "VK_EXT_fragment_density_map2" -typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 fragmentDensityMapDeferred; -} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT; - -typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 subsampledLoads; - VkBool32 subsampledCoarseReconstructionEarlyAccess; - uint32_t maxSubsampledArrayLayers; - uint32_t maxDescriptorSetSubsampledSamplers; -} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT; - - - -// VK_QCOM_rotated_copy_commands is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_rotated_copy_commands 1 -#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 2 -#define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands" -typedef struct VkCopyCommandTransformInfoQCOM { - VkStructureType sType; - const void* pNext; - VkSurfaceTransformFlagBitsKHR transform; -} VkCopyCommandTransformInfoQCOM; - - - -// VK_EXT_image_robustness is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_image_robustness 1 -#define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1 -#define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness" -typedef VkPhysicalDeviceImageRobustnessFeatures VkPhysicalDeviceImageRobustnessFeaturesEXT; - - - -// VK_EXT_image_compression_control is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_image_compression_control 1 -#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION 1 -#define VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME "VK_EXT_image_compression_control" - -typedef enum VkImageCompressionFlagBitsEXT { - VK_IMAGE_COMPRESSION_DEFAULT_EXT = 0, - VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT = 0x00000001, - VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT = 0x00000002, - VK_IMAGE_COMPRESSION_DISABLED_EXT = 0x00000004, - VK_IMAGE_COMPRESSION_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkImageCompressionFlagBitsEXT; -typedef VkFlags VkImageCompressionFlagsEXT; - -typedef enum VkImageCompressionFixedRateFlagBitsEXT { - VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT = 0, - VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT = 0x00000001, - VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT = 0x00000002, - VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT = 0x00000004, - VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT = 0x00000008, - VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT = 0x00000010, - VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT = 0x00000020, - VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT = 0x00000040, - VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT = 0x00000080, - VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT = 0x00000100, - VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT = 0x00000200, - VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT = 0x00000400, - VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT = 0x00000800, - VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT = 0x00001000, - VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT = 0x00002000, - VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT = 0x00004000, - VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT = 0x00008000, - VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT = 0x00010000, - VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT = 0x00020000, - VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT = 0x00040000, - VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT = 0x00080000, - VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT = 0x00100000, - VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT = 0x00200000, - VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT = 0x00400000, - VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT = 0x00800000, - VK_IMAGE_COMPRESSION_FIXED_RATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkImageCompressionFixedRateFlagBitsEXT; -typedef VkFlags VkImageCompressionFixedRateFlagsEXT; -typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 imageCompressionControl; -} VkPhysicalDeviceImageCompressionControlFeaturesEXT; - -typedef struct VkImageCompressionControlEXT { - VkStructureType sType; - const void* pNext; - VkImageCompressionFlagsEXT flags; - uint32_t compressionControlPlaneCount; - VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags; -} VkImageCompressionControlEXT; - -typedef struct VkImageCompressionPropertiesEXT { - VkStructureType sType; - void* pNext; - VkImageCompressionFlagsEXT imageCompressionFlags; - VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags; -} VkImageCompressionPropertiesEXT; - - - -// VK_EXT_attachment_feedback_loop_layout is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_attachment_feedback_loop_layout 1 -#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION 2 -#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME "VK_EXT_attachment_feedback_loop_layout" -typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 attachmentFeedbackLoopLayout; -} VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; - - - -// VK_EXT_4444_formats is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_4444_formats 1 -#define VK_EXT_4444_FORMATS_SPEC_VERSION 1 -#define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats" -typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 formatA4R4G4B4; - VkBool32 formatA4B4G4R4; -} VkPhysicalDevice4444FormatsFeaturesEXT; - - - -// VK_EXT_device_fault is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_device_fault 1 -#define VK_EXT_DEVICE_FAULT_SPEC_VERSION 2 -#define VK_EXT_DEVICE_FAULT_EXTENSION_NAME "VK_EXT_device_fault" - -typedef enum VkDeviceFaultAddressTypeEXT { - VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0, - VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1, - VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2, - VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6, - VK_DEVICE_FAULT_ADDRESS_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceFaultAddressTypeEXT; - -typedef enum VkDeviceFaultVendorBinaryHeaderVersionEXT { - VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = 1, - VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceFaultVendorBinaryHeaderVersionEXT; -typedef struct VkPhysicalDeviceFaultFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 deviceFault; - VkBool32 deviceFaultVendorBinary; -} VkPhysicalDeviceFaultFeaturesEXT; - -typedef struct VkDeviceFaultCountsEXT { - VkStructureType sType; - void* pNext; - uint32_t addressInfoCount; - uint32_t vendorInfoCount; - VkDeviceSize vendorBinarySize; -} VkDeviceFaultCountsEXT; - -typedef struct VkDeviceFaultAddressInfoEXT { - VkDeviceFaultAddressTypeEXT addressType; - VkDeviceAddress reportedAddress; - VkDeviceSize addressPrecision; -} VkDeviceFaultAddressInfoEXT; - -typedef struct VkDeviceFaultVendorInfoEXT { - char description[VK_MAX_DESCRIPTION_SIZE]; - uint64_t vendorFaultCode; - uint64_t vendorFaultData; -} VkDeviceFaultVendorInfoEXT; - -typedef struct VkDeviceFaultInfoEXT { - VkStructureType sType; - void* pNext; - char description[VK_MAX_DESCRIPTION_SIZE]; - VkDeviceFaultAddressInfoEXT* pAddressInfos; - VkDeviceFaultVendorInfoEXT* pVendorInfos; - void* pVendorBinaryData; -} VkDeviceFaultInfoEXT; - -typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT { - uint32_t headerSize; - VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion; - uint32_t vendorID; - uint32_t deviceID; - uint32_t driverVersion; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; - uint32_t applicationNameOffset; - uint32_t applicationVersion; - uint32_t engineNameOffset; - uint32_t engineVersion; - uint32_t apiVersion; -} VkDeviceFaultVendorBinaryHeaderVersionOneEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceFaultInfoEXT( - VkDevice device, - VkDeviceFaultCountsEXT* pFaultCounts, - VkDeviceFaultInfoEXT* pFaultInfo); -#endif -#endif - - -// VK_ARM_rasterization_order_attachment_access is a preprocessor guard. Do not pass it to API calls. -#define VK_ARM_rasterization_order_attachment_access 1 -#define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1 -#define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_ARM_rasterization_order_attachment_access" -typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 rasterizationOrderColorAttachmentAccess; - VkBool32 rasterizationOrderDepthAttachmentAccess; - VkBool32 rasterizationOrderStencilAttachmentAccess; -} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; - -typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; - - - -// VK_EXT_rgba10x6_formats is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_rgba10x6_formats 1 -#define VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION 1 -#define VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME "VK_EXT_rgba10x6_formats" -typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 formatRgba10x6WithoutYCbCrSampler; -} VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT; - - - -// VK_VALVE_mutable_descriptor_type is a preprocessor guard. Do not pass it to API calls. -#define VK_VALVE_mutable_descriptor_type 1 -#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1 -#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type" -typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 mutableDescriptorType; -} VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT; - -typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE; - -typedef struct VkMutableDescriptorTypeListEXT { - uint32_t descriptorTypeCount; - const VkDescriptorType* pDescriptorTypes; -} VkMutableDescriptorTypeListEXT; - -typedef VkMutableDescriptorTypeListEXT VkMutableDescriptorTypeListVALVE; - -typedef struct VkMutableDescriptorTypeCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t mutableDescriptorTypeListCount; - const VkMutableDescriptorTypeListEXT* pMutableDescriptorTypeLists; -} VkMutableDescriptorTypeCreateInfoEXT; - -typedef VkMutableDescriptorTypeCreateInfoEXT VkMutableDescriptorTypeCreateInfoVALVE; - - - -// VK_EXT_vertex_input_dynamic_state is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_vertex_input_dynamic_state 1 -#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2 -#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state" -typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 vertexInputDynamicState; -} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; - -typedef struct VkVertexInputBindingDescription2EXT { - VkStructureType sType; - void* pNext; - uint32_t binding; - uint32_t stride; - VkVertexInputRate inputRate; - uint32_t divisor; -} VkVertexInputBindingDescription2EXT; - -typedef struct VkVertexInputAttributeDescription2EXT { - VkStructureType sType; - void* pNext; - uint32_t location; - uint32_t binding; - VkFormat format; - uint32_t offset; -} VkVertexInputAttributeDescription2EXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT( - VkCommandBuffer commandBuffer, - uint32_t vertexBindingDescriptionCount, - const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, - uint32_t vertexAttributeDescriptionCount, - const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); -#endif -#endif - - -// VK_EXT_physical_device_drm is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_physical_device_drm 1 -#define VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION 1 -#define VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME "VK_EXT_physical_device_drm" -typedef struct VkPhysicalDeviceDrmPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 hasPrimary; - VkBool32 hasRender; - int64_t primaryMajor; - int64_t primaryMinor; - int64_t renderMajor; - int64_t renderMinor; -} VkPhysicalDeviceDrmPropertiesEXT; - - - -// VK_EXT_device_address_binding_report is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_device_address_binding_report 1 -#define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION 1 -#define VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME "VK_EXT_device_address_binding_report" - -typedef enum VkDeviceAddressBindingTypeEXT { - VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT = 0, - VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT = 1, - VK_DEVICE_ADDRESS_BINDING_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceAddressBindingTypeEXT; - -typedef enum VkDeviceAddressBindingFlagBitsEXT { - VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT = 0x00000001, - VK_DEVICE_ADDRESS_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceAddressBindingFlagBitsEXT; -typedef VkFlags VkDeviceAddressBindingFlagsEXT; -typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 reportAddressBinding; -} VkPhysicalDeviceAddressBindingReportFeaturesEXT; - -typedef struct VkDeviceAddressBindingCallbackDataEXT { - VkStructureType sType; - void* pNext; - VkDeviceAddressBindingFlagsEXT flags; - VkDeviceAddress baseAddress; - VkDeviceSize size; - VkDeviceAddressBindingTypeEXT bindingType; -} VkDeviceAddressBindingCallbackDataEXT; - - - -// VK_EXT_depth_clip_control is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_depth_clip_control 1 -#define VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION 1 -#define VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clip_control" -typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 depthClipControl; -} VkPhysicalDeviceDepthClipControlFeaturesEXT; - -typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 negativeOneToOne; -} VkPipelineViewportDepthClipControlCreateInfoEXT; - - - -// VK_EXT_primitive_topology_list_restart is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_primitive_topology_list_restart 1 -#define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION 1 -#define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME "VK_EXT_primitive_topology_list_restart" -typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 primitiveTopologyListRestart; - VkBool32 primitiveTopologyPatchListRestart; -} VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; - - - -// VK_EXT_present_mode_fifo_latest_ready is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_present_mode_fifo_latest_ready 1 -#define VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION 1 -#define VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME "VK_EXT_present_mode_fifo_latest_ready" -typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT; - - - -// VK_HUAWEI_subpass_shading is a preprocessor guard. Do not pass it to API calls. -#define VK_HUAWEI_subpass_shading 1 -#define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 3 -#define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading" -typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI { - VkStructureType sType; - void* pNext; - VkRenderPass renderPass; - uint32_t subpass; -} VkSubpassShadingPipelineCreateInfoHUAWEI; - -typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI { - VkStructureType sType; - void* pNext; - VkBool32 subpassShading; -} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI; - -typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI { - VkStructureType sType; - void* pNext; - uint32_t maxSubpassShadingWorkgroupSizeAspectRatio; -} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI; - -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize); -typedef void (VKAPI_PTR *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( - VkDevice device, - VkRenderPass renderpass, - VkExtent2D* pMaxWorkgroupSize); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI( - VkCommandBuffer commandBuffer); -#endif -#endif - - -// VK_HUAWEI_invocation_mask is a preprocessor guard. Do not pass it to API calls. -#define VK_HUAWEI_invocation_mask 1 -#define VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION 1 -#define VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME "VK_HUAWEI_invocation_mask" -typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI { - VkStructureType sType; - void* pNext; - VkBool32 invocationMask; -} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI; - -typedef void (VKAPI_PTR *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI( - VkCommandBuffer commandBuffer, - VkImageView imageView, - VkImageLayout imageLayout); -#endif -#endif - - -// VK_NV_external_memory_rdma is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_external_memory_rdma 1 -typedef void* VkRemoteAddressNV; -#define VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION 1 -#define VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME "VK_NV_external_memory_rdma" -typedef struct VkMemoryGetRemoteAddressInfoNV { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkMemoryGetRemoteAddressInfoNV; - -typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 externalMemoryRDMA; -} VkPhysicalDeviceExternalMemoryRDMAFeaturesNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV( - VkDevice device, - const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, - VkRemoteAddressNV* pAddress); -#endif -#endif - - -// VK_EXT_pipeline_properties is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_pipeline_properties 1 -#define VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION 1 -#define VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME "VK_EXT_pipeline_properties" -typedef VkPipelineInfoKHR VkPipelineInfoEXT; - -typedef struct VkPipelinePropertiesIdentifierEXT { - VkStructureType sType; - void* pNext; - uint8_t pipelineIdentifier[VK_UUID_SIZE]; -} VkPipelinePropertiesIdentifierEXT; - -typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 pipelinePropertiesIdentifier; -} VkPhysicalDevicePipelinePropertiesFeaturesEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelinePropertiesEXT( - VkDevice device, - const VkPipelineInfoEXT* pPipelineInfo, - VkBaseOutStructure* pPipelineProperties); -#endif -#endif - - -// VK_EXT_frame_boundary is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_frame_boundary 1 -#define VK_EXT_FRAME_BOUNDARY_SPEC_VERSION 1 -#define VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME "VK_EXT_frame_boundary" - -typedef enum VkFrameBoundaryFlagBitsEXT { - VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT = 0x00000001, - VK_FRAME_BOUNDARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkFrameBoundaryFlagBitsEXT; -typedef VkFlags VkFrameBoundaryFlagsEXT; -typedef struct VkPhysicalDeviceFrameBoundaryFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 frameBoundary; -} VkPhysicalDeviceFrameBoundaryFeaturesEXT; - -typedef struct VkFrameBoundaryEXT { - VkStructureType sType; - const void* pNext; - VkFrameBoundaryFlagsEXT flags; - uint64_t frameID; - uint32_t imageCount; - const VkImage* pImages; - uint32_t bufferCount; - const VkBuffer* pBuffers; - uint64_t tagName; - size_t tagSize; - const void* pTag; -} VkFrameBoundaryEXT; - - - -// VK_EXT_multisampled_render_to_single_sampled is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_multisampled_render_to_single_sampled 1 -#define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION 1 -#define VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME "VK_EXT_multisampled_render_to_single_sampled" -typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 multisampledRenderToSingleSampled; -} VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; - -typedef struct VkSubpassResolvePerformanceQueryEXT { - VkStructureType sType; - void* pNext; - VkBool32 optimal; -} VkSubpassResolvePerformanceQueryEXT; - -typedef struct VkMultisampledRenderToSingleSampledInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 multisampledRenderToSingleSampledEnable; - VkSampleCountFlagBits rasterizationSamples; -} VkMultisampledRenderToSingleSampledInfoEXT; - - - -// VK_EXT_extended_dynamic_state2 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_extended_dynamic_state2 1 -#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1 -#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2" -typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 extendedDynamicState2; - VkBool32 extendedDynamicState2LogicOp; - VkBool32 extendedDynamicState2PatchControlPoints; -} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints); -typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp); -typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT( - VkCommandBuffer commandBuffer, - uint32_t patchControlPoints); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 rasterizerDiscardEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBiasEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT( - VkCommandBuffer commandBuffer, - VkLogicOp logicOp); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 primitiveRestartEnable); -#endif -#endif - - -// VK_EXT_color_write_enable is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_color_write_enable 1 -#define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1 -#define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable" -typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 colorWriteEnable; -} VkPhysicalDeviceColorWriteEnableFeaturesEXT; - -typedef struct VkPipelineColorWriteCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t attachmentCount; - const VkBool32* pColorWriteEnables; -} VkPipelineColorWriteCreateInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkBool32* pColorWriteEnables); -#endif -#endif - - -// VK_EXT_primitives_generated_query is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_primitives_generated_query 1 -#define VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION 1 -#define VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME "VK_EXT_primitives_generated_query" -typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 primitivesGeneratedQuery; - VkBool32 primitivesGeneratedQueryWithRasterizerDiscard; - VkBool32 primitivesGeneratedQueryWithNonZeroStreams; -} VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; - - - -// VK_EXT_global_priority_query is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_global_priority_query 1 -#define VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION 1 -#define VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME "VK_EXT_global_priority_query" -#define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT VK_MAX_GLOBAL_PRIORITY_SIZE -typedef VkPhysicalDeviceGlobalPriorityQueryFeatures VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT; - -typedef VkQueueFamilyGlobalPriorityProperties VkQueueFamilyGlobalPriorityPropertiesEXT; - - - -// VK_VALVE_video_encode_rgb_conversion is a preprocessor guard. Do not pass it to API calls. -#define VK_VALVE_video_encode_rgb_conversion 1 -#define VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION 1 -#define VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME "VK_VALVE_video_encode_rgb_conversion" - -typedef enum VkVideoEncodeRgbModelConversionFlagBitsVALVE { - VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE = 0x00000001, - VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE = 0x00000002, - VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE = 0x00000004, - VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE = 0x00000008, - VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE = 0x00000010, - VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF -} VkVideoEncodeRgbModelConversionFlagBitsVALVE; -typedef VkFlags VkVideoEncodeRgbModelConversionFlagsVALVE; - -typedef enum VkVideoEncodeRgbRangeCompressionFlagBitsVALVE { - VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE = 0x00000001, - VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE = 0x00000002, - VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF -} VkVideoEncodeRgbRangeCompressionFlagBitsVALVE; -typedef VkFlags VkVideoEncodeRgbRangeCompressionFlagsVALVE; - -typedef enum VkVideoEncodeRgbChromaOffsetFlagBitsVALVE { - VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE = 0x00000001, - VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE = 0x00000002, - VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_FLAG_BITS_MAX_ENUM_VALVE = 0x7FFFFFFF -} VkVideoEncodeRgbChromaOffsetFlagBitsVALVE; -typedef VkFlags VkVideoEncodeRgbChromaOffsetFlagsVALVE; -typedef struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE { - VkStructureType sType; - void* pNext; - VkBool32 videoEncodeRgbConversion; -} VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; - -typedef struct VkVideoEncodeRgbConversionCapabilitiesVALVE { - VkStructureType sType; - void* pNext; - VkVideoEncodeRgbModelConversionFlagsVALVE rgbModels; - VkVideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges; - VkVideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets; - VkVideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets; -} VkVideoEncodeRgbConversionCapabilitiesVALVE; - -typedef struct VkVideoEncodeProfileRgbConversionInfoVALVE { - VkStructureType sType; - const void* pNext; - VkBool32 performEncodeRgbConversion; -} VkVideoEncodeProfileRgbConversionInfoVALVE; - -typedef struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE { - VkStructureType sType; - const void* pNext; - VkVideoEncodeRgbModelConversionFlagBitsVALVE rgbModel; - VkVideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange; - VkVideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset; - VkVideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset; -} VkVideoEncodeSessionRgbConversionCreateInfoVALVE; - - - -// VK_EXT_image_view_min_lod is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_image_view_min_lod 1 -#define VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION 1 -#define VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME "VK_EXT_image_view_min_lod" -typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 minLod; -} VkPhysicalDeviceImageViewMinLodFeaturesEXT; - -typedef struct VkImageViewMinLodCreateInfoEXT { - VkStructureType sType; - const void* pNext; - float minLod; -} VkImageViewMinLodCreateInfoEXT; - - - -// VK_EXT_multi_draw is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_multi_draw 1 -#define VK_EXT_MULTI_DRAW_SPEC_VERSION 1 -#define VK_EXT_MULTI_DRAW_EXTENSION_NAME "VK_EXT_multi_draw" -typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 multiDraw; -} VkPhysicalDeviceMultiDrawFeaturesEXT; - -typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxMultiDrawCount; -} VkPhysicalDeviceMultiDrawPropertiesEXT; - -typedef struct VkMultiDrawInfoEXT { - uint32_t firstVertex; - uint32_t vertexCount; -} VkMultiDrawInfoEXT; - -typedef struct VkMultiDrawIndexedInfoEXT { - uint32_t firstIndex; - uint32_t indexCount; - int32_t vertexOffset; -} VkMultiDrawIndexedInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT( - VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawInfoEXT* pVertexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT( - VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawIndexedInfoEXT* pIndexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride, - const int32_t* pVertexOffset); -#endif -#endif - - -// VK_EXT_image_2d_view_of_3d is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_image_2d_view_of_3d 1 -#define VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION 1 -#define VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_2d_view_of_3d" -typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 image2DViewOf3D; - VkBool32 sampler2DViewOf3D; -} VkPhysicalDeviceImage2DViewOf3DFeaturesEXT; - - - -// VK_EXT_shader_tile_image is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_tile_image 1 -#define VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION 1 -#define VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME "VK_EXT_shader_tile_image" -typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderTileImageColorReadAccess; - VkBool32 shaderTileImageDepthReadAccess; - VkBool32 shaderTileImageStencilReadAccess; -} VkPhysicalDeviceShaderTileImageFeaturesEXT; - -typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderTileImageCoherentReadAccelerated; - VkBool32 shaderTileImageReadSampleFromPixelRateInvocation; - VkBool32 shaderTileImageReadFromHelperInvocation; -} VkPhysicalDeviceShaderTileImagePropertiesEXT; - - - -// VK_EXT_opacity_micromap is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_opacity_micromap 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkMicromapEXT) -#define VK_EXT_OPACITY_MICROMAP_SPEC_VERSION 2 -#define VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME "VK_EXT_opacity_micromap" - -typedef enum VkMicromapTypeEXT { - VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT = 0, -#ifdef VK_ENABLE_BETA_EXTENSIONS - VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV = 1000397000, -#endif - VK_MICROMAP_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkMicromapTypeEXT; - -typedef enum VkBuildMicromapModeEXT { - VK_BUILD_MICROMAP_MODE_BUILD_EXT = 0, - VK_BUILD_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkBuildMicromapModeEXT; - -typedef enum VkCopyMicromapModeEXT { - VK_COPY_MICROMAP_MODE_CLONE_EXT = 0, - VK_COPY_MICROMAP_MODE_SERIALIZE_EXT = 1, - VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT = 2, - VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3, - VK_COPY_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkCopyMicromapModeEXT; - -typedef enum VkOpacityMicromapFormatEXT { - VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1, - VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2, - VK_OPACITY_MICROMAP_FORMAT_MAX_ENUM_EXT = 0x7FFFFFFF -} VkOpacityMicromapFormatEXT; - -typedef enum VkOpacityMicromapSpecialIndexEXT { - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV = -5, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_MAX_ENUM_EXT = 0x7FFFFFFF -} VkOpacityMicromapSpecialIndexEXT; - -typedef enum VkAccelerationStructureCompatibilityKHR { - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0, - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1, - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureCompatibilityKHR; - -typedef enum VkAccelerationStructureBuildTypeKHR { - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureBuildTypeKHR; - -typedef enum VkBuildMicromapFlagBitsEXT { - VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT = 0x00000001, - VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT = 0x00000002, - VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT = 0x00000004, - VK_BUILD_MICROMAP_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkBuildMicromapFlagBitsEXT; -typedef VkFlags VkBuildMicromapFlagsEXT; - -typedef enum VkMicromapCreateFlagBitsEXT { - VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000001, - VK_MICROMAP_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkMicromapCreateFlagBitsEXT; -typedef VkFlags VkMicromapCreateFlagsEXT; -typedef struct VkMicromapUsageEXT { - uint32_t count; - uint32_t subdivisionLevel; - uint32_t format; -} VkMicromapUsageEXT; - -typedef union VkDeviceOrHostAddressKHR { - VkDeviceAddress deviceAddress; - void* hostAddress; -} VkDeviceOrHostAddressKHR; - -typedef struct VkMicromapBuildInfoEXT { - VkStructureType sType; - const void* pNext; - VkMicromapTypeEXT type; - VkBuildMicromapFlagsEXT flags; - VkBuildMicromapModeEXT mode; - VkMicromapEXT dstMicromap; - uint32_t usageCountsCount; - const VkMicromapUsageEXT* pUsageCounts; - const VkMicromapUsageEXT* const* ppUsageCounts; - VkDeviceOrHostAddressConstKHR data; - VkDeviceOrHostAddressKHR scratchData; - VkDeviceOrHostAddressConstKHR triangleArray; - VkDeviceSize triangleArrayStride; -} VkMicromapBuildInfoEXT; - -typedef struct VkMicromapCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkMicromapCreateFlagsEXT createFlags; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; - VkMicromapTypeEXT type; - VkDeviceAddress deviceAddress; -} VkMicromapCreateInfoEXT; - -typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 micromap; - VkBool32 micromapCaptureReplay; - VkBool32 micromapHostCommands; -} VkPhysicalDeviceOpacityMicromapFeaturesEXT; - -typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxOpacity2StateSubdivisionLevel; - uint32_t maxOpacity4StateSubdivisionLevel; -} VkPhysicalDeviceOpacityMicromapPropertiesEXT; - -typedef struct VkMicromapVersionInfoEXT { - VkStructureType sType; - const void* pNext; - const uint8_t* pVersionData; -} VkMicromapVersionInfoEXT; - -typedef struct VkCopyMicromapToMemoryInfoEXT { - VkStructureType sType; - const void* pNext; - VkMicromapEXT src; - VkDeviceOrHostAddressKHR dst; - VkCopyMicromapModeEXT mode; -} VkCopyMicromapToMemoryInfoEXT; - -typedef struct VkCopyMemoryToMicromapInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR src; - VkMicromapEXT dst; - VkCopyMicromapModeEXT mode; -} VkCopyMemoryToMicromapInfoEXT; - -typedef struct VkCopyMicromapInfoEXT { - VkStructureType sType; - const void* pNext; - VkMicromapEXT src; - VkMicromapEXT dst; - VkCopyMicromapModeEXT mode; -} VkCopyMicromapInfoEXT; - -typedef struct VkMicromapBuildSizesInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceSize micromapSize; - VkDeviceSize buildScratchSize; - VkBool32 discardable; -} VkMicromapBuildSizesInfoEXT; - -typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT { - VkStructureType sType; - void* pNext; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR indexBuffer; - VkDeviceSize indexStride; - uint32_t baseTriangle; - uint32_t usageCountsCount; - const VkMicromapUsageEXT* pUsageCounts; - const VkMicromapUsageEXT* const* ppUsageCounts; - VkMicromapEXT micromap; -} VkAccelerationStructureTrianglesOpacityMicromapEXT; - -typedef struct VkMicromapTriangleEXT { - uint32_t dataOffset; - uint16_t subdivisionLevel; - uint16_t format; -} VkMicromapTriangleEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); -typedef void (VKAPI_PTR *PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); -typedef VkResult (VKAPI_PTR *PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -typedef void (VKAPI_PTR *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); -typedef void (VKAPI_PTR *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateMicromapEXT( - VkDevice device, - const VkMicromapCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkMicromapEXT* pMicromap); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyMicromapEXT( - VkDevice device, - VkMicromapEXT micromap, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBuildMicromapsEXT( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkMicromapBuildInfoEXT* pInfos); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkBuildMicromapsEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkMicromapBuildInfoEXT* pInfos); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMicromapInfoEXT* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCopyMicromapToMemoryEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMicromapToMemoryInfoEXT* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToMicromapEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToMicromapInfoEXT* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkWriteMicromapsPropertiesEXT( - VkDevice device, - uint32_t micromapCount, - const VkMicromapEXT* pMicromaps, - VkQueryType queryType, - size_t dataSize, - void* pData, - size_t stride); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapEXT( - VkCommandBuffer commandBuffer, - const VkCopyMicromapInfoEXT* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyMicromapToMemoryEXT( - VkCommandBuffer commandBuffer, - const VkCopyMicromapToMemoryInfoEXT* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToMicromapEXT( - VkCommandBuffer commandBuffer, - const VkCopyMemoryToMicromapInfoEXT* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdWriteMicromapsPropertiesEXT( - VkCommandBuffer commandBuffer, - uint32_t micromapCount, - const VkMicromapEXT* pMicromaps, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDeviceMicromapCompatibilityEXT( - VkDevice device, - const VkMicromapVersionInfoEXT* pVersionInfo, - VkAccelerationStructureCompatibilityKHR* pCompatibility); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT( - VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkMicromapBuildInfoEXT* pBuildInfo, - VkMicromapBuildSizesInfoEXT* pSizeInfo); -#endif -#endif - - -// VK_EXT_load_store_op_none is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_load_store_op_none 1 -#define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1 -#define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none" - - -// VK_HUAWEI_cluster_culling_shader is a preprocessor guard. Do not pass it to API calls. -#define VK_HUAWEI_cluster_culling_shader 1 -#define VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION 3 -#define VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME "VK_HUAWEI_cluster_culling_shader" -typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI { - VkStructureType sType; - void* pNext; - VkBool32 clustercullingShader; - VkBool32 multiviewClusterCullingShader; -} VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI; - -typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI { - VkStructureType sType; - void* pNext; - uint32_t maxWorkGroupCount[3]; - uint32_t maxWorkGroupSize[3]; - uint32_t maxOutputClusterCount; - VkDeviceSize indirectBufferOffsetAlignment; -} VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI; - -typedef struct VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI { - VkStructureType sType; - void* pNext; - VkBool32 clusterShadingRate; -} VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; - -typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterHUAWEI)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef void (VKAPI_PTR *PFN_vkCmdDrawClusterIndirectHUAWEI)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterHUAWEI( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawClusterIndirectHUAWEI( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset); -#endif -#endif - - -// VK_EXT_border_color_swizzle is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_border_color_swizzle 1 -#define VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION 1 -#define VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME "VK_EXT_border_color_swizzle" -typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 borderColorSwizzle; - VkBool32 borderColorSwizzleFromImage; -} VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; - -typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkComponentMapping components; - VkBool32 srgb; -} VkSamplerBorderColorComponentMappingCreateInfoEXT; - - - -// VK_EXT_pageable_device_local_memory is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_pageable_device_local_memory 1 -#define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION 1 -#define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME "VK_EXT_pageable_device_local_memory" -typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 pageableDeviceLocalMemory; -} VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; - -typedef void (VKAPI_PTR *PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT( - VkDevice device, - VkDeviceMemory memory, - float priority); -#endif -#endif - - -// VK_ARM_shader_core_properties is a preprocessor guard. Do not pass it to API calls. -#define VK_ARM_shader_core_properties 1 -#define VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION 1 -#define VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_ARM_shader_core_properties" -typedef struct VkPhysicalDeviceShaderCorePropertiesARM { - VkStructureType sType; - void* pNext; - uint32_t pixelRate; - uint32_t texelRate; - uint32_t fmaRate; -} VkPhysicalDeviceShaderCorePropertiesARM; - - - -// VK_ARM_scheduling_controls is a preprocessor guard. Do not pass it to API calls. -#define VK_ARM_scheduling_controls 1 -#define VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION 1 -#define VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME "VK_ARM_scheduling_controls" -typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM; - -// Flag bits for VkPhysicalDeviceSchedulingControlsFlagBitsARM -typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagBitsARM; -static const VkPhysicalDeviceSchedulingControlsFlagBitsARM VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001ULL; - -typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM { - VkStructureType sType; - void* pNext; - uint32_t shaderCoreCount; -} VkDeviceQueueShaderCoreControlCreateInfoARM; - -typedef struct VkPhysicalDeviceSchedulingControlsFeaturesARM { - VkStructureType sType; - void* pNext; - VkBool32 schedulingControls; -} VkPhysicalDeviceSchedulingControlsFeaturesARM; - -typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags; -} VkPhysicalDeviceSchedulingControlsPropertiesARM; - - - -// VK_EXT_image_sliced_view_of_3d is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_image_sliced_view_of_3d 1 -#define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION 1 -#define VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_sliced_view_of_3d" -#define VK_REMAINING_3D_SLICES_EXT (~0U) -typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 imageSlicedViewOf3D; -} VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT; - -typedef struct VkImageViewSlicedCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t sliceOffset; - uint32_t sliceCount; -} VkImageViewSlicedCreateInfoEXT; - - - -// VK_VALVE_descriptor_set_host_mapping is a preprocessor guard. Do not pass it to API calls. -#define VK_VALVE_descriptor_set_host_mapping 1 -#define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION 1 -#define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME "VK_VALVE_descriptor_set_host_mapping" -typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { - VkStructureType sType; - void* pNext; - VkBool32 descriptorSetHostMapping; -} VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; - -typedef struct VkDescriptorSetBindingReferenceVALVE { - VkStructureType sType; - const void* pNext; - VkDescriptorSetLayout descriptorSetLayout; - uint32_t binding; -} VkDescriptorSetBindingReferenceVALVE; - -typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE { - VkStructureType sType; - void* pNext; - size_t descriptorOffset; - uint32_t descriptorSize; -} VkDescriptorSetLayoutHostMappingInfoVALVE; - -typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); -typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void** ppData); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE( - VkDevice device, - const VkDescriptorSetBindingReferenceVALVE* pBindingReference, - VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE( - VkDevice device, - VkDescriptorSet descriptorSet, - void** ppData); -#endif -#endif - - -// VK_EXT_depth_clamp_zero_one is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_depth_clamp_zero_one 1 -#define VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION 1 -#define VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME "VK_EXT_depth_clamp_zero_one" -typedef VkPhysicalDeviceDepthClampZeroOneFeaturesKHR VkPhysicalDeviceDepthClampZeroOneFeaturesEXT; - - - -// VK_EXT_non_seamless_cube_map is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_non_seamless_cube_map 1 -#define VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION 1 -#define VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME "VK_EXT_non_seamless_cube_map" -typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 nonSeamlessCubeMap; -} VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT; - - - -// VK_ARM_render_pass_striped is a preprocessor guard. Do not pass it to API calls. -#define VK_ARM_render_pass_striped 1 -#define VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION 1 -#define VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME "VK_ARM_render_pass_striped" -typedef struct VkPhysicalDeviceRenderPassStripedFeaturesARM { - VkStructureType sType; - void* pNext; - VkBool32 renderPassStriped; -} VkPhysicalDeviceRenderPassStripedFeaturesARM; - -typedef struct VkPhysicalDeviceRenderPassStripedPropertiesARM { - VkStructureType sType; - void* pNext; - VkExtent2D renderPassStripeGranularity; - uint32_t maxRenderPassStripes; -} VkPhysicalDeviceRenderPassStripedPropertiesARM; - -typedef struct VkRenderPassStripeInfoARM { - VkStructureType sType; - const void* pNext; - VkRect2D stripeArea; -} VkRenderPassStripeInfoARM; - -typedef struct VkRenderPassStripeBeginInfoARM { - VkStructureType sType; - const void* pNext; - uint32_t stripeInfoCount; - const VkRenderPassStripeInfoARM* pStripeInfos; -} VkRenderPassStripeBeginInfoARM; - -typedef struct VkRenderPassStripeSubmitInfoARM { - VkStructureType sType; - const void* pNext; - uint32_t stripeSemaphoreInfoCount; - const VkSemaphoreSubmitInfo* pStripeSemaphoreInfos; -} VkRenderPassStripeSubmitInfoARM; - - - -// VK_QCOM_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_fragment_density_map_offset 1 -#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 3 -#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset" -typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 fragmentDensityMapOffset; -} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; - -typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; - -typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT { - VkStructureType sType; - void* pNext; - VkExtent2D fragmentDensityOffsetGranularity; -} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; - -typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; - -typedef struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t fragmentDensityOffsetCount; - const VkOffset2D* pFragmentDensityOffsets; -} VkRenderPassFragmentDensityMapOffsetEndInfoEXT; - -typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT VkSubpassFragmentDensityMapOffsetEndInfoQCOM; - - - -// VK_NV_copy_memory_indirect is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_copy_memory_indirect 1 -#define VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION 1 -#define VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME "VK_NV_copy_memory_indirect" -typedef VkCopyMemoryIndirectCommandKHR VkCopyMemoryIndirectCommandNV; - -typedef VkCopyMemoryToImageIndirectCommandKHR VkCopyMemoryToImageIndirectCommandNV; - -typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 indirectCopy; -} VkPhysicalDeviceCopyMemoryIndirectFeaturesNV; - -typedef VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR VkPhysicalDeviceCopyMemoryIndirectPropertiesNV; - -typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryIndirectNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToImageIndirectNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride, - VkImage dstImage, - VkImageLayout dstImageLayout, - const VkImageSubresourceLayers* pImageSubresources); -#endif -#endif - - -// VK_NV_memory_decompression is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_memory_decompression 1 -#define VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION 1 -#define VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME "VK_NV_memory_decompression" - -// Flag bits for VkMemoryDecompressionMethodFlagBitsEXT -typedef VkFlags64 VkMemoryDecompressionMethodFlagBitsEXT; -static const VkMemoryDecompressionMethodFlagBitsEXT VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT = 0x00000001ULL; -static const VkMemoryDecompressionMethodFlagBitsEXT VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV = 0x00000001ULL; - -typedef VkMemoryDecompressionMethodFlagBitsEXT VkMemoryDecompressionMethodFlagBitsNV; - -typedef VkFlags64 VkMemoryDecompressionMethodFlagsEXT; -typedef VkMemoryDecompressionMethodFlagsEXT VkMemoryDecompressionMethodFlagsNV; - -typedef struct VkDecompressMemoryRegionNV { - VkDeviceAddress srcAddress; - VkDeviceAddress dstAddress; - VkDeviceSize compressedSize; - VkDeviceSize decompressedSize; - VkMemoryDecompressionMethodFlagsNV decompressionMethod; -} VkDecompressMemoryRegionNV; - -typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 memoryDecompression; -} VkPhysicalDeviceMemoryDecompressionFeaturesEXT; - -typedef VkPhysicalDeviceMemoryDecompressionFeaturesEXT VkPhysicalDeviceMemoryDecompressionFeaturesNV; - -typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesEXT { - VkStructureType sType; - void* pNext; - VkMemoryDecompressionMethodFlagsEXT decompressionMethods; - uint64_t maxDecompressionIndirectCount; -} VkPhysicalDeviceMemoryDecompressionPropertiesEXT; - -typedef VkPhysicalDeviceMemoryDecompressionPropertiesEXT VkPhysicalDeviceMemoryDecompressionPropertiesNV; - -typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); -typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryIndirectCountNV)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryNV( - VkCommandBuffer commandBuffer, - uint32_t decompressRegionCount, - const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress indirectCommandsAddress, - VkDeviceAddress indirectCommandsCountAddress, - uint32_t stride); -#endif -#endif - - -// VK_NV_device_generated_commands_compute is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_device_generated_commands_compute 1 -#define VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION 2 -#define VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME "VK_NV_device_generated_commands_compute" -typedef struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 deviceGeneratedCompute; - VkBool32 deviceGeneratedComputePipelines; - VkBool32 deviceGeneratedComputeCaptureReplay; -} VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; - -typedef struct VkComputePipelineIndirectBufferInfoNV { - VkStructureType sType; - const void* pNext; - VkDeviceAddress deviceAddress; - VkDeviceSize size; - VkDeviceAddress pipelineDeviceAddressCaptureReplay; -} VkComputePipelineIndirectBufferInfoNV; - -typedef struct VkPipelineIndirectDeviceAddressInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineBindPoint pipelineBindPoint; - VkPipeline pipeline; -} VkPipelineIndirectDeviceAddressInfoNV; - -typedef struct VkBindPipelineIndirectCommandNV { - VkDeviceAddress pipelineAddress; -} VkBindPipelineIndirectCommandNV; - -typedef void (VKAPI_PTR *PFN_vkGetPipelineIndirectMemoryRequirementsNV)(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkCmdUpdatePipelineIndirectBufferNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetPipelineIndirectDeviceAddressNV)(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPipelineIndirectMemoryRequirementsNV( - VkDevice device, - const VkComputePipelineCreateInfo* pCreateInfo, - VkMemoryRequirements2* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdUpdatePipelineIndirectBufferNV( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetPipelineIndirectDeviceAddressNV( - VkDevice device, - const VkPipelineIndirectDeviceAddressInfoNV* pInfo); -#endif -#endif - - -// VK_NV_ray_tracing_linear_swept_spheres is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_ray_tracing_linear_swept_spheres 1 -#define VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION 1 -#define VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_EXTENSION_NAME "VK_NV_ray_tracing_linear_swept_spheres" - -typedef enum VkRayTracingLssIndexingModeNV { - VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV = 0, - VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV = 1, - VK_RAY_TRACING_LSS_INDEXING_MODE_MAX_ENUM_NV = 0x7FFFFFFF -} VkRayTracingLssIndexingModeNV; - -typedef enum VkRayTracingLssPrimitiveEndCapsModeNV { - VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV = 0, - VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV = 1, - VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_MAX_ENUM_NV = 0x7FFFFFFF -} VkRayTracingLssPrimitiveEndCapsModeNV; -typedef struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 spheres; - VkBool32 linearSweptSpheres; -} VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; - -typedef struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV { - VkStructureType sType; - const void* pNext; - VkFormat vertexFormat; - VkDeviceOrHostAddressConstKHR vertexData; - VkDeviceSize vertexStride; - VkFormat radiusFormat; - VkDeviceOrHostAddressConstKHR radiusData; - VkDeviceSize radiusStride; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR indexData; - VkDeviceSize indexStride; - VkRayTracingLssIndexingModeNV indexingMode; - VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode; -} VkAccelerationStructureGeometryLinearSweptSpheresDataNV; - -typedef struct VkAccelerationStructureGeometrySpheresDataNV { - VkStructureType sType; - const void* pNext; - VkFormat vertexFormat; - VkDeviceOrHostAddressConstKHR vertexData; - VkDeviceSize vertexStride; - VkFormat radiusFormat; - VkDeviceOrHostAddressConstKHR radiusData; - VkDeviceSize radiusStride; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR indexData; - VkDeviceSize indexStride; -} VkAccelerationStructureGeometrySpheresDataNV; - - - -// VK_NV_linear_color_attachment is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_linear_color_attachment 1 -#define VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION 1 -#define VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME "VK_NV_linear_color_attachment" -typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 linearColorAttachment; -} VkPhysicalDeviceLinearColorAttachmentFeaturesNV; - - - -// VK_GOOGLE_surfaceless_query is a preprocessor guard. Do not pass it to API calls. -#define VK_GOOGLE_surfaceless_query 1 -#define VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION 2 -#define VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME "VK_GOOGLE_surfaceless_query" - - -// VK_EXT_image_compression_control_swapchain is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_image_compression_control_swapchain 1 -#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION 1 -#define VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME "VK_EXT_image_compression_control_swapchain" -typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 imageCompressionControlSwapchain; -} VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; - - - -// VK_QCOM_image_processing is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_image_processing 1 -#define VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION 1 -#define VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME "VK_QCOM_image_processing" -typedef struct VkImageViewSampleWeightCreateInfoQCOM { - VkStructureType sType; - const void* pNext; - VkOffset2D filterCenter; - VkExtent2D filterSize; - uint32_t numPhases; -} VkImageViewSampleWeightCreateInfoQCOM; - -typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 textureSampleWeighted; - VkBool32 textureBoxFilter; - VkBool32 textureBlockMatch; -} VkPhysicalDeviceImageProcessingFeaturesQCOM; - -typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM { - VkStructureType sType; - void* pNext; - uint32_t maxWeightFilterPhases; - VkExtent2D maxWeightFilterDimension; - VkExtent2D maxBlockMatchRegion; - VkExtent2D maxBoxFilterBlockSize; -} VkPhysicalDeviceImageProcessingPropertiesQCOM; - - - -// VK_EXT_nested_command_buffer is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_nested_command_buffer 1 -#define VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION 1 -#define VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME "VK_EXT_nested_command_buffer" -typedef struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 nestedCommandBuffer; - VkBool32 nestedCommandBufferRendering; - VkBool32 nestedCommandBufferSimultaneousUse; -} VkPhysicalDeviceNestedCommandBufferFeaturesEXT; - -typedef struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxCommandBufferNestingLevel; -} VkPhysicalDeviceNestedCommandBufferPropertiesEXT; - - - -// VK_EXT_external_memory_acquire_unmodified is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_external_memory_acquire_unmodified 1 -#define VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION 1 -#define VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME "VK_EXT_external_memory_acquire_unmodified" -typedef struct VkExternalMemoryAcquireUnmodifiedEXT { - VkStructureType sType; - const void* pNext; - VkBool32 acquireUnmodifiedMemory; -} VkExternalMemoryAcquireUnmodifiedEXT; - - - -// VK_EXT_extended_dynamic_state3 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_extended_dynamic_state3 1 -#define VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION 2 -#define VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME "VK_EXT_extended_dynamic_state3" -typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 extendedDynamicState3TessellationDomainOrigin; - VkBool32 extendedDynamicState3DepthClampEnable; - VkBool32 extendedDynamicState3PolygonMode; - VkBool32 extendedDynamicState3RasterizationSamples; - VkBool32 extendedDynamicState3SampleMask; - VkBool32 extendedDynamicState3AlphaToCoverageEnable; - VkBool32 extendedDynamicState3AlphaToOneEnable; - VkBool32 extendedDynamicState3LogicOpEnable; - VkBool32 extendedDynamicState3ColorBlendEnable; - VkBool32 extendedDynamicState3ColorBlendEquation; - VkBool32 extendedDynamicState3ColorWriteMask; - VkBool32 extendedDynamicState3RasterizationStream; - VkBool32 extendedDynamicState3ConservativeRasterizationMode; - VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize; - VkBool32 extendedDynamicState3DepthClipEnable; - VkBool32 extendedDynamicState3SampleLocationsEnable; - VkBool32 extendedDynamicState3ColorBlendAdvanced; - VkBool32 extendedDynamicState3ProvokingVertexMode; - VkBool32 extendedDynamicState3LineRasterizationMode; - VkBool32 extendedDynamicState3LineStippleEnable; - VkBool32 extendedDynamicState3DepthClipNegativeOneToOne; - VkBool32 extendedDynamicState3ViewportWScalingEnable; - VkBool32 extendedDynamicState3ViewportSwizzle; - VkBool32 extendedDynamicState3CoverageToColorEnable; - VkBool32 extendedDynamicState3CoverageToColorLocation; - VkBool32 extendedDynamicState3CoverageModulationMode; - VkBool32 extendedDynamicState3CoverageModulationTableEnable; - VkBool32 extendedDynamicState3CoverageModulationTable; - VkBool32 extendedDynamicState3CoverageReductionMode; - VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable; - VkBool32 extendedDynamicState3ShadingRateImageEnable; -} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT; - -typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 dynamicPrimitiveTopologyUnrestricted; -} VkPhysicalDeviceExtendedDynamicState3PropertiesEXT; - -typedef struct VkColorBlendEquationEXT { - VkBlendFactor srcColorBlendFactor; - VkBlendFactor dstColorBlendFactor; - VkBlendOp colorBlendOp; - VkBlendFactor srcAlphaBlendFactor; - VkBlendFactor dstAlphaBlendFactor; - VkBlendOp alphaBlendOp; -} VkColorBlendEquationEXT; - -typedef struct VkColorBlendAdvancedEXT { - VkBlendOp advancedBlendOp; - VkBool32 srcPremultiplied; - VkBool32 dstPremultiplied; - VkBlendOverlapEXT blendOverlap; - VkBool32 clampResults; -} VkColorBlendAdvancedEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); -typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); -typedef void (VKAPI_PTR *PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask); -typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables); -typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations); -typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); -typedef void (VKAPI_PTR *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); -typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream); -typedef void (VKAPI_PTR *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); -typedef void (VKAPI_PTR *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced); -typedef void (VKAPI_PTR *PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode); -typedef void (VKAPI_PTR *PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); -typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); -typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles); -typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation); -typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode); -typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable); -typedef void (VKAPI_PTR *PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); -typedef void (VKAPI_PTR *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthClampEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetPolygonModeEXT( - VkCommandBuffer commandBuffer, - VkPolygonMode polygonMode); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationSamplesEXT( - VkCommandBuffer commandBuffer, - VkSampleCountFlagBits rasterizationSamples); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleMaskEXT( - VkCommandBuffer commandBuffer, - VkSampleCountFlagBits samples, - const VkSampleMask* pSampleMask); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToCoverageEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 alphaToCoverageEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetAlphaToOneEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 alphaToOneEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 logicOpEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEnableEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkBool32* pColorBlendEnables); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendEquationEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorBlendEquationEXT* pColorBlendEquations); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteMaskEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorComponentFlags* pColorWriteMasks); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetTessellationDomainOriginEXT( - VkCommandBuffer commandBuffer, - VkTessellationDomainOrigin domainOrigin); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizationStreamEXT( - VkCommandBuffer commandBuffer, - uint32_t rasterizationStream); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetConservativeRasterizationModeEXT( - VkCommandBuffer commandBuffer, - VkConservativeRasterizationModeEXT conservativeRasterizationMode); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetExtraPrimitiveOverestimationSizeEXT( - VkCommandBuffer commandBuffer, - float extraPrimitiveOverestimationSize); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthClipEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 sampleLocationsEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetColorBlendAdvancedEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorBlendAdvancedEXT* pColorBlendAdvanced); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetProvokingVertexModeEXT( - VkCommandBuffer commandBuffer, - VkProvokingVertexModeEXT provokingVertexMode); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetLineRasterizationModeEXT( - VkCommandBuffer commandBuffer, - VkLineRasterizationModeEXT lineRasterizationMode); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 stippledLineEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClipNegativeOneToOneEXT( - VkCommandBuffer commandBuffer, - VkBool32 negativeOneToOne); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 viewportWScalingEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportSwizzleNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportSwizzleNV* pViewportSwizzles); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 coverageToColorEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageToColorLocationNV( - VkCommandBuffer commandBuffer, - uint32_t coverageToColorLocation); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationModeNV( - VkCommandBuffer commandBuffer, - VkCoverageModulationModeNV coverageModulationMode); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 coverageModulationTableEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageModulationTableNV( - VkCommandBuffer commandBuffer, - uint32_t coverageModulationTableCount, - const float* pCoverageModulationTable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetShadingRateImageEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 shadingRateImageEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetRepresentativeFragmentTestEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 representativeFragmentTestEnable); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetCoverageReductionModeNV( - VkCommandBuffer commandBuffer, - VkCoverageReductionModeNV coverageReductionMode); -#endif -#endif - - -// VK_EXT_subpass_merge_feedback is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_subpass_merge_feedback 1 -#define VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION 2 -#define VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME "VK_EXT_subpass_merge_feedback" - -typedef enum VkSubpassMergeStatusEXT { - VK_SUBPASS_MERGE_STATUS_MERGED_EXT = 0, - VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT = 1, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT = 2, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT = 3, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT = 4, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT = 5, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT = 6, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT = 7, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT = 8, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT = 9, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT = 10, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT = 11, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT = 12, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT = 13, - VK_SUBPASS_MERGE_STATUS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkSubpassMergeStatusEXT; -typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 subpassMergeFeedback; -} VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT; - -typedef struct VkRenderPassCreationControlEXT { - VkStructureType sType; - const void* pNext; - VkBool32 disallowMerging; -} VkRenderPassCreationControlEXT; - -typedef struct VkRenderPassCreationFeedbackInfoEXT { - uint32_t postMergeSubpassCount; -} VkRenderPassCreationFeedbackInfoEXT; - -typedef struct VkRenderPassCreationFeedbackCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback; -} VkRenderPassCreationFeedbackCreateInfoEXT; - -typedef struct VkRenderPassSubpassFeedbackInfoEXT { - VkSubpassMergeStatusEXT subpassMergeStatus; - char description[VK_MAX_DESCRIPTION_SIZE]; - uint32_t postMergeIndex; -} VkRenderPassSubpassFeedbackInfoEXT; - -typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback; -} VkRenderPassSubpassFeedbackCreateInfoEXT; - - - -// VK_LUNARG_direct_driver_loading is a preprocessor guard. Do not pass it to API calls. -#define VK_LUNARG_direct_driver_loading 1 -#define VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION 1 -#define VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME "VK_LUNARG_direct_driver_loading" - -typedef enum VkDirectDriverLoadingModeLUNARG { - VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG = 0, - VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG = 1, - VK_DIRECT_DRIVER_LOADING_MODE_MAX_ENUM_LUNARG = 0x7FFFFFFF -} VkDirectDriverLoadingModeLUNARG; -typedef VkFlags VkDirectDriverLoadingFlagsLUNARG; -typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddrLUNARG)( - VkInstance instance, - const char* pName); - -typedef struct VkDirectDriverLoadingInfoLUNARG { - VkStructureType sType; - void* pNext; - VkDirectDriverLoadingFlagsLUNARG flags; - PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr; -} VkDirectDriverLoadingInfoLUNARG; - -typedef struct VkDirectDriverLoadingListLUNARG { - VkStructureType sType; - const void* pNext; - VkDirectDriverLoadingModeLUNARG mode; - uint32_t driverCount; - const VkDirectDriverLoadingInfoLUNARG* pDrivers; -} VkDirectDriverLoadingListLUNARG; - - - -// VK_ARM_tensors is a preprocessor guard. Do not pass it to API calls. -#define VK_ARM_tensors 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkTensorViewARM) -#define VK_ARM_TENSORS_SPEC_VERSION 1 -#define VK_ARM_TENSORS_EXTENSION_NAME "VK_ARM_tensors" - -typedef enum VkTensorTilingARM { - VK_TENSOR_TILING_OPTIMAL_ARM = 0, - VK_TENSOR_TILING_LINEAR_ARM = 1, - VK_TENSOR_TILING_MAX_ENUM_ARM = 0x7FFFFFFF -} VkTensorTilingARM; -typedef VkFlags64 VkTensorCreateFlagsARM; - -// Flag bits for VkTensorCreateFlagBitsARM -typedef VkFlags64 VkTensorCreateFlagBitsARM; -static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM = 0x00000001ULL; -static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_PROTECTED_BIT_ARM = 0x00000002ULL; -static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM = 0x00000008ULL; -static const VkTensorCreateFlagBitsARM VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM = 0x00000004ULL; - -typedef VkFlags64 VkTensorUsageFlagsARM; - -// Flag bits for VkTensorUsageFlagBitsARM -typedef VkFlags64 VkTensorUsageFlagBitsARM; -static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_SHADER_BIT_ARM = 0x00000002ULL; -static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM = 0x00000004ULL; -static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM = 0x00000008ULL; -static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM = 0x00000010ULL; -static const VkTensorUsageFlagBitsARM VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM = 0x00000020ULL; - -typedef struct VkTensorDescriptionARM { - VkStructureType sType; - const void* pNext; - VkTensorTilingARM tiling; - VkFormat format; - uint32_t dimensionCount; - const int64_t* pDimensions; - const int64_t* pStrides; - VkTensorUsageFlagsARM usage; -} VkTensorDescriptionARM; - -typedef struct VkTensorCreateInfoARM { - VkStructureType sType; - const void* pNext; - VkTensorCreateFlagsARM flags; - const VkTensorDescriptionARM* pDescription; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; -} VkTensorCreateInfoARM; - -typedef struct VkTensorMemoryRequirementsInfoARM { - VkStructureType sType; - const void* pNext; - VkTensorARM tensor; -} VkTensorMemoryRequirementsInfoARM; - -typedef struct VkBindTensorMemoryInfoARM { - VkStructureType sType; - const void* pNext; - VkTensorARM tensor; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; -} VkBindTensorMemoryInfoARM; - -typedef struct VkWriteDescriptorSetTensorARM { - VkStructureType sType; - const void* pNext; - uint32_t tensorViewCount; - const VkTensorViewARM* pTensorViews; -} VkWriteDescriptorSetTensorARM; - -typedef struct VkTensorFormatPropertiesARM { - VkStructureType sType; - void* pNext; - VkFormatFeatureFlags2 optimalTilingTensorFeatures; - VkFormatFeatureFlags2 linearTilingTensorFeatures; -} VkTensorFormatPropertiesARM; - -typedef struct VkPhysicalDeviceTensorPropertiesARM { - VkStructureType sType; - void* pNext; - uint32_t maxTensorDimensionCount; - uint64_t maxTensorElements; - uint64_t maxPerDimensionTensorElements; - int64_t maxTensorStride; - uint64_t maxTensorSize; - uint32_t maxTensorShaderAccessArrayLength; - uint32_t maxTensorShaderAccessSize; - uint32_t maxDescriptorSetStorageTensors; - uint32_t maxPerStageDescriptorSetStorageTensors; - uint32_t maxDescriptorSetUpdateAfterBindStorageTensors; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors; - VkBool32 shaderStorageTensorArrayNonUniformIndexingNative; - VkShaderStageFlags shaderTensorSupportedStages; -} VkPhysicalDeviceTensorPropertiesARM; - -typedef struct VkTensorMemoryBarrierARM { - VkStructureType sType; - const void* pNext; - VkPipelineStageFlags2 srcStageMask; - VkAccessFlags2 srcAccessMask; - VkPipelineStageFlags2 dstStageMask; - VkAccessFlags2 dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkTensorARM tensor; -} VkTensorMemoryBarrierARM; - -typedef struct VkTensorDependencyInfoARM { - VkStructureType sType; - const void* pNext; - uint32_t tensorMemoryBarrierCount; - const VkTensorMemoryBarrierARM* pTensorMemoryBarriers; -} VkTensorDependencyInfoARM; - -typedef struct VkPhysicalDeviceTensorFeaturesARM { - VkStructureType sType; - void* pNext; - VkBool32 tensorNonPacked; - VkBool32 shaderTensorAccess; - VkBool32 shaderStorageTensorArrayDynamicIndexing; - VkBool32 shaderStorageTensorArrayNonUniformIndexing; - VkBool32 descriptorBindingStorageTensorUpdateAfterBind; - VkBool32 tensors; -} VkPhysicalDeviceTensorFeaturesARM; - -typedef struct VkDeviceTensorMemoryRequirementsARM { - VkStructureType sType; - const void* pNext; - const VkTensorCreateInfoARM* pCreateInfo; -} VkDeviceTensorMemoryRequirementsARM; - -typedef struct VkTensorCopyARM { - VkStructureType sType; - const void* pNext; - uint32_t dimensionCount; - const uint64_t* pSrcOffset; - const uint64_t* pDstOffset; - const uint64_t* pExtent; -} VkTensorCopyARM; - -typedef struct VkCopyTensorInfoARM { - VkStructureType sType; - const void* pNext; - VkTensorARM srcTensor; - VkTensorARM dstTensor; - uint32_t regionCount; - const VkTensorCopyARM* pRegions; -} VkCopyTensorInfoARM; - -typedef struct VkMemoryDedicatedAllocateInfoTensorARM { - VkStructureType sType; - const void* pNext; - VkTensorARM tensor; -} VkMemoryDedicatedAllocateInfoTensorARM; - -typedef struct VkPhysicalDeviceExternalTensorInfoARM { - VkStructureType sType; - const void* pNext; - VkTensorCreateFlagsARM flags; - const VkTensorDescriptionARM* pDescription; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalTensorInfoARM; - -typedef struct VkExternalTensorPropertiesARM { - VkStructureType sType; - const void* pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalTensorPropertiesARM; - -typedef struct VkExternalMemoryTensorCreateInfoARM { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryTensorCreateInfoARM; - -typedef struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM { - VkStructureType sType; - void* pNext; - VkBool32 descriptorBufferTensorDescriptors; -} VkPhysicalDeviceDescriptorBufferTensorFeaturesARM; - -typedef struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM { - VkStructureType sType; - void* pNext; - size_t tensorCaptureReplayDescriptorDataSize; - size_t tensorViewCaptureReplayDescriptorDataSize; - size_t tensorDescriptorSize; -} VkPhysicalDeviceDescriptorBufferTensorPropertiesARM; - -typedef struct VkDescriptorGetTensorInfoARM { - VkStructureType sType; - const void* pNext; - VkTensorViewARM tensorView; -} VkDescriptorGetTensorInfoARM; - -typedef struct VkTensorCaptureDescriptorDataInfoARM { - VkStructureType sType; - const void* pNext; - VkTensorARM tensor; -} VkTensorCaptureDescriptorDataInfoARM; - -typedef struct VkTensorViewCaptureDescriptorDataInfoARM { - VkStructureType sType; - const void* pNext; - VkTensorViewARM tensorView; -} VkTensorViewCaptureDescriptorDataInfoARM; - -typedef struct VkFrameBoundaryTensorsARM { - VkStructureType sType; - const void* pNext; - uint32_t tensorCount; - const VkTensorARM* pTensors; -} VkFrameBoundaryTensorsARM; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateTensorARM)(VkDevice device, const VkTensorCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorARM* pTensor); -typedef void (VKAPI_PTR *PFN_vkDestroyTensorARM)(VkDevice device, VkTensorARM tensor, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateTensorViewARM)(VkDevice device, const VkTensorViewCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkTensorViewARM* pView); -typedef void (VKAPI_PTR *PFN_vkDestroyTensorViewARM)(VkDevice device, VkTensorViewARM tensorView, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetTensorMemoryRequirementsARM)(VkDevice device, const VkTensorMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef VkResult (VKAPI_PTR *PFN_vkBindTensorMemoryARM)(VkDevice device, uint32_t bindInfoCount, const VkBindTensorMemoryInfoARM* pBindInfos); -typedef void (VKAPI_PTR *PFN_vkGetDeviceTensorMemoryRequirementsARM)(VkDevice device, const VkDeviceTensorMemoryRequirementsARM* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkCmdCopyTensorARM)(VkCommandBuffer commandBuffer, const VkCopyTensorInfoARM* pCopyTensorInfo); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, VkExternalTensorPropertiesARM* pExternalTensorProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetTensorOpaqueCaptureDescriptorDataARM)(VkDevice device, const VkTensorCaptureDescriptorDataInfoARM* pInfo, void* pData); -typedef VkResult (VKAPI_PTR *PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM)(VkDevice device, const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, void* pData); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorARM( - VkDevice device, - const VkTensorCreateInfoARM* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkTensorARM* pTensor); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyTensorARM( - VkDevice device, - VkTensorARM tensor, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateTensorViewARM( - VkDevice device, - const VkTensorViewCreateInfoARM* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkTensorViewARM* pView); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyTensorViewARM( - VkDevice device, - VkTensorViewARM tensorView, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetTensorMemoryRequirementsARM( - VkDevice device, - const VkTensorMemoryRequirementsInfoARM* pInfo, - VkMemoryRequirements2* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkBindTensorMemoryARM( - VkDevice device, - uint32_t bindInfoCount, - const VkBindTensorMemoryInfoARM* pBindInfos); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDeviceTensorMemoryRequirementsARM( - VkDevice device, - const VkDeviceTensorMemoryRequirementsARM* pInfo, - VkMemoryRequirements2* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyTensorARM( - VkCommandBuffer commandBuffer, - const VkCopyTensorInfoARM* pCopyTensorInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalTensorPropertiesARM( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalTensorInfoARM* pExternalTensorInfo, - VkExternalTensorPropertiesARM* pExternalTensorProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorOpaqueCaptureDescriptorDataARM( - VkDevice device, - const VkTensorCaptureDescriptorDataInfoARM* pInfo, - void* pData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetTensorViewOpaqueCaptureDescriptorDataARM( - VkDevice device, - const VkTensorViewCaptureDescriptorDataInfoARM* pInfo, - void* pData); -#endif -#endif - - -// VK_EXT_shader_module_identifier is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_module_identifier 1 -#define VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT 32U -#define VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION 1 -#define VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME "VK_EXT_shader_module_identifier" -typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderModuleIdentifier; -} VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT; - -typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT { - VkStructureType sType; - void* pNext; - uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE]; -} VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT; - -typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t identifierSize; - const uint8_t* pIdentifier; -} VkPipelineShaderStageModuleIdentifierCreateInfoEXT; - -typedef struct VkShaderModuleIdentifierEXT { - VkStructureType sType; - void* pNext; - uint32_t identifierSize; - uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]; -} VkShaderModuleIdentifierEXT; - -typedef void (VKAPI_PTR *PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier); -typedef void (VKAPI_PTR *PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleIdentifierEXT( - VkDevice device, - VkShaderModule shaderModule, - VkShaderModuleIdentifierEXT* pIdentifier); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetShaderModuleCreateInfoIdentifierEXT( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - VkShaderModuleIdentifierEXT* pIdentifier); -#endif -#endif - - -// VK_EXT_rasterization_order_attachment_access is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_rasterization_order_attachment_access 1 -#define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1 -#define VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_EXT_rasterization_order_attachment_access" - - -// VK_NV_optical_flow is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_optical_flow 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkOpticalFlowSessionNV) -#define VK_NV_OPTICAL_FLOW_SPEC_VERSION 1 -#define VK_NV_OPTICAL_FLOW_EXTENSION_NAME "VK_NV_optical_flow" - -typedef enum VkOpticalFlowPerformanceLevelNV { - VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV = 0, - VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV = 1, - VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV = 2, - VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV = 3, - VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowPerformanceLevelNV; - -typedef enum VkOpticalFlowSessionBindingPointNV { - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV = 0, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV = 1, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV = 2, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV = 3, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV = 4, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV = 5, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV = 6, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV = 7, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV = 8, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowSessionBindingPointNV; - -typedef enum VkOpticalFlowGridSizeFlagBitsNV { - VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV = 0, - VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV = 0x00000001, - VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV = 0x00000002, - VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV = 0x00000004, - VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV = 0x00000008, - VK_OPTICAL_FLOW_GRID_SIZE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowGridSizeFlagBitsNV; -typedef VkFlags VkOpticalFlowGridSizeFlagsNV; - -typedef enum VkOpticalFlowUsageFlagBitsNV { - VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV = 0, - VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV = 0x00000001, - VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV = 0x00000002, - VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV = 0x00000004, - VK_OPTICAL_FLOW_USAGE_COST_BIT_NV = 0x00000008, - VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV = 0x00000010, - VK_OPTICAL_FLOW_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowUsageFlagBitsNV; -typedef VkFlags VkOpticalFlowUsageFlagsNV; - -typedef enum VkOpticalFlowSessionCreateFlagBitsNV { - VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV = 0x00000001, - VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV = 0x00000002, - VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV = 0x00000004, - VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV = 0x00000008, - VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV = 0x00000010, - VK_OPTICAL_FLOW_SESSION_CREATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowSessionCreateFlagBitsNV; -typedef VkFlags VkOpticalFlowSessionCreateFlagsNV; - -typedef enum VkOpticalFlowExecuteFlagBitsNV { - VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV = 0x00000001, - VK_OPTICAL_FLOW_EXECUTE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowExecuteFlagBitsNV; -typedef VkFlags VkOpticalFlowExecuteFlagsNV; -typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 opticalFlow; -} VkPhysicalDeviceOpticalFlowFeaturesNV; - -typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV { - VkStructureType sType; - void* pNext; - VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes; - VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes; - VkBool32 hintSupported; - VkBool32 costSupported; - VkBool32 bidirectionalFlowSupported; - VkBool32 globalFlowSupported; - uint32_t minWidth; - uint32_t minHeight; - uint32_t maxWidth; - uint32_t maxHeight; - uint32_t maxNumRegionsOfInterest; -} VkPhysicalDeviceOpticalFlowPropertiesNV; - -typedef struct VkOpticalFlowImageFormatInfoNV { - VkStructureType sType; - const void* pNext; - VkOpticalFlowUsageFlagsNV usage; -} VkOpticalFlowImageFormatInfoNV; - -typedef struct VkOpticalFlowImageFormatPropertiesNV { - VkStructureType sType; - void* pNext; - VkFormat format; -} VkOpticalFlowImageFormatPropertiesNV; - -typedef struct VkOpticalFlowSessionCreateInfoNV { - VkStructureType sType; - void* pNext; - uint32_t width; - uint32_t height; - VkFormat imageFormat; - VkFormat flowVectorFormat; - VkFormat costFormat; - VkOpticalFlowGridSizeFlagsNV outputGridSize; - VkOpticalFlowGridSizeFlagsNV hintGridSize; - VkOpticalFlowPerformanceLevelNV performanceLevel; - VkOpticalFlowSessionCreateFlagsNV flags; -} VkOpticalFlowSessionCreateInfoNV; - -typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV { - VkStructureType sType; - void* pNext; - uint32_t id; - uint32_t size; - const void* pPrivateData; -} VkOpticalFlowSessionCreatePrivateDataInfoNV; - -typedef struct VkOpticalFlowExecuteInfoNV { - VkStructureType sType; - void* pNext; - VkOpticalFlowExecuteFlagsNV flags; - uint32_t regionCount; - const VkRect2D* pRegions; -} VkOpticalFlowExecuteInfoNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); -typedef VkResult (VKAPI_PTR *PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession); -typedef void (VKAPI_PTR *PFN_vkDestroyOpticalFlowSessionNV)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkBindOpticalFlowSessionImageNV)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout); -typedef void (VKAPI_PTR *PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceOpticalFlowImageFormatsNV( - VkPhysicalDevice physicalDevice, - const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, - uint32_t* pFormatCount, - VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateOpticalFlowSessionNV( - VkDevice device, - const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkOpticalFlowSessionNV* pSession); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyOpticalFlowSessionNV( - VkDevice device, - VkOpticalFlowSessionNV session, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkBindOpticalFlowSessionImageNV( - VkDevice device, - VkOpticalFlowSessionNV session, - VkOpticalFlowSessionBindingPointNV bindingPoint, - VkImageView view, - VkImageLayout layout); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdOpticalFlowExecuteNV( - VkCommandBuffer commandBuffer, - VkOpticalFlowSessionNV session, - const VkOpticalFlowExecuteInfoNV* pExecuteInfo); -#endif -#endif - - -// VK_EXT_legacy_dithering is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_legacy_dithering 1 -#define VK_EXT_LEGACY_DITHERING_SPEC_VERSION 2 -#define VK_EXT_LEGACY_DITHERING_EXTENSION_NAME "VK_EXT_legacy_dithering" -typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 legacyDithering; -} VkPhysicalDeviceLegacyDitheringFeaturesEXT; - - - -// VK_EXT_pipeline_protected_access is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_pipeline_protected_access 1 -#define VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION 1 -#define VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME "VK_EXT_pipeline_protected_access" -typedef VkPhysicalDevicePipelineProtectedAccessFeatures VkPhysicalDevicePipelineProtectedAccessFeaturesEXT; - - - -// VK_AMD_anti_lag is a preprocessor guard. Do not pass it to API calls. -#define VK_AMD_anti_lag 1 -#define VK_AMD_ANTI_LAG_SPEC_VERSION 1 -#define VK_AMD_ANTI_LAG_EXTENSION_NAME "VK_AMD_anti_lag" - -typedef enum VkAntiLagModeAMD { - VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD = 0, - VK_ANTI_LAG_MODE_ON_AMD = 1, - VK_ANTI_LAG_MODE_OFF_AMD = 2, - VK_ANTI_LAG_MODE_MAX_ENUM_AMD = 0x7FFFFFFF -} VkAntiLagModeAMD; - -typedef enum VkAntiLagStageAMD { - VK_ANTI_LAG_STAGE_INPUT_AMD = 0, - VK_ANTI_LAG_STAGE_PRESENT_AMD = 1, - VK_ANTI_LAG_STAGE_MAX_ENUM_AMD = 0x7FFFFFFF -} VkAntiLagStageAMD; -typedef struct VkPhysicalDeviceAntiLagFeaturesAMD { - VkStructureType sType; - void* pNext; - VkBool32 antiLag; -} VkPhysicalDeviceAntiLagFeaturesAMD; - -typedef struct VkAntiLagPresentationInfoAMD { - VkStructureType sType; - void* pNext; - VkAntiLagStageAMD stage; - uint64_t frameIndex; -} VkAntiLagPresentationInfoAMD; - -typedef struct VkAntiLagDataAMD { - VkStructureType sType; - const void* pNext; - VkAntiLagModeAMD mode; - uint32_t maxFPS; - const VkAntiLagPresentationInfoAMD* pPresentationInfo; -} VkAntiLagDataAMD; - -typedef void (VKAPI_PTR *PFN_vkAntiLagUpdateAMD)(VkDevice device, const VkAntiLagDataAMD* pData); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkAntiLagUpdateAMD( - VkDevice device, - const VkAntiLagDataAMD* pData); -#endif -#endif - - -// VK_EXT_shader_object is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_object 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderEXT) -#define VK_EXT_SHADER_OBJECT_SPEC_VERSION 1 -#define VK_EXT_SHADER_OBJECT_EXTENSION_NAME "VK_EXT_shader_object" - -typedef enum VkShaderCodeTypeEXT { - VK_SHADER_CODE_TYPE_BINARY_EXT = 0, - VK_SHADER_CODE_TYPE_SPIRV_EXT = 1, - VK_SHADER_CODE_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkShaderCodeTypeEXT; - -typedef enum VkDepthClampModeEXT { - VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT = 0, - VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT = 1, - VK_DEPTH_CLAMP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDepthClampModeEXT; - -typedef enum VkShaderCreateFlagBitsEXT { - VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = 0x00000001, - VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT = 0x00000400, - VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000002, - VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000004, - VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT = 0x00000008, - VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = 0x00000010, - VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, - VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, - VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT = 0x00000080, - VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT = 0x00008000, - VK_SHADER_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkShaderCreateFlagBitsEXT; -typedef VkFlags VkShaderCreateFlagsEXT; -typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderObject; -} VkPhysicalDeviceShaderObjectFeaturesEXT; - -typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT { - VkStructureType sType; - void* pNext; - uint8_t shaderBinaryUUID[VK_UUID_SIZE]; - uint32_t shaderBinaryVersion; -} VkPhysicalDeviceShaderObjectPropertiesEXT; - -typedef struct VkShaderCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkShaderCreateFlagsEXT flags; - VkShaderStageFlagBits stage; - VkShaderStageFlags nextStage; - VkShaderCodeTypeEXT codeType; - size_t codeSize; - const void* pCode; - const char* pName; - uint32_t setLayoutCount; - const VkDescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange* pPushConstantRanges; - const VkSpecializationInfo* pSpecializationInfo; -} VkShaderCreateInfoEXT; - -typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkShaderRequiredSubgroupSizeCreateInfoEXT; - -typedef struct VkDepthClampRangeEXT { - float minDepthClamp; - float maxDepthClamp; -} VkDepthClampRangeEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateShadersEXT)(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders); -typedef void (VKAPI_PTR *PFN_vkDestroyShaderEXT)(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetShaderBinaryDataEXT)(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdBindShadersEXT)(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); -typedef void (VKAPI_PTR *PFN_vkCmdSetDepthClampRangeEXT)(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT( - VkDevice device, - uint32_t createInfoCount, - const VkShaderCreateInfoEXT* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkShaderEXT* pShaders); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyShaderEXT( - VkDevice device, - VkShaderEXT shader, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderBinaryDataEXT( - VkDevice device, - VkShaderEXT shader, - size_t* pDataSize, - void* pData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindShadersEXT( - VkCommandBuffer commandBuffer, - uint32_t stageCount, - const VkShaderStageFlagBits* pStages, - const VkShaderEXT* pShaders); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthClampRangeEXT( - VkCommandBuffer commandBuffer, - VkDepthClampModeEXT depthClampMode, - const VkDepthClampRangeEXT* pDepthClampRange); -#endif -#endif - - -// VK_QCOM_tile_properties is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_tile_properties 1 -#define VK_QCOM_TILE_PROPERTIES_SPEC_VERSION 1 -#define VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME "VK_QCOM_tile_properties" -typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 tileProperties; -} VkPhysicalDeviceTilePropertiesFeaturesQCOM; - -typedef struct VkTilePropertiesQCOM { - VkStructureType sType; - void* pNext; - VkExtent3D tileSize; - VkExtent2D apronSize; - VkOffset2D origin; -} VkTilePropertiesQCOM; - -typedef VkResult (VKAPI_PTR *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetFramebufferTilePropertiesQCOM( - VkDevice device, - VkFramebuffer framebuffer, - uint32_t* pPropertiesCount, - VkTilePropertiesQCOM* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDynamicRenderingTilePropertiesQCOM( - VkDevice device, - const VkRenderingInfo* pRenderingInfo, - VkTilePropertiesQCOM* pProperties); -#endif -#endif - - -// VK_SEC_amigo_profiling is a preprocessor guard. Do not pass it to API calls. -#define VK_SEC_amigo_profiling 1 -#define VK_SEC_AMIGO_PROFILING_SPEC_VERSION 1 -#define VK_SEC_AMIGO_PROFILING_EXTENSION_NAME "VK_SEC_amigo_profiling" -typedef struct VkPhysicalDeviceAmigoProfilingFeaturesSEC { - VkStructureType sType; - void* pNext; - VkBool32 amigoProfiling; -} VkPhysicalDeviceAmigoProfilingFeaturesSEC; - -typedef struct VkAmigoProfilingSubmitInfoSEC { - VkStructureType sType; - const void* pNext; - uint64_t firstDrawTimestamp; - uint64_t swapBufferTimestamp; -} VkAmigoProfilingSubmitInfoSEC; - - - -// VK_QCOM_multiview_per_view_viewports is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_multiview_per_view_viewports 1 -#define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION 1 -#define VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME "VK_QCOM_multiview_per_view_viewports" -typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 multiviewPerViewViewports; -} VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; - - - -// VK_NV_ray_tracing_invocation_reorder is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_ray_tracing_invocation_reorder 1 -#define VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 1 -#define VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME "VK_NV_ray_tracing_invocation_reorder" - -typedef enum VkRayTracingInvocationReorderModeEXT { - VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT = 0, - VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT = 1, - VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT, - VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT, - VK_RAY_TRACING_INVOCATION_REORDER_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkRayTracingInvocationReorderModeEXT; -typedef VkRayTracingInvocationReorderModeEXT VkRayTracingInvocationReorderModeNV; - -typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV { - VkStructureType sType; - void* pNext; - VkRayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint; -} VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV; - -typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingInvocationReorder; -} VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV; - - - -// VK_NV_cooperative_vector is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_cooperative_vector 1 -#define VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION 4 -#define VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME "VK_NV_cooperative_vector" - -typedef enum VkCooperativeVectorMatrixLayoutNV { - VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV = 0, - VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV = 1, - VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV = 2, - VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV = 3, - VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_MAX_ENUM_NV = 0x7FFFFFFF -} VkCooperativeVectorMatrixLayoutNV; -typedef struct VkPhysicalDeviceCooperativeVectorPropertiesNV { - VkStructureType sType; - void* pNext; - VkShaderStageFlags cooperativeVectorSupportedStages; - VkBool32 cooperativeVectorTrainingFloat16Accumulation; - VkBool32 cooperativeVectorTrainingFloat32Accumulation; - uint32_t maxCooperativeVectorComponents; -} VkPhysicalDeviceCooperativeVectorPropertiesNV; - -typedef struct VkPhysicalDeviceCooperativeVectorFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 cooperativeVector; - VkBool32 cooperativeVectorTraining; -} VkPhysicalDeviceCooperativeVectorFeaturesNV; - -typedef struct VkCooperativeVectorPropertiesNV { - VkStructureType sType; - void* pNext; - VkComponentTypeKHR inputType; - VkComponentTypeKHR inputInterpretation; - VkComponentTypeKHR matrixInterpretation; - VkComponentTypeKHR biasInterpretation; - VkComponentTypeKHR resultType; - VkBool32 transpose; -} VkCooperativeVectorPropertiesNV; - -typedef struct VkConvertCooperativeVectorMatrixInfoNV { - VkStructureType sType; - const void* pNext; - size_t srcSize; - VkDeviceOrHostAddressConstKHR srcData; - size_t* pDstSize; - VkDeviceOrHostAddressKHR dstData; - VkComponentTypeKHR srcComponentType; - VkComponentTypeKHR dstComponentType; - uint32_t numRows; - uint32_t numColumns; - VkCooperativeVectorMatrixLayoutNV srcLayout; - size_t srcStride; - VkCooperativeVectorMatrixLayoutNV dstLayout; - size_t dstStride; -} VkConvertCooperativeVectorMatrixInfoNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeVectorPropertiesNV* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkConvertCooperativeVectorMatrixNV)(VkDevice device, const VkConvertCooperativeVectorMatrixInfoNV* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdConvertCooperativeVectorMatrixNV)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkConvertCooperativeVectorMatrixInfoNV* pInfos); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeVectorPropertiesNV( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeVectorPropertiesNV* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkConvertCooperativeVectorMatrixNV( - VkDevice device, - const VkConvertCooperativeVectorMatrixInfoNV* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdConvertCooperativeVectorMatrixNV( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkConvertCooperativeVectorMatrixInfoNV* pInfos); -#endif -#endif - - -// VK_NV_extended_sparse_address_space is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_extended_sparse_address_space 1 -#define VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION 1 -#define VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME "VK_NV_extended_sparse_address_space" -typedef struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 extendedSparseAddressSpace; -} VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; - -typedef struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV { - VkStructureType sType; - void* pNext; - VkDeviceSize extendedSparseAddressSpaceSize; - VkImageUsageFlags extendedSparseImageUsageFlags; - VkBufferUsageFlags extendedSparseBufferUsageFlags; -} VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV; - - - -// VK_EXT_mutable_descriptor_type is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_mutable_descriptor_type 1 -#define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1 -#define VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_EXT_mutable_descriptor_type" - - -// VK_EXT_legacy_vertex_attributes is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_legacy_vertex_attributes 1 -#define VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION 1 -#define VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME "VK_EXT_legacy_vertex_attributes" -typedef struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 legacyVertexAttributes; -} VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT; - -typedef struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 nativeUnalignedPerformance; -} VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT; - - - -// VK_EXT_layer_settings is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_layer_settings 1 -#define VK_EXT_LAYER_SETTINGS_SPEC_VERSION 2 -#define VK_EXT_LAYER_SETTINGS_EXTENSION_NAME "VK_EXT_layer_settings" - -typedef enum VkLayerSettingTypeEXT { - VK_LAYER_SETTING_TYPE_BOOL32_EXT = 0, - VK_LAYER_SETTING_TYPE_INT32_EXT = 1, - VK_LAYER_SETTING_TYPE_INT64_EXT = 2, - VK_LAYER_SETTING_TYPE_UINT32_EXT = 3, - VK_LAYER_SETTING_TYPE_UINT64_EXT = 4, - VK_LAYER_SETTING_TYPE_FLOAT32_EXT = 5, - VK_LAYER_SETTING_TYPE_FLOAT64_EXT = 6, - VK_LAYER_SETTING_TYPE_STRING_EXT = 7, - VK_LAYER_SETTING_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkLayerSettingTypeEXT; -typedef struct VkLayerSettingEXT { - const char* pLayerName; - const char* pSettingName; - VkLayerSettingTypeEXT type; - uint32_t valueCount; - const void* pValues; -} VkLayerSettingEXT; - -typedef struct VkLayerSettingsCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t settingCount; - const VkLayerSettingEXT* pSettings; -} VkLayerSettingsCreateInfoEXT; - - - -// VK_ARM_shader_core_builtins is a preprocessor guard. Do not pass it to API calls. -#define VK_ARM_shader_core_builtins 1 -#define VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION 2 -#define VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME "VK_ARM_shader_core_builtins" -typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM { - VkStructureType sType; - void* pNext; - VkBool32 shaderCoreBuiltins; -} VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM; - -typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM { - VkStructureType sType; - void* pNext; - uint64_t shaderCoreMask; - uint32_t shaderCoreCount; - uint32_t shaderWarpsPerCore; -} VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM; - - - -// VK_EXT_pipeline_library_group_handles is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_pipeline_library_group_handles 1 -#define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION 1 -#define VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME "VK_EXT_pipeline_library_group_handles" -typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 pipelineLibraryGroupHandles; -} VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; - - - -// VK_EXT_dynamic_rendering_unused_attachments is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_dynamic_rendering_unused_attachments 1 -#define VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION 1 -#define VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME "VK_EXT_dynamic_rendering_unused_attachments" -typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 dynamicRenderingUnusedAttachments; -} VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; - - - -// VK_NV_low_latency2 is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_low_latency2 1 -#define VK_NV_LOW_LATENCY_2_SPEC_VERSION 2 -#define VK_NV_LOW_LATENCY_2_EXTENSION_NAME "VK_NV_low_latency2" - -typedef enum VkLatencyMarkerNV { - VK_LATENCY_MARKER_SIMULATION_START_NV = 0, - VK_LATENCY_MARKER_SIMULATION_END_NV = 1, - VK_LATENCY_MARKER_RENDERSUBMIT_START_NV = 2, - VK_LATENCY_MARKER_RENDERSUBMIT_END_NV = 3, - VK_LATENCY_MARKER_PRESENT_START_NV = 4, - VK_LATENCY_MARKER_PRESENT_END_NV = 5, - VK_LATENCY_MARKER_INPUT_SAMPLE_NV = 6, - VK_LATENCY_MARKER_TRIGGER_FLASH_NV = 7, - VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV = 8, - VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV = 9, - VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV = 10, - VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV = 11, - VK_LATENCY_MARKER_MAX_ENUM_NV = 0x7FFFFFFF -} VkLatencyMarkerNV; - -typedef enum VkOutOfBandQueueTypeNV { - VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV = 0, - VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV = 1, - VK_OUT_OF_BAND_QUEUE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkOutOfBandQueueTypeNV; -typedef struct VkLatencySleepModeInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 lowLatencyMode; - VkBool32 lowLatencyBoost; - uint32_t minimumIntervalUs; -} VkLatencySleepModeInfoNV; - -typedef struct VkLatencySleepInfoNV { - VkStructureType sType; - const void* pNext; - VkSemaphore signalSemaphore; - uint64_t value; -} VkLatencySleepInfoNV; - -typedef struct VkSetLatencyMarkerInfoNV { - VkStructureType sType; - const void* pNext; - uint64_t presentID; - VkLatencyMarkerNV marker; -} VkSetLatencyMarkerInfoNV; - -typedef struct VkLatencyTimingsFrameReportNV { - VkStructureType sType; - void* pNext; - uint64_t presentID; - uint64_t inputSampleTimeUs; - uint64_t simStartTimeUs; - uint64_t simEndTimeUs; - uint64_t renderSubmitStartTimeUs; - uint64_t renderSubmitEndTimeUs; - uint64_t presentStartTimeUs; - uint64_t presentEndTimeUs; - uint64_t driverStartTimeUs; - uint64_t driverEndTimeUs; - uint64_t osRenderQueueStartTimeUs; - uint64_t osRenderQueueEndTimeUs; - uint64_t gpuRenderStartTimeUs; - uint64_t gpuRenderEndTimeUs; -} VkLatencyTimingsFrameReportNV; - -typedef struct VkGetLatencyMarkerInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t timingCount; - VkLatencyTimingsFrameReportNV* pTimings; -} VkGetLatencyMarkerInfoNV; - -typedef struct VkLatencySubmissionPresentIdNV { - VkStructureType sType; - const void* pNext; - uint64_t presentID; -} VkLatencySubmissionPresentIdNV; - -typedef struct VkSwapchainLatencyCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 latencyModeEnable; -} VkSwapchainLatencyCreateInfoNV; - -typedef struct VkOutOfBandQueueTypeInfoNV { - VkStructureType sType; - const void* pNext; - VkOutOfBandQueueTypeNV queueType; -} VkOutOfBandQueueTypeInfoNV; - -typedef struct VkLatencySurfaceCapabilitiesNV { - VkStructureType sType; - const void* pNext; - uint32_t presentModeCount; - VkPresentModeKHR* pPresentModes; -} VkLatencySurfaceCapabilitiesNV; - -typedef VkResult (VKAPI_PTR *PFN_vkSetLatencySleepModeNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo); -typedef VkResult (VKAPI_PTR *PFN_vkLatencySleepNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo); -typedef void (VKAPI_PTR *PFN_vkSetLatencyMarkerNV)(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo); -typedef void (VKAPI_PTR *PFN_vkGetLatencyTimingsNV)(VkDevice device, VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo); -typedef void (VKAPI_PTR *PFN_vkQueueNotifyOutOfBandNV)(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkSetLatencySleepModeNV( - VkDevice device, - VkSwapchainKHR swapchain, - const VkLatencySleepModeInfoNV* pSleepModeInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkLatencySleepNV( - VkDevice device, - VkSwapchainKHR swapchain, - const VkLatencySleepInfoNV* pSleepInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkSetLatencyMarkerNV( - VkDevice device, - VkSwapchainKHR swapchain, - const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetLatencyTimingsNV( - VkDevice device, - VkSwapchainKHR swapchain, - VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkQueueNotifyOutOfBandNV( - VkQueue queue, - const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); -#endif -#endif - - -// VK_ARM_data_graph is a preprocessor guard. Do not pass it to API calls. -#define VK_ARM_data_graph 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDataGraphPipelineSessionARM) -#define VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM 128U -#define VK_ARM_DATA_GRAPH_SPEC_VERSION 1 -#define VK_ARM_DATA_GRAPH_EXTENSION_NAME "VK_ARM_data_graph" - -typedef enum VkDataGraphPipelineSessionBindPointARM { - VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM = 0, - VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_MAX_ENUM_ARM = 0x7FFFFFFF -} VkDataGraphPipelineSessionBindPointARM; - -typedef enum VkDataGraphPipelineSessionBindPointTypeARM { - VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM = 0, - VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF -} VkDataGraphPipelineSessionBindPointTypeARM; - -typedef enum VkDataGraphPipelinePropertyARM { - VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM = 0, - VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM = 1, - VK_DATA_GRAPH_PIPELINE_PROPERTY_MAX_ENUM_ARM = 0x7FFFFFFF -} VkDataGraphPipelinePropertyARM; - -typedef enum VkPhysicalDeviceDataGraphProcessingEngineTypeARM { - VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM = 0, - VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM = 1000629000, - VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM = 1000629001, - VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF -} VkPhysicalDeviceDataGraphProcessingEngineTypeARM; - -typedef enum VkPhysicalDeviceDataGraphOperationTypeARM { - VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM = 0, - VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM = 1000629000, - VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM = 1000629001, - VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_MAX_ENUM_ARM = 0x7FFFFFFF -} VkPhysicalDeviceDataGraphOperationTypeARM; -typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagsARM; - -// Flag bits for VkDataGraphPipelineSessionCreateFlagBitsARM -typedef VkFlags64 VkDataGraphPipelineSessionCreateFlagBitsARM; -static const VkDataGraphPipelineSessionCreateFlagBitsARM VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM = 0x00000001ULL; - -typedef VkFlags64 VkDataGraphPipelineDispatchFlagsARM; - -// Flag bits for VkDataGraphPipelineDispatchFlagBitsARM -typedef VkFlags64 VkDataGraphPipelineDispatchFlagBitsARM; - -typedef struct VkPhysicalDeviceDataGraphFeaturesARM { - VkStructureType sType; - void* pNext; - VkBool32 dataGraph; - VkBool32 dataGraphUpdateAfterBind; - VkBool32 dataGraphSpecializationConstants; - VkBool32 dataGraphDescriptorBuffer; - VkBool32 dataGraphShaderModule; -} VkPhysicalDeviceDataGraphFeaturesARM; - -typedef struct VkDataGraphPipelineConstantARM { - VkStructureType sType; - const void* pNext; - uint32_t id; - const void* pConstantData; -} VkDataGraphPipelineConstantARM; - -typedef struct VkDataGraphPipelineResourceInfoARM { - VkStructureType sType; - const void* pNext; - uint32_t descriptorSet; - uint32_t binding; - uint32_t arrayElement; -} VkDataGraphPipelineResourceInfoARM; - -typedef struct VkDataGraphPipelineCompilerControlCreateInfoARM { - VkStructureType sType; - const void* pNext; - const char* pVendorOptions; -} VkDataGraphPipelineCompilerControlCreateInfoARM; - -typedef struct VkDataGraphPipelineCreateInfoARM { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags2KHR flags; - VkPipelineLayout layout; - uint32_t resourceInfoCount; - const VkDataGraphPipelineResourceInfoARM* pResourceInfos; -} VkDataGraphPipelineCreateInfoARM; - -typedef struct VkDataGraphPipelineShaderModuleCreateInfoARM { - VkStructureType sType; - const void* pNext; - VkShaderModule module; - const char* pName; - const VkSpecializationInfo* pSpecializationInfo; - uint32_t constantCount; - const VkDataGraphPipelineConstantARM* pConstants; -} VkDataGraphPipelineShaderModuleCreateInfoARM; - -typedef struct VkDataGraphPipelineSessionCreateInfoARM { - VkStructureType sType; - const void* pNext; - VkDataGraphPipelineSessionCreateFlagsARM flags; - VkPipeline dataGraphPipeline; -} VkDataGraphPipelineSessionCreateInfoARM; - -typedef struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM { - VkStructureType sType; - const void* pNext; - VkDataGraphPipelineSessionARM session; -} VkDataGraphPipelineSessionBindPointRequirementsInfoARM; - -typedef struct VkDataGraphPipelineSessionBindPointRequirementARM { - VkStructureType sType; - void* pNext; - VkDataGraphPipelineSessionBindPointARM bindPoint; - VkDataGraphPipelineSessionBindPointTypeARM bindPointType; - uint32_t numObjects; -} VkDataGraphPipelineSessionBindPointRequirementARM; - -typedef struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM { - VkStructureType sType; - const void* pNext; - VkDataGraphPipelineSessionARM session; - VkDataGraphPipelineSessionBindPointARM bindPoint; - uint32_t objectIndex; -} VkDataGraphPipelineSessionMemoryRequirementsInfoARM; - -typedef struct VkBindDataGraphPipelineSessionMemoryInfoARM { - VkStructureType sType; - const void* pNext; - VkDataGraphPipelineSessionARM session; - VkDataGraphPipelineSessionBindPointARM bindPoint; - uint32_t objectIndex; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; -} VkBindDataGraphPipelineSessionMemoryInfoARM; - -typedef struct VkDataGraphPipelineInfoARM { - VkStructureType sType; - const void* pNext; - VkPipeline dataGraphPipeline; -} VkDataGraphPipelineInfoARM; - -typedef struct VkDataGraphPipelinePropertyQueryResultARM { - VkStructureType sType; - void* pNext; - VkDataGraphPipelinePropertyARM property; - VkBool32 isText; - size_t dataSize; - void* pData; -} VkDataGraphPipelinePropertyQueryResultARM; - -typedef struct VkDataGraphPipelineIdentifierCreateInfoARM { - VkStructureType sType; - const void* pNext; - uint32_t identifierSize; - const uint8_t* pIdentifier; -} VkDataGraphPipelineIdentifierCreateInfoARM; - -typedef struct VkDataGraphPipelineDispatchInfoARM { - VkStructureType sType; - void* pNext; - VkDataGraphPipelineDispatchFlagsARM flags; -} VkDataGraphPipelineDispatchInfoARM; - -typedef struct VkPhysicalDeviceDataGraphProcessingEngineARM { - VkPhysicalDeviceDataGraphProcessingEngineTypeARM type; - VkBool32 isForeign; -} VkPhysicalDeviceDataGraphProcessingEngineARM; - -typedef struct VkPhysicalDeviceDataGraphOperationSupportARM { - VkPhysicalDeviceDataGraphOperationTypeARM operationType; - char name[VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM]; - uint32_t version; -} VkPhysicalDeviceDataGraphOperationSupportARM; - -typedef struct VkQueueFamilyDataGraphPropertiesARM { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceDataGraphProcessingEngineARM engine; - VkPhysicalDeviceDataGraphOperationSupportARM operation; -} VkQueueFamilyDataGraphPropertiesARM; - -typedef struct VkDataGraphProcessingEngineCreateInfoARM { - VkStructureType sType; - const void* pNext; - uint32_t processingEngineCount; - VkPhysicalDeviceDataGraphProcessingEngineARM* pProcessingEngines; -} VkDataGraphProcessingEngineCreateInfoARM; - -typedef struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM { - VkStructureType sType; - const void* pNext; - uint32_t queueFamilyIndex; - VkPhysicalDeviceDataGraphProcessingEngineTypeARM engineType; -} VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; - -typedef struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM { - VkStructureType sType; - void* pNext; - VkExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes; - VkExternalMemoryHandleTypeFlags foreignMemoryHandleTypes; -} VkQueueFamilyDataGraphProcessingEnginePropertiesARM; - -typedef struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM { - VkStructureType sType; - const void* pNext; - uint32_t dimension; - uint32_t zeroCount; - uint32_t groupSize; -} VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateDataGraphPipelinesARM)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkDataGraphPipelineCreateInfoARM* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDataGraphPipelineSessionARM)(VkDevice device, const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDataGraphPipelineSessionARM* pSession); -typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM)(VkDevice device, const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, uint32_t* pBindPointRequirementCount, VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements); -typedef void (VKAPI_PTR *PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM)(VkDevice device, const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef VkResult (VKAPI_PTR *PFN_vkBindDataGraphPipelineSessionMemoryARM)(VkDevice device, uint32_t bindInfoCount, const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos); -typedef void (VKAPI_PTR *PFN_vkDestroyDataGraphPipelineSessionARM)(VkDevice device, VkDataGraphPipelineSessionARM session, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkCmdDispatchDataGraphARM)(VkCommandBuffer commandBuffer, VkDataGraphPipelineSessionARM session, const VkDataGraphPipelineDispatchInfoARM* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelineAvailablePropertiesARM)(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t* pPropertiesCount, VkDataGraphPipelinePropertyARM* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetDataGraphPipelinePropertiesARM)(VkDevice device, const VkDataGraphPipelineInfoARM* pPipelineInfo, uint32_t propertiesCount, VkDataGraphPipelinePropertyQueryResultARM* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pQueueFamilyDataGraphPropertyCount, VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties); -typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelinesARM( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkDataGraphPipelineCreateInfoARM* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDataGraphPipelineSessionARM( - VkDevice device, - const VkDataGraphPipelineSessionCreateInfoARM* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDataGraphPipelineSessionARM* pSession); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineSessionBindPointRequirementsARM( - VkDevice device, - const VkDataGraphPipelineSessionBindPointRequirementsInfoARM* pInfo, - uint32_t* pBindPointRequirementCount, - VkDataGraphPipelineSessionBindPointRequirementARM* pBindPointRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDataGraphPipelineSessionMemoryRequirementsARM( - VkDevice device, - const VkDataGraphPipelineSessionMemoryRequirementsInfoARM* pInfo, - VkMemoryRequirements2* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkBindDataGraphPipelineSessionMemoryARM( - VkDevice device, - uint32_t bindInfoCount, - const VkBindDataGraphPipelineSessionMemoryInfoARM* pBindInfos); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyDataGraphPipelineSessionARM( - VkDevice device, - VkDataGraphPipelineSessionARM session, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDispatchDataGraphARM( - VkCommandBuffer commandBuffer, - VkDataGraphPipelineSessionARM session, - const VkDataGraphPipelineDispatchInfoARM* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelineAvailablePropertiesARM( - VkDevice device, - const VkDataGraphPipelineInfoARM* pPipelineInfo, - uint32_t* pPropertiesCount, - VkDataGraphPipelinePropertyARM* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDataGraphPipelinePropertiesARM( - VkDevice device, - const VkDataGraphPipelineInfoARM* pPipelineInfo, - uint32_t propertiesCount, - VkDataGraphPipelinePropertyQueryResultARM* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - uint32_t* pQueueFamilyDataGraphPropertyCount, - VkQueueFamilyDataGraphPropertiesARM* pQueueFamilyDataGraphProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM* pQueueFamilyDataGraphProcessingEngineInfo, - VkQueueFamilyDataGraphProcessingEnginePropertiesARM* pQueueFamilyDataGraphProcessingEngineProperties); -#endif -#endif - - -// VK_QCOM_multiview_per_view_render_areas is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_multiview_per_view_render_areas 1 -#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION 1 -#define VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME "VK_QCOM_multiview_per_view_render_areas" -typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 multiviewPerViewRenderAreas; -} VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; - -typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM { - VkStructureType sType; - const void* pNext; - uint32_t perViewRenderAreaCount; - const VkRect2D* pPerViewRenderAreas; -} VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; - - - -// VK_NV_per_stage_descriptor_set is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_per_stage_descriptor_set 1 -#define VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION 1 -#define VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME "VK_NV_per_stage_descriptor_set" -typedef struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 perStageDescriptorSet; - VkBool32 dynamicPipelineLayout; -} VkPhysicalDevicePerStageDescriptorSetFeaturesNV; - - - -// VK_QCOM_image_processing2 is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_image_processing2 1 -#define VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION 1 -#define VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME "VK_QCOM_image_processing2" - -typedef enum VkBlockMatchWindowCompareModeQCOM { - VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM = 0, - VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM = 1, - VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_ENUM_QCOM = 0x7FFFFFFF -} VkBlockMatchWindowCompareModeQCOM; -typedef struct VkPhysicalDeviceImageProcessing2FeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 textureBlockMatch2; -} VkPhysicalDeviceImageProcessing2FeaturesQCOM; - -typedef struct VkPhysicalDeviceImageProcessing2PropertiesQCOM { - VkStructureType sType; - void* pNext; - VkExtent2D maxBlockMatchWindow; -} VkPhysicalDeviceImageProcessing2PropertiesQCOM; - -typedef struct VkSamplerBlockMatchWindowCreateInfoQCOM { - VkStructureType sType; - const void* pNext; - VkExtent2D windowExtent; - VkBlockMatchWindowCompareModeQCOM windowCompareMode; -} VkSamplerBlockMatchWindowCreateInfoQCOM; - - - -// VK_QCOM_filter_cubic_weights is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_filter_cubic_weights 1 -#define VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION 1 -#define VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME "VK_QCOM_filter_cubic_weights" - -typedef enum VkCubicFilterWeightsQCOM { - VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM = 0, - VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM = 1, - VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM = 2, - VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM = 3, - VK_CUBIC_FILTER_WEIGHTS_MAX_ENUM_QCOM = 0x7FFFFFFF -} VkCubicFilterWeightsQCOM; -typedef struct VkPhysicalDeviceCubicWeightsFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 selectableCubicWeights; -} VkPhysicalDeviceCubicWeightsFeaturesQCOM; - -typedef struct VkSamplerCubicWeightsCreateInfoQCOM { - VkStructureType sType; - const void* pNext; - VkCubicFilterWeightsQCOM cubicWeights; -} VkSamplerCubicWeightsCreateInfoQCOM; - -typedef struct VkBlitImageCubicWeightsInfoQCOM { - VkStructureType sType; - const void* pNext; - VkCubicFilterWeightsQCOM cubicWeights; -} VkBlitImageCubicWeightsInfoQCOM; - - - -// VK_QCOM_ycbcr_degamma is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_ycbcr_degamma 1 -#define VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION 1 -#define VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME "VK_QCOM_ycbcr_degamma" -typedef struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 ycbcrDegamma; -} VkPhysicalDeviceYcbcrDegammaFeaturesQCOM; - -typedef struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM { - VkStructureType sType; - void* pNext; - VkBool32 enableYDegamma; - VkBool32 enableCbCrDegamma; -} VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; - - - -// VK_QCOM_filter_cubic_clamp is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_filter_cubic_clamp 1 -#define VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION 1 -#define VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME "VK_QCOM_filter_cubic_clamp" -typedef struct VkPhysicalDeviceCubicClampFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 cubicRangeClamp; -} VkPhysicalDeviceCubicClampFeaturesQCOM; - - - -// VK_EXT_attachment_feedback_loop_dynamic_state is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_attachment_feedback_loop_dynamic_state 1 -#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION 1 -#define VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_attachment_feedback_loop_dynamic_state" -typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 attachmentFeedbackLoopDynamicState; -} VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT)(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetAttachmentFeedbackLoopEnableEXT( - VkCommandBuffer commandBuffer, - VkImageAspectFlags aspectMask); -#endif -#endif - - -// VK_MSFT_layered_driver is a preprocessor guard. Do not pass it to API calls. -#define VK_MSFT_layered_driver 1 -#define VK_MSFT_LAYERED_DRIVER_SPEC_VERSION 1 -#define VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME "VK_MSFT_layered_driver" - -typedef enum VkLayeredDriverUnderlyingApiMSFT { - VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT = 0, - VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT = 1, - VK_LAYERED_DRIVER_UNDERLYING_API_MAX_ENUM_MSFT = 0x7FFFFFFF -} VkLayeredDriverUnderlyingApiMSFT; -typedef struct VkPhysicalDeviceLayeredDriverPropertiesMSFT { - VkStructureType sType; - void* pNext; - VkLayeredDriverUnderlyingApiMSFT underlyingAPI; -} VkPhysicalDeviceLayeredDriverPropertiesMSFT; - - - -// VK_NV_descriptor_pool_overallocation is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_descriptor_pool_overallocation 1 -#define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION 1 -#define VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME "VK_NV_descriptor_pool_overallocation" -typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 descriptorPoolOverallocation; -} VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV; - - - -// VK_QCOM_tile_memory_heap is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_tile_memory_heap 1 -#define VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION 1 -#define VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME "VK_QCOM_tile_memory_heap" -typedef struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 tileMemoryHeap; -} VkPhysicalDeviceTileMemoryHeapFeaturesQCOM; - -typedef struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 queueSubmitBoundary; - VkBool32 tileBufferTransfers; -} VkPhysicalDeviceTileMemoryHeapPropertiesQCOM; - -typedef struct VkTileMemoryRequirementsQCOM { - VkStructureType sType; - void* pNext; - VkDeviceSize size; - VkDeviceSize alignment; -} VkTileMemoryRequirementsQCOM; - -typedef struct VkTileMemoryBindInfoQCOM { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; -} VkTileMemoryBindInfoQCOM; - -typedef struct VkTileMemorySizeInfoQCOM { - VkStructureType sType; - const void* pNext; - VkDeviceSize size; -} VkTileMemorySizeInfoQCOM; - -typedef void (VKAPI_PTR *PFN_vkCmdBindTileMemoryQCOM)(VkCommandBuffer commandBuffer, const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBindTileMemoryQCOM( - VkCommandBuffer commandBuffer, - const VkTileMemoryBindInfoQCOM* pTileMemoryBindInfo); -#endif -#endif - - -// VK_EXT_memory_decompression is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_memory_decompression 1 -#define VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION 1 -#define VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME "VK_EXT_memory_decompression" -typedef struct VkDecompressMemoryRegionEXT { - VkDeviceAddress srcAddress; - VkDeviceAddress dstAddress; - VkDeviceSize compressedSize; - VkDeviceSize decompressedSize; -} VkDecompressMemoryRegionEXT; - -typedef struct VkDecompressMemoryInfoEXT { - VkStructureType sType; - const void* pNext; - VkMemoryDecompressionMethodFlagsEXT decompressionMethod; - uint32_t regionCount; - const VkDecompressMemoryRegionEXT* pRegions; -} VkDecompressMemoryInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryEXT)(VkCommandBuffer commandBuffer, const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT); -typedef void (VKAPI_PTR *PFN_vkCmdDecompressMemoryIndirectCountEXT)(VkCommandBuffer commandBuffer, VkMemoryDecompressionMethodFlagsEXT decompressionMethod, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t maxDecompressionCount, uint32_t stride); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryEXT( - VkCommandBuffer commandBuffer, - const VkDecompressMemoryInfoEXT* pDecompressMemoryInfoEXT); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDecompressMemoryIndirectCountEXT( - VkCommandBuffer commandBuffer, - VkMemoryDecompressionMethodFlagsEXT decompressionMethod, - VkDeviceAddress indirectCommandsAddress, - VkDeviceAddress indirectCommandsCountAddress, - uint32_t maxDecompressionCount, - uint32_t stride); -#endif -#endif - - -// VK_NV_display_stereo is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_display_stereo 1 -#define VK_NV_DISPLAY_STEREO_SPEC_VERSION 1 -#define VK_NV_DISPLAY_STEREO_EXTENSION_NAME "VK_NV_display_stereo" - -typedef enum VkDisplaySurfaceStereoTypeNV { - VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV = 0, - VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV = 1, - VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV = 2, - VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV = 3, - VK_DISPLAY_SURFACE_STEREO_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkDisplaySurfaceStereoTypeNV; -typedef struct VkDisplaySurfaceStereoCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkDisplaySurfaceStereoTypeNV stereoType; -} VkDisplaySurfaceStereoCreateInfoNV; - -typedef struct VkDisplayModeStereoPropertiesNV { - VkStructureType sType; - void* pNext; - VkBool32 hdmi3DSupported; -} VkDisplayModeStereoPropertiesNV; - - - -// VK_NV_raw_access_chains is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_raw_access_chains 1 -#define VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION 1 -#define VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME "VK_NV_raw_access_chains" -typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 shaderRawAccessChains; -} VkPhysicalDeviceRawAccessChainsFeaturesNV; - - - -// VK_NV_external_compute_queue is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_external_compute_queue 1 -VK_DEFINE_HANDLE(VkExternalComputeQueueNV) -#define VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION 1 -#define VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME "VK_NV_external_compute_queue" -typedef struct VkExternalComputeQueueDeviceCreateInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t reservedExternalQueues; -} VkExternalComputeQueueDeviceCreateInfoNV; - -typedef struct VkExternalComputeQueueCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkQueue preferredQueue; -} VkExternalComputeQueueCreateInfoNV; - -typedef struct VkExternalComputeQueueDataParamsNV { - VkStructureType sType; - const void* pNext; - uint32_t deviceIndex; -} VkExternalComputeQueueDataParamsNV; - -typedef struct VkPhysicalDeviceExternalComputeQueuePropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t externalDataSize; - uint32_t maxExternalQueues; -} VkPhysicalDeviceExternalComputeQueuePropertiesNV; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateExternalComputeQueueNV)(VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue); -typedef void (VKAPI_PTR *PFN_vkDestroyExternalComputeQueueNV)(VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkGetExternalComputeQueueDataNV)(VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateExternalComputeQueueNV( - VkDevice device, - const VkExternalComputeQueueCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkExternalComputeQueueNV* pExternalQueue); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyExternalComputeQueueNV( - VkDevice device, - VkExternalComputeQueueNV externalQueue, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetExternalComputeQueueDataNV( - VkExternalComputeQueueNV externalQueue, - VkExternalComputeQueueDataParamsNV* params, - void* pData); -#endif -#endif - - -// VK_NV_command_buffer_inheritance is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_command_buffer_inheritance 1 -#define VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION 1 -#define VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME "VK_NV_command_buffer_inheritance" -typedef struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 commandBufferInheritance; -} VkPhysicalDeviceCommandBufferInheritanceFeaturesNV; - - - -// VK_NV_shader_atomic_float16_vector is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_shader_atomic_float16_vector 1 -#define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION 1 -#define VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME "VK_NV_shader_atomic_float16_vector" -typedef struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 shaderFloat16VectorAtomics; -} VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; - - - -// VK_EXT_shader_replicated_composites is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_replicated_composites 1 -#define VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION 1 -#define VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME "VK_EXT_shader_replicated_composites" -typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderReplicatedComposites; -} VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT; - - - -// VK_EXT_shader_float8 is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_float8 1 -#define VK_EXT_SHADER_FLOAT8_SPEC_VERSION 1 -#define VK_EXT_SHADER_FLOAT8_EXTENSION_NAME "VK_EXT_shader_float8" -typedef struct VkPhysicalDeviceShaderFloat8FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderFloat8; - VkBool32 shaderFloat8CooperativeMatrix; -} VkPhysicalDeviceShaderFloat8FeaturesEXT; - - - -// VK_NV_ray_tracing_validation is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_ray_tracing_validation 1 -#define VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION 1 -#define VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME "VK_NV_ray_tracing_validation" -typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingValidation; -} VkPhysicalDeviceRayTracingValidationFeaturesNV; - - - -// VK_NV_cluster_acceleration_structure is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_cluster_acceleration_structure 1 -#define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION 4 -#define VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_NV_cluster_acceleration_structure" - -typedef enum VkClusterAccelerationStructureTypeNV { - VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV = 0, - VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV = 1, - VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV = 2, - VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkClusterAccelerationStructureTypeNV; - -typedef enum VkClusterAccelerationStructureOpTypeNV { - VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV = 0, - VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV = 1, - VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV = 2, - VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV = 3, - VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV = 4, - VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV = 5, - VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkClusterAccelerationStructureOpTypeNV; - -typedef enum VkClusterAccelerationStructureOpModeNV { - VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV = 0, - VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV = 1, - VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV = 2, - VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_MAX_ENUM_NV = 0x7FFFFFFF -} VkClusterAccelerationStructureOpModeNV; - -typedef enum VkClusterAccelerationStructureAddressResolutionFlagBitsNV { - VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV = 0, - VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV = 0x00000001, - VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV = 0x00000002, - VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV = 0x00000004, - VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV = 0x00000008, - VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV = 0x00000010, - VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV = 0x00000020, - VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkClusterAccelerationStructureAddressResolutionFlagBitsNV; -typedef VkFlags VkClusterAccelerationStructureAddressResolutionFlagsNV; - -typedef enum VkClusterAccelerationStructureClusterFlagBitsNV { - VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV = 0x00000001, - VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkClusterAccelerationStructureClusterFlagBitsNV; -typedef VkFlags VkClusterAccelerationStructureClusterFlagsNV; - -typedef enum VkClusterAccelerationStructureGeometryFlagBitsNV { - VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV = 0x00000001, - VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV = 0x00000002, - VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV = 0x00000004, - VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkClusterAccelerationStructureGeometryFlagBitsNV; -typedef VkFlags VkClusterAccelerationStructureGeometryFlagsNV; - -typedef enum VkClusterAccelerationStructureIndexFormatFlagBitsNV { - VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV = 0x00000001, - VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV = 0x00000002, - VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV = 0x00000004, - VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkClusterAccelerationStructureIndexFormatFlagBitsNV; -typedef VkFlags VkClusterAccelerationStructureIndexFormatFlagsNV; -typedef struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 clusterAccelerationStructure; -} VkPhysicalDeviceClusterAccelerationStructureFeaturesNV; - -typedef struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t maxVerticesPerCluster; - uint32_t maxTrianglesPerCluster; - uint32_t clusterScratchByteAlignment; - uint32_t clusterByteAlignment; - uint32_t clusterTemplateByteAlignment; - uint32_t clusterBottomLevelByteAlignment; - uint32_t clusterTemplateBoundsByteAlignment; - uint32_t maxClusterGeometryIndex; -} VkPhysicalDeviceClusterAccelerationStructurePropertiesNV; - -typedef struct VkClusterAccelerationStructureClustersBottomLevelInputNV { - VkStructureType sType; - void* pNext; - uint32_t maxTotalClusterCount; - uint32_t maxClusterCountPerAccelerationStructure; -} VkClusterAccelerationStructureClustersBottomLevelInputNV; - -typedef struct VkClusterAccelerationStructureTriangleClusterInputNV { - VkStructureType sType; - void* pNext; - VkFormat vertexFormat; - uint32_t maxGeometryIndexValue; - uint32_t maxClusterUniqueGeometryCount; - uint32_t maxClusterTriangleCount; - uint32_t maxClusterVertexCount; - uint32_t maxTotalTriangleCount; - uint32_t maxTotalVertexCount; - uint32_t minPositionTruncateBitCount; -} VkClusterAccelerationStructureTriangleClusterInputNV; - -typedef struct VkClusterAccelerationStructureMoveObjectsInputNV { - VkStructureType sType; - void* pNext; - VkClusterAccelerationStructureTypeNV type; - VkBool32 noMoveOverlap; - VkDeviceSize maxMovedBytes; -} VkClusterAccelerationStructureMoveObjectsInputNV; - -typedef union VkClusterAccelerationStructureOpInputNV { - VkClusterAccelerationStructureClustersBottomLevelInputNV* pClustersBottomLevel; - VkClusterAccelerationStructureTriangleClusterInputNV* pTriangleClusters; - VkClusterAccelerationStructureMoveObjectsInputNV* pMoveObjects; -} VkClusterAccelerationStructureOpInputNV; - -typedef struct VkClusterAccelerationStructureInputInfoNV { - VkStructureType sType; - void* pNext; - uint32_t maxAccelerationStructureCount; - VkBuildAccelerationStructureFlagsKHR flags; - VkClusterAccelerationStructureOpTypeNV opType; - VkClusterAccelerationStructureOpModeNV opMode; - VkClusterAccelerationStructureOpInputNV opInput; -} VkClusterAccelerationStructureInputInfoNV; - -typedef struct VkStridedDeviceAddressRegionKHR { - VkDeviceAddress deviceAddress; - VkDeviceSize stride; - VkDeviceSize size; -} VkStridedDeviceAddressRegionKHR; - -typedef struct VkClusterAccelerationStructureCommandsInfoNV { - VkStructureType sType; - void* pNext; - VkClusterAccelerationStructureInputInfoNV input; - VkDeviceAddress dstImplicitData; - VkDeviceAddress scratchData; - VkStridedDeviceAddressRegionKHR dstAddressesArray; - VkStridedDeviceAddressRegionKHR dstSizesArray; - VkStridedDeviceAddressRegionKHR srcInfosArray; - VkDeviceAddress srcInfosCount; - VkClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags; -} VkClusterAccelerationStructureCommandsInfoNV; - -typedef struct VkStridedDeviceAddressNV { - VkDeviceAddress startAddress; - VkDeviceSize strideInBytes; -} VkStridedDeviceAddressNV; - -typedef struct VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV { - uint32_t geometryIndex:24; - uint32_t reserved:5; - uint32_t geometryFlags:3; -} VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV; - -typedef struct VkClusterAccelerationStructureMoveObjectsInfoNV { - VkDeviceAddress srcAccelerationStructure; -} VkClusterAccelerationStructureMoveObjectsInfoNV; - -typedef struct VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV { - uint32_t clusterReferencesCount; - uint32_t clusterReferencesStride; - VkDeviceAddress clusterReferences; -} VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV; - -typedef struct VkClusterAccelerationStructureBuildTriangleClusterInfoNV { - uint32_t clusterID; - VkClusterAccelerationStructureClusterFlagsNV clusterFlags; - uint32_t triangleCount:9; - uint32_t vertexCount:9; - uint32_t positionTruncateBitCount:6; - uint32_t indexType:4; - uint32_t opacityMicromapIndexType:4; - VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags; - uint16_t indexBufferStride; - uint16_t vertexBufferStride; - uint16_t geometryIndexAndFlagsBufferStride; - uint16_t opacityMicromapIndexBufferStride; - VkDeviceAddress indexBuffer; - VkDeviceAddress vertexBuffer; - VkDeviceAddress geometryIndexAndFlagsBuffer; - VkDeviceAddress opacityMicromapArray; - VkDeviceAddress opacityMicromapIndexBuffer; -} VkClusterAccelerationStructureBuildTriangleClusterInfoNV; - -typedef struct VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV { - uint32_t clusterID; - VkClusterAccelerationStructureClusterFlagsNV clusterFlags; - uint32_t triangleCount:9; - uint32_t vertexCount:9; - uint32_t positionTruncateBitCount:6; - uint32_t indexType:4; - uint32_t opacityMicromapIndexType:4; - VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags; - uint16_t indexBufferStride; - uint16_t vertexBufferStride; - uint16_t geometryIndexAndFlagsBufferStride; - uint16_t opacityMicromapIndexBufferStride; - VkDeviceAddress indexBuffer; - VkDeviceAddress vertexBuffer; - VkDeviceAddress geometryIndexAndFlagsBuffer; - VkDeviceAddress opacityMicromapArray; - VkDeviceAddress opacityMicromapIndexBuffer; - VkDeviceAddress instantiationBoundingBoxLimit; -} VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV; - -typedef struct VkClusterAccelerationStructureInstantiateClusterInfoNV { - uint32_t clusterIdOffset; - uint32_t geometryIndexOffset:24; - uint32_t reserved:8; - VkDeviceAddress clusterTemplateAddress; - VkStridedDeviceAddressNV vertexBuffer; -} VkClusterAccelerationStructureInstantiateClusterInfoNV; - -typedef struct VkClusterAccelerationStructureGetTemplateIndicesInfoNV { - VkDeviceAddress clusterTemplateAddress; -} VkClusterAccelerationStructureGetTemplateIndicesInfoNV; - -typedef struct VkAccelerationStructureBuildSizesInfoKHR { - VkStructureType sType; - void* pNext; - VkDeviceSize accelerationStructureSize; - VkDeviceSize updateScratchSize; - VkDeviceSize buildScratchSize; -} VkAccelerationStructureBuildSizesInfoKHR; - -typedef struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV { - VkStructureType sType; - void* pNext; - VkBool32 allowClusterAccelerationStructure; -} VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV; - -typedef void (VKAPI_PTR *PFN_vkGetClusterAccelerationStructureBuildSizesNV)(VkDevice device, const VkClusterAccelerationStructureInputInfoNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBuildClusterAccelerationStructureIndirectNV)(VkCommandBuffer commandBuffer, const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetClusterAccelerationStructureBuildSizesNV( - VkDevice device, - const VkClusterAccelerationStructureInputInfoNV* pInfo, - VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBuildClusterAccelerationStructureIndirectNV( - VkCommandBuffer commandBuffer, - const VkClusterAccelerationStructureCommandsInfoNV* pCommandInfos); -#endif -#endif - - -// VK_NV_partitioned_acceleration_structure is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_partitioned_acceleration_structure 1 -#define VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION 1 -#define VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_NV_partitioned_acceleration_structure" -#define VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV (~0U) - -typedef enum VkPartitionedAccelerationStructureOpTypeNV { - VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV = 0, - VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV = 1, - VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV = 2, - VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkPartitionedAccelerationStructureOpTypeNV; - -typedef enum VkPartitionedAccelerationStructureInstanceFlagBitsNV { - VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV = 0x00000001, - VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV = 0x00000002, - VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV = 0x00000004, - VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV = 0x00000008, - VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV = 0x00000010, - VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkPartitionedAccelerationStructureInstanceFlagBitsNV; -typedef VkFlags VkPartitionedAccelerationStructureInstanceFlagsNV; -typedef struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 partitionedAccelerationStructure; -} VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV; - -typedef struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t maxPartitionCount; -} VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV; - -typedef struct VkPartitionedAccelerationStructureFlagsNV { - VkStructureType sType; - void* pNext; - VkBool32 enablePartitionTranslation; -} VkPartitionedAccelerationStructureFlagsNV; - -typedef struct VkBuildPartitionedAccelerationStructureIndirectCommandNV { - VkPartitionedAccelerationStructureOpTypeNV opType; - uint32_t argCount; - VkStridedDeviceAddressNV argData; -} VkBuildPartitionedAccelerationStructureIndirectCommandNV; - -typedef struct VkPartitionedAccelerationStructureWriteInstanceDataNV { - VkTransformMatrixKHR transform; - float explicitAABB[6]; - uint32_t instanceID; - uint32_t instanceMask; - uint32_t instanceContributionToHitGroupIndex; - VkPartitionedAccelerationStructureInstanceFlagsNV instanceFlags; - uint32_t instanceIndex; - uint32_t partitionIndex; - VkDeviceAddress accelerationStructure; -} VkPartitionedAccelerationStructureWriteInstanceDataNV; - -typedef struct VkPartitionedAccelerationStructureUpdateInstanceDataNV { - uint32_t instanceIndex; - uint32_t instanceContributionToHitGroupIndex; - VkDeviceAddress accelerationStructure; -} VkPartitionedAccelerationStructureUpdateInstanceDataNV; - -typedef struct VkPartitionedAccelerationStructureWritePartitionTranslationDataNV { - uint32_t partitionIndex; - float partitionTranslation[3]; -} VkPartitionedAccelerationStructureWritePartitionTranslationDataNV; - -typedef struct VkWriteDescriptorSetPartitionedAccelerationStructureNV { - VkStructureType sType; - void* pNext; - uint32_t accelerationStructureCount; - const VkDeviceAddress* pAccelerationStructures; -} VkWriteDescriptorSetPartitionedAccelerationStructureNV; - -typedef struct VkPartitionedAccelerationStructureInstancesInputNV { - VkStructureType sType; - void* pNext; - VkBuildAccelerationStructureFlagsKHR flags; - uint32_t instanceCount; - uint32_t maxInstancePerPartitionCount; - uint32_t partitionCount; - uint32_t maxInstanceInGlobalPartitionCount; -} VkPartitionedAccelerationStructureInstancesInputNV; - -typedef struct VkBuildPartitionedAccelerationStructureInfoNV { - VkStructureType sType; - void* pNext; - VkPartitionedAccelerationStructureInstancesInputNV input; - VkDeviceAddress srcAccelerationStructureData; - VkDeviceAddress dstAccelerationStructureData; - VkDeviceAddress scratchData; - VkDeviceAddress srcInfos; - VkDeviceAddress srcInfosCount; -} VkBuildPartitionedAccelerationStructureInfoNV; - -typedef void (VKAPI_PTR *PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV)(VkDevice device, const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); -typedef void (VKAPI_PTR *PFN_vkCmdBuildPartitionedAccelerationStructuresNV)(VkCommandBuffer commandBuffer, const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetPartitionedAccelerationStructuresBuildSizesNV( - VkDevice device, - const VkPartitionedAccelerationStructureInstancesInputNV* pInfo, - VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBuildPartitionedAccelerationStructuresNV( - VkCommandBuffer commandBuffer, - const VkBuildPartitionedAccelerationStructureInfoNV* pBuildInfo); -#endif -#endif - - -// VK_EXT_device_generated_commands is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_device_generated_commands 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectExecutionSetEXT) -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutEXT) -#define VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 1 -#define VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_EXT_device_generated_commands" - -typedef enum VkIndirectExecutionSetInfoTypeEXT { - VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT = 0, - VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT = 1, - VK_INDIRECT_EXECUTION_SET_INFO_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkIndirectExecutionSetInfoTypeEXT; - -typedef enum VkIndirectCommandsTokenTypeEXT { - VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT = 0, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT = 1, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT = 2, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT = 3, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT = 4, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT = 5, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT = 6, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT = 7, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT = 8, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT = 9, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT = 1000135000, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT = 1000135001, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT = 1000202002, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT = 1000202003, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT = 1000328000, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT = 1000328001, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT = 1000386004, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkIndirectCommandsTokenTypeEXT; - -typedef enum VkIndirectCommandsInputModeFlagBitsEXT { - VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT = 0x00000001, - VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT = 0x00000002, - VK_INDIRECT_COMMANDS_INPUT_MODE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkIndirectCommandsInputModeFlagBitsEXT; -typedef VkFlags VkIndirectCommandsInputModeFlagsEXT; - -typedef enum VkIndirectCommandsLayoutUsageFlagBitsEXT { - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT = 0x00000001, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT = 0x00000002, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkIndirectCommandsLayoutUsageFlagBitsEXT; -typedef VkFlags VkIndirectCommandsLayoutUsageFlagsEXT; -typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 deviceGeneratedCommands; - VkBool32 dynamicGeneratedPipelineLayout; -} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; - -typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxIndirectPipelineCount; - uint32_t maxIndirectShaderObjectCount; - uint32_t maxIndirectSequenceCount; - uint32_t maxIndirectCommandsTokenCount; - uint32_t maxIndirectCommandsTokenOffset; - uint32_t maxIndirectCommandsIndirectStride; - VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes; - VkShaderStageFlags supportedIndirectCommandsShaderStages; - VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding; - VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding; - VkBool32 deviceGeneratedCommandsTransformFeedback; - VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount; -} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; - -typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT { - VkStructureType sType; - const void* pNext; - VkIndirectExecutionSetEXT indirectExecutionSet; - VkIndirectCommandsLayoutEXT indirectCommandsLayout; - uint32_t maxSequenceCount; - uint32_t maxDrawCount; -} VkGeneratedCommandsMemoryRequirementsInfoEXT; - -typedef struct VkIndirectExecutionSetPipelineInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipeline initialPipeline; - uint32_t maxPipelineCount; -} VkIndirectExecutionSetPipelineInfoEXT; - -typedef struct VkIndirectExecutionSetShaderLayoutInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t setLayoutCount; - const VkDescriptorSetLayout* pSetLayouts; -} VkIndirectExecutionSetShaderLayoutInfoEXT; - -typedef struct VkIndirectExecutionSetShaderInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t shaderCount; - const VkShaderEXT* pInitialShaders; - const VkIndirectExecutionSetShaderLayoutInfoEXT* pSetLayoutInfos; - uint32_t maxShaderCount; - uint32_t pushConstantRangeCount; - const VkPushConstantRange* pPushConstantRanges; -} VkIndirectExecutionSetShaderInfoEXT; - -typedef union VkIndirectExecutionSetInfoEXT { - const VkIndirectExecutionSetPipelineInfoEXT* pPipelineInfo; - const VkIndirectExecutionSetShaderInfoEXT* pShaderInfo; -} VkIndirectExecutionSetInfoEXT; - -typedef struct VkIndirectExecutionSetCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkIndirectExecutionSetInfoTypeEXT type; - VkIndirectExecutionSetInfoEXT info; -} VkIndirectExecutionSetCreateInfoEXT; - -typedef struct VkGeneratedCommandsInfoEXT { - VkStructureType sType; - const void* pNext; - VkShaderStageFlags shaderStages; - VkIndirectExecutionSetEXT indirectExecutionSet; - VkIndirectCommandsLayoutEXT indirectCommandsLayout; - VkDeviceAddress indirectAddress; - VkDeviceSize indirectAddressSize; - VkDeviceAddress preprocessAddress; - VkDeviceSize preprocessSize; - uint32_t maxSequenceCount; - VkDeviceAddress sequenceCountAddress; - uint32_t maxDrawCount; -} VkGeneratedCommandsInfoEXT; - -typedef struct VkWriteIndirectExecutionSetPipelineEXT { - VkStructureType sType; - const void* pNext; - uint32_t index; - VkPipeline pipeline; -} VkWriteIndirectExecutionSetPipelineEXT; - -typedef struct VkIndirectCommandsPushConstantTokenEXT { - VkPushConstantRange updateRange; -} VkIndirectCommandsPushConstantTokenEXT; - -typedef struct VkIndirectCommandsVertexBufferTokenEXT { - uint32_t vertexBindingUnit; -} VkIndirectCommandsVertexBufferTokenEXT; - -typedef struct VkIndirectCommandsIndexBufferTokenEXT { - VkIndirectCommandsInputModeFlagBitsEXT mode; -} VkIndirectCommandsIndexBufferTokenEXT; - -typedef struct VkIndirectCommandsExecutionSetTokenEXT { - VkIndirectExecutionSetInfoTypeEXT type; - VkShaderStageFlags shaderStages; -} VkIndirectCommandsExecutionSetTokenEXT; - -typedef union VkIndirectCommandsTokenDataEXT { - const VkIndirectCommandsPushConstantTokenEXT* pPushConstant; - const VkIndirectCommandsVertexBufferTokenEXT* pVertexBuffer; - const VkIndirectCommandsIndexBufferTokenEXT* pIndexBuffer; - const VkIndirectCommandsExecutionSetTokenEXT* pExecutionSet; -} VkIndirectCommandsTokenDataEXT; - -typedef struct VkIndirectCommandsLayoutTokenEXT { - VkStructureType sType; - const void* pNext; - VkIndirectCommandsTokenTypeEXT type; - VkIndirectCommandsTokenDataEXT data; - uint32_t offset; -} VkIndirectCommandsLayoutTokenEXT; - -typedef struct VkIndirectCommandsLayoutCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkIndirectCommandsLayoutUsageFlagsEXT flags; - VkShaderStageFlags shaderStages; - uint32_t indirectStride; - VkPipelineLayout pipelineLayout; - uint32_t tokenCount; - const VkIndirectCommandsLayoutTokenEXT* pTokens; -} VkIndirectCommandsLayoutCreateInfoEXT; - -typedef struct VkDrawIndirectCountIndirectCommandEXT { - VkDeviceAddress bufferAddress; - uint32_t stride; - uint32_t commandCount; -} VkDrawIndirectCountIndirectCommandEXT; - -typedef struct VkBindVertexBufferIndirectCommandEXT { - VkDeviceAddress bufferAddress; - uint32_t size; - uint32_t stride; -} VkBindVertexBufferIndirectCommandEXT; - -typedef struct VkBindIndexBufferIndirectCommandEXT { - VkDeviceAddress bufferAddress; - uint32_t size; - VkIndexType indexType; -} VkBindIndexBufferIndirectCommandEXT; - -typedef struct VkGeneratedCommandsPipelineInfoEXT { - VkStructureType sType; - void* pNext; - VkPipeline pipeline; -} VkGeneratedCommandsPipelineInfoEXT; - -typedef struct VkGeneratedCommandsShaderInfoEXT { - VkStructureType sType; - void* pNext; - uint32_t shaderCount; - const VkShaderEXT* pShaders; -} VkGeneratedCommandsShaderInfoEXT; - -typedef struct VkWriteIndirectExecutionSetShaderEXT { - VkStructureType sType; - const void* pNext; - uint32_t index; - VkShaderEXT shader; -} VkWriteIndirectExecutionSetShaderEXT; - -typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsEXT)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsEXT)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer); -typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsEXT)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutEXT)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout); -typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutEXT)(VkDevice device, VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectExecutionSetEXT)(VkDevice device, const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet); -typedef void (VKAPI_PTR *PFN_vkDestroyIndirectExecutionSetEXT)(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetPipelineEXT)(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites); -typedef void (VKAPI_PTR *PFN_vkUpdateIndirectExecutionSetShaderEXT)(VkDevice device, VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsEXT( - VkDevice device, - const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, - VkMemoryRequirements2* pMemoryRequirements); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsEXT( - VkCommandBuffer commandBuffer, - const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, - VkCommandBuffer stateCommandBuffer); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsEXT( - VkCommandBuffer commandBuffer, - VkBool32 isPreprocessed, - const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutEXT( - VkDevice device, - const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutEXT( - VkDevice device, - VkIndirectCommandsLayoutEXT indirectCommandsLayout, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectExecutionSetEXT( - VkDevice device, - const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectExecutionSetEXT* pIndirectExecutionSet); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectExecutionSetEXT( - VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetPipelineEXT( - VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, - const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkUpdateIndirectExecutionSetShaderEXT( - VkDevice device, - VkIndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, - const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites); -#endif -#endif - - -// VK_MESA_image_alignment_control is a preprocessor guard. Do not pass it to API calls. -#define VK_MESA_image_alignment_control 1 -#define VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION 1 -#define VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME "VK_MESA_image_alignment_control" -typedef struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA { - VkStructureType sType; - void* pNext; - VkBool32 imageAlignmentControl; -} VkPhysicalDeviceImageAlignmentControlFeaturesMESA; - -typedef struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA { - VkStructureType sType; - void* pNext; - uint32_t supportedImageAlignmentMask; -} VkPhysicalDeviceImageAlignmentControlPropertiesMESA; - -typedef struct VkImageAlignmentControlCreateInfoMESA { - VkStructureType sType; - const void* pNext; - uint32_t maximumRequestedAlignment; -} VkImageAlignmentControlCreateInfoMESA; - - - -// VK_NV_push_constant_bank is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_push_constant_bank 1 -#define VK_NV_PUSH_CONSTANT_BANK_SPEC_VERSION 1 -#define VK_NV_PUSH_CONSTANT_BANK_EXTENSION_NAME "VK_NV_push_constant_bank" -typedef struct VkPushConstantBankInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t bank; -} VkPushConstantBankInfoNV; - -typedef struct VkPhysicalDevicePushConstantBankFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 pushConstantBank; -} VkPhysicalDevicePushConstantBankFeaturesNV; - -typedef struct VkPhysicalDevicePushConstantBankPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t maxGraphicsPushConstantBanks; - uint32_t maxComputePushConstantBanks; - uint32_t maxGraphicsPushDataBanks; - uint32_t maxComputePushDataBanks; -} VkPhysicalDevicePushConstantBankPropertiesNV; - - - -// VK_EXT_ray_tracing_invocation_reorder is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_ray_tracing_invocation_reorder 1 -#define VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION 1 -#define VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME "VK_EXT_ray_tracing_invocation_reorder" -typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT { - VkStructureType sType; - void* pNext; - VkRayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint; - uint32_t maxShaderBindingTableRecordIndex; -} VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT; - -typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingInvocationReorder; -} VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT; - - - -// VK_EXT_depth_clamp_control is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_depth_clamp_control 1 -#define VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION 1 -#define VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clamp_control" -typedef struct VkPhysicalDeviceDepthClampControlFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 depthClampControl; -} VkPhysicalDeviceDepthClampControlFeaturesEXT; - -typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDepthClampModeEXT depthClampMode; - const VkDepthClampRangeEXT* pDepthClampRange; -} VkPipelineViewportDepthClampControlCreateInfoEXT; - - - -// VK_HUAWEI_hdr_vivid is a preprocessor guard. Do not pass it to API calls. -#define VK_HUAWEI_hdr_vivid 1 -#define VK_HUAWEI_HDR_VIVID_SPEC_VERSION 1 -#define VK_HUAWEI_HDR_VIVID_EXTENSION_NAME "VK_HUAWEI_hdr_vivid" -typedef struct VkPhysicalDeviceHdrVividFeaturesHUAWEI { - VkStructureType sType; - void* pNext; - VkBool32 hdrVivid; -} VkPhysicalDeviceHdrVividFeaturesHUAWEI; - -typedef struct VkHdrVividDynamicMetadataHUAWEI { - VkStructureType sType; - const void* pNext; - size_t dynamicMetadataSize; - const void* pDynamicMetadata; -} VkHdrVividDynamicMetadataHUAWEI; - - - -// VK_NV_cooperative_matrix2 is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_cooperative_matrix2 1 -#define VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION 1 -#define VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME "VK_NV_cooperative_matrix2" -typedef struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t MGranularity; - uint32_t NGranularity; - uint32_t KGranularity; - VkComponentTypeKHR AType; - VkComponentTypeKHR BType; - VkComponentTypeKHR CType; - VkComponentTypeKHR ResultType; - VkBool32 saturatingAccumulation; - VkScopeKHR scope; - uint32_t workgroupInvocations; -} VkCooperativeMatrixFlexibleDimensionsPropertiesNV; - -typedef struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 cooperativeMatrixWorkgroupScope; - VkBool32 cooperativeMatrixFlexibleDimensions; - VkBool32 cooperativeMatrixReductions; - VkBool32 cooperativeMatrixConversions; - VkBool32 cooperativeMatrixPerElementOperations; - VkBool32 cooperativeMatrixTensorAddressing; - VkBool32 cooperativeMatrixBlockLoads; -} VkPhysicalDeviceCooperativeMatrix2FeaturesNV; - -typedef struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize; - uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension; - uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory; -} VkPhysicalDeviceCooperativeMatrix2PropertiesNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeMatrixFlexibleDimensionsPropertiesNV* pProperties); -#endif -#endif - - -// VK_ARM_pipeline_opacity_micromap is a preprocessor guard. Do not pass it to API calls. -#define VK_ARM_pipeline_opacity_micromap 1 -#define VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION 1 -#define VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME "VK_ARM_pipeline_opacity_micromap" -typedef struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM { - VkStructureType sType; - void* pNext; - VkBool32 pipelineOpacityMicromap; -} VkPhysicalDevicePipelineOpacityMicromapFeaturesARM; - - - -// VK_ARM_performance_counters_by_region is a preprocessor guard. Do not pass it to API calls. -#define VK_ARM_performance_counters_by_region 1 -#define VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION 1 -#define VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_EXTENSION_NAME "VK_ARM_performance_counters_by_region" -typedef VkFlags VkPerformanceCounterDescriptionFlagsARM; -typedef struct VkPhysicalDevicePerformanceCountersByRegionFeaturesARM { - VkStructureType sType; - void* pNext; - VkBool32 performanceCountersByRegion; -} VkPhysicalDevicePerformanceCountersByRegionFeaturesARM; - -typedef struct VkPhysicalDevicePerformanceCountersByRegionPropertiesARM { - VkStructureType sType; - void* pNext; - uint32_t maxPerRegionPerformanceCounters; - VkExtent2D performanceCounterRegionSize; - uint32_t rowStrideAlignment; - uint32_t regionAlignment; - VkBool32 identityTransformOrder; -} VkPhysicalDevicePerformanceCountersByRegionPropertiesARM; - -typedef struct VkPerformanceCounterARM { - VkStructureType sType; - void* pNext; - uint32_t counterID; -} VkPerformanceCounterARM; - -typedef struct VkPerformanceCounterDescriptionARM { - VkStructureType sType; - void* pNext; - VkPerformanceCounterDescriptionFlagsARM flags; - char name[VK_MAX_DESCRIPTION_SIZE]; -} VkPerformanceCounterDescriptionARM; - -typedef struct VkRenderPassPerformanceCountersByRegionBeginInfoARM { - VkStructureType sType; - void* pNext; - uint32_t counterAddressCount; - const VkDeviceAddress* pCounterAddresses; - VkBool32 serializeRegions; - uint32_t counterIndexCount; - uint32_t* pCounterIndices; -} VkRenderPassPerformanceCountersByRegionBeginInfoARM; - -typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterARM* pCounters, VkPerformanceCounterDescriptionARM* pCounterDescriptions); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - uint32_t* pCounterCount, - VkPerformanceCounterARM* pCounters, - VkPerformanceCounterDescriptionARM* pCounterDescriptions); -#endif -#endif - - -// VK_EXT_vertex_attribute_robustness is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_vertex_attribute_robustness 1 -#define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION 1 -#define VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_vertex_attribute_robustness" -typedef struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 vertexAttributeRobustness; -} VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT; - - - -// VK_ARM_format_pack is a preprocessor guard. Do not pass it to API calls. -#define VK_ARM_format_pack 1 -#define VK_ARM_FORMAT_PACK_SPEC_VERSION 1 -#define VK_ARM_FORMAT_PACK_EXTENSION_NAME "VK_ARM_format_pack" -typedef struct VkPhysicalDeviceFormatPackFeaturesARM { - VkStructureType sType; - void* pNext; - VkBool32 formatPack; -} VkPhysicalDeviceFormatPackFeaturesARM; - - - -// VK_VALVE_fragment_density_map_layered is a preprocessor guard. Do not pass it to API calls. -#define VK_VALVE_fragment_density_map_layered 1 -#define VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION 1 -#define VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME "VK_VALVE_fragment_density_map_layered" -typedef struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE { - VkStructureType sType; - void* pNext; - VkBool32 fragmentDensityMapLayered; -} VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; - -typedef struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE { - VkStructureType sType; - void* pNext; - uint32_t maxFragmentDensityMapLayers; -} VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; - -typedef struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE { - VkStructureType sType; - const void* pNext; - uint32_t maxFragmentDensityMapLayers; -} VkPipelineFragmentDensityMapLayeredCreateInfoVALVE; - - - -// VK_NV_present_metering is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_present_metering 1 -#define VK_NV_PRESENT_METERING_SPEC_VERSION 1 -#define VK_NV_PRESENT_METERING_EXTENSION_NAME "VK_NV_present_metering" -typedef struct VkSetPresentConfigNV { - VkStructureType sType; - const void* pNext; - uint32_t numFramesPerBatch; - uint32_t presentConfigFeedback; -} VkSetPresentConfigNV; - -typedef struct VkPhysicalDevicePresentMeteringFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 presentMetering; -} VkPhysicalDevicePresentMeteringFeaturesNV; - - - -// VK_EXT_fragment_density_map_offset is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_fragment_density_map_offset 1 -#define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1 -#define VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_EXT_fragment_density_map_offset" -typedef VkRenderingEndInfoKHR VkRenderingEndInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdEndRendering2EXT)(VkCommandBuffer commandBuffer, const VkRenderingEndInfoKHR* pRenderingEndInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering2EXT( - VkCommandBuffer commandBuffer, - const VkRenderingEndInfoKHR* pRenderingEndInfo); -#endif -#endif - - -// VK_EXT_zero_initialize_device_memory is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_zero_initialize_device_memory 1 -#define VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION 1 -#define VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME "VK_EXT_zero_initialize_device_memory" -typedef struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 zeroInitializeDeviceMemory; -} VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; - - - -// VK_EXT_shader_64bit_indexing is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_64bit_indexing 1 -#define VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION 1 -#define VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME "VK_EXT_shader_64bit_indexing" -typedef struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shader64BitIndexing; -} VkPhysicalDeviceShader64BitIndexingFeaturesEXT; - - - -// VK_EXT_custom_resolve is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_custom_resolve 1 -#define VK_EXT_CUSTOM_RESOLVE_SPEC_VERSION 1 -#define VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME "VK_EXT_custom_resolve" -typedef struct VkPhysicalDeviceCustomResolveFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 customResolve; -} VkPhysicalDeviceCustomResolveFeaturesEXT; - -typedef struct VkBeginCustomResolveInfoEXT { - VkStructureType sType; - void* pNext; -} VkBeginCustomResolveInfoEXT; - -typedef struct VkCustomResolveCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 customResolve; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; -} VkCustomResolveCreateInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdBeginCustomResolveEXT)(VkCommandBuffer commandBuffer, const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBeginCustomResolveEXT( - VkCommandBuffer commandBuffer, - const VkBeginCustomResolveInfoEXT* pBeginCustomResolveInfo); -#endif -#endif - - -// VK_QCOM_data_graph_model is a preprocessor guard. Do not pass it to API calls. -#define VK_QCOM_data_graph_model 1 -#define VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM 3U -#define VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION 1 -#define VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME "VK_QCOM_data_graph_model" - -typedef enum VkDataGraphModelCacheTypeQCOM { - VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM = 0, - VK_DATA_GRAPH_MODEL_CACHE_TYPE_MAX_ENUM_QCOM = 0x7FFFFFFF -} VkDataGraphModelCacheTypeQCOM; -typedef struct VkPipelineCacheHeaderVersionDataGraphQCOM { - uint32_t headerSize; - VkPipelineCacheHeaderVersion headerVersion; - VkDataGraphModelCacheTypeQCOM cacheType; - uint32_t cacheVersion; - uint32_t toolchainVersion[VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM]; -} VkPipelineCacheHeaderVersionDataGraphQCOM; - -typedef struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM { - VkStructureType sType; - const void* pNext; - const VkPhysicalDeviceDataGraphOperationSupportARM* pOperation; -} VkDataGraphPipelineBuiltinModelCreateInfoQCOM; - -typedef struct VkPhysicalDeviceDataGraphModelFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 dataGraphModel; -} VkPhysicalDeviceDataGraphModelFeaturesQCOM; - - - -// VK_EXT_shader_long_vector is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_long_vector 1 -#define VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION 1 -#define VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME "VK_EXT_shader_long_vector" -typedef struct VkPhysicalDeviceShaderLongVectorFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 longVector; -} VkPhysicalDeviceShaderLongVectorFeaturesEXT; - -typedef struct VkPhysicalDeviceShaderLongVectorPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxVectorComponents; -} VkPhysicalDeviceShaderLongVectorPropertiesEXT; - - - -// VK_SEC_pipeline_cache_incremental_mode is a preprocessor guard. Do not pass it to API calls. -#define VK_SEC_pipeline_cache_incremental_mode 1 -#define VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION 1 -#define VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME "VK_SEC_pipeline_cache_incremental_mode" -typedef struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC { - VkStructureType sType; - void* pNext; - VkBool32 pipelineCacheIncrementalMode; -} VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; - - - -// VK_EXT_shader_uniform_buffer_unsized_array is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_uniform_buffer_unsized_array 1 -#define VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION 1 -#define VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME "VK_EXT_shader_uniform_buffer_unsized_array" -typedef struct VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderUniformBufferUnsizedArray; -} VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; - - - -// VK_NV_compute_occupancy_priority is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_compute_occupancy_priority 1 -#define VK_NV_COMPUTE_OCCUPANCY_PRIORITY_SPEC_VERSION 1 -#define VK_NV_COMPUTE_OCCUPANCY_PRIORITY_EXTENSION_NAME "VK_NV_compute_occupancy_priority" -#define VK_COMPUTE_OCCUPANCY_PRIORITY_LOW_NV 0.25f -#define VK_COMPUTE_OCCUPANCY_PRIORITY_NORMAL_NV 0.50f -#define VK_COMPUTE_OCCUPANCY_PRIORITY_HIGH_NV 0.75f -typedef struct VkComputeOccupancyPriorityParametersNV { - VkStructureType sType; - const void* pNext; - float occupancyPriority; - float occupancyThrottling; -} VkComputeOccupancyPriorityParametersNV; - -typedef struct VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 computeOccupancyPriority; -} VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV; - -typedef void (VKAPI_PTR *PFN_vkCmdSetComputeOccupancyPriorityNV)(VkCommandBuffer commandBuffer, const VkComputeOccupancyPriorityParametersNV* pParameters); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetComputeOccupancyPriorityNV( - VkCommandBuffer commandBuffer, - const VkComputeOccupancyPriorityParametersNV* pParameters); -#endif -#endif - - -// VK_EXT_shader_subgroup_partitioned is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_shader_subgroup_partitioned 1 -#define VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1 -#define VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_EXT_shader_subgroup_partitioned" -typedef struct VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderSubgroupPartitioned; -} VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; - - - -// VK_KHR_acceleration_structure is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_acceleration_structure 1 -#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13 -#define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure" - -typedef enum VkBuildAccelerationStructureModeKHR { - VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0, - VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1, - VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkBuildAccelerationStructureModeKHR; - -typedef enum VkAccelerationStructureCreateFlagBitsKHR { - VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, - VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, - VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, - VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureCreateFlagBitsKHR; -typedef VkFlags VkAccelerationStructureCreateFlagsKHR; -typedef struct VkAccelerationStructureBuildRangeInfoKHR { - uint32_t primitiveCount; - uint32_t primitiveOffset; - uint32_t firstVertex; - uint32_t transformOffset; -} VkAccelerationStructureBuildRangeInfoKHR; - -typedef struct VkAccelerationStructureGeometryTrianglesDataKHR { - VkStructureType sType; - const void* pNext; - VkFormat vertexFormat; - VkDeviceOrHostAddressConstKHR vertexData; - VkDeviceSize vertexStride; - uint32_t maxVertex; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR indexData; - VkDeviceOrHostAddressConstKHR transformData; -} VkAccelerationStructureGeometryTrianglesDataKHR; - -typedef struct VkAccelerationStructureGeometryAabbsDataKHR { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR data; - VkDeviceSize stride; -} VkAccelerationStructureGeometryAabbsDataKHR; - -typedef struct VkAccelerationStructureGeometryInstancesDataKHR { - VkStructureType sType; - const void* pNext; - VkBool32 arrayOfPointers; - VkDeviceOrHostAddressConstKHR data; -} VkAccelerationStructureGeometryInstancesDataKHR; - -typedef union VkAccelerationStructureGeometryDataKHR { - VkAccelerationStructureGeometryTrianglesDataKHR triangles; - VkAccelerationStructureGeometryAabbsDataKHR aabbs; - VkAccelerationStructureGeometryInstancesDataKHR instances; -} VkAccelerationStructureGeometryDataKHR; - -typedef struct VkAccelerationStructureGeometryKHR { - VkStructureType sType; - const void* pNext; - VkGeometryTypeKHR geometryType; - VkAccelerationStructureGeometryDataKHR geometry; - VkGeometryFlagsKHR flags; -} VkAccelerationStructureGeometryKHR; - -typedef struct VkAccelerationStructureBuildGeometryInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureTypeKHR type; - VkBuildAccelerationStructureFlagsKHR flags; - VkBuildAccelerationStructureModeKHR mode; - VkAccelerationStructureKHR srcAccelerationStructure; - VkAccelerationStructureKHR dstAccelerationStructure; - uint32_t geometryCount; - const VkAccelerationStructureGeometryKHR* pGeometries; - const VkAccelerationStructureGeometryKHR* const* ppGeometries; - VkDeviceOrHostAddressKHR scratchData; -} VkAccelerationStructureBuildGeometryInfoKHR; - -typedef struct VkAccelerationStructureCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureCreateFlagsKHR createFlags; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; - VkAccelerationStructureTypeKHR type; - VkDeviceAddress deviceAddress; -} VkAccelerationStructureCreateInfoKHR; - -typedef struct VkWriteDescriptorSetAccelerationStructureKHR { - VkStructureType sType; - const void* pNext; - uint32_t accelerationStructureCount; - const VkAccelerationStructureKHR* pAccelerationStructures; -} VkWriteDescriptorSetAccelerationStructureKHR; - -typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 accelerationStructure; - VkBool32 accelerationStructureCaptureReplay; - VkBool32 accelerationStructureIndirectBuild; - VkBool32 accelerationStructureHostCommands; - VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind; -} VkPhysicalDeviceAccelerationStructureFeaturesKHR; - -typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR { - VkStructureType sType; - void* pNext; - uint64_t maxGeometryCount; - uint64_t maxInstanceCount; - uint64_t maxPrimitiveCount; - uint32_t maxPerStageDescriptorAccelerationStructures; - uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures; - uint32_t maxDescriptorSetAccelerationStructures; - uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures; - uint32_t minAccelerationStructureScratchOffsetAlignment; -} VkPhysicalDeviceAccelerationStructurePropertiesKHR; - -typedef struct VkAccelerationStructureDeviceAddressInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureKHR accelerationStructure; -} VkAccelerationStructureDeviceAddressInfoKHR; - -typedef struct VkAccelerationStructureVersionInfoKHR { - VkStructureType sType; - const void* pNext; - const uint8_t* pVersionData; -} VkAccelerationStructureVersionInfoKHR; - -typedef struct VkCopyAccelerationStructureToMemoryInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureKHR src; - VkDeviceOrHostAddressKHR dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyAccelerationStructureToMemoryInfoKHR; - -typedef struct VkCopyMemoryToAccelerationStructureInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR src; - VkAccelerationStructureKHR dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyMemoryToAccelerationStructureInfoKHR; - -typedef struct VkCopyAccelerationStructureInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureKHR src; - VkAccelerationStructureKHR dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyAccelerationStructureInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); -typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator); -typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); -typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts); -typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); -typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); -typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); -typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); -typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -typedef void (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); -typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR( - VkDevice device, - const VkAccelerationStructureCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureKHR* pAccelerationStructure); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR( - VkDevice device, - VkAccelerationStructureKHR accelerationStructure, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkDeviceAddress* pIndirectDeviceAddresses, - const uint32_t* pIndirectStrides, - const uint32_t* const* ppMaxPrimitiveCounts); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureInfoKHR* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR( - VkDevice device, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR* pAccelerationStructures, - VkQueryType queryType, - size_t dataSize, - void* pData, - size_t stride); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR( - VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureInfoKHR* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR( - VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR( - VkCommandBuffer commandBuffer, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR( - VkDevice device, - const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR( - VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR( - VkDevice device, - const VkAccelerationStructureVersionInfoKHR* pVersionInfo, - VkAccelerationStructureCompatibilityKHR* pCompatibility); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR( - VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, - const uint32_t* pMaxPrimitiveCounts, - VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); -#endif -#endif - - -// VK_KHR_ray_tracing_pipeline is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_ray_tracing_pipeline 1 -#define VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION 1 -#define VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME "VK_KHR_ray_tracing_pipeline" - -typedef enum VkShaderGroupShaderKHR { - VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0, - VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1, - VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2, - VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3, - VK_SHADER_GROUP_SHADER_MAX_ENUM_KHR = 0x7FFFFFFF -} VkShaderGroupShaderKHR; -typedef struct VkRayTracingShaderGroupCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkRayTracingShaderGroupTypeKHR type; - uint32_t generalShader; - uint32_t closestHitShader; - uint32_t anyHitShader; - uint32_t intersectionShader; - const void* pShaderGroupCaptureReplayHandle; -} VkRayTracingShaderGroupCreateInfoKHR; - -typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t maxPipelineRayPayloadSize; - uint32_t maxPipelineRayHitAttributeSize; -} VkRayTracingPipelineInterfaceCreateInfoKHR; - -typedef struct VkRayTracingPipelineCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - uint32_t groupCount; - const VkRayTracingShaderGroupCreateInfoKHR* pGroups; - uint32_t maxPipelineRayRecursionDepth; - const VkPipelineLibraryCreateInfoKHR* pLibraryInfo; - const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface; - const VkPipelineDynamicStateCreateInfo* pDynamicState; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkRayTracingPipelineCreateInfoKHR; - -typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingPipeline; - VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay; - VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed; - VkBool32 rayTracingPipelineTraceRaysIndirect; - VkBool32 rayTraversalPrimitiveCulling; -} VkPhysicalDeviceRayTracingPipelineFeaturesKHR; - -typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t shaderGroupHandleSize; - uint32_t maxRayRecursionDepth; - uint32_t maxShaderGroupStride; - uint32_t shaderGroupBaseAlignment; - uint32_t shaderGroupHandleCaptureReplaySize; - uint32_t maxRayDispatchInvocationCount; - uint32_t shaderGroupHandleAlignment; - uint32_t maxRayHitAttributeSize; -} VkPhysicalDeviceRayTracingPipelinePropertiesKHR; - -typedef struct VkTraceRaysIndirectCommandKHR { - uint32_t width; - uint32_t height; - uint32_t depth; -} VkTraceRaysIndirectCommandKHR; - -typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth); -typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); -typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress); -typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader); -typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR( - VkCommandBuffer commandBuffer, - const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, - uint32_t width, - uint32_t height, - uint32_t depth); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR( - VkCommandBuffer commandBuffer, - const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, - VkDeviceAddress indirectDeviceAddress); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t group, - VkShaderGroupShaderKHR groupShader); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR( - VkCommandBuffer commandBuffer, - uint32_t pipelineStackSize); -#endif -#endif - - -// VK_KHR_ray_query is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_ray_query 1 -#define VK_KHR_RAY_QUERY_SPEC_VERSION 1 -#define VK_KHR_RAY_QUERY_EXTENSION_NAME "VK_KHR_ray_query" -typedef struct VkPhysicalDeviceRayQueryFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 rayQuery; -} VkPhysicalDeviceRayQueryFeaturesKHR; - - - -// VK_EXT_mesh_shader is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_mesh_shader 1 -#define VK_EXT_MESH_SHADER_SPEC_VERSION 1 -#define VK_EXT_MESH_SHADER_EXTENSION_NAME "VK_EXT_mesh_shader" -typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 taskShader; - VkBool32 meshShader; - VkBool32 multiviewMeshShader; - VkBool32 primitiveFragmentShadingRateMeshShader; - VkBool32 meshShaderQueries; -} VkPhysicalDeviceMeshShaderFeaturesEXT; - -typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxTaskWorkGroupTotalCount; - uint32_t maxTaskWorkGroupCount[3]; - uint32_t maxTaskWorkGroupInvocations; - uint32_t maxTaskWorkGroupSize[3]; - uint32_t maxTaskPayloadSize; - uint32_t maxTaskSharedMemorySize; - uint32_t maxTaskPayloadAndSharedMemorySize; - uint32_t maxMeshWorkGroupTotalCount; - uint32_t maxMeshWorkGroupCount[3]; - uint32_t maxMeshWorkGroupInvocations; - uint32_t maxMeshWorkGroupSize[3]; - uint32_t maxMeshSharedMemorySize; - uint32_t maxMeshPayloadAndSharedMemorySize; - uint32_t maxMeshOutputMemorySize; - uint32_t maxMeshPayloadAndOutputMemorySize; - uint32_t maxMeshOutputComponents; - uint32_t maxMeshOutputVertices; - uint32_t maxMeshOutputPrimitives; - uint32_t maxMeshOutputLayers; - uint32_t maxMeshMultiviewViewCount; - uint32_t meshOutputPerVertexGranularity; - uint32_t meshOutputPerPrimitiveGranularity; - uint32_t maxPreferredTaskWorkGroupInvocations; - uint32_t maxPreferredMeshWorkGroupInvocations; - VkBool32 prefersLocalInvocationVertexOutput; - VkBool32 prefersLocalInvocationPrimitiveOutput; - VkBool32 prefersCompactVertexOutput; - VkBool32 prefersCompactPrimitiveOutput; -} VkPhysicalDeviceMeshShaderPropertiesEXT; - -typedef struct VkDrawMeshTasksIndirectCommandEXT { - uint32_t groupCountX; - uint32_t groupCountY; - uint32_t groupCountZ; -} VkDrawMeshTasksIndirectCommandEXT; - -typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksEXT)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksEXT( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectEXT( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountEXT( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_directfb.h b/lib/vulkan-headers/include/vulkan/vulkan_directfb.h deleted file mode 100644 index b96e957e14b..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_directfb.h +++ /dev/null @@ -1,59 +0,0 @@ -#ifndef VULKAN_DIRECTFB_H_ -#define VULKAN_DIRECTFB_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_EXT_directfb_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_directfb_surface 1 -#define VK_EXT_DIRECTFB_SURFACE_SPEC_VERSION 1 -#define VK_EXT_DIRECTFB_SURFACE_EXTENSION_NAME "VK_EXT_directfb_surface" -typedef VkFlags VkDirectFBSurfaceCreateFlagsEXT; -typedef struct VkDirectFBSurfaceCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDirectFBSurfaceCreateFlagsEXT flags; - IDirectFB* dfb; - IDirectFBSurface* surface; -} VkDirectFBSurfaceCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateDirectFBSurfaceEXT)(VkInstance instance, const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateDirectFBSurfaceEXT( - VkInstance instance, - const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceDirectFBPresentationSupportEXT( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - IDirectFB* dfb); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_enums.hpp b/lib/vulkan-headers/include/vulkan/vulkan_enums.hpp deleted file mode 100644 index 6cb46de1fce..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_enums.hpp +++ /dev/null @@ -1,9806 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_ENUMS_HPP -#define VULKAN_ENUMS_HPP - -// include-what-you-use: make sure, vulkan.hpp is used by code-completers -// IWYU pragma: private, include "vulkan/vulkan.hpp" - -#if !defined( VULKAN_HPP_CXX_MODULE ) -# include // for std::underlying_type -#endif - -namespace VULKAN_HPP_NAMESPACE -{ - template - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = false; - }; - - template - class Flags - { - public: - using BitsType = BitType; - using MaskType = typename std::underlying_type::type; - - // constructors - VULKAN_HPP_CONSTEXPR Flags() VULKAN_HPP_NOEXCEPT : m_mask( 0 ) {} - - VULKAN_HPP_CONSTEXPR Flags( BitType bit ) VULKAN_HPP_NOEXCEPT : m_mask( static_cast( bit ) ) {} - - VULKAN_HPP_CONSTEXPR Flags( Flags const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VULKAN_HPP_CONSTEXPR explicit Flags( MaskType flags ) VULKAN_HPP_NOEXCEPT : m_mask( flags ) {} - - // relational operators -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( Flags const & ) const = default; -#else - VULKAN_HPP_CONSTEXPR bool operator<( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return m_mask < rhs.m_mask; - } - - VULKAN_HPP_CONSTEXPR bool operator<=( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return m_mask <= rhs.m_mask; - } - - VULKAN_HPP_CONSTEXPR bool operator>( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return m_mask > rhs.m_mask; - } - - VULKAN_HPP_CONSTEXPR bool operator>=( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return m_mask >= rhs.m_mask; - } - - VULKAN_HPP_CONSTEXPR bool operator==( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return m_mask == rhs.m_mask; - } - - VULKAN_HPP_CONSTEXPR bool operator!=( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return m_mask != rhs.m_mask; - } -#endif - - // logical operator - VULKAN_HPP_CONSTEXPR bool operator!() const VULKAN_HPP_NOEXCEPT - { - return !m_mask; - } - - // bitwise operators - VULKAN_HPP_CONSTEXPR Flags operator&( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return Flags( m_mask & rhs.m_mask ); - } - - VULKAN_HPP_CONSTEXPR Flags operator|( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return Flags( m_mask | rhs.m_mask ); - } - - VULKAN_HPP_CONSTEXPR Flags operator^( Flags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return Flags( m_mask ^ rhs.m_mask ); - } - - VULKAN_HPP_CONSTEXPR Flags operator~() const VULKAN_HPP_NOEXCEPT - { - return Flags( m_mask ^ FlagTraits::allFlags.m_mask ); - } - - // assignment operators - VULKAN_HPP_CONSTEXPR_14 Flags & operator=( Flags const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VULKAN_HPP_CONSTEXPR_14 Flags & operator|=( Flags const & rhs ) VULKAN_HPP_NOEXCEPT - { - m_mask |= rhs.m_mask; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Flags & operator&=( Flags const & rhs ) VULKAN_HPP_NOEXCEPT - { - m_mask &= rhs.m_mask; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Flags & operator^=( Flags const & rhs ) VULKAN_HPP_NOEXCEPT - { - m_mask ^= rhs.m_mask; - return *this; - } - - // cast operators - explicit VULKAN_HPP_CONSTEXPR operator bool() const VULKAN_HPP_NOEXCEPT - { - return !!m_mask; - } - - explicit VULKAN_HPP_CONSTEXPR operator MaskType() const VULKAN_HPP_NOEXCEPT - { - return m_mask; - } - -#if defined( VULKAN_HPP_FLAGS_MASK_TYPE_AS_PUBLIC ) - public: -#else - private: -#endif - MaskType m_mask; - }; - -#if !defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - // relational operators only needed for pre C++20 - template - VULKAN_HPP_CONSTEXPR bool operator<( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT - { - return flags.operator>( bit ); - } - - template - VULKAN_HPP_CONSTEXPR bool operator<=( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT - { - return flags.operator>=( bit ); - } - - template - VULKAN_HPP_CONSTEXPR bool operator>( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT - { - return flags.operator<( bit ); - } - - template - VULKAN_HPP_CONSTEXPR bool operator>=( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT - { - return flags.operator<=( bit ); - } - - template - VULKAN_HPP_CONSTEXPR bool operator==( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT - { - return flags.operator==( bit ); - } - - template - VULKAN_HPP_CONSTEXPR bool operator!=( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT - { - return flags.operator!=( bit ); - } -#endif - - // bitwise operators - template - VULKAN_HPP_CONSTEXPR Flags operator&( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT - { - return flags.operator&( bit ); - } - - template - VULKAN_HPP_CONSTEXPR Flags operator|( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT - { - return flags.operator|( bit ); - } - - template - VULKAN_HPP_CONSTEXPR Flags operator^( BitType bit, Flags const & flags ) VULKAN_HPP_NOEXCEPT - { - return flags.operator^( bit ); - } - - // bitwise operators on BitType - template ::isBitmask, bool>::type = true> - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags operator&( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT - { - return Flags( lhs ) & rhs; - } - - template ::isBitmask, bool>::type = true> - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags operator|( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT - { - return Flags( lhs ) | rhs; - } - - template ::isBitmask, bool>::type = true> - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags operator^( BitType lhs, BitType rhs ) VULKAN_HPP_NOEXCEPT - { - return Flags( lhs ) ^ rhs; - } - - template ::isBitmask, bool>::type = true> - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR Flags operator~( BitType bit ) VULKAN_HPP_NOEXCEPT - { - return ~( Flags( bit ) ); - } - - //============= - //=== ENUMs === - //============= - - //=== VK_VERSION_1_0 === - - // wrapper class for enum VkResult, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResult.html - enum class Result - { - eSuccess = VK_SUCCESS, - eNotReady = VK_NOT_READY, - eTimeout = VK_TIMEOUT, - eEventSet = VK_EVENT_SET, - eEventReset = VK_EVENT_RESET, - eIncomplete = VK_INCOMPLETE, - eErrorOutOfHostMemory = VK_ERROR_OUT_OF_HOST_MEMORY, - eErrorOutOfDeviceMemory = VK_ERROR_OUT_OF_DEVICE_MEMORY, - eErrorInitializationFailed = VK_ERROR_INITIALIZATION_FAILED, - eErrorDeviceLost = VK_ERROR_DEVICE_LOST, - eErrorMemoryMapFailed = VK_ERROR_MEMORY_MAP_FAILED, - eErrorLayerNotPresent = VK_ERROR_LAYER_NOT_PRESENT, - eErrorExtensionNotPresent = VK_ERROR_EXTENSION_NOT_PRESENT, - eErrorFeatureNotPresent = VK_ERROR_FEATURE_NOT_PRESENT, - eErrorIncompatibleDriver = VK_ERROR_INCOMPATIBLE_DRIVER, - eErrorTooManyObjects = VK_ERROR_TOO_MANY_OBJECTS, - eErrorFormatNotSupported = VK_ERROR_FORMAT_NOT_SUPPORTED, - eErrorFragmentedPool = VK_ERROR_FRAGMENTED_POOL, - eErrorUnknown = VK_ERROR_UNKNOWN, - eErrorValidationFailed = VK_ERROR_VALIDATION_FAILED, - eErrorValidationFailedEXT = VK_ERROR_VALIDATION_FAILED_EXT, - eErrorOutOfPoolMemory = VK_ERROR_OUT_OF_POOL_MEMORY, - eErrorOutOfPoolMemoryKHR = VK_ERROR_OUT_OF_POOL_MEMORY_KHR, - eErrorInvalidExternalHandle = VK_ERROR_INVALID_EXTERNAL_HANDLE, - eErrorInvalidExternalHandleKHR = VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, - eErrorInvalidOpaqueCaptureAddress = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, - eErrorInvalidDeviceAddressEXT = VK_ERROR_INVALID_DEVICE_ADDRESS_EXT, - eErrorInvalidOpaqueCaptureAddressKHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR, - eErrorFragmentation = VK_ERROR_FRAGMENTATION, - eErrorFragmentationEXT = VK_ERROR_FRAGMENTATION_EXT, - ePipelineCompileRequired = VK_PIPELINE_COMPILE_REQUIRED, - ePipelineCompileRequiredEXT = VK_PIPELINE_COMPILE_REQUIRED_EXT, - eErrorPipelineCompileRequiredEXT = VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT, - eErrorNotPermitted = VK_ERROR_NOT_PERMITTED, - eErrorNotPermittedEXT = VK_ERROR_NOT_PERMITTED_EXT, - eErrorNotPermittedKHR = VK_ERROR_NOT_PERMITTED_KHR, - eErrorSurfaceLostKHR = VK_ERROR_SURFACE_LOST_KHR, - eErrorNativeWindowInUseKHR = VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, - eSuboptimalKHR = VK_SUBOPTIMAL_KHR, - eErrorOutOfDateKHR = VK_ERROR_OUT_OF_DATE_KHR, - eErrorIncompatibleDisplayKHR = VK_ERROR_INCOMPATIBLE_DISPLAY_KHR, - eErrorInvalidShaderNV = VK_ERROR_INVALID_SHADER_NV, - eErrorImageUsageNotSupportedKHR = VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR, - eErrorVideoPictureLayoutNotSupportedKHR = VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR, - eErrorVideoProfileOperationNotSupportedKHR = VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR, - eErrorVideoProfileFormatNotSupportedKHR = VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR, - eErrorVideoProfileCodecNotSupportedKHR = VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR, - eErrorVideoStdVersionNotSupportedKHR = VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR, - eErrorInvalidDrmFormatModifierPlaneLayoutEXT = VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT, - eErrorPresentTimingQueueFullEXT = VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT, -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - eErrorFullScreenExclusiveModeLostEXT = VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT, -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - eThreadIdleKHR = VK_THREAD_IDLE_KHR, - eThreadDoneKHR = VK_THREAD_DONE_KHR, - eOperationDeferredKHR = VK_OPERATION_DEFERRED_KHR, - eOperationNotDeferredKHR = VK_OPERATION_NOT_DEFERRED_KHR, - eErrorInvalidVideoStdParametersKHR = VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR, - eErrorCompressionExhaustedEXT = VK_ERROR_COMPRESSION_EXHAUSTED_EXT, - eIncompatibleShaderBinaryEXT = VK_INCOMPATIBLE_SHADER_BINARY_EXT, - eErrorIncompatibleShaderBinaryEXT = VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT, - ePipelineBinaryMissingKHR = VK_PIPELINE_BINARY_MISSING_KHR, - eErrorNotEnoughSpaceKHR = VK_ERROR_NOT_ENOUGH_SPACE_KHR - }; - - // wrapper class for enum VkStructureType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStructureType.html - enum class StructureType - { - eApplicationInfo = VK_STRUCTURE_TYPE_APPLICATION_INFO, - eInstanceCreateInfo = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, - eDeviceQueueCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, - eDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, - eSubmitInfo = VK_STRUCTURE_TYPE_SUBMIT_INFO, - eMemoryAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, - eMappedMemoryRange = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, - eBindSparseInfo = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, - eFenceCreateInfo = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, - eSemaphoreCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, - eEventCreateInfo = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, - eQueryPoolCreateInfo = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, - eBufferCreateInfo = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, - eBufferViewCreateInfo = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, - eImageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, - eImageViewCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, - eShaderModuleCreateInfo = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, - ePipelineCacheCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, - ePipelineShaderStageCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - ePipelineVertexInputStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - ePipelineInputAssemblyStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, - ePipelineTessellationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, - ePipelineViewportStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, - ePipelineRasterizationStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, - ePipelineMultisampleStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, - ePipelineDepthStencilStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, - ePipelineColorBlendStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, - ePipelineDynamicStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, - eGraphicsPipelineCreateInfo = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, - eComputePipelineCreateInfo = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO, - ePipelineLayoutCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, - eSamplerCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, - eDescriptorSetLayoutCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, - eDescriptorPoolCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, - eDescriptorSetAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, - eWriteDescriptorSet = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - eCopyDescriptorSet = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, - eFramebufferCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, - eRenderPassCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, - eCommandPoolCreateInfo = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, - eCommandBufferAllocateInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, - eCommandBufferInheritanceInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, - eCommandBufferBeginInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, - eRenderPassBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, - eBufferMemoryBarrier = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, - eImageMemoryBarrier = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, - eMemoryBarrier = VK_STRUCTURE_TYPE_MEMORY_BARRIER, - eLoaderInstanceCreateInfo = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, - eLoaderDeviceCreateInfo = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, - eBindBufferMemoryInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, - eBindBufferMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, - eBindImageMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, - eBindImageMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, - eMemoryDedicatedRequirements = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, - eMemoryDedicatedRequirementsKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, - eMemoryDedicatedAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, - eMemoryDedicatedAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, - eMemoryAllocateFlagsInfo = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, - eMemoryAllocateFlagsInfoKHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR, - eDeviceGroupCommandBufferBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, - eDeviceGroupCommandBufferBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR, - eDeviceGroupSubmitInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, - eDeviceGroupSubmitInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR, - eDeviceGroupBindSparseInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, - eDeviceGroupBindSparseInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, - eBindBufferMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, - eBindBufferMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR, - eBindImageMemoryDeviceGroupInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, - eBindImageMemoryDeviceGroupInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR, - ePhysicalDeviceGroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, - ePhysicalDeviceGroupPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR, - eDeviceGroupDeviceCreateInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, - eDeviceGroupDeviceCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, - eBufferMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, - eBufferMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, - eImageMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, - eImageMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR, - eImageSparseMemoryRequirementsInfo2 = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, - eImageSparseMemoryRequirementsInfo2KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR, - eMemoryRequirements2 = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, - eMemoryRequirements2KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, - eSparseImageMemoryRequirements2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, - eSparseImageMemoryRequirements2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR, - ePhysicalDeviceFeatures2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, - ePhysicalDeviceFeatures2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, - ePhysicalDeviceProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, - ePhysicalDeviceProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR, - eFormatProperties2 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, - eFormatProperties2KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR, - eImageFormatProperties2 = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, - eImageFormatProperties2KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR, - ePhysicalDeviceImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, - ePhysicalDeviceImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR, - eQueueFamilyProperties2 = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, - eQueueFamilyProperties2KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR, - ePhysicalDeviceMemoryProperties2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, - ePhysicalDeviceMemoryProperties2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR, - eSparseImageFormatProperties2 = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, - eSparseImageFormatProperties2KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR, - ePhysicalDeviceSparseImageFormatInfo2 = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, - ePhysicalDeviceSparseImageFormatInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR, - eImageViewUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, - eImageViewUsageCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, - eProtectedSubmitInfo = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO, - ePhysicalDeviceProtectedMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, - ePhysicalDeviceProtectedMemoryProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, - eDeviceQueueInfo2 = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, - ePhysicalDeviceExternalImageFormatInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, - ePhysicalDeviceExternalImageFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR, - eExternalImageFormatProperties = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, - eExternalImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR, - ePhysicalDeviceExternalBufferInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, - ePhysicalDeviceExternalBufferInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR, - eExternalBufferProperties = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, - eExternalBufferPropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR, - ePhysicalDeviceIdProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, - ePhysicalDeviceIdPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR, - eExternalMemoryBufferCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, - eExternalMemoryBufferCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR, - eExternalMemoryImageCreateInfo = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, - eExternalMemoryImageCreateInfoKHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR, - eExportMemoryAllocateInfo = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, - eExportMemoryAllocateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR, - ePhysicalDeviceExternalFenceInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, - ePhysicalDeviceExternalFenceInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR, - eExternalFenceProperties = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, - eExternalFencePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR, - eExportFenceCreateInfo = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, - eExportFenceCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR, - eExportSemaphoreCreateInfo = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, - eExportSemaphoreCreateInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR, - ePhysicalDeviceExternalSemaphoreInfo = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, - ePhysicalDeviceExternalSemaphoreInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR, - eExternalSemaphoreProperties = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, - eExternalSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR, - ePhysicalDeviceSubgroupProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, - ePhysicalDevice16BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, - ePhysicalDevice16BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, - ePhysicalDeviceVariablePointersFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, - ePhysicalDeviceVariablePointerFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES, - ePhysicalDeviceVariablePointersFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, - ePhysicalDeviceVariablePointerFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR, - eDescriptorUpdateTemplateCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, - eDescriptorUpdateTemplateCreateInfoKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR, - ePhysicalDeviceMaintenance3Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, - ePhysicalDeviceMaintenance3PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR, - eDescriptorSetLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, - eDescriptorSetLayoutSupportKHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR, - eSamplerYcbcrConversionCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, - eSamplerYcbcrConversionCreateInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR, - eSamplerYcbcrConversionInfo = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, - eSamplerYcbcrConversionInfoKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR, - eBindImagePlaneMemoryInfo = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, - eBindImagePlaneMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR, - eImagePlaneMemoryRequirementsInfo = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, - eImagePlaneMemoryRequirementsInfoKHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR, - ePhysicalDeviceSamplerYcbcrConversionFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, - ePhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR, - eSamplerYcbcrConversionImageFormatProperties = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, - eSamplerYcbcrConversionImageFormatPropertiesKHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR, - eDeviceGroupRenderPassBeginInfo = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, - eDeviceGroupRenderPassBeginInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR, - ePhysicalDevicePointClippingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, - ePhysicalDevicePointClippingPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR, - eRenderPassInputAttachmentAspectCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, - eRenderPassInputAttachmentAspectCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR, - ePipelineTessellationDomainOriginStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, - ePipelineTessellationDomainOriginStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR, - eRenderPassMultiviewCreateInfo = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, - eRenderPassMultiviewCreateInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR, - ePhysicalDeviceMultiviewFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, - ePhysicalDeviceMultiviewFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, - ePhysicalDeviceMultiviewProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, - ePhysicalDeviceMultiviewPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR, - ePhysicalDeviceShaderDrawParametersFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, - ePhysicalDeviceShaderDrawParameterFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES, - ePhysicalDeviceVulkan11Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, - ePhysicalDeviceVulkan11Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, - ePhysicalDeviceVulkan12Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, - ePhysicalDeviceVulkan12Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, - eImageFormatListCreateInfo = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, - eImageFormatListCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR, - ePhysicalDeviceDriverProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, - ePhysicalDeviceDriverPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR, - ePhysicalDeviceVulkanMemoryModelFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, - ePhysicalDeviceVulkanMemoryModelFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR, - ePhysicalDeviceHostQueryResetFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, - ePhysicalDeviceHostQueryResetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, - ePhysicalDeviceTimelineSemaphoreFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, - ePhysicalDeviceTimelineSemaphoreFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR, - ePhysicalDeviceTimelineSemaphoreProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, - ePhysicalDeviceTimelineSemaphorePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR, - eSemaphoreTypeCreateInfo = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, - eSemaphoreTypeCreateInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR, - eTimelineSemaphoreSubmitInfo = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, - eTimelineSemaphoreSubmitInfoKHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR, - eSemaphoreWaitInfo = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, - eSemaphoreWaitInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR, - eSemaphoreSignalInfo = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, - eSemaphoreSignalInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR, - ePhysicalDeviceBufferDeviceAddressFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, - ePhysicalDeviceBufferDeviceAddressFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR, - eBufferDeviceAddressInfo = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, - eBufferDeviceAddressInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT, - eBufferDeviceAddressInfoKHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR, - eBufferOpaqueCaptureAddressCreateInfo = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, - eBufferOpaqueCaptureAddressCreateInfoKHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR, - eMemoryOpaqueCaptureAddressAllocateInfo = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, - eMemoryOpaqueCaptureAddressAllocateInfoKHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR, - eDeviceMemoryOpaqueCaptureAddressInfo = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, - eDeviceMemoryOpaqueCaptureAddressInfoKHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR, - ePhysicalDevice8BitStorageFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, - ePhysicalDevice8BitStorageFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, - ePhysicalDeviceShaderAtomicInt64Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, - ePhysicalDeviceShaderAtomicInt64FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, - ePhysicalDeviceShaderFloat16Int8Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, - ePhysicalDeviceShaderFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR, - ePhysicalDeviceFloat16Int8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR, - ePhysicalDeviceFloatControlsProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, - ePhysicalDeviceFloatControlsPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR, - eDescriptorSetLayoutBindingFlagsCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, - eDescriptorSetLayoutBindingFlagsCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT, - ePhysicalDeviceDescriptorIndexingFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, - ePhysicalDeviceDescriptorIndexingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, - ePhysicalDeviceDescriptorIndexingProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, - ePhysicalDeviceDescriptorIndexingPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT, - eDescriptorSetVariableDescriptorCountAllocateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, - eDescriptorSetVariableDescriptorCountAllocateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT, - eDescriptorSetVariableDescriptorCountLayoutSupport = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, - eDescriptorSetVariableDescriptorCountLayoutSupportEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT, - ePhysicalDeviceScalarBlockLayoutFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, - ePhysicalDeviceScalarBlockLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, - ePhysicalDeviceSamplerFilterMinmaxProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, - ePhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT, - eSamplerReductionModeCreateInfo = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, - eSamplerReductionModeCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT, - ePhysicalDeviceUniformBufferStandardLayoutFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, - ePhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR, - ePhysicalDeviceShaderSubgroupExtendedTypesFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, - ePhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR, - eAttachmentDescription2 = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, - eAttachmentDescription2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR, - eAttachmentReference2 = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, - eAttachmentReference2KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR, - eSubpassDescription2 = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, - eSubpassDescription2KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR, - eSubpassDependency2 = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, - eSubpassDependency2KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR, - eRenderPassCreateInfo2 = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, - eRenderPassCreateInfo2KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR, - eSubpassBeginInfo = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, - eSubpassBeginInfoKHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR, - eSubpassEndInfo = VK_STRUCTURE_TYPE_SUBPASS_END_INFO, - eSubpassEndInfoKHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR, - ePhysicalDeviceDepthStencilResolveProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, - ePhysicalDeviceDepthStencilResolvePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR, - eSubpassDescriptionDepthStencilResolve = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, - eSubpassDescriptionDepthStencilResolveKHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR, - eImageStencilUsageCreateInfo = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, - eImageStencilUsageCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT, - ePhysicalDeviceImagelessFramebufferFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, - ePhysicalDeviceImagelessFramebufferFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, - eFramebufferAttachmentsCreateInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, - eFramebufferAttachmentsCreateInfoKHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR, - eFramebufferAttachmentImageInfo = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, - eFramebufferAttachmentImageInfoKHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR, - eRenderPassAttachmentBeginInfo = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, - eRenderPassAttachmentBeginInfoKHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR, - ePhysicalDeviceSeparateDepthStencilLayoutsFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, - ePhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR, - eAttachmentReferenceStencilLayout = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, - eAttachmentReferenceStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR, - eAttachmentDescriptionStencilLayout = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, - eAttachmentDescriptionStencilLayoutKHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR, - ePhysicalDeviceVulkan13Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES, - ePhysicalDeviceVulkan13Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES, - ePhysicalDeviceToolProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES, - ePhysicalDeviceToolPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT, - ePhysicalDevicePrivateDataFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, - ePhysicalDevicePrivateDataFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT, - eDevicePrivateDataCreateInfo = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, - eDevicePrivateDataCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT, - ePrivateDataSlotCreateInfo = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, - ePrivateDataSlotCreateInfoEXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT, - eMemoryBarrier2 = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, - eMemoryBarrier2KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, - eBufferMemoryBarrier2 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, - eBufferMemoryBarrier2KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR, - eImageMemoryBarrier2 = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, - eImageMemoryBarrier2KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR, - eDependencyInfo = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, - eDependencyInfoKHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR, - eSubmitInfo2 = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, - eSubmitInfo2KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR, - eSemaphoreSubmitInfo = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, - eSemaphoreSubmitInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, - eCommandBufferSubmitInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, - eCommandBufferSubmitInfoKHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR, - ePhysicalDeviceSynchronization2Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, - ePhysicalDeviceSynchronization2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR, - eCopyBufferInfo2 = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, - eCopyBufferInfo2KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR, - eCopyImageInfo2 = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2, - eCopyImageInfo2KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR, - eCopyBufferToImageInfo2 = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, - eCopyBufferToImageInfo2KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR, - eCopyImageToBufferInfo2 = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, - eCopyImageToBufferInfo2KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR, - eBufferCopy2 = VK_STRUCTURE_TYPE_BUFFER_COPY_2, - eBufferCopy2KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR, - eImageCopy2 = VK_STRUCTURE_TYPE_IMAGE_COPY_2, - eImageCopy2KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR, - eBufferImageCopy2 = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, - eBufferImageCopy2KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR, - ePhysicalDeviceTextureCompressionAstcHdrFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, - ePhysicalDeviceTextureCompressionAstcHdrFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT, - eFormatProperties3 = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, - eFormatProperties3KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, - ePhysicalDeviceMaintenance4Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, - ePhysicalDeviceMaintenance4FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR, - ePhysicalDeviceMaintenance4Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, - ePhysicalDeviceMaintenance4PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR, - eDeviceBufferMemoryRequirements = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, - eDeviceBufferMemoryRequirementsKHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR, - eDeviceImageMemoryRequirements = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, - eDeviceImageMemoryRequirementsKHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR, - ePipelineCreationFeedbackCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, - ePipelineCreationFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT, - ePhysicalDeviceShaderTerminateInvocationFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, - ePhysicalDeviceShaderTerminateInvocationFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR, - ePhysicalDeviceShaderDemoteToHelperInvocationFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, - ePhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, - ePhysicalDevicePipelineCreationCacheControlFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, - ePhysicalDevicePipelineCreationCacheControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT, - ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, - ePhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR, - ePhysicalDeviceImageRobustnessFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, - ePhysicalDeviceImageRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT, - ePhysicalDeviceSubgroupSizeControlProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, - ePhysicalDeviceSubgroupSizeControlPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, - ePipelineShaderStageRequiredSubgroupSizeCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, - ePipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT, - eShaderRequiredSubgroupSizeCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT, - ePhysicalDeviceSubgroupSizeControlFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, - ePhysicalDeviceSubgroupSizeControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT, - ePhysicalDeviceInlineUniformBlockFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, - ePhysicalDeviceInlineUniformBlockFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, - ePhysicalDeviceInlineUniformBlockProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, - ePhysicalDeviceInlineUniformBlockPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, - eWriteDescriptorSetInlineUniformBlock = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, - eWriteDescriptorSetInlineUniformBlockEXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT, - eDescriptorPoolInlineUniformBlockCreateInfo = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, - eDescriptorPoolInlineUniformBlockCreateInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT, - ePhysicalDeviceShaderIntegerDotProductFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, - ePhysicalDeviceShaderIntegerDotProductFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR, - ePhysicalDeviceShaderIntegerDotProductProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, - ePhysicalDeviceShaderIntegerDotProductPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR, - ePhysicalDeviceTexelBufferAlignmentProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, - ePhysicalDeviceTexelBufferAlignmentPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, - eBlitImageInfo2 = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, - eBlitImageInfo2KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR, - eResolveImageInfo2 = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, - eResolveImageInfo2KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR, - eImageBlit2 = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, - eImageBlit2KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR, - eImageResolve2 = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, - eImageResolve2KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR, - eRenderingInfo = VK_STRUCTURE_TYPE_RENDERING_INFO, - eRenderingInfoKHR = VK_STRUCTURE_TYPE_RENDERING_INFO_KHR, - eRenderingAttachmentInfo = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, - eRenderingAttachmentInfoKHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR, - ePipelineRenderingCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, - ePipelineRenderingCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR, - ePhysicalDeviceDynamicRenderingFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, - ePhysicalDeviceDynamicRenderingFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR, - eCommandBufferInheritanceRenderingInfo = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, - eCommandBufferInheritanceRenderingInfoKHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR, - ePhysicalDeviceVulkan14Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES, - ePhysicalDeviceVulkan14Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES, - eDeviceQueueGlobalPriorityCreateInfo = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO, - eDeviceQueueGlobalPriorityCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, - eDeviceQueueGlobalPriorityCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR, - ePhysicalDeviceGlobalPriorityQueryFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES, - ePhysicalDeviceGlobalPriorityQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, - ePhysicalDeviceGlobalPriorityQueryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT, - eQueueFamilyGlobalPriorityProperties = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES, - eQueueFamilyGlobalPriorityPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR, - eQueueFamilyGlobalPriorityPropertiesEXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT, - ePhysicalDeviceIndexTypeUint8Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES, - ePhysicalDeviceIndexTypeUint8FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, - ePhysicalDeviceIndexTypeUint8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR, - eMemoryMapInfo = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO, - eMemoryMapInfoKHR = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR, - eMemoryUnmapInfo = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO, - eMemoryUnmapInfoKHR = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR, - ePhysicalDeviceMaintenance5Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES, - ePhysicalDeviceMaintenance5FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR, - ePhysicalDeviceMaintenance5Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES, - ePhysicalDeviceMaintenance5PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR, - eDeviceImageSubresourceInfo = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO, - eDeviceImageSubresourceInfoKHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR, - eSubresourceLayout2 = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2, - eSubresourceLayout2EXT = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT, - eSubresourceLayout2KHR = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR, - eImageSubresource2 = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2, - eImageSubresource2EXT = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT, - eImageSubresource2KHR = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR, - eBufferUsageFlags2CreateInfo = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO, - eBufferUsageFlags2CreateInfoKHR = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR, - ePhysicalDeviceMaintenance6Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES, - ePhysicalDeviceMaintenance6FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR, - ePhysicalDeviceMaintenance6Properties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES, - ePhysicalDeviceMaintenance6PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR, - eBindMemoryStatus = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS, - eBindMemoryStatusKHR = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR, - ePhysicalDeviceHostImageCopyFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES, - ePhysicalDeviceHostImageCopyFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT, - ePhysicalDeviceHostImageCopyProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES, - ePhysicalDeviceHostImageCopyPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT, - eMemoryToImageCopy = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY, - eMemoryToImageCopyEXT = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT, - eImageToMemoryCopy = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY, - eImageToMemoryCopyEXT = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT, - eCopyImageToMemoryInfo = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO, - eCopyImageToMemoryInfoEXT = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT, - eCopyMemoryToImageInfo = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO, - eCopyMemoryToImageInfoEXT = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT, - eHostImageLayoutTransitionInfo = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO, - eHostImageLayoutTransitionInfoEXT = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT, - eCopyImageToImageInfo = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO, - eCopyImageToImageInfoEXT = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT, - eSubresourceHostMemcpySize = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE, - eSubresourceHostMemcpySizeEXT = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT, - eHostImageCopyDevicePerformanceQuery = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY, - eHostImageCopyDevicePerformanceQueryEXT = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT, - ePhysicalDeviceShaderSubgroupRotateFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES, - ePhysicalDeviceShaderSubgroupRotateFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR, - ePhysicalDeviceShaderFloatControls2Features = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES, - ePhysicalDeviceShaderFloatControls2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR, - ePhysicalDeviceShaderExpectAssumeFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES, - ePhysicalDeviceShaderExpectAssumeFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR, - ePipelineCreateFlags2CreateInfo = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO, - ePipelineCreateFlags2CreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR, - ePhysicalDevicePushDescriptorProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES, - ePhysicalDevicePushDescriptorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, - eBindDescriptorSetsInfo = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO, - eBindDescriptorSetsInfoKHR = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR, - ePushConstantsInfo = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO, - ePushConstantsInfoKHR = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR, - ePushDescriptorSetInfo = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO, - ePushDescriptorSetInfoKHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR, - ePushDescriptorSetWithTemplateInfo = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO, - ePushDescriptorSetWithTemplateInfoKHR = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR, - ePhysicalDevicePipelineProtectedAccessFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES, - ePhysicalDevicePipelineProtectedAccessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT, - ePipelineRobustnessCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO, - ePipelineRobustnessCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT, - ePhysicalDevicePipelineRobustnessFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES, - ePhysicalDevicePipelineRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT, - ePhysicalDevicePipelineRobustnessProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES, - ePhysicalDevicePipelineRobustnessPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT, - ePhysicalDeviceLineRasterizationFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES, - ePhysicalDeviceLineRasterizationFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, - ePhysicalDeviceLineRasterizationFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR, - ePipelineRasterizationLineStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO, - ePipelineRasterizationLineStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, - ePipelineRasterizationLineStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR, - ePhysicalDeviceLineRasterizationProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES, - ePhysicalDeviceLineRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, - ePhysicalDeviceLineRasterizationPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR, - ePhysicalDeviceVertexAttributeDivisorProperties = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES, - ePhysicalDeviceVertexAttributeDivisorPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR, - ePipelineVertexInputDivisorStateCreateInfo = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO, - ePipelineVertexInputDivisorStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, - ePipelineVertexInputDivisorStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR, - ePhysicalDeviceVertexAttributeDivisorFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES, - ePhysicalDeviceVertexAttributeDivisorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, - ePhysicalDeviceVertexAttributeDivisorFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR, - eRenderingAreaInfo = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO, - eRenderingAreaInfoKHR = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR, - ePhysicalDeviceDynamicRenderingLocalReadFeatures = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES, - ePhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR, - eRenderingAttachmentLocationInfo = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO, - eRenderingAttachmentLocationInfoKHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR, - eRenderingInputAttachmentIndexInfo = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO, - eRenderingInputAttachmentIndexInfoKHR = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR, - eSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, - ePresentInfoKHR = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, - eDeviceGroupPresentCapabilitiesKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, - eImageSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, - eBindImageMemorySwapchainInfoKHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, - eAcquireNextImageInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR, - eDeviceGroupPresentInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR, - eDeviceGroupSwapchainCreateInfoKHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, - eDisplayModeCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR, - eDisplaySurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR, - eDisplayPresentInfoKHR = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - eXlibSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ -#if defined( VK_USE_PLATFORM_XCB_KHR ) - eXcbSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, -#endif /*VK_USE_PLATFORM_XCB_KHR*/ -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - eWaylandSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR, -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - eAndroidSurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - eWin32SurfaceCreateInfoKHR = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - eDebugReportCallbackCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, - eDebugReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT, - ePipelineRasterizationStateRasterizationOrderAMD = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, - eDebugMarkerObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT, - eDebugMarkerObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT, - eDebugMarkerMarkerInfoEXT = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, - eVideoProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, - eVideoCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR, - eVideoPictureResourceInfoKHR = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR, - eVideoSessionMemoryRequirementsKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR, - eBindVideoSessionMemoryInfoKHR = VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR, - eVideoSessionCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR, - eVideoSessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR, - eVideoSessionParametersUpdateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR, - eVideoBeginCodingInfoKHR = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR, - eVideoEndCodingInfoKHR = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR, - eVideoCodingControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR, - eVideoReferenceSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR, - eQueueFamilyVideoPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR, - eVideoProfileListInfoKHR = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR, - ePhysicalDeviceVideoFormatInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, - eVideoFormatPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR, - eQueueFamilyQueryResultStatusPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR, - eVideoDecodeInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR, - eVideoDecodeCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR, - eVideoDecodeUsageInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR, - eDedicatedAllocationImageCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, - eDedicatedAllocationBufferCreateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, - eDedicatedAllocationMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, - ePhysicalDeviceTransformFeedbackFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, - ePhysicalDeviceTransformFeedbackPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT, - ePipelineRasterizationStateStreamCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT, - eCuModuleCreateInfoNVX = VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX, - eCuFunctionCreateInfoNVX = VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX, - eCuLaunchInfoNVX = VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX, - eCuModuleTexturingModeCreateInfoNVX = VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX, - eImageViewHandleInfoNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX, - eImageViewAddressPropertiesNVX = VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX, - eVideoEncodeH264CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR, - eVideoEncodeH264SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR, - eVideoEncodeH264SessionParametersAddInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR, - eVideoEncodeH264PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR, - eVideoEncodeH264DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR, - eVideoEncodeH264NaluSliceInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR, - eVideoEncodeH264GopRemainingFrameInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR, - eVideoEncodeH264ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR, - eVideoEncodeH264RateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR, - eVideoEncodeH264RateControlLayerInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR, - eVideoEncodeH264SessionCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR, - eVideoEncodeH264QualityLevelPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR, - eVideoEncodeH264SessionParametersGetInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR, - eVideoEncodeH264SessionParametersFeedbackInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR, - eVideoEncodeH265CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR, - eVideoEncodeH265SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR, - eVideoEncodeH265SessionParametersAddInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR, - eVideoEncodeH265PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR, - eVideoEncodeH265DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR, - eVideoEncodeH265NaluSliceSegmentInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR, - eVideoEncodeH265GopRemainingFrameInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR, - eVideoEncodeH265ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR, - eVideoEncodeH265RateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR, - eVideoEncodeH265RateControlLayerInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR, - eVideoEncodeH265SessionCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR, - eVideoEncodeH265QualityLevelPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR, - eVideoEncodeH265SessionParametersGetInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR, - eVideoEncodeH265SessionParametersFeedbackInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR, - eVideoDecodeH264CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR, - eVideoDecodeH264PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR, - eVideoDecodeH264ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR, - eVideoDecodeH264SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR, - eVideoDecodeH264SessionParametersAddInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR, - eVideoDecodeH264DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR, - eTextureLodGatherFormatPropertiesAMD = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, -#if defined( VK_USE_PLATFORM_GGP ) - eStreamDescriptorSurfaceCreateInfoGGP = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP, -#endif /*VK_USE_PLATFORM_GGP*/ - ePhysicalDeviceCornerSampledImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, - eExternalMemoryImageCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, - eExportMemoryAllocateInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - eImportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV, - eExportMemoryWin32HandleInfoNV = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV, - eWin32KeyedMutexAcquireReleaseInfoNV = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV, -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - eValidationFlagsEXT = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT, -#if defined( VK_USE_PLATFORM_VI_NN ) - eViSurfaceCreateInfoNN = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN, -#endif /*VK_USE_PLATFORM_VI_NN*/ - eImageViewAstcDecodeModeEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT, - ePhysicalDeviceAstcDecodeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - eImportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR, - eExportMemoryWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR, - eMemoryWin32HandlePropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, - eMemoryGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR, -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - eImportMemoryFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, - eMemoryFdPropertiesKHR = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, - eMemoryGetFdInfoKHR = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - eWin32KeyedMutexAcquireReleaseInfoKHR = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR, - eImportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, - eExportSemaphoreWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR, - eD3D12FenceSubmitInfoKHR = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR, - eSemaphoreGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR, -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - eImportSemaphoreFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, - eSemaphoreGetFdInfoKHR = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, - eCommandBufferInheritanceConditionalRenderingInfoEXT = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, - ePhysicalDeviceConditionalRenderingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, - eConditionalRenderingBeginInfoEXT = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT, - ePresentRegionsKHR = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, - ePipelineViewportWScalingStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV, - eSurfaceCapabilities2EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, - eDisplayPowerInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT, - eDeviceEventInfoEXT = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT, - eDisplayEventInfoEXT = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT, - eSwapchainCounterCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT, - ePresentTimesInfoGOOGLE = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE, - ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX, - eMultiviewPerViewAttributesInfoNVX = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX, - ePipelineViewportSwizzleStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV, - ePhysicalDeviceDiscardRectanglePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, - ePipelineDiscardRectangleStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, - ePhysicalDeviceConservativeRasterizationPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, - ePipelineRasterizationConservativeStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, - ePhysicalDeviceDepthClipEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, - ePipelineRasterizationDepthClipStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT, - eHdrMetadataEXT = VK_STRUCTURE_TYPE_HDR_METADATA_EXT, - ePhysicalDeviceRelaxedLineRasterizationFeaturesIMG = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG, - eSharedPresentSurfaceCapabilitiesKHR = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - eImportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR, - eExportFenceWin32HandleInfoKHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR, - eFenceGetWin32HandleInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR, -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - eImportFenceFdInfoKHR = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, - eFenceGetFdInfoKHR = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, - ePhysicalDevicePerformanceQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, - ePhysicalDevicePerformanceQueryPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR, - eQueryPoolPerformanceCreateInfoKHR = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR, - ePerformanceQuerySubmitInfoKHR = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR, - eAcquireProfilingLockInfoKHR = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR, - ePerformanceCounterKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR, - ePerformanceCounterDescriptionKHR = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR, - ePhysicalDeviceSurfaceInfo2KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, - eSurfaceCapabilities2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, - eSurfaceFormat2KHR = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, - eDisplayProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR, - eDisplayPlaneProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR, - eDisplayModeProperties2KHR = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR, - eDisplayPlaneInfo2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR, - eDisplayPlaneCapabilities2KHR = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR, -#if defined( VK_USE_PLATFORM_IOS_MVK ) - eIosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK, -#endif /*VK_USE_PLATFORM_IOS_MVK*/ -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - eMacosSurfaceCreateInfoMVK = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - eDebugUtilsObjectNameInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT, - eDebugUtilsObjectTagInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT, - eDebugUtilsLabelEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, - eDebugUtilsMessengerCallbackDataEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, - eDebugUtilsMessengerCreateInfoEXT = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - eAndroidHardwareBufferUsageANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID, - eAndroidHardwareBufferPropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID, - eAndroidHardwareBufferFormatPropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID, - eImportAndroidHardwareBufferInfoANDROID = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, - eMemoryGetAndroidHardwareBufferInfoANDROID = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, - eExternalFormatANDROID = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, - eAndroidHardwareBufferFormatProperties2ANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID, -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - ePhysicalDeviceShaderEnqueueFeaturesAMDX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX, - ePhysicalDeviceShaderEnqueuePropertiesAMDX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX, - eExecutionGraphPipelineScratchSizeAMDX = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX, - eExecutionGraphPipelineCreateInfoAMDX = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX, - ePipelineShaderStageNodeCreateInfoAMDX = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eTexelBufferDescriptorInfoEXT = VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT, - eImageDescriptorInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT, - eResourceDescriptorInfoEXT = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT, - eBindHeapInfoEXT = VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT, - ePushDataInfoEXT = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT, - eDescriptorSetAndBindingMappingEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT, - eShaderDescriptorSetAndBindingMappingInfoEXT = VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT, - eOpaqueCaptureDataCreateInfoEXT = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT, - ePhysicalDeviceDescriptorHeapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT, - ePhysicalDeviceDescriptorHeapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT, - eCommandBufferInheritanceDescriptorHeapInfoEXT = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT, - eSamplerCustomBorderColorIndexCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT, - eIndirectCommandsLayoutPushDataTokenNV = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV, - eSubsampledImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT, - ePhysicalDeviceDescriptorHeapTensorPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM, - eAttachmentSampleCountInfoAMD = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, - eAttachmentSampleCountInfoNV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV, - ePhysicalDeviceShaderBfloat16FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR, - eSampleLocationsInfoEXT = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, - eRenderPassSampleLocationsBeginInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, - ePipelineSampleLocationsStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, - ePhysicalDeviceSampleLocationsPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, - eMultisamplePropertiesEXT = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, - ePhysicalDeviceBlendOperationAdvancedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, - ePhysicalDeviceBlendOperationAdvancedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT, - ePipelineColorBlendAdvancedStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT, - ePipelineCoverageToColorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV, - eWriteDescriptorSetAccelerationStructureKHR = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR, - eAccelerationStructureBuildGeometryInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR, - eAccelerationStructureDeviceAddressInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR, - eAccelerationStructureGeometryAabbsDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR, - eAccelerationStructureGeometryInstancesDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR, - eAccelerationStructureGeometryTrianglesDataKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR, - eAccelerationStructureGeometryKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR, - eAccelerationStructureVersionInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR, - eCopyAccelerationStructureInfoKHR = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR, - eCopyAccelerationStructureToMemoryInfoKHR = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR, - eCopyMemoryToAccelerationStructureInfoKHR = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR, - ePhysicalDeviceAccelerationStructureFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR, - ePhysicalDeviceAccelerationStructurePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR, - eAccelerationStructureCreateInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR, - eAccelerationStructureBuildSizesInfoKHR = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR, - ePhysicalDeviceRayTracingPipelineFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR, - ePhysicalDeviceRayTracingPipelinePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR, - eRayTracingPipelineCreateInfoKHR = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR, - eRayTracingShaderGroupCreateInfoKHR = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR, - eRayTracingPipelineInterfaceCreateInfoKHR = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR, - ePhysicalDeviceRayQueryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR, - ePipelineCoverageModulationStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV, - ePhysicalDeviceShaderSmBuiltinsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, - ePhysicalDeviceShaderSmBuiltinsPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV, - eDrmFormatModifierPropertiesListEXT = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT, - ePhysicalDeviceImageDrmFormatModifierInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT, - eImageDrmFormatModifierListCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT, - eImageDrmFormatModifierExplicitCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT, - eImageDrmFormatModifierPropertiesEXT = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT, - eDrmFormatModifierPropertiesList2EXT = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT, - eValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, - eShaderModuleValidationCacheCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - ePhysicalDevicePortabilitySubsetFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR, - ePhysicalDevicePortabilitySubsetPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - ePipelineViewportShadingRateImageStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV, - ePhysicalDeviceShadingRateImageFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, - ePhysicalDeviceShadingRateImagePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV, - ePipelineViewportCoarseSampleOrderStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV, - eRayTracingPipelineCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV, - eAccelerationStructureCreateInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV, - eGeometryNV = VK_STRUCTURE_TYPE_GEOMETRY_NV, - eGeometryTrianglesNV = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV, - eGeometryAabbNV = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV, - eBindAccelerationStructureMemoryInfoNV = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV, - eWriteDescriptorSetAccelerationStructureNV = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV, - eAccelerationStructureMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV, - ePhysicalDeviceRayTracingPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV, - eRayTracingShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV, - eAccelerationStructureInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV, - ePhysicalDeviceRepresentativeFragmentTestFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, - ePipelineRepresentativeFragmentTestStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV, - ePhysicalDeviceImageViewImageFormatInfoEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT, - eFilterCubicImageViewImageFormatPropertiesEXT = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, - eImportMemoryHostPointerInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT, - eMemoryHostPointerPropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, - ePhysicalDeviceExternalMemoryHostPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT, - ePhysicalDeviceShaderClockFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, - ePipelineCompilerControlCreateInfoAMD = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD, - ePhysicalDeviceShaderCorePropertiesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, - eVideoDecodeH265CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR, - eVideoDecodeH265SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR, - eVideoDecodeH265SessionParametersAddInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR, - eVideoDecodeH265ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR, - eVideoDecodeH265PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR, - eVideoDecodeH265DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR, - eDeviceMemoryOverallocationCreateInfoAMD = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD, - ePhysicalDeviceVertexAttributeDivisorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, -#if defined( VK_USE_PLATFORM_GGP ) - ePresentFrameTokenGGP = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP, -#endif /*VK_USE_PLATFORM_GGP*/ - ePhysicalDeviceMeshShaderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, - ePhysicalDeviceMeshShaderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV, - ePhysicalDeviceShaderImageFootprintFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, - ePipelineViewportExclusiveScissorStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV, - ePhysicalDeviceExclusiveScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, - eCheckpointDataNV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV, - eQueueFamilyCheckpointPropertiesNV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV, - eQueueFamilyCheckpointProperties2NV = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV, - eCheckpointData2NV = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV, - ePhysicalDevicePresentTimingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT, - eSwapchainTimingPropertiesEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT, - eSwapchainTimeDomainPropertiesEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT, - ePresentTimingsInfoEXT = VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT, - ePresentTimingInfoEXT = VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT, - ePastPresentationTimingInfoEXT = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT, - ePastPresentationTimingPropertiesEXT = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT, - ePastPresentationTimingEXT = VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT, - ePresentTimingSurfaceCapabilitiesEXT = VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT, - eSwapchainCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT, - ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, - eQueryPoolPerformanceQueryCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, - eQueryPoolCreateInfoINTEL = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL, - eInitializePerformanceApiInfoINTEL = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL, - ePerformanceMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL, - ePerformanceStreamMarkerInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL, - ePerformanceOverrideInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL, - ePerformanceConfigurationAcquireInfoINTEL = VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL, - ePhysicalDevicePciBusInfoPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, - eDisplayNativeHdrSurfaceCapabilitiesAMD = VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD, - eSwapchainDisplayNativeHdrCreateInfoAMD = VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD, -#if defined( VK_USE_PLATFORM_FUCHSIA ) - eImagepipeSurfaceCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA, -#endif /*VK_USE_PLATFORM_FUCHSIA*/ -#if defined( VK_USE_PLATFORM_METAL_EXT ) - eMetalSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT, -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - ePhysicalDeviceFragmentDensityMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, - ePhysicalDeviceFragmentDensityMapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, - eRenderPassFragmentDensityMapCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, - eRenderingFragmentDensityMapAttachmentInfoEXT = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT, - eFragmentShadingRateAttachmentInfoKHR = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, - ePipelineFragmentShadingRateStateCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR, - ePhysicalDeviceFragmentShadingRatePropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR, - ePhysicalDeviceFragmentShadingRateFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR, - ePhysicalDeviceFragmentShadingRateKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR, - eRenderingFragmentShadingRateAttachmentInfoKHR = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR, - ePhysicalDeviceShaderCoreProperties2AMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD, - ePhysicalDeviceCoherentMemoryFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, - ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, - ePhysicalDeviceShaderQuadControlFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR, - ePhysicalDeviceMemoryBudgetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, - ePhysicalDeviceMemoryPriorityFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, - eMemoryPriorityAllocateInfoEXT = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT, - eSurfaceProtectedCapabilitiesKHR = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR, - ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, - ePhysicalDeviceBufferDeviceAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, - ePhysicalDeviceBufferAddressFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT, - eBufferDeviceAddressCreateInfoEXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, - eValidationFeaturesEXT = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT, - ePhysicalDevicePresentWaitFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, - ePhysicalDeviceCooperativeMatrixFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, - eCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV, - ePhysicalDeviceCooperativeMatrixPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV, - ePhysicalDeviceCoverageReductionModeFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, - ePipelineCoverageReductionStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV, - eFramebufferMixedSamplesCombinationNV = VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV, - ePhysicalDeviceFragmentShaderInterlockFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, - ePhysicalDeviceYcbcrImageArraysFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, - ePhysicalDeviceProvokingVertexFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT, - ePipelineRasterizationProvokingVertexStateCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT, - ePhysicalDeviceProvokingVertexPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT, -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - eSurfaceFullScreenExclusiveInfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT, - eSurfaceCapabilitiesFullScreenExclusiveEXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT, - eSurfaceFullScreenExclusiveWin32InfoEXT = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT, -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - eHeadlessSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT, - ePhysicalDeviceShaderAtomicFloatFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, - ePhysicalDeviceExtendedDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, - ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, - ePipelineInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, - ePipelineInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT, - ePipelineExecutablePropertiesKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR, - ePipelineExecutableInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR, - ePipelineExecutableStatisticKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR, - ePipelineExecutableInternalRepresentationKHR = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR, - ePhysicalDeviceMapMemoryPlacedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT, - ePhysicalDeviceMapMemoryPlacedPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT, - eMemoryMapPlacedInfoEXT = VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT, - ePhysicalDeviceShaderAtomicFloat2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, - ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV, - eGraphicsShaderGroupCreateInfoNV = VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV, - eGraphicsPipelineShaderGroupsCreateInfoNV = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV, - eIndirectCommandsLayoutTokenNV = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV, - eIndirectCommandsLayoutCreateInfoNV = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV, - eGeneratedCommandsInfoNV = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV, - eGeneratedCommandsMemoryRequirementsInfoNV = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV, - ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV, - ePhysicalDeviceInheritedViewportScissorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV, - eCommandBufferInheritanceViewportScissorInfoNV = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV, - ePhysicalDeviceTexelBufferAlignmentFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, - eCommandBufferInheritanceRenderPassTransformInfoQCOM = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM, - eRenderPassTransformBeginInfoQCOM = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM, - ePhysicalDeviceDepthBiasControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT, - eDepthBiasInfoEXT = VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT, - eDepthBiasRepresentationInfoEXT = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT, - ePhysicalDeviceDeviceMemoryReportFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT, - eDeviceDeviceMemoryReportCreateInfoEXT = VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT, - eDeviceMemoryReportCallbackDataEXT = VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT, - eSamplerCustomBorderColorCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT, - ePhysicalDeviceCustomBorderColorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT, - ePhysicalDeviceCustomBorderColorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, - ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT, - ePipelineLibraryCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR, - ePhysicalDevicePresentBarrierFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV, - eSurfaceCapabilitiesPresentBarrierNV = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV, - eSwapchainPresentBarrierCreateInfoNV = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV, - ePresentIdKHR = VK_STRUCTURE_TYPE_PRESENT_ID_KHR, - ePhysicalDevicePresentIdFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, - eVideoEncodeInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR, - eVideoEncodeRateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR, - eVideoEncodeRateControlLayerInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR, - eVideoEncodeCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR, - eVideoEncodeUsageInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR, - eQueryPoolVideoEncodeFeedbackCreateInfoKHR = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR, - ePhysicalDeviceVideoEncodeQualityLevelInfoKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR, - eVideoEncodeQualityLevelPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR, - eVideoEncodeQualityLevelInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR, - eVideoEncodeSessionParametersGetInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR, - eVideoEncodeSessionParametersFeedbackInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR, - ePhysicalDeviceDiagnosticsConfigFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV, - eDeviceDiagnosticsConfigCreateInfoNV = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eCudaModuleCreateInfoNV = VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV, - eCudaFunctionCreateInfoNV = VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV, - eCudaLaunchInfoNV = VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV, - ePhysicalDeviceCudaKernelLaunchFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV, - ePhysicalDeviceCudaKernelLaunchPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - ePhysicalDeviceTileShadingFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM, - ePhysicalDeviceTileShadingPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM, - eRenderPassTileShadingCreateInfoQCOM = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM, - ePerTileBeginInfoQCOM = VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM, - ePerTileEndInfoQCOM = VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM, - eDispatchTileInfoQCOM = VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM, - eQueryLowLatencySupportNV = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV, -#if defined( VK_USE_PLATFORM_METAL_EXT ) - eExportMetalObjectCreateInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, - eExportMetalObjectsInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT, - eExportMetalDeviceInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT, - eExportMetalCommandQueueInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT, - eExportMetalBufferInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT, - eImportMetalBufferInfoEXT = VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT, - eExportMetalTextureInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT, - eImportMetalTextureInfoEXT = VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT, - eExportMetalIoSurfaceInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT, - eImportMetalIoSurfaceInfoEXT = VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT, - eExportMetalSharedEventInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT, - eImportMetalSharedEventInfoEXT = VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT, -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - ePhysicalDeviceDescriptorBufferPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT, - ePhysicalDeviceDescriptorBufferDensityMapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT, - ePhysicalDeviceDescriptorBufferFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT, - eDescriptorAddressInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT, - eDescriptorGetInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT, - eBufferCaptureDescriptorDataInfoEXT = VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, - eImageCaptureDescriptorDataInfoEXT = VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, - eImageViewCaptureDescriptorDataInfoEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, - eSamplerCaptureDescriptorDataInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, - eOpaqueCaptureDescriptorDataCreateInfoEXT = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT, - eDescriptorBufferBindingInfoEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT, - eDescriptorBufferBindingPushDescriptorBufferHandleEXT = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT, - eAccelerationStructureCaptureDescriptorDataInfoEXT = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT, - ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT, - ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT, - eGraphicsPipelineLibraryCreateInfoEXT = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT, - ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD, - ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, - ePhysicalDeviceFragmentShaderBarycentricFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, - ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR, - ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, - ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV, - ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV, - ePipelineFragmentShadingRateEnumStateCreateInfoNV = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV, - eAccelerationStructureGeometryMotionTrianglesDataNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV, - ePhysicalDeviceRayTracingMotionBlurFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV, - eAccelerationStructureMotionInfoNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV, - ePhysicalDeviceMeshShaderFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT, - ePhysicalDeviceMeshShaderPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT, - ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, - ePhysicalDeviceFragmentDensityMap2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, - ePhysicalDeviceFragmentDensityMap2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT, - eCopyCommandTransformInfoQCOM = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM, - ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, - ePhysicalDeviceImageCompressionControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT, - eImageCompressionControlEXT = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT, - eImageCompressionPropertiesEXT = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT, - ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT, - ePhysicalDevice4444FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT, - ePhysicalDeviceFaultFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT, - eDeviceFaultCountsEXT = VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT, - eDeviceFaultInfoEXT = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT, - ePhysicalDeviceRgba10X6FormatsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - eDirectfbSurfaceCreateInfoEXT = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT, -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - ePhysicalDeviceVertexInputDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT, - eVertexInputBindingDescription2EXT = VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT, - eVertexInputAttributeDescription2EXT = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT, - ePhysicalDeviceDrmPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT, - ePhysicalDeviceAddressBindingReportFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT, - eDeviceAddressBindingCallbackDataEXT = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT, - ePhysicalDeviceDepthClipControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT, - ePipelineViewportDepthClipControlCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT, - ePhysicalDevicePrimitiveTopologyListRestartFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT, -#if defined( VK_USE_PLATFORM_FUCHSIA ) - eImportMemoryZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA, - eMemoryZirconHandlePropertiesFUCHSIA = VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA, - eMemoryGetZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA, - eImportSemaphoreZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA, - eSemaphoreGetZirconHandleInfoFUCHSIA = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA, - eBufferCollectionCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA, - eImportMemoryBufferCollectionFUCHSIA = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA, - eBufferCollectionImageCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA, - eBufferCollectionPropertiesFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA, - eBufferConstraintsInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA, - eBufferCollectionBufferCreateInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA, - eImageConstraintsInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA, - eImageFormatConstraintsInfoFUCHSIA = VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA, - eSysmemColorSpaceFUCHSIA = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA, - eBufferCollectionConstraintsInfoFUCHSIA = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA, -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - eSubpassShadingPipelineCreateInfoHUAWEI = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI, - ePhysicalDeviceSubpassShadingFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI, - ePhysicalDeviceSubpassShadingPropertiesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI, - ePhysicalDeviceInvocationMaskFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI, - eMemoryGetRemoteAddressInfoNV = VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV, - ePhysicalDeviceExternalMemoryRdmaFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV, - ePipelinePropertiesIdentifierEXT = VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT, - ePhysicalDevicePipelinePropertiesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT, - ePhysicalDeviceFrameBoundaryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT, - eFrameBoundaryEXT = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT, - ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT, - eSubpassResolvePerformanceQueryEXT = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT, - eMultisampledRenderToSingleSampledInfoEXT = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT, - ePhysicalDeviceExtendedDynamicState2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT, -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - eScreenSurfaceCreateInfoQNX = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX, -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - ePhysicalDeviceColorWriteEnableFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT, - ePipelineColorWriteCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT, - ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT, - ePhysicalDeviceRayTracingMaintenance1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR, - ePhysicalDeviceShaderUntypedPointersFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR, - ePhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE, - eVideoEncodeRgbConversionCapabilitiesVALVE = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE, - eVideoEncodeProfileRgbConversionInfoVALVE = VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE, - eVideoEncodeSessionRgbConversionCreateInfoVALVE = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE, - ePhysicalDeviceImageViewMinLodFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT, - eImageViewMinLodCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT, - ePhysicalDeviceMultiDrawFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, - ePhysicalDeviceMultiDrawPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT, - ePhysicalDeviceImage2DViewOf3DFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, - ePhysicalDeviceShaderTileImageFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, - ePhysicalDeviceShaderTileImagePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT, - eMicromapBuildInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT, - eMicromapVersionInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT, - eCopyMicromapInfoEXT = VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT, - eCopyMicromapToMemoryInfoEXT = VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT, - eCopyMemoryToMicromapInfoEXT = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT, - ePhysicalDeviceOpacityMicromapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT, - ePhysicalDeviceOpacityMicromapPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT, - eMicromapCreateInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT, - eMicromapBuildSizesInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT, - eAccelerationStructureTrianglesOpacityMicromapEXT = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - ePhysicalDeviceDisplacementMicromapFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV, - ePhysicalDeviceDisplacementMicromapPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV, - eAccelerationStructureTrianglesDisplacementMicromapNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - ePhysicalDeviceClusterCullingShaderFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI, - ePhysicalDeviceClusterCullingShaderPropertiesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI, - ePhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI, - ePhysicalDeviceBorderColorSwizzleFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT, - eSamplerBorderColorComponentMappingCreateInfoEXT = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT, - ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT, - ePhysicalDeviceShaderCorePropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM, - eDeviceQueueShaderCoreControlCreateInfoARM = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM, - ePhysicalDeviceSchedulingControlsFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM, - ePhysicalDeviceSchedulingControlsPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM, - ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT, - eImageViewSlicedCreateInfoEXT = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT, - ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE, - eDescriptorSetBindingReferenceVALVE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE, - eDescriptorSetLayoutHostMappingInfoVALVE = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE, - ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT, - ePhysicalDeviceRenderPassStripedFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM, - ePhysicalDeviceRenderPassStripedPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM, - eRenderPassStripeBeginInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM, - eRenderPassStripeInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM, - eRenderPassStripeSubmitInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM, - ePhysicalDeviceCopyMemoryIndirectFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV, - ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV, - eComputePipelineIndirectBufferInfoNV = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV, - ePipelineIndirectDeviceAddressInfoNV = VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV, - ePhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV, - eAccelerationStructureGeometryLinearSweptSpheresDataNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV, - eAccelerationStructureGeometrySpheresDataNV = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV, - ePhysicalDeviceLinearColorAttachmentFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV, - ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR, - ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT, - ePhysicalDeviceImageProcessingFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM, - ePhysicalDeviceImageProcessingPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM, - eImageViewSampleWeightCreateInfoQCOM = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM, - ePhysicalDeviceNestedCommandBufferFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT, - ePhysicalDeviceNestedCommandBufferPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT, -#if defined( VK_USE_PLATFORM_OHOS ) - eNativeBufferUsageOHOS = VK_STRUCTURE_TYPE_NATIVE_BUFFER_USAGE_OHOS, - eNativeBufferPropertiesOHOS = VK_STRUCTURE_TYPE_NATIVE_BUFFER_PROPERTIES_OHOS, - eNativeBufferFormatPropertiesOHOS = VK_STRUCTURE_TYPE_NATIVE_BUFFER_FORMAT_PROPERTIES_OHOS, - eImportNativeBufferInfoOHOS = VK_STRUCTURE_TYPE_IMPORT_NATIVE_BUFFER_INFO_OHOS, - eMemoryGetNativeBufferInfoOHOS = VK_STRUCTURE_TYPE_MEMORY_GET_NATIVE_BUFFER_INFO_OHOS, - eExternalFormatOHOS = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_OHOS, -#endif /*VK_USE_PLATFORM_OHOS*/ - eExternalMemoryAcquireUnmodifiedEXT = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT, - ePhysicalDeviceExtendedDynamicState3FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT, - ePhysicalDeviceExtendedDynamicState3PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT, - ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT, - eRenderPassCreationControlEXT = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT, - eRenderPassCreationFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT, - eRenderPassSubpassFeedbackCreateInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT, - eDirectDriverLoadingInfoLUNARG = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG, - eDirectDriverLoadingListLUNARG = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG, - eTensorCreateInfoARM = VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM, - eTensorViewCreateInfoARM = VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM, - eBindTensorMemoryInfoARM = VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM, - eWriteDescriptorSetTensorARM = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM, - ePhysicalDeviceTensorPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM, - eTensorFormatPropertiesARM = VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM, - eTensorDescriptionARM = VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM, - eTensorMemoryRequirementsInfoARM = VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM, - eTensorMemoryBarrierARM = VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM, - ePhysicalDeviceTensorFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM, - eDeviceTensorMemoryRequirementsARM = VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM, - eCopyTensorInfoARM = VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM, - eTensorCopyARM = VK_STRUCTURE_TYPE_TENSOR_COPY_ARM, - eTensorDependencyInfoARM = VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM, - eMemoryDedicatedAllocateInfoTensorARM = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM, - ePhysicalDeviceExternalTensorInfoARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM, - eExternalTensorPropertiesARM = VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM, - eExternalMemoryTensorCreateInfoARM = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM, - ePhysicalDeviceDescriptorBufferTensorFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM, - ePhysicalDeviceDescriptorBufferTensorPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM, - eDescriptorGetTensorInfoARM = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM, - eTensorCaptureDescriptorDataInfoARM = VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM, - eTensorViewCaptureDescriptorDataInfoARM = VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM, - eFrameBoundaryTensorsARM = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM, - ePhysicalDeviceShaderModuleIdentifierFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT, - ePhysicalDeviceShaderModuleIdentifierPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT, - ePipelineShaderStageModuleIdentifierCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT, - eShaderModuleIdentifierEXT = VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT, - ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, - ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM, - ePhysicalDeviceOpticalFlowFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV, - ePhysicalDeviceOpticalFlowPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV, - eOpticalFlowImageFormatInfoNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV, - eOpticalFlowImageFormatPropertiesNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV, - eOpticalFlowSessionCreateInfoNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV, - eOpticalFlowExecuteInfoNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV, - eOpticalFlowSessionCreatePrivateDataInfoNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV, - ePhysicalDeviceLegacyDitheringFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT, -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - ePhysicalDeviceExternalFormatResolveFeaturesANDROID = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID, - ePhysicalDeviceExternalFormatResolvePropertiesANDROID = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID, - eAndroidHardwareBufferFormatResolvePropertiesANDROID = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID, -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - ePhysicalDeviceAntiLagFeaturesAMD = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD, - eAntiLagDataAMD = VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD, - eAntiLagPresentationInfoAMD = VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - ePhysicalDeviceDenseGeometryFormatFeaturesAMDX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DENSE_GEOMETRY_FORMAT_FEATURES_AMDX, - eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DENSE_GEOMETRY_FORMAT_TRIANGLES_DATA_AMDX, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eSurfaceCapabilitiesPresentId2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR, - ePresentId2KHR = VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR, - ePhysicalDevicePresentId2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR, - eSurfaceCapabilitiesPresentWait2KHR = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR, - ePhysicalDevicePresentWait2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR, - ePresentWait2InfoKHR = VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR, - ePhysicalDeviceRayTracingPositionFetchFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR, - ePhysicalDeviceShaderObjectFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, - ePhysicalDeviceShaderObjectPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT, - eShaderCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT, - ePhysicalDevicePipelineBinaryFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR, - ePipelineBinaryCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR, - ePipelineBinaryInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR, - ePipelineBinaryKeyKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR, - ePhysicalDevicePipelineBinaryPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR, - eReleaseCapturedPipelineDataInfoKHR = VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR, - ePipelineBinaryDataInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR, - ePipelineCreateInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR, - eDevicePipelineBinaryInternalCacheControlKHR = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR, - ePipelineBinaryHandlesInfoKHR = VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR, - ePhysicalDeviceTilePropertiesFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM, - eTilePropertiesQCOM = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM, - ePhysicalDeviceAmigoProfilingFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, - eAmigoProfilingSubmitInfoSEC = VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC, - eSurfacePresentModeKHR = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR, - eSurfacePresentModeEXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT, - eSurfacePresentScalingCapabilitiesKHR = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR, - eSurfacePresentScalingCapabilitiesEXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT, - eSurfacePresentModeCompatibilityKHR = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR, - eSurfacePresentModeCompatibilityEXT = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT, - ePhysicalDeviceSwapchainMaintenance1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR, - ePhysicalDeviceSwapchainMaintenance1FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT, - eSwapchainPresentFenceInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR, - eSwapchainPresentFenceInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT, - eSwapchainPresentModesCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR, - eSwapchainPresentModesCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT, - eSwapchainPresentModeInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR, - eSwapchainPresentModeInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT, - eSwapchainPresentScalingCreateInfoKHR = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR, - eSwapchainPresentScalingCreateInfoEXT = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT, - eReleaseSwapchainImagesInfoKHR = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR, - eReleaseSwapchainImagesInfoEXT = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT, - ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM, - ePhysicalDeviceRayTracingInvocationReorderFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV, - ePhysicalDeviceRayTracingInvocationReorderPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV, - ePhysicalDeviceCooperativeVectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV, - ePhysicalDeviceCooperativeVectorPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV, - eCooperativeVectorPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV, - eConvertCooperativeVectorMatrixInfoNV = VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV, - ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV, - ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV, - ePhysicalDeviceMutableDescriptorTypeFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, - ePhysicalDeviceMutableDescriptorTypeFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE, - eMutableDescriptorTypeCreateInfoEXT = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, - eMutableDescriptorTypeCreateInfoVALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE, - ePhysicalDeviceLegacyVertexAttributesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT, - ePhysicalDeviceLegacyVertexAttributesPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT, - eLayerSettingsCreateInfoEXT = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT, - ePhysicalDeviceShaderCoreBuiltinsFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM, - ePhysicalDeviceShaderCoreBuiltinsPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM, - ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT, - ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT, - ePhysicalDeviceInternallySynchronizedQueuesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR, - eLatencySleepModeInfoNV = VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV, - eLatencySleepInfoNV = VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV, - eSetLatencyMarkerInfoNV = VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV, - eGetLatencyMarkerInfoNV = VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV, - eLatencyTimingsFrameReportNV = VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV, - eLatencySubmissionPresentIdNV = VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV, - eOutOfBandQueueTypeInfoNV = VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV, - eSwapchainLatencyCreateInfoNV = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV, - eLatencySurfaceCapabilitiesNV = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV, - ePhysicalDeviceCooperativeMatrixFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR, - eCooperativeMatrixPropertiesKHR = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR, - ePhysicalDeviceCooperativeMatrixPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR, - eDataGraphPipelineCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM, - eDataGraphPipelineSessionCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM, - eDataGraphPipelineResourceInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM, - eDataGraphPipelineConstantARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM, - eDataGraphPipelineSessionMemoryRequirementsInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM, - eBindDataGraphPipelineSessionMemoryInfoARM = VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM, - ePhysicalDeviceDataGraphFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM, - eDataGraphPipelineShaderModuleCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM, - eDataGraphPipelinePropertyQueryResultARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM, - eDataGraphPipelineInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM, - eDataGraphPipelineCompilerControlCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM, - eDataGraphPipelineSessionBindPointRequirementsInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM, - eDataGraphPipelineSessionBindPointRequirementARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM, - eDataGraphPipelineIdentifierCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM, - eDataGraphPipelineDispatchInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM, - eDataGraphProcessingEngineCreateInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM, - eQueueFamilyDataGraphProcessingEnginePropertiesARM = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM, - eQueueFamilyDataGraphPropertiesARM = VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM, - ePhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM, - eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM, - ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM, - eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM, - ePhysicalDeviceComputeShaderDerivativesFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR, - ePhysicalDeviceComputeShaderDerivativesFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, - ePhysicalDeviceComputeShaderDerivativesPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR, - eVideoDecodeAv1CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR, - eVideoDecodeAv1PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR, - eVideoDecodeAv1ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR, - eVideoDecodeAv1SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR, - eVideoDecodeAv1DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR, - eVideoEncodeAv1CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR, - eVideoEncodeAv1SessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR, - eVideoEncodeAv1PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR, - eVideoEncodeAv1DpbSlotInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR, - ePhysicalDeviceVideoEncodeAv1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR, - eVideoEncodeAv1ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR, - eVideoEncodeAv1RateControlInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR, - eVideoEncodeAv1RateControlLayerInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR, - eVideoEncodeAv1QualityLevelPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR, - eVideoEncodeAv1SessionCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR, - eVideoEncodeAv1GopRemainingFrameInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR, - ePhysicalDeviceVideoDecodeVp9FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR, - eVideoDecodeVp9CapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR, - eVideoDecodeVp9PictureInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR, - eVideoDecodeVp9ProfileInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR, - ePhysicalDeviceVideoMaintenance1FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR, - eVideoInlineQueryInfoKHR = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR, - ePhysicalDevicePerStageDescriptorSetFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV, - ePhysicalDeviceImageProcessing2FeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM, - ePhysicalDeviceImageProcessing2PropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM, - eSamplerBlockMatchWindowCreateInfoQCOM = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM, - eSamplerCubicWeightsCreateInfoQCOM = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM, - ePhysicalDeviceCubicWeightsFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM, - eBlitImageCubicWeightsInfoQCOM = VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM, - ePhysicalDeviceYcbcrDegammaFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM, - eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM, - ePhysicalDeviceCubicClampFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM, - ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT, - ePhysicalDeviceUnifiedImageLayoutsFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR, - eAttachmentFeedbackLoopInfoEXT = VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT, -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - eScreenBufferPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX, - eScreenBufferFormatPropertiesQNX = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX, - eImportScreenBufferInfoQNX = VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX, - eExternalFormatQNX = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX, - ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX, -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - ePhysicalDeviceLayeredDriverPropertiesMSFT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT, - eCalibratedTimestampInfoKHR = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR, - eCalibratedTimestampInfoEXT = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, - eSetDescriptorBufferOffsetsInfoEXT = VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT, - eBindDescriptorBufferEmbeddedSamplersInfoEXT = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT, - ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV, - ePhysicalDeviceTileMemoryHeapFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM, - ePhysicalDeviceTileMemoryHeapPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM, - eTileMemoryRequirementsQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM, - eTileMemoryBindInfoQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM, - eTileMemorySizeInfoQCOM = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM, - ePhysicalDeviceCopyMemoryIndirectFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR, - ePhysicalDeviceCopyMemoryIndirectPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR, - ePhysicalDeviceCopyMemoryIndirectPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV, - eCopyMemoryIndirectInfoKHR = VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR, - eCopyMemoryToImageIndirectInfoKHR = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR, - ePhysicalDeviceMemoryDecompressionFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT, - ePhysicalDeviceMemoryDecompressionFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV, - ePhysicalDeviceMemoryDecompressionPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT, - ePhysicalDeviceMemoryDecompressionPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV, - eDecompressMemoryInfoEXT = VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT, - eDisplaySurfaceStereoCreateInfoNV = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV, - eDisplayModeStereoPropertiesNV = VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV, - eVideoEncodeIntraRefreshCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR, - eVideoEncodeSessionIntraRefreshCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR, - eVideoEncodeIntraRefreshInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR, - eVideoReferenceIntraRefreshInfoKHR = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR, - ePhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR, - eVideoEncodeQuantizationMapCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR, - eVideoFormatQuantizationMapPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR, - eVideoEncodeQuantizationMapInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR, - eVideoEncodeQuantizationMapSessionParametersCreateInfoKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR, - ePhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR, - eVideoEncodeH264QuantizationMapCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR, - eVideoEncodeH265QuantizationMapCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR, - eVideoFormatH265QuantizationMapPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR, - eVideoEncodeAv1QuantizationMapCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR, - eVideoFormatAv1QuantizationMapPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR, - ePhysicalDeviceRawAccessChainsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV, - eExternalComputeQueueDeviceCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV, - eExternalComputeQueueCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV, - eExternalComputeQueueDataParamsNV = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV, - ePhysicalDeviceExternalComputeQueuePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV, - ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR, - ePhysicalDeviceCommandBufferInheritanceFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV, - ePhysicalDeviceMaintenance7FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR, - ePhysicalDeviceMaintenance7PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR, - ePhysicalDeviceLayeredApiPropertiesListKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR, - ePhysicalDeviceLayeredApiPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR, - ePhysicalDeviceLayeredApiVulkanPropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR, - ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV, - ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT, - ePhysicalDeviceShaderFloat8FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT, - ePhysicalDeviceRayTracingValidationFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV, - ePhysicalDeviceClusterAccelerationStructureFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV, - ePhysicalDeviceClusterAccelerationStructurePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV, - eClusterAccelerationStructureClustersBottomLevelInputNV = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV, - eClusterAccelerationStructureTriangleClusterInputNV = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV, - eClusterAccelerationStructureMoveObjectsInputNV = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV, - eClusterAccelerationStructureInputInfoNV = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV, - eClusterAccelerationStructureCommandsInfoNV = VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV, - eRayTracingPipelineClusterAccelerationStructureCreateInfoNV = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV, - ePhysicalDevicePartitionedAccelerationStructureFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV, - ePhysicalDevicePartitionedAccelerationStructurePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV, - eWriteDescriptorSetPartitionedAccelerationStructureNV = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV, - ePartitionedAccelerationStructureInstancesInputNV = VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV, - eBuildPartitionedAccelerationStructureInfoNV = VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV, - ePartitionedAccelerationStructureFlagsNV = VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV, - ePhysicalDeviceDeviceGeneratedCommandsFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT, - ePhysicalDeviceDeviceGeneratedCommandsPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT, - eGeneratedCommandsMemoryRequirementsInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT, - eIndirectExecutionSetCreateInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT, - eGeneratedCommandsInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT, - eIndirectCommandsLayoutCreateInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT, - eIndirectCommandsLayoutTokenEXT = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT, - eWriteIndirectExecutionSetPipelineEXT = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT, - eWriteIndirectExecutionSetShaderEXT = VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT, - eIndirectExecutionSetPipelineInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT, - eIndirectExecutionSetShaderInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT, - eIndirectExecutionSetShaderLayoutInfoEXT = VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT, - eGeneratedCommandsPipelineInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT, - eGeneratedCommandsShaderInfoEXT = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT, - ePhysicalDeviceMaintenance8FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR, - eMemoryBarrierAccessFlags3KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR, - ePhysicalDeviceImageAlignmentControlFeaturesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA, - ePhysicalDeviceImageAlignmentControlPropertiesMESA = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA, - eImageAlignmentControlCreateInfoMESA = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA, - ePhysicalDeviceShaderFmaFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR, - ePushConstantBankInfoNV = VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV, - ePhysicalDevicePushConstantBankFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV, - ePhysicalDevicePushConstantBankPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV, - ePhysicalDeviceRayTracingInvocationReorderFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT, - ePhysicalDeviceRayTracingInvocationReorderPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT, - ePhysicalDeviceDepthClampControlFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT, - ePipelineViewportDepthClampControlCreateInfoEXT = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT, - ePhysicalDeviceMaintenance9FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR, - ePhysicalDeviceMaintenance9PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR, - eQueueFamilyOwnershipTransferPropertiesKHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR, - ePhysicalDeviceVideoMaintenance2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR, - eVideoDecodeH264InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR, - eVideoDecodeH265InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR, - eVideoDecodeAv1InlineSessionParametersInfoKHR = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR, -#if defined( VK_USE_PLATFORM_OHOS ) - eSurfaceCreateInfoOHOS = VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS, -#endif /*VK_USE_PLATFORM_OHOS*/ - ePhysicalDeviceHdrVividFeaturesHUAWEI = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI, - eHdrVividDynamicMetadataHUAWEI = VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI, - ePhysicalDeviceCooperativeMatrix2FeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV, - eCooperativeMatrixFlexibleDimensionsPropertiesNV = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV, - ePhysicalDeviceCooperativeMatrix2PropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV, - ePhysicalDevicePipelineOpacityMicromapFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM, -#if defined( VK_USE_PLATFORM_METAL_EXT ) - eImportMemoryMetalHandleInfoEXT = VK_STRUCTURE_TYPE_IMPORT_MEMORY_METAL_HANDLE_INFO_EXT, - eMemoryMetalHandlePropertiesEXT = VK_STRUCTURE_TYPE_MEMORY_METAL_HANDLE_PROPERTIES_EXT, - eMemoryGetMetalHandleInfoEXT = VK_STRUCTURE_TYPE_MEMORY_GET_METAL_HANDLE_INFO_EXT, -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - ePhysicalDeviceDepthClampZeroOneFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR, - ePhysicalDeviceDepthClampZeroOneFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT, - ePhysicalDevicePerformanceCountersByRegionFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM, - ePhysicalDevicePerformanceCountersByRegionPropertiesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM, - ePerformanceCounterARM = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM, - ePerformanceCounterDescriptionARM = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM, - eRenderPassPerformanceCountersByRegionBeginInfoARM = VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM, - ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT, - ePhysicalDeviceFormatPackFeaturesARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM, - ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE, - ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE, - ePipelineFragmentDensityMapLayeredCreateInfoVALVE = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE, - ePhysicalDeviceRobustness2FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR, - ePhysicalDeviceRobustness2FeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, - ePhysicalDeviceRobustness2PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR, - ePhysicalDeviceRobustness2PropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eSetPresentConfigNV = VK_STRUCTURE_TYPE_SET_PRESENT_CONFIG_NV, - ePhysicalDevicePresentMeteringFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_METERING_FEATURES_NV, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT, - ePhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM, - ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT, - ePhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM, - eRenderPassFragmentDensityMapOffsetEndInfoEXT = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT, - eSubpassFragmentDensityMapOffsetEndInfoQCOM = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM, - ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT, - ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR, - ePhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT, - ePhysicalDeviceShader64BitIndexingFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT, - ePhysicalDeviceCustomResolveFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT, - eBeginCustomResolveInfoEXT = VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT, - eCustomResolveCreateInfoEXT = VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT, - ePhysicalDeviceDataGraphModelFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM, - eDataGraphPipelineBuiltinModelCreateInfoQCOM = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM, - ePhysicalDeviceMaintenance10FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR, - ePhysicalDeviceMaintenance10PropertiesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR, - eRenderingAttachmentFlagsInfoKHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR, - eRenderingEndInfoKHR = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR, - eRenderingEndInfoEXT = VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT, - eResolveImageModeInfoKHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR, - ePhysicalDeviceShaderLongVectorFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT, - ePhysicalDeviceShaderLongVectorPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT, - ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC, - ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT, - eComputeOccupancyPriorityParametersNV = VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV, - ePhysicalDeviceComputeOccupancyPriorityFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV, - ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT - }; - - // wrapper class for enum VkObjectType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkObjectType.html - enum class ObjectType - { - eUnknown = VK_OBJECT_TYPE_UNKNOWN, - eInstance = VK_OBJECT_TYPE_INSTANCE, - ePhysicalDevice = VK_OBJECT_TYPE_PHYSICAL_DEVICE, - eDevice = VK_OBJECT_TYPE_DEVICE, - eQueue = VK_OBJECT_TYPE_QUEUE, - eSemaphore = VK_OBJECT_TYPE_SEMAPHORE, - eCommandBuffer = VK_OBJECT_TYPE_COMMAND_BUFFER, - eFence = VK_OBJECT_TYPE_FENCE, - eDeviceMemory = VK_OBJECT_TYPE_DEVICE_MEMORY, - eBuffer = VK_OBJECT_TYPE_BUFFER, - eImage = VK_OBJECT_TYPE_IMAGE, - eEvent = VK_OBJECT_TYPE_EVENT, - eQueryPool = VK_OBJECT_TYPE_QUERY_POOL, - eBufferView = VK_OBJECT_TYPE_BUFFER_VIEW, - eImageView = VK_OBJECT_TYPE_IMAGE_VIEW, - eShaderModule = VK_OBJECT_TYPE_SHADER_MODULE, - ePipelineCache = VK_OBJECT_TYPE_PIPELINE_CACHE, - ePipelineLayout = VK_OBJECT_TYPE_PIPELINE_LAYOUT, - eRenderPass = VK_OBJECT_TYPE_RENDER_PASS, - ePipeline = VK_OBJECT_TYPE_PIPELINE, - eDescriptorSetLayout = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, - eSampler = VK_OBJECT_TYPE_SAMPLER, - eDescriptorPool = VK_OBJECT_TYPE_DESCRIPTOR_POOL, - eDescriptorSet = VK_OBJECT_TYPE_DESCRIPTOR_SET, - eFramebuffer = VK_OBJECT_TYPE_FRAMEBUFFER, - eCommandPool = VK_OBJECT_TYPE_COMMAND_POOL, - eDescriptorUpdateTemplate = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, - eDescriptorUpdateTemplateKHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, - eSamplerYcbcrConversion = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, - eSamplerYcbcrConversionKHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR, - ePrivateDataSlot = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, - ePrivateDataSlotEXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT, - eSurfaceKHR = VK_OBJECT_TYPE_SURFACE_KHR, - eSwapchainKHR = VK_OBJECT_TYPE_SWAPCHAIN_KHR, - eDisplayKHR = VK_OBJECT_TYPE_DISPLAY_KHR, - eDisplayModeKHR = VK_OBJECT_TYPE_DISPLAY_MODE_KHR, - eDebugReportCallbackEXT = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, - eVideoSessionKHR = VK_OBJECT_TYPE_VIDEO_SESSION_KHR, - eVideoSessionParametersKHR = VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR, - eCuModuleNVX = VK_OBJECT_TYPE_CU_MODULE_NVX, - eCuFunctionNVX = VK_OBJECT_TYPE_CU_FUNCTION_NVX, - eDebugUtilsMessengerEXT = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, - eAccelerationStructureKHR = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR, - eValidationCacheEXT = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT, - eAccelerationStructureNV = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV, - ePerformanceConfigurationINTEL = VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL, - eDeferredOperationKHR = VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR, - eIndirectCommandsLayoutNV = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eCudaModuleNV = VK_OBJECT_TYPE_CUDA_MODULE_NV, - eCudaFunctionNV = VK_OBJECT_TYPE_CUDA_FUNCTION_NV, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ -#if defined( VK_USE_PLATFORM_FUCHSIA ) - eBufferCollectionFUCHSIA = VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA, -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - eMicromapEXT = VK_OBJECT_TYPE_MICROMAP_EXT, - eTensorARM = VK_OBJECT_TYPE_TENSOR_ARM, - eTensorViewARM = VK_OBJECT_TYPE_TENSOR_VIEW_ARM, - eOpticalFlowSessionNV = VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV, - eShaderEXT = VK_OBJECT_TYPE_SHADER_EXT, - ePipelineBinaryKHR = VK_OBJECT_TYPE_PIPELINE_BINARY_KHR, - eDataGraphPipelineSessionARM = VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM, - eExternalComputeQueueNV = VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV, - eIndirectCommandsLayoutEXT = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT, - eIndirectExecutionSetEXT = VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT - }; - - // wrapper class for enum VkVendorId, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVendorId.html - enum class VendorId - { - eKhronos = VK_VENDOR_ID_KHRONOS, - eVIV = VK_VENDOR_ID_VIV, - eVSI = VK_VENDOR_ID_VSI, - eKazan = VK_VENDOR_ID_KAZAN, - eCodeplay = VK_VENDOR_ID_CODEPLAY, - eMESA = VK_VENDOR_ID_MESA, - ePocl = VK_VENDOR_ID_POCL, - eMobileye = VK_VENDOR_ID_MOBILEYE - }; - - // wrapper class for enum VkFormat, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormat.html - enum class Format - { - eUndefined = VK_FORMAT_UNDEFINED, - eR4G4UnormPack8 = VK_FORMAT_R4G4_UNORM_PACK8, - eR4G4B4A4UnormPack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16, - eB4G4R4A4UnormPack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16, - eR5G6B5UnormPack16 = VK_FORMAT_R5G6B5_UNORM_PACK16, - eB5G6R5UnormPack16 = VK_FORMAT_B5G6R5_UNORM_PACK16, - eR5G5B5A1UnormPack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16, - eB5G5R5A1UnormPack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16, - eA1R5G5B5UnormPack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16, - eR8Unorm = VK_FORMAT_R8_UNORM, - eR8Snorm = VK_FORMAT_R8_SNORM, - eR8Uscaled = VK_FORMAT_R8_USCALED, - eR8Sscaled = VK_FORMAT_R8_SSCALED, - eR8Uint = VK_FORMAT_R8_UINT, - eR8Sint = VK_FORMAT_R8_SINT, - eR8Srgb = VK_FORMAT_R8_SRGB, - eR8G8Unorm = VK_FORMAT_R8G8_UNORM, - eR8G8Snorm = VK_FORMAT_R8G8_SNORM, - eR8G8Uscaled = VK_FORMAT_R8G8_USCALED, - eR8G8Sscaled = VK_FORMAT_R8G8_SSCALED, - eR8G8Uint = VK_FORMAT_R8G8_UINT, - eR8G8Sint = VK_FORMAT_R8G8_SINT, - eR8G8Srgb = VK_FORMAT_R8G8_SRGB, - eR8G8B8Unorm = VK_FORMAT_R8G8B8_UNORM, - eR8G8B8Snorm = VK_FORMAT_R8G8B8_SNORM, - eR8G8B8Uscaled = VK_FORMAT_R8G8B8_USCALED, - eR8G8B8Sscaled = VK_FORMAT_R8G8B8_SSCALED, - eR8G8B8Uint = VK_FORMAT_R8G8B8_UINT, - eR8G8B8Sint = VK_FORMAT_R8G8B8_SINT, - eR8G8B8Srgb = VK_FORMAT_R8G8B8_SRGB, - eB8G8R8Unorm = VK_FORMAT_B8G8R8_UNORM, - eB8G8R8Snorm = VK_FORMAT_B8G8R8_SNORM, - eB8G8R8Uscaled = VK_FORMAT_B8G8R8_USCALED, - eB8G8R8Sscaled = VK_FORMAT_B8G8R8_SSCALED, - eB8G8R8Uint = VK_FORMAT_B8G8R8_UINT, - eB8G8R8Sint = VK_FORMAT_B8G8R8_SINT, - eB8G8R8Srgb = VK_FORMAT_B8G8R8_SRGB, - eR8G8B8A8Unorm = VK_FORMAT_R8G8B8A8_UNORM, - eR8G8B8A8Snorm = VK_FORMAT_R8G8B8A8_SNORM, - eR8G8B8A8Uscaled = VK_FORMAT_R8G8B8A8_USCALED, - eR8G8B8A8Sscaled = VK_FORMAT_R8G8B8A8_SSCALED, - eR8G8B8A8Uint = VK_FORMAT_R8G8B8A8_UINT, - eR8G8B8A8Sint = VK_FORMAT_R8G8B8A8_SINT, - eR8G8B8A8Srgb = VK_FORMAT_R8G8B8A8_SRGB, - eB8G8R8A8Unorm = VK_FORMAT_B8G8R8A8_UNORM, - eB8G8R8A8Snorm = VK_FORMAT_B8G8R8A8_SNORM, - eB8G8R8A8Uscaled = VK_FORMAT_B8G8R8A8_USCALED, - eB8G8R8A8Sscaled = VK_FORMAT_B8G8R8A8_SSCALED, - eB8G8R8A8Uint = VK_FORMAT_B8G8R8A8_UINT, - eB8G8R8A8Sint = VK_FORMAT_B8G8R8A8_SINT, - eB8G8R8A8Srgb = VK_FORMAT_B8G8R8A8_SRGB, - eA8B8G8R8UnormPack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32, - eA8B8G8R8SnormPack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32, - eA8B8G8R8UscaledPack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32, - eA8B8G8R8SscaledPack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32, - eA8B8G8R8UintPack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32, - eA8B8G8R8SintPack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32, - eA8B8G8R8SrgbPack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32, - eA2R10G10B10UnormPack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32, - eA2R10G10B10SnormPack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32, - eA2R10G10B10UscaledPack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32, - eA2R10G10B10SscaledPack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32, - eA2R10G10B10UintPack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32, - eA2R10G10B10SintPack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32, - eA2B10G10R10UnormPack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32, - eA2B10G10R10SnormPack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32, - eA2B10G10R10UscaledPack32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32, - eA2B10G10R10SscaledPack32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32, - eA2B10G10R10UintPack32 = VK_FORMAT_A2B10G10R10_UINT_PACK32, - eA2B10G10R10SintPack32 = VK_FORMAT_A2B10G10R10_SINT_PACK32, - eR16Unorm = VK_FORMAT_R16_UNORM, - eR16Snorm = VK_FORMAT_R16_SNORM, - eR16Uscaled = VK_FORMAT_R16_USCALED, - eR16Sscaled = VK_FORMAT_R16_SSCALED, - eR16Uint = VK_FORMAT_R16_UINT, - eR16Sint = VK_FORMAT_R16_SINT, - eR16Sfloat = VK_FORMAT_R16_SFLOAT, - eR16G16Unorm = VK_FORMAT_R16G16_UNORM, - eR16G16Snorm = VK_FORMAT_R16G16_SNORM, - eR16G16Uscaled = VK_FORMAT_R16G16_USCALED, - eR16G16Sscaled = VK_FORMAT_R16G16_SSCALED, - eR16G16Uint = VK_FORMAT_R16G16_UINT, - eR16G16Sint = VK_FORMAT_R16G16_SINT, - eR16G16Sfloat = VK_FORMAT_R16G16_SFLOAT, - eR16G16B16Unorm = VK_FORMAT_R16G16B16_UNORM, - eR16G16B16Snorm = VK_FORMAT_R16G16B16_SNORM, - eR16G16B16Uscaled = VK_FORMAT_R16G16B16_USCALED, - eR16G16B16Sscaled = VK_FORMAT_R16G16B16_SSCALED, - eR16G16B16Uint = VK_FORMAT_R16G16B16_UINT, - eR16G16B16Sint = VK_FORMAT_R16G16B16_SINT, - eR16G16B16Sfloat = VK_FORMAT_R16G16B16_SFLOAT, - eR16G16B16A16Unorm = VK_FORMAT_R16G16B16A16_UNORM, - eR16G16B16A16Snorm = VK_FORMAT_R16G16B16A16_SNORM, - eR16G16B16A16Uscaled = VK_FORMAT_R16G16B16A16_USCALED, - eR16G16B16A16Sscaled = VK_FORMAT_R16G16B16A16_SSCALED, - eR16G16B16A16Uint = VK_FORMAT_R16G16B16A16_UINT, - eR16G16B16A16Sint = VK_FORMAT_R16G16B16A16_SINT, - eR16G16B16A16Sfloat = VK_FORMAT_R16G16B16A16_SFLOAT, - eR32Uint = VK_FORMAT_R32_UINT, - eR32Sint = VK_FORMAT_R32_SINT, - eR32Sfloat = VK_FORMAT_R32_SFLOAT, - eR32G32Uint = VK_FORMAT_R32G32_UINT, - eR32G32Sint = VK_FORMAT_R32G32_SINT, - eR32G32Sfloat = VK_FORMAT_R32G32_SFLOAT, - eR32G32B32Uint = VK_FORMAT_R32G32B32_UINT, - eR32G32B32Sint = VK_FORMAT_R32G32B32_SINT, - eR32G32B32Sfloat = VK_FORMAT_R32G32B32_SFLOAT, - eR32G32B32A32Uint = VK_FORMAT_R32G32B32A32_UINT, - eR32G32B32A32Sint = VK_FORMAT_R32G32B32A32_SINT, - eR32G32B32A32Sfloat = VK_FORMAT_R32G32B32A32_SFLOAT, - eR64Uint = VK_FORMAT_R64_UINT, - eR64Sint = VK_FORMAT_R64_SINT, - eR64Sfloat = VK_FORMAT_R64_SFLOAT, - eR64G64Uint = VK_FORMAT_R64G64_UINT, - eR64G64Sint = VK_FORMAT_R64G64_SINT, - eR64G64Sfloat = VK_FORMAT_R64G64_SFLOAT, - eR64G64B64Uint = VK_FORMAT_R64G64B64_UINT, - eR64G64B64Sint = VK_FORMAT_R64G64B64_SINT, - eR64G64B64Sfloat = VK_FORMAT_R64G64B64_SFLOAT, - eR64G64B64A64Uint = VK_FORMAT_R64G64B64A64_UINT, - eR64G64B64A64Sint = VK_FORMAT_R64G64B64A64_SINT, - eR64G64B64A64Sfloat = VK_FORMAT_R64G64B64A64_SFLOAT, - eB10G11R11UfloatPack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32, - eE5B9G9R9UfloatPack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, - eD16Unorm = VK_FORMAT_D16_UNORM, - eX8D24UnormPack32 = VK_FORMAT_X8_D24_UNORM_PACK32, - eD32Sfloat = VK_FORMAT_D32_SFLOAT, - eS8Uint = VK_FORMAT_S8_UINT, - eD16UnormS8Uint = VK_FORMAT_D16_UNORM_S8_UINT, - eD24UnormS8Uint = VK_FORMAT_D24_UNORM_S8_UINT, - eD32SfloatS8Uint = VK_FORMAT_D32_SFLOAT_S8_UINT, - eBc1RgbUnormBlock = VK_FORMAT_BC1_RGB_UNORM_BLOCK, - eBc1RgbSrgbBlock = VK_FORMAT_BC1_RGB_SRGB_BLOCK, - eBc1RgbaUnormBlock = VK_FORMAT_BC1_RGBA_UNORM_BLOCK, - eBc1RgbaSrgbBlock = VK_FORMAT_BC1_RGBA_SRGB_BLOCK, - eBc2UnormBlock = VK_FORMAT_BC2_UNORM_BLOCK, - eBc2SrgbBlock = VK_FORMAT_BC2_SRGB_BLOCK, - eBc3UnormBlock = VK_FORMAT_BC3_UNORM_BLOCK, - eBc3SrgbBlock = VK_FORMAT_BC3_SRGB_BLOCK, - eBc4UnormBlock = VK_FORMAT_BC4_UNORM_BLOCK, - eBc4SnormBlock = VK_FORMAT_BC4_SNORM_BLOCK, - eBc5UnormBlock = VK_FORMAT_BC5_UNORM_BLOCK, - eBc5SnormBlock = VK_FORMAT_BC5_SNORM_BLOCK, - eBc6HUfloatBlock = VK_FORMAT_BC6H_UFLOAT_BLOCK, - eBc6HSfloatBlock = VK_FORMAT_BC6H_SFLOAT_BLOCK, - eBc7UnormBlock = VK_FORMAT_BC7_UNORM_BLOCK, - eBc7SrgbBlock = VK_FORMAT_BC7_SRGB_BLOCK, - eEtc2R8G8B8UnormBlock = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, - eEtc2R8G8B8SrgbBlock = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, - eEtc2R8G8B8A1UnormBlock = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, - eEtc2R8G8B8A1SrgbBlock = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, - eEtc2R8G8B8A8UnormBlock = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, - eEtc2R8G8B8A8SrgbBlock = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, - eEacR11UnormBlock = VK_FORMAT_EAC_R11_UNORM_BLOCK, - eEacR11SnormBlock = VK_FORMAT_EAC_R11_SNORM_BLOCK, - eEacR11G11UnormBlock = VK_FORMAT_EAC_R11G11_UNORM_BLOCK, - eEacR11G11SnormBlock = VK_FORMAT_EAC_R11G11_SNORM_BLOCK, - eAstc4x4UnormBlock = VK_FORMAT_ASTC_4x4_UNORM_BLOCK, - eAstc4x4SrgbBlock = VK_FORMAT_ASTC_4x4_SRGB_BLOCK, - eAstc5x4UnormBlock = VK_FORMAT_ASTC_5x4_UNORM_BLOCK, - eAstc5x4SrgbBlock = VK_FORMAT_ASTC_5x4_SRGB_BLOCK, - eAstc5x5UnormBlock = VK_FORMAT_ASTC_5x5_UNORM_BLOCK, - eAstc5x5SrgbBlock = VK_FORMAT_ASTC_5x5_SRGB_BLOCK, - eAstc6x5UnormBlock = VK_FORMAT_ASTC_6x5_UNORM_BLOCK, - eAstc6x5SrgbBlock = VK_FORMAT_ASTC_6x5_SRGB_BLOCK, - eAstc6x6UnormBlock = VK_FORMAT_ASTC_6x6_UNORM_BLOCK, - eAstc6x6SrgbBlock = VK_FORMAT_ASTC_6x6_SRGB_BLOCK, - eAstc8x5UnormBlock = VK_FORMAT_ASTC_8x5_UNORM_BLOCK, - eAstc8x5SrgbBlock = VK_FORMAT_ASTC_8x5_SRGB_BLOCK, - eAstc8x6UnormBlock = VK_FORMAT_ASTC_8x6_UNORM_BLOCK, - eAstc8x6SrgbBlock = VK_FORMAT_ASTC_8x6_SRGB_BLOCK, - eAstc8x8UnormBlock = VK_FORMAT_ASTC_8x8_UNORM_BLOCK, - eAstc8x8SrgbBlock = VK_FORMAT_ASTC_8x8_SRGB_BLOCK, - eAstc10x5UnormBlock = VK_FORMAT_ASTC_10x5_UNORM_BLOCK, - eAstc10x5SrgbBlock = VK_FORMAT_ASTC_10x5_SRGB_BLOCK, - eAstc10x6UnormBlock = VK_FORMAT_ASTC_10x6_UNORM_BLOCK, - eAstc10x6SrgbBlock = VK_FORMAT_ASTC_10x6_SRGB_BLOCK, - eAstc10x8UnormBlock = VK_FORMAT_ASTC_10x8_UNORM_BLOCK, - eAstc10x8SrgbBlock = VK_FORMAT_ASTC_10x8_SRGB_BLOCK, - eAstc10x10UnormBlock = VK_FORMAT_ASTC_10x10_UNORM_BLOCK, - eAstc10x10SrgbBlock = VK_FORMAT_ASTC_10x10_SRGB_BLOCK, - eAstc12x10UnormBlock = VK_FORMAT_ASTC_12x10_UNORM_BLOCK, - eAstc12x10SrgbBlock = VK_FORMAT_ASTC_12x10_SRGB_BLOCK, - eAstc12x12UnormBlock = VK_FORMAT_ASTC_12x12_UNORM_BLOCK, - eAstc12x12SrgbBlock = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, - eG8B8G8R8422Unorm = VK_FORMAT_G8B8G8R8_422_UNORM, - eG8B8G8R8422UnormKHR = VK_FORMAT_G8B8G8R8_422_UNORM_KHR, - eB8G8R8G8422Unorm = VK_FORMAT_B8G8R8G8_422_UNORM, - eB8G8R8G8422UnormKHR = VK_FORMAT_B8G8R8G8_422_UNORM_KHR, - eG8B8R83Plane420Unorm = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, - eG8B8R83Plane420UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR, - eG8B8R82Plane420Unorm = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, - eG8B8R82Plane420UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR, - eG8B8R83Plane422Unorm = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, - eG8B8R83Plane422UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR, - eG8B8R82Plane422Unorm = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, - eG8B8R82Plane422UnormKHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR, - eG8B8R83Plane444Unorm = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, - eG8B8R83Plane444UnormKHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR, - eR10X6UnormPack16 = VK_FORMAT_R10X6_UNORM_PACK16, - eR10X6UnormPack16KHR = VK_FORMAT_R10X6_UNORM_PACK16_KHR, - eR10X6G10X6Unorm2Pack16 = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, - eR10X6G10X6Unorm2Pack16KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR, - eR10X6G10X6B10X6A10X6Unorm4Pack16 = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, - eR10X6G10X6B10X6A10X6Unorm4Pack16KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR, - eG10X6B10X6G10X6R10X6422Unorm4Pack16 = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, - eG10X6B10X6G10X6R10X6422Unorm4Pack16KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR, - eB10X6G10X6R10X6G10X6422Unorm4Pack16 = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, - eB10X6G10X6R10X6G10X6422Unorm4Pack16KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR, - eG10X6B10X6R10X63Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, - eG10X6B10X6R10X63Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR, - eG10X6B10X6R10X62Plane420Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, - eG10X6B10X6R10X62Plane420Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR, - eG10X6B10X6R10X63Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, - eG10X6B10X6R10X63Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR, - eG10X6B10X6R10X62Plane422Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, - eG10X6B10X6R10X62Plane422Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR, - eG10X6B10X6R10X63Plane444Unorm3Pack16 = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, - eG10X6B10X6R10X63Plane444Unorm3Pack16KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR, - eR12X4UnormPack16 = VK_FORMAT_R12X4_UNORM_PACK16, - eR12X4UnormPack16KHR = VK_FORMAT_R12X4_UNORM_PACK16_KHR, - eR12X4G12X4Unorm2Pack16 = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, - eR12X4G12X4Unorm2Pack16KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR, - eR12X4G12X4B12X4A12X4Unorm4Pack16 = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, - eR12X4G12X4B12X4A12X4Unorm4Pack16KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR, - eG12X4B12X4G12X4R12X4422Unorm4Pack16 = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, - eG12X4B12X4G12X4R12X4422Unorm4Pack16KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR, - eB12X4G12X4R12X4G12X4422Unorm4Pack16 = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, - eB12X4G12X4R12X4G12X4422Unorm4Pack16KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR, - eG12X4B12X4R12X43Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, - eG12X4B12X4R12X43Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR, - eG12X4B12X4R12X42Plane420Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, - eG12X4B12X4R12X42Plane420Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR, - eG12X4B12X4R12X43Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, - eG12X4B12X4R12X43Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR, - eG12X4B12X4R12X42Plane422Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, - eG12X4B12X4R12X42Plane422Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR, - eG12X4B12X4R12X43Plane444Unorm3Pack16 = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, - eG12X4B12X4R12X43Plane444Unorm3Pack16KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR, - eG16B16G16R16422Unorm = VK_FORMAT_G16B16G16R16_422_UNORM, - eG16B16G16R16422UnormKHR = VK_FORMAT_G16B16G16R16_422_UNORM_KHR, - eB16G16R16G16422Unorm = VK_FORMAT_B16G16R16G16_422_UNORM, - eB16G16R16G16422UnormKHR = VK_FORMAT_B16G16R16G16_422_UNORM_KHR, - eG16B16R163Plane420Unorm = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, - eG16B16R163Plane420UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR, - eG16B16R162Plane420Unorm = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, - eG16B16R162Plane420UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR, - eG16B16R163Plane422Unorm = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, - eG16B16R163Plane422UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR, - eG16B16R162Plane422Unorm = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, - eG16B16R162Plane422UnormKHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR, - eG16B16R163Plane444Unorm = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, - eG16B16R163Plane444UnormKHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR, - eG8B8R82Plane444Unorm = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, - eG8B8R82Plane444UnormEXT = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT, - eG10X6B10X6R10X62Plane444Unorm3Pack16 = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, - eG10X6B10X6R10X62Plane444Unorm3Pack16EXT = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT, - eG12X4B12X4R12X42Plane444Unorm3Pack16 = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, - eG12X4B12X4R12X42Plane444Unorm3Pack16EXT = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT, - eG16B16R162Plane444Unorm = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, - eG16B16R162Plane444UnormEXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT, - eA4R4G4B4UnormPack16 = VK_FORMAT_A4R4G4B4_UNORM_PACK16, - eA4R4G4B4UnormPack16EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, - eA4B4G4R4UnormPack16 = VK_FORMAT_A4B4G4R4_UNORM_PACK16, - eA4B4G4R4UnormPack16EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT, - eAstc4x4SfloatBlock = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, - eAstc4x4SfloatBlockEXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT, - eAstc5x4SfloatBlock = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, - eAstc5x4SfloatBlockEXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT, - eAstc5x5SfloatBlock = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, - eAstc5x5SfloatBlockEXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT, - eAstc6x5SfloatBlock = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK, - eAstc6x5SfloatBlockEXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT, - eAstc6x6SfloatBlock = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK, - eAstc6x6SfloatBlockEXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT, - eAstc8x5SfloatBlock = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK, - eAstc8x5SfloatBlockEXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT, - eAstc8x6SfloatBlock = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK, - eAstc8x6SfloatBlockEXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT, - eAstc8x8SfloatBlock = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK, - eAstc8x8SfloatBlockEXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT, - eAstc10x5SfloatBlock = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK, - eAstc10x5SfloatBlockEXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT, - eAstc10x6SfloatBlock = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK, - eAstc10x6SfloatBlockEXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT, - eAstc10x8SfloatBlock = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK, - eAstc10x8SfloatBlockEXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT, - eAstc10x10SfloatBlock = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK, - eAstc10x10SfloatBlockEXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT, - eAstc12x10SfloatBlock = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK, - eAstc12x10SfloatBlockEXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT, - eAstc12x12SfloatBlock = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, - eAstc12x12SfloatBlockEXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT, - eA1B5G5R5UnormPack16 = VK_FORMAT_A1B5G5R5_UNORM_PACK16, - eA1B5G5R5UnormPack16KHR = VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR, - eA8Unorm = VK_FORMAT_A8_UNORM, - eA8UnormKHR = VK_FORMAT_A8_UNORM_KHR, - ePvrtc12BppUnormBlockIMG = VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, - ePvrtc14BppUnormBlockIMG = VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, - ePvrtc22BppUnormBlockIMG = VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, - ePvrtc24BppUnormBlockIMG = VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, - ePvrtc12BppSrgbBlockIMG = VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, - ePvrtc14BppSrgbBlockIMG = VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, - ePvrtc22BppSrgbBlockIMG = VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, - ePvrtc24BppSrgbBlockIMG = VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG, - eAstc3x3x3UnormBlockEXT = VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT, - eAstc3x3x3SrgbBlockEXT = VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT, - eAstc3x3x3SfloatBlockEXT = VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT, - eAstc4x3x3UnormBlockEXT = VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT, - eAstc4x3x3SrgbBlockEXT = VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT, - eAstc4x3x3SfloatBlockEXT = VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT, - eAstc4x4x3UnormBlockEXT = VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT, - eAstc4x4x3SrgbBlockEXT = VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT, - eAstc4x4x3SfloatBlockEXT = VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT, - eAstc4x4x4UnormBlockEXT = VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT, - eAstc4x4x4SrgbBlockEXT = VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT, - eAstc4x4x4SfloatBlockEXT = VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT, - eAstc5x4x4UnormBlockEXT = VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT, - eAstc5x4x4SrgbBlockEXT = VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT, - eAstc5x4x4SfloatBlockEXT = VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT, - eAstc5x5x4UnormBlockEXT = VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT, - eAstc5x5x4SrgbBlockEXT = VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT, - eAstc5x5x4SfloatBlockEXT = VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT, - eAstc5x5x5UnormBlockEXT = VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT, - eAstc5x5x5SrgbBlockEXT = VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT, - eAstc5x5x5SfloatBlockEXT = VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT, - eAstc6x5x5UnormBlockEXT = VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT, - eAstc6x5x5SrgbBlockEXT = VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT, - eAstc6x5x5SfloatBlockEXT = VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT, - eAstc6x6x5UnormBlockEXT = VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT, - eAstc6x6x5SrgbBlockEXT = VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT, - eAstc6x6x5SfloatBlockEXT = VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT, - eAstc6x6x6UnormBlockEXT = VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT, - eAstc6x6x6SrgbBlockEXT = VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT, - eAstc6x6x6SfloatBlockEXT = VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT, - eR8BoolARM = VK_FORMAT_R8_BOOL_ARM, - eR16G16Sfixed5NV = VK_FORMAT_R16G16_SFIXED5_NV, - eR16G16S105NV = VK_FORMAT_R16G16_S10_5_NV, - eR10X6UintPack16ARM = VK_FORMAT_R10X6_UINT_PACK16_ARM, - eR10X6G10X6Uint2Pack16ARM = VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM, - eR10X6G10X6B10X6A10X6Uint4Pack16ARM = VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM, - eR12X4UintPack16ARM = VK_FORMAT_R12X4_UINT_PACK16_ARM, - eR12X4G12X4Uint2Pack16ARM = VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM, - eR12X4G12X4B12X4A12X4Uint4Pack16ARM = VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM, - eR14X2UintPack16ARM = VK_FORMAT_R14X2_UINT_PACK16_ARM, - eR14X2G14X2Uint2Pack16ARM = VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM, - eR14X2G14X2B14X2A14X2Uint4Pack16ARM = VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM, - eR14X2UnormPack16ARM = VK_FORMAT_R14X2_UNORM_PACK16_ARM, - eR14X2G14X2Unorm2Pack16ARM = VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM, - eR14X2G14X2B14X2A14X2Unorm4Pack16ARM = VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM, - eG14X2B14X2R14X22Plane420Unorm3Pack16ARM = VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM, - eG14X2B14X2R14X22Plane422Unorm3Pack16ARM = VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM - }; - - // wrapper class for enum VkFormatFeatureFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlagBits.html - enum class FormatFeatureFlagBits : VkFormatFeatureFlags - { - eSampledImage = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT, - eStorageImage = VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT, - eStorageImageAtomic = VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT, - eUniformTexelBuffer = VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT, - eStorageTexelBuffer = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT, - eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, - eVertexBuffer = VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT, - eColorAttachment = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT, - eColorAttachmentBlend = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, - eDepthStencilAttachment = VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT, - eBlitSrc = VK_FORMAT_FEATURE_BLIT_SRC_BIT, - eBlitDst = VK_FORMAT_FEATURE_BLIT_DST_BIT, - eSampledImageFilterLinear = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, - eTransferSrc = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, - eTransferSrcKHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR, - eTransferDst = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, - eTransferDstKHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR, - eMidpointChromaSamples = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, - eMidpointChromaSamplesKHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR, - eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, - eSampledImageYcbcrConversionLinearFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR, - eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, - eSampledImageYcbcrConversionSeparateReconstructionFilterKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR, - eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, - eSampledImageYcbcrConversionChromaReconstructionExplicitKHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR, - eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, - eSampledImageYcbcrConversionChromaReconstructionExplicitForceableKHR = - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR, - eDisjoint = VK_FORMAT_FEATURE_DISJOINT_BIT, - eDisjointKHR = VK_FORMAT_FEATURE_DISJOINT_BIT_KHR, - eCositedChromaSamples = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, - eCositedChromaSamplesKHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR, - eSampledImageFilterMinmax = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, - eSampledImageFilterMinmaxEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT, - eVideoDecodeOutputKHR = VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR, - eVideoDecodeDpbKHR = VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR, - eAccelerationStructureVertexBufferKHR = VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR, - eSampledImageFilterCubicEXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, - eSampledImageFilterCubicIMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG, - eFragmentDensityMapEXT = VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT, - eFragmentShadingRateAttachmentKHR = VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - eVideoEncodeInputKHR = VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR, - eVideoEncodeDpbKHR = VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR - }; - - // wrapper using for bitmask VkFormatFeatureFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlags.html - using FormatFeatureFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkFormatFeatureFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR FormatFeatureFlags allFlags = - FormatFeatureFlagBits::eSampledImage | FormatFeatureFlagBits::eStorageImage | FormatFeatureFlagBits::eStorageImageAtomic | - FormatFeatureFlagBits::eUniformTexelBuffer | FormatFeatureFlagBits::eStorageTexelBuffer | FormatFeatureFlagBits::eStorageTexelBufferAtomic | - FormatFeatureFlagBits::eVertexBuffer | FormatFeatureFlagBits::eColorAttachment | FormatFeatureFlagBits::eColorAttachmentBlend | - FormatFeatureFlagBits::eDepthStencilAttachment | FormatFeatureFlagBits::eBlitSrc | FormatFeatureFlagBits::eBlitDst | - FormatFeatureFlagBits::eSampledImageFilterLinear | FormatFeatureFlagBits::eTransferSrc | FormatFeatureFlagBits::eTransferDst | - FormatFeatureFlagBits::eMidpointChromaSamples | FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter | - FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter | - FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit | - FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable | FormatFeatureFlagBits::eDisjoint | - FormatFeatureFlagBits::eCositedChromaSamples | FormatFeatureFlagBits::eSampledImageFilterMinmax | FormatFeatureFlagBits::eVideoDecodeOutputKHR | - FormatFeatureFlagBits::eVideoDecodeDpbKHR | FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR | - FormatFeatureFlagBits::eSampledImageFilterCubicEXT | FormatFeatureFlagBits::eFragmentDensityMapEXT | - FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR | FormatFeatureFlagBits::eVideoEncodeInputKHR | FormatFeatureFlagBits::eVideoEncodeDpbKHR; - }; - - // wrapper class for enum VkImageCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateFlagBits.html - enum class ImageCreateFlagBits : VkImageCreateFlags - { - eSparseBinding = VK_IMAGE_CREATE_SPARSE_BINDING_BIT, - eSparseResidency = VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT, - eSparseAliased = VK_IMAGE_CREATE_SPARSE_ALIASED_BIT, - eMutableFormat = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, - eCubeCompatible = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, - eAlias = VK_IMAGE_CREATE_ALIAS_BIT, - eAliasKHR = VK_IMAGE_CREATE_ALIAS_BIT_KHR, - eSplitInstanceBindRegions = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, - eSplitInstanceBindRegionsKHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, - e2DArrayCompatible = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, - e2DArrayCompatibleKHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR, - eBlockTexelViewCompatible = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, - eBlockTexelViewCompatibleKHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR, - eExtendedUsage = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, - eExtendedUsageKHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR, - eProtected = VK_IMAGE_CREATE_PROTECTED_BIT, - eDisjoint = VK_IMAGE_CREATE_DISJOINT_BIT, - eDisjointKHR = VK_IMAGE_CREATE_DISJOINT_BIT_KHR, - eCornerSampledNV = VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV, - eDescriptorHeapCaptureReplayEXT = VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT, - eDescriptorBufferCaptureReplayEXT = VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, - eSampleLocationsCompatibleDepthEXT = VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT, - eSubsampledEXT = VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT, - eMultisampledRenderToSingleSampledEXT = VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT, - e2DViewCompatibleEXT = VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT, - eVideoProfileIndependentKHR = VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR, - eFragmentDensityMapOffsetEXT = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT, - eFragmentDensityMapOffsetQCOM = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM - }; - - // wrapper using for bitmask VkImageCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateFlags.html - using ImageCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkImageCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCreateFlags allFlags = - ImageCreateFlagBits::eSparseBinding | ImageCreateFlagBits::eSparseResidency | ImageCreateFlagBits::eSparseAliased | ImageCreateFlagBits::eMutableFormat | - ImageCreateFlagBits::eCubeCompatible | ImageCreateFlagBits::eAlias | ImageCreateFlagBits::eSplitInstanceBindRegions | - ImageCreateFlagBits::e2DArrayCompatible | ImageCreateFlagBits::eBlockTexelViewCompatible | ImageCreateFlagBits::eExtendedUsage | - ImageCreateFlagBits::eProtected | ImageCreateFlagBits::eDisjoint | ImageCreateFlagBits::eCornerSampledNV | - ImageCreateFlagBits::eDescriptorHeapCaptureReplayEXT | ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT | ImageCreateFlagBits::eSubsampledEXT | - ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT | ImageCreateFlagBits::e2DViewCompatibleEXT | - ImageCreateFlagBits::eVideoProfileIndependentKHR | ImageCreateFlagBits::eFragmentDensityMapOffsetEXT; - }; - - // wrapper class for enum VkImageTiling, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageTiling.html - enum class ImageTiling - { - eOptimal = VK_IMAGE_TILING_OPTIMAL, - eLinear = VK_IMAGE_TILING_LINEAR, - eDrmFormatModifierEXT = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT - }; - - // wrapper class for enum VkImageType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageType.html - enum class ImageType - { - e1D = VK_IMAGE_TYPE_1D, - e2D = VK_IMAGE_TYPE_2D, - e3D = VK_IMAGE_TYPE_3D - }; - - // wrapper class for enum VkImageUsageFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageUsageFlagBits.html - enum class ImageUsageFlagBits : VkImageUsageFlags - { - eTransferSrc = VK_IMAGE_USAGE_TRANSFER_SRC_BIT, - eTransferDst = VK_IMAGE_USAGE_TRANSFER_DST_BIT, - eSampled = VK_IMAGE_USAGE_SAMPLED_BIT, - eStorage = VK_IMAGE_USAGE_STORAGE_BIT, - eColorAttachment = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, - eDepthStencilAttachment = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, - eTransientAttachment = VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT, - eInputAttachment = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, - eHostTransfer = VK_IMAGE_USAGE_HOST_TRANSFER_BIT, - eHostTransferEXT = VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT, - eVideoDecodeDstKHR = VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR, - eVideoDecodeSrcKHR = VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR, - eVideoDecodeDpbKHR = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, - eFragmentDensityMapEXT = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT, - eFragmentShadingRateAttachmentKHR = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - eShadingRateImageNV = VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV, - eVideoEncodeDstKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR, - eVideoEncodeSrcKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, - eVideoEncodeDpbKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, - eAttachmentFeedbackLoopEXT = VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, - eInvocationMaskHUAWEI = VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI, - eSampleWeightQCOM = VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM, - eSampleBlockMatchQCOM = VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM, - eTensorAliasingARM = VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM, - eTileMemoryQCOM = VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM, - eVideoEncodeQuantizationDeltaMapKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, - eVideoEncodeEmphasisMapKHR = VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR - }; - - // wrapper using for bitmask VkImageUsageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageUsageFlags.html - using ImageUsageFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkImageUsageFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ImageUsageFlags allFlags = - ImageUsageFlagBits::eTransferSrc | ImageUsageFlagBits::eTransferDst | ImageUsageFlagBits::eSampled | ImageUsageFlagBits::eStorage | - ImageUsageFlagBits::eColorAttachment | ImageUsageFlagBits::eDepthStencilAttachment | ImageUsageFlagBits::eTransientAttachment | - ImageUsageFlagBits::eInputAttachment | ImageUsageFlagBits::eHostTransfer | ImageUsageFlagBits::eVideoDecodeDstKHR | - ImageUsageFlagBits::eVideoDecodeSrcKHR | ImageUsageFlagBits::eVideoDecodeDpbKHR | ImageUsageFlagBits::eFragmentDensityMapEXT | - ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR | ImageUsageFlagBits::eVideoEncodeDstKHR | ImageUsageFlagBits::eVideoEncodeSrcKHR | - ImageUsageFlagBits::eVideoEncodeDpbKHR | ImageUsageFlagBits::eAttachmentFeedbackLoopEXT | ImageUsageFlagBits::eInvocationMaskHUAWEI | - ImageUsageFlagBits::eSampleWeightQCOM | ImageUsageFlagBits::eSampleBlockMatchQCOM | ImageUsageFlagBits::eTensorAliasingARM | - ImageUsageFlagBits::eTileMemoryQCOM | ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR | ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR; - }; - - // wrapper class for enum VkInstanceCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstanceCreateFlagBits.html - enum class InstanceCreateFlagBits : VkInstanceCreateFlags - { - eEnumeratePortabilityKHR = VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR - }; - - // wrapper using for bitmask VkInstanceCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstanceCreateFlags.html - using InstanceCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkInstanceCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR InstanceCreateFlags allFlags = InstanceCreateFlagBits::eEnumeratePortabilityKHR; - }; - - // wrapper class for enum VkInternalAllocationType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInternalAllocationType.html - enum class InternalAllocationType - { - eExecutable = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - }; - - // wrapper class for enum VkMemoryHeapFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryHeapFlagBits.html - enum class MemoryHeapFlagBits : VkMemoryHeapFlags - { - eDeviceLocal = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT, - eMultiInstance = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, - eMultiInstanceKHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR, - eTileMemoryQCOM = VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM - }; - - // wrapper using for bitmask VkMemoryHeapFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryHeapFlags.html - using MemoryHeapFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkMemoryHeapFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryHeapFlags allFlags = - MemoryHeapFlagBits::eDeviceLocal | MemoryHeapFlagBits::eMultiInstance | MemoryHeapFlagBits::eTileMemoryQCOM; - }; - - // wrapper class for enum VkMemoryPropertyFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryPropertyFlagBits.html - enum class MemoryPropertyFlagBits : VkMemoryPropertyFlags - { - eDeviceLocal = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, - eHostVisible = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, - eHostCoherent = VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, - eHostCached = VK_MEMORY_PROPERTY_HOST_CACHED_BIT, - eLazilyAllocated = VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT, - eProtected = VK_MEMORY_PROPERTY_PROTECTED_BIT, - eDeviceCoherentAMD = VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD, - eDeviceUncachedAMD = VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD, - eRdmaCapableNV = VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV - }; - - // wrapper using for bitmask VkMemoryPropertyFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryPropertyFlags.html - using MemoryPropertyFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkMemoryPropertyFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryPropertyFlags allFlags = - MemoryPropertyFlagBits::eDeviceLocal | MemoryPropertyFlagBits::eHostVisible | MemoryPropertyFlagBits::eHostCoherent | - MemoryPropertyFlagBits::eHostCached | MemoryPropertyFlagBits::eLazilyAllocated | MemoryPropertyFlagBits::eProtected | - MemoryPropertyFlagBits::eDeviceCoherentAMD | MemoryPropertyFlagBits::eDeviceUncachedAMD | MemoryPropertyFlagBits::eRdmaCapableNV; - }; - - // wrapper class for enum VkPhysicalDeviceType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceType.html - enum class PhysicalDeviceType - { - eOther = VK_PHYSICAL_DEVICE_TYPE_OTHER, - eIntegratedGpu = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, - eDiscreteGpu = VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, - eVirtualGpu = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU, - eCpu = VK_PHYSICAL_DEVICE_TYPE_CPU - }; - - // wrapper class for enum VkQueueFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFlagBits.html - enum class QueueFlagBits : VkQueueFlags - { - eGraphics = VK_QUEUE_GRAPHICS_BIT, - eCompute = VK_QUEUE_COMPUTE_BIT, - eTransfer = VK_QUEUE_TRANSFER_BIT, - eSparseBinding = VK_QUEUE_SPARSE_BINDING_BIT, - eProtected = VK_QUEUE_PROTECTED_BIT, - eVideoDecodeKHR = VK_QUEUE_VIDEO_DECODE_BIT_KHR, - eVideoEncodeKHR = VK_QUEUE_VIDEO_ENCODE_BIT_KHR, - eOpticalFlowNV = VK_QUEUE_OPTICAL_FLOW_BIT_NV, - eDataGraphARM = VK_QUEUE_DATA_GRAPH_BIT_ARM - }; - - // wrapper using for bitmask VkQueueFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFlags.html - using QueueFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkQueueFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR QueueFlags allFlags = QueueFlagBits::eGraphics | QueueFlagBits::eCompute | QueueFlagBits::eTransfer | - QueueFlagBits::eSparseBinding | QueueFlagBits::eProtected | QueueFlagBits::eVideoDecodeKHR | - QueueFlagBits::eVideoEncodeKHR | QueueFlagBits::eOpticalFlowNV | QueueFlagBits::eDataGraphARM; - }; - - // wrapper class for enum VkSampleCountFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleCountFlagBits.html - enum class SampleCountFlagBits : VkSampleCountFlags - { - e1 = VK_SAMPLE_COUNT_1_BIT, - e2 = VK_SAMPLE_COUNT_2_BIT, - e4 = VK_SAMPLE_COUNT_4_BIT, - e8 = VK_SAMPLE_COUNT_8_BIT, - e16 = VK_SAMPLE_COUNT_16_BIT, - e32 = VK_SAMPLE_COUNT_32_BIT, - e64 = VK_SAMPLE_COUNT_64_BIT - }; - - // wrapper using for bitmask VkSampleCountFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleCountFlags.html - using SampleCountFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkSampleCountFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SampleCountFlags allFlags = SampleCountFlagBits::e1 | SampleCountFlagBits::e2 | SampleCountFlagBits::e4 | - SampleCountFlagBits::e8 | SampleCountFlagBits::e16 | SampleCountFlagBits::e32 | - SampleCountFlagBits::e64; - }; - - // wrapper class for enum VkSystemAllocationScope, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSystemAllocationScope.html - enum class SystemAllocationScope - { - eCommand = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, - eObject = VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, - eCache = VK_SYSTEM_ALLOCATION_SCOPE_CACHE, - eDevice = VK_SYSTEM_ALLOCATION_SCOPE_DEVICE, - eInstance = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - }; - - enum class DeviceCreateFlagBits : VkDeviceCreateFlags - { - }; - - // wrapper using for bitmask VkDeviceCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceCreateFlags.html - using DeviceCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceCreateFlags allFlags = {}; - }; - - // wrapper class for enum VkDeviceQueueCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueCreateFlagBits.html - enum class DeviceQueueCreateFlagBits : VkDeviceQueueCreateFlags - { - eProtected = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT, - eInternallySynchronizedKHR = VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR - }; - - // wrapper using for bitmask VkDeviceQueueCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueCreateFlags.html - using DeviceQueueCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDeviceQueueCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceQueueCreateFlags allFlags = - DeviceQueueCreateFlagBits::eProtected | DeviceQueueCreateFlagBits::eInternallySynchronizedKHR; - }; - - // wrapper class for enum VkPipelineStageFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlagBits.html - enum class PipelineStageFlagBits : VkPipelineStageFlags - { - eTopOfPipe = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, - eDrawIndirect = VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, - eVertexInput = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, - eVertexShader = VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, - eTessellationControlShader = VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, - eTessellationEvaluationShader = VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, - eGeometryShader = VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, - eFragmentShader = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, - eEarlyFragmentTests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, - eLateFragmentTests = VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, - eColorAttachmentOutput = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - eComputeShader = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, - eTransfer = VK_PIPELINE_STAGE_TRANSFER_BIT, - eBottomOfPipe = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, - eHost = VK_PIPELINE_STAGE_HOST_BIT, - eAllGraphics = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, - eAllCommands = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - eNone = VK_PIPELINE_STAGE_NONE, - eNoneKHR = VK_PIPELINE_STAGE_NONE_KHR, - eTransformFeedbackEXT = VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT, - eConditionalRenderingEXT = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT, - eAccelerationStructureBuildKHR = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, - eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV, - eRayTracingShaderKHR = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, - eRayTracingShaderNV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV, - eFragmentDensityProcessEXT = VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT, - eFragmentShadingRateAttachmentKHR = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - eShadingRateImageNV = VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV, - eTaskShaderEXT = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, - eTaskShaderNV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV, - eMeshShaderEXT = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, - eMeshShaderNV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV, - eCommandPreprocessEXT = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT, - eCommandPreprocessNV = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV - }; - - // wrapper using for bitmask VkPipelineStageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlags.html - using PipelineStageFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPipelineStageFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineStageFlags allFlags = - PipelineStageFlagBits::eTopOfPipe | PipelineStageFlagBits::eDrawIndirect | PipelineStageFlagBits::eVertexInput | PipelineStageFlagBits::eVertexShader | - PipelineStageFlagBits::eTessellationControlShader | PipelineStageFlagBits::eTessellationEvaluationShader | PipelineStageFlagBits::eGeometryShader | - PipelineStageFlagBits::eFragmentShader | PipelineStageFlagBits::eEarlyFragmentTests | PipelineStageFlagBits::eLateFragmentTests | - PipelineStageFlagBits::eColorAttachmentOutput | PipelineStageFlagBits::eComputeShader | PipelineStageFlagBits::eTransfer | - PipelineStageFlagBits::eBottomOfPipe | PipelineStageFlagBits::eHost | PipelineStageFlagBits::eAllGraphics | PipelineStageFlagBits::eAllCommands | - PipelineStageFlagBits::eNone | PipelineStageFlagBits::eTransformFeedbackEXT | PipelineStageFlagBits::eConditionalRenderingEXT | - PipelineStageFlagBits::eAccelerationStructureBuildKHR | PipelineStageFlagBits::eRayTracingShaderKHR | PipelineStageFlagBits::eFragmentDensityProcessEXT | - PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR | PipelineStageFlagBits::eTaskShaderEXT | PipelineStageFlagBits::eMeshShaderEXT | - PipelineStageFlagBits::eCommandPreprocessEXT; - }; - - // wrapper class for enum VkMemoryMapFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMapFlagBits.html - enum class MemoryMapFlagBits : VkMemoryMapFlags - { - ePlacedEXT = VK_MEMORY_MAP_PLACED_BIT_EXT - }; - - // wrapper using for bitmask VkMemoryMapFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMapFlags.html - using MemoryMapFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkMemoryMapFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryMapFlags allFlags = MemoryMapFlagBits::ePlacedEXT; - }; - - // wrapper class for enum VkImageAspectFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageAspectFlagBits.html - enum class ImageAspectFlagBits : VkImageAspectFlags - { - eColor = VK_IMAGE_ASPECT_COLOR_BIT, - eDepth = VK_IMAGE_ASPECT_DEPTH_BIT, - eStencil = VK_IMAGE_ASPECT_STENCIL_BIT, - eMetadata = VK_IMAGE_ASPECT_METADATA_BIT, - ePlane0 = VK_IMAGE_ASPECT_PLANE_0_BIT, - ePlane0KHR = VK_IMAGE_ASPECT_PLANE_0_BIT_KHR, - ePlane1 = VK_IMAGE_ASPECT_PLANE_1_BIT, - ePlane1KHR = VK_IMAGE_ASPECT_PLANE_1_BIT_KHR, - ePlane2 = VK_IMAGE_ASPECT_PLANE_2_BIT, - ePlane2KHR = VK_IMAGE_ASPECT_PLANE_2_BIT_KHR, - eNone = VK_IMAGE_ASPECT_NONE, - eNoneKHR = VK_IMAGE_ASPECT_NONE_KHR, - eMemoryPlane0EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT, - eMemoryPlane1EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT, - eMemoryPlane2EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT, - eMemoryPlane3EXT = VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT - }; - - // wrapper using for bitmask VkImageAspectFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageAspectFlags.html - using ImageAspectFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkImageAspectFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ImageAspectFlags allFlags = ImageAspectFlagBits::eColor | ImageAspectFlagBits::eDepth | ImageAspectFlagBits::eStencil | - ImageAspectFlagBits::eMetadata | ImageAspectFlagBits::ePlane0 | - ImageAspectFlagBits::ePlane1 | ImageAspectFlagBits::ePlane2 | ImageAspectFlagBits::eNone | - ImageAspectFlagBits::eMemoryPlane0EXT | ImageAspectFlagBits::eMemoryPlane1EXT | - ImageAspectFlagBits::eMemoryPlane2EXT | ImageAspectFlagBits::eMemoryPlane3EXT; - }; - - // wrapper class for enum VkSparseImageFormatFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageFormatFlagBits.html - enum class SparseImageFormatFlagBits : VkSparseImageFormatFlags - { - eSingleMiptail = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT, - eAlignedMipSize = VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT, - eNonstandardBlockSize = VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT - }; - - // wrapper using for bitmask VkSparseImageFormatFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageFormatFlags.html - using SparseImageFormatFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkSparseImageFormatFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SparseImageFormatFlags allFlags = - SparseImageFormatFlagBits::eSingleMiptail | SparseImageFormatFlagBits::eAlignedMipSize | SparseImageFormatFlagBits::eNonstandardBlockSize; - }; - - // wrapper class for enum VkSparseMemoryBindFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseMemoryBindFlagBits.html - enum class SparseMemoryBindFlagBits : VkSparseMemoryBindFlags - { - eMetadata = VK_SPARSE_MEMORY_BIND_METADATA_BIT - }; - - // wrapper using for bitmask VkSparseMemoryBindFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseMemoryBindFlags.html - using SparseMemoryBindFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkSparseMemoryBindFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SparseMemoryBindFlags allFlags = SparseMemoryBindFlagBits::eMetadata; - }; - - // wrapper class for enum VkFenceCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceCreateFlagBits.html - enum class FenceCreateFlagBits : VkFenceCreateFlags - { - eSignaled = VK_FENCE_CREATE_SIGNALED_BIT - }; - - // wrapper using for bitmask VkFenceCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceCreateFlags.html - using FenceCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkFenceCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR FenceCreateFlags allFlags = FenceCreateFlagBits::eSignaled; - }; - - enum class SemaphoreCreateFlagBits : VkSemaphoreCreateFlags - { - }; - - // wrapper using for bitmask VkSemaphoreCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreCreateFlags.html - using SemaphoreCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreCreateFlags allFlags = {}; - }; - - // wrapper class for enum VkQueryPoolCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolCreateFlagBits.html - enum class QueryPoolCreateFlagBits : VkQueryPoolCreateFlags - { - eResetKHR = VK_QUERY_POOL_CREATE_RESET_BIT_KHR - }; - - // wrapper using for bitmask VkQueryPoolCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolCreateFlags.html - using QueryPoolCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkQueryPoolCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR QueryPoolCreateFlags allFlags = QueryPoolCreateFlagBits::eResetKHR; - }; - - // wrapper class for enum VkQueryResultFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryResultFlagBits.html - enum class QueryResultFlagBits : VkQueryResultFlags - { - e64 = VK_QUERY_RESULT_64_BIT, - eWait = VK_QUERY_RESULT_WAIT_BIT, - eWithAvailability = VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, - ePartial = VK_QUERY_RESULT_PARTIAL_BIT, - eWithStatusKHR = VK_QUERY_RESULT_WITH_STATUS_BIT_KHR - }; - - // wrapper using for bitmask VkQueryResultFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryResultFlags.html - using QueryResultFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkQueryResultFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR QueryResultFlags allFlags = QueryResultFlagBits::e64 | QueryResultFlagBits::eWait | - QueryResultFlagBits::eWithAvailability | QueryResultFlagBits::ePartial | - QueryResultFlagBits::eWithStatusKHR; - }; - - // wrapper class for enum VkQueryType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryType.html - enum class QueryType - { - eOcclusion = VK_QUERY_TYPE_OCCLUSION, - ePipelineStatistics = VK_QUERY_TYPE_PIPELINE_STATISTICS, - eTimestamp = VK_QUERY_TYPE_TIMESTAMP, - eResultStatusOnlyKHR = VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR, - eTransformFeedbackStreamEXT = VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT, - ePerformanceQueryKHR = VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, - eAccelerationStructureCompactedSizeKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR, - eAccelerationStructureSerializationSizeKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR, - eAccelerationStructureCompactedSizeNV = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV, - ePerformanceQueryINTEL = VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL, - eVideoEncodeFeedbackKHR = VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR, - eMeshPrimitivesGeneratedEXT = VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT, - ePrimitivesGeneratedEXT = VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT, - eAccelerationStructureSerializationBottomLevelPointersKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR, - eAccelerationStructureSizeKHR = VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR, - eMicromapSerializationSizeEXT = VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT, - eMicromapCompactedSizeEXT = VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT - }; - - // wrapper class for enum VkBufferCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCreateFlagBits.html - enum class BufferCreateFlagBits : VkBufferCreateFlags - { - eSparseBinding = VK_BUFFER_CREATE_SPARSE_BINDING_BIT, - eSparseResidency = VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT, - eSparseAliased = VK_BUFFER_CREATE_SPARSE_ALIASED_BIT, - eProtected = VK_BUFFER_CREATE_PROTECTED_BIT, - eDeviceAddressCaptureReplay = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, - eDeviceAddressCaptureReplayEXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT, - eDeviceAddressCaptureReplayKHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, - eDescriptorBufferCaptureReplayEXT = VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, - eVideoProfileIndependentKHR = VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR - }; - - // wrapper using for bitmask VkBufferCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCreateFlags.html - using BufferCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkBufferCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR BufferCreateFlags allFlags = - BufferCreateFlagBits::eSparseBinding | BufferCreateFlagBits::eSparseResidency | BufferCreateFlagBits::eSparseAliased | BufferCreateFlagBits::eProtected | - BufferCreateFlagBits::eDeviceAddressCaptureReplay | BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT | - BufferCreateFlagBits::eVideoProfileIndependentKHR; - }; - - // wrapper class for enum VkBufferUsageFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlagBits.html - enum class BufferUsageFlagBits : VkBufferUsageFlags - { - eTransferSrc = VK_BUFFER_USAGE_TRANSFER_SRC_BIT, - eTransferDst = VK_BUFFER_USAGE_TRANSFER_DST_BIT, - eUniformTexelBuffer = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, - eStorageTexelBuffer = VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, - eUniformBuffer = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, - eStorageBuffer = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, - eIndexBuffer = VK_BUFFER_USAGE_INDEX_BUFFER_BIT, - eVertexBuffer = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, - eIndirectBuffer = VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, - eShaderDeviceAddress = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, - eShaderDeviceAddressEXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT, - eShaderDeviceAddressKHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR, - eVideoDecodeSrcKHR = VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR, - eVideoDecodeDstKHR = VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR, - eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT, - eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, - eConditionalRenderingEXT = VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eExecutionGraphScratchAMDX = VK_BUFFER_USAGE_EXECUTION_GRAPH_SCRATCH_BIT_AMDX, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eDescriptorHeapEXT = VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT, - eAccelerationStructureBuildInputReadOnlyKHR = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR, - eAccelerationStructureStorageKHR = VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR, - eShaderBindingTableKHR = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, - eRayTracingNV = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV, - eVideoEncodeDstKHR = VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR, - eVideoEncodeSrcKHR = VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, - eSamplerDescriptorBufferEXT = VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT, - eResourceDescriptorBufferEXT = VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT, - ePushDescriptorsDescriptorBufferEXT = VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, - eMicromapBuildInputReadOnlyEXT = VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, - eMicromapStorageEXT = VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT, - eTileMemoryQCOM = VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM - }; - - // wrapper using for bitmask VkBufferUsageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlags.html - using BufferUsageFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkBufferUsageFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR BufferUsageFlags allFlags = - BufferUsageFlagBits::eTransferSrc | BufferUsageFlagBits::eTransferDst | BufferUsageFlagBits::eUniformTexelBuffer | - BufferUsageFlagBits::eStorageTexelBuffer | BufferUsageFlagBits::eUniformBuffer | BufferUsageFlagBits::eStorageBuffer | BufferUsageFlagBits::eIndexBuffer | - BufferUsageFlagBits::eVertexBuffer | BufferUsageFlagBits::eIndirectBuffer | BufferUsageFlagBits::eShaderDeviceAddress | - BufferUsageFlagBits::eVideoDecodeSrcKHR | BufferUsageFlagBits::eVideoDecodeDstKHR | BufferUsageFlagBits::eTransformFeedbackBufferEXT | - BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT | BufferUsageFlagBits::eConditionalRenderingEXT -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | BufferUsageFlagBits::eExecutionGraphScratchAMDX -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | BufferUsageFlagBits::eDescriptorHeapEXT | BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR | - BufferUsageFlagBits::eAccelerationStructureStorageKHR | BufferUsageFlagBits::eShaderBindingTableKHR | BufferUsageFlagBits::eVideoEncodeDstKHR | - BufferUsageFlagBits::eVideoEncodeSrcKHR | BufferUsageFlagBits::eSamplerDescriptorBufferEXT | BufferUsageFlagBits::eResourceDescriptorBufferEXT | - BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT | BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT | - BufferUsageFlagBits::eMicromapStorageEXT | BufferUsageFlagBits::eTileMemoryQCOM; - }; - - // wrapper class for enum VkSharingMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSharingMode.html - enum class SharingMode - { - eExclusive = VK_SHARING_MODE_EXCLUSIVE, - eConcurrent = VK_SHARING_MODE_CONCURRENT - }; - - // wrapper class for enum VkImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageLayout.html - enum class ImageLayout - { - eUndefined = VK_IMAGE_LAYOUT_UNDEFINED, - eGeneral = VK_IMAGE_LAYOUT_GENERAL, - eColorAttachmentOptimal = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - eDepthStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - eDepthStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL, - eShaderReadOnlyOptimal = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - eTransferSrcOptimal = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - eTransferDstOptimal = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - ePreinitialized = VK_IMAGE_LAYOUT_PREINITIALIZED, - eDepthReadOnlyStencilAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, - eDepthReadOnlyStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR, - eDepthAttachmentStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, - eDepthAttachmentStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR, - eDepthAttachmentOptimal = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, - eDepthAttachmentOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR, - eDepthReadOnlyOptimal = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, - eDepthReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR, - eStencilAttachmentOptimal = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, - eStencilAttachmentOptimalKHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR, - eStencilReadOnlyOptimal = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, - eStencilReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR, - eReadOnlyOptimal = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, - eReadOnlyOptimalKHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR, - eAttachmentOptimal = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, - eAttachmentOptimalKHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR, - eRenderingLocalRead = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ, - eRenderingLocalReadKHR = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR, - ePresentSrcKHR = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, - eVideoDecodeDstKHR = VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR, - eVideoDecodeSrcKHR = VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR, - eVideoDecodeDpbKHR = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR, - eSharedPresentKHR = VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR, - eFragmentDensityMapOptimalEXT = VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT, - eFragmentShadingRateAttachmentOptimalKHR = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, - eShadingRateOptimalNV = VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV, - eVideoEncodeDstKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR, - eVideoEncodeSrcKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR, - eVideoEncodeDpbKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR, - eAttachmentFeedbackLoopOptimalEXT = VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT, - eTensorAliasingARM = VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM, - eVideoEncodeQuantizationMapKHR = VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR, - eZeroInitializedEXT = VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT - }; - - // wrapper class for enum VkComponentSwizzle, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkComponentSwizzle.html - enum class ComponentSwizzle - { - eIdentity = VK_COMPONENT_SWIZZLE_IDENTITY, - eZero = VK_COMPONENT_SWIZZLE_ZERO, - eOne = VK_COMPONENT_SWIZZLE_ONE, - eR = VK_COMPONENT_SWIZZLE_R, - eG = VK_COMPONENT_SWIZZLE_G, - eB = VK_COMPONENT_SWIZZLE_B, - eA = VK_COMPONENT_SWIZZLE_A - }; - - // wrapper class for enum VkImageViewCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewCreateFlagBits.html - enum class ImageViewCreateFlagBits : VkImageViewCreateFlags - { - eFragmentDensityMapDynamicEXT = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT, - eDescriptorBufferCaptureReplayEXT = VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, - eFragmentDensityMapDeferredEXT = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT - }; - - // wrapper using for bitmask VkImageViewCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewCreateFlags.html - using ImageViewCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkImageViewCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ImageViewCreateFlags allFlags = ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT | - ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT | - ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT; - }; - - // wrapper class for enum VkImageViewType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewType.html - enum class ImageViewType - { - e1D = VK_IMAGE_VIEW_TYPE_1D, - e2D = VK_IMAGE_VIEW_TYPE_2D, - e3D = VK_IMAGE_VIEW_TYPE_3D, - eCube = VK_IMAGE_VIEW_TYPE_CUBE, - e1DArray = VK_IMAGE_VIEW_TYPE_1D_ARRAY, - e2DArray = VK_IMAGE_VIEW_TYPE_2D_ARRAY, - eCubeArray = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - }; - - // wrapper class for enum VkAccessFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits.html - enum class AccessFlagBits : VkAccessFlags - { - eIndirectCommandRead = VK_ACCESS_INDIRECT_COMMAND_READ_BIT, - eIndexRead = VK_ACCESS_INDEX_READ_BIT, - eVertexAttributeRead = VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT, - eUniformRead = VK_ACCESS_UNIFORM_READ_BIT, - eInputAttachmentRead = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT, - eShaderRead = VK_ACCESS_SHADER_READ_BIT, - eShaderWrite = VK_ACCESS_SHADER_WRITE_BIT, - eColorAttachmentRead = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT, - eColorAttachmentWrite = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - eDepthStencilAttachmentRead = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT, - eDepthStencilAttachmentWrite = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, - eTransferRead = VK_ACCESS_TRANSFER_READ_BIT, - eTransferWrite = VK_ACCESS_TRANSFER_WRITE_BIT, - eHostRead = VK_ACCESS_HOST_READ_BIT, - eHostWrite = VK_ACCESS_HOST_WRITE_BIT, - eMemoryRead = VK_ACCESS_MEMORY_READ_BIT, - eMemoryWrite = VK_ACCESS_MEMORY_WRITE_BIT, - eNone = VK_ACCESS_NONE, - eNoneKHR = VK_ACCESS_NONE_KHR, - eTransformFeedbackWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, - eTransformFeedbackCounterReadEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, - eTransformFeedbackCounterWriteEXT = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, - eConditionalRenderingReadEXT = VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT, - eColorAttachmentReadNoncoherentEXT = VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, - eAccelerationStructureReadKHR = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, - eAccelerationStructureReadNV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV, - eAccelerationStructureWriteKHR = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, - eAccelerationStructureWriteNV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV, - eFragmentDensityMapReadEXT = VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, - eFragmentShadingRateAttachmentReadKHR = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, - eShadingRateImageReadNV = VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV, - eCommandPreprocessReadEXT = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT, - eCommandPreprocessReadNV = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV, - eCommandPreprocessWriteEXT = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT, - eCommandPreprocessWriteNV = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV - }; - - // wrapper using for bitmask VkAccessFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlags.html - using AccessFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkAccessFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags allFlags = - AccessFlagBits::eIndirectCommandRead | AccessFlagBits::eIndexRead | AccessFlagBits::eVertexAttributeRead | AccessFlagBits::eUniformRead | - AccessFlagBits::eInputAttachmentRead | AccessFlagBits::eShaderRead | AccessFlagBits::eShaderWrite | AccessFlagBits::eColorAttachmentRead | - AccessFlagBits::eColorAttachmentWrite | AccessFlagBits::eDepthStencilAttachmentRead | AccessFlagBits::eDepthStencilAttachmentWrite | - AccessFlagBits::eTransferRead | AccessFlagBits::eTransferWrite | AccessFlagBits::eHostRead | AccessFlagBits::eHostWrite | AccessFlagBits::eMemoryRead | - AccessFlagBits::eMemoryWrite | AccessFlagBits::eNone | AccessFlagBits::eTransformFeedbackWriteEXT | AccessFlagBits::eTransformFeedbackCounterReadEXT | - AccessFlagBits::eTransformFeedbackCounterWriteEXT | AccessFlagBits::eConditionalRenderingReadEXT | AccessFlagBits::eColorAttachmentReadNoncoherentEXT | - AccessFlagBits::eAccelerationStructureReadKHR | AccessFlagBits::eAccelerationStructureWriteKHR | AccessFlagBits::eFragmentDensityMapReadEXT | - AccessFlagBits::eFragmentShadingRateAttachmentReadKHR | AccessFlagBits::eCommandPreprocessReadEXT | AccessFlagBits::eCommandPreprocessWriteEXT; - }; - - // wrapper class for enum VkDependencyFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDependencyFlagBits.html - enum class DependencyFlagBits : VkDependencyFlags - { - eByRegion = VK_DEPENDENCY_BY_REGION_BIT, - eDeviceGroup = VK_DEPENDENCY_DEVICE_GROUP_BIT, - eDeviceGroupKHR = VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR, - eViewLocal = VK_DEPENDENCY_VIEW_LOCAL_BIT, - eViewLocalKHR = VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR, - eFeedbackLoopEXT = VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT, - eQueueFamilyOwnershipTransferUseAllStagesKHR = VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR, - eAsymmetricEventKHR = VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR - }; - - // wrapper using for bitmask VkDependencyFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDependencyFlags.html - using DependencyFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDependencyFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DependencyFlags allFlags = - DependencyFlagBits::eByRegion | DependencyFlagBits::eDeviceGroup | DependencyFlagBits::eViewLocal | DependencyFlagBits::eFeedbackLoopEXT | - DependencyFlagBits::eQueueFamilyOwnershipTransferUseAllStagesKHR | DependencyFlagBits::eAsymmetricEventKHR; - }; - - // wrapper class for enum VkCommandPoolCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolCreateFlagBits.html - enum class CommandPoolCreateFlagBits : VkCommandPoolCreateFlags - { - eTransient = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, - eResetCommandBuffer = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, - eProtected = VK_COMMAND_POOL_CREATE_PROTECTED_BIT - }; - - // wrapper using for bitmask VkCommandPoolCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolCreateFlags.html - using CommandPoolCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkCommandPoolCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolCreateFlags allFlags = - CommandPoolCreateFlagBits::eTransient | CommandPoolCreateFlagBits::eResetCommandBuffer | CommandPoolCreateFlagBits::eProtected; - }; - - // wrapper class for enum VkCommandPoolResetFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolResetFlagBits.html - enum class CommandPoolResetFlagBits : VkCommandPoolResetFlags - { - eReleaseResources = VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT - }; - - // wrapper using for bitmask VkCommandPoolResetFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolResetFlags.html - using CommandPoolResetFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkCommandPoolResetFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolResetFlags allFlags = CommandPoolResetFlagBits::eReleaseResources; - }; - - // wrapper class for enum VkCommandBufferLevel, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferLevel.html - enum class CommandBufferLevel - { - ePrimary = VK_COMMAND_BUFFER_LEVEL_PRIMARY, - eSecondary = VK_COMMAND_BUFFER_LEVEL_SECONDARY - }; - - // wrapper class for enum VkCommandBufferResetFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferResetFlagBits.html - enum class CommandBufferResetFlagBits : VkCommandBufferResetFlags - { - eReleaseResources = VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT - }; - - // wrapper using for bitmask VkCommandBufferResetFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferResetFlags.html - using CommandBufferResetFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkCommandBufferResetFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR CommandBufferResetFlags allFlags = CommandBufferResetFlagBits::eReleaseResources; - }; - - // wrapper class for enum VkCommandBufferUsageFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferUsageFlagBits.html - enum class CommandBufferUsageFlagBits : VkCommandBufferUsageFlags - { - eOneTimeSubmit = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, - eRenderPassContinue = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT, - eSimultaneousUse = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT - }; - - // wrapper using for bitmask VkCommandBufferUsageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferUsageFlags.html - using CommandBufferUsageFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkCommandBufferUsageFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR CommandBufferUsageFlags allFlags = - CommandBufferUsageFlagBits::eOneTimeSubmit | CommandBufferUsageFlagBits::eRenderPassContinue | CommandBufferUsageFlagBits::eSimultaneousUse; - }; - - // wrapper class for enum VkQueryControlFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryControlFlagBits.html - enum class QueryControlFlagBits : VkQueryControlFlags - { - ePrecise = VK_QUERY_CONTROL_PRECISE_BIT - }; - - // wrapper using for bitmask VkQueryControlFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryControlFlags.html - using QueryControlFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkQueryControlFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR QueryControlFlags allFlags = QueryControlFlagBits::ePrecise; - }; - - // wrapper class for enum VkIndexType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndexType.html - enum class IndexType - { - eUint16 = VK_INDEX_TYPE_UINT16, - eUint32 = VK_INDEX_TYPE_UINT32, - eUint8 = VK_INDEX_TYPE_UINT8, - eUint8EXT = VK_INDEX_TYPE_UINT8_EXT, - eUint8KHR = VK_INDEX_TYPE_UINT8_KHR, - eNoneKHR = VK_INDEX_TYPE_NONE_KHR, - eNoneNV = VK_INDEX_TYPE_NONE_NV - }; - - //========================= - //=== Index Type Traits === - //========================= - - template - struct IndexTypeValue - { - }; - - template <> - struct IndexTypeValue - { - static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint16; - }; - - template <> - struct CppType - { - using Type = uint16_t; - }; - - template <> - struct IndexTypeValue - { - static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint32; - }; - - template <> - struct CppType - { - using Type = uint32_t; - }; - - template <> - struct IndexTypeValue - { - static VULKAN_HPP_CONST_OR_CONSTEXPR IndexType value = IndexType::eUint8; - }; - - template <> - struct CppType - { - using Type = uint8_t; - }; - - // wrapper class for enum VkPipelineCacheHeaderVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersion.html - enum class PipelineCacheHeaderVersion - { - eOne = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, - eDataGraphQCOM = VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM - }; - - // wrapper class for enum VkEventCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEventCreateFlagBits.html - enum class EventCreateFlagBits : VkEventCreateFlags - { - eDeviceOnly = VK_EVENT_CREATE_DEVICE_ONLY_BIT, - eDeviceOnlyKHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR - }; - - // wrapper using for bitmask VkEventCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEventCreateFlags.html - using EventCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkEventCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR EventCreateFlags allFlags = EventCreateFlagBits::eDeviceOnly; - }; - - enum class BufferViewCreateFlagBits : VkBufferViewCreateFlags - { - }; - - // wrapper using for bitmask VkBufferViewCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferViewCreateFlags.html - using BufferViewCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR BufferViewCreateFlags allFlags = {}; - }; - - enum class ShaderModuleCreateFlagBits : VkShaderModuleCreateFlags - { - }; - - // wrapper using for bitmask VkShaderModuleCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleCreateFlags.html - using ShaderModuleCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderModuleCreateFlags allFlags = {}; - }; - - // wrapper class for enum VkPipelineCacheCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheCreateFlagBits.html - enum class PipelineCacheCreateFlagBits : VkPipelineCacheCreateFlags - { - eExternallySynchronized = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, - eExternallySynchronizedEXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT, - eInternallySynchronizedMergeKHR = VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR - }; - - // wrapper using for bitmask VkPipelineCacheCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheCreateFlags.html - using PipelineCacheCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPipelineCacheCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCacheCreateFlags allFlags = - PipelineCacheCreateFlagBits::eExternallySynchronized | PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR; - }; - - // wrapper class for enum VkPipelineCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlagBits.html - enum class PipelineCreateFlagBits : VkPipelineCreateFlags - { - eDisableOptimization = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT, - eAllowDerivatives = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT, - eDerivative = VK_PIPELINE_CREATE_DERIVATIVE_BIT, - eDispatchBase = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, - eDispatchBaseKHR = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR, - eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, - eViewIndexFromDeviceIndexKHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR, - eFailOnPipelineCompileRequired = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, - eFailOnPipelineCompileRequiredEXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT, - eEarlyReturnOnFailure = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, - eEarlyReturnOnFailureEXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT, - eNoProtectedAccess = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT, - eNoProtectedAccessEXT = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT, - eProtectedAccessOnly = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT, - eProtectedAccessOnlyEXT = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT, - eRayTracingNoNullAnyHitShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, - eRayTracingNoNullClosestHitShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, - eRayTracingNoNullMissShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR, - eRayTracingNoNullIntersectionShadersKHR = VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, - eRayTracingSkipTrianglesKHR = VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR, - eRayTracingSkipAabbsKHR = VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR, - eRayTracingShaderGroupHandleCaptureReplayKHR = VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR, - eDeferCompileNV = VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV, - eRenderingFragmentDensityMapAttachmentEXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, - eVkPipelineRasterizationStateCreateFragmentDensityMapAttachmentEXT = VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, - eRenderingFragmentShadingRateAttachmentKHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - eVkPipelineRasterizationStateCreateFragmentShadingRateAttachmentKHR = VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - eCaptureStatisticsKHR = VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR, - eCaptureInternalRepresentationsKHR = VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, - eIndirectBindableNV = VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV, - eLibraryKHR = VK_PIPELINE_CREATE_LIBRARY_BIT_KHR, - eDescriptorBufferEXT = VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, - eRetainLinkTimeOptimizationInfoEXT = VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT, - eLinkTimeOptimizationEXT = VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT, - eRayTracingAllowMotionNV = VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV, - eColorAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, - eDepthStencilAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, - eRayTracingOpacityMicromapEXT = VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eRayTracingDisplacementMicromapNV = VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - }; - - // wrapper using for bitmask VkPipelineCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlags.html - using PipelineCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPipelineCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreateFlags allFlags = - PipelineCreateFlagBits::eDisableOptimization | PipelineCreateFlagBits::eAllowDerivatives | PipelineCreateFlagBits::eDerivative | - PipelineCreateFlagBits::eDispatchBase | PipelineCreateFlagBits::eViewIndexFromDeviceIndex | PipelineCreateFlagBits::eFailOnPipelineCompileRequired | - PipelineCreateFlagBits::eEarlyReturnOnFailure | PipelineCreateFlagBits::eNoProtectedAccess | PipelineCreateFlagBits::eProtectedAccessOnly | - PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR | PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR | - PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR | PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR | - PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR | PipelineCreateFlagBits::eRayTracingSkipAabbsKHR | - PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR | PipelineCreateFlagBits::eDeferCompileNV | - PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT | PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR | - PipelineCreateFlagBits::eCaptureStatisticsKHR | PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR | PipelineCreateFlagBits::eIndirectBindableNV | - PipelineCreateFlagBits::eLibraryKHR | PipelineCreateFlagBits::eDescriptorBufferEXT | PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT | - PipelineCreateFlagBits::eLinkTimeOptimizationEXT | PipelineCreateFlagBits::eRayTracingAllowMotionNV | - PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT | - PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - ; - }; - - // wrapper class for enum VkPipelineShaderStageCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageCreateFlagBits.html - enum class PipelineShaderStageCreateFlagBits : VkPipelineShaderStageCreateFlags - { - eAllowVaryingSubgroupSize = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, - eAllowVaryingSubgroupSizeEXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, - eRequireFullSubgroups = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, - eRequireFullSubgroupsEXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT - }; - - // wrapper using for bitmask VkPipelineShaderStageCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageCreateFlags.html - using PipelineShaderStageCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPipelineShaderStageCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineShaderStageCreateFlags allFlags = - PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize | PipelineShaderStageCreateFlagBits::eRequireFullSubgroups; - }; - - // wrapper class for enum VkShaderStageFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderStageFlagBits.html - enum class ShaderStageFlagBits : VkShaderStageFlags - { - eVertex = VK_SHADER_STAGE_VERTEX_BIT, - eTessellationControl = VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, - eTessellationEvaluation = VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, - eGeometry = VK_SHADER_STAGE_GEOMETRY_BIT, - eFragment = VK_SHADER_STAGE_FRAGMENT_BIT, - eCompute = VK_SHADER_STAGE_COMPUTE_BIT, - eAllGraphics = VK_SHADER_STAGE_ALL_GRAPHICS, - eAll = VK_SHADER_STAGE_ALL, - eRaygenKHR = VK_SHADER_STAGE_RAYGEN_BIT_KHR, - eRaygenNV = VK_SHADER_STAGE_RAYGEN_BIT_NV, - eAnyHitKHR = VK_SHADER_STAGE_ANY_HIT_BIT_KHR, - eAnyHitNV = VK_SHADER_STAGE_ANY_HIT_BIT_NV, - eClosestHitKHR = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, - eClosestHitNV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV, - eMissKHR = VK_SHADER_STAGE_MISS_BIT_KHR, - eMissNV = VK_SHADER_STAGE_MISS_BIT_NV, - eIntersectionKHR = VK_SHADER_STAGE_INTERSECTION_BIT_KHR, - eIntersectionNV = VK_SHADER_STAGE_INTERSECTION_BIT_NV, - eCallableKHR = VK_SHADER_STAGE_CALLABLE_BIT_KHR, - eCallableNV = VK_SHADER_STAGE_CALLABLE_BIT_NV, - eTaskEXT = VK_SHADER_STAGE_TASK_BIT_EXT, - eTaskNV = VK_SHADER_STAGE_TASK_BIT_NV, - eMeshEXT = VK_SHADER_STAGE_MESH_BIT_EXT, - eMeshNV = VK_SHADER_STAGE_MESH_BIT_NV, - eSubpassShadingHUAWEI = VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI, - eClusterCullingHUAWEI = VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI - }; - - // wrapper using for bitmask VkShaderStageFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderStageFlags.html - using ShaderStageFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkShaderStageFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderStageFlags allFlags = - ShaderStageFlagBits::eVertex | ShaderStageFlagBits::eTessellationControl | ShaderStageFlagBits::eTessellationEvaluation | ShaderStageFlagBits::eGeometry | - ShaderStageFlagBits::eFragment | ShaderStageFlagBits::eCompute | ShaderStageFlagBits::eAllGraphics | ShaderStageFlagBits::eAll | - ShaderStageFlagBits::eRaygenKHR | ShaderStageFlagBits::eAnyHitKHR | ShaderStageFlagBits::eClosestHitKHR | ShaderStageFlagBits::eMissKHR | - ShaderStageFlagBits::eIntersectionKHR | ShaderStageFlagBits::eCallableKHR | ShaderStageFlagBits::eTaskEXT | ShaderStageFlagBits::eMeshEXT | - ShaderStageFlagBits::eSubpassShadingHUAWEI | ShaderStageFlagBits::eClusterCullingHUAWEI; - }; - - // wrapper class for enum VkPipelineLayoutCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlagBits.html - enum class PipelineLayoutCreateFlagBits : VkPipelineLayoutCreateFlags - { - eIndependentSetsEXT = VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT - }; - - // wrapper using for bitmask VkPipelineLayoutCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateFlags.html - using PipelineLayoutCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPipelineLayoutCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineLayoutCreateFlags allFlags = PipelineLayoutCreateFlagBits::eIndependentSetsEXT; - }; - - // wrapper class for enum VkBorderColor, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBorderColor.html - enum class BorderColor - { - eFloatTransparentBlack = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, - eIntTransparentBlack = VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, - eFloatOpaqueBlack = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK, - eIntOpaqueBlack = VK_BORDER_COLOR_INT_OPAQUE_BLACK, - eFloatOpaqueWhite = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, - eIntOpaqueWhite = VK_BORDER_COLOR_INT_OPAQUE_WHITE, - eFloatCustomEXT = VK_BORDER_COLOR_FLOAT_CUSTOM_EXT, - eIntCustomEXT = VK_BORDER_COLOR_INT_CUSTOM_EXT - }; - - // wrapper class for enum VkFilter, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFilter.html - enum class Filter - { - eNearest = VK_FILTER_NEAREST, - eLinear = VK_FILTER_LINEAR, - eCubicEXT = VK_FILTER_CUBIC_EXT, - eCubicIMG = VK_FILTER_CUBIC_IMG - }; - - // wrapper class for enum VkSamplerAddressMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerAddressMode.html - enum class SamplerAddressMode - { - eRepeat = VK_SAMPLER_ADDRESS_MODE_REPEAT, - eMirroredRepeat = VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, - eClampToEdge = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, - eClampToBorder = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, - eMirrorClampToEdge = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, - eMirrorClampToEdgeKHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR - }; - - // wrapper class for enum VkSamplerCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCreateFlagBits.html - enum class SamplerCreateFlagBits : VkSamplerCreateFlags - { - eSubsampledEXT = VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT, - eSubsampledCoarseReconstructionEXT = VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT, - eDescriptorBufferCaptureReplayEXT = VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, - eNonSeamlessCubeMapEXT = VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT, - eImageProcessingQCOM = VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM - }; - - // wrapper using for bitmask VkSamplerCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCreateFlags.html - using SamplerCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkSamplerCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SamplerCreateFlags allFlags = - SamplerCreateFlagBits::eSubsampledEXT | SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT | - SamplerCreateFlagBits::eDescriptorBufferCaptureReplayEXT | SamplerCreateFlagBits::eNonSeamlessCubeMapEXT | SamplerCreateFlagBits::eImageProcessingQCOM; - }; - - // wrapper class for enum VkSamplerMipmapMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerMipmapMode.html - enum class SamplerMipmapMode - { - eNearest = VK_SAMPLER_MIPMAP_MODE_NEAREST, - eLinear = VK_SAMPLER_MIPMAP_MODE_LINEAR - }; - - // wrapper class for enum VkDescriptorPoolCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolCreateFlagBits.html - enum class DescriptorPoolCreateFlagBits : VkDescriptorPoolCreateFlags - { - eFreeDescriptorSet = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, - eUpdateAfterBind = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, - eUpdateAfterBindEXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT, - eHostOnlyEXT = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT, - eHostOnlyVALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE, - eAllowOverallocationSetsNV = VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV, - eAllowOverallocationPoolsNV = VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV - }; - - // wrapper using for bitmask VkDescriptorPoolCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolCreateFlags.html - using DescriptorPoolCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDescriptorPoolCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorPoolCreateFlags allFlags = - DescriptorPoolCreateFlagBits::eFreeDescriptorSet | DescriptorPoolCreateFlagBits::eUpdateAfterBind | DescriptorPoolCreateFlagBits::eHostOnlyEXT | - DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV | DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV; - }; - - // wrapper class for enum VkDescriptorSetLayoutCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutCreateFlagBits.html - enum class DescriptorSetLayoutCreateFlagBits : VkDescriptorSetLayoutCreateFlags - { - eUpdateAfterBindPool = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, - eUpdateAfterBindPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT, - ePushDescriptor = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT, - ePushDescriptorKHR = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR, - eDescriptorBufferEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, - eEmbeddedImmutableSamplersEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT, - eIndirectBindableNV = VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV, - eHostOnlyPoolEXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, - eHostOnlyPoolVALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE, - ePerStageNV = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV - }; - - // wrapper using for bitmask VkDescriptorSetLayoutCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutCreateFlags.html - using DescriptorSetLayoutCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDescriptorSetLayoutCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorSetLayoutCreateFlags allFlags = - DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool | DescriptorSetLayoutCreateFlagBits::ePushDescriptor | - DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT | DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT | - DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV | DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT | - DescriptorSetLayoutCreateFlagBits::ePerStageNV; - }; - - // wrapper class for enum VkDescriptorType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorType.html - enum class DescriptorType - { - eSampler = VK_DESCRIPTOR_TYPE_SAMPLER, - eCombinedImageSampler = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, - eSampledImage = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, - eStorageImage = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, - eUniformTexelBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, - eStorageTexelBuffer = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, - eUniformBuffer = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, - eStorageBuffer = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, - eUniformBufferDynamic = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, - eStorageBufferDynamic = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, - eInputAttachment = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, - eInlineUniformBlock = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, - eInlineUniformBlockEXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, - eAccelerationStructureKHR = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, - eAccelerationStructureNV = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, - eSampleWeightImageQCOM = VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, - eBlockMatchImageQCOM = VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, - eTensorARM = VK_DESCRIPTOR_TYPE_TENSOR_ARM, - eMutableEXT = VK_DESCRIPTOR_TYPE_MUTABLE_EXT, - eMutableVALVE = VK_DESCRIPTOR_TYPE_MUTABLE_VALVE, - ePartitionedAccelerationStructureNV = VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV - }; - - enum class DescriptorPoolResetFlagBits : VkDescriptorPoolResetFlags - { - }; - - // wrapper using for bitmask VkDescriptorPoolResetFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolResetFlags.html - using DescriptorPoolResetFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorPoolResetFlags allFlags = {}; - }; - - // wrapper class for enum VkQueryPipelineStatisticFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPipelineStatisticFlagBits.html - enum class QueryPipelineStatisticFlagBits : VkQueryPipelineStatisticFlags - { - eInputAssemblyVertices = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT, - eInputAssemblyPrimitives = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT, - eVertexShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, - eGeometryShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT, - eGeometryShaderPrimitives = VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT, - eClippingInvocations = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT, - eClippingPrimitives = VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT, - eFragmentShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT, - eTessellationControlShaderPatches = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT, - eTessellationEvaluationShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT, - eComputeShaderInvocations = VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT, - eTaskShaderInvocationsEXT = VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT, - eMeshShaderInvocationsEXT = VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT, - eClusterCullingShaderInvocationsHUAWEI = VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI - }; - - // wrapper using for bitmask VkQueryPipelineStatisticFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPipelineStatisticFlags.html - using QueryPipelineStatisticFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkQueryPipelineStatisticFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR QueryPipelineStatisticFlags allFlags = - QueryPipelineStatisticFlagBits::eInputAssemblyVertices | QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives | - QueryPipelineStatisticFlagBits::eVertexShaderInvocations | QueryPipelineStatisticFlagBits::eGeometryShaderInvocations | - QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives | QueryPipelineStatisticFlagBits::eClippingInvocations | - QueryPipelineStatisticFlagBits::eClippingPrimitives | QueryPipelineStatisticFlagBits::eFragmentShaderInvocations | - QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches | QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations | - QueryPipelineStatisticFlagBits::eComputeShaderInvocations | QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT | - QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT | QueryPipelineStatisticFlagBits::eClusterCullingShaderInvocationsHUAWEI; - }; - - // wrapper class for enum VkPipelineBindPoint, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBindPoint.html - enum class PipelineBindPoint - { - eGraphics = VK_PIPELINE_BIND_POINT_GRAPHICS, - eCompute = VK_PIPELINE_BIND_POINT_COMPUTE, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eExecutionGraphAMDX = VK_PIPELINE_BIND_POINT_EXECUTION_GRAPH_AMDX, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eRayTracingKHR = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, - eRayTracingNV = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, - eSubpassShadingHUAWEI = VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI, - eDataGraphARM = VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM - }; - - // wrapper class for enum VkBlendFactor, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlendFactor.html - enum class BlendFactor - { - eZero = VK_BLEND_FACTOR_ZERO, - eOne = VK_BLEND_FACTOR_ONE, - eSrcColor = VK_BLEND_FACTOR_SRC_COLOR, - eOneMinusSrcColor = VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, - eDstColor = VK_BLEND_FACTOR_DST_COLOR, - eOneMinusDstColor = VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, - eSrcAlpha = VK_BLEND_FACTOR_SRC_ALPHA, - eOneMinusSrcAlpha = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, - eDstAlpha = VK_BLEND_FACTOR_DST_ALPHA, - eOneMinusDstAlpha = VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, - eConstantColor = VK_BLEND_FACTOR_CONSTANT_COLOR, - eOneMinusConstantColor = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, - eConstantAlpha = VK_BLEND_FACTOR_CONSTANT_ALPHA, - eOneMinusConstantAlpha = VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, - eSrcAlphaSaturate = VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, - eSrc1Color = VK_BLEND_FACTOR_SRC1_COLOR, - eOneMinusSrc1Color = VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, - eSrc1Alpha = VK_BLEND_FACTOR_SRC1_ALPHA, - eOneMinusSrc1Alpha = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - }; - - // wrapper class for enum VkBlendOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlendOp.html - enum class BlendOp - { - eAdd = VK_BLEND_OP_ADD, - eSubtract = VK_BLEND_OP_SUBTRACT, - eReverseSubtract = VK_BLEND_OP_REVERSE_SUBTRACT, - eMin = VK_BLEND_OP_MIN, - eMax = VK_BLEND_OP_MAX, - eZeroEXT = VK_BLEND_OP_ZERO_EXT, - eSrcEXT = VK_BLEND_OP_SRC_EXT, - eDstEXT = VK_BLEND_OP_DST_EXT, - eSrcOverEXT = VK_BLEND_OP_SRC_OVER_EXT, - eDstOverEXT = VK_BLEND_OP_DST_OVER_EXT, - eSrcInEXT = VK_BLEND_OP_SRC_IN_EXT, - eDstInEXT = VK_BLEND_OP_DST_IN_EXT, - eSrcOutEXT = VK_BLEND_OP_SRC_OUT_EXT, - eDstOutEXT = VK_BLEND_OP_DST_OUT_EXT, - eSrcAtopEXT = VK_BLEND_OP_SRC_ATOP_EXT, - eDstAtopEXT = VK_BLEND_OP_DST_ATOP_EXT, - eXorEXT = VK_BLEND_OP_XOR_EXT, - eMultiplyEXT = VK_BLEND_OP_MULTIPLY_EXT, - eScreenEXT = VK_BLEND_OP_SCREEN_EXT, - eOverlayEXT = VK_BLEND_OP_OVERLAY_EXT, - eDarkenEXT = VK_BLEND_OP_DARKEN_EXT, - eLightenEXT = VK_BLEND_OP_LIGHTEN_EXT, - eColordodgeEXT = VK_BLEND_OP_COLORDODGE_EXT, - eColorburnEXT = VK_BLEND_OP_COLORBURN_EXT, - eHardlightEXT = VK_BLEND_OP_HARDLIGHT_EXT, - eSoftlightEXT = VK_BLEND_OP_SOFTLIGHT_EXT, - eDifferenceEXT = VK_BLEND_OP_DIFFERENCE_EXT, - eExclusionEXT = VK_BLEND_OP_EXCLUSION_EXT, - eInvertEXT = VK_BLEND_OP_INVERT_EXT, - eInvertRgbEXT = VK_BLEND_OP_INVERT_RGB_EXT, - eLineardodgeEXT = VK_BLEND_OP_LINEARDODGE_EXT, - eLinearburnEXT = VK_BLEND_OP_LINEARBURN_EXT, - eVividlightEXT = VK_BLEND_OP_VIVIDLIGHT_EXT, - eLinearlightEXT = VK_BLEND_OP_LINEARLIGHT_EXT, - ePinlightEXT = VK_BLEND_OP_PINLIGHT_EXT, - eHardmixEXT = VK_BLEND_OP_HARDMIX_EXT, - eHslHueEXT = VK_BLEND_OP_HSL_HUE_EXT, - eHslSaturationEXT = VK_BLEND_OP_HSL_SATURATION_EXT, - eHslColorEXT = VK_BLEND_OP_HSL_COLOR_EXT, - eHslLuminosityEXT = VK_BLEND_OP_HSL_LUMINOSITY_EXT, - ePlusEXT = VK_BLEND_OP_PLUS_EXT, - ePlusClampedEXT = VK_BLEND_OP_PLUS_CLAMPED_EXT, - ePlusClampedAlphaEXT = VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, - ePlusDarkerEXT = VK_BLEND_OP_PLUS_DARKER_EXT, - eMinusEXT = VK_BLEND_OP_MINUS_EXT, - eMinusClampedEXT = VK_BLEND_OP_MINUS_CLAMPED_EXT, - eContrastEXT = VK_BLEND_OP_CONTRAST_EXT, - eInvertOvgEXT = VK_BLEND_OP_INVERT_OVG_EXT, - eRedEXT = VK_BLEND_OP_RED_EXT, - eGreenEXT = VK_BLEND_OP_GREEN_EXT, - eBlueEXT = VK_BLEND_OP_BLUE_EXT - }; - - // wrapper class for enum VkColorComponentFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorComponentFlagBits.html - enum class ColorComponentFlagBits : VkColorComponentFlags - { - eR = VK_COLOR_COMPONENT_R_BIT, - eG = VK_COLOR_COMPONENT_G_BIT, - eB = VK_COLOR_COMPONENT_B_BIT, - eA = VK_COLOR_COMPONENT_A_BIT - }; - - // wrapper using for bitmask VkColorComponentFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorComponentFlags.html - using ColorComponentFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkColorComponentFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ColorComponentFlags allFlags = - ColorComponentFlagBits::eR | ColorComponentFlagBits::eG | ColorComponentFlagBits::eB | ColorComponentFlagBits::eA; - }; - - // wrapper class for enum VkCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompareOp.html - enum class CompareOp - { - eNever = VK_COMPARE_OP_NEVER, - eLess = VK_COMPARE_OP_LESS, - eEqual = VK_COMPARE_OP_EQUAL, - eLessOrEqual = VK_COMPARE_OP_LESS_OR_EQUAL, - eGreater = VK_COMPARE_OP_GREATER, - eNotEqual = VK_COMPARE_OP_NOT_EQUAL, - eGreaterOrEqual = VK_COMPARE_OP_GREATER_OR_EQUAL, - eAlways = VK_COMPARE_OP_ALWAYS - }; - - // wrapper class for enum VkCullModeFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCullModeFlagBits.html - enum class CullModeFlagBits : VkCullModeFlags - { - eNone = VK_CULL_MODE_NONE, - eFront = VK_CULL_MODE_FRONT_BIT, - eBack = VK_CULL_MODE_BACK_BIT, - eFrontAndBack = VK_CULL_MODE_FRONT_AND_BACK - }; - - // wrapper using for bitmask VkCullModeFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCullModeFlags.html - using CullModeFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkCullModeFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR CullModeFlags allFlags = - CullModeFlagBits::eNone | CullModeFlagBits::eFront | CullModeFlagBits::eBack | CullModeFlagBits::eFrontAndBack; - }; - - // wrapper class for enum VkDynamicState, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDynamicState.html - enum class DynamicState - { - eViewport = VK_DYNAMIC_STATE_VIEWPORT, - eScissor = VK_DYNAMIC_STATE_SCISSOR, - eLineWidth = VK_DYNAMIC_STATE_LINE_WIDTH, - eDepthBias = VK_DYNAMIC_STATE_DEPTH_BIAS, - eBlendConstants = VK_DYNAMIC_STATE_BLEND_CONSTANTS, - eDepthBounds = VK_DYNAMIC_STATE_DEPTH_BOUNDS, - eStencilCompareMask = VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, - eStencilWriteMask = VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, - eStencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE, - eCullMode = VK_DYNAMIC_STATE_CULL_MODE, - eCullModeEXT = VK_DYNAMIC_STATE_CULL_MODE_EXT, - eFrontFace = VK_DYNAMIC_STATE_FRONT_FACE, - eFrontFaceEXT = VK_DYNAMIC_STATE_FRONT_FACE_EXT, - ePrimitiveTopology = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, - ePrimitiveTopologyEXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT, - eViewportWithCount = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, - eViewportWithCountEXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT, - eScissorWithCount = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, - eScissorWithCountEXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT, - eVertexInputBindingStride = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE, - eVertexInputBindingStrideEXT = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT, - eDepthTestEnable = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE, - eDepthTestEnableEXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT, - eDepthWriteEnable = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE, - eDepthWriteEnableEXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT, - eDepthCompareOp = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP, - eDepthCompareOpEXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT, - eDepthBoundsTestEnable = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE, - eDepthBoundsTestEnableEXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT, - eStencilTestEnable = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE, - eStencilTestEnableEXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT, - eStencilOp = VK_DYNAMIC_STATE_STENCIL_OP, - eStencilOpEXT = VK_DYNAMIC_STATE_STENCIL_OP_EXT, - eRasterizerDiscardEnable = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE, - eRasterizerDiscardEnableEXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT, - eDepthBiasEnable = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE, - eDepthBiasEnableEXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT, - ePrimitiveRestartEnable = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE, - ePrimitiveRestartEnableEXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT, - eLineStipple = VK_DYNAMIC_STATE_LINE_STIPPLE, - eLineStippleEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_EXT, - eLineStippleKHR = VK_DYNAMIC_STATE_LINE_STIPPLE_KHR, - eViewportWScalingNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, - eDiscardRectangleEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, - eDiscardRectangleEnableEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT, - eDiscardRectangleModeEXT = VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT, - eSampleLocationsEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, - eRayTracingPipelineStackSizeKHR = VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR, - eViewportShadingRatePaletteNV = VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV, - eViewportCoarseSampleOrderNV = VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV, - eExclusiveScissorEnableNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV, - eExclusiveScissorNV = VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV, - eFragmentShadingRateKHR = VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR, - eVertexInputEXT = VK_DYNAMIC_STATE_VERTEX_INPUT_EXT, - ePatchControlPointsEXT = VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT, - eLogicOpEXT = VK_DYNAMIC_STATE_LOGIC_OP_EXT, - eColorWriteEnableEXT = VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT, - eDepthClampEnableEXT = VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT, - ePolygonModeEXT = VK_DYNAMIC_STATE_POLYGON_MODE_EXT, - eRasterizationSamplesEXT = VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT, - eSampleMaskEXT = VK_DYNAMIC_STATE_SAMPLE_MASK_EXT, - eAlphaToCoverageEnableEXT = VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT, - eAlphaToOneEnableEXT = VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT, - eLogicOpEnableEXT = VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT, - eColorBlendEnableEXT = VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT, - eColorBlendEquationEXT = VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT, - eColorWriteMaskEXT = VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT, - eTessellationDomainOriginEXT = VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT, - eRasterizationStreamEXT = VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT, - eConservativeRasterizationModeEXT = VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT, - eExtraPrimitiveOverestimationSizeEXT = VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT, - eDepthClipEnableEXT = VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT, - eSampleLocationsEnableEXT = VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT, - eColorBlendAdvancedEXT = VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT, - eProvokingVertexModeEXT = VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT, - eLineRasterizationModeEXT = VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT, - eLineStippleEnableEXT = VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT, - eDepthClipNegativeOneToOneEXT = VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT, - eViewportWScalingEnableNV = VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV, - eViewportSwizzleNV = VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV, - eCoverageToColorEnableNV = VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV, - eCoverageToColorLocationNV = VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV, - eCoverageModulationModeNV = VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV, - eCoverageModulationTableEnableNV = VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV, - eCoverageModulationTableNV = VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV, - eShadingRateImageEnableNV = VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV, - eRepresentativeFragmentTestEnableNV = VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV, - eCoverageReductionModeNV = VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV, - eAttachmentFeedbackLoopEnableEXT = VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT, - eDepthClampRangeEXT = VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT - }; - - // wrapper class for enum VkFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrontFace.html - enum class FrontFace - { - eCounterClockwise = VK_FRONT_FACE_COUNTER_CLOCKWISE, - eClockwise = VK_FRONT_FACE_CLOCKWISE - }; - - // wrapper class for enum VkLogicOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLogicOp.html - enum class LogicOp - { - eClear = VK_LOGIC_OP_CLEAR, - eAnd = VK_LOGIC_OP_AND, - eAndReverse = VK_LOGIC_OP_AND_REVERSE, - eCopy = VK_LOGIC_OP_COPY, - eAndInverted = VK_LOGIC_OP_AND_INVERTED, - eNoOp = VK_LOGIC_OP_NO_OP, - eXor = VK_LOGIC_OP_XOR, - eOr = VK_LOGIC_OP_OR, - eNor = VK_LOGIC_OP_NOR, - eEquivalent = VK_LOGIC_OP_EQUIVALENT, - eInvert = VK_LOGIC_OP_INVERT, - eOrReverse = VK_LOGIC_OP_OR_REVERSE, - eCopyInverted = VK_LOGIC_OP_COPY_INVERTED, - eOrInverted = VK_LOGIC_OP_OR_INVERTED, - eNand = VK_LOGIC_OP_NAND, - eSet = VK_LOGIC_OP_SET - }; - - // wrapper class for enum VkPolygonMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPolygonMode.html - enum class PolygonMode - { - eFill = VK_POLYGON_MODE_FILL, - eLine = VK_POLYGON_MODE_LINE, - ePoint = VK_POLYGON_MODE_POINT, - eFillRectangleNV = VK_POLYGON_MODE_FILL_RECTANGLE_NV - }; - - // wrapper class for enum VkPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrimitiveTopology.html - enum class PrimitiveTopology - { - ePointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, - eLineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST, - eLineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, - eTriangleList = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, - eTriangleStrip = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, - eTriangleFan = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, - eLineListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, - eLineStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, - eTriangleListWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, - eTriangleStripWithAdjacency = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, - ePatchList = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - }; - - // wrapper class for enum VkStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilOp.html - enum class StencilOp - { - eKeep = VK_STENCIL_OP_KEEP, - eZero = VK_STENCIL_OP_ZERO, - eReplace = VK_STENCIL_OP_REPLACE, - eIncrementAndClamp = VK_STENCIL_OP_INCREMENT_AND_CLAMP, - eDecrementAndClamp = VK_STENCIL_OP_DECREMENT_AND_CLAMP, - eInvert = VK_STENCIL_OP_INVERT, - eIncrementAndWrap = VK_STENCIL_OP_INCREMENT_AND_WRAP, - eDecrementAndWrap = VK_STENCIL_OP_DECREMENT_AND_WRAP - }; - - // wrapper class for enum VkVertexInputRate, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputRate.html - enum class VertexInputRate - { - eVertex = VK_VERTEX_INPUT_RATE_VERTEX, - eInstance = VK_VERTEX_INPUT_RATE_INSTANCE - }; - - // wrapper class for enum VkPipelineColorBlendStateCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendStateCreateFlagBits.html - enum class PipelineColorBlendStateCreateFlagBits : VkPipelineColorBlendStateCreateFlags - { - eRasterizationOrderAttachmentAccessEXT = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT, - eRasterizationOrderAttachmentAccessARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM - }; - - // wrapper using for bitmask VkPipelineColorBlendStateCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendStateCreateFlags.html - using PipelineColorBlendStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPipelineColorBlendStateCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineColorBlendStateCreateFlags allFlags = - PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT; - }; - - // wrapper class for enum VkPipelineDepthStencilStateCreateFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDepthStencilStateCreateFlagBits.html - enum class PipelineDepthStencilStateCreateFlagBits : VkPipelineDepthStencilStateCreateFlags - { - eRasterizationOrderAttachmentDepthAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, - eRasterizationOrderAttachmentDepthAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM, - eRasterizationOrderAttachmentStencilAccessEXT = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, - eRasterizationOrderAttachmentStencilAccessARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM - }; - - // wrapper using for bitmask VkPipelineDepthStencilStateCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDepthStencilStateCreateFlags.html - using PipelineDepthStencilStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPipelineDepthStencilStateCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDepthStencilStateCreateFlags allFlags = - PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT | - PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT; - }; - - enum class PipelineDynamicStateCreateFlagBits : VkPipelineDynamicStateCreateFlags - { - }; - - // wrapper using for bitmask VkPipelineDynamicStateCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDynamicStateCreateFlags.html - using PipelineDynamicStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDynamicStateCreateFlags allFlags = {}; - }; - - enum class PipelineInputAssemblyStateCreateFlagBits : VkPipelineInputAssemblyStateCreateFlags - { - }; - - // wrapper using for bitmask VkPipelineInputAssemblyStateCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineInputAssemblyStateCreateFlags.html - using PipelineInputAssemblyStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineInputAssemblyStateCreateFlags allFlags = {}; - }; - - enum class PipelineMultisampleStateCreateFlagBits : VkPipelineMultisampleStateCreateFlags - { - }; - - // wrapper using for bitmask VkPipelineMultisampleStateCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineMultisampleStateCreateFlags.html - using PipelineMultisampleStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineMultisampleStateCreateFlags allFlags = {}; - }; - - enum class PipelineRasterizationStateCreateFlagBits : VkPipelineRasterizationStateCreateFlags - { - }; - - // wrapper using for bitmask VkPipelineRasterizationStateCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateCreateFlags.html - using PipelineRasterizationStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationStateCreateFlags allFlags = {}; - }; - - enum class PipelineTessellationStateCreateFlagBits : VkPipelineTessellationStateCreateFlags - { - }; - - // wrapper using for bitmask VkPipelineTessellationStateCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineTessellationStateCreateFlags.html - using PipelineTessellationStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineTessellationStateCreateFlags allFlags = {}; - }; - - enum class PipelineVertexInputStateCreateFlagBits : VkPipelineVertexInputStateCreateFlags - { - }; - - // wrapper using for bitmask VkPipelineVertexInputStateCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineVertexInputStateCreateFlags.html - using PipelineVertexInputStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineVertexInputStateCreateFlags allFlags = {}; - }; - - enum class PipelineViewportStateCreateFlagBits : VkPipelineViewportStateCreateFlags - { - }; - - // wrapper using for bitmask VkPipelineViewportStateCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportStateCreateFlags.html - using PipelineViewportStateCreateFlags = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineViewportStateCreateFlags allFlags = {}; - }; - - // wrapper class for enum VkAttachmentDescriptionFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescriptionFlagBits.html - enum class AttachmentDescriptionFlagBits : VkAttachmentDescriptionFlags - { - eMayAlias = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT, - eResolveSkipTransferFunctionKHR = VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR, - eResolveEnableTransferFunctionKHR = VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR - }; - - // wrapper using for bitmask VkAttachmentDescriptionFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescriptionFlags.html - using AttachmentDescriptionFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkAttachmentDescriptionFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR AttachmentDescriptionFlags allFlags = AttachmentDescriptionFlagBits::eMayAlias | - AttachmentDescriptionFlagBits::eResolveSkipTransferFunctionKHR | - AttachmentDescriptionFlagBits::eResolveEnableTransferFunctionKHR; - }; - - // wrapper class for enum VkAttachmentLoadOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentLoadOp.html - enum class AttachmentLoadOp - { - eLoad = VK_ATTACHMENT_LOAD_OP_LOAD, - eClear = VK_ATTACHMENT_LOAD_OP_CLEAR, - eDontCare = VK_ATTACHMENT_LOAD_OP_DONT_CARE, - eNone = VK_ATTACHMENT_LOAD_OP_NONE, - eNoneEXT = VK_ATTACHMENT_LOAD_OP_NONE_EXT, - eNoneKHR = VK_ATTACHMENT_LOAD_OP_NONE_KHR - }; - - // wrapper class for enum VkAttachmentStoreOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentStoreOp.html - enum class AttachmentStoreOp - { - eStore = VK_ATTACHMENT_STORE_OP_STORE, - eDontCare = VK_ATTACHMENT_STORE_OP_DONT_CARE, - eNone = VK_ATTACHMENT_STORE_OP_NONE, - eNoneKHR = VK_ATTACHMENT_STORE_OP_NONE_KHR, - eNoneQCOM = VK_ATTACHMENT_STORE_OP_NONE_QCOM, - eNoneEXT = VK_ATTACHMENT_STORE_OP_NONE_EXT - }; - - // wrapper class for enum VkFramebufferCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferCreateFlagBits.html - enum class FramebufferCreateFlagBits : VkFramebufferCreateFlags - { - eImageless = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, - eImagelessKHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR - }; - - // wrapper using for bitmask VkFramebufferCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferCreateFlags.html - using FramebufferCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkFramebufferCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR FramebufferCreateFlags allFlags = FramebufferCreateFlagBits::eImageless; - }; - - // wrapper class for enum VkRenderPassCreateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateFlagBits.html - enum class RenderPassCreateFlagBits : VkRenderPassCreateFlags - { - eTransformQCOM = VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM, - ePerLayerFragmentDensityVALVE = VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE - }; - - // wrapper using for bitmask VkRenderPassCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateFlags.html - using RenderPassCreateFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkRenderPassCreateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR RenderPassCreateFlags allFlags = - RenderPassCreateFlagBits::eTransformQCOM | RenderPassCreateFlagBits::ePerLayerFragmentDensityVALVE; - }; - - // wrapper class for enum VkSubpassDescriptionFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescriptionFlagBits.html - enum class SubpassDescriptionFlagBits : VkSubpassDescriptionFlags - { - ePerViewAttributesNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX, - ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, - eTileShadingApronQCOM = VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM, - eRasterizationOrderAttachmentColorAccessEXT = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT, - eRasterizationOrderAttachmentColorAccessARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM, - eRasterizationOrderAttachmentDepthAccessEXT = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, - eRasterizationOrderAttachmentDepthAccessARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM, - eRasterizationOrderAttachmentStencilAccessEXT = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, - eRasterizationOrderAttachmentStencilAccessARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM, - eEnableLegacyDitheringEXT = VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT, - eFragmentRegionEXT = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT, - eFragmentRegionQCOM = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, - eCustomResolveEXT = VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT, - eShaderResolveQCOM = VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM - }; - - // wrapper using for bitmask VkSubpassDescriptionFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescriptionFlags.html - using SubpassDescriptionFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkSubpassDescriptionFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SubpassDescriptionFlags allFlags = - SubpassDescriptionFlagBits::ePerViewAttributesNVX | SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX | - SubpassDescriptionFlagBits::eTileShadingApronQCOM | SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT | - SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT | SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT | - SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT | SubpassDescriptionFlagBits::eFragmentRegionEXT | SubpassDescriptionFlagBits::eCustomResolveEXT; - }; - - // wrapper class for enum VkStencilFaceFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilFaceFlagBits.html - enum class StencilFaceFlagBits : VkStencilFaceFlags - { - eFront = VK_STENCIL_FACE_FRONT_BIT, - eBack = VK_STENCIL_FACE_BACK_BIT, - eFrontAndBack = VK_STENCIL_FACE_FRONT_AND_BACK, - eVkStencilFrontAndBack = VK_STENCIL_FRONT_AND_BACK - }; - - // wrapper using for bitmask VkStencilFaceFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilFaceFlags.html - using StencilFaceFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkStencilFaceFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StencilFaceFlags allFlags = - StencilFaceFlagBits::eFront | StencilFaceFlagBits::eBack | StencilFaceFlagBits::eFrontAndBack; - }; - - // wrapper class for enum VkSubpassContents, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassContents.html - enum class SubpassContents - { - eInline = VK_SUBPASS_CONTENTS_INLINE, - eSecondaryCommandBuffers = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, - eInlineAndSecondaryCommandBuffersKHR = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR, - eInlineAndSecondaryCommandBuffersEXT = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT - }; - - //=== VK_VERSION_1_1 === - - // wrapper class for enum VkPeerMemoryFeatureFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPeerMemoryFeatureFlagBits.html - enum class PeerMemoryFeatureFlagBits : VkPeerMemoryFeatureFlags - { - eCopySrc = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, - eCopyDst = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, - eGenericSrc = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, - eGenericDst = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT - }; - - using PeerMemoryFeatureFlagBitsKHR = PeerMemoryFeatureFlagBits; - - // wrapper using for bitmask VkPeerMemoryFeatureFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPeerMemoryFeatureFlags.html - using PeerMemoryFeatureFlags = Flags; - using PeerMemoryFeatureFlagsKHR = PeerMemoryFeatureFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkPeerMemoryFeatureFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PeerMemoryFeatureFlags allFlags = PeerMemoryFeatureFlagBits::eCopySrc | PeerMemoryFeatureFlagBits::eCopyDst | - PeerMemoryFeatureFlagBits::eGenericSrc | PeerMemoryFeatureFlagBits::eGenericDst; - }; - - // wrapper class for enum VkMemoryAllocateFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryAllocateFlagBits.html - enum class MemoryAllocateFlagBits : VkMemoryAllocateFlags - { - eDeviceMask = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, - eDeviceAddress = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, - eDeviceAddressCaptureReplay = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, - eZeroInitializeEXT = VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT - }; - - using MemoryAllocateFlagBitsKHR = MemoryAllocateFlagBits; - - // wrapper using for bitmask VkMemoryAllocateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryAllocateFlags.html - using MemoryAllocateFlags = Flags; - using MemoryAllocateFlagsKHR = MemoryAllocateFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkMemoryAllocateFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryAllocateFlags allFlags = MemoryAllocateFlagBits::eDeviceMask | MemoryAllocateFlagBits::eDeviceAddress | - MemoryAllocateFlagBits::eDeviceAddressCaptureReplay | - MemoryAllocateFlagBits::eZeroInitializeEXT; - }; - - enum class CommandPoolTrimFlagBits : VkCommandPoolTrimFlags - { - }; - - // wrapper using for bitmask VkCommandPoolTrimFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolTrimFlags.html - using CommandPoolTrimFlags = Flags; - using CommandPoolTrimFlagsKHR = CommandPoolTrimFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR CommandPoolTrimFlags allFlags = {}; - }; - - // wrapper class for enum VkExternalMemoryHandleTypeFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlagBits.html - enum class ExternalMemoryHandleTypeFlagBits : VkExternalMemoryHandleTypeFlags - { - eOpaqueFd = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, - eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, - eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - eD3D11Texture = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, - eD3D11TextureKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, - eD3D12Heap = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, - eD3D12Resource = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, - eDmaBufEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - eAndroidHardwareBufferANDROID = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - eHostAllocationEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, - eHostMappedForeignMemoryEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, -#if defined( VK_USE_PLATFORM_FUCHSIA ) - eZirconVmoFUCHSIA = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA, -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - eRdmaAddressNV = VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV, -#if defined( VK_USE_PLATFORM_OHOS ) - eOhNativeBufferOHOS = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OH_NATIVE_BUFFER_BIT_OHOS, -#endif /*VK_USE_PLATFORM_OHOS*/ -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - eScreenBufferQNX = VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX, -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ -#if defined( VK_USE_PLATFORM_METAL_EXT ) - eMtlbufferEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLBUFFER_BIT_EXT, - eMtltextureEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLTEXTURE_BIT_EXT, - eMtlheapEXT = VK_EXTERNAL_MEMORY_HANDLE_TYPE_MTLHEAP_BIT_EXT -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - }; - - using ExternalMemoryHandleTypeFlagBitsKHR = ExternalMemoryHandleTypeFlagBits; - - // wrapper using for bitmask VkExternalMemoryHandleTypeFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlags.html - using ExternalMemoryHandleTypeFlags = Flags; - using ExternalMemoryHandleTypeFlagsKHR = ExternalMemoryHandleTypeFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkExternalMemoryHandleTypeFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryHandleTypeFlags allFlags = - ExternalMemoryHandleTypeFlagBits::eOpaqueFd | ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 | ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt | - ExternalMemoryHandleTypeFlagBits::eD3D11Texture | ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt | ExternalMemoryHandleTypeFlagBits::eD3D12Heap | - ExternalMemoryHandleTypeFlagBits::eD3D12Resource | ExternalMemoryHandleTypeFlagBits::eDmaBufEXT -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - | ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - | ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT | ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT -#if defined( VK_USE_PLATFORM_FUCHSIA ) - | ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - | ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV -#if defined( VK_USE_PLATFORM_OHOS ) - | ExternalMemoryHandleTypeFlagBits::eOhNativeBufferOHOS -#endif /*VK_USE_PLATFORM_OHOS*/ -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - | ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ -#if defined( VK_USE_PLATFORM_METAL_EXT ) - | ExternalMemoryHandleTypeFlagBits::eMtlbufferEXT | ExternalMemoryHandleTypeFlagBits::eMtltextureEXT | ExternalMemoryHandleTypeFlagBits::eMtlheapEXT -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - ; - }; - - // wrapper class for enum VkExternalMemoryFeatureFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlagBits.html - enum class ExternalMemoryFeatureFlagBits : VkExternalMemoryFeatureFlags - { - eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, - eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, - eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT - }; - - using ExternalMemoryFeatureFlagBitsKHR = ExternalMemoryFeatureFlagBits; - - // wrapper using for bitmask VkExternalMemoryFeatureFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlags.html - using ExternalMemoryFeatureFlags = Flags; - using ExternalMemoryFeatureFlagsKHR = ExternalMemoryFeatureFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkExternalMemoryFeatureFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryFeatureFlags allFlags = - ExternalMemoryFeatureFlagBits::eDedicatedOnly | ExternalMemoryFeatureFlagBits::eExportable | ExternalMemoryFeatureFlagBits::eImportable; - }; - - // wrapper class for enum VkExternalFenceHandleTypeFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceHandleTypeFlagBits.html - enum class ExternalFenceHandleTypeFlagBits : VkExternalFenceHandleTypeFlags - { - eOpaqueFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, - eOpaqueWin32 = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - eOpaqueWin32Kmt = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - eSyncFd = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT - }; - - using ExternalFenceHandleTypeFlagBitsKHR = ExternalFenceHandleTypeFlagBits; - - // wrapper using for bitmask VkExternalFenceHandleTypeFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceHandleTypeFlags.html - using ExternalFenceHandleTypeFlags = Flags; - using ExternalFenceHandleTypeFlagsKHR = ExternalFenceHandleTypeFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkExternalFenceHandleTypeFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalFenceHandleTypeFlags allFlags = - ExternalFenceHandleTypeFlagBits::eOpaqueFd | ExternalFenceHandleTypeFlagBits::eOpaqueWin32 | ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt | - ExternalFenceHandleTypeFlagBits::eSyncFd; - }; - - // wrapper class for enum VkExternalFenceFeatureFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceFeatureFlagBits.html - enum class ExternalFenceFeatureFlagBits : VkExternalFenceFeatureFlags - { - eExportable = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, - eImportable = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT - }; - - using ExternalFenceFeatureFlagBitsKHR = ExternalFenceFeatureFlagBits; - - // wrapper using for bitmask VkExternalFenceFeatureFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceFeatureFlags.html - using ExternalFenceFeatureFlags = Flags; - using ExternalFenceFeatureFlagsKHR = ExternalFenceFeatureFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkExternalFenceFeatureFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalFenceFeatureFlags allFlags = - ExternalFenceFeatureFlagBits::eExportable | ExternalFenceFeatureFlagBits::eImportable; - }; - - // wrapper class for enum VkFenceImportFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceImportFlagBits.html - enum class FenceImportFlagBits : VkFenceImportFlags - { - eTemporary = VK_FENCE_IMPORT_TEMPORARY_BIT - }; - - using FenceImportFlagBitsKHR = FenceImportFlagBits; - - // wrapper using for bitmask VkFenceImportFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceImportFlags.html - using FenceImportFlags = Flags; - using FenceImportFlagsKHR = FenceImportFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkFenceImportFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR FenceImportFlags allFlags = FenceImportFlagBits::eTemporary; - }; - - // wrapper class for enum VkSemaphoreImportFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreImportFlagBits.html - enum class SemaphoreImportFlagBits : VkSemaphoreImportFlags - { - eTemporary = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT - }; - - using SemaphoreImportFlagBitsKHR = SemaphoreImportFlagBits; - - // wrapper using for bitmask VkSemaphoreImportFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreImportFlags.html - using SemaphoreImportFlags = Flags; - using SemaphoreImportFlagsKHR = SemaphoreImportFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkSemaphoreImportFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreImportFlags allFlags = SemaphoreImportFlagBits::eTemporary; - }; - - // wrapper class for enum VkExternalSemaphoreHandleTypeFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreHandleTypeFlagBits.html - enum class ExternalSemaphoreHandleTypeFlagBits : VkExternalSemaphoreHandleTypeFlags - { - eOpaqueFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, - eOpaqueWin32 = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - eOpaqueWin32Kmt = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - eD3D12Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, - eD3D11Fence = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT, - eSyncFd = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, -#if defined( VK_USE_PLATFORM_FUCHSIA ) - eZirconEventFUCHSIA = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - }; - - using ExternalSemaphoreHandleTypeFlagBitsKHR = ExternalSemaphoreHandleTypeFlagBits; - - // wrapper using for bitmask VkExternalSemaphoreHandleTypeFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreHandleTypeFlags.html - using ExternalSemaphoreHandleTypeFlags = Flags; - using ExternalSemaphoreHandleTypeFlagsKHR = ExternalSemaphoreHandleTypeFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkExternalSemaphoreHandleTypeFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalSemaphoreHandleTypeFlags allFlags = - ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd | ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 | - ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt | ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence | ExternalSemaphoreHandleTypeFlagBits::eSyncFd -#if defined( VK_USE_PLATFORM_FUCHSIA ) - | ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - ; - }; - - // wrapper class for enum VkExternalSemaphoreFeatureFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreFeatureFlagBits.html - enum class ExternalSemaphoreFeatureFlagBits : VkExternalSemaphoreFeatureFlags - { - eExportable = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, - eImportable = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT - }; - - using ExternalSemaphoreFeatureFlagBitsKHR = ExternalSemaphoreFeatureFlagBits; - - // wrapper using for bitmask VkExternalSemaphoreFeatureFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreFeatureFlags.html - using ExternalSemaphoreFeatureFlags = Flags; - using ExternalSemaphoreFeatureFlagsKHR = ExternalSemaphoreFeatureFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkExternalSemaphoreFeatureFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalSemaphoreFeatureFlags allFlags = - ExternalSemaphoreFeatureFlagBits::eExportable | ExternalSemaphoreFeatureFlagBits::eImportable; - }; - - // wrapper class for enum VkSubgroupFeatureFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubgroupFeatureFlagBits.html - enum class SubgroupFeatureFlagBits : VkSubgroupFeatureFlags - { - eBasic = VK_SUBGROUP_FEATURE_BASIC_BIT, - eVote = VK_SUBGROUP_FEATURE_VOTE_BIT, - eArithmetic = VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, - eBallot = VK_SUBGROUP_FEATURE_BALLOT_BIT, - eShuffle = VK_SUBGROUP_FEATURE_SHUFFLE_BIT, - eShuffleRelative = VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, - eClustered = VK_SUBGROUP_FEATURE_CLUSTERED_BIT, - eQuad = VK_SUBGROUP_FEATURE_QUAD_BIT, - eRotate = VK_SUBGROUP_FEATURE_ROTATE_BIT, - eRotateKHR = VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR, - eRotateClustered = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT, - eRotateClusteredKHR = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR, - ePartitionedEXT = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT, - ePartitionedNV = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV - }; - - // wrapper using for bitmask VkSubgroupFeatureFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubgroupFeatureFlags.html - using SubgroupFeatureFlags = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkSubgroupFeatureFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SubgroupFeatureFlags allFlags = - SubgroupFeatureFlagBits::eBasic | SubgroupFeatureFlagBits::eVote | SubgroupFeatureFlagBits::eArithmetic | SubgroupFeatureFlagBits::eBallot | - SubgroupFeatureFlagBits::eShuffle | SubgroupFeatureFlagBits::eShuffleRelative | SubgroupFeatureFlagBits::eClustered | SubgroupFeatureFlagBits::eQuad | - SubgroupFeatureFlagBits::eRotate | SubgroupFeatureFlagBits::eRotateClustered | SubgroupFeatureFlagBits::ePartitionedEXT; - }; - - // wrapper class for enum VkDescriptorUpdateTemplateType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateType.html - enum class DescriptorUpdateTemplateType - { - eDescriptorSet = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, - ePushDescriptors = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS - }; - - using DescriptorUpdateTemplateTypeKHR = DescriptorUpdateTemplateType; - - enum class DescriptorUpdateTemplateCreateFlagBits : VkDescriptorUpdateTemplateCreateFlags - { - }; - - // wrapper using for bitmask VkDescriptorUpdateTemplateCreateFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateCreateFlags.html - using DescriptorUpdateTemplateCreateFlags = Flags; - using DescriptorUpdateTemplateCreateFlagsKHR = DescriptorUpdateTemplateCreateFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorUpdateTemplateCreateFlags allFlags = {}; - }; - - // wrapper class for enum VkSamplerYcbcrModelConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrModelConversion.html - enum class SamplerYcbcrModelConversion - { - eRgbIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, - eYcbcrIdentity = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, - eYcbcr709 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, - eYcbcr601 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, - eYcbcr2020 = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 - }; - - using SamplerYcbcrModelConversionKHR = SamplerYcbcrModelConversion; - - // wrapper class for enum VkSamplerYcbcrRange, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrRange.html - enum class SamplerYcbcrRange - { - eItuFull = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, - eItuNarrow = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW - }; - - using SamplerYcbcrRangeKHR = SamplerYcbcrRange; - - // wrapper class for enum VkChromaLocation, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkChromaLocation.html - enum class ChromaLocation - { - eCositedEven = VK_CHROMA_LOCATION_COSITED_EVEN, - eMidpoint = VK_CHROMA_LOCATION_MIDPOINT - }; - - using ChromaLocationKHR = ChromaLocation; - - // wrapper class for enum VkPointClippingBehavior, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPointClippingBehavior.html - enum class PointClippingBehavior - { - eAllClipPlanes = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, - eUserClipPlanesOnly = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY - }; - - using PointClippingBehaviorKHR = PointClippingBehavior; - - // wrapper class for enum VkTessellationDomainOrigin, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTessellationDomainOrigin.html - enum class TessellationDomainOrigin - { - eUpperLeft = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, - eLowerLeft = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT - }; - - using TessellationDomainOriginKHR = TessellationDomainOrigin; - - //=== VK_VERSION_1_2 === - - // wrapper class for enum VkDriverId, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDriverId.html - enum class DriverId - { - eAmdProprietary = VK_DRIVER_ID_AMD_PROPRIETARY, - eAmdOpenSource = VK_DRIVER_ID_AMD_OPEN_SOURCE, - eMesaRadv = VK_DRIVER_ID_MESA_RADV, - eNvidiaProprietary = VK_DRIVER_ID_NVIDIA_PROPRIETARY, - eIntelProprietaryWindows = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS, - eIntelOpenSourceMESA = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA, - eImaginationProprietary = VK_DRIVER_ID_IMAGINATION_PROPRIETARY, - eQualcommProprietary = VK_DRIVER_ID_QUALCOMM_PROPRIETARY, - eArmProprietary = VK_DRIVER_ID_ARM_PROPRIETARY, - eGoogleSwiftshader = VK_DRIVER_ID_GOOGLE_SWIFTSHADER, - eGgpProprietary = VK_DRIVER_ID_GGP_PROPRIETARY, - eBroadcomProprietary = VK_DRIVER_ID_BROADCOM_PROPRIETARY, - eMesaLlvmpipe = VK_DRIVER_ID_MESA_LLVMPIPE, - eMoltenvk = VK_DRIVER_ID_MOLTENVK, - eCoreaviProprietary = VK_DRIVER_ID_COREAVI_PROPRIETARY, - eJuiceProprietary = VK_DRIVER_ID_JUICE_PROPRIETARY, - eVerisiliconProprietary = VK_DRIVER_ID_VERISILICON_PROPRIETARY, - eMesaTurnip = VK_DRIVER_ID_MESA_TURNIP, - eMesaV3Dv = VK_DRIVER_ID_MESA_V3DV, - eMesaPanvk = VK_DRIVER_ID_MESA_PANVK, - eSamsungProprietary = VK_DRIVER_ID_SAMSUNG_PROPRIETARY, - eMesaVenus = VK_DRIVER_ID_MESA_VENUS, - eMesaDozen = VK_DRIVER_ID_MESA_DOZEN, - eMesaNvk = VK_DRIVER_ID_MESA_NVK, - eImaginationOpenSourceMESA = VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA, - eMesaHoneykrisp = VK_DRIVER_ID_MESA_HONEYKRISP, - eVulkanScEmulationOnVulkan = VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN, - eMesaKosmickrisp = VK_DRIVER_ID_MESA_KOSMICKRISP - }; - - using DriverIdKHR = DriverId; - - // wrapper class for enum VkSemaphoreType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreType.html - enum class SemaphoreType - { - eBinary = VK_SEMAPHORE_TYPE_BINARY, - eTimeline = VK_SEMAPHORE_TYPE_TIMELINE - }; - - using SemaphoreTypeKHR = SemaphoreType; - - // wrapper class for enum VkSemaphoreWaitFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreWaitFlagBits.html - enum class SemaphoreWaitFlagBits : VkSemaphoreWaitFlags - { - eAny = VK_SEMAPHORE_WAIT_ANY_BIT - }; - - using SemaphoreWaitFlagBitsKHR = SemaphoreWaitFlagBits; - - // wrapper using for bitmask VkSemaphoreWaitFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreWaitFlags.html - using SemaphoreWaitFlags = Flags; - using SemaphoreWaitFlagsKHR = SemaphoreWaitFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkSemaphoreWaitFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SemaphoreWaitFlags allFlags = SemaphoreWaitFlagBits::eAny; - }; - - // wrapper class for enum VkShaderFloatControlsIndependence, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderFloatControlsIndependence.html - enum class ShaderFloatControlsIndependence - { - e32BitOnly = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, - eAll = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, - eNone = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE - }; - - using ShaderFloatControlsIndependenceKHR = ShaderFloatControlsIndependence; - - // wrapper class for enum VkDescriptorBindingFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBindingFlagBits.html - enum class DescriptorBindingFlagBits : VkDescriptorBindingFlags - { - eUpdateAfterBind = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, - eUpdateUnusedWhilePending = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, - ePartiallyBound = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, - eVariableDescriptorCount = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT - }; - - using DescriptorBindingFlagBitsEXT = DescriptorBindingFlagBits; - - // wrapper using for bitmask VkDescriptorBindingFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBindingFlags.html - using DescriptorBindingFlags = Flags; - using DescriptorBindingFlagsEXT = DescriptorBindingFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkDescriptorBindingFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DescriptorBindingFlags allFlags = - DescriptorBindingFlagBits::eUpdateAfterBind | DescriptorBindingFlagBits::eUpdateUnusedWhilePending | DescriptorBindingFlagBits::ePartiallyBound | - DescriptorBindingFlagBits::eVariableDescriptorCount; - }; - - // wrapper class for enum VkSamplerReductionMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerReductionMode.html - enum class SamplerReductionMode - { - eWeightedAverage = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, - eMin = VK_SAMPLER_REDUCTION_MODE_MIN, - eMax = VK_SAMPLER_REDUCTION_MODE_MAX, - eWeightedAverageRangeclampQCOM = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM - }; - - using SamplerReductionModeEXT = SamplerReductionMode; - - // wrapper class for enum VkResolveModeFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveModeFlagBits.html - enum class ResolveModeFlagBits : VkResolveModeFlags - { - eNone = VK_RESOLVE_MODE_NONE, - eSampleZero = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, - eAverage = VK_RESOLVE_MODE_AVERAGE_BIT, - eMin = VK_RESOLVE_MODE_MIN_BIT, - eMax = VK_RESOLVE_MODE_MAX_BIT, -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - eExternalFormatDownsampleANDROID = VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_BIT_ANDROID, -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - eCustomEXT = VK_RESOLVE_MODE_CUSTOM_BIT_EXT - }; - - using ResolveModeFlagBitsKHR = ResolveModeFlagBits; - - // wrapper using for bitmask VkResolveModeFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveModeFlags.html - using ResolveModeFlags = Flags; - using ResolveModeFlagsKHR = ResolveModeFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkResolveModeFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveModeFlags allFlags = ResolveModeFlagBits::eNone | ResolveModeFlagBits::eSampleZero | - ResolveModeFlagBits::eAverage | ResolveModeFlagBits::eMin | ResolveModeFlagBits::eMax -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - | ResolveModeFlagBits::eExternalFormatDownsampleANDROID -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - | ResolveModeFlagBits::eCustomEXT; - }; - - //=== VK_VERSION_1_3 === - - // wrapper class for enum VkToolPurposeFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkToolPurposeFlagBits.html - enum class ToolPurposeFlagBits : VkToolPurposeFlags - { - eValidation = VK_TOOL_PURPOSE_VALIDATION_BIT, - eProfiling = VK_TOOL_PURPOSE_PROFILING_BIT, - eTracing = VK_TOOL_PURPOSE_TRACING_BIT, - eAdditionalFeatures = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, - eModifyingFeatures = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT, - eDebugReportingEXT = VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT, - eDebugMarkersEXT = VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT - }; - - using ToolPurposeFlagBitsEXT = ToolPurposeFlagBits; - - // wrapper using for bitmask VkToolPurposeFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkToolPurposeFlags.html - using ToolPurposeFlags = Flags; - using ToolPurposeFlagsEXT = ToolPurposeFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkToolPurposeFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ToolPurposeFlags allFlags = - ToolPurposeFlagBits::eValidation | ToolPurposeFlagBits::eProfiling | ToolPurposeFlagBits::eTracing | ToolPurposeFlagBits::eAdditionalFeatures | - ToolPurposeFlagBits::eModifyingFeatures | ToolPurposeFlagBits::eDebugReportingEXT | ToolPurposeFlagBits::eDebugMarkersEXT; - }; - - enum class PrivateDataSlotCreateFlagBits : VkPrivateDataSlotCreateFlags - { - }; - - using PrivateDataSlotCreateFlagBitsEXT = PrivateDataSlotCreateFlagBits; - - // wrapper using for bitmask VkPrivateDataSlotCreateFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlotCreateFlags.html - using PrivateDataSlotCreateFlags = Flags; - using PrivateDataSlotCreateFlagsEXT = PrivateDataSlotCreateFlags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PrivateDataSlotCreateFlags allFlags = {}; - }; - - // wrapper class for enum VkPipelineStageFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlagBits2.html - enum class PipelineStageFlagBits2 : VkPipelineStageFlags2 - { - eNone = VK_PIPELINE_STAGE_2_NONE, - eTopOfPipe = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT, - eDrawIndirect = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT, - eVertexInput = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT, - eVertexShader = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT, - eTessellationControlShader = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT, - eTessellationEvaluationShader = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT, - eGeometryShader = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT, - eFragmentShader = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT, - eEarlyFragmentTests = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT, - eLateFragmentTests = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT, - eColorAttachmentOutput = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT, - eComputeShader = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT, - eAllTransfer = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT, - eTransfer = VK_PIPELINE_STAGE_2_TRANSFER_BIT, - eBottomOfPipe = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT, - eHost = VK_PIPELINE_STAGE_2_HOST_BIT, - eAllGraphics = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, - eAllCommands = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, - eCopy = VK_PIPELINE_STAGE_2_COPY_BIT, - eResolve = VK_PIPELINE_STAGE_2_RESOLVE_BIT, - eBlit = VK_PIPELINE_STAGE_2_BLIT_BIT, - eClear = VK_PIPELINE_STAGE_2_CLEAR_BIT, - eIndexInput = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT, - eVertexAttributeInput = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT, - ePreRasterizationShaders = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT, - eVideoDecodeKHR = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR, - eVideoEncodeKHR = VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR, - eTransformFeedbackEXT = VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT, - eConditionalRenderingEXT = VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT, - eCommandPreprocessEXT = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT, - eCommandPreprocessNV = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV, - eFragmentShadingRateAttachmentKHR = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - eShadingRateImageNV = VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV, - eAccelerationStructureBuildKHR = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, - eAccelerationStructureBuildNV = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV, - eRayTracingShaderKHR = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR, - eRayTracingShaderNV = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV, - eFragmentDensityProcessEXT = VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT, - eTaskShaderEXT = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT, - eTaskShaderNV = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV, - eMeshShaderEXT = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT, - eMeshShaderNV = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV, - eSubpassShaderHUAWEI = VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI, - eSubpassShadingHUAWEI = VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI, - eInvocationMaskHUAWEI = VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI, - eAccelerationStructureCopyKHR = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR, - eMicromapBuildEXT = VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT, - eClusterCullingShaderHUAWEI = VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI, - eOpticalFlowNV = VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV, - eConvertCooperativeVectorMatrixNV = VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV, - eDataGraphARM = VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM, - eCopyIndirectKHR = VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR, - eMemoryDecompressionEXT = VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT - }; - - using PipelineStageFlagBits2KHR = PipelineStageFlagBits2; - - // wrapper using for bitmask VkPipelineStageFlags2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineStageFlags2.html - using PipelineStageFlags2 = Flags; - using PipelineStageFlags2KHR = PipelineStageFlags2; - - template <> - struct FlagTraits - { - using WrappedType = VkPipelineStageFlagBits2; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineStageFlags2 allFlags = - PipelineStageFlagBits2::eNone | PipelineStageFlagBits2::eTopOfPipe | PipelineStageFlagBits2::eDrawIndirect | PipelineStageFlagBits2::eVertexInput | - PipelineStageFlagBits2::eVertexShader | PipelineStageFlagBits2::eTessellationControlShader | PipelineStageFlagBits2::eTessellationEvaluationShader | - PipelineStageFlagBits2::eGeometryShader | PipelineStageFlagBits2::eFragmentShader | PipelineStageFlagBits2::eEarlyFragmentTests | - PipelineStageFlagBits2::eLateFragmentTests | PipelineStageFlagBits2::eColorAttachmentOutput | PipelineStageFlagBits2::eComputeShader | - PipelineStageFlagBits2::eAllTransfer | PipelineStageFlagBits2::eBottomOfPipe | PipelineStageFlagBits2::eHost | PipelineStageFlagBits2::eAllGraphics | - PipelineStageFlagBits2::eAllCommands | PipelineStageFlagBits2::eCopy | PipelineStageFlagBits2::eResolve | PipelineStageFlagBits2::eBlit | - PipelineStageFlagBits2::eClear | PipelineStageFlagBits2::eIndexInput | PipelineStageFlagBits2::eVertexAttributeInput | - PipelineStageFlagBits2::ePreRasterizationShaders | PipelineStageFlagBits2::eVideoDecodeKHR | PipelineStageFlagBits2::eVideoEncodeKHR | - PipelineStageFlagBits2::eTransformFeedbackEXT | PipelineStageFlagBits2::eConditionalRenderingEXT | PipelineStageFlagBits2::eCommandPreprocessEXT | - PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR | PipelineStageFlagBits2::eAccelerationStructureBuildKHR | - PipelineStageFlagBits2::eRayTracingShaderKHR | PipelineStageFlagBits2::eFragmentDensityProcessEXT | PipelineStageFlagBits2::eTaskShaderEXT | - PipelineStageFlagBits2::eMeshShaderEXT | PipelineStageFlagBits2::eSubpassShaderHUAWEI | PipelineStageFlagBits2::eInvocationMaskHUAWEI | - PipelineStageFlagBits2::eAccelerationStructureCopyKHR | PipelineStageFlagBits2::eMicromapBuildEXT | PipelineStageFlagBits2::eClusterCullingShaderHUAWEI | - PipelineStageFlagBits2::eOpticalFlowNV | PipelineStageFlagBits2::eConvertCooperativeVectorMatrixNV | PipelineStageFlagBits2::eDataGraphARM | - PipelineStageFlagBits2::eCopyIndirectKHR | PipelineStageFlagBits2::eMemoryDecompressionEXT; - }; - - // wrapper class for enum VkAccessFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits2.html - enum class AccessFlagBits2 : VkAccessFlags2 - { - eNone = VK_ACCESS_2_NONE, - eIndirectCommandRead = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT, - eIndexRead = VK_ACCESS_2_INDEX_READ_BIT, - eVertexAttributeRead = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT, - eUniformRead = VK_ACCESS_2_UNIFORM_READ_BIT, - eInputAttachmentRead = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT, - eShaderRead = VK_ACCESS_2_SHADER_READ_BIT, - eShaderWrite = VK_ACCESS_2_SHADER_WRITE_BIT, - eColorAttachmentRead = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT, - eColorAttachmentWrite = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT, - eDepthStencilAttachmentRead = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT, - eDepthStencilAttachmentWrite = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT, - eTransferRead = VK_ACCESS_2_TRANSFER_READ_BIT, - eTransferWrite = VK_ACCESS_2_TRANSFER_WRITE_BIT, - eHostRead = VK_ACCESS_2_HOST_READ_BIT, - eHostWrite = VK_ACCESS_2_HOST_WRITE_BIT, - eMemoryRead = VK_ACCESS_2_MEMORY_READ_BIT, - eMemoryWrite = VK_ACCESS_2_MEMORY_WRITE_BIT, - eShaderSampledRead = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT, - eShaderStorageRead = VK_ACCESS_2_SHADER_STORAGE_READ_BIT, - eShaderStorageWrite = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT, - eVideoDecodeReadKHR = VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR, - eVideoDecodeWriteKHR = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR, - eSamplerHeapReadEXT = VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT, - eResourceHeapReadEXT = VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT, - eVideoEncodeReadKHR = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR, - eVideoEncodeWriteKHR = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR, - eShaderTileAttachmentReadQCOM = VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM, - eShaderTileAttachmentWriteQCOM = VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM, - eTransformFeedbackWriteEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, - eTransformFeedbackCounterReadEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, - eTransformFeedbackCounterWriteEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, - eConditionalRenderingReadEXT = VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT, - eCommandPreprocessReadEXT = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT, - eCommandPreprocessReadNV = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV, - eCommandPreprocessWriteEXT = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT, - eCommandPreprocessWriteNV = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV, - eFragmentShadingRateAttachmentReadKHR = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, - eShadingRateImageReadNV = VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV, - eAccelerationStructureReadKHR = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR, - eAccelerationStructureReadNV = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV, - eAccelerationStructureWriteKHR = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, - eAccelerationStructureWriteNV = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV, - eFragmentDensityMapReadEXT = VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT, - eColorAttachmentReadNoncoherentEXT = VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, - eDescriptorBufferReadEXT = VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT, - eInvocationMaskReadHUAWEI = VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI, - eShaderBindingTableReadKHR = VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR, - eMicromapReadEXT = VK_ACCESS_2_MICROMAP_READ_BIT_EXT, - eMicromapWriteEXT = VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT, - eOpticalFlowReadNV = VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV, - eOpticalFlowWriteNV = VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV, - eDataGraphReadARM = VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM, - eDataGraphWriteARM = VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM, - eMemoryDecompressionReadEXT = VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT, - eMemoryDecompressionWriteEXT = VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT - }; - - using AccessFlagBits2KHR = AccessFlagBits2; - - // wrapper using for bitmask VkAccessFlags2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlags2.html - using AccessFlags2 = Flags; - using AccessFlags2KHR = AccessFlags2; - - template <> - struct FlagTraits - { - using WrappedType = VkAccessFlagBits2; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags2 allFlags = - AccessFlagBits2::eNone | AccessFlagBits2::eIndirectCommandRead | AccessFlagBits2::eIndexRead | AccessFlagBits2::eVertexAttributeRead | - AccessFlagBits2::eUniformRead | AccessFlagBits2::eInputAttachmentRead | AccessFlagBits2::eShaderRead | AccessFlagBits2::eShaderWrite | - AccessFlagBits2::eColorAttachmentRead | AccessFlagBits2::eColorAttachmentWrite | AccessFlagBits2::eDepthStencilAttachmentRead | - AccessFlagBits2::eDepthStencilAttachmentWrite | AccessFlagBits2::eTransferRead | AccessFlagBits2::eTransferWrite | AccessFlagBits2::eHostRead | - AccessFlagBits2::eHostWrite | AccessFlagBits2::eMemoryRead | AccessFlagBits2::eMemoryWrite | AccessFlagBits2::eShaderSampledRead | - AccessFlagBits2::eShaderStorageRead | AccessFlagBits2::eShaderStorageWrite | AccessFlagBits2::eVideoDecodeReadKHR | - AccessFlagBits2::eVideoDecodeWriteKHR | AccessFlagBits2::eSamplerHeapReadEXT | AccessFlagBits2::eResourceHeapReadEXT | - AccessFlagBits2::eVideoEncodeReadKHR | AccessFlagBits2::eVideoEncodeWriteKHR | AccessFlagBits2::eShaderTileAttachmentReadQCOM | - AccessFlagBits2::eShaderTileAttachmentWriteQCOM | AccessFlagBits2::eTransformFeedbackWriteEXT | AccessFlagBits2::eTransformFeedbackCounterReadEXT | - AccessFlagBits2::eTransformFeedbackCounterWriteEXT | AccessFlagBits2::eConditionalRenderingReadEXT | AccessFlagBits2::eCommandPreprocessReadEXT | - AccessFlagBits2::eCommandPreprocessWriteEXT | AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR | AccessFlagBits2::eAccelerationStructureReadKHR | - AccessFlagBits2::eAccelerationStructureWriteKHR | AccessFlagBits2::eFragmentDensityMapReadEXT | AccessFlagBits2::eColorAttachmentReadNoncoherentEXT | - AccessFlagBits2::eDescriptorBufferReadEXT | AccessFlagBits2::eInvocationMaskReadHUAWEI | AccessFlagBits2::eShaderBindingTableReadKHR | - AccessFlagBits2::eMicromapReadEXT | AccessFlagBits2::eMicromapWriteEXT | AccessFlagBits2::eOpticalFlowReadNV | AccessFlagBits2::eOpticalFlowWriteNV | - AccessFlagBits2::eDataGraphReadARM | AccessFlagBits2::eDataGraphWriteARM | AccessFlagBits2::eMemoryDecompressionReadEXT | - AccessFlagBits2::eMemoryDecompressionWriteEXT; - }; - - // wrapper class for enum VkSubmitFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitFlagBits.html - enum class SubmitFlagBits : VkSubmitFlags - { - eProtected = VK_SUBMIT_PROTECTED_BIT - }; - - using SubmitFlagBitsKHR = SubmitFlagBits; - - // wrapper using for bitmask VkSubmitFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitFlags.html - using SubmitFlags = Flags; - using SubmitFlagsKHR = SubmitFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkSubmitFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SubmitFlags allFlags = SubmitFlagBits::eProtected; - }; - - // wrapper class for enum VkFormatFeatureFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlagBits2.html - enum class FormatFeatureFlagBits2 : VkFormatFeatureFlags2 - { - eSampledImage = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT, - eStorageImage = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT, - eStorageImageAtomic = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT, - eUniformTexelBuffer = VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT, - eStorageTexelBuffer = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT, - eStorageTexelBufferAtomic = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, - eVertexBuffer = VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT, - eColorAttachment = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT, - eColorAttachmentBlend = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT, - eDepthStencilAttachment = VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT, - eBlitSrc = VK_FORMAT_FEATURE_2_BLIT_SRC_BIT, - eBlitDst = VK_FORMAT_FEATURE_2_BLIT_DST_BIT, - eSampledImageFilterLinear = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT, - eTransferSrc = VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT, - eTransferDst = VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT, - eSampledImageFilterMinmax = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT, - eMidpointChromaSamples = VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT, - eSampledImageYcbcrConversionLinearFilter = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, - eSampledImageYcbcrConversionSeparateReconstructionFilter = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, - eSampledImageYcbcrConversionChromaReconstructionExplicit = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, - eSampledImageYcbcrConversionChromaReconstructionExplicitForceable = - VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, - eDisjoint = VK_FORMAT_FEATURE_2_DISJOINT_BIT, - eCositedChromaSamples = VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT, - eStorageReadWithoutFormat = VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT, - eStorageWriteWithoutFormat = VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT, - eSampledImageDepthComparison = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT, - eSampledImageFilterCubic = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT, - eSampledImageFilterCubicEXT = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, - eHostImageTransfer = VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT, - eHostImageTransferEXT = VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT, - eVideoDecodeOutputKHR = VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR, - eVideoDecodeDpbKHR = VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR, - eAccelerationStructureVertexBufferKHR = VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR, - eFragmentDensityMapEXT = VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT, - eFragmentShadingRateAttachmentKHR = VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - eVideoEncodeInputKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR, - eVideoEncodeDpbKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR, - eAccelerationStructureRadiusBufferNV = VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV, - eLinearColorAttachmentNV = VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV, - eWeightImageQCOM = VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM, - eWeightSampledImageQCOM = VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM, - eBlockMatchingQCOM = VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM, - eBoxFilterSampledQCOM = VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM, - eTensorShaderARM = VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM, - eTensorImageAliasingARM = VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM, - eOpticalFlowImageNV = VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV, - eOpticalFlowVectorNV = VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV, - eOpticalFlowCostNV = VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV, - eTensorDataGraphARM = VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM, - eCopyImageIndirectDstKHR = VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR, - eVideoEncodeQuantizationDeltaMapKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, - eVideoEncodeEmphasisMapKHR = VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR, - eDepthCopyOnComputeQueueKHR = VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR, - eDepthCopyOnTransferQueueKHR = VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR, - eStencilCopyOnComputeQueueKHR = VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR, - eStencilCopyOnTransferQueueKHR = VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR - }; - - using FormatFeatureFlagBits2KHR = FormatFeatureFlagBits2; - - // wrapper using for bitmask VkFormatFeatureFlags2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatFeatureFlags2.html - using FormatFeatureFlags2 = Flags; - using FormatFeatureFlags2KHR = FormatFeatureFlags2; - - template <> - struct FlagTraits - { - using WrappedType = VkFormatFeatureFlagBits2; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR FormatFeatureFlags2 allFlags = - FormatFeatureFlagBits2::eSampledImage | FormatFeatureFlagBits2::eStorageImage | FormatFeatureFlagBits2::eStorageImageAtomic | - FormatFeatureFlagBits2::eUniformTexelBuffer | FormatFeatureFlagBits2::eStorageTexelBuffer | FormatFeatureFlagBits2::eStorageTexelBufferAtomic | - FormatFeatureFlagBits2::eVertexBuffer | FormatFeatureFlagBits2::eColorAttachment | FormatFeatureFlagBits2::eColorAttachmentBlend | - FormatFeatureFlagBits2::eDepthStencilAttachment | FormatFeatureFlagBits2::eBlitSrc | FormatFeatureFlagBits2::eBlitDst | - FormatFeatureFlagBits2::eSampledImageFilterLinear | FormatFeatureFlagBits2::eTransferSrc | FormatFeatureFlagBits2::eTransferDst | - FormatFeatureFlagBits2::eSampledImageFilterMinmax | FormatFeatureFlagBits2::eMidpointChromaSamples | - FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter | FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter | - FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit | - FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable | FormatFeatureFlagBits2::eDisjoint | - FormatFeatureFlagBits2::eCositedChromaSamples | FormatFeatureFlagBits2::eStorageReadWithoutFormat | FormatFeatureFlagBits2::eStorageWriteWithoutFormat | - FormatFeatureFlagBits2::eSampledImageDepthComparison | FormatFeatureFlagBits2::eSampledImageFilterCubic | FormatFeatureFlagBits2::eHostImageTransfer | - FormatFeatureFlagBits2::eVideoDecodeOutputKHR | FormatFeatureFlagBits2::eVideoDecodeDpbKHR | - FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR | FormatFeatureFlagBits2::eFragmentDensityMapEXT | - FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR | FormatFeatureFlagBits2::eVideoEncodeInputKHR | FormatFeatureFlagBits2::eVideoEncodeDpbKHR | - FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV | FormatFeatureFlagBits2::eLinearColorAttachmentNV | - FormatFeatureFlagBits2::eWeightImageQCOM | FormatFeatureFlagBits2::eWeightSampledImageQCOM | FormatFeatureFlagBits2::eBlockMatchingQCOM | - FormatFeatureFlagBits2::eBoxFilterSampledQCOM | FormatFeatureFlagBits2::eTensorShaderARM | FormatFeatureFlagBits2::eTensorImageAliasingARM | - FormatFeatureFlagBits2::eOpticalFlowImageNV | FormatFeatureFlagBits2::eOpticalFlowVectorNV | FormatFeatureFlagBits2::eOpticalFlowCostNV | - FormatFeatureFlagBits2::eTensorDataGraphARM | FormatFeatureFlagBits2::eCopyImageIndirectDstKHR | - FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR | FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR | - FormatFeatureFlagBits2::eDepthCopyOnComputeQueueKHR | FormatFeatureFlagBits2::eDepthCopyOnTransferQueueKHR | - FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR | FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR; - }; - - // wrapper class for enum VkPipelineCreationFeedbackFlagBits, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreationFeedbackFlagBits.html - enum class PipelineCreationFeedbackFlagBits : VkPipelineCreationFeedbackFlags - { - eValid = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, - eApplicationPipelineCacheHit = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, - eBasePipelineAcceleration = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT - }; - - using PipelineCreationFeedbackFlagBitsEXT = PipelineCreationFeedbackFlagBits; - - // wrapper using for bitmask VkPipelineCreationFeedbackFlags, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreationFeedbackFlags.html - using PipelineCreationFeedbackFlags = Flags; - using PipelineCreationFeedbackFlagsEXT = PipelineCreationFeedbackFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkPipelineCreationFeedbackFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreationFeedbackFlags allFlags = PipelineCreationFeedbackFlagBits::eValid | - PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit | - PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration; - }; - - // wrapper class for enum VkRenderingFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFlagBits.html - enum class RenderingFlagBits : VkRenderingFlags - { - eContentsSecondaryCommandBuffers = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, - eSuspending = VK_RENDERING_SUSPENDING_BIT, - eResuming = VK_RENDERING_RESUMING_BIT, - eEnableLegacyDitheringEXT = VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT, - eContentsInlineKHR = VK_RENDERING_CONTENTS_INLINE_BIT_KHR, - eContentsInlineEXT = VK_RENDERING_CONTENTS_INLINE_BIT_EXT, - ePerLayerFragmentDensityVALVE = VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE, - eFragmentRegionEXT = VK_RENDERING_FRAGMENT_REGION_BIT_EXT, - eCustomResolveEXT = VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT, - eLocalReadConcurrentAccessControlKHR = VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR - }; - - using RenderingFlagBitsKHR = RenderingFlagBits; - - // wrapper using for bitmask VkRenderingFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFlags.html - using RenderingFlags = Flags; - using RenderingFlagsKHR = RenderingFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkRenderingFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR RenderingFlags allFlags = - RenderingFlagBits::eContentsSecondaryCommandBuffers | RenderingFlagBits::eSuspending | RenderingFlagBits::eResuming | - RenderingFlagBits::eEnableLegacyDitheringEXT | RenderingFlagBits::eContentsInlineKHR | RenderingFlagBits::ePerLayerFragmentDensityVALVE | - RenderingFlagBits::eFragmentRegionEXT | RenderingFlagBits::eCustomResolveEXT | RenderingFlagBits::eLocalReadConcurrentAccessControlKHR; - }; - - //=== VK_VERSION_1_4 === - - // wrapper class for enum VkQueueGlobalPriority, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueGlobalPriority.html - enum class QueueGlobalPriority - { - eLow = VK_QUEUE_GLOBAL_PRIORITY_LOW, - eLowKHR = VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR, - eMedium = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM, - eMediumKHR = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR, - eHigh = VK_QUEUE_GLOBAL_PRIORITY_HIGH, - eHighKHR = VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR, - eRealtime = VK_QUEUE_GLOBAL_PRIORITY_REALTIME, - eRealtimeKHR = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR - }; - - using QueueGlobalPriorityEXT = QueueGlobalPriority; - using QueueGlobalPriorityKHR = QueueGlobalPriority; - - // wrapper class for enum VkMemoryUnmapFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryUnmapFlagBits.html - enum class MemoryUnmapFlagBits : VkMemoryUnmapFlags - { - eReserveEXT = VK_MEMORY_UNMAP_RESERVE_BIT_EXT - }; - - using MemoryUnmapFlagBitsKHR = MemoryUnmapFlagBits; - - // wrapper using for bitmask VkMemoryUnmapFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryUnmapFlags.html - using MemoryUnmapFlags = Flags; - using MemoryUnmapFlagsKHR = MemoryUnmapFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkMemoryUnmapFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryUnmapFlags allFlags = MemoryUnmapFlagBits::eReserveEXT; - }; - - // wrapper class for enum VkBufferUsageFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlagBits2.html - enum class BufferUsageFlagBits2 : VkBufferUsageFlags2 - { - eTransferSrc = VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT, - eTransferDst = VK_BUFFER_USAGE_2_TRANSFER_DST_BIT, - eUniformTexelBuffer = VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT, - eStorageTexelBuffer = VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT, - eUniformBuffer = VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT, - eStorageBuffer = VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT, - eIndexBuffer = VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT, - eVertexBuffer = VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT, - eIndirectBuffer = VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT, - eShaderDeviceAddress = VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eExecutionGraphScratchAMDX = VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eDescriptorHeapEXT = VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT, - eConditionalRenderingEXT = VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT, - eShaderBindingTableKHR = VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR, - eRayTracingNV = VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV, - eTransformFeedbackBufferEXT = VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT, - eTransformFeedbackCounterBufferEXT = VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT, - eVideoDecodeSrcKHR = VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR, - eVideoDecodeDstKHR = VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR, - eVideoEncodeDstKHR = VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR, - eVideoEncodeSrcKHR = VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR, - eAccelerationStructureBuildInputReadOnlyKHR = VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR, - eAccelerationStructureStorageKHR = VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR, - eSamplerDescriptorBufferEXT = VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT, - eResourceDescriptorBufferEXT = VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT, - ePushDescriptorsDescriptorBufferEXT = VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT, - eMicromapBuildInputReadOnlyEXT = VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT, - eMicromapStorageEXT = VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eCompressedDataDgf1AMDX = VK_BUFFER_USAGE_2_COMPRESSED_DATA_DGF1_BIT_AMDX, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eDataGraphForeignDescriptorARM = VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM, - eTileMemoryQCOM = VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM, - eMemoryDecompressionEXT = VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT, - ePreprocessBufferEXT = VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT - }; - - using BufferUsageFlagBits2KHR = BufferUsageFlagBits2; - - // wrapper using for bitmask VkBufferUsageFlags2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlags2.html - using BufferUsageFlags2 = Flags; - using BufferUsageFlags2KHR = BufferUsageFlags2; - - template <> - struct FlagTraits - { - using WrappedType = VkBufferUsageFlagBits2; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR BufferUsageFlags2 allFlags = - BufferUsageFlagBits2::eTransferSrc | BufferUsageFlagBits2::eTransferDst | BufferUsageFlagBits2::eUniformTexelBuffer | - BufferUsageFlagBits2::eStorageTexelBuffer | BufferUsageFlagBits2::eUniformBuffer | BufferUsageFlagBits2::eStorageBuffer | - BufferUsageFlagBits2::eIndexBuffer | BufferUsageFlagBits2::eVertexBuffer | BufferUsageFlagBits2::eIndirectBuffer | - BufferUsageFlagBits2::eShaderDeviceAddress -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | BufferUsageFlagBits2::eExecutionGraphScratchAMDX -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | BufferUsageFlagBits2::eDescriptorHeapEXT | BufferUsageFlagBits2::eConditionalRenderingEXT | BufferUsageFlagBits2::eShaderBindingTableKHR | - BufferUsageFlagBits2::eTransformFeedbackBufferEXT | BufferUsageFlagBits2::eTransformFeedbackCounterBufferEXT | BufferUsageFlagBits2::eVideoDecodeSrcKHR | - BufferUsageFlagBits2::eVideoDecodeDstKHR | BufferUsageFlagBits2::eVideoEncodeDstKHR | BufferUsageFlagBits2::eVideoEncodeSrcKHR | - BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR | BufferUsageFlagBits2::eAccelerationStructureStorageKHR | - BufferUsageFlagBits2::eSamplerDescriptorBufferEXT | BufferUsageFlagBits2::eResourceDescriptorBufferEXT | - BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT | BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT | - BufferUsageFlagBits2::eMicromapStorageEXT -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | BufferUsageFlagBits2::eCompressedDataDgf1AMDX -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | BufferUsageFlagBits2::eDataGraphForeignDescriptorARM | BufferUsageFlagBits2::eTileMemoryQCOM | BufferUsageFlagBits2::eMemoryDecompressionEXT | - BufferUsageFlagBits2::ePreprocessBufferEXT; - }; - - // wrapper class for enum VkHostImageCopyFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostImageCopyFlagBits.html - enum class HostImageCopyFlagBits : VkHostImageCopyFlags - { - eMemcpy = VK_HOST_IMAGE_COPY_MEMCPY_BIT - }; - - using HostImageCopyFlagBitsEXT = HostImageCopyFlagBits; - - // wrapper using for bitmask VkHostImageCopyFlags, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostImageCopyFlags.html - using HostImageCopyFlags = Flags; - using HostImageCopyFlagsEXT = HostImageCopyFlags; - - template <> - struct FlagTraits - { - using WrappedType = VkHostImageCopyFlagBits; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR HostImageCopyFlags allFlags = HostImageCopyFlagBits::eMemcpy; - }; - - // wrapper class for enum VkPipelineCreateFlagBits2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlagBits2.html - enum class PipelineCreateFlagBits2 : VkPipelineCreateFlags2 - { - eDisableOptimization = VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT, - eAllowDerivatives = VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT, - eDerivative = VK_PIPELINE_CREATE_2_DERIVATIVE_BIT, - eViewIndexFromDeviceIndex = VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, - eDispatchBase = VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT, - eFailOnPipelineCompileRequired = VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, - eEarlyReturnOnFailure = VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT, - eNoProtectedAccess = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT, - eNoProtectedAccessEXT = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT, - eProtectedAccessOnly = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT, - eProtectedAccessOnlyEXT = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eExecutionGraphAMDX = VK_PIPELINE_CREATE_2_EXECUTION_GRAPH_BIT_AMDX, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eDescriptorHeapEXT = VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT, - eRayTracingAllowSpheresAndLinearSweptSpheresNV = VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV, - eEnableLegacyDitheringEXT = VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, - eDeferCompileNV = VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV, - eCaptureStatisticsKHR = VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR, - eCaptureInternalRepresentationsKHR = VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR, - eLinkTimeOptimizationEXT = VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT, - eRetainLinkTimeOptimizationInfoEXT = VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT, - eLibraryKHR = VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR, - eRayTracingSkipTrianglesKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR, - eRayTracingSkipBuiltInPrimitives = VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR, - eRayTracingSkipAabbsKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR, - eRayTracingNoNullAnyHitShadersKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR, - eRayTracingNoNullClosestHitShadersKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR, - eRayTracingNoNullMissShadersKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR, - eRayTracingNoNullIntersectionShadersKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR, - eRayTracingShaderGroupHandleCaptureReplayKHR = VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR, - eIndirectBindableNV = VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV, - eRayTracingAllowMotionNV = VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV, - eRenderingFragmentShadingRateAttachmentKHR = VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - eRenderingFragmentDensityMapAttachmentEXT = VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, - eRayTracingOpacityMicromapEXT = VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT, - eColorAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, - eDepthStencilAttachmentFeedbackLoopEXT = VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT, - eRayTracingDisplacementMicromapNV = VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV, - eDescriptorBufferEXT = VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT, - eDisallowOpacityMicromapARM = VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM, - eCaptureDataKHR = VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR, - eIndirectBindableEXT = VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT, - ePerLayerFragmentDensityVALVE = VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE, - e64BitIndexingEXT = VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT - }; - - using PipelineCreateFlagBits2KHR = PipelineCreateFlagBits2; - - // wrapper using for bitmask VkPipelineCreateFlags2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlags2.html - using PipelineCreateFlags2 = Flags; - using PipelineCreateFlags2KHR = PipelineCreateFlags2; - - template <> - struct FlagTraits - { - using WrappedType = VkPipelineCreateFlagBits2; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCreateFlags2 allFlags = - PipelineCreateFlagBits2::eDisableOptimization | PipelineCreateFlagBits2::eAllowDerivatives | PipelineCreateFlagBits2::eDerivative | - PipelineCreateFlagBits2::eViewIndexFromDeviceIndex | PipelineCreateFlagBits2::eDispatchBase | PipelineCreateFlagBits2::eFailOnPipelineCompileRequired | - PipelineCreateFlagBits2::eEarlyReturnOnFailure | PipelineCreateFlagBits2::eNoProtectedAccess | PipelineCreateFlagBits2::eProtectedAccessOnly -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | PipelineCreateFlagBits2::eExecutionGraphAMDX -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | PipelineCreateFlagBits2::eDescriptorHeapEXT | PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV | - PipelineCreateFlagBits2::eEnableLegacyDitheringEXT | PipelineCreateFlagBits2::eDeferCompileNV | PipelineCreateFlagBits2::eCaptureStatisticsKHR | - PipelineCreateFlagBits2::eCaptureInternalRepresentationsKHR | PipelineCreateFlagBits2::eLinkTimeOptimizationEXT | - PipelineCreateFlagBits2::eRetainLinkTimeOptimizationInfoEXT | PipelineCreateFlagBits2::eLibraryKHR | - PipelineCreateFlagBits2::eRayTracingSkipTrianglesKHR | PipelineCreateFlagBits2::eRayTracingSkipAabbsKHR | - PipelineCreateFlagBits2::eRayTracingNoNullAnyHitShadersKHR | PipelineCreateFlagBits2::eRayTracingNoNullClosestHitShadersKHR | - PipelineCreateFlagBits2::eRayTracingNoNullMissShadersKHR | PipelineCreateFlagBits2::eRayTracingNoNullIntersectionShadersKHR | - PipelineCreateFlagBits2::eRayTracingShaderGroupHandleCaptureReplayKHR | PipelineCreateFlagBits2::eIndirectBindableNV | - PipelineCreateFlagBits2::eRayTracingAllowMotionNV | PipelineCreateFlagBits2::eRenderingFragmentShadingRateAttachmentKHR | - PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT | PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT | - PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT | PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT | - PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV | PipelineCreateFlagBits2::eDescriptorBufferEXT | - PipelineCreateFlagBits2::eDisallowOpacityMicromapARM | PipelineCreateFlagBits2::eCaptureDataKHR | PipelineCreateFlagBits2::eIndirectBindableEXT | - PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE | PipelineCreateFlagBits2::e64BitIndexingEXT; - }; - - // wrapper class for enum VkPipelineRobustnessBufferBehavior, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRobustnessBufferBehavior.html - enum class PipelineRobustnessBufferBehavior - { - eDeviceDefault = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT, - eDisabled = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED, - eRobustBufferAccess = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS, - eRobustBufferAccess2 = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 - }; - - using PipelineRobustnessBufferBehaviorEXT = PipelineRobustnessBufferBehavior; - - // wrapper class for enum VkPipelineRobustnessImageBehavior, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRobustnessImageBehavior.html - enum class PipelineRobustnessImageBehavior - { - eDeviceDefault = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT, - eDisabled = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED, - eRobustImageAccess = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS, - eRobustImageAccess2 = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2 - }; - - using PipelineRobustnessImageBehaviorEXT = PipelineRobustnessImageBehavior; - - // wrapper class for enum VkLineRasterizationMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLineRasterizationMode.html - enum class LineRasterizationMode - { - eDefault = VK_LINE_RASTERIZATION_MODE_DEFAULT, - eDefaultKHR = VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR, - eRectangular = VK_LINE_RASTERIZATION_MODE_RECTANGULAR, - eRectangularKHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR, - eBresenham = VK_LINE_RASTERIZATION_MODE_BRESENHAM, - eBresenhamKHR = VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR, - eRectangularSmooth = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, - eRectangularSmoothKHR = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR - }; - - using LineRasterizationModeEXT = LineRasterizationMode; - using LineRasterizationModeKHR = LineRasterizationMode; - - //=== VK_KHR_surface === - - // wrapper class for enum VkSurfaceTransformFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceTransformFlagBitsKHR.html - enum class SurfaceTransformFlagBitsKHR : VkSurfaceTransformFlagsKHR - { - eIdentity = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR, - eRotate90 = VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR, - eRotate180 = VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR, - eRotate270 = VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR, - eHorizontalMirror = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR, - eHorizontalMirrorRotate90 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR, - eHorizontalMirrorRotate180 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR, - eHorizontalMirrorRotate270 = VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR, - eInherit = VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR - }; - - // wrapper using for bitmask VkSurfaceTransformFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceTransformFlagsKHR.html - using SurfaceTransformFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkSurfaceTransformFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceTransformFlagsKHR allFlags = - SurfaceTransformFlagBitsKHR::eIdentity | SurfaceTransformFlagBitsKHR::eRotate90 | SurfaceTransformFlagBitsKHR::eRotate180 | - SurfaceTransformFlagBitsKHR::eRotate270 | SurfaceTransformFlagBitsKHR::eHorizontalMirror | SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 | - SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 | SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 | SurfaceTransformFlagBitsKHR::eInherit; - }; - - // wrapper class for enum VkPresentModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentModeKHR.html - enum class PresentModeKHR - { - eImmediate = VK_PRESENT_MODE_IMMEDIATE_KHR, - eMailbox = VK_PRESENT_MODE_MAILBOX_KHR, - eFifo = VK_PRESENT_MODE_FIFO_KHR, - eFifoRelaxed = VK_PRESENT_MODE_FIFO_RELAXED_KHR, - eSharedDemandRefresh = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR, - eSharedContinuousRefresh = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR, - eFifoLatestReady = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR, - eFifoLatestReadyEXT = VK_PRESENT_MODE_FIFO_LATEST_READY_EXT - }; - - // wrapper class for enum VkColorSpaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorSpaceKHR.html - enum class ColorSpaceKHR - { - eSrgbNonlinear = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - eVkColorspaceSrgbNonlinear = VK_COLORSPACE_SRGB_NONLINEAR_KHR, - eDisplayP3NonlinearEXT = VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT, - eExtendedSrgbLinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT, - eDisplayP3LinearEXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, - eDciP3LinearEXT = VK_COLOR_SPACE_DCI_P3_LINEAR_EXT, - eDciP3NonlinearEXT = VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT, - eBt709LinearEXT = VK_COLOR_SPACE_BT709_LINEAR_EXT, - eBt709NonlinearEXT = VK_COLOR_SPACE_BT709_NONLINEAR_EXT, - eBt2020LinearEXT = VK_COLOR_SPACE_BT2020_LINEAR_EXT, - eHdr10St2084EXT = VK_COLOR_SPACE_HDR10_ST2084_EXT, - eDolbyvisionEXT VULKAN_HPP_DEPRECATED_17( "eDolbyvisionEXT is deprecated, but no reason was given in the API XML" ) = VK_COLOR_SPACE_DOLBYVISION_EXT, - eHdr10HlgEXT = VK_COLOR_SPACE_HDR10_HLG_EXT, - eAdobergbLinearEXT = VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT, - eAdobergbNonlinearEXT = VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT, - ePassThroughEXT = VK_COLOR_SPACE_PASS_THROUGH_EXT, - eExtendedSrgbNonlinearEXT = VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT, - eDisplayNativeAMD = VK_COLOR_SPACE_DISPLAY_NATIVE_AMD - }; - - // wrapper class for enum VkCompositeAlphaFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompositeAlphaFlagBitsKHR.html - enum class CompositeAlphaFlagBitsKHR : VkCompositeAlphaFlagsKHR - { - eOpaque = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, - ePreMultiplied = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR, - ePostMultiplied = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, - eInherit = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR - }; - - // wrapper using for bitmask VkCompositeAlphaFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompositeAlphaFlagsKHR.html - using CompositeAlphaFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkCompositeAlphaFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR CompositeAlphaFlagsKHR allFlags = CompositeAlphaFlagBitsKHR::eOpaque | CompositeAlphaFlagBitsKHR::ePreMultiplied | - CompositeAlphaFlagBitsKHR::ePostMultiplied | CompositeAlphaFlagBitsKHR::eInherit; - }; - - //=== VK_KHR_swapchain === - - // wrapper class for enum VkSwapchainCreateFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCreateFlagBitsKHR.html - enum class SwapchainCreateFlagBitsKHR : VkSwapchainCreateFlagsKHR - { - eSplitInstanceBindRegions = VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR, - eProtected = VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR, - eMutableFormat = VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR, - ePresentTimingEXT = VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT, - ePresentId2 = VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR, - ePresentWait2 = VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR, - eDeferredMemoryAllocation = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR, - eDeferredMemoryAllocationEXT = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT - }; - - // wrapper using for bitmask VkSwapchainCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCreateFlagsKHR.html - using SwapchainCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkSwapchainCreateFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SwapchainCreateFlagsKHR allFlags = - SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions | SwapchainCreateFlagBitsKHR::eProtected | SwapchainCreateFlagBitsKHR::eMutableFormat | - SwapchainCreateFlagBitsKHR::ePresentTimingEXT | SwapchainCreateFlagBitsKHR::ePresentId2 | SwapchainCreateFlagBitsKHR::ePresentWait2 | - SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocation; - }; - - // wrapper class for enum VkDeviceGroupPresentModeFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupPresentModeFlagBitsKHR.html - enum class DeviceGroupPresentModeFlagBitsKHR : VkDeviceGroupPresentModeFlagsKHR - { - eLocal = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR, - eRemote = VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR, - eSum = VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR, - eLocalMultiDevice = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR - }; - - // wrapper using for bitmask VkDeviceGroupPresentModeFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupPresentModeFlagsKHR.html - using DeviceGroupPresentModeFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDeviceGroupPresentModeFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceGroupPresentModeFlagsKHR allFlags = - DeviceGroupPresentModeFlagBitsKHR::eLocal | DeviceGroupPresentModeFlagBitsKHR::eRemote | DeviceGroupPresentModeFlagBitsKHR::eSum | - DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice; - }; - - //=== VK_KHR_display === - - // wrapper class for enum VkDisplayPlaneAlphaFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneAlphaFlagBitsKHR.html - enum class DisplayPlaneAlphaFlagBitsKHR : VkDisplayPlaneAlphaFlagsKHR - { - eOpaque = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR, - eGlobal = VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR, - ePerPixel = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR, - ePerPixelPremultiplied = VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR - }; - - // wrapper using for bitmask VkDisplayPlaneAlphaFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneAlphaFlagsKHR.html - using DisplayPlaneAlphaFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDisplayPlaneAlphaFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DisplayPlaneAlphaFlagsKHR allFlags = DisplayPlaneAlphaFlagBitsKHR::eOpaque | DisplayPlaneAlphaFlagBitsKHR::eGlobal | - DisplayPlaneAlphaFlagBitsKHR::ePerPixel | - DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied; - }; - - enum class DisplayModeCreateFlagBitsKHR : VkDisplayModeCreateFlagsKHR - { - }; - - // wrapper using for bitmask VkDisplayModeCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeCreateFlagsKHR.html - using DisplayModeCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DisplayModeCreateFlagsKHR allFlags = {}; - }; - - enum class DisplaySurfaceCreateFlagBitsKHR : VkDisplaySurfaceCreateFlagsKHR - { - }; - - // wrapper using for bitmask VkDisplaySurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplaySurfaceCreateFlagsKHR.html - using DisplaySurfaceCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DisplaySurfaceCreateFlagsKHR allFlags = {}; - }; - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - - enum class XlibSurfaceCreateFlagBitsKHR : VkXlibSurfaceCreateFlagsKHR - { - }; - - // wrapper using for bitmask VkXlibSurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXlibSurfaceCreateFlagsKHR.html - using XlibSurfaceCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR XlibSurfaceCreateFlagsKHR allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - - enum class XcbSurfaceCreateFlagBitsKHR : VkXcbSurfaceCreateFlagsKHR - { - }; - - // wrapper using for bitmask VkXcbSurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXcbSurfaceCreateFlagsKHR.html - using XcbSurfaceCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR XcbSurfaceCreateFlagsKHR allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - - enum class WaylandSurfaceCreateFlagBitsKHR : VkWaylandSurfaceCreateFlagsKHR - { - }; - - // wrapper using for bitmask VkWaylandSurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWaylandSurfaceCreateFlagsKHR.html - using WaylandSurfaceCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR WaylandSurfaceCreateFlagsKHR allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - - enum class AndroidSurfaceCreateFlagBitsKHR : VkAndroidSurfaceCreateFlagsKHR - { - }; - - // wrapper using for bitmask VkAndroidSurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidSurfaceCreateFlagsKHR.html - using AndroidSurfaceCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR AndroidSurfaceCreateFlagsKHR allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - - enum class Win32SurfaceCreateFlagBitsKHR : VkWin32SurfaceCreateFlagsKHR - { - }; - - // wrapper using for bitmask VkWin32SurfaceCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWin32SurfaceCreateFlagsKHR.html - using Win32SurfaceCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR Win32SurfaceCreateFlagsKHR allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - - // wrapper class for enum VkDebugReportFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportFlagBitsEXT.html - enum class DebugReportFlagBitsEXT : VkDebugReportFlagsEXT - { - eInformation = VK_DEBUG_REPORT_INFORMATION_BIT_EXT, - eWarning = VK_DEBUG_REPORT_WARNING_BIT_EXT, - ePerformanceWarning = VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, - eError = VK_DEBUG_REPORT_ERROR_BIT_EXT, - eDebug = VK_DEBUG_REPORT_DEBUG_BIT_EXT - }; - - // wrapper using for bitmask VkDebugReportFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportFlagsEXT.html - using DebugReportFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDebugReportFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportFlagsEXT allFlags = DebugReportFlagBitsEXT::eInformation | DebugReportFlagBitsEXT::eWarning | - DebugReportFlagBitsEXT::ePerformanceWarning | DebugReportFlagBitsEXT::eError | - DebugReportFlagBitsEXT::eDebug; - }; - - // wrapper class for enum VkDebugReportObjectTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportObjectTypeEXT.html - enum class DebugReportObjectTypeEXT - { - eUnknown = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, - eInstance = VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, - ePhysicalDevice = VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, - eDevice = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, - eQueue = VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, - eSemaphore = VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, - eCommandBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, - eFence = VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, - eDeviceMemory = VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, - eBuffer = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, - eImage = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, - eEvent = VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, - eQueryPool = VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, - eBufferView = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, - eImageView = VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, - eShaderModule = VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, - ePipelineCache = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, - ePipelineLayout = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, - eRenderPass = VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, - ePipeline = VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, - eDescriptorSetLayout = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, - eSampler = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, - eDescriptorPool = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, - eDescriptorSet = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, - eFramebuffer = VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, - eCommandPool = VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, - eSurfaceKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, - eSwapchainKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, - eDebugReportCallbackEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, - eDebugReport = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, - eDisplayKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, - eDisplayModeKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, - eValidationCacheEXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, - eValidationCache = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT, - eSamplerYcbcrConversion = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, - eSamplerYcbcrConversionKHR = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT, - eDescriptorUpdateTemplate = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, - eDescriptorUpdateTemplateKHR = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT, - eCuModuleNVX = VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT, - eCuFunctionNVX = VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT, - eAccelerationStructureKHR = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT, - eAccelerationStructureNV = VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eCudaModuleNV = VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV_EXT, - eCudaFunctionNV = VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV_EXT, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ -#if defined( VK_USE_PLATFORM_FUCHSIA ) - eBufferCollectionFUCHSIA = VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - }; - - //=== VK_AMD_rasterization_order === - - // wrapper class for enum VkRasterizationOrderAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRasterizationOrderAMD.html - enum class RasterizationOrderAMD - { - eStrict = VK_RASTERIZATION_ORDER_STRICT_AMD, - eRelaxed = VK_RASTERIZATION_ORDER_RELAXED_AMD - }; - - //=== VK_KHR_video_queue === - - // wrapper class for enum VkVideoCodecOperationFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodecOperationFlagBitsKHR.html - enum class VideoCodecOperationFlagBitsKHR : VkVideoCodecOperationFlagsKHR - { - eNone = VK_VIDEO_CODEC_OPERATION_NONE_KHR, - eEncodeH264 = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, - eEncodeH265 = VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, - eDecodeH264 = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, - eDecodeH265 = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, - eDecodeAv1 = VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR, - eEncodeAv1 = VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR, - eDecodeVp9 = VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR - }; - - // wrapper using for bitmask VkVideoCodecOperationFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodecOperationFlagsKHR.html - using VideoCodecOperationFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoCodecOperationFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodecOperationFlagsKHR allFlags = - VideoCodecOperationFlagBitsKHR::eNone | VideoCodecOperationFlagBitsKHR::eEncodeH264 | VideoCodecOperationFlagBitsKHR::eEncodeH265 | - VideoCodecOperationFlagBitsKHR::eDecodeH264 | VideoCodecOperationFlagBitsKHR::eDecodeH265 | VideoCodecOperationFlagBitsKHR::eDecodeAv1 | - VideoCodecOperationFlagBitsKHR::eEncodeAv1 | VideoCodecOperationFlagBitsKHR::eDecodeVp9; - }; - - // wrapper class for enum VkVideoChromaSubsamplingFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoChromaSubsamplingFlagBitsKHR.html - enum class VideoChromaSubsamplingFlagBitsKHR : VkVideoChromaSubsamplingFlagsKHR - { - eInvalid = VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR, - eMonochrome = VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR, - e420 = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, - e422 = VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR, - e444 = VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR - }; - - // wrapper using for bitmask VkVideoChromaSubsamplingFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoChromaSubsamplingFlagsKHR.html - using VideoChromaSubsamplingFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoChromaSubsamplingFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoChromaSubsamplingFlagsKHR allFlags = - VideoChromaSubsamplingFlagBitsKHR::eInvalid | VideoChromaSubsamplingFlagBitsKHR::eMonochrome | VideoChromaSubsamplingFlagBitsKHR::e420 | - VideoChromaSubsamplingFlagBitsKHR::e422 | VideoChromaSubsamplingFlagBitsKHR::e444; - }; - - // wrapper class for enum VkVideoComponentBitDepthFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoComponentBitDepthFlagBitsKHR.html - enum class VideoComponentBitDepthFlagBitsKHR : VkVideoComponentBitDepthFlagsKHR - { - eInvalid = VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR, - e8 = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, - e10 = VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR, - e12 = VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR - }; - - // wrapper using for bitmask VkVideoComponentBitDepthFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoComponentBitDepthFlagsKHR.html - using VideoComponentBitDepthFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoComponentBitDepthFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoComponentBitDepthFlagsKHR allFlags = - VideoComponentBitDepthFlagBitsKHR::eInvalid | VideoComponentBitDepthFlagBitsKHR::e8 | VideoComponentBitDepthFlagBitsKHR::e10 | - VideoComponentBitDepthFlagBitsKHR::e12; - }; - - // wrapper class for enum VkVideoCapabilityFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCapabilityFlagBitsKHR.html - enum class VideoCapabilityFlagBitsKHR : VkVideoCapabilityFlagsKHR - { - eProtectedContent = VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR, - eSeparateReferenceImages = VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR - }; - - // wrapper using for bitmask VkVideoCapabilityFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCapabilityFlagsKHR.html - using VideoCapabilityFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoCapabilityFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCapabilityFlagsKHR allFlags = - VideoCapabilityFlagBitsKHR::eProtectedContent | VideoCapabilityFlagBitsKHR::eSeparateReferenceImages; - }; - - // wrapper class for enum VkVideoSessionCreateFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionCreateFlagBitsKHR.html - enum class VideoSessionCreateFlagBitsKHR : VkVideoSessionCreateFlagsKHR - { - eProtectedContent = VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR, - eAllowEncodeParameterOptimizations = VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR, - eInlineQueries = VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR, - eAllowEncodeQuantizationDeltaMap = VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR, - eAllowEncodeEmphasisMap = VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR, - eInlineSessionParameters = VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR - }; - - // wrapper using for bitmask VkVideoSessionCreateFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionCreateFlagsKHR.html - using VideoSessionCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoSessionCreateFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionCreateFlagsKHR allFlags = - VideoSessionCreateFlagBitsKHR::eProtectedContent | VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations | - VideoSessionCreateFlagBitsKHR::eInlineQueries | VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap | - VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap | VideoSessionCreateFlagBitsKHR::eInlineSessionParameters; - }; - - // wrapper class for enum VkVideoCodingControlFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodingControlFlagBitsKHR.html - enum class VideoCodingControlFlagBitsKHR : VkVideoCodingControlFlagsKHR - { - eReset = VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR, - eEncodeRateControl = VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR, - eEncodeQualityLevel = VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR - }; - - // wrapper using for bitmask VkVideoCodingControlFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodingControlFlagsKHR.html - using VideoCodingControlFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoCodingControlFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoCodingControlFlagsKHR allFlags = - VideoCodingControlFlagBitsKHR::eReset | VideoCodingControlFlagBitsKHR::eEncodeRateControl | VideoCodingControlFlagBitsKHR::eEncodeQualityLevel; - }; - - // wrapper class for enum VkQueryResultStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryResultStatusKHR.html - enum class QueryResultStatusKHR - { - eError = VK_QUERY_RESULT_STATUS_ERROR_KHR, - eNotReady = VK_QUERY_RESULT_STATUS_NOT_READY_KHR, - eComplete = VK_QUERY_RESULT_STATUS_COMPLETE_KHR, - eInsufficientBitstreamBufferRange = VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR - }; - - // wrapper class for enum VkVideoSessionParametersCreateFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersCreateFlagBitsKHR.html - enum class VideoSessionParametersCreateFlagBitsKHR : VkVideoSessionParametersCreateFlagsKHR - { - eQuantizationMapCompatible = VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR - }; - - // wrapper using for bitmask VkVideoSessionParametersCreateFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersCreateFlagsKHR.html - using VideoSessionParametersCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoSessionParametersCreateFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoSessionParametersCreateFlagsKHR allFlags = VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible; - }; - - enum class VideoBeginCodingFlagBitsKHR : VkVideoBeginCodingFlagsKHR - { - }; - - // wrapper using for bitmask VkVideoBeginCodingFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoBeginCodingFlagsKHR.html - using VideoBeginCodingFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoBeginCodingFlagsKHR allFlags = {}; - }; - - enum class VideoEndCodingFlagBitsKHR : VkVideoEndCodingFlagsKHR - { - }; - - // wrapper using for bitmask VkVideoEndCodingFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEndCodingFlagsKHR.html - using VideoEndCodingFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEndCodingFlagsKHR allFlags = {}; - }; - - //=== VK_KHR_video_decode_queue === - - // wrapper class for enum VkVideoDecodeCapabilityFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeCapabilityFlagBitsKHR.html - enum class VideoDecodeCapabilityFlagBitsKHR : VkVideoDecodeCapabilityFlagsKHR - { - eDpbAndOutputCoincide = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR, - eDpbAndOutputDistinct = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR - }; - - // wrapper using for bitmask VkVideoDecodeCapabilityFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeCapabilityFlagsKHR.html - using VideoDecodeCapabilityFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoDecodeCapabilityFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeCapabilityFlagsKHR allFlags = - VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide | VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct; - }; - - // wrapper class for enum VkVideoDecodeUsageFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeUsageFlagBitsKHR.html - enum class VideoDecodeUsageFlagBitsKHR : VkVideoDecodeUsageFlagsKHR - { - eDefault = VK_VIDEO_DECODE_USAGE_DEFAULT_KHR, - eTranscoding = VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR, - eOffline = VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR, - eStreaming = VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR - }; - - // wrapper using for bitmask VkVideoDecodeUsageFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeUsageFlagsKHR.html - using VideoDecodeUsageFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoDecodeUsageFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeUsageFlagsKHR allFlags = VideoDecodeUsageFlagBitsKHR::eDefault | VideoDecodeUsageFlagBitsKHR::eTranscoding | - VideoDecodeUsageFlagBitsKHR::eOffline | VideoDecodeUsageFlagBitsKHR::eStreaming; - }; - - enum class VideoDecodeFlagBitsKHR : VkVideoDecodeFlagsKHR - { - }; - - // wrapper using for bitmask VkVideoDecodeFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeFlagsKHR.html - using VideoDecodeFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeFlagsKHR allFlags = {}; - }; - - //=== VK_EXT_transform_feedback === - - enum class PipelineRasterizationStateStreamCreateFlagBitsEXT : VkPipelineRasterizationStateStreamCreateFlagsEXT - { - }; - - // wrapper using for bitmask VkPipelineRasterizationStateStreamCreateFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateStreamCreateFlagsEXT.html - using PipelineRasterizationStateStreamCreateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationStateStreamCreateFlagsEXT allFlags = {}; - }; - - //=== VK_KHR_video_encode_h264 === - - // wrapper class for enum VkVideoEncodeH264CapabilityFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264CapabilityFlagBitsKHR.html - enum class VideoEncodeH264CapabilityFlagBitsKHR : VkVideoEncodeH264CapabilityFlagsKHR - { - eHrdCompliance = VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR, - ePredictionWeightTableGenerated = VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR, - eRowUnalignedSlice = VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR, - eDifferentSliceType = VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR, - eBFrameInL0List = VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR, - eBFrameInL1List = VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR, - ePerPictureTypeMinMaxQp = VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR, - ePerSliceConstantQp = VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR, - eGeneratePrefixNalu = VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR, - eBPictureIntraRefresh = VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR, - eMbQpDiffWraparound = VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeH264CapabilityFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264CapabilityFlagsKHR.html - using VideoEncodeH264CapabilityFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeH264CapabilityFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264CapabilityFlagsKHR allFlags = - VideoEncodeH264CapabilityFlagBitsKHR::eHrdCompliance | VideoEncodeH264CapabilityFlagBitsKHR::ePredictionWeightTableGenerated | - VideoEncodeH264CapabilityFlagBitsKHR::eRowUnalignedSlice | VideoEncodeH264CapabilityFlagBitsKHR::eDifferentSliceType | - VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL0List | VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL1List | - VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp | VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp | - VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu | VideoEncodeH264CapabilityFlagBitsKHR::eBPictureIntraRefresh | - VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound; - }; - - // wrapper class for enum VkVideoEncodeH264StdFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264StdFlagBitsKHR.html - enum class VideoEncodeH264StdFlagBitsKHR : VkVideoEncodeH264StdFlagsKHR - { - eSeparateColorPlaneFlagSet = VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR, - eQpprimeYZeroTransformBypassFlagSet = VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR, - eScalingMatrixPresentFlagSet = VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR, - eChromaQpIndexOffset = VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR, - eSecondChromaQpIndexOffset = VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR, - ePicInitQpMinus26 = VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR, - eWeightedPredFlagSet = VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR, - eWeightedBipredIdcExplicit = VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR, - eWeightedBipredIdcImplicit = VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR, - eTransform8X8ModeFlagSet = VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR, - eDirectSpatialMvPredFlagUnset = VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR, - eEntropyCodingModeFlagUnset = VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR, - eEntropyCodingModeFlagSet = VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR, - eDirect8X8InferenceFlagUnset = VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR, - eConstrainedIntraPredFlagSet = VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR, - eDeblockingFilterDisabled = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR, - eDeblockingFilterEnabled = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR, - eDeblockingFilterPartial = VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR, - eSliceQpDelta = VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR, - eDifferentSliceQpDelta = VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeH264StdFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264StdFlagsKHR.html - using VideoEncodeH264StdFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeH264StdFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264StdFlagsKHR allFlags = - VideoEncodeH264StdFlagBitsKHR::eSeparateColorPlaneFlagSet | VideoEncodeH264StdFlagBitsKHR::eQpprimeYZeroTransformBypassFlagSet | - VideoEncodeH264StdFlagBitsKHR::eScalingMatrixPresentFlagSet | VideoEncodeH264StdFlagBitsKHR::eChromaQpIndexOffset | - VideoEncodeH264StdFlagBitsKHR::eSecondChromaQpIndexOffset | VideoEncodeH264StdFlagBitsKHR::ePicInitQpMinus26 | - VideoEncodeH264StdFlagBitsKHR::eWeightedPredFlagSet | VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcExplicit | - VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcImplicit | VideoEncodeH264StdFlagBitsKHR::eTransform8X8ModeFlagSet | - VideoEncodeH264StdFlagBitsKHR::eDirectSpatialMvPredFlagUnset | VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagUnset | - VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagSet | VideoEncodeH264StdFlagBitsKHR::eDirect8X8InferenceFlagUnset | - VideoEncodeH264StdFlagBitsKHR::eConstrainedIntraPredFlagSet | VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterDisabled | - VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterEnabled | VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterPartial | - VideoEncodeH264StdFlagBitsKHR::eSliceQpDelta | VideoEncodeH264StdFlagBitsKHR::eDifferentSliceQpDelta; - }; - - // wrapper class for enum VkVideoEncodeH264RateControlFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlFlagBitsKHR.html - enum class VideoEncodeH264RateControlFlagBitsKHR : VkVideoEncodeH264RateControlFlagsKHR - { - eAttemptHrdCompliance = VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR, - eRegularGop = VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR, - eReferencePatternFlat = VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR, - eReferencePatternDyadic = VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR, - eTemporalLayerPatternDyadic = VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeH264RateControlFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlFlagsKHR.html - using VideoEncodeH264RateControlFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeH264RateControlFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH264RateControlFlagsKHR allFlags = - VideoEncodeH264RateControlFlagBitsKHR::eAttemptHrdCompliance | VideoEncodeH264RateControlFlagBitsKHR::eRegularGop | - VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternFlat | VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternDyadic | - VideoEncodeH264RateControlFlagBitsKHR::eTemporalLayerPatternDyadic; - }; - - //=== VK_KHR_video_encode_h265 === - - // wrapper class for enum VkVideoEncodeH265CapabilityFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilityFlagBitsKHR.html - enum class VideoEncodeH265CapabilityFlagBitsKHR : VkVideoEncodeH265CapabilityFlagsKHR - { - eHrdCompliance = VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR, - ePredictionWeightTableGenerated = VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR, - eRowUnalignedSliceSegment = VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR, - eDifferentSliceSegmentType = VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR, - eBFrameInL0List = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR, - eBFrameInL1List = VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR, - ePerPictureTypeMinMaxQp = VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR, - ePerSliceSegmentConstantQp = VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR, - eMultipleTilesPerSliceSegment = VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR, - eMultipleSliceSegmentsPerTile = VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR, - eBPictureIntraRefresh = VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR, - eCuQpDiffWraparound = VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeH265CapabilityFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilityFlagsKHR.html - using VideoEncodeH265CapabilityFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeH265CapabilityFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265CapabilityFlagsKHR allFlags = - VideoEncodeH265CapabilityFlagBitsKHR::eHrdCompliance | VideoEncodeH265CapabilityFlagBitsKHR::ePredictionWeightTableGenerated | - VideoEncodeH265CapabilityFlagBitsKHR::eRowUnalignedSliceSegment | VideoEncodeH265CapabilityFlagBitsKHR::eDifferentSliceSegmentType | - VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL0List | VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL1List | - VideoEncodeH265CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp | VideoEncodeH265CapabilityFlagBitsKHR::ePerSliceSegmentConstantQp | - VideoEncodeH265CapabilityFlagBitsKHR::eMultipleTilesPerSliceSegment | VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile | - VideoEncodeH265CapabilityFlagBitsKHR::eBPictureIntraRefresh | VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound; - }; - - // wrapper class for enum VkVideoEncodeH265StdFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265StdFlagBitsKHR.html - enum class VideoEncodeH265StdFlagBitsKHR : VkVideoEncodeH265StdFlagsKHR - { - eSeparateColorPlaneFlagSet = VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR, - eSampleAdaptiveOffsetEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR, - eScalingListDataPresentFlagSet = VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR, - ePcmEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR, - eSpsTemporalMvpEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR, - eInitQpMinus26 = VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR, - eWeightedPredFlagSet = VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR, - eWeightedBipredFlagSet = VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR, - eLog2ParallelMergeLevelMinus2 = VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR, - eSignDataHidingEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR, - eTransformSkipEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR, - eTransformSkipEnabledFlagUnset = VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR, - ePpsSliceChromaQpOffsetsPresentFlagSet = VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR, - eTransquantBypassEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR, - eConstrainedIntraPredFlagSet = VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR, - eEntropyCodingSyncEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR, - eDeblockingFilterOverrideEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR, - eDependentSliceSegmentsEnabledFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR, - eDependentSliceSegmentFlagSet = VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR, - eSliceQpDelta = VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR, - eDifferentSliceQpDelta = VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeH265StdFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265StdFlagsKHR.html - using VideoEncodeH265StdFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeH265StdFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265StdFlagsKHR allFlags = - VideoEncodeH265StdFlagBitsKHR::eSeparateColorPlaneFlagSet | VideoEncodeH265StdFlagBitsKHR::eSampleAdaptiveOffsetEnabledFlagSet | - VideoEncodeH265StdFlagBitsKHR::eScalingListDataPresentFlagSet | VideoEncodeH265StdFlagBitsKHR::ePcmEnabledFlagSet | - VideoEncodeH265StdFlagBitsKHR::eSpsTemporalMvpEnabledFlagSet | VideoEncodeH265StdFlagBitsKHR::eInitQpMinus26 | - VideoEncodeH265StdFlagBitsKHR::eWeightedPredFlagSet | VideoEncodeH265StdFlagBitsKHR::eWeightedBipredFlagSet | - VideoEncodeH265StdFlagBitsKHR::eLog2ParallelMergeLevelMinus2 | VideoEncodeH265StdFlagBitsKHR::eSignDataHidingEnabledFlagSet | - VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagSet | VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagUnset | - VideoEncodeH265StdFlagBitsKHR::ePpsSliceChromaQpOffsetsPresentFlagSet | VideoEncodeH265StdFlagBitsKHR::eTransquantBypassEnabledFlagSet | - VideoEncodeH265StdFlagBitsKHR::eConstrainedIntraPredFlagSet | VideoEncodeH265StdFlagBitsKHR::eEntropyCodingSyncEnabledFlagSet | - VideoEncodeH265StdFlagBitsKHR::eDeblockingFilterOverrideEnabledFlagSet | VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentsEnabledFlagSet | - VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentFlagSet | VideoEncodeH265StdFlagBitsKHR::eSliceQpDelta | - VideoEncodeH265StdFlagBitsKHR::eDifferentSliceQpDelta; - }; - - // wrapper class for enum VkVideoEncodeH265CtbSizeFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CtbSizeFlagBitsKHR.html - enum class VideoEncodeH265CtbSizeFlagBitsKHR : VkVideoEncodeH265CtbSizeFlagsKHR - { - e16 = VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR, - e32 = VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR, - e64 = VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeH265CtbSizeFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CtbSizeFlagsKHR.html - using VideoEncodeH265CtbSizeFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeH265CtbSizeFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265CtbSizeFlagsKHR allFlags = - VideoEncodeH265CtbSizeFlagBitsKHR::e16 | VideoEncodeH265CtbSizeFlagBitsKHR::e32 | VideoEncodeH265CtbSizeFlagBitsKHR::e64; - }; - - // wrapper class for enum VkVideoEncodeH265TransformBlockSizeFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265TransformBlockSizeFlagBitsKHR.html - enum class VideoEncodeH265TransformBlockSizeFlagBitsKHR : VkVideoEncodeH265TransformBlockSizeFlagsKHR - { - e4 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR, - e8 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR, - e16 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR, - e32 = VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeH265TransformBlockSizeFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265TransformBlockSizeFlagsKHR.html - using VideoEncodeH265TransformBlockSizeFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeH265TransformBlockSizeFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265TransformBlockSizeFlagsKHR allFlags = - VideoEncodeH265TransformBlockSizeFlagBitsKHR::e4 | VideoEncodeH265TransformBlockSizeFlagBitsKHR::e8 | VideoEncodeH265TransformBlockSizeFlagBitsKHR::e16 | - VideoEncodeH265TransformBlockSizeFlagBitsKHR::e32; - }; - - // wrapper class for enum VkVideoEncodeH265RateControlFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlFlagBitsKHR.html - enum class VideoEncodeH265RateControlFlagBitsKHR : VkVideoEncodeH265RateControlFlagsKHR - { - eAttemptHrdCompliance = VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR, - eRegularGop = VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR, - eReferencePatternFlat = VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR, - eReferencePatternDyadic = VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR, - eTemporalSubLayerPatternDyadic = VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeH265RateControlFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlFlagsKHR.html - using VideoEncodeH265RateControlFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeH265RateControlFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeH265RateControlFlagsKHR allFlags = - VideoEncodeH265RateControlFlagBitsKHR::eAttemptHrdCompliance | VideoEncodeH265RateControlFlagBitsKHR::eRegularGop | - VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternFlat | VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternDyadic | - VideoEncodeH265RateControlFlagBitsKHR::eTemporalSubLayerPatternDyadic; - }; - - //=== VK_KHR_video_decode_h264 === - - // wrapper class for enum VkVideoDecodeH264PictureLayoutFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264PictureLayoutFlagBitsKHR.html - enum class VideoDecodeH264PictureLayoutFlagBitsKHR : VkVideoDecodeH264PictureLayoutFlagsKHR - { - eProgressive = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR, - eInterlacedInterleavedLines = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR, - eInterlacedSeparatePlanes = VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR - }; - - // wrapper using for bitmask VkVideoDecodeH264PictureLayoutFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264PictureLayoutFlagsKHR.html - using VideoDecodeH264PictureLayoutFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoDecodeH264PictureLayoutFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoDecodeH264PictureLayoutFlagsKHR allFlags = VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive | - VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines | - VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes; - }; - - //=== VK_AMD_shader_info === - - // wrapper class for enum VkShaderInfoTypeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderInfoTypeAMD.html - enum class ShaderInfoTypeAMD - { - eStatistics = VK_SHADER_INFO_TYPE_STATISTICS_AMD, - eBinary = VK_SHADER_INFO_TYPE_BINARY_AMD, - eDisassembly = VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD - }; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - - enum class StreamDescriptorSurfaceCreateFlagBitsGGP : VkStreamDescriptorSurfaceCreateFlagsGGP - { - }; - - // wrapper using for bitmask VkStreamDescriptorSurfaceCreateFlagsGGP, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkStreamDescriptorSurfaceCreateFlagsGGP.html - using StreamDescriptorSurfaceCreateFlagsGGP = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StreamDescriptorSurfaceCreateFlagsGGP allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - - // wrapper class for enum VkExternalMemoryHandleTypeFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlagBitsNV.html - enum class ExternalMemoryHandleTypeFlagBitsNV : VkExternalMemoryHandleTypeFlagsNV - { - eOpaqueWin32 = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV, - eOpaqueWin32Kmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV, - eD3D11Image = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV, - eD3D11ImageKmt = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV - }; - - // wrapper using for bitmask VkExternalMemoryHandleTypeFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryHandleTypeFlagsNV.html - using ExternalMemoryHandleTypeFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkExternalMemoryHandleTypeFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryHandleTypeFlagsNV allFlags = - ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 | ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt | ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image | - ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt; - }; - - // wrapper class for enum VkExternalMemoryFeatureFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlagBitsNV.html - enum class ExternalMemoryFeatureFlagBitsNV : VkExternalMemoryFeatureFlagsNV - { - eDedicatedOnly = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV, - eExportable = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV, - eImportable = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV - }; - - // wrapper using for bitmask VkExternalMemoryFeatureFlagsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryFeatureFlagsNV.html - using ExternalMemoryFeatureFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkExternalMemoryFeatureFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ExternalMemoryFeatureFlagsNV allFlags = - ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly | ExternalMemoryFeatureFlagBitsNV::eExportable | ExternalMemoryFeatureFlagBitsNV::eImportable; - }; - - //=== VK_EXT_validation_flags === - - // wrapper class for enum VkValidationCheckEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCheckEXT.html - enum class ValidationCheckEXT - { - eAll = VK_VALIDATION_CHECK_ALL_EXT, - eShaders = VK_VALIDATION_CHECK_SHADERS_EXT - }; - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - - enum class ViSurfaceCreateFlagBitsNN : VkViSurfaceCreateFlagsNN - { - }; - - // wrapper using for bitmask VkViSurfaceCreateFlagsNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViSurfaceCreateFlagsNN.html - using ViSurfaceCreateFlagsNN = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ViSurfaceCreateFlagsNN allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_EXT_conditional_rendering === - - // wrapper class for enum VkConditionalRenderingFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingFlagBitsEXT.html - enum class ConditionalRenderingFlagBitsEXT : VkConditionalRenderingFlagsEXT - { - eInverted = VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT - }; - - // wrapper using for bitmask VkConditionalRenderingFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingFlagsEXT.html - using ConditionalRenderingFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkConditionalRenderingFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ConditionalRenderingFlagsEXT allFlags = ConditionalRenderingFlagBitsEXT::eInverted; - }; - - //=== VK_EXT_display_surface_counter === - - // wrapper class for enum VkSurfaceCounterFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCounterFlagBitsEXT.html - enum class SurfaceCounterFlagBitsEXT : VkSurfaceCounterFlagsEXT - { - eVblank = VK_SURFACE_COUNTER_VBLANK_BIT_EXT - }; - - // wrapper using for bitmask VkSurfaceCounterFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCounterFlagsEXT.html - using SurfaceCounterFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkSurfaceCounterFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceCounterFlagsEXT allFlags = SurfaceCounterFlagBitsEXT::eVblank; - }; - - //=== VK_EXT_display_control === - - // wrapper class for enum VkDisplayPowerStateEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPowerStateEXT.html - enum class DisplayPowerStateEXT - { - eOff = VK_DISPLAY_POWER_STATE_OFF_EXT, - eSuspend = VK_DISPLAY_POWER_STATE_SUSPEND_EXT, - eOn = VK_DISPLAY_POWER_STATE_ON_EXT - }; - - // wrapper class for enum VkDeviceEventTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceEventTypeEXT.html - enum class DeviceEventTypeEXT - { - eDisplayHotplug = VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT - }; - - // wrapper class for enum VkDisplayEventTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayEventTypeEXT.html - enum class DisplayEventTypeEXT - { - eFirstPixelOut = VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT - }; - - //=== VK_NV_viewport_swizzle === - - // wrapper class for enum VkViewportCoordinateSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViewportCoordinateSwizzleNV.html - enum class ViewportCoordinateSwizzleNV - { - ePositiveX = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV, - eNegativeX = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV, - ePositiveY = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV, - eNegativeY = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV, - ePositiveZ = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV, - eNegativeZ = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV, - ePositiveW = VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV, - eNegativeW = VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV - }; - - enum class PipelineViewportSwizzleStateCreateFlagBitsNV : VkPipelineViewportSwizzleStateCreateFlagsNV - { - }; - - // wrapper using for bitmask VkPipelineViewportSwizzleStateCreateFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportSwizzleStateCreateFlagsNV.html - using PipelineViewportSwizzleStateCreateFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineViewportSwizzleStateCreateFlagsNV allFlags = {}; - }; - - //=== VK_EXT_discard_rectangles === - - // wrapper class for enum VkDiscardRectangleModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDiscardRectangleModeEXT.html - enum class DiscardRectangleModeEXT - { - eInclusive = VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT, - eExclusive = VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT - }; - - enum class PipelineDiscardRectangleStateCreateFlagBitsEXT : VkPipelineDiscardRectangleStateCreateFlagsEXT - { - }; - - // wrapper using for bitmask VkPipelineDiscardRectangleStateCreateFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDiscardRectangleStateCreateFlagsEXT.html - using PipelineDiscardRectangleStateCreateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineDiscardRectangleStateCreateFlagsEXT allFlags = {}; - }; - - //=== VK_EXT_conservative_rasterization === - - // wrapper class for enum VkConservativeRasterizationModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConservativeRasterizationModeEXT.html - enum class ConservativeRasterizationModeEXT - { - eDisabled = VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT, - eOverestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, - eUnderestimate = VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT - }; - - enum class PipelineRasterizationConservativeStateCreateFlagBitsEXT : VkPipelineRasterizationConservativeStateCreateFlagsEXT - { - }; - - // wrapper using for bitmask VkPipelineRasterizationConservativeStateCreateFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationConservativeStateCreateFlagsEXT.html - using PipelineRasterizationConservativeStateCreateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationConservativeStateCreateFlagsEXT allFlags = {}; - }; - - //=== VK_EXT_depth_clip_enable === - - enum class PipelineRasterizationDepthClipStateCreateFlagBitsEXT : VkPipelineRasterizationDepthClipStateCreateFlagsEXT - { - }; - - // wrapper using for bitmask VkPipelineRasterizationDepthClipStateCreateFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationDepthClipStateCreateFlagsEXT.html - using PipelineRasterizationDepthClipStateCreateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineRasterizationDepthClipStateCreateFlagsEXT allFlags = {}; - }; - - //=== VK_KHR_performance_query === - - // wrapper class for enum VkPerformanceCounterDescriptionFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionFlagBitsKHR.html - enum class PerformanceCounterDescriptionFlagBitsKHR : VkPerformanceCounterDescriptionFlagsKHR - { - ePerformanceImpacting = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, - eConcurrentlyImpacted = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR - }; - - // wrapper using for bitmask VkPerformanceCounterDescriptionFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionFlagsKHR.html - using PerformanceCounterDescriptionFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPerformanceCounterDescriptionFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PerformanceCounterDescriptionFlagsKHR allFlags = - PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting | PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted; - }; - - // wrapper class for enum VkPerformanceCounterScopeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterScopeKHR.html - enum class PerformanceCounterScopeKHR - { - eCommandBuffer = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, - eVkQueryScopeCommandBuffer = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR, - eRenderPass = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, - eVkQueryScopeRenderPass = VK_QUERY_SCOPE_RENDER_PASS_KHR, - eCommand = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, - eVkQueryScopeCommand = VK_QUERY_SCOPE_COMMAND_KHR - }; - - // wrapper class for enum VkPerformanceCounterStorageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterStorageKHR.html - enum class PerformanceCounterStorageKHR - { - eInt32 = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR, - eInt64 = VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR, - eUint32 = VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR, - eUint64 = VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR, - eFloat32 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR, - eFloat64 = VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR - }; - - // wrapper class for enum VkPerformanceCounterUnitKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterUnitKHR.html - enum class PerformanceCounterUnitKHR - { - eGeneric = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR, - ePercentage = VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR, - eNanoseconds = VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR, - eBytes = VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR, - eBytesPerSecond = VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR, - eKelvin = VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR, - eWatts = VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR, - eVolts = VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR, - eAmps = VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR, - eHertz = VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR, - eCycles = VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR - }; - - enum class AcquireProfilingLockFlagBitsKHR : VkAcquireProfilingLockFlagsKHR - { - }; - - // wrapper using for bitmask VkAcquireProfilingLockFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAcquireProfilingLockFlagsKHR.html - using AcquireProfilingLockFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR AcquireProfilingLockFlagsKHR allFlags = {}; - }; - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - - enum class IOSSurfaceCreateFlagBitsMVK : VkIOSSurfaceCreateFlagsMVK - { - }; - - // wrapper using for bitmask VkIOSSurfaceCreateFlagsMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIOSSurfaceCreateFlagsMVK.html - using IOSSurfaceCreateFlagsMVK = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR IOSSurfaceCreateFlagsMVK allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - - enum class MacOSSurfaceCreateFlagBitsMVK : VkMacOSSurfaceCreateFlagsMVK - { - }; - - // wrapper using for bitmask VkMacOSSurfaceCreateFlagsMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMacOSSurfaceCreateFlagsMVK.html - using MacOSSurfaceCreateFlagsMVK = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MacOSSurfaceCreateFlagsMVK allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - - // wrapper class for enum VkDebugUtilsMessageSeverityFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageSeverityFlagBitsEXT.html - enum class DebugUtilsMessageSeverityFlagBitsEXT : VkDebugUtilsMessageSeverityFlagsEXT - { - eVerbose = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT, - eInfo = VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT, - eWarning = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT, - eError = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT - }; - - // wrapper using for bitmask VkDebugUtilsMessageSeverityFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageSeverityFlagsEXT.html - using DebugUtilsMessageSeverityFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDebugUtilsMessageSeverityFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessageSeverityFlagsEXT allFlags = - DebugUtilsMessageSeverityFlagBitsEXT::eVerbose | DebugUtilsMessageSeverityFlagBitsEXT::eInfo | DebugUtilsMessageSeverityFlagBitsEXT::eWarning | - DebugUtilsMessageSeverityFlagBitsEXT::eError; - }; - - // wrapper class for enum VkDebugUtilsMessageTypeFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageTypeFlagBitsEXT.html - enum class DebugUtilsMessageTypeFlagBitsEXT : VkDebugUtilsMessageTypeFlagsEXT - { - eGeneral = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT, - eValidation = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT, - ePerformance = VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT, - eDeviceAddressBinding = VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT - }; - - // wrapper using for bitmask VkDebugUtilsMessageTypeFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessageTypeFlagsEXT.html - using DebugUtilsMessageTypeFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDebugUtilsMessageTypeFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessageTypeFlagsEXT allFlags = - DebugUtilsMessageTypeFlagBitsEXT::eGeneral | DebugUtilsMessageTypeFlagBitsEXT::eValidation | DebugUtilsMessageTypeFlagBitsEXT::ePerformance | - DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding; - }; - - enum class DebugUtilsMessengerCallbackDataFlagBitsEXT : VkDebugUtilsMessengerCallbackDataFlagsEXT - { - }; - - // wrapper using for bitmask VkDebugUtilsMessengerCallbackDataFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCallbackDataFlagsEXT.html - using DebugUtilsMessengerCallbackDataFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessengerCallbackDataFlagsEXT allFlags = {}; - }; - - enum class DebugUtilsMessengerCreateFlagBitsEXT : VkDebugUtilsMessengerCreateFlagsEXT - { - }; - - // wrapper using for bitmask VkDebugUtilsMessengerCreateFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCreateFlagsEXT.html - using DebugUtilsMessengerCreateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugUtilsMessengerCreateFlagsEXT allFlags = {}; - }; - - //=== VK_EXT_descriptor_heap === - - // wrapper class for enum VkDescriptorMappingSourceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceEXT.html - enum class DescriptorMappingSourceEXT - { - eHeapWithConstantOffset = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT, - eHeapWithPushIndex = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT, - eHeapWithIndirectIndex = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT, - eHeapWithIndirectIndexArray = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT, - eResourceHeapData = VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT, - ePushData = VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT, - ePushAddress = VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT, - eIndirectAddress = VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT, - eHeapWithShaderRecordIndex = VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT, - eShaderRecordData = VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT, - eShaderRecordAddress = VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT - }; - - // wrapper class for enum VkSpirvResourceTypeFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpirvResourceTypeFlagBitsEXT.html - enum class SpirvResourceTypeFlagBitsEXT : VkSpirvResourceTypeFlagsEXT - { - eAll = VK_SPIRV_RESOURCE_TYPE_ALL_EXT, - eSampler = VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT, - eSampledImage = VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT, - eReadOnlyImage = VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT, - eReadWriteImage = VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT, - eCombinedSampledImage = VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT, - eUniformBuffer = VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT, - eReadOnlyStorageBuffer = VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT, - eReadWriteStorageBuffer = VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT, - eAccelerationStructure = VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT, - eTensorARM = VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM - }; - - // wrapper using for bitmask VkSpirvResourceTypeFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpirvResourceTypeFlagsEXT.html - using SpirvResourceTypeFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkSpirvResourceTypeFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SpirvResourceTypeFlagsEXT allFlags = - SpirvResourceTypeFlagBitsEXT::eAll | SpirvResourceTypeFlagBitsEXT::eSampler | SpirvResourceTypeFlagBitsEXT::eSampledImage | - SpirvResourceTypeFlagBitsEXT::eReadOnlyImage | SpirvResourceTypeFlagBitsEXT::eReadWriteImage | SpirvResourceTypeFlagBitsEXT::eCombinedSampledImage | - SpirvResourceTypeFlagBitsEXT::eUniformBuffer | SpirvResourceTypeFlagBitsEXT::eReadOnlyStorageBuffer | - SpirvResourceTypeFlagBitsEXT::eReadWriteStorageBuffer | SpirvResourceTypeFlagBitsEXT::eAccelerationStructure | SpirvResourceTypeFlagBitsEXT::eTensorARM; - }; - - // wrapper class for enum VkTensorViewCreateFlagBitsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateFlagBitsARM.html - enum class TensorViewCreateFlagBitsARM : VkTensorViewCreateFlagsARM - { - eDescriptorBufferCaptureReplay = VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM - }; - - // wrapper using for bitmask VkTensorViewCreateFlagsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateFlagsARM.html - using TensorViewCreateFlagsARM = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkTensorViewCreateFlagBitsARM; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR TensorViewCreateFlagsARM allFlags = TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay; - }; - - //=== VK_EXT_blend_operation_advanced === - - // wrapper class for enum VkBlendOverlapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlendOverlapEXT.html - enum class BlendOverlapEXT - { - eUncorrelated = VK_BLEND_OVERLAP_UNCORRELATED_EXT, - eDisjoint = VK_BLEND_OVERLAP_DISJOINT_EXT, - eConjoint = VK_BLEND_OVERLAP_CONJOINT_EXT - }; - - //=== VK_NV_fragment_coverage_to_color === - - enum class PipelineCoverageToColorStateCreateFlagBitsNV : VkPipelineCoverageToColorStateCreateFlagsNV - { - }; - - // wrapper using for bitmask VkPipelineCoverageToColorStateCreateFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageToColorStateCreateFlagsNV.html - using PipelineCoverageToColorStateCreateFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCoverageToColorStateCreateFlagsNV allFlags = {}; - }; - - //=== VK_KHR_acceleration_structure === - - // wrapper class for enum VkAccelerationStructureTypeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTypeKHR.html - enum class AccelerationStructureTypeKHR - { - eTopLevel = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, - eBottomLevel = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, - eGeneric = VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR - }; - - using AccelerationStructureTypeNV = AccelerationStructureTypeKHR; - - // wrapper class for enum VkAccelerationStructureBuildTypeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildTypeKHR.html - enum class AccelerationStructureBuildTypeKHR - { - eHost = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR, - eDevice = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR, - eHostOrDevice = VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR - }; - - // wrapper class for enum VkGeometryFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryFlagBitsKHR.html - enum class GeometryFlagBitsKHR : VkGeometryFlagsKHR - { - eOpaque = VK_GEOMETRY_OPAQUE_BIT_KHR, - eNoDuplicateAnyHitInvocation = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR - }; - - using GeometryFlagBitsNV = GeometryFlagBitsKHR; - - // wrapper using for bitmask VkGeometryFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryFlagsKHR.html - using GeometryFlagsKHR = Flags; - using GeometryFlagsNV = GeometryFlagsKHR; - - template <> - struct FlagTraits - { - using WrappedType = VkGeometryFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR GeometryFlagsKHR allFlags = GeometryFlagBitsKHR::eOpaque | GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation; - }; - - // wrapper class for enum VkGeometryInstanceFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryInstanceFlagBitsKHR.html - enum class GeometryInstanceFlagBitsKHR : VkGeometryInstanceFlagsKHR - { - eTriangleFacingCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, - eTriangleCullDisable = VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV, - eTriangleFlipFacing = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, - eTriangleFrontCounterclockwise = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, - eForceOpaque = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, - eForceNoOpaque = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, - eForceOpacityMicromap2StateEXT = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT, - eDisableOpacityMicromapsEXT = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT - }; - - using GeometryInstanceFlagBitsNV = GeometryInstanceFlagBitsKHR; - - // wrapper using for bitmask VkGeometryInstanceFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryInstanceFlagsKHR.html - using GeometryInstanceFlagsKHR = Flags; - using GeometryInstanceFlagsNV = GeometryInstanceFlagsKHR; - - template <> - struct FlagTraits - { - using WrappedType = VkGeometryInstanceFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR GeometryInstanceFlagsKHR allFlags = - GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable | GeometryInstanceFlagBitsKHR::eTriangleFlipFacing | GeometryInstanceFlagBitsKHR::eForceOpaque | - GeometryInstanceFlagBitsKHR::eForceNoOpaque | GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT | - GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT; - }; - - // wrapper class for enum VkBuildAccelerationStructureFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildAccelerationStructureFlagBitsKHR.html - enum class BuildAccelerationStructureFlagBitsKHR : VkBuildAccelerationStructureFlagsKHR - { - eAllowUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, - eAllowCompaction = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, - ePreferFastTrace = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, - ePreferFastBuild = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, - eLowMemory = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, - eMotionNV = VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV, - eAllowOpacityMicromapUpdateEXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT, - eAllowDisableOpacityMicromapsEXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT, - eAllowOpacityMicromapDataUpdateEXT = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eAllowDisplacementMicromapUpdateNV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_BIT_NV, - eAllowDisplacementMicromapUpdate = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV, -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eAllowDataAccess = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR, - eAllowClusterOpacityMicromapsNV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV - }; - - using BuildAccelerationStructureFlagBitsNV = BuildAccelerationStructureFlagBitsKHR; - - // wrapper using for bitmask VkBuildAccelerationStructureFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildAccelerationStructureFlagsKHR.html - using BuildAccelerationStructureFlagsKHR = Flags; - using BuildAccelerationStructureFlagsNV = BuildAccelerationStructureFlagsKHR; - - template <> - struct FlagTraits - { - using WrappedType = VkBuildAccelerationStructureFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR BuildAccelerationStructureFlagsKHR allFlags = - BuildAccelerationStructureFlagBitsKHR::eAllowUpdate | BuildAccelerationStructureFlagBitsKHR::eAllowCompaction | - BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace | BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild | - BuildAccelerationStructureFlagBitsKHR::eLowMemory | BuildAccelerationStructureFlagBitsKHR::eMotionNV | - BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT | BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT | - BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - | BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - | BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess | BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV; - }; - - // wrapper class for enum VkCopyAccelerationStructureModeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyAccelerationStructureModeKHR.html - enum class CopyAccelerationStructureModeKHR - { - eClone = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR, - eCompact = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, - eSerialize = VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR, - eDeserialize = VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR - }; - - using CopyAccelerationStructureModeNV = CopyAccelerationStructureModeKHR; - - // wrapper class for enum VkGeometryTypeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryTypeKHR.html - enum class GeometryTypeKHR - { - eTriangles = VK_GEOMETRY_TYPE_TRIANGLES_KHR, - eAabbs = VK_GEOMETRY_TYPE_AABBS_KHR, - eInstances = VK_GEOMETRY_TYPE_INSTANCES_KHR, - eSpheresNV = VK_GEOMETRY_TYPE_SPHERES_NV, - eLinearSweptSpheresNV = VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eDenseGeometryFormatTrianglesAMDX = VK_GEOMETRY_TYPE_DENSE_GEOMETRY_FORMAT_TRIANGLES_AMDX -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - }; - - using GeometryTypeNV = GeometryTypeKHR; - - // wrapper class for enum VkAccelerationStructureCompatibilityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCompatibilityKHR.html - enum class AccelerationStructureCompatibilityKHR - { - eCompatible = VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR, - eIncompatible = VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR - }; - - // wrapper class for enum VkAccelerationStructureCreateFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateFlagBitsKHR.html - enum class AccelerationStructureCreateFlagBitsKHR : VkAccelerationStructureCreateFlagsKHR - { - eDeviceAddressCaptureReplay = VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR, - eDescriptorBufferCaptureReplayEXT = VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT, - eMotionNV = VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV - }; - - // wrapper using for bitmask VkAccelerationStructureCreateFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateFlagsKHR.html - using AccelerationStructureCreateFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkAccelerationStructureCreateFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR AccelerationStructureCreateFlagsKHR allFlags = - AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay | AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT | - AccelerationStructureCreateFlagBitsKHR::eMotionNV; - }; - - // wrapper class for enum VkBuildAccelerationStructureModeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildAccelerationStructureModeKHR.html - enum class BuildAccelerationStructureModeKHR - { - eBuild = VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR, - eUpdate = VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR - }; - - //=== VK_KHR_ray_tracing_pipeline === - - // wrapper class for enum VkRayTracingShaderGroupTypeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingShaderGroupTypeKHR.html - enum class RayTracingShaderGroupTypeKHR - { - eGeneral = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR, - eTrianglesHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR, - eProceduralHitGroup = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR - }; - - using RayTracingShaderGroupTypeNV = RayTracingShaderGroupTypeKHR; - - // wrapper class for enum VkShaderGroupShaderKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderGroupShaderKHR.html - enum class ShaderGroupShaderKHR - { - eGeneral = VK_SHADER_GROUP_SHADER_GENERAL_KHR, - eClosestHit = VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR, - eAnyHit = VK_SHADER_GROUP_SHADER_ANY_HIT_KHR, - eIntersection = VK_SHADER_GROUP_SHADER_INTERSECTION_KHR - }; - - //=== VK_NV_framebuffer_mixed_samples === - - // wrapper class for enum VkCoverageModulationModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoverageModulationModeNV.html - enum class CoverageModulationModeNV - { - eNone = VK_COVERAGE_MODULATION_MODE_NONE_NV, - eRgb = VK_COVERAGE_MODULATION_MODE_RGB_NV, - eAlpha = VK_COVERAGE_MODULATION_MODE_ALPHA_NV, - eRgba = VK_COVERAGE_MODULATION_MODE_RGBA_NV - }; - - enum class PipelineCoverageModulationStateCreateFlagBitsNV : VkPipelineCoverageModulationStateCreateFlagsNV - { - }; - - // wrapper using for bitmask VkPipelineCoverageModulationStateCreateFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageModulationStateCreateFlagsNV.html - using PipelineCoverageModulationStateCreateFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCoverageModulationStateCreateFlagsNV allFlags = {}; - }; - - //=== VK_EXT_validation_cache === - - // wrapper class for enum VkValidationCacheHeaderVersionEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheHeaderVersionEXT.html - enum class ValidationCacheHeaderVersionEXT - { - eOne = VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT - }; - - enum class ValidationCacheCreateFlagBitsEXT : VkValidationCacheCreateFlagsEXT - { - }; - - // wrapper using for bitmask VkValidationCacheCreateFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheCreateFlagsEXT.html - using ValidationCacheCreateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ValidationCacheCreateFlagsEXT allFlags = {}; - }; - - //=== VK_NV_shading_rate_image === - - // wrapper class for enum VkShadingRatePaletteEntryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShadingRatePaletteEntryNV.html - enum class ShadingRatePaletteEntryNV - { - eNoInvocations = VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV, - e16InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV, - e8InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV, - e4InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV, - e2InvocationsPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV, - e1InvocationPerPixel = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV, - e1InvocationPer2X1Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV, - e1InvocationPer1X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV, - e1InvocationPer2X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV, - e1InvocationPer4X2Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV, - e1InvocationPer2X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV, - e1InvocationPer4X4Pixels = VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV - }; - - // wrapper class for enum VkCoarseSampleOrderTypeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoarseSampleOrderTypeNV.html - enum class CoarseSampleOrderTypeNV - { - eDefault = VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV, - eCustom = VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, - ePixelMajor = VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV, - eSampleMajor = VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV - }; - - //=== VK_NV_ray_tracing === - - // wrapper class for enum VkAccelerationStructureMemoryRequirementsTypeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMemoryRequirementsTypeNV.html - enum class AccelerationStructureMemoryRequirementsTypeNV - { - eObject = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV, - eBuildScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV, - eUpdateScratch = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV - }; - - //=== VK_AMD_pipeline_compiler_control === - - enum class PipelineCompilerControlFlagBitsAMD : VkPipelineCompilerControlFlagsAMD - { - }; - - // wrapper using for bitmask VkPipelineCompilerControlFlagsAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCompilerControlFlagsAMD.html - using PipelineCompilerControlFlagsAMD = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCompilerControlFlagsAMD allFlags = {}; - }; - - //=== VK_AMD_memory_overallocation_behavior === - - // wrapper class for enum VkMemoryOverallocationBehaviorAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryOverallocationBehaviorAMD.html - enum class MemoryOverallocationBehaviorAMD - { - eDefault = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD, - eAllowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD, - eDisallowed = VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD - }; - - //=== VK_EXT_present_timing === - - // wrapper class for enum VkPresentStageFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentStageFlagBitsEXT.html - enum class PresentStageFlagBitsEXT : VkPresentStageFlagsEXT - { - eQueueOperationsEnd = VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT, - eRequestDequeued = VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT, - eImageFirstPixelOut = VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT, - eImageFirstPixelVisible = VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT - }; - - // wrapper using for bitmask VkPresentStageFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentStageFlagsEXT.html - using PresentStageFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPresentStageFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PresentStageFlagsEXT allFlags = - PresentStageFlagBitsEXT::eQueueOperationsEnd | PresentStageFlagBitsEXT::eRequestDequeued | PresentStageFlagBitsEXT::eImageFirstPixelOut | - PresentStageFlagBitsEXT::eImageFirstPixelVisible; - }; - - // wrapper class for enum VkPresentTimingInfoFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingInfoFlagBitsEXT.html - enum class PresentTimingInfoFlagBitsEXT : VkPresentTimingInfoFlagsEXT - { - ePresentAtRelativeTime = VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT, - ePresentAtNearestRefreshCycle = VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT - }; - - // wrapper using for bitmask VkPresentTimingInfoFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingInfoFlagsEXT.html - using PresentTimingInfoFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPresentTimingInfoFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PresentTimingInfoFlagsEXT allFlags = - PresentTimingInfoFlagBitsEXT::ePresentAtRelativeTime | PresentTimingInfoFlagBitsEXT::ePresentAtNearestRefreshCycle; - }; - - // wrapper class for enum VkPastPresentationTimingFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingFlagBitsEXT.html - enum class PastPresentationTimingFlagBitsEXT : VkPastPresentationTimingFlagsEXT - { - eAllowPartialResults = VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT, - eAllowOutOfOrderResults = VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT - }; - - // wrapper using for bitmask VkPastPresentationTimingFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingFlagsEXT.html - using PastPresentationTimingFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPastPresentationTimingFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PastPresentationTimingFlagsEXT allFlags = - PastPresentationTimingFlagBitsEXT::eAllowPartialResults | PastPresentationTimingFlagBitsEXT::eAllowOutOfOrderResults; - }; - - //=== VK_INTEL_performance_query === - - // wrapper class for enum VkPerformanceConfigurationTypeINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationTypeINTEL.html - enum class PerformanceConfigurationTypeINTEL - { - eCommandQueueMetricsDiscoveryActivated = VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL - }; - - // wrapper class for enum VkQueryPoolSamplingModeINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolSamplingModeINTEL.html - enum class QueryPoolSamplingModeINTEL - { - eManual = VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL - }; - - // wrapper class for enum VkPerformanceOverrideTypeINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceOverrideTypeINTEL.html - enum class PerformanceOverrideTypeINTEL - { - eNullHardware = VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL, - eFlushGpuCaches = VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL - }; - - // wrapper class for enum VkPerformanceParameterTypeINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceParameterTypeINTEL.html - enum class PerformanceParameterTypeINTEL - { - eHwCountersSupported = VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL, - eStreamMarkerValidBits = VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL - }; - - // wrapper class for enum VkPerformanceValueTypeINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceValueTypeINTEL.html - enum class PerformanceValueTypeINTEL - { - eUint32 = VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL, - eUint64 = VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL, - eFloat = VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL, - eBool = VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL, - eString = VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL - }; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - - enum class ImagePipeSurfaceCreateFlagBitsFUCHSIA : VkImagePipeSurfaceCreateFlagsFUCHSIA - { - }; - - // wrapper using for bitmask VkImagePipeSurfaceCreateFlagsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImagePipeSurfaceCreateFlagsFUCHSIA.html - using ImagePipeSurfaceCreateFlagsFUCHSIA = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ImagePipeSurfaceCreateFlagsFUCHSIA allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - - enum class MetalSurfaceCreateFlagBitsEXT : VkMetalSurfaceCreateFlagsEXT - { - }; - - // wrapper using for bitmask VkMetalSurfaceCreateFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMetalSurfaceCreateFlagsEXT.html - using MetalSurfaceCreateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MetalSurfaceCreateFlagsEXT allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_fragment_shading_rate === - - // wrapper class for enum VkFragmentShadingRateCombinerOpKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFragmentShadingRateCombinerOpKHR.html - enum class FragmentShadingRateCombinerOpKHR - { - eKeep = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR, - eReplace = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR, - eMin = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR, - eMax = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR, - eMul = VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR - }; - - //=== VK_AMD_shader_core_properties2 === - - enum class ShaderCorePropertiesFlagBitsAMD : VkShaderCorePropertiesFlagsAMD - { - }; - - // wrapper using for bitmask VkShaderCorePropertiesFlagsAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCorePropertiesFlagsAMD.html - using ShaderCorePropertiesFlagsAMD = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderCorePropertiesFlagsAMD allFlags = {}; - }; - - //=== VK_EXT_validation_features === - - // wrapper class for enum VkValidationFeatureEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationFeatureEnableEXT.html - enum class ValidationFeatureEnableEXT - { - eGpuAssisted = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT, - eGpuAssistedReserveBindingSlot = VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT, - eBestPractices = VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT, - eDebugPrintf = VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT, - eSynchronizationValidation = VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT - }; - - // wrapper class for enum VkValidationFeatureDisableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationFeatureDisableEXT.html - enum class ValidationFeatureDisableEXT - { - eAll = VK_VALIDATION_FEATURE_DISABLE_ALL_EXT, - eShaders = VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT, - eThreadSafety = VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT, - eApiParameters = VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT, - eObjectLifetimes = VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT, - eCoreChecks = VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT, - eUniqueHandles = VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT, - eShaderValidationCache = VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT - }; - - //=== VK_NV_coverage_reduction_mode === - - // wrapper class for enum VkCoverageReductionModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoverageReductionModeNV.html - enum class CoverageReductionModeNV - { - eMerge = VK_COVERAGE_REDUCTION_MODE_MERGE_NV, - eTruncate = VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV - }; - - enum class PipelineCoverageReductionStateCreateFlagBitsNV : VkPipelineCoverageReductionStateCreateFlagsNV - { - }; - - // wrapper using for bitmask VkPipelineCoverageReductionStateCreateFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageReductionStateCreateFlagsNV.html - using PipelineCoverageReductionStateCreateFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PipelineCoverageReductionStateCreateFlagsNV allFlags = {}; - }; - - //=== VK_EXT_provoking_vertex === - - // wrapper class for enum VkProvokingVertexModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkProvokingVertexModeEXT.html - enum class ProvokingVertexModeEXT - { - eFirstVertex = VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT, - eLastVertex = VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT - }; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - - // wrapper class for enum VkFullScreenExclusiveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFullScreenExclusiveEXT.html - enum class FullScreenExclusiveEXT - { - eDefault = VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT, - eAllowed = VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT, - eDisallowed = VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT, - eApplicationControlled = VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT - }; - -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - - enum class HeadlessSurfaceCreateFlagBitsEXT : VkHeadlessSurfaceCreateFlagsEXT - { - }; - - // wrapper using for bitmask VkHeadlessSurfaceCreateFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkHeadlessSurfaceCreateFlagsEXT.html - using HeadlessSurfaceCreateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR HeadlessSurfaceCreateFlagsEXT allFlags = {}; - }; - - //=== VK_KHR_pipeline_executable_properties === - - // wrapper class for enum VkPipelineExecutableStatisticFormatKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineExecutableStatisticFormatKHR.html - enum class PipelineExecutableStatisticFormatKHR - { - eBool32 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR, - eInt64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR, - eUint64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR, - eFloat64 = VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR - }; - - //=== VK_NV_device_generated_commands === - - // wrapper class for enum VkIndirectStateFlagBitsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectStateFlagBitsNV.html - enum class IndirectStateFlagBitsNV : VkIndirectStateFlagsNV - { - eFlagFrontface = VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV - }; - - // wrapper using for bitmask VkIndirectStateFlagsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectStateFlagsNV.html - using IndirectStateFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkIndirectStateFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectStateFlagsNV allFlags = IndirectStateFlagBitsNV::eFlagFrontface; - }; - - // wrapper class for enum VkIndirectCommandsTokenTypeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsTokenTypeNV.html - enum class IndirectCommandsTokenTypeNV - { - eShaderGroup = VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV, - eStateFlags = VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV, - eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV, - eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV, - ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV, - eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV, - eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV, - eDrawTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV, - ePushData = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV, - eDrawMeshTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV, - ePipeline = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV, - eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV - }; - - // wrapper class for enum VkIndirectCommandsLayoutUsageFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagBitsNV.html - enum class IndirectCommandsLayoutUsageFlagBitsNV : VkIndirectCommandsLayoutUsageFlagsNV - { - eExplicitPreprocess = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV, - eIndexedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV, - eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV - }; - - // wrapper using for bitmask VkIndirectCommandsLayoutUsageFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagsNV.html - using IndirectCommandsLayoutUsageFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkIndirectCommandsLayoutUsageFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectCommandsLayoutUsageFlagsNV allFlags = IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess | - IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences | - IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences; - }; - - //=== VK_EXT_depth_bias_control === - - // wrapper class for enum VkDepthBiasRepresentationEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthBiasRepresentationEXT.html - enum class DepthBiasRepresentationEXT - { - eLeastRepresentableValueFormat = VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT, - eLeastRepresentableValueForceUnorm = VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT, - eFloat = VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT - }; - - //=== VK_EXT_device_memory_report === - - // wrapper class for enum VkDeviceMemoryReportEventTypeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryReportEventTypeEXT.html - enum class DeviceMemoryReportEventTypeEXT - { - eAllocate = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT, - eFree = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT, - eImport = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT, - eUnimport = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT, - eAllocationFailed = VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT - }; - - enum class DeviceMemoryReportFlagBitsEXT : VkDeviceMemoryReportFlagsEXT - { - }; - - // wrapper using for bitmask VkDeviceMemoryReportFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryReportFlagsEXT.html - using DeviceMemoryReportFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceMemoryReportFlagsEXT allFlags = {}; - }; - - //=== VK_KHR_video_encode_queue === - - // wrapper class for enum VkVideoEncodeCapabilityFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeCapabilityFlagBitsKHR.html - enum class VideoEncodeCapabilityFlagBitsKHR : VkVideoEncodeCapabilityFlagsKHR - { - ePrecedingExternallyEncodedBytes = VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR, - eInsufficientBitstreamBufferRangeDetection = VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR, - eQuantizationDeltaMap = VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR, - eEmphasisMap = VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeCapabilityFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeCapabilityFlagsKHR.html - using VideoEncodeCapabilityFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeCapabilityFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeCapabilityFlagsKHR allFlags = - VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes | VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection | - VideoEncodeCapabilityFlagBitsKHR::eQuantizationDeltaMap | VideoEncodeCapabilityFlagBitsKHR::eEmphasisMap; - }; - - // wrapper class for enum VkVideoEncodeFeedbackFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFeedbackFlagBitsKHR.html - enum class VideoEncodeFeedbackFlagBitsKHR : VkVideoEncodeFeedbackFlagsKHR - { - eBitstreamBufferOffset = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR, - eBitstreamBytesWritten = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR, - eBitstreamHasOverrides = VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeFeedbackFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFeedbackFlagsKHR.html - using VideoEncodeFeedbackFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeFeedbackFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeFeedbackFlagsKHR allFlags = VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset | - VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten | - VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides; - }; - - // wrapper class for enum VkVideoEncodeUsageFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeUsageFlagBitsKHR.html - enum class VideoEncodeUsageFlagBitsKHR : VkVideoEncodeUsageFlagsKHR - { - eDefault = VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR, - eTranscoding = VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR, - eStreaming = VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR, - eRecording = VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR, - eConferencing = VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeUsageFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeUsageFlagsKHR.html - using VideoEncodeUsageFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeUsageFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeUsageFlagsKHR allFlags = VideoEncodeUsageFlagBitsKHR::eDefault | VideoEncodeUsageFlagBitsKHR::eTranscoding | - VideoEncodeUsageFlagBitsKHR::eStreaming | VideoEncodeUsageFlagBitsKHR::eRecording | - VideoEncodeUsageFlagBitsKHR::eConferencing; - }; - - // wrapper class for enum VkVideoEncodeContentFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeContentFlagBitsKHR.html - enum class VideoEncodeContentFlagBitsKHR : VkVideoEncodeContentFlagsKHR - { - eDefault = VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR, - eCamera = VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR, - eDesktop = VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR, - eRendered = VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeContentFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeContentFlagsKHR.html - using VideoEncodeContentFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeContentFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeContentFlagsKHR allFlags = - VideoEncodeContentFlagBitsKHR::eDefault | VideoEncodeContentFlagBitsKHR::eCamera | VideoEncodeContentFlagBitsKHR::eDesktop | - VideoEncodeContentFlagBitsKHR::eRendered; - }; - - // wrapper class for enum VkVideoEncodeTuningModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeTuningModeKHR.html - enum class VideoEncodeTuningModeKHR - { - eDefault = VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR, - eHighQuality = VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR, - eLowLatency = VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR, - eUltraLowLatency = VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR, - eLossless = VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR - }; - - // wrapper class for enum VkVideoEncodeRateControlModeFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlModeFlagBitsKHR.html - enum class VideoEncodeRateControlModeFlagBitsKHR : VkVideoEncodeRateControlModeFlagsKHR - { - eDefault = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR, - eDisabled = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR, - eCbr = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR, - eVbr = VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeRateControlModeFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlModeFlagsKHR.html - using VideoEncodeRateControlModeFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeRateControlModeFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRateControlModeFlagsKHR allFlags = - VideoEncodeRateControlModeFlagBitsKHR::eDefault | VideoEncodeRateControlModeFlagBitsKHR::eDisabled | VideoEncodeRateControlModeFlagBitsKHR::eCbr | - VideoEncodeRateControlModeFlagBitsKHR::eVbr; - }; - - // wrapper class for enum VkVideoEncodeFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFlagBitsKHR.html - enum class VideoEncodeFlagBitsKHR : VkVideoEncodeFlagsKHR - { - eIntraRefresh = VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR, - eWithQuantizationDeltaMap = VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR, - eWithEmphasisMap = VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeFlagsKHR.html - using VideoEncodeFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeFlagsKHR allFlags = - VideoEncodeFlagBitsKHR::eIntraRefresh | VideoEncodeFlagBitsKHR::eWithQuantizationDeltaMap | VideoEncodeFlagBitsKHR::eWithEmphasisMap; - }; - - enum class VideoEncodeRateControlFlagBitsKHR : VkVideoEncodeRateControlFlagsKHR - { - }; - - // wrapper using for bitmask VkVideoEncodeRateControlFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlFlagsKHR.html - using VideoEncodeRateControlFlagsKHR = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRateControlFlagsKHR allFlags = {}; - }; - - //=== VK_NV_device_diagnostics_config === - - // wrapper class for enum VkDeviceDiagnosticsConfigFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceDiagnosticsConfigFlagBitsNV.html - enum class DeviceDiagnosticsConfigFlagBitsNV : VkDeviceDiagnosticsConfigFlagsNV - { - eEnableShaderDebugInfo = VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV, - eEnableResourceTracking = VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV, - eEnableAutomaticCheckpoints = VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV, - eEnableShaderErrorReporting = VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV - }; - - // wrapper using for bitmask VkDeviceDiagnosticsConfigFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceDiagnosticsConfigFlagsNV.html - using DeviceDiagnosticsConfigFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDeviceDiagnosticsConfigFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceDiagnosticsConfigFlagsNV allFlags = - DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo | DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking | - DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints | DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting; - }; - - //=== VK_QCOM_tile_shading === - - // wrapper class for enum VkTileShadingRenderPassFlagBitsQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileShadingRenderPassFlagBitsQCOM.html - enum class TileShadingRenderPassFlagBitsQCOM : VkTileShadingRenderPassFlagsQCOM - { - eEnable = VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM, - ePerTileExecution = VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM - }; - - // wrapper using for bitmask VkTileShadingRenderPassFlagsQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileShadingRenderPassFlagsQCOM.html - using TileShadingRenderPassFlagsQCOM = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkTileShadingRenderPassFlagBitsQCOM; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR TileShadingRenderPassFlagsQCOM allFlags = - TileShadingRenderPassFlagBitsQCOM::eEnable | TileShadingRenderPassFlagBitsQCOM::ePerTileExecution; - }; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - - // wrapper class for enum VkExportMetalObjectTypeFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalObjectTypeFlagBitsEXT.html - enum class ExportMetalObjectTypeFlagBitsEXT : VkExportMetalObjectTypeFlagsEXT - { - eMetalDevice = VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT, - eMetalCommandQueue = VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT, - eMetalBuffer = VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT, - eMetalTexture = VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT, - eMetalIosurface = VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT, - eMetalSharedEvent = VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT - }; - - // wrapper using for bitmask VkExportMetalObjectTypeFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalObjectTypeFlagsEXT.html - using ExportMetalObjectTypeFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkExportMetalObjectTypeFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ExportMetalObjectTypeFlagsEXT allFlags = - ExportMetalObjectTypeFlagBitsEXT::eMetalDevice | ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue | ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer | - ExportMetalObjectTypeFlagBitsEXT::eMetalTexture | ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface | ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_graphics_pipeline_library === - - // wrapper class for enum VkGraphicsPipelineLibraryFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineLibraryFlagBitsEXT.html - enum class GraphicsPipelineLibraryFlagBitsEXT : VkGraphicsPipelineLibraryFlagsEXT - { - eVertexInputInterface = VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT, - ePreRasterizationShaders = VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT, - eFragmentShader = VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT, - eFragmentOutputInterface = VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT - }; - - // wrapper using for bitmask VkGraphicsPipelineLibraryFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineLibraryFlagsEXT.html - using GraphicsPipelineLibraryFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkGraphicsPipelineLibraryFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR GraphicsPipelineLibraryFlagsEXT allFlags = - GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface | GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders | - GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader | GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface; - }; - - //=== VK_NV_fragment_shading_rate_enums === - - // wrapper class for enum VkFragmentShadingRateNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFragmentShadingRateNV.html - enum class FragmentShadingRateNV - { - e1InvocationPerPixel = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV, - e1InvocationPer1X2Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV, - e1InvocationPer2X1Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV, - e1InvocationPer2X2Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV, - e1InvocationPer2X4Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV, - e1InvocationPer4X2Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV, - e1InvocationPer4X4Pixels = VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV, - e2InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV, - e4InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV, - e8InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV, - e16InvocationsPerPixel = VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV, - eNoInvocations = VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV - }; - - // wrapper class for enum VkFragmentShadingRateTypeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFragmentShadingRateTypeNV.html - enum class FragmentShadingRateTypeNV - { - eFragmentSize = VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV, - eEnums = VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV - }; - - //=== VK_NV_ray_tracing_motion_blur === - - // wrapper class for enum VkAccelerationStructureMotionInstanceTypeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceTypeNV.html - enum class AccelerationStructureMotionInstanceTypeNV - { - eStatic = VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV, - eMatrixMotion = VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV, - eSrtMotion = VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV - }; - - enum class AccelerationStructureMotionInfoFlagBitsNV : VkAccelerationStructureMotionInfoFlagsNV - { - }; - - // wrapper using for bitmask VkAccelerationStructureMotionInfoFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInfoFlagsNV.html - using AccelerationStructureMotionInfoFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR AccelerationStructureMotionInfoFlagsNV allFlags = {}; - }; - - enum class AccelerationStructureMotionInstanceFlagBitsNV : VkAccelerationStructureMotionInstanceFlagsNV - { - }; - - // wrapper using for bitmask VkAccelerationStructureMotionInstanceFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceFlagsNV.html - using AccelerationStructureMotionInstanceFlagsNV = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR AccelerationStructureMotionInstanceFlagsNV allFlags = {}; - }; - - //=== VK_EXT_image_compression_control === - - // wrapper class for enum VkImageCompressionFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFlagBitsEXT.html - enum class ImageCompressionFlagBitsEXT : VkImageCompressionFlagsEXT - { - eDefault = VK_IMAGE_COMPRESSION_DEFAULT_EXT, - eFixedRateDefault = VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT, - eFixedRateExplicit = VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT, - eDisabled = VK_IMAGE_COMPRESSION_DISABLED_EXT - }; - - // wrapper using for bitmask VkImageCompressionFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFlagsEXT.html - using ImageCompressionFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkImageCompressionFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCompressionFlagsEXT allFlags = - ImageCompressionFlagBitsEXT::eDefault | ImageCompressionFlagBitsEXT::eFixedRateDefault | ImageCompressionFlagBitsEXT::eFixedRateExplicit | - ImageCompressionFlagBitsEXT::eDisabled; - }; - - // wrapper class for enum VkImageCompressionFixedRateFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFixedRateFlagBitsEXT.html - enum class ImageCompressionFixedRateFlagBitsEXT : VkImageCompressionFixedRateFlagsEXT - { - eNone = VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT, - e1Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT, - e2Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT, - e3Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT, - e4Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT, - e5Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT, - e6Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT, - e7Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT, - e8Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT, - e9Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT, - e10Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT, - e11Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT, - e12Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT, - e13Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT, - e14Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT, - e15Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT, - e16Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT, - e17Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT, - e18Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT, - e19Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT, - e20Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT, - e21Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT, - e22Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT, - e23Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT, - e24Bpc = VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT - }; - - // wrapper using for bitmask VkImageCompressionFixedRateFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionFixedRateFlagsEXT.html - using ImageCompressionFixedRateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkImageCompressionFixedRateFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ImageCompressionFixedRateFlagsEXT allFlags = - ImageCompressionFixedRateFlagBitsEXT::eNone | ImageCompressionFixedRateFlagBitsEXT::e1Bpc | ImageCompressionFixedRateFlagBitsEXT::e2Bpc | - ImageCompressionFixedRateFlagBitsEXT::e3Bpc | ImageCompressionFixedRateFlagBitsEXT::e4Bpc | ImageCompressionFixedRateFlagBitsEXT::e5Bpc | - ImageCompressionFixedRateFlagBitsEXT::e6Bpc | ImageCompressionFixedRateFlagBitsEXT::e7Bpc | ImageCompressionFixedRateFlagBitsEXT::e8Bpc | - ImageCompressionFixedRateFlagBitsEXT::e9Bpc | ImageCompressionFixedRateFlagBitsEXT::e10Bpc | ImageCompressionFixedRateFlagBitsEXT::e11Bpc | - ImageCompressionFixedRateFlagBitsEXT::e12Bpc | ImageCompressionFixedRateFlagBitsEXT::e13Bpc | ImageCompressionFixedRateFlagBitsEXT::e14Bpc | - ImageCompressionFixedRateFlagBitsEXT::e15Bpc | ImageCompressionFixedRateFlagBitsEXT::e16Bpc | ImageCompressionFixedRateFlagBitsEXT::e17Bpc | - ImageCompressionFixedRateFlagBitsEXT::e18Bpc | ImageCompressionFixedRateFlagBitsEXT::e19Bpc | ImageCompressionFixedRateFlagBitsEXT::e20Bpc | - ImageCompressionFixedRateFlagBitsEXT::e21Bpc | ImageCompressionFixedRateFlagBitsEXT::e22Bpc | ImageCompressionFixedRateFlagBitsEXT::e23Bpc | - ImageCompressionFixedRateFlagBitsEXT::e24Bpc; - }; - - //=== VK_EXT_device_fault === - - // wrapper class for enum VkDeviceFaultAddressTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultAddressTypeEXT.html - enum class DeviceFaultAddressTypeEXT - { - eNone = VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT, - eReadInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT, - eWriteInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT, - eExecuteInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT, - eInstructionPointerUnknown = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT, - eInstructionPointerInvalid = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT, - eInstructionPointerFault = VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT - }; - - // wrapper class for enum VkDeviceFaultVendorBinaryHeaderVersionEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorBinaryHeaderVersionEXT.html - enum class DeviceFaultVendorBinaryHeaderVersionEXT - { - eOne = VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT - }; - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - - enum class DirectFBSurfaceCreateFlagBitsEXT : VkDirectFBSurfaceCreateFlagsEXT - { - }; - - // wrapper using for bitmask VkDirectFBSurfaceCreateFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectFBSurfaceCreateFlagsEXT.html - using DirectFBSurfaceCreateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DirectFBSurfaceCreateFlagsEXT allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_device_address_binding_report === - - // wrapper class for enum VkDeviceAddressBindingFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingFlagBitsEXT.html - enum class DeviceAddressBindingFlagBitsEXT : VkDeviceAddressBindingFlagsEXT - { - eInternalObject = VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT - }; - - // wrapper using for bitmask VkDeviceAddressBindingFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingFlagsEXT.html - using DeviceAddressBindingFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDeviceAddressBindingFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DeviceAddressBindingFlagsEXT allFlags = DeviceAddressBindingFlagBitsEXT::eInternalObject; - }; - - // wrapper class for enum VkDeviceAddressBindingTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingTypeEXT.html - enum class DeviceAddressBindingTypeEXT - { - eBind = VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT, - eUnbind = VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT - }; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - - // wrapper class for enum VkImageConstraintsInfoFlagBitsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageConstraintsInfoFlagBitsFUCHSIA.html - enum class ImageConstraintsInfoFlagBitsFUCHSIA : VkImageConstraintsInfoFlagsFUCHSIA - { - eCpuReadRarely = VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA, - eCpuReadOften = VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA, - eCpuWriteRarely = VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA, - eCpuWriteOften = VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA, - eProtectedOptional = VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA - }; - - // wrapper using for bitmask VkImageConstraintsInfoFlagsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageConstraintsInfoFlagsFUCHSIA.html - using ImageConstraintsInfoFlagsFUCHSIA = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkImageConstraintsInfoFlagBitsFUCHSIA; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ImageConstraintsInfoFlagsFUCHSIA allFlags = - ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely | ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften | - ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely | ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften | - ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional; - }; - - enum class ImageFormatConstraintsFlagBitsFUCHSIA : VkImageFormatConstraintsFlagsFUCHSIA - { - }; - - // wrapper using for bitmask VkImageFormatConstraintsFlagsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatConstraintsFlagsFUCHSIA.html - using ImageFormatConstraintsFlagsFUCHSIA = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ImageFormatConstraintsFlagsFUCHSIA allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_EXT_frame_boundary === - - // wrapper class for enum VkFrameBoundaryFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrameBoundaryFlagBitsEXT.html - enum class FrameBoundaryFlagBitsEXT : VkFrameBoundaryFlagsEXT - { - eFrameEnd = VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT - }; - - // wrapper using for bitmask VkFrameBoundaryFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrameBoundaryFlagsEXT.html - using FrameBoundaryFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkFrameBoundaryFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR FrameBoundaryFlagsEXT allFlags = FrameBoundaryFlagBitsEXT::eFrameEnd; - }; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - - enum class ScreenSurfaceCreateFlagBitsQNX : VkScreenSurfaceCreateFlagsQNX - { - }; - - // wrapper using for bitmask VkScreenSurfaceCreateFlagsQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkScreenSurfaceCreateFlagsQNX.html - using ScreenSurfaceCreateFlagsQNX = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ScreenSurfaceCreateFlagsQNX allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_VALVE_video_encode_rgb_conversion === - - // wrapper class for enum VkVideoEncodeRgbModelConversionFlagBitsVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbModelConversionFlagBitsVALVE.html - enum class VideoEncodeRgbModelConversionFlagBitsVALVE : VkVideoEncodeRgbModelConversionFlagsVALVE - { - eRgbIdentity = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE, - eYcbcrIdentity = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE, - eYcbcr709 = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE, - eYcbcr601 = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE, - eYcbcr2020 = VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE - }; - - // wrapper using for bitmask VkVideoEncodeRgbModelConversionFlagsVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbModelConversionFlagsVALVE.html - using VideoEncodeRgbModelConversionFlagsVALVE = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeRgbModelConversionFlagBitsVALVE; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRgbModelConversionFlagsVALVE allFlags = - VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity | VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcrIdentity | - VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr709 | VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr601 | - VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr2020; - }; - - // wrapper class for enum VkVideoEncodeRgbRangeCompressionFlagBitsVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbRangeCompressionFlagBitsVALVE.html - enum class VideoEncodeRgbRangeCompressionFlagBitsVALVE : VkVideoEncodeRgbRangeCompressionFlagsVALVE - { - eFullRange = VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE, - eNarrowRange = VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE - }; - - // wrapper using for bitmask VkVideoEncodeRgbRangeCompressionFlagsVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbRangeCompressionFlagsVALVE.html - using VideoEncodeRgbRangeCompressionFlagsVALVE = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeRgbRangeCompressionFlagBitsVALVE; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRgbRangeCompressionFlagsVALVE allFlags = - VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange | VideoEncodeRgbRangeCompressionFlagBitsVALVE::eNarrowRange; - }; - - // wrapper class for enum VkVideoEncodeRgbChromaOffsetFlagBitsVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbChromaOffsetFlagBitsVALVE.html - enum class VideoEncodeRgbChromaOffsetFlagBitsVALVE : VkVideoEncodeRgbChromaOffsetFlagsVALVE - { - eCositedEven = VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE, - eMidpoint = VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE - }; - - // wrapper using for bitmask VkVideoEncodeRgbChromaOffsetFlagsVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbChromaOffsetFlagsVALVE.html - using VideoEncodeRgbChromaOffsetFlagsVALVE = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeRgbChromaOffsetFlagBitsVALVE; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeRgbChromaOffsetFlagsVALVE allFlags = - VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven | VideoEncodeRgbChromaOffsetFlagBitsVALVE::eMidpoint; - }; - - //=== VK_EXT_opacity_micromap === - - // wrapper class for enum VkMicromapTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapTypeEXT.html - enum class MicromapTypeEXT - { - eOpacityMicromap = VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - eDisplacementMicromapNV = VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - }; - - // wrapper class for enum VkBuildMicromapFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildMicromapFlagBitsEXT.html - enum class BuildMicromapFlagBitsEXT : VkBuildMicromapFlagsEXT - { - ePreferFastTrace = VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT, - ePreferFastBuild = VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT, - eAllowCompaction = VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT - }; - - // wrapper using for bitmask VkBuildMicromapFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildMicromapFlagsEXT.html - using BuildMicromapFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkBuildMicromapFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR BuildMicromapFlagsEXT allFlags = - BuildMicromapFlagBitsEXT::ePreferFastTrace | BuildMicromapFlagBitsEXT::ePreferFastBuild | BuildMicromapFlagBitsEXT::eAllowCompaction; - }; - - // wrapper class for enum VkCopyMicromapModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMicromapModeEXT.html - enum class CopyMicromapModeEXT - { - eClone = VK_COPY_MICROMAP_MODE_CLONE_EXT, - eSerialize = VK_COPY_MICROMAP_MODE_SERIALIZE_EXT, - eDeserialize = VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT, - eCompact = VK_COPY_MICROMAP_MODE_COMPACT_EXT - }; - - // wrapper class for enum VkMicromapCreateFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapCreateFlagBitsEXT.html - enum class MicromapCreateFlagBitsEXT : VkMicromapCreateFlagsEXT - { - eDeviceAddressCaptureReplay = VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT - }; - - // wrapper using for bitmask VkMicromapCreateFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapCreateFlagsEXT.html - using MicromapCreateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkMicromapCreateFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MicromapCreateFlagsEXT allFlags = MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay; - }; - - // wrapper class for enum VkBuildMicromapModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildMicromapModeEXT.html - enum class BuildMicromapModeEXT - { - eBuild = VK_BUILD_MICROMAP_MODE_BUILD_EXT - }; - - // wrapper class for enum VkOpacityMicromapFormatEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpacityMicromapFormatEXT.html - enum class OpacityMicromapFormatEXT - { - e2State = VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT, - e4State = VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT - }; - - // wrapper class for enum VkOpacityMicromapSpecialIndexEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpacityMicromapSpecialIndexEXT.html - enum class OpacityMicromapSpecialIndexEXT - { - eFullyTransparent = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT, - eFullyOpaque = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT, - eFullyUnknownTransparent = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT, - eFullyUnknownOpaque = VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT, - eClusterGeometryDisableOpacityMicromapNV = VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_displacement_micromap === - - // wrapper class for enum VkDisplacementMicromapFormatNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplacementMicromapFormatNV.html - enum class DisplacementMicromapFormatNV - { - e64Triangles64Bytes = VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV, - e256Triangles128Bytes = VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV, - e1024Triangles128Bytes = VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV - }; - -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_ARM_scheduling_controls === - - // wrapper class for enum VkPhysicalDeviceSchedulingControlsFlagBitsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsFlagBitsARM.html - enum class PhysicalDeviceSchedulingControlsFlagBitsARM : VkPhysicalDeviceSchedulingControlsFlagsARM - { - eShaderCoreCount = VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM - }; - - // wrapper using for bitmask VkPhysicalDeviceSchedulingControlsFlagsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsFlagsARM.html - using PhysicalDeviceSchedulingControlsFlagsARM = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPhysicalDeviceSchedulingControlsFlagBitsARM; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PhysicalDeviceSchedulingControlsFlagsARM allFlags = PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount; - }; - - //=== VK_NV_ray_tracing_linear_swept_spheres === - - // wrapper class for enum VkRayTracingLssIndexingModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingLssIndexingModeNV.html - enum class RayTracingLssIndexingModeNV - { - eList = VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV, - eSuccessive = VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV - }; - - // wrapper class for enum VkRayTracingLssPrimitiveEndCapsModeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingLssPrimitiveEndCapsModeNV.html - enum class RayTracingLssPrimitiveEndCapsModeNV - { - eNone = VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV, - eChained = VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV - }; - - //=== VK_EXT_subpass_merge_feedback === - - // wrapper class for enum VkSubpassMergeStatusEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassMergeStatusEXT.html - enum class SubpassMergeStatusEXT - { - eMerged = VK_SUBPASS_MERGE_STATUS_MERGED_EXT, - eDisallowed = VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT, - eNotMergedSideEffects = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT, - eNotMergedSamplesMismatch = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT, - eNotMergedViewsMismatch = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT, - eNotMergedAliasing = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT, - eNotMergedDependencies = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT, - eNotMergedIncompatibleInputAttachment = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT, - eNotMergedTooManyAttachments = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT, - eNotMergedInsufficientStorage = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT, - eNotMergedDepthStencilCount = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT, - eNotMergedResolveAttachmentReuse = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT, - eNotMergedSingleSubpass = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT, - eNotMergedUnspecified = VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT - }; - - //=== VK_LUNARG_direct_driver_loading === - - // wrapper class for enum VkDirectDriverLoadingModeLUNARG, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectDriverLoadingModeLUNARG.html - enum class DirectDriverLoadingModeLUNARG - { - eExclusive = VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG, - eInclusive = VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG - }; - - enum class DirectDriverLoadingFlagBitsLUNARG : VkDirectDriverLoadingFlagsLUNARG - { - }; - - // wrapper using for bitmask VkDirectDriverLoadingFlagsLUNARG, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectDriverLoadingFlagsLUNARG.html - using DirectDriverLoadingFlagsLUNARG = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DirectDriverLoadingFlagsLUNARG allFlags = {}; - }; - - //=== VK_ARM_tensors === - - // wrapper class for enum VkTensorCreateFlagBitsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCreateFlagBitsARM.html - enum class TensorCreateFlagBitsARM : VkTensorCreateFlagsARM - { - eMutableFormat = VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM, - eProtected = VK_TENSOR_CREATE_PROTECTED_BIT_ARM, - eDescriptorHeapCaptureReplay = VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM, - eDescriptorBufferCaptureReplay = VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM - }; - - // wrapper using for bitmask VkTensorCreateFlagsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCreateFlagsARM.html - using TensorCreateFlagsARM = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkTensorCreateFlagBitsARM; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR TensorCreateFlagsARM allFlags = TensorCreateFlagBitsARM::eMutableFormat | TensorCreateFlagBitsARM::eProtected | - TensorCreateFlagBitsARM::eDescriptorHeapCaptureReplay | - TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay; - }; - - // wrapper class for enum VkTensorUsageFlagBitsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorUsageFlagBitsARM.html - enum class TensorUsageFlagBitsARM : VkTensorUsageFlagsARM - { - eShader = VK_TENSOR_USAGE_SHADER_BIT_ARM, - eTransferSrc = VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM, - eTransferDst = VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM, - eImageAliasing = VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM, - eDataGraph = VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM - }; - - // wrapper using for bitmask VkTensorUsageFlagsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorUsageFlagsARM.html - using TensorUsageFlagsARM = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkTensorUsageFlagBitsARM; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR TensorUsageFlagsARM allFlags = TensorUsageFlagBitsARM::eShader | TensorUsageFlagBitsARM::eTransferSrc | - TensorUsageFlagBitsARM::eTransferDst | TensorUsageFlagBitsARM::eImageAliasing | - TensorUsageFlagBitsARM::eDataGraph; - }; - - // wrapper class for enum VkTensorTilingARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorTilingARM.html - enum class TensorTilingARM - { - eOptimal = VK_TENSOR_TILING_OPTIMAL_ARM, - eLinear = VK_TENSOR_TILING_LINEAR_ARM - }; - - //=== VK_NV_optical_flow === - - // wrapper class for enum VkOpticalFlowUsageFlagBitsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowUsageFlagBitsNV.html - enum class OpticalFlowUsageFlagBitsNV : VkOpticalFlowUsageFlagsNV - { - eUnknown = VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV, - eInput = VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV, - eOutput = VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV, - eHint = VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV, - eCost = VK_OPTICAL_FLOW_USAGE_COST_BIT_NV, - eGlobalFlow = VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV - }; - - // wrapper using for bitmask VkOpticalFlowUsageFlagsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowUsageFlagsNV.html - using OpticalFlowUsageFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkOpticalFlowUsageFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowUsageFlagsNV allFlags = OpticalFlowUsageFlagBitsNV::eUnknown | OpticalFlowUsageFlagBitsNV::eInput | - OpticalFlowUsageFlagBitsNV::eOutput | OpticalFlowUsageFlagBitsNV::eHint | - OpticalFlowUsageFlagBitsNV::eCost | OpticalFlowUsageFlagBitsNV::eGlobalFlow; - }; - - // wrapper class for enum VkOpticalFlowGridSizeFlagBitsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowGridSizeFlagBitsNV.html - enum class OpticalFlowGridSizeFlagBitsNV : VkOpticalFlowGridSizeFlagsNV - { - eUnknown = VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV, - e1X1 = VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV, - e2X2 = VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV, - e4X4 = VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV, - e8X8 = VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV - }; - - // wrapper using for bitmask VkOpticalFlowGridSizeFlagsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowGridSizeFlagsNV.html - using OpticalFlowGridSizeFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkOpticalFlowGridSizeFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowGridSizeFlagsNV allFlags = OpticalFlowGridSizeFlagBitsNV::eUnknown | OpticalFlowGridSizeFlagBitsNV::e1X1 | - OpticalFlowGridSizeFlagBitsNV::e2X2 | OpticalFlowGridSizeFlagBitsNV::e4X4 | - OpticalFlowGridSizeFlagBitsNV::e8X8; - }; - - // wrapper class for enum VkOpticalFlowPerformanceLevelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowPerformanceLevelNV.html - enum class OpticalFlowPerformanceLevelNV - { - eUnknown = VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV, - eSlow = VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV, - eMedium = VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV, - eFast = VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV - }; - - // wrapper class for enum VkOpticalFlowSessionBindingPointNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionBindingPointNV.html - enum class OpticalFlowSessionBindingPointNV - { - eUnknown = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV, - eInput = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV, - eReference = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV, - eHint = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV, - eFlowVector = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV, - eBackwardFlowVector = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV, - eCost = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV, - eBackwardCost = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV, - eGlobalFlow = VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV - }; - - // wrapper class for enum VkOpticalFlowSessionCreateFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreateFlagBitsNV.html - enum class OpticalFlowSessionCreateFlagBitsNV : VkOpticalFlowSessionCreateFlagsNV - { - eEnableHint = VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV, - eEnableCost = VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV, - eEnableGlobalFlow = VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV, - eAllowRegions = VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV, - eBothDirections = VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV - }; - - // wrapper using for bitmask VkOpticalFlowSessionCreateFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreateFlagsNV.html - using OpticalFlowSessionCreateFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkOpticalFlowSessionCreateFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowSessionCreateFlagsNV allFlags = - OpticalFlowSessionCreateFlagBitsNV::eEnableHint | OpticalFlowSessionCreateFlagBitsNV::eEnableCost | - OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow | OpticalFlowSessionCreateFlagBitsNV::eAllowRegions | - OpticalFlowSessionCreateFlagBitsNV::eBothDirections; - }; - - // wrapper class for enum VkOpticalFlowExecuteFlagBitsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowExecuteFlagBitsNV.html - enum class OpticalFlowExecuteFlagBitsNV : VkOpticalFlowExecuteFlagsNV - { - eDisableTemporalHints = VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV - }; - - // wrapper using for bitmask VkOpticalFlowExecuteFlagsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowExecuteFlagsNV.html - using OpticalFlowExecuteFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkOpticalFlowExecuteFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowExecuteFlagsNV allFlags = OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints; - }; - - //=== VK_AMD_anti_lag === - - // wrapper class for enum VkAntiLagModeAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagModeAMD.html - enum class AntiLagModeAMD - { - eDriverControl = VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD, - eOn = VK_ANTI_LAG_MODE_ON_AMD, - eOff = VK_ANTI_LAG_MODE_OFF_AMD - }; - - // wrapper class for enum VkAntiLagStageAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagStageAMD.html - enum class AntiLagStageAMD - { - eInput = VK_ANTI_LAG_STAGE_INPUT_AMD, - ePresent = VK_ANTI_LAG_STAGE_PRESENT_AMD - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_dense_geometry_format === - - // wrapper class for enum VkCompressedTriangleFormatAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCompressedTriangleFormatAMDX.html - enum class CompressedTriangleFormatAMDX - { - eDgf1 = VK_COMPRESSED_TRIANGLE_FORMAT_DGF1_AMDX - }; - -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_shader_object === - - // wrapper class for enum VkShaderCreateFlagBitsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCreateFlagBitsEXT.html - enum class ShaderCreateFlagBitsEXT : VkShaderCreateFlagsEXT - { - eLinkStage = VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, - eDescriptorHeap = VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT, - eAllowVaryingSubgroupSize = VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, - eRequireFullSubgroups = VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT, - eNoTaskShader = VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT, - eDispatchBase = VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT, - eFragmentShadingRateAttachment = VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT, - eFragmentDensityMapAttachment = VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, - eIndirectBindable = VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT, - e64BitIndexing = VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT - }; - - // wrapper using for bitmask VkShaderCreateFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCreateFlagsEXT.html - using ShaderCreateFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkShaderCreateFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderCreateFlagsEXT allFlags = - ShaderCreateFlagBitsEXT::eLinkStage | ShaderCreateFlagBitsEXT::eDescriptorHeap | ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize | - ShaderCreateFlagBitsEXT::eRequireFullSubgroups | ShaderCreateFlagBitsEXT::eNoTaskShader | ShaderCreateFlagBitsEXT::eDispatchBase | - ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment | ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment | - ShaderCreateFlagBitsEXT::eIndirectBindable | ShaderCreateFlagBitsEXT::e64BitIndexing; - }; - - // wrapper class for enum VkShaderCodeTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCodeTypeEXT.html - enum class ShaderCodeTypeEXT - { - eBinary = VK_SHADER_CODE_TYPE_BINARY_EXT, - eSpirv = VK_SHADER_CODE_TYPE_SPIRV_EXT - }; - - //=== VK_KHR_surface_maintenance1 === - - // wrapper class for enum VkPresentScalingFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentScalingFlagBitsKHR.html - enum class PresentScalingFlagBitsKHR : VkPresentScalingFlagsKHR - { - eOneToOne = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR, - eAspectRatioStretch = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR, - eStretch = VK_PRESENT_SCALING_STRETCH_BIT_KHR - }; - - using PresentScalingFlagBitsEXT = PresentScalingFlagBitsKHR; - - // wrapper using for bitmask VkPresentScalingFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentScalingFlagsKHR.html - using PresentScalingFlagsKHR = Flags; - using PresentScalingFlagsEXT = PresentScalingFlagsKHR; - - template <> - struct FlagTraits - { - using WrappedType = VkPresentScalingFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PresentScalingFlagsKHR allFlags = - PresentScalingFlagBitsKHR::eOneToOne | PresentScalingFlagBitsKHR::eAspectRatioStretch | PresentScalingFlagBitsKHR::eStretch; - }; - - // wrapper class for enum VkPresentGravityFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentGravityFlagBitsKHR.html - enum class PresentGravityFlagBitsKHR : VkPresentGravityFlagsKHR - { - eMin = VK_PRESENT_GRAVITY_MIN_BIT_KHR, - eMax = VK_PRESENT_GRAVITY_MAX_BIT_KHR, - eCentered = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR - }; - - using PresentGravityFlagBitsEXT = PresentGravityFlagBitsKHR; - - // wrapper using for bitmask VkPresentGravityFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentGravityFlagsKHR.html - using PresentGravityFlagsKHR = Flags; - using PresentGravityFlagsEXT = PresentGravityFlagsKHR; - - template <> - struct FlagTraits - { - using WrappedType = VkPresentGravityFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PresentGravityFlagsKHR allFlags = - PresentGravityFlagBitsKHR::eMin | PresentGravityFlagBitsKHR::eMax | PresentGravityFlagBitsKHR::eCentered; - }; - - //=== VK_NV_cooperative_vector === - - // wrapper class for enum VkCooperativeVectorMatrixLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeVectorMatrixLayoutNV.html - enum class CooperativeVectorMatrixLayoutNV - { - eRowMajor = VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV, - eColumnMajor = VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV, - eInferencingOptimal = VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV, - eTrainingOptimal = VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV - }; - - // wrapper class for enum VkComponentTypeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkComponentTypeKHR.html - enum class ComponentTypeKHR - { - eFloat16 = VK_COMPONENT_TYPE_FLOAT16_KHR, - eFloat32 = VK_COMPONENT_TYPE_FLOAT32_KHR, - eFloat64 = VK_COMPONENT_TYPE_FLOAT64_KHR, - eSint8 = VK_COMPONENT_TYPE_SINT8_KHR, - eSint16 = VK_COMPONENT_TYPE_SINT16_KHR, - eSint32 = VK_COMPONENT_TYPE_SINT32_KHR, - eSint64 = VK_COMPONENT_TYPE_SINT64_KHR, - eUint8 = VK_COMPONENT_TYPE_UINT8_KHR, - eUint16 = VK_COMPONENT_TYPE_UINT16_KHR, - eUint32 = VK_COMPONENT_TYPE_UINT32_KHR, - eUint64 = VK_COMPONENT_TYPE_UINT64_KHR, - eBfloat16 = VK_COMPONENT_TYPE_BFLOAT16_KHR, - eSint8PackedNV = VK_COMPONENT_TYPE_SINT8_PACKED_NV, - eUint8PackedNV = VK_COMPONENT_TYPE_UINT8_PACKED_NV, - eFloat8E4M3EXT = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT, - eFloatE4M3 = VK_COMPONENT_TYPE_FLOAT_E4M3_NV, - eFloat8E5M2EXT = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT, - eFloatE5M2 = VK_COMPONENT_TYPE_FLOAT_E5M2_NV - }; - - using ComponentTypeNV = ComponentTypeKHR; - - //=== VK_EXT_layer_settings === - - // wrapper class for enum VkLayerSettingTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayerSettingTypeEXT.html - enum class LayerSettingTypeEXT - { - eBool32 = VK_LAYER_SETTING_TYPE_BOOL32_EXT, - eInt32 = VK_LAYER_SETTING_TYPE_INT32_EXT, - eInt64 = VK_LAYER_SETTING_TYPE_INT64_EXT, - eUint32 = VK_LAYER_SETTING_TYPE_UINT32_EXT, - eUint64 = VK_LAYER_SETTING_TYPE_UINT64_EXT, - eFloat32 = VK_LAYER_SETTING_TYPE_FLOAT32_EXT, - eFloat64 = VK_LAYER_SETTING_TYPE_FLOAT64_EXT, - eString = VK_LAYER_SETTING_TYPE_STRING_EXT - }; - - //================================= - //=== Layer Setting Type Traits === - //================================= - - template <> - struct CppType - { - using Type = Bool32; - }; - - template <> - struct CppType - { - using Type = int32_t; - }; - - template <> - struct CppType - { - using Type = int64_t; - }; - - template <> - struct CppType - { - using Type = uint32_t; - }; - - template <> - struct CppType - { - using Type = uint64_t; - }; - - template <> - struct CppType - { - using Type = float; - }; - - template <> - struct CppType - { - using Type = double; - }; - - template <> - struct CppType - { - using Type = char *; - }; - - template - bool isSameType( LayerSettingTypeEXT layerSettingType ) - { - switch ( layerSettingType ) - { - case LayerSettingTypeEXT::eBool32 : return std::is_same::value; - case LayerSettingTypeEXT::eInt32 : return std::is_same::value; - case LayerSettingTypeEXT::eInt64 : return std::is_same::value; - case LayerSettingTypeEXT::eUint32 : return std::is_same::value; - case LayerSettingTypeEXT::eUint64 : return std::is_same::value; - case LayerSettingTypeEXT::eFloat32: return std::is_same::value; - case LayerSettingTypeEXT::eFloat64: return std::is_same::value; - case LayerSettingTypeEXT::eString : return std::is_same::value; - default : return false; - } - } - - //=== VK_NV_low_latency2 === - - // wrapper class for enum VkLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencyMarkerNV.html - enum class LatencyMarkerNV - { - eSimulationStart = VK_LATENCY_MARKER_SIMULATION_START_NV, - eSimulationEnd = VK_LATENCY_MARKER_SIMULATION_END_NV, - eRendersubmitStart = VK_LATENCY_MARKER_RENDERSUBMIT_START_NV, - eRendersubmitEnd = VK_LATENCY_MARKER_RENDERSUBMIT_END_NV, - ePresentStart = VK_LATENCY_MARKER_PRESENT_START_NV, - ePresentEnd = VK_LATENCY_MARKER_PRESENT_END_NV, - eInputSample = VK_LATENCY_MARKER_INPUT_SAMPLE_NV, - eTriggerFlash = VK_LATENCY_MARKER_TRIGGER_FLASH_NV, - eOutOfBandRendersubmitStart = VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV, - eOutOfBandRendersubmitEnd = VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV, - eOutOfBandPresentStart = VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV, - eOutOfBandPresentEnd = VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV - }; - - // wrapper class for enum VkOutOfBandQueueTypeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOutOfBandQueueTypeNV.html - enum class OutOfBandQueueTypeNV - { - eRender = VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV, - ePresent = VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV - }; - - //=== VK_KHR_cooperative_matrix === - - // wrapper class for enum VkScopeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkScopeKHR.html - enum class ScopeKHR - { - eDevice = VK_SCOPE_DEVICE_KHR, - eWorkgroup = VK_SCOPE_WORKGROUP_KHR, - eSubgroup = VK_SCOPE_SUBGROUP_KHR, - eQueueFamily = VK_SCOPE_QUEUE_FAMILY_KHR - }; - - using ScopeNV = ScopeKHR; - - //=== VK_ARM_data_graph === - - // wrapper class for enum VkDataGraphPipelineSessionBindPointARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointARM.html - enum class DataGraphPipelineSessionBindPointARM - { - eTransient = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM - }; - - // wrapper class for enum VkDataGraphPipelineSessionBindPointTypeARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointTypeARM.html - enum class DataGraphPipelineSessionBindPointTypeARM - { - eMemory = VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM - }; - - // wrapper class for enum VkDataGraphPipelineSessionCreateFlagBitsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionCreateFlagBitsARM.html - enum class DataGraphPipelineSessionCreateFlagBitsARM : VkDataGraphPipelineSessionCreateFlagsARM - { - eProtected = VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM - }; - - // wrapper using for bitmask VkDataGraphPipelineSessionCreateFlagsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionCreateFlagsARM.html - using DataGraphPipelineSessionCreateFlagsARM = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkDataGraphPipelineSessionCreateFlagBitsARM; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DataGraphPipelineSessionCreateFlagsARM allFlags = DataGraphPipelineSessionCreateFlagBitsARM::eProtected; - }; - - // wrapper class for enum VkDataGraphPipelinePropertyARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelinePropertyARM.html - enum class DataGraphPipelinePropertyARM - { - eCreationLog = VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM, - eIdentifier = VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM - }; - - enum class DataGraphPipelineDispatchFlagBitsARM : VkDataGraphPipelineDispatchFlagsARM - { - }; - - // wrapper using for bitmask VkDataGraphPipelineDispatchFlagsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineDispatchFlagsARM.html - using DataGraphPipelineDispatchFlagsARM = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR DataGraphPipelineDispatchFlagsARM allFlags = {}; - }; - - // wrapper class for enum VkPhysicalDeviceDataGraphProcessingEngineTypeARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphProcessingEngineTypeARM.html - enum class PhysicalDeviceDataGraphProcessingEngineTypeARM - { - eDefault = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM, - eNeuralQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM, - eComputeQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM - }; - - // wrapper class for enum VkPhysicalDeviceDataGraphOperationTypeARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationTypeARM.html - enum class PhysicalDeviceDataGraphOperationTypeARM - { - eSpirvExtendedInstructionSet = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM, - eNeuralModelQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM, - eBuiltinModelQCOM = VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM - }; - - //=== VK_KHR_video_encode_av1 === - - // wrapper class for enum VkVideoEncodeAV1PredictionModeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1PredictionModeKHR.html - enum class VideoEncodeAV1PredictionModeKHR - { - eIntraOnly = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR, - eSingleReference = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR, - eUnidirectionalCompound = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR, - eBidirectionalCompound = VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR - }; - - // wrapper class for enum VkVideoEncodeAV1RateControlGroupKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlGroupKHR.html - enum class VideoEncodeAV1RateControlGroupKHR - { - eIntra = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR, - ePredictive = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR, - eBipredictive = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR - }; - - // wrapper class for enum VkVideoEncodeAV1CapabilityFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1CapabilityFlagBitsKHR.html - enum class VideoEncodeAV1CapabilityFlagBitsKHR : VkVideoEncodeAV1CapabilityFlagsKHR - { - ePerRateControlGroupMinMaxQIndex = VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR, - eGenerateObuExtensionHeader = VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR, - ePrimaryReferenceCdfOnly = VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR, - eFrameSizeOverride = VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR, - eMotionVectorScaling = VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR, - eCompoundPredictionIntraRefresh = VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeAV1CapabilityFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1CapabilityFlagsKHR.html - using VideoEncodeAV1CapabilityFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeAV1CapabilityFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1CapabilityFlagsKHR allFlags = - VideoEncodeAV1CapabilityFlagBitsKHR::ePerRateControlGroupMinMaxQIndex | VideoEncodeAV1CapabilityFlagBitsKHR::eGenerateObuExtensionHeader | - VideoEncodeAV1CapabilityFlagBitsKHR::ePrimaryReferenceCdfOnly | VideoEncodeAV1CapabilityFlagBitsKHR::eFrameSizeOverride | - VideoEncodeAV1CapabilityFlagBitsKHR::eMotionVectorScaling | VideoEncodeAV1CapabilityFlagBitsKHR::eCompoundPredictionIntraRefresh; - }; - - // wrapper class for enum VkVideoEncodeAV1StdFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1StdFlagBitsKHR.html - enum class VideoEncodeAV1StdFlagBitsKHR : VkVideoEncodeAV1StdFlagsKHR - { - eUniformTileSpacingFlagSet = VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR, - eSkipModePresentUnset = VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR, - ePrimaryRefFrame = VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR, - eDeltaQ = VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeAV1StdFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1StdFlagsKHR.html - using VideoEncodeAV1StdFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeAV1StdFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1StdFlagsKHR allFlags = - VideoEncodeAV1StdFlagBitsKHR::eUniformTileSpacingFlagSet | VideoEncodeAV1StdFlagBitsKHR::eSkipModePresentUnset | - VideoEncodeAV1StdFlagBitsKHR::ePrimaryRefFrame | VideoEncodeAV1StdFlagBitsKHR::eDeltaQ; - }; - - // wrapper class for enum VkVideoEncodeAV1SuperblockSizeFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1SuperblockSizeFlagBitsKHR.html - enum class VideoEncodeAV1SuperblockSizeFlagBitsKHR : VkVideoEncodeAV1SuperblockSizeFlagsKHR - { - e64 = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR, - e128 = VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeAV1SuperblockSizeFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1SuperblockSizeFlagsKHR.html - using VideoEncodeAV1SuperblockSizeFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeAV1SuperblockSizeFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1SuperblockSizeFlagsKHR allFlags = - VideoEncodeAV1SuperblockSizeFlagBitsKHR::e64 | VideoEncodeAV1SuperblockSizeFlagBitsKHR::e128; - }; - - // wrapper class for enum VkVideoEncodeAV1RateControlFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlFlagBitsKHR.html - enum class VideoEncodeAV1RateControlFlagBitsKHR : VkVideoEncodeAV1RateControlFlagsKHR - { - eRegularGop = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR, - eTemporalLayerPatternDyadic = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR, - eReferencePatternFlat = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR, - eReferencePatternDyadic = VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeAV1RateControlFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlFlagsKHR.html - using VideoEncodeAV1RateControlFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeAV1RateControlFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeAV1RateControlFlagsKHR allFlags = - VideoEncodeAV1RateControlFlagBitsKHR::eRegularGop | VideoEncodeAV1RateControlFlagBitsKHR::eTemporalLayerPatternDyadic | - VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternFlat | VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternDyadic; - }; - - //=== VK_QCOM_image_processing2 === - - // wrapper class for enum VkBlockMatchWindowCompareModeQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlockMatchWindowCompareModeQCOM.html - enum class BlockMatchWindowCompareModeQCOM - { - eMin = VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM, - eMax = VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM - }; - - //=== VK_QCOM_filter_cubic_weights === - - // wrapper class for enum VkCubicFilterWeightsQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCubicFilterWeightsQCOM.html - enum class CubicFilterWeightsQCOM - { - eCatmullRom = VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM, - eZeroTangentCardinal = VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM, - eBSpline = VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM, - eMitchellNetravali = VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM - }; - - //=== VK_MSFT_layered_driver === - - // wrapper class for enum VkLayeredDriverUnderlyingApiMSFT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayeredDriverUnderlyingApiMSFT.html - enum class LayeredDriverUnderlyingApiMSFT - { - eNone = VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT, - eD3D12 = VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT - }; - - //=== VK_KHR_calibrated_timestamps === - - // wrapper class for enum VkTimeDomainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTimeDomainKHR.html - enum class TimeDomainKHR - { - eDevice = VK_TIME_DOMAIN_DEVICE_KHR, - eClockMonotonic = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR, - eClockMonotonicRaw = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR, - eQueryPerformanceCounter = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR, - ePresentStageLocalEXT = VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT, - eSwapchainLocalEXT = VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT - }; - - using TimeDomainEXT = TimeDomainKHR; - - //=== VK_KHR_copy_memory_indirect === - - // wrapper class for enum VkAddressCopyFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCopyFlagBitsKHR.html - enum class AddressCopyFlagBitsKHR : VkAddressCopyFlagsKHR - { - eDeviceLocal = VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR, - eSparse = VK_ADDRESS_COPY_SPARSE_BIT_KHR, - eProtected = VK_ADDRESS_COPY_PROTECTED_BIT_KHR - }; - - // wrapper using for bitmask VkAddressCopyFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAddressCopyFlagsKHR.html - using AddressCopyFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkAddressCopyFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR AddressCopyFlagsKHR allFlags = - AddressCopyFlagBitsKHR::eDeviceLocal | AddressCopyFlagBitsKHR::eSparse | AddressCopyFlagBitsKHR::eProtected; - }; - - //=== VK_EXT_memory_decompression === - - // wrapper class for enum VkMemoryDecompressionMethodFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDecompressionMethodFlagBitsEXT.html - enum class MemoryDecompressionMethodFlagBitsEXT : VkMemoryDecompressionMethodFlagsEXT - { - eGdeflate10 = VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT - }; - - using MemoryDecompressionMethodFlagBitsNV = MemoryDecompressionMethodFlagBitsEXT; - - // wrapper using for bitmask VkMemoryDecompressionMethodFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDecompressionMethodFlagsEXT.html - using MemoryDecompressionMethodFlagsEXT = Flags; - using MemoryDecompressionMethodFlagsNV = MemoryDecompressionMethodFlagsEXT; - - template <> - struct FlagTraits - { - using WrappedType = VkMemoryDecompressionMethodFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR MemoryDecompressionMethodFlagsEXT allFlags = MemoryDecompressionMethodFlagBitsEXT::eGdeflate10; - }; - - //=== VK_NV_display_stereo === - - // wrapper class for enum VkDisplaySurfaceStereoTypeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplaySurfaceStereoTypeNV.html - enum class DisplaySurfaceStereoTypeNV - { - eNone = VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV, - eOnboardDin = VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV, - eHdmi3D = VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV, - eInbandDisplayport = VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV - }; - - //=== VK_KHR_video_encode_intra_refresh === - - // wrapper class for enum VkVideoEncodeIntraRefreshModeFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeIntraRefreshModeFlagBitsKHR.html - enum class VideoEncodeIntraRefreshModeFlagBitsKHR : VkVideoEncodeIntraRefreshModeFlagsKHR - { - eNone = VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR, - ePerPicturePartition = VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR, - eBlockBased = VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR, - eBlockRowBased = VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR, - eBlockColumnBased = VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR - }; - - // wrapper using for bitmask VkVideoEncodeIntraRefreshModeFlagsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeIntraRefreshModeFlagsKHR.html - using VideoEncodeIntraRefreshModeFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkVideoEncodeIntraRefreshModeFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR VideoEncodeIntraRefreshModeFlagsKHR allFlags = - VideoEncodeIntraRefreshModeFlagBitsKHR::eNone | VideoEncodeIntraRefreshModeFlagBitsKHR::ePerPicturePartition | - VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockBased | VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockRowBased | - VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockColumnBased; - }; - - //=== VK_KHR_maintenance7 === - - // wrapper class for enum VkPhysicalDeviceLayeredApiKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiKHR.html - enum class PhysicalDeviceLayeredApiKHR - { - eVulkan = VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR, - eD3D12 = VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR, - eMetal = VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR, - eOpengl = VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR, - eOpengles = VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR - }; - - //=== VK_NV_cluster_acceleration_structure === - - // wrapper class for enum VkClusterAccelerationStructureClusterFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureClusterFlagBitsNV.html - enum class ClusterAccelerationStructureClusterFlagBitsNV : VkClusterAccelerationStructureClusterFlagsNV - { - eAllowDisableOpacityMicromaps = VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV - }; - - // wrapper using for bitmask VkClusterAccelerationStructureClusterFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureClusterFlagsNV.html - using ClusterAccelerationStructureClusterFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkClusterAccelerationStructureClusterFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureClusterFlagsNV allFlags = - ClusterAccelerationStructureClusterFlagBitsNV::eAllowDisableOpacityMicromaps; - }; - - // wrapper class for enum VkClusterAccelerationStructureGeometryFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGeometryFlagBitsNV.html - enum class ClusterAccelerationStructureGeometryFlagBitsNV : VkClusterAccelerationStructureGeometryFlagsNV - { - eCullDisable = VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV, - eNoDuplicateAnyhitInvocation = VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV, - eOpaque = VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV - }; - - // wrapper using for bitmask VkClusterAccelerationStructureGeometryFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGeometryFlagsNV.html - using ClusterAccelerationStructureGeometryFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkClusterAccelerationStructureGeometryFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureGeometryFlagsNV allFlags = - ClusterAccelerationStructureGeometryFlagBitsNV::eCullDisable | ClusterAccelerationStructureGeometryFlagBitsNV::eNoDuplicateAnyhitInvocation | - ClusterAccelerationStructureGeometryFlagBitsNV::eOpaque; - }; - - // wrapper class for enum VkClusterAccelerationStructureAddressResolutionFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureAddressResolutionFlagBitsNV.html - enum class ClusterAccelerationStructureAddressResolutionFlagBitsNV : VkClusterAccelerationStructureAddressResolutionFlagsNV - { - eNone = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV, - eIndirectedDstImplicitData = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV, - eIndirectedScratchData = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV, - eIndirectedDstAddressArray = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV, - eIndirectedDstSizesArray = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV, - eIndirectedSrcInfosArray = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV, - eIndirectedSrcInfosCount = VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV - }; - - // wrapper using for bitmask VkClusterAccelerationStructureAddressResolutionFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureAddressResolutionFlagsNV.html - using ClusterAccelerationStructureAddressResolutionFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkClusterAccelerationStructureAddressResolutionFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureAddressResolutionFlagsNV allFlags = - ClusterAccelerationStructureAddressResolutionFlagBitsNV::eNone | ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstImplicitData | - ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedScratchData | - ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstAddressArray | - ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstSizesArray | - ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosArray | - ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosCount; - }; - - // wrapper class for enum VkClusterAccelerationStructureIndexFormatFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureIndexFormatFlagBitsNV.html - enum class ClusterAccelerationStructureIndexFormatFlagBitsNV : VkClusterAccelerationStructureIndexFormatFlagsNV - { - e8 = VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV, - e16 = VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV, - e32 = VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV - }; - - // wrapper using for bitmask VkClusterAccelerationStructureIndexFormatFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureIndexFormatFlagsNV.html - using ClusterAccelerationStructureIndexFormatFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkClusterAccelerationStructureIndexFormatFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ClusterAccelerationStructureIndexFormatFlagsNV allFlags = ClusterAccelerationStructureIndexFormatFlagBitsNV::e8 | - ClusterAccelerationStructureIndexFormatFlagBitsNV::e16 | - ClusterAccelerationStructureIndexFormatFlagBitsNV::e32; - }; - - // wrapper class for enum VkClusterAccelerationStructureTypeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureTypeNV.html - enum class ClusterAccelerationStructureTypeNV - { - eClustersBottomLevel = VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV, - eTriangleCluster = VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV, - eTriangleClusterTemplate = VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV - }; - - // wrapper class for enum VkClusterAccelerationStructureOpTypeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureOpTypeNV.html - enum class ClusterAccelerationStructureOpTypeNV - { - eMoveObjects = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV, - eBuildClustersBottomLevel = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV, - eBuildTriangleCluster = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV, - eBuildTriangleClusterTemplate = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV, - eInstantiateTriangleCluster = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV, - eGetClusterTemplateIndices = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV - }; - - // wrapper class for enum VkClusterAccelerationStructureOpModeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureOpModeNV.html - enum class ClusterAccelerationStructureOpModeNV - { - eImplicitDestinations = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV, - eExplicitDestinations = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV, - eComputeSizes = VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV - }; - - //=== VK_NV_partitioned_acceleration_structure === - - // wrapper class for enum VkPartitionedAccelerationStructureOpTypeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureOpTypeNV.html - enum class PartitionedAccelerationStructureOpTypeNV - { - eWriteInstance = VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV, - eUpdateInstance = VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV, - eWritePartitionTranslation = VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV - }; - - // wrapper class for enum VkPartitionedAccelerationStructureInstanceFlagBitsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureInstanceFlagBitsNV.html - enum class PartitionedAccelerationStructureInstanceFlagBitsNV : VkPartitionedAccelerationStructureInstanceFlagsNV - { - eFlagTriangleFacingCullDisable = VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV, - eFlagTriangleFlipFacing = VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV, - eFlagForceOpaque = VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV, - eFlagForceNoOpaque = VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV, - eFlagEnableExplicitBoundingBox = VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV - }; - - // wrapper using for bitmask VkPartitionedAccelerationStructureInstanceFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureInstanceFlagsNV.html - using PartitionedAccelerationStructureInstanceFlagsNV = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkPartitionedAccelerationStructureInstanceFlagBitsNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PartitionedAccelerationStructureInstanceFlagsNV allFlags = - PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFacingCullDisable | - PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFlipFacing | PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceOpaque | - PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceNoOpaque | - PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagEnableExplicitBoundingBox; - }; - - //=== VK_EXT_device_generated_commands === - - // wrapper class for enum VkIndirectCommandsTokenTypeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsTokenTypeEXT.html - enum class IndirectCommandsTokenTypeEXT - { - eExecutionSet = VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT, - ePushConstant = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT, - eSequenceIndex = VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT, - eIndexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT, - eVertexBuffer = VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT, - eDrawIndexed = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT, - eDraw = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT, - eDrawIndexedCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT, - eDrawCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT, - eDispatch = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT, - ePushData = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT, - ePushDataSequenceIndex = VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT, - eDrawMeshTasksNV = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT, - eDrawMeshTasksCountNV = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT, - eDrawMeshTasks = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT, - eDrawMeshTasksCount = VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT, - eTraceRays2 = VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT - }; - - // wrapper class for enum VkIndirectExecutionSetInfoTypeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetInfoTypeEXT.html - enum class IndirectExecutionSetInfoTypeEXT - { - ePipelines = VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT, - eShaderObjects = VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT - }; - - // wrapper class for enum VkIndirectCommandsLayoutUsageFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagBitsEXT.html - enum class IndirectCommandsLayoutUsageFlagBitsEXT : VkIndirectCommandsLayoutUsageFlagsEXT - { - eExplicitPreprocess = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT, - eUnorderedSequences = VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT - }; - - // wrapper using for bitmask VkIndirectCommandsLayoutUsageFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutUsageFlagsEXT.html - using IndirectCommandsLayoutUsageFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkIndirectCommandsLayoutUsageFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectCommandsLayoutUsageFlagsEXT allFlags = - IndirectCommandsLayoutUsageFlagBitsEXT::eExplicitPreprocess | IndirectCommandsLayoutUsageFlagBitsEXT::eUnorderedSequences; - }; - - // wrapper class for enum VkIndirectCommandsInputModeFlagBitsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsInputModeFlagBitsEXT.html - enum class IndirectCommandsInputModeFlagBitsEXT : VkIndirectCommandsInputModeFlagsEXT - { - eVulkanIndexBuffer = VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT, - eDxgiIndexBuffer = VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT - }; - - // wrapper using for bitmask VkIndirectCommandsInputModeFlagsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsInputModeFlagsEXT.html - using IndirectCommandsInputModeFlagsEXT = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkIndirectCommandsInputModeFlagBitsEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR IndirectCommandsInputModeFlagsEXT allFlags = - IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer | IndirectCommandsInputModeFlagBitsEXT::eDxgiIndexBuffer; - }; - - //=== VK_KHR_maintenance8 === - - // wrapper class for enum VkAccessFlagBits3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlagBits3KHR.html - enum class AccessFlagBits3KHR : VkAccessFlags3KHR - { - eNone = VK_ACCESS_3_NONE_KHR - }; - - // wrapper using for bitmask VkAccessFlags3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccessFlags3KHR.html - using AccessFlags3KHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkAccessFlagBits3KHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR AccessFlags3KHR allFlags = AccessFlagBits3KHR::eNone; - }; - - //=== VK_EXT_ray_tracing_invocation_reorder === - - // wrapper class for enum VkRayTracingInvocationReorderModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingInvocationReorderModeEXT.html - enum class RayTracingInvocationReorderModeEXT - { - eNone = VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT, - eReorder = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT - }; - - using RayTracingInvocationReorderModeNV = RayTracingInvocationReorderModeEXT; - - //=== VK_EXT_depth_clamp_control === - - // wrapper class for enum VkDepthClampModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthClampModeEXT.html - enum class DepthClampModeEXT - { - eViewportRange = VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT, - eUserDefinedRange = VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT - }; - - //=== VK_KHR_maintenance9 === - - // wrapper class for enum VkDefaultVertexAttributeValueKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDefaultVertexAttributeValueKHR.html - enum class DefaultVertexAttributeValueKHR - { - eZeroZeroZeroZero = VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR, - eZeroZeroZeroOne = VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR - }; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - - enum class SurfaceCreateFlagBitsOHOS : VkSurfaceCreateFlagsOHOS - { - }; - - // wrapper using for bitmask VkSurfaceCreateFlagsOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCreateFlagsOHOS.html - using SurfaceCreateFlagsOHOS = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR SurfaceCreateFlagsOHOS allFlags = {}; - }; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_ARM_performance_counters_by_region === - - enum class PerformanceCounterDescriptionFlagBitsARM : VkPerformanceCounterDescriptionFlagsARM - { - }; - - // wrapper using for bitmask VkPerformanceCounterDescriptionFlagsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionFlagsARM.html - using PerformanceCounterDescriptionFlagsARM = Flags; - - template <> - struct FlagTraits - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR PerformanceCounterDescriptionFlagsARM allFlags = {}; - }; - - //=== VK_QCOM_data_graph_model === - - // wrapper class for enum VkDataGraphModelCacheTypeQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphModelCacheTypeQCOM.html - enum class DataGraphModelCacheTypeQCOM - { - eGenericBinary = VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM - }; - - //=== VK_KHR_maintenance10 === - - // wrapper class for enum VkRenderingAttachmentFlagBitsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentFlagBitsKHR.html - enum class RenderingAttachmentFlagBitsKHR : VkRenderingAttachmentFlagsKHR - { - eInputAttachmentFeedback = VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR, - eResolveSkipTransferFunction = VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR, - eResolveEnableTransferFunction = VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR - }; - - // wrapper using for bitmask VkRenderingAttachmentFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentFlagsKHR.html - using RenderingAttachmentFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkRenderingAttachmentFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR RenderingAttachmentFlagsKHR allFlags = RenderingAttachmentFlagBitsKHR::eInputAttachmentFeedback | - RenderingAttachmentFlagBitsKHR::eResolveSkipTransferFunction | - RenderingAttachmentFlagBitsKHR::eResolveEnableTransferFunction; - }; - - // wrapper class for enum VkResolveImageFlagBitsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveImageFlagBitsKHR.html - enum class ResolveImageFlagBitsKHR : VkResolveImageFlagsKHR - { - eSkipTransferFunction = VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR, - eEnableTransferFunction = VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR - }; - - // wrapper using for bitmask VkResolveImageFlagsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveImageFlagsKHR.html - using ResolveImageFlagsKHR = Flags; - - template <> - struct FlagTraits - { - using WrappedType = VkResolveImageFlagBitsKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR ResolveImageFlagsKHR allFlags = - ResolveImageFlagBitsKHR::eSkipTransferFunction | ResolveImageFlagBitsKHR::eEnableTransferFunction; - }; - - //=========================================================== - //=== Mapping from ObjectType to DebugReportObjectTypeEXT === - //=========================================================== - - VULKAN_HPP_INLINE DebugReportObjectTypeEXT debugReportObjectType( ObjectType objectType ) - { - switch ( objectType ) - { - //=== VK_VERSION_1_0 === - case ObjectType::eInstance : return DebugReportObjectTypeEXT::eInstance; - case ObjectType::ePhysicalDevice : return DebugReportObjectTypeEXT::ePhysicalDevice; - case ObjectType::eDevice : return DebugReportObjectTypeEXT::eDevice; - case ObjectType::eQueue : return DebugReportObjectTypeEXT::eQueue; - case ObjectType::eDeviceMemory : return DebugReportObjectTypeEXT::eDeviceMemory; - case ObjectType::eFence : return DebugReportObjectTypeEXT::eFence; - case ObjectType::eSemaphore : return DebugReportObjectTypeEXT::eSemaphore; - case ObjectType::eQueryPool : return DebugReportObjectTypeEXT::eQueryPool; - case ObjectType::eBuffer : return DebugReportObjectTypeEXT::eBuffer; - case ObjectType::eImage : return DebugReportObjectTypeEXT::eImage; - case ObjectType::eImageView : return DebugReportObjectTypeEXT::eImageView; - case ObjectType::eCommandPool : return DebugReportObjectTypeEXT::eCommandPool; - case ObjectType::eCommandBuffer : return DebugReportObjectTypeEXT::eCommandBuffer; - case ObjectType::eEvent : return DebugReportObjectTypeEXT::eEvent; - case ObjectType::eBufferView : return DebugReportObjectTypeEXT::eBufferView; - case ObjectType::eShaderModule : return DebugReportObjectTypeEXT::eShaderModule; - case ObjectType::ePipelineCache : return DebugReportObjectTypeEXT::ePipelineCache; - case ObjectType::ePipeline : return DebugReportObjectTypeEXT::ePipeline; - case ObjectType::ePipelineLayout : return DebugReportObjectTypeEXT::ePipelineLayout; - case ObjectType::eSampler : return DebugReportObjectTypeEXT::eSampler; - case ObjectType::eDescriptorPool : return DebugReportObjectTypeEXT::eDescriptorPool; - case ObjectType::eDescriptorSet : return DebugReportObjectTypeEXT::eDescriptorSet; - case ObjectType::eDescriptorSetLayout: return DebugReportObjectTypeEXT::eDescriptorSetLayout; - case ObjectType::eFramebuffer : return DebugReportObjectTypeEXT::eFramebuffer; - case ObjectType::eRenderPass: - return DebugReportObjectTypeEXT::eRenderPass; - - //=== VK_VERSION_1_1 === - case ObjectType::eDescriptorUpdateTemplate: return DebugReportObjectTypeEXT::eDescriptorUpdateTemplate; - case ObjectType::eSamplerYcbcrConversion: - return DebugReportObjectTypeEXT::eSamplerYcbcrConversion; - - //=== VK_VERSION_1_3 === - case ObjectType::ePrivateDataSlot: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_KHR_surface === - case ObjectType::eSurfaceKHR: - return DebugReportObjectTypeEXT::eSurfaceKHR; - - //=== VK_KHR_swapchain === - case ObjectType::eSwapchainKHR: - return DebugReportObjectTypeEXT::eSwapchainKHR; - - //=== VK_KHR_display === - case ObjectType::eDisplayKHR: return DebugReportObjectTypeEXT::eDisplayKHR; - case ObjectType::eDisplayModeKHR: - return DebugReportObjectTypeEXT::eDisplayModeKHR; - - //=== VK_EXT_debug_report === - case ObjectType::eDebugReportCallbackEXT: - return DebugReportObjectTypeEXT::eDebugReportCallbackEXT; - - //=== VK_KHR_video_queue === - case ObjectType::eVideoSessionKHR: return DebugReportObjectTypeEXT::eUnknown; - case ObjectType::eVideoSessionParametersKHR: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_NVX_binary_import === - case ObjectType::eCuModuleNVX: return DebugReportObjectTypeEXT::eCuModuleNVX; - case ObjectType::eCuFunctionNVX: - return DebugReportObjectTypeEXT::eCuFunctionNVX; - - //=== VK_EXT_debug_utils === - case ObjectType::eDebugUtilsMessengerEXT: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_EXT_descriptor_heap === - case ObjectType::eTensorARM: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_KHR_acceleration_structure === - case ObjectType::eAccelerationStructureKHR: - return DebugReportObjectTypeEXT::eAccelerationStructureKHR; - - //=== VK_EXT_validation_cache === - case ObjectType::eValidationCacheEXT: - return DebugReportObjectTypeEXT::eValidationCacheEXT; - - //=== VK_NV_ray_tracing === - case ObjectType::eAccelerationStructureNV: - return DebugReportObjectTypeEXT::eAccelerationStructureNV; - - //=== VK_INTEL_performance_query === - case ObjectType::ePerformanceConfigurationINTEL: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_KHR_deferred_host_operations === - case ObjectType::eDeferredOperationKHR: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_NV_device_generated_commands === - case ObjectType::eIndirectCommandsLayoutNV: return DebugReportObjectTypeEXT::eUnknown; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - case ObjectType::eCudaModuleNV : return DebugReportObjectTypeEXT::eCudaModuleNV; - case ObjectType::eCudaFunctionNV: return DebugReportObjectTypeEXT::eCudaFunctionNV; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - case ObjectType::eBufferCollectionFUCHSIA: return DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_EXT_opacity_micromap === - case ObjectType::eMicromapEXT: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_ARM_tensors === - case ObjectType::eTensorViewARM: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_NV_optical_flow === - case ObjectType::eOpticalFlowSessionNV: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_EXT_shader_object === - case ObjectType::eShaderEXT: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_KHR_pipeline_binary === - case ObjectType::ePipelineBinaryKHR: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_ARM_data_graph === - case ObjectType::eDataGraphPipelineSessionARM: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_NV_external_compute_queue === - case ObjectType::eExternalComputeQueueNV: - return DebugReportObjectTypeEXT::eUnknown; - - //=== VK_EXT_device_generated_commands === - case ObjectType::eIndirectCommandsLayoutEXT: return DebugReportObjectTypeEXT::eUnknown; - case ObjectType::eIndirectExecutionSetEXT : return DebugReportObjectTypeEXT::eUnknown; - - default: VULKAN_HPP_ASSERT( false && "unknown ObjectType" ); return DebugReportObjectTypeEXT::eUnknown; - } - } - -} // namespace VULKAN_HPP_NAMESPACE -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_extension_inspection.hpp b/lib/vulkan-headers/include/vulkan/vulkan_extension_inspection.hpp deleted file mode 100644 index 34c9779f801..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_extension_inspection.hpp +++ /dev/null @@ -1,4155 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_EXTENSION_INSPECTION_HPP -#define VULKAN_EXTENSION_INSPECTION_HPP - -#if !defined( VULKAN_HPP_CXX_MODULE ) -# include -# include -# include -# include -# include -#endif - -namespace VULKAN_HPP_NAMESPACE -{ - //====================================== - //=== Extension inspection functions === - //====================================== - - std::set const & getDeviceExtensions(); - std::set const & getInstanceExtensions(); - std::map const & getDeprecatedExtensions(); - std::map>> const & getExtensionDepends( std::string const & extension ); - std::pair> const &> getExtensionDepends( std::string const & version, std::string const & extension ); - std::map const & getObsoletedExtensions(); - std::map const & getPromotedExtensions(); - VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & extension ); - VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & extension ); - VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & extension ); - VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & extension ); - VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension ); - VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension ); - VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension ); - VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & extension ); - - //===================================================== - //=== Extension inspection function implementations === - //===================================================== - - VULKAN_HPP_INLINE std::map const & getDeprecatedExtensions() - { - static const std::map deprecatedExtensions = { { "VK_EXT_debug_report", "VK_EXT_debug_utils" }, - { "VK_NV_glsl_shader", "" }, - { "VK_NV_dedicated_allocation", "VK_KHR_dedicated_allocation" }, - { "VK_AMD_gpu_shader_half_float", "VK_KHR_shader_float16_int8" }, - { "VK_IMG_format_pvrtc", "" }, - { "VK_NV_external_memory_capabilities", "VK_KHR_external_memory_capabilities" }, - { "VK_NV_external_memory", "VK_KHR_external_memory" }, -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - { "VK_NV_external_memory_win32", "VK_KHR_external_memory_win32" }, -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - { "VK_EXT_validation_flags", "VK_EXT_layer_settings" }, - { "VK_EXT_shader_subgroup_ballot", "VK_VERSION_1_2" }, - { "VK_EXT_shader_subgroup_vote", "VK_VERSION_1_1" }, -#if defined( VK_USE_PLATFORM_IOS_MVK ) - { "VK_MVK_ios_surface", "VK_EXT_metal_surface" }, -#endif /*VK_USE_PLATFORM_IOS_MVK*/ -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - { "VK_MVK_macos_surface", "VK_EXT_metal_surface" }, -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - { "VK_AMD_gpu_shader_int16", "VK_KHR_shader_float16_int8" }, - { "VK_NV_ray_tracing", "VK_KHR_ray_tracing_pipeline" }, - { "VK_EXT_buffer_device_address", "VK_KHR_buffer_device_address" }, - { "VK_EXT_validation_features", "VK_EXT_layer_settings" }, -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - { "VK_NV_displacement_micromap", "VK_NV_cluster_acceleration_structure" } -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - }; - return deprecatedExtensions; - } - - VULKAN_HPP_INLINE std::set const & getDeviceExtensions() - { - static const std::set deviceExtensions = { "VK_KHR_swapchain", - "VK_KHR_display_swapchain", - "VK_NV_glsl_shader", - "VK_EXT_depth_range_unrestricted", - "VK_KHR_sampler_mirror_clamp_to_edge", - "VK_IMG_filter_cubic", - "VK_AMD_rasterization_order", - "VK_AMD_shader_trinary_minmax", - "VK_AMD_shader_explicit_vertex_parameter", - "VK_EXT_debug_marker", - "VK_KHR_video_queue", - "VK_KHR_video_decode_queue", - "VK_AMD_gcn_shader", - "VK_NV_dedicated_allocation", - "VK_EXT_transform_feedback", - "VK_NVX_binary_import", - "VK_NVX_image_view_handle", - "VK_AMD_draw_indirect_count", - "VK_AMD_negative_viewport_height", - "VK_AMD_gpu_shader_half_float", - "VK_AMD_shader_ballot", - "VK_KHR_video_encode_h264", - "VK_KHR_video_encode_h265", - "VK_KHR_video_decode_h264", - "VK_AMD_texture_gather_bias_lod", - "VK_AMD_shader_info", - "VK_KHR_dynamic_rendering", - "VK_AMD_shader_image_load_store_lod", - "VK_NV_corner_sampled_image", - "VK_KHR_multiview", - "VK_IMG_format_pvrtc", - "VK_NV_external_memory", -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - "VK_NV_external_memory_win32", - "VK_NV_win32_keyed_mutex", -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - "VK_KHR_device_group", - "VK_KHR_shader_draw_parameters", - "VK_EXT_shader_subgroup_ballot", - "VK_EXT_shader_subgroup_vote", - "VK_EXT_texture_compression_astc_hdr", - "VK_EXT_astc_decode_mode", - "VK_EXT_pipeline_robustness", - "VK_KHR_maintenance1", - "VK_KHR_external_memory", -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - "VK_KHR_external_memory_win32", -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - "VK_KHR_external_memory_fd", -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - "VK_KHR_win32_keyed_mutex", -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - "VK_KHR_external_semaphore", -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - "VK_KHR_external_semaphore_win32", -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - "VK_KHR_external_semaphore_fd", - "VK_KHR_push_descriptor", - "VK_EXT_conditional_rendering", - "VK_KHR_shader_float16_int8", - "VK_KHR_16bit_storage", - "VK_KHR_incremental_present", - "VK_KHR_descriptor_update_template", - "VK_NV_clip_space_w_scaling", - "VK_EXT_display_control", - "VK_GOOGLE_display_timing", - "VK_NV_sample_mask_override_coverage", - "VK_NV_geometry_shader_passthrough", - "VK_NV_viewport_array2", - "VK_NVX_multiview_per_view_attributes", - "VK_NV_viewport_swizzle", - "VK_EXT_discard_rectangles", - "VK_EXT_conservative_rasterization", - "VK_EXT_depth_clip_enable", - "VK_EXT_hdr_metadata", - "VK_KHR_imageless_framebuffer", - "VK_KHR_create_renderpass2", - "VK_IMG_relaxed_line_rasterization", - "VK_KHR_shared_presentable_image", - "VK_KHR_external_fence", -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - "VK_KHR_external_fence_win32", -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - "VK_KHR_external_fence_fd", - "VK_KHR_performance_query", - "VK_KHR_maintenance2", - "VK_KHR_variable_pointers", - "VK_EXT_external_memory_dma_buf", - "VK_EXT_queue_family_foreign", - "VK_KHR_dedicated_allocation", -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - "VK_ANDROID_external_memory_android_hardware_buffer", -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - "VK_EXT_sampler_filter_minmax", - "VK_KHR_storage_buffer_storage_class", - "VK_AMD_gpu_shader_int16", -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - "VK_AMDX_shader_enqueue", -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - "VK_EXT_descriptor_heap", - "VK_AMD_mixed_attachment_samples", - "VK_AMD_shader_fragment_mask", - "VK_EXT_inline_uniform_block", - "VK_EXT_shader_stencil_export", - "VK_KHR_shader_bfloat16", - "VK_EXT_sample_locations", - "VK_KHR_relaxed_block_layout", - "VK_KHR_get_memory_requirements2", - "VK_KHR_image_format_list", - "VK_EXT_blend_operation_advanced", - "VK_NV_fragment_coverage_to_color", - "VK_KHR_acceleration_structure", - "VK_KHR_ray_tracing_pipeline", - "VK_KHR_ray_query", - "VK_NV_framebuffer_mixed_samples", - "VK_NV_fill_rectangle", - "VK_NV_shader_sm_builtins", - "VK_EXT_post_depth_coverage", - "VK_KHR_sampler_ycbcr_conversion", - "VK_KHR_bind_memory2", - "VK_EXT_image_drm_format_modifier", - "VK_EXT_validation_cache", - "VK_EXT_descriptor_indexing", - "VK_EXT_shader_viewport_index_layer", -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - "VK_KHR_portability_subset", -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - "VK_NV_shading_rate_image", - "VK_NV_ray_tracing", - "VK_NV_representative_fragment_test", - "VK_KHR_maintenance3", - "VK_KHR_draw_indirect_count", - "VK_EXT_filter_cubic", - "VK_QCOM_render_pass_shader_resolve", - "VK_EXT_global_priority", - "VK_KHR_shader_subgroup_extended_types", - "VK_KHR_8bit_storage", - "VK_EXT_external_memory_host", - "VK_AMD_buffer_marker", - "VK_KHR_shader_atomic_int64", - "VK_KHR_shader_clock", - "VK_AMD_pipeline_compiler_control", - "VK_EXT_calibrated_timestamps", - "VK_AMD_shader_core_properties", - "VK_KHR_video_decode_h265", - "VK_KHR_global_priority", - "VK_AMD_memory_overallocation_behavior", - "VK_EXT_vertex_attribute_divisor", -#if defined( VK_USE_PLATFORM_GGP ) - "VK_GGP_frame_token", -#endif /*VK_USE_PLATFORM_GGP*/ - "VK_EXT_pipeline_creation_feedback", - "VK_KHR_driver_properties", - "VK_KHR_shader_float_controls", - "VK_NV_shader_subgroup_partitioned", - "VK_KHR_depth_stencil_resolve", - "VK_KHR_swapchain_mutable_format", - "VK_NV_compute_shader_derivatives", - "VK_NV_mesh_shader", - "VK_NV_fragment_shader_barycentric", - "VK_NV_shader_image_footprint", - "VK_NV_scissor_exclusive", - "VK_NV_device_diagnostic_checkpoints", - "VK_KHR_timeline_semaphore", - "VK_EXT_present_timing", - "VK_INTEL_shader_integer_functions2", - "VK_INTEL_performance_query", - "VK_KHR_vulkan_memory_model", - "VK_EXT_pci_bus_info", - "VK_AMD_display_native_hdr", - "VK_KHR_shader_terminate_invocation", - "VK_EXT_fragment_density_map", - "VK_EXT_scalar_block_layout", - "VK_GOOGLE_hlsl_functionality1", - "VK_GOOGLE_decorate_string", - "VK_EXT_subgroup_size_control", - "VK_KHR_fragment_shading_rate", - "VK_AMD_shader_core_properties2", - "VK_AMD_device_coherent_memory", - "VK_KHR_dynamic_rendering_local_read", - "VK_EXT_shader_image_atomic_int64", - "VK_KHR_shader_quad_control", - "VK_KHR_spirv_1_4", - "VK_EXT_memory_budget", - "VK_EXT_memory_priority", - "VK_NV_dedicated_allocation_image_aliasing", - "VK_KHR_separate_depth_stencil_layouts", - "VK_EXT_buffer_device_address", - "VK_EXT_tooling_info", - "VK_EXT_separate_stencil_usage", - "VK_KHR_present_wait", - "VK_NV_cooperative_matrix", - "VK_NV_coverage_reduction_mode", - "VK_EXT_fragment_shader_interlock", - "VK_EXT_ycbcr_image_arrays", - "VK_KHR_uniform_buffer_standard_layout", - "VK_EXT_provoking_vertex", -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - "VK_EXT_full_screen_exclusive", -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - "VK_KHR_buffer_device_address", - "VK_EXT_line_rasterization", - "VK_EXT_shader_atomic_float", - "VK_EXT_host_query_reset", - "VK_EXT_index_type_uint8", - "VK_EXT_extended_dynamic_state", - "VK_KHR_deferred_host_operations", - "VK_KHR_pipeline_executable_properties", - "VK_EXT_host_image_copy", - "VK_KHR_map_memory2", - "VK_EXT_map_memory_placed", - "VK_EXT_shader_atomic_float2", - "VK_EXT_swapchain_maintenance1", - "VK_EXT_shader_demote_to_helper_invocation", - "VK_NV_device_generated_commands", - "VK_NV_inherited_viewport_scissor", - "VK_KHR_shader_integer_dot_product", - "VK_EXT_texel_buffer_alignment", - "VK_QCOM_render_pass_transform", - "VK_EXT_depth_bias_control", - "VK_EXT_device_memory_report", - "VK_EXT_robustness2", - "VK_EXT_custom_border_color", - "VK_EXT_texture_compression_astc_3d", - "VK_GOOGLE_user_type", - "VK_KHR_pipeline_library", - "VK_NV_present_barrier", - "VK_KHR_shader_non_semantic_info", - "VK_KHR_present_id", - "VK_EXT_private_data", - "VK_EXT_pipeline_creation_cache_control", - "VK_KHR_video_encode_queue", - "VK_NV_device_diagnostics_config", - "VK_QCOM_render_pass_store_ops", -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - "VK_NV_cuda_kernel_launch", -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - "VK_QCOM_tile_shading", - "VK_NV_low_latency", -#if defined( VK_USE_PLATFORM_METAL_EXT ) - "VK_EXT_metal_objects", -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - "VK_KHR_synchronization2", - "VK_EXT_descriptor_buffer", - "VK_EXT_graphics_pipeline_library", - "VK_AMD_shader_early_and_late_fragment_tests", - "VK_KHR_fragment_shader_barycentric", - "VK_KHR_shader_subgroup_uniform_control_flow", - "VK_KHR_zero_initialize_workgroup_memory", - "VK_NV_fragment_shading_rate_enums", - "VK_NV_ray_tracing_motion_blur", - "VK_EXT_mesh_shader", - "VK_EXT_ycbcr_2plane_444_formats", - "VK_EXT_fragment_density_map2", - "VK_QCOM_rotated_copy_commands", - "VK_EXT_image_robustness", - "VK_KHR_workgroup_memory_explicit_layout", - "VK_KHR_copy_commands2", - "VK_EXT_image_compression_control", - "VK_EXT_attachment_feedback_loop_layout", - "VK_EXT_4444_formats", - "VK_EXT_device_fault", - "VK_ARM_rasterization_order_attachment_access", - "VK_EXT_rgba10x6_formats", -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - "VK_NV_acquire_winrt_display", -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - "VK_VALVE_mutable_descriptor_type", - "VK_EXT_vertex_input_dynamic_state", - "VK_EXT_physical_device_drm", - "VK_EXT_device_address_binding_report", - "VK_EXT_depth_clip_control", - "VK_EXT_primitive_topology_list_restart", - "VK_KHR_format_feature_flags2", - "VK_EXT_present_mode_fifo_latest_ready", -#if defined( VK_USE_PLATFORM_FUCHSIA ) - "VK_FUCHSIA_external_memory", - "VK_FUCHSIA_external_semaphore", - "VK_FUCHSIA_buffer_collection", -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - "VK_HUAWEI_subpass_shading", - "VK_HUAWEI_invocation_mask", - "VK_NV_external_memory_rdma", - "VK_EXT_pipeline_properties", - "VK_EXT_frame_boundary", - "VK_EXT_multisampled_render_to_single_sampled", - "VK_EXT_extended_dynamic_state2", - "VK_EXT_color_write_enable", - "VK_EXT_primitives_generated_query", - "VK_KHR_ray_tracing_maintenance1", - "VK_KHR_shader_untyped_pointers", - "VK_EXT_global_priority_query", - "VK_VALVE_video_encode_rgb_conversion", - "VK_EXT_image_view_min_lod", - "VK_EXT_multi_draw", - "VK_EXT_image_2d_view_of_3d", - "VK_EXT_shader_tile_image", - "VK_EXT_opacity_micromap", -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - "VK_NV_displacement_micromap", -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - "VK_EXT_load_store_op_none", - "VK_HUAWEI_cluster_culling_shader", - "VK_EXT_border_color_swizzle", - "VK_EXT_pageable_device_local_memory", - "VK_KHR_maintenance4", - "VK_ARM_shader_core_properties", - "VK_KHR_shader_subgroup_rotate", - "VK_ARM_scheduling_controls", - "VK_EXT_image_sliced_view_of_3d", - "VK_VALVE_descriptor_set_host_mapping", - "VK_EXT_depth_clamp_zero_one", - "VK_EXT_non_seamless_cube_map", - "VK_ARM_render_pass_striped", - "VK_QCOM_fragment_density_map_offset", - "VK_NV_copy_memory_indirect", - "VK_NV_memory_decompression", - "VK_NV_device_generated_commands_compute", - "VK_NV_ray_tracing_linear_swept_spheres", - "VK_NV_linear_color_attachment", - "VK_KHR_shader_maximal_reconvergence", - "VK_EXT_image_compression_control_swapchain", - "VK_QCOM_image_processing", - "VK_EXT_nested_command_buffer", -#if defined( VK_USE_PLATFORM_OHOS ) - "VK_OHOS_external_memory", -#endif /*VK_USE_PLATFORM_OHOS*/ - "VK_EXT_external_memory_acquire_unmodified", - "VK_EXT_extended_dynamic_state3", - "VK_EXT_subpass_merge_feedback", - "VK_ARM_tensors", - "VK_EXT_shader_module_identifier", - "VK_EXT_rasterization_order_attachment_access", - "VK_NV_optical_flow", - "VK_EXT_legacy_dithering", - "VK_EXT_pipeline_protected_access", -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - "VK_ANDROID_external_format_resolve", -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - "VK_KHR_maintenance5", - "VK_AMD_anti_lag", -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - "VK_AMDX_dense_geometry_format", -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - "VK_KHR_present_id2", - "VK_KHR_present_wait2", - "VK_KHR_ray_tracing_position_fetch", - "VK_EXT_shader_object", - "VK_KHR_pipeline_binary", - "VK_QCOM_tile_properties", - "VK_SEC_amigo_profiling", - "VK_KHR_swapchain_maintenance1", - "VK_QCOM_multiview_per_view_viewports", - "VK_NV_ray_tracing_invocation_reorder", - "VK_NV_cooperative_vector", - "VK_NV_extended_sparse_address_space", - "VK_EXT_mutable_descriptor_type", - "VK_EXT_legacy_vertex_attributes", - "VK_ARM_shader_core_builtins", - "VK_EXT_pipeline_library_group_handles", - "VK_EXT_dynamic_rendering_unused_attachments", - "VK_KHR_internally_synchronized_queues", - "VK_NV_low_latency2", - "VK_KHR_cooperative_matrix", - "VK_ARM_data_graph", - "VK_QCOM_multiview_per_view_render_areas", - "VK_KHR_compute_shader_derivatives", - "VK_KHR_video_decode_av1", - "VK_KHR_video_encode_av1", - "VK_KHR_video_decode_vp9", - "VK_KHR_video_maintenance1", - "VK_NV_per_stage_descriptor_set", - "VK_QCOM_image_processing2", - "VK_QCOM_filter_cubic_weights", - "VK_QCOM_ycbcr_degamma", - "VK_QCOM_filter_cubic_clamp", - "VK_EXT_attachment_feedback_loop_dynamic_state", - "VK_KHR_vertex_attribute_divisor", - "VK_KHR_load_store_op_none", - "VK_KHR_unified_image_layouts", - "VK_KHR_shader_float_controls2", -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - "VK_QNX_external_memory_screen_buffer", -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - "VK_MSFT_layered_driver", - "VK_KHR_index_type_uint8", - "VK_KHR_line_rasterization", - "VK_KHR_calibrated_timestamps", - "VK_KHR_shader_expect_assume", - "VK_KHR_maintenance6", - "VK_NV_descriptor_pool_overallocation", - "VK_QCOM_tile_memory_heap", - "VK_KHR_copy_memory_indirect", - "VK_EXT_memory_decompression", - "VK_KHR_video_encode_intra_refresh", - "VK_KHR_video_encode_quantization_map", - "VK_NV_raw_access_chains", - "VK_NV_external_compute_queue", - "VK_KHR_shader_relaxed_extended_instruction", - "VK_NV_command_buffer_inheritance", - "VK_KHR_maintenance7", - "VK_NV_shader_atomic_float16_vector", - "VK_EXT_shader_replicated_composites", - "VK_EXT_shader_float8", - "VK_NV_ray_tracing_validation", - "VK_NV_cluster_acceleration_structure", - "VK_NV_partitioned_acceleration_structure", - "VK_EXT_device_generated_commands", - "VK_KHR_maintenance8", - "VK_MESA_image_alignment_control", - "VK_KHR_shader_fma", - "VK_NV_push_constant_bank", - "VK_EXT_ray_tracing_invocation_reorder", - "VK_EXT_depth_clamp_control", - "VK_KHR_maintenance9", - "VK_KHR_video_maintenance2", - "VK_HUAWEI_hdr_vivid", - "VK_NV_cooperative_matrix2", - "VK_ARM_pipeline_opacity_micromap", -#if defined( VK_USE_PLATFORM_METAL_EXT ) - "VK_EXT_external_memory_metal", -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - "VK_KHR_depth_clamp_zero_one", - "VK_ARM_performance_counters_by_region", - "VK_EXT_vertex_attribute_robustness", - "VK_ARM_format_pack", - "VK_VALVE_fragment_density_map_layered", - "VK_KHR_robustness2", -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - "VK_NV_present_metering", -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - "VK_EXT_fragment_density_map_offset", - "VK_EXT_zero_initialize_device_memory", - "VK_KHR_present_mode_fifo_latest_ready", - "VK_EXT_shader_64bit_indexing", - "VK_EXT_custom_resolve", - "VK_QCOM_data_graph_model", - "VK_KHR_maintenance10", - "VK_EXT_shader_long_vector", - "VK_SEC_pipeline_cache_incremental_mode", - "VK_EXT_shader_uniform_buffer_unsized_array", - "VK_NV_compute_occupancy_priority", - "VK_EXT_shader_subgroup_partitioned" }; - return deviceExtensions; - } - - VULKAN_HPP_INLINE std::set const & getInstanceExtensions() - { - static const std::set instanceExtensions = { "VK_KHR_surface", - "VK_KHR_display", -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - "VK_KHR_xlib_surface", -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ -#if defined( VK_USE_PLATFORM_XCB_KHR ) - "VK_KHR_xcb_surface", -#endif /*VK_USE_PLATFORM_XCB_KHR*/ -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - "VK_KHR_wayland_surface", -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - "VK_KHR_android_surface", -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - "VK_KHR_win32_surface", -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - "VK_EXT_debug_report", -#if defined( VK_USE_PLATFORM_GGP ) - "VK_GGP_stream_descriptor_surface", -#endif /*VK_USE_PLATFORM_GGP*/ - "VK_NV_external_memory_capabilities", - "VK_KHR_get_physical_device_properties2", - "VK_EXT_validation_flags", -#if defined( VK_USE_PLATFORM_VI_NN ) - "VK_NN_vi_surface", -#endif /*VK_USE_PLATFORM_VI_NN*/ - "VK_KHR_device_group_creation", - "VK_KHR_external_memory_capabilities", - "VK_KHR_external_semaphore_capabilities", - "VK_EXT_direct_mode_display", -#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - "VK_EXT_acquire_xlib_display", -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - "VK_EXT_display_surface_counter", - "VK_EXT_swapchain_colorspace", - "VK_KHR_external_fence_capabilities", - "VK_KHR_get_surface_capabilities2", - "VK_KHR_get_display_properties2", -#if defined( VK_USE_PLATFORM_IOS_MVK ) - "VK_MVK_ios_surface", -#endif /*VK_USE_PLATFORM_IOS_MVK*/ -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - "VK_MVK_macos_surface", -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - "VK_EXT_debug_utils", -#if defined( VK_USE_PLATFORM_FUCHSIA ) - "VK_FUCHSIA_imagepipe_surface", -#endif /*VK_USE_PLATFORM_FUCHSIA*/ -#if defined( VK_USE_PLATFORM_METAL_EXT ) - "VK_EXT_metal_surface", -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - "VK_KHR_surface_protected_capabilities", - "VK_EXT_validation_features", - "VK_EXT_headless_surface", - "VK_EXT_surface_maintenance1", - "VK_EXT_acquire_drm_display", -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - "VK_EXT_directfb_surface", -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - "VK_QNX_screen_surface", -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - "VK_KHR_portability_enumeration", - "VK_GOOGLE_surfaceless_query", - "VK_LUNARG_direct_driver_loading", - "VK_KHR_surface_maintenance1", - "VK_EXT_layer_settings", - "VK_NV_display_stereo", -#if defined( VK_USE_PLATFORM_OHOS ) - "VK_OHOS_surface" -#endif /*VK_USE_PLATFORM_OHOS*/ - }; - return instanceExtensions; - } - - VULKAN_HPP_INLINE std::map>> const & getExtensionDepends( std::string const & extension ) - { - static const std::map>> noDependencies; - static const std::map>>> dependencies = { - { "VK_KHR_swapchain", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } }, - { "VK_KHR_display", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } }, - { "VK_KHR_display_swapchain", - { { "VK_VERSION_1_0", - { { - "VK_KHR_display", - "VK_KHR_swapchain", - } } } } } -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - , - { "VK_KHR_xlib_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ -#if defined( VK_USE_PLATFORM_XCB_KHR ) - , - { "VK_KHR_xcb_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_XCB_KHR*/ -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - , - { "VK_KHR_wayland_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - , - { "VK_KHR_android_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - , - { "VK_KHR_win32_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - , - { "VK_EXT_debug_marker", - { { "VK_VERSION_1_0", - { { - "VK_EXT_debug_report", - } } } } }, - { "VK_KHR_video_queue", - { { "VK_VERSION_1_1", - { { - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_KHR_video_decode_queue", - { { "VK_VERSION_1_0", - { { - "VK_KHR_synchronization2", - "VK_KHR_video_queue", - } } }, - { "VK_VERSION_1_3", - { { - "VK_KHR_video_queue", - } } } } }, - { "VK_EXT_transform_feedback", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_video_encode_h264", - { { "VK_VERSION_1_0", - { { - "VK_KHR_video_encode_queue", - } } } } }, - { "VK_KHR_video_encode_h265", - { { "VK_VERSION_1_0", - { { - "VK_KHR_video_encode_queue", - } } } } }, - { "VK_KHR_video_decode_h264", - { { "VK_VERSION_1_0", - { { - "VK_KHR_video_decode_queue", - } } } } }, - { "VK_AMD_texture_gather_bias_lod", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_dynamic_rendering", - { { "VK_VERSION_1_0", - { { - "VK_KHR_depth_stencil_resolve", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_depth_stencil_resolve", - } } }, - { "VK_VERSION_1_2", { {} } } } } -#if defined( VK_USE_PLATFORM_GGP ) - , - { "VK_GGP_stream_descriptor_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_GGP*/ - , - { "VK_NV_corner_sampled_image", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_multiview", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_external_memory", - { { "VK_VERSION_1_0", - { { - "VK_NV_external_memory_capabilities", - } } } } } -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - , - { "VK_NV_external_memory_win32", - { { "VK_VERSION_1_0", - { { - "VK_NV_external_memory", - } } } } }, - { "VK_NV_win32_keyed_mutex", - { { "VK_VERSION_1_0", - { { - "VK_NV_external_memory_win32", - } } } } } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - , - { "VK_KHR_device_group", - { { "VK_VERSION_1_0", - { { - "VK_KHR_device_group_creation", - } } } } } -#if defined( VK_USE_PLATFORM_VI_NN ) - , - { "VK_NN_vi_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_VI_NN*/ - , - { "VK_EXT_texture_compression_astc_hdr", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_astc_decode_mode", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_pipeline_robustness", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_external_memory_capabilities", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_external_memory", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_memory_capabilities", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - , - { "VK_KHR_external_memory_win32", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_memory", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - , - { "VK_KHR_external_memory_fd", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_memory", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - , - { "VK_KHR_win32_keyed_mutex", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_memory_win32", - } } } } } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - , - { "VK_KHR_external_semaphore_capabilities", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_external_semaphore", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_semaphore_capabilities", - } } } } } -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - , - { "VK_KHR_external_semaphore_win32", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_semaphore", - } } } } } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - , - { "VK_KHR_external_semaphore_fd", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_semaphore", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_push_descriptor", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_conditional_rendering", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_float16_int8", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_16bit_storage", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_storage_buffer_storage_class", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_incremental_present", - { { "VK_VERSION_1_0", - { { - "VK_KHR_swapchain", - } } } } }, - { "VK_EXT_direct_mode_display", - { { "VK_VERSION_1_0", - { { - "VK_KHR_display", - } } } } } -#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - , - { "VK_EXT_acquire_xlib_display", - { { "VK_VERSION_1_0", - { { - "VK_EXT_direct_mode_display", - } } } } } -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - , - { "VK_EXT_display_surface_counter", - { { "VK_VERSION_1_0", - { { - "VK_KHR_display", - } } } } }, - { "VK_EXT_display_control", - { { "VK_VERSION_1_0", - { { - "VK_EXT_display_surface_counter", - "VK_KHR_swapchain", - } } } } }, - { "VK_GOOGLE_display_timing", - { { "VK_VERSION_1_0", - { { - "VK_KHR_swapchain", - } } } } }, - { "VK_NVX_multiview_per_view_attributes", - { { "VK_VERSION_1_0", - { { - "VK_KHR_multiview", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_discard_rectangles", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_conservative_rasterization", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_depth_clip_enable", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_swapchain_colorspace", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } }, - { "VK_EXT_hdr_metadata", - { { "VK_VERSION_1_0", - { { - "VK_KHR_swapchain", - } } } } }, - { "VK_KHR_imageless_framebuffer", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_image_format_list", - "VK_KHR_maintenance2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_image_format_list", - } } }, - { "VK_VERSION_1_2", { {} } } } }, - { "VK_KHR_create_renderpass2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_maintenance2", - "VK_KHR_multiview", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_IMG_relaxed_line_rasterization", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shared_presentable_image", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_get_surface_capabilities2", - "VK_KHR_swapchain", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_get_surface_capabilities2", - "VK_KHR_swapchain", - } } } } }, - { "VK_KHR_external_fence_capabilities", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_external_fence", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_fence_capabilities", - } } } } } -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - , - { "VK_KHR_external_fence_win32", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_fence", - } } } } } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - , - { "VK_KHR_external_fence_fd", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_fence", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_performance_query", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_get_surface_capabilities2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } }, - { "VK_KHR_variable_pointers", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_storage_buffer_storage_class", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_get_display_properties2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_display", - } } } } } -#if defined( VK_USE_PLATFORM_IOS_MVK ) - , - { "VK_MVK_ios_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_IOS_MVK*/ -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - , - { "VK_MVK_macos_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - , - { "VK_EXT_external_memory_dma_buf", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_memory_fd", - } } } } }, - { "VK_EXT_queue_family_foreign", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_memory", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_dedicated_allocation", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_memory_requirements2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - , - { "VK_ANDROID_external_memory_android_hardware_buffer", - { { "VK_VERSION_1_0", - { { - "VK_EXT_queue_family_foreign", - "VK_KHR_dedicated_allocation", - "VK_KHR_external_memory", - "VK_KHR_sampler_ycbcr_conversion", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_queue_family_foreign", - } } } } } -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - , - { "VK_EXT_sampler_filter_minmax", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - , - { "VK_AMDX_shader_enqueue", - { { "VK_VERSION_1_0", - { { - "VK_EXT_extended_dynamic_state", - "VK_KHR_maintenance5", - "VK_KHR_pipeline_library", - "VK_KHR_spirv_1_4", - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_3", - { { - "VK_KHR_maintenance5", - "VK_KHR_pipeline_library", - } } } } } -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - , - { "VK_EXT_descriptor_heap", - { { "VK_VERSION_1_0", - { { - "VK_KHR_buffer_device_address", - "VK_KHR_maintenance5", - } } }, - { "VK_VERSION_1_2", - { { - "VK_KHR_maintenance5", - } } } } }, - { "VK_EXT_inline_uniform_block", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_maintenance1", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_bfloat16", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_sample_locations", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_blend_operation_advanced", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_acceleration_structure", - { { "VK_VERSION_1_1", - { { - "VK_EXT_descriptor_indexing", - "VK_KHR_buffer_device_address", - "VK_KHR_deferred_host_operations", - } } }, - { "VK_VERSION_1_2", - { { - "VK_KHR_deferred_host_operations", - } } } } }, - { "VK_KHR_ray_tracing_pipeline", - { { "VK_VERSION_1_0", - { { - "VK_KHR_acceleration_structure", - "VK_KHR_spirv_1_4", - } } }, - { "VK_VERSION_1_2", - { { - "VK_KHR_acceleration_structure", - } } } } }, - { "VK_KHR_ray_query", - { { "VK_VERSION_1_0", - { { - "VK_KHR_acceleration_structure", - "VK_KHR_spirv_1_4", - } } }, - { "VK_VERSION_1_2", - { { - "VK_KHR_acceleration_structure", - } } } } }, - { "VK_NV_shader_sm_builtins", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_sampler_ycbcr_conversion", - { { "VK_VERSION_1_0", - { { - "VK_KHR_bind_memory2", - "VK_KHR_get_memory_requirements2", - "VK_KHR_get_physical_device_properties2", - "VK_KHR_maintenance1", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_image_drm_format_modifier", - { { "VK_VERSION_1_0", - { { - "VK_KHR_bind_memory2", - "VK_KHR_get_physical_device_properties2", - "VK_KHR_image_format_list", - "VK_KHR_sampler_ycbcr_conversion", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_image_format_list", - } } }, - { "VK_VERSION_1_2", { {} } } } }, - { "VK_EXT_descriptor_indexing", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_maintenance3", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - , - { "VK_KHR_portability_subset", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - , - { "VK_NV_shading_rate_image", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_ray_tracing", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_memory_requirements2", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_representative_fragment_test", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_maintenance3", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_subgroup_extended_types", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_8bit_storage", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_storage_buffer_storage_class", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_external_memory_host", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_memory", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_atomic_int64", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_clock", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_calibrated_timestamps", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_AMD_shader_core_properties", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_video_decode_h265", - { { "VK_VERSION_1_0", - { { - "VK_KHR_video_decode_queue", - } } } } }, - { "VK_KHR_global_priority", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_vertex_attribute_divisor", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_USE_PLATFORM_GGP ) - , - { "VK_GGP_frame_token", - { { "VK_VERSION_1_0", - { { - "VK_GGP_stream_descriptor_surface", - "VK_KHR_swapchain", - } } } } } -#endif /*VK_USE_PLATFORM_GGP*/ - , - { "VK_KHR_driver_properties", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_float_controls", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_shader_subgroup_partitioned", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_depth_stencil_resolve", - { { "VK_VERSION_1_0", - { { - "VK_KHR_create_renderpass2", - } } }, - { "VK_VERSION_1_2", { {} } } } }, - { "VK_KHR_swapchain_mutable_format", - { { "VK_VERSION_1_0", - { { - "VK_KHR_image_format_list", - "VK_KHR_maintenance2", - "VK_KHR_swapchain", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_image_format_list", - "VK_KHR_swapchain", - } } }, - { "VK_VERSION_1_2", - { { - "VK_KHR_swapchain", - } } } } }, - { "VK_NV_compute_shader_derivatives", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_mesh_shader", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_fragment_shader_barycentric", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_shader_image_footprint", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_scissor_exclusive", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_device_diagnostic_checkpoints", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_timeline_semaphore", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_present_timing", - { { "VK_VERSION_1_0", - { { - "VK_KHR_calibrated_timestamps", - "VK_KHR_get_surface_capabilities2", - "VK_KHR_present_id2", - "VK_KHR_swapchain", - } } } } }, - { "VK_INTEL_shader_integer_functions2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_vulkan_memory_model", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_pci_bus_info", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_AMD_display_native_hdr", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_get_surface_capabilities2", - "VK_KHR_swapchain", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_get_surface_capabilities2", - "VK_KHR_swapchain", - } } } } } -#if defined( VK_USE_PLATFORM_FUCHSIA ) - , - { "VK_FUCHSIA_imagepipe_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - , - { "VK_KHR_shader_terminate_invocation", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_USE_PLATFORM_METAL_EXT ) - , - { "VK_EXT_metal_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - , - { "VK_EXT_fragment_density_map", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_scalar_block_layout", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_subgroup_size_control", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_fragment_shading_rate", - { { "VK_VERSION_1_0", - { { - "VK_KHR_create_renderpass2", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_create_renderpass2", - } } }, - { "VK_VERSION_1_2", { {} } } } }, - { "VK_AMD_shader_core_properties2", - { { "VK_VERSION_1_0", - { { - "VK_AMD_shader_core_properties", - } } } } }, - { "VK_AMD_device_coherent_memory", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_dynamic_rendering_local_read", - { { "VK_VERSION_1_0", - { { - "VK_KHR_dynamic_rendering", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_EXT_shader_image_atomic_int64", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_quad_control", - { { "VK_VERSION_1_1", - { { - "VK_KHR_shader_maximal_reconvergence", - "VK_KHR_vulkan_memory_model", - } } }, - { "VK_VERSION_1_2", - { { - "VK_KHR_shader_maximal_reconvergence", - } } } } }, - { "VK_KHR_spirv_1_4", - { { "VK_VERSION_1_1", - { { - "VK_KHR_shader_float_controls", - } } } } }, - { "VK_EXT_memory_budget", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_memory_priority", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_surface_protected_capabilities", - { { "VK_VERSION_1_1", - { { - "VK_KHR_get_surface_capabilities2", - } } } } }, - { "VK_NV_dedicated_allocation_image_aliasing", - { { "VK_VERSION_1_0", - { { - "VK_KHR_dedicated_allocation", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_separate_depth_stencil_layouts", - { { "VK_VERSION_1_0", - { { - "VK_KHR_create_renderpass2", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_create_renderpass2", - } } }, - { "VK_VERSION_1_2", { {} } } } }, - { "VK_EXT_buffer_device_address", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_present_wait", - { { "VK_VERSION_1_0", - { { - "VK_KHR_present_id", - "VK_KHR_swapchain", - } } } } }, - { "VK_NV_cooperative_matrix", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_coverage_reduction_mode", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_NV_framebuffer_mixed_samples", - } } }, - { "VK_VERSION_1_1", - { { - "VK_NV_framebuffer_mixed_samples", - } } } } }, - { "VK_EXT_fragment_shader_interlock", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_ycbcr_image_arrays", - { { "VK_VERSION_1_0", - { { - "VK_KHR_sampler_ycbcr_conversion", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_uniform_buffer_standard_layout", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_provoking_vertex", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - , - { "VK_EXT_full_screen_exclusive", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_get_surface_capabilities2", - "VK_KHR_surface", - "VK_KHR_swapchain", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_get_surface_capabilities2", - "VK_KHR_surface", - "VK_KHR_swapchain", - } } } } } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - , - { "VK_EXT_headless_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } }, - { "VK_KHR_buffer_device_address", - { { "VK_VERSION_1_0", - { { - "VK_KHR_device_group", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_line_rasterization", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_shader_atomic_float", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_host_query_reset", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_index_type_uint8", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_extended_dynamic_state", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_pipeline_executable_properties", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_host_image_copy", - { { "VK_VERSION_1_0", - { { - "VK_KHR_copy_commands2", - "VK_KHR_format_feature_flags2", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_copy_commands2", - "VK_KHR_format_feature_flags2", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_EXT_map_memory_placed", - { { "VK_VERSION_1_0", - { { - "VK_KHR_map_memory2", - } } }, - { "VK_VERSION_1_4", { {} } } } }, - { "VK_EXT_shader_atomic_float2", - { { "VK_VERSION_1_0", - { { - "VK_EXT_shader_atomic_float", - } } } } }, - { "VK_EXT_surface_maintenance1", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_surface_capabilities2", - "VK_KHR_surface", - } } } } }, - { "VK_EXT_swapchain_maintenance1", - { { "VK_VERSION_1_0", - { { - "VK_EXT_surface_maintenance1", - "VK_KHR_get_physical_device_properties2", - "VK_KHR_swapchain", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_surface_maintenance1", - "VK_KHR_swapchain", - } } } } }, - { "VK_EXT_shader_demote_to_helper_invocation", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_device_generated_commands", - { { "VK_VERSION_1_1", - { { - "VK_KHR_buffer_device_address", - } } }, - { "VK_VERSION_1_2", { {} } } } }, - { "VK_NV_inherited_viewport_scissor", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_integer_dot_product", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_texel_buffer_alignment", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_depth_bias_control", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_device_memory_report", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_acquire_drm_display", - { { "VK_VERSION_1_0", - { { - "VK_EXT_direct_mode_display", - } } } } }, - { "VK_EXT_robustness2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_custom_border_color", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_texture_compression_astc_3d", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_present_barrier", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_get_surface_capabilities2", - "VK_KHR_surface", - "VK_KHR_swapchain", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_get_surface_capabilities2", - "VK_KHR_surface", - "VK_KHR_swapchain", - } } } } }, - { "VK_KHR_present_id", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_swapchain", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_swapchain", - } } } } }, - { "VK_EXT_private_data", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_pipeline_creation_cache_control", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_video_encode_queue", - { { "VK_VERSION_1_0", - { { - "VK_KHR_synchronization2", - "VK_KHR_video_queue", - } } }, - { "VK_VERSION_1_3", - { { - "VK_KHR_video_queue", - } } } } }, - { "VK_NV_device_diagnostics_config", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - , - { "VK_NV_cuda_kernel_launch", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - , - { "VK_QCOM_tile_shading", - { { "VK_VERSION_1_0", - { { - "VK_QCOM_tile_properties", - } } } } }, - { "VK_KHR_synchronization2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_descriptor_buffer", - { { "VK_VERSION_1_0", - { { - "VK_EXT_descriptor_indexing", - "VK_KHR_buffer_device_address", - "VK_KHR_get_physical_device_properties2", - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_descriptor_indexing", - "VK_KHR_buffer_device_address", - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_2", - { { - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_EXT_graphics_pipeline_library", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_pipeline_library", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_pipeline_library", - } } } } }, - { "VK_AMD_shader_early_and_late_fragment_tests", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_fragment_shader_barycentric", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_subgroup_uniform_control_flow", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_zero_initialize_workgroup_memory", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_fragment_shading_rate_enums", - { { "VK_VERSION_1_0", - { { - "VK_KHR_fragment_shading_rate", - } } } } }, - { "VK_NV_ray_tracing_motion_blur", - { { "VK_VERSION_1_0", - { { - "VK_KHR_ray_tracing_pipeline", - } } } } }, - { "VK_EXT_mesh_shader", - { { "VK_VERSION_1_0", - { { - "VK_KHR_spirv_1_4", - } } }, - { "VK_VERSION_1_2", { {} } } } }, - { "VK_EXT_ycbcr_2plane_444_formats", - { { "VK_VERSION_1_0", - { { - "VK_KHR_sampler_ycbcr_conversion", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_fragment_density_map2", - { { "VK_VERSION_1_0", - { { - "VK_EXT_fragment_density_map", - } } } } }, - { "VK_QCOM_rotated_copy_commands", - { { "VK_VERSION_1_0", - { { - "VK_KHR_copy_commands2", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_EXT_image_robustness", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_workgroup_memory_explicit_layout", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_copy_commands2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_image_compression_control", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_attachment_feedback_loop_layout", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_4444_formats", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_device_fault", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_ARM_rasterization_order_attachment_access", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_rgba10x6_formats", - { { "VK_VERSION_1_0", - { { - "VK_KHR_sampler_ycbcr_conversion", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - , - { "VK_NV_acquire_winrt_display", - { { "VK_VERSION_1_0", - { { - "VK_EXT_direct_mode_display", - } } } } } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - , - { "VK_EXT_directfb_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - , - { "VK_VALVE_mutable_descriptor_type", - { { "VK_VERSION_1_0", - { { - "VK_KHR_maintenance3", - } } } } }, - { "VK_EXT_vertex_input_dynamic_state", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_physical_device_drm", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_device_address_binding_report", - { { "VK_VERSION_1_0", - { { - "VK_EXT_debug_utils", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_debug_utils", - } } } } }, - { "VK_EXT_depth_clip_control", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_primitive_topology_list_restart", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_format_feature_flags2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_present_mode_fifo_latest_ready", - { { "VK_VERSION_1_0", - { { - "VK_KHR_swapchain", - } } } } } -#if defined( VK_USE_PLATFORM_FUCHSIA ) - , - { "VK_FUCHSIA_external_memory", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_memory", - "VK_KHR_external_memory_capabilities", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_FUCHSIA_external_semaphore", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_semaphore", - "VK_KHR_external_semaphore_capabilities", - } } } } }, - { "VK_FUCHSIA_buffer_collection", - { { "VK_VERSION_1_0", - { { - "VK_FUCHSIA_external_memory", - "VK_KHR_sampler_ycbcr_conversion", - } } }, - { "VK_VERSION_1_1", - { { - "VK_FUCHSIA_external_memory", - } } } } } -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - , - { "VK_HUAWEI_subpass_shading", - { { "VK_VERSION_1_0", - { { - "VK_KHR_create_renderpass2", - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_2", - { { - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_HUAWEI_invocation_mask", - { { "VK_VERSION_1_0", - { { - "VK_KHR_ray_tracing_pipeline", - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_3", - { { - "VK_KHR_ray_tracing_pipeline", - } } } } }, - { "VK_NV_external_memory_rdma", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_memory", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_pipeline_properties", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_frame_boundary", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_multisampled_render_to_single_sampled", - { { "VK_VERSION_1_0", - { { - "VK_KHR_create_renderpass2", - "VK_KHR_depth_stencil_resolve", - } } }, - { "VK_VERSION_1_2", { {} } } } }, - { "VK_EXT_extended_dynamic_state2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - , - { "VK_QNX_screen_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - , - { "VK_EXT_color_write_enable", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_primitives_generated_query", - { { "VK_VERSION_1_0", - { { - "VK_EXT_transform_feedback", - } } } } }, - { "VK_KHR_ray_tracing_maintenance1", - { { "VK_VERSION_1_0", - { { - "VK_KHR_acceleration_structure", - } } } } }, - { "VK_KHR_shader_untyped_pointers", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } } } }, - { "VK_EXT_global_priority_query", - { { "VK_VERSION_1_0", - { { - "VK_EXT_global_priority", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_global_priority", - } } } } }, - { "VK_VALVE_video_encode_rgb_conversion", - { { "VK_VERSION_1_0", - { { - "VK_KHR_sampler_ycbcr_conversion", - "VK_KHR_video_encode_queue", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_video_encode_queue", - } } } } }, - { "VK_EXT_image_view_min_lod", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_multi_draw", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_image_2d_view_of_3d", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_maintenance1", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_shader_tile_image", { { "VK_VERSION_1_3", { {} } } } }, - { "VK_EXT_opacity_micromap", - { { "VK_VERSION_1_0", - { { - "VK_KHR_acceleration_structure", - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_3", - { { - "VK_KHR_acceleration_structure", - } } } } } -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - , - { "VK_NV_displacement_micromap", - { { "VK_VERSION_1_0", - { { - "VK_EXT_opacity_micromap", - } } } } } -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - , - { "VK_HUAWEI_cluster_culling_shader", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_border_color_swizzle", - { { "VK_VERSION_1_0", - { { - "VK_EXT_custom_border_color", - } } } } }, - { "VK_EXT_pageable_device_local_memory", - { { "VK_VERSION_1_0", - { { - "VK_EXT_memory_priority", - } } } } }, - { "VK_KHR_maintenance4", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_ARM_shader_core_properties", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_subgroup_rotate", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_ARM_scheduling_controls", - { { "VK_VERSION_1_0", - { { - "VK_ARM_shader_core_builtins", - } } } } }, - { "VK_EXT_image_sliced_view_of_3d", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_maintenance1", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_VALVE_descriptor_set_host_mapping", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_depth_clamp_zero_one", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_non_seamless_cube_map", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_ARM_render_pass_striped", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_QCOM_fragment_density_map_offset", - { { "VK_VERSION_1_0", - { { - "VK_EXT_fragment_density_map", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_fragment_density_map", - } } } } }, - { "VK_NV_copy_memory_indirect", - { { "VK_VERSION_1_0", - { { - "VK_KHR_buffer_device_address", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_buffer_device_address", - } } }, - { "VK_VERSION_1_2", { {} } } } }, - { "VK_NV_memory_decompression", - { { "VK_VERSION_1_0", - { { - "VK_KHR_buffer_device_address", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_buffer_device_address", - } } }, - { "VK_VERSION_1_2", { {} } } } }, - { "VK_NV_device_generated_commands_compute", - { { "VK_VERSION_1_0", - { { - "VK_NV_device_generated_commands", - } } } } }, - { "VK_NV_ray_tracing_linear_swept_spheres", - { { "VK_VERSION_1_0", - { { - "VK_KHR_ray_tracing_pipeline", - } } } } }, - { "VK_NV_linear_color_attachment", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_GOOGLE_surfaceless_query", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } }, - { "VK_KHR_shader_maximal_reconvergence", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_image_compression_control_swapchain", - { { "VK_VERSION_1_0", - { { - "VK_EXT_image_compression_control", - } } } } }, - { "VK_QCOM_image_processing", - { { "VK_VERSION_1_0", - { { - "VK_KHR_format_feature_flags2", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_EXT_nested_command_buffer", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_USE_PLATFORM_OHOS ) - , - { "VK_OHOS_external_memory", - { { "VK_VERSION_1_0", - { { - "VK_EXT_queue_family_foreign", - "VK_KHR_dedicated_allocation", - "VK_KHR_external_memory", - "VK_KHR_sampler_ycbcr_conversion", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_queue_family_foreign", - } } } } } -#endif /*VK_USE_PLATFORM_OHOS*/ - , - { "VK_EXT_external_memory_acquire_unmodified", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_memory", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_extended_dynamic_state3", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_subpass_merge_feedback", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_ARM_tensors", { { "VK_VERSION_1_3", { {} } } } }, - { "VK_EXT_shader_module_identifier", - { { "VK_VERSION_1_0", - { { - "VK_EXT_pipeline_creation_cache_control", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_pipeline_creation_cache_control", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_EXT_rasterization_order_attachment_access", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_optical_flow", - { { "VK_VERSION_1_0", - { { - "VK_KHR_format_feature_flags2", - "VK_KHR_get_physical_device_properties2", - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_format_feature_flags2", - "VK_KHR_synchronization2", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_EXT_legacy_dithering", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_pipeline_protected_access", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - , - { "VK_ANDROID_external_format_resolve", - { { "VK_VERSION_1_0", - { { - "VK_ANDROID_external_memory_android_hardware_buffer", - } } } } } -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - , - { "VK_KHR_maintenance5", - { { "VK_VERSION_1_1", - { { - "VK_KHR_dynamic_rendering", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_AMD_anti_lag", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - , - { "VK_AMDX_dense_geometry_format", - { { "VK_VERSION_1_0", - { { - "VK_KHR_acceleration_structure", - "VK_KHR_maintenance5", - } } }, - { "VK_VERSION_1_4", - { { - "VK_KHR_acceleration_structure", - } } } } } -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - , - { "VK_KHR_present_id2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_surface_capabilities2", - "VK_KHR_surface", - "VK_KHR_swapchain", - } } } } }, - { "VK_KHR_present_wait2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_surface_capabilities2", - "VK_KHR_present_id2", - "VK_KHR_surface", - "VK_KHR_swapchain", - } } } } }, - { "VK_KHR_ray_tracing_position_fetch", - { { "VK_VERSION_1_0", - { { - "VK_KHR_acceleration_structure", - } } } } }, - { "VK_EXT_shader_object", - { { "VK_VERSION_1_0", - { { - "VK_KHR_dynamic_rendering", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_dynamic_rendering", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_KHR_pipeline_binary", - { { "VK_VERSION_1_0", - { { - "VK_KHR_maintenance5", - } } }, - { "VK_VERSION_1_4", { {} } } } }, - { "VK_QCOM_tile_properties", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_SEC_amigo_profiling", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_surface_maintenance1", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_surface_capabilities2", - "VK_KHR_surface", - } } } } }, - { "VK_KHR_swapchain_maintenance1", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - "VK_KHR_surface_maintenance1", - "VK_KHR_swapchain", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_surface_maintenance1", - "VK_KHR_swapchain", - } } } } }, - { "VK_QCOM_multiview_per_view_viewports", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_ray_tracing_invocation_reorder", - { { "VK_VERSION_1_0", - { { - "VK_KHR_ray_tracing_pipeline", - } } } } }, - { "VK_NV_cooperative_vector", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_extended_sparse_address_space", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_mutable_descriptor_type", - { { "VK_VERSION_1_0", - { { - "VK_KHR_maintenance3", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_legacy_vertex_attributes", - { { "VK_VERSION_1_0", - { { - "VK_EXT_vertex_input_dynamic_state", - } } } } }, - { "VK_ARM_shader_core_builtins", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_pipeline_library_group_handles", - { { "VK_VERSION_1_0", - { { - "VK_KHR_pipeline_library", - "VK_KHR_ray_tracing_pipeline", - } } } } }, - { "VK_EXT_dynamic_rendering_unused_attachments", - { { "VK_VERSION_1_0", - { { - "VK_KHR_dynamic_rendering", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_KHR_dynamic_rendering", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_KHR_internally_synchronized_queues", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_low_latency2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_present_id", - "VK_KHR_timeline_semaphore", - }, - { - "VK_KHR_present_id2", - "VK_KHR_timeline_semaphore", - } } }, - { "VK_VERSION_1_2", - { { - "VK_KHR_present_id", - }, - { - "VK_KHR_present_id2", - } } } } }, - { "VK_KHR_cooperative_matrix", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_ARM_data_graph", - { { "VK_VERSION_1_3", - { { - "VK_KHR_deferred_host_operations", - "VK_KHR_maintenance5", - } } } } }, - { "VK_QCOM_multiview_per_view_render_areas", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_compute_shader_derivatives", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_video_decode_av1", - { { "VK_VERSION_1_0", - { { - "VK_KHR_video_decode_queue", - } } } } }, - { "VK_KHR_video_encode_av1", - { { "VK_VERSION_1_0", - { { - "VK_KHR_video_encode_queue", - } } } } }, - { "VK_KHR_video_decode_vp9", - { { "VK_VERSION_1_0", - { { - "VK_KHR_video_decode_queue", - } } } } }, - { "VK_KHR_video_maintenance1", - { { "VK_VERSION_1_0", - { { - "VK_KHR_video_queue", - } } } } }, - { "VK_NV_per_stage_descriptor_set", - { { "VK_VERSION_1_0", - { { - "VK_KHR_maintenance6", - } } }, - { "VK_VERSION_1_4", { {} } } } }, - { "VK_QCOM_image_processing2", - { { "VK_VERSION_1_0", - { { - "VK_QCOM_image_processing", - } } } } }, - { "VK_QCOM_filter_cubic_weights", - { { "VK_VERSION_1_0", - { { - "VK_EXT_filter_cubic", - } } } } }, - { "VK_QCOM_ycbcr_degamma", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_QCOM_filter_cubic_clamp", - { { "VK_VERSION_1_0", - { { - "VK_EXT_filter_cubic", - "VK_EXT_sampler_filter_minmax", - } } }, - { "VK_VERSION_1_2", - { { - "VK_EXT_filter_cubic", - } } } } }, - { "VK_EXT_attachment_feedback_loop_dynamic_state", - { { "VK_VERSION_1_0", - { { - "VK_EXT_attachment_feedback_loop_layout", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_attachment_feedback_loop_layout", - } } } } }, - { "VK_KHR_vertex_attribute_divisor", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_unified_image_layouts", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_float_controls2", - { { "VK_VERSION_1_1", - { { - "VK_KHR_shader_float_controls", - } } } } } -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - , - { "VK_QNX_external_memory_screen_buffer", - { { "VK_VERSION_1_0", - { { - "VK_EXT_queue_family_foreign", - "VK_KHR_dedicated_allocation", - "VK_KHR_external_memory", - "VK_KHR_sampler_ycbcr_conversion", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_queue_family_foreign", - } } } } } -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - , - { "VK_MSFT_layered_driver", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_index_type_uint8", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_line_rasterization", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_calibrated_timestamps", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_expect_assume", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_QCOM_tile_memory_heap", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_memory_requirements2", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_copy_memory_indirect", - { { "VK_VERSION_1_0", - { { - "VK_KHR_buffer_device_address", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_2", { {} } } } }, - { "VK_EXT_memory_decompression", - { { "VK_VERSION_1_0", - { { - "VK_KHR_buffer_device_address", - "VK_KHR_get_physical_device_properties2", - } } } } }, - { "VK_NV_display_stereo", - { { "VK_VERSION_1_0", - { { - "VK_KHR_display", - "VK_KHR_get_display_properties2", - } } } } }, - { "VK_KHR_video_encode_intra_refresh", - { { "VK_VERSION_1_0", - { { - "VK_KHR_video_encode_queue", - } } } } }, - { "VK_KHR_video_encode_quantization_map", - { { "VK_VERSION_1_0", - { { - "VK_KHR_format_feature_flags2", - "VK_KHR_video_encode_queue", - } } }, - { "VK_VERSION_1_3", - { { - "VK_KHR_video_encode_queue", - } } } } }, - { "VK_NV_raw_access_chains", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_relaxed_extended_instruction", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_command_buffer_inheritance", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_shader_atomic_float16_vector", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_shader_replicated_composites", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_shader_float8", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_ray_tracing_validation", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_cluster_acceleration_structure", - { { "VK_VERSION_1_0", - { { - "VK_KHR_acceleration_structure", - } } } } }, - { "VK_NV_partitioned_acceleration_structure", - { { "VK_VERSION_1_0", - { { - "VK_KHR_acceleration_structure", - } } } } }, - { "VK_EXT_device_generated_commands", - { { "VK_VERSION_1_0", - { { - "VK_KHR_buffer_device_address", - "VK_KHR_maintenance5", - } } }, - { "VK_VERSION_1_2", - { { - "VK_KHR_maintenance5", - } } }, - { "VK_VERSION_1_3", { {} } } } }, - { "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } }, - { "VK_MESA_image_alignment_control", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_shader_fma", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_ray_tracing_invocation_reorder", - { { "VK_VERSION_1_0", - { { - "VK_KHR_ray_tracing_pipeline", - } } } } }, - { "VK_EXT_depth_clamp_control", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_maintenance9", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_video_maintenance2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_video_queue", - } } } } } -#if defined( VK_USE_PLATFORM_OHOS ) - , - { "VK_OHOS_surface", - { { "VK_VERSION_1_0", - { { - "VK_KHR_surface", - } } } } } -#endif /*VK_USE_PLATFORM_OHOS*/ - , - { "VK_HUAWEI_hdr_vivid", - { { "VK_VERSION_1_0", - { { - "VK_EXT_hdr_metadata", - "VK_KHR_get_physical_device_properties2", - "VK_KHR_swapchain", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_hdr_metadata", - "VK_KHR_swapchain", - } } } } }, - { "VK_NV_cooperative_matrix2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_cooperative_matrix", - } } } } }, - { "VK_ARM_pipeline_opacity_micromap", - { { "VK_VERSION_1_0", - { { - "VK_EXT_opacity_micromap", - } } } } } -#if defined( VK_USE_PLATFORM_METAL_EXT ) - , - { "VK_EXT_external_memory_metal", - { { "VK_VERSION_1_0", - { { - "VK_KHR_external_memory", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - , - { "VK_KHR_depth_clamp_zero_one", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_ARM_performance_counters_by_region", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_vertex_attribute_robustness", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_ARM_format_pack", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_VALVE_fragment_density_map_layered", - { { "VK_VERSION_1_0", - { { - "VK_EXT_fragment_density_map", - "VK_KHR_maintenance5", - } } }, - { "VK_VERSION_1_4", - { { - "VK_EXT_fragment_density_map", - } } } } }, - { "VK_KHR_robustness2", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - , - { "VK_NV_present_metering", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - , - { "VK_EXT_fragment_density_map_offset", - { { "VK_VERSION_1_0", - { { - "VK_EXT_fragment_density_map", - "VK_KHR_create_renderpass2", - "VK_KHR_dynamic_rendering", - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", - { { - "VK_EXT_fragment_density_map", - "VK_KHR_create_renderpass2", - "VK_KHR_dynamic_rendering", - } } }, - { "VK_VERSION_1_2", - { { - "VK_EXT_fragment_density_map", - "VK_KHR_dynamic_rendering", - } } }, - { "VK_VERSION_1_3", - { { - "VK_EXT_fragment_density_map", - } } } } }, - { "VK_EXT_zero_initialize_device_memory", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_KHR_present_mode_fifo_latest_ready", - { { "VK_VERSION_1_0", - { { - "VK_KHR_swapchain", - } } } } }, - { "VK_EXT_shader_64bit_indexing", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_custom_resolve", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_QCOM_data_graph_model", - { { "VK_VERSION_1_0", - { { - "VK_ARM_data_graph", - } } } } }, - { "VK_KHR_maintenance10", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_shader_long_vector", { { "VK_VERSION_1_2", { {} } } } }, - { "VK_SEC_pipeline_cache_incremental_mode", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_shader_uniform_buffer_unsized_array", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_NV_compute_occupancy_priority", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } }, - { "VK_EXT_shader_subgroup_partitioned", - { { "VK_VERSION_1_0", - { { - "VK_KHR_get_physical_device_properties2", - } } }, - { "VK_VERSION_1_1", { {} } } } } - }; - auto depIt = dependencies.find( extension ); - return ( depIt != dependencies.end() ) ? depIt->second : noDependencies; - } - - VULKAN_HPP_INLINE std::pair> const &> getExtensionDepends( std::string const & version, - std::string const & extension ) - { -#if !defined( NDEBUG ) - static std::set versions = { "VK_VERSION_1_0", "VK_VERSION_1_1", "VK_VERSION_1_2", "VK_VERSION_1_3", "VK_VERSION_1_4" }; - VULKAN_HPP_ASSERT( versions.find( version ) != versions.end() ); -#endif - static std::vector> noDependencies; - - std::map>> const & dependencies = getExtensionDepends( extension ); - if ( dependencies.empty() ) - { - return { true, noDependencies }; - } - auto depIt = dependencies.lower_bound( version ); - if ( ( depIt == dependencies.end() ) || ( depIt->first != version ) ) - { - depIt = std::prev( depIt ); - } - if ( depIt == dependencies.end() ) - { - return { false, noDependencies }; - } - else - { - return { true, depIt->second }; - } - } - - VULKAN_HPP_INLINE std::map const & getObsoletedExtensions() - { - static const std::map obsoletedExtensions = { { "VK_AMD_negative_viewport_height", "VK_KHR_maintenance1" } }; - return obsoletedExtensions; - } - - VULKAN_HPP_INLINE std::map const & getPromotedExtensions() - { - static const std::map promotedExtensions = { { "VK_KHR_sampler_mirror_clamp_to_edge", "VK_VERSION_1_2" }, - { "VK_EXT_debug_marker", "VK_EXT_debug_utils" }, - { "VK_AMD_draw_indirect_count", "VK_KHR_draw_indirect_count" }, - { "VK_KHR_dynamic_rendering", "VK_VERSION_1_3" }, - { "VK_KHR_multiview", "VK_VERSION_1_1" }, -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - { "VK_NV_win32_keyed_mutex", "VK_KHR_win32_keyed_mutex" }, -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - { "VK_KHR_get_physical_device_properties2", "VK_VERSION_1_1" }, - { "VK_KHR_device_group", "VK_VERSION_1_1" }, - { "VK_KHR_shader_draw_parameters", "VK_VERSION_1_1" }, - { "VK_EXT_texture_compression_astc_hdr", "VK_VERSION_1_3" }, - { "VK_EXT_pipeline_robustness", "VK_VERSION_1_4" }, - { "VK_KHR_maintenance1", "VK_VERSION_1_1" }, - { "VK_KHR_device_group_creation", "VK_VERSION_1_1" }, - { "VK_KHR_external_memory_capabilities", "VK_VERSION_1_1" }, - { "VK_KHR_external_memory", "VK_VERSION_1_1" }, - { "VK_KHR_external_semaphore_capabilities", "VK_VERSION_1_1" }, - { "VK_KHR_external_semaphore", "VK_VERSION_1_1" }, - { "VK_KHR_push_descriptor", "VK_VERSION_1_4" }, - { "VK_KHR_shader_float16_int8", "VK_VERSION_1_2" }, - { "VK_KHR_16bit_storage", "VK_VERSION_1_1" }, - { "VK_KHR_descriptor_update_template", "VK_VERSION_1_1" }, - { "VK_KHR_imageless_framebuffer", "VK_VERSION_1_2" }, - { "VK_KHR_create_renderpass2", "VK_VERSION_1_2" }, - { "VK_KHR_external_fence_capabilities", "VK_VERSION_1_1" }, - { "VK_KHR_external_fence", "VK_VERSION_1_1" }, - { "VK_KHR_maintenance2", "VK_VERSION_1_1" }, - { "VK_KHR_variable_pointers", "VK_VERSION_1_1" }, - { "VK_KHR_dedicated_allocation", "VK_VERSION_1_1" }, - { "VK_EXT_sampler_filter_minmax", "VK_VERSION_1_2" }, - { "VK_KHR_storage_buffer_storage_class", "VK_VERSION_1_1" }, - { "VK_EXT_inline_uniform_block", "VK_VERSION_1_3" }, - { "VK_KHR_relaxed_block_layout", "VK_VERSION_1_1" }, - { "VK_KHR_get_memory_requirements2", "VK_VERSION_1_1" }, - { "VK_KHR_image_format_list", "VK_VERSION_1_2" }, - { "VK_KHR_sampler_ycbcr_conversion", "VK_VERSION_1_1" }, - { "VK_KHR_bind_memory2", "VK_VERSION_1_1" }, - { "VK_EXT_descriptor_indexing", "VK_VERSION_1_2" }, - { "VK_EXT_shader_viewport_index_layer", "VK_VERSION_1_2" }, - { "VK_KHR_maintenance3", "VK_VERSION_1_1" }, - { "VK_KHR_draw_indirect_count", "VK_VERSION_1_2" }, - { "VK_QCOM_render_pass_shader_resolve", "VK_EXT_custom_resolve" }, - { "VK_EXT_global_priority", "VK_KHR_global_priority" }, - { "VK_KHR_shader_subgroup_extended_types", "VK_VERSION_1_2" }, - { "VK_KHR_8bit_storage", "VK_VERSION_1_2" }, - { "VK_KHR_shader_atomic_int64", "VK_VERSION_1_2" }, - { "VK_EXT_calibrated_timestamps", "VK_KHR_calibrated_timestamps" }, - { "VK_KHR_global_priority", "VK_VERSION_1_4" }, - { "VK_EXT_vertex_attribute_divisor", "VK_KHR_vertex_attribute_divisor" }, - { "VK_EXT_pipeline_creation_feedback", "VK_VERSION_1_3" }, - { "VK_KHR_driver_properties", "VK_VERSION_1_2" }, - { "VK_KHR_shader_float_controls", "VK_VERSION_1_2" }, - { "VK_NV_shader_subgroup_partitioned", "VK_EXT_shader_subgroup_partitioned" }, - { "VK_KHR_depth_stencil_resolve", "VK_VERSION_1_2" }, - { "VK_NV_compute_shader_derivatives", "VK_KHR_compute_shader_derivatives" }, - { "VK_NV_fragment_shader_barycentric", "VK_KHR_fragment_shader_barycentric" }, - { "VK_KHR_timeline_semaphore", "VK_VERSION_1_2" }, - { "VK_KHR_vulkan_memory_model", "VK_VERSION_1_2" }, - { "VK_KHR_shader_terminate_invocation", "VK_VERSION_1_3" }, - { "VK_EXT_scalar_block_layout", "VK_VERSION_1_2" }, - { "VK_EXT_subgroup_size_control", "VK_VERSION_1_3" }, - { "VK_KHR_dynamic_rendering_local_read", "VK_VERSION_1_4" }, - { "VK_KHR_spirv_1_4", "VK_VERSION_1_2" }, - { "VK_KHR_separate_depth_stencil_layouts", "VK_VERSION_1_2" }, - { "VK_EXT_tooling_info", "VK_VERSION_1_3" }, - { "VK_EXT_separate_stencil_usage", "VK_VERSION_1_2" }, - { "VK_KHR_uniform_buffer_standard_layout", "VK_VERSION_1_2" }, - { "VK_KHR_buffer_device_address", "VK_VERSION_1_2" }, - { "VK_EXT_line_rasterization", "VK_KHR_line_rasterization" }, - { "VK_EXT_host_query_reset", "VK_VERSION_1_2" }, - { "VK_EXT_index_type_uint8", "VK_KHR_index_type_uint8" }, - { "VK_EXT_extended_dynamic_state", "VK_VERSION_1_3" }, - { "VK_EXT_host_image_copy", "VK_VERSION_1_4" }, - { "VK_KHR_map_memory2", "VK_VERSION_1_4" }, - { "VK_EXT_surface_maintenance1", "VK_KHR_surface_maintenance1" }, - { "VK_EXT_swapchain_maintenance1", "VK_KHR_swapchain_maintenance1" }, - { "VK_EXT_shader_demote_to_helper_invocation", "VK_VERSION_1_3" }, - { "VK_KHR_shader_integer_dot_product", "VK_VERSION_1_3" }, - { "VK_EXT_texel_buffer_alignment", "VK_VERSION_1_3" }, - { "VK_EXT_robustness2", "VK_KHR_robustness2" }, - { "VK_KHR_shader_non_semantic_info", "VK_VERSION_1_3" }, - { "VK_EXT_private_data", "VK_VERSION_1_3" }, - { "VK_EXT_pipeline_creation_cache_control", "VK_VERSION_1_3" }, - { "VK_KHR_synchronization2", "VK_VERSION_1_3" }, - { "VK_KHR_zero_initialize_workgroup_memory", "VK_VERSION_1_3" }, - { "VK_EXT_ycbcr_2plane_444_formats", "VK_VERSION_1_3" }, - { "VK_EXT_image_robustness", "VK_VERSION_1_3" }, - { "VK_KHR_copy_commands2", "VK_VERSION_1_3" }, - { "VK_EXT_4444_formats", "VK_VERSION_1_3" }, - { "VK_ARM_rasterization_order_attachment_access", - "VK_EXT_rasterization_order_attachment_access" }, - { "VK_VALVE_mutable_descriptor_type", "VK_EXT_mutable_descriptor_type" }, - { "VK_KHR_format_feature_flags2", "VK_VERSION_1_3" }, - { "VK_EXT_present_mode_fifo_latest_ready", "VK_KHR_present_mode_fifo_latest_ready" }, - { "VK_EXT_extended_dynamic_state2", "VK_VERSION_1_3" }, - { "VK_EXT_global_priority_query", "VK_KHR_global_priority" }, - { "VK_EXT_load_store_op_none", "VK_KHR_load_store_op_none" }, - { "VK_KHR_maintenance4", "VK_VERSION_1_3" }, - { "VK_KHR_shader_subgroup_rotate", "VK_VERSION_1_4" }, - { "VK_EXT_depth_clamp_zero_one", "VK_KHR_depth_clamp_zero_one" }, - { "VK_QCOM_fragment_density_map_offset", "VK_EXT_fragment_density_map_offset" }, - { "VK_NV_copy_memory_indirect", "VK_KHR_copy_memory_indirect" }, - { "VK_NV_memory_decompression", "VK_EXT_memory_decompression" }, - { "VK_EXT_pipeline_protected_access", "VK_VERSION_1_4" }, - { "VK_KHR_maintenance5", "VK_VERSION_1_4" }, - { "VK_NV_ray_tracing_invocation_reorder", "VK_EXT_ray_tracing_invocation_reorder" }, - { "VK_KHR_vertex_attribute_divisor", "VK_VERSION_1_4" }, - { "VK_KHR_load_store_op_none", "VK_VERSION_1_4" }, - { "VK_KHR_shader_float_controls2", "VK_VERSION_1_4" }, - { "VK_KHR_index_type_uint8", "VK_VERSION_1_4" }, - { "VK_KHR_line_rasterization", "VK_VERSION_1_4" }, - { "VK_KHR_shader_expect_assume", "VK_VERSION_1_4" }, - { "VK_KHR_maintenance6", "VK_VERSION_1_4" }, - { "VK_EXT_vertex_attribute_robustness", "VK_KHR_maintenance9" } }; - return promotedExtensions; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & extension ) - { - if ( extension == "VK_EXT_debug_report" ) - { - return "VK_EXT_debug_utils"; - } - if ( extension == "VK_NV_glsl_shader" ) - { - return ""; - } - if ( extension == "VK_NV_dedicated_allocation" ) - { - return "VK_KHR_dedicated_allocation"; - } - if ( extension == "VK_AMD_gpu_shader_half_float" ) - { - return "VK_KHR_shader_float16_int8"; - } - if ( extension == "VK_IMG_format_pvrtc" ) - { - return ""; - } - if ( extension == "VK_NV_external_memory_capabilities" ) - { - return "VK_KHR_external_memory_capabilities"; - } - if ( extension == "VK_NV_external_memory" ) - { - return "VK_KHR_external_memory"; - } -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - if ( extension == "VK_NV_external_memory_win32" ) - { - return "VK_KHR_external_memory_win32"; - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - if ( extension == "VK_EXT_validation_flags" ) - { - return "VK_EXT_layer_settings"; - } - if ( extension == "VK_EXT_shader_subgroup_ballot" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_EXT_shader_subgroup_vote" ) - { - return "VK_VERSION_1_1"; - } -#if defined( VK_USE_PLATFORM_IOS_MVK ) - if ( extension == "VK_MVK_ios_surface" ) - { - return "VK_EXT_metal_surface"; - } -#endif /*VK_USE_PLATFORM_IOS_MVK*/ -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - if ( extension == "VK_MVK_macos_surface" ) - { - return "VK_EXT_metal_surface"; - } -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - if ( extension == "VK_AMD_gpu_shader_int16" ) - { - return "VK_KHR_shader_float16_int8"; - } - if ( extension == "VK_NV_ray_tracing" ) - { - return "VK_KHR_ray_tracing_pipeline"; - } - if ( extension == "VK_EXT_buffer_device_address" ) - { - return "VK_KHR_buffer_device_address"; - } - if ( extension == "VK_EXT_validation_features" ) - { - return "VK_EXT_layer_settings"; - } -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( extension == "VK_NV_displacement_micromap" ) - { - return "VK_NV_cluster_acceleration_structure"; - } -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - return ""; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & extension ) - { - if ( extension == "VK_AMD_negative_viewport_height" ) - { - return "VK_KHR_maintenance1"; - } - return ""; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & extension ) - { - if ( extension == "VK_KHR_sampler_mirror_clamp_to_edge" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_EXT_debug_marker" ) - { - return "VK_EXT_debug_utils"; - } - if ( extension == "VK_AMD_draw_indirect_count" ) - { - return "VK_KHR_draw_indirect_count"; - } - if ( extension == "VK_KHR_dynamic_rendering" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_KHR_multiview" ) - { - return "VK_VERSION_1_1"; - } -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - if ( extension == "VK_NV_win32_keyed_mutex" ) - { - return "VK_KHR_win32_keyed_mutex"; - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - if ( extension == "VK_KHR_get_physical_device_properties2" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_device_group" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_shader_draw_parameters" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_EXT_texture_compression_astc_hdr" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_pipeline_robustness" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_KHR_maintenance1" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_device_group_creation" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_external_memory_capabilities" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_external_memory" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_external_semaphore_capabilities" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_external_semaphore" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_push_descriptor" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_KHR_shader_float16_int8" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_16bit_storage" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_descriptor_update_template" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_imageless_framebuffer" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_create_renderpass2" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_external_fence_capabilities" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_external_fence" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_maintenance2" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_variable_pointers" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_dedicated_allocation" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_EXT_sampler_filter_minmax" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_storage_buffer_storage_class" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_EXT_inline_uniform_block" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_KHR_relaxed_block_layout" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_get_memory_requirements2" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_image_format_list" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_sampler_ycbcr_conversion" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_bind_memory2" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_EXT_descriptor_indexing" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_EXT_shader_viewport_index_layer" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_maintenance3" ) - { - return "VK_VERSION_1_1"; - } - if ( extension == "VK_KHR_draw_indirect_count" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_QCOM_render_pass_shader_resolve" ) - { - return "VK_EXT_custom_resolve"; - } - if ( extension == "VK_EXT_global_priority" ) - { - return "VK_KHR_global_priority"; - } - if ( extension == "VK_KHR_shader_subgroup_extended_types" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_8bit_storage" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_shader_atomic_int64" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_EXT_calibrated_timestamps" ) - { - return "VK_KHR_calibrated_timestamps"; - } - if ( extension == "VK_KHR_global_priority" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_EXT_vertex_attribute_divisor" ) - { - return "VK_KHR_vertex_attribute_divisor"; - } - if ( extension == "VK_EXT_pipeline_creation_feedback" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_KHR_driver_properties" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_shader_float_controls" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_NV_shader_subgroup_partitioned" ) - { - return "VK_EXT_shader_subgroup_partitioned"; - } - if ( extension == "VK_KHR_depth_stencil_resolve" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_NV_compute_shader_derivatives" ) - { - return "VK_KHR_compute_shader_derivatives"; - } - if ( extension == "VK_NV_fragment_shader_barycentric" ) - { - return "VK_KHR_fragment_shader_barycentric"; - } - if ( extension == "VK_KHR_timeline_semaphore" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_vulkan_memory_model" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_shader_terminate_invocation" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_scalar_block_layout" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_EXT_subgroup_size_control" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_KHR_dynamic_rendering_local_read" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_KHR_spirv_1_4" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_separate_depth_stencil_layouts" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_EXT_tooling_info" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_separate_stencil_usage" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_uniform_buffer_standard_layout" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_KHR_buffer_device_address" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_EXT_line_rasterization" ) - { - return "VK_KHR_line_rasterization"; - } - if ( extension == "VK_EXT_host_query_reset" ) - { - return "VK_VERSION_1_2"; - } - if ( extension == "VK_EXT_index_type_uint8" ) - { - return "VK_KHR_index_type_uint8"; - } - if ( extension == "VK_EXT_extended_dynamic_state" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_host_image_copy" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_KHR_map_memory2" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_EXT_surface_maintenance1" ) - { - return "VK_KHR_surface_maintenance1"; - } - if ( extension == "VK_EXT_swapchain_maintenance1" ) - { - return "VK_KHR_swapchain_maintenance1"; - } - if ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_KHR_shader_integer_dot_product" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_texel_buffer_alignment" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_robustness2" ) - { - return "VK_KHR_robustness2"; - } - if ( extension == "VK_KHR_shader_non_semantic_info" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_private_data" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_pipeline_creation_cache_control" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_KHR_synchronization2" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_image_robustness" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_KHR_copy_commands2" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_4444_formats" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_ARM_rasterization_order_attachment_access" ) - { - return "VK_EXT_rasterization_order_attachment_access"; - } - if ( extension == "VK_VALVE_mutable_descriptor_type" ) - { - return "VK_EXT_mutable_descriptor_type"; - } - if ( extension == "VK_KHR_format_feature_flags2" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_present_mode_fifo_latest_ready" ) - { - return "VK_KHR_present_mode_fifo_latest_ready"; - } - if ( extension == "VK_EXT_extended_dynamic_state2" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_EXT_global_priority_query" ) - { - return "VK_KHR_global_priority"; - } - if ( extension == "VK_EXT_load_store_op_none" ) - { - return "VK_KHR_load_store_op_none"; - } - if ( extension == "VK_KHR_maintenance4" ) - { - return "VK_VERSION_1_3"; - } - if ( extension == "VK_KHR_shader_subgroup_rotate" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_EXT_depth_clamp_zero_one" ) - { - return "VK_KHR_depth_clamp_zero_one"; - } - if ( extension == "VK_QCOM_fragment_density_map_offset" ) - { - return "VK_EXT_fragment_density_map_offset"; - } - if ( extension == "VK_NV_copy_memory_indirect" ) - { - return "VK_KHR_copy_memory_indirect"; - } - if ( extension == "VK_NV_memory_decompression" ) - { - return "VK_EXT_memory_decompression"; - } - if ( extension == "VK_EXT_pipeline_protected_access" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_KHR_maintenance5" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_NV_ray_tracing_invocation_reorder" ) - { - return "VK_EXT_ray_tracing_invocation_reorder"; - } - if ( extension == "VK_KHR_vertex_attribute_divisor" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_KHR_load_store_op_none" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_KHR_shader_float_controls2" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_KHR_index_type_uint8" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_KHR_line_rasterization" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_KHR_shader_expect_assume" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_KHR_maintenance6" ) - { - return "VK_VERSION_1_4"; - } - if ( extension == "VK_EXT_vertex_attribute_robustness" ) - { - return "VK_KHR_maintenance9"; - } - return ""; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeprecatedExtension( std::string const & extension ) - { - return ( extension == "VK_EXT_debug_report" ) || ( extension == "VK_NV_glsl_shader" ) || ( extension == "VK_NV_dedicated_allocation" ) || - ( extension == "VK_AMD_gpu_shader_half_float" ) || ( extension == "VK_IMG_format_pvrtc" ) || ( extension == "VK_NV_external_memory_capabilities" ) || - ( extension == "VK_NV_external_memory" ) -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - || ( extension == "VK_NV_external_memory_win32" ) -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - || ( extension == "VK_EXT_validation_flags" ) || ( extension == "VK_EXT_shader_subgroup_ballot" ) || ( extension == "VK_EXT_shader_subgroup_vote" ) -#if defined( VK_USE_PLATFORM_IOS_MVK ) - || ( extension == "VK_MVK_ios_surface" ) -#endif /*VK_USE_PLATFORM_IOS_MVK*/ -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - || ( extension == "VK_MVK_macos_surface" ) -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - || ( extension == "VK_AMD_gpu_shader_int16" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_EXT_buffer_device_address" ) || - ( extension == "VK_EXT_validation_features" ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - || ( extension == "VK_NV_displacement_micromap" ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - || false; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & extension ) - { - return ( extension == "VK_KHR_swapchain" ) || ( extension == "VK_KHR_display_swapchain" ) || ( extension == "VK_NV_glsl_shader" ) || - ( extension == "VK_EXT_depth_range_unrestricted" ) || ( extension == "VK_KHR_sampler_mirror_clamp_to_edge" ) || - ( extension == "VK_IMG_filter_cubic" ) || ( extension == "VK_AMD_rasterization_order" ) || ( extension == "VK_AMD_shader_trinary_minmax" ) || - ( extension == "VK_AMD_shader_explicit_vertex_parameter" ) || ( extension == "VK_EXT_debug_marker" ) || ( extension == "VK_KHR_video_queue" ) || - ( extension == "VK_KHR_video_decode_queue" ) || ( extension == "VK_AMD_gcn_shader" ) || ( extension == "VK_NV_dedicated_allocation" ) || - ( extension == "VK_EXT_transform_feedback" ) || ( extension == "VK_NVX_binary_import" ) || ( extension == "VK_NVX_image_view_handle" ) || - ( extension == "VK_AMD_draw_indirect_count" ) || ( extension == "VK_AMD_negative_viewport_height" ) || - ( extension == "VK_AMD_gpu_shader_half_float" ) || ( extension == "VK_AMD_shader_ballot" ) || ( extension == "VK_KHR_video_encode_h264" ) || - ( extension == "VK_KHR_video_encode_h265" ) || ( extension == "VK_KHR_video_decode_h264" ) || ( extension == "VK_AMD_texture_gather_bias_lod" ) || - ( extension == "VK_AMD_shader_info" ) || ( extension == "VK_KHR_dynamic_rendering" ) || ( extension == "VK_AMD_shader_image_load_store_lod" ) || - ( extension == "VK_NV_corner_sampled_image" ) || ( extension == "VK_KHR_multiview" ) || ( extension == "VK_IMG_format_pvrtc" ) || - ( extension == "VK_NV_external_memory" ) -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - || ( extension == "VK_NV_external_memory_win32" ) || ( extension == "VK_NV_win32_keyed_mutex" ) -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - || ( extension == "VK_KHR_device_group" ) || ( extension == "VK_KHR_shader_draw_parameters" ) || ( extension == "VK_EXT_shader_subgroup_ballot" ) || - ( extension == "VK_EXT_shader_subgroup_vote" ) || ( extension == "VK_EXT_texture_compression_astc_hdr" ) || - ( extension == "VK_EXT_astc_decode_mode" ) || ( extension == "VK_EXT_pipeline_robustness" ) || ( extension == "VK_KHR_maintenance1" ) || - ( extension == "VK_KHR_external_memory" ) -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - || ( extension == "VK_KHR_external_memory_win32" ) -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - || ( extension == "VK_KHR_external_memory_fd" ) -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - || ( extension == "VK_KHR_win32_keyed_mutex" ) -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - || ( extension == "VK_KHR_external_semaphore" ) -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - || ( extension == "VK_KHR_external_semaphore_win32" ) -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - || ( extension == "VK_KHR_external_semaphore_fd" ) || ( extension == "VK_KHR_push_descriptor" ) || ( extension == "VK_EXT_conditional_rendering" ) || - ( extension == "VK_KHR_shader_float16_int8" ) || ( extension == "VK_KHR_16bit_storage" ) || ( extension == "VK_KHR_incremental_present" ) || - ( extension == "VK_KHR_descriptor_update_template" ) || ( extension == "VK_NV_clip_space_w_scaling" ) || ( extension == "VK_EXT_display_control" ) || - ( extension == "VK_GOOGLE_display_timing" ) || ( extension == "VK_NV_sample_mask_override_coverage" ) || - ( extension == "VK_NV_geometry_shader_passthrough" ) || ( extension == "VK_NV_viewport_array2" ) || - ( extension == "VK_NVX_multiview_per_view_attributes" ) || ( extension == "VK_NV_viewport_swizzle" ) || - ( extension == "VK_EXT_discard_rectangles" ) || ( extension == "VK_EXT_conservative_rasterization" ) || - ( extension == "VK_EXT_depth_clip_enable" ) || ( extension == "VK_EXT_hdr_metadata" ) || ( extension == "VK_KHR_imageless_framebuffer" ) || - ( extension == "VK_KHR_create_renderpass2" ) || ( extension == "VK_IMG_relaxed_line_rasterization" ) || - ( extension == "VK_KHR_shared_presentable_image" ) || ( extension == "VK_KHR_external_fence" ) -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - || ( extension == "VK_KHR_external_fence_win32" ) -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - || ( extension == "VK_KHR_external_fence_fd" ) || ( extension == "VK_KHR_performance_query" ) || ( extension == "VK_KHR_maintenance2" ) || - ( extension == "VK_KHR_variable_pointers" ) || ( extension == "VK_EXT_external_memory_dma_buf" ) || ( extension == "VK_EXT_queue_family_foreign" ) || - ( extension == "VK_KHR_dedicated_allocation" ) -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - || ( extension == "VK_ANDROID_external_memory_android_hardware_buffer" ) -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - || ( extension == "VK_EXT_sampler_filter_minmax" ) || ( extension == "VK_KHR_storage_buffer_storage_class" ) || - ( extension == "VK_AMD_gpu_shader_int16" ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - || ( extension == "VK_AMDX_shader_enqueue" ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - || ( extension == "VK_EXT_descriptor_heap" ) || ( extension == "VK_AMD_mixed_attachment_samples" ) || ( extension == "VK_AMD_shader_fragment_mask" ) || - ( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_EXT_shader_stencil_export" ) || ( extension == "VK_KHR_shader_bfloat16" ) || - ( extension == "VK_EXT_sample_locations" ) || ( extension == "VK_KHR_relaxed_block_layout" ) || ( extension == "VK_KHR_get_memory_requirements2" ) || - ( extension == "VK_KHR_image_format_list" ) || ( extension == "VK_EXT_blend_operation_advanced" ) || - ( extension == "VK_NV_fragment_coverage_to_color" ) || ( extension == "VK_KHR_acceleration_structure" ) || - ( extension == "VK_KHR_ray_tracing_pipeline" ) || ( extension == "VK_KHR_ray_query" ) || ( extension == "VK_NV_framebuffer_mixed_samples" ) || - ( extension == "VK_NV_fill_rectangle" ) || ( extension == "VK_NV_shader_sm_builtins" ) || ( extension == "VK_EXT_post_depth_coverage" ) || - ( extension == "VK_KHR_sampler_ycbcr_conversion" ) || ( extension == "VK_KHR_bind_memory2" ) || - ( extension == "VK_EXT_image_drm_format_modifier" ) || ( extension == "VK_EXT_validation_cache" ) || ( extension == "VK_EXT_descriptor_indexing" ) || - ( extension == "VK_EXT_shader_viewport_index_layer" ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - || ( extension == "VK_KHR_portability_subset" ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - || ( extension == "VK_NV_shading_rate_image" ) || ( extension == "VK_NV_ray_tracing" ) || ( extension == "VK_NV_representative_fragment_test" ) || - ( extension == "VK_KHR_maintenance3" ) || ( extension == "VK_KHR_draw_indirect_count" ) || ( extension == "VK_EXT_filter_cubic" ) || - ( extension == "VK_QCOM_render_pass_shader_resolve" ) || ( extension == "VK_EXT_global_priority" ) || - ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) || - ( extension == "VK_EXT_external_memory_host" ) || ( extension == "VK_AMD_buffer_marker" ) || ( extension == "VK_KHR_shader_atomic_int64" ) || - ( extension == "VK_KHR_shader_clock" ) || ( extension == "VK_AMD_pipeline_compiler_control" ) || ( extension == "VK_EXT_calibrated_timestamps" ) || - ( extension == "VK_AMD_shader_core_properties" ) || ( extension == "VK_KHR_video_decode_h265" ) || ( extension == "VK_KHR_global_priority" ) || - ( extension == "VK_AMD_memory_overallocation_behavior" ) || ( extension == "VK_EXT_vertex_attribute_divisor" ) -#if defined( VK_USE_PLATFORM_GGP ) - || ( extension == "VK_GGP_frame_token" ) -#endif /*VK_USE_PLATFORM_GGP*/ - || ( extension == "VK_EXT_pipeline_creation_feedback" ) || ( extension == "VK_KHR_driver_properties" ) || - ( extension == "VK_KHR_shader_float_controls" ) || ( extension == "VK_NV_shader_subgroup_partitioned" ) || - ( extension == "VK_KHR_depth_stencil_resolve" ) || ( extension == "VK_KHR_swapchain_mutable_format" ) || - ( extension == "VK_NV_compute_shader_derivatives" ) || ( extension == "VK_NV_mesh_shader" ) || - ( extension == "VK_NV_fragment_shader_barycentric" ) || ( extension == "VK_NV_shader_image_footprint" ) || - ( extension == "VK_NV_scissor_exclusive" ) || ( extension == "VK_NV_device_diagnostic_checkpoints" ) || - ( extension == "VK_KHR_timeline_semaphore" ) || ( extension == "VK_EXT_present_timing" ) || ( extension == "VK_INTEL_shader_integer_functions2" ) || - ( extension == "VK_INTEL_performance_query" ) || ( extension == "VK_KHR_vulkan_memory_model" ) || ( extension == "VK_EXT_pci_bus_info" ) || - ( extension == "VK_AMD_display_native_hdr" ) || ( extension == "VK_KHR_shader_terminate_invocation" ) || - ( extension == "VK_EXT_fragment_density_map" ) || ( extension == "VK_EXT_scalar_block_layout" ) || - ( extension == "VK_GOOGLE_hlsl_functionality1" ) || ( extension == "VK_GOOGLE_decorate_string" ) || - ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_fragment_shading_rate" ) || - ( extension == "VK_AMD_shader_core_properties2" ) || ( extension == "VK_AMD_device_coherent_memory" ) || - ( extension == "VK_KHR_dynamic_rendering_local_read" ) || ( extension == "VK_EXT_shader_image_atomic_int64" ) || - ( extension == "VK_KHR_shader_quad_control" ) || ( extension == "VK_KHR_spirv_1_4" ) || ( extension == "VK_EXT_memory_budget" ) || - ( extension == "VK_EXT_memory_priority" ) || ( extension == "VK_NV_dedicated_allocation_image_aliasing" ) || - ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || ( extension == "VK_EXT_buffer_device_address" ) || - ( extension == "VK_EXT_tooling_info" ) || ( extension == "VK_EXT_separate_stencil_usage" ) || ( extension == "VK_KHR_present_wait" ) || - ( extension == "VK_NV_cooperative_matrix" ) || ( extension == "VK_NV_coverage_reduction_mode" ) || - ( extension == "VK_EXT_fragment_shader_interlock" ) || ( extension == "VK_EXT_ycbcr_image_arrays" ) || - ( extension == "VK_KHR_uniform_buffer_standard_layout" ) || ( extension == "VK_EXT_provoking_vertex" ) -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - || ( extension == "VK_EXT_full_screen_exclusive" ) -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - || ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_shader_atomic_float" ) || - ( extension == "VK_EXT_host_query_reset" ) || ( extension == "VK_EXT_index_type_uint8" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || - ( extension == "VK_KHR_deferred_host_operations" ) || ( extension == "VK_KHR_pipeline_executable_properties" ) || - ( extension == "VK_EXT_host_image_copy" ) || ( extension == "VK_KHR_map_memory2" ) || ( extension == "VK_EXT_map_memory_placed" ) || - ( extension == "VK_EXT_shader_atomic_float2" ) || ( extension == "VK_EXT_swapchain_maintenance1" ) || - ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || ( extension == "VK_NV_device_generated_commands" ) || - ( extension == "VK_NV_inherited_viewport_scissor" ) || ( extension == "VK_KHR_shader_integer_dot_product" ) || - ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_QCOM_render_pass_transform" ) || - ( extension == "VK_EXT_depth_bias_control" ) || ( extension == "VK_EXT_device_memory_report" ) || ( extension == "VK_EXT_robustness2" ) || - ( extension == "VK_EXT_custom_border_color" ) || ( extension == "VK_EXT_texture_compression_astc_3d" ) || ( extension == "VK_GOOGLE_user_type" ) || - ( extension == "VK_KHR_pipeline_library" ) || ( extension == "VK_NV_present_barrier" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || - ( extension == "VK_KHR_present_id" ) || ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || - ( extension == "VK_KHR_video_encode_queue" ) || ( extension == "VK_NV_device_diagnostics_config" ) || - ( extension == "VK_QCOM_render_pass_store_ops" ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - || ( extension == "VK_NV_cuda_kernel_launch" ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - || ( extension == "VK_QCOM_tile_shading" ) || ( extension == "VK_NV_low_latency" ) -#if defined( VK_USE_PLATFORM_METAL_EXT ) - || ( extension == "VK_EXT_metal_objects" ) -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - || ( extension == "VK_KHR_synchronization2" ) || ( extension == "VK_EXT_descriptor_buffer" ) || ( extension == "VK_EXT_graphics_pipeline_library" ) || - ( extension == "VK_AMD_shader_early_and_late_fragment_tests" ) || ( extension == "VK_KHR_fragment_shader_barycentric" ) || - ( extension == "VK_KHR_shader_subgroup_uniform_control_flow" ) || ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || - ( extension == "VK_NV_fragment_shading_rate_enums" ) || ( extension == "VK_NV_ray_tracing_motion_blur" ) || ( extension == "VK_EXT_mesh_shader" ) || - ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || ( extension == "VK_EXT_fragment_density_map2" ) || - ( extension == "VK_QCOM_rotated_copy_commands" ) || ( extension == "VK_EXT_image_robustness" ) || - ( extension == "VK_KHR_workgroup_memory_explicit_layout" ) || ( extension == "VK_KHR_copy_commands2" ) || - ( extension == "VK_EXT_image_compression_control" ) || ( extension == "VK_EXT_attachment_feedback_loop_layout" ) || - ( extension == "VK_EXT_4444_formats" ) || ( extension == "VK_EXT_device_fault" ) || - ( extension == "VK_ARM_rasterization_order_attachment_access" ) || ( extension == "VK_EXT_rgba10x6_formats" ) -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - || ( extension == "VK_NV_acquire_winrt_display" ) -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - || ( extension == "VK_VALVE_mutable_descriptor_type" ) || ( extension == "VK_EXT_vertex_input_dynamic_state" ) || - ( extension == "VK_EXT_physical_device_drm" ) || ( extension == "VK_EXT_device_address_binding_report" ) || - ( extension == "VK_EXT_depth_clip_control" ) || ( extension == "VK_EXT_primitive_topology_list_restart" ) || - ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_present_mode_fifo_latest_ready" ) -#if defined( VK_USE_PLATFORM_FUCHSIA ) - || ( extension == "VK_FUCHSIA_external_memory" ) || ( extension == "VK_FUCHSIA_external_semaphore" ) || ( extension == "VK_FUCHSIA_buffer_collection" ) -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - || ( extension == "VK_HUAWEI_subpass_shading" ) || ( extension == "VK_HUAWEI_invocation_mask" ) || ( extension == "VK_NV_external_memory_rdma" ) || - ( extension == "VK_EXT_pipeline_properties" ) || ( extension == "VK_EXT_frame_boundary" ) || - ( extension == "VK_EXT_multisampled_render_to_single_sampled" ) || ( extension == "VK_EXT_extended_dynamic_state2" ) || - ( extension == "VK_EXT_color_write_enable" ) || ( extension == "VK_EXT_primitives_generated_query" ) || - ( extension == "VK_KHR_ray_tracing_maintenance1" ) || ( extension == "VK_KHR_shader_untyped_pointers" ) || - ( extension == "VK_EXT_global_priority_query" ) || ( extension == "VK_VALVE_video_encode_rgb_conversion" ) || - ( extension == "VK_EXT_image_view_min_lod" ) || ( extension == "VK_EXT_multi_draw" ) || ( extension == "VK_EXT_image_2d_view_of_3d" ) || - ( extension == "VK_EXT_shader_tile_image" ) || ( extension == "VK_EXT_opacity_micromap" ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - || ( extension == "VK_NV_displacement_micromap" ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - || ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_HUAWEI_cluster_culling_shader" ) || - ( extension == "VK_EXT_border_color_swizzle" ) || ( extension == "VK_EXT_pageable_device_local_memory" ) || ( extension == "VK_KHR_maintenance4" ) || - ( extension == "VK_ARM_shader_core_properties" ) || ( extension == "VK_KHR_shader_subgroup_rotate" ) || - ( extension == "VK_ARM_scheduling_controls" ) || ( extension == "VK_EXT_image_sliced_view_of_3d" ) || - ( extension == "VK_VALVE_descriptor_set_host_mapping" ) || ( extension == "VK_EXT_depth_clamp_zero_one" ) || - ( extension == "VK_EXT_non_seamless_cube_map" ) || ( extension == "VK_ARM_render_pass_striped" ) || - ( extension == "VK_QCOM_fragment_density_map_offset" ) || ( extension == "VK_NV_copy_memory_indirect" ) || - ( extension == "VK_NV_memory_decompression" ) || ( extension == "VK_NV_device_generated_commands_compute" ) || - ( extension == "VK_NV_ray_tracing_linear_swept_spheres" ) || ( extension == "VK_NV_linear_color_attachment" ) || - ( extension == "VK_KHR_shader_maximal_reconvergence" ) || ( extension == "VK_EXT_image_compression_control_swapchain" ) || - ( extension == "VK_QCOM_image_processing" ) || ( extension == "VK_EXT_nested_command_buffer" ) -#if defined( VK_USE_PLATFORM_OHOS ) - || ( extension == "VK_OHOS_external_memory" ) -#endif /*VK_USE_PLATFORM_OHOS*/ - || ( extension == "VK_EXT_external_memory_acquire_unmodified" ) || ( extension == "VK_EXT_extended_dynamic_state3" ) || - ( extension == "VK_EXT_subpass_merge_feedback" ) || ( extension == "VK_ARM_tensors" ) || ( extension == "VK_EXT_shader_module_identifier" ) || - ( extension == "VK_EXT_rasterization_order_attachment_access" ) || ( extension == "VK_NV_optical_flow" ) || - ( extension == "VK_EXT_legacy_dithering" ) || ( extension == "VK_EXT_pipeline_protected_access" ) -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - || ( extension == "VK_ANDROID_external_format_resolve" ) -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - || ( extension == "VK_KHR_maintenance5" ) || ( extension == "VK_AMD_anti_lag" ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - || ( extension == "VK_AMDX_dense_geometry_format" ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - || ( extension == "VK_KHR_present_id2" ) || ( extension == "VK_KHR_present_wait2" ) || ( extension == "VK_KHR_ray_tracing_position_fetch" ) || - ( extension == "VK_EXT_shader_object" ) || ( extension == "VK_KHR_pipeline_binary" ) || ( extension == "VK_QCOM_tile_properties" ) || - ( extension == "VK_SEC_amigo_profiling" ) || ( extension == "VK_KHR_swapchain_maintenance1" ) || - ( extension == "VK_QCOM_multiview_per_view_viewports" ) || ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || - ( extension == "VK_NV_cooperative_vector" ) || ( extension == "VK_NV_extended_sparse_address_space" ) || - ( extension == "VK_EXT_mutable_descriptor_type" ) || ( extension == "VK_EXT_legacy_vertex_attributes" ) || - ( extension == "VK_ARM_shader_core_builtins" ) || ( extension == "VK_EXT_pipeline_library_group_handles" ) || - ( extension == "VK_EXT_dynamic_rendering_unused_attachments" ) || ( extension == "VK_KHR_internally_synchronized_queues" ) || - ( extension == "VK_NV_low_latency2" ) || ( extension == "VK_KHR_cooperative_matrix" ) || ( extension == "VK_ARM_data_graph" ) || - ( extension == "VK_QCOM_multiview_per_view_render_areas" ) || ( extension == "VK_KHR_compute_shader_derivatives" ) || - ( extension == "VK_KHR_video_decode_av1" ) || ( extension == "VK_KHR_video_encode_av1" ) || ( extension == "VK_KHR_video_decode_vp9" ) || - ( extension == "VK_KHR_video_maintenance1" ) || ( extension == "VK_NV_per_stage_descriptor_set" ) || ( extension == "VK_QCOM_image_processing2" ) || - ( extension == "VK_QCOM_filter_cubic_weights" ) || ( extension == "VK_QCOM_ycbcr_degamma" ) || ( extension == "VK_QCOM_filter_cubic_clamp" ) || - ( extension == "VK_EXT_attachment_feedback_loop_dynamic_state" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) || - ( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_unified_image_layouts" ) || ( extension == "VK_KHR_shader_float_controls2" ) -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - || ( extension == "VK_QNX_external_memory_screen_buffer" ) -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) || - ( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) || - ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_QCOM_tile_memory_heap" ) || - ( extension == "VK_KHR_copy_memory_indirect" ) || ( extension == "VK_EXT_memory_decompression" ) || - ( extension == "VK_KHR_video_encode_intra_refresh" ) || ( extension == "VK_KHR_video_encode_quantization_map" ) || - ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_NV_external_compute_queue" ) || - ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) || - ( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) || - ( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_EXT_shader_float8" ) || - ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) || - ( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) || - ( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_KHR_shader_fma" ) || - ( extension == "VK_NV_push_constant_bank" ) || ( extension == "VK_EXT_ray_tracing_invocation_reorder" ) || - ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_KHR_maintenance9" ) || ( extension == "VK_KHR_video_maintenance2" ) || - ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" ) -#if defined( VK_USE_PLATFORM_METAL_EXT ) - || ( extension == "VK_EXT_external_memory_metal" ) -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - || ( extension == "VK_KHR_depth_clamp_zero_one" ) || ( extension == "VK_ARM_performance_counters_by_region" ) || - ( extension == "VK_EXT_vertex_attribute_robustness" ) || ( extension == "VK_ARM_format_pack" ) || - ( extension == "VK_VALVE_fragment_density_map_layered" ) || ( extension == "VK_KHR_robustness2" ) -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - || ( extension == "VK_NV_present_metering" ) -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - || ( extension == "VK_EXT_fragment_density_map_offset" ) || ( extension == "VK_EXT_zero_initialize_device_memory" ) || - ( extension == "VK_KHR_present_mode_fifo_latest_ready" ) || ( extension == "VK_EXT_shader_64bit_indexing" ) || - ( extension == "VK_EXT_custom_resolve" ) || ( extension == "VK_QCOM_data_graph_model" ) || ( extension == "VK_KHR_maintenance10" ) || - ( extension == "VK_EXT_shader_long_vector" ) || ( extension == "VK_SEC_pipeline_cache_incremental_mode" ) || - ( extension == "VK_EXT_shader_uniform_buffer_unsized_array" ) || ( extension == "VK_NV_compute_occupancy_priority" ) || - ( extension == "VK_EXT_shader_subgroup_partitioned" ); - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & extension ) - { - return ( extension == "VK_KHR_surface" ) || ( extension == "VK_KHR_display" ) -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - || ( extension == "VK_KHR_xlib_surface" ) -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ -#if defined( VK_USE_PLATFORM_XCB_KHR ) - || ( extension == "VK_KHR_xcb_surface" ) -#endif /*VK_USE_PLATFORM_XCB_KHR*/ -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - || ( extension == "VK_KHR_wayland_surface" ) -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - || ( extension == "VK_KHR_android_surface" ) -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - || ( extension == "VK_KHR_win32_surface" ) -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - || ( extension == "VK_EXT_debug_report" ) -#if defined( VK_USE_PLATFORM_GGP ) - || ( extension == "VK_GGP_stream_descriptor_surface" ) -#endif /*VK_USE_PLATFORM_GGP*/ - || ( extension == "VK_NV_external_memory_capabilities" ) || ( extension == "VK_KHR_get_physical_device_properties2" ) || - ( extension == "VK_EXT_validation_flags" ) -#if defined( VK_USE_PLATFORM_VI_NN ) - || ( extension == "VK_NN_vi_surface" ) -#endif /*VK_USE_PLATFORM_VI_NN*/ - || ( extension == "VK_KHR_device_group_creation" ) || ( extension == "VK_KHR_external_memory_capabilities" ) || - ( extension == "VK_KHR_external_semaphore_capabilities" ) || ( extension == "VK_EXT_direct_mode_display" ) -#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - || ( extension == "VK_EXT_acquire_xlib_display" ) -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - || ( extension == "VK_EXT_display_surface_counter" ) || ( extension == "VK_EXT_swapchain_colorspace" ) || - ( extension == "VK_KHR_external_fence_capabilities" ) || ( extension == "VK_KHR_get_surface_capabilities2" ) || - ( extension == "VK_KHR_get_display_properties2" ) -#if defined( VK_USE_PLATFORM_IOS_MVK ) - || ( extension == "VK_MVK_ios_surface" ) -#endif /*VK_USE_PLATFORM_IOS_MVK*/ -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - || ( extension == "VK_MVK_macos_surface" ) -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - || ( extension == "VK_EXT_debug_utils" ) -#if defined( VK_USE_PLATFORM_FUCHSIA ) - || ( extension == "VK_FUCHSIA_imagepipe_surface" ) -#endif /*VK_USE_PLATFORM_FUCHSIA*/ -#if defined( VK_USE_PLATFORM_METAL_EXT ) - || ( extension == "VK_EXT_metal_surface" ) -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - || ( extension == "VK_KHR_surface_protected_capabilities" ) || ( extension == "VK_EXT_validation_features" ) || - ( extension == "VK_EXT_headless_surface" ) || ( extension == "VK_EXT_surface_maintenance1" ) || ( extension == "VK_EXT_acquire_drm_display" ) -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - || ( extension == "VK_EXT_directfb_surface" ) -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - || ( extension == "VK_QNX_screen_surface" ) -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - || ( extension == "VK_KHR_portability_enumeration" ) || ( extension == "VK_GOOGLE_surfaceless_query" ) || - ( extension == "VK_LUNARG_direct_driver_loading" ) || ( extension == "VK_KHR_surface_maintenance1" ) || ( extension == "VK_EXT_layer_settings" ) || - ( extension == "VK_NV_display_stereo" ) -#if defined( VK_USE_PLATFORM_OHOS ) - || ( extension == "VK_OHOS_surface" ) -#endif /*VK_USE_PLATFORM_OHOS*/ - ; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isObsoletedExtension( std::string const & extension ) - { - return ( extension == "VK_AMD_negative_viewport_height" ); - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isPromotedExtension( std::string const & extension ) - { - return ( extension == "VK_KHR_sampler_mirror_clamp_to_edge" ) || ( extension == "VK_EXT_debug_marker" ) || ( extension == "VK_AMD_draw_indirect_count" ) || - ( extension == "VK_KHR_dynamic_rendering" ) || ( extension == "VK_KHR_multiview" ) -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - || ( extension == "VK_NV_win32_keyed_mutex" ) -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - || ( extension == "VK_KHR_get_physical_device_properties2" ) || ( extension == "VK_KHR_device_group" ) || - ( extension == "VK_KHR_shader_draw_parameters" ) || ( extension == "VK_EXT_texture_compression_astc_hdr" ) || - ( extension == "VK_EXT_pipeline_robustness" ) || ( extension == "VK_KHR_maintenance1" ) || ( extension == "VK_KHR_device_group_creation" ) || - ( extension == "VK_KHR_external_memory_capabilities" ) || ( extension == "VK_KHR_external_memory" ) || - ( extension == "VK_KHR_external_semaphore_capabilities" ) || ( extension == "VK_KHR_external_semaphore" ) || - ( extension == "VK_KHR_push_descriptor" ) || ( extension == "VK_KHR_shader_float16_int8" ) || ( extension == "VK_KHR_16bit_storage" ) || - ( extension == "VK_KHR_descriptor_update_template" ) || ( extension == "VK_KHR_imageless_framebuffer" ) || - ( extension == "VK_KHR_create_renderpass2" ) || ( extension == "VK_KHR_external_fence_capabilities" ) || ( extension == "VK_KHR_external_fence" ) || - ( extension == "VK_KHR_maintenance2" ) || ( extension == "VK_KHR_variable_pointers" ) || ( extension == "VK_KHR_dedicated_allocation" ) || - ( extension == "VK_EXT_sampler_filter_minmax" ) || ( extension == "VK_KHR_storage_buffer_storage_class" ) || - ( extension == "VK_EXT_inline_uniform_block" ) || ( extension == "VK_KHR_relaxed_block_layout" ) || - ( extension == "VK_KHR_get_memory_requirements2" ) || ( extension == "VK_KHR_image_format_list" ) || - ( extension == "VK_KHR_sampler_ycbcr_conversion" ) || ( extension == "VK_KHR_bind_memory2" ) || ( extension == "VK_EXT_descriptor_indexing" ) || - ( extension == "VK_EXT_shader_viewport_index_layer" ) || ( extension == "VK_KHR_maintenance3" ) || ( extension == "VK_KHR_draw_indirect_count" ) || - ( extension == "VK_QCOM_render_pass_shader_resolve" ) || ( extension == "VK_EXT_global_priority" ) || - ( extension == "VK_KHR_shader_subgroup_extended_types" ) || ( extension == "VK_KHR_8bit_storage" ) || - ( extension == "VK_KHR_shader_atomic_int64" ) || ( extension == "VK_EXT_calibrated_timestamps" ) || ( extension == "VK_KHR_global_priority" ) || - ( extension == "VK_EXT_vertex_attribute_divisor" ) || ( extension == "VK_EXT_pipeline_creation_feedback" ) || - ( extension == "VK_KHR_driver_properties" ) || ( extension == "VK_KHR_shader_float_controls" ) || - ( extension == "VK_NV_shader_subgroup_partitioned" ) || ( extension == "VK_KHR_depth_stencil_resolve" ) || - ( extension == "VK_NV_compute_shader_derivatives" ) || ( extension == "VK_NV_fragment_shader_barycentric" ) || - ( extension == "VK_KHR_timeline_semaphore" ) || ( extension == "VK_KHR_vulkan_memory_model" ) || - ( extension == "VK_KHR_shader_terminate_invocation" ) || ( extension == "VK_EXT_scalar_block_layout" ) || - ( extension == "VK_EXT_subgroup_size_control" ) || ( extension == "VK_KHR_dynamic_rendering_local_read" ) || ( extension == "VK_KHR_spirv_1_4" ) || - ( extension == "VK_KHR_separate_depth_stencil_layouts" ) || ( extension == "VK_EXT_tooling_info" ) || - ( extension == "VK_EXT_separate_stencil_usage" ) || ( extension == "VK_KHR_uniform_buffer_standard_layout" ) || - ( extension == "VK_KHR_buffer_device_address" ) || ( extension == "VK_EXT_line_rasterization" ) || ( extension == "VK_EXT_host_query_reset" ) || - ( extension == "VK_EXT_index_type_uint8" ) || ( extension == "VK_EXT_extended_dynamic_state" ) || ( extension == "VK_EXT_host_image_copy" ) || - ( extension == "VK_KHR_map_memory2" ) || ( extension == "VK_EXT_surface_maintenance1" ) || ( extension == "VK_EXT_swapchain_maintenance1" ) || - ( extension == "VK_EXT_shader_demote_to_helper_invocation" ) || ( extension == "VK_KHR_shader_integer_dot_product" ) || - ( extension == "VK_EXT_texel_buffer_alignment" ) || ( extension == "VK_EXT_robustness2" ) || ( extension == "VK_KHR_shader_non_semantic_info" ) || - ( extension == "VK_EXT_private_data" ) || ( extension == "VK_EXT_pipeline_creation_cache_control" ) || ( extension == "VK_KHR_synchronization2" ) || - ( extension == "VK_KHR_zero_initialize_workgroup_memory" ) || ( extension == "VK_EXT_ycbcr_2plane_444_formats" ) || - ( extension == "VK_EXT_image_robustness" ) || ( extension == "VK_KHR_copy_commands2" ) || ( extension == "VK_EXT_4444_formats" ) || - ( extension == "VK_ARM_rasterization_order_attachment_access" ) || ( extension == "VK_VALVE_mutable_descriptor_type" ) || - ( extension == "VK_KHR_format_feature_flags2" ) || ( extension == "VK_EXT_present_mode_fifo_latest_ready" ) || - ( extension == "VK_EXT_extended_dynamic_state2" ) || ( extension == "VK_EXT_global_priority_query" ) || - ( extension == "VK_EXT_load_store_op_none" ) || ( extension == "VK_KHR_maintenance4" ) || ( extension == "VK_KHR_shader_subgroup_rotate" ) || - ( extension == "VK_EXT_depth_clamp_zero_one" ) || ( extension == "VK_QCOM_fragment_density_map_offset" ) || - ( extension == "VK_NV_copy_memory_indirect" ) || ( extension == "VK_NV_memory_decompression" ) || - ( extension == "VK_EXT_pipeline_protected_access" ) || ( extension == "VK_KHR_maintenance5" ) || - ( extension == "VK_NV_ray_tracing_invocation_reorder" ) || ( extension == "VK_KHR_vertex_attribute_divisor" ) || - ( extension == "VK_KHR_load_store_op_none" ) || ( extension == "VK_KHR_shader_float_controls2" ) || ( extension == "VK_KHR_index_type_uint8" ) || - ( extension == "VK_KHR_line_rasterization" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) || - ( extension == "VK_EXT_vertex_attribute_robustness" ); - } -} // namespace VULKAN_HPP_NAMESPACE - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_format_traits.hpp b/lib/vulkan-headers/include/vulkan/vulkan_format_traits.hpp deleted file mode 100644 index 54072b79991..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_format_traits.hpp +++ /dev/null @@ -1,10576 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_FORMAT_TRAITS_HPP -#define VULKAN_FORMAT_TRAITS_HPP - -#include - -namespace VULKAN_HPP_NAMESPACE -{ - //===================== - //=== Format Traits === - //===================== - - //=== Function Declarations === - - // The three-dimensional extent of a texel block. - VULKAN_HPP_CONSTEXPR_14 std::array blockExtent( Format format ); - - // The texel block size in bytes. - VULKAN_HPP_CONSTEXPR_14 uint8_t blockSize( Format format ); - - // The class of the format (can't be just named "class"!) - VULKAN_HPP_CONSTEXPR_14 char const * compatibilityClass( Format format ); - - // The number of bits in this component, if not compressed, otherwise 0. - VULKAN_HPP_CONSTEXPR_14 uint8_t componentBits( Format format, uint8_t component ); - - // The number of components of this format. - VULKAN_HPP_CONSTEXPR_14 uint8_t componentCount( Format format ); - - // The name of the component - VULKAN_HPP_CONSTEXPR_14 char const * componentName( Format format, uint8_t component ); - - // The numeric format of the component - VULKAN_HPP_CONSTEXPR_14 char const * componentNumericFormat( Format format, uint8_t component ); - - // The plane this component lies in. - VULKAN_HPP_CONSTEXPR_14 uint8_t componentPlaneIndex( Format format, uint8_t component ); - - // True, if the components of this format are compressed, otherwise false. - VULKAN_HPP_CONSTEXPR_14 bool componentsAreCompressed( Format format ); - - // A textual description of the compression scheme, or an empty string if it is not compressed - VULKAN_HPP_CONSTEXPR_14 char const * compressionScheme( Format format ); - - // Get all formats - std::vector const & getAllFormats(); - - // Get all color with a color component - std::vector const & getColorFormats(); - - // Get all formats with a depth component - std::vector const & getDepthFormats(); - - // Get all formats with a depth and a stencil component - std::vector const & getDepthStencilFormats(); - - // Get all formats with a stencil component - std::vector const & getStencilFormats(); - - // True, if this format has an alpha component - VULKAN_HPP_CONSTEXPR_14 bool hasAlphaComponent( Format format ); - - // True, if this format has a blue component - VULKAN_HPP_CONSTEXPR_14 bool hasBlueComponent( Format format ); - - // True, if this format has a depth component - VULKAN_HPP_CONSTEXPR_14 bool hasDepthComponent( Format format ); - - // True, if this format has a green component - VULKAN_HPP_CONSTEXPR_14 bool hasGreenComponent( Format format ); - - // True, if this format has a red component - VULKAN_HPP_CONSTEXPR_14 bool hasRedComponent( Format format ); - - // True, if this format has a stencil component - VULKAN_HPP_CONSTEXPR_14 bool hasStencilComponent( Format format ); - - // True, if the format is a color - VULKAN_HPP_CONSTEXPR_14 bool isColor( Format format ); - - // True, if this format is a compressed one. - VULKAN_HPP_CONSTEXPR_14 bool isCompressed( Format format ); - - // The number of bits into which the format is packed. A single image element in this format can be stored in the same space as a scalar type of this bit - // width. - VULKAN_HPP_CONSTEXPR_14 uint8_t packed( Format format ); - - // The single-plane format that this plane is compatible with. - VULKAN_HPP_CONSTEXPR_14 Format planeCompatibleFormat( Format format, uint8_t plane ); - - // The number of image planes of this format. - VULKAN_HPP_CONSTEXPR_14 uint8_t planeCount( Format format ); - - // The relative height of this plane. A value of k means that this plane is 1/k the height of the overall format. - VULKAN_HPP_CONSTEXPR_14 uint8_t planeHeightDivisor( Format format, uint8_t plane ); - - // The relative width of this plane. A value of k means that this plane is 1/k the width of the overall format. - VULKAN_HPP_CONSTEXPR_14 uint8_t planeWidthDivisor( Format format, uint8_t plane ); - - // The number of texels in a texel block. - VULKAN_HPP_CONSTEXPR_14 uint8_t texelsPerBlock( Format format ); - - //=== Function Definitions === - - // The three-dimensional extent of a texel block. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 std::array blockExtent( Format format ) - { - switch ( format ) - { - case Format::eBc1RgbUnormBlock : return { { 4, 4, 1 } }; - case Format::eBc1RgbSrgbBlock : return { { 4, 4, 1 } }; - case Format::eBc1RgbaUnormBlock : return { { 4, 4, 1 } }; - case Format::eBc1RgbaSrgbBlock : return { { 4, 4, 1 } }; - case Format::eBc2UnormBlock : return { { 4, 4, 1 } }; - case Format::eBc2SrgbBlock : return { { 4, 4, 1 } }; - case Format::eBc3UnormBlock : return { { 4, 4, 1 } }; - case Format::eBc3SrgbBlock : return { { 4, 4, 1 } }; - case Format::eBc4UnormBlock : return { { 4, 4, 1 } }; - case Format::eBc4SnormBlock : return { { 4, 4, 1 } }; - case Format::eBc5UnormBlock : return { { 4, 4, 1 } }; - case Format::eBc5SnormBlock : return { { 4, 4, 1 } }; - case Format::eBc6HUfloatBlock : return { { 4, 4, 1 } }; - case Format::eBc6HSfloatBlock : return { { 4, 4, 1 } }; - case Format::eBc7UnormBlock : return { { 4, 4, 1 } }; - case Format::eBc7SrgbBlock : return { { 4, 4, 1 } }; - case Format::eEtc2R8G8B8UnormBlock : return { { 4, 4, 1 } }; - case Format::eEtc2R8G8B8SrgbBlock : return { { 4, 4, 1 } }; - case Format::eEtc2R8G8B8A1UnormBlock : return { { 4, 4, 1 } }; - case Format::eEtc2R8G8B8A1SrgbBlock : return { { 4, 4, 1 } }; - case Format::eEtc2R8G8B8A8UnormBlock : return { { 4, 4, 1 } }; - case Format::eEtc2R8G8B8A8SrgbBlock : return { { 4, 4, 1 } }; - case Format::eEacR11UnormBlock : return { { 4, 4, 1 } }; - case Format::eEacR11SnormBlock : return { { 4, 4, 1 } }; - case Format::eEacR11G11UnormBlock : return { { 4, 4, 1 } }; - case Format::eEacR11G11SnormBlock : return { { 4, 4, 1 } }; - case Format::eAstc4x4UnormBlock : return { { 4, 4, 1 } }; - case Format::eAstc4x4SrgbBlock : return { { 4, 4, 1 } }; - case Format::eAstc5x4UnormBlock : return { { 5, 4, 1 } }; - case Format::eAstc5x4SrgbBlock : return { { 5, 4, 1 } }; - case Format::eAstc5x5UnormBlock : return { { 5, 5, 1 } }; - case Format::eAstc5x5SrgbBlock : return { { 5, 5, 1 } }; - case Format::eAstc6x5UnormBlock : return { { 6, 5, 1 } }; - case Format::eAstc6x5SrgbBlock : return { { 6, 5, 1 } }; - case Format::eAstc6x6UnormBlock : return { { 6, 6, 1 } }; - case Format::eAstc6x6SrgbBlock : return { { 6, 6, 1 } }; - case Format::eAstc8x5UnormBlock : return { { 8, 5, 1 } }; - case Format::eAstc8x5SrgbBlock : return { { 8, 5, 1 } }; - case Format::eAstc8x6UnormBlock : return { { 8, 6, 1 } }; - case Format::eAstc8x6SrgbBlock : return { { 8, 6, 1 } }; - case Format::eAstc8x8UnormBlock : return { { 8, 8, 1 } }; - case Format::eAstc8x8SrgbBlock : return { { 8, 8, 1 } }; - case Format::eAstc10x5UnormBlock : return { { 10, 5, 1 } }; - case Format::eAstc10x5SrgbBlock : return { { 10, 5, 1 } }; - case Format::eAstc10x6UnormBlock : return { { 10, 6, 1 } }; - case Format::eAstc10x6SrgbBlock : return { { 10, 6, 1 } }; - case Format::eAstc10x8UnormBlock : return { { 10, 8, 1 } }; - case Format::eAstc10x8SrgbBlock : return { { 10, 8, 1 } }; - case Format::eAstc10x10UnormBlock : return { { 10, 10, 1 } }; - case Format::eAstc10x10SrgbBlock : return { { 10, 10, 1 } }; - case Format::eAstc12x10UnormBlock : return { { 12, 10, 1 } }; - case Format::eAstc12x10SrgbBlock : return { { 12, 10, 1 } }; - case Format::eAstc12x12UnormBlock : return { { 12, 12, 1 } }; - case Format::eAstc12x12SrgbBlock : return { { 12, 12, 1 } }; - case Format::eG8B8G8R8422Unorm : return { { 2, 1, 1 } }; - case Format::eB8G8R8G8422Unorm : return { { 2, 1, 1 } }; - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: return { { 2, 1, 1 } }; - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: return { { 2, 1, 1 } }; - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: return { { 2, 1, 1 } }; - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: return { { 2, 1, 1 } }; - case Format::eG16B16G16R16422Unorm : return { { 2, 1, 1 } }; - case Format::eB16G16R16G16422Unorm : return { { 2, 1, 1 } }; - case Format::eAstc4x4SfloatBlock : return { { 4, 4, 1 } }; - case Format::eAstc5x4SfloatBlock : return { { 5, 4, 1 } }; - case Format::eAstc5x5SfloatBlock : return { { 5, 5, 1 } }; - case Format::eAstc6x5SfloatBlock : return { { 6, 5, 1 } }; - case Format::eAstc6x6SfloatBlock : return { { 6, 6, 1 } }; - case Format::eAstc8x5SfloatBlock : return { { 8, 5, 1 } }; - case Format::eAstc8x6SfloatBlock : return { { 8, 6, 1 } }; - case Format::eAstc8x8SfloatBlock : return { { 8, 8, 1 } }; - case Format::eAstc10x5SfloatBlock : return { { 10, 5, 1 } }; - case Format::eAstc10x6SfloatBlock : return { { 10, 6, 1 } }; - case Format::eAstc10x8SfloatBlock : return { { 10, 8, 1 } }; - case Format::eAstc10x10SfloatBlock : return { { 10, 10, 1 } }; - case Format::eAstc12x10SfloatBlock : return { { 12, 10, 1 } }; - case Format::eAstc12x12SfloatBlock : return { { 12, 12, 1 } }; - case Format::ePvrtc12BppUnormBlockIMG : return { { 8, 4, 1 } }; - case Format::ePvrtc14BppUnormBlockIMG : return { { 4, 4, 1 } }; - case Format::ePvrtc22BppUnormBlockIMG : return { { 8, 4, 1 } }; - case Format::ePvrtc24BppUnormBlockIMG : return { { 4, 4, 1 } }; - case Format::ePvrtc12BppSrgbBlockIMG : return { { 8, 4, 1 } }; - case Format::ePvrtc14BppSrgbBlockIMG : return { { 4, 4, 1 } }; - case Format::ePvrtc22BppSrgbBlockIMG : return { { 8, 4, 1 } }; - case Format::ePvrtc24BppSrgbBlockIMG : return { { 4, 4, 1 } }; - case Format::eAstc3x3x3UnormBlockEXT : return { { 3, 3, 3 } }; - case Format::eAstc3x3x3SrgbBlockEXT : return { { 3, 3, 3 } }; - case Format::eAstc3x3x3SfloatBlockEXT : return { { 3, 3, 3 } }; - case Format::eAstc4x3x3UnormBlockEXT : return { { 4, 3, 3 } }; - case Format::eAstc4x3x3SrgbBlockEXT : return { { 4, 3, 3 } }; - case Format::eAstc4x3x3SfloatBlockEXT : return { { 4, 3, 3 } }; - case Format::eAstc4x4x3UnormBlockEXT : return { { 4, 4, 3 } }; - case Format::eAstc4x4x3SrgbBlockEXT : return { { 4, 4, 3 } }; - case Format::eAstc4x4x3SfloatBlockEXT : return { { 4, 4, 3 } }; - case Format::eAstc4x4x4UnormBlockEXT : return { { 4, 4, 4 } }; - case Format::eAstc4x4x4SrgbBlockEXT : return { { 4, 4, 4 } }; - case Format::eAstc4x4x4SfloatBlockEXT : return { { 4, 4, 4 } }; - case Format::eAstc5x4x4UnormBlockEXT : return { { 5, 4, 4 } }; - case Format::eAstc5x4x4SrgbBlockEXT : return { { 5, 4, 4 } }; - case Format::eAstc5x4x4SfloatBlockEXT : return { { 5, 4, 4 } }; - case Format::eAstc5x5x4UnormBlockEXT : return { { 5, 5, 4 } }; - case Format::eAstc5x5x4SrgbBlockEXT : return { { 5, 5, 4 } }; - case Format::eAstc5x5x4SfloatBlockEXT : return { { 5, 5, 4 } }; - case Format::eAstc5x5x5UnormBlockEXT : return { { 5, 5, 5 } }; - case Format::eAstc5x5x5SrgbBlockEXT : return { { 5, 5, 5 } }; - case Format::eAstc5x5x5SfloatBlockEXT : return { { 5, 5, 5 } }; - case Format::eAstc6x5x5UnormBlockEXT : return { { 6, 5, 5 } }; - case Format::eAstc6x5x5SrgbBlockEXT : return { { 6, 5, 5 } }; - case Format::eAstc6x5x5SfloatBlockEXT : return { { 6, 5, 5 } }; - case Format::eAstc6x6x5UnormBlockEXT : return { { 6, 6, 5 } }; - case Format::eAstc6x6x5SrgbBlockEXT : return { { 6, 6, 5 } }; - case Format::eAstc6x6x5SfloatBlockEXT : return { { 6, 6, 5 } }; - case Format::eAstc6x6x6UnormBlockEXT : return { { 6, 6, 6 } }; - case Format::eAstc6x6x6SrgbBlockEXT : return { { 6, 6, 6 } }; - case Format::eAstc6x6x6SfloatBlockEXT : return { { 6, 6, 6 } }; - - default: return { { 1, 1, 1 } }; - } - } - - // The texel block size in bytes. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t blockSize( Format format ) - { - switch ( format ) - { - case Format::eR4G4UnormPack8 : return 1; - case Format::eR4G4B4A4UnormPack16 : return 2; - case Format::eB4G4R4A4UnormPack16 : return 2; - case Format::eR5G6B5UnormPack16 : return 2; - case Format::eB5G6R5UnormPack16 : return 2; - case Format::eR5G5B5A1UnormPack16 : return 2; - case Format::eB5G5R5A1UnormPack16 : return 2; - case Format::eA1R5G5B5UnormPack16 : return 2; - case Format::eR8Unorm : return 1; - case Format::eR8Snorm : return 1; - case Format::eR8Uscaled : return 1; - case Format::eR8Sscaled : return 1; - case Format::eR8Uint : return 1; - case Format::eR8Sint : return 1; - case Format::eR8Srgb : return 1; - case Format::eR8G8Unorm : return 2; - case Format::eR8G8Snorm : return 2; - case Format::eR8G8Uscaled : return 2; - case Format::eR8G8Sscaled : return 2; - case Format::eR8G8Uint : return 2; - case Format::eR8G8Sint : return 2; - case Format::eR8G8Srgb : return 2; - case Format::eR8G8B8Unorm : return 3; - case Format::eR8G8B8Snorm : return 3; - case Format::eR8G8B8Uscaled : return 3; - case Format::eR8G8B8Sscaled : return 3; - case Format::eR8G8B8Uint : return 3; - case Format::eR8G8B8Sint : return 3; - case Format::eR8G8B8Srgb : return 3; - case Format::eB8G8R8Unorm : return 3; - case Format::eB8G8R8Snorm : return 3; - case Format::eB8G8R8Uscaled : return 3; - case Format::eB8G8R8Sscaled : return 3; - case Format::eB8G8R8Uint : return 3; - case Format::eB8G8R8Sint : return 3; - case Format::eB8G8R8Srgb : return 3; - case Format::eR8G8B8A8Unorm : return 4; - case Format::eR8G8B8A8Snorm : return 4; - case Format::eR8G8B8A8Uscaled : return 4; - case Format::eR8G8B8A8Sscaled : return 4; - case Format::eR8G8B8A8Uint : return 4; - case Format::eR8G8B8A8Sint : return 4; - case Format::eR8G8B8A8Srgb : return 4; - case Format::eB8G8R8A8Unorm : return 4; - case Format::eB8G8R8A8Snorm : return 4; - case Format::eB8G8R8A8Uscaled : return 4; - case Format::eB8G8R8A8Sscaled : return 4; - case Format::eB8G8R8A8Uint : return 4; - case Format::eB8G8R8A8Sint : return 4; - case Format::eB8G8R8A8Srgb : return 4; - case Format::eA8B8G8R8UnormPack32 : return 4; - case Format::eA8B8G8R8SnormPack32 : return 4; - case Format::eA8B8G8R8UscaledPack32 : return 4; - case Format::eA8B8G8R8SscaledPack32 : return 4; - case Format::eA8B8G8R8UintPack32 : return 4; - case Format::eA8B8G8R8SintPack32 : return 4; - case Format::eA8B8G8R8SrgbPack32 : return 4; - case Format::eA2R10G10B10UnormPack32 : return 4; - case Format::eA2R10G10B10SnormPack32 : return 4; - case Format::eA2R10G10B10UscaledPack32 : return 4; - case Format::eA2R10G10B10SscaledPack32 : return 4; - case Format::eA2R10G10B10UintPack32 : return 4; - case Format::eA2R10G10B10SintPack32 : return 4; - case Format::eA2B10G10R10UnormPack32 : return 4; - case Format::eA2B10G10R10SnormPack32 : return 4; - case Format::eA2B10G10R10UscaledPack32 : return 4; - case Format::eA2B10G10R10SscaledPack32 : return 4; - case Format::eA2B10G10R10UintPack32 : return 4; - case Format::eA2B10G10R10SintPack32 : return 4; - case Format::eR16Unorm : return 2; - case Format::eR16Snorm : return 2; - case Format::eR16Uscaled : return 2; - case Format::eR16Sscaled : return 2; - case Format::eR16Uint : return 2; - case Format::eR16Sint : return 2; - case Format::eR16Sfloat : return 2; - case Format::eR16G16Unorm : return 4; - case Format::eR16G16Snorm : return 4; - case Format::eR16G16Uscaled : return 4; - case Format::eR16G16Sscaled : return 4; - case Format::eR16G16Uint : return 4; - case Format::eR16G16Sint : return 4; - case Format::eR16G16Sfloat : return 4; - case Format::eR16G16B16Unorm : return 6; - case Format::eR16G16B16Snorm : return 6; - case Format::eR16G16B16Uscaled : return 6; - case Format::eR16G16B16Sscaled : return 6; - case Format::eR16G16B16Uint : return 6; - case Format::eR16G16B16Sint : return 6; - case Format::eR16G16B16Sfloat : return 6; - case Format::eR16G16B16A16Unorm : return 8; - case Format::eR16G16B16A16Snorm : return 8; - case Format::eR16G16B16A16Uscaled : return 8; - case Format::eR16G16B16A16Sscaled : return 8; - case Format::eR16G16B16A16Uint : return 8; - case Format::eR16G16B16A16Sint : return 8; - case Format::eR16G16B16A16Sfloat : return 8; - case Format::eR32Uint : return 4; - case Format::eR32Sint : return 4; - case Format::eR32Sfloat : return 4; - case Format::eR32G32Uint : return 8; - case Format::eR32G32Sint : return 8; - case Format::eR32G32Sfloat : return 8; - case Format::eR32G32B32Uint : return 12; - case Format::eR32G32B32Sint : return 12; - case Format::eR32G32B32Sfloat : return 12; - case Format::eR32G32B32A32Uint : return 16; - case Format::eR32G32B32A32Sint : return 16; - case Format::eR32G32B32A32Sfloat : return 16; - case Format::eR64Uint : return 8; - case Format::eR64Sint : return 8; - case Format::eR64Sfloat : return 8; - case Format::eR64G64Uint : return 16; - case Format::eR64G64Sint : return 16; - case Format::eR64G64Sfloat : return 16; - case Format::eR64G64B64Uint : return 24; - case Format::eR64G64B64Sint : return 24; - case Format::eR64G64B64Sfloat : return 24; - case Format::eR64G64B64A64Uint : return 32; - case Format::eR64G64B64A64Sint : return 32; - case Format::eR64G64B64A64Sfloat : return 32; - case Format::eB10G11R11UfloatPack32 : return 4; - case Format::eE5B9G9R9UfloatPack32 : return 4; - case Format::eD16Unorm : return 2; - case Format::eX8D24UnormPack32 : return 4; - case Format::eD32Sfloat : return 4; - case Format::eS8Uint : return 1; - case Format::eD16UnormS8Uint : return 3; - case Format::eD24UnormS8Uint : return 4; - case Format::eD32SfloatS8Uint : return 5; - case Format::eBc1RgbUnormBlock : return 8; - case Format::eBc1RgbSrgbBlock : return 8; - case Format::eBc1RgbaUnormBlock : return 8; - case Format::eBc1RgbaSrgbBlock : return 8; - case Format::eBc2UnormBlock : return 16; - case Format::eBc2SrgbBlock : return 16; - case Format::eBc3UnormBlock : return 16; - case Format::eBc3SrgbBlock : return 16; - case Format::eBc4UnormBlock : return 8; - case Format::eBc4SnormBlock : return 8; - case Format::eBc5UnormBlock : return 16; - case Format::eBc5SnormBlock : return 16; - case Format::eBc6HUfloatBlock : return 16; - case Format::eBc6HSfloatBlock : return 16; - case Format::eBc7UnormBlock : return 16; - case Format::eBc7SrgbBlock : return 16; - case Format::eEtc2R8G8B8UnormBlock : return 8; - case Format::eEtc2R8G8B8SrgbBlock : return 8; - case Format::eEtc2R8G8B8A1UnormBlock : return 8; - case Format::eEtc2R8G8B8A1SrgbBlock : return 8; - case Format::eEtc2R8G8B8A8UnormBlock : return 16; - case Format::eEtc2R8G8B8A8SrgbBlock : return 16; - case Format::eEacR11UnormBlock : return 8; - case Format::eEacR11SnormBlock : return 8; - case Format::eEacR11G11UnormBlock : return 16; - case Format::eEacR11G11SnormBlock : return 16; - case Format::eAstc4x4UnormBlock : return 16; - case Format::eAstc4x4SrgbBlock : return 16; - case Format::eAstc5x4UnormBlock : return 16; - case Format::eAstc5x4SrgbBlock : return 16; - case Format::eAstc5x5UnormBlock : return 16; - case Format::eAstc5x5SrgbBlock : return 16; - case Format::eAstc6x5UnormBlock : return 16; - case Format::eAstc6x5SrgbBlock : return 16; - case Format::eAstc6x6UnormBlock : return 16; - case Format::eAstc6x6SrgbBlock : return 16; - case Format::eAstc8x5UnormBlock : return 16; - case Format::eAstc8x5SrgbBlock : return 16; - case Format::eAstc8x6UnormBlock : return 16; - case Format::eAstc8x6SrgbBlock : return 16; - case Format::eAstc8x8UnormBlock : return 16; - case Format::eAstc8x8SrgbBlock : return 16; - case Format::eAstc10x5UnormBlock : return 16; - case Format::eAstc10x5SrgbBlock : return 16; - case Format::eAstc10x6UnormBlock : return 16; - case Format::eAstc10x6SrgbBlock : return 16; - case Format::eAstc10x8UnormBlock : return 16; - case Format::eAstc10x8SrgbBlock : return 16; - case Format::eAstc10x10UnormBlock : return 16; - case Format::eAstc10x10SrgbBlock : return 16; - case Format::eAstc12x10UnormBlock : return 16; - case Format::eAstc12x10SrgbBlock : return 16; - case Format::eAstc12x12UnormBlock : return 16; - case Format::eAstc12x12SrgbBlock : return 16; - case Format::eG8B8G8R8422Unorm : return 4; - case Format::eB8G8R8G8422Unorm : return 4; - case Format::eG8B8R83Plane420Unorm : return 3; - case Format::eG8B8R82Plane420Unorm : return 3; - case Format::eG8B8R83Plane422Unorm : return 3; - case Format::eG8B8R82Plane422Unorm : return 3; - case Format::eG8B8R83Plane444Unorm : return 3; - case Format::eR10X6UnormPack16 : return 2; - case Format::eR10X6G10X6Unorm2Pack16 : return 4; - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return 8; - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return 8; - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return 8; - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return 6; - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return 6; - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return 6; - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return 6; - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return 6; - case Format::eR12X4UnormPack16 : return 2; - case Format::eR12X4G12X4Unorm2Pack16 : return 4; - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return 8; - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return 8; - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return 8; - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return 6; - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return 6; - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return 6; - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return 6; - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return 6; - case Format::eG16B16G16R16422Unorm : return 8; - case Format::eB16G16R16G16422Unorm : return 8; - case Format::eG16B16R163Plane420Unorm : return 6; - case Format::eG16B16R162Plane420Unorm : return 6; - case Format::eG16B16R163Plane422Unorm : return 6; - case Format::eG16B16R162Plane422Unorm : return 6; - case Format::eG16B16R163Plane444Unorm : return 6; - case Format::eG8B8R82Plane444Unorm : return 3; - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return 6; - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return 6; - case Format::eG16B16R162Plane444Unorm : return 6; - case Format::eA4R4G4B4UnormPack16 : return 2; - case Format::eA4B4G4R4UnormPack16 : return 2; - case Format::eAstc4x4SfloatBlock : return 16; - case Format::eAstc5x4SfloatBlock : return 16; - case Format::eAstc5x5SfloatBlock : return 16; - case Format::eAstc6x5SfloatBlock : return 16; - case Format::eAstc6x6SfloatBlock : return 16; - case Format::eAstc8x5SfloatBlock : return 16; - case Format::eAstc8x6SfloatBlock : return 16; - case Format::eAstc8x8SfloatBlock : return 16; - case Format::eAstc10x5SfloatBlock : return 16; - case Format::eAstc10x6SfloatBlock : return 16; - case Format::eAstc10x8SfloatBlock : return 16; - case Format::eAstc10x10SfloatBlock : return 16; - case Format::eAstc12x10SfloatBlock : return 16; - case Format::eAstc12x12SfloatBlock : return 16; - case Format::eA1B5G5R5UnormPack16 : return 2; - case Format::eA8Unorm : return 1; - case Format::ePvrtc12BppUnormBlockIMG : return 8; - case Format::ePvrtc14BppUnormBlockIMG : return 8; - case Format::ePvrtc22BppUnormBlockIMG : return 8; - case Format::ePvrtc24BppUnormBlockIMG : return 8; - case Format::ePvrtc12BppSrgbBlockIMG : return 8; - case Format::ePvrtc14BppSrgbBlockIMG : return 8; - case Format::ePvrtc22BppSrgbBlockIMG : return 8; - case Format::ePvrtc24BppSrgbBlockIMG : return 8; - case Format::eAstc3x3x3UnormBlockEXT : return 16; - case Format::eAstc3x3x3SrgbBlockEXT : return 16; - case Format::eAstc3x3x3SfloatBlockEXT : return 16; - case Format::eAstc4x3x3UnormBlockEXT : return 16; - case Format::eAstc4x3x3SrgbBlockEXT : return 16; - case Format::eAstc4x3x3SfloatBlockEXT : return 16; - case Format::eAstc4x4x3UnormBlockEXT : return 16; - case Format::eAstc4x4x3SrgbBlockEXT : return 16; - case Format::eAstc4x4x3SfloatBlockEXT : return 16; - case Format::eAstc4x4x4UnormBlockEXT : return 16; - case Format::eAstc4x4x4SrgbBlockEXT : return 16; - case Format::eAstc4x4x4SfloatBlockEXT : return 16; - case Format::eAstc5x4x4UnormBlockEXT : return 16; - case Format::eAstc5x4x4SrgbBlockEXT : return 16; - case Format::eAstc5x4x4SfloatBlockEXT : return 16; - case Format::eAstc5x5x4UnormBlockEXT : return 16; - case Format::eAstc5x5x4SrgbBlockEXT : return 16; - case Format::eAstc5x5x4SfloatBlockEXT : return 16; - case Format::eAstc5x5x5UnormBlockEXT : return 16; - case Format::eAstc5x5x5SrgbBlockEXT : return 16; - case Format::eAstc5x5x5SfloatBlockEXT : return 16; - case Format::eAstc6x5x5UnormBlockEXT : return 16; - case Format::eAstc6x5x5SrgbBlockEXT : return 16; - case Format::eAstc6x5x5SfloatBlockEXT : return 16; - case Format::eAstc6x6x5UnormBlockEXT : return 16; - case Format::eAstc6x6x5SrgbBlockEXT : return 16; - case Format::eAstc6x6x5SfloatBlockEXT : return 16; - case Format::eAstc6x6x6UnormBlockEXT : return 16; - case Format::eAstc6x6x6SrgbBlockEXT : return 16; - case Format::eAstc6x6x6SfloatBlockEXT : return 16; - case Format::eR8BoolARM : return 1; - case Format::eR16G16Sfixed5NV : return 4; - case Format::eR10X6UintPack16ARM : return 2; - case Format::eR10X6G10X6Uint2Pack16ARM : return 4; - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return 8; - case Format::eR12X4UintPack16ARM : return 2; - case Format::eR12X4G12X4Uint2Pack16ARM : return 4; - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return 8; - case Format::eR14X2UintPack16ARM : return 2; - case Format::eR14X2G14X2Uint2Pack16ARM : return 4; - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return 8; - case Format::eR14X2UnormPack16ARM : return 2; - case Format::eR14X2G14X2Unorm2Pack16ARM : return 4; - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return 8; - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return 6; - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return 6; - - default: VULKAN_HPP_ASSERT( false ); return 0; - } - } - - // The class of the format (can't be just named "class"!) - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 char const * compatibilityClass( Format format ) - { - switch ( format ) - { - case Format::eR4G4UnormPack8 : return "8-bit"; - case Format::eR4G4B4A4UnormPack16 : return "16-bit"; - case Format::eB4G4R4A4UnormPack16 : return "16-bit"; - case Format::eR5G6B5UnormPack16 : return "16-bit"; - case Format::eB5G6R5UnormPack16 : return "16-bit"; - case Format::eR5G5B5A1UnormPack16 : return "16-bit"; - case Format::eB5G5R5A1UnormPack16 : return "16-bit"; - case Format::eA1R5G5B5UnormPack16 : return "16-bit"; - case Format::eR8Unorm : return "8-bit"; - case Format::eR8Snorm : return "8-bit"; - case Format::eR8Uscaled : return "8-bit"; - case Format::eR8Sscaled : return "8-bit"; - case Format::eR8Uint : return "8-bit"; - case Format::eR8Sint : return "8-bit"; - case Format::eR8Srgb : return "8-bit"; - case Format::eR8G8Unorm : return "16-bit"; - case Format::eR8G8Snorm : return "16-bit"; - case Format::eR8G8Uscaled : return "16-bit"; - case Format::eR8G8Sscaled : return "16-bit"; - case Format::eR8G8Uint : return "16-bit"; - case Format::eR8G8Sint : return "16-bit"; - case Format::eR8G8Srgb : return "16-bit"; - case Format::eR8G8B8Unorm : return "24-bit"; - case Format::eR8G8B8Snorm : return "24-bit"; - case Format::eR8G8B8Uscaled : return "24-bit"; - case Format::eR8G8B8Sscaled : return "24-bit"; - case Format::eR8G8B8Uint : return "24-bit"; - case Format::eR8G8B8Sint : return "24-bit"; - case Format::eR8G8B8Srgb : return "24-bit"; - case Format::eB8G8R8Unorm : return "24-bit"; - case Format::eB8G8R8Snorm : return "24-bit"; - case Format::eB8G8R8Uscaled : return "24-bit"; - case Format::eB8G8R8Sscaled : return "24-bit"; - case Format::eB8G8R8Uint : return "24-bit"; - case Format::eB8G8R8Sint : return "24-bit"; - case Format::eB8G8R8Srgb : return "24-bit"; - case Format::eR8G8B8A8Unorm : return "32-bit"; - case Format::eR8G8B8A8Snorm : return "32-bit"; - case Format::eR8G8B8A8Uscaled : return "32-bit"; - case Format::eR8G8B8A8Sscaled : return "32-bit"; - case Format::eR8G8B8A8Uint : return "32-bit"; - case Format::eR8G8B8A8Sint : return "32-bit"; - case Format::eR8G8B8A8Srgb : return "32-bit"; - case Format::eB8G8R8A8Unorm : return "32-bit"; - case Format::eB8G8R8A8Snorm : return "32-bit"; - case Format::eB8G8R8A8Uscaled : return "32-bit"; - case Format::eB8G8R8A8Sscaled : return "32-bit"; - case Format::eB8G8R8A8Uint : return "32-bit"; - case Format::eB8G8R8A8Sint : return "32-bit"; - case Format::eB8G8R8A8Srgb : return "32-bit"; - case Format::eA8B8G8R8UnormPack32 : return "32-bit"; - case Format::eA8B8G8R8SnormPack32 : return "32-bit"; - case Format::eA8B8G8R8UscaledPack32 : return "32-bit"; - case Format::eA8B8G8R8SscaledPack32 : return "32-bit"; - case Format::eA8B8G8R8UintPack32 : return "32-bit"; - case Format::eA8B8G8R8SintPack32 : return "32-bit"; - case Format::eA8B8G8R8SrgbPack32 : return "32-bit"; - case Format::eA2R10G10B10UnormPack32 : return "32-bit"; - case Format::eA2R10G10B10SnormPack32 : return "32-bit"; - case Format::eA2R10G10B10UscaledPack32 : return "32-bit"; - case Format::eA2R10G10B10SscaledPack32 : return "32-bit"; - case Format::eA2R10G10B10UintPack32 : return "32-bit"; - case Format::eA2R10G10B10SintPack32 : return "32-bit"; - case Format::eA2B10G10R10UnormPack32 : return "32-bit"; - case Format::eA2B10G10R10SnormPack32 : return "32-bit"; - case Format::eA2B10G10R10UscaledPack32 : return "32-bit"; - case Format::eA2B10G10R10SscaledPack32 : return "32-bit"; - case Format::eA2B10G10R10UintPack32 : return "32-bit"; - case Format::eA2B10G10R10SintPack32 : return "32-bit"; - case Format::eR16Unorm : return "16-bit"; - case Format::eR16Snorm : return "16-bit"; - case Format::eR16Uscaled : return "16-bit"; - case Format::eR16Sscaled : return "16-bit"; - case Format::eR16Uint : return "16-bit"; - case Format::eR16Sint : return "16-bit"; - case Format::eR16Sfloat : return "16-bit"; - case Format::eR16G16Unorm : return "32-bit"; - case Format::eR16G16Snorm : return "32-bit"; - case Format::eR16G16Uscaled : return "32-bit"; - case Format::eR16G16Sscaled : return "32-bit"; - case Format::eR16G16Uint : return "32-bit"; - case Format::eR16G16Sint : return "32-bit"; - case Format::eR16G16Sfloat : return "32-bit"; - case Format::eR16G16B16Unorm : return "48-bit"; - case Format::eR16G16B16Snorm : return "48-bit"; - case Format::eR16G16B16Uscaled : return "48-bit"; - case Format::eR16G16B16Sscaled : return "48-bit"; - case Format::eR16G16B16Uint : return "48-bit"; - case Format::eR16G16B16Sint : return "48-bit"; - case Format::eR16G16B16Sfloat : return "48-bit"; - case Format::eR16G16B16A16Unorm : return "64-bit"; - case Format::eR16G16B16A16Snorm : return "64-bit"; - case Format::eR16G16B16A16Uscaled : return "64-bit"; - case Format::eR16G16B16A16Sscaled : return "64-bit"; - case Format::eR16G16B16A16Uint : return "64-bit"; - case Format::eR16G16B16A16Sint : return "64-bit"; - case Format::eR16G16B16A16Sfloat : return "64-bit"; - case Format::eR32Uint : return "32-bit"; - case Format::eR32Sint : return "32-bit"; - case Format::eR32Sfloat : return "32-bit"; - case Format::eR32G32Uint : return "64-bit"; - case Format::eR32G32Sint : return "64-bit"; - case Format::eR32G32Sfloat : return "64-bit"; - case Format::eR32G32B32Uint : return "96-bit"; - case Format::eR32G32B32Sint : return "96-bit"; - case Format::eR32G32B32Sfloat : return "96-bit"; - case Format::eR32G32B32A32Uint : return "128-bit"; - case Format::eR32G32B32A32Sint : return "128-bit"; - case Format::eR32G32B32A32Sfloat : return "128-bit"; - case Format::eR64Uint : return "64-bit"; - case Format::eR64Sint : return "64-bit"; - case Format::eR64Sfloat : return "64-bit"; - case Format::eR64G64Uint : return "128-bit"; - case Format::eR64G64Sint : return "128-bit"; - case Format::eR64G64Sfloat : return "128-bit"; - case Format::eR64G64B64Uint : return "192-bit"; - case Format::eR64G64B64Sint : return "192-bit"; - case Format::eR64G64B64Sfloat : return "192-bit"; - case Format::eR64G64B64A64Uint : return "256-bit"; - case Format::eR64G64B64A64Sint : return "256-bit"; - case Format::eR64G64B64A64Sfloat : return "256-bit"; - case Format::eB10G11R11UfloatPack32 : return "32-bit"; - case Format::eE5B9G9R9UfloatPack32 : return "32-bit"; - case Format::eD16Unorm : return "D16"; - case Format::eX8D24UnormPack32 : return "D24"; - case Format::eD32Sfloat : return "D32"; - case Format::eS8Uint : return "S8"; - case Format::eD16UnormS8Uint : return "D16S8"; - case Format::eD24UnormS8Uint : return "D24S8"; - case Format::eD32SfloatS8Uint : return "D32S8"; - case Format::eBc1RgbUnormBlock : return "BC1_RGB"; - case Format::eBc1RgbSrgbBlock : return "BC1_RGB"; - case Format::eBc1RgbaUnormBlock : return "BC1_RGBA"; - case Format::eBc1RgbaSrgbBlock : return "BC1_RGBA"; - case Format::eBc2UnormBlock : return "BC2"; - case Format::eBc2SrgbBlock : return "BC2"; - case Format::eBc3UnormBlock : return "BC3"; - case Format::eBc3SrgbBlock : return "BC3"; - case Format::eBc4UnormBlock : return "BC4"; - case Format::eBc4SnormBlock : return "BC4"; - case Format::eBc5UnormBlock : return "BC5"; - case Format::eBc5SnormBlock : return "BC5"; - case Format::eBc6HUfloatBlock : return "BC6H"; - case Format::eBc6HSfloatBlock : return "BC6H"; - case Format::eBc7UnormBlock : return "BC7"; - case Format::eBc7SrgbBlock : return "BC7"; - case Format::eEtc2R8G8B8UnormBlock : return "ETC2_RGB"; - case Format::eEtc2R8G8B8SrgbBlock : return "ETC2_RGB"; - case Format::eEtc2R8G8B8A1UnormBlock : return "ETC2_RGBA"; - case Format::eEtc2R8G8B8A1SrgbBlock : return "ETC2_RGBA"; - case Format::eEtc2R8G8B8A8UnormBlock : return "ETC2_EAC_RGBA"; - case Format::eEtc2R8G8B8A8SrgbBlock : return "ETC2_EAC_RGBA"; - case Format::eEacR11UnormBlock : return "EAC_R"; - case Format::eEacR11SnormBlock : return "EAC_R"; - case Format::eEacR11G11UnormBlock : return "EAC_RG"; - case Format::eEacR11G11SnormBlock : return "EAC_RG"; - case Format::eAstc4x4UnormBlock : return "ASTC_4x4"; - case Format::eAstc4x4SrgbBlock : return "ASTC_4x4"; - case Format::eAstc5x4UnormBlock : return "ASTC_5x4"; - case Format::eAstc5x4SrgbBlock : return "ASTC_5x4"; - case Format::eAstc5x5UnormBlock : return "ASTC_5x5"; - case Format::eAstc5x5SrgbBlock : return "ASTC_5x5"; - case Format::eAstc6x5UnormBlock : return "ASTC_6x5"; - case Format::eAstc6x5SrgbBlock : return "ASTC_6x5"; - case Format::eAstc6x6UnormBlock : return "ASTC_6x6"; - case Format::eAstc6x6SrgbBlock : return "ASTC_6x6"; - case Format::eAstc8x5UnormBlock : return "ASTC_8x5"; - case Format::eAstc8x5SrgbBlock : return "ASTC_8x5"; - case Format::eAstc8x6UnormBlock : return "ASTC_8x6"; - case Format::eAstc8x6SrgbBlock : return "ASTC_8x6"; - case Format::eAstc8x8UnormBlock : return "ASTC_8x8"; - case Format::eAstc8x8SrgbBlock : return "ASTC_8x8"; - case Format::eAstc10x5UnormBlock : return "ASTC_10x5"; - case Format::eAstc10x5SrgbBlock : return "ASTC_10x5"; - case Format::eAstc10x6UnormBlock : return "ASTC_10x6"; - case Format::eAstc10x6SrgbBlock : return "ASTC_10x6"; - case Format::eAstc10x8UnormBlock : return "ASTC_10x8"; - case Format::eAstc10x8SrgbBlock : return "ASTC_10x8"; - case Format::eAstc10x10UnormBlock : return "ASTC_10x10"; - case Format::eAstc10x10SrgbBlock : return "ASTC_10x10"; - case Format::eAstc12x10UnormBlock : return "ASTC_12x10"; - case Format::eAstc12x10SrgbBlock : return "ASTC_12x10"; - case Format::eAstc12x12UnormBlock : return "ASTC_12x12"; - case Format::eAstc12x12SrgbBlock : return "ASTC_12x12"; - case Format::eG8B8G8R8422Unorm : return "32-bit G8B8G8R8"; - case Format::eB8G8R8G8422Unorm : return "32-bit B8G8R8G8"; - case Format::eG8B8R83Plane420Unorm : return "8-bit 3-plane 420"; - case Format::eG8B8R82Plane420Unorm : return "8-bit 2-plane 420"; - case Format::eG8B8R83Plane422Unorm : return "8-bit 3-plane 422"; - case Format::eG8B8R82Plane422Unorm : return "8-bit 2-plane 422"; - case Format::eG8B8R83Plane444Unorm : return "8-bit 3-plane 444"; - case Format::eR10X6UnormPack16 : return "16-bit"; - case Format::eR10X6G10X6Unorm2Pack16 : return "32-bit"; - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return "64-bit R10G10B10A10"; - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return "64-bit G10B10G10R10"; - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return "64-bit B10G10R10G10"; - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return "10-bit 3-plane 420"; - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return "10-bit 2-plane 420"; - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return "10-bit 3-plane 422"; - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return "10-bit 2-plane 422"; - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return "10-bit 3-plane 444"; - case Format::eR12X4UnormPack16 : return "16-bit"; - case Format::eR12X4G12X4Unorm2Pack16 : return "32-bit"; - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return "64-bit R12G12B12A12"; - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return "64-bit G12B12G12R12"; - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return "64-bit B12G12R12G12"; - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return "12-bit 3-plane 420"; - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return "12-bit 2-plane 420"; - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return "12-bit 3-plane 422"; - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return "12-bit 2-plane 422"; - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return "12-bit 3-plane 444"; - case Format::eG16B16G16R16422Unorm : return "64-bit G16B16G16R16"; - case Format::eB16G16R16G16422Unorm : return "64-bit B16G16R16G16"; - case Format::eG16B16R163Plane420Unorm : return "16-bit 3-plane 420"; - case Format::eG16B16R162Plane420Unorm : return "16-bit 2-plane 420"; - case Format::eG16B16R163Plane422Unorm : return "16-bit 3-plane 422"; - case Format::eG16B16R162Plane422Unorm : return "16-bit 2-plane 422"; - case Format::eG16B16R163Plane444Unorm : return "16-bit 3-plane 444"; - case Format::eG8B8R82Plane444Unorm : return "8-bit 2-plane 444"; - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return "10-bit 2-plane 444"; - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return "12-bit 2-plane 444"; - case Format::eG16B16R162Plane444Unorm : return "16-bit 2-plane 444"; - case Format::eA4R4G4B4UnormPack16 : return "16-bit"; - case Format::eA4B4G4R4UnormPack16 : return "16-bit"; - case Format::eAstc4x4SfloatBlock : return "ASTC_4x4"; - case Format::eAstc5x4SfloatBlock : return "ASTC_5x4"; - case Format::eAstc5x5SfloatBlock : return "ASTC_5x5"; - case Format::eAstc6x5SfloatBlock : return "ASTC_6x5"; - case Format::eAstc6x6SfloatBlock : return "ASTC_6x6"; - case Format::eAstc8x5SfloatBlock : return "ASTC_8x5"; - case Format::eAstc8x6SfloatBlock : return "ASTC_8x6"; - case Format::eAstc8x8SfloatBlock : return "ASTC_8x8"; - case Format::eAstc10x5SfloatBlock : return "ASTC_10x5"; - case Format::eAstc10x6SfloatBlock : return "ASTC_10x6"; - case Format::eAstc10x8SfloatBlock : return "ASTC_10x8"; - case Format::eAstc10x10SfloatBlock : return "ASTC_10x10"; - case Format::eAstc12x10SfloatBlock : return "ASTC_12x10"; - case Format::eAstc12x12SfloatBlock : return "ASTC_12x12"; - case Format::eA1B5G5R5UnormPack16 : return "16-bit"; - case Format::eA8Unorm : return "8-bit alpha"; - case Format::ePvrtc12BppUnormBlockIMG : return "PVRTC1_2BPP"; - case Format::ePvrtc14BppUnormBlockIMG : return "PVRTC1_4BPP"; - case Format::ePvrtc22BppUnormBlockIMG : return "PVRTC2_2BPP"; - case Format::ePvrtc24BppUnormBlockIMG : return "PVRTC2_4BPP"; - case Format::ePvrtc12BppSrgbBlockIMG : return "PVRTC1_2BPP"; - case Format::ePvrtc14BppSrgbBlockIMG : return "PVRTC1_4BPP"; - case Format::ePvrtc22BppSrgbBlockIMG : return "PVRTC2_2BPP"; - case Format::ePvrtc24BppSrgbBlockIMG : return "PVRTC2_4BPP"; - case Format::eAstc3x3x3UnormBlockEXT : return "ASTC_3x3x3"; - case Format::eAstc3x3x3SrgbBlockEXT : return "ASTC_3x3x3"; - case Format::eAstc3x3x3SfloatBlockEXT : return "ASTC_3x3x3"; - case Format::eAstc4x3x3UnormBlockEXT : return "ASTC_4x3x3"; - case Format::eAstc4x3x3SrgbBlockEXT : return "ASTC_4x3x3"; - case Format::eAstc4x3x3SfloatBlockEXT : return "ASTC_4x3x3"; - case Format::eAstc4x4x3UnormBlockEXT : return "ASTC_4x4x3"; - case Format::eAstc4x4x3SrgbBlockEXT : return "ASTC_4x4x3"; - case Format::eAstc4x4x3SfloatBlockEXT : return "ASTC_4x4x3"; - case Format::eAstc4x4x4UnormBlockEXT : return "ASTC_4x4x4"; - case Format::eAstc4x4x4SrgbBlockEXT : return "ASTC_4x4x4"; - case Format::eAstc4x4x4SfloatBlockEXT : return "ASTC_4x4x4"; - case Format::eAstc5x4x4UnormBlockEXT : return "ASTC_5x4x4"; - case Format::eAstc5x4x4SrgbBlockEXT : return "ASTC_5x4x4"; - case Format::eAstc5x4x4SfloatBlockEXT : return "ASTC_5x4x4"; - case Format::eAstc5x5x4UnormBlockEXT : return "ASTC_5x5x4"; - case Format::eAstc5x5x4SrgbBlockEXT : return "ASTC_5x5x4"; - case Format::eAstc5x5x4SfloatBlockEXT : return "ASTC_5x5x4"; - case Format::eAstc5x5x5UnormBlockEXT : return "ASTC_5x5x5"; - case Format::eAstc5x5x5SrgbBlockEXT : return "ASTC_5x5x5"; - case Format::eAstc5x5x5SfloatBlockEXT : return "ASTC_5x5x5"; - case Format::eAstc6x5x5UnormBlockEXT : return "ASTC_6x5x5"; - case Format::eAstc6x5x5SrgbBlockEXT : return "ASTC_6x5x5"; - case Format::eAstc6x5x5SfloatBlockEXT : return "ASTC_6x5x5"; - case Format::eAstc6x6x5UnormBlockEXT : return "ASTC_6x6x5"; - case Format::eAstc6x6x5SrgbBlockEXT : return "ASTC_6x6x5"; - case Format::eAstc6x6x5SfloatBlockEXT : return "ASTC_6x6x5"; - case Format::eAstc6x6x6UnormBlockEXT : return "ASTC_6x6x6"; - case Format::eAstc6x6x6SrgbBlockEXT : return "ASTC_6x6x6"; - case Format::eAstc6x6x6SfloatBlockEXT : return "ASTC_6x6x6"; - case Format::eR8BoolARM : return "8-bit"; - case Format::eR16G16Sfixed5NV : return "32-bit"; - case Format::eR10X6UintPack16ARM : return "16-bit"; - case Format::eR10X6G10X6Uint2Pack16ARM : return "32-bit"; - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return "64-bit R10G10B10A10"; - case Format::eR12X4UintPack16ARM : return "16-bit"; - case Format::eR12X4G12X4Uint2Pack16ARM : return "32-bit"; - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return "64-bit R12G12B12A12"; - case Format::eR14X2UintPack16ARM : return "16-bit"; - case Format::eR14X2G14X2Uint2Pack16ARM : return "32-bit"; - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return "64-bit R14G14B14A14"; - case Format::eR14X2UnormPack16ARM : return "16-bit"; - case Format::eR14X2G14X2Unorm2Pack16ARM : return "32-bit"; - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return "64-bit R14G14B14A14"; - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return "14-bit 2-plane 420"; - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return "14-bit 2-plane 422"; - - default: VULKAN_HPP_ASSERT( false ); return ""; - } - } - - // The number of bits in this component, if not compressed, otherwise 0. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t componentBits( Format format, uint8_t component ) - { - switch ( format ) - { - case Format::eR4G4UnormPack8: - switch ( component ) - { - case 0 : return 4; - case 1 : return 4; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR4G4B4A4UnormPack16: - switch ( component ) - { - case 0 : return 4; - case 1 : return 4; - case 2 : return 4; - case 3 : return 4; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB4G4R4A4UnormPack16: - switch ( component ) - { - case 0 : return 4; - case 1 : return 4; - case 2 : return 4; - case 3 : return 4; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR5G6B5UnormPack16: - switch ( component ) - { - case 0 : return 5; - case 1 : return 6; - case 2 : return 5; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB5G6R5UnormPack16: - switch ( component ) - { - case 0 : return 5; - case 1 : return 6; - case 2 : return 5; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR5G5B5A1UnormPack16: - switch ( component ) - { - case 0 : return 5; - case 1 : return 5; - case 2 : return 5; - case 3 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB5G5R5A1UnormPack16: - switch ( component ) - { - case 0 : return 5; - case 1 : return 5; - case 2 : return 5; - case 3 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA1R5G5B5UnormPack16: - switch ( component ) - { - case 0 : return 1; - case 1 : return 5; - case 2 : return 5; - case 3 : return 5; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8Unorm: - switch ( component ) - { - case 0 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8Snorm: - switch ( component ) - { - case 0 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8Uscaled: - switch ( component ) - { - case 0 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8Sscaled: - switch ( component ) - { - case 0 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8Uint: - switch ( component ) - { - case 0 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8Sint: - switch ( component ) - { - case 0 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8Srgb: - switch ( component ) - { - case 0 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8Snorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8Uscaled: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8Sscaled: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8Uint: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8Sint: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8Srgb: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8Snorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8Uscaled: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8Sscaled: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8Uint: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8Sint: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8Srgb: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8Snorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8Uscaled: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8Sscaled: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8Uint: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8Sint: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8Srgb: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8A8Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8A8Snorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8A8Uscaled: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8A8Sscaled: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8A8Uint: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8A8Sint: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8G8B8A8Srgb: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8A8Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8A8Snorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8A8Uscaled: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8A8Sscaled: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8A8Uint: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8A8Sint: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8A8Srgb: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA8B8G8R8UnormPack32: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA8B8G8R8SnormPack32: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA8B8G8R8UscaledPack32: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA8B8G8R8SscaledPack32: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA8B8G8R8UintPack32: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA8B8G8R8SintPack32: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA8B8G8R8SrgbPack32: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2R10G10B10UnormPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2R10G10B10SnormPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2R10G10B10UscaledPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2R10G10B10SscaledPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2R10G10B10UintPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2R10G10B10SintPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2B10G10R10UnormPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2B10G10R10SnormPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2B10G10R10UscaledPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2B10G10R10SscaledPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2B10G10R10UintPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA2B10G10R10SintPack32: - switch ( component ) - { - case 0 : return 2; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16Unorm: - switch ( component ) - { - case 0 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16Snorm: - switch ( component ) - { - case 0 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16Uscaled: - switch ( component ) - { - case 0 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16Sscaled: - switch ( component ) - { - case 0 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16Uint: - switch ( component ) - { - case 0 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16Sint: - switch ( component ) - { - case 0 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16Sfloat: - switch ( component ) - { - case 0 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16Unorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16Snorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16Uscaled: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16Sscaled: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16Uint: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16Sint: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16Sfloat: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16Unorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16Snorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16Uscaled: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16Sscaled: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16Uint: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16Sint: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16Sfloat: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16A16Unorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - case 3 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16A16Snorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - case 3 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16A16Uscaled: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - case 3 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16A16Sscaled: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - case 3 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16A16Uint: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - case 3 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16A16Sint: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - case 3 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16B16A16Sfloat: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - case 3 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32Uint: - switch ( component ) - { - case 0 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32Sint: - switch ( component ) - { - case 0 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32Sfloat: - switch ( component ) - { - case 0 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32G32Uint: - switch ( component ) - { - case 0 : return 32; - case 1 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32G32Sint: - switch ( component ) - { - case 0 : return 32; - case 1 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32G32Sfloat: - switch ( component ) - { - case 0 : return 32; - case 1 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32G32B32Uint: - switch ( component ) - { - case 0 : return 32; - case 1 : return 32; - case 2 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32G32B32Sint: - switch ( component ) - { - case 0 : return 32; - case 1 : return 32; - case 2 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32G32B32Sfloat: - switch ( component ) - { - case 0 : return 32; - case 1 : return 32; - case 2 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32G32B32A32Uint: - switch ( component ) - { - case 0 : return 32; - case 1 : return 32; - case 2 : return 32; - case 3 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32G32B32A32Sint: - switch ( component ) - { - case 0 : return 32; - case 1 : return 32; - case 2 : return 32; - case 3 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR32G32B32A32Sfloat: - switch ( component ) - { - case 0 : return 32; - case 1 : return 32; - case 2 : return 32; - case 3 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64Uint: - switch ( component ) - { - case 0 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64Sint: - switch ( component ) - { - case 0 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64Sfloat: - switch ( component ) - { - case 0 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64G64Uint: - switch ( component ) - { - case 0 : return 64; - case 1 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64G64Sint: - switch ( component ) - { - case 0 : return 64; - case 1 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64G64Sfloat: - switch ( component ) - { - case 0 : return 64; - case 1 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64G64B64Uint: - switch ( component ) - { - case 0 : return 64; - case 1 : return 64; - case 2 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64G64B64Sint: - switch ( component ) - { - case 0 : return 64; - case 1 : return 64; - case 2 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64G64B64Sfloat: - switch ( component ) - { - case 0 : return 64; - case 1 : return 64; - case 2 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64G64B64A64Uint: - switch ( component ) - { - case 0 : return 64; - case 1 : return 64; - case 2 : return 64; - case 3 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64G64B64A64Sint: - switch ( component ) - { - case 0 : return 64; - case 1 : return 64; - case 2 : return 64; - case 3 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR64G64B64A64Sfloat: - switch ( component ) - { - case 0 : return 64; - case 1 : return 64; - case 2 : return 64; - case 3 : return 64; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB10G11R11UfloatPack32: - switch ( component ) - { - case 0 : return 10; - case 1 : return 11; - case 2 : return 11; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eE5B9G9R9UfloatPack32: - switch ( component ) - { - case 0 : return 9; - case 1 : return 9; - case 2 : return 9; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eD16Unorm: - switch ( component ) - { - case 0 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eX8D24UnormPack32: - switch ( component ) - { - case 0 : return 24; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eD32Sfloat: - switch ( component ) - { - case 0 : return 32; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eS8Uint: - switch ( component ) - { - case 0 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eD16UnormS8Uint: - switch ( component ) - { - case 0 : return 16; - case 1 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eD24UnormS8Uint: - switch ( component ) - { - case 0 : return 24; - case 1 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eD32SfloatS8Uint: - switch ( component ) - { - case 0 : return 32; - case 1 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eEacR11UnormBlock: - switch ( component ) - { - case 0 : return 11; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eEacR11SnormBlock: - switch ( component ) - { - case 0 : return 11; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eEacR11G11UnormBlock: - switch ( component ) - { - case 0 : return 11; - case 1 : return 11; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eEacR11G11SnormBlock: - switch ( component ) - { - case 0 : return 11; - case 1 : return 11; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8G8R8422Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB8G8R8G8422Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - case 3 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8R83Plane420Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8R82Plane420Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8R83Plane422Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8R82Plane422Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8R83Plane444Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR10X6UnormPack16: - switch ( component ) - { - case 0 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR10X6G10X6Unorm2Pack16: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - case 2 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - case 2 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - case 2 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - case 2 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - case 2 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR12X4UnormPack16: - switch ( component ) - { - case 0 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR12X4G12X4Unorm2Pack16: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - case 2 : return 12; - case 3 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - case 2 : return 12; - case 3 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - case 2 : return 12; - case 3 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - case 2 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - case 2 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - case 2 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - case 2 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - case 2 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16G16R16422Unorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - case 3 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eB16G16R16G16422Unorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - case 3 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R163Plane420Unorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R162Plane420Unorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R163Plane422Unorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R162Plane422Unorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R163Plane444Unorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8R82Plane444Unorm: - switch ( component ) - { - case 0 : return 8; - case 1 : return 8; - case 2 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - case 2 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - case 2 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R162Plane444Unorm: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - case 2 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA4R4G4B4UnormPack16: - switch ( component ) - { - case 0 : return 4; - case 1 : return 4; - case 2 : return 4; - case 3 : return 4; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA4B4G4R4UnormPack16: - switch ( component ) - { - case 0 : return 4; - case 1 : return 4; - case 2 : return 4; - case 3 : return 4; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA1B5G5R5UnormPack16: - switch ( component ) - { - case 0 : return 1; - case 1 : return 5; - case 2 : return 5; - case 3 : return 5; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eA8Unorm: - switch ( component ) - { - case 0 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR8BoolARM: - switch ( component ) - { - case 0 : return 8; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR16G16Sfixed5NV: - switch ( component ) - { - case 0 : return 16; - case 1 : return 16; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR10X6UintPack16ARM: - switch ( component ) - { - case 0 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR10X6G10X6Uint2Pack16ARM: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: - switch ( component ) - { - case 0 : return 10; - case 1 : return 10; - case 2 : return 10; - case 3 : return 10; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR12X4UintPack16ARM: - switch ( component ) - { - case 0 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR12X4G12X4Uint2Pack16ARM: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: - switch ( component ) - { - case 0 : return 12; - case 1 : return 12; - case 2 : return 12; - case 3 : return 12; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR14X2UintPack16ARM: - switch ( component ) - { - case 0 : return 14; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR14X2G14X2Uint2Pack16ARM: - switch ( component ) - { - case 0 : return 14; - case 1 : return 14; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: - switch ( component ) - { - case 0 : return 14; - case 1 : return 14; - case 2 : return 14; - case 3 : return 14; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR14X2UnormPack16ARM: - switch ( component ) - { - case 0 : return 14; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR14X2G14X2Unorm2Pack16ARM: - switch ( component ) - { - case 0 : return 14; - case 1 : return 14; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: - switch ( component ) - { - case 0 : return 14; - case 1 : return 14; - case 2 : return 14; - case 3 : return 14; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: - switch ( component ) - { - case 0 : return 14; - case 1 : return 14; - case 2 : return 14; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: - switch ( component ) - { - case 0 : return 14; - case 1 : return 14; - case 2 : return 14; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - - default: return 0; - } - } - - // The number of components of this format. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t componentCount( Format format ) - { - switch ( format ) - { - case Format::eR4G4UnormPack8 : return 2; - case Format::eR4G4B4A4UnormPack16 : return 4; - case Format::eB4G4R4A4UnormPack16 : return 4; - case Format::eR5G6B5UnormPack16 : return 3; - case Format::eB5G6R5UnormPack16 : return 3; - case Format::eR5G5B5A1UnormPack16 : return 4; - case Format::eB5G5R5A1UnormPack16 : return 4; - case Format::eA1R5G5B5UnormPack16 : return 4; - case Format::eR8Unorm : return 1; - case Format::eR8Snorm : return 1; - case Format::eR8Uscaled : return 1; - case Format::eR8Sscaled : return 1; - case Format::eR8Uint : return 1; - case Format::eR8Sint : return 1; - case Format::eR8Srgb : return 1; - case Format::eR8G8Unorm : return 2; - case Format::eR8G8Snorm : return 2; - case Format::eR8G8Uscaled : return 2; - case Format::eR8G8Sscaled : return 2; - case Format::eR8G8Uint : return 2; - case Format::eR8G8Sint : return 2; - case Format::eR8G8Srgb : return 2; - case Format::eR8G8B8Unorm : return 3; - case Format::eR8G8B8Snorm : return 3; - case Format::eR8G8B8Uscaled : return 3; - case Format::eR8G8B8Sscaled : return 3; - case Format::eR8G8B8Uint : return 3; - case Format::eR8G8B8Sint : return 3; - case Format::eR8G8B8Srgb : return 3; - case Format::eB8G8R8Unorm : return 3; - case Format::eB8G8R8Snorm : return 3; - case Format::eB8G8R8Uscaled : return 3; - case Format::eB8G8R8Sscaled : return 3; - case Format::eB8G8R8Uint : return 3; - case Format::eB8G8R8Sint : return 3; - case Format::eB8G8R8Srgb : return 3; - case Format::eR8G8B8A8Unorm : return 4; - case Format::eR8G8B8A8Snorm : return 4; - case Format::eR8G8B8A8Uscaled : return 4; - case Format::eR8G8B8A8Sscaled : return 4; - case Format::eR8G8B8A8Uint : return 4; - case Format::eR8G8B8A8Sint : return 4; - case Format::eR8G8B8A8Srgb : return 4; - case Format::eB8G8R8A8Unorm : return 4; - case Format::eB8G8R8A8Snorm : return 4; - case Format::eB8G8R8A8Uscaled : return 4; - case Format::eB8G8R8A8Sscaled : return 4; - case Format::eB8G8R8A8Uint : return 4; - case Format::eB8G8R8A8Sint : return 4; - case Format::eB8G8R8A8Srgb : return 4; - case Format::eA8B8G8R8UnormPack32 : return 4; - case Format::eA8B8G8R8SnormPack32 : return 4; - case Format::eA8B8G8R8UscaledPack32 : return 4; - case Format::eA8B8G8R8SscaledPack32 : return 4; - case Format::eA8B8G8R8UintPack32 : return 4; - case Format::eA8B8G8R8SintPack32 : return 4; - case Format::eA8B8G8R8SrgbPack32 : return 4; - case Format::eA2R10G10B10UnormPack32 : return 4; - case Format::eA2R10G10B10SnormPack32 : return 4; - case Format::eA2R10G10B10UscaledPack32 : return 4; - case Format::eA2R10G10B10SscaledPack32 : return 4; - case Format::eA2R10G10B10UintPack32 : return 4; - case Format::eA2R10G10B10SintPack32 : return 4; - case Format::eA2B10G10R10UnormPack32 : return 4; - case Format::eA2B10G10R10SnormPack32 : return 4; - case Format::eA2B10G10R10UscaledPack32 : return 4; - case Format::eA2B10G10R10SscaledPack32 : return 4; - case Format::eA2B10G10R10UintPack32 : return 4; - case Format::eA2B10G10R10SintPack32 : return 4; - case Format::eR16Unorm : return 1; - case Format::eR16Snorm : return 1; - case Format::eR16Uscaled : return 1; - case Format::eR16Sscaled : return 1; - case Format::eR16Uint : return 1; - case Format::eR16Sint : return 1; - case Format::eR16Sfloat : return 1; - case Format::eR16G16Unorm : return 2; - case Format::eR16G16Snorm : return 2; - case Format::eR16G16Uscaled : return 2; - case Format::eR16G16Sscaled : return 2; - case Format::eR16G16Uint : return 2; - case Format::eR16G16Sint : return 2; - case Format::eR16G16Sfloat : return 2; - case Format::eR16G16B16Unorm : return 3; - case Format::eR16G16B16Snorm : return 3; - case Format::eR16G16B16Uscaled : return 3; - case Format::eR16G16B16Sscaled : return 3; - case Format::eR16G16B16Uint : return 3; - case Format::eR16G16B16Sint : return 3; - case Format::eR16G16B16Sfloat : return 3; - case Format::eR16G16B16A16Unorm : return 4; - case Format::eR16G16B16A16Snorm : return 4; - case Format::eR16G16B16A16Uscaled : return 4; - case Format::eR16G16B16A16Sscaled : return 4; - case Format::eR16G16B16A16Uint : return 4; - case Format::eR16G16B16A16Sint : return 4; - case Format::eR16G16B16A16Sfloat : return 4; - case Format::eR32Uint : return 1; - case Format::eR32Sint : return 1; - case Format::eR32Sfloat : return 1; - case Format::eR32G32Uint : return 2; - case Format::eR32G32Sint : return 2; - case Format::eR32G32Sfloat : return 2; - case Format::eR32G32B32Uint : return 3; - case Format::eR32G32B32Sint : return 3; - case Format::eR32G32B32Sfloat : return 3; - case Format::eR32G32B32A32Uint : return 4; - case Format::eR32G32B32A32Sint : return 4; - case Format::eR32G32B32A32Sfloat : return 4; - case Format::eR64Uint : return 1; - case Format::eR64Sint : return 1; - case Format::eR64Sfloat : return 1; - case Format::eR64G64Uint : return 2; - case Format::eR64G64Sint : return 2; - case Format::eR64G64Sfloat : return 2; - case Format::eR64G64B64Uint : return 3; - case Format::eR64G64B64Sint : return 3; - case Format::eR64G64B64Sfloat : return 3; - case Format::eR64G64B64A64Uint : return 4; - case Format::eR64G64B64A64Sint : return 4; - case Format::eR64G64B64A64Sfloat : return 4; - case Format::eB10G11R11UfloatPack32 : return 3; - case Format::eE5B9G9R9UfloatPack32 : return 3; - case Format::eD16Unorm : return 1; - case Format::eX8D24UnormPack32 : return 1; - case Format::eD32Sfloat : return 1; - case Format::eS8Uint : return 1; - case Format::eD16UnormS8Uint : return 2; - case Format::eD24UnormS8Uint : return 2; - case Format::eD32SfloatS8Uint : return 2; - case Format::eBc1RgbUnormBlock : return 3; - case Format::eBc1RgbSrgbBlock : return 3; - case Format::eBc1RgbaUnormBlock : return 4; - case Format::eBc1RgbaSrgbBlock : return 4; - case Format::eBc2UnormBlock : return 4; - case Format::eBc2SrgbBlock : return 4; - case Format::eBc3UnormBlock : return 4; - case Format::eBc3SrgbBlock : return 4; - case Format::eBc4UnormBlock : return 1; - case Format::eBc4SnormBlock : return 1; - case Format::eBc5UnormBlock : return 2; - case Format::eBc5SnormBlock : return 2; - case Format::eBc6HUfloatBlock : return 3; - case Format::eBc6HSfloatBlock : return 3; - case Format::eBc7UnormBlock : return 4; - case Format::eBc7SrgbBlock : return 4; - case Format::eEtc2R8G8B8UnormBlock : return 3; - case Format::eEtc2R8G8B8SrgbBlock : return 3; - case Format::eEtc2R8G8B8A1UnormBlock : return 4; - case Format::eEtc2R8G8B8A1SrgbBlock : return 4; - case Format::eEtc2R8G8B8A8UnormBlock : return 4; - case Format::eEtc2R8G8B8A8SrgbBlock : return 4; - case Format::eEacR11UnormBlock : return 1; - case Format::eEacR11SnormBlock : return 1; - case Format::eEacR11G11UnormBlock : return 2; - case Format::eEacR11G11SnormBlock : return 2; - case Format::eAstc4x4UnormBlock : return 4; - case Format::eAstc4x4SrgbBlock : return 4; - case Format::eAstc5x4UnormBlock : return 4; - case Format::eAstc5x4SrgbBlock : return 4; - case Format::eAstc5x5UnormBlock : return 4; - case Format::eAstc5x5SrgbBlock : return 4; - case Format::eAstc6x5UnormBlock : return 4; - case Format::eAstc6x5SrgbBlock : return 4; - case Format::eAstc6x6UnormBlock : return 4; - case Format::eAstc6x6SrgbBlock : return 4; - case Format::eAstc8x5UnormBlock : return 4; - case Format::eAstc8x5SrgbBlock : return 4; - case Format::eAstc8x6UnormBlock : return 4; - case Format::eAstc8x6SrgbBlock : return 4; - case Format::eAstc8x8UnormBlock : return 4; - case Format::eAstc8x8SrgbBlock : return 4; - case Format::eAstc10x5UnormBlock : return 4; - case Format::eAstc10x5SrgbBlock : return 4; - case Format::eAstc10x6UnormBlock : return 4; - case Format::eAstc10x6SrgbBlock : return 4; - case Format::eAstc10x8UnormBlock : return 4; - case Format::eAstc10x8SrgbBlock : return 4; - case Format::eAstc10x10UnormBlock : return 4; - case Format::eAstc10x10SrgbBlock : return 4; - case Format::eAstc12x10UnormBlock : return 4; - case Format::eAstc12x10SrgbBlock : return 4; - case Format::eAstc12x12UnormBlock : return 4; - case Format::eAstc12x12SrgbBlock : return 4; - case Format::eG8B8G8R8422Unorm : return 4; - case Format::eB8G8R8G8422Unorm : return 4; - case Format::eG8B8R83Plane420Unorm : return 3; - case Format::eG8B8R82Plane420Unorm : return 3; - case Format::eG8B8R83Plane422Unorm : return 3; - case Format::eG8B8R82Plane422Unorm : return 3; - case Format::eG8B8R83Plane444Unorm : return 3; - case Format::eR10X6UnormPack16 : return 1; - case Format::eR10X6G10X6Unorm2Pack16 : return 2; - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return 4; - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return 4; - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return 4; - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return 3; - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return 3; - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return 3; - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return 3; - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return 3; - case Format::eR12X4UnormPack16 : return 1; - case Format::eR12X4G12X4Unorm2Pack16 : return 2; - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return 4; - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return 4; - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return 4; - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return 3; - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return 3; - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return 3; - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return 3; - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return 3; - case Format::eG16B16G16R16422Unorm : return 4; - case Format::eB16G16R16G16422Unorm : return 4; - case Format::eG16B16R163Plane420Unorm : return 3; - case Format::eG16B16R162Plane420Unorm : return 3; - case Format::eG16B16R163Plane422Unorm : return 3; - case Format::eG16B16R162Plane422Unorm : return 3; - case Format::eG16B16R163Plane444Unorm : return 3; - case Format::eG8B8R82Plane444Unorm : return 3; - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return 3; - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return 3; - case Format::eG16B16R162Plane444Unorm : return 3; - case Format::eA4R4G4B4UnormPack16 : return 4; - case Format::eA4B4G4R4UnormPack16 : return 4; - case Format::eAstc4x4SfloatBlock : return 4; - case Format::eAstc5x4SfloatBlock : return 4; - case Format::eAstc5x5SfloatBlock : return 4; - case Format::eAstc6x5SfloatBlock : return 4; - case Format::eAstc6x6SfloatBlock : return 4; - case Format::eAstc8x5SfloatBlock : return 4; - case Format::eAstc8x6SfloatBlock : return 4; - case Format::eAstc8x8SfloatBlock : return 4; - case Format::eAstc10x5SfloatBlock : return 4; - case Format::eAstc10x6SfloatBlock : return 4; - case Format::eAstc10x8SfloatBlock : return 4; - case Format::eAstc10x10SfloatBlock : return 4; - case Format::eAstc12x10SfloatBlock : return 4; - case Format::eAstc12x12SfloatBlock : return 4; - case Format::eA1B5G5R5UnormPack16 : return 4; - case Format::eA8Unorm : return 1; - case Format::ePvrtc12BppUnormBlockIMG : return 4; - case Format::ePvrtc14BppUnormBlockIMG : return 4; - case Format::ePvrtc22BppUnormBlockIMG : return 4; - case Format::ePvrtc24BppUnormBlockIMG : return 4; - case Format::ePvrtc12BppSrgbBlockIMG : return 4; - case Format::ePvrtc14BppSrgbBlockIMG : return 4; - case Format::ePvrtc22BppSrgbBlockIMG : return 4; - case Format::ePvrtc24BppSrgbBlockIMG : return 4; - case Format::eAstc3x3x3UnormBlockEXT : return 4; - case Format::eAstc3x3x3SrgbBlockEXT : return 4; - case Format::eAstc3x3x3SfloatBlockEXT : return 4; - case Format::eAstc4x3x3UnormBlockEXT : return 4; - case Format::eAstc4x3x3SrgbBlockEXT : return 4; - case Format::eAstc4x3x3SfloatBlockEXT : return 4; - case Format::eAstc4x4x3UnormBlockEXT : return 4; - case Format::eAstc4x4x3SrgbBlockEXT : return 4; - case Format::eAstc4x4x3SfloatBlockEXT : return 4; - case Format::eAstc4x4x4UnormBlockEXT : return 4; - case Format::eAstc4x4x4SrgbBlockEXT : return 4; - case Format::eAstc4x4x4SfloatBlockEXT : return 4; - case Format::eAstc5x4x4UnormBlockEXT : return 4; - case Format::eAstc5x4x4SrgbBlockEXT : return 4; - case Format::eAstc5x4x4SfloatBlockEXT : return 4; - case Format::eAstc5x5x4UnormBlockEXT : return 4; - case Format::eAstc5x5x4SrgbBlockEXT : return 4; - case Format::eAstc5x5x4SfloatBlockEXT : return 4; - case Format::eAstc5x5x5UnormBlockEXT : return 4; - case Format::eAstc5x5x5SrgbBlockEXT : return 4; - case Format::eAstc5x5x5SfloatBlockEXT : return 4; - case Format::eAstc6x5x5UnormBlockEXT : return 4; - case Format::eAstc6x5x5SrgbBlockEXT : return 4; - case Format::eAstc6x5x5SfloatBlockEXT : return 4; - case Format::eAstc6x6x5UnormBlockEXT : return 4; - case Format::eAstc6x6x5SrgbBlockEXT : return 4; - case Format::eAstc6x6x5SfloatBlockEXT : return 4; - case Format::eAstc6x6x6UnormBlockEXT : return 4; - case Format::eAstc6x6x6SrgbBlockEXT : return 4; - case Format::eAstc6x6x6SfloatBlockEXT : return 4; - case Format::eR8BoolARM : return 1; - case Format::eR16G16Sfixed5NV : return 2; - case Format::eR10X6UintPack16ARM : return 1; - case Format::eR10X6G10X6Uint2Pack16ARM : return 2; - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return 4; - case Format::eR12X4UintPack16ARM : return 1; - case Format::eR12X4G12X4Uint2Pack16ARM : return 2; - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return 4; - case Format::eR14X2UintPack16ARM : return 1; - case Format::eR14X2G14X2Uint2Pack16ARM : return 2; - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return 4; - case Format::eR14X2UnormPack16ARM : return 1; - case Format::eR14X2G14X2Unorm2Pack16ARM : return 2; - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return 4; - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return 3; - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return 3; - - default: return 0; - } - } - - // The name of the component - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 char const * componentName( Format format, uint8_t component ) - { - switch ( format ) - { - case Format::eR4G4UnormPack8: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR4G4B4A4UnormPack16: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB4G4R4A4UnormPack16: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR5G6B5UnormPack16: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB5G6R5UnormPack16: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR5G5B5A1UnormPack16: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB5G5R5A1UnormPack16: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA1R5G5B5UnormPack16: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "R"; - case 2 : return "G"; - case 3 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Unorm: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Snorm: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Uscaled: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Sscaled: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Uint: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Sint: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Srgb: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Unorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Snorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Uscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Sscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Srgb: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Unorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Snorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Uscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Sscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Srgb: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Unorm: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Snorm: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Uscaled: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Sscaled: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Uint: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Sint: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Srgb: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Unorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Snorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Uscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Sscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Srgb: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Unorm: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Snorm: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Uscaled: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Sscaled: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Uint: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Sint: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Srgb: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8UnormPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8SnormPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8UscaledPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8SscaledPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8UintPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8SintPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8SrgbPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10UnormPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "R"; - case 2 : return "G"; - case 3 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10SnormPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "R"; - case 2 : return "G"; - case 3 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10UscaledPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "R"; - case 2 : return "G"; - case 3 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10SscaledPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "R"; - case 2 : return "G"; - case 3 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10UintPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "R"; - case 2 : return "G"; - case 3 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10SintPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "R"; - case 2 : return "G"; - case 3 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10UnormPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10SnormPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10UscaledPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10SscaledPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10UintPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10SintPack32: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Unorm: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Snorm: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Uscaled: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Sscaled: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Uint: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Sint: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Sfloat: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Unorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Snorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Uscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Sscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Sfloat: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Unorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Snorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Uscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Sscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Sfloat: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Unorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Snorm: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Uscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Sscaled: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Sfloat: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32Uint: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32Sint: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32Sfloat: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32Sfloat: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32Sfloat: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32A32Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32A32Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32A32Sfloat: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64Uint: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64Sint: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64Sfloat: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64Sfloat: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64Sfloat: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64A64Uint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64A64Sint: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64A64Sfloat: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB10G11R11UfloatPack32: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eE5B9G9R9UfloatPack32: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eD16Unorm: - switch ( component ) - { - case 0 : return "D"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eX8D24UnormPack32: - switch ( component ) - { - case 0 : return "D"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eD32Sfloat: - switch ( component ) - { - case 0 : return "D"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eS8Uint: - switch ( component ) - { - case 0 : return "S"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eD16UnormS8Uint: - switch ( component ) - { - case 0 : return "D"; - case 1 : return "S"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eD24UnormS8Uint: - switch ( component ) - { - case 0 : return "D"; - case 1 : return "S"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eD32SfloatS8Uint: - switch ( component ) - { - case 0 : return "D"; - case 1 : return "S"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc1RgbUnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc1RgbSrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc1RgbaUnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc1RgbaSrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc2UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc2SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc3UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc3SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc4UnormBlock: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc4SnormBlock: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc5UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc5SnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc6HUfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc6HSfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc7UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc7SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8A1UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8A1SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8A8UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8A8SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEacR11UnormBlock: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEacR11SnormBlock: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEacR11G11UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEacR11G11SnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x5UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x5SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x6UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x6SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x8UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x8SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x5UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x5SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x6UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x6SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x8UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x8SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x10UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x10SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x10UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x10SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x12UnormBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x12SrgbBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8G8R8422Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8G8422Unorm: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R83Plane420Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R82Plane420Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R83Plane422Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R82Plane422Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R83Plane444Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6UnormPack16: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6G10X6Unorm2Pack16: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4UnormPack16: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4G12X4Unorm2Pack16: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16G16R16422Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB16G16R16G16422Unorm: - switch ( component ) - { - case 0 : return "B"; - case 1 : return "G"; - case 2 : return "R"; - case 3 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R163Plane420Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R162Plane420Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R163Plane422Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R162Plane422Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R163Plane444Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R82Plane444Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R162Plane444Unorm: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA4R4G4B4UnormPack16: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "R"; - case 2 : return "G"; - case 3 : return "B"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA4B4G4R4UnormPack16: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x5SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x6SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x8SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x5SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x6SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x8SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x10SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x10SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x12SfloatBlock: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA1B5G5R5UnormPack16: - switch ( component ) - { - case 0 : return "A"; - case 1 : return "B"; - case 2 : return "G"; - case 3 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8Unorm: - switch ( component ) - { - case 0 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc12BppUnormBlockIMG: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc14BppUnormBlockIMG: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc22BppUnormBlockIMG: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc24BppUnormBlockIMG: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc12BppSrgbBlockIMG: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc14BppSrgbBlockIMG: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc22BppSrgbBlockIMG: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc24BppSrgbBlockIMG: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc3x3x3UnormBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc3x3x3SrgbBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc3x3x3SfloatBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x3x3UnormBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x3x3SrgbBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x3x3SfloatBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x3UnormBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x3SrgbBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x3SfloatBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x4UnormBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x4SrgbBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x4SfloatBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4x4UnormBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4x4SrgbBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4x4SfloatBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x4UnormBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x4SrgbBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x4SfloatBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x5UnormBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x5SrgbBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x5SfloatBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5x5UnormBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5x5SrgbBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5x5SfloatBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x5UnormBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x5SrgbBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x5SfloatBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x6UnormBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x6SrgbBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x6SfloatBlockEXT: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8BoolARM: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Sfixed5NV: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6UintPack16ARM: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6G10X6Uint2Pack16ARM: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4UintPack16ARM: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4G12X4Uint2Pack16ARM: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2UintPack16ARM: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2G14X2Uint2Pack16ARM: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2UnormPack16ARM: - switch ( component ) - { - case 0 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2G14X2Unorm2Pack16ARM: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: - switch ( component ) - { - case 0 : return "R"; - case 1 : return "G"; - case 2 : return "B"; - case 3 : return "A"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: - switch ( component ) - { - case 0 : return "G"; - case 1 : return "B"; - case 2 : return "R"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - - default: return ""; - } - } - - // The numeric format of the component - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 char const * componentNumericFormat( Format format, uint8_t component ) - { - switch ( format ) - { - case Format::eR4G4UnormPack8: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR4G4B4A4UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB4G4R4A4UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR5G6B5UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB5G6R5UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR5G5B5A1UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB5G5R5A1UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA1R5G5B5UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Snorm: - switch ( component ) - { - case 0 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Uscaled: - switch ( component ) - { - case 0 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Sscaled: - switch ( component ) - { - case 0 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Uint: - switch ( component ) - { - case 0 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Sint: - switch ( component ) - { - case 0 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8Srgb: - switch ( component ) - { - case 0 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Snorm: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Uscaled: - switch ( component ) - { - case 0 : return "USCALED"; - case 1 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Sscaled: - switch ( component ) - { - case 0 : return "SSCALED"; - case 1 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8Srgb: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Snorm: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - case 2 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Uscaled: - switch ( component ) - { - case 0 : return "USCALED"; - case 1 : return "USCALED"; - case 2 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Sscaled: - switch ( component ) - { - case 0 : return "SSCALED"; - case 1 : return "SSCALED"; - case 2 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8Srgb: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Snorm: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - case 2 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Uscaled: - switch ( component ) - { - case 0 : return "USCALED"; - case 1 : return "USCALED"; - case 2 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Sscaled: - switch ( component ) - { - case 0 : return "SSCALED"; - case 1 : return "SSCALED"; - case 2 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8Srgb: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Snorm: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - case 2 : return "SNORM"; - case 3 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Uscaled: - switch ( component ) - { - case 0 : return "USCALED"; - case 1 : return "USCALED"; - case 2 : return "USCALED"; - case 3 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Sscaled: - switch ( component ) - { - case 0 : return "SSCALED"; - case 1 : return "SSCALED"; - case 2 : return "SSCALED"; - case 3 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - case 3 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - case 3 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8G8B8A8Srgb: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Snorm: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - case 2 : return "SNORM"; - case 3 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Uscaled: - switch ( component ) - { - case 0 : return "USCALED"; - case 1 : return "USCALED"; - case 2 : return "USCALED"; - case 3 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Sscaled: - switch ( component ) - { - case 0 : return "SSCALED"; - case 1 : return "SSCALED"; - case 2 : return "SSCALED"; - case 3 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - case 3 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - case 3 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8A8Srgb: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8UnormPack32: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8SnormPack32: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - case 2 : return "SNORM"; - case 3 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8UscaledPack32: - switch ( component ) - { - case 0 : return "USCALED"; - case 1 : return "USCALED"; - case 2 : return "USCALED"; - case 3 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8SscaledPack32: - switch ( component ) - { - case 0 : return "SSCALED"; - case 1 : return "SSCALED"; - case 2 : return "SSCALED"; - case 3 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8UintPack32: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - case 3 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8SintPack32: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - case 3 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8B8G8R8SrgbPack32: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10UnormPack32: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10SnormPack32: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - case 2 : return "SNORM"; - case 3 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10UscaledPack32: - switch ( component ) - { - case 0 : return "USCALED"; - case 1 : return "USCALED"; - case 2 : return "USCALED"; - case 3 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10SscaledPack32: - switch ( component ) - { - case 0 : return "SSCALED"; - case 1 : return "SSCALED"; - case 2 : return "SSCALED"; - case 3 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10UintPack32: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - case 3 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2R10G10B10SintPack32: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - case 3 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10UnormPack32: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10SnormPack32: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - case 2 : return "SNORM"; - case 3 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10UscaledPack32: - switch ( component ) - { - case 0 : return "USCALED"; - case 1 : return "USCALED"; - case 2 : return "USCALED"; - case 3 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10SscaledPack32: - switch ( component ) - { - case 0 : return "SSCALED"; - case 1 : return "SSCALED"; - case 2 : return "SSCALED"; - case 3 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10UintPack32: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - case 3 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA2B10G10R10SintPack32: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - case 3 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Snorm: - switch ( component ) - { - case 0 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Uscaled: - switch ( component ) - { - case 0 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Sscaled: - switch ( component ) - { - case 0 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Uint: - switch ( component ) - { - case 0 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Sint: - switch ( component ) - { - case 0 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Snorm: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Uscaled: - switch ( component ) - { - case 0 : return "USCALED"; - case 1 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Sscaled: - switch ( component ) - { - case 0 : return "SSCALED"; - case 1 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Snorm: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - case 2 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Uscaled: - switch ( component ) - { - case 0 : return "USCALED"; - case 1 : return "USCALED"; - case 2 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Sscaled: - switch ( component ) - { - case 0 : return "SSCALED"; - case 1 : return "SSCALED"; - case 2 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Snorm: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - case 2 : return "SNORM"; - case 3 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Uscaled: - switch ( component ) - { - case 0 : return "USCALED"; - case 1 : return "USCALED"; - case 2 : return "USCALED"; - case 3 : return "USCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Sscaled: - switch ( component ) - { - case 0 : return "SSCALED"; - case 1 : return "SSCALED"; - case 2 : return "SSCALED"; - case 3 : return "SSCALED"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - case 3 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - case 3 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16B16A16Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32Uint: - switch ( component ) - { - case 0 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32Sint: - switch ( component ) - { - case 0 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32A32Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - case 3 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32A32Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - case 3 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR32G32B32A32Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64Uint: - switch ( component ) - { - case 0 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64Sint: - switch ( component ) - { - case 0 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64A64Uint: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - case 3 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64A64Sint: - switch ( component ) - { - case 0 : return "SINT"; - case 1 : return "SINT"; - case 2 : return "SINT"; - case 3 : return "SINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR64G64B64A64Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB10G11R11UfloatPack32: - switch ( component ) - { - case 0 : return "UFLOAT"; - case 1 : return "UFLOAT"; - case 2 : return "UFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eE5B9G9R9UfloatPack32: - switch ( component ) - { - case 0 : return "UFLOAT"; - case 1 : return "UFLOAT"; - case 2 : return "UFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eD16Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eX8D24UnormPack32: - switch ( component ) - { - case 0 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eD32Sfloat: - switch ( component ) - { - case 0 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eS8Uint: - switch ( component ) - { - case 0 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eD16UnormS8Uint: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eD24UnormS8Uint: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eD32SfloatS8Uint: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc1RgbUnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc1RgbSrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc1RgbaUnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc1RgbaSrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc2UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc2SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc3UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc3SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc4UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc4SnormBlock: - switch ( component ) - { - case 0 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc5UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc5SnormBlock: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc6HUfloatBlock: - switch ( component ) - { - case 0 : return "UFLOAT"; - case 1 : return "UFLOAT"; - case 2 : return "UFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc6HSfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc7UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eBc7SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8A1UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8A1SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8A8UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEtc2R8G8B8A8SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEacR11UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEacR11SnormBlock: - switch ( component ) - { - case 0 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEacR11G11UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eEacR11G11SnormBlock: - switch ( component ) - { - case 0 : return "SNORM"; - case 1 : return "SNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x5UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x5SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x6UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x6SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x8UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x8SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x5UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x5SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x6UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x6SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x8UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x8SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x10UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x10SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x10UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x10SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x12UnormBlock: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x12SrgbBlock: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8G8R8422Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB8G8R8G8422Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R83Plane420Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R82Plane420Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R83Plane422Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R82Plane422Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R83Plane444Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6G10X6Unorm2Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4G12X4Unorm2Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16G16R16422Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eB16G16R16G16422Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R163Plane420Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R162Plane420Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R163Plane422Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R162Plane422Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R163Plane444Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG8B8R82Plane444Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG16B16R162Plane444Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA4R4G4B4UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA4B4G4R4UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x5SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x6SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc8x8SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x5SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x6SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x8SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc10x10SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x10SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc12x12SfloatBlock: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA1B5G5R5UnormPack16: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eA8Unorm: - switch ( component ) - { - case 0 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc12BppUnormBlockIMG: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc14BppUnormBlockIMG: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc22BppUnormBlockIMG: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc24BppUnormBlockIMG: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc12BppSrgbBlockIMG: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc14BppSrgbBlockIMG: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc22BppSrgbBlockIMG: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::ePvrtc24BppSrgbBlockIMG: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc3x3x3UnormBlockEXT: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc3x3x3SrgbBlockEXT: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc3x3x3SfloatBlockEXT: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x3x3UnormBlockEXT: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x3x3SrgbBlockEXT: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x3x3SfloatBlockEXT: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x3UnormBlockEXT: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x3SrgbBlockEXT: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x3SfloatBlockEXT: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x4UnormBlockEXT: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x4SrgbBlockEXT: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc4x4x4SfloatBlockEXT: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4x4UnormBlockEXT: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4x4SrgbBlockEXT: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x4x4SfloatBlockEXT: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x4UnormBlockEXT: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x4SrgbBlockEXT: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x4SfloatBlockEXT: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x5UnormBlockEXT: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x5SrgbBlockEXT: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc5x5x5SfloatBlockEXT: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5x5UnormBlockEXT: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5x5SrgbBlockEXT: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x5x5SfloatBlockEXT: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x5UnormBlockEXT: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x5SrgbBlockEXT: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x5SfloatBlockEXT: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x6UnormBlockEXT: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x6SrgbBlockEXT: - switch ( component ) - { - case 0 : return "SRGB"; - case 1 : return "SRGB"; - case 2 : return "SRGB"; - case 3 : return "SRGB"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eAstc6x6x6SfloatBlockEXT: - switch ( component ) - { - case 0 : return "SFLOAT"; - case 1 : return "SFLOAT"; - case 2 : return "SFLOAT"; - case 3 : return "SFLOAT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR8BoolARM: - switch ( component ) - { - case 0 : return "BOOL"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR16G16Sfixed5NV: - switch ( component ) - { - case 0 : return "SFIXED5"; - case 1 : return "SFIXED5"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6UintPack16ARM: - switch ( component ) - { - case 0 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6G10X6Uint2Pack16ARM: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - case 3 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4UintPack16ARM: - switch ( component ) - { - case 0 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4G12X4Uint2Pack16ARM: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - case 3 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2UintPack16ARM: - switch ( component ) - { - case 0 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2G14X2Uint2Pack16ARM: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: - switch ( component ) - { - case 0 : return "UINT"; - case 1 : return "UINT"; - case 2 : return "UINT"; - case 3 : return "UINT"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2UnormPack16ARM: - switch ( component ) - { - case 0 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2G14X2Unorm2Pack16ARM: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - case 3 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: - switch ( component ) - { - case 0 : return "UNORM"; - case 1 : return "UNORM"; - case 2 : return "UNORM"; - default: VULKAN_HPP_ASSERT( false ); return ""; - } - - default: return ""; - } - } - - // The plane this component lies in. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t componentPlaneIndex( Format format, uint8_t component ) - { - switch ( format ) - { - case Format::eG8B8R83Plane420Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8R82Plane420Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8R83Plane422Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8R82Plane422Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8R83Plane444Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R163Plane420Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R162Plane420Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R163Plane422Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R162Plane422Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R163Plane444Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG8B8R82Plane444Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG16B16R162Plane444Unorm: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: - switch ( component ) - { - case 0 : return 0; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 0; - } - - default: return 0; - } - } - - // True, if the components of this format are compressed, otherwise false. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool componentsAreCompressed( Format format ) - { - switch ( format ) - { - case Format::eBc1RgbUnormBlock: - case Format::eBc1RgbSrgbBlock: - case Format::eBc1RgbaUnormBlock: - case Format::eBc1RgbaSrgbBlock: - case Format::eBc2UnormBlock: - case Format::eBc2SrgbBlock: - case Format::eBc3UnormBlock: - case Format::eBc3SrgbBlock: - case Format::eBc4UnormBlock: - case Format::eBc4SnormBlock: - case Format::eBc5UnormBlock: - case Format::eBc5SnormBlock: - case Format::eBc6HUfloatBlock: - case Format::eBc6HSfloatBlock: - case Format::eBc7UnormBlock: - case Format::eBc7SrgbBlock: - case Format::eEtc2R8G8B8UnormBlock: - case Format::eEtc2R8G8B8SrgbBlock: - case Format::eEtc2R8G8B8A1UnormBlock: - case Format::eEtc2R8G8B8A1SrgbBlock: - case Format::eEtc2R8G8B8A8UnormBlock: - case Format::eEtc2R8G8B8A8SrgbBlock: - case Format::eAstc4x4UnormBlock: - case Format::eAstc4x4SrgbBlock: - case Format::eAstc5x4UnormBlock: - case Format::eAstc5x4SrgbBlock: - case Format::eAstc5x5UnormBlock: - case Format::eAstc5x5SrgbBlock: - case Format::eAstc6x5UnormBlock: - case Format::eAstc6x5SrgbBlock: - case Format::eAstc6x6UnormBlock: - case Format::eAstc6x6SrgbBlock: - case Format::eAstc8x5UnormBlock: - case Format::eAstc8x5SrgbBlock: - case Format::eAstc8x6UnormBlock: - case Format::eAstc8x6SrgbBlock: - case Format::eAstc8x8UnormBlock: - case Format::eAstc8x8SrgbBlock: - case Format::eAstc10x5UnormBlock: - case Format::eAstc10x5SrgbBlock: - case Format::eAstc10x6UnormBlock: - case Format::eAstc10x6SrgbBlock: - case Format::eAstc10x8UnormBlock: - case Format::eAstc10x8SrgbBlock: - case Format::eAstc10x10UnormBlock: - case Format::eAstc10x10SrgbBlock: - case Format::eAstc12x10UnormBlock: - case Format::eAstc12x10SrgbBlock: - case Format::eAstc12x12UnormBlock: - case Format::eAstc12x12SrgbBlock: - case Format::eAstc4x4SfloatBlock: - case Format::eAstc5x4SfloatBlock: - case Format::eAstc5x5SfloatBlock: - case Format::eAstc6x5SfloatBlock: - case Format::eAstc6x6SfloatBlock: - case Format::eAstc8x5SfloatBlock: - case Format::eAstc8x6SfloatBlock: - case Format::eAstc8x8SfloatBlock: - case Format::eAstc10x5SfloatBlock: - case Format::eAstc10x6SfloatBlock: - case Format::eAstc10x8SfloatBlock: - case Format::eAstc10x10SfloatBlock: - case Format::eAstc12x10SfloatBlock: - case Format::eAstc12x12SfloatBlock: - case Format::ePvrtc12BppUnormBlockIMG: - case Format::ePvrtc14BppUnormBlockIMG: - case Format::ePvrtc22BppUnormBlockIMG: - case Format::ePvrtc24BppUnormBlockIMG: - case Format::ePvrtc12BppSrgbBlockIMG: - case Format::ePvrtc14BppSrgbBlockIMG: - case Format::ePvrtc22BppSrgbBlockIMG: - case Format::ePvrtc24BppSrgbBlockIMG: - case Format::eAstc3x3x3UnormBlockEXT: - case Format::eAstc3x3x3SrgbBlockEXT: - case Format::eAstc3x3x3SfloatBlockEXT: - case Format::eAstc4x3x3UnormBlockEXT: - case Format::eAstc4x3x3SrgbBlockEXT: - case Format::eAstc4x3x3SfloatBlockEXT: - case Format::eAstc4x4x3UnormBlockEXT: - case Format::eAstc4x4x3SrgbBlockEXT: - case Format::eAstc4x4x3SfloatBlockEXT: - case Format::eAstc4x4x4UnormBlockEXT: - case Format::eAstc4x4x4SrgbBlockEXT: - case Format::eAstc4x4x4SfloatBlockEXT: - case Format::eAstc5x4x4UnormBlockEXT: - case Format::eAstc5x4x4SrgbBlockEXT: - case Format::eAstc5x4x4SfloatBlockEXT: - case Format::eAstc5x5x4UnormBlockEXT: - case Format::eAstc5x5x4SrgbBlockEXT: - case Format::eAstc5x5x4SfloatBlockEXT: - case Format::eAstc5x5x5UnormBlockEXT: - case Format::eAstc5x5x5SrgbBlockEXT: - case Format::eAstc5x5x5SfloatBlockEXT: - case Format::eAstc6x5x5UnormBlockEXT: - case Format::eAstc6x5x5SrgbBlockEXT: - case Format::eAstc6x5x5SfloatBlockEXT: - case Format::eAstc6x6x5UnormBlockEXT: - case Format::eAstc6x6x5SrgbBlockEXT: - case Format::eAstc6x6x5SfloatBlockEXT: - case Format::eAstc6x6x6UnormBlockEXT: - case Format::eAstc6x6x6SrgbBlockEXT: - case Format::eAstc6x6x6SfloatBlockEXT: return true; - default : return false; - } - } - - // A textual description of the compression scheme, or an empty string if it is not compressed - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 char const * compressionScheme( Format format ) - { - switch ( format ) - { - case Format::eBc1RgbUnormBlock : return "BC"; - case Format::eBc1RgbSrgbBlock : return "BC"; - case Format::eBc1RgbaUnormBlock : return "BC"; - case Format::eBc1RgbaSrgbBlock : return "BC"; - case Format::eBc2UnormBlock : return "BC"; - case Format::eBc2SrgbBlock : return "BC"; - case Format::eBc3UnormBlock : return "BC"; - case Format::eBc3SrgbBlock : return "BC"; - case Format::eBc4UnormBlock : return "BC"; - case Format::eBc4SnormBlock : return "BC"; - case Format::eBc5UnormBlock : return "BC"; - case Format::eBc5SnormBlock : return "BC"; - case Format::eBc6HUfloatBlock : return "BC"; - case Format::eBc6HSfloatBlock : return "BC"; - case Format::eBc7UnormBlock : return "BC"; - case Format::eBc7SrgbBlock : return "BC"; - case Format::eEtc2R8G8B8UnormBlock : return "ETC2"; - case Format::eEtc2R8G8B8SrgbBlock : return "ETC2"; - case Format::eEtc2R8G8B8A1UnormBlock : return "ETC2"; - case Format::eEtc2R8G8B8A1SrgbBlock : return "ETC2"; - case Format::eEtc2R8G8B8A8UnormBlock : return "ETC2"; - case Format::eEtc2R8G8B8A8SrgbBlock : return "ETC2"; - case Format::eEacR11UnormBlock : return "EAC"; - case Format::eEacR11SnormBlock : return "EAC"; - case Format::eEacR11G11UnormBlock : return "EAC"; - case Format::eEacR11G11SnormBlock : return "EAC"; - case Format::eAstc4x4UnormBlock : return "ASTC LDR"; - case Format::eAstc4x4SrgbBlock : return "ASTC LDR"; - case Format::eAstc5x4UnormBlock : return "ASTC LDR"; - case Format::eAstc5x4SrgbBlock : return "ASTC LDR"; - case Format::eAstc5x5UnormBlock : return "ASTC LDR"; - case Format::eAstc5x5SrgbBlock : return "ASTC LDR"; - case Format::eAstc6x5UnormBlock : return "ASTC LDR"; - case Format::eAstc6x5SrgbBlock : return "ASTC LDR"; - case Format::eAstc6x6UnormBlock : return "ASTC LDR"; - case Format::eAstc6x6SrgbBlock : return "ASTC LDR"; - case Format::eAstc8x5UnormBlock : return "ASTC LDR"; - case Format::eAstc8x5SrgbBlock : return "ASTC LDR"; - case Format::eAstc8x6UnormBlock : return "ASTC LDR"; - case Format::eAstc8x6SrgbBlock : return "ASTC LDR"; - case Format::eAstc8x8UnormBlock : return "ASTC LDR"; - case Format::eAstc8x8SrgbBlock : return "ASTC LDR"; - case Format::eAstc10x5UnormBlock : return "ASTC LDR"; - case Format::eAstc10x5SrgbBlock : return "ASTC LDR"; - case Format::eAstc10x6UnormBlock : return "ASTC LDR"; - case Format::eAstc10x6SrgbBlock : return "ASTC LDR"; - case Format::eAstc10x8UnormBlock : return "ASTC LDR"; - case Format::eAstc10x8SrgbBlock : return "ASTC LDR"; - case Format::eAstc10x10UnormBlock : return "ASTC LDR"; - case Format::eAstc10x10SrgbBlock : return "ASTC LDR"; - case Format::eAstc12x10UnormBlock : return "ASTC LDR"; - case Format::eAstc12x10SrgbBlock : return "ASTC LDR"; - case Format::eAstc12x12UnormBlock : return "ASTC LDR"; - case Format::eAstc12x12SrgbBlock : return "ASTC LDR"; - case Format::eAstc4x4SfloatBlock : return "ASTC HDR"; - case Format::eAstc5x4SfloatBlock : return "ASTC HDR"; - case Format::eAstc5x5SfloatBlock : return "ASTC HDR"; - case Format::eAstc6x5SfloatBlock : return "ASTC HDR"; - case Format::eAstc6x6SfloatBlock : return "ASTC HDR"; - case Format::eAstc8x5SfloatBlock : return "ASTC HDR"; - case Format::eAstc8x6SfloatBlock : return "ASTC HDR"; - case Format::eAstc8x8SfloatBlock : return "ASTC HDR"; - case Format::eAstc10x5SfloatBlock : return "ASTC HDR"; - case Format::eAstc10x6SfloatBlock : return "ASTC HDR"; - case Format::eAstc10x8SfloatBlock : return "ASTC HDR"; - case Format::eAstc10x10SfloatBlock : return "ASTC HDR"; - case Format::eAstc12x10SfloatBlock : return "ASTC HDR"; - case Format::eAstc12x12SfloatBlock : return "ASTC HDR"; - case Format::ePvrtc12BppUnormBlockIMG: return "PVRTC"; - case Format::ePvrtc14BppUnormBlockIMG: return "PVRTC"; - case Format::ePvrtc22BppUnormBlockIMG: return "PVRTC"; - case Format::ePvrtc24BppUnormBlockIMG: return "PVRTC"; - case Format::ePvrtc12BppSrgbBlockIMG : return "PVRTC"; - case Format::ePvrtc14BppSrgbBlockIMG : return "PVRTC"; - case Format::ePvrtc22BppSrgbBlockIMG : return "PVRTC"; - case Format::ePvrtc24BppSrgbBlockIMG : return "PVRTC"; - case Format::eAstc3x3x3UnormBlockEXT : return "ASTC LDR"; - case Format::eAstc3x3x3SrgbBlockEXT : return "ASTC LDR"; - case Format::eAstc3x3x3SfloatBlockEXT: return "ASTC HDR"; - case Format::eAstc4x3x3UnormBlockEXT : return "ASTC LDR"; - case Format::eAstc4x3x3SrgbBlockEXT : return "ASTC LDR"; - case Format::eAstc4x3x3SfloatBlockEXT: return "ASTC HDR"; - case Format::eAstc4x4x3UnormBlockEXT : return "ASTC LDR"; - case Format::eAstc4x4x3SrgbBlockEXT : return "ASTC LDR"; - case Format::eAstc4x4x3SfloatBlockEXT: return "ASTC HDR"; - case Format::eAstc4x4x4UnormBlockEXT : return "ASTC LDR"; - case Format::eAstc4x4x4SrgbBlockEXT : return "ASTC LDR"; - case Format::eAstc4x4x4SfloatBlockEXT: return "ASTC HDR"; - case Format::eAstc5x4x4UnormBlockEXT : return "ASTC LDR"; - case Format::eAstc5x4x4SrgbBlockEXT : return "ASTC LDR"; - case Format::eAstc5x4x4SfloatBlockEXT: return "ASTC HDR"; - case Format::eAstc5x5x4UnormBlockEXT : return "ASTC LDR"; - case Format::eAstc5x5x4SrgbBlockEXT : return "ASTC LDR"; - case Format::eAstc5x5x4SfloatBlockEXT: return "ASTC HDR"; - case Format::eAstc5x5x5UnormBlockEXT : return "ASTC LDR"; - case Format::eAstc5x5x5SrgbBlockEXT : return "ASTC LDR"; - case Format::eAstc5x5x5SfloatBlockEXT: return "ASTC HDR"; - case Format::eAstc6x5x5UnormBlockEXT : return "ASTC LDR"; - case Format::eAstc6x5x5SrgbBlockEXT : return "ASTC LDR"; - case Format::eAstc6x5x5SfloatBlockEXT: return "ASTC HDR"; - case Format::eAstc6x6x5UnormBlockEXT : return "ASTC LDR"; - case Format::eAstc6x6x5SrgbBlockEXT : return "ASTC LDR"; - case Format::eAstc6x6x5SfloatBlockEXT: return "ASTC HDR"; - case Format::eAstc6x6x6UnormBlockEXT : return "ASTC LDR"; - case Format::eAstc6x6x6SrgbBlockEXT : return "ASTC LDR"; - case Format::eAstc6x6x6SfloatBlockEXT: return "ASTC HDR"; - - default: return ""; - } - } - - // Get all formats - VULKAN_HPP_INLINE std::vector const & getAllFormats() - { - static std::vector allFormats = { Format::eR4G4UnormPack8, - Format::eR4G4B4A4UnormPack16, - Format::eB4G4R4A4UnormPack16, - Format::eR5G6B5UnormPack16, - Format::eB5G6R5UnormPack16, - Format::eR5G5B5A1UnormPack16, - Format::eB5G5R5A1UnormPack16, - Format::eA1R5G5B5UnormPack16, - Format::eR8Unorm, - Format::eR8Snorm, - Format::eR8Uscaled, - Format::eR8Sscaled, - Format::eR8Uint, - Format::eR8Sint, - Format::eR8Srgb, - Format::eR8G8Unorm, - Format::eR8G8Snorm, - Format::eR8G8Uscaled, - Format::eR8G8Sscaled, - Format::eR8G8Uint, - Format::eR8G8Sint, - Format::eR8G8Srgb, - Format::eR8G8B8Unorm, - Format::eR8G8B8Snorm, - Format::eR8G8B8Uscaled, - Format::eR8G8B8Sscaled, - Format::eR8G8B8Uint, - Format::eR8G8B8Sint, - Format::eR8G8B8Srgb, - Format::eB8G8R8Unorm, - Format::eB8G8R8Snorm, - Format::eB8G8R8Uscaled, - Format::eB8G8R8Sscaled, - Format::eB8G8R8Uint, - Format::eB8G8R8Sint, - Format::eB8G8R8Srgb, - Format::eR8G8B8A8Unorm, - Format::eR8G8B8A8Snorm, - Format::eR8G8B8A8Uscaled, - Format::eR8G8B8A8Sscaled, - Format::eR8G8B8A8Uint, - Format::eR8G8B8A8Sint, - Format::eR8G8B8A8Srgb, - Format::eB8G8R8A8Unorm, - Format::eB8G8R8A8Snorm, - Format::eB8G8R8A8Uscaled, - Format::eB8G8R8A8Sscaled, - Format::eB8G8R8A8Uint, - Format::eB8G8R8A8Sint, - Format::eB8G8R8A8Srgb, - Format::eA8B8G8R8UnormPack32, - Format::eA8B8G8R8SnormPack32, - Format::eA8B8G8R8UscaledPack32, - Format::eA8B8G8R8SscaledPack32, - Format::eA8B8G8R8UintPack32, - Format::eA8B8G8R8SintPack32, - Format::eA8B8G8R8SrgbPack32, - Format::eA2R10G10B10UnormPack32, - Format::eA2R10G10B10SnormPack32, - Format::eA2R10G10B10UscaledPack32, - Format::eA2R10G10B10SscaledPack32, - Format::eA2R10G10B10UintPack32, - Format::eA2R10G10B10SintPack32, - Format::eA2B10G10R10UnormPack32, - Format::eA2B10G10R10SnormPack32, - Format::eA2B10G10R10UscaledPack32, - Format::eA2B10G10R10SscaledPack32, - Format::eA2B10G10R10UintPack32, - Format::eA2B10G10R10SintPack32, - Format::eR16Unorm, - Format::eR16Snorm, - Format::eR16Uscaled, - Format::eR16Sscaled, - Format::eR16Uint, - Format::eR16Sint, - Format::eR16Sfloat, - Format::eR16G16Unorm, - Format::eR16G16Snorm, - Format::eR16G16Uscaled, - Format::eR16G16Sscaled, - Format::eR16G16Uint, - Format::eR16G16Sint, - Format::eR16G16Sfloat, - Format::eR16G16B16Unorm, - Format::eR16G16B16Snorm, - Format::eR16G16B16Uscaled, - Format::eR16G16B16Sscaled, - Format::eR16G16B16Uint, - Format::eR16G16B16Sint, - Format::eR16G16B16Sfloat, - Format::eR16G16B16A16Unorm, - Format::eR16G16B16A16Snorm, - Format::eR16G16B16A16Uscaled, - Format::eR16G16B16A16Sscaled, - Format::eR16G16B16A16Uint, - Format::eR16G16B16A16Sint, - Format::eR16G16B16A16Sfloat, - Format::eR32Uint, - Format::eR32Sint, - Format::eR32Sfloat, - Format::eR32G32Uint, - Format::eR32G32Sint, - Format::eR32G32Sfloat, - Format::eR32G32B32Uint, - Format::eR32G32B32Sint, - Format::eR32G32B32Sfloat, - Format::eR32G32B32A32Uint, - Format::eR32G32B32A32Sint, - Format::eR32G32B32A32Sfloat, - Format::eR64Uint, - Format::eR64Sint, - Format::eR64Sfloat, - Format::eR64G64Uint, - Format::eR64G64Sint, - Format::eR64G64Sfloat, - Format::eR64G64B64Uint, - Format::eR64G64B64Sint, - Format::eR64G64B64Sfloat, - Format::eR64G64B64A64Uint, - Format::eR64G64B64A64Sint, - Format::eR64G64B64A64Sfloat, - Format::eB10G11R11UfloatPack32, - Format::eE5B9G9R9UfloatPack32, - Format::eD16Unorm, - Format::eX8D24UnormPack32, - Format::eD32Sfloat, - Format::eS8Uint, - Format::eD16UnormS8Uint, - Format::eD24UnormS8Uint, - Format::eD32SfloatS8Uint, - Format::eBc1RgbUnormBlock, - Format::eBc1RgbSrgbBlock, - Format::eBc1RgbaUnormBlock, - Format::eBc1RgbaSrgbBlock, - Format::eBc2UnormBlock, - Format::eBc2SrgbBlock, - Format::eBc3UnormBlock, - Format::eBc3SrgbBlock, - Format::eBc4UnormBlock, - Format::eBc4SnormBlock, - Format::eBc5UnormBlock, - Format::eBc5SnormBlock, - Format::eBc6HUfloatBlock, - Format::eBc6HSfloatBlock, - Format::eBc7UnormBlock, - Format::eBc7SrgbBlock, - Format::eEtc2R8G8B8UnormBlock, - Format::eEtc2R8G8B8SrgbBlock, - Format::eEtc2R8G8B8A1UnormBlock, - Format::eEtc2R8G8B8A1SrgbBlock, - Format::eEtc2R8G8B8A8UnormBlock, - Format::eEtc2R8G8B8A8SrgbBlock, - Format::eEacR11UnormBlock, - Format::eEacR11SnormBlock, - Format::eEacR11G11UnormBlock, - Format::eEacR11G11SnormBlock, - Format::eAstc4x4UnormBlock, - Format::eAstc4x4SrgbBlock, - Format::eAstc5x4UnormBlock, - Format::eAstc5x4SrgbBlock, - Format::eAstc5x5UnormBlock, - Format::eAstc5x5SrgbBlock, - Format::eAstc6x5UnormBlock, - Format::eAstc6x5SrgbBlock, - Format::eAstc6x6UnormBlock, - Format::eAstc6x6SrgbBlock, - Format::eAstc8x5UnormBlock, - Format::eAstc8x5SrgbBlock, - Format::eAstc8x6UnormBlock, - Format::eAstc8x6SrgbBlock, - Format::eAstc8x8UnormBlock, - Format::eAstc8x8SrgbBlock, - Format::eAstc10x5UnormBlock, - Format::eAstc10x5SrgbBlock, - Format::eAstc10x6UnormBlock, - Format::eAstc10x6SrgbBlock, - Format::eAstc10x8UnormBlock, - Format::eAstc10x8SrgbBlock, - Format::eAstc10x10UnormBlock, - Format::eAstc10x10SrgbBlock, - Format::eAstc12x10UnormBlock, - Format::eAstc12x10SrgbBlock, - Format::eAstc12x12UnormBlock, - Format::eAstc12x12SrgbBlock, - Format::eG8B8G8R8422Unorm, - Format::eB8G8R8G8422Unorm, - Format::eG8B8R83Plane420Unorm, - Format::eG8B8R82Plane420Unorm, - Format::eG8B8R83Plane422Unorm, - Format::eG8B8R82Plane422Unorm, - Format::eG8B8R83Plane444Unorm, - Format::eR10X6UnormPack16, - Format::eR10X6G10X6Unorm2Pack16, - Format::eR10X6G10X6B10X6A10X6Unorm4Pack16, - Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16, - Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16, - Format::eG10X6B10X6R10X63Plane420Unorm3Pack16, - Format::eG10X6B10X6R10X62Plane420Unorm3Pack16, - Format::eG10X6B10X6R10X63Plane422Unorm3Pack16, - Format::eG10X6B10X6R10X62Plane422Unorm3Pack16, - Format::eG10X6B10X6R10X63Plane444Unorm3Pack16, - Format::eR12X4UnormPack16, - Format::eR12X4G12X4Unorm2Pack16, - Format::eR12X4G12X4B12X4A12X4Unorm4Pack16, - Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16, - Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16, - Format::eG12X4B12X4R12X43Plane420Unorm3Pack16, - Format::eG12X4B12X4R12X42Plane420Unorm3Pack16, - Format::eG12X4B12X4R12X43Plane422Unorm3Pack16, - Format::eG12X4B12X4R12X42Plane422Unorm3Pack16, - Format::eG12X4B12X4R12X43Plane444Unorm3Pack16, - Format::eG16B16G16R16422Unorm, - Format::eB16G16R16G16422Unorm, - Format::eG16B16R163Plane420Unorm, - Format::eG16B16R162Plane420Unorm, - Format::eG16B16R163Plane422Unorm, - Format::eG16B16R162Plane422Unorm, - Format::eG16B16R163Plane444Unorm, - Format::eG8B8R82Plane444Unorm, - Format::eG10X6B10X6R10X62Plane444Unorm3Pack16, - Format::eG12X4B12X4R12X42Plane444Unorm3Pack16, - Format::eG16B16R162Plane444Unorm, - Format::eA4R4G4B4UnormPack16, - Format::eA4B4G4R4UnormPack16, - Format::eAstc4x4SfloatBlock, - Format::eAstc5x4SfloatBlock, - Format::eAstc5x5SfloatBlock, - Format::eAstc6x5SfloatBlock, - Format::eAstc6x6SfloatBlock, - Format::eAstc8x5SfloatBlock, - Format::eAstc8x6SfloatBlock, - Format::eAstc8x8SfloatBlock, - Format::eAstc10x5SfloatBlock, - Format::eAstc10x6SfloatBlock, - Format::eAstc10x8SfloatBlock, - Format::eAstc10x10SfloatBlock, - Format::eAstc12x10SfloatBlock, - Format::eAstc12x12SfloatBlock, - Format::eA1B5G5R5UnormPack16, - Format::eA8Unorm, - Format::ePvrtc12BppUnormBlockIMG, - Format::ePvrtc14BppUnormBlockIMG, - Format::ePvrtc22BppUnormBlockIMG, - Format::ePvrtc24BppUnormBlockIMG, - Format::ePvrtc12BppSrgbBlockIMG, - Format::ePvrtc14BppSrgbBlockIMG, - Format::ePvrtc22BppSrgbBlockIMG, - Format::ePvrtc24BppSrgbBlockIMG, - Format::eAstc3x3x3UnormBlockEXT, - Format::eAstc3x3x3SrgbBlockEXT, - Format::eAstc3x3x3SfloatBlockEXT, - Format::eAstc4x3x3UnormBlockEXT, - Format::eAstc4x3x3SrgbBlockEXT, - Format::eAstc4x3x3SfloatBlockEXT, - Format::eAstc4x4x3UnormBlockEXT, - Format::eAstc4x4x3SrgbBlockEXT, - Format::eAstc4x4x3SfloatBlockEXT, - Format::eAstc4x4x4UnormBlockEXT, - Format::eAstc4x4x4SrgbBlockEXT, - Format::eAstc4x4x4SfloatBlockEXT, - Format::eAstc5x4x4UnormBlockEXT, - Format::eAstc5x4x4SrgbBlockEXT, - Format::eAstc5x4x4SfloatBlockEXT, - Format::eAstc5x5x4UnormBlockEXT, - Format::eAstc5x5x4SrgbBlockEXT, - Format::eAstc5x5x4SfloatBlockEXT, - Format::eAstc5x5x5UnormBlockEXT, - Format::eAstc5x5x5SrgbBlockEXT, - Format::eAstc5x5x5SfloatBlockEXT, - Format::eAstc6x5x5UnormBlockEXT, - Format::eAstc6x5x5SrgbBlockEXT, - Format::eAstc6x5x5SfloatBlockEXT, - Format::eAstc6x6x5UnormBlockEXT, - Format::eAstc6x6x5SrgbBlockEXT, - Format::eAstc6x6x5SfloatBlockEXT, - Format::eAstc6x6x6UnormBlockEXT, - Format::eAstc6x6x6SrgbBlockEXT, - Format::eAstc6x6x6SfloatBlockEXT, - Format::eR8BoolARM, - Format::eR16G16Sfixed5NV, - Format::eR10X6UintPack16ARM, - Format::eR10X6G10X6Uint2Pack16ARM, - Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM, - Format::eR12X4UintPack16ARM, - Format::eR12X4G12X4Uint2Pack16ARM, - Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM, - Format::eR14X2UintPack16ARM, - Format::eR14X2G14X2Uint2Pack16ARM, - Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM, - Format::eR14X2UnormPack16ARM, - Format::eR14X2G14X2Unorm2Pack16ARM, - Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM, - Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM, - Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM }; - return allFormats; - } - - // Get all formats with a color component - VULKAN_HPP_INLINE std::vector const & getColorFormats() - { - static std::vector colorFormats = { Format::eR4G4UnormPack8, - Format::eR4G4B4A4UnormPack16, - Format::eB4G4R4A4UnormPack16, - Format::eR5G6B5UnormPack16, - Format::eB5G6R5UnormPack16, - Format::eR5G5B5A1UnormPack16, - Format::eB5G5R5A1UnormPack16, - Format::eA1R5G5B5UnormPack16, - Format::eR8Unorm, - Format::eR8Snorm, - Format::eR8Uscaled, - Format::eR8Sscaled, - Format::eR8Uint, - Format::eR8Sint, - Format::eR8Srgb, - Format::eR8G8Unorm, - Format::eR8G8Snorm, - Format::eR8G8Uscaled, - Format::eR8G8Sscaled, - Format::eR8G8Uint, - Format::eR8G8Sint, - Format::eR8G8Srgb, - Format::eR8G8B8Unorm, - Format::eR8G8B8Snorm, - Format::eR8G8B8Uscaled, - Format::eR8G8B8Sscaled, - Format::eR8G8B8Uint, - Format::eR8G8B8Sint, - Format::eR8G8B8Srgb, - Format::eB8G8R8Unorm, - Format::eB8G8R8Snorm, - Format::eB8G8R8Uscaled, - Format::eB8G8R8Sscaled, - Format::eB8G8R8Uint, - Format::eB8G8R8Sint, - Format::eB8G8R8Srgb, - Format::eR8G8B8A8Unorm, - Format::eR8G8B8A8Snorm, - Format::eR8G8B8A8Uscaled, - Format::eR8G8B8A8Sscaled, - Format::eR8G8B8A8Uint, - Format::eR8G8B8A8Sint, - Format::eR8G8B8A8Srgb, - Format::eB8G8R8A8Unorm, - Format::eB8G8R8A8Snorm, - Format::eB8G8R8A8Uscaled, - Format::eB8G8R8A8Sscaled, - Format::eB8G8R8A8Uint, - Format::eB8G8R8A8Sint, - Format::eB8G8R8A8Srgb, - Format::eA8B8G8R8UnormPack32, - Format::eA8B8G8R8SnormPack32, - Format::eA8B8G8R8UscaledPack32, - Format::eA8B8G8R8SscaledPack32, - Format::eA8B8G8R8UintPack32, - Format::eA8B8G8R8SintPack32, - Format::eA8B8G8R8SrgbPack32, - Format::eA2R10G10B10UnormPack32, - Format::eA2R10G10B10SnormPack32, - Format::eA2R10G10B10UscaledPack32, - Format::eA2R10G10B10SscaledPack32, - Format::eA2R10G10B10UintPack32, - Format::eA2R10G10B10SintPack32, - Format::eA2B10G10R10UnormPack32, - Format::eA2B10G10R10SnormPack32, - Format::eA2B10G10R10UscaledPack32, - Format::eA2B10G10R10SscaledPack32, - Format::eA2B10G10R10UintPack32, - Format::eA2B10G10R10SintPack32, - Format::eR16Unorm, - Format::eR16Snorm, - Format::eR16Uscaled, - Format::eR16Sscaled, - Format::eR16Uint, - Format::eR16Sint, - Format::eR16Sfloat, - Format::eR16G16Unorm, - Format::eR16G16Snorm, - Format::eR16G16Uscaled, - Format::eR16G16Sscaled, - Format::eR16G16Uint, - Format::eR16G16Sint, - Format::eR16G16Sfloat, - Format::eR16G16B16Unorm, - Format::eR16G16B16Snorm, - Format::eR16G16B16Uscaled, - Format::eR16G16B16Sscaled, - Format::eR16G16B16Uint, - Format::eR16G16B16Sint, - Format::eR16G16B16Sfloat, - Format::eR16G16B16A16Unorm, - Format::eR16G16B16A16Snorm, - Format::eR16G16B16A16Uscaled, - Format::eR16G16B16A16Sscaled, - Format::eR16G16B16A16Uint, - Format::eR16G16B16A16Sint, - Format::eR16G16B16A16Sfloat, - Format::eR32Uint, - Format::eR32Sint, - Format::eR32Sfloat, - Format::eR32G32Uint, - Format::eR32G32Sint, - Format::eR32G32Sfloat, - Format::eR32G32B32Uint, - Format::eR32G32B32Sint, - Format::eR32G32B32Sfloat, - Format::eR32G32B32A32Uint, - Format::eR32G32B32A32Sint, - Format::eR32G32B32A32Sfloat, - Format::eR64Uint, - Format::eR64Sint, - Format::eR64Sfloat, - Format::eR64G64Uint, - Format::eR64G64Sint, - Format::eR64G64Sfloat, - Format::eR64G64B64Uint, - Format::eR64G64B64Sint, - Format::eR64G64B64Sfloat, - Format::eR64G64B64A64Uint, - Format::eR64G64B64A64Sint, - Format::eR64G64B64A64Sfloat, - Format::eB10G11R11UfloatPack32, - Format::eE5B9G9R9UfloatPack32, - Format::eBc1RgbUnormBlock, - Format::eBc1RgbSrgbBlock, - Format::eBc1RgbaUnormBlock, - Format::eBc1RgbaSrgbBlock, - Format::eBc2UnormBlock, - Format::eBc2SrgbBlock, - Format::eBc3UnormBlock, - Format::eBc3SrgbBlock, - Format::eBc4UnormBlock, - Format::eBc4SnormBlock, - Format::eBc5UnormBlock, - Format::eBc5SnormBlock, - Format::eBc6HUfloatBlock, - Format::eBc6HSfloatBlock, - Format::eBc7UnormBlock, - Format::eBc7SrgbBlock, - Format::eEtc2R8G8B8UnormBlock, - Format::eEtc2R8G8B8SrgbBlock, - Format::eEtc2R8G8B8A1UnormBlock, - Format::eEtc2R8G8B8A1SrgbBlock, - Format::eEtc2R8G8B8A8UnormBlock, - Format::eEtc2R8G8B8A8SrgbBlock, - Format::eEacR11UnormBlock, - Format::eEacR11SnormBlock, - Format::eEacR11G11UnormBlock, - Format::eEacR11G11SnormBlock, - Format::eAstc4x4UnormBlock, - Format::eAstc4x4SrgbBlock, - Format::eAstc5x4UnormBlock, - Format::eAstc5x4SrgbBlock, - Format::eAstc5x5UnormBlock, - Format::eAstc5x5SrgbBlock, - Format::eAstc6x5UnormBlock, - Format::eAstc6x5SrgbBlock, - Format::eAstc6x6UnormBlock, - Format::eAstc6x6SrgbBlock, - Format::eAstc8x5UnormBlock, - Format::eAstc8x5SrgbBlock, - Format::eAstc8x6UnormBlock, - Format::eAstc8x6SrgbBlock, - Format::eAstc8x8UnormBlock, - Format::eAstc8x8SrgbBlock, - Format::eAstc10x5UnormBlock, - Format::eAstc10x5SrgbBlock, - Format::eAstc10x6UnormBlock, - Format::eAstc10x6SrgbBlock, - Format::eAstc10x8UnormBlock, - Format::eAstc10x8SrgbBlock, - Format::eAstc10x10UnormBlock, - Format::eAstc10x10SrgbBlock, - Format::eAstc12x10UnormBlock, - Format::eAstc12x10SrgbBlock, - Format::eAstc12x12UnormBlock, - Format::eAstc12x12SrgbBlock, - Format::eG8B8G8R8422Unorm, - Format::eB8G8R8G8422Unorm, - Format::eG8B8R83Plane420Unorm, - Format::eG8B8R82Plane420Unorm, - Format::eG8B8R83Plane422Unorm, - Format::eG8B8R82Plane422Unorm, - Format::eG8B8R83Plane444Unorm, - Format::eR10X6UnormPack16, - Format::eR10X6G10X6Unorm2Pack16, - Format::eR10X6G10X6B10X6A10X6Unorm4Pack16, - Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16, - Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16, - Format::eG10X6B10X6R10X63Plane420Unorm3Pack16, - Format::eG10X6B10X6R10X62Plane420Unorm3Pack16, - Format::eG10X6B10X6R10X63Plane422Unorm3Pack16, - Format::eG10X6B10X6R10X62Plane422Unorm3Pack16, - Format::eG10X6B10X6R10X63Plane444Unorm3Pack16, - Format::eR12X4UnormPack16, - Format::eR12X4G12X4Unorm2Pack16, - Format::eR12X4G12X4B12X4A12X4Unorm4Pack16, - Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16, - Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16, - Format::eG12X4B12X4R12X43Plane420Unorm3Pack16, - Format::eG12X4B12X4R12X42Plane420Unorm3Pack16, - Format::eG12X4B12X4R12X43Plane422Unorm3Pack16, - Format::eG12X4B12X4R12X42Plane422Unorm3Pack16, - Format::eG12X4B12X4R12X43Plane444Unorm3Pack16, - Format::eG16B16G16R16422Unorm, - Format::eB16G16R16G16422Unorm, - Format::eG16B16R163Plane420Unorm, - Format::eG16B16R162Plane420Unorm, - Format::eG16B16R163Plane422Unorm, - Format::eG16B16R162Plane422Unorm, - Format::eG16B16R163Plane444Unorm, - Format::eG8B8R82Plane444Unorm, - Format::eG10X6B10X6R10X62Plane444Unorm3Pack16, - Format::eG12X4B12X4R12X42Plane444Unorm3Pack16, - Format::eG16B16R162Plane444Unorm, - Format::eA4R4G4B4UnormPack16, - Format::eA4B4G4R4UnormPack16, - Format::eAstc4x4SfloatBlock, - Format::eAstc5x4SfloatBlock, - Format::eAstc5x5SfloatBlock, - Format::eAstc6x5SfloatBlock, - Format::eAstc6x6SfloatBlock, - Format::eAstc8x5SfloatBlock, - Format::eAstc8x6SfloatBlock, - Format::eAstc8x8SfloatBlock, - Format::eAstc10x5SfloatBlock, - Format::eAstc10x6SfloatBlock, - Format::eAstc10x8SfloatBlock, - Format::eAstc10x10SfloatBlock, - Format::eAstc12x10SfloatBlock, - Format::eAstc12x12SfloatBlock, - Format::eA1B5G5R5UnormPack16, - Format::eA8Unorm, - Format::ePvrtc12BppUnormBlockIMG, - Format::ePvrtc14BppUnormBlockIMG, - Format::ePvrtc22BppUnormBlockIMG, - Format::ePvrtc24BppUnormBlockIMG, - Format::ePvrtc12BppSrgbBlockIMG, - Format::ePvrtc14BppSrgbBlockIMG, - Format::ePvrtc22BppSrgbBlockIMG, - Format::ePvrtc24BppSrgbBlockIMG, - Format::eAstc3x3x3UnormBlockEXT, - Format::eAstc3x3x3SrgbBlockEXT, - Format::eAstc3x3x3SfloatBlockEXT, - Format::eAstc4x3x3UnormBlockEXT, - Format::eAstc4x3x3SrgbBlockEXT, - Format::eAstc4x3x3SfloatBlockEXT, - Format::eAstc4x4x3UnormBlockEXT, - Format::eAstc4x4x3SrgbBlockEXT, - Format::eAstc4x4x3SfloatBlockEXT, - Format::eAstc4x4x4UnormBlockEXT, - Format::eAstc4x4x4SrgbBlockEXT, - Format::eAstc4x4x4SfloatBlockEXT, - Format::eAstc5x4x4UnormBlockEXT, - Format::eAstc5x4x4SrgbBlockEXT, - Format::eAstc5x4x4SfloatBlockEXT, - Format::eAstc5x5x4UnormBlockEXT, - Format::eAstc5x5x4SrgbBlockEXT, - Format::eAstc5x5x4SfloatBlockEXT, - Format::eAstc5x5x5UnormBlockEXT, - Format::eAstc5x5x5SrgbBlockEXT, - Format::eAstc5x5x5SfloatBlockEXT, - Format::eAstc6x5x5UnormBlockEXT, - Format::eAstc6x5x5SrgbBlockEXT, - Format::eAstc6x5x5SfloatBlockEXT, - Format::eAstc6x6x5UnormBlockEXT, - Format::eAstc6x6x5SrgbBlockEXT, - Format::eAstc6x6x5SfloatBlockEXT, - Format::eAstc6x6x6UnormBlockEXT, - Format::eAstc6x6x6SrgbBlockEXT, - Format::eAstc6x6x6SfloatBlockEXT, - Format::eR8BoolARM, - Format::eR16G16Sfixed5NV, - Format::eR10X6UintPack16ARM, - Format::eR10X6G10X6Uint2Pack16ARM, - Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM, - Format::eR12X4UintPack16ARM, - Format::eR12X4G12X4Uint2Pack16ARM, - Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM, - Format::eR14X2UintPack16ARM, - Format::eR14X2G14X2Uint2Pack16ARM, - Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM, - Format::eR14X2UnormPack16ARM, - Format::eR14X2G14X2Unorm2Pack16ARM, - Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM, - Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM, - Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM }; - return colorFormats; - } - - // Get all formats with a depth component - VULKAN_HPP_INLINE std::vector const & getDepthFormats() - { - static std::vector depthFormats = { Format::eD16Unorm, Format::eX8D24UnormPack32, Format::eD32Sfloat, - Format::eD16UnormS8Uint, Format::eD24UnormS8Uint, Format::eD32SfloatS8Uint }; - return depthFormats; - } - - // Get all formats with a depth and a stencil component - VULKAN_HPP_INLINE std::vector const & getDepthStencilFormats() - { - static std::vector depthStencilFormats = { Format::eD16UnormS8Uint, Format::eD24UnormS8Uint, Format::eD32SfloatS8Uint }; - return depthStencilFormats; - } - - // Get all formats with a stencil component - VULKAN_HPP_INLINE std::vector const & getStencilFormats() - { - static std::vector stencilFormats = { Format::eS8Uint, Format::eD16UnormS8Uint, Format::eD24UnormS8Uint, Format::eD32SfloatS8Uint }; - return stencilFormats; - } - - // True, if this format has an alpha component - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasAlphaComponent( Format format ) - { - switch ( format ) - { - case Format::eR4G4B4A4UnormPack16: - case Format::eB4G4R4A4UnormPack16: - case Format::eR5G5B5A1UnormPack16: - case Format::eB5G5R5A1UnormPack16: - case Format::eA1R5G5B5UnormPack16: - case Format::eR8G8B8A8Unorm: - case Format::eR8G8B8A8Snorm: - case Format::eR8G8B8A8Uscaled: - case Format::eR8G8B8A8Sscaled: - case Format::eR8G8B8A8Uint: - case Format::eR8G8B8A8Sint: - case Format::eR8G8B8A8Srgb: - case Format::eB8G8R8A8Unorm: - case Format::eB8G8R8A8Snorm: - case Format::eB8G8R8A8Uscaled: - case Format::eB8G8R8A8Sscaled: - case Format::eB8G8R8A8Uint: - case Format::eB8G8R8A8Sint: - case Format::eB8G8R8A8Srgb: - case Format::eA8B8G8R8UnormPack32: - case Format::eA8B8G8R8SnormPack32: - case Format::eA8B8G8R8UscaledPack32: - case Format::eA8B8G8R8SscaledPack32: - case Format::eA8B8G8R8UintPack32: - case Format::eA8B8G8R8SintPack32: - case Format::eA8B8G8R8SrgbPack32: - case Format::eA2R10G10B10UnormPack32: - case Format::eA2R10G10B10SnormPack32: - case Format::eA2R10G10B10UscaledPack32: - case Format::eA2R10G10B10SscaledPack32: - case Format::eA2R10G10B10UintPack32: - case Format::eA2R10G10B10SintPack32: - case Format::eA2B10G10R10UnormPack32: - case Format::eA2B10G10R10SnormPack32: - case Format::eA2B10G10R10UscaledPack32: - case Format::eA2B10G10R10SscaledPack32: - case Format::eA2B10G10R10UintPack32: - case Format::eA2B10G10R10SintPack32: - case Format::eR16G16B16A16Unorm: - case Format::eR16G16B16A16Snorm: - case Format::eR16G16B16A16Uscaled: - case Format::eR16G16B16A16Sscaled: - case Format::eR16G16B16A16Uint: - case Format::eR16G16B16A16Sint: - case Format::eR16G16B16A16Sfloat: - case Format::eR32G32B32A32Uint: - case Format::eR32G32B32A32Sint: - case Format::eR32G32B32A32Sfloat: - case Format::eR64G64B64A64Uint: - case Format::eR64G64B64A64Sint: - case Format::eR64G64B64A64Sfloat: - case Format::eBc1RgbaUnormBlock: - case Format::eBc1RgbaSrgbBlock: - case Format::eBc2UnormBlock: - case Format::eBc2SrgbBlock: - case Format::eBc3UnormBlock: - case Format::eBc3SrgbBlock: - case Format::eBc7UnormBlock: - case Format::eBc7SrgbBlock: - case Format::eEtc2R8G8B8A1UnormBlock: - case Format::eEtc2R8G8B8A1SrgbBlock: - case Format::eEtc2R8G8B8A8UnormBlock: - case Format::eEtc2R8G8B8A8SrgbBlock: - case Format::eAstc4x4UnormBlock: - case Format::eAstc4x4SrgbBlock: - case Format::eAstc5x4UnormBlock: - case Format::eAstc5x4SrgbBlock: - case Format::eAstc5x5UnormBlock: - case Format::eAstc5x5SrgbBlock: - case Format::eAstc6x5UnormBlock: - case Format::eAstc6x5SrgbBlock: - case Format::eAstc6x6UnormBlock: - case Format::eAstc6x6SrgbBlock: - case Format::eAstc8x5UnormBlock: - case Format::eAstc8x5SrgbBlock: - case Format::eAstc8x6UnormBlock: - case Format::eAstc8x6SrgbBlock: - case Format::eAstc8x8UnormBlock: - case Format::eAstc8x8SrgbBlock: - case Format::eAstc10x5UnormBlock: - case Format::eAstc10x5SrgbBlock: - case Format::eAstc10x6UnormBlock: - case Format::eAstc10x6SrgbBlock: - case Format::eAstc10x8UnormBlock: - case Format::eAstc10x8SrgbBlock: - case Format::eAstc10x10UnormBlock: - case Format::eAstc10x10SrgbBlock: - case Format::eAstc12x10UnormBlock: - case Format::eAstc12x10SrgbBlock: - case Format::eAstc12x12UnormBlock: - case Format::eAstc12x12SrgbBlock: - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: - case Format::eA4R4G4B4UnormPack16: - case Format::eA4B4G4R4UnormPack16: - case Format::eAstc4x4SfloatBlock: - case Format::eAstc5x4SfloatBlock: - case Format::eAstc5x5SfloatBlock: - case Format::eAstc6x5SfloatBlock: - case Format::eAstc6x6SfloatBlock: - case Format::eAstc8x5SfloatBlock: - case Format::eAstc8x6SfloatBlock: - case Format::eAstc8x8SfloatBlock: - case Format::eAstc10x5SfloatBlock: - case Format::eAstc10x6SfloatBlock: - case Format::eAstc10x8SfloatBlock: - case Format::eAstc10x10SfloatBlock: - case Format::eAstc12x10SfloatBlock: - case Format::eAstc12x12SfloatBlock: - case Format::eA1B5G5R5UnormPack16: - case Format::eA8Unorm: - case Format::ePvrtc12BppUnormBlockIMG: - case Format::ePvrtc14BppUnormBlockIMG: - case Format::ePvrtc22BppUnormBlockIMG: - case Format::ePvrtc24BppUnormBlockIMG: - case Format::ePvrtc12BppSrgbBlockIMG: - case Format::ePvrtc14BppSrgbBlockIMG: - case Format::ePvrtc22BppSrgbBlockIMG: - case Format::ePvrtc24BppSrgbBlockIMG: - case Format::eAstc3x3x3UnormBlockEXT: - case Format::eAstc3x3x3SrgbBlockEXT: - case Format::eAstc3x3x3SfloatBlockEXT: - case Format::eAstc4x3x3UnormBlockEXT: - case Format::eAstc4x3x3SrgbBlockEXT: - case Format::eAstc4x3x3SfloatBlockEXT: - case Format::eAstc4x4x3UnormBlockEXT: - case Format::eAstc4x4x3SrgbBlockEXT: - case Format::eAstc4x4x3SfloatBlockEXT: - case Format::eAstc4x4x4UnormBlockEXT: - case Format::eAstc4x4x4SrgbBlockEXT: - case Format::eAstc4x4x4SfloatBlockEXT: - case Format::eAstc5x4x4UnormBlockEXT: - case Format::eAstc5x4x4SrgbBlockEXT: - case Format::eAstc5x4x4SfloatBlockEXT: - case Format::eAstc5x5x4UnormBlockEXT: - case Format::eAstc5x5x4SrgbBlockEXT: - case Format::eAstc5x5x4SfloatBlockEXT: - case Format::eAstc5x5x5UnormBlockEXT: - case Format::eAstc5x5x5SrgbBlockEXT: - case Format::eAstc5x5x5SfloatBlockEXT: - case Format::eAstc6x5x5UnormBlockEXT: - case Format::eAstc6x5x5SrgbBlockEXT: - case Format::eAstc6x5x5SfloatBlockEXT: - case Format::eAstc6x6x5UnormBlockEXT: - case Format::eAstc6x6x5SrgbBlockEXT: - case Format::eAstc6x6x5SfloatBlockEXT: - case Format::eAstc6x6x6UnormBlockEXT: - case Format::eAstc6x6x6SrgbBlockEXT: - case Format::eAstc6x6x6SfloatBlockEXT: - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: return true; - default : return false; - } - } - - // True, if this format has a blue component - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasBlueComponent( Format format ) - { - switch ( format ) - { - case Format::eR4G4B4A4UnormPack16: - case Format::eB4G4R4A4UnormPack16: - case Format::eR5G6B5UnormPack16: - case Format::eB5G6R5UnormPack16: - case Format::eR5G5B5A1UnormPack16: - case Format::eB5G5R5A1UnormPack16: - case Format::eA1R5G5B5UnormPack16: - case Format::eR8G8B8Unorm: - case Format::eR8G8B8Snorm: - case Format::eR8G8B8Uscaled: - case Format::eR8G8B8Sscaled: - case Format::eR8G8B8Uint: - case Format::eR8G8B8Sint: - case Format::eR8G8B8Srgb: - case Format::eB8G8R8Unorm: - case Format::eB8G8R8Snorm: - case Format::eB8G8R8Uscaled: - case Format::eB8G8R8Sscaled: - case Format::eB8G8R8Uint: - case Format::eB8G8R8Sint: - case Format::eB8G8R8Srgb: - case Format::eR8G8B8A8Unorm: - case Format::eR8G8B8A8Snorm: - case Format::eR8G8B8A8Uscaled: - case Format::eR8G8B8A8Sscaled: - case Format::eR8G8B8A8Uint: - case Format::eR8G8B8A8Sint: - case Format::eR8G8B8A8Srgb: - case Format::eB8G8R8A8Unorm: - case Format::eB8G8R8A8Snorm: - case Format::eB8G8R8A8Uscaled: - case Format::eB8G8R8A8Sscaled: - case Format::eB8G8R8A8Uint: - case Format::eB8G8R8A8Sint: - case Format::eB8G8R8A8Srgb: - case Format::eA8B8G8R8UnormPack32: - case Format::eA8B8G8R8SnormPack32: - case Format::eA8B8G8R8UscaledPack32: - case Format::eA8B8G8R8SscaledPack32: - case Format::eA8B8G8R8UintPack32: - case Format::eA8B8G8R8SintPack32: - case Format::eA8B8G8R8SrgbPack32: - case Format::eA2R10G10B10UnormPack32: - case Format::eA2R10G10B10SnormPack32: - case Format::eA2R10G10B10UscaledPack32: - case Format::eA2R10G10B10SscaledPack32: - case Format::eA2R10G10B10UintPack32: - case Format::eA2R10G10B10SintPack32: - case Format::eA2B10G10R10UnormPack32: - case Format::eA2B10G10R10SnormPack32: - case Format::eA2B10G10R10UscaledPack32: - case Format::eA2B10G10R10SscaledPack32: - case Format::eA2B10G10R10UintPack32: - case Format::eA2B10G10R10SintPack32: - case Format::eR16G16B16Unorm: - case Format::eR16G16B16Snorm: - case Format::eR16G16B16Uscaled: - case Format::eR16G16B16Sscaled: - case Format::eR16G16B16Uint: - case Format::eR16G16B16Sint: - case Format::eR16G16B16Sfloat: - case Format::eR16G16B16A16Unorm: - case Format::eR16G16B16A16Snorm: - case Format::eR16G16B16A16Uscaled: - case Format::eR16G16B16A16Sscaled: - case Format::eR16G16B16A16Uint: - case Format::eR16G16B16A16Sint: - case Format::eR16G16B16A16Sfloat: - case Format::eR32G32B32Uint: - case Format::eR32G32B32Sint: - case Format::eR32G32B32Sfloat: - case Format::eR32G32B32A32Uint: - case Format::eR32G32B32A32Sint: - case Format::eR32G32B32A32Sfloat: - case Format::eR64G64B64Uint: - case Format::eR64G64B64Sint: - case Format::eR64G64B64Sfloat: - case Format::eR64G64B64A64Uint: - case Format::eR64G64B64A64Sint: - case Format::eR64G64B64A64Sfloat: - case Format::eB10G11R11UfloatPack32: - case Format::eE5B9G9R9UfloatPack32: - case Format::eBc1RgbUnormBlock: - case Format::eBc1RgbSrgbBlock: - case Format::eBc1RgbaUnormBlock: - case Format::eBc1RgbaSrgbBlock: - case Format::eBc2UnormBlock: - case Format::eBc2SrgbBlock: - case Format::eBc3UnormBlock: - case Format::eBc3SrgbBlock: - case Format::eBc6HUfloatBlock: - case Format::eBc6HSfloatBlock: - case Format::eBc7UnormBlock: - case Format::eBc7SrgbBlock: - case Format::eEtc2R8G8B8UnormBlock: - case Format::eEtc2R8G8B8SrgbBlock: - case Format::eEtc2R8G8B8A1UnormBlock: - case Format::eEtc2R8G8B8A1SrgbBlock: - case Format::eEtc2R8G8B8A8UnormBlock: - case Format::eEtc2R8G8B8A8SrgbBlock: - case Format::eAstc4x4UnormBlock: - case Format::eAstc4x4SrgbBlock: - case Format::eAstc5x4UnormBlock: - case Format::eAstc5x4SrgbBlock: - case Format::eAstc5x5UnormBlock: - case Format::eAstc5x5SrgbBlock: - case Format::eAstc6x5UnormBlock: - case Format::eAstc6x5SrgbBlock: - case Format::eAstc6x6UnormBlock: - case Format::eAstc6x6SrgbBlock: - case Format::eAstc8x5UnormBlock: - case Format::eAstc8x5SrgbBlock: - case Format::eAstc8x6UnormBlock: - case Format::eAstc8x6SrgbBlock: - case Format::eAstc8x8UnormBlock: - case Format::eAstc8x8SrgbBlock: - case Format::eAstc10x5UnormBlock: - case Format::eAstc10x5SrgbBlock: - case Format::eAstc10x6UnormBlock: - case Format::eAstc10x6SrgbBlock: - case Format::eAstc10x8UnormBlock: - case Format::eAstc10x8SrgbBlock: - case Format::eAstc10x10UnormBlock: - case Format::eAstc10x10SrgbBlock: - case Format::eAstc12x10UnormBlock: - case Format::eAstc12x10SrgbBlock: - case Format::eAstc12x12UnormBlock: - case Format::eAstc12x12SrgbBlock: - case Format::eG8B8G8R8422Unorm: - case Format::eB8G8R8G8422Unorm: - case Format::eG8B8R83Plane420Unorm: - case Format::eG8B8R82Plane420Unorm: - case Format::eG8B8R83Plane422Unorm: - case Format::eG8B8R82Plane422Unorm: - case Format::eG8B8R83Plane444Unorm: - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: - case Format::eG16B16G16R16422Unorm: - case Format::eB16G16R16G16422Unorm: - case Format::eG16B16R163Plane420Unorm: - case Format::eG16B16R162Plane420Unorm: - case Format::eG16B16R163Plane422Unorm: - case Format::eG16B16R162Plane422Unorm: - case Format::eG16B16R163Plane444Unorm: - case Format::eG8B8R82Plane444Unorm: - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: - case Format::eG16B16R162Plane444Unorm: - case Format::eA4R4G4B4UnormPack16: - case Format::eA4B4G4R4UnormPack16: - case Format::eAstc4x4SfloatBlock: - case Format::eAstc5x4SfloatBlock: - case Format::eAstc5x5SfloatBlock: - case Format::eAstc6x5SfloatBlock: - case Format::eAstc6x6SfloatBlock: - case Format::eAstc8x5SfloatBlock: - case Format::eAstc8x6SfloatBlock: - case Format::eAstc8x8SfloatBlock: - case Format::eAstc10x5SfloatBlock: - case Format::eAstc10x6SfloatBlock: - case Format::eAstc10x8SfloatBlock: - case Format::eAstc10x10SfloatBlock: - case Format::eAstc12x10SfloatBlock: - case Format::eAstc12x12SfloatBlock: - case Format::eA1B5G5R5UnormPack16: - case Format::ePvrtc12BppUnormBlockIMG: - case Format::ePvrtc14BppUnormBlockIMG: - case Format::ePvrtc22BppUnormBlockIMG: - case Format::ePvrtc24BppUnormBlockIMG: - case Format::ePvrtc12BppSrgbBlockIMG: - case Format::ePvrtc14BppSrgbBlockIMG: - case Format::ePvrtc22BppSrgbBlockIMG: - case Format::ePvrtc24BppSrgbBlockIMG: - case Format::eAstc3x3x3UnormBlockEXT: - case Format::eAstc3x3x3SrgbBlockEXT: - case Format::eAstc3x3x3SfloatBlockEXT: - case Format::eAstc4x3x3UnormBlockEXT: - case Format::eAstc4x3x3SrgbBlockEXT: - case Format::eAstc4x3x3SfloatBlockEXT: - case Format::eAstc4x4x3UnormBlockEXT: - case Format::eAstc4x4x3SrgbBlockEXT: - case Format::eAstc4x4x3SfloatBlockEXT: - case Format::eAstc4x4x4UnormBlockEXT: - case Format::eAstc4x4x4SrgbBlockEXT: - case Format::eAstc4x4x4SfloatBlockEXT: - case Format::eAstc5x4x4UnormBlockEXT: - case Format::eAstc5x4x4SrgbBlockEXT: - case Format::eAstc5x4x4SfloatBlockEXT: - case Format::eAstc5x5x4UnormBlockEXT: - case Format::eAstc5x5x4SrgbBlockEXT: - case Format::eAstc5x5x4SfloatBlockEXT: - case Format::eAstc5x5x5UnormBlockEXT: - case Format::eAstc5x5x5SrgbBlockEXT: - case Format::eAstc5x5x5SfloatBlockEXT: - case Format::eAstc6x5x5UnormBlockEXT: - case Format::eAstc6x5x5SrgbBlockEXT: - case Format::eAstc6x5x5SfloatBlockEXT: - case Format::eAstc6x6x5UnormBlockEXT: - case Format::eAstc6x6x5SrgbBlockEXT: - case Format::eAstc6x6x5SfloatBlockEXT: - case Format::eAstc6x6x6UnormBlockEXT: - case Format::eAstc6x6x6SrgbBlockEXT: - case Format::eAstc6x6x6SfloatBlockEXT: - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return true; - default : return false; - } - } - - // True, if this format has a depth component - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasDepthComponent( Format format ) - { - switch ( format ) - { - case Format::eD16Unorm: - case Format::eX8D24UnormPack32: - case Format::eD32Sfloat: - case Format::eD16UnormS8Uint: - case Format::eD24UnormS8Uint: - case Format::eD32SfloatS8Uint : return true; - default : return false; - } - } - - // True, if this format has a green component - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasGreenComponent( Format format ) - { - switch ( format ) - { - case Format::eR4G4UnormPack8: - case Format::eR4G4B4A4UnormPack16: - case Format::eB4G4R4A4UnormPack16: - case Format::eR5G6B5UnormPack16: - case Format::eB5G6R5UnormPack16: - case Format::eR5G5B5A1UnormPack16: - case Format::eB5G5R5A1UnormPack16: - case Format::eA1R5G5B5UnormPack16: - case Format::eR8G8Unorm: - case Format::eR8G8Snorm: - case Format::eR8G8Uscaled: - case Format::eR8G8Sscaled: - case Format::eR8G8Uint: - case Format::eR8G8Sint: - case Format::eR8G8Srgb: - case Format::eR8G8B8Unorm: - case Format::eR8G8B8Snorm: - case Format::eR8G8B8Uscaled: - case Format::eR8G8B8Sscaled: - case Format::eR8G8B8Uint: - case Format::eR8G8B8Sint: - case Format::eR8G8B8Srgb: - case Format::eB8G8R8Unorm: - case Format::eB8G8R8Snorm: - case Format::eB8G8R8Uscaled: - case Format::eB8G8R8Sscaled: - case Format::eB8G8R8Uint: - case Format::eB8G8R8Sint: - case Format::eB8G8R8Srgb: - case Format::eR8G8B8A8Unorm: - case Format::eR8G8B8A8Snorm: - case Format::eR8G8B8A8Uscaled: - case Format::eR8G8B8A8Sscaled: - case Format::eR8G8B8A8Uint: - case Format::eR8G8B8A8Sint: - case Format::eR8G8B8A8Srgb: - case Format::eB8G8R8A8Unorm: - case Format::eB8G8R8A8Snorm: - case Format::eB8G8R8A8Uscaled: - case Format::eB8G8R8A8Sscaled: - case Format::eB8G8R8A8Uint: - case Format::eB8G8R8A8Sint: - case Format::eB8G8R8A8Srgb: - case Format::eA8B8G8R8UnormPack32: - case Format::eA8B8G8R8SnormPack32: - case Format::eA8B8G8R8UscaledPack32: - case Format::eA8B8G8R8SscaledPack32: - case Format::eA8B8G8R8UintPack32: - case Format::eA8B8G8R8SintPack32: - case Format::eA8B8G8R8SrgbPack32: - case Format::eA2R10G10B10UnormPack32: - case Format::eA2R10G10B10SnormPack32: - case Format::eA2R10G10B10UscaledPack32: - case Format::eA2R10G10B10SscaledPack32: - case Format::eA2R10G10B10UintPack32: - case Format::eA2R10G10B10SintPack32: - case Format::eA2B10G10R10UnormPack32: - case Format::eA2B10G10R10SnormPack32: - case Format::eA2B10G10R10UscaledPack32: - case Format::eA2B10G10R10SscaledPack32: - case Format::eA2B10G10R10UintPack32: - case Format::eA2B10G10R10SintPack32: - case Format::eR16G16Unorm: - case Format::eR16G16Snorm: - case Format::eR16G16Uscaled: - case Format::eR16G16Sscaled: - case Format::eR16G16Uint: - case Format::eR16G16Sint: - case Format::eR16G16Sfloat: - case Format::eR16G16B16Unorm: - case Format::eR16G16B16Snorm: - case Format::eR16G16B16Uscaled: - case Format::eR16G16B16Sscaled: - case Format::eR16G16B16Uint: - case Format::eR16G16B16Sint: - case Format::eR16G16B16Sfloat: - case Format::eR16G16B16A16Unorm: - case Format::eR16G16B16A16Snorm: - case Format::eR16G16B16A16Uscaled: - case Format::eR16G16B16A16Sscaled: - case Format::eR16G16B16A16Uint: - case Format::eR16G16B16A16Sint: - case Format::eR16G16B16A16Sfloat: - case Format::eR32G32Uint: - case Format::eR32G32Sint: - case Format::eR32G32Sfloat: - case Format::eR32G32B32Uint: - case Format::eR32G32B32Sint: - case Format::eR32G32B32Sfloat: - case Format::eR32G32B32A32Uint: - case Format::eR32G32B32A32Sint: - case Format::eR32G32B32A32Sfloat: - case Format::eR64G64Uint: - case Format::eR64G64Sint: - case Format::eR64G64Sfloat: - case Format::eR64G64B64Uint: - case Format::eR64G64B64Sint: - case Format::eR64G64B64Sfloat: - case Format::eR64G64B64A64Uint: - case Format::eR64G64B64A64Sint: - case Format::eR64G64B64A64Sfloat: - case Format::eB10G11R11UfloatPack32: - case Format::eE5B9G9R9UfloatPack32: - case Format::eBc1RgbUnormBlock: - case Format::eBc1RgbSrgbBlock: - case Format::eBc1RgbaUnormBlock: - case Format::eBc1RgbaSrgbBlock: - case Format::eBc2UnormBlock: - case Format::eBc2SrgbBlock: - case Format::eBc3UnormBlock: - case Format::eBc3SrgbBlock: - case Format::eBc5UnormBlock: - case Format::eBc5SnormBlock: - case Format::eBc6HUfloatBlock: - case Format::eBc6HSfloatBlock: - case Format::eBc7UnormBlock: - case Format::eBc7SrgbBlock: - case Format::eEtc2R8G8B8UnormBlock: - case Format::eEtc2R8G8B8SrgbBlock: - case Format::eEtc2R8G8B8A1UnormBlock: - case Format::eEtc2R8G8B8A1SrgbBlock: - case Format::eEtc2R8G8B8A8UnormBlock: - case Format::eEtc2R8G8B8A8SrgbBlock: - case Format::eEacR11G11UnormBlock: - case Format::eEacR11G11SnormBlock: - case Format::eAstc4x4UnormBlock: - case Format::eAstc4x4SrgbBlock: - case Format::eAstc5x4UnormBlock: - case Format::eAstc5x4SrgbBlock: - case Format::eAstc5x5UnormBlock: - case Format::eAstc5x5SrgbBlock: - case Format::eAstc6x5UnormBlock: - case Format::eAstc6x5SrgbBlock: - case Format::eAstc6x6UnormBlock: - case Format::eAstc6x6SrgbBlock: - case Format::eAstc8x5UnormBlock: - case Format::eAstc8x5SrgbBlock: - case Format::eAstc8x6UnormBlock: - case Format::eAstc8x6SrgbBlock: - case Format::eAstc8x8UnormBlock: - case Format::eAstc8x8SrgbBlock: - case Format::eAstc10x5UnormBlock: - case Format::eAstc10x5SrgbBlock: - case Format::eAstc10x6UnormBlock: - case Format::eAstc10x6SrgbBlock: - case Format::eAstc10x8UnormBlock: - case Format::eAstc10x8SrgbBlock: - case Format::eAstc10x10UnormBlock: - case Format::eAstc10x10SrgbBlock: - case Format::eAstc12x10UnormBlock: - case Format::eAstc12x10SrgbBlock: - case Format::eAstc12x12UnormBlock: - case Format::eAstc12x12SrgbBlock: - case Format::eG8B8G8R8422Unorm: - case Format::eB8G8R8G8422Unorm: - case Format::eG8B8R83Plane420Unorm: - case Format::eG8B8R82Plane420Unorm: - case Format::eG8B8R83Plane422Unorm: - case Format::eG8B8R82Plane422Unorm: - case Format::eG8B8R83Plane444Unorm: - case Format::eR10X6G10X6Unorm2Pack16: - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: - case Format::eR12X4G12X4Unorm2Pack16: - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: - case Format::eG16B16G16R16422Unorm: - case Format::eB16G16R16G16422Unorm: - case Format::eG16B16R163Plane420Unorm: - case Format::eG16B16R162Plane420Unorm: - case Format::eG16B16R163Plane422Unorm: - case Format::eG16B16R162Plane422Unorm: - case Format::eG16B16R163Plane444Unorm: - case Format::eG8B8R82Plane444Unorm: - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: - case Format::eG16B16R162Plane444Unorm: - case Format::eA4R4G4B4UnormPack16: - case Format::eA4B4G4R4UnormPack16: - case Format::eAstc4x4SfloatBlock: - case Format::eAstc5x4SfloatBlock: - case Format::eAstc5x5SfloatBlock: - case Format::eAstc6x5SfloatBlock: - case Format::eAstc6x6SfloatBlock: - case Format::eAstc8x5SfloatBlock: - case Format::eAstc8x6SfloatBlock: - case Format::eAstc8x8SfloatBlock: - case Format::eAstc10x5SfloatBlock: - case Format::eAstc10x6SfloatBlock: - case Format::eAstc10x8SfloatBlock: - case Format::eAstc10x10SfloatBlock: - case Format::eAstc12x10SfloatBlock: - case Format::eAstc12x12SfloatBlock: - case Format::eA1B5G5R5UnormPack16: - case Format::ePvrtc12BppUnormBlockIMG: - case Format::ePvrtc14BppUnormBlockIMG: - case Format::ePvrtc22BppUnormBlockIMG: - case Format::ePvrtc24BppUnormBlockIMG: - case Format::ePvrtc12BppSrgbBlockIMG: - case Format::ePvrtc14BppSrgbBlockIMG: - case Format::ePvrtc22BppSrgbBlockIMG: - case Format::ePvrtc24BppSrgbBlockIMG: - case Format::eAstc3x3x3UnormBlockEXT: - case Format::eAstc3x3x3SrgbBlockEXT: - case Format::eAstc3x3x3SfloatBlockEXT: - case Format::eAstc4x3x3UnormBlockEXT: - case Format::eAstc4x3x3SrgbBlockEXT: - case Format::eAstc4x3x3SfloatBlockEXT: - case Format::eAstc4x4x3UnormBlockEXT: - case Format::eAstc4x4x3SrgbBlockEXT: - case Format::eAstc4x4x3SfloatBlockEXT: - case Format::eAstc4x4x4UnormBlockEXT: - case Format::eAstc4x4x4SrgbBlockEXT: - case Format::eAstc4x4x4SfloatBlockEXT: - case Format::eAstc5x4x4UnormBlockEXT: - case Format::eAstc5x4x4SrgbBlockEXT: - case Format::eAstc5x4x4SfloatBlockEXT: - case Format::eAstc5x5x4UnormBlockEXT: - case Format::eAstc5x5x4SrgbBlockEXT: - case Format::eAstc5x5x4SfloatBlockEXT: - case Format::eAstc5x5x5UnormBlockEXT: - case Format::eAstc5x5x5SrgbBlockEXT: - case Format::eAstc5x5x5SfloatBlockEXT: - case Format::eAstc6x5x5UnormBlockEXT: - case Format::eAstc6x5x5SrgbBlockEXT: - case Format::eAstc6x5x5SfloatBlockEXT: - case Format::eAstc6x6x5UnormBlockEXT: - case Format::eAstc6x6x5SrgbBlockEXT: - case Format::eAstc6x6x5SfloatBlockEXT: - case Format::eAstc6x6x6UnormBlockEXT: - case Format::eAstc6x6x6SrgbBlockEXT: - case Format::eAstc6x6x6SfloatBlockEXT: - case Format::eR16G16Sfixed5NV: - case Format::eR10X6G10X6Uint2Pack16ARM: - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: - case Format::eR12X4G12X4Uint2Pack16ARM: - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: - case Format::eR14X2G14X2Uint2Pack16ARM: - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: - case Format::eR14X2G14X2Unorm2Pack16ARM: - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return true; - default : return false; - } - } - - // True, if this format has a red component - VULKAN_HPP_CONSTEXPR_14 bool hasRedComponent( Format format ) - { - switch ( format ) - { - case Format::eR4G4UnormPack8: - case Format::eR4G4B4A4UnormPack16: - case Format::eB4G4R4A4UnormPack16: - case Format::eR5G6B5UnormPack16: - case Format::eB5G6R5UnormPack16: - case Format::eR5G5B5A1UnormPack16: - case Format::eB5G5R5A1UnormPack16: - case Format::eA1R5G5B5UnormPack16: - case Format::eR8Unorm: - case Format::eR8Snorm: - case Format::eR8Uscaled: - case Format::eR8Sscaled: - case Format::eR8Uint: - case Format::eR8Sint: - case Format::eR8Srgb: - case Format::eR8G8Unorm: - case Format::eR8G8Snorm: - case Format::eR8G8Uscaled: - case Format::eR8G8Sscaled: - case Format::eR8G8Uint: - case Format::eR8G8Sint: - case Format::eR8G8Srgb: - case Format::eR8G8B8Unorm: - case Format::eR8G8B8Snorm: - case Format::eR8G8B8Uscaled: - case Format::eR8G8B8Sscaled: - case Format::eR8G8B8Uint: - case Format::eR8G8B8Sint: - case Format::eR8G8B8Srgb: - case Format::eB8G8R8Unorm: - case Format::eB8G8R8Snorm: - case Format::eB8G8R8Uscaled: - case Format::eB8G8R8Sscaled: - case Format::eB8G8R8Uint: - case Format::eB8G8R8Sint: - case Format::eB8G8R8Srgb: - case Format::eR8G8B8A8Unorm: - case Format::eR8G8B8A8Snorm: - case Format::eR8G8B8A8Uscaled: - case Format::eR8G8B8A8Sscaled: - case Format::eR8G8B8A8Uint: - case Format::eR8G8B8A8Sint: - case Format::eR8G8B8A8Srgb: - case Format::eB8G8R8A8Unorm: - case Format::eB8G8R8A8Snorm: - case Format::eB8G8R8A8Uscaled: - case Format::eB8G8R8A8Sscaled: - case Format::eB8G8R8A8Uint: - case Format::eB8G8R8A8Sint: - case Format::eB8G8R8A8Srgb: - case Format::eA8B8G8R8UnormPack32: - case Format::eA8B8G8R8SnormPack32: - case Format::eA8B8G8R8UscaledPack32: - case Format::eA8B8G8R8SscaledPack32: - case Format::eA8B8G8R8UintPack32: - case Format::eA8B8G8R8SintPack32: - case Format::eA8B8G8R8SrgbPack32: - case Format::eA2R10G10B10UnormPack32: - case Format::eA2R10G10B10SnormPack32: - case Format::eA2R10G10B10UscaledPack32: - case Format::eA2R10G10B10SscaledPack32: - case Format::eA2R10G10B10UintPack32: - case Format::eA2R10G10B10SintPack32: - case Format::eA2B10G10R10UnormPack32: - case Format::eA2B10G10R10SnormPack32: - case Format::eA2B10G10R10UscaledPack32: - case Format::eA2B10G10R10SscaledPack32: - case Format::eA2B10G10R10UintPack32: - case Format::eA2B10G10R10SintPack32: - case Format::eR16Unorm: - case Format::eR16Snorm: - case Format::eR16Uscaled: - case Format::eR16Sscaled: - case Format::eR16Uint: - case Format::eR16Sint: - case Format::eR16Sfloat: - case Format::eR16G16Unorm: - case Format::eR16G16Snorm: - case Format::eR16G16Uscaled: - case Format::eR16G16Sscaled: - case Format::eR16G16Uint: - case Format::eR16G16Sint: - case Format::eR16G16Sfloat: - case Format::eR16G16B16Unorm: - case Format::eR16G16B16Snorm: - case Format::eR16G16B16Uscaled: - case Format::eR16G16B16Sscaled: - case Format::eR16G16B16Uint: - case Format::eR16G16B16Sint: - case Format::eR16G16B16Sfloat: - case Format::eR16G16B16A16Unorm: - case Format::eR16G16B16A16Snorm: - case Format::eR16G16B16A16Uscaled: - case Format::eR16G16B16A16Sscaled: - case Format::eR16G16B16A16Uint: - case Format::eR16G16B16A16Sint: - case Format::eR16G16B16A16Sfloat: - case Format::eR32Uint: - case Format::eR32Sint: - case Format::eR32Sfloat: - case Format::eR32G32Uint: - case Format::eR32G32Sint: - case Format::eR32G32Sfloat: - case Format::eR32G32B32Uint: - case Format::eR32G32B32Sint: - case Format::eR32G32B32Sfloat: - case Format::eR32G32B32A32Uint: - case Format::eR32G32B32A32Sint: - case Format::eR32G32B32A32Sfloat: - case Format::eR64Uint: - case Format::eR64Sint: - case Format::eR64Sfloat: - case Format::eR64G64Uint: - case Format::eR64G64Sint: - case Format::eR64G64Sfloat: - case Format::eR64G64B64Uint: - case Format::eR64G64B64Sint: - case Format::eR64G64B64Sfloat: - case Format::eR64G64B64A64Uint: - case Format::eR64G64B64A64Sint: - case Format::eR64G64B64A64Sfloat: - case Format::eB10G11R11UfloatPack32: - case Format::eE5B9G9R9UfloatPack32: - case Format::eBc1RgbUnormBlock: - case Format::eBc1RgbSrgbBlock: - case Format::eBc1RgbaUnormBlock: - case Format::eBc1RgbaSrgbBlock: - case Format::eBc2UnormBlock: - case Format::eBc2SrgbBlock: - case Format::eBc3UnormBlock: - case Format::eBc3SrgbBlock: - case Format::eBc4UnormBlock: - case Format::eBc4SnormBlock: - case Format::eBc5UnormBlock: - case Format::eBc5SnormBlock: - case Format::eBc6HUfloatBlock: - case Format::eBc6HSfloatBlock: - case Format::eBc7UnormBlock: - case Format::eBc7SrgbBlock: - case Format::eEtc2R8G8B8UnormBlock: - case Format::eEtc2R8G8B8SrgbBlock: - case Format::eEtc2R8G8B8A1UnormBlock: - case Format::eEtc2R8G8B8A1SrgbBlock: - case Format::eEtc2R8G8B8A8UnormBlock: - case Format::eEtc2R8G8B8A8SrgbBlock: - case Format::eEacR11UnormBlock: - case Format::eEacR11SnormBlock: - case Format::eEacR11G11UnormBlock: - case Format::eEacR11G11SnormBlock: - case Format::eAstc4x4UnormBlock: - case Format::eAstc4x4SrgbBlock: - case Format::eAstc5x4UnormBlock: - case Format::eAstc5x4SrgbBlock: - case Format::eAstc5x5UnormBlock: - case Format::eAstc5x5SrgbBlock: - case Format::eAstc6x5UnormBlock: - case Format::eAstc6x5SrgbBlock: - case Format::eAstc6x6UnormBlock: - case Format::eAstc6x6SrgbBlock: - case Format::eAstc8x5UnormBlock: - case Format::eAstc8x5SrgbBlock: - case Format::eAstc8x6UnormBlock: - case Format::eAstc8x6SrgbBlock: - case Format::eAstc8x8UnormBlock: - case Format::eAstc8x8SrgbBlock: - case Format::eAstc10x5UnormBlock: - case Format::eAstc10x5SrgbBlock: - case Format::eAstc10x6UnormBlock: - case Format::eAstc10x6SrgbBlock: - case Format::eAstc10x8UnormBlock: - case Format::eAstc10x8SrgbBlock: - case Format::eAstc10x10UnormBlock: - case Format::eAstc10x10SrgbBlock: - case Format::eAstc12x10UnormBlock: - case Format::eAstc12x10SrgbBlock: - case Format::eAstc12x12UnormBlock: - case Format::eAstc12x12SrgbBlock: - case Format::eG8B8G8R8422Unorm: - case Format::eB8G8R8G8422Unorm: - case Format::eG8B8R83Plane420Unorm: - case Format::eG8B8R82Plane420Unorm: - case Format::eG8B8R83Plane422Unorm: - case Format::eG8B8R82Plane422Unorm: - case Format::eG8B8R83Plane444Unorm: - case Format::eR10X6UnormPack16: - case Format::eR10X6G10X6Unorm2Pack16: - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16: - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16: - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16: - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: - case Format::eR12X4UnormPack16: - case Format::eR12X4G12X4Unorm2Pack16: - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16: - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16: - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16: - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: - case Format::eG16B16G16R16422Unorm: - case Format::eB16G16R16G16422Unorm: - case Format::eG16B16R163Plane420Unorm: - case Format::eG16B16R162Plane420Unorm: - case Format::eG16B16R163Plane422Unorm: - case Format::eG16B16R162Plane422Unorm: - case Format::eG16B16R163Plane444Unorm: - case Format::eG8B8R82Plane444Unorm: - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: - case Format::eG16B16R162Plane444Unorm: - case Format::eA4R4G4B4UnormPack16: - case Format::eA4B4G4R4UnormPack16: - case Format::eAstc4x4SfloatBlock: - case Format::eAstc5x4SfloatBlock: - case Format::eAstc5x5SfloatBlock: - case Format::eAstc6x5SfloatBlock: - case Format::eAstc6x6SfloatBlock: - case Format::eAstc8x5SfloatBlock: - case Format::eAstc8x6SfloatBlock: - case Format::eAstc8x8SfloatBlock: - case Format::eAstc10x5SfloatBlock: - case Format::eAstc10x6SfloatBlock: - case Format::eAstc10x8SfloatBlock: - case Format::eAstc10x10SfloatBlock: - case Format::eAstc12x10SfloatBlock: - case Format::eAstc12x12SfloatBlock: - case Format::eA1B5G5R5UnormPack16: - case Format::ePvrtc12BppUnormBlockIMG: - case Format::ePvrtc14BppUnormBlockIMG: - case Format::ePvrtc22BppUnormBlockIMG: - case Format::ePvrtc24BppUnormBlockIMG: - case Format::ePvrtc12BppSrgbBlockIMG: - case Format::ePvrtc14BppSrgbBlockIMG: - case Format::ePvrtc22BppSrgbBlockIMG: - case Format::ePvrtc24BppSrgbBlockIMG: - case Format::eAstc3x3x3UnormBlockEXT: - case Format::eAstc3x3x3SrgbBlockEXT: - case Format::eAstc3x3x3SfloatBlockEXT: - case Format::eAstc4x3x3UnormBlockEXT: - case Format::eAstc4x3x3SrgbBlockEXT: - case Format::eAstc4x3x3SfloatBlockEXT: - case Format::eAstc4x4x3UnormBlockEXT: - case Format::eAstc4x4x3SrgbBlockEXT: - case Format::eAstc4x4x3SfloatBlockEXT: - case Format::eAstc4x4x4UnormBlockEXT: - case Format::eAstc4x4x4SrgbBlockEXT: - case Format::eAstc4x4x4SfloatBlockEXT: - case Format::eAstc5x4x4UnormBlockEXT: - case Format::eAstc5x4x4SrgbBlockEXT: - case Format::eAstc5x4x4SfloatBlockEXT: - case Format::eAstc5x5x4UnormBlockEXT: - case Format::eAstc5x5x4SrgbBlockEXT: - case Format::eAstc5x5x4SfloatBlockEXT: - case Format::eAstc5x5x5UnormBlockEXT: - case Format::eAstc5x5x5SrgbBlockEXT: - case Format::eAstc5x5x5SfloatBlockEXT: - case Format::eAstc6x5x5UnormBlockEXT: - case Format::eAstc6x5x5SrgbBlockEXT: - case Format::eAstc6x5x5SfloatBlockEXT: - case Format::eAstc6x6x5UnormBlockEXT: - case Format::eAstc6x6x5SrgbBlockEXT: - case Format::eAstc6x6x5SfloatBlockEXT: - case Format::eAstc6x6x6UnormBlockEXT: - case Format::eAstc6x6x6SrgbBlockEXT: - case Format::eAstc6x6x6SfloatBlockEXT: - case Format::eR8BoolARM: - case Format::eR16G16Sfixed5NV: - case Format::eR10X6UintPack16ARM: - case Format::eR10X6G10X6Uint2Pack16ARM: - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM: - case Format::eR12X4UintPack16ARM: - case Format::eR12X4G12X4Uint2Pack16ARM: - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM: - case Format::eR14X2UintPack16ARM: - case Format::eR14X2G14X2Uint2Pack16ARM: - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM: - case Format::eR14X2UnormPack16ARM: - case Format::eR14X2G14X2Unorm2Pack16ARM: - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM: - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return true; - default : return false; - } - } - - // True, if this format has a stencil component - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool hasStencilComponent( Format format ) - { - switch ( format ) - { - case Format::eS8Uint: - case Format::eD16UnormS8Uint: - case Format::eD24UnormS8Uint: - case Format::eD32SfloatS8Uint: return true; - default : return false; - } - } - - // True, if this format is a color. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool isColor( Format format ) - { - return hasRedComponent( format ) || hasGreenComponent( format ) || hasBlueComponent( format ) || hasAlphaComponent( format ); - } - - // True, if this format is a compressed one. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 bool isCompressed( Format format ) - { - return ( *compressionScheme( format ) != 0 ); - } - - // The number of bits into which the format is packed. A single image element in this format - // can be stored in the same space as a scalar type of this bit width. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t packed( Format format ) - { - switch ( format ) - { - case Format::eR4G4UnormPack8 : return 8; - case Format::eR4G4B4A4UnormPack16 : return 16; - case Format::eB4G4R4A4UnormPack16 : return 16; - case Format::eR5G6B5UnormPack16 : return 16; - case Format::eB5G6R5UnormPack16 : return 16; - case Format::eR5G5B5A1UnormPack16 : return 16; - case Format::eB5G5R5A1UnormPack16 : return 16; - case Format::eA1R5G5B5UnormPack16 : return 16; - case Format::eA8B8G8R8UnormPack32 : return 32; - case Format::eA8B8G8R8SnormPack32 : return 32; - case Format::eA8B8G8R8UscaledPack32 : return 32; - case Format::eA8B8G8R8SscaledPack32 : return 32; - case Format::eA8B8G8R8UintPack32 : return 32; - case Format::eA8B8G8R8SintPack32 : return 32; - case Format::eA8B8G8R8SrgbPack32 : return 32; - case Format::eA2R10G10B10UnormPack32 : return 32; - case Format::eA2R10G10B10SnormPack32 : return 32; - case Format::eA2R10G10B10UscaledPack32 : return 32; - case Format::eA2R10G10B10SscaledPack32 : return 32; - case Format::eA2R10G10B10UintPack32 : return 32; - case Format::eA2R10G10B10SintPack32 : return 32; - case Format::eA2B10G10R10UnormPack32 : return 32; - case Format::eA2B10G10R10SnormPack32 : return 32; - case Format::eA2B10G10R10UscaledPack32 : return 32; - case Format::eA2B10G10R10SscaledPack32 : return 32; - case Format::eA2B10G10R10UintPack32 : return 32; - case Format::eA2B10G10R10SintPack32 : return 32; - case Format::eB10G11R11UfloatPack32 : return 32; - case Format::eE5B9G9R9UfloatPack32 : return 32; - case Format::eX8D24UnormPack32 : return 32; - case Format::eR10X6UnormPack16 : return 16; - case Format::eR10X6G10X6Unorm2Pack16 : return 16; - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return 16; - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return 16; - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return 16; - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return 16; - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return 16; - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return 16; - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return 16; - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return 16; - case Format::eR12X4UnormPack16 : return 16; - case Format::eR12X4G12X4Unorm2Pack16 : return 16; - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return 16; - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return 16; - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return 16; - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return 16; - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return 16; - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return 16; - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return 16; - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return 16; - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return 16; - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return 16; - case Format::eA4R4G4B4UnormPack16 : return 16; - case Format::eA4B4G4R4UnormPack16 : return 16; - case Format::eA1B5G5R5UnormPack16 : return 16; - case Format::eR10X6UintPack16ARM : return 16; - case Format::eR10X6G10X6Uint2Pack16ARM : return 16; - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return 16; - case Format::eR12X4UintPack16ARM : return 16; - case Format::eR12X4G12X4Uint2Pack16ARM : return 16; - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return 16; - case Format::eR14X2UintPack16ARM : return 16; - case Format::eR14X2G14X2Uint2Pack16ARM : return 16; - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return 16; - case Format::eR14X2UnormPack16ARM : return 16; - case Format::eR14X2G14X2Unorm2Pack16ARM : return 16; - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return 16; - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return 16; - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return 16; - - default: return 0; - } - } - - // The single-plane format that this plane is compatible with. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 Format planeCompatibleFormat( Format format, uint8_t plane ) - { - switch ( format ) - { - case Format::eG8B8R83Plane420Unorm: - switch ( plane ) - { - case 0 : return Format::eR8Unorm; - case 1 : return Format::eR8Unorm; - case 2 : return Format::eR8Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG8B8R82Plane420Unorm: - switch ( plane ) - { - case 0 : return Format::eR8Unorm; - case 1 : return Format::eR8G8Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG8B8R83Plane422Unorm: - switch ( plane ) - { - case 0 : return Format::eR8Unorm; - case 1 : return Format::eR8Unorm; - case 2 : return Format::eR8Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG8B8R82Plane422Unorm: - switch ( plane ) - { - case 0 : return Format::eR8Unorm; - case 1 : return Format::eR8G8Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG8B8R83Plane444Unorm: - switch ( plane ) - { - case 0 : return Format::eR8Unorm; - case 1 : return Format::eR8Unorm; - case 2 : return Format::eR8Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR10X6UnormPack16; - case 1 : return Format::eR10X6UnormPack16; - case 2 : return Format::eR10X6UnormPack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR10X6UnormPack16; - case 1 : return Format::eR10X6G10X6Unorm2Pack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR10X6UnormPack16; - case 1 : return Format::eR10X6UnormPack16; - case 2 : return Format::eR10X6UnormPack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR10X6UnormPack16; - case 1 : return Format::eR10X6G10X6Unorm2Pack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR10X6UnormPack16; - case 1 : return Format::eR10X6UnormPack16; - case 2 : return Format::eR10X6UnormPack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR12X4UnormPack16; - case 1 : return Format::eR12X4UnormPack16; - case 2 : return Format::eR12X4UnormPack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR12X4UnormPack16; - case 1 : return Format::eR12X4G12X4Unorm2Pack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR12X4UnormPack16; - case 1 : return Format::eR12X4UnormPack16; - case 2 : return Format::eR12X4UnormPack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR12X4UnormPack16; - case 1 : return Format::eR12X4G12X4Unorm2Pack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR12X4UnormPack16; - case 1 : return Format::eR12X4UnormPack16; - case 2 : return Format::eR12X4UnormPack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG16B16R163Plane420Unorm: - switch ( plane ) - { - case 0 : return Format::eR16Unorm; - case 1 : return Format::eR16Unorm; - case 2 : return Format::eR16Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG16B16R162Plane420Unorm: - switch ( plane ) - { - case 0 : return Format::eR16Unorm; - case 1 : return Format::eR16G16Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG16B16R163Plane422Unorm: - switch ( plane ) - { - case 0 : return Format::eR16Unorm; - case 1 : return Format::eR16Unorm; - case 2 : return Format::eR16Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG16B16R162Plane422Unorm: - switch ( plane ) - { - case 0 : return Format::eR16Unorm; - case 1 : return Format::eR16G16Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG16B16R163Plane444Unorm: - switch ( plane ) - { - case 0 : return Format::eR16Unorm; - case 1 : return Format::eR16Unorm; - case 2 : return Format::eR16Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG8B8R82Plane444Unorm: - switch ( plane ) - { - case 0 : return Format::eR8Unorm; - case 1 : return Format::eR8G8Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR10X6UnormPack16; - case 1 : return Format::eR10X6G10X6Unorm2Pack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return Format::eR12X4UnormPack16; - case 1 : return Format::eR12X4G12X4Unorm2Pack16; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG16B16R162Plane444Unorm: - switch ( plane ) - { - case 0 : return Format::eR16Unorm; - case 1 : return Format::eR16G16Unorm; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: - switch ( plane ) - { - case 0 : return Format::eR14X2UnormPack16ARM; - case 1 : return Format::eR14X2G14X2Unorm2Pack16ARM; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: - switch ( plane ) - { - case 0 : return Format::eR14X2UnormPack16ARM; - case 1 : return Format::eR14X2G14X2Unorm2Pack16ARM; - default: VULKAN_HPP_ASSERT( false ); return Format::eUndefined; - } - - default: VULKAN_HPP_ASSERT( plane == 0 ); return format; - } - } - - // The number of image planes of this format. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t planeCount( Format format ) - { - switch ( format ) - { - case Format::eG8B8R83Plane420Unorm : return 3; - case Format::eG8B8R82Plane420Unorm : return 2; - case Format::eG8B8R83Plane422Unorm : return 3; - case Format::eG8B8R82Plane422Unorm : return 2; - case Format::eG8B8R83Plane444Unorm : return 3; - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return 3; - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return 2; - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return 3; - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return 2; - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return 3; - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return 3; - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return 2; - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return 3; - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return 2; - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return 3; - case Format::eG16B16R163Plane420Unorm : return 3; - case Format::eG16B16R162Plane420Unorm : return 2; - case Format::eG16B16R163Plane422Unorm : return 3; - case Format::eG16B16R162Plane422Unorm : return 2; - case Format::eG16B16R163Plane444Unorm : return 3; - case Format::eG8B8R82Plane444Unorm : return 2; - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return 2; - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return 2; - case Format::eG16B16R162Plane444Unorm : return 2; - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return 2; - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return 2; - - default: return 1; - } - } - - // The relative height of this plane. A value of k means that this plane is 1/k the height of the overall format. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t planeHeightDivisor( Format format, uint8_t plane ) - { - switch ( format ) - { - case Format::eG8B8R83Plane420Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG8B8R82Plane420Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG8B8R83Plane422Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG8B8R82Plane422Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG8B8R83Plane444Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R163Plane420Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R162Plane420Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R163Plane422Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R162Plane422Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R163Plane444Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG8B8R82Plane444Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R162Plane444Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - - default: VULKAN_HPP_ASSERT( plane == 0 ); return 1; - } - } - - // The relative width of this plane. A value of k means that this plane is 1/k the width of the overall format. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t planeWidthDivisor( Format format, uint8_t plane ) - { - switch ( format ) - { - case Format::eG8B8R83Plane420Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG8B8R82Plane420Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG8B8R83Plane422Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG8B8R82Plane422Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG8B8R83Plane444Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R163Plane420Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R162Plane420Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R163Plane422Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - case 2 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R162Plane422Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R163Plane444Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - case 2 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG8B8R82Plane444Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG16B16R162Plane444Unorm: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 1; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: - switch ( plane ) - { - case 0 : return 1; - case 1 : return 2; - default: VULKAN_HPP_ASSERT( false ); return 1; - } - - default: VULKAN_HPP_ASSERT( plane == 0 ); return 1; - } - } - - // The number of texels in a texel block. - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_14 uint8_t texelsPerBlock( Format format ) - { - switch ( format ) - { - case Format::eR4G4UnormPack8 : return 1; - case Format::eR4G4B4A4UnormPack16 : return 1; - case Format::eB4G4R4A4UnormPack16 : return 1; - case Format::eR5G6B5UnormPack16 : return 1; - case Format::eB5G6R5UnormPack16 : return 1; - case Format::eR5G5B5A1UnormPack16 : return 1; - case Format::eB5G5R5A1UnormPack16 : return 1; - case Format::eA1R5G5B5UnormPack16 : return 1; - case Format::eR8Unorm : return 1; - case Format::eR8Snorm : return 1; - case Format::eR8Uscaled : return 1; - case Format::eR8Sscaled : return 1; - case Format::eR8Uint : return 1; - case Format::eR8Sint : return 1; - case Format::eR8Srgb : return 1; - case Format::eR8G8Unorm : return 1; - case Format::eR8G8Snorm : return 1; - case Format::eR8G8Uscaled : return 1; - case Format::eR8G8Sscaled : return 1; - case Format::eR8G8Uint : return 1; - case Format::eR8G8Sint : return 1; - case Format::eR8G8Srgb : return 1; - case Format::eR8G8B8Unorm : return 1; - case Format::eR8G8B8Snorm : return 1; - case Format::eR8G8B8Uscaled : return 1; - case Format::eR8G8B8Sscaled : return 1; - case Format::eR8G8B8Uint : return 1; - case Format::eR8G8B8Sint : return 1; - case Format::eR8G8B8Srgb : return 1; - case Format::eB8G8R8Unorm : return 1; - case Format::eB8G8R8Snorm : return 1; - case Format::eB8G8R8Uscaled : return 1; - case Format::eB8G8R8Sscaled : return 1; - case Format::eB8G8R8Uint : return 1; - case Format::eB8G8R8Sint : return 1; - case Format::eB8G8R8Srgb : return 1; - case Format::eR8G8B8A8Unorm : return 1; - case Format::eR8G8B8A8Snorm : return 1; - case Format::eR8G8B8A8Uscaled : return 1; - case Format::eR8G8B8A8Sscaled : return 1; - case Format::eR8G8B8A8Uint : return 1; - case Format::eR8G8B8A8Sint : return 1; - case Format::eR8G8B8A8Srgb : return 1; - case Format::eB8G8R8A8Unorm : return 1; - case Format::eB8G8R8A8Snorm : return 1; - case Format::eB8G8R8A8Uscaled : return 1; - case Format::eB8G8R8A8Sscaled : return 1; - case Format::eB8G8R8A8Uint : return 1; - case Format::eB8G8R8A8Sint : return 1; - case Format::eB8G8R8A8Srgb : return 1; - case Format::eA8B8G8R8UnormPack32 : return 1; - case Format::eA8B8G8R8SnormPack32 : return 1; - case Format::eA8B8G8R8UscaledPack32 : return 1; - case Format::eA8B8G8R8SscaledPack32 : return 1; - case Format::eA8B8G8R8UintPack32 : return 1; - case Format::eA8B8G8R8SintPack32 : return 1; - case Format::eA8B8G8R8SrgbPack32 : return 1; - case Format::eA2R10G10B10UnormPack32 : return 1; - case Format::eA2R10G10B10SnormPack32 : return 1; - case Format::eA2R10G10B10UscaledPack32 : return 1; - case Format::eA2R10G10B10SscaledPack32 : return 1; - case Format::eA2R10G10B10UintPack32 : return 1; - case Format::eA2R10G10B10SintPack32 : return 1; - case Format::eA2B10G10R10UnormPack32 : return 1; - case Format::eA2B10G10R10SnormPack32 : return 1; - case Format::eA2B10G10R10UscaledPack32 : return 1; - case Format::eA2B10G10R10SscaledPack32 : return 1; - case Format::eA2B10G10R10UintPack32 : return 1; - case Format::eA2B10G10R10SintPack32 : return 1; - case Format::eR16Unorm : return 1; - case Format::eR16Snorm : return 1; - case Format::eR16Uscaled : return 1; - case Format::eR16Sscaled : return 1; - case Format::eR16Uint : return 1; - case Format::eR16Sint : return 1; - case Format::eR16Sfloat : return 1; - case Format::eR16G16Unorm : return 1; - case Format::eR16G16Snorm : return 1; - case Format::eR16G16Uscaled : return 1; - case Format::eR16G16Sscaled : return 1; - case Format::eR16G16Uint : return 1; - case Format::eR16G16Sint : return 1; - case Format::eR16G16Sfloat : return 1; - case Format::eR16G16B16Unorm : return 1; - case Format::eR16G16B16Snorm : return 1; - case Format::eR16G16B16Uscaled : return 1; - case Format::eR16G16B16Sscaled : return 1; - case Format::eR16G16B16Uint : return 1; - case Format::eR16G16B16Sint : return 1; - case Format::eR16G16B16Sfloat : return 1; - case Format::eR16G16B16A16Unorm : return 1; - case Format::eR16G16B16A16Snorm : return 1; - case Format::eR16G16B16A16Uscaled : return 1; - case Format::eR16G16B16A16Sscaled : return 1; - case Format::eR16G16B16A16Uint : return 1; - case Format::eR16G16B16A16Sint : return 1; - case Format::eR16G16B16A16Sfloat : return 1; - case Format::eR32Uint : return 1; - case Format::eR32Sint : return 1; - case Format::eR32Sfloat : return 1; - case Format::eR32G32Uint : return 1; - case Format::eR32G32Sint : return 1; - case Format::eR32G32Sfloat : return 1; - case Format::eR32G32B32Uint : return 1; - case Format::eR32G32B32Sint : return 1; - case Format::eR32G32B32Sfloat : return 1; - case Format::eR32G32B32A32Uint : return 1; - case Format::eR32G32B32A32Sint : return 1; - case Format::eR32G32B32A32Sfloat : return 1; - case Format::eR64Uint : return 1; - case Format::eR64Sint : return 1; - case Format::eR64Sfloat : return 1; - case Format::eR64G64Uint : return 1; - case Format::eR64G64Sint : return 1; - case Format::eR64G64Sfloat : return 1; - case Format::eR64G64B64Uint : return 1; - case Format::eR64G64B64Sint : return 1; - case Format::eR64G64B64Sfloat : return 1; - case Format::eR64G64B64A64Uint : return 1; - case Format::eR64G64B64A64Sint : return 1; - case Format::eR64G64B64A64Sfloat : return 1; - case Format::eB10G11R11UfloatPack32 : return 1; - case Format::eE5B9G9R9UfloatPack32 : return 1; - case Format::eD16Unorm : return 1; - case Format::eX8D24UnormPack32 : return 1; - case Format::eD32Sfloat : return 1; - case Format::eS8Uint : return 1; - case Format::eD16UnormS8Uint : return 1; - case Format::eD24UnormS8Uint : return 1; - case Format::eD32SfloatS8Uint : return 1; - case Format::eBc1RgbUnormBlock : return 16; - case Format::eBc1RgbSrgbBlock : return 16; - case Format::eBc1RgbaUnormBlock : return 16; - case Format::eBc1RgbaSrgbBlock : return 16; - case Format::eBc2UnormBlock : return 16; - case Format::eBc2SrgbBlock : return 16; - case Format::eBc3UnormBlock : return 16; - case Format::eBc3SrgbBlock : return 16; - case Format::eBc4UnormBlock : return 16; - case Format::eBc4SnormBlock : return 16; - case Format::eBc5UnormBlock : return 16; - case Format::eBc5SnormBlock : return 16; - case Format::eBc6HUfloatBlock : return 16; - case Format::eBc6HSfloatBlock : return 16; - case Format::eBc7UnormBlock : return 16; - case Format::eBc7SrgbBlock : return 16; - case Format::eEtc2R8G8B8UnormBlock : return 16; - case Format::eEtc2R8G8B8SrgbBlock : return 16; - case Format::eEtc2R8G8B8A1UnormBlock : return 16; - case Format::eEtc2R8G8B8A1SrgbBlock : return 16; - case Format::eEtc2R8G8B8A8UnormBlock : return 16; - case Format::eEtc2R8G8B8A8SrgbBlock : return 16; - case Format::eEacR11UnormBlock : return 16; - case Format::eEacR11SnormBlock : return 16; - case Format::eEacR11G11UnormBlock : return 16; - case Format::eEacR11G11SnormBlock : return 16; - case Format::eAstc4x4UnormBlock : return 16; - case Format::eAstc4x4SrgbBlock : return 16; - case Format::eAstc5x4UnormBlock : return 20; - case Format::eAstc5x4SrgbBlock : return 20; - case Format::eAstc5x5UnormBlock : return 25; - case Format::eAstc5x5SrgbBlock : return 25; - case Format::eAstc6x5UnormBlock : return 30; - case Format::eAstc6x5SrgbBlock : return 30; - case Format::eAstc6x6UnormBlock : return 36; - case Format::eAstc6x6SrgbBlock : return 36; - case Format::eAstc8x5UnormBlock : return 40; - case Format::eAstc8x5SrgbBlock : return 40; - case Format::eAstc8x6UnormBlock : return 48; - case Format::eAstc8x6SrgbBlock : return 48; - case Format::eAstc8x8UnormBlock : return 64; - case Format::eAstc8x8SrgbBlock : return 64; - case Format::eAstc10x5UnormBlock : return 50; - case Format::eAstc10x5SrgbBlock : return 50; - case Format::eAstc10x6UnormBlock : return 60; - case Format::eAstc10x6SrgbBlock : return 60; - case Format::eAstc10x8UnormBlock : return 80; - case Format::eAstc10x8SrgbBlock : return 80; - case Format::eAstc10x10UnormBlock : return 100; - case Format::eAstc10x10SrgbBlock : return 100; - case Format::eAstc12x10UnormBlock : return 120; - case Format::eAstc12x10SrgbBlock : return 120; - case Format::eAstc12x12UnormBlock : return 144; - case Format::eAstc12x12SrgbBlock : return 144; - case Format::eG8B8G8R8422Unorm : return 1; - case Format::eB8G8R8G8422Unorm : return 1; - case Format::eG8B8R83Plane420Unorm : return 1; - case Format::eG8B8R82Plane420Unorm : return 1; - case Format::eG8B8R83Plane422Unorm : return 1; - case Format::eG8B8R82Plane422Unorm : return 1; - case Format::eG8B8R83Plane444Unorm : return 1; - case Format::eR10X6UnormPack16 : return 1; - case Format::eR10X6G10X6Unorm2Pack16 : return 1; - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return 1; - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return 1; - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return 1; - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return 1; - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return 1; - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return 1; - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return 1; - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return 1; - case Format::eR12X4UnormPack16 : return 1; - case Format::eR12X4G12X4Unorm2Pack16 : return 1; - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return 1; - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return 1; - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return 1; - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return 1; - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return 1; - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return 1; - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return 1; - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return 1; - case Format::eG16B16G16R16422Unorm : return 1; - case Format::eB16G16R16G16422Unorm : return 1; - case Format::eG16B16R163Plane420Unorm : return 1; - case Format::eG16B16R162Plane420Unorm : return 1; - case Format::eG16B16R163Plane422Unorm : return 1; - case Format::eG16B16R162Plane422Unorm : return 1; - case Format::eG16B16R163Plane444Unorm : return 1; - case Format::eG8B8R82Plane444Unorm : return 1; - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return 1; - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return 1; - case Format::eG16B16R162Plane444Unorm : return 1; - case Format::eA4R4G4B4UnormPack16 : return 1; - case Format::eA4B4G4R4UnormPack16 : return 1; - case Format::eAstc4x4SfloatBlock : return 16; - case Format::eAstc5x4SfloatBlock : return 20; - case Format::eAstc5x5SfloatBlock : return 25; - case Format::eAstc6x5SfloatBlock : return 30; - case Format::eAstc6x6SfloatBlock : return 36; - case Format::eAstc8x5SfloatBlock : return 40; - case Format::eAstc8x6SfloatBlock : return 48; - case Format::eAstc8x8SfloatBlock : return 64; - case Format::eAstc10x5SfloatBlock : return 50; - case Format::eAstc10x6SfloatBlock : return 60; - case Format::eAstc10x8SfloatBlock : return 80; - case Format::eAstc10x10SfloatBlock : return 100; - case Format::eAstc12x10SfloatBlock : return 120; - case Format::eAstc12x12SfloatBlock : return 144; - case Format::eA1B5G5R5UnormPack16 : return 1; - case Format::eA8Unorm : return 1; - case Format::ePvrtc12BppUnormBlockIMG : return 1; - case Format::ePvrtc14BppUnormBlockIMG : return 1; - case Format::ePvrtc22BppUnormBlockIMG : return 1; - case Format::ePvrtc24BppUnormBlockIMG : return 1; - case Format::ePvrtc12BppSrgbBlockIMG : return 1; - case Format::ePvrtc14BppSrgbBlockIMG : return 1; - case Format::ePvrtc22BppSrgbBlockIMG : return 1; - case Format::ePvrtc24BppSrgbBlockIMG : return 1; - case Format::eAstc3x3x3UnormBlockEXT : return 27; - case Format::eAstc3x3x3SrgbBlockEXT : return 27; - case Format::eAstc3x3x3SfloatBlockEXT : return 27; - case Format::eAstc4x3x3UnormBlockEXT : return 36; - case Format::eAstc4x3x3SrgbBlockEXT : return 36; - case Format::eAstc4x3x3SfloatBlockEXT : return 36; - case Format::eAstc4x4x3UnormBlockEXT : return 48; - case Format::eAstc4x4x3SrgbBlockEXT : return 48; - case Format::eAstc4x4x3SfloatBlockEXT : return 48; - case Format::eAstc4x4x4UnormBlockEXT : return 64; - case Format::eAstc4x4x4SrgbBlockEXT : return 64; - case Format::eAstc4x4x4SfloatBlockEXT : return 64; - case Format::eAstc5x4x4UnormBlockEXT : return 80; - case Format::eAstc5x4x4SrgbBlockEXT : return 80; - case Format::eAstc5x4x4SfloatBlockEXT : return 80; - case Format::eAstc5x5x4UnormBlockEXT : return 100; - case Format::eAstc5x5x4SrgbBlockEXT : return 100; - case Format::eAstc5x5x4SfloatBlockEXT : return 100; - case Format::eAstc5x5x5UnormBlockEXT : return 125; - case Format::eAstc5x5x5SrgbBlockEXT : return 125; - case Format::eAstc5x5x5SfloatBlockEXT : return 125; - case Format::eAstc6x5x5UnormBlockEXT : return 150; - case Format::eAstc6x5x5SrgbBlockEXT : return 150; - case Format::eAstc6x5x5SfloatBlockEXT : return 150; - case Format::eAstc6x6x5UnormBlockEXT : return 180; - case Format::eAstc6x6x5SrgbBlockEXT : return 180; - case Format::eAstc6x6x5SfloatBlockEXT : return 180; - case Format::eAstc6x6x6UnormBlockEXT : return 216; - case Format::eAstc6x6x6SrgbBlockEXT : return 216; - case Format::eAstc6x6x6SfloatBlockEXT : return 216; - case Format::eR8BoolARM : return 1; - case Format::eR16G16Sfixed5NV : return 1; - case Format::eR10X6UintPack16ARM : return 1; - case Format::eR10X6G10X6Uint2Pack16ARM : return 1; - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return 1; - case Format::eR12X4UintPack16ARM : return 1; - case Format::eR12X4G12X4Uint2Pack16ARM : return 1; - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return 1; - case Format::eR14X2UintPack16ARM : return 1; - case Format::eR14X2G14X2Uint2Pack16ARM : return 1; - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return 1; - case Format::eR14X2UnormPack16ARM : return 1; - case Format::eR14X2G14X2Unorm2Pack16ARM : return 1; - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return 1; - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return 1; - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return 1; - - default: VULKAN_HPP_ASSERT( false ); return 0; - } - } - -} // namespace VULKAN_HPP_NAMESPACE -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_fuchsia.h b/lib/vulkan-headers/include/vulkan/vulkan_fuchsia.h deleted file mode 100644 index ccca6271f34..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_fuchsia.h +++ /dev/null @@ -1,282 +0,0 @@ -#ifndef VULKAN_FUCHSIA_H_ -#define VULKAN_FUCHSIA_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_FUCHSIA_imagepipe_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_FUCHSIA_imagepipe_surface 1 -#define VK_FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION 1 -#define VK_FUCHSIA_IMAGEPIPE_SURFACE_EXTENSION_NAME "VK_FUCHSIA_imagepipe_surface" -typedef VkFlags VkImagePipeSurfaceCreateFlagsFUCHSIA; -typedef struct VkImagePipeSurfaceCreateInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - VkImagePipeSurfaceCreateFlagsFUCHSIA flags; - zx_handle_t imagePipeHandle; -} VkImagePipeSurfaceCreateInfoFUCHSIA; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateImagePipeSurfaceFUCHSIA)(VkInstance instance, const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateImagePipeSurfaceFUCHSIA( - VkInstance instance, - const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif -#endif - - -// VK_FUCHSIA_external_memory is a preprocessor guard. Do not pass it to API calls. -#define VK_FUCHSIA_external_memory 1 -#define VK_FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION 1 -#define VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME "VK_FUCHSIA_external_memory" -typedef struct VkImportMemoryZirconHandleInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - zx_handle_t handle; -} VkImportMemoryZirconHandleInfoFUCHSIA; - -typedef struct VkMemoryZirconHandlePropertiesFUCHSIA { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryZirconHandlePropertiesFUCHSIA; - -typedef struct VkMemoryGetZirconHandleInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkMemoryGetZirconHandleInfoFUCHSIA; - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandleFUCHSIA)(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandleFUCHSIA( - VkDevice device, - const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, - zx_handle_t* pZirconHandle); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryZirconHandlePropertiesFUCHSIA( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - zx_handle_t zirconHandle, - VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); -#endif -#endif - - -// VK_FUCHSIA_external_semaphore is a preprocessor guard. Do not pass it to API calls. -#define VK_FUCHSIA_external_semaphore 1 -#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION 1 -#define VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_FUCHSIA_external_semaphore" -typedef struct VkImportSemaphoreZirconHandleInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkSemaphoreImportFlags flags; - VkExternalSemaphoreHandleTypeFlagBits handleType; - zx_handle_t zirconHandle; -} VkImportSemaphoreZirconHandleInfoFUCHSIA; - -typedef struct VkSemaphoreGetZirconHandleInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkSemaphoreGetZirconHandleInfoFUCHSIA; - -typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreZirconHandleFUCHSIA)(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreZirconHandleFUCHSIA( - VkDevice device, - const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreZirconHandleFUCHSIA( - VkDevice device, - const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, - zx_handle_t* pZirconHandle); -#endif -#endif - - -// VK_FUCHSIA_buffer_collection is a preprocessor guard. Do not pass it to API calls. -#define VK_FUCHSIA_buffer_collection 1 -VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferCollectionFUCHSIA) -#define VK_FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION 2 -#define VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME "VK_FUCHSIA_buffer_collection" -typedef VkFlags VkImageFormatConstraintsFlagsFUCHSIA; - -typedef enum VkImageConstraintsInfoFlagBitsFUCHSIA { - VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_RARELY_FUCHSIA = 0x00000001, - VK_IMAGE_CONSTRAINTS_INFO_CPU_READ_OFTEN_FUCHSIA = 0x00000002, - VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_RARELY_FUCHSIA = 0x00000004, - VK_IMAGE_CONSTRAINTS_INFO_CPU_WRITE_OFTEN_FUCHSIA = 0x00000008, - VK_IMAGE_CONSTRAINTS_INFO_PROTECTED_OPTIONAL_FUCHSIA = 0x00000010, - VK_IMAGE_CONSTRAINTS_INFO_FLAG_BITS_MAX_ENUM_FUCHSIA = 0x7FFFFFFF -} VkImageConstraintsInfoFlagBitsFUCHSIA; -typedef VkFlags VkImageConstraintsInfoFlagsFUCHSIA; -typedef struct VkBufferCollectionCreateInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - zx_handle_t collectionToken; -} VkBufferCollectionCreateInfoFUCHSIA; - -typedef struct VkImportMemoryBufferCollectionFUCHSIA { - VkStructureType sType; - const void* pNext; - VkBufferCollectionFUCHSIA collection; - uint32_t index; -} VkImportMemoryBufferCollectionFUCHSIA; - -typedef struct VkBufferCollectionImageCreateInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - VkBufferCollectionFUCHSIA collection; - uint32_t index; -} VkBufferCollectionImageCreateInfoFUCHSIA; - -typedef struct VkBufferCollectionConstraintsInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - uint32_t minBufferCount; - uint32_t maxBufferCount; - uint32_t minBufferCountForCamping; - uint32_t minBufferCountForDedicatedSlack; - uint32_t minBufferCountForSharedSlack; -} VkBufferCollectionConstraintsInfoFUCHSIA; - -typedef struct VkBufferConstraintsInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - VkBufferCreateInfo createInfo; - VkFormatFeatureFlags requiredFormatFeatures; - VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; -} VkBufferConstraintsInfoFUCHSIA; - -typedef struct VkBufferCollectionBufferCreateInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - VkBufferCollectionFUCHSIA collection; - uint32_t index; -} VkBufferCollectionBufferCreateInfoFUCHSIA; - -typedef struct VkSysmemColorSpaceFUCHSIA { - VkStructureType sType; - const void* pNext; - uint32_t colorSpace; -} VkSysmemColorSpaceFUCHSIA; - -typedef struct VkBufferCollectionPropertiesFUCHSIA { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; - uint32_t bufferCount; - uint32_t createInfoIndex; - uint64_t sysmemPixelFormat; - VkFormatFeatureFlags formatFeatures; - VkSysmemColorSpaceFUCHSIA sysmemColorSpaceIndex; - VkComponentMapping samplerYcbcrConversionComponents; - VkSamplerYcbcrModelConversion suggestedYcbcrModel; - VkSamplerYcbcrRange suggestedYcbcrRange; - VkChromaLocation suggestedXChromaOffset; - VkChromaLocation suggestedYChromaOffset; -} VkBufferCollectionPropertiesFUCHSIA; - -typedef struct VkImageFormatConstraintsInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - VkImageCreateInfo imageCreateInfo; - VkFormatFeatureFlags requiredFormatFeatures; - VkImageFormatConstraintsFlagsFUCHSIA flags; - uint64_t sysmemPixelFormat; - uint32_t colorSpaceCount; - const VkSysmemColorSpaceFUCHSIA* pColorSpaces; -} VkImageFormatConstraintsInfoFUCHSIA; - -typedef struct VkImageConstraintsInfoFUCHSIA { - VkStructureType sType; - const void* pNext; - uint32_t formatConstraintsCount; - const VkImageFormatConstraintsInfoFUCHSIA* pFormatConstraints; - VkBufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints; - VkImageConstraintsInfoFlagsFUCHSIA flags; -} VkImageConstraintsInfoFUCHSIA; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferCollectionFUCHSIA)(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection); -typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionImageConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); -typedef VkResult (VKAPI_PTR *PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); -typedef void (VKAPI_PTR *PFN_vkDestroyBufferCollectionFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator); -typedef VkResult (VKAPI_PTR *PFN_vkGetBufferCollectionPropertiesFUCHSIA)(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferCollectionFUCHSIA( - VkDevice device, - const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBufferCollectionFUCHSIA* pCollection); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionImageConstraintsFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkSetBufferCollectionBufferConstraintsFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkDestroyBufferCollectionFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkAllocationCallbacks* pAllocator); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetBufferCollectionPropertiesFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - VkBufferCollectionPropertiesFUCHSIA* pProperties); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_funcs.hpp b/lib/vulkan-headers/include/vulkan/vulkan_funcs.hpp deleted file mode 100644 index 41f3a2a2e30..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_funcs.hpp +++ /dev/null @@ -1,32761 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_FUNCS_HPP -#define VULKAN_FUNCS_HPP - -// include-what-you-use: make sure, vulkan.hpp is used by code-completers -// IWYU pragma: private, include "vulkan/vulkan.hpp" - -namespace VULKAN_HPP_NAMESPACE -{ - - //=========================== - //=== COMMAND Definitions === - //=========================== - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result createInstance( const InstanceCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Instance * pInstance, - Dispatch const & d ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateInstance( reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pInstance ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - createInstance( const InstanceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateInstance && "Function requires " ); -# endif - - Instance instance; - Result result = static_cast( d.vkCreateInstance( reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &instance ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::createInstance" ); - - return detail::createResultValueType( result, std::move( instance ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - createInstanceUnique( const InstanceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateInstance && "Function requires " ); -# endif - - Instance instance; - Result result = static_cast( d.vkCreateInstance( reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &instance ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::createInstanceUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( instance, detail::ObjectDestroy( allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html - template ::type> - VULKAN_HPP_INLINE void Instance::destroy( const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyInstance( static_cast( m_instance ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html - template ::type> - VULKAN_HPP_INLINE void Instance::destroy( Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyInstance && "Function requires " ); -# endif - - d.vkDestroyInstance( m_instance, reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount, - PhysicalDevice * pPhysicalDevices, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkEnumeratePhysicalDevices( static_cast( m_instance ), pPhysicalDeviceCount, reinterpret_cast( pPhysicalDevices ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::enumeratePhysicalDevices( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDevices && "Function requires " ); -# endif - - std::vector physicalDevices; - uint32_t physicalDeviceCount; - Result result; - do - { - result = static_cast( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceCount ) - { - physicalDevices.resize( physicalDeviceCount ); - result = static_cast( - d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast( physicalDevices.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" ); - VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); - if ( physicalDeviceCount < physicalDevices.size() ) - { - physicalDevices.resize( physicalDeviceCount ); - } - return detail::createResultValueType( result, std::move( physicalDevices ) ); - } - - // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::enumeratePhysicalDevices( PhysicalDeviceAllocator const & physicalDeviceAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDevices && "Function requires " ); -# endif - - std::vector physicalDevices( physicalDeviceAllocator ); - uint32_t physicalDeviceCount; - Result result; - do - { - result = static_cast( d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceCount ) - { - physicalDevices.resize( physicalDeviceCount ); - result = static_cast( - d.vkEnumeratePhysicalDevices( m_instance, &physicalDeviceCount, reinterpret_cast( physicalDevices.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" ); - VULKAN_HPP_ASSERT( physicalDeviceCount <= physicalDevices.size() ); - if ( physicalDeviceCount < physicalDevices.size() ) - { - physicalDevices.resize( physicalDeviceCount ); - } - return detail::createResultValueType( result, std::move( physicalDevices ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getFeatures( PhysicalDeviceFeatures * pFeatures, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceFeatures( static_cast( m_physicalDevice ), reinterpret_cast( pFeatures ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures && "Function requires " ); -# endif - - PhysicalDeviceFeatures features; - d.vkGetPhysicalDeviceFeatures( m_physicalDevice, reinterpret_cast( &features ) ); - - return features; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html - template ::type> - VULKAN_HPP_INLINE void - PhysicalDevice::getFormatProperties( Format format, FormatProperties * pFormatProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceFormatProperties( - static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( pFormatProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties && "Function requires " ); -# endif - - FormatProperties formatProperties; - d.vkGetPhysicalDeviceFormatProperties( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); - - return formatProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties( Format format, - ImageType type, - ImageTiling tiling, - ImageUsageFlags usage, - ImageCreateFlags flags, - ImageFormatProperties * pImageFormatProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceImageFormatProperties( static_cast( m_physicalDevice ), - static_cast( format ), - static_cast( type ), - static_cast( tiling ), - static_cast( usage ), - static_cast( flags ), - reinterpret_cast( pImageFormatProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::getImageFormatProperties( - Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties && "Function requires " ); -# endif - - ImageFormatProperties imageFormatProperties; - Result result = static_cast( d.vkGetPhysicalDeviceImageFormatProperties( m_physicalDevice, - static_cast( format ), - static_cast( type ), - static_cast( tiling ), - static_cast( usage ), - static_cast( flags ), - reinterpret_cast( &imageFormatProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); - - return detail::createResultValueType( result, std::move( imageFormatProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getProperties( PhysicalDeviceProperties * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceProperties( static_cast( m_physicalDevice ), reinterpret_cast( pProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties && "Function requires " ); -# endif - - PhysicalDeviceProperties properties; - d.vkGetPhysicalDeviceProperties( m_physicalDevice, reinterpret_cast( &properties ) ); - - return properties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount, - QueueFamilyProperties * pQueueFamilyProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceQueueFamilyProperties( - static_cast( m_physicalDevice ), pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getQueueFamilyProperties( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties && "Function requires " ); -# endif - - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties( - m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - queueFamilyProperties.resize( queueFamilyPropertyCount ); - } - return queueFamilyProperties; - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getQueueFamilyProperties( QueueFamilyPropertiesAllocator const & queueFamilyPropertiesAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties && "Function requires " ); -# endif - - std::vector queueFamilyProperties( queueFamilyPropertiesAllocator ); - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties( - m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - queueFamilyProperties.resize( queueFamilyPropertyCount ); - } - return queueFamilyProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties( PhysicalDeviceMemoryProperties * pMemoryProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceMemoryProperties( static_cast( m_physicalDevice ), - reinterpret_cast( pMemoryProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties && "Function requires " ); -# endif - - PhysicalDeviceMemoryProperties memoryProperties; - d.vkGetPhysicalDeviceMemoryProperties( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); - - return memoryProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html - template ::type> - VULKAN_HPP_INLINE PFN_vkVoidFunction Instance::getProcAddr( const char * pName, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return d.vkGetInstanceProcAddr( static_cast( m_instance ), pName ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html - template ::type> - VULKAN_HPP_INLINE PFN_VoidFunction Instance::getProcAddr( const std::string & name, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetInstanceProcAddr && "Function requires " ); -# endif - - PFN_vkVoidFunction result = d.vkGetInstanceProcAddr( m_instance, name.c_str() ); - - return result; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html - template ::type> - VULKAN_HPP_INLINE PFN_vkVoidFunction Device::getProcAddr( const char * pName, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return d.vkGetDeviceProcAddr( static_cast( m_device ), pName ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html - template ::type> - VULKAN_HPP_INLINE PFN_VoidFunction Device::getProcAddr( const std::string & name, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceProcAddr && "Function requires " ); -# endif - - PFN_vkVoidFunction result = d.vkGetDeviceProcAddr( m_device, name.c_str() ); - - return result; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::createDevice( const DeviceCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Device * pDevice, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDevice( static_cast( m_physicalDevice ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pDevice ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::createDevice( const DeviceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDevice && "Function requires " ); -# endif - - Device device; - Result result = static_cast( d.vkCreateDevice( m_physicalDevice, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &device ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDevice" ); - - return detail::createResultValueType( result, std::move( device ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::createDeviceUnique( const DeviceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDevice && "Function requires " ); -# endif - - Device device; - Result result = static_cast( d.vkCreateDevice( m_physicalDevice, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &device ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDeviceUnique" ); - - return detail::createResultValueType( result, UniqueHandle( device, detail::ObjectDestroy( allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDevice( static_cast( m_device ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDevice && "Function requires " ); -# endif - - d.vkDestroyDevice( m_device, reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkEnumerateInstanceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceExtensionProperties( const char * pLayerName, - uint32_t * pPropertyCount, - ExtensionProperties * pProperties, - Dispatch const & d ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkEnumerateInstanceExtensionProperties( pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumerateInstanceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - enumerateInstanceExtensionProperties( Optional layerName, Dispatch const & d ) - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumerateInstanceExtensionProperties && "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkEnumerateInstanceExtensionProperties( - layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkEnumerateInstanceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - enumerateInstanceExtensionProperties( Optional layerName, - ExtensionPropertiesAllocator const & extensionPropertiesAllocator, - Dispatch const & d ) - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumerateInstanceExtensionProperties && "Function requires " ); -# endif - - std::vector properties( extensionPropertiesAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkEnumerateInstanceExtensionProperties( - layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceExtensionProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkEnumerateDeviceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceExtensionProperties( const char * pLayerName, - uint32_t * pPropertyCount, - ExtensionProperties * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkEnumerateDeviceExtensionProperties( - static_cast( m_physicalDevice ), pLayerName, pPropertyCount, reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumerateDeviceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumerateDeviceExtensionProperties && "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = - static_cast( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkEnumerateDeviceExtensionProperties( - m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkEnumerateDeviceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName, - ExtensionPropertiesAllocator const & extensionPropertiesAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumerateDeviceExtensionProperties && "Function requires " ); -# endif - - std::vector properties( extensionPropertiesAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = - static_cast( d.vkEnumerateDeviceExtensionProperties( m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkEnumerateDeviceExtensionProperties( - m_physicalDevice, layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkEnumerateInstanceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount, - LayerProperties * pProperties, - Dispatch const & d ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkEnumerateInstanceLayerProperties( pPropertyCount, reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumerateInstanceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - enumerateInstanceLayerProperties( Dispatch const & d ) - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumerateInstanceLayerProperties && "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkEnumerateInstanceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - enumerateInstanceLayerProperties( LayerPropertiesAllocator const & layerPropertiesAllocator, Dispatch const & d ) - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumerateInstanceLayerProperties && "Function requires " ); -# endif - - std::vector properties( layerPropertiesAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceLayerProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkEnumerateDeviceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::enumerateDeviceLayerProperties( uint32_t * pPropertyCount, - LayerProperties * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkEnumerateDeviceLayerProperties( - static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumerateDeviceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::enumerateDeviceLayerProperties( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumerateDeviceLayerProperties && "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( - d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkEnumerateDeviceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::enumerateDeviceLayerProperties( LayerPropertiesAllocator const & layerPropertiesAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumerateDeviceLayerProperties && "Function requires " ); -# endif - - std::vector properties( layerPropertiesAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( - d.vkEnumerateDeviceLayerProperties( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html - template ::type> - VULKAN_HPP_INLINE void Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Queue * pQueue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceQueue( static_cast( m_device ), queueFamilyIndex, queueIndex, reinterpret_cast( pQueue ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceQueue && "Function requires " ); -# endif - - Queue queue; - d.vkGetDeviceQueue( m_device, queueFamilyIndex, queueIndex, reinterpret_cast( &queue ) ); - - return queue; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Queue::submit( uint32_t submitCount, const SubmitInfo * pSubmits, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkQueueSubmit( static_cast( m_queue ), submitCount, reinterpret_cast( pSubmits ), static_cast( fence ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Queue::submit( ArrayProxy const & submits, Fence fence, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkQueueSubmit && "Function requires " ); -# endif - - Result result = static_cast( - d.vkQueueSubmit( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkQueueWaitIdle( static_cast( m_queue ) ) ); - } -#else - // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Queue::waitIdle( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkQueueWaitIdle && "Function requires " ); -# endif - - Result result = static_cast( d.vkQueueWaitIdle( m_queue ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::waitIdle" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitIdle( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkDeviceWaitIdle( static_cast( m_device ) ) ); - } -#else - // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::waitIdle( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDeviceWaitIdle && "Function requires " ); -# endif - - Result result = static_cast( d.vkDeviceWaitIdle( m_device ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitIdle" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateMemory( const MemoryAllocateInfo * pAllocateInfo, - const AllocationCallbacks * pAllocator, - DeviceMemory * pMemory, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkAllocateMemory( static_cast( m_device ), - reinterpret_cast( pAllocateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pMemory ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::allocateMemory( const MemoryAllocateInfo & allocateInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAllocateMemory && "Function requires " ); -# endif - - DeviceMemory memory; - Result result = static_cast( d.vkAllocateMemory( m_device, - reinterpret_cast( &allocateInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &memory ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemory" ); - - return detail::createResultValueType( result, std::move( memory ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAllocateMemory && "Function requires " ); -# endif - - DeviceMemory memory; - Result result = static_cast( d.vkAllocateMemory( m_device, - reinterpret_cast( &allocateInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &memory ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateMemoryUnique" ); - - return detail::createResultValueType( result, UniqueHandle( memory, detail::ObjectFree( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html - template ::type> - VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkFreeMemory( static_cast( m_device ), static_cast( memory ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html - template ::type> - VULKAN_HPP_INLINE void Device::freeMemory( DeviceMemory memory, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkFreeMemory && "Function requires " ); -# endif - - d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html - template ::type> - VULKAN_HPP_INLINE void( Device::free )( DeviceMemory memory, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkFreeMemory( static_cast( m_device ), static_cast( memory ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html - template ::type> - VULKAN_HPP_INLINE void( Device::free )( DeviceMemory memory, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkFreeMemory && "Function requires " ); -# endif - - d.vkFreeMemory( m_device, static_cast( memory ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory( - DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, void ** ppData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkMapMemory( static_cast( m_device ), - static_cast( memory ), - static_cast( offset ), - static_cast( size ), - static_cast( flags ), - ppData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::mapMemory( DeviceMemory memory, DeviceSize offset, DeviceSize size, MemoryMapFlags flags, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkMapMemory && "Function requires " ); -# endif - - void * pData; - Result result = static_cast( d.vkMapMemory( m_device, - static_cast( memory ), - static_cast( offset ), - static_cast( size ), - static_cast( flags ), - &pData ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory" ); - - return detail::createResultValueType( result, std::move( pData ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html - template ::type> - VULKAN_HPP_INLINE void Device::unmapMemory( DeviceMemory memory, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkUnmapMemory( static_cast( m_device ), static_cast( memory ) ); - } - - // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::flushMappedMemoryRanges( uint32_t memoryRangeCount, - const MappedMemoryRange * pMemoryRanges, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkFlushMappedMemoryRanges( static_cast( m_device ), memoryRangeCount, reinterpret_cast( pMemoryRanges ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::flushMappedMemoryRanges( ArrayProxy const & memoryRanges, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkFlushMappedMemoryRanges && "Function requires " ); -# endif - - Result result = - static_cast( d.vkFlushMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkInvalidateMappedMemoryRanges, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::invalidateMappedMemoryRanges( uint32_t memoryRangeCount, - const MappedMemoryRange * pMemoryRanges, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkInvalidateMappedMemoryRanges( static_cast( m_device ), memoryRangeCount, reinterpret_cast( pMemoryRanges ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkInvalidateMappedMemoryRanges, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::invalidateMappedMemoryRanges( ArrayProxy const & memoryRanges, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkInvalidateMappedMemoryRanges && "Function requires " ); -# endif - - Result result = static_cast( - d.vkInvalidateMappedMemoryRanges( m_device, memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html - template ::type> - VULKAN_HPP_INLINE void Device::getMemoryCommitment( DeviceMemory memory, DeviceSize * pCommittedMemoryInBytes, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceMemoryCommitment( - static_cast( m_device ), static_cast( memory ), reinterpret_cast( pCommittedMemoryInBytes ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize Device::getMemoryCommitment( DeviceMemory memory, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryCommitment && "Function requires " ); -# endif - - DeviceSize committedMemoryInBytes; - d.vkGetDeviceMemoryCommitment( m_device, static_cast( memory ), reinterpret_cast( &committedMemoryInBytes ) ); - - return committedMemoryInBytes; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkBindBufferMemory( - static_cast( m_device ), static_cast( buffer ), static_cast( memory ), static_cast( memoryOffset ) ) ); - } -#else - // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBindBufferMemory && "Function requires " ); -# endif - - Result result = static_cast( - d.vkBindBufferMemory( m_device, static_cast( buffer ), static_cast( memory ), static_cast( memoryOffset ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkBindImageMemory( - static_cast( m_device ), static_cast( image ), static_cast( memory ), static_cast( memoryOffset ) ) ); - } -#else - // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBindImageMemory && "Function requires " ); -# endif - - Result result = static_cast( - d.vkBindImageMemory( m_device, static_cast( image ), static_cast( memory ), static_cast( memoryOffset ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html - template ::type> - VULKAN_HPP_INLINE void - Device::getBufferMemoryRequirements( Buffer buffer, MemoryRequirements * pMemoryRequirements, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetBufferMemoryRequirements( - static_cast( m_device ), static_cast( buffer ), reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements Device::getBufferMemoryRequirements( Buffer buffer, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements && "Function requires " ); -# endif - - MemoryRequirements memoryRequirements; - d.vkGetBufferMemoryRequirements( m_device, static_cast( buffer ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html - template ::type> - VULKAN_HPP_INLINE void - Device::getImageMemoryRequirements( Image image, MemoryRequirements * pMemoryRequirements, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetImageMemoryRequirements( - static_cast( m_device ), static_cast( image ), reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements Device::getImageMemoryRequirements( Image image, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements && "Function requires " ); -# endif - - MemoryRequirements memoryRequirements; - d.vkGetImageMemoryRequirements( m_device, static_cast( image ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( Image image, - uint32_t * pSparseMemoryRequirementCount, - SparseImageMemoryRequirements * pSparseMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetImageSparseMemoryRequirements( static_cast( m_device ), - static_cast( image ), - pSparseMemoryRequirementCount, - reinterpret_cast( pSparseMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirements( Image image, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements && "Function requires " ); -# endif - - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - d.vkGetImageSparseMemoryRequirements( m_device, static_cast( image ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetImageSparseMemoryRequirements( m_device, - static_cast( image ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } - - // wrapper function for command vkGetImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirements( Image image, - SparseImageMemoryRequirementsAllocator const & sparseImageMemoryRequirementsAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements && "Function requires " ); -# endif - - std::vector sparseMemoryRequirements( sparseImageMemoryRequirementsAllocator ); - uint32_t sparseMemoryRequirementCount; - d.vkGetImageSparseMemoryRequirements( m_device, static_cast( image ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetImageSparseMemoryRequirements( m_device, - static_cast( image ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties( Format format, - ImageType type, - SampleCountFlagBits samples, - ImageUsageFlags usage, - ImageTiling tiling, - uint32_t * pPropertyCount, - SparseImageFormatProperties * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceSparseImageFormatProperties( static_cast( m_physicalDevice ), - static_cast( format ), - static_cast( type ), - static_cast( samples ), - static_cast( usage ), - static_cast( tiling ), - pPropertyCount, - reinterpret_cast( pProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getSparseImageFormatProperties( - Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties && - "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, - static_cast( format ), - static_cast( type ), - static_cast( samples ), - static_cast( usage ), - static_cast( tiling ), - &propertyCount, - nullptr ); - properties.resize( propertyCount ); - d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, - static_cast( format ), - static_cast( type ), - static_cast( samples ), - static_cast( usage ), - static_cast( tiling ), - &propertyCount, - reinterpret_cast( properties.data() ) ); - - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return properties; - } - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getSparseImageFormatProperties( Format format, - ImageType type, - SampleCountFlagBits samples, - ImageUsageFlags usage, - ImageTiling tiling, - SparseImageFormatPropertiesAllocator const & sparseImageFormatPropertiesAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties && - "Function requires " ); -# endif - - std::vector properties( sparseImageFormatPropertiesAllocator ); - uint32_t propertyCount; - d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, - static_cast( format ), - static_cast( type ), - static_cast( samples ), - static_cast( usage ), - static_cast( tiling ), - &propertyCount, - nullptr ); - properties.resize( propertyCount ); - d.vkGetPhysicalDeviceSparseImageFormatProperties( m_physicalDevice, - static_cast( format ), - static_cast( type ), - static_cast( samples ), - static_cast( usage ), - static_cast( tiling ), - &propertyCount, - reinterpret_cast( properties.data() ) ); - - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return properties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Queue::bindSparse( uint32_t bindInfoCount, const BindSparseInfo * pBindInfo, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkQueueBindSparse( - static_cast( m_queue ), bindInfoCount, reinterpret_cast( pBindInfo ), static_cast( fence ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Queue::bindSparse( ArrayProxy const & bindInfo, Fence fence, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkQueueBindSparse && "Function requires " ); -# endif - - Result result = static_cast( - d.vkQueueBindSparse( m_queue, bindInfo.size(), reinterpret_cast( bindInfo.data() ), static_cast( fence ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::bindSparse" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createFence( const FenceCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Fence * pFence, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateFence( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pFence ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createFence( const FenceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateFence && "Function requires " ); -# endif - - Fence fence; - Result result = static_cast( d.vkCreateFence( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &fence ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFence" ); - - return detail::createResultValueType( result, std::move( fence ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createFenceUnique( const FenceCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateFence && "Function requires " ); -# endif - - Fence fence; - Result result = static_cast( d.vkCreateFence( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &fence ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFenceUnique" ); - - return detail::createResultValueType( result, UniqueHandle( fence, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyFence( static_cast( m_device ), static_cast( fence ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyFence( Fence fence, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyFence && "Function requires " ); -# endif - - d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Fence fence, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyFence( static_cast( m_device ), static_cast( fence ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Fence fence, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyFence && "Function requires " ); -# endif - - d.vkDestroyFence( m_device, static_cast( fence ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetFences( uint32_t fenceCount, const Fence * pFences, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkResetFences( static_cast( m_device ), fenceCount, reinterpret_cast( pFences ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::resetFences( ArrayProxy const & fences, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkResetFences && "Function requires " ); -# endif - - Result result = static_cast( d.vkResetFences( m_device, fences.size(), reinterpret_cast( fences.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetFences" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetFenceStatus( static_cast( m_device ), static_cast( fence ) ) ); - } -#else - // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceStatus( Fence fence, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetFenceStatus && "Function requires " ); -# endif - - Result result = static_cast( d.vkGetFenceStatus( m_device, static_cast( fence ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceStatus", { Result::eSuccess, Result::eNotReady } ); - - return static_cast( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::waitForFences( uint32_t fenceCount, const Fence * pFences, Bool32 waitAll, uint64_t timeout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkWaitForFences( - static_cast( m_device ), fenceCount, reinterpret_cast( pFences ), static_cast( waitAll ), timeout ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::waitForFences( ArrayProxy const & fences, Bool32 waitAll, uint64_t timeout, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkWaitForFences && "Function requires " ); -# endif - - Result result = static_cast( - d.vkWaitForFences( m_device, fences.size(), reinterpret_cast( fences.data() ), static_cast( waitAll ), timeout ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForFences", { Result::eSuccess, Result::eTimeout } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSemaphore( const SemaphoreCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Semaphore * pSemaphore, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateSemaphore( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSemaphore ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createSemaphore( const SemaphoreCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSemaphore && "Function requires " ); -# endif - - Semaphore semaphore; - Result result = static_cast( d.vkCreateSemaphore( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &semaphore ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphore" ); - - return detail::createResultValueType( result, std::move( semaphore ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSemaphore && "Function requires " ); -# endif - - Semaphore semaphore; - Result result = static_cast( d.vkCreateSemaphore( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &semaphore ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSemaphoreUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( semaphore, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html - template ::type> - VULKAN_HPP_INLINE void Device::destroySemaphore( Semaphore semaphore, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroySemaphore( - static_cast( m_device ), static_cast( semaphore ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroySemaphore( Semaphore semaphore, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroySemaphore && "Function requires " ); -# endif - - d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroySemaphore( - static_cast( m_device ), static_cast( semaphore ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Semaphore semaphore, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroySemaphore && "Function requires " ); -# endif - - d.vkDestroySemaphore( m_device, static_cast( semaphore ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createQueryPool( const QueryPoolCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - QueryPool * pQueryPool, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateQueryPool( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pQueryPool ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createQueryPool( const QueryPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateQueryPool && "Function requires " ); -# endif - - QueryPool queryPool; - Result result = static_cast( d.vkCreateQueryPool( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &queryPool ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPool" ); - - return detail::createResultValueType( result, std::move( queryPool ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateQueryPool && "Function requires " ); -# endif - - QueryPool queryPool; - Result result = static_cast( d.vkCreateQueryPool( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &queryPool ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createQueryPoolUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( queryPool, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyQueryPool( QueryPool queryPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyQueryPool( - static_cast( m_device ), static_cast( queryPool ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyQueryPool( QueryPool queryPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyQueryPool && "Function requires " ); -# endif - - d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyQueryPool( - static_cast( m_device ), static_cast( queryPool ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( QueryPool queryPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyQueryPool && "Function requires " ); -# endif - - d.vkDestroyQueryPool( m_device, static_cast( queryPool ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getQueryPoolResults( QueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - size_t dataSize, - void * pData, - DeviceSize stride, - QueryResultFlags flags, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetQueryPoolResults( static_cast( m_device ), - static_cast( queryPool ), - firstQuery, - queryCount, - dataSize, - pData, - static_cast( stride ), - static_cast( flags ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::getQueryPoolResults( - QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, DeviceSize stride, QueryResultFlags flags, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetQueryPoolResults && "Function requires " ); -# endif - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( d.vkGetQueryPoolResults( m_device, - static_cast( queryPool ), - firstQuery, - queryCount, - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ), - static_cast( stride ), - static_cast( flags ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResults", { Result::eSuccess, Result::eNotReady } ); - - return ResultValue>( result, std::move( data ) ); - } - - // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::getQueryPoolResult( - QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, DeviceSize stride, QueryResultFlags flags, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetQueryPoolResults && "Function requires " ); -# endif - - DataType data; - Result result = static_cast( d.vkGetQueryPoolResults( m_device, - static_cast( queryPool ), - firstQuery, - queryCount, - sizeof( DataType ), - reinterpret_cast( &data ), - static_cast( stride ), - static_cast( flags ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getQueryPoolResult", { Result::eSuccess, Result::eNotReady } ); - - return ResultValue( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBuffer( const BufferCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Buffer * pBuffer, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateBuffer( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pBuffer ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createBuffer( const BufferCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateBuffer && "Function requires " ); -# endif - - Buffer buffer; - Result result = static_cast( d.vkCreateBuffer( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &buffer ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBuffer" ); - - return detail::createResultValueType( result, std::move( buffer ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createBufferUnique( const BufferCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateBuffer && "Function requires " ); -# endif - - Buffer buffer; - Result result = static_cast( d.vkCreateBuffer( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &buffer ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferUnique" ); - - return detail::createResultValueType( result, UniqueHandle( buffer, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyBuffer( static_cast( m_device ), static_cast( buffer ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyBuffer( Buffer buffer, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyBuffer && "Function requires " ); -# endif - - d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyBuffer( static_cast( m_device ), static_cast( buffer ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Buffer buffer, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyBuffer && "Function requires " ); -# endif - - d.vkDestroyBuffer( m_device, static_cast( buffer ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createImage( const ImageCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Image * pImage, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateImage( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pImage ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createImage( const ImageCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateImage && "Function requires " ); -# endif - - Image image; - Result result = static_cast( d.vkCreateImage( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &image ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImage" ); - - return detail::createResultValueType( result, std::move( image ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createImageUnique( const ImageCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateImage && "Function requires " ); -# endif - - Image image; - Result result = static_cast( d.vkCreateImage( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &image ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageUnique" ); - - return detail::createResultValueType( result, UniqueHandle( image, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyImage( Image image, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyImage( static_cast( m_device ), static_cast( image ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyImage( Image image, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyImage && "Function requires " ); -# endif - - d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Image image, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyImage( static_cast( m_device ), static_cast( image ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Image image, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyImage && "Function requires " ); -# endif - - d.vkDestroyImage( m_device, static_cast( image ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageSubresourceLayout( Image image, - const ImageSubresource * pSubresource, - SubresourceLayout * pLayout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetImageSubresourceLayout( static_cast( m_device ), - static_cast( image ), - reinterpret_cast( pSubresource ), - reinterpret_cast( pLayout ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout Device::getImageSubresourceLayout( Image image, - const ImageSubresource & subresource, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageSubresourceLayout && "Function requires " ); -# endif - - SubresourceLayout layout; - d.vkGetImageSubresourceLayout( m_device, - static_cast( image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return layout; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createImageView( const ImageViewCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - ImageView * pView, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateImageView( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pView ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createImageView( const ImageViewCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateImageView && "Function requires " ); -# endif - - ImageView view; - Result result = static_cast( d.vkCreateImageView( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &view ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageView" ); - - return detail::createResultValueType( result, std::move( view ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createImageViewUnique( const ImageViewCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateImageView && "Function requires " ); -# endif - - ImageView view; - Result result = static_cast( d.vkCreateImageView( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &view ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createImageViewUnique" ); - - return detail::createResultValueType( result, UniqueHandle( view, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyImageView( ImageView imageView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyImageView( - static_cast( m_device ), static_cast( imageView ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyImageView( ImageView imageView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyImageView && "Function requires " ); -# endif - - d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyImageView( - static_cast( m_device ), static_cast( imageView ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( ImageView imageView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyImageView && "Function requires " ); -# endif - - d.vkDestroyImageView( m_device, static_cast( imageView ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCommandPool( const CommandPoolCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - CommandPool * pCommandPool, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateCommandPool( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pCommandPool ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createCommandPool( const CommandPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateCommandPool && "Function requires " ); -# endif - - CommandPool commandPool; - Result result = static_cast( d.vkCreateCommandPool( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &commandPool ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPool" ); - - return detail::createResultValueType( result, std::move( commandPool ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateCommandPool && "Function requires " ); -# endif - - CommandPool commandPool; - Result result = static_cast( d.vkCreateCommandPool( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &commandPool ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCommandPoolUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( commandPool, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyCommandPool( CommandPool commandPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyCommandPool( - static_cast( m_device ), static_cast( commandPool ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyCommandPool( CommandPool commandPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyCommandPool && "Function requires " ); -# endif - - d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyCommandPool( - static_cast( m_device ), static_cast( commandPool ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( CommandPool commandPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyCommandPool && "Function requires " ); -# endif - - d.vkDestroyCommandPool( m_device, static_cast( commandPool ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetCommandPool( CommandPool commandPool, - CommandPoolResetFlags flags, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkResetCommandPool( static_cast( m_device ), static_cast( commandPool ), static_cast( flags ) ) ); - } -#else - // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::resetCommandPool( CommandPool commandPool, CommandPoolResetFlags flags, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkResetCommandPool && "Function requires " ); -# endif - - Result result = - static_cast( d.vkResetCommandPool( m_device, static_cast( commandPool ), static_cast( flags ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetCommandPool" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateCommandBuffers( const CommandBufferAllocateInfo * pAllocateInfo, - CommandBuffer * pCommandBuffers, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkAllocateCommandBuffers( static_cast( m_device ), - reinterpret_cast( pAllocateInfo ), - reinterpret_cast( pCommandBuffers ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function requires " ); -# endif - - std::vector commandBuffers( allocateInfo.commandBufferCount ); - Result result = static_cast( d.vkAllocateCommandBuffers( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); - - return detail::createResultValueType( result, std::move( commandBuffers ) ); - } - - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateCommandBuffers( - const CommandBufferAllocateInfo & allocateInfo, CommandBufferAllocator const & commandBufferAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function requires " ); -# endif - - std::vector commandBuffers( allocateInfo.commandBufferCount, {}, commandBufferAllocator ); - Result result = static_cast( d.vkAllocateCommandBuffers( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); - - return detail::createResultValueType( result, std::move( commandBuffers ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, CommandBufferAllocator>>::type - Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function requires " ); -# endif - - std::vector commandBuffers( allocateInfo.commandBufferCount ); - Result result = static_cast( d.vkAllocateCommandBuffers( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); - std::vector, CommandBufferAllocator> uniqueCommandBuffers; - uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); - detail::PoolFree deleter( *this, allocateInfo.commandPool, d ); - for ( auto const & commandBuffer : commandBuffers ) - { - uniqueCommandBuffers.push_back( UniqueHandle( commandBuffer, deleter ) ); - } - return detail::createResultValueType( result, std::move( uniqueCommandBuffers ) ); - } - - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, CommandBufferAllocator>>::type - Device::allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, - CommandBufferAllocator const & commandBufferAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAllocateCommandBuffers && "Function requires " ); -# endif - - std::vector commandBuffers( allocateInfo.commandBufferCount ); - Result result = static_cast( d.vkAllocateCommandBuffers( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( commandBuffers.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateCommandBuffersUnique" ); - std::vector, CommandBufferAllocator> uniqueCommandBuffers( commandBufferAllocator ); - uniqueCommandBuffers.reserve( allocateInfo.commandBufferCount ); - detail::PoolFree deleter( *this, allocateInfo.commandPool, d ); - for ( auto const & commandBuffer : commandBuffers ) - { - uniqueCommandBuffers.push_back( UniqueHandle( commandBuffer, deleter ) ); - } - return detail::createResultValueType( result, std::move( uniqueCommandBuffers ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html - template ::type> - VULKAN_HPP_INLINE void Device::freeCommandBuffers( CommandPool commandPool, - uint32_t commandBufferCount, - const CommandBuffer * pCommandBuffers, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkFreeCommandBuffers( static_cast( m_device ), - static_cast( commandPool ), - commandBufferCount, - reinterpret_cast( pCommandBuffers ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html - template ::type> - VULKAN_HPP_INLINE void - Device::freeCommandBuffers( CommandPool commandPool, ArrayProxy const & commandBuffers, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkFreeCommandBuffers && "Function requires " ); -# endif - - d.vkFreeCommandBuffers( - m_device, static_cast( commandPool ), commandBuffers.size(), reinterpret_cast( commandBuffers.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html - template ::type> - VULKAN_HPP_INLINE void( Device::free )( CommandPool commandPool, - uint32_t commandBufferCount, - const CommandBuffer * pCommandBuffers, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkFreeCommandBuffers( static_cast( m_device ), - static_cast( commandPool ), - commandBufferCount, - reinterpret_cast( pCommandBuffers ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html - template ::type> - VULKAN_HPP_INLINE void( Device::free )( CommandPool commandPool, - ArrayProxy const & commandBuffers, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkFreeCommandBuffers && "Function requires " ); -# endif - - d.vkFreeCommandBuffers( - m_device, static_cast( commandPool ), commandBuffers.size(), reinterpret_cast( commandBuffers.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::begin( const CommandBufferBeginInfo * pBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkBeginCommandBuffer( static_cast( m_commandBuffer ), reinterpret_cast( pBeginInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBeginCommandBuffer && "Function requires " ); -# endif - - Result result = static_cast( d.vkBeginCommandBuffer( m_commandBuffer, reinterpret_cast( &beginInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::begin" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::end( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkEndCommandBuffer( static_cast( m_commandBuffer ) ) ); - } -#else - // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::end( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEndCommandBuffer && "Function requires " ); -# endif - - Result result = static_cast( d.vkEndCommandBuffer( m_commandBuffer ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::end" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::reset( CommandBufferResetFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkResetCommandBuffer( static_cast( m_commandBuffer ), static_cast( flags ) ) ); - } -#else - // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::reset( CommandBufferResetFlags flags, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkResetCommandBuffer && "Function requires " ); -# endif - - Result result = static_cast( d.vkResetCommandBuffer( m_commandBuffer, static_cast( flags ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::reset" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( - Buffer srcBuffer, Buffer dstBuffer, uint32_t regionCount, const BufferCopy * pRegions, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyBuffer( static_cast( m_commandBuffer ), - static_cast( srcBuffer ), - static_cast( dstBuffer ), - regionCount, - reinterpret_cast( pRegions ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::copyBuffer( Buffer srcBuffer, Buffer dstBuffer, ArrayProxy const & regions, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer && "Function requires " ); -# endif - - d.vkCmdCopyBuffer( m_commandBuffer, - static_cast( srcBuffer ), - static_cast( dstBuffer ), - regions.size(), - reinterpret_cast( regions.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - uint32_t regionCount, - const ImageCopy * pRegions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyImage( static_cast( m_commandBuffer ), - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regionCount, - reinterpret_cast( pRegions ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyImage && "Function requires " ); -# endif - - d.vkCmdCopyImage( m_commandBuffer, - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regions.size(), - reinterpret_cast( regions.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, - Image dstImage, - ImageLayout dstImageLayout, - uint32_t regionCount, - const BufferImageCopy * pRegions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyBufferToImage( static_cast( m_commandBuffer ), - static_cast( srcBuffer ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regionCount, - reinterpret_cast( pRegions ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( Buffer srcBuffer, - Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage && "Function requires " ); -# endif - - d.vkCmdCopyBufferToImage( m_commandBuffer, - static_cast( srcBuffer ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regions.size(), - reinterpret_cast( regions.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, - ImageLayout srcImageLayout, - Buffer dstBuffer, - uint32_t regionCount, - const BufferImageCopy * pRegions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyImageToBuffer( static_cast( m_commandBuffer ), - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstBuffer ), - regionCount, - reinterpret_cast( pRegions ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( Image srcImage, - ImageLayout srcImageLayout, - Buffer dstBuffer, - ArrayProxy const & regions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer && "Function requires " ); -# endif - - d.vkCmdCopyImageToBuffer( m_commandBuffer, - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstBuffer ), - regions.size(), - reinterpret_cast( regions.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize dataSize, const void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdUpdateBuffer( static_cast( m_commandBuffer ), - static_cast( dstBuffer ), - static_cast( dstOffset ), - static_cast( dataSize ), - pData ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::updateBuffer( Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy const & data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdUpdateBuffer && "Function requires " ); -# endif - - d.vkCmdUpdateBuffer( m_commandBuffer, - static_cast( dstBuffer ), - static_cast( dstOffset ), - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdFillBuffer( static_cast( m_commandBuffer ), - static_cast( dstBuffer ), - static_cast( dstOffset ), - static_cast( size ), - data ); - } - - // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - DependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, - const MemoryBarrier * pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const BufferMemoryBarrier * pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const ImageMemoryBarrier * pImageMemoryBarriers, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPipelineBarrier( static_cast( m_commandBuffer ), - static_cast( srcStageMask ), - static_cast( dstStageMask ), - static_cast( dependencyFlags ), - memoryBarrierCount, - reinterpret_cast( pMemoryBarriers ), - bufferMemoryBarrierCount, - reinterpret_cast( pBufferMemoryBarriers ), - imageMemoryBarrierCount, - reinterpret_cast( pImageMemoryBarriers ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - DependencyFlags dependencyFlags, - ArrayProxy const & memoryBarriers, - ArrayProxy const & bufferMemoryBarriers, - ArrayProxy const & imageMemoryBarriers, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier && "Function requires " ); -# endif - - d.vkCmdPipelineBarrier( m_commandBuffer, - static_cast( srcStageMask ), - static_cast( dstStageMask ), - static_cast( dependencyFlags ), - memoryBarriers.size(), - reinterpret_cast( memoryBarriers.data() ), - bufferMemoryBarriers.size(), - reinterpret_cast( bufferMemoryBarriers.data() ), - imageMemoryBarriers.size(), - reinterpret_cast( imageMemoryBarriers.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginQuery( QueryPool queryPool, uint32_t query, QueryControlFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginQuery( - static_cast( m_commandBuffer ), static_cast( queryPool ), query, static_cast( flags ) ); - } - - // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endQuery( QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndQuery( static_cast( m_commandBuffer ), static_cast( queryPool ), query ); - } - - // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdResetQueryPool( static_cast( m_commandBuffer ), static_cast( queryPool ), firstQuery, queryCount ); - } - - // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdWriteTimestamp( - static_cast( m_commandBuffer ), static_cast( pipelineStage ), static_cast( queryPool ), query ); - } - - // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( QueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - Buffer dstBuffer, - DeviceSize dstOffset, - DeviceSize stride, - QueryResultFlags flags, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyQueryPoolResults( static_cast( m_commandBuffer ), - static_cast( queryPool ), - firstQuery, - queryCount, - static_cast( dstBuffer ), - static_cast( dstOffset ), - static_cast( stride ), - static_cast( flags ) ); - } - - // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::executeCommands( uint32_t commandBufferCount, const CommandBuffer * pCommandBuffers, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdExecuteCommands( static_cast( m_commandBuffer ), commandBufferCount, reinterpret_cast( pCommandBuffers ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::executeCommands( ArrayProxy const & commandBuffers, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdExecuteCommands && "Function requires " ); -# endif - - d.vkCmdExecuteCommands( m_commandBuffer, commandBuffers.size(), reinterpret_cast( commandBuffers.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createEvent( const EventCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Event * pEvent, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateEvent( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pEvent ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createEvent( const EventCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateEvent && "Function requires " ); -# endif - - Event event; - Result result = static_cast( d.vkCreateEvent( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &event ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createEvent" ); - - return detail::createResultValueType( result, std::move( event ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createEventUnique( const EventCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateEvent && "Function requires " ); -# endif - - Event event; - Result result = static_cast( d.vkCreateEvent( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &event ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createEventUnique" ); - - return detail::createResultValueType( result, UniqueHandle( event, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyEvent( Event event, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyEvent( static_cast( m_device ), static_cast( event ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyEvent( Event event, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyEvent && "Function requires " ); -# endif - - d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Event event, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyEvent( static_cast( m_device ), static_cast( event ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Event event, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyEvent && "Function requires " ); -# endif - - d.vkDestroyEvent( m_device, static_cast( event ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetEventStatus( static_cast( m_device ), static_cast( event ) ) ); - } -#else - // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getEventStatus( Event event, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetEventStatus && "Function requires " ); -# endif - - Result result = static_cast( d.vkGetEventStatus( m_device, static_cast( event ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEventStatus", { Result::eEventSet, Result::eEventReset } ); - - return static_cast( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setEvent( Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkSetEvent( static_cast( m_device ), static_cast( event ) ) ); - } -#else - // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::setEvent( Event event, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSetEvent && "Function requires " ); -# endif - - Result result = static_cast( d.vkSetEvent( m_device, static_cast( event ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setEvent" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetEvent( Event event, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkResetEvent( static_cast( m_device ), static_cast( event ) ) ); - } -#else - // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::resetEvent( Event event, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkResetEvent && "Function requires " ); -# endif - - Result result = static_cast( d.vkResetEvent( m_device, static_cast( event ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetEvent" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBufferView( const BufferViewCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - BufferView * pView, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateBufferView( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pView ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createBufferView( const BufferViewCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateBufferView && "Function requires " ); -# endif - - BufferView view; - Result result = static_cast( d.vkCreateBufferView( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &view ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferView" ); - - return detail::createResultValueType( result, std::move( view ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createBufferViewUnique( const BufferViewCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateBufferView && "Function requires " ); -# endif - - BufferView view; - Result result = static_cast( d.vkCreateBufferView( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &view ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferViewUnique" ); - - return detail::createResultValueType( result, UniqueHandle( view, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyBufferView( BufferView bufferView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyBufferView( - static_cast( m_device ), static_cast( bufferView ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyBufferView( BufferView bufferView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyBufferView && "Function requires " ); -# endif - - d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyBufferView( - static_cast( m_device ), static_cast( bufferView ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( BufferView bufferView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyBufferView && "Function requires " ); -# endif - - d.vkDestroyBufferView( m_device, static_cast( bufferView ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createShaderModule( const ShaderModuleCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - ShaderModule * pShaderModule, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateShaderModule( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pShaderModule ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createShaderModule( const ShaderModuleCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateShaderModule && "Function requires " ); -# endif - - ShaderModule shaderModule; - Result result = static_cast( d.vkCreateShaderModule( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &shaderModule ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModule" ); - - return detail::createResultValueType( result, std::move( shaderModule ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateShaderModule && "Function requires " ); -# endif - - ShaderModule shaderModule; - Result result = static_cast( d.vkCreateShaderModule( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &shaderModule ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderModuleUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( shaderModule, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyShaderModule( ShaderModule shaderModule, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyShaderModule( - static_cast( m_device ), static_cast( shaderModule ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyShaderModule( ShaderModule shaderModule, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyShaderModule && "Function requires " ); -# endif - - d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( ShaderModule shaderModule, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyShaderModule( - static_cast( m_device ), static_cast( shaderModule ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( ShaderModule shaderModule, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyShaderModule && "Function requires " ); -# endif - - d.vkDestroyShaderModule( m_device, static_cast( shaderModule ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineCache( const PipelineCacheCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - PipelineCache * pPipelineCache, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreatePipelineCache( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pPipelineCache ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createPipelineCache( const PipelineCacheCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePipelineCache && "Function requires " ); -# endif - - PipelineCache pipelineCache; - Result result = static_cast( d.vkCreatePipelineCache( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipelineCache ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCache" ); - - return detail::createResultValueType( result, std::move( pipelineCache ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePipelineCache && "Function requires " ); -# endif - - PipelineCache pipelineCache; - Result result = static_cast( d.vkCreatePipelineCache( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipelineCache ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineCacheUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( pipelineCache, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyPipelineCache( PipelineCache pipelineCache, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyPipelineCache( - static_cast( m_device ), static_cast( pipelineCache ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyPipelineCache( PipelineCache pipelineCache, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyPipelineCache && "Function requires " ); -# endif - - d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( PipelineCache pipelineCache, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyPipelineCache( - static_cast( m_device ), static_cast( pipelineCache ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( PipelineCache pipelineCache, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyPipelineCache && "Function requires " ); -# endif - - d.vkDestroyPipelineCache( m_device, static_cast( pipelineCache ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::getPipelineCacheData( PipelineCache pipelineCache, size_t * pDataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPipelineCacheData( static_cast( m_device ), static_cast( pipelineCache ), pDataSize, pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getPipelineCacheData( PipelineCache pipelineCache, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineCacheData && "Function requires " ); -# endif - - std::vector data; - size_t dataSize; - Result result; - do - { - result = static_cast( d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( - d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" ); - VULKAN_HPP_ASSERT( dataSize <= data.size() ); - if ( dataSize < data.size() ) - { - data.resize( dataSize ); - } - return detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getPipelineCacheData( PipelineCache pipelineCache, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineCacheData && "Function requires " ); -# endif - - std::vector data( uint8_tAllocator ); - size_t dataSize; - Result result; - do - { - result = static_cast( d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( - d.vkGetPipelineCacheData( m_device, static_cast( pipelineCache ), &dataSize, reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineCacheData" ); - VULKAN_HPP_ASSERT( dataSize <= data.size() ); - if ( dataSize < data.size() ) - { - data.resize( dataSize ); - } - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mergePipelineCaches( PipelineCache dstCache, - uint32_t srcCacheCount, - const PipelineCache * pSrcCaches, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkMergePipelineCaches( - static_cast( m_device ), static_cast( dstCache ), srcCacheCount, reinterpret_cast( pSrcCaches ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::mergePipelineCaches( PipelineCache dstCache, ArrayProxy const & srcCaches, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkMergePipelineCaches && "Function requires " ); -# endif - - Result result = static_cast( d.vkMergePipelineCaches( - m_device, static_cast( dstCache ), srcCaches.size(), reinterpret_cast( srcCaches.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergePipelineCaches" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createComputePipelines( PipelineCache pipelineCache, - uint32_t createInfoCount, - const ComputePipelineCreateInfo * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateComputePipelines( static_cast( m_device ), - static_cast( pipelineCache ), - createInfoCount, - reinterpret_cast( pCreateInfos ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pPipelines ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createComputePipelines( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateComputePipelines( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createComputePipelines( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); - Result result = static_cast( d.vkCreateComputePipelines( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelines", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::createComputePipeline( PipelineCache pipelineCache, - const ComputePipelineCreateInfo & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateComputePipelines( m_device, - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipeline", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue( result, std::move( pipeline ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createComputePipelinesUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateComputePipelines( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines; - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createComputePipelinesUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateComputePipelines( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelinesUnique", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::createComputePipelineUnique( - PipelineCache pipelineCache, const ComputePipelineCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateComputePipelines && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateComputePipelines( m_device, - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::createComputePipelineUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue>( - result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyPipeline( Pipeline pipeline, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyPipeline( - static_cast( m_device ), static_cast( pipeline ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyPipeline( Pipeline pipeline, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyPipeline && "Function requires " ); -# endif - - d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyPipeline( - static_cast( m_device ), static_cast( pipeline ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Pipeline pipeline, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyPipeline && "Function requires " ); -# endif - - d.vkDestroyPipeline( m_device, static_cast( pipeline ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineLayout( const PipelineLayoutCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - PipelineLayout * pPipelineLayout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreatePipelineLayout( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pPipelineLayout ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePipelineLayout && "Function requires " ); -# endif - - PipelineLayout pipelineLayout; - Result result = static_cast( d.vkCreatePipelineLayout( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipelineLayout ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayout" ); - - return detail::createResultValueType( result, std::move( pipelineLayout ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePipelineLayout && "Function requires " ); -# endif - - PipelineLayout pipelineLayout; - Result result = static_cast( d.vkCreatePipelineLayout( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipelineLayout ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineLayoutUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( pipelineLayout, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyPipelineLayout( PipelineLayout pipelineLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyPipelineLayout( - static_cast( m_device ), static_cast( pipelineLayout ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyPipelineLayout( PipelineLayout pipelineLayout, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyPipelineLayout && "Function requires " ); -# endif - - d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( PipelineLayout pipelineLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyPipelineLayout( - static_cast( m_device ), static_cast( pipelineLayout ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( PipelineLayout pipelineLayout, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyPipelineLayout && "Function requires " ); -# endif - - d.vkDestroyPipelineLayout( m_device, static_cast( pipelineLayout ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSampler( const SamplerCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Sampler * pSampler, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateSampler( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSampler ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createSampler( const SamplerCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSampler && "Function requires " ); -# endif - - Sampler sampler; - Result result = static_cast( d.vkCreateSampler( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &sampler ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSampler" ); - - return detail::createResultValueType( result, std::move( sampler ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createSamplerUnique( const SamplerCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSampler && "Function requires " ); -# endif - - Sampler sampler; - Result result = static_cast( d.vkCreateSampler( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &sampler ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerUnique" ); - - return detail::createResultValueType( result, UniqueHandle( sampler, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html - template ::type> - VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroySampler( static_cast( m_device ), static_cast( sampler ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html - template ::type> - VULKAN_HPP_INLINE void Device::destroySampler( Sampler sampler, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroySampler && "Function requires " ); -# endif - - d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroySampler( static_cast( m_device ), static_cast( sampler ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Sampler sampler, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroySampler && "Function requires " ); -# endif - - d.vkDestroySampler( m_device, static_cast( sampler ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - DescriptorSetLayout * pSetLayout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDescriptorSetLayout( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSetLayout ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createDescriptorSetLayout( - const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDescriptorSetLayout && "Function requires " ); -# endif - - DescriptorSetLayout setLayout; - Result result = static_cast( d.vkCreateDescriptorSetLayout( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &setLayout ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayout" ); - - return detail::createResultValueType( result, std::move( setLayout ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::createDescriptorSetLayoutUnique( - const DescriptorSetLayoutCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDescriptorSetLayout && "Function requires " ); -# endif - - DescriptorSetLayout setLayout; - Result result = static_cast( d.vkCreateDescriptorSetLayout( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &setLayout ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorSetLayoutUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( setLayout, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDescriptorSetLayout( static_cast( m_device ), - static_cast( descriptorSetLayout ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDescriptorSetLayout && "Function requires " ); -# endif - - d.vkDestroyDescriptorSetLayout( - m_device, static_cast( descriptorSetLayout ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( DescriptorSetLayout descriptorSetLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDescriptorSetLayout( static_cast( m_device ), - static_cast( descriptorSetLayout ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( DescriptorSetLayout descriptorSetLayout, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDescriptorSetLayout && "Function requires " ); -# endif - - d.vkDestroyDescriptorSetLayout( - m_device, static_cast( descriptorSetLayout ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorPool( const DescriptorPoolCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - DescriptorPool * pDescriptorPool, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDescriptorPool( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pDescriptorPool ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDescriptorPool && "Function requires " ); -# endif - - DescriptorPool descriptorPool; - Result result = static_cast( d.vkCreateDescriptorPool( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &descriptorPool ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPool" ); - - return detail::createResultValueType( result, std::move( descriptorPool ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDescriptorPool && "Function requires " ); -# endif - - DescriptorPool descriptorPool; - Result result = static_cast( d.vkCreateDescriptorPool( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &descriptorPool ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorPoolUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( descriptorPool, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyDescriptorPool( DescriptorPool descriptorPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDescriptorPool( - static_cast( m_device ), static_cast( descriptorPool ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyDescriptorPool( DescriptorPool descriptorPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDescriptorPool && "Function requires " ); -# endif - - d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( DescriptorPool descriptorPool, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDescriptorPool( - static_cast( m_device ), static_cast( descriptorPool ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( DescriptorPool descriptorPool, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDescriptorPool && "Function requires " ); -# endif - - d.vkDestroyDescriptorPool( m_device, static_cast( descriptorPool ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::resetDescriptorPool( DescriptorPool descriptorPool, - DescriptorPoolResetFlags flags, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkResetDescriptorPool( - static_cast( m_device ), static_cast( descriptorPool ), static_cast( flags ) ) ); - } -#else - // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::resetDescriptorPool( DescriptorPool descriptorPool, DescriptorPoolResetFlags flags, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkResetDescriptorPool && "Function requires " ); -# endif - - Result result = static_cast( - d.vkResetDescriptorPool( m_device, static_cast( descriptorPool ), static_cast( flags ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::resetDescriptorPool" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::allocateDescriptorSets( const DescriptorSetAllocateInfo * pAllocateInfo, - DescriptorSet * pDescriptorSets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkAllocateDescriptorSets( static_cast( m_device ), - reinterpret_cast( pAllocateInfo ), - reinterpret_cast( pDescriptorSets ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function requires " ); -# endif - - std::vector descriptorSets( allocateInfo.descriptorSetCount ); - Result result = static_cast( d.vkAllocateDescriptorSets( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); - - return detail::createResultValueType( result, std::move( descriptorSets ) ); - } - - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::allocateDescriptorSets( - const DescriptorSetAllocateInfo & allocateInfo, DescriptorSetAllocator const & descriptorSetAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function requires " ); -# endif - - std::vector descriptorSets( allocateInfo.descriptorSetCount, {}, descriptorSetAllocator ); - Result result = static_cast( d.vkAllocateDescriptorSets( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); - - return detail::createResultValueType( result, std::move( descriptorSets ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, DescriptorSetAllocator>>::type - Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function requires " ); -# endif - - std::vector descriptorSets( allocateInfo.descriptorSetCount ); - Result result = static_cast( d.vkAllocateDescriptorSets( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); - std::vector, DescriptorSetAllocator> uniqueDescriptorSets; - uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); - detail::PoolFree deleter( *this, allocateInfo.descriptorPool, d ); - for ( auto const & descriptorSet : descriptorSets ) - { - uniqueDescriptorSets.push_back( UniqueHandle( descriptorSet, deleter ) ); - } - return detail::createResultValueType( result, std::move( uniqueDescriptorSets ) ); - } - - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, DescriptorSetAllocator>>::type - Device::allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, - DescriptorSetAllocator const & descriptorSetAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAllocateDescriptorSets && "Function requires " ); -# endif - - std::vector descriptorSets( allocateInfo.descriptorSetCount ); - Result result = static_cast( d.vkAllocateDescriptorSets( - m_device, reinterpret_cast( &allocateInfo ), reinterpret_cast( descriptorSets.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::allocateDescriptorSetsUnique" ); - std::vector, DescriptorSetAllocator> uniqueDescriptorSets( descriptorSetAllocator ); - uniqueDescriptorSets.reserve( allocateInfo.descriptorSetCount ); - detail::PoolFree deleter( *this, allocateInfo.descriptorPool, d ); - for ( auto const & descriptorSet : descriptorSets ) - { - uniqueDescriptorSets.push_back( UniqueHandle( descriptorSet, deleter ) ); - } - return detail::createResultValueType( result, std::move( uniqueDescriptorSets ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::freeDescriptorSets( DescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const DescriptorSet * pDescriptorSets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkFreeDescriptorSets( static_cast( m_device ), - static_cast( descriptorPool ), - descriptorSetCount, - reinterpret_cast( pDescriptorSets ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::freeDescriptorSets( DescriptorPool descriptorPool, ArrayProxy const & descriptorSets, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function requires " ); -# endif - - Result result = static_cast( d.vkFreeDescriptorSets( - m_device, static_cast( descriptorPool ), descriptorSets.size(), reinterpret_cast( descriptorSets.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::freeDescriptorSets" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result( Device::free )( DescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const DescriptorSet * pDescriptorSets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkFreeDescriptorSets( static_cast( m_device ), - static_cast( descriptorPool ), - descriptorSetCount, - reinterpret_cast( pDescriptorSets ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE - typename ResultValueType::type( Device::free )( DescriptorPool descriptorPool, - ArrayProxy const & descriptorSets, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkFreeDescriptorSets && "Function requires " ); -# endif - - Result result = static_cast( d.vkFreeDescriptorSets( - m_device, static_cast( descriptorPool ), descriptorSets.size(), reinterpret_cast( descriptorSets.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::( Device::free )" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html - template ::type> - VULKAN_HPP_INLINE void Device::updateDescriptorSets( uint32_t descriptorWriteCount, - const WriteDescriptorSet * pDescriptorWrites, - uint32_t descriptorCopyCount, - const CopyDescriptorSet * pDescriptorCopies, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkUpdateDescriptorSets( static_cast( m_device ), - descriptorWriteCount, - reinterpret_cast( pDescriptorWrites ), - descriptorCopyCount, - reinterpret_cast( pDescriptorCopies ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html - template ::type> - VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy const & descriptorWrites, - ArrayProxy const & descriptorCopies, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSets && "Function requires " ); -# endif - - d.vkUpdateDescriptorSets( m_device, - descriptorWrites.size(), - reinterpret_cast( descriptorWrites.data() ), - descriptorCopies.size(), - reinterpret_cast( descriptorCopies.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindPipeline( - static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( pipeline ) ); - } - - // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t firstSet, - uint32_t descriptorSetCount, - const DescriptorSet * pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t * pDynamicOffsets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindDescriptorSets( static_cast( m_commandBuffer ), - static_cast( pipelineBindPoint ), - static_cast( layout ), - firstSet, - descriptorSetCount, - reinterpret_cast( pDescriptorSets ), - dynamicOffsetCount, - pDynamicOffsets ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t firstSet, - ArrayProxy const & descriptorSets, - ArrayProxy const & dynamicOffsets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets && "Function requires " ); -# endif - - d.vkCmdBindDescriptorSets( m_commandBuffer, - static_cast( pipelineBindPoint ), - static_cast( layout ), - firstSet, - descriptorSets.size(), - reinterpret_cast( descriptorSets.data() ), - dynamicOffsets.size(), - dynamicOffsets.data() ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, - ImageLayout imageLayout, - const ClearColorValue * pColor, - uint32_t rangeCount, - const ImageSubresourceRange * pRanges, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdClearColorImage( static_cast( m_commandBuffer ), - static_cast( image ), - static_cast( imageLayout ), - reinterpret_cast( pColor ), - rangeCount, - reinterpret_cast( pRanges ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( Image image, - ImageLayout imageLayout, - const ClearColorValue & color, - ArrayProxy const & ranges, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdClearColorImage && "Function requires " ); -# endif - - d.vkCmdClearColorImage( m_commandBuffer, - static_cast( image ), - static_cast( imageLayout ), - reinterpret_cast( &color ), - ranges.size(), - reinterpret_cast( ranges.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDispatch( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); - } - - // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDispatchIndirect( static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ) ); - } - - // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetEvent( static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); - } - - // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdResetEvent( static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); - } - - // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::waitEvents( uint32_t eventCount, - const Event * pEvents, - PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const MemoryBarrier * pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const BufferMemoryBarrier * pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const ImageMemoryBarrier * pImageMemoryBarriers, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdWaitEvents( static_cast( m_commandBuffer ), - eventCount, - reinterpret_cast( pEvents ), - static_cast( srcStageMask ), - static_cast( dstStageMask ), - memoryBarrierCount, - reinterpret_cast( pMemoryBarriers ), - bufferMemoryBarrierCount, - reinterpret_cast( pBufferMemoryBarriers ), - imageMemoryBarrierCount, - reinterpret_cast( pImageMemoryBarriers ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy const & events, - PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - ArrayProxy const & memoryBarriers, - ArrayProxy const & bufferMemoryBarriers, - ArrayProxy const & imageMemoryBarriers, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdWaitEvents && "Function requires " ); -# endif - - d.vkCmdWaitEvents( m_commandBuffer, - events.size(), - reinterpret_cast( events.data() ), - static_cast( srcStageMask ), - static_cast( dstStageMask ), - memoryBarriers.size(), - reinterpret_cast( memoryBarriers.data() ), - bufferMemoryBarriers.size(), - reinterpret_cast( bufferMemoryBarriers.data() ), - imageMemoryBarriers.size(), - reinterpret_cast( imageMemoryBarriers.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushConstants( - PipelineLayout layout, ShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void * pValues, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushConstants( static_cast( m_commandBuffer ), - static_cast( layout ), - static_cast( stageFlags ), - offset, - size, - pValues ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushConstants( PipelineLayout layout, - ShaderStageFlags stageFlags, - uint32_t offset, - ArrayProxy const & values, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPushConstants && "Function requires " ); -# endif - - d.vkCmdPushConstants( m_commandBuffer, - static_cast( layout ), - static_cast( stageFlags ), - offset, - values.size() * sizeof( ValuesType ), - reinterpret_cast( values.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createGraphicsPipelines( PipelineCache pipelineCache, - uint32_t createInfoCount, - const GraphicsPipelineCreateInfo * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateGraphicsPipelines( static_cast( m_device ), - static_cast( pipelineCache ), - createInfoCount, - reinterpret_cast( pCreateInfos ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pPipelines ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createGraphicsPipelines( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createGraphicsPipelines( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); - Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelines", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::createGraphicsPipeline( PipelineCache pipelineCache, - const GraphicsPipelineCreateInfo & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipeline", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue( result, std::move( pipeline ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines; - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createGraphicsPipelinesUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelinesUnique", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::createGraphicsPipelineUnique( - PipelineCache pipelineCache, const GraphicsPipelineCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateGraphicsPipelines && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateGraphicsPipelines( m_device, - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::createGraphicsPipelineUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue>( - result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createFramebuffer( const FramebufferCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Framebuffer * pFramebuffer, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateFramebuffer( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pFramebuffer ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createFramebuffer( const FramebufferCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateFramebuffer && "Function requires " ); -# endif - - Framebuffer framebuffer; - Result result = static_cast( d.vkCreateFramebuffer( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &framebuffer ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebuffer" ); - - return detail::createResultValueType( result, std::move( framebuffer ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createFramebufferUnique( const FramebufferCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateFramebuffer && "Function requires " ); -# endif - - Framebuffer framebuffer; - Result result = static_cast( d.vkCreateFramebuffer( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &framebuffer ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createFramebufferUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( framebuffer, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyFramebuffer( Framebuffer framebuffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyFramebuffer( - static_cast( m_device ), static_cast( framebuffer ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyFramebuffer( Framebuffer framebuffer, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyFramebuffer && "Function requires " ); -# endif - - d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyFramebuffer( - static_cast( m_device ), static_cast( framebuffer ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( Framebuffer framebuffer, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyFramebuffer && "Function requires " ); -# endif - - d.vkDestroyFramebuffer( m_device, static_cast( framebuffer ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass( const RenderPassCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - RenderPass * pRenderPass, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateRenderPass( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pRenderPass ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createRenderPass( const RenderPassCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRenderPass && "Function requires " ); -# endif - - RenderPass renderPass; - Result result = static_cast( d.vkCreateRenderPass( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &renderPass ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass" ); - - return detail::createResultValueType( result, std::move( renderPass ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createRenderPassUnique( const RenderPassCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRenderPass && "Function requires " ); -# endif - - RenderPass renderPass; - Result result = static_cast( d.vkCreateRenderPass( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &renderPass ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPassUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( renderPass, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyRenderPass( RenderPass renderPass, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyRenderPass( - static_cast( m_device ), static_cast( renderPass ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyRenderPass( RenderPass renderPass, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyRenderPass && "Function requires " ); -# endif - - d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyRenderPass( - static_cast( m_device ), static_cast( renderPass ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( RenderPass renderPass, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyRenderPass && "Function requires " ); -# endif - - d.vkDestroyRenderPass( m_device, static_cast( renderPass ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html - template ::type> - VULKAN_HPP_INLINE void Device::getRenderAreaGranularity( RenderPass renderPass, Extent2D * pGranularity, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetRenderAreaGranularity( static_cast( m_device ), static_cast( renderPass ), reinterpret_cast( pGranularity ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D Device::getRenderAreaGranularity( RenderPass renderPass, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRenderAreaGranularity && "Function requires " ); -# endif - - Extent2D granularity; - d.vkGetRenderAreaGranularity( m_device, static_cast( renderPass ), reinterpret_cast( &granularity ) ); - - return granularity; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::setViewport( uint32_t firstViewport, uint32_t viewportCount, const Viewport * pViewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetViewport( static_cast( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast( pViewports ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy const & viewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetViewport && "Function requires " ); -# endif - - d.vkCmdSetViewport( m_commandBuffer, firstViewport, viewports.size(), reinterpret_cast( viewports.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::setScissor( uint32_t firstScissor, uint32_t scissorCount, const Rect2D * pScissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetScissor( static_cast( m_commandBuffer ), firstScissor, scissorCount, reinterpret_cast( pScissors ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy const & scissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetScissor && "Function requires " ); -# endif - - d.vkCmdSetScissor( m_commandBuffer, firstScissor, scissors.size(), reinterpret_cast( scissors.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetLineWidth( static_cast( m_commandBuffer ), lineWidth ); - } - - // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthBias( static_cast( m_commandBuffer ), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); - } - - // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4], Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetBlendConstants( static_cast( m_commandBuffer ), blendConstants ); - } - - // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthBounds( static_cast( m_commandBuffer ), minDepthBounds, maxDepthBounds ); - } - - // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetStencilCompareMask( static_cast( m_commandBuffer ), static_cast( faceMask ), compareMask ); - } - - // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetStencilWriteMask( static_cast( m_commandBuffer ), static_cast( faceMask ), writeMask ); - } - - // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetStencilReference( static_cast( m_commandBuffer ), static_cast( faceMask ), reference ); - } - - // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer( Buffer buffer, DeviceSize offset, IndexType indexType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindIndexBuffer( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( indexType ) ); - } - - // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( - uint32_t firstBinding, uint32_t bindingCount, const Buffer * pBuffers, const DeviceSize * pOffsets, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindVertexBuffers( static_cast( m_commandBuffer ), - firstBinding, - bindingCount, - reinterpret_cast( pBuffers ), - reinterpret_cast( pOffsets ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers && "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); -# else - if ( buffers.size() != offsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdBindVertexBuffers( m_commandBuffer, - firstBinding, - buffers.size(), - reinterpret_cast( buffers.data() ), - reinterpret_cast( offsets.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::draw( - uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDraw( static_cast( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance ); - } - - // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawIndexed( static_cast( m_commandBuffer ), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); - } - - // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawIndirect( - static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); - } - - // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::drawIndexedIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawIndexedIndirect( - static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); - } - - // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - uint32_t regionCount, - const ImageBlit * pRegions, - Filter filter, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBlitImage( static_cast( m_commandBuffer ), - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regionCount, - reinterpret_cast( pRegions ), - static_cast( filter ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::blitImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions, - Filter filter, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBlitImage && "Function requires " ); -# endif - - d.vkCmdBlitImage( m_commandBuffer, - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regions.size(), - reinterpret_cast( regions.data() ), - static_cast( filter ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, - ImageLayout imageLayout, - const ClearDepthStencilValue * pDepthStencil, - uint32_t rangeCount, - const ImageSubresourceRange * pRanges, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdClearDepthStencilImage( static_cast( m_commandBuffer ), - static_cast( image ), - static_cast( imageLayout ), - reinterpret_cast( pDepthStencil ), - rangeCount, - reinterpret_cast( pRanges ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( Image image, - ImageLayout imageLayout, - const ClearDepthStencilValue & depthStencil, - ArrayProxy const & ranges, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdClearDepthStencilImage && "Function requires " ); -# endif - - d.vkCmdClearDepthStencilImage( m_commandBuffer, - static_cast( image ), - static_cast( imageLayout ), - reinterpret_cast( &depthStencil ), - ranges.size(), - reinterpret_cast( ranges.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( - uint32_t attachmentCount, const ClearAttachment * pAttachments, uint32_t rectCount, const ClearRect * pRects, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdClearAttachments( static_cast( m_commandBuffer ), - attachmentCount, - reinterpret_cast( pAttachments ), - rectCount, - reinterpret_cast( pRects ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy const & attachments, - ArrayProxy const & rects, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdClearAttachments && "Function requires " ); -# endif - - d.vkCmdClearAttachments( m_commandBuffer, - attachments.size(), - reinterpret_cast( attachments.data() ), - rects.size(), - reinterpret_cast( rects.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - uint32_t regionCount, - const ImageResolve * pRegions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdResolveImage( static_cast( m_commandBuffer ), - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regionCount, - reinterpret_cast( pRegions ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::resolveImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdResolveImage && "Function requires " ); -# endif - - d.vkCmdResolveImage( m_commandBuffer, - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regions.size(), - reinterpret_cast( regions.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::beginRenderPass( const RenderPassBeginInfo * pRenderPassBegin, SubpassContents contents, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginRenderPass( static_cast( m_commandBuffer ), - reinterpret_cast( pRenderPassBegin ), - static_cast( contents ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass && "Function requires " ); -# endif - - d.vkCmdBeginRenderPass( m_commandBuffer, reinterpret_cast( &renderPassBegin ), static_cast( contents ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdNextSubpass( static_cast( m_commandBuffer ), static_cast( contents ) ); - } - - // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endRenderPass( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndRenderPass( static_cast( m_commandBuffer ) ); - } - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result enumerateInstanceVersion( uint32_t * pApiVersion, Dispatch const & d ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkEnumerateInstanceVersion( pApiVersion ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type enumerateInstanceVersion( Dispatch const & d ) - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumerateInstanceVersion && "Function requires " ); -# endif - - uint32_t apiVersion; - Result result = static_cast( d.vkEnumerateInstanceVersion( &apiVersion ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::enumerateInstanceVersion" ); - - return detail::createResultValueType( result, std::move( apiVersion ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindBufferMemory2( uint32_t bindInfoCount, - const BindBufferMemoryInfo * pBindInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkBindBufferMemory2( static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::bindBufferMemory2( ArrayProxy const & bindInfos, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBindBufferMemory2 && "Function requires or " ); -# endif - - Result result = - static_cast( d.vkBindBufferMemory2( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory2( uint32_t bindInfoCount, - const BindImageMemoryInfo * pBindInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkBindImageMemory2( static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::bindImageMemory2( ArrayProxy const & bindInfos, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBindImageMemory2 && "Function requires or " ); -# endif - - Result result = - static_cast( d.vkBindImageMemory2( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html - template ::type> - VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - PeerMemoryFeatureFlags * pPeerMemoryFeatures, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceGroupPeerMemoryFeatures( - static_cast( m_device ), heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( pPeerMemoryFeatures ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPeerMemoryFeatures && - "Function requires or " ); -# endif - - PeerMemoryFeatureFlags peerMemoryFeatures; - d.vkGetDeviceGroupPeerMemoryFeatures( - m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( &peerMemoryFeatures ) ); - - return peerMemoryFeatures; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDeviceMask( static_cast( m_commandBuffer ), deviceMask ); - } - - // wrapper function for command vkEnumeratePhysicalDeviceGroups, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount, - PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkEnumeratePhysicalDeviceGroups( static_cast( m_instance ), - pPhysicalDeviceGroupCount, - reinterpret_cast( pPhysicalDeviceGroupProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumeratePhysicalDeviceGroups, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::enumeratePhysicalDeviceGroups( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroups && - "Function requires or " ); -# endif - - std::vector physicalDeviceGroupProperties; - uint32_t physicalDeviceGroupCount; - Result result; - do - { - result = static_cast( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - result = static_cast( d.vkEnumeratePhysicalDeviceGroups( - m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); - if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - } - return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); - } - - // wrapper function for command vkEnumeratePhysicalDeviceGroups, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator const & physicalDeviceGroupPropertiesAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroups && - "Function requires or " ); -# endif - - std::vector physicalDeviceGroupProperties( physicalDeviceGroupPropertiesAllocator ); - uint32_t physicalDeviceGroupCount; - Result result; - do - { - result = static_cast( d.vkEnumeratePhysicalDeviceGroups( m_instance, &physicalDeviceGroupCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - result = static_cast( d.vkEnumeratePhysicalDeviceGroups( - m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); - if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - } - return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetImageMemoryRequirements2( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2 && - "Function requires or " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetImageMemoryRequirements2( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetImageMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2 && - "Function requires or " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetImageMemoryRequirements2( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html - template ::type> - VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetBufferMemoryRequirements2( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2 && - "Function requires or " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetBufferMemoryRequirements2( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetBufferMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2 && - "Function requires or " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetBufferMemoryRequirements2( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSparseMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 * pInfo, - uint32_t * pSparseMemoryRequirementCount, - SparseImageMemoryRequirements2 * pSparseMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetImageSparseMemoryRequirements2( static_cast( m_device ), - reinterpret_cast( pInfo ), - pSparseMemoryRequirementCount, - reinterpret_cast( pSparseMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSparseMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html - template < - typename SparseImageMemoryRequirements2Allocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2 && - "Function requires or " ); -# endif - - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - d.vkGetImageSparseMemoryRequirements2( - m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetImageSparseMemoryRequirements2( m_device, - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } - - // wrapper function for command vkGetImageSparseMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html - template < - typename SparseImageMemoryRequirements2Allocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, - SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2 && - "Function requires or " ); -# endif - - std::vector sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator ); - uint32_t sparseMemoryRequirementCount; - d.vkGetImageSparseMemoryRequirements2( - m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetImageSparseMemoryRequirements2( m_device, - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceFeatures2( static_cast( m_physicalDevice ), reinterpret_cast( pFeatures ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2 && - "Function requires or " ); -# endif - - PhysicalDeviceFeatures2 features; - d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( &features ) ); - - return features; - } - - // wrapper function for command vkGetPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2 && - "Function requires or " ); -# endif - - StructureChain structureChain; - PhysicalDeviceFeatures2 & features = structureChain.template get(); - d.vkGetPhysicalDeviceFeatures2( m_physicalDevice, reinterpret_cast( &features ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getProperties2( PhysicalDeviceProperties2 * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceProperties2( static_cast( m_physicalDevice ), reinterpret_cast( pProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2 && - "Function requires or " ); -# endif - - PhysicalDeviceProperties2 properties; - d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( &properties ) ); - - return properties; - } - - // wrapper function for command vkGetPhysicalDeviceProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2 && - "Function requires or " ); -# endif - - StructureChain structureChain; - PhysicalDeviceProperties2 & properties = structureChain.template get(); - d.vkGetPhysicalDeviceProperties2( m_physicalDevice, reinterpret_cast( &properties ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html - template ::type> - VULKAN_HPP_INLINE void - PhysicalDevice::getFormatProperties2( Format format, FormatProperties2 * pFormatProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceFormatProperties2( - static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( pFormatProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2( Format format, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2 && - "Function requires or " ); -# endif - - FormatProperties2 formatProperties; - d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); - - return formatProperties; - } - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFormatProperties2( Format format, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2 && - "Function requires or " ); -# endif - - StructureChain structureChain; - FormatProperties2 & formatProperties = structureChain.template get(); - d.vkGetPhysicalDeviceFormatProperties2( m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, - ImageFormatProperties2 * pImageFormatProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( pImageFormatInfo ), - reinterpret_cast( pImageFormatProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2 && - "Function requires or " ); -# endif - - ImageFormatProperties2 imageFormatProperties; - Result result = - static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, - reinterpret_cast( &imageFormatInfo ), - reinterpret_cast( &imageFormatProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); - - return detail::createResultValueType( result, std::move( imageFormatProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2 && - "Function requires or " ); -# endif - - StructureChain structureChain; - ImageFormatProperties2 & imageFormatProperties = structureChain.template get(); - Result result = - static_cast( d.vkGetPhysicalDeviceImageFormatProperties2( m_physicalDevice, - reinterpret_cast( &imageFormatInfo ), - reinterpret_cast( &imageFormatProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); - - return detail::createResultValueType( result, std::move( structureChain ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount, - QueueFamilyProperties2 * pQueueFamilyProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceQueueFamilyProperties2( - static_cast( m_physicalDevice ), pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && - "Function requires or " ); -# endif - - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties2( - m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - queueFamilyProperties.resize( queueFamilyPropertyCount ); - } - return queueFamilyProperties; - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getQueueFamilyProperties2( QueueFamilyProperties2Allocator const & queueFamilyProperties2Allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && - "Function requires or " ); -# endif - - std::vector queueFamilyProperties( queueFamilyProperties2Allocator ); - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties2( - m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - queueFamilyProperties.resize( queueFamilyPropertyCount ); - } - return queueFamilyProperties; - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getQueueFamilyProperties2( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && - "Function requires or " ); -# endif - - std::vector structureChains; - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - structureChains.resize( queueFamilyPropertyCount ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; - } - d.vkGetPhysicalDeviceQueueFamilyProperties2( - m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - structureChains.resize( queueFamilyPropertyCount ); - } - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - structureChains[i].template get() = queueFamilyProperties[i]; - } - return structureChains; - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2 && - "Function requires or " ); -# endif - - std::vector structureChains( structureChainAllocator ); - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties2( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - structureChains.resize( queueFamilyPropertyCount ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; - } - d.vkGetPhysicalDeviceQueueFamilyProperties2( - m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - structureChains.resize( queueFamilyPropertyCount ); - } - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - structureChains[i].template get() = queueFamilyProperties[i]; - } - return structureChains; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2( PhysicalDeviceMemoryProperties2 * pMemoryProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceMemoryProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( pMemoryProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2 && - "Function requires or " ); -# endif - - PhysicalDeviceMemoryProperties2 memoryProperties; - d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); - - return memoryProperties; - } - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getMemoryProperties2( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2 && - "Function requires or " ); -# endif - - StructureChain structureChain; - PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get(); - d.vkGetPhysicalDeviceMemoryProperties2( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, - uint32_t * pPropertyCount, - SparseImageFormatProperties2 * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( pFormatInfo ), - pPropertyCount, - reinterpret_cast( pProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2 && - "Function requires or " ); -# endif - - std::vector properties; - uint32_t propertyCount; - d.vkGetPhysicalDeviceSparseImageFormatProperties2( - m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); - properties.resize( propertyCount ); - d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, - reinterpret_cast( &formatInfo ), - &propertyCount, - reinterpret_cast( properties.data() ) ); - - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return properties; - } - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, - SparseImageFormatProperties2Allocator const & sparseImageFormatProperties2Allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2 && - "Function requires or " ); -# endif - - std::vector properties( sparseImageFormatProperties2Allocator ); - uint32_t propertyCount; - d.vkGetPhysicalDeviceSparseImageFormatProperties2( - m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); - properties.resize( propertyCount ); - d.vkGetPhysicalDeviceSparseImageFormatProperties2( m_physicalDevice, - reinterpret_cast( &formatInfo ), - &propertyCount, - reinterpret_cast( properties.data() ) ); - - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return properties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html - template ::type> - VULKAN_HPP_INLINE void Device::trimCommandPool( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkTrimCommandPool( static_cast( m_device ), static_cast( commandPool ), static_cast( flags ) ); - } - - // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html - template ::type> - VULKAN_HPP_INLINE void Device::getQueue2( const DeviceQueueInfo2 * pQueueInfo, Queue * pQueue, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceQueue2( static_cast( m_device ), reinterpret_cast( pQueueInfo ), reinterpret_cast( pQueue ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Queue Device::getQueue2( const DeviceQueueInfo2 & queueInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceQueue2 && "Function requires " ); -# endif - - Queue queue; - d.vkGetDeviceQueue2( m_device, reinterpret_cast( &queueInfo ), reinterpret_cast( &queue ) ); - - return queue; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, - ExternalBufferProperties * pExternalBufferProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceExternalBufferProperties( static_cast( m_physicalDevice ), - reinterpret_cast( pExternalBufferInfo ), - reinterpret_cast( pExternalBufferProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalBufferProperties - PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalBufferProperties && - "Function requires or " ); -# endif - - ExternalBufferProperties externalBufferProperties; - d.vkGetPhysicalDeviceExternalBufferProperties( m_physicalDevice, - reinterpret_cast( &externalBufferInfo ), - reinterpret_cast( &externalBufferProperties ) ); - - return externalBufferProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, - ExternalFenceProperties * pExternalFenceProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceExternalFenceProperties( static_cast( m_physicalDevice ), - reinterpret_cast( pExternalFenceInfo ), - reinterpret_cast( pExternalFenceProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalFenceProperties - PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalFenceProperties && - "Function requires or " ); -# endif - - ExternalFenceProperties externalFenceProperties; - d.vkGetPhysicalDeviceExternalFenceProperties( m_physicalDevice, - reinterpret_cast( &externalFenceInfo ), - reinterpret_cast( &externalFenceProperties ) ); - - return externalFenceProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, - ExternalSemaphoreProperties * pExternalSemaphoreProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceExternalSemaphoreProperties( static_cast( m_physicalDevice ), - reinterpret_cast( pExternalSemaphoreInfo ), - reinterpret_cast( pExternalSemaphoreProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphoreProperties( - const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalSemaphoreProperties && - "Function requires or " ); -# endif - - ExternalSemaphoreProperties externalSemaphoreProperties; - d.vkGetPhysicalDeviceExternalSemaphoreProperties( m_physicalDevice, - reinterpret_cast( &externalSemaphoreInfo ), - reinterpret_cast( &externalSemaphoreProperties ) ); - - return externalSemaphoreProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDispatchBase( static_cast( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); - } - - // wrapper function for command vkCreateDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - DescriptorUpdateTemplate * pDescriptorUpdateTemplate, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDescriptorUpdateTemplate( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pDescriptorUpdateTemplate ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createDescriptorUpdateTemplate( - const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplate && - "Function requires or " ); -# endif - - DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = static_cast( d.vkCreateDescriptorUpdateTemplate( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &descriptorUpdateTemplate ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" ); - - return detail::createResultValueType( result, std::move( descriptorUpdateTemplate ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplate && - "Function requires or " ); -# endif - - DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = static_cast( d.vkCreateDescriptorUpdateTemplate( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &descriptorUpdateTemplate ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( descriptorUpdateTemplate, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDescriptorUpdateTemplate( static_cast( m_device ), - static_cast( descriptorUpdateTemplate ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplate && - "Function requires or " ); -# endif - - d.vkDestroyDescriptorUpdateTemplate( - m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDescriptorUpdateTemplate( static_cast( m_device ), - static_cast( descriptorUpdateTemplate ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplate && - "Function requires or " ); -# endif - - d.vkDestroyDescriptorUpdateTemplate( - m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html - template ::type> - VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, - DescriptorUpdateTemplate descriptorUpdateTemplate, - const void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkUpdateDescriptorSetWithTemplate( static_cast( m_device ), - static_cast( descriptorSet ), - static_cast( descriptorUpdateTemplate ), - pData ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html - template ::type> - VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, - DescriptorUpdateTemplate descriptorUpdateTemplate, - DataType const & data, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSetWithTemplate && - "Function requires or " ); -# endif - - d.vkUpdateDescriptorSetWithTemplate( m_device, - static_cast( descriptorSet ), - static_cast( descriptorUpdateTemplate ), - reinterpret_cast( &data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDescriptorSetLayoutSupport, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html - template ::type> - VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo * pCreateInfo, - DescriptorSetLayoutSupport * pSupport, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDescriptorSetLayoutSupport( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pSupport ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetLayoutSupport, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupport && "Function requires or " ); -# endif - - DescriptorSetLayoutSupport support; - d.vkGetDescriptorSetLayoutSupport( - m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); - - return support; - } - - // wrapper function for command vkGetDescriptorSetLayoutSupport, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupport && "Function requires or " ); -# endif - - StructureChain structureChain; - DescriptorSetLayoutSupport & support = structureChain.template get(); - d.vkGetDescriptorSetLayoutSupport( - m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateSamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - SamplerYcbcrConversion * pYcbcrConversion, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateSamplerYcbcrConversion( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pYcbcrConversion ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createSamplerYcbcrConversion( - const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversion && - "Function requires or " ); -# endif - - SamplerYcbcrConversion ycbcrConversion; - Result result = static_cast( d.vkCreateSamplerYcbcrConversion( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &ycbcrConversion ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" ); - - return detail::createResultValueType( result, std::move( ycbcrConversion ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversion && - "Function requires or " ); -# endif - - SamplerYcbcrConversion ycbcrConversion; - Result result = static_cast( d.vkCreateSamplerYcbcrConversion( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &ycbcrConversion ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( ycbcrConversion, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html - template ::type> - VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroySamplerYcbcrConversion( static_cast( m_device ), - static_cast( ycbcrConversion ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html - template ::type> - VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversion && - "Function requires or " ); -# endif - - d.vkDestroySamplerYcbcrConversion( - m_device, static_cast( ycbcrConversion ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( SamplerYcbcrConversion ycbcrConversion, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroySamplerYcbcrConversion( static_cast( m_device ), - static_cast( ycbcrConversion ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( SamplerYcbcrConversion ycbcrConversion, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversion && - "Function requires or " ); -# endif - - d.vkDestroySamplerYcbcrConversion( - m_device, static_cast( ycbcrConversion ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_2 === - - // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html - template ::type> - VULKAN_HPP_INLINE void Device::resetQueryPool( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkResetQueryPool( static_cast( m_device ), static_cast( queryPool ), firstQuery, queryCount ); - } - - // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValue( Semaphore semaphore, - uint64_t * pValue, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetSemaphoreCounterValue( static_cast( m_device ), static_cast( semaphore ), pValue ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getSemaphoreCounterValue( Semaphore semaphore, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetSemaphoreCounterValue && "Function requires or " ); -# endif - - uint64_t value; - Result result = static_cast( d.vkGetSemaphoreCounterValue( m_device, static_cast( semaphore ), &value ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValue" ); - - return detail::createResultValueType( result, std::move( value ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const SemaphoreWaitInfo * pWaitInfo, - uint64_t timeout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkWaitSemaphores( static_cast( m_device ), reinterpret_cast( pWaitInfo ), timeout ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkWaitSemaphores && "Function requires or " ); -# endif - - Result result = static_cast( d.vkWaitSemaphores( m_device, reinterpret_cast( &waitInfo ), timeout ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphores", { Result::eSuccess, Result::eTimeout } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphore( const SemaphoreSignalInfo * pSignalInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkSignalSemaphore( static_cast( m_device ), reinterpret_cast( pSignalInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::signalSemaphore( const SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSignalSemaphore && "Function requires or " ); -# endif - - Result result = static_cast( d.vkSignalSemaphore( m_device, reinterpret_cast( &signalInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphore" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html - template ::type> - VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetBufferDeviceAddress( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html - template ::type> - VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddress && - "Function requires or or " ); -# endif - - VkDeviceAddress result = d.vkGetBufferDeviceAddress( m_device, reinterpret_cast( &info ) ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html - template ::type> - VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return d.vkGetBufferOpaqueCaptureAddress( static_cast( m_device ), reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html - template ::type> - VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureAddress && - "Function requires or " ); -# endif - - uint64_t result = d.vkGetBufferOpaqueCaptureAddress( m_device, reinterpret_cast( &info ) ); - - return result; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html - template ::type> - VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return d.vkGetDeviceMemoryOpaqueCaptureAddress( static_cast( m_device ), - reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html - template ::type> - VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryOpaqueCaptureAddress && - "Function requires or " ); -# endif - - uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddress( m_device, reinterpret_cast( &info ) ); - - return result; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawIndirectCount( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - // wrapper function for command vkCmdDrawIndexedIndirectCount, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawIndexedIndirectCount( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass2( const RenderPassCreateInfo2 * pCreateInfo, - const AllocationCallbacks * pAllocator, - RenderPass * pRenderPass, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateRenderPass2( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pRenderPass ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createRenderPass2( const RenderPassCreateInfo2 & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRenderPass2 && "Function requires or " ); -# endif - - RenderPass renderPass; - Result result = static_cast( d.vkCreateRenderPass2( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &renderPass ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2" ); - - return detail::createResultValueType( result, std::move( renderPass ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createRenderPass2Unique( const RenderPassCreateInfo2 & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRenderPass2 && "Function requires or " ); -# endif - - RenderPass renderPass; - Result result = static_cast( d.vkCreateRenderPass2( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &renderPass ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2Unique" ); - - return detail::createResultValueType( result, - UniqueHandle( renderPass, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const RenderPassBeginInfo * pRenderPassBegin, - const SubpassBeginInfo * pSubpassBeginInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginRenderPass2( static_cast( m_commandBuffer ), - reinterpret_cast( pRenderPassBegin ), - reinterpret_cast( pSubpassBeginInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const RenderPassBeginInfo & renderPassBegin, - const SubpassBeginInfo & subpassBeginInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass2 && "Function requires or " ); -# endif - - d.vkCmdBeginRenderPass2( - m_commandBuffer, reinterpret_cast( &renderPassBegin ), reinterpret_cast( &subpassBeginInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const SubpassBeginInfo * pSubpassBeginInfo, - const SubpassEndInfo * pSubpassEndInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdNextSubpass2( static_cast( m_commandBuffer ), - reinterpret_cast( pSubpassBeginInfo ), - reinterpret_cast( pSubpassEndInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const SubpassBeginInfo & subpassBeginInfo, - const SubpassEndInfo & subpassEndInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdNextSubpass2 && "Function requires or " ); -# endif - - d.vkCmdNextSubpass2( - m_commandBuffer, reinterpret_cast( &subpassBeginInfo ), reinterpret_cast( &subpassEndInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndRenderPass2( static_cast( m_commandBuffer ), reinterpret_cast( pSubpassEndInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const SubpassEndInfo & subpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdEndRenderPass2 && "Function requires or " ); -# endif - - d.vkCmdEndRenderPass2( m_commandBuffer, reinterpret_cast( &subpassEndInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_3 === - - // wrapper function for command vkGetPhysicalDeviceToolProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getToolProperties( uint32_t * pToolCount, - PhysicalDeviceToolProperties * pToolProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceToolProperties( - static_cast( m_physicalDevice ), pToolCount, reinterpret_cast( pToolProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceToolProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getToolProperties( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolProperties && - "Function requires or " ); -# endif - - std::vector toolProperties; - uint32_t toolCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && toolCount ) - { - toolProperties.resize( toolCount ); - result = static_cast( - d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, reinterpret_cast( toolProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" ); - VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); - if ( toolCount < toolProperties.size() ) - { - toolProperties.resize( toolCount ); - } - return detail::createResultValueType( result, std::move( toolProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceToolProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getToolProperties( PhysicalDeviceToolPropertiesAllocator const & physicalDeviceToolPropertiesAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolProperties && - "Function requires or " ); -# endif - - std::vector toolProperties( physicalDeviceToolPropertiesAllocator ); - uint32_t toolCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && toolCount ) - { - toolProperties.resize( toolCount ); - result = static_cast( - d.vkGetPhysicalDeviceToolProperties( m_physicalDevice, &toolCount, reinterpret_cast( toolProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" ); - VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); - if ( toolCount < toolProperties.size() ) - { - toolProperties.resize( toolCount ); - } - return detail::createResultValueType( result, std::move( toolProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPrivateDataSlot( const PrivateDataSlotCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - PrivateDataSlot * pPrivateDataSlot, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreatePrivateDataSlot( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pPrivateDataSlot ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createPrivateDataSlot( const PrivateDataSlotCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlot && "Function requires or " ); -# endif - - PrivateDataSlot privateDataSlot; - Result result = static_cast( d.vkCreatePrivateDataSlot( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &privateDataSlot ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlot" ); - - return detail::createResultValueType( result, std::move( privateDataSlot ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createPrivateDataSlotUnique( const PrivateDataSlotCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlot && "Function requires or " ); -# endif - - PrivateDataSlot privateDataSlot; - Result result = static_cast( d.vkCreatePrivateDataSlot( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &privateDataSlot ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( privateDataSlot, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyPrivateDataSlot( PrivateDataSlot privateDataSlot, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyPrivateDataSlot( - static_cast( m_device ), static_cast( privateDataSlot ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyPrivateDataSlot( PrivateDataSlot privateDataSlot, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlot && "Function requires or " ); -# endif - - d.vkDestroyPrivateDataSlot( - m_device, static_cast( privateDataSlot ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( PrivateDataSlot privateDataSlot, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyPrivateDataSlot( - static_cast( m_device ), static_cast( privateDataSlot ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( PrivateDataSlot privateDataSlot, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlot && "Function requires or " ); -# endif - - d.vkDestroyPrivateDataSlot( - m_device, static_cast( privateDataSlot ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setPrivateData( - ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkSetPrivateData( - static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); - } -#else - // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::setPrivateData( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSetPrivateData && "Function requires or " ); -# endif - - Result result = static_cast( - d.vkSetPrivateData( m_device, static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateData" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html - template ::type> - VULKAN_HPP_INLINE void Device::getPrivateData( - ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPrivateData( - static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), pData ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t - Device::getPrivateData( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPrivateData && "Function requires or " ); -# endif - - uint64_t data; - d.vkGetPrivateData( m_device, static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), &data ); - - return data; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPipelineBarrier2( static_cast( m_commandBuffer ), reinterpret_cast( pDependencyInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier2 && "Function requires or " ); -# endif - - d.vkCmdPipelineBarrier2( m_commandBuffer, reinterpret_cast( &dependencyInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::writeTimestamp2( PipelineStageFlags2 stage, QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdWriteTimestamp2( - static_cast( m_commandBuffer ), static_cast( stage ), static_cast( queryPool ), query ); - } - - // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Queue::submit2( uint32_t submitCount, const SubmitInfo2 * pSubmits, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkQueueSubmit2( static_cast( m_queue ), submitCount, reinterpret_cast( pSubmits ), static_cast( fence ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Queue::submit2( ArrayProxy const & submits, Fence fence, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkQueueSubmit2 && "Function requires or " ); -# endif - - Result result = static_cast( - d.vkQueueSubmit2( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyBuffer2( static_cast( m_commandBuffer ), reinterpret_cast( pCopyBufferInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer2 && "Function requires or " ); -# endif - - d.vkCmdCopyBuffer2( m_commandBuffer, reinterpret_cast( ©BufferInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyImage2( static_cast( m_commandBuffer ), reinterpret_cast( pCopyImageInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const CopyImageInfo2 & copyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyImage2 && "Function requires or " ); -# endif - - d.vkCmdCopyImage2( m_commandBuffer, reinterpret_cast( ©ImageInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyBufferToImage2( static_cast( m_commandBuffer ), reinterpret_cast( pCopyBufferToImageInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2( const CopyBufferToImageInfo2 & copyBufferToImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage2 && "Function requires or " ); -# endif - - d.vkCmdCopyBufferToImage2( m_commandBuffer, reinterpret_cast( ©BufferToImageInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyImageToBuffer2( static_cast( m_commandBuffer ), reinterpret_cast( pCopyImageToBufferInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2( const CopyImageToBufferInfo2 & copyImageToBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer2 && "Function requires or " ); -# endif - - d.vkCmdCopyImageToBuffer2( m_commandBuffer, reinterpret_cast( ©ImageToBufferInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html - template ::type> - VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceBufferMemoryRequirements( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirements && - "Function requires or " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetDeviceBufferMemoryRequirements( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDeviceBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirements && - "Function requires or " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetDeviceBufferMemoryRequirements( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceImageMemoryRequirements( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirements && - "Function requires or " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetDeviceImageMemoryRequirements( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDeviceImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirements && - "Function requires or " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetDeviceImageMemoryRequirements( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements * pInfo, - uint32_t * pSparseMemoryRequirementCount, - SparseImageMemoryRequirements2 * pSparseMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceImageSparseMemoryRequirements( static_cast( m_device ), - reinterpret_cast( pInfo ), - pSparseMemoryRequirementCount, - reinterpret_cast( pSparseMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html - template < - typename SparseImageMemoryRequirements2Allocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirements && - "Function requires or " ); -# endif - - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - d.vkGetDeviceImageSparseMemoryRequirements( - m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetDeviceImageSparseMemoryRequirements( m_device, - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } - - // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html - template < - typename SparseImageMemoryRequirements2Allocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info, - SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirements && - "Function requires or " ); -# endif - - std::vector sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator ); - uint32_t sparseMemoryRequirementCount; - d.vkGetDeviceImageSparseMemoryRequirements( - m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetDeviceImageSparseMemoryRequirements( m_device, - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setEvent2( Event event, const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetEvent2( - static_cast( m_commandBuffer ), static_cast( event ), reinterpret_cast( pDependencyInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setEvent2( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetEvent2 && "Function requires or " ); -# endif - - d.vkCmdSetEvent2( m_commandBuffer, static_cast( event ), reinterpret_cast( &dependencyInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::resetEvent2( Event event, PipelineStageFlags2 stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdResetEvent2( static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); - } - - // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::waitEvents2( uint32_t eventCount, - const Event * pEvents, - const DependencyInfo * pDependencyInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdWaitEvents2( static_cast( m_commandBuffer ), - eventCount, - reinterpret_cast( pEvents ), - reinterpret_cast( pDependencyInfos ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::waitEvents2( ArrayProxy const & events, - ArrayProxy const & dependencyInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdWaitEvents2 && "Function requires or " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); -# else - if ( events.size() != dependencyInfos.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2: events.size() != dependencyInfos.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdWaitEvents2( m_commandBuffer, - events.size(), - reinterpret_cast( events.data() ), - reinterpret_cast( dependencyInfos.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBlitImage2( static_cast( m_commandBuffer ), reinterpret_cast( pBlitImageInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const BlitImageInfo2 & blitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBlitImage2 && "Function requires or " ); -# endif - - d.vkCmdBlitImage2( m_commandBuffer, reinterpret_cast( &blitImageInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdResolveImage2( static_cast( m_commandBuffer ), reinterpret_cast( pResolveImageInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdResolveImage2 && "Function requires or " ); -# endif - - d.vkCmdResolveImage2( m_commandBuffer, reinterpret_cast( &resolveImageInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const RenderingInfo * pRenderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginRendering( static_cast( m_commandBuffer ), reinterpret_cast( pRenderingInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const RenderingInfo & renderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBeginRendering && "Function requires or " ); -# endif - - d.vkCmdBeginRendering( m_commandBuffer, reinterpret_cast( &renderingInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endRendering( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndRendering( static_cast( m_commandBuffer ) ); - } - - // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCullMode( CullModeFlags cullMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetCullMode( static_cast( m_commandBuffer ), static_cast( cullMode ) ); - } - - // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setFrontFace( FrontFace frontFace, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetFrontFace( static_cast( m_commandBuffer ), static_cast( frontFace ) ); - } - - // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology( PrimitiveTopology primitiveTopology, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetPrimitiveTopology( static_cast( m_commandBuffer ), static_cast( primitiveTopology ) ); - } - - // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::setViewportWithCount( uint32_t viewportCount, const Viewport * pViewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetViewportWithCount( static_cast( m_commandBuffer ), viewportCount, reinterpret_cast( pViewports ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCount( ArrayProxy const & viewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetViewportWithCount && - "Function requires or or " ); -# endif - - d.vkCmdSetViewportWithCount( m_commandBuffer, viewports.size(), reinterpret_cast( viewports.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCount( uint32_t scissorCount, const Rect2D * pScissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetScissorWithCount( static_cast( m_commandBuffer ), scissorCount, reinterpret_cast( pScissors ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCount( ArrayProxy const & scissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetScissorWithCount && - "Function requires or or " ); -# endif - - d.vkCmdSetScissorWithCount( m_commandBuffer, scissors.size(), reinterpret_cast( scissors.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding, - uint32_t bindingCount, - const Buffer * pBuffers, - const DeviceSize * pOffsets, - const DeviceSize * pSizes, - const DeviceSize * pStrides, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindVertexBuffers2( static_cast( m_commandBuffer ), - firstBinding, - bindingCount, - reinterpret_cast( pBuffers ), - reinterpret_cast( pOffsets ), - reinterpret_cast( pSizes ), - reinterpret_cast( pStrides ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes, - ArrayProxy const & strides, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers2 && - "Function requires or or " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); - VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); - VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); -# else - if ( buffers.size() != offsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != offsets.size()" ); - } - if ( !sizes.empty() && buffers.size() != sizes.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != sizes.size()" ); - } - if ( !strides.empty() && buffers.size() != strides.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != strides.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdBindVertexBuffers2( m_commandBuffer, - firstBinding, - buffers.size(), - reinterpret_cast( buffers.data() ), - reinterpret_cast( offsets.data() ), - reinterpret_cast( sizes.data() ), - reinterpret_cast( strides.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable( Bool32 depthTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthTestEnable( static_cast( m_commandBuffer ), static_cast( depthTestEnable ) ); - } - - // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable( Bool32 depthWriteEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthWriteEnable( static_cast( m_commandBuffer ), static_cast( depthWriteEnable ) ); - } - - // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp( CompareOp depthCompareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthCompareOp( static_cast( m_commandBuffer ), static_cast( depthCompareOp ) ); - } - - // wrapper function for command vkCmdSetDepthBoundsTestEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthBoundsTestEnable( static_cast( m_commandBuffer ), static_cast( depthBoundsTestEnable ) ); - } - - // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable( Bool32 stencilTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetStencilTestEnable( static_cast( m_commandBuffer ), static_cast( stencilTestEnable ) ); - } - - // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setStencilOp( - StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetStencilOp( static_cast( m_commandBuffer ), - static_cast( faceMask ), - static_cast( failOp ), - static_cast( passOp ), - static_cast( depthFailOp ), - static_cast( compareOp ) ); - } - - // wrapper function for command vkCmdSetRasterizerDiscardEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetRasterizerDiscardEnable( static_cast( m_commandBuffer ), static_cast( rasterizerDiscardEnable ) ); - } - - // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable( Bool32 depthBiasEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthBiasEnable( static_cast( m_commandBuffer ), static_cast( depthBiasEnable ) ); - } - - // wrapper function for command vkCmdSetPrimitiveRestartEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable( Bool32 primitiveRestartEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetPrimitiveRestartEnable( static_cast( m_commandBuffer ), static_cast( primitiveRestartEnable ) ); - } - - //=== VK_VERSION_1_4 === - - // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory2( const MemoryMapInfo * pMemoryMapInfo, - void ** ppData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkMapMemory2( static_cast( m_device ), reinterpret_cast( pMemoryMapInfo ), ppData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::mapMemory2( const MemoryMapInfo & memoryMapInfo, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkMapMemory2 && "Function requires or " ); -# endif - - void * pData; - Result result = static_cast( d.vkMapMemory2( m_device, reinterpret_cast( &memoryMapInfo ), &pData ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2" ); - - return detail::createResultValueType( result, std::move( pData ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::unmapMemory2( const MemoryUnmapInfo * pMemoryUnmapInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkUnmapMemory2( static_cast( m_device ), reinterpret_cast( pMemoryUnmapInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkUnmapMemory2 && "Function requires or " ); -# endif - - Result result = static_cast( d.vkUnmapMemory2( m_device, reinterpret_cast( &memoryUnmapInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::unmapMemory2" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageSubresourceLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html - template ::type> - VULKAN_HPP_INLINE void - Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo * pInfo, SubresourceLayout2 * pLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceImageSubresourceLayout( - static_cast( m_device ), reinterpret_cast( pInfo ), reinterpret_cast( pLayout ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageSubresourceLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayout && - "Function requires or " ); -# endif - - SubresourceLayout2 layout; - d.vkGetDeviceImageSubresourceLayout( - m_device, reinterpret_cast( &info ), reinterpret_cast( &layout ) ); - - return layout; - } - - // wrapper function for command vkGetDeviceImageSubresourceLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayout && - "Function requires or " ); -# endif - - StructureChain structureChain; - SubresourceLayout2 & layout = structureChain.template get(); - d.vkGetDeviceImageSubresourceLayout( - m_device, reinterpret_cast( &info ), reinterpret_cast( &layout ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageSubresourceLayout2( Image image, - const ImageSubresource2 * pSubresource, - SubresourceLayout2 * pLayout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetImageSubresourceLayout2( static_cast( m_device ), - static_cast( image ), - reinterpret_cast( pSubresource ), - reinterpret_cast( pLayout ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout2( Image image, - const ImageSubresource2 & subresource, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( - d.vkGetImageSubresourceLayout2 && - "Function requires or or or " ); -# endif - - SubresourceLayout2 layout; - d.vkGetImageSubresourceLayout2( m_device, - static_cast( image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return layout; - } - - // wrapper function for command vkGetImageSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getImageSubresourceLayout2( Image image, const ImageSubresource2 & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( - d.vkGetImageSubresourceLayout2 && - "Function requires or or or " ); -# endif - - StructureChain structureChain; - SubresourceLayout2 & layout = structureChain.template get(); - d.vkGetImageSubresourceLayout2( m_device, - static_cast( image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToImage( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkCopyMemoryToImage( static_cast( m_device ), reinterpret_cast( pCopyMemoryToImageInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::copyMemoryToImage( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyMemoryToImage && "Function requires or " ); -# endif - - Result result = static_cast( d.vkCopyMemoryToImage( m_device, reinterpret_cast( ©MemoryToImageInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToImage" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToMemory( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkCopyImageToMemory( static_cast( m_device ), reinterpret_cast( pCopyImageToMemoryInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::copyImageToMemory( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyImageToMemory && "Function requires or " ); -# endif - - Result result = static_cast( d.vkCopyImageToMemory( m_device, reinterpret_cast( ©ImageToMemoryInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToMemory" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToImage( const CopyImageToImageInfo * pCopyImageToImageInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkCopyImageToImage( static_cast( m_device ), reinterpret_cast( pCopyImageToImageInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::copyImageToImage( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyImageToImage && "Function requires or " ); -# endif - - Result result = static_cast( d.vkCopyImageToImage( m_device, reinterpret_cast( ©ImageToImageInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToImage" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::transitionImageLayout( uint32_t transitionCount, - const HostImageLayoutTransitionInfo * pTransitions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkTransitionImageLayout( - static_cast( m_device ), transitionCount, reinterpret_cast( pTransitions ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::transitionImageLayout( ArrayProxy const & transitions, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkTransitionImageLayout && "Function requires or " ); -# endif - - Result result = static_cast( - d.vkTransitionImageLayout( m_device, transitions.size(), reinterpret_cast( transitions.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::transitionImageLayout" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const WriteDescriptorSet * pDescriptorWrites, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushDescriptorSet( static_cast( m_commandBuffer ), - static_cast( pipelineBindPoint ), - static_cast( layout ), - set, - descriptorWriteCount, - reinterpret_cast( pDescriptorWrites ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t set, - ArrayProxy const & descriptorWrites, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSet && "Function requires or " ); -# endif - - d.vkCmdPushDescriptorSet( m_commandBuffer, - static_cast( pipelineBindPoint ), - static_cast( layout ), - set, - descriptorWrites.size(), - reinterpret_cast( descriptorWrites.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate( - DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushDescriptorSetWithTemplate( static_cast( m_commandBuffer ), - static_cast( descriptorUpdateTemplate ), - static_cast( layout ), - set, - pData ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, - PipelineLayout layout, - uint32_t set, - DataType const & data, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( - d.vkCmdPushDescriptorSetWithTemplate && - "Function requires or or " ); -# endif - - d.vkCmdPushDescriptorSetWithTemplate( m_commandBuffer, - static_cast( descriptorUpdateTemplate ), - static_cast( layout ), - set, - reinterpret_cast( &data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindDescriptorSets2( static_cast( m_commandBuffer ), - reinterpret_cast( pBindDescriptorSetsInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2( const BindDescriptorSetsInfo & bindDescriptorSetsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets2 && "Function requires or " ); -# endif - - d.vkCmdBindDescriptorSets2( m_commandBuffer, reinterpret_cast( &bindDescriptorSetsInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushConstants2( const PushConstantsInfo * pPushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushConstants2( static_cast( m_commandBuffer ), reinterpret_cast( pPushConstantsInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushConstants2( const PushConstantsInfo & pushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPushConstants2 && "Function requires or " ); -# endif - - d.vkCmdPushConstants2( m_commandBuffer, reinterpret_cast( &pushConstantsInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2( const PushDescriptorSetInfo * pPushDescriptorSetInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushDescriptorSet2( static_cast( m_commandBuffer ), reinterpret_cast( pPushDescriptorSetInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2( const PushDescriptorSetInfo & pushDescriptorSetInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSet2 && "Function requires or " ); -# endif - - d.vkCmdPushDescriptorSet2( m_commandBuffer, reinterpret_cast( &pushDescriptorSetInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushDescriptorSetWithTemplate2( static_cast( m_commandBuffer ), - reinterpret_cast( pPushDescriptorSetWithTemplateInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetWithTemplate2 && - "Function requires or " ); -# endif - - d.vkCmdPushDescriptorSetWithTemplate2( m_commandBuffer, - reinterpret_cast( &pushDescriptorSetWithTemplateInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setLineStipple( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetLineStipple( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); - } - - // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::bindIndexBuffer2( Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindIndexBuffer2( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( size ), - static_cast( indexType ) ); - } - - // wrapper function for command vkGetRenderingAreaGranularity, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html - template ::type> - VULKAN_HPP_INLINE void - Device::getRenderingAreaGranularity( const RenderingAreaInfo * pRenderingAreaInfo, Extent2D * pGranularity, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetRenderingAreaGranularity( - static_cast( m_device ), reinterpret_cast( pRenderingAreaInfo ), reinterpret_cast( pGranularity ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRenderingAreaGranularity, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D Device::getRenderingAreaGranularity( const RenderingAreaInfo & renderingAreaInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRenderingAreaGranularity && "Function requires or " ); -# endif - - Extent2D granularity; - d.vkGetRenderingAreaGranularity( - m_device, reinterpret_cast( &renderingAreaInfo ), reinterpret_cast( &granularity ) ); - - return granularity; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetRenderingAttachmentLocations, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo * pLocationInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetRenderingAttachmentLocations( static_cast( m_commandBuffer ), - reinterpret_cast( pLocationInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetRenderingAttachmentLocations, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo & locationInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetRenderingAttachmentLocations && - "Function requires or " ); -# endif - - d.vkCmdSetRenderingAttachmentLocations( m_commandBuffer, reinterpret_cast( &locationInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetRenderingInputAttachmentIndices( static_cast( m_commandBuffer ), - reinterpret_cast( pInputAttachmentIndexInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetRenderingInputAttachmentIndices && - "Function requires or " ); -# endif - - d.vkCmdSetRenderingInputAttachmentIndices( m_commandBuffer, reinterpret_cast( &inputAttachmentIndexInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_surface === - - // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html - template ::type> - VULKAN_HPP_INLINE void Instance::destroySurfaceKHR( SurfaceKHR surface, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroySurfaceKHR( - static_cast( m_instance ), static_cast( surface ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html - template ::type> - VULKAN_HPP_INLINE void - Instance::destroySurfaceKHR( SurfaceKHR surface, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroySurfaceKHR && "Function requires " ); -# endif - - d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html - template ::type> - VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroySurfaceKHR( - static_cast( m_instance ), static_cast( surface ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html - template ::type> - VULKAN_HPP_INLINE void Instance::destroy( SurfaceKHR surface, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroySurfaceKHR && "Function requires " ); -# endif - - d.vkDestroySurfaceKHR( m_instance, static_cast( surface ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Bool32 * pSupported, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceSurfaceSupportKHR( - static_cast( m_physicalDevice ), queueFamilyIndex, static_cast( surface ), reinterpret_cast( pSupported ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceSupportKHR && "Function requires " ); -# endif - - Bool32 supported; - Result result = static_cast( d.vkGetPhysicalDeviceSurfaceSupportKHR( - m_physicalDevice, queueFamilyIndex, static_cast( surface ), reinterpret_cast( &supported ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); - - return detail::createResultValueType( result, std::move( supported ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, - SurfaceCapabilitiesKHR * pSurfaceCapabilities, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( static_cast( m_physicalDevice ), - static_cast( surface ), - reinterpret_cast( pSurfaceCapabilities ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR && "Function requires " ); -# endif - - SurfaceCapabilitiesKHR surfaceCapabilities; - Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilitiesKHR( - m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); - - return detail::createResultValueType( result, std::move( surfaceCapabilities ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, - uint32_t * pSurfaceFormatCount, - SurfaceFormatKHR * pSurfaceFormats, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast( m_physicalDevice ), - static_cast( surface ), - pSurfaceFormatCount, - reinterpret_cast( pSurfaceFormats ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormatsKHR && "Function requires " ); -# endif - - std::vector surfaceFormats; - uint32_t surfaceFormatCount; - Result result; - do - { - result = - static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast( surface ), &surfaceFormatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - surfaceFormats.resize( surfaceFormatCount ); - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( - m_physicalDevice, static_cast( surface ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); - if ( surfaceFormatCount < surfaceFormats.size() ) - { - surfaceFormats.resize( surfaceFormatCount ); - } - return detail::createResultValueType( result, std::move( surfaceFormats ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormatsKHR( SurfaceKHR surface, SurfaceFormatKHRAllocator const & surfaceFormatKHRAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormatsKHR && "Function requires " ); -# endif - - std::vector surfaceFormats( surfaceFormatKHRAllocator ); - uint32_t surfaceFormatCount; - Result result; - do - { - result = - static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( m_physicalDevice, static_cast( surface ), &surfaceFormatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - surfaceFormats.resize( surfaceFormatCount ); - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormatsKHR( - m_physicalDevice, static_cast( surface ), &surfaceFormatCount, reinterpret_cast( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); - if ( surfaceFormatCount < surfaceFormats.size() ) - { - surfaceFormats.resize( surfaceFormatCount ); - } - return detail::createResultValueType( result, std::move( surfaceFormats ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, - uint32_t * pPresentModeCount, - PresentModeKHR * pPresentModes, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast( m_physicalDevice ), - static_cast( surface ), - pPresentModeCount, - reinterpret_cast( pPresentModes ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModesKHR && "Function requires " ); -# endif - - std::vector presentModes; - uint32_t presentModeCount; - Result result; - do - { - result = static_cast( - d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast( surface ), &presentModeCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentModeCount ) - { - presentModes.resize( presentModeCount ); - result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( - m_physicalDevice, static_cast( surface ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); - VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); - if ( presentModeCount < presentModes.size() ) - { - presentModes.resize( presentModeCount ); - } - return detail::createResultValueType( result, std::move( presentModes ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfacePresentModesKHR( SurfaceKHR surface, PresentModeKHRAllocator const & presentModeKHRAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModesKHR && "Function requires " ); -# endif - - std::vector presentModes( presentModeKHRAllocator ); - uint32_t presentModeCount; - Result result; - do - { - result = static_cast( - d.vkGetPhysicalDeviceSurfacePresentModesKHR( m_physicalDevice, static_cast( surface ), &presentModeCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentModeCount ) - { - presentModes.resize( presentModeCount ); - result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModesKHR( - m_physicalDevice, static_cast( surface ), &presentModeCount, reinterpret_cast( presentModes.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); - VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); - if ( presentModeCount < presentModes.size() ) - { - presentModes.resize( presentModeCount ); - } - return detail::createResultValueType( result, std::move( presentModes ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_swapchain === - - // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSwapchainKHR( const SwapchainCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SwapchainKHR * pSwapchain, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateSwapchainKHR( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSwapchain ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSwapchainKHR && "Function requires " ); -# endif - - SwapchainKHR swapchain; - Result result = static_cast( d.vkCreateSwapchainKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &swapchain ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHR" ); - - return detail::createResultValueType( result, std::move( swapchain ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSwapchainKHR && "Function requires " ); -# endif - - SwapchainKHR swapchain; - Result result = static_cast( d.vkCreateSwapchainKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &swapchain ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSwapchainKHRUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( swapchain, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroySwapchainKHR( SwapchainKHR swapchain, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroySwapchainKHR( - static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroySwapchainKHR( SwapchainKHR swapchain, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroySwapchainKHR && "Function requires " ); -# endif - - d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroySwapchainKHR( - static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( SwapchainKHR swapchain, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroySwapchainKHR && "Function requires " ); -# endif - - d.vkDestroySwapchainKHR( m_device, static_cast( swapchain ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainImagesKHR( SwapchainKHR swapchain, - uint32_t * pSwapchainImageCount, - Image * pSwapchainImages, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetSwapchainImagesKHR( - static_cast( m_device ), static_cast( swapchain ), pSwapchainImageCount, reinterpret_cast( pSwapchainImages ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetSwapchainImagesKHR && "Function requires " ); -# endif - - std::vector swapchainImages; - uint32_t swapchainImageCount; - Result result; - do - { - result = static_cast( d.vkGetSwapchainImagesKHR( m_device, static_cast( swapchain ), &swapchainImageCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && swapchainImageCount ) - { - swapchainImages.resize( swapchainImageCount ); - result = static_cast( d.vkGetSwapchainImagesKHR( - m_device, static_cast( swapchain ), &swapchainImageCount, reinterpret_cast( swapchainImages.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" ); - VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); - if ( swapchainImageCount < swapchainImages.size() ) - { - swapchainImages.resize( swapchainImageCount ); - } - return detail::createResultValueType( result, std::move( swapchainImages ) ); - } - - // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getSwapchainImagesKHR( SwapchainKHR swapchain, ImageAllocator const & imageAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetSwapchainImagesKHR && "Function requires " ); -# endif - - std::vector swapchainImages( imageAllocator ); - uint32_t swapchainImageCount; - Result result; - do - { - result = static_cast( d.vkGetSwapchainImagesKHR( m_device, static_cast( swapchain ), &swapchainImageCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && swapchainImageCount ) - { - swapchainImages.resize( swapchainImageCount ); - result = static_cast( d.vkGetSwapchainImagesKHR( - m_device, static_cast( swapchain ), &swapchainImageCount, reinterpret_cast( swapchainImages.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainImagesKHR" ); - VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); - if ( swapchainImageCount < swapchainImages.size() ) - { - swapchainImages.resize( swapchainImageCount ); - } - return detail::createResultValueType( result, std::move( swapchainImages ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireNextImageKHR( - SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, uint32_t * pImageIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkAcquireNextImageKHR( static_cast( m_device ), - static_cast( swapchain ), - timeout, - static_cast( semaphore ), - static_cast( fence ), - pImageIndex ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue - Device::acquireNextImageKHR( SwapchainKHR swapchain, uint64_t timeout, Semaphore semaphore, Fence fence, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAcquireNextImageKHR && "Function requires " ); -# endif - - uint32_t imageIndex; - Result result = static_cast( d.vkAcquireNextImageKHR( - m_device, static_cast( swapchain ), timeout, static_cast( semaphore ), static_cast( fence ), &imageIndex ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR", - { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImageKHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); -# endif - - return ResultValue( result, std::move( imageIndex ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR * pPresentInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkQueuePresentKHR( static_cast( m_queue ), reinterpret_cast( pPresentInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkQueuePresentKHR && "Function requires " ); -# endif - - Result result = static_cast( d.vkQueuePresentKHR( m_queue, reinterpret_cast( &presentInfo ) ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); -# endif - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDeviceGroupPresentCapabilitiesKHR( - static_cast( m_device ), reinterpret_cast( pDeviceGroupPresentCapabilities ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getGroupPresentCapabilitiesKHR( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPresentCapabilitiesKHR && - "Function requires or " ); -# endif - - DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; - Result result = static_cast( - d.vkGetDeviceGroupPresentCapabilitiesKHR( m_device, reinterpret_cast( &deviceGroupPresentCapabilities ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); - - return detail::createResultValueType( result, std::move( deviceGroupPresentCapabilities ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, - DeviceGroupPresentModeFlagsKHR * pModes, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDeviceGroupSurfacePresentModesKHR( - static_cast( m_device ), static_cast( surface ), reinterpret_cast( pModes ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceGroupSurfacePresentModesKHR && - "Function requires or " ); -# endif - - DeviceGroupPresentModeFlagsKHR modes; - Result result = static_cast( d.vkGetDeviceGroupSurfacePresentModesKHR( - m_device, static_cast( surface ), reinterpret_cast( &modes ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); - - return detail::createResultValueType( result, std::move( modes ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, uint32_t * pRectCount, Rect2D * pRects, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( - static_cast( m_physicalDevice ), static_cast( surface ), pRectCount, reinterpret_cast( pRects ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDevicePresentRectanglesKHR && - "Function requires or " ); -# endif - - std::vector rects; - uint32_t rectCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast( surface ), &rectCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && rectCount ) - { - rects.resize( rectCount ); - result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( - m_physicalDevice, static_cast( surface ), &rectCount, reinterpret_cast( rects.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); - VULKAN_HPP_ASSERT( rectCount <= rects.size() ); - if ( rectCount < rects.size() ) - { - rects.resize( rectCount ); - } - return detail::createResultValueType( result, std::move( rects ) ); - } - - // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getPresentRectanglesKHR( SurfaceKHR surface, Rect2DAllocator const & rect2DAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDevicePresentRectanglesKHR && - "Function requires or " ); -# endif - - std::vector rects( rect2DAllocator ); - uint32_t rectCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( m_physicalDevice, static_cast( surface ), &rectCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && rectCount ) - { - rects.resize( rectCount ); - result = static_cast( d.vkGetPhysicalDevicePresentRectanglesKHR( - m_physicalDevice, static_cast( surface ), &rectCount, reinterpret_cast( rects.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); - VULKAN_HPP_ASSERT( rectCount <= rects.size() ); - if ( rectCount < rects.size() ) - { - rects.resize( rectCount ); - } - return detail::createResultValueType( result, std::move( rects ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR * pAcquireInfo, - uint32_t * pImageIndex, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkAcquireNextImage2KHR( static_cast( m_device ), reinterpret_cast( pAcquireInfo ), pImageIndex ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAcquireNextImage2KHR && "Function requires or " ); -# endif - - uint32_t imageIndex; - Result result = - static_cast( d.vkAcquireNextImage2KHR( m_device, reinterpret_cast( &acquireInfo ), &imageIndex ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR", - { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireNextImage2KHR", { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); -# endif - - return ResultValue( result, std::move( imageIndex ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_display === - - // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPropertiesKHR( uint32_t * pPropertyCount, - DisplayPropertiesKHR * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( - static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPropertiesKHR( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPropertiesKHR && "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( - d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator const & displayPropertiesKHRAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPropertiesKHR && "Function requires " ); -# endif - - std::vector properties( displayPropertiesKHRAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( - d.vkGetPhysicalDeviceDisplayPropertiesKHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount, - DisplayPlanePropertiesKHR * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( - static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPlanePropertiesKHR( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR && "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator const & displayPlanePropertiesKHRAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR && "Function requires " ); -# endif - - std::vector properties( displayPlanePropertiesKHRAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceDisplayPlanePropertiesKHR( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, - uint32_t * pDisplayCount, - DisplayKHR * pDisplays, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( - static_cast( m_physicalDevice ), planeIndex, pDisplayCount, reinterpret_cast( pDisplays ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneSupportedDisplaysKHR && "Function requires " ); -# endif - - std::vector displays; - uint32_t displayCount; - Result result; - do - { - result = static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && displayCount ) - { - displays.resize( displayCount ); - result = static_cast( - d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast( displays.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); - VULKAN_HPP_ASSERT( displayCount <= displays.size() ); - if ( displayCount < displays.size() ) - { - displays.resize( displayCount ); - } - return detail::createResultValueType( result, std::move( displays ) ); - } - - // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, DisplayKHRAllocator const & displayKHRAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneSupportedDisplaysKHR && "Function requires " ); -# endif - - std::vector displays( displayKHRAllocator ); - uint32_t displayCount; - Result result; - do - { - result = static_cast( d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && displayCount ) - { - displays.resize( displayCount ); - result = static_cast( - d.vkGetDisplayPlaneSupportedDisplaysKHR( m_physicalDevice, planeIndex, &displayCount, reinterpret_cast( displays.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); - VULKAN_HPP_ASSERT( displayCount <= displays.size() ); - if ( displayCount < displays.size() ) - { - displays.resize( displayCount ); - } - return detail::createResultValueType( result, std::move( displays ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDisplayModePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, - uint32_t * pPropertyCount, - DisplayModePropertiesKHR * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDisplayModePropertiesKHR( static_cast( m_physicalDevice ), - static_cast( display ), - pPropertyCount, - reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDisplayModePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDisplayModePropertiesKHR && "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetDisplayModePropertiesKHR( - m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetDisplayModePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayModePropertiesKHR( DisplayKHR display, - DisplayModePropertiesKHRAllocator const & displayModePropertiesKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDisplayModePropertiesKHR && "Function requires " ); -# endif - - std::vector properties( displayModePropertiesKHRAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetDisplayModePropertiesKHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetDisplayModePropertiesKHR( - m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModePropertiesKHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::createDisplayModeKHR( DisplayKHR display, - const DisplayModeCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - DisplayModeKHR * pMode, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDisplayModeKHR( static_cast( m_physicalDevice ), - static_cast( display ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pMode ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::createDisplayModeKHR( - DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDisplayModeKHR && "Function requires " ); -# endif - - DisplayModeKHR mode; - Result result = static_cast( d.vkCreateDisplayModeKHR( m_physicalDevice, - static_cast( display ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &mode ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHR" ); - - return detail::createResultValueType( result, std::move( mode ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::createDisplayModeKHRUnique( - DisplayKHR display, const DisplayModeCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDisplayModeKHR && "Function requires " ); -# endif - - DisplayModeKHR mode; - Result result = static_cast( d.vkCreateDisplayModeKHR( m_physicalDevice, - static_cast( display ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &mode ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::createDisplayModeKHRUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( mode, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, - uint32_t planeIndex, - DisplayPlaneCapabilitiesKHR * pCapabilities, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDisplayPlaneCapabilitiesKHR( static_cast( m_physicalDevice ), - static_cast( mode ), - planeIndex, - reinterpret_cast( pCapabilities ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneCapabilitiesKHR && "Function requires " ); -# endif - - DisplayPlaneCapabilitiesKHR capabilities; - Result result = static_cast( d.vkGetDisplayPlaneCapabilitiesKHR( - m_physicalDevice, static_cast( mode ), planeIndex, reinterpret_cast( &capabilities ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilitiesKHR" ); - - return detail::createResultValueType( result, std::move( capabilities ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDisplayPlaneSurfaceKHR( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createDisplayPlaneSurfaceKHR( - const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDisplayPlaneSurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createDisplayPlaneSurfaceKHRUnique( - const DisplaySurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDisplayPlaneSurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateDisplayPlaneSurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHRUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_display_swapchain === - - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSharedSwapchainsKHR( uint32_t swapchainCount, - const SwapchainCreateInfoKHR * pCreateInfos, - const AllocationCallbacks * pAllocator, - SwapchainKHR * pSwapchains, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateSharedSwapchainsKHR( static_cast( m_device ), - swapchainCount, - reinterpret_cast( pCreateInfos ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSwapchains ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::createSharedSwapchainsKHR( - ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); -# endif - - std::vector swapchains( createInfos.size() ); - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( swapchains.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); - - return detail::createResultValueType( result, std::move( swapchains ) ); - } - - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createSharedSwapchainsKHR( ArrayProxy const & createInfos, - Optional allocator, - SwapchainKHRAllocator const & swapchainKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); -# endif - - std::vector swapchains( createInfos.size(), {}, swapchainKHRAllocator ); - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( swapchains.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); - - return detail::createResultValueType( result, std::move( swapchains ) ); - } - - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); -# endif - - SwapchainKHR swapchain; - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &swapchain ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" ); - - return detail::createResultValueType( result, std::move( swapchain ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, SwapchainKHRAllocator>>::type - Device::createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); -# endif - - std::vector swapchains( createInfos.size() ); - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( swapchains.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); - std::vector, SwapchainKHRAllocator> uniqueSwapchains; - uniqueSwapchains.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & swapchain : swapchains ) - { - uniqueSwapchains.push_back( UniqueHandle( swapchain, deleter ) ); - } - return detail::createResultValueType( result, std::move( uniqueSwapchains ) ); - } - - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, SwapchainKHRAllocator>>::type - Device::createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, - Optional allocator, - SwapchainKHRAllocator const & swapchainKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); -# endif - - std::vector swapchains( createInfos.size() ); - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( swapchains.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainsKHRUnique" ); - std::vector, SwapchainKHRAllocator> uniqueSwapchains( swapchainKHRAllocator ); - uniqueSwapchains.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & swapchain : swapchains ) - { - uniqueSwapchains.push_back( UniqueHandle( swapchain, deleter ) ); - } - return detail::createResultValueType( result, std::move( uniqueSwapchains ) ); - } - - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSharedSwapchainsKHR && "Function requires " ); -# endif - - SwapchainKHR swapchain; - Result result = static_cast( d.vkCreateSharedSwapchainsKHR( m_device, - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &swapchain ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSharedSwapchainKHRUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( swapchain, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - - // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateXlibSurfaceKHR( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateXlibSurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateXlibSurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateXlibSurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateXlibSurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXlibSurfaceKHRUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html - template ::type> - VULKAN_HPP_INLINE Bool32 - PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display * dpy, VisualID visualID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPhysicalDeviceXlibPresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex, dpy, visualID ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html - template ::type> - VULKAN_HPP_INLINE Bool32 - PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceXlibPresentationSupportKHR && - "Function requires " ); -# endif - - VkBool32 result = d.vkGetPhysicalDeviceXlibPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &dpy, visualID ); - - return static_cast( result ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - - // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateXcbSurfaceKHR( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateXcbSurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateXcbSurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateXcbSurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateXcbSurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createXcbSurfaceKHRUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html - template ::type> - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, - xcb_connection_t * connection, - xcb_visualid_t visual_id, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPhysicalDeviceXcbPresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex, connection, visual_id ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html - template ::type> - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, - xcb_connection_t & connection, - xcb_visualid_t visual_id, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceXcbPresentationSupportKHR && - "Function requires " ); -# endif - - VkBool32 result = d.vkGetPhysicalDeviceXcbPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &connection, visual_id ); - - return static_cast( result ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - - // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateWaylandSurfaceKHR( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateWaylandSurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateWaylandSurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createWaylandSurfaceKHRUnique( - const WaylandSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateWaylandSurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateWaylandSurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHRUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html - template ::type> - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, - struct wl_display * display, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex, display ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html - template ::type> - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, - struct wl_display & display, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceWaylandPresentationSupportKHR && - "Function requires " ); -# endif - - VkBool32 result = d.vkGetPhysicalDeviceWaylandPresentationSupportKHR( m_physicalDevice, queueFamilyIndex, &display ); - - return static_cast( result ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - - // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateAndroidSurfaceKHR( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateAndroidSurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateAndroidSurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createAndroidSurfaceKHRUnique( - const AndroidSurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateAndroidSurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateAndroidSurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHRUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - - // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateWin32SurfaceKHR( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateWin32SurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateWin32SurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createWin32SurfaceKHRUnique( - const Win32SurfaceCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateWin32SurfaceKHR && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateWin32SurfaceKHR( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createWin32SurfaceKHRUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html - template ::type> - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceWin32PresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex ) ); - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - - // wrapper function for command vkCreateDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - DebugReportCallbackEXT * pCallback, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDebugReportCallbackEXT( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pCallback ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createDebugReportCallbackEXT( - const DebugReportCallbackCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDebugReportCallbackEXT && "Function requires " ); -# endif - - DebugReportCallbackEXT callback; - Result result = static_cast( d.vkCreateDebugReportCallbackEXT( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &callback ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" ); - - return detail::createResultValueType( result, std::move( callback ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDebugReportCallbackEXT && "Function requires " ); -# endif - - DebugReportCallbackEXT callback; - Result result = static_cast( d.vkCreateDebugReportCallbackEXT( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &callback ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXTUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( callback, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html - template ::type> - VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDebugReportCallbackEXT( - static_cast( m_instance ), static_cast( callback ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html - template ::type> - VULKAN_HPP_INLINE void Instance::destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDebugReportCallbackEXT && "Function requires " ); -# endif - - d.vkDestroyDebugReportCallbackEXT( - m_instance, static_cast( callback ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html - template ::type> - VULKAN_HPP_INLINE void - Instance::destroy( DebugReportCallbackEXT callback, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDebugReportCallbackEXT( - static_cast( m_instance ), static_cast( callback ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html - template ::type> - VULKAN_HPP_INLINE void - Instance::destroy( DebugReportCallbackEXT callback, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDebugReportCallbackEXT && "Function requires " ); -# endif - - d.vkDestroyDebugReportCallbackEXT( - m_instance, static_cast( callback ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html - template ::type> - VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, - DebugReportObjectTypeEXT objectType_, - uint64_t object, - size_t location, - int32_t messageCode, - const char * pLayerPrefix, - const char * pMessage, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDebugReportMessageEXT( static_cast( m_instance ), - static_cast( flags ), - static_cast( objectType_ ), - object, - location, - messageCode, - pLayerPrefix, - pMessage ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html - template ::type> - VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, - DebugReportObjectTypeEXT objectType_, - uint64_t object, - size_t location, - int32_t messageCode, - const std::string & layerPrefix, - const std::string & message, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDebugReportMessageEXT && "Function requires " ); -# endif - - d.vkDebugReportMessageEXT( m_instance, - static_cast( flags ), - static_cast( objectType_ ), - object, - location, - messageCode, - layerPrefix.c_str(), - message.c_str() ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_debug_marker === - - // wrapper function for command vkDebugMarkerSetObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT * pTagInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkDebugMarkerSetObjectTagEXT( static_cast( m_device ), reinterpret_cast( pTagInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDebugMarkerSetObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDebugMarkerSetObjectTagEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkDebugMarkerSetObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDebugMarkerSetObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT * pNameInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkDebugMarkerSetObjectNameEXT( static_cast( m_device ), reinterpret_cast( pNameInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDebugMarkerSetObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDebugMarkerSetObjectNameEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkDebugMarkerSetObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDebugMarkerBeginEXT( static_cast( m_commandBuffer ), reinterpret_cast( pMarkerInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdDebugMarkerBeginEXT && "Function requires " ); -# endif - - d.vkCmdDebugMarkerBeginEXT( m_commandBuffer, reinterpret_cast( &markerInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDebugMarkerEndEXT( static_cast( m_commandBuffer ) ); - } - - // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDebugMarkerInsertEXT( static_cast( m_commandBuffer ), reinterpret_cast( pMarkerInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdDebugMarkerInsertEXT && "Function requires " ); -# endif - - d.vkCmdDebugMarkerInsertEXT( m_commandBuffer, reinterpret_cast( &markerInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_video_queue === - - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR * pVideoProfile, - VideoCapabilitiesKHR * pCapabilities, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( pVideoProfile ), - reinterpret_cast( pCapabilities ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoCapabilitiesKHR && "Function requires " ); -# endif - - VideoCapabilitiesKHR capabilities; - Result result = static_cast( d.vkGetPhysicalDeviceVideoCapabilitiesKHR( - m_physicalDevice, reinterpret_cast( &videoProfile ), reinterpret_cast( &capabilities ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); - - return detail::createResultValueType( result, std::move( capabilities ) ); - } - - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoCapabilitiesKHR && "Function requires " ); -# endif - - StructureChain structureChain; - VideoCapabilitiesKHR & capabilities = structureChain.template get(); - Result result = static_cast( d.vkGetPhysicalDeviceVideoCapabilitiesKHR( - m_physicalDevice, reinterpret_cast( &videoProfile ), reinterpret_cast( &capabilities ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); - - return detail::createResultValueType( result, std::move( structureChain ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, - uint32_t * pVideoFormatPropertyCount, - VideoFormatPropertiesKHR * pVideoFormatProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( pVideoFormatInfo ), - pVideoFormatPropertyCount, - reinterpret_cast( pVideoFormatProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR && - "Function requires " ); -# endif - - std::vector videoFormatProperties; - uint32_t videoFormatPropertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( - m_physicalDevice, reinterpret_cast( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) - { - videoFormatProperties.resize( videoFormatPropertyCount ); - result = static_cast( - d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice, - reinterpret_cast( &videoFormatInfo ), - &videoFormatPropertyCount, - reinterpret_cast( videoFormatProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); - VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); - if ( videoFormatPropertyCount < videoFormatProperties.size() ) - { - videoFormatProperties.resize( videoFormatPropertyCount ); - } - return detail::createResultValueType( result, std::move( videoFormatProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, - VideoFormatPropertiesKHRAllocator const & videoFormatPropertiesKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR && - "Function requires " ); -# endif - - std::vector videoFormatProperties( videoFormatPropertiesKHRAllocator ); - uint32_t videoFormatPropertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( - m_physicalDevice, reinterpret_cast( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) - { - videoFormatProperties.resize( videoFormatPropertyCount ); - result = static_cast( - d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice, - reinterpret_cast( &videoFormatInfo ), - &videoFormatPropertyCount, - reinterpret_cast( videoFormatProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); - VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); - if ( videoFormatPropertyCount < videoFormatProperties.size() ) - { - videoFormatProperties.resize( videoFormatPropertyCount ); - } - return detail::createResultValueType( result, std::move( videoFormatProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR && - "Function requires " ); -# endif - - std::vector structureChains; - std::vector videoFormatProperties; - uint32_t videoFormatPropertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( - m_physicalDevice, reinterpret_cast( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) - { - structureChains.resize( videoFormatPropertyCount ); - videoFormatProperties.resize( videoFormatPropertyCount ); - for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) - { - videoFormatProperties[i].pNext = structureChains[i].template get().pNext; - } - result = static_cast( - d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice, - reinterpret_cast( &videoFormatInfo ), - &videoFormatPropertyCount, - reinterpret_cast( videoFormatProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); - VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); - if ( videoFormatPropertyCount < videoFormatProperties.size() ) - { - structureChains.resize( videoFormatPropertyCount ); - } - for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) - { - structureChains[i].template get() = videoFormatProperties[i]; - } - return detail::createResultValueType( result, std::move( structureChains ) ); - } - - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, - StructureChainAllocator & structureChainAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR && - "Function requires " ); -# endif - - std::vector structureChains( structureChainAllocator ); - std::vector videoFormatProperties; - uint32_t videoFormatPropertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( - m_physicalDevice, reinterpret_cast( &videoFormatInfo ), &videoFormatPropertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) - { - structureChains.resize( videoFormatPropertyCount ); - videoFormatProperties.resize( videoFormatPropertyCount ); - for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) - { - videoFormatProperties[i].pNext = structureChains[i].template get().pNext; - } - result = static_cast( - d.vkGetPhysicalDeviceVideoFormatPropertiesKHR( m_physicalDevice, - reinterpret_cast( &videoFormatInfo ), - &videoFormatPropertyCount, - reinterpret_cast( videoFormatProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); - VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); - if ( videoFormatPropertyCount < videoFormatProperties.size() ) - { - structureChains.resize( videoFormatPropertyCount ); - } - for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) - { - structureChains[i].template get() = videoFormatProperties[i]; - } - return detail::createResultValueType( result, std::move( structureChains ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createVideoSessionKHR( const VideoSessionCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - VideoSessionKHR * pVideoSession, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateVideoSessionKHR( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pVideoSession ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createVideoSessionKHR( const VideoSessionCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateVideoSessionKHR && "Function requires " ); -# endif - - VideoSessionKHR videoSession; - Result result = static_cast( d.vkCreateVideoSessionKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &videoSession ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHR" ); - - return detail::createResultValueType( result, std::move( videoSession ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateVideoSessionKHR && "Function requires " ); -# endif - - VideoSessionKHR videoSession; - Result result = static_cast( d.vkCreateVideoSessionKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &videoSession ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionKHRUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( videoSession, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyVideoSessionKHR( VideoSessionKHR videoSession, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyVideoSessionKHR( - static_cast( m_device ), static_cast( videoSession ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyVideoSessionKHR( VideoSessionKHR videoSession, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionKHR && "Function requires " ); -# endif - - d.vkDestroyVideoSessionKHR( m_device, static_cast( videoSession ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( VideoSessionKHR videoSession, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyVideoSessionKHR( - static_cast( m_device ), static_cast( videoSession ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( VideoSessionKHR videoSession, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionKHR && "Function requires " ); -# endif - - d.vkDestroyVideoSessionKHR( m_device, static_cast( videoSession ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, - uint32_t * pMemoryRequirementsCount, - VideoSessionMemoryRequirementsKHR * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetVideoSessionMemoryRequirementsKHR( static_cast( m_device ), - static_cast( videoSession ), - pMemoryRequirementsCount, - reinterpret_cast( pMemoryRequirements ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html - template < - typename VideoSessionMemoryRequirementsKHRAllocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Device::getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetVideoSessionMemoryRequirementsKHR && "Function requires " ); -# endif - - std::vector memoryRequirements; - uint32_t memoryRequirementsCount; - Result result; - do - { - result = static_cast( - d.vkGetVideoSessionMemoryRequirementsKHR( m_device, static_cast( videoSession ), &memoryRequirementsCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && memoryRequirementsCount ) - { - memoryRequirements.resize( memoryRequirementsCount ); - result = static_cast( - d.vkGetVideoSessionMemoryRequirementsKHR( m_device, - static_cast( videoSession ), - &memoryRequirementsCount, - reinterpret_cast( memoryRequirements.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" ); - VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() ); - if ( memoryRequirementsCount < memoryRequirements.size() ) - { - memoryRequirements.resize( memoryRequirementsCount ); - } - return detail::createResultValueType( result, std::move( memoryRequirements ) ); - } - - // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html - template < - typename VideoSessionMemoryRequirementsKHRAllocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Device::getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, - VideoSessionMemoryRequirementsKHRAllocator const & videoSessionMemoryRequirementsKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetVideoSessionMemoryRequirementsKHR && "Function requires " ); -# endif - - std::vector memoryRequirements( videoSessionMemoryRequirementsKHRAllocator ); - uint32_t memoryRequirementsCount; - Result result; - do - { - result = static_cast( - d.vkGetVideoSessionMemoryRequirementsKHR( m_device, static_cast( videoSession ), &memoryRequirementsCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && memoryRequirementsCount ) - { - memoryRequirements.resize( memoryRequirementsCount ); - result = static_cast( - d.vkGetVideoSessionMemoryRequirementsKHR( m_device, - static_cast( videoSession ), - &memoryRequirementsCount, - reinterpret_cast( memoryRequirements.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getVideoSessionMemoryRequirementsKHR" ); - VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() ); - if ( memoryRequirementsCount < memoryRequirements.size() ) - { - memoryRequirements.resize( memoryRequirementsCount ); - } - return detail::createResultValueType( result, std::move( memoryRequirements ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindVideoSessionMemoryKHR( VideoSessionKHR videoSession, - uint32_t bindSessionMemoryInfoCount, - const BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkBindVideoSessionMemoryKHR( static_cast( m_device ), - static_cast( videoSession ), - bindSessionMemoryInfoCount, - reinterpret_cast( pBindSessionMemoryInfos ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::bindVideoSessionMemoryKHR( - VideoSessionKHR videoSession, ArrayProxy const & bindSessionMemoryInfos, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBindVideoSessionMemoryKHR && "Function requires " ); -# endif - - Result result = - static_cast( d.vkBindVideoSessionMemoryKHR( m_device, - static_cast( videoSession ), - bindSessionMemoryInfos.size(), - reinterpret_cast( bindSessionMemoryInfos.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindVideoSessionMemoryKHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - VideoSessionParametersKHR * pVideoSessionParameters, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateVideoSessionParametersKHR( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pVideoSessionParameters ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createVideoSessionParametersKHR( - const VideoSessionParametersCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateVideoSessionParametersKHR && "Function requires " ); -# endif - - VideoSessionParametersKHR videoSessionParameters; - Result result = static_cast( d.vkCreateVideoSessionParametersKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &videoSessionParameters ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" ); - - return detail::createResultValueType( result, std::move( videoSessionParameters ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateVideoSessionParametersKHR && "Function requires " ); -# endif - - VideoSessionParametersKHR videoSessionParameters; - Result result = static_cast( d.vkCreateVideoSessionParametersKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &videoSessionParameters ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createVideoSessionParametersKHRUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( videoSessionParameters, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::updateVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, - const VideoSessionParametersUpdateInfoKHR * pUpdateInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkUpdateVideoSessionParametersKHR( static_cast( m_device ), - static_cast( videoSessionParameters ), - reinterpret_cast( pUpdateInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::updateVideoSessionParametersKHR( - VideoSessionParametersKHR videoSessionParameters, const VideoSessionParametersUpdateInfoKHR & updateInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkUpdateVideoSessionParametersKHR && "Function requires " ); -# endif - - Result result = - static_cast( d.vkUpdateVideoSessionParametersKHR( m_device, - static_cast( videoSessionParameters ), - reinterpret_cast( &updateInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::updateVideoSessionParametersKHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyVideoSessionParametersKHR( static_cast( m_device ), - static_cast( videoSessionParameters ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionParametersKHR && "Function requires " ); -# endif - - d.vkDestroyVideoSessionParametersKHR( - m_device, static_cast( videoSessionParameters ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( VideoSessionParametersKHR videoSessionParameters, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyVideoSessionParametersKHR( static_cast( m_device ), - static_cast( videoSessionParameters ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( VideoSessionParametersKHR videoSessionParameters, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyVideoSessionParametersKHR && "Function requires " ); -# endif - - d.vkDestroyVideoSessionParametersKHR( - m_device, static_cast( videoSessionParameters ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR * pBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginVideoCodingKHR( static_cast( m_commandBuffer ), reinterpret_cast( pBeginInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBeginVideoCodingKHR && "Function requires " ); -# endif - - d.vkCmdBeginVideoCodingKHR( m_commandBuffer, reinterpret_cast( &beginInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR * pEndCodingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndVideoCodingKHR( static_cast( m_commandBuffer ), reinterpret_cast( pEndCodingInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdEndVideoCodingKHR && "Function requires " ); -# endif - - d.vkCmdEndVideoCodingKHR( m_commandBuffer, reinterpret_cast( &endCodingInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VideoCodingControlInfoKHR * pCodingControlInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdControlVideoCodingKHR( static_cast( m_commandBuffer ), - reinterpret_cast( pCodingControlInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdControlVideoCodingKHR && "Function requires " ); -# endif - - d.vkCmdControlVideoCodingKHR( m_commandBuffer, reinterpret_cast( &codingControlInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_video_decode_queue === - - // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR * pDecodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDecodeVideoKHR( static_cast( m_commandBuffer ), reinterpret_cast( pDecodeInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR & decodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdDecodeVideoKHR && "Function requires " ); -# endif - - d.vkCmdDecodeVideoKHR( m_commandBuffer, reinterpret_cast( &decodeInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_transform_feedback === - - // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, - uint32_t bindingCount, - const Buffer * pBuffers, - const DeviceSize * pOffsets, - const DeviceSize * pSizes, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindTransformFeedbackBuffersEXT( static_cast( m_commandBuffer ), - firstBinding, - bindingCount, - reinterpret_cast( pBuffers ), - reinterpret_cast( pOffsets ), - reinterpret_cast( pSizes ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindTransformFeedbackBuffersEXT && "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); - VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); -# else - if ( buffers.size() != offsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); - } - if ( !sizes.empty() && buffers.size() != sizes.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdBindTransformFeedbackBuffersEXT( m_commandBuffer, - firstBinding, - buffers.size(), - reinterpret_cast( buffers.data() ), - reinterpret_cast( offsets.data() ), - reinterpret_cast( sizes.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginTransformFeedbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const Buffer * pCounterBuffers, - const DeviceSize * pCounterBufferOffsets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginTransformFeedbackEXT( static_cast( m_commandBuffer ), - firstCounterBuffer, - counterBufferCount, - reinterpret_cast( pCounterBuffers ), - reinterpret_cast( pCounterBufferOffsets ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginTransformFeedbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, - ArrayProxy const & counterBuffers, - ArrayProxy const & counterBufferOffsets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBeginTransformFeedbackEXT && "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); -# else - if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdBeginTransformFeedbackEXT( m_commandBuffer, - firstCounterBuffer, - counterBuffers.size(), - reinterpret_cast( counterBuffers.data() ), - reinterpret_cast( counterBufferOffsets.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndTransformFeedbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const Buffer * pCounterBuffers, - const DeviceSize * pCounterBufferOffsets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndTransformFeedbackEXT( static_cast( m_commandBuffer ), - firstCounterBuffer, - counterBufferCount, - reinterpret_cast( pCounterBuffers ), - reinterpret_cast( pCounterBufferOffsets ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndTransformFeedbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, - ArrayProxy const & counterBuffers, - ArrayProxy const & counterBufferOffsets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdEndTransformFeedbackEXT && "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); -# else - if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdEndTransformFeedbackEXT( m_commandBuffer, - firstCounterBuffer, - counterBuffers.size(), - reinterpret_cast( counterBuffers.data() ), - reinterpret_cast( counterBufferOffsets.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( - QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginQueryIndexedEXT( - static_cast( m_commandBuffer ), static_cast( queryPool ), query, static_cast( flags ), index ); - } - - // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endQueryIndexedEXT( QueryPool queryPool, uint32_t query, uint32_t index, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndQueryIndexedEXT( static_cast( m_commandBuffer ), static_cast( queryPool ), query, index ); - } - - // wrapper function for command vkCmdDrawIndirectByteCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, - uint32_t firstInstance, - Buffer counterBuffer, - DeviceSize counterBufferOffset, - uint32_t counterOffset, - uint32_t vertexStride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawIndirectByteCountEXT( static_cast( m_commandBuffer ), - instanceCount, - firstInstance, - static_cast( counterBuffer ), - static_cast( counterBufferOffset ), - counterOffset, - vertexStride ); - } - - //=== VK_NVX_binary_import === - - // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCuModuleNVX( const CuModuleCreateInfoNVX * pCreateInfo, - const AllocationCallbacks * pAllocator, - CuModuleNVX * pModule, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateCuModuleNVX( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pModule ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createCuModuleNVX( const CuModuleCreateInfoNVX & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateCuModuleNVX && "Function requires " ); -# endif - - CuModuleNVX module; - Result result = static_cast( d.vkCreateCuModuleNVX( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &module ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVX" ); - - return detail::createResultValueType( result, std::move( module ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createCuModuleNVXUnique( const CuModuleCreateInfoNVX & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateCuModuleNVX && "Function requires " ); -# endif - - CuModuleNVX module; - Result result = static_cast( d.vkCreateCuModuleNVX( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &module ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuModuleNVXUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( module, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCuFunctionNVX( const CuFunctionCreateInfoNVX * pCreateInfo, - const AllocationCallbacks * pAllocator, - CuFunctionNVX * pFunction, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateCuFunctionNVX( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pFunction ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createCuFunctionNVX( const CuFunctionCreateInfoNVX & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateCuFunctionNVX && "Function requires " ); -# endif - - CuFunctionNVX function; - Result result = static_cast( d.vkCreateCuFunctionNVX( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &function ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVX" ); - - return detail::createResultValueType( result, std::move( function ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateCuFunctionNVX && "Function requires " ); -# endif - - CuFunctionNVX function; - Result result = static_cast( d.vkCreateCuFunctionNVX( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &function ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCuFunctionNVXUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( function, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyCuModuleNVX( CuModuleNVX module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyCuModuleNVX( - static_cast( m_device ), static_cast( module ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyCuModuleNVX( CuModuleNVX module, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyCuModuleNVX && "Function requires " ); -# endif - - d.vkDestroyCuModuleNVX( m_device, static_cast( module ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( CuModuleNVX module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyCuModuleNVX( - static_cast( m_device ), static_cast( module ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( CuModuleNVX module, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyCuModuleNVX && "Function requires " ); -# endif - - d.vkDestroyCuModuleNVX( m_device, static_cast( module ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyCuFunctionNVX( CuFunctionNVX function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyCuFunctionNVX( - static_cast( m_device ), static_cast( function ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyCuFunctionNVX( CuFunctionNVX function, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyCuFunctionNVX && "Function requires " ); -# endif - - d.vkDestroyCuFunctionNVX( m_device, static_cast( function ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( CuFunctionNVX function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyCuFunctionNVX( - static_cast( m_device ), static_cast( function ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( CuFunctionNVX function, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyCuFunctionNVX && "Function requires " ); -# endif - - d.vkDestroyCuFunctionNVX( m_device, static_cast( function ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX * pLaunchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCuLaunchKernelNVX( static_cast( m_commandBuffer ), reinterpret_cast( pLaunchInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCuLaunchKernelNVX && "Function requires " ); -# endif - - d.vkCmdCuLaunchKernelNVX( m_commandBuffer, reinterpret_cast( &launchInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NVX_image_view_handle === - - // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html - template ::type> - VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return d.vkGetImageViewHandleNVX( static_cast( m_device ), reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html - template ::type> - VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageViewHandleNVX && "Function requires " ); -# endif - - uint32_t result = d.vkGetImageViewHandleNVX( m_device, reinterpret_cast( &info ) ); - - return result; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html - template ::type> - VULKAN_HPP_INLINE uint64_t Device::getImageViewHandle64NVX( const ImageViewHandleInfoNVX * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return d.vkGetImageViewHandle64NVX( static_cast( m_device ), reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html - template ::type> - VULKAN_HPP_INLINE uint64_t Device::getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageViewHandle64NVX && "Function requires " ); -# endif - - uint64_t result = d.vkGetImageViewHandle64NVX( m_device, reinterpret_cast( &info ) ); - - return result; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageViewAddressNVX( ImageView imageView, - ImageViewAddressPropertiesNVX * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetImageViewAddressNVX( - static_cast( m_device ), static_cast( imageView ), reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getImageViewAddressNVX( ImageView imageView, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageViewAddressNVX && "Function requires " ); -# endif - - ImageViewAddressPropertiesNVX properties; - Result result = static_cast( - d.vkGetImageViewAddressNVX( m_device, static_cast( imageView ), reinterpret_cast( &properties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewAddressNVX" ); - - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html - template ::type> - VULKAN_HPP_INLINE uint64_t Device::getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex, - uint64_t samplerIndex, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return d.vkGetDeviceCombinedImageSamplerIndexNVX( static_cast( m_device ), imageViewIndex, samplerIndex ); - } - - //=== VK_AMD_draw_indirect_count === - - // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawIndirectCountAMD( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawIndexedIndirectCountAMD( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - //=== VK_AMD_shader_info === - - // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getShaderInfoAMD( Pipeline pipeline, - ShaderStageFlagBits shaderStage, - ShaderInfoTypeAMD infoType, - size_t * pInfoSize, - void * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetShaderInfoAMD( static_cast( m_device ), - static_cast( pipeline ), - static_cast( shaderStage ), - static_cast( infoType ), - pInfoSize, - pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getShaderInfoAMD( Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetShaderInfoAMD && "Function requires " ); -# endif - - std::vector info; - size_t infoSize; - Result result; - do - { - result = static_cast( d.vkGetShaderInfoAMD( m_device, - static_cast( pipeline ), - static_cast( shaderStage ), - static_cast( infoType ), - &infoSize, - nullptr ) ); - if ( ( result == Result::eSuccess ) && infoSize ) - { - info.resize( infoSize ); - result = static_cast( d.vkGetShaderInfoAMD( m_device, - static_cast( pipeline ), - static_cast( shaderStage ), - static_cast( infoType ), - &infoSize, - reinterpret_cast( info.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" ); - VULKAN_HPP_ASSERT( infoSize <= info.size() ); - if ( infoSize < info.size() ) - { - info.resize( infoSize ); - } - return detail::createResultValueType( result, std::move( info ) ); - } - - // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::getShaderInfoAMD( - Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetShaderInfoAMD && "Function requires " ); -# endif - - std::vector info( uint8_tAllocator ); - size_t infoSize; - Result result; - do - { - result = static_cast( d.vkGetShaderInfoAMD( m_device, - static_cast( pipeline ), - static_cast( shaderStage ), - static_cast( infoType ), - &infoSize, - nullptr ) ); - if ( ( result == Result::eSuccess ) && infoSize ) - { - info.resize( infoSize ); - result = static_cast( d.vkGetShaderInfoAMD( m_device, - static_cast( pipeline ), - static_cast( shaderStage ), - static_cast( infoType ), - &infoSize, - reinterpret_cast( info.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderInfoAMD" ); - VULKAN_HPP_ASSERT( infoSize <= info.size() ); - if ( infoSize < info.size() ) - { - info.resize( infoSize ); - } - return detail::createResultValueType( result, std::move( info ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_dynamic_rendering === - - // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const RenderingInfo * pRenderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginRenderingKHR( static_cast( m_commandBuffer ), reinterpret_cast( pRenderingInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const RenderingInfo & renderingInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBeginRenderingKHR && "Function requires or " ); -# endif - - d.vkCmdBeginRenderingKHR( m_commandBuffer, reinterpret_cast( &renderingInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndRenderingKHR( static_cast( m_commandBuffer ) ); - } - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - - // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateStreamDescriptorSurfaceGGP( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createStreamDescriptorSurfaceGGP( - const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateStreamDescriptorSurfaceGGP && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createStreamDescriptorSurfaceGGPUnique( - const StreamDescriptorSurfaceCreateInfoGGP & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateStreamDescriptorSurfaceGGP && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateStreamDescriptorSurfaceGGP( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGPUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, - ImageType type, - ImageTiling tiling, - ImageUsageFlags usage, - ImageCreateFlags flags, - ExternalMemoryHandleTypeFlagsNV externalHandleType, - ExternalImageFormatPropertiesNV * pExternalImageFormatProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( static_cast( m_physicalDevice ), - static_cast( format ), - static_cast( type ), - static_cast( tiling ), - static_cast( usage ), - static_cast( flags ), - static_cast( externalHandleType ), - reinterpret_cast( pExternalImageFormatProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, - ImageType type, - ImageTiling tiling, - ImageUsageFlags usage, - ImageCreateFlags flags, - ExternalMemoryHandleTypeFlagsNV externalHandleType, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV && - "Function requires " ); -# endif - - ExternalImageFormatPropertiesNV externalImageFormatProperties; - Result result = static_cast( - d.vkGetPhysicalDeviceExternalImageFormatPropertiesNV( m_physicalDevice, - static_cast( format ), - static_cast( type ), - static_cast( tiling ), - static_cast( usage ), - static_cast( flags ), - static_cast( externalHandleType ), - reinterpret_cast( &externalImageFormatProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); - - return detail::createResultValueType( result, std::move( externalImageFormatProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - - // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleNV( DeviceMemory memory, - ExternalMemoryHandleTypeFlagsNV handleType, - HANDLE * pHandle, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetMemoryWin32HandleNV( - static_cast( m_device ), static_cast( memory ), static_cast( handleType ), pHandle ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryWin32HandleNV( DeviceMemory memory, ExternalMemoryHandleTypeFlagsNV handleType, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandleNV && "Function requires " ); -# endif - - HANDLE handle; - Result result = static_cast( - d.vkGetMemoryWin32HandleNV( m_device, static_cast( memory ), static_cast( handleType ), &handle ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleNV" ); - - return detail::createResultValueType( result, std::move( handle ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_get_physical_device_properties2 === - - // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getFeatures2KHR( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceFeatures2KHR( static_cast( m_physicalDevice ), reinterpret_cast( pFeatures ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2KHR && - "Function requires or " ); -# endif - - PhysicalDeviceFeatures2 features; - d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( &features ) ); - - return features; - } - - // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFeatures2KHR && - "Function requires or " ); -# endif - - StructureChain structureChain; - PhysicalDeviceFeatures2 & features = structureChain.template get(); - d.vkGetPhysicalDeviceFeatures2KHR( m_physicalDevice, reinterpret_cast( &features ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getProperties2KHR( PhysicalDeviceProperties2 * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceProperties2KHR( static_cast( m_physicalDevice ), reinterpret_cast( pProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2KHR && - "Function requires or " ); -# endif - - PhysicalDeviceProperties2 properties; - d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( &properties ) ); - - return properties; - } - - // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceProperties2KHR && - "Function requires or " ); -# endif - - StructureChain structureChain; - PhysicalDeviceProperties2 & properties = structureChain.template get(); - d.vkGetPhysicalDeviceProperties2KHR( m_physicalDevice, reinterpret_cast( &properties ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html - template ::type> - VULKAN_HPP_INLINE void - PhysicalDevice::getFormatProperties2KHR( Format format, FormatProperties2 * pFormatProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceFormatProperties2KHR( - static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( pFormatProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2KHR( Format format, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2KHR && - "Function requires or " ); -# endif - - FormatProperties2 formatProperties; - d.vkGetPhysicalDeviceFormatProperties2KHR( - m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); - - return formatProperties; - } - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFormatProperties2KHR( Format format, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFormatProperties2KHR && - "Function requires or " ); -# endif - - StructureChain structureChain; - FormatProperties2 & formatProperties = structureChain.template get(); - d.vkGetPhysicalDeviceFormatProperties2KHR( - m_physicalDevice, static_cast( format ), reinterpret_cast( &formatProperties ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, - ImageFormatProperties2 * pImageFormatProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( pImageFormatInfo ), - reinterpret_cast( pImageFormatProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2KHR && - "Function requires or " ); -# endif - - ImageFormatProperties2 imageFormatProperties; - Result result = - static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, - reinterpret_cast( &imageFormatInfo ), - reinterpret_cast( &imageFormatProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); - - return detail::createResultValueType( result, std::move( imageFormatProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceImageFormatProperties2KHR && - "Function requires or " ); -# endif - - StructureChain structureChain; - ImageFormatProperties2 & imageFormatProperties = structureChain.template get(); - Result result = - static_cast( d.vkGetPhysicalDeviceImageFormatProperties2KHR( m_physicalDevice, - reinterpret_cast( &imageFormatInfo ), - reinterpret_cast( &imageFormatProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); - - return detail::createResultValueType( result, std::move( structureChain ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount, - QueueFamilyProperties2 * pQueueFamilyProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( - static_cast( m_physicalDevice ), pQueueFamilyPropertyCount, reinterpret_cast( pQueueFamilyProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && - "Function requires or " ); -# endif - - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( - m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - queueFamilyProperties.resize( queueFamilyPropertyCount ); - } - return queueFamilyProperties; - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator const & queueFamilyProperties2Allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && - "Function requires or " ); -# endif - - std::vector queueFamilyProperties( queueFamilyProperties2Allocator ); - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( - m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - queueFamilyProperties.resize( queueFamilyPropertyCount ); - } - return queueFamilyProperties; - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getQueueFamilyProperties2KHR( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && - "Function requires or " ); -# endif - - std::vector structureChains; - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - structureChains.resize( queueFamilyPropertyCount ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; - } - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( - m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - structureChains.resize( queueFamilyPropertyCount ); - } - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - structureChains[i].template get() = queueFamilyProperties[i]; - } - return structureChains; - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyProperties2KHR && - "Function requires or " ); -# endif - - std::vector structureChains( structureChainAllocator ); - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( m_physicalDevice, &queueFamilyPropertyCount, nullptr ); - structureChains.resize( queueFamilyPropertyCount ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; - } - d.vkGetPhysicalDeviceQueueFamilyProperties2KHR( - m_physicalDevice, &queueFamilyPropertyCount, reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - structureChains.resize( queueFamilyPropertyCount ); - } - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - structureChains[i].template get() = queueFamilyProperties[i]; - } - return structureChains; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2 * pMemoryProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceMemoryProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( pMemoryProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2KHR && - "Function requires or " ); -# endif - - PhysicalDeviceMemoryProperties2 memoryProperties; - d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); - - return memoryProperties; - } - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getMemoryProperties2KHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMemoryProperties2KHR && - "Function requires or " ); -# endif - - StructureChain structureChain; - PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get(); - d.vkGetPhysicalDeviceMemoryProperties2KHR( m_physicalDevice, reinterpret_cast( &memoryProperties ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, - uint32_t * pPropertyCount, - SparseImageFormatProperties2 * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( pFormatInfo ), - pPropertyCount, - reinterpret_cast( pProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR && - "Function requires or " ); -# endif - - std::vector properties; - uint32_t propertyCount; - d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( - m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); - properties.resize( propertyCount ); - d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, - reinterpret_cast( &formatInfo ), - &propertyCount, - reinterpret_cast( properties.data() ) ); - - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return properties; - } - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, - SparseImageFormatProperties2Allocator const & sparseImageFormatProperties2Allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR && - "Function requires or " ); -# endif - - std::vector properties( sparseImageFormatProperties2Allocator ); - uint32_t propertyCount; - d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( - m_physicalDevice, reinterpret_cast( &formatInfo ), &propertyCount, nullptr ); - properties.resize( propertyCount ); - d.vkGetPhysicalDeviceSparseImageFormatProperties2KHR( m_physicalDevice, - reinterpret_cast( &formatInfo ), - &propertyCount, - reinterpret_cast( properties.data() ) ); - - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return properties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_device_group === - - // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - PeerMemoryFeatureFlags * pPeerMemoryFeatures, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceGroupPeerMemoryFeaturesKHR( - static_cast( m_device ), heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( pPeerMemoryFeatures ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceGroupPeerMemoryFeaturesKHR && - "Function requires or " ); -# endif - - PeerMemoryFeatureFlags peerMemoryFeatures; - d.vkGetDeviceGroupPeerMemoryFeaturesKHR( - m_device, heapIndex, localDeviceIndex, remoteDeviceIndex, reinterpret_cast( &peerMemoryFeatures ) ); - - return peerMemoryFeatures; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDeviceMaskKHR( static_cast( m_commandBuffer ), deviceMask ); - } - - // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDispatchBaseKHR( static_cast( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); - } - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - - // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateViSurfaceNN( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateViSurfaceNN && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateViSurfaceNN( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNN" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateViSurfaceNN && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateViSurfaceNN( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createViSurfaceNNUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_maintenance1 === - - // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::trimCommandPoolKHR( CommandPool commandPool, CommandPoolTrimFlags flags, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkTrimCommandPoolKHR( static_cast( m_device ), static_cast( commandPool ), static_cast( flags ) ); - } - - //=== VK_KHR_device_group_creation === - - // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount, - PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( static_cast( m_instance ), - pPhysicalDeviceGroupCount, - reinterpret_cast( pPhysicalDeviceGroupProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::enumeratePhysicalDeviceGroupsKHR( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroupsKHR && - "Function requires or " ); -# endif - - std::vector physicalDeviceGroupProperties; - uint32_t physicalDeviceGroupCount; - Result result; - do - { - result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( - m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); - if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - } - return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); - } - - // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator const & physicalDeviceGroupPropertiesAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceGroupsKHR && - "Function requires or " ); -# endif - - std::vector physicalDeviceGroupProperties( physicalDeviceGroupPropertiesAllocator ); - uint32_t physicalDeviceGroupCount; - Result result; - do - { - result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( m_instance, &physicalDeviceGroupCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - result = static_cast( d.vkEnumeratePhysicalDeviceGroupsKHR( - m_instance, &physicalDeviceGroupCount, reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); - if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - } - return detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_external_memory_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, - ExternalBufferProperties * pExternalBufferProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( pExternalBufferInfo ), - reinterpret_cast( pExternalBufferProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalBufferProperties - PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalBufferPropertiesKHR && - "Function requires or " ); -# endif - - ExternalBufferProperties externalBufferProperties; - d.vkGetPhysicalDeviceExternalBufferPropertiesKHR( m_physicalDevice, - reinterpret_cast( &externalBufferInfo ), - reinterpret_cast( &externalBufferProperties ) ); - - return externalBufferProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - - // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, - HANDLE * pHandle, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetMemoryWin32HandleKHR( - static_cast( m_device ), reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandleKHR && "Function requires " ); -# endif - - HANDLE handle; - Result result = - static_cast( d.vkGetMemoryWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); - - return detail::createResultValueType( result, std::move( handle ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, - HANDLE handle, - MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetMemoryWin32HandlePropertiesKHR( static_cast( m_device ), - static_cast( handleType ), - handle, - reinterpret_cast( pMemoryWin32HandleProperties ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryWin32HandlePropertiesKHR && "Function requires " ); -# endif - - MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; - Result result = - static_cast( d.vkGetMemoryWin32HandlePropertiesKHR( m_device, - static_cast( handleType ), - handle, - reinterpret_cast( &memoryWin32HandleProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); - - return detail::createResultValueType( result, std::move( memoryWin32HandleProperties ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - - // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryFdKHR( const MemoryGetFdInfoKHR * pGetFdInfo, - int * pFd, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetMemoryFdKHR( static_cast( m_device ), reinterpret_cast( pGetFdInfo ), pFd ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryFdKHR && "Function requires " ); -# endif - - int fd; - Result result = static_cast( d.vkGetMemoryFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); - - return detail::createResultValueType( result, std::move( fd ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, - int fd, - MemoryFdPropertiesKHR * pMemoryFdProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetMemoryFdPropertiesKHR( static_cast( m_device ), - static_cast( handleType ), - fd, - reinterpret_cast( pMemoryFdProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryFdPropertiesKHR && "Function requires " ); -# endif - - MemoryFdPropertiesKHR memoryFdProperties; - Result result = static_cast( d.vkGetMemoryFdPropertiesKHR( - m_device, static_cast( handleType ), fd, reinterpret_cast( &memoryFdProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); - - return detail::createResultValueType( result, std::move( memoryFdProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_external_semaphore_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, - ExternalSemaphoreProperties * pExternalSemaphoreProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( pExternalSemaphoreInfo ), - reinterpret_cast( pExternalSemaphoreProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalSemaphoreProperties PhysicalDevice::getExternalSemaphorePropertiesKHR( - const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR && - "Function requires or " ); -# endif - - ExternalSemaphoreProperties externalSemaphoreProperties; - d.vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( m_physicalDevice, - reinterpret_cast( &externalSemaphoreInfo ), - reinterpret_cast( &externalSemaphoreProperties ) ); - - return externalSemaphoreProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - - // wrapper function for command vkImportSemaphoreWin32HandleKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreWin32HandleKHR( - const ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkImportSemaphoreWin32HandleKHR( - static_cast( m_device ), reinterpret_cast( pImportSemaphoreWin32HandleInfo ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkImportSemaphoreWin32HandleKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkImportSemaphoreWin32HandleKHR && "Function requires " ); -# endif - - Result result = static_cast( - d.vkImportSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &importSemaphoreWin32HandleInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" ); - - return detail::createResultValueType( result ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSemaphoreWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, - HANDLE * pHandle, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetSemaphoreWin32HandleKHR( - static_cast( m_device ), reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSemaphoreWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetSemaphoreWin32HandleKHR && "Function requires " ); -# endif - - HANDLE handle; - Result result = static_cast( - d.vkGetSemaphoreWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); - - return detail::createResultValueType( result, std::move( handle ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - - // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkImportSemaphoreFdKHR( static_cast( m_device ), reinterpret_cast( pImportSemaphoreFdInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkImportSemaphoreFdKHR && "Function requires " ); -# endif - - Result result = static_cast( d.vkImportSemaphoreFdKHR( m_device, reinterpret_cast( &importSemaphoreFdInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR * pGetFdInfo, - int * pFd, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetSemaphoreFdKHR( static_cast( m_device ), reinterpret_cast( pGetFdInfo ), pFd ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetSemaphoreFdKHR && "Function requires " ); -# endif - - int fd; - Result result = static_cast( d.vkGetSemaphoreFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); - - return detail::createResultValueType( result, std::move( fd ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_push_descriptor === - - // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const WriteDescriptorSet * pDescriptorWrites, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushDescriptorSetKHR( static_cast( m_commandBuffer ), - static_cast( pipelineBindPoint ), - static_cast( layout ), - set, - descriptorWriteCount, - reinterpret_cast( pDescriptorWrites ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t set, - ArrayProxy const & descriptorWrites, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetKHR && "Function requires or " ); -# endif - - d.vkCmdPushDescriptorSetKHR( m_commandBuffer, - static_cast( pipelineBindPoint ), - static_cast( layout ), - set, - descriptorWrites.size(), - reinterpret_cast( descriptorWrites.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( - DescriptorUpdateTemplate descriptorUpdateTemplate, PipelineLayout layout, uint32_t set, const void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushDescriptorSetWithTemplateKHR( static_cast( m_commandBuffer ), - static_cast( descriptorUpdateTemplate ), - static_cast( layout ), - set, - pData ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, - PipelineLayout layout, - uint32_t set, - DataType const & data, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( - d.vkCmdPushDescriptorSetWithTemplateKHR && - "Function requires or or " ); -# endif - - d.vkCmdPushDescriptorSetWithTemplateKHR( m_commandBuffer, - static_cast( descriptorUpdateTemplate ), - static_cast( layout ), - set, - reinterpret_cast( &data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_conditional_rendering === - - // wrapper function for command vkCmdBeginConditionalRenderingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginConditionalRenderingEXT( static_cast( m_commandBuffer ), - reinterpret_cast( pConditionalRenderingBegin ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginConditionalRenderingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBeginConditionalRenderingEXT && "Function requires " ); -# endif - - d.vkCmdBeginConditionalRenderingEXT( m_commandBuffer, reinterpret_cast( &conditionalRenderingBegin ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndConditionalRenderingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndConditionalRenderingEXT( static_cast( m_commandBuffer ) ); - } - - //=== VK_KHR_descriptor_update_template === - - // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - DescriptorUpdateTemplate * pDescriptorUpdateTemplate, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDescriptorUpdateTemplateKHR( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pDescriptorUpdateTemplate ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createDescriptorUpdateTemplateKHR( - const DescriptorUpdateTemplateCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplateKHR && - "Function requires or " ); -# endif - - DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = static_cast( d.vkCreateDescriptorUpdateTemplateKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &descriptorUpdateTemplate ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR" ); - - return detail::createResultValueType( result, std::move( descriptorUpdateTemplate ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDescriptorUpdateTemplateKHR && - "Function requires or " ); -# endif - - DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = static_cast( d.vkCreateDescriptorUpdateTemplateKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &descriptorUpdateTemplate ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHRUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( descriptorUpdateTemplate, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDescriptorUpdateTemplateKHR( static_cast( m_device ), - static_cast( descriptorUpdateTemplate ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDescriptorUpdateTemplateKHR && - "Function requires or " ); -# endif - - d.vkDestroyDescriptorUpdateTemplateKHR( - m_device, static_cast( descriptorUpdateTemplate ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, - DescriptorUpdateTemplate descriptorUpdateTemplate, - const void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkUpdateDescriptorSetWithTemplateKHR( static_cast( m_device ), - static_cast( descriptorSet ), - static_cast( descriptorUpdateTemplate ), - pData ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, - DescriptorUpdateTemplate descriptorUpdateTemplate, - DataType const & data, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkUpdateDescriptorSetWithTemplateKHR && - "Function requires or " ); -# endif - - d.vkUpdateDescriptorSetWithTemplateKHR( m_device, - static_cast( descriptorSet ), - static_cast( descriptorUpdateTemplate ), - reinterpret_cast( &data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_clip_space_w_scaling === - - // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, - uint32_t viewportCount, - const ViewportWScalingNV * pViewportWScalings, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetViewportWScalingNV( - static_cast( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast( pViewportWScalings ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, - ArrayProxy const & viewportWScalings, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetViewportWScalingNV && "Function requires " ); -# endif - - d.vkCmdSetViewportWScalingNV( - m_commandBuffer, firstViewport, viewportWScalings.size(), reinterpret_cast( viewportWScalings.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_direct_mode_display === - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::releaseDisplayEXT( DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkReleaseDisplayEXT( static_cast( m_physicalDevice ), static_cast( display ) ) ); - } -#else - // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::releaseDisplayEXT( DisplayKHR display, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkReleaseDisplayEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkReleaseDisplayEXT( m_physicalDevice, static_cast( display ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::releaseDisplayEXT" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - - // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireXlibDisplayEXT( Display * dpy, - DisplayKHR display, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkAcquireXlibDisplayEXT( static_cast( m_physicalDevice ), dpy, static_cast( display ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, DisplayKHR display, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAcquireXlibDisplayEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkAcquireXlibDisplayEXT( m_physicalDevice, &dpy, static_cast( display ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" ); - - return detail::createResultValueType( result ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - PhysicalDevice::getRandROutputDisplayEXT( Display * dpy, RROutput rrOutput, DisplayKHR * pDisplay, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetRandROutputDisplayEXT( static_cast( m_physicalDevice ), dpy, rrOutput, reinterpret_cast( pDisplay ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRandROutputDisplayEXT && "Function requires " ); -# endif - - DisplayKHR display; - Result result = static_cast( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast( &display ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" ); - - return detail::createResultValueType( result, std::move( display ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRandROutputDisplayEXT && "Function requires " ); -# endif - - DisplayKHR display; - Result result = static_cast( d.vkGetRandROutputDisplayEXT( m_physicalDevice, &dpy, rrOutput, reinterpret_cast( &display ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXTUnique" ); - - return detail::createResultValueType( result, UniqueHandle( display, detail::ObjectRelease( *this, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, - SurfaceCapabilities2EXT * pSurfaceCapabilities, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( static_cast( m_physicalDevice ), - static_cast( surface ), - reinterpret_cast( pSurfaceCapabilities ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT && - "Function requires " ); -# endif - - SurfaceCapabilities2EXT surfaceCapabilities; - Result result = static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2EXT( - m_physicalDevice, static_cast( surface ), reinterpret_cast( &surfaceCapabilities ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); - - return detail::createResultValueType( result, std::move( surfaceCapabilities ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_display_control === - - // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::displayPowerControlEXT( DisplayKHR display, - const DisplayPowerInfoEXT * pDisplayPowerInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkDisplayPowerControlEXT( - static_cast( m_device ), static_cast( display ), reinterpret_cast( pDisplayPowerInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::displayPowerControlEXT( DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDisplayPowerControlEXT && "Function requires " ); -# endif - - Result result = static_cast( - d.vkDisplayPowerControlEXT( m_device, static_cast( display ), reinterpret_cast( &displayPowerInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::displayPowerControlEXT" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerEventEXT( const DeviceEventInfoEXT * pDeviceEventInfo, - const AllocationCallbacks * pAllocator, - Fence * pFence, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkRegisterDeviceEventEXT( static_cast( m_device ), - reinterpret_cast( pDeviceEventInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pFence ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkRegisterDeviceEventEXT && "Function requires " ); -# endif - - Fence fence; - Result result = static_cast( d.vkRegisterDeviceEventEXT( m_device, - reinterpret_cast( &deviceEventInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &fence ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXT" ); - - return detail::createResultValueType( result, std::move( fence ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkRegisterDeviceEventEXT && "Function requires " ); -# endif - - Fence fence; - Result result = static_cast( d.vkRegisterDeviceEventEXT( m_device, - reinterpret_cast( &deviceEventInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &fence ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerEventEXTUnique" ); - - return detail::createResultValueType( result, UniqueHandle( fence, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerDisplayEventEXT( DisplayKHR display, - const DisplayEventInfoEXT * pDisplayEventInfo, - const AllocationCallbacks * pAllocator, - Fence * pFence, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkRegisterDisplayEventEXT( static_cast( m_device ), - static_cast( display ), - reinterpret_cast( pDisplayEventInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pFence ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::registerDisplayEventEXT( DisplayKHR display, - const DisplayEventInfoEXT & displayEventInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkRegisterDisplayEventEXT && "Function requires " ); -# endif - - Fence fence; - Result result = static_cast( d.vkRegisterDisplayEventEXT( m_device, - static_cast( display ), - reinterpret_cast( &displayEventInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &fence ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXT" ); - - return detail::createResultValueType( result, std::move( fence ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::registerDisplayEventEXTUnique( - DisplayKHR display, const DisplayEventInfoEXT & displayEventInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkRegisterDisplayEventEXT && "Function requires " ); -# endif - - Fence fence; - Result result = static_cast( d.vkRegisterDisplayEventEXT( m_device, - static_cast( display ), - reinterpret_cast( &displayEventInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &fence ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerDisplayEventEXTUnique" ); - - return detail::createResultValueType( result, UniqueHandle( fence, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainCounterEXT( SwapchainKHR swapchain, - SurfaceCounterFlagBitsEXT counter, - uint64_t * pCounterValue, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetSwapchainCounterEXT( - static_cast( m_device ), static_cast( swapchain ), static_cast( counter ), pCounterValue ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - ResultValue -# else - typename ResultValueType::type -# endif - Device::getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetSwapchainCounterEXT && "Function requires " ); -# endif - - uint64_t counterValue; - Result result = static_cast( - d.vkGetSwapchainCounterEXT( m_device, static_cast( swapchain ), static_cast( counter ), &counterValue ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT", { Result::eSuccess, Result::eErrorOutOfDateKHR } ); -# else - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainCounterEXT" ); -# endif - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - return ResultValue( result, std::move( counterValue ) ); -# else - return detail::createResultValueType( result, std::move( counterValue ) ); -# endif - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_GOOGLE_display_timing === - - // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, - RefreshCycleDurationGOOGLE * pDisplayTimingProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetRefreshCycleDurationGOOGLE( static_cast( m_device ), - static_cast( swapchain ), - reinterpret_cast( pDisplayTimingProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRefreshCycleDurationGOOGLE && "Function requires " ); -# endif - - RefreshCycleDurationGOOGLE displayTimingProperties; - Result result = static_cast( d.vkGetRefreshCycleDurationGOOGLE( - m_device, static_cast( swapchain ), reinterpret_cast( &displayTimingProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRefreshCycleDurationGOOGLE" ); - - return detail::createResultValueType( result, std::move( displayTimingProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPastPresentationTimingGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, - uint32_t * pPresentationTimingCount, - PastPresentationTimingGOOGLE * pPresentationTimings, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPastPresentationTimingGOOGLE( static_cast( m_device ), - static_cast( swapchain ), - pPresentationTimingCount, - reinterpret_cast( pPresentationTimings ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPastPresentationTimingGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - ResultValue> -# else - typename ResultValueType>::type -# endif - Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPastPresentationTimingGOOGLE && "Function requires " ); -# endif - - std::vector presentationTimings; - uint32_t presentationTimingCount; - Result result; - do - { - result = - static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast( swapchain ), &presentationTimingCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentationTimingCount ) - { - presentationTimings.resize( presentationTimingCount ); - result = static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, - static_cast( swapchain ), - &presentationTimingCount, - reinterpret_cast( presentationTimings.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE", { Result::eSuccess, Result::eIncomplete, Result::eErrorOutOfDateKHR } ); -# else - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" ); -# endif - - VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); - if ( presentationTimingCount < presentationTimings.size() ) - { - presentationTimings.resize( presentationTimingCount ); - } - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - return ResultValue>( result, std::move( presentationTimings ) ); -# else - return detail::createResultValueType( result, std::move( presentationTimings ) ); -# endif - } - - // wrapper function for command vkGetPastPresentationTimingGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - ResultValue> -# else - typename ResultValueType>::type -# endif - Device::getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, - PastPresentationTimingGOOGLEAllocator const & pastPresentationTimingGOOGLEAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPastPresentationTimingGOOGLE && "Function requires " ); -# endif - - std::vector presentationTimings( pastPresentationTimingGOOGLEAllocator ); - uint32_t presentationTimingCount; - Result result; - do - { - result = - static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, static_cast( swapchain ), &presentationTimingCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentationTimingCount ) - { - presentationTimings.resize( presentationTimingCount ); - result = static_cast( d.vkGetPastPresentationTimingGOOGLE( m_device, - static_cast( swapchain ), - &presentationTimingCount, - reinterpret_cast( presentationTimings.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE", { Result::eSuccess, Result::eIncomplete, Result::eErrorOutOfDateKHR } ); -# else - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPastPresentationTimingGOOGLE" ); -# endif - - VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); - if ( presentationTimingCount < presentationTimings.size() ) - { - presentationTimings.resize( presentationTimingCount ); - } - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - return ResultValue>( result, std::move( presentationTimings ) ); -# else - return detail::createResultValueType( result, std::move( presentationTimings ) ); -# endif - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_discard_rectangles === - - // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, - uint32_t discardRectangleCount, - const Rect2D * pDiscardRectangles, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDiscardRectangleEXT( - static_cast( m_commandBuffer ), firstDiscardRectangle, discardRectangleCount, reinterpret_cast( pDiscardRectangles ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, - ArrayProxy const & discardRectangles, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetDiscardRectangleEXT && "Function requires " ); -# endif - - d.vkCmdSetDiscardRectangleEXT( - m_commandBuffer, firstDiscardRectangle, discardRectangles.size(), reinterpret_cast( discardRectangles.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEnableEXT( Bool32 discardRectangleEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDiscardRectangleEnableEXT( static_cast( m_commandBuffer ), static_cast( discardRectangleEnable ) ); - } - - // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleModeEXT( DiscardRectangleModeEXT discardRectangleMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDiscardRectangleModeEXT( static_cast( m_commandBuffer ), static_cast( discardRectangleMode ) ); - } - - //=== VK_EXT_hdr_metadata === - - // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( uint32_t swapchainCount, - const SwapchainKHR * pSwapchains, - const HdrMetadataEXT * pMetadata, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkSetHdrMetadataEXT( static_cast( m_device ), - swapchainCount, - reinterpret_cast( pSwapchains ), - reinterpret_cast( pMetadata ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy const & swapchains, - ArrayProxy const & metadata, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSetHdrMetadataEXT && "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); -# else - if ( swapchains.size() != metadata.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkSetHdrMetadataEXT( m_device, - swapchains.size(), - reinterpret_cast( swapchains.data() ), - reinterpret_cast( metadata.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_create_renderpass2 === - - // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRenderPass2KHR( const RenderPassCreateInfo2 * pCreateInfo, - const AllocationCallbacks * pAllocator, - RenderPass * pRenderPass, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateRenderPass2KHR( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pRenderPass ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRenderPass2KHR && "Function requires or " ); -# endif - - RenderPass renderPass; - Result result = static_cast( d.vkCreateRenderPass2KHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &renderPass ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHR" ); - - return detail::createResultValueType( result, std::move( renderPass ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRenderPass2KHR && "Function requires or " ); -# endif - - RenderPass renderPass; - Result result = static_cast( d.vkCreateRenderPass2KHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &renderPass ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRenderPass2KHRUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( renderPass, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo * pRenderPassBegin, - const SubpassBeginInfo * pSubpassBeginInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginRenderPass2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( pRenderPassBegin ), - reinterpret_cast( pSubpassBeginInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, - const SubpassBeginInfo & subpassBeginInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBeginRenderPass2KHR && "Function requires or " ); -# endif - - d.vkCmdBeginRenderPass2KHR( - m_commandBuffer, reinterpret_cast( &renderPassBegin ), reinterpret_cast( &subpassBeginInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo * pSubpassBeginInfo, - const SubpassEndInfo * pSubpassEndInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdNextSubpass2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( pSubpassBeginInfo ), - reinterpret_cast( pSubpassEndInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo, - const SubpassEndInfo & subpassEndInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdNextSubpass2KHR && "Function requires or " ); -# endif - - d.vkCmdNextSubpass2KHR( - m_commandBuffer, reinterpret_cast( &subpassBeginInfo ), reinterpret_cast( &subpassEndInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndRenderPass2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pSubpassEndInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdEndRenderPass2KHR && "Function requires or " ); -# endif - - d.vkCmdEndRenderPass2KHR( m_commandBuffer, reinterpret_cast( &subpassEndInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_shared_presentable_image === - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetSwapchainStatusKHR( static_cast( m_device ), static_cast( swapchain ) ) ); - } -#else - // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetSwapchainStatusKHR && "Function requires " ); -# endif - - Result result = static_cast( d.vkGetSwapchainStatusKHR( m_device, static_cast( swapchain ) ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainStatusKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); -# endif - - return static_cast( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - //=== VK_KHR_external_fence_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, - ExternalFenceProperties * pExternalFenceProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceExternalFencePropertiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( pExternalFenceInfo ), - reinterpret_cast( pExternalFenceProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalFenceProperties - PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalFencePropertiesKHR && - "Function requires or " ); -# endif - - ExternalFenceProperties externalFenceProperties; - d.vkGetPhysicalDeviceExternalFencePropertiesKHR( m_physicalDevice, - reinterpret_cast( &externalFenceInfo ), - reinterpret_cast( &externalFenceProperties ) ); - - return externalFenceProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - - // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkImportFenceWin32HandleKHR( static_cast( m_device ), - reinterpret_cast( pImportFenceWin32HandleInfo ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkImportFenceWin32HandleKHR && "Function requires " ); -# endif - - Result result = static_cast( - d.vkImportFenceWin32HandleKHR( m_device, reinterpret_cast( &importFenceWin32HandleInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" ); - - return detail::createResultValueType( result ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, - HANDLE * pHandle, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetFenceWin32HandleKHR( static_cast( m_device ), reinterpret_cast( pGetWin32HandleInfo ), pHandle ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetFenceWin32HandleKHR && "Function requires " ); -# endif - - HANDLE handle; - Result result = - static_cast( d.vkGetFenceWin32HandleKHR( m_device, reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); - - return detail::createResultValueType( result, std::move( handle ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - - // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importFenceFdKHR( const ImportFenceFdInfoKHR * pImportFenceFdInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkImportFenceFdKHR( static_cast( m_device ), reinterpret_cast( pImportFenceFdInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkImportFenceFdKHR && "Function requires " ); -# endif - - Result result = static_cast( d.vkImportFenceFdKHR( m_device, reinterpret_cast( &importFenceFdInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importFenceFdKHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFenceFdKHR( const FenceGetFdInfoKHR * pGetFdInfo, - int * pFd, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetFenceFdKHR( static_cast( m_device ), reinterpret_cast( pGetFdInfo ), pFd ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetFenceFdKHR && "Function requires " ); -# endif - - int fd; - Result result = static_cast( d.vkGetFenceFdKHR( m_device, reinterpret_cast( &getFdInfo ), &fd ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFenceFdKHR" ); - - return detail::createResultValueType( result, std::move( fd ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_performance_query === - - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, - uint32_t * pCounterCount, - PerformanceCounterKHR * pCounters, - PerformanceCounterDescriptionKHR * pCounterDescriptions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( static_cast( m_physicalDevice ), - queueFamilyIndex, - pCounterCount, - reinterpret_cast( pCounters ), - reinterpret_cast( pCounterDescriptions ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html - template ::value && - std::is_same::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType, - std::vector>>::type - PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && - "Function requires " ); -# endif - - std::pair, - std::vector> - data_; - std::vector & counters = data_.first; - std::vector & counterDescriptions = data_.second; - uint32_t counterCount; - Result result; - do - { - result = static_cast( - d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); - if ( ( result == Result::eSuccess ) && counterCount ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - m_physicalDevice, - queueFamilyIndex, - &counterCount, - reinterpret_cast( counters.data() ), - reinterpret_cast( counterDescriptions.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); - VULKAN_HPP_ASSERT( counterCount <= counters.size() ); - if ( counterCount < counters.size() ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - } - return detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html - template ::value && - std::is_same::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType, - std::vector>>::type - PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( - uint32_t queueFamilyIndex, - PerformanceCounterKHRAllocator const & performanceCounterKHRAllocator, - PerformanceCounterDescriptionKHRAllocator const & performanceCounterDescriptionKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && - "Function requires " ); -# endif - - std::pair, - std::vector> - data_( - std::piecewise_construct, std::forward_as_tuple( performanceCounterKHRAllocator ), std::forward_as_tuple( performanceCounterDescriptionKHRAllocator ) ); - std::vector & counters = data_.first; - std::vector & counterDescriptions = data_.second; - uint32_t counterCount; - Result result; - do - { - result = static_cast( - d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); - if ( ( result == Result::eSuccess ) && counterCount ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - m_physicalDevice, - queueFamilyIndex, - &counterCount, - reinterpret_cast( counters.data() ), - reinterpret_cast( counterDescriptions.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); - VULKAN_HPP_ASSERT( counterCount <= counters.size() ); - if ( counterCount < counters.size() ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - } - return detail::createResultValueType( result, std::move( data_ ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, - uint32_t * pNumPasses, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( pPerformanceQueryCreateInfo ), - pNumPasses ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( - const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR && - "Function requires " ); -# endif - - uint32_t numPasses; - d.vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( - m_physicalDevice, reinterpret_cast( &performanceQueryCreateInfo ), &numPasses ); - - return numPasses; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkAcquireProfilingLockKHR( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAcquireProfilingLockKHR && "Function requires " ); -# endif - - Result result = static_cast( d.vkAcquireProfilingLockKHR( m_device, reinterpret_cast( &info ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkReleaseProfilingLockKHR( static_cast( m_device ) ); - } - - //=== VK_KHR_get_surface_capabilities2 === - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - SurfaceCapabilities2KHR * pSurfaceCapabilities, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( pSurfaceInfo ), - reinterpret_cast( pSurfaceCapabilities ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR && - "Function requires " ); -# endif - - SurfaceCapabilities2KHR surfaceCapabilities; - Result result = - static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, - reinterpret_cast( &surfaceInfo ), - reinterpret_cast( &surfaceCapabilities ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); - - return detail::createResultValueType( result, std::move( surfaceCapabilities ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR && - "Function requires " ); -# endif - - StructureChain structureChain; - SurfaceCapabilities2KHR & surfaceCapabilities = structureChain.template get(); - Result result = - static_cast( d.vkGetPhysicalDeviceSurfaceCapabilities2KHR( m_physicalDevice, - reinterpret_cast( &surfaceInfo ), - reinterpret_cast( &surfaceCapabilities ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); - - return detail::createResultValueType( result, std::move( structureChain ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - uint32_t * pSurfaceFormatCount, - SurfaceFormat2KHR * pSurfaceFormats, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( pSurfaceInfo ), - pSurfaceFormatCount, - reinterpret_cast( pSurfaceFormats ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && - "Function requires " ); -# endif - - std::vector surfaceFormats; - uint32_t surfaceFormatCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( - m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - surfaceFormats.resize( surfaceFormatCount ); - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, - reinterpret_cast( &surfaceInfo ), - &surfaceFormatCount, - reinterpret_cast( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); - if ( surfaceFormatCount < surfaceFormats.size() ) - { - surfaceFormats.resize( surfaceFormatCount ); - } - return detail::createResultValueType( result, std::move( surfaceFormats ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, - SurfaceFormat2KHRAllocator const & surfaceFormat2KHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && - "Function requires " ); -# endif - - std::vector surfaceFormats( surfaceFormat2KHRAllocator ); - uint32_t surfaceFormatCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( - m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - surfaceFormats.resize( surfaceFormatCount ); - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, - reinterpret_cast( &surfaceInfo ), - &surfaceFormatCount, - reinterpret_cast( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); - if ( surfaceFormatCount < surfaceFormats.size() ) - { - surfaceFormats.resize( surfaceFormatCount ); - } - return detail::createResultValueType( result, std::move( surfaceFormats ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && - "Function requires " ); -# endif - - std::vector structureChains; - std::vector surfaceFormats; - uint32_t surfaceFormatCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( - m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - structureChains.resize( surfaceFormatCount ); - surfaceFormats.resize( surfaceFormatCount ); - for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) - { - surfaceFormats[i].pNext = structureChains[i].template get().pNext; - } - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, - reinterpret_cast( &surfaceInfo ), - &surfaceFormatCount, - reinterpret_cast( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); - if ( surfaceFormatCount < surfaceFormats.size() ) - { - structureChains.resize( surfaceFormatCount ); - } - for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) - { - structureChains[i].template get() = surfaceFormats[i]; - } - return detail::createResultValueType( result, std::move( structureChains ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, - StructureChainAllocator & structureChainAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfaceFormats2KHR && - "Function requires " ); -# endif - - std::vector structureChains( structureChainAllocator ); - std::vector surfaceFormats; - uint32_t surfaceFormatCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( - m_physicalDevice, reinterpret_cast( &surfaceInfo ), &surfaceFormatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - structureChains.resize( surfaceFormatCount ); - surfaceFormats.resize( surfaceFormatCount ); - for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) - { - surfaceFormats[i].pNext = structureChains[i].template get().pNext; - } - result = static_cast( d.vkGetPhysicalDeviceSurfaceFormats2KHR( m_physicalDevice, - reinterpret_cast( &surfaceInfo ), - &surfaceFormatCount, - reinterpret_cast( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); - if ( surfaceFormatCount < surfaceFormats.size() ) - { - structureChains.resize( surfaceFormatCount ); - } - for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) - { - structureChains[i].template get() = surfaceFormats[i]; - } - return detail::createResultValueType( result, std::move( structureChains ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_get_display_properties2 === - - // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayProperties2KHR( uint32_t * pPropertyCount, - DisplayProperties2KHR * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( - static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayProperties2KHR( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayProperties2KHR && - "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( - d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayProperties2KHR( DisplayProperties2KHRAllocator const & displayProperties2KHRAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayProperties2KHR && - "Function requires " ); -# endif - - std::vector properties( displayProperties2KHRAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( - d.vkGetPhysicalDeviceDisplayProperties2KHR( m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount, - DisplayPlaneProperties2KHR * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( - static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPlaneProperties2KHR( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR && - "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator const & displayPlaneProperties2KHRAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR && - "Function requires " ); -# endif - - std::vector properties( displayPlaneProperties2KHRAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceDisplayPlaneProperties2KHR( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, - uint32_t * pPropertyCount, - DisplayModeProperties2KHR * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDisplayModeProperties2KHR( static_cast( m_physicalDevice ), - static_cast( display ), - pPropertyCount, - reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetDisplayModeProperties2KHR( - m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, - DisplayModeProperties2KHRAllocator const & displayModeProperties2KHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function requires " ); -# endif - - std::vector properties( displayModeProperties2KHRAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetDisplayModeProperties2KHR( - m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function requires " ); -# endif - - std::vector structureChains; - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - structureChains.resize( propertyCount ); - properties.resize( propertyCount ); - for ( uint32_t i = 0; i < propertyCount; i++ ) - { - properties[i].pNext = structureChains[i].template get().pNext; - } - result = static_cast( d.vkGetDisplayModeProperties2KHR( - m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - structureChains.resize( propertyCount ); - } - for ( uint32_t i = 0; i < propertyCount; i++ ) - { - structureChains[i].template get() = properties[i]; - } - return detail::createResultValueType( result, std::move( structureChains ) ); - } - - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayModeProperties2KHR( DisplayKHR display, StructureChainAllocator & structureChainAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDisplayModeProperties2KHR && "Function requires " ); -# endif - - std::vector structureChains( structureChainAllocator ); - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetDisplayModeProperties2KHR( m_physicalDevice, static_cast( display ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - structureChains.resize( propertyCount ); - properties.resize( propertyCount ); - for ( uint32_t i = 0; i < propertyCount; i++ ) - { - properties[i].pNext = structureChains[i].template get().pNext; - } - result = static_cast( d.vkGetDisplayModeProperties2KHR( - m_physicalDevice, static_cast( display ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayModeProperties2KHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - structureChains.resize( propertyCount ); - } - for ( uint32_t i = 0; i < propertyCount; i++ ) - { - structureChains[i].template get() = properties[i]; - } - return detail::createResultValueType( result, std::move( structureChains ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR * pDisplayPlaneInfo, - DisplayPlaneCapabilities2KHR * pCapabilities, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDisplayPlaneCapabilities2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( pDisplayPlaneInfo ), - reinterpret_cast( pCapabilities ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDisplayPlaneCapabilities2KHR && "Function requires " ); -# endif - - DisplayPlaneCapabilities2KHR capabilities; - Result result = static_cast( d.vkGetDisplayPlaneCapabilities2KHR( m_physicalDevice, - reinterpret_cast( &displayPlaneInfo ), - reinterpret_cast( &capabilities ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); - - return detail::createResultValueType( result, std::move( capabilities ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - - // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateIOSSurfaceMVK( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateIOSSurfaceMVK && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateIOSSurfaceMVK( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateIOSSurfaceMVK && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateIOSSurfaceMVK( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createIOSSurfaceMVKUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - - // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateMacOSSurfaceMVK( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateMacOSSurfaceMVK && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateMacOSSurfaceMVK( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createMacOSSurfaceMVKUnique( - const MacOSSurfaceCreateInfoMVK & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateMacOSSurfaceMVK && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateMacOSSurfaceMVK( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVKUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - - // wrapper function for command vkSetDebugUtilsObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT * pNameInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkSetDebugUtilsObjectNameEXT( static_cast( m_device ), reinterpret_cast( pNameInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetDebugUtilsObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSetDebugUtilsObjectNameEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkSetDebugUtilsObjectNameEXT( m_device, reinterpret_cast( &nameInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" ); - - return detail::createResultValueType( result ); - } - - // wrapper function for command vkSetDebugUtilsObjectNameEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name, Dispatch const & d ) const - { - VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); - // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member - VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo; - nameInfo.objectType = handle.objectType; - nameInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); - nameInfo.pObjectName = name.c_str(); - return setDebugUtilsObjectNameEXT( nameInfo, d ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT * pTagInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkSetDebugUtilsObjectTagEXT( static_cast( m_device ), reinterpret_cast( pTagInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSetDebugUtilsObjectTagEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkSetDebugUtilsObjectTagEXT( m_device, reinterpret_cast( &tagInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" ); - - return detail::createResultValueType( result ); - } - - // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::setDebugUtilsObjectTagEXT( HandleType const & handle, uint64_t name, TagType const & tag, Dispatch const & d ) const - { - VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); - // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member - VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo; - tagInfo.objectType = handle.objectType; - tagInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); - tagInfo.tagName = name; - tagInfo.tagSize = sizeof( TagType ); - tagInfo.pTag = &tag; - return setDebugUtilsObjectTagEXT( tagInfo, d ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html - template ::type> - VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkQueueBeginDebugUtilsLabelEXT( static_cast( m_queue ), reinterpret_cast( pLabelInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html - template ::type> - VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkQueueBeginDebugUtilsLabelEXT && "Function requires " ); -# endif - - d.vkQueueBeginDebugUtilsLabelEXT( m_queue, reinterpret_cast( &labelInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html - template ::type> - VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkQueueEndDebugUtilsLabelEXT( static_cast( m_queue ) ); - } - - // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html - template ::type> - VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkQueueInsertDebugUtilsLabelEXT( static_cast( m_queue ), reinterpret_cast( pLabelInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html - template ::type> - VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkQueueInsertDebugUtilsLabelEXT && "Function requires " ); -# endif - - d.vkQueueInsertDebugUtilsLabelEXT( m_queue, reinterpret_cast( &labelInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginDebugUtilsLabelEXT( static_cast( m_commandBuffer ), reinterpret_cast( pLabelInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBeginDebugUtilsLabelEXT && "Function requires " ); -# endif - - d.vkCmdBeginDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( &labelInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndDebugUtilsLabelEXT( static_cast( m_commandBuffer ) ); - } - - // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdInsertDebugUtilsLabelEXT( static_cast( m_commandBuffer ), reinterpret_cast( pLabelInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdInsertDebugUtilsLabelEXT && "Function requires " ); -# endif - - d.vkCmdInsertDebugUtilsLabelEXT( m_commandBuffer, reinterpret_cast( &labelInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - DebugUtilsMessengerEXT * pMessenger, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDebugUtilsMessengerEXT( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pMessenger ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createDebugUtilsMessengerEXT( - const DebugUtilsMessengerCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDebugUtilsMessengerEXT && "Function requires " ); -# endif - - DebugUtilsMessengerEXT messenger; - Result result = static_cast( d.vkCreateDebugUtilsMessengerEXT( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &messenger ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" ); - - return detail::createResultValueType( result, std::move( messenger ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDebugUtilsMessengerEXT && "Function requires " ); -# endif - - DebugUtilsMessengerEXT messenger; - Result result = static_cast( d.vkCreateDebugUtilsMessengerEXT( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &messenger ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXTUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( messenger, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html - template ::type> - VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDebugUtilsMessengerEXT( static_cast( m_instance ), - static_cast( messenger ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html - template ::type> - VULKAN_HPP_INLINE void Instance::destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDebugUtilsMessengerEXT && "Function requires " ); -# endif - - d.vkDestroyDebugUtilsMessengerEXT( - m_instance, static_cast( messenger ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html - template ::type> - VULKAN_HPP_INLINE void - Instance::destroy( DebugUtilsMessengerEXT messenger, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDebugUtilsMessengerEXT( static_cast( m_instance ), - static_cast( messenger ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html - template ::type> - VULKAN_HPP_INLINE void - Instance::destroy( DebugUtilsMessengerEXT messenger, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDebugUtilsMessengerEXT && "Function requires " ); -# endif - - d.vkDestroyDebugUtilsMessengerEXT( - m_instance, static_cast( messenger ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSubmitDebugUtilsMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html - template ::type> - VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - DebugUtilsMessageTypeFlagsEXT messageTypes, - const DebugUtilsMessengerCallbackDataEXT * pCallbackData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkSubmitDebugUtilsMessageEXT( static_cast( m_instance ), - static_cast( messageSeverity ), - static_cast( messageTypes ), - reinterpret_cast( pCallbackData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSubmitDebugUtilsMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html - template ::type> - VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - DebugUtilsMessageTypeFlagsEXT messageTypes, - const DebugUtilsMessengerCallbackDataEXT & callbackData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSubmitDebugUtilsMessageEXT && "Function requires " ); -# endif - - d.vkSubmitDebugUtilsMessageEXT( m_instance, - static_cast( messageSeverity ), - static_cast( messageTypes ), - reinterpret_cast( &callbackData ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer, - AndroidHardwareBufferPropertiesANDROID * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetAndroidHardwareBufferPropertiesANDROID( - static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetAndroidHardwareBufferPropertiesANDROID && - "Function requires " ); -# endif - - AndroidHardwareBufferPropertiesANDROID properties; - Result result = static_cast( - d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast( &properties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); - - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetAndroidHardwareBufferPropertiesANDROID && - "Function requires " ); -# endif - - StructureChain structureChain; - AndroidHardwareBufferPropertiesANDROID & properties = structureChain.template get(); - Result result = static_cast( - d.vkGetAndroidHardwareBufferPropertiesANDROID( m_device, &buffer, reinterpret_cast( &properties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); - - return detail::createResultValueType( result, std::move( structureChain ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID * pInfo, - struct AHardwareBuffer ** pBuffer, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetMemoryAndroidHardwareBufferANDROID( - static_cast( m_device ), reinterpret_cast( pInfo ), pBuffer ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryAndroidHardwareBufferANDROID && - "Function requires " ); -# endif - - struct AHardwareBuffer * buffer; - Result result = static_cast( - d.vkGetMemoryAndroidHardwareBufferANDROID( m_device, reinterpret_cast( &info ), &buffer ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); - - return detail::createResultValueType( result, std::move( buffer ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, - uint32_t createInfoCount, - const ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateExecutionGraphPipelinesAMDX( static_cast( m_device ), - static_cast( pipelineCache ), - createInfoCount, - reinterpret_cast( pCreateInfos ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pPipelines ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = - static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); - Result result = - static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue - Device::createExecutionGraphPipelineAMDX( PipelineCache pipelineCache, - const ExecutionGraphPipelineCreateInfoAMDX & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDX", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue( result, std::move( pipeline ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = - static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDXUnique", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines; - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = - static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDXUnique", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createExecutionGraphPipelineAMDXUnique( PipelineCache pipelineCache, - const ExecutionGraphPipelineCreateInfoAMDX & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateExecutionGraphPipelinesAMDX && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateExecutionGraphPipelinesAMDX( m_device, - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDXUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue>( - result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph, - ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetExecutionGraphPipelineScratchSizeAMDX( static_cast( m_device ), - static_cast( executionGraph ), - reinterpret_cast( pSizeInfo ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetExecutionGraphPipelineScratchSizeAMDX && - "Function requires " ); -# endif - - ExecutionGraphPipelineScratchSizeAMDX sizeInfo; - Result result = static_cast( d.vkGetExecutionGraphPipelineScratchSizeAMDX( - m_device, static_cast( executionGraph ), reinterpret_cast( &sizeInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getExecutionGraphPipelineScratchSizeAMDX" ); - - return detail::createResultValueType( result, std::move( sizeInfo ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getExecutionGraphPipelineNodeIndexAMDX( Pipeline executionGraph, - const PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo, - uint32_t * pNodeIndex, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetExecutionGraphPipelineNodeIndexAMDX( static_cast( m_device ), - static_cast( executionGraph ), - reinterpret_cast( pNodeInfo ), - pNodeIndex ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getExecutionGraphPipelineNodeIndexAMDX( Pipeline executionGraph, const PipelineShaderStageNodeCreateInfoAMDX & nodeInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetExecutionGraphPipelineNodeIndexAMDX && "Function requires " ); -# endif - - uint32_t nodeIndex; - Result result = static_cast( d.vkGetExecutionGraphPipelineNodeIndexAMDX( - m_device, static_cast( executionGraph ), reinterpret_cast( &nodeInfo ), &nodeIndex ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getExecutionGraphPipelineNodeIndexAMDX" ); - - return detail::createResultValueType( result, std::move( nodeIndex ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::initializeGraphScratchMemoryAMDX( Pipeline executionGraph, - DeviceAddress scratch, - DeviceSize scratchSize, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdInitializeGraphScratchMemoryAMDX( static_cast( m_commandBuffer ), - static_cast( executionGraph ), - static_cast( scratch ), - static_cast( scratchSize ) ); - } - - // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphAMDX( DeviceAddress scratch, - DeviceSize scratchSize, - const DispatchGraphCountInfoAMDX * pCountInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDispatchGraphAMDX( static_cast( m_commandBuffer ), - static_cast( scratch ), - static_cast( scratchSize ), - reinterpret_cast( pCountInfo ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphAMDX( DeviceAddress scratch, - DeviceSize scratchSize, - const DispatchGraphCountInfoAMDX & countInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdDispatchGraphAMDX && "Function requires " ); -# endif - - d.vkCmdDispatchGraphAMDX( m_commandBuffer, - static_cast( scratch ), - static_cast( scratchSize ), - reinterpret_cast( &countInfo ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectAMDX( DeviceAddress scratch, - DeviceSize scratchSize, - const DispatchGraphCountInfoAMDX * pCountInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDispatchGraphIndirectAMDX( static_cast( m_commandBuffer ), - static_cast( scratch ), - static_cast( scratchSize ), - reinterpret_cast( pCountInfo ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectAMDX( DeviceAddress scratch, - DeviceSize scratchSize, - const DispatchGraphCountInfoAMDX & countInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdDispatchGraphIndirectAMDX && "Function requires " ); -# endif - - d.vkCmdDispatchGraphIndirectAMDX( m_commandBuffer, - static_cast( scratch ), - static_cast( scratchSize ), - reinterpret_cast( &countInfo ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectCountAMDX( DeviceAddress scratch, - DeviceSize scratchSize, - DeviceAddress countInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDispatchGraphIndirectCountAMDX( static_cast( m_commandBuffer ), - static_cast( scratch ), - static_cast( scratchSize ), - static_cast( countInfo ) ); - } -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - - // wrapper function for command vkWriteSamplerDescriptorsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeSamplerDescriptorsEXT( uint32_t samplerCount, - const SamplerCreateInfo * pSamplers, - const HostAddressRangeEXT * pDescriptors, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkWriteSamplerDescriptorsEXT( static_cast( m_device ), - samplerCount, - reinterpret_cast( pSamplers ), - reinterpret_cast( pDescriptors ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWriteSamplerDescriptorsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::writeSamplerDescriptorsEXT( - ArrayProxy const & samplers, ArrayProxy const & descriptors, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkWriteSamplerDescriptorsEXT && "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( samplers.size() == descriptors.size() ); -# else - if ( samplers.size() != descriptors.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT: samplers.size() != descriptors.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - Result result = static_cast( d.vkWriteSamplerDescriptorsEXT( m_device, - samplers.size(), - reinterpret_cast( samplers.data() ), - reinterpret_cast( descriptors.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkWriteResourceDescriptorsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeResourceDescriptorsEXT( uint32_t resourceCount, - const ResourceDescriptorInfoEXT * pResources, - const HostAddressRangeEXT * pDescriptors, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkWriteResourceDescriptorsEXT( static_cast( m_device ), - resourceCount, - reinterpret_cast( pResources ), - reinterpret_cast( pDescriptors ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWriteResourceDescriptorsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::writeResourceDescriptorsEXT( - ArrayProxy const & resources, ArrayProxy const & descriptors, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkWriteResourceDescriptorsEXT && "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( resources.size() == descriptors.size() ); -# else - if ( resources.size() != descriptors.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT: resources.size() != descriptors.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - Result result = static_cast( d.vkWriteResourceDescriptorsEXT( m_device, - resources.size(), - reinterpret_cast( resources.data() ), - reinterpret_cast( descriptors.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindSamplerHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindSamplerHeapEXT( static_cast( m_commandBuffer ), reinterpret_cast( pBindInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindSamplerHeapEXT && "Function requires " ); -# endif - - d.vkCmdBindSamplerHeapEXT( m_commandBuffer, reinterpret_cast( &bindInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindResourceHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindResourceHeapEXT( static_cast( m_commandBuffer ), reinterpret_cast( pBindInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindResourceHeapEXT && "Function requires " ); -# endif - - d.vkCmdBindResourceHeapEXT( m_commandBuffer, reinterpret_cast( &bindInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDataEXT( const PushDataInfoEXT * pPushDataInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushDataEXT( static_cast( m_commandBuffer ), reinterpret_cast( pPushDataInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDataEXT( const PushDataInfoEXT & pushDataInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPushDataEXT && "Function requires " ); -# endif - - d.vkCmdPushDataEXT( m_commandBuffer, reinterpret_cast( &pushDataInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageOpaqueCaptureDataEXT( uint32_t imageCount, - const Image * pImages, - HostAddressRangeEXT * pDatas, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetImageOpaqueCaptureDataEXT( - static_cast( m_device ), imageCount, reinterpret_cast( pImages ), reinterpret_cast( pDatas ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getImageOpaqueCaptureDataEXT( ArrayProxy const & images, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDataEXT && "Function requires " ); -# endif - - std::vector datas( images.size() ); - Result result = static_cast( d.vkGetImageOpaqueCaptureDataEXT( - m_device, images.size(), reinterpret_cast( images.data() ), reinterpret_cast( datas.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" ); - - return detail::createResultValueType( result, std::move( datas ) ); - } - - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getImageOpaqueCaptureDataEXT( ArrayProxy const & images, - HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDataEXT && "Function requires " ); -# endif - - std::vector datas( images.size(), {}, hostAddressRangeEXTAllocator ); - Result result = static_cast( d.vkGetImageOpaqueCaptureDataEXT( - m_device, images.size(), reinterpret_cast( images.data() ), reinterpret_cast( datas.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" ); - - return detail::createResultValueType( result, std::move( datas ) ); - } - - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getImageOpaqueCaptureDataEXT( const Image & image, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDataEXT && "Function requires " ); -# endif - - HostAddressRangeEXT data; - Result result = static_cast( - d.vkGetImageOpaqueCaptureDataEXT( m_device, 1, reinterpret_cast( &image ), reinterpret_cast( &data ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html - template ::type> - VULKAN_HPP_INLINE DeviceSize PhysicalDevice::getDescriptorSizeEXT( DescriptorType descriptorType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPhysicalDeviceDescriptorSizeEXT( static_cast( m_physicalDevice ), static_cast( descriptorType ) ) ); - } - - // wrapper function for command vkRegisterCustomBorderColorEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT * pBorderColor, - Bool32 requestIndex, - uint32_t * pIndex, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkRegisterCustomBorderColorEXT( static_cast( m_device ), - reinterpret_cast( pBorderColor ), - static_cast( requestIndex ), - pIndex ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkRegisterCustomBorderColorEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT & borderColor, Bool32 requestIndex, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkRegisterCustomBorderColorEXT && "Function requires " ); -# endif - - uint32_t index; - Result result = static_cast( d.vkRegisterCustomBorderColorEXT( - m_device, reinterpret_cast( &borderColor ), static_cast( requestIndex ), &index ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::registerCustomBorderColorEXT" ); - - return detail::createResultValueType( result, std::move( index ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUnregisterCustomBorderColorEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::unregisterCustomBorderColorEXT( uint32_t index, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkUnregisterCustomBorderColorEXT( static_cast( m_device ), index ); - } - - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getTensorOpaqueCaptureDataARM( uint32_t tensorCount, - const TensorARM * pTensors, - HostAddressRangeEXT * pDatas, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetTensorOpaqueCaptureDataARM( static_cast( m_device ), - tensorCount, - reinterpret_cast( pTensors ), - reinterpret_cast( pDatas ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDataARM && "Function requires " ); -# endif - - std::vector datas( tensors.size() ); - Result result = static_cast( d.vkGetTensorOpaqueCaptureDataARM( - m_device, tensors.size(), reinterpret_cast( tensors.data() ), reinterpret_cast( datas.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" ); - - return detail::createResultValueType( result, std::move( datas ) ); - } - - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors, - HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDataARM && "Function requires " ); -# endif - - std::vector datas( tensors.size(), {}, hostAddressRangeEXTAllocator ); - Result result = static_cast( d.vkGetTensorOpaqueCaptureDataARM( - m_device, tensors.size(), reinterpret_cast( tensors.data() ), reinterpret_cast( datas.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" ); - - return detail::createResultValueType( result, std::move( datas ) ); - } - - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getTensorOpaqueCaptureDataARM( const TensorARM & tensor, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDataARM && "Function requires " ); -# endif - - HostAddressRangeEXT data; - Result result = static_cast( - d.vkGetTensorOpaqueCaptureDataARM( m_device, 1, reinterpret_cast( &tensor ), reinterpret_cast( &data ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_sample_locations === - - // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT * pSampleLocationsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetSampleLocationsEXT( static_cast( m_commandBuffer ), reinterpret_cast( pSampleLocationsInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetSampleLocationsEXT && "Function requires " ); -# endif - - d.vkCmdSetSampleLocationsEXT( m_commandBuffer, reinterpret_cast( &sampleLocationsInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, - MultisamplePropertiesEXT * pMultisampleProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceMultisamplePropertiesEXT( static_cast( m_physicalDevice ), - static_cast( samples ), - reinterpret_cast( pMultisampleProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MultisamplePropertiesEXT PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceMultisamplePropertiesEXT && - "Function requires " ); -# endif - - MultisamplePropertiesEXT multisampleProperties; - d.vkGetPhysicalDeviceMultisamplePropertiesEXT( - m_physicalDevice, static_cast( samples ), reinterpret_cast( &multisampleProperties ) ); - - return multisampleProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_get_memory_requirements2 === - - // wrapper function for command vkGetImageMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetImageMemoryRequirements2KHR( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2KHR && - "Function requires or " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetImageMemoryRequirements2KHR( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetImageMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageMemoryRequirements2KHR && - "Function requires or " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetImageMemoryRequirements2KHR( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetBufferMemoryRequirements2KHR( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2KHR && - "Function requires or " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetBufferMemoryRequirements2KHR( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetBufferMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferMemoryRequirements2KHR && - "Function requires or " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetBufferMemoryRequirements2KHR( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 * pInfo, - uint32_t * pSparseMemoryRequirementCount, - SparseImageMemoryRequirements2 * pSparseMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetImageSparseMemoryRequirements2KHR( static_cast( m_device ), - reinterpret_cast( pInfo ), - pSparseMemoryRequirementCount, - reinterpret_cast( pSparseMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html - template < - typename SparseImageMemoryRequirements2Allocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2KHR && - "Function requires or " ); -# endif - - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - d.vkGetImageSparseMemoryRequirements2KHR( - m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetImageSparseMemoryRequirements2KHR( m_device, - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } - - // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html - template < - typename SparseImageMemoryRequirements2Allocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, - SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageSparseMemoryRequirements2KHR && - "Function requires or " ); -# endif - - std::vector sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator ); - uint32_t sparseMemoryRequirementCount; - d.vkGetImageSparseMemoryRequirements2KHR( - m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetImageSparseMemoryRequirements2KHR( m_device, - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_acceleration_structure === - - // wrapper function for command vkCreateAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - AccelerationStructureKHR * pAccelerationStructure, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateAccelerationStructureKHR( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pAccelerationStructure ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createAccelerationStructureKHR( - const AccelerationStructureCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureKHR && "Function requires " ); -# endif - - AccelerationStructureKHR accelerationStructure; - Result result = static_cast( d.vkCreateAccelerationStructureKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &accelerationStructure ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" ); - - return detail::createResultValueType( result, std::move( accelerationStructure ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureKHR && "Function requires " ); -# endif - - AccelerationStructureKHR accelerationStructure; - Result result = static_cast( d.vkCreateAccelerationStructureKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &accelerationStructure ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureKHRUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( accelerationStructure, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyAccelerationStructureKHR( static_cast( m_device ), - static_cast( accelerationStructure ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureKHR && "Function requires " ); -# endif - - d.vkDestroyAccelerationStructureKHR( - m_device, static_cast( accelerationStructure ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( AccelerationStructureKHR accelerationStructure, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyAccelerationStructureKHR( static_cast( m_device ), - static_cast( accelerationStructure ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureKHR accelerationStructure, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureKHR && "Function requires " ); -# endif - - d.vkDestroyAccelerationStructureKHR( - m_device, static_cast( accelerationStructure ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresKHR( uint32_t infoCount, - const AccelerationStructureBuildGeometryInfoKHR * pInfos, - const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBuildAccelerationStructuresKHR( static_cast( m_commandBuffer ), - infoCount, - reinterpret_cast( pInfos ), - reinterpret_cast( ppBuildRangeInfos ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::buildAccelerationStructuresKHR( ArrayProxy const & infos, - ArrayProxy const & pBuildRangeInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructuresKHR && "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); -# else - if ( infos.size() != pBuildRangeInfos.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdBuildAccelerationStructuresKHR( m_commandBuffer, - infos.size(), - reinterpret_cast( infos.data() ), - reinterpret_cast( pBuildRangeInfos.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( uint32_t infoCount, - const AccelerationStructureBuildGeometryInfoKHR * pInfos, - const DeviceAddress * pIndirectDeviceAddresses, - const uint32_t * pIndirectStrides, - const uint32_t * const * ppMaxPrimitiveCounts, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBuildAccelerationStructuresIndirectKHR( static_cast( m_commandBuffer ), - infoCount, - reinterpret_cast( pInfos ), - reinterpret_cast( pIndirectDeviceAddresses ), - pIndirectStrides, - ppMaxPrimitiveCounts ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( ArrayProxy const & infos, - ArrayProxy const & indirectDeviceAddresses, - ArrayProxy const & indirectStrides, - ArrayProxy const & pMaxPrimitiveCounts, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructuresIndirectKHR && - "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() ); - VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() ); - VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() ); -# else - if ( infos.size() != indirectDeviceAddresses.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" ); - } - if ( infos.size() != indirectStrides.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" ); - } - if ( infos.size() != pMaxPrimitiveCounts.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdBuildAccelerationStructuresIndirectKHR( m_commandBuffer, - infos.size(), - reinterpret_cast( infos.data() ), - reinterpret_cast( indirectDeviceAddresses.data() ), - indirectStrides.data(), - pMaxPrimitiveCounts.data() ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation, - uint32_t infoCount, - const AccelerationStructureBuildGeometryInfoKHR * pInfos, - const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkBuildAccelerationStructuresKHR( static_cast( m_device ), - static_cast( deferredOperation ), - infoCount, - reinterpret_cast( pInfos ), - reinterpret_cast( ppBuildRangeInfos ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation, - ArrayProxy const & infos, - ArrayProxy const & pBuildRangeInfos, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBuildAccelerationStructuresKHR && "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); -# else - if ( infos.size() != pBuildRangeInfos.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - Result result = static_cast( - d.vkBuildAccelerationStructuresKHR( m_device, - static_cast( deferredOperation ), - infos.size(), - reinterpret_cast( infos.data() ), - reinterpret_cast( pBuildRangeInfos.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureInfoKHR * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCopyAccelerationStructureKHR( static_cast( m_device ), - static_cast( deferredOperation ), - reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureInfoKHR & info, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyAccelerationStructureKHR && "Function requires " ); -# endif - - Result result = static_cast( d.vkCopyAccelerationStructureKHR( - m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureToMemoryInfoKHR * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCopyAccelerationStructureToMemoryKHR( static_cast( m_device ), - static_cast( deferredOperation ), - reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureToMemoryInfoKHR & info, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyAccelerationStructureToMemoryKHR && - "Function requires " ); -# endif - - Result result = static_cast( d.vkCopyAccelerationStructureToMemoryKHR( - m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation, - const CopyMemoryToAccelerationStructureInfoKHR * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCopyMemoryToAccelerationStructureKHR( static_cast( m_device ), - static_cast( deferredOperation ), - reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation, - const CopyMemoryToAccelerationStructureInfoKHR & info, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyMemoryToAccelerationStructureKHR && - "Function requires " ); -# endif - - Result result = static_cast( d.vkCopyMemoryToAccelerationStructureKHR( - m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, - const AccelerationStructureKHR * pAccelerationStructures, - QueryType queryType, - size_t dataSize, - void * pData, - size_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkWriteAccelerationStructuresPropertiesKHR( static_cast( m_device ), - accelerationStructureCount, - reinterpret_cast( pAccelerationStructures ), - static_cast( queryType ), - dataSize, - pData, - stride ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::writeAccelerationStructuresPropertiesKHR( - ArrayProxy const & accelerationStructures, QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkWriteAccelerationStructuresPropertiesKHR && - "Function requires " ); -# endif - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = - static_cast( d.vkWriteAccelerationStructuresPropertiesKHR( m_device, - accelerationStructures.size(), - reinterpret_cast( accelerationStructures.data() ), - static_cast( queryType ), - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ), - stride ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); - - return detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::writeAccelerationStructuresPropertyKHR( - ArrayProxy const & accelerationStructures, QueryType queryType, size_t stride, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkWriteAccelerationStructuresPropertiesKHR && - "Function requires " ); -# endif - - DataType data; - Result result = - static_cast( d.vkWriteAccelerationStructuresPropertiesKHR( m_device, - accelerationStructures.size(), - reinterpret_cast( accelerationStructures.data() ), - static_cast( queryType ), - sizeof( DataType ), - reinterpret_cast( &data ), - stride ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyAccelerationStructureKHR( static_cast( m_commandBuffer ), - reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyAccelerationStructureKHR && "Function requires " ); -# endif - - d.vkCmdCopyAccelerationStructureKHR( m_commandBuffer, reinterpret_cast( &info ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyAccelerationStructureToMemoryKHR( static_cast( m_commandBuffer ), - reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyAccelerationStructureToMemoryKHR && - "Function requires " ); -# endif - - d.vkCmdCopyAccelerationStructureToMemoryKHR( m_commandBuffer, reinterpret_cast( &info ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyMemoryToAccelerationStructureKHR( static_cast( m_commandBuffer ), - reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToAccelerationStructureKHR && - "Function requires " ); -# endif - - d.vkCmdCopyMemoryToAccelerationStructureKHR( m_commandBuffer, reinterpret_cast( &info ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html - template ::type> - VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetAccelerationStructureDeviceAddressKHR( - static_cast( m_device ), reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html - template ::type> - VULKAN_HPP_INLINE DeviceAddress Device::getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureDeviceAddressKHR && - "Function requires " ); -# endif - - VkDeviceAddress result = - d.vkGetAccelerationStructureDeviceAddressKHR( m_device, reinterpret_cast( &info ) ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, - const AccelerationStructureKHR * pAccelerationStructures, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdWriteAccelerationStructuresPropertiesKHR( static_cast( m_commandBuffer ), - accelerationStructureCount, - reinterpret_cast( pAccelerationStructures ), - static_cast( queryType ), - static_cast( queryPool ), - firstQuery ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdWriteAccelerationStructuresPropertiesKHR && - "Function requires " ); -# endif - - d.vkCmdWriteAccelerationStructuresPropertiesKHR( m_commandBuffer, - accelerationStructures.size(), - reinterpret_cast( accelerationStructures.data() ), - static_cast( queryType ), - static_cast( queryPool ), - firstQuery ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR * pVersionInfo, - AccelerationStructureCompatibilityKHR * pCompatibility, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceAccelerationStructureCompatibilityKHR( static_cast( m_device ), - reinterpret_cast( pVersionInfo ), - reinterpret_cast( pCompatibility ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureCompatibilityKHR - Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceAccelerationStructureCompatibilityKHR && - "Function requires " ); -# endif - - AccelerationStructureCompatibilityKHR compatibility; - d.vkGetDeviceAccelerationStructureCompatibilityKHR( m_device, - reinterpret_cast( &versionInfo ), - reinterpret_cast( &compatibility ) ); - - return compatibility; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, - const AccelerationStructureBuildGeometryInfoKHR * pBuildInfo, - const uint32_t * pMaxPrimitiveCounts, - AccelerationStructureBuildSizesInfoKHR * pSizeInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetAccelerationStructureBuildSizesKHR( static_cast( m_device ), - static_cast( buildType ), - reinterpret_cast( pBuildInfo ), - pMaxPrimitiveCounts, - reinterpret_cast( pSizeInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR - Device::getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, - const AccelerationStructureBuildGeometryInfoKHR & buildInfo, - ArrayProxy const & maxPrimitiveCounts, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureBuildSizesKHR && - "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( maxPrimitiveCounts.size() == buildInfo.geometryCount ); -# else - if ( maxPrimitiveCounts.size() != buildInfo.geometryCount ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - AccelerationStructureBuildSizesInfoKHR sizeInfo; - d.vkGetAccelerationStructureBuildSizesKHR( m_device, - static_cast( buildType ), - reinterpret_cast( &buildInfo ), - maxPrimitiveCounts.data(), - reinterpret_cast( &sizeInfo ) ); - - return sizeInfo; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_ray_tracing_pipeline === - - // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, - const StridedDeviceAddressRegionKHR * pMissShaderBindingTable, - const StridedDeviceAddressRegionKHR * pHitShaderBindingTable, - const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, - uint32_t width, - uint32_t height, - uint32_t depth, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdTraceRaysKHR( static_cast( m_commandBuffer ), - reinterpret_cast( pRaygenShaderBindingTable ), - reinterpret_cast( pMissShaderBindingTable ), - reinterpret_cast( pHitShaderBindingTable ), - reinterpret_cast( pCallableShaderBindingTable ), - width, - height, - depth ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, - const StridedDeviceAddressRegionKHR & missShaderBindingTable, - const StridedDeviceAddressRegionKHR & hitShaderBindingTable, - const StridedDeviceAddressRegionKHR & callableShaderBindingTable, - uint32_t width, - uint32_t height, - uint32_t depth, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdTraceRaysKHR && "Function requires " ); -# endif - - d.vkCmdTraceRaysKHR( m_commandBuffer, - reinterpret_cast( &raygenShaderBindingTable ), - reinterpret_cast( &missShaderBindingTable ), - reinterpret_cast( &hitShaderBindingTable ), - reinterpret_cast( &callableShaderBindingTable ), - width, - height, - depth ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - uint32_t createInfoCount, - const RayTracingPipelineCreateInfoKHR * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateRayTracingPipelinesKHR( static_cast( m_device ), - static_cast( deferredOperation ), - static_cast( pipelineCache ), - createInfoCount, - reinterpret_cast( pCreateInfos ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pPipelines ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); - Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::createRayTracingPipelineKHR( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - const RayTracingPipelineCreateInfoKHR & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue( result, std::move( pipeline ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines; - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHRUnique", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createRayTracingPipelineKHRUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - const RayTracingPipelineCreateInfoKHR & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesKHR && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateRayTracingPipelinesKHR( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineKHRUnique", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue>( - result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesKHR( - Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetRayTracingShaderGroupHandlesKHR( - static_cast( m_device ), static_cast( pipeline ), firstGroup, groupCount, dataSize, pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getRayTracingShaderGroupHandlesKHR( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesKHR && - "Function requires or " ); -# endif - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesKHR( - m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesKHR" ); - - return detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getRayTracingShaderGroupHandleKHR( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesKHR && - "Function requires or " ); -# endif - - DataType data; - Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesKHR( - m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleKHR" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( - Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( - static_cast( m_device ), static_cast( pipeline ), firstGroup, groupCount, dataSize, pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getRayTracingCaptureReplayShaderGroupHandlesKHR( - Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && - "Function requires " ); -# endif - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( - m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); - - return detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getRayTracingCaptureReplayShaderGroupHandleKHR( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && - "Function requires " ); -# endif - - DataType data; - Result result = static_cast( d.vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( - m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingCaptureReplayShaderGroupHandleKHR" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, - const StridedDeviceAddressRegionKHR * pMissShaderBindingTable, - const StridedDeviceAddressRegionKHR * pHitShaderBindingTable, - const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, - DeviceAddress indirectDeviceAddress, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdTraceRaysIndirectKHR( static_cast( m_commandBuffer ), - reinterpret_cast( pRaygenShaderBindingTable ), - reinterpret_cast( pMissShaderBindingTable ), - reinterpret_cast( pHitShaderBindingTable ), - reinterpret_cast( pCallableShaderBindingTable ), - static_cast( indirectDeviceAddress ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, - const StridedDeviceAddressRegionKHR & missShaderBindingTable, - const StridedDeviceAddressRegionKHR & hitShaderBindingTable, - const StridedDeviceAddressRegionKHR & callableShaderBindingTable, - DeviceAddress indirectDeviceAddress, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdTraceRaysIndirectKHR && "Function requires " ); -# endif - - d.vkCmdTraceRaysIndirectKHR( m_commandBuffer, - reinterpret_cast( &raygenShaderBindingTable ), - reinterpret_cast( &missShaderBindingTable ), - reinterpret_cast( &hitShaderBindingTable ), - reinterpret_cast( &callableShaderBindingTable ), - static_cast( indirectDeviceAddress ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html - template ::type> - VULKAN_HPP_INLINE DeviceSize Device::getRayTracingShaderGroupStackSizeKHR( Pipeline pipeline, - uint32_t group, - ShaderGroupShaderKHR groupShader, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetRayTracingShaderGroupStackSizeKHR( - static_cast( m_device ), static_cast( pipeline ), group, static_cast( groupShader ) ) ); - } - - // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetRayTracingPipelineStackSizeKHR( static_cast( m_commandBuffer ), pipelineStackSize ); - } - - //=== VK_KHR_sampler_ycbcr_conversion === - - // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - SamplerYcbcrConversion * pYcbcrConversion, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateSamplerYcbcrConversionKHR( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pYcbcrConversion ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createSamplerYcbcrConversionKHR( - const SamplerYcbcrConversionCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversionKHR && - "Function requires or " ); -# endif - - SamplerYcbcrConversion ycbcrConversion; - Result result = static_cast( d.vkCreateSamplerYcbcrConversionKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &ycbcrConversion ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" ); - - return detail::createResultValueType( result, std::move( ycbcrConversion ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSamplerYcbcrConversionKHR && - "Function requires or " ); -# endif - - SamplerYcbcrConversion ycbcrConversion; - Result result = static_cast( d.vkCreateSamplerYcbcrConversionKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &ycbcrConversion ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHRUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( ycbcrConversion, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroySamplerYcbcrConversionKHR( static_cast( m_device ), - static_cast( ycbcrConversion ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroySamplerYcbcrConversionKHR && - "Function requires or " ); -# endif - - d.vkDestroySamplerYcbcrConversionKHR( - m_device, static_cast( ycbcrConversion ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_bind_memory2 === - - // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindBufferMemory2KHR( uint32_t bindInfoCount, - const BindBufferMemoryInfo * pBindInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkBindBufferMemory2KHR( static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::bindBufferMemory2KHR( ArrayProxy const & bindInfos, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBindBufferMemory2KHR && "Function requires or " ); -# endif - - Result result = - static_cast( d.vkBindBufferMemory2KHR( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindImageMemory2KHR( uint32_t bindInfoCount, - const BindImageMemoryInfo * pBindInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkBindImageMemory2KHR( static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::bindImageMemory2KHR( ArrayProxy const & bindInfos, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBindImageMemory2KHR && "Function requires or " ); -# endif - - Result result = - static_cast( d.vkBindImageMemory2KHR( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindImageMemory2KHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_image_drm_format_modifier === - - // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageDrmFormatModifierPropertiesEXT( Image image, - ImageDrmFormatModifierPropertiesEXT * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetImageDrmFormatModifierPropertiesEXT( - static_cast( m_device ), static_cast( image ), reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageDrmFormatModifierPropertiesEXT && - "Function requires " ); -# endif - - ImageDrmFormatModifierPropertiesEXT properties; - Result result = static_cast( d.vkGetImageDrmFormatModifierPropertiesEXT( - m_device, static_cast( image ), reinterpret_cast( &properties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageDrmFormatModifierPropertiesEXT" ); - - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_validation_cache === - - // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - ValidationCacheEXT * pValidationCache, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateValidationCacheEXT( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pValidationCache ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateValidationCacheEXT && "Function requires " ); -# endif - - ValidationCacheEXT validationCache; - Result result = static_cast( d.vkCreateValidationCacheEXT( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &validationCache ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXT" ); - - return detail::createResultValueType( result, std::move( validationCache ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::createValidationCacheEXTUnique( - const ValidationCacheCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateValidationCacheEXT && "Function requires " ); -# endif - - ValidationCacheEXT validationCache; - Result result = static_cast( d.vkCreateValidationCacheEXT( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &validationCache ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createValidationCacheEXTUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( validationCache, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyValidationCacheEXT( - static_cast( m_device ), static_cast( validationCache ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyValidationCacheEXT( ValidationCacheEXT validationCache, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyValidationCacheEXT && "Function requires " ); -# endif - - d.vkDestroyValidationCacheEXT( - m_device, static_cast( validationCache ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( ValidationCacheEXT validationCache, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyValidationCacheEXT( - static_cast( m_device ), static_cast( validationCache ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( ValidationCacheEXT validationCache, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyValidationCacheEXT && "Function requires " ); -# endif - - d.vkDestroyValidationCacheEXT( - m_device, static_cast( validationCache ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, - uint32_t srcCacheCount, - const ValidationCacheEXT * pSrcCaches, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkMergeValidationCachesEXT( static_cast( m_device ), - static_cast( dstCache ), - srcCacheCount, - reinterpret_cast( pSrcCaches ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::mergeValidationCachesEXT( ValidationCacheEXT dstCache, ArrayProxy const & srcCaches, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkMergeValidationCachesEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkMergeValidationCachesEXT( - m_device, static_cast( dstCache ), srcCaches.size(), reinterpret_cast( srcCaches.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mergeValidationCachesEXT" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, size_t * pDataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetValidationCacheDataEXT( static_cast( m_device ), static_cast( validationCache ), pDataSize, pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetValidationCacheDataEXT && "Function requires " ); -# endif - - std::vector data; - size_t dataSize; - Result result; - do - { - result = static_cast( d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( - d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" ); - VULKAN_HPP_ASSERT( dataSize <= data.size() ); - if ( dataSize < data.size() ) - { - data.resize( dataSize ); - } - return detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getValidationCacheDataEXT( ValidationCacheEXT validationCache, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetValidationCacheDataEXT && "Function requires " ); -# endif - - std::vector data( uint8_tAllocator ); - size_t dataSize; - Result result; - do - { - result = static_cast( d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( - d.vkGetValidationCacheDataEXT( m_device, static_cast( validationCache ), &dataSize, reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getValidationCacheDataEXT" ); - VULKAN_HPP_ASSERT( dataSize <= data.size() ); - if ( dataSize < data.size() ) - { - data.resize( dataSize ); - } - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_shading_rate_image === - - // wrapper function for command vkCmdBindShadingRateImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( ImageView imageView, ImageLayout imageLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindShadingRateImageNV( - static_cast( m_commandBuffer ), static_cast( imageView ), static_cast( imageLayout ) ); - } - - // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, - uint32_t viewportCount, - const ShadingRatePaletteNV * pShadingRatePalettes, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetViewportShadingRatePaletteNV( - static_cast( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast( pShadingRatePalettes ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, - ArrayProxy const & shadingRatePalettes, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetViewportShadingRatePaletteNV && "Function requires " ); -# endif - - d.vkCmdSetViewportShadingRatePaletteNV( - m_commandBuffer, firstViewport, shadingRatePalettes.size(), reinterpret_cast( shadingRatePalettes.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, - uint32_t customSampleOrderCount, - const CoarseSampleOrderCustomNV * pCustomSampleOrders, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetCoarseSampleOrderNV( static_cast( m_commandBuffer ), - static_cast( sampleOrderType ), - customSampleOrderCount, - reinterpret_cast( pCustomSampleOrders ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, - ArrayProxy const & customSampleOrders, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetCoarseSampleOrderNV && "Function requires " ); -# endif - - d.vkCmdSetCoarseSampleOrderNV( m_commandBuffer, - static_cast( sampleOrderType ), - customSampleOrders.size(), - reinterpret_cast( customSampleOrders.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_ray_tracing === - - // wrapper function for command vkCreateAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createAccelerationStructureNV( const AccelerationStructureCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - AccelerationStructureNV * pAccelerationStructure, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateAccelerationStructureNV( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pAccelerationStructure ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createAccelerationStructureNV( - const AccelerationStructureCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureNV && "Function requires " ); -# endif - - AccelerationStructureNV accelerationStructure; - Result result = static_cast( d.vkCreateAccelerationStructureNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &accelerationStructure ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNV" ); - - return detail::createResultValueType( result, std::move( accelerationStructure ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateAccelerationStructureNV && "Function requires " ); -# endif - - AccelerationStructureNV accelerationStructure; - Result result = static_cast( d.vkCreateAccelerationStructureNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &accelerationStructure ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createAccelerationStructureNVUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( accelerationStructure, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyAccelerationStructureNV( static_cast( m_device ), - static_cast( accelerationStructure ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureNV && "Function requires " ); -# endif - - d.vkDestroyAccelerationStructureNV( - m_device, static_cast( accelerationStructure ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( AccelerationStructureNV accelerationStructure, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyAccelerationStructureNV( static_cast( m_device ), - static_cast( accelerationStructure ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( AccelerationStructureNV accelerationStructure, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyAccelerationStructureNV && "Function requires " ); -# endif - - d.vkDestroyAccelerationStructureNV( - m_device, static_cast( accelerationStructure ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html - template ::type> - VULKAN_HPP_INLINE void Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV * pInfo, - MemoryRequirements2KHR * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetAccelerationStructureMemoryRequirementsNV( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2KHR Device::getAccelerationStructureMemoryRequirementsNV( - const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureMemoryRequirementsNV && - "Function requires " ); -# endif - - MemoryRequirements2KHR memoryRequirements; - d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureMemoryRequirementsNV && - "Function requires " ); -# endif - - StructureChain structureChain; - MemoryRequirements2KHR & memoryRequirements = structureChain.template get(); - d.vkGetAccelerationStructureMemoryRequirementsNV( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindAccelerationStructureMemoryNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, - const BindAccelerationStructureMemoryInfoNV * pBindInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkBindAccelerationStructureMemoryNV( - static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindAccelerationStructureMemoryNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::bindAccelerationStructureMemoryNV( ArrayProxy const & bindInfos, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBindAccelerationStructureMemoryNV && "Function requires " ); -# endif - - Result result = static_cast( d.vkBindAccelerationStructureMemoryNV( - m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBuildAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV * pInfo, - Buffer instanceData, - DeviceSize instanceOffset, - Bool32 update, - AccelerationStructureNV dst, - AccelerationStructureNV src, - Buffer scratch, - DeviceSize scratchOffset, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBuildAccelerationStructureNV( static_cast( m_commandBuffer ), - reinterpret_cast( pInfo ), - static_cast( instanceData ), - static_cast( instanceOffset ), - static_cast( update ), - static_cast( dst ), - static_cast( src ), - static_cast( scratch ), - static_cast( scratchOffset ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, - Buffer instanceData, - DeviceSize instanceOffset, - Bool32 update, - AccelerationStructureNV dst, - AccelerationStructureNV src, - Buffer scratch, - DeviceSize scratchOffset, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBuildAccelerationStructureNV && "Function requires " ); -# endif - - d.vkCmdBuildAccelerationStructureNV( m_commandBuffer, - reinterpret_cast( &info ), - static_cast( instanceData ), - static_cast( instanceOffset ), - static_cast( update ), - static_cast( dst ), - static_cast( src ), - static_cast( scratch ), - static_cast( scratchOffset ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( AccelerationStructureNV dst, - AccelerationStructureNV src, - CopyAccelerationStructureModeKHR mode, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyAccelerationStructureNV( static_cast( m_commandBuffer ), - static_cast( dst ), - static_cast( src ), - static_cast( mode ) ); - } - - // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( Buffer raygenShaderBindingTableBuffer, - DeviceSize raygenShaderBindingOffset, - Buffer missShaderBindingTableBuffer, - DeviceSize missShaderBindingOffset, - DeviceSize missShaderBindingStride, - Buffer hitShaderBindingTableBuffer, - DeviceSize hitShaderBindingOffset, - DeviceSize hitShaderBindingStride, - Buffer callableShaderBindingTableBuffer, - DeviceSize callableShaderBindingOffset, - DeviceSize callableShaderBindingStride, - uint32_t width, - uint32_t height, - uint32_t depth, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdTraceRaysNV( static_cast( m_commandBuffer ), - static_cast( raygenShaderBindingTableBuffer ), - static_cast( raygenShaderBindingOffset ), - static_cast( missShaderBindingTableBuffer ), - static_cast( missShaderBindingOffset ), - static_cast( missShaderBindingStride ), - static_cast( hitShaderBindingTableBuffer ), - static_cast( hitShaderBindingOffset ), - static_cast( hitShaderBindingStride ), - static_cast( callableShaderBindingTableBuffer ), - static_cast( callableShaderBindingOffset ), - static_cast( callableShaderBindingStride ), - width, - height, - depth ); - } - - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, - uint32_t createInfoCount, - const RayTracingPipelineCreateInfoNV * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateRayTracingPipelinesNV( static_cast( m_device ), - static_cast( pipelineCache ), - createInfoCount, - reinterpret_cast( pCreateInfos ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pPipelines ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createRayTracingPipelinesNV( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); - Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::createRayTracingPipelineNV( PipelineCache pipelineCache, - const RayTracingPipelineCreateInfoNV & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNV", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue( result, std::move( pipeline ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines; - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelinesNVUnique", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::createRayTracingPipelineNVUnique( - PipelineCache pipelineCache, const RayTracingPipelineCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateRayTracingPipelinesNV && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateRayTracingPipelinesNV( m_device, - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::createRayTracingPipelineNVUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue>( - result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getRayTracingShaderGroupHandlesNV( - Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetRayTracingShaderGroupHandlesNV( - static_cast( m_device ), static_cast( pipeline ), firstGroup, groupCount, dataSize, pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getRayTracingShaderGroupHandlesNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesNV && - "Function requires or " ); -# endif - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesNV( - m_device, static_cast( pipeline ), firstGroup, groupCount, data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandlesNV" ); - - return detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getRayTracingShaderGroupHandleNV( Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRayTracingShaderGroupHandlesNV && - "Function requires or " ); -# endif - - DataType data; - Result result = static_cast( d.vkGetRayTracingShaderGroupHandlesNV( - m_device, static_cast( pipeline ), firstGroup, groupCount, sizeof( DataType ), reinterpret_cast( &data ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getRayTracingShaderGroupHandleNV" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetAccelerationStructureHandleNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, - size_t dataSize, - void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetAccelerationStructureHandleNV( - static_cast( m_device ), static_cast( accelerationStructure ), dataSize, pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAccelerationStructureHandleNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureHandleNV && "Function requires " ); -# endif - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( d.vkGetAccelerationStructureHandleNV( - m_device, static_cast( accelerationStructure ), data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); - - return detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetAccelerationStructureHandleNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureHandleNV && "Function requires " ); -# endif - - DataType data; - Result result = static_cast( d.vkGetAccelerationStructureHandleNV( - m_device, static_cast( accelerationStructure ), sizeof( DataType ), reinterpret_cast( &data ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureHandleNV" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, - const AccelerationStructureNV * pAccelerationStructures, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdWriteAccelerationStructuresPropertiesNV( static_cast( m_commandBuffer ), - accelerationStructureCount, - reinterpret_cast( pAccelerationStructures ), - static_cast( queryType ), - static_cast( queryPool ), - firstQuery ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy const & accelerationStructures, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdWriteAccelerationStructuresPropertiesNV && - "Function requires " ); -# endif - - d.vkCmdWriteAccelerationStructuresPropertiesNV( m_commandBuffer, - accelerationStructures.size(), - reinterpret_cast( accelerationStructures.data() ), - static_cast( queryType ), - static_cast( queryPool ), - firstQuery ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCompileDeferredNV( static_cast( m_device ), static_cast( pipeline ), shader ) ); - } -#else - // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCompileDeferredNV && "Function requires " ); -# endif - - Result result = static_cast( d.vkCompileDeferredNV( m_device, static_cast( pipeline ), shader ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::compileDeferredNV" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - //=== VK_KHR_maintenance3 === - - // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo * pCreateInfo, - DescriptorSetLayoutSupport * pSupport, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDescriptorSetLayoutSupportKHR( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pSupport ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutSupport Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupportKHR && - "Function requires or " ); -# endif - - DescriptorSetLayoutSupport support; - d.vkGetDescriptorSetLayoutSupportKHR( - m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); - - return support; - } - - // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSupportKHR && - "Function requires or " ); -# endif - - StructureChain structureChain; - DescriptorSetLayoutSupport & support = structureChain.template get(); - d.vkGetDescriptorSetLayoutSupportKHR( - m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &support ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_draw_indirect_count === - - // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawIndirectCountKHR( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawIndexedIndirectCountKHR( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - //=== VK_EXT_external_memory_host === - - // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, - const void * pHostPointer, - MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetMemoryHostPointerPropertiesEXT( static_cast( m_device ), - static_cast( handleType ), - pHostPointer, - reinterpret_cast( pMemoryHostPointerProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryHostPointerPropertiesEXT && "Function requires " ); -# endif - - MemoryHostPointerPropertiesEXT memoryHostPointerProperties; - Result result = - static_cast( d.vkGetMemoryHostPointerPropertiesEXT( m_device, - static_cast( handleType ), - pHostPointer, - reinterpret_cast( &memoryHostPointerProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); - - return detail::createResultValueType( result, std::move( memoryHostPointerProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_AMD_buffer_marker === - - // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( - PipelineStageFlagBits pipelineStage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdWriteBufferMarkerAMD( static_cast( m_commandBuffer ), - static_cast( pipelineStage ), - static_cast( dstBuffer ), - static_cast( dstOffset ), - marker ); - } - - // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( - PipelineStageFlags2 stage, Buffer dstBuffer, DeviceSize dstOffset, uint32_t marker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdWriteBufferMarker2AMD( static_cast( m_commandBuffer ), - static_cast( stage ), - static_cast( dstBuffer ), - static_cast( dstOffset ), - marker ); - } - - //=== VK_EXT_calibrated_timestamps === - - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount, - TimeDomainKHR * pTimeDomains, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( - static_cast( m_physicalDevice ), pTimeDomainCount, reinterpret_cast( pTimeDomains ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCalibrateableTimeDomainsEXT( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT && - "Function requires or " ); -# endif - - std::vector timeDomains; - uint32_t timeDomainCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && timeDomainCount ) - { - timeDomains.resize( timeDomainCount ); - result = static_cast( - d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); - VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); - if ( timeDomainCount < timeDomains.size() ) - { - timeDomains.resize( timeDomainCount ); - } - return detail::createResultValueType( result, std::move( timeDomains ) ); - } - - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator const & timeDomainKHRAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT && - "Function requires or " ); -# endif - - std::vector timeDomains( timeDomainKHRAllocator ); - uint32_t timeDomainCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && timeDomainCount ) - { - timeDomains.resize( timeDomainCount ); - result = static_cast( - d.vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); - VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); - if ( timeDomainCount < timeDomains.size() ) - { - timeDomains.resize( timeDomainCount ); - } - return detail::createResultValueType( result, std::move( timeDomains ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsEXT( uint32_t timestampCount, - const CalibratedTimestampInfoKHR * pTimestampInfos, - uint64_t * pTimestamps, - uint64_t * pMaxDeviation, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetCalibratedTimestampsEXT( static_cast( m_device ), - timestampCount, - reinterpret_cast( pTimestampInfos ), - pTimestamps, - pMaxDeviation ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type - Device::getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT && - "Function requires or " ); -# endif - - std::pair, uint64_t> data_( - std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); - std::vector & timestamps = data_.first; - uint64_t & maxDeviation = data_.second; - Result result = static_cast( d.vkGetCalibratedTimestampsEXT( - m_device, timestampInfos.size(), reinterpret_cast( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type - Device::getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos, - Uint64_tAllocator const & uint64_tAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT && - "Function requires or " ); -# endif - - std::pair, uint64_t> data_( - std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) ); - std::vector & timestamps = data_.first; - uint64_t & maxDeviation = data_.second; - Result result = static_cast( d.vkGetCalibratedTimestampsEXT( - m_device, timestampInfos.size(), reinterpret_cast( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetCalibratedTimestampsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getCalibratedTimestampEXT( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsEXT && - "Function requires or " ); -# endif - - std::pair data_; - uint64_t & timestamp = data_.first; - uint64_t & maxDeviation = data_.second; - Result result = static_cast( - d.vkGetCalibratedTimestampsEXT( m_device, 1, reinterpret_cast( ×tampInfo ), ×tamp, &maxDeviation ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_mesh_shader === - - // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawMeshTasksNV( static_cast( m_commandBuffer ), taskCount, firstTask ); - } - - // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( - Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawMeshTasksIndirectNV( - static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); - } - - // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawMeshTasksIndirectCountNV( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - //=== VK_NV_scissor_exclusive === - - // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const Bool32 * pExclusiveScissorEnables, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetExclusiveScissorEnableNV( static_cast( m_commandBuffer ), - firstExclusiveScissor, - exclusiveScissorCount, - reinterpret_cast( pExclusiveScissorEnables ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, - ArrayProxy const & exclusiveScissorEnables, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetExclusiveScissorEnableNV && "Function requires " ); -# endif - - d.vkCmdSetExclusiveScissorEnableNV( - m_commandBuffer, firstExclusiveScissor, exclusiveScissorEnables.size(), reinterpret_cast( exclusiveScissorEnables.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const Rect2D * pExclusiveScissors, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetExclusiveScissorNV( - static_cast( m_commandBuffer ), firstExclusiveScissor, exclusiveScissorCount, reinterpret_cast( pExclusiveScissors ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, - ArrayProxy const & exclusiveScissors, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetExclusiveScissorNV && "Function requires " ); -# endif - - d.vkCmdSetExclusiveScissorNV( - m_commandBuffer, firstExclusiveScissor, exclusiveScissors.size(), reinterpret_cast( exclusiveScissors.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_device_diagnostic_checkpoints === - - // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetCheckpointNV( static_cast( m_commandBuffer ), pCheckpointMarker ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetCheckpointNV && "Function requires " ); -# endif - - d.vkCmdSetCheckpointNV( m_commandBuffer, reinterpret_cast( &checkpointMarker ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html - template ::type> - VULKAN_HPP_INLINE void - Queue::getCheckpointDataNV( uint32_t * pCheckpointDataCount, CheckpointDataNV * pCheckpointData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetQueueCheckpointDataNV( static_cast( m_queue ), pCheckpointDataCount, reinterpret_cast( pCheckpointData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Queue::getCheckpointDataNV( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointDataNV && "Function requires " ); -# endif - - std::vector checkpointData; - uint32_t checkpointDataCount; - d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); - checkpointData.resize( checkpointDataCount ); - d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); - - VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); - if ( checkpointDataCount < checkpointData.size() ) - { - checkpointData.resize( checkpointDataCount ); - } - return checkpointData; - } - - // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Queue::getCheckpointDataNV( CheckpointDataNVAllocator const & checkpointDataNVAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointDataNV && "Function requires " ); -# endif - - std::vector checkpointData( checkpointDataNVAllocator ); - uint32_t checkpointDataCount; - d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, nullptr ); - checkpointData.resize( checkpointDataCount ); - d.vkGetQueueCheckpointDataNV( m_queue, &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); - - VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); - if ( checkpointDataCount < checkpointData.size() ) - { - checkpointData.resize( checkpointDataCount ); - } - return checkpointData; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html - template ::type> - VULKAN_HPP_INLINE void - Queue::getCheckpointData2NV( uint32_t * pCheckpointDataCount, CheckpointData2NV * pCheckpointData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetQueueCheckpointData2NV( static_cast( m_queue ), pCheckpointDataCount, reinterpret_cast( pCheckpointData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Queue::getCheckpointData2NV( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointData2NV && "Function requires " ); -# endif - - std::vector checkpointData; - uint32_t checkpointDataCount; - d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr ); - checkpointData.resize( checkpointDataCount ); - d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); - - VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); - if ( checkpointDataCount < checkpointData.size() ) - { - checkpointData.resize( checkpointDataCount ); - } - return checkpointData; - } - - // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Queue::getCheckpointData2NV( CheckpointData2NVAllocator const & checkpointData2NVAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetQueueCheckpointData2NV && "Function requires " ); -# endif - - std::vector checkpointData( checkpointData2NVAllocator ); - uint32_t checkpointDataCount; - d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, nullptr ); - checkpointData.resize( checkpointDataCount ); - d.vkGetQueueCheckpointData2NV( m_queue, &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); - - VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); - if ( checkpointDataCount < checkpointData.size() ) - { - checkpointData.resize( checkpointDataCount ); - } - return checkpointData; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_timeline_semaphore === - - // wrapper function for command vkGetSemaphoreCounterValueKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreCounterValueKHR( Semaphore semaphore, - uint64_t * pValue, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetSemaphoreCounterValueKHR( static_cast( m_device ), static_cast( semaphore ), pValue ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSemaphoreCounterValueKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getSemaphoreCounterValueKHR( Semaphore semaphore, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetSemaphoreCounterValueKHR && "Function requires or " ); -# endif - - uint64_t value; - Result result = static_cast( d.vkGetSemaphoreCounterValueKHR( m_device, static_cast( semaphore ), &value ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreCounterValueKHR" ); - - return detail::createResultValueType( result, std::move( value ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo * pWaitInfo, - uint64_t timeout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkWaitSemaphoresKHR( static_cast( m_device ), reinterpret_cast( pWaitInfo ), timeout ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, uint64_t timeout, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkWaitSemaphoresKHR && "Function requires or " ); -# endif - - Result result = static_cast( d.vkWaitSemaphoresKHR( m_device, reinterpret_cast( &waitInfo ), timeout ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitSemaphoresKHR", { Result::eSuccess, Result::eTimeout } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::signalSemaphoreKHR( const SemaphoreSignalInfo * pSignalInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkSignalSemaphoreKHR( static_cast( m_device ), reinterpret_cast( pSignalInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSignalSemaphoreKHR && "Function requires or " ); -# endif - - Result result = static_cast( d.vkSignalSemaphoreKHR( m_device, reinterpret_cast( &signalInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::signalSemaphoreKHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_present_timing === - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, - uint32_t size, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkSetSwapchainPresentTimingQueueSizeEXT( static_cast( m_device ), static_cast( swapchain ), size ) ); - } -#else - // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, uint32_t size, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSetSwapchainPresentTimingQueueSizeEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkSetSwapchainPresentTimingQueueSizeEXT( m_device, static_cast( swapchain ), size ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setSwapchainPresentTimingQueueSizeEXT", { Result::eSuccess, Result::eNotReady } ); - - return static_cast( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, - SwapchainTimingPropertiesEXT * pSwapchainTimingProperties, - uint64_t * pSwapchainTimingPropertiesCounter, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetSwapchainTimingPropertiesEXT( static_cast( m_device ), - static_cast( swapchain ), - reinterpret_cast( pSwapchainTimingProperties ), - pSwapchainTimingPropertiesCounter ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetSwapchainTimingPropertiesEXT && "Function requires " ); -# endif - - std::pair data_; - SwapchainTimingPropertiesEXT & swapchainTimingProperties = data_.first; - uint64_t & swapchainTimingPropertiesCounter = data_.second; - Result result = static_cast( d.vkGetSwapchainTimingPropertiesEXT( m_device, - static_cast( swapchain ), - reinterpret_cast( &swapchainTimingProperties ), - &swapchainTimingPropertiesCounter ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSwapchainTimingPropertiesEXT", { Result::eSuccess, Result::eNotReady } ); - - return ResultValue>( result, std::move( data_ ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSwapchainTimeDomainPropertiesEXT( SwapchainKHR swapchain, - SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, - uint64_t * pTimeDomainsCounter, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetSwapchainTimeDomainPropertiesEXT( static_cast( m_device ), - static_cast( swapchain ), - reinterpret_cast( pSwapchainTimeDomainProperties ), - pTimeDomainsCounter ) ); - } - - // wrapper function for command vkGetPastPresentationTimingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, - PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPastPresentationTimingEXT( static_cast( m_device ), - reinterpret_cast( pPastPresentationTimingInfo ), - reinterpret_cast( pPastPresentationTimingProperties ) ) ); - } - - //=== VK_INTEL_performance_query === - - // wrapper function for command vkInitializePerformanceApiINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL * pInitializeInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkInitializePerformanceApiINTEL( static_cast( m_device ), - reinterpret_cast( pInitializeInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkInitializePerformanceApiINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkInitializePerformanceApiINTEL && "Function requires " ); -# endif - - Result result = - static_cast( d.vkInitializePerformanceApiINTEL( m_device, reinterpret_cast( &initializeInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUninitializePerformanceApiINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html - template ::type> - VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkUninitializePerformanceApiINTEL( static_cast( m_device ) ); - } - - // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL * pMarkerInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCmdSetPerformanceMarkerINTEL( static_cast( m_commandBuffer ), - reinterpret_cast( pMarkerInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceMarkerINTEL && "Function requires " ); -# endif - - Result result = - static_cast( d.vkCmdSetPerformanceMarkerINTEL( m_commandBuffer, reinterpret_cast( &markerInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL * pMarkerInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCmdSetPerformanceStreamMarkerINTEL( static_cast( m_commandBuffer ), - reinterpret_cast( pMarkerInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceStreamMarkerINTEL && "Function requires " ); -# endif - - Result result = static_cast( - d.vkCmdSetPerformanceStreamMarkerINTEL( m_commandBuffer, reinterpret_cast( &markerInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL * pOverrideInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCmdSetPerformanceOverrideINTEL( static_cast( m_commandBuffer ), - reinterpret_cast( pOverrideInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetPerformanceOverrideINTEL && "Function requires " ); -# endif - - Result result = - static_cast( d.vkCmdSetPerformanceOverrideINTEL( m_commandBuffer, reinterpret_cast( &overrideInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, - PerformanceConfigurationINTEL * pConfiguration, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkAcquirePerformanceConfigurationINTEL( static_cast( m_device ), - reinterpret_cast( pAcquireInfo ), - reinterpret_cast( pConfiguration ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAcquirePerformanceConfigurationINTEL && "Function requires " ); -# endif - - PerformanceConfigurationINTEL configuration; - Result result = - static_cast( d.vkAcquirePerformanceConfigurationINTEL( m_device, - reinterpret_cast( &acquireInfo ), - reinterpret_cast( &configuration ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" ); - - return detail::createResultValueType( result, std::move( configuration ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAcquirePerformanceConfigurationINTEL && "Function requires " ); -# endif - - PerformanceConfigurationINTEL configuration; - Result result = - static_cast( d.vkAcquirePerformanceConfigurationINTEL( m_device, - reinterpret_cast( &acquireInfo ), - reinterpret_cast( &configuration ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTELUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( configuration, detail::ObjectRelease( *this, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleasePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkReleasePerformanceConfigurationINTEL( static_cast( m_device ), static_cast( configuration ) ) ); - } -#else - // wrapper function for command vkReleasePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkReleasePerformanceConfigurationINTEL && "Function requires " ); -# endif - - Result result = static_cast( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast( configuration ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releasePerformanceConfigurationINTEL" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleasePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::release( PerformanceConfigurationINTEL configuration, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkReleasePerformanceConfigurationINTEL( static_cast( m_device ), static_cast( configuration ) ) ); - } -#else - // wrapper function for command vkReleasePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::release( PerformanceConfigurationINTEL configuration, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkReleasePerformanceConfigurationINTEL && "Function requires " ); -# endif - - Result result = static_cast( d.vkReleasePerformanceConfigurationINTEL( m_device, static_cast( configuration ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::release" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkQueueSetPerformanceConfigurationINTEL( static_cast( m_queue ), static_cast( configuration ) ) ); - } -#else - // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Queue::setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkQueueSetPerformanceConfigurationINTEL && - "Function requires " ); -# endif - - Result result = static_cast( d.vkQueueSetPerformanceConfigurationINTEL( m_queue, static_cast( configuration ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetPerformanceParameterINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, - PerformanceValueINTEL * pValue, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPerformanceParameterINTEL( - static_cast( m_device ), static_cast( parameter ), reinterpret_cast( pValue ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPerformanceParameterINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPerformanceParameterINTEL && "Function requires " ); -# endif - - PerformanceValueINTEL value; - Result result = static_cast( d.vkGetPerformanceParameterINTEL( - m_device, static_cast( parameter ), reinterpret_cast( &value ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); - - return detail::createResultValueType( result, std::move( value ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_AMD_display_native_hdr === - - // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html - template ::type> - VULKAN_HPP_INLINE void Device::setLocalDimmingAMD( SwapchainKHR swapChain, Bool32 localDimmingEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkSetLocalDimmingAMD( static_cast( m_device ), static_cast( swapChain ), static_cast( localDimmingEnable ) ); - } - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - - // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateImagePipeSurfaceFUCHSIA( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createImagePipeSurfaceFUCHSIA( - const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateImagePipeSurfaceFUCHSIA && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createImagePipeSurfaceFUCHSIAUnique( - const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateImagePipeSurfaceFUCHSIA && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateImagePipeSurfaceFUCHSIA( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIAUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - - // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateMetalSurfaceEXT( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateMetalSurfaceEXT && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateMetalSurfaceEXT( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createMetalSurfaceEXTUnique( - const MetalSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateMetalSurfaceEXT && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateMetalSurfaceEXT( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createMetalSurfaceEXTUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_fragment_shading_rate === - - // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount, - PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPhysicalDeviceFragmentShadingRatesKHR( static_cast( m_physicalDevice ), - pFragmentShadingRateCount, - reinterpret_cast( pFragmentShadingRates ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html - template < - typename PhysicalDeviceFragmentShadingRateKHRAllocator, - typename Dispatch, - typename std::enable_if::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getFragmentShadingRatesKHR( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFragmentShadingRatesKHR && - "Function requires " ); -# endif - - std::vector fragmentShadingRates; - uint32_t fragmentShadingRateCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && fragmentShadingRateCount ) - { - fragmentShadingRates.resize( fragmentShadingRateCount ); - result = static_cast( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( - m_physicalDevice, &fragmentShadingRateCount, reinterpret_cast( fragmentShadingRates.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); - VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); - if ( fragmentShadingRateCount < fragmentShadingRates.size() ) - { - fragmentShadingRates.resize( fragmentShadingRateCount ); - } - return detail::createResultValueType( result, std::move( fragmentShadingRates ) ); - } - - // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html - template < - typename PhysicalDeviceFragmentShadingRateKHRAllocator, - typename Dispatch, - typename std::enable_if::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator const & physicalDeviceFragmentShadingRateKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceFragmentShadingRatesKHR && - "Function requires " ); -# endif - - std::vector fragmentShadingRates( - physicalDeviceFragmentShadingRateKHRAllocator ); - uint32_t fragmentShadingRateCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( m_physicalDevice, &fragmentShadingRateCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && fragmentShadingRateCount ) - { - fragmentShadingRates.resize( fragmentShadingRateCount ); - result = static_cast( d.vkGetPhysicalDeviceFragmentShadingRatesKHR( - m_physicalDevice, &fragmentShadingRateCount, reinterpret_cast( fragmentShadingRates.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); - VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); - if ( fragmentShadingRateCount < fragmentShadingRates.size() ) - { - fragmentShadingRates.resize( fragmentShadingRateCount ); - } - return detail::createResultValueType( result, std::move( fragmentShadingRates ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetFragmentShadingRateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( const Extent2D * pFragmentSize, - const FragmentShadingRateCombinerOpKHR combinerOps[2], - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetFragmentShadingRateKHR( static_cast( m_commandBuffer ), - reinterpret_cast( pFragmentSize ), - reinterpret_cast( combinerOps ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetFragmentShadingRateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( const Extent2D & fragmentSize, - const FragmentShadingRateCombinerOpKHR combinerOps[2], - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetFragmentShadingRateKHR && "Function requires " ); -# endif - - d.vkCmdSetFragmentShadingRateKHR( - m_commandBuffer, reinterpret_cast( &fragmentSize ), reinterpret_cast( combinerOps ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_dynamic_rendering_local_read === - - // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo * pLocationInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetRenderingAttachmentLocationsKHR( static_cast( m_commandBuffer ), - reinterpret_cast( pLocationInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo & locationInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetRenderingAttachmentLocationsKHR && - "Function requires or " ); -# endif - - d.vkCmdSetRenderingAttachmentLocationsKHR( m_commandBuffer, reinterpret_cast( &locationInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetRenderingInputAttachmentIndicesKHR( static_cast( m_commandBuffer ), - reinterpret_cast( pInputAttachmentIndexInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetRenderingInputAttachmentIndicesKHR && - "Function requires or " ); -# endif - - d.vkCmdSetRenderingInputAttachmentIndicesKHR( m_commandBuffer, reinterpret_cast( &inputAttachmentIndexInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_buffer_device_address === - - // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html - template ::type> - VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetBufferDeviceAddressEXT( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html - template ::type> - VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddressEXT && - "Function requires or or " ); -# endif - - VkDeviceAddress result = d.vkGetBufferDeviceAddressEXT( m_device, reinterpret_cast( &info ) ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_tooling_info === - - // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getToolPropertiesEXT( uint32_t * pToolCount, - PhysicalDeviceToolProperties * pToolProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceToolPropertiesEXT( - static_cast( m_physicalDevice ), pToolCount, reinterpret_cast( pToolProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getToolPropertiesEXT( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolPropertiesEXT && - "Function requires or " ); -# endif - - std::vector toolProperties; - uint32_t toolCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && toolCount ) - { - toolProperties.resize( toolCount ); - result = static_cast( - d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, reinterpret_cast( toolProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); - VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); - if ( toolCount < toolProperties.size() ) - { - toolProperties.resize( toolCount ); - } - return detail::createResultValueType( result, std::move( toolProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator const & physicalDeviceToolPropertiesAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceToolPropertiesEXT && - "Function requires or " ); -# endif - - std::vector toolProperties( physicalDeviceToolPropertiesAllocator ); - uint32_t toolCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && toolCount ) - { - toolProperties.resize( toolCount ); - result = static_cast( - d.vkGetPhysicalDeviceToolPropertiesEXT( m_physicalDevice, &toolCount, reinterpret_cast( toolProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); - VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); - if ( toolCount < toolProperties.size() ) - { - toolProperties.resize( toolCount ); - } - return detail::createResultValueType( result, std::move( toolProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_present_wait === - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::waitForPresentKHR( SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkWaitForPresentKHR( static_cast( m_device ), static_cast( swapchain ), presentId, timeout ) ); - } -#else - // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::waitForPresentKHR( SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkWaitForPresentKHR && "Function requires " ); -# endif - - Result result = static_cast( d.vkWaitForPresentKHR( m_device, static_cast( swapchain ), presentId, timeout ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR", - { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresentKHR", { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR } ); -# endif - - return static_cast( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - //=== VK_NV_cooperative_matrix === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount, - CooperativeMatrixPropertiesNV * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( - static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCooperativeMatrixPropertiesNV( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV && - "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator const & cooperativeMatrixPropertiesNVAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV && - "Function requires " ); -# endif - - std::vector properties( cooperativeMatrixPropertiesNVAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_coverage_reduction_mode === - - // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( - uint32_t * pCombinationCount, FramebufferMixedSamplesCombinationNV * pCombinations, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - static_cast( m_physicalDevice ), pCombinationCount, reinterpret_cast( pCombinations ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html - template < - typename FramebufferMixedSamplesCombinationNVAllocator, - typename Dispatch, - typename std::enable_if::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV && - "Function requires " ); -# endif - - std::vector combinations; - uint32_t combinationCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && combinationCount ) - { - combinations.resize( combinationCount ); - result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - m_physicalDevice, &combinationCount, reinterpret_cast( combinations.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); - VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); - if ( combinationCount < combinations.size() ) - { - combinations.resize( combinationCount ); - } - return detail::createResultValueType( result, std::move( combinations ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html - template < - typename FramebufferMixedSamplesCombinationNVAllocator, - typename Dispatch, - typename std::enable_if::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV( - FramebufferMixedSamplesCombinationNVAllocator const & framebufferMixedSamplesCombinationNVAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV && - "Function requires " ); -# endif - - std::vector combinations( - framebufferMixedSamplesCombinationNVAllocator ); - uint32_t combinationCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( m_physicalDevice, &combinationCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && combinationCount ) - { - combinations.resize( combinationCount ); - result = static_cast( d.vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - m_physicalDevice, &combinationCount, reinterpret_cast( combinations.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); - VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); - if ( combinationCount < combinations.size() ) - { - combinations.resize( combinationCount ); - } - return detail::createResultValueType( result, std::move( combinations ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - uint32_t * pPresentModeCount, - PresentModeKHR * pPresentModes, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast( m_physicalDevice ), - reinterpret_cast( pSurfaceInfo ), - pPresentModeCount, - reinterpret_cast( pPresentModes ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModes2EXT && - "Function requires " ); -# endif - - std::vector presentModes; - uint32_t presentModeCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( - m_physicalDevice, reinterpret_cast( &surfaceInfo ), &presentModeCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentModeCount ) - { - presentModes.resize( presentModeCount ); - result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, - reinterpret_cast( &surfaceInfo ), - &presentModeCount, - reinterpret_cast( presentModes.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" ); - VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); - if ( presentModeCount < presentModes.size() ) - { - presentModes.resize( presentModeCount ); - } - return detail::createResultValueType( result, std::move( presentModes ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, - PresentModeKHRAllocator const & presentModeKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceSurfacePresentModes2EXT && - "Function requires " ); -# endif - - std::vector presentModes( presentModeKHRAllocator ); - uint32_t presentModeCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( - m_physicalDevice, reinterpret_cast( &surfaceInfo ), &presentModeCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentModeCount ) - { - presentModes.resize( presentModeCount ); - result = static_cast( d.vkGetPhysicalDeviceSurfacePresentModes2EXT( m_physicalDevice, - reinterpret_cast( &surfaceInfo ), - &presentModeCount, - reinterpret_cast( presentModes.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" ); - VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); - if ( presentModeCount < presentModes.size() ) - { - presentModes.resize( presentModeCount ); - } - return detail::createResultValueType( result, std::move( presentModes ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkAcquireFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( swapchain ) ) ); - } -# else - // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAcquireFullScreenExclusiveModeEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkAcquireFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::acquireFullScreenExclusiveModeEXT" ); - - return detail::createResultValueType( result ); - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkReleaseFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( swapchain ) ) ); - } -# else - // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkReleaseFullScreenExclusiveModeEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkReleaseFullScreenExclusiveModeEXT( m_device, static_cast( swapchain ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseFullScreenExclusiveModeEXT" ); - - return detail::createResultValueType( result ); - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - DeviceGroupPresentModeFlagsKHR * pModes, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDeviceGroupSurfacePresentModes2EXT( static_cast( m_device ), - reinterpret_cast( pSurfaceInfo ), - reinterpret_cast( pModes ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceGroupSurfacePresentModes2EXT && - "Function requires " ); -# endif - - DeviceGroupPresentModeFlagsKHR modes; - Result result = static_cast( d.vkGetDeviceGroupSurfacePresentModes2EXT( - m_device, reinterpret_cast( &surfaceInfo ), reinterpret_cast( &modes ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); - - return detail::createResultValueType( result, std::move( modes ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - - // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateHeadlessSurfaceEXT( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createHeadlessSurfaceEXT( - const HeadlessSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateHeadlessSurfaceEXT && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateHeadlessSurfaceEXT( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createHeadlessSurfaceEXTUnique( - const HeadlessSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateHeadlessSurfaceEXT && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateHeadlessSurfaceEXT( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXTUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_buffer_device_address === - - // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html - template ::type> - VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetBufferDeviceAddressKHR( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html - template ::type> - VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferDeviceAddressKHR && - "Function requires or or " ); -# endif - - VkDeviceAddress result = d.vkGetBufferDeviceAddressKHR( m_device, reinterpret_cast( &info ) ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html - template ::type> - VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return d.vkGetBufferOpaqueCaptureAddressKHR( static_cast( m_device ), reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html - template ::type> - VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureAddressKHR && - "Function requires or " ); -# endif - - uint64_t result = d.vkGetBufferOpaqueCaptureAddressKHR( m_device, reinterpret_cast( &info ) ); - - return result; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html - template ::type> - VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( static_cast( m_device ), - reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html - template ::type> - VULKAN_HPP_INLINE uint64_t Device::getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceMemoryOpaqueCaptureAddressKHR && - "Function requires or " ); -# endif - - uint64_t result = d.vkGetDeviceMemoryOpaqueCaptureAddressKHR( m_device, reinterpret_cast( &info ) ); - - return result; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_line_rasterization === - - // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetLineStippleEXT( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); - } - - //=== VK_EXT_host_query_reset === - - // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::resetQueryPoolEXT( QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkResetQueryPoolEXT( static_cast( m_device ), static_cast( queryPool ), firstQuery, queryCount ); - } - - //=== VK_EXT_extended_dynamic_state === - - // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( CullModeFlags cullMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetCullModeEXT( static_cast( m_commandBuffer ), static_cast( cullMode ) ); - } - - // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( FrontFace frontFace, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetFrontFaceEXT( static_cast( m_commandBuffer ), static_cast( frontFace ) ); - } - - // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( PrimitiveTopology primitiveTopology, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetPrimitiveTopologyEXT( static_cast( m_commandBuffer ), static_cast( primitiveTopology ) ); - } - - // wrapper function for command vkCmdSetViewportWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::setViewportWithCountEXT( uint32_t viewportCount, const Viewport * pViewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetViewportWithCountEXT( static_cast( m_commandBuffer ), viewportCount, reinterpret_cast( pViewports ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewportWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( ArrayProxy const & viewports, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetViewportWithCountEXT && - "Function requires or or " ); -# endif - - d.vkCmdSetViewportWithCountEXT( m_commandBuffer, viewports.size(), reinterpret_cast( viewports.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( uint32_t scissorCount, const Rect2D * pScissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetScissorWithCountEXT( static_cast( m_commandBuffer ), scissorCount, reinterpret_cast( pScissors ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( ArrayProxy const & scissors, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetScissorWithCountEXT && - "Function requires or or " ); -# endif - - d.vkCmdSetScissorWithCountEXT( m_commandBuffer, scissors.size(), reinterpret_cast( scissors.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding, - uint32_t bindingCount, - const Buffer * pBuffers, - const DeviceSize * pOffsets, - const DeviceSize * pSizes, - const DeviceSize * pStrides, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindVertexBuffers2EXT( static_cast( m_commandBuffer ), - firstBinding, - bindingCount, - reinterpret_cast( pBuffers ), - reinterpret_cast( pOffsets ), - reinterpret_cast( pSizes ), - reinterpret_cast( pStrides ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes, - ArrayProxy const & strides, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindVertexBuffers2EXT && - "Function requires or or " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); - VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); - VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); -# else - if ( buffers.size() != offsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); - } - if ( !sizes.empty() && buffers.size() != sizes.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" ); - } - if ( !strides.empty() && buffers.size() != strides.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdBindVertexBuffers2EXT( m_commandBuffer, - firstBinding, - buffers.size(), - reinterpret_cast( buffers.data() ), - reinterpret_cast( offsets.data() ), - reinterpret_cast( sizes.data() ), - reinterpret_cast( strides.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( Bool32 depthTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthTestEnableEXT( static_cast( m_commandBuffer ), static_cast( depthTestEnable ) ); - } - - // wrapper function for command vkCmdSetDepthWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( Bool32 depthWriteEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthWriteEnableEXT( static_cast( m_commandBuffer ), static_cast( depthWriteEnable ) ); - } - - // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( CompareOp depthCompareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthCompareOpEXT( static_cast( m_commandBuffer ), static_cast( depthCompareOp ) ); - } - - // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( Bool32 depthBoundsTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthBoundsTestEnableEXT( static_cast( m_commandBuffer ), static_cast( depthBoundsTestEnable ) ); - } - - // wrapper function for command vkCmdSetStencilTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( Bool32 stencilTestEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetStencilTestEnableEXT( static_cast( m_commandBuffer ), static_cast( stencilTestEnable ) ); - } - - // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( - StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetStencilOpEXT( static_cast( m_commandBuffer ), - static_cast( faceMask ), - static_cast( failOp ), - static_cast( passOp ), - static_cast( depthFailOp ), - static_cast( compareOp ) ); - } - - //=== VK_KHR_deferred_host_operations === - - // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDeferredOperationKHR( const AllocationCallbacks * pAllocator, - DeferredOperationKHR * pDeferredOperation, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDeferredOperationKHR( static_cast( m_device ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pDeferredOperation ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createDeferredOperationKHR( Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDeferredOperationKHR && "Function requires " ); -# endif - - DeferredOperationKHR deferredOperation; - Result result = static_cast( d.vkCreateDeferredOperationKHR( - m_device, reinterpret_cast( allocator.get() ), reinterpret_cast( &deferredOperation ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHR" ); - - return detail::createResultValueType( result, std::move( deferredOperation ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createDeferredOperationKHRUnique( Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDeferredOperationKHR && "Function requires " ); -# endif - - DeferredOperationKHR deferredOperation; - Result result = static_cast( d.vkCreateDeferredOperationKHR( - m_device, reinterpret_cast( allocator.get() ), reinterpret_cast( &deferredOperation ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDeferredOperationKHRUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( deferredOperation, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyDeferredOperationKHR( DeferredOperationKHR operation, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDeferredOperationKHR( - static_cast( m_device ), static_cast( operation ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyDeferredOperationKHR( DeferredOperationKHR operation, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDeferredOperationKHR && "Function requires " ); -# endif - - d.vkDestroyDeferredOperationKHR( - m_device, static_cast( operation ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( DeferredOperationKHR operation, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDeferredOperationKHR( - static_cast( m_device ), static_cast( operation ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( DeferredOperationKHR operation, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDeferredOperationKHR && "Function requires " ); -# endif - - d.vkDestroyDeferredOperationKHR( - m_device, static_cast( operation ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html - template ::type> - VULKAN_HPP_INLINE uint32_t Device::getDeferredOperationMaxConcurrencyKHR( DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return d.vkGetDeferredOperationMaxConcurrencyKHR( static_cast( m_device ), static_cast( operation ) ); - } - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeferredOperationResultKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( DeferredOperationKHR operation, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDeferredOperationResultKHR( static_cast( m_device ), static_cast( operation ) ) ); - } -#else - // wrapper function for command vkGetDeferredOperationResultKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDeferredOperationResultKHR( DeferredOperationKHR operation, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeferredOperationResultKHR && "Function requires " ); -# endif - - Result result = static_cast( d.vkGetDeferredOperationResultKHR( m_device, static_cast( operation ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDeferredOperationResultKHR", { Result::eSuccess, Result::eNotReady } ); - - return static_cast( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR( DeferredOperationKHR operation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkDeferredOperationJoinKHR( static_cast( m_device ), static_cast( operation ) ) ); - } -#else - // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::deferredOperationJoinKHR( DeferredOperationKHR operation, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDeferredOperationJoinKHR && "Function requires " ); -# endif - - Result result = static_cast( d.vkDeferredOperationJoinKHR( m_device, static_cast( operation ) ) ); - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::deferredOperationJoinKHR", { Result::eSuccess, Result::eThreadDoneKHR, Result::eThreadIdleKHR } ); - - return static_cast( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - //=== VK_KHR_pipeline_executable_properties === - - // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR * pPipelineInfo, - uint32_t * pExecutableCount, - PipelineExecutablePropertiesKHR * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPipelineExecutablePropertiesKHR( static_cast( m_device ), - reinterpret_cast( pPipelineInfo ), - pExecutableCount, - reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html - template < - typename PipelineExecutablePropertiesKHRAllocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineExecutablePropertiesKHR && - "Function requires " ); -# endif - - std::vector properties; - uint32_t executableCount; - Result result; - do - { - result = static_cast( - d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast( &pipelineInfo ), &executableCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && executableCount ) - { - properties.resize( executableCount ); - result = static_cast( d.vkGetPipelineExecutablePropertiesKHR( m_device, - reinterpret_cast( &pipelineInfo ), - &executableCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); - VULKAN_HPP_ASSERT( executableCount <= properties.size() ); - if ( executableCount < properties.size() ) - { - properties.resize( executableCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html - template < - typename PipelineExecutablePropertiesKHRAllocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, - PipelineExecutablePropertiesKHRAllocator const & pipelineExecutablePropertiesKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineExecutablePropertiesKHR && - "Function requires " ); -# endif - - std::vector properties( pipelineExecutablePropertiesKHRAllocator ); - uint32_t executableCount; - Result result; - do - { - result = static_cast( - d.vkGetPipelineExecutablePropertiesKHR( m_device, reinterpret_cast( &pipelineInfo ), &executableCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && executableCount ) - { - properties.resize( executableCount ); - result = static_cast( d.vkGetPipelineExecutablePropertiesKHR( m_device, - reinterpret_cast( &pipelineInfo ), - &executableCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); - VULKAN_HPP_ASSERT( executableCount <= properties.size() ); - if ( executableCount < properties.size() ) - { - properties.resize( executableCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR * pExecutableInfo, - uint32_t * pStatisticCount, - PipelineExecutableStatisticKHR * pStatistics, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPipelineExecutableStatisticsKHR( static_cast( m_device ), - reinterpret_cast( pExecutableInfo ), - pStatisticCount, - reinterpret_cast( pStatistics ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html - template < - typename PipelineExecutableStatisticKHRAllocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableStatisticsKHR && - "Function requires " ); -# endif - - std::vector statistics; - uint32_t statisticCount; - Result result; - do - { - result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( - m_device, reinterpret_cast( &executableInfo ), &statisticCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && statisticCount ) - { - statistics.resize( statisticCount ); - result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( m_device, - reinterpret_cast( &executableInfo ), - &statisticCount, - reinterpret_cast( statistics.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); - VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); - if ( statisticCount < statistics.size() ) - { - statistics.resize( statisticCount ); - } - return detail::createResultValueType( result, std::move( statistics ) ); - } - - // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html - template < - typename PipelineExecutableStatisticKHRAllocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, - PipelineExecutableStatisticKHRAllocator const & pipelineExecutableStatisticKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableStatisticsKHR && - "Function requires " ); -# endif - - std::vector statistics( pipelineExecutableStatisticKHRAllocator ); - uint32_t statisticCount; - Result result; - do - { - result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( - m_device, reinterpret_cast( &executableInfo ), &statisticCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && statisticCount ) - { - statistics.resize( statisticCount ); - result = static_cast( d.vkGetPipelineExecutableStatisticsKHR( m_device, - reinterpret_cast( &executableInfo ), - &statisticCount, - reinterpret_cast( statistics.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); - VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); - if ( statisticCount < statistics.size() ) - { - statistics.resize( statisticCount ); - } - return detail::createResultValueType( result, std::move( statistics ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR * pExecutableInfo, - uint32_t * pInternalRepresentationCount, - PipelineExecutableInternalRepresentationKHR * pInternalRepresentations, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPipelineExecutableInternalRepresentationsKHR( static_cast( m_device ), - reinterpret_cast( pExecutableInfo ), - pInternalRepresentationCount, - reinterpret_cast( pInternalRepresentations ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html - template ::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableInternalRepresentationsKHR && - "Function requires " ); -# endif - - std::vector internalRepresentations; - uint32_t internalRepresentationCount; - Result result; - do - { - result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( - m_device, reinterpret_cast( &executableInfo ), &internalRepresentationCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && internalRepresentationCount ) - { - internalRepresentations.resize( internalRepresentationCount ); - result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( - m_device, - reinterpret_cast( &executableInfo ), - &internalRepresentationCount, - reinterpret_cast( internalRepresentations.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); - VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); - if ( internalRepresentationCount < internalRepresentations.size() ) - { - internalRepresentations.resize( internalRepresentationCount ); - } - return detail::createResultValueType( result, std::move( internalRepresentations ) ); - } - - // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html - template ::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Device::getPipelineExecutableInternalRepresentationsKHR( - const PipelineExecutableInfoKHR & executableInfo, - PipelineExecutableInternalRepresentationKHRAllocator const & pipelineExecutableInternalRepresentationKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineExecutableInternalRepresentationsKHR && - "Function requires " ); -# endif - - std::vector internalRepresentations( - pipelineExecutableInternalRepresentationKHRAllocator ); - uint32_t internalRepresentationCount; - Result result; - do - { - result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( - m_device, reinterpret_cast( &executableInfo ), &internalRepresentationCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && internalRepresentationCount ) - { - internalRepresentations.resize( internalRepresentationCount ); - result = static_cast( d.vkGetPipelineExecutableInternalRepresentationsKHR( - m_device, - reinterpret_cast( &executableInfo ), - &internalRepresentationCount, - reinterpret_cast( internalRepresentations.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); - VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); - if ( internalRepresentationCount < internalRepresentations.size() ) - { - internalRepresentations.resize( internalRepresentationCount ); - } - return detail::createResultValueType( result, std::move( internalRepresentations ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_host_image_copy === - - // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToImageEXT( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkCopyMemoryToImageEXT( static_cast( m_device ), reinterpret_cast( pCopyMemoryToImageInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::copyMemoryToImageEXT( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyMemoryToImageEXT && "Function requires or " ); -# endif - - Result result = static_cast( d.vkCopyMemoryToImageEXT( m_device, reinterpret_cast( ©MemoryToImageInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToImageEXT" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToMemoryEXT( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkCopyImageToMemoryEXT( static_cast( m_device ), reinterpret_cast( pCopyImageToMemoryInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::copyImageToMemoryEXT( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyImageToMemoryEXT && "Function requires or " ); -# endif - - Result result = static_cast( d.vkCopyImageToMemoryEXT( m_device, reinterpret_cast( ©ImageToMemoryInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToMemoryEXT" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyImageToImageEXT( const CopyImageToImageInfo * pCopyImageToImageInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkCopyImageToImageEXT( static_cast( m_device ), reinterpret_cast( pCopyImageToImageInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::copyImageToImageEXT( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyImageToImageEXT && "Function requires or " ); -# endif - - Result result = static_cast( d.vkCopyImageToImageEXT( m_device, reinterpret_cast( ©ImageToImageInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyImageToImageEXT" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::transitionImageLayoutEXT( uint32_t transitionCount, - const HostImageLayoutTransitionInfo * pTransitions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkTransitionImageLayoutEXT( - static_cast( m_device ), transitionCount, reinterpret_cast( pTransitions ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::transitionImageLayoutEXT( ArrayProxy const & transitions, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkTransitionImageLayoutEXT && "Function requires or " ); -# endif - - Result result = static_cast( - d.vkTransitionImageLayoutEXT( m_device, transitions.size(), reinterpret_cast( transitions.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::transitionImageLayoutEXT" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSubresourceLayout2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageSubresourceLayout2EXT( Image image, - const ImageSubresource2 * pSubresource, - SubresourceLayout2 * pLayout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetImageSubresourceLayout2EXT( static_cast( m_device ), - static_cast( image ), - reinterpret_cast( pSubresource ), - reinterpret_cast( pLayout ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSubresourceLayout2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout2EXT( Image image, - const ImageSubresource2 & subresource, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( - d.vkGetImageSubresourceLayout2EXT && - "Function requires or or or " ); -# endif - - SubresourceLayout2 layout; - d.vkGetImageSubresourceLayout2EXT( m_device, - static_cast( image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return layout; - } - - // wrapper function for command vkGetImageSubresourceLayout2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getImageSubresourceLayout2EXT( Image image, const ImageSubresource2 & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( - d.vkGetImageSubresourceLayout2EXT && - "Function requires or or or " ); -# endif - - StructureChain structureChain; - SubresourceLayout2 & layout = structureChain.template get(); - d.vkGetImageSubresourceLayout2EXT( m_device, - static_cast( image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_map_memory2 === - - // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::mapMemory2KHR( const MemoryMapInfo * pMemoryMapInfo, - void ** ppData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkMapMemory2KHR( static_cast( m_device ), reinterpret_cast( pMemoryMapInfo ), ppData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::mapMemory2KHR( const MemoryMapInfo & memoryMapInfo, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkMapMemory2KHR && "Function requires or " ); -# endif - - void * pData; - Result result = static_cast( d.vkMapMemory2KHR( m_device, reinterpret_cast( &memoryMapInfo ), &pData ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::mapMemory2KHR" ); - - return detail::createResultValueType( result, std::move( pData ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::unmapMemory2KHR( const MemoryUnmapInfo * pMemoryUnmapInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkUnmapMemory2KHR( static_cast( m_device ), reinterpret_cast( pMemoryUnmapInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkUnmapMemory2KHR && "Function requires or " ); -# endif - - Result result = static_cast( d.vkUnmapMemory2KHR( m_device, reinterpret_cast( &memoryUnmapInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::unmapMemory2KHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_swapchain_maintenance1 === - - // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkReleaseSwapchainImagesEXT( static_cast( m_device ), reinterpret_cast( pReleaseInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkReleaseSwapchainImagesEXT && - "Function requires or " ); -# endif - - Result result = static_cast( d.vkReleaseSwapchainImagesEXT( m_device, reinterpret_cast( &releaseInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseSwapchainImagesEXT" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_device_generated_commands === - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html - template ::type> - VULKAN_HPP_INLINE void Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetGeneratedCommandsMemoryRequirementsNV( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsNV && - "Function requires " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsNV && - "Function requires " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetGeneratedCommandsMemoryRequirementsNV( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV * pGeneratedCommandsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPreprocessGeneratedCommandsNV( static_cast( m_commandBuffer ), - reinterpret_cast( pGeneratedCommandsInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPreprocessGeneratedCommandsNV && "Function requires " ); -# endif - - d.vkCmdPreprocessGeneratedCommandsNV( m_commandBuffer, reinterpret_cast( &generatedCommandsInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( Bool32 isPreprocessed, - const GeneratedCommandsInfoNV * pGeneratedCommandsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdExecuteGeneratedCommandsNV( static_cast( m_commandBuffer ), - static_cast( isPreprocessed ), - reinterpret_cast( pGeneratedCommandsInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( Bool32 isPreprocessed, - const GeneratedCommandsInfoNV & generatedCommandsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdExecuteGeneratedCommandsNV && "Function requires " ); -# endif - - d.vkCmdExecuteGeneratedCommandsNV( - m_commandBuffer, static_cast( isPreprocessed ), reinterpret_cast( &generatedCommandsInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindPipelineShaderGroupNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindPipelineShaderGroupNV( PipelineBindPoint pipelineBindPoint, - Pipeline pipeline, - uint32_t groupIndex, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindPipelineShaderGroupNV( - static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( pipeline ), groupIndex ); - } - - // wrapper function for command vkCreateIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - IndirectCommandsLayoutNV * pIndirectCommandsLayout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateIndirectCommandsLayoutNV( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pIndirectCommandsLayout ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createIndirectCommandsLayoutNV( - const IndirectCommandsLayoutCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutNV && "Function requires " ); -# endif - - IndirectCommandsLayoutNV indirectCommandsLayout; - Result result = static_cast( d.vkCreateIndirectCommandsLayoutNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &indirectCommandsLayout ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" ); - - return detail::createResultValueType( result, std::move( indirectCommandsLayout ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutNV && "Function requires " ); -# endif - - IndirectCommandsLayoutNV indirectCommandsLayout; - Result result = static_cast( d.vkCreateIndirectCommandsLayoutNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &indirectCommandsLayout ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNVUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( indirectCommandsLayout, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyIndirectCommandsLayoutNV( static_cast( m_device ), - static_cast( indirectCommandsLayout ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutNV && "Function requires " ); -# endif - - d.vkDestroyIndirectCommandsLayoutNV( - m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( IndirectCommandsLayoutNV indirectCommandsLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyIndirectCommandsLayoutNV( static_cast( m_device ), - static_cast( indirectCommandsLayout ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutNV indirectCommandsLayout, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutNV && "Function requires " ); -# endif - - d.vkDestroyIndirectCommandsLayoutNV( - m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_depth_bias_control === - - // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const DepthBiasInfoEXT * pDepthBiasInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthBias2EXT( static_cast( m_commandBuffer ), reinterpret_cast( pDepthBiasInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const DepthBiasInfoEXT & depthBiasInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetDepthBias2EXT && "Function requires " ); -# endif - - d.vkCmdSetDepthBias2EXT( m_commandBuffer, reinterpret_cast( &depthBiasInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_acquire_drm_display === - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, - DisplayKHR display, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkAcquireDrmDisplayEXT( static_cast( m_physicalDevice ), drmFd, static_cast( display ) ) ); - } -#else - // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, DisplayKHR display, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAcquireDrmDisplayEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkAcquireDrmDisplayEXT( m_physicalDevice, drmFd, static_cast( display ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, DisplayKHR * display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetDrmDisplayEXT( static_cast( m_physicalDevice ), drmFd, connectorId, reinterpret_cast( display ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDrmDisplayEXT && "Function requires " ); -# endif - - DisplayKHR display; - Result result = static_cast( d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast( &display ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXT" ); - - return detail::createResultValueType( result, std::move( display ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDrmDisplayEXT && "Function requires " ); -# endif - - DisplayKHR display; - Result result = static_cast( d.vkGetDrmDisplayEXT( m_physicalDevice, drmFd, connectorId, reinterpret_cast( &display ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXTUnique" ); - - return detail::createResultValueType( result, UniqueHandle( display, detail::ObjectRelease( *this, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_private_data === - - // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - PrivateDataSlot * pPrivateDataSlot, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreatePrivateDataSlotEXT( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pPrivateDataSlot ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlotEXT && "Function requires or " ); -# endif - - PrivateDataSlot privateDataSlot; - Result result = static_cast( d.vkCreatePrivateDataSlotEXT( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &privateDataSlot ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" ); - - return detail::createResultValueType( result, std::move( privateDataSlot ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::createPrivateDataSlotEXTUnique( - const PrivateDataSlotCreateInfo & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePrivateDataSlotEXT && "Function requires or " ); -# endif - - PrivateDataSlot privateDataSlot; - Result result = static_cast( d.vkCreatePrivateDataSlotEXT( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &privateDataSlot ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPrivateDataSlotEXTUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( privateDataSlot, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyPrivateDataSlotEXT( - static_cast( m_device ), static_cast( privateDataSlot ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyPrivateDataSlotEXT && "Function requires or " ); -# endif - - d.vkDestroyPrivateDataSlotEXT( - m_device, static_cast( privateDataSlot ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setPrivateDataEXT( - ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkSetPrivateDataEXT( - static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); - } -#else - // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::setPrivateDataEXT( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t data, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSetPrivateDataEXT && "Function requires or " ); -# endif - - Result result = static_cast( - d.vkSetPrivateDataEXT( m_device, static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setPrivateDataEXT" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::getPrivateDataEXT( - ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, uint64_t * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPrivateDataEXT( - static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), pData ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t - Device::getPrivateDataEXT( ObjectType objectType_, uint64_t objectHandle, PrivateDataSlot privateDataSlot, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPrivateDataEXT && "Function requires or " ); -# endif - - uint64_t data; - d.vkGetPrivateDataEXT( m_device, static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), &data ); - - return data; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_video_encode_queue === - - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, - VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( pQualityLevelInfo ), - reinterpret_cast( pQualityLevelProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && - "Function requires " ); -# endif - - VideoEncodeQualityLevelPropertiesKHR qualityLevelProperties; - Result result = static_cast( - d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice, - reinterpret_cast( &qualityLevelInfo ), - reinterpret_cast( &qualityLevelProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); - - return detail::createResultValueType( result, std::move( qualityLevelProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && - "Function requires " ); -# endif - - StructureChain structureChain; - VideoEncodeQualityLevelPropertiesKHR & qualityLevelProperties = structureChain.template get(); - Result result = static_cast( - d.vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( m_physicalDevice, - reinterpret_cast( &qualityLevelInfo ), - reinterpret_cast( &qualityLevelProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); - - return detail::createResultValueType( result, std::move( structureChain ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, - VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, - size_t * pDataSize, - void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetEncodedVideoSessionParametersKHR( static_cast( m_device ), - reinterpret_cast( pVideoSessionParametersInfo ), - reinterpret_cast( pFeedbackInfo ), - pDataSize, - pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>>::type - Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function requires " ); -# endif - - std::pair> data_; - VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; - std::vector & data = data_.second; - size_t dataSize; - Result result; - do - { - result = static_cast( - d.vkGetEncodedVideoSessionParametersKHR( m_device, - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( - d.vkGetEncodedVideoSessionParametersKHR( m_device, - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>>::type - Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, - Uint8_tAllocator const & uint8_tAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function requires " ); -# endif - - std::pair> data_( - std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) ); - VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; - std::vector & data = data_.second; - size_t dataSize; - Result result; - do - { - result = static_cast( - d.vkGetEncodedVideoSessionParametersKHR( m_device, - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( - d.vkGetEncodedVideoSessionParametersKHR( m_device, - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, std::vector>>::type - Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function requires " ); -# endif - - std::pair, std::vector> data_; - VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first.template get(); - std::vector & data = data_.second; - size_t dataSize; - Result result; - do - { - result = static_cast( - d.vkGetEncodedVideoSessionParametersKHR( m_device, - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( - d.vkGetEncodedVideoSessionParametersKHR( m_device, - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, std::vector>>::type - Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, - Uint8_tAllocator const & uint8_tAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetEncodedVideoSessionParametersKHR && "Function requires " ); -# endif - - std::pair, std::vector> data_( - std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) ); - VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first.template get(); - std::vector & data = data_.second; - size_t dataSize; - Result result; - do - { - result = static_cast( - d.vkGetEncodedVideoSessionParametersKHR( m_device, - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( - d.vkGetEncodedVideoSessionParametersKHR( m_device, - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR * pEncodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEncodeVideoKHR( static_cast( m_commandBuffer ), reinterpret_cast( pEncodeInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdEncodeVideoKHR && "Function requires " ); -# endif - - d.vkCmdEncodeVideoKHR( m_commandBuffer, reinterpret_cast( &encodeInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - - // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCudaModuleNV( const CudaModuleCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - CudaModuleNV * pModule, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateCudaModuleNV( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pModule ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createCudaModuleNV( const CudaModuleCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateCudaModuleNV && "Function requires " ); -# endif - - CudaModuleNV module; - Result result = static_cast( d.vkCreateCudaModuleNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &module ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaModuleNV" ); - - return detail::createResultValueType( result, std::move( module ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createCudaModuleNVUnique( const CudaModuleCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateCudaModuleNV && "Function requires " ); -# endif - - CudaModuleNV module; - Result result = static_cast( d.vkCreateCudaModuleNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &module ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaModuleNVUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( module, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::getCudaModuleCacheNV( CudaModuleNV module, size_t * pCacheSize, void * pCacheData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetCudaModuleCacheNV( static_cast( m_device ), static_cast( module ), pCacheSize, pCacheData ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getCudaModuleCacheNV( CudaModuleNV module, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetCudaModuleCacheNV && "Function requires " ); -# endif - - std::vector cacheData; - size_t cacheSize; - Result result; - do - { - result = static_cast( d.vkGetCudaModuleCacheNV( m_device, static_cast( module ), &cacheSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && cacheSize ) - { - cacheData.resize( cacheSize ); - result = static_cast( - d.vkGetCudaModuleCacheNV( m_device, static_cast( module ), &cacheSize, reinterpret_cast( cacheData.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCudaModuleCacheNV" ); - VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() ); - if ( cacheSize < cacheData.size() ) - { - cacheData.resize( cacheSize ); - } - return detail::createResultValueType( result, std::move( cacheData ) ); - } - - // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getCudaModuleCacheNV( CudaModuleNV module, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetCudaModuleCacheNV && "Function requires " ); -# endif - - std::vector cacheData( uint8_tAllocator ); - size_t cacheSize; - Result result; - do - { - result = static_cast( d.vkGetCudaModuleCacheNV( m_device, static_cast( module ), &cacheSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && cacheSize ) - { - cacheData.resize( cacheSize ); - result = static_cast( - d.vkGetCudaModuleCacheNV( m_device, static_cast( module ), &cacheSize, reinterpret_cast( cacheData.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCudaModuleCacheNV" ); - VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() ); - if ( cacheSize < cacheData.size() ) - { - cacheData.resize( cacheSize ); - } - return detail::createResultValueType( result, std::move( cacheData ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createCudaFunctionNV( const CudaFunctionCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - CudaFunctionNV * pFunction, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateCudaFunctionNV( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pFunction ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createCudaFunctionNV( const CudaFunctionCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateCudaFunctionNV && "Function requires " ); -# endif - - CudaFunctionNV function; - Result result = static_cast( d.vkCreateCudaFunctionNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &function ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaFunctionNV" ); - - return detail::createResultValueType( result, std::move( function ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createCudaFunctionNVUnique( const CudaFunctionCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateCudaFunctionNV && "Function requires " ); -# endif - - CudaFunctionNV function; - Result result = static_cast( d.vkCreateCudaFunctionNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &function ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createCudaFunctionNVUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( function, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyCudaModuleNV( CudaModuleNV module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyCudaModuleNV( - static_cast( m_device ), static_cast( module ), reinterpret_cast( pAllocator ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyCudaModuleNV( CudaModuleNV module, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyCudaModuleNV && "Function requires " ); -# endif - - d.vkDestroyCudaModuleNV( m_device, static_cast( module ), reinterpret_cast( allocator.get() ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( CudaModuleNV module, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyCudaModuleNV( - static_cast( m_device ), static_cast( module ), reinterpret_cast( pAllocator ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( CudaModuleNV module, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyCudaModuleNV && "Function requires " ); -# endif - - d.vkDestroyCudaModuleNV( m_device, static_cast( module ), reinterpret_cast( allocator.get() ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyCudaFunctionNV( CudaFunctionNV function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyCudaFunctionNV( - static_cast( m_device ), static_cast( function ), reinterpret_cast( pAllocator ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyCudaFunctionNV( CudaFunctionNV function, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyCudaFunctionNV && "Function requires " ); -# endif - - d.vkDestroyCudaFunctionNV( m_device, static_cast( function ), reinterpret_cast( allocator.get() ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( CudaFunctionNV function, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyCudaFunctionNV( - static_cast( m_device ), static_cast( function ), reinterpret_cast( pAllocator ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( CudaFunctionNV function, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyCudaFunctionNV && "Function requires " ); -# endif - - d.vkDestroyCudaFunctionNV( m_device, static_cast( function ), reinterpret_cast( allocator.get() ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const CudaLaunchInfoNV * pLaunchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCudaLaunchKernelNV( static_cast( m_commandBuffer ), reinterpret_cast( pLaunchInfo ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const CudaLaunchInfoNV & launchInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCudaLaunchKernelNV && "Function requires " ); -# endif - - d.vkCmdCudaLaunchKernelNV( m_commandBuffer, reinterpret_cast( &launchInfo ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - - // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchTileQCOM( const DispatchTileInfoQCOM * pDispatchTileInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDispatchTileQCOM( static_cast( m_commandBuffer ), reinterpret_cast( pDispatchTileInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchTileQCOM( const DispatchTileInfoQCOM & dispatchTileInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdDispatchTileQCOM && "Function requires " ); -# endif - - d.vkCmdDispatchTileQCOM( m_commandBuffer, reinterpret_cast( &dispatchTileInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM * pPerTileBeginInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginPerTileExecutionQCOM( static_cast( m_commandBuffer ), reinterpret_cast( pPerTileBeginInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM & perTileBeginInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBeginPerTileExecutionQCOM && "Function requires " ); -# endif - - d.vkCmdBeginPerTileExecutionQCOM( m_commandBuffer, reinterpret_cast( &perTileBeginInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const PerTileEndInfoQCOM * pPerTileEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndPerTileExecutionQCOM( static_cast( m_commandBuffer ), reinterpret_cast( pPerTileEndInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const PerTileEndInfoQCOM & perTileEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdEndPerTileExecutionQCOM && "Function requires " ); -# endif - - d.vkCmdEndPerTileExecutionQCOM( m_commandBuffer, reinterpret_cast( &perTileEndInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - - // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( ExportMetalObjectsInfoEXT * pMetalObjectsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkExportMetalObjectsEXT( static_cast( m_device ), reinterpret_cast( pMetalObjectsInfo ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( ExportMetalObjectsInfoEXT & metalObjectsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkExportMetalObjectsEXT && "Function requires " ); -# endif - - d.vkExportMetalObjectsEXT( m_device, reinterpret_cast( &metalObjectsInfo ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_synchronization2 === - - // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( Event event, const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetEvent2KHR( - static_cast( m_commandBuffer ), static_cast( event ), reinterpret_cast( pDependencyInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetEvent2KHR && "Function requires or " ); -# endif - - d.vkCmdSetEvent2KHR( m_commandBuffer, static_cast( event ), reinterpret_cast( &dependencyInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( Event event, PipelineStageFlags2 stageMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdResetEvent2KHR( static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); - } - - // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR( uint32_t eventCount, - const Event * pEvents, - const DependencyInfo * pDependencyInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdWaitEvents2KHR( static_cast( m_commandBuffer ), - eventCount, - reinterpret_cast( pEvents ), - reinterpret_cast( pDependencyInfos ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR( ArrayProxy const & events, - ArrayProxy const & dependencyInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdWaitEvents2KHR && "Function requires or " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); -# else - if ( events.size() != dependencyInfos.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdWaitEvents2KHR( m_commandBuffer, - events.size(), - reinterpret_cast( events.data() ), - reinterpret_cast( dependencyInfos.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const DependencyInfo * pDependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPipelineBarrier2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pDependencyInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const DependencyInfo & dependencyInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPipelineBarrier2KHR && "Function requires or " ); -# endif - - d.vkCmdPipelineBarrier2KHR( m_commandBuffer, reinterpret_cast( &dependencyInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::writeTimestamp2KHR( PipelineStageFlags2 stage, QueryPool queryPool, uint32_t query, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdWriteTimestamp2KHR( - static_cast( m_commandBuffer ), static_cast( stage ), static_cast( queryPool ), query ); - } - - // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Queue::submit2KHR( uint32_t submitCount, const SubmitInfo2 * pSubmits, Fence fence, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkQueueSubmit2KHR( static_cast( m_queue ), submitCount, reinterpret_cast( pSubmits ), static_cast( fence ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Queue::submit2KHR( ArrayProxy const & submits, Fence fence, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkQueueSubmit2KHR && "Function requires or " ); -# endif - - Result result = static_cast( - d.vkQueueSubmit2KHR( m_queue, submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Queue::submit2KHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_descriptor_buffer === - - // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout, DeviceSize * pLayoutSizeInBytes, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDescriptorSetLayoutSizeEXT( - static_cast( m_device ), static_cast( layout ), reinterpret_cast( pLayoutSizeInBytes ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize Device::getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutSizeEXT && "Function requires " ); -# endif - - DeviceSize layoutSizeInBytes; - d.vkGetDescriptorSetLayoutSizeEXT( m_device, static_cast( layout ), reinterpret_cast( &layoutSizeInBytes ) ); - - return layoutSizeInBytes; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutBindingOffsetEXT( DescriptorSetLayout layout, - uint32_t binding, - DeviceSize * pOffset, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDescriptorSetLayoutBindingOffsetEXT( - static_cast( m_device ), static_cast( layout ), binding, reinterpret_cast( pOffset ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize Device::getDescriptorSetLayoutBindingOffsetEXT( DescriptorSetLayout layout, - uint32_t binding, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutBindingOffsetEXT && - "Function requires " ); -# endif - - DeviceSize offset; - d.vkGetDescriptorSetLayoutBindingOffsetEXT( m_device, static_cast( layout ), binding, reinterpret_cast( &offset ) ); - - return offset; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::getDescriptorEXT( const DescriptorGetInfoEXT * pDescriptorInfo, size_t dataSize, void * pDescriptor, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDescriptorEXT( static_cast( m_device ), reinterpret_cast( pDescriptorInfo ), dataSize, pDescriptor ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDescriptorEXT && "Function requires " ); -# endif - - d.vkGetDescriptorEXT( m_device, reinterpret_cast( &descriptorInfo ), dataSize, pDescriptor ); - } - - // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorType Device::getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDescriptorEXT && "Function requires " ); -# endif - - DescriptorType descriptor; - d.vkGetDescriptorEXT( - m_device, reinterpret_cast( &descriptorInfo ), sizeof( DescriptorType ), reinterpret_cast( &descriptor ) ); - - return descriptor; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindDescriptorBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBuffersEXT( uint32_t bufferCount, - const DescriptorBufferBindingInfoEXT * pBindingInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindDescriptorBuffersEXT( - static_cast( m_commandBuffer ), bufferCount, reinterpret_cast( pBindingInfos ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindDescriptorBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBuffersEXT( ArrayProxy const & bindingInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorBuffersEXT && "Function requires " ); -# endif - - d.vkCmdBindDescriptorBuffersEXT( m_commandBuffer, bindingInfos.size(), reinterpret_cast( bindingInfos.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t firstSet, - uint32_t setCount, - const uint32_t * pBufferIndices, - const DeviceSize * pOffsets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDescriptorBufferOffsetsEXT( static_cast( m_commandBuffer ), - static_cast( pipelineBindPoint ), - static_cast( layout ), - firstSet, - setCount, - pBufferIndices, - reinterpret_cast( pOffsets ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t firstSet, - ArrayProxy const & bufferIndices, - ArrayProxy const & offsets, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetDescriptorBufferOffsetsEXT && "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( bufferIndices.size() == offsets.size() ); -# else - if ( bufferIndices.size() != offsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setDescriptorBufferOffsetsEXT: bufferIndices.size() != offsets.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdSetDescriptorBufferOffsetsEXT( m_commandBuffer, - static_cast( pipelineBindPoint ), - static_cast( layout ), - firstSet, - bufferIndices.size(), - bufferIndices.data(), - reinterpret_cast( offsets.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t set, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindDescriptorBufferEmbeddedSamplersEXT( - static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( layout ), set ); - } - - // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT * pInfo, - void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetBufferOpaqueCaptureDescriptorDataEXT( - static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferOpaqueCaptureDescriptorDataEXT && - "Function requires " ); -# endif - - DataType data; - Result result = static_cast( - d.vkGetBufferOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferOpaqueCaptureDescriptorDataEXT" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT * pInfo, - void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetImageOpaqueCaptureDescriptorDataEXT( - static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageOpaqueCaptureDescriptorDataEXT && - "Function requires " ); -# endif - - DataType data; - Result result = static_cast( - d.vkGetImageOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDescriptorDataEXT" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT * pInfo, - void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetImageViewOpaqueCaptureDescriptorDataEXT( - static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetImageViewOpaqueCaptureDescriptorDataEXT && - "Function requires " ); -# endif - - DataType data; - Result result = static_cast( - d.vkGetImageViewOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getImageViewOpaqueCaptureDescriptorDataEXT" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT * pInfo, - void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetSamplerOpaqueCaptureDescriptorDataEXT( - static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetSamplerOpaqueCaptureDescriptorDataEXT && - "Function requires " ); -# endif - - DataType data; - Result result = static_cast( - d.vkGetSamplerOpaqueCaptureDescriptorDataEXT( m_device, reinterpret_cast( &info ), &data ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSamplerOpaqueCaptureDescriptorDataEXT" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT( - const AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( - static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT && - "Function requires " ); -# endif - - DataType data; - Result result = static_cast( d.vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( - m_device, reinterpret_cast( &info ), &data ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_fragment_shading_rate_enums === - - // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, - const FragmentShadingRateCombinerOpKHR combinerOps[2], - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetFragmentShadingRateEnumNV( static_cast( m_commandBuffer ), - static_cast( shadingRate ), - reinterpret_cast( combinerOps ) ); - } - - //=== VK_EXT_mesh_shader === - - // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawMeshTasksEXT( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); - } - - // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectEXT( - Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawMeshTasksIndirectEXT( - static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); - } - - // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountEXT( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawMeshTasksIndirectCountEXT( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - //=== VK_KHR_copy_commands2 === - - // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyBuffer2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pCopyBufferInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyBuffer2KHR && "Function requires or " ); -# endif - - d.vkCmdCopyBuffer2KHR( m_commandBuffer, reinterpret_cast( ©BufferInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyImage2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pCopyImageInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const CopyImageInfo2 & copyImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyImage2KHR && "Function requires or " ); -# endif - - d.vkCmdCopyImage2KHR( m_commandBuffer, reinterpret_cast( ©ImageInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyBufferToImage2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( pCopyBufferToImageInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const CopyBufferToImageInfo2 & copyBufferToImageInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyBufferToImage2KHR && "Function requires or " ); -# endif - - d.vkCmdCopyBufferToImage2KHR( m_commandBuffer, reinterpret_cast( ©BufferToImageInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyImageToBuffer2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( pCopyImageToBufferInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const CopyImageToBufferInfo2 & copyImageToBufferInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyImageToBuffer2KHR && "Function requires or " ); -# endif - - d.vkCmdCopyImageToBuffer2KHR( m_commandBuffer, reinterpret_cast( ©ImageToBufferInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBlitImage2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pBlitImageInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const BlitImageInfo2 & blitImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBlitImage2KHR && "Function requires or " ); -# endif - - d.vkCmdBlitImage2KHR( m_commandBuffer, reinterpret_cast( &blitImageInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdResolveImage2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pResolveImageInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdResolveImage2KHR && "Function requires or " ); -# endif - - d.vkCmdResolveImage2KHR( m_commandBuffer, reinterpret_cast( &resolveImageInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_device_fault === - - // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts, - DeviceFaultInfoEXT * pFaultInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDeviceFaultInfoEXT( - static_cast( m_device ), reinterpret_cast( pFaultCounts ), reinterpret_cast( pFaultInfo ) ) ); - } - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - -# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::acquireWinrtDisplayNV( DisplayKHR display, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkAcquireWinrtDisplayNV( static_cast( m_physicalDevice ), static_cast( display ) ) ); - } -# else - // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::acquireWinrtDisplayNV( DisplayKHR display, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAcquireWinrtDisplayNV && "Function requires " ); -# endif - - Result result = static_cast( d.vkAcquireWinrtDisplayNV( m_physicalDevice, static_cast( display ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::acquireWinrtDisplayNV" ); - - return detail::createResultValueType( result ); - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, - DisplayKHR * pDisplay, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetWinrtDisplayNV( static_cast( m_physicalDevice ), deviceRelativeId, reinterpret_cast( pDisplay ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function requires " ); -# endif - - DisplayKHR display; - Result result = static_cast( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); - - return detail::createResultValueType( result, std::move( display ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetWinrtDisplayNV && "Function requires " ); -# endif - - DisplayKHR display; - Result result = static_cast( d.vkGetWinrtDisplayNV( m_physicalDevice, deviceRelativeId, reinterpret_cast( &display ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNVUnique" ); - - return detail::createResultValueType( result, UniqueHandle( display, detail::ObjectRelease( *this, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - - // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDirectFBSurfaceEXT( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Instance::createDirectFBSurfaceEXT( - const DirectFBSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDirectFBSurfaceEXT && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateDirectFBSurfaceEXT( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createDirectFBSurfaceEXTUnique( - const DirectFBSurfaceCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDirectFBSurfaceEXT && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateDirectFBSurfaceEXT( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXTUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html - template ::type> - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, - IDirectFB * dfb, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( static_cast( m_physicalDevice ), queueFamilyIndex, dfb ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html - template ::type> - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, - IDirectFB & dfb, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT && - "Function requires " ); -# endif - - VkBool32 result = d.vkGetPhysicalDeviceDirectFBPresentationSupportEXT( m_physicalDevice, queueFamilyIndex, &dfb ); - - return static_cast( result ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_vertex_input_dynamic_state === - - // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( uint32_t vertexBindingDescriptionCount, - const VertexInputBindingDescription2EXT * pVertexBindingDescriptions, - uint32_t vertexAttributeDescriptionCount, - const VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetVertexInputEXT( static_cast( m_commandBuffer ), - vertexBindingDescriptionCount, - reinterpret_cast( pVertexBindingDescriptions ), - vertexAttributeDescriptionCount, - reinterpret_cast( pVertexAttributeDescriptions ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setVertexInputEXT( ArrayProxy const & vertexBindingDescriptions, - ArrayProxy const & vertexAttributeDescriptions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetVertexInputEXT && "Function requires or " ); -# endif - - d.vkCmdSetVertexInputEXT( m_commandBuffer, - vertexBindingDescriptions.size(), - reinterpret_cast( vertexBindingDescriptions.data() ), - vertexAttributeDescriptions.size(), - reinterpret_cast( vertexAttributeDescriptions.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - - // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, - zx_handle_t * pZirconHandle, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetMemoryZirconHandleFUCHSIA( - static_cast( m_device ), reinterpret_cast( pGetZirconHandleInfo ), pZirconHandle ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryZirconHandleFUCHSIA && "Function requires " ); -# endif - - zx_handle_t zirconHandle; - Result result = static_cast( - d.vkGetMemoryZirconHandleFUCHSIA( m_device, reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); - - return detail::createResultValueType( result, std::move( zirconHandle ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType, - zx_handle_t zirconHandle, - MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetMemoryZirconHandlePropertiesFUCHSIA( static_cast( m_device ), - static_cast( handleType ), - zirconHandle, - reinterpret_cast( pMemoryZirconHandleProperties ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryZirconHandlePropertiesFUCHSIA && - "Function requires " ); -# endif - - MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties; - Result result = static_cast( - d.vkGetMemoryZirconHandlePropertiesFUCHSIA( m_device, - static_cast( handleType ), - zirconHandle, - reinterpret_cast( &memoryZirconHandleProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); - - return detail::createResultValueType( result, std::move( memoryZirconHandleProperties ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - - // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::importSemaphoreZirconHandleFUCHSIA( - const ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkImportSemaphoreZirconHandleFUCHSIA( - static_cast( m_device ), reinterpret_cast( pImportSemaphoreZirconHandleInfo ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkImportSemaphoreZirconHandleFUCHSIA && "Function requires " ); -# endif - - Result result = static_cast( d.vkImportSemaphoreZirconHandleFUCHSIA( - m_device, reinterpret_cast( &importSemaphoreZirconHandleInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" ); - - return detail::createResultValueType( result ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, - zx_handle_t * pZirconHandle, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetSemaphoreZirconHandleFUCHSIA( - static_cast( m_device ), reinterpret_cast( pGetZirconHandleInfo ), pZirconHandle ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetSemaphoreZirconHandleFUCHSIA && "Function requires " ); -# endif - - zx_handle_t zirconHandle; - Result result = static_cast( - d.vkGetSemaphoreZirconHandleFUCHSIA( m_device, reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); - - return detail::createResultValueType( result, std::move( zirconHandle ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - - // wrapper function for command vkCreateBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createBufferCollectionFUCHSIA( const BufferCollectionCreateInfoFUCHSIA * pCreateInfo, - const AllocationCallbacks * pAllocator, - BufferCollectionFUCHSIA * pCollection, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateBufferCollectionFUCHSIA( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pCollection ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createBufferCollectionFUCHSIA( - const BufferCollectionCreateInfoFUCHSIA & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateBufferCollectionFUCHSIA && "Function requires " ); -# endif - - BufferCollectionFUCHSIA collection; - Result result = static_cast( d.vkCreateBufferCollectionFUCHSIA( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &collection ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIA" ); - - return detail::createResultValueType( result, std::move( collection ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createBufferCollectionFUCHSIAUnique( const BufferCollectionCreateInfoFUCHSIA & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateBufferCollectionFUCHSIA && "Function requires " ); -# endif - - BufferCollectionFUCHSIA collection; - Result result = static_cast( d.vkCreateBufferCollectionFUCHSIA( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &collection ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIAUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( collection, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setBufferCollectionImageConstraintsFUCHSIA( BufferCollectionFUCHSIA collection, - const ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkSetBufferCollectionImageConstraintsFUCHSIA( static_cast( m_device ), - static_cast( collection ), - reinterpret_cast( pImageConstraintsInfo ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::setBufferCollectionImageConstraintsFUCHSIA( - BufferCollectionFUCHSIA collection, const ImageConstraintsInfoFUCHSIA & imageConstraintsInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSetBufferCollectionImageConstraintsFUCHSIA && - "Function requires " ); -# endif - - Result result = static_cast( d.vkSetBufferCollectionImageConstraintsFUCHSIA( - m_device, static_cast( collection ), reinterpret_cast( &imageConstraintsInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionImageConstraintsFUCHSIA" ); - - return detail::createResultValueType( result ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setBufferCollectionBufferConstraintsFUCHSIA( - BufferCollectionFUCHSIA collection, const BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkSetBufferCollectionBufferConstraintsFUCHSIA( static_cast( m_device ), - static_cast( collection ), - reinterpret_cast( pBufferConstraintsInfo ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::setBufferCollectionBufferConstraintsFUCHSIA( - BufferCollectionFUCHSIA collection, const BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSetBufferCollectionBufferConstraintsFUCHSIA && - "Function requires " ); -# endif - - Result result = static_cast( d.vkSetBufferCollectionBufferConstraintsFUCHSIA( - m_device, static_cast( collection ), reinterpret_cast( &bufferConstraintsInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setBufferCollectionBufferConstraintsFUCHSIA" ); - - return detail::createResultValueType( result ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyBufferCollectionFUCHSIA( - static_cast( m_device ), static_cast( collection ), reinterpret_cast( pAllocator ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyBufferCollectionFUCHSIA && "Function requires " ); -# endif - - d.vkDestroyBufferCollectionFUCHSIA( - m_device, static_cast( collection ), reinterpret_cast( allocator.get() ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( BufferCollectionFUCHSIA collection, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyBufferCollectionFUCHSIA( - static_cast( m_device ), static_cast( collection ), reinterpret_cast( pAllocator ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( BufferCollectionFUCHSIA collection, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyBufferCollectionFUCHSIA && "Function requires " ); -# endif - - d.vkDestroyBufferCollectionFUCHSIA( - m_device, static_cast( collection ), reinterpret_cast( allocator.get() ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection, - BufferCollectionPropertiesFUCHSIA * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetBufferCollectionPropertiesFUCHSIA( static_cast( m_device ), - static_cast( collection ), - reinterpret_cast( pProperties ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetBufferCollectionPropertiesFUCHSIA && - "Function requires " ); -# endif - - BufferCollectionPropertiesFUCHSIA properties; - Result result = static_cast( d.vkGetBufferCollectionPropertiesFUCHSIA( - m_device, static_cast( collection ), reinterpret_cast( &properties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getBufferCollectionPropertiesFUCHSIA" ); - - return detail::createResultValueType( result, std::move( properties ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - - // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( RenderPass renderpass, - Extent2D * pMaxWorkgroupSize, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( - static_cast( m_device ), static_cast( renderpass ), reinterpret_cast( pMaxWorkgroupSize ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getSubpassShadingMaxWorkgroupSizeHUAWEI( RenderPass renderpass, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI && - "Function requires " ); -# endif - - Extent2D maxWorkgroupSize; - Result result = static_cast( d.vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( - m_device, static_cast( renderpass ), reinterpret_cast( &maxWorkgroupSize ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getSubpassShadingMaxWorkgroupSizeHUAWEI" ); - - return detail::createResultValueType( result, std::move( maxWorkgroupSize ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSubpassShadingHUAWEI( static_cast( m_commandBuffer ) ); - } - - //=== VK_HUAWEI_invocation_mask === - - // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI( ImageView imageView, ImageLayout imageLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindInvocationMaskHUAWEI( - static_cast( m_commandBuffer ), static_cast( imageView ), static_cast( imageLayout ) ); - } - - //=== VK_NV_external_memory_rdma === - - // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, - RemoteAddressNV * pAddress, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetMemoryRemoteAddressNV( static_cast( m_device ), - reinterpret_cast( pMemoryGetRemoteAddressInfo ), - reinterpret_cast( pAddress ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryRemoteAddressNV && "Function requires " ); -# endif - - RemoteAddressNV address; - Result result = static_cast( d.vkGetMemoryRemoteAddressNV( - m_device, reinterpret_cast( &memoryGetRemoteAddressInfo ), reinterpret_cast( &address ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); - - return detail::createResultValueType( result, std::move( address ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_pipeline_properties === - - // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelinePropertiesEXT( const PipelineInfoEXT * pPipelineInfo, - BaseOutStructure * pPipelineProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPipelinePropertiesEXT( static_cast( m_device ), - reinterpret_cast( pPipelineInfo ), - reinterpret_cast( pPipelineProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getPipelinePropertiesEXT( const PipelineInfoEXT & pipelineInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelinePropertiesEXT && "Function requires " ); -# endif - - BaseOutStructure pipelineProperties; - Result result = static_cast( d.vkGetPipelinePropertiesEXT( - m_device, reinterpret_cast( &pipelineInfo ), reinterpret_cast( &pipelineProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" ); - - return detail::createResultValueType( result, std::move( pipelineProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_extended_dynamic_state2 === - - // wrapper function for command vkCmdSetPatchControlPointsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetPatchControlPointsEXT( static_cast( m_commandBuffer ), patchControlPoints ); - } - - // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT( Bool32 rasterizerDiscardEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetRasterizerDiscardEnableEXT( static_cast( m_commandBuffer ), static_cast( rasterizerDiscardEnable ) ); - } - - // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( Bool32 depthBiasEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthBiasEnableEXT( static_cast( m_commandBuffer ), static_cast( depthBiasEnable ) ); - } - - // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( LogicOp logicOp, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetLogicOpEXT( static_cast( m_commandBuffer ), static_cast( logicOp ) ); - } - - // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT( Bool32 primitiveRestartEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetPrimitiveRestartEnableEXT( static_cast( m_commandBuffer ), static_cast( primitiveRestartEnable ) ); - } - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - - // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateScreenSurfaceQNX( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateScreenSurfaceQNX && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateScreenSurfaceQNX( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::createScreenSurfaceQNXUnique( - const ScreenSurfaceCreateInfoQNX & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateScreenSurfaceQNX && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateScreenSurfaceQNX( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createScreenSurfaceQNXUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html - template ::type> - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, - struct _screen_window * window, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPhysicalDeviceScreenPresentationSupportQNX( static_cast( m_physicalDevice ), queueFamilyIndex, window ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html - template ::type> - VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, - struct _screen_window & window, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceScreenPresentationSupportQNX && - "Function requires " ); -# endif - - VkBool32 result = d.vkGetPhysicalDeviceScreenPresentationSupportQNX( m_physicalDevice, queueFamilyIndex, &window ); - - return static_cast( result ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_EXT_color_write_enable === - - // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::setColorWriteEnableEXT( uint32_t attachmentCount, const Bool32 * pColorWriteEnables, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetColorWriteEnableEXT( static_cast( m_commandBuffer ), attachmentCount, reinterpret_cast( pColorWriteEnables ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( ArrayProxy const & colorWriteEnables, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetColorWriteEnableEXT && "Function requires " ); -# endif - - d.vkCmdSetColorWriteEnableEXT( m_commandBuffer, colorWriteEnables.size(), reinterpret_cast( colorWriteEnables.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_ray_tracing_maintenance1 === - - // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirect2KHR( DeviceAddress indirectDeviceAddress, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdTraceRaysIndirect2KHR( static_cast( m_commandBuffer ), static_cast( indirectDeviceAddress ) ); - } - - //=== VK_EXT_multi_draw === - - // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT( uint32_t drawCount, - const MultiDrawInfoEXT * pVertexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawMultiEXT( static_cast( m_commandBuffer ), - drawCount, - reinterpret_cast( pVertexInfo ), - instanceCount, - firstInstance, - stride ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT( StridedArrayProxy const & vertexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdDrawMultiEXT && "Function requires " ); -# endif - - d.vkCmdDrawMultiEXT( m_commandBuffer, - vertexInfo.size(), - reinterpret_cast( vertexInfo.data() ), - instanceCount, - firstInstance, - vertexInfo.stride() ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT( uint32_t drawCount, - const MultiDrawIndexedInfoEXT * pIndexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride, - const int32_t * pVertexOffset, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawMultiIndexedEXT( static_cast( m_commandBuffer ), - drawCount, - reinterpret_cast( pIndexInfo ), - instanceCount, - firstInstance, - stride, - pVertexOffset ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT( StridedArrayProxy const & indexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - Optional vertexOffset, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdDrawMultiIndexedEXT && "Function requires " ); -# endif - - d.vkCmdDrawMultiIndexedEXT( m_commandBuffer, - indexInfo.size(), - reinterpret_cast( indexInfo.data() ), - instanceCount, - firstInstance, - indexInfo.stride(), - vertexOffset.get() ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_opacity_micromap === - - // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createMicromapEXT( const MicromapCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - MicromapEXT * pMicromap, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateMicromapEXT( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pMicromap ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createMicromapEXT( const MicromapCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateMicromapEXT && "Function requires " ); -# endif - - MicromapEXT micromap; - Result result = static_cast( d.vkCreateMicromapEXT( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( µmap ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createMicromapEXT" ); - - return detail::createResultValueType( result, std::move( micromap ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createMicromapEXTUnique( const MicromapCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateMicromapEXT && "Function requires " ); -# endif - - MicromapEXT micromap; - Result result = static_cast( d.vkCreateMicromapEXT( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( µmap ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createMicromapEXTUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( micromap, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyMicromapEXT( MicromapEXT micromap, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyMicromapEXT( - static_cast( m_device ), static_cast( micromap ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyMicromapEXT( MicromapEXT micromap, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyMicromapEXT && "Function requires " ); -# endif - - d.vkDestroyMicromapEXT( m_device, static_cast( micromap ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( MicromapEXT micromap, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyMicromapEXT( - static_cast( m_device ), static_cast( micromap ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( MicromapEXT micromap, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyMicromapEXT && "Function requires " ); -# endif - - d.vkDestroyMicromapEXT( m_device, static_cast( micromap ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::buildMicromapsEXT( uint32_t infoCount, const MicromapBuildInfoEXT * pInfos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBuildMicromapsEXT( static_cast( m_commandBuffer ), infoCount, reinterpret_cast( pInfos ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::buildMicromapsEXT( ArrayProxy const & infos, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBuildMicromapsEXT && "Function requires " ); -# endif - - d.vkCmdBuildMicromapsEXT( m_commandBuffer, infos.size(), reinterpret_cast( infos.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildMicromapsEXT( DeferredOperationKHR deferredOperation, - uint32_t infoCount, - const MicromapBuildInfoEXT * pInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkBuildMicromapsEXT( static_cast( m_device ), - static_cast( deferredOperation ), - infoCount, - reinterpret_cast( pInfos ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildMicromapsEXT( DeferredOperationKHR deferredOperation, - ArrayProxy const & infos, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBuildMicromapsEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkBuildMicromapsEXT( - m_device, static_cast( deferredOperation ), infos.size(), reinterpret_cast( infos.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::buildMicromapsEXT", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapEXT( DeferredOperationKHR deferredOperation, - const CopyMicromapInfoEXT * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCopyMicromapEXT( - static_cast( m_device ), static_cast( deferredOperation ), reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapEXT( DeferredOperationKHR deferredOperation, - const CopyMicromapInfoEXT & info, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyMicromapEXT && "Function requires " ); -# endif - - Result result = static_cast( - d.vkCopyMicromapEXT( m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapEXT", { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation, - const CopyMicromapToMemoryInfoEXT * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCopyMicromapToMemoryEXT( static_cast( m_device ), - static_cast( deferredOperation ), - reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation, - const CopyMicromapToMemoryInfoEXT & info, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyMicromapToMemoryEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkCopyMicromapToMemoryEXT( - m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::copyMicromapToMemoryEXT", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation, - const CopyMemoryToMicromapInfoEXT * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCopyMemoryToMicromapEXT( static_cast( m_device ), - static_cast( deferredOperation ), - reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation, - const CopyMemoryToMicromapInfoEXT & info, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCopyMemoryToMicromapEXT && "Function requires " ); -# endif - - Result result = static_cast( d.vkCopyMemoryToMicromapEXT( - m_device, static_cast( deferredOperation ), reinterpret_cast( &info ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::copyMemoryToMicromapEXT", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::writeMicromapsPropertiesEXT( uint32_t micromapCount, - const MicromapEXT * pMicromaps, - QueryType queryType, - size_t dataSize, - void * pData, - size_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkWriteMicromapsPropertiesEXT( static_cast( m_device ), - micromapCount, - reinterpret_cast( pMicromaps ), - static_cast( queryType ), - dataSize, - pData, - stride ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::writeMicromapsPropertiesEXT( - ArrayProxy const & micromaps, QueryType queryType, size_t dataSize, size_t stride, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkWriteMicromapsPropertiesEXT && "Function requires " ); -# endif - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( d.vkWriteMicromapsPropertiesEXT( m_device, - micromaps.size(), - reinterpret_cast( micromaps.data() ), - static_cast( queryType ), - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ), - stride ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertiesEXT" ); - - return detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::writeMicromapsPropertyEXT( ArrayProxy const & micromaps, QueryType queryType, size_t stride, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkWriteMicromapsPropertiesEXT && "Function requires " ); -# endif - - DataType data; - Result result = static_cast( d.vkWriteMicromapsPropertiesEXT( m_device, - micromaps.size(), - reinterpret_cast( micromaps.data() ), - static_cast( queryType ), - sizeof( DataType ), - reinterpret_cast( &data ), - stride ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::writeMicromapsPropertyEXT" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const CopyMicromapInfoEXT * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyMicromapEXT( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const CopyMicromapInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyMicromapEXT && "Function requires " ); -# endif - - d.vkCmdCopyMicromapEXT( m_commandBuffer, reinterpret_cast( &info ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyMicromapToMemoryEXT( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyMicromapToMemoryEXT && "Function requires " ); -# endif - - d.vkCmdCopyMicromapToMemoryEXT( m_commandBuffer, reinterpret_cast( &info ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT * pInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyMemoryToMicromapEXT( static_cast( m_commandBuffer ), reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToMicromapEXT && "Function requires " ); -# endif - - d.vkCmdCopyMemoryToMicromapEXT( m_commandBuffer, reinterpret_cast( &info ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::writeMicromapsPropertiesEXT( uint32_t micromapCount, - const MicromapEXT * pMicromaps, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdWriteMicromapsPropertiesEXT( static_cast( m_commandBuffer ), - micromapCount, - reinterpret_cast( pMicromaps ), - static_cast( queryType ), - static_cast( queryPool ), - firstQuery ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::writeMicromapsPropertiesEXT( ArrayProxy const & micromaps, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdWriteMicromapsPropertiesEXT && "Function requires " ); -# endif - - d.vkCmdWriteMicromapsPropertiesEXT( m_commandBuffer, - micromaps.size(), - reinterpret_cast( micromaps.data() ), - static_cast( queryType ), - static_cast( queryPool ), - firstQuery ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::getMicromapCompatibilityEXT( const MicromapVersionInfoEXT * pVersionInfo, - AccelerationStructureCompatibilityKHR * pCompatibility, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceMicromapCompatibilityEXT( static_cast( m_device ), - reinterpret_cast( pVersionInfo ), - reinterpret_cast( pCompatibility ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureCompatibilityKHR - Device::getMicromapCompatibilityEXT( const MicromapVersionInfoEXT & versionInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceMicromapCompatibilityEXT && "Function requires " ); -# endif - - AccelerationStructureCompatibilityKHR compatibility; - d.vkGetDeviceMicromapCompatibilityEXT( m_device, - reinterpret_cast( &versionInfo ), - reinterpret_cast( &compatibility ) ); - - return compatibility; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, - const MicromapBuildInfoEXT * pBuildInfo, - MicromapBuildSizesInfoEXT * pSizeInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetMicromapBuildSizesEXT( static_cast( m_device ), - static_cast( buildType ), - reinterpret_cast( pBuildInfo ), - reinterpret_cast( pSizeInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MicromapBuildSizesInfoEXT Device::getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, - const MicromapBuildInfoEXT & buildInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMicromapBuildSizesEXT && "Function requires " ); -# endif - - MicromapBuildSizesInfoEXT sizeInfo; - d.vkGetMicromapBuildSizesEXT( m_device, - static_cast( buildType ), - reinterpret_cast( &buildInfo ), - reinterpret_cast( &sizeInfo ) ); - - return sizeInfo; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_HUAWEI_cluster_culling_shader === - - // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawClusterHUAWEI( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); - } - - // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::drawClusterIndirectHUAWEI( Buffer buffer, DeviceSize offset, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDrawClusterIndirectHUAWEI( static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ) ); - } - - //=== VK_EXT_pageable_device_local_memory === - - // wrapper function for command vkSetDeviceMemoryPriorityEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::setMemoryPriorityEXT( DeviceMemory memory, float priority, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkSetDeviceMemoryPriorityEXT( static_cast( m_device ), static_cast( memory ), priority ); - } - - //=== VK_KHR_maintenance4 === - - // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceBufferMemoryRequirementsKHR( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirementsKHR && - "Function requires or " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetDeviceBufferMemoryRequirementsKHR( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceBufferMemoryRequirementsKHR && - "Function requires or " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetDeviceBufferMemoryRequirementsKHR( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceImageMemoryRequirementsKHR( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirementsKHR && - "Function requires or " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetDeviceImageMemoryRequirementsKHR( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageMemoryRequirementsKHR && - "Function requires or " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetDeviceImageMemoryRequirementsKHR( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo, - uint32_t * pSparseMemoryRequirementCount, - SparseImageMemoryRequirements2 * pSparseMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceImageSparseMemoryRequirementsKHR( static_cast( m_device ), - reinterpret_cast( pInfo ), - pSparseMemoryRequirementCount, - reinterpret_cast( pSparseMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html - template < - typename SparseImageMemoryRequirements2Allocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirementsKHR && - "Function requires or " ); -# endif - - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - d.vkGetDeviceImageSparseMemoryRequirementsKHR( - m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetDeviceImageSparseMemoryRequirementsKHR( m_device, - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } - - // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html - template < - typename SparseImageMemoryRequirements2Allocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, - SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageSparseMemoryRequirementsKHR && - "Function requires or " ); -# endif - - std::vector sparseMemoryRequirements( sparseImageMemoryRequirements2Allocator ); - uint32_t sparseMemoryRequirementCount; - d.vkGetDeviceImageSparseMemoryRequirementsKHR( - m_device, reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - d.vkGetDeviceImageSparseMemoryRequirementsKHR( m_device, - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VALVE_descriptor_set_host_mapping === - - // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html - template ::type> - VULKAN_HPP_INLINE void Device::getDescriptorSetLayoutHostMappingInfoVALVE( const DescriptorSetBindingReferenceVALVE * pBindingReference, - DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDescriptorSetLayoutHostMappingInfoVALVE( static_cast( m_device ), - reinterpret_cast( pBindingReference ), - reinterpret_cast( pHostMapping ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutHostMappingInfoVALVE Device::getDescriptorSetLayoutHostMappingInfoVALVE( - const DescriptorSetBindingReferenceVALVE & bindingReference, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDescriptorSetLayoutHostMappingInfoVALVE && - "Function requires " ); -# endif - - DescriptorSetLayoutHostMappingInfoVALVE hostMapping; - d.vkGetDescriptorSetLayoutHostMappingInfoVALVE( m_device, - reinterpret_cast( &bindingReference ), - reinterpret_cast( &hostMapping ) ); - - return hostMapping; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html - template ::type> - VULKAN_HPP_INLINE void Device::getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet, void ** ppData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDescriptorSetHostMappingVALVE( static_cast( m_device ), static_cast( descriptorSet ), ppData ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * Device::getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDescriptorSetHostMappingVALVE && - "Function requires " ); -# endif - - void * pData; - d.vkGetDescriptorSetHostMappingVALVE( m_device, static_cast( descriptorSet ), &pData ); - - return pData; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_copy_memory_indirect === - - // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::copyMemoryIndirectNV( DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyMemoryIndirectNV( static_cast( m_commandBuffer ), static_cast( copyBufferAddress ), copyCount, stride ); - } - - // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride, - Image dstImage, - ImageLayout dstImageLayout, - const ImageSubresourceLayers * pImageSubresources, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyMemoryToImageIndirectNV( static_cast( m_commandBuffer ), - static_cast( copyBufferAddress ), - copyCount, - stride, - static_cast( dstImage ), - static_cast( dstImageLayout ), - reinterpret_cast( pImageSubresources ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, - uint32_t stride, - Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & imageSubresources, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToImageIndirectNV && "Function requires " ); -# endif - - d.vkCmdCopyMemoryToImageIndirectNV( m_commandBuffer, - static_cast( copyBufferAddress ), - imageSubresources.size(), - stride, - static_cast( dstImage ), - static_cast( dstImageLayout ), - reinterpret_cast( imageSubresources.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_memory_decompression === - - // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryNV( uint32_t decompressRegionCount, - const DecompressMemoryRegionNV * pDecompressMemoryRegions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDecompressMemoryNV( static_cast( m_commandBuffer ), - decompressRegionCount, - reinterpret_cast( pDecompressMemoryRegions ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryNV( ArrayProxy const & decompressMemoryRegions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdDecompressMemoryNV && "Function requires " ); -# endif - - d.vkCmdDecompressMemoryNV( - m_commandBuffer, decompressMemoryRegions.size(), reinterpret_cast( decompressMemoryRegions.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountNV( DeviceAddress indirectCommandsAddress, - DeviceAddress indirectCommandsCountAddress, - uint32_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDecompressMemoryIndirectCountNV( static_cast( m_commandBuffer ), - static_cast( indirectCommandsAddress ), - static_cast( indirectCommandsCountAddress ), - stride ); - } - - //=== VK_NV_device_generated_commands_compute === - - // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html - template ::type> - VULKAN_HPP_INLINE void Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo * pCreateInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPipelineIndirectMemoryRequirementsNV( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectMemoryRequirementsNV && - "Function requires " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetPipelineIndirectMemoryRequirementsNV( - m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectMemoryRequirementsNV && - "Function requires " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetPipelineIndirectMemoryRequirementsNV( - m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::updatePipelineIndirectBufferNV( PipelineBindPoint pipelineBindPoint, Pipeline pipeline, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdUpdatePipelineIndirectBufferNV( - static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( pipeline ) ); - } - - // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html - template ::type> - VULKAN_HPP_INLINE DeviceAddress Device::getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPipelineIndirectDeviceAddressNV( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html - template ::type> - VULKAN_HPP_INLINE DeviceAddress Device::getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineIndirectDeviceAddressNV && - "Function requires " ); -# endif - - VkDeviceAddress result = d.vkGetPipelineIndirectDeviceAddressNV( m_device, reinterpret_cast( &info ) ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer * buffer, - NativeBufferPropertiesOHOS * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetNativeBufferPropertiesOHOS( static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetNativeBufferPropertiesOHOS && "Function requires " ); -# endif - - NativeBufferPropertiesOHOS properties; - Result result = - static_cast( d.vkGetNativeBufferPropertiesOHOS( m_device, &buffer, reinterpret_cast( &properties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getNativeBufferPropertiesOHOS" ); - - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetNativeBufferPropertiesOHOS && "Function requires " ); -# endif - - StructureChain structureChain; - NativeBufferPropertiesOHOS & properties = structureChain.template get(); - Result result = - static_cast( d.vkGetNativeBufferPropertiesOHOS( m_device, &buffer, reinterpret_cast( &properties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getNativeBufferPropertiesOHOS" ); - - return detail::createResultValueType( result, std::move( structureChain ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS * pInfo, - struct OH_NativeBuffer ** pBuffer, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetMemoryNativeBufferOHOS( static_cast( m_device ), reinterpret_cast( pInfo ), pBuffer ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryNativeBufferOHOS && "Function requires " ); -# endif - - struct OH_NativeBuffer * buffer; - Result result = - static_cast( d.vkGetMemoryNativeBufferOHOS( m_device, reinterpret_cast( &info ), &buffer ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryNativeBufferOHOS" ); - - return detail::createResultValueType( result, std::move( buffer ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_extended_dynamic_state3 === - - // wrapper function for command vkCmdSetDepthClampEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( Bool32 depthClampEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthClampEnableEXT( static_cast( m_commandBuffer ), static_cast( depthClampEnable ) ); - } - - // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setPolygonModeEXT( PolygonMode polygonMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetPolygonModeEXT( static_cast( m_commandBuffer ), static_cast( polygonMode ) ); - } - - // wrapper function for command vkCmdSetRasterizationSamplesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRasterizationSamplesEXT( SampleCountFlagBits rasterizationSamples, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetRasterizationSamplesEXT( static_cast( m_commandBuffer ), static_cast( rasterizationSamples ) ); - } - - // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::setSampleMaskEXT( SampleCountFlagBits samples, const SampleMask * pSampleMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetSampleMaskEXT( - static_cast( m_commandBuffer ), static_cast( samples ), reinterpret_cast( pSampleMask ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setSampleMaskEXT( SampleCountFlagBits samples, - ArrayProxy const & sampleMask, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetSampleMaskEXT && "Function requires or " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( sampleMask.size() == ( static_cast( samples ) + 31 ) / 32 ); -# else - if ( sampleMask.size() != ( static_cast( samples ) + 31 ) / 32 ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setSampleMaskEXT: sampleMask.size() != ( static_cast( samples ) + 31 ) / 32" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdSetSampleMaskEXT( m_commandBuffer, static_cast( samples ), reinterpret_cast( sampleMask.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setAlphaToCoverageEnableEXT( Bool32 alphaToCoverageEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetAlphaToCoverageEnableEXT( static_cast( m_commandBuffer ), static_cast( alphaToCoverageEnable ) ); - } - - // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setAlphaToOneEnableEXT( Bool32 alphaToOneEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetAlphaToOneEnableEXT( static_cast( m_commandBuffer ), static_cast( alphaToOneEnable ) ); - } - - // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEnableEXT( Bool32 logicOpEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetLogicOpEnableEXT( static_cast( m_commandBuffer ), static_cast( logicOpEnable ) ); - } - - // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( uint32_t firstAttachment, - uint32_t attachmentCount, - const Bool32 * pColorBlendEnables, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetColorBlendEnableEXT( - static_cast( m_commandBuffer ), firstAttachment, attachmentCount, reinterpret_cast( pColorBlendEnables ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( uint32_t firstAttachment, - ArrayProxy const & colorBlendEnables, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendEnableEXT && - "Function requires or " ); -# endif - - d.vkCmdSetColorBlendEnableEXT( m_commandBuffer, firstAttachment, colorBlendEnables.size(), reinterpret_cast( colorBlendEnables.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetColorBlendEquationEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEquationEXT( uint32_t firstAttachment, - uint32_t attachmentCount, - const ColorBlendEquationEXT * pColorBlendEquations, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetColorBlendEquationEXT( static_cast( m_commandBuffer ), - firstAttachment, - attachmentCount, - reinterpret_cast( pColorBlendEquations ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetColorBlendEquationEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEquationEXT( uint32_t firstAttachment, - ArrayProxy const & colorBlendEquations, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendEquationEXT && - "Function requires or " ); -# endif - - d.vkCmdSetColorBlendEquationEXT( - m_commandBuffer, firstAttachment, colorBlendEquations.size(), reinterpret_cast( colorBlendEquations.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT( uint32_t firstAttachment, - uint32_t attachmentCount, - const ColorComponentFlags * pColorWriteMasks, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetColorWriteMaskEXT( - static_cast( m_commandBuffer ), firstAttachment, attachmentCount, reinterpret_cast( pColorWriteMasks ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT( uint32_t firstAttachment, - ArrayProxy const & colorWriteMasks, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetColorWriteMaskEXT && - "Function requires or " ); -# endif - - d.vkCmdSetColorWriteMaskEXT( - m_commandBuffer, firstAttachment, colorWriteMasks.size(), reinterpret_cast( colorWriteMasks.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setTessellationDomainOriginEXT( TessellationDomainOrigin domainOrigin, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetTessellationDomainOriginEXT( static_cast( m_commandBuffer ), static_cast( domainOrigin ) ); - } - - // wrapper function for command vkCmdSetRasterizationStreamEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetRasterizationStreamEXT( static_cast( m_commandBuffer ), rasterizationStream ); - } - - // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setConservativeRasterizationModeEXT( ConservativeRasterizationModeEXT conservativeRasterizationMode, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetConservativeRasterizationModeEXT( static_cast( m_commandBuffer ), - static_cast( conservativeRasterizationMode ) ); - } - - // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetExtraPrimitiveOverestimationSizeEXT( static_cast( m_commandBuffer ), extraPrimitiveOverestimationSize ); - } - - // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthClipEnableEXT( Bool32 depthClipEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthClipEnableEXT( static_cast( m_commandBuffer ), static_cast( depthClipEnable ) ); - } - - // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEnableEXT( Bool32 sampleLocationsEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetSampleLocationsEnableEXT( static_cast( m_commandBuffer ), static_cast( sampleLocationsEnable ) ); - } - - // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setColorBlendAdvancedEXT( uint32_t firstAttachment, - uint32_t attachmentCount, - const ColorBlendAdvancedEXT * pColorBlendAdvanced, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetColorBlendAdvancedEXT( static_cast( m_commandBuffer ), - firstAttachment, - attachmentCount, - reinterpret_cast( pColorBlendAdvanced ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setColorBlendAdvancedEXT( uint32_t firstAttachment, - ArrayProxy const & colorBlendAdvanced, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetColorBlendAdvancedEXT && - "Function requires or " ); -# endif - - d.vkCmdSetColorBlendAdvancedEXT( - m_commandBuffer, firstAttachment, colorBlendAdvanced.size(), reinterpret_cast( colorBlendAdvanced.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetProvokingVertexModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setProvokingVertexModeEXT( ProvokingVertexModeEXT provokingVertexMode, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetProvokingVertexModeEXT( static_cast( m_commandBuffer ), static_cast( provokingVertexMode ) ); - } - - // wrapper function for command vkCmdSetLineRasterizationModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setLineRasterizationModeEXT( LineRasterizationModeEXT lineRasterizationMode, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetLineRasterizationModeEXT( static_cast( m_commandBuffer ), static_cast( lineRasterizationMode ) ); - } - - // wrapper function for command vkCmdSetLineStippleEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEnableEXT( Bool32 stippledLineEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetLineStippleEnableEXT( static_cast( m_commandBuffer ), static_cast( stippledLineEnable ) ); - } - - // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthClipNegativeOneToOneEXT( Bool32 negativeOneToOne, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthClipNegativeOneToOneEXT( static_cast( m_commandBuffer ), static_cast( negativeOneToOne ) ); - } - - // wrapper function for command vkCmdSetViewportWScalingEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingEnableNV( Bool32 viewportWScalingEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetViewportWScalingEnableNV( static_cast( m_commandBuffer ), static_cast( viewportWScalingEnable ) ); - } - - // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV( uint32_t firstViewport, - uint32_t viewportCount, - const ViewportSwizzleNV * pViewportSwizzles, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetViewportSwizzleNV( - static_cast( m_commandBuffer ), firstViewport, viewportCount, reinterpret_cast( pViewportSwizzles ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV( uint32_t firstViewport, - ArrayProxy const & viewportSwizzles, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetViewportSwizzleNV && - "Function requires or " ); -# endif - - d.vkCmdSetViewportSwizzleNV( - m_commandBuffer, firstViewport, viewportSwizzles.size(), reinterpret_cast( viewportSwizzles.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetCoverageToColorEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorEnableNV( Bool32 coverageToColorEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetCoverageToColorEnableNV( static_cast( m_commandBuffer ), static_cast( coverageToColorEnable ) ); - } - - // wrapper function for command vkCmdSetCoverageToColorLocationNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorLocationNV( uint32_t coverageToColorLocation, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetCoverageToColorLocationNV( static_cast( m_commandBuffer ), coverageToColorLocation ); - } - - // wrapper function for command vkCmdSetCoverageModulationModeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationModeNV( CoverageModulationModeNV coverageModulationMode, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetCoverageModulationModeNV( static_cast( m_commandBuffer ), static_cast( coverageModulationMode ) ); - } - - // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableEnableNV( Bool32 coverageModulationTableEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetCoverageModulationTableEnableNV( static_cast( m_commandBuffer ), static_cast( coverageModulationTableEnable ) ); - } - - // wrapper function for command vkCmdSetCoverageModulationTableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableNV( uint32_t coverageModulationTableCount, - const float * pCoverageModulationTable, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetCoverageModulationTableNV( static_cast( m_commandBuffer ), coverageModulationTableCount, pCoverageModulationTable ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetCoverageModulationTableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableNV( ArrayProxy const & coverageModulationTable, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetCoverageModulationTableNV && - "Function requires or " ); -# endif - - d.vkCmdSetCoverageModulationTableNV( m_commandBuffer, coverageModulationTable.size(), coverageModulationTable.data() ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetShadingRateImageEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setShadingRateImageEnableNV( Bool32 shadingRateImageEnable, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetShadingRateImageEnableNV( static_cast( m_commandBuffer ), static_cast( shadingRateImageEnable ) ); - } - - // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setRepresentativeFragmentTestEnableNV( Bool32 representativeFragmentTestEnable, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetRepresentativeFragmentTestEnableNV( static_cast( m_commandBuffer ), static_cast( representativeFragmentTestEnable ) ); - } - - // wrapper function for command vkCmdSetCoverageReductionModeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setCoverageReductionModeNV( CoverageReductionModeNV coverageReductionMode, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetCoverageReductionModeNV( static_cast( m_commandBuffer ), static_cast( coverageReductionMode ) ); - } - - //=== VK_ARM_tensors === - - // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createTensorARM( const TensorCreateInfoARM * pCreateInfo, - const AllocationCallbacks * pAllocator, - TensorARM * pTensor, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateTensorARM( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pTensor ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createTensorARM( const TensorCreateInfoARM & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateTensorARM && "Function requires " ); -# endif - - TensorARM tensor; - Result result = static_cast( d.vkCreateTensorARM( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &tensor ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorARM" ); - - return detail::createResultValueType( result, std::move( tensor ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createTensorARMUnique( const TensorCreateInfoARM & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateTensorARM && "Function requires " ); -# endif - - TensorARM tensor; - Result result = static_cast( d.vkCreateTensorARM( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &tensor ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorARMUnique" ); - - return detail::createResultValueType( result, UniqueHandle( tensor, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyTensorARM( TensorARM tensor, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyTensorARM( - static_cast( m_device ), static_cast( tensor ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyTensorARM( TensorARM tensor, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyTensorARM && "Function requires " ); -# endif - - d.vkDestroyTensorARM( m_device, static_cast( tensor ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( TensorARM tensor, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyTensorARM( - static_cast( m_device ), static_cast( tensor ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( TensorARM tensor, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyTensorARM && "Function requires " ); -# endif - - d.vkDestroyTensorARM( m_device, static_cast( tensor ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createTensorViewARM( const TensorViewCreateInfoARM * pCreateInfo, - const AllocationCallbacks * pAllocator, - TensorViewARM * pView, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateTensorViewARM( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pView ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createTensorViewARM( const TensorViewCreateInfoARM & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateTensorViewARM && "Function requires " ); -# endif - - TensorViewARM view; - Result result = static_cast( d.vkCreateTensorViewARM( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &view ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorViewARM" ); - - return detail::createResultValueType( result, std::move( view ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createTensorViewARMUnique( const TensorViewCreateInfoARM & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateTensorViewARM && "Function requires " ); -# endif - - TensorViewARM view; - Result result = static_cast( d.vkCreateTensorViewARM( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &view ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createTensorViewARMUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( view, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyTensorViewARM( TensorViewARM tensorView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyTensorViewARM( - static_cast( m_device ), static_cast( tensorView ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyTensorViewARM( TensorViewARM tensorView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyTensorViewARM && "Function requires " ); -# endif - - d.vkDestroyTensorViewARM( m_device, static_cast( tensorView ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( TensorViewARM tensorView, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyTensorViewARM( - static_cast( m_device ), static_cast( tensorView ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( TensorViewARM tensorView, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyTensorViewARM && "Function requires " ); -# endif - - d.vkDestroyTensorViewARM( m_device, static_cast( tensorView ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html - template ::type> - VULKAN_HPP_INLINE void Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetTensorMemoryRequirementsARM( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetTensorMemoryRequirementsARM && "Function requires " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetTensorMemoryRequirementsARM( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetTensorMemoryRequirementsARM && "Function requires " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetTensorMemoryRequirementsARM( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindTensorMemoryARM( uint32_t bindInfoCount, - const BindTensorMemoryInfoARM * pBindInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkBindTensorMemoryARM( static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::bindTensorMemoryARM( ArrayProxy const & bindInfos, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBindTensorMemoryARM && "Function requires " ); -# endif - - Result result = - static_cast( d.vkBindTensorMemoryARM( m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindTensorMemoryARM" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html - template ::type> - VULKAN_HPP_INLINE void Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceTensorMemoryRequirementsARM( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceTensorMemoryRequirementsARM && "Function requires " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetDeviceTensorMemoryRequirementsARM( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceTensorMemoryRequirementsARM && "Function requires " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetDeviceTensorMemoryRequirementsARM( - m_device, reinterpret_cast( &info ), reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyTensorARM( const CopyTensorInfoARM * pCopyTensorInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyTensorARM( static_cast( m_commandBuffer ), reinterpret_cast( pCopyTensorInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyTensorARM( const CopyTensorInfoARM & copyTensorInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyTensorARM && "Function requires " ); -# endif - - d.vkCmdCopyTensorARM( m_commandBuffer, reinterpret_cast( ©TensorInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getExternalTensorPropertiesARM( const PhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo, - ExternalTensorPropertiesARM * pExternalTensorProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceExternalTensorPropertiesARM( static_cast( m_physicalDevice ), - reinterpret_cast( pExternalTensorInfo ), - reinterpret_cast( pExternalTensorProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalTensorPropertiesARM PhysicalDevice::getExternalTensorPropertiesARM( - const PhysicalDeviceExternalTensorInfoARM & externalTensorInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceExternalTensorPropertiesARM && - "Function requires " ); -# endif - - ExternalTensorPropertiesARM externalTensorProperties; - d.vkGetPhysicalDeviceExternalTensorPropertiesARM( m_physicalDevice, - reinterpret_cast( &externalTensorInfo ), - reinterpret_cast( &externalTensorProperties ) ); - - return externalTensorProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM * pInfo, - void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetTensorOpaqueCaptureDescriptorDataARM( - static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetTensorOpaqueCaptureDescriptorDataARM && "Function requires " ); -# endif - - DataType data; - Result result = static_cast( - d.vkGetTensorOpaqueCaptureDescriptorDataARM( m_device, reinterpret_cast( &info ), &data ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDescriptorDataARM" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM * pInfo, - void * pData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetTensorViewOpaqueCaptureDescriptorDataARM( - static_cast( m_device ), reinterpret_cast( pInfo ), pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetTensorViewOpaqueCaptureDescriptorDataARM && - "Function requires " ); -# endif - - DataType data; - Result result = static_cast( - d.vkGetTensorViewOpaqueCaptureDescriptorDataARM( m_device, reinterpret_cast( &info ), &data ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getTensorViewOpaqueCaptureDescriptorDataARM" ); - - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_shader_module_identifier === - - // wrapper function for command vkGetShaderModuleIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::getShaderModuleIdentifierEXT( ShaderModule shaderModule, ShaderModuleIdentifierEXT * pIdentifier, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetShaderModuleIdentifierEXT( - static_cast( m_device ), static_cast( shaderModule ), reinterpret_cast( pIdentifier ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetShaderModuleIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ShaderModuleIdentifierEXT Device::getShaderModuleIdentifierEXT( ShaderModule shaderModule, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetShaderModuleIdentifierEXT && "Function requires " ); -# endif - - ShaderModuleIdentifierEXT identifier; - d.vkGetShaderModuleIdentifierEXT( m_device, static_cast( shaderModule ), reinterpret_cast( &identifier ) ); - - return identifier; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo * pCreateInfo, - ShaderModuleIdentifierEXT * pIdentifier, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetShaderModuleCreateInfoIdentifierEXT( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pIdentifier ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ShaderModuleIdentifierEXT - Device::getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo & createInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetShaderModuleCreateInfoIdentifierEXT && - "Function requires " ); -# endif - - ShaderModuleIdentifierEXT identifier; - d.vkGetShaderModuleCreateInfoIdentifierEXT( - m_device, reinterpret_cast( &createInfo ), reinterpret_cast( &identifier ) ); - - return identifier; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_optical_flow === - - // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo, - uint32_t * pFormatCount, - OpticalFlowImageFormatPropertiesNV * pImageFormatProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( static_cast( m_physicalDevice ), - reinterpret_cast( pOpticalFlowImageFormatInfo ), - pFormatCount, - reinterpret_cast( pImageFormatProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html - template ::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV && - "Function requires " ); -# endif - - std::vector imageFormatProperties; - uint32_t formatCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( - m_physicalDevice, reinterpret_cast( &opticalFlowImageFormatInfo ), &formatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && formatCount ) - { - imageFormatProperties.resize( formatCount ); - result = static_cast( - d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( m_physicalDevice, - reinterpret_cast( &opticalFlowImageFormatInfo ), - &formatCount, - reinterpret_cast( imageFormatProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" ); - VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); - if ( formatCount < imageFormatProperties.size() ) - { - imageFormatProperties.resize( formatCount ); - } - return detail::createResultValueType( result, std::move( imageFormatProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html - template ::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, - OpticalFlowImageFormatPropertiesNVAllocator const & opticalFlowImageFormatPropertiesNVAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV && - "Function requires " ); -# endif - - std::vector imageFormatProperties( - opticalFlowImageFormatPropertiesNVAllocator ); - uint32_t formatCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( - m_physicalDevice, reinterpret_cast( &opticalFlowImageFormatInfo ), &formatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && formatCount ) - { - imageFormatProperties.resize( formatCount ); - result = static_cast( - d.vkGetPhysicalDeviceOpticalFlowImageFormatsNV( m_physicalDevice, - reinterpret_cast( &opticalFlowImageFormatInfo ), - &formatCount, - reinterpret_cast( imageFormatProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" ); - VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); - if ( formatCount < imageFormatProperties.size() ) - { - imageFormatProperties.resize( formatCount ); - } - return detail::createResultValueType( result, std::move( imageFormatProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createOpticalFlowSessionNV( const OpticalFlowSessionCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - OpticalFlowSessionNV * pSession, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateOpticalFlowSessionNV( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSession ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createOpticalFlowSessionNV( - const OpticalFlowSessionCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateOpticalFlowSessionNV && "Function requires " ); -# endif - - OpticalFlowSessionNV session; - Result result = static_cast( d.vkCreateOpticalFlowSessionNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &session ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createOpticalFlowSessionNV" ); - - return detail::createResultValueType( result, std::move( session ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::createOpticalFlowSessionNVUnique( - const OpticalFlowSessionCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateOpticalFlowSessionNV && "Function requires " ); -# endif - - OpticalFlowSessionNV session; - Result result = static_cast( d.vkCreateOpticalFlowSessionNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &session ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createOpticalFlowSessionNVUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( session, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyOpticalFlowSessionNV( OpticalFlowSessionNV session, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyOpticalFlowSessionNV( - static_cast( m_device ), static_cast( session ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyOpticalFlowSessionNV( OpticalFlowSessionNV session, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyOpticalFlowSessionNV && "Function requires " ); -# endif - - d.vkDestroyOpticalFlowSessionNV( - m_device, static_cast( session ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( OpticalFlowSessionNV session, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyOpticalFlowSessionNV( - static_cast( m_device ), static_cast( session ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( OpticalFlowSessionNV session, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyOpticalFlowSessionNV && "Function requires " ); -# endif - - d.vkDestroyOpticalFlowSessionNV( - m_device, static_cast( session ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindOpticalFlowSessionImageNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindOpticalFlowSessionImageNV( OpticalFlowSessionNV session, - OpticalFlowSessionBindingPointNV bindingPoint, - ImageView view, - ImageLayout layout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkBindOpticalFlowSessionImageNV( static_cast( m_device ), - static_cast( session ), - static_cast( bindingPoint ), - static_cast( view ), - static_cast( layout ) ) ); - } -#else - // wrapper function for command vkBindOpticalFlowSessionImageNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::bindOpticalFlowSessionImageNV( - OpticalFlowSessionNV session, OpticalFlowSessionBindingPointNV bindingPoint, ImageView view, ImageLayout layout, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBindOpticalFlowSessionImageNV && "Function requires " ); -# endif - - Result result = static_cast( d.vkBindOpticalFlowSessionImageNV( m_device, - static_cast( session ), - static_cast( bindingPoint ), - static_cast( view ), - static_cast( layout ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindOpticalFlowSessionImageNV" ); - - return detail::createResultValueType( result ); - } -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( OpticalFlowSessionNV session, - const OpticalFlowExecuteInfoNV * pExecuteInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdOpticalFlowExecuteNV( static_cast( m_commandBuffer ), - static_cast( session ), - reinterpret_cast( pExecuteInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( OpticalFlowSessionNV session, - const OpticalFlowExecuteInfoNV & executeInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdOpticalFlowExecuteNV && "Function requires " ); -# endif - - d.vkCmdOpticalFlowExecuteNV( - m_commandBuffer, static_cast( session ), reinterpret_cast( &executeInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_maintenance5 === - - // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::bindIndexBuffer2KHR( Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindIndexBuffer2KHR( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( size ), - static_cast( indexType ) ); - } - - // wrapper function for command vkGetRenderingAreaGranularityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getRenderingAreaGranularityKHR( const RenderingAreaInfo * pRenderingAreaInfo, - Extent2D * pGranularity, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetRenderingAreaGranularityKHR( - static_cast( m_device ), reinterpret_cast( pRenderingAreaInfo ), reinterpret_cast( pGranularity ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRenderingAreaGranularityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D Device::getRenderingAreaGranularityKHR( const RenderingAreaInfo & renderingAreaInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetRenderingAreaGranularityKHR && "Function requires or " ); -# endif - - Extent2D granularity; - d.vkGetRenderingAreaGranularityKHR( - m_device, reinterpret_cast( &renderingAreaInfo ), reinterpret_cast( &granularity ) ); - - return granularity; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo * pInfo, SubresourceLayout2 * pLayout, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDeviceImageSubresourceLayoutKHR( - static_cast( m_device ), reinterpret_cast( pInfo ), reinterpret_cast( pLayout ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayoutKHR && - "Function requires or " ); -# endif - - SubresourceLayout2 layout; - d.vkGetDeviceImageSubresourceLayoutKHR( - m_device, reinterpret_cast( &info ), reinterpret_cast( &layout ) ); - - return layout; - } - - // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDeviceImageSubresourceLayoutKHR && - "Function requires or " ); -# endif - - StructureChain structureChain; - SubresourceLayout2 & layout = structureChain.template get(); - d.vkGetDeviceImageSubresourceLayoutKHR( - m_device, reinterpret_cast( &info ), reinterpret_cast( &layout ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSubresourceLayout2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html - template ::type> - VULKAN_HPP_INLINE void Device::getImageSubresourceLayout2KHR( Image image, - const ImageSubresource2 * pSubresource, - SubresourceLayout2 * pLayout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetImageSubresourceLayout2KHR( static_cast( m_device ), - static_cast( image ), - reinterpret_cast( pSubresource ), - reinterpret_cast( pLayout ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSubresourceLayout2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Device::getImageSubresourceLayout2KHR( Image image, - const ImageSubresource2 & subresource, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( - d.vkGetImageSubresourceLayout2KHR && - "Function requires or or or " ); -# endif - - SubresourceLayout2 layout; - d.vkGetImageSubresourceLayout2KHR( m_device, - static_cast( image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return layout; - } - - // wrapper function for command vkGetImageSubresourceLayout2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getImageSubresourceLayout2KHR( Image image, const ImageSubresource2 & subresource, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( - d.vkGetImageSubresourceLayout2KHR && - "Function requires or or or " ); -# endif - - StructureChain structureChain; - SubresourceLayout2 & layout = structureChain.template get(); - d.vkGetImageSubresourceLayout2KHR( m_device, - static_cast( image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_AMD_anti_lag === - - // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html - template ::type> - VULKAN_HPP_INLINE void Device::antiLagUpdateAMD( const AntiLagDataAMD * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkAntiLagUpdateAMD( static_cast( m_device ), reinterpret_cast( pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html - template ::type> - VULKAN_HPP_INLINE void Device::antiLagUpdateAMD( const AntiLagDataAMD & data, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkAntiLagUpdateAMD && "Function requires " ); -# endif - - d.vkAntiLagUpdateAMD( m_device, reinterpret_cast( &data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_present_wait2 === - - // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForPresent2KHR( SwapchainKHR swapchain, - const PresentWait2InfoKHR * pPresentWait2Info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkWaitForPresent2KHR( - static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pPresentWait2Info ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForPresent2KHR( SwapchainKHR swapchain, - const PresentWait2InfoKHR & presentWait2Info, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkWaitForPresent2KHR && "Function requires " ); -# endif - - Result result = static_cast( - d.vkWaitForPresent2KHR( m_device, static_cast( swapchain ), reinterpret_cast( &presentWait2Info ) ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresent2KHR", - { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::waitForPresent2KHR", { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR } ); -# endif - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_shader_object === - - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createShadersEXT( uint32_t createInfoCount, - const ShaderCreateInfoEXT * pCreateInfos, - const AllocationCallbacks * pAllocator, - ShaderEXT * pShaders, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateShadersEXT( static_cast( m_device ), - createInfoCount, - reinterpret_cast( pCreateInfos ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pShaders ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> Device::createShadersEXT( - ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); -# endif - - std::vector shaders( createInfos.size() ); - Result result = static_cast( d.vkCreateShadersEXT( m_device, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( shaders.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); - - return ResultValue>( result, std::move( shaders ) ); - } - - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createShadersEXT( ArrayProxy const & createInfos, - Optional allocator, - ShaderEXTAllocator const & shaderEXTAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); -# endif - - std::vector shaders( createInfos.size(), {}, shaderEXTAllocator ); - Result result = static_cast( d.vkCreateShadersEXT( m_device, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( shaders.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); - - return ResultValue>( result, std::move( shaders ) ); - } - - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue - Device::createShaderEXT( const ShaderCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); -# endif - - ShaderEXT shader; - Result result = static_cast( d.vkCreateShadersEXT( m_device, - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &shader ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); - - return ResultValue( result, std::move( shader ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, ShaderEXTAllocator>> Device::createShadersEXTUnique( - ArrayProxy const & createInfos, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); -# endif - - std::vector shaders( createInfos.size() ); - Result result = static_cast( d.vkCreateShadersEXT( m_device, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( shaders.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); - std::vector, ShaderEXTAllocator> uniqueShaders; - uniqueShaders.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & shader : shaders ) - { - uniqueShaders.push_back( UniqueHandle( shader, deleter ) ); - } - return ResultValue, ShaderEXTAllocator>>( result, std::move( uniqueShaders ) ); - } - - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, ShaderEXTAllocator>> - Device::createShadersEXTUnique( ArrayProxy const & createInfos, - Optional allocator, - ShaderEXTAllocator const & shaderEXTAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); -# endif - - std::vector shaders( createInfos.size() ); - Result result = static_cast( d.vkCreateShadersEXT( m_device, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( shaders.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); - std::vector, ShaderEXTAllocator> uniqueShaders( shaderEXTAllocator ); - uniqueShaders.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & shader : shaders ) - { - uniqueShaders.push_back( UniqueHandle( shader, deleter ) ); - } - return ResultValue, ShaderEXTAllocator>>( result, std::move( uniqueShaders ) ); - } - - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createShaderEXTUnique( const ShaderCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateShadersEXT && "Function requires " ); -# endif - - ShaderEXT shader; - Result result = static_cast( d.vkCreateShadersEXT( m_device, - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &shader ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXTUnique", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); - - return ResultValue>( - result, UniqueHandle( shader, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyShaderEXT( ShaderEXT shader, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyShaderEXT( - static_cast( m_device ), static_cast( shader ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyShaderEXT( ShaderEXT shader, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyShaderEXT && "Function requires " ); -# endif - - d.vkDestroyShaderEXT( m_device, static_cast( shader ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( ShaderEXT shader, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyShaderEXT( - static_cast( m_device ), static_cast( shader ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( ShaderEXT shader, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyShaderEXT && "Function requires " ); -# endif - - d.vkDestroyShaderEXT( m_device, static_cast( shader ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::getShaderBinaryDataEXT( ShaderEXT shader, size_t * pDataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetShaderBinaryDataEXT( static_cast( m_device ), static_cast( shader ), pDataSize, pData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getShaderBinaryDataEXT( ShaderEXT shader, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetShaderBinaryDataEXT && "Function requires " ); -# endif - - std::vector data; - size_t dataSize; - Result result; - do - { - result = static_cast( d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = - static_cast( d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderBinaryDataEXT" ); - VULKAN_HPP_ASSERT( dataSize <= data.size() ); - if ( dataSize < data.size() ) - { - data.resize( dataSize ); - } - return detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getShaderBinaryDataEXT( ShaderEXT shader, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetShaderBinaryDataEXT && "Function requires " ); -# endif - - std::vector data( uint8_tAllocator ); - size_t dataSize; - Result result; - do - { - result = static_cast( d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = - static_cast( d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderBinaryDataEXT" ); - VULKAN_HPP_ASSERT( dataSize <= data.size() ); - if ( dataSize < data.size() ) - { - data.resize( dataSize ); - } - return detail::createResultValueType( result, std::move( data ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( uint32_t stageCount, - const ShaderStageFlagBits * pStages, - const ShaderEXT * pShaders, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindShadersEXT( static_cast( m_commandBuffer ), - stageCount, - reinterpret_cast( pStages ), - reinterpret_cast( pShaders ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( ArrayProxy const & stages, - ArrayProxy const & shaders, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindShadersEXT && "Function requires " ); -# endif -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( stages.size() == shaders.size() ); -# else - if ( stages.size() != shaders.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindShadersEXT: stages.size() != shaders.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - d.vkCmdBindShadersEXT( m_commandBuffer, - stages.size(), - reinterpret_cast( stages.data() ), - reinterpret_cast( shaders.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, - const DepthClampRangeEXT * pDepthClampRange, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDepthClampRangeEXT( static_cast( m_commandBuffer ), - static_cast( depthClampMode ), - reinterpret_cast( pDepthClampRange ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, - Optional depthClampRange, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetDepthClampRangeEXT && - "Function requires or " ); -# endif - - d.vkCmdSetDepthClampRangeEXT( - m_commandBuffer, static_cast( depthClampMode ), reinterpret_cast( depthClampRange.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_pipeline_binary === - - // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - PipelineBinaryHandlesInfoKHR * pBinaries, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreatePipelineBinariesKHR( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pBinaries ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function requires " ); -# endif - - std::vector pipelineBinaries; - PipelineBinaryHandlesInfoKHR binaries; - Result result; - if ( createInfo.pKeysAndDataInfo ) - { - VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo ); - pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount ); - binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount; - binaries.pPipelineBinaries = pipelineBinaries.data(); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - } - else - { - VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo ); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - if ( result == Result::eSuccess ) - { - pipelineBinaries.resize( binaries.pipelineBinaryCount ); - binaries.pPipelineBinaries = pipelineBinaries.data(); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - } - } - - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHR", { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } ); - - return ResultValue>( result, std::move( pipelineBinaries ) ); - } - - // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo, - Optional allocator, - PipelineBinaryKHRAllocator const & pipelineBinaryKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function requires " ); -# endif - - std::vector pipelineBinaries( pipelineBinaryKHRAllocator ); - PipelineBinaryHandlesInfoKHR binaries; - Result result; - if ( createInfo.pKeysAndDataInfo ) - { - VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo ); - pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount ); - binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount; - binaries.pPipelineBinaries = pipelineBinaries.data(); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - } - else - { - VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo ); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - if ( result == Result::eSuccess ) - { - pipelineBinaries.resize( binaries.pipelineBinaryCount ); - binaries.pPipelineBinaries = pipelineBinaries.data(); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - } - } - - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHR", { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } ); - - return ResultValue>( result, std::move( pipelineBinaries ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineBinaryKHRAllocator>> - Device::createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function requires " ); -# endif - - std::vector pipelineBinaries; - PipelineBinaryHandlesInfoKHR binaries; - Result result; - if ( createInfo.pKeysAndDataInfo ) - { - VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo ); - pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount ); - binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount; - binaries.pPipelineBinaries = pipelineBinaries.data(); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - } - else - { - VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo ); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - if ( result == Result::eSuccess ) - { - pipelineBinaries.resize( binaries.pipelineBinaryCount ); - binaries.pPipelineBinaries = pipelineBinaries.data(); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - } - } - - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHRUnique", - { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } ); - std::vector, PipelineBinaryKHRAllocator> uniquePipelineBinaries; - uniquePipelineBinaries.reserve( pipelineBinaries.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipelineBinary : pipelineBinaries ) - { - uniquePipelineBinaries.push_back( UniqueHandle( pipelineBinary, deleter ) ); - } - return ResultValue, PipelineBinaryKHRAllocator>>( result, std::move( uniquePipelineBinaries ) ); - } - - // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineBinaryKHRAllocator>> - Device::createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo, - Optional allocator, - PipelineBinaryKHRAllocator const & pipelineBinaryKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreatePipelineBinariesKHR && "Function requires " ); -# endif - - std::vector pipelineBinaries; - PipelineBinaryHandlesInfoKHR binaries; - Result result; - if ( createInfo.pKeysAndDataInfo ) - { - VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo ); - pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount ); - binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount; - binaries.pPipelineBinaries = pipelineBinaries.data(); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - } - else - { - VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo ); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - if ( result == Result::eSuccess ) - { - pipelineBinaries.resize( binaries.pipelineBinaryCount ); - binaries.pPipelineBinaries = pipelineBinaries.data(); - result = static_cast( d.vkCreatePipelineBinariesKHR( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - } - } - - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createPipelineBinariesKHRUnique", - { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } ); - std::vector, PipelineBinaryKHRAllocator> uniquePipelineBinaries( pipelineBinaryKHRAllocator ); - uniquePipelineBinaries.reserve( pipelineBinaries.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipelineBinary : pipelineBinaries ) - { - uniquePipelineBinaries.push_back( UniqueHandle( pipelineBinary, deleter ) ); - } - return ResultValue, PipelineBinaryKHRAllocator>>( result, std::move( uniquePipelineBinaries ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyPipelineBinaryKHR( - static_cast( m_device ), static_cast( pipelineBinary ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyPipelineBinaryKHR && "Function requires " ); -# endif - - d.vkDestroyPipelineBinaryKHR( - m_device, static_cast( pipelineBinary ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( PipelineBinaryKHR pipelineBinary, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyPipelineBinaryKHR( - static_cast( m_device ), static_cast( pipelineBinary ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( PipelineBinaryKHR pipelineBinary, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyPipelineBinaryKHR && "Function requires " ); -# endif - - d.vkDestroyPipelineBinaryKHR( - m_device, static_cast( pipelineBinary ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineKeyKHR( const PipelineCreateInfoKHR * pPipelineCreateInfo, - PipelineBinaryKeyKHR * pPipelineKey, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPipelineKeyKHR( static_cast( m_device ), - reinterpret_cast( pPipelineCreateInfo ), - reinterpret_cast( pPipelineKey ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getPipelineKeyKHR( Optional pipelineCreateInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineKeyKHR && "Function requires " ); -# endif - - PipelineBinaryKeyKHR pipelineKey; - Result result = static_cast( d.vkGetPipelineKeyKHR( - m_device, reinterpret_cast( pipelineCreateInfo.get() ), reinterpret_cast( &pipelineKey ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineKeyKHR" ); - - return detail::createResultValueType( result, std::move( pipelineKey ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR * pInfo, - PipelineBinaryKeyKHR * pPipelineBinaryKey, - size_t * pPipelineBinaryDataSize, - void * pPipelineBinaryData, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPipelineBinaryDataKHR( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pPipelineBinaryKey ), - pPipelineBinaryDataSize, - pPipelineBinaryData ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>>::type - Device::getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineBinaryDataKHR && "Function requires " ); -# endif - - std::pair> data_; - PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first; - std::vector & pipelineBinaryData = data_.second; - size_t pipelineBinaryDataSize; - Result result = static_cast( d.vkGetPipelineBinaryDataKHR( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &pipelineBinaryKey ), - &pipelineBinaryDataSize, - nullptr ) ); - if ( result == Result::eSuccess ) - { - pipelineBinaryData.resize( pipelineBinaryDataSize ); - result = static_cast( d.vkGetPipelineBinaryDataKHR( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &pipelineBinaryKey ), - &pipelineBinaryDataSize, - reinterpret_cast( pipelineBinaryData.data() ) ) ); - } - - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>>::type - Device::getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPipelineBinaryDataKHR && "Function requires " ); -# endif - - std::pair> data_( - std::piecewise_construct, std::forward_as_tuple(), std::forward_as_tuple( uint8_tAllocator ) ); - PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first; - std::vector & pipelineBinaryData = data_.second; - size_t pipelineBinaryDataSize; - Result result = static_cast( d.vkGetPipelineBinaryDataKHR( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &pipelineBinaryKey ), - &pipelineBinaryDataSize, - nullptr ) ); - if ( result == Result::eSuccess ) - { - pipelineBinaryData.resize( pipelineBinaryDataSize ); - result = static_cast( d.vkGetPipelineBinaryDataKHR( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &pipelineBinaryKey ), - &pipelineBinaryDataSize, - reinterpret_cast( pipelineBinaryData.data() ) ) ); - } - - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkReleaseCapturedPipelineDataKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR * pInfo, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkReleaseCapturedPipelineDataKHR( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pAllocator ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleaseCapturedPipelineDataKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type Device::releaseCapturedPipelineDataKHR( - const ReleaseCapturedPipelineDataInfoKHR & info, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkReleaseCapturedPipelineDataKHR && "Function requires " ); -# endif - - Result result = static_cast( d.vkReleaseCapturedPipelineDataKHR( - m_device, reinterpret_cast( &info ), reinterpret_cast( allocator.get() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseCapturedPipelineDataKHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_QCOM_tile_properties === - - // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, - uint32_t * pPropertiesCount, - TilePropertiesQCOM * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetFramebufferTilePropertiesQCOM( static_cast( m_device ), - static_cast( framebuffer ), - pPropertiesCount, - reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetFramebufferTilePropertiesQCOM && "Function requires " ); -# endif - - std::vector properties; - uint32_t propertiesCount; - Result result; - do - { - result = static_cast( d.vkGetFramebufferTilePropertiesQCOM( m_device, static_cast( framebuffer ), &propertiesCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertiesCount ) - { - properties.resize( propertiesCount ); - result = static_cast( d.vkGetFramebufferTilePropertiesQCOM( - m_device, static_cast( framebuffer ), &propertiesCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFramebufferTilePropertiesQCOM" ); - VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); - if ( propertiesCount < properties.size() ) - { - properties.resize( propertiesCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, - TilePropertiesQCOMAllocator const & tilePropertiesQCOMAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetFramebufferTilePropertiesQCOM && "Function requires " ); -# endif - - std::vector properties( tilePropertiesQCOMAllocator ); - uint32_t propertiesCount; - Result result; - do - { - result = static_cast( d.vkGetFramebufferTilePropertiesQCOM( m_device, static_cast( framebuffer ), &propertiesCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertiesCount ) - { - properties.resize( propertiesCount ); - result = static_cast( d.vkGetFramebufferTilePropertiesQCOM( - m_device, static_cast( framebuffer ), &propertiesCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getFramebufferTilePropertiesQCOM" ); - VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); - if ( propertiesCount < properties.size() ) - { - properties.resize( propertiesCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo * pRenderingInfo, - TilePropertiesQCOM * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDynamicRenderingTilePropertiesQCOM( static_cast( m_device ), - reinterpret_cast( pRenderingInfo ), - reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDynamicRenderingTilePropertiesQCOM && "Function requires " ); -# endif - - TilePropertiesQCOM properties; - Result result = static_cast( d.vkGetDynamicRenderingTilePropertiesQCOM( - m_device, reinterpret_cast( &renderingInfo ), reinterpret_cast( &properties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDynamicRenderingTilePropertiesQCOM" ); - - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_swapchain_maintenance1 === - - // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkReleaseSwapchainImagesKHR( static_cast( m_device ), reinterpret_cast( pReleaseInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkReleaseSwapchainImagesKHR && - "Function requires or " ); -# endif - - Result result = static_cast( d.vkReleaseSwapchainImagesKHR( m_device, reinterpret_cast( &releaseInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::releaseSwapchainImagesKHR" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_cooperative_vector === - - // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeVectorPropertiesNV( uint32_t * pPropertyCount, - CooperativeVectorPropertiesNV * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( - static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCooperativeVectorPropertiesNV( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV && - "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeVectorPropertiesNV" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCooperativeVectorPropertiesNV( CooperativeVectorPropertiesNVAllocator const & cooperativeVectorPropertiesNVAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV && - "Function requires " ); -# endif - - std::vector properties( cooperativeVectorPropertiesNVAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceCooperativeVectorPropertiesNV( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeVectorPropertiesNV" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkConvertCooperativeVectorMatrixNV( static_cast( m_device ), reinterpret_cast( pInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV & info, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkConvertCooperativeVectorMatrixNV && "Function requires " ); -# endif - - Result result = - static_cast( d.vkConvertCooperativeVectorMatrixNV( m_device, reinterpret_cast( &info ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::convertCooperativeVectorMatrixNV", { Result::eSuccess, Result::eIncomplete } ); - - return static_cast( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::convertCooperativeVectorMatrixNV( uint32_t infoCount, - const ConvertCooperativeVectorMatrixInfoNV * pInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdConvertCooperativeVectorMatrixNV( - static_cast( m_commandBuffer ), infoCount, reinterpret_cast( pInfos ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::convertCooperativeVectorMatrixNV( ArrayProxy const & infos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdConvertCooperativeVectorMatrixNV && "Function requires " ); -# endif - - d.vkCmdConvertCooperativeVectorMatrixNV( m_commandBuffer, infos.size(), reinterpret_cast( infos.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_low_latency2 === - - // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::setLatencySleepModeNV( SwapchainKHR swapchain, - const LatencySleepModeInfoNV * pSleepModeInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkSetLatencySleepModeNV( - static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pSleepModeInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::setLatencySleepModeNV( SwapchainKHR swapchain, const LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSetLatencySleepModeNV && "Function requires " ); -# endif - - Result result = static_cast( - d.vkSetLatencySleepModeNV( m_device, static_cast( swapchain ), reinterpret_cast( &sleepModeInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::setLatencySleepModeNV" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::latencySleepNV( SwapchainKHR swapchain, - const LatencySleepInfoNV * pSleepInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkLatencySleepNV( - static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pSleepInfo ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::latencySleepNV( SwapchainKHR swapchain, const LatencySleepInfoNV & sleepInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkLatencySleepNV && "Function requires " ); -# endif - - Result result = static_cast( - d.vkLatencySleepNV( m_device, static_cast( swapchain ), reinterpret_cast( &sleepInfo ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::latencySleepNV" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::setLatencyMarkerNV( SwapchainKHR swapchain, const SetLatencyMarkerInfoNV * pLatencyMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkSetLatencyMarkerNV( - static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pLatencyMarkerInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::setLatencyMarkerNV( SwapchainKHR swapchain, const SetLatencyMarkerInfoNV & latencyMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkSetLatencyMarkerNV && "Function requires " ); -# endif - - d.vkSetLatencyMarkerNV( m_device, static_cast( swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::getLatencyTimingsNV( SwapchainKHR swapchain, GetLatencyMarkerInfoNV * pLatencyMarkerInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetLatencyTimingsNV( - static_cast( m_device ), static_cast( swapchain ), reinterpret_cast( pLatencyMarkerInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getLatencyTimingsNV( SwapchainKHR swapchain, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetLatencyTimingsNV && "Function requires " ); -# endif - - std::vector timings; - GetLatencyMarkerInfoNV latencyMarkerInfo; - d.vkGetLatencyTimingsNV( m_device, static_cast( swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); - timings.resize( latencyMarkerInfo.timingCount ); - latencyMarkerInfo.pTimings = timings.data(); - d.vkGetLatencyTimingsNV( m_device, static_cast( swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); - - return timings; - } - - // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Device::getLatencyTimingsNV( - SwapchainKHR swapchain, LatencyTimingsFrameReportNVAllocator const & latencyTimingsFrameReportNVAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetLatencyTimingsNV && "Function requires " ); -# endif - - std::vector timings( latencyTimingsFrameReportNVAllocator ); - GetLatencyMarkerInfoNV latencyMarkerInfo; - d.vkGetLatencyTimingsNV( m_device, static_cast( swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); - timings.resize( latencyMarkerInfo.timingCount ); - latencyMarkerInfo.pTimings = timings.data(); - d.vkGetLatencyTimingsNV( m_device, static_cast( swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); - - return timings; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html - template ::type> - VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV * pQueueTypeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkQueueNotifyOutOfBandNV( static_cast( m_queue ), reinterpret_cast( pQueueTypeInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html - template ::type> - VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkQueueNotifyOutOfBandNV && "Function requires " ); -# endif - - d.vkQueueNotifyOutOfBandNV( m_queue, reinterpret_cast( &queueTypeInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_cooperative_matrix === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixPropertiesKHR( uint32_t * pPropertyCount, - CooperativeMatrixPropertiesKHR * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( - static_cast( m_physicalDevice ), pPropertyCount, reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html - template < - typename CooperativeMatrixPropertiesKHRAllocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCooperativeMatrixPropertiesKHR( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR && - "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html - template < - typename CooperativeMatrixPropertiesKHRAllocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator const & cooperativeMatrixPropertiesKHRAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR && - "Function requires " ); -# endif - - std::vector properties( cooperativeMatrixPropertiesKHRAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_ARM_data_graph === - - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - uint32_t createInfoCount, - const DataGraphPipelineCreateInfoARM * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDataGraphPipelinesARM( static_cast( m_device ), - static_cast( deferredOperation ), - static_cast( pipelineCache ), - createInfoCount, - reinterpret_cast( pCreateInfos ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pPipelines ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARM", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size(), {}, pipelineAllocator ); - Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARM", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - - return ResultValue>( result, std::move( pipelines ) ); - } - - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::createDataGraphPipelineARM( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - const DataGraphPipelineCreateInfoARM & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineARM", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue( result, std::move( pipeline ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARMUnique", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines; - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template >::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue, PipelineAllocator>> - Device::createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); -# endif - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - detail::resultCheck( result, - VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelinesARMUnique", - { Result::eSuccess, Result::ePipelineCompileRequiredEXT }, - m_device, - pipelines, - allocator.get(), - d ); - std::vector, PipelineAllocator> uniquePipelines( pipelineAllocator ); - uniquePipelines.reserve( createInfos.size() ); - detail::ObjectDestroy deleter( *this, allocator, d ); - for ( auto const & pipeline : pipelines ) - { - uniquePipelines.push_back( UniqueHandle( pipeline, deleter ) ); - } - return ResultValue, PipelineAllocator>>( result, std::move( uniquePipelines ) ); - } - - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - Device::createDataGraphPipelineARMUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - const DataGraphPipelineCreateInfoARM & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelinesARM && "Function requires " ); -# endif - - Pipeline pipeline; - Result result = static_cast( d.vkCreateDataGraphPipelinesARM( m_device, - static_cast( deferredOperation ), - static_cast( pipelineCache ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - detail::resultCheck( - result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineARMUnique", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - - return ResultValue>( - result, UniqueHandle( pipeline, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createDataGraphPipelineSessionARM( const DataGraphPipelineSessionCreateInfoARM * pCreateInfo, - const AllocationCallbacks * pAllocator, - DataGraphPipelineSessionARM * pSession, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateDataGraphPipelineSessionARM( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSession ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createDataGraphPipelineSessionARM( - const DataGraphPipelineSessionCreateInfoARM & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelineSessionARM && "Function requires " ); -# endif - - DataGraphPipelineSessionARM session; - Result result = - static_cast( d.vkCreateDataGraphPipelineSessionARM( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &session ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineSessionARM" ); - - return detail::createResultValueType( result, std::move( session ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createDataGraphPipelineSessionARMUnique( const DataGraphPipelineSessionCreateInfoARM & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateDataGraphPipelineSessionARM && "Function requires " ); -# endif - - DataGraphPipelineSessionARM session; - Result result = - static_cast( d.vkCreateDataGraphPipelineSessionARM( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &session ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createDataGraphPipelineSessionARMUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( session, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM * pInfo, - uint32_t * pBindPointRequirementCount, - DataGraphPipelineSessionBindPointRequirementARM * pBindPointRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM( - static_cast( m_device ), - reinterpret_cast( pInfo ), - pBindPointRequirementCount, - reinterpret_cast( pBindPointRequirements ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html - template ::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Device::getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM & info, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM && - "Function requires " ); -# endif - - std::vector bindPointRequirements; - uint32_t bindPointRequirementCount; - Result result; - do - { - result = static_cast( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM( - m_device, reinterpret_cast( &info ), &bindPointRequirementCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && bindPointRequirementCount ) - { - bindPointRequirements.resize( bindPointRequirementCount ); - result = static_cast( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM( - m_device, - reinterpret_cast( &info ), - &bindPointRequirementCount, - reinterpret_cast( bindPointRequirements.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineSessionBindPointRequirementsARM" ); - VULKAN_HPP_ASSERT( bindPointRequirementCount <= bindPointRequirements.size() ); - if ( bindPointRequirementCount < bindPointRequirements.size() ) - { - bindPointRequirements.resize( bindPointRequirementCount ); - } - return detail::createResultValueType( result, std::move( bindPointRequirements ) ); - } - - // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html - template ::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - Device::getDataGraphPipelineSessionBindPointRequirementsARM( - const DataGraphPipelineSessionBindPointRequirementsInfoARM & info, - DataGraphPipelineSessionBindPointRequirementARMAllocator const & dataGraphPipelineSessionBindPointRequirementARMAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM && - "Function requires " ); -# endif - - std::vector bindPointRequirements( - dataGraphPipelineSessionBindPointRequirementARMAllocator ); - uint32_t bindPointRequirementCount; - Result result; - do - { - result = static_cast( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM( - m_device, reinterpret_cast( &info ), &bindPointRequirementCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && bindPointRequirementCount ) - { - bindPointRequirements.resize( bindPointRequirementCount ); - result = static_cast( d.vkGetDataGraphPipelineSessionBindPointRequirementsARM( - m_device, - reinterpret_cast( &info ), - &bindPointRequirementCount, - reinterpret_cast( bindPointRequirements.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineSessionBindPointRequirementsARM" ); - VULKAN_HPP_ASSERT( bindPointRequirementCount <= bindPointRequirements.size() ); - if ( bindPointRequirementCount < bindPointRequirements.size() ) - { - bindPointRequirements.resize( bindPointRequirementCount ); - } - return detail::createResultValueType( result, std::move( bindPointRequirements ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html - template ::type> - VULKAN_HPP_INLINE void Device::getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetDataGraphPipelineSessionMemoryRequirementsARM( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 Device::getDataGraphPipelineSessionMemoryRequirementsARM( - const DataGraphPipelineSessionMemoryRequirementsInfoARM & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionMemoryRequirementsARM && - "Function requires " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetDataGraphPipelineSessionMemoryRequirementsARM( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineSessionMemoryRequirementsARM && - "Function requires " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetDataGraphPipelineSessionMemoryRequirementsARM( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::bindDataGraphPipelineSessionMemoryARM( uint32_t bindInfoCount, - const BindDataGraphPipelineSessionMemoryInfoARM * pBindInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkBindDataGraphPipelineSessionMemoryARM( - static_cast( m_device ), bindInfoCount, reinterpret_cast( pBindInfos ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html - template ::type> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS VULKAN_HPP_INLINE typename ResultValueType::type - Device::bindDataGraphPipelineSessionMemoryARM( ArrayProxy const & bindInfos, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkBindDataGraphPipelineSessionMemoryARM && "Function requires " ); -# endif - - Result result = static_cast( d.vkBindDataGraphPipelineSessionMemoryARM( - m_device, bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::bindDataGraphPipelineSessionMemoryARM" ); - - return detail::createResultValueType( result ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDataGraphPipelineSessionARM( - static_cast( m_device ), static_cast( session ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDataGraphPipelineSessionARM && "Function requires " ); -# endif - - d.vkDestroyDataGraphPipelineSessionARM( - m_device, static_cast( session ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( DataGraphPipelineSessionARM session, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyDataGraphPipelineSessionARM( - static_cast( m_device ), static_cast( session ), reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( DataGraphPipelineSessionARM session, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyDataGraphPipelineSessionARM && "Function requires " ); -# endif - - d.vkDestroyDataGraphPipelineSessionARM( - m_device, static_cast( session ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchDataGraphARM( DataGraphPipelineSessionARM session, - const DataGraphPipelineDispatchInfoARM * pInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDispatchDataGraphARM( static_cast( m_commandBuffer ), - static_cast( session ), - reinterpret_cast( pInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::dispatchDataGraphARM( DataGraphPipelineSessionARM session, - Optional info, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdDispatchDataGraphARM && "Function requires " ); -# endif - - d.vkCmdDispatchDataGraphARM( - m_commandBuffer, static_cast( session ), reinterpret_cast( info.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, - uint32_t * pPropertiesCount, - DataGraphPipelinePropertyARM * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDataGraphPipelineAvailablePropertiesARM( static_cast( m_device ), - reinterpret_cast( pPipelineInfo ), - pPropertiesCount, - reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineAvailablePropertiesARM && - "Function requires " ); -# endif - - std::vector properties; - uint32_t propertiesCount; - Result result; - do - { - result = static_cast( d.vkGetDataGraphPipelineAvailablePropertiesARM( - m_device, reinterpret_cast( &pipelineInfo ), &propertiesCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertiesCount ) - { - properties.resize( propertiesCount ); - result = - static_cast( d.vkGetDataGraphPipelineAvailablePropertiesARM( m_device, - reinterpret_cast( &pipelineInfo ), - &propertiesCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineAvailablePropertiesARM" ); - VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); - if ( propertiesCount < properties.size() ) - { - properties.resize( propertiesCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo, - DataGraphPipelinePropertyARMAllocator const & dataGraphPipelinePropertyARMAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetDataGraphPipelineAvailablePropertiesARM && - "Function requires " ); -# endif - - std::vector properties( dataGraphPipelinePropertyARMAllocator ); - uint32_t propertiesCount; - Result result; - do - { - result = static_cast( d.vkGetDataGraphPipelineAvailablePropertiesARM( - m_device, reinterpret_cast( &pipelineInfo ), &propertiesCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertiesCount ) - { - properties.resize( propertiesCount ); - result = - static_cast( d.vkGetDataGraphPipelineAvailablePropertiesARM( m_device, - reinterpret_cast( &pipelineInfo ), - &propertiesCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getDataGraphPipelineAvailablePropertiesARM" ); - VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); - if ( propertiesCount < properties.size() ) - { - properties.resize( propertiesCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDataGraphPipelinePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelinePropertiesARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getDataGraphPipelinePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, - uint32_t propertiesCount, - DataGraphPipelinePropertyQueryResultARM * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetDataGraphPipelinePropertiesARM( static_cast( m_device ), - reinterpret_cast( pPipelineInfo ), - propertiesCount, - reinterpret_cast( pProperties ) ) ); - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - PhysicalDevice::getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, - uint32_t * pQueueFamilyDataGraphPropertyCount, - QueueFamilyDataGraphPropertiesARM * pQueueFamilyDataGraphProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( static_cast( m_physicalDevice ), - queueFamilyIndex, - pQueueFamilyDataGraphPropertyCount, - reinterpret_cast( pQueueFamilyDataGraphProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html - template < - typename QueueFamilyDataGraphPropertiesARMAllocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM && - "Function requires " ); -# endif - - std::vector queueFamilyDataGraphProperties; - uint32_t queueFamilyDataGraphPropertyCount; - Result result; - do - { - result = static_cast( - d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( m_physicalDevice, queueFamilyIndex, &queueFamilyDataGraphPropertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && queueFamilyDataGraphPropertyCount ) - { - queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); - result = static_cast( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( - m_physicalDevice, - queueFamilyIndex, - &queueFamilyDataGraphPropertyCount, - reinterpret_cast( queueFamilyDataGraphProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getQueueFamilyDataGraphPropertiesARM" ); - VULKAN_HPP_ASSERT( queueFamilyDataGraphPropertyCount <= queueFamilyDataGraphProperties.size() ); - if ( queueFamilyDataGraphPropertyCount < queueFamilyDataGraphProperties.size() ) - { - queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); - } - return detail::createResultValueType( result, std::move( queueFamilyDataGraphProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html - template < - typename QueueFamilyDataGraphPropertiesARMAllocator, - typename Dispatch, - typename std::enable_if::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, - QueueFamilyDataGraphPropertiesARMAllocator const & queueFamilyDataGraphPropertiesARMAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM && - "Function requires " ); -# endif - - std::vector queueFamilyDataGraphProperties( - queueFamilyDataGraphPropertiesARMAllocator ); - uint32_t queueFamilyDataGraphPropertyCount; - Result result; - do - { - result = static_cast( - d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( m_physicalDevice, queueFamilyIndex, &queueFamilyDataGraphPropertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && queueFamilyDataGraphPropertyCount ) - { - queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); - result = static_cast( d.vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( - m_physicalDevice, - queueFamilyIndex, - &queueFamilyDataGraphPropertyCount, - reinterpret_cast( queueFamilyDataGraphProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getQueueFamilyDataGraphPropertiesARM" ); - VULKAN_HPP_ASSERT( queueFamilyDataGraphPropertyCount <= queueFamilyDataGraphProperties.size() ); - if ( queueFamilyDataGraphPropertyCount < queueFamilyDataGraphProperties.size() ) - { - queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); - } - return detail::createResultValueType( result, std::move( queueFamilyDataGraphProperties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html - template ::type> - VULKAN_HPP_INLINE void PhysicalDevice::getQueueFamilyDataGraphProcessingEnginePropertiesARM( - const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM * pQueueFamilyDataGraphProcessingEngineInfo, - QueueFamilyDataGraphProcessingEnginePropertiesARM * pQueueFamilyDataGraphProcessingEngineProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( - static_cast( m_physicalDevice ), - reinterpret_cast( pQueueFamilyDataGraphProcessingEngineInfo ), - reinterpret_cast( pQueueFamilyDataGraphProcessingEngineProperties ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE QueueFamilyDataGraphProcessingEnginePropertiesARM PhysicalDevice::getQueueFamilyDataGraphProcessingEnginePropertiesARM( - const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & queueFamilyDataGraphProcessingEngineInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM && - "Function requires " ); -# endif - - QueueFamilyDataGraphProcessingEnginePropertiesARM queueFamilyDataGraphProcessingEngineProperties; - d.vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( - m_physicalDevice, - reinterpret_cast( &queueFamilyDataGraphProcessingEngineInfo ), - reinterpret_cast( &queueFamilyDataGraphProcessingEngineProperties ) ); - - return queueFamilyDataGraphProcessingEngineProperties; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - - // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setAttachmentFeedbackLoopEnableEXT( ImageAspectFlags aspectMask, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetAttachmentFeedbackLoopEnableEXT( static_cast( m_commandBuffer ), static_cast( aspectMask ) ); - } - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer, - ScreenBufferPropertiesQNX * pProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkGetScreenBufferPropertiesQNX( static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetScreenBufferPropertiesQNX && "Function requires " ); -# endif - - ScreenBufferPropertiesQNX properties; - Result result = - static_cast( d.vkGetScreenBufferPropertiesQNX( m_device, &buffer, reinterpret_cast( &properties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); - - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetScreenBufferPropertiesQNX && "Function requires " ); -# endif - - StructureChain structureChain; - ScreenBufferPropertiesQNX & properties = structureChain.template get(); - Result result = - static_cast( d.vkGetScreenBufferPropertiesQNX( m_device, &buffer, reinterpret_cast( &properties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); - - return detail::createResultValueType( result, std::move( structureChain ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_KHR_line_rasterization === - - // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetLineStippleKHR( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); - } - - //=== VK_KHR_calibrated_timestamps === - - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount, - TimeDomainKHR * pTimeDomains, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( - static_cast( m_physicalDevice ), pTimeDomainCount, reinterpret_cast( pTimeDomains ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCalibrateableTimeDomainsKHR( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR && - "Function requires or " ); -# endif - - std::vector timeDomains; - uint32_t timeDomainCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && timeDomainCount ) - { - timeDomains.resize( timeDomainCount ); - result = static_cast( - d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" ); - VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); - if ( timeDomainCount < timeDomains.size() ) - { - timeDomains.resize( timeDomainCount ); - } - return detail::createResultValueType( result, std::move( timeDomains ) ); - } - - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator const & timeDomainKHRAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR && - "Function requires or " ); -# endif - - std::vector timeDomains( timeDomainKHRAllocator ); - uint32_t timeDomainCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && timeDomainCount ) - { - timeDomains.resize( timeDomainCount ); - result = static_cast( - d.vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( m_physicalDevice, &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" ); - VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); - if ( timeDomainCount < timeDomains.size() ) - { - timeDomains.resize( timeDomainCount ); - } - return detail::createResultValueType( result, std::move( timeDomains ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getCalibratedTimestampsKHR( uint32_t timestampCount, - const CalibratedTimestampInfoKHR * pTimestampInfos, - uint64_t * pTimestamps, - uint64_t * pMaxDeviation, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetCalibratedTimestampsKHR( static_cast( m_device ), - timestampCount, - reinterpret_cast( pTimestampInfos ), - pTimestamps, - pMaxDeviation ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type - Device::getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR && - "Function requires or " ); -# endif - - std::pair, uint64_t> data_( - std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); - std::vector & timestamps = data_.first; - uint64_t & maxDeviation = data_.second; - Result result = static_cast( d.vkGetCalibratedTimestampsKHR( - m_device, timestampInfos.size(), reinterpret_cast( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - template ::value, int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type - Device::getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos, - Uint64_tAllocator const & uint64_tAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR && - "Function requires or " ); -# endif - - std::pair, uint64_t> data_( - std::piecewise_construct, std::forward_as_tuple( timestampInfos.size(), uint64_tAllocator ), std::forward_as_tuple( 0 ) ); - std::vector & timestamps = data_.first; - uint64_t & maxDeviation = data_.second; - Result result = static_cast( d.vkGetCalibratedTimestampsKHR( - m_device, timestampInfos.size(), reinterpret_cast( timestampInfos.data() ), timestamps.data(), &maxDeviation ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetCalibratedTimestampsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getCalibratedTimestampKHR( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetCalibratedTimestampsKHR && - "Function requires or " ); -# endif - - std::pair data_; - uint64_t & timestamp = data_.first; - uint64_t & maxDeviation = data_.second; - Result result = static_cast( - d.vkGetCalibratedTimestampsKHR( m_device, 1, reinterpret_cast( ×tampInfo ), ×tamp, &maxDeviation ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" ); - - return detail::createResultValueType( result, std::move( data_ ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_maintenance6 === - - // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2KHR( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindDescriptorSets2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( pBindDescriptorSetsInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2KHR( const BindDescriptorSetsInfo & bindDescriptorSetsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorSets2KHR && "Function requires or " ); -# endif - - d.vkCmdBindDescriptorSets2KHR( m_commandBuffer, reinterpret_cast( &bindDescriptorSetsInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const PushConstantsInfo * pPushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushConstants2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pPushConstantsInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const PushConstantsInfo & pushConstantsInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPushConstants2KHR && "Function requires or " ); -# endif - - d.vkCmdPushConstants2KHR( m_commandBuffer, reinterpret_cast( &pushConstantsInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2KHR( const PushDescriptorSetInfo * pPushDescriptorSetInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushDescriptorSet2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( pPushDescriptorSetInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2KHR( const PushDescriptorSetInfo & pushDescriptorSetInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSet2KHR && "Function requires or " ); -# endif - - d.vkCmdPushDescriptorSet2KHR( m_commandBuffer, reinterpret_cast( &pushDescriptorSetInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPushDescriptorSetWithTemplate2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( pPushDescriptorSetWithTemplateInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPushDescriptorSetWithTemplate2KHR && - "Function requires or " ); -# endif - - d.vkCmdPushDescriptorSetWithTemplate2KHR( m_commandBuffer, - reinterpret_cast( &pushDescriptorSetWithTemplateInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetDescriptorBufferOffsets2EXT( static_cast( m_commandBuffer ), - reinterpret_cast( pSetDescriptorBufferOffsetsInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetDescriptorBufferOffsets2EXT && "Function requires " ); -# endif - - d.vkCmdSetDescriptorBufferOffsets2EXT( m_commandBuffer, reinterpret_cast( &setDescriptorBufferOffsetsInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( - static_cast( m_commandBuffer ), - reinterpret_cast( pBindDescriptorBufferEmbeddedSamplersInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html - template ::type> - VULKAN_HPP_INLINE void - CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT && - "Function requires " ); -# endif - - d.vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( - m_commandBuffer, reinterpret_cast( &bindDescriptorBufferEmbeddedSamplersInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_QCOM_tile_memory_heap === - - // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( const TileMemoryBindInfoQCOM * pTileMemoryBindInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBindTileMemoryQCOM( static_cast( m_commandBuffer ), reinterpret_cast( pTileMemoryBindInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( Optional tileMemoryBindInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBindTileMemoryQCOM && "Function requires " ); -# endif - - d.vkCmdBindTileMemoryQCOM( m_commandBuffer, reinterpret_cast( tileMemoryBindInfo.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_copy_memory_indirect === - - // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyMemoryIndirectKHR( static_cast( m_commandBuffer ), - reinterpret_cast( pCopyMemoryIndirectInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryIndirectKHR && "Function requires " ); -# endif - - d.vkCmdCopyMemoryIndirectKHR( m_commandBuffer, reinterpret_cast( ©MemoryIndirectInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdCopyMemoryToImageIndirectKHR( static_cast( m_commandBuffer ), - reinterpret_cast( pCopyMemoryToImageIndirectInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdCopyMemoryToImageIndirectKHR && "Function requires " ); -# endif - - d.vkCmdCopyMemoryToImageIndirectKHR( m_commandBuffer, reinterpret_cast( ©MemoryToImageIndirectInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_memory_decompression === - - // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryEXT( const DecompressMemoryInfoEXT * pDecompressMemoryInfoEXT, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDecompressMemoryEXT( static_cast( m_commandBuffer ), - reinterpret_cast( pDecompressMemoryInfoEXT ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryEXT( const DecompressMemoryInfoEXT & decompressMemoryInfoEXT, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdDecompressMemoryEXT && "Function requires " ); -# endif - - d.vkCmdDecompressMemoryEXT( m_commandBuffer, reinterpret_cast( &decompressMemoryInfoEXT ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDecompressMemoryIndirectCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod, - DeviceAddress indirectCommandsAddress, - DeviceAddress indirectCommandsCountAddress, - uint32_t maxDecompressionCount, - uint32_t stride, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdDecompressMemoryIndirectCountEXT( static_cast( m_commandBuffer ), - static_cast( decompressionMethod ), - static_cast( indirectCommandsAddress ), - static_cast( indirectCommandsCountAddress ), - maxDecompressionCount, - stride ); - } - - //=== VK_NV_external_compute_queue === - - // wrapper function for command vkCreateExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createExternalComputeQueueNV( const ExternalComputeQueueCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - ExternalComputeQueueNV * pExternalQueue, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateExternalComputeQueueNV( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pExternalQueue ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createExternalComputeQueueNV( - const ExternalComputeQueueCreateInfoNV & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateExternalComputeQueueNV && "Function requires " ); -# endif - - ExternalComputeQueueNV externalQueue; - Result result = static_cast( d.vkCreateExternalComputeQueueNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &externalQueue ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExternalComputeQueueNV" ); - - return detail::createResultValueType( result, std::move( externalQueue ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createExternalComputeQueueNVUnique( const ExternalComputeQueueCreateInfoNV & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateExternalComputeQueueNV && "Function requires " ); -# endif - - ExternalComputeQueueNV externalQueue; - Result result = static_cast( d.vkCreateExternalComputeQueueNV( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &externalQueue ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExternalComputeQueueNVUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( externalQueue, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyExternalComputeQueueNV( static_cast( m_device ), - static_cast( externalQueue ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyExternalComputeQueueNV && "Function requires " ); -# endif - - d.vkDestroyExternalComputeQueueNV( - m_device, static_cast( externalQueue ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( ExternalComputeQueueNV externalQueue, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyExternalComputeQueueNV( static_cast( m_device ), - static_cast( externalQueue ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( ExternalComputeQueueNV externalQueue, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyExternalComputeQueueNV && "Function requires " ); -# endif - - d.vkDestroyExternalComputeQueueNV( - m_device, static_cast( externalQueue ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetExternalComputeQueueDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html - template ::type> - VULKAN_HPP_INLINE void - ExternalComputeQueueNV::getData( ExternalComputeQueueDataParamsNV * params, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetExternalComputeQueueDataNV( - static_cast( m_externalComputeQueueNV ), reinterpret_cast( params ), pData ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetExternalComputeQueueDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair - ExternalComputeQueueNV::getData( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetExternalComputeQueueDataNV && "Function requires " ); -# endif - - std::pair data_; - ExternalComputeQueueDataParamsNV & arams = data_.first; - DataType & data = data_.second; - d.vkGetExternalComputeQueueDataNV( m_externalComputeQueueNV, reinterpret_cast( &arams ), &data ); - - return data_; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_cluster_acceleration_structure === - - // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html - template ::type> - VULKAN_HPP_INLINE void Device::getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV * pInfo, - AccelerationStructureBuildSizesInfoKHR * pSizeInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetClusterAccelerationStructureBuildSizesNV( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pSizeInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR - Device::getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetClusterAccelerationStructureBuildSizesNV && - "Function requires " ); -# endif - - AccelerationStructureBuildSizesInfoKHR sizeInfo; - d.vkGetClusterAccelerationStructureBuildSizesNV( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &sizeInfo ) ); - - return sizeInfo; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV * pCommandInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBuildClusterAccelerationStructureIndirectNV( static_cast( m_commandBuffer ), - reinterpret_cast( pCommandInfos ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV & commandInfos, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBuildClusterAccelerationStructureIndirectNV && - "Function requires " ); -# endif - - d.vkCmdBuildClusterAccelerationStructureIndirectNV( m_commandBuffer, - reinterpret_cast( &commandInfos ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_partitioned_acceleration_structure === - - // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html - template ::type> - VULKAN_HPP_INLINE void Device::getPartitionedAccelerationStructuresBuildSizesNV( const PartitionedAccelerationStructureInstancesInputNV * pInfo, - AccelerationStructureBuildSizesInfoKHR * pSizeInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetPartitionedAccelerationStructuresBuildSizesNV( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pSizeInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR Device::getPartitionedAccelerationStructuresBuildSizesNV( - const PartitionedAccelerationStructureInstancesInputNV & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPartitionedAccelerationStructuresBuildSizesNV && - "Function requires " ); -# endif - - AccelerationStructureBuildSizesInfoKHR sizeInfo; - d.vkGetPartitionedAccelerationStructuresBuildSizesNV( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &sizeInfo ) ); - - return sizeInfo; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV * pBuildInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBuildPartitionedAccelerationStructuresNV( static_cast( m_commandBuffer ), - reinterpret_cast( pBuildInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV & buildInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBuildPartitionedAccelerationStructuresNV && - "Function requires " ); -# endif - - d.vkCmdBuildPartitionedAccelerationStructuresNV( m_commandBuffer, reinterpret_cast( &buildInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_device_generated_commands === - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkGetGeneratedCommandsMemoryRequirementsEXT( static_cast( m_device ), - reinterpret_cast( pInfo ), - reinterpret_cast( pMemoryRequirements ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsEXT && - "Function requires " ); -# endif - - MemoryRequirements2 memoryRequirements; - d.vkGetGeneratedCommandsMemoryRequirementsEXT( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetGeneratedCommandsMemoryRequirementsEXT && - "Function requires " ); -# endif - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - d.vkGetGeneratedCommandsMemoryRequirementsEXT( m_device, - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo, - CommandBuffer stateCommandBuffer, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdPreprocessGeneratedCommandsEXT( static_cast( m_commandBuffer ), - reinterpret_cast( pGeneratedCommandsInfo ), - static_cast( stateCommandBuffer ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT & generatedCommandsInfo, - CommandBuffer stateCommandBuffer, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdPreprocessGeneratedCommandsEXT && "Function requires " ); -# endif - - d.vkCmdPreprocessGeneratedCommandsEXT( - m_commandBuffer, reinterpret_cast( &generatedCommandsInfo ), static_cast( stateCommandBuffer ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsEXT( Bool32 isPreprocessed, - const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdExecuteGeneratedCommandsEXT( static_cast( m_commandBuffer ), - static_cast( isPreprocessed ), - reinterpret_cast( pGeneratedCommandsInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsEXT( Bool32 isPreprocessed, - const GeneratedCommandsInfoEXT & generatedCommandsInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdExecuteGeneratedCommandsEXT && "Function requires " ); -# endif - - d.vkCmdExecuteGeneratedCommandsEXT( - m_commandBuffer, static_cast( isPreprocessed ), reinterpret_cast( &generatedCommandsInfo ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createIndirectCommandsLayoutEXT( const IndirectCommandsLayoutCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - IndirectCommandsLayoutEXT * pIndirectCommandsLayout, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateIndirectCommandsLayoutEXT( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pIndirectCommandsLayout ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createIndirectCommandsLayoutEXT( - const IndirectCommandsLayoutCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutEXT && "Function requires " ); -# endif - - IndirectCommandsLayoutEXT indirectCommandsLayout; - Result result = static_cast( d.vkCreateIndirectCommandsLayoutEXT( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &indirectCommandsLayout ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutEXT" ); - - return detail::createResultValueType( result, std::move( indirectCommandsLayout ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createIndirectCommandsLayoutEXTUnique( const IndirectCommandsLayoutCreateInfoEXT & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateIndirectCommandsLayoutEXT && "Function requires " ); -# endif - - IndirectCommandsLayoutEXT indirectCommandsLayout; - Result result = static_cast( d.vkCreateIndirectCommandsLayoutEXT( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &indirectCommandsLayout ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutEXTUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( indirectCommandsLayout, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyIndirectCommandsLayoutEXT( static_cast( m_device ), - static_cast( indirectCommandsLayout ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutEXT && "Function requires " ); -# endif - - d.vkDestroyIndirectCommandsLayoutEXT( - m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( IndirectCommandsLayoutEXT indirectCommandsLayout, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyIndirectCommandsLayoutEXT( static_cast( m_device ), - static_cast( indirectCommandsLayout ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroy( IndirectCommandsLayoutEXT indirectCommandsLayout, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyIndirectCommandsLayoutEXT && "Function requires " ); -# endif - - d.vkDestroyIndirectCommandsLayoutEXT( - m_device, static_cast( indirectCommandsLayout ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createIndirectExecutionSetEXT( const IndirectExecutionSetCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - IndirectExecutionSetEXT * pIndirectExecutionSet, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateIndirectExecutionSetEXT( static_cast( m_device ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pIndirectExecutionSet ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::createIndirectExecutionSetEXT( - const IndirectExecutionSetCreateInfoEXT & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateIndirectExecutionSetEXT && "Function requires " ); -# endif - - IndirectExecutionSetEXT indirectExecutionSet; - Result result = static_cast( d.vkCreateIndirectExecutionSetEXT( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &indirectExecutionSet ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectExecutionSetEXT" ); - - return detail::createResultValueType( result, std::move( indirectExecutionSet ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createIndirectExecutionSetEXTUnique( const IndirectExecutionSetCreateInfoEXT & createInfo, - Optional allocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateIndirectExecutionSetEXT && "Function requires " ); -# endif - - IndirectExecutionSetEXT indirectExecutionSet; - Result result = static_cast( d.vkCreateIndirectExecutionSetEXT( m_device, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &indirectExecutionSet ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createIndirectExecutionSetEXTUnique" ); - - return detail::createResultValueType( - result, UniqueHandle( indirectExecutionSet, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet, - const AllocationCallbacks * pAllocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyIndirectExecutionSetEXT( static_cast( m_device ), - static_cast( indirectExecutionSet ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet, - Optional allocator, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyIndirectExecutionSetEXT && "Function requires " ); -# endif - - d.vkDestroyIndirectExecutionSetEXT( - m_device, static_cast( indirectExecutionSet ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( IndirectExecutionSetEXT indirectExecutionSet, const AllocationCallbacks * pAllocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkDestroyIndirectExecutionSetEXT( static_cast( m_device ), - static_cast( indirectExecutionSet ), - reinterpret_cast( pAllocator ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html - template ::type> - VULKAN_HPP_INLINE void - Device::destroy( IndirectExecutionSetEXT indirectExecutionSet, Optional allocator, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkDestroyIndirectExecutionSetEXT && "Function requires " ); -# endif - - d.vkDestroyIndirectExecutionSetEXT( - m_device, static_cast( indirectExecutionSet ), reinterpret_cast( allocator.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, - const WriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkUpdateIndirectExecutionSetPipelineEXT( static_cast( m_device ), - static_cast( indirectExecutionSet ), - executionSetWriteCount, - reinterpret_cast( pExecutionSetWrites ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet, - ArrayProxy const & executionSetWrites, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkUpdateIndirectExecutionSetPipelineEXT && - "Function requires " ); -# endif - - d.vkUpdateIndirectExecutionSetPipelineEXT( m_device, - static_cast( indirectExecutionSet ), - executionSetWrites.size(), - reinterpret_cast( executionSetWrites.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, - const WriteIndirectExecutionSetShaderEXT * pExecutionSetWrites, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkUpdateIndirectExecutionSetShaderEXT( static_cast( m_device ), - static_cast( indirectExecutionSet ), - executionSetWriteCount, - reinterpret_cast( pExecutionSetWrites ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html - template ::type> - VULKAN_HPP_INLINE void Device::updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet, - ArrayProxy const & executionSetWrites, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkUpdateIndirectExecutionSetShaderEXT && - "Function requires " ); -# endif - - d.vkUpdateIndirectExecutionSetShaderEXT( m_device, - static_cast( indirectExecutionSet ), - executionSetWrites.size(), - reinterpret_cast( executionSetWrites.data() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - - // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Instance::createSurfaceOHOS( const SurfaceCreateInfoOHOS * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkCreateSurfaceOHOS( static_cast( m_instance ), - reinterpret_cast( pCreateInfo ), - reinterpret_cast( pAllocator ), - reinterpret_cast( pSurface ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createSurfaceOHOS( const SurfaceCreateInfoOHOS & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSurfaceOHOS && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateSurfaceOHOS( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createSurfaceOHOS" ); - - return detail::createResultValueType( result, std::move( surface ) ); - } - -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::createSurfaceOHOSUnique( const SurfaceCreateInfoOHOS & createInfo, Optional allocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCreateSurfaceOHOS && "Function requires " ); -# endif - - SurfaceKHR surface; - Result result = static_cast( d.vkCreateSurfaceOHOS( m_instance, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Instance::createSurfaceOHOSUnique" ); - - return detail::createResultValueType( result, - UniqueHandle( surface, detail::ObjectDestroy( *this, allocator, d ) ) ); - } -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_NV_cooperative_matrix2 === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV( - uint32_t * pPropertyCount, CooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( - static_cast( m_physicalDevice ), - pPropertyCount, - reinterpret_cast( pProperties ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html - template ::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV( Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV && - "Function requires " ); -# endif - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html - template ::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType>::type - PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV( - CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator const & cooperativeMatrixFlexibleDimensionsPropertiesNVAllocator, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV && - "Function requires " ); -# endif - - std::vector properties( - cooperativeMatrixFlexibleDimensionsPropertiesNVAllocator ); - uint32_t propertyCount; - Result result; - do - { - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( m_physicalDevice, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( d.vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( - m_physicalDevice, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return detail::createResultValueType( result, std::move( properties ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - - // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo, - void ** pHandle, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetMemoryMetalHandleEXT( - static_cast( m_device ), reinterpret_cast( pGetMetalHandleInfo ), pHandle ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT & getMetalHandleInfo, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryMetalHandleEXT && "Function requires " ); -# endif - - void * handle; - Result result = - static_cast( d.vkGetMemoryMetalHandleEXT( m_device, reinterpret_cast( &getMetalHandleInfo ), &handle ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryMetalHandleEXT" ); - - return detail::createResultValueType( result, std::move( handle ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, - const void * pHandle, - MemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( d.vkGetMemoryMetalHandlePropertiesEXT( static_cast( m_device ), - static_cast( handleType ), - pHandle, - reinterpret_cast( pMemoryMetalHandleProperties ) ) ); - } - -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkGetMemoryMetalHandlePropertiesEXT && "Function requires " ); -# endif - - MemoryMetalHandlePropertiesEXT memoryMetalHandleProperties; - Result result = - static_cast( d.vkGetMemoryMetalHandlePropertiesEXT( m_device, - static_cast( handleType ), - reinterpret_cast( &handle ), - reinterpret_cast( &memoryMetalHandleProperties ) ) ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::getMemoryMetalHandlePropertiesEXT" ); - - return detail::createResultValueType( result, std::move( memoryMetalHandleProperties ) ); - } -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_ARM_performance_counters_by_region === - - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html - template ::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, - uint32_t * pCounterCount, - PerformanceCounterARM * pCounters, - PerformanceCounterDescriptionARM * pCounterDescriptions, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - return static_cast( - d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( static_cast( m_physicalDevice ), - queueFamilyIndex, - pCounterCount, - reinterpret_cast( pCounters ), - reinterpret_cast( pCounterDescriptions ) ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html - template ::value && - std::is_same::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType, - std::vector>>::type - PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM && - "Function requires " ); -# endif - - std::pair, - std::vector> - data_; - std::vector & counters = data_.first; - std::vector & counterDescriptions = data_.second; - uint32_t counterCount; - Result result; - do - { - result = static_cast( - d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); - if ( ( result == Result::eSuccess ) && counterCount ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( - m_physicalDevice, - queueFamilyIndex, - &counterCount, - reinterpret_cast( counters.data() ), - reinterpret_cast( counterDescriptions.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM" ); - VULKAN_HPP_ASSERT( counterCount <= counters.size() ); - if ( counterCount < counters.size() ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - } - return detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html - template ::value && - std::is_same::value, - int>::type, - typename std::enable_if::type> - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType, - std::vector>>::type - PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM( - uint32_t queueFamilyIndex, - PerformanceCounterARMAllocator const & performanceCounterARMAllocator, - PerformanceCounterDescriptionARMAllocator const & performanceCounterDescriptionARMAllocator, - Dispatch const & d ) const - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM && - "Function requires " ); -# endif - - std::pair, - std::vector> - data_( - std::piecewise_construct, std::forward_as_tuple( performanceCounterARMAllocator ), std::forward_as_tuple( performanceCounterDescriptionARMAllocator ) ); - std::vector & counters = data_.first; - std::vector & counterDescriptions = data_.second; - uint32_t counterCount; - Result result; - do - { - result = static_cast( - d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( m_physicalDevice, queueFamilyIndex, &counterCount, nullptr, nullptr ) ); - if ( ( result == Result::eSuccess ) && counterCount ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - result = static_cast( d.vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( - m_physicalDevice, - queueFamilyIndex, - &counterCount, - reinterpret_cast( counters.data() ), - reinterpret_cast( counterDescriptions.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM" ); - VULKAN_HPP_ASSERT( counterCount <= counters.size() ); - if ( counterCount < counters.size() ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - } - return detail::createResultValueType( result, std::move( data_ ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_fragment_density_map_offset === - - // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( const RenderingEndInfoKHR * pRenderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndRendering2EXT( static_cast( m_commandBuffer ), reinterpret_cast( pRenderingEndInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( Optional renderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdEndRendering2EXT && "Function requires or " ); -# endif - - d.vkCmdEndRendering2EXT( m_commandBuffer, reinterpret_cast( renderingEndInfo.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_custom_resolve === - - // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginCustomResolveEXT( const BeginCustomResolveInfoEXT * pBeginCustomResolveInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdBeginCustomResolveEXT( static_cast( m_commandBuffer ), - reinterpret_cast( pBeginCustomResolveInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::beginCustomResolveEXT( Optional beginCustomResolveInfo, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdBeginCustomResolveEXT && "Function requires " ); -# endif - - d.vkCmdBeginCustomResolveEXT( m_commandBuffer, reinterpret_cast( beginCustomResolveInfo.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_maintenance10 === - - // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endRendering2KHR( const RenderingEndInfoKHR * pRenderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdEndRendering2KHR( static_cast( m_commandBuffer ), reinterpret_cast( pRenderingEndInfo ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::endRendering2KHR( Optional renderingEndInfo, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdEndRendering2KHR && "Function requires or " ); -# endif - - d.vkCmdEndRendering2KHR( m_commandBuffer, reinterpret_cast( renderingEndInfo.get() ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_compute_occupancy_priority === - - // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV * pParameters, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); - d.vkCmdSetComputeOccupancyPriorityNV( static_cast( m_commandBuffer ), - reinterpret_cast( pParameters ) ); - } - -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html - template ::type> - VULKAN_HPP_INLINE void CommandBuffer::setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV & parameters, - Dispatch const & d ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); -# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) - VULKAN_HPP_ASSERT( d.vkCmdSetComputeOccupancyPriorityNV && "Function requires " ); -# endif - - d.vkCmdSetComputeOccupancyPriorityNV( m_commandBuffer, reinterpret_cast( ¶meters ) ); - } -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -} // namespace VULKAN_HPP_NAMESPACE -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_ggp.h b/lib/vulkan-headers/include/vulkan/vulkan_ggp.h deleted file mode 100644 index f8a48ec8769..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_ggp.h +++ /dev/null @@ -1,62 +0,0 @@ -#ifndef VULKAN_GGP_H_ -#define VULKAN_GGP_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_GGP_stream_descriptor_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_GGP_stream_descriptor_surface 1 -#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION 1 -#define VK_GGP_STREAM_DESCRIPTOR_SURFACE_EXTENSION_NAME "VK_GGP_stream_descriptor_surface" -typedef VkFlags VkStreamDescriptorSurfaceCreateFlagsGGP; -typedef struct VkStreamDescriptorSurfaceCreateInfoGGP { - VkStructureType sType; - const void* pNext; - VkStreamDescriptorSurfaceCreateFlagsGGP flags; - GgpStreamDescriptor streamDescriptor; -} VkStreamDescriptorSurfaceCreateInfoGGP; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateStreamDescriptorSurfaceGGP)(VkInstance instance, const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateStreamDescriptorSurfaceGGP( - VkInstance instance, - const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif -#endif - - -// VK_GGP_frame_token is a preprocessor guard. Do not pass it to API calls. -#define VK_GGP_frame_token 1 -#define VK_GGP_FRAME_TOKEN_SPEC_VERSION 1 -#define VK_GGP_FRAME_TOKEN_EXTENSION_NAME "VK_GGP_frame_token" -typedef struct VkPresentFrameTokenGGP { - VkStructureType sType; - const void* pNext; - GgpFrameToken frameToken; -} VkPresentFrameTokenGGP; - - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_handles.hpp b/lib/vulkan-headers/include/vulkan/vulkan_handles.hpp deleted file mode 100644 index 3ca8da889cd..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_handles.hpp +++ /dev/null @@ -1,22749 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_HANDLES_HPP -#define VULKAN_HANDLES_HPP - -// include-what-you-use: make sure, vulkan.hpp is used by code-completers -// IWYU pragma: private, include "vulkan/vulkan.hpp" - -namespace VULKAN_HPP_NAMESPACE -{ - - //=================================== - //=== STRUCT forward declarations === - //=================================== - - //=== VK_VERSION_1_0 === - struct Extent2D; - struct Extent3D; - struct Offset2D; - struct Offset3D; - struct Rect2D; - struct BaseInStructure; - struct BaseOutStructure; - struct BufferMemoryBarrier; - struct ImageMemoryBarrier; - struct MemoryBarrier; - struct AllocationCallbacks; - struct ApplicationInfo; - struct FormatProperties; - struct ImageFormatProperties; - struct InstanceCreateInfo; - struct MemoryHeap; - struct MemoryType; - struct PhysicalDeviceFeatures; - struct PhysicalDeviceLimits; - struct PhysicalDeviceMemoryProperties; - struct PhysicalDeviceProperties; - struct PhysicalDeviceSparseProperties; - struct QueueFamilyProperties; - struct DeviceCreateInfo; - struct DeviceQueueCreateInfo; - struct ExtensionProperties; - struct LayerProperties; - struct SubmitInfo; - struct MappedMemoryRange; - struct MemoryAllocateInfo; - struct MemoryRequirements; - struct BindSparseInfo; - struct ImageSubresource; - struct SparseBufferMemoryBindInfo; - struct SparseImageFormatProperties; - struct SparseImageMemoryBind; - struct SparseImageMemoryBindInfo; - struct SparseImageMemoryRequirements; - struct SparseImageOpaqueMemoryBindInfo; - struct SparseMemoryBind; - struct FenceCreateInfo; - struct SemaphoreCreateInfo; - struct QueryPoolCreateInfo; - struct BufferCreateInfo; - struct ImageCreateInfo; - struct SubresourceLayout; - struct ComponentMapping; - struct ImageSubresourceRange; - struct ImageViewCreateInfo; - struct CommandPoolCreateInfo; - struct CommandBufferAllocateInfo; - struct CommandBufferBeginInfo; - struct CommandBufferInheritanceInfo; - struct BufferCopy; - struct BufferImageCopy; - struct ImageCopy; - struct ImageSubresourceLayers; - struct DispatchIndirectCommand; - struct PipelineCacheHeaderVersionOne; - struct EventCreateInfo; - struct BufferViewCreateInfo; - struct ShaderModuleCreateInfo; - struct PipelineCacheCreateInfo; - struct ComputePipelineCreateInfo; - struct PipelineShaderStageCreateInfo; - struct SpecializationInfo; - struct SpecializationMapEntry; - struct PipelineLayoutCreateInfo; - struct PushConstantRange; - struct SamplerCreateInfo; - struct CopyDescriptorSet; - struct DescriptorBufferInfo; - struct DescriptorImageInfo; - struct DescriptorPoolCreateInfo; - struct DescriptorPoolSize; - struct DescriptorSetAllocateInfo; - struct DescriptorSetLayoutBinding; - struct DescriptorSetLayoutCreateInfo; - struct WriteDescriptorSet; - union ClearColorValue; - struct DrawIndexedIndirectCommand; - struct DrawIndirectCommand; - struct GraphicsPipelineCreateInfo; - struct PipelineColorBlendAttachmentState; - struct PipelineColorBlendStateCreateInfo; - struct PipelineDepthStencilStateCreateInfo; - struct PipelineDynamicStateCreateInfo; - struct PipelineInputAssemblyStateCreateInfo; - struct PipelineMultisampleStateCreateInfo; - struct PipelineRasterizationStateCreateInfo; - struct PipelineTessellationStateCreateInfo; - struct PipelineVertexInputStateCreateInfo; - struct PipelineViewportStateCreateInfo; - struct StencilOpState; - struct VertexInputAttributeDescription; - struct VertexInputBindingDescription; - struct Viewport; - struct AttachmentDescription; - struct AttachmentReference; - struct FramebufferCreateInfo; - struct RenderPassCreateInfo; - struct SubpassDependency; - struct SubpassDescription; - struct ClearAttachment; - struct ClearDepthStencilValue; - struct ClearRect; - union ClearValue; - struct ImageBlit; - struct ImageResolve; - struct RenderPassBeginInfo; - - //=== VK_VERSION_1_1 === - struct BindBufferMemoryInfo; - using BindBufferMemoryInfoKHR = BindBufferMemoryInfo; - struct BindImageMemoryInfo; - using BindImageMemoryInfoKHR = BindImageMemoryInfo; - struct MemoryDedicatedRequirements; - using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements; - struct MemoryDedicatedAllocateInfo; - using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo; - struct MemoryAllocateFlagsInfo; - using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo; - struct DeviceGroupCommandBufferBeginInfo; - using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo; - struct DeviceGroupSubmitInfo; - using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo; - struct DeviceGroupBindSparseInfo; - using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo; - struct BindBufferMemoryDeviceGroupInfo; - using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo; - struct BindImageMemoryDeviceGroupInfo; - using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo; - struct PhysicalDeviceGroupProperties; - using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; - struct DeviceGroupDeviceCreateInfo; - using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo; - struct BufferMemoryRequirementsInfo2; - using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2; - struct ImageMemoryRequirementsInfo2; - using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2; - struct ImageSparseMemoryRequirementsInfo2; - using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; - struct MemoryRequirements2; - using MemoryRequirements2KHR = MemoryRequirements2; - struct SparseImageMemoryRequirements2; - using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; - struct PhysicalDeviceFeatures2; - using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; - struct PhysicalDeviceProperties2; - using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; - struct FormatProperties2; - using FormatProperties2KHR = FormatProperties2; - struct ImageFormatProperties2; - using ImageFormatProperties2KHR = ImageFormatProperties2; - struct PhysicalDeviceImageFormatInfo2; - using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; - struct QueueFamilyProperties2; - using QueueFamilyProperties2KHR = QueueFamilyProperties2; - struct PhysicalDeviceMemoryProperties2; - using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; - struct SparseImageFormatProperties2; - using SparseImageFormatProperties2KHR = SparseImageFormatProperties2; - struct PhysicalDeviceSparseImageFormatInfo2; - using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; - struct ImageViewUsageCreateInfo; - using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; - struct PhysicalDeviceProtectedMemoryFeatures; - struct PhysicalDeviceProtectedMemoryProperties; - struct DeviceQueueInfo2; - struct ProtectedSubmitInfo; - struct BindImagePlaneMemoryInfo; - using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; - struct ImagePlaneMemoryRequirementsInfo; - using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo; - struct ExternalMemoryProperties; - using ExternalMemoryPropertiesKHR = ExternalMemoryProperties; - struct PhysicalDeviceExternalImageFormatInfo; - using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo; - struct ExternalImageFormatProperties; - using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties; - struct PhysicalDeviceExternalBufferInfo; - using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; - struct ExternalBufferProperties; - using ExternalBufferPropertiesKHR = ExternalBufferProperties; - struct PhysicalDeviceIDProperties; - using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; - struct ExternalMemoryImageCreateInfo; - using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo; - struct ExternalMemoryBufferCreateInfo; - using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo; - struct ExportMemoryAllocateInfo; - using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo; - struct PhysicalDeviceExternalFenceInfo; - using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; - struct ExternalFenceProperties; - using ExternalFencePropertiesKHR = ExternalFenceProperties; - struct ExportFenceCreateInfo; - using ExportFenceCreateInfoKHR = ExportFenceCreateInfo; - struct ExportSemaphoreCreateInfo; - using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo; - struct PhysicalDeviceExternalSemaphoreInfo; - using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; - struct ExternalSemaphoreProperties; - using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; - struct PhysicalDeviceSubgroupProperties; - struct PhysicalDevice16BitStorageFeatures; - using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; - struct PhysicalDeviceVariablePointersFeatures; - using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures; - using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures; - using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures; - struct DescriptorUpdateTemplateEntry; - using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry; - struct DescriptorUpdateTemplateCreateInfo; - using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; - struct PhysicalDeviceMaintenance3Properties; - using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; - struct DescriptorSetLayoutSupport; - using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; - struct SamplerYcbcrConversionCreateInfo; - using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; - struct SamplerYcbcrConversionInfo; - using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; - struct PhysicalDeviceSamplerYcbcrConversionFeatures; - using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures; - struct SamplerYcbcrConversionImageFormatProperties; - using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties; - struct DeviceGroupRenderPassBeginInfo; - using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo; - struct PhysicalDevicePointClippingProperties; - using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; - struct RenderPassInputAttachmentAspectCreateInfo; - using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo; - struct InputAttachmentAspectReference; - using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; - struct PipelineTessellationDomainOriginStateCreateInfo; - using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo; - struct RenderPassMultiviewCreateInfo; - using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo; - struct PhysicalDeviceMultiviewFeatures; - using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures; - struct PhysicalDeviceMultiviewProperties; - using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; - struct PhysicalDeviceShaderDrawParametersFeatures; - using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures; - - //=== VK_VERSION_1_2 === - struct PhysicalDeviceVulkan11Features; - struct PhysicalDeviceVulkan11Properties; - struct PhysicalDeviceVulkan12Features; - struct PhysicalDeviceVulkan12Properties; - struct ImageFormatListCreateInfo; - using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo; - struct ConformanceVersion; - using ConformanceVersionKHR = ConformanceVersion; - struct PhysicalDeviceDriverProperties; - using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties; - struct PhysicalDeviceVulkanMemoryModelFeatures; - using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures; - struct PhysicalDeviceHostQueryResetFeatures; - using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures; - struct PhysicalDeviceTimelineSemaphoreFeatures; - using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures; - struct PhysicalDeviceTimelineSemaphoreProperties; - using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties; - struct SemaphoreTypeCreateInfo; - using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo; - struct TimelineSemaphoreSubmitInfo; - using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo; - struct SemaphoreWaitInfo; - using SemaphoreWaitInfoKHR = SemaphoreWaitInfo; - struct SemaphoreSignalInfo; - using SemaphoreSignalInfoKHR = SemaphoreSignalInfo; - struct PhysicalDeviceBufferDeviceAddressFeatures; - using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures; - struct BufferDeviceAddressInfo; - using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo; - using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo; - struct BufferOpaqueCaptureAddressCreateInfo; - using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo; - struct MemoryOpaqueCaptureAddressAllocateInfo; - using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo; - struct DeviceMemoryOpaqueCaptureAddressInfo; - using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo; - struct PhysicalDevice8BitStorageFeatures; - using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures; - struct PhysicalDeviceShaderAtomicInt64Features; - using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features; - struct PhysicalDeviceShaderFloat16Int8Features; - using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; - using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; - struct PhysicalDeviceFloatControlsProperties; - using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties; - struct DescriptorSetLayoutBindingFlagsCreateInfo; - using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo; - struct PhysicalDeviceDescriptorIndexingFeatures; - using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures; - struct PhysicalDeviceDescriptorIndexingProperties; - using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties; - struct DescriptorSetVariableDescriptorCountAllocateInfo; - using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo; - struct DescriptorSetVariableDescriptorCountLayoutSupport; - using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport; - struct PhysicalDeviceScalarBlockLayoutFeatures; - using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures; - struct SamplerReductionModeCreateInfo; - using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo; - struct PhysicalDeviceSamplerFilterMinmaxProperties; - using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties; - struct PhysicalDeviceUniformBufferStandardLayoutFeatures; - using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures; - struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures; - using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; - struct RenderPassCreateInfo2; - using RenderPassCreateInfo2KHR = RenderPassCreateInfo2; - struct AttachmentDescription2; - using AttachmentDescription2KHR = AttachmentDescription2; - struct AttachmentReference2; - using AttachmentReference2KHR = AttachmentReference2; - struct SubpassDescription2; - using SubpassDescription2KHR = SubpassDescription2; - struct SubpassDependency2; - using SubpassDependency2KHR = SubpassDependency2; - struct SubpassBeginInfo; - using SubpassBeginInfoKHR = SubpassBeginInfo; - struct SubpassEndInfo; - using SubpassEndInfoKHR = SubpassEndInfo; - struct SubpassDescriptionDepthStencilResolve; - using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve; - struct PhysicalDeviceDepthStencilResolveProperties; - using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties; - struct ImageStencilUsageCreateInfo; - using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo; - struct PhysicalDeviceImagelessFramebufferFeatures; - using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures; - struct FramebufferAttachmentsCreateInfo; - using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo; - struct FramebufferAttachmentImageInfo; - using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo; - struct RenderPassAttachmentBeginInfo; - using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo; - struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures; - using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; - struct AttachmentReferenceStencilLayout; - using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout; - struct AttachmentDescriptionStencilLayout; - using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout; - - //=== VK_VERSION_1_3 === - struct PhysicalDeviceVulkan13Features; - struct PhysicalDeviceVulkan13Properties; - struct PhysicalDeviceToolProperties; - using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties; - struct PhysicalDevicePrivateDataFeatures; - using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures; - struct DevicePrivateDataCreateInfo; - using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo; - struct PrivateDataSlotCreateInfo; - using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo; - struct MemoryBarrier2; - using MemoryBarrier2KHR = MemoryBarrier2; - struct BufferMemoryBarrier2; - using BufferMemoryBarrier2KHR = BufferMemoryBarrier2; - struct ImageMemoryBarrier2; - using ImageMemoryBarrier2KHR = ImageMemoryBarrier2; - struct DependencyInfo; - using DependencyInfoKHR = DependencyInfo; - struct SubmitInfo2; - using SubmitInfo2KHR = SubmitInfo2; - struct SemaphoreSubmitInfo; - using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo; - struct CommandBufferSubmitInfo; - using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo; - struct PhysicalDeviceSynchronization2Features; - using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features; - struct CopyBufferInfo2; - using CopyBufferInfo2KHR = CopyBufferInfo2; - struct CopyImageInfo2; - using CopyImageInfo2KHR = CopyImageInfo2; - struct CopyBufferToImageInfo2; - using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2; - struct CopyImageToBufferInfo2; - using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2; - struct BufferCopy2; - using BufferCopy2KHR = BufferCopy2; - struct ImageCopy2; - using ImageCopy2KHR = ImageCopy2; - struct BufferImageCopy2; - using BufferImageCopy2KHR = BufferImageCopy2; - struct PhysicalDeviceTextureCompressionASTCHDRFeatures; - using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures; - struct FormatProperties3; - using FormatProperties3KHR = FormatProperties3; - struct PhysicalDeviceMaintenance4Features; - using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features; - struct PhysicalDeviceMaintenance4Properties; - using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties; - struct DeviceBufferMemoryRequirements; - using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements; - struct DeviceImageMemoryRequirements; - using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements; - struct PipelineCreationFeedbackCreateInfo; - using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo; - struct PipelineCreationFeedback; - using PipelineCreationFeedbackEXT = PipelineCreationFeedback; - struct PhysicalDeviceShaderTerminateInvocationFeatures; - using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures; - struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures; - using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; - struct PhysicalDevicePipelineCreationCacheControlFeatures; - using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures; - struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - struct PhysicalDeviceImageRobustnessFeatures; - using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures; - struct PhysicalDeviceSubgroupSizeControlFeatures; - using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures; - struct PhysicalDeviceSubgroupSizeControlProperties; - using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties; - struct PipelineShaderStageRequiredSubgroupSizeCreateInfo; - using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; - using ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; - struct PhysicalDeviceInlineUniformBlockFeatures; - using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures; - struct PhysicalDeviceInlineUniformBlockProperties; - using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties; - struct WriteDescriptorSetInlineUniformBlock; - using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock; - struct DescriptorPoolInlineUniformBlockCreateInfo; - using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo; - struct PhysicalDeviceShaderIntegerDotProductFeatures; - using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures; - struct PhysicalDeviceShaderIntegerDotProductProperties; - using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties; - struct PhysicalDeviceTexelBufferAlignmentProperties; - using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties; - struct BlitImageInfo2; - using BlitImageInfo2KHR = BlitImageInfo2; - struct ImageBlit2; - using ImageBlit2KHR = ImageBlit2; - struct ResolveImageInfo2; - using ResolveImageInfo2KHR = ResolveImageInfo2; - struct ImageResolve2; - using ImageResolve2KHR = ImageResolve2; - struct RenderingInfo; - using RenderingInfoKHR = RenderingInfo; - struct RenderingAttachmentInfo; - using RenderingAttachmentInfoKHR = RenderingAttachmentInfo; - struct PipelineRenderingCreateInfo; - using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo; - struct PhysicalDeviceDynamicRenderingFeatures; - using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures; - struct CommandBufferInheritanceRenderingInfo; - using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo; - - //=== VK_VERSION_1_4 === - struct PhysicalDeviceVulkan14Features; - struct PhysicalDeviceVulkan14Properties; - struct DeviceQueueGlobalPriorityCreateInfo; - using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfo; - using DeviceQueueGlobalPriorityCreateInfoKHR = DeviceQueueGlobalPriorityCreateInfo; - struct PhysicalDeviceGlobalPriorityQueryFeatures; - using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeatures; - using PhysicalDeviceGlobalPriorityQueryFeaturesKHR = PhysicalDeviceGlobalPriorityQueryFeatures; - struct QueueFamilyGlobalPriorityProperties; - using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityProperties; - using QueueFamilyGlobalPriorityPropertiesKHR = QueueFamilyGlobalPriorityProperties; - struct PhysicalDeviceIndexTypeUint8Features; - using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8Features; - using PhysicalDeviceIndexTypeUint8FeaturesKHR = PhysicalDeviceIndexTypeUint8Features; - struct MemoryMapInfo; - using MemoryMapInfoKHR = MemoryMapInfo; - struct MemoryUnmapInfo; - using MemoryUnmapInfoKHR = MemoryUnmapInfo; - struct PhysicalDeviceMaintenance5Features; - using PhysicalDeviceMaintenance5FeaturesKHR = PhysicalDeviceMaintenance5Features; - struct PhysicalDeviceMaintenance5Properties; - using PhysicalDeviceMaintenance5PropertiesKHR = PhysicalDeviceMaintenance5Properties; - struct DeviceImageSubresourceInfo; - using DeviceImageSubresourceInfoKHR = DeviceImageSubresourceInfo; - struct ImageSubresource2; - using ImageSubresource2EXT = ImageSubresource2; - using ImageSubresource2KHR = ImageSubresource2; - struct SubresourceLayout2; - using SubresourceLayout2EXT = SubresourceLayout2; - using SubresourceLayout2KHR = SubresourceLayout2; - struct BufferUsageFlags2CreateInfo; - using BufferUsageFlags2CreateInfoKHR = BufferUsageFlags2CreateInfo; - struct PhysicalDeviceMaintenance6Features; - using PhysicalDeviceMaintenance6FeaturesKHR = PhysicalDeviceMaintenance6Features; - struct PhysicalDeviceMaintenance6Properties; - using PhysicalDeviceMaintenance6PropertiesKHR = PhysicalDeviceMaintenance6Properties; - struct BindMemoryStatus; - using BindMemoryStatusKHR = BindMemoryStatus; - struct PhysicalDeviceHostImageCopyFeatures; - using PhysicalDeviceHostImageCopyFeaturesEXT = PhysicalDeviceHostImageCopyFeatures; - struct PhysicalDeviceHostImageCopyProperties; - using PhysicalDeviceHostImageCopyPropertiesEXT = PhysicalDeviceHostImageCopyProperties; - struct MemoryToImageCopy; - using MemoryToImageCopyEXT = MemoryToImageCopy; - struct ImageToMemoryCopy; - using ImageToMemoryCopyEXT = ImageToMemoryCopy; - struct CopyMemoryToImageInfo; - using CopyMemoryToImageInfoEXT = CopyMemoryToImageInfo; - struct CopyImageToMemoryInfo; - using CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo; - struct CopyImageToImageInfo; - using CopyImageToImageInfoEXT = CopyImageToImageInfo; - struct HostImageLayoutTransitionInfo; - using HostImageLayoutTransitionInfoEXT = HostImageLayoutTransitionInfo; - struct SubresourceHostMemcpySize; - using SubresourceHostMemcpySizeEXT = SubresourceHostMemcpySize; - struct HostImageCopyDevicePerformanceQuery; - using HostImageCopyDevicePerformanceQueryEXT = HostImageCopyDevicePerformanceQuery; - struct PhysicalDeviceShaderSubgroupRotateFeatures; - using PhysicalDeviceShaderSubgroupRotateFeaturesKHR = PhysicalDeviceShaderSubgroupRotateFeatures; - struct PhysicalDeviceShaderFloatControls2Features; - using PhysicalDeviceShaderFloatControls2FeaturesKHR = PhysicalDeviceShaderFloatControls2Features; - struct PhysicalDeviceShaderExpectAssumeFeatures; - using PhysicalDeviceShaderExpectAssumeFeaturesKHR = PhysicalDeviceShaderExpectAssumeFeatures; - struct PipelineCreateFlags2CreateInfo; - using PipelineCreateFlags2CreateInfoKHR = PipelineCreateFlags2CreateInfo; - struct PhysicalDevicePushDescriptorProperties; - using PhysicalDevicePushDescriptorPropertiesKHR = PhysicalDevicePushDescriptorProperties; - struct BindDescriptorSetsInfo; - using BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo; - struct PushConstantsInfo; - using PushConstantsInfoKHR = PushConstantsInfo; - struct PushDescriptorSetInfo; - using PushDescriptorSetInfoKHR = PushDescriptorSetInfo; - struct PushDescriptorSetWithTemplateInfo; - using PushDescriptorSetWithTemplateInfoKHR = PushDescriptorSetWithTemplateInfo; - struct PhysicalDevicePipelineProtectedAccessFeatures; - using PhysicalDevicePipelineProtectedAccessFeaturesEXT = PhysicalDevicePipelineProtectedAccessFeatures; - struct PhysicalDevicePipelineRobustnessFeatures; - using PhysicalDevicePipelineRobustnessFeaturesEXT = PhysicalDevicePipelineRobustnessFeatures; - struct PhysicalDevicePipelineRobustnessProperties; - using PhysicalDevicePipelineRobustnessPropertiesEXT = PhysicalDevicePipelineRobustnessProperties; - struct PipelineRobustnessCreateInfo; - using PipelineRobustnessCreateInfoEXT = PipelineRobustnessCreateInfo; - struct PhysicalDeviceLineRasterizationFeatures; - using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeatures; - using PhysicalDeviceLineRasterizationFeaturesKHR = PhysicalDeviceLineRasterizationFeatures; - struct PhysicalDeviceLineRasterizationProperties; - using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationProperties; - using PhysicalDeviceLineRasterizationPropertiesKHR = PhysicalDeviceLineRasterizationProperties; - struct PipelineRasterizationLineStateCreateInfo; - using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfo; - using PipelineRasterizationLineStateCreateInfoKHR = PipelineRasterizationLineStateCreateInfo; - struct PhysicalDeviceVertexAttributeDivisorProperties; - using PhysicalDeviceVertexAttributeDivisorPropertiesKHR = PhysicalDeviceVertexAttributeDivisorProperties; - struct VertexInputBindingDivisorDescription; - using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescription; - using VertexInputBindingDivisorDescriptionKHR = VertexInputBindingDivisorDescription; - struct PipelineVertexInputDivisorStateCreateInfo; - using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfo; - using PipelineVertexInputDivisorStateCreateInfoKHR = PipelineVertexInputDivisorStateCreateInfo; - struct PhysicalDeviceVertexAttributeDivisorFeatures; - using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeatures; - using PhysicalDeviceVertexAttributeDivisorFeaturesKHR = PhysicalDeviceVertexAttributeDivisorFeatures; - struct RenderingAreaInfo; - using RenderingAreaInfoKHR = RenderingAreaInfo; - struct PhysicalDeviceDynamicRenderingLocalReadFeatures; - using PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = PhysicalDeviceDynamicRenderingLocalReadFeatures; - struct RenderingAttachmentLocationInfo; - using RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo; - struct RenderingInputAttachmentIndexInfo; - using RenderingInputAttachmentIndexInfoKHR = RenderingInputAttachmentIndexInfo; - - //=== VK_KHR_surface === - struct SurfaceCapabilitiesKHR; - struct SurfaceFormatKHR; - - //=== VK_KHR_swapchain === - struct SwapchainCreateInfoKHR; - struct PresentInfoKHR; - struct ImageSwapchainCreateInfoKHR; - struct BindImageMemorySwapchainInfoKHR; - struct AcquireNextImageInfoKHR; - struct DeviceGroupPresentCapabilitiesKHR; - struct DeviceGroupPresentInfoKHR; - struct DeviceGroupSwapchainCreateInfoKHR; - - //=== VK_KHR_display === - struct DisplayModeCreateInfoKHR; - struct DisplayModeParametersKHR; - struct DisplayModePropertiesKHR; - struct DisplayPlaneCapabilitiesKHR; - struct DisplayPlanePropertiesKHR; - struct DisplayPropertiesKHR; - struct DisplaySurfaceCreateInfoKHR; - - //=== VK_KHR_display_swapchain === - struct DisplayPresentInfoKHR; - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - struct XlibSurfaceCreateInfoKHR; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - struct XcbSurfaceCreateInfoKHR; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - struct WaylandSurfaceCreateInfoKHR; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - struct AndroidSurfaceCreateInfoKHR; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - struct Win32SurfaceCreateInfoKHR; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - struct DebugReportCallbackCreateInfoEXT; - - //=== VK_AMD_rasterization_order === - struct PipelineRasterizationStateRasterizationOrderAMD; - - //=== VK_EXT_debug_marker === - struct DebugMarkerObjectNameInfoEXT; - struct DebugMarkerObjectTagInfoEXT; - struct DebugMarkerMarkerInfoEXT; - - //=== VK_KHR_video_queue === - struct QueueFamilyQueryResultStatusPropertiesKHR; - struct QueueFamilyVideoPropertiesKHR; - struct VideoProfileInfoKHR; - struct VideoProfileListInfoKHR; - struct VideoCapabilitiesKHR; - struct PhysicalDeviceVideoFormatInfoKHR; - struct VideoFormatPropertiesKHR; - struct VideoPictureResourceInfoKHR; - struct VideoReferenceSlotInfoKHR; - struct VideoSessionMemoryRequirementsKHR; - struct BindVideoSessionMemoryInfoKHR; - struct VideoSessionCreateInfoKHR; - struct VideoSessionParametersCreateInfoKHR; - struct VideoSessionParametersUpdateInfoKHR; - struct VideoBeginCodingInfoKHR; - struct VideoEndCodingInfoKHR; - struct VideoCodingControlInfoKHR; - - //=== VK_KHR_video_decode_queue === - struct VideoDecodeCapabilitiesKHR; - struct VideoDecodeUsageInfoKHR; - struct VideoDecodeInfoKHR; - - //=== VK_NV_dedicated_allocation === - struct DedicatedAllocationImageCreateInfoNV; - struct DedicatedAllocationBufferCreateInfoNV; - struct DedicatedAllocationMemoryAllocateInfoNV; - - //=== VK_EXT_transform_feedback === - struct PhysicalDeviceTransformFeedbackFeaturesEXT; - struct PhysicalDeviceTransformFeedbackPropertiesEXT; - struct PipelineRasterizationStateStreamCreateInfoEXT; - - //=== VK_NVX_binary_import === - struct CuModuleCreateInfoNVX; - struct CuModuleTexturingModeCreateInfoNVX; - struct CuFunctionCreateInfoNVX; - struct CuLaunchInfoNVX; - - //=== VK_NVX_image_view_handle === - struct ImageViewHandleInfoNVX; - struct ImageViewAddressPropertiesNVX; - - //=== VK_KHR_video_encode_h264 === - struct VideoEncodeH264CapabilitiesKHR; - struct VideoEncodeH264QualityLevelPropertiesKHR; - struct VideoEncodeH264SessionCreateInfoKHR; - struct VideoEncodeH264SessionParametersCreateInfoKHR; - struct VideoEncodeH264SessionParametersAddInfoKHR; - struct VideoEncodeH264SessionParametersGetInfoKHR; - struct VideoEncodeH264SessionParametersFeedbackInfoKHR; - struct VideoEncodeH264PictureInfoKHR; - struct VideoEncodeH264DpbSlotInfoKHR; - struct VideoEncodeH264NaluSliceInfoKHR; - struct VideoEncodeH264ProfileInfoKHR; - struct VideoEncodeH264RateControlInfoKHR; - struct VideoEncodeH264RateControlLayerInfoKHR; - struct VideoEncodeH264QpKHR; - struct VideoEncodeH264FrameSizeKHR; - struct VideoEncodeH264GopRemainingFrameInfoKHR; - - //=== VK_KHR_video_encode_h265 === - struct VideoEncodeH265CapabilitiesKHR; - struct VideoEncodeH265SessionCreateInfoKHR; - struct VideoEncodeH265QualityLevelPropertiesKHR; - struct VideoEncodeH265SessionParametersCreateInfoKHR; - struct VideoEncodeH265SessionParametersAddInfoKHR; - struct VideoEncodeH265SessionParametersGetInfoKHR; - struct VideoEncodeH265SessionParametersFeedbackInfoKHR; - struct VideoEncodeH265PictureInfoKHR; - struct VideoEncodeH265DpbSlotInfoKHR; - struct VideoEncodeH265NaluSliceSegmentInfoKHR; - struct VideoEncodeH265ProfileInfoKHR; - struct VideoEncodeH265RateControlInfoKHR; - struct VideoEncodeH265RateControlLayerInfoKHR; - struct VideoEncodeH265QpKHR; - struct VideoEncodeH265FrameSizeKHR; - struct VideoEncodeH265GopRemainingFrameInfoKHR; - - //=== VK_KHR_video_decode_h264 === - struct VideoDecodeH264ProfileInfoKHR; - struct VideoDecodeH264CapabilitiesKHR; - struct VideoDecodeH264SessionParametersCreateInfoKHR; - struct VideoDecodeH264SessionParametersAddInfoKHR; - struct VideoDecodeH264PictureInfoKHR; - struct VideoDecodeH264DpbSlotInfoKHR; - - //=== VK_AMD_texture_gather_bias_lod === - struct TextureLODGatherFormatPropertiesAMD; - - //=== VK_AMD_shader_info === - struct ShaderResourceUsageAMD; - struct ShaderStatisticsInfoAMD; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - struct StreamDescriptorSurfaceCreateInfoGGP; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_corner_sampled_image === - struct PhysicalDeviceCornerSampledImageFeaturesNV; - - //=== VK_NV_external_memory_capabilities === - struct ExternalImageFormatPropertiesNV; - - //=== VK_NV_external_memory === - struct ExternalMemoryImageCreateInfoNV; - struct ExportMemoryAllocateInfoNV; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - struct ImportMemoryWin32HandleInfoNV; - struct ExportMemoryWin32HandleInfoNV; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_win32_keyed_mutex === - struct Win32KeyedMutexAcquireReleaseInfoNV; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_validation_flags === - struct ValidationFlagsEXT; - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - struct ViSurfaceCreateInfoNN; -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_EXT_astc_decode_mode === - struct ImageViewASTCDecodeModeEXT; - struct PhysicalDeviceASTCDecodeFeaturesEXT; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - struct ImportMemoryWin32HandleInfoKHR; - struct ExportMemoryWin32HandleInfoKHR; - struct MemoryWin32HandlePropertiesKHR; - struct MemoryGetWin32HandleInfoKHR; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - struct ImportMemoryFdInfoKHR; - struct MemoryFdPropertiesKHR; - struct MemoryGetFdInfoKHR; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_keyed_mutex === - struct Win32KeyedMutexAcquireReleaseInfoKHR; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - struct ImportSemaphoreWin32HandleInfoKHR; - struct ExportSemaphoreWin32HandleInfoKHR; - struct D3D12FenceSubmitInfoKHR; - struct SemaphoreGetWin32HandleInfoKHR; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - struct ImportSemaphoreFdInfoKHR; - struct SemaphoreGetFdInfoKHR; - - //=== VK_EXT_conditional_rendering === - struct ConditionalRenderingBeginInfoEXT; - struct PhysicalDeviceConditionalRenderingFeaturesEXT; - struct CommandBufferInheritanceConditionalRenderingInfoEXT; - - //=== VK_KHR_incremental_present === - struct PresentRegionsKHR; - struct PresentRegionKHR; - struct RectLayerKHR; - - //=== VK_NV_clip_space_w_scaling === - struct ViewportWScalingNV; - struct PipelineViewportWScalingStateCreateInfoNV; - - //=== VK_EXT_display_surface_counter === - struct SurfaceCapabilities2EXT; - - //=== VK_EXT_display_control === - struct DisplayPowerInfoEXT; - struct DeviceEventInfoEXT; - struct DisplayEventInfoEXT; - struct SwapchainCounterCreateInfoEXT; - - //=== VK_GOOGLE_display_timing === - struct RefreshCycleDurationGOOGLE; - struct PastPresentationTimingGOOGLE; - struct PresentTimesInfoGOOGLE; - struct PresentTimeGOOGLE; - - //=== VK_NVX_multiview_per_view_attributes === - struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - struct MultiviewPerViewAttributesInfoNVX; - - //=== VK_NV_viewport_swizzle === - struct ViewportSwizzleNV; - struct PipelineViewportSwizzleStateCreateInfoNV; - - //=== VK_EXT_discard_rectangles === - struct PhysicalDeviceDiscardRectanglePropertiesEXT; - struct PipelineDiscardRectangleStateCreateInfoEXT; - - //=== VK_EXT_conservative_rasterization === - struct PhysicalDeviceConservativeRasterizationPropertiesEXT; - struct PipelineRasterizationConservativeStateCreateInfoEXT; - - //=== VK_EXT_depth_clip_enable === - struct PhysicalDeviceDepthClipEnableFeaturesEXT; - struct PipelineRasterizationDepthClipStateCreateInfoEXT; - - //=== VK_EXT_hdr_metadata === - struct HdrMetadataEXT; - struct XYColorEXT; - - //=== VK_IMG_relaxed_line_rasterization === - struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG; - - //=== VK_KHR_shared_presentable_image === - struct SharedPresentSurfaceCapabilitiesKHR; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - struct ImportFenceWin32HandleInfoKHR; - struct ExportFenceWin32HandleInfoKHR; - struct FenceGetWin32HandleInfoKHR; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - struct ImportFenceFdInfoKHR; - struct FenceGetFdInfoKHR; - - //=== VK_KHR_performance_query === - struct PhysicalDevicePerformanceQueryFeaturesKHR; - struct PhysicalDevicePerformanceQueryPropertiesKHR; - struct PerformanceCounterKHR; - struct PerformanceCounterDescriptionKHR; - struct QueryPoolPerformanceCreateInfoKHR; - union PerformanceCounterResultKHR; - struct AcquireProfilingLockInfoKHR; - struct PerformanceQuerySubmitInfoKHR; - - //=== VK_KHR_get_surface_capabilities2 === - struct PhysicalDeviceSurfaceInfo2KHR; - struct SurfaceCapabilities2KHR; - struct SurfaceFormat2KHR; - - //=== VK_KHR_get_display_properties2 === - struct DisplayProperties2KHR; - struct DisplayPlaneProperties2KHR; - struct DisplayModeProperties2KHR; - struct DisplayPlaneInfo2KHR; - struct DisplayPlaneCapabilities2KHR; - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - struct IOSSurfaceCreateInfoMVK; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - struct MacOSSurfaceCreateInfoMVK; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - struct DebugUtilsLabelEXT; - struct DebugUtilsMessengerCallbackDataEXT; - struct DebugUtilsMessengerCreateInfoEXT; - struct DebugUtilsObjectNameInfoEXT; - struct DebugUtilsObjectTagInfoEXT; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - struct AndroidHardwareBufferUsageANDROID; - struct AndroidHardwareBufferPropertiesANDROID; - struct AndroidHardwareBufferFormatPropertiesANDROID; - struct ImportAndroidHardwareBufferInfoANDROID; - struct MemoryGetAndroidHardwareBufferInfoANDROID; - struct ExternalFormatANDROID; - struct AndroidHardwareBufferFormatProperties2ANDROID; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - struct PhysicalDeviceShaderEnqueueFeaturesAMDX; - struct PhysicalDeviceShaderEnqueuePropertiesAMDX; - struct ExecutionGraphPipelineScratchSizeAMDX; - struct ExecutionGraphPipelineCreateInfoAMDX; - struct DispatchGraphInfoAMDX; - struct DispatchGraphCountInfoAMDX; - struct PipelineShaderStageNodeCreateInfoAMDX; - union DeviceOrHostAddressConstAMDX; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - struct HostAddressRangeEXT; - struct HostAddressRangeConstEXT; - struct DeviceAddressRangeEXT; - struct TexelBufferDescriptorInfoEXT; - struct ImageDescriptorInfoEXT; - struct ResourceDescriptorInfoEXT; - union ResourceDescriptorDataEXT; - struct BindHeapInfoEXT; - struct PushDataInfoEXT; - struct DescriptorMappingSourceConstantOffsetEXT; - struct DescriptorMappingSourcePushIndexEXT; - struct DescriptorMappingSourceIndirectIndexEXT; - struct DescriptorMappingSourceHeapDataEXT; - struct DescriptorMappingSourceIndirectAddressEXT; - struct DescriptorMappingSourceShaderRecordIndexEXT; - union DescriptorMappingSourceDataEXT; - struct DescriptorMappingSourceIndirectIndexArrayEXT; - struct DescriptorSetAndBindingMappingEXT; - struct ShaderDescriptorSetAndBindingMappingInfoEXT; - struct OpaqueCaptureDataCreateInfoEXT; - struct PhysicalDeviceDescriptorHeapFeaturesEXT; - struct PhysicalDeviceDescriptorHeapPropertiesEXT; - struct CommandBufferInheritanceDescriptorHeapInfoEXT; - struct SamplerCustomBorderColorIndexCreateInfoEXT; - struct IndirectCommandsLayoutPushDataTokenNV; - struct SubsampledImageFormatPropertiesEXT; - struct TensorViewCreateInfoARM; - struct PhysicalDeviceDescriptorHeapTensorPropertiesARM; - - //=== VK_AMD_mixed_attachment_samples === - struct AttachmentSampleCountInfoAMD; - using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD; - - //=== VK_KHR_shader_bfloat16 === - struct PhysicalDeviceShaderBfloat16FeaturesKHR; - - //=== VK_EXT_sample_locations === - struct SampleLocationEXT; - struct SampleLocationsInfoEXT; - struct AttachmentSampleLocationsEXT; - struct SubpassSampleLocationsEXT; - struct RenderPassSampleLocationsBeginInfoEXT; - struct PipelineSampleLocationsStateCreateInfoEXT; - struct PhysicalDeviceSampleLocationsPropertiesEXT; - struct MultisamplePropertiesEXT; - - //=== VK_EXT_blend_operation_advanced === - struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT; - struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT; - struct PipelineColorBlendAdvancedStateCreateInfoEXT; - - //=== VK_NV_fragment_coverage_to_color === - struct PipelineCoverageToColorStateCreateInfoNV; - - //=== VK_KHR_acceleration_structure === - union DeviceOrHostAddressKHR; - union DeviceOrHostAddressConstKHR; - struct AccelerationStructureBuildRangeInfoKHR; - struct AabbPositionsKHR; - using AabbPositionsNV = AabbPositionsKHR; - struct AccelerationStructureGeometryTrianglesDataKHR; - struct TransformMatrixKHR; - using TransformMatrixNV = TransformMatrixKHR; - struct AccelerationStructureBuildGeometryInfoKHR; - struct AccelerationStructureGeometryAabbsDataKHR; - struct AccelerationStructureInstanceKHR; - using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR; - struct AccelerationStructureGeometryInstancesDataKHR; - union AccelerationStructureGeometryDataKHR; - struct AccelerationStructureGeometryKHR; - struct AccelerationStructureCreateInfoKHR; - struct WriteDescriptorSetAccelerationStructureKHR; - struct PhysicalDeviceAccelerationStructureFeaturesKHR; - struct PhysicalDeviceAccelerationStructurePropertiesKHR; - struct AccelerationStructureDeviceAddressInfoKHR; - struct AccelerationStructureVersionInfoKHR; - struct CopyAccelerationStructureToMemoryInfoKHR; - struct CopyMemoryToAccelerationStructureInfoKHR; - struct CopyAccelerationStructureInfoKHR; - struct AccelerationStructureBuildSizesInfoKHR; - - //=== VK_KHR_ray_tracing_pipeline === - struct RayTracingShaderGroupCreateInfoKHR; - struct RayTracingPipelineCreateInfoKHR; - struct PhysicalDeviceRayTracingPipelineFeaturesKHR; - struct PhysicalDeviceRayTracingPipelinePropertiesKHR; - struct StridedDeviceAddressRegionKHR; - struct TraceRaysIndirectCommandKHR; - struct RayTracingPipelineInterfaceCreateInfoKHR; - - //=== VK_KHR_ray_query === - struct PhysicalDeviceRayQueryFeaturesKHR; - - //=== VK_NV_framebuffer_mixed_samples === - struct PipelineCoverageModulationStateCreateInfoNV; - - //=== VK_NV_shader_sm_builtins === - struct PhysicalDeviceShaderSMBuiltinsPropertiesNV; - struct PhysicalDeviceShaderSMBuiltinsFeaturesNV; - - //=== VK_EXT_image_drm_format_modifier === - struct DrmFormatModifierPropertiesListEXT; - struct DrmFormatModifierPropertiesEXT; - struct PhysicalDeviceImageDrmFormatModifierInfoEXT; - struct ImageDrmFormatModifierListCreateInfoEXT; - struct ImageDrmFormatModifierExplicitCreateInfoEXT; - struct ImageDrmFormatModifierPropertiesEXT; - struct DrmFormatModifierPropertiesList2EXT; - struct DrmFormatModifierProperties2EXT; - - //=== VK_EXT_validation_cache === - struct ValidationCacheCreateInfoEXT; - struct ShaderModuleValidationCacheCreateInfoEXT; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_KHR_portability_subset === - struct PhysicalDevicePortabilitySubsetFeaturesKHR; - struct PhysicalDevicePortabilitySubsetPropertiesKHR; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_NV_shading_rate_image === - struct ShadingRatePaletteNV; - struct PipelineViewportShadingRateImageStateCreateInfoNV; - struct PhysicalDeviceShadingRateImageFeaturesNV; - struct PhysicalDeviceShadingRateImagePropertiesNV; - struct CoarseSampleLocationNV; - struct CoarseSampleOrderCustomNV; - struct PipelineViewportCoarseSampleOrderStateCreateInfoNV; - - //=== VK_NV_ray_tracing === - struct RayTracingShaderGroupCreateInfoNV; - struct RayTracingPipelineCreateInfoNV; - struct GeometryTrianglesNV; - struct GeometryAABBNV; - struct GeometryDataNV; - struct GeometryNV; - struct AccelerationStructureInfoNV; - struct AccelerationStructureCreateInfoNV; - struct BindAccelerationStructureMemoryInfoNV; - struct WriteDescriptorSetAccelerationStructureNV; - struct AccelerationStructureMemoryRequirementsInfoNV; - struct PhysicalDeviceRayTracingPropertiesNV; - - //=== VK_NV_representative_fragment_test === - struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV; - struct PipelineRepresentativeFragmentTestStateCreateInfoNV; - - //=== VK_EXT_filter_cubic === - struct PhysicalDeviceImageViewImageFormatInfoEXT; - struct FilterCubicImageViewImageFormatPropertiesEXT; - - //=== VK_EXT_external_memory_host === - struct ImportMemoryHostPointerInfoEXT; - struct MemoryHostPointerPropertiesEXT; - struct PhysicalDeviceExternalMemoryHostPropertiesEXT; - - //=== VK_KHR_shader_clock === - struct PhysicalDeviceShaderClockFeaturesKHR; - - //=== VK_AMD_pipeline_compiler_control === - struct PipelineCompilerControlCreateInfoAMD; - - //=== VK_AMD_shader_core_properties === - struct PhysicalDeviceShaderCorePropertiesAMD; - - //=== VK_KHR_video_decode_h265 === - struct VideoDecodeH265ProfileInfoKHR; - struct VideoDecodeH265CapabilitiesKHR; - struct VideoDecodeH265SessionParametersCreateInfoKHR; - struct VideoDecodeH265SessionParametersAddInfoKHR; - struct VideoDecodeH265PictureInfoKHR; - struct VideoDecodeH265DpbSlotInfoKHR; - - //=== VK_AMD_memory_overallocation_behavior === - struct DeviceMemoryOverallocationCreateInfoAMD; - - //=== VK_EXT_vertex_attribute_divisor === - struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT; - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_frame_token === - struct PresentFrameTokenGGP; -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_mesh_shader === - struct PhysicalDeviceMeshShaderFeaturesNV; - struct PhysicalDeviceMeshShaderPropertiesNV; - struct DrawMeshTasksIndirectCommandNV; - - //=== VK_NV_shader_image_footprint === - struct PhysicalDeviceShaderImageFootprintFeaturesNV; - - //=== VK_NV_scissor_exclusive === - struct PipelineViewportExclusiveScissorStateCreateInfoNV; - struct PhysicalDeviceExclusiveScissorFeaturesNV; - - //=== VK_NV_device_diagnostic_checkpoints === - struct QueueFamilyCheckpointPropertiesNV; - struct CheckpointDataNV; - struct QueueFamilyCheckpointProperties2NV; - struct CheckpointData2NV; - - //=== VK_EXT_present_timing === - struct PhysicalDevicePresentTimingFeaturesEXT; - struct PresentTimingSurfaceCapabilitiesEXT; - struct SwapchainCalibratedTimestampInfoEXT; - struct SwapchainTimingPropertiesEXT; - struct SwapchainTimeDomainPropertiesEXT; - struct PastPresentationTimingInfoEXT; - struct PastPresentationTimingPropertiesEXT; - struct PastPresentationTimingEXT; - struct PresentTimingsInfoEXT; - struct PresentTimingInfoEXT; - struct PresentStageTimeEXT; - - //=== VK_INTEL_shader_integer_functions2 === - struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - - //=== VK_INTEL_performance_query === - union PerformanceValueDataINTEL; - struct PerformanceValueINTEL; - struct InitializePerformanceApiInfoINTEL; - struct QueryPoolPerformanceQueryCreateInfoINTEL; - using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL; - struct PerformanceMarkerInfoINTEL; - struct PerformanceStreamMarkerInfoINTEL; - struct PerformanceOverrideInfoINTEL; - struct PerformanceConfigurationAcquireInfoINTEL; - - //=== VK_EXT_pci_bus_info === - struct PhysicalDevicePCIBusInfoPropertiesEXT; - - //=== VK_AMD_display_native_hdr === - struct DisplayNativeHdrSurfaceCapabilitiesAMD; - struct SwapchainDisplayNativeHdrCreateInfoAMD; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - struct ImagePipeSurfaceCreateInfoFUCHSIA; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - struct MetalSurfaceCreateInfoEXT; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_fragment_density_map === - struct PhysicalDeviceFragmentDensityMapFeaturesEXT; - struct PhysicalDeviceFragmentDensityMapPropertiesEXT; - struct RenderPassFragmentDensityMapCreateInfoEXT; - struct RenderingFragmentDensityMapAttachmentInfoEXT; - - //=== VK_KHR_fragment_shading_rate === - struct FragmentShadingRateAttachmentInfoKHR; - struct PipelineFragmentShadingRateStateCreateInfoKHR; - struct PhysicalDeviceFragmentShadingRateFeaturesKHR; - struct PhysicalDeviceFragmentShadingRatePropertiesKHR; - struct PhysicalDeviceFragmentShadingRateKHR; - struct RenderingFragmentShadingRateAttachmentInfoKHR; - - //=== VK_AMD_shader_core_properties2 === - struct PhysicalDeviceShaderCoreProperties2AMD; - - //=== VK_AMD_device_coherent_memory === - struct PhysicalDeviceCoherentMemoryFeaturesAMD; - - //=== VK_EXT_shader_image_atomic_int64 === - struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; - - //=== VK_KHR_shader_quad_control === - struct PhysicalDeviceShaderQuadControlFeaturesKHR; - - //=== VK_EXT_memory_budget === - struct PhysicalDeviceMemoryBudgetPropertiesEXT; - - //=== VK_EXT_memory_priority === - struct PhysicalDeviceMemoryPriorityFeaturesEXT; - struct MemoryPriorityAllocateInfoEXT; - - //=== VK_KHR_surface_protected_capabilities === - struct SurfaceProtectedCapabilitiesKHR; - - //=== VK_NV_dedicated_allocation_image_aliasing === - struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - - //=== VK_EXT_buffer_device_address === - struct PhysicalDeviceBufferDeviceAddressFeaturesEXT; - using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT; - struct BufferDeviceAddressCreateInfoEXT; - - //=== VK_EXT_validation_features === - struct ValidationFeaturesEXT; - - //=== VK_KHR_present_wait === - struct PhysicalDevicePresentWaitFeaturesKHR; - - //=== VK_NV_cooperative_matrix === - struct CooperativeMatrixPropertiesNV; - struct PhysicalDeviceCooperativeMatrixFeaturesNV; - struct PhysicalDeviceCooperativeMatrixPropertiesNV; - - //=== VK_NV_coverage_reduction_mode === - struct PhysicalDeviceCoverageReductionModeFeaturesNV; - struct PipelineCoverageReductionStateCreateInfoNV; - struct FramebufferMixedSamplesCombinationNV; - - //=== VK_EXT_fragment_shader_interlock === - struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT; - - //=== VK_EXT_ycbcr_image_arrays === - struct PhysicalDeviceYcbcrImageArraysFeaturesEXT; - - //=== VK_EXT_provoking_vertex === - struct PhysicalDeviceProvokingVertexFeaturesEXT; - struct PhysicalDeviceProvokingVertexPropertiesEXT; - struct PipelineRasterizationProvokingVertexStateCreateInfoEXT; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - struct SurfaceFullScreenExclusiveInfoEXT; - struct SurfaceCapabilitiesFullScreenExclusiveEXT; - struct SurfaceFullScreenExclusiveWin32InfoEXT; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - struct HeadlessSurfaceCreateInfoEXT; - - //=== VK_EXT_shader_atomic_float === - struct PhysicalDeviceShaderAtomicFloatFeaturesEXT; - - //=== VK_EXT_extended_dynamic_state === - struct PhysicalDeviceExtendedDynamicStateFeaturesEXT; - - //=== VK_KHR_pipeline_executable_properties === - struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - struct PipelineInfoKHR; - using PipelineInfoEXT = PipelineInfoKHR; - struct PipelineExecutablePropertiesKHR; - struct PipelineExecutableInfoKHR; - union PipelineExecutableStatisticValueKHR; - struct PipelineExecutableStatisticKHR; - struct PipelineExecutableInternalRepresentationKHR; - - //=== VK_EXT_map_memory_placed === - struct PhysicalDeviceMapMemoryPlacedFeaturesEXT; - struct PhysicalDeviceMapMemoryPlacedPropertiesEXT; - struct MemoryMapPlacedInfoEXT; - - //=== VK_EXT_shader_atomic_float2 === - struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT; - - //=== VK_NV_device_generated_commands === - struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; - struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; - struct GraphicsShaderGroupCreateInfoNV; - struct GraphicsPipelineShaderGroupsCreateInfoNV; - struct BindShaderGroupIndirectCommandNV; - struct BindIndexBufferIndirectCommandNV; - struct BindVertexBufferIndirectCommandNV; - struct SetStateFlagsIndirectCommandNV; - struct IndirectCommandsStreamNV; - struct IndirectCommandsLayoutTokenNV; - struct IndirectCommandsLayoutCreateInfoNV; - struct GeneratedCommandsInfoNV; - struct GeneratedCommandsMemoryRequirementsInfoNV; - - //=== VK_NV_inherited_viewport_scissor === - struct PhysicalDeviceInheritedViewportScissorFeaturesNV; - struct CommandBufferInheritanceViewportScissorInfoNV; - - //=== VK_EXT_texel_buffer_alignment === - struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT; - - //=== VK_QCOM_render_pass_transform === - struct RenderPassTransformBeginInfoQCOM; - struct CommandBufferInheritanceRenderPassTransformInfoQCOM; - - //=== VK_EXT_depth_bias_control === - struct PhysicalDeviceDepthBiasControlFeaturesEXT; - struct DepthBiasInfoEXT; - struct DepthBiasRepresentationInfoEXT; - - //=== VK_EXT_device_memory_report === - struct PhysicalDeviceDeviceMemoryReportFeaturesEXT; - struct DeviceDeviceMemoryReportCreateInfoEXT; - struct DeviceMemoryReportCallbackDataEXT; - - //=== VK_EXT_custom_border_color === - struct SamplerCustomBorderColorCreateInfoEXT; - struct PhysicalDeviceCustomBorderColorPropertiesEXT; - struct PhysicalDeviceCustomBorderColorFeaturesEXT; - - //=== VK_EXT_texture_compression_astc_3d === - struct PhysicalDeviceTextureCompressionASTC3DFeaturesEXT; - - //=== VK_KHR_pipeline_library === - struct PipelineLibraryCreateInfoKHR; - - //=== VK_NV_present_barrier === - struct PhysicalDevicePresentBarrierFeaturesNV; - struct SurfaceCapabilitiesPresentBarrierNV; - struct SwapchainPresentBarrierCreateInfoNV; - - //=== VK_KHR_present_id === - struct PresentIdKHR; - struct PhysicalDevicePresentIdFeaturesKHR; - - //=== VK_KHR_video_encode_queue === - struct VideoEncodeInfoKHR; - struct VideoEncodeCapabilitiesKHR; - struct QueryPoolVideoEncodeFeedbackCreateInfoKHR; - struct VideoEncodeUsageInfoKHR; - struct VideoEncodeRateControlInfoKHR; - struct VideoEncodeRateControlLayerInfoKHR; - struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR; - struct VideoEncodeQualityLevelPropertiesKHR; - struct VideoEncodeQualityLevelInfoKHR; - struct VideoEncodeSessionParametersGetInfoKHR; - struct VideoEncodeSessionParametersFeedbackInfoKHR; - - //=== VK_NV_device_diagnostics_config === - struct PhysicalDeviceDiagnosticsConfigFeaturesNV; - struct DeviceDiagnosticsConfigCreateInfoNV; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - struct CudaModuleCreateInfoNV; - struct CudaFunctionCreateInfoNV; - struct CudaLaunchInfoNV; - struct PhysicalDeviceCudaKernelLaunchFeaturesNV; - struct PhysicalDeviceCudaKernelLaunchPropertiesNV; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - struct PhysicalDeviceTileShadingFeaturesQCOM; - struct PhysicalDeviceTileShadingPropertiesQCOM; - struct RenderPassTileShadingCreateInfoQCOM; - struct PerTileBeginInfoQCOM; - struct PerTileEndInfoQCOM; - struct DispatchTileInfoQCOM; - - //=== VK_NV_low_latency === - struct QueryLowLatencySupportNV; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - struct ExportMetalObjectCreateInfoEXT; - struct ExportMetalObjectsInfoEXT; - struct ExportMetalDeviceInfoEXT; - struct ExportMetalCommandQueueInfoEXT; - struct ExportMetalBufferInfoEXT; - struct ImportMetalBufferInfoEXT; - struct ExportMetalTextureInfoEXT; - struct ImportMetalTextureInfoEXT; - struct ExportMetalIOSurfaceInfoEXT; - struct ImportMetalIOSurfaceInfoEXT; - struct ExportMetalSharedEventInfoEXT; - struct ImportMetalSharedEventInfoEXT; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_descriptor_buffer === - struct PhysicalDeviceDescriptorBufferPropertiesEXT; - struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; - struct PhysicalDeviceDescriptorBufferFeaturesEXT; - struct DescriptorAddressInfoEXT; - struct DescriptorBufferBindingInfoEXT; - struct DescriptorBufferBindingPushDescriptorBufferHandleEXT; - union DescriptorDataEXT; - struct DescriptorGetInfoEXT; - struct BufferCaptureDescriptorDataInfoEXT; - struct ImageCaptureDescriptorDataInfoEXT; - struct ImageViewCaptureDescriptorDataInfoEXT; - struct SamplerCaptureDescriptorDataInfoEXT; - struct OpaqueCaptureDescriptorDataCreateInfoEXT; - struct AccelerationStructureCaptureDescriptorDataInfoEXT; - - //=== VK_EXT_graphics_pipeline_library === - struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; - struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; - struct GraphicsPipelineLibraryCreateInfoEXT; - - //=== VK_AMD_shader_early_and_late_fragment_tests === - struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; - - //=== VK_KHR_fragment_shader_barycentric === - struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; - using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; - struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR; - - //=== VK_KHR_shader_subgroup_uniform_control_flow === - struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; - - //=== VK_NV_fragment_shading_rate_enums === - struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; - struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; - struct PipelineFragmentShadingRateEnumStateCreateInfoNV; - - //=== VK_NV_ray_tracing_motion_blur === - struct AccelerationStructureGeometryMotionTrianglesDataNV; - struct AccelerationStructureMotionInfoNV; - struct AccelerationStructureMotionInstanceNV; - union AccelerationStructureMotionInstanceDataNV; - struct AccelerationStructureMatrixMotionInstanceNV; - struct AccelerationStructureSRTMotionInstanceNV; - struct SRTDataNV; - struct PhysicalDeviceRayTracingMotionBlurFeaturesNV; - - //=== VK_EXT_mesh_shader === - struct PhysicalDeviceMeshShaderFeaturesEXT; - struct PhysicalDeviceMeshShaderPropertiesEXT; - struct DrawMeshTasksIndirectCommandEXT; - - //=== VK_EXT_ycbcr_2plane_444_formats === - struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; - - //=== VK_EXT_fragment_density_map2 === - struct PhysicalDeviceFragmentDensityMap2FeaturesEXT; - struct PhysicalDeviceFragmentDensityMap2PropertiesEXT; - - //=== VK_QCOM_rotated_copy_commands === - struct CopyCommandTransformInfoQCOM; - - //=== VK_KHR_workgroup_memory_explicit_layout === - struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; - - //=== VK_EXT_image_compression_control === - struct PhysicalDeviceImageCompressionControlFeaturesEXT; - struct ImageCompressionControlEXT; - struct ImageCompressionPropertiesEXT; - - //=== VK_EXT_attachment_feedback_loop_layout === - struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; - - //=== VK_EXT_4444_formats === - struct PhysicalDevice4444FormatsFeaturesEXT; - - //=== VK_EXT_device_fault === - struct PhysicalDeviceFaultFeaturesEXT; - struct DeviceFaultCountsEXT; - struct DeviceFaultInfoEXT; - struct DeviceFaultAddressInfoEXT; - struct DeviceFaultVendorInfoEXT; - struct DeviceFaultVendorBinaryHeaderVersionOneEXT; - - //=== VK_EXT_rgba10x6_formats === - struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT; - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - struct DirectFBSurfaceCreateInfoEXT; -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_vertex_input_dynamic_state === - struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT; - struct VertexInputBindingDescription2EXT; - struct VertexInputAttributeDescription2EXT; - - //=== VK_EXT_physical_device_drm === - struct PhysicalDeviceDrmPropertiesEXT; - - //=== VK_EXT_device_address_binding_report === - struct PhysicalDeviceAddressBindingReportFeaturesEXT; - struct DeviceAddressBindingCallbackDataEXT; - - //=== VK_EXT_depth_clip_control === - struct PhysicalDeviceDepthClipControlFeaturesEXT; - struct PipelineViewportDepthClipControlCreateInfoEXT; - - //=== VK_EXT_primitive_topology_list_restart === - struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - struct ImportMemoryZirconHandleInfoFUCHSIA; - struct MemoryZirconHandlePropertiesFUCHSIA; - struct MemoryGetZirconHandleInfoFUCHSIA; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - struct ImportSemaphoreZirconHandleInfoFUCHSIA; - struct SemaphoreGetZirconHandleInfoFUCHSIA; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - struct BufferCollectionCreateInfoFUCHSIA; - struct ImportMemoryBufferCollectionFUCHSIA; - struct BufferCollectionImageCreateInfoFUCHSIA; - struct BufferConstraintsInfoFUCHSIA; - struct BufferCollectionBufferCreateInfoFUCHSIA; - struct BufferCollectionPropertiesFUCHSIA; - struct SysmemColorSpaceFUCHSIA; - struct ImageConstraintsInfoFUCHSIA; - struct ImageFormatConstraintsInfoFUCHSIA; - struct BufferCollectionConstraintsInfoFUCHSIA; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - struct SubpassShadingPipelineCreateInfoHUAWEI; - struct PhysicalDeviceSubpassShadingFeaturesHUAWEI; - struct PhysicalDeviceSubpassShadingPropertiesHUAWEI; - - //=== VK_HUAWEI_invocation_mask === - struct PhysicalDeviceInvocationMaskFeaturesHUAWEI; - - //=== VK_NV_external_memory_rdma === - struct MemoryGetRemoteAddressInfoNV; - struct PhysicalDeviceExternalMemoryRDMAFeaturesNV; - - //=== VK_EXT_pipeline_properties === - struct PipelinePropertiesIdentifierEXT; - struct PhysicalDevicePipelinePropertiesFeaturesEXT; - - //=== VK_EXT_frame_boundary === - struct PhysicalDeviceFrameBoundaryFeaturesEXT; - struct FrameBoundaryEXT; - - //=== VK_EXT_multisampled_render_to_single_sampled === - struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; - struct SubpassResolvePerformanceQueryEXT; - struct MultisampledRenderToSingleSampledInfoEXT; - - //=== VK_EXT_extended_dynamic_state2 === - struct PhysicalDeviceExtendedDynamicState2FeaturesEXT; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - struct ScreenSurfaceCreateInfoQNX; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_EXT_color_write_enable === - struct PhysicalDeviceColorWriteEnableFeaturesEXT; - struct PipelineColorWriteCreateInfoEXT; - - //=== VK_EXT_primitives_generated_query === - struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; - - //=== VK_KHR_ray_tracing_maintenance1 === - struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR; - struct TraceRaysIndirectCommand2KHR; - - //=== VK_KHR_shader_untyped_pointers === - struct PhysicalDeviceShaderUntypedPointersFeaturesKHR; - - //=== VK_VALVE_video_encode_rgb_conversion === - struct PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; - struct VideoEncodeRgbConversionCapabilitiesVALVE; - struct VideoEncodeProfileRgbConversionInfoVALVE; - struct VideoEncodeSessionRgbConversionCreateInfoVALVE; - - //=== VK_EXT_image_view_min_lod === - struct PhysicalDeviceImageViewMinLodFeaturesEXT; - struct ImageViewMinLodCreateInfoEXT; - - //=== VK_EXT_multi_draw === - struct PhysicalDeviceMultiDrawFeaturesEXT; - struct PhysicalDeviceMultiDrawPropertiesEXT; - struct MultiDrawInfoEXT; - struct MultiDrawIndexedInfoEXT; - - //=== VK_EXT_image_2d_view_of_3d === - struct PhysicalDeviceImage2DViewOf3DFeaturesEXT; - - //=== VK_EXT_shader_tile_image === - struct PhysicalDeviceShaderTileImageFeaturesEXT; - struct PhysicalDeviceShaderTileImagePropertiesEXT; - - //=== VK_EXT_opacity_micromap === - struct MicromapBuildInfoEXT; - struct MicromapUsageEXT; - struct MicromapCreateInfoEXT; - struct PhysicalDeviceOpacityMicromapFeaturesEXT; - struct PhysicalDeviceOpacityMicromapPropertiesEXT; - struct MicromapVersionInfoEXT; - struct CopyMicromapToMemoryInfoEXT; - struct CopyMemoryToMicromapInfoEXT; - struct CopyMicromapInfoEXT; - struct MicromapBuildSizesInfoEXT; - struct AccelerationStructureTrianglesOpacityMicromapEXT; - struct MicromapTriangleEXT; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_displacement_micromap === - struct PhysicalDeviceDisplacementMicromapFeaturesNV; - struct PhysicalDeviceDisplacementMicromapPropertiesNV; - struct AccelerationStructureTrianglesDisplacementMicromapNV; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_HUAWEI_cluster_culling_shader === - struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI; - struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI; - struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; - - //=== VK_EXT_border_color_swizzle === - struct PhysicalDeviceBorderColorSwizzleFeaturesEXT; - struct SamplerBorderColorComponentMappingCreateInfoEXT; - - //=== VK_EXT_pageable_device_local_memory === - struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; - - //=== VK_ARM_shader_core_properties === - struct PhysicalDeviceShaderCorePropertiesARM; - - //=== VK_ARM_scheduling_controls === - struct DeviceQueueShaderCoreControlCreateInfoARM; - struct PhysicalDeviceSchedulingControlsFeaturesARM; - struct PhysicalDeviceSchedulingControlsPropertiesARM; - - //=== VK_EXT_image_sliced_view_of_3d === - struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT; - struct ImageViewSlicedCreateInfoEXT; - - //=== VK_VALVE_descriptor_set_host_mapping === - struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; - struct DescriptorSetBindingReferenceVALVE; - struct DescriptorSetLayoutHostMappingInfoVALVE; - - //=== VK_EXT_non_seamless_cube_map === - struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; - - //=== VK_ARM_render_pass_striped === - struct PhysicalDeviceRenderPassStripedFeaturesARM; - struct PhysicalDeviceRenderPassStripedPropertiesARM; - struct RenderPassStripeBeginInfoARM; - struct RenderPassStripeInfoARM; - struct RenderPassStripeSubmitInfoARM; - - //=== VK_NV_copy_memory_indirect === - struct PhysicalDeviceCopyMemoryIndirectFeaturesNV; - - //=== VK_NV_memory_decompression === - struct DecompressMemoryRegionNV; - - //=== VK_NV_device_generated_commands_compute === - struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; - struct ComputePipelineIndirectBufferInfoNV; - struct PipelineIndirectDeviceAddressInfoNV; - struct BindPipelineIndirectCommandNV; - - //=== VK_NV_ray_tracing_linear_swept_spheres === - struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; - struct AccelerationStructureGeometryLinearSweptSpheresDataNV; - struct AccelerationStructureGeometrySpheresDataNV; - - //=== VK_NV_linear_color_attachment === - struct PhysicalDeviceLinearColorAttachmentFeaturesNV; - - //=== VK_KHR_shader_maximal_reconvergence === - struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; - - //=== VK_EXT_image_compression_control_swapchain === - struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; - - //=== VK_QCOM_image_processing === - struct ImageViewSampleWeightCreateInfoQCOM; - struct PhysicalDeviceImageProcessingFeaturesQCOM; - struct PhysicalDeviceImageProcessingPropertiesQCOM; - - //=== VK_EXT_nested_command_buffer === - struct PhysicalDeviceNestedCommandBufferFeaturesEXT; - struct PhysicalDeviceNestedCommandBufferPropertiesEXT; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - struct NativeBufferUsageOHOS; - struct NativeBufferPropertiesOHOS; - struct NativeBufferFormatPropertiesOHOS; - struct ImportNativeBufferInfoOHOS; - struct MemoryGetNativeBufferInfoOHOS; - struct ExternalFormatOHOS; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_external_memory_acquire_unmodified === - struct ExternalMemoryAcquireUnmodifiedEXT; - - //=== VK_EXT_extended_dynamic_state3 === - struct PhysicalDeviceExtendedDynamicState3FeaturesEXT; - struct PhysicalDeviceExtendedDynamicState3PropertiesEXT; - struct ColorBlendEquationEXT; - struct ColorBlendAdvancedEXT; - - //=== VK_EXT_subpass_merge_feedback === - struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT; - struct RenderPassCreationControlEXT; - struct RenderPassCreationFeedbackInfoEXT; - struct RenderPassCreationFeedbackCreateInfoEXT; - struct RenderPassSubpassFeedbackInfoEXT; - struct RenderPassSubpassFeedbackCreateInfoEXT; - - //=== VK_LUNARG_direct_driver_loading === - struct DirectDriverLoadingInfoLUNARG; - struct DirectDriverLoadingListLUNARG; - - //=== VK_ARM_tensors === - struct TensorDescriptionARM; - struct TensorCreateInfoARM; - struct TensorMemoryRequirementsInfoARM; - struct BindTensorMemoryInfoARM; - struct WriteDescriptorSetTensorARM; - struct TensorFormatPropertiesARM; - struct PhysicalDeviceTensorPropertiesARM; - struct TensorMemoryBarrierARM; - struct TensorDependencyInfoARM; - struct PhysicalDeviceTensorFeaturesARM; - struct DeviceTensorMemoryRequirementsARM; - struct CopyTensorInfoARM; - struct TensorCopyARM; - struct MemoryDedicatedAllocateInfoTensorARM; - struct PhysicalDeviceExternalTensorInfoARM; - struct ExternalTensorPropertiesARM; - struct ExternalMemoryTensorCreateInfoARM; - struct PhysicalDeviceDescriptorBufferTensorFeaturesARM; - struct PhysicalDeviceDescriptorBufferTensorPropertiesARM; - struct DescriptorGetTensorInfoARM; - struct TensorCaptureDescriptorDataInfoARM; - struct TensorViewCaptureDescriptorDataInfoARM; - struct FrameBoundaryTensorsARM; - - //=== VK_EXT_shader_module_identifier === - struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT; - struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT; - struct PipelineShaderStageModuleIdentifierCreateInfoEXT; - struct ShaderModuleIdentifierEXT; - - //=== VK_EXT_rasterization_order_attachment_access === - struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; - using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; - - //=== VK_NV_optical_flow === - struct PhysicalDeviceOpticalFlowFeaturesNV; - struct PhysicalDeviceOpticalFlowPropertiesNV; - struct OpticalFlowImageFormatInfoNV; - struct OpticalFlowImageFormatPropertiesNV; - struct OpticalFlowSessionCreateInfoNV; - struct OpticalFlowSessionCreatePrivateDataInfoNV; - struct OpticalFlowExecuteInfoNV; - - //=== VK_EXT_legacy_dithering === - struct PhysicalDeviceLegacyDitheringFeaturesEXT; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_format_resolve === - struct PhysicalDeviceExternalFormatResolveFeaturesANDROID; - struct PhysicalDeviceExternalFormatResolvePropertiesANDROID; - struct AndroidHardwareBufferFormatResolvePropertiesANDROID; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - //=== VK_AMD_anti_lag === - struct PhysicalDeviceAntiLagFeaturesAMD; - struct AntiLagDataAMD; - struct AntiLagPresentationInfoAMD; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_dense_geometry_format === - struct PhysicalDeviceDenseGeometryFormatFeaturesAMDX; - struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_KHR_present_id2 === - struct SurfaceCapabilitiesPresentId2KHR; - struct PresentId2KHR; - struct PhysicalDevicePresentId2FeaturesKHR; - - //=== VK_KHR_present_wait2 === - struct SurfaceCapabilitiesPresentWait2KHR; - struct PhysicalDevicePresentWait2FeaturesKHR; - struct PresentWait2InfoKHR; - - //=== VK_KHR_ray_tracing_position_fetch === - struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR; - - //=== VK_EXT_shader_object === - struct PhysicalDeviceShaderObjectFeaturesEXT; - struct PhysicalDeviceShaderObjectPropertiesEXT; - struct ShaderCreateInfoEXT; - - //=== VK_KHR_pipeline_binary === - struct PhysicalDevicePipelineBinaryFeaturesKHR; - struct PhysicalDevicePipelineBinaryPropertiesKHR; - struct DevicePipelineBinaryInternalCacheControlKHR; - struct PipelineBinaryKeyKHR; - struct PipelineBinaryDataKHR; - struct PipelineBinaryKeysAndDataKHR; - struct PipelineBinaryCreateInfoKHR; - struct PipelineBinaryInfoKHR; - struct ReleaseCapturedPipelineDataInfoKHR; - struct PipelineBinaryDataInfoKHR; - struct PipelineCreateInfoKHR; - struct PipelineBinaryHandlesInfoKHR; - - //=== VK_QCOM_tile_properties === - struct PhysicalDeviceTilePropertiesFeaturesQCOM; - struct TilePropertiesQCOM; - - //=== VK_SEC_amigo_profiling === - struct PhysicalDeviceAmigoProfilingFeaturesSEC; - struct AmigoProfilingSubmitInfoSEC; - - //=== VK_KHR_surface_maintenance1 === - struct SurfacePresentModeKHR; - using SurfacePresentModeEXT = SurfacePresentModeKHR; - struct SurfacePresentScalingCapabilitiesKHR; - using SurfacePresentScalingCapabilitiesEXT = SurfacePresentScalingCapabilitiesKHR; - struct SurfacePresentModeCompatibilityKHR; - using SurfacePresentModeCompatibilityEXT = SurfacePresentModeCompatibilityKHR; - - //=== VK_KHR_swapchain_maintenance1 === - struct PhysicalDeviceSwapchainMaintenance1FeaturesKHR; - using PhysicalDeviceSwapchainMaintenance1FeaturesEXT = PhysicalDeviceSwapchainMaintenance1FeaturesKHR; - struct SwapchainPresentFenceInfoKHR; - using SwapchainPresentFenceInfoEXT = SwapchainPresentFenceInfoKHR; - struct SwapchainPresentModesCreateInfoKHR; - using SwapchainPresentModesCreateInfoEXT = SwapchainPresentModesCreateInfoKHR; - struct SwapchainPresentModeInfoKHR; - using SwapchainPresentModeInfoEXT = SwapchainPresentModeInfoKHR; - struct SwapchainPresentScalingCreateInfoKHR; - using SwapchainPresentScalingCreateInfoEXT = SwapchainPresentScalingCreateInfoKHR; - struct ReleaseSwapchainImagesInfoKHR; - using ReleaseSwapchainImagesInfoEXT = ReleaseSwapchainImagesInfoKHR; - - //=== VK_QCOM_multiview_per_view_viewports === - struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; - - //=== VK_NV_ray_tracing_invocation_reorder === - struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV; - struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV; - - //=== VK_NV_cooperative_vector === - struct PhysicalDeviceCooperativeVectorPropertiesNV; - struct PhysicalDeviceCooperativeVectorFeaturesNV; - struct CooperativeVectorPropertiesNV; - struct ConvertCooperativeVectorMatrixInfoNV; - - //=== VK_NV_extended_sparse_address_space === - struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; - struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV; - - //=== VK_EXT_mutable_descriptor_type === - struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT; - using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT; - struct MutableDescriptorTypeListEXT; - using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT; - struct MutableDescriptorTypeCreateInfoEXT; - using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT; - - //=== VK_EXT_legacy_vertex_attributes === - struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT; - struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT; - - //=== VK_EXT_layer_settings === - struct LayerSettingsCreateInfoEXT; - struct LayerSettingEXT; - - //=== VK_ARM_shader_core_builtins === - struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM; - struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM; - - //=== VK_EXT_pipeline_library_group_handles === - struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; - - //=== VK_EXT_dynamic_rendering_unused_attachments === - struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; - - //=== VK_KHR_internally_synchronized_queues === - struct PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; - - //=== VK_NV_low_latency2 === - struct LatencySleepModeInfoNV; - struct LatencySleepInfoNV; - struct SetLatencyMarkerInfoNV; - struct GetLatencyMarkerInfoNV; - struct LatencyTimingsFrameReportNV; - struct LatencySubmissionPresentIdNV; - struct SwapchainLatencyCreateInfoNV; - struct OutOfBandQueueTypeInfoNV; - struct LatencySurfaceCapabilitiesNV; - - //=== VK_KHR_cooperative_matrix === - struct CooperativeMatrixPropertiesKHR; - struct PhysicalDeviceCooperativeMatrixFeaturesKHR; - struct PhysicalDeviceCooperativeMatrixPropertiesKHR; - - //=== VK_ARM_data_graph === - struct PhysicalDeviceDataGraphFeaturesARM; - struct DataGraphPipelineConstantARM; - struct DataGraphPipelineResourceInfoARM; - struct DataGraphPipelineCompilerControlCreateInfoARM; - struct DataGraphPipelineCreateInfoARM; - struct DataGraphPipelineShaderModuleCreateInfoARM; - struct DataGraphPipelineSessionCreateInfoARM; - struct DataGraphPipelineSessionBindPointRequirementsInfoARM; - struct DataGraphPipelineSessionBindPointRequirementARM; - struct DataGraphPipelineSessionMemoryRequirementsInfoARM; - struct BindDataGraphPipelineSessionMemoryInfoARM; - struct DataGraphPipelineInfoARM; - struct DataGraphPipelinePropertyQueryResultARM; - struct DataGraphPipelineIdentifierCreateInfoARM; - struct DataGraphPipelineDispatchInfoARM; - struct PhysicalDeviceDataGraphProcessingEngineARM; - struct QueueFamilyDataGraphPropertiesARM; - struct DataGraphProcessingEngineCreateInfoARM; - struct PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; - struct QueueFamilyDataGraphProcessingEnginePropertiesARM; - struct PhysicalDeviceDataGraphOperationSupportARM; - struct DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; - - //=== VK_QCOM_multiview_per_view_render_areas === - struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; - struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; - - //=== VK_KHR_compute_shader_derivatives === - struct PhysicalDeviceComputeShaderDerivativesFeaturesKHR; - using PhysicalDeviceComputeShaderDerivativesFeaturesNV = PhysicalDeviceComputeShaderDerivativesFeaturesKHR; - struct PhysicalDeviceComputeShaderDerivativesPropertiesKHR; - - //=== VK_KHR_video_decode_av1 === - struct VideoDecodeAV1ProfileInfoKHR; - struct VideoDecodeAV1CapabilitiesKHR; - struct VideoDecodeAV1SessionParametersCreateInfoKHR; - struct VideoDecodeAV1PictureInfoKHR; - struct VideoDecodeAV1DpbSlotInfoKHR; - - //=== VK_KHR_video_encode_av1 === - struct PhysicalDeviceVideoEncodeAV1FeaturesKHR; - struct VideoEncodeAV1CapabilitiesKHR; - struct VideoEncodeAV1QualityLevelPropertiesKHR; - struct VideoEncodeAV1SessionCreateInfoKHR; - struct VideoEncodeAV1SessionParametersCreateInfoKHR; - struct VideoEncodeAV1PictureInfoKHR; - struct VideoEncodeAV1DpbSlotInfoKHR; - struct VideoEncodeAV1ProfileInfoKHR; - struct VideoEncodeAV1QIndexKHR; - struct VideoEncodeAV1FrameSizeKHR; - struct VideoEncodeAV1GopRemainingFrameInfoKHR; - struct VideoEncodeAV1RateControlInfoKHR; - struct VideoEncodeAV1RateControlLayerInfoKHR; - - //=== VK_KHR_video_decode_vp9 === - struct PhysicalDeviceVideoDecodeVP9FeaturesKHR; - struct VideoDecodeVP9ProfileInfoKHR; - struct VideoDecodeVP9CapabilitiesKHR; - struct VideoDecodeVP9PictureInfoKHR; - - //=== VK_KHR_video_maintenance1 === - struct PhysicalDeviceVideoMaintenance1FeaturesKHR; - struct VideoInlineQueryInfoKHR; - - //=== VK_NV_per_stage_descriptor_set === - struct PhysicalDevicePerStageDescriptorSetFeaturesNV; - - //=== VK_QCOM_image_processing2 === - struct PhysicalDeviceImageProcessing2FeaturesQCOM; - struct PhysicalDeviceImageProcessing2PropertiesQCOM; - struct SamplerBlockMatchWindowCreateInfoQCOM; - - //=== VK_QCOM_filter_cubic_weights === - struct PhysicalDeviceCubicWeightsFeaturesQCOM; - struct SamplerCubicWeightsCreateInfoQCOM; - struct BlitImageCubicWeightsInfoQCOM; - - //=== VK_QCOM_ycbcr_degamma === - struct PhysicalDeviceYcbcrDegammaFeaturesQCOM; - struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; - - //=== VK_QCOM_filter_cubic_clamp === - struct PhysicalDeviceCubicClampFeaturesQCOM; - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; - - //=== VK_KHR_unified_image_layouts === - struct PhysicalDeviceUnifiedImageLayoutsFeaturesKHR; - struct AttachmentFeedbackLoopInfoEXT; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - struct ScreenBufferPropertiesQNX; - struct ScreenBufferFormatPropertiesQNX; - struct ImportScreenBufferInfoQNX; - struct ExternalFormatQNX; - struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_MSFT_layered_driver === - struct PhysicalDeviceLayeredDriverPropertiesMSFT; - - //=== VK_KHR_calibrated_timestamps === - struct CalibratedTimestampInfoKHR; - using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR; - - //=== VK_KHR_maintenance6 === - struct SetDescriptorBufferOffsetsInfoEXT; - struct BindDescriptorBufferEmbeddedSamplersInfoEXT; - - //=== VK_NV_descriptor_pool_overallocation === - struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; - - //=== VK_QCOM_tile_memory_heap === - struct PhysicalDeviceTileMemoryHeapFeaturesQCOM; - struct PhysicalDeviceTileMemoryHeapPropertiesQCOM; - struct TileMemoryRequirementsQCOM; - struct TileMemoryBindInfoQCOM; - struct TileMemorySizeInfoQCOM; - - //=== VK_KHR_copy_memory_indirect === - struct StridedDeviceAddressRangeKHR; - struct CopyMemoryIndirectCommandKHR; - using CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR; - struct CopyMemoryIndirectInfoKHR; - struct CopyMemoryToImageIndirectCommandKHR; - using CopyMemoryToImageIndirectCommandNV = CopyMemoryToImageIndirectCommandKHR; - struct CopyMemoryToImageIndirectInfoKHR; - struct PhysicalDeviceCopyMemoryIndirectFeaturesKHR; - struct PhysicalDeviceCopyMemoryIndirectPropertiesKHR; - using PhysicalDeviceCopyMemoryIndirectPropertiesNV = PhysicalDeviceCopyMemoryIndirectPropertiesKHR; - - //=== VK_EXT_memory_decompression === - struct DecompressMemoryInfoEXT; - struct DecompressMemoryRegionEXT; - struct PhysicalDeviceMemoryDecompressionFeaturesEXT; - using PhysicalDeviceMemoryDecompressionFeaturesNV = PhysicalDeviceMemoryDecompressionFeaturesEXT; - struct PhysicalDeviceMemoryDecompressionPropertiesEXT; - using PhysicalDeviceMemoryDecompressionPropertiesNV = PhysicalDeviceMemoryDecompressionPropertiesEXT; - - //=== VK_NV_display_stereo === - struct DisplaySurfaceStereoCreateInfoNV; - struct DisplayModeStereoPropertiesNV; - - //=== VK_KHR_video_encode_intra_refresh === - struct VideoEncodeIntraRefreshCapabilitiesKHR; - struct VideoEncodeSessionIntraRefreshCreateInfoKHR; - struct VideoEncodeIntraRefreshInfoKHR; - struct VideoReferenceIntraRefreshInfoKHR; - struct PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; - - //=== VK_KHR_video_encode_quantization_map === - struct VideoEncodeQuantizationMapCapabilitiesKHR; - struct VideoFormatQuantizationMapPropertiesKHR; - struct VideoEncodeQuantizationMapInfoKHR; - struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR; - struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; - struct VideoEncodeH264QuantizationMapCapabilitiesKHR; - struct VideoEncodeH265QuantizationMapCapabilitiesKHR; - struct VideoFormatH265QuantizationMapPropertiesKHR; - struct VideoEncodeAV1QuantizationMapCapabilitiesKHR; - struct VideoFormatAV1QuantizationMapPropertiesKHR; - - //=== VK_NV_raw_access_chains === - struct PhysicalDeviceRawAccessChainsFeaturesNV; - - //=== VK_NV_external_compute_queue === - struct ExternalComputeQueueDeviceCreateInfoNV; - struct ExternalComputeQueueCreateInfoNV; - struct ExternalComputeQueueDataParamsNV; - struct PhysicalDeviceExternalComputeQueuePropertiesNV; - - //=== VK_KHR_shader_relaxed_extended_instruction === - struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; - - //=== VK_NV_command_buffer_inheritance === - struct PhysicalDeviceCommandBufferInheritanceFeaturesNV; - - //=== VK_KHR_maintenance7 === - struct PhysicalDeviceMaintenance7FeaturesKHR; - struct PhysicalDeviceMaintenance7PropertiesKHR; - struct PhysicalDeviceLayeredApiPropertiesListKHR; - struct PhysicalDeviceLayeredApiPropertiesKHR; - struct PhysicalDeviceLayeredApiVulkanPropertiesKHR; - - //=== VK_NV_shader_atomic_float16_vector === - struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; - - //=== VK_EXT_shader_replicated_composites === - struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT; - - //=== VK_EXT_shader_float8 === - struct PhysicalDeviceShaderFloat8FeaturesEXT; - - //=== VK_NV_ray_tracing_validation === - struct PhysicalDeviceRayTracingValidationFeaturesNV; - - //=== VK_NV_cluster_acceleration_structure === - struct PhysicalDeviceClusterAccelerationStructureFeaturesNV; - struct PhysicalDeviceClusterAccelerationStructurePropertiesNV; - struct ClusterAccelerationStructureClustersBottomLevelInputNV; - struct ClusterAccelerationStructureTriangleClusterInputNV; - struct ClusterAccelerationStructureMoveObjectsInputNV; - union ClusterAccelerationStructureOpInputNV; - struct ClusterAccelerationStructureInputInfoNV; - struct ClusterAccelerationStructureCommandsInfoNV; - struct StridedDeviceAddressNV; - struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV; - struct ClusterAccelerationStructureMoveObjectsInfoNV; - struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNV; - struct ClusterAccelerationStructureBuildTriangleClusterInfoNV; - struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV; - struct ClusterAccelerationStructureInstantiateClusterInfoNV; - struct ClusterAccelerationStructureGetTemplateIndicesInfoNV; - struct RayTracingPipelineClusterAccelerationStructureCreateInfoNV; - - //=== VK_NV_partitioned_acceleration_structure === - struct PhysicalDevicePartitionedAccelerationStructureFeaturesNV; - struct PhysicalDevicePartitionedAccelerationStructurePropertiesNV; - struct PartitionedAccelerationStructureFlagsNV; - struct BuildPartitionedAccelerationStructureIndirectCommandNV; - struct PartitionedAccelerationStructureWriteInstanceDataNV; - struct PartitionedAccelerationStructureUpdateInstanceDataNV; - struct PartitionedAccelerationStructureWritePartitionTranslationDataNV; - struct WriteDescriptorSetPartitionedAccelerationStructureNV; - struct PartitionedAccelerationStructureInstancesInputNV; - struct BuildPartitionedAccelerationStructureInfoNV; - - //=== VK_EXT_device_generated_commands === - struct PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; - struct PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; - struct GeneratedCommandsMemoryRequirementsInfoEXT; - struct IndirectExecutionSetCreateInfoEXT; - union IndirectExecutionSetInfoEXT; - struct IndirectExecutionSetPipelineInfoEXT; - struct IndirectExecutionSetShaderInfoEXT; - struct GeneratedCommandsInfoEXT; - struct WriteIndirectExecutionSetPipelineEXT; - struct IndirectCommandsLayoutCreateInfoEXT; - struct IndirectCommandsLayoutTokenEXT; - struct DrawIndirectCountIndirectCommandEXT; - struct IndirectCommandsVertexBufferTokenEXT; - struct BindVertexBufferIndirectCommandEXT; - struct IndirectCommandsIndexBufferTokenEXT; - struct BindIndexBufferIndirectCommandEXT; - struct IndirectCommandsPushConstantTokenEXT; - struct IndirectCommandsExecutionSetTokenEXT; - union IndirectCommandsTokenDataEXT; - struct IndirectExecutionSetShaderLayoutInfoEXT; - struct GeneratedCommandsPipelineInfoEXT; - struct GeneratedCommandsShaderInfoEXT; - struct WriteIndirectExecutionSetShaderEXT; - - //=== VK_KHR_maintenance8 === - struct MemoryBarrierAccessFlags3KHR; - struct PhysicalDeviceMaintenance8FeaturesKHR; - - //=== VK_MESA_image_alignment_control === - struct PhysicalDeviceImageAlignmentControlFeaturesMESA; - struct PhysicalDeviceImageAlignmentControlPropertiesMESA; - struct ImageAlignmentControlCreateInfoMESA; - - //=== VK_KHR_shader_fma === - struct PhysicalDeviceShaderFmaFeaturesKHR; - - //=== VK_NV_push_constant_bank === - struct PushConstantBankInfoNV; - struct PhysicalDevicePushConstantBankFeaturesNV; - struct PhysicalDevicePushConstantBankPropertiesNV; - - //=== VK_EXT_ray_tracing_invocation_reorder === - struct PhysicalDeviceRayTracingInvocationReorderPropertiesEXT; - struct PhysicalDeviceRayTracingInvocationReorderFeaturesEXT; - - //=== VK_EXT_depth_clamp_control === - struct PhysicalDeviceDepthClampControlFeaturesEXT; - struct PipelineViewportDepthClampControlCreateInfoEXT; - struct DepthClampRangeEXT; - - //=== VK_KHR_maintenance9 === - struct PhysicalDeviceMaintenance9FeaturesKHR; - struct PhysicalDeviceMaintenance9PropertiesKHR; - struct QueueFamilyOwnershipTransferPropertiesKHR; - - //=== VK_KHR_video_maintenance2 === - struct PhysicalDeviceVideoMaintenance2FeaturesKHR; - struct VideoDecodeH264InlineSessionParametersInfoKHR; - struct VideoDecodeH265InlineSessionParametersInfoKHR; - struct VideoDecodeAV1InlineSessionParametersInfoKHR; - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - struct SurfaceCreateInfoOHOS; -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_HUAWEI_hdr_vivid === - struct PhysicalDeviceHdrVividFeaturesHUAWEI; - struct HdrVividDynamicMetadataHUAWEI; - - //=== VK_NV_cooperative_matrix2 === - struct CooperativeMatrixFlexibleDimensionsPropertiesNV; - struct PhysicalDeviceCooperativeMatrix2FeaturesNV; - struct PhysicalDeviceCooperativeMatrix2PropertiesNV; - - //=== VK_ARM_pipeline_opacity_micromap === - struct PhysicalDevicePipelineOpacityMicromapFeaturesARM; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - struct ImportMemoryMetalHandleInfoEXT; - struct MemoryMetalHandlePropertiesEXT; - struct MemoryGetMetalHandleInfoEXT; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_depth_clamp_zero_one === - struct PhysicalDeviceDepthClampZeroOneFeaturesKHR; - using PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR; - - //=== VK_ARM_performance_counters_by_region === - struct PhysicalDevicePerformanceCountersByRegionFeaturesARM; - struct PhysicalDevicePerformanceCountersByRegionPropertiesARM; - struct PerformanceCounterARM; - struct PerformanceCounterDescriptionARM; - struct RenderPassPerformanceCountersByRegionBeginInfoARM; - - //=== VK_EXT_vertex_attribute_robustness === - struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT; - - //=== VK_ARM_format_pack === - struct PhysicalDeviceFormatPackFeaturesARM; - - //=== VK_VALVE_fragment_density_map_layered === - struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; - struct PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; - struct PipelineFragmentDensityMapLayeredCreateInfoVALVE; - - //=== VK_KHR_robustness2 === - struct PhysicalDeviceRobustness2FeaturesKHR; - using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR; - struct PhysicalDeviceRobustness2PropertiesKHR; - using PhysicalDeviceRobustness2PropertiesEXT = PhysicalDeviceRobustness2PropertiesKHR; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_present_metering === - struct SetPresentConfigNV; - struct PhysicalDevicePresentMeteringFeaturesNV; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_fragment_density_map_offset === - struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; - using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; - struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; - using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; - struct RenderPassFragmentDensityMapOffsetEndInfoEXT; - using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT; - - //=== VK_EXT_zero_initialize_device_memory === - struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; - - //=== VK_KHR_present_mode_fifo_latest_ready === - struct PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; - using PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; - - //=== VK_EXT_shader_64bit_indexing === - struct PhysicalDeviceShader64BitIndexingFeaturesEXT; - - //=== VK_EXT_custom_resolve === - struct PhysicalDeviceCustomResolveFeaturesEXT; - struct BeginCustomResolveInfoEXT; - struct CustomResolveCreateInfoEXT; - - //=== VK_QCOM_data_graph_model === - struct PipelineCacheHeaderVersionDataGraphQCOM; - struct DataGraphPipelineBuiltinModelCreateInfoQCOM; - struct PhysicalDeviceDataGraphModelFeaturesQCOM; - - //=== VK_KHR_maintenance10 === - struct PhysicalDeviceMaintenance10FeaturesKHR; - struct PhysicalDeviceMaintenance10PropertiesKHR; - struct RenderingEndInfoKHR; - using RenderingEndInfoEXT = RenderingEndInfoKHR; - struct RenderingAttachmentFlagsInfoKHR; - struct ResolveImageModeInfoKHR; - - //=== VK_EXT_shader_long_vector === - struct PhysicalDeviceShaderLongVectorFeaturesEXT; - struct PhysicalDeviceShaderLongVectorPropertiesEXT; - - //=== VK_SEC_pipeline_cache_incremental_mode === - struct PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; - - //=== VK_EXT_shader_uniform_buffer_unsized_array === - struct PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; - - //=== VK_NV_compute_occupancy_priority === - struct ComputeOccupancyPriorityParametersNV; - struct PhysicalDeviceComputeOccupancyPriorityFeaturesNV; - - //=== VK_EXT_shader_subgroup_partitioned === - struct PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; - - //=================================== - //=== HANDLE forward declarations === - //=================================== - - //=== VK_VERSION_1_0 === - class Instance; - class PhysicalDevice; - class Device; - class Queue; - class DeviceMemory; - class Fence; - class Semaphore; - class QueryPool; - class Buffer; - class Image; - class ImageView; - class CommandPool; - class CommandBuffer; - class Event; - class BufferView; - class ShaderModule; - class PipelineCache; - class Pipeline; - class PipelineLayout; - class Sampler; - class DescriptorPool; - class DescriptorSet; - class DescriptorSetLayout; - class Framebuffer; - class RenderPass; - - //=== VK_VERSION_1_1 === - class DescriptorUpdateTemplate; - class SamplerYcbcrConversion; - - //=== VK_VERSION_1_3 === - class PrivateDataSlot; - - //=== VK_KHR_surface === - class SurfaceKHR; - - //=== VK_KHR_swapchain === - class SwapchainKHR; - - //=== VK_KHR_display === - class DisplayKHR; - class DisplayModeKHR; - - //=== VK_EXT_debug_report === - class DebugReportCallbackEXT; - - //=== VK_KHR_video_queue === - class VideoSessionKHR; - class VideoSessionParametersKHR; - - //=== VK_NVX_binary_import === - class CuModuleNVX; - class CuFunctionNVX; - - //=== VK_EXT_debug_utils === - class DebugUtilsMessengerEXT; - - //=== VK_EXT_descriptor_heap === - class TensorARM; - - //=== VK_KHR_acceleration_structure === - class AccelerationStructureKHR; - - //=== VK_EXT_validation_cache === - class ValidationCacheEXT; - - //=== VK_NV_ray_tracing === - class AccelerationStructureNV; - - //=== VK_INTEL_performance_query === - class PerformanceConfigurationINTEL; - - //=== VK_KHR_deferred_host_operations === - class DeferredOperationKHR; - - //=== VK_NV_device_generated_commands === - class IndirectCommandsLayoutNV; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - class CudaModuleNV; - class CudaFunctionNV; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - class BufferCollectionFUCHSIA; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_EXT_opacity_micromap === - class MicromapEXT; - - //=== VK_ARM_tensors === - class TensorARM; - class TensorViewARM; - - //=== VK_NV_optical_flow === - class OpticalFlowSessionNV; - - //=== VK_EXT_shader_object === - class ShaderEXT; - - //=== VK_KHR_pipeline_binary === - class PipelineBinaryKHR; - - //=== VK_ARM_data_graph === - class DataGraphPipelineSessionARM; - - //=== VK_NV_external_compute_queue === - class ExternalComputeQueueNV; - - //=== VK_EXT_device_generated_commands === - class IndirectCommandsLayoutEXT; - class IndirectExecutionSetEXT; - - typedef void( VKAPI_PTR * PFN_VoidFunction )(); - -#ifndef VULKAN_HPP_NO_SMART_HANDLE - //====================== - //=== UNIQUE HANDLEs === - //====================== - - //=== VK_VERSION_1_0 === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueInstance = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueDevice = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectFree; - }; - - using UniqueDeviceMemory = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueFence = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueSemaphore = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueQueryPool = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueBuffer = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueImage = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueImageView = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueCommandPool = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::PoolFree; - }; - - using UniqueCommandBuffer = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueEvent = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueBufferView = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueShaderModule = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniquePipelineCache = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniquePipeline = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniquePipelineLayout = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueSampler = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueDescriptorPool = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::PoolFree; - }; - - using UniqueDescriptorSet = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueDescriptorSetLayout = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueFramebuffer = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueRenderPass = UniqueHandle; - - //=== VK_VERSION_1_1 === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueDescriptorUpdateTemplate = UniqueHandle; - using UniqueDescriptorUpdateTemplateKHR = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueSamplerYcbcrConversion = UniqueHandle; - using UniqueSamplerYcbcrConversionKHR = UniqueHandle; - - //=== VK_VERSION_1_3 === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniquePrivateDataSlot = UniqueHandle; - using UniquePrivateDataSlotEXT = UniqueHandle; - - //=== VK_KHR_surface === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueSurfaceKHR = UniqueHandle; - - //=== VK_KHR_swapchain === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueSwapchainKHR = UniqueHandle; - - //=== VK_KHR_display === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueDisplayKHR = UniqueHandle; - - //=== VK_EXT_debug_report === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueDebugReportCallbackEXT = UniqueHandle; - - //=== VK_KHR_video_queue === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueVideoSessionKHR = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueVideoSessionParametersKHR = UniqueHandle; - - //=== VK_NVX_binary_import === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueCuModuleNVX = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueCuFunctionNVX = UniqueHandle; - - //=== VK_EXT_debug_utils === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueDebugUtilsMessengerEXT = UniqueHandle; - - //=== VK_EXT_descriptor_heap === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueTensorARM = UniqueHandle; - - //=== VK_KHR_acceleration_structure === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueAccelerationStructureKHR = UniqueHandle; - - //=== VK_EXT_validation_cache === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueValidationCacheEXT = UniqueHandle; - - //=== VK_NV_ray_tracing === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueAccelerationStructureNV = UniqueHandle; - - //=== VK_INTEL_performance_query === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniquePerformanceConfigurationINTEL = UniqueHandle; - - //=== VK_KHR_deferred_host_operations === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueDeferredOperationKHR = UniqueHandle; - - //=== VK_NV_device_generated_commands === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueIndirectCommandsLayoutNV = UniqueHandle; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueCudaModuleNV = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueCudaFunctionNV = UniqueHandle; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueBufferCollectionFUCHSIA = UniqueHandle; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_EXT_opacity_micromap === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueMicromapEXT = UniqueHandle; - - //=== VK_ARM_tensors === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueTensorViewARM = UniqueHandle; - - //=== VK_NV_optical_flow === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueOpticalFlowSessionNV = UniqueHandle; - - //=== VK_EXT_shader_object === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueShaderEXT = UniqueHandle; - - //=== VK_KHR_pipeline_binary === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniquePipelineBinaryKHR = UniqueHandle; - - //=== VK_ARM_data_graph === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueDataGraphPipelineSessionARM = UniqueHandle; - - //=== VK_NV_external_compute_queue === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueExternalComputeQueueNV = UniqueHandle; - - //=== VK_EXT_device_generated_commands === - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueIndirectCommandsLayoutEXT = UniqueHandle; - - template - class UniqueHandleTraits - { - public: - using deleter = detail::ObjectDestroy; - }; - - using UniqueIndirectExecutionSetEXT = UniqueHandle; -#endif /*VULKAN_HPP_NO_SMART_HANDLE*/ - - //=============== - //=== HANDLEs === - //=============== - - template - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false; - }; - - // wrapper class for handle VkSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceKHR.html - class SurfaceKHR - { - public: - using CType = VkSurfaceKHR; - using NativeType = VkSurfaceKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSurfaceKHR; - - public: - SurfaceKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - SurfaceKHR( SurfaceKHR const & rhs ) = default; - SurfaceKHR & operator=( SurfaceKHR const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - SurfaceKHR( SurfaceKHR && rhs ) = default; - SurfaceKHR & operator=( SurfaceKHR && rhs ) = default; -#else - SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( exchange( rhs.m_surfaceKHR, {} ) ) {} - - SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - m_surfaceKHR = exchange( rhs.m_surfaceKHR, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR SurfaceKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT SurfaceKHR( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT : m_surfaceKHR( surfaceKHR ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - SurfaceKHR & operator=( VkSurfaceKHR surfaceKHR ) VULKAN_HPP_NOEXCEPT - { - m_surfaceKHR = surfaceKHR; - return *this; - } -#endif - - SurfaceKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_surfaceKHR = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSurfaceKHR() const VULKAN_HPP_NOEXCEPT - { - return m_surfaceKHR; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_surfaceKHR != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_surfaceKHR == VK_NULL_HANDLE; - } - - private: - VkSurfaceKHR m_surfaceKHR = {}; - }; - - template <> - struct CppType - { - using Type = SurfaceKHR; - }; - - template <> - struct CppType - { - using Type = SurfaceKHR; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = SurfaceKHR; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportCallbackEXT.html - class DebugReportCallbackEXT - { - public: - using CType = VkDebugReportCallbackEXT; - using NativeType = VkDebugReportCallbackEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDebugReportCallbackEXT; - - public: - DebugReportCallbackEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - DebugReportCallbackEXT( DebugReportCallbackEXT const & rhs ) = default; - DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) = default; - DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) = default; -#else - DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_debugReportCallbackEXT( exchange( rhs.m_debugReportCallbackEXT, {} ) ) {} - - DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - m_debugReportCallbackEXT = exchange( rhs.m_debugReportCallbackEXT, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR DebugReportCallbackEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DebugReportCallbackEXT( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT - : m_debugReportCallbackEXT( debugReportCallbackEXT ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - DebugReportCallbackEXT & operator=( VkDebugReportCallbackEXT debugReportCallbackEXT ) VULKAN_HPP_NOEXCEPT - { - m_debugReportCallbackEXT = debugReportCallbackEXT; - return *this; - } -#endif - - DebugReportCallbackEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_debugReportCallbackEXT = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT - { - return m_debugReportCallbackEXT; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_debugReportCallbackEXT != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_debugReportCallbackEXT == VK_NULL_HANDLE; - } - - private: - VkDebugReportCallbackEXT m_debugReportCallbackEXT = {}; - }; - - template <> - struct CppType - { - using Type = DebugReportCallbackEXT; - }; - - template <> - struct CppType - { - using Type = DebugReportCallbackEXT; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = DebugReportCallbackEXT; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerEXT.html - class DebugUtilsMessengerEXT - { - public: - using CType = VkDebugUtilsMessengerEXT; - using NativeType = VkDebugUtilsMessengerEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - DebugUtilsMessengerEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & rhs ) = default; - DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) = default; - DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) = default; -#else - DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_debugUtilsMessengerEXT( exchange( rhs.m_debugUtilsMessengerEXT, {} ) ) {} - - DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - m_debugUtilsMessengerEXT = exchange( rhs.m_debugUtilsMessengerEXT, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DebugUtilsMessengerEXT( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT - : m_debugUtilsMessengerEXT( debugUtilsMessengerEXT ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - DebugUtilsMessengerEXT & operator=( VkDebugUtilsMessengerEXT debugUtilsMessengerEXT ) VULKAN_HPP_NOEXCEPT - { - m_debugUtilsMessengerEXT = debugUtilsMessengerEXT; - return *this; - } -#endif - - DebugUtilsMessengerEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_debugUtilsMessengerEXT = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT - { - return m_debugUtilsMessengerEXT; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_debugUtilsMessengerEXT != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_debugUtilsMessengerEXT == VK_NULL_HANDLE; - } - - private: - VkDebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {}; - }; - - template <> - struct CppType - { - using Type = DebugUtilsMessengerEXT; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = DebugUtilsMessengerEXT; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDisplayKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayKHR.html - class DisplayKHR - { - public: - using CType = VkDisplayKHR; - using NativeType = VkDisplayKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayKHR; - - public: - DisplayKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - DisplayKHR( DisplayKHR const & rhs ) = default; - DisplayKHR & operator=( DisplayKHR const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - DisplayKHR( DisplayKHR && rhs ) = default; - DisplayKHR & operator=( DisplayKHR && rhs ) = default; -#else - DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayKHR( exchange( rhs.m_displayKHR, {} ) ) {} - - DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - m_displayKHR = exchange( rhs.m_displayKHR, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR DisplayKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DisplayKHR( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT : m_displayKHR( displayKHR ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - DisplayKHR & operator=( VkDisplayKHR displayKHR ) VULKAN_HPP_NOEXCEPT - { - m_displayKHR = displayKHR; - return *this; - } -#endif - - DisplayKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_displayKHR = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayKHR() const VULKAN_HPP_NOEXCEPT - { - return m_displayKHR; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_displayKHR != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_displayKHR == VK_NULL_HANDLE; - } - - private: - VkDisplayKHR m_displayKHR = {}; - }; - - template <> - struct CppType - { - using Type = DisplayKHR; - }; - - template <> - struct CppType - { - using Type = DisplayKHR; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = DisplayKHR; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainKHR.html - class SwapchainKHR - { - public: - using CType = VkSwapchainKHR; - using NativeType = VkSwapchainKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSwapchainKHR; - - public: - SwapchainKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - SwapchainKHR( SwapchainKHR const & rhs ) = default; - SwapchainKHR & operator=( SwapchainKHR const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - SwapchainKHR( SwapchainKHR && rhs ) = default; - SwapchainKHR & operator=( SwapchainKHR && rhs ) = default; -#else - SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( exchange( rhs.m_swapchainKHR, {} ) ) {} - - SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - m_swapchainKHR = exchange( rhs.m_swapchainKHR, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR SwapchainKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT SwapchainKHR( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT : m_swapchainKHR( swapchainKHR ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - SwapchainKHR & operator=( VkSwapchainKHR swapchainKHR ) VULKAN_HPP_NOEXCEPT - { - m_swapchainKHR = swapchainKHR; - return *this; - } -#endif - - SwapchainKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_swapchainKHR = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSwapchainKHR() const VULKAN_HPP_NOEXCEPT - { - return m_swapchainKHR; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_swapchainKHR != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_swapchainKHR == VK_NULL_HANDLE; - } - - private: - VkSwapchainKHR m_swapchainKHR = {}; - }; - - template <> - struct CppType - { - using Type = SwapchainKHR; - }; - - template <> - struct CppType - { - using Type = SwapchainKHR; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = SwapchainKHR; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphore.html - class Semaphore - { - public: - using CType = VkSemaphore; - using NativeType = VkSemaphore; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSemaphore; - - public: - Semaphore() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - Semaphore( Semaphore const & rhs ) = default; - Semaphore & operator=( Semaphore const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - Semaphore( Semaphore && rhs ) = default; - Semaphore & operator=( Semaphore && rhs ) = default; -#else - Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT : m_semaphore( exchange( rhs.m_semaphore, {} ) ) {} - - Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT - { - m_semaphore = exchange( rhs.m_semaphore, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR Semaphore( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Semaphore( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT : m_semaphore( semaphore ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - Semaphore & operator=( VkSemaphore semaphore ) VULKAN_HPP_NOEXCEPT - { - m_semaphore = semaphore; - return *this; - } -#endif - - Semaphore & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_semaphore = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSemaphore() const VULKAN_HPP_NOEXCEPT - { - return m_semaphore; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_semaphore != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_semaphore == VK_NULL_HANDLE; - } - - private: - VkSemaphore m_semaphore = {}; - }; - - template <> - struct CppType - { - using Type = Semaphore; - }; - - template <> - struct CppType - { - using Type = Semaphore; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Semaphore; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFence.html - class Fence - { - public: - using CType = VkFence; - using NativeType = VkFence; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFence; - - public: - Fence() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - Fence( Fence const & rhs ) = default; - Fence & operator=( Fence const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - Fence( Fence && rhs ) = default; - Fence & operator=( Fence && rhs ) = default; -#else - Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT : m_fence( exchange( rhs.m_fence, {} ) ) {} - - Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT - { - m_fence = exchange( rhs.m_fence, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR Fence( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Fence( VkFence fence ) VULKAN_HPP_NOEXCEPT : m_fence( fence ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - Fence & operator=( VkFence fence ) VULKAN_HPP_NOEXCEPT - { - m_fence = fence; - return *this; - } -#endif - - Fence & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_fence = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFence() const VULKAN_HPP_NOEXCEPT - { - return m_fence; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_fence != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_fence == VK_NULL_HANDLE; - } - - private: - VkFence m_fence = {}; - }; - - template <> - struct CppType - { - using Type = Fence; - }; - - template <> - struct CppType - { - using Type = Fence; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Fence; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationINTEL.html - class PerformanceConfigurationINTEL - { - public: - using CType = VkPerformanceConfigurationINTEL; - using NativeType = VkPerformanceConfigurationINTEL; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePerformanceConfigurationINTEL; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - PerformanceConfigurationINTEL() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & rhs ) = default; - PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) = default; - PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) = default; -#else - PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT - : m_performanceConfigurationINTEL( exchange( rhs.m_performanceConfigurationINTEL, {} ) ) - { - } - - PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT - { - m_performanceConfigurationINTEL = exchange( rhs.m_performanceConfigurationINTEL, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR PerformanceConfigurationINTEL( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT PerformanceConfigurationINTEL( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT - : m_performanceConfigurationINTEL( performanceConfigurationINTEL ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - PerformanceConfigurationINTEL & operator=( VkPerformanceConfigurationINTEL performanceConfigurationINTEL ) VULKAN_HPP_NOEXCEPT - { - m_performanceConfigurationINTEL = performanceConfigurationINTEL; - return *this; - } -#endif - - PerformanceConfigurationINTEL & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_performanceConfigurationINTEL = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT - { - return m_performanceConfigurationINTEL; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_performanceConfigurationINTEL != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_performanceConfigurationINTEL == VK_NULL_HANDLE; - } - - private: - VkPerformanceConfigurationINTEL m_performanceConfigurationINTEL = {}; - }; - - template <> - struct CppType - { - using Type = PerformanceConfigurationINTEL; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = PerformanceConfigurationINTEL; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPool.html - class QueryPool - { - public: - using CType = VkQueryPool; - using NativeType = VkQueryPool; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueryPool; - - public: - QueryPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - QueryPool( QueryPool const & rhs ) = default; - QueryPool & operator=( QueryPool const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - QueryPool( QueryPool && rhs ) = default; - QueryPool & operator=( QueryPool && rhs ) = default; -#else - QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT : m_queryPool( exchange( rhs.m_queryPool, {} ) ) {} - - QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT - { - m_queryPool = exchange( rhs.m_queryPool, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR QueryPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT QueryPool( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT : m_queryPool( queryPool ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - QueryPool & operator=( VkQueryPool queryPool ) VULKAN_HPP_NOEXCEPT - { - m_queryPool = queryPool; - return *this; - } -#endif - - QueryPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_queryPool = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkQueryPool() const VULKAN_HPP_NOEXCEPT - { - return m_queryPool; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_queryPool != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_queryPool == VK_NULL_HANDLE; - } - - private: - VkQueryPool m_queryPool = {}; - }; - - template <> - struct CppType - { - using Type = QueryPool; - }; - - template <> - struct CppType - { - using Type = QueryPool; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = QueryPool; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuffer.html - class Buffer - { - public: - using CType = VkBuffer; - using NativeType = VkBuffer; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBuffer; - - public: - Buffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - Buffer( Buffer const & rhs ) = default; - Buffer & operator=( Buffer const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - Buffer( Buffer && rhs ) = default; - Buffer & operator=( Buffer && rhs ) = default; -#else - Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT : m_buffer( exchange( rhs.m_buffer, {} ) ) {} - - Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT - { - m_buffer = exchange( rhs.m_buffer, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR Buffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Buffer( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT : m_buffer( buffer ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - Buffer & operator=( VkBuffer buffer ) VULKAN_HPP_NOEXCEPT - { - m_buffer = buffer; - return *this; - } -#endif - - Buffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_buffer = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBuffer() const VULKAN_HPP_NOEXCEPT - { - return m_buffer; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_buffer != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_buffer == VK_NULL_HANDLE; - } - - private: - VkBuffer m_buffer = {}; - }; - - template <> - struct CppType - { - using Type = Buffer; - }; - - template <> - struct CppType - { - using Type = Buffer; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Buffer; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayout.html - class PipelineLayout - { - public: - using CType = VkPipelineLayout; - using NativeType = VkPipelineLayout; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineLayout; - - public: - PipelineLayout() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - PipelineLayout( PipelineLayout const & rhs ) = default; - PipelineLayout & operator=( PipelineLayout const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - PipelineLayout( PipelineLayout && rhs ) = default; - PipelineLayout & operator=( PipelineLayout && rhs ) = default; -#else - PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( exchange( rhs.m_pipelineLayout, {} ) ) {} - - PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT - { - m_pipelineLayout = exchange( rhs.m_pipelineLayout, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR PipelineLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT PipelineLayout( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT : m_pipelineLayout( pipelineLayout ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - PipelineLayout & operator=( VkPipelineLayout pipelineLayout ) VULKAN_HPP_NOEXCEPT - { - m_pipelineLayout = pipelineLayout; - return *this; - } -#endif - - PipelineLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_pipelineLayout = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineLayout() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineLayout; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineLayout != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineLayout == VK_NULL_HANDLE; - } - - private: - VkPipelineLayout m_pipelineLayout = {}; - }; - - template <> - struct CppType - { - using Type = PipelineLayout; - }; - - template <> - struct CppType - { - using Type = PipelineLayout; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = PipelineLayout; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSet.html - class DescriptorSet - { - public: - using CType = VkDescriptorSet; - using NativeType = VkDescriptorSet; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSet; - - public: - DescriptorSet() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - DescriptorSet( DescriptorSet const & rhs ) = default; - DescriptorSet & operator=( DescriptorSet const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - DescriptorSet( DescriptorSet && rhs ) = default; - DescriptorSet & operator=( DescriptorSet && rhs ) = default; -#else - DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( exchange( rhs.m_descriptorSet, {} ) ) {} - - DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT - { - m_descriptorSet = exchange( rhs.m_descriptorSet, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR DescriptorSet( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSet( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT : m_descriptorSet( descriptorSet ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - DescriptorSet & operator=( VkDescriptorSet descriptorSet ) VULKAN_HPP_NOEXCEPT - { - m_descriptorSet = descriptorSet; - return *this; - } -#endif - - DescriptorSet & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_descriptorSet = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSet() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorSet; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorSet != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorSet == VK_NULL_HANDLE; - } - - private: - VkDescriptorSet m_descriptorSet = {}; - }; - - template <> - struct CppType - { - using Type = DescriptorSet; - }; - - template <> - struct CppType - { - using Type = DescriptorSet; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = DescriptorSet; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageView.html - class ImageView - { - public: - using CType = VkImageView; - using NativeType = VkImageView; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImageView; - - public: - ImageView() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - ImageView( ImageView const & rhs ) = default; - ImageView & operator=( ImageView const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - ImageView( ImageView && rhs ) = default; - ImageView & operator=( ImageView && rhs ) = default; -#else - ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT : m_imageView( exchange( rhs.m_imageView, {} ) ) {} - - ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT - { - m_imageView = exchange( rhs.m_imageView, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR ImageView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ImageView( VkImageView imageView ) VULKAN_HPP_NOEXCEPT : m_imageView( imageView ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - ImageView & operator=( VkImageView imageView ) VULKAN_HPP_NOEXCEPT - { - m_imageView = imageView; - return *this; - } -#endif - - ImageView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_imageView = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImageView() const VULKAN_HPP_NOEXCEPT - { - return m_imageView; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_imageView != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_imageView == VK_NULL_HANDLE; - } - - private: - VkImageView m_imageView = {}; - }; - - template <> - struct CppType - { - using Type = ImageView; - }; - - template <> - struct CppType - { - using Type = ImageView; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = ImageView; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipeline.html - class Pipeline - { - public: - using CType = VkPipeline; - using NativeType = VkPipeline; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipeline; - - public: - Pipeline() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - Pipeline( Pipeline const & rhs ) = default; - Pipeline & operator=( Pipeline const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - Pipeline( Pipeline && rhs ) = default; - Pipeline & operator=( Pipeline && rhs ) = default; -#else - Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT : m_pipeline( exchange( rhs.m_pipeline, {} ) ) {} - - Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT - { - m_pipeline = exchange( rhs.m_pipeline, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR Pipeline( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Pipeline( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT : m_pipeline( pipeline ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - Pipeline & operator=( VkPipeline pipeline ) VULKAN_HPP_NOEXCEPT - { - m_pipeline = pipeline; - return *this; - } -#endif - - Pipeline & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_pipeline = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipeline() const VULKAN_HPP_NOEXCEPT - { - return m_pipeline; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_pipeline != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_pipeline == VK_NULL_HANDLE; - } - - private: - VkPipeline m_pipeline = {}; - }; - - template <> - struct CppType - { - using Type = Pipeline; - }; - - template <> - struct CppType - { - using Type = Pipeline; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Pipeline; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderEXT.html - class ShaderEXT - { - public: - using CType = VkShaderEXT; - using NativeType = VkShaderEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - ShaderEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - ShaderEXT( ShaderEXT const & rhs ) = default; - ShaderEXT & operator=( ShaderEXT const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - ShaderEXT( ShaderEXT && rhs ) = default; - ShaderEXT & operator=( ShaderEXT && rhs ) = default; -#else - ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( exchange( rhs.m_shaderEXT, {} ) ) {} - - ShaderEXT & operator=( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - m_shaderEXT = exchange( rhs.m_shaderEXT, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( shaderEXT ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - ShaderEXT & operator=( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT - { - m_shaderEXT = shaderEXT; - return *this; - } -#endif - - ShaderEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_shaderEXT = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT - { - return m_shaderEXT; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_shaderEXT != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_shaderEXT == VK_NULL_HANDLE; - } - - private: - VkShaderEXT m_shaderEXT = {}; - }; - - template <> - struct CppType - { - using Type = ShaderEXT; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = ShaderEXT; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImage.html - class Image - { - public: - using CType = VkImage; - using NativeType = VkImage; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImage; - - public: - Image() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - Image( Image const & rhs ) = default; - Image & operator=( Image const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - Image( Image && rhs ) = default; - Image & operator=( Image && rhs ) = default; -#else - Image( Image && rhs ) VULKAN_HPP_NOEXCEPT : m_image( exchange( rhs.m_image, {} ) ) {} - - Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT - { - m_image = exchange( rhs.m_image, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR Image( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Image( VkImage image ) VULKAN_HPP_NOEXCEPT : m_image( image ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - Image & operator=( VkImage image ) VULKAN_HPP_NOEXCEPT - { - m_image = image; - return *this; - } -#endif - - Image & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_image = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkImage() const VULKAN_HPP_NOEXCEPT - { - return m_image; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_image != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_image == VK_NULL_HANDLE; - } - - private: - VkImage m_image = {}; - }; - - template <> - struct CppType - { - using Type = Image; - }; - - template <> - struct CppType - { - using Type = Image; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Image; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureNV.html - class AccelerationStructureNV - { - public: - using CType = VkAccelerationStructureNV; - using NativeType = VkAccelerationStructureNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureNV; - - public: - AccelerationStructureNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - AccelerationStructureNV( AccelerationStructureNV const & rhs ) = default; - AccelerationStructureNV & operator=( AccelerationStructureNV const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - AccelerationStructureNV( AccelerationStructureNV && rhs ) = default; - AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) = default; -#else - AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT : m_accelerationStructureNV( exchange( rhs.m_accelerationStructureNV, {} ) ) - { - } - - AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT - { - m_accelerationStructureNV = exchange( rhs.m_accelerationStructureNV, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR AccelerationStructureNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureNV( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT - : m_accelerationStructureNV( accelerationStructureNV ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - AccelerationStructureNV & operator=( VkAccelerationStructureNV accelerationStructureNV ) VULKAN_HPP_NOEXCEPT - { - m_accelerationStructureNV = accelerationStructureNV; - return *this; - } -#endif - - AccelerationStructureNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_accelerationStructureNV = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureNV() const VULKAN_HPP_NOEXCEPT - { - return m_accelerationStructureNV; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_accelerationStructureNV != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_accelerationStructureNV == VK_NULL_HANDLE; - } - - private: - VkAccelerationStructureNV m_accelerationStructureNV = {}; - }; - - template <> - struct CppType - { - using Type = AccelerationStructureNV; - }; - - template <> - struct CppType - { - using Type = AccelerationStructureNV; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = AccelerationStructureNV; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDataGraphPipelineSessionARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionARM.html - class DataGraphPipelineSessionARM - { - public: - using CType = VkDataGraphPipelineSessionARM; - using NativeType = VkDataGraphPipelineSessionARM; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDataGraphPipelineSessionARM; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - DataGraphPipelineSessionARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - DataGraphPipelineSessionARM( DataGraphPipelineSessionARM const & rhs ) = default; - DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - DataGraphPipelineSessionARM( DataGraphPipelineSessionARM && rhs ) = default; - DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM && rhs ) = default; -#else - DataGraphPipelineSessionARM( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT - : m_dataGraphPipelineSessionARM( exchange( rhs.m_dataGraphPipelineSessionARM, {} ) ) - { - } - - DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT - { - m_dataGraphPipelineSessionARM = exchange( rhs.m_dataGraphPipelineSessionARM, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DataGraphPipelineSessionARM( VkDataGraphPipelineSessionARM dataGraphPipelineSessionARM ) VULKAN_HPP_NOEXCEPT - : m_dataGraphPipelineSessionARM( dataGraphPipelineSessionARM ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - DataGraphPipelineSessionARM & operator=( VkDataGraphPipelineSessionARM dataGraphPipelineSessionARM ) VULKAN_HPP_NOEXCEPT - { - m_dataGraphPipelineSessionARM = dataGraphPipelineSessionARM; - return *this; - } -#endif - - DataGraphPipelineSessionARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_dataGraphPipelineSessionARM = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDataGraphPipelineSessionARM() const VULKAN_HPP_NOEXCEPT - { - return m_dataGraphPipelineSessionARM; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_dataGraphPipelineSessionARM != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_dataGraphPipelineSessionARM == VK_NULL_HANDLE; - } - - private: - VkDataGraphPipelineSessionARM m_dataGraphPipelineSessionARM = {}; - }; - - template <> - struct CppType - { - using Type = DataGraphPipelineSessionARM; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = DataGraphPipelineSessionARM; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionNV.html - class OpticalFlowSessionNV - { - public: - using CType = VkOpticalFlowSessionNV; - using NativeType = VkOpticalFlowSessionNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eOpticalFlowSessionNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - OpticalFlowSessionNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - OpticalFlowSessionNV( OpticalFlowSessionNV const & rhs ) = default; - OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) = default; - OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) = default; -#else - OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_opticalFlowSessionNV( exchange( rhs.m_opticalFlowSessionNV, {} ) ) {} - - OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT - { - m_opticalFlowSessionNV = exchange( rhs.m_opticalFlowSessionNV, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR OpticalFlowSessionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT OpticalFlowSessionNV( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT - : m_opticalFlowSessionNV( opticalFlowSessionNV ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - OpticalFlowSessionNV & operator=( VkOpticalFlowSessionNV opticalFlowSessionNV ) VULKAN_HPP_NOEXCEPT - { - m_opticalFlowSessionNV = opticalFlowSessionNV; - return *this; - } -#endif - - OpticalFlowSessionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_opticalFlowSessionNV = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkOpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT - { - return m_opticalFlowSessionNV; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_opticalFlowSessionNV != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_opticalFlowSessionNV == VK_NULL_HANDLE; - } - - private: - VkOpticalFlowSessionNV m_opticalFlowSessionNV = {}; - }; - - template <> - struct CppType - { - using Type = OpticalFlowSessionNV; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = OpticalFlowSessionNV; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplate.html - class DescriptorUpdateTemplate - { - public: - using CType = VkDescriptorUpdateTemplate; - using NativeType = VkDescriptorUpdateTemplate; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorUpdateTemplate; - - public: - DescriptorUpdateTemplate() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - DescriptorUpdateTemplate( DescriptorUpdateTemplate const & rhs ) = default; - DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) = default; - DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) = default; -#else - DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT - : m_descriptorUpdateTemplate( exchange( rhs.m_descriptorUpdateTemplate, {} ) ) - { - } - - DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT - { - m_descriptorUpdateTemplate = exchange( rhs.m_descriptorUpdateTemplate, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplate( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorUpdateTemplate( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT - : m_descriptorUpdateTemplate( descriptorUpdateTemplate ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - DescriptorUpdateTemplate & operator=( VkDescriptorUpdateTemplate descriptorUpdateTemplate ) VULKAN_HPP_NOEXCEPT - { - m_descriptorUpdateTemplate = descriptorUpdateTemplate; - return *this; - } -#endif - - DescriptorUpdateTemplate & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_descriptorUpdateTemplate = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorUpdateTemplate; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorUpdateTemplate != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorUpdateTemplate == VK_NULL_HANDLE; - } - - private: - VkDescriptorUpdateTemplate m_descriptorUpdateTemplate = {}; - }; - - template <> - struct CppType - { - using Type = DescriptorUpdateTemplate; - }; - - template <> - struct CppType - { - using Type = DescriptorUpdateTemplate; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = DescriptorUpdateTemplate; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; - - // wrapper class for handle VkEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEvent.html - class Event - { - public: - using CType = VkEvent; - using NativeType = VkEvent; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eEvent; - - public: - Event() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - Event( Event const & rhs ) = default; - Event & operator=( Event const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - Event( Event && rhs ) = default; - Event & operator=( Event && rhs ) = default; -#else - Event( Event && rhs ) VULKAN_HPP_NOEXCEPT : m_event( exchange( rhs.m_event, {} ) ) {} - - Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT - { - m_event = exchange( rhs.m_event, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR Event( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Event( VkEvent event ) VULKAN_HPP_NOEXCEPT : m_event( event ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - Event & operator=( VkEvent event ) VULKAN_HPP_NOEXCEPT - { - m_event = event; - return *this; - } -#endif - - Event & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_event = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkEvent() const VULKAN_HPP_NOEXCEPT - { - return m_event; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_event != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_event == VK_NULL_HANDLE; - } - - private: - VkEvent m_event = {}; - }; - - template <> - struct CppType - { - using Type = Event; - }; - - template <> - struct CppType - { - using Type = Event; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Event; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureKHR.html - class AccelerationStructureKHR - { - public: - using CType = VkAccelerationStructureKHR; - using NativeType = VkAccelerationStructureKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureKHR; - - public: - AccelerationStructureKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - AccelerationStructureKHR( AccelerationStructureKHR const & rhs ) = default; - AccelerationStructureKHR & operator=( AccelerationStructureKHR const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - AccelerationStructureKHR( AccelerationStructureKHR && rhs ) = default; - AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) = default; -#else - AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_accelerationStructureKHR( exchange( rhs.m_accelerationStructureKHR, {} ) ) - { - } - - AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - m_accelerationStructureKHR = exchange( rhs.m_accelerationStructureKHR, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR AccelerationStructureKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT AccelerationStructureKHR( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT - : m_accelerationStructureKHR( accelerationStructureKHR ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - AccelerationStructureKHR & operator=( VkAccelerationStructureKHR accelerationStructureKHR ) VULKAN_HPP_NOEXCEPT - { - m_accelerationStructureKHR = accelerationStructureKHR; - return *this; - } -#endif - - AccelerationStructureKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_accelerationStructureKHR = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkAccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT - { - return m_accelerationStructureKHR; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_accelerationStructureKHR != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_accelerationStructureKHR == VK_NULL_HANDLE; - } - - private: - VkAccelerationStructureKHR m_accelerationStructureKHR = {}; - }; - - template <> - struct CppType - { - using Type = AccelerationStructureKHR; - }; - - template <> - struct CppType - { - using Type = AccelerationStructureKHR; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = AccelerationStructureKHR; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapEXT.html - class MicromapEXT - { - public: - using CType = VkMicromapEXT; - using NativeType = VkMicromapEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eMicromapEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - MicromapEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - MicromapEXT( MicromapEXT const & rhs ) = default; - MicromapEXT & operator=( MicromapEXT const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - MicromapEXT( MicromapEXT && rhs ) = default; - MicromapEXT & operator=( MicromapEXT && rhs ) = default; -#else - MicromapEXT( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( exchange( rhs.m_micromapEXT, {} ) ) {} - - MicromapEXT & operator=( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - m_micromapEXT = exchange( rhs.m_micromapEXT, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR MicromapEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT MicromapEXT( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT : m_micromapEXT( micromapEXT ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - MicromapEXT & operator=( VkMicromapEXT micromapEXT ) VULKAN_HPP_NOEXCEPT - { - m_micromapEXT = micromapEXT; - return *this; - } -#endif - - MicromapEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_micromapEXT = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkMicromapEXT() const VULKAN_HPP_NOEXCEPT - { - return m_micromapEXT; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_micromapEXT != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_micromapEXT == VK_NULL_HANDLE; - } - - private: - VkMicromapEXT m_micromapEXT = {}; - }; - - template <> - struct CppType - { - using Type = MicromapEXT; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = MicromapEXT; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBuffer.html - class CommandBuffer - { - public: - using CType = VkCommandBuffer; - using NativeType = VkCommandBuffer; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandBuffer; - - public: - CommandBuffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - CommandBuffer( CommandBuffer const & rhs ) = default; - CommandBuffer & operator=( CommandBuffer const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - CommandBuffer( CommandBuffer && rhs ) = default; - CommandBuffer & operator=( CommandBuffer && rhs ) = default; -#else - CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( exchange( rhs.m_commandBuffer, {} ) ) {} - - CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT - { - m_commandBuffer = exchange( rhs.m_commandBuffer, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR CommandBuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - CommandBuffer( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT : m_commandBuffer( commandBuffer ) {} - - CommandBuffer & operator=( VkCommandBuffer commandBuffer ) VULKAN_HPP_NOEXCEPT - { - m_commandBuffer = commandBuffer; - return *this; - } - - CommandBuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_commandBuffer = {}; - return *this; - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD Result begin( const CommandBufferBeginInfo * pBeginInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type begin( const CommandBufferBeginInfo & beginInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD Result end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type end( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD Result reset( CommandBufferResetFlags flags, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type reset( CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html - template ::type = true> - void copyBuffer( Buffer srcBuffer, - Buffer dstBuffer, - uint32_t regionCount, - const BufferCopy * pRegions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html - template ::type = true> - void copyBuffer( Buffer srcBuffer, - Buffer dstBuffer, - ArrayProxy const & regions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html - template ::type = true> - void copyImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - uint32_t regionCount, - const ImageCopy * pRegions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html - template ::type = true> - void copyImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html - template ::type = true> - void copyBufferToImage( Buffer srcBuffer, - Image dstImage, - ImageLayout dstImageLayout, - uint32_t regionCount, - const BufferImageCopy * pRegions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html - template ::type = true> - void copyBufferToImage( Buffer srcBuffer, - Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html - template ::type = true> - void copyImageToBuffer( Image srcImage, - ImageLayout srcImageLayout, - Buffer dstBuffer, - uint32_t regionCount, - const BufferImageCopy * pRegions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html - template ::type = true> - void copyImageToBuffer( Image srcImage, - ImageLayout srcImageLayout, - Buffer dstBuffer, - ArrayProxy const & regions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html - template ::type = true> - void updateBuffer( Buffer dstBuffer, - DeviceSize dstOffset, - DeviceSize dataSize, - const void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html - template ::type = true> - void updateBuffer( Buffer dstBuffer, - DeviceSize dstOffset, - ArrayProxy const & data, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html - template ::type = true> - void fillBuffer( Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const - VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html - template ::type = true> - void pipelineBarrier( PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - DependencyFlags dependencyFlags, - uint32_t memoryBarrierCount, - const MemoryBarrier * pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const BufferMemoryBarrier * pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const ImageMemoryBarrier * pImageMemoryBarriers, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html - template ::type = true> - void pipelineBarrier( PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - DependencyFlags dependencyFlags, - ArrayProxy const & memoryBarriers, - ArrayProxy const & bufferMemoryBarriers, - ArrayProxy const & imageMemoryBarriers, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html - template ::type = true> - void beginQuery( QueryPool queryPool, - uint32_t query, - QueryControlFlags flags, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html - template ::type = true> - void endQuery( QueryPool queryPool, uint32_t query, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html - template ::type = true> - void resetQueryPool( QueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html - template ::type = true> - void writeTimestamp( PipelineStageFlagBits pipelineStage, - QueryPool queryPool, - uint32_t query, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html - template ::type = true> - void copyQueryPoolResults( QueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - Buffer dstBuffer, - DeviceSize dstOffset, - DeviceSize stride, - QueryResultFlags flags, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html - template ::type = true> - void executeCommands( uint32_t commandBufferCount, - const CommandBuffer * pCommandBuffers, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html - template ::type = true> - void executeCommands( ArrayProxy const & commandBuffers, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html - template ::type = true> - void bindPipeline( PipelineBindPoint pipelineBindPoint, - Pipeline pipeline, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html - template ::type = true> - void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t firstSet, - uint32_t descriptorSetCount, - const DescriptorSet * pDescriptorSets, - uint32_t dynamicOffsetCount, - const uint32_t * pDynamicOffsets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html - template ::type = true> - void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t firstSet, - ArrayProxy const & descriptorSets, - ArrayProxy const & dynamicOffsets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html - template ::type = true> - void clearColorImage( Image image, - ImageLayout imageLayout, - const ClearColorValue * pColor, - uint32_t rangeCount, - const ImageSubresourceRange * pRanges, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html - template ::type = true> - void clearColorImage( Image image, - ImageLayout imageLayout, - const ClearColorValue & color, - ArrayProxy const & ranges, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html - template ::type = true> - void dispatch( uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html - template ::type = true> - void dispatchIndirect( Buffer buffer, DeviceSize offset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html - template ::type = true> - void setEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html - template ::type = true> - void resetEvent( Event event, PipelineStageFlags stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html - template ::type = true> - void waitEvents( uint32_t eventCount, - const Event * pEvents, - PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const MemoryBarrier * pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const BufferMemoryBarrier * pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const ImageMemoryBarrier * pImageMemoryBarriers, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html - template ::type = true> - void waitEvents( ArrayProxy const & events, - PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - ArrayProxy const & memoryBarriers, - ArrayProxy const & bufferMemoryBarriers, - ArrayProxy const & imageMemoryBarriers, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html - template ::type = true> - void pushConstants( PipelineLayout layout, - ShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void * pValues, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html - template ::type = true> - void pushConstants( PipelineLayout layout, - ShaderStageFlags stageFlags, - uint32_t offset, - ArrayProxy const & values, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html - template ::type = true> - void setViewport( uint32_t firstViewport, - uint32_t viewportCount, - const Viewport * pViewports, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html - template ::type = true> - void setViewport( uint32_t firstViewport, - ArrayProxy const & viewports, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html - template ::type = true> - void setScissor( uint32_t firstScissor, - uint32_t scissorCount, - const Rect2D * pScissors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html - template ::type = true> - void setScissor( uint32_t firstScissor, - ArrayProxy const & scissors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html - template ::type = true> - void setLineWidth( float lineWidth, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html - template ::type = true> - void setDepthBias( float depthBiasConstantFactor, - float depthBiasClamp, - float depthBiasSlopeFactor, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html - template ::type = true> - void setBlendConstants( const float blendConstants[4], Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html - template ::type = true> - void setDepthBounds( float minDepthBounds, float maxDepthBounds, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html - template ::type = true> - void setStencilCompareMask( StencilFaceFlags faceMask, - uint32_t compareMask, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html - template ::type = true> - void setStencilWriteMask( StencilFaceFlags faceMask, - uint32_t writeMask, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html - template ::type = true> - void setStencilReference( StencilFaceFlags faceMask, - uint32_t reference, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html - template ::type = true> - void bindIndexBuffer( Buffer buffer, - DeviceSize offset, - IndexType indexType, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html - template ::type = true> - void bindVertexBuffers( uint32_t firstBinding, - uint32_t bindingCount, - const Buffer * pBuffers, - const DeviceSize * pOffsets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html - template ::type = true> - void bindVertexBuffers( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html - template ::type = true> - void draw( uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html - template ::type = true> - void drawIndexed( uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html - template ::type = true> - void drawIndirect( Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) - const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html - template ::type = true> - void drawIndexedIndirect( Buffer buffer, - DeviceSize offset, - uint32_t drawCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html - template ::type = true> - void blitImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - uint32_t regionCount, - const ImageBlit * pRegions, - Filter filter, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html - template ::type = true> - void blitImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions, - Filter filter, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html - template ::type = true> - void clearDepthStencilImage( Image image, - ImageLayout imageLayout, - const ClearDepthStencilValue * pDepthStencil, - uint32_t rangeCount, - const ImageSubresourceRange * pRanges, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html - template ::type = true> - void clearDepthStencilImage( Image image, - ImageLayout imageLayout, - const ClearDepthStencilValue & depthStencil, - ArrayProxy const & ranges, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html - template ::type = true> - void clearAttachments( uint32_t attachmentCount, - const ClearAttachment * pAttachments, - uint32_t rectCount, - const ClearRect * pRects, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html - template ::type = true> - void clearAttachments( ArrayProxy const & attachments, - ArrayProxy const & rects, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html - template ::type = true> - void resolveImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - uint32_t regionCount, - const ImageResolve * pRegions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html - template ::type = true> - void resolveImage( Image srcImage, - ImageLayout srcImageLayout, - Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html - template ::type = true> - void beginRenderPass( const RenderPassBeginInfo * pRenderPassBegin, - SubpassContents contents, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html - template ::type = true> - void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, - SubpassContents contents, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html - template ::type = true> - void nextSubpass( SubpassContents contents, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html - template ::type = true> - void endRenderPass( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html - template ::type = true> - void setDeviceMask( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html - template ::type = true> - void dispatchBase( uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_VERSION_1_2 === - - // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html - template ::type = true> - void drawIndirectCount( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndexedIndirectCount, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html - template ::type = true> - void drawIndexedIndirectCount( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html - template ::type = true> - void beginRenderPass2( const RenderPassBeginInfo * pRenderPassBegin, - const SubpassBeginInfo * pSubpassBeginInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html - template ::type = true> - void beginRenderPass2( const RenderPassBeginInfo & renderPassBegin, - const SubpassBeginInfo & subpassBeginInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html - template ::type = true> - void nextSubpass2( const SubpassBeginInfo * pSubpassBeginInfo, - const SubpassEndInfo * pSubpassEndInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html - template ::type = true> - void nextSubpass2( const SubpassBeginInfo & subpassBeginInfo, - const SubpassEndInfo & subpassEndInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html - template ::type = true> - void endRenderPass2( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html - template ::type = true> - void endRenderPass2( const SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_3 === - - // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html - template ::type = true> - void pipelineBarrier2( const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html - template ::type = true> - void pipelineBarrier2( const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html - template ::type = true> - void writeTimestamp2( PipelineStageFlags2 stage, - QueryPool queryPool, - uint32_t query, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html - template ::type = true> - void copyBuffer2( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html - template ::type = true> - void copyBuffer2( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html - template ::type = true> - void copyImage2( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html - template ::type = true> - void copyImage2( const CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html - template ::type = true> - void copyBufferToImage2( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html - template ::type = true> - void copyBufferToImage2( const CopyBufferToImageInfo2 & copyBufferToImageInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html - template ::type = true> - void copyImageToBuffer2( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html - template ::type = true> - void copyImageToBuffer2( const CopyImageToBufferInfo2 & copyImageToBufferInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html - template ::type = true> - void - setEvent2( Event event, const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html - template ::type = true> - void setEvent2( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html - template ::type = true> - void resetEvent2( Event event, PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html - template ::type = true> - void waitEvents2( uint32_t eventCount, - const Event * pEvents, - const DependencyInfo * pDependencyInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html - template ::type = true> - void waitEvents2( ArrayProxy const & events, - ArrayProxy const & dependencyInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html - template ::type = true> - void blitImage2( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html - template ::type = true> - void blitImage2( const BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html - template ::type = true> - void resolveImage2( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html - template ::type = true> - void resolveImage2( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html - template ::type = true> - void beginRendering( const RenderingInfo * pRenderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html - template ::type = true> - void beginRendering( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html - template ::type = true> - void endRendering( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html - template ::type = true> - void setCullMode( CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html - template ::type = true> - void setFrontFace( FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html - template ::type = true> - void setPrimitiveTopology( PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html - template ::type = true> - void setViewportWithCount( uint32_t viewportCount, - const Viewport * pViewports, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html - template ::type = true> - void setViewportWithCount( ArrayProxy const & viewports, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html - template ::type = true> - void setScissorWithCount( uint32_t scissorCount, - const Rect2D * pScissors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html - template ::type = true> - void setScissorWithCount( ArrayProxy const & scissors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html - template ::type = true> - void bindVertexBuffers2( uint32_t firstBinding, - uint32_t bindingCount, - const Buffer * pBuffers, - const DeviceSize * pOffsets, - const DeviceSize * pSizes, - const DeviceSize * pStrides, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html - template ::type = true> - void bindVertexBuffers2( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - ArrayProxy const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html - template ::type = true> - void setDepthTestEnable( Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html - template ::type = true> - void setDepthWriteEnable( Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html - template ::type = true> - void setDepthCompareOp( CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBoundsTestEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html - template ::type = true> - void setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html - template ::type = true> - void setStencilTestEnable( Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html - template ::type = true> - void setStencilOp( StencilFaceFlags faceMask, - StencilOp failOp, - StencilOp passOp, - StencilOp depthFailOp, - CompareOp compareOp, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRasterizerDiscardEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html - template ::type = true> - void setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html - template ::type = true> - void setDepthBiasEnable( Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetPrimitiveRestartEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html - template ::type = true> - void setPrimitiveRestartEnable( Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_VERSION_1_4 === - - // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html - template ::type = true> - void pushDescriptorSet( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const WriteDescriptorSet * pDescriptorWrites, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html - template ::type = true> - void pushDescriptorSet( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t set, - ArrayProxy const & descriptorWrites, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html - template ::type = true> - void pushDescriptorSetWithTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, - PipelineLayout layout, - uint32_t set, - const void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html - template ::type = true> - void pushDescriptorSetWithTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, - PipelineLayout layout, - uint32_t set, - DataType const & data, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html - template ::type = true> - void bindDescriptorSets2( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html - template ::type = true> - void bindDescriptorSets2( const BindDescriptorSetsInfo & bindDescriptorSetsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html - template ::type = true> - void pushConstants2( const PushConstantsInfo * pPushConstantsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html - template ::type = true> - void pushConstants2( const PushConstantsInfo & pushConstantsInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html - template ::type = true> - void pushDescriptorSet2( const PushDescriptorSetInfo * pPushDescriptorSetInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html - template ::type = true> - void pushDescriptorSet2( const PushDescriptorSetInfo & pushDescriptorSetInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html - template ::type = true> - void pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html - template ::type = true> - void pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html - template ::type = true> - void setLineStipple( uint32_t lineStippleFactor, - uint16_t lineStipplePattern, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html - template ::type = true> - void bindIndexBuffer2( Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) - const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRenderingAttachmentLocations, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html - template ::type = true> - void setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo * pLocationInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetRenderingAttachmentLocations, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html - template ::type = true> - void setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo & locationInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html - template ::type = true> - void setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html - template ::type = true> - void setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_debug_marker === - - // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html - template ::type = true> - void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html - template ::type = true> - void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html - template ::type = true> - void debugMarkerEndEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html - template ::type = true> - void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT * pMarkerInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html - template ::type = true> - void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_video_queue === - - // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html - template ::type = true> - void beginVideoCodingKHR( const VideoBeginCodingInfoKHR * pBeginInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html - template ::type = true> - void beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html - template ::type = true> - void endVideoCodingKHR( const VideoEndCodingInfoKHR * pEndCodingInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html - template ::type = true> - void endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html - template ::type = true> - void controlVideoCodingKHR( const VideoCodingControlInfoKHR * pCodingControlInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html - template ::type = true> - void controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_video_decode_queue === - - // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html - template ::type = true> - void decodeVideoKHR( const VideoDecodeInfoKHR * pDecodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html - template ::type = true> - void decodeVideoKHR( const VideoDecodeInfoKHR & decodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_transform_feedback === - - // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html - template ::type = true> - void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, - uint32_t bindingCount, - const Buffer * pBuffers, - const DeviceSize * pOffsets, - const DeviceSize * pSizes, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html - template ::type = true> - void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginTransformFeedbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html - template ::type = true> - void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const Buffer * pCounterBuffers, - const DeviceSize * pCounterBufferOffsets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginTransformFeedbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html - template ::type = true> - void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, - ArrayProxy const & counterBuffers, - ArrayProxy const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndTransformFeedbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html - template ::type = true> - void endTransformFeedbackEXT( uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const Buffer * pCounterBuffers, - const DeviceSize * pCounterBufferOffsets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndTransformFeedbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html - template ::type = true> - void endTransformFeedbackEXT( uint32_t firstCounterBuffer, - ArrayProxy const & counterBuffers, - ArrayProxy const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html - template ::type = true> - void beginQueryIndexedEXT( QueryPool queryPool, - uint32_t query, - QueryControlFlags flags, - uint32_t index, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html - template ::type = true> - void endQueryIndexedEXT( QueryPool queryPool, - uint32_t query, - uint32_t index, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndirectByteCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html - template ::type = true> - void drawIndirectByteCountEXT( uint32_t instanceCount, - uint32_t firstInstance, - Buffer counterBuffer, - DeviceSize counterBufferOffset, - uint32_t counterOffset, - uint32_t vertexStride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NVX_binary_import === - - // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html - template ::type = true> - void cuLaunchKernelNVX( const CuLaunchInfoNVX * pLaunchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html - template ::type = true> - void cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_AMD_draw_indirect_count === - - // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html - template ::type = true> - void drawIndirectCountAMD( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html - template ::type = true> - void drawIndexedIndirectCountAMD( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_dynamic_rendering === - - // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html - template ::type = true> - void beginRenderingKHR( const RenderingInfo * pRenderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html - template ::type = true> - void beginRenderingKHR( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html - template ::type = true> - void endRenderingKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_device_group === - - // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html - template ::type = true> - void setDeviceMaskKHR( uint32_t deviceMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html - template ::type = true> - void dispatchBaseKHR( uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_push_descriptor === - - // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html - template ::type = true> - void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const WriteDescriptorSet * pDescriptorWrites, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html - template ::type = true> - void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t set, - ArrayProxy const & descriptorWrites, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html - template ::type = true> - void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, - PipelineLayout layout, - uint32_t set, - const void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html - template ::type = true> - void pushDescriptorSetWithTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, - PipelineLayout layout, - uint32_t set, - DataType const & data, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_conditional_rendering === - - // wrapper function for command vkCmdBeginConditionalRenderingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html - template ::type = true> - void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT * pConditionalRenderingBegin, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginConditionalRenderingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html - template ::type = true> - void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndConditionalRenderingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html - template ::type = true> - void endConditionalRenderingEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_clip_space_w_scaling === - - // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html - template ::type = true> - void setViewportWScalingNV( uint32_t firstViewport, - uint32_t viewportCount, - const ViewportWScalingNV * pViewportWScalings, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html - template ::type = true> - void setViewportWScalingNV( uint32_t firstViewport, - ArrayProxy const & viewportWScalings, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_discard_rectangles === - - // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html - template ::type = true> - void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, - uint32_t discardRectangleCount, - const Rect2D * pDiscardRectangles, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html - template ::type = true> - void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, - ArrayProxy const & discardRectangles, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html - template ::type = true> - void setDiscardRectangleEnableEXT( Bool32 discardRectangleEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html - template ::type = true> - void setDiscardRectangleModeEXT( DiscardRectangleModeEXT discardRectangleMode, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_create_renderpass2 === - - // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html - template ::type = true> - void beginRenderPass2KHR( const RenderPassBeginInfo * pRenderPassBegin, - const SubpassBeginInfo * pSubpassBeginInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html - template ::type = true> - void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, - const SubpassBeginInfo & subpassBeginInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html - template ::type = true> - void nextSubpass2KHR( const SubpassBeginInfo * pSubpassBeginInfo, - const SubpassEndInfo * pSubpassEndInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html - template ::type = true> - void nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo, - const SubpassEndInfo & subpassEndInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html - template ::type = true> - void endRenderPass2KHR( const SubpassEndInfo * pSubpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html - template ::type = true> - void endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_debug_utils === - - // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html - template ::type = true> - void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html - template ::type = true> - void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html - template ::type = true> - void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html - template ::type = true> - void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html - template ::type = true> - void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - - // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html - template ::type = true> - void initializeGraphScratchMemoryAMDX( Pipeline executionGraph, - DeviceAddress scratch, - DeviceSize scratchSize, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html - template ::type = true> - void dispatchGraphAMDX( DeviceAddress scratch, - DeviceSize scratchSize, - const DispatchGraphCountInfoAMDX * pCountInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html - template ::type = true> - void dispatchGraphAMDX( DeviceAddress scratch, - DeviceSize scratchSize, - const DispatchGraphCountInfoAMDX & countInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html - template ::type = true> - void dispatchGraphIndirectAMDX( DeviceAddress scratch, - DeviceSize scratchSize, - const DispatchGraphCountInfoAMDX * pCountInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html - template ::type = true> - void dispatchGraphIndirectAMDX( DeviceAddress scratch, - DeviceSize scratchSize, - const DispatchGraphCountInfoAMDX & countInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html - template ::type = true> - void dispatchGraphIndirectCountAMDX( DeviceAddress scratch, - DeviceSize scratchSize, - DeviceAddress countInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - - // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html - template ::type = true> - void bindSamplerHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html - template ::type = true> - void bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html - template ::type = true> - void bindResourceHeapEXT( const BindHeapInfoEXT * pBindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html - template ::type = true> - void bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html - template ::type = true> - void pushDataEXT( const PushDataInfoEXT * pPushDataInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html - template ::type = true> - void pushDataEXT( const PushDataInfoEXT & pushDataInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_sample_locations === - - // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html - template ::type = true> - void setSampleLocationsEXT( const SampleLocationsInfoEXT * pSampleLocationsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html - template ::type = true> - void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_acceleration_structure === - - // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html - template ::type = true> - void buildAccelerationStructuresKHR( uint32_t infoCount, - const AccelerationStructureBuildGeometryInfoKHR * pInfos, - const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html - template ::type = true> - void buildAccelerationStructuresKHR( ArrayProxy const & infos, - ArrayProxy const & pBuildRangeInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html - template ::type = true> - void buildAccelerationStructuresIndirectKHR( uint32_t infoCount, - const AccelerationStructureBuildGeometryInfoKHR * pInfos, - const DeviceAddress * pIndirectDeviceAddresses, - const uint32_t * pIndirectStrides, - const uint32_t * const * ppMaxPrimitiveCounts, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html - template ::type = true> - void buildAccelerationStructuresIndirectKHR( ArrayProxy const & infos, - ArrayProxy const & indirectDeviceAddresses, - ArrayProxy const & indirectStrides, - ArrayProxy const & pMaxPrimitiveCounts, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html - template ::type = true> - void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html - template ::type = true> - void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html - template ::type = true> - void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html - template ::type = true> - void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html - template ::type = true> - void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html - template ::type = true> - void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html - template ::type = true> - void writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, - const AccelerationStructureKHR * pAccelerationStructures, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html - template ::type = true> - void writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_ray_tracing_pipeline === - - // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html - template ::type = true> - void traceRaysKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, - const StridedDeviceAddressRegionKHR * pMissShaderBindingTable, - const StridedDeviceAddressRegionKHR * pHitShaderBindingTable, - const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, - uint32_t width, - uint32_t height, - uint32_t depth, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html - template ::type = true> - void traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, - const StridedDeviceAddressRegionKHR & missShaderBindingTable, - const StridedDeviceAddressRegionKHR & hitShaderBindingTable, - const StridedDeviceAddressRegionKHR & callableShaderBindingTable, - uint32_t width, - uint32_t height, - uint32_t depth, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html - template ::type = true> - void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR * pRaygenShaderBindingTable, - const StridedDeviceAddressRegionKHR * pMissShaderBindingTable, - const StridedDeviceAddressRegionKHR * pHitShaderBindingTable, - const StridedDeviceAddressRegionKHR * pCallableShaderBindingTable, - DeviceAddress indirectDeviceAddress, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html - template ::type = true> - void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, - const StridedDeviceAddressRegionKHR & missShaderBindingTable, - const StridedDeviceAddressRegionKHR & hitShaderBindingTable, - const StridedDeviceAddressRegionKHR & callableShaderBindingTable, - DeviceAddress indirectDeviceAddress, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html - template ::type = true> - void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_shading_rate_image === - - // wrapper function for command vkCmdBindShadingRateImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html - template ::type = true> - void bindShadingRateImageNV( ImageView imageView, - ImageLayout imageLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html - template ::type = true> - void setViewportShadingRatePaletteNV( uint32_t firstViewport, - uint32_t viewportCount, - const ShadingRatePaletteNV * pShadingRatePalettes, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html - template ::type = true> - void setViewportShadingRatePaletteNV( uint32_t firstViewport, - ArrayProxy const & shadingRatePalettes, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html - template ::type = true> - void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, - uint32_t customSampleOrderCount, - const CoarseSampleOrderCustomNV * pCustomSampleOrders, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html - template ::type = true> - void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, - ArrayProxy const & customSampleOrders, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_ray_tracing === - - // wrapper function for command vkCmdBuildAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html - template ::type = true> - void buildAccelerationStructureNV( const AccelerationStructureInfoNV * pInfo, - Buffer instanceData, - DeviceSize instanceOffset, - Bool32 update, - AccelerationStructureNV dst, - AccelerationStructureNV src, - Buffer scratch, - DeviceSize scratchOffset, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html - template ::type = true> - void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, - Buffer instanceData, - DeviceSize instanceOffset, - Bool32 update, - AccelerationStructureNV dst, - AccelerationStructureNV src, - Buffer scratch, - DeviceSize scratchOffset, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html - template ::type = true> - void copyAccelerationStructureNV( AccelerationStructureNV dst, - AccelerationStructureNV src, - CopyAccelerationStructureModeKHR mode, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html - template ::type = true> - void traceRaysNV( Buffer raygenShaderBindingTableBuffer, - DeviceSize raygenShaderBindingOffset, - Buffer missShaderBindingTableBuffer, - DeviceSize missShaderBindingOffset, - DeviceSize missShaderBindingStride, - Buffer hitShaderBindingTableBuffer, - DeviceSize hitShaderBindingOffset, - DeviceSize hitShaderBindingStride, - Buffer callableShaderBindingTableBuffer, - DeviceSize callableShaderBindingOffset, - DeviceSize callableShaderBindingStride, - uint32_t width, - uint32_t height, - uint32_t depth, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html - template ::type = true> - void writeAccelerationStructuresPropertiesNV( uint32_t accelerationStructureCount, - const AccelerationStructureNV * pAccelerationStructures, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html - template ::type = true> - void writeAccelerationStructuresPropertiesNV( ArrayProxy const & accelerationStructures, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_draw_indirect_count === - - // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html - template ::type = true> - void drawIndirectCountKHR( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html - template ::type = true> - void drawIndexedIndirectCountKHR( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_AMD_buffer_marker === - - // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html - template ::type = true> - void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, - Buffer dstBuffer, - DeviceSize dstOffset, - uint32_t marker, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html - template ::type = true> - void writeBufferMarker2AMD( PipelineStageFlags2 stage, - Buffer dstBuffer, - DeviceSize dstOffset, - uint32_t marker, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_mesh_shader === - - // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html - template ::type = true> - void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html - template ::type = true> - void drawMeshTasksIndirectNV( Buffer buffer, - DeviceSize offset, - uint32_t drawCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html - template ::type = true> - void drawMeshTasksIndirectCountNV( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_scissor_exclusive === - - // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html - template ::type = true> - void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const Bool32 * pExclusiveScissorEnables, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html - template ::type = true> - void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, - ArrayProxy const & exclusiveScissorEnables, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html - template ::type = true> - void setExclusiveScissorNV( uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const Rect2D * pExclusiveScissors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html - template ::type = true> - void setExclusiveScissorNV( uint32_t firstExclusiveScissor, - ArrayProxy const & exclusiveScissors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_device_diagnostic_checkpoints === - - // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html - template ::type = true> - void setCheckpointNV( const void * pCheckpointMarker, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html - template ::type = true> - void setCheckpointNV( CheckpointMarkerType const & checkpointMarker, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_INTEL_performance_query === - - // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL * pMarkerInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL * pMarkerInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL * pOverrideInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_fragment_shading_rate === - - // wrapper function for command vkCmdSetFragmentShadingRateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html - template ::type = true> - void setFragmentShadingRateKHR( const Extent2D * pFragmentSize, - const FragmentShadingRateCombinerOpKHR combinerOps[2], - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetFragmentShadingRateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html - template ::type = true> - void setFragmentShadingRateKHR( const Extent2D & fragmentSize, - const FragmentShadingRateCombinerOpKHR combinerOps[2], - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_dynamic_rendering_local_read === - - // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html - template ::type = true> - void setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo * pLocationInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html - template ::type = true> - void setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo & locationInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html - template ::type = true> - void setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo * pInputAttachmentIndexInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html - template ::type = true> - void setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_line_rasterization === - - // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html - template ::type = true> - void setLineStippleEXT( uint32_t lineStippleFactor, - uint16_t lineStipplePattern, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_extended_dynamic_state === - - // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html - template ::type = true> - void setCullModeEXT( CullModeFlags cullMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html - template ::type = true> - void setFrontFaceEXT( FrontFace frontFace, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html - template ::type = true> - void setPrimitiveTopologyEXT( PrimitiveTopology primitiveTopology, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetViewportWithCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html - template ::type = true> - void setViewportWithCountEXT( uint32_t viewportCount, - const Viewport * pViewports, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewportWithCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html - template ::type = true> - void setViewportWithCountEXT( ArrayProxy const & viewports, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html - template ::type = true> - void setScissorWithCountEXT( uint32_t scissorCount, - const Rect2D * pScissors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html - template ::type = true> - void setScissorWithCountEXT( ArrayProxy const & scissors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html - template ::type = true> - void bindVertexBuffers2EXT( uint32_t firstBinding, - uint32_t bindingCount, - const Buffer * pBuffers, - const DeviceSize * pOffsets, - const DeviceSize * pSizes, - const DeviceSize * pStrides, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html - template ::type = true> - void bindVertexBuffers2EXT( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - ArrayProxy const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html - template ::type = true> - void setDepthTestEnableEXT( Bool32 depthTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html - template ::type = true> - void setDepthWriteEnableEXT( Bool32 depthWriteEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html - template ::type = true> - void setDepthCompareOpEXT( CompareOp depthCompareOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html - template ::type = true> - void setDepthBoundsTestEnableEXT( Bool32 depthBoundsTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilTestEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html - template ::type = true> - void setStencilTestEnableEXT( Bool32 stencilTestEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html - template ::type = true> - void setStencilOpEXT( StencilFaceFlags faceMask, - StencilOp failOp, - StencilOp passOp, - StencilOp depthFailOp, - CompareOp compareOp, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_device_generated_commands === - - // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html - template ::type = true> - void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV * pGeneratedCommandsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html - template ::type = true> - void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html - template ::type = true> - void executeGeneratedCommandsNV( Bool32 isPreprocessed, - const GeneratedCommandsInfoNV * pGeneratedCommandsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html - template ::type = true> - void executeGeneratedCommandsNV( Bool32 isPreprocessed, - const GeneratedCommandsInfoNV & generatedCommandsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindPipelineShaderGroupNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html - template ::type = true> - void bindPipelineShaderGroupNV( PipelineBindPoint pipelineBindPoint, - Pipeline pipeline, - uint32_t groupIndex, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_depth_bias_control === - - // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html - template ::type = true> - void setDepthBias2EXT( const DepthBiasInfoEXT * pDepthBiasInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html - template ::type = true> - void setDepthBias2EXT( const DepthBiasInfoEXT & depthBiasInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_video_encode_queue === - - // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html - template ::type = true> - void encodeVideoKHR( const VideoEncodeInfoKHR * pEncodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html - template ::type = true> - void encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - - // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html - template ::type = true> - void cudaLaunchKernelNV( const CudaLaunchInfoNV * pLaunchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html - template ::type = true> - void cudaLaunchKernelNV( const CudaLaunchInfoNV & launchInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - - // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html - template ::type = true> - void dispatchTileQCOM( const DispatchTileInfoQCOM * pDispatchTileInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html - template ::type = true> - void dispatchTileQCOM( const DispatchTileInfoQCOM & dispatchTileInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html - template ::type = true> - void beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM * pPerTileBeginInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html - template ::type = true> - void beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM & perTileBeginInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdEndPerTileExecutionQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html - template ::type = true> - void endPerTileExecutionQCOM( const PerTileEndInfoQCOM * pPerTileEndInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndPerTileExecutionQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html - template ::type = true> - void endPerTileExecutionQCOM( const PerTileEndInfoQCOM & perTileEndInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_synchronization2 === - - // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html - template ::type = true> - void setEvent2KHR( Event event, - const DependencyInfo * pDependencyInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html - template ::type = true> - void - setEvent2KHR( Event event, const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html - template ::type = true> - void resetEvent2KHR( Event event, PipelineStageFlags2 stageMask, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html - template ::type = true> - void waitEvents2KHR( uint32_t eventCount, - const Event * pEvents, - const DependencyInfo * pDependencyInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html - template ::type = true> - void waitEvents2KHR( ArrayProxy const & events, - ArrayProxy const & dependencyInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html - template ::type = true> - void pipelineBarrier2KHR( const DependencyInfo * pDependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html - template ::type = true> - void pipelineBarrier2KHR( const DependencyInfo & dependencyInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html - template ::type = true> - void writeTimestamp2KHR( PipelineStageFlags2 stage, - QueryPool queryPool, - uint32_t query, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_descriptor_buffer === - - // wrapper function for command vkCmdBindDescriptorBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html - template ::type = true> - void bindDescriptorBuffersEXT( uint32_t bufferCount, - const DescriptorBufferBindingInfoEXT * pBindingInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindDescriptorBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html - template ::type = true> - void bindDescriptorBuffersEXT( ArrayProxy const & bindingInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html - template ::type = true> - void setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t firstSet, - uint32_t setCount, - const uint32_t * pBufferIndices, - const DeviceSize * pOffsets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html - template ::type = true> - void setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t firstSet, - ArrayProxy const & bufferIndices, - ArrayProxy const & offsets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html - template ::type = true> - void bindDescriptorBufferEmbeddedSamplersEXT( PipelineBindPoint pipelineBindPoint, - PipelineLayout layout, - uint32_t set, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_fragment_shading_rate_enums === - - // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html - template ::type = true> - void setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, - const FragmentShadingRateCombinerOpKHR combinerOps[2], - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_mesh_shader === - - // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html - template ::type = true> - void drawMeshTasksEXT( uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html - template ::type = true> - void drawMeshTasksIndirectEXT( Buffer buffer, - DeviceSize offset, - uint32_t drawCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html - template ::type = true> - void drawMeshTasksIndirectCountEXT( Buffer buffer, - DeviceSize offset, - Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_copy_commands2 === - - // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html - template ::type = true> - void copyBuffer2KHR( const CopyBufferInfo2 * pCopyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html - template ::type = true> - void copyBuffer2KHR( const CopyBufferInfo2 & copyBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html - template ::type = true> - void copyImage2KHR( const CopyImageInfo2 * pCopyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html - template ::type = true> - void copyImage2KHR( const CopyImageInfo2 & copyImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html - template ::type = true> - void copyBufferToImage2KHR( const CopyBufferToImageInfo2 * pCopyBufferToImageInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html - template ::type = true> - void copyBufferToImage2KHR( const CopyBufferToImageInfo2 & copyBufferToImageInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html - template ::type = true> - void copyImageToBuffer2KHR( const CopyImageToBufferInfo2 * pCopyImageToBufferInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html - template ::type = true> - void copyImageToBuffer2KHR( const CopyImageToBufferInfo2 & copyImageToBufferInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html - template ::type = true> - void blitImage2KHR( const BlitImageInfo2 * pBlitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html - template ::type = true> - void blitImage2KHR( const BlitImageInfo2 & blitImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html - template ::type = true> - void resolveImage2KHR( const ResolveImageInfo2 * pResolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html - template ::type = true> - void resolveImage2KHR( const ResolveImageInfo2 & resolveImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_vertex_input_dynamic_state === - - // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html - template ::type = true> - void setVertexInputEXT( uint32_t vertexBindingDescriptionCount, - const VertexInputBindingDescription2EXT * pVertexBindingDescriptions, - uint32_t vertexAttributeDescriptionCount, - const VertexInputAttributeDescription2EXT * pVertexAttributeDescriptions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html - template ::type = true> - void setVertexInputEXT( ArrayProxy const & vertexBindingDescriptions, - ArrayProxy const & vertexAttributeDescriptions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_HUAWEI_subpass_shading === - - // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html - template ::type = true> - void subpassShadingHUAWEI( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_HUAWEI_invocation_mask === - - // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html - template ::type = true> - void bindInvocationMaskHUAWEI( ImageView imageView, - ImageLayout imageLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_extended_dynamic_state2 === - - // wrapper function for command vkCmdSetPatchControlPointsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html - template ::type = true> - void setPatchControlPointsEXT( uint32_t patchControlPoints, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html - template ::type = true> - void setRasterizerDiscardEnableEXT( Bool32 rasterizerDiscardEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html - template ::type = true> - void setDepthBiasEnableEXT( Bool32 depthBiasEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html - template ::type = true> - void setLogicOpEXT( LogicOp logicOp, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html - template ::type = true> - void setPrimitiveRestartEnableEXT( Bool32 primitiveRestartEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_color_write_enable === - - // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html - template ::type = true> - void setColorWriteEnableEXT( uint32_t attachmentCount, - const Bool32 * pColorWriteEnables, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html - template ::type = true> - void setColorWriteEnableEXT( ArrayProxy const & colorWriteEnables, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_ray_tracing_maintenance1 === - - // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html - template ::type = true> - void traceRaysIndirect2KHR( DeviceAddress indirectDeviceAddress, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_multi_draw === - - // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html - template ::type = true> - void drawMultiEXT( uint32_t drawCount, - const MultiDrawInfoEXT * pVertexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html - template ::type = true> - void drawMultiEXT( StridedArrayProxy const & vertexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html - template ::type = true> - void drawMultiIndexedEXT( uint32_t drawCount, - const MultiDrawIndexedInfoEXT * pIndexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride, - const int32_t * pVertexOffset, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html - template ::type = true> - void drawMultiIndexedEXT( StridedArrayProxy const & indexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - Optional vertexOffset VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_opacity_micromap === - - // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html - template ::type = true> - void buildMicromapsEXT( uint32_t infoCount, - const MicromapBuildInfoEXT * pInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html - template ::type = true> - void buildMicromapsEXT( ArrayProxy const & infos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html - template ::type = true> - void copyMicromapEXT( const CopyMicromapInfoEXT * pInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html - template ::type = true> - void copyMicromapEXT( const CopyMicromapInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html - template ::type = true> - void copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html - template ::type = true> - void copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html - template ::type = true> - void copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html - template ::type = true> - void copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html - template ::type = true> - void writeMicromapsPropertiesEXT( uint32_t micromapCount, - const MicromapEXT * pMicromaps, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html - template ::type = true> - void writeMicromapsPropertiesEXT( ArrayProxy const & micromaps, - QueryType queryType, - QueryPool queryPool, - uint32_t firstQuery, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_HUAWEI_cluster_culling_shader === - - // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html - template ::type = true> - void drawClusterHUAWEI( uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html - template ::type = true> - void drawClusterIndirectHUAWEI( Buffer buffer, DeviceSize offset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_copy_memory_indirect === - - // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html - template ::type = true> - void copyMemoryIndirectNV( DeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html - template ::type = true> - void copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride, - Image dstImage, - ImageLayout dstImageLayout, - const ImageSubresourceLayers * pImageSubresources, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html - template ::type = true> - void copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, - uint32_t stride, - Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & imageSubresources, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_memory_decompression === - - // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html - template ::type = true> - void decompressMemoryNV( uint32_t decompressRegionCount, - const DecompressMemoryRegionNV * pDecompressMemoryRegions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html - template ::type = true> - void decompressMemoryNV( ArrayProxy const & decompressMemoryRegions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html - template ::type = true> - void decompressMemoryIndirectCountNV( DeviceAddress indirectCommandsAddress, - DeviceAddress indirectCommandsCountAddress, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_device_generated_commands_compute === - - // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html - template ::type = true> - void updatePipelineIndirectBufferNV( PipelineBindPoint pipelineBindPoint, - Pipeline pipeline, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_extended_dynamic_state3 === - - // wrapper function for command vkCmdSetDepthClampEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html - template ::type = true> - void setDepthClampEnableEXT( Bool32 depthClampEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html - template ::type = true> - void setPolygonModeEXT( PolygonMode polygonMode, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRasterizationSamplesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html - template ::type = true> - void setRasterizationSamplesEXT( SampleCountFlagBits rasterizationSamples, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html - template ::type = true> - void setSampleMaskEXT( SampleCountFlagBits samples, - const SampleMask * pSampleMask, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html - template ::type = true> - void setSampleMaskEXT( SampleCountFlagBits samples, - ArrayProxy const & sampleMask VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html - template ::type = true> - void setAlphaToCoverageEnableEXT( Bool32 alphaToCoverageEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html - template ::type = true> - void setAlphaToOneEnableEXT( Bool32 alphaToOneEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html - template ::type = true> - void setLogicOpEnableEXT( Bool32 logicOpEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html - template ::type = true> - void setColorBlendEnableEXT( uint32_t firstAttachment, - uint32_t attachmentCount, - const Bool32 * pColorBlendEnables, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html - template ::type = true> - void setColorBlendEnableEXT( uint32_t firstAttachment, - ArrayProxy const & colorBlendEnables, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetColorBlendEquationEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html - template ::type = true> - void setColorBlendEquationEXT( uint32_t firstAttachment, - uint32_t attachmentCount, - const ColorBlendEquationEXT * pColorBlendEquations, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetColorBlendEquationEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html - template ::type = true> - void setColorBlendEquationEXT( uint32_t firstAttachment, - ArrayProxy const & colorBlendEquations, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html - template ::type = true> - void setColorWriteMaskEXT( uint32_t firstAttachment, - uint32_t attachmentCount, - const ColorComponentFlags * pColorWriteMasks, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html - template ::type = true> - void setColorWriteMaskEXT( uint32_t firstAttachment, - ArrayProxy const & colorWriteMasks, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html - template ::type = true> - void setTessellationDomainOriginEXT( TessellationDomainOrigin domainOrigin, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRasterizationStreamEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html - template ::type = true> - void setRasterizationStreamEXT( uint32_t rasterizationStream, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html - template ::type = true> - void setConservativeRasterizationModeEXT( ConservativeRasterizationModeEXT conservativeRasterizationMode, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html - template ::type = true> - void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html - template ::type = true> - void setDepthClipEnableEXT( Bool32 depthClipEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html - template ::type = true> - void setSampleLocationsEnableEXT( Bool32 sampleLocationsEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html - template ::type = true> - void setColorBlendAdvancedEXT( uint32_t firstAttachment, - uint32_t attachmentCount, - const ColorBlendAdvancedEXT * pColorBlendAdvanced, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html - template ::type = true> - void setColorBlendAdvancedEXT( uint32_t firstAttachment, - ArrayProxy const & colorBlendAdvanced, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetProvokingVertexModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html - template ::type = true> - void setProvokingVertexModeEXT( ProvokingVertexModeEXT provokingVertexMode, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetLineRasterizationModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html - template ::type = true> - void setLineRasterizationModeEXT( LineRasterizationModeEXT lineRasterizationMode, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetLineStippleEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html - template ::type = true> - void setLineStippleEnableEXT( Bool32 stippledLineEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html - template ::type = true> - void setDepthClipNegativeOneToOneEXT( Bool32 negativeOneToOne, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetViewportWScalingEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html - template ::type = true> - void setViewportWScalingEnableNV( Bool32 viewportWScalingEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html - template ::type = true> - void setViewportSwizzleNV( uint32_t firstViewport, - uint32_t viewportCount, - const ViewportSwizzleNV * pViewportSwizzles, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html - template ::type = true> - void setViewportSwizzleNV( uint32_t firstViewport, - ArrayProxy const & viewportSwizzles, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetCoverageToColorEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html - template ::type = true> - void setCoverageToColorEnableNV( Bool32 coverageToColorEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoverageToColorLocationNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html - template ::type = true> - void setCoverageToColorLocationNV( uint32_t coverageToColorLocation, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoverageModulationModeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html - template ::type = true> - void setCoverageModulationModeNV( CoverageModulationModeNV coverageModulationMode, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html - template ::type = true> - void setCoverageModulationTableEnableNV( Bool32 coverageModulationTableEnable, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoverageModulationTableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html - template ::type = true> - void setCoverageModulationTableNV( uint32_t coverageModulationTableCount, - const float * pCoverageModulationTable, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetCoverageModulationTableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html - template ::type = true> - void setCoverageModulationTableNV( ArrayProxy const & coverageModulationTable, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetShadingRateImageEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html - template ::type = true> - void setShadingRateImageEnableNV( Bool32 shadingRateImageEnable, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html - template ::type = true> - void setRepresentativeFragmentTestEnableNV( Bool32 representativeFragmentTestEnable, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoverageReductionModeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html - template ::type = true> - void setCoverageReductionModeNV( CoverageReductionModeNV coverageReductionMode, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_ARM_tensors === - - // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html - template ::type = true> - void copyTensorARM( const CopyTensorInfoARM * pCopyTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html - template ::type = true> - void copyTensorARM( const CopyTensorInfoARM & copyTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_optical_flow === - - // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html - template ::type = true> - void opticalFlowExecuteNV( OpticalFlowSessionNV session, - const OpticalFlowExecuteInfoNV * pExecuteInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html - template ::type = true> - void opticalFlowExecuteNV( OpticalFlowSessionNV session, - const OpticalFlowExecuteInfoNV & executeInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_maintenance5 === - - // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html - template ::type = true> - void bindIndexBuffer2KHR( Buffer buffer, - DeviceSize offset, - DeviceSize size, - IndexType indexType, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_shader_object === - - // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html - template ::type = true> - void bindShadersEXT( uint32_t stageCount, - const ShaderStageFlagBits * pStages, - const ShaderEXT * pShaders, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html - template ::type = true> - void bindShadersEXT( ArrayProxy const & stages, - ArrayProxy const & shaders, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html - template ::type = true> - void setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, - const DepthClampRangeEXT * pDepthClampRange, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html - template ::type = true> - void setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, - Optional depthClampRange VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_cooperative_vector === - - // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html - template ::type = true> - void convertCooperativeVectorMatrixNV( uint32_t infoCount, - const ConvertCooperativeVectorMatrixInfoNV * pInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html - template ::type = true> - void convertCooperativeVectorMatrixNV( ArrayProxy const & infos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_ARM_data_graph === - - // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html - template ::type = true> - void dispatchDataGraphARM( DataGraphPipelineSessionARM session, - const DataGraphPipelineDispatchInfoARM * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html - template ::type = true> - void dispatchDataGraphARM( DataGraphPipelineSessionARM session, - Optional info VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - - // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html - template ::type = true> - void setAttachmentFeedbackLoopEnableEXT( ImageAspectFlags aspectMask, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_line_rasterization === - - // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html - template ::type = true> - void setLineStippleKHR( uint32_t lineStippleFactor, - uint16_t lineStipplePattern, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_maintenance6 === - - // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html - template ::type = true> - void bindDescriptorSets2KHR( const BindDescriptorSetsInfo * pBindDescriptorSetsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html - template ::type = true> - void bindDescriptorSets2KHR( const BindDescriptorSetsInfo & bindDescriptorSetsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html - template ::type = true> - void pushConstants2KHR( const PushConstantsInfo * pPushConstantsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html - template ::type = true> - void pushConstants2KHR( const PushConstantsInfo & pushConstantsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html - template ::type = true> - void pushDescriptorSet2KHR( const PushDescriptorSetInfo * pPushDescriptorSetInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html - template ::type = true> - void pushDescriptorSet2KHR( const PushDescriptorSetInfo & pushDescriptorSetInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html - template ::type = true> - void pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo * pPushDescriptorSetWithTemplateInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html - template ::type = true> - void pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html - template ::type = true> - void setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT * pSetDescriptorBufferOffsetsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html - template ::type = true> - void setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html - template ::type = true> - void bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT * pBindDescriptorBufferEmbeddedSamplersInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html - template ::type = true> - void bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_QCOM_tile_memory_heap === - - // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html - template ::type = true> - void bindTileMemoryQCOM( const TileMemoryBindInfoQCOM * pTileMemoryBindInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html - template ::type = true> - void bindTileMemoryQCOM( Optional tileMemoryBindInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_copy_memory_indirect === - - // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html - template ::type = true> - void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR * pCopyMemoryIndirectInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html - template ::type = true> - void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html - template ::type = true> - void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR * pCopyMemoryToImageIndirectInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html - template ::type = true> - void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_memory_decompression === - - // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html - template ::type = true> - void decompressMemoryEXT( const DecompressMemoryInfoEXT * pDecompressMemoryInfoEXT, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html - template ::type = true> - void decompressMemoryEXT( const DecompressMemoryInfoEXT & decompressMemoryInfoEXT, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdDecompressMemoryIndirectCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountEXT.html - template ::type = true> - void decompressMemoryIndirectCountEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod, - DeviceAddress indirectCommandsAddress, - DeviceAddress indirectCommandsCountAddress, - uint32_t maxDecompressionCount, - uint32_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_cluster_acceleration_structure === - - // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html - template ::type = true> - void buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV * pCommandInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html - template ::type = true> - void buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV & commandInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_partitioned_acceleration_structure === - - // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html - template ::type = true> - void buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV * pBuildInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html - template ::type = true> - void buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV & buildInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_device_generated_commands === - - // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html - template ::type = true> - void preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo, - CommandBuffer stateCommandBuffer, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html - template ::type = true> - void preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT & generatedCommandsInfo, - CommandBuffer stateCommandBuffer, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html - template ::type = true> - void executeGeneratedCommandsEXT( Bool32 isPreprocessed, - const GeneratedCommandsInfoEXT * pGeneratedCommandsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html - template ::type = true> - void executeGeneratedCommandsEXT( Bool32 isPreprocessed, - const GeneratedCommandsInfoEXT & generatedCommandsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_fragment_density_map_offset === - - // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html - template ::type = true> - void endRendering2EXT( const RenderingEndInfoKHR * pRenderingEndInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html - template ::type = true> - void endRendering2EXT( Optional renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_custom_resolve === - - // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html - template ::type = true> - void beginCustomResolveEXT( const BeginCustomResolveInfoEXT * pBeginCustomResolveInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html - template ::type = true> - void beginCustomResolveEXT( Optional beginCustomResolveInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_maintenance10 === - - // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html - template ::type = true> - void endRendering2KHR( const RenderingEndInfoKHR * pRenderingEndInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html - template ::type = true> - void endRendering2KHR( Optional renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_compute_occupancy_priority === - - // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html - template ::type = true> - void setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV * pParameters, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html - template ::type = true> - void setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV & parameters, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT - { - return m_commandBuffer; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_commandBuffer != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_commandBuffer == VK_NULL_HANDLE; - } - - private: - VkCommandBuffer m_commandBuffer = {}; - }; - - template <> - struct CppType - { - using Type = CommandBuffer; - }; - - template <> - struct CppType - { - using Type = CommandBuffer; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = CommandBuffer; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDeviceMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemory.html - class DeviceMemory - { - public: - using CType = VkDeviceMemory; - using NativeType = VkDeviceMemory; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDeviceMemory; - - public: - DeviceMemory() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - DeviceMemory( DeviceMemory const & rhs ) = default; - DeviceMemory & operator=( DeviceMemory const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - DeviceMemory( DeviceMemory && rhs ) = default; - DeviceMemory & operator=( DeviceMemory && rhs ) = default; -#else - DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( exchange( rhs.m_deviceMemory, {} ) ) {} - - DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT - { - m_deviceMemory = exchange( rhs.m_deviceMemory, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR DeviceMemory( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DeviceMemory( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT : m_deviceMemory( deviceMemory ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - DeviceMemory & operator=( VkDeviceMemory deviceMemory ) VULKAN_HPP_NOEXCEPT - { - m_deviceMemory = deviceMemory; - return *this; - } -#endif - - DeviceMemory & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_deviceMemory = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeviceMemory() const VULKAN_HPP_NOEXCEPT - { - return m_deviceMemory; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_deviceMemory != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_deviceMemory == VK_NULL_HANDLE; - } - - private: - VkDeviceMemory m_deviceMemory = {}; - }; - - template <> - struct CppType - { - using Type = DeviceMemory; - }; - - template <> - struct CppType - { - using Type = DeviceMemory; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = DeviceMemory; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionKHR.html - class VideoSessionKHR - { - public: - using CType = VkVideoSessionKHR; - using NativeType = VkVideoSessionKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - VideoSessionKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - VideoSessionKHR( VideoSessionKHR const & rhs ) = default; - VideoSessionKHR & operator=( VideoSessionKHR const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - VideoSessionKHR( VideoSessionKHR && rhs ) = default; - VideoSessionKHR & operator=( VideoSessionKHR && rhs ) = default; -#else - VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( exchange( rhs.m_videoSessionKHR, {} ) ) {} - - VideoSessionKHR & operator=( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - m_videoSessionKHR = exchange( rhs.m_videoSessionKHR, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR VideoSessionKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionKHR( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT : m_videoSessionKHR( videoSessionKHR ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - VideoSessionKHR & operator=( VkVideoSessionKHR videoSessionKHR ) VULKAN_HPP_NOEXCEPT - { - m_videoSessionKHR = videoSessionKHR; - return *this; - } -#endif - - VideoSessionKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_videoSessionKHR = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionKHR() const VULKAN_HPP_NOEXCEPT - { - return m_videoSessionKHR; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_videoSessionKHR != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_videoSessionKHR == VK_NULL_HANDLE; - } - - private: - VkVideoSessionKHR m_videoSessionKHR = {}; - }; - - template <> - struct CppType - { - using Type = VideoSessionKHR; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = VideoSessionKHR; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeferredOperationKHR.html - class DeferredOperationKHR - { - public: - using CType = VkDeferredOperationKHR; - using NativeType = VkDeferredOperationKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeferredOperationKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - DeferredOperationKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - DeferredOperationKHR( DeferredOperationKHR const & rhs ) = default; - DeferredOperationKHR & operator=( DeferredOperationKHR const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - DeferredOperationKHR( DeferredOperationKHR && rhs ) = default; - DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) = default; -#else - DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_deferredOperationKHR( exchange( rhs.m_deferredOperationKHR, {} ) ) {} - - DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - m_deferredOperationKHR = exchange( rhs.m_deferredOperationKHR, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR DeferredOperationKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DeferredOperationKHR( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT - : m_deferredOperationKHR( deferredOperationKHR ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - DeferredOperationKHR & operator=( VkDeferredOperationKHR deferredOperationKHR ) VULKAN_HPP_NOEXCEPT - { - m_deferredOperationKHR = deferredOperationKHR; - return *this; - } -#endif - - DeferredOperationKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_deferredOperationKHR = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDeferredOperationKHR() const VULKAN_HPP_NOEXCEPT - { - return m_deferredOperationKHR; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_deferredOperationKHR != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_deferredOperationKHR == VK_NULL_HANDLE; - } - - private: - VkDeferredOperationKHR m_deferredOperationKHR = {}; - }; - - template <> - struct CppType - { - using Type = DeferredOperationKHR; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = DeferredOperationKHR; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionFUCHSIA.html -#if defined( VK_USE_PLATFORM_FUCHSIA ) - class BufferCollectionFUCHSIA - { - public: - using CType = VkBufferCollectionFUCHSIA; - using NativeType = VkBufferCollectionFUCHSIA; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferCollectionFUCHSIA; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA; - - public: - BufferCollectionFUCHSIA() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & rhs ) = default; - BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & rhs ) = default; - -# if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) = default; - BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) = default; -# else - BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT : m_bufferCollectionFUCHSIA( exchange( rhs.m_bufferCollectionFUCHSIA, {} ) ) - { - } - - BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT - { - m_bufferCollectionFUCHSIA = exchange( rhs.m_bufferCollectionFUCHSIA, {} ); - return *this; - } -# endif - - VULKAN_HPP_CONSTEXPR BufferCollectionFUCHSIA( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT BufferCollectionFUCHSIA( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT - : m_bufferCollectionFUCHSIA( bufferCollectionFUCHSIA ) - { - } - -# if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - BufferCollectionFUCHSIA & operator=( VkBufferCollectionFUCHSIA bufferCollectionFUCHSIA ) VULKAN_HPP_NOEXCEPT - { - m_bufferCollectionFUCHSIA = bufferCollectionFUCHSIA; - return *this; - } -# endif - - BufferCollectionFUCHSIA & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_bufferCollectionFUCHSIA = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT - { - return m_bufferCollectionFUCHSIA; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_bufferCollectionFUCHSIA != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_bufferCollectionFUCHSIA == VK_NULL_HANDLE; - } - - private: - VkBufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {}; - }; - - template <> - struct CppType - { - using Type = BufferCollectionFUCHSIA; - }; - - template <> - struct CppType - { - using Type = BufferCollectionFUCHSIA; - }; - -# if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = BufferCollectionFUCHSIA; - }; -# endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - // wrapper class for handle VkBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferView.html - class BufferView - { - public: - using CType = VkBufferView; - using NativeType = VkBufferView; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferView; - - public: - BufferView() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - BufferView( BufferView const & rhs ) = default; - BufferView & operator=( BufferView const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - BufferView( BufferView && rhs ) = default; - BufferView & operator=( BufferView && rhs ) = default; -#else - BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT : m_bufferView( exchange( rhs.m_bufferView, {} ) ) {} - - BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT - { - m_bufferView = exchange( rhs.m_bufferView, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR BufferView( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT BufferView( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT : m_bufferView( bufferView ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - BufferView & operator=( VkBufferView bufferView ) VULKAN_HPP_NOEXCEPT - { - m_bufferView = bufferView; - return *this; - } -#endif - - BufferView & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_bufferView = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkBufferView() const VULKAN_HPP_NOEXCEPT - { - return m_bufferView; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_bufferView != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_bufferView == VK_NULL_HANDLE; - } - - private: - VkBufferView m_bufferView = {}; - }; - - template <> - struct CppType - { - using Type = BufferView; - }; - - template <> - struct CppType - { - using Type = BufferView; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = BufferView; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPool.html - class CommandPool - { - public: - using CType = VkCommandPool; - using NativeType = VkCommandPool; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandPool; - - public: - CommandPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - CommandPool( CommandPool const & rhs ) = default; - CommandPool & operator=( CommandPool const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - CommandPool( CommandPool && rhs ) = default; - CommandPool & operator=( CommandPool && rhs ) = default; -#else - CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT : m_commandPool( exchange( rhs.m_commandPool, {} ) ) {} - - CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT - { - m_commandPool = exchange( rhs.m_commandPool, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR CommandPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT CommandPool( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT : m_commandPool( commandPool ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - CommandPool & operator=( VkCommandPool commandPool ) VULKAN_HPP_NOEXCEPT - { - m_commandPool = commandPool; - return *this; - } -#endif - - CommandPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_commandPool = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCommandPool() const VULKAN_HPP_NOEXCEPT - { - return m_commandPool; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_commandPool != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_commandPool == VK_NULL_HANDLE; - } - - private: - VkCommandPool m_commandPool = {}; - }; - - template <> - struct CppType - { - using Type = CommandPool; - }; - - template <> - struct CppType - { - using Type = CommandPool; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = CommandPool; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCache.html - class PipelineCache - { - public: - using CType = VkPipelineCache; - using NativeType = VkPipelineCache; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineCache; - - public: - PipelineCache() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - PipelineCache( PipelineCache const & rhs ) = default; - PipelineCache & operator=( PipelineCache const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - PipelineCache( PipelineCache && rhs ) = default; - PipelineCache & operator=( PipelineCache && rhs ) = default; -#else - PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( exchange( rhs.m_pipelineCache, {} ) ) {} - - PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT - { - m_pipelineCache = exchange( rhs.m_pipelineCache, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR PipelineCache( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT PipelineCache( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT : m_pipelineCache( pipelineCache ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - PipelineCache & operator=( VkPipelineCache pipelineCache ) VULKAN_HPP_NOEXCEPT - { - m_pipelineCache = pipelineCache; - return *this; - } -#endif - - PipelineCache & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_pipelineCache = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineCache() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineCache; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineCache != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineCache == VK_NULL_HANDLE; - } - - private: - VkPipelineCache m_pipelineCache = {}; - }; - - template <> - struct CppType - { - using Type = PipelineCache; - }; - - template <> - struct CppType - { - using Type = PipelineCache; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = PipelineCache; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuFunctionNVX.html - class CuFunctionNVX - { - public: - using CType = VkCuFunctionNVX; - using NativeType = VkCuFunctionNVX; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuFunctionNVX; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuFunctionNVX; - - public: - CuFunctionNVX() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - CuFunctionNVX( CuFunctionNVX const & rhs ) = default; - CuFunctionNVX & operator=( CuFunctionNVX const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - CuFunctionNVX( CuFunctionNVX && rhs ) = default; - CuFunctionNVX & operator=( CuFunctionNVX && rhs ) = default; -#else - CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( exchange( rhs.m_cuFunctionNVX, {} ) ) {} - - CuFunctionNVX & operator=( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT - { - m_cuFunctionNVX = exchange( rhs.m_cuFunctionNVX, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR CuFunctionNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT CuFunctionNVX( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT : m_cuFunctionNVX( cuFunctionNVX ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - CuFunctionNVX & operator=( VkCuFunctionNVX cuFunctionNVX ) VULKAN_HPP_NOEXCEPT - { - m_cuFunctionNVX = cuFunctionNVX; - return *this; - } -#endif - - CuFunctionNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_cuFunctionNVX = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuFunctionNVX() const VULKAN_HPP_NOEXCEPT - { - return m_cuFunctionNVX; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_cuFunctionNVX != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_cuFunctionNVX == VK_NULL_HANDLE; - } - - private: - VkCuFunctionNVX m_cuFunctionNVX = {}; - }; - - template <> - struct CppType - { - using Type = CuFunctionNVX; - }; - - template <> - struct CppType - { - using Type = CuFunctionNVX; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = CuFunctionNVX; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleNVX.html - class CuModuleNVX - { - public: - using CType = VkCuModuleNVX; - using NativeType = VkCuModuleNVX; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuModuleNVX; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuModuleNVX; - - public: - CuModuleNVX() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - CuModuleNVX( CuModuleNVX const & rhs ) = default; - CuModuleNVX & operator=( CuModuleNVX const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - CuModuleNVX( CuModuleNVX && rhs ) = default; - CuModuleNVX & operator=( CuModuleNVX && rhs ) = default; -#else - CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( exchange( rhs.m_cuModuleNVX, {} ) ) {} - - CuModuleNVX & operator=( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT - { - m_cuModuleNVX = exchange( rhs.m_cuModuleNVX, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR CuModuleNVX( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT CuModuleNVX( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT : m_cuModuleNVX( cuModuleNVX ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - CuModuleNVX & operator=( VkCuModuleNVX cuModuleNVX ) VULKAN_HPP_NOEXCEPT - { - m_cuModuleNVX = cuModuleNVX; - return *this; - } -#endif - - CuModuleNVX & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_cuModuleNVX = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCuModuleNVX() const VULKAN_HPP_NOEXCEPT - { - return m_cuModuleNVX; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_cuModuleNVX != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_cuModuleNVX == VK_NULL_HANDLE; - } - - private: - VkCuModuleNVX m_cuModuleNVX = {}; - }; - - template <> - struct CppType - { - using Type = CuModuleNVX; - }; - - template <> - struct CppType - { - using Type = CuModuleNVX; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = CuModuleNVX; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaFunctionNV.html -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - class CudaFunctionNV - { - public: - using CType = VkCudaFunctionNV; - using NativeType = VkCudaFunctionNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaFunctionNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaFunctionNV; - - public: - CudaFunctionNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - CudaFunctionNV( CudaFunctionNV const & rhs ) = default; - CudaFunctionNV & operator=( CudaFunctionNV const & rhs ) = default; - -# if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - CudaFunctionNV( CudaFunctionNV && rhs ) = default; - CudaFunctionNV & operator=( CudaFunctionNV && rhs ) = default; -# else - CudaFunctionNV( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( exchange( rhs.m_cudaFunctionNV, {} ) ) {} - - CudaFunctionNV & operator=( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT - { - m_cudaFunctionNV = exchange( rhs.m_cudaFunctionNV, {} ); - return *this; - } -# endif - - VULKAN_HPP_CONSTEXPR CudaFunctionNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT CudaFunctionNV( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT : m_cudaFunctionNV( cudaFunctionNV ) {} - -# if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - CudaFunctionNV & operator=( VkCudaFunctionNV cudaFunctionNV ) VULKAN_HPP_NOEXCEPT - { - m_cudaFunctionNV = cudaFunctionNV; - return *this; - } -# endif - - CudaFunctionNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_cudaFunctionNV = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaFunctionNV() const VULKAN_HPP_NOEXCEPT - { - return m_cudaFunctionNV; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_cudaFunctionNV != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_cudaFunctionNV == VK_NULL_HANDLE; - } - - private: - VkCudaFunctionNV m_cudaFunctionNV = {}; - }; - - template <> - struct CppType - { - using Type = CudaFunctionNV; - }; - - template <> - struct CppType - { - using Type = CudaFunctionNV; - }; - -# if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = CudaFunctionNV; - }; -# endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper class for handle VkCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaModuleNV.html -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - class CudaModuleNV - { - public: - using CType = VkCudaModuleNV; - using NativeType = VkCudaModuleNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaModuleNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaModuleNV; - - public: - CudaModuleNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - CudaModuleNV( CudaModuleNV const & rhs ) = default; - CudaModuleNV & operator=( CudaModuleNV const & rhs ) = default; - -# if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - CudaModuleNV( CudaModuleNV && rhs ) = default; - CudaModuleNV & operator=( CudaModuleNV && rhs ) = default; -# else - CudaModuleNV( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( exchange( rhs.m_cudaModuleNV, {} ) ) {} - - CudaModuleNV & operator=( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT - { - m_cudaModuleNV = exchange( rhs.m_cudaModuleNV, {} ); - return *this; - } -# endif - - VULKAN_HPP_CONSTEXPR CudaModuleNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT CudaModuleNV( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT : m_cudaModuleNV( cudaModuleNV ) {} - -# if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - CudaModuleNV & operator=( VkCudaModuleNV cudaModuleNV ) VULKAN_HPP_NOEXCEPT - { - m_cudaModuleNV = cudaModuleNV; - return *this; - } -# endif - - CudaModuleNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_cudaModuleNV = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkCudaModuleNV() const VULKAN_HPP_NOEXCEPT - { - return m_cudaModuleNV; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_cudaModuleNV != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_cudaModuleNV == VK_NULL_HANDLE; - } - - private: - VkCudaModuleNV m_cudaModuleNV = {}; - }; - - template <> - struct CppType - { - using Type = CudaModuleNV; - }; - - template <> - struct CppType - { - using Type = CudaModuleNV; - }; - -# if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = CudaModuleNV; - }; -# endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper class for handle VkDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPool.html - class DescriptorPool - { - public: - using CType = VkDescriptorPool; - using NativeType = VkDescriptorPool; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorPool; - - public: - DescriptorPool() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - DescriptorPool( DescriptorPool const & rhs ) = default; - DescriptorPool & operator=( DescriptorPool const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - DescriptorPool( DescriptorPool && rhs ) = default; - DescriptorPool & operator=( DescriptorPool && rhs ) = default; -#else - DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( exchange( rhs.m_descriptorPool, {} ) ) {} - - DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT - { - m_descriptorPool = exchange( rhs.m_descriptorPool, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR DescriptorPool( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorPool( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT : m_descriptorPool( descriptorPool ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - DescriptorPool & operator=( VkDescriptorPool descriptorPool ) VULKAN_HPP_NOEXCEPT - { - m_descriptorPool = descriptorPool; - return *this; - } -#endif - - DescriptorPool & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_descriptorPool = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorPool() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorPool; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorPool != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorPool == VK_NULL_HANDLE; - } - - private: - VkDescriptorPool m_descriptorPool = {}; - }; - - template <> - struct CppType - { - using Type = DescriptorPool; - }; - - template <> - struct CppType - { - using Type = DescriptorPool; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = DescriptorPool; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayout.html - class DescriptorSetLayout - { - public: - using CType = VkDescriptorSetLayout; - using NativeType = VkDescriptorSetLayout; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSetLayout; - - public: - DescriptorSetLayout() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - DescriptorSetLayout( DescriptorSetLayout const & rhs ) = default; - DescriptorSetLayout & operator=( DescriptorSetLayout const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - DescriptorSetLayout( DescriptorSetLayout && rhs ) = default; - DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) = default; -#else - DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT : m_descriptorSetLayout( exchange( rhs.m_descriptorSetLayout, {} ) ) {} - - DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT - { - m_descriptorSetLayout = exchange( rhs.m_descriptorSetLayout, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR DescriptorSetLayout( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DescriptorSetLayout( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT - : m_descriptorSetLayout( descriptorSetLayout ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - DescriptorSetLayout & operator=( VkDescriptorSetLayout descriptorSetLayout ) VULKAN_HPP_NOEXCEPT - { - m_descriptorSetLayout = descriptorSetLayout; - return *this; - } -#endif - - DescriptorSetLayout & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_descriptorSetLayout = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDescriptorSetLayout() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorSetLayout; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorSetLayout != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorSetLayout == VK_NULL_HANDLE; - } - - private: - VkDescriptorSetLayout m_descriptorSetLayout = {}; - }; - - template <> - struct CppType - { - using Type = DescriptorSetLayout; - }; - - template <> - struct CppType - { - using Type = DescriptorSetLayout; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = DescriptorSetLayout; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueNV.html - class ExternalComputeQueueNV - { - public: - using CType = VkExternalComputeQueueNV; - using NativeType = VkExternalComputeQueueNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eExternalComputeQueueNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - ExternalComputeQueueNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - ExternalComputeQueueNV( ExternalComputeQueueNV const & rhs ) = default; - ExternalComputeQueueNV & operator=( ExternalComputeQueueNV const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) = default; - ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) = default; -#else - ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT : m_externalComputeQueueNV( exchange( rhs.m_externalComputeQueueNV, {} ) ) {} - - ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT - { - m_externalComputeQueueNV = exchange( rhs.m_externalComputeQueueNV, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR ExternalComputeQueueNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - ExternalComputeQueueNV( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT : m_externalComputeQueueNV( externalComputeQueueNV ) {} - - ExternalComputeQueueNV & operator=( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT - { - m_externalComputeQueueNV = externalComputeQueueNV; - return *this; - } - - ExternalComputeQueueNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_externalComputeQueueNV = {}; - return *this; - } - - //=== VK_NV_external_compute_queue === - - // wrapper function for command vkGetExternalComputeQueueDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html - template ::type = true> - void - getData( ExternalComputeQueueDataParamsNV * params, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetExternalComputeQueueDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html - template ::type = true> - VULKAN_HPP_NODISCARD std::pair - getData( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - operator VkExternalComputeQueueNV() const VULKAN_HPP_NOEXCEPT - { - return m_externalComputeQueueNV; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_externalComputeQueueNV != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_externalComputeQueueNV == VK_NULL_HANDLE; - } - - private: - VkExternalComputeQueueNV m_externalComputeQueueNV = {}; - }; - - template <> - struct CppType - { - using Type = ExternalComputeQueueNV; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = ExternalComputeQueueNV; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebuffer.html - class Framebuffer - { - public: - using CType = VkFramebuffer; - using NativeType = VkFramebuffer; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFramebuffer; - - public: - Framebuffer() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - Framebuffer( Framebuffer const & rhs ) = default; - Framebuffer & operator=( Framebuffer const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - Framebuffer( Framebuffer && rhs ) = default; - Framebuffer & operator=( Framebuffer && rhs ) = default; -#else - Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT : m_framebuffer( exchange( rhs.m_framebuffer, {} ) ) {} - - Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT - { - m_framebuffer = exchange( rhs.m_framebuffer, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR Framebuffer( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Framebuffer( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT : m_framebuffer( framebuffer ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - Framebuffer & operator=( VkFramebuffer framebuffer ) VULKAN_HPP_NOEXCEPT - { - m_framebuffer = framebuffer; - return *this; - } -#endif - - Framebuffer & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_framebuffer = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkFramebuffer() const VULKAN_HPP_NOEXCEPT - { - return m_framebuffer; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_framebuffer != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_framebuffer == VK_NULL_HANDLE; - } - - private: - VkFramebuffer m_framebuffer = {}; - }; - - template <> - struct CppType - { - using Type = Framebuffer; - }; - - template <> - struct CppType - { - using Type = Framebuffer; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Framebuffer; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutEXT.html - class IndirectCommandsLayoutEXT - { - public: - using CType = VkIndirectCommandsLayoutEXT; - using NativeType = VkIndirectCommandsLayoutEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - IndirectCommandsLayoutEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT const & rhs ) = default; - IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) = default; - IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) = default; -#else - IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_indirectCommandsLayoutEXT( exchange( rhs.m_indirectCommandsLayoutEXT, {} ) ) - { - } - - IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - m_indirectCommandsLayoutEXT = exchange( rhs.m_indirectCommandsLayoutEXT, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutEXT( VkIndirectCommandsLayoutEXT indirectCommandsLayoutEXT ) VULKAN_HPP_NOEXCEPT - : m_indirectCommandsLayoutEXT( indirectCommandsLayoutEXT ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - IndirectCommandsLayoutEXT & operator=( VkIndirectCommandsLayoutEXT indirectCommandsLayoutEXT ) VULKAN_HPP_NOEXCEPT - { - m_indirectCommandsLayoutEXT = indirectCommandsLayoutEXT; - return *this; - } -#endif - - IndirectCommandsLayoutEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_indirectCommandsLayoutEXT = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutEXT() const VULKAN_HPP_NOEXCEPT - { - return m_indirectCommandsLayoutEXT; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_indirectCommandsLayoutEXT != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_indirectCommandsLayoutEXT == VK_NULL_HANDLE; - } - - private: - VkIndirectCommandsLayoutEXT m_indirectCommandsLayoutEXT = {}; - }; - - template <> - struct CppType - { - using Type = IndirectCommandsLayoutEXT; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = IndirectCommandsLayoutEXT; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutNV.html - class IndirectCommandsLayoutNV - { - public: - using CType = VkIndirectCommandsLayoutNV; - using NativeType = VkIndirectCommandsLayoutNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - IndirectCommandsLayoutNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & rhs ) = default; - IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) = default; - IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) = default; -#else - IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT - : m_indirectCommandsLayoutNV( exchange( rhs.m_indirectCommandsLayoutNV, {} ) ) - { - } - - IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT - { - m_indirectCommandsLayoutNV = exchange( rhs.m_indirectCommandsLayoutNV, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT IndirectCommandsLayoutNV( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT - : m_indirectCommandsLayoutNV( indirectCommandsLayoutNV ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - IndirectCommandsLayoutNV & operator=( VkIndirectCommandsLayoutNV indirectCommandsLayoutNV ) VULKAN_HPP_NOEXCEPT - { - m_indirectCommandsLayoutNV = indirectCommandsLayoutNV; - return *this; - } -#endif - - IndirectCommandsLayoutNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_indirectCommandsLayoutNV = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT - { - return m_indirectCommandsLayoutNV; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_indirectCommandsLayoutNV != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_indirectCommandsLayoutNV == VK_NULL_HANDLE; - } - - private: - VkIndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {}; - }; - - template <> - struct CppType - { - using Type = IndirectCommandsLayoutNV; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = IndirectCommandsLayoutNV; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetEXT.html - class IndirectExecutionSetEXT - { - public: - using CType = VkIndirectExecutionSetEXT; - using NativeType = VkIndirectExecutionSetEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectExecutionSetEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - IndirectExecutionSetEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - IndirectExecutionSetEXT( IndirectExecutionSetEXT const & rhs ) = default; - IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) = default; - IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) = default; -#else - IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_indirectExecutionSetEXT( exchange( rhs.m_indirectExecutionSetEXT, {} ) ) - { - } - - IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - m_indirectExecutionSetEXT = exchange( rhs.m_indirectExecutionSetEXT, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR IndirectExecutionSetEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT IndirectExecutionSetEXT( VkIndirectExecutionSetEXT indirectExecutionSetEXT ) VULKAN_HPP_NOEXCEPT - : m_indirectExecutionSetEXT( indirectExecutionSetEXT ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - IndirectExecutionSetEXT & operator=( VkIndirectExecutionSetEXT indirectExecutionSetEXT ) VULKAN_HPP_NOEXCEPT - { - m_indirectExecutionSetEXT = indirectExecutionSetEXT; - return *this; - } -#endif - - IndirectExecutionSetEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_indirectExecutionSetEXT = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkIndirectExecutionSetEXT() const VULKAN_HPP_NOEXCEPT - { - return m_indirectExecutionSetEXT; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_indirectExecutionSetEXT != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_indirectExecutionSetEXT == VK_NULL_HANDLE; - } - - private: - VkIndirectExecutionSetEXT m_indirectExecutionSetEXT = {}; - }; - - template <> - struct CppType - { - using Type = IndirectExecutionSetEXT; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = IndirectExecutionSetEXT; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlot.html - class PrivateDataSlot - { - public: - using CType = VkPrivateDataSlot; - using NativeType = VkPrivateDataSlot; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePrivateDataSlot; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - PrivateDataSlot() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - PrivateDataSlot( PrivateDataSlot const & rhs ) = default; - PrivateDataSlot & operator=( PrivateDataSlot const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - PrivateDataSlot( PrivateDataSlot && rhs ) = default; - PrivateDataSlot & operator=( PrivateDataSlot && rhs ) = default; -#else - PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( exchange( rhs.m_privateDataSlot, {} ) ) {} - - PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT - { - m_privateDataSlot = exchange( rhs.m_privateDataSlot, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR PrivateDataSlot( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT PrivateDataSlot( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT : m_privateDataSlot( privateDataSlot ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - PrivateDataSlot & operator=( VkPrivateDataSlot privateDataSlot ) VULKAN_HPP_NOEXCEPT - { - m_privateDataSlot = privateDataSlot; - return *this; - } -#endif - - PrivateDataSlot & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_privateDataSlot = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPrivateDataSlot() const VULKAN_HPP_NOEXCEPT - { - return m_privateDataSlot; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_privateDataSlot != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_privateDataSlot == VK_NULL_HANDLE; - } - - private: - VkPrivateDataSlot m_privateDataSlot = {}; - }; - - template <> - struct CppType - { - using Type = PrivateDataSlot; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = PrivateDataSlot; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - using PrivateDataSlotEXT = PrivateDataSlot; - - // wrapper class for handle VkRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPass.html - class RenderPass - { - public: - using CType = VkRenderPass; - using NativeType = VkRenderPass; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eRenderPass; - - public: - RenderPass() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - RenderPass( RenderPass const & rhs ) = default; - RenderPass & operator=( RenderPass const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - RenderPass( RenderPass && rhs ) = default; - RenderPass & operator=( RenderPass && rhs ) = default; -#else - RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT : m_renderPass( exchange( rhs.m_renderPass, {} ) ) {} - - RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT - { - m_renderPass = exchange( rhs.m_renderPass, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR RenderPass( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT RenderPass( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT : m_renderPass( renderPass ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - RenderPass & operator=( VkRenderPass renderPass ) VULKAN_HPP_NOEXCEPT - { - m_renderPass = renderPass; - return *this; - } -#endif - - RenderPass & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_renderPass = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkRenderPass() const VULKAN_HPP_NOEXCEPT - { - return m_renderPass; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_renderPass != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_renderPass == VK_NULL_HANDLE; - } - - private: - VkRenderPass m_renderPass = {}; - }; - - template <> - struct CppType - { - using Type = RenderPass; - }; - - template <> - struct CppType - { - using Type = RenderPass; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = RenderPass; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampler.html - class Sampler - { - public: - using CType = VkSampler; - using NativeType = VkSampler; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSampler; - - public: - Sampler() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - Sampler( Sampler const & rhs ) = default; - Sampler & operator=( Sampler const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - Sampler( Sampler && rhs ) = default; - Sampler & operator=( Sampler && rhs ) = default; -#else - Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT : m_sampler( exchange( rhs.m_sampler, {} ) ) {} - - Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT - { - m_sampler = exchange( rhs.m_sampler, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR Sampler( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT Sampler( VkSampler sampler ) VULKAN_HPP_NOEXCEPT : m_sampler( sampler ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - Sampler & operator=( VkSampler sampler ) VULKAN_HPP_NOEXCEPT - { - m_sampler = sampler; - return *this; - } -#endif - - Sampler & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_sampler = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSampler() const VULKAN_HPP_NOEXCEPT - { - return m_sampler; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_sampler != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_sampler == VK_NULL_HANDLE; - } - - private: - VkSampler m_sampler = {}; - }; - - template <> - struct CppType - { - using Type = Sampler; - }; - - template <> - struct CppType - { - using Type = Sampler; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Sampler; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkSamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversion.html - class SamplerYcbcrConversion - { - public: - using CType = VkSamplerYcbcrConversion; - using NativeType = VkSamplerYcbcrConversion; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSamplerYcbcrConversion; - - public: - SamplerYcbcrConversion() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - SamplerYcbcrConversion( SamplerYcbcrConversion const & rhs ) = default; - SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) = default; - SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) = default; -#else - SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT : m_samplerYcbcrConversion( exchange( rhs.m_samplerYcbcrConversion, {} ) ) {} - - SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT - { - m_samplerYcbcrConversion = exchange( rhs.m_samplerYcbcrConversion, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversion( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT SamplerYcbcrConversion( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT - : m_samplerYcbcrConversion( samplerYcbcrConversion ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - SamplerYcbcrConversion & operator=( VkSamplerYcbcrConversion samplerYcbcrConversion ) VULKAN_HPP_NOEXCEPT - { - m_samplerYcbcrConversion = samplerYcbcrConversion; - return *this; - } -#endif - - SamplerYcbcrConversion & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_samplerYcbcrConversion = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkSamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT - { - return m_samplerYcbcrConversion; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_samplerYcbcrConversion != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_samplerYcbcrConversion == VK_NULL_HANDLE; - } - - private: - VkSamplerYcbcrConversion m_samplerYcbcrConversion = {}; - }; - - template <> - struct CppType - { - using Type = SamplerYcbcrConversion; - }; - - template <> - struct CppType - { - using Type = SamplerYcbcrConversion; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = SamplerYcbcrConversion; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; - - // wrapper class for handle VkShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModule.html - class ShaderModule - { - public: - using CType = VkShaderModule; - using NativeType = VkShaderModule; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eShaderModule; - - public: - ShaderModule() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - ShaderModule( ShaderModule const & rhs ) = default; - ShaderModule & operator=( ShaderModule const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - ShaderModule( ShaderModule && rhs ) = default; - ShaderModule & operator=( ShaderModule && rhs ) = default; -#else - ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT : m_shaderModule( exchange( rhs.m_shaderModule, {} ) ) {} - - ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT - { - m_shaderModule = exchange( rhs.m_shaderModule, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR ShaderModule( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ShaderModule( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT : m_shaderModule( shaderModule ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - ShaderModule & operator=( VkShaderModule shaderModule ) VULKAN_HPP_NOEXCEPT - { - m_shaderModule = shaderModule; - return *this; - } -#endif - - ShaderModule & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_shaderModule = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderModule() const VULKAN_HPP_NOEXCEPT - { - return m_shaderModule; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_shaderModule != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_shaderModule == VK_NULL_HANDLE; - } - - private: - VkShaderModule m_shaderModule = {}; - }; - - template <> - struct CppType - { - using Type = ShaderModule; - }; - - template <> - struct CppType - { - using Type = ShaderModule; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = ShaderModule; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorARM.html - class TensorARM - { - public: - using CType = VkTensorARM; - using NativeType = VkTensorARM; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorARM; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - TensorARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - TensorARM( TensorARM const & rhs ) = default; - TensorARM & operator=( TensorARM const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - TensorARM( TensorARM && rhs ) = default; - TensorARM & operator=( TensorARM && rhs ) = default; -#else - TensorARM( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT : m_tensorARM( exchange( rhs.m_tensorARM, {} ) ) {} - - TensorARM & operator=( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT - { - m_tensorARM = exchange( rhs.m_tensorARM, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR TensorARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT TensorARM( VkTensorARM tensorARM ) VULKAN_HPP_NOEXCEPT : m_tensorARM( tensorARM ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - TensorARM & operator=( VkTensorARM tensorARM ) VULKAN_HPP_NOEXCEPT - { - m_tensorARM = tensorARM; - return *this; - } -#endif - - TensorARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_tensorARM = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkTensorARM() const VULKAN_HPP_NOEXCEPT - { - return m_tensorARM; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_tensorARM != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_tensorARM == VK_NULL_HANDLE; - } - - private: - VkTensorARM m_tensorARM = {}; - }; - - template <> - struct CppType - { - using Type = TensorARM; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = TensorARM; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewARM.html - class TensorViewARM - { - public: - using CType = VkTensorViewARM; - using NativeType = VkTensorViewARM; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorViewARM; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - TensorViewARM() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - TensorViewARM( TensorViewARM const & rhs ) = default; - TensorViewARM & operator=( TensorViewARM const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - TensorViewARM( TensorViewARM && rhs ) = default; - TensorViewARM & operator=( TensorViewARM && rhs ) = default; -#else - TensorViewARM( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT : m_tensorViewARM( exchange( rhs.m_tensorViewARM, {} ) ) {} - - TensorViewARM & operator=( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT - { - m_tensorViewARM = exchange( rhs.m_tensorViewARM, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR TensorViewARM( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT TensorViewARM( VkTensorViewARM tensorViewARM ) VULKAN_HPP_NOEXCEPT : m_tensorViewARM( tensorViewARM ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - TensorViewARM & operator=( VkTensorViewARM tensorViewARM ) VULKAN_HPP_NOEXCEPT - { - m_tensorViewARM = tensorViewARM; - return *this; - } -#endif - - TensorViewARM & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_tensorViewARM = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkTensorViewARM() const VULKAN_HPP_NOEXCEPT - { - return m_tensorViewARM; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_tensorViewARM != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_tensorViewARM == VK_NULL_HANDLE; - } - - private: - VkTensorViewARM m_tensorViewARM = {}; - }; - - template <> - struct CppType - { - using Type = TensorViewARM; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = TensorViewARM; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheEXT.html - class ValidationCacheEXT - { - public: - using CType = VkValidationCacheEXT; - using NativeType = VkValidationCacheEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eValidationCacheEXT; - - public: - ValidationCacheEXT() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - ValidationCacheEXT( ValidationCacheEXT const & rhs ) = default; - ValidationCacheEXT & operator=( ValidationCacheEXT const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - ValidationCacheEXT( ValidationCacheEXT && rhs ) = default; - ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) = default; -#else - ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( exchange( rhs.m_validationCacheEXT, {} ) ) {} - - ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - m_validationCacheEXT = exchange( rhs.m_validationCacheEXT, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR ValidationCacheEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT ValidationCacheEXT( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT : m_validationCacheEXT( validationCacheEXT ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - ValidationCacheEXT & operator=( VkValidationCacheEXT validationCacheEXT ) VULKAN_HPP_NOEXCEPT - { - m_validationCacheEXT = validationCacheEXT; - return *this; - } -#endif - - ValidationCacheEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_validationCacheEXT = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkValidationCacheEXT() const VULKAN_HPP_NOEXCEPT - { - return m_validationCacheEXT; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_validationCacheEXT != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_validationCacheEXT == VK_NULL_HANDLE; - } - - private: - VkValidationCacheEXT m_validationCacheEXT = {}; - }; - - template <> - struct CppType - { - using Type = ValidationCacheEXT; - }; - - template <> - struct CppType - { - using Type = ValidationCacheEXT; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = ValidationCacheEXT; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersKHR.html - class VideoSessionParametersKHR - { - public: - using CType = VkVideoSessionParametersKHR; - using NativeType = VkVideoSessionParametersKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionParametersKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - VideoSessionParametersKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - VideoSessionParametersKHR( VideoSessionParametersKHR const & rhs ) = default; - VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) = default; - VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) = default; -#else - VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_videoSessionParametersKHR( exchange( rhs.m_videoSessionParametersKHR, {} ) ) - { - } - - VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - m_videoSessionParametersKHR = exchange( rhs.m_videoSessionParametersKHR, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR VideoSessionParametersKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT VideoSessionParametersKHR( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT - : m_videoSessionParametersKHR( videoSessionParametersKHR ) - { - } - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - VideoSessionParametersKHR & operator=( VkVideoSessionParametersKHR videoSessionParametersKHR ) VULKAN_HPP_NOEXCEPT - { - m_videoSessionParametersKHR = videoSessionParametersKHR; - return *this; - } -#endif - - VideoSessionParametersKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_videoSessionParametersKHR = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkVideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT - { - return m_videoSessionParametersKHR; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_videoSessionParametersKHR != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_videoSessionParametersKHR == VK_NULL_HANDLE; - } - - private: - VkVideoSessionParametersKHR m_videoSessionParametersKHR = {}; - }; - - template <> - struct CppType - { - using Type = VideoSessionParametersKHR; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = VideoSessionParametersKHR; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryKHR.html - class PipelineBinaryKHR - { - public: - using CType = VkPipelineBinaryKHR; - using NativeType = VkPipelineBinaryKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineBinaryKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - PipelineBinaryKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - PipelineBinaryKHR( PipelineBinaryKHR const & rhs ) = default; - PipelineBinaryKHR & operator=( PipelineBinaryKHR const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - PipelineBinaryKHR( PipelineBinaryKHR && rhs ) = default; - PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) = default; -#else - PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( exchange( rhs.m_pipelineBinaryKHR, {} ) ) {} - - PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - m_pipelineBinaryKHR = exchange( rhs.m_pipelineBinaryKHR, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR PipelineBinaryKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT PipelineBinaryKHR( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT : m_pipelineBinaryKHR( pipelineBinaryKHR ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - PipelineBinaryKHR & operator=( VkPipelineBinaryKHR pipelineBinaryKHR ) VULKAN_HPP_NOEXCEPT - { - m_pipelineBinaryKHR = pipelineBinaryKHR; - return *this; - } -#endif - - PipelineBinaryKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_pipelineBinaryKHR = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkPipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineBinaryKHR; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineBinaryKHR != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineBinaryKHR == VK_NULL_HANDLE; - } - - private: - VkPipelineBinaryKHR m_pipelineBinaryKHR = {}; - }; - - template <> - struct CppType - { - using Type = PipelineBinaryKHR; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = PipelineBinaryKHR; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueue.html - class Queue - { - public: - using CType = VkQueue; - using NativeType = VkQueue; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueue; - - public: - Queue() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - Queue( Queue const & rhs ) = default; - Queue & operator=( Queue const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - Queue( Queue && rhs ) = default; - Queue & operator=( Queue && rhs ) = default; -#else - Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT : m_queue( exchange( rhs.m_queue, {} ) ) {} - - Queue & operator=( Queue && rhs ) VULKAN_HPP_NOEXCEPT - { - m_queue = exchange( rhs.m_queue, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR Queue( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - Queue( VkQueue queue ) VULKAN_HPP_NOEXCEPT : m_queue( queue ) {} - - Queue & operator=( VkQueue queue ) VULKAN_HPP_NOEXCEPT - { - m_queue = queue; - return *this; - } - - Queue & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_queue = {}; - return *this; - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html - template ::type = true> - VULKAN_HPP_NODISCARD Result submit( uint32_t submitCount, - const SubmitInfo * pSubmits, - Fence fence, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type submit( ArrayProxy const & submits, - Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html - template ::type = true> - VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindSparse( uint32_t bindInfoCount, - const BindSparseInfo * pBindInfo, - Fence fence, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindSparse( ArrayProxy const & bindInfo, - Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_3 === - - // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html - template ::type = true> - VULKAN_HPP_NODISCARD Result submit2( uint32_t submitCount, - const SubmitInfo2 * pSubmits, - Fence fence, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type submit2( ArrayProxy const & submits, - Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_swapchain === - - // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR * pPresentInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR & presentInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_debug_utils === - - // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html - template ::type = true> - void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html - template ::type = true> - void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html - template ::type = true> - void endDebugUtilsLabelEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html - template ::type = true> - void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT * pLabelInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html - template ::type = true> - void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_device_diagnostic_checkpoints === - - // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html - template ::type = true> - void getCheckpointDataNV( uint32_t * pCheckpointDataCount, - CheckpointDataNV * pCheckpointData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getCheckpointDataNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getCheckpointDataNV( CheckpointDataNVAllocator const & checkpointDataNVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html - template ::type = true> - void getCheckpointData2NV( uint32_t * pCheckpointDataCount, - CheckpointData2NV * pCheckpointData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getCheckpointData2NV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getCheckpointData2NV( CheckpointData2NVAllocator const & checkpointData2NVAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_INTEL_performance_query === - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - setPerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - //=== VK_KHR_synchronization2 === - - // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result submit2KHR( uint32_t submitCount, - const SubmitInfo2 * pSubmits, - Fence fence, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - submit2KHR( ArrayProxy const & submits, - Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_low_latency2 === - - // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html - template ::type = true> - void notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV * pQueueTypeInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html - template ::type = true> - void notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - operator VkQueue() const VULKAN_HPP_NOEXCEPT - { - return m_queue; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_queue != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_queue == VK_NULL_HANDLE; - } - - private: - VkQueue m_queue = {}; - }; - - template <> - struct CppType - { - using Type = Queue; - }; - - template <> - struct CppType - { - using Type = Queue; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Queue; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDevice.html - class Device - { - public: - using CType = VkDevice; - using NativeType = VkDevice; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDevice; - - public: - Device() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - Device( Device const & rhs ) = default; - Device & operator=( Device const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - Device( Device && rhs ) = default; - Device & operator=( Device && rhs ) = default; -#else - Device( Device && rhs ) VULKAN_HPP_NOEXCEPT : m_device( exchange( rhs.m_device, {} ) ) {} - - Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT - { - m_device = exchange( rhs.m_device, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR Device( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - Device( VkDevice device ) VULKAN_HPP_NOEXCEPT : m_device( device ) {} - - Device & operator=( VkDevice device ) VULKAN_HPP_NOEXCEPT - { - m_device = device; - return *this; - } - - Device & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_device = {}; - return *this; - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html - template ::type = true> - PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html - template ::type = true> - PFN_VoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html - template ::type = true> - void destroy( const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDevice.html - template ::type = true> - void destroy( Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html - template ::type = true> - void getQueue( uint32_t queueFamilyIndex, - uint32_t queueIndex, - Queue * pQueue, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html - template ::type = true> - VULKAN_HPP_NODISCARD Queue getQueue( uint32_t queueFamilyIndex, - uint32_t queueIndex, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html - template ::type = true> - VULKAN_HPP_NODISCARD Result waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type waitIdle( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html - template ::type = true> - VULKAN_HPP_NODISCARD Result allocateMemory( const MemoryAllocateInfo * pAllocateInfo, - const AllocationCallbacks * pAllocator, - DeviceMemory * pMemory, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - allocateMemory( const MemoryAllocateInfo & allocateInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - allocateMemoryUnique( const MemoryAllocateInfo & allocateInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html - template ::type = true> - void freeMemory( DeviceMemory memory, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html - template ::type = true> - void freeMemory( DeviceMemory memory VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html - template ::type = true> - void( free )( DeviceMemory memory, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeMemory.html - template ::type = true> - void( free )( DeviceMemory memory, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html - template ::type = true> - VULKAN_HPP_NODISCARD Result mapMemory( DeviceMemory memory, - DeviceSize offset, - DeviceSize size, - MemoryMapFlags flags, - void ** ppData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type mapMemory( DeviceMemory memory, - DeviceSize offset, - DeviceSize size, - MemoryMapFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html - template ::type = true> - void unmapMemory( DeviceMemory memory, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html - template ::type = true> - VULKAN_HPP_NODISCARD Result flushMappedMemoryRanges( uint32_t memoryRangeCount, - const MappedMemoryRange * pMemoryRanges, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - flushMappedMemoryRanges( ArrayProxy const & memoryRanges, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkInvalidateMappedMemoryRanges, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html - template ::type = true> - VULKAN_HPP_NODISCARD Result invalidateMappedMemoryRanges( uint32_t memoryRangeCount, - const MappedMemoryRange * pMemoryRanges, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkInvalidateMappedMemoryRanges, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - invalidateMappedMemoryRanges( ArrayProxy const & memoryRanges, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html - template ::type = true> - void getMemoryCommitment( DeviceMemory memory, - DeviceSize * pCommittedMemoryInBytes, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html - template ::type = true> - VULKAN_HPP_NODISCARD DeviceSize getMemoryCommitment( DeviceMemory memory, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindBufferMemory( Buffer buffer, - DeviceMemory memory, - DeviceSize memoryOffset, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindBufferMemory( Buffer buffer, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindImageMemory( Image image, - DeviceMemory memory, - DeviceSize memoryOffset, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindImageMemory( Image image, DeviceMemory memory, DeviceSize memoryOffset, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html - template ::type = true> - void getBufferMemoryRequirements( Buffer buffer, - MemoryRequirements * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements - getBufferMemoryRequirements( Buffer buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html - template ::type = true> - void getImageMemoryRequirements( Image image, - MemoryRequirements * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements getImageMemoryRequirements( Image image, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html - template ::type = true> - void getImageSparseMemoryRequirements( Image image, - uint32_t * pSparseMemoryRequirementCount, - SparseImageMemoryRequirements * pSparseMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html - template < - typename SparseImageMemoryRequirementsAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirements( Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html - template < - typename SparseImageMemoryRequirementsAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirements( Image image, - SparseImageMemoryRequirementsAllocator const & sparseImageMemoryRequirementsAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createFence( const FenceCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Fence * pFence, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createFence( const FenceCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createFenceUnique( const FenceCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html - template ::type = true> - void destroyFence( Fence fence, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html - template ::type = true> - void destroyFence( Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html - template ::type = true> - void destroy( Fence fence, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFence.html - template ::type = true> - void destroy( Fence fence, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html - template ::type = true> - VULKAN_HPP_NODISCARD Result resetFences( uint32_t fenceCount, - const Fence * pFences, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - resetFences( ArrayProxy const & fences, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getFenceStatus( Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getFenceStatus( Fence fence, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html - template ::type = true> - VULKAN_HPP_NODISCARD Result waitForFences( uint32_t fenceCount, - const Fence * pFences, - Bool32 waitAll, - uint64_t timeout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html - template ::type = true> - VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy const & fences, - Bool32 waitAll, - uint64_t timeout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createSemaphore( const SemaphoreCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Semaphore * pSemaphore, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSemaphore( const SemaphoreCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createSemaphoreUnique( const SemaphoreCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html - template ::type = true> - void destroySemaphore( Semaphore semaphore, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html - template ::type = true> - void destroySemaphore( Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html - template ::type = true> - void destroy( Semaphore semaphore, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySemaphore.html - template ::type = true> - void destroy( Semaphore semaphore, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createQueryPool( const QueryPoolCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - QueryPool * pQueryPool, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createQueryPool( const QueryPoolCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createQueryPoolUnique( const QueryPoolCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html - template ::type = true> - void destroyQueryPool( QueryPool queryPool, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html - template ::type = true> - void destroyQueryPool( QueryPool queryPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html - template ::type = true> - void destroy( QueryPool queryPool, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyQueryPool.html - template ::type = true> - void destroy( QueryPool queryPool, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getQueryPoolResults( QueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - size_t dataSize, - void * pData, - DeviceSize stride, - QueryResultFlags flags, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - getQueryPoolResults( QueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - size_t dataSize, - DeviceSize stride, - QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue getQueryPoolResult( QueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - DeviceSize stride, - QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createBuffer( const BufferCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Buffer * pBuffer, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createBuffer( const BufferCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createBufferUnique( const BufferCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html - template ::type = true> - void destroyBuffer( Buffer buffer, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html - template ::type = true> - void destroyBuffer( Buffer buffer VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html - template ::type = true> - void - destroy( Buffer buffer, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBuffer.html - template ::type = true> - void destroy( Buffer buffer, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createImage( const ImageCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Image * pImage, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createImage( const ImageCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createImageUnique( const ImageCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html - template ::type = true> - void destroyImage( Image image, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html - template ::type = true> - void destroyImage( Image image VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html - template ::type = true> - void destroy( Image image, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImage.html - template ::type = true> - void destroy( Image image, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html - template ::type = true> - void getImageSubresourceLayout( Image image, - const ImageSubresource * pSubresource, - SubresourceLayout * pLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html - template ::type = true> - VULKAN_HPP_NODISCARD SubresourceLayout getImageSubresourceLayout( Image image, - const ImageSubresource & subresource, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createImageView( const ImageViewCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - ImageView * pView, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createImageView( const ImageViewCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createImageViewUnique( const ImageViewCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html - template ::type = true> - void destroyImageView( ImageView imageView, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html - template ::type = true> - void destroyImageView( ImageView imageView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html - template ::type = true> - void destroy( ImageView imageView, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyImageView.html - template ::type = true> - void destroy( ImageView imageView, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createCommandPool( const CommandPoolCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - CommandPool * pCommandPool, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createCommandPool( const CommandPoolCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createCommandPoolUnique( const CommandPoolCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html - template ::type = true> - void destroyCommandPool( CommandPool commandPool, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html - template ::type = true> - void destroyCommandPool( CommandPool commandPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html - template ::type = true> - void destroy( CommandPool commandPool, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCommandPool.html - template ::type = true> - void destroy( CommandPool commandPool, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html - template ::type = true> - VULKAN_HPP_NODISCARD Result resetCommandPool( CommandPool commandPool, - CommandPoolResetFlags flags, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - resetCommandPool( CommandPool commandPool, - CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - template ::type = true> - VULKAN_HPP_NODISCARD Result allocateCommandBuffers( const CommandBufferAllocateInfo * pAllocateInfo, - CommandBuffer * pCommandBuffers, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - allocateCommandBuffers( const CommandBufferAllocateInfo & allocateInfo, - CommandBufferAllocator const & commandBufferAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, CommandBufferAllocator>>::type - allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, CommandBufferAllocator>>::type - allocateCommandBuffersUnique( const CommandBufferAllocateInfo & allocateInfo, - CommandBufferAllocator const & commandBufferAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html - template ::type = true> - void freeCommandBuffers( CommandPool commandPool, - uint32_t commandBufferCount, - const CommandBuffer * pCommandBuffers, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html - template ::type = true> - void freeCommandBuffers( CommandPool commandPool, - ArrayProxy const & commandBuffers, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html - template ::type = true> - void( free )( CommandPool commandPool, - uint32_t commandBufferCount, - const CommandBuffer * pCommandBuffers, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeCommandBuffers.html - template ::type = true> - void( free )( CommandPool commandPool, - ArrayProxy const & commandBuffers, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createEvent( const EventCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Event * pEvent, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createEvent( const EventCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createEventUnique( const EventCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html - template ::type = true> - void destroyEvent( Event event, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html - template ::type = true> - void destroyEvent( Event event VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html - template ::type = true> - void destroy( Event event, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyEvent.html - template ::type = true> - void destroy( Event event, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getEventStatus( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getEventStatus( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setEvent( Event event, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html - template ::type = true> - VULKAN_HPP_NODISCARD Result resetEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - resetEvent( Event event, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createBufferView( const BufferViewCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - BufferView * pView, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createBufferView( const BufferViewCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createBufferViewUnique( const BufferViewCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html - template ::type = true> - void destroyBufferView( BufferView bufferView, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html - template ::type = true> - void destroyBufferView( BufferView bufferView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html - template ::type = true> - void destroy( BufferView bufferView, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferView.html - template ::type = true> - void destroy( BufferView bufferView, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createShaderModule( const ShaderModuleCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - ShaderModule * pShaderModule, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createShaderModule( const ShaderModuleCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createShaderModuleUnique( const ShaderModuleCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html - template ::type = true> - void destroyShaderModule( ShaderModule shaderModule, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html - template ::type = true> - void destroyShaderModule( ShaderModule shaderModule VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html - template ::type = true> - void destroy( ShaderModule shaderModule, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderModule.html - template ::type = true> - void destroy( ShaderModule shaderModule, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createPipelineCache( const PipelineCacheCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - PipelineCache * pPipelineCache, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createPipelineCache( const PipelineCacheCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createPipelineCacheUnique( const PipelineCacheCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html - template ::type = true> - void destroyPipelineCache( PipelineCache pipelineCache, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html - template ::type = true> - void destroyPipelineCache( PipelineCache pipelineCache VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html - template ::type = true> - void destroy( PipelineCache pipelineCache, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineCache.html - template ::type = true> - void destroy( PipelineCache pipelineCache, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getPipelineCacheData( PipelineCache pipelineCache, - size_t * pDataSize, - void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPipelineCacheData( PipelineCache pipelineCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type getPipelineCacheData( - PipelineCache pipelineCache, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html - template ::type = true> - VULKAN_HPP_NODISCARD Result mergePipelineCaches( PipelineCache dstCache, - uint32_t srcCacheCount, - const PipelineCache * pSrcCaches, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type mergePipelineCaches( - PipelineCache dstCache, ArrayProxy const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createComputePipelines( PipelineCache pipelineCache, - uint32_t createInfoCount, - const ComputePipelineCreateInfo * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createComputePipelines( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createComputePipelines( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue createComputePipeline( PipelineCache pipelineCache, - const ComputePipelineCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createComputePipelinesUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createComputePipelinesUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createComputePipelineUnique( PipelineCache pipelineCache, - const ComputePipelineCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html - template ::type = true> - void destroyPipeline( Pipeline pipeline, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html - template ::type = true> - void destroyPipeline( Pipeline pipeline VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html - template ::type = true> - void destroy( Pipeline pipeline, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipeline.html - template ::type = true> - void destroy( Pipeline pipeline, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createPipelineLayout( const PipelineLayoutCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - PipelineLayout * pPipelineLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createPipelineLayout( const PipelineLayoutCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createPipelineLayoutUnique( const PipelineLayoutCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html - template ::type = true> - void destroyPipelineLayout( PipelineLayout pipelineLayout, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html - template ::type = true> - void destroyPipelineLayout( PipelineLayout pipelineLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html - template ::type = true> - void destroy( PipelineLayout pipelineLayout, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineLayout.html - template ::type = true> - void destroy( PipelineLayout pipelineLayout, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createSampler( const SamplerCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Sampler * pSampler, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSampler( const SamplerCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createSamplerUnique( const SamplerCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html - template ::type = true> - void destroySampler( Sampler sampler, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html - template ::type = true> - void destroySampler( Sampler sampler VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html - template ::type = true> - void - destroy( Sampler sampler, const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySampler.html - template ::type = true> - void destroy( Sampler sampler, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - DescriptorSetLayout * pSetLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDescriptorSetLayout( const DescriptorSetLayoutCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDescriptorSetLayoutUnique( const DescriptorSetLayoutCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorSetLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html - template ::type = true> - void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorSetLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html - template ::type = true> - void destroyDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorSetLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html - template ::type = true> - void destroy( DescriptorSetLayout descriptorSetLayout, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorSetLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorSetLayout.html - template ::type = true> - void destroy( DescriptorSetLayout descriptorSetLayout, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDescriptorPool( const DescriptorPoolCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - DescriptorPool * pDescriptorPool, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDescriptorPool( const DescriptorPoolCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDescriptorPoolUnique( const DescriptorPoolCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html - template ::type = true> - void destroyDescriptorPool( DescriptorPool descriptorPool, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html - template ::type = true> - void destroyDescriptorPool( DescriptorPool descriptorPool VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html - template ::type = true> - void destroy( DescriptorPool descriptorPool, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorPool.html - template ::type = true> - void destroy( DescriptorPool descriptorPool, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html - template ::type = true> - VULKAN_HPP_NODISCARD Result resetDescriptorPool( DescriptorPool descriptorPool, - DescriptorPoolResetFlags flags, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - resetDescriptorPool( DescriptorPool descriptorPool, - DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - template ::type = true> - VULKAN_HPP_NODISCARD Result allocateDescriptorSets( const DescriptorSetAllocateInfo * pAllocateInfo, - DescriptorSet * pDescriptorSets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - allocateDescriptorSets( const DescriptorSetAllocateInfo & allocateInfo, - DescriptorSetAllocator const & descriptorSetAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, DescriptorSetAllocator>>::type - allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, DescriptorSetAllocator>>::type - allocateDescriptorSetsUnique( const DescriptorSetAllocateInfo & allocateInfo, - DescriptorSetAllocator const & descriptorSetAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html - template ::type = true> - VULKAN_HPP_NODISCARD Result freeDescriptorSets( DescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const DescriptorSet * pDescriptorSets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - freeDescriptorSets( DescriptorPool descriptorPool, - ArrayProxy const & descriptorSets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html - template ::type = true> - VULKAN_HPP_NODISCARD Result( free )( DescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const DescriptorSet * pDescriptorSets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkFreeDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFreeDescriptorSets.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type( free )( DescriptorPool descriptorPool, - ArrayProxy const & descriptorSets, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html - template ::type = true> - void updateDescriptorSets( uint32_t descriptorWriteCount, - const WriteDescriptorSet * pDescriptorWrites, - uint32_t descriptorCopyCount, - const CopyDescriptorSet * pDescriptorCopies, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html - template ::type = true> - void updateDescriptorSets( ArrayProxy const & descriptorWrites, - ArrayProxy const & descriptorCopies, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createGraphicsPipelines( PipelineCache pipelineCache, - uint32_t createInfoCount, - const GraphicsPipelineCreateInfo * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createGraphicsPipelines( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createGraphicsPipelines( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue createGraphicsPipeline( PipelineCache pipelineCache, - const GraphicsPipelineCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createGraphicsPipelinesUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createGraphicsPipelinesUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createGraphicsPipelineUnique( PipelineCache pipelineCache, - const GraphicsPipelineCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createFramebuffer( const FramebufferCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Framebuffer * pFramebuffer, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createFramebuffer( const FramebufferCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createFramebufferUnique( const FramebufferCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html - template ::type = true> - void destroyFramebuffer( Framebuffer framebuffer, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html - template ::type = true> - void destroyFramebuffer( Framebuffer framebuffer VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html - template ::type = true> - void destroy( Framebuffer framebuffer, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyFramebuffer.html - template ::type = true> - void destroy( Framebuffer framebuffer, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createRenderPass( const RenderPassCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - RenderPass * pRenderPass, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createRenderPass( const RenderPassCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createRenderPassUnique( const RenderPassCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html - template ::type = true> - void destroyRenderPass( RenderPass renderPass, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html - template ::type = true> - void destroyRenderPass( RenderPass renderPass VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html - template ::type = true> - void destroy( RenderPass renderPass, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyRenderPass.html - template ::type = true> - void destroy( RenderPass renderPass, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html - template ::type = true> - void getRenderAreaGranularity( RenderPass renderPass, - Extent2D * pGranularity, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html - template ::type = true> - VULKAN_HPP_NODISCARD Extent2D getRenderAreaGranularity( RenderPass renderPass, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindBufferMemory2( uint32_t bindInfoCount, - const BindBufferMemoryInfo * pBindInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindBufferMemory2( ArrayProxy const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindImageMemory2( uint32_t bindInfoCount, - const BindImageMemoryInfo * pBindInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindImageMemory2( ArrayProxy const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html - template ::type = true> - void getGroupPeerMemoryFeatures( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - PeerMemoryFeatureFlags * pPeerMemoryFeatures, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html - template ::type = true> - VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags - getGroupPeerMemoryFeatures( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html - template ::type = true> - void getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2( - const ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetImageMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html - template ::type = true> - void getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2( - const BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetBufferMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSparseMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html - template ::type = true> - void getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 * pInfo, - uint32_t * pSparseMemoryRequirementCount, - SparseImageMemoryRequirements2 * pSparseMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSparseMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html - template < - typename SparseImageMemoryRequirements2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetImageSparseMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html - template < - typename SparseImageMemoryRequirements2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info, - SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html - template ::type = true> - void trimCommandPool( CommandPool commandPool, - CommandPoolTrimFlags flags, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html - template ::type = true> - void - getQueue2( const DeviceQueueInfo2 * pQueueInfo, Queue * pQueue, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html - template ::type = true> - VULKAN_HPP_NODISCARD Queue getQueue2( const DeviceQueueInfo2 & queueInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - DescriptorUpdateTemplate * pDescriptorUpdateTemplate, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDescriptorUpdateTemplate( const DescriptorUpdateTemplateCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDescriptorUpdateTemplateUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html - template ::type = true> - void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html - template ::type = true> - void destroyDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html - template ::type = true> - void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplate.html - template ::type = true> - void destroy( DescriptorUpdateTemplate descriptorUpdateTemplate, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html - template ::type = true> - void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, - DescriptorUpdateTemplate descriptorUpdateTemplate, - const void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html - template ::type = true> - void updateDescriptorSetWithTemplate( DescriptorSet descriptorSet, - DescriptorUpdateTemplate descriptorUpdateTemplate, - DataType const & data, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDescriptorSetLayoutSupport, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html - template ::type = true> - void getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo * pCreateInfo, - DescriptorSetLayoutSupport * pSupport, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetLayoutSupport, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html - template ::type = true> - VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport getDescriptorSetLayoutSupport( - const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetDescriptorSetLayoutSupport, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateSamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - SamplerYcbcrConversion * pYcbcrConversion, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSamplerYcbcrConversion( const SamplerYcbcrConversionCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createSamplerYcbcrConversionUnique( const SamplerYcbcrConversionCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html - template ::type = true> - void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html - template ::type = true> - void destroySamplerYcbcrConversion( SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html - template ::type = true> - void destroy( SamplerYcbcrConversion ycbcrConversion, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversion.html - template ::type = true> - void destroy( SamplerYcbcrConversion ycbcrConversion, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_2 === - - // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html - template ::type = true> - void resetQueryPool( QueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSemaphoreCounterValue( Semaphore semaphore, - uint64_t * pValue, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreCounterValue( Semaphore semaphore, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html - template ::type = true> - VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo * pWaitInfo, - uint64_t timeout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html - template ::type = true> - VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo & waitInfo, - uint64_t timeout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html - template ::type = true> - VULKAN_HPP_NODISCARD Result signalSemaphore( const SemaphoreSignalInfo * pSignalInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - signalSemaphore( const SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html - template ::type = true> - DeviceAddress getBufferAddress( const BufferDeviceAddressInfo * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html - template ::type = true> - DeviceAddress getBufferAddress( const BufferDeviceAddressInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html - template ::type = true> - uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html - template ::type = true> - uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html - template ::type = true> - uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html - template ::type = true> - uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createRenderPass2( const RenderPassCreateInfo2 * pCreateInfo, - const AllocationCallbacks * pAllocator, - RenderPass * pRenderPass, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createRenderPass2( const RenderPassCreateInfo2 & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createRenderPass2Unique( const RenderPassCreateInfo2 & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_3 === - - // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createPrivateDataSlot( const PrivateDataSlotCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - PrivateDataSlot * pPrivateDataSlot, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createPrivateDataSlot( const PrivateDataSlotCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createPrivateDataSlotUnique( const PrivateDataSlotCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html - template ::type = true> - void destroyPrivateDataSlot( PrivateDataSlot privateDataSlot, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html - template ::type = true> - void destroyPrivateDataSlot( PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html - template ::type = true> - void destroy( PrivateDataSlot privateDataSlot, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlot.html - template ::type = true> - void destroy( PrivateDataSlot privateDataSlot, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setPrivateData( ObjectType objectType, - uint64_t objectHandle, - PrivateDataSlot privateDataSlot, - uint64_t data, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - setPrivateData( ObjectType objectType, - uint64_t objectHandle, - PrivateDataSlot privateDataSlot, - uint64_t data, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html - template ::type = true> - void getPrivateData( ObjectType objectType, - uint64_t objectHandle, - PrivateDataSlot privateDataSlot, - uint64_t * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html - template ::type = true> - VULKAN_HPP_NODISCARD uint64_t getPrivateData( ObjectType objectType, - uint64_t objectHandle, - PrivateDataSlot privateDataSlot, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html - template ::type = true> - void getBufferMemoryRequirements( const DeviceBufferMemoryRequirements * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements( - const DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetDeviceBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html - template ::type = true> - void getImageMemoryRequirements( const DeviceImageMemoryRequirements * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements( - const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetDeviceImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getImageMemoryRequirements( const DeviceImageMemoryRequirements & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html - template ::type = true> - void getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements * pInfo, - uint32_t * pSparseMemoryRequirementCount, - SparseImageMemoryRequirements2 * pSparseMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html - template < - typename SparseImageMemoryRequirements2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html - template < - typename SparseImageMemoryRequirements2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info, - SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_4 === - - // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html - template ::type = true> - VULKAN_HPP_NODISCARD Result mapMemory2( const MemoryMapInfo * pMemoryMapInfo, - void ** ppData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type mapMemory2( const MemoryMapInfo & memoryMapInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html - template ::type = true> - VULKAN_HPP_NODISCARD Result unmapMemory2( const MemoryUnmapInfo * pMemoryUnmapInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageSubresourceLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html - template ::type = true> - void getImageSubresourceLayout( const DeviceImageSubresourceInfo * pInfo, - SubresourceLayout2 * pLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageSubresourceLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html - template ::type = true> - VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout( const DeviceImageSubresourceInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetDeviceImageSubresourceLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getImageSubresourceLayout( const DeviceImageSubresourceInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSubresourceLayout2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html - template ::type = true> - void getImageSubresourceLayout2( Image image, - const ImageSubresource2 * pSubresource, - SubresourceLayout2 * pLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSubresourceLayout2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html - template ::type = true> - VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2( Image image, - const ImageSubresource2 & subresource, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetImageSubresourceLayout2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain getImageSubresourceLayout2( - Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyMemoryToImage( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - copyMemoryToImage( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyImageToMemory( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - copyImageToMemory( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyImageToImage( const CopyImageToImageInfo * pCopyImageToImageInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - copyImageToImage( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html - template ::type = true> - VULKAN_HPP_NODISCARD Result transitionImageLayout( uint32_t transitionCount, - const HostImageLayoutTransitionInfo * pTransitions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - transitionImageLayout( ArrayProxy const & transitions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRenderingAreaGranularity, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html - template ::type = true> - void getRenderingAreaGranularity( const RenderingAreaInfo * pRenderingAreaInfo, - Extent2D * pGranularity, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRenderingAreaGranularity, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html - template ::type = true> - VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularity( const RenderingAreaInfo & renderingAreaInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_swapchain === - - // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createSwapchainKHR( const SwapchainCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SwapchainKHR * pSwapchain, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html - template ::type = true> - void destroySwapchainKHR( SwapchainKHR swapchain, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html - template ::type = true> - void destroySwapchainKHR( SwapchainKHR swapchain VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html - template ::type = true> - void destroy( SwapchainKHR swapchain, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySwapchainKHR.html - template ::type = true> - void destroy( SwapchainKHR swapchain, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSwapchainImagesKHR( SwapchainKHR swapchain, - uint32_t * pSwapchainImageCount, - Image * pSwapchainImages, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSwapchainImagesKHR( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSwapchainImagesKHR( SwapchainKHR swapchain, ImageAllocator const & imageAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result acquireNextImageKHR( SwapchainKHR swapchain, - uint64_t timeout, - Semaphore semaphore, - Fence fence, - uint32_t * pImageIndex, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue acquireNextImageKHR( SwapchainKHR swapchain, - uint64_t timeout, - Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR * pDeviceGroupPresentCapabilities, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getGroupPresentCapabilitiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModesKHR( SurfaceKHR surface, - DeviceGroupPresentModeFlagsKHR * pModes, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getGroupSurfacePresentModesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result acquireNextImage2KHR( const AcquireNextImageInfoKHR * pAcquireInfo, - uint32_t * pImageIndex, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_display_swapchain === - - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createSharedSwapchainsKHR( uint32_t swapchainCount, - const SwapchainCreateInfoKHR * pCreateInfos, - const AllocationCallbacks * pAllocator, - SwapchainKHR * pSwapchains, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createSharedSwapchainsKHR( ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createSharedSwapchainsKHR( ArrayProxy const & createInfos, - Optional allocator, - SwapchainKHRAllocator const & swapchainKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSharedSwapchainKHR( const SwapchainCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, SwapchainKHRAllocator>>::type - createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, SwapchainKHRAllocator>>::type - createSharedSwapchainsKHRUnique( ArrayProxy const & createInfos, - Optional allocator, - SwapchainKHRAllocator const & swapchainKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createSharedSwapchainKHRUnique( const SwapchainCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_debug_marker === - - // wrapper function for command vkDebugMarkerSetObjectTagEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT * pTagInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDebugMarkerSetObjectTagEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDebugMarkerSetObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT * pNameInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDebugMarkerSetObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_video_queue === - - // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createVideoSessionKHR( const VideoSessionCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - VideoSessionKHR * pVideoSession, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createVideoSessionKHR( const VideoSessionCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createVideoSessionKHRUnique( const VideoSessionCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html - template ::type = true> - void destroyVideoSessionKHR( VideoSessionKHR videoSession, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html - template ::type = true> - void destroyVideoSessionKHR( VideoSessionKHR videoSession VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html - template ::type = true> - void destroy( VideoSessionKHR videoSession, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionKHR.html - template ::type = true> - void destroy( VideoSessionKHR videoSession, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, - uint32_t * pMemoryRequirementsCount, - VideoSessionMemoryRequirementsKHR * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getVideoSessionMemoryRequirementsKHR( VideoSessionKHR videoSession, - VideoSessionMemoryRequirementsKHRAllocator const & videoSessionMemoryRequirementsKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindVideoSessionMemoryKHR( VideoSessionKHR videoSession, - uint32_t bindSessionMemoryInfoCount, - const BindVideoSessionMemoryInfoKHR * pBindSessionMemoryInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindVideoSessionMemoryKHR( VideoSessionKHR videoSession, - ArrayProxy const & bindSessionMemoryInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - VideoSessionParametersKHR * pVideoSessionParameters, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createVideoSessionParametersKHR( const VideoSessionParametersCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createVideoSessionParametersKHRUnique( const VideoSessionParametersCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result updateVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, - const VideoSessionParametersUpdateInfoKHR * pUpdateInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - updateVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, - const VideoSessionParametersUpdateInfoKHR & updateInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html - template ::type = true> - void destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html - template ::type = true> - void destroyVideoSessionParametersKHR( VideoSessionParametersKHR videoSessionParameters VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html - template ::type = true> - void destroy( VideoSessionParametersKHR videoSessionParameters, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyVideoSessionParametersKHR.html - template ::type = true> - void destroy( VideoSessionParametersKHR videoSessionParameters, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NVX_binary_import === - - // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createCuModuleNVX( const CuModuleCreateInfoNVX * pCreateInfo, - const AllocationCallbacks * pAllocator, - CuModuleNVX * pModule, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createCuModuleNVX( const CuModuleCreateInfoNVX & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createCuModuleNVXUnique( const CuModuleCreateInfoNVX & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createCuFunctionNVX( const CuFunctionCreateInfoNVX * pCreateInfo, - const AllocationCallbacks * pAllocator, - CuFunctionNVX * pFunction, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createCuFunctionNVX( const CuFunctionCreateInfoNVX & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createCuFunctionNVXUnique( const CuFunctionCreateInfoNVX & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html - template ::type = true> - void destroyCuModuleNVX( CuModuleNVX module, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html - template ::type = true> - void destroyCuModuleNVX( CuModuleNVX module, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html - template ::type = true> - void destroy( CuModuleNVX module, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuModuleNVX.html - template ::type = true> - void destroy( CuModuleNVX module, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html - template ::type = true> - void destroyCuFunctionNVX( CuFunctionNVX function, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html - template ::type = true> - void destroyCuFunctionNVX( CuFunctionNVX function, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html - template ::type = true> - void destroy( CuFunctionNVX function, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCuFunctionNVX.html - template ::type = true> - void destroy( CuFunctionNVX function, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NVX_image_view_handle === - - // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html - template ::type = true> - uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html - template ::type = true> - uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html - template ::type = true> - uint64_t getImageViewHandle64NVX( const ImageViewHandleInfoNVX * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html - template ::type = true> - uint64_t getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getImageViewAddressNVX( ImageView imageView, - ImageViewAddressPropertiesNVX * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageViewAddressNVX( ImageView imageView, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html - template ::type = true> - uint64_t getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex, - uint64_t samplerIndex, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_AMD_shader_info === - - // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getShaderInfoAMD( Pipeline pipeline, - ShaderStageFlagBits shaderStage, - ShaderInfoTypeAMD infoType, - size_t * pInfoSize, - void * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type getShaderInfoAMD( - Pipeline pipeline, ShaderStageFlagBits shaderStage, ShaderInfoTypeAMD infoType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getShaderInfoAMD( Pipeline pipeline, - ShaderStageFlagBits shaderStage, - ShaderInfoTypeAMD infoType, - Uint8_tAllocator const & uint8_tAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - - // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryWin32HandleNV( DeviceMemory memory, - ExternalMemoryHandleTypeFlagsNV handleType, - HANDLE * pHandle, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryWin32HandleNV( DeviceMemory memory, - ExternalMemoryHandleTypeFlagsNV handleType, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_device_group === - - // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html - template ::type = true> - void getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - PeerMemoryFeatureFlags * pPeerMemoryFeatures, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags - getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_maintenance1 === - - // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html - template ::type = true> - void trimCommandPoolKHR( CommandPool commandPool, - CommandPoolTrimFlags flags, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - - // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR * pGetWin32HandleInfo, - HANDLE * pHandle, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, - HANDLE handle, - MemoryWin32HandlePropertiesKHR * pMemoryWin32HandleProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryWin32HandlePropertiesKHR( - ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - - // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryFdKHR( const MemoryGetFdInfoKHR * pGetFdInfo, - int * pFd, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, - int fd, - MemoryFdPropertiesKHR * pMemoryFdProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - - // wrapper function for command vkImportSemaphoreWin32HandleKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR * pImportSemaphoreWin32HandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkImportSemaphoreWin32HandleKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSemaphoreWin32HandleKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR * pGetWin32HandleInfo, - HANDLE * pHandle, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSemaphoreWin32HandleKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - - // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR * pImportSemaphoreFdInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR * pGetFdInfo, - int * pFd, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_descriptor_update_template === - - // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - DescriptorUpdateTemplate * pDescriptorUpdateTemplate, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDescriptorUpdateTemplateKHR( const DescriptorUpdateTemplateCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDescriptorUpdateTemplateKHRUnique( const DescriptorUpdateTemplateCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html - template ::type = true> - void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html - template ::type = true> - void destroyDescriptorUpdateTemplateKHR( DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html - template ::type = true> - void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, - DescriptorUpdateTemplate descriptorUpdateTemplate, - const void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html - template ::type = true> - void updateDescriptorSetWithTemplateKHR( DescriptorSet descriptorSet, - DescriptorUpdateTemplate descriptorUpdateTemplate, - DataType const & data, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_display_control === - - // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result displayPowerControlEXT( DisplayKHR display, - const DisplayPowerInfoEXT * pDisplayPowerInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type displayPowerControlEXT( - DisplayKHR display, const DisplayPowerInfoEXT & displayPowerInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result registerEventEXT( const DeviceEventInfoEXT * pDeviceEventInfo, - const AllocationCallbacks * pAllocator, - Fence * pFence, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - registerEventEXT( const DeviceEventInfoEXT & deviceEventInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - registerEventEXTUnique( const DeviceEventInfoEXT & deviceEventInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result registerDisplayEventEXT( DisplayKHR display, - const DisplayEventInfoEXT * pDisplayEventInfo, - const AllocationCallbacks * pAllocator, - Fence * pFence, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - registerDisplayEventEXT( DisplayKHR display, - const DisplayEventInfoEXT & displayEventInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - registerDisplayEventEXTUnique( DisplayKHR display, - const DisplayEventInfoEXT & displayEventInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSwapchainCounterEXT( SwapchainKHR swapchain, - SurfaceCounterFlagBitsEXT counter, - uint64_t * pCounterValue, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - ResultValue -# else - typename ResultValueType::type -# endif - getSwapchainCounterEXT( SwapchainKHR swapchain, SurfaceCounterFlagBitsEXT counter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_GOOGLE_display_timing === - - // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, - RefreshCycleDurationGOOGLE * pDisplayTimingProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getRefreshCycleDurationGOOGLE( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPastPresentationTimingGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, - uint32_t * pPresentationTimingCount, - PastPresentationTimingGOOGLE * pPresentationTimings, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPastPresentationTimingGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html - template < - typename PastPresentationTimingGOOGLEAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - ResultValue> -# else - typename ResultValueType>::type -# endif - getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPastPresentationTimingGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html - template < - typename PastPresentationTimingGOOGLEAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - ResultValue> -# else - typename ResultValueType>::type -# endif - getPastPresentationTimingGOOGLE( SwapchainKHR swapchain, - PastPresentationTimingGOOGLEAllocator const & pastPresentationTimingGOOGLEAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_hdr_metadata === - - // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html - template ::type = true> - void setHdrMetadataEXT( uint32_t swapchainCount, - const SwapchainKHR * pSwapchains, - const HdrMetadataEXT * pMetadata, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html - template ::type = true> - void setHdrMetadataEXT( ArrayProxy const & swapchains, - ArrayProxy const & metadata, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_create_renderpass2 === - - // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createRenderPass2KHR( const RenderPassCreateInfo2 * pCreateInfo, - const AllocationCallbacks * pAllocator, - RenderPass * pRenderPass, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createRenderPass2KHR( const RenderPassCreateInfo2 & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createRenderPass2KHRUnique( const RenderPassCreateInfo2 & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_shared_presentable_image === - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( SwapchainKHR swapchain, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSwapchainStatusKHR( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - - // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR * pImportFenceWin32HandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR * pGetWin32HandleInfo, - HANDLE * pHandle, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - - // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result importFenceFdKHR( const ImportFenceFdInfoKHR * pImportFenceFdInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getFenceFdKHR( const FenceGetFdInfoKHR * pGetFdInfo, - int * pFd, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_performance_query === - - // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html - template ::type = true> - void releaseProfilingLockKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_debug_utils === - - // wrapper function for command vkSetDebugUtilsObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT * pNameInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetDebugUtilsObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkSetDebugUtilsObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT * pTagInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkSetDebugUtilsObjectTagEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setDebugUtilsObjectTagEXT( - HandleType const & handle, uint64_t name, TagType const & tag, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer, - AndroidHardwareBufferPropertiesANDROID * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID * pInfo, - struct AHardwareBuffer ** pBuffer, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, - uint32_t createInfoCount, - const ExecutionGraphPipelineCreateInfoAMDX * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createExecutionGraphPipelinesAMDX( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue - createExecutionGraphPipelineAMDX( PipelineCache pipelineCache, - const ExecutionGraphPipelineCreateInfoAMDX & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createExecutionGraphPipelinesAMDXUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createExecutionGraphPipelineAMDXUnique( PipelineCache pipelineCache, - const ExecutionGraphPipelineCreateInfoAMDX & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph, - ExecutionGraphPipelineScratchSizeAMDX * pSizeInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getExecutionGraphPipelineScratchSizeAMDX( Pipeline executionGraph, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getExecutionGraphPipelineNodeIndexAMDX( Pipeline executionGraph, - const PipelineShaderStageNodeCreateInfoAMDX * pNodeInfo, - uint32_t * pNodeIndex, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getExecutionGraphPipelineNodeIndexAMDX( - Pipeline executionGraph, const PipelineShaderStageNodeCreateInfoAMDX & nodeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - - // wrapper function for command vkWriteSamplerDescriptorsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result writeSamplerDescriptorsEXT( uint32_t samplerCount, - const SamplerCreateInfo * pSamplers, - const HostAddressRangeEXT * pDescriptors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWriteSamplerDescriptorsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - writeSamplerDescriptorsEXT( ArrayProxy const & samplers, - ArrayProxy const & descriptors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkWriteResourceDescriptorsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result writeResourceDescriptorsEXT( uint32_t resourceCount, - const ResourceDescriptorInfoEXT * pResources, - const HostAddressRangeEXT * pDescriptors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWriteResourceDescriptorsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - writeResourceDescriptorsEXT( ArrayProxy const & resources, - ArrayProxy const & descriptors, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDataEXT( uint32_t imageCount, - const Image * pImages, - HostAddressRangeEXT * pDatas, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getImageOpaqueCaptureDataEXT( ArrayProxy const & images, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getImageOpaqueCaptureDataEXT( ArrayProxy const & images, - HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageOpaqueCaptureDataEXT( const Image & image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkRegisterCustomBorderColorEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT * pBorderColor, - Bool32 requestIndex, - uint32_t * pIndex, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkRegisterCustomBorderColorEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type registerCustomBorderColorEXT( - const SamplerCustomBorderColorCreateInfoEXT & borderColor, Bool32 requestIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUnregisterCustomBorderColorEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html - template ::type = true> - void unregisterCustomBorderColorEXT( uint32_t index, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getTensorOpaqueCaptureDataARM( uint32_t tensorCount, - const TensorARM * pTensors, - HostAddressRangeEXT * pDatas, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors, - HostAddressRangeEXTAllocator const & hostAddressRangeEXTAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getTensorOpaqueCaptureDataARM( const TensorARM & tensor, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_get_memory_requirements2 === - - // wrapper function for command vkGetImageMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html - template ::type = true> - void getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2KHR( - const ImageMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetImageMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html - template ::type = true> - void getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2KHR( - const BufferMemoryRequirementsInfo2 & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetBufferMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html - template ::type = true> - void getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 * pInfo, - uint32_t * pSparseMemoryRequirementCount, - SparseImageMemoryRequirements2 * pSparseMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html - template < - typename SparseImageMemoryRequirements2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html - template < - typename SparseImageMemoryRequirements2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info, - SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_acceleration_structure === - - // wrapper function for command vkCreateAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - AccelerationStructureKHR * pAccelerationStructure, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createAccelerationStructureKHR( const AccelerationStructureCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createAccelerationStructureKHRUnique( const AccelerationStructureCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html - template ::type = true> - void destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html - template ::type = true> - void destroyAccelerationStructureKHR( AccelerationStructureKHR accelerationStructure VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html - template ::type = true> - void destroy( AccelerationStructureKHR accelerationStructure, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureKHR.html - template ::type = true> - void destroy( AccelerationStructureKHR accelerationStructure, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation, - uint32_t infoCount, - const AccelerationStructureBuildGeometryInfoKHR * pInfos, - const AccelerationStructureBuildRangeInfoKHR * const * ppBuildRangeInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result buildAccelerationStructuresKHR( DeferredOperationKHR deferredOperation, - ArrayProxy const & infos, - ArrayProxy const & pBuildRangeInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureInfoKHR * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureInfoKHR & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureToMemoryInfoKHR * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureToMemoryInfoKHR & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation, - const CopyMemoryToAccelerationStructureInfoKHR * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( DeferredOperationKHR deferredOperation, - const CopyMemoryToAccelerationStructureInfoKHR & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - writeAccelerationStructuresPropertiesKHR( uint32_t accelerationStructureCount, - const AccelerationStructureKHR * pAccelerationStructures, - QueryType queryType, - size_t dataSize, - void * pData, - size_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, - QueryType queryType, - size_t dataSize, - size_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - writeAccelerationStructuresPropertyKHR( ArrayProxy const & accelerationStructures, - QueryType queryType, - size_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html - template ::type = true> - DeviceAddress getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html - template ::type = true> - DeviceAddress getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html - template ::type = true> - void getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR * pVersionInfo, - AccelerationStructureCompatibilityKHR * pCompatibility, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR getAccelerationStructureCompatibilityKHR( - const AccelerationStructureVersionInfoKHR & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html - template ::type = true> - void getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, - const AccelerationStructureBuildGeometryInfoKHR * pBuildInfo, - const uint32_t * pMaxPrimitiveCounts, - AccelerationStructureBuildSizesInfoKHR * pSizeInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR - getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, - const AccelerationStructureBuildGeometryInfoKHR & buildInfo, - ArrayProxy const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_ray_tracing_pipeline === - - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - uint32_t createInfoCount, - const RayTracingPipelineCreateInfoKHR * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createRayTracingPipelinesKHR( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue - createRayTracingPipelineKHR( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - const RayTracingPipelineCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createRayTracingPipelinesKHRUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createRayTracingPipelineKHRUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - const RayTracingPipelineCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesKHR( Pipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type getRayTracingShaderGroupHandlesKHR( - Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingShaderGroupHandleKHR( - Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getRayTracingCaptureReplayShaderGroupHandlesKHR( - Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) - const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type getRayTracingCaptureReplayShaderGroupHandlesKHR( - Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingCaptureReplayShaderGroupHandleKHR( - Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html - template ::type = true> - DeviceSize getRayTracingShaderGroupStackSizeKHR( Pipeline pipeline, - uint32_t group, - ShaderGroupShaderKHR groupShader, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_sampler_ycbcr_conversion === - - // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - SamplerYcbcrConversion * pYcbcrConversion, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSamplerYcbcrConversionKHR( const SamplerYcbcrConversionCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createSamplerYcbcrConversionKHRUnique( const SamplerYcbcrConversionCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html - template ::type = true> - void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html - template ::type = true> - void destroySamplerYcbcrConversionKHR( SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_bind_memory2 === - - // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindBufferMemory2KHR( uint32_t bindInfoCount, - const BindBufferMemoryInfo * pBindInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindBufferMemory2KHR( ArrayProxy const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindImageMemory2KHR( uint32_t bindInfoCount, - const BindImageMemoryInfo * pBindInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindImageMemory2KHR( ArrayProxy const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_image_drm_format_modifier === - - // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getImageDrmFormatModifierPropertiesEXT( Image image, - ImageDrmFormatModifierPropertiesEXT * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageDrmFormatModifierPropertiesEXT( Image image, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_validation_cache === - - // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createValidationCacheEXT( const ValidationCacheCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - ValidationCacheEXT * pValidationCache, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createValidationCacheEXT( const ValidationCacheCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createValidationCacheEXTUnique( const ValidationCacheCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html - template ::type = true> - void destroyValidationCacheEXT( ValidationCacheEXT validationCache, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html - template ::type = true> - void destroyValidationCacheEXT( ValidationCacheEXT validationCache VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html - template ::type = true> - void destroy( ValidationCacheEXT validationCache, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyValidationCacheEXT.html - template ::type = true> - void destroy( ValidationCacheEXT validationCache, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result mergeValidationCachesEXT( ValidationCacheEXT dstCache, - uint32_t srcCacheCount, - const ValidationCacheEXT * pSrcCaches, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type mergeValidationCachesEXT( - ValidationCacheEXT dstCache, ArrayProxy const & srcCaches, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getValidationCacheDataEXT( ValidationCacheEXT validationCache, - size_t * pDataSize, - void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getValidationCacheDataEXT( ValidationCacheEXT validationCache, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type getValidationCacheDataEXT( - ValidationCacheEXT validationCache, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_ray_tracing === - - // wrapper function for command vkCreateAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createAccelerationStructureNV( const AccelerationStructureCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - AccelerationStructureNV * pAccelerationStructure, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createAccelerationStructureNV( const AccelerationStructureCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createAccelerationStructureNVUnique( const AccelerationStructureCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html - template ::type = true> - void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html - template ::type = true> - void destroyAccelerationStructureNV( AccelerationStructureNV accelerationStructure VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html - template ::type = true> - void destroy( AccelerationStructureNV accelerationStructure, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyAccelerationStructureNV.html - template ::type = true> - void destroy( AccelerationStructureNV accelerationStructure, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html - template ::type = true> - void getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV * pInfo, - MemoryRequirements2KHR * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2KHR getAccelerationStructureMemoryRequirementsNV( - const AccelerationStructureMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindAccelerationStructureMemoryNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindAccelerationStructureMemoryNV( uint32_t bindInfoCount, - const BindAccelerationStructureMemoryInfoNV * pBindInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindAccelerationStructureMemoryNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindAccelerationStructureMemoryNV( ArrayProxy const & bindInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createRayTracingPipelinesNV( PipelineCache pipelineCache, - uint32_t createInfoCount, - const RayTracingPipelineCreateInfoNV * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createRayTracingPipelinesNV( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createRayTracingPipelinesNV( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue - createRayTracingPipelineNV( PipelineCache pipelineCache, - const RayTracingPipelineCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createRayTracingPipelinesNVUnique( PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createRayTracingPipelineNVUnique( PipelineCache pipelineCache, - const RayTracingPipelineCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getRayTracingShaderGroupHandlesNV( Pipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type getRayTracingShaderGroupHandlesNV( - Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingShaderGroupHandleNV( - Pipeline pipeline, uint32_t firstGroup, uint32_t groupCount, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetAccelerationStructureHandleNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, - size_t dataSize, - void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAccelerationStructureHandleNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type getAccelerationStructureHandleNV( - AccelerationStructureNV accelerationStructure, size_t dataSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetAccelerationStructureHandleNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getAccelerationStructureHandleNV( AccelerationStructureNV accelerationStructure, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result compileDeferredNV( Pipeline pipeline, - uint32_t shader, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - compileDeferredNV( Pipeline pipeline, uint32_t shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - //=== VK_KHR_maintenance3 === - - // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html - template ::type = true> - void getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo * pCreateInfo, - DescriptorSetLayoutSupport * pSupport, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport getDescriptorSetLayoutSupportKHR( - const DescriptorSetLayoutCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_external_memory_host === - - // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, - const void * pHostPointer, - MemoryHostPointerPropertiesEXT * pMemoryHostPointerProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryHostPointerPropertiesEXT( - ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_calibrated_timestamps === - - // wrapper function for command vkGetCalibratedTimestampsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getCalibratedTimestampsEXT( uint32_t timestampCount, - const CalibratedTimestampInfoKHR * pTimestampInfos, - uint64_t * pTimestamps, - uint64_t * pMaxDeviation, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetCalibratedTimestampsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type - getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetCalibratedTimestampsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type - getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos, - Uint64_tAllocator const & uint64_tAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetCalibratedTimestampsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCalibratedTimestampEXT( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_timeline_semaphore === - - // wrapper function for command vkGetSemaphoreCounterValueKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSemaphoreCounterValueKHR( Semaphore semaphore, - uint64_t * pValue, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSemaphoreCounterValueKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getSemaphoreCounterValueKHR( Semaphore semaphore, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo * pWaitInfo, - uint64_t timeout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, - uint64_t timeout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result signalSemaphoreKHR( const SemaphoreSignalInfo * pSignalInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_present_timing === - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, - uint32_t size, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setSwapchainPresentTimingQueueSizeEXT( SwapchainKHR swapchain, - uint32_t size, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, - SwapchainTimingPropertiesEXT * pSwapchainTimingProperties, - uint64_t * pSwapchainTimingPropertiesCounter, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue> - getSwapchainTimingPropertiesEXT( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSwapchainTimeDomainPropertiesEXT( SwapchainKHR swapchain, - SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, - uint64_t * pTimeDomainsCounter, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPastPresentationTimingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, - PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_INTEL_performance_query === - - // wrapper function for command vkInitializePerformanceApiINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD Result initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL * pInitializeInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkInitializePerformanceApiINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUninitializePerformanceApiINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html - template ::type = true> - void uninitializePerformanceApiINTEL( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD Result acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL * pAcquireInfo, - PerformanceConfigurationINTEL * pConfiguration, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - acquirePerformanceConfigurationINTEL( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - acquirePerformanceConfigurationINTELUnique( const PerformanceConfigurationAcquireInfoINTEL & acquireInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleasePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD Result releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkReleasePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - releasePerformanceConfigurationINTEL( PerformanceConfigurationINTEL configuration VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleasePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD Result release( PerformanceConfigurationINTEL configuration, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkReleasePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleasePerformanceConfigurationINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type release( PerformanceConfigurationINTEL configuration, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetPerformanceParameterINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, - PerformanceValueINTEL * pValue, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPerformanceParameterINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_AMD_display_native_hdr === - - // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html - template ::type = true> - void setLocalDimmingAMD( SwapchainKHR swapChain, - Bool32 localDimmingEnable, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_buffer_device_address === - - // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html - template ::type = true> - DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfo * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html - template ::type = true> - DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_present_wait === - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result waitForPresentKHR( SwapchainKHR swapchain, - uint64_t presentId, - uint64_t timeout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - waitForPresentKHR( SwapchainKHR swapchain, uint64_t presentId, uint64_t timeout, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - -# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# else - // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - acquireFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# else - // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - releaseFullScreenExclusiveModeEXT( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - DeviceGroupPresentModeFlagsKHR * pModes, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_buffer_device_address === - - // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html - template ::type = true> - DeviceAddress getBufferAddressKHR( const BufferDeviceAddressInfo * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html - template ::type = true> - DeviceAddress getBufferAddressKHR( const BufferDeviceAddressInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html - template ::type = true> - uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html - template ::type = true> - uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html - template ::type = true> - uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html - template ::type = true> - uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_host_query_reset === - - // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html - template ::type = true> - void resetQueryPoolEXT( QueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_deferred_host_operations === - - // wrapper function for command vkCreateDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDeferredOperationKHR( const AllocationCallbacks * pAllocator, - DeferredOperationKHR * pDeferredOperation, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDeferredOperationKHR( Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDeferredOperationKHRUnique( Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html - template ::type = true> - void destroyDeferredOperationKHR( DeferredOperationKHR operation, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html - template ::type = true> - void destroyDeferredOperationKHR( DeferredOperationKHR operation VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html - template ::type = true> - void destroy( DeferredOperationKHR operation, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDeferredOperationKHR.html - template ::type = true> - void destroy( DeferredOperationKHR operation, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html - template ::type = true> - uint32_t getDeferredOperationMaxConcurrencyKHR( DeferredOperationKHR operation, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeferredOperationResultKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( DeferredOperationKHR operation, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkGetDeferredOperationResultKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDeferredOperationResultKHR( DeferredOperationKHR operation, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( DeferredOperationKHR operation, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result deferredOperationJoinKHR( DeferredOperationKHR operation, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - //=== VK_KHR_pipeline_executable_properties === - - // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getPipelineExecutablePropertiesKHR( const PipelineInfoKHR * pPipelineInfo, - uint32_t * pExecutableCount, - PipelineExecutablePropertiesKHR * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo, - PipelineExecutablePropertiesKHRAllocator const & pipelineExecutablePropertiesKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR * pExecutableInfo, - uint32_t * pStatisticCount, - PipelineExecutableStatisticKHR * pStatistics, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html - template < - typename PipelineExecutableStatisticKHRAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html - template < - typename PipelineExecutableStatisticKHRAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo, - PipelineExecutableStatisticKHRAllocator const & pipelineExecutableStatisticKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR * pExecutableInfo, - uint32_t * pInternalRepresentationCount, - PipelineExecutableInternalRepresentationKHR * pInternalRepresentations, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if< - std::is_same::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD - typename ResultValueType>::type - getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if< - std::is_same::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD - typename ResultValueType>::type - getPipelineExecutableInternalRepresentationsKHR( - const PipelineExecutableInfoKHR & executableInfo, - PipelineExecutableInternalRepresentationKHRAllocator const & pipelineExecutableInternalRepresentationKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_host_image_copy === - - // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyMemoryToImageEXT( const CopyMemoryToImageInfo * pCopyMemoryToImageInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - copyMemoryToImageEXT( const CopyMemoryToImageInfo & copyMemoryToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyImageToMemoryEXT( const CopyImageToMemoryInfo * pCopyImageToMemoryInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - copyImageToMemoryEXT( const CopyImageToMemoryInfo & copyImageToMemoryInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyImageToImageEXT( const CopyImageToImageInfo * pCopyImageToImageInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - copyImageToImageEXT( const CopyImageToImageInfo & copyImageToImageInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result transitionImageLayoutEXT( uint32_t transitionCount, - const HostImageLayoutTransitionInfo * pTransitions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - transitionImageLayoutEXT( ArrayProxy const & transitions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSubresourceLayout2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html - template ::type = true> - void getImageSubresourceLayout2EXT( Image image, - const ImageSubresource2 * pSubresource, - SubresourceLayout2 * pLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSubresourceLayout2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html - template ::type = true> - VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2EXT( - Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetImageSubresourceLayout2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain getImageSubresourceLayout2EXT( - Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_map_memory2 === - - // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result mapMemory2KHR( const MemoryMapInfo * pMemoryMapInfo, - void ** ppData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type mapMemory2KHR( const MemoryMapInfo & memoryMapInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result unmapMemory2KHR( const MemoryUnmapInfo * pMemoryUnmapInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_swapchain_maintenance1 === - - // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_device_generated_commands === - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html - template ::type = true> - void getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getGeneratedCommandsMemoryRequirementsNV( - const GeneratedCommandsMemoryRequirementsInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - IndirectCommandsLayoutNV * pIndirectCommandsLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createIndirectCommandsLayoutNV( const IndirectCommandsLayoutCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createIndirectCommandsLayoutNVUnique( const IndirectCommandsLayoutCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html - template ::type = true> - void destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html - template ::type = true> - void destroyIndirectCommandsLayoutNV( IndirectCommandsLayoutNV indirectCommandsLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html - template ::type = true> - void destroy( IndirectCommandsLayoutNV indirectCommandsLayout, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutNV.html - template ::type = true> - void destroy( IndirectCommandsLayoutNV indirectCommandsLayout, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_private_data === - - // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - PrivateDataSlot * pPrivateDataSlot, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createPrivateDataSlotEXT( const PrivateDataSlotCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createPrivateDataSlotEXTUnique( const PrivateDataSlotCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html - template ::type = true> - void destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html - template ::type = true> - void destroyPrivateDataSlotEXT( PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setPrivateDataEXT( ObjectType objectType, - uint64_t objectHandle, - PrivateDataSlot privateDataSlot, - uint64_t data, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - setPrivateDataEXT( ObjectType objectType, - uint64_t objectHandle, - PrivateDataSlot privateDataSlot, - uint64_t data, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html - template ::type = true> - void getPrivateDataEXT( ObjectType objectType, - uint64_t objectHandle, - PrivateDataSlot privateDataSlot, - uint64_t * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( ObjectType objectType, - uint64_t objectHandle, - PrivateDataSlot privateDataSlot, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_video_encode_queue === - - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR * pVideoSessionParametersInfo, - VideoEncodeSessionParametersFeedbackInfoKHR * pFeedbackInfo, - size_t * pDataSize, - void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>>::type - getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>>::type - getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, - Uint8_tAllocator const & uint8_tAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type - getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type - getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo, - Uint8_tAllocator const & uint8_tAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - - // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createCudaModuleNV( const CudaModuleCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - CudaModuleNV * pModule, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createCudaModuleNV( const CudaModuleCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createCudaModuleNVUnique( const CudaModuleCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getCudaModuleCacheNV( CudaModuleNV module, - size_t * pCacheSize, - void * pCacheData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCudaModuleCacheNV( CudaModuleNV module, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCudaModuleCacheNV( CudaModuleNV module, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createCudaFunctionNV( const CudaFunctionCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - CudaFunctionNV * pFunction, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createCudaFunctionNV( const CudaFunctionCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createCudaFunctionNVUnique( const CudaFunctionCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html - template ::type = true> - void destroyCudaModuleNV( CudaModuleNV module, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html - template ::type = true> - void destroyCudaModuleNV( CudaModuleNV module, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html - template ::type = true> - void destroy( CudaModuleNV module, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaModuleNV.html - template ::type = true> - void destroy( CudaModuleNV module, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html - template ::type = true> - void destroyCudaFunctionNV( CudaFunctionNV function, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html - template ::type = true> - void destroyCudaFunctionNV( CudaFunctionNV function, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html - template ::type = true> - void destroy( CudaFunctionNV function, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyCudaFunctionNV.html - template ::type = true> - void destroy( CudaFunctionNV function, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - - // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - template ::type = true> - void exportMetalObjectsEXT( ExportMetalObjectsInfoEXT * pMetalObjectsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - template ::type = true> - void exportMetalObjectsEXT( ExportMetalObjectsInfoEXT & metalObjectsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_descriptor_buffer === - - // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html - template ::type = true> - void getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout, - DeviceSize * pLayoutSizeInBytes, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD DeviceSize getDescriptorSetLayoutSizeEXT( DescriptorSetLayout layout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html - template ::type = true> - void getDescriptorSetLayoutBindingOffsetEXT( DescriptorSetLayout layout, - uint32_t binding, - DeviceSize * pOffset, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD DeviceSize getDescriptorSetLayoutBindingOffsetEXT( - DescriptorSetLayout layout, uint32_t binding, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html - template ::type = true> - void getDescriptorEXT( const DescriptorGetInfoEXT * pDescriptorInfo, - size_t dataSize, - void * pDescriptor, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html - template ::type = true> - void getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, - size_t dataSize, - void * pDescriptor, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getBufferOpaqueCaptureDescriptorDataEXT( - const BufferCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT * pInfo, - void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT * pInfo, - void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSamplerOpaqueCaptureDescriptorDataEXT( - const SamplerCaptureDescriptorDataInfoEXT * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT * pInfo, - void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_device_fault === - - // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts, - DeviceFaultInfoEXT * pFaultInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - - // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, - zx_handle_t * pZirconHandle, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType, - zx_handle_t zirconHandle, - MemoryZirconHandlePropertiesFUCHSIA * pMemoryZirconHandleProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryZirconHandlePropertiesFUCHSIA( - ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - - // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD Result importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA * pImportSemaphoreZirconHandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA * pGetZirconHandleInfo, - zx_handle_t * pZirconHandle, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - - // wrapper function for command vkCreateBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createBufferCollectionFUCHSIA( const BufferCollectionCreateInfoFUCHSIA * pCreateInfo, - const AllocationCallbacks * pAllocator, - BufferCollectionFUCHSIA * pCollection, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createBufferCollectionFUCHSIA( const BufferCollectionCreateInfoFUCHSIA & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createBufferCollectionFUCHSIAUnique( const BufferCollectionCreateInfoFUCHSIA & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - setBufferCollectionImageConstraintsFUCHSIA( BufferCollectionFUCHSIA collection, - const ImageConstraintsInfoFUCHSIA * pImageConstraintsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - setBufferCollectionImageConstraintsFUCHSIA( BufferCollectionFUCHSIA collection, - const ImageConstraintsInfoFUCHSIA & imageConstraintsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - setBufferCollectionBufferConstraintsFUCHSIA( BufferCollectionFUCHSIA collection, - const BufferConstraintsInfoFUCHSIA * pBufferConstraintsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - setBufferCollectionBufferConstraintsFUCHSIA( BufferCollectionFUCHSIA collection, - const BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html - template ::type = true> - void destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html - template ::type = true> - void destroyBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html - template ::type = true> - void destroy( BufferCollectionFUCHSIA collection, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyBufferCollectionFUCHSIA.html - template ::type = true> - void destroy( BufferCollectionFUCHSIA collection, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection, - BufferCollectionPropertiesFUCHSIA * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getBufferCollectionPropertiesFUCHSIA( BufferCollectionFUCHSIA collection, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - - // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSubpassShadingMaxWorkgroupSizeHUAWEI( - RenderPass renderpass, Extent2D * pMaxWorkgroupSize, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getSubpassShadingMaxWorkgroupSizeHUAWEI( RenderPass renderpass, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_external_memory_rdma === - - // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV * pMemoryGetRemoteAddressInfo, - RemoteAddressNV * pAddress, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_pipeline_properties === - - // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getPipelinePropertiesEXT( const PipelineInfoEXT * pPipelineInfo, - BaseOutStructure * pPipelineProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getPipelinePropertiesEXT( const PipelineInfoEXT & pipelineInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_opacity_micromap === - - // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createMicromapEXT( const MicromapCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - MicromapEXT * pMicromap, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createMicromapEXT( const MicromapCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createMicromapEXTUnique( const MicromapCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html - template ::type = true> - void destroyMicromapEXT( MicromapEXT micromap, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html - template ::type = true> - void destroyMicromapEXT( MicromapEXT micromap VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html - template ::type = true> - void destroy( MicromapEXT micromap, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyMicromapEXT.html - template ::type = true> - void destroy( MicromapEXT micromap, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result buildMicromapsEXT( DeferredOperationKHR deferredOperation, - uint32_t infoCount, - const MicromapBuildInfoEXT * pInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result buildMicromapsEXT( DeferredOperationKHR deferredOperation, - ArrayProxy const & infos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyMicromapEXT( DeferredOperationKHR deferredOperation, - const CopyMicromapInfoEXT * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyMicromapEXT( DeferredOperationKHR deferredOperation, - const CopyMicromapInfoEXT & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation, - const CopyMicromapToMemoryInfoEXT * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( DeferredOperationKHR deferredOperation, - const CopyMicromapToMemoryInfoEXT & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation, - const CopyMemoryToMicromapInfoEXT * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( DeferredOperationKHR deferredOperation, - const CopyMemoryToMicromapInfoEXT & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result writeMicromapsPropertiesEXT( uint32_t micromapCount, - const MicromapEXT * pMicromaps, - QueryType queryType, - size_t dataSize, - void * pData, - size_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - writeMicromapsPropertiesEXT( ArrayProxy const & micromaps, - QueryType queryType, - size_t dataSize, - size_t stride, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type writeMicromapsPropertyEXT( - ArrayProxy const & micromaps, QueryType queryType, size_t stride, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html - template ::type = true> - void getMicromapCompatibilityEXT( const MicromapVersionInfoEXT * pVersionInfo, - AccelerationStructureCompatibilityKHR * pCompatibility, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR getMicromapCompatibilityEXT( - const MicromapVersionInfoEXT & versionInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html - template ::type = true> - void getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, - const MicromapBuildInfoEXT * pBuildInfo, - MicromapBuildSizesInfoEXT * pSizeInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD MicromapBuildSizesInfoEXT - getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, - const MicromapBuildInfoEXT & buildInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_pageable_device_local_memory === - - // wrapper function for command vkSetDeviceMemoryPriorityEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html - template ::type = true> - void setMemoryPriorityEXT( DeviceMemory memory, float priority, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_maintenance4 === - - // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html - template ::type = true> - void getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirementsKHR( - const DeviceBufferMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html - template ::type = true> - void getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirementsKHR( - const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html - template ::type = true> - void getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements * pInfo, - uint32_t * pSparseMemoryRequirementCount, - SparseImageMemoryRequirements2 * pSparseMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html - template < - typename SparseImageMemoryRequirements2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html - template < - typename SparseImageMemoryRequirements2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info, - SparseImageMemoryRequirements2Allocator const & sparseImageMemoryRequirements2Allocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VALVE_descriptor_set_host_mapping === - - // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html - template ::type = true> - void getDescriptorSetLayoutHostMappingInfoVALVE( const DescriptorSetBindingReferenceVALVE * pBindingReference, - DescriptorSetLayoutHostMappingInfoVALVE * pHostMapping, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html - template ::type = true> - VULKAN_HPP_NODISCARD DescriptorSetLayoutHostMappingInfoVALVE getDescriptorSetLayoutHostMappingInfoVALVE( - const DescriptorSetBindingReferenceVALVE & bindingReference, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html - template ::type = true> - void getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet, - void ** ppData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html - template ::type = true> - VULKAN_HPP_NODISCARD void * getDescriptorSetHostMappingVALVE( DescriptorSet descriptorSet, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_device_generated_commands_compute === - - // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html - template ::type = true> - void getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo * pCreateInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getPipelineIndirectMemoryRequirementsNV( - const ComputePipelineCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html - template ::type = true> - DeviceAddress getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html - template ::type = true> - DeviceAddress getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer * buffer, - NativeBufferPropertiesOHOS * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS * pInfo, - struct OH_NativeBuffer ** pBuffer, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_ARM_tensors === - - // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createTensorARM( const TensorCreateInfoARM * pCreateInfo, - const AllocationCallbacks * pAllocator, - TensorARM * pTensor, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createTensorARM( const TensorCreateInfoARM & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createTensorARMUnique( const TensorCreateInfoARM & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html - template ::type = true> - void destroyTensorARM( TensorARM tensor, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html - template ::type = true> - void destroyTensorARM( TensorARM tensor VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html - template ::type = true> - void destroy( TensorARM tensor, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorARM.html - template ::type = true> - void destroy( TensorARM tensor, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createTensorViewARM( const TensorViewCreateInfoARM * pCreateInfo, - const AllocationCallbacks * pAllocator, - TensorViewARM * pView, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createTensorViewARM( const TensorViewCreateInfoARM & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createTensorViewARMUnique( const TensorViewCreateInfoARM & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html - template ::type = true> - void destroyTensorViewARM( TensorViewARM tensorView, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html - template ::type = true> - void destroyTensorViewARM( TensorViewARM tensorView VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html - template ::type = true> - void destroy( TensorViewARM tensorView, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyTensorViewARM.html - template ::type = true> - void destroy( TensorViewARM tensorView, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html - template ::type = true> - void getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM( - const TensorMemoryRequirementsInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindTensorMemoryARM( uint32_t bindInfoCount, - const BindTensorMemoryInfoARM * pBindInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindTensorMemoryARM( ArrayProxy const & bindInfos, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html - template ::type = true> - void getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM( - const DeviceTensorMemoryRequirementsARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getTensorOpaqueCaptureDescriptorDataARM( - const TensorCaptureDescriptorDataInfoARM * pInfo, void * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM * pInfo, - void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_shader_module_identifier === - - // wrapper function for command vkGetShaderModuleIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html - template ::type = true> - void getShaderModuleIdentifierEXT( ShaderModule shaderModule, - ShaderModuleIdentifierEXT * pIdentifier, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetShaderModuleIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT - getShaderModuleIdentifierEXT( ShaderModule shaderModule, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html - template ::type = true> - void getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo * pCreateInfo, - ShaderModuleIdentifierEXT * pIdentifier, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT getShaderModuleCreateInfoIdentifierEXT( - const ShaderModuleCreateInfo & createInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_optical_flow === - - // wrapper function for command vkCreateOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createOpticalFlowSessionNV( const OpticalFlowSessionCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - OpticalFlowSessionNV * pSession, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createOpticalFlowSessionNV( const OpticalFlowSessionCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createOpticalFlowSessionNVUnique( const OpticalFlowSessionCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html - template ::type = true> - void destroyOpticalFlowSessionNV( OpticalFlowSessionNV session, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html - template ::type = true> - void destroyOpticalFlowSessionNV( OpticalFlowSessionNV session, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html - template ::type = true> - void destroy( OpticalFlowSessionNV session, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyOpticalFlowSessionNV.html - template ::type = true> - void destroy( OpticalFlowSessionNV session, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindOpticalFlowSessionImageNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindOpticalFlowSessionImageNV( OpticalFlowSessionNV session, - OpticalFlowSessionBindingPointNV bindingPoint, - ImageView view, - ImageLayout layout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkBindOpticalFlowSessionImageNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindOpticalFlowSessionImageNV( OpticalFlowSessionNV session, - OpticalFlowSessionBindingPointNV bindingPoint, - ImageView view, - ImageLayout layout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - //=== VK_KHR_maintenance5 === - - // wrapper function for command vkGetRenderingAreaGranularityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html - template ::type = true> - void getRenderingAreaGranularityKHR( const RenderingAreaInfo * pRenderingAreaInfo, - Extent2D * pGranularity, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRenderingAreaGranularityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularityKHR( const RenderingAreaInfo & renderingAreaInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html - template ::type = true> - void getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo * pInfo, - SubresourceLayout2 * pLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayoutKHR( - const DeviceImageSubresourceInfo & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetImageSubresourceLayout2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html - template ::type = true> - void getImageSubresourceLayout2KHR( Image image, - const ImageSubresource2 * pSubresource, - SubresourceLayout2 * pLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetImageSubresourceLayout2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout2KHR( - Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetImageSubresourceLayout2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain getImageSubresourceLayout2KHR( - Image image, const ImageSubresource2 & subresource, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_AMD_anti_lag === - - // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html - template ::type = true> - void antiLagUpdateAMD( const AntiLagDataAMD * pData, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html - template ::type = true> - void antiLagUpdateAMD( const AntiLagDataAMD & data, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_present_wait2 === - - // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result waitForPresent2KHR( SwapchainKHR swapchain, - const PresentWait2InfoKHR * pPresentWait2Info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result waitForPresent2KHR( SwapchainKHR swapchain, - const PresentWait2InfoKHR & presentWait2Info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_shader_object === - - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t createInfoCount, - const ShaderCreateInfoEXT * pCreateInfos, - const AllocationCallbacks * pAllocator, - ShaderEXT * pShaders, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createShadersEXT( ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createShadersEXT( ArrayProxy const & createInfos, - Optional allocator, - ShaderEXTAllocator const & shaderEXTAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue createShaderEXT( const ShaderCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, ShaderEXTAllocator>> - createShadersEXTUnique( ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, ShaderEXTAllocator>> - createShadersEXTUnique( ArrayProxy const & createInfos, - Optional allocator, - ShaderEXTAllocator const & shaderEXTAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createShaderEXTUnique( const ShaderCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html - template ::type = true> - void destroyShaderEXT( ShaderEXT shader, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html - template ::type = true> - void destroyShaderEXT( ShaderEXT shader VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html - template ::type = true> - void destroy( ShaderEXT shader, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyShaderEXT.html - template ::type = true> - void destroy( ShaderEXT shader, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( ShaderEXT shader, - size_t * pDataSize, - void * pData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getShaderBinaryDataEXT( ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getShaderBinaryDataEXT( ShaderEXT shader, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_pipeline_binary === - - // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - PipelineBinaryHandlesInfoKHR * pBinaries, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createPipelineBinariesKHR( const PipelineBinaryCreateInfoKHR & createInfo, - Optional allocator, - PipelineBinaryKHRAllocator const & pipelineBinaryKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - template < - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename PipelineBinaryKHRAllocator = std::allocator>, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineBinaryKHRAllocator>> - createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - template < - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename PipelineBinaryKHRAllocator = std::allocator>, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineBinaryKHRAllocator>> - createPipelineBinariesKHRUnique( const PipelineBinaryCreateInfoKHR & createInfo, - Optional allocator, - PipelineBinaryKHRAllocator const & pipelineBinaryKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html - template ::type = true> - void destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html - template ::type = true> - void destroyPipelineBinaryKHR( PipelineBinaryKHR pipelineBinary VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html - template ::type = true> - void destroy( PipelineBinaryKHR pipelineBinary, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPipelineBinaryKHR.html - template ::type = true> - void destroy( PipelineBinaryKHR pipelineBinary, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getPipelineKeyKHR( const PipelineCreateInfoKHR * pPipelineCreateInfo, - PipelineBinaryKeyKHR * pPipelineKey, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getPipelineKeyKHR( Optional pipelineCreateInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR * pInfo, - PipelineBinaryKeyKHR * pPipelineBinaryKey, - size_t * pPipelineBinaryDataSize, - void * pPipelineBinaryData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>>::type - getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>>::type getPipelineBinaryDataKHR( - const PipelineBinaryDataInfoKHR & info, Uint8_tAllocator const & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkReleaseCapturedPipelineDataKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR * pInfo, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleaseCapturedPipelineDataKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR & info, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_QCOM_tile_properties === - - // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, - uint32_t * pPropertiesCount, - TilePropertiesQCOM * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getFramebufferTilePropertiesQCOM( Framebuffer framebuffer, - TilePropertiesQCOMAllocator const & tilePropertiesQCOMAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDynamicRenderingTilePropertiesQCOM( const RenderingInfo * pRenderingInfo, - TilePropertiesQCOM * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_swapchain_maintenance1 === - - // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR * pReleaseInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_cooperative_vector === - - // wrapper function for command vkConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV * pInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_low_latency2 === - - // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result setLatencySleepModeNV( SwapchainKHR swapchain, - const LatencySleepModeInfoNV * pSleepModeInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setLatencySleepModeNV( - SwapchainKHR swapchain, const LatencySleepModeInfoNV & sleepModeInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result latencySleepNV( SwapchainKHR swapchain, - const LatencySleepInfoNV * pSleepInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - latencySleepNV( SwapchainKHR swapchain, const LatencySleepInfoNV & sleepInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html - template ::type = true> - void setLatencyMarkerNV( SwapchainKHR swapchain, - const SetLatencyMarkerInfoNV * pLatencyMarkerInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html - template ::type = true> - void setLatencyMarkerNV( SwapchainKHR swapchain, - const SetLatencyMarkerInfoNV & latencyMarkerInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html - template ::type = true> - void getLatencyTimingsNV( SwapchainKHR swapchain, - GetLatencyMarkerInfoNV * pLatencyMarkerInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html - template < - typename LatencyTimingsFrameReportNVAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getLatencyTimingsNV( SwapchainKHR swapchain, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html - template < - typename LatencyTimingsFrameReportNVAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getLatencyTimingsNV( SwapchainKHR swapchain, - LatencyTimingsFrameReportNVAllocator const & latencyTimingsFrameReportNVAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_ARM_data_graph === - - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - uint32_t createInfoCount, - const DataGraphPipelineCreateInfoARM * pCreateInfos, - const AllocationCallbacks * pAllocator, - Pipeline * pPipelines, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createDataGraphPipelinesARM( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue - createDataGraphPipelineARM( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - const DataGraphPipelineCreateInfoARM & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template >, - typename std::enable_if>::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD ResultValue, PipelineAllocator>> - createDataGraphPipelinesARMUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - ArrayProxy const & createInfos, - Optional allocator, - PipelineAllocator const & pipelineAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - template ::type = true> - VULKAN_HPP_NODISCARD ResultValue> - createDataGraphPipelineARMUnique( DeferredOperationKHR deferredOperation, - PipelineCache pipelineCache, - const DataGraphPipelineCreateInfoARM & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDataGraphPipelineSessionARM( const DataGraphPipelineSessionCreateInfoARM * pCreateInfo, - const AllocationCallbacks * pAllocator, - DataGraphPipelineSessionARM * pSession, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDataGraphPipelineSessionARM( const DataGraphPipelineSessionCreateInfoARM & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDataGraphPipelineSessionARMUnique( const DataGraphPipelineSessionCreateInfoARM & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM * pInfo, - uint32_t * pBindPointRequirementCount, - DataGraphPipelineSessionBindPointRequirementARM * pBindPointRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD - typename ResultValueType>::type - getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD - typename ResultValueType>::type - getDataGraphPipelineSessionBindPointRequirementsARM( - const DataGraphPipelineSessionBindPointRequirementsInfoARM & info, - DataGraphPipelineSessionBindPointRequirementARMAllocator const & dataGraphPipelineSessionBindPointRequirementARMAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html - template ::type = true> - void getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getDataGraphPipelineSessionMemoryRequirementsARM( - const DataGraphPipelineSessionMemoryRequirementsInfoARM & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result bindDataGraphPipelineSessionMemoryARM( uint32_t bindInfoCount, - const BindDataGraphPipelineSessionMemoryInfoARM * pBindInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - bindDataGraphPipelineSessionMemoryARM( ArrayProxy const & bindInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html - template ::type = true> - void destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html - template ::type = true> - void destroyDataGraphPipelineSessionARM( DataGraphPipelineSessionARM session, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html - template ::type = true> - void destroy( DataGraphPipelineSessionARM session, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDataGraphPipelineSessionARM.html - template ::type = true> - void destroy( DataGraphPipelineSessionARM session, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, - uint32_t * pPropertiesCount, - DataGraphPipelinePropertyARM * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html - template < - typename DataGraphPipelinePropertyARMAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html - template < - typename DataGraphPipelinePropertyARMAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo, - DataGraphPipelinePropertyARMAllocator const & dataGraphPipelinePropertyARMAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDataGraphPipelinePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelinePropertiesARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDataGraphPipelinePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, - uint32_t propertiesCount, - DataGraphPipelinePropertyQueryResultARM * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer, - ScreenBufferPropertiesQNX * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_KHR_calibrated_timestamps === - - // wrapper function for command vkGetCalibratedTimestampsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getCalibratedTimestampsKHR( uint32_t timestampCount, - const CalibratedTimestampInfoKHR * pTimestampInfos, - uint64_t * pTimestamps, - uint64_t * pMaxDeviation, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetCalibratedTimestampsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type - getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetCalibratedTimestampsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type - getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos, - Uint64_tAllocator const & uint64_tAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetCalibratedTimestampsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCalibratedTimestampKHR( const CalibratedTimestampInfoKHR & timestampInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_external_compute_queue === - - // wrapper function for command vkCreateExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createExternalComputeQueueNV( const ExternalComputeQueueCreateInfoNV * pCreateInfo, - const AllocationCallbacks * pAllocator, - ExternalComputeQueueNV * pExternalQueue, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createExternalComputeQueueNV( const ExternalComputeQueueCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createExternalComputeQueueNVUnique( const ExternalComputeQueueCreateInfoNV & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html - template ::type = true> - void destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html - template ::type = true> - void destroyExternalComputeQueueNV( ExternalComputeQueueNV externalQueue, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html - template ::type = true> - void destroy( ExternalComputeQueueNV externalQueue, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html - template ::type = true> - void destroy( ExternalComputeQueueNV externalQueue, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_cluster_acceleration_structure === - - // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html - template ::type = true> - void getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV * pInfo, - AccelerationStructureBuildSizesInfoKHR * pSizeInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR getClusterAccelerationStructureBuildSizesNV( - const ClusterAccelerationStructureInputInfoNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_partitioned_acceleration_structure === - - // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html - template ::type = true> - void getPartitionedAccelerationStructuresBuildSizesNV( const PartitionedAccelerationStructureInstancesInputNV * pInfo, - AccelerationStructureBuildSizesInfoKHR * pSizeInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR getPartitionedAccelerationStructuresBuildSizesNV( - const PartitionedAccelerationStructureInstancesInputNV & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_device_generated_commands === - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html - template ::type = true> - void getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT * pInfo, - MemoryRequirements2 * pMemoryRequirements, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD MemoryRequirements2 getGeneratedCommandsMemoryRequirementsEXT( - const GeneratedCommandsMemoryRequirementsInfoEXT & info, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createIndirectCommandsLayoutEXT( const IndirectCommandsLayoutCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - IndirectCommandsLayoutEXT * pIndirectCommandsLayout, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createIndirectCommandsLayoutEXT( const IndirectCommandsLayoutCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createIndirectCommandsLayoutEXTUnique( const IndirectCommandsLayoutCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html - template ::type = true> - void destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html - template ::type = true> - void destroyIndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT indirectCommandsLayout VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html - template ::type = true> - void destroy( IndirectCommandsLayoutEXT indirectCommandsLayout, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectCommandsLayoutEXT.html - template ::type = true> - void destroy( IndirectCommandsLayoutEXT indirectCommandsLayout, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createIndirectExecutionSetEXT( const IndirectExecutionSetCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - IndirectExecutionSetEXT * pIndirectExecutionSet, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createIndirectExecutionSetEXT( const IndirectExecutionSetCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createIndirectExecutionSetEXTUnique( const IndirectExecutionSetCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html - template ::type = true> - void destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html - template ::type = true> - void destroyIndirectExecutionSetEXT( IndirectExecutionSetEXT indirectExecutionSet VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html - template ::type = true> - void destroy( IndirectExecutionSetEXT indirectExecutionSet, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyIndirectExecutionSetEXT.html - template ::type = true> - void destroy( IndirectExecutionSetEXT indirectExecutionSet, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html - template ::type = true> - void updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, - const WriteIndirectExecutionSetPipelineEXT * pExecutionSetWrites, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html - template ::type = true> - void updateIndirectExecutionSetPipelineEXT( IndirectExecutionSetEXT indirectExecutionSet, - ArrayProxy const & executionSetWrites, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html - template ::type = true> - void updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet, - uint32_t executionSetWriteCount, - const WriteIndirectExecutionSetShaderEXT * pExecutionSetWrites, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html - template ::type = true> - void updateIndirectExecutionSetShaderEXT( IndirectExecutionSetEXT indirectExecutionSet, - ArrayProxy const & executionSetWrites, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - - // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT * pGetMetalHandleInfo, - void ** pHandle, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT & getMetalHandleInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, - const void * pHandle, - MemoryMetalHandlePropertiesEXT * pMemoryMetalHandleProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryMetalHandlePropertiesEXT( - ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - operator VkDevice() const VULKAN_HPP_NOEXCEPT - { - return m_device; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_device != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_device == VK_NULL_HANDLE; - } - - private: - VkDevice m_device = {}; - }; - - template <> - struct CppType - { - using Type = Device; - }; - - template <> - struct CppType - { - using Type = Device; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Device; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeKHR.html - class DisplayModeKHR - { - public: - using CType = VkDisplayModeKHR; - using NativeType = VkDisplayModeKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayModeKHR; - - public: - DisplayModeKHR() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - DisplayModeKHR( DisplayModeKHR const & rhs ) = default; - DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - DisplayModeKHR( DisplayModeKHR && rhs ) = default; - DisplayModeKHR & operator=( DisplayModeKHR && rhs ) = default; -#else - DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( exchange( rhs.m_displayModeKHR, {} ) ) {} - - DisplayModeKHR & operator=( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - m_displayModeKHR = exchange( rhs.m_displayModeKHR, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR DisplayModeKHR( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - VULKAN_HPP_TYPESAFE_EXPLICIT DisplayModeKHR( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT : m_displayModeKHR( displayModeKHR ) {} - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) - DisplayModeKHR & operator=( VkDisplayModeKHR displayModeKHR ) VULKAN_HPP_NOEXCEPT - { - m_displayModeKHR = displayModeKHR; - return *this; - } -#endif - - DisplayModeKHR & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_displayModeKHR = {}; - return *this; - } - - VULKAN_HPP_TYPESAFE_EXPLICIT operator VkDisplayModeKHR() const VULKAN_HPP_NOEXCEPT - { - return m_displayModeKHR; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_displayModeKHR != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_displayModeKHR == VK_NULL_HANDLE; - } - - private: - VkDisplayModeKHR m_displayModeKHR = {}; - }; - - template <> - struct CppType - { - using Type = DisplayModeKHR; - }; - - template <> - struct CppType - { - using Type = DisplayModeKHR; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = DisplayModeKHR; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPhysicalDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice.html - class PhysicalDevice - { - public: - using CType = VkPhysicalDevice; - using NativeType = VkPhysicalDevice; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePhysicalDevice; - - public: - PhysicalDevice() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - PhysicalDevice( PhysicalDevice const & rhs ) = default; - PhysicalDevice & operator=( PhysicalDevice const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - PhysicalDevice( PhysicalDevice && rhs ) = default; - PhysicalDevice & operator=( PhysicalDevice && rhs ) = default; -#else - PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( exchange( rhs.m_physicalDevice, {} ) ) {} - - PhysicalDevice & operator=( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT - { - m_physicalDevice = exchange( rhs.m_physicalDevice, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR PhysicalDevice( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - PhysicalDevice( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( physicalDevice ) {} - - PhysicalDevice & operator=( VkPhysicalDevice physicalDevice ) VULKAN_HPP_NOEXCEPT - { - m_physicalDevice = physicalDevice; - return *this; - } - - PhysicalDevice & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_physicalDevice = {}; - return *this; - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html - template ::type = true> - void getFeatures( PhysicalDeviceFeatures * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html - template ::type = true> - VULKAN_HPP_NODISCARD PhysicalDeviceFeatures getFeatures( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html - template ::type = true> - void getFormatProperties( Format format, - FormatProperties * pFormatProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD FormatProperties getFormatProperties( Format format, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getImageFormatProperties( Format format, - ImageType type, - ImageTiling tiling, - ImageUsageFlags usage, - ImageCreateFlags flags, - ImageFormatProperties * pImageFormatProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageFormatProperties( Format format, - ImageType type, - ImageTiling tiling, - ImageUsageFlags usage, - ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html - template ::type = true> - void getProperties( PhysicalDeviceProperties * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD PhysicalDeviceProperties getProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html - template ::type = true> - void getQueueFamilyProperties( uint32_t * pQueueFamilyPropertyCount, - QueueFamilyProperties * pQueueFamilyProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getQueueFamilyProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getQueueFamilyProperties( QueueFamilyPropertiesAllocator const & queueFamilyPropertiesAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html - template ::type = true> - void getMemoryProperties( PhysicalDeviceMemoryProperties * pMemoryProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties - getMemoryProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDevice( const DeviceCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Device * pDevice, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDevice( const DeviceCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDeviceUnique( const DeviceCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkEnumerateDeviceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD Result enumerateDeviceExtensionProperties( const char * pLayerName, - uint32_t * pPropertyCount, - ExtensionProperties * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumerateDeviceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateDeviceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkEnumerateDeviceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateDeviceExtensionProperties( Optional layerName, - ExtensionPropertiesAllocator const & extensionPropertiesAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkEnumerateDeviceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD Result enumerateDeviceLayerProperties( uint32_t * pPropertyCount, - LayerProperties * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumerateDeviceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateDeviceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkEnumerateDeviceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateDeviceLayerProperties( LayerPropertiesAllocator const & layerPropertiesAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html - template ::type = true> - void getSparseImageFormatProperties( Format format, - ImageType type, - SampleCountFlagBits samples, - ImageUsageFlags usage, - ImageTiling tiling, - uint32_t * pPropertyCount, - SparseImageFormatProperties * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html - template < - typename SparseImageFormatPropertiesAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getSparseImageFormatProperties( Format format, - ImageType type, - SampleCountFlagBits samples, - ImageUsageFlags usage, - ImageTiling tiling, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html - template < - typename SparseImageFormatPropertiesAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getSparseImageFormatProperties( Format format, - ImageType type, - SampleCountFlagBits samples, - ImageUsageFlags usage, - ImageTiling tiling, - SparseImageFormatPropertiesAllocator const & sparseImageFormatPropertiesAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkGetPhysicalDeviceFeatures2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html - template ::type = true> - void getFeatures2( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFeatures2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html - template ::type = true> - VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetPhysicalDeviceFeatures2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain getFeatures2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html - template ::type = true> - void getProperties2( PhysicalDeviceProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html - template ::type = true> - VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetPhysicalDeviceProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain getProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html - template ::type = true> - void getFormatProperties2( Format format, - FormatProperties2 * pFormatProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html - template ::type = true> - VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2( Format format, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getFormatProperties2( Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, - ImageFormatProperties2 * pImageFormatProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template ::type = true> - void getQueueFamilyProperties2( uint32_t * pQueueFamilyPropertyCount, - QueueFamilyProperties2 * pQueueFamilyProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getQueueFamilyProperties2( QueueFamilyProperties2Allocator const & queueFamilyProperties2Allocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getQueueFamilyProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getQueueFamilyProperties2( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html - template ::type = true> - void getMemoryProperties2( PhysicalDeviceMemoryProperties2 * pMemoryProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html - template ::type = true> - VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2 - getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getMemoryProperties2( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html - template ::type = true> - void getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, - uint32_t * pPropertyCount, - SparseImageFormatProperties2 * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html - template < - typename SparseImageFormatProperties2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html - template < - typename SparseImageFormatProperties2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, - SparseImageFormatProperties2Allocator const & sparseImageFormatProperties2Allocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html - template ::type = true> - void getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, - ExternalBufferProperties * pExternalBufferProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD ExternalBufferProperties getExternalBufferProperties( - const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html - template ::type = true> - void getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, - ExternalFenceProperties * pExternalFenceProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD ExternalFenceProperties getExternalFenceProperties( - const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html - template ::type = true> - void getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, - ExternalSemaphoreProperties * pExternalSemaphoreProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD ExternalSemaphoreProperties - getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_3 === - - // wrapper function for command vkGetPhysicalDeviceToolProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getToolProperties( uint32_t * pToolCount, - PhysicalDeviceToolProperties * pToolProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceToolProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html - template < - typename PhysicalDeviceToolPropertiesAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getToolProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceToolProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html - template < - typename PhysicalDeviceToolPropertiesAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getToolProperties( PhysicalDeviceToolPropertiesAllocator const & physicalDeviceToolPropertiesAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_surface === - - // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSurfaceSupportKHR( uint32_t queueFamilyIndex, - SurfaceKHR surface, - Bool32 * pSupported, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getSurfaceSupportKHR( uint32_t queueFamilyIndex, SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSurfaceCapabilitiesKHR( SurfaceKHR surface, - SurfaceCapabilitiesKHR * pSurfaceCapabilities, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getSurfaceCapabilitiesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSurfaceFormatsKHR( SurfaceKHR surface, - uint32_t * pSurfaceFormatCount, - SurfaceFormatKHR * pSurfaceFormats, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfaceFormatsKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfaceFormatsKHR( - SurfaceKHR surface, SurfaceFormatKHRAllocator const & surfaceFormatKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSurfacePresentModesKHR( SurfaceKHR surface, - uint32_t * pPresentModeCount, - PresentModeKHR * pPresentModes, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfacePresentModesKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type getSurfacePresentModesKHR( - SurfaceKHR surface, PresentModeKHRAllocator const & presentModeKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_swapchain === - - // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getPresentRectanglesKHR( SurfaceKHR surface, - uint32_t * pRectCount, - Rect2D * pRects, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPresentRectanglesKHR( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPresentRectanglesKHR( SurfaceKHR surface, Rect2DAllocator const & rect2DAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_display === - - // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDisplayPropertiesKHR( uint32_t * pPropertyCount, - DisplayPropertiesKHR * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayPropertiesKHR( DisplayPropertiesKHRAllocator const & displayPropertiesKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDisplayPlanePropertiesKHR( uint32_t * pPropertyCount, - DisplayPlanePropertiesKHR * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayPlanePropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayPlanePropertiesKHR( DisplayPlanePropertiesKHRAllocator const & displayPlanePropertiesKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, - uint32_t * pDisplayCount, - DisplayKHR * pDisplays, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlaneSupportedDisplaysKHR( - uint32_t planeIndex, DisplayKHRAllocator const & displayKHRAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDisplayModePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDisplayModePropertiesKHR( DisplayKHR display, - uint32_t * pPropertyCount, - DisplayModePropertiesKHR * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDisplayModePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayModePropertiesKHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetDisplayModePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayModePropertiesKHR( DisplayKHR display, - DisplayModePropertiesKHRAllocator const & displayModePropertiesKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDisplayModeKHR( DisplayKHR display, - const DisplayModeCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - DisplayModeKHR * pMode, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDisplayModeKHR( DisplayKHR display, - const DisplayModeCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDisplayModeKHRUnique( DisplayKHR display, - const DisplayModeCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, - uint32_t planeIndex, - DisplayPlaneCapabilitiesKHR * pCapabilities, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getDisplayPlaneCapabilitiesKHR( DisplayModeKHR mode, uint32_t planeIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - - // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html - template ::type = true> - Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, - Display * dpy, - VisualID visualID, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html - template ::type = true> - Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, - Display & dpy, - VisualID visualID, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - - // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html - template ::type = true> - Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, - xcb_connection_t * connection, - xcb_visualid_t visual_id, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html - template ::type = true> - Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, - xcb_connection_t & connection, - xcb_visualid_t visual_id, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - - // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html - template ::type = true> - Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, - struct wl_display * display, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html - template ::type = true> - Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, - struct wl_display & display, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - - // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html - template ::type = true> - Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_video_queue === - - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VideoProfileInfoKHR * pVideoProfile, - VideoCapabilitiesKHR * pCapabilities, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR * pVideoFormatInfo, - uint32_t * pVideoFormatPropertyCount, - VideoFormatPropertiesKHR * pVideoFormatProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, - VideoFormatPropertiesKHRAllocator const & videoFormatPropertiesKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo, - StructureChainAllocator & structureChainAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_external_memory_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getExternalImageFormatPropertiesNV( Format format, - ImageType type, - ImageTiling tiling, - ImageUsageFlags usage, - ImageCreateFlags flags, - ExternalMemoryHandleTypeFlagsNV externalHandleType, - ExternalImageFormatPropertiesNV * pExternalImageFormatProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getExternalImageFormatPropertiesNV( Format format, - ImageType type, - ImageTiling tiling, - ImageUsageFlags usage, - ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_get_physical_device_properties2 === - - // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html - template ::type = true> - void getFeatures2KHR( PhysicalDeviceFeatures2 * pFeatures, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain getFeatures2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html - template ::type = true> - void getProperties2KHR( PhysicalDeviceProperties2 * pProperties, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain getProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html - template ::type = true> - void getFormatProperties2KHR( Format format, - FormatProperties2 * pFormatProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2KHR( Format format, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getFormatProperties2KHR( Format format, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, - ImageFormatProperties2 * pImageFormatProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template ::type = true> - void getQueueFamilyProperties2KHR( uint32_t * pQueueFamilyPropertyCount, - QueueFamilyProperties2 * pQueueFamilyProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getQueueFamilyProperties2KHR( QueueFamilyProperties2Allocator const & queueFamilyProperties2Allocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getQueueFamilyProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getQueueFamilyProperties2KHR( StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html - template ::type = true> - void getMemoryProperties2KHR( PhysicalDeviceMemoryProperties2 * pMemoryProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2 - getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD StructureChain - getMemoryProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html - template ::type = true> - void getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 * pFormatInfo, - uint32_t * pPropertyCount, - SparseImageFormatProperties2 * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html - template < - typename SparseImageFormatProperties2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html - template < - typename SparseImageFormatProperties2Allocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD std::vector - getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo, - SparseImageFormatProperties2Allocator const & sparseImageFormatProperties2Allocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_external_memory_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html - template ::type = true> - void getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo * pExternalBufferInfo, - ExternalBufferProperties * pExternalBufferProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD ExternalBufferProperties getExternalBufferPropertiesKHR( - const PhysicalDeviceExternalBufferInfo & externalBufferInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_external_semaphore_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html - template ::type = true> - void getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo * pExternalSemaphoreInfo, - ExternalSemaphoreProperties * pExternalSemaphoreProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD ExternalSemaphoreProperties - getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_direct_mode_display === - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkReleaseDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - releaseDisplayEXT( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - -#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - - // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result acquireXlibDisplayEXT( Display * dpy, - DisplayKHR display, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - acquireXlibDisplayEXT( Display & dpy, DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getRandROutputDisplayEXT( Display * dpy, - RROutput rrOutput, - DisplayKHR * pDisplay, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getRandROutputDisplayEXTUnique( Display & dpy, RROutput rrOutput, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2EXT( SurfaceKHR surface, - SurfaceCapabilities2EXT * pSurfaceCapabilities, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getSurfaceCapabilities2EXT( SurfaceKHR surface, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_external_fence_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html - template ::type = true> - void getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo * pExternalFenceInfo, - ExternalFenceProperties * pExternalFenceProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD ExternalFenceProperties getExternalFencePropertiesKHR( - const PhysicalDeviceExternalFenceInfo & externalFenceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_performance_query === - - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, - uint32_t * pCounterCount, - PerformanceCounterKHR * pCounters, - PerformanceCounterDescriptionKHR * pCounterDescriptions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html - template , - typename PerformanceCounterDescriptionKHRAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value && - std::is_same::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, - std::vector>>::type - enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html - template , - typename PerformanceCounterDescriptionKHRAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value && - std::is_same::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, - std::vector>>::type - enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex, - PerformanceCounterKHRAllocator const & performanceCounterKHRAllocator, - PerformanceCounterDescriptionKHRAllocator const & performanceCounterDescriptionKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html - template ::type = true> - void getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR * pPerformanceQueryCreateInfo, - uint32_t * pNumPasses, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD uint32_t - getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_get_surface_capabilities2 === - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - SurfaceCapabilities2KHR * pSurfaceCapabilities, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - uint32_t * pSurfaceFormatCount, - SurfaceFormat2KHR * pSurfaceFormats, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, - SurfaceFormat2KHRAllocator const & surfaceFormat2KHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, - StructureChainAllocator & structureChainAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_get_display_properties2 === - - // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDisplayProperties2KHR( uint32_t * pPropertyCount, - DisplayProperties2KHR * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayProperties2KHR( DisplayProperties2KHRAllocator const & displayProperties2KHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDisplayPlaneProperties2KHR( uint32_t * pPropertyCount, - DisplayPlaneProperties2KHR * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayPlaneProperties2KHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayPlaneProperties2KHR( DisplayPlaneProperties2KHRAllocator const & displayPlaneProperties2KHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDisplayModeProperties2KHR( DisplayKHR display, - uint32_t * pPropertyCount, - DisplayModeProperties2KHR * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayModeProperties2KHR( DisplayKHR display, - DisplayModeProperties2KHRAllocator const & displayModeProperties2KHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDisplayModeProperties2KHR( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayModeProperties2KHR( - DisplayKHR display, StructureChainAllocator & structureChainAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR * pDisplayPlaneInfo, - DisplayPlaneCapabilities2KHR * pCapabilities, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_descriptor_heap === - - // wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html - template ::type = true> - DeviceSize getDescriptorSizeEXT( DescriptorType descriptorType, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_sample_locations === - - // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html - template ::type = true> - void getMultisamplePropertiesEXT( SampleCountFlagBits samples, - MultisamplePropertiesEXT * pMultisampleProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD MultisamplePropertiesEXT - getMultisamplePropertiesEXT( SampleCountFlagBits samples, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_calibrated_timestamps === - - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsEXT( uint32_t * pTimeDomainCount, - TimeDomainKHR * pTimeDomains, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCalibrateableTimeDomainsEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCalibrateableTimeDomainsEXT( TimeDomainKHRAllocator const & timeDomainKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_fragment_shading_rate === - - // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getFragmentShadingRatesKHR( uint32_t * pFragmentShadingRateCount, - PhysicalDeviceFragmentShadingRateKHR * pFragmentShadingRates, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html - template < - typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getFragmentShadingRatesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html - template < - typename PhysicalDeviceFragmentShadingRateKHRAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getFragmentShadingRatesKHR( PhysicalDeviceFragmentShadingRateKHRAllocator const & physicalDeviceFragmentShadingRateKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_EXT_tooling_info === - - // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getToolPropertiesEXT( uint32_t * pToolCount, - PhysicalDeviceToolProperties * pToolProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html - template < - typename PhysicalDeviceToolPropertiesAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getToolPropertiesEXT( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html - template < - typename PhysicalDeviceToolPropertiesAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getToolPropertiesEXT( PhysicalDeviceToolPropertiesAllocator const & physicalDeviceToolPropertiesAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_cooperative_matrix === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesNV( uint32_t * pPropertyCount, - CooperativeMatrixPropertiesNV * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html - template < - typename CooperativeMatrixPropertiesNVAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCooperativeMatrixPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html - template < - typename CooperativeMatrixPropertiesNVAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNVAllocator const & cooperativeMatrixPropertiesNVAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_coverage_reduction_mode === - - // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - getSupportedFramebufferMixedSamplesCombinationsNV( uint32_t * pCombinationCount, - FramebufferMixedSamplesCombinationNV * pCombinations, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html - template < - typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSupportedFramebufferMixedSamplesCombinationsNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html - template < - typename FramebufferMixedSamplesCombinationNVAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSupportedFramebufferMixedSamplesCombinationsNV( FramebufferMixedSamplesCombinationNVAllocator const & framebufferMixedSamplesCombinationNVAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - uint32_t * pPresentModeCount, - PresentModeKHR * pPresentModes, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo, - PresentModeKHRAllocator const & presentModeKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_acquire_drm_display === - -#ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result acquireDrmDisplayEXT( int32_t drmFd, - DisplayKHR display, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#else - // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - acquireDrmDisplayEXT( int32_t drmFd, DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getDrmDisplayEXT( int32_t drmFd, - uint32_t connectorId, - DisplayKHR * display, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDrmDisplayEXTUnique( int32_t drmFd, uint32_t connectorId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_video_encode_queue === - - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, - VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - -# ifdef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result acquireWinrtDisplayNV( DisplayKHR display, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# else - // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html - template ::type = true> - VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type - acquireWinrtDisplayNV( DisplayKHR display, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getWinrtDisplayNV( uint32_t deviceRelativeId, - DisplayKHR * pDisplay, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type getWinrtDisplayNV( uint32_t deviceRelativeId, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getWinrtDisplayNVUnique( uint32_t deviceRelativeId, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - - // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html - template ::type = true> - Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, - IDirectFB * dfb, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html - template ::type = true> - Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, - IDirectFB & dfb, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - - // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html - template ::type = true> - Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, - struct _screen_window * window, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html - template ::type = true> - Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, - struct _screen_window & window, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_ARM_tensors === - - // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html - template ::type = true> - void getExternalTensorPropertiesARM( const PhysicalDeviceExternalTensorInfoARM * pExternalTensorInfo, - ExternalTensorPropertiesARM * pExternalTensorProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html - template ::type = true> - VULKAN_HPP_NODISCARD ExternalTensorPropertiesARM getExternalTensorPropertiesARM( - const PhysicalDeviceExternalTensorInfoARM & externalTensorInfo, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_optical_flow === - - // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV * pOpticalFlowImageFormatInfo, - uint32_t * pFormatCount, - OpticalFlowImageFormatPropertiesNV * pImageFormatProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo, - OpticalFlowImageFormatPropertiesNVAllocator const & opticalFlowImageFormatPropertiesNVAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_cooperative_vector === - - // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getCooperativeVectorPropertiesNV( uint32_t * pPropertyCount, - CooperativeVectorPropertiesNV * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html - template < - typename CooperativeVectorPropertiesNVAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCooperativeVectorPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html - template < - typename CooperativeVectorPropertiesNVAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCooperativeVectorPropertiesNV( CooperativeVectorPropertiesNVAllocator const & cooperativeVectorPropertiesNVAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_cooperative_matrix === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getCooperativeMatrixPropertiesKHR( uint32_t * pPropertyCount, - CooperativeMatrixPropertiesKHR * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html - template < - typename CooperativeMatrixPropertiesKHRAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCooperativeMatrixPropertiesKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html - template < - typename CooperativeMatrixPropertiesKHRAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHRAllocator const & cooperativeMatrixPropertiesKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_ARM_data_graph === - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, - uint32_t * pQueueFamilyDataGraphPropertyCount, - QueueFamilyDataGraphPropertiesARM * pQueueFamilyDataGraphProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex, - QueueFamilyDataGraphPropertiesARMAllocator const & queueFamilyDataGraphPropertiesARMAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html - template ::type = true> - void getQueueFamilyDataGraphProcessingEnginePropertiesARM( - const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM * pQueueFamilyDataGraphProcessingEngineInfo, - QueueFamilyDataGraphProcessingEnginePropertiesARM * pQueueFamilyDataGraphProcessingEngineProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html - template ::type = true> - VULKAN_HPP_NODISCARD QueueFamilyDataGraphProcessingEnginePropertiesARM getQueueFamilyDataGraphProcessingEnginePropertiesARM( - const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & queueFamilyDataGraphProcessingEngineInfo, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_calibrated_timestamps === - - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result getCalibrateableTimeDomainsKHR( uint32_t * pTimeDomainCount, - TimeDomainKHR * pTimeDomains, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCalibrateableTimeDomainsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCalibrateableTimeDomainsKHR( TimeDomainKHRAllocator const & timeDomainKHRAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_NV_cooperative_matrix2 === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - getCooperativeMatrixFlexibleDimensionsPropertiesNV( uint32_t * pPropertyCount, - CooperativeMatrixFlexibleDimensionsPropertiesNV * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD - typename ResultValueType>::type - getCooperativeMatrixFlexibleDimensionsPropertiesNV( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD - typename ResultValueType>::type - getCooperativeMatrixFlexibleDimensionsPropertiesNV( - CooperativeMatrixFlexibleDimensionsPropertiesNVAllocator const & cooperativeMatrixFlexibleDimensionsPropertiesNVAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_ARM_performance_counters_by_region === - - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html - template ::type = true> - VULKAN_HPP_NODISCARD Result - enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, - uint32_t * pCounterCount, - PerformanceCounterARM * pCounters, - PerformanceCounterDescriptionARM * pCounterDescriptions, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html - template , - typename PerformanceCounterDescriptionARMAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value && - std::is_same::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, - std::vector>>::type - enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html - template , - typename PerformanceCounterDescriptionARMAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value && - std::is_same::value, - int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType, - std::vector>>::type - enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex, - PerformanceCounterARMAllocator const & performanceCounterARMAllocator, - PerformanceCounterDescriptionARMAllocator const & performanceCounterDescriptionARMAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - operator VkPhysicalDevice() const VULKAN_HPP_NOEXCEPT - { - return m_physicalDevice; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_physicalDevice != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_physicalDevice == VK_NULL_HANDLE; - } - - private: - VkPhysicalDevice m_physicalDevice = {}; - }; - - template <> - struct CppType - { - using Type = PhysicalDevice; - }; - - template <> - struct CppType - { - using Type = PhysicalDevice; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = PhysicalDevice; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstance.html - class Instance - { - public: - using CType = VkInstance; - using NativeType = VkInstance; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eInstance; - - public: - Instance() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue - - Instance( Instance const & rhs ) = default; - Instance & operator=( Instance const & rhs ) = default; - -#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) - Instance( Instance && rhs ) = default; - Instance & operator=( Instance && rhs ) = default; -#else - Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT : m_instance( exchange( rhs.m_instance, {} ) ) {} - - Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT - { - m_instance = exchange( rhs.m_instance, {} ); - return *this; - } -#endif - - VULKAN_HPP_CONSTEXPR Instance( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} - - Instance( VkInstance instance ) VULKAN_HPP_NOEXCEPT : m_instance( instance ) {} - - Instance & operator=( VkInstance instance ) VULKAN_HPP_NOEXCEPT - { - m_instance = instance; - return *this; - } - - Instance & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - m_instance = {}; - return *this; - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html - template ::type = true> - void destroy( const AllocationCallbacks * pAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyInstance.html - template ::type = true> - void destroy( Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html - template ::type = true> - VULKAN_HPP_NODISCARD Result enumeratePhysicalDevices( uint32_t * pPhysicalDeviceCount, - PhysicalDevice * pPhysicalDevices, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumeratePhysicalDevices( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumeratePhysicalDevices( PhysicalDeviceAllocator const & physicalDeviceAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html - template ::type = true> - PFN_vkVoidFunction getProcAddr( const char * pName, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html - template ::type = true> - PFN_VoidFunction getProcAddr( const std::string & name, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkEnumeratePhysicalDeviceGroups, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html - template ::type = true> - VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroups( uint32_t * pPhysicalDeviceGroupCount, - PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumeratePhysicalDeviceGroups, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html - template < - typename PhysicalDeviceGroupPropertiesAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumeratePhysicalDeviceGroups( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkEnumeratePhysicalDeviceGroups, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html - template < - typename PhysicalDeviceGroupPropertiesAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumeratePhysicalDeviceGroups( PhysicalDeviceGroupPropertiesAllocator const & physicalDeviceGroupPropertiesAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_surface === - - // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html - template ::type = true> - void destroySurfaceKHR( SurfaceKHR surface, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html - template ::type = true> - void destroySurfaceKHR( SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html - template ::type = true> - void destroy( SurfaceKHR surface, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroySurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySurfaceKHR.html - template ::type = true> - void destroy( SurfaceKHR surface, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_KHR_display === - - // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDisplayPlaneSurfaceKHR( const DisplaySurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDisplayPlaneSurfaceKHRUnique( const DisplaySurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - - // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createXlibSurfaceKHR( const XlibSurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createXlibSurfaceKHRUnique( const XlibSurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - - // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createXcbSurfaceKHR( const XcbSurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createXcbSurfaceKHRUnique( const XcbSurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - - // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createWaylandSurfaceKHR( const WaylandSurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createWaylandSurfaceKHRUnique( const WaylandSurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - - // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createAndroidSurfaceKHR( const AndroidSurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createAndroidSurfaceKHRUnique( const AndroidSurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - - // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createWin32SurfaceKHR( const Win32SurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createWin32SurfaceKHRUnique( const Win32SurfaceCreateInfoKHR & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - - // wrapper function for command vkCreateDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - DebugReportCallbackEXT * pCallback, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDebugReportCallbackEXT( const DebugReportCallbackCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDebugReportCallbackEXTUnique( const DebugReportCallbackCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html - template ::type = true> - void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html - template ::type = true> - void destroyDebugReportCallbackEXT( DebugReportCallbackEXT callback VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html - template ::type = true> - void destroy( DebugReportCallbackEXT callback, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugReportCallbackEXT.html - template ::type = true> - void destroy( DebugReportCallbackEXT callback, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html - template ::type = true> - void debugReportMessageEXT( DebugReportFlagsEXT flags, - DebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char * pLayerPrefix, - const char * pMessage, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html - template ::type = true> - void debugReportMessageEXT( DebugReportFlagsEXT flags, - DebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const std::string & layerPrefix, - const std::string & message, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - - // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createStreamDescriptorSurfaceGGP( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createStreamDescriptorSurfaceGGPUnique( const StreamDescriptorSurfaceCreateInfoGGP & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_GGP*/ - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - - // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createViSurfaceNN( const ViSurfaceCreateInfoNN * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createViSurfaceNN( const ViSurfaceCreateInfoNN & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createViSurfaceNNUnique( const ViSurfaceCreateInfoNN & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_device_group_creation === - - // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html - template ::type = true> - VULKAN_HPP_NODISCARD Result enumeratePhysicalDeviceGroupsKHR( uint32_t * pPhysicalDeviceGroupCount, - PhysicalDeviceGroupProperties * pPhysicalDeviceGroupProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html - template < - typename PhysicalDeviceGroupPropertiesAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumeratePhysicalDeviceGroupsKHR( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; - // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html - template < - typename PhysicalDeviceGroupPropertiesAllocator = std::allocator, - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumeratePhysicalDeviceGroupsKHR( PhysicalDeviceGroupPropertiesAllocator const & physicalDeviceGroupPropertiesAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - - // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createIOSSurfaceMVK( const IOSSurfaceCreateInfoMVK & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createIOSSurfaceMVKUnique( const IOSSurfaceCreateInfoMVK & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - - // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createMacOSSurfaceMVK( const MacOSSurfaceCreateInfoMVK & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createMacOSSurfaceMVKUnique( const MacOSSurfaceCreateInfoMVK & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - - // wrapper function for command vkCreateDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - DebugUtilsMessengerEXT * pMessenger, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDebugUtilsMessengerEXT( const DebugUtilsMessengerCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDebugUtilsMessengerEXTUnique( const DebugUtilsMessengerCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html - template ::type = true> - void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html - template ::type = true> - void destroyDebugUtilsMessengerEXT( DebugUtilsMessengerEXT messenger VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html - template ::type = true> - void destroy( DebugUtilsMessengerEXT messenger, - const AllocationCallbacks * pAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkDestroyDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDebugUtilsMessengerEXT.html - template ::type = true> - void destroy( DebugUtilsMessengerEXT messenger, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkSubmitDebugUtilsMessageEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html - template ::type = true> - void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - DebugUtilsMessageTypeFlagsEXT messageTypes, - const DebugUtilsMessengerCallbackDataEXT * pCallbackData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkSubmitDebugUtilsMessageEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html - template ::type = true> - void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - DebugUtilsMessageTypeFlagsEXT messageTypes, - const DebugUtilsMessengerCallbackDataEXT & callbackData, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - - // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createImagePipeSurfaceFUCHSIA( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createImagePipeSurfaceFUCHSIAUnique( const ImagePipeSurfaceCreateInfoFUCHSIA & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - - // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createMetalSurfaceEXT( const MetalSurfaceCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createMetalSurfaceEXTUnique( const MetalSurfaceCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_headless_surface === - - // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createHeadlessSurfaceEXT( const HeadlessSurfaceCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createHeadlessSurfaceEXTUnique( const HeadlessSurfaceCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - - // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDirectFBSurfaceEXT( const DirectFBSurfaceCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDirectFBSurfaceEXTUnique( const DirectFBSurfaceCreateInfoEXT & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - - // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createScreenSurfaceQNX( const ScreenSurfaceCreateInfoQNX & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createScreenSurfaceQNXUnique( const ScreenSurfaceCreateInfoQNX & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - - // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createSurfaceOHOS( const SurfaceCreateInfoOHOS * pCreateInfo, - const AllocationCallbacks * pAllocator, - SurfaceKHR * pSurface, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; -# ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSurfaceOHOS( const SurfaceCreateInfoOHOS & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createSurfaceOHOSUnique( const SurfaceCreateInfoOHOS & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -# endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ -#endif /*VK_USE_PLATFORM_OHOS*/ - - operator VkInstance() const VULKAN_HPP_NOEXCEPT - { - return m_instance; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return m_instance != VK_NULL_HANDLE; - } - - bool operator!() const VULKAN_HPP_NOEXCEPT - { - return m_instance == VK_NULL_HANDLE; - } - - private: - VkInstance m_instance = {}; - }; - - template <> - struct CppType - { - using Type = Instance; - }; - - template <> - struct CppType - { - using Type = Instance; - }; - -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) - template <> - struct CppType - { - using Type = Instance; - }; -#endif - - template <> - struct isVulkanHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html - template ::type = true> - VULKAN_HPP_NODISCARD Result createInstance( const InstanceCreateInfo * pCreateInfo, - const AllocationCallbacks * pAllocator, - Instance * pInstance, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type - createInstance( const InstanceCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); -# ifndef VULKAN_HPP_NO_SMART_HANDLE - // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createInstanceUnique( const InstanceCreateInfo & createInfo, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); -# endif /* VULKAN_HPP_NO_SMART_HANDLE */ -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkEnumerateInstanceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD Result enumerateInstanceExtensionProperties( const char * pLayerName, - uint32_t * pPropertyCount, - ExtensionProperties * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumerateInstanceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateInstanceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); - // wrapper function for command vkEnumerateInstanceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateInstanceExtensionProperties( Optional layerName, - ExtensionPropertiesAllocator const & extensionPropertiesAllocator, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // wrapper function for command vkEnumerateInstanceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html - template ::type = true> - VULKAN_HPP_NODISCARD Result enumerateInstanceLayerProperties( uint32_t * pPropertyCount, - LayerProperties * pProperties, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumerateInstanceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateInstanceLayerProperties( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); - // wrapper function for command vkEnumerateInstanceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html - template , - typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, - typename std::enable_if::value, int>::type = 0, - typename std::enable_if::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateInstanceLayerProperties( LayerPropertiesAllocator const & layerPropertiesAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html - template ::type = true> - VULKAN_HPP_NODISCARD Result enumerateInstanceVersion( uint32_t * pApiVersion, - Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT; -#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE - // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html - template ::type = true> - VULKAN_HPP_NODISCARD typename ResultValueType::type enumerateInstanceVersion( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ); -#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ - - // operators to compare VULKAN_HPP_NAMESPACE::-handles - template ::value, int>::type = 0> - bool operator==( T const & lhs, T const & rhs ) - { - return static_cast( lhs ) == static_cast( rhs ); - } - - template ::value, int>::type = 0> - bool operator!=( T const & lhs, T const & rhs ) - { - return static_cast( lhs ) != static_cast( rhs ); - } - - template ::value, int>::type = 0> - bool operator<( T const & lhs, T const & rhs ) - { - return static_cast( lhs ) < static_cast( rhs ); - } - - template ::value, int>::type = 0> - bool operator<=( T const & lhs, T const & rhs ) - { - return static_cast( lhs ) <= static_cast( rhs ); - } - - template ::value, int>::type = 0> - bool operator>( T const & lhs, T const & rhs ) - { - return static_cast( lhs ) > static_cast( rhs ); - } - - template ::value, int>::type = 0> - bool operator>=( T const & lhs, T const & rhs ) - { - return static_cast( lhs ) >= static_cast( rhs ); - } - - template ::value, int>::type = 0> - bool operator==( T const & v, std::nullptr_t ) - { - return !v; - } - - template ::value, int>::type = 0> - bool operator==( std::nullptr_t, T const & v ) - { - return !v; - } - - template ::value, int>::type = 0> - bool operator!=( T const & v, std::nullptr_t ) - { - return !!v; - } - - template ::value, int>::type = 0> - bool operator!=( std::nullptr_t, T const & v ) - { - return !!v; - } -} // namespace VULKAN_HPP_NAMESPACE -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_hash.hpp b/lib/vulkan-headers/include/vulkan/vulkan_hash.hpp deleted file mode 100644 index a0992e7a9dc..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_hash.hpp +++ /dev/null @@ -1,21424 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_HASH_HPP -#define VULKAN_HASH_HPP - -#include - -namespace std -{ - //======================================= - //=== HASH structures for Flags types === - //======================================= - - template - struct hash> - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Flags const & flags ) const VULKAN_HPP_NOEXCEPT - { - return std::hash::type>{}( static_cast::type>( flags ) ); - } - }; - - //=================================== - //=== HASH structures for handles === - //=================================== - - //=== VK_VERSION_1_0 === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Instance const & instance ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( instance ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice const & physicalDevice ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( physicalDevice ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Device const & device ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( device ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Queue const & queue ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( queue ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemory const & deviceMemory ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( deviceMemory ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Fence const & fence ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( fence ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Semaphore const & semaphore ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( semaphore ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPool const & queryPool ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( queryPool ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Buffer const & buffer ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( buffer ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Image const & image ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( image ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageView const & imageView ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( imageView ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPool const & commandPool ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( commandPool ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBuffer const & commandBuffer ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( commandBuffer ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Event const & event ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( event ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferView const & bufferView ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( bufferView ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModule const & shaderModule ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( shaderModule ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCache const & pipelineCache ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( pipelineCache ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Pipeline const & pipeline ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( pipeline ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayout const & pipelineLayout ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( pipelineLayout ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Sampler const & sampler ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( sampler ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPool const & descriptorPool ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( descriptorPool ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSet const & descriptorSet ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( descriptorSet ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & descriptorSetLayout ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( descriptorSetLayout ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Framebuffer const & framebuffer ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( framebuffer ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPass const & renderPass ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( renderPass ) ); - } - }; - - //=== VK_VERSION_1_1 === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & descriptorUpdateTemplate ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( descriptorUpdateTemplate ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & samplerYcbcrConversion ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( samplerYcbcrConversion ) ); - } - }; - - //=== VK_VERSION_1_3 === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlot const & privateDataSlot ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( privateDataSlot ) ); - } - }; - - //=== VK_KHR_surface === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceKHR const & surfaceKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( surfaceKHR ) ); - } - }; - - //=== VK_KHR_swapchain === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainKHR const & swapchainKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( swapchainKHR ) ); - } - }; - - //=== VK_KHR_display === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayKHR const & displayKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( displayKHR ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeKHR const & displayModeKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( displayModeKHR ) ); - } - }; - - //=== VK_EXT_debug_report === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & debugReportCallbackEXT ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( debugReportCallbackEXT ) ); - } - }; - - //=== VK_KHR_video_queue === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionKHR const & videoSessionKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( videoSessionKHR ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & videoSessionParametersKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( videoSessionParametersKHR ) ); - } - }; - - //=== VK_NVX_binary_import === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleNVX const & cuModuleNVX ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( cuModuleNVX ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionNVX const & cuFunctionNVX ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( cuFunctionNVX ) ); - } - }; - - //=== VK_EXT_debug_utils === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & debugUtilsMessengerEXT ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( debugUtilsMessengerEXT ) ); - } - }; - - //=== VK_EXT_descriptor_heap === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorARM const & tensorARM ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( tensorARM ) ); - } - }; - - //=== VK_KHR_acceleration_structure === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & accelerationStructureKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( accelerationStructureKHR ) ); - } - }; - - //=== VK_EXT_validation_cache === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & validationCacheEXT ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( validationCacheEXT ) ); - } - }; - - //=== VK_NV_ray_tracing === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & accelerationStructureNV ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( accelerationStructureNV ) ); - } - }; - - //=== VK_INTEL_performance_query === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & performanceConfigurationINTEL ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( performanceConfigurationINTEL ) ); - } - }; - - //=== VK_KHR_deferred_host_operations === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & deferredOperationKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( deferredOperationKHR ) ); - } - }; - - //=== VK_NV_device_generated_commands === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & indirectCommandsLayoutNV ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( indirectCommandsLayoutNV ) ); - } - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleNV const & cudaModuleNV ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( cudaModuleNV ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionNV const & cudaFunctionNV ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( cudaFunctionNV ) ); - } - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & bufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( bufferCollectionFUCHSIA ) ); - } - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_EXT_opacity_micromap === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapEXT const & micromapEXT ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( micromapEXT ) ); - } - }; - - //=== VK_ARM_tensors === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorViewARM const & tensorViewARM ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( tensorViewARM ) ); - } - }; - - //=== VK_NV_optical_flow === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & opticalFlowSessionNV ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( opticalFlowSessionNV ) ); - } - }; - - //=== VK_EXT_shader_object === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderEXT const & shaderEXT ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( shaderEXT ) ); - } - }; - - //=== VK_KHR_pipeline_binary === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const & pipelineBinaryKHR ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( pipelineBinaryKHR ) ); - } - }; - - //=== VK_ARM_data_graph === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM const & dataGraphPipelineSessionARM ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( dataGraphPipelineSessionARM ) ); - } - }; - - //=== VK_NV_external_compute_queue === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV const & externalComputeQueueNV ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( externalComputeQueueNV ) ); - } - }; - - //=== VK_EXT_device_generated_commands === - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT const & indirectCommandsLayoutEXT ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( indirectCommandsLayoutEXT ) ); - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT const & indirectExecutionSetEXT ) const VULKAN_HPP_NOEXCEPT - { - return std::hash{}( static_cast( indirectExecutionSetEXT ) ); - } - }; - -#if 14 <= VULKAN_HPP_CPP_VERSION - //====================================== - //=== HASH structures for structures === - //====================================== - -# if !defined( VULKAN_HPP_HASH_COMBINE ) -# define VULKAN_HPP_HASH_COMBINE( seed, value ) \ - seed ^= std::hash::type>{}( value ) + 0x9e3779b9 + ( seed << 6 ) + ( seed >> 2 ) -# endif - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AabbPositionsKHR const & aabbPositionsKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minX ); - VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minY ); - VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.minZ ); - VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxX ); - VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxY ); - VULKAN_HPP_HASH_COMBINE( seed, aabbPositionsKHR.maxZ ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR const & accelerationStructureBuildRangeInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveCount ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.primitiveOffset ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.firstVertex ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildRangeInfoKHR.transformOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR const & accelerationStructureBuildSizesInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.accelerationStructureSize ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.updateScratchSize ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureBuildSizesInfoKHR.buildScratchSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT const & accelerationStructureCaptureDescriptorDataInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructure ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCaptureDescriptorDataInfoEXT.accelerationStructureNV ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR const & accelerationStructureCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.createFlags ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.buffer ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.offset ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.size ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.type ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoKHR.deviceAddress ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV const & geometryTrianglesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexData ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexOffset ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexCount ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexStride ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.vertexFormat ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexData ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexOffset ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexCount ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.indexType ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformData ); - VULKAN_HPP_HASH_COMBINE( seed, geometryTrianglesNV.transformOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryAABBNV const & geometryAABBNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.aabbData ); - VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.numAABBs ); - VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.stride ); - VULKAN_HPP_HASH_COMBINE( seed, geometryAABBNV.offset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryDataNV const & geometryDataNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.triangles ); - VULKAN_HPP_HASH_COMBINE( seed, geometryDataNV.aabbs ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeometryNV const & geometryNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, geometryNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, geometryNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometryType ); - VULKAN_HPP_HASH_COMBINE( seed, geometryNV.geometry ); - VULKAN_HPP_HASH_COMBINE( seed, geometryNV.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV const & accelerationStructureInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.type ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.instanceCount ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.geometryCount ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInfoNV.pGeometries ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV const & accelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.compactedSize ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureCreateInfoNV.info ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR const & accelerationStructureDeviceAddressInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureDeviceAddressInfoKHR.accelerationStructure ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TransformMatrixKHR const & transformMatrixKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - for ( size_t i = 0; i < 3; ++i ) - { - for ( size_t j = 0; j < 4; ++j ) - { - VULKAN_HPP_HASH_COMBINE( seed, transformMatrixKHR.matrix[i][j] ); - } - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR const & accelerationStructureInstanceKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.transform ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceCustomIndex ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.mask ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.instanceShaderBindingTableRecordOffset ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureInstanceKHR.accelerationStructureReference ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV const & accelerationStructureMatrixMotionInstanceNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT0 ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.transformT1 ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceCustomIndex ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.mask ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.instanceShaderBindingTableRecordOffset ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.flags ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMatrixMotionInstanceNV.accelerationStructureReference ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV const & accelerationStructureMemoryRequirementsInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.type ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMemoryRequirementsInfoNV.accelerationStructure ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV const & accelerationStructureMotionInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.maxInstances ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureMotionInfoNV.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SRTDataNV const & sRTDataNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sx ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.a ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.b ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvx ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sy ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.c ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvy ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.sz ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.pvz ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qx ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qy ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qz ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.qw ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tx ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.ty ); - VULKAN_HPP_HASH_COMBINE( seed, sRTDataNV.tz ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV const & accelerationStructureSRTMotionInstanceNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT0 ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.transformT1 ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceCustomIndex ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.mask ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.instanceShaderBindingTableRecordOffset ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.flags ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureSRTMotionInstanceNV.accelerationStructureReference ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapUsageEXT const & micromapUsageEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.count ); - VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.subdivisionLevel ); - VULKAN_HPP_HASH_COMBINE( seed, micromapUsageEXT.format ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR const & accelerationStructureVersionInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, accelerationStructureVersionInfoKHR.pVersionData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR const & acquireNextImageInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.swapchain ); - VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.timeout ); - VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.semaphore ); - VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.fence ); - VULKAN_HPP_HASH_COMBINE( seed, acquireNextImageInfoKHR.deviceMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR const & acquireProfilingLockInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, acquireProfilingLockInfoKHR.timeout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AllocationCallbacks const & allocationCallbacks ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pUserData ); - VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnAllocation ); - VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnReallocation ); - VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnFree ); - VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalAllocation ); - VULKAN_HPP_HASH_COMBINE( seed, allocationCallbacks.pfnInternalFree ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC const & amigoProfilingSubmitInfoSEC ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.sType ); - VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.firstDrawTimestamp ); - VULKAN_HPP_HASH_COMBINE( seed, amigoProfilingSubmitInfoSEC.swapBufferTimestamp ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ComponentMapping const & componentMapping ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, componentMapping.r ); - VULKAN_HPP_HASH_COMBINE( seed, componentMapping.g ); - VULKAN_HPP_HASH_COMBINE( seed, componentMapping.b ); - VULKAN_HPP_HASH_COMBINE( seed, componentMapping.a ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID const & androidHardwareBufferFormatProperties2ANDROID ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.format ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.externalFormat ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.formatFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.samplerYcbcrConversionComponents ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrModel ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYcbcrRange ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedXChromaOffset ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatProperties2ANDROID.suggestedYChromaOffset ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID const & androidHardwareBufferFormatPropertiesANDROID ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.format ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.externalFormat ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.formatFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.samplerYcbcrConversionComponents ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrModel ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYcbcrRange ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedXChromaOffset ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatPropertiesANDROID.suggestedYChromaOffset ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID const & androidHardwareBufferFormatResolvePropertiesANDROID ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferFormatResolvePropertiesANDROID.colorAttachmentFormat ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID const & androidHardwareBufferPropertiesANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.allocationSize ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferPropertiesANDROID.memoryTypeBits ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID const & androidHardwareBufferUsageANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, androidHardwareBufferUsageANDROID.androidHardwareBufferUsage ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR const & androidSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, androidSurfaceCreateInfoKHR.window ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD const & antiLagPresentationInfoAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.stage ); - VULKAN_HPP_HASH_COMBINE( seed, antiLagPresentationInfoAMD.frameIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AntiLagDataAMD const & antiLagDataAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.mode ); - VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.maxFPS ); - VULKAN_HPP_HASH_COMBINE( seed, antiLagDataAMD.pPresentationInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ApplicationInfo const & applicationInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.pNext ); - for ( const char * p = applicationInfo.pApplicationName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.applicationVersion ); - for ( const char * p = applicationInfo.pEngineName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.engineVersion ); - VULKAN_HPP_HASH_COMBINE( seed, applicationInfo.apiVersion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription const & attachmentDescription ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.flags ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.format ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.samples ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.loadOp ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.storeOp ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilLoadOp ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.stencilStoreOp ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.initialLayout ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription.finalLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescription2 const & attachmentDescription2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.flags ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.format ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.samples ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.loadOp ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.storeOp ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilLoadOp ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.stencilStoreOp ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.initialLayout ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescription2.finalLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout const & attachmentDescriptionStencilLayout ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.sType ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilInitialLayout ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentDescriptionStencilLayout.stencilFinalLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentFeedbackLoopInfoEXT const & attachmentFeedbackLoopInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, attachmentFeedbackLoopInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentFeedbackLoopInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentFeedbackLoopInfoEXT.feedbackLoopEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference const & attachmentReference ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.attachment ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentReference.layout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReference2 const & attachmentReference2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.attachment ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.layout ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentReference2.aspectMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout const & attachmentReferenceStencilLayout ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.sType ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentReferenceStencilLayout.stencilLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD const & attachmentSampleCountInfoAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.pColorAttachmentSamples ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleCountInfoAMD.depthStencilAttachmentSamples ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent2D const & extent2D ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, extent2D.width ); - VULKAN_HPP_HASH_COMBINE( seed, extent2D.height ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationEXT const & sampleLocationEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.x ); - VULKAN_HPP_HASH_COMBINE( seed, sampleLocationEXT.y ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT const & sampleLocationsInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsPerPixel ); - VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationGridSize ); - VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.sampleLocationsCount ); - VULKAN_HPP_HASH_COMBINE( seed, sampleLocationsInfoEXT.pSampleLocations ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT const & attachmentSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.attachmentIndex ); - VULKAN_HPP_HASH_COMBINE( seed, attachmentSampleLocationsEXT.sampleLocationsInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseInStructure const & baseInStructure ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.sType ); - VULKAN_HPP_HASH_COMBINE( seed, baseInStructure.pNext ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BaseOutStructure const & baseOutStructure ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.sType ); - VULKAN_HPP_HASH_COMBINE( seed, baseOutStructure.pNext ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BeginCustomResolveInfoEXT const & beginCustomResolveInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, beginCustomResolveInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, beginCustomResolveInfoEXT.pNext ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV const & bindAccelerationStructureMemoryInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.accelerationStructure ); - VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memory ); - VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.memoryOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.deviceIndexCount ); - VULKAN_HPP_HASH_COMBINE( seed, bindAccelerationStructureMemoryInfoNV.pDeviceIndices ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo const & bindBufferMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.deviceIndexCount ); - VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryDeviceGroupInfo.pDeviceIndices ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo const & bindBufferMemoryInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.buffer ); - VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memory ); - VULKAN_HPP_HASH_COMBINE( seed, bindBufferMemoryInfo.memoryOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BindDataGraphPipelineSessionMemoryInfoARM const & bindDataGraphPipelineSessionMemoryInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.session ); - VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.bindPoint ); - VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.objectIndex ); - VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.memory ); - VULKAN_HPP_HASH_COMBINE( seed, bindDataGraphPipelineSessionMemoryInfoARM.memoryOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT const & bindDescriptorBufferEmbeddedSamplersInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.stageFlags ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.layout ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorBufferEmbeddedSamplersInfoEXT.set ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo const & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.stageFlags ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.layout ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.firstSet ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.descriptorSetCount ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pDescriptorSets ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.dynamicOffsetCount ); - VULKAN_HPP_HASH_COMBINE( seed, bindDescriptorSetsInfo.pDynamicOffsets ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT const & deviceAddressRangeEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceAddressRangeEXT.address ); - VULKAN_HPP_HASH_COMBINE( seed, deviceAddressRangeEXT.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindHeapInfoEXT const & bindHeapInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.heapRange ); - VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.reservedRangeOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bindHeapInfoEXT.reservedRangeSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset2D const & offset2D ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, offset2D.x ); - VULKAN_HPP_HASH_COMBINE( seed, offset2D.y ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Rect2D const & rect2D ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, rect2D.offset ); - VULKAN_HPP_HASH_COMBINE( seed, rect2D.extent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo const & bindImageMemoryDeviceGroupInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.deviceIndexCount ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pDeviceIndices ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.splitInstanceBindRegionCount ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo const & bindImageMemoryInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.image ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memory ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemoryInfo.memoryOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR const & bindImageMemorySwapchainInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.swapchain ); - VULKAN_HPP_HASH_COMBINE( seed, bindImageMemorySwapchainInfoKHR.imageIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo const & bindImagePlaneMemoryInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindImagePlaneMemoryInfo.planeAspect ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT const & bindIndexBufferIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.bufferAddress ); - VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.size ); - VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandEXT.indexType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV const & bindIndexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.bufferAddress ); - VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.size ); - VULKAN_HPP_HASH_COMBINE( seed, bindIndexBufferIndirectCommandNV.indexType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindMemoryStatus const & bindMemoryStatus ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindMemoryStatus.pResult ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV const & bindPipelineIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindPipelineIndirectCommandNV.pipelineAddress ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV const & bindShaderGroupIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindShaderGroupIndirectCommandNV.groupIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseMemoryBind const & sparseMemoryBind ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.resourceOffset ); - VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.size ); - VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memory ); - VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.memoryOffset ); - VULKAN_HPP_HASH_COMBINE( seed, sparseMemoryBind.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo const & sparseBufferMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.buffer ); - VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.bindCount ); - VULKAN_HPP_HASH_COMBINE( seed, sparseBufferMemoryBindInfo.pBinds ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo const & sparseImageOpaqueMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.image ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.bindCount ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageOpaqueMemoryBindInfo.pBinds ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource const & imageSubresource ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.aspectMask ); - VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.mipLevel ); - VULKAN_HPP_HASH_COMBINE( seed, imageSubresource.arrayLayer ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Offset3D const & offset3D ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, offset3D.x ); - VULKAN_HPP_HASH_COMBINE( seed, offset3D.y ); - VULKAN_HPP_HASH_COMBINE( seed, offset3D.z ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Extent3D const & extent3D ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, extent3D.width ); - VULKAN_HPP_HASH_COMBINE( seed, extent3D.height ); - VULKAN_HPP_HASH_COMBINE( seed, extent3D.depth ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind const & sparseImageMemoryBind ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.subresource ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.offset ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.extent ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memory ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.memoryOffset ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBind.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo const & sparseImageMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.image ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.bindCount ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryBindInfo.pBinds ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindSparseInfo const & bindSparseInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.waitSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pWaitSemaphores ); - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.bufferBindCount ); - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pBufferBinds ); - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageOpaqueBindCount ); - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageOpaqueBinds ); - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.imageBindCount ); - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pImageBinds ); - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.signalSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( seed, bindSparseInfo.pSignalSemaphores ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindTensorMemoryInfoARM const & bindTensorMemoryInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.tensor ); - VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.memory ); - VULKAN_HPP_HASH_COMBINE( seed, bindTensorMemoryInfoARM.memoryOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT const & bindVertexBufferIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.bufferAddress ); - VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.size ); - VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandEXT.stride ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV const & bindVertexBufferIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.bufferAddress ); - VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.size ); - VULKAN_HPP_HASH_COMBINE( seed, bindVertexBufferIndirectCommandNV.stride ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR const & bindVideoSessionMemoryInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryBindIndex ); - VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memory ); - VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memoryOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bindVideoSessionMemoryInfoKHR.memorySize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM const & blitImageCubicWeightsInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, blitImageCubicWeightsInfoQCOM.cubicWeights ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers const & imageSubresourceLayers ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.aspectMask ); - VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.mipLevel ); - VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.baseArrayLayer ); - VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceLayers.layerCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit2 const & imageBlit2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcSubresource ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.srcOffsets[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstSubresource ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, imageBlit2.dstOffsets[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BlitImageInfo2 const & blitImageInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImage ); - VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.srcImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImage ); - VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.dstImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.pRegions ); - VULKAN_HPP_HASH_COMBINE( seed, blitImageInfo2.filter ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT const & bufferCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCaptureDescriptorDataInfoEXT.buffer ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA const & bufferCollectionBufferCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.collection ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionBufferCreateInfoFUCHSIA.index ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCount ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.maxBufferCount ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForCamping ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForDedicatedSlack ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionConstraintsInfoFUCHSIA.minBufferCountForSharedSlack ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA const & bufferCollectionCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionCreateInfoFUCHSIA.collectionToken ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA const & bufferCollectionImageCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.collection ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionImageCreateInfoFUCHSIA.index ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA const & sysmemColorSpaceFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, sysmemColorSpaceFUCHSIA.colorSpace ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA const & bufferCollectionPropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.memoryTypeBits ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.bufferCount ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.createInfoIndex ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemPixelFormat ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.formatFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.sysmemColorSpaceIndex ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.samplerYcbcrConversionComponents ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrModel ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYcbcrRange ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedXChromaOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCollectionPropertiesFUCHSIA.suggestedYChromaOffset ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCreateInfo const & bufferCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.size ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.usage ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.sharingMode ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.queueFamilyIndexCount ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCreateInfo.pQueueFamilyIndices ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA const & bufferConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.createInfo ); - VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.requiredFormatFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, bufferConstraintsInfoFUCHSIA.bufferCollectionConstraints ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy const & bufferCopy ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.srcOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.dstOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCopy.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferCopy2 const & bufferCopy2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.srcOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.dstOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferCopy2.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT const & bufferDeviceAddressCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressCreateInfoEXT.deviceAddress ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo const & bufferDeviceAddressInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferDeviceAddressInfo.buffer ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy const & bufferImageCopy ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferRowLength ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.bufferImageHeight ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy.imageExtent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferImageCopy2 const & bufferImageCopy2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferRowLength ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.bufferImageHeight ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageOffset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferImageCopy2.imageExtent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier const & bufferMemoryBarrier ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.srcQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.dstQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.buffer ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.offset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 const & bufferMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.srcQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.dstQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.buffer ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.offset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryBarrier2.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 const & bufferMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferMemoryRequirementsInfo2.buffer ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo const & bufferOpaqueCaptureAddressCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfo const & bufferUsageFlags2CreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferUsageFlags2CreateInfo.usage ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo const & bufferViewCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.buffer ); - VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.format ); - VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.offset ); - VULKAN_HPP_HASH_COMBINE( seed, bufferViewCreateInfo.range ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV const & stridedDeviceAddressNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressNV.startAddress ); - VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressNV.strideInBytes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV const & - buildPartitionedAccelerationStructureIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureIndirectCommandNV.opType ); - VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureIndirectCommandNV.argCount ); - VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureIndirectCommandNV.argData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV const & partitionedAccelerationStructureInstancesInputNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.flags ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.instanceCount ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.maxInstancePerPartitionCount ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.partitionCount ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureInstancesInputNV.maxInstanceInGlobalPartitionCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV const & buildPartitionedAccelerationStructureInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.input ); - VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.srcAccelerationStructureData ); - VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.dstAccelerationStructureData ); - VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.scratchData ); - VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.srcInfos ); - VULKAN_HPP_HASH_COMBINE( seed, buildPartitionedAccelerationStructureInfoNV.srcInfosCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR const & calibratedTimestampInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, calibratedTimestampInfoKHR.timeDomain ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointData2NV const & checkpointData2NV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.stage ); - VULKAN_HPP_HASH_COMBINE( seed, checkpointData2NV.pCheckpointMarker ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CheckpointDataNV const & checkpointDataNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.stage ); - VULKAN_HPP_HASH_COMBINE( seed, checkpointDataNV.pCheckpointMarker ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue const & clearDepthStencilValue ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.depth ); - VULKAN_HPP_HASH_COMBINE( seed, clearDepthStencilValue.stencil ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClearRect const & clearRect ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clearRect.rect ); - VULKAN_HPP_HASH_COMBINE( seed, clearRect.baseArrayLayer ); - VULKAN_HPP_HASH_COMBINE( seed, clearRect.layerCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & - clusterAccelerationStructureBuildClustersBottomLevelInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildClustersBottomLevelInfoNV.clusterReferencesCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildClustersBottomLevelInfoNV.clusterReferencesStride ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildClustersBottomLevelInfoNV.clusterReferences ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & - clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.geometryIndex ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.reserved ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.geometryFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV const & - clusterAccelerationStructureBuildTriangleClusterInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterID ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterFlags ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.triangleCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.positionTruncateBitCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.indexType ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexType ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.baseGeometryIndexAndGeometryFlags ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBufferStride ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBufferStride ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBufferStride ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBufferStride ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapArray ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBuffer ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & - clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.clusterID ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.clusterFlags ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.triangleCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.vertexCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.positionTruncateBitCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.indexType ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapIndexType ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.baseGeometryIndexAndGeometryFlags ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.indexBufferStride ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.vertexBufferStride ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.geometryIndexAndFlagsBufferStride ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapIndexBufferStride ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.indexBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.vertexBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.geometryIndexAndFlagsBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapArray ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.opacityMicromapIndexBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.instantiationBoundingBoxLimit ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV const & - clusterAccelerationStructureClustersBottomLevelInputNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.maxTotalClusterCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureClustersBottomLevelInputNV.maxClusterCountPerAccelerationStructure ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV const & clusterAccelerationStructureTriangleClusterInputNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.vertexFormat ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxGeometryIndexValue ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxClusterUniqueGeometryCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxClusterTriangleCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxClusterVertexCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxTotalTriangleCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.maxTotalVertexCount ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureTriangleClusterInputNV.minPositionTruncateBitCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV const & clusterAccelerationStructureMoveObjectsInputNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.type ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.noMoveOverlap ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInputNV.maxMovedBytes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR const & stridedDeviceAddressRegionKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.deviceAddress ); - VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.stride ); - VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRegionKHR.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGetTemplateIndicesInfoNV const & - clusterAccelerationStructureGetTemplateIndicesInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureGetTemplateIndicesInfoNV.clusterTemplateAddress ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV const & - clusterAccelerationStructureInstantiateClusterInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.clusterIdOffset ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.geometryIndexOffset ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.reserved ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.clusterTemplateAddress ); - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureInstantiateClusterInfoNV.vertexBuffer ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV const & clusterAccelerationStructureMoveObjectsInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, clusterAccelerationStructureMoveObjectsInfoNV.srcAccelerationStructure ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV const & coarseSampleLocationNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelX ); - VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.pixelY ); - VULKAN_HPP_HASH_COMBINE( seed, coarseSampleLocationNV.sample ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV const & coarseSampleOrderCustomNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.shadingRate ); - VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleCount ); - VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.sampleLocationCount ); - VULKAN_HPP_HASH_COMBINE( seed, coarseSampleOrderCustomNV.pSampleLocations ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT const & colorBlendAdvancedEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.advancedBlendOp ); - VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.srcPremultiplied ); - VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.dstPremultiplied ); - VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.blendOverlap ); - VULKAN_HPP_HASH_COMBINE( seed, colorBlendAdvancedEXT.clampResults ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT const & colorBlendEquationEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcColorBlendFactor ); - VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstColorBlendFactor ); - VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.colorBlendOp ); - VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.srcAlphaBlendFactor ); - VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.dstAlphaBlendFactor ); - VULKAN_HPP_HASH_COMBINE( seed, colorBlendEquationEXT.alphaBlendOp ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo const & commandBufferAllocateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandPool ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.level ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferAllocateInfo.commandBufferCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo const & commandBufferInheritanceInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.renderPass ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.subpass ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.framebuffer ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.occlusionQueryEnable ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.queryFlags ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceInfo.pipelineStatistics ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo const & commandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferBeginInfo.pInheritanceInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT const & commandBufferInheritanceConditionalRenderingInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceConditionalRenderingInfoEXT.conditionalRenderingEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT const & commandBufferInheritanceDescriptorHeapInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.pSamplerHeapBindInfo ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceDescriptorHeapInfoEXT.pResourceHeapBindInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM const & commandBufferInheritanceRenderPassTransformInfoQCOM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.transform ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderPassTransformInfoQCOM.renderArea ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo const & commandBufferInheritanceRenderingInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.viewMask ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.pColorAttachmentFormats ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.depthAttachmentFormat ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.stencilAttachmentFormat ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceRenderingInfo.rasterizationSamples ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Viewport const & viewport ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, viewport.x ); - VULKAN_HPP_HASH_COMBINE( seed, viewport.y ); - VULKAN_HPP_HASH_COMBINE( seed, viewport.width ); - VULKAN_HPP_HASH_COMBINE( seed, viewport.height ); - VULKAN_HPP_HASH_COMBINE( seed, viewport.minDepth ); - VULKAN_HPP_HASH_COMBINE( seed, viewport.maxDepth ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV const & commandBufferInheritanceViewportScissorInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportScissor2D ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.viewportDepthCount ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferInheritanceViewportScissorInfoNV.pViewportDepths ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo const & commandBufferSubmitInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.commandBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, commandBufferSubmitInfo.deviceMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo const & commandPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, commandPoolCreateInfo.queueFamilyIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityParametersNV const & computeOccupancyPriorityParametersNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, computeOccupancyPriorityParametersNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, computeOccupancyPriorityParametersNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, computeOccupancyPriorityParametersNV.occupancyPriority ); - VULKAN_HPP_HASH_COMBINE( seed, computeOccupancyPriorityParametersNV.occupancyThrottling ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationMapEntry const & specializationMapEntry ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.constantID ); - VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.offset ); - VULKAN_HPP_HASH_COMBINE( seed, specializationMapEntry.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SpecializationInfo const & specializationInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.mapEntryCount ); - VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pMapEntries ); - VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.dataSize ); - VULKAN_HPP_HASH_COMBINE( seed, specializationInfo.pData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo const & pipelineShaderStageCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.stage ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.module ); - for ( const char * p = pipelineShaderStageCreateInfo.pName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageCreateInfo.pSpecializationInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo const & computePipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.stage ); - VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.layout ); - VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineHandle ); - VULKAN_HPP_HASH_COMBINE( seed, computePipelineCreateInfo.basePipelineIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV const & computePipelineIndirectBufferInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.deviceAddress ); - VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.size ); - VULKAN_HPP_HASH_COMBINE( seed, computePipelineIndirectBufferInfoNV.pipelineDeviceAddressCaptureReplay ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT const & conditionalRenderingBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.buffer ); - VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.offset ); - VULKAN_HPP_HASH_COMBINE( seed, conditionalRenderingBeginInfoEXT.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ConformanceVersion const & conformanceVersion ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.major ); - VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.minor ); - VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.subminor ); - VULKAN_HPP_HASH_COMBINE( seed, conformanceVersion.patch ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV const & cooperativeMatrixFlexibleDimensionsPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.MGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.NGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.KGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.AType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.BType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.CType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.ResultType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.saturatingAccumulation ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.scope ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixFlexibleDimensionsPropertiesNV.workgroupInvocations ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR const & cooperativeMatrixPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.MSize ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.NSize ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.KSize ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.AType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.BType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.CType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.ResultType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.saturatingAccumulation ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesKHR.scope ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV const & cooperativeMatrixPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.MSize ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.NSize ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.KSize ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.AType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.BType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.CType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.DType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeMatrixPropertiesNV.scope ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV const & cooperativeVectorPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.inputType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.inputInterpretation ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.matrixInterpretation ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.biasInterpretation ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.resultType ); - VULKAN_HPP_HASH_COMBINE( seed, cooperativeVectorPropertiesNV.transpose ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR const & copyAccelerationStructureInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.src ); - VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.dst ); - VULKAN_HPP_HASH_COMBINE( seed, copyAccelerationStructureInfoKHR.mode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 const & copyBufferInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.srcBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.dstBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, copyBufferInfo2.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 const & copyBufferToImageInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.srcBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImage ); - VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.dstImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, copyBufferToImageInfo2.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM const & copyCommandTransformInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyCommandTransformInfoQCOM.transform ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyDescriptorSet const & copyDescriptorSet ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcSet ); - VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcBinding ); - VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.srcArrayElement ); - VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstSet ); - VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstBinding ); - VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.dstArrayElement ); - VULKAN_HPP_HASH_COMBINE( seed, copyDescriptorSet.descriptorCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy2 const & imageCopy2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.srcOffset ); - VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.dstOffset ); - VULKAN_HPP_HASH_COMBINE( seed, imageCopy2.extent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageInfo2 const & copyImageInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImage ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.srcImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImage ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.dstImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageInfo2.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 const & copyImageToBufferInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImage ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.srcImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.dstBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToBufferInfo2.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToImageInfo const & copyImageToImageInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.srcImage ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.srcImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.dstImage ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.dstImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToImageInfo.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageToMemoryCopy const & imageToMemoryCopy ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.pHostPointer ); - VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.memoryRowLength ); - VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.memoryImageHeight ); - VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageOffset ); - VULKAN_HPP_HASH_COMBINE( seed, imageToMemoryCopy.imageExtent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo const & copyImageToMemoryInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.srcImage ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.srcImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, copyImageToMemoryInfo.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR const & copyMemoryIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.srcAddress ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.dstAddress ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectCommandKHR.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR const & stridedDeviceAddressRangeKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.address ); - VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.size ); - VULKAN_HPP_HASH_COMBINE( seed, stridedDeviceAddressRangeKHR.stride ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR const & copyMemoryIndirectInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.srcCopyFlags ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.dstCopyFlags ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.copyCount ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryIndirectInfoKHR.copyAddressRange ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR const & copyMemoryToImageIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.srcAddress ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.bufferRowLength ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.bufferImageHeight ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageOffset ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectCommandKHR.imageExtent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR const & copyMemoryToImageIndirectInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.srcCopyFlags ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.copyCount ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.copyAddressRange ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.dstImage ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.dstImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageIndirectInfoKHR.pImageSubresources ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryToImageCopy const & memoryToImageCopy ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.pHostPointer ); - VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.memoryRowLength ); - VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.memoryImageHeight ); - VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageOffset ); - VULKAN_HPP_HASH_COMBINE( seed, memoryToImageCopy.imageExtent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo const & copyMemoryToImageInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.dstImage ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.dstImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, copyMemoryToImageInfo.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT const & copyMicromapInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.src ); - VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.dst ); - VULKAN_HPP_HASH_COMBINE( seed, copyMicromapInfoEXT.mode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorCopyARM const & tensorCopyARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.dimensionCount ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pSrcOffset ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pDstOffset ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCopyARM.pExtent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CopyTensorInfoARM const & copyTensorInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.srcTensor ); - VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.dstTensor ); - VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, copyTensorInfoARM.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX const & cuFunctionCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, cuFunctionCreateInfoNVX.module ); - for ( const char * p = cuFunctionCreateInfoNVX.pName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX const & cuLaunchInfoNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.function ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimX ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimY ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.gridDimZ ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimX ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimY ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.blockDimZ ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.sharedMemBytes ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.paramCount ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pParams ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.extraCount ); - VULKAN_HPP_HASH_COMBINE( seed, cuLaunchInfoNVX.pExtras ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX const & cuModuleCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.dataSize ); - VULKAN_HPP_HASH_COMBINE( seed, cuModuleCreateInfoNVX.pData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX const & cuModuleTexturingModeCreateInfoNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, cuModuleTexturingModeCreateInfoNVX.use64bitTexturing ); - return seed; - } - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV const & cudaFunctionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, cudaFunctionCreateInfoNV.module ); - for ( const char * p = cudaFunctionCreateInfoNV.pName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV const & cudaLaunchInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.function ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimX ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimY ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.gridDimZ ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimX ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimY ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.blockDimZ ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.sharedMemBytes ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.paramCount ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pParams ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.extraCount ); - VULKAN_HPP_HASH_COMBINE( seed, cudaLaunchInfoNV.pExtras ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV const & cudaModuleCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.dataSize ); - VULKAN_HPP_HASH_COMBINE( seed, cudaModuleCreateInfoNV.pData ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::CustomResolveCreateInfoEXT const & customResolveCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.customResolve ); - VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.pColorAttachmentFormats ); - VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.depthAttachmentFormat ); - VULKAN_HPP_HASH_COMBINE( seed, customResolveCreateInfoEXT.stencilAttachmentFormat ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR const & d3D12FenceSubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.waitSemaphoreValuesCount ); - VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pWaitSemaphoreValues ); - VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.signalSemaphoreValuesCount ); - VULKAN_HPP_HASH_COMBINE( seed, d3D12FenceSubmitInfoKHR.pSignalSemaphoreValues ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM const & physicalDeviceDataGraphOperationSupportARM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.operationType ); - for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.name[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphOperationSupportARM.version ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM const & dataGraphPipelineBuiltinModelCreateInfoQCOM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineBuiltinModelCreateInfoQCOM.pOperation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM const & dataGraphPipelineCompilerControlCreateInfoARM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCompilerControlCreateInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCompilerControlCreateInfoARM.pNext ); - for ( const char * p = dataGraphPipelineCompilerControlCreateInfoARM.pVendorOptions; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantARM const & dataGraphPipelineConstantARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.id ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantARM.pConstantData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & - dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.dimension ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.zeroCount ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.groupSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoARM const & dataGraphPipelineResourceInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.descriptorSet ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.binding ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineResourceInfoARM.arrayElement ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineCreateInfoARM const & dataGraphPipelineCreateInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.flags ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.layout ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.resourceInfoCount ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineCreateInfoARM.pResourceInfos ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchInfoARM const & dataGraphPipelineDispatchInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineDispatchInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineDispatchInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineDispatchInfoARM.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineIdentifierCreateInfoARM const & dataGraphPipelineIdentifierCreateInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.identifierSize ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineIdentifierCreateInfoARM.pIdentifier ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineInfoARM const & dataGraphPipelineInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineInfoARM.dataGraphPipeline ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyQueryResultARM const & dataGraphPipelinePropertyQueryResultARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.property ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.isText ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.dataSize ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelinePropertyQueryResultARM.pData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementARM const & dataGraphPipelineSessionBindPointRequirementARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.bindPoint ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.bindPointType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementARM.numObjects ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementsInfoARM const & - dataGraphPipelineSessionBindPointRequirementsInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementsInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementsInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionBindPointRequirementsInfoARM.session ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateInfoARM const & dataGraphPipelineSessionCreateInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.flags ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionCreateInfoARM.dataGraphPipeline ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionMemoryRequirementsInfoARM const & dataGraphPipelineSessionMemoryRequirementsInfoARM ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.session ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.bindPoint ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineSessionMemoryRequirementsInfoARM.objectIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DataGraphPipelineShaderModuleCreateInfoARM const & dataGraphPipelineShaderModuleCreateInfoARM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.module ); - for ( const char * p = dataGraphPipelineShaderModuleCreateInfoARM.pName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.pSpecializationInfo ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.constantCount ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphPipelineShaderModuleCreateInfoARM.pConstants ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineARM const & physicalDeviceDataGraphProcessingEngineARM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphProcessingEngineARM.type ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphProcessingEngineARM.isForeign ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DataGraphProcessingEngineCreateInfoARM const & dataGraphProcessingEngineCreateInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.processingEngineCount ); - VULKAN_HPP_HASH_COMBINE( seed, dataGraphProcessingEngineCreateInfoARM.pProcessingEngines ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT const & debugMarkerMarkerInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.pNext ); - for ( const char * p = debugMarkerMarkerInfoEXT.pMarkerName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - for ( size_t i = 0; i < 4; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerMarkerInfoEXT.color[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT const & debugMarkerObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.objectType ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectNameInfoEXT.object ); - for ( const char * p = debugMarkerObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT const & debugMarkerObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.objectType ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.object ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagName ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.tagSize ); - VULKAN_HPP_HASH_COMBINE( seed, debugMarkerObjectTagInfoEXT.pTag ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT const & debugReportCallbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pfnCallback ); - VULKAN_HPP_HASH_COMBINE( seed, debugReportCallbackCreateInfoEXT.pUserData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT const & debugUtilsLabelEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.pNext ); - for ( const char * p = debugUtilsLabelEXT.pLabelName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - for ( size_t i = 0; i < 4; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsLabelEXT.color[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT const & debugUtilsObjectNameInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectType ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectNameInfoEXT.objectHandle ); - for ( const char * p = debugUtilsObjectNameInfoEXT.pObjectName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT const & debugUtilsMessengerCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.flags ); - for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessageIdName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.messageIdNumber ); - for ( const char * p = debugUtilsMessengerCallbackDataEXT.pMessage; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.queueLabelCount ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pQueueLabels ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.cmdBufLabelCount ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pCmdBufLabels ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.objectCount ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCallbackDataEXT.pObjects ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT const & debugUtilsMessengerCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageSeverity ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.messageType ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pfnUserCallback ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsMessengerCreateInfoEXT.pUserData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT const & debugUtilsObjectTagInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectType ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.objectHandle ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagName ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.tagSize ); - VULKAN_HPP_HASH_COMBINE( seed, debugUtilsObjectTagInfoEXT.pTag ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT const & decompressMemoryRegionEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.srcAddress ); - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.dstAddress ); - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.compressedSize ); - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionEXT.decompressedSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT const & decompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.decompressionMethod ); - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryInfoEXT.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV const & decompressMemoryRegionNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.srcAddress ); - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.dstAddress ); - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.compressedSize ); - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressedSize ); - VULKAN_HPP_HASH_COMBINE( seed, decompressMemoryRegionNV.decompressionMethod ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV const & dedicatedAllocationBufferCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationBufferCreateInfoNV.dedicatedAllocation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV const & dedicatedAllocationImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationImageCreateInfoNV.dedicatedAllocation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV const & dedicatedAllocationMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.image ); - VULKAN_HPP_HASH_COMBINE( seed, dedicatedAllocationMemoryAllocateInfoNV.buffer ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier2 const & memoryBarrier2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier2.dstAccessMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresourceRange const & imageSubresourceRange ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.aspectMask ); - VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseMipLevel ); - VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.levelCount ); - VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.baseArrayLayer ); - VULKAN_HPP_HASH_COMBINE( seed, imageSubresourceRange.layerCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 const & imageMemoryBarrier2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.oldLayout ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.newLayout ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.srcQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.dstQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.image ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier2.subresourceRange ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DependencyInfo const & dependencyInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.dependencyFlags ); - VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.memoryBarrierCount ); - VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pMemoryBarriers ); - VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.bufferMemoryBarrierCount ); - VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pBufferMemoryBarriers ); - VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.imageMemoryBarrierCount ); - VULKAN_HPP_HASH_COMBINE( seed, dependencyInfo.pImageMemoryBarriers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT const & depthBiasInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasConstantFactor ); - VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasClamp ); - VULKAN_HPP_HASH_COMBINE( seed, depthBiasInfoEXT.depthBiasSlopeFactor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT const & depthBiasRepresentationInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasRepresentation ); - VULKAN_HPP_HASH_COMBINE( seed, depthBiasRepresentationInfoEXT.depthBiasExact ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DepthClampRangeEXT const & depthClampRangeEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, depthClampRangeEXT.minDepthClamp ); - VULKAN_HPP_HASH_COMBINE( seed, depthClampRangeEXT.maxDepthClamp ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT const & descriptorAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.address ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.range ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorAddressInfoEXT.format ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT const & descriptorBufferBindingInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.address ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingInfoEXT.usage ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT const & - descriptorBufferBindingPushDescriptorBufferHandleEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferBindingPushDescriptorBufferHandleEXT.buffer ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo const & descriptorBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.buffer ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.offset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorBufferInfo.range ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorImageInfo const & descriptorImageInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.sampler ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageView ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorImageInfo.imageLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorGetTensorInfoARM const & descriptorGetTensorInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorGetTensorInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorGetTensorInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorGetTensorInfoARM.tensorView ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCreateInfo const & samplerCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.magFilter ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minFilter ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipmapMode ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeU ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeV ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.addressModeW ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.mipLodBias ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.anisotropyEnable ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxAnisotropy ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareEnable ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.compareOp ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.minLod ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.maxLod ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.borderColor ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCreateInfo.unnormalizedCoordinates ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT const & descriptorMappingSourceConstantOffsetEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.heapOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.heapArrayStride ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.pEmbeddedSampler ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.samplerHeapOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceConstantOffsetEXT.samplerHeapArrayStride ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT const & descriptorMappingSourcePushIndexEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.heapOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.pushOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.heapIndexStride ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.heapArrayStride ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.pEmbeddedSampler ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.useCombinedImageSamplerIndex ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerHeapOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerPushOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerHeapIndexStride ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourcePushIndexEXT.samplerHeapArrayStride ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT const & descriptorMappingSourceIndirectIndexEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.heapOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.pushOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.addressOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.heapIndexStride ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.heapArrayStride ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.pEmbeddedSampler ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.useCombinedImageSamplerIndex ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerHeapOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerPushOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerAddressOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerHeapIndexStride ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexEXT.samplerHeapArrayStride ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT const & descriptorMappingSourceIndirectIndexArrayEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.heapOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.pushOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.addressOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.heapIndexStride ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.pEmbeddedSampler ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.useCombinedImageSamplerIndex ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerHeapOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerPushOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerAddressOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectIndexArrayEXT.samplerHeapIndexStride ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT const & descriptorMappingSourceHeapDataEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceHeapDataEXT.heapOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceHeapDataEXT.pushOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT const & descriptorMappingSourceIndirectAddressEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectAddressEXT.pushOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceIndirectAddressEXT.addressOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT const & descriptorMappingSourceShaderRecordIndexEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.heapOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.shaderRecordOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.heapIndexStride ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.heapArrayStride ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.pEmbeddedSampler ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.useCombinedImageSamplerIndex ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerHeapOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerShaderRecordOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerHeapIndexStride ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorMappingSourceShaderRecordIndexEXT.samplerHeapArrayStride ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolSize const & descriptorPoolSize ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.type ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolSize.descriptorCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo const & descriptorPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.maxSets ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.poolSizeCount ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolCreateInfo.pPoolSizes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo const & descriptorPoolInlineUniformBlockCreateInfo ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorPoolInlineUniformBlockCreateInfo.maxInlineUniformBlockBindings ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo const & descriptorSetAllocateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorPool ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.descriptorSetCount ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetAllocateInfo.pSetLayouts ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE const & descriptorSetBindingReferenceVALVE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.descriptorSetLayout ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetBindingReferenceVALVE.binding ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding const & descriptorSetLayoutBinding ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.binding ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.descriptorCount ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.stageFlags ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBinding.pImmutableSamplers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo const & descriptorSetLayoutBindingFlagsCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.bindingCount ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutBindingFlagsCreateInfo.pBindingFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo const & descriptorSetLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.bindingCount ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutCreateInfo.pBindings ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE const & descriptorSetLayoutHostMappingInfoVALVE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorOffset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutHostMappingInfoVALVE.descriptorSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport const & descriptorSetLayoutSupport ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetLayoutSupport.supported ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo const & descriptorSetVariableDescriptorCountAllocateInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.descriptorSetCount ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountAllocateInfo.pDescriptorCounts ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport const & descriptorSetVariableDescriptorCountLayoutSupport ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorSetVariableDescriptorCountLayoutSupport.maxVariableDescriptorCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry const & descriptorUpdateTemplateEntry ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstBinding ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.dstArrayElement ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorCount ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.descriptorType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.offset ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateEntry.stride ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo const & descriptorUpdateTemplateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorUpdateEntryCount ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.templateType ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.descriptorSetLayout ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.pipelineLayout ); - VULKAN_HPP_HASH_COMBINE( seed, descriptorUpdateTemplateCreateInfo.set ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT const & deviceAddressBindingCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.baseAddress ); - VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.size ); - VULKAN_HPP_HASH_COMBINE( seed, deviceAddressBindingCallbackDataEXT.bindingType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements const & deviceBufferMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceBufferMemoryRequirements.pCreateInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo const & deviceQueueCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.queueCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueCreateInfo.pQueuePriorities ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures const & physicalDeviceFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.robustBufferAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fullDrawIndexUint32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.imageCubeArray ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.independentBlend ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.geometryShader ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.tessellationShader ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sampleRateShading ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.dualSrcBlend ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.logicOp ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiDrawIndirect ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.drawIndirectFirstInstance ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthClamp ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBiasClamp ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fillModeNonSolid ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.depthBounds ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.wideLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.largePoints ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.alphaToOne ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.multiViewport ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.samplerAnisotropy ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionETC2 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionASTC_LDR ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.textureCompressionBC ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.occlusionQueryPrecise ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.pipelineStatisticsQuery ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.vertexPipelineStoresAndAtomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.fragmentStoresAndAtomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderTessellationAndGeometryPointSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderImageGatherExtended ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageExtendedFormats ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageMultisample ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageReadWithoutFormat ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageWriteWithoutFormat ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderUniformBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderSampledImageArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderStorageImageArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderClipDistance ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderCullDistance ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderFloat64 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt64 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderInt16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceResidency ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.shaderResourceMinLod ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseBinding ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage2D ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyImage3D ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency2Samples ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency4Samples ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency8Samples ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidency16Samples ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.sparseResidencyAliased ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.variableMultisampleRate ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures.inheritedQueries ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceCreateInfo const & deviceCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.queueCreateInfoCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pQueueCreateInfos ); - VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.enabledExtensionCount ); - for ( size_t i = 0; i < deviceCreateInfo.enabledExtensionCount; ++i ) - { - for ( const char * p = deviceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - } - VULKAN_HPP_HASH_COMBINE( seed, deviceCreateInfo.pEnabledFeatures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT const & deviceDeviceMemoryReportCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pfnUserCallback ); - VULKAN_HPP_HASH_COMBINE( seed, deviceDeviceMemoryReportCreateInfoEXT.pUserData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV const & deviceDiagnosticsConfigCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceDiagnosticsConfigCreateInfoNV.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT const & deviceEventInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceEventInfoEXT.deviceEvent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT const & deviceFaultAddressInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.reportedAddress ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultAddressInfoEXT.addressPrecision ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT const & deviceFaultCountsEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.addressInfoCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorInfoCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultCountsEXT.vendorBinarySize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT const & deviceFaultVendorInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.description[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultCode ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorInfoEXT.vendorFaultData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT const & deviceFaultInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pNext ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.description[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pAddressInfos ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorInfos ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultInfoEXT.pVendorBinaryData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT const & deviceFaultVendorBinaryHeaderVersionOneEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerSize ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.headerVersion ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.vendorID ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.deviceID ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.driverVersion ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.pipelineCacheUUID[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationNameOffset ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.applicationVersion ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineNameOffset ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.engineVersion ); - VULKAN_HPP_HASH_COMBINE( seed, deviceFaultVendorBinaryHeaderVersionOneEXT.apiVersion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo const & deviceGroupBindSparseInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.resourceDeviceIndex ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupBindSparseInfo.memoryDeviceIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo const & deviceGroupCommandBufferBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupCommandBufferBeginInfo.deviceMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo const & deviceGroupDeviceCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.physicalDeviceCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupDeviceCreateInfo.pPhysicalDevices ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR const & deviceGroupPresentCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.pNext ); - for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.presentMask[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentCapabilitiesKHR.modes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR const & deviceGroupPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.pDeviceMasks ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupPresentInfoKHR.mode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo const & deviceGroupRenderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceMask ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.deviceRenderAreaCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupRenderPassBeginInfo.pDeviceRenderAreas ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo const & deviceGroupSubmitInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.waitSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pWaitSemaphoreDeviceIndices ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.commandBufferCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pCommandBufferDeviceMasks ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.signalSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSubmitInfo.pSignalSemaphoreDeviceIndices ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR const & deviceGroupSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceGroupSwapchainCreateInfoKHR.modes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCreateInfo const & imageCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.imageType ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.format ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.extent ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.mipLevels ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.arrayLayers ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.samples ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.tiling ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.usage ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.sharingMode ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.queueFamilyIndexCount ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.pQueueFamilyIndices ); - VULKAN_HPP_HASH_COMBINE( seed, imageCreateInfo.initialLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements const & deviceImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.pCreateInfo ); - VULKAN_HPP_HASH_COMBINE( seed, deviceImageMemoryRequirements.planeAspect ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSubresource2 const & imageSubresource2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageSubresource2.imageSubresource ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo const & deviceImageSubresourceInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pCreateInfo ); - VULKAN_HPP_HASH_COMBINE( seed, deviceImageSubresourceInfo.pSubresource ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo const & deviceMemoryOpaqueCaptureAddressInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOpaqueCaptureAddressInfo.memory ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD const & deviceMemoryOverallocationCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryOverallocationCreateInfoAMD.overallocationBehavior ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT const & deviceMemoryReportCallbackDataEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.type ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.memoryObjectId ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.size ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.objectHandle ); - VULKAN_HPP_HASH_COMBINE( seed, deviceMemoryReportCallbackDataEXT.heapIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR const & devicePipelineBinaryInternalCacheControlKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, devicePipelineBinaryInternalCacheControlKHR.disableInternalCache ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo const & devicePrivateDataCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, devicePrivateDataCreateInfo.privateDataSlotRequestCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfo const & deviceQueueGlobalPriorityCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueGlobalPriorityCreateInfo.globalPriority ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 const & deviceQueueInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.flags ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueInfo2.queueIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM const & deviceQueueShaderCoreControlCreateInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceQueueShaderCoreControlCreateInfoARM.shaderCoreCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorDescriptionARM const & tensorDescriptionARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.tiling ); - VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.format ); - VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.dimensionCount ); - VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.pDimensions ); - VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.pStrides ); - VULKAN_HPP_HASH_COMBINE( seed, tensorDescriptionARM.usage ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorCreateInfoARM const & tensorCreateInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.flags ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.pDescription ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.sharingMode ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.queueFamilyIndexCount ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCreateInfoARM.pQueueFamilyIndices ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM const & deviceTensorMemoryRequirementsARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, deviceTensorMemoryRequirementsARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, deviceTensorMemoryRequirementsARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, deviceTensorMemoryRequirementsARM.pCreateInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG const & directDriverLoadingInfoLUNARG ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.sType ); - VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.flags ); - VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingInfoLUNARG.pfnGetInstanceProcAddr ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG const & directDriverLoadingListLUNARG ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.sType ); - VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.mode ); - VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.driverCount ); - VULKAN_HPP_HASH_COMBINE( seed, directDriverLoadingListLUNARG.pDrivers ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT const & directFBSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.dfb ); - VULKAN_HPP_HASH_COMBINE( seed, directFBSurfaceCreateInfoEXT.surface ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand const & dispatchIndirectCommand ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.x ); - VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.y ); - VULKAN_HPP_HASH_COMBINE( seed, dispatchIndirectCommand.z ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM const & dispatchTileInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, dispatchTileInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, dispatchTileInfoQCOM.pNext ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT const & displayEventInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displayEventInfoEXT.displayEvent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR const & displayModeParametersKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.visibleRegion ); - VULKAN_HPP_HASH_COMBINE( seed, displayModeParametersKHR.refreshRate ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR const & displayModeCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, displayModeCreateInfoKHR.parameters ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR const & displayModePropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.displayMode ); - VULKAN_HPP_HASH_COMBINE( seed, displayModePropertiesKHR.parameters ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR const & displayModeProperties2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displayModeProperties2KHR.displayModeProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV const & displayModeStereoPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displayModeStereoPropertiesNV.hdmi3DSupported ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD const & displayNativeHdrSurfaceCapabilitiesAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displayNativeHdrSurfaceCapabilitiesAMD.localDimmingSupport ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR const & displayPlaneCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.supportedAlpha ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcPosition ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcPosition ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minSrcExtent ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxSrcExtent ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstPosition ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstPosition ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.minDstExtent ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilitiesKHR.maxDstExtent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR const & displayPlaneCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneCapabilities2KHR.capabilities ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR const & displayPlaneInfo2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.mode ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneInfo2KHR.planeIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR const & displayPlanePropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentDisplay ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlanePropertiesKHR.currentStackIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR const & displayPlaneProperties2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displayPlaneProperties2KHR.displayPlaneProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT const & displayPowerInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displayPowerInfoEXT.powerState ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR const & displayPresentInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.srcRect ); - VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.dstRect ); - VULKAN_HPP_HASH_COMBINE( seed, displayPresentInfoKHR.persistent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR const & displayPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.display ); - for ( const char * p = displayPropertiesKHR.displayName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalDimensions ); - VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.physicalResolution ); - VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.supportedTransforms ); - VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.planeReorderPossible ); - VULKAN_HPP_HASH_COMBINE( seed, displayPropertiesKHR.persistentContent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR const & displayProperties2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displayProperties2KHR.displayProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR const & displaySurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.displayMode ); - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeIndex ); - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.planeStackIndex ); - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.transform ); - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.globalAlpha ); - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.alphaMode ); - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceCreateInfoKHR.imageExtent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV const & displaySurfaceStereoCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, displaySurfaceStereoCreateInfoNV.stereoType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand const & drawIndexedIndirectCommand ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.indexCount ); - VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.instanceCount ); - VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstIndex ); - VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.vertexOffset ); - VULKAN_HPP_HASH_COMBINE( seed, drawIndexedIndirectCommand.firstInstance ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCommand const & drawIndirectCommand ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.vertexCount ); - VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.instanceCount ); - VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstVertex ); - VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCommand.firstInstance ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawIndirectCountIndirectCommandEXT const & drawIndirectCountIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCountIndirectCommandEXT.bufferAddress ); - VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCountIndirectCommandEXT.stride ); - VULKAN_HPP_HASH_COMBINE( seed, drawIndirectCountIndirectCommandEXT.commandCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT const & drawMeshTasksIndirectCommandEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountX ); - VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountY ); - VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandEXT.groupCountZ ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV const & drawMeshTasksIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.taskCount ); - VULKAN_HPP_HASH_COMBINE( seed, drawMeshTasksIndirectCommandNV.firstTask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT const & drmFormatModifierProperties2EXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifier ); - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierPlaneCount ); - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierProperties2EXT.drmFormatModifierTilingFeatures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT const & drmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifier ); - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierPlaneCount ); - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesEXT.drmFormatModifierTilingFeatures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT const & drmFormatModifierPropertiesList2EXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.drmFormatModifierCount ); - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT const & drmFormatModifierPropertiesListEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.drmFormatModifierCount ); - VULKAN_HPP_HASH_COMBINE( seed, drmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::EventCreateInfo const & eventCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, eventCreateInfo.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR const & pipelineLibraryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.libraryCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineLibraryCreateInfoKHR.pLibraries ); - return seed; - } - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX const & executionGraphPipelineCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.flags ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.stageCount ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pStages ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.pLibraryInfo ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.layout ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineHandle ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineCreateInfoAMDX.basePipelineIndex ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX const & executionGraphPipelineScratchSizeAMDX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.minSize ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.maxSize ); - VULKAN_HPP_HASH_COMBINE( seed, executionGraphPipelineScratchSizeAMDX.sizeGranularity ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo const & exportFenceCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportFenceCreateInfo.handleTypes ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR const & exportFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.pAttributes ); - VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.dwAccess ); - VULKAN_HPP_HASH_COMBINE( seed, exportFenceWin32HandleInfoKHR.name ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo const & exportMemoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfo.handleTypes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV const & exportMemoryAllocateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryAllocateInfoNV.handleTypes ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR const & exportMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.pAttributes ); - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.dwAccess ); - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoKHR.name ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV const & exportMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.pAttributes ); - VULKAN_HPP_HASH_COMBINE( seed, exportMemoryWin32HandleInfoNV.dwAccess ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT const & exportMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.memory ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalBufferInfoEXT.mtlBuffer ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT const & exportMetalCommandQueueInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.queue ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalCommandQueueInfoEXT.mtlCommandQueue ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT const & exportMetalDeviceInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalDeviceInfoEXT.mtlDevice ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT const & exportMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.image ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalIOSurfaceInfoEXT.ioSurface ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT const & exportMetalObjectCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectCreateInfoEXT.exportObjectType ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT const & exportMetalObjectsInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalObjectsInfoEXT.pNext ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT const & exportMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.semaphore ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.event ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalSharedEventInfoEXT.mtlSharedEvent ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT const & exportMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.image ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.imageView ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.bufferView ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.plane ); - VULKAN_HPP_HASH_COMBINE( seed, exportMetalTextureInfoEXT.mtlTexture ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo const & exportSemaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreCreateInfo.handleTypes ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR const & exportSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.pAttributes ); - VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.dwAccess ); - VULKAN_HPP_HASH_COMBINE( seed, exportSemaphoreWin32HandleInfoKHR.name ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExtensionProperties const & extensionProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.extensionName[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, extensionProperties.specVersion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties const & externalMemoryProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.externalMemoryFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.exportFromImportedHandleTypes ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryProperties.compatibleHandleTypes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalBufferProperties const & externalBufferProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalBufferProperties.externalMemoryProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV const & externalComputeQueueCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.preferredQueue ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV const & externalComputeQueueDataParamsNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.deviceIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV const & externalComputeQueueDeviceCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.reservedExternalQueues ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFenceProperties const & externalFenceProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.exportFromImportedHandleTypes ); - VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.compatibleHandleTypes ); - VULKAN_HPP_HASH_COMBINE( seed, externalFenceProperties.externalFenceFeatures ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID const & externalFormatANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalFormatANDROID.externalFormat ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_OHOS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatOHOS const & externalFormatOHOS ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalFormatOHOS.externalFormat ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_OHOS*/ - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalFormatQNX const & externalFormatQNX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalFormatQNX.externalFormat ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties const & externalImageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatProperties.externalMemoryProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties const & imageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxExtent ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxMipLevels ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxArrayLayers ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.sampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties.maxResourceSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV const & externalImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.imageFormatProperties ); - VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.externalMemoryFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.exportFromImportedHandleTypes ); - VULKAN_HPP_HASH_COMBINE( seed, externalImageFormatPropertiesNV.compatibleHandleTypes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT const & externalMemoryAcquireUnmodifiedEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryAcquireUnmodifiedEXT.acquireUnmodifiedMemory ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo const & externalMemoryBufferCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryBufferCreateInfo.handleTypes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo const & externalMemoryImageCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfo.handleTypes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV const & externalMemoryImageCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryImageCreateInfoNV.handleTypes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalMemoryTensorCreateInfoARM const & externalMemoryTensorCreateInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryTensorCreateInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryTensorCreateInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalMemoryTensorCreateInfoARM.handleTypes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties const & externalSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.exportFromImportedHandleTypes ); - VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.compatibleHandleTypes ); - VULKAN_HPP_HASH_COMBINE( seed, externalSemaphoreProperties.externalSemaphoreFeatures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalTensorPropertiesARM const & externalTensorPropertiesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, externalTensorPropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, externalTensorPropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, externalTensorPropertiesARM.externalMemoryProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceCreateInfo const & fenceCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, fenceCreateInfo.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR const & fenceGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.fence ); - VULKAN_HPP_HASH_COMBINE( seed, fenceGetFdInfoKHR.handleType ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR const & fenceGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.fence ); - VULKAN_HPP_HASH_COMBINE( seed, fenceGetWin32HandleInfoKHR.handleType ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT const & filterCubicImageViewImageFormatPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubic ); - VULKAN_HPP_HASH_COMBINE( seed, filterCubicImageViewImageFormatPropertiesEXT.filterCubicMinmax ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties const & formatProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, formatProperties.linearTilingFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, formatProperties.optimalTilingFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, formatProperties.bufferFeatures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties2 const & formatProperties2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, formatProperties2.formatProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FormatProperties3 const & formatProperties3 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.sType ); - VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.linearTilingFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.optimalTilingFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, formatProperties3.bufferFeatures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR const & fragmentShadingRateAttachmentInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment ); - VULKAN_HPP_HASH_COMBINE( seed, fragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT const & frameBoundaryEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.frameID ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.imageCount ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pImages ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.bufferCount ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagName ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.tagSize ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryEXT.pTag ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FrameBoundaryTensorsARM const & frameBoundaryTensorsARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.tensorCount ); - VULKAN_HPP_HASH_COMBINE( seed, frameBoundaryTensorsARM.pTensors ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo const & framebufferAttachmentImageInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.usage ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.width ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.height ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.layerCount ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.viewFormatCount ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentImageInfo.pViewFormats ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo const & framebufferAttachmentsCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.attachmentImageInfoCount ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferAttachmentsCreateInfo.pAttachmentImageInfos ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo const & framebufferCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.renderPass ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.pAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.width ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.height ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferCreateInfo.layers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV const & framebufferMixedSamplesCombinationNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.coverageReductionMode ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.rasterizationSamples ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.depthStencilSamples ); - VULKAN_HPP_HASH_COMBINE( seed, framebufferMixedSamplesCombinationNV.colorSamples ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT const & generatedCommandsInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.shaderStages ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectExecutionSet ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectCommandsLayout ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectAddress ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.indirectAddressSize ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.preprocessAddress ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.preprocessSize ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.maxSequenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.sequenceCountAddress ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoEXT.maxDrawCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV const & indirectCommandsStreamNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.buffer ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsStreamNV.offset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV const & generatedCommandsInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pipeline ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.indirectCommandsLayout ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.streamCount ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.pStreams ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCount ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessOffset ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.preprocessSize ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesCountOffset ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsInfoNV.sequencesIndexOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoEXT const & generatedCommandsMemoryRequirementsInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.indirectExecutionSet ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.indirectCommandsLayout ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.maxSequenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoEXT.maxDrawCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV const & generatedCommandsMemoryRequirementsInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.pipeline ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.indirectCommandsLayout ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsMemoryRequirementsInfoNV.maxSequencesCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsPipelineInfoEXT const & generatedCommandsPipelineInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsPipelineInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsPipelineInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsPipelineInfoEXT.pipeline ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GeneratedCommandsShaderInfoEXT const & generatedCommandsShaderInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.shaderCount ); - VULKAN_HPP_HASH_COMBINE( seed, generatedCommandsShaderInfoEXT.pShaders ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV const & latencyTimingsFrameReportNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentID ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.inputSampleTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simStartTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.simEndTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitStartTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.renderSubmitEndTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentStartTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.presentEndTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverStartTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.driverEndTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueStartTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.osRenderQueueEndTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderStartTimeUs ); - VULKAN_HPP_HASH_COMBINE( seed, latencyTimingsFrameReportNV.gpuRenderEndTimeUs ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV const & getLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.timingCount ); - VULKAN_HPP_HASH_COMBINE( seed, getLatencyMarkerInfoNV.pTimings ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription const & vertexInputBindingDescription ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.binding ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.stride ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription.inputRate ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription const & vertexInputAttributeDescription ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.location ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.binding ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.format ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription.offset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo const & pipelineVertexInputStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo const & pipelineInputAssemblyStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.topology ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo const & pipelineTessellationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationStateCreateInfo.patchControlPoints ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo const & pipelineViewportStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.viewportCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pViewports ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.scissorCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportStateCreateInfo.pScissors ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo const & pipelineRasterizationStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthClampEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.rasterizerDiscardEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.polygonMode ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.cullMode ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.frontFace ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasConstantFactor ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasClamp ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.depthBiasSlopeFactor ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateCreateInfo.lineWidth ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo const & pipelineMultisampleStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.rasterizationSamples ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.sampleShadingEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.minSampleShading ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.pSampleMask ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToCoverageEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineMultisampleStateCreateInfo.alphaToOneEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::StencilOpState const & stencilOpState ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.failOp ); - VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.passOp ); - VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.depthFailOp ); - VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareOp ); - VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.compareMask ); - VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.writeMask ); - VULKAN_HPP_HASH_COMBINE( seed, stencilOpState.reference ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo const & pipelineDepthStencilStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthTestEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthWriteEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthCompareOp ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.depthBoundsTestEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.stencilTestEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.front ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.back ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.minDepthBounds ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDepthStencilStateCreateInfo.maxDepthBounds ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState const & pipelineColorBlendAttachmentState ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.blendEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcColorBlendFactor ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstColorBlendFactor ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorBlendOp ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.srcAlphaBlendFactor ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.dstAlphaBlendFactor ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.alphaBlendOp ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAttachmentState.colorWriteMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo const & pipelineColorBlendStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOpEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.logicOp ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.pAttachments ); - for ( size_t i = 0; i < 4; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendStateCreateInfo.blendConstants[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo const & pipelineDynamicStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.dynamicStateCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDynamicStateCreateInfo.pDynamicStates ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo const & graphicsPipelineCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.stageCount ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pStages ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pVertexInputState ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pInputAssemblyState ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pTessellationState ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pViewportState ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pRasterizationState ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pMultisampleState ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDepthStencilState ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pColorBlendState ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.pDynamicState ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.layout ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.renderPass ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.subpass ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineHandle ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineCreateInfo.basePipelineIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT const & graphicsPipelineLibraryCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineLibraryCreateInfoEXT.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV const & graphicsShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.stageCount ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pStages ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pVertexInputState ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsShaderGroupCreateInfoNV.pTessellationState ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV const & graphicsPipelineShaderGroupsCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.groupCount ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pGroups ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pipelineCount ); - VULKAN_HPP_HASH_COMBINE( seed, graphicsPipelineShaderGroupsCreateInfoNV.pPipelines ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::XYColorEXT const & xYColorEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.x ); - VULKAN_HPP_HASH_COMBINE( seed, xYColorEXT.y ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrMetadataEXT const & hdrMetadataEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryRed ); - VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryGreen ); - VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.displayPrimaryBlue ); - VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.whitePoint ); - VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxLuminance ); - VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.minLuminance ); - VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxContentLightLevel ); - VULKAN_HPP_HASH_COMBINE( seed, hdrMetadataEXT.maxFrameAverageLightLevel ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI const & hdrVividDynamicMetadataHUAWEI ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.dynamicMetadataSize ); - VULKAN_HPP_HASH_COMBINE( seed, hdrVividDynamicMetadataHUAWEI.pDynamicMetadata ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT const & headlessSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, headlessSurfaceCreateInfoEXT.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT const & hostAddressRangeConstEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeConstEXT.address ); - VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeConstEXT.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::HostAddressRangeEXT const & hostAddressRangeEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeEXT.address ); - VULKAN_HPP_HASH_COMBINE( seed, hostAddressRangeEXT.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQuery const & hostImageCopyDevicePerformanceQuery ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.sType ); - VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.optimalDeviceAccess ); - VULKAN_HPP_HASH_COMBINE( seed, hostImageCopyDevicePerformanceQuery.identicalMemoryLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo const & hostImageLayoutTransitionInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.image ); - VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.oldLayout ); - VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.newLayout ); - VULKAN_HPP_HASH_COMBINE( seed, hostImageLayoutTransitionInfo.subresourceRange ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_IOS_MVK ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK const & iOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.sType ); - VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.flags ); - VULKAN_HPP_HASH_COMBINE( seed, iOSSurfaceCreateInfoMVK.pView ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_IOS_MVK*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA const & imageAlignmentControlCreateInfoMESA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageAlignmentControlCreateInfoMESA.maximumRequestedAlignment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageBlit const & imageBlit ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcSubresource ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, imageBlit.srcOffsets[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstSubresource ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, imageBlit.dstOffsets[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT const & imageCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageCaptureDescriptorDataInfoEXT.image ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT const & imageCompressionControlEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.compressionControlPlaneCount ); - VULKAN_HPP_HASH_COMBINE( seed, imageCompressionControlEXT.pFixedRateFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT const & imageCompressionPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFlags ); - VULKAN_HPP_HASH_COMBINE( seed, imageCompressionPropertiesEXT.imageCompressionFixedRateFlags ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA const & imageFormatConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.imageCreateInfo ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.requiredFormatFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.flags ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.sysmemPixelFormat ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.colorSpaceCount ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatConstraintsInfoFUCHSIA.pColorSpaces ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA const & imageConstraintsInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.formatConstraintsCount ); - VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.pFormatConstraints ); - VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.bufferCollectionConstraints ); - VULKAN_HPP_HASH_COMBINE( seed, imageConstraintsInfoFUCHSIA.flags ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageCopy const & imageCopy ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, imageCopy.srcOffset ); - VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, imageCopy.dstOffset ); - VULKAN_HPP_HASH_COMBINE( seed, imageCopy.extent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo const & imageViewCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.image ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.viewType ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.format ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.components ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewCreateInfo.subresourceRange ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT const & imageDescriptorInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.pView ); - VULKAN_HPP_HASH_COMBINE( seed, imageDescriptorInfoEXT.layout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout const & subresourceLayout ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.offset ); - VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.size ); - VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.rowPitch ); - VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.arrayPitch ); - VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout.depthPitch ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT const & imageDrmFormatModifierExplicitCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifier ); - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.drmFormatModifierPlaneCount ); - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT const & imageDrmFormatModifierListCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.drmFormatModifierCount ); - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierListCreateInfoEXT.pDrmFormatModifiers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT const & imageDrmFormatModifierPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageDrmFormatModifierPropertiesEXT.drmFormatModifier ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo const & imageFormatListCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.viewFormatCount ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatListCreateInfo.pViewFormats ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 const & imageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageFormatProperties2.imageFormatProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier const & imageMemoryBarrier ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.oldLayout ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.newLayout ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.srcQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.dstQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.image ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryBarrier.subresourceRange ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 const & imageMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageMemoryRequirementsInfo2.image ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA const & imagePipeSurfaceCreateInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.flags ); - VULKAN_HPP_HASH_COMBINE( seed, imagePipeSurfaceCreateInfoFUCHSIA.imagePipeHandle ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo const & imagePlaneMemoryRequirementsInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imagePlaneMemoryRequirementsInfo.planeAspect ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve const & imageResolve ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, imageResolve.srcOffset ); - VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, imageResolve.dstOffset ); - VULKAN_HPP_HASH_COMBINE( seed, imageResolve.extent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageResolve2 const & imageResolve2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.srcOffset ); - VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstSubresource ); - VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.dstOffset ); - VULKAN_HPP_HASH_COMBINE( seed, imageResolve2.extent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 const & imageSparseMemoryRequirementsInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageSparseMemoryRequirementsInfo2.image ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo const & imageStencilUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageStencilUsageCreateInfo.stencilUsage ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR const & imageSwapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageSwapchainCreateInfoKHR.swapchain ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT const & imageViewASTCDecodeModeEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewASTCDecodeModeEXT.decodeMode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX const & imageViewAddressPropertiesNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.deviceAddress ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewAddressPropertiesNVX.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT const & imageViewCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewCaptureDescriptorDataInfoEXT.imageView ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX const & imageViewHandleInfoNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.imageView ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.descriptorType ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewHandleInfoNVX.sampler ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT const & imageViewMinLodCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewMinLodCreateInfoEXT.minLod ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM const & imageViewSampleWeightCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterCenter ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.filterSize ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewSampleWeightCreateInfoQCOM.numPhases ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT const & imageViewSlicedCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceOffset ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewSlicedCreateInfoEXT.sliceCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo const & imageViewUsageCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, imageViewUsageCreateInfo.usage ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID const & importAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importAndroidHardwareBufferInfoANDROID.buffer ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR const & importFenceFdInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fence ); - VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( seed, importFenceFdInfoKHR.fd ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR const & importFenceWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.fence ); - VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.handle ); - VULKAN_HPP_HASH_COMBINE( seed, importFenceWin32HandleInfoKHR.name ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA const & importMemoryBufferCollectionFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.collection ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryBufferCollectionFUCHSIA.index ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR const & importMemoryFdInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryFdInfoKHR.fd ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT const & importMemoryHostPointerInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.handleType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryHostPointerInfoEXT.pHostPointer ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT const & importMemoryMetalHandleInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.handleType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryMetalHandleInfoEXT.handle ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR const & importMemoryWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.handle ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoKHR.name ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV const & importMemoryWin32HandleInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handleType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryWin32HandleInfoNV.handle ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA const & importMemoryZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handleType ); - VULKAN_HPP_HASH_COMBINE( seed, importMemoryZirconHandleInfoFUCHSIA.handle ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT const & importMetalBufferInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importMetalBufferInfoEXT.mtlBuffer ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT const & importMetalIOSurfaceInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importMetalIOSurfaceInfoEXT.ioSurface ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT const & importMetalSharedEventInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importMetalSharedEventInfoEXT.mtlSharedEvent ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT const & importMetalTextureInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.plane ); - VULKAN_HPP_HASH_COMBINE( seed, importMetalTextureInfoEXT.mtlTexture ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_OHOS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS const & importNativeBufferInfoOHOS ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importNativeBufferInfoOHOS.buffer ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_OHOS*/ - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX const & importScreenBufferInfoQNX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importScreenBufferInfoQNX.buffer ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR const & importSemaphoreFdInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.semaphore ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreFdInfoKHR.fd ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR const & importSemaphoreWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.semaphore ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handleType ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.handle ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreWin32HandleInfoKHR.name ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA const & importSemaphoreZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.semaphore ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.flags ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.handleType ); - VULKAN_HPP_HASH_COMBINE( seed, importSemaphoreZirconHandleInfoFUCHSIA.zirconHandle ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsExecutionSetTokenEXT const & indirectCommandsExecutionSetTokenEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsExecutionSetTokenEXT.type ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsExecutionSetTokenEXT.shaderStages ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsIndexBufferTokenEXT const & indirectCommandsIndexBufferTokenEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsIndexBufferTokenEXT.mode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantRange const & pushConstantRange ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.stageFlags ); - VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.offset ); - VULKAN_HPP_HASH_COMBINE( seed, pushConstantRange.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsPushConstantTokenEXT const & indirectCommandsPushConstantTokenEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsPushConstantTokenEXT.updateRange ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsVertexBufferTokenEXT const & indirectCommandsVertexBufferTokenEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsVertexBufferTokenEXT.vertexBindingUnit ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoEXT const & indirectCommandsLayoutCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.shaderStages ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.indirectStride ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.pipelineLayout ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.tokenCount ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoEXT.pTokens ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV const & indirectCommandsLayoutTokenNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.tokenType ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.stream ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.offset ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexBindingUnit ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.vertexDynamicStride ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantPipelineLayout ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantShaderStageFlags ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantOffset ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pushconstantSize ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indirectStateFlags ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.indexTypeCount ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypes ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutTokenNV.pIndexTypeValues ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV const & indirectCommandsLayoutCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.tokenCount ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pTokens ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.streamCount ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutCreateInfoNV.pStreamStrides ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV const & indirectCommandsLayoutPushDataTokenNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.pushDataOffset ); - VULKAN_HPP_HASH_COMBINE( seed, indirectCommandsLayoutPushDataTokenNV.pushDataSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT const & indirectExecutionSetPipelineInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.initialPipeline ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetPipelineInfoEXT.maxPipelineCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT const & indirectExecutionSetShaderLayoutInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.setLayoutCount ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderLayoutInfoEXT.pSetLayouts ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT const & indirectExecutionSetShaderInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.shaderCount ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pInitialShaders ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pSetLayoutInfos ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.maxShaderCount ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pushConstantRangeCount ); - VULKAN_HPP_HASH_COMBINE( seed, indirectExecutionSetShaderInfoEXT.pPushConstantRanges ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL const & initializePerformanceApiInfoINTEL ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, initializePerformanceApiInfoINTEL.pUserData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference const & inputAttachmentAspectReference ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.subpass ); - VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.inputAttachmentIndex ); - VULKAN_HPP_HASH_COMBINE( seed, inputAttachmentAspectReference.aspectMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::InstanceCreateInfo const & instanceCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.pApplicationInfo ); - VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledLayerCount ); - for ( size_t i = 0; i < instanceCreateInfo.enabledLayerCount; ++i ) - { - for ( const char * p = instanceCreateInfo.ppEnabledLayerNames[i]; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - } - VULKAN_HPP_HASH_COMBINE( seed, instanceCreateInfo.enabledExtensionCount ); - for ( size_t i = 0; i < instanceCreateInfo.enabledExtensionCount; ++i ) - { - for ( const char * p = instanceCreateInfo.ppEnabledExtensionNames[i]; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV const & latencySleepInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.signalSemaphore ); - VULKAN_HPP_HASH_COMBINE( seed, latencySleepInfoNV.value ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV const & latencySleepModeInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyMode ); - VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.lowLatencyBoost ); - VULKAN_HPP_HASH_COMBINE( seed, latencySleepModeInfoNV.minimumIntervalUs ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV const & latencySubmissionPresentIdNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, latencySubmissionPresentIdNV.presentID ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV const & latencySurfaceCapabilitiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.presentModeCount ); - VULKAN_HPP_HASH_COMBINE( seed, latencySurfaceCapabilitiesNV.pPresentModes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerProperties const & layerProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, layerProperties.layerName[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, layerProperties.specVersion ); - VULKAN_HPP_HASH_COMBINE( seed, layerProperties.implementationVersion ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, layerProperties.description[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingEXT const & layerSettingEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - for ( const char * p = layerSettingEXT.pLayerName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - for ( const char * p = layerSettingEXT.pSettingName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.type ); - VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.valueCount ); - VULKAN_HPP_HASH_COMBINE( seed, layerSettingEXT.pValues ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT const & layerSettingsCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.settingCount ); - VULKAN_HPP_HASH_COMBINE( seed, layerSettingsCreateInfoEXT.pSettings ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_MACOS_MVK ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK const & macOSSurfaceCreateInfoMVK ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.sType ); - VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.flags ); - VULKAN_HPP_HASH_COMBINE( seed, macOSSurfaceCreateInfoMVK.pView ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MappedMemoryRange const & mappedMemoryRange ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.sType ); - VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.memory ); - VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.offset ); - VULKAN_HPP_HASH_COMBINE( seed, mappedMemoryRange.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo const & memoryAllocateFlagsInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateFlagsInfo.deviceMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo const & memoryAllocateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.allocationSize ); - VULKAN_HPP_HASH_COMBINE( seed, memoryAllocateInfo.memoryTypeIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrier const & memoryBarrier ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrier.dstAccessMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR const & memoryBarrierAccessFlags3KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.srcAccessMask3 ); - VULKAN_HPP_HASH_COMBINE( seed, memoryBarrierAccessFlags3KHR.dstAccessMask3 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo const & memoryDedicatedAllocateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.image ); - VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfo.buffer ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoTensorARM const & memoryDedicatedAllocateInfoTensorARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfoTensorARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfoTensorARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedAllocateInfoTensorARM.tensor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements const & memoryDedicatedRequirements ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.prefersDedicatedAllocation ); - VULKAN_HPP_HASH_COMBINE( seed, memoryDedicatedRequirements.requiresDedicatedAllocation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR const & memoryFdPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryFdPropertiesKHR.memoryTypeBits ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID const & memoryGetAndroidHardwareBufferInfoANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetAndroidHardwareBufferInfoANDROID.memory ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR const & memoryGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.memory ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetFdInfoKHR.handleType ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT const & memoryGetMetalHandleInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.memory ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetMetalHandleInfoEXT.handleType ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - -# if defined( VK_USE_PLATFORM_OHOS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS const & memoryGetNativeBufferInfoOHOS ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetNativeBufferInfoOHOS.memory ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_OHOS*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV const & memoryGetRemoteAddressInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.memory ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetRemoteAddressInfoNV.handleType ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR const & memoryGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.memory ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetWin32HandleInfoKHR.handleType ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA const & memoryGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.memory ); - VULKAN_HPP_HASH_COMBINE( seed, memoryGetZirconHandleInfoFUCHSIA.handleType ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHeap const & memoryHeap ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.size ); - VULKAN_HPP_HASH_COMBINE( seed, memoryHeap.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT const & memoryHostPointerPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryHostPointerPropertiesEXT.memoryTypeBits ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapInfo const & memoryMapInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.memory ); - VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.offset ); - VULKAN_HPP_HASH_COMBINE( seed, memoryMapInfo.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT const & memoryMapPlacedInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryMapPlacedInfoEXT.pPlacedAddress ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT const & memoryMetalHandlePropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryMetalHandlePropertiesEXT.memoryTypeBits ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo const & memoryOpaqueCaptureAddressAllocateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT const & memoryPriorityAllocateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryPriorityAllocateInfoEXT.priority ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements const & memoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.size ); - VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.alignment ); - VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements.memoryTypeBits ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryRequirements2 const & memoryRequirements2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryRequirements2.memoryRequirements ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryType const & memoryType ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryType.propertyFlags ); - VULKAN_HPP_HASH_COMBINE( seed, memoryType.heapIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryUnmapInfo const & memoryUnmapInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, memoryUnmapInfo.memory ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR const & memoryWin32HandlePropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryWin32HandlePropertiesKHR.memoryTypeBits ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA const & memoryZirconHandlePropertiesFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, memoryZirconHandlePropertiesFUCHSIA.memoryTypeBits ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT const & metalSurfaceCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, metalSurfaceCreateInfoEXT.pLayer ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT const & micromapBuildSizesInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.micromapSize ); - VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.buildScratchSize ); - VULKAN_HPP_HASH_COMBINE( seed, micromapBuildSizesInfoEXT.discardable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT const & micromapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.createFlags ); - VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.buffer ); - VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.offset ); - VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.size ); - VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.type ); - VULKAN_HPP_HASH_COMBINE( seed, micromapCreateInfoEXT.deviceAddress ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT const & micromapTriangleEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.dataOffset ); - VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.subdivisionLevel ); - VULKAN_HPP_HASH_COMBINE( seed, micromapTriangleEXT.format ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT const & micromapVersionInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, micromapVersionInfoEXT.pVersionData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT const & multiDrawIndexedInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.firstIndex ); - VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.indexCount ); - VULKAN_HPP_HASH_COMBINE( seed, multiDrawIndexedInfoEXT.vertexOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT const & multiDrawInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.firstVertex ); - VULKAN_HPP_HASH_COMBINE( seed, multiDrawInfoEXT.vertexCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT const & multisamplePropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, multisamplePropertiesEXT.maxSampleLocationGridSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT const & multisampledRenderToSingleSampledInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.multisampledRenderToSingleSampledEnable ); - VULKAN_HPP_HASH_COMBINE( seed, multisampledRenderToSingleSampledInfoEXT.rasterizationSamples ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX const & multiviewPerViewAttributesInfoNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributes ); - VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewAttributesInfoNVX.perViewAttributesPositionXOnly ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & multiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.perViewRenderAreaCount ); - VULKAN_HPP_HASH_COMBINE( seed, multiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pPerViewRenderAreas ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT const & mutableDescriptorTypeListEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.descriptorTypeCount ); - VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeListEXT.pDescriptorTypes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT const & mutableDescriptorTypeCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.mutableDescriptorTypeListCount ); - VULKAN_HPP_HASH_COMBINE( seed, mutableDescriptorTypeCreateInfoEXT.pMutableDescriptorTypeLists ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_OHOS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS const & nativeBufferFormatPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.sType ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.format ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.externalFormat ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.formatFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.samplerYcbcrConversionComponents ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYcbcrModel ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYcbcrRange ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedXChromaOffset ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferFormatPropertiesOHOS.suggestedYChromaOffset ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_OHOS*/ - -# if defined( VK_USE_PLATFORM_OHOS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS const & nativeBufferPropertiesOHOS ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.sType ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.allocationSize ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferPropertiesOHOS.memoryTypeBits ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_OHOS*/ - -# if defined( VK_USE_PLATFORM_OHOS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS const & nativeBufferUsageOHOS ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.sType ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, nativeBufferUsageOHOS.OHOSNativeBufferUsage ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_OHOS*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT const & opaqueCaptureDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDataCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDataCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDataCreateInfoEXT.pData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT const & opaqueCaptureDescriptorDataCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, opaqueCaptureDescriptorDataCreateInfoEXT.opaqueCaptureDescriptorData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV const & opticalFlowExecuteInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowExecuteInfoNV.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV const & opticalFlowImageFormatInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatInfoNV.usage ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV const & opticalFlowImageFormatPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowImageFormatPropertiesNV.format ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & opticalFlowSessionCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.width ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.height ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.imageFormat ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flowVectorFormat ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.costFormat ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.outputGridSize ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.hintGridSize ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.performanceLevel ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreateInfoNV.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV const & opticalFlowSessionCreatePrivateDataInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.id ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.size ); - VULKAN_HPP_HASH_COMBINE( seed, opticalFlowSessionCreatePrivateDataInfoNV.pPrivateData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV const & outOfBandQueueTypeInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, outOfBandQueueTypeInfoNV.queueType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV const & partitionedAccelerationStructureFlagsNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureFlagsNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureFlagsNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureFlagsNV.enablePartitionTranslation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV const & - partitionedAccelerationStructureUpdateInstanceDataNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureUpdateInstanceDataNV.instanceIndex ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureUpdateInstanceDataNV.instanceContributionToHitGroupIndex ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureUpdateInstanceDataNV.accelerationStructure ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV const & partitionedAccelerationStructureWriteInstanceDataNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.transform ); - for ( size_t i = 0; i < 6; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.explicitAABB[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceID ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceMask ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceContributionToHitGroupIndex ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceFlags ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.instanceIndex ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.partitionIndex ); - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWriteInstanceDataNV.accelerationStructure ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV const & - partitionedAccelerationStructureWritePartitionTranslationDataNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWritePartitionTranslationDataNV.partitionIndex ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, partitionedAccelerationStructureWritePartitionTranslationDataNV.partitionTranslation[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentStageTimeEXT const & presentStageTimeEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentStageTimeEXT.stage ); - VULKAN_HPP_HASH_COMBINE( seed, presentStageTimeEXT.time ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingEXT const & pastPresentationTimingEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.presentId ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.targetTime ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.presentStageCount ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.pPresentStages ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.timeDomain ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.timeDomainId ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingEXT.reportComplete ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE const & pastPresentationTimingGOOGLE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentID ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.desiredPresentTime ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.actualPresentTime ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.earliestPresentTime ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingGOOGLE.presentMargin ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingInfoEXT const & pastPresentationTimingInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingInfoEXT.swapchain ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PastPresentationTimingPropertiesEXT const & pastPresentationTimingPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.timingPropertiesCounter ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.timeDomainsCounter ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.presentationTimingCount ); - VULKAN_HPP_HASH_COMBINE( seed, pastPresentationTimingPropertiesEXT.pPresentationTimings ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM const & perTileBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, perTileBeginInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, perTileBeginInfoQCOM.pNext ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM const & perTileEndInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, perTileEndInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, perTileEndInfoQCOM.pNext ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL const & performanceConfigurationAcquireInfoINTEL ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, performanceConfigurationAcquireInfoINTEL.type ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterARM const & performanceCounterARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterARM.counterID ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM const & performanceCounterDescriptionARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.flags ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionARM.name[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR const & performanceCounterDescriptionKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.flags ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.name[i] ); - } - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.category[i] ); - } - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterDescriptionKHR.description[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR const & performanceCounterKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.unit ); - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.scope ); - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.storage ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, performanceCounterKHR.uuid[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL const & performanceMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, performanceMarkerInfoINTEL.marker ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL const & performanceOverrideInfoINTEL ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.type ); - VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.enable ); - VULKAN_HPP_HASH_COMBINE( seed, performanceOverrideInfoINTEL.parameter ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR const & performanceQuerySubmitInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, performanceQuerySubmitInfoKHR.counterPassIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL const & performanceStreamMarkerInfoINTEL ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, performanceStreamMarkerInfoINTEL.marker ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures const & physicalDevice16BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageBuffer16BitAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.uniformAndStorageBuffer16BitAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storagePushConstant16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice16BitStorageFeatures.storageInputOutput16 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT const & physicalDevice4444FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice4444FormatsFeaturesEXT.formatA4B4G4R4 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures const & physicalDevice8BitStorageFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storageBuffer8BitAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.uniformAndStorageBuffer8BitAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevice8BitStorageFeatures.storagePushConstant8 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT const & physicalDeviceASTCDecodeFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceASTCDecodeFeaturesEXT.decodeModeSharedExponent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR const & physicalDeviceAccelerationStructureFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureIndirectBuild ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructureHostCommands ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR const & physicalDeviceAccelerationStructurePropertiesKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxGeometryCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxInstanceCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPrimitiveCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorAccelerationStructures ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetAccelerationStructures ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.maxDescriptorSetUpdateAfterBindAccelerationStructures ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAccelerationStructurePropertiesKHR.minAccelerationStructureScratchOffsetAlignment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT const & physicalDeviceAddressBindingReportFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAddressBindingReportFeaturesEXT.reportAddressBinding ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC const & physicalDeviceAmigoProfilingFeaturesSEC ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAmigoProfilingFeaturesSEC.amigoProfiling ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD const & physicalDeviceAntiLagFeaturesAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAntiLagFeaturesAMD.antiLag ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & - physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.attachmentFeedbackLoopDynamicState ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & - physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.attachmentFeedbackLoopLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & physicalDeviceBlendOperationAdvancedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedFeaturesEXT.advancedBlendCoherentOperations ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & physicalDeviceBlendOperationAdvancedPropertiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendMaxColorAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendIndependentBlend ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedSrcColor ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendNonPremultipliedDstColor ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendCorrelatedOverlap ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBlendOperationAdvancedPropertiesEXT.advancedBlendAllOperations ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT const & physicalDeviceBorderColorSwizzleFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzleFromImage ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures const & physicalDeviceBufferDeviceAddressFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddressMultiDevice ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT const & physicalDeviceBufferDeviceAddressFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddress ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceBufferDeviceAddressFeaturesEXT.bufferDeviceAddressMultiDevice ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV const & - physicalDeviceClusterAccelerationStructureFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructureFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructureFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructureFeaturesNV.clusterAccelerationStructure ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV const & - physicalDeviceClusterAccelerationStructurePropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.maxVerticesPerCluster ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.maxTrianglesPerCluster ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterScratchByteAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterByteAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterTemplateByteAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterBottomLevelByteAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.clusterTemplateBoundsByteAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterAccelerationStructurePropertiesNV.maxClusterGeometryIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & physicalDeviceClusterCullingShaderFeaturesHUAWEI ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.clustercullingShader ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderFeaturesHUAWEI.multiviewClusterCullingShader ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & physicalDeviceClusterCullingShaderPropertiesHUAWEI ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.pNext ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupCount[i] ); - } - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxWorkGroupSize[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.maxOutputClusterCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderPropertiesHUAWEI.indirectBufferOffsetAlignment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.clusterShadingRate ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD const & physicalDeviceCoherentMemoryFeaturesAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoherentMemoryFeaturesAMD.deviceCoherentMemory ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT const & physicalDeviceColorWriteEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCommandBufferInheritanceFeaturesNV const & physicalDeviceCommandBufferInheritanceFeaturesNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCommandBufferInheritanceFeaturesNV.commandBufferInheritance ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & physicalDeviceComputeOccupancyPriorityFeaturesNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeOccupancyPriorityFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeOccupancyPriorityFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeOccupancyPriorityFeaturesNV.computeOccupancyPriority ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & physicalDeviceComputeShaderDerivativesFeaturesKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.computeDerivativeGroupQuads ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesFeaturesKHR.computeDerivativeGroupLinear ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & physicalDeviceComputeShaderDerivativesPropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceComputeShaderDerivativesPropertiesKHR.meshAndTaskShaderDerivatives ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT const & physicalDeviceConditionalRenderingFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConditionalRenderingFeaturesEXT.inheritedConditionalRendering ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT const & - physicalDeviceConservativeRasterizationPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveOverestimationSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.maxExtraPrimitiveOverestimationSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.extraPrimitiveOverestimationSizeGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.primitiveUnderestimation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativePointAndLineRasterization ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateTrianglesRasterized ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.degenerateLinesRasterized ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.fullyCoveredFragmentShaderInputVariable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceConservativeRasterizationPropertiesEXT.conservativeRasterizationPostDepthCoverage ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV const & physicalDeviceCooperativeMatrix2FeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixWorkgroupScope ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixFlexibleDimensions ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixReductions ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixConversions ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixPerElementOperations ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixTensorAddressing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2FeaturesNV.cooperativeMatrixBlockLoads ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV const & physicalDeviceCooperativeMatrix2PropertiesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixFlexibleDimensionsMaxDimension ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrix2PropertiesNV.cooperativeMatrixWorkgroupScopeReservedSharedMemory ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR const & physicalDeviceCooperativeMatrixFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrix ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesKHR.cooperativeMatrixRobustBufferAccess ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV const & physicalDeviceCooperativeMatrixFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrix ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixFeaturesNV.cooperativeMatrixRobustBufferAccess ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR const & physicalDeviceCooperativeMatrixPropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesKHR.cooperativeMatrixSupportedStages ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV const & physicalDeviceCooperativeMatrixPropertiesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeMatrixPropertiesNV.cooperativeMatrixSupportedStages ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV const & physicalDeviceCooperativeVectorFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.cooperativeVector ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorFeaturesNV.cooperativeVectorTraining ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV const & physicalDeviceCooperativeVectorPropertiesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.cooperativeVectorSupportedStages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.cooperativeVectorTrainingFloat16Accumulation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.cooperativeVectorTrainingFloat32Accumulation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCooperativeVectorPropertiesNV.maxCooperativeVectorComponents ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & physicalDeviceCopyMemoryIndirectFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.indirectMemoryCopy ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesKHR.indirectMemoryToImageCopy ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV const & physicalDeviceCopyMemoryIndirectFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectFeaturesNV.indirectCopy ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & physicalDeviceCopyMemoryIndirectPropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCopyMemoryIndirectPropertiesKHR.supportedQueues ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV const & physicalDeviceCornerSampledImageFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCornerSampledImageFeaturesNV.cornerSampledImage ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV const & physicalDeviceCoverageReductionModeFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCoverageReductionModeFeaturesNV.coverageReductionMode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM const & physicalDeviceCubicClampFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicClampFeaturesQCOM.cubicRangeClamp ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM const & physicalDeviceCubicWeightsFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCubicWeightsFeaturesQCOM.selectableCubicWeights ); - return seed; - } - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV const & physicalDeviceCudaKernelLaunchFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchFeaturesNV.cudaKernelLaunchFeatures ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV const & physicalDeviceCudaKernelLaunchPropertiesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMinor ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCudaKernelLaunchPropertiesNV.computeCapabilityMajor ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT const & physicalDeviceCustomBorderColorFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColors ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorFeaturesEXT.customBorderColorWithoutFormat ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT const & physicalDeviceCustomBorderColorPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomBorderColorPropertiesEXT.maxCustomBorderColorSamplers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomResolveFeaturesEXT const & physicalDeviceCustomResolveFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceCustomResolveFeaturesEXT.customResolve ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphFeaturesARM const & physicalDeviceDataGraphFeaturesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraph ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphSpecializationConstants ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphDescriptorBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphFeaturesARM.dataGraphShaderModule ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM const & physicalDeviceDataGraphModelFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDataGraphModelFeaturesQCOM.dataGraphModel ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & - physicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDedicatedAllocationImageAliasingFeaturesNV.dedicatedAllocationImageAliasing ); - return seed; - } - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & physicalDeviceDenseGeometryFormatFeaturesAMDX ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDenseGeometryFormatFeaturesAMDX.denseGeometryFormat ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT const & physicalDeviceDepthBiasControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasControl ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.leastRepresentableValueForceUnormRepresentation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.floatRepresentation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthBiasControlFeaturesEXT.depthBiasExact ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT const & physicalDeviceDepthClampControlFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampControlFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampControlFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampControlFeaturesEXT.depthClampControl ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR const & physicalDeviceDepthClampZeroOneFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClampZeroOneFeaturesKHR.depthClampZeroOne ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT const & physicalDeviceDepthClipControlFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipControlFeaturesEXT.depthClipControl ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT const & physicalDeviceDepthClipEnableFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties const & physicalDeviceDepthStencilResolveProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedDepthResolveModes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.supportedStencilResolveModes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolveNone ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDepthStencilResolveProperties.independentResolve ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & - physicalDeviceDescriptorBufferDensityMapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferDensityMapPropertiesEXT.combinedImageSamplerDensityMapDescriptorSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT const & physicalDeviceDescriptorBufferFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferImageLayoutIgnored ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferFeaturesEXT.descriptorBufferPushDescriptors ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT const & physicalDeviceDescriptorBufferPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSingleArray ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferlessPushDescriptors ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.allowSamplerImageViewPostSubmitCreation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxDescriptorBufferBindings ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferBindings ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferBindings ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplerBindings ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxEmbeddedImmutableSamplers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.bufferCaptureReplayDescriptorDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageCaptureReplayDescriptorDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.imageViewCaptureReplayDescriptorDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerCaptureReplayDescriptorDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureCaptureReplayDescriptorDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.combinedImageSamplerDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.sampledImageDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageImageDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformTexelBufferDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformTexelBufferDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageTexelBufferDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageTexelBufferDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.uniformBufferDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustUniformBufferDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.storageBufferDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.robustStorageBufferDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.inputAttachmentDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.accelerationStructureDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxSamplerDescriptorBufferRange ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.maxResourceDescriptorBufferRange ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.samplerDescriptorBufferAddressSpaceSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.resourceDescriptorBufferAddressSpaceSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferPropertiesEXT.descriptorBufferAddressSpaceSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorFeaturesARM const & physicalDeviceDescriptorBufferTensorFeaturesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorFeaturesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorFeaturesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorFeaturesARM.descriptorBufferTensorDescriptors ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorPropertiesARM const & physicalDeviceDescriptorBufferTensorPropertiesARM ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.tensorCaptureReplayDescriptorDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.tensorViewCaptureReplayDescriptorDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorBufferTensorPropertiesARM.tensorDescriptorSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT const & physicalDeviceDescriptorHeapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.descriptorHeap ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapFeaturesEXT.descriptorHeapCaptureReplay ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT const & physicalDeviceDescriptorHeapPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerHeapAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.resourceHeapAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxSamplerHeapSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxResourceHeapSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.minSamplerHeapReservedRange ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.minSamplerHeapReservedRangeWithEmbedded ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.minResourceHeapReservedRange ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.imageDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.bufferDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerDescriptorAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.imageDescriptorAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.bufferDescriptorAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxPushDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.imageCaptureReplayOpaqueDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.maxDescriptorHeapEmbeddedSamplers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.samplerYcbcrConversionCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.sparseDescriptorHeaps ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapPropertiesEXT.protectedDescriptorHeaps ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM const & physicalDeviceDescriptorHeapTensorPropertiesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.tensorDescriptorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.tensorDescriptorAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorHeapTensorPropertiesARM.tensorCaptureReplayOpaqueDataSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures const & physicalDeviceDescriptorIndexingFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageImageArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderInputAttachmentArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.descriptorBindingVariableDescriptorCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties const & physicalDeviceDescriptorIndexingProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxUpdateAfterBindDescriptorsInAllPools ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderUniformBufferArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderSampledImageArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageBufferArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderStorageImageArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.shaderInputAttachmentArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.robustBufferAccessUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.quadDivergentImplicitLod ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSamplers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindSampledImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindStorageImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxPerStageUpdateAfterBindResources ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSamplers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindSampledImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindStorageImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorIndexingProperties.maxDescriptorSetUpdateAfterBindInputAttachments ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & - physicalDeviceDescriptorPoolOverallocationFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorPoolOverallocationFeaturesNV.descriptorPoolOverallocation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & physicalDeviceDescriptorSetHostMappingFeaturesVALVE ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDescriptorSetHostMappingFeaturesVALVE.descriptorSetHostMapping ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & - physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedCompute ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputePipelines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.deviceGeneratedComputeCaptureReplay ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & physicalDeviceDeviceGeneratedCommandsFeaturesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.deviceGeneratedCommands ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesEXT.dynamicGeneratedPipelineLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & physicalDeviceDeviceGeneratedCommandsFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsFeaturesNV.deviceGeneratedCommands ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & physicalDeviceDeviceGeneratedCommandsPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectPipelineCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectShaderObjectCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectSequenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectCommandsTokenCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectCommandsTokenOffset ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.maxIndirectCommandsIndirectStride ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsInputModes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsShaderStages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsShaderStagesPipelineBinding ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.supportedIndirectCommandsShaderStagesShaderBinding ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.deviceGeneratedCommandsTransformFeedback ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesEXT.deviceGeneratedCommandsMultiDrawIndirectCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & physicalDeviceDeviceGeneratedCommandsPropertiesNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxGraphicsShaderGroupCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectSequenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsTokenOffset ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.maxIndirectCommandsStreamStride ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesCountBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minSequencesIndexBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceGeneratedCommandsPropertiesNV.minIndirectCommandsBufferOffsetAlignment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT const & physicalDeviceDeviceMemoryReportFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDeviceMemoryReportFeaturesEXT.deviceMemoryReport ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV const & physicalDeviceDiagnosticsConfigFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiagnosticsConfigFeaturesNV.diagnosticsConfig ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT const & physicalDeviceDiscardRectanglePropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDiscardRectanglePropertiesEXT.maxDiscardRectangles ); - return seed; - } - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV const & physicalDeviceDisplacementMicromapFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapFeaturesNV.displacementMicromap ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV const & physicalDeviceDisplacementMicromapPropertiesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDisplacementMicromapPropertiesNV.maxDisplacementMicromapSubdivisionLevel ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties const & physicalDeviceDriverProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverID ); - for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverName[i] ); - } - for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.driverInfo[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDriverProperties.conformanceVersion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT const & physicalDeviceDrmPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasPrimary ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.hasRender ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMajor ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.primaryMinor ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMajor ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDrmPropertiesEXT.renderMinor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures const & physicalDeviceDynamicRenderingFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingFeatures.dynamicRendering ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeatures const & physicalDeviceDynamicRenderingLocalReadFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingLocalReadFeatures.dynamicRenderingLocalRead ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & - physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.dynamicRenderingUnusedAttachments ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV const & physicalDeviceExclusiveScissorFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExclusiveScissorFeaturesNV.exclusiveScissor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT const & physicalDeviceExtendedDynamicState2FeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2LogicOp ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2PatchControlPoints ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT const & physicalDeviceExtendedDynamicState3FeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3TessellationDomainOrigin ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClampEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3PolygonMode ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationSamples ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleMask ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToCoverageEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3AlphaToOneEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LogicOpEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendEquation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorWriteMask ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RasterizationStream ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ConservativeRasterizationMode ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ExtraPrimitiveOverestimationSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3SampleLocationsEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ColorBlendAdvanced ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ProvokingVertexMode ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineRasterizationMode ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3LineStippleEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3DepthClipNegativeOneToOne ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportWScalingEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ViewportSwizzle ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageToColorLocation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationMode ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTableEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageModulationTable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3CoverageReductionMode ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3RepresentativeFragmentTestEnable ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3FeaturesEXT.extendedDynamicState3ShadingRateImageEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT const & physicalDeviceExtendedDynamicState3PropertiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicState3PropertiesEXT.dynamicPrimitiveTopologyUnrestricted ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT const & physicalDeviceExtendedDynamicStateFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedDynamicStateFeaturesEXT.extendedDynamicState ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & physicalDeviceExtendedSparseAddressSpaceFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpaceFeaturesNV.extendedSparseAddressSpace ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & - physicalDeviceExtendedSparseAddressSpacePropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseAddressSpaceSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseImageUsageFlags ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExtendedSparseAddressSpacePropertiesNV.extendedSparseBufferUsageFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo const & physicalDeviceExternalBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.usage ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalBufferInfo.handleType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV const & physicalDeviceExternalComputeQueuePropertiesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.externalDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.maxExternalQueues ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo const & physicalDeviceExternalFenceInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFenceInfo.handleType ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID const & physicalDeviceExternalFormatResolveFeaturesANDROID ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolveFeaturesANDROID.externalFormatResolve ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID const & - physicalDeviceExternalFormatResolvePropertiesANDROID ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.nullColorAttachmentWithExternalFormatResolve ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetX ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalFormatResolvePropertiesANDROID.externalFormatResolveChromaOffsetY ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo const & physicalDeviceExternalImageFormatInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalImageFormatInfo.handleType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT const & physicalDeviceExternalMemoryHostPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryHostPropertiesEXT.minImportedHostPointerAlignment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV const & physicalDeviceExternalMemoryRDMAFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryRDMAFeaturesNV.externalMemoryRDMA ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & physicalDeviceExternalMemoryScreenBufferFeaturesQNX ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalMemoryScreenBufferFeaturesQNX.screenBufferImport ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo const & physicalDeviceExternalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalSemaphoreInfo.handleType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalTensorInfoARM const & physicalDeviceExternalTensorInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.flags ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.pDescription ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalTensorInfoARM.handleType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT const & physicalDeviceFaultFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFault ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFaultFeaturesEXT.deviceFaultVendorBinary ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 const & physicalDeviceFeatures2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFeatures2.features ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties const & physicalDeviceFloatControlsProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.denormBehaviorIndependence ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.roundingModeIndependence ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderSignedZeroInfNanPreserveFloat64 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormPreserveFloat64 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderDenormFlushToZeroFloat64 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTEFloat64 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFloatControlsProperties.shaderRoundingModeRTZFloat64 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM const & physicalDeviceFormatPackFeaturesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFormatPackFeaturesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFormatPackFeaturesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFormatPackFeaturesARM.formatPack ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT const & physicalDeviceFragmentDensityMap2FeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2FeaturesEXT.fragmentDensityMapDeferred ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT const & physicalDeviceFragmentDensityMap2PropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledLoads ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.subsampledCoarseReconstructionEarlyAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxSubsampledArrayLayers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMap2PropertiesEXT.maxDescriptorSetSubsampledSamplers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT const & physicalDeviceFragmentDensityMapFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMapNonSubsampledImages ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & - physicalDeviceFragmentDensityMapLayeredFeaturesVALVE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredFeaturesVALVE.fragmentDensityMapLayered ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & - physicalDeviceFragmentDensityMapLayeredPropertiesVALVE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapLayeredPropertiesVALVE.maxFragmentDensityMapLayers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & physicalDeviceFragmentDensityMapOffsetFeaturesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetFeaturesEXT.fragmentDensityMapOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & physicalDeviceFragmentDensityMapOffsetPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapOffsetPropertiesEXT.fragmentDensityOffsetGranularity ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT const & physicalDeviceFragmentDensityMapPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.minFragmentDensityTexelSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.maxFragmentDensityTexelSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentDensityMapPropertiesEXT.fragmentDensityInvocations ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & physicalDeviceFragmentShaderBarycentricFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricFeaturesKHR.fragmentShaderBarycentric ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & - physicalDeviceFragmentShaderBarycentricPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderBarycentricPropertiesKHR.triStripVertexOrderIndependentOfProvokingVertex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & physicalDeviceFragmentShaderInterlockFeaturesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & physicalDeviceFragmentShadingRateEnumsFeaturesNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.fragmentShadingRateEnums ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.supersampleFragmentShadingRates ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsFeaturesNV.noInvocationFragmentShadingRates ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & physicalDeviceFragmentShadingRateEnumsPropertiesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateEnumsPropertiesNV.maxFragmentShadingRateInvocationCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR const & physicalDeviceFragmentShadingRateFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.pipelineFragmentShadingRate ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateFeaturesKHR.attachmentFragmentShadingRate ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR const & physicalDeviceFragmentShadingRateKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.sampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRateKHR.fragmentSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR const & physicalDeviceFragmentShadingRatePropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.minFragmentShadingRateAttachmentTexelSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.primitiveFragmentShadingRateWithMultipleViewports ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.layeredShadingRateAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateNonTrivialCombinerOps ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentSizeAspectRatio ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateCoverageSamples ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.maxFragmentShadingRateRasterizationSamples ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderDepthStencilWrites ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithSampleMask ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithShaderSampleMask ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithConservativeRasterization ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithFragmentShaderInterlock ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateWithCustomSampleLocations ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFragmentShadingRatePropertiesKHR.fragmentShadingRateStrictMultiplyCombiner ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT const & physicalDeviceFrameBoundaryFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceFrameBoundaryFeaturesEXT.frameBoundary ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeatures const & physicalDeviceGlobalPriorityQueryFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGlobalPriorityQueryFeatures.globalPriorityQuery ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & physicalDeviceGraphicsPipelineLibraryFeaturesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryFeaturesEXT.graphicsPipelineLibrary ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & physicalDeviceGraphicsPipelineLibraryPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryFastLinking ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGraphicsPipelineLibraryPropertiesEXT.graphicsPipelineLibraryIndependentInterpolationDecoration ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties const & physicalDeviceGroupProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDeviceCount ); - for ( size_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.physicalDevices[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceGroupProperties.subsetAllocation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI const & physicalDeviceHdrVividFeaturesHUAWEI ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHdrVividFeaturesHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHdrVividFeaturesHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHdrVividFeaturesHUAWEI.hdrVivid ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeatures const & physicalDeviceHostImageCopyFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyFeatures.hostImageCopy ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyProperties const & physicalDeviceHostImageCopyProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.copySrcLayoutCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pCopySrcLayouts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.copyDstLayoutCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.pCopyDstLayouts ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.optimalTilingLayoutUUID[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostImageCopyProperties.identicalMemoryTypeRequirements ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures const & physicalDeviceHostQueryResetFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceHostQueryResetFeatures.hostQueryReset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties const & physicalDeviceIDProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.pNext ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceUUID[i] ); - } - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.driverUUID[i] ); - } - for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUID[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceNodeMask ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIDProperties.deviceLUIDValid ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT const & physicalDeviceImage2DViewOf3DFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImage2DViewOf3DFeaturesEXT.sampler2DViewOf3D ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA const & physicalDeviceImageAlignmentControlFeaturesMESA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlFeaturesMESA.imageAlignmentControl ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA const & physicalDeviceImageAlignmentControlPropertiesMESA ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageAlignmentControlPropertiesMESA.supportedImageAlignmentMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT const & physicalDeviceImageCompressionControlFeaturesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlFeaturesEXT.imageCompressionControl ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & - physicalDeviceImageCompressionControlSwapchainFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageCompressionControlSwapchainFeaturesEXT.imageCompressionControlSwapchain ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT const & physicalDeviceImageDrmFormatModifierInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.drmFormatModifier ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.sharingMode ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.queueFamilyIndexCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageDrmFormatModifierInfoEXT.pQueueFamilyIndices ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 const & physicalDeviceImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.format ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.type ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.tiling ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.usage ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageFormatInfo2.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM const & physicalDeviceImageProcessing2FeaturesQCOM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2FeaturesQCOM.textureBlockMatch2 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM const & physicalDeviceImageProcessing2PropertiesQCOM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessing2PropertiesQCOM.maxBlockMatchWindow ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM const & physicalDeviceImageProcessingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureSampleWeighted ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBoxFilter ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingFeaturesQCOM.textureBlockMatch ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM const & physicalDeviceImageProcessingPropertiesQCOM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterPhases ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxWeightFilterDimension ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBlockMatchRegion ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageProcessingPropertiesQCOM.maxBoxFilterBlockSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures const & physicalDeviceImageRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageRobustnessFeatures.robustImageAccess ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & physicalDeviceImageSlicedViewOf3DFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageSlicedViewOf3DFeaturesEXT.imageSlicedViewOf3D ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT const & physicalDeviceImageViewImageFormatInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewImageFormatInfoEXT.imageViewType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT const & physicalDeviceImageViewMinLodFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImageViewMinLodFeaturesEXT.minLod ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures const & physicalDeviceImagelessFramebufferFeatures ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8Features const & physicalDeviceIndexTypeUint8Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceIndexTypeUint8Features.indexTypeUint8 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV const & physicalDeviceInheritedViewportScissorFeaturesNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInheritedViewportScissorFeaturesNV.inheritedViewportScissor2D ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures const & physicalDeviceInlineUniformBlockFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.inlineUniformBlock ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockFeatures.descriptorBindingInlineUniformBlockUpdateAfterBind ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties const & physicalDeviceInlineUniformBlockProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxInlineUniformBlockSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorInlineUniformBlocks ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetInlineUniformBlocks ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInlineUniformBlockProperties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & - physicalDeviceInternallySynchronizedQueuesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInternallySynchronizedQueuesFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInternallySynchronizedQueuesFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInternallySynchronizedQueuesFeaturesKHR.internallySynchronizedQueues ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI const & physicalDeviceInvocationMaskFeaturesHUAWEI ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceInvocationMaskFeaturesHUAWEI.invocationMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR const & physicalDeviceLayeredApiPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.vendorID ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceID ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.layeredAPI ); - for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesKHR.deviceName[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR const & physicalDeviceLayeredApiPropertiesListKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.layeredApiCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiPropertiesListKHR.pLayeredApis ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits const & physicalDeviceLimits ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension1D ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension2D ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimension3D ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageDimensionCube ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxImageArrayLayers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelBufferElements ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxUniformBufferRange ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxStorageBufferRange ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPushConstantsSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxMemoryAllocationCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAllocationCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.bufferImageGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sparseAddressSpaceSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxBoundDescriptorSets ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSamplers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorSampledImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorStorageImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageDescriptorInputAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxPerStageResources ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSamplers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetUniformBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetSampledImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetStorageImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDescriptorSetInputAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindings ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputAttributeOffset ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexInputBindingStride ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxVertexOutputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationGenerationLevel ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationPatchSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexInputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerVertexOutputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlPerPatchOutputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationControlTotalOutputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationInputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTessellationEvaluationOutputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryShaderInvocations ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryInputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryOutputVertices ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxGeometryTotalOutputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentInputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentOutputAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentDualSrcAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFragmentCombinedOutputResources ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeSharedMemorySize ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupCount[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupInvocations ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxComputeWorkGroupSize[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelPrecisionBits ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subTexelPrecisionBits ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.mipmapPrecisionBits ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndexedIndexValue ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxDrawIndirectCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerLodBias ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSamplerAnisotropy ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewports ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxViewportDimensions[i] ); - } - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportBoundsRange[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.viewportSubPixelBits ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minMemoryMapAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minUniformBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minStorageBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelOffset ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelOffset ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minTexelGatherOffset ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxTexelGatherOffset ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.minInterpolationOffset ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxInterpolationOffset ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.subPixelInterpolationOffsetBits ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferWidth ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferHeight ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxFramebufferLayers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferColorSampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferDepthSampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferStencilSampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.framebufferNoAttachmentsSampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxColorAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageColorSampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageIntegerSampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageDepthSampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.sampledImageStencilSampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.storageImageSampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxSampleMaskWords ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampComputeAndGraphics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.timestampPeriod ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxClipDistances ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCullDistances ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.maxCombinedClipAndCullDistances ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.discreteQueuePriorities ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeRange[i] ); - } - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthRange[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.pointSizeGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.lineWidthGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.strictLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.standardSampleLocations ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.optimalBufferCopyRowPitchAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLimits.nonCoherentAtomSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties const & physicalDeviceSparseProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DBlockShape ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard2DMultisampleBlockShape ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyStandard3DBlockShape ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyAlignedMipSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseProperties.residencyNonResidentStrict ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties const & physicalDeviceProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.apiVersion ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.driverVersion ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.vendorID ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceID ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceType ); - for ( size_t i = 0; i < VK_MAX_PHYSICAL_DEVICE_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.deviceName[i] ); - } - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.pipelineCacheUUID[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.limits ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties.sparseProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 const & physicalDeviceProperties2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProperties2.properties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR const & physicalDeviceLayeredApiVulkanPropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredApiVulkanPropertiesKHR.properties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT const & physicalDeviceLayeredDriverPropertiesMSFT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLayeredDriverPropertiesMSFT.underlyingAPI ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT const & physicalDeviceLegacyDitheringFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & physicalDeviceLegacyVertexAttributesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesFeaturesEXT.legacyVertexAttributes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & physicalDeviceLegacyVertexAttributesPropertiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLegacyVertexAttributesPropertiesEXT.nativeUnalignedPerformance ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeatures const & physicalDeviceLineRasterizationFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.rectangularLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.bresenhamLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.smoothLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledRectangularLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledBresenhamLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationFeatures.stippledSmoothLines ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationProperties const & physicalDeviceLineRasterizationProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLineRasterizationProperties.lineSubPixelPrecisionBits ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV const & physicalDeviceLinearColorAttachmentFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceLinearColorAttachmentFeaturesNV.linearColorAttachment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR const & physicalDeviceMaintenance10FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10FeaturesKHR.maintenance10 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR const & physicalDeviceMaintenance10PropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.rgba4OpaqueBlackSwizzled ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.resolveSrgbFormatAppliesTransferFunction ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance10PropertiesKHR.resolveSrgbFormatSupportsTransferFunctionControl ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties const & physicalDeviceMaintenance3Properties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxPerSetDescriptors ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance3Properties.maxMemoryAllocationSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features const & physicalDeviceMaintenance4Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Features.maintenance4 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties const & physicalDeviceMaintenance4Properties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance4Properties.maxBufferSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Features const & physicalDeviceMaintenance5Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Features.maintenance5 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Properties const & physicalDeviceMaintenance5Properties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.earlyFragmentMultisampleCoverageAfterSampleCounting ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.earlyFragmentSampleMaskTestBeforeSampleCounting ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.depthStencilSwizzleOneSupport ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.polygonModePointSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.nonStrictSinglePixelWideLinesUseParallelogram ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance5Properties.nonStrictWideLinesUseParallelogram ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Features const & physicalDeviceMaintenance6Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Features.maintenance6 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Properties const & physicalDeviceMaintenance6Properties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.blockTexelViewCompatibleMultipleLayers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.maxCombinedImageSamplerDescriptorCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance6Properties.fragmentShadingRateClampCombinerInputs ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR const & physicalDeviceMaintenance7FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7FeaturesKHR.maintenance7 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR const & physicalDeviceMaintenance7PropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.robustFragmentShadingRateAttachmentAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.separateDepthStencilAttachmentAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalUniformBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalStorageBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetTotalBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance7PropertiesKHR.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR const & physicalDeviceMaintenance8FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance8FeaturesKHR.maintenance8 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9FeaturesKHR const & physicalDeviceMaintenance9FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9FeaturesKHR.maintenance9 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9PropertiesKHR const & physicalDeviceMaintenance9PropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.image2DViewOf3DSparse ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMaintenance9PropertiesKHR.defaultVertexAttributeValue ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT const & physicalDeviceMapMemoryPlacedFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapPlaced ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryMapRangePlaced ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedFeaturesEXT.memoryUnmapReserve ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT const & physicalDeviceMapMemoryPlacedPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMapMemoryPlacedPropertiesEXT.minPlacedMemoryMapAlignment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT const & physicalDeviceMemoryBudgetPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.pNext ); - for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapBudget[i] ); - } - for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryBudgetPropertiesEXT.heapUsage[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT const & physicalDeviceMemoryDecompressionFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionFeaturesEXT.memoryDecompression ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT const & physicalDeviceMemoryDecompressionPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.decompressionMethods ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryDecompressionPropertiesEXT.maxDecompressionIndirectCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT const & physicalDeviceMemoryPriorityFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties const & physicalDeviceMemoryProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypeCount ); - for ( size_t i = 0; i < VK_MAX_MEMORY_TYPES; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryTypes[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeapCount ); - for ( size_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties.memoryHeaps[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 const & physicalDeviceMemoryProperties2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMemoryProperties2.memoryProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT const & physicalDeviceMeshShaderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.taskShader ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShader ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.multiviewMeshShader ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesEXT.meshShaderQueries ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV const & physicalDeviceMeshShaderFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.taskShader ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderFeaturesNV.meshShader ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT const & physicalDeviceMeshShaderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupTotalCount ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupCount[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupInvocations ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskWorkGroupSize[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskSharedMemorySize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxTaskPayloadAndSharedMemorySize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupTotalCount ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupCount[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupInvocations ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshWorkGroupSize[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshSharedMemorySize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndSharedMemorySize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputMemorySize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshPayloadAndOutputMemorySize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputComponents ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputVertices ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputPrimitives ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshOutputLayers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxMeshMultiviewViewCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerVertexGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.meshOutputPerPrimitiveGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredTaskWorkGroupInvocations ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.maxPreferredMeshWorkGroupInvocations ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationVertexOutput ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersLocalInvocationPrimitiveOutput ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactVertexOutput ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesEXT.prefersCompactPrimitiveOutput ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV const & physicalDeviceMeshShaderPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxDrawMeshTasksCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupInvocations ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskWorkGroupSize[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskTotalMemorySize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxTaskOutputCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupInvocations ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshWorkGroupSize[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshTotalMemorySize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputVertices ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshOutputPrimitives ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.maxMeshMultiviewViewCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerVertexGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMeshShaderPropertiesNV.meshOutputPerPrimitiveGranularity ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT const & physicalDeviceMultiDrawFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawFeaturesEXT.multiDraw ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT const & physicalDeviceMultiDrawPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiDrawPropertiesEXT.maxMultiDrawCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & - physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.multisampledRenderToSingleSampled ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures const & physicalDeviceMultiviewFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiview ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewGeometryShader ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewFeatures.multiviewTessellationShader ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & - physicalDeviceMultiviewPerViewAttributesPropertiesNVX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewAttributesPropertiesNVX.perViewPositionAllComponents ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & - physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.multiviewPerViewRenderAreas ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & physicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewPerViewViewportsFeaturesQCOM.multiviewPerViewViewports ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties const & physicalDeviceMultiviewProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewViewCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMultiviewProperties.maxMultiviewInstanceIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & physicalDeviceMutableDescriptorTypeFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceMutableDescriptorTypeFeaturesEXT.mutableDescriptorType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT const & physicalDeviceNestedCommandBufferFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferRendering ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferFeaturesEXT.nestedCommandBufferSimultaneousUse ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT const & physicalDeviceNestedCommandBufferPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNestedCommandBufferPropertiesEXT.maxCommandBufferNestingLevel ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & physicalDeviceNonSeamlessCubeMapFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceNonSeamlessCubeMapFeaturesEXT.nonSeamlessCubeMap ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT const & physicalDeviceOpacityMicromapFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromap ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapFeaturesEXT.micromapHostCommands ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT const & physicalDeviceOpacityMicromapPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity2StateSubdivisionLevel ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpacityMicromapPropertiesEXT.maxOpacity4StateSubdivisionLevel ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV const & physicalDeviceOpticalFlowFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowFeaturesNV.opticalFlow ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV const & physicalDeviceOpticalFlowPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedOutputGridSizes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.supportedHintGridSizes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.hintSupported ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.costSupported ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.bidirectionalFlowSupported ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.globalFlowSupported ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minWidth ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.minHeight ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxWidth ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxHeight ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceOpticalFlowPropertiesNV.maxNumRegionsOfInterest ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT const & physicalDevicePCIBusInfoPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDomain ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciBus ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciDevice ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePCIBusInfoPropertiesEXT.pciFunction ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & physicalDevicePageableDeviceLocalMemoryFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & - physicalDevicePartitionedAccelerationStructureFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructureFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructureFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructureFeaturesNV.partitionedAccelerationStructure ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & - physicalDevicePartitionedAccelerationStructurePropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructurePropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructurePropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePartitionedAccelerationStructurePropertiesNV.maxPartitionCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV const & physicalDevicePerStageDescriptorSetFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.perStageDescriptorSet ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerStageDescriptorSetFeaturesNV.dynamicPipelineLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM const & - physicalDevicePerformanceCountersByRegionFeaturesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionFeaturesARM.performanceCountersByRegion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM const & - physicalDevicePerformanceCountersByRegionPropertiesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.maxPerRegionPerformanceCounters ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.performanceCounterRegionSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.rowStrideAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.regionAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceCountersByRegionPropertiesARM.identityTransformOrder ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR const & physicalDevicePerformanceQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryFeaturesKHR.performanceCounterMultipleQueryPools ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR const & physicalDevicePerformanceQueryPropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePerformanceQueryPropertiesKHR.allowCommandBufferQueryCopies ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR const & physicalDevicePipelineBinaryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryFeaturesKHR.pipelineBinaries ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR const & physicalDevicePipelineBinaryPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryInternalCache ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryInternalCacheControl ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryPrefersInternalCache ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryPrecompiledInternalCache ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineBinaryPropertiesKHR.pipelineBinaryCompressedData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & - physicalDevicePipelineCacheIncrementalModeFeaturesSEC ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCacheIncrementalModeFeaturesSEC.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCacheIncrementalModeFeaturesSEC.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCacheIncrementalModeFeaturesSEC.pipelineCacheIncrementalMode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures const & physicalDevicePipelineCreationCacheControlFeatures ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineCreationCacheControlFeatures.pipelineCreationCacheControl ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & - physicalDevicePipelineExecutablePropertiesFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & - physicalDevicePipelineLibraryGroupHandlesFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineLibraryGroupHandlesFeaturesEXT.pipelineLibraryGroupHandles ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM const & physicalDevicePipelineOpacityMicromapFeaturesARM ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineOpacityMicromapFeaturesARM.pipelineOpacityMicromap ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT const & physicalDevicePipelinePropertiesFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelinePropertiesFeaturesEXT.pipelinePropertiesIdentifier ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeatures const & physicalDevicePipelineProtectedAccessFeatures ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineProtectedAccessFeatures.pipelineProtectedAccess ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeatures const & physicalDevicePipelineRobustnessFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessFeatures.pipelineRobustness ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessProperties const & physicalDevicePipelineRobustnessProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessVertexInputs ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePipelineRobustnessProperties.defaultRobustnessImages ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties const & physicalDevicePointClippingProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePointClippingProperties.pointClippingBehavior ); - return seed; - } - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR const & physicalDevicePortabilitySubsetFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.constantAlphaColorBlendFactors ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.events ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatReinterpretation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageViewFormatSwizzle ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.imageView2DOn3DImage ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.multisampleArrayImage ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.mutableComparisonSamplers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.pointPolygons ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.samplerMipLodBias ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.separateStencilMaskRef ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.shaderSampleRateInterpolationFunctions ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationIsolines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.tessellationPointMode ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.triangleFans ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetFeaturesKHR.vertexAttributeAccessBeyondStride ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR const & physicalDevicePortabilitySubsetPropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePortabilitySubsetPropertiesKHR.minVertexInputBindingStrideAlignment ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV const & physicalDevicePresentBarrierFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentBarrierFeaturesNV.presentBarrier ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentId2FeaturesKHR const & physicalDevicePresentId2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentId2FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentId2FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentId2FeaturesKHR.presentId2 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR const & physicalDevicePresentIdFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentIdFeaturesKHR.presentId ); - return seed; - } - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV const & physicalDevicePresentMeteringFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentMeteringFeaturesNV.presentMetering ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & physicalDevicePresentModeFifoLatestReadyFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentModeFifoLatestReadyFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentModeFifoLatestReadyFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentModeFifoLatestReadyFeaturesKHR.presentModeFifoLatestReady ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentTimingFeaturesEXT const & physicalDevicePresentTimingFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.presentTiming ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.presentAtAbsoluteTime ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentTimingFeaturesEXT.presentAtRelativeTime ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWait2FeaturesKHR const & physicalDevicePresentWait2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWait2FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWait2FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWait2FeaturesKHR.presentWait2 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR const & physicalDevicePresentWaitFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePresentWaitFeaturesKHR.presentWait ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & - physicalDevicePrimitiveTopologyListRestartFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyPatchListRestart ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & physicalDevicePrimitivesGeneratedQueryFeaturesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQuery ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithRasterizerDiscard ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrimitivesGeneratedQueryFeaturesEXT.primitivesGeneratedQueryWithNonZeroStreams ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures const & physicalDevicePrivateDataFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePrivateDataFeatures.privateData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures const & physicalDeviceProtectedMemoryFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryFeatures.protectedMemory ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties const & physicalDeviceProtectedMemoryProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProtectedMemoryProperties.protectedNoFault ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT const & physicalDeviceProvokingVertexFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.provokingVertexLast ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexFeaturesEXT.transformFeedbackPreservesProvokingVertex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT const & physicalDeviceProvokingVertexPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.provokingVertexModePerPipeline ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceProvokingVertexPropertiesEXT.transformFeedbackPreservesTriangleFanProvokingVertex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV const & physicalDevicePushConstantBankFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankFeaturesNV.pushConstantBank ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV const & physicalDevicePushConstantBankPropertiesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxGraphicsPushConstantBanks ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxComputePushConstantBanks ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxGraphicsPushDataBanks ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushConstantBankPropertiesNV.maxComputePushDataBanks ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorProperties const & physicalDevicePushDescriptorProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDevicePushDescriptorProperties.maxPushDescriptors ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & - physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.queueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.engineType ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & physicalDeviceRGBA10X6FormatsFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRGBA10X6FormatsFeaturesEXT.formatRgba10x6WithoutYCbCrSampler ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & - physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderColorAttachmentAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderDepthAttachmentAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.rasterizationOrderStencilAttachmentAccess ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV const & physicalDeviceRawAccessChainsFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRawAccessChainsFeaturesNV.shaderRawAccessChains ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR const & physicalDeviceRayQueryFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayQueryFeaturesKHR.rayQuery ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & - physicalDeviceRayTracingInvocationReorderFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesEXT.rayTracingInvocationReorder ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & physicalDeviceRayTracingInvocationReorderFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderFeaturesNV.rayTracingInvocationReorder ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & - physicalDeviceRayTracingInvocationReorderPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.rayTracingInvocationReorderReorderingHint ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesEXT.maxShaderBindingTableRecordIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & - physicalDeviceRayTracingInvocationReorderPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingInvocationReorderPropertiesNV.rayTracingInvocationReorderReorderingHint ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & - physicalDeviceRayTracingLinearSweptSpheresFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.spheres ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingLinearSweptSpheresFeaturesNV.linearSweptSpheres ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & physicalDeviceRayTracingMaintenance1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingMaintenance1 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingPipelineTraceRaysIndirect2 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV const & physicalDeviceRayTracingMotionBlurFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlur ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingMotionBlurFeaturesNV.rayTracingMotionBlurPipelineTraceRaysIndirect ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR const & physicalDeviceRayTracingPipelineFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR const & physicalDeviceRayTracingPipelinePropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayRecursionDepth ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxShaderGroupStride ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupBaseAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleCaptureReplaySize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayDispatchInvocationCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.shaderGroupHandleAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPipelinePropertiesKHR.maxRayHitAttributeSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & physicalDeviceRayTracingPositionFetchFeaturesKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPositionFetchFeaturesKHR.rayTracingPositionFetch ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV const & physicalDeviceRayTracingPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupHandleSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxRecursionDepth ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxShaderGroupStride ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.shaderGroupBaseAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxGeometryCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxInstanceCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxTriangleCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingPropertiesNV.maxDescriptorSetAccelerationStructures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV const & physicalDeviceRayTracingValidationFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRayTracingValidationFeaturesNV.rayTracingValidation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & physicalDeviceRelaxedLineRasterizationFeaturesIMG ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRelaxedLineRasterizationFeaturesIMG.relaxedLineRasterization ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM const & physicalDeviceRenderPassStripedFeaturesARM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedFeaturesARM.renderPassStriped ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM const & physicalDeviceRenderPassStripedPropertiesARM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.renderPassStripeGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRenderPassStripedPropertiesARM.maxRenderPassStripes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & physicalDeviceRepresentativeFragmentTestFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRepresentativeFragmentTestFeaturesNV.representativeFragmentTest ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR const & physicalDeviceRobustness2FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.robustBufferAccess2 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.robustImageAccess2 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2FeaturesKHR.nullDescriptor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR const & physicalDeviceRobustness2PropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.robustStorageBufferAccessSizeAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceRobustness2PropertiesKHR.robustUniformBufferAccessSizeAlignment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT const & physicalDeviceSampleLocationsPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSampleCounts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.maxSampleLocationGridSize ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationCoordinateRange[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.sampleLocationSubPixelBits ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSampleLocationsPropertiesEXT.variableSampleLocations ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties const & physicalDeviceSamplerFilterMinmaxProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxSingleComponentFormats ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerFilterMinmaxProperties.filterMinmaxImageComponentMapping ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures const & physicalDeviceSamplerYcbcrConversionFeatures ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures const & physicalDeviceScalarBlockLayoutFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM const & physicalDeviceSchedulingControlsFeaturesARM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsFeaturesARM.schedulingControls ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM const & physicalDeviceSchedulingControlsPropertiesARM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSchedulingControlsPropertiesARM.schedulingControlsFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & physicalDeviceSeparateDepthStencilLayoutsFeatures ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT const & physicalDeviceShader64BitIndexingFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShader64BitIndexingFeaturesEXT.shader64BitIndexing ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & physicalDeviceShaderAtomicFloat16VectorFeaturesNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat16VectorFeaturesNV.shaderFloat16VectorAtomics ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & physicalDeviceShaderAtomicFloat2FeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat16AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat32AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderBufferFloat64AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat16AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat32AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderSharedFloat64AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT const & physicalDeviceShaderAtomicFloatFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat32AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderBufferFloat64AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat32AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderSharedFloat64AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features const & physicalDeviceShaderAtomicInt64Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR const & physicalDeviceShaderBfloat16FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16Type ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16DotProduct ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderBfloat16FeaturesKHR.shaderBFloat16CooperativeMatrix ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR const & physicalDeviceShaderClockFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderClockFeaturesKHR.shaderDeviceClock ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & physicalDeviceShaderCoreBuiltinsFeaturesARM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsFeaturesARM.shaderCoreBuiltins ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & physicalDeviceShaderCoreBuiltinsPropertiesARM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreMask ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderCoreCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreBuiltinsPropertiesARM.shaderWarpsPerCore ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD const & physicalDeviceShaderCoreProperties2AMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.shaderCoreFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCoreProperties2AMD.activeComputeUnitCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD const & physicalDeviceShaderCorePropertiesAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderEngineCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.shaderArraysPerEngineCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.computeUnitsPerShaderArray ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.simdPerComputeUnit ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontsPerSimd ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.wavefrontSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprsPerSimd ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minSgprAllocation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxSgprAllocation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.sgprAllocationGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprsPerSimd ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.minVgprAllocation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.maxVgprAllocation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesAMD.vgprAllocationGranularity ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM const & physicalDeviceShaderCorePropertiesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.pixelRate ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.texelRate ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderCorePropertiesARM.fmaRate ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & - physicalDeviceShaderDemoteToHelperInvocationFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDemoteToHelperInvocationFeatures.shaderDemoteToHelperInvocation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures const & physicalDeviceShaderDrawParametersFeatures ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderDrawParametersFeatures.shaderDrawParameters ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & - physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.shaderEarlyAndLateFragmentTests ); - return seed; - } - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX const & physicalDeviceShaderEnqueueFeaturesAMDX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.shaderEnqueue ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueueFeaturesAMDX.shaderMeshEnqueue ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX const & physicalDeviceShaderEnqueuePropertiesAMDX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphDepth ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderOutputNodes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphShaderPayloadCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.executionGraphDispatchAddressAlignment ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphWorkgroupCount[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderEnqueuePropertiesAMDX.maxExecutionGraphWorkgroups ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeatures const & physicalDeviceShaderExpectAssumeFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderExpectAssumeFeatures.shaderExpectAssume ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features const & physicalDeviceShaderFloat16Int8Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat16Int8Features.shaderInt8 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat8FeaturesEXT const & physicalDeviceShaderFloat8FeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.shaderFloat8 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloat8FeaturesEXT.shaderFloat8CooperativeMatrix ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2Features const & physicalDeviceShaderFloatControls2Features ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFloatControls2Features.shaderFloatControls2 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR const & physicalDeviceShaderFmaFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderFmaFeaturesKHR.shaderFmaFloat64 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & physicalDeviceShaderImageAtomicInt64FeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV const & physicalDeviceShaderImageFootprintFeaturesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderImageFootprintFeaturesNV.imageFootprint ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures const & physicalDeviceShaderIntegerDotProductFeatures ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductFeatures.shaderIntegerDotProduct ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties const & physicalDeviceShaderIntegerDotProductProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct8BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct16BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct32BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProduct64BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, - physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerDotProductProperties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & physicalDeviceShaderIntegerFunctions2FeaturesINTEL ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderIntegerFunctions2FeaturesINTEL.shaderIntegerFunctions2 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT const & physicalDeviceShaderLongVectorFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorFeaturesEXT.longVector ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT const & physicalDeviceShaderLongVectorPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderLongVectorPropertiesEXT.maxVectorComponents ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & physicalDeviceShaderMaximalReconvergenceFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderMaximalReconvergenceFeaturesKHR.shaderMaximalReconvergence ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & physicalDeviceShaderModuleIdentifierFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierFeaturesEXT.shaderModuleIdentifier ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & physicalDeviceShaderModuleIdentifierPropertiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.pNext ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderModuleIdentifierPropertiesEXT.shaderModuleIdentifierAlgorithmUUID[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT const & physicalDeviceShaderObjectFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.shaderObject ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT const & physicalDeviceShaderObjectPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.pNext ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryUUID[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryVersion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR const & physicalDeviceShaderQuadControlFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderQuadControlFeaturesKHR.shaderQuadControl ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & - physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.shaderRelaxedExtendedInstruction ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & physicalDeviceShaderReplicatedCompositesFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderReplicatedCompositesFeaturesEXT.shaderReplicatedComposites ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV const & physicalDeviceShaderSMBuiltinsFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsFeaturesNV.shaderSMBuiltins ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV const & physicalDeviceShaderSMBuiltinsPropertiesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderSMCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSMBuiltinsPropertiesNV.shaderWarpsPerSM ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & physicalDeviceShaderSubgroupExtendedTypesFeatures ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & physicalDeviceShaderSubgroupPartitionedFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupPartitionedFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupPartitionedFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupPartitionedFeaturesEXT.shaderSubgroupPartitioned ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeatures const & physicalDeviceShaderSubgroupRotateFeatures ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.shaderSubgroupRotate ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupRotateFeatures.shaderSubgroupRotateClustered ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & - physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures const & physicalDeviceShaderTerminateInvocationFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTerminateInvocationFeatures.shaderTerminateInvocation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT const & physicalDeviceShaderTileImageFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageColorReadAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageDepthReadAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageStencilReadAccess ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT const & physicalDeviceShaderTileImagePropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageCoherentReadAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadSampleFromPixelRateInvocation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadFromHelperInvocation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & - physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.shaderUniformBufferUnsizedArray ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR const & physicalDeviceShaderUntypedPointersFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUntypedPointersFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUntypedPointersFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderUntypedPointersFeaturesKHR.shaderUntypedPointers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV const & physicalDeviceShadingRateImageFeaturesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateImage ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImageFeaturesNV.shadingRateCoarseSampleOrder ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV const & physicalDeviceShadingRateImagePropertiesNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateTexelSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRatePaletteSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShadingRateImagePropertiesNV.shadingRateMaxCoarseSamples ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 const & physicalDeviceSparseImageFormatInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.format ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.type ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.samples ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.usage ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSparseImageFormatInfo2.tiling ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties const & physicalDeviceSubgroupProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.subgroupSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedStages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.supportedOperations ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupProperties.quadOperationsInAllStages ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures const & physicalDeviceSubgroupSizeControlFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.subgroupSizeControl ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlFeatures.computeFullSubgroups ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties const & physicalDeviceSubgroupSizeControlProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.minSubgroupSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxSubgroupSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.maxComputeWorkgroupSubgroups ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubgroupSizeControlProperties.requiredSubgroupSizeStages ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & physicalDeviceSubpassMergeFeedbackFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassMergeFeedbackFeaturesEXT.subpassMergeFeedback ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI const & physicalDeviceSubpassShadingFeaturesHUAWEI ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingFeaturesHUAWEI.subpassShading ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI const & physicalDeviceSubpassShadingPropertiesHUAWEI ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSubpassShadingPropertiesHUAWEI.maxSubpassShadingWorkgroupSizeAspectRatio ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR const & physicalDeviceSurfaceInfo2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSurfaceInfo2KHR.surface ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & physicalDeviceSwapchainMaintenance1FeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSwapchainMaintenance1FeaturesKHR.swapchainMaintenance1 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features const & physicalDeviceSynchronization2Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceSynchronization2Features.synchronization2 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorFeaturesARM const & physicalDeviceTensorFeaturesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.tensorNonPacked ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.shaderTensorAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.shaderStorageTensorArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.shaderStorageTensorArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.descriptorBindingStorageTensorUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorFeaturesARM.tensors ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorPropertiesARM const & physicalDeviceTensorPropertiesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorDimensionCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorElements ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxPerDimensionTensorElements ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorStride ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorShaderAccessArrayLength ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxTensorShaderAccessSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxDescriptorSetStorageTensors ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxPerStageDescriptorSetStorageTensors ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxDescriptorSetUpdateAfterBindStorageTensors ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.maxPerStageDescriptorUpdateAfterBindStorageTensors ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.shaderStorageTensorArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTensorPropertiesARM.shaderTensorSupportedStages ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & physicalDeviceTexelBufferAlignmentFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties const & physicalDeviceTexelBufferAlignmentProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetAlignmentBytes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.storageTexelBufferOffsetSingleTexelAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetAlignmentBytes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTexelBufferAlignmentProperties.uniformTexelBufferOffsetSingleTexelAlignment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & physicalDeviceTextureCompressionASTC3DFeaturesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTC3DFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTC3DFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTC3DFeaturesEXT.textureCompressionASTC_3D ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures const & physicalDeviceTextureCompressionASTCHDRFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTextureCompressionASTCHDRFeatures.textureCompressionASTC_HDR ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM const & physicalDeviceTileMemoryHeapFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapFeaturesQCOM.tileMemoryHeap ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM const & physicalDeviceTileMemoryHeapPropertiesQCOM ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.queueSubmitBoundary ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileMemoryHeapPropertiesQCOM.tileBufferTransfers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM const & physicalDeviceTilePropertiesFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTilePropertiesFeaturesQCOM.tileProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM const & physicalDeviceTileShadingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShading ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingFragmentStage ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingColorAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingDepthAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingStencilAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingInputAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingSampledAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingPerTileDraw ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingPerTileDispatch ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingDispatchTile ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingApron ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingAnisotropicApron ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingAtomicOps ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingImageProcessing ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM const & physicalDeviceTileShadingPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.maxApronSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.preferNonCoherent ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.tileGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.maxTileShadingRate ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures const & physicalDeviceTimelineSemaphoreFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties const & physicalDeviceTimelineSemaphoreProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTimelineSemaphoreProperties.maxTimelineSemaphoreValueDifference ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties const & physicalDeviceToolProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.pNext ); - for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.name[i] ); - } - for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.version[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.purposes ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.description[i] ); - } - for ( size_t i = 0; i < VK_MAX_EXTENSION_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceToolProperties.layer[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT const & physicalDeviceTransformFeedbackFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackFeaturesEXT.geometryStreams ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT const & physicalDeviceTransformFeedbackPropertiesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreams ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackStreamDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.maxTransformFeedbackBufferDataStride ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackQueries ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackStreamsLinesTriangles ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackRasterizationStreamSelect ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTransformFeedbackPropertiesEXT.transformFeedbackDraw ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & physicalDeviceUnifiedImageLayoutsFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.unifiedImageLayouts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUnifiedImageLayoutsFeaturesKHR.unifiedImageLayoutsVideo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures const & physicalDeviceUniformBufferStandardLayoutFeatures ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures const & physicalDeviceVariablePointersFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVariablePointersFeatures.variablePointers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeatures const & physicalDeviceVertexAttributeDivisorFeatures ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.vertexAttributeInstanceRateDivisor ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorFeatures.vertexAttributeInstanceRateZeroDivisor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorProperties const & physicalDeviceVertexAttributeDivisorProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.maxVertexAttribDivisor ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorProperties.supportsNonZeroFirstInstance ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & physicalDeviceVertexAttributeDivisorPropertiesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeDivisorPropertiesEXT.maxVertexAttribDivisor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & physicalDeviceVertexAttributeRobustnessFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexAttributeRobustnessFeaturesEXT.vertexAttributeRobustness ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & physicalDeviceVertexInputDynamicStateFeaturesEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoDecodeVP9FeaturesKHR const & physicalDeviceVideoDecodeVP9FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoDecodeVP9FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoDecodeVP9FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoDecodeVP9FeaturesKHR.videoDecodeVP9 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR const & physicalDeviceVideoEncodeAV1FeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeAV1FeaturesKHR.videoEncodeAV1 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & physicalDeviceVideoEncodeIntraRefreshFeaturesKHR ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeIntraRefreshFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeIntraRefreshFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeIntraRefreshFeaturesKHR.videoEncodeIntraRefresh ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR const & videoProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.videoCodecOperation ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaSubsampling ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.lumaBitDepth ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileInfoKHR.chromaBitDepth ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & physicalDeviceVideoEncodeQualityLevelInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.pVideoProfile ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQualityLevelInfoKHR.qualityLevel ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & physicalDeviceVideoEncodeQuantizationMapFeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeQuantizationMapFeaturesKHR.videoEncodeQuantizationMap ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & physicalDeviceVideoEncodeRgbConversionFeaturesVALVE ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoEncodeRgbConversionFeaturesVALVE.videoEncodeRgbConversion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR const & physicalDeviceVideoFormatInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoFormatInfoKHR.imageUsage ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR const & physicalDeviceVideoMaintenance1FeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance1FeaturesKHR.videoMaintenance1 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR const & physicalDeviceVideoMaintenance2FeaturesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVideoMaintenance2FeaturesKHR.videoMaintenance2 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features const & physicalDeviceVulkan11Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageBuffer16BitAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.uniformAndStorageBuffer16BitAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storagePushConstant16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.storageInputOutput16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiview ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewGeometryShader ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.multiviewTessellationShader ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointersStorageBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.variablePointers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.protectedMemory ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.samplerYcbcrConversion ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Features.shaderDrawParameters ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties const & physicalDeviceVulkan11Properties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pNext ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceUUID[i] ); - } - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.driverUUID[i] ); - } - for ( size_t i = 0; i < VK_LUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUID[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceNodeMask ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.deviceLUIDValid ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedStages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupSupportedOperations ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.subgroupQuadOperationsInAllStages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.pointClippingBehavior ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewViewCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMultiviewInstanceIndex ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.protectedNoFault ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxPerSetDescriptors ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan11Properties.maxMemoryAllocationSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features const & physicalDeviceVulkan12Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerMirrorClampToEdge ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.drawIndirectCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storageBuffer8BitAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformAndStorageBuffer8BitAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.storagePushConstant8 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderBufferInt64Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSharedInt64Atomics ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInt8 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageImageArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderInputAttachmentArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayNonUniformIndexing ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingPartiallyBound ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.descriptorBindingVariableDescriptorCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.runtimeDescriptorArray ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.samplerFilterMinmax ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.scalarBlockLayout ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.imagelessFramebuffer ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.uniformBufferStandardLayout ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.separateDepthStencilLayouts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.hostQueryReset ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.timelineSemaphore ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddress ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressCaptureReplay ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.bufferDeviceAddressMultiDevice ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModel ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.vulkanMemoryModelAvailabilityVisibilityChains ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputViewportIndex ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.shaderOutputLayer ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Features.subgroupBroadcastDynamicId ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties const & physicalDeviceVulkan12Properties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverID ); - for ( size_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverName[i] ); - } - for ( size_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.driverInfo[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.conformanceVersion ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.denormBehaviorIndependence ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.roundingModeIndependence ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSignedZeroInfNanPreserveFloat64 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormPreserveFloat64 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderDenormFlushToZeroFloat64 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTEFloat64 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat16 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat32 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderRoundingModeRTZFloat64 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxUpdateAfterBindDescriptorsInAllPools ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderUniformBufferArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderSampledImageArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageBufferArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderStorageImageArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.shaderInputAttachmentArrayNonUniformIndexingNative ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.robustBufferAccessUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.quadDivergentImplicitLod ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSamplers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindSampledImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindStorageImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageDescriptorUpdateAfterBindInputAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxPerStageUpdateAfterBindResources ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSamplers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindSampledImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindStorageImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxDescriptorSetUpdateAfterBindInputAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedDepthResolveModes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.supportedStencilResolveModes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolveNone ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.independentResolve ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxSingleComponentFormats ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.filterMinmaxImageComponentMapping ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.maxTimelineSemaphoreValueDifference ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan12Properties.framebufferIntegerColorSampleCounts ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features const & physicalDeviceVulkan13Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.robustImageAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.inlineUniformBlock ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.pipelineCreationCacheControl ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.privateData ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderTerminateInvocation ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.subgroupSizeControl ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.computeFullSubgroups ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.synchronization2 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.textureCompressionASTC_HDR ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.dynamicRendering ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.shaderIntegerDotProduct ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Features.maintenance4 ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties const & physicalDeviceVulkan13Properties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.minSubgroupSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxSubgroupSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxComputeWorkgroupSubgroups ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.requiredSubgroupSizeStages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformBlockSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorInlineUniformBlocks ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetInlineUniformBlocks ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxInlineUniformTotalSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct8BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct4x8BitPackedMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct16BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct32BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProduct64BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitSignedAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetAlignmentBytes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.storageTexelBufferOffsetSingleTexelAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetAlignmentBytes ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.uniformTexelBufferOffsetSingleTexelAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan13Properties.maxBufferSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Features const & physicalDeviceVulkan14Features ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.globalPriorityQuery ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderSubgroupRotate ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderSubgroupRotateClustered ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderFloatControls2 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.shaderExpectAssume ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.rectangularLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.bresenhamLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.smoothLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledRectangularLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledBresenhamLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.stippledSmoothLines ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.vertexAttributeInstanceRateDivisor ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.vertexAttributeInstanceRateZeroDivisor ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.indexTypeUint8 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.dynamicRenderingLocalRead ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.maintenance5 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.maintenance6 ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pipelineProtectedAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pipelineRobustness ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.hostImageCopy ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Features.pushDescriptor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Properties const & physicalDeviceVulkan14Properties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.lineSubPixelPrecisionBits ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxVertexAttribDivisor ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.supportsNonZeroFirstInstance ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxPushDescriptors ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.dynamicRenderingLocalReadDepthStencilAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.dynamicRenderingLocalReadMultisampledAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.earlyFragmentMultisampleCoverageAfterSampleCounting ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.earlyFragmentSampleMaskTestBeforeSampleCounting ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.depthStencilSwizzleOneSupport ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.polygonModePointSize ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.nonStrictSinglePixelWideLinesUseParallelogram ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.nonStrictWideLinesUseParallelogram ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.blockTexelViewCompatibleMultipleLayers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.maxCombinedImageSamplerDescriptorCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.fragmentShadingRateClampCombinerInputs ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessStorageBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessUniformBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessVertexInputs ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.defaultRobustnessImages ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.copySrcLayoutCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pCopySrcLayouts ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.copyDstLayoutCount ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.pCopyDstLayouts ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.optimalTilingLayoutUUID[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkan14Properties.identicalMemoryTypeRequirements ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures const & physicalDeviceVulkanMemoryModelFeatures ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelDeviceScope ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModelAvailabilityVisibilityChains ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & - physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & physicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM const & physicalDeviceYcbcrDegammaFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrDegammaFeaturesQCOM.ycbcrDegamma ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT const & physicalDeviceYcbcrImageArraysFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.zeroInitializeDeviceMemory ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & physicalDeviceZeroInitializeWorkgroupMemoryFeatures ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.sType ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceZeroInitializeWorkgroupMemoryFeatures.shaderZeroInitializeWorkgroupMemory ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR const & pipelineBinaryKeyKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.keySize ); - for ( size_t i = 0; i < VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeyKHR.key[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR const & pipelineBinaryDataKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataKHR.dataSize ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataKHR.pData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR const & pipelineBinaryKeysAndDataKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.binaryCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.pPipelineBinaryKeys ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryKeysAndDataKHR.pPipelineBinaryData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR const & pipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateInfoKHR.pNext ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR const & pipelineBinaryCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pKeysAndDataInfo ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pipeline ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryCreateInfoKHR.pPipelineCreateInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR const & pipelineBinaryDataInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryDataInfoKHR.pipelineBinary ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR const & pipelineBinaryHandlesInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pipelineBinaryCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryHandlesInfoKHR.pPipelineBinaries ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR const & pipelineBinaryInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.binaryCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineBinaryInfoKHR.pPipelineBinaries ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo const & pipelineCacheCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.initialDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheCreateInfo.pInitialData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM const & pipelineCacheHeaderVersionDataGraphQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerSize ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.headerVersion ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.cacheVersion ); - for ( size_t i = 0; i < VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionDataGraphQCOM.toolchainVersion[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne const & pipelineCacheHeaderVersionOne ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerSize ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.headerVersion ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.vendorID ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.deviceID ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, pipelineCacheHeaderVersionOne.pipelineCacheUUID[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT const & pipelineColorBlendAdvancedStateCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.srcPremultiplied ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.dstPremultiplied ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorBlendAdvancedStateCreateInfoEXT.blendOverlap ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT const & pipelineColorWriteCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineColorWriteCreateInfoEXT.pColorWriteEnables ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD const & pipelineCompilerControlCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCompilerControlCreateInfoAMD.compilerControlFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV const & pipelineCoverageModulationStateCreateInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationMode ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.coverageModulationTableCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageModulationStateCreateInfoNV.pCoverageModulationTable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV const & pipelineCoverageReductionStateCreateInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageReductionStateCreateInfoNV.coverageReductionMode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV const & pipelineCoverageToColorStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCoverageToColorStateCreateInfoNV.coverageToColorLocation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfo const & pipelineCreateFlags2CreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreateFlags2CreateInfo.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedback const & pipelineCreationFeedback ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedback.duration ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo const & pipelineCreationFeedbackCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineCreationFeedback ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pipelineStageCreationFeedbackCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineCreationFeedbackCreateInfo.pPipelineStageCreationFeedbacks ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT const & pipelineDiscardRectangleStateCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleMode ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.discardRectangleCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR const & pipelineExecutableInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.pipeline ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInfoKHR.executableIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR const & pipelineExecutableInternalRepresentationKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pNext ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.name[i] ); - } - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.description[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.isText ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.dataSize ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutableInternalRepresentationKHR.pData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR const & pipelineExecutablePropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.stages ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.name[i] ); - } - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.description[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, pipelineExecutablePropertiesKHR.subgroupSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE const & pipelineFragmentDensityMapLayeredCreateInfoVALVE ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentDensityMapLayeredCreateInfoVALVE.maxFragmentDensityMapLayers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV const & pipelineFragmentShadingRateEnumStateCreateInfoNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRateType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.shadingRate ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateEnumStateCreateInfoNV.combinerOps[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR const & pipelineFragmentShadingRateStateCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.fragmentSize ); - for ( size_t i = 0; i < 2; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, pipelineFragmentShadingRateStateCreateInfoKHR.combinerOps[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV const & pipelineIndirectDeviceAddressInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineIndirectDeviceAddressInfoNV.pipeline ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineInfoKHR const & pipelineInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineInfoKHR.pipeline ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo const & pipelineLayoutCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.setLayoutCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pSetLayouts ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pushConstantRangeCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineLayoutCreateInfo.pPushConstantRanges ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT const & pipelinePropertiesIdentifierEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pNext ); - for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, pipelinePropertiesIdentifierEXT.pipelineIdentifier[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT const & pipelineRasterizationConservativeStateCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.conservativeRasterizationMode ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationConservativeStateCreateInfoEXT.extraPrimitiveOverestimationSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT const & pipelineRasterizationDepthClipStateCreateInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationDepthClipStateCreateInfoEXT.depthClipEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfo const & pipelineRasterizationLineStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineRasterizationMode ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.stippledLineEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineStippleFactor ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationLineStateCreateInfo.lineStipplePattern ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT const & - pipelineRasterizationProvokingVertexStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationProvokingVertexStateCreateInfoEXT.provokingVertexMode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD const & pipelineRasterizationStateRasterizationOrderAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateRasterizationOrderAMD.rasterizationOrder ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT const & pipelineRasterizationStateStreamCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRasterizationStateStreamCreateInfoEXT.rasterizationStream ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo const & pipelineRenderingCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.viewMask ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.pColorAttachmentFormats ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.depthAttachmentFormat ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRenderingCreateInfo.stencilAttachmentFormat ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV const & pipelineRepresentativeFragmentTestStateCreateInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRepresentativeFragmentTestStateCreateInfoNV.representativeFragmentTestEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfo const & pipelineRobustnessCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.storageBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.uniformBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.vertexInputs ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineRobustnessCreateInfo.images ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT const & pipelineSampleLocationsStateCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineSampleLocationsStateCreateInfoEXT.sampleLocationsInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT const & pipelineShaderStageModuleIdentifierCreateInfoEXT ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.identifierSize ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageModuleIdentifierCreateInfoEXT.pIdentifier ); - return seed; - } - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX const & pipelineShaderStageNodeCreateInfoAMDX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.pNext ); - for ( const char * p = pipelineShaderStageNodeCreateInfoAMDX.pName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageNodeCreateInfoAMDX.index ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo const & pipelineShaderStageRequiredSubgroupSizeCreateInfo ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineShaderStageRequiredSubgroupSizeCreateInfo.requiredSubgroupSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo const & pipelineTessellationDomainOriginStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineTessellationDomainOriginStateCreateInfo.domainOrigin ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescription const & vertexInputBindingDivisorDescription ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescription.binding ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDivisorDescription.divisor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfo const & pipelineVertexInputDivisorStateCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.vertexBindingDivisorCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineVertexInputDivisorStateCreateInfo.pVertexBindingDivisors ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV const & pipelineViewportCoarseSampleOrderStateCreateInfoNV ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.sampleOrderType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.customSampleOrderCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT const & pipelineViewportDepthClampControlCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.depthClampMode ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClampControlCreateInfoEXT.pDepthClampRange ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT const & pipelineViewportDepthClipControlCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportDepthClipControlCreateInfoEXT.negativeOneToOne ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV const & pipelineViewportExclusiveScissorStateCreateInfoNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.exclusiveScissorCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV const & shadingRatePaletteNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.shadingRatePaletteEntryCount ); - VULKAN_HPP_HASH_COMBINE( seed, shadingRatePaletteNV.pShadingRatePaletteEntries ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV const & pipelineViewportShadingRateImageStateCreateInfoNV ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.shadingRateImageEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.viewportCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV const & viewportSwizzleNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.x ); - VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.y ); - VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.z ); - VULKAN_HPP_HASH_COMBINE( seed, viewportSwizzleNV.w ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV const & pipelineViewportSwizzleStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.viewportCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ViewportWScalingNV const & viewportWScalingNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.xcoeff ); - VULKAN_HPP_HASH_COMBINE( seed, viewportWScalingNV.ycoeff ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV const & pipelineViewportWScalingStateCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportWScalingEnable ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.viewportCount ); - VULKAN_HPP_HASH_COMBINE( seed, pipelineViewportWScalingStateCreateInfoNV.pViewportWScalings ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_GGP ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP const & presentFrameTokenGGP ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.sType ); - VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, presentFrameTokenGGP.frameToken ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_GGP*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentId2KHR const & presentId2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( seed, presentId2KHR.pPresentIds ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentIdKHR const & presentIdKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( seed, presentIdKHR.pPresentIds ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentInfoKHR const & presentInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.waitSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pWaitSemaphores ); - VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pSwapchains ); - VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pImageIndices ); - VULKAN_HPP_HASH_COMBINE( seed, presentInfoKHR.pResults ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RectLayerKHR const & rectLayerKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.offset ); - VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.extent ); - VULKAN_HPP_HASH_COMBINE( seed, rectLayerKHR.layer ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionKHR const & presentRegionKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.rectangleCount ); - VULKAN_HPP_HASH_COMBINE( seed, presentRegionKHR.pRectangles ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentRegionsKHR const & presentRegionsKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( seed, presentRegionsKHR.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE const & presentTimeGOOGLE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.presentID ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimeGOOGLE.desiredPresentTime ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE const & presentTimesInfoGOOGLE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.sType ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimesInfoGOOGLE.pTimes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimingInfoEXT const & presentTimingInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.targetTime ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.timeDomainId ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.presentStageQueries ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingInfoEXT.targetTimeDomainPresentStage ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimingSurfaceCapabilitiesEXT const & presentTimingSurfaceCapabilitiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentTimingSupported ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentAtAbsoluteTimeSupported ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentAtRelativeTimeSupported ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingSurfaceCapabilitiesEXT.presentStageQueries ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentTimingsInfoEXT const & presentTimingsInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( seed, presentTimingsInfoEXT.pTimingInfos ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PresentWait2InfoKHR const & presentWait2InfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.presentId ); - VULKAN_HPP_HASH_COMBINE( seed, presentWait2InfoKHR.timeout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo const & privateDataSlotCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, privateDataSlotCreateInfo.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo const & protectedSubmitInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, protectedSubmitInfo.protectedSubmit ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV const & pushConstantBankInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pushConstantBankInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pushConstantBankInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pushConstantBankInfoNV.bank ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PushConstantsInfo const & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.layout ); - VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.stageFlags ); - VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.offset ); - VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.size ); - VULKAN_HPP_HASH_COMBINE( seed, pushConstantsInfo.pValues ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDataInfoEXT const & pushDataInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.offset ); - VULKAN_HPP_HASH_COMBINE( seed, pushDataInfoEXT.data ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSet const & writeDescriptorSet ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.sType ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstSet ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstBinding ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.dstArrayElement ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorCount ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.descriptorType ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pImageInfo ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pBufferInfo ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSet.pTexelBufferView ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo const & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.stageFlags ); - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.layout ); - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.set ); - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.descriptorWriteCount ); - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetInfo.pDescriptorWrites ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo const & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.descriptorUpdateTemplate ); - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.layout ); - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.set ); - VULKAN_HPP_HASH_COMBINE( seed, pushDescriptorSetWithTemplateInfo.pData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV const & queryLowLatencySupportNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queryLowLatencySupportNV.pQueriedLowLatencyData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo const & queryPoolCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryType ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.queryCount ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolCreateInfo.pipelineStatistics ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR const & queryPoolPerformanceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.queueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.counterIndexCount ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceCreateInfoKHR.pCounterIndices ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL const & queryPoolPerformanceQueryCreateInfoINTEL ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolPerformanceQueryCreateInfoINTEL.performanceCountersSampling ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR const & queryPoolVideoEncodeFeedbackCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queryPoolVideoEncodeFeedbackCreateInfoKHR.encodeFeedbackFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV const & queueFamilyCheckpointProperties2NV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointProperties2NV.checkpointExecutionStageMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV const & queueFamilyCheckpointPropertiesNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyCheckpointPropertiesNV.checkpointExecutionStageMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphProcessingEnginePropertiesARM const & queueFamilyDataGraphProcessingEnginePropertiesARM ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.foreignSemaphoreHandleTypes ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphProcessingEnginePropertiesARM.foreignMemoryHandleTypes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphPropertiesARM const & queueFamilyDataGraphPropertiesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.engine ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyDataGraphPropertiesARM.operation ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityProperties const & queueFamilyGlobalPriorityProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.priorityCount ); - for ( size_t i = 0; i < VK_MAX_GLOBAL_PRIORITY_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyGlobalPriorityProperties.priorities[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::QueueFamilyOwnershipTransferPropertiesKHR const & queueFamilyOwnershipTransferPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOwnershipTransferPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOwnershipTransferPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyOwnershipTransferPropertiesKHR.optimalImageTransferToQueueFamilies ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties const & queueFamilyProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueFlags ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.queueCount ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.timestampValidBits ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties.minImageTransferGranularity ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 const & queueFamilyProperties2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyProperties2.queueFamilyProperties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR const & queueFamilyQueryResultStatusPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyQueryResultStatusPropertiesKHR.queryResultStatusSupport ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR const & queueFamilyVideoPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, queueFamilyVideoPropertiesKHR.videoCodecOperations ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & - rayTracingPipelineClusterAccelerationStructureCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineClusterAccelerationStructureCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineClusterAccelerationStructureCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineClusterAccelerationStructureCreateInfoNV.allowClusterAccelerationStructure ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR const & rayTracingShaderGroupCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.type ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.generalShader ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.closestHitShader ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.anyHitShader ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.intersectionShader ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoKHR.pShaderGroupCaptureReplayHandle ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR const & rayTracingPipelineInterfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayPayloadSize ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineInterfaceCreateInfoKHR.maxPipelineRayHitAttributeSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR const & rayTracingPipelineCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.stageCount ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pStages ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.groupCount ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pGroups ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.maxPipelineRayRecursionDepth ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInfo ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pLibraryInterface ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.pDynamicState ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.layout ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineHandle ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoKHR.basePipelineIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV const & rayTracingShaderGroupCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.type ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.generalShader ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.closestHitShader ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.anyHitShader ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingShaderGroupCreateInfoNV.intersectionShader ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV const & rayTracingPipelineCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.flags ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.stageCount ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pStages ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.groupCount ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.pGroups ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.maxRecursionDepth ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.layout ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineHandle ); - VULKAN_HPP_HASH_COMBINE( seed, rayTracingPipelineCreateInfoNV.basePipelineIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE const & refreshCycleDurationGOOGLE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, refreshCycleDurationGOOGLE.refreshDuration ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR const & releaseCapturedPipelineDataInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, releaseCapturedPipelineDataInfoKHR.pipeline ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoKHR const & releaseSwapchainImagesInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.swapchain ); - VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.imageIndexCount ); - VULKAN_HPP_HASH_COMBINE( seed, releaseSwapchainImagesInfoKHR.pImageIndices ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo const & renderPassAttachmentBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassAttachmentBeginInfo.pAttachments ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo const & renderPassBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderPass ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.framebuffer ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.renderArea ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.clearValueCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassBeginInfo.pClearValues ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription const & subpassDescription ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.flags ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.inputAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pInputAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pColorAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pResolveAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pDepthStencilAttachment ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.preserveAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription.pPreserveAttachments ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency const & subpassDependency ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcSubpass ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstSubpass ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency.dependencyFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo const & renderPassCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.subpassCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pSubpasses ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.dependencyCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo.pDependencies ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDescription2 const & subpassDescription2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.flags ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pipelineBindPoint ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.viewMask ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.inputAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pInputAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pColorAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pResolveAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pDepthStencilAttachment ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.preserveAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescription2.pPreserveAttachments ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassDependency2 const & subpassDependency2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcSubpass ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstSubpass ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.dependencyFlags ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDependency2.viewOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 const & renderPassCreateInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.flags ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.attachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.subpassCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pSubpasses ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.dependencyCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pDependencies ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.correlatedViewMaskCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreateInfo2.pCorrelatedViewMasks ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT const & renderPassCreationControlEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationControlEXT.disallowMerging ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT const & renderPassCreationFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackInfoEXT.postMergeSubpassCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT const & renderPassCreationFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassCreationFeedbackCreateInfoEXT.pRenderPassFeedback ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT const & renderPassFragmentDensityMapCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapCreateInfoEXT.fragmentDensityMapAttachment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT const & renderPassFragmentDensityMapOffsetEndInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.fragmentDensityOffsetCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassFragmentDensityMapOffsetEndInfoEXT.pFragmentDensityOffsets ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo const & renderPassInputAttachmentAspectCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.aspectReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassInputAttachmentAspectCreateInfo.pAspectReferences ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo const & renderPassMultiviewCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.subpassCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewMasks ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.dependencyCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pViewOffsets ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.correlationMaskCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassMultiviewCreateInfo.pCorrelationMasks ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM const & renderPassPerformanceCountersByRegionBeginInfoARM ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.counterAddressCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pCounterAddresses ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.serializeRegions ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.counterIndexCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassPerformanceCountersByRegionBeginInfoARM.pCounterIndices ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT const & subpassSampleLocationsEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.subpassIndex ); - VULKAN_HPP_HASH_COMBINE( seed, subpassSampleLocationsEXT.sampleLocationsInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT const & renderPassSampleLocationsBeginInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.attachmentInitialSampleLocationsCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.postSubpassSampleLocationsCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM const & renderPassStripeInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeInfoARM.stripeArea ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM const & renderPassStripeBeginInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.stripeInfoCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeBeginInfoARM.pStripeInfos ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo const & semaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.semaphore ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.value ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.stageMask ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreSubmitInfo.deviceIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM const & renderPassStripeSubmitInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.stripeSemaphoreInfoCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassStripeSubmitInfoARM.pStripeSemaphoreInfos ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT const & renderPassSubpassFeedbackInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.subpassMergeStatus ); - for ( size_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.description[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackInfoEXT.postMergeIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT const & renderPassSubpassFeedbackCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassSubpassFeedbackCreateInfoEXT.pSubpassFeedback ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM const & renderPassTileShadingCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.flags ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.tileApronSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM const & renderPassTransformBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderPassTransformBeginInfoQCOM.transform ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAreaInfo const & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.viewMask ); - VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.pColorAttachmentFormats ); - VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.depthAttachmentFormat ); - VULKAN_HPP_HASH_COMBINE( seed, renderingAreaInfo.stencilAttachmentFormat ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR const & renderingAttachmentFlagsInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentFlagsInfoKHR.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo const & renderingAttachmentLocationInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderingAttachmentLocationInfo.pColorAttachmentLocations ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR const & renderingEndInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderingEndInfoKHR.pNext ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT const & renderingFragmentDensityMapAttachmentInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageView ); - VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentDensityMapAttachmentInfoEXT.imageLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR const & renderingFragmentShadingRateAttachmentInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageView ); - VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.imageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, renderingFragmentShadingRateAttachmentInfoKHR.shadingRateAttachmentTexelSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInfo const & renderingInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.renderArea ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.layerCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.viewMask ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pColorAttachments ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pDepthAttachment ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInfo.pStencilAttachment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo const & renderingInputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.colorAttachmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pColorAttachmentInputIndices ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pDepthInputAttachmentIndex ); - VULKAN_HPP_HASH_COMBINE( seed, renderingInputAttachmentIndexInfo.pStencilInputAttachmentIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 const & resolveImageInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImage ); - VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.srcImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImage ); - VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.dstImageLayout ); - VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.regionCount ); - VULKAN_HPP_HASH_COMBINE( seed, resolveImageInfo2.pRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR const & resolveImageModeInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.resolveMode ); - VULKAN_HPP_HASH_COMBINE( seed, resolveImageModeInfoKHR.stencilResolveMode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT const & texelBufferDescriptorInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.format ); - VULKAN_HPP_HASH_COMBINE( seed, texelBufferDescriptorInfoEXT.addressRange ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM const & tensorViewCreateInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.flags ); - VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.tensor ); - VULKAN_HPP_HASH_COMBINE( seed, tensorViewCreateInfoARM.format ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM const & samplerBlockMatchWindowCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowExtent ); - VULKAN_HPP_HASH_COMBINE( seed, samplerBlockMatchWindowCreateInfoQCOM.windowCompareMode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT const & samplerBorderColorComponentMappingCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.components ); - VULKAN_HPP_HASH_COMBINE( seed, samplerBorderColorComponentMappingCreateInfoEXT.srgb ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT const & samplerCaptureDescriptorDataInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCaptureDescriptorDataInfoEXT.sampler ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM const & samplerCubicWeightsCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCubicWeightsCreateInfoQCOM.cubicWeights ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT const & samplerCustomBorderColorIndexCreateInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, samplerCustomBorderColorIndexCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCustomBorderColorIndexCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, samplerCustomBorderColorIndexCreateInfoEXT.index ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo const & samplerReductionModeCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, samplerReductionModeCreateInfo.reductionMode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo const & samplerYcbcrConversionCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.format ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrModel ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.ycbcrRange ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.components ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.xChromaOffset ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.yChromaOffset ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.chromaFilter ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionCreateInfo.forceExplicitReconstruction ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties const & samplerYcbcrConversionImageFormatProperties ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.sType ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionImageFormatProperties.combinedImageSamplerDescriptorCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo const & samplerYcbcrConversionInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionInfo.conversion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ) - const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableYDegamma ); - VULKAN_HPP_HASH_COMBINE( seed, samplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.enableCbCrDegamma ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX const & screenBufferFormatPropertiesQNX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.format ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.externalFormat ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.screenUsage ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.formatFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.samplerYcbcrConversionComponents ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrModel ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYcbcrRange ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedXChromaOffset ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferFormatPropertiesQNX.suggestedYChromaOffset ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX const & screenBufferPropertiesQNX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.allocationSize ); - VULKAN_HPP_HASH_COMBINE( seed, screenBufferPropertiesQNX.memoryTypeBits ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX const & screenSurfaceCreateInfoQNX ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.sType ); - VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.flags ); - VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.context ); - VULKAN_HPP_HASH_COMBINE( seed, screenSurfaceCreateInfoQNX.window ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo const & semaphoreCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreCreateInfo.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR const & semaphoreGetFdInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.semaphore ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetFdInfoKHR.handleType ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR const & semaphoreGetWin32HandleInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.semaphore ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetWin32HandleInfoKHR.handleType ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA const & semaphoreGetZirconHandleInfoFUCHSIA ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.sType ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.semaphore ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreGetZirconHandleInfoFUCHSIA.handleType ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo const & semaphoreSignalInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.semaphore ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreSignalInfo.value ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo const & semaphoreTypeCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.semaphoreType ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreTypeCreateInfo.initialValue ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo const & semaphoreWaitInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.semaphoreCount ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pSemaphores ); - VULKAN_HPP_HASH_COMBINE( seed, semaphoreWaitInfo.pValues ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT const & setDescriptorBufferOffsetsInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.stageFlags ); - VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.layout ); - VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.firstSet ); - VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.setCount ); - VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pBufferIndices ); - VULKAN_HPP_HASH_COMBINE( seed, setDescriptorBufferOffsetsInfoEXT.pOffsets ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV const & setLatencyMarkerInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.presentID ); - VULKAN_HPP_HASH_COMBINE( seed, setLatencyMarkerInfoNV.marker ); - return seed; - } - }; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SetPresentConfigNV const & setPresentConfigNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.numFramesPerBatch ); - VULKAN_HPP_HASH_COMBINE( seed, setPresentConfigNV.presentConfigFeedback ); - return seed; - } - }; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV const & setStateFlagsIndirectCommandNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, setStateFlagsIndirectCommandNV.data ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & shaderCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.stage ); - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.nextStage ); - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeType ); - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeSize ); - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pCode ); - for ( const char * p = shaderCreateInfoEXT.pName; *p != '\0'; ++p ) - { - VULKAN_HPP_HASH_COMBINE( seed, *p ); - } - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.setLayoutCount ); - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSetLayouts ); - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pushConstantRangeCount ); - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pPushConstantRanges ); - VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSpecializationInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT const & shaderDescriptorSetAndBindingMappingInfoEXT ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.mappingCount ); - VULKAN_HPP_HASH_COMBINE( seed, shaderDescriptorSetAndBindingMappingInfoEXT.pMappings ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo const & shaderModuleCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.flags ); - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.codeSize ); - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleCreateInfo.pCode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT const & shaderModuleIdentifierEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifierSize ); - for ( size_t i = 0; i < VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleIdentifierEXT.identifier[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT const & shaderModuleValidationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, shaderModuleValidationCacheCreateInfoEXT.validationCache ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD const & shaderResourceUsageAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedVgprs ); - VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.numUsedSgprs ); - VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsSizePerLocalWorkGroup ); - VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.ldsUsageSizeInBytes ); - VULKAN_HPP_HASH_COMBINE( seed, shaderResourceUsageAMD.scratchMemUsageInBytes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD const & shaderStatisticsInfoAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.shaderStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.resourceUsage ); - VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalVgprs ); - VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numPhysicalSgprs ); - VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableVgprs ); - VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.numAvailableSgprs ); - for ( size_t i = 0; i < 3; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, shaderStatisticsInfoAMD.computeWorkGroupSize[i] ); - } - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR const & sharedPresentSurfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, sharedPresentSurfaceCapabilitiesKHR.sharedPresentSupportedUsageFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties const & sparseImageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.aspectMask ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.imageGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 const & sparseImageFormatProperties2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageFormatProperties2.properties ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements const & sparseImageMemoryRequirements ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.formatProperties ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailFirstLod ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailSize ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailOffset ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements.imageMipTailStride ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 const & sparseImageMemoryRequirements2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, sparseImageMemoryRequirements2.memoryRequirements ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_GGP ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP const & streamDescriptorSurfaceCreateInfoGGP ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.sType ); - VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.flags ); - VULKAN_HPP_HASH_COMBINE( seed, streamDescriptorSurfaceCreateInfoGGP.streamDescriptor ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_GGP*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo const & submitInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, submitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo.waitSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitSemaphores ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pWaitDstStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo.commandBufferCount ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pCommandBuffers ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo.signalSemaphoreCount ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo.pSignalSemaphores ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubmitInfo2 const & submitInfo2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.flags ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.waitSemaphoreInfoCount ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pWaitSemaphoreInfos ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.commandBufferInfoCount ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pCommandBufferInfos ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.signalSemaphoreInfoCount ); - VULKAN_HPP_HASH_COMBINE( seed, submitInfo2.pSignalSemaphoreInfos ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassBeginInfo const & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, subpassBeginInfo.contents ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve const & subpassDescriptionDepthStencilResolve ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.sType ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.depthResolveMode ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.stencilResolveMode ); - VULKAN_HPP_HASH_COMBINE( seed, subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassEndInfo const & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, subpassEndInfo.pNext ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT const & subpassResolvePerformanceQueryEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, subpassResolvePerformanceQueryEXT.optimal ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI const & subpassShadingPipelineCreateInfoHUAWEI ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.sType ); - VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.renderPass ); - VULKAN_HPP_HASH_COMBINE( seed, subpassShadingPipelineCreateInfoHUAWEI.subpass ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySize const & subresourceHostMemcpySize ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.sType ); - VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, subresourceHostMemcpySize.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubresourceLayout2 const & subresourceLayout2 ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.sType ); - VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, subresourceLayout2.subresourceLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT const & subsampledImageFormatPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, subsampledImageFormatPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, subsampledImageFormatPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, subsampledImageFormatPropertiesEXT.subsampledImageDescriptorCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT const & surfaceCapabilities2EXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageCount ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageCount ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentExtent ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.minImageExtent ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageExtent ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.maxImageArrayLayers ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedTransforms ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.currentTransform ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedCompositeAlpha ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedUsageFlags ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2EXT.supportedSurfaceCounters ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR const & surfaceCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageCount ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageCount ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentExtent ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.minImageExtent ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageExtent ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.maxImageArrayLayers ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedTransforms ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.currentTransform ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedCompositeAlpha ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesKHR.supportedUsageFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR const & surfaceCapabilities2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilities2KHR.surfaceCapabilities ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT const & surfaceCapabilitiesFullScreenExclusiveEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesFullScreenExclusiveEXT.fullScreenExclusiveSupported ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV const & surfaceCapabilitiesPresentBarrierNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentBarrierNV.presentBarrierSupported ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentId2KHR const & surfaceCapabilitiesPresentId2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentId2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentId2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentId2KHR.presentId2Supported ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentWait2KHR const & surfaceCapabilitiesPresentWait2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentWait2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentWait2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCapabilitiesPresentWait2KHR.presentWait2Supported ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_OHOS ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS const & surfaceCreateInfoOHOS ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.flags ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceCreateInfoOHOS.window ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_OHOS*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR const & surfaceFormatKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.format ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceFormatKHR.colorSpace ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR const & surfaceFormat2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceFormat2KHR.surfaceFormat ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT const & surfaceFullScreenExclusiveInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveInfoEXT.fullScreenExclusive ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT const & surfaceFullScreenExclusiveWin32InfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceFullScreenExclusiveWin32InfoEXT.hmonitor ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityKHR const & surfacePresentModeCompatibilityKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.presentModeCount ); - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeCompatibilityKHR.pPresentModes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentModeKHR const & surfacePresentModeKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentModeKHR.presentMode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesKHR const & surfacePresentScalingCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.supportedPresentScaling ); - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.supportedPresentGravityX ); - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.supportedPresentGravityY ); - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.minScaledImageExtent ); - VULKAN_HPP_HASH_COMBINE( seed, surfacePresentScalingCapabilitiesKHR.maxScaledImageExtent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR const & surfaceProtectedCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, surfaceProtectedCapabilitiesKHR.supportsProtected ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCalibratedTimestampInfoEXT const & swapchainCalibratedTimestampInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.swapchain ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.presentStage ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCalibratedTimestampInfoEXT.timeDomainId ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT const & swapchainCounterCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCounterCreateInfoEXT.surfaceCounters ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR const & swapchainCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.surface ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.minImageCount ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageFormat ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageColorSpace ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageExtent ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageArrayLayers ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageUsage ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.imageSharingMode ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.queueFamilyIndexCount ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.pQueueFamilyIndices ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.preTransform ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.compositeAlpha ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.presentMode ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.clipped ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainCreateInfoKHR.oldSwapchain ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD const & swapchainDisplayNativeHdrCreateInfoAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainDisplayNativeHdrCreateInfoAMD.localDimmingEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV const & swapchainLatencyCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainLatencyCreateInfoNV.latencyModeEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV const & swapchainPresentBarrierCreateInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentBarrierCreateInfoNV.presentBarrierEnable ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoKHR const & swapchainPresentFenceInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentFenceInfoKHR.pFences ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoKHR const & swapchainPresentModeInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.swapchainCount ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModeInfoKHR.pPresentModes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoKHR const & swapchainPresentModesCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.presentModeCount ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentModesCreateInfoKHR.pPresentModes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoKHR const & swapchainPresentScalingCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.scalingBehavior ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.presentGravityX ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainPresentScalingCreateInfoKHR.presentGravityY ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainTimeDomainPropertiesEXT const & swapchainTimeDomainPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.timeDomainCount ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.pTimeDomains ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainTimeDomainPropertiesEXT.pTimeDomainIds ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::SwapchainTimingPropertiesEXT const & swapchainTimingPropertiesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.refreshDuration ); - VULKAN_HPP_HASH_COMBINE( seed, swapchainTimingPropertiesEXT.refreshInterval ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorCaptureDescriptorDataInfoARM const & tensorCaptureDescriptorDataInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tensorCaptureDescriptorDataInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCaptureDescriptorDataInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tensorCaptureDescriptorDataInfoARM.tensor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorMemoryBarrierARM const & tensorMemoryBarrierARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.srcStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.srcAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.dstStageMask ); - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.dstAccessMask ); - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.srcQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.dstQueueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryBarrierARM.tensor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorDependencyInfoARM const & tensorDependencyInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.tensorMemoryBarrierCount ); - VULKAN_HPP_HASH_COMBINE( seed, tensorDependencyInfoARM.pTensorMemoryBarriers ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorFormatPropertiesARM const & tensorFormatPropertiesARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.optimalTilingTensorFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, tensorFormatPropertiesARM.linearTilingTensorFeatures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM const & tensorMemoryRequirementsInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryRequirementsInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryRequirementsInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tensorMemoryRequirementsInfoARM.tensor ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM const & tensorViewCaptureDescriptorDataInfoARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tensorViewCaptureDescriptorDataInfoARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tensorViewCaptureDescriptorDataInfoARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tensorViewCaptureDescriptorDataInfoARM.tensorView ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD const & textureLODGatherFormatPropertiesAMD ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.sType ); - VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, textureLODGatherFormatPropertiesAMD.supportsTextureGatherLODBiasAMD ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM const & tileMemoryBindInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tileMemoryBindInfoQCOM.memory ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM const & tileMemoryRequirementsQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.size ); - VULKAN_HPP_HASH_COMBINE( seed, tileMemoryRequirementsQCOM.alignment ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM const & tileMemorySizeInfoQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tileMemorySizeInfoQCOM.size ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TilePropertiesQCOM const & tilePropertiesQCOM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.tileSize ); - VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.apronSize ); - VULKAN_HPP_HASH_COMBINE( seed, tilePropertiesQCOM.origin ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo const & timelineSemaphoreSubmitInfo ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.sType ); - VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.waitSemaphoreValueCount ); - VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pWaitSemaphoreValues ); - VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.signalSemaphoreValueCount ); - VULKAN_HPP_HASH_COMBINE( seed, timelineSemaphoreSubmitInfo.pSignalSemaphoreValues ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR const & traceRaysIndirectCommand2KHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordAddress ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.raygenShaderRecordSize ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableAddress ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableSize ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.missShaderBindingTableStride ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableAddress ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableSize ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.hitShaderBindingTableStride ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableAddress ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableSize ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.callableShaderBindingTableStride ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.width ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.height ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommand2KHR.depth ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR const & traceRaysIndirectCommandKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.width ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.height ); - VULKAN_HPP_HASH_COMBINE( seed, traceRaysIndirectCommandKHR.depth ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT const & validationCacheCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.flags ); - VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.initialDataSize ); - VULKAN_HPP_HASH_COMBINE( seed, validationCacheCreateInfoEXT.pInitialData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT const & validationFeaturesEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.enabledValidationFeatureCount ); - VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pEnabledValidationFeatures ); - VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.disabledValidationFeatureCount ); - VULKAN_HPP_HASH_COMBINE( seed, validationFeaturesEXT.pDisabledValidationFeatures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT const & validationFlagsEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.disabledValidationCheckCount ); - VULKAN_HPP_HASH_COMBINE( seed, validationFlagsEXT.pDisabledValidationChecks ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT const & vertexInputAttributeDescription2EXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.location ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.binding ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.format ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputAttributeDescription2EXT.offset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT const & vertexInputBindingDescription2EXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.binding ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.stride ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.inputRate ); - VULKAN_HPP_HASH_COMBINE( seed, vertexInputBindingDescription2EXT.divisor ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_VI_NN ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN const & viSurfaceCreateInfoNN ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.sType ); - VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.flags ); - VULKAN_HPP_HASH_COMBINE( seed, viSurfaceCreateInfoNN.window ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_VI_NN*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR const & videoPictureResourceInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedOffset ); - VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.codedExtent ); - VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.baseArrayLayer ); - VULKAN_HPP_HASH_COMBINE( seed, videoPictureResourceInfoKHR.imageViewBinding ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR const & videoReferenceSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.slotIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoReferenceSlotInfoKHR.pPictureResource ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR const & videoBeginCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSession ); - VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.videoSessionParameters ); - VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.referenceSlotCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoBeginCodingInfoKHR.pReferenceSlots ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR const & videoCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minBitstreamBufferSizeAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.pictureAccessGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.minCodedExtent ); - VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxCodedExtent ); - VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxDpbSlots ); - VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.maxActiveReferencePictures ); - VULKAN_HPP_HASH_COMBINE( seed, videoCapabilitiesKHR.stdHeaderVersion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR const & videoCodingControlInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoCodingControlInfoKHR.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR const & videoDecodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1CapabilitiesKHR.maxLevel ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR const & videoDecodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1DpbSlotInfoKHR.pStdReferenceInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR const & videoDecodeAV1InlineSessionParametersInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1InlineSessionParametersInfoKHR.pStdSequenceHeader ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR const & videoDecodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pStdPictureInfo ); - for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.referenceNameSlotIndices[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.frameHeaderOffset ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.tileCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileOffsets ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1PictureInfoKHR.pTileSizes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR const & videoDecodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.stdProfile ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1ProfileInfoKHR.filmGrainSupport ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR const & videoDecodeAV1SessionParametersCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR const & videoDecodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeCapabilitiesKHR.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR const & videoDecodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.maxLevelIdc ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264CapabilitiesKHR.fieldOffsetGranularity ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR const & videoDecodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264DpbSlotInfoKHR.pStdReferenceInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR const & videoDecodeH264InlineSessionParametersInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pStdSPS ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264InlineSessionParametersInfoKHR.pStdPPS ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR const & videoDecodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pStdPictureInfo ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.sliceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264PictureInfoKHR.pSliceOffsets ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR const & videoDecodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.stdProfileIdc ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264ProfileInfoKHR.pictureLayout ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR const & videoDecodeH264SessionParametersAddInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdSPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdSPSs ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.stdPPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersAddInfoKHR.pStdPPSs ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR const & videoDecodeH264SessionParametersCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdSPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.maxStdPPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH264SessionParametersCreateInfoKHR.pParametersAddInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR const & videoDecodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265CapabilitiesKHR.maxLevelIdc ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR const & videoDecodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265DpbSlotInfoKHR.pStdReferenceInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR const & videoDecodeH265InlineSessionParametersInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdVPS ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdSPS ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265InlineSessionParametersInfoKHR.pStdPPS ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR const & videoDecodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pStdPictureInfo ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.sliceSegmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265PictureInfoKHR.pSliceSegmentOffsets ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR const & videoDecodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265ProfileInfoKHR.stdProfileIdc ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR const & videoDecodeH265SessionParametersAddInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdVPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdVPSs ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdSPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdSPSs ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.stdPPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersAddInfoKHR.pStdPPSs ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR const & videoDecodeH265SessionParametersCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdVPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdSPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.maxStdPPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeH265SessionParametersCreateInfoKHR.pParametersAddInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR const & videoDecodeInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferOffset ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.srcBufferRange ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.dstPictureResource ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pSetupReferenceSlot ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.referenceSlotCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeInfoKHR.pReferenceSlots ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR const & videoDecodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeUsageInfoKHR.videoUsageHints ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeVP9CapabilitiesKHR const & videoDecodeVP9CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9CapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9CapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9CapabilitiesKHR.maxLevel ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeVP9PictureInfoKHR const & videoDecodeVP9PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.pStdPictureInfo ); - for ( size_t i = 0; i < VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.referenceNameSlotIndices[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.uncompressedHeaderOffset ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.compressedHeaderOffset ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9PictureInfoKHR.tilesOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoDecodeVP9ProfileInfoKHR const & videoDecodeVP9ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9ProfileInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9ProfileInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoDecodeVP9ProfileInfoKHR.stdProfile ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR const & videoEncodeAV1CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxLevel ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.codedPictureAlignment ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTiles ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.minTileSize ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTileSize ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.superblockSizes ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxSingleReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.singleReferenceNameMask ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxUnidirectionalCompoundReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxUnidirectionalCompoundGroup1ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.unidirectionalCompoundReferenceNameMask ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundGroup1ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxBidirectionalCompoundGroup2ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.bidirectionalCompoundReferenceNameMask ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxTemporalLayerCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxSpatialLayerCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxOperatingPoints ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.minQIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.maxQIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.prefersGopRemainingFrames ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.requiresGopRemainingFrames ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1CapabilitiesKHR.stdSyntaxFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR const & videoEncodeAV1DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1DpbSlotInfoKHR.pStdReferenceInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR const & videoEncodeAV1FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.intraFrameSize ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.predictiveFrameSize ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1FrameSizeKHR.bipredictiveFrameSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR const & videoEncodeAV1GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.useGopRemainingFrames ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingIntra ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingPredictive ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1GopRemainingFrameInfoKHR.gopRemainingBipredictive ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR const & videoEncodeAV1PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.predictionMode ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.rateControlGroup ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.constantQIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.pStdPictureInfo ); - for ( size_t i = 0; i < VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR; ++i ) - { - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.referenceNameSlotIndices[i] ); - } - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.primaryReferenceCdfOnly ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1PictureInfoKHR.generateObuExtensionHeader ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR const & videoEncodeAV1ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1ProfileInfoKHR.stdProfile ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR const & videoEncodeAV1QIndexKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.intraQIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.predictiveQIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QIndexKHR.bipredictiveQIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR const & videoEncodeAV1QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredRateControlFlags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredGopFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredKeyFramePeriod ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredConsecutiveBipredictiveFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredTemporalLayerCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredConstantQIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxSingleReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredSingleReferenceNameMask ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxUnidirectionalCompoundReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxUnidirectionalCompoundGroup1ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredUnidirectionalCompoundReferenceNameMask ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundGroup1ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredMaxBidirectionalCompoundGroup2ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QualityLevelPropertiesKHR.preferredBidirectionalCompoundReferenceNameMask ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR const & videoEncodeAV1QuantizationMapCapabilitiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.minQIndexDelta ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1QuantizationMapCapabilitiesKHR.maxQIndexDelta ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR const & videoEncodeAV1RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.gopFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.keyFramePeriod ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.consecutiveBipredictiveFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlInfoKHR.temporalLayerCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR const & videoEncodeAV1RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMinQIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.minQIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMaxQIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.maxQIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.useMaxFrameSize ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1RateControlLayerInfoKHR.maxFrameSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR const & videoEncodeAV1SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.useMaxLevel ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionCreateInfoKHR.maxLevel ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR const & videoEncodeAV1SessionParametersCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdDecoderModelInfo ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.stdOperatingPointCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeAV1SessionParametersCreateInfoKHR.pStdOperatingPoints ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR const & videoEncodeCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.rateControlModes ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxRateControlLayers ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxBitrate ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.maxQualityLevels ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.encodeInputPictureGranularity ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeCapabilitiesKHR.supportedEncodeFeedbackFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR const & videoEncodeH264CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxLevelIdc ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxSliceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxPPictureL0ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxBPictureL0ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxL1ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxTemporalLayerCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.expectDyadicTemporalLayerPattern ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.minQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.maxQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.prefersGopRemainingFrames ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.requiresGopRemainingFrames ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264CapabilitiesKHR.stdSyntaxFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR const & videoEncodeH264DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264DpbSlotInfoKHR.pStdReferenceInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR const & videoEncodeH264FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameISize ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.framePSize ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264FrameSizeKHR.frameBSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR const & videoEncodeH264GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.useGopRemainingFrames ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingI ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingP ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264GopRemainingFrameInfoKHR.gopRemainingB ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR const & videoEncodeH264NaluSliceInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.constantQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264NaluSliceInfoKHR.pStdSliceHeader ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR const & videoEncodeH264PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.naluSliceEntryCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pNaluSliceEntries ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.pStdPictureInfo ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264PictureInfoKHR.generatePrefixNalu ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR const & videoEncodeH264ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264ProfileInfoKHR.stdProfileIdc ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR const & videoEncodeH264QpKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpI ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpP ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QpKHR.qpB ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR const & videoEncodeH264QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredRateControlFlags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredGopFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredIdrPeriod ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredTemporalLayerCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredConstantQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QualityLevelPropertiesKHR.preferredStdEntropyCodingModeFlag ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR const & videoEncodeH264QuantizationMapCapabilitiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.minQpDelta ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264QuantizationMapCapabilitiesKHR.maxQpDelta ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR const & videoEncodeH264RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.gopFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.idrPeriod ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.consecutiveBFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlInfoKHR.temporalLayerCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR const & videoEncodeH264RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMinQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.minQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.useMaxFrameSize ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264RateControlLayerInfoKHR.maxFrameSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR const & videoEncodeH264SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.useMaxLevelIdc ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionCreateInfoKHR.maxLevelIdc ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR const & videoEncodeH264SessionParametersAddInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdSPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdSPSs ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.stdPPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersAddInfoKHR.pStdPPSs ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR const & videoEncodeH264SessionParametersCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdSPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.maxStdPPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersCreateInfoKHR.pParametersAddInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR const & videoEncodeH264SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdSPSOverrides ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersFeedbackInfoKHR.hasStdPPSOverrides ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR const & videoEncodeH264SessionParametersGetInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdSPS ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.writeStdPPS ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdSPSId ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH264SessionParametersGetInfoKHR.stdPPSId ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR const & videoEncodeH265CapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxLevelIdc ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSliceSegmentCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxTiles ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.ctbSizes ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.transformBlockSizes ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxPPictureL0ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxBPictureL0ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxL1ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxSubLayerCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.expectDyadicTemporalSubLayerPattern ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.minQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.maxQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.prefersGopRemainingFrames ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.requiresGopRemainingFrames ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265CapabilitiesKHR.stdSyntaxFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR const & videoEncodeH265DpbSlotInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265DpbSlotInfoKHR.pStdReferenceInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR const & videoEncodeH265FrameSizeKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameISize ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.framePSize ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265FrameSizeKHR.frameBSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR const & videoEncodeH265GopRemainingFrameInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.useGopRemainingFrames ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingI ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingP ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265GopRemainingFrameInfoKHR.gopRemainingB ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR const & videoEncodeH265NaluSliceSegmentInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.constantQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265NaluSliceSegmentInfoKHR.pStdSliceSegmentHeader ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR const & videoEncodeH265PictureInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.naluSliceSegmentEntryCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pNaluSliceSegmentEntries ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265PictureInfoKHR.pStdPictureInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR const & videoEncodeH265ProfileInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265ProfileInfoKHR.stdProfileIdc ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR const & videoEncodeH265QpKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpI ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpP ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QpKHR.qpB ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR const & videoEncodeH265QualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredRateControlFlags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredGopFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredIdrPeriod ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConsecutiveBFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredSubLayerCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredConstantQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL0ReferenceCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QualityLevelPropertiesKHR.preferredMaxL1ReferenceCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR const & videoEncodeH265QuantizationMapCapabilitiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.minQpDelta ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265QuantizationMapCapabilitiesKHR.maxQpDelta ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR const & videoEncodeH265RateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.gopFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.idrPeriod ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.consecutiveBFrameCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlInfoKHR.subLayerCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR const & videoEncodeH265RateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMinQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.minQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxQp ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.useMaxFrameSize ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265RateControlLayerInfoKHR.maxFrameSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR const & videoEncodeH265SessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.useMaxLevelIdc ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionCreateInfoKHR.maxLevelIdc ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR const & videoEncodeH265SessionParametersAddInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdVPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdVPSs ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdSPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdSPSs ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.stdPPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersAddInfoKHR.pStdPPSs ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR const & videoEncodeH265SessionParametersCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdVPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdSPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.maxStdPPSCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersCreateInfoKHR.pParametersAddInfo ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( - VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR const & videoEncodeH265SessionParametersFeedbackInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdVPSOverrides ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdSPSOverrides ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersFeedbackInfoKHR.hasStdPPSOverrides ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR const & videoEncodeH265SessionParametersGetInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdVPS ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdSPS ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.writeStdPPS ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdVPSId ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdSPSId ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeH265SessionParametersGetInfoKHR.stdPPSId ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR const & videoEncodeInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBuffer ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferOffset ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.dstBufferRange ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.srcPictureResource ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pSetupReferenceSlot ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.referenceSlotCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.pReferenceSlots ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeInfoKHR.precedingExternallyEncodedBytes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshCapabilitiesKHR const & videoEncodeIntraRefreshCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.intraRefreshModes ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.maxIntraRefreshCycleDuration ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.maxIntraRefreshActiveReferencePictures ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.partitionIndependentIntraRefreshRegions ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshCapabilitiesKHR.nonRectangularIntraRefreshRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshInfoKHR const & videoEncodeIntraRefreshInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.intraRefreshCycleDuration ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeIntraRefreshInfoKHR.intraRefreshIndex ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE const & videoEncodeProfileRgbConversionInfoVALVE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeProfileRgbConversionInfoVALVE.performEncodeRgbConversion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR const & videoEncodeQualityLevelInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelInfoKHR.qualityLevel ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR const & videoEncodeQualityLevelPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlMode ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQualityLevelPropertiesKHR.preferredRateControlLayerCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR const & videoEncodeQuantizationMapCapabilitiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapCapabilitiesKHR.maxQuantizationMapExtent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR const & videoEncodeQuantizationMapInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.quantizationMap ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapInfoKHR.quantizationMapExtent ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & - videoEncodeQuantizationMapSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeQuantizationMapSessionParametersCreateInfoKHR.quantizationMapTexelSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR const & videoEncodeRateControlLayerInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.averageBitrate ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.maxBitrate ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateNumerator ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlLayerInfoKHR.frameRateDenominator ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR const & videoEncodeRateControlInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.rateControlMode ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.layerCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.pLayers ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.virtualBufferSizeInMs ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRateControlInfoKHR.initialVirtualBufferSizeInMs ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE const & videoEncodeRgbConversionCapabilitiesVALVE ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.rgbModels ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.rgbRanges ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.xChromaOffsets ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeRgbConversionCapabilitiesVALVE.yChromaOffsets ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionIntraRefreshCreateInfoKHR const & videoEncodeSessionIntraRefreshCreateInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionIntraRefreshCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionIntraRefreshCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionIntraRefreshCreateInfoKHR.intraRefreshMode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR const & videoEncodeSessionParametersFeedbackInfoKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersFeedbackInfoKHR.hasOverrides ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR const & videoEncodeSessionParametersGetInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionParametersGetInfoKHR.videoSessionParameters ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE const & videoEncodeSessionRgbConversionCreateInfoVALVE ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.rgbModel ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.rgbRange ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.xChromaOffset ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeSessionRgbConversionCreateInfoVALVE.yChromaOffset ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR const & videoEncodeUsageInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoUsageHints ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.videoContentHints ); - VULKAN_HPP_HASH_COMBINE( seed, videoEncodeUsageInfoKHR.tuningMode ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR const & videoEndCodingInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoEndCodingInfoKHR.flags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR const & videoFormatAV1QuantizationMapPropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatAV1QuantizationMapPropertiesKHR.compatibleSuperblockSizes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR const & videoFormatH265QuantizationMapPropertiesKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatH265QuantizationMapPropertiesKHR.compatibleCtbSizes ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR const & videoFormatPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.format ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.componentMapping ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageCreateFlags ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageType ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageTiling ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatPropertiesKHR.imageUsageFlags ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR const & videoFormatQuantizationMapPropertiesKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoFormatQuantizationMapPropertiesKHR.quantizationMapTexelSize ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR const & videoInlineQueryInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryPool ); - VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.firstQuery ); - VULKAN_HPP_HASH_COMBINE( seed, videoInlineQueryInfoKHR.queryCount ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR const & videoProfileListInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.profileCount ); - VULKAN_HPP_HASH_COMBINE( seed, videoProfileListInfoKHR.pProfiles ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoReferenceIntraRefreshInfoKHR const & videoReferenceIntraRefreshInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoReferenceIntraRefreshInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoReferenceIntraRefreshInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoReferenceIntraRefreshInfoKHR.dirtyIntraRefreshRegions ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR const & videoSessionCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.queueFamilyIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pVideoProfile ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pictureFormat ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxCodedExtent ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.referencePictureFormat ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxDpbSlots ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.maxActiveReferencePictures ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionCreateInfoKHR.pStdHeaderVersion ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR const & videoSessionMemoryRequirementsKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryBindIndex ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionMemoryRequirementsKHR.memoryRequirements ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR const & videoSessionParametersCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSessionParametersTemplate ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersCreateInfoKHR.videoSession ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR const & videoSessionParametersUpdateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, videoSessionParametersUpdateInfoKHR.updateSequenceCount ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR const & waylandSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.display ); - VULKAN_HPP_HASH_COMBINE( seed, waylandSurfaceCreateInfoKHR.surface ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR const & win32KeyedMutexAcquireReleaseInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.acquireCount ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireSyncs ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireKeys ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pAcquireTimeouts ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.releaseCount ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseSyncs ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoKHR.pReleaseKeys ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV const & win32KeyedMutexAcquireReleaseInfoNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.acquireCount ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireSyncs ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireKeys ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pAcquireTimeoutMilliseconds ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.releaseCount ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseSyncs ); - VULKAN_HPP_HASH_COMBINE( seed, win32KeyedMutexAcquireReleaseInfoNV.pReleaseKeys ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR const & win32SurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hinstance ); - VULKAN_HPP_HASH_COMBINE( seed, win32SurfaceCreateInfoKHR.hwnd ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR const & writeDescriptorSetAccelerationStructureKHR ) const - VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.accelerationStructureCount ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureKHR.pAccelerationStructures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t - operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV const & writeDescriptorSetAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.accelerationStructureCount ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetAccelerationStructureNV.pAccelerationStructures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock const & writeDescriptorSetInlineUniformBlock ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.sType ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.dataSize ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetInlineUniformBlock.pData ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV const & - writeDescriptorSetPartitionedAccelerationStructureNV ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.sType ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.accelerationStructureCount ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetPartitionedAccelerationStructureNV.pAccelerationStructures ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteDescriptorSetTensorARM const & writeDescriptorSetTensorARM ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.sType ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.tensorViewCount ); - VULKAN_HPP_HASH_COMBINE( seed, writeDescriptorSetTensorARM.pTensorViews ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetPipelineEXT const & writeIndirectExecutionSetPipelineEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.index ); - VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetPipelineEXT.pipeline ); - return seed; - } - }; - - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT const & writeIndirectExecutionSetShaderEXT ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.sType ); - VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.index ); - VULKAN_HPP_HASH_COMBINE( seed, writeIndirectExecutionSetShaderEXT.shader ); - return seed; - } - }; - -# if defined( VK_USE_PLATFORM_XCB_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR const & xcbSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.connection ); - VULKAN_HPP_HASH_COMBINE( seed, xcbSurfaceCreateInfoKHR.window ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_XCB_KHR*/ - -# if defined( VK_USE_PLATFORM_XLIB_KHR ) - template <> - struct hash - { - std::size_t operator()( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR const & xlibSurfaceCreateInfoKHR ) const VULKAN_HPP_NOEXCEPT - { - std::size_t seed = 0; - VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.sType ); - VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.pNext ); - VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.flags ); - VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.dpy ); - VULKAN_HPP_HASH_COMBINE( seed, xlibSurfaceCreateInfoKHR.window ); - return seed; - } - }; -# endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#endif // 14 <= VULKAN_HPP_CPP_VERSION - -} // namespace std -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_hpp_macros.hpp b/lib/vulkan-headers/include/vulkan/vulkan_hpp_macros.hpp deleted file mode 100644 index ec96c1d63a0..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_hpp_macros.hpp +++ /dev/null @@ -1,337 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_HPP_MACROS_HPP -#define VULKAN_HPP_MACROS_HPP - -#if defined( _MSVC_LANG ) -# define VULKAN_HPP_CPLUSPLUS _MSVC_LANG -#else -# define VULKAN_HPP_CPLUSPLUS __cplusplus -#endif - -#if 202002L < VULKAN_HPP_CPLUSPLUS -# define VULKAN_HPP_CPP_VERSION 23 -#elif 201703L < VULKAN_HPP_CPLUSPLUS -# define VULKAN_HPP_CPP_VERSION 20 -#elif 201402L < VULKAN_HPP_CPLUSPLUS -# define VULKAN_HPP_CPP_VERSION 17 -#elif 201103L < VULKAN_HPP_CPLUSPLUS -# define VULKAN_HPP_CPP_VERSION 14 -#elif 199711L < VULKAN_HPP_CPLUSPLUS -# define VULKAN_HPP_CPP_VERSION 11 -#else -# error "vulkan.hpp needs at least c++ standard version 11" -#endif - -// include headers holding feature-test macros -#if 20 <= VULKAN_HPP_CPP_VERSION -# include -#else -# include -#endif - -#define VULKAN_HPP_STRINGIFY2( text ) #text -#define VULKAN_HPP_STRINGIFY( text ) VULKAN_HPP_STRINGIFY2( text ) -#define VULKAN_HPP_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE ) - -#if defined( __clang__ ) || defined( __GNUC__ ) || defined( __GNUG__ ) -# define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( GCC warning text ) ) -#elif defined( _MSC_VER ) -# define VULKAN_HPP_COMPILE_WARNING( text ) _Pragma( VULKAN_HPP_STRINGIFY( message( __FILE__ "(" VULKAN_HPP_STRINGIFY( __LINE__ ) "): warning: " text ) ) ) -#else -# define VULKAN_HPP_COMPILE_WARNING( text ) -#endif - -#if defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) -# if !defined( VULKAN_HPP_NO_SMART_HANDLE ) -# define VULKAN_HPP_NO_SMART_HANDLE -# endif -#endif - -#if defined( VULKAN_HPP_NO_CONSTRUCTORS ) -# if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) -# define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS -# endif -# if !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) -# define VULKAN_HPP_NO_UNION_CONSTRUCTORS -# endif -#endif - -#if defined( VULKAN_HPP_NO_SETTERS ) -# if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) -# define VULKAN_HPP_NO_STRUCT_SETTERS -# endif -# if !defined( VULKAN_HPP_NO_UNION_SETTERS ) -# define VULKAN_HPP_NO_UNION_SETTERS -# endif -#endif - -#if !defined( VULKAN_HPP_ASSERT ) -# define VULKAN_HPP_ASSERT assert -#endif - -#if !defined( VULKAN_HPP_ASSERT_ON_RESULT ) -# define VULKAN_HPP_ASSERT_ON_RESULT VULKAN_HPP_ASSERT -#endif - -#if !defined( VULKAN_HPP_STATIC_ASSERT ) -# define VULKAN_HPP_STATIC_ASSERT static_assert -#endif - -#if !defined( VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL ) -# define VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL 1 -#endif - -#if !defined( __has_include ) -# define __has_include( x ) false -#endif - -#if defined( __cpp_lib_three_way_comparison ) && ( 201907 <= __cpp_lib_three_way_comparison ) && __has_include( ) && !defined( VULKAN_HPP_NO_SPACESHIP_OPERATOR ) -# define VULKAN_HPP_HAS_SPACESHIP_OPERATOR -#endif - -#if defined( __cpp_lib_span ) && ( 201803 <= __cpp_lib_span ) -# define VULKAN_HPP_SUPPORT_SPAN -#endif - -#if defined( VULKAN_HPP_CXX_MODULE ) && !( defined( __cpp_modules ) && defined( __cpp_lib_modules ) ) -VULKAN_HPP_COMPILE_WARNING( "This is a non-conforming implementation of C++ named modules and the standard library module." ) -#endif - -#ifndef VK_USE_64_BIT_PTR_DEFINES -# if defined( __LP64__ ) || defined( _WIN64 ) || ( defined( __x86_64__ ) && !defined( __ILP32__ ) ) || defined( _M_X64 ) || defined( __ia64 ) || \ - defined( _M_IA64 ) || defined( __aarch64__ ) || defined( __powerpc64__ ) || ( defined( __riscv ) && __riscv_xlen == 64 ) -# define VK_USE_64_BIT_PTR_DEFINES 1 -# else -# define VK_USE_64_BIT_PTR_DEFINES 0 -# endif -#endif - -// 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default. -// To enable this feature on 32-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 1 -// To disable this feature on 64-bit platforms please #define VULKAN_HPP_TYPESAFE_CONVERSION 0 -#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) -# if !defined( VULKAN_HPP_TYPESAFE_CONVERSION ) -# define VULKAN_HPP_TYPESAFE_CONVERSION 1 -# endif -#endif - -#if defined( __GNUC__ ) -# define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ ) -#endif - -#if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS ) -# if defined( __clang__ ) -# if __has_feature( cxx_unrestricted_unions ) -# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS -# endif -# elif defined( __GNUC__ ) -# if 40600 <= GCC_VERSION -# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS -# endif -# elif defined( _MSC_VER ) -# if 1900 <= _MSC_VER -# define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS -# endif -# endif -#endif - -#if !defined( VULKAN_HPP_INLINE ) -# if defined( __clang__ ) -# if __has_attribute( always_inline ) -# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__ -# else -# define VULKAN_HPP_INLINE inline -# endif -# elif defined( __GNUC__ ) -# define VULKAN_HPP_INLINE __attribute__( ( always_inline ) ) __inline__ -# elif defined( _MSC_VER ) -# define VULKAN_HPP_INLINE inline -# else -# define VULKAN_HPP_INLINE inline -# endif -#endif - -#if ( VULKAN_HPP_TYPESAFE_CONVERSION == 1 ) -# define VULKAN_HPP_TYPESAFE_EXPLICIT -#else -# define VULKAN_HPP_TYPESAFE_EXPLICIT explicit -#endif - -#if defined( __cpp_constexpr ) -# define VULKAN_HPP_CONSTEXPR constexpr -# if 201304 <= __cpp_constexpr -# define VULKAN_HPP_CONSTEXPR_14 constexpr -# else -# define VULKAN_HPP_CONSTEXPR_14 -# endif -# if 201603 <= __cpp_constexpr -# define VULKAN_HPP_CONSTEXPR_17 constexpr -# else -# define VULKAN_HPP_CONSTEXPR_17 -# endif -# if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110400 < GCC_VERSION ) ) -# define VULKAN_HPP_CONSTEXPR_20 constexpr -# else -# define VULKAN_HPP_CONSTEXPR_20 -# endif -# define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr -#else -# define VULKAN_HPP_CONSTEXPR -# define VULKAN_HPP_CONSTEXPR_14 -# define VULKAN_HPP_CONST_OR_CONSTEXPR const -#endif - -#if !defined( VULKAN_HPP_CONSTEXPR_INLINE ) -# if 201606L <= __cpp_inline_variables -# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR inline -# else -# define VULKAN_HPP_CONSTEXPR_INLINE VULKAN_HPP_CONSTEXPR -# endif -#endif - -#if !defined( VULKAN_HPP_NOEXCEPT ) -# if defined( _MSC_VER ) && ( _MSC_VER <= 1800 ) -# define VULKAN_HPP_NOEXCEPT -# else -# define VULKAN_HPP_NOEXCEPT noexcept -# define VULKAN_HPP_HAS_NOEXCEPT 1 -# if defined( VULKAN_HPP_NO_EXCEPTIONS ) -# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS noexcept -# else -# define VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS -# endif -# endif -#endif - -#if 14 <= VULKAN_HPP_CPP_VERSION -# define VULKAN_HPP_DEPRECATED( msg ) [[deprecated( msg )]] -#else -# define VULKAN_HPP_DEPRECATED( msg ) -#endif - -#if 17 <= VULKAN_HPP_CPP_VERSION -# define VULKAN_HPP_DEPRECATED_17( msg ) [[deprecated( msg )]] -#else -# define VULKAN_HPP_DEPRECATED_17( msg ) -#endif - -#if ( 17 <= VULKAN_HPP_CPP_VERSION ) && !defined( VULKAN_HPP_NO_NODISCARD_WARNINGS ) -# define VULKAN_HPP_NODISCARD [[nodiscard]] -# if defined( VULKAN_HPP_NO_EXCEPTIONS ) -# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]] -# else -# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS -# endif -#else -# define VULKAN_HPP_NODISCARD -# define VULKAN_HPP_NODISCARD_WHEN_NO_EXCEPTIONS -#endif - -#if !defined( VULKAN_HPP_NAMESPACE ) -# define VULKAN_HPP_NAMESPACE vk -#endif - -#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC ) -# if defined( VK_NO_PROTOTYPES ) -# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1 -# else -# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 0 -# endif -#endif - -#if !defined( VULKAN_HPP_STORAGE_API ) -# if defined( VULKAN_HPP_STORAGE_SHARED ) -# if defined( _MSC_VER ) -# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT ) -# define VULKAN_HPP_STORAGE_API __declspec( dllexport ) -# else -# define VULKAN_HPP_STORAGE_API __declspec( dllimport ) -# endif -# elif defined( __clang__ ) || defined( __GNUC__ ) -# if defined( VULKAN_HPP_STORAGE_SHARED_EXPORT ) -# define VULKAN_HPP_STORAGE_API __attribute__( ( visibility( "default" ) ) ) -# else -# define VULKAN_HPP_STORAGE_API -# endif -# else -# define VULKAN_HPP_STORAGE_API -# pragma warning Unknown import / export semantics -# endif -# else -# define VULKAN_HPP_STORAGE_API -# endif -#endif - -namespace VULKAN_HPP_NAMESPACE -{ - namespace detail - { - class DispatchLoaderDynamic; - -#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER ) -# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 - extern VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; -# endif -#endif - } // namespace detail -} // namespace VULKAN_HPP_NAMESPACE - -#if !defined( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC_TYPE ) -# define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC_TYPE VULKAN_HPP_NAMESPACE::detail::DispatchLoaderDynamic -#endif -#if !defined( VULKAN_HPP_DISPATCH_LOADER_STATIC_TYPE ) -# define VULKAN_HPP_DISPATCH_LOADER_STATIC_TYPE VULKAN_HPP_NAMESPACE::detail::DispatchLoaderStatic -#endif - -#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER_TYPE ) -# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 -# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE VULKAN_HPP_DISPATCH_LOADER_DYNAMIC_TYPE -# else -# define VULKAN_HPP_DEFAULT_DISPATCHER_TYPE VULKAN_HPP_DISPATCH_LOADER_STATIC_TYPE -# endif -#endif - -#if !defined( VULKAN_HPP_DEFAULT_DISPATCHER ) -# if VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 -# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::detail::defaultDispatchLoaderDynamic -# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE \ - namespace VULKAN_HPP_NAMESPACE \ - { \ - namespace detail \ - { \ - VULKAN_HPP_STORAGE_API DispatchLoaderDynamic defaultDispatchLoaderDynamic; \ - } \ - } -# else -# define VULKAN_HPP_DEFAULT_DISPATCHER ::VULKAN_HPP_NAMESPACE::detail::getDispatchLoaderStatic() -# define VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE -# endif -#endif - -#if defined( VULKAN_HPP_NO_DEFAULT_DISPATCHER ) -# define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment ) -#else -# define VULKAN_HPP_DEFAULT_ASSIGNMENT( assignment ) = assignment -#endif -#define VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT VULKAN_HPP_DEFAULT_ASSIGNMENT( VULKAN_HPP_DEFAULT_DISPATCHER ) - -#if !defined( VULKAN_HPP_EXPECTED ) && ( 23 <= VULKAN_HPP_CPP_VERSION ) && defined( __cpp_lib_expected ) && defined( VULKAN_HPP_USE_STD_EXPECTED ) -# if !( defined( VULKAN_HPP_ENABLE_STD_MODULE ) && defined( VULKAN_HPP_STD_MODULE ) ) -# include -# endif -# define VULKAN_HPP_EXPECTED std::expected -# define VULKAN_HPP_UNEXPECTED std::unexpected -#endif - -#if !defined( VULKAN_HPP_RAII_NAMESPACE ) -# define VULKAN_HPP_RAII_NAMESPACE raii -# define VULKAN_HPP_RAII_NAMESPACE_STRING VULKAN_HPP_STRINGIFY( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE ) -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_ios.h b/lib/vulkan-headers/include/vulkan/vulkan_ios.h deleted file mode 100644 index 089991a4f60..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_ios.h +++ /dev/null @@ -1,50 +0,0 @@ -#ifndef VULKAN_IOS_H_ -#define VULKAN_IOS_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_MVK_ios_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_MVK_ios_surface 1 -#define VK_MVK_IOS_SURFACE_SPEC_VERSION 3 -#define VK_MVK_IOS_SURFACE_EXTENSION_NAME "VK_MVK_ios_surface" -typedef VkFlags VkIOSSurfaceCreateFlagsMVK; -typedef struct VkIOSSurfaceCreateInfoMVK { - VkStructureType sType; - const void* pNext; - VkIOSSurfaceCreateFlagsMVK flags; - const void* pView; -} VkIOSSurfaceCreateInfoMVK; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateIOSSurfaceMVK)(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( - VkInstance instance, - const VkIOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_macos.h b/lib/vulkan-headers/include/vulkan/vulkan_macos.h deleted file mode 100644 index 7d5d8a1b31a..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_macos.h +++ /dev/null @@ -1,50 +0,0 @@ -#ifndef VULKAN_MACOS_H_ -#define VULKAN_MACOS_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_MVK_macos_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_MVK_macos_surface 1 -#define VK_MVK_MACOS_SURFACE_SPEC_VERSION 3 -#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface" -typedef VkFlags VkMacOSSurfaceCreateFlagsMVK; -typedef struct VkMacOSSurfaceCreateInfoMVK { - VkStructureType sType; - const void* pNext; - VkMacOSSurfaceCreateFlagsMVK flags; - const void* pView; -} VkMacOSSurfaceCreateInfoMVK; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateMacOSSurfaceMVK)(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( - VkInstance instance, - const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_metal.h b/lib/vulkan-headers/include/vulkan/vulkan_metal.h deleted file mode 100644 index 501c3638861..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_metal.h +++ /dev/null @@ -1,244 +0,0 @@ -#ifndef VULKAN_METAL_H_ -#define VULKAN_METAL_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_EXT_metal_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_metal_surface 1 -#ifdef __OBJC__ -@class CAMetalLayer; -#else -typedef void CAMetalLayer; -#endif - -#define VK_EXT_METAL_SURFACE_SPEC_VERSION 1 -#define VK_EXT_METAL_SURFACE_EXTENSION_NAME "VK_EXT_metal_surface" -typedef VkFlags VkMetalSurfaceCreateFlagsEXT; -typedef struct VkMetalSurfaceCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkMetalSurfaceCreateFlagsEXT flags; - const CAMetalLayer* pLayer; -} VkMetalSurfaceCreateInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateMetalSurfaceEXT)(VkInstance instance, const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateMetalSurfaceEXT( - VkInstance instance, - const VkMetalSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif -#endif - - -// VK_EXT_metal_objects is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_metal_objects 1 -#ifdef __OBJC__ -@protocol MTLDevice; -typedef __unsafe_unretained id MTLDevice_id; -#else -typedef void* MTLDevice_id; -#endif - -#ifdef __OBJC__ -@protocol MTLCommandQueue; -typedef __unsafe_unretained id MTLCommandQueue_id; -#else -typedef void* MTLCommandQueue_id; -#endif - -#ifdef __OBJC__ -@protocol MTLBuffer; -typedef __unsafe_unretained id MTLBuffer_id; -#else -typedef void* MTLBuffer_id; -#endif - -#ifdef __OBJC__ -@protocol MTLTexture; -typedef __unsafe_unretained id MTLTexture_id; -#else -typedef void* MTLTexture_id; -#endif - -typedef struct __IOSurface* IOSurfaceRef; -#ifdef __OBJC__ -@protocol MTLSharedEvent; -typedef __unsafe_unretained id MTLSharedEvent_id; -#else -typedef void* MTLSharedEvent_id; -#endif - -#define VK_EXT_METAL_OBJECTS_SPEC_VERSION 2 -#define VK_EXT_METAL_OBJECTS_EXTENSION_NAME "VK_EXT_metal_objects" - -typedef enum VkExportMetalObjectTypeFlagBitsEXT { - VK_EXPORT_METAL_OBJECT_TYPE_METAL_DEVICE_BIT_EXT = 0x00000001, - VK_EXPORT_METAL_OBJECT_TYPE_METAL_COMMAND_QUEUE_BIT_EXT = 0x00000002, - VK_EXPORT_METAL_OBJECT_TYPE_METAL_BUFFER_BIT_EXT = 0x00000004, - VK_EXPORT_METAL_OBJECT_TYPE_METAL_TEXTURE_BIT_EXT = 0x00000008, - VK_EXPORT_METAL_OBJECT_TYPE_METAL_IOSURFACE_BIT_EXT = 0x00000010, - VK_EXPORT_METAL_OBJECT_TYPE_METAL_SHARED_EVENT_BIT_EXT = 0x00000020, - VK_EXPORT_METAL_OBJECT_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkExportMetalObjectTypeFlagBitsEXT; -typedef VkFlags VkExportMetalObjectTypeFlagsEXT; -typedef struct VkExportMetalObjectCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkExportMetalObjectTypeFlagBitsEXT exportObjectType; -} VkExportMetalObjectCreateInfoEXT; - -typedef struct VkExportMetalObjectsInfoEXT { - VkStructureType sType; - const void* pNext; -} VkExportMetalObjectsInfoEXT; - -typedef struct VkExportMetalDeviceInfoEXT { - VkStructureType sType; - const void* pNext; - MTLDevice_id mtlDevice; -} VkExportMetalDeviceInfoEXT; - -typedef struct VkExportMetalCommandQueueInfoEXT { - VkStructureType sType; - const void* pNext; - VkQueue queue; - MTLCommandQueue_id mtlCommandQueue; -} VkExportMetalCommandQueueInfoEXT; - -typedef struct VkExportMetalBufferInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - MTLBuffer_id mtlBuffer; -} VkExportMetalBufferInfoEXT; - -typedef struct VkImportMetalBufferInfoEXT { - VkStructureType sType; - const void* pNext; - MTLBuffer_id mtlBuffer; -} VkImportMetalBufferInfoEXT; - -typedef struct VkExportMetalTextureInfoEXT { - VkStructureType sType; - const void* pNext; - VkImage image; - VkImageView imageView; - VkBufferView bufferView; - VkImageAspectFlagBits plane; - MTLTexture_id mtlTexture; -} VkExportMetalTextureInfoEXT; - -typedef struct VkImportMetalTextureInfoEXT { - VkStructureType sType; - const void* pNext; - VkImageAspectFlagBits plane; - MTLTexture_id mtlTexture; -} VkImportMetalTextureInfoEXT; - -typedef struct VkExportMetalIOSurfaceInfoEXT { - VkStructureType sType; - const void* pNext; - VkImage image; - IOSurfaceRef ioSurface; -} VkExportMetalIOSurfaceInfoEXT; - -typedef struct VkImportMetalIOSurfaceInfoEXT { - VkStructureType sType; - const void* pNext; - IOSurfaceRef ioSurface; -} VkImportMetalIOSurfaceInfoEXT; - -typedef struct VkExportMetalSharedEventInfoEXT { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkEvent event; - MTLSharedEvent_id mtlSharedEvent; -} VkExportMetalSharedEventInfoEXT; - -typedef struct VkImportMetalSharedEventInfoEXT { - VkStructureType sType; - const void* pNext; - MTLSharedEvent_id mtlSharedEvent; -} VkImportMetalSharedEventInfoEXT; - -typedef void (VKAPI_PTR *PFN_vkExportMetalObjectsEXT)(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR void VKAPI_CALL vkExportMetalObjectsEXT( - VkDevice device, - VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); -#endif -#endif - - -// VK_EXT_external_memory_metal is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_external_memory_metal 1 -#define VK_EXT_EXTERNAL_MEMORY_METAL_SPEC_VERSION 1 -#define VK_EXT_EXTERNAL_MEMORY_METAL_EXTENSION_NAME "VK_EXT_external_memory_metal" -typedef struct VkImportMemoryMetalHandleInfoEXT { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - void* handle; -} VkImportMemoryMetalHandleInfoEXT; - -typedef struct VkMemoryMetalHandlePropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryMetalHandlePropertiesEXT; - -typedef struct VkMemoryGetMetalHandleInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkMemoryGetMetalHandleInfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandleEXT)(VkDevice device, const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, void** pHandle); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryMetalHandlePropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHandle, VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandleEXT( - VkDevice device, - const VkMemoryGetMetalHandleInfoEXT* pGetMetalHandleInfo, - void** pHandle); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryMetalHandlePropertiesEXT( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - const void* pHandle, - VkMemoryMetalHandlePropertiesEXT* pMemoryMetalHandleProperties); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_ohos.h b/lib/vulkan-headers/include/vulkan/vulkan_ohos.h deleted file mode 100644 index 3bde0114f5a..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_ohos.h +++ /dev/null @@ -1,120 +0,0 @@ -#ifndef VULKAN_OHOS_H_ -#define VULKAN_OHOS_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_OHOS_external_memory is a preprocessor guard. Do not pass it to API calls. -#define VK_OHOS_external_memory 1 -struct OH_NativeBuffer; -#define VK_OHOS_EXTERNAL_MEMORY_SPEC_VERSION 1 -#define VK_OHOS_EXTERNAL_MEMORY_EXTENSION_NAME "VK_OHOS_external_memory" -typedef struct VkNativeBufferUsageOHOS { - VkStructureType sType; - void* pNext; - uint64_t OHOSNativeBufferUsage; -} VkNativeBufferUsageOHOS; - -typedef struct VkNativeBufferPropertiesOHOS { - VkStructureType sType; - void* pNext; - VkDeviceSize allocationSize; - uint32_t memoryTypeBits; -} VkNativeBufferPropertiesOHOS; - -typedef struct VkNativeBufferFormatPropertiesOHOS { - VkStructureType sType; - void* pNext; - VkFormat format; - uint64_t externalFormat; - VkFormatFeatureFlags formatFeatures; - VkComponentMapping samplerYcbcrConversionComponents; - VkSamplerYcbcrModelConversion suggestedYcbcrModel; - VkSamplerYcbcrRange suggestedYcbcrRange; - VkChromaLocation suggestedXChromaOffset; - VkChromaLocation suggestedYChromaOffset; -} VkNativeBufferFormatPropertiesOHOS; - -typedef struct VkImportNativeBufferInfoOHOS { - VkStructureType sType; - const void* pNext; - struct OH_NativeBuffer* buffer; -} VkImportNativeBufferInfoOHOS; - -typedef struct VkMemoryGetNativeBufferInfoOHOS { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; -} VkMemoryGetNativeBufferInfoOHOS; - -typedef struct VkExternalFormatOHOS { - VkStructureType sType; - void* pNext; - uint64_t externalFormat; -} VkExternalFormatOHOS; - -typedef VkResult (VKAPI_PTR *PFN_vkGetNativeBufferPropertiesOHOS)(VkDevice device, const struct OH_NativeBuffer* buffer, VkNativeBufferPropertiesOHOS* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryNativeBufferOHOS)(VkDevice device, const VkMemoryGetNativeBufferInfoOHOS* pInfo, struct OH_NativeBuffer** pBuffer); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetNativeBufferPropertiesOHOS( - VkDevice device, - const struct OH_NativeBuffer* buffer, - VkNativeBufferPropertiesOHOS* pProperties); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryNativeBufferOHOS( - VkDevice device, - const VkMemoryGetNativeBufferInfoOHOS* pInfo, - struct OH_NativeBuffer** pBuffer); -#endif -#endif - - -// VK_OHOS_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_OHOS_surface 1 -typedef struct NativeWindow OHNativeWindow; -#define VK_OHOS_SURFACE_SPEC_VERSION 1 -#define VK_OHOS_SURFACE_EXTENSION_NAME "VK_OHOS_surface" -typedef VkFlags VkSurfaceCreateFlagsOHOS; -typedef struct VkSurfaceCreateInfoOHOS { - VkStructureType sType; - const void* pNext; - VkSurfaceCreateFlagsOHOS flags; - OHNativeWindow* window; -} VkSurfaceCreateInfoOHOS; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateSurfaceOHOS)(VkInstance instance, const VkSurfaceCreateInfoOHOS* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateSurfaceOHOS( - VkInstance instance, - const VkSurfaceCreateInfoOHOS* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_raii.hpp b/lib/vulkan-headers/include/vulkan/vulkan_raii.hpp deleted file mode 100644 index 9f18b89ee80..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_raii.hpp +++ /dev/null @@ -1,28565 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_RAII_HPP -#define VULKAN_RAII_HPP - -#include -#if !defined( VULKAN_HPP_CXX_MODULE ) -# include // std::unique_ptr -# include // std::forward -#endif - -#if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) -namespace VULKAN_HPP_NAMESPACE -{ - namespace VULKAN_HPP_RAII_NAMESPACE - { - namespace detail - { - using PFN_dummy = void ( * )(); - - class ContextDispatcher : public ::VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase - { - public: - ContextDispatcher( PFN_vkGetInstanceProcAddr getProcAddr ) - : vkGetInstanceProcAddr( getProcAddr ) - //=== VK_VERSION_1_0 === - , vkCreateInstance( PFN_vkCreateInstance( getProcAddr( NULL, "vkCreateInstance" ) ) ) - , vkEnumerateInstanceExtensionProperties( - PFN_vkEnumerateInstanceExtensionProperties( getProcAddr( NULL, "vkEnumerateInstanceExtensionProperties" ) ) ) - , vkEnumerateInstanceLayerProperties( PFN_vkEnumerateInstanceLayerProperties( getProcAddr( NULL, "vkEnumerateInstanceLayerProperties" ) ) ) - //=== VK_VERSION_1_1 === - , vkEnumerateInstanceVersion( PFN_vkEnumerateInstanceVersion( getProcAddr( NULL, "vkEnumerateInstanceVersion" ) ) ) - { - } - - public: - PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; - - //=== VK_VERSION_1_0 === - PFN_vkCreateInstance vkCreateInstance = 0; - PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties = 0; - PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties = 0; - - //=== VK_VERSION_1_1 === - PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion = 0; - }; - - class InstanceDispatcher : public ::VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase - { - public: - InstanceDispatcher( PFN_vkGetInstanceProcAddr getProcAddr, VkInstance instance ) : vkGetInstanceProcAddr( getProcAddr ) - { - //=== VK_VERSION_1_0 === - vkDestroyInstance = PFN_vkDestroyInstance( vkGetInstanceProcAddr( instance, "vkDestroyInstance" ) ); - vkEnumeratePhysicalDevices = PFN_vkEnumeratePhysicalDevices( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDevices" ) ); - vkGetPhysicalDeviceFeatures = PFN_vkGetPhysicalDeviceFeatures( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures" ) ); - vkGetPhysicalDeviceFormatProperties = - PFN_vkGetPhysicalDeviceFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties" ) ); - vkGetPhysicalDeviceImageFormatProperties = - PFN_vkGetPhysicalDeviceImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties" ) ); - vkGetPhysicalDeviceProperties = PFN_vkGetPhysicalDeviceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties" ) ); - vkGetPhysicalDeviceQueueFamilyProperties = - PFN_vkGetPhysicalDeviceQueueFamilyProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties" ) ); - vkGetPhysicalDeviceMemoryProperties = - PFN_vkGetPhysicalDeviceMemoryProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties" ) ); - vkCreateDevice = PFN_vkCreateDevice( vkGetInstanceProcAddr( instance, "vkCreateDevice" ) ); - vkEnumerateDeviceExtensionProperties = - PFN_vkEnumerateDeviceExtensionProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceExtensionProperties" ) ); - vkEnumerateDeviceLayerProperties = PFN_vkEnumerateDeviceLayerProperties( vkGetInstanceProcAddr( instance, "vkEnumerateDeviceLayerProperties" ) ); - vkGetPhysicalDeviceSparseImageFormatProperties = - PFN_vkGetPhysicalDeviceSparseImageFormatProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties" ) ); - - //=== VK_VERSION_1_1 === - vkEnumeratePhysicalDeviceGroups = PFN_vkEnumeratePhysicalDeviceGroups( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroups" ) ); - vkGetPhysicalDeviceFeatures2 = PFN_vkGetPhysicalDeviceFeatures2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2" ) ); - vkGetPhysicalDeviceProperties2 = PFN_vkGetPhysicalDeviceProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2" ) ); - vkGetPhysicalDeviceFormatProperties2 = - PFN_vkGetPhysicalDeviceFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2" ) ); - vkGetPhysicalDeviceImageFormatProperties2 = - PFN_vkGetPhysicalDeviceImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2" ) ); - vkGetPhysicalDeviceQueueFamilyProperties2 = - PFN_vkGetPhysicalDeviceQueueFamilyProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2" ) ); - vkGetPhysicalDeviceMemoryProperties2 = - PFN_vkGetPhysicalDeviceMemoryProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2" ) ); - vkGetPhysicalDeviceSparseImageFormatProperties2 = - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2" ) ); - vkGetPhysicalDeviceExternalBufferProperties = - PFN_vkGetPhysicalDeviceExternalBufferProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferProperties" ) ); - vkGetPhysicalDeviceExternalFenceProperties = - PFN_vkGetPhysicalDeviceExternalFenceProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFenceProperties" ) ); - vkGetPhysicalDeviceExternalSemaphoreProperties = - PFN_vkGetPhysicalDeviceExternalSemaphoreProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphoreProperties" ) ); - - //=== VK_VERSION_1_3 === - vkGetPhysicalDeviceToolProperties = PFN_vkGetPhysicalDeviceToolProperties( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolProperties" ) ); - - //=== VK_KHR_surface === - vkDestroySurfaceKHR = PFN_vkDestroySurfaceKHR( vkGetInstanceProcAddr( instance, "vkDestroySurfaceKHR" ) ); - vkGetPhysicalDeviceSurfaceSupportKHR = - PFN_vkGetPhysicalDeviceSurfaceSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceSupportKHR" ) ); - vkGetPhysicalDeviceSurfaceCapabilitiesKHR = - PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR" ) ); - vkGetPhysicalDeviceSurfaceFormatsKHR = - PFN_vkGetPhysicalDeviceSurfaceFormatsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormatsKHR" ) ); - vkGetPhysicalDeviceSurfacePresentModesKHR = - PFN_vkGetPhysicalDeviceSurfacePresentModesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModesKHR" ) ); - - //=== VK_KHR_swapchain === - vkGetPhysicalDevicePresentRectanglesKHR = - PFN_vkGetPhysicalDevicePresentRectanglesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDevicePresentRectanglesKHR" ) ); - - //=== VK_KHR_display === - vkGetPhysicalDeviceDisplayPropertiesKHR = - PFN_vkGetPhysicalDeviceDisplayPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPropertiesKHR" ) ); - vkGetPhysicalDeviceDisplayPlanePropertiesKHR = - PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR" ) ); - vkGetDisplayPlaneSupportedDisplaysKHR = - PFN_vkGetDisplayPlaneSupportedDisplaysKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneSupportedDisplaysKHR" ) ); - vkGetDisplayModePropertiesKHR = PFN_vkGetDisplayModePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModePropertiesKHR" ) ); - vkCreateDisplayModeKHR = PFN_vkCreateDisplayModeKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayModeKHR" ) ); - vkGetDisplayPlaneCapabilitiesKHR = PFN_vkGetDisplayPlaneCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilitiesKHR" ) ); - vkCreateDisplayPlaneSurfaceKHR = PFN_vkCreateDisplayPlaneSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateDisplayPlaneSurfaceKHR" ) ); - -# if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - vkCreateXlibSurfaceKHR = PFN_vkCreateXlibSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXlibSurfaceKHR" ) ); - vkGetPhysicalDeviceXlibPresentationSupportKHR = - PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR" ) ); -# endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -# if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - vkCreateXcbSurfaceKHR = PFN_vkCreateXcbSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateXcbSurfaceKHR" ) ); - vkGetPhysicalDeviceXcbPresentationSupportKHR = - PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR" ) ); -# endif /*VK_USE_PLATFORM_XCB_KHR*/ - -# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - vkCreateWaylandSurfaceKHR = PFN_vkCreateWaylandSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWaylandSurfaceKHR" ) ); - vkGetPhysicalDeviceWaylandPresentationSupportKHR = - PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR" ) ); -# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - vkCreateAndroidSurfaceKHR = PFN_vkCreateAndroidSurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateAndroidSurfaceKHR" ) ); -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - vkCreateWin32SurfaceKHR = PFN_vkCreateWin32SurfaceKHR( vkGetInstanceProcAddr( instance, "vkCreateWin32SurfaceKHR" ) ); - vkGetPhysicalDeviceWin32PresentationSupportKHR = - PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR" ) ); -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - vkCreateDebugReportCallbackEXT = PFN_vkCreateDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugReportCallbackEXT" ) ); - vkDestroyDebugReportCallbackEXT = PFN_vkDestroyDebugReportCallbackEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugReportCallbackEXT" ) ); - vkDebugReportMessageEXT = PFN_vkDebugReportMessageEXT( vkGetInstanceProcAddr( instance, "vkDebugReportMessageEXT" ) ); - - //=== VK_KHR_video_queue === - vkGetPhysicalDeviceVideoCapabilitiesKHR = - PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR" ) ); - vkGetPhysicalDeviceVideoFormatPropertiesKHR = - PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR" ) ); - -# if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - vkCreateStreamDescriptorSurfaceGGP = - PFN_vkCreateStreamDescriptorSurfaceGGP( vkGetInstanceProcAddr( instance, "vkCreateStreamDescriptorSurfaceGGP" ) ); -# endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - vkGetPhysicalDeviceExternalImageFormatPropertiesNV = - PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV" ) ); - - //=== VK_KHR_get_physical_device_properties2 === - vkGetPhysicalDeviceFeatures2KHR = PFN_vkGetPhysicalDeviceFeatures2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFeatures2KHR" ) ); - if ( !vkGetPhysicalDeviceFeatures2 ) - vkGetPhysicalDeviceFeatures2 = vkGetPhysicalDeviceFeatures2KHR; - vkGetPhysicalDeviceProperties2KHR = PFN_vkGetPhysicalDeviceProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceProperties2 ) - vkGetPhysicalDeviceProperties2 = vkGetPhysicalDeviceProperties2KHR; - vkGetPhysicalDeviceFormatProperties2KHR = - PFN_vkGetPhysicalDeviceFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFormatProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceFormatProperties2 ) - vkGetPhysicalDeviceFormatProperties2 = vkGetPhysicalDeviceFormatProperties2KHR; - vkGetPhysicalDeviceImageFormatProperties2KHR = - PFN_vkGetPhysicalDeviceImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceImageFormatProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceImageFormatProperties2 ) - vkGetPhysicalDeviceImageFormatProperties2 = vkGetPhysicalDeviceImageFormatProperties2KHR; - vkGetPhysicalDeviceQueueFamilyProperties2KHR = - PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceQueueFamilyProperties2 ) - vkGetPhysicalDeviceQueueFamilyProperties2 = vkGetPhysicalDeviceQueueFamilyProperties2KHR; - vkGetPhysicalDeviceMemoryProperties2KHR = - PFN_vkGetPhysicalDeviceMemoryProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMemoryProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceMemoryProperties2 ) - vkGetPhysicalDeviceMemoryProperties2 = vkGetPhysicalDeviceMemoryProperties2KHR; - vkGetPhysicalDeviceSparseImageFormatProperties2KHR = - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR" ) ); - if ( !vkGetPhysicalDeviceSparseImageFormatProperties2 ) - vkGetPhysicalDeviceSparseImageFormatProperties2 = vkGetPhysicalDeviceSparseImageFormatProperties2KHR; - -# if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - vkCreateViSurfaceNN = PFN_vkCreateViSurfaceNN( vkGetInstanceProcAddr( instance, "vkCreateViSurfaceNN" ) ); -# endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_device_group_creation === - vkEnumeratePhysicalDeviceGroupsKHR = - PFN_vkEnumeratePhysicalDeviceGroupsKHR( vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceGroupsKHR" ) ); - if ( !vkEnumeratePhysicalDeviceGroups ) - vkEnumeratePhysicalDeviceGroups = vkEnumeratePhysicalDeviceGroupsKHR; - - //=== VK_KHR_external_memory_capabilities === - vkGetPhysicalDeviceExternalBufferPropertiesKHR = - PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR" ) ); - if ( !vkGetPhysicalDeviceExternalBufferProperties ) - vkGetPhysicalDeviceExternalBufferProperties = vkGetPhysicalDeviceExternalBufferPropertiesKHR; - - //=== VK_KHR_external_semaphore_capabilities === - vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = - PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR" ) ); - if ( !vkGetPhysicalDeviceExternalSemaphoreProperties ) - vkGetPhysicalDeviceExternalSemaphoreProperties = vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; - - //=== VK_EXT_direct_mode_display === - vkReleaseDisplayEXT = PFN_vkReleaseDisplayEXT( vkGetInstanceProcAddr( instance, "vkReleaseDisplayEXT" ) ); - -# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - vkAcquireXlibDisplayEXT = PFN_vkAcquireXlibDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireXlibDisplayEXT" ) ); - vkGetRandROutputDisplayEXT = PFN_vkGetRandROutputDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetRandROutputDisplayEXT" ) ); -# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - vkGetPhysicalDeviceSurfaceCapabilities2EXT = - PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT" ) ); - - //=== VK_KHR_external_fence_capabilities === - vkGetPhysicalDeviceExternalFencePropertiesKHR = - PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR" ) ); - if ( !vkGetPhysicalDeviceExternalFenceProperties ) - vkGetPhysicalDeviceExternalFenceProperties = vkGetPhysicalDeviceExternalFencePropertiesKHR; - - //=== VK_KHR_performance_query === - vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR" ) ); - vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( - vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR" ) ); - - //=== VK_KHR_get_surface_capabilities2 === - vkGetPhysicalDeviceSurfaceCapabilities2KHR = - PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR" ) ); - vkGetPhysicalDeviceSurfaceFormats2KHR = - PFN_vkGetPhysicalDeviceSurfaceFormats2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfaceFormats2KHR" ) ); - - //=== VK_KHR_get_display_properties2 === - vkGetPhysicalDeviceDisplayProperties2KHR = - PFN_vkGetPhysicalDeviceDisplayProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayProperties2KHR" ) ); - vkGetPhysicalDeviceDisplayPlaneProperties2KHR = - PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR" ) ); - vkGetDisplayModeProperties2KHR = PFN_vkGetDisplayModeProperties2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayModeProperties2KHR" ) ); - vkGetDisplayPlaneCapabilities2KHR = PFN_vkGetDisplayPlaneCapabilities2KHR( vkGetInstanceProcAddr( instance, "vkGetDisplayPlaneCapabilities2KHR" ) ); - -# if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - vkCreateIOSSurfaceMVK = PFN_vkCreateIOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateIOSSurfaceMVK" ) ); -# endif /*VK_USE_PLATFORM_IOS_MVK*/ - -# if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK( vkGetInstanceProcAddr( instance, "vkCreateMacOSSurfaceMVK" ) ); -# endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - vkCreateDebugUtilsMessengerEXT = PFN_vkCreateDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkCreateDebugUtilsMessengerEXT" ) ); - vkDestroyDebugUtilsMessengerEXT = PFN_vkDestroyDebugUtilsMessengerEXT( vkGetInstanceProcAddr( instance, "vkDestroyDebugUtilsMessengerEXT" ) ); - vkSubmitDebugUtilsMessageEXT = PFN_vkSubmitDebugUtilsMessageEXT( vkGetInstanceProcAddr( instance, "vkSubmitDebugUtilsMessageEXT" ) ); - - //=== VK_EXT_descriptor_heap === - vkGetPhysicalDeviceDescriptorSizeEXT = - PFN_vkGetPhysicalDeviceDescriptorSizeEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDescriptorSizeEXT" ) ); - - //=== VK_EXT_sample_locations === - vkGetPhysicalDeviceMultisamplePropertiesEXT = - PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT" ) ); - - //=== VK_EXT_calibrated_timestamps === - vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = - PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT" ) ); - if ( !vkGetPhysicalDeviceCalibrateableTimeDomainsKHR ) - vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - vkCreateImagePipeSurfaceFUCHSIA = PFN_vkCreateImagePipeSurfaceFUCHSIA( vkGetInstanceProcAddr( instance, "vkCreateImagePipeSurfaceFUCHSIA" ) ); -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateMetalSurfaceEXT" ) ); -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_fragment_shading_rate === - vkGetPhysicalDeviceFragmentShadingRatesKHR = - PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR" ) ); - - //=== VK_EXT_tooling_info === - vkGetPhysicalDeviceToolPropertiesEXT = - PFN_vkGetPhysicalDeviceToolPropertiesEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceToolPropertiesEXT" ) ); - if ( !vkGetPhysicalDeviceToolProperties ) - vkGetPhysicalDeviceToolProperties = vkGetPhysicalDeviceToolPropertiesEXT; - - //=== VK_NV_cooperative_matrix === - vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = - PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV" ) ); - - //=== VK_NV_coverage_reduction_mode === - vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" ) ); - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - vkGetPhysicalDeviceSurfacePresentModes2EXT = - PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT" ) ); -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - vkCreateHeadlessSurfaceEXT = PFN_vkCreateHeadlessSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateHeadlessSurfaceEXT" ) ); - - //=== VK_EXT_acquire_drm_display === - vkAcquireDrmDisplayEXT = PFN_vkAcquireDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkAcquireDrmDisplayEXT" ) ); - vkGetDrmDisplayEXT = PFN_vkGetDrmDisplayEXT( vkGetInstanceProcAddr( instance, "vkGetDrmDisplayEXT" ) ); - - //=== VK_KHR_video_encode_queue === - vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( - vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR" ) ); - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - vkAcquireWinrtDisplayNV = PFN_vkAcquireWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkAcquireWinrtDisplayNV" ) ); - vkGetWinrtDisplayNV = PFN_vkGetWinrtDisplayNV( vkGetInstanceProcAddr( instance, "vkGetWinrtDisplayNV" ) ); -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - vkCreateDirectFBSurfaceEXT = PFN_vkCreateDirectFBSurfaceEXT( vkGetInstanceProcAddr( instance, "vkCreateDirectFBSurfaceEXT" ) ); - vkGetPhysicalDeviceDirectFBPresentationSupportEXT = - PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT" ) ); -# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - vkCreateScreenSurfaceQNX = PFN_vkCreateScreenSurfaceQNX( vkGetInstanceProcAddr( instance, "vkCreateScreenSurfaceQNX" ) ); - vkGetPhysicalDeviceScreenPresentationSupportQNX = - PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX" ) ); -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_ARM_tensors === - vkGetPhysicalDeviceExternalTensorPropertiesARM = - PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceExternalTensorPropertiesARM" ) ); - - //=== VK_NV_optical_flow === - vkGetPhysicalDeviceOpticalFlowImageFormatsNV = - PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV" ) ); - - //=== VK_NV_cooperative_vector === - vkGetPhysicalDeviceCooperativeVectorPropertiesNV = - PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeVectorPropertiesNV" ) ); - - //=== VK_KHR_cooperative_matrix === - vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = - PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR" ) ); - - //=== VK_ARM_data_graph === - vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( - vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM" ) ); - vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( - vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM" ) ); - - //=== VK_KHR_calibrated_timestamps === - vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = - PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR" ) ); - -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - vkCreateSurfaceOHOS = PFN_vkCreateSurfaceOHOS( vkGetInstanceProcAddr( instance, "vkCreateSurfaceOHOS" ) ); -# endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_NV_cooperative_matrix2 === - vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( - vkGetInstanceProcAddr( instance, "vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV" ) ); - - //=== VK_ARM_performance_counters_by_region === - vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( - vkGetInstanceProcAddr( instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM" ) ); - - vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetInstanceProcAddr( instance, "vkGetDeviceProcAddr" ) ); - } - - public: - //=== VK_VERSION_1_0 === - PFN_vkDestroyInstance vkDestroyInstance = 0; - PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = 0; - PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures = 0; - PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties = 0; - PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties = 0; - PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties = 0; - PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties = 0; - PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = 0; - PFN_vkCreateDevice vkCreateDevice = 0; - PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = 0; - PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties = 0; - - //=== VK_VERSION_1_1 === - PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups = 0; - PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2 = 0; - PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = 0; - PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2 = 0; - PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2 = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2 = 0; - PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2 = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2 = 0; - PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties = 0; - PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties = 0; - PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties = 0; - - //=== VK_VERSION_1_3 === - PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties = 0; - - //=== VK_KHR_surface === - PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR = 0; - PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR = 0; - PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR = 0; - PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR = 0; - PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR = 0; - - //=== VK_KHR_swapchain === - PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR = 0; - - //=== VK_KHR_display === - PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR = 0; - PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR = 0; - PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR = 0; - PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR = 0; - PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR = 0; - PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR = 0; - PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR = 0; - -# if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHR = 0; - PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR vkGetPhysicalDeviceXlibPresentationSupportKHR = 0; -# else - PFN_dummy vkCreateXlibSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceXlibPresentationSupportKHR_placeholder = 0; -# endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -# if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - PFN_vkCreateXcbSurfaceKHR vkCreateXcbSurfaceKHR = 0; - PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR vkGetPhysicalDeviceXcbPresentationSupportKHR = 0; -# else - PFN_dummy vkCreateXcbSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceXcbPresentationSupportKHR_placeholder = 0; -# endif /*VK_USE_PLATFORM_XCB_KHR*/ - -# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - PFN_vkCreateWaylandSurfaceKHR vkCreateWaylandSurfaceKHR = 0; - PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR vkGetPhysicalDeviceWaylandPresentationSupportKHR = 0; -# else - PFN_dummy vkCreateWaylandSurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceWaylandPresentationSupportKHR_placeholder = 0; -# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - PFN_vkCreateAndroidSurfaceKHR vkCreateAndroidSurfaceKHR = 0; -# else - PFN_dummy vkCreateAndroidSurfaceKHR_placeholder = 0; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - PFN_vkCreateWin32SurfaceKHR vkCreateWin32SurfaceKHR = 0; - PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR vkGetPhysicalDeviceWin32PresentationSupportKHR = 0; -# else - PFN_dummy vkCreateWin32SurfaceKHR_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceWin32PresentationSupportKHR_placeholder = 0; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT = 0; - PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = 0; - PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT = 0; - - //=== VK_KHR_video_queue === - PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = 0; - PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR = 0; - -# if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = 0; -# else - PFN_dummy vkCreateStreamDescriptorSurfaceGGP_placeholder = 0; -# endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV = 0; - - //=== VK_KHR_get_physical_device_properties2 === - PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR = 0; - PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR = 0; - PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR = 0; - PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR = 0; - PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR = 0; - PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = 0; - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR = 0; - -# if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - PFN_vkCreateViSurfaceNN vkCreateViSurfaceNN = 0; -# else - PFN_dummy vkCreateViSurfaceNN_placeholder = 0; -# endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_device_group_creation === - PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR = 0; - - //=== VK_KHR_external_memory_capabilities === - PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR = 0; - - //=== VK_KHR_external_semaphore_capabilities === - PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = 0; - - //=== VK_EXT_direct_mode_display === - PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT = 0; - -# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - PFN_vkAcquireXlibDisplayEXT vkAcquireXlibDisplayEXT = 0; - PFN_vkGetRandROutputDisplayEXT vkGetRandROutputDisplayEXT = 0; -# else - PFN_dummy vkAcquireXlibDisplayEXT_placeholder = 0; - PFN_dummy vkGetRandROutputDisplayEXT_placeholder = 0; -# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT = 0; - - //=== VK_KHR_external_fence_capabilities === - PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR = 0; - - //=== VK_KHR_performance_query === - PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = 0; - PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = 0; - - //=== VK_KHR_get_surface_capabilities2 === - PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR = 0; - PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR = 0; - - //=== VK_KHR_get_display_properties2 === - PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR = 0; - PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR = 0; - PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR = 0; - PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR = 0; - -# if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - PFN_vkCreateIOSSurfaceMVK vkCreateIOSSurfaceMVK = 0; -# else - PFN_dummy vkCreateIOSSurfaceMVK_placeholder = 0; -# endif /*VK_USE_PLATFORM_IOS_MVK*/ - -# if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK = 0; -# else - PFN_dummy vkCreateMacOSSurfaceMVK_placeholder = 0; -# endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = 0; - PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = 0; - PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT = 0; - - //=== VK_EXT_descriptor_heap === - PFN_vkGetPhysicalDeviceDescriptorSizeEXT vkGetPhysicalDeviceDescriptorSizeEXT = 0; - - //=== VK_EXT_sample_locations === - PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT = 0; - - //=== VK_EXT_calibrated_timestamps === - PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = 0; - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = 0; -# else - PFN_dummy vkCreateImagePipeSurfaceFUCHSIA_placeholder = 0; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - PFN_vkCreateMetalSurfaceEXT vkCreateMetalSurfaceEXT = 0; -# else - PFN_dummy vkCreateMetalSurfaceEXT_placeholder = 0; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_fragment_shading_rate === - PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR = 0; - - //=== VK_EXT_tooling_info === - PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT = 0; - - //=== VK_NV_cooperative_matrix === - PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = 0; - - //=== VK_NV_coverage_reduction_mode === - PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = 0; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT vkGetPhysicalDeviceSurfacePresentModes2EXT = 0; -# else - PFN_dummy vkGetPhysicalDeviceSurfacePresentModes2EXT_placeholder = 0; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT = 0; - - //=== VK_EXT_acquire_drm_display === - PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT = 0; - PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT = 0; - - //=== VK_KHR_video_encode_queue === - PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = 0; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - PFN_vkAcquireWinrtDisplayNV vkAcquireWinrtDisplayNV = 0; - PFN_vkGetWinrtDisplayNV vkGetWinrtDisplayNV = 0; -# else - PFN_dummy vkAcquireWinrtDisplayNV_placeholder = 0; - PFN_dummy vkGetWinrtDisplayNV_placeholder = 0; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - PFN_vkCreateDirectFBSurfaceEXT vkCreateDirectFBSurfaceEXT = 0; - PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT vkGetPhysicalDeviceDirectFBPresentationSupportEXT = 0; -# else - PFN_dummy vkCreateDirectFBSurfaceEXT_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceDirectFBPresentationSupportEXT_placeholder = 0; -# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - PFN_vkCreateScreenSurfaceQNX vkCreateScreenSurfaceQNX = 0; - PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX vkGetPhysicalDeviceScreenPresentationSupportQNX = 0; -# else - PFN_dummy vkCreateScreenSurfaceQNX_placeholder = 0; - PFN_dummy vkGetPhysicalDeviceScreenPresentationSupportQNX_placeholder = 0; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_ARM_tensors === - PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM vkGetPhysicalDeviceExternalTensorPropertiesARM = 0; - - //=== VK_NV_optical_flow === - PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV = 0; - - //=== VK_NV_cooperative_vector === - PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV vkGetPhysicalDeviceCooperativeVectorPropertiesNV = 0; - - //=== VK_KHR_cooperative_matrix === - PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = 0; - - //=== VK_ARM_data_graph === - PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = 0; - PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = 0; - - //=== VK_KHR_calibrated_timestamps === - PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = 0; - -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - PFN_vkCreateSurfaceOHOS vkCreateSurfaceOHOS = 0; -# else - PFN_dummy vkCreateSurfaceOHOS_placeholder = 0; -# endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_NV_cooperative_matrix2 === - PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = 0; - - //=== VK_ARM_performance_counters_by_region === - PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = 0; - - PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; - }; - - class DeviceDispatcher : public ::VULKAN_HPP_NAMESPACE::detail::DispatchLoaderBase - { - public: - DeviceDispatcher( PFN_vkGetDeviceProcAddr getProcAddr, VkDevice device ) : vkGetDeviceProcAddr( getProcAddr ) - { - //=== VK_VERSION_1_0 === - vkGetDeviceProcAddr = PFN_vkGetDeviceProcAddr( vkGetDeviceProcAddr( device, "vkGetDeviceProcAddr" ) ); - vkDestroyDevice = PFN_vkDestroyDevice( vkGetDeviceProcAddr( device, "vkDestroyDevice" ) ); - vkGetDeviceQueue = PFN_vkGetDeviceQueue( vkGetDeviceProcAddr( device, "vkGetDeviceQueue" ) ); - vkQueueSubmit = PFN_vkQueueSubmit( vkGetDeviceProcAddr( device, "vkQueueSubmit" ) ); - vkQueueWaitIdle = PFN_vkQueueWaitIdle( vkGetDeviceProcAddr( device, "vkQueueWaitIdle" ) ); - vkDeviceWaitIdle = PFN_vkDeviceWaitIdle( vkGetDeviceProcAddr( device, "vkDeviceWaitIdle" ) ); - vkAllocateMemory = PFN_vkAllocateMemory( vkGetDeviceProcAddr( device, "vkAllocateMemory" ) ); - vkFreeMemory = PFN_vkFreeMemory( vkGetDeviceProcAddr( device, "vkFreeMemory" ) ); - vkMapMemory = PFN_vkMapMemory( vkGetDeviceProcAddr( device, "vkMapMemory" ) ); - vkUnmapMemory = PFN_vkUnmapMemory( vkGetDeviceProcAddr( device, "vkUnmapMemory" ) ); - vkFlushMappedMemoryRanges = PFN_vkFlushMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkFlushMappedMemoryRanges" ) ); - vkInvalidateMappedMemoryRanges = PFN_vkInvalidateMappedMemoryRanges( vkGetDeviceProcAddr( device, "vkInvalidateMappedMemoryRanges" ) ); - vkGetDeviceMemoryCommitment = PFN_vkGetDeviceMemoryCommitment( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryCommitment" ) ); - vkBindBufferMemory = PFN_vkBindBufferMemory( vkGetDeviceProcAddr( device, "vkBindBufferMemory" ) ); - vkBindImageMemory = PFN_vkBindImageMemory( vkGetDeviceProcAddr( device, "vkBindImageMemory" ) ); - vkGetBufferMemoryRequirements = PFN_vkGetBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements" ) ); - vkGetImageMemoryRequirements = PFN_vkGetImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements" ) ); - vkGetImageSparseMemoryRequirements = PFN_vkGetImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements" ) ); - vkQueueBindSparse = PFN_vkQueueBindSparse( vkGetDeviceProcAddr( device, "vkQueueBindSparse" ) ); - vkCreateFence = PFN_vkCreateFence( vkGetDeviceProcAddr( device, "vkCreateFence" ) ); - vkDestroyFence = PFN_vkDestroyFence( vkGetDeviceProcAddr( device, "vkDestroyFence" ) ); - vkResetFences = PFN_vkResetFences( vkGetDeviceProcAddr( device, "vkResetFences" ) ); - vkGetFenceStatus = PFN_vkGetFenceStatus( vkGetDeviceProcAddr( device, "vkGetFenceStatus" ) ); - vkWaitForFences = PFN_vkWaitForFences( vkGetDeviceProcAddr( device, "vkWaitForFences" ) ); - vkCreateSemaphore = PFN_vkCreateSemaphore( vkGetDeviceProcAddr( device, "vkCreateSemaphore" ) ); - vkDestroySemaphore = PFN_vkDestroySemaphore( vkGetDeviceProcAddr( device, "vkDestroySemaphore" ) ); - vkCreateQueryPool = PFN_vkCreateQueryPool( vkGetDeviceProcAddr( device, "vkCreateQueryPool" ) ); - vkDestroyQueryPool = PFN_vkDestroyQueryPool( vkGetDeviceProcAddr( device, "vkDestroyQueryPool" ) ); - vkGetQueryPoolResults = PFN_vkGetQueryPoolResults( vkGetDeviceProcAddr( device, "vkGetQueryPoolResults" ) ); - vkCreateBuffer = PFN_vkCreateBuffer( vkGetDeviceProcAddr( device, "vkCreateBuffer" ) ); - vkDestroyBuffer = PFN_vkDestroyBuffer( vkGetDeviceProcAddr( device, "vkDestroyBuffer" ) ); - vkCreateImage = PFN_vkCreateImage( vkGetDeviceProcAddr( device, "vkCreateImage" ) ); - vkDestroyImage = PFN_vkDestroyImage( vkGetDeviceProcAddr( device, "vkDestroyImage" ) ); - vkGetImageSubresourceLayout = PFN_vkGetImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout" ) ); - vkCreateImageView = PFN_vkCreateImageView( vkGetDeviceProcAddr( device, "vkCreateImageView" ) ); - vkDestroyImageView = PFN_vkDestroyImageView( vkGetDeviceProcAddr( device, "vkDestroyImageView" ) ); - vkCreateCommandPool = PFN_vkCreateCommandPool( vkGetDeviceProcAddr( device, "vkCreateCommandPool" ) ); - vkDestroyCommandPool = PFN_vkDestroyCommandPool( vkGetDeviceProcAddr( device, "vkDestroyCommandPool" ) ); - vkResetCommandPool = PFN_vkResetCommandPool( vkGetDeviceProcAddr( device, "vkResetCommandPool" ) ); - vkAllocateCommandBuffers = PFN_vkAllocateCommandBuffers( vkGetDeviceProcAddr( device, "vkAllocateCommandBuffers" ) ); - vkFreeCommandBuffers = PFN_vkFreeCommandBuffers( vkGetDeviceProcAddr( device, "vkFreeCommandBuffers" ) ); - vkBeginCommandBuffer = PFN_vkBeginCommandBuffer( vkGetDeviceProcAddr( device, "vkBeginCommandBuffer" ) ); - vkEndCommandBuffer = PFN_vkEndCommandBuffer( vkGetDeviceProcAddr( device, "vkEndCommandBuffer" ) ); - vkResetCommandBuffer = PFN_vkResetCommandBuffer( vkGetDeviceProcAddr( device, "vkResetCommandBuffer" ) ); - vkCmdCopyBuffer = PFN_vkCmdCopyBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer" ) ); - vkCmdCopyImage = PFN_vkCmdCopyImage( vkGetDeviceProcAddr( device, "vkCmdCopyImage" ) ); - vkCmdCopyBufferToImage = PFN_vkCmdCopyBufferToImage( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage" ) ); - vkCmdCopyImageToBuffer = PFN_vkCmdCopyImageToBuffer( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer" ) ); - vkCmdUpdateBuffer = PFN_vkCmdUpdateBuffer( vkGetDeviceProcAddr( device, "vkCmdUpdateBuffer" ) ); - vkCmdFillBuffer = PFN_vkCmdFillBuffer( vkGetDeviceProcAddr( device, "vkCmdFillBuffer" ) ); - vkCmdPipelineBarrier = PFN_vkCmdPipelineBarrier( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier" ) ); - vkCmdBeginQuery = PFN_vkCmdBeginQuery( vkGetDeviceProcAddr( device, "vkCmdBeginQuery" ) ); - vkCmdEndQuery = PFN_vkCmdEndQuery( vkGetDeviceProcAddr( device, "vkCmdEndQuery" ) ); - vkCmdResetQueryPool = PFN_vkCmdResetQueryPool( vkGetDeviceProcAddr( device, "vkCmdResetQueryPool" ) ); - vkCmdWriteTimestamp = PFN_vkCmdWriteTimestamp( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp" ) ); - vkCmdCopyQueryPoolResults = PFN_vkCmdCopyQueryPoolResults( vkGetDeviceProcAddr( device, "vkCmdCopyQueryPoolResults" ) ); - vkCmdExecuteCommands = PFN_vkCmdExecuteCommands( vkGetDeviceProcAddr( device, "vkCmdExecuteCommands" ) ); - vkCreateEvent = PFN_vkCreateEvent( vkGetDeviceProcAddr( device, "vkCreateEvent" ) ); - vkDestroyEvent = PFN_vkDestroyEvent( vkGetDeviceProcAddr( device, "vkDestroyEvent" ) ); - vkGetEventStatus = PFN_vkGetEventStatus( vkGetDeviceProcAddr( device, "vkGetEventStatus" ) ); - vkSetEvent = PFN_vkSetEvent( vkGetDeviceProcAddr( device, "vkSetEvent" ) ); - vkResetEvent = PFN_vkResetEvent( vkGetDeviceProcAddr( device, "vkResetEvent" ) ); - vkCreateBufferView = PFN_vkCreateBufferView( vkGetDeviceProcAddr( device, "vkCreateBufferView" ) ); - vkDestroyBufferView = PFN_vkDestroyBufferView( vkGetDeviceProcAddr( device, "vkDestroyBufferView" ) ); - vkCreateShaderModule = PFN_vkCreateShaderModule( vkGetDeviceProcAddr( device, "vkCreateShaderModule" ) ); - vkDestroyShaderModule = PFN_vkDestroyShaderModule( vkGetDeviceProcAddr( device, "vkDestroyShaderModule" ) ); - vkCreatePipelineCache = PFN_vkCreatePipelineCache( vkGetDeviceProcAddr( device, "vkCreatePipelineCache" ) ); - vkDestroyPipelineCache = PFN_vkDestroyPipelineCache( vkGetDeviceProcAddr( device, "vkDestroyPipelineCache" ) ); - vkGetPipelineCacheData = PFN_vkGetPipelineCacheData( vkGetDeviceProcAddr( device, "vkGetPipelineCacheData" ) ); - vkMergePipelineCaches = PFN_vkMergePipelineCaches( vkGetDeviceProcAddr( device, "vkMergePipelineCaches" ) ); - vkCreateComputePipelines = PFN_vkCreateComputePipelines( vkGetDeviceProcAddr( device, "vkCreateComputePipelines" ) ); - vkDestroyPipeline = PFN_vkDestroyPipeline( vkGetDeviceProcAddr( device, "vkDestroyPipeline" ) ); - vkCreatePipelineLayout = PFN_vkCreatePipelineLayout( vkGetDeviceProcAddr( device, "vkCreatePipelineLayout" ) ); - vkDestroyPipelineLayout = PFN_vkDestroyPipelineLayout( vkGetDeviceProcAddr( device, "vkDestroyPipelineLayout" ) ); - vkCreateSampler = PFN_vkCreateSampler( vkGetDeviceProcAddr( device, "vkCreateSampler" ) ); - vkDestroySampler = PFN_vkDestroySampler( vkGetDeviceProcAddr( device, "vkDestroySampler" ) ); - vkCreateDescriptorSetLayout = PFN_vkCreateDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkCreateDescriptorSetLayout" ) ); - vkDestroyDescriptorSetLayout = PFN_vkDestroyDescriptorSetLayout( vkGetDeviceProcAddr( device, "vkDestroyDescriptorSetLayout" ) ); - vkCreateDescriptorPool = PFN_vkCreateDescriptorPool( vkGetDeviceProcAddr( device, "vkCreateDescriptorPool" ) ); - vkDestroyDescriptorPool = PFN_vkDestroyDescriptorPool( vkGetDeviceProcAddr( device, "vkDestroyDescriptorPool" ) ); - vkResetDescriptorPool = PFN_vkResetDescriptorPool( vkGetDeviceProcAddr( device, "vkResetDescriptorPool" ) ); - vkAllocateDescriptorSets = PFN_vkAllocateDescriptorSets( vkGetDeviceProcAddr( device, "vkAllocateDescriptorSets" ) ); - vkFreeDescriptorSets = PFN_vkFreeDescriptorSets( vkGetDeviceProcAddr( device, "vkFreeDescriptorSets" ) ); - vkUpdateDescriptorSets = PFN_vkUpdateDescriptorSets( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSets" ) ); - vkCmdBindPipeline = PFN_vkCmdBindPipeline( vkGetDeviceProcAddr( device, "vkCmdBindPipeline" ) ); - vkCmdBindDescriptorSets = PFN_vkCmdBindDescriptorSets( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets" ) ); - vkCmdClearColorImage = PFN_vkCmdClearColorImage( vkGetDeviceProcAddr( device, "vkCmdClearColorImage" ) ); - vkCmdDispatch = PFN_vkCmdDispatch( vkGetDeviceProcAddr( device, "vkCmdDispatch" ) ); - vkCmdDispatchIndirect = PFN_vkCmdDispatchIndirect( vkGetDeviceProcAddr( device, "vkCmdDispatchIndirect" ) ); - vkCmdSetEvent = PFN_vkCmdSetEvent( vkGetDeviceProcAddr( device, "vkCmdSetEvent" ) ); - vkCmdResetEvent = PFN_vkCmdResetEvent( vkGetDeviceProcAddr( device, "vkCmdResetEvent" ) ); - vkCmdWaitEvents = PFN_vkCmdWaitEvents( vkGetDeviceProcAddr( device, "vkCmdWaitEvents" ) ); - vkCmdPushConstants = PFN_vkCmdPushConstants( vkGetDeviceProcAddr( device, "vkCmdPushConstants" ) ); - vkCreateGraphicsPipelines = PFN_vkCreateGraphicsPipelines( vkGetDeviceProcAddr( device, "vkCreateGraphicsPipelines" ) ); - vkCreateFramebuffer = PFN_vkCreateFramebuffer( vkGetDeviceProcAddr( device, "vkCreateFramebuffer" ) ); - vkDestroyFramebuffer = PFN_vkDestroyFramebuffer( vkGetDeviceProcAddr( device, "vkDestroyFramebuffer" ) ); - vkCreateRenderPass = PFN_vkCreateRenderPass( vkGetDeviceProcAddr( device, "vkCreateRenderPass" ) ); - vkDestroyRenderPass = PFN_vkDestroyRenderPass( vkGetDeviceProcAddr( device, "vkDestroyRenderPass" ) ); - vkGetRenderAreaGranularity = PFN_vkGetRenderAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderAreaGranularity" ) ); - vkCmdSetViewport = PFN_vkCmdSetViewport( vkGetDeviceProcAddr( device, "vkCmdSetViewport" ) ); - vkCmdSetScissor = PFN_vkCmdSetScissor( vkGetDeviceProcAddr( device, "vkCmdSetScissor" ) ); - vkCmdSetLineWidth = PFN_vkCmdSetLineWidth( vkGetDeviceProcAddr( device, "vkCmdSetLineWidth" ) ); - vkCmdSetDepthBias = PFN_vkCmdSetDepthBias( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias" ) ); - vkCmdSetBlendConstants = PFN_vkCmdSetBlendConstants( vkGetDeviceProcAddr( device, "vkCmdSetBlendConstants" ) ); - vkCmdSetDepthBounds = PFN_vkCmdSetDepthBounds( vkGetDeviceProcAddr( device, "vkCmdSetDepthBounds" ) ); - vkCmdSetStencilCompareMask = PFN_vkCmdSetStencilCompareMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilCompareMask" ) ); - vkCmdSetStencilWriteMask = PFN_vkCmdSetStencilWriteMask( vkGetDeviceProcAddr( device, "vkCmdSetStencilWriteMask" ) ); - vkCmdSetStencilReference = PFN_vkCmdSetStencilReference( vkGetDeviceProcAddr( device, "vkCmdSetStencilReference" ) ); - vkCmdBindIndexBuffer = PFN_vkCmdBindIndexBuffer( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer" ) ); - vkCmdBindVertexBuffers = PFN_vkCmdBindVertexBuffers( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers" ) ); - vkCmdDraw = PFN_vkCmdDraw( vkGetDeviceProcAddr( device, "vkCmdDraw" ) ); - vkCmdDrawIndexed = PFN_vkCmdDrawIndexed( vkGetDeviceProcAddr( device, "vkCmdDrawIndexed" ) ); - vkCmdDrawIndirect = PFN_vkCmdDrawIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndirect" ) ); - vkCmdDrawIndexedIndirect = PFN_vkCmdDrawIndexedIndirect( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirect" ) ); - vkCmdBlitImage = PFN_vkCmdBlitImage( vkGetDeviceProcAddr( device, "vkCmdBlitImage" ) ); - vkCmdClearDepthStencilImage = PFN_vkCmdClearDepthStencilImage( vkGetDeviceProcAddr( device, "vkCmdClearDepthStencilImage" ) ); - vkCmdClearAttachments = PFN_vkCmdClearAttachments( vkGetDeviceProcAddr( device, "vkCmdClearAttachments" ) ); - vkCmdResolveImage = PFN_vkCmdResolveImage( vkGetDeviceProcAddr( device, "vkCmdResolveImage" ) ); - vkCmdBeginRenderPass = PFN_vkCmdBeginRenderPass( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass" ) ); - vkCmdNextSubpass = PFN_vkCmdNextSubpass( vkGetDeviceProcAddr( device, "vkCmdNextSubpass" ) ); - vkCmdEndRenderPass = PFN_vkCmdEndRenderPass( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass" ) ); - - //=== VK_VERSION_1_1 === - vkBindBufferMemory2 = PFN_vkBindBufferMemory2( vkGetDeviceProcAddr( device, "vkBindBufferMemory2" ) ); - vkBindImageMemory2 = PFN_vkBindImageMemory2( vkGetDeviceProcAddr( device, "vkBindImageMemory2" ) ); - vkGetDeviceGroupPeerMemoryFeatures = PFN_vkGetDeviceGroupPeerMemoryFeatures( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeatures" ) ); - vkCmdSetDeviceMask = PFN_vkCmdSetDeviceMask( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMask" ) ); - vkGetImageMemoryRequirements2 = PFN_vkGetImageMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2" ) ); - vkGetBufferMemoryRequirements2 = PFN_vkGetBufferMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2" ) ); - vkGetImageSparseMemoryRequirements2 = PFN_vkGetImageSparseMemoryRequirements2( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2" ) ); - vkTrimCommandPool = PFN_vkTrimCommandPool( vkGetDeviceProcAddr( device, "vkTrimCommandPool" ) ); - vkGetDeviceQueue2 = PFN_vkGetDeviceQueue2( vkGetDeviceProcAddr( device, "vkGetDeviceQueue2" ) ); - vkCmdDispatchBase = PFN_vkCmdDispatchBase( vkGetDeviceProcAddr( device, "vkCmdDispatchBase" ) ); - vkCreateDescriptorUpdateTemplate = PFN_vkCreateDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplate" ) ); - vkDestroyDescriptorUpdateTemplate = PFN_vkDestroyDescriptorUpdateTemplate( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplate" ) ); - vkUpdateDescriptorSetWithTemplate = PFN_vkUpdateDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplate" ) ); - vkGetDescriptorSetLayoutSupport = PFN_vkGetDescriptorSetLayoutSupport( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupport" ) ); - vkCreateSamplerYcbcrConversion = PFN_vkCreateSamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversion" ) ); - vkDestroySamplerYcbcrConversion = PFN_vkDestroySamplerYcbcrConversion( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversion" ) ); - - //=== VK_VERSION_1_2 === - vkResetQueryPool = PFN_vkResetQueryPool( vkGetDeviceProcAddr( device, "vkResetQueryPool" ) ); - vkGetSemaphoreCounterValue = PFN_vkGetSemaphoreCounterValue( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValue" ) ); - vkWaitSemaphores = PFN_vkWaitSemaphores( vkGetDeviceProcAddr( device, "vkWaitSemaphores" ) ); - vkSignalSemaphore = PFN_vkSignalSemaphore( vkGetDeviceProcAddr( device, "vkSignalSemaphore" ) ); - vkGetBufferDeviceAddress = PFN_vkGetBufferDeviceAddress( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddress" ) ); - vkGetBufferOpaqueCaptureAddress = PFN_vkGetBufferOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddress" ) ); - vkGetDeviceMemoryOpaqueCaptureAddress = - PFN_vkGetDeviceMemoryOpaqueCaptureAddress( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddress" ) ); - vkCmdDrawIndirectCount = PFN_vkCmdDrawIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCount" ) ); - vkCmdDrawIndexedIndirectCount = PFN_vkCmdDrawIndexedIndirectCount( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCount" ) ); - vkCreateRenderPass2 = PFN_vkCreateRenderPass2( vkGetDeviceProcAddr( device, "vkCreateRenderPass2" ) ); - vkCmdBeginRenderPass2 = PFN_vkCmdBeginRenderPass2( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2" ) ); - vkCmdNextSubpass2 = PFN_vkCmdNextSubpass2( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2" ) ); - vkCmdEndRenderPass2 = PFN_vkCmdEndRenderPass2( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2" ) ); - - //=== VK_VERSION_1_3 === - vkCreatePrivateDataSlot = PFN_vkCreatePrivateDataSlot( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlot" ) ); - vkDestroyPrivateDataSlot = PFN_vkDestroyPrivateDataSlot( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlot" ) ); - vkSetPrivateData = PFN_vkSetPrivateData( vkGetDeviceProcAddr( device, "vkSetPrivateData" ) ); - vkGetPrivateData = PFN_vkGetPrivateData( vkGetDeviceProcAddr( device, "vkGetPrivateData" ) ); - vkCmdPipelineBarrier2 = PFN_vkCmdPipelineBarrier2( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2" ) ); - vkCmdWriteTimestamp2 = PFN_vkCmdWriteTimestamp2( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2" ) ); - vkQueueSubmit2 = PFN_vkQueueSubmit2( vkGetDeviceProcAddr( device, "vkQueueSubmit2" ) ); - vkCmdCopyBuffer2 = PFN_vkCmdCopyBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2" ) ); - vkCmdCopyImage2 = PFN_vkCmdCopyImage2( vkGetDeviceProcAddr( device, "vkCmdCopyImage2" ) ); - vkCmdCopyBufferToImage2 = PFN_vkCmdCopyBufferToImage2( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2" ) ); - vkCmdCopyImageToBuffer2 = PFN_vkCmdCopyImageToBuffer2( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2" ) ); - vkGetDeviceBufferMemoryRequirements = PFN_vkGetDeviceBufferMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirements" ) ); - vkGetDeviceImageMemoryRequirements = PFN_vkGetDeviceImageMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirements" ) ); - vkGetDeviceImageSparseMemoryRequirements = - PFN_vkGetDeviceImageSparseMemoryRequirements( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirements" ) ); - vkCmdSetEvent2 = PFN_vkCmdSetEvent2( vkGetDeviceProcAddr( device, "vkCmdSetEvent2" ) ); - vkCmdResetEvent2 = PFN_vkCmdResetEvent2( vkGetDeviceProcAddr( device, "vkCmdResetEvent2" ) ); - vkCmdWaitEvents2 = PFN_vkCmdWaitEvents2( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2" ) ); - vkCmdBlitImage2 = PFN_vkCmdBlitImage2( vkGetDeviceProcAddr( device, "vkCmdBlitImage2" ) ); - vkCmdResolveImage2 = PFN_vkCmdResolveImage2( vkGetDeviceProcAddr( device, "vkCmdResolveImage2" ) ); - vkCmdBeginRendering = PFN_vkCmdBeginRendering( vkGetDeviceProcAddr( device, "vkCmdBeginRendering" ) ); - vkCmdEndRendering = PFN_vkCmdEndRendering( vkGetDeviceProcAddr( device, "vkCmdEndRendering" ) ); - vkCmdSetCullMode = PFN_vkCmdSetCullMode( vkGetDeviceProcAddr( device, "vkCmdSetCullMode" ) ); - vkCmdSetFrontFace = PFN_vkCmdSetFrontFace( vkGetDeviceProcAddr( device, "vkCmdSetFrontFace" ) ); - vkCmdSetPrimitiveTopology = PFN_vkCmdSetPrimitiveTopology( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopology" ) ); - vkCmdSetViewportWithCount = PFN_vkCmdSetViewportWithCount( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCount" ) ); - vkCmdSetScissorWithCount = PFN_vkCmdSetScissorWithCount( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCount" ) ); - vkCmdBindVertexBuffers2 = PFN_vkCmdBindVertexBuffers2( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2" ) ); - vkCmdSetDepthTestEnable = PFN_vkCmdSetDepthTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnable" ) ); - vkCmdSetDepthWriteEnable = PFN_vkCmdSetDepthWriteEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnable" ) ); - vkCmdSetDepthCompareOp = PFN_vkCmdSetDepthCompareOp( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOp" ) ); - vkCmdSetDepthBoundsTestEnable = PFN_vkCmdSetDepthBoundsTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnable" ) ); - vkCmdSetStencilTestEnable = PFN_vkCmdSetStencilTestEnable( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnable" ) ); - vkCmdSetStencilOp = PFN_vkCmdSetStencilOp( vkGetDeviceProcAddr( device, "vkCmdSetStencilOp" ) ); - vkCmdSetRasterizerDiscardEnable = PFN_vkCmdSetRasterizerDiscardEnable( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnable" ) ); - vkCmdSetDepthBiasEnable = PFN_vkCmdSetDepthBiasEnable( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnable" ) ); - vkCmdSetPrimitiveRestartEnable = PFN_vkCmdSetPrimitiveRestartEnable( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnable" ) ); - - //=== VK_VERSION_1_4 === - vkMapMemory2 = PFN_vkMapMemory2( vkGetDeviceProcAddr( device, "vkMapMemory2" ) ); - vkUnmapMemory2 = PFN_vkUnmapMemory2( vkGetDeviceProcAddr( device, "vkUnmapMemory2" ) ); - vkGetDeviceImageSubresourceLayout = PFN_vkGetDeviceImageSubresourceLayout( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayout" ) ); - vkGetImageSubresourceLayout2 = PFN_vkGetImageSubresourceLayout2( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2" ) ); - vkCopyMemoryToImage = PFN_vkCopyMemoryToImage( vkGetDeviceProcAddr( device, "vkCopyMemoryToImage" ) ); - vkCopyImageToMemory = PFN_vkCopyImageToMemory( vkGetDeviceProcAddr( device, "vkCopyImageToMemory" ) ); - vkCopyImageToImage = PFN_vkCopyImageToImage( vkGetDeviceProcAddr( device, "vkCopyImageToImage" ) ); - vkTransitionImageLayout = PFN_vkTransitionImageLayout( vkGetDeviceProcAddr( device, "vkTransitionImageLayout" ) ); - vkCmdPushDescriptorSet = PFN_vkCmdPushDescriptorSet( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet" ) ); - vkCmdPushDescriptorSetWithTemplate = PFN_vkCmdPushDescriptorSetWithTemplate( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate" ) ); - vkCmdBindDescriptorSets2 = PFN_vkCmdBindDescriptorSets2( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2" ) ); - vkCmdPushConstants2 = PFN_vkCmdPushConstants2( vkGetDeviceProcAddr( device, "vkCmdPushConstants2" ) ); - vkCmdPushDescriptorSet2 = PFN_vkCmdPushDescriptorSet2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2" ) ); - vkCmdPushDescriptorSetWithTemplate2 = PFN_vkCmdPushDescriptorSetWithTemplate2( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2" ) ); - vkCmdSetLineStipple = PFN_vkCmdSetLineStipple( vkGetDeviceProcAddr( device, "vkCmdSetLineStipple" ) ); - vkCmdBindIndexBuffer2 = PFN_vkCmdBindIndexBuffer2( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2" ) ); - vkGetRenderingAreaGranularity = PFN_vkGetRenderingAreaGranularity( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularity" ) ); - vkCmdSetRenderingAttachmentLocations = - PFN_vkCmdSetRenderingAttachmentLocations( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocations" ) ); - vkCmdSetRenderingInputAttachmentIndices = - PFN_vkCmdSetRenderingInputAttachmentIndices( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndices" ) ); - - //=== VK_KHR_swapchain === - vkCreateSwapchainKHR = PFN_vkCreateSwapchainKHR( vkGetDeviceProcAddr( device, "vkCreateSwapchainKHR" ) ); - vkDestroySwapchainKHR = PFN_vkDestroySwapchainKHR( vkGetDeviceProcAddr( device, "vkDestroySwapchainKHR" ) ); - vkGetSwapchainImagesKHR = PFN_vkGetSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainImagesKHR" ) ); - vkAcquireNextImageKHR = PFN_vkAcquireNextImageKHR( vkGetDeviceProcAddr( device, "vkAcquireNextImageKHR" ) ); - vkQueuePresentKHR = PFN_vkQueuePresentKHR( vkGetDeviceProcAddr( device, "vkQueuePresentKHR" ) ); - vkGetDeviceGroupPresentCapabilitiesKHR = - PFN_vkGetDeviceGroupPresentCapabilitiesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPresentCapabilitiesKHR" ) ); - vkGetDeviceGroupSurfacePresentModesKHR = - PFN_vkGetDeviceGroupSurfacePresentModesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModesKHR" ) ); - vkAcquireNextImage2KHR = PFN_vkAcquireNextImage2KHR( vkGetDeviceProcAddr( device, "vkAcquireNextImage2KHR" ) ); - - //=== VK_KHR_display_swapchain === - vkCreateSharedSwapchainsKHR = PFN_vkCreateSharedSwapchainsKHR( vkGetDeviceProcAddr( device, "vkCreateSharedSwapchainsKHR" ) ); - - //=== VK_EXT_debug_marker === - vkDebugMarkerSetObjectTagEXT = PFN_vkDebugMarkerSetObjectTagEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectTagEXT" ) ); - vkDebugMarkerSetObjectNameEXT = PFN_vkDebugMarkerSetObjectNameEXT( vkGetDeviceProcAddr( device, "vkDebugMarkerSetObjectNameEXT" ) ); - vkCmdDebugMarkerBeginEXT = PFN_vkCmdDebugMarkerBeginEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerBeginEXT" ) ); - vkCmdDebugMarkerEndEXT = PFN_vkCmdDebugMarkerEndEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerEndEXT" ) ); - vkCmdDebugMarkerInsertEXT = PFN_vkCmdDebugMarkerInsertEXT( vkGetDeviceProcAddr( device, "vkCmdDebugMarkerInsertEXT" ) ); - - //=== VK_KHR_video_queue === - vkCreateVideoSessionKHR = PFN_vkCreateVideoSessionKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionKHR" ) ); - vkDestroyVideoSessionKHR = PFN_vkDestroyVideoSessionKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionKHR" ) ); - vkGetVideoSessionMemoryRequirementsKHR = - PFN_vkGetVideoSessionMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetVideoSessionMemoryRequirementsKHR" ) ); - vkBindVideoSessionMemoryKHR = PFN_vkBindVideoSessionMemoryKHR( vkGetDeviceProcAddr( device, "vkBindVideoSessionMemoryKHR" ) ); - vkCreateVideoSessionParametersKHR = PFN_vkCreateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkCreateVideoSessionParametersKHR" ) ); - vkUpdateVideoSessionParametersKHR = PFN_vkUpdateVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkUpdateVideoSessionParametersKHR" ) ); - vkDestroyVideoSessionParametersKHR = PFN_vkDestroyVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkDestroyVideoSessionParametersKHR" ) ); - vkCmdBeginVideoCodingKHR = PFN_vkCmdBeginVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginVideoCodingKHR" ) ); - vkCmdEndVideoCodingKHR = PFN_vkCmdEndVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdEndVideoCodingKHR" ) ); - vkCmdControlVideoCodingKHR = PFN_vkCmdControlVideoCodingKHR( vkGetDeviceProcAddr( device, "vkCmdControlVideoCodingKHR" ) ); - - //=== VK_KHR_video_decode_queue === - vkCmdDecodeVideoKHR = PFN_vkCmdDecodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdDecodeVideoKHR" ) ); - - //=== VK_EXT_transform_feedback === - vkCmdBindTransformFeedbackBuffersEXT = - PFN_vkCmdBindTransformFeedbackBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindTransformFeedbackBuffersEXT" ) ); - vkCmdBeginTransformFeedbackEXT = PFN_vkCmdBeginTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdBeginTransformFeedbackEXT" ) ); - vkCmdEndTransformFeedbackEXT = PFN_vkCmdEndTransformFeedbackEXT( vkGetDeviceProcAddr( device, "vkCmdEndTransformFeedbackEXT" ) ); - vkCmdBeginQueryIndexedEXT = PFN_vkCmdBeginQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdBeginQueryIndexedEXT" ) ); - vkCmdEndQueryIndexedEXT = PFN_vkCmdEndQueryIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdEndQueryIndexedEXT" ) ); - vkCmdDrawIndirectByteCountEXT = PFN_vkCmdDrawIndirectByteCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectByteCountEXT" ) ); - - //=== VK_NVX_binary_import === - vkCreateCuModuleNVX = PFN_vkCreateCuModuleNVX( vkGetDeviceProcAddr( device, "vkCreateCuModuleNVX" ) ); - vkCreateCuFunctionNVX = PFN_vkCreateCuFunctionNVX( vkGetDeviceProcAddr( device, "vkCreateCuFunctionNVX" ) ); - vkDestroyCuModuleNVX = PFN_vkDestroyCuModuleNVX( vkGetDeviceProcAddr( device, "vkDestroyCuModuleNVX" ) ); - vkDestroyCuFunctionNVX = PFN_vkDestroyCuFunctionNVX( vkGetDeviceProcAddr( device, "vkDestroyCuFunctionNVX" ) ); - vkCmdCuLaunchKernelNVX = PFN_vkCmdCuLaunchKernelNVX( vkGetDeviceProcAddr( device, "vkCmdCuLaunchKernelNVX" ) ); - - //=== VK_NVX_image_view_handle === - vkGetImageViewHandleNVX = PFN_vkGetImageViewHandleNVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandleNVX" ) ); - vkGetImageViewHandle64NVX = PFN_vkGetImageViewHandle64NVX( vkGetDeviceProcAddr( device, "vkGetImageViewHandle64NVX" ) ); - vkGetImageViewAddressNVX = PFN_vkGetImageViewAddressNVX( vkGetDeviceProcAddr( device, "vkGetImageViewAddressNVX" ) ); - vkGetDeviceCombinedImageSamplerIndexNVX = - PFN_vkGetDeviceCombinedImageSamplerIndexNVX( vkGetDeviceProcAddr( device, "vkGetDeviceCombinedImageSamplerIndexNVX" ) ); - - //=== VK_AMD_draw_indirect_count === - vkCmdDrawIndirectCountAMD = PFN_vkCmdDrawIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountAMD" ) ); - if ( !vkCmdDrawIndirectCount ) - vkCmdDrawIndirectCount = vkCmdDrawIndirectCountAMD; - vkCmdDrawIndexedIndirectCountAMD = PFN_vkCmdDrawIndexedIndirectCountAMD( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountAMD" ) ); - if ( !vkCmdDrawIndexedIndirectCount ) - vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountAMD; - - //=== VK_AMD_shader_info === - vkGetShaderInfoAMD = PFN_vkGetShaderInfoAMD( vkGetDeviceProcAddr( device, "vkGetShaderInfoAMD" ) ); - - //=== VK_KHR_dynamic_rendering === - vkCmdBeginRenderingKHR = PFN_vkCmdBeginRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderingKHR" ) ); - if ( !vkCmdBeginRendering ) - vkCmdBeginRendering = vkCmdBeginRenderingKHR; - vkCmdEndRenderingKHR = PFN_vkCmdEndRenderingKHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderingKHR" ) ); - if ( !vkCmdEndRendering ) - vkCmdEndRendering = vkCmdEndRenderingKHR; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - vkGetMemoryWin32HandleNV = PFN_vkGetMemoryWin32HandleNV( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleNV" ) ); -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_device_group === - vkGetDeviceGroupPeerMemoryFeaturesKHR = - PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR( vkGetDeviceProcAddr( device, "vkGetDeviceGroupPeerMemoryFeaturesKHR" ) ); - if ( !vkGetDeviceGroupPeerMemoryFeatures ) - vkGetDeviceGroupPeerMemoryFeatures = vkGetDeviceGroupPeerMemoryFeaturesKHR; - vkCmdSetDeviceMaskKHR = PFN_vkCmdSetDeviceMaskKHR( vkGetDeviceProcAddr( device, "vkCmdSetDeviceMaskKHR" ) ); - if ( !vkCmdSetDeviceMask ) - vkCmdSetDeviceMask = vkCmdSetDeviceMaskKHR; - vkCmdDispatchBaseKHR = PFN_vkCmdDispatchBaseKHR( vkGetDeviceProcAddr( device, "vkCmdDispatchBaseKHR" ) ); - if ( !vkCmdDispatchBase ) - vkCmdDispatchBase = vkCmdDispatchBaseKHR; - - //=== VK_KHR_maintenance1 === - vkTrimCommandPoolKHR = PFN_vkTrimCommandPoolKHR( vkGetDeviceProcAddr( device, "vkTrimCommandPoolKHR" ) ); - if ( !vkTrimCommandPool ) - vkTrimCommandPool = vkTrimCommandPoolKHR; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - vkGetMemoryWin32HandleKHR = PFN_vkGetMemoryWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandleKHR" ) ); - vkGetMemoryWin32HandlePropertiesKHR = PFN_vkGetMemoryWin32HandlePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryWin32HandlePropertiesKHR" ) ); -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - vkGetMemoryFdKHR = PFN_vkGetMemoryFdKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdKHR" ) ); - vkGetMemoryFdPropertiesKHR = PFN_vkGetMemoryFdPropertiesKHR( vkGetDeviceProcAddr( device, "vkGetMemoryFdPropertiesKHR" ) ); - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - vkImportSemaphoreWin32HandleKHR = PFN_vkImportSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreWin32HandleKHR" ) ); - vkGetSemaphoreWin32HandleKHR = PFN_vkGetSemaphoreWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreWin32HandleKHR" ) ); -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - vkImportSemaphoreFdKHR = PFN_vkImportSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkImportSemaphoreFdKHR" ) ); - vkGetSemaphoreFdKHR = PFN_vkGetSemaphoreFdKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreFdKHR" ) ); - - //=== VK_KHR_push_descriptor === - vkCmdPushDescriptorSetKHR = PFN_vkCmdPushDescriptorSetKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetKHR" ) ); - if ( !vkCmdPushDescriptorSet ) - vkCmdPushDescriptorSet = vkCmdPushDescriptorSetKHR; - vkCmdPushDescriptorSetWithTemplateKHR = - PFN_vkCmdPushDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplateKHR" ) ); - if ( !vkCmdPushDescriptorSetWithTemplate ) - vkCmdPushDescriptorSetWithTemplate = vkCmdPushDescriptorSetWithTemplateKHR; - - //=== VK_EXT_conditional_rendering === - vkCmdBeginConditionalRenderingEXT = PFN_vkCmdBeginConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdBeginConditionalRenderingEXT" ) ); - vkCmdEndConditionalRenderingEXT = PFN_vkCmdEndConditionalRenderingEXT( vkGetDeviceProcAddr( device, "vkCmdEndConditionalRenderingEXT" ) ); - - //=== VK_KHR_descriptor_update_template === - vkCreateDescriptorUpdateTemplateKHR = PFN_vkCreateDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkCreateDescriptorUpdateTemplateKHR" ) ); - if ( !vkCreateDescriptorUpdateTemplate ) - vkCreateDescriptorUpdateTemplate = vkCreateDescriptorUpdateTemplateKHR; - vkDestroyDescriptorUpdateTemplateKHR = - PFN_vkDestroyDescriptorUpdateTemplateKHR( vkGetDeviceProcAddr( device, "vkDestroyDescriptorUpdateTemplateKHR" ) ); - if ( !vkDestroyDescriptorUpdateTemplate ) - vkDestroyDescriptorUpdateTemplate = vkDestroyDescriptorUpdateTemplateKHR; - vkUpdateDescriptorSetWithTemplateKHR = - PFN_vkUpdateDescriptorSetWithTemplateKHR( vkGetDeviceProcAddr( device, "vkUpdateDescriptorSetWithTemplateKHR" ) ); - if ( !vkUpdateDescriptorSetWithTemplate ) - vkUpdateDescriptorSetWithTemplate = vkUpdateDescriptorSetWithTemplateKHR; - - //=== VK_NV_clip_space_w_scaling === - vkCmdSetViewportWScalingNV = PFN_vkCmdSetViewportWScalingNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingNV" ) ); - - //=== VK_EXT_display_control === - vkDisplayPowerControlEXT = PFN_vkDisplayPowerControlEXT( vkGetDeviceProcAddr( device, "vkDisplayPowerControlEXT" ) ); - vkRegisterDeviceEventEXT = PFN_vkRegisterDeviceEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDeviceEventEXT" ) ); - vkRegisterDisplayEventEXT = PFN_vkRegisterDisplayEventEXT( vkGetDeviceProcAddr( device, "vkRegisterDisplayEventEXT" ) ); - vkGetSwapchainCounterEXT = PFN_vkGetSwapchainCounterEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainCounterEXT" ) ); - - //=== VK_GOOGLE_display_timing === - vkGetRefreshCycleDurationGOOGLE = PFN_vkGetRefreshCycleDurationGOOGLE( vkGetDeviceProcAddr( device, "vkGetRefreshCycleDurationGOOGLE" ) ); - vkGetPastPresentationTimingGOOGLE = PFN_vkGetPastPresentationTimingGOOGLE( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingGOOGLE" ) ); - - //=== VK_EXT_discard_rectangles === - vkCmdSetDiscardRectangleEXT = PFN_vkCmdSetDiscardRectangleEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEXT" ) ); - vkCmdSetDiscardRectangleEnableEXT = PFN_vkCmdSetDiscardRectangleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleEnableEXT" ) ); - vkCmdSetDiscardRectangleModeEXT = PFN_vkCmdSetDiscardRectangleModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDiscardRectangleModeEXT" ) ); - - //=== VK_EXT_hdr_metadata === - vkSetHdrMetadataEXT = PFN_vkSetHdrMetadataEXT( vkGetDeviceProcAddr( device, "vkSetHdrMetadataEXT" ) ); - - //=== VK_KHR_create_renderpass2 === - vkCreateRenderPass2KHR = PFN_vkCreateRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCreateRenderPass2KHR" ) ); - if ( !vkCreateRenderPass2 ) - vkCreateRenderPass2 = vkCreateRenderPass2KHR; - vkCmdBeginRenderPass2KHR = PFN_vkCmdBeginRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdBeginRenderPass2KHR" ) ); - if ( !vkCmdBeginRenderPass2 ) - vkCmdBeginRenderPass2 = vkCmdBeginRenderPass2KHR; - vkCmdNextSubpass2KHR = PFN_vkCmdNextSubpass2KHR( vkGetDeviceProcAddr( device, "vkCmdNextSubpass2KHR" ) ); - if ( !vkCmdNextSubpass2 ) - vkCmdNextSubpass2 = vkCmdNextSubpass2KHR; - vkCmdEndRenderPass2KHR = PFN_vkCmdEndRenderPass2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRenderPass2KHR" ) ); - if ( !vkCmdEndRenderPass2 ) - vkCmdEndRenderPass2 = vkCmdEndRenderPass2KHR; - - //=== VK_KHR_shared_presentable_image === - vkGetSwapchainStatusKHR = PFN_vkGetSwapchainStatusKHR( vkGetDeviceProcAddr( device, "vkGetSwapchainStatusKHR" ) ); - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - vkImportFenceWin32HandleKHR = PFN_vkImportFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkImportFenceWin32HandleKHR" ) ); - vkGetFenceWin32HandleKHR = PFN_vkGetFenceWin32HandleKHR( vkGetDeviceProcAddr( device, "vkGetFenceWin32HandleKHR" ) ); -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - vkImportFenceFdKHR = PFN_vkImportFenceFdKHR( vkGetDeviceProcAddr( device, "vkImportFenceFdKHR" ) ); - vkGetFenceFdKHR = PFN_vkGetFenceFdKHR( vkGetDeviceProcAddr( device, "vkGetFenceFdKHR" ) ); - - //=== VK_KHR_performance_query === - vkAcquireProfilingLockKHR = PFN_vkAcquireProfilingLockKHR( vkGetDeviceProcAddr( device, "vkAcquireProfilingLockKHR" ) ); - vkReleaseProfilingLockKHR = PFN_vkReleaseProfilingLockKHR( vkGetDeviceProcAddr( device, "vkReleaseProfilingLockKHR" ) ); - - //=== VK_EXT_debug_utils === - vkSetDebugUtilsObjectNameEXT = PFN_vkSetDebugUtilsObjectNameEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectNameEXT" ) ); - vkSetDebugUtilsObjectTagEXT = PFN_vkSetDebugUtilsObjectTagEXT( vkGetDeviceProcAddr( device, "vkSetDebugUtilsObjectTagEXT" ) ); - vkQueueBeginDebugUtilsLabelEXT = PFN_vkQueueBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueBeginDebugUtilsLabelEXT" ) ); - vkQueueEndDebugUtilsLabelEXT = PFN_vkQueueEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueEndDebugUtilsLabelEXT" ) ); - vkQueueInsertDebugUtilsLabelEXT = PFN_vkQueueInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkQueueInsertDebugUtilsLabelEXT" ) ); - vkCmdBeginDebugUtilsLabelEXT = PFN_vkCmdBeginDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdBeginDebugUtilsLabelEXT" ) ); - vkCmdEndDebugUtilsLabelEXT = PFN_vkCmdEndDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdEndDebugUtilsLabelEXT" ) ); - vkCmdInsertDebugUtilsLabelEXT = PFN_vkCmdInsertDebugUtilsLabelEXT( vkGetDeviceProcAddr( device, "vkCmdInsertDebugUtilsLabelEXT" ) ); - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - vkGetAndroidHardwareBufferPropertiesANDROID = - PFN_vkGetAndroidHardwareBufferPropertiesANDROID( vkGetDeviceProcAddr( device, "vkGetAndroidHardwareBufferPropertiesANDROID" ) ); - vkGetMemoryAndroidHardwareBufferANDROID = - PFN_vkGetMemoryAndroidHardwareBufferANDROID( vkGetDeviceProcAddr( device, "vkGetMemoryAndroidHardwareBufferANDROID" ) ); -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - vkCreateExecutionGraphPipelinesAMDX = PFN_vkCreateExecutionGraphPipelinesAMDX( vkGetDeviceProcAddr( device, "vkCreateExecutionGraphPipelinesAMDX" ) ); - vkGetExecutionGraphPipelineScratchSizeAMDX = - PFN_vkGetExecutionGraphPipelineScratchSizeAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineScratchSizeAMDX" ) ); - vkGetExecutionGraphPipelineNodeIndexAMDX = - PFN_vkGetExecutionGraphPipelineNodeIndexAMDX( vkGetDeviceProcAddr( device, "vkGetExecutionGraphPipelineNodeIndexAMDX" ) ); - vkCmdInitializeGraphScratchMemoryAMDX = - PFN_vkCmdInitializeGraphScratchMemoryAMDX( vkGetDeviceProcAddr( device, "vkCmdInitializeGraphScratchMemoryAMDX" ) ); - vkCmdDispatchGraphAMDX = PFN_vkCmdDispatchGraphAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphAMDX" ) ); - vkCmdDispatchGraphIndirectAMDX = PFN_vkCmdDispatchGraphIndirectAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectAMDX" ) ); - vkCmdDispatchGraphIndirectCountAMDX = PFN_vkCmdDispatchGraphIndirectCountAMDX( vkGetDeviceProcAddr( device, "vkCmdDispatchGraphIndirectCountAMDX" ) ); -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - vkWriteSamplerDescriptorsEXT = PFN_vkWriteSamplerDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteSamplerDescriptorsEXT" ) ); - vkWriteResourceDescriptorsEXT = PFN_vkWriteResourceDescriptorsEXT( vkGetDeviceProcAddr( device, "vkWriteResourceDescriptorsEXT" ) ); - vkCmdBindSamplerHeapEXT = PFN_vkCmdBindSamplerHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindSamplerHeapEXT" ) ); - vkCmdBindResourceHeapEXT = PFN_vkCmdBindResourceHeapEXT( vkGetDeviceProcAddr( device, "vkCmdBindResourceHeapEXT" ) ); - vkCmdPushDataEXT = PFN_vkCmdPushDataEXT( vkGetDeviceProcAddr( device, "vkCmdPushDataEXT" ) ); - vkGetImageOpaqueCaptureDataEXT = PFN_vkGetImageOpaqueCaptureDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDataEXT" ) ); - vkRegisterCustomBorderColorEXT = PFN_vkRegisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkRegisterCustomBorderColorEXT" ) ); - vkUnregisterCustomBorderColorEXT = PFN_vkUnregisterCustomBorderColorEXT( vkGetDeviceProcAddr( device, "vkUnregisterCustomBorderColorEXT" ) ); - vkGetTensorOpaqueCaptureDataARM = PFN_vkGetTensorOpaqueCaptureDataARM( vkGetDeviceProcAddr( device, "vkGetTensorOpaqueCaptureDataARM" ) ); - - //=== VK_EXT_sample_locations === - vkCmdSetSampleLocationsEXT = PFN_vkCmdSetSampleLocationsEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEXT" ) ); - - //=== VK_KHR_get_memory_requirements2 === - vkGetImageMemoryRequirements2KHR = PFN_vkGetImageMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageMemoryRequirements2KHR" ) ); - if ( !vkGetImageMemoryRequirements2 ) - vkGetImageMemoryRequirements2 = vkGetImageMemoryRequirements2KHR; - vkGetBufferMemoryRequirements2KHR = PFN_vkGetBufferMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetBufferMemoryRequirements2KHR" ) ); - if ( !vkGetBufferMemoryRequirements2 ) - vkGetBufferMemoryRequirements2 = vkGetBufferMemoryRequirements2KHR; - vkGetImageSparseMemoryRequirements2KHR = - PFN_vkGetImageSparseMemoryRequirements2KHR( vkGetDeviceProcAddr( device, "vkGetImageSparseMemoryRequirements2KHR" ) ); - if ( !vkGetImageSparseMemoryRequirements2 ) - vkGetImageSparseMemoryRequirements2 = vkGetImageSparseMemoryRequirements2KHR; - - //=== VK_KHR_acceleration_structure === - vkCreateAccelerationStructureKHR = PFN_vkCreateAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureKHR" ) ); - vkDestroyAccelerationStructureKHR = PFN_vkDestroyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureKHR" ) ); - vkCmdBuildAccelerationStructuresKHR = PFN_vkCmdBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresKHR" ) ); - vkCmdBuildAccelerationStructuresIndirectKHR = - PFN_vkCmdBuildAccelerationStructuresIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructuresIndirectKHR" ) ); - vkBuildAccelerationStructuresKHR = PFN_vkBuildAccelerationStructuresKHR( vkGetDeviceProcAddr( device, "vkBuildAccelerationStructuresKHR" ) ); - vkCopyAccelerationStructureKHR = PFN_vkCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureKHR" ) ); - vkCopyAccelerationStructureToMemoryKHR = - PFN_vkCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCopyAccelerationStructureToMemoryKHR" ) ); - vkCopyMemoryToAccelerationStructureKHR = - PFN_vkCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCopyMemoryToAccelerationStructureKHR" ) ); - vkWriteAccelerationStructuresPropertiesKHR = - PFN_vkWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkWriteAccelerationStructuresPropertiesKHR" ) ); - vkCmdCopyAccelerationStructureKHR = PFN_vkCmdCopyAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureKHR" ) ); - vkCmdCopyAccelerationStructureToMemoryKHR = - PFN_vkCmdCopyAccelerationStructureToMemoryKHR( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureToMemoryKHR" ) ); - vkCmdCopyMemoryToAccelerationStructureKHR = - PFN_vkCmdCopyMemoryToAccelerationStructureKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToAccelerationStructureKHR" ) ); - vkGetAccelerationStructureDeviceAddressKHR = - PFN_vkGetAccelerationStructureDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureDeviceAddressKHR" ) ); - vkCmdWriteAccelerationStructuresPropertiesKHR = - PFN_vkCmdWriteAccelerationStructuresPropertiesKHR( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesKHR" ) ); - vkGetDeviceAccelerationStructureCompatibilityKHR = - PFN_vkGetDeviceAccelerationStructureCompatibilityKHR( vkGetDeviceProcAddr( device, "vkGetDeviceAccelerationStructureCompatibilityKHR" ) ); - vkGetAccelerationStructureBuildSizesKHR = - PFN_vkGetAccelerationStructureBuildSizesKHR( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureBuildSizesKHR" ) ); - - //=== VK_KHR_ray_tracing_pipeline === - vkCmdTraceRaysKHR = PFN_vkCmdTraceRaysKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysKHR" ) ); - vkCreateRayTracingPipelinesKHR = PFN_vkCreateRayTracingPipelinesKHR( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesKHR" ) ); - vkGetRayTracingShaderGroupHandlesKHR = - PFN_vkGetRayTracingShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesKHR" ) ); - vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = - PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR" ) ); - vkCmdTraceRaysIndirectKHR = PFN_vkCmdTraceRaysIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirectKHR" ) ); - vkGetRayTracingShaderGroupStackSizeKHR = - PFN_vkGetRayTracingShaderGroupStackSizeKHR( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupStackSizeKHR" ) ); - vkCmdSetRayTracingPipelineStackSizeKHR = - PFN_vkCmdSetRayTracingPipelineStackSizeKHR( vkGetDeviceProcAddr( device, "vkCmdSetRayTracingPipelineStackSizeKHR" ) ); - - //=== VK_KHR_sampler_ycbcr_conversion === - vkCreateSamplerYcbcrConversionKHR = PFN_vkCreateSamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkCreateSamplerYcbcrConversionKHR" ) ); - if ( !vkCreateSamplerYcbcrConversion ) - vkCreateSamplerYcbcrConversion = vkCreateSamplerYcbcrConversionKHR; - vkDestroySamplerYcbcrConversionKHR = PFN_vkDestroySamplerYcbcrConversionKHR( vkGetDeviceProcAddr( device, "vkDestroySamplerYcbcrConversionKHR" ) ); - if ( !vkDestroySamplerYcbcrConversion ) - vkDestroySamplerYcbcrConversion = vkDestroySamplerYcbcrConversionKHR; - - //=== VK_KHR_bind_memory2 === - vkBindBufferMemory2KHR = PFN_vkBindBufferMemory2KHR( vkGetDeviceProcAddr( device, "vkBindBufferMemory2KHR" ) ); - if ( !vkBindBufferMemory2 ) - vkBindBufferMemory2 = vkBindBufferMemory2KHR; - vkBindImageMemory2KHR = PFN_vkBindImageMemory2KHR( vkGetDeviceProcAddr( device, "vkBindImageMemory2KHR" ) ); - if ( !vkBindImageMemory2 ) - vkBindImageMemory2 = vkBindImageMemory2KHR; - - //=== VK_EXT_image_drm_format_modifier === - vkGetImageDrmFormatModifierPropertiesEXT = - PFN_vkGetImageDrmFormatModifierPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetImageDrmFormatModifierPropertiesEXT" ) ); - - //=== VK_EXT_validation_cache === - vkCreateValidationCacheEXT = PFN_vkCreateValidationCacheEXT( vkGetDeviceProcAddr( device, "vkCreateValidationCacheEXT" ) ); - vkDestroyValidationCacheEXT = PFN_vkDestroyValidationCacheEXT( vkGetDeviceProcAddr( device, "vkDestroyValidationCacheEXT" ) ); - vkMergeValidationCachesEXT = PFN_vkMergeValidationCachesEXT( vkGetDeviceProcAddr( device, "vkMergeValidationCachesEXT" ) ); - vkGetValidationCacheDataEXT = PFN_vkGetValidationCacheDataEXT( vkGetDeviceProcAddr( device, "vkGetValidationCacheDataEXT" ) ); - - //=== VK_NV_shading_rate_image === - vkCmdBindShadingRateImageNV = PFN_vkCmdBindShadingRateImageNV( vkGetDeviceProcAddr( device, "vkCmdBindShadingRateImageNV" ) ); - vkCmdSetViewportShadingRatePaletteNV = - PFN_vkCmdSetViewportShadingRatePaletteNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportShadingRatePaletteNV" ) ); - vkCmdSetCoarseSampleOrderNV = PFN_vkCmdSetCoarseSampleOrderNV( vkGetDeviceProcAddr( device, "vkCmdSetCoarseSampleOrderNV" ) ); - - //=== VK_NV_ray_tracing === - vkCreateAccelerationStructureNV = PFN_vkCreateAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCreateAccelerationStructureNV" ) ); - vkDestroyAccelerationStructureNV = PFN_vkDestroyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkDestroyAccelerationStructureNV" ) ); - vkGetAccelerationStructureMemoryRequirementsNV = - PFN_vkGetAccelerationStructureMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureMemoryRequirementsNV" ) ); - vkBindAccelerationStructureMemoryNV = PFN_vkBindAccelerationStructureMemoryNV( vkGetDeviceProcAddr( device, "vkBindAccelerationStructureMemoryNV" ) ); - vkCmdBuildAccelerationStructureNV = PFN_vkCmdBuildAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdBuildAccelerationStructureNV" ) ); - vkCmdCopyAccelerationStructureNV = PFN_vkCmdCopyAccelerationStructureNV( vkGetDeviceProcAddr( device, "vkCmdCopyAccelerationStructureNV" ) ); - vkCmdTraceRaysNV = PFN_vkCmdTraceRaysNV( vkGetDeviceProcAddr( device, "vkCmdTraceRaysNV" ) ); - vkCreateRayTracingPipelinesNV = PFN_vkCreateRayTracingPipelinesNV( vkGetDeviceProcAddr( device, "vkCreateRayTracingPipelinesNV" ) ); - vkGetRayTracingShaderGroupHandlesNV = PFN_vkGetRayTracingShaderGroupHandlesNV( vkGetDeviceProcAddr( device, "vkGetRayTracingShaderGroupHandlesNV" ) ); - if ( !vkGetRayTracingShaderGroupHandlesKHR ) - vkGetRayTracingShaderGroupHandlesKHR = vkGetRayTracingShaderGroupHandlesNV; - vkGetAccelerationStructureHandleNV = PFN_vkGetAccelerationStructureHandleNV( vkGetDeviceProcAddr( device, "vkGetAccelerationStructureHandleNV" ) ); - vkCmdWriteAccelerationStructuresPropertiesNV = - PFN_vkCmdWriteAccelerationStructuresPropertiesNV( vkGetDeviceProcAddr( device, "vkCmdWriteAccelerationStructuresPropertiesNV" ) ); - vkCompileDeferredNV = PFN_vkCompileDeferredNV( vkGetDeviceProcAddr( device, "vkCompileDeferredNV" ) ); - - //=== VK_KHR_maintenance3 === - vkGetDescriptorSetLayoutSupportKHR = PFN_vkGetDescriptorSetLayoutSupportKHR( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSupportKHR" ) ); - if ( !vkGetDescriptorSetLayoutSupport ) - vkGetDescriptorSetLayoutSupport = vkGetDescriptorSetLayoutSupportKHR; - - //=== VK_KHR_draw_indirect_count === - vkCmdDrawIndirectCountKHR = PFN_vkCmdDrawIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndirectCountKHR" ) ); - if ( !vkCmdDrawIndirectCount ) - vkCmdDrawIndirectCount = vkCmdDrawIndirectCountKHR; - vkCmdDrawIndexedIndirectCountKHR = PFN_vkCmdDrawIndexedIndirectCountKHR( vkGetDeviceProcAddr( device, "vkCmdDrawIndexedIndirectCountKHR" ) ); - if ( !vkCmdDrawIndexedIndirectCount ) - vkCmdDrawIndexedIndirectCount = vkCmdDrawIndexedIndirectCountKHR; - - //=== VK_EXT_external_memory_host === - vkGetMemoryHostPointerPropertiesEXT = PFN_vkGetMemoryHostPointerPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryHostPointerPropertiesEXT" ) ); - - //=== VK_AMD_buffer_marker === - vkCmdWriteBufferMarkerAMD = PFN_vkCmdWriteBufferMarkerAMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarkerAMD" ) ); - vkCmdWriteBufferMarker2AMD = PFN_vkCmdWriteBufferMarker2AMD( vkGetDeviceProcAddr( device, "vkCmdWriteBufferMarker2AMD" ) ); - - //=== VK_EXT_calibrated_timestamps === - vkGetCalibratedTimestampsEXT = PFN_vkGetCalibratedTimestampsEXT( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsEXT" ) ); - if ( !vkGetCalibratedTimestampsKHR ) - vkGetCalibratedTimestampsKHR = vkGetCalibratedTimestampsEXT; - - //=== VK_NV_mesh_shader === - vkCmdDrawMeshTasksNV = PFN_vkCmdDrawMeshTasksNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksNV" ) ); - vkCmdDrawMeshTasksIndirectNV = PFN_vkCmdDrawMeshTasksIndirectNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectNV" ) ); - vkCmdDrawMeshTasksIndirectCountNV = PFN_vkCmdDrawMeshTasksIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountNV" ) ); - - //=== VK_NV_scissor_exclusive === - vkCmdSetExclusiveScissorEnableNV = PFN_vkCmdSetExclusiveScissorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorEnableNV" ) ); - vkCmdSetExclusiveScissorNV = PFN_vkCmdSetExclusiveScissorNV( vkGetDeviceProcAddr( device, "vkCmdSetExclusiveScissorNV" ) ); - - //=== VK_NV_device_diagnostic_checkpoints === - vkCmdSetCheckpointNV = PFN_vkCmdSetCheckpointNV( vkGetDeviceProcAddr( device, "vkCmdSetCheckpointNV" ) ); - vkGetQueueCheckpointDataNV = PFN_vkGetQueueCheckpointDataNV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointDataNV" ) ); - vkGetQueueCheckpointData2NV = PFN_vkGetQueueCheckpointData2NV( vkGetDeviceProcAddr( device, "vkGetQueueCheckpointData2NV" ) ); - - //=== VK_KHR_timeline_semaphore === - vkGetSemaphoreCounterValueKHR = PFN_vkGetSemaphoreCounterValueKHR( vkGetDeviceProcAddr( device, "vkGetSemaphoreCounterValueKHR" ) ); - if ( !vkGetSemaphoreCounterValue ) - vkGetSemaphoreCounterValue = vkGetSemaphoreCounterValueKHR; - vkWaitSemaphoresKHR = PFN_vkWaitSemaphoresKHR( vkGetDeviceProcAddr( device, "vkWaitSemaphoresKHR" ) ); - if ( !vkWaitSemaphores ) - vkWaitSemaphores = vkWaitSemaphoresKHR; - vkSignalSemaphoreKHR = PFN_vkSignalSemaphoreKHR( vkGetDeviceProcAddr( device, "vkSignalSemaphoreKHR" ) ); - if ( !vkSignalSemaphore ) - vkSignalSemaphore = vkSignalSemaphoreKHR; - - //=== VK_EXT_present_timing === - vkSetSwapchainPresentTimingQueueSizeEXT = - PFN_vkSetSwapchainPresentTimingQueueSizeEXT( vkGetDeviceProcAddr( device, "vkSetSwapchainPresentTimingQueueSizeEXT" ) ); - vkGetSwapchainTimingPropertiesEXT = PFN_vkGetSwapchainTimingPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimingPropertiesEXT" ) ); - vkGetSwapchainTimeDomainPropertiesEXT = - PFN_vkGetSwapchainTimeDomainPropertiesEXT( vkGetDeviceProcAddr( device, "vkGetSwapchainTimeDomainPropertiesEXT" ) ); - vkGetPastPresentationTimingEXT = PFN_vkGetPastPresentationTimingEXT( vkGetDeviceProcAddr( device, "vkGetPastPresentationTimingEXT" ) ); - - //=== VK_INTEL_performance_query === - vkInitializePerformanceApiINTEL = PFN_vkInitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkInitializePerformanceApiINTEL" ) ); - vkUninitializePerformanceApiINTEL = PFN_vkUninitializePerformanceApiINTEL( vkGetDeviceProcAddr( device, "vkUninitializePerformanceApiINTEL" ) ); - vkCmdSetPerformanceMarkerINTEL = PFN_vkCmdSetPerformanceMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceMarkerINTEL" ) ); - vkCmdSetPerformanceStreamMarkerINTEL = - PFN_vkCmdSetPerformanceStreamMarkerINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceStreamMarkerINTEL" ) ); - vkCmdSetPerformanceOverrideINTEL = PFN_vkCmdSetPerformanceOverrideINTEL( vkGetDeviceProcAddr( device, "vkCmdSetPerformanceOverrideINTEL" ) ); - vkAcquirePerformanceConfigurationINTEL = - PFN_vkAcquirePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkAcquirePerformanceConfigurationINTEL" ) ); - vkReleasePerformanceConfigurationINTEL = - PFN_vkReleasePerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkReleasePerformanceConfigurationINTEL" ) ); - vkQueueSetPerformanceConfigurationINTEL = - PFN_vkQueueSetPerformanceConfigurationINTEL( vkGetDeviceProcAddr( device, "vkQueueSetPerformanceConfigurationINTEL" ) ); - vkGetPerformanceParameterINTEL = PFN_vkGetPerformanceParameterINTEL( vkGetDeviceProcAddr( device, "vkGetPerformanceParameterINTEL" ) ); - - //=== VK_AMD_display_native_hdr === - vkSetLocalDimmingAMD = PFN_vkSetLocalDimmingAMD( vkGetDeviceProcAddr( device, "vkSetLocalDimmingAMD" ) ); - - //=== VK_KHR_fragment_shading_rate === - vkCmdSetFragmentShadingRateKHR = PFN_vkCmdSetFragmentShadingRateKHR( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateKHR" ) ); - - //=== VK_KHR_dynamic_rendering_local_read === - vkCmdSetRenderingAttachmentLocationsKHR = - PFN_vkCmdSetRenderingAttachmentLocationsKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingAttachmentLocationsKHR" ) ); - if ( !vkCmdSetRenderingAttachmentLocations ) - vkCmdSetRenderingAttachmentLocations = vkCmdSetRenderingAttachmentLocationsKHR; - vkCmdSetRenderingInputAttachmentIndicesKHR = - PFN_vkCmdSetRenderingInputAttachmentIndicesKHR( vkGetDeviceProcAddr( device, "vkCmdSetRenderingInputAttachmentIndicesKHR" ) ); - if ( !vkCmdSetRenderingInputAttachmentIndices ) - vkCmdSetRenderingInputAttachmentIndices = vkCmdSetRenderingInputAttachmentIndicesKHR; - - //=== VK_EXT_buffer_device_address === - vkGetBufferDeviceAddressEXT = PFN_vkGetBufferDeviceAddressEXT( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressEXT" ) ); - if ( !vkGetBufferDeviceAddress ) - vkGetBufferDeviceAddress = vkGetBufferDeviceAddressEXT; - - //=== VK_KHR_present_wait === - vkWaitForPresentKHR = PFN_vkWaitForPresentKHR( vkGetDeviceProcAddr( device, "vkWaitForPresentKHR" ) ); - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - vkAcquireFullScreenExclusiveModeEXT = PFN_vkAcquireFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkAcquireFullScreenExclusiveModeEXT" ) ); - vkReleaseFullScreenExclusiveModeEXT = PFN_vkReleaseFullScreenExclusiveModeEXT( vkGetDeviceProcAddr( device, "vkReleaseFullScreenExclusiveModeEXT" ) ); - vkGetDeviceGroupSurfacePresentModes2EXT = - PFN_vkGetDeviceGroupSurfacePresentModes2EXT( vkGetDeviceProcAddr( device, "vkGetDeviceGroupSurfacePresentModes2EXT" ) ); -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_buffer_device_address === - vkGetBufferDeviceAddressKHR = PFN_vkGetBufferDeviceAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferDeviceAddressKHR" ) ); - if ( !vkGetBufferDeviceAddress ) - vkGetBufferDeviceAddress = vkGetBufferDeviceAddressKHR; - vkGetBufferOpaqueCaptureAddressKHR = PFN_vkGetBufferOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureAddressKHR" ) ); - if ( !vkGetBufferOpaqueCaptureAddress ) - vkGetBufferOpaqueCaptureAddress = vkGetBufferOpaqueCaptureAddressKHR; - vkGetDeviceMemoryOpaqueCaptureAddressKHR = - PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR( vkGetDeviceProcAddr( device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR" ) ); - if ( !vkGetDeviceMemoryOpaqueCaptureAddress ) - vkGetDeviceMemoryOpaqueCaptureAddress = vkGetDeviceMemoryOpaqueCaptureAddressKHR; - - //=== VK_EXT_line_rasterization === - vkCmdSetLineStippleEXT = PFN_vkCmdSetLineStippleEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEXT" ) ); - if ( !vkCmdSetLineStipple ) - vkCmdSetLineStipple = vkCmdSetLineStippleEXT; - - //=== VK_EXT_host_query_reset === - vkResetQueryPoolEXT = PFN_vkResetQueryPoolEXT( vkGetDeviceProcAddr( device, "vkResetQueryPoolEXT" ) ); - if ( !vkResetQueryPool ) - vkResetQueryPool = vkResetQueryPoolEXT; - - //=== VK_EXT_extended_dynamic_state === - vkCmdSetCullModeEXT = PFN_vkCmdSetCullModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetCullModeEXT" ) ); - if ( !vkCmdSetCullMode ) - vkCmdSetCullMode = vkCmdSetCullModeEXT; - vkCmdSetFrontFaceEXT = PFN_vkCmdSetFrontFaceEXT( vkGetDeviceProcAddr( device, "vkCmdSetFrontFaceEXT" ) ); - if ( !vkCmdSetFrontFace ) - vkCmdSetFrontFace = vkCmdSetFrontFaceEXT; - vkCmdSetPrimitiveTopologyEXT = PFN_vkCmdSetPrimitiveTopologyEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveTopologyEXT" ) ); - if ( !vkCmdSetPrimitiveTopology ) - vkCmdSetPrimitiveTopology = vkCmdSetPrimitiveTopologyEXT; - vkCmdSetViewportWithCountEXT = PFN_vkCmdSetViewportWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetViewportWithCountEXT" ) ); - if ( !vkCmdSetViewportWithCount ) - vkCmdSetViewportWithCount = vkCmdSetViewportWithCountEXT; - vkCmdSetScissorWithCountEXT = PFN_vkCmdSetScissorWithCountEXT( vkGetDeviceProcAddr( device, "vkCmdSetScissorWithCountEXT" ) ); - if ( !vkCmdSetScissorWithCount ) - vkCmdSetScissorWithCount = vkCmdSetScissorWithCountEXT; - vkCmdBindVertexBuffers2EXT = PFN_vkCmdBindVertexBuffers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindVertexBuffers2EXT" ) ); - if ( !vkCmdBindVertexBuffers2 ) - vkCmdBindVertexBuffers2 = vkCmdBindVertexBuffers2EXT; - vkCmdSetDepthTestEnableEXT = PFN_vkCmdSetDepthTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthTestEnableEXT" ) ); - if ( !vkCmdSetDepthTestEnable ) - vkCmdSetDepthTestEnable = vkCmdSetDepthTestEnableEXT; - vkCmdSetDepthWriteEnableEXT = PFN_vkCmdSetDepthWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthWriteEnableEXT" ) ); - if ( !vkCmdSetDepthWriteEnable ) - vkCmdSetDepthWriteEnable = vkCmdSetDepthWriteEnableEXT; - vkCmdSetDepthCompareOpEXT = PFN_vkCmdSetDepthCompareOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthCompareOpEXT" ) ); - if ( !vkCmdSetDepthCompareOp ) - vkCmdSetDepthCompareOp = vkCmdSetDepthCompareOpEXT; - vkCmdSetDepthBoundsTestEnableEXT = PFN_vkCmdSetDepthBoundsTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBoundsTestEnableEXT" ) ); - if ( !vkCmdSetDepthBoundsTestEnable ) - vkCmdSetDepthBoundsTestEnable = vkCmdSetDepthBoundsTestEnableEXT; - vkCmdSetStencilTestEnableEXT = PFN_vkCmdSetStencilTestEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilTestEnableEXT" ) ); - if ( !vkCmdSetStencilTestEnable ) - vkCmdSetStencilTestEnable = vkCmdSetStencilTestEnableEXT; - vkCmdSetStencilOpEXT = PFN_vkCmdSetStencilOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetStencilOpEXT" ) ); - if ( !vkCmdSetStencilOp ) - vkCmdSetStencilOp = vkCmdSetStencilOpEXT; - - //=== VK_KHR_deferred_host_operations === - vkCreateDeferredOperationKHR = PFN_vkCreateDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkCreateDeferredOperationKHR" ) ); - vkDestroyDeferredOperationKHR = PFN_vkDestroyDeferredOperationKHR( vkGetDeviceProcAddr( device, "vkDestroyDeferredOperationKHR" ) ); - vkGetDeferredOperationMaxConcurrencyKHR = - PFN_vkGetDeferredOperationMaxConcurrencyKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationMaxConcurrencyKHR" ) ); - vkGetDeferredOperationResultKHR = PFN_vkGetDeferredOperationResultKHR( vkGetDeviceProcAddr( device, "vkGetDeferredOperationResultKHR" ) ); - vkDeferredOperationJoinKHR = PFN_vkDeferredOperationJoinKHR( vkGetDeviceProcAddr( device, "vkDeferredOperationJoinKHR" ) ); - - //=== VK_KHR_pipeline_executable_properties === - vkGetPipelineExecutablePropertiesKHR = - PFN_vkGetPipelineExecutablePropertiesKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutablePropertiesKHR" ) ); - vkGetPipelineExecutableStatisticsKHR = - PFN_vkGetPipelineExecutableStatisticsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableStatisticsKHR" ) ); - vkGetPipelineExecutableInternalRepresentationsKHR = - PFN_vkGetPipelineExecutableInternalRepresentationsKHR( vkGetDeviceProcAddr( device, "vkGetPipelineExecutableInternalRepresentationsKHR" ) ); - - //=== VK_EXT_host_image_copy === - vkCopyMemoryToImageEXT = PFN_vkCopyMemoryToImageEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToImageEXT" ) ); - if ( !vkCopyMemoryToImage ) - vkCopyMemoryToImage = vkCopyMemoryToImageEXT; - vkCopyImageToMemoryEXT = PFN_vkCopyImageToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyImageToMemoryEXT" ) ); - if ( !vkCopyImageToMemory ) - vkCopyImageToMemory = vkCopyImageToMemoryEXT; - vkCopyImageToImageEXT = PFN_vkCopyImageToImageEXT( vkGetDeviceProcAddr( device, "vkCopyImageToImageEXT" ) ); - if ( !vkCopyImageToImage ) - vkCopyImageToImage = vkCopyImageToImageEXT; - vkTransitionImageLayoutEXT = PFN_vkTransitionImageLayoutEXT( vkGetDeviceProcAddr( device, "vkTransitionImageLayoutEXT" ) ); - if ( !vkTransitionImageLayout ) - vkTransitionImageLayout = vkTransitionImageLayoutEXT; - vkGetImageSubresourceLayout2EXT = PFN_vkGetImageSubresourceLayout2EXT( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2EXT" ) ); - if ( !vkGetImageSubresourceLayout2 ) - vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2EXT; - - //=== VK_KHR_map_memory2 === - vkMapMemory2KHR = PFN_vkMapMemory2KHR( vkGetDeviceProcAddr( device, "vkMapMemory2KHR" ) ); - if ( !vkMapMemory2 ) - vkMapMemory2 = vkMapMemory2KHR; - vkUnmapMemory2KHR = PFN_vkUnmapMemory2KHR( vkGetDeviceProcAddr( device, "vkUnmapMemory2KHR" ) ); - if ( !vkUnmapMemory2 ) - vkUnmapMemory2 = vkUnmapMemory2KHR; - - //=== VK_EXT_swapchain_maintenance1 === - vkReleaseSwapchainImagesEXT = PFN_vkReleaseSwapchainImagesEXT( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesEXT" ) ); - if ( !vkReleaseSwapchainImagesKHR ) - vkReleaseSwapchainImagesKHR = vkReleaseSwapchainImagesEXT; - - //=== VK_NV_device_generated_commands === - vkGetGeneratedCommandsMemoryRequirementsNV = - PFN_vkGetGeneratedCommandsMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsNV" ) ); - vkCmdPreprocessGeneratedCommandsNV = PFN_vkCmdPreprocessGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsNV" ) ); - vkCmdExecuteGeneratedCommandsNV = PFN_vkCmdExecuteGeneratedCommandsNV( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsNV" ) ); - vkCmdBindPipelineShaderGroupNV = PFN_vkCmdBindPipelineShaderGroupNV( vkGetDeviceProcAddr( device, "vkCmdBindPipelineShaderGroupNV" ) ); - vkCreateIndirectCommandsLayoutNV = PFN_vkCreateIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutNV" ) ); - vkDestroyIndirectCommandsLayoutNV = PFN_vkDestroyIndirectCommandsLayoutNV( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutNV" ) ); - - //=== VK_EXT_depth_bias_control === - vkCmdSetDepthBias2EXT = PFN_vkCmdSetDepthBias2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBias2EXT" ) ); - - //=== VK_EXT_private_data === - vkCreatePrivateDataSlotEXT = PFN_vkCreatePrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkCreatePrivateDataSlotEXT" ) ); - if ( !vkCreatePrivateDataSlot ) - vkCreatePrivateDataSlot = vkCreatePrivateDataSlotEXT; - vkDestroyPrivateDataSlotEXT = PFN_vkDestroyPrivateDataSlotEXT( vkGetDeviceProcAddr( device, "vkDestroyPrivateDataSlotEXT" ) ); - if ( !vkDestroyPrivateDataSlot ) - vkDestroyPrivateDataSlot = vkDestroyPrivateDataSlotEXT; - vkSetPrivateDataEXT = PFN_vkSetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkSetPrivateDataEXT" ) ); - if ( !vkSetPrivateData ) - vkSetPrivateData = vkSetPrivateDataEXT; - vkGetPrivateDataEXT = PFN_vkGetPrivateDataEXT( vkGetDeviceProcAddr( device, "vkGetPrivateDataEXT" ) ); - if ( !vkGetPrivateData ) - vkGetPrivateData = vkGetPrivateDataEXT; - - //=== VK_KHR_video_encode_queue === - vkGetEncodedVideoSessionParametersKHR = - PFN_vkGetEncodedVideoSessionParametersKHR( vkGetDeviceProcAddr( device, "vkGetEncodedVideoSessionParametersKHR" ) ); - vkCmdEncodeVideoKHR = PFN_vkCmdEncodeVideoKHR( vkGetDeviceProcAddr( device, "vkCmdEncodeVideoKHR" ) ); - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - vkCreateCudaModuleNV = PFN_vkCreateCudaModuleNV( vkGetDeviceProcAddr( device, "vkCreateCudaModuleNV" ) ); - vkGetCudaModuleCacheNV = PFN_vkGetCudaModuleCacheNV( vkGetDeviceProcAddr( device, "vkGetCudaModuleCacheNV" ) ); - vkCreateCudaFunctionNV = PFN_vkCreateCudaFunctionNV( vkGetDeviceProcAddr( device, "vkCreateCudaFunctionNV" ) ); - vkDestroyCudaModuleNV = PFN_vkDestroyCudaModuleNV( vkGetDeviceProcAddr( device, "vkDestroyCudaModuleNV" ) ); - vkDestroyCudaFunctionNV = PFN_vkDestroyCudaFunctionNV( vkGetDeviceProcAddr( device, "vkDestroyCudaFunctionNV" ) ); - vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetDeviceProcAddr( device, "vkCmdCudaLaunchKernelNV" ) ); -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - vkCmdDispatchTileQCOM = PFN_vkCmdDispatchTileQCOM( vkGetDeviceProcAddr( device, "vkCmdDispatchTileQCOM" ) ); - vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdBeginPerTileExecutionQCOM" ) ); - vkCmdEndPerTileExecutionQCOM = PFN_vkCmdEndPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdEndPerTileExecutionQCOM" ) ); - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) ); -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_synchronization2 === - vkCmdSetEvent2KHR = PFN_vkCmdSetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdSetEvent2KHR" ) ); - if ( !vkCmdSetEvent2 ) - vkCmdSetEvent2 = vkCmdSetEvent2KHR; - vkCmdResetEvent2KHR = PFN_vkCmdResetEvent2KHR( vkGetDeviceProcAddr( device, "vkCmdResetEvent2KHR" ) ); - if ( !vkCmdResetEvent2 ) - vkCmdResetEvent2 = vkCmdResetEvent2KHR; - vkCmdWaitEvents2KHR = PFN_vkCmdWaitEvents2KHR( vkGetDeviceProcAddr( device, "vkCmdWaitEvents2KHR" ) ); - if ( !vkCmdWaitEvents2 ) - vkCmdWaitEvents2 = vkCmdWaitEvents2KHR; - vkCmdPipelineBarrier2KHR = PFN_vkCmdPipelineBarrier2KHR( vkGetDeviceProcAddr( device, "vkCmdPipelineBarrier2KHR" ) ); - if ( !vkCmdPipelineBarrier2 ) - vkCmdPipelineBarrier2 = vkCmdPipelineBarrier2KHR; - vkCmdWriteTimestamp2KHR = PFN_vkCmdWriteTimestamp2KHR( vkGetDeviceProcAddr( device, "vkCmdWriteTimestamp2KHR" ) ); - if ( !vkCmdWriteTimestamp2 ) - vkCmdWriteTimestamp2 = vkCmdWriteTimestamp2KHR; - vkQueueSubmit2KHR = PFN_vkQueueSubmit2KHR( vkGetDeviceProcAddr( device, "vkQueueSubmit2KHR" ) ); - if ( !vkQueueSubmit2 ) - vkQueueSubmit2 = vkQueueSubmit2KHR; - - //=== VK_EXT_descriptor_buffer === - vkGetDescriptorSetLayoutSizeEXT = PFN_vkGetDescriptorSetLayoutSizeEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutSizeEXT" ) ); - vkGetDescriptorSetLayoutBindingOffsetEXT = - PFN_vkGetDescriptorSetLayoutBindingOffsetEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutBindingOffsetEXT" ) ); - vkGetDescriptorEXT = PFN_vkGetDescriptorEXT( vkGetDeviceProcAddr( device, "vkGetDescriptorEXT" ) ); - vkCmdBindDescriptorBuffersEXT = PFN_vkCmdBindDescriptorBuffersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBuffersEXT" ) ); - vkCmdSetDescriptorBufferOffsetsEXT = PFN_vkCmdSetDescriptorBufferOffsetsEXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsetsEXT" ) ); - vkCmdBindDescriptorBufferEmbeddedSamplersEXT = - PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT" ) ); - vkGetBufferOpaqueCaptureDescriptorDataEXT = - PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetBufferOpaqueCaptureDescriptorDataEXT" ) ); - vkGetImageOpaqueCaptureDescriptorDataEXT = - PFN_vkGetImageOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageOpaqueCaptureDescriptorDataEXT" ) ); - vkGetImageViewOpaqueCaptureDescriptorDataEXT = - PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT" ) ); - vkGetSamplerOpaqueCaptureDescriptorDataEXT = - PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT( vkGetDeviceProcAddr( device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT" ) ); - vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( - vkGetDeviceProcAddr( device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT" ) ); - - //=== VK_NV_fragment_shading_rate_enums === - vkCmdSetFragmentShadingRateEnumNV = PFN_vkCmdSetFragmentShadingRateEnumNV( vkGetDeviceProcAddr( device, "vkCmdSetFragmentShadingRateEnumNV" ) ); - - //=== VK_EXT_mesh_shader === - vkCmdDrawMeshTasksEXT = PFN_vkCmdDrawMeshTasksEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksEXT" ) ); - vkCmdDrawMeshTasksIndirectEXT = PFN_vkCmdDrawMeshTasksIndirectEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectEXT" ) ); - vkCmdDrawMeshTasksIndirectCountEXT = PFN_vkCmdDrawMeshTasksIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMeshTasksIndirectCountEXT" ) ); - - //=== VK_KHR_copy_commands2 === - vkCmdCopyBuffer2KHR = PFN_vkCmdCopyBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBuffer2KHR" ) ); - if ( !vkCmdCopyBuffer2 ) - vkCmdCopyBuffer2 = vkCmdCopyBuffer2KHR; - vkCmdCopyImage2KHR = PFN_vkCmdCopyImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImage2KHR" ) ); - if ( !vkCmdCopyImage2 ) - vkCmdCopyImage2 = vkCmdCopyImage2KHR; - vkCmdCopyBufferToImage2KHR = PFN_vkCmdCopyBufferToImage2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyBufferToImage2KHR" ) ); - if ( !vkCmdCopyBufferToImage2 ) - vkCmdCopyBufferToImage2 = vkCmdCopyBufferToImage2KHR; - vkCmdCopyImageToBuffer2KHR = PFN_vkCmdCopyImageToBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdCopyImageToBuffer2KHR" ) ); - if ( !vkCmdCopyImageToBuffer2 ) - vkCmdCopyImageToBuffer2 = vkCmdCopyImageToBuffer2KHR; - vkCmdBlitImage2KHR = PFN_vkCmdBlitImage2KHR( vkGetDeviceProcAddr( device, "vkCmdBlitImage2KHR" ) ); - if ( !vkCmdBlitImage2 ) - vkCmdBlitImage2 = vkCmdBlitImage2KHR; - vkCmdResolveImage2KHR = PFN_vkCmdResolveImage2KHR( vkGetDeviceProcAddr( device, "vkCmdResolveImage2KHR" ) ); - if ( !vkCmdResolveImage2 ) - vkCmdResolveImage2 = vkCmdResolveImage2KHR; - - //=== VK_EXT_device_fault === - vkGetDeviceFaultInfoEXT = PFN_vkGetDeviceFaultInfoEXT( vkGetDeviceProcAddr( device, "vkGetDeviceFaultInfoEXT" ) ); - - //=== VK_EXT_vertex_input_dynamic_state === - vkCmdSetVertexInputEXT = PFN_vkCmdSetVertexInputEXT( vkGetDeviceProcAddr( device, "vkCmdSetVertexInputEXT" ) ); - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - vkGetMemoryZirconHandleFUCHSIA = PFN_vkGetMemoryZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandleFUCHSIA" ) ); - vkGetMemoryZirconHandlePropertiesFUCHSIA = - PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetMemoryZirconHandlePropertiesFUCHSIA" ) ); -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - vkImportSemaphoreZirconHandleFUCHSIA = - PFN_vkImportSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkImportSemaphoreZirconHandleFUCHSIA" ) ); - vkGetSemaphoreZirconHandleFUCHSIA = PFN_vkGetSemaphoreZirconHandleFUCHSIA( vkGetDeviceProcAddr( device, "vkGetSemaphoreZirconHandleFUCHSIA" ) ); -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - vkCreateBufferCollectionFUCHSIA = PFN_vkCreateBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkCreateBufferCollectionFUCHSIA" ) ); - vkSetBufferCollectionImageConstraintsFUCHSIA = - PFN_vkSetBufferCollectionImageConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionImageConstraintsFUCHSIA" ) ); - vkSetBufferCollectionBufferConstraintsFUCHSIA = - PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA( vkGetDeviceProcAddr( device, "vkSetBufferCollectionBufferConstraintsFUCHSIA" ) ); - vkDestroyBufferCollectionFUCHSIA = PFN_vkDestroyBufferCollectionFUCHSIA( vkGetDeviceProcAddr( device, "vkDestroyBufferCollectionFUCHSIA" ) ); - vkGetBufferCollectionPropertiesFUCHSIA = - PFN_vkGetBufferCollectionPropertiesFUCHSIA( vkGetDeviceProcAddr( device, "vkGetBufferCollectionPropertiesFUCHSIA" ) ); -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = - PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( vkGetDeviceProcAddr( device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI" ) ); - vkCmdSubpassShadingHUAWEI = PFN_vkCmdSubpassShadingHUAWEI( vkGetDeviceProcAddr( device, "vkCmdSubpassShadingHUAWEI" ) ); - - //=== VK_HUAWEI_invocation_mask === - vkCmdBindInvocationMaskHUAWEI = PFN_vkCmdBindInvocationMaskHUAWEI( vkGetDeviceProcAddr( device, "vkCmdBindInvocationMaskHUAWEI" ) ); - - //=== VK_NV_external_memory_rdma === - vkGetMemoryRemoteAddressNV = PFN_vkGetMemoryRemoteAddressNV( vkGetDeviceProcAddr( device, "vkGetMemoryRemoteAddressNV" ) ); - - //=== VK_EXT_pipeline_properties === - vkGetPipelinePropertiesEXT = PFN_vkGetPipelinePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetPipelinePropertiesEXT" ) ); - - //=== VK_EXT_extended_dynamic_state2 === - vkCmdSetPatchControlPointsEXT = PFN_vkCmdSetPatchControlPointsEXT( vkGetDeviceProcAddr( device, "vkCmdSetPatchControlPointsEXT" ) ); - vkCmdSetRasterizerDiscardEnableEXT = PFN_vkCmdSetRasterizerDiscardEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizerDiscardEnableEXT" ) ); - if ( !vkCmdSetRasterizerDiscardEnable ) - vkCmdSetRasterizerDiscardEnable = vkCmdSetRasterizerDiscardEnableEXT; - vkCmdSetDepthBiasEnableEXT = PFN_vkCmdSetDepthBiasEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthBiasEnableEXT" ) ); - if ( !vkCmdSetDepthBiasEnable ) - vkCmdSetDepthBiasEnable = vkCmdSetDepthBiasEnableEXT; - vkCmdSetLogicOpEXT = PFN_vkCmdSetLogicOpEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEXT" ) ); - vkCmdSetPrimitiveRestartEnableEXT = PFN_vkCmdSetPrimitiveRestartEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetPrimitiveRestartEnableEXT" ) ); - if ( !vkCmdSetPrimitiveRestartEnable ) - vkCmdSetPrimitiveRestartEnable = vkCmdSetPrimitiveRestartEnableEXT; - - //=== VK_EXT_color_write_enable === - vkCmdSetColorWriteEnableEXT = PFN_vkCmdSetColorWriteEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteEnableEXT" ) ); - - //=== VK_KHR_ray_tracing_maintenance1 === - vkCmdTraceRaysIndirect2KHR = PFN_vkCmdTraceRaysIndirect2KHR( vkGetDeviceProcAddr( device, "vkCmdTraceRaysIndirect2KHR" ) ); - - //=== VK_EXT_multi_draw === - vkCmdDrawMultiEXT = PFN_vkCmdDrawMultiEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiEXT" ) ); - vkCmdDrawMultiIndexedEXT = PFN_vkCmdDrawMultiIndexedEXT( vkGetDeviceProcAddr( device, "vkCmdDrawMultiIndexedEXT" ) ); - - //=== VK_EXT_opacity_micromap === - vkCreateMicromapEXT = PFN_vkCreateMicromapEXT( vkGetDeviceProcAddr( device, "vkCreateMicromapEXT" ) ); - vkDestroyMicromapEXT = PFN_vkDestroyMicromapEXT( vkGetDeviceProcAddr( device, "vkDestroyMicromapEXT" ) ); - vkCmdBuildMicromapsEXT = PFN_vkCmdBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkCmdBuildMicromapsEXT" ) ); - vkBuildMicromapsEXT = PFN_vkBuildMicromapsEXT( vkGetDeviceProcAddr( device, "vkBuildMicromapsEXT" ) ); - vkCopyMicromapEXT = PFN_vkCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapEXT" ) ); - vkCopyMicromapToMemoryEXT = PFN_vkCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCopyMicromapToMemoryEXT" ) ); - vkCopyMemoryToMicromapEXT = PFN_vkCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCopyMemoryToMicromapEXT" ) ); - vkWriteMicromapsPropertiesEXT = PFN_vkWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkWriteMicromapsPropertiesEXT" ) ); - vkCmdCopyMicromapEXT = PFN_vkCmdCopyMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapEXT" ) ); - vkCmdCopyMicromapToMemoryEXT = PFN_vkCmdCopyMicromapToMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMicromapToMemoryEXT" ) ); - vkCmdCopyMemoryToMicromapEXT = PFN_vkCmdCopyMemoryToMicromapEXT( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToMicromapEXT" ) ); - vkCmdWriteMicromapsPropertiesEXT = PFN_vkCmdWriteMicromapsPropertiesEXT( vkGetDeviceProcAddr( device, "vkCmdWriteMicromapsPropertiesEXT" ) ); - vkGetDeviceMicromapCompatibilityEXT = PFN_vkGetDeviceMicromapCompatibilityEXT( vkGetDeviceProcAddr( device, "vkGetDeviceMicromapCompatibilityEXT" ) ); - vkGetMicromapBuildSizesEXT = PFN_vkGetMicromapBuildSizesEXT( vkGetDeviceProcAddr( device, "vkGetMicromapBuildSizesEXT" ) ); - - //=== VK_HUAWEI_cluster_culling_shader === - vkCmdDrawClusterHUAWEI = PFN_vkCmdDrawClusterHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterHUAWEI" ) ); - vkCmdDrawClusterIndirectHUAWEI = PFN_vkCmdDrawClusterIndirectHUAWEI( vkGetDeviceProcAddr( device, "vkCmdDrawClusterIndirectHUAWEI" ) ); - - //=== VK_EXT_pageable_device_local_memory === - vkSetDeviceMemoryPriorityEXT = PFN_vkSetDeviceMemoryPriorityEXT( vkGetDeviceProcAddr( device, "vkSetDeviceMemoryPriorityEXT" ) ); - - //=== VK_KHR_maintenance4 === - vkGetDeviceBufferMemoryRequirementsKHR = - PFN_vkGetDeviceBufferMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceBufferMemoryRequirementsKHR" ) ); - if ( !vkGetDeviceBufferMemoryRequirements ) - vkGetDeviceBufferMemoryRequirements = vkGetDeviceBufferMemoryRequirementsKHR; - vkGetDeviceImageMemoryRequirementsKHR = - PFN_vkGetDeviceImageMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageMemoryRequirementsKHR" ) ); - if ( !vkGetDeviceImageMemoryRequirements ) - vkGetDeviceImageMemoryRequirements = vkGetDeviceImageMemoryRequirementsKHR; - vkGetDeviceImageSparseMemoryRequirementsKHR = - PFN_vkGetDeviceImageSparseMemoryRequirementsKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSparseMemoryRequirementsKHR" ) ); - if ( !vkGetDeviceImageSparseMemoryRequirements ) - vkGetDeviceImageSparseMemoryRequirements = vkGetDeviceImageSparseMemoryRequirementsKHR; - - //=== VK_VALVE_descriptor_set_host_mapping === - vkGetDescriptorSetLayoutHostMappingInfoVALVE = - PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE" ) ); - vkGetDescriptorSetHostMappingVALVE = PFN_vkGetDescriptorSetHostMappingVALVE( vkGetDeviceProcAddr( device, "vkGetDescriptorSetHostMappingVALVE" ) ); - - //=== VK_NV_copy_memory_indirect === - vkCmdCopyMemoryIndirectNV = PFN_vkCmdCopyMemoryIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectNV" ) ); - vkCmdCopyMemoryToImageIndirectNV = PFN_vkCmdCopyMemoryToImageIndirectNV( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectNV" ) ); - - //=== VK_NV_memory_decompression === - vkCmdDecompressMemoryNV = PFN_vkCmdDecompressMemoryNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryNV" ) ); - vkCmdDecompressMemoryIndirectCountNV = - PFN_vkCmdDecompressMemoryIndirectCountNV( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountNV" ) ); - - //=== VK_NV_device_generated_commands_compute === - vkGetPipelineIndirectMemoryRequirementsNV = - PFN_vkGetPipelineIndirectMemoryRequirementsNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectMemoryRequirementsNV" ) ); - vkCmdUpdatePipelineIndirectBufferNV = PFN_vkCmdUpdatePipelineIndirectBufferNV( vkGetDeviceProcAddr( device, "vkCmdUpdatePipelineIndirectBufferNV" ) ); - vkGetPipelineIndirectDeviceAddressNV = - PFN_vkGetPipelineIndirectDeviceAddressNV( vkGetDeviceProcAddr( device, "vkGetPipelineIndirectDeviceAddressNV" ) ); - -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - vkGetNativeBufferPropertiesOHOS = PFN_vkGetNativeBufferPropertiesOHOS( vkGetDeviceProcAddr( device, "vkGetNativeBufferPropertiesOHOS" ) ); - vkGetMemoryNativeBufferOHOS = PFN_vkGetMemoryNativeBufferOHOS( vkGetDeviceProcAddr( device, "vkGetMemoryNativeBufferOHOS" ) ); -# endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_extended_dynamic_state3 === - vkCmdSetDepthClampEnableEXT = PFN_vkCmdSetDepthClampEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampEnableEXT" ) ); - vkCmdSetPolygonModeEXT = PFN_vkCmdSetPolygonModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetPolygonModeEXT" ) ); - vkCmdSetRasterizationSamplesEXT = PFN_vkCmdSetRasterizationSamplesEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationSamplesEXT" ) ); - vkCmdSetSampleMaskEXT = PFN_vkCmdSetSampleMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleMaskEXT" ) ); - vkCmdSetAlphaToCoverageEnableEXT = PFN_vkCmdSetAlphaToCoverageEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToCoverageEnableEXT" ) ); - vkCmdSetAlphaToOneEnableEXT = PFN_vkCmdSetAlphaToOneEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAlphaToOneEnableEXT" ) ); - vkCmdSetLogicOpEnableEXT = PFN_vkCmdSetLogicOpEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLogicOpEnableEXT" ) ); - vkCmdSetColorBlendEnableEXT = PFN_vkCmdSetColorBlendEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEnableEXT" ) ); - vkCmdSetColorBlendEquationEXT = PFN_vkCmdSetColorBlendEquationEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendEquationEXT" ) ); - vkCmdSetColorWriteMaskEXT = PFN_vkCmdSetColorWriteMaskEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorWriteMaskEXT" ) ); - vkCmdSetTessellationDomainOriginEXT = PFN_vkCmdSetTessellationDomainOriginEXT( vkGetDeviceProcAddr( device, "vkCmdSetTessellationDomainOriginEXT" ) ); - vkCmdSetRasterizationStreamEXT = PFN_vkCmdSetRasterizationStreamEXT( vkGetDeviceProcAddr( device, "vkCmdSetRasterizationStreamEXT" ) ); - vkCmdSetConservativeRasterizationModeEXT = - PFN_vkCmdSetConservativeRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetConservativeRasterizationModeEXT" ) ); - vkCmdSetExtraPrimitiveOverestimationSizeEXT = - PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT( vkGetDeviceProcAddr( device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT" ) ); - vkCmdSetDepthClipEnableEXT = PFN_vkCmdSetDepthClipEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipEnableEXT" ) ); - vkCmdSetSampleLocationsEnableEXT = PFN_vkCmdSetSampleLocationsEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetSampleLocationsEnableEXT" ) ); - vkCmdSetColorBlendAdvancedEXT = PFN_vkCmdSetColorBlendAdvancedEXT( vkGetDeviceProcAddr( device, "vkCmdSetColorBlendAdvancedEXT" ) ); - vkCmdSetProvokingVertexModeEXT = PFN_vkCmdSetProvokingVertexModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetProvokingVertexModeEXT" ) ); - vkCmdSetLineRasterizationModeEXT = PFN_vkCmdSetLineRasterizationModeEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineRasterizationModeEXT" ) ); - vkCmdSetLineStippleEnableEXT = PFN_vkCmdSetLineStippleEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleEnableEXT" ) ); - vkCmdSetDepthClipNegativeOneToOneEXT = - PFN_vkCmdSetDepthClipNegativeOneToOneEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClipNegativeOneToOneEXT" ) ); - vkCmdSetViewportWScalingEnableNV = PFN_vkCmdSetViewportWScalingEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportWScalingEnableNV" ) ); - vkCmdSetViewportSwizzleNV = PFN_vkCmdSetViewportSwizzleNV( vkGetDeviceProcAddr( device, "vkCmdSetViewportSwizzleNV" ) ); - vkCmdSetCoverageToColorEnableNV = PFN_vkCmdSetCoverageToColorEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorEnableNV" ) ); - vkCmdSetCoverageToColorLocationNV = PFN_vkCmdSetCoverageToColorLocationNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageToColorLocationNV" ) ); - vkCmdSetCoverageModulationModeNV = PFN_vkCmdSetCoverageModulationModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationModeNV" ) ); - vkCmdSetCoverageModulationTableEnableNV = - PFN_vkCmdSetCoverageModulationTableEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableEnableNV" ) ); - vkCmdSetCoverageModulationTableNV = PFN_vkCmdSetCoverageModulationTableNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageModulationTableNV" ) ); - vkCmdSetShadingRateImageEnableNV = PFN_vkCmdSetShadingRateImageEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetShadingRateImageEnableNV" ) ); - vkCmdSetRepresentativeFragmentTestEnableNV = - PFN_vkCmdSetRepresentativeFragmentTestEnableNV( vkGetDeviceProcAddr( device, "vkCmdSetRepresentativeFragmentTestEnableNV" ) ); - vkCmdSetCoverageReductionModeNV = PFN_vkCmdSetCoverageReductionModeNV( vkGetDeviceProcAddr( device, "vkCmdSetCoverageReductionModeNV" ) ); - - //=== VK_ARM_tensors === - vkCreateTensorARM = PFN_vkCreateTensorARM( vkGetDeviceProcAddr( device, "vkCreateTensorARM" ) ); - vkDestroyTensorARM = PFN_vkDestroyTensorARM( vkGetDeviceProcAddr( device, "vkDestroyTensorARM" ) ); - vkCreateTensorViewARM = PFN_vkCreateTensorViewARM( vkGetDeviceProcAddr( device, "vkCreateTensorViewARM" ) ); - vkDestroyTensorViewARM = PFN_vkDestroyTensorViewARM( vkGetDeviceProcAddr( device, "vkDestroyTensorViewARM" ) ); - vkGetTensorMemoryRequirementsARM = PFN_vkGetTensorMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetTensorMemoryRequirementsARM" ) ); - vkBindTensorMemoryARM = PFN_vkBindTensorMemoryARM( vkGetDeviceProcAddr( device, "vkBindTensorMemoryARM" ) ); - vkGetDeviceTensorMemoryRequirementsARM = - PFN_vkGetDeviceTensorMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDeviceTensorMemoryRequirementsARM" ) ); - vkCmdCopyTensorARM = PFN_vkCmdCopyTensorARM( vkGetDeviceProcAddr( device, "vkCmdCopyTensorARM" ) ); - vkGetTensorOpaqueCaptureDescriptorDataARM = - PFN_vkGetTensorOpaqueCaptureDescriptorDataARM( vkGetDeviceProcAddr( device, "vkGetTensorOpaqueCaptureDescriptorDataARM" ) ); - vkGetTensorViewOpaqueCaptureDescriptorDataARM = - PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM( vkGetDeviceProcAddr( device, "vkGetTensorViewOpaqueCaptureDescriptorDataARM" ) ); - - //=== VK_EXT_shader_module_identifier === - vkGetShaderModuleIdentifierEXT = PFN_vkGetShaderModuleIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleIdentifierEXT" ) ); - vkGetShaderModuleCreateInfoIdentifierEXT = - PFN_vkGetShaderModuleCreateInfoIdentifierEXT( vkGetDeviceProcAddr( device, "vkGetShaderModuleCreateInfoIdentifierEXT" ) ); - - //=== VK_NV_optical_flow === - vkCreateOpticalFlowSessionNV = PFN_vkCreateOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkCreateOpticalFlowSessionNV" ) ); - vkDestroyOpticalFlowSessionNV = PFN_vkDestroyOpticalFlowSessionNV( vkGetDeviceProcAddr( device, "vkDestroyOpticalFlowSessionNV" ) ); - vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) ); - vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) ); - - //=== VK_KHR_maintenance5 === - vkCmdBindIndexBuffer2KHR = PFN_vkCmdBindIndexBuffer2KHR( vkGetDeviceProcAddr( device, "vkCmdBindIndexBuffer2KHR" ) ); - if ( !vkCmdBindIndexBuffer2 ) - vkCmdBindIndexBuffer2 = vkCmdBindIndexBuffer2KHR; - vkGetRenderingAreaGranularityKHR = PFN_vkGetRenderingAreaGranularityKHR( vkGetDeviceProcAddr( device, "vkGetRenderingAreaGranularityKHR" ) ); - if ( !vkGetRenderingAreaGranularity ) - vkGetRenderingAreaGranularity = vkGetRenderingAreaGranularityKHR; - vkGetDeviceImageSubresourceLayoutKHR = - PFN_vkGetDeviceImageSubresourceLayoutKHR( vkGetDeviceProcAddr( device, "vkGetDeviceImageSubresourceLayoutKHR" ) ); - if ( !vkGetDeviceImageSubresourceLayout ) - vkGetDeviceImageSubresourceLayout = vkGetDeviceImageSubresourceLayoutKHR; - vkGetImageSubresourceLayout2KHR = PFN_vkGetImageSubresourceLayout2KHR( vkGetDeviceProcAddr( device, "vkGetImageSubresourceLayout2KHR" ) ); - if ( !vkGetImageSubresourceLayout2 ) - vkGetImageSubresourceLayout2 = vkGetImageSubresourceLayout2KHR; - - //=== VK_AMD_anti_lag === - vkAntiLagUpdateAMD = PFN_vkAntiLagUpdateAMD( vkGetDeviceProcAddr( device, "vkAntiLagUpdateAMD" ) ); - - //=== VK_KHR_present_wait2 === - vkWaitForPresent2KHR = PFN_vkWaitForPresent2KHR( vkGetDeviceProcAddr( device, "vkWaitForPresent2KHR" ) ); - - //=== VK_EXT_shader_object === - vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetDeviceProcAddr( device, "vkCreateShadersEXT" ) ); - vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetDeviceProcAddr( device, "vkDestroyShaderEXT" ) ); - vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) ); - vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) ); - vkCmdSetDepthClampRangeEXT = PFN_vkCmdSetDepthClampRangeEXT( vkGetDeviceProcAddr( device, "vkCmdSetDepthClampRangeEXT" ) ); - - //=== VK_KHR_pipeline_binary === - vkCreatePipelineBinariesKHR = PFN_vkCreatePipelineBinariesKHR( vkGetDeviceProcAddr( device, "vkCreatePipelineBinariesKHR" ) ); - vkDestroyPipelineBinaryKHR = PFN_vkDestroyPipelineBinaryKHR( vkGetDeviceProcAddr( device, "vkDestroyPipelineBinaryKHR" ) ); - vkGetPipelineKeyKHR = PFN_vkGetPipelineKeyKHR( vkGetDeviceProcAddr( device, "vkGetPipelineKeyKHR" ) ); - vkGetPipelineBinaryDataKHR = PFN_vkGetPipelineBinaryDataKHR( vkGetDeviceProcAddr( device, "vkGetPipelineBinaryDataKHR" ) ); - vkReleaseCapturedPipelineDataKHR = PFN_vkReleaseCapturedPipelineDataKHR( vkGetDeviceProcAddr( device, "vkReleaseCapturedPipelineDataKHR" ) ); - - //=== VK_QCOM_tile_properties === - vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) ); - vkGetDynamicRenderingTilePropertiesQCOM = - PFN_vkGetDynamicRenderingTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetDynamicRenderingTilePropertiesQCOM" ) ); - - //=== VK_KHR_swapchain_maintenance1 === - vkReleaseSwapchainImagesKHR = PFN_vkReleaseSwapchainImagesKHR( vkGetDeviceProcAddr( device, "vkReleaseSwapchainImagesKHR" ) ); - - //=== VK_NV_cooperative_vector === - vkConvertCooperativeVectorMatrixNV = PFN_vkConvertCooperativeVectorMatrixNV( vkGetDeviceProcAddr( device, "vkConvertCooperativeVectorMatrixNV" ) ); - vkCmdConvertCooperativeVectorMatrixNV = - PFN_vkCmdConvertCooperativeVectorMatrixNV( vkGetDeviceProcAddr( device, "vkCmdConvertCooperativeVectorMatrixNV" ) ); - - //=== VK_NV_low_latency2 === - vkSetLatencySleepModeNV = PFN_vkSetLatencySleepModeNV( vkGetDeviceProcAddr( device, "vkSetLatencySleepModeNV" ) ); - vkLatencySleepNV = PFN_vkLatencySleepNV( vkGetDeviceProcAddr( device, "vkLatencySleepNV" ) ); - vkSetLatencyMarkerNV = PFN_vkSetLatencyMarkerNV( vkGetDeviceProcAddr( device, "vkSetLatencyMarkerNV" ) ); - vkGetLatencyTimingsNV = PFN_vkGetLatencyTimingsNV( vkGetDeviceProcAddr( device, "vkGetLatencyTimingsNV" ) ); - vkQueueNotifyOutOfBandNV = PFN_vkQueueNotifyOutOfBandNV( vkGetDeviceProcAddr( device, "vkQueueNotifyOutOfBandNV" ) ); - - //=== VK_ARM_data_graph === - vkCreateDataGraphPipelinesARM = PFN_vkCreateDataGraphPipelinesARM( vkGetDeviceProcAddr( device, "vkCreateDataGraphPipelinesARM" ) ); - vkCreateDataGraphPipelineSessionARM = PFN_vkCreateDataGraphPipelineSessionARM( vkGetDeviceProcAddr( device, "vkCreateDataGraphPipelineSessionARM" ) ); - vkGetDataGraphPipelineSessionBindPointRequirementsARM = - PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineSessionBindPointRequirementsARM" ) ); - vkGetDataGraphPipelineSessionMemoryRequirementsARM = - PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineSessionMemoryRequirementsARM" ) ); - vkBindDataGraphPipelineSessionMemoryARM = - PFN_vkBindDataGraphPipelineSessionMemoryARM( vkGetDeviceProcAddr( device, "vkBindDataGraphPipelineSessionMemoryARM" ) ); - vkDestroyDataGraphPipelineSessionARM = - PFN_vkDestroyDataGraphPipelineSessionARM( vkGetDeviceProcAddr( device, "vkDestroyDataGraphPipelineSessionARM" ) ); - vkCmdDispatchDataGraphARM = PFN_vkCmdDispatchDataGraphARM( vkGetDeviceProcAddr( device, "vkCmdDispatchDataGraphARM" ) ); - vkGetDataGraphPipelineAvailablePropertiesARM = - PFN_vkGetDataGraphPipelineAvailablePropertiesARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelineAvailablePropertiesARM" ) ); - vkGetDataGraphPipelinePropertiesARM = PFN_vkGetDataGraphPipelinePropertiesARM( vkGetDeviceProcAddr( device, "vkGetDataGraphPipelinePropertiesARM" ) ); - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - vkCmdSetAttachmentFeedbackLoopEnableEXT = - PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT( vkGetDeviceProcAddr( device, "vkCmdSetAttachmentFeedbackLoopEnableEXT" ) ); - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - vkGetScreenBufferPropertiesQNX = PFN_vkGetScreenBufferPropertiesQNX( vkGetDeviceProcAddr( device, "vkGetScreenBufferPropertiesQNX" ) ); -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_KHR_line_rasterization === - vkCmdSetLineStippleKHR = PFN_vkCmdSetLineStippleKHR( vkGetDeviceProcAddr( device, "vkCmdSetLineStippleKHR" ) ); - if ( !vkCmdSetLineStipple ) - vkCmdSetLineStipple = vkCmdSetLineStippleKHR; - - //=== VK_KHR_calibrated_timestamps === - vkGetCalibratedTimestampsKHR = PFN_vkGetCalibratedTimestampsKHR( vkGetDeviceProcAddr( device, "vkGetCalibratedTimestampsKHR" ) ); - - //=== VK_KHR_maintenance6 === - vkCmdBindDescriptorSets2KHR = PFN_vkCmdBindDescriptorSets2KHR( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorSets2KHR" ) ); - if ( !vkCmdBindDescriptorSets2 ) - vkCmdBindDescriptorSets2 = vkCmdBindDescriptorSets2KHR; - vkCmdPushConstants2KHR = PFN_vkCmdPushConstants2KHR( vkGetDeviceProcAddr( device, "vkCmdPushConstants2KHR" ) ); - if ( !vkCmdPushConstants2 ) - vkCmdPushConstants2 = vkCmdPushConstants2KHR; - vkCmdPushDescriptorSet2KHR = PFN_vkCmdPushDescriptorSet2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSet2KHR" ) ); - if ( !vkCmdPushDescriptorSet2 ) - vkCmdPushDescriptorSet2 = vkCmdPushDescriptorSet2KHR; - vkCmdPushDescriptorSetWithTemplate2KHR = - PFN_vkCmdPushDescriptorSetWithTemplate2KHR( vkGetDeviceProcAddr( device, "vkCmdPushDescriptorSetWithTemplate2KHR" ) ); - if ( !vkCmdPushDescriptorSetWithTemplate2 ) - vkCmdPushDescriptorSetWithTemplate2 = vkCmdPushDescriptorSetWithTemplate2KHR; - vkCmdSetDescriptorBufferOffsets2EXT = PFN_vkCmdSetDescriptorBufferOffsets2EXT( vkGetDeviceProcAddr( device, "vkCmdSetDescriptorBufferOffsets2EXT" ) ); - vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = - PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); - - //=== VK_QCOM_tile_memory_heap === - vkCmdBindTileMemoryQCOM = PFN_vkCmdBindTileMemoryQCOM( vkGetDeviceProcAddr( device, "vkCmdBindTileMemoryQCOM" ) ); - - //=== VK_KHR_copy_memory_indirect === - vkCmdCopyMemoryIndirectKHR = PFN_vkCmdCopyMemoryIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryIndirectKHR" ) ); - vkCmdCopyMemoryToImageIndirectKHR = PFN_vkCmdCopyMemoryToImageIndirectKHR( vkGetDeviceProcAddr( device, "vkCmdCopyMemoryToImageIndirectKHR" ) ); - - //=== VK_EXT_memory_decompression === - vkCmdDecompressMemoryEXT = PFN_vkCmdDecompressMemoryEXT( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryEXT" ) ); - vkCmdDecompressMemoryIndirectCountEXT = - PFN_vkCmdDecompressMemoryIndirectCountEXT( vkGetDeviceProcAddr( device, "vkCmdDecompressMemoryIndirectCountEXT" ) ); - - //=== VK_NV_external_compute_queue === - vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) ); - vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) ); - vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetDeviceProcAddr( device, "vkGetExternalComputeQueueDataNV" ) ); - - //=== VK_NV_cluster_acceleration_structure === - vkGetClusterAccelerationStructureBuildSizesNV = - PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetClusterAccelerationStructureBuildSizesNV" ) ); - vkCmdBuildClusterAccelerationStructureIndirectNV = - PFN_vkCmdBuildClusterAccelerationStructureIndirectNV( vkGetDeviceProcAddr( device, "vkCmdBuildClusterAccelerationStructureIndirectNV" ) ); - - //=== VK_NV_partitioned_acceleration_structure === - vkGetPartitionedAccelerationStructuresBuildSizesNV = - PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetPartitionedAccelerationStructuresBuildSizesNV" ) ); - vkCmdBuildPartitionedAccelerationStructuresNV = - PFN_vkCmdBuildPartitionedAccelerationStructuresNV( vkGetDeviceProcAddr( device, "vkCmdBuildPartitionedAccelerationStructuresNV" ) ); - - //=== VK_EXT_device_generated_commands === - vkGetGeneratedCommandsMemoryRequirementsEXT = - PFN_vkGetGeneratedCommandsMemoryRequirementsEXT( vkGetDeviceProcAddr( device, "vkGetGeneratedCommandsMemoryRequirementsEXT" ) ); - vkCmdPreprocessGeneratedCommandsEXT = PFN_vkCmdPreprocessGeneratedCommandsEXT( vkGetDeviceProcAddr( device, "vkCmdPreprocessGeneratedCommandsEXT" ) ); - vkCmdExecuteGeneratedCommandsEXT = PFN_vkCmdExecuteGeneratedCommandsEXT( vkGetDeviceProcAddr( device, "vkCmdExecuteGeneratedCommandsEXT" ) ); - vkCreateIndirectCommandsLayoutEXT = PFN_vkCreateIndirectCommandsLayoutEXT( vkGetDeviceProcAddr( device, "vkCreateIndirectCommandsLayoutEXT" ) ); - vkDestroyIndirectCommandsLayoutEXT = PFN_vkDestroyIndirectCommandsLayoutEXT( vkGetDeviceProcAddr( device, "vkDestroyIndirectCommandsLayoutEXT" ) ); - vkCreateIndirectExecutionSetEXT = PFN_vkCreateIndirectExecutionSetEXT( vkGetDeviceProcAddr( device, "vkCreateIndirectExecutionSetEXT" ) ); - vkDestroyIndirectExecutionSetEXT = PFN_vkDestroyIndirectExecutionSetEXT( vkGetDeviceProcAddr( device, "vkDestroyIndirectExecutionSetEXT" ) ); - vkUpdateIndirectExecutionSetPipelineEXT = - PFN_vkUpdateIndirectExecutionSetPipelineEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetPipelineEXT" ) ); - vkUpdateIndirectExecutionSetShaderEXT = - PFN_vkUpdateIndirectExecutionSetShaderEXT( vkGetDeviceProcAddr( device, "vkUpdateIndirectExecutionSetShaderEXT" ) ); - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - vkGetMemoryMetalHandleEXT = PFN_vkGetMemoryMetalHandleEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandleEXT" ) ); - vkGetMemoryMetalHandlePropertiesEXT = PFN_vkGetMemoryMetalHandlePropertiesEXT( vkGetDeviceProcAddr( device, "vkGetMemoryMetalHandlePropertiesEXT" ) ); -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_fragment_density_map_offset === - vkCmdEndRendering2EXT = PFN_vkCmdEndRendering2EXT( vkGetDeviceProcAddr( device, "vkCmdEndRendering2EXT" ) ); - if ( !vkCmdEndRendering2KHR ) - vkCmdEndRendering2KHR = vkCmdEndRendering2EXT; - - //=== VK_EXT_custom_resolve === - vkCmdBeginCustomResolveEXT = PFN_vkCmdBeginCustomResolveEXT( vkGetDeviceProcAddr( device, "vkCmdBeginCustomResolveEXT" ) ); - - //=== VK_KHR_maintenance10 === - vkCmdEndRendering2KHR = PFN_vkCmdEndRendering2KHR( vkGetDeviceProcAddr( device, "vkCmdEndRendering2KHR" ) ); - - //=== VK_NV_compute_occupancy_priority === - vkCmdSetComputeOccupancyPriorityNV = PFN_vkCmdSetComputeOccupancyPriorityNV( vkGetDeviceProcAddr( device, "vkCmdSetComputeOccupancyPriorityNV" ) ); - } - - public: - //=== VK_VERSION_1_0 === - PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr = 0; - PFN_vkDestroyDevice vkDestroyDevice = 0; - PFN_vkGetDeviceQueue vkGetDeviceQueue = 0; - PFN_vkQueueSubmit vkQueueSubmit = 0; - PFN_vkQueueWaitIdle vkQueueWaitIdle = 0; - PFN_vkDeviceWaitIdle vkDeviceWaitIdle = 0; - PFN_vkAllocateMemory vkAllocateMemory = 0; - PFN_vkFreeMemory vkFreeMemory = 0; - PFN_vkMapMemory vkMapMemory = 0; - PFN_vkUnmapMemory vkUnmapMemory = 0; - PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges = 0; - PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges = 0; - PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment = 0; - PFN_vkBindBufferMemory vkBindBufferMemory = 0; - PFN_vkBindImageMemory vkBindImageMemory = 0; - PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements = 0; - PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements = 0; - PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements = 0; - PFN_vkQueueBindSparse vkQueueBindSparse = 0; - PFN_vkCreateFence vkCreateFence = 0; - PFN_vkDestroyFence vkDestroyFence = 0; - PFN_vkResetFences vkResetFences = 0; - PFN_vkGetFenceStatus vkGetFenceStatus = 0; - PFN_vkWaitForFences vkWaitForFences = 0; - PFN_vkCreateSemaphore vkCreateSemaphore = 0; - PFN_vkDestroySemaphore vkDestroySemaphore = 0; - PFN_vkCreateQueryPool vkCreateQueryPool = 0; - PFN_vkDestroyQueryPool vkDestroyQueryPool = 0; - PFN_vkGetQueryPoolResults vkGetQueryPoolResults = 0; - PFN_vkCreateBuffer vkCreateBuffer = 0; - PFN_vkDestroyBuffer vkDestroyBuffer = 0; - PFN_vkCreateImage vkCreateImage = 0; - PFN_vkDestroyImage vkDestroyImage = 0; - PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout = 0; - PFN_vkCreateImageView vkCreateImageView = 0; - PFN_vkDestroyImageView vkDestroyImageView = 0; - PFN_vkCreateCommandPool vkCreateCommandPool = 0; - PFN_vkDestroyCommandPool vkDestroyCommandPool = 0; - PFN_vkResetCommandPool vkResetCommandPool = 0; - PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers = 0; - PFN_vkFreeCommandBuffers vkFreeCommandBuffers = 0; - PFN_vkBeginCommandBuffer vkBeginCommandBuffer = 0; - PFN_vkEndCommandBuffer vkEndCommandBuffer = 0; - PFN_vkResetCommandBuffer vkResetCommandBuffer = 0; - PFN_vkCmdCopyBuffer vkCmdCopyBuffer = 0; - PFN_vkCmdCopyImage vkCmdCopyImage = 0; - PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage = 0; - PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer = 0; - PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer = 0; - PFN_vkCmdFillBuffer vkCmdFillBuffer = 0; - PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier = 0; - PFN_vkCmdBeginQuery vkCmdBeginQuery = 0; - PFN_vkCmdEndQuery vkCmdEndQuery = 0; - PFN_vkCmdResetQueryPool vkCmdResetQueryPool = 0; - PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp = 0; - PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults = 0; - PFN_vkCmdExecuteCommands vkCmdExecuteCommands = 0; - PFN_vkCreateEvent vkCreateEvent = 0; - PFN_vkDestroyEvent vkDestroyEvent = 0; - PFN_vkGetEventStatus vkGetEventStatus = 0; - PFN_vkSetEvent vkSetEvent = 0; - PFN_vkResetEvent vkResetEvent = 0; - PFN_vkCreateBufferView vkCreateBufferView = 0; - PFN_vkDestroyBufferView vkDestroyBufferView = 0; - PFN_vkCreateShaderModule vkCreateShaderModule = 0; - PFN_vkDestroyShaderModule vkDestroyShaderModule = 0; - PFN_vkCreatePipelineCache vkCreatePipelineCache = 0; - PFN_vkDestroyPipelineCache vkDestroyPipelineCache = 0; - PFN_vkGetPipelineCacheData vkGetPipelineCacheData = 0; - PFN_vkMergePipelineCaches vkMergePipelineCaches = 0; - PFN_vkCreateComputePipelines vkCreateComputePipelines = 0; - PFN_vkDestroyPipeline vkDestroyPipeline = 0; - PFN_vkCreatePipelineLayout vkCreatePipelineLayout = 0; - PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout = 0; - PFN_vkCreateSampler vkCreateSampler = 0; - PFN_vkDestroySampler vkDestroySampler = 0; - PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout = 0; - PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout = 0; - PFN_vkCreateDescriptorPool vkCreateDescriptorPool = 0; - PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool = 0; - PFN_vkResetDescriptorPool vkResetDescriptorPool = 0; - PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets = 0; - PFN_vkFreeDescriptorSets vkFreeDescriptorSets = 0; - PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets = 0; - PFN_vkCmdBindPipeline vkCmdBindPipeline = 0; - PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets = 0; - PFN_vkCmdClearColorImage vkCmdClearColorImage = 0; - PFN_vkCmdDispatch vkCmdDispatch = 0; - PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect = 0; - PFN_vkCmdSetEvent vkCmdSetEvent = 0; - PFN_vkCmdResetEvent vkCmdResetEvent = 0; - PFN_vkCmdWaitEvents vkCmdWaitEvents = 0; - PFN_vkCmdPushConstants vkCmdPushConstants = 0; - PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines = 0; - PFN_vkCreateFramebuffer vkCreateFramebuffer = 0; - PFN_vkDestroyFramebuffer vkDestroyFramebuffer = 0; - PFN_vkCreateRenderPass vkCreateRenderPass = 0; - PFN_vkDestroyRenderPass vkDestroyRenderPass = 0; - PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity = 0; - PFN_vkCmdSetViewport vkCmdSetViewport = 0; - PFN_vkCmdSetScissor vkCmdSetScissor = 0; - PFN_vkCmdSetLineWidth vkCmdSetLineWidth = 0; - PFN_vkCmdSetDepthBias vkCmdSetDepthBias = 0; - PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants = 0; - PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds = 0; - PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask = 0; - PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask = 0; - PFN_vkCmdSetStencilReference vkCmdSetStencilReference = 0; - PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer = 0; - PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers = 0; - PFN_vkCmdDraw vkCmdDraw = 0; - PFN_vkCmdDrawIndexed vkCmdDrawIndexed = 0; - PFN_vkCmdDrawIndirect vkCmdDrawIndirect = 0; - PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect = 0; - PFN_vkCmdBlitImage vkCmdBlitImage = 0; - PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage = 0; - PFN_vkCmdClearAttachments vkCmdClearAttachments = 0; - PFN_vkCmdResolveImage vkCmdResolveImage = 0; - PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass = 0; - PFN_vkCmdNextSubpass vkCmdNextSubpass = 0; - PFN_vkCmdEndRenderPass vkCmdEndRenderPass = 0; - - //=== VK_VERSION_1_1 === - PFN_vkBindBufferMemory2 vkBindBufferMemory2 = 0; - PFN_vkBindImageMemory2 vkBindImageMemory2 = 0; - PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures = 0; - PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask = 0; - PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2 = 0; - PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2 = 0; - PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2 = 0; - PFN_vkTrimCommandPool vkTrimCommandPool = 0; - PFN_vkGetDeviceQueue2 vkGetDeviceQueue2 = 0; - PFN_vkCmdDispatchBase vkCmdDispatchBase = 0; - PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate = 0; - PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate = 0; - PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate = 0; - PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport = 0; - PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion = 0; - PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion = 0; - - //=== VK_VERSION_1_2 === - PFN_vkResetQueryPool vkResetQueryPool = 0; - PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue = 0; - PFN_vkWaitSemaphores vkWaitSemaphores = 0; - PFN_vkSignalSemaphore vkSignalSemaphore = 0; - PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress = 0; - PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress = 0; - PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress = 0; - PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount = 0; - PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount = 0; - PFN_vkCreateRenderPass2 vkCreateRenderPass2 = 0; - PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2 = 0; - PFN_vkCmdNextSubpass2 vkCmdNextSubpass2 = 0; - PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2 = 0; - - //=== VK_VERSION_1_3 === - PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot = 0; - PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot = 0; - PFN_vkSetPrivateData vkSetPrivateData = 0; - PFN_vkGetPrivateData vkGetPrivateData = 0; - PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2 = 0; - PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2 = 0; - PFN_vkQueueSubmit2 vkQueueSubmit2 = 0; - PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2 = 0; - PFN_vkCmdCopyImage2 vkCmdCopyImage2 = 0; - PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2 = 0; - PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2 = 0; - PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements = 0; - PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements = 0; - PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements = 0; - PFN_vkCmdSetEvent2 vkCmdSetEvent2 = 0; - PFN_vkCmdResetEvent2 vkCmdResetEvent2 = 0; - PFN_vkCmdWaitEvents2 vkCmdWaitEvents2 = 0; - PFN_vkCmdBlitImage2 vkCmdBlitImage2 = 0; - PFN_vkCmdResolveImage2 vkCmdResolveImage2 = 0; - PFN_vkCmdBeginRendering vkCmdBeginRendering = 0; - PFN_vkCmdEndRendering vkCmdEndRendering = 0; - PFN_vkCmdSetCullMode vkCmdSetCullMode = 0; - PFN_vkCmdSetFrontFace vkCmdSetFrontFace = 0; - PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology = 0; - PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount = 0; - PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount = 0; - PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2 = 0; - PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable = 0; - PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable = 0; - PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp = 0; - PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable = 0; - PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable = 0; - PFN_vkCmdSetStencilOp vkCmdSetStencilOp = 0; - PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable = 0; - PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable = 0; - PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable = 0; - - //=== VK_VERSION_1_4 === - PFN_vkMapMemory2 vkMapMemory2 = 0; - PFN_vkUnmapMemory2 vkUnmapMemory2 = 0; - PFN_vkGetDeviceImageSubresourceLayout vkGetDeviceImageSubresourceLayout = 0; - PFN_vkGetImageSubresourceLayout2 vkGetImageSubresourceLayout2 = 0; - PFN_vkCopyMemoryToImage vkCopyMemoryToImage = 0; - PFN_vkCopyImageToMemory vkCopyImageToMemory = 0; - PFN_vkCopyImageToImage vkCopyImageToImage = 0; - PFN_vkTransitionImageLayout vkTransitionImageLayout = 0; - PFN_vkCmdPushDescriptorSet vkCmdPushDescriptorSet = 0; - PFN_vkCmdPushDescriptorSetWithTemplate vkCmdPushDescriptorSetWithTemplate = 0; - PFN_vkCmdBindDescriptorSets2 vkCmdBindDescriptorSets2 = 0; - PFN_vkCmdPushConstants2 vkCmdPushConstants2 = 0; - PFN_vkCmdPushDescriptorSet2 vkCmdPushDescriptorSet2 = 0; - PFN_vkCmdPushDescriptorSetWithTemplate2 vkCmdPushDescriptorSetWithTemplate2 = 0; - PFN_vkCmdSetLineStipple vkCmdSetLineStipple = 0; - PFN_vkCmdBindIndexBuffer2 vkCmdBindIndexBuffer2 = 0; - PFN_vkGetRenderingAreaGranularity vkGetRenderingAreaGranularity = 0; - PFN_vkCmdSetRenderingAttachmentLocations vkCmdSetRenderingAttachmentLocations = 0; - PFN_vkCmdSetRenderingInputAttachmentIndices vkCmdSetRenderingInputAttachmentIndices = 0; - - //=== VK_KHR_swapchain === - PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR = 0; - PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR = 0; - PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR = 0; - PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR = 0; - PFN_vkQueuePresentKHR vkQueuePresentKHR = 0; - PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR = 0; - PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR = 0; - PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR = 0; - - //=== VK_KHR_display_swapchain === - PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR = 0; - - //=== VK_EXT_debug_marker === - PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT = 0; - PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT = 0; - PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT = 0; - PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT = 0; - PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT = 0; - - //=== VK_KHR_video_queue === - PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR = 0; - PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR = 0; - PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR = 0; - PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR = 0; - PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR = 0; - PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR = 0; - PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR = 0; - PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR = 0; - PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR = 0; - PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR = 0; - - //=== VK_KHR_video_decode_queue === - PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR = 0; - - //=== VK_EXT_transform_feedback === - PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = 0; - PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT = 0; - PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT = 0; - PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT = 0; - PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT = 0; - PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT = 0; - - //=== VK_NVX_binary_import === - PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX = 0; - PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX = 0; - PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX = 0; - PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX = 0; - PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX = 0; - - //=== VK_NVX_image_view_handle === - PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX = 0; - PFN_vkGetImageViewHandle64NVX vkGetImageViewHandle64NVX = 0; - PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX = 0; - PFN_vkGetDeviceCombinedImageSamplerIndexNVX vkGetDeviceCombinedImageSamplerIndexNVX = 0; - - //=== VK_AMD_draw_indirect_count === - PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD = 0; - PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD = 0; - - //=== VK_AMD_shader_info === - PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD = 0; - - //=== VK_KHR_dynamic_rendering === - PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR = 0; - PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR = 0; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - PFN_vkGetMemoryWin32HandleNV vkGetMemoryWin32HandleNV = 0; -# else - PFN_dummy vkGetMemoryWin32HandleNV_placeholder = 0; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_device_group === - PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR = 0; - PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR = 0; - PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR = 0; - - //=== VK_KHR_maintenance1 === - PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR = 0; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR = 0; - PFN_vkGetMemoryWin32HandlePropertiesKHR vkGetMemoryWin32HandlePropertiesKHR = 0; -# else - PFN_dummy vkGetMemoryWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetMemoryWin32HandlePropertiesKHR_placeholder = 0; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR = 0; - PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR = 0; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - PFN_vkImportSemaphoreWin32HandleKHR vkImportSemaphoreWin32HandleKHR = 0; - PFN_vkGetSemaphoreWin32HandleKHR vkGetSemaphoreWin32HandleKHR = 0; -# else - PFN_dummy vkImportSemaphoreWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetSemaphoreWin32HandleKHR_placeholder = 0; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = 0; - PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR = 0; - - //=== VK_KHR_push_descriptor === - PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR = 0; - PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR = 0; - - //=== VK_EXT_conditional_rendering === - PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT = 0; - PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT = 0; - - //=== VK_KHR_descriptor_update_template === - PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR = 0; - PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR = 0; - PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR = 0; - - //=== VK_NV_clip_space_w_scaling === - PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV = 0; - - //=== VK_EXT_display_control === - PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT = 0; - PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT = 0; - PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT = 0; - PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT = 0; - - //=== VK_GOOGLE_display_timing === - PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE = 0; - PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE = 0; - - //=== VK_EXT_discard_rectangles === - PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT = 0; - PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT = 0; - PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT = 0; - - //=== VK_EXT_hdr_metadata === - PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT = 0; - - //=== VK_KHR_create_renderpass2 === - PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = 0; - PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR = 0; - PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR = 0; - PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR = 0; - - //=== VK_KHR_shared_presentable_image === - PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR = 0; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - PFN_vkImportFenceWin32HandleKHR vkImportFenceWin32HandleKHR = 0; - PFN_vkGetFenceWin32HandleKHR vkGetFenceWin32HandleKHR = 0; -# else - PFN_dummy vkImportFenceWin32HandleKHR_placeholder = 0; - PFN_dummy vkGetFenceWin32HandleKHR_placeholder = 0; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - PFN_vkImportFenceFdKHR vkImportFenceFdKHR = 0; - PFN_vkGetFenceFdKHR vkGetFenceFdKHR = 0; - - //=== VK_KHR_performance_query === - PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR = 0; - PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR = 0; - - //=== VK_EXT_debug_utils === - PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT = 0; - PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT = 0; - PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT = 0; - PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT = 0; - PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT = 0; - PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT = 0; - PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT = 0; - PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT = 0; - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID = 0; - PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = 0; -# else - PFN_dummy vkGetAndroidHardwareBufferPropertiesANDROID_placeholder = 0; - PFN_dummy vkGetMemoryAndroidHardwareBufferANDROID_placeholder = 0; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - PFN_vkCreateExecutionGraphPipelinesAMDX vkCreateExecutionGraphPipelinesAMDX = 0; - PFN_vkGetExecutionGraphPipelineScratchSizeAMDX vkGetExecutionGraphPipelineScratchSizeAMDX = 0; - PFN_vkGetExecutionGraphPipelineNodeIndexAMDX vkGetExecutionGraphPipelineNodeIndexAMDX = 0; - PFN_vkCmdInitializeGraphScratchMemoryAMDX vkCmdInitializeGraphScratchMemoryAMDX = 0; - PFN_vkCmdDispatchGraphAMDX vkCmdDispatchGraphAMDX = 0; - PFN_vkCmdDispatchGraphIndirectAMDX vkCmdDispatchGraphIndirectAMDX = 0; - PFN_vkCmdDispatchGraphIndirectCountAMDX vkCmdDispatchGraphIndirectCountAMDX = 0; -# else - PFN_dummy vkCreateExecutionGraphPipelinesAMDX_placeholder = 0; - PFN_dummy vkGetExecutionGraphPipelineScratchSizeAMDX_placeholder = 0; - PFN_dummy vkGetExecutionGraphPipelineNodeIndexAMDX_placeholder = 0; - PFN_dummy vkCmdInitializeGraphScratchMemoryAMDX_placeholder = 0; - PFN_dummy vkCmdDispatchGraphAMDX_placeholder = 0; - PFN_dummy vkCmdDispatchGraphIndirectAMDX_placeholder = 0; - PFN_dummy vkCmdDispatchGraphIndirectCountAMDX_placeholder = 0; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - PFN_vkWriteSamplerDescriptorsEXT vkWriteSamplerDescriptorsEXT = 0; - PFN_vkWriteResourceDescriptorsEXT vkWriteResourceDescriptorsEXT = 0; - PFN_vkCmdBindSamplerHeapEXT vkCmdBindSamplerHeapEXT = 0; - PFN_vkCmdBindResourceHeapEXT vkCmdBindResourceHeapEXT = 0; - PFN_vkCmdPushDataEXT vkCmdPushDataEXT = 0; - PFN_vkGetImageOpaqueCaptureDataEXT vkGetImageOpaqueCaptureDataEXT = 0; - PFN_vkRegisterCustomBorderColorEXT vkRegisterCustomBorderColorEXT = 0; - PFN_vkUnregisterCustomBorderColorEXT vkUnregisterCustomBorderColorEXT = 0; - PFN_vkGetTensorOpaqueCaptureDataARM vkGetTensorOpaqueCaptureDataARM = 0; - - //=== VK_EXT_sample_locations === - PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT = 0; - - //=== VK_KHR_get_memory_requirements2 === - PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR = 0; - PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = 0; - PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR = 0; - - //=== VK_KHR_acceleration_structure === - PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR = 0; - PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR = 0; - PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR = 0; - PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR = 0; - PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR = 0; - PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR = 0; - PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR = 0; - PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR = 0; - PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR = 0; - PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR = 0; - PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR = 0; - PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR = 0; - PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR = 0; - PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR = 0; - PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR = 0; - PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR = 0; - - //=== VK_KHR_ray_tracing_pipeline === - PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR = 0; - PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR = 0; - PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR = 0; - PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = 0; - PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR = 0; - PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR = 0; - PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR = 0; - - //=== VK_KHR_sampler_ycbcr_conversion === - PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR = 0; - PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = 0; - - //=== VK_KHR_bind_memory2 === - PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = 0; - PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR = 0; - - //=== VK_EXT_image_drm_format_modifier === - PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT = 0; - - //=== VK_EXT_validation_cache === - PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT = 0; - PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT = 0; - PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT = 0; - PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT = 0; - - //=== VK_NV_shading_rate_image === - PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV = 0; - PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV = 0; - PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV = 0; - - //=== VK_NV_ray_tracing === - PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = 0; - PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV = 0; - PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV = 0; - PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV = 0; - PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV = 0; - PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV = 0; - PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV = 0; - PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = 0; - PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV = 0; - PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV = 0; - PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV = 0; - PFN_vkCompileDeferredNV vkCompileDeferredNV = 0; - - //=== VK_KHR_maintenance3 === - PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR = 0; - - //=== VK_KHR_draw_indirect_count === - PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR = 0; - PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR = 0; - - //=== VK_EXT_external_memory_host === - PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = 0; - - //=== VK_AMD_buffer_marker === - PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD = 0; - PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD = 0; - - //=== VK_EXT_calibrated_timestamps === - PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT = 0; - - //=== VK_NV_mesh_shader === - PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV = 0; - PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV = 0; - PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV = 0; - - //=== VK_NV_scissor_exclusive === - PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV = 0; - PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV = 0; - - //=== VK_NV_device_diagnostic_checkpoints === - PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV = 0; - PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV = 0; - PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV = 0; - - //=== VK_KHR_timeline_semaphore === - PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR = 0; - PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR = 0; - PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR = 0; - - //=== VK_EXT_present_timing === - PFN_vkSetSwapchainPresentTimingQueueSizeEXT vkSetSwapchainPresentTimingQueueSizeEXT = 0; - PFN_vkGetSwapchainTimingPropertiesEXT vkGetSwapchainTimingPropertiesEXT = 0; - PFN_vkGetSwapchainTimeDomainPropertiesEXT vkGetSwapchainTimeDomainPropertiesEXT = 0; - PFN_vkGetPastPresentationTimingEXT vkGetPastPresentationTimingEXT = 0; - - //=== VK_INTEL_performance_query === - PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL = 0; - PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL = 0; - PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL = 0; - PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL = 0; - PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL = 0; - PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL = 0; - PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL = 0; - PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL = 0; - PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL = 0; - - //=== VK_AMD_display_native_hdr === - PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD = 0; - - //=== VK_KHR_fragment_shading_rate === - PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR = 0; - - //=== VK_KHR_dynamic_rendering_local_read === - PFN_vkCmdSetRenderingAttachmentLocationsKHR vkCmdSetRenderingAttachmentLocationsKHR = 0; - PFN_vkCmdSetRenderingInputAttachmentIndicesKHR vkCmdSetRenderingInputAttachmentIndicesKHR = 0; - - //=== VK_EXT_buffer_device_address === - PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT = 0; - - //=== VK_KHR_present_wait === - PFN_vkWaitForPresentKHR vkWaitForPresentKHR = 0; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - PFN_vkAcquireFullScreenExclusiveModeEXT vkAcquireFullScreenExclusiveModeEXT = 0; - PFN_vkReleaseFullScreenExclusiveModeEXT vkReleaseFullScreenExclusiveModeEXT = 0; - PFN_vkGetDeviceGroupSurfacePresentModes2EXT vkGetDeviceGroupSurfacePresentModes2EXT = 0; -# else - PFN_dummy vkAcquireFullScreenExclusiveModeEXT_placeholder = 0; - PFN_dummy vkReleaseFullScreenExclusiveModeEXT_placeholder = 0; - PFN_dummy vkGetDeviceGroupSurfacePresentModes2EXT_placeholder = 0; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_buffer_device_address === - PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR = 0; - PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR = 0; - PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR = 0; - - //=== VK_EXT_line_rasterization === - PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT = 0; - - //=== VK_EXT_host_query_reset === - PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT = 0; - - //=== VK_EXT_extended_dynamic_state === - PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT = 0; - PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT = 0; - PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT = 0; - PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT = 0; - PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT = 0; - PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT = 0; - PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT = 0; - PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT = 0; - PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT = 0; - PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT = 0; - PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT = 0; - PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT = 0; - - //=== VK_KHR_deferred_host_operations === - PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR = 0; - PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR = 0; - PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR = 0; - PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR = 0; - PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR = 0; - - //=== VK_KHR_pipeline_executable_properties === - PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR = 0; - PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR = 0; - PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR = 0; - - //=== VK_EXT_host_image_copy === - PFN_vkCopyMemoryToImageEXT vkCopyMemoryToImageEXT = 0; - PFN_vkCopyImageToMemoryEXT vkCopyImageToMemoryEXT = 0; - PFN_vkCopyImageToImageEXT vkCopyImageToImageEXT = 0; - PFN_vkTransitionImageLayoutEXT vkTransitionImageLayoutEXT = 0; - PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT = 0; - - //=== VK_KHR_map_memory2 === - PFN_vkMapMemory2KHR vkMapMemory2KHR = 0; - PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR = 0; - - //=== VK_EXT_swapchain_maintenance1 === - PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT = 0; - - //=== VK_NV_device_generated_commands === - PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV = 0; - PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV = 0; - PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV = 0; - PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV = 0; - PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV = 0; - PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV = 0; - - //=== VK_EXT_depth_bias_control === - PFN_vkCmdSetDepthBias2EXT vkCmdSetDepthBias2EXT = 0; - - //=== VK_EXT_private_data === - PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT = 0; - PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT = 0; - PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT = 0; - PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT = 0; - - //=== VK_KHR_video_encode_queue === - PFN_vkGetEncodedVideoSessionParametersKHR vkGetEncodedVideoSessionParametersKHR = 0; - PFN_vkCmdEncodeVideoKHR vkCmdEncodeVideoKHR = 0; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - PFN_vkCreateCudaModuleNV vkCreateCudaModuleNV = 0; - PFN_vkGetCudaModuleCacheNV vkGetCudaModuleCacheNV = 0; - PFN_vkCreateCudaFunctionNV vkCreateCudaFunctionNV = 0; - PFN_vkDestroyCudaModuleNV vkDestroyCudaModuleNV = 0; - PFN_vkDestroyCudaFunctionNV vkDestroyCudaFunctionNV = 0; - PFN_vkCmdCudaLaunchKernelNV vkCmdCudaLaunchKernelNV = 0; -# else - PFN_dummy vkCreateCudaModuleNV_placeholder = 0; - PFN_dummy vkGetCudaModuleCacheNV_placeholder = 0; - PFN_dummy vkCreateCudaFunctionNV_placeholder = 0; - PFN_dummy vkDestroyCudaModuleNV_placeholder = 0; - PFN_dummy vkDestroyCudaFunctionNV_placeholder = 0; - PFN_dummy vkCmdCudaLaunchKernelNV_placeholder = 0; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - PFN_vkCmdDispatchTileQCOM vkCmdDispatchTileQCOM = 0; - PFN_vkCmdBeginPerTileExecutionQCOM vkCmdBeginPerTileExecutionQCOM = 0; - PFN_vkCmdEndPerTileExecutionQCOM vkCmdEndPerTileExecutionQCOM = 0; - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0; -# else - PFN_dummy vkExportMetalObjectsEXT_placeholder = 0; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_synchronization2 === - PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR = 0; - PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR = 0; - PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR = 0; - PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR = 0; - PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR = 0; - PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR = 0; - - //=== VK_EXT_descriptor_buffer === - PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT = 0; - PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT = 0; - PFN_vkGetDescriptorEXT vkGetDescriptorEXT = 0; - PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT = 0; - PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT = 0; - PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT = 0; - PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT = 0; - PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT = 0; - PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT = 0; - PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT = 0; - PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = 0; - - //=== VK_NV_fragment_shading_rate_enums === - PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV = 0; - - //=== VK_EXT_mesh_shader === - PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT = 0; - PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT = 0; - PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT = 0; - - //=== VK_KHR_copy_commands2 === - PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR = 0; - PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR = 0; - PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR = 0; - PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR = 0; - PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR = 0; - PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR = 0; - - //=== VK_EXT_device_fault === - PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT = 0; - - //=== VK_EXT_vertex_input_dynamic_state === - PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT = 0; - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - PFN_vkGetMemoryZirconHandleFUCHSIA vkGetMemoryZirconHandleFUCHSIA = 0; - PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA vkGetMemoryZirconHandlePropertiesFUCHSIA = 0; -# else - PFN_dummy vkGetMemoryZirconHandleFUCHSIA_placeholder = 0; - PFN_dummy vkGetMemoryZirconHandlePropertiesFUCHSIA_placeholder = 0; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - PFN_vkImportSemaphoreZirconHandleFUCHSIA vkImportSemaphoreZirconHandleFUCHSIA = 0; - PFN_vkGetSemaphoreZirconHandleFUCHSIA vkGetSemaphoreZirconHandleFUCHSIA = 0; -# else - PFN_dummy vkImportSemaphoreZirconHandleFUCHSIA_placeholder = 0; - PFN_dummy vkGetSemaphoreZirconHandleFUCHSIA_placeholder = 0; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - PFN_vkCreateBufferCollectionFUCHSIA vkCreateBufferCollectionFUCHSIA = 0; - PFN_vkSetBufferCollectionImageConstraintsFUCHSIA vkSetBufferCollectionImageConstraintsFUCHSIA = 0; - PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA vkSetBufferCollectionBufferConstraintsFUCHSIA = 0; - PFN_vkDestroyBufferCollectionFUCHSIA vkDestroyBufferCollectionFUCHSIA = 0; - PFN_vkGetBufferCollectionPropertiesFUCHSIA vkGetBufferCollectionPropertiesFUCHSIA = 0; -# else - PFN_dummy vkCreateBufferCollectionFUCHSIA_placeholder = 0; - PFN_dummy vkSetBufferCollectionImageConstraintsFUCHSIA_placeholder = 0; - PFN_dummy vkSetBufferCollectionBufferConstraintsFUCHSIA_placeholder = 0; - PFN_dummy vkDestroyBufferCollectionFUCHSIA_placeholder = 0; - PFN_dummy vkGetBufferCollectionPropertiesFUCHSIA_placeholder = 0; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = 0; - PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI = 0; - - //=== VK_HUAWEI_invocation_mask === - PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI = 0; - - //=== VK_NV_external_memory_rdma === - PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV = 0; - - //=== VK_EXT_pipeline_properties === - PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT = 0; - - //=== VK_EXT_extended_dynamic_state2 === - PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT = 0; - PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT = 0; - PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT = 0; - PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT = 0; - PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT = 0; - - //=== VK_EXT_color_write_enable === - PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT = 0; - - //=== VK_KHR_ray_tracing_maintenance1 === - PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR = 0; - - //=== VK_EXT_multi_draw === - PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT = 0; - PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT = 0; - - //=== VK_EXT_opacity_micromap === - PFN_vkCreateMicromapEXT vkCreateMicromapEXT = 0; - PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT = 0; - PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT = 0; - PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT = 0; - PFN_vkCopyMicromapEXT vkCopyMicromapEXT = 0; - PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT = 0; - PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT = 0; - PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT = 0; - PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT = 0; - PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT = 0; - PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT = 0; - PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT = 0; - PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT = 0; - PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT = 0; - - //=== VK_HUAWEI_cluster_culling_shader === - PFN_vkCmdDrawClusterHUAWEI vkCmdDrawClusterHUAWEI = 0; - PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI = 0; - - //=== VK_EXT_pageable_device_local_memory === - PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT = 0; - - //=== VK_KHR_maintenance4 === - PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR = 0; - PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR = 0; - PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR = 0; - - //=== VK_VALVE_descriptor_set_host_mapping === - PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE = 0; - PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE = 0; - - //=== VK_NV_copy_memory_indirect === - PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV = 0; - PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV = 0; - - //=== VK_NV_memory_decompression === - PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV = 0; - PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV = 0; - - //=== VK_NV_device_generated_commands_compute === - PFN_vkGetPipelineIndirectMemoryRequirementsNV vkGetPipelineIndirectMemoryRequirementsNV = 0; - PFN_vkCmdUpdatePipelineIndirectBufferNV vkCmdUpdatePipelineIndirectBufferNV = 0; - PFN_vkGetPipelineIndirectDeviceAddressNV vkGetPipelineIndirectDeviceAddressNV = 0; - -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - PFN_vkGetNativeBufferPropertiesOHOS vkGetNativeBufferPropertiesOHOS = 0; - PFN_vkGetMemoryNativeBufferOHOS vkGetMemoryNativeBufferOHOS = 0; -# else - PFN_dummy vkGetNativeBufferPropertiesOHOS_placeholder = 0; - PFN_dummy vkGetMemoryNativeBufferOHOS_placeholder = 0; -# endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_extended_dynamic_state3 === - PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT = 0; - PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT = 0; - PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT = 0; - PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT = 0; - PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT = 0; - PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT = 0; - PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT = 0; - PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT = 0; - PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT = 0; - PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT = 0; - PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT = 0; - PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT = 0; - PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT = 0; - PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT = 0; - PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT = 0; - PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT = 0; - PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT = 0; - PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT = 0; - PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT = 0; - PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT = 0; - PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT = 0; - PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV = 0; - PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV = 0; - PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV = 0; - PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV = 0; - PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV = 0; - PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV = 0; - PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV = 0; - PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV = 0; - PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV = 0; - PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV = 0; - - //=== VK_ARM_tensors === - PFN_vkCreateTensorARM vkCreateTensorARM = 0; - PFN_vkDestroyTensorARM vkDestroyTensorARM = 0; - PFN_vkCreateTensorViewARM vkCreateTensorViewARM = 0; - PFN_vkDestroyTensorViewARM vkDestroyTensorViewARM = 0; - PFN_vkGetTensorMemoryRequirementsARM vkGetTensorMemoryRequirementsARM = 0; - PFN_vkBindTensorMemoryARM vkBindTensorMemoryARM = 0; - PFN_vkGetDeviceTensorMemoryRequirementsARM vkGetDeviceTensorMemoryRequirementsARM = 0; - PFN_vkCmdCopyTensorARM vkCmdCopyTensorARM = 0; - PFN_vkGetTensorOpaqueCaptureDescriptorDataARM vkGetTensorOpaqueCaptureDescriptorDataARM = 0; - PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM vkGetTensorViewOpaqueCaptureDescriptorDataARM = 0; - - //=== VK_EXT_shader_module_identifier === - PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT = 0; - PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT = 0; - - //=== VK_NV_optical_flow === - PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV = 0; - PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV = 0; - PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV = 0; - PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV = 0; - - //=== VK_KHR_maintenance5 === - PFN_vkCmdBindIndexBuffer2KHR vkCmdBindIndexBuffer2KHR = 0; - PFN_vkGetRenderingAreaGranularityKHR vkGetRenderingAreaGranularityKHR = 0; - PFN_vkGetDeviceImageSubresourceLayoutKHR vkGetDeviceImageSubresourceLayoutKHR = 0; - PFN_vkGetImageSubresourceLayout2KHR vkGetImageSubresourceLayout2KHR = 0; - - //=== VK_AMD_anti_lag === - PFN_vkAntiLagUpdateAMD vkAntiLagUpdateAMD = 0; - - //=== VK_KHR_present_wait2 === - PFN_vkWaitForPresent2KHR vkWaitForPresent2KHR = 0; - - //=== VK_EXT_shader_object === - PFN_vkCreateShadersEXT vkCreateShadersEXT = 0; - PFN_vkDestroyShaderEXT vkDestroyShaderEXT = 0; - PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0; - PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 0; - PFN_vkCmdSetDepthClampRangeEXT vkCmdSetDepthClampRangeEXT = 0; - - //=== VK_KHR_pipeline_binary === - PFN_vkCreatePipelineBinariesKHR vkCreatePipelineBinariesKHR = 0; - PFN_vkDestroyPipelineBinaryKHR vkDestroyPipelineBinaryKHR = 0; - PFN_vkGetPipelineKeyKHR vkGetPipelineKeyKHR = 0; - PFN_vkGetPipelineBinaryDataKHR vkGetPipelineBinaryDataKHR = 0; - PFN_vkReleaseCapturedPipelineDataKHR vkReleaseCapturedPipelineDataKHR = 0; - - //=== VK_QCOM_tile_properties === - PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0; - PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0; - - //=== VK_KHR_swapchain_maintenance1 === - PFN_vkReleaseSwapchainImagesKHR vkReleaseSwapchainImagesKHR = 0; - - //=== VK_NV_cooperative_vector === - PFN_vkConvertCooperativeVectorMatrixNV vkConvertCooperativeVectorMatrixNV = 0; - PFN_vkCmdConvertCooperativeVectorMatrixNV vkCmdConvertCooperativeVectorMatrixNV = 0; - - //=== VK_NV_low_latency2 === - PFN_vkSetLatencySleepModeNV vkSetLatencySleepModeNV = 0; - PFN_vkLatencySleepNV vkLatencySleepNV = 0; - PFN_vkSetLatencyMarkerNV vkSetLatencyMarkerNV = 0; - PFN_vkGetLatencyTimingsNV vkGetLatencyTimingsNV = 0; - PFN_vkQueueNotifyOutOfBandNV vkQueueNotifyOutOfBandNV = 0; - - //=== VK_ARM_data_graph === - PFN_vkCreateDataGraphPipelinesARM vkCreateDataGraphPipelinesARM = 0; - PFN_vkCreateDataGraphPipelineSessionARM vkCreateDataGraphPipelineSessionARM = 0; - PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM vkGetDataGraphPipelineSessionBindPointRequirementsARM = 0; - PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM vkGetDataGraphPipelineSessionMemoryRequirementsARM = 0; - PFN_vkBindDataGraphPipelineSessionMemoryARM vkBindDataGraphPipelineSessionMemoryARM = 0; - PFN_vkDestroyDataGraphPipelineSessionARM vkDestroyDataGraphPipelineSessionARM = 0; - PFN_vkCmdDispatchDataGraphARM vkCmdDispatchDataGraphARM = 0; - PFN_vkGetDataGraphPipelineAvailablePropertiesARM vkGetDataGraphPipelineAvailablePropertiesARM = 0; - PFN_vkGetDataGraphPipelinePropertiesARM vkGetDataGraphPipelinePropertiesARM = 0; - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT = 0; - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - PFN_vkGetScreenBufferPropertiesQNX vkGetScreenBufferPropertiesQNX = 0; -# else - PFN_dummy vkGetScreenBufferPropertiesQNX_placeholder = 0; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_KHR_line_rasterization === - PFN_vkCmdSetLineStippleKHR vkCmdSetLineStippleKHR = 0; - - //=== VK_KHR_calibrated_timestamps === - PFN_vkGetCalibratedTimestampsKHR vkGetCalibratedTimestampsKHR = 0; - - //=== VK_KHR_maintenance6 === - PFN_vkCmdBindDescriptorSets2KHR vkCmdBindDescriptorSets2KHR = 0; - PFN_vkCmdPushConstants2KHR vkCmdPushConstants2KHR = 0; - PFN_vkCmdPushDescriptorSet2KHR vkCmdPushDescriptorSet2KHR = 0; - PFN_vkCmdPushDescriptorSetWithTemplate2KHR vkCmdPushDescriptorSetWithTemplate2KHR = 0; - PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0; - PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0; - - //=== VK_QCOM_tile_memory_heap === - PFN_vkCmdBindTileMemoryQCOM vkCmdBindTileMemoryQCOM = 0; - - //=== VK_KHR_copy_memory_indirect === - PFN_vkCmdCopyMemoryIndirectKHR vkCmdCopyMemoryIndirectKHR = 0; - PFN_vkCmdCopyMemoryToImageIndirectKHR vkCmdCopyMemoryToImageIndirectKHR = 0; - - //=== VK_EXT_memory_decompression === - PFN_vkCmdDecompressMemoryEXT vkCmdDecompressMemoryEXT = 0; - PFN_vkCmdDecompressMemoryIndirectCountEXT vkCmdDecompressMemoryIndirectCountEXT = 0; - - //=== VK_NV_external_compute_queue === - PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0; - PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0; - PFN_vkGetExternalComputeQueueDataNV vkGetExternalComputeQueueDataNV = 0; - - //=== VK_NV_cluster_acceleration_structure === - PFN_vkGetClusterAccelerationStructureBuildSizesNV vkGetClusterAccelerationStructureBuildSizesNV = 0; - PFN_vkCmdBuildClusterAccelerationStructureIndirectNV vkCmdBuildClusterAccelerationStructureIndirectNV = 0; - - //=== VK_NV_partitioned_acceleration_structure === - PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV vkGetPartitionedAccelerationStructuresBuildSizesNV = 0; - PFN_vkCmdBuildPartitionedAccelerationStructuresNV vkCmdBuildPartitionedAccelerationStructuresNV = 0; - - //=== VK_EXT_device_generated_commands === - PFN_vkGetGeneratedCommandsMemoryRequirementsEXT vkGetGeneratedCommandsMemoryRequirementsEXT = 0; - PFN_vkCmdPreprocessGeneratedCommandsEXT vkCmdPreprocessGeneratedCommandsEXT = 0; - PFN_vkCmdExecuteGeneratedCommandsEXT vkCmdExecuteGeneratedCommandsEXT = 0; - PFN_vkCreateIndirectCommandsLayoutEXT vkCreateIndirectCommandsLayoutEXT = 0; - PFN_vkDestroyIndirectCommandsLayoutEXT vkDestroyIndirectCommandsLayoutEXT = 0; - PFN_vkCreateIndirectExecutionSetEXT vkCreateIndirectExecutionSetEXT = 0; - PFN_vkDestroyIndirectExecutionSetEXT vkDestroyIndirectExecutionSetEXT = 0; - PFN_vkUpdateIndirectExecutionSetPipelineEXT vkUpdateIndirectExecutionSetPipelineEXT = 0; - PFN_vkUpdateIndirectExecutionSetShaderEXT vkUpdateIndirectExecutionSetShaderEXT = 0; - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - PFN_vkGetMemoryMetalHandleEXT vkGetMemoryMetalHandleEXT = 0; - PFN_vkGetMemoryMetalHandlePropertiesEXT vkGetMemoryMetalHandlePropertiesEXT = 0; -# else - PFN_dummy vkGetMemoryMetalHandleEXT_placeholder = 0; - PFN_dummy vkGetMemoryMetalHandlePropertiesEXT_placeholder = 0; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_fragment_density_map_offset === - PFN_vkCmdEndRendering2EXT vkCmdEndRendering2EXT = 0; - - //=== VK_EXT_custom_resolve === - PFN_vkCmdBeginCustomResolveEXT vkCmdBeginCustomResolveEXT = 0; - - //=== VK_KHR_maintenance10 === - PFN_vkCmdEndRendering2KHR vkCmdEndRendering2KHR = 0; - - //=== VK_NV_compute_occupancy_priority === - PFN_vkCmdSetComputeOccupancyPriorityNV vkCmdSetComputeOccupancyPriorityNV = 0; - }; - - } // namespace detail - - //======================================== - //=== RAII HANDLE forward declarations === - //======================================== - - //=== VK_VERSION_1_0 === - class Instance; - class PhysicalDevice; - class Device; - class Queue; - class DeviceMemory; - class Fence; - class Semaphore; - class QueryPool; - class Buffer; - class Image; - class ImageView; - class CommandPool; - class CommandBuffer; - class Event; - class BufferView; - class ShaderModule; - class PipelineCache; - class Pipeline; - class PipelineLayout; - class Sampler; - class DescriptorPool; - class DescriptorSet; - class DescriptorSetLayout; - class Framebuffer; - class RenderPass; - - //=== VK_VERSION_1_1 === - class DescriptorUpdateTemplate; - class SamplerYcbcrConversion; - - //=== VK_VERSION_1_3 === - class PrivateDataSlot; - - //=== VK_KHR_surface === - class SurfaceKHR; - - //=== VK_KHR_swapchain === - class SwapchainKHR; - - //=== VK_KHR_display === - class DisplayKHR; - class DisplayModeKHR; - - //=== VK_EXT_debug_report === - class DebugReportCallbackEXT; - - //=== VK_KHR_video_queue === - class VideoSessionKHR; - class VideoSessionParametersKHR; - - //=== VK_NVX_binary_import === - class CuModuleNVX; - class CuFunctionNVX; - - //=== VK_KHR_descriptor_update_template === - using DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate; - - //=== VK_EXT_debug_utils === - class DebugUtilsMessengerEXT; - - //=== VK_EXT_descriptor_heap === - class TensorARM; - - //=== VK_KHR_acceleration_structure === - class AccelerationStructureKHR; - - //=== VK_KHR_sampler_ycbcr_conversion === - using SamplerYcbcrConversionKHR = SamplerYcbcrConversion; - - //=== VK_EXT_validation_cache === - class ValidationCacheEXT; - - //=== VK_NV_ray_tracing === - class AccelerationStructureNV; - - //=== VK_INTEL_performance_query === - class PerformanceConfigurationINTEL; - - //=== VK_KHR_deferred_host_operations === - class DeferredOperationKHR; - - //=== VK_NV_device_generated_commands === - class IndirectCommandsLayoutNV; - - //=== VK_EXT_private_data === - using PrivateDataSlotEXT = PrivateDataSlot; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - class CudaModuleNV; - class CudaFunctionNV; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - class BufferCollectionFUCHSIA; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_EXT_opacity_micromap === - class MicromapEXT; - - //=== VK_ARM_tensors === - class TensorARM; - class TensorViewARM; - - //=== VK_NV_optical_flow === - class OpticalFlowSessionNV; - - //=== VK_EXT_shader_object === - class ShaderEXT; - - //=== VK_KHR_pipeline_binary === - class PipelineBinaryKHR; - - //=== VK_ARM_data_graph === - class DataGraphPipelineSessionARM; - - //=== VK_NV_external_compute_queue === - class ExternalComputeQueueNV; - - //=== VK_EXT_device_generated_commands === - class IndirectCommandsLayoutEXT; - class IndirectExecutionSetEXT; - - //==================== - //=== RAII HANDLES === - //==================== - - template - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = false; - }; - - class Context - { - public: -# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL - Context() : m_dispatcher( new detail::ContextDispatcher( m_dynamicLoader.getProcAddress( "vkGetInstanceProcAddr" ) ) ) -# else - Context( PFN_vkGetInstanceProcAddr getInstanceProcAddr ) : m_dispatcher( new detail::ContextDispatcher( getInstanceProcAddr ) ) -# endif - { - } - - ~Context() = default; - - Context( Context const & ) = delete; - Context( Context && rhs ) VULKAN_HPP_NOEXCEPT -# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL - : m_dynamicLoader( std::move( rhs.m_dynamicLoader ) ) - , m_dispatcher( rhs.m_dispatcher.release() ) -# else - : m_dispatcher( rhs.m_dispatcher.release() ) -# endif - { - } - Context & operator=( Context const & ) = delete; - - Context & operator=( Context && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { -# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL - m_dynamicLoader = std::move( rhs.m_dynamicLoader ); -# endif - m_dispatcher.reset( rhs.m_dispatcher.release() ); - } - return *this; - } - - detail::ContextDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return &*m_dispatcher; - } - - void swap( Context & rhs ) - { -# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL - std::swap( m_dynamicLoader, rhs.m_dynamicLoader ); -# endif - m_dispatcher.swap( rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createInstance( InstanceCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkEnumerateInstanceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateInstanceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; - - // wrapper function for command vkEnumerateInstanceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateInstanceLayerProperties() const; - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html - VULKAN_HPP_NODISCARD typename ResultValueType::type enumerateInstanceVersion() const; - - private: -# if VULKAN_HPP_ENABLE_DYNAMIC_LOADER_TOOL - VULKAN_HPP_NAMESPACE::detail::DynamicLoader m_dynamicLoader; -# endif - std::unique_ptr m_dispatcher; - }; - - // wrapper class for handle VkInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstance.html - class Instance - { - public: - using CType = VkInstance; - using CppType = VULKAN_HPP_NAMESPACE::Instance; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eInstance; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eInstance; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Instance( Context const & context, InstanceCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = context.createInstance( createInfo, allocator ); - } -# endif - - Instance( Context const & context, VkInstance instance, Optional allocator = nullptr ) - : m_instance( instance ), m_allocator( static_cast( allocator ) ) - { - m_dispatcher.reset( new detail::InstanceDispatcher( context.getDispatcher()->vkGetInstanceProcAddr, static_cast( m_instance ) ) ); - } - - Instance( std::nullptr_t ) {} - - ~Instance() - { - clear(); - } - - Instance() = delete; - Instance( Instance const & ) = delete; - - Instance( Instance && rhs ) VULKAN_HPP_NOEXCEPT - : m_instance( exchange( rhs.m_instance, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( rhs.m_dispatcher.release() ) - { - } - - Instance & operator=( Instance const & ) = delete; - - Instance & operator=( Instance && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_instance, rhs.m_instance ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::Instance const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_instance; - } - - VULKAN_HPP_NAMESPACE::Instance const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_instance ); - } - - operator VULKAN_HPP_NAMESPACE::Instance() const VULKAN_HPP_NOEXCEPT - { - return m_instance; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_instance ) - { - getDispatcher()->vkDestroyInstance( static_cast( m_instance ), reinterpret_cast( m_allocator ) ); - } - m_instance = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::Instance release() - { - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_instance, nullptr ); - } - - detail::InstanceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return &*m_dispatcher; - } - - void swap( Instance & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_instance, rhs.m_instance ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type enumeratePhysicalDevices() const; - - // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html - VULKAN_HPP_NODISCARD PFN_VoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkEnumeratePhysicalDeviceGroups, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type enumeratePhysicalDeviceGroups() const; - - //=== VK_KHR_display === - - // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDisplayPlaneSurfaceKHR( DisplaySurfaceCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - -# if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - - // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createXlibSurfaceKHR( XlibSurfaceCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -# if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - - // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createXcbSurfaceKHR( XcbSurfaceCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_XCB_KHR*/ - -# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - - // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createWaylandSurfaceKHR( WaylandSurfaceCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - - // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createAndroidSurfaceKHR( AndroidSurfaceCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - - // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createWin32SurfaceKHR( Win32SurfaceCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - - // wrapper function for command vkCreateDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDebugReportCallbackEXT( DebugReportCallbackCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html - void debugReportMessageEXT( DebugReportFlagsEXT flags, - DebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const std::string & layerPrefix, - const std::string & message ) const VULKAN_HPP_NOEXCEPT; - -# if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - - // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createStreamDescriptorSurfaceGGP( StreamDescriptorSurfaceCreateInfoGGP const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_GGP*/ - -# if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - - // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createViSurfaceNN( ViSurfaceCreateInfoNN const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_device_group_creation === - - // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type enumeratePhysicalDeviceGroupsKHR() const; - -# if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - - // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createIOSSurfaceMVK( IOSSurfaceCreateInfoMVK const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_IOS_MVK*/ - -# if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - - // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createMacOSSurfaceMVK( MacOSSurfaceCreateInfoMVK const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - - // wrapper function for command vkCreateDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDebugUtilsMessengerEXT( DebugUtilsMessengerCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkSubmitDebugUtilsMessageEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html - void submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - DebugUtilsMessageTypeFlagsEXT messageTypes, - const DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT; - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - - // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createImagePipeSurfaceFUCHSIA( ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - - // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createMetalSurfaceEXT( MetalSurfaceCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_headless_surface === - - // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createHeadlessSurfaceEXT( HeadlessSurfaceCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - -# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - - // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDirectFBSurfaceEXT( DirectFBSurfaceCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - - // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createScreenSurfaceQNX( ScreenSurfaceCreateInfoQNX const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - - // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSurfaceOHOS( SurfaceCreateInfoOHOS const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_OHOS*/ - - private: - VULKAN_HPP_NAMESPACE::Instance m_instance = {}; - const AllocationCallbacks * m_allocator = {}; - std::unique_ptr m_dispatcher; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPhysicalDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice.html - class PhysicalDevice - { - public: - using CType = VkPhysicalDevice; - using CppType = VULKAN_HPP_NAMESPACE::PhysicalDevice; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePhysicalDevice; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePhysicalDevice; - - public: - PhysicalDevice( Instance const & instance, VkPhysicalDevice physicalDevice ) - : m_physicalDevice( physicalDevice ), m_dispatcher( instance.getDispatcher() ) - { - } - - PhysicalDevice( std::nullptr_t ) {} - - ~PhysicalDevice() - { - clear(); - } - - PhysicalDevice() = delete; - - PhysicalDevice( PhysicalDevice const & rhs ) : m_physicalDevice( rhs.m_physicalDevice ), m_dispatcher( rhs.m_dispatcher ) {} - - PhysicalDevice( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT - : m_physicalDevice( exchange( rhs.m_physicalDevice, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - PhysicalDevice & operator=( PhysicalDevice const & rhs ) - { - m_physicalDevice = rhs.m_physicalDevice; - m_dispatcher = rhs.m_dispatcher; - return *this; - } - - PhysicalDevice & operator=( PhysicalDevice && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_physicalDevice, rhs.m_physicalDevice ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::PhysicalDevice const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_physicalDevice; - } - - VULKAN_HPP_NAMESPACE::PhysicalDevice const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_physicalDevice ); - } - - operator VULKAN_HPP_NAMESPACE::PhysicalDevice() const VULKAN_HPP_NOEXCEPT - { - return m_physicalDevice; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - m_physicalDevice = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::PhysicalDevice release() - { - m_dispatcher = nullptr; - return exchange( m_physicalDevice, nullptr ); - } - - detail::InstanceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( PhysicalDevice & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_physicalDevice, rhs.m_physicalDevice ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkGetPhysicalDeviceFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html - VULKAN_HPP_NODISCARD PhysicalDeviceFeatures getFeatures() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html - VULKAN_HPP_NODISCARD FormatProperties getFormatProperties( Format format ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getImageFormatProperties( - Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - // wrapper function for command vkGetPhysicalDeviceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html - VULKAN_HPP_NODISCARD PhysicalDeviceProperties getProperties() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html - VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties() const; - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html - VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties getMemoryProperties() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDevice( DeviceCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkEnumerateDeviceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - enumerateDeviceExtensionProperties( Optional layerName VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; - - // wrapper function for command vkEnumerateDeviceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type enumerateDeviceLayerProperties() const; - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html - VULKAN_HPP_NODISCARD std::vector - getSparseImageFormatProperties( Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling ) const; - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkGetPhysicalDeviceFeatures2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html - VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceFeatures2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html - template - VULKAN_HPP_NODISCARD StructureChain getFeatures2() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html - VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html - template - VULKAN_HPP_NODISCARD StructureChain getProperties2() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html - VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2( Format format ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html - template - VULKAN_HPP_NODISCARD StructureChain getFormatProperties2( Format format ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - VULKAN_HPP_NODISCARD Result getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, - ImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2() const; - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template - VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2() const; - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html - VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2 getMemoryProperties2() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html - template - VULKAN_HPP_NODISCARD StructureChain getMemoryProperties2() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html - VULKAN_HPP_NODISCARD std::vector - getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const; - - // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html - VULKAN_HPP_NODISCARD ExternalBufferProperties - getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html - VULKAN_HPP_NODISCARD ExternalFenceProperties - getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html - VULKAN_HPP_NODISCARD ExternalSemaphoreProperties - getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_VERSION_1_3 === - - // wrapper function for command vkGetPhysicalDeviceToolProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getToolProperties() const; - - //=== VK_KHR_surface === - - // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getSurfaceSupportKHR( uint32_t queueFamilyIndex, - VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - //=== VK_KHR_swapchain === - - // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; - - //=== VK_KHR_display === - - // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPropertiesKHR() const; - - // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlanePropertiesKHR() const; - - // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const; - -# if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - - // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html - VULKAN_HPP_NODISCARD Bool32 getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, Display & dpy, VisualID visualID ) const VULKAN_HPP_NOEXCEPT; -# endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -# if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - - // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html - VULKAN_HPP_NODISCARD Bool32 getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, - xcb_connection_t & connection, - xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT; -# endif /*VK_USE_PLATFORM_XCB_KHR*/ - -# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - - // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html - VULKAN_HPP_NODISCARD Bool32 getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, struct wl_display & display ) const VULKAN_HPP_NOEXCEPT; -# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - - // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html - VULKAN_HPP_NODISCARD Bool32 getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_video_queue === - - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - VULKAN_HPP_NODISCARD Result getVideoCapabilitiesKHR( const VideoProfileInfoKHR * pVideoProfile, - VideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile ) const; - - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile ) const; - - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const; - - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const; - - //=== VK_NV_external_memory_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getExternalImageFormatPropertiesNV( Format format, - ImageType type, - ImageTiling tiling, - ImageUsageFlags usage, - ImageCreateFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - ExternalMemoryHandleTypeFlagsNV externalHandleType VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - //=== VK_KHR_get_physical_device_properties2 === - - // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html - VULKAN_HPP_NODISCARD PhysicalDeviceFeatures2 getFeatures2KHR() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html - template - VULKAN_HPP_NODISCARD StructureChain getFeatures2KHR() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html - VULKAN_HPP_NODISCARD PhysicalDeviceProperties2 getProperties2KHR() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html - template - VULKAN_HPP_NODISCARD StructureChain getProperties2KHR() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html - VULKAN_HPP_NODISCARD FormatProperties2 getFormatProperties2KHR( Format format ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html - template - VULKAN_HPP_NODISCARD StructureChain getFormatProperties2KHR( Format format ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - VULKAN_HPP_NODISCARD Result getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, - ImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const; - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2KHR() const; - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template - VULKAN_HPP_NODISCARD std::vector getQueueFamilyProperties2KHR() const; - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html - VULKAN_HPP_NODISCARD PhysicalDeviceMemoryProperties2 getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html - template - VULKAN_HPP_NODISCARD StructureChain getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html - VULKAN_HPP_NODISCARD std::vector - getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const; - - //=== VK_KHR_external_memory_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html - VULKAN_HPP_NODISCARD ExternalBufferProperties - getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_external_semaphore_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html - VULKAN_HPP_NODISCARD ExternalSemaphoreProperties - getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT; - -# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - - // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html - typename ResultValueType::type acquireXlibDisplayEXT( Display & dpy, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const; - - // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; - - //=== VK_KHR_external_fence_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html - VULKAN_HPP_NODISCARD ExternalFenceProperties - getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_performance_query === - - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type - enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const; - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html - VULKAN_HPP_NODISCARD uint32_t - getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_get_surface_capabilities2 === - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - VULKAN_HPP_NODISCARD Result getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, - SurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; - - //=== VK_KHR_get_display_properties2 === - - // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayProperties2KHR() const; - - // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getDisplayPlaneProperties2KHR() const; - - // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo ) const; - - //=== VK_EXT_descriptor_heap === - - // wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html - VULKAN_HPP_NODISCARD DeviceSize getDescriptorSizeEXT( DescriptorType descriptorType ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_sample_locations === - - // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html - VULKAN_HPP_NODISCARD MultisamplePropertiesEXT getMultisamplePropertiesEXT( SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_calibrated_timestamps === - - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getCalibrateableTimeDomainsEXT() const; - - //=== VK_KHR_fragment_shading_rate === - - // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getFragmentShadingRatesKHR() const; - - //=== VK_EXT_tooling_info === - - // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getToolPropertiesEXT() const; - - //=== VK_NV_cooperative_matrix === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getCooperativeMatrixPropertiesNV() const; - - //=== VK_NV_coverage_reduction_mode === - - // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSupportedFramebufferMixedSamplesCombinationsNV() const; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_acquire_drm_display === - - // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html - typename ResultValueType::type acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const; - - // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getDrmDisplayEXT( int32_t drmFd, - uint32_t connectorId ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_KHR_video_encode_queue === - - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - VULKAN_HPP_NODISCARD Result - getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, - VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const; - - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - - // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getWinrtDisplayNV( uint32_t deviceRelativeId ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - - // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html - VULKAN_HPP_NODISCARD Bool32 getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT; -# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - - // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html - VULKAN_HPP_NODISCARD Bool32 getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_ARM_tensors === - - // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html - VULKAN_HPP_NODISCARD ExternalTensorPropertiesARM - getExternalTensorPropertiesARM( const PhysicalDeviceExternalTensorInfoARM & externalTensorInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_optical_flow === - - // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo ) const; - - //=== VK_NV_cooperative_vector === - - // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getCooperativeVectorPropertiesNV() const; - - //=== VK_KHR_cooperative_matrix === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getCooperativeMatrixPropertiesKHR() const; - - //=== VK_ARM_data_graph === - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex ) const; - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html - VULKAN_HPP_NODISCARD QueueFamilyDataGraphProcessingEnginePropertiesARM getQueueFamilyDataGraphProcessingEnginePropertiesARM( - const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & queueFamilyDataGraphProcessingEngineInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_calibrated_timestamps === - - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getCalibrateableTimeDomainsKHR() const; - - //=== VK_NV_cooperative_matrix2 === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCooperativeMatrixFlexibleDimensionsPropertiesNV() const; - - //=== VK_ARM_performance_counters_by_region === - - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html - VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type - enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex ) const; - - private: - VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; - detail::InstanceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - class PhysicalDevices : public std::vector - { - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - PhysicalDevices( Instance const & instance ) - { - *this = instance.enumeratePhysicalDevices(); - } -# endif - - PhysicalDevices( std::nullptr_t ) {} - - PhysicalDevices() = delete; - PhysicalDevices( PhysicalDevices const & ) = delete; - PhysicalDevices( PhysicalDevices && rhs ) = default; - PhysicalDevices & operator=( PhysicalDevices const & ) = delete; - PhysicalDevices & operator=( PhysicalDevices && rhs ) = default; - - PhysicalDevices( std::vector && rhs ) - { - std::swap( *this, rhs ); - } - }; - - // wrapper class for handle VkDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDevice.html - class Device - { - public: - using CType = VkDevice; - using CppType = VULKAN_HPP_NAMESPACE::Device; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDevice; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDevice; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Device( PhysicalDevice const & physicalDevice, DeviceCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = physicalDevice.createDevice( createInfo, allocator ); - } -# endif - - Device( PhysicalDevice const & physicalDevice, VkDevice device, Optional allocator = nullptr ) - : m_device( device ), m_allocator( static_cast( allocator ) ) - { - m_dispatcher.reset( new detail::DeviceDispatcher( physicalDevice.getDispatcher()->vkGetDeviceProcAddr, static_cast( m_device ) ) ); - } - - Device( std::nullptr_t ) {} - - ~Device() - { - clear(); - } - - Device() = delete; - Device( Device const & ) = delete; - - Device( Device && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( rhs.m_dispatcher.release() ) - { - } - - Device & operator=( Device const & ) = delete; - - Device & operator=( Device && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::Device const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_device; - } - - VULKAN_HPP_NAMESPACE::Device const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_device ); - } - - operator VULKAN_HPP_NAMESPACE::Device() const VULKAN_HPP_NOEXCEPT - { - return m_device; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_device ) - { - getDispatcher()->vkDestroyDevice( static_cast( m_device ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::Device release() - { - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_device, nullptr ); - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return &*m_dispatcher; - } - - void swap( Device & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html - VULKAN_HPP_NODISCARD PFN_VoidFunction getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html - VULKAN_HPP_NODISCARD Queue getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html - typename ResultValueType::type waitIdle() const; - - // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - allocateMemory( MemoryAllocateInfo const & allocateInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html - typename ResultValueType::type flushMappedMemoryRanges( ArrayProxy const & memoryRanges ) const; - - // wrapper function for command vkInvalidateMappedMemoryRanges, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html - typename ResultValueType::type invalidateMappedMemoryRanges( ArrayProxy const & memoryRanges ) const; - - // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createFence( FenceCreateInfo const & createInfo, Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html - typename ResultValueType::type resetFences( ArrayProxy const & fences ) const; - - // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html - VULKAN_HPP_NODISCARD Result waitForFences( ArrayProxy const & fences, Bool32 waitAll, uint64_t timeout ) const; - - // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSemaphore( SemaphoreCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createQueryPool( QueryPoolCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createBuffer( BufferCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createImage( ImageCreateInfo const & createInfo, Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createImageView( ImageViewCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createCommandPool( CommandPoolCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - allocateCommandBuffers( CommandBufferAllocateInfo const & allocateInfo ) const; - - // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createEvent( EventCreateInfo const & createInfo, Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createBufferView( BufferViewCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createShaderModule( ShaderModuleCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createPipelineCache( PipelineCacheCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createComputePipelines( Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) const; - - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createComputePipeline( Optional const & pipelineCache, - ComputePipelineCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createPipelineLayout( PipelineLayoutCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSampler( SamplerCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateDescriptorSetLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDescriptorSetLayout( DescriptorSetLayoutCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDescriptorPool( DescriptorPoolCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - allocateDescriptorSets( DescriptorSetAllocateInfo const & allocateInfo ) const; - - // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html - void updateDescriptorSets( ArrayProxy const & descriptorWrites, - ArrayProxy const & descriptorCopies ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createGraphicsPipelines( Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) const; - - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createGraphicsPipeline( Optional const & pipelineCache, - GraphicsPipelineCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createFramebuffer( FramebufferCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createRenderPass( RenderPassCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html - typename ResultValueType::type bindBufferMemory2( ArrayProxy const & bindInfos ) const; - - // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html - typename ResultValueType::type bindImageMemory2( ArrayProxy const & bindInfos ) const; - - // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html - VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags getGroupPeerMemoryFeatures( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetImageMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html - VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetImageMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html - template - VULKAN_HPP_NODISCARD StructureChain getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetBufferMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html - VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetBufferMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html - template - VULKAN_HPP_NODISCARD StructureChain getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetImageSparseMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info ) const; - - // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html - VULKAN_HPP_NODISCARD Queue getQueue2( DeviceQueueInfo2 const & queueInfo ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDescriptorUpdateTemplate( DescriptorUpdateTemplateCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkGetDescriptorSetLayoutSupport, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html - VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport - getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDescriptorSetLayoutSupport, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html - template - VULKAN_HPP_NODISCARD StructureChain - getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCreateSamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSamplerYcbcrConversion( SamplerYcbcrConversionCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_VERSION_1_2 === - - // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html - VULKAN_HPP_NODISCARD Result waitSemaphores( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const; - - // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html - typename ResultValueType::type signalSemaphore( const SemaphoreSignalInfo & signalInfo ) const; - - // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html - VULKAN_HPP_NODISCARD DeviceAddress getBufferAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetBufferOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html - VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html - VULKAN_HPP_NODISCARD uint64_t getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createRenderPass2( RenderPassCreateInfo2 const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_VERSION_1_3 === - - // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createPrivateDataSlot( PrivateDataSlotCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html - typename ResultValueType::type - setPrivateData( ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data ) const; - - // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html - VULKAN_HPP_NODISCARD uint64_t getPrivateData( ObjectType objectType, - uint64_t objectHandle, - VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html - VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html - template - VULKAN_HPP_NODISCARD StructureChain getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html - VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html - template - VULKAN_HPP_NODISCARD StructureChain getImageMemoryRequirements( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html - VULKAN_HPP_NODISCARD std::vector getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info ) const; - - //=== VK_VERSION_1_4 === - - // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html - VULKAN_HPP_NODISCARD typename ResultValueType::type mapMemory2( const MemoryMapInfo & memoryMapInfo ) const; - - // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html - typename ResultValueType::type unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo ) const; - - // wrapper function for command vkGetDeviceImageSubresourceLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html - VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayout( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceImageSubresourceLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html - template - VULKAN_HPP_NODISCARD StructureChain getImageSubresourceLayout( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html - typename ResultValueType::type copyMemoryToImage( const CopyMemoryToImageInfo & copyMemoryToImageInfo ) const; - - // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html - typename ResultValueType::type copyImageToMemory( const CopyImageToMemoryInfo & copyImageToMemoryInfo ) const; - - // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html - typename ResultValueType::type copyImageToImage( const CopyImageToImageInfo & copyImageToImageInfo ) const; - - // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html - typename ResultValueType::type transitionImageLayout( ArrayProxy const & transitions ) const; - - // wrapper function for command vkGetRenderingAreaGranularity, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html - VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularity( const RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_swapchain === - - // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSwapchainKHR( SwapchainCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getGroupPresentCapabilitiesKHR() const; - - // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const; - - // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html - VULKAN_HPP_NODISCARD ResultValue acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo ) const; - - //=== VK_KHR_display_swapchain === - - // wrapper function for command vkCreateSharedSwapchainsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createSharedSwapchainsKHR( ArrayProxy const & createInfos, Optional allocator = nullptr ) const; - - // wrapper function for command vkCreateSharedSwapchainsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSharedSwapchainKHR( SwapchainCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_EXT_debug_marker === - - // wrapper function for command vkDebugMarkerSetObjectTagEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html - typename ResultValueType::type debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const; - - // wrapper function for command vkDebugMarkerSetObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html - typename ResultValueType::type debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const; - - //=== VK_KHR_video_queue === - - // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createVideoSessionKHR( VideoSessionCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createVideoSessionParametersKHR( VideoSessionParametersCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_NVX_binary_import === - - // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createCuModuleNVX( CuModuleCreateInfoNVX const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createCuFunctionNVX( CuFunctionCreateInfoNVX const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_NVX_image_view_handle === - - // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html - VULKAN_HPP_NODISCARD uint32_t getImageViewHandleNVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html - VULKAN_HPP_NODISCARD uint64_t getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html - VULKAN_HPP_NODISCARD uint64_t getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex, uint64_t samplerIndex ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_device_group === - - // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html - VULKAN_HPP_NODISCARD PeerMemoryFeatureFlags getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - - // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const; - - // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle ) const; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - - // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const; - - // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, - int fd ) const; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - - // wrapper function for command vkImportSemaphoreWin32HandleKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html - typename ResultValueType::type importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const; - - // wrapper function for command vkGetSemaphoreWin32HandleKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - - // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html - typename ResultValueType::type importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const; - - // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const; - - //=== VK_KHR_descriptor_update_template === - - // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html - void - destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_display_control === - - // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html - typename ResultValueType::type displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, - const DisplayPowerInfoEXT & displayPowerInfo ) const; - - // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - registerEventEXT( DeviceEventInfoEXT const & deviceEventInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - registerDisplayEventEXT( DisplayKHR const & display, - DisplayEventInfoEXT const & displayEventInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_EXT_hdr_metadata === - - // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html - void setHdrMetadataEXT( ArrayProxy const & swapchains, - ArrayProxy const & metadata ) const; - - //=== VK_KHR_create_renderpass2 === - - // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createRenderPass2KHR( RenderPassCreateInfo2 const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - - // wrapper function for command vkImportFenceWin32HandleKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html - typename ResultValueType::type importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const; - - // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - - // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html - typename ResultValueType::type importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const; - - // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const; - - //=== VK_KHR_performance_query === - - // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html - typename ResultValueType::type acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info ) const; - - // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html - void releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_debug_utils === - - // wrapper function for command vkSetDebugUtilsObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html - typename ResultValueType::type setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo ) const; - - // wrapper function for command vkSetDebugUtilsObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html - template - typename ResultValueType::type setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name ) const; - - // wrapper function for command vkSetDebugUtilsObjectTagEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html - typename ResultValueType::type setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo ) const; - - // wrapper function for command vkSetDebugUtilsObjectTagEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html - template - typename ResultValueType::type setDebugUtilsObjectTagEXT( HandleType const & handle, uint64_t name, TagType const & tag ) const; - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - VULKAN_HPP_NODISCARD Result getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer * buffer, - AndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const; - - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const; - - // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info ) const; -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createExecutionGraphPipelinesAMDX( Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) const; - - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createExecutionGraphPipelineAMDX( Optional const & pipelineCache, - ExecutionGraphPipelineCreateInfoAMDX const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - - // wrapper function for command vkWriteSamplerDescriptorsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html - typename ResultValueType::type writeSamplerDescriptorsEXT( ArrayProxy const & samplers, - ArrayProxy const & descriptors ) const; - - // wrapper function for command vkWriteResourceDescriptorsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html - typename ResultValueType::type writeResourceDescriptorsEXT( ArrayProxy const & resources, - ArrayProxy const & descriptors ) const; - - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getImageOpaqueCaptureDataEXT( ArrayProxy const & images ) const; - - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getImageOpaqueCaptureDataEXT( const VULKAN_HPP_NAMESPACE::Image & image ) const; - - // wrapper function for command vkRegisterCustomBorderColorEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT & borderColor, - Bool32 requestIndex ) const; - - // wrapper function for command vkUnregisterCustomBorderColorEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html - void unregisterCustomBorderColorEXT( uint32_t index ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors ) const; - - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getTensorOpaqueCaptureDataARM( const VULKAN_HPP_NAMESPACE::TensorARM & tensor ) const; - - //=== VK_KHR_get_memory_requirements2 === - - // wrapper function for command vkGetImageMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html - VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetImageMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html - template - VULKAN_HPP_NODISCARD StructureChain getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetBufferMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html - VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetBufferMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html - template - VULKAN_HPP_NODISCARD StructureChain getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html - VULKAN_HPP_NODISCARD std::vector - getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info ) const; - - //=== VK_KHR_acceleration_structure === - - // wrapper function for command vkCreateAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createAccelerationStructureKHR( AccelerationStructureCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html - VULKAN_HPP_NODISCARD Result - buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - ArrayProxy const & infos, - ArrayProxy const & pBuildRangeInfos ) const; - - // wrapper function for command vkCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html - VULKAN_HPP_NODISCARD Result copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureInfoKHR & info ) const; - - // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html - VULKAN_HPP_NODISCARD Result copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureToMemoryInfoKHR & info ) const; - - // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html - VULKAN_HPP_NODISCARD Result copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const CopyMemoryToAccelerationStructureInfoKHR & info ) const; - - // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, - QueryType queryType, - size_t dataSize, - size_t stride ) const; - - // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type writeAccelerationStructuresPropertyKHR( - ArrayProxy const & accelerationStructures, QueryType queryType, size_t stride ) const; - - // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html - VULKAN_HPP_NODISCARD DeviceAddress getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html - VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR - getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html - VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR - getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, - const AccelerationStructureBuildGeometryInfoKHR & buildInfo, - ArrayProxy const & maxPrimitiveCounts VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; - - //=== VK_KHR_ray_tracing_pipeline === - - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createRayTracingPipelinesKHR( Optional const & deferredOperation, - Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) const; - - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createRayTracingPipelineKHR( Optional const & deferredOperation, - Optional const & pipelineCache, - RayTracingPipelineCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_KHR_sampler_ycbcr_conversion === - - // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createSamplerYcbcrConversionKHR( SamplerYcbcrConversionCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html - void destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_bind_memory2 === - - // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html - typename ResultValueType::type bindBufferMemory2KHR( ArrayProxy const & bindInfos ) const; - - // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html - typename ResultValueType::type bindImageMemory2KHR( ArrayProxy const & bindInfos ) const; - - //=== VK_EXT_validation_cache === - - // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createValidationCacheEXT( ValidationCacheCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_NV_ray_tracing === - - // wrapper function for command vkCreateAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createAccelerationStructureNV( AccelerationStructureCreateInfoNV const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html - VULKAN_HPP_NODISCARD MemoryRequirements2KHR - getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html - template - VULKAN_HPP_NODISCARD StructureChain - getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkBindAccelerationStructureMemoryNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html - typename ResultValueType::type bindAccelerationStructureMemoryNV( ArrayProxy const & bindInfos ) const; - - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createRayTracingPipelinesNV( Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) const; - - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createRayTracingPipelineNV( Optional const & pipelineCache, - RayTracingPipelineCreateInfoNV const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_KHR_maintenance3 === - - // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html - VULKAN_HPP_NODISCARD DescriptorSetLayoutSupport - getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html - template - VULKAN_HPP_NODISCARD StructureChain - getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_external_memory_host === - - // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer ) const; - - //=== VK_EXT_calibrated_timestamps === - - // wrapper function for command vkGetCalibratedTimestampsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type - getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos ) const; - - // wrapper function for command vkGetCalibratedTimestampsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCalibratedTimestampEXT( const CalibratedTimestampInfoKHR & timestampInfo ) const; - - //=== VK_KHR_timeline_semaphore === - - // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html - VULKAN_HPP_NODISCARD Result waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const; - - // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html - typename ResultValueType::type signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo ) const; - - //=== VK_EXT_present_timing === - - // wrapper function for command vkGetPastPresentationTimingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html - VULKAN_HPP_NODISCARD Result - getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, - PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_INTEL_performance_query === - - // wrapper function for command vkInitializePerformanceApiINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html - typename ResultValueType::type initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo ) const; - - // wrapper function for command vkUninitializePerformanceApiINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html - void uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - acquirePerformanceConfigurationINTEL( PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkGetPerformanceParameterINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter ) const; - - //=== VK_EXT_buffer_device_address === - - // wrapper function for command vkGetBufferDeviceAddressEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html - VULKAN_HPP_NODISCARD DeviceAddress getBufferAddressEXT( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - - // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_buffer_device_address === - - // wrapper function for command vkGetBufferDeviceAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html - VULKAN_HPP_NODISCARD DeviceAddress getBufferAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html - VULKAN_HPP_NODISCARD uint64_t getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html - VULKAN_HPP_NODISCARD uint64_t getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_deferred_host_operations === - - // wrapper function for command vkCreateDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDeferredOperationKHR( Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_KHR_pipeline_executable_properties === - - // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo ) const; - - // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo ) const; - - // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo ) const; - - //=== VK_EXT_host_image_copy === - - // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html - typename ResultValueType::type copyMemoryToImageEXT( const CopyMemoryToImageInfo & copyMemoryToImageInfo ) const; - - // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html - typename ResultValueType::type copyImageToMemoryEXT( const CopyImageToMemoryInfo & copyImageToMemoryInfo ) const; - - // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html - typename ResultValueType::type copyImageToImageEXT( const CopyImageToImageInfo & copyImageToImageInfo ) const; - - // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html - typename ResultValueType::type transitionImageLayoutEXT( ArrayProxy const & transitions ) const; - - //=== VK_KHR_map_memory2 === - - // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type mapMemory2KHR( const MemoryMapInfo & memoryMapInfo ) const; - - // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html - typename ResultValueType::type unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo ) const; - - //=== VK_EXT_swapchain_maintenance1 === - - // wrapper function for command vkReleaseSwapchainImagesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html - typename ResultValueType::type releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo ) const; - - //=== VK_NV_device_generated_commands === - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html - VULKAN_HPP_NODISCARD MemoryRequirements2 - getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html - template - VULKAN_HPP_NODISCARD StructureChain - getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCreateIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createIndirectCommandsLayoutNV( IndirectCommandsLayoutCreateInfoNV const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_EXT_private_data === - - // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createPrivateDataSlotEXT( PrivateDataSlotCreateInfo const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkDestroyPrivateDataSlotEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html - void destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html - typename ResultValueType::type - setPrivateDataEXT( ObjectType objectType, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data ) const; - - // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html - VULKAN_HPP_NODISCARD uint64_t getPrivateDataEXT( ObjectType objectType, - uint64_t objectHandle, - VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_video_encode_queue === - - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>>::type - getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const; - - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType, std::vector>>::type - getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - - // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createCudaModuleNV( CudaModuleCreateInfoNV const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createCudaFunctionNV( CudaFunctionCreateInfoNV const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - - // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - void exportMetalObjectsEXT( ExportMetalObjectsInfoEXT & metalObjectsInfo ) const VULKAN_HPP_NOEXCEPT; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_descriptor_buffer === - - // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html - void getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html - template - VULKAN_HPP_NODISCARD DescriptorType getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type - getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT & info ) const; - - // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT & info ) const; - - // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type - getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT & info ) const; - - // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type - getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT & info ) const; - - // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type - getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info ) const; - - //=== VK_EXT_device_fault === - - // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html - VULKAN_HPP_NODISCARD Result getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts, DeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT; - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - - // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const; - - // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle ) const; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - - // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html - typename ResultValueType::type - importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const; - - // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - - // wrapper function for command vkCreateBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createBufferCollectionFUCHSIA( BufferCollectionCreateInfoFUCHSIA const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_NV_external_memory_rdma === - - // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const; - - //=== VK_EXT_pipeline_properties === - - // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getPipelinePropertiesEXT( const PipelineInfoEXT & pipelineInfo ) const; - - //=== VK_EXT_opacity_micromap === - - // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createMicromapEXT( MicromapCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html - VULKAN_HPP_NODISCARD Result buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - ArrayProxy const & infos ) const; - - // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html - VULKAN_HPP_NODISCARD Result copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, const CopyMicromapInfoEXT & info ) const; - - // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html - VULKAN_HPP_NODISCARD Result copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const CopyMicromapToMemoryInfoEXT & info ) const; - - // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html - VULKAN_HPP_NODISCARD Result copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const CopyMemoryToMicromapInfoEXT & info ) const; - - // wrapper function for command vkWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type writeMicromapsPropertiesEXT( - ArrayProxy const & micromaps, QueryType queryType, size_t dataSize, size_t stride ) const; - - // wrapper function for command vkWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type - writeMicromapsPropertyEXT( ArrayProxy const & micromaps, QueryType queryType, size_t stride ) const; - - // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html - VULKAN_HPP_NODISCARD AccelerationStructureCompatibilityKHR - getMicromapCompatibilityEXT( const MicromapVersionInfoEXT & versionInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html - VULKAN_HPP_NODISCARD MicromapBuildSizesInfoEXT getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, - const MicromapBuildInfoEXT & buildInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_maintenance4 === - - // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html - VULKAN_HPP_NODISCARD MemoryRequirements2 getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html - template - VULKAN_HPP_NODISCARD StructureChain getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html - VULKAN_HPP_NODISCARD MemoryRequirements2 getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html - template - VULKAN_HPP_NODISCARD StructureChain getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html - VULKAN_HPP_NODISCARD std::vector getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const; - - //=== VK_VALVE_descriptor_set_host_mapping === - - // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html - VULKAN_HPP_NODISCARD DescriptorSetLayoutHostMappingInfoVALVE - getDescriptorSetLayoutHostMappingInfoVALVE( const DescriptorSetBindingReferenceVALVE & bindingReference ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_device_generated_commands_compute === - - // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html - VULKAN_HPP_NODISCARD MemoryRequirements2 - getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html - template - VULKAN_HPP_NODISCARD StructureChain - getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html - VULKAN_HPP_NODISCARD DeviceAddress getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV & info ) const VULKAN_HPP_NOEXCEPT; - -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - VULKAN_HPP_NODISCARD Result getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer * buffer, - NativeBufferPropertiesOHOS * pProperties ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer ) const; - - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer ) const; - - // wrapper function for command vkGetMemoryNativeBufferOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS & info ) const; -# endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_ARM_tensors === - - // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createTensorARM( TensorCreateInfoARM const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createTensorViewARM( TensorViewCreateInfoARM const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkGetTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html - VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html - template - VULKAN_HPP_NODISCARD StructureChain getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html - typename ResultValueType::type bindTensorMemoryARM( ArrayProxy const & bindInfos ) const; - - // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html - VULKAN_HPP_NODISCARD MemoryRequirements2 getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html - template - VULKAN_HPP_NODISCARD StructureChain - getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type - getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM & info ) const; - - // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type - getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM & info ) const; - - //=== VK_EXT_shader_module_identifier === - - // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html - VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT - getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_optical_flow === - - // wrapper function for command vkCreateOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createOpticalFlowSessionNV( OpticalFlowSessionCreateInfoNV const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_KHR_maintenance5 === - - // wrapper function for command vkGetRenderingAreaGranularityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html - VULKAN_HPP_NODISCARD Extent2D getRenderingAreaGranularityKHR( const RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html - VULKAN_HPP_NODISCARD SubresourceLayout2 getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html - template - VULKAN_HPP_NODISCARD StructureChain getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_AMD_anti_lag === - - // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html - void antiLagUpdateAMD( const AntiLagDataAMD & data ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_shader_object === - - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createShadersEXT( ArrayProxy const & createInfos, Optional allocator = nullptr ) const; - - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createShaderEXT( ShaderCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_KHR_pipeline_binary === - - // wrapper function for command vkCreatePipelineBinariesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createPipelineBinariesKHR( PipelineBinaryCreateInfoKHR const & createInfo, Optional allocator = nullptr ) const; - - // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getPipelineKeyKHR( Optional pipelineCreateInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; - - // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>>::type - getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info ) const; - - // wrapper function for command vkReleaseCapturedPipelineDataKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html - typename ResultValueType::type - releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR & info, - Optional allocator VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; - - //=== VK_QCOM_tile_properties === - - // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo ) const; - - //=== VK_KHR_swapchain_maintenance1 === - - // wrapper function for command vkReleaseSwapchainImagesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html - typename ResultValueType::type releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo ) const; - - //=== VK_NV_cooperative_vector === - - // wrapper function for command vkConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html - VULKAN_HPP_NODISCARD Result convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV & info ) const; - - //=== VK_ARM_data_graph === - - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - createDataGraphPipelinesARM( Optional const & deferredOperation, - Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) const; - - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDataGraphPipelineARM( Optional const & deferredOperation, - Optional const & pipelineCache, - DataGraphPipelineCreateInfoARM const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createDataGraphPipelineSessionARM( DataGraphPipelineSessionCreateInfoARM const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM & info ) const; - - // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html - VULKAN_HPP_NODISCARD MemoryRequirements2 - getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html - template - VULKAN_HPP_NODISCARD StructureChain - getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html - typename ResultValueType::type - bindDataGraphPipelineSessionMemoryARM( ArrayProxy const & bindInfos ) const; - - // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo ) const; - - // wrapper function for command vkGetDataGraphPipelinePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelinePropertiesARM.html - VULKAN_HPP_NODISCARD Result getDataGraphPipelinePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, - uint32_t propertiesCount, - DataGraphPipelinePropertyQueryResultARM * pProperties ) const VULKAN_HPP_NOEXCEPT; - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - VULKAN_HPP_NODISCARD Result getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer, - ScreenBufferPropertiesQNX * pProperties ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const; - - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const; -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_KHR_calibrated_timestamps === - - // wrapper function for command vkGetCalibratedTimestampsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType, uint64_t>>::type - getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos ) const; - - // wrapper function for command vkGetCalibratedTimestampsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getCalibratedTimestampKHR( const CalibratedTimestampInfoKHR & timestampInfo ) const; - - //=== VK_NV_external_compute_queue === - - // wrapper function for command vkCreateExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createExternalComputeQueueNV( ExternalComputeQueueCreateInfoNV const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_NV_cluster_acceleration_structure === - - // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html - VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR - getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV & info ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_partitioned_acceleration_structure === - - // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html - VULKAN_HPP_NODISCARD AccelerationStructureBuildSizesInfoKHR - getPartitionedAccelerationStructuresBuildSizesNV( const PartitionedAccelerationStructureInstancesInputNV & info ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_device_generated_commands === - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html - VULKAN_HPP_NODISCARD MemoryRequirements2 - getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html - template - VULKAN_HPP_NODISCARD StructureChain - getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createIndirectCommandsLayoutEXT( IndirectCommandsLayoutCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - // wrapper function for command vkCreateIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createIndirectExecutionSetEXT( IndirectExecutionSetCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - - // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT & getMetalHandleInfo ) const; - - // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type - getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle ) const; -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - const AllocationCallbacks * m_allocator = {}; - std::unique_ptr m_dispatcher; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkAccelerationStructureKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureKHR.html - class AccelerationStructureKHR - { - public: - using CType = VkAccelerationStructureKHR; - using CppType = VULKAN_HPP_NAMESPACE::AccelerationStructureKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureKHR; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - AccelerationStructureKHR( Device const & device, - AccelerationStructureCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createAccelerationStructureKHR( createInfo, allocator ); - } -# endif - - AccelerationStructureKHR( Device const & device, - VkAccelerationStructureKHR accelerationStructure, - Optional allocator = nullptr ) - : m_device( device ) - , m_accelerationStructureKHR( accelerationStructure ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - AccelerationStructureKHR( std::nullptr_t ) {} - - ~AccelerationStructureKHR() - { - clear(); - } - - AccelerationStructureKHR() = delete; - AccelerationStructureKHR( AccelerationStructureKHR const & ) = delete; - - AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_accelerationStructureKHR( exchange( rhs.m_accelerationStructureKHR, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - AccelerationStructureKHR & operator=( AccelerationStructureKHR const & ) = delete; - - AccelerationStructureKHR & operator=( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_accelerationStructureKHR, rhs.m_accelerationStructureKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_accelerationStructureKHR; - } - - VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_accelerationStructureKHR ); - } - - operator VULKAN_HPP_NAMESPACE::AccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT - { - return m_accelerationStructureKHR; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_accelerationStructureKHR ) - { - getDispatcher()->vkDestroyAccelerationStructureKHR( static_cast( m_device ), - static_cast( m_accelerationStructureKHR ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_accelerationStructureKHR = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::AccelerationStructureKHR release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_accelerationStructureKHR, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( AccelerationStructureKHR & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_accelerationStructureKHR, rhs.m_accelerationStructureKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructureKHR = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkAccelerationStructureNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureNV.html - class AccelerationStructureNV - { - public: - using CType = VkAccelerationStructureNV; - using CppType = VULKAN_HPP_NAMESPACE::AccelerationStructureNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eAccelerationStructureNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eAccelerationStructureNV; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - AccelerationStructureNV( Device const & device, - AccelerationStructureCreateInfoNV const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createAccelerationStructureNV( createInfo, allocator ); - } -# endif - - AccelerationStructureNV( Device const & device, VkAccelerationStructureNV accelerationStructure, Optional allocator = nullptr ) - : m_device( device ) - , m_accelerationStructureNV( accelerationStructure ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - AccelerationStructureNV( std::nullptr_t ) {} - - ~AccelerationStructureNV() - { - clear(); - } - - AccelerationStructureNV() = delete; - AccelerationStructureNV( AccelerationStructureNV const & ) = delete; - - AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_accelerationStructureNV( exchange( rhs.m_accelerationStructureNV, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - AccelerationStructureNV & operator=( AccelerationStructureNV const & ) = delete; - - AccelerationStructureNV & operator=( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_accelerationStructureNV, rhs.m_accelerationStructureNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_accelerationStructureNV; - } - - VULKAN_HPP_NAMESPACE::AccelerationStructureNV const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_accelerationStructureNV ); - } - - operator VULKAN_HPP_NAMESPACE::AccelerationStructureNV() const VULKAN_HPP_NOEXCEPT - { - return m_accelerationStructureNV; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_accelerationStructureNV ) - { - getDispatcher()->vkDestroyAccelerationStructureNV( static_cast( m_device ), - static_cast( m_accelerationStructureNV ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_accelerationStructureNV = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::AccelerationStructureNV release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_accelerationStructureNV, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( AccelerationStructureNV & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_accelerationStructureNV, rhs.m_accelerationStructureNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_NV_ray_tracing === - - // wrapper function for command vkGetAccelerationStructureHandleNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type getHandle( size_t dataSize ) const; - - // wrapper function for command vkGetAccelerationStructureHandleNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type getHandle() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructureNV = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuffer.html - class Buffer - { - public: - using CType = VkBuffer; - using CppType = VULKAN_HPP_NAMESPACE::Buffer; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBuffer; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBuffer; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Buffer( Device const & device, BufferCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createBuffer( createInfo, allocator ); - } -# endif - - Buffer( Device const & device, VkBuffer buffer, Optional allocator = nullptr ) - : m_device( device ), m_buffer( buffer ), m_allocator( static_cast( allocator ) ), m_dispatcher( device.getDispatcher() ) - { - } - - Buffer( std::nullptr_t ) {} - - ~Buffer() - { - clear(); - } - - Buffer() = delete; - Buffer( Buffer const & ) = delete; - - Buffer( Buffer && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_buffer( exchange( rhs.m_buffer, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - Buffer & operator=( Buffer const & ) = delete; - - Buffer & operator=( Buffer && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_buffer, rhs.m_buffer ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::Buffer const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_buffer; - } - - VULKAN_HPP_NAMESPACE::Buffer const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_buffer ); - } - - operator VULKAN_HPP_NAMESPACE::Buffer() const VULKAN_HPP_NOEXCEPT - { - return m_buffer; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_buffer ) - { - getDispatcher()->vkDestroyBuffer( - static_cast( m_device ), static_cast( m_buffer ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_buffer = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::Buffer release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_buffer, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( Buffer & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_buffer, rhs.m_buffer ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html - typename ResultValueType::type bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, DeviceSize memoryOffset ) const; - - // wrapper function for command vkGetBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html - VULKAN_HPP_NODISCARD MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; - - protected: - Buffer( VULKAN_HPP_NAMESPACE::Device device, - VULKAN_HPP_NAMESPACE::Buffer buffer, - const AllocationCallbacks * allocator, - detail::DeviceDispatcher const * dispatcher ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( device, {} ) ) - , m_buffer( exchange( buffer, {} ) ) - , m_allocator( exchange( allocator, {} ) ) - , m_dispatcher( exchange( dispatcher, nullptr ) ) - { - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::Buffer m_buffer = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkBufferCollectionFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionFUCHSIA.html -# if defined( VK_USE_PLATFORM_FUCHSIA ) - class BufferCollectionFUCHSIA - { - public: - using CType = VkBufferCollectionFUCHSIA; - using CppType = VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferCollectionFUCHSIA; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - BufferCollectionFUCHSIA( Device const & device, - BufferCollectionCreateInfoFUCHSIA const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createBufferCollectionFUCHSIA( createInfo, allocator ); - } -# endif - - BufferCollectionFUCHSIA( Device const & device, VkBufferCollectionFUCHSIA collection, Optional allocator = nullptr ) - : m_device( device ) - , m_bufferCollectionFUCHSIA( collection ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - BufferCollectionFUCHSIA( std::nullptr_t ) {} - - ~BufferCollectionFUCHSIA() - { - clear(); - } - - BufferCollectionFUCHSIA() = delete; - BufferCollectionFUCHSIA( BufferCollectionFUCHSIA const & ) = delete; - - BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_bufferCollectionFUCHSIA( exchange( rhs.m_bufferCollectionFUCHSIA, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA const & ) = delete; - - BufferCollectionFUCHSIA & operator=( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_bufferCollectionFUCHSIA, rhs.m_bufferCollectionFUCHSIA ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_bufferCollectionFUCHSIA; - } - - VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_bufferCollectionFUCHSIA ); - } - - operator VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT - { - return m_bufferCollectionFUCHSIA; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_bufferCollectionFUCHSIA ) - { - getDispatcher()->vkDestroyBufferCollectionFUCHSIA( static_cast( m_device ), - static_cast( m_bufferCollectionFUCHSIA ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_bufferCollectionFUCHSIA = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_bufferCollectionFUCHSIA, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( BufferCollectionFUCHSIA & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_bufferCollectionFUCHSIA, rhs.m_bufferCollectionFUCHSIA ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_FUCHSIA_buffer_collection === - - // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html - typename ResultValueType::type setImageConstraints( const ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const; - - // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html - typename ResultValueType::type setBufferConstraints( const BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const; - - // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getProperties() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - // wrapper class for handle VkBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferView.html - class BufferView - { - public: - using CType = VkBufferView; - using CppType = VULKAN_HPP_NAMESPACE::BufferView; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eBufferView; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eBufferView; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - BufferView( Device const & device, BufferViewCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createBufferView( createInfo, allocator ); - } -# endif - - BufferView( Device const & device, VkBufferView bufferView, Optional allocator = nullptr ) - : m_device( device ) - , m_bufferView( bufferView ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - BufferView( std::nullptr_t ) {} - - ~BufferView() - { - clear(); - } - - BufferView() = delete; - BufferView( BufferView const & ) = delete; - - BufferView( BufferView && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_bufferView( exchange( rhs.m_bufferView, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - BufferView & operator=( BufferView const & ) = delete; - - BufferView & operator=( BufferView && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_bufferView, rhs.m_bufferView ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::BufferView const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_bufferView; - } - - VULKAN_HPP_NAMESPACE::BufferView const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_bufferView ); - } - - operator VULKAN_HPP_NAMESPACE::BufferView() const VULKAN_HPP_NOEXCEPT - { - return m_bufferView; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_bufferView ) - { - getDispatcher()->vkDestroyBufferView( - static_cast( m_device ), static_cast( m_bufferView ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_bufferView = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::BufferView release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_bufferView, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( BufferView & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_bufferView, rhs.m_bufferView ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::BufferView m_bufferView = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPool.html - class CommandPool - { - public: - using CType = VkCommandPool; - using CppType = VULKAN_HPP_NAMESPACE::CommandPool; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandPool; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandPool; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - CommandPool( Device const & device, CommandPoolCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createCommandPool( createInfo, allocator ); - } -# endif - - CommandPool( Device const & device, VkCommandPool commandPool, Optional allocator = nullptr ) - : m_device( device ) - , m_commandPool( commandPool ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - CommandPool( std::nullptr_t ) {} - - ~CommandPool() - { - clear(); - } - - CommandPool() = delete; - CommandPool( CommandPool const & ) = delete; - - CommandPool( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_commandPool( exchange( rhs.m_commandPool, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - CommandPool & operator=( CommandPool const & ) = delete; - - CommandPool & operator=( CommandPool && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_commandPool, rhs.m_commandPool ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::CommandPool const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_commandPool; - } - - VULKAN_HPP_NAMESPACE::CommandPool const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_commandPool ); - } - - operator VULKAN_HPP_NAMESPACE::CommandPool() const VULKAN_HPP_NOEXCEPT - { - return m_commandPool; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_commandPool ) - { - getDispatcher()->vkDestroyCommandPool( - static_cast( m_device ), static_cast( m_commandPool ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_commandPool = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::CommandPool release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_commandPool, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( CommandPool & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_commandPool, rhs.m_commandPool ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html - typename ResultValueType::type reset( CommandPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html - void trim( CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_maintenance1 === - - // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html - void trimKHR( CommandPoolTrimFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBuffer.html - class CommandBuffer - { - public: - using CType = VkCommandBuffer; - using CppType = VULKAN_HPP_NAMESPACE::CommandBuffer; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCommandBuffer; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCommandBuffer; - - public: - CommandBuffer( Device const & device, VkCommandBuffer commandBuffer, VkCommandPool commandPool ) - : m_device( device ), m_commandPool( commandPool ), m_commandBuffer( commandBuffer ), m_dispatcher( device.getDispatcher() ) - { - } - - CommandBuffer( std::nullptr_t ) {} - - ~CommandBuffer() - { - clear(); - } - - CommandBuffer() = delete; - CommandBuffer( CommandBuffer const & ) = delete; - - CommandBuffer( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_commandPool( exchange( rhs.m_commandPool, {} ) ) - , m_commandBuffer( exchange( rhs.m_commandBuffer, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - CommandBuffer & operator=( CommandBuffer const & ) = delete; - - CommandBuffer & operator=( CommandBuffer && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_commandPool, rhs.m_commandPool ); - std::swap( m_commandBuffer, rhs.m_commandBuffer ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::CommandBuffer const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_commandBuffer; - } - - VULKAN_HPP_NAMESPACE::CommandBuffer const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_commandBuffer ); - } - - operator VULKAN_HPP_NAMESPACE::CommandBuffer() const VULKAN_HPP_NOEXCEPT - { - return m_commandBuffer; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_commandBuffer ) - { - getDispatcher()->vkFreeCommandBuffers( - static_cast( m_device ), static_cast( m_commandPool ), 1, reinterpret_cast( &m_commandBuffer ) ); - } - m_device = nullptr; - m_commandPool = nullptr; - m_commandBuffer = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::CommandBuffer release() - { - m_device = nullptr; - m_commandPool = nullptr; - m_dispatcher = nullptr; - return exchange( m_commandBuffer, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( CommandBuffer & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_commandPool, rhs.m_commandPool ); - std::swap( m_commandBuffer, rhs.m_commandBuffer ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html - typename ResultValueType::type begin( const CommandBufferBeginInfo & beginInfo ) const; - - // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html - typename ResultValueType::type end() const; - - // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html - typename ResultValueType::type reset( CommandBufferResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html - void copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer, - ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html - void copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, - ImageLayout srcImageLayout, - VULKAN_HPP_NAMESPACE::Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html - void copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, - VULKAN_HPP_NAMESPACE::Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html - void copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, - ImageLayout srcImageLayout, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer, - ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html - template - void updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, DeviceSize dstOffset, ArrayProxy const & data ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html - void fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html - void pipelineBarrier( PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - DependencyFlags dependencyFlags, - ArrayProxy const & memoryBarriers, - ArrayProxy const & bufferMemoryBarriers, - ArrayProxy const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html - void beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, - uint32_t query, - QueryControlFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html - void endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html - void resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html - void writeTimestamp( PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html - void copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer, - DeviceSize dstOffset, - DeviceSize stride, - QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html - void executeCommands( ArrayProxy const & commandBuffers ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html - void bindPipeline( PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html - void bindDescriptorSets( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t firstSet, - ArrayProxy const & descriptorSets, - ArrayProxy const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html - void clearColorImage( VULKAN_HPP_NAMESPACE::Image image, - ImageLayout imageLayout, - const ClearColorValue & color, - ArrayProxy const & ranges ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html - void dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html - void dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html - void setEvent( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags stageMask VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html - void resetEvent( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags stageMask VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html - void waitEvents( ArrayProxy const & events, - PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - ArrayProxy const & memoryBarriers, - ArrayProxy const & bufferMemoryBarriers, - ArrayProxy const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html - template - void pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, - ShaderStageFlags stageFlags, - uint32_t offset, - ArrayProxy const & values ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html - void setViewport( uint32_t firstViewport, ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html - void setScissor( uint32_t firstScissor, ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html - void setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html - void setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html - void setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html - void setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html - void setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html - void setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html - void setStencilReference( StencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html - void bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, IndexType indexType ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html - void bindVertexBuffers( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets ) const; - - // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html - void draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html - void - drawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html - void drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html - void drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html - void blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, - ImageLayout srcImageLayout, - VULKAN_HPP_NAMESPACE::Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions, - Filter filter ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdClearDepthStencilImage, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html - void clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, - ImageLayout imageLayout, - const ClearDepthStencilValue & depthStencil, - ArrayProxy const & ranges ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html - void clearAttachments( ArrayProxy const & attachments, ArrayProxy const & rects ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html - void resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, - ImageLayout srcImageLayout, - VULKAN_HPP_NAMESPACE::Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html - void beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html - void nextSubpass( SubpassContents contents ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html - void endRenderPass() const VULKAN_HPP_NOEXCEPT; - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html - void setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html - void dispatchBase( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const - VULKAN_HPP_NOEXCEPT; - - //=== VK_VERSION_1_2 === - - // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html - void drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndexedIndirectCount, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html - void drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html - void beginRenderPass2( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html - void nextSubpass2( const SubpassBeginInfo & subpassBeginInfo, const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html - void endRenderPass2( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_VERSION_1_3 === - - // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html - void pipelineBarrier2( const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html - void writeTimestamp2( PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html - void copyBuffer2( const CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html - void copyImage2( const CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html - void copyBufferToImage2( const CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html - void copyImageToBuffer2( const CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html - void setEvent2( VULKAN_HPP_NAMESPACE::Event event, const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html - void resetEvent2( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags2 stageMask VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html - void waitEvents2( ArrayProxy const & events, ArrayProxy const & dependencyInfos ) const; - - // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html - void blitImage2( const BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html - void resolveImage2( const ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html - void beginRendering( const RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html - void endRendering() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html - void setCullMode( CullModeFlags cullMode VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html - void setFrontFace( FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html - void setPrimitiveTopology( PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html - void setViewportWithCount( ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html - void setScissorWithCount( ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html - void bindVertexBuffers2( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - ArrayProxy const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; - - // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html - void setDepthTestEnable( Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html - void setDepthWriteEnable( Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html - void setDepthCompareOp( CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBoundsTestEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html - void setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html - void setStencilTestEnable( Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html - void setStencilOp( StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRasterizerDiscardEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html - void setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html - void setDepthBiasEnable( Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetPrimitiveRestartEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html - void setPrimitiveRestartEnable( Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_VERSION_1_4 === - - // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html - void pushDescriptorSet( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set, - ArrayProxy const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html - template - void pushDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set, - DataType const & data ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html - void bindDescriptorSets2( const BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html - void pushConstants2( const PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html - void pushDescriptorSet2( const PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html - void pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html - void setLineStipple( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html - void bindIndexBuffer2( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRenderingAttachmentLocations, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html - void setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html - void setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_debug_marker === - - // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html - void debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html - void debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html - void debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_video_queue === - - // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html - void beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html - void endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html - void controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_video_decode_queue === - - // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html - void decodeVideoKHR( const VideoDecodeInfoKHR & decodeInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_transform_feedback === - - // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html - void bindTransformFeedbackBuffersEXT( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; - - // wrapper function for command vkCmdBeginTransformFeedbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html - void beginTransformFeedbackEXT( uint32_t firstCounterBuffer, - ArrayProxy const & counterBuffers, - ArrayProxy const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; - - // wrapper function for command vkCmdEndTransformFeedbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html - void endTransformFeedbackEXT( uint32_t firstCounterBuffer, - ArrayProxy const & counterBuffers, - ArrayProxy const & counterBufferOffsets VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; - - // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html - void beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, QueryControlFlags flags, uint32_t index ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html - void endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndirectByteCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html - void drawIndirectByteCountEXT( uint32_t instanceCount, - uint32_t firstInstance, - VULKAN_HPP_NAMESPACE::Buffer counterBuffer, - DeviceSize counterBufferOffset, - uint32_t counterOffset, - uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NVX_binary_import === - - // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html - void cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_AMD_draw_indirect_count === - - // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html - void drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html - void drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_dynamic_rendering === - - // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html - void beginRenderingKHR( const RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html - void endRenderingKHR() const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_device_group === - - // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html - void setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html - void dispatchBaseKHR( uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) - const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_push_descriptor === - - // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html - void pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set, - ArrayProxy const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html - template - void pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set, - DataType const & data ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_conditional_rendering === - - // wrapper function for command vkCmdBeginConditionalRenderingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html - void beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndConditionalRenderingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html - void endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_clip_space_w_scaling === - - // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html - void setViewportWScalingNV( uint32_t firstViewport, ArrayProxy const & viewportWScalings ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_discard_rectangles === - - // wrapper function for command vkCmdSetDiscardRectangleEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html - void setDiscardRectangleEXT( uint32_t firstDiscardRectangle, ArrayProxy const & discardRectangles ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html - void setDiscardRectangleEnableEXT( Bool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html - void setDiscardRectangleModeEXT( DiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_create_renderpass2 === - - // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html - void beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, const SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html - void nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo, const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html - void endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_debug_utils === - - // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html - void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html - void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html - void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - - // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html - void initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, - DeviceAddress scratch, - DeviceSize scratchSize ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html - void dispatchGraphAMDX( DeviceAddress scratch, DeviceSize scratchSize, const DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html - void dispatchGraphIndirectAMDX( DeviceAddress scratch, DeviceSize scratchSize, const DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html - void dispatchGraphIndirectCountAMDX( DeviceAddress scratch, DeviceSize scratchSize, DeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - - // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html - void bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html - void bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html - void pushDataEXT( const PushDataInfoEXT & pushDataInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_sample_locations === - - // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html - void setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_acceleration_structure === - - // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html - void buildAccelerationStructuresKHR( ArrayProxy const & infos, - ArrayProxy const & pBuildRangeInfos ) const; - - // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html - void buildAccelerationStructuresIndirectKHR( ArrayProxy const & infos, - ArrayProxy const & indirectDeviceAddresses, - ArrayProxy const & indirectStrides, - ArrayProxy const & pMaxPrimitiveCounts ) const; - - // wrapper function for command vkCmdCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html - void copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html - void copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html - void copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html - void writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, - QueryType queryType, - VULKAN_HPP_NAMESPACE::QueryPool queryPool, - uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_ray_tracing_pipeline === - - // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html - void traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, - const StridedDeviceAddressRegionKHR & missShaderBindingTable, - const StridedDeviceAddressRegionKHR & hitShaderBindingTable, - const StridedDeviceAddressRegionKHR & callableShaderBindingTable, - uint32_t width, - uint32_t height, - uint32_t depth ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html - void traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, - const StridedDeviceAddressRegionKHR & missShaderBindingTable, - const StridedDeviceAddressRegionKHR & hitShaderBindingTable, - const StridedDeviceAddressRegionKHR & callableShaderBindingTable, - DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html - void setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_shading_rate_image === - - // wrapper function for command vkCmdBindShadingRateImageNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html - void bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html - void setViewportShadingRatePaletteNV( uint32_t firstViewport, - ArrayProxy const & shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoarseSampleOrderNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html - void setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, - ArrayProxy const & customSampleOrders ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_ray_tracing === - - // wrapper function for command vkCmdBuildAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html - void buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, - VULKAN_HPP_NAMESPACE::Buffer instanceData, - DeviceSize instanceOffset, - Bool32 update, - VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, - VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, - VULKAN_HPP_NAMESPACE::Buffer scratch, - DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html - void copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, - VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, - CopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html - void traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, - DeviceSize raygenShaderBindingOffset, - VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, - DeviceSize missShaderBindingOffset, - DeviceSize missShaderBindingStride, - VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, - DeviceSize hitShaderBindingOffset, - DeviceSize hitShaderBindingStride, - VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, - DeviceSize callableShaderBindingOffset, - DeviceSize callableShaderBindingStride, - uint32_t width, - uint32_t height, - uint32_t depth ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html - void writeAccelerationStructuresPropertiesNV( ArrayProxy const & accelerationStructures, - QueryType queryType, - VULKAN_HPP_NAMESPACE::QueryPool queryPool, - uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_draw_indirect_count === - - // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html - void drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html - void drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_AMD_buffer_marker === - - // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html - void writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer, - DeviceSize dstOffset, - uint32_t marker ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html - void writeBufferMarker2AMD( PipelineStageFlags2 stage, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer, - DeviceSize dstOffset, - uint32_t marker ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_mesh_shader === - - // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html - void drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html - void drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html - void drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_scissor_exclusive === - - // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html - void setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, ArrayProxy const & exclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html - void setExclusiveScissorNV( uint32_t firstExclusiveScissor, ArrayProxy const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_device_diagnostic_checkpoints === - - // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html - template - void setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_INTEL_performance_query === - - // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html - typename ResultValueType::type setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo ) const; - - // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html - typename ResultValueType::type setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo ) const; - - // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html - typename ResultValueType::type setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo ) const; - - //=== VK_KHR_fragment_shading_rate === - - // wrapper function for command vkCmdSetFragmentShadingRateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html - void setFragmentShadingRateKHR( const Extent2D & fragmentSize, const FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_dynamic_rendering_local_read === - - // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html - void setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html - void setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_line_rasterization === - - // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html - void setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_extended_dynamic_state === - - // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html - void setCullModeEXT( CullModeFlags cullMode VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html - void setFrontFaceEXT( FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html - void setPrimitiveTopologyEXT( PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetViewportWithCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html - void setViewportWithCountEXT( ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetScissorWithCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html - void setScissorWithCountEXT( ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html - void bindVertexBuffers2EXT( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - ArrayProxy const & strides VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; - - // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html - void setDepthTestEnableEXT( Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthWriteEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html - void setDepthWriteEnableEXT( Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html - void setDepthCompareOpEXT( CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html - void setDepthBoundsTestEnableEXT( Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilTestEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html - void setStencilTestEnableEXT( Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html - void - setStencilOpEXT( StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_device_generated_commands === - - // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html - void preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html - void executeGeneratedCommandsNV( Bool32 isPreprocessed, const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindPipelineShaderGroupNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html - void bindPipelineShaderGroupNV( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::Pipeline pipeline, - uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_depth_bias_control === - - // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html - void setDepthBias2EXT( const DepthBiasInfoEXT & depthBiasInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_video_encode_queue === - - // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html - void encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - - // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html - void cudaLaunchKernelNV( const CudaLaunchInfoNV & launchInfo ) const VULKAN_HPP_NOEXCEPT; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - - // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html - void dispatchTileQCOM( const DispatchTileInfoQCOM & dispatchTileInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html - void beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM & perTileBeginInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdEndPerTileExecutionQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html - void endPerTileExecutionQCOM( const PerTileEndInfoQCOM & perTileEndInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_synchronization2 === - - // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html - void setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html - void resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags2 stageMask VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html - void waitEvents2KHR( ArrayProxy const & events, ArrayProxy const & dependencyInfos ) const; - - // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html - void pipelineBarrier2KHR( const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html - void writeTimestamp2KHR( PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_descriptor_buffer === - - // wrapper function for command vkCmdBindDescriptorBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html - void bindDescriptorBuffersEXT( ArrayProxy const & bindingInfos ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html - void setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t firstSet, - ArrayProxy const & bufferIndices, - ArrayProxy const & offsets ) const; - - // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html - void bindDescriptorBufferEmbeddedSamplersEXT( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_fragment_shading_rate_enums === - - // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html - void setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, const FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_mesh_shader === - - // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html - void drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html - void drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html - void drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_copy_commands2 === - - // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html - void copyBuffer2KHR( const CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html - void copyImage2KHR( const CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html - void copyBufferToImage2KHR( const CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html - void copyImageToBuffer2KHR( const CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html - void blitImage2KHR( const BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html - void resolveImage2KHR( const ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_vertex_input_dynamic_state === - - // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html - void setVertexInputEXT( ArrayProxy const & vertexBindingDescriptions, - ArrayProxy const & vertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_HUAWEI_subpass_shading === - - // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html - void subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT; - - //=== VK_HUAWEI_invocation_mask === - - // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html - void bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_extended_dynamic_state2 === - - // wrapper function for command vkCmdSetPatchControlPointsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html - void setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html - void setRasterizerDiscardEnableEXT( Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html - void setDepthBiasEnableEXT( Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html - void setLogicOpEXT( LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html - void setPrimitiveRestartEnableEXT( Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_color_write_enable === - - // wrapper function for command vkCmdSetColorWriteEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html - void setColorWriteEnableEXT( ArrayProxy const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_ray_tracing_maintenance1 === - - // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html - void traceRaysIndirect2KHR( DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_multi_draw === - - // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html - void - drawMultiEXT( StridedArrayProxy const & vertexInfo, uint32_t instanceCount, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html - void drawMultiIndexedEXT( StridedArrayProxy const & indexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - Optional vertexOffset VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_opacity_micromap === - - // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html - void buildMicromapsEXT( ArrayProxy const & infos ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html - void copyMicromapEXT( const CopyMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html - void copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html - void copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html - void writeMicromapsPropertiesEXT( ArrayProxy const & micromaps, - QueryType queryType, - VULKAN_HPP_NAMESPACE::QueryPool queryPool, - uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_HUAWEI_cluster_culling_shader === - - // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html - void drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html - void drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_copy_memory_indirect === - - // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html - void copyMemoryIndirectNV( DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html - void copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, - uint32_t stride, - VULKAN_HPP_NAMESPACE::Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & imageSubresources ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_memory_decompression === - - // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html - void decompressMemoryNV( ArrayProxy const & decompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html - void decompressMemoryIndirectCountNV( DeviceAddress indirectCommandsAddress, - DeviceAddress indirectCommandsCountAddress, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_device_generated_commands_compute === - - // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html - void updatePipelineIndirectBufferNV( PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_extended_dynamic_state3 === - - // wrapper function for command vkCmdSetDepthClampEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html - void setDepthClampEnableEXT( Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html - void setPolygonModeEXT( PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRasterizationSamplesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html - void setRasterizationSamplesEXT( SampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html - void setSampleMaskEXT( SampleCountFlagBits samples, ArrayProxy const & sampleMask VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const; - - // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html - void setAlphaToCoverageEnableEXT( Bool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html - void setAlphaToOneEnableEXT( Bool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html - void setLogicOpEnableEXT( Bool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetColorBlendEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html - void setColorBlendEnableEXT( uint32_t firstAttachment, ArrayProxy const & colorBlendEnables ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetColorBlendEquationEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html - void setColorBlendEquationEXT( uint32_t firstAttachment, ArrayProxy const & colorBlendEquations ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html - void setColorWriteMaskEXT( uint32_t firstAttachment, ArrayProxy const & colorWriteMasks ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html - void setTessellationDomainOriginEXT( TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRasterizationStreamEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html - void setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html - void setConservativeRasterizationModeEXT( ConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html - void setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html - void setDepthClipEnableEXT( Bool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html - void setSampleLocationsEnableEXT( Bool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html - void setColorBlendAdvancedEXT( uint32_t firstAttachment, ArrayProxy const & colorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetProvokingVertexModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html - void setProvokingVertexModeEXT( ProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetLineRasterizationModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html - void setLineRasterizationModeEXT( LineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetLineStippleEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html - void setLineStippleEnableEXT( Bool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html - void setDepthClipNegativeOneToOneEXT( Bool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetViewportWScalingEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html - void setViewportWScalingEnableNV( Bool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html - void setViewportSwizzleNV( uint32_t firstViewport, ArrayProxy const & viewportSwizzles ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoverageToColorEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html - void setCoverageToColorEnableNV( Bool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoverageToColorLocationNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html - void setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoverageModulationModeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html - void setCoverageModulationModeNV( CoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html - void setCoverageModulationTableEnableNV( Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoverageModulationTableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html - void setCoverageModulationTableNV( ArrayProxy const & coverageModulationTable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetShadingRateImageEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html - void setShadingRateImageEnableNV( Bool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html - void setRepresentativeFragmentTestEnableNV( Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetCoverageReductionModeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html - void setCoverageReductionModeNV( CoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_ARM_tensors === - - // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html - void copyTensorARM( const CopyTensorInfoARM & copyTensorInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_optical_flow === - - // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html - void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const OpticalFlowExecuteInfoNV & executeInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_maintenance5 === - - // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html - void bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_shader_object === - - // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html - void bindShadersEXT( ArrayProxy const & stages, ArrayProxy const & shaders ) const; - - // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html - void setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, - Optional depthClampRange VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_cooperative_vector === - - // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html - void convertCooperativeVectorMatrixNV( ArrayProxy const & infos ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_ARM_data_graph === - - // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html - void dispatchDataGraphARM( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM session, - Optional info VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - - // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html - void setAttachmentFeedbackLoopEnableEXT( ImageAspectFlags aspectMask VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_line_rasterization === - - // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html - void setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_maintenance6 === - - // wrapper function for command vkCmdBindDescriptorSets2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html - void bindDescriptorSets2KHR( const BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html - void pushConstants2KHR( const PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html - void pushDescriptorSet2KHR( const PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html - void pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html - void setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html - void bindDescriptorBufferEmbeddedSamplers2EXT( const BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo ) const - VULKAN_HPP_NOEXCEPT; - - //=== VK_QCOM_tile_memory_heap === - - // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html - void bindTileMemoryQCOM( Optional tileMemoryBindInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_copy_memory_indirect === - - // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html - void copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html - void copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_memory_decompression === - - // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html - void decompressMemoryEXT( const DecompressMemoryInfoEXT & decompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdDecompressMemoryIndirectCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountEXT.html - void decompressMemoryIndirectCountEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod, - DeviceAddress indirectCommandsAddress, - DeviceAddress indirectCommandsCountAddress, - uint32_t maxDecompressionCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_cluster_acceleration_structure === - - // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html - void buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV & commandInfos ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_partitioned_acceleration_structure === - - // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html - void buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV & buildInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_device_generated_commands === - - // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html - void preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT & generatedCommandsInfo, - VULKAN_HPP_NAMESPACE::CommandBuffer stateCommandBuffer ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html - void executeGeneratedCommandsEXT( Bool32 isPreprocessed, const GeneratedCommandsInfoEXT & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_fragment_density_map_offset === - - // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html - void endRendering2EXT( Optional renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_custom_resolve === - - // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html - void beginCustomResolveEXT( Optional beginCustomResolveInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const - VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_maintenance10 === - - // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html - void endRendering2KHR( Optional renderingEndInfo VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ) ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_compute_occupancy_priority === - - // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html - void setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV & parameters ) const VULKAN_HPP_NOEXCEPT; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; - VULKAN_HPP_NAMESPACE::CommandBuffer m_commandBuffer = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - class CommandBuffers : public std::vector - { - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - CommandBuffers( Device const & device, CommandBufferAllocateInfo const & allocateInfo ) - { - *this = device.allocateCommandBuffers( allocateInfo ); - } -# endif - - CommandBuffers( std::nullptr_t ) {} - - CommandBuffers() = delete; - CommandBuffers( CommandBuffers const & ) = delete; - CommandBuffers( CommandBuffers && rhs ) = default; - CommandBuffers & operator=( CommandBuffers const & ) = delete; - CommandBuffers & operator=( CommandBuffers && rhs ) = default; - - CommandBuffers( std::vector && rhs ) - { - std::swap( *this, rhs ); - } - }; - - // wrapper class for handle VkCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuFunctionNVX.html - class CuFunctionNVX - { - public: - using CType = VkCuFunctionNVX; - using CppType = VULKAN_HPP_NAMESPACE::CuFunctionNVX; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuFunctionNVX; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuFunctionNVX; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - CuFunctionNVX( Device const & device, CuFunctionCreateInfoNVX const & createInfo, Optional allocator = nullptr ) - { - *this = device.createCuFunctionNVX( createInfo, allocator ); - } -# endif - - CuFunctionNVX( Device const & device, VkCuFunctionNVX function, Optional allocator = nullptr ) - : m_device( device ) - , m_cuFunctionNVX( function ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - CuFunctionNVX( std::nullptr_t ) {} - - ~CuFunctionNVX() - { - clear(); - } - - CuFunctionNVX() = delete; - CuFunctionNVX( CuFunctionNVX const & ) = delete; - - CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_cuFunctionNVX( exchange( rhs.m_cuFunctionNVX, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - CuFunctionNVX & operator=( CuFunctionNVX const & ) = delete; - - CuFunctionNVX & operator=( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_cuFunctionNVX, rhs.m_cuFunctionNVX ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::CuFunctionNVX const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_cuFunctionNVX; - } - - VULKAN_HPP_NAMESPACE::CuFunctionNVX const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_cuFunctionNVX ); - } - - operator VULKAN_HPP_NAMESPACE::CuFunctionNVX() const VULKAN_HPP_NOEXCEPT - { - return m_cuFunctionNVX; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_cuFunctionNVX ) - { - getDispatcher()->vkDestroyCuFunctionNVX( static_cast( m_device ), - static_cast( m_cuFunctionNVX ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_cuFunctionNVX = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::CuFunctionNVX release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_cuFunctionNVX, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( CuFunctionNVX & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_cuFunctionNVX, rhs.m_cuFunctionNVX ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::CuFunctionNVX m_cuFunctionNVX = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleNVX.html - class CuModuleNVX - { - public: - using CType = VkCuModuleNVX; - using CppType = VULKAN_HPP_NAMESPACE::CuModuleNVX; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCuModuleNVX; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCuModuleNVX; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - CuModuleNVX( Device const & device, CuModuleCreateInfoNVX const & createInfo, Optional allocator = nullptr ) - { - *this = device.createCuModuleNVX( createInfo, allocator ); - } -# endif - - CuModuleNVX( Device const & device, VkCuModuleNVX module, Optional allocator = nullptr ) - : m_device( device ) - , m_cuModuleNVX( module ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - CuModuleNVX( std::nullptr_t ) {} - - ~CuModuleNVX() - { - clear(); - } - - CuModuleNVX() = delete; - CuModuleNVX( CuModuleNVX const & ) = delete; - - CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_cuModuleNVX( exchange( rhs.m_cuModuleNVX, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - CuModuleNVX & operator=( CuModuleNVX const & ) = delete; - - CuModuleNVX & operator=( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_cuModuleNVX, rhs.m_cuModuleNVX ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::CuModuleNVX const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_cuModuleNVX; - } - - VULKAN_HPP_NAMESPACE::CuModuleNVX const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_cuModuleNVX ); - } - - operator VULKAN_HPP_NAMESPACE::CuModuleNVX() const VULKAN_HPP_NOEXCEPT - { - return m_cuModuleNVX; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_cuModuleNVX ) - { - getDispatcher()->vkDestroyCuModuleNVX( - static_cast( m_device ), static_cast( m_cuModuleNVX ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_cuModuleNVX = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::CuModuleNVX release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_cuModuleNVX, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( CuModuleNVX & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_cuModuleNVX, rhs.m_cuModuleNVX ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::CuModuleNVX m_cuModuleNVX = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaFunctionNV.html -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - class CudaFunctionNV - { - public: - using CType = VkCudaFunctionNV; - using CppType = VULKAN_HPP_NAMESPACE::CudaFunctionNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaFunctionNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaFunctionNV; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - CudaFunctionNV( Device const & device, CudaFunctionCreateInfoNV const & createInfo, Optional allocator = nullptr ) - { - *this = device.createCudaFunctionNV( createInfo, allocator ); - } -# endif - - CudaFunctionNV( Device const & device, VkCudaFunctionNV function, Optional allocator = nullptr ) - : m_device( device ) - , m_cudaFunctionNV( function ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - CudaFunctionNV( std::nullptr_t ) {} - - ~CudaFunctionNV() - { - clear(); - } - - CudaFunctionNV() = delete; - CudaFunctionNV( CudaFunctionNV const & ) = delete; - - CudaFunctionNV( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_cudaFunctionNV( exchange( rhs.m_cudaFunctionNV, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - CudaFunctionNV & operator=( CudaFunctionNV const & ) = delete; - - CudaFunctionNV & operator=( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_cudaFunctionNV, rhs.m_cudaFunctionNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::CudaFunctionNV const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_cudaFunctionNV; - } - - VULKAN_HPP_NAMESPACE::CudaFunctionNV const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_cudaFunctionNV ); - } - - operator VULKAN_HPP_NAMESPACE::CudaFunctionNV() const VULKAN_HPP_NOEXCEPT - { - return m_cudaFunctionNV; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_cudaFunctionNV ) - { - getDispatcher()->vkDestroyCudaFunctionNV( static_cast( m_device ), - static_cast( m_cudaFunctionNV ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_cudaFunctionNV = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::CudaFunctionNV release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_cudaFunctionNV, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( CudaFunctionNV & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_cudaFunctionNV, rhs.m_cudaFunctionNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::CudaFunctionNV m_cudaFunctionNV = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper class for handle VkCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaModuleNV.html -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - class CudaModuleNV - { - public: - using CType = VkCudaModuleNV; - using CppType = VULKAN_HPP_NAMESPACE::CudaModuleNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eCudaModuleNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eCudaModuleNV; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - CudaModuleNV( Device const & device, CudaModuleCreateInfoNV const & createInfo, Optional allocator = nullptr ) - { - *this = device.createCudaModuleNV( createInfo, allocator ); - } -# endif - - CudaModuleNV( Device const & device, VkCudaModuleNV module, Optional allocator = nullptr ) - : m_device( device ) - , m_cudaModuleNV( module ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - CudaModuleNV( std::nullptr_t ) {} - - ~CudaModuleNV() - { - clear(); - } - - CudaModuleNV() = delete; - CudaModuleNV( CudaModuleNV const & ) = delete; - - CudaModuleNV( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_cudaModuleNV( exchange( rhs.m_cudaModuleNV, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - CudaModuleNV & operator=( CudaModuleNV const & ) = delete; - - CudaModuleNV & operator=( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_cudaModuleNV, rhs.m_cudaModuleNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::CudaModuleNV const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_cudaModuleNV; - } - - VULKAN_HPP_NAMESPACE::CudaModuleNV const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_cudaModuleNV ); - } - - operator VULKAN_HPP_NAMESPACE::CudaModuleNV() const VULKAN_HPP_NOEXCEPT - { - return m_cudaModuleNV; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_cudaModuleNV ) - { - getDispatcher()->vkDestroyCudaModuleNV( - static_cast( m_device ), static_cast( m_cudaModuleNV ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_cudaModuleNV = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::CudaModuleNV release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_cudaModuleNV, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( CudaModuleNV & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_cudaModuleNV, rhs.m_cudaModuleNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_NV_cuda_kernel_launch === - - // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getCache() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::CudaModuleNV m_cudaModuleNV = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper class for handle VkDataGraphPipelineSessionARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionARM.html - class DataGraphPipelineSessionARM - { - public: - using CType = VkDataGraphPipelineSessionARM; - using CppType = VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDataGraphPipelineSessionARM; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DataGraphPipelineSessionARM( Device const & device, - DataGraphPipelineSessionCreateInfoARM const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createDataGraphPipelineSessionARM( createInfo, allocator ); - } -# endif - - DataGraphPipelineSessionARM( Device const & device, VkDataGraphPipelineSessionARM session, Optional allocator = nullptr ) - : m_device( device ) - , m_dataGraphPipelineSessionARM( session ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - DataGraphPipelineSessionARM( std::nullptr_t ) {} - - ~DataGraphPipelineSessionARM() - { - clear(); - } - - DataGraphPipelineSessionARM() = delete; - DataGraphPipelineSessionARM( DataGraphPipelineSessionARM const & ) = delete; - - DataGraphPipelineSessionARM( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_dataGraphPipelineSessionARM( exchange( rhs.m_dataGraphPipelineSessionARM, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM const & ) = delete; - - DataGraphPipelineSessionARM & operator=( DataGraphPipelineSessionARM && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_dataGraphPipelineSessionARM, rhs.m_dataGraphPipelineSessionARM ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_dataGraphPipelineSessionARM; - } - - VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_dataGraphPipelineSessionARM ); - } - - operator VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM() const VULKAN_HPP_NOEXCEPT - { - return m_dataGraphPipelineSessionARM; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_dataGraphPipelineSessionARM ) - { - getDispatcher()->vkDestroyDataGraphPipelineSessionARM( static_cast( m_device ), - static_cast( m_dataGraphPipelineSessionARM ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_dataGraphPipelineSessionARM = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_dataGraphPipelineSessionARM, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( DataGraphPipelineSessionARM & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_dataGraphPipelineSessionARM, rhs.m_dataGraphPipelineSessionARM ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM m_dataGraphPipelineSessionARM = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDebugReportCallbackEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportCallbackEXT.html - class DebugReportCallbackEXT - { - public: - using CType = VkDebugReportCallbackEXT; - using CppType = VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugReportCallbackEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDebugReportCallbackEXT; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DebugReportCallbackEXT( Instance const & instance, - DebugReportCallbackCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) - { - *this = instance.createDebugReportCallbackEXT( createInfo, allocator ); - } -# endif - - DebugReportCallbackEXT( Instance const & instance, VkDebugReportCallbackEXT callback, Optional allocator = nullptr ) - : m_instance( instance ) - , m_debugReportCallbackEXT( callback ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( instance.getDispatcher() ) - { - } - - DebugReportCallbackEXT( std::nullptr_t ) {} - - ~DebugReportCallbackEXT() - { - clear(); - } - - DebugReportCallbackEXT() = delete; - DebugReportCallbackEXT( DebugReportCallbackEXT const & ) = delete; - - DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_instance( exchange( rhs.m_instance, {} ) ) - , m_debugReportCallbackEXT( exchange( rhs.m_debugReportCallbackEXT, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - DebugReportCallbackEXT & operator=( DebugReportCallbackEXT const & ) = delete; - - DebugReportCallbackEXT & operator=( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_instance, rhs.m_instance ); - std::swap( m_debugReportCallbackEXT, rhs.m_debugReportCallbackEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_debugReportCallbackEXT; - } - - VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_debugReportCallbackEXT ); - } - - operator VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT - { - return m_debugReportCallbackEXT; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_debugReportCallbackEXT ) - { - getDispatcher()->vkDestroyDebugReportCallbackEXT( static_cast( m_instance ), - static_cast( m_debugReportCallbackEXT ), - reinterpret_cast( m_allocator ) ); - } - m_instance = nullptr; - m_debugReportCallbackEXT = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT release() - { - m_instance = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_debugReportCallbackEXT, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Instance getInstance() const - { - return m_instance; - } - - detail::InstanceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( DebugReportCallbackEXT & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_instance, rhs.m_instance ); - std::swap( m_debugReportCallbackEXT, rhs.m_debugReportCallbackEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Instance m_instance = {}; - VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT m_debugReportCallbackEXT = {}; - const AllocationCallbacks * m_allocator = {}; - detail::InstanceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDebugUtilsMessengerEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerEXT.html - class DebugUtilsMessengerEXT - { - public: - using CType = VkDebugUtilsMessengerEXT; - using CppType = VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDebugUtilsMessengerEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DebugUtilsMessengerEXT( Instance const & instance, - DebugUtilsMessengerCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) - { - *this = instance.createDebugUtilsMessengerEXT( createInfo, allocator ); - } -# endif - - DebugUtilsMessengerEXT( Instance const & instance, VkDebugUtilsMessengerEXT messenger, Optional allocator = nullptr ) - : m_instance( instance ) - , m_debugUtilsMessengerEXT( messenger ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( instance.getDispatcher() ) - { - } - - DebugUtilsMessengerEXT( std::nullptr_t ) {} - - ~DebugUtilsMessengerEXT() - { - clear(); - } - - DebugUtilsMessengerEXT() = delete; - DebugUtilsMessengerEXT( DebugUtilsMessengerEXT const & ) = delete; - - DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_instance( exchange( rhs.m_instance, {} ) ) - , m_debugUtilsMessengerEXT( exchange( rhs.m_debugUtilsMessengerEXT, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT const & ) = delete; - - DebugUtilsMessengerEXT & operator=( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_instance, rhs.m_instance ); - std::swap( m_debugUtilsMessengerEXT, rhs.m_debugUtilsMessengerEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_debugUtilsMessengerEXT; - } - - VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_debugUtilsMessengerEXT ); - } - - operator VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT - { - return m_debugUtilsMessengerEXT; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_debugUtilsMessengerEXT ) - { - getDispatcher()->vkDestroyDebugUtilsMessengerEXT( static_cast( m_instance ), - static_cast( m_debugUtilsMessengerEXT ), - reinterpret_cast( m_allocator ) ); - } - m_instance = nullptr; - m_debugUtilsMessengerEXT = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT release() - { - m_instance = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_debugUtilsMessengerEXT, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Instance getInstance() const - { - return m_instance; - } - - detail::InstanceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( DebugUtilsMessengerEXT & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_instance, rhs.m_instance ); - std::swap( m_debugUtilsMessengerEXT, rhs.m_debugUtilsMessengerEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Instance m_instance = {}; - VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {}; - const AllocationCallbacks * m_allocator = {}; - detail::InstanceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDeferredOperationKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeferredOperationKHR.html - class DeferredOperationKHR - { - public: - using CType = VkDeferredOperationKHR; - using CppType = VULKAN_HPP_NAMESPACE::DeferredOperationKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeferredOperationKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DeferredOperationKHR( Device const & device, Optional allocator = nullptr ) - { - *this = device.createDeferredOperationKHR( allocator ); - } -# endif - - DeferredOperationKHR( Device const & device, VkDeferredOperationKHR operation, Optional allocator = nullptr ) - : m_device( device ) - , m_deferredOperationKHR( operation ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - DeferredOperationKHR( std::nullptr_t ) {} - - ~DeferredOperationKHR() - { - clear(); - } - - DeferredOperationKHR() = delete; - DeferredOperationKHR( DeferredOperationKHR const & ) = delete; - - DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_deferredOperationKHR( exchange( rhs.m_deferredOperationKHR, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - DeferredOperationKHR & operator=( DeferredOperationKHR const & ) = delete; - - DeferredOperationKHR & operator=( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_deferredOperationKHR, rhs.m_deferredOperationKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_deferredOperationKHR; - } - - VULKAN_HPP_NAMESPACE::DeferredOperationKHR const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_deferredOperationKHR ); - } - - operator VULKAN_HPP_NAMESPACE::DeferredOperationKHR() const VULKAN_HPP_NOEXCEPT - { - return m_deferredOperationKHR; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_deferredOperationKHR ) - { - getDispatcher()->vkDestroyDeferredOperationKHR( static_cast( m_device ), - static_cast( m_deferredOperationKHR ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_deferredOperationKHR = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::DeferredOperationKHR release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_deferredOperationKHR, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( DeferredOperationKHR & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_deferredOperationKHR, rhs.m_deferredOperationKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_KHR_deferred_host_operations === - - // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html - VULKAN_HPP_NODISCARD uint32_t getMaxConcurrency() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeferredOperationResultKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html - VULKAN_HPP_NODISCARD Result getResult() const; - - // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html - VULKAN_HPP_NODISCARD Result join() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::DeferredOperationKHR m_deferredOperationKHR = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPool.html - class DescriptorPool - { - public: - using CType = VkDescriptorPool; - using CppType = VULKAN_HPP_NAMESPACE::DescriptorPool; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorPool; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorPool; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DescriptorPool( Device const & device, DescriptorPoolCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createDescriptorPool( createInfo, allocator ); - } -# endif - - DescriptorPool( Device const & device, VkDescriptorPool descriptorPool, Optional allocator = nullptr ) - : m_device( device ) - , m_descriptorPool( descriptorPool ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - DescriptorPool( std::nullptr_t ) {} - - ~DescriptorPool() - { - clear(); - } - - DescriptorPool() = delete; - DescriptorPool( DescriptorPool const & ) = delete; - - DescriptorPool( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_descriptorPool( exchange( rhs.m_descriptorPool, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - DescriptorPool & operator=( DescriptorPool const & ) = delete; - - DescriptorPool & operator=( DescriptorPool && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_descriptorPool, rhs.m_descriptorPool ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::DescriptorPool const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_descriptorPool; - } - - VULKAN_HPP_NAMESPACE::DescriptorPool const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_descriptorPool ); - } - - operator VULKAN_HPP_NAMESPACE::DescriptorPool() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorPool; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_descriptorPool ) - { - getDispatcher()->vkDestroyDescriptorPool( static_cast( m_device ), - static_cast( m_descriptorPool ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_descriptorPool = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::DescriptorPool release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_descriptorPool, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( DescriptorPool & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_descriptorPool, rhs.m_descriptorPool ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html - typename ResultValueType::type reset( DescriptorPoolResetFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSet.html - class DescriptorSet - { - public: - using CType = VkDescriptorSet; - using CppType = VULKAN_HPP_NAMESPACE::DescriptorSet; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSet; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSet; - - public: - DescriptorSet( Device const & device, VkDescriptorSet descriptorSet, VkDescriptorPool descriptorPool ) - : m_device( device ), m_descriptorPool( descriptorPool ), m_descriptorSet( descriptorSet ), m_dispatcher( device.getDispatcher() ) - { - } - - DescriptorSet( std::nullptr_t ) {} - - ~DescriptorSet() - { - clear(); - } - - DescriptorSet() = delete; - DescriptorSet( DescriptorSet const & ) = delete; - - DescriptorSet( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_descriptorPool( exchange( rhs.m_descriptorPool, {} ) ) - , m_descriptorSet( exchange( rhs.m_descriptorSet, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - DescriptorSet & operator=( DescriptorSet const & ) = delete; - - DescriptorSet & operator=( DescriptorSet && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_descriptorPool, rhs.m_descriptorPool ); - std::swap( m_descriptorSet, rhs.m_descriptorSet ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::DescriptorSet const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_descriptorSet; - } - - VULKAN_HPP_NAMESPACE::DescriptorSet const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_descriptorSet ); - } - - operator VULKAN_HPP_NAMESPACE::DescriptorSet() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorSet; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_descriptorSet ) - { - getDispatcher()->vkFreeDescriptorSets( static_cast( m_device ), - static_cast( m_descriptorPool ), - 1, - reinterpret_cast( &m_descriptorSet ) ); - } - m_device = nullptr; - m_descriptorPool = nullptr; - m_descriptorSet = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::DescriptorSet release() - { - m_device = nullptr; - m_descriptorPool = nullptr; - m_dispatcher = nullptr; - return exchange( m_descriptorSet, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( DescriptorSet & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_descriptorPool, rhs.m_descriptorPool ); - std::swap( m_descriptorSet, rhs.m_descriptorSet ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkUpdateDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html - template - void updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_descriptor_update_template === - - // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html - template - void updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, DataType const & data ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_VALVE_descriptor_set_host_mapping === - - // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html - VULKAN_HPP_NODISCARD void * getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::DescriptorPool m_descriptorPool = {}; - VULKAN_HPP_NAMESPACE::DescriptorSet m_descriptorSet = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - class DescriptorSets : public std::vector - { - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DescriptorSets( Device const & device, DescriptorSetAllocateInfo const & allocateInfo ) - { - *this = device.allocateDescriptorSets( allocateInfo ); - } -# endif - - DescriptorSets( std::nullptr_t ) {} - - DescriptorSets() = delete; - DescriptorSets( DescriptorSets const & ) = delete; - DescriptorSets( DescriptorSets && rhs ) = default; - DescriptorSets & operator=( DescriptorSets const & ) = delete; - DescriptorSets & operator=( DescriptorSets && rhs ) = default; - - DescriptorSets( std::vector && rhs ) - { - std::swap( *this, rhs ); - } - }; - - // wrapper class for handle VkDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayout.html - class DescriptorSetLayout - { - public: - using CType = VkDescriptorSetLayout; - using CppType = VULKAN_HPP_NAMESPACE::DescriptorSetLayout; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorSetLayout; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorSetLayout; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DescriptorSetLayout( Device const & device, DescriptorSetLayoutCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createDescriptorSetLayout( createInfo, allocator ); - } -# endif - - DescriptorSetLayout( Device const & device, VkDescriptorSetLayout descriptorSetLayout, Optional allocator = nullptr ) - : m_device( device ) - , m_descriptorSetLayout( descriptorSetLayout ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - DescriptorSetLayout( std::nullptr_t ) {} - - ~DescriptorSetLayout() - { - clear(); - } - - DescriptorSetLayout() = delete; - DescriptorSetLayout( DescriptorSetLayout const & ) = delete; - - DescriptorSetLayout( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_descriptorSetLayout( exchange( rhs.m_descriptorSetLayout, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - DescriptorSetLayout & operator=( DescriptorSetLayout const & ) = delete; - - DescriptorSetLayout & operator=( DescriptorSetLayout && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::DescriptorSetLayout const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_descriptorSetLayout; - } - - VULKAN_HPP_NAMESPACE::DescriptorSetLayout const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_descriptorSetLayout ); - } - - operator VULKAN_HPP_NAMESPACE::DescriptorSetLayout() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorSetLayout; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_descriptorSetLayout ) - { - getDispatcher()->vkDestroyDescriptorSetLayout( static_cast( m_device ), - static_cast( m_descriptorSetLayout ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_descriptorSetLayout = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::DescriptorSetLayout release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_descriptorSetLayout, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( DescriptorSetLayout & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_descriptorSetLayout, rhs.m_descriptorSetLayout ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_EXT_descriptor_buffer === - - // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html - VULKAN_HPP_NODISCARD DeviceSize getSizeEXT() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html - VULKAN_HPP_NODISCARD DeviceSize getBindingOffsetEXT( uint32_t binding ) const VULKAN_HPP_NOEXCEPT; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::DescriptorSetLayout m_descriptorSetLayout = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDescriptorUpdateTemplate, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplate.html - class DescriptorUpdateTemplate - { - public: - using CType = VkDescriptorUpdateTemplate; - using CppType = VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDescriptorUpdateTemplate; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDescriptorUpdateTemplate; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DescriptorUpdateTemplate( Device const & device, - DescriptorUpdateTemplateCreateInfo const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createDescriptorUpdateTemplate( createInfo, allocator ); - } -# endif - - DescriptorUpdateTemplate( Device const & device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - Optional allocator = nullptr ) - : m_device( device ) - , m_descriptorUpdateTemplate( descriptorUpdateTemplate ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - DescriptorUpdateTemplate( std::nullptr_t ) {} - - ~DescriptorUpdateTemplate() - { - clear(); - } - - DescriptorUpdateTemplate() = delete; - DescriptorUpdateTemplate( DescriptorUpdateTemplate const & ) = delete; - - DescriptorUpdateTemplate( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_descriptorUpdateTemplate( exchange( rhs.m_descriptorUpdateTemplate, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate const & ) = delete; - - DescriptorUpdateTemplate & operator=( DescriptorUpdateTemplate && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_descriptorUpdateTemplate; - } - - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_descriptorUpdateTemplate ); - } - - operator VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate() const VULKAN_HPP_NOEXCEPT - { - return m_descriptorUpdateTemplate; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_descriptorUpdateTemplate ) - { - getDispatcher()->vkDestroyDescriptorUpdateTemplate( static_cast( m_device ), - static_cast( m_descriptorUpdateTemplate ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_descriptorUpdateTemplate = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_descriptorUpdateTemplate, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( DescriptorUpdateTemplate & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_descriptorUpdateTemplate, rhs.m_descriptorUpdateTemplate ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate m_descriptorUpdateTemplate = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDeviceMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemory.html - class DeviceMemory - { - public: - using CType = VkDeviceMemory; - using CppType = VULKAN_HPP_NAMESPACE::DeviceMemory; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDeviceMemory; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDeviceMemory; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DeviceMemory( Device const & device, MemoryAllocateInfo const & allocateInfo, Optional allocator = nullptr ) - { - *this = device.allocateMemory( allocateInfo, allocator ); - } -# endif - - DeviceMemory( Device const & device, VkDeviceMemory memory, Optional allocator = nullptr ) - : m_device( device ) - , m_deviceMemory( memory ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - DeviceMemory( std::nullptr_t ) {} - - ~DeviceMemory() - { - clear(); - } - - DeviceMemory() = delete; - DeviceMemory( DeviceMemory const & ) = delete; - - DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_deviceMemory( exchange( rhs.m_deviceMemory, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - DeviceMemory & operator=( DeviceMemory const & ) = delete; - - DeviceMemory & operator=( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_deviceMemory, rhs.m_deviceMemory ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::DeviceMemory const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_deviceMemory; - } - - VULKAN_HPP_NAMESPACE::DeviceMemory const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_deviceMemory ); - } - - operator VULKAN_HPP_NAMESPACE::DeviceMemory() const VULKAN_HPP_NOEXCEPT - { - return m_deviceMemory; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_deviceMemory ) - { - getDispatcher()->vkFreeMemory( - static_cast( m_device ), static_cast( m_deviceMemory ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_deviceMemory = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::DeviceMemory release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_deviceMemory, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( DeviceMemory & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_deviceMemory, rhs.m_deviceMemory ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - mapMemory( DeviceSize offset, DeviceSize size, MemoryMapFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html - void unmapMemory() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetDeviceMemoryCommitment, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html - VULKAN_HPP_NODISCARD DeviceSize getCommitment() const VULKAN_HPP_NOEXCEPT; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - - // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getMemoryWin32HandleNV( ExternalMemoryHandleTypeFlagsNV handleType ) const; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_pageable_device_local_memory === - - // wrapper function for command vkSetDeviceMemoryPriorityEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html - void setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::DeviceMemory m_deviceMemory = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkDisplayKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayKHR.html - class DisplayKHR - { - public: - using CType = VkDisplayKHR; - using CppType = VULKAN_HPP_NAMESPACE::DisplayKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayKHR; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DisplayKHR( PhysicalDevice const & physicalDevice, int32_t drmFd, uint32_t connectorId ) - { - *this = physicalDevice.getDrmDisplayEXT( drmFd, connectorId ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - DisplayKHR( PhysicalDevice const & physicalDevice, Display & dpy, RROutput rrOutput ) - { - *this = physicalDevice.getRandROutputDisplayEXT( dpy, rrOutput ); - } -# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - DisplayKHR( PhysicalDevice const & physicalDevice, uint32_t deviceRelativeId ) - { - *this = physicalDevice.getWinrtDisplayNV( deviceRelativeId ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ -# endif - - DisplayKHR( PhysicalDevice const & physicalDevice, VkDisplayKHR display ) - : m_physicalDevice( physicalDevice ), m_displayKHR( display ), m_dispatcher( physicalDevice.getDispatcher() ) - { - } - - DisplayKHR( std::nullptr_t ) {} - - ~DisplayKHR() - { - clear(); - } - - DisplayKHR() = delete; - DisplayKHR( DisplayKHR const & ) = delete; - - DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_physicalDevice( exchange( rhs.m_physicalDevice, {} ) ) - , m_displayKHR( exchange( rhs.m_displayKHR, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - DisplayKHR & operator=( DisplayKHR const & ) = delete; - - DisplayKHR & operator=( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_physicalDevice, rhs.m_physicalDevice ); - std::swap( m_displayKHR, rhs.m_displayKHR ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::DisplayKHR const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_displayKHR; - } - - VULKAN_HPP_NAMESPACE::DisplayKHR const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_displayKHR ); - } - - operator VULKAN_HPP_NAMESPACE::DisplayKHR() const VULKAN_HPP_NOEXCEPT - { - return m_displayKHR; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_displayKHR ) - { - getDispatcher()->vkReleaseDisplayEXT( static_cast( m_physicalDevice ), static_cast( m_displayKHR ) ); - } - m_physicalDevice = nullptr; - m_displayKHR = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::DisplayKHR release() - { - m_physicalDevice = nullptr; - m_dispatcher = nullptr; - return exchange( m_displayKHR, nullptr ); - } - - VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const - { - return m_physicalDevice; - } - - detail::InstanceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( DisplayKHR & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_physicalDevice, rhs.m_physicalDevice ); - std::swap( m_displayKHR, rhs.m_displayKHR ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_KHR_display === - - // wrapper function for command vkGetDisplayModePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getModeProperties() const; - - // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - createMode( DisplayModeCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; - - //=== VK_KHR_get_display_properties2 === - - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getModeProperties2() const; - - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type getModeProperties2() const; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - - // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html - typename ResultValueType::type acquireWinrtNV() const; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - private: - VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; - VULKAN_HPP_NAMESPACE::DisplayKHR m_displayKHR = {}; - detail::InstanceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - class DisplayKHRs : public std::vector - { - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DisplayKHRs( PhysicalDevice const & physicalDevice, uint32_t planeIndex ) - { - *this = physicalDevice.getDisplayPlaneSupportedDisplaysKHR( planeIndex ); - } -# endif - - DisplayKHRs( std::nullptr_t ) {} - - DisplayKHRs() = delete; - DisplayKHRs( DisplayKHRs const & ) = delete; - DisplayKHRs( DisplayKHRs && rhs ) = default; - DisplayKHRs & operator=( DisplayKHRs const & ) = delete; - DisplayKHRs & operator=( DisplayKHRs && rhs ) = default; - - DisplayKHRs( std::vector && rhs ) - { - std::swap( *this, rhs ); - } - }; - - // wrapper class for handle VkDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeKHR.html - class DisplayModeKHR - { - public: - using CType = VkDisplayModeKHR; - using CppType = VULKAN_HPP_NAMESPACE::DisplayModeKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eDisplayModeKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eDisplayModeKHR; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - DisplayModeKHR( DisplayKHR const & display, DisplayModeCreateInfoKHR const & createInfo, Optional allocator = nullptr ) - { - *this = display.createMode( createInfo, allocator ); - } -# endif - - DisplayModeKHR( DisplayKHR const & display, VkDisplayModeKHR displayModeKHR ) - : m_physicalDevice( display.getPhysicalDevice() ), m_displayModeKHR( displayModeKHR ), m_dispatcher( display.getDispatcher() ) - { - } - - DisplayModeKHR( std::nullptr_t ) {} - - ~DisplayModeKHR() - { - clear(); - } - - DisplayModeKHR() = delete; - - DisplayModeKHR( DisplayModeKHR const & rhs ) : m_displayModeKHR( rhs.m_displayModeKHR ), m_dispatcher( rhs.m_dispatcher ) {} - - DisplayModeKHR( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_physicalDevice( exchange( rhs.m_physicalDevice, {} ) ) - , m_displayModeKHR( exchange( rhs.m_displayModeKHR, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - DisplayModeKHR & operator=( DisplayModeKHR const & rhs ) - { - m_displayModeKHR = rhs.m_displayModeKHR; - m_dispatcher = rhs.m_dispatcher; - return *this; - } - - DisplayModeKHR & operator=( DisplayModeKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_physicalDevice, rhs.m_physicalDevice ); - std::swap( m_displayModeKHR, rhs.m_displayModeKHR ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::DisplayModeKHR const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_displayModeKHR; - } - - VULKAN_HPP_NAMESPACE::DisplayModeKHR const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_displayModeKHR ); - } - - operator VULKAN_HPP_NAMESPACE::DisplayModeKHR() const VULKAN_HPP_NOEXCEPT - { - return m_displayModeKHR; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - m_physicalDevice = nullptr; - m_displayModeKHR = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::DisplayModeKHR release() - { - m_physicalDevice = nullptr; - m_dispatcher = nullptr; - return exchange( m_displayModeKHR, nullptr ); - } - - detail::InstanceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( DisplayModeKHR & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_physicalDevice, rhs.m_physicalDevice ); - std::swap( m_displayModeKHR, rhs.m_displayModeKHR ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_KHR_display === - - // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getDisplayPlaneCapabilities( uint32_t planeIndex ) const; - - private: - VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; - VULKAN_HPP_NAMESPACE::DisplayModeKHR m_displayModeKHR = {}; - detail::InstanceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEvent.html - class Event - { - public: - using CType = VkEvent; - using CppType = VULKAN_HPP_NAMESPACE::Event; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eEvent; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eEvent; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Event( Device const & device, EventCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createEvent( createInfo, allocator ); - } -# endif - - Event( Device const & device, VkEvent event, Optional allocator = nullptr ) - : m_device( device ), m_event( event ), m_allocator( static_cast( allocator ) ), m_dispatcher( device.getDispatcher() ) - { - } - - Event( std::nullptr_t ) {} - - ~Event() - { - clear(); - } - - Event() = delete; - Event( Event const & ) = delete; - - Event( Event && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_event( exchange( rhs.m_event, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - Event & operator=( Event const & ) = delete; - - Event & operator=( Event && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_event, rhs.m_event ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::Event const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_event; - } - - VULKAN_HPP_NAMESPACE::Event const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_event ); - } - - operator VULKAN_HPP_NAMESPACE::Event() const VULKAN_HPP_NOEXCEPT - { - return m_event; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_event ) - { - getDispatcher()->vkDestroyEvent( - static_cast( m_device ), static_cast( m_event ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_event = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::Event release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_event, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( Event & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_event, rhs.m_event ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html - VULKAN_HPP_NODISCARD Result getStatus() const; - - // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html - typename ResultValueType::type set() const; - - // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html - typename ResultValueType::type reset() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::Event m_event = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueNV.html - class ExternalComputeQueueNV - { - public: - using CType = VkExternalComputeQueueNV; - using CppType = VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eExternalComputeQueueNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - ExternalComputeQueueNV( Device const & device, - ExternalComputeQueueCreateInfoNV const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createExternalComputeQueueNV( createInfo, allocator ); - } -# endif - - ExternalComputeQueueNV( Device const & device, VkExternalComputeQueueNV externalQueue, Optional allocator = nullptr ) - : m_device( device ) - , m_externalComputeQueueNV( externalQueue ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - ExternalComputeQueueNV( std::nullptr_t ) {} - - ~ExternalComputeQueueNV() - { - clear(); - } - - ExternalComputeQueueNV() = delete; - ExternalComputeQueueNV( ExternalComputeQueueNV const & ) = delete; - - ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_externalComputeQueueNV( exchange( rhs.m_externalComputeQueueNV, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - ExternalComputeQueueNV & operator=( ExternalComputeQueueNV const & ) = delete; - - ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_externalComputeQueueNV, rhs.m_externalComputeQueueNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_externalComputeQueueNV; - } - - VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_externalComputeQueueNV ); - } - - operator VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV() const VULKAN_HPP_NOEXCEPT - { - return m_externalComputeQueueNV; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_externalComputeQueueNV ) - { - getDispatcher()->vkDestroyExternalComputeQueueNV( static_cast( m_device ), - static_cast( m_externalComputeQueueNV ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_externalComputeQueueNV = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_externalComputeQueueNV, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( ExternalComputeQueueNV & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_externalComputeQueueNV, rhs.m_externalComputeQueueNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_NV_external_compute_queue === - - // wrapper function for command vkGetExternalComputeQueueDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html - template - VULKAN_HPP_NODISCARD std::pair getData() const VULKAN_HPP_NOEXCEPT; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV m_externalComputeQueueNV = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFence.html - class Fence - { - public: - using CType = VkFence; - using CppType = VULKAN_HPP_NAMESPACE::Fence; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFence; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFence; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Fence( Device const & device, FenceCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createFence( createInfo, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Fence( Device const & device, DeviceEventInfoEXT const & deviceEventInfo, Optional allocator = nullptr ) - { - *this = device.registerEventEXT( deviceEventInfo, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Fence( Device const & device, - DisplayKHR const & display, - DisplayEventInfoEXT const & displayEventInfo, - Optional allocator = nullptr ) - { - *this = device.registerDisplayEventEXT( display, displayEventInfo, allocator ); - } -# endif - - Fence( Device const & device, VkFence fence, Optional allocator = nullptr ) - : m_device( device ), m_fence( fence ), m_allocator( static_cast( allocator ) ), m_dispatcher( device.getDispatcher() ) - { - } - - Fence( std::nullptr_t ) {} - - ~Fence() - { - clear(); - } - - Fence() = delete; - Fence( Fence const & ) = delete; - - Fence( Fence && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_fence( exchange( rhs.m_fence, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - Fence & operator=( Fence const & ) = delete; - - Fence & operator=( Fence && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_fence, rhs.m_fence ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::Fence const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_fence; - } - - VULKAN_HPP_NAMESPACE::Fence const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_fence ); - } - - operator VULKAN_HPP_NAMESPACE::Fence() const VULKAN_HPP_NOEXCEPT - { - return m_fence; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_fence ) - { - getDispatcher()->vkDestroyFence( - static_cast( m_device ), static_cast( m_fence ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_fence = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::Fence release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_fence, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( Fence & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_fence, rhs.m_fence ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html - VULKAN_HPP_NODISCARD Result getStatus() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::Fence m_fence = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebuffer.html - class Framebuffer - { - public: - using CType = VkFramebuffer; - using CppType = VULKAN_HPP_NAMESPACE::Framebuffer; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eFramebuffer; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eFramebuffer; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Framebuffer( Device const & device, FramebufferCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createFramebuffer( createInfo, allocator ); - } -# endif - - Framebuffer( Device const & device, VkFramebuffer framebuffer, Optional allocator = nullptr ) - : m_device( device ) - , m_framebuffer( framebuffer ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - Framebuffer( std::nullptr_t ) {} - - ~Framebuffer() - { - clear(); - } - - Framebuffer() = delete; - Framebuffer( Framebuffer const & ) = delete; - - Framebuffer( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_framebuffer( exchange( rhs.m_framebuffer, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - Framebuffer & operator=( Framebuffer const & ) = delete; - - Framebuffer & operator=( Framebuffer && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_framebuffer, rhs.m_framebuffer ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::Framebuffer const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_framebuffer; - } - - VULKAN_HPP_NAMESPACE::Framebuffer const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_framebuffer ); - } - - operator VULKAN_HPP_NAMESPACE::Framebuffer() const VULKAN_HPP_NOEXCEPT - { - return m_framebuffer; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_framebuffer ) - { - getDispatcher()->vkDestroyFramebuffer( - static_cast( m_device ), static_cast( m_framebuffer ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_framebuffer = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::Framebuffer release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_framebuffer, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( Framebuffer & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_framebuffer, rhs.m_framebuffer ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_QCOM_tile_properties === - - // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getTilePropertiesQCOM() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::Framebuffer m_framebuffer = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImage.html - class Image - { - public: - using CType = VkImage; - using CppType = VULKAN_HPP_NAMESPACE::Image; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImage; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImage; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Image( Device const & device, ImageCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createImage( createInfo, allocator ); - } -# endif - - Image( Device const & device, VkImage image, Optional allocator = nullptr ) - : m_device( device ), m_image( image ), m_allocator( static_cast( allocator ) ), m_dispatcher( device.getDispatcher() ) - { - } - - Image( std::nullptr_t ) {} - - ~Image() - { - clear(); - } - - Image() = delete; - Image( Image const & ) = delete; - - Image( Image && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_image( exchange( rhs.m_image, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - Image & operator=( Image const & ) = delete; - - Image & operator=( Image && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_image, rhs.m_image ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::Image const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_image; - } - - VULKAN_HPP_NAMESPACE::Image const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_image ); - } - - operator VULKAN_HPP_NAMESPACE::Image() const VULKAN_HPP_NOEXCEPT - { - return m_image; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_image ) - { - getDispatcher()->vkDestroyImage( - static_cast( m_device ), static_cast( m_image ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_image = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::Image release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_image, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( Image & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_image, rhs.m_image ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html - typename ResultValueType::type bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, DeviceSize memoryOffset ) const; - - // wrapper function for command vkGetImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html - VULKAN_HPP_NODISCARD MemoryRequirements getMemoryRequirements() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html - VULKAN_HPP_NODISCARD std::vector getSparseMemoryRequirements() const; - - // wrapper function for command vkGetImageSubresourceLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html - VULKAN_HPP_NODISCARD SubresourceLayout getSubresourceLayout( const ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_VERSION_1_4 === - - // wrapper function for command vkGetImageSubresourceLayout2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html - VULKAN_HPP_NODISCARD SubresourceLayout2 getSubresourceLayout2( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetImageSubresourceLayout2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html - template - VULKAN_HPP_NODISCARD StructureChain getSubresourceLayout2( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_image_drm_format_modifier === - - // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getDrmFormatModifierPropertiesEXT() const; - - //=== VK_EXT_host_image_copy === - - // wrapper function for command vkGetImageSubresourceLayout2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html - VULKAN_HPP_NODISCARD SubresourceLayout2 getSubresourceLayout2EXT( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetImageSubresourceLayout2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html - template - VULKAN_HPP_NODISCARD StructureChain getSubresourceLayout2EXT( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_maintenance5 === - - // wrapper function for command vkGetImageSubresourceLayout2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html - VULKAN_HPP_NODISCARD SubresourceLayout2 getSubresourceLayout2KHR( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetImageSubresourceLayout2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html - template - VULKAN_HPP_NODISCARD StructureChain getSubresourceLayout2KHR( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT; - - protected: - Image( VULKAN_HPP_NAMESPACE::Device device, - VULKAN_HPP_NAMESPACE::Image image, - const AllocationCallbacks * allocator, - detail::DeviceDispatcher const * dispatcher ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( device, {} ) ) - , m_image( exchange( image, {} ) ) - , m_allocator( exchange( allocator, {} ) ) - , m_dispatcher( exchange( dispatcher, nullptr ) ) - { - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::Image m_image = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageView.html - class ImageView - { - public: - using CType = VkImageView; - using CppType = VULKAN_HPP_NAMESPACE::ImageView; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eImageView; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eImageView; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - ImageView( Device const & device, ImageViewCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createImageView( createInfo, allocator ); - } -# endif - - ImageView( Device const & device, VkImageView imageView, Optional allocator = nullptr ) - : m_device( device ) - , m_imageView( imageView ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - ImageView( std::nullptr_t ) {} - - ~ImageView() - { - clear(); - } - - ImageView() = delete; - ImageView( ImageView const & ) = delete; - - ImageView( ImageView && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_imageView( exchange( rhs.m_imageView, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - ImageView & operator=( ImageView const & ) = delete; - - ImageView & operator=( ImageView && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_imageView, rhs.m_imageView ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::ImageView const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_imageView; - } - - VULKAN_HPP_NAMESPACE::ImageView const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_imageView ); - } - - operator VULKAN_HPP_NAMESPACE::ImageView() const VULKAN_HPP_NOEXCEPT - { - return m_imageView; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_imageView ) - { - getDispatcher()->vkDestroyImageView( - static_cast( m_device ), static_cast( m_imageView ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_imageView = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::ImageView release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_imageView, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( ImageView & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_imageView, rhs.m_imageView ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_NVX_image_view_handle === - - // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getAddressNVX() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::ImageView m_imageView = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkIndirectCommandsLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutEXT.html - class IndirectCommandsLayoutEXT - { - public: - using CType = VkIndirectCommandsLayoutEXT; - using CppType = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - IndirectCommandsLayoutEXT( Device const & device, - IndirectCommandsLayoutCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createIndirectCommandsLayoutEXT( createInfo, allocator ); - } -# endif - - IndirectCommandsLayoutEXT( Device const & device, - VkIndirectCommandsLayoutEXT indirectCommandsLayout, - Optional allocator = nullptr ) - : m_device( device ) - , m_indirectCommandsLayoutEXT( indirectCommandsLayout ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - IndirectCommandsLayoutEXT( std::nullptr_t ) {} - - ~IndirectCommandsLayoutEXT() - { - clear(); - } - - IndirectCommandsLayoutEXT() = delete; - IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT const & ) = delete; - - IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_indirectCommandsLayoutEXT( exchange( rhs.m_indirectCommandsLayoutEXT, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT const & ) = delete; - - IndirectCommandsLayoutEXT & operator=( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_indirectCommandsLayoutEXT, rhs.m_indirectCommandsLayoutEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_indirectCommandsLayoutEXT; - } - - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_indirectCommandsLayoutEXT ); - } - - operator VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT() const VULKAN_HPP_NOEXCEPT - { - return m_indirectCommandsLayoutEXT; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_indirectCommandsLayoutEXT ) - { - getDispatcher()->vkDestroyIndirectCommandsLayoutEXT( static_cast( m_device ), - static_cast( m_indirectCommandsLayoutEXT ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_indirectCommandsLayoutEXT = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_indirectCommandsLayoutEXT, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( IndirectCommandsLayoutEXT & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_indirectCommandsLayoutEXT, rhs.m_indirectCommandsLayoutEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT m_indirectCommandsLayoutEXT = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkIndirectCommandsLayoutNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutNV.html - class IndirectCommandsLayoutNV - { - public: - using CType = VkIndirectCommandsLayoutNV; - using CppType = VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectCommandsLayoutNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - IndirectCommandsLayoutNV( Device const & device, - IndirectCommandsLayoutCreateInfoNV const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createIndirectCommandsLayoutNV( createInfo, allocator ); - } -# endif - - IndirectCommandsLayoutNV( Device const & device, - VkIndirectCommandsLayoutNV indirectCommandsLayout, - Optional allocator = nullptr ) - : m_device( device ) - , m_indirectCommandsLayoutNV( indirectCommandsLayout ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - IndirectCommandsLayoutNV( std::nullptr_t ) {} - - ~IndirectCommandsLayoutNV() - { - clear(); - } - - IndirectCommandsLayoutNV() = delete; - IndirectCommandsLayoutNV( IndirectCommandsLayoutNV const & ) = delete; - - IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_indirectCommandsLayoutNV( exchange( rhs.m_indirectCommandsLayoutNV, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV const & ) = delete; - - IndirectCommandsLayoutNV & operator=( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_indirectCommandsLayoutNV, rhs.m_indirectCommandsLayoutNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_indirectCommandsLayoutNV; - } - - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_indirectCommandsLayoutNV ); - } - - operator VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT - { - return m_indirectCommandsLayoutNV; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_indirectCommandsLayoutNV ) - { - getDispatcher()->vkDestroyIndirectCommandsLayoutNV( static_cast( m_device ), - static_cast( m_indirectCommandsLayoutNV ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_indirectCommandsLayoutNV = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_indirectCommandsLayoutNV, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( IndirectCommandsLayoutNV & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_indirectCommandsLayoutNV, rhs.m_indirectCommandsLayoutNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkIndirectExecutionSetEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetEXT.html - class IndirectExecutionSetEXT - { - public: - using CType = VkIndirectExecutionSetEXT; - using CppType = VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eIndirectExecutionSetEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - IndirectExecutionSetEXT( Device const & device, - IndirectExecutionSetCreateInfoEXT const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createIndirectExecutionSetEXT( createInfo, allocator ); - } -# endif - - IndirectExecutionSetEXT( Device const & device, VkIndirectExecutionSetEXT indirectExecutionSet, Optional allocator = nullptr ) - : m_device( device ) - , m_indirectExecutionSetEXT( indirectExecutionSet ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - IndirectExecutionSetEXT( std::nullptr_t ) {} - - ~IndirectExecutionSetEXT() - { - clear(); - } - - IndirectExecutionSetEXT() = delete; - IndirectExecutionSetEXT( IndirectExecutionSetEXT const & ) = delete; - - IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_indirectExecutionSetEXT( exchange( rhs.m_indirectExecutionSetEXT, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT const & ) = delete; - - IndirectExecutionSetEXT & operator=( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_indirectExecutionSetEXT, rhs.m_indirectExecutionSetEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_indirectExecutionSetEXT; - } - - VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_indirectExecutionSetEXT ); - } - - operator VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT() const VULKAN_HPP_NOEXCEPT - { - return m_indirectExecutionSetEXT; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_indirectExecutionSetEXT ) - { - getDispatcher()->vkDestroyIndirectExecutionSetEXT( static_cast( m_device ), - static_cast( m_indirectExecutionSetEXT ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_indirectExecutionSetEXT = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_indirectExecutionSetEXT, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( IndirectExecutionSetEXT & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_indirectExecutionSetEXT, rhs.m_indirectExecutionSetEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_EXT_device_generated_commands === - - // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html - void updatePipeline( ArrayProxy const & executionSetWrites ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html - void updateShader( ArrayProxy const & executionSetWrites ) const VULKAN_HPP_NOEXCEPT; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT m_indirectExecutionSetEXT = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapEXT.html - class MicromapEXT - { - public: - using CType = VkMicromapEXT; - using CppType = VULKAN_HPP_NAMESPACE::MicromapEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eMicromapEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - MicromapEXT( Device const & device, MicromapCreateInfoEXT const & createInfo, Optional allocator = nullptr ) - { - *this = device.createMicromapEXT( createInfo, allocator ); - } -# endif - - MicromapEXT( Device const & device, VkMicromapEXT micromap, Optional allocator = nullptr ) - : m_device( device ) - , m_micromapEXT( micromap ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - MicromapEXT( std::nullptr_t ) {} - - ~MicromapEXT() - { - clear(); - } - - MicromapEXT() = delete; - MicromapEXT( MicromapEXT const & ) = delete; - - MicromapEXT( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_micromapEXT( exchange( rhs.m_micromapEXT, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - MicromapEXT & operator=( MicromapEXT const & ) = delete; - - MicromapEXT & operator=( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_micromapEXT, rhs.m_micromapEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::MicromapEXT const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_micromapEXT; - } - - VULKAN_HPP_NAMESPACE::MicromapEXT const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_micromapEXT ); - } - - operator VULKAN_HPP_NAMESPACE::MicromapEXT() const VULKAN_HPP_NOEXCEPT - { - return m_micromapEXT; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_micromapEXT ) - { - getDispatcher()->vkDestroyMicromapEXT( - static_cast( m_device ), static_cast( m_micromapEXT ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_micromapEXT = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::MicromapEXT release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_micromapEXT, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( MicromapEXT & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_micromapEXT, rhs.m_micromapEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::MicromapEXT m_micromapEXT = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkOpticalFlowSessionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionNV.html - class OpticalFlowSessionNV - { - public: - using CType = VkOpticalFlowSessionNV; - using CppType = VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eOpticalFlowSessionNV; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - OpticalFlowSessionNV( Device const & device, OpticalFlowSessionCreateInfoNV const & createInfo, Optional allocator = nullptr ) - { - *this = device.createOpticalFlowSessionNV( createInfo, allocator ); - } -# endif - - OpticalFlowSessionNV( Device const & device, VkOpticalFlowSessionNV session, Optional allocator = nullptr ) - : m_device( device ) - , m_opticalFlowSessionNV( session ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - OpticalFlowSessionNV( std::nullptr_t ) {} - - ~OpticalFlowSessionNV() - { - clear(); - } - - OpticalFlowSessionNV() = delete; - OpticalFlowSessionNV( OpticalFlowSessionNV const & ) = delete; - - OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_opticalFlowSessionNV( exchange( rhs.m_opticalFlowSessionNV, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - OpticalFlowSessionNV & operator=( OpticalFlowSessionNV const & ) = delete; - - OpticalFlowSessionNV & operator=( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_opticalFlowSessionNV, rhs.m_opticalFlowSessionNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_opticalFlowSessionNV; - } - - VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_opticalFlowSessionNV ); - } - - operator VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT - { - return m_opticalFlowSessionNV; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_opticalFlowSessionNV ) - { - getDispatcher()->vkDestroyOpticalFlowSessionNV( static_cast( m_device ), - static_cast( m_opticalFlowSessionNV ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_opticalFlowSessionNV = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_opticalFlowSessionNV, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( OpticalFlowSessionNV & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_opticalFlowSessionNV, rhs.m_opticalFlowSessionNV ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_NV_optical_flow === - - // wrapper function for command vkBindOpticalFlowSessionImageNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html - typename ResultValueType::type - bindImage( OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, ImageLayout layout ) const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV m_opticalFlowSessionNV = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationINTEL.html - class PerformanceConfigurationINTEL - { - public: - using CType = VkPerformanceConfigurationINTEL; - using CppType = VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePerformanceConfigurationINTEL; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - PerformanceConfigurationINTEL( Device const & device, PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) - { - *this = device.acquirePerformanceConfigurationINTEL( acquireInfo ); - } -# endif - - PerformanceConfigurationINTEL( Device const & device, VkPerformanceConfigurationINTEL configuration ) - : m_device( device ), m_performanceConfigurationINTEL( configuration ), m_dispatcher( device.getDispatcher() ) - { - } - - PerformanceConfigurationINTEL( std::nullptr_t ) {} - - ~PerformanceConfigurationINTEL() - { - clear(); - } - - PerformanceConfigurationINTEL() = delete; - PerformanceConfigurationINTEL( PerformanceConfigurationINTEL const & ) = delete; - - PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_performanceConfigurationINTEL( exchange( rhs.m_performanceConfigurationINTEL, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL const & ) = delete; - - PerformanceConfigurationINTEL & operator=( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_performanceConfigurationINTEL, rhs.m_performanceConfigurationINTEL ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_performanceConfigurationINTEL; - } - - VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_performanceConfigurationINTEL ); - } - - operator VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT - { - return m_performanceConfigurationINTEL; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_performanceConfigurationINTEL ) - { - getDispatcher()->vkReleasePerformanceConfigurationINTEL( static_cast( m_device ), - static_cast( m_performanceConfigurationINTEL ) ); - } - m_device = nullptr; - m_performanceConfigurationINTEL = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL release() - { - m_device = nullptr; - m_dispatcher = nullptr; - return exchange( m_performanceConfigurationINTEL, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( PerformanceConfigurationINTEL & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_performanceConfigurationINTEL, rhs.m_performanceConfigurationINTEL ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL m_performanceConfigurationINTEL = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCache.html - class PipelineCache - { - public: - using CType = VkPipelineCache; - using CppType = VULKAN_HPP_NAMESPACE::PipelineCache; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineCache; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineCache; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - PipelineCache( Device const & device, PipelineCacheCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createPipelineCache( createInfo, allocator ); - } -# endif - - PipelineCache( Device const & device, VkPipelineCache pipelineCache, Optional allocator = nullptr ) - : m_device( device ) - , m_pipelineCache( pipelineCache ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - PipelineCache( std::nullptr_t ) {} - - ~PipelineCache() - { - clear(); - } - - PipelineCache() = delete; - PipelineCache( PipelineCache const & ) = delete; - - PipelineCache( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_pipelineCache( exchange( rhs.m_pipelineCache, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - PipelineCache & operator=( PipelineCache const & ) = delete; - - PipelineCache & operator=( PipelineCache && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_pipelineCache, rhs.m_pipelineCache ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::PipelineCache const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_pipelineCache; - } - - VULKAN_HPP_NAMESPACE::PipelineCache const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_pipelineCache ); - } - - operator VULKAN_HPP_NAMESPACE::PipelineCache() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineCache; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_pipelineCache ) - { - getDispatcher()->vkDestroyPipelineCache( static_cast( m_device ), - static_cast( m_pipelineCache ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_pipelineCache = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::PipelineCache release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_pipelineCache, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( PipelineCache & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_pipelineCache, rhs.m_pipelineCache ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getData() const; - - // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html - typename ResultValueType::type merge( ArrayProxy const & srcCaches ) const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::PipelineCache m_pipelineCache = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipeline.html - class Pipeline - { - public: - using CType = VkPipeline; - using CppType = VULKAN_HPP_NAMESPACE::Pipeline; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipeline; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipeline; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Pipeline( Device const & device, - Optional const & pipelineCache, - ComputePipelineCreateInfo const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createComputePipeline( pipelineCache, createInfo, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Pipeline( Device const & device, - Optional const & deferredOperation, - Optional const & pipelineCache, - DataGraphPipelineCreateInfoARM const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createDataGraphPipelineARM( deferredOperation, pipelineCache, createInfo, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - Pipeline( Device const & device, - Optional const & pipelineCache, - ExecutionGraphPipelineCreateInfoAMDX const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createExecutionGraphPipelineAMDX( pipelineCache, createInfo, allocator ); - } -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Pipeline( Device const & device, - Optional const & pipelineCache, - GraphicsPipelineCreateInfo const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createGraphicsPipeline( pipelineCache, createInfo, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Pipeline( Device const & device, - Optional const & deferredOperation, - Optional const & pipelineCache, - RayTracingPipelineCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createRayTracingPipelineKHR( deferredOperation, pipelineCache, createInfo, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Pipeline( Device const & device, - Optional const & pipelineCache, - RayTracingPipelineCreateInfoNV const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createRayTracingPipelineNV( pipelineCache, createInfo, allocator ); - } -# endif - - Pipeline( Device const & device, VkPipeline pipeline, Optional allocator = nullptr, Result successCode = Result::eSuccess ) - : m_device( device ) - , m_pipeline( pipeline ) - , m_allocator( static_cast( allocator ) ) - , m_constructorSuccessCode( successCode ) - , m_dispatcher( device.getDispatcher() ) - { - } - - Pipeline( std::nullptr_t ) {} - - ~Pipeline() - { - clear(); - } - - Pipeline() = delete; - Pipeline( Pipeline const & ) = delete; - - Pipeline( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_pipeline( exchange( rhs.m_pipeline, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_constructorSuccessCode( exchange( rhs.m_constructorSuccessCode, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - Pipeline & operator=( Pipeline const & ) = delete; - - Pipeline & operator=( Pipeline && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_pipeline, rhs.m_pipeline ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::Pipeline const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_pipeline; - } - - VULKAN_HPP_NAMESPACE::Pipeline const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_pipeline ); - } - - operator VULKAN_HPP_NAMESPACE::Pipeline() const VULKAN_HPP_NOEXCEPT - { - return m_pipeline; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_pipeline ) - { - getDispatcher()->vkDestroyPipeline( - static_cast( m_device ), static_cast( m_pipeline ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_pipeline = nullptr; - m_allocator = nullptr; - m_constructorSuccessCode = Result::eErrorUnknown; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::Pipeline release() - { - m_device = nullptr; - m_allocator = nullptr; - m_constructorSuccessCode = Result::eErrorUnknown; - m_dispatcher = nullptr; - return exchange( m_pipeline, nullptr ); - } - - Result getConstructorSuccessCode() const - { - return m_constructorSuccessCode; - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( Pipeline & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_pipeline, rhs.m_pipeline ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_AMD_shader_info === - - // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getShaderInfoAMD( ShaderStageFlagBits shaderStage, - ShaderInfoTypeAMD infoType ) const; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - - // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getExecutionGraphScratchSizeAMDX() const; - - // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html - VULKAN_HPP_NODISCARD typename ResultValueType::type - getExecutionGraphNodeIndexAMDX( const PipelineShaderStageNodeCreateInfoAMDX & nodeInfo ) const; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_KHR_ray_tracing_pipeline === - - // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; - - // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const; - - // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; - - // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, - uint32_t groupCount ) const; - - // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html - VULKAN_HPP_NODISCARD DeviceSize getRayTracingShaderGroupStackSizeKHR( uint32_t group, ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_ray_tracing === - - // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html - template - VULKAN_HPP_NODISCARD typename ResultValueType>::type - getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const; - - // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html - template - VULKAN_HPP_NODISCARD typename ResultValueType::type getRayTracingShaderGroupHandleNV( uint32_t firstGroup, uint32_t groupCount ) const; - - // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html - typename ResultValueType::type compileDeferredNV( uint32_t shader ) const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::Pipeline m_pipeline = {}; - const AllocationCallbacks * m_allocator = {}; - Result m_constructorSuccessCode = Result::eErrorUnknown; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - class Pipelines : public std::vector - { - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Pipelines( Device const & device, - Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) - { - *this = device.createComputePipelines( pipelineCache, createInfos, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Pipelines( Device const & device, - Optional const & deferredOperation, - Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) - { - *this = device.createDataGraphPipelinesARM( deferredOperation, pipelineCache, createInfos, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - Pipelines( Device const & device, - Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) - { - *this = device.createExecutionGraphPipelinesAMDX( pipelineCache, createInfos, allocator ); - } -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Pipelines( Device const & device, - Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) - { - *this = device.createGraphicsPipelines( pipelineCache, createInfos, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Pipelines( Device const & device, - Optional const & deferredOperation, - Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) - { - *this = device.createRayTracingPipelinesKHR( deferredOperation, pipelineCache, createInfos, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Pipelines( Device const & device, - Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator = nullptr ) - { - *this = device.createRayTracingPipelinesNV( pipelineCache, createInfos, allocator ); - } -# endif - - Pipelines( std::nullptr_t ) {} - - Pipelines() = delete; - Pipelines( Pipelines const & ) = delete; - Pipelines( Pipelines && rhs ) = default; - Pipelines & operator=( Pipelines const & ) = delete; - Pipelines & operator=( Pipelines && rhs ) = default; - - Pipelines( std::vector && rhs ) - { - std::swap( *this, rhs ); - } - }; - - // wrapper class for handle VkPipelineBinaryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryKHR.html - class PipelineBinaryKHR - { - public: - using CType = VkPipelineBinaryKHR; - using CppType = VULKAN_HPP_NAMESPACE::PipelineBinaryKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineBinaryKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: - PipelineBinaryKHR( Device const & device, - VkPipelineBinaryKHR pipelineBinary, - Optional allocator = nullptr, - Result successCode = Result::eSuccess ) - : m_device( device ) - , m_pipelineBinaryKHR( pipelineBinary ) - , m_allocator( static_cast( allocator ) ) - , m_constructorSuccessCode( successCode ) - , m_dispatcher( device.getDispatcher() ) - { - } - - PipelineBinaryKHR( std::nullptr_t ) {} - - ~PipelineBinaryKHR() - { - clear(); - } - - PipelineBinaryKHR() = delete; - PipelineBinaryKHR( PipelineBinaryKHR const & ) = delete; - - PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_pipelineBinaryKHR( exchange( rhs.m_pipelineBinaryKHR, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_constructorSuccessCode( exchange( rhs.m_constructorSuccessCode, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - PipelineBinaryKHR & operator=( PipelineBinaryKHR const & ) = delete; - - PipelineBinaryKHR & operator=( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_pipelineBinaryKHR, rhs.m_pipelineBinaryKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_pipelineBinaryKHR; - } - - VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_pipelineBinaryKHR ); - } - - operator VULKAN_HPP_NAMESPACE::PipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineBinaryKHR; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_pipelineBinaryKHR ) - { - getDispatcher()->vkDestroyPipelineBinaryKHR( static_cast( m_device ), - static_cast( m_pipelineBinaryKHR ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_pipelineBinaryKHR = nullptr; - m_allocator = nullptr; - m_constructorSuccessCode = Result::eErrorUnknown; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::PipelineBinaryKHR release() - { - m_device = nullptr; - m_allocator = nullptr; - m_constructorSuccessCode = Result::eErrorUnknown; - m_dispatcher = nullptr; - return exchange( m_pipelineBinaryKHR, nullptr ); - } - - Result getConstructorSuccessCode() const - { - return m_constructorSuccessCode; - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( PipelineBinaryKHR & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_pipelineBinaryKHR, rhs.m_pipelineBinaryKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::PipelineBinaryKHR m_pipelineBinaryKHR = {}; - const AllocationCallbacks * m_allocator = {}; - Result m_constructorSuccessCode = Result::eErrorUnknown; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - class PipelineBinaryKHRs : public std::vector - { - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - PipelineBinaryKHRs( Device const & device, PipelineBinaryCreateInfoKHR const & createInfo, Optional allocator = nullptr ) - { - *this = device.createPipelineBinariesKHR( createInfo, allocator ); - } -# endif - - PipelineBinaryKHRs( std::nullptr_t ) {} - - PipelineBinaryKHRs() = delete; - PipelineBinaryKHRs( PipelineBinaryKHRs const & ) = delete; - PipelineBinaryKHRs( PipelineBinaryKHRs && rhs ) = default; - PipelineBinaryKHRs & operator=( PipelineBinaryKHRs const & ) = delete; - PipelineBinaryKHRs & operator=( PipelineBinaryKHRs && rhs ) = default; - - PipelineBinaryKHRs( std::vector && rhs ) - { - std::swap( *this, rhs ); - } - }; - - // wrapper class for handle VkPipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayout.html - class PipelineLayout - { - public: - using CType = VkPipelineLayout; - using CppType = VULKAN_HPP_NAMESPACE::PipelineLayout; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePipelineLayout; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::ePipelineLayout; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - PipelineLayout( Device const & device, PipelineLayoutCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createPipelineLayout( createInfo, allocator ); - } -# endif - - PipelineLayout( Device const & device, VkPipelineLayout pipelineLayout, Optional allocator = nullptr ) - : m_device( device ) - , m_pipelineLayout( pipelineLayout ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - PipelineLayout( std::nullptr_t ) {} - - ~PipelineLayout() - { - clear(); - } - - PipelineLayout() = delete; - PipelineLayout( PipelineLayout const & ) = delete; - - PipelineLayout( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_pipelineLayout( exchange( rhs.m_pipelineLayout, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - PipelineLayout & operator=( PipelineLayout const & ) = delete; - - PipelineLayout & operator=( PipelineLayout && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_pipelineLayout, rhs.m_pipelineLayout ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::PipelineLayout const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_pipelineLayout; - } - - VULKAN_HPP_NAMESPACE::PipelineLayout const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_pipelineLayout ); - } - - operator VULKAN_HPP_NAMESPACE::PipelineLayout() const VULKAN_HPP_NOEXCEPT - { - return m_pipelineLayout; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_pipelineLayout ) - { - getDispatcher()->vkDestroyPipelineLayout( static_cast( m_device ), - static_cast( m_pipelineLayout ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_pipelineLayout = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::PipelineLayout release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_pipelineLayout, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( PipelineLayout & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_pipelineLayout, rhs.m_pipelineLayout ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::PipelineLayout m_pipelineLayout = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkPrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlot.html - class PrivateDataSlot - { - public: - using CType = VkPrivateDataSlot; - using CppType = VULKAN_HPP_NAMESPACE::PrivateDataSlot; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::ePrivateDataSlot; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - PrivateDataSlot( Device const & device, PrivateDataSlotCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createPrivateDataSlot( createInfo, allocator ); - } -# endif - - PrivateDataSlot( Device const & device, VkPrivateDataSlot privateDataSlot, Optional allocator = nullptr ) - : m_device( device ) - , m_privateDataSlot( privateDataSlot ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - PrivateDataSlot( std::nullptr_t ) {} - - ~PrivateDataSlot() - { - clear(); - } - - PrivateDataSlot() = delete; - PrivateDataSlot( PrivateDataSlot const & ) = delete; - - PrivateDataSlot( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_privateDataSlot( exchange( rhs.m_privateDataSlot, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - PrivateDataSlot & operator=( PrivateDataSlot const & ) = delete; - - PrivateDataSlot & operator=( PrivateDataSlot && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_privateDataSlot, rhs.m_privateDataSlot ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::PrivateDataSlot const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_privateDataSlot; - } - - VULKAN_HPP_NAMESPACE::PrivateDataSlot const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_privateDataSlot ); - } - - operator VULKAN_HPP_NAMESPACE::PrivateDataSlot() const VULKAN_HPP_NOEXCEPT - { - return m_privateDataSlot; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_privateDataSlot ) - { - getDispatcher()->vkDestroyPrivateDataSlot( static_cast( m_device ), - static_cast( m_privateDataSlot ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_privateDataSlot = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::PrivateDataSlot release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_privateDataSlot, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( PrivateDataSlot & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_privateDataSlot, rhs.m_privateDataSlot ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::PrivateDataSlot m_privateDataSlot = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPool.html - class QueryPool - { - public: - using CType = VkQueryPool; - using CppType = VULKAN_HPP_NAMESPACE::QueryPool; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueryPool; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueryPool; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - QueryPool( Device const & device, QueryPoolCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createQueryPool( createInfo, allocator ); - } -# endif - - QueryPool( Device const & device, VkQueryPool queryPool, Optional allocator = nullptr ) - : m_device( device ) - , m_queryPool( queryPool ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - QueryPool( std::nullptr_t ) {} - - ~QueryPool() - { - clear(); - } - - QueryPool() = delete; - QueryPool( QueryPool const & ) = delete; - - QueryPool( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_queryPool( exchange( rhs.m_queryPool, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - QueryPool & operator=( QueryPool const & ) = delete; - - QueryPool & operator=( QueryPool && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_queryPool, rhs.m_queryPool ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::QueryPool const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_queryPool; - } - - VULKAN_HPP_NAMESPACE::QueryPool const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_queryPool ); - } - - operator VULKAN_HPP_NAMESPACE::QueryPool() const VULKAN_HPP_NOEXCEPT - { - return m_queryPool; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_queryPool ) - { - getDispatcher()->vkDestroyQueryPool( - static_cast( m_device ), static_cast( m_queryPool ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_queryPool = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::QueryPool release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_queryPool, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( QueryPool & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_queryPool, rhs.m_queryPool ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html - template - VULKAN_HPP_NODISCARD ResultValue> getResults( - uint32_t firstQuery, uint32_t queryCount, size_t dataSize, DeviceSize stride, QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html - template - VULKAN_HPP_NODISCARD ResultValue - getResult( uint32_t firstQuery, uint32_t queryCount, DeviceSize stride, QueryResultFlags flags VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - //=== VK_VERSION_1_2 === - - // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html - void reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_EXT_host_query_reset === - - // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html - void resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::QueryPool m_queryPool = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueue.html - class Queue - { - public: - using CType = VkQueue; - using CppType = VULKAN_HPP_NAMESPACE::Queue; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eQueue; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eQueue; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Queue( Device const & device, uint32_t queueFamilyIndex, uint32_t queueIndex ) - { - *this = device.getQueue( queueFamilyIndex, queueIndex ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Queue( Device const & device, DeviceQueueInfo2 const & queueInfo ) - { - *this = device.getQueue2( queueInfo ); - } -# endif - - Queue( Device const & device, VkQueue queue ) : m_queue( queue ), m_dispatcher( device.getDispatcher() ) {} - - Queue( std::nullptr_t ) {} - - ~Queue() - { - clear(); - } - - Queue() = delete; - - Queue( Queue const & rhs ) : m_queue( rhs.m_queue ), m_dispatcher( rhs.m_dispatcher ) {} - - Queue( Queue && rhs ) VULKAN_HPP_NOEXCEPT - : m_queue( exchange( rhs.m_queue, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - Queue & operator=( Queue const & rhs ) - { - m_queue = rhs.m_queue; - m_dispatcher = rhs.m_dispatcher; - return *this; - } - - Queue & operator=( Queue && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_queue, rhs.m_queue ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::Queue const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_queue; - } - - VULKAN_HPP_NAMESPACE::Queue const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_queue ); - } - - operator VULKAN_HPP_NAMESPACE::Queue() const VULKAN_HPP_NOEXCEPT - { - return m_queue; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - m_queue = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::Queue release() - { - m_dispatcher = nullptr; - return exchange( m_queue, nullptr ); - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( Queue & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_queue, rhs.m_queue ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html - typename ResultValueType::type submit( ArrayProxy const & submits, - VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html - typename ResultValueType::type waitIdle() const; - - // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html - typename ResultValueType::type bindSparse( ArrayProxy const & bindInfo, - VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - //=== VK_VERSION_1_3 === - - // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html - typename ResultValueType::type submit2( ArrayProxy const & submits, - VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - //=== VK_KHR_swapchain === - - // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html - VULKAN_HPP_NODISCARD Result presentKHR( const PresentInfoKHR & presentInfo ) const; - - //=== VK_EXT_debug_utils === - - // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html - void beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html - void endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html - void insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_NV_device_diagnostic_checkpoints === - - // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html - VULKAN_HPP_NODISCARD std::vector getCheckpointDataNV() const; - - // wrapper function for command vkGetQueueCheckpointData2NV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html - VULKAN_HPP_NODISCARD std::vector getCheckpointData2NV() const; - - //=== VK_INTEL_performance_query === - - // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html - typename ResultValueType::type setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const; - - //=== VK_KHR_synchronization2 === - - // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html - typename ResultValueType::type submit2KHR( ArrayProxy const & submits, - VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - //=== VK_NV_low_latency2 === - - // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html - void notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo ) const VULKAN_HPP_NOEXCEPT; - - private: - VULKAN_HPP_NAMESPACE::Queue m_queue = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPass.html - class RenderPass - { - public: - using CType = VkRenderPass; - using CppType = VULKAN_HPP_NAMESPACE::RenderPass; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eRenderPass; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eRenderPass; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - RenderPass( Device const & device, RenderPassCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createRenderPass( createInfo, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - RenderPass( Device const & device, RenderPassCreateInfo2 const & createInfo, Optional allocator = nullptr ) - { - *this = device.createRenderPass2( createInfo, allocator ); - } -# endif - - RenderPass( Device const & device, VkRenderPass renderPass, Optional allocator = nullptr ) - : m_device( device ) - , m_renderPass( renderPass ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - RenderPass( std::nullptr_t ) {} - - ~RenderPass() - { - clear(); - } - - RenderPass() = delete; - RenderPass( RenderPass const & ) = delete; - - RenderPass( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_renderPass( exchange( rhs.m_renderPass, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - RenderPass & operator=( RenderPass const & ) = delete; - - RenderPass & operator=( RenderPass && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_renderPass, rhs.m_renderPass ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::RenderPass const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_renderPass; - } - - VULKAN_HPP_NAMESPACE::RenderPass const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_renderPass ); - } - - operator VULKAN_HPP_NAMESPACE::RenderPass() const VULKAN_HPP_NOEXCEPT - { - return m_renderPass; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_renderPass ) - { - getDispatcher()->vkDestroyRenderPass( - static_cast( m_device ), static_cast( m_renderPass ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_renderPass = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::RenderPass release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_renderPass, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( RenderPass & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_renderPass, rhs.m_renderPass ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html - VULKAN_HPP_NODISCARD Extent2D getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT; - - //=== VK_HUAWEI_subpass_shading === - - // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getSubpassShadingMaxWorkgroupSizeHUAWEI() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::RenderPass m_renderPass = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampler.html - class Sampler - { - public: - using CType = VkSampler; - using CppType = VULKAN_HPP_NAMESPACE::Sampler; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSampler; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSampler; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Sampler( Device const & device, SamplerCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createSampler( createInfo, allocator ); - } -# endif - - Sampler( Device const & device, VkSampler sampler, Optional allocator = nullptr ) - : m_device( device ), m_sampler( sampler ), m_allocator( static_cast( allocator ) ), m_dispatcher( device.getDispatcher() ) - { - } - - Sampler( std::nullptr_t ) {} - - ~Sampler() - { - clear(); - } - - Sampler() = delete; - Sampler( Sampler const & ) = delete; - - Sampler( Sampler && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_sampler( exchange( rhs.m_sampler, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - Sampler & operator=( Sampler const & ) = delete; - - Sampler & operator=( Sampler && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_sampler, rhs.m_sampler ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::Sampler const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_sampler; - } - - VULKAN_HPP_NAMESPACE::Sampler const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_sampler ); - } - - operator VULKAN_HPP_NAMESPACE::Sampler() const VULKAN_HPP_NOEXCEPT - { - return m_sampler; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_sampler ) - { - getDispatcher()->vkDestroySampler( - static_cast( m_device ), static_cast( m_sampler ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_sampler = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::Sampler release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_sampler, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( Sampler & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_sampler, rhs.m_sampler ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::Sampler m_sampler = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkSamplerYcbcrConversion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversion.html - class SamplerYcbcrConversion - { - public: - using CType = VkSamplerYcbcrConversion; - using CppType = VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSamplerYcbcrConversion; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSamplerYcbcrConversion; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - SamplerYcbcrConversion( Device const & device, - SamplerYcbcrConversionCreateInfo const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createSamplerYcbcrConversion( createInfo, allocator ); - } -# endif - - SamplerYcbcrConversion( Device const & device, VkSamplerYcbcrConversion ycbcrConversion, Optional allocator = nullptr ) - : m_device( device ) - , m_samplerYcbcrConversion( ycbcrConversion ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - SamplerYcbcrConversion( std::nullptr_t ) {} - - ~SamplerYcbcrConversion() - { - clear(); - } - - SamplerYcbcrConversion() = delete; - SamplerYcbcrConversion( SamplerYcbcrConversion const & ) = delete; - - SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_samplerYcbcrConversion( exchange( rhs.m_samplerYcbcrConversion, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - SamplerYcbcrConversion & operator=( SamplerYcbcrConversion const & ) = delete; - - SamplerYcbcrConversion & operator=( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_samplerYcbcrConversion, rhs.m_samplerYcbcrConversion ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_samplerYcbcrConversion; - } - - VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_samplerYcbcrConversion ); - } - - operator VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT - { - return m_samplerYcbcrConversion; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_samplerYcbcrConversion ) - { - getDispatcher()->vkDestroySamplerYcbcrConversion( static_cast( m_device ), - static_cast( m_samplerYcbcrConversion ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_samplerYcbcrConversion = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_samplerYcbcrConversion, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( SamplerYcbcrConversion & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_samplerYcbcrConversion, rhs.m_samplerYcbcrConversion ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_samplerYcbcrConversion = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphore.html - class Semaphore - { - public: - using CType = VkSemaphore; - using CppType = VULKAN_HPP_NAMESPACE::Semaphore; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSemaphore; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSemaphore; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - Semaphore( Device const & device, SemaphoreCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createSemaphore( createInfo, allocator ); - } -# endif - - Semaphore( Device const & device, VkSemaphore semaphore, Optional allocator = nullptr ) - : m_device( device ) - , m_semaphore( semaphore ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - Semaphore( std::nullptr_t ) {} - - ~Semaphore() - { - clear(); - } - - Semaphore() = delete; - Semaphore( Semaphore const & ) = delete; - - Semaphore( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_semaphore( exchange( rhs.m_semaphore, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - Semaphore & operator=( Semaphore const & ) = delete; - - Semaphore & operator=( Semaphore && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_semaphore, rhs.m_semaphore ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::Semaphore const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_semaphore; - } - - VULKAN_HPP_NAMESPACE::Semaphore const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_semaphore ); - } - - operator VULKAN_HPP_NAMESPACE::Semaphore() const VULKAN_HPP_NOEXCEPT - { - return m_semaphore; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_semaphore ) - { - getDispatcher()->vkDestroySemaphore( - static_cast( m_device ), static_cast( m_semaphore ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_semaphore = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::Semaphore release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_semaphore, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( Semaphore & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_semaphore, rhs.m_semaphore ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_VERSION_1_2 === - - // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getCounterValue() const; - - //=== VK_KHR_timeline_semaphore === - - // wrapper function for command vkGetSemaphoreCounterValueKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getCounterValueKHR() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::Semaphore m_semaphore = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkShaderEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderEXT.html - class ShaderEXT - { - public: - using CType = VkShaderEXT; - using CppType = VULKAN_HPP_NAMESPACE::ShaderEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - ShaderEXT( Device const & device, ShaderCreateInfoEXT const & createInfo, Optional allocator = nullptr ) - { - *this = device.createShaderEXT( createInfo, allocator ); - } -# endif - - ShaderEXT( Device const & device, VkShaderEXT shader, Optional allocator = nullptr, Result successCode = Result::eSuccess ) - : m_device( device ) - , m_shaderEXT( shader ) - , m_allocator( static_cast( allocator ) ) - , m_constructorSuccessCode( successCode ) - , m_dispatcher( device.getDispatcher() ) - { - } - - ShaderEXT( std::nullptr_t ) {} - - ~ShaderEXT() - { - clear(); - } - - ShaderEXT() = delete; - ShaderEXT( ShaderEXT const & ) = delete; - - ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_shaderEXT( exchange( rhs.m_shaderEXT, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_constructorSuccessCode( exchange( rhs.m_constructorSuccessCode, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - ShaderEXT & operator=( ShaderEXT const & ) = delete; - - ShaderEXT & operator=( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_shaderEXT, rhs.m_shaderEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::ShaderEXT const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_shaderEXT; - } - - VULKAN_HPP_NAMESPACE::ShaderEXT const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_shaderEXT ); - } - - operator VULKAN_HPP_NAMESPACE::ShaderEXT() const VULKAN_HPP_NOEXCEPT - { - return m_shaderEXT; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_shaderEXT ) - { - getDispatcher()->vkDestroyShaderEXT( - static_cast( m_device ), static_cast( m_shaderEXT ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_shaderEXT = nullptr; - m_allocator = nullptr; - m_constructorSuccessCode = Result::eErrorUnknown; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::ShaderEXT release() - { - m_device = nullptr; - m_allocator = nullptr; - m_constructorSuccessCode = Result::eErrorUnknown; - m_dispatcher = nullptr; - return exchange( m_shaderEXT, nullptr ); - } - - Result getConstructorSuccessCode() const - { - return m_constructorSuccessCode; - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( ShaderEXT & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_shaderEXT, rhs.m_shaderEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_EXT_shader_object === - - // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getBinaryData() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::ShaderEXT m_shaderEXT = {}; - const AllocationCallbacks * m_allocator = {}; - Result m_constructorSuccessCode = Result::eErrorUnknown; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - class ShaderEXTs : public std::vector - { - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - ShaderEXTs( Device const & device, ArrayProxy const & createInfos, Optional allocator = nullptr ) - { - *this = device.createShadersEXT( createInfos, allocator ); - } -# endif - - ShaderEXTs( std::nullptr_t ) {} - - ShaderEXTs() = delete; - ShaderEXTs( ShaderEXTs const & ) = delete; - ShaderEXTs( ShaderEXTs && rhs ) = default; - ShaderEXTs & operator=( ShaderEXTs const & ) = delete; - ShaderEXTs & operator=( ShaderEXTs && rhs ) = default; - - ShaderEXTs( std::vector && rhs ) - { - std::swap( *this, rhs ); - } - }; - - // wrapper class for handle VkShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModule.html - class ShaderModule - { - public: - using CType = VkShaderModule; - using CppType = VULKAN_HPP_NAMESPACE::ShaderModule; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eShaderModule; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eShaderModule; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - ShaderModule( Device const & device, ShaderModuleCreateInfo const & createInfo, Optional allocator = nullptr ) - { - *this = device.createShaderModule( createInfo, allocator ); - } -# endif - - ShaderModule( Device const & device, VkShaderModule shaderModule, Optional allocator = nullptr ) - : m_device( device ) - , m_shaderModule( shaderModule ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - ShaderModule( std::nullptr_t ) {} - - ~ShaderModule() - { - clear(); - } - - ShaderModule() = delete; - ShaderModule( ShaderModule const & ) = delete; - - ShaderModule( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_shaderModule( exchange( rhs.m_shaderModule, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - ShaderModule & operator=( ShaderModule const & ) = delete; - - ShaderModule & operator=( ShaderModule && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_shaderModule, rhs.m_shaderModule ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::ShaderModule const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_shaderModule; - } - - VULKAN_HPP_NAMESPACE::ShaderModule const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_shaderModule ); - } - - operator VULKAN_HPP_NAMESPACE::ShaderModule() const VULKAN_HPP_NOEXCEPT - { - return m_shaderModule; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_shaderModule ) - { - getDispatcher()->vkDestroyShaderModule( - static_cast( m_device ), static_cast( m_shaderModule ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_shaderModule = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::ShaderModule release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_shaderModule, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( ShaderModule & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_shaderModule, rhs.m_shaderModule ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_EXT_shader_module_identifier === - - // wrapper function for command vkGetShaderModuleIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html - VULKAN_HPP_NODISCARD ShaderModuleIdentifierEXT getIdentifierEXT() const VULKAN_HPP_NOEXCEPT; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::ShaderModule m_shaderModule = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceKHR.html - class SurfaceKHR - { - public: - using CType = VkSurfaceKHR; - using CppType = VULKAN_HPP_NAMESPACE::SurfaceKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSurfaceKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSurfaceKHR; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - SurfaceKHR( Instance const & instance, AndroidSurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createAndroidSurfaceKHR( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - SurfaceKHR( Instance const & instance, DirectFBSurfaceCreateInfoEXT const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createDirectFBSurfaceEXT( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - SurfaceKHR( Instance const & instance, DisplaySurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createDisplayPlaneSurfaceKHR( createInfo, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - SurfaceKHR( Instance const & instance, HeadlessSurfaceCreateInfoEXT const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createHeadlessSurfaceEXT( createInfo, allocator ); - } -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_IOS_MVK ) - SurfaceKHR( Instance const & instance, IOSSurfaceCreateInfoMVK const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createIOSSurfaceMVK( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_IOS_MVK*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_FUCHSIA ) - SurfaceKHR( Instance const & instance, ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createImagePipeSurfaceFUCHSIA( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_FUCHSIA*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_MACOS_MVK ) - SurfaceKHR( Instance const & instance, MacOSSurfaceCreateInfoMVK const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createMacOSSurfaceMVK( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_MACOS_MVK*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_METAL_EXT ) - SurfaceKHR( Instance const & instance, MetalSurfaceCreateInfoEXT const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createMetalSurfaceEXT( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_METAL_EXT*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - SurfaceKHR( Instance const & instance, ScreenSurfaceCreateInfoQNX const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createScreenSurfaceQNX( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_GGP ) - SurfaceKHR( Instance const & instance, StreamDescriptorSurfaceCreateInfoGGP const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createStreamDescriptorSurfaceGGP( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_GGP*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_OHOS ) - SurfaceKHR( Instance const & instance, SurfaceCreateInfoOHOS const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createSurfaceOHOS( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_OHOS*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_VI_NN ) - SurfaceKHR( Instance const & instance, ViSurfaceCreateInfoNN const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createViSurfaceNN( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_VI_NN*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - SurfaceKHR( Instance const & instance, WaylandSurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createWaylandSurfaceKHR( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - SurfaceKHR( Instance const & instance, Win32SurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createWin32SurfaceKHR( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_XCB_KHR ) - SurfaceKHR( Instance const & instance, XcbSurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createXcbSurfaceKHR( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_XCB_KHR*/ -# endif - -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) -# if defined( VK_USE_PLATFORM_XLIB_KHR ) - SurfaceKHR( Instance const & instance, XlibSurfaceCreateInfoKHR const & createInfo, Optional allocator = nullptr ) - { - *this = instance.createXlibSurfaceKHR( createInfo, allocator ); - } -# endif /*VK_USE_PLATFORM_XLIB_KHR*/ -# endif - - SurfaceKHR( Instance const & instance, VkSurfaceKHR surface, Optional allocator = nullptr ) - : m_instance( instance ) - , m_surfaceKHR( surface ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( instance.getDispatcher() ) - { - } - - SurfaceKHR( std::nullptr_t ) {} - - ~SurfaceKHR() - { - clear(); - } - - SurfaceKHR() = delete; - SurfaceKHR( SurfaceKHR const & ) = delete; - - SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_instance( exchange( rhs.m_instance, {} ) ) - , m_surfaceKHR( exchange( rhs.m_surfaceKHR, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - SurfaceKHR & operator=( SurfaceKHR const & ) = delete; - - SurfaceKHR & operator=( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_instance, rhs.m_instance ); - std::swap( m_surfaceKHR, rhs.m_surfaceKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::SurfaceKHR const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_surfaceKHR; - } - - VULKAN_HPP_NAMESPACE::SurfaceKHR const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_surfaceKHR ); - } - - operator VULKAN_HPP_NAMESPACE::SurfaceKHR() const VULKAN_HPP_NOEXCEPT - { - return m_surfaceKHR; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_surfaceKHR ) - { - getDispatcher()->vkDestroySurfaceKHR( - static_cast( m_instance ), static_cast( m_surfaceKHR ), reinterpret_cast( m_allocator ) ); - } - m_instance = nullptr; - m_surfaceKHR = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::SurfaceKHR release() - { - m_instance = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_surfaceKHR, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Instance getInstance() const - { - return m_instance; - } - - detail::InstanceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( SurfaceKHR & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_instance, rhs.m_instance ); - std::swap( m_surfaceKHR, rhs.m_surfaceKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Instance m_instance = {}; - VULKAN_HPP_NAMESPACE::SurfaceKHR m_surfaceKHR = {}; - const AllocationCallbacks * m_allocator = {}; - detail::InstanceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainKHR.html - class SwapchainKHR - { - public: - using CType = VkSwapchainKHR; - using CppType = VULKAN_HPP_NAMESPACE::SwapchainKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eSwapchainKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eSwapchainKHR; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - SwapchainKHR( Device const & device, SwapchainCreateInfoKHR const & createInfo, Optional allocator = nullptr ) - { - *this = device.createSwapchainKHR( createInfo, allocator ); - } -# endif - - SwapchainKHR( Device const & device, VkSwapchainKHR swapchain, Optional allocator = nullptr ) - : m_device( device ) - , m_swapchainKHR( swapchain ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - SwapchainKHR( std::nullptr_t ) {} - - ~SwapchainKHR() - { - clear(); - } - - SwapchainKHR() = delete; - SwapchainKHR( SwapchainKHR const & ) = delete; - - SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_swapchainKHR( exchange( rhs.m_swapchainKHR, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - SwapchainKHR & operator=( SwapchainKHR const & ) = delete; - - SwapchainKHR & operator=( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_swapchainKHR, rhs.m_swapchainKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::SwapchainKHR const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_swapchainKHR; - } - - VULKAN_HPP_NAMESPACE::SwapchainKHR const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_swapchainKHR ); - } - - operator VULKAN_HPP_NAMESPACE::SwapchainKHR() const VULKAN_HPP_NOEXCEPT - { - return m_swapchainKHR; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_swapchainKHR ) - { - getDispatcher()->vkDestroySwapchainKHR( - static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_swapchainKHR = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::SwapchainKHR release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_swapchainKHR, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( SwapchainKHR & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_swapchainKHR, rhs.m_swapchainKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_KHR_swapchain === - - // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getImages() const; - - // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html - VULKAN_HPP_NODISCARD ResultValue acquireNextImage( uint64_t timeout, - VULKAN_HPP_NAMESPACE::Semaphore semaphore VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ), - VULKAN_HPP_NAMESPACE::Fence fence VULKAN_HPP_DEFAULT_ASSIGNMENT( {} ) ) const; - - //=== VK_EXT_display_control === - - // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html - VULKAN_HPP_NODISCARD -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - ResultValue -# else - typename ResultValueType::type -# endif - getCounterEXT( SurfaceCounterFlagBitsEXT counter ) const; - - //=== VK_GOOGLE_display_timing === - - // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html - VULKAN_HPP_NODISCARD typename ResultValueType::type getRefreshCycleDurationGOOGLE() const; - - // wrapper function for command vkGetPastPresentationTimingGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html - VULKAN_HPP_NODISCARD -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - ResultValue> -# else - typename ResultValueType>::type -# endif - getPastPresentationTimingGOOGLE() const; - - //=== VK_KHR_shared_presentable_image === - - // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html - VULKAN_HPP_NODISCARD Result getStatus() const; - - //=== VK_EXT_present_timing === - - // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html - VULKAN_HPP_NODISCARD Result setPresentTimingQueueSizeEXT( uint32_t size ) const; - - // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html - VULKAN_HPP_NODISCARD ResultValue> getTimingPropertiesEXT() const; - - // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html - VULKAN_HPP_NODISCARD Result getTimeDomainPropertiesEXT( SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, - uint64_t * pTimeDomainsCounter ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_AMD_display_native_hdr === - - // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html - void setLocalDimmingAMD( Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT; - - //=== VK_KHR_present_wait === - - // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html - VULKAN_HPP_NODISCARD Result waitForPresent( uint64_t presentId, uint64_t timeout ) const; - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - - // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html - typename ResultValueType::type acquireFullScreenExclusiveModeEXT() const; - - // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html - typename ResultValueType::type releaseFullScreenExclusiveModeEXT() const; -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_present_wait2 === - - // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html - VULKAN_HPP_NODISCARD Result waitForPresent2( const PresentWait2InfoKHR & presentWait2Info ) const; - - //=== VK_NV_low_latency2 === - - // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html - typename ResultValueType::type setLatencySleepModeNV( const LatencySleepModeInfoNV & sleepModeInfo ) const; - - // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html - typename ResultValueType::type latencySleepNV( const LatencySleepInfoNV & sleepInfo ) const; - - // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html - void setLatencyMarkerNV( const SetLatencyMarkerInfoNV & latencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT; - - // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html - VULKAN_HPP_NODISCARD std::vector getLatencyTimingsNV() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchainKHR = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - class SwapchainKHRs : public std::vector - { - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - SwapchainKHRs( Device const & device, ArrayProxy const & createInfos, Optional allocator = nullptr ) - { - *this = device.createSharedSwapchainsKHR( createInfos, allocator ); - } -# endif - - SwapchainKHRs( std::nullptr_t ) {} - - SwapchainKHRs() = delete; - SwapchainKHRs( SwapchainKHRs const & ) = delete; - SwapchainKHRs( SwapchainKHRs && rhs ) = default; - SwapchainKHRs & operator=( SwapchainKHRs const & ) = delete; - SwapchainKHRs & operator=( SwapchainKHRs && rhs ) = default; - - SwapchainKHRs( std::vector && rhs ) - { - std::swap( *this, rhs ); - } - }; - - // wrapper class for handle VkTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorARM.html - class TensorARM - { - public: - using CType = VkTensorARM; - using CppType = VULKAN_HPP_NAMESPACE::TensorARM; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorARM; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - TensorARM( Device const & device, TensorCreateInfoARM const & createInfo, Optional allocator = nullptr ) - { - *this = device.createTensorARM( createInfo, allocator ); - } -# endif - - TensorARM( Device const & device, VkTensorARM tensor, Optional allocator = nullptr ) - : m_device( device ) - , m_tensorARM( tensor ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - TensorARM( std::nullptr_t ) {} - - ~TensorARM() - { - clear(); - } - - TensorARM() = delete; - TensorARM( TensorARM const & ) = delete; - - TensorARM( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_tensorARM( exchange( rhs.m_tensorARM, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - TensorARM & operator=( TensorARM const & ) = delete; - - TensorARM & operator=( TensorARM && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_tensorARM, rhs.m_tensorARM ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::TensorARM const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_tensorARM; - } - - VULKAN_HPP_NAMESPACE::TensorARM const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_tensorARM ); - } - - operator VULKAN_HPP_NAMESPACE::TensorARM() const VULKAN_HPP_NOEXCEPT - { - return m_tensorARM; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_tensorARM ) - { - getDispatcher()->vkDestroyTensorARM( - static_cast( m_device ), static_cast( m_tensorARM ), reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_tensorARM = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::TensorARM release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_tensorARM, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( TensorARM & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_tensorARM, rhs.m_tensorARM ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::TensorARM m_tensorARM = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewARM.html - class TensorViewARM - { - public: - using CType = VkTensorViewARM; - using CppType = VULKAN_HPP_NAMESPACE::TensorViewARM; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eTensorViewARM; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - TensorViewARM( Device const & device, TensorViewCreateInfoARM const & createInfo, Optional allocator = nullptr ) - { - *this = device.createTensorViewARM( createInfo, allocator ); - } -# endif - - TensorViewARM( Device const & device, VkTensorViewARM tensorView, Optional allocator = nullptr ) - : m_device( device ) - , m_tensorViewARM( tensorView ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - TensorViewARM( std::nullptr_t ) {} - - ~TensorViewARM() - { - clear(); - } - - TensorViewARM() = delete; - TensorViewARM( TensorViewARM const & ) = delete; - - TensorViewARM( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_tensorViewARM( exchange( rhs.m_tensorViewARM, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - TensorViewARM & operator=( TensorViewARM const & ) = delete; - - TensorViewARM & operator=( TensorViewARM && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_tensorViewARM, rhs.m_tensorViewARM ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::TensorViewARM const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_tensorViewARM; - } - - VULKAN_HPP_NAMESPACE::TensorViewARM const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_tensorViewARM ); - } - - operator VULKAN_HPP_NAMESPACE::TensorViewARM() const VULKAN_HPP_NOEXCEPT - { - return m_tensorViewARM; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_tensorViewARM ) - { - getDispatcher()->vkDestroyTensorViewARM( static_cast( m_device ), - static_cast( m_tensorViewARM ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_tensorViewARM = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::TensorViewARM release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_tensorViewARM, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( TensorViewARM & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_tensorViewARM, rhs.m_tensorViewARM ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::TensorViewARM m_tensorViewARM = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheEXT.html - class ValidationCacheEXT - { - public: - using CType = VkValidationCacheEXT; - using CppType = VULKAN_HPP_NAMESPACE::ValidationCacheEXT; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eValidationCacheEXT; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eValidationCacheEXT; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - ValidationCacheEXT( Device const & device, ValidationCacheCreateInfoEXT const & createInfo, Optional allocator = nullptr ) - { - *this = device.createValidationCacheEXT( createInfo, allocator ); - } -# endif - - ValidationCacheEXT( Device const & device, VkValidationCacheEXT validationCache, Optional allocator = nullptr ) - : m_device( device ) - , m_validationCacheEXT( validationCache ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - ValidationCacheEXT( std::nullptr_t ) {} - - ~ValidationCacheEXT() - { - clear(); - } - - ValidationCacheEXT() = delete; - ValidationCacheEXT( ValidationCacheEXT const & ) = delete; - - ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_validationCacheEXT( exchange( rhs.m_validationCacheEXT, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - ValidationCacheEXT & operator=( ValidationCacheEXT const & ) = delete; - - ValidationCacheEXT & operator=( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_validationCacheEXT, rhs.m_validationCacheEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_validationCacheEXT; - } - - VULKAN_HPP_NAMESPACE::ValidationCacheEXT const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_validationCacheEXT ); - } - - operator VULKAN_HPP_NAMESPACE::ValidationCacheEXT() const VULKAN_HPP_NOEXCEPT - { - return m_validationCacheEXT; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_validationCacheEXT ) - { - getDispatcher()->vkDestroyValidationCacheEXT( static_cast( m_device ), - static_cast( m_validationCacheEXT ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_validationCacheEXT = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::ValidationCacheEXT release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_validationCacheEXT, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( ValidationCacheEXT & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_validationCacheEXT, rhs.m_validationCacheEXT ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_EXT_validation_cache === - - // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html - typename ResultValueType::type merge( ArrayProxy const & srcCaches ) const; - - // wrapper function for command vkGetValidationCacheDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getData() const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCacheEXT = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionKHR.html - class VideoSessionKHR - { - public: - using CType = VkVideoSessionKHR; - using CppType = VULKAN_HPP_NAMESPACE::VideoSessionKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - VideoSessionKHR( Device const & device, VideoSessionCreateInfoKHR const & createInfo, Optional allocator = nullptr ) - { - *this = device.createVideoSessionKHR( createInfo, allocator ); - } -# endif - - VideoSessionKHR( Device const & device, VkVideoSessionKHR videoSession, Optional allocator = nullptr ) - : m_device( device ) - , m_videoSessionKHR( videoSession ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - VideoSessionKHR( std::nullptr_t ) {} - - ~VideoSessionKHR() - { - clear(); - } - - VideoSessionKHR() = delete; - VideoSessionKHR( VideoSessionKHR const & ) = delete; - - VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_videoSessionKHR( exchange( rhs.m_videoSessionKHR, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - VideoSessionKHR & operator=( VideoSessionKHR const & ) = delete; - - VideoSessionKHR & operator=( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_videoSessionKHR, rhs.m_videoSessionKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::VideoSessionKHR const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_videoSessionKHR; - } - - VULKAN_HPP_NAMESPACE::VideoSessionKHR const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_videoSessionKHR ); - } - - operator VULKAN_HPP_NAMESPACE::VideoSessionKHR() const VULKAN_HPP_NOEXCEPT - { - return m_videoSessionKHR; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_videoSessionKHR ) - { - getDispatcher()->vkDestroyVideoSessionKHR( static_cast( m_device ), - static_cast( m_videoSessionKHR ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_videoSessionKHR = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::VideoSessionKHR release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_videoSessionKHR, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( VideoSessionKHR & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_videoSessionKHR, rhs.m_videoSessionKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_KHR_video_queue === - - // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html - VULKAN_HPP_NODISCARD typename ResultValueType>::type getMemoryRequirements() const; - - // wrapper function for command vkBindVideoSessionMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html - typename ResultValueType::type bindMemory( ArrayProxy const & bindSessionMemoryInfos ) const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSessionKHR = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // wrapper class for handle VkVideoSessionParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersKHR.html - class VideoSessionParametersKHR - { - public: - using CType = VkVideoSessionParametersKHR; - using CppType = VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR; - - static VULKAN_HPP_CONST_OR_CONSTEXPR ObjectType objectType = ObjectType::eVideoSessionParametersKHR; - static VULKAN_HPP_CONST_OR_CONSTEXPR DebugReportObjectTypeEXT debugReportObjectType = DebugReportObjectTypeEXT::eUnknown; - - public: -# if !defined( VULKAN_HPP_NO_EXCEPTIONS ) - VideoSessionParametersKHR( Device const & device, - VideoSessionParametersCreateInfoKHR const & createInfo, - Optional allocator = nullptr ) - { - *this = device.createVideoSessionParametersKHR( createInfo, allocator ); - } -# endif - - VideoSessionParametersKHR( Device const & device, - VkVideoSessionParametersKHR videoSessionParameters, - Optional allocator = nullptr ) - : m_device( device ) - , m_videoSessionParametersKHR( videoSessionParameters ) - , m_allocator( static_cast( allocator ) ) - , m_dispatcher( device.getDispatcher() ) - { - } - - VideoSessionParametersKHR( std::nullptr_t ) {} - - ~VideoSessionParametersKHR() - { - clear(); - } - - VideoSessionParametersKHR() = delete; - VideoSessionParametersKHR( VideoSessionParametersKHR const & ) = delete; - - VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT - : m_device( exchange( rhs.m_device, {} ) ) - , m_videoSessionParametersKHR( exchange( rhs.m_videoSessionParametersKHR, {} ) ) - , m_allocator( exchange( rhs.m_allocator, {} ) ) - , m_dispatcher( exchange( rhs.m_dispatcher, nullptr ) ) - { - } - - VideoSessionParametersKHR & operator=( VideoSessionParametersKHR const & ) = delete; - - VideoSessionParametersKHR & operator=( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT - { - if ( this != &rhs ) - { - std::swap( m_device, rhs.m_device ); - std::swap( m_videoSessionParametersKHR, rhs.m_videoSessionParametersKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - return *this; - } - - VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & operator*() const & VULKAN_HPP_NOEXCEPT - { - return m_videoSessionParametersKHR; - } - - VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const && operator*() const && VULKAN_HPP_NOEXCEPT - { - return std::move( m_videoSessionParametersKHR ); - } - - operator VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT - { - return m_videoSessionParametersKHR; - } - - void clear() VULKAN_HPP_NOEXCEPT - { - if ( m_videoSessionParametersKHR ) - { - getDispatcher()->vkDestroyVideoSessionParametersKHR( static_cast( m_device ), - static_cast( m_videoSessionParametersKHR ), - reinterpret_cast( m_allocator ) ); - } - m_device = nullptr; - m_videoSessionParametersKHR = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - } - - VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR release() - { - m_device = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; - return exchange( m_videoSessionParametersKHR, nullptr ); - } - - VULKAN_HPP_NAMESPACE::Device getDevice() const - { - return m_device; - } - - detail::DeviceDispatcher const * getDispatcher() const - { - VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); - return m_dispatcher; - } - - void swap( VideoSessionParametersKHR & rhs ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_device, rhs.m_device ); - std::swap( m_videoSessionParametersKHR, rhs.m_videoSessionParametersKHR ); - std::swap( m_allocator, rhs.m_allocator ); - std::swap( m_dispatcher, rhs.m_dispatcher ); - } - - //=== VK_KHR_video_queue === - - // wrapper function for command vkUpdateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html - typename ResultValueType::type update( const VideoSessionParametersUpdateInfoKHR & updateInfo ) const; - - private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParametersKHR = {}; - const AllocationCallbacks * m_allocator = {}; - detail::DeviceDispatcher const * m_dispatcher = nullptr; - }; - - template <> - struct isVulkanRAIIHandleType - { - static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; - }; - - // operators to compare VULKAN_HPP_NAMESPACE::raii-handles -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - template ::value, bool>::type = 0> - auto operator<=>( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT - { - return *a <=> *b; - } -# else - template ::value, bool>::type = 0> - bool operator<( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT - { - return *a < *b; - } -# endif - - template ::value, bool>::type = 0> - bool operator==( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT - { - return *a == *b; - } - - template ::value, bool>::type = 0> - bool operator!=( T const & a, T const & b ) VULKAN_HPP_NOEXCEPT - { - return *a != *b; - } - - template ::value, bool>::type = 0> - bool operator==( const T & v, std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - return !*v; - } - - template ::value, bool>::type = 0> - bool operator==( std::nullptr_t, const T & v ) VULKAN_HPP_NOEXCEPT - { - return !*v; - } - - template ::value, bool>::type = 0> - bool operator!=( const T & v, std::nullptr_t ) VULKAN_HPP_NOEXCEPT - { - return *v; - } - - template ::value, bool>::type = 0> - bool operator!=( std::nullptr_t, const T & v ) VULKAN_HPP_NOEXCEPT - { - return *v; - } - - //=========================== - //=== COMMAND Definitions === - //=========================== - - //=== VK_VERSION_1_0 === - - // wrapper function for command vkCreateInstance, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateInstance.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Context::createInstance( InstanceCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateInstance && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Instance instance; - Result result = static_cast( getDispatcher()->vkCreateInstance( reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &instance ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Context::createInstance" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Instance( *this, *reinterpret_cast( &instance ), allocator ) ); - } - - // wrapper function for command vkEnumeratePhysicalDevices, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDevices.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Instance::enumeratePhysicalDevices() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDevices && "Function requires " ); - - std::vector physicalDevices; - uint32_t physicalDeviceCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkEnumeratePhysicalDevices( static_cast( m_instance ), &physicalDeviceCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceCount ) - { - physicalDevices.resize( physicalDeviceCount ); - result = static_cast( getDispatcher()->vkEnumeratePhysicalDevices( - static_cast( m_instance ), &physicalDeviceCount, reinterpret_cast( physicalDevices.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::enumeratePhysicalDevices" ); - std::vector physicalDevicesRAII; - if ( result == Result::eSuccess ) - { - physicalDevicesRAII.reserve( physicalDevices.size() ); - for ( auto & physicalDevice : physicalDevices ) - { - physicalDevicesRAII.emplace_back( *this, *reinterpret_cast( &physicalDevice ) ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDevicesRAII ) ); - } - - // wrapper function for command vkGetPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures PhysicalDevice::getFeatures() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures && "Function requires " ); - - PhysicalDeviceFeatures features; - getDispatcher()->vkGetPhysicalDeviceFeatures( static_cast( m_physicalDevice ), - reinterpret_cast( &features ) ); - - return features; - } - - // wrapper function for command vkGetPhysicalDeviceFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties PhysicalDevice::getFormatProperties( Format format ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties && "Function requires " ); - - FormatProperties formatProperties; - getDispatcher()->vkGetPhysicalDeviceFormatProperties( - static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); - - return formatProperties; - } - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getImageFormatProperties( Format format, ImageType type, ImageTiling tiling, ImageUsageFlags usage, ImageCreateFlags flags ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties && - "Function requires " ); - - ImageFormatProperties imageFormatProperties; - Result result = static_cast( - getDispatcher()->vkGetPhysicalDeviceImageFormatProperties( static_cast( m_physicalDevice ), - static_cast( format ), - static_cast( type ), - static_cast( tiling ), - static_cast( usage ), - static_cast( flags ), - reinterpret_cast( &imageFormatProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties PhysicalDevice::getProperties() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties && "Function requires " ); - - PhysicalDeviceProperties properties; - getDispatcher()->vkGetPhysicalDeviceProperties( static_cast( m_physicalDevice ), - reinterpret_cast( &properties ) ); - - return properties; - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties && - "Function requires " ); - - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties( static_cast( m_physicalDevice ), - &queueFamilyPropertyCount, - reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - queueFamilyProperties.resize( queueFamilyPropertyCount ); - } - return queueFamilyProperties; - } - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties PhysicalDevice::getMemoryProperties() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties && "Function requires " ); - - PhysicalDeviceMemoryProperties memoryProperties; - getDispatcher()->vkGetPhysicalDeviceMemoryProperties( static_cast( m_physicalDevice ), - reinterpret_cast( &memoryProperties ) ); - - return memoryProperties; - } - - // wrapper function for command vkGetInstanceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetInstanceProcAddr.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_VoidFunction Instance::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetInstanceProcAddr && "Function requires " ); - - PFN_vkVoidFunction result = getDispatcher()->vkGetInstanceProcAddr( static_cast( m_instance ), name.c_str() ); - - return result; - } - - // wrapper function for command vkGetDeviceProcAddr, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceProcAddr.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PFN_VoidFunction Device::getProcAddr( const std::string & name ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceProcAddr && "Function requires " ); - - PFN_vkVoidFunction result = getDispatcher()->vkGetDeviceProcAddr( static_cast( m_device ), name.c_str() ); - - return result; - } - - // wrapper function for command vkCreateDevice, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDevice.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::createDevice( DeviceCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDevice && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Device device; - Result result = static_cast( getDispatcher()->vkCreateDevice( static_cast( m_physicalDevice ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &device ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::createDevice" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Device( *this, *reinterpret_cast( &device ), allocator ) ); - } - - // wrapper function for command vkEnumerateInstanceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceExtensionProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Context::enumerateInstanceExtensionProperties( Optional layerName ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateInstanceExtensionProperties && - "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = - static_cast( getDispatcher()->vkEnumerateInstanceExtensionProperties( layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( getDispatcher()->vkEnumerateInstanceExtensionProperties( - layerName ? layerName->c_str() : nullptr, &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Context::enumerateInstanceExtensionProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkEnumerateDeviceExtensionProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceExtensionProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::enumerateDeviceExtensionProperties( Optional layerName ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateDeviceExtensionProperties && "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkEnumerateDeviceExtensionProperties( - static_cast( m_physicalDevice ), layerName ? layerName->c_str() : nullptr, &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = - static_cast( getDispatcher()->vkEnumerateDeviceExtensionProperties( static_cast( m_physicalDevice ), - layerName ? layerName->c_str() : nullptr, - &propertyCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceExtensionProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkEnumerateInstanceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceLayerProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Context::enumerateInstanceLayerProperties() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateInstanceLayerProperties && "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( - getDispatcher()->vkEnumerateInstanceLayerProperties( &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Context::enumerateInstanceLayerProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkEnumerateDeviceLayerProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateDeviceLayerProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::enumerateDeviceLayerProperties() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateDeviceLayerProperties && "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkEnumerateDeviceLayerProperties( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( getDispatcher()->vkEnumerateDeviceLayerProperties( - static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::enumerateDeviceLayerProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetDeviceQueue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Queue Device::getQueue( uint32_t queueFamilyIndex, uint32_t queueIndex ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceQueue && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Queue queue; - getDispatcher()->vkGetDeviceQueue( static_cast( m_device ), queueFamilyIndex, queueIndex, reinterpret_cast( &queue ) ); - - return Queue( *this, *reinterpret_cast( &queue ) ); - } - - // wrapper function for command vkQueueSubmit, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit.html - VULKAN_HPP_INLINE typename ResultValueType::type Queue::submit( ArrayProxy const & submits, - VULKAN_HPP_NAMESPACE::Fence fence ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkQueueSubmit( - static_cast( m_queue ), submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::submit" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkQueueWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueWaitIdle.html - VULKAN_HPP_INLINE typename ResultValueType::type Queue::waitIdle() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueueWaitIdle && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkQueueWaitIdle( static_cast( m_queue ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::waitIdle" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkDeviceWaitIdle, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeviceWaitIdle.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::waitIdle() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkDeviceWaitIdle && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkDeviceWaitIdle( static_cast( m_device ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::waitIdle" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkAllocateMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateMemory.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::allocateMemory( MemoryAllocateInfo const & allocateInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAllocateMemory && "Function requires " ); - - VULKAN_HPP_NAMESPACE::DeviceMemory memory; - Result result = static_cast( getDispatcher()->vkAllocateMemory( static_cast( m_device ), - reinterpret_cast( &allocateInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &memory ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::allocateMemory" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, DeviceMemory( *this, *reinterpret_cast( &memory ), allocator ) ); - } - - // wrapper function for command vkMapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - DeviceMemory::mapMemory( DeviceSize offset, DeviceSize size, MemoryMapFlags flags ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory && "Function requires " ); - - void * pData; - Result result = static_cast( getDispatcher()->vkMapMemory( static_cast( m_device ), - static_cast( m_deviceMemory ), - static_cast( offset ), - static_cast( size ), - static_cast( flags ), - &pData ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DeviceMemory::mapMemory" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pData ) ); - } - - // wrapper function for command vkUnmapMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory.html - VULKAN_HPP_INLINE void DeviceMemory::unmapMemory() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory && "Function requires " ); - - getDispatcher()->vkUnmapMemory( static_cast( m_device ), static_cast( m_deviceMemory ) ); - } - - // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::flushMappedMemoryRanges( ArrayProxy const & memoryRanges ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkFlushMappedMemoryRanges && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkFlushMappedMemoryRanges( - static_cast( m_device ), memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::flushMappedMemoryRanges" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkInvalidateMappedMemoryRanges, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInvalidateMappedMemoryRanges.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::invalidateMappedMemoryRanges( ArrayProxy const & memoryRanges ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkInvalidateMappedMemoryRanges && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkInvalidateMappedMemoryRanges( - static_cast( m_device ), memoryRanges.size(), reinterpret_cast( memoryRanges.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::invalidateMappedMemoryRanges" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetDeviceMemoryCommitment, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryCommitment.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize DeviceMemory::getCommitment() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMemoryCommitment && "Function requires " ); - - DeviceSize committedMemoryInBytes; - getDispatcher()->vkGetDeviceMemoryCommitment( - static_cast( m_device ), static_cast( m_deviceMemory ), reinterpret_cast( &committedMemoryInBytes ) ); - - return committedMemoryInBytes; - } - - // wrapper function for command vkBindBufferMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory.html - VULKAN_HPP_INLINE typename ResultValueType::type Buffer::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, DeviceSize memoryOffset ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkBindBufferMemory( static_cast( m_device ), - static_cast( m_buffer ), - static_cast( memory ), - static_cast( memoryOffset ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Buffer::bindMemory" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkBindImageMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory.html - VULKAN_HPP_INLINE typename ResultValueType::type Image::bindMemory( VULKAN_HPP_NAMESPACE::DeviceMemory memory, DeviceSize memoryOffset ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkBindImageMemory( static_cast( m_device ), - static_cast( m_image ), - static_cast( memory ), - static_cast( memoryOffset ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Image::bindMemory" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements Buffer::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements && "Function requires " ); - - MemoryRequirements memoryRequirements; - getDispatcher()->vkGetBufferMemoryRequirements( - static_cast( m_device ), static_cast( m_buffer ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements Image::getMemoryRequirements() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements && "Function requires " ); - - MemoryRequirements memoryRequirements; - getDispatcher()->vkGetImageMemoryRequirements( - static_cast( m_device ), static_cast( m_image ), reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Image::getSparseMemoryRequirements() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements && "Function requires " ); - - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - getDispatcher()->vkGetImageSparseMemoryRequirements( - static_cast( m_device ), static_cast( m_image ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - getDispatcher()->vkGetImageSparseMemoryRequirements( static_cast( m_device ), - static_cast( m_image ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getSparseImageFormatProperties( - Format format, ImageType type, SampleCountFlagBits samples, ImageUsageFlags usage, ImageTiling tiling ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties && - "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast( m_physicalDevice ), - static_cast( format ), - static_cast( type ), - static_cast( samples ), - static_cast( usage ), - static_cast( tiling ), - &propertyCount, - nullptr ); - properties.resize( propertyCount ); - getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties( static_cast( m_physicalDevice ), - static_cast( format ), - static_cast( type ), - static_cast( samples ), - static_cast( usage ), - static_cast( tiling ), - &propertyCount, - reinterpret_cast( properties.data() ) ); - - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return properties; - } - - // wrapper function for command vkQueueBindSparse, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBindSparse.html - VULKAN_HPP_INLINE typename ResultValueType::type Queue::bindSparse( ArrayProxy const & bindInfo, - VULKAN_HPP_NAMESPACE::Fence fence ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueueBindSparse && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkQueueBindSparse( - static_cast( m_queue ), bindInfo.size(), reinterpret_cast( bindInfo.data() ), static_cast( fence ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::bindSparse" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCreateFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFence.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createFence( FenceCreateInfo const & createInfo, Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateFence && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Fence fence; - Result result = static_cast( getDispatcher()->vkCreateFence( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &fence ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createFence" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Fence( *this, *reinterpret_cast( &fence ), allocator ) ); - } - - // wrapper function for command vkResetFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetFences.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::resetFences( ArrayProxy const & fences ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkResetFences && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkResetFences( static_cast( m_device ), fences.size(), reinterpret_cast( fences.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::resetFences" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetFenceStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceStatus.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Fence::getStatus() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceStatus && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkGetFenceStatus( static_cast( m_device ), static_cast( m_fence ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Fence::getStatus", { Result::eSuccess, Result::eNotReady } ); - - return static_cast( result ); - } - - // wrapper function for command vkWaitForFences, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForFences.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitForFences( ArrayProxy const & fences, - Bool32 waitAll, - uint64_t timeout ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForFences && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkWaitForFences( - static_cast( m_device ), fences.size(), reinterpret_cast( fences.data() ), static_cast( waitAll ), timeout ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::waitForFences", { Result::eSuccess, Result::eTimeout } ); - - return static_cast( result ); - } - - // wrapper function for command vkCreateSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSemaphore.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createSemaphore( SemaphoreCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSemaphore && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Semaphore semaphore; - Result result = static_cast( getDispatcher()->vkCreateSemaphore( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &semaphore ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSemaphore" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Semaphore( *this, *reinterpret_cast( &semaphore ), allocator ) ); - } - - // wrapper function for command vkCreateQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateQueryPool.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createQueryPool( QueryPoolCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateQueryPool && "Function requires " ); - - VULKAN_HPP_NAMESPACE::QueryPool queryPool; - Result result = static_cast( getDispatcher()->vkCreateQueryPool( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &queryPool ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createQueryPool" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, QueryPool( *this, *reinterpret_cast( &queryPool ), allocator ) ); - } - - // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> - QueryPool::getResults( uint32_t firstQuery, uint32_t queryCount, size_t dataSize, DeviceSize stride, QueryResultFlags flags ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueryPoolResults && "Function requires " ); - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( getDispatcher()->vkGetQueryPoolResults( static_cast( m_device ), - static_cast( m_queryPool ), - firstQuery, - queryCount, - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ), - static_cast( stride ), - static_cast( flags ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::QueryPool::getResults", { Result::eSuccess, Result::eNotReady } ); - - return ResultValue>( result, std::move( data ) ); - } - - // wrapper function for command vkGetQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueryPoolResults.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue - QueryPool::getResult( uint32_t firstQuery, uint32_t queryCount, DeviceSize stride, QueryResultFlags flags ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueryPoolResults && "Function requires " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkGetQueryPoolResults( static_cast( m_device ), - static_cast( m_queryPool ), - firstQuery, - queryCount, - sizeof( DataType ), - reinterpret_cast( &data ), - static_cast( stride ), - static_cast( flags ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::QueryPool::getResult", { Result::eSuccess, Result::eNotReady } ); - - return ResultValue( result, std::move( data ) ); - } - - // wrapper function for command vkCreateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBuffer.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createBuffer( BufferCreateInfo const & createInfo, Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateBuffer && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Buffer buffer; - Result result = static_cast( getDispatcher()->vkCreateBuffer( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &buffer ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createBuffer" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Buffer( *this, *reinterpret_cast( &buffer ), allocator ) ); - } - - // wrapper function for command vkCreateImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImage.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createImage( ImageCreateInfo const & createInfo, Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateImage && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Image image; - Result result = static_cast( getDispatcher()->vkCreateImage( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &image ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createImage" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Image( *this, *reinterpret_cast( &image ), allocator ) ); - } - - // wrapper function for command vkGetImageSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout Image::getSubresourceLayout( const ImageSubresource & subresource ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSubresourceLayout && "Function requires " ); - - SubresourceLayout layout; - getDispatcher()->vkGetImageSubresourceLayout( static_cast( m_device ), - static_cast( m_image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return layout; - } - - // wrapper function for command vkCreateImageView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImageView.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createImageView( ImageViewCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateImageView && "Function requires " ); - - VULKAN_HPP_NAMESPACE::ImageView view; - Result result = static_cast( getDispatcher()->vkCreateImageView( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &view ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createImageView" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, ImageView( *this, *reinterpret_cast( &view ), allocator ) ); - } - - // wrapper function for command vkCreateCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCommandPool.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createCommandPool( CommandPoolCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateCommandPool && "Function requires " ); - - VULKAN_HPP_NAMESPACE::CommandPool commandPool; - Result result = static_cast( getDispatcher()->vkCreateCommandPool( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &commandPool ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createCommandPool" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, CommandPool( *this, *reinterpret_cast( &commandPool ), allocator ) ); - } - - // wrapper function for command vkResetCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandPool.html - VULKAN_HPP_INLINE typename ResultValueType::type CommandPool::reset( CommandPoolResetFlags flags ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkResetCommandPool && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkResetCommandPool( - static_cast( m_device ), static_cast( m_commandPool ), static_cast( flags ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandPool::reset" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkAllocateCommandBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateCommandBuffers.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::allocateCommandBuffers( CommandBufferAllocateInfo const & allocateInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAllocateCommandBuffers && "Function requires " ); - - std::vector commandBuffers( allocateInfo.commandBufferCount ); - Result result = static_cast( getDispatcher()->vkAllocateCommandBuffers( static_cast( m_device ), - reinterpret_cast( &allocateInfo ), - reinterpret_cast( commandBuffers.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::allocateCommandBuffers" ); - std::vector commandBuffersRAII; - if ( result == Result::eSuccess ) - { - commandBuffersRAII.reserve( commandBuffers.size() ); - for ( auto & commandBuffer : commandBuffers ) - { - commandBuffersRAII.emplace_back( - *this, *reinterpret_cast( &commandBuffer ), static_cast( allocateInfo.commandPool ) ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( commandBuffersRAII ) ); - } - - // wrapper function for command vkBeginCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBeginCommandBuffer.html - VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::begin( const CommandBufferBeginInfo & beginInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBeginCommandBuffer && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkBeginCommandBuffer( static_cast( m_commandBuffer ), - reinterpret_cast( &beginInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::begin" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkEndCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEndCommandBuffer.html - VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::end() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkEndCommandBuffer && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkEndCommandBuffer( static_cast( m_commandBuffer ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::end" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkResetCommandBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetCommandBuffer.html - VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::reset( CommandBufferResetFlags flags ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkResetCommandBuffer && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkResetCommandBuffer( static_cast( m_commandBuffer ), static_cast( flags ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::reset" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCmdCopyBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer.html - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer, - ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer && "Function requires " ); - - getDispatcher()->vkCmdCopyBuffer( static_cast( m_commandBuffer ), - static_cast( srcBuffer ), - static_cast( dstBuffer ), - regions.size(), - reinterpret_cast( regions.data() ) ); - } - - // wrapper function for command vkCmdCopyImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage.html - VULKAN_HPP_INLINE void CommandBuffer::copyImage( VULKAN_HPP_NAMESPACE::Image srcImage, - ImageLayout srcImageLayout, - VULKAN_HPP_NAMESPACE::Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage && "Function requires " ); - - getDispatcher()->vkCmdCopyImage( static_cast( m_commandBuffer ), - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regions.size(), - reinterpret_cast( regions.data() ) ); - } - - // wrapper function for command vkCmdCopyBufferToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage.html - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage( VULKAN_HPP_NAMESPACE::Buffer srcBuffer, - VULKAN_HPP_NAMESPACE::Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage && "Function requires " ); - - getDispatcher()->vkCmdCopyBufferToImage( static_cast( m_commandBuffer ), - static_cast( srcBuffer ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regions.size(), - reinterpret_cast( regions.data() ) ); - } - - // wrapper function for command vkCmdCopyImageToBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer.html - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer( VULKAN_HPP_NAMESPACE::Image srcImage, - ImageLayout srcImageLayout, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer, - ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer && "Function requires " ); - - getDispatcher()->vkCmdCopyImageToBuffer( static_cast( m_commandBuffer ), - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstBuffer ), - regions.size(), - reinterpret_cast( regions.data() ) ); - } - - // wrapper function for command vkCmdUpdateBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdateBuffer.html - template - VULKAN_HPP_INLINE void CommandBuffer::updateBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, - DeviceSize dstOffset, - ArrayProxy const & data ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdUpdateBuffer && "Function requires " ); - - getDispatcher()->vkCmdUpdateBuffer( static_cast( m_commandBuffer ), - static_cast( dstBuffer ), - static_cast( dstOffset ), - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ) ); - } - - // wrapper function for command vkCmdFillBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdFillBuffer.html - VULKAN_HPP_INLINE void - CommandBuffer::fillBuffer( VULKAN_HPP_NAMESPACE::Buffer dstBuffer, DeviceSize dstOffset, DeviceSize size, uint32_t data ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdFillBuffer && "Function requires " ); - - getDispatcher()->vkCmdFillBuffer( static_cast( m_commandBuffer ), - static_cast( dstBuffer ), - static_cast( dstOffset ), - static_cast( size ), - data ); - } - - // wrapper function for command vkCmdPipelineBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier.html - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier( PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - DependencyFlags dependencyFlags, - ArrayProxy const & memoryBarriers, - ArrayProxy const & bufferMemoryBarriers, - ArrayProxy const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier && "Function requires " ); - - getDispatcher()->vkCmdPipelineBarrier( static_cast( m_commandBuffer ), - static_cast( srcStageMask ), - static_cast( dstStageMask ), - static_cast( dependencyFlags ), - memoryBarriers.size(), - reinterpret_cast( memoryBarriers.data() ), - bufferMemoryBarriers.size(), - reinterpret_cast( bufferMemoryBarriers.data() ), - imageMemoryBarriers.size(), - reinterpret_cast( imageMemoryBarriers.data() ) ); - } - - // wrapper function for command vkCmdBeginQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQuery.html - VULKAN_HPP_INLINE void - CommandBuffer::beginQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, QueryControlFlags flags ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQuery && "Function requires " ); - - getDispatcher()->vkCmdBeginQuery( - static_cast( m_commandBuffer ), static_cast( queryPool ), query, static_cast( flags ) ); - } - - // wrapper function for command vkCmdEndQuery, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQuery.html - VULKAN_HPP_INLINE void CommandBuffer::endQuery( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQuery && "Function requires " ); - - getDispatcher()->vkCmdEndQuery( static_cast( m_commandBuffer ), static_cast( queryPool ), query ); - } - - // wrapper function for command vkCmdResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetQueryPool.html - VULKAN_HPP_INLINE void - CommandBuffer::resetQueryPool( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetQueryPool && "Function requires " ); - - getDispatcher()->vkCmdResetQueryPool( static_cast( m_commandBuffer ), static_cast( queryPool ), firstQuery, queryCount ); - } - - // wrapper function for command vkCmdWriteTimestamp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp.html - VULKAN_HPP_INLINE void - CommandBuffer::writeTimestamp( PipelineStageFlagBits pipelineStage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp && "Function requires " ); - - getDispatcher()->vkCmdWriteTimestamp( - static_cast( m_commandBuffer ), static_cast( pipelineStage ), static_cast( queryPool ), query ); - } - - // wrapper function for command vkCmdCopyQueryPoolResults, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyQueryPoolResults.html - VULKAN_HPP_INLINE void CommandBuffer::copyQueryPoolResults( VULKAN_HPP_NAMESPACE::QueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer, - DeviceSize dstOffset, - DeviceSize stride, - QueryResultFlags flags ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyQueryPoolResults && "Function requires " ); - - getDispatcher()->vkCmdCopyQueryPoolResults( static_cast( m_commandBuffer ), - static_cast( queryPool ), - firstQuery, - queryCount, - static_cast( dstBuffer ), - static_cast( dstOffset ), - static_cast( stride ), - static_cast( flags ) ); - } - - // wrapper function for command vkCmdExecuteCommands, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteCommands.html - VULKAN_HPP_INLINE void - CommandBuffer::executeCommands( ArrayProxy const & commandBuffers ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdExecuteCommands && "Function requires " ); - - getDispatcher()->vkCmdExecuteCommands( - static_cast( m_commandBuffer ), commandBuffers.size(), reinterpret_cast( commandBuffers.data() ) ); - } - - // wrapper function for command vkCreateEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateEvent.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createEvent( EventCreateInfo const & createInfo, Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateEvent && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Event event; - Result result = static_cast( getDispatcher()->vkCreateEvent( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &event ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createEvent" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Event( *this, *reinterpret_cast( &event ), allocator ) ); - } - - // wrapper function for command vkGetEventStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEventStatus.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Event::getStatus() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetEventStatus && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkGetEventStatus( static_cast( m_device ), static_cast( m_event ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Event::getStatus", { Result::eEventSet, Result::eEventReset } ); - - return static_cast( result ); - } - - // wrapper function for command vkSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetEvent.html - VULKAN_HPP_INLINE typename ResultValueType::type Event::set() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetEvent && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkSetEvent( static_cast( m_device ), static_cast( m_event ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Event::set" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetEvent.html - VULKAN_HPP_INLINE typename ResultValueType::type Event::reset() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkResetEvent && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkResetEvent( static_cast( m_device ), static_cast( m_event ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Event::reset" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCreateBufferView, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferView.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createBufferView( BufferViewCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateBufferView && "Function requires " ); - - VULKAN_HPP_NAMESPACE::BufferView view; - Result result = static_cast( getDispatcher()->vkCreateBufferView( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &view ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createBufferView" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, BufferView( *this, *reinterpret_cast( &view ), allocator ) ); - } - - // wrapper function for command vkCreateShaderModule, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShaderModule.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createShaderModule( ShaderModuleCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateShaderModule && "Function requires " ); - - VULKAN_HPP_NAMESPACE::ShaderModule shaderModule; - Result result = static_cast( getDispatcher()->vkCreateShaderModule( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &shaderModule ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createShaderModule" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, - ShaderModule( *this, *reinterpret_cast( &shaderModule ), allocator ) ); - } - - // wrapper function for command vkCreatePipelineCache, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineCache.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createPipelineCache( PipelineCacheCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreatePipelineCache && "Function requires " ); - - VULKAN_HPP_NAMESPACE::PipelineCache pipelineCache; - Result result = static_cast( getDispatcher()->vkCreatePipelineCache( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipelineCache ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createPipelineCache" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, - PipelineCache( *this, *reinterpret_cast( &pipelineCache ), allocator ) ); - } - - // wrapper function for command vkGetPipelineCacheData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineCacheData.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PipelineCache::getData() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineCacheData && "Function requires " ); - - std::vector data; - size_t dataSize; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPipelineCacheData( static_cast( m_device ), static_cast( m_pipelineCache ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( getDispatcher()->vkGetPipelineCacheData( - static_cast( m_device ), static_cast( m_pipelineCache ), &dataSize, reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PipelineCache::getData" ); - VULKAN_HPP_ASSERT( dataSize <= data.size() ); - if ( dataSize < data.size() ) - { - data.resize( dataSize ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkMergePipelineCaches, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergePipelineCaches.html - VULKAN_HPP_INLINE typename ResultValueType::type PipelineCache::merge( ArrayProxy const & srcCaches ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkMergePipelineCaches && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkMergePipelineCaches( static_cast( m_device ), - static_cast( m_pipelineCache ), - srcCaches.size(), - reinterpret_cast( srcCaches.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PipelineCache::merge" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createComputePipelines( Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateComputePipelines && "Function requires " ); - - std::vector pipelines( createInfos.size() ); - Result result = - static_cast( getDispatcher()->vkCreateComputePipelines( static_cast( m_device ), - pipelineCache ? static_cast( **pipelineCache ) : 0, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createComputePipelines", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - std::vector pipelinesRAII; - if ( result == Result::eSuccess ) - { - pipelinesRAII.reserve( pipelines.size() ); - for ( auto & pipeline : pipelines ) - { - pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); - } - - // wrapper function for command vkCreateComputePipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateComputePipelines.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createComputePipeline( Optional const & pipelineCache, - ComputePipelineCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateComputePipelines && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Pipeline pipeline; - Result result = static_cast( getDispatcher()->vkCreateComputePipelines( static_cast( m_device ), - pipelineCache ? static_cast( **pipelineCache ) : 0, - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createComputePipeline", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); - } - - // wrapper function for command vkCreatePipelineLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineLayout.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createPipelineLayout( PipelineLayoutCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreatePipelineLayout && "Function requires " ); - - VULKAN_HPP_NAMESPACE::PipelineLayout pipelineLayout; - Result result = static_cast( getDispatcher()->vkCreatePipelineLayout( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipelineLayout ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createPipelineLayout" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, PipelineLayout( *this, *reinterpret_cast( &pipelineLayout ), allocator ) ); - } - - // wrapper function for command vkCreateSampler, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSampler.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createSampler( SamplerCreateInfo const & createInfo, Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSampler && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Sampler sampler; - Result result = static_cast( getDispatcher()->vkCreateSampler( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &sampler ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSampler" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Sampler( *this, *reinterpret_cast( &sampler ), allocator ) ); - } - - // wrapper function for command vkCreateDescriptorSetLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorSetLayout.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createDescriptorSetLayout( DescriptorSetLayoutCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDescriptorSetLayout && "Function requires " ); - - VULKAN_HPP_NAMESPACE::DescriptorSetLayout setLayout; - Result result = - static_cast( getDispatcher()->vkCreateDescriptorSetLayout( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &setLayout ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDescriptorSetLayout" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, DescriptorSetLayout( *this, *reinterpret_cast( &setLayout ), allocator ) ); - } - - // wrapper function for command vkCreateDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorPool.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createDescriptorPool( DescriptorPoolCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDescriptorPool && "Function requires " ); - - VULKAN_HPP_NAMESPACE::DescriptorPool descriptorPool; - Result result = static_cast( getDispatcher()->vkCreateDescriptorPool( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &descriptorPool ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDescriptorPool" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, DescriptorPool( *this, *reinterpret_cast( &descriptorPool ), allocator ) ); - } - - // wrapper function for command vkResetDescriptorPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetDescriptorPool.html - VULKAN_HPP_INLINE typename ResultValueType::type DescriptorPool::reset( DescriptorPoolResetFlags flags ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkResetDescriptorPool && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkResetDescriptorPool( - static_cast( m_device ), static_cast( m_descriptorPool ), static_cast( flags ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DescriptorPool::reset" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkAllocateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAllocateDescriptorSets.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::allocateDescriptorSets( DescriptorSetAllocateInfo const & allocateInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAllocateDescriptorSets && "Function requires " ); - - std::vector descriptorSets( allocateInfo.descriptorSetCount ); - Result result = static_cast( getDispatcher()->vkAllocateDescriptorSets( static_cast( m_device ), - reinterpret_cast( &allocateInfo ), - reinterpret_cast( descriptorSets.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::allocateDescriptorSets" ); - std::vector descriptorSetsRAII; - if ( result == Result::eSuccess ) - { - descriptorSetsRAII.reserve( descriptorSets.size() ); - for ( auto & descriptorSet : descriptorSets ) - { - descriptorSetsRAII.emplace_back( - *this, *reinterpret_cast( &descriptorSet ), static_cast( allocateInfo.descriptorPool ) ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( descriptorSetsRAII ) ); - } - - // wrapper function for command vkUpdateDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSets.html - VULKAN_HPP_INLINE void Device::updateDescriptorSets( ArrayProxy const & descriptorWrites, - ArrayProxy const & descriptorCopies ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateDescriptorSets && "Function requires " ); - - getDispatcher()->vkUpdateDescriptorSets( static_cast( m_device ), - descriptorWrites.size(), - reinterpret_cast( descriptorWrites.data() ), - descriptorCopies.size(), - reinterpret_cast( descriptorCopies.data() ) ); - } - - // wrapper function for command vkCmdBindPipeline, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipeline.html - VULKAN_HPP_INLINE void CommandBuffer::bindPipeline( PipelineBindPoint pipelineBindPoint, VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindPipeline && "Function requires " ); - - getDispatcher()->vkCmdBindPipeline( - static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( pipeline ) ); - } - - // wrapper function for command vkCmdBindDescriptorSets, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets.html - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t firstSet, - ArrayProxy const & descriptorSets, - ArrayProxy const & dynamicOffsets ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorSets && "Function requires " ); - - getDispatcher()->vkCmdBindDescriptorSets( static_cast( m_commandBuffer ), - static_cast( pipelineBindPoint ), - static_cast( layout ), - firstSet, - descriptorSets.size(), - reinterpret_cast( descriptorSets.data() ), - dynamicOffsets.size(), - dynamicOffsets.data() ); - } - - // wrapper function for command vkCmdClearColorImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearColorImage.html - VULKAN_HPP_INLINE void CommandBuffer::clearColorImage( VULKAN_HPP_NAMESPACE::Image image, - ImageLayout imageLayout, - const ClearColorValue & color, - ArrayProxy const & ranges ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearColorImage && "Function requires " ); - - getDispatcher()->vkCmdClearColorImage( static_cast( m_commandBuffer ), - static_cast( image ), - static_cast( imageLayout ), - reinterpret_cast( &color ), - ranges.size(), - reinterpret_cast( ranges.data() ) ); - } - - // wrapper function for command vkCmdDispatch, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatch.html - VULKAN_HPP_INLINE void CommandBuffer::dispatch( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatch && "Function requires " ); - - getDispatcher()->vkCmdDispatch( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); - } - - // wrapper function for command vkCmdDispatchIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchIndirect.html - VULKAN_HPP_INLINE void CommandBuffer::dispatchIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchIndirect && "Function requires " ); - - getDispatcher()->vkCmdDispatchIndirect( - static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ) ); - } - - // wrapper function for command vkCmdSetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent.html - VULKAN_HPP_INLINE void CommandBuffer::setEvent( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent && "Function requires " ); - - getDispatcher()->vkCmdSetEvent( - static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); - } - - // wrapper function for command vkCmdResetEvent, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent.html - VULKAN_HPP_INLINE void CommandBuffer::resetEvent( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags stageMask ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent && "Function requires " ); - - getDispatcher()->vkCmdResetEvent( - static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); - } - - // wrapper function for command vkCmdWaitEvents, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents.html - VULKAN_HPP_INLINE void CommandBuffer::waitEvents( ArrayProxy const & events, - PipelineStageFlags srcStageMask, - PipelineStageFlags dstStageMask, - ArrayProxy const & memoryBarriers, - ArrayProxy const & bufferMemoryBarriers, - ArrayProxy const & imageMemoryBarriers ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents && "Function requires " ); - - getDispatcher()->vkCmdWaitEvents( static_cast( m_commandBuffer ), - events.size(), - reinterpret_cast( events.data() ), - static_cast( srcStageMask ), - static_cast( dstStageMask ), - memoryBarriers.size(), - reinterpret_cast( memoryBarriers.data() ), - bufferMemoryBarriers.size(), - reinterpret_cast( bufferMemoryBarriers.data() ), - imageMemoryBarriers.size(), - reinterpret_cast( imageMemoryBarriers.data() ) ); - } - - // wrapper function for command vkCmdPushConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants.html - template - VULKAN_HPP_INLINE void CommandBuffer::pushConstants( VULKAN_HPP_NAMESPACE::PipelineLayout layout, - ShaderStageFlags stageFlags, - uint32_t offset, - ArrayProxy const & values ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushConstants && "Function requires " ); - - getDispatcher()->vkCmdPushConstants( static_cast( m_commandBuffer ), - static_cast( layout ), - static_cast( stageFlags ), - offset, - values.size() * sizeof( ValuesType ), - reinterpret_cast( values.data() ) ); - } - - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createGraphicsPipelines( Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateGraphicsPipelines && "Function requires " ); - - std::vector pipelines( createInfos.size() ); - Result result = - static_cast( getDispatcher()->vkCreateGraphicsPipelines( static_cast( m_device ), - pipelineCache ? static_cast( **pipelineCache ) : 0, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createGraphicsPipelines", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - std::vector pipelinesRAII; - if ( result == Result::eSuccess ) - { - pipelinesRAII.reserve( pipelines.size() ); - for ( auto & pipeline : pipelines ) - { - pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); - } - - // wrapper function for command vkCreateGraphicsPipelines, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateGraphicsPipelines.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createGraphicsPipeline( Optional const & pipelineCache, - GraphicsPipelineCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateGraphicsPipelines && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Pipeline pipeline; - Result result = static_cast( getDispatcher()->vkCreateGraphicsPipelines( static_cast( m_device ), - pipelineCache ? static_cast( **pipelineCache ) : 0, - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createGraphicsPipeline", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); - } - - // wrapper function for command vkCreateFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateFramebuffer.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createFramebuffer( FramebufferCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateFramebuffer && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Framebuffer framebuffer; - Result result = static_cast( getDispatcher()->vkCreateFramebuffer( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &framebuffer ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createFramebuffer" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Framebuffer( *this, *reinterpret_cast( &framebuffer ), allocator ) ); - } - - // wrapper function for command vkCreateRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createRenderPass( RenderPassCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRenderPass && "Function requires " ); - - VULKAN_HPP_NAMESPACE::RenderPass renderPass; - Result result = static_cast( getDispatcher()->vkCreateRenderPass( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &renderPass ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRenderPass" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, RenderPass( *this, *reinterpret_cast( &renderPass ), allocator ) ); - } - - // wrapper function for command vkGetRenderAreaGranularity, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderAreaGranularity.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D RenderPass::getRenderAreaGranularity() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRenderAreaGranularity && "Function requires " ); - - Extent2D granularity; - getDispatcher()->vkGetRenderAreaGranularity( - static_cast( m_device ), static_cast( m_renderPass ), reinterpret_cast( &granularity ) ); - - return granularity; - } - - // wrapper function for command vkCmdSetViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewport.html - VULKAN_HPP_INLINE void CommandBuffer::setViewport( uint32_t firstViewport, ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewport && "Function requires " ); - - getDispatcher()->vkCmdSetViewport( - static_cast( m_commandBuffer ), firstViewport, viewports.size(), reinterpret_cast( viewports.data() ) ); - } - - // wrapper function for command vkCmdSetScissor, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissor.html - VULKAN_HPP_INLINE void CommandBuffer::setScissor( uint32_t firstScissor, ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissor && "Function requires " ); - - getDispatcher()->vkCmdSetScissor( - static_cast( m_commandBuffer ), firstScissor, scissors.size(), reinterpret_cast( scissors.data() ) ); - } - - // wrapper function for command vkCmdSetLineWidth, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineWidth.html - VULKAN_HPP_INLINE void CommandBuffer::setLineWidth( float lineWidth ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineWidth && "Function requires " ); - - getDispatcher()->vkCmdSetLineWidth( static_cast( m_commandBuffer ), lineWidth ); - } - - // wrapper function for command vkCmdSetDepthBias, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias.html - VULKAN_HPP_INLINE void - CommandBuffer::setDepthBias( float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBias && "Function requires " ); - - getDispatcher()->vkCmdSetDepthBias( static_cast( m_commandBuffer ), depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); - } - - // wrapper function for command vkCmdSetBlendConstants, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetBlendConstants.html - VULKAN_HPP_INLINE void CommandBuffer::setBlendConstants( const float blendConstants[4] ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetBlendConstants && "Function requires " ); - - getDispatcher()->vkCmdSetBlendConstants( static_cast( m_commandBuffer ), blendConstants ); - } - - // wrapper function for command vkCmdSetDepthBounds, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBounds.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthBounds( float minDepthBounds, float maxDepthBounds ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBounds && "Function requires " ); - - getDispatcher()->vkCmdSetDepthBounds( static_cast( m_commandBuffer ), minDepthBounds, maxDepthBounds ); - } - - // wrapper function for command vkCmdSetStencilCompareMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilCompareMask.html - VULKAN_HPP_INLINE void CommandBuffer::setStencilCompareMask( StencilFaceFlags faceMask, uint32_t compareMask ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilCompareMask && "Function requires " ); - - getDispatcher()->vkCmdSetStencilCompareMask( static_cast( m_commandBuffer ), static_cast( faceMask ), compareMask ); - } - - // wrapper function for command vkCmdSetStencilWriteMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilWriteMask.html - VULKAN_HPP_INLINE void CommandBuffer::setStencilWriteMask( StencilFaceFlags faceMask, uint32_t writeMask ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilWriteMask && "Function requires " ); - - getDispatcher()->vkCmdSetStencilWriteMask( static_cast( m_commandBuffer ), static_cast( faceMask ), writeMask ); - } - - // wrapper function for command vkCmdSetStencilReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilReference.html - VULKAN_HPP_INLINE void CommandBuffer::setStencilReference( StencilFaceFlags faceMask, uint32_t reference ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilReference && "Function requires " ); - - getDispatcher()->vkCmdSetStencilReference( static_cast( m_commandBuffer ), static_cast( faceMask ), reference ); - } - - // wrapper function for command vkCmdBindIndexBuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer.html - VULKAN_HPP_INLINE void - CommandBuffer::bindIndexBuffer( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, IndexType indexType ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer && "Function requires " ); - - getDispatcher()->vkCmdBindIndexBuffer( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( indexType ) ); - } - - // wrapper function for command vkCmdBindVertexBuffers, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers.html - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers && "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); -# else - if ( buffers.size() != offsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers: buffers.size() != offsets.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdBindVertexBuffers( static_cast( m_commandBuffer ), - firstBinding, - buffers.size(), - reinterpret_cast( buffers.data() ), - reinterpret_cast( offsets.data() ) ); - } - - // wrapper function for command vkCmdDraw, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDraw.html - VULKAN_HPP_INLINE void - CommandBuffer::draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDraw && "Function requires " ); - - getDispatcher()->vkCmdDraw( static_cast( m_commandBuffer ), vertexCount, instanceCount, firstVertex, firstInstance ); - } - - // wrapper function for command vkCmdDrawIndexed, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexed.html - VULKAN_HPP_INLINE void CommandBuffer::drawIndexed( - uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexed && "Function requires " ); - - getDispatcher()->vkCmdDrawIndexed( static_cast( m_commandBuffer ), indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); - } - - // wrapper function for command vkCmdDrawIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirect.html - VULKAN_HPP_INLINE void - CommandBuffer::drawIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, uint32_t drawCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirect && "Function requires " ); - - getDispatcher()->vkCmdDrawIndirect( - static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); - } - - // wrapper function for command vkCmdDrawIndexedIndirect, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirect.html - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirect( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - uint32_t drawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexedIndirect && "Function requires " ); - - getDispatcher()->vkCmdDrawIndexedIndirect( - static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); - } - - // wrapper function for command vkCmdBlitImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage.html - VULKAN_HPP_INLINE void CommandBuffer::blitImage( VULKAN_HPP_NAMESPACE::Image srcImage, - ImageLayout srcImageLayout, - VULKAN_HPP_NAMESPACE::Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions, - Filter filter ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage && "Function requires " ); - - getDispatcher()->vkCmdBlitImage( static_cast( m_commandBuffer ), - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regions.size(), - reinterpret_cast( regions.data() ), - static_cast( filter ) ); - } - - // wrapper function for command vkCmdClearDepthStencilImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearDepthStencilImage.html - VULKAN_HPP_INLINE void CommandBuffer::clearDepthStencilImage( VULKAN_HPP_NAMESPACE::Image image, - ImageLayout imageLayout, - const ClearDepthStencilValue & depthStencil, - ArrayProxy const & ranges ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearDepthStencilImage && "Function requires " ); - - getDispatcher()->vkCmdClearDepthStencilImage( static_cast( m_commandBuffer ), - static_cast( image ), - static_cast( imageLayout ), - reinterpret_cast( &depthStencil ), - ranges.size(), - reinterpret_cast( ranges.data() ) ); - } - - // wrapper function for command vkCmdClearAttachments, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdClearAttachments.html - VULKAN_HPP_INLINE void CommandBuffer::clearAttachments( ArrayProxy const & attachments, - ArrayProxy const & rects ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdClearAttachments && "Function requires " ); - - getDispatcher()->vkCmdClearAttachments( static_cast( m_commandBuffer ), - attachments.size(), - reinterpret_cast( attachments.data() ), - rects.size(), - reinterpret_cast( rects.data() ) ); - } - - // wrapper function for command vkCmdResolveImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage.html - VULKAN_HPP_INLINE void CommandBuffer::resolveImage( VULKAN_HPP_NAMESPACE::Image srcImage, - ImageLayout srcImageLayout, - VULKAN_HPP_NAMESPACE::Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & regions ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage && "Function requires " ); - - getDispatcher()->vkCmdResolveImage( static_cast( m_commandBuffer ), - static_cast( srcImage ), - static_cast( srcImageLayout ), - static_cast( dstImage ), - static_cast( dstImageLayout ), - regions.size(), - reinterpret_cast( regions.data() ) ); - } - - // wrapper function for command vkCmdBeginRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass.html - VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass( const RenderPassBeginInfo & renderPassBegin, SubpassContents contents ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass && "Function requires " ); - - getDispatcher()->vkCmdBeginRenderPass( static_cast( m_commandBuffer ), - reinterpret_cast( &renderPassBegin ), - static_cast( contents ) ); - } - - // wrapper function for command vkCmdNextSubpass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass.html - VULKAN_HPP_INLINE void CommandBuffer::nextSubpass( SubpassContents contents ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass && "Function requires " ); - - getDispatcher()->vkCmdNextSubpass( static_cast( m_commandBuffer ), static_cast( contents ) ); - } - - // wrapper function for command vkCmdEndRenderPass, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass.html - VULKAN_HPP_INLINE void CommandBuffer::endRenderPass() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass && "Function requires " ); - - getDispatcher()->vkCmdEndRenderPass( static_cast( m_commandBuffer ) ); - } - - //=== VK_VERSION_1_1 === - - // wrapper function for command vkEnumerateInstanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumerateInstanceVersion.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Context::enumerateInstanceVersion() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkEnumerateInstanceVersion && "Function requires " ); - - uint32_t apiVersion; - Result result = static_cast( getDispatcher()->vkEnumerateInstanceVersion( &apiVersion ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Context::enumerateInstanceVersion" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( apiVersion ) ); - } - - // wrapper function for command vkBindBufferMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::bindBufferMemory2( ArrayProxy const & bindInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2 && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkBindBufferMemory2( - static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindBufferMemory2" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkBindImageMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::bindImageMemory2( ArrayProxy const & bindInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2 && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkBindImageMemory2( - static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindImageMemory2" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetDeviceGroupPeerMemoryFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeatures.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeatures( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures && - "Function requires or " ); - - PeerMemoryFeatureFlags peerMemoryFeatures; - getDispatcher()->vkGetDeviceGroupPeerMemoryFeatures( static_cast( m_device ), - heapIndex, - localDeviceIndex, - remoteDeviceIndex, - reinterpret_cast( &peerMemoryFeatures ) ); - - return peerMemoryFeatures; - } - - // wrapper function for command vkCmdSetDeviceMask, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMask.html - VULKAN_HPP_INLINE void CommandBuffer::setDeviceMask( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMask && "Function requires or " ); - - getDispatcher()->vkCmdSetDeviceMask( static_cast( m_commandBuffer ), deviceMask ); - } - - // wrapper function for command vkEnumeratePhysicalDeviceGroups, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroups.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::enumeratePhysicalDeviceGroups() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceGroups && - "Function requires or " ); - - std::vector physicalDeviceGroupProperties; - uint32_t physicalDeviceGroupCount; - Result result; - do - { - result = - static_cast( getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast( m_instance ), &physicalDeviceGroupCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - result = static_cast( - getDispatcher()->vkEnumeratePhysicalDeviceGroups( static_cast( m_instance ), - &physicalDeviceGroupCount, - reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroups" ); - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); - if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); - } - - // wrapper function for command vkGetImageMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2 && - "Function requires or " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetImageMemoryRequirements2( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetImageMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getImageMemoryRequirements2( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2 && - "Function requires or " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetImageMemoryRequirements2( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkGetBufferMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2 && - "Function requires or " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetBufferMemoryRequirements2( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetBufferMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getBufferMemoryRequirements2( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2 && - "Function requires or " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetBufferMemoryRequirements2( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkGetImageSparseMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirements2( const ImageSparseMemoryRequirementsInfo2 & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements2 && - "Function requires or " ); - - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - getDispatcher()->vkGetImageSparseMemoryRequirements2( - static_cast( m_device ), reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - getDispatcher()->vkGetImageSparseMemoryRequirements2( static_cast( m_device ), - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } - - // wrapper function for command vkGetPhysicalDeviceFeatures2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2 && - "Function requires or " ); - - PhysicalDeviceFeatures2 features; - getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast( m_physicalDevice ), - reinterpret_cast( &features ) ); - - return features; - } - - // wrapper function for command vkGetPhysicalDeviceFeatures2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2 && - "Function requires or " ); - - StructureChain structureChain; - PhysicalDeviceFeatures2 & features = structureChain.template get(); - getDispatcher()->vkGetPhysicalDeviceFeatures2( static_cast( m_physicalDevice ), - reinterpret_cast( &features ) ); - - return structureChain; - } - - // wrapper function for command vkGetPhysicalDeviceProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2 && - "Function requires or " ); - - PhysicalDeviceProperties2 properties; - getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( &properties ) ); - - return properties; - } - - // wrapper function for command vkGetPhysicalDeviceProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2 && - "Function requires or " ); - - StructureChain structureChain; - PhysicalDeviceProperties2 & properties = structureChain.template get(); - getDispatcher()->vkGetPhysicalDeviceProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( &properties ) ); - - return structureChain; - } - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2( Format format ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2 && - "Function requires or " ); - - FormatProperties2 formatProperties; - getDispatcher()->vkGetPhysicalDeviceFormatProperties2( - static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); - - return formatProperties; - } - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFormatProperties2( Format format ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2 && - "Function requires or " ); - - StructureChain structureChain; - FormatProperties2 & formatProperties = structureChain.template get(); - getDispatcher()->vkGetPhysicalDeviceFormatProperties2( - static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); - - return structureChain; - } - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2( - const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, ImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2 && - "Function requires or " ); - return static_cast( - getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( pImageFormatInfo ), - reinterpret_cast( pImageFormatProperties ) ) ); - } - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2 && - "Function requires or " ); - - ImageFormatProperties2 imageFormatProperties; - Result result = static_cast( - getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( &imageFormatInfo ), - reinterpret_cast( &imageFormatProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getImageFormatProperties2( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2 && - "Function requires or " ); - - StructureChain structureChain; - ImageFormatProperties2 & imageFormatProperties = structureChain.template get(); - Result result = static_cast( - getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( &imageFormatInfo ), - reinterpret_cast( &imageFormatProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2 && - "Function requires or " ); - - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast( m_physicalDevice ), - &queueFamilyPropertyCount, - reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - queueFamilyProperties.resize( queueFamilyPropertyCount ); - } - return queueFamilyProperties; - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2 && - "Function requires or " ); - - std::vector structureChains; - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); - structureChains.resize( queueFamilyPropertyCount ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; - } - getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2( static_cast( m_physicalDevice ), - &queueFamilyPropertyCount, - reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - structureChains.resize( queueFamilyPropertyCount ); - } - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - structureChains[i].template get() = queueFamilyProperties[i]; - } - return structureChains; - } - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2 && - "Function requires or " ); - - PhysicalDeviceMemoryProperties2 memoryProperties; - getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( &memoryProperties ) ); - - return memoryProperties; - } - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getMemoryProperties2() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2 && - "Function requires or " ); - - StructureChain structureChain; - PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get(); - getDispatcher()->vkGetPhysicalDeviceMemoryProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( &memoryProperties ) ); - - return structureChain; - } - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getSparseImageFormatProperties2( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2 && - "Function requires or " ); - - std::vector properties; - uint32_t propertyCount; - getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( &formatInfo ), - &propertyCount, - nullptr ); - properties.resize( propertyCount ); - getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2( static_cast( m_physicalDevice ), - reinterpret_cast( &formatInfo ), - &propertyCount, - reinterpret_cast( properties.data() ) ); - - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return properties; - } - - // wrapper function for command vkTrimCommandPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPool.html - VULKAN_HPP_INLINE void CommandPool::trim( CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPool && "Function requires or " ); - - getDispatcher()->vkTrimCommandPool( - static_cast( m_device ), static_cast( m_commandPool ), static_cast( flags ) ); - } - - // wrapper function for command vkGetDeviceQueue2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceQueue2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Queue Device::getQueue2( DeviceQueueInfo2 const & queueInfo ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceQueue2 && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Queue queue; - getDispatcher()->vkGetDeviceQueue2( - static_cast( m_device ), reinterpret_cast( &queueInfo ), reinterpret_cast( &queue ) ); - - return Queue( *this, *reinterpret_cast( &queue ) ); - } - - // wrapper function for command vkGetPhysicalDeviceExternalBufferProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalBufferProperties - PhysicalDevice::getExternalBufferProperties( const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalBufferProperties && - "Function requires or " ); - - ExternalBufferProperties externalBufferProperties; - getDispatcher()->vkGetPhysicalDeviceExternalBufferProperties( static_cast( m_physicalDevice ), - reinterpret_cast( &externalBufferInfo ), - reinterpret_cast( &externalBufferProperties ) ); - - return externalBufferProperties; - } - - // wrapper function for command vkGetPhysicalDeviceExternalFenceProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFenceProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalFenceProperties - PhysicalDevice::getExternalFenceProperties( const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalFenceProperties && - "Function requires or " ); - - ExternalFenceProperties externalFenceProperties; - getDispatcher()->vkGetPhysicalDeviceExternalFenceProperties( static_cast( m_physicalDevice ), - reinterpret_cast( &externalFenceInfo ), - reinterpret_cast( &externalFenceProperties ) ); - - return externalFenceProperties; - } - - // wrapper function for command vkGetPhysicalDeviceExternalSemaphoreProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalSemaphoreProperties - PhysicalDevice::getExternalSemaphoreProperties( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalSemaphoreProperties && - "Function requires or " ); - - ExternalSemaphoreProperties externalSemaphoreProperties; - getDispatcher()->vkGetPhysicalDeviceExternalSemaphoreProperties( - static_cast( m_physicalDevice ), - reinterpret_cast( &externalSemaphoreInfo ), - reinterpret_cast( &externalSemaphoreProperties ) ); - - return externalSemaphoreProperties; - } - - // wrapper function for command vkCmdDispatchBase, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBase.html - VULKAN_HPP_INLINE void CommandBuffer::dispatchBase( uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBase && "Function requires or " ); - - getDispatcher()->vkCmdDispatchBase( - static_cast( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); - } - - // wrapper function for command vkCreateDescriptorUpdateTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplate.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createDescriptorUpdateTemplate( DescriptorUpdateTemplateCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDescriptorUpdateTemplate && - "Function requires or " ); - - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = - static_cast( getDispatcher()->vkCreateDescriptorUpdateTemplate( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &descriptorUpdateTemplate ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplate" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, DescriptorUpdateTemplate( *this, *reinterpret_cast( &descriptorUpdateTemplate ), allocator ) ); - } - - // wrapper function for command vkUpdateDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplate.html - template - VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - DataType const & data ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateDescriptorSetWithTemplate && - "Function requires or " ); - - getDispatcher()->vkUpdateDescriptorSetWithTemplate( static_cast( m_device ), - static_cast( m_descriptorSet ), - static_cast( descriptorUpdateTemplate ), - reinterpret_cast( &data ) ); - } - - // wrapper function for command vkGetDescriptorSetLayoutSupport, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutSupport - Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupport && - "Function requires or " ); - - DescriptorSetLayoutSupport support; - getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( &support ) ); - - return support; - } - - // wrapper function for command vkGetDescriptorSetLayoutSupport, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupport.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getDescriptorSetLayoutSupport( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupport && - "Function requires or " ); - - StructureChain structureChain; - DescriptorSetLayoutSupport & support = structureChain.template get(); - getDispatcher()->vkGetDescriptorSetLayoutSupport( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( &support ) ); - - return structureChain; - } - - // wrapper function for command vkCreateSamplerYcbcrConversion, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversion.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createSamplerYcbcrConversion( SamplerYcbcrConversionCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSamplerYcbcrConversion && - "Function requires or " ); - - VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; - Result result = - static_cast( getDispatcher()->vkCreateSamplerYcbcrConversion( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &ycbcrConversion ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSamplerYcbcrConversion" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, SamplerYcbcrConversion( *this, *reinterpret_cast( &ycbcrConversion ), allocator ) ); - } - - //=== VK_VERSION_1_2 === - - // wrapper function for command vkResetQueryPool, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPool.html - VULKAN_HPP_INLINE void QueryPool::reset( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPool && "Function requires or " ); - - getDispatcher()->vkResetQueryPool( static_cast( m_device ), static_cast( m_queryPool ), firstQuery, queryCount ); - } - - // wrapper function for command vkGetSemaphoreCounterValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValue.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Semaphore::getCounterValue() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreCounterValue && - "Function requires or " ); - - uint64_t value; - Result result = static_cast( - getDispatcher()->vkGetSemaphoreCounterValue( static_cast( m_device ), static_cast( m_semaphore ), &value ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Semaphore::getCounterValue" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( value ) ); - } - - // wrapper function for command vkWaitSemaphores, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphores.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphores( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphores && "Function requires or " ); - - Result result = static_cast( - getDispatcher()->vkWaitSemaphores( static_cast( m_device ), reinterpret_cast( &waitInfo ), timeout ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::waitSemaphores", { Result::eSuccess, Result::eTimeout } ); - - return static_cast( result ); - } - - // wrapper function for command vkSignalSemaphore, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphore.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::signalSemaphore( const SemaphoreSignalInfo & signalInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphore && "Function requires or " ); - - Result result = static_cast( - getDispatcher()->vkSignalSemaphore( static_cast( m_device ), reinterpret_cast( &signalInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::signalSemaphore" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetBufferDeviceAddress, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddress.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferDeviceAddress && - "Function requires or or " ); - - VkDeviceAddress result = - getDispatcher()->vkGetBufferDeviceAddress( static_cast( m_device ), reinterpret_cast( &info ) ); - - return static_cast( result ); - } - - // wrapper function for command vkGetBufferOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddress.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddress( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferOpaqueCaptureAddress && - "Function requires or " ); - - uint64_t result = - getDispatcher()->vkGetBufferOpaqueCaptureAddress( static_cast( m_device ), reinterpret_cast( &info ) ); - - return result; - } - - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddress, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t - Device::getMemoryOpaqueCaptureAddress( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress && - "Function requires or " ); - - uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddress( static_cast( m_device ), - reinterpret_cast( &info ) ); - - return result; - } - - // wrapper function for command vkCmdDrawIndirectCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCount.html - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCount && - "Function requires or or " ); - - getDispatcher()->vkCmdDrawIndirectCount( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - // wrapper function for command vkCmdDrawIndexedIndirectCount, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCount.html - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCount( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndexedIndirectCount && - "Function requires or or " ); - - getDispatcher()->vkCmdDrawIndexedIndirectCount( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - // wrapper function for command vkCreateRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createRenderPass2( RenderPassCreateInfo2 const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRenderPass2 && "Function requires or " ); - - VULKAN_HPP_NAMESPACE::RenderPass renderPass; - Result result = static_cast( getDispatcher()->vkCreateRenderPass2( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &renderPass ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRenderPass2" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, RenderPass( *this, *reinterpret_cast( &renderPass ), allocator ) ); - } - - // wrapper function for command vkCmdBeginRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2.html - VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2( const RenderPassBeginInfo & renderPassBegin, - const SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2 && - "Function requires or " ); - - getDispatcher()->vkCmdBeginRenderPass2( static_cast( m_commandBuffer ), - reinterpret_cast( &renderPassBegin ), - reinterpret_cast( &subpassBeginInfo ) ); - } - - // wrapper function for command vkCmdNextSubpass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2.html - VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2( const SubpassBeginInfo & subpassBeginInfo, - const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2 && "Function requires or " ); - - getDispatcher()->vkCmdNextSubpass2( static_cast( m_commandBuffer ), - reinterpret_cast( &subpassBeginInfo ), - reinterpret_cast( &subpassEndInfo ) ); - } - - // wrapper function for command vkCmdEndRenderPass2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2.html - VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2 && "Function requires or " ); - - getDispatcher()->vkCmdEndRenderPass2( static_cast( m_commandBuffer ), reinterpret_cast( &subpassEndInfo ) ); - } - - //=== VK_VERSION_1_3 === - - // wrapper function for command vkGetPhysicalDeviceToolProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolProperties.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getToolProperties() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceToolProperties && - "Function requires or " ); - - std::vector toolProperties; - uint32_t toolCount; - Result result; - do - { - result = - static_cast( getDispatcher()->vkGetPhysicalDeviceToolProperties( static_cast( m_physicalDevice ), &toolCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && toolCount ) - { - toolProperties.resize( toolCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceToolProperties( - static_cast( m_physicalDevice ), &toolCount, reinterpret_cast( toolProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getToolProperties" ); - VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); - if ( toolCount < toolProperties.size() ) - { - toolProperties.resize( toolCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( toolProperties ) ); - } - - // wrapper function for command vkCreatePrivateDataSlot, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlot.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createPrivateDataSlot( PrivateDataSlotCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreatePrivateDataSlot && "Function requires or " ); - - VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; - Result result = static_cast( getDispatcher()->vkCreatePrivateDataSlot( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &privateDataSlot ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createPrivateDataSlot" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, PrivateDataSlot( *this, *reinterpret_cast( &privateDataSlot ), allocator ) ); - } - - // wrapper function for command vkSetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateData.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::setPrivateData( ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetPrivateData && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkSetPrivateData( - static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::setPrivateData" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetPrivateData, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateData.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateData( ObjectType objectType_, - uint64_t objectHandle, - VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateData && "Function requires or " ); - - uint64_t data; - getDispatcher()->vkGetPrivateData( - static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), &data ); - - return data; - } - - // wrapper function for command vkCmdPipelineBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2.html - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2( const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2 && "Function requires or " ); - - getDispatcher()->vkCmdPipelineBarrier2( static_cast( m_commandBuffer ), reinterpret_cast( &dependencyInfo ) ); - } - - // wrapper function for command vkCmdWriteTimestamp2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2.html - VULKAN_HPP_INLINE void - CommandBuffer::writeTimestamp2( PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2 && "Function requires or " ); - - getDispatcher()->vkCmdWriteTimestamp2( - static_cast( m_commandBuffer ), static_cast( stage ), static_cast( queryPool ), query ); - } - - // wrapper function for command vkQueueSubmit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2.html - VULKAN_HPP_INLINE typename ResultValueType::type Queue::submit2( ArrayProxy const & submits, - VULKAN_HPP_NAMESPACE::Fence fence ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2 && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkQueueSubmit2( - static_cast( m_queue ), submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::submit2" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCmdCopyBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2.html - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2( const CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2 && "Function requires or " ); - - getDispatcher()->vkCmdCopyBuffer2( static_cast( m_commandBuffer ), reinterpret_cast( ©BufferInfo ) ); - } - - // wrapper function for command vkCmdCopyImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2.html - VULKAN_HPP_INLINE void CommandBuffer::copyImage2( const CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2 && "Function requires or " ); - - getDispatcher()->vkCmdCopyImage2( static_cast( m_commandBuffer ), reinterpret_cast( ©ImageInfo ) ); - } - - // wrapper function for command vkCmdCopyBufferToImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2.html - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2( const CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2 && - "Function requires or " ); - - getDispatcher()->vkCmdCopyBufferToImage2( static_cast( m_commandBuffer ), - reinterpret_cast( ©BufferToImageInfo ) ); - } - - // wrapper function for command vkCmdCopyImageToBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2.html - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2( const CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2 && - "Function requires or " ); - - getDispatcher()->vkCmdCopyImageToBuffer2( static_cast( m_commandBuffer ), - reinterpret_cast( ©ImageToBufferInfo ) ); - } - - // wrapper function for command vkGetDeviceBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirements && - "Function requires or " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDeviceBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirements.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getBufferMemoryRequirements( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirements && - "Function requires or " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetDeviceBufferMemoryRequirements( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkGetDeviceImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirements && - "Function requires or " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDeviceImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirements.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getImageMemoryRequirements( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirements && - "Function requires or " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetDeviceImageMemoryRequirements( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkGetDeviceImageSparseMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirements.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirements( const DeviceImageMemoryRequirements & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSparseMemoryRequirements && - "Function requires or " ); - - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( - static_cast( m_device ), reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - getDispatcher()->vkGetDeviceImageSparseMemoryRequirements( static_cast( m_device ), - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } - - // wrapper function for command vkCmdSetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2.html - VULKAN_HPP_INLINE void CommandBuffer::setEvent2( VULKAN_HPP_NAMESPACE::Event event, const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent2 && "Function requires or " ); - - getDispatcher()->vkCmdSetEvent2( - static_cast( m_commandBuffer ), static_cast( event ), reinterpret_cast( &dependencyInfo ) ); - } - - // wrapper function for command vkCmdResetEvent2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2.html - VULKAN_HPP_INLINE void CommandBuffer::resetEvent2( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2 && "Function requires or " ); - - getDispatcher()->vkCmdResetEvent2( - static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); - } - - // wrapper function for command vkCmdWaitEvents2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2.html - VULKAN_HPP_INLINE void CommandBuffer::waitEvents2( ArrayProxy const & events, - ArrayProxy const & dependencyInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents2 && "Function requires or " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); -# else - if ( events.size() != dependencyInfos.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2: events.size() != dependencyInfos.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdWaitEvents2( static_cast( m_commandBuffer ), - events.size(), - reinterpret_cast( events.data() ), - reinterpret_cast( dependencyInfos.data() ) ); - } - - // wrapper function for command vkCmdBlitImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2.html - VULKAN_HPP_INLINE void CommandBuffer::blitImage2( const BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2 && "Function requires or " ); - - getDispatcher()->vkCmdBlitImage2( static_cast( m_commandBuffer ), reinterpret_cast( &blitImageInfo ) ); - } - - // wrapper function for command vkCmdResolveImage2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2.html - VULKAN_HPP_INLINE void CommandBuffer::resolveImage2( const ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2 && "Function requires or " ); - - getDispatcher()->vkCmdResolveImage2( static_cast( m_commandBuffer ), - reinterpret_cast( &resolveImageInfo ) ); - } - - // wrapper function for command vkCmdBeginRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRendering.html - VULKAN_HPP_INLINE void CommandBuffer::beginRendering( const RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRendering && "Function requires or " ); - - getDispatcher()->vkCmdBeginRendering( static_cast( m_commandBuffer ), reinterpret_cast( &renderingInfo ) ); - } - - // wrapper function for command vkCmdEndRendering, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering.html - VULKAN_HPP_INLINE void CommandBuffer::endRendering() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRendering && "Function requires or " ); - - getDispatcher()->vkCmdEndRendering( static_cast( m_commandBuffer ) ); - } - - // wrapper function for command vkCmdSetCullMode, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullMode.html - VULKAN_HPP_INLINE void CommandBuffer::setCullMode( CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullMode && - "Function requires or or " ); - - getDispatcher()->vkCmdSetCullMode( static_cast( m_commandBuffer ), static_cast( cullMode ) ); - } - - // wrapper function for command vkCmdSetFrontFace, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFace.html - VULKAN_HPP_INLINE void CommandBuffer::setFrontFace( FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFace && - "Function requires or or " ); - - getDispatcher()->vkCmdSetFrontFace( static_cast( m_commandBuffer ), static_cast( frontFace ) ); - } - - // wrapper function for command vkCmdSetPrimitiveTopology, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopology.html - VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology( PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveTopology && - "Function requires or or " ); - - getDispatcher()->vkCmdSetPrimitiveTopology( static_cast( m_commandBuffer ), static_cast( primitiveTopology ) ); - } - - // wrapper function for command vkCmdSetViewportWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCount.html - VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCount( ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWithCount && - "Function requires or or " ); - - getDispatcher()->vkCmdSetViewportWithCount( - static_cast( m_commandBuffer ), viewports.size(), reinterpret_cast( viewports.data() ) ); - } - - // wrapper function for command vkCmdSetScissorWithCount, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCount.html - VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCount( ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissorWithCount && - "Function requires or or " ); - - getDispatcher()->vkCmdSetScissorWithCount( - static_cast( m_commandBuffer ), scissors.size(), reinterpret_cast( scissors.data() ) ); - } - - // wrapper function for command vkCmdBindVertexBuffers2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2.html - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes, - ArrayProxy const & strides ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers2 && - "Function requires or or " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); - VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); - VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); -# else - if ( buffers.size() != offsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != offsets.size()" ); - } - if ( !sizes.empty() && buffers.size() != sizes.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != sizes.size()" ); - } - if ( !strides.empty() && buffers.size() != strides.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != strides.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdBindVertexBuffers2( static_cast( m_commandBuffer ), - firstBinding, - buffers.size(), - reinterpret_cast( buffers.data() ), - reinterpret_cast( offsets.data() ), - reinterpret_cast( sizes.data() ), - reinterpret_cast( strides.data() ) ); - } - - // wrapper function for command vkCmdSetDepthTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnable.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable( Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthTestEnable && - "Function requires or or " ); - - getDispatcher()->vkCmdSetDepthTestEnable( static_cast( m_commandBuffer ), static_cast( depthTestEnable ) ); - } - - // wrapper function for command vkCmdSetDepthWriteEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnable.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable( Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthWriteEnable && - "Function requires or or " ); - - getDispatcher()->vkCmdSetDepthWriteEnable( static_cast( m_commandBuffer ), static_cast( depthWriteEnable ) ); - } - - // wrapper function for command vkCmdSetDepthCompareOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOp.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp( CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthCompareOp && - "Function requires or or " ); - - getDispatcher()->vkCmdSetDepthCompareOp( static_cast( m_commandBuffer ), static_cast( depthCompareOp ) ); - } - - // wrapper function for command vkCmdSetDepthBoundsTestEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnable.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBoundsTestEnable && - "Function requires or or " ); - - getDispatcher()->vkCmdSetDepthBoundsTestEnable( static_cast( m_commandBuffer ), static_cast( depthBoundsTestEnable ) ); - } - - // wrapper function for command vkCmdSetStencilTestEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnable.html - VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable( Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilTestEnable && - "Function requires or or " ); - - getDispatcher()->vkCmdSetStencilTestEnable( static_cast( m_commandBuffer ), static_cast( stencilTestEnable ) ); - } - - // wrapper function for command vkCmdSetStencilOp, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOp.html - VULKAN_HPP_INLINE void CommandBuffer::setStencilOp( - StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOp && - "Function requires or or " ); - - getDispatcher()->vkCmdSetStencilOp( static_cast( m_commandBuffer ), - static_cast( faceMask ), - static_cast( failOp ), - static_cast( passOp ), - static_cast( depthFailOp ), - static_cast( compareOp ) ); - } - - // wrapper function for command vkCmdSetRasterizerDiscardEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnable.html - VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizerDiscardEnable && - "Function requires or or " ); - - getDispatcher()->vkCmdSetRasterizerDiscardEnable( static_cast( m_commandBuffer ), static_cast( rasterizerDiscardEnable ) ); - } - - // wrapper function for command vkCmdSetDepthBiasEnable, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnable.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable( Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBiasEnable && - "Function requires or or " ); - - getDispatcher()->vkCmdSetDepthBiasEnable( static_cast( m_commandBuffer ), static_cast( depthBiasEnable ) ); - } - - // wrapper function for command vkCmdSetPrimitiveRestartEnable, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnable.html - VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable( Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveRestartEnable && - "Function requires or or " ); - - getDispatcher()->vkCmdSetPrimitiveRestartEnable( static_cast( m_commandBuffer ), static_cast( primitiveRestartEnable ) ); - } - - //=== VK_VERSION_1_4 === - - // wrapper function for command vkMapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::mapMemory2( const MemoryMapInfo & memoryMapInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory2 && "Function requires or " ); - - void * pData; - Result result = static_cast( - getDispatcher()->vkMapMemory2( static_cast( m_device ), reinterpret_cast( &memoryMapInfo ), &pData ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::mapMemory2" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pData ) ); - } - - // wrapper function for command vkUnmapMemory2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::unmapMemory2( const MemoryUnmapInfo & memoryUnmapInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory2 && "Function requires or " ); - - Result result = static_cast( - getDispatcher()->vkUnmapMemory2( static_cast( m_device ), reinterpret_cast( &memoryUnmapInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::unmapMemory2" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetDeviceImageSubresourceLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 - Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayout && - "Function requires or " ); - - SubresourceLayout2 layout; - getDispatcher()->vkGetDeviceImageSubresourceLayout( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &layout ) ); - - return layout; - } - - // wrapper function for command vkGetDeviceImageSubresourceLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayout.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getImageSubresourceLayout( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayout && - "Function requires or " ); - - StructureChain structureChain; - SubresourceLayout2 & layout = structureChain.template get(); - getDispatcher()->vkGetDeviceImageSubresourceLayout( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &layout ) ); - - return structureChain; - } - - // wrapper function for command vkGetImageSubresourceLayout2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Image::getSubresourceLayout2( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkGetImageSubresourceLayout2 && - "Function requires or or or " ); - - SubresourceLayout2 layout; - getDispatcher()->vkGetImageSubresourceLayout2( static_cast( m_device ), - static_cast( m_image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return layout; - } - - // wrapper function for command vkGetImageSubresourceLayout2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Image::getSubresourceLayout2( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkGetImageSubresourceLayout2 && - "Function requires or or or " ); - - StructureChain structureChain; - SubresourceLayout2 & layout = structureChain.template get(); - getDispatcher()->vkGetImageSubresourceLayout2( static_cast( m_device ), - static_cast( m_image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return structureChain; - } - - // wrapper function for command vkCopyMemoryToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImage.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::copyMemoryToImage( const CopyMemoryToImageInfo & copyMemoryToImageInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToImage && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkCopyMemoryToImage( - static_cast( m_device ), reinterpret_cast( ©MemoryToImageInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMemoryToImage" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCopyImageToMemory, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemory.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::copyImageToMemory( const CopyImageToMemoryInfo & copyImageToMemoryInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToMemory && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkCopyImageToMemory( - static_cast( m_device ), reinterpret_cast( ©ImageToMemoryInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyImageToMemory" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCopyImageToImage, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImage.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::copyImageToImage( const CopyImageToImageInfo & copyImageToImageInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToImage && "Function requires or " ); - - Result result = static_cast( - getDispatcher()->vkCopyImageToImage( static_cast( m_device ), reinterpret_cast( ©ImageToImageInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyImageToImage" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkTransitionImageLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayout.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::transitionImageLayout( ArrayProxy const & transitions ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkTransitionImageLayout && - "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkTransitionImageLayout( - static_cast( m_device ), transitions.size(), reinterpret_cast( transitions.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::transitionImageLayout" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCmdPushDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet.html - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set, - ArrayProxy const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSet && "Function requires or " ); - - getDispatcher()->vkCmdPushDescriptorSet( static_cast( m_commandBuffer ), - static_cast( pipelineBindPoint ), - static_cast( layout ), - set, - descriptorWrites.size(), - reinterpret_cast( descriptorWrites.data() ) ); - } - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate.html - template - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplate( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set, - DataType const & data ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkCmdPushDescriptorSetWithTemplate && - "Function requires or or " ); - - getDispatcher()->vkCmdPushDescriptorSetWithTemplate( static_cast( m_commandBuffer ), - static_cast( descriptorUpdateTemplate ), - static_cast( layout ), - set, - reinterpret_cast( &data ) ); - } - - // wrapper function for command vkCmdBindDescriptorSets2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2.html - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2( const BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorSets2 && - "Function requires or " ); - - getDispatcher()->vkCmdBindDescriptorSets2( static_cast( m_commandBuffer ), - reinterpret_cast( &bindDescriptorSetsInfo ) ); - } - - // wrapper function for command vkCmdPushConstants2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2.html - VULKAN_HPP_INLINE void CommandBuffer::pushConstants2( const PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushConstants2 && "Function requires or " ); - - getDispatcher()->vkCmdPushConstants2( static_cast( m_commandBuffer ), - reinterpret_cast( &pushConstantsInfo ) ); - } - - // wrapper function for command vkCmdPushDescriptorSet2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2.html - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2( const PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSet2 && "Function requires or " ); - - getDispatcher()->vkCmdPushDescriptorSet2( static_cast( m_commandBuffer ), - reinterpret_cast( &pushDescriptorSetInfo ) ); - } - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2.html - VULKAN_HPP_INLINE void - CommandBuffer::pushDescriptorSetWithTemplate2( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetWithTemplate2 && - "Function requires or " ); - - getDispatcher()->vkCmdPushDescriptorSetWithTemplate2( - static_cast( m_commandBuffer ), reinterpret_cast( &pushDescriptorSetWithTemplateInfo ) ); - } - - // wrapper function for command vkCmdSetLineStipple, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStipple.html - VULKAN_HPP_INLINE void CommandBuffer::setLineStipple( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStipple && - "Function requires or or " ); - - getDispatcher()->vkCmdSetLineStipple( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); - } - - // wrapper function for command vkCmdBindIndexBuffer2, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2.html - VULKAN_HPP_INLINE void - CommandBuffer::bindIndexBuffer2( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset, DeviceSize size, IndexType indexType ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer2 && "Function requires or " ); - - getDispatcher()->vkCmdBindIndexBuffer2( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( size ), - static_cast( indexType ) ); - } - - // wrapper function for command vkGetRenderingAreaGranularity, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularity.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D Device::getRenderingAreaGranularity( const RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRenderingAreaGranularity && - "Function requires or " ); - - Extent2D granularity; - getDispatcher()->vkGetRenderingAreaGranularity( static_cast( m_device ), - reinterpret_cast( &renderingAreaInfo ), - reinterpret_cast( &granularity ) ); - - return granularity; - } - - // wrapper function for command vkCmdSetRenderingAttachmentLocations, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocations.html - VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocations( const RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingAttachmentLocations && - "Function requires or " ); - - getDispatcher()->vkCmdSetRenderingAttachmentLocations( static_cast( m_commandBuffer ), - reinterpret_cast( &locationInfo ) ); - } - - // wrapper function for command vkCmdSetRenderingInputAttachmentIndices, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndices.html - VULKAN_HPP_INLINE void - CommandBuffer::setRenderingInputAttachmentIndices( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingInputAttachmentIndices && - "Function requires or " ); - - getDispatcher()->vkCmdSetRenderingInputAttachmentIndices( static_cast( m_commandBuffer ), - reinterpret_cast( &inputAttachmentIndexInfo ) ); - } - - //=== VK_KHR_surface === - - // wrapper function for command vkGetPhysicalDeviceSurfaceSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceSupportKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getSurfaceSupportKHR( uint32_t queueFamilyIndex, VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR && "Function requires " ); - - Bool32 supported; - Result result = static_cast( getDispatcher()->vkGetPhysicalDeviceSurfaceSupportKHR( static_cast( m_physicalDevice ), - queueFamilyIndex, - static_cast( surface ), - reinterpret_cast( &supported ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceSupportKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( supported ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilitiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getSurfaceCapabilitiesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR && - "Function requires " ); - - SurfaceCapabilitiesKHR surfaceCapabilities; - Result result = static_cast( - getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilitiesKHR( static_cast( m_physicalDevice ), - static_cast( surface ), - reinterpret_cast( &surfaceCapabilities ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilitiesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceCapabilities ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormatsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormatsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormatsKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR && "Function requires " ); - - std::vector surfaceFormats; - uint32_t surfaceFormatCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( - static_cast( m_physicalDevice ), static_cast( surface ), &surfaceFormatCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - surfaceFormats.resize( surfaceFormatCount ); - result = - static_cast( getDispatcher()->vkGetPhysicalDeviceSurfaceFormatsKHR( static_cast( m_physicalDevice ), - static_cast( surface ), - &surfaceFormatCount, - reinterpret_cast( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormatsKHR" ); - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); - if ( surfaceFormatCount < surfaceFormats.size() ) - { - surfaceFormats.resize( surfaceFormatCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceFormats ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR && - "Function requires " ); - - std::vector presentModes; - uint32_t presentModeCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( - static_cast( m_physicalDevice ), static_cast( surface ), &presentModeCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentModeCount ) - { - presentModes.resize( presentModeCount ); - result = - static_cast( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModesKHR( static_cast( m_physicalDevice ), - static_cast( surface ), - &presentModeCount, - reinterpret_cast( presentModes.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModesKHR" ); - VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); - if ( presentModeCount < presentModes.size() ) - { - presentModes.resize( presentModeCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentModes ) ); - } - - //=== VK_KHR_swapchain === - - // wrapper function for command vkCreateSwapchainKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSwapchainKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createSwapchainKHR( SwapchainCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSwapchainKHR && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; - Result result = static_cast( getDispatcher()->vkCreateSwapchainKHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &swapchain ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSwapchainKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SwapchainKHR( *this, *reinterpret_cast( &swapchain ), allocator ) ); - } - - // wrapper function for command vkGetSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainImagesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type SwapchainKHR::getImages() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainImagesKHR && "Function requires " ); - - std::vector swapchainImages; - uint32_t swapchainImageCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetSwapchainImagesKHR( - static_cast( m_device ), static_cast( m_swapchainKHR ), &swapchainImageCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && swapchainImageCount ) - { - swapchainImages.resize( swapchainImageCount ); - result = static_cast( getDispatcher()->vkGetSwapchainImagesKHR( static_cast( m_device ), - static_cast( m_swapchainKHR ), - &swapchainImageCount, - reinterpret_cast( swapchainImages.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getImages" ); - VULKAN_HPP_ASSERT( swapchainImageCount <= swapchainImages.size() ); - if ( swapchainImageCount < swapchainImages.size() ) - { - swapchainImages.resize( swapchainImageCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( swapchainImages ) ); - } - - // wrapper function for command vkAcquireNextImageKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImageKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue - SwapchainKHR::acquireNextImage( uint64_t timeout, VULKAN_HPP_NAMESPACE::Semaphore semaphore, VULKAN_HPP_NAMESPACE::Fence fence ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImageKHR && "Function requires " ); - - uint32_t imageIndex; - Result result = static_cast( getDispatcher()->vkAcquireNextImageKHR( static_cast( m_device ), - static_cast( m_swapchainKHR ), - timeout, - static_cast( semaphore ), - static_cast( fence ), - &imageIndex ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::acquireNextImage", - { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::acquireNextImage", - { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); -# endif - - return ResultValue( result, std::move( imageIndex ) ); - } - - // wrapper function for command vkQueuePresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueuePresentKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Queue::presentKHR( const PresentInfoKHR & presentInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueuePresentKHR && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkQueuePresentKHR( static_cast( m_queue ), reinterpret_cast( &presentInfo ) ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::presentKHR", { Result::eSuccess, Result::eSuboptimalKHR } ); -# endif - - return static_cast( result ); - } - - // wrapper function for command vkGetDeviceGroupPresentCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPresentCapabilitiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getGroupPresentCapabilitiesKHR() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR && - "Function requires or " ); - - DeviceGroupPresentCapabilitiesKHR deviceGroupPresentCapabilities; - Result result = static_cast( getDispatcher()->vkGetDeviceGroupPresentCapabilitiesKHR( - static_cast( m_device ), reinterpret_cast( &deviceGroupPresentCapabilities ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getGroupPresentCapabilitiesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( deviceGroupPresentCapabilities ) ); - } - - // wrapper function for command vkGetDeviceGroupSurfacePresentModesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getGroupSurfacePresentModesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR && - "Function requires or " ); - - DeviceGroupPresentModeFlagsKHR modes; - Result result = static_cast( getDispatcher()->vkGetDeviceGroupSurfacePresentModesKHR( - static_cast( m_device ), static_cast( surface ), reinterpret_cast( &modes ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getGroupSurfacePresentModesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( modes ) ); - } - - // wrapper function for command vkGetPhysicalDevicePresentRectanglesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDevicePresentRectanglesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getPresentRectanglesKHR( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR && - "Function requires or " ); - - std::vector rects; - uint32_t rectCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR( - static_cast( m_physicalDevice ), static_cast( surface ), &rectCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && rectCount ) - { - rects.resize( rectCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDevicePresentRectanglesKHR( static_cast( m_physicalDevice ), - static_cast( surface ), - &rectCount, - reinterpret_cast( rects.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getPresentRectanglesKHR" ); - VULKAN_HPP_ASSERT( rectCount <= rects.size() ); - if ( rectCount < rects.size() ) - { - rects.resize( rectCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( rects ) ); - } - - // wrapper function for command vkAcquireNextImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireNextImage2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue Device::acquireNextImage2KHR( const AcquireNextImageInfoKHR & acquireInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireNextImage2KHR && "Function requires or " ); - - uint32_t imageIndex; - Result result = static_cast( getDispatcher()->vkAcquireNextImage2KHR( - static_cast( m_device ), reinterpret_cast( &acquireInfo ), &imageIndex ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::acquireNextImage2KHR", - { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::acquireNextImage2KHR", - { Result::eSuccess, Result::eTimeout, Result::eNotReady, Result::eSuboptimalKHR } ); -# endif - - return ResultValue( result, std::move( imageIndex ) ); - } - - //=== VK_KHR_display === - - // wrapper function for command vkGetPhysicalDeviceDisplayPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayPropertiesKHR() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR && - "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceDisplayPropertiesKHR( - static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayPropertiesKHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceDisplayPlanePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlanePropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPlanePropertiesKHR() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR && - "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceDisplayPlanePropertiesKHR( - static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlanePropertiesKHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetDisplayPlaneSupportedDisplaysKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneSupportedDisplaysKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR( uint32_t planeIndex ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneSupportedDisplaysKHR && - "Function requires " ); - - std::vector displays; - uint32_t displayCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetDisplayPlaneSupportedDisplaysKHR( static_cast( m_physicalDevice ), planeIndex, &displayCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && displayCount ) - { - displays.resize( displayCount ); - result = static_cast( getDispatcher()->vkGetDisplayPlaneSupportedDisplaysKHR( - static_cast( m_physicalDevice ), planeIndex, &displayCount, reinterpret_cast( displays.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneSupportedDisplaysKHR" ); - std::vector displaysRAII; - if ( result == Result::eSuccess ) - { - displaysRAII.reserve( displays.size() ); - for ( auto & display : displays ) - { - displaysRAII.emplace_back( *this, *reinterpret_cast( &display ) ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( displaysRAII ) ); - } - - // wrapper function for command vkGetDisplayModePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModePropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type DisplayKHR::getModeProperties() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModePropertiesKHR && "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetDisplayModePropertiesKHR( - static_cast( m_physicalDevice ), static_cast( m_displayKHR ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast( m_physicalDevice ), - static_cast( m_displayKHR ), - &propertyCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayKHR::getModeProperties" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkCreateDisplayModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayModeKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - DisplayKHR::createMode( DisplayModeCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDisplayModeKHR && "Function requires " ); - - VULKAN_HPP_NAMESPACE::DisplayModeKHR mode; - Result result = static_cast( getDispatcher()->vkCreateDisplayModeKHR( static_cast( m_physicalDevice ), - static_cast( m_displayKHR ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &mode ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayKHR::createMode" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, DisplayModeKHR( *this, *reinterpret_cast( &mode ) ) ); - } - - // wrapper function for command vkGetDisplayPlaneCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilitiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - DisplayModeKHR::getDisplayPlaneCapabilities( uint32_t planeIndex ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR && "Function requires " ); - - DisplayPlaneCapabilitiesKHR capabilities; - Result result = - static_cast( getDispatcher()->vkGetDisplayPlaneCapabilitiesKHR( static_cast( m_physicalDevice ), - static_cast( m_displayModeKHR ), - planeIndex, - reinterpret_cast( &capabilities ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayModeKHR::getDisplayPlaneCapabilities" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( capabilities ) ); - } - - // wrapper function for command vkCreateDisplayPlaneSurfaceKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDisplayPlaneSurfaceKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createDisplayPlaneSurfaceKHR( DisplaySurfaceCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDisplayPlaneSurfaceKHR && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = - static_cast( getDispatcher()->vkCreateDisplayPlaneSurfaceKHR( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createDisplayPlaneSurfaceKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } - - //=== VK_KHR_display_swapchain === - - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createSharedSwapchainsKHR( ArrayProxy const & createInfos, Optional allocator ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSharedSwapchainsKHR && "Function requires " ); - - std::vector swapchains( createInfos.size() ); - Result result = - static_cast( getDispatcher()->vkCreateSharedSwapchainsKHR( static_cast( m_device ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( swapchains.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSharedSwapchainsKHR" ); - std::vector swapchainsRAII; - if ( result == Result::eSuccess ) - { - swapchainsRAII.reserve( swapchains.size() ); - for ( auto & swapchain : swapchains ) - { - swapchainsRAII.emplace_back( *this, *reinterpret_cast( &swapchain ), allocator ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( swapchainsRAII ) ); - } - - // wrapper function for command vkCreateSharedSwapchainsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSharedSwapchainsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createSharedSwapchainKHR( SwapchainCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSharedSwapchainsKHR && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SwapchainKHR swapchain; - Result result = static_cast( getDispatcher()->vkCreateSharedSwapchainsKHR( static_cast( m_device ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &swapchain ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSharedSwapchainKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SwapchainKHR( *this, *reinterpret_cast( &swapchain ), allocator ) ); - } - -# if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - - // wrapper function for command vkCreateXlibSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXlibSurfaceKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createXlibSurfaceKHR( XlibSurfaceCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateXlibSurfaceKHR && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateXlibSurfaceKHR( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createXlibSurfaceKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } - - // wrapper function for command vkGetPhysicalDeviceXlibPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXlibPresentationSupportKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXlibPresentationSupportKHR( uint32_t queueFamilyIndex, - Display & dpy, - VisualID visualID ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR && - "Function requires " ); - - VkBool32 result = - getDispatcher()->vkGetPhysicalDeviceXlibPresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex, &dpy, visualID ); - - return static_cast( result ); - } -# endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -# if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - - // wrapper function for command vkCreateXcbSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateXcbSurfaceKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createXcbSurfaceKHR( XcbSurfaceCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateXcbSurfaceKHR && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateXcbSurfaceKHR( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createXcbSurfaceKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } - - // wrapper function for command vkGetPhysicalDeviceXcbPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceXcbPresentationSupportKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getXcbPresentationSupportKHR( uint32_t queueFamilyIndex, - xcb_connection_t & connection, - xcb_visualid_t visual_id ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR && - "Function requires " ); - - VkBool32 result = getDispatcher()->vkGetPhysicalDeviceXcbPresentationSupportKHR( - static_cast( m_physicalDevice ), queueFamilyIndex, &connection, visual_id ); - - return static_cast( result ); - } -# endif /*VK_USE_PLATFORM_XCB_KHR*/ - -# if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - - // wrapper function for command vkCreateWaylandSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWaylandSurfaceKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createWaylandSurfaceKHR( WaylandSurfaceCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateWaylandSurfaceKHR && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateWaylandSurfaceKHR( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createWaylandSurfaceKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } - - // wrapper function for command vkGetPhysicalDeviceWaylandPresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWaylandPresentationSupportKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWaylandPresentationSupportKHR( uint32_t queueFamilyIndex, - struct wl_display & display ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR && - "Function requires " ); - - VkBool32 result = - getDispatcher()->vkGetPhysicalDeviceWaylandPresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex, &display ); - - return static_cast( result ); - } -# endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - - // wrapper function for command vkCreateAndroidSurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAndroidSurfaceKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createAndroidSurfaceKHR( AndroidSurfaceCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateAndroidSurfaceKHR && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateAndroidSurfaceKHR( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createAndroidSurfaceKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - - // wrapper function for command vkCreateWin32SurfaceKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateWin32SurfaceKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createWin32SurfaceKHR( Win32SurfaceCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateWin32SurfaceKHR && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateWin32SurfaceKHR( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createWin32SurfaceKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } - - // wrapper function for command vkGetPhysicalDeviceWin32PresentationSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceWin32PresentationSupportKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getWin32PresentationSupportKHR( uint32_t queueFamilyIndex ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR && - "Function requires " ); - - VkBool32 result = getDispatcher()->vkGetPhysicalDeviceWin32PresentationSupportKHR( static_cast( m_physicalDevice ), queueFamilyIndex ); - - return static_cast( result ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - - // wrapper function for command vkCreateDebugReportCallbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugReportCallbackEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createDebugReportCallbackEXT( DebugReportCallbackCreateInfoEXT const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDebugReportCallbackEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT callback; - Result result = - static_cast( getDispatcher()->vkCreateDebugReportCallbackEXT( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &callback ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createDebugReportCallbackEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, DebugReportCallbackEXT( *this, *reinterpret_cast( &callback ), allocator ) ); - } - - // wrapper function for command vkDebugReportMessageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugReportMessageEXT.html - VULKAN_HPP_INLINE void Instance::debugReportMessageEXT( DebugReportFlagsEXT flags, - DebugReportObjectTypeEXT objectType_, - uint64_t object, - size_t location, - int32_t messageCode, - const std::string & layerPrefix, - const std::string & message ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkDebugReportMessageEXT && "Function requires " ); - - getDispatcher()->vkDebugReportMessageEXT( static_cast( m_instance ), - static_cast( flags ), - static_cast( objectType_ ), - object, - location, - messageCode, - layerPrefix.c_str(), - message.c_str() ); - } - - //=== VK_EXT_debug_marker === - - // wrapper function for command vkDebugMarkerSetObjectTagEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectTagEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::debugMarkerSetObjectTagEXT( const DebugMarkerObjectTagInfoEXT & tagInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectTagEXT && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkDebugMarkerSetObjectTagEXT( - static_cast( m_device ), reinterpret_cast( &tagInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::debugMarkerSetObjectTagEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkDebugMarkerSetObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDebugMarkerSetObjectNameEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::debugMarkerSetObjectNameEXT( const DebugMarkerObjectNameInfoEXT & nameInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkDebugMarkerSetObjectNameEXT && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkDebugMarkerSetObjectNameEXT( - static_cast( m_device ), reinterpret_cast( &nameInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::debugMarkerSetObjectNameEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCmdDebugMarkerBeginEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerBeginEXT.html - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerBeginEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerBeginEXT && "Function requires " ); - - getDispatcher()->vkCmdDebugMarkerBeginEXT( static_cast( m_commandBuffer ), - reinterpret_cast( &markerInfo ) ); - } - - // wrapper function for command vkCmdDebugMarkerEndEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerEndEXT.html - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerEndEXT() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerEndEXT && "Function requires " ); - - getDispatcher()->vkCmdDebugMarkerEndEXT( static_cast( m_commandBuffer ) ); - } - - // wrapper function for command vkCmdDebugMarkerInsertEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDebugMarkerInsertEXT.html - VULKAN_HPP_INLINE void CommandBuffer::debugMarkerInsertEXT( const DebugMarkerMarkerInfoEXT & markerInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDebugMarkerInsertEXT && "Function requires " ); - - getDispatcher()->vkCmdDebugMarkerInsertEXT( static_cast( m_commandBuffer ), - reinterpret_cast( &markerInfo ) ); - } - - //=== VK_KHR_video_queue === - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR * pVideoProfile, - VideoCapabilitiesKHR * pCapabilities ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR && - "Function requires " ); - return static_cast( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( pVideoProfile ), - reinterpret_cast( pCapabilities ) ) ); - } - - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR && - "Function requires " ); - - VideoCapabilitiesKHR capabilities; - Result result = - static_cast( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( &videoProfile ), - reinterpret_cast( &capabilities ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( capabilities ) ); - } - - // wrapper function for command vkGetPhysicalDeviceVideoCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoCapabilitiesKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getVideoCapabilitiesKHR( const VideoProfileInfoKHR & videoProfile ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR && - "Function requires " ); - - StructureChain structureChain; - VideoCapabilitiesKHR & capabilities = structureChain.template get(); - Result result = - static_cast( getDispatcher()->vkGetPhysicalDeviceVideoCapabilitiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( &videoProfile ), - reinterpret_cast( &capabilities ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoCapabilitiesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); - } - - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR && - "Function requires " ); - - std::vector videoFormatProperties; - uint32_t videoFormatPropertyCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( &videoFormatInfo ), - &videoFormatPropertyCount, - nullptr ) ); - if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) - { - videoFormatProperties.resize( videoFormatPropertyCount ); - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( &videoFormatInfo ), - &videoFormatPropertyCount, - reinterpret_cast( videoFormatProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); - VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); - if ( videoFormatPropertyCount < videoFormatProperties.size() ) - { - videoFormatProperties.resize( videoFormatPropertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( videoFormatProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceVideoFormatPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoFormatPropertiesKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getVideoFormatPropertiesKHR( const PhysicalDeviceVideoFormatInfoKHR & videoFormatInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR && - "Function requires " ); - - std::vector structureChains; - std::vector videoFormatProperties; - uint32_t videoFormatPropertyCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( &videoFormatInfo ), - &videoFormatPropertyCount, - nullptr ) ); - if ( ( result == Result::eSuccess ) && videoFormatPropertyCount ) - { - structureChains.resize( videoFormatPropertyCount ); - videoFormatProperties.resize( videoFormatPropertyCount ); - for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) - { - videoFormatProperties[i].pNext = structureChains[i].template get().pNext; - } - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceVideoFormatPropertiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( &videoFormatInfo ), - &videoFormatPropertyCount, - reinterpret_cast( videoFormatProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoFormatPropertiesKHR" ); - VULKAN_HPP_ASSERT( videoFormatPropertyCount <= videoFormatProperties.size() ); - if ( videoFormatPropertyCount < videoFormatProperties.size() ) - { - structureChains.resize( videoFormatPropertyCount ); - } - for ( uint32_t i = 0; i < videoFormatPropertyCount; i++ ) - { - structureChains[i].template get() = videoFormatProperties[i]; - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChains ) ); - } - - // wrapper function for command vkCreateVideoSessionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createVideoSessionKHR( VideoSessionCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateVideoSessionKHR && "Function requires " ); - - VULKAN_HPP_NAMESPACE::VideoSessionKHR videoSession; - Result result = static_cast( getDispatcher()->vkCreateVideoSessionKHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &videoSession ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createVideoSessionKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, VideoSessionKHR( *this, *reinterpret_cast( &videoSession ), allocator ) ); - } - - // wrapper function for command vkGetVideoSessionMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetVideoSessionMemoryRequirementsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - VideoSessionKHR::getMemoryRequirements() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR && - "Function requires " ); - - std::vector memoryRequirements; - uint32_t memoryRequirementsCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( - static_cast( m_device ), static_cast( m_videoSessionKHR ), &memoryRequirementsCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && memoryRequirementsCount ) - { - memoryRequirements.resize( memoryRequirementsCount ); - result = static_cast( - getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast( m_device ), - static_cast( m_videoSessionKHR ), - &memoryRequirementsCount, - reinterpret_cast( memoryRequirements.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::VideoSessionKHR::getMemoryRequirements" ); - VULKAN_HPP_ASSERT( memoryRequirementsCount <= memoryRequirements.size() ); - if ( memoryRequirementsCount < memoryRequirements.size() ) - { - memoryRequirements.resize( memoryRequirementsCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryRequirements ) ); - } - - // wrapper function for command vkBindVideoSessionMemoryKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindVideoSessionMemoryKHR.html - VULKAN_HPP_INLINE typename ResultValueType::type - VideoSessionKHR::bindMemory( ArrayProxy const & bindSessionMemoryInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBindVideoSessionMemoryKHR && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkBindVideoSessionMemoryKHR( static_cast( m_device ), - static_cast( m_videoSessionKHR ), - bindSessionMemoryInfos.size(), - reinterpret_cast( bindSessionMemoryInfos.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::VideoSessionKHR::bindMemory" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCreateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateVideoSessionParametersKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createVideoSessionParametersKHR( VideoSessionParametersCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateVideoSessionParametersKHR && "Function requires " ); - - VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR videoSessionParameters; - Result result = - static_cast( getDispatcher()->vkCreateVideoSessionParametersKHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &videoSessionParameters ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createVideoSessionParametersKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, VideoSessionParametersKHR( *this, *reinterpret_cast( &videoSessionParameters ), allocator ) ); - } - - // wrapper function for command vkUpdateVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateVideoSessionParametersKHR.html - VULKAN_HPP_INLINE typename ResultValueType::type VideoSessionParametersKHR::update( const VideoSessionParametersUpdateInfoKHR & updateInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateVideoSessionParametersKHR && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkUpdateVideoSessionParametersKHR( static_cast( m_device ), - static_cast( m_videoSessionParametersKHR ), - reinterpret_cast( &updateInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::VideoSessionParametersKHR::update" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCmdBeginVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginVideoCodingKHR.html - VULKAN_HPP_INLINE void CommandBuffer::beginVideoCodingKHR( const VideoBeginCodingInfoKHR & beginInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginVideoCodingKHR && "Function requires " ); - - getDispatcher()->vkCmdBeginVideoCodingKHR( static_cast( m_commandBuffer ), - reinterpret_cast( &beginInfo ) ); - } - - // wrapper function for command vkCmdEndVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndVideoCodingKHR.html - VULKAN_HPP_INLINE void CommandBuffer::endVideoCodingKHR( const VideoEndCodingInfoKHR & endCodingInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndVideoCodingKHR && "Function requires " ); - - getDispatcher()->vkCmdEndVideoCodingKHR( static_cast( m_commandBuffer ), - reinterpret_cast( &endCodingInfo ) ); - } - - // wrapper function for command vkCmdControlVideoCodingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdControlVideoCodingKHR.html - VULKAN_HPP_INLINE void CommandBuffer::controlVideoCodingKHR( const VideoCodingControlInfoKHR & codingControlInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdControlVideoCodingKHR && "Function requires " ); - - getDispatcher()->vkCmdControlVideoCodingKHR( static_cast( m_commandBuffer ), - reinterpret_cast( &codingControlInfo ) ); - } - - //=== VK_KHR_video_decode_queue === - - // wrapper function for command vkCmdDecodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecodeVideoKHR.html - VULKAN_HPP_INLINE void CommandBuffer::decodeVideoKHR( const VideoDecodeInfoKHR & decodeInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecodeVideoKHR && "Function requires " ); - - getDispatcher()->vkCmdDecodeVideoKHR( static_cast( m_commandBuffer ), reinterpret_cast( &decodeInfo ) ); - } - - //=== VK_EXT_transform_feedback === - - // wrapper function for command vkCmdBindTransformFeedbackBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTransformFeedbackBuffersEXT.html - VULKAN_HPP_INLINE void CommandBuffer::bindTransformFeedbackBuffersEXT( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT && - "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); - VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); -# else - if ( buffers.size() != offsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != offsets.size()" ); - } - if ( !sizes.empty() && buffers.size() != sizes.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindTransformFeedbackBuffersEXT: buffers.size() != sizes.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdBindTransformFeedbackBuffersEXT( static_cast( m_commandBuffer ), - firstBinding, - buffers.size(), - reinterpret_cast( buffers.data() ), - reinterpret_cast( offsets.data() ), - reinterpret_cast( sizes.data() ) ); - } - - // wrapper function for command vkCmdBeginTransformFeedbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginTransformFeedbackEXT.html - VULKAN_HPP_INLINE void CommandBuffer::beginTransformFeedbackEXT( uint32_t firstCounterBuffer, - ArrayProxy const & counterBuffers, - ArrayProxy const & counterBufferOffsets ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginTransformFeedbackEXT && "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); -# else - if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::beginTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdBeginTransformFeedbackEXT( static_cast( m_commandBuffer ), - firstCounterBuffer, - counterBuffers.size(), - reinterpret_cast( counterBuffers.data() ), - reinterpret_cast( counterBufferOffsets.data() ) ); - } - - // wrapper function for command vkCmdEndTransformFeedbackEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndTransformFeedbackEXT.html - VULKAN_HPP_INLINE void CommandBuffer::endTransformFeedbackEXT( uint32_t firstCounterBuffer, - ArrayProxy const & counterBuffers, - ArrayProxy const & counterBufferOffsets ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndTransformFeedbackEXT && "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( counterBufferOffsets.empty() || counterBuffers.size() == counterBufferOffsets.size() ); -# else - if ( !counterBufferOffsets.empty() && counterBuffers.size() != counterBufferOffsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::endTransformFeedbackEXT: counterBuffers.size() != counterBufferOffsets.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdEndTransformFeedbackEXT( static_cast( m_commandBuffer ), - firstCounterBuffer, - counterBuffers.size(), - reinterpret_cast( counterBuffers.data() ), - reinterpret_cast( counterBufferOffsets.data() ) ); - } - - // wrapper function for command vkCmdBeginQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginQueryIndexedEXT.html - VULKAN_HPP_INLINE void CommandBuffer::beginQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, - uint32_t query, - QueryControlFlags flags, - uint32_t index ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginQueryIndexedEXT && "Function requires " ); - - getDispatcher()->vkCmdBeginQueryIndexedEXT( - static_cast( m_commandBuffer ), static_cast( queryPool ), query, static_cast( flags ), index ); - } - - // wrapper function for command vkCmdEndQueryIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndQueryIndexedEXT.html - VULKAN_HPP_INLINE void - CommandBuffer::endQueryIndexedEXT( VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query, uint32_t index ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndQueryIndexedEXT && "Function requires " ); - - getDispatcher()->vkCmdEndQueryIndexedEXT( static_cast( m_commandBuffer ), static_cast( queryPool ), query, index ); - } - - // wrapper function for command vkCmdDrawIndirectByteCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectByteCountEXT.html - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectByteCountEXT( uint32_t instanceCount, - uint32_t firstInstance, - VULKAN_HPP_NAMESPACE::Buffer counterBuffer, - DeviceSize counterBufferOffset, - uint32_t counterOffset, - uint32_t vertexStride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectByteCountEXT && "Function requires " ); - - getDispatcher()->vkCmdDrawIndirectByteCountEXT( static_cast( m_commandBuffer ), - instanceCount, - firstInstance, - static_cast( counterBuffer ), - static_cast( counterBufferOffset ), - counterOffset, - vertexStride ); - } - - //=== VK_NVX_binary_import === - - // wrapper function for command vkCreateCuModuleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuModuleNVX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createCuModuleNVX( CuModuleCreateInfoNVX const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateCuModuleNVX && "Function requires " ); - - VULKAN_HPP_NAMESPACE::CuModuleNVX module; - Result result = static_cast( getDispatcher()->vkCreateCuModuleNVX( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &module ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createCuModuleNVX" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, CuModuleNVX( *this, *reinterpret_cast( &module ), allocator ) ); - } - - // wrapper function for command vkCreateCuFunctionNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCuFunctionNVX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createCuFunctionNVX( CuFunctionCreateInfoNVX const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateCuFunctionNVX && "Function requires " ); - - VULKAN_HPP_NAMESPACE::CuFunctionNVX function; - Result result = static_cast( getDispatcher()->vkCreateCuFunctionNVX( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &function ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createCuFunctionNVX" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, - CuFunctionNVX( *this, *reinterpret_cast( &function ), allocator ) ); - } - - // wrapper function for command vkCmdCuLaunchKernelNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCuLaunchKernelNVX.html - VULKAN_HPP_INLINE void CommandBuffer::cuLaunchKernelNVX( const CuLaunchInfoNVX & launchInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCuLaunchKernelNVX && "Function requires " ); - - getDispatcher()->vkCmdCuLaunchKernelNVX( static_cast( m_commandBuffer ), reinterpret_cast( &launchInfo ) ); - } - - //=== VK_NVX_image_view_handle === - - // wrapper function for command vkGetImageViewHandleNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandleNVX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t Device::getImageViewHandleNVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewHandleNVX && "Function requires " ); - - uint32_t result = - getDispatcher()->vkGetImageViewHandleNVX( static_cast( m_device ), reinterpret_cast( &info ) ); - - return result; - } - - // wrapper function for command vkGetImageViewHandle64NVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewHandle64NVX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getImageViewHandle64NVX( const ImageViewHandleInfoNVX & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewHandle64NVX && "Function requires " ); - - uint64_t result = - getDispatcher()->vkGetImageViewHandle64NVX( static_cast( m_device ), reinterpret_cast( &info ) ); - - return result; - } - - // wrapper function for command vkGetImageViewAddressNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewAddressNVX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type ImageView::getAddressNVX() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewAddressNVX && "Function requires " ); - - ImageViewAddressPropertiesNVX properties; - Result result = static_cast( getDispatcher()->vkGetImageViewAddressNVX( - static_cast( m_device ), static_cast( m_imageView ), reinterpret_cast( &properties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::ImageView::getAddressNVX" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetDeviceCombinedImageSamplerIndexNVX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceCombinedImageSamplerIndexNVX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getCombinedImageSamplerIndexNVX( uint64_t imageViewIndex, - uint64_t samplerIndex ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceCombinedImageSamplerIndexNVX && - "Function requires " ); - - uint64_t result = getDispatcher()->vkGetDeviceCombinedImageSamplerIndexNVX( static_cast( m_device ), imageViewIndex, samplerIndex ); - - return result; - } - - //=== VK_AMD_draw_indirect_count === - - // wrapper function for command vkCmdDrawIndirectCountAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountAMD.html - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountAMD && - "Function requires or or " ); - - getDispatcher()->vkCmdDrawIndirectCountAMD( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - // wrapper function for command vkCmdDrawIndexedIndirectCountAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountAMD.html - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountAMD( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkCmdDrawIndexedIndirectCountAMD && - "Function requires or or " ); - - getDispatcher()->vkCmdDrawIndexedIndirectCountAMD( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - //=== VK_AMD_shader_info === - - // wrapper function for command vkGetShaderInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderInfoAMD.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Pipeline::getShaderInfoAMD( ShaderStageFlagBits shaderStage, - ShaderInfoTypeAMD infoType ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderInfoAMD && "Function requires " ); - - std::vector info; - size_t infoSize; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetShaderInfoAMD( static_cast( m_device ), - static_cast( m_pipeline ), - static_cast( shaderStage ), - static_cast( infoType ), - &infoSize, - nullptr ) ); - if ( ( result == Result::eSuccess ) && infoSize ) - { - info.resize( infoSize ); - result = static_cast( getDispatcher()->vkGetShaderInfoAMD( static_cast( m_device ), - static_cast( m_pipeline ), - static_cast( shaderStage ), - static_cast( infoType ), - &infoSize, - reinterpret_cast( info.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getShaderInfoAMD" ); - VULKAN_HPP_ASSERT( infoSize <= info.size() ); - if ( infoSize < info.size() ) - { - info.resize( infoSize ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( info ) ); - } - - //=== VK_KHR_dynamic_rendering === - - // wrapper function for command vkCmdBeginRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderingKHR.html - VULKAN_HPP_INLINE void CommandBuffer::beginRenderingKHR( const RenderingInfo & renderingInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderingKHR && - "Function requires or " ); - - getDispatcher()->vkCmdBeginRenderingKHR( static_cast( m_commandBuffer ), reinterpret_cast( &renderingInfo ) ); - } - - // wrapper function for command vkCmdEndRenderingKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderingKHR.html - VULKAN_HPP_INLINE void CommandBuffer::endRenderingKHR() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderingKHR && "Function requires or " ); - - getDispatcher()->vkCmdEndRenderingKHR( static_cast( m_commandBuffer ) ); - } - -# if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - - // wrapper function for command vkCreateStreamDescriptorSurfaceGGP, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateStreamDescriptorSurfaceGGP.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createStreamDescriptorSurfaceGGP( StreamDescriptorSurfaceCreateInfoGGP const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateStreamDescriptorSurfaceGGP && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( - getDispatcher()->vkCreateStreamDescriptorSurfaceGGP( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createStreamDescriptorSurfaceGGP" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } -# endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalImageFormatPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalImageFormatPropertiesNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getExternalImageFormatPropertiesNV( Format format, - ImageType type, - ImageTiling tiling, - ImageUsageFlags usage, - ImageCreateFlags flags, - ExternalMemoryHandleTypeFlagsNV externalHandleType ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV && - "Function requires " ); - - ExternalImageFormatPropertiesNV externalImageFormatProperties; - Result result = static_cast( getDispatcher()->vkGetPhysicalDeviceExternalImageFormatPropertiesNV( - static_cast( m_physicalDevice ), - static_cast( format ), - static_cast( type ), - static_cast( tiling ), - static_cast( usage ), - static_cast( flags ), - static_cast( externalHandleType ), - reinterpret_cast( &externalImageFormatProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getExternalImageFormatPropertiesNV" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( externalImageFormatProperties ) ); - } - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_external_memory_win32 === - - // wrapper function for command vkGetMemoryWin32HandleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - DeviceMemory::getMemoryWin32HandleNV( ExternalMemoryHandleTypeFlagsNV handleType ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleNV && "Function requires " ); - - HANDLE handle; - Result result = static_cast( getDispatcher()->vkGetMemoryWin32HandleNV( static_cast( m_device ), - static_cast( m_deviceMemory ), - static_cast( handleType ), - &handle ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_get_physical_device_properties2 === - - // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceFeatures2 PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2KHR && - "Function requires or " ); - - PhysicalDeviceFeatures2 features; - getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &features ) ); - - return features; - } - - // wrapper function for command vkGetPhysicalDeviceFeatures2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFeatures2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFeatures2KHR() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFeatures2KHR && - "Function requires or " ); - - StructureChain structureChain; - PhysicalDeviceFeatures2 & features = structureChain.template get(); - getDispatcher()->vkGetPhysicalDeviceFeatures2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &features ) ); - - return structureChain; - } - - // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceProperties2 PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2KHR && - "Function requires or " ); - - PhysicalDeviceProperties2 properties; - getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &properties ) ); - - return properties; - } - - // wrapper function for command vkGetPhysicalDeviceProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceProperties2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getProperties2KHR() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceProperties2KHR && - "Function requires or " ); - - StructureChain structureChain; - PhysicalDeviceProperties2 & properties = structureChain.template get(); - getDispatcher()->vkGetPhysicalDeviceProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &properties ) ); - - return structureChain; - } - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE FormatProperties2 PhysicalDevice::getFormatProperties2KHR( Format format ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR && - "Function requires or " ); - - FormatProperties2 formatProperties; - getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR( - static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); - - return formatProperties; - } - - // wrapper function for command vkGetPhysicalDeviceFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFormatProperties2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getFormatProperties2KHR( Format format ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR && - "Function requires or " ); - - StructureChain structureChain; - FormatProperties2 & formatProperties = structureChain.template get(); - getDispatcher()->vkGetPhysicalDeviceFormatProperties2KHR( - static_cast( m_physicalDevice ), static_cast( format ), reinterpret_cast( &formatProperties ) ); - - return structureChain; - } - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getImageFormatProperties2KHR( - const PhysicalDeviceImageFormatInfo2 * pImageFormatInfo, ImageFormatProperties2 * pImageFormatProperties ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR && - "Function requires or " ); - return static_cast( - getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( pImageFormatInfo ), - reinterpret_cast( pImageFormatProperties ) ) ); - } - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR && - "Function requires or " ); - - ImageFormatProperties2 imageFormatProperties; - Result result = static_cast( - getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &imageFormatInfo ), - reinterpret_cast( &imageFormatProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceImageFormatProperties2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getImageFormatProperties2KHR( const PhysicalDeviceImageFormatInfo2 & imageFormatInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR && - "Function requires or " ); - - StructureChain structureChain; - ImageFormatProperties2 & imageFormatProperties = structureChain.template get(); - Result result = static_cast( - getDispatcher()->vkGetPhysicalDeviceImageFormatProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &imageFormatInfo ), - reinterpret_cast( &imageFormatProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getImageFormatProperties2KHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2KHR() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR && - "Function requires or " ); - - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast( m_physicalDevice ), - &queueFamilyPropertyCount, - reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - queueFamilyProperties.resize( queueFamilyPropertyCount ); - } - return queueFamilyProperties; - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyProperties2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector PhysicalDevice::getQueueFamilyProperties2KHR() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR && - "Function requires or " ); - - std::vector structureChains; - std::vector queueFamilyProperties; - uint32_t queueFamilyPropertyCount; - getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast( m_physicalDevice ), &queueFamilyPropertyCount, nullptr ); - structureChains.resize( queueFamilyPropertyCount ); - queueFamilyProperties.resize( queueFamilyPropertyCount ); - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - queueFamilyProperties[i].pNext = structureChains[i].template get().pNext; - } - getDispatcher()->vkGetPhysicalDeviceQueueFamilyProperties2KHR( static_cast( m_physicalDevice ), - &queueFamilyPropertyCount, - reinterpret_cast( queueFamilyProperties.data() ) ); - - VULKAN_HPP_ASSERT( queueFamilyPropertyCount <= queueFamilyProperties.size() ); - if ( queueFamilyPropertyCount < queueFamilyProperties.size() ) - { - structureChains.resize( queueFamilyPropertyCount ); - } - for ( uint32_t i = 0; i < queueFamilyPropertyCount; i++ ) - { - structureChains[i].template get() = queueFamilyProperties[i]; - } - return structureChains; - } - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PhysicalDeviceMemoryProperties2 PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR && - "Function requires or " ); - - PhysicalDeviceMemoryProperties2 memoryProperties; - getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &memoryProperties ) ); - - return memoryProperties; - } - - // wrapper function for command vkGetPhysicalDeviceMemoryProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMemoryProperties2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain PhysicalDevice::getMemoryProperties2KHR() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR && - "Function requires or " ); - - StructureChain structureChain; - PhysicalDeviceMemoryProperties2 & memoryProperties = structureChain.template get(); - getDispatcher()->vkGetPhysicalDeviceMemoryProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &memoryProperties ) ); - - return structureChain; - } - - // wrapper function for command vkGetPhysicalDeviceSparseImageFormatProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - PhysicalDevice::getSparseImageFormatProperties2KHR( const PhysicalDeviceSparseImageFormatInfo2 & formatInfo ) const - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR && - "Function requires or " ); - - std::vector properties; - uint32_t propertyCount; - getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &formatInfo ), - &propertyCount, - nullptr ); - properties.resize( propertyCount ); - getDispatcher()->vkGetPhysicalDeviceSparseImageFormatProperties2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &formatInfo ), - &propertyCount, - reinterpret_cast( properties.data() ) ); - - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return properties; - } - - //=== VK_KHR_device_group === - - // wrapper function for command vkGetDeviceGroupPeerMemoryFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupPeerMemoryFeaturesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE PeerMemoryFeatureFlags Device::getGroupPeerMemoryFeaturesKHR( uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR && - "Function requires or " ); - - PeerMemoryFeatureFlags peerMemoryFeatures; - getDispatcher()->vkGetDeviceGroupPeerMemoryFeaturesKHR( static_cast( m_device ), - heapIndex, - localDeviceIndex, - remoteDeviceIndex, - reinterpret_cast( &peerMemoryFeatures ) ); - - return peerMemoryFeatures; - } - - // wrapper function for command vkCmdSetDeviceMaskKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDeviceMaskKHR.html - VULKAN_HPP_INLINE void CommandBuffer::setDeviceMaskKHR( uint32_t deviceMask ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDeviceMaskKHR && "Function requires or " ); - - getDispatcher()->vkCmdSetDeviceMaskKHR( static_cast( m_commandBuffer ), deviceMask ); - } - - // wrapper function for command vkCmdDispatchBaseKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchBaseKHR.html - VULKAN_HPP_INLINE void CommandBuffer::dispatchBaseKHR( uint32_t baseGroupX, - uint32_t baseGroupY, - uint32_t baseGroupZ, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchBaseKHR && "Function requires or " ); - - getDispatcher()->vkCmdDispatchBaseKHR( - static_cast( m_commandBuffer ), baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ ); - } - -# if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - - // wrapper function for command vkCreateViSurfaceNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateViSurfaceNN.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createViSurfaceNN( ViSurfaceCreateInfoNN const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateViSurfaceNN && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateViSurfaceNN( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createViSurfaceNN" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } -# endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_KHR_maintenance1 === - - // wrapper function for command vkTrimCommandPoolKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTrimCommandPoolKHR.html - VULKAN_HPP_INLINE void CommandPool::trimKHR( CommandPoolTrimFlags flags ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkTrimCommandPoolKHR && "Function requires or " ); - - getDispatcher()->vkTrimCommandPoolKHR( - static_cast( m_device ), static_cast( m_commandPool ), static_cast( flags ) ); - } - - //=== VK_KHR_device_group_creation === - - // wrapper function for command vkEnumeratePhysicalDeviceGroupsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceGroupsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Instance::enumeratePhysicalDeviceGroupsKHR() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR && - "Function requires or " ); - - std::vector physicalDeviceGroupProperties; - uint32_t physicalDeviceGroupCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( static_cast( m_instance ), &physicalDeviceGroupCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && physicalDeviceGroupCount ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - result = static_cast( getDispatcher()->vkEnumeratePhysicalDeviceGroupsKHR( - static_cast( m_instance ), - &physicalDeviceGroupCount, - reinterpret_cast( physicalDeviceGroupProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::enumeratePhysicalDeviceGroupsKHR" ); - VULKAN_HPP_ASSERT( physicalDeviceGroupCount <= physicalDeviceGroupProperties.size() ); - if ( physicalDeviceGroupCount < physicalDeviceGroupProperties.size() ) - { - physicalDeviceGroupProperties.resize( physicalDeviceGroupCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( physicalDeviceGroupProperties ) ); - } - - //=== VK_KHR_external_memory_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalBufferPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalBufferPropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalBufferProperties - PhysicalDevice::getExternalBufferPropertiesKHR( const PhysicalDeviceExternalBufferInfo & externalBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR && - "Function requires or " ); - - ExternalBufferProperties externalBufferProperties; - getDispatcher()->vkGetPhysicalDeviceExternalBufferPropertiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( &externalBufferInfo ), - reinterpret_cast( &externalBufferProperties ) ); - - return externalBufferProperties; - } - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_memory_win32 === - - // wrapper function for command vkGetMemoryWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandleKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryWin32HandleKHR( const MemoryGetWin32HandleInfoKHR & getWin32HandleInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleKHR && "Function requires " ); - - HANDLE handle; - Result result = static_cast( getDispatcher()->vkGetMemoryWin32HandleKHR( - static_cast( m_device ), reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryWin32HandleKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); - } - - // wrapper function for command vkGetMemoryWin32HandlePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryWin32HandlePropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryWin32HandlePropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, HANDLE handle ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR && - "Function requires " ); - - MemoryWin32HandlePropertiesKHR memoryWin32HandleProperties; - Result result = static_cast( - getDispatcher()->vkGetMemoryWin32HandlePropertiesKHR( static_cast( m_device ), - static_cast( handleType ), - handle, - reinterpret_cast( &memoryWin32HandleProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryWin32HandlePropertiesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryWin32HandleProperties ) ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_memory_fd === - - // wrapper function for command vkGetMemoryFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getMemoryFdKHR( const MemoryGetFdInfoKHR & getFdInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdKHR && "Function requires " ); - - int fd; - Result result = static_cast( - getDispatcher()->vkGetMemoryFdKHR( static_cast( m_device ), reinterpret_cast( &getFdInfo ), &fd ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryFdKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fd ) ); - } - - // wrapper function for command vkGetMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryFdPropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryFdPropertiesKHR( ExternalMemoryHandleTypeFlagBits handleType, int fd ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryFdPropertiesKHR && "Function requires " ); - - MemoryFdPropertiesKHR memoryFdProperties; - Result result = static_cast( getDispatcher()->vkGetMemoryFdPropertiesKHR( static_cast( m_device ), - static_cast( handleType ), - fd, - reinterpret_cast( &memoryFdProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryFdPropertiesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryFdProperties ) ); - } - - //=== VK_KHR_external_semaphore_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalSemaphorePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalSemaphorePropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalSemaphoreProperties - PhysicalDevice::getExternalSemaphorePropertiesKHR( const PhysicalDeviceExternalSemaphoreInfo & externalSemaphoreInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR && - "Function requires or " ); - - ExternalSemaphoreProperties externalSemaphoreProperties; - getDispatcher()->vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( - static_cast( m_physicalDevice ), - reinterpret_cast( &externalSemaphoreInfo ), - reinterpret_cast( &externalSemaphoreProperties ) ); - - return externalSemaphoreProperties; - } - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_semaphore_win32 === - - // wrapper function for command vkImportSemaphoreWin32HandleKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreWin32HandleKHR.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::importSemaphoreWin32HandleKHR( const ImportSemaphoreWin32HandleInfoKHR & importSemaphoreWin32HandleInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreWin32HandleKHR && - "Function requires " ); - - Result result = static_cast( getDispatcher()->vkImportSemaphoreWin32HandleKHR( - static_cast( m_device ), reinterpret_cast( &importSemaphoreWin32HandleInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::importSemaphoreWin32HandleKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetSemaphoreWin32HandleKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreWin32HandleKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getSemaphoreWin32HandleKHR( const SemaphoreGetWin32HandleInfoKHR & getWin32HandleInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreWin32HandleKHR && - "Function requires " ); - - HANDLE handle; - Result result = static_cast( getDispatcher()->vkGetSemaphoreWin32HandleKHR( - static_cast( m_device ), reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getSemaphoreWin32HandleKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_semaphore_fd === - - // wrapper function for command vkImportSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreFdKHR.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::importSemaphoreFdKHR( const ImportSemaphoreFdInfoKHR & importSemaphoreFdInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreFdKHR && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkImportSemaphoreFdKHR( - static_cast( m_device ), reinterpret_cast( &importSemaphoreFdInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::importSemaphoreFdKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetSemaphoreFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreFdKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getSemaphoreFdKHR( const SemaphoreGetFdInfoKHR & getFdInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreFdKHR && "Function requires " ); - - int fd; - Result result = static_cast( - getDispatcher()->vkGetSemaphoreFdKHR( static_cast( m_device ), reinterpret_cast( &getFdInfo ), &fd ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getSemaphoreFdKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fd ) ); - } - - //=== VK_KHR_push_descriptor === - - // wrapper function for command vkCmdPushDescriptorSetKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetKHR.html - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetKHR( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set, - ArrayProxy const & descriptorWrites ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetKHR && - "Function requires or " ); - - getDispatcher()->vkCmdPushDescriptorSetKHR( static_cast( m_commandBuffer ), - static_cast( pipelineBindPoint ), - static_cast( layout ), - set, - descriptorWrites.size(), - reinterpret_cast( descriptorWrites.data() ) ); - } - - // wrapper function for command vkCmdPushDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplateKHR.html - template - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSetWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set, - DataType const & data ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR && - "Function requires or or " ); - - getDispatcher()->vkCmdPushDescriptorSetWithTemplateKHR( static_cast( m_commandBuffer ), - static_cast( descriptorUpdateTemplate ), - static_cast( layout ), - set, - reinterpret_cast( &data ) ); - } - - //=== VK_EXT_conditional_rendering === - - // wrapper function for command vkCmdBeginConditionalRenderingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginConditionalRenderingEXT.html - VULKAN_HPP_INLINE void - CommandBuffer::beginConditionalRenderingEXT( const ConditionalRenderingBeginInfoEXT & conditionalRenderingBegin ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginConditionalRenderingEXT && - "Function requires " ); - - getDispatcher()->vkCmdBeginConditionalRenderingEXT( static_cast( m_commandBuffer ), - reinterpret_cast( &conditionalRenderingBegin ) ); - } - - // wrapper function for command vkCmdEndConditionalRenderingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndConditionalRenderingEXT.html - VULKAN_HPP_INLINE void CommandBuffer::endConditionalRenderingEXT() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndConditionalRenderingEXT && - "Function requires " ); - - getDispatcher()->vkCmdEndConditionalRenderingEXT( static_cast( m_commandBuffer ) ); - } - - //=== VK_KHR_descriptor_update_template === - - // wrapper function for command vkCreateDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDescriptorUpdateTemplateKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createDescriptorUpdateTemplateKHR( DescriptorUpdateTemplateCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDescriptorUpdateTemplateKHR && - "Function requires or " ); - - VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate; - Result result = static_cast( - getDispatcher()->vkCreateDescriptorUpdateTemplateKHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &descriptorUpdateTemplate ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDescriptorUpdateTemplateKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, DescriptorUpdateTemplate( *this, *reinterpret_cast( &descriptorUpdateTemplate ), allocator ) ); - } - - // wrapper function for command vkDestroyDescriptorUpdateTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyDescriptorUpdateTemplateKHR.html - VULKAN_HPP_INLINE void Device::destroyDescriptorUpdateTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - Optional allocator ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR && - "Function requires or " ); - - getDispatcher()->vkDestroyDescriptorUpdateTemplateKHR( static_cast( m_device ), - static_cast( descriptorUpdateTemplate ), - reinterpret_cast( allocator.get() ) ); - } - - // wrapper function for command vkUpdateDescriptorSetWithTemplateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateDescriptorSetWithTemplateKHR.html - template - VULKAN_HPP_INLINE void DescriptorSet::updateWithTemplateKHR( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate descriptorUpdateTemplate, - DataType const & data ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR && - "Function requires or " ); - - getDispatcher()->vkUpdateDescriptorSetWithTemplateKHR( static_cast( m_device ), - static_cast( m_descriptorSet ), - static_cast( descriptorUpdateTemplate ), - reinterpret_cast( &data ) ); - } - - //=== VK_NV_clip_space_w_scaling === - - // wrapper function for command vkCmdSetViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingNV.html - VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingNV( uint32_t firstViewport, - ArrayProxy const & viewportWScalings ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWScalingNV && "Function requires " ); - - getDispatcher()->vkCmdSetViewportWScalingNV( static_cast( m_commandBuffer ), - firstViewport, - viewportWScalings.size(), - reinterpret_cast( viewportWScalings.data() ) ); - } - -# if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) - //=== VK_EXT_acquire_xlib_display === - - // wrapper function for command vkAcquireXlibDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireXlibDisplayEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::acquireXlibDisplayEXT( Display & dpy, - VULKAN_HPP_NAMESPACE::DisplayKHR display ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireXlibDisplayEXT && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkAcquireXlibDisplayEXT( static_cast( m_physicalDevice ), &dpy, static_cast( display ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::acquireXlibDisplayEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetRandROutputDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRandROutputDisplayEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getRandROutputDisplayEXT( Display & dpy, RROutput rrOutput ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRandROutputDisplayEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::DisplayKHR display; - Result result = static_cast( getDispatcher()->vkGetRandROutputDisplayEXT( - static_cast( m_physicalDevice ), &dpy, rrOutput, reinterpret_cast( &display ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getRandROutputDisplayEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, DisplayKHR( *this, *reinterpret_cast( &display ) ) ); - } -# endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ - - //=== VK_EXT_display_surface_counter === - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2EXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getSurfaceCapabilities2EXT( VULKAN_HPP_NAMESPACE::SurfaceKHR surface ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT && - "Function requires " ); - - SurfaceCapabilities2EXT surfaceCapabilities; - Result result = static_cast( - getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2EXT( static_cast( m_physicalDevice ), - static_cast( surface ), - reinterpret_cast( &surfaceCapabilities ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2EXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceCapabilities ) ); - } - - //=== VK_EXT_display_control === - - // wrapper function for command vkDisplayPowerControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDisplayPowerControlEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::displayPowerControlEXT( VULKAN_HPP_NAMESPACE::DisplayKHR display, - const DisplayPowerInfoEXT & displayPowerInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkDisplayPowerControlEXT && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkDisplayPowerControlEXT( - static_cast( m_device ), static_cast( display ), reinterpret_cast( &displayPowerInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::displayPowerControlEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkRegisterDeviceEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDeviceEventEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::registerEventEXT( DeviceEventInfoEXT const & deviceEventInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkRegisterDeviceEventEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Fence fence; - Result result = static_cast( getDispatcher()->vkRegisterDeviceEventEXT( static_cast( m_device ), - reinterpret_cast( &deviceEventInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &fence ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::registerEventEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Fence( *this, *reinterpret_cast( &fence ), allocator ) ); - } - - // wrapper function for command vkRegisterDisplayEventEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterDisplayEventEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::registerDisplayEventEXT( DisplayKHR const & display, - DisplayEventInfoEXT const & displayEventInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkRegisterDisplayEventEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Fence fence; - Result result = static_cast( getDispatcher()->vkRegisterDisplayEventEXT( static_cast( m_device ), - static_cast( *display ), - reinterpret_cast( &displayEventInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &fence ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::registerDisplayEventEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Fence( *this, *reinterpret_cast( &fence ), allocator ) ); - } - - // wrapper function for command vkGetSwapchainCounterEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainCounterEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - ResultValue -# else - typename ResultValueType::type -# endif - SwapchainKHR::getCounterEXT( SurfaceCounterFlagBitsEXT counter ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainCounterEXT && "Function requires " ); - - uint64_t counterValue; - Result result = static_cast( getDispatcher()->vkGetSwapchainCounterEXT( static_cast( m_device ), - static_cast( m_swapchainKHR ), - static_cast( counter ), - &counterValue ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT", { Result::eSuccess, Result::eErrorOutOfDateKHR } ); -# else - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT" ); -# endif - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - return ResultValue( result, std::move( counterValue ) ); -# else - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( counterValue ) ); -# endif - } - - //=== VK_GOOGLE_display_timing === - - // wrapper function for command vkGetRefreshCycleDurationGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRefreshCycleDurationGOOGLE.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type SwapchainKHR::getRefreshCycleDurationGOOGLE() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRefreshCycleDurationGOOGLE && "Function requires " ); - - RefreshCycleDurationGOOGLE displayTimingProperties; - Result result = - static_cast( getDispatcher()->vkGetRefreshCycleDurationGOOGLE( static_cast( m_device ), - static_cast( m_swapchainKHR ), - reinterpret_cast( &displayTimingProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( displayTimingProperties ) ); - } - - // wrapper function for command vkGetPastPresentationTimingGOOGLE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingGOOGLE.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - ResultValue> -# else - typename ResultValueType>::type -# endif - SwapchainKHR::getPastPresentationTimingGOOGLE() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPastPresentationTimingGOOGLE && - "Function requires " ); - - std::vector presentationTimings; - uint32_t presentationTimingCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetPastPresentationTimingGOOGLE( - static_cast( m_device ), static_cast( m_swapchainKHR ), &presentationTimingCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && presentationTimingCount ) - { - presentationTimings.resize( presentationTimingCount ); - result = static_cast( - getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast( m_device ), - static_cast( m_swapchainKHR ), - &presentationTimingCount, - reinterpret_cast( presentationTimings.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getPastPresentationTimingGOOGLE", - { Result::eSuccess, Result::eIncomplete, Result::eErrorOutOfDateKHR } ); -# else - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getPastPresentationTimingGOOGLE" ); -# endif - - VULKAN_HPP_ASSERT( presentationTimingCount <= presentationTimings.size() ); - if ( presentationTimingCount < presentationTimings.size() ) - { - presentationTimings.resize( presentationTimingCount ); - } - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - return ResultValue>( result, std::move( presentationTimings ) ); -# else - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentationTimings ) ); -# endif - } - - //=== VK_EXT_discard_rectangles === - - // wrapper function for command vkCmdSetDiscardRectangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEXT( uint32_t firstDiscardRectangle, - ArrayProxy const & discardRectangles ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleEXT && "Function requires " ); - - getDispatcher()->vkCmdSetDiscardRectangleEXT( static_cast( m_commandBuffer ), - firstDiscardRectangle, - discardRectangles.size(), - reinterpret_cast( discardRectangles.data() ) ); - } - - // wrapper function for command vkCmdSetDiscardRectangleEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleEnableEXT( Bool32 discardRectangleEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleEnableEXT && - "Function requires " ); - - getDispatcher()->vkCmdSetDiscardRectangleEnableEXT( static_cast( m_commandBuffer ), static_cast( discardRectangleEnable ) ); - } - - // wrapper function for command vkCmdSetDiscardRectangleModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDiscardRectangleModeEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDiscardRectangleModeEXT( DiscardRectangleModeEXT discardRectangleMode ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDiscardRectangleModeEXT && - "Function requires " ); - - getDispatcher()->vkCmdSetDiscardRectangleModeEXT( static_cast( m_commandBuffer ), - static_cast( discardRectangleMode ) ); - } - - //=== VK_EXT_hdr_metadata === - - // wrapper function for command vkSetHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetHdrMetadataEXT.html - VULKAN_HPP_INLINE void Device::setHdrMetadataEXT( ArrayProxy const & swapchains, - ArrayProxy const & metadata ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetHdrMetadataEXT && "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( swapchains.size() == metadata.size() ); -# else - if ( swapchains.size() != metadata.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::setHdrMetadataEXT: swapchains.size() != metadata.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkSetHdrMetadataEXT( static_cast( m_device ), - swapchains.size(), - reinterpret_cast( swapchains.data() ), - reinterpret_cast( metadata.data() ) ); - } - - //=== VK_KHR_create_renderpass2 === - - // wrapper function for command vkCreateRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRenderPass2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createRenderPass2KHR( RenderPassCreateInfo2 const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRenderPass2KHR && - "Function requires or " ); - - VULKAN_HPP_NAMESPACE::RenderPass renderPass; - Result result = static_cast( getDispatcher()->vkCreateRenderPass2KHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &renderPass ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRenderPass2KHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, RenderPass( *this, *reinterpret_cast( &renderPass ), allocator ) ); - } - - // wrapper function for command vkCmdBeginRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginRenderPass2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::beginRenderPass2KHR( const RenderPassBeginInfo & renderPassBegin, - const SubpassBeginInfo & subpassBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginRenderPass2KHR && - "Function requires or " ); - - getDispatcher()->vkCmdBeginRenderPass2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( &renderPassBegin ), - reinterpret_cast( &subpassBeginInfo ) ); - } - - // wrapper function for command vkCmdNextSubpass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdNextSubpass2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::nextSubpass2KHR( const SubpassBeginInfo & subpassBeginInfo, - const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdNextSubpass2KHR && "Function requires or " ); - - getDispatcher()->vkCmdNextSubpass2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( &subpassBeginInfo ), - reinterpret_cast( &subpassEndInfo ) ); - } - - // wrapper function for command vkCmdEndRenderPass2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRenderPass2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::endRenderPass2KHR( const SubpassEndInfo & subpassEndInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRenderPass2KHR && - "Function requires or " ); - - getDispatcher()->vkCmdEndRenderPass2KHR( static_cast( m_commandBuffer ), reinterpret_cast( &subpassEndInfo ) ); - } - - //=== VK_KHR_shared_presentable_image === - - // wrapper function for command vkGetSwapchainStatusKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainStatusKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::getStatus() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainStatusKHR && "Function requires " ); - - Result result = - static_cast( getDispatcher()->vkGetSwapchainStatusKHR( static_cast( m_device ), static_cast( m_swapchainKHR ) ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getStatus", { Result::eSuccess, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getStatus", { Result::eSuccess, Result::eSuboptimalKHR } ); -# endif - - return static_cast( result ); - } - - //=== VK_KHR_external_fence_capabilities === - - // wrapper function for command vkGetPhysicalDeviceExternalFencePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalFencePropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalFenceProperties - PhysicalDevice::getExternalFencePropertiesKHR( const PhysicalDeviceExternalFenceInfo & externalFenceInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR && - "Function requires or " ); - - ExternalFenceProperties externalFenceProperties; - getDispatcher()->vkGetPhysicalDeviceExternalFencePropertiesKHR( static_cast( m_physicalDevice ), - reinterpret_cast( &externalFenceInfo ), - reinterpret_cast( &externalFenceProperties ) ); - - return externalFenceProperties; - } - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_external_fence_win32 === - - // wrapper function for command vkImportFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceWin32HandleKHR.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::importFenceWin32HandleKHR( const ImportFenceWin32HandleInfoKHR & importFenceWin32HandleInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceWin32HandleKHR && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkImportFenceWin32HandleKHR( - static_cast( m_device ), reinterpret_cast( &importFenceWin32HandleInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::importFenceWin32HandleKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetFenceWin32HandleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceWin32HandleKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getFenceWin32HandleKHR( const FenceGetWin32HandleInfoKHR & getWin32HandleInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceWin32HandleKHR && "Function requires " ); - - HANDLE handle; - Result result = static_cast( getDispatcher()->vkGetFenceWin32HandleKHR( - static_cast( m_device ), reinterpret_cast( &getWin32HandleInfo ), &handle ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getFenceWin32HandleKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_KHR_external_fence_fd === - - // wrapper function for command vkImportFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportFenceFdKHR.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::importFenceFdKHR( const ImportFenceFdInfoKHR & importFenceFdInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkImportFenceFdKHR && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkImportFenceFdKHR( static_cast( m_device ), reinterpret_cast( &importFenceFdInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::importFenceFdKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetFenceFdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFenceFdKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::getFenceFdKHR( const FenceGetFdInfoKHR & getFdInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetFenceFdKHR && "Function requires " ); - - int fd; - Result result = static_cast( - getDispatcher()->vkGetFenceFdKHR( static_cast( m_device ), reinterpret_cast( &getFdInfo ), &fd ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getFenceFdKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fd ) ); - } - - //=== VK_KHR_performance_query === - - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType, std::vector>>::type - PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR( uint32_t queueFamilyIndex ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR && - "Function requires " ); - - std::pair, std::vector> data_; - std::vector & counters = data_.first; - std::vector & counterDescriptions = data_.second; - uint32_t counterCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - static_cast( m_physicalDevice ), queueFamilyIndex, &counterCount, nullptr, nullptr ) ); - if ( ( result == Result::eSuccess ) && counterCount ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - result = static_cast( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - static_cast( m_physicalDevice ), - queueFamilyIndex, - &counterCount, - reinterpret_cast( counters.data() ), - reinterpret_cast( counterDescriptions.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceQueryCountersKHR" ); - VULKAN_HPP_ASSERT( counterCount <= counters.size() ); - if ( counterCount < counters.size() ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t - PhysicalDevice::getQueueFamilyPerformanceQueryPassesKHR( const QueryPoolPerformanceCreateInfoKHR & performanceQueryCreateInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR && - "Function requires " ); - - uint32_t numPasses; - getDispatcher()->vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( - static_cast( m_physicalDevice ), - reinterpret_cast( &performanceQueryCreateInfo ), - &numPasses ); - - return numPasses; - } - - // wrapper function for command vkAcquireProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireProfilingLockKHR.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::acquireProfilingLockKHR( const AcquireProfilingLockInfoKHR & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireProfilingLockKHR && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkAcquireProfilingLockKHR( static_cast( m_device ), reinterpret_cast( &info ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::acquireProfilingLockKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkReleaseProfilingLockKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseProfilingLockKHR.html - VULKAN_HPP_INLINE void Device::releaseProfilingLockKHR() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseProfilingLockKHR && "Function requires " ); - - getDispatcher()->vkReleaseProfilingLockKHR( static_cast( m_device ) ); - } - - //=== VK_KHR_get_surface_capabilities2 === - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result PhysicalDevice::getSurfaceCapabilities2KHR( - const PhysicalDeviceSurfaceInfo2KHR * pSurfaceInfo, SurfaceCapabilities2KHR * pSurfaceCapabilities ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR && - "Function requires " ); - return static_cast( - getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( pSurfaceInfo ), - reinterpret_cast( pSurfaceCapabilities ) ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR && - "Function requires " ); - - SurfaceCapabilities2KHR surfaceCapabilities; - Result result = static_cast( - getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &surfaceInfo ), - reinterpret_cast( &surfaceCapabilities ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceCapabilities ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfaceCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceCapabilities2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceCapabilities2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR && - "Function requires " ); - - StructureChain structureChain; - SurfaceCapabilities2KHR & surfaceCapabilities = structureChain.template get(); - Result result = static_cast( - getDispatcher()->vkGetPhysicalDeviceSurfaceCapabilities2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &surfaceInfo ), - reinterpret_cast( &surfaceCapabilities ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceCapabilities2KHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR && - "Function requires " ); - - std::vector surfaceFormats; - uint32_t surfaceFormatCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &surfaceInfo ), - &surfaceFormatCount, - nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - surfaceFormats.resize( surfaceFormatCount ); - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &surfaceInfo ), - &surfaceFormatCount, - reinterpret_cast( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); - if ( surfaceFormatCount < surfaceFormats.size() ) - { - surfaceFormats.resize( surfaceFormatCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( surfaceFormats ) ); - } - - // wrapper function for command vkGetPhysicalDeviceSurfaceFormats2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfaceFormats2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfaceFormats2KHR( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR && - "Function requires " ); - - std::vector structureChains; - std::vector surfaceFormats; - uint32_t surfaceFormatCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &surfaceInfo ), - &surfaceFormatCount, - nullptr ) ); - if ( ( result == Result::eSuccess ) && surfaceFormatCount ) - { - structureChains.resize( surfaceFormatCount ); - surfaceFormats.resize( surfaceFormatCount ); - for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) - { - surfaceFormats[i].pNext = structureChains[i].template get().pNext; - } - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceSurfaceFormats2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &surfaceInfo ), - &surfaceFormatCount, - reinterpret_cast( surfaceFormats.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfaceFormats2KHR" ); - VULKAN_HPP_ASSERT( surfaceFormatCount <= surfaceFormats.size() ); - if ( surfaceFormatCount < surfaceFormats.size() ) - { - structureChains.resize( surfaceFormatCount ); - } - for ( uint32_t i = 0; i < surfaceFormatCount; i++ ) - { - structureChains[i].template get() = surfaceFormats[i]; - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChains ) ); - } - - //=== VK_KHR_get_display_properties2 === - - // wrapper function for command vkGetPhysicalDeviceDisplayProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayProperties2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getDisplayProperties2KHR() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR && - "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceDisplayProperties2KHR( - static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayProperties2KHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceDisplayPlaneProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDisplayPlaneProperties2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getDisplayPlaneProperties2KHR() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR && - "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceDisplayPlaneProperties2KHR( - static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneProperties2KHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type DisplayKHR::getModeProperties2() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModeProperties2KHR && - "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( - static_cast( m_physicalDevice ), static_cast( m_displayKHR ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = - static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast( m_physicalDevice ), - static_cast( m_displayKHR ), - &propertyCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayKHR::getModeProperties2" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetDisplayModeProperties2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayModeProperties2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type DisplayKHR::getModeProperties2() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayModeProperties2KHR && - "Function requires " ); - - std::vector structureChains; - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( - static_cast( m_physicalDevice ), static_cast( m_displayKHR ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - structureChains.resize( propertyCount ); - properties.resize( propertyCount ); - for ( uint32_t i = 0; i < propertyCount; i++ ) - { - properties[i].pNext = structureChains[i].template get().pNext; - } - result = - static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast( m_physicalDevice ), - static_cast( m_displayKHR ), - &propertyCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayKHR::getModeProperties2" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - structureChains.resize( propertyCount ); - } - for ( uint32_t i = 0; i < propertyCount; i++ ) - { - structureChains[i].template get() = properties[i]; - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChains ) ); - } - - // wrapper function for command vkGetDisplayPlaneCapabilities2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDisplayPlaneCapabilities2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getDisplayPlaneCapabilities2KHR( const DisplayPlaneInfo2KHR & displayPlaneInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDisplayPlaneCapabilities2KHR && - "Function requires " ); - - DisplayPlaneCapabilities2KHR capabilities; - Result result = - static_cast( getDispatcher()->vkGetDisplayPlaneCapabilities2KHR( static_cast( m_physicalDevice ), - reinterpret_cast( &displayPlaneInfo ), - reinterpret_cast( &capabilities ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDisplayPlaneCapabilities2KHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( capabilities ) ); - } - -# if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - - // wrapper function for command vkCreateIOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIOSSurfaceMVK.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createIOSSurfaceMVK( IOSSurfaceCreateInfoMVK const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateIOSSurfaceMVK && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateIOSSurfaceMVK( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createIOSSurfaceMVK" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } -# endif /*VK_USE_PLATFORM_IOS_MVK*/ - -# if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - - // wrapper function for command vkCreateMacOSSurfaceMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMacOSSurfaceMVK.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createMacOSSurfaceMVK( MacOSSurfaceCreateInfoMVK const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateMacOSSurfaceMVK && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateMacOSSurfaceMVK( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createMacOSSurfaceMVK" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } -# endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - - // wrapper function for command vkSetDebugUtilsObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::setDebugUtilsObjectNameEXT( const DebugUtilsObjectNameInfoEXT & nameInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectNameEXT && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkSetDebugUtilsObjectNameEXT( - static_cast( m_device ), reinterpret_cast( &nameInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::setDebugUtilsObjectNameEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkSetDebugUtilsObjectNameEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectNameEXT.html - template - VULKAN_HPP_INLINE typename ResultValueType::type Device::setDebugUtilsObjectNameEXT( HandleType const & handle, std::string const & name ) const - { - VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); - // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member - VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT nameInfo; - nameInfo.objectType = handle.objectType; - nameInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); - nameInfo.pObjectName = name.c_str(); - return setDebugUtilsObjectNameEXT( nameInfo ); - } - - // wrapper function for command vkSetDebugUtilsObjectTagEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::setDebugUtilsObjectTagEXT( const DebugUtilsObjectTagInfoEXT & tagInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetDebugUtilsObjectTagEXT && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkSetDebugUtilsObjectTagEXT( static_cast( m_device ), reinterpret_cast( &tagInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::setDebugUtilsObjectTagEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkSetDebugUtilsObjectTagEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDebugUtilsObjectTagEXT.html - template - VULKAN_HPP_INLINE typename ResultValueType::type - Device::setDebugUtilsObjectTagEXT( HandleType const & handle, uint64_t name, TagType const & tag ) const - { - VULKAN_HPP_STATIC_ASSERT( VULKAN_HPP_NAMESPACE::isVulkanHandleType::value, "HandleType must be a Vulkan handle type" ); - // It might be, that neither constructors, nor setters, nor designated initializers are available... need to explicitly set member by member - VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT tagInfo; - tagInfo.objectType = handle.objectType; - tagInfo.objectHandle = reinterpret_cast( static_cast( handle ) ); - tagInfo.tagName = name; - tagInfo.tagSize = sizeof( TagType ); - tagInfo.pTag = &tag; - return setDebugUtilsObjectTagEXT( tagInfo ); - } - - // wrapper function for command vkQueueBeginDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueBeginDebugUtilsLabelEXT.html - VULKAN_HPP_INLINE void Queue::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueueBeginDebugUtilsLabelEXT && "Function requires " ); - - getDispatcher()->vkQueueBeginDebugUtilsLabelEXT( static_cast( m_queue ), reinterpret_cast( &labelInfo ) ); - } - - // wrapper function for command vkQueueEndDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueEndDebugUtilsLabelEXT.html - VULKAN_HPP_INLINE void Queue::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueueEndDebugUtilsLabelEXT && "Function requires " ); - - getDispatcher()->vkQueueEndDebugUtilsLabelEXT( static_cast( m_queue ) ); - } - - // wrapper function for command vkQueueInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueInsertDebugUtilsLabelEXT.html - VULKAN_HPP_INLINE void Queue::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueueInsertDebugUtilsLabelEXT && "Function requires " ); - - getDispatcher()->vkQueueInsertDebugUtilsLabelEXT( static_cast( m_queue ), reinterpret_cast( &labelInfo ) ); - } - - // wrapper function for command vkCmdBeginDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginDebugUtilsLabelEXT.html - VULKAN_HPP_INLINE void CommandBuffer::beginDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginDebugUtilsLabelEXT && "Function requires " ); - - getDispatcher()->vkCmdBeginDebugUtilsLabelEXT( static_cast( m_commandBuffer ), - reinterpret_cast( &labelInfo ) ); - } - - // wrapper function for command vkCmdEndDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndDebugUtilsLabelEXT.html - VULKAN_HPP_INLINE void CommandBuffer::endDebugUtilsLabelEXT() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndDebugUtilsLabelEXT && "Function requires " ); - - getDispatcher()->vkCmdEndDebugUtilsLabelEXT( static_cast( m_commandBuffer ) ); - } - - // wrapper function for command vkCmdInsertDebugUtilsLabelEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInsertDebugUtilsLabelEXT.html - VULKAN_HPP_INLINE void CommandBuffer::insertDebugUtilsLabelEXT( const DebugUtilsLabelEXT & labelInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdInsertDebugUtilsLabelEXT && "Function requires " ); - - getDispatcher()->vkCmdInsertDebugUtilsLabelEXT( static_cast( m_commandBuffer ), - reinterpret_cast( &labelInfo ) ); - } - - // wrapper function for command vkCreateDebugUtilsMessengerEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDebugUtilsMessengerEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createDebugUtilsMessengerEXT( DebugUtilsMessengerCreateInfoEXT const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDebugUtilsMessengerEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT messenger; - Result result = - static_cast( getDispatcher()->vkCreateDebugUtilsMessengerEXT( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &messenger ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createDebugUtilsMessengerEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, DebugUtilsMessengerEXT( *this, *reinterpret_cast( &messenger ), allocator ) ); - } - - // wrapper function for command vkSubmitDebugUtilsMessageEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSubmitDebugUtilsMessageEXT.html - VULKAN_HPP_INLINE void Instance::submitDebugUtilsMessageEXT( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - DebugUtilsMessageTypeFlagsEXT messageTypes, - const DebugUtilsMessengerCallbackDataEXT & callbackData ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSubmitDebugUtilsMessageEXT && "Function requires " ); - - getDispatcher()->vkSubmitDebugUtilsMessageEXT( static_cast( m_instance ), - static_cast( messageSeverity ), - static_cast( messageTypes ), - reinterpret_cast( &callbackData ) ); - } - -# if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_ANDROID_external_memory_android_hardware_buffer === - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getAndroidHardwareBufferPropertiesANDROID( - const struct AHardwareBuffer * buffer, AndroidHardwareBufferPropertiesANDROID * pProperties ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID && - "Function requires " ); - return static_cast( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( - static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); - } - - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID && - "Function requires " ); - - AndroidHardwareBufferPropertiesANDROID properties; - Result result = static_cast( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( - static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAndroidHardwareBufferPropertiesANDROID.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getAndroidHardwareBufferPropertiesANDROID( const struct AHardwareBuffer & buffer ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID && - "Function requires " ); - - StructureChain structureChain; - AndroidHardwareBufferPropertiesANDROID & properties = structureChain.template get(); - Result result = static_cast( getDispatcher()->vkGetAndroidHardwareBufferPropertiesANDROID( - static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getAndroidHardwareBufferPropertiesANDROID" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); - } - - // wrapper function for command vkGetMemoryAndroidHardwareBufferANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryAndroidHardwareBufferANDROID.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryAndroidHardwareBufferANDROID( const MemoryGetAndroidHardwareBufferInfoANDROID & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID && - "Function requires " ); - - struct AHardwareBuffer * buffer; - Result result = static_cast( getDispatcher()->vkGetMemoryAndroidHardwareBufferANDROID( - static_cast( m_device ), reinterpret_cast( &info ), &buffer ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryAndroidHardwareBufferANDROID" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( buffer ) ); - } -# endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_shader_enqueue === - - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createExecutionGraphPipelinesAMDX( Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateExecutionGraphPipelinesAMDX && - "Function requires " ); - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( - getDispatcher()->vkCreateExecutionGraphPipelinesAMDX( static_cast( m_device ), - pipelineCache ? static_cast( **pipelineCache ) : 0, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createExecutionGraphPipelinesAMDX", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - std::vector pipelinesRAII; - if ( result == Result::eSuccess ) - { - pipelinesRAII.reserve( pipelines.size() ); - for ( auto & pipeline : pipelines ) - { - pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); - } - - // wrapper function for command vkCreateExecutionGraphPipelinesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExecutionGraphPipelinesAMDX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createExecutionGraphPipelineAMDX( Optional const & pipelineCache, - ExecutionGraphPipelineCreateInfoAMDX const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateExecutionGraphPipelinesAMDX && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::Pipeline pipeline; - Result result = static_cast( - getDispatcher()->vkCreateExecutionGraphPipelinesAMDX( static_cast( m_device ), - pipelineCache ? static_cast( **pipelineCache ) : 0, - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createExecutionGraphPipelineAMDX", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); - } - - // wrapper function for command vkGetExecutionGraphPipelineScratchSizeAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineScratchSizeAMDX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Pipeline::getExecutionGraphScratchSizeAMDX() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetExecutionGraphPipelineScratchSizeAMDX && - "Function requires " ); - - ExecutionGraphPipelineScratchSizeAMDX sizeInfo; - Result result = static_cast( getDispatcher()->vkGetExecutionGraphPipelineScratchSizeAMDX( - static_cast( m_device ), static_cast( m_pipeline ), reinterpret_cast( &sizeInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getExecutionGraphScratchSizeAMDX" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( sizeInfo ) ); - } - - // wrapper function for command vkGetExecutionGraphPipelineNodeIndexAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExecutionGraphPipelineNodeIndexAMDX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Pipeline::getExecutionGraphNodeIndexAMDX( const PipelineShaderStageNodeCreateInfoAMDX & nodeInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetExecutionGraphPipelineNodeIndexAMDX && - "Function requires " ); - - uint32_t nodeIndex; - Result result = static_cast( - getDispatcher()->vkGetExecutionGraphPipelineNodeIndexAMDX( static_cast( m_device ), - static_cast( m_pipeline ), - reinterpret_cast( &nodeInfo ), - &nodeIndex ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getExecutionGraphNodeIndexAMDX" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( nodeIndex ) ); - } - - // wrapper function for command vkCmdInitializeGraphScratchMemoryAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdInitializeGraphScratchMemoryAMDX.html - VULKAN_HPP_INLINE void CommandBuffer::initializeGraphScratchMemoryAMDX( VULKAN_HPP_NAMESPACE::Pipeline executionGraph, - DeviceAddress scratch, - DeviceSize scratchSize ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdInitializeGraphScratchMemoryAMDX && - "Function requires " ); - - getDispatcher()->vkCmdInitializeGraphScratchMemoryAMDX( static_cast( m_commandBuffer ), - static_cast( executionGraph ), - static_cast( scratch ), - static_cast( scratchSize ) ); - } - - // wrapper function for command vkCmdDispatchGraphAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphAMDX.html - VULKAN_HPP_INLINE void - CommandBuffer::dispatchGraphAMDX( DeviceAddress scratch, DeviceSize scratchSize, const DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphAMDX && "Function requires " ); - - getDispatcher()->vkCmdDispatchGraphAMDX( static_cast( m_commandBuffer ), - static_cast( scratch ), - static_cast( scratchSize ), - reinterpret_cast( &countInfo ) ); - } - - // wrapper function for command vkCmdDispatchGraphIndirectAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectAMDX.html - VULKAN_HPP_INLINE void CommandBuffer::dispatchGraphIndirectAMDX( DeviceAddress scratch, - DeviceSize scratchSize, - const DispatchGraphCountInfoAMDX & countInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphIndirectAMDX && "Function requires " ); - - getDispatcher()->vkCmdDispatchGraphIndirectAMDX( static_cast( m_commandBuffer ), - static_cast( scratch ), - static_cast( scratchSize ), - reinterpret_cast( &countInfo ) ); - } - - // wrapper function for command vkCmdDispatchGraphIndirectCountAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchGraphIndirectCountAMDX.html - VULKAN_HPP_INLINE void - CommandBuffer::dispatchGraphIndirectCountAMDX( DeviceAddress scratch, DeviceSize scratchSize, DeviceAddress countInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchGraphIndirectCountAMDX && - "Function requires " ); - - getDispatcher()->vkCmdDispatchGraphIndirectCountAMDX( static_cast( m_commandBuffer ), - static_cast( scratch ), - static_cast( scratchSize ), - static_cast( countInfo ) ); - } -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_descriptor_heap === - - // wrapper function for command vkWriteSamplerDescriptorsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteSamplerDescriptorsEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::writeSamplerDescriptorsEXT( ArrayProxy const & samplers, - ArrayProxy const & descriptors ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkWriteSamplerDescriptorsEXT && "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( samplers.size() == descriptors.size() ); -# else - if ( samplers.size() != descriptors.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT: samplers.size() != descriptors.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - Result result = - static_cast( getDispatcher()->vkWriteSamplerDescriptorsEXT( static_cast( m_device ), - samplers.size(), - reinterpret_cast( samplers.data() ), - reinterpret_cast( descriptors.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeSamplerDescriptorsEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkWriteResourceDescriptorsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteResourceDescriptorsEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::writeResourceDescriptorsEXT( ArrayProxy const & resources, - ArrayProxy const & descriptors ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkWriteResourceDescriptorsEXT && "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( resources.size() == descriptors.size() ); -# else - if ( resources.size() != descriptors.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT: resources.size() != descriptors.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - Result result = - static_cast( getDispatcher()->vkWriteResourceDescriptorsEXT( static_cast( m_device ), - resources.size(), - reinterpret_cast( resources.data() ), - reinterpret_cast( descriptors.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeResourceDescriptorsEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCmdBindSamplerHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindSamplerHeapEXT.html - VULKAN_HPP_INLINE void CommandBuffer::bindSamplerHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindSamplerHeapEXT && "Function requires " ); - - getDispatcher()->vkCmdBindSamplerHeapEXT( static_cast( m_commandBuffer ), reinterpret_cast( &bindInfo ) ); - } - - // wrapper function for command vkCmdBindResourceHeapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindResourceHeapEXT.html - VULKAN_HPP_INLINE void CommandBuffer::bindResourceHeapEXT( const BindHeapInfoEXT & bindInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindResourceHeapEXT && "Function requires " ); - - getDispatcher()->vkCmdBindResourceHeapEXT( static_cast( m_commandBuffer ), reinterpret_cast( &bindInfo ) ); - } - - // wrapper function for command vkCmdPushDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDataEXT.html - VULKAN_HPP_INLINE void CommandBuffer::pushDataEXT( const PushDataInfoEXT & pushDataInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDataEXT && "Function requires " ); - - getDispatcher()->vkCmdPushDataEXT( static_cast( m_commandBuffer ), reinterpret_cast( &pushDataInfo ) ); - } - - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getImageOpaqueCaptureDataEXT( ArrayProxy const & images ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageOpaqueCaptureDataEXT && "Function requires " ); - - std::vector datas( images.size() ); - Result result = static_cast( getDispatcher()->vkGetImageOpaqueCaptureDataEXT( static_cast( m_device ), - images.size(), - reinterpret_cast( images.data() ), - reinterpret_cast( datas.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( datas ) ); - } - - // wrapper function for command vkGetImageOpaqueCaptureDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDataEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getImageOpaqueCaptureDataEXT( const VULKAN_HPP_NAMESPACE::Image & image ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageOpaqueCaptureDataEXT && "Function requires " ); - - HostAddressRangeEXT data; - Result result = static_cast( getDispatcher()->vkGetImageOpaqueCaptureDataEXT( - static_cast( m_device ), 1, reinterpret_cast( &image ), reinterpret_cast( &data ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDataEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetPhysicalDeviceDescriptorSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDescriptorSizeEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize PhysicalDevice::getDescriptorSizeEXT( DescriptorType descriptorType ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDescriptorSizeEXT && - "Function requires " ); - - VkDeviceSize result = getDispatcher()->vkGetPhysicalDeviceDescriptorSizeEXT( static_cast( m_physicalDevice ), - static_cast( descriptorType ) ); - - return static_cast( result ); - } - - // wrapper function for command vkRegisterCustomBorderColorEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkRegisterCustomBorderColorEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::registerCustomBorderColorEXT( const SamplerCustomBorderColorCreateInfoEXT & borderColor, Bool32 requestIndex ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkRegisterCustomBorderColorEXT && "Function requires " ); - - uint32_t index; - Result result = - static_cast( getDispatcher()->vkRegisterCustomBorderColorEXT( static_cast( m_device ), - reinterpret_cast( &borderColor ), - static_cast( requestIndex ), - &index ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::registerCustomBorderColorEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( index ) ); - } - - // wrapper function for command vkUnregisterCustomBorderColorEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnregisterCustomBorderColorEXT.html - VULKAN_HPP_INLINE void Device::unregisterCustomBorderColorEXT( uint32_t index ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkUnregisterCustomBorderColorEXT && "Function requires " ); - - getDispatcher()->vkUnregisterCustomBorderColorEXT( static_cast( m_device ), index ); - } - - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getTensorOpaqueCaptureDataARM( ArrayProxy const & tensors ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorOpaqueCaptureDataARM && "Function requires " ); - - std::vector datas( tensors.size() ); - Result result = static_cast( getDispatcher()->vkGetTensorOpaqueCaptureDataARM( static_cast( m_device ), - tensors.size(), - reinterpret_cast( tensors.data() ), - reinterpret_cast( datas.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( datas ) ); - } - - // wrapper function for command vkGetTensorOpaqueCaptureDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDataARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getTensorOpaqueCaptureDataARM( const VULKAN_HPP_NAMESPACE::TensorARM & tensor ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorOpaqueCaptureDataARM && "Function requires " ); - - HostAddressRangeEXT data; - Result result = static_cast( getDispatcher()->vkGetTensorOpaqueCaptureDataARM( - static_cast( m_device ), 1, reinterpret_cast( &tensor ), reinterpret_cast( &data ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDataARM" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - //=== VK_EXT_sample_locations === - - // wrapper function for command vkCmdSetSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEXT( const SampleLocationsInfoEXT & sampleLocationsInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEXT && "Function requires " ); - - getDispatcher()->vkCmdSetSampleLocationsEXT( static_cast( m_commandBuffer ), - reinterpret_cast( &sampleLocationsInfo ) ); - } - - // wrapper function for command vkGetPhysicalDeviceMultisamplePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceMultisamplePropertiesEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MultisamplePropertiesEXT - PhysicalDevice::getMultisamplePropertiesEXT( SampleCountFlagBits samples ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT && - "Function requires " ); - - MultisamplePropertiesEXT multisampleProperties; - getDispatcher()->vkGetPhysicalDeviceMultisamplePropertiesEXT( static_cast( m_physicalDevice ), - static_cast( samples ), - reinterpret_cast( &multisampleProperties ) ); - - return multisampleProperties; - } - - //=== VK_KHR_get_memory_requirements2 === - - // wrapper function for command vkGetImageMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2KHR && - "Function requires or " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetImageMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageMemoryRequirements2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getImageMemoryRequirements2KHR( const ImageMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageMemoryRequirements2KHR && - "Function requires or " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetImageMemoryRequirements2KHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkGetBufferMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2KHR && - "Function requires or " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetBufferMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferMemoryRequirements2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getBufferMemoryRequirements2KHR( const BufferMemoryRequirementsInfo2 & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferMemoryRequirements2KHR && - "Function requires or " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetBufferMemoryRequirements2KHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkGetImageSparseMemoryRequirements2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSparseMemoryRequirements2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirements2KHR( const ImageSparseMemoryRequirementsInfo2 & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageSparseMemoryRequirements2KHR && - "Function requires or " ); - - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( - static_cast( m_device ), reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - getDispatcher()->vkGetImageSparseMemoryRequirements2KHR( static_cast( m_device ), - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } - - //=== VK_KHR_acceleration_structure === - - // wrapper function for command vkCreateAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createAccelerationStructureKHR( AccelerationStructureCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateAccelerationStructureKHR && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::AccelerationStructureKHR accelerationStructure; - Result result = - static_cast( getDispatcher()->vkCreateAccelerationStructureKHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &accelerationStructure ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createAccelerationStructureKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, AccelerationStructureKHR( *this, *reinterpret_cast( &accelerationStructure ), allocator ) ); - } - - // wrapper function for command vkCmdBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresKHR.html - VULKAN_HPP_INLINE void - CommandBuffer::buildAccelerationStructuresKHR( ArrayProxy const & infos, - ArrayProxy const & pBuildRangeInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructuresKHR && - "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); -# else - if ( infos.size() != pBuildRangeInfos.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdBuildAccelerationStructuresKHR( - static_cast( m_commandBuffer ), - infos.size(), - reinterpret_cast( infos.data() ), - reinterpret_cast( pBuildRangeInfos.data() ) ); - } - - // wrapper function for command vkCmdBuildAccelerationStructuresIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructuresIndirectKHR.html - VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructuresIndirectKHR( ArrayProxy const & infos, - ArrayProxy const & indirectDeviceAddresses, - ArrayProxy const & indirectStrides, - ArrayProxy const & pMaxPrimitiveCounts ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR && - "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( infos.size() == indirectDeviceAddresses.size() ); - VULKAN_HPP_ASSERT( infos.size() == indirectStrides.size() ); - VULKAN_HPP_ASSERT( infos.size() == pMaxPrimitiveCounts.size() ); -# else - if ( infos.size() != indirectDeviceAddresses.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectDeviceAddresses.size()" ); - } - if ( infos.size() != indirectStrides.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != indirectStrides.size()" ); - } - if ( infos.size() != pMaxPrimitiveCounts.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::buildAccelerationStructuresIndirectKHR: infos.size() != pMaxPrimitiveCounts.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdBuildAccelerationStructuresIndirectKHR( static_cast( m_commandBuffer ), - infos.size(), - reinterpret_cast( infos.data() ), - reinterpret_cast( indirectDeviceAddresses.data() ), - indirectStrides.data(), - pMaxPrimitiveCounts.data() ); - } - - // wrapper function for command vkBuildAccelerationStructuresKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildAccelerationStructuresKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::buildAccelerationStructuresKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - ArrayProxy const & infos, - ArrayProxy const & pBuildRangeInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBuildAccelerationStructuresKHR && - "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( infos.size() == pBuildRangeInfos.size() ); -# else - if ( infos.size() != pBuildRangeInfos.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR: infos.size() != pBuildRangeInfos.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - Result result = static_cast( getDispatcher()->vkBuildAccelerationStructuresKHR( - static_cast( m_device ), - static_cast( deferredOperation ), - infos.size(), - reinterpret_cast( infos.data() ), - reinterpret_cast( pBuildRangeInfos.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::buildAccelerationStructuresKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } - - // wrapper function for command vkCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureInfoKHR & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyAccelerationStructureKHR && - "Function requires " ); - - Result result = - static_cast( getDispatcher()->vkCopyAccelerationStructureKHR( static_cast( m_device ), - static_cast( deferredOperation ), - reinterpret_cast( &info ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyAccelerationStructureKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } - - // wrapper function for command vkCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyAccelerationStructureToMemoryKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyAccelerationStructureToMemoryKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const CopyAccelerationStructureToMemoryInfoKHR & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyAccelerationStructureToMemoryKHR && - "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkCopyAccelerationStructureToMemoryKHR( static_cast( m_device ), - static_cast( deferredOperation ), - reinterpret_cast( &info ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyAccelerationStructureToMemoryKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } - - // wrapper function for command vkCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToAccelerationStructureKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToAccelerationStructureKHR( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const CopyMemoryToAccelerationStructureInfoKHR & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToAccelerationStructureKHR && - "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkCopyMemoryToAccelerationStructureKHR( static_cast( m_device ), - static_cast( deferredOperation ), - reinterpret_cast( &info ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMemoryToAccelerationStructureKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } - - // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, - QueryType queryType, - size_t dataSize, - size_t stride ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR && - "Function requires " ); - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( - getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast( m_device ), - accelerationStructures.size(), - reinterpret_cast( accelerationStructures.data() ), - static_cast( queryType ), - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ), - stride ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertiesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteAccelerationStructuresPropertiesKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::writeAccelerationStructuresPropertyKHR( - ArrayProxy const & accelerationStructures, QueryType queryType, size_t stride ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR && - "Function requires " ); - - DataType data; - Result result = static_cast( - getDispatcher()->vkWriteAccelerationStructuresPropertiesKHR( static_cast( m_device ), - accelerationStructures.size(), - reinterpret_cast( accelerationStructures.data() ), - static_cast( queryType ), - sizeof( DataType ), - reinterpret_cast( &data ), - stride ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeAccelerationStructuresPropertyKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkCmdCopyAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureKHR.html - VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureKHR( const CopyAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureKHR && - "Function requires " ); - - getDispatcher()->vkCmdCopyAccelerationStructureKHR( static_cast( m_commandBuffer ), - reinterpret_cast( &info ) ); - } - - // wrapper function for command vkCmdCopyAccelerationStructureToMemoryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureToMemoryKHR.html - VULKAN_HPP_INLINE void - CommandBuffer::copyAccelerationStructureToMemoryKHR( const CopyAccelerationStructureToMemoryInfoKHR & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR && - "Function requires " ); - - getDispatcher()->vkCmdCopyAccelerationStructureToMemoryKHR( static_cast( m_commandBuffer ), - reinterpret_cast( &info ) ); - } - - // wrapper function for command vkCmdCopyMemoryToAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToAccelerationStructureKHR.html - VULKAN_HPP_INLINE void - CommandBuffer::copyMemoryToAccelerationStructureKHR( const CopyMemoryToAccelerationStructureInfoKHR & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR && - "Function requires " ); - - getDispatcher()->vkCmdCopyMemoryToAccelerationStructureKHR( static_cast( m_commandBuffer ), - reinterpret_cast( &info ) ); - } - - // wrapper function for command vkGetAccelerationStructureDeviceAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureDeviceAddressKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceAddress - Device::getAccelerationStructureAddressKHR( const AccelerationStructureDeviceAddressInfoKHR & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR && - "Function requires " ); - - VkDeviceAddress result = getDispatcher()->vkGetAccelerationStructureDeviceAddressKHR( - static_cast( m_device ), reinterpret_cast( &info ) ); - - return static_cast( result ); - } - - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesKHR.html - VULKAN_HPP_INLINE void - CommandBuffer::writeAccelerationStructuresPropertiesKHR( ArrayProxy const & accelerationStructures, - QueryType queryType, - VULKAN_HPP_NAMESPACE::QueryPool queryPool, - uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR && - "Function requires " ); - - getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesKHR( static_cast( m_commandBuffer ), - accelerationStructures.size(), - reinterpret_cast( accelerationStructures.data() ), - static_cast( queryType ), - static_cast( queryPool ), - firstQuery ); - } - - // wrapper function for command vkGetDeviceAccelerationStructureCompatibilityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceAccelerationStructureCompatibilityKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureCompatibilityKHR - Device::getAccelerationStructureCompatibilityKHR( const AccelerationStructureVersionInfoKHR & versionInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR && - "Function requires " ); - - AccelerationStructureCompatibilityKHR compatibility; - getDispatcher()->vkGetDeviceAccelerationStructureCompatibilityKHR( static_cast( m_device ), - reinterpret_cast( &versionInfo ), - reinterpret_cast( &compatibility ) ); - - return compatibility; - } - - // wrapper function for command vkGetAccelerationStructureBuildSizesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureBuildSizesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR - Device::getAccelerationStructureBuildSizesKHR( AccelerationStructureBuildTypeKHR buildType, - const AccelerationStructureBuildGeometryInfoKHR & buildInfo, - ArrayProxy const & maxPrimitiveCounts ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureBuildSizesKHR && - "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( maxPrimitiveCounts.size() == buildInfo.geometryCount ); -# else - if ( maxPrimitiveCounts.size() != buildInfo.geometryCount ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::Device::getAccelerationStructureBuildSizesKHR: maxPrimitiveCounts.size() != buildInfo.geometryCount" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - AccelerationStructureBuildSizesInfoKHR sizeInfo; - getDispatcher()->vkGetAccelerationStructureBuildSizesKHR( static_cast( m_device ), - static_cast( buildType ), - reinterpret_cast( &buildInfo ), - maxPrimitiveCounts.data(), - reinterpret_cast( &sizeInfo ) ); - - return sizeInfo; - } - - //=== VK_KHR_ray_tracing_pipeline === - - // wrapper function for command vkCmdTraceRaysKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysKHR.html - VULKAN_HPP_INLINE void CommandBuffer::traceRaysKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, - const StridedDeviceAddressRegionKHR & missShaderBindingTable, - const StridedDeviceAddressRegionKHR & hitShaderBindingTable, - const StridedDeviceAddressRegionKHR & callableShaderBindingTable, - uint32_t width, - uint32_t height, - uint32_t depth ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysKHR && "Function requires " ); - - getDispatcher()->vkCmdTraceRaysKHR( static_cast( m_commandBuffer ), - reinterpret_cast( &raygenShaderBindingTable ), - reinterpret_cast( &missShaderBindingTable ), - reinterpret_cast( &hitShaderBindingTable ), - reinterpret_cast( &callableShaderBindingTable ), - width, - height, - depth ); - } - - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createRayTracingPipelinesKHR( Optional const & deferredOperation, - Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRayTracingPipelinesKHR && - "Function requires " ); - - std::vector pipelines( createInfos.size() ); - Result result = static_cast( - getDispatcher()->vkCreateRayTracingPipelinesKHR( static_cast( m_device ), - deferredOperation ? static_cast( **deferredOperation ) : 0, - pipelineCache ? static_cast( **pipelineCache ) : 0, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRayTracingPipelinesKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } ); - std::vector pipelinesRAII; - if ( result == Result::eSuccess ) - { - pipelinesRAII.reserve( pipelines.size() ); - for ( auto & pipeline : pipelines ) - { - pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); - } - - // wrapper function for command vkCreateRayTracingPipelinesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createRayTracingPipelineKHR( Optional const & deferredOperation, - Optional const & pipelineCache, - RayTracingPipelineCreateInfoKHR const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRayTracingPipelinesKHR && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::Pipeline pipeline; - Result result = static_cast( - getDispatcher()->vkCreateRayTracingPipelinesKHR( static_cast( m_device ), - deferredOperation ? static_cast( **deferredOperation ) : 0, - pipelineCache ? static_cast( **pipelineCache ) : 0, - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRayTracingPipelineKHR", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR, Result::ePipelineCompileRequiredEXT } ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); - } - - // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Pipeline::getRayTracingShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR && - "Function requires or " ); - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast( m_device ), - static_cast( m_pipeline ), - firstGroup, - groupCount, - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetRayTracingShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Pipeline::getRayTracingShaderGroupHandleKHR( uint32_t firstGroup, - uint32_t groupCount ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR && - "Function requires or " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkGetRayTracingShaderGroupHandlesKHR( static_cast( m_device ), - static_cast( m_pipeline ), - firstGroup, - groupCount, - sizeof( DataType ), - reinterpret_cast( &data ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && - "Function requires " ); - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast( m_device ), - static_cast( m_pipeline ), - firstGroup, - groupCount, - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandlesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetRayTracingCaptureReplayShaderGroupHandlesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingCaptureReplayShaderGroupHandlesKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR( uint32_t firstGroup, uint32_t groupCount ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR && - "Function requires " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( static_cast( m_device ), - static_cast( m_pipeline ), - firstGroup, - groupCount, - sizeof( DataType ), - reinterpret_cast( &data ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingCaptureReplayShaderGroupHandleKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkCmdTraceRaysIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirectKHR.html - VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirectKHR( const StridedDeviceAddressRegionKHR & raygenShaderBindingTable, - const StridedDeviceAddressRegionKHR & missShaderBindingTable, - const StridedDeviceAddressRegionKHR & hitShaderBindingTable, - const StridedDeviceAddressRegionKHR & callableShaderBindingTable, - DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysIndirectKHR && "Function requires " ); - - getDispatcher()->vkCmdTraceRaysIndirectKHR( static_cast( m_commandBuffer ), - reinterpret_cast( &raygenShaderBindingTable ), - reinterpret_cast( &missShaderBindingTable ), - reinterpret_cast( &hitShaderBindingTable ), - reinterpret_cast( &callableShaderBindingTable ), - static_cast( indirectDeviceAddress ) ); - } - - // wrapper function for command vkGetRayTracingShaderGroupStackSizeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupStackSizeKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize - Pipeline::getRayTracingShaderGroupStackSizeKHR( uint32_t group, ShaderGroupShaderKHR groupShader ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR && - "Function requires " ); - - VkDeviceSize result = getDispatcher()->vkGetRayTracingShaderGroupStackSizeKHR( - static_cast( m_device ), static_cast( m_pipeline ), group, static_cast( groupShader ) ); - - return static_cast( result ); - } - - // wrapper function for command vkCmdSetRayTracingPipelineStackSizeKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRayTracingPipelineStackSizeKHR.html - VULKAN_HPP_INLINE void CommandBuffer::setRayTracingPipelineStackSizeKHR( uint32_t pipelineStackSize ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR && - "Function requires " ); - - getDispatcher()->vkCmdSetRayTracingPipelineStackSizeKHR( static_cast( m_commandBuffer ), pipelineStackSize ); - } - - //=== VK_KHR_sampler_ycbcr_conversion === - - // wrapper function for command vkCreateSamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSamplerYcbcrConversionKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createSamplerYcbcrConversionKHR( SamplerYcbcrConversionCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSamplerYcbcrConversionKHR && - "Function requires or " ); - - VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion; - Result result = - static_cast( getDispatcher()->vkCreateSamplerYcbcrConversionKHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &ycbcrConversion ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createSamplerYcbcrConversionKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, SamplerYcbcrConversion( *this, *reinterpret_cast( &ycbcrConversion ), allocator ) ); - } - - // wrapper function for command vkDestroySamplerYcbcrConversionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroySamplerYcbcrConversionKHR.html - VULKAN_HPP_INLINE void Device::destroySamplerYcbcrConversionKHR( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ycbcrConversion, - Optional allocator ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkDestroySamplerYcbcrConversionKHR && - "Function requires or " ); - - getDispatcher()->vkDestroySamplerYcbcrConversionKHR( static_cast( m_device ), - static_cast( ycbcrConversion ), - reinterpret_cast( allocator.get() ) ); - } - - //=== VK_KHR_bind_memory2 === - - // wrapper function for command vkBindBufferMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindBufferMemory2KHR.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::bindBufferMemory2KHR( ArrayProxy const & bindInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBindBufferMemory2KHR && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkBindBufferMemory2KHR( - static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindBufferMemory2KHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkBindImageMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindImageMemory2KHR.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::bindImageMemory2KHR( ArrayProxy const & bindInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBindImageMemory2KHR && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkBindImageMemory2KHR( - static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindImageMemory2KHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - //=== VK_EXT_image_drm_format_modifier === - - // wrapper function for command vkGetImageDrmFormatModifierPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageDrmFormatModifierPropertiesEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Image::getDrmFormatModifierPropertiesEXT() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT && - "Function requires " ); - - ImageDrmFormatModifierPropertiesEXT properties; - Result result = static_cast( getDispatcher()->vkGetImageDrmFormatModifierPropertiesEXT( - static_cast( m_device ), static_cast( m_image ), reinterpret_cast( &properties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Image::getDrmFormatModifierPropertiesEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - //=== VK_EXT_validation_cache === - - // wrapper function for command vkCreateValidationCacheEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateValidationCacheEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createValidationCacheEXT( ValidationCacheCreateInfoEXT const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateValidationCacheEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::ValidationCacheEXT validationCache; - Result result = static_cast( getDispatcher()->vkCreateValidationCacheEXT( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &validationCache ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createValidationCacheEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, ValidationCacheEXT( *this, *reinterpret_cast( &validationCache ), allocator ) ); - } - - // wrapper function for command vkMergeValidationCachesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMergeValidationCachesEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type - ValidationCacheEXT::merge( ArrayProxy const & srcCaches ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkMergeValidationCachesEXT && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkMergeValidationCachesEXT( static_cast( m_device ), - static_cast( m_validationCacheEXT ), - srcCaches.size(), - reinterpret_cast( srcCaches.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::ValidationCacheEXT::merge" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetValidationCacheDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetValidationCacheDataEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type ValidationCacheEXT::getData() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetValidationCacheDataEXT && "Function requires " ); - - std::vector data; - size_t dataSize; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetValidationCacheDataEXT( - static_cast( m_device ), static_cast( m_validationCacheEXT ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( getDispatcher()->vkGetValidationCacheDataEXT( static_cast( m_device ), - static_cast( m_validationCacheEXT ), - &dataSize, - reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::ValidationCacheEXT::getData" ); - VULKAN_HPP_ASSERT( dataSize <= data.size() ); - if ( dataSize < data.size() ) - { - data.resize( dataSize ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - //=== VK_NV_shading_rate_image === - - // wrapper function for command vkCmdBindShadingRateImageNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadingRateImageNV.html - VULKAN_HPP_INLINE void CommandBuffer::bindShadingRateImageNV( VULKAN_HPP_NAMESPACE::ImageView imageView, ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadingRateImageNV && "Function requires " ); - - getDispatcher()->vkCmdBindShadingRateImageNV( - static_cast( m_commandBuffer ), static_cast( imageView ), static_cast( imageLayout ) ); - } - - // wrapper function for command vkCmdSetViewportShadingRatePaletteNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportShadingRatePaletteNV.html - VULKAN_HPP_INLINE void - CommandBuffer::setViewportShadingRatePaletteNV( uint32_t firstViewport, - ArrayProxy const & shadingRatePalettes ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportShadingRatePaletteNV && - "Function requires " ); - - getDispatcher()->vkCmdSetViewportShadingRatePaletteNV( static_cast( m_commandBuffer ), - firstViewport, - shadingRatePalettes.size(), - reinterpret_cast( shadingRatePalettes.data() ) ); - } - - // wrapper function for command vkCmdSetCoarseSampleOrderNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoarseSampleOrderNV.html - VULKAN_HPP_INLINE void - CommandBuffer::setCoarseSampleOrderNV( CoarseSampleOrderTypeNV sampleOrderType, - ArrayProxy const & customSampleOrders ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoarseSampleOrderNV && "Function requires " ); - - getDispatcher()->vkCmdSetCoarseSampleOrderNV( static_cast( m_commandBuffer ), - static_cast( sampleOrderType ), - customSampleOrders.size(), - reinterpret_cast( customSampleOrders.data() ) ); - } - - //=== VK_NV_ray_tracing === - - // wrapper function for command vkCreateAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateAccelerationStructureNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createAccelerationStructureNV( AccelerationStructureCreateInfoNV const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateAccelerationStructureNV && "Function requires " ); - - VULKAN_HPP_NAMESPACE::AccelerationStructureNV accelerationStructure; - Result result = - static_cast( getDispatcher()->vkCreateAccelerationStructureNV( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &accelerationStructure ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createAccelerationStructureNV" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, AccelerationStructureNV( *this, *reinterpret_cast( &accelerationStructure ), allocator ) ); - } - - // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2KHR - Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV && - "Function requires " ); - - MemoryRequirements2KHR memoryRequirements; - getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetAccelerationStructureMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureMemoryRequirementsNV.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getAccelerationStructureMemoryRequirementsNV( const AccelerationStructureMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV && - "Function requires " ); - - StructureChain structureChain; - MemoryRequirements2KHR & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetAccelerationStructureMemoryRequirementsNV( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkBindAccelerationStructureMemoryNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindAccelerationStructureMemoryNV.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::bindAccelerationStructureMemoryNV( ArrayProxy const & bindInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBindAccelerationStructureMemoryNV && - "Function requires " ); - - Result result = static_cast( getDispatcher()->vkBindAccelerationStructureMemoryNV( - static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindAccelerationStructureMemoryNV" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCmdBuildAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildAccelerationStructureNV.html - VULKAN_HPP_INLINE void CommandBuffer::buildAccelerationStructureNV( const AccelerationStructureInfoNV & info, - VULKAN_HPP_NAMESPACE::Buffer instanceData, - DeviceSize instanceOffset, - Bool32 update, - VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, - VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, - VULKAN_HPP_NAMESPACE::Buffer scratch, - DeviceSize scratchOffset ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildAccelerationStructureNV && "Function requires " ); - - getDispatcher()->vkCmdBuildAccelerationStructureNV( static_cast( m_commandBuffer ), - reinterpret_cast( &info ), - static_cast( instanceData ), - static_cast( instanceOffset ), - static_cast( update ), - static_cast( dst ), - static_cast( src ), - static_cast( scratch ), - static_cast( scratchOffset ) ); - } - - // wrapper function for command vkCmdCopyAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyAccelerationStructureNV.html - VULKAN_HPP_INLINE void CommandBuffer::copyAccelerationStructureNV( VULKAN_HPP_NAMESPACE::AccelerationStructureNV dst, - VULKAN_HPP_NAMESPACE::AccelerationStructureNV src, - CopyAccelerationStructureModeKHR mode ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyAccelerationStructureNV && "Function requires " ); - - getDispatcher()->vkCmdCopyAccelerationStructureNV( static_cast( m_commandBuffer ), - static_cast( dst ), - static_cast( src ), - static_cast( mode ) ); - } - - // wrapper function for command vkCmdTraceRaysNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysNV.html - VULKAN_HPP_INLINE void CommandBuffer::traceRaysNV( VULKAN_HPP_NAMESPACE::Buffer raygenShaderBindingTableBuffer, - DeviceSize raygenShaderBindingOffset, - VULKAN_HPP_NAMESPACE::Buffer missShaderBindingTableBuffer, - DeviceSize missShaderBindingOffset, - DeviceSize missShaderBindingStride, - VULKAN_HPP_NAMESPACE::Buffer hitShaderBindingTableBuffer, - DeviceSize hitShaderBindingOffset, - DeviceSize hitShaderBindingStride, - VULKAN_HPP_NAMESPACE::Buffer callableShaderBindingTableBuffer, - DeviceSize callableShaderBindingOffset, - DeviceSize callableShaderBindingStride, - uint32_t width, - uint32_t height, - uint32_t depth ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysNV && "Function requires " ); - - getDispatcher()->vkCmdTraceRaysNV( static_cast( m_commandBuffer ), - static_cast( raygenShaderBindingTableBuffer ), - static_cast( raygenShaderBindingOffset ), - static_cast( missShaderBindingTableBuffer ), - static_cast( missShaderBindingOffset ), - static_cast( missShaderBindingStride ), - static_cast( hitShaderBindingTableBuffer ), - static_cast( hitShaderBindingOffset ), - static_cast( hitShaderBindingStride ), - static_cast( callableShaderBindingTableBuffer ), - static_cast( callableShaderBindingOffset ), - static_cast( callableShaderBindingStride ), - width, - height, - depth ); - } - - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createRayTracingPipelinesNV( Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRayTracingPipelinesNV && "Function requires " ); - - std::vector pipelines( createInfos.size() ); - Result result = - static_cast( getDispatcher()->vkCreateRayTracingPipelinesNV( static_cast( m_device ), - pipelineCache ? static_cast( **pipelineCache ) : 0, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRayTracingPipelinesNV", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - std::vector pipelinesRAII; - if ( result == Result::eSuccess ) - { - pipelinesRAII.reserve( pipelines.size() ); - for ( auto & pipeline : pipelines ) - { - pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); - } - - // wrapper function for command vkCreateRayTracingPipelinesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateRayTracingPipelinesNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createRayTracingPipelineNV( Optional const & pipelineCache, - RayTracingPipelineCreateInfoNV const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateRayTracingPipelinesNV && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Pipeline pipeline; - Result result = - static_cast( getDispatcher()->vkCreateRayTracingPipelinesNV( static_cast( m_device ), - pipelineCache ? static_cast( **pipelineCache ) : 0, - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createRayTracingPipelineNV", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); - } - - // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Pipeline::getRayTracingShaderGroupHandlesNV( uint32_t firstGroup, uint32_t groupCount, size_t dataSize ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV && - "Function requires or " ); - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast( m_device ), - static_cast( m_pipeline ), - firstGroup, - groupCount, - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandlesNV" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetRayTracingShaderGroupHandlesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRayTracingShaderGroupHandlesNV.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Pipeline::getRayTracingShaderGroupHandleNV( uint32_t firstGroup, - uint32_t groupCount ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV && - "Function requires or " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkGetRayTracingShaderGroupHandlesNV( static_cast( m_device ), - static_cast( m_pipeline ), - firstGroup, - groupCount, - sizeof( DataType ), - reinterpret_cast( &data ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::getRayTracingShaderGroupHandleNV" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetAccelerationStructureHandleNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type AccelerationStructureNV::getHandle( size_t dataSize ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV && "Function requires " ); - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = - static_cast( getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast( m_device ), - static_cast( m_accelerationStructureNV ), - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetAccelerationStructureHandleNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureHandleNV.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type AccelerationStructureNV::getHandle() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureHandleNV && "Function requires " ); - - DataType data; - Result result = - static_cast( getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast( m_device ), - static_cast( m_accelerationStructureNV ), - sizeof( DataType ), - reinterpret_cast( &data ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkCmdWriteAccelerationStructuresPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteAccelerationStructuresPropertiesNV.html - VULKAN_HPP_INLINE void - CommandBuffer::writeAccelerationStructuresPropertiesNV( ArrayProxy const & accelerationStructures, - QueryType queryType, - VULKAN_HPP_NAMESPACE::QueryPool queryPool, - uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV && - "Function requires " ); - - getDispatcher()->vkCmdWriteAccelerationStructuresPropertiesNV( static_cast( m_commandBuffer ), - accelerationStructures.size(), - reinterpret_cast( accelerationStructures.data() ), - static_cast( queryType ), - static_cast( queryPool ), - firstQuery ); - } - - // wrapper function for command vkCompileDeferredNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCompileDeferredNV.html - VULKAN_HPP_INLINE typename ResultValueType::type Pipeline::compileDeferredNV( uint32_t shader ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCompileDeferredNV && "Function requires " ); - - Result result = - static_cast( getDispatcher()->vkCompileDeferredNV( static_cast( m_device ), static_cast( m_pipeline ), shader ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Pipeline::compileDeferredNV" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - //=== VK_KHR_maintenance3 === - - // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutSupport - Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupportKHR && - "Function requires or " ); - - DescriptorSetLayoutSupport support; - getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( &support ) ); - - return support; - } - - // wrapper function for command vkGetDescriptorSetLayoutSupportKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSupportKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getDescriptorSetLayoutSupportKHR( const DescriptorSetLayoutCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSupportKHR && - "Function requires or " ); - - StructureChain structureChain; - DescriptorSetLayoutSupport & support = structureChain.template get(); - getDispatcher()->vkGetDescriptorSetLayoutSupportKHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( &support ) ); - - return structureChain; - } - - //=== VK_KHR_draw_indirect_count === - - // wrapper function for command vkCmdDrawIndirectCountKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndirectCountKHR.html - VULKAN_HPP_INLINE void CommandBuffer::drawIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawIndirectCountKHR && - "Function requires or or " ); - - getDispatcher()->vkCmdDrawIndirectCountKHR( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - // wrapper function for command vkCmdDrawIndexedIndirectCountKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawIndexedIndirectCountKHR.html - VULKAN_HPP_INLINE void CommandBuffer::drawIndexedIndirectCountKHR( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkCmdDrawIndexedIndirectCountKHR && - "Function requires or or " ); - - getDispatcher()->vkCmdDrawIndexedIndirectCountKHR( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - //=== VK_EXT_external_memory_host === - - // wrapper function for command vkGetMemoryHostPointerPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryHostPointerPropertiesEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryHostPointerPropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, const void * pHostPointer ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryHostPointerPropertiesEXT && - "Function requires " ); - - MemoryHostPointerPropertiesEXT memoryHostPointerProperties; - Result result = static_cast( - getDispatcher()->vkGetMemoryHostPointerPropertiesEXT( static_cast( m_device ), - static_cast( handleType ), - pHostPointer, - reinterpret_cast( &memoryHostPointerProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryHostPointerPropertiesEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryHostPointerProperties ) ); - } - - //=== VK_AMD_buffer_marker === - - // wrapper function for command vkCmdWriteBufferMarkerAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarkerAMD.html - VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarkerAMD( PipelineStageFlagBits pipelineStage, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer, - DeviceSize dstOffset, - uint32_t marker ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarkerAMD && "Function requires " ); - - getDispatcher()->vkCmdWriteBufferMarkerAMD( static_cast( m_commandBuffer ), - static_cast( pipelineStage ), - static_cast( dstBuffer ), - static_cast( dstOffset ), - marker ); - } - - // wrapper function for command vkCmdWriteBufferMarker2AMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteBufferMarker2AMD.html - VULKAN_HPP_INLINE void CommandBuffer::writeBufferMarker2AMD( PipelineStageFlags2 stage, - VULKAN_HPP_NAMESPACE::Buffer dstBuffer, - DeviceSize dstOffset, - uint32_t marker ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteBufferMarker2AMD && "Function requires " ); - - getDispatcher()->vkCmdWriteBufferMarker2AMD( static_cast( m_commandBuffer ), - static_cast( stage ), - static_cast( dstBuffer ), - static_cast( dstOffset ), - marker ); - } - - //=== VK_EXT_calibrated_timestamps === - - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getCalibrateableTimeDomainsEXT() const - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT && - "Function requires or " ); - - std::vector timeDomains; - uint32_t timeDomainCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( static_cast( m_physicalDevice ), &timeDomainCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && timeDomainCount ) - { - timeDomains.resize( timeDomainCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsEXT( - static_cast( m_physicalDevice ), &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsEXT" ); - VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); - if ( timeDomainCount < timeDomains.size() ) - { - timeDomains.resize( timeDomainCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) ); - } - - // wrapper function for command vkGetCalibratedTimestampsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type - Device::getCalibratedTimestampsEXT( ArrayProxy const & timestampInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && - "Function requires or " ); - - std::pair, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); - std::vector & timestamps = data_.first; - uint64_t & maxDeviation = data_.second; - Result result = - static_cast( getDispatcher()->vkGetCalibratedTimestampsEXT( static_cast( m_device ), - timestampInfos.size(), - reinterpret_cast( timestampInfos.data() ), - timestamps.data(), - &maxDeviation ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getCalibratedTimestampsEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetCalibratedTimestampsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getCalibratedTimestampEXT( const CalibratedTimestampInfoKHR & timestampInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsEXT && - "Function requires or " ); - - std::pair data_; - uint64_t & timestamp = data_.first; - uint64_t & maxDeviation = data_.second; - Result result = static_cast( getDispatcher()->vkGetCalibratedTimestampsEXT( - static_cast( m_device ), 1, reinterpret_cast( ×tampInfo ), ×tamp, &maxDeviation ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getCalibratedTimestampEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); - } - - //=== VK_NV_mesh_shader === - - // wrapper function for command vkCmdDrawMeshTasksNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksNV.html - VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksNV( uint32_t taskCount, uint32_t firstTask ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksNV && "Function requires " ); - - getDispatcher()->vkCmdDrawMeshTasksNV( static_cast( m_commandBuffer ), taskCount, firstTask ); - } - - // wrapper function for command vkCmdDrawMeshTasksIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectNV.html - VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectNV( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - uint32_t drawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectNV && "Function requires " ); - - getDispatcher()->vkCmdDrawMeshTasksIndirectNV( - static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); - } - - // wrapper function for command vkCmdDrawMeshTasksIndirectCountNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountNV.html - VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountNV( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV && "Function requires " ); - - getDispatcher()->vkCmdDrawMeshTasksIndirectCountNV( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - //=== VK_NV_scissor_exclusive === - - // wrapper function for command vkCmdSetExclusiveScissorEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorEnableNV.html - VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorEnableNV( uint32_t firstExclusiveScissor, - ArrayProxy const & exclusiveScissorEnables ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorEnableNV && - "Function requires " ); - - getDispatcher()->vkCmdSetExclusiveScissorEnableNV( static_cast( m_commandBuffer ), - firstExclusiveScissor, - exclusiveScissorEnables.size(), - reinterpret_cast( exclusiveScissorEnables.data() ) ); - } - - // wrapper function for command vkCmdSetExclusiveScissorNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExclusiveScissorNV.html - VULKAN_HPP_INLINE void CommandBuffer::setExclusiveScissorNV( uint32_t firstExclusiveScissor, - ArrayProxy const & exclusiveScissors ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExclusiveScissorNV && "Function requires " ); - - getDispatcher()->vkCmdSetExclusiveScissorNV( static_cast( m_commandBuffer ), - firstExclusiveScissor, - exclusiveScissors.size(), - reinterpret_cast( exclusiveScissors.data() ) ); - } - - //=== VK_NV_device_diagnostic_checkpoints === - - // wrapper function for command vkCmdSetCheckpointNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCheckpointNV.html - template - VULKAN_HPP_INLINE void CommandBuffer::setCheckpointNV( CheckpointMarkerType const & checkpointMarker ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCheckpointNV && "Function requires " ); - - getDispatcher()->vkCmdSetCheckpointNV( static_cast( m_commandBuffer ), reinterpret_cast( &checkpointMarker ) ); - } - - // wrapper function for command vkGetQueueCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointDataNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Queue::getCheckpointDataNV() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointDataNV && - "Function requires " ); - - std::vector checkpointData; - uint32_t checkpointDataCount; - getDispatcher()->vkGetQueueCheckpointDataNV( static_cast( m_queue ), &checkpointDataCount, nullptr ); - checkpointData.resize( checkpointDataCount ); - getDispatcher()->vkGetQueueCheckpointDataNV( - static_cast( m_queue ), &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); - - VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); - if ( checkpointDataCount < checkpointData.size() ) - { - checkpointData.resize( checkpointDataCount ); - } - return checkpointData; - } - - // wrapper function for command vkGetQueueCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetQueueCheckpointData2NV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Queue::getCheckpointData2NV() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetQueueCheckpointData2NV && - "Function requires " ); - - std::vector checkpointData; - uint32_t checkpointDataCount; - getDispatcher()->vkGetQueueCheckpointData2NV( static_cast( m_queue ), &checkpointDataCount, nullptr ); - checkpointData.resize( checkpointDataCount ); - getDispatcher()->vkGetQueueCheckpointData2NV( - static_cast( m_queue ), &checkpointDataCount, reinterpret_cast( checkpointData.data() ) ); - - VULKAN_HPP_ASSERT( checkpointDataCount <= checkpointData.size() ); - if ( checkpointDataCount < checkpointData.size() ) - { - checkpointData.resize( checkpointDataCount ); - } - return checkpointData; - } - - //=== VK_KHR_timeline_semaphore === - - // wrapper function for command vkGetSemaphoreCounterValueKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreCounterValueKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Semaphore::getCounterValueKHR() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreCounterValueKHR && - "Function requires or " ); - - uint64_t value; - Result result = static_cast( - getDispatcher()->vkGetSemaphoreCounterValueKHR( static_cast( m_device ), static_cast( m_semaphore ), &value ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Semaphore::getCounterValueKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( value ) ); - } - - // wrapper function for command vkWaitSemaphoresKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitSemaphoresKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::waitSemaphoresKHR( const SemaphoreWaitInfo & waitInfo, uint64_t timeout ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkWaitSemaphoresKHR && "Function requires or " ); - - Result result = static_cast( - getDispatcher()->vkWaitSemaphoresKHR( static_cast( m_device ), reinterpret_cast( &waitInfo ), timeout ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::waitSemaphoresKHR", { Result::eSuccess, Result::eTimeout } ); - - return static_cast( result ); - } - - // wrapper function for command vkSignalSemaphoreKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSignalSemaphoreKHR.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::signalSemaphoreKHR( const SemaphoreSignalInfo & signalInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSignalSemaphoreKHR && "Function requires or " ); - - Result result = static_cast( - getDispatcher()->vkSignalSemaphoreKHR( static_cast( m_device ), reinterpret_cast( &signalInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::signalSemaphoreKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - //=== VK_EXT_present_timing === - - // wrapper function for command vkSetSwapchainPresentTimingQueueSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetSwapchainPresentTimingQueueSizeEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::setPresentTimingQueueSizeEXT( uint32_t size ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetSwapchainPresentTimingQueueSizeEXT && - "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkSetSwapchainPresentTimingQueueSizeEXT( static_cast( m_device ), static_cast( m_swapchainKHR ), size ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::setPresentTimingQueueSizeEXT", { Result::eSuccess, Result::eNotReady } ); - - return static_cast( result ); - } - - // wrapper function for command vkGetSwapchainTimingPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimingPropertiesEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ResultValue> SwapchainKHR::getTimingPropertiesEXT() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainTimingPropertiesEXT && - "Function requires " ); - - std::pair data_; - SwapchainTimingPropertiesEXT & swapchainTimingProperties = data_.first; - uint64_t & swapchainTimingPropertiesCounter = data_.second; - Result result = static_cast( - getDispatcher()->vkGetSwapchainTimingPropertiesEXT( static_cast( m_device ), - static_cast( m_swapchainKHR ), - reinterpret_cast( &swapchainTimingProperties ), - &swapchainTimingPropertiesCounter ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::getTimingPropertiesEXT", { Result::eSuccess, Result::eNotReady } ); - - return ResultValue>( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetSwapchainTimeDomainPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSwapchainTimeDomainPropertiesEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::getTimeDomainPropertiesEXT( SwapchainTimeDomainPropertiesEXT * pSwapchainTimeDomainProperties, - uint64_t * pTimeDomainsCounter ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainTimeDomainPropertiesEXT && - "Function requires " ); - return static_cast( - getDispatcher()->vkGetSwapchainTimeDomainPropertiesEXT( static_cast( m_device ), - static_cast( m_swapchainKHR ), - reinterpret_cast( pSwapchainTimeDomainProperties ), - pTimeDomainsCounter ) ); - } // wrapper function for command vkGetPastPresentationTimingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPastPresentationTimingEXT.html - - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::getPastPresentationTimingEXT( const PastPresentationTimingInfoEXT * pPastPresentationTimingInfo, - PastPresentationTimingPropertiesEXT * pPastPresentationTimingProperties ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPastPresentationTimingEXT && "Function requires " ); - return static_cast( - getDispatcher()->vkGetPastPresentationTimingEXT( static_cast( m_device ), - reinterpret_cast( pPastPresentationTimingInfo ), - reinterpret_cast( pPastPresentationTimingProperties ) ) ); - } - - //=== VK_INTEL_performance_query === - - // wrapper function for command vkInitializePerformanceApiINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkInitializePerformanceApiINTEL.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::initializePerformanceApiINTEL( const InitializePerformanceApiInfoINTEL & initializeInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkInitializePerformanceApiINTEL && - "Function requires " ); - - Result result = static_cast( getDispatcher()->vkInitializePerformanceApiINTEL( - static_cast( m_device ), reinterpret_cast( &initializeInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::initializePerformanceApiINTEL" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkUninitializePerformanceApiINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUninitializePerformanceApiINTEL.html - VULKAN_HPP_INLINE void Device::uninitializePerformanceApiINTEL() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkUninitializePerformanceApiINTEL && - "Function requires " ); - - getDispatcher()->vkUninitializePerformanceApiINTEL( static_cast( m_device ) ); - } - - // wrapper function for command vkCmdSetPerformanceMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceMarkerINTEL.html - VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::setPerformanceMarkerINTEL( const PerformanceMarkerInfoINTEL & markerInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPerformanceMarkerINTEL && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkCmdSetPerformanceMarkerINTEL( - static_cast( m_commandBuffer ), reinterpret_cast( &markerInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::setPerformanceMarkerINTEL" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCmdSetPerformanceStreamMarkerINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceStreamMarkerINTEL.html - VULKAN_HPP_INLINE typename ResultValueType::type - CommandBuffer::setPerformanceStreamMarkerINTEL( const PerformanceStreamMarkerInfoINTEL & markerInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL && - "Function requires " ); - - Result result = static_cast( getDispatcher()->vkCmdSetPerformanceStreamMarkerINTEL( - static_cast( m_commandBuffer ), reinterpret_cast( &markerInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::setPerformanceStreamMarkerINTEL" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCmdSetPerformanceOverrideINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPerformanceOverrideINTEL.html - VULKAN_HPP_INLINE typename ResultValueType::type CommandBuffer::setPerformanceOverrideINTEL( const PerformanceOverrideInfoINTEL & overrideInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPerformanceOverrideINTEL && - "Function requires " ); - - Result result = static_cast( getDispatcher()->vkCmdSetPerformanceOverrideINTEL( - static_cast( m_commandBuffer ), reinterpret_cast( &overrideInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CommandBuffer::setPerformanceOverrideINTEL" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkAcquirePerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquirePerformanceConfigurationINTEL.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::acquirePerformanceConfigurationINTEL( PerformanceConfigurationAcquireInfoINTEL const & acquireInfo ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAcquirePerformanceConfigurationINTEL && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration; - Result result = static_cast( - getDispatcher()->vkAcquirePerformanceConfigurationINTEL( static_cast( m_device ), - reinterpret_cast( &acquireInfo ), - reinterpret_cast( &configuration ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::acquirePerformanceConfigurationINTEL" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, PerformanceConfigurationINTEL( *this, *reinterpret_cast( &configuration ) ) ); - } - - // wrapper function for command vkQueueSetPerformanceConfigurationINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSetPerformanceConfigurationINTEL.html - VULKAN_HPP_INLINE typename ResultValueType::type - Queue::setPerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL configuration ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSetPerformanceConfigurationINTEL && - "Function requires " ); - - Result result = static_cast( getDispatcher()->vkQueueSetPerformanceConfigurationINTEL( - static_cast( m_queue ), static_cast( configuration ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::setPerformanceConfigurationINTEL" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetPerformanceParameterINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPerformanceParameterINTEL.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getPerformanceParameterINTEL( PerformanceParameterTypeINTEL parameter ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPerformanceParameterINTEL && "Function requires " ); - - PerformanceValueINTEL value; - Result result = static_cast( getDispatcher()->vkGetPerformanceParameterINTEL( - static_cast( m_device ), static_cast( parameter ), reinterpret_cast( &value ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPerformanceParameterINTEL" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( value ) ); - } - - //=== VK_AMD_display_native_hdr === - - // wrapper function for command vkSetLocalDimmingAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLocalDimmingAMD.html - VULKAN_HPP_INLINE void SwapchainKHR::setLocalDimmingAMD( Bool32 localDimmingEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetLocalDimmingAMD && "Function requires " ); - - getDispatcher()->vkSetLocalDimmingAMD( - static_cast( m_device ), static_cast( m_swapchainKHR ), static_cast( localDimmingEnable ) ); - } - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - - // wrapper function for command vkCreateImagePipeSurfaceFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateImagePipeSurfaceFUCHSIA.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createImagePipeSurfaceFUCHSIA( ImagePipeSurfaceCreateInfoFUCHSIA const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateImagePipeSurfaceFUCHSIA && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = - static_cast( getDispatcher()->vkCreateImagePipeSurfaceFUCHSIA( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createImagePipeSurfaceFUCHSIA" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - - // wrapper function for command vkCreateMetalSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMetalSurfaceEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createMetalSurfaceEXT( MetalSurfaceCreateInfoEXT const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateMetalSurfaceEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateMetalSurfaceEXT( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createMetalSurfaceEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_fragment_shading_rate === - - // wrapper function for command vkGetPhysicalDeviceFragmentShadingRatesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceFragmentShadingRatesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getFragmentShadingRatesKHR() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR && - "Function requires " ); - - std::vector fragmentShadingRates; - uint32_t fragmentShadingRateCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( - static_cast( m_physicalDevice ), &fragmentShadingRateCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && fragmentShadingRateCount ) - { - fragmentShadingRates.resize( fragmentShadingRateCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceFragmentShadingRatesKHR( - static_cast( m_physicalDevice ), - &fragmentShadingRateCount, - reinterpret_cast( fragmentShadingRates.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getFragmentShadingRatesKHR" ); - VULKAN_HPP_ASSERT( fragmentShadingRateCount <= fragmentShadingRates.size() ); - if ( fragmentShadingRateCount < fragmentShadingRates.size() ) - { - fragmentShadingRates.resize( fragmentShadingRateCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( fragmentShadingRates ) ); - } - - // wrapper function for command vkCmdSetFragmentShadingRateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateKHR.html - VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateKHR( const Extent2D & fragmentSize, - const FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFragmentShadingRateKHR && - "Function requires " ); - - getDispatcher()->vkCmdSetFragmentShadingRateKHR( static_cast( m_commandBuffer ), - reinterpret_cast( &fragmentSize ), - reinterpret_cast( combinerOps ) ); - } - - //=== VK_KHR_dynamic_rendering_local_read === - - // wrapper function for command vkCmdSetRenderingAttachmentLocationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingAttachmentLocationsKHR.html - VULKAN_HPP_INLINE void CommandBuffer::setRenderingAttachmentLocationsKHR( const RenderingAttachmentLocationInfo & locationInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingAttachmentLocationsKHR && - "Function requires or " ); - - getDispatcher()->vkCmdSetRenderingAttachmentLocationsKHR( static_cast( m_commandBuffer ), - reinterpret_cast( &locationInfo ) ); - } - - // wrapper function for command vkCmdSetRenderingInputAttachmentIndicesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRenderingInputAttachmentIndicesKHR.html - VULKAN_HPP_INLINE void - CommandBuffer::setRenderingInputAttachmentIndicesKHR( const RenderingInputAttachmentIndexInfo & inputAttachmentIndexInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRenderingInputAttachmentIndicesKHR && - "Function requires or " ); - - getDispatcher()->vkCmdSetRenderingInputAttachmentIndicesKHR( static_cast( m_commandBuffer ), - reinterpret_cast( &inputAttachmentIndexInfo ) ); - } - - //=== VK_EXT_buffer_device_address === - - // wrapper function for command vkGetBufferDeviceAddressEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressEXT( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkGetBufferDeviceAddressEXT && - "Function requires or or " ); - - VkDeviceAddress result = - getDispatcher()->vkGetBufferDeviceAddressEXT( static_cast( m_device ), reinterpret_cast( &info ) ); - - return static_cast( result ); - } - - //=== VK_EXT_tooling_info === - - // wrapper function for command vkGetPhysicalDeviceToolPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceToolPropertiesEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getToolPropertiesEXT() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT && - "Function requires or " ); - - std::vector toolProperties; - uint32_t toolCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( static_cast( m_physicalDevice ), &toolCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && toolCount ) - { - toolProperties.resize( toolCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceToolPropertiesEXT( - static_cast( m_physicalDevice ), &toolCount, reinterpret_cast( toolProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getToolPropertiesEXT" ); - VULKAN_HPP_ASSERT( toolCount <= toolProperties.size() ); - if ( toolCount < toolProperties.size() ) - { - toolProperties.resize( toolCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( toolProperties ) ); - } - - //=== VK_KHR_present_wait === - - // wrapper function for command vkWaitForPresentKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresentKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::waitForPresent( uint64_t presentId, uint64_t timeout ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForPresentKHR && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkWaitForPresentKHR( static_cast( m_device ), static_cast( m_swapchainKHR ), presentId, timeout ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::waitForPresent", - { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::waitForPresent", { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR } ); -# endif - - return static_cast( result ); - } - - //=== VK_NV_cooperative_matrix === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCooperativeMatrixPropertiesNV() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV && - "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesNV( - static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesNV" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - //=== VK_NV_coverage_reduction_mode === - - // wrapper function for command vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV && - "Function requires " ); - - std::vector combinations; - uint32_t combinationCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - static_cast( m_physicalDevice ), &combinationCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && combinationCount ) - { - combinations.resize( combinationCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - static_cast( m_physicalDevice ), - &combinationCount, - reinterpret_cast( combinations.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSupportedFramebufferMixedSamplesCombinationsNV" ); - VULKAN_HPP_ASSERT( combinationCount <= combinations.size() ); - if ( combinationCount < combinations.size() ) - { - combinations.resize( combinationCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( combinations ) ); - } - -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - - // wrapper function for command vkGetPhysicalDeviceSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceSurfacePresentModes2EXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT && - "Function requires " ); - - std::vector presentModes; - uint32_t presentModeCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast( m_physicalDevice ), - reinterpret_cast( &surfaceInfo ), - &presentModeCount, - nullptr ) ); - if ( ( result == Result::eSuccess ) && presentModeCount ) - { - presentModes.resize( presentModeCount ); - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceSurfacePresentModes2EXT( static_cast( m_physicalDevice ), - reinterpret_cast( &surfaceInfo ), - &presentModeCount, - reinterpret_cast( presentModes.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getSurfacePresentModes2EXT" ); - VULKAN_HPP_ASSERT( presentModeCount <= presentModes.size() ); - if ( presentModeCount < presentModes.size() ) - { - presentModes.resize( presentModeCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( presentModes ) ); - } - - // wrapper function for command vkAcquireFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireFullScreenExclusiveModeEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type SwapchainKHR::acquireFullScreenExclusiveModeEXT() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireFullScreenExclusiveModeEXT && - "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkAcquireFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( m_swapchainKHR ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkReleaseFullScreenExclusiveModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseFullScreenExclusiveModeEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type SwapchainKHR::releaseFullScreenExclusiveModeEXT() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseFullScreenExclusiveModeEXT && - "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkReleaseFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( m_swapchainKHR ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetDeviceGroupSurfacePresentModes2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceGroupSurfacePresentModes2EXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getGroupSurfacePresentModes2EXT( const PhysicalDeviceSurfaceInfo2KHR & surfaceInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT && - "Function requires " ); - - DeviceGroupPresentModeFlagsKHR modes; - Result result = static_cast( - getDispatcher()->vkGetDeviceGroupSurfacePresentModes2EXT( static_cast( m_device ), - reinterpret_cast( &surfaceInfo ), - reinterpret_cast( &modes ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getGroupSurfacePresentModes2EXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( modes ) ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - - // wrapper function for command vkCreateHeadlessSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateHeadlessSurfaceEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createHeadlessSurfaceEXT( HeadlessSurfaceCreateInfoEXT const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateHeadlessSurfaceEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateHeadlessSurfaceEXT( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createHeadlessSurfaceEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } - - //=== VK_KHR_buffer_device_address === - - // wrapper function for command vkGetBufferDeviceAddressKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferDeviceAddressKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceAddress Device::getBufferAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkGetBufferDeviceAddressKHR && - "Function requires or or " ); - - VkDeviceAddress result = - getDispatcher()->vkGetBufferDeviceAddressKHR( static_cast( m_device ), reinterpret_cast( &info ) ); - - return static_cast( result ); - } - - // wrapper function for command vkGetBufferOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureAddressKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getBufferOpaqueCaptureAddressKHR( const BufferDeviceAddressInfo & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR && - "Function requires or " ); - - uint64_t result = - getDispatcher()->vkGetBufferOpaqueCaptureAddressKHR( static_cast( m_device ), reinterpret_cast( &info ) ); - - return result; - } - - // wrapper function for command vkGetDeviceMemoryOpaqueCaptureAddressKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMemoryOpaqueCaptureAddressKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t - Device::getMemoryOpaqueCaptureAddressKHR( const DeviceMemoryOpaqueCaptureAddressInfo & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR && - "Function requires or " ); - - uint64_t result = getDispatcher()->vkGetDeviceMemoryOpaqueCaptureAddressKHR( static_cast( m_device ), - reinterpret_cast( &info ) ); - - return result; - } - - //=== VK_EXT_line_rasterization === - - // wrapper function for command vkCmdSetLineStippleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEXT( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetLineStippleEXT( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); - } - - //=== VK_EXT_host_query_reset === - - // wrapper function for command vkResetQueryPoolEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkResetQueryPoolEXT.html - VULKAN_HPP_INLINE void QueryPool::resetEXT( uint32_t firstQuery, uint32_t queryCount ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkResetQueryPoolEXT && "Function requires or " ); - - getDispatcher()->vkResetQueryPoolEXT( static_cast( m_device ), static_cast( m_queryPool ), firstQuery, queryCount ); - } - - //=== VK_EXT_extended_dynamic_state === - - // wrapper function for command vkCmdSetCullModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCullModeEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullModeEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetCullModeEXT( static_cast( m_commandBuffer ), static_cast( cullMode ) ); - } - - // wrapper function for command vkCmdSetFrontFaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFrontFaceEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFaceEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetFrontFaceEXT( static_cast( m_commandBuffer ), static_cast( frontFace ) ); - } - - // wrapper function for command vkCmdSetPrimitiveTopologyEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveTopologyEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveTopologyEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetPrimitiveTopologyEXT( static_cast( m_commandBuffer ), static_cast( primitiveTopology ) ); - } - - // wrapper function for command vkCmdSetViewportWithCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWithCountEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setViewportWithCountEXT( ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWithCountEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetViewportWithCountEXT( - static_cast( m_commandBuffer ), viewports.size(), reinterpret_cast( viewports.data() ) ); - } - - // wrapper function for command vkCmdSetScissorWithCountEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetScissorWithCountEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setScissorWithCountEXT( ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissorWithCountEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetScissorWithCountEXT( - static_cast( m_commandBuffer ), scissors.size(), reinterpret_cast( scissors.data() ) ); - } - - // wrapper function for command vkCmdBindVertexBuffers2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindVertexBuffers2EXT.html - VULKAN_HPP_INLINE void CommandBuffer::bindVertexBuffers2EXT( uint32_t firstBinding, - ArrayProxy const & buffers, - ArrayProxy const & offsets, - ArrayProxy const & sizes, - ArrayProxy const & strides ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers2EXT && - "Function requires or or " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( buffers.size() == offsets.size() ); - VULKAN_HPP_ASSERT( sizes.empty() || buffers.size() == sizes.size() ); - VULKAN_HPP_ASSERT( strides.empty() || buffers.size() == strides.size() ); -# else - if ( buffers.size() != offsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); - } - if ( !sizes.empty() && buffers.size() != sizes.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != sizes.size()" ); - } - if ( !strides.empty() && buffers.size() != strides.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != strides.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdBindVertexBuffers2EXT( static_cast( m_commandBuffer ), - firstBinding, - buffers.size(), - reinterpret_cast( buffers.data() ), - reinterpret_cast( offsets.data() ), - reinterpret_cast( sizes.data() ), - reinterpret_cast( strides.data() ) ); - } - - // wrapper function for command vkCmdSetDepthTestEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthTestEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthTestEnableEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetDepthTestEnableEXT( static_cast( m_commandBuffer ), static_cast( depthTestEnable ) ); - } - - // wrapper function for command vkCmdSetDepthWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthWriteEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthWriteEnableEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetDepthWriteEnableEXT( static_cast( m_commandBuffer ), static_cast( depthWriteEnable ) ); - } - - // wrapper function for command vkCmdSetDepthCompareOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthCompareOpEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthCompareOpEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetDepthCompareOpEXT( static_cast( m_commandBuffer ), static_cast( depthCompareOp ) ); - } - - // wrapper function for command vkCmdSetDepthBoundsTestEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBoundsTestEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT( static_cast( m_commandBuffer ), static_cast( depthBoundsTestEnable ) ); - } - - // wrapper function for command vkCmdSetStencilTestEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilTestEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilTestEnableEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetStencilTestEnableEXT( static_cast( m_commandBuffer ), static_cast( stencilTestEnable ) ); - } - - // wrapper function for command vkCmdSetStencilOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetStencilOpEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setStencilOpEXT( - StencilFaceFlags faceMask, StencilOp failOp, StencilOp passOp, StencilOp depthFailOp, CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOpEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetStencilOpEXT( static_cast( m_commandBuffer ), - static_cast( faceMask ), - static_cast( failOp ), - static_cast( passOp ), - static_cast( depthFailOp ), - static_cast( compareOp ) ); - } - - //=== VK_KHR_deferred_host_operations === - - // wrapper function for command vkCreateDeferredOperationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDeferredOperationKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createDeferredOperationKHR( Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDeferredOperationKHR && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation; - Result result = static_cast( getDispatcher()->vkCreateDeferredOperationKHR( static_cast( m_device ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &deferredOperation ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDeferredOperationKHR" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, DeferredOperationKHR( *this, *reinterpret_cast( &deferredOperation ), allocator ) ); - } - - // wrapper function for command vkGetDeferredOperationMaxConcurrencyKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationMaxConcurrencyKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint32_t DeferredOperationKHR::getMaxConcurrency() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR && - "Function requires " ); - - uint32_t result = getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR( static_cast( m_device ), - static_cast( m_deferredOperationKHR ) ); - - return result; - } - - // wrapper function for command vkGetDeferredOperationResultKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeferredOperationResultKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result DeferredOperationKHR::getResult() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeferredOperationResultKHR && - "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkGetDeferredOperationResultKHR( static_cast( m_device ), static_cast( m_deferredOperationKHR ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DeferredOperationKHR::getResult", { Result::eSuccess, Result::eNotReady } ); - - return static_cast( result ); - } - - // wrapper function for command vkDeferredOperationJoinKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDeferredOperationJoinKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result DeferredOperationKHR::join() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkDeferredOperationJoinKHR && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkDeferredOperationJoinKHR( static_cast( m_device ), static_cast( m_deferredOperationKHR ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DeferredOperationKHR::join", { Result::eSuccess, Result::eThreadDoneKHR, Result::eThreadIdleKHR } ); - - return static_cast( result ); - } - - //=== VK_KHR_pipeline_executable_properties === - - // wrapper function for command vkGetPipelineExecutablePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutablePropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getPipelineExecutablePropertiesKHR( const PipelineInfoKHR & pipelineInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineExecutablePropertiesKHR && - "Function requires " ); - - std::vector properties; - uint32_t executableCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetPipelineExecutablePropertiesKHR( - static_cast( m_device ), reinterpret_cast( &pipelineInfo ), &executableCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && executableCount ) - { - properties.resize( executableCount ); - result = static_cast( - getDispatcher()->vkGetPipelineExecutablePropertiesKHR( static_cast( m_device ), - reinterpret_cast( &pipelineInfo ), - &executableCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelineExecutablePropertiesKHR" ); - VULKAN_HPP_ASSERT( executableCount <= properties.size() ); - if ( executableCount < properties.size() ) - { - properties.resize( executableCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetPipelineExecutableStatisticsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableStatisticsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getPipelineExecutableStatisticsKHR( const PipelineExecutableInfoKHR & executableInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineExecutableStatisticsKHR && - "Function requires " ); - - std::vector statistics; - uint32_t statisticCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetPipelineExecutableStatisticsKHR( - static_cast( m_device ), reinterpret_cast( &executableInfo ), &statisticCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && statisticCount ) - { - statistics.resize( statisticCount ); - result = static_cast( - getDispatcher()->vkGetPipelineExecutableStatisticsKHR( static_cast( m_device ), - reinterpret_cast( &executableInfo ), - &statisticCount, - reinterpret_cast( statistics.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelineExecutableStatisticsKHR" ); - VULKAN_HPP_ASSERT( statisticCount <= statistics.size() ); - if ( statisticCount < statistics.size() ) - { - statistics.resize( statisticCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( statistics ) ); - } - - // wrapper function for command vkGetPipelineExecutableInternalRepresentationsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineExecutableInternalRepresentationsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getPipelineExecutableInternalRepresentationsKHR( const PipelineExecutableInfoKHR & executableInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR && - "Function requires " ); - - std::vector internalRepresentations; - uint32_t internalRepresentationCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR( static_cast( m_device ), - reinterpret_cast( &executableInfo ), - &internalRepresentationCount, - nullptr ) ); - if ( ( result == Result::eSuccess ) && internalRepresentationCount ) - { - internalRepresentations.resize( internalRepresentationCount ); - result = static_cast( getDispatcher()->vkGetPipelineExecutableInternalRepresentationsKHR( - static_cast( m_device ), - reinterpret_cast( &executableInfo ), - &internalRepresentationCount, - reinterpret_cast( internalRepresentations.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelineExecutableInternalRepresentationsKHR" ); - VULKAN_HPP_ASSERT( internalRepresentationCount <= internalRepresentations.size() ); - if ( internalRepresentationCount < internalRepresentations.size() ) - { - internalRepresentations.resize( internalRepresentationCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( internalRepresentations ) ); - } - - //=== VK_EXT_host_image_copy === - - // wrapper function for command vkCopyMemoryToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToImageEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::copyMemoryToImageEXT( const CopyMemoryToImageInfo & copyMemoryToImageInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToImageEXT && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkCopyMemoryToImageEXT( - static_cast( m_device ), reinterpret_cast( ©MemoryToImageInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMemoryToImageEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCopyImageToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToMemoryEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::copyImageToMemoryEXT( const CopyImageToMemoryInfo & copyImageToMemoryInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToMemoryEXT && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkCopyImageToMemoryEXT( - static_cast( m_device ), reinterpret_cast( ©ImageToMemoryInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyImageToMemoryEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCopyImageToImageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyImageToImageEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::copyImageToImageEXT( const CopyImageToImageInfo & copyImageToImageInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyImageToImageEXT && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkCopyImageToImageEXT( - static_cast( m_device ), reinterpret_cast( ©ImageToImageInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyImageToImageEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkTransitionImageLayoutEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkTransitionImageLayoutEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::transitionImageLayoutEXT( ArrayProxy const & transitions ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkTransitionImageLayoutEXT && - "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkTransitionImageLayoutEXT( - static_cast( m_device ), transitions.size(), reinterpret_cast( transitions.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::transitionImageLayoutEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetImageSubresourceLayout2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Image::getSubresourceLayout2EXT( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkGetImageSubresourceLayout2EXT && - "Function requires or or or " ); - - SubresourceLayout2 layout; - getDispatcher()->vkGetImageSubresourceLayout2EXT( static_cast( m_device ), - static_cast( m_image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return layout; - } - - // wrapper function for command vkGetImageSubresourceLayout2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2EXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Image::getSubresourceLayout2EXT( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkGetImageSubresourceLayout2EXT && - "Function requires or or or " ); - - StructureChain structureChain; - SubresourceLayout2 & layout = structureChain.template get(); - getDispatcher()->vkGetImageSubresourceLayout2EXT( static_cast( m_device ), - static_cast( m_image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return structureChain; - } - - //=== VK_KHR_map_memory2 === - - // wrapper function for command vkMapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkMapMemory2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type Device::mapMemory2KHR( const MemoryMapInfo & memoryMapInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory2KHR && "Function requires or " ); - - void * pData; - Result result = static_cast( - getDispatcher()->vkMapMemory2KHR( static_cast( m_device ), reinterpret_cast( &memoryMapInfo ), &pData ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::mapMemory2KHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pData ) ); - } - - // wrapper function for command vkUnmapMemory2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkUnmapMemory2KHR.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::unmapMemory2KHR( const MemoryUnmapInfo & memoryUnmapInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory2KHR && "Function requires or " ); - - Result result = static_cast( - getDispatcher()->vkUnmapMemory2KHR( static_cast( m_device ), reinterpret_cast( &memoryUnmapInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::unmapMemory2KHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - //=== VK_EXT_swapchain_maintenance1 === - - // wrapper function for command vkReleaseSwapchainImagesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::releaseSwapchainImagesEXT( const ReleaseSwapchainImagesInfoKHR & releaseInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseSwapchainImagesEXT && - "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkReleaseSwapchainImagesEXT( - static_cast( m_device ), reinterpret_cast( &releaseInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::releaseSwapchainImagesEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - //=== VK_NV_device_generated_commands === - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV && - "Function requires " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsNV.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getGeneratedCommandsMemoryRequirementsNV( const GeneratedCommandsMemoryRequirementsInfoNV & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV && - "Function requires " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsNV( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkCmdPreprocessGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsNV.html - VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsNV( const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPreprocessGeneratedCommandsNV && - "Function requires " ); - - getDispatcher()->vkCmdPreprocessGeneratedCommandsNV( static_cast( m_commandBuffer ), - reinterpret_cast( &generatedCommandsInfo ) ); - } - - // wrapper function for command vkCmdExecuteGeneratedCommandsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsNV.html - VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsNV( Bool32 isPreprocessed, - const GeneratedCommandsInfoNV & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdExecuteGeneratedCommandsNV && - "Function requires " ); - - getDispatcher()->vkCmdExecuteGeneratedCommandsNV( static_cast( m_commandBuffer ), - static_cast( isPreprocessed ), - reinterpret_cast( &generatedCommandsInfo ) ); - } - - // wrapper function for command vkCmdBindPipelineShaderGroupNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindPipelineShaderGroupNV.html - VULKAN_HPP_INLINE void CommandBuffer::bindPipelineShaderGroupNV( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::Pipeline pipeline, - uint32_t groupIndex ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindPipelineShaderGroupNV && - "Function requires " ); - - getDispatcher()->vkCmdBindPipelineShaderGroupNV( static_cast( m_commandBuffer ), - static_cast( pipelineBindPoint ), - static_cast( pipeline ), - groupIndex ); - } - - // wrapper function for command vkCreateIndirectCommandsLayoutNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createIndirectCommandsLayoutNV( IndirectCommandsLayoutCreateInfoNV const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateIndirectCommandsLayoutNV && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV indirectCommandsLayout; - Result result = - static_cast( getDispatcher()->vkCreateIndirectCommandsLayoutNV( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &indirectCommandsLayout ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutNV" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, IndirectCommandsLayoutNV( *this, *reinterpret_cast( &indirectCommandsLayout ), allocator ) ); - } - - //=== VK_EXT_depth_bias_control === - - // wrapper function for command vkCmdSetDepthBias2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBias2EXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthBias2EXT( const DepthBiasInfoEXT & depthBiasInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBias2EXT && "Function requires " ); - - getDispatcher()->vkCmdSetDepthBias2EXT( static_cast( m_commandBuffer ), reinterpret_cast( &depthBiasInfo ) ); - } - - //=== VK_EXT_acquire_drm_display === - - // wrapper function for command vkAcquireDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireDrmDisplayEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type PhysicalDevice::acquireDrmDisplayEXT( int32_t drmFd, VULKAN_HPP_NAMESPACE::DisplayKHR display ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireDrmDisplayEXT && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkAcquireDrmDisplayEXT( static_cast( m_physicalDevice ), drmFd, static_cast( display ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::acquireDrmDisplayEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetDrmDisplayEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDrmDisplayEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getDrmDisplayEXT( int32_t drmFd, uint32_t connectorId ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDrmDisplayEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::DisplayKHR display; - Result result = static_cast( getDispatcher()->vkGetDrmDisplayEXT( - static_cast( m_physicalDevice ), drmFd, connectorId, reinterpret_cast( &display ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getDrmDisplayEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, DisplayKHR( *this, *reinterpret_cast( &display ) ) ); - } - - //=== VK_EXT_private_data === - - // wrapper function for command vkCreatePrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePrivateDataSlotEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createPrivateDataSlotEXT( PrivateDataSlotCreateInfo const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreatePrivateDataSlotEXT && - "Function requires or " ); - - VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot; - Result result = static_cast( getDispatcher()->vkCreatePrivateDataSlotEXT( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &privateDataSlot ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createPrivateDataSlotEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, PrivateDataSlot( *this, *reinterpret_cast( &privateDataSlot ), allocator ) ); - } - - // wrapper function for command vkDestroyPrivateDataSlotEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyPrivateDataSlotEXT.html - VULKAN_HPP_INLINE void Device::destroyPrivateDataSlotEXT( VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, - Optional allocator ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkDestroyPrivateDataSlotEXT && - "Function requires or " ); - - getDispatcher()->vkDestroyPrivateDataSlotEXT( static_cast( m_device ), - static_cast( privateDataSlot ), - reinterpret_cast( allocator.get() ) ); - } - - // wrapper function for command vkSetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetPrivateDataEXT.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::setPrivateDataEXT( ObjectType objectType_, uint64_t objectHandle, VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot, uint64_t data ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetPrivateDataEXT && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkSetPrivateDataEXT( - static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), data ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::setPrivateDataEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetPrivateDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPrivateDataEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE uint64_t Device::getPrivateDataEXT( ObjectType objectType_, - uint64_t objectHandle, - VULKAN_HPP_NAMESPACE::PrivateDataSlot privateDataSlot ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPrivateDataEXT && "Function requires or " ); - - uint64_t data; - getDispatcher()->vkGetPrivateDataEXT( - static_cast( m_device ), static_cast( objectType_ ), objectHandle, static_cast( privateDataSlot ), &data ); - - return data; - } - - //=== VK_KHR_video_encode_queue === - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR * pQualityLevelInfo, - VideoEncodeQualityLevelPropertiesKHR * pQualityLevelProperties ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && - "Function requires " ); - return static_cast( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( - static_cast( m_physicalDevice ), - reinterpret_cast( pQualityLevelInfo ), - reinterpret_cast( pQualityLevelProperties ) ) ); - } - - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && - "Function requires " ); - - VideoEncodeQualityLevelPropertiesKHR qualityLevelProperties; - Result result = static_cast( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( - static_cast( m_physicalDevice ), - reinterpret_cast( &qualityLevelInfo ), - reinterpret_cast( &qualityLevelProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( qualityLevelProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR( const PhysicalDeviceVideoEncodeQualityLevelInfoKHR & qualityLevelInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR && - "Function requires " ); - - StructureChain structureChain; - VideoEncodeQualityLevelPropertiesKHR & qualityLevelProperties = structureChain.template get(); - Result result = static_cast( getDispatcher()->vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( - static_cast( m_physicalDevice ), - reinterpret_cast( &qualityLevelInfo ), - reinterpret_cast( &qualityLevelProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getVideoEncodeQualityLevelPropertiesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); - } - - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>>::type - Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetEncodedVideoSessionParametersKHR && - "Function requires " ); - - std::pair> data_; - VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first; - std::vector & data = data_.second; - size_t dataSize; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( - static_cast( m_device ), - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( - static_cast( m_device ), - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetEncodedVideoSessionParametersKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetEncodedVideoSessionParametersKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, std::vector>>::type - Device::getEncodedVideoSessionParametersKHR( const VideoEncodeSessionParametersGetInfoKHR & videoSessionParametersInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetEncodedVideoSessionParametersKHR && - "Function requires " ); - - std::pair, std::vector> data_; - VideoEncodeSessionParametersFeedbackInfoKHR & feedbackInfo = data_.first.template get(); - std::vector & data = data_.second; - size_t dataSize; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( - static_cast( m_device ), - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( getDispatcher()->vkGetEncodedVideoSessionParametersKHR( - static_cast( m_device ), - reinterpret_cast( &videoSessionParametersInfo ), - reinterpret_cast( &feedbackInfo ), - &dataSize, - reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getEncodedVideoSessionParametersKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkCmdEncodeVideoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEncodeVideoKHR.html - VULKAN_HPP_INLINE void CommandBuffer::encodeVideoKHR( const VideoEncodeInfoKHR & encodeInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEncodeVideoKHR && "Function requires " ); - - getDispatcher()->vkCmdEncodeVideoKHR( static_cast( m_commandBuffer ), reinterpret_cast( &encodeInfo ) ); - } - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - - // wrapper function for command vkCreateCudaModuleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaModuleNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createCudaModuleNV( CudaModuleCreateInfoNV const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateCudaModuleNV && "Function requires " ); - - VULKAN_HPP_NAMESPACE::CudaModuleNV module; - Result result = static_cast( getDispatcher()->vkCreateCudaModuleNV( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &module ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createCudaModuleNV" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, CudaModuleNV( *this, *reinterpret_cast( &module ), allocator ) ); - } - - // wrapper function for command vkGetCudaModuleCacheNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCudaModuleCacheNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type CudaModuleNV::getCache() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetCudaModuleCacheNV && "Function requires " ); - - std::vector cacheData; - size_t cacheSize; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetCudaModuleCacheNV( static_cast( m_device ), static_cast( m_cudaModuleNV ), &cacheSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && cacheSize ) - { - cacheData.resize( cacheSize ); - result = static_cast( getDispatcher()->vkGetCudaModuleCacheNV( - static_cast( m_device ), static_cast( m_cudaModuleNV ), &cacheSize, reinterpret_cast( cacheData.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::CudaModuleNV::getCache" ); - VULKAN_HPP_ASSERT( cacheSize <= cacheData.size() ); - if ( cacheSize < cacheData.size() ) - { - cacheData.resize( cacheSize ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( cacheData ) ); - } - - // wrapper function for command vkCreateCudaFunctionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateCudaFunctionNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createCudaFunctionNV( CudaFunctionCreateInfoNV const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateCudaFunctionNV && "Function requires " ); - - VULKAN_HPP_NAMESPACE::CudaFunctionNV function; - Result result = static_cast( getDispatcher()->vkCreateCudaFunctionNV( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &function ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createCudaFunctionNV" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, - CudaFunctionNV( *this, *reinterpret_cast( &function ), allocator ) ); - } - - // wrapper function for command vkCmdCudaLaunchKernelNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCudaLaunchKernelNV.html - VULKAN_HPP_INLINE void CommandBuffer::cudaLaunchKernelNV( const CudaLaunchInfoNV & launchInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCudaLaunchKernelNV && "Function requires " ); - - getDispatcher()->vkCmdCudaLaunchKernelNV( static_cast( m_commandBuffer ), reinterpret_cast( &launchInfo ) ); - } -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_QCOM_tile_shading === - - // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html - VULKAN_HPP_INLINE void CommandBuffer::dispatchTileQCOM( const DispatchTileInfoQCOM & dispatchTileInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchTileQCOM && "Function requires " ); - - getDispatcher()->vkCmdDispatchTileQCOM( static_cast( m_commandBuffer ), - reinterpret_cast( &dispatchTileInfo ) ); - } - - // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html - VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const PerTileBeginInfoQCOM & perTileBeginInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginPerTileExecutionQCOM && "Function requires " ); - - getDispatcher()->vkCmdBeginPerTileExecutionQCOM( static_cast( m_commandBuffer ), - reinterpret_cast( &perTileBeginInfo ) ); - } - - // wrapper function for command vkCmdEndPerTileExecutionQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html - VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const PerTileEndInfoQCOM & perTileEndInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndPerTileExecutionQCOM && "Function requires " ); - - getDispatcher()->vkCmdEndPerTileExecutionQCOM( static_cast( m_commandBuffer ), - reinterpret_cast( &perTileEndInfo ) ); - } - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - - // wrapper function for command vkExportMetalObjectsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkExportMetalObjectsEXT.html - VULKAN_HPP_INLINE void Device::exportMetalObjectsEXT( ExportMetalObjectsInfoEXT & metalObjectsInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkExportMetalObjectsEXT && "Function requires " ); - - getDispatcher()->vkExportMetalObjectsEXT( static_cast( m_device ), reinterpret_cast( &metalObjectsInfo ) ); - } -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_synchronization2 === - - // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::setEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetEvent2KHR && "Function requires or " ); - - getDispatcher()->vkCmdSetEvent2KHR( - static_cast( m_commandBuffer ), static_cast( event ), reinterpret_cast( &dependencyInfo ) ); - } - - // wrapper function for command vkCmdResetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResetEvent2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::resetEvent2KHR( VULKAN_HPP_NAMESPACE::Event event, PipelineStageFlags2 stageMask ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResetEvent2KHR && "Function requires or " ); - - getDispatcher()->vkCmdResetEvent2KHR( - static_cast( m_commandBuffer ), static_cast( event ), static_cast( stageMask ) ); - } - - // wrapper function for command vkCmdWaitEvents2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWaitEvents2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::waitEvents2KHR( ArrayProxy const & events, - ArrayProxy const & dependencyInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWaitEvents2KHR && "Function requires or " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( events.size() == dependencyInfos.size() ); -# else - if ( events.size() != dependencyInfos.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::waitEvents2KHR: events.size() != dependencyInfos.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdWaitEvents2KHR( static_cast( m_commandBuffer ), - events.size(), - reinterpret_cast( events.data() ), - reinterpret_cast( dependencyInfos.data() ) ); - } - - // wrapper function for command vkCmdPipelineBarrier2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPipelineBarrier2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::pipelineBarrier2KHR( const DependencyInfo & dependencyInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPipelineBarrier2KHR && - "Function requires or " ); - - getDispatcher()->vkCmdPipelineBarrier2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( &dependencyInfo ) ); - } - - // wrapper function for command vkCmdWriteTimestamp2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteTimestamp2KHR.html - VULKAN_HPP_INLINE void - CommandBuffer::writeTimestamp2KHR( PipelineStageFlags2 stage, VULKAN_HPP_NAMESPACE::QueryPool queryPool, uint32_t query ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteTimestamp2KHR && - "Function requires or " ); - - getDispatcher()->vkCmdWriteTimestamp2KHR( - static_cast( m_commandBuffer ), static_cast( stage ), static_cast( queryPool ), query ); - } - - // wrapper function for command vkQueueSubmit2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueSubmit2KHR.html - VULKAN_HPP_INLINE typename ResultValueType::type Queue::submit2KHR( ArrayProxy const & submits, - VULKAN_HPP_NAMESPACE::Fence fence ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueueSubmit2KHR && "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkQueueSubmit2KHR( - static_cast( m_queue ), submits.size(), reinterpret_cast( submits.data() ), static_cast( fence ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Queue::submit2KHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - //=== VK_EXT_descriptor_buffer === - - // wrapper function for command vkGetDescriptorSetLayoutSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutSizeEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize DescriptorSetLayout::getSizeEXT() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutSizeEXT && "Function requires " ); - - DeviceSize layoutSizeInBytes; - getDispatcher()->vkGetDescriptorSetLayoutSizeEXT( static_cast( m_device ), - static_cast( m_descriptorSetLayout ), - reinterpret_cast( &layoutSizeInBytes ) ); - - return layoutSizeInBytes; - } - - // wrapper function for command vkGetDescriptorSetLayoutBindingOffsetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutBindingOffsetEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceSize DescriptorSetLayout::getBindingOffsetEXT( uint32_t binding ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutBindingOffsetEXT && - "Function requires " ); - - DeviceSize offset; - getDispatcher()->vkGetDescriptorSetLayoutBindingOffsetEXT( - static_cast( m_device ), static_cast( m_descriptorSetLayout ), binding, reinterpret_cast( &offset ) ); - - return offset; - } - - // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html - VULKAN_HPP_INLINE void - Device::getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo, size_t dataSize, void * pDescriptor ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorEXT && "Function requires " ); - - getDispatcher()->vkGetDescriptorEXT( - static_cast( m_device ), reinterpret_cast( &descriptorInfo ), dataSize, pDescriptor ); - } - - // wrapper function for command vkGetDescriptorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorType Device::getDescriptorEXT( const DescriptorGetInfoEXT & descriptorInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorEXT && "Function requires " ); - - DescriptorType descriptor; - getDispatcher()->vkGetDescriptorEXT( static_cast( m_device ), - reinterpret_cast( &descriptorInfo ), - sizeof( DescriptorType ), - reinterpret_cast( &descriptor ) ); - - return descriptor; - } - - // wrapper function for command vkCmdBindDescriptorBuffersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBuffersEXT.html - VULKAN_HPP_INLINE void - CommandBuffer::bindDescriptorBuffersEXT( ArrayProxy const & bindingInfos ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorBuffersEXT && "Function requires " ); - - getDispatcher()->vkCmdBindDescriptorBuffersEXT( static_cast( m_commandBuffer ), - bindingInfos.size(), - reinterpret_cast( bindingInfos.data() ) ); - } - - // wrapper function for command vkCmdSetDescriptorBufferOffsetsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsetsEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDescriptorBufferOffsetsEXT( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t firstSet, - ArrayProxy const & bufferIndices, - ArrayProxy const & offsets ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDescriptorBufferOffsetsEXT && - "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( bufferIndices.size() == offsets.size() ); -# else - if ( bufferIndices.size() != offsets.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::setDescriptorBufferOffsetsEXT: bufferIndices.size() != offsets.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdSetDescriptorBufferOffsetsEXT( static_cast( m_commandBuffer ), - static_cast( pipelineBindPoint ), - static_cast( layout ), - firstSet, - bufferIndices.size(), - bufferIndices.data(), - reinterpret_cast( offsets.data() ) ); - } - - // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplersEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplersEXT.html - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplersEXT( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::PipelineLayout layout, - uint32_t set ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplersEXT && - "Function requires " ); - - getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplersEXT( - static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( layout ), set ); - } - - // wrapper function for command vkGetBufferOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferOpaqueCaptureDescriptorDataEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getBufferOpaqueCaptureDescriptorDataEXT( const BufferCaptureDescriptorDataInfoEXT & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferOpaqueCaptureDescriptorDataEXT && - "Function requires " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkGetBufferOpaqueCaptureDescriptorDataEXT( - static_cast( m_device ), reinterpret_cast( &info ), &data ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getBufferOpaqueCaptureDescriptorDataEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetImageOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageOpaqueCaptureDescriptorDataEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getImageOpaqueCaptureDescriptorDataEXT( const ImageCaptureDescriptorDataInfoEXT & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageOpaqueCaptureDescriptorDataEXT && - "Function requires " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkGetImageOpaqueCaptureDescriptorDataEXT( - static_cast( m_device ), reinterpret_cast( &info ), &data ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getImageOpaqueCaptureDescriptorDataEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetImageViewOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageViewOpaqueCaptureDescriptorDataEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getImageViewOpaqueCaptureDescriptorDataEXT( const ImageViewCaptureDescriptorDataInfoEXT & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetImageViewOpaqueCaptureDescriptorDataEXT && - "Function requires " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkGetImageViewOpaqueCaptureDescriptorDataEXT( - static_cast( m_device ), reinterpret_cast( &info ), &data ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getImageViewOpaqueCaptureDescriptorDataEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetSamplerOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSamplerOpaqueCaptureDescriptorDataEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getSamplerOpaqueCaptureDescriptorDataEXT( const SamplerCaptureDescriptorDataInfoEXT & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSamplerOpaqueCaptureDescriptorDataEXT && - "Function requires " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkGetSamplerOpaqueCaptureDescriptorDataEXT( - static_cast( m_device ), reinterpret_cast( &info ), &data ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getSamplerOpaqueCaptureDescriptorDataEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT( const AccelerationStructureCaptureDescriptorDataInfoEXT & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT && - "Function requires " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT( - static_cast( m_device ), reinterpret_cast( &info ), &data ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getAccelerationStructureOpaqueCaptureDescriptorDataEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - //=== VK_NV_fragment_shading_rate_enums === - - // wrapper function for command vkCmdSetFragmentShadingRateEnumNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetFragmentShadingRateEnumNV.html - VULKAN_HPP_INLINE void CommandBuffer::setFragmentShadingRateEnumNV( FragmentShadingRateNV shadingRate, - const FragmentShadingRateCombinerOpKHR combinerOps[2] ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFragmentShadingRateEnumNV && - "Function requires " ); - - getDispatcher()->vkCmdSetFragmentShadingRateEnumNV( static_cast( m_commandBuffer ), - static_cast( shadingRate ), - reinterpret_cast( combinerOps ) ); - } - - //=== VK_EXT_mesh_shader === - - // wrapper function for command vkCmdDrawMeshTasksEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksEXT.html - VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksEXT( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksEXT && "Function requires " ); - - getDispatcher()->vkCmdDrawMeshTasksEXT( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); - } - - // wrapper function for command vkCmdDrawMeshTasksIndirectEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectEXT.html - VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - uint32_t drawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectEXT && "Function requires " ); - - getDispatcher()->vkCmdDrawMeshTasksIndirectEXT( - static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ), drawCount, stride ); - } - - // wrapper function for command vkCmdDrawMeshTasksIndirectCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMeshTasksIndirectCountEXT.html - VULKAN_HPP_INLINE void CommandBuffer::drawMeshTasksIndirectCountEXT( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - VULKAN_HPP_NAMESPACE::Buffer countBuffer, - DeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMeshTasksIndirectCountEXT && "Function requires " ); - - getDispatcher()->vkCmdDrawMeshTasksIndirectCountEXT( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( countBuffer ), - static_cast( countBufferOffset ), - maxDrawCount, - stride ); - } - - //=== VK_KHR_copy_commands2 === - - // wrapper function for command vkCmdCopyBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBuffer2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::copyBuffer2KHR( const CopyBufferInfo2 & copyBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBuffer2KHR && "Function requires or " ); - - getDispatcher()->vkCmdCopyBuffer2KHR( static_cast( m_commandBuffer ), reinterpret_cast( ©BufferInfo ) ); - } - - // wrapper function for command vkCmdCopyImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImage2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::copyImage2KHR( const CopyImageInfo2 & copyImageInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImage2KHR && "Function requires or " ); - - getDispatcher()->vkCmdCopyImage2KHR( static_cast( m_commandBuffer ), reinterpret_cast( ©ImageInfo ) ); - } - - // wrapper function for command vkCmdCopyBufferToImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyBufferToImage2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::copyBufferToImage2KHR( const CopyBufferToImageInfo2 & copyBufferToImageInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyBufferToImage2KHR && - "Function requires or " ); - - getDispatcher()->vkCmdCopyBufferToImage2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( ©BufferToImageInfo ) ); - } - - // wrapper function for command vkCmdCopyImageToBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyImageToBuffer2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::copyImageToBuffer2KHR( const CopyImageToBufferInfo2 & copyImageToBufferInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyImageToBuffer2KHR && - "Function requires or " ); - - getDispatcher()->vkCmdCopyImageToBuffer2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( ©ImageToBufferInfo ) ); - } - - // wrapper function for command vkCmdBlitImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBlitImage2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::blitImage2KHR( const BlitImageInfo2 & blitImageInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBlitImage2KHR && "Function requires or " ); - - getDispatcher()->vkCmdBlitImage2KHR( static_cast( m_commandBuffer ), reinterpret_cast( &blitImageInfo ) ); - } - - // wrapper function for command vkCmdResolveImage2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdResolveImage2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::resolveImage2KHR( const ResolveImageInfo2 & resolveImageInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdResolveImage2KHR && "Function requires or " ); - - getDispatcher()->vkCmdResolveImage2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( &resolveImageInfo ) ); - } - - //=== VK_EXT_device_fault === - // wrapper function for command vkGetDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceFaultInfoEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getFaultInfoEXT( DeviceFaultCountsEXT * pFaultCounts, - DeviceFaultInfoEXT * pFaultInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceFaultInfoEXT && "Function requires " ); - return static_cast( getDispatcher()->vkGetDeviceFaultInfoEXT( static_cast( m_device ), - reinterpret_cast( pFaultCounts ), - reinterpret_cast( pFaultInfo ) ) ); - } -# if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_NV_acquire_winrt_display === - - // wrapper function for command vkAcquireWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAcquireWinrtDisplayNV.html - VULKAN_HPP_INLINE typename ResultValueType::type DisplayKHR::acquireWinrtNV() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireWinrtDisplayNV && "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkAcquireWinrtDisplayNV( static_cast( m_physicalDevice ), static_cast( m_displayKHR ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetWinrtDisplayNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetWinrtDisplayNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - PhysicalDevice::getWinrtDisplayNV( uint32_t deviceRelativeId ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetWinrtDisplayNV && "Function requires " ); - - VULKAN_HPP_NAMESPACE::DisplayKHR display; - Result result = static_cast( getDispatcher()->vkGetWinrtDisplayNV( - static_cast( m_physicalDevice ), deviceRelativeId, reinterpret_cast( &display ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getWinrtDisplayNV" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, DisplayKHR( *this, *reinterpret_cast( &display ) ) ); - } -# endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -# if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - - // wrapper function for command vkCreateDirectFBSurfaceEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDirectFBSurfaceEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createDirectFBSurfaceEXT( DirectFBSurfaceCreateInfoEXT const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDirectFBSurfaceEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateDirectFBSurfaceEXT( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createDirectFBSurfaceEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } - - // wrapper function for command vkGetPhysicalDeviceDirectFBPresentationSupportEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceDirectFBPresentationSupportEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getDirectFBPresentationSupportEXT( uint32_t queueFamilyIndex, - IDirectFB & dfb ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT && - "Function requires " ); - - VkBool32 result = - getDispatcher()->vkGetPhysicalDeviceDirectFBPresentationSupportEXT( static_cast( m_physicalDevice ), queueFamilyIndex, &dfb ); - - return static_cast( result ); - } -# endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_vertex_input_dynamic_state === - - // wrapper function for command vkCmdSetVertexInputEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetVertexInputEXT.html - VULKAN_HPP_INLINE void - CommandBuffer::setVertexInputEXT( ArrayProxy const & vertexBindingDescriptions, - ArrayProxy const & vertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetVertexInputEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetVertexInputEXT( static_cast( m_commandBuffer ), - vertexBindingDescriptions.size(), - reinterpret_cast( vertexBindingDescriptions.data() ), - vertexAttributeDescriptions.size(), - reinterpret_cast( vertexAttributeDescriptions.data() ) ); - } - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_memory === - - // wrapper function for command vkGetMemoryZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandleFUCHSIA.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryZirconHandleFUCHSIA( const MemoryGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryZirconHandleFUCHSIA && "Function requires " ); - - zx_handle_t zirconHandle; - Result result = static_cast( getDispatcher()->vkGetMemoryZirconHandleFUCHSIA( - static_cast( m_device ), reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryZirconHandleFUCHSIA" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( zirconHandle ) ); - } - - // wrapper function for command vkGetMemoryZirconHandlePropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryZirconHandlePropertiesFUCHSIA.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryZirconHandlePropertiesFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA && - "Function requires " ); - - MemoryZirconHandlePropertiesFUCHSIA memoryZirconHandleProperties; - Result result = static_cast( getDispatcher()->vkGetMemoryZirconHandlePropertiesFUCHSIA( - static_cast( m_device ), - static_cast( handleType ), - zirconHandle, - reinterpret_cast( &memoryZirconHandleProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryZirconHandlePropertiesFUCHSIA" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryZirconHandleProperties ) ); - } -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_external_semaphore === - - // wrapper function for command vkImportSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkImportSemaphoreZirconHandleFUCHSIA.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::importSemaphoreZirconHandleFUCHSIA( const ImportSemaphoreZirconHandleInfoFUCHSIA & importSemaphoreZirconHandleInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA && - "Function requires " ); - - Result result = static_cast( getDispatcher()->vkImportSemaphoreZirconHandleFUCHSIA( - static_cast( m_device ), reinterpret_cast( &importSemaphoreZirconHandleInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::importSemaphoreZirconHandleFUCHSIA" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetSemaphoreZirconHandleFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetSemaphoreZirconHandleFUCHSIA.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getSemaphoreZirconHandleFUCHSIA( const SemaphoreGetZirconHandleInfoFUCHSIA & getZirconHandleInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA && - "Function requires " ); - - zx_handle_t zirconHandle; - Result result = static_cast( getDispatcher()->vkGetSemaphoreZirconHandleFUCHSIA( - static_cast( m_device ), reinterpret_cast( &getZirconHandleInfo ), &zirconHandle ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getSemaphoreZirconHandleFUCHSIA" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( zirconHandle ) ); - } -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - - // wrapper function for command vkCreateBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateBufferCollectionFUCHSIA.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createBufferCollectionFUCHSIA( BufferCollectionCreateInfoFUCHSIA const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateBufferCollectionFUCHSIA && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA collection; - Result result = - static_cast( getDispatcher()->vkCreateBufferCollectionFUCHSIA( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &collection ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createBufferCollectionFUCHSIA" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, BufferCollectionFUCHSIA( *this, *reinterpret_cast( &collection ), allocator ) ); - } - - // wrapper function for command vkSetBufferCollectionImageConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionImageConstraintsFUCHSIA.html - VULKAN_HPP_INLINE typename ResultValueType::type - BufferCollectionFUCHSIA::setImageConstraints( const ImageConstraintsInfoFUCHSIA & imageConstraintsInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA && - "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA( static_cast( m_device ), - static_cast( m_bufferCollectionFUCHSIA ), - reinterpret_cast( &imageConstraintsInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setImageConstraints" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkSetBufferCollectionBufferConstraintsFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetBufferCollectionBufferConstraintsFUCHSIA.html - VULKAN_HPP_INLINE typename ResultValueType::type - BufferCollectionFUCHSIA::setBufferConstraints( const BufferConstraintsInfoFUCHSIA & bufferConstraintsInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA && - "Function requires " ); - - Result result = static_cast( - getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA( static_cast( m_device ), - static_cast( m_bufferCollectionFUCHSIA ), - reinterpret_cast( &bufferConstraintsInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setBufferConstraints" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetBufferCollectionPropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetBufferCollectionPropertiesFUCHSIA.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type BufferCollectionFUCHSIA::getProperties() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA && - "Function requires " ); - - BufferCollectionPropertiesFUCHSIA properties; - Result result = static_cast( - getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA( static_cast( m_device ), - static_cast( m_bufferCollectionFUCHSIA ), - reinterpret_cast( &properties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::BufferCollectionFUCHSIA::getProperties" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_HUAWEI_subpass_shading === - - // wrapper function for command vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI && - "Function requires " ); - - Extent2D maxWorkgroupSize; - Result result = static_cast( getDispatcher()->vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( - static_cast( m_device ), static_cast( m_renderPass ), reinterpret_cast( &maxWorkgroupSize ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::RenderPass::getSubpassShadingMaxWorkgroupSizeHUAWEI" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( maxWorkgroupSize ) ); - } - - // wrapper function for command vkCmdSubpassShadingHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSubpassShadingHUAWEI.html - VULKAN_HPP_INLINE void CommandBuffer::subpassShadingHUAWEI() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSubpassShadingHUAWEI && "Function requires " ); - - getDispatcher()->vkCmdSubpassShadingHUAWEI( static_cast( m_commandBuffer ) ); - } - - //=== VK_HUAWEI_invocation_mask === - - // wrapper function for command vkCmdBindInvocationMaskHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindInvocationMaskHUAWEI.html - VULKAN_HPP_INLINE void CommandBuffer::bindInvocationMaskHUAWEI( VULKAN_HPP_NAMESPACE::ImageView imageView, - ImageLayout imageLayout ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindInvocationMaskHUAWEI && "Function requires " ); - - getDispatcher()->vkCmdBindInvocationMaskHUAWEI( - static_cast( m_commandBuffer ), static_cast( imageView ), static_cast( imageLayout ) ); - } - - //=== VK_NV_external_memory_rdma === - - // wrapper function for command vkGetMemoryRemoteAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryRemoteAddressNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryRemoteAddressNV( const MemoryGetRemoteAddressInfoNV & memoryGetRemoteAddressInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryRemoteAddressNV && "Function requires " ); - - RemoteAddressNV address; - Result result = static_cast( - getDispatcher()->vkGetMemoryRemoteAddressNV( static_cast( m_device ), - reinterpret_cast( &memoryGetRemoteAddressInfo ), - reinterpret_cast( &address ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryRemoteAddressNV" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( address ) ); - } - - //=== VK_EXT_pipeline_properties === - - // wrapper function for command vkGetPipelinePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelinePropertiesEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getPipelinePropertiesEXT( const PipelineInfoEXT & pipelineInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelinePropertiesEXT && "Function requires " ); - - BaseOutStructure pipelineProperties; - Result result = static_cast( getDispatcher()->vkGetPipelinePropertiesEXT( static_cast( m_device ), - reinterpret_cast( &pipelineInfo ), - reinterpret_cast( &pipelineProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelinePropertiesEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelineProperties ) ); - } - - //=== VK_EXT_extended_dynamic_state2 === - - // wrapper function for command vkCmdSetPatchControlPointsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPatchControlPointsEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPatchControlPointsEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetPatchControlPointsEXT( static_cast( m_commandBuffer ), patchControlPoints ); - } - - // wrapper function for command vkCmdSetRasterizerDiscardEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizerDiscardEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT( Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT( static_cast( m_commandBuffer ), static_cast( rasterizerDiscardEnable ) ); - } - - // wrapper function for command vkCmdSetDepthBiasEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthBiasEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBiasEnableEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetDepthBiasEnableEXT( static_cast( m_commandBuffer ), static_cast( depthBiasEnable ) ); - } - - // wrapper function for command vkCmdSetLogicOpEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetLogicOpEXT( static_cast( m_commandBuffer ), static_cast( logicOp ) ); - } - - // wrapper function for command vkCmdSetPrimitiveRestartEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPrimitiveRestartEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT( Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT && - "Function requires or or " ); - - getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT( static_cast( m_commandBuffer ), static_cast( primitiveRestartEnable ) ); - } - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - - // wrapper function for command vkCreateScreenSurfaceQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateScreenSurfaceQNX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createScreenSurfaceQNX( ScreenSurfaceCreateInfoQNX const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateScreenSurfaceQNX && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateScreenSurfaceQNX( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createScreenSurfaceQNX" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } - - // wrapper function for command vkGetPhysicalDeviceScreenPresentationSupportQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceScreenPresentationSupportQNX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Bool32 PhysicalDevice::getScreenPresentationSupportQNX( uint32_t queueFamilyIndex, - struct _screen_window & window ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX && - "Function requires " ); - - VkBool32 result = - getDispatcher()->vkGetPhysicalDeviceScreenPresentationSupportQNX( static_cast( m_physicalDevice ), queueFamilyIndex, &window ); - - return static_cast( result ); - } -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_EXT_color_write_enable === - - // wrapper function for command vkCmdSetColorWriteEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setColorWriteEnableEXT( ArrayProxy const & colorWriteEnables ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteEnableEXT && "Function requires " ); - - getDispatcher()->vkCmdSetColorWriteEnableEXT( - static_cast( m_commandBuffer ), colorWriteEnables.size(), reinterpret_cast( colorWriteEnables.data() ) ); - } - - //=== VK_KHR_ray_tracing_maintenance1 === - - // wrapper function for command vkCmdTraceRaysIndirect2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdTraceRaysIndirect2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::traceRaysIndirect2KHR( DeviceAddress indirectDeviceAddress ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdTraceRaysIndirect2KHR && "Function requires " ); - - getDispatcher()->vkCmdTraceRaysIndirect2KHR( static_cast( m_commandBuffer ), static_cast( indirectDeviceAddress ) ); - } - - //=== VK_EXT_multi_draw === - - // wrapper function for command vkCmdDrawMultiEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiEXT.html - VULKAN_HPP_INLINE void CommandBuffer::drawMultiEXT( StridedArrayProxy const & vertexInfo, - uint32_t instanceCount, - uint32_t firstInstance ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiEXT && "Function requires " ); - - getDispatcher()->vkCmdDrawMultiEXT( static_cast( m_commandBuffer ), - vertexInfo.size(), - reinterpret_cast( vertexInfo.data() ), - instanceCount, - firstInstance, - vertexInfo.stride() ); - } - - // wrapper function for command vkCmdDrawMultiIndexedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawMultiIndexedEXT.html - VULKAN_HPP_INLINE void CommandBuffer::drawMultiIndexedEXT( StridedArrayProxy const & indexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - Optional vertexOffset ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawMultiIndexedEXT && "Function requires " ); - - getDispatcher()->vkCmdDrawMultiIndexedEXT( static_cast( m_commandBuffer ), - indexInfo.size(), - reinterpret_cast( indexInfo.data() ), - instanceCount, - firstInstance, - indexInfo.stride(), - vertexOffset.get() ); - } - - //=== VK_EXT_opacity_micromap === - - // wrapper function for command vkCreateMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateMicromapEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createMicromapEXT( MicromapCreateInfoEXT const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateMicromapEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::MicromapEXT micromap; - Result result = static_cast( getDispatcher()->vkCreateMicromapEXT( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( µmap ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createMicromapEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, MicromapEXT( *this, *reinterpret_cast( µmap ), allocator ) ); - } - - // wrapper function for command vkCmdBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildMicromapsEXT.html - VULKAN_HPP_INLINE void CommandBuffer::buildMicromapsEXT( ArrayProxy const & infos ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildMicromapsEXT && "Function requires " ); - - getDispatcher()->vkCmdBuildMicromapsEXT( - static_cast( m_commandBuffer ), infos.size(), reinterpret_cast( infos.data() ) ); - } - - // wrapper function for command vkBuildMicromapsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBuildMicromapsEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::buildMicromapsEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - ArrayProxy const & infos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBuildMicromapsEXT && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkBuildMicromapsEXT( static_cast( m_device ), - static_cast( deferredOperation ), - infos.size(), - reinterpret_cast( infos.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::buildMicromapsEXT", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } - - // wrapper function for command vkCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const CopyMicromapInfoEXT & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMicromapEXT && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkCopyMicromapEXT( static_cast( m_device ), - static_cast( deferredOperation ), - reinterpret_cast( &info ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMicromapEXT", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } - - // wrapper function for command vkCopyMicromapToMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMicromapToMemoryEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMicromapToMemoryEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const CopyMicromapToMemoryInfoEXT & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMicromapToMemoryEXT && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkCopyMicromapToMemoryEXT( static_cast( m_device ), - static_cast( deferredOperation ), - reinterpret_cast( &info ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMicromapToMemoryEXT", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } - - // wrapper function for command vkCopyMemoryToMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCopyMemoryToMicromapEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::copyMemoryToMicromapEXT( VULKAN_HPP_NAMESPACE::DeferredOperationKHR deferredOperation, - const CopyMemoryToMicromapInfoEXT & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCopyMemoryToMicromapEXT && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkCopyMemoryToMicromapEXT( static_cast( m_device ), - static_cast( deferredOperation ), - reinterpret_cast( &info ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::copyMemoryToMicromapEXT", - { Result::eSuccess, Result::eOperationDeferredKHR, Result::eOperationNotDeferredKHR } ); - - return static_cast( result ); - } - - // wrapper function for command vkWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Device::writeMicromapsPropertiesEXT( - ArrayProxy const & micromaps, QueryType queryType, size_t dataSize, size_t stride ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkWriteMicromapsPropertiesEXT && "Function requires " ); - - VULKAN_HPP_ASSERT( dataSize % sizeof( DataType ) == 0 ); - std::vector data( dataSize / sizeof( DataType ) ); - Result result = static_cast( getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast( m_device ), - micromaps.size(), - reinterpret_cast( micromaps.data() ), - static_cast( queryType ), - data.size() * sizeof( DataType ), - reinterpret_cast( data.data() ), - stride ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeMicromapsPropertiesEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkWriteMicromapsPropertiesEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::writeMicromapsPropertyEXT( ArrayProxy const & micromaps, QueryType queryType, size_t stride ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkWriteMicromapsPropertiesEXT && "Function requires " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkWriteMicromapsPropertiesEXT( static_cast( m_device ), - micromaps.size(), - reinterpret_cast( micromaps.data() ), - static_cast( queryType ), - sizeof( DataType ), - reinterpret_cast( &data ), - stride ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::writeMicromapsPropertyEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkCmdCopyMicromapEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapEXT.html - VULKAN_HPP_INLINE void CommandBuffer::copyMicromapEXT( const CopyMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMicromapEXT && "Function requires " ); - - getDispatcher()->vkCmdCopyMicromapEXT( static_cast( m_commandBuffer ), reinterpret_cast( &info ) ); - } - - // wrapper function for command vkCmdCopyMicromapToMemoryEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMicromapToMemoryEXT.html - VULKAN_HPP_INLINE void CommandBuffer::copyMicromapToMemoryEXT( const CopyMicromapToMemoryInfoEXT & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMicromapToMemoryEXT && "Function requires " ); - - getDispatcher()->vkCmdCopyMicromapToMemoryEXT( static_cast( m_commandBuffer ), - reinterpret_cast( &info ) ); - } - - // wrapper function for command vkCmdCopyMemoryToMicromapEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToMicromapEXT.html - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryToMicromapEXT( const CopyMemoryToMicromapInfoEXT & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToMicromapEXT && "Function requires " ); - - getDispatcher()->vkCmdCopyMemoryToMicromapEXT( static_cast( m_commandBuffer ), - reinterpret_cast( &info ) ); - } - - // wrapper function for command vkCmdWriteMicromapsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdWriteMicromapsPropertiesEXT.html - VULKAN_HPP_INLINE void CommandBuffer::writeMicromapsPropertiesEXT( ArrayProxy const & micromaps, - QueryType queryType, - VULKAN_HPP_NAMESPACE::QueryPool queryPool, - uint32_t firstQuery ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdWriteMicromapsPropertiesEXT && - "Function requires " ); - - getDispatcher()->vkCmdWriteMicromapsPropertiesEXT( static_cast( m_commandBuffer ), - micromaps.size(), - reinterpret_cast( micromaps.data() ), - static_cast( queryType ), - static_cast( queryPool ), - firstQuery ); - } - - // wrapper function for command vkGetDeviceMicromapCompatibilityEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceMicromapCompatibilityEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureCompatibilityKHR - Device::getMicromapCompatibilityEXT( const MicromapVersionInfoEXT & versionInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceMicromapCompatibilityEXT && - "Function requires " ); - - AccelerationStructureCompatibilityKHR compatibility; - getDispatcher()->vkGetDeviceMicromapCompatibilityEXT( static_cast( m_device ), - reinterpret_cast( &versionInfo ), - reinterpret_cast( &compatibility ) ); - - return compatibility; - } - - // wrapper function for command vkGetMicromapBuildSizesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMicromapBuildSizesEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MicromapBuildSizesInfoEXT - Device::getMicromapBuildSizesEXT( AccelerationStructureBuildTypeKHR buildType, const MicromapBuildInfoEXT & buildInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMicromapBuildSizesEXT && "Function requires " ); - - MicromapBuildSizesInfoEXT sizeInfo; - getDispatcher()->vkGetMicromapBuildSizesEXT( static_cast( m_device ), - static_cast( buildType ), - reinterpret_cast( &buildInfo ), - reinterpret_cast( &sizeInfo ) ); - - return sizeInfo; - } - - //=== VK_HUAWEI_cluster_culling_shader === - - // wrapper function for command vkCmdDrawClusterHUAWEI, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterHUAWEI.html - VULKAN_HPP_INLINE void CommandBuffer::drawClusterHUAWEI( uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawClusterHUAWEI && "Function requires " ); - - getDispatcher()->vkCmdDrawClusterHUAWEI( static_cast( m_commandBuffer ), groupCountX, groupCountY, groupCountZ ); - } - - // wrapper function for command vkCmdDrawClusterIndirectHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDrawClusterIndirectHUAWEI.html - VULKAN_HPP_INLINE void CommandBuffer::drawClusterIndirectHUAWEI( VULKAN_HPP_NAMESPACE::Buffer buffer, DeviceSize offset ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDrawClusterIndirectHUAWEI && - "Function requires " ); - - getDispatcher()->vkCmdDrawClusterIndirectHUAWEI( - static_cast( m_commandBuffer ), static_cast( buffer ), static_cast( offset ) ); - } - - //=== VK_EXT_pageable_device_local_memory === - - // wrapper function for command vkSetDeviceMemoryPriorityEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetDeviceMemoryPriorityEXT.html - VULKAN_HPP_INLINE void DeviceMemory::setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetDeviceMemoryPriorityEXT && - "Function requires " ); - - getDispatcher()->vkSetDeviceMemoryPriorityEXT( static_cast( m_device ), static_cast( m_deviceMemory ), priority ); - } - - //=== VK_KHR_maintenance4 === - - // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR && - "Function requires or " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDeviceBufferMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceBufferMemoryRequirementsKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getBufferMemoryRequirementsKHR( const DeviceBufferMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR && - "Function requires or " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetDeviceBufferMemoryRequirementsKHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR && - "Function requires or " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDeviceImageMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageMemoryRequirementsKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getImageMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR && - "Function requires or " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetDeviceImageMemoryRequirementsKHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkGetDeviceImageSparseMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSparseMemoryRequirementsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector - Device::getImageSparseMemoryRequirementsKHR( const DeviceImageMemoryRequirements & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR && - "Function requires or " ); - - std::vector sparseMemoryRequirements; - uint32_t sparseMemoryRequirementCount; - getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( - static_cast( m_device ), reinterpret_cast( &info ), &sparseMemoryRequirementCount, nullptr ); - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - getDispatcher()->vkGetDeviceImageSparseMemoryRequirementsKHR( static_cast( m_device ), - reinterpret_cast( &info ), - &sparseMemoryRequirementCount, - reinterpret_cast( sparseMemoryRequirements.data() ) ); - - VULKAN_HPP_ASSERT( sparseMemoryRequirementCount <= sparseMemoryRequirements.size() ); - if ( sparseMemoryRequirementCount < sparseMemoryRequirements.size() ) - { - sparseMemoryRequirements.resize( sparseMemoryRequirementCount ); - } - return sparseMemoryRequirements; - } - - //=== VK_VALVE_descriptor_set_host_mapping === - - // wrapper function for command vkGetDescriptorSetLayoutHostMappingInfoVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetLayoutHostMappingInfoVALVE.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DescriptorSetLayoutHostMappingInfoVALVE - Device::getDescriptorSetLayoutHostMappingInfoVALVE( const DescriptorSetBindingReferenceVALVE & bindingReference ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetLayoutHostMappingInfoVALVE && - "Function requires " ); - - DescriptorSetLayoutHostMappingInfoVALVE hostMapping; - getDispatcher()->vkGetDescriptorSetLayoutHostMappingInfoVALVE( static_cast( m_device ), - reinterpret_cast( &bindingReference ), - reinterpret_cast( &hostMapping ) ); - - return hostMapping; - } - - // wrapper function for command vkGetDescriptorSetHostMappingVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDescriptorSetHostMappingVALVE.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE void * DescriptorSet::getHostMappingVALVE() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDescriptorSetHostMappingVALVE && - "Function requires " ); - - void * pData; - getDispatcher()->vkGetDescriptorSetHostMappingVALVE( static_cast( m_device ), static_cast( m_descriptorSet ), &pData ); - - return pData; - } - - //=== VK_NV_copy_memory_indirect === - - // wrapper function for command vkCmdCopyMemoryIndirectNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectNV.html - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectNV( DeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryIndirectNV && "Function requires " ); - - getDispatcher()->vkCmdCopyMemoryIndirectNV( - static_cast( m_commandBuffer ), static_cast( copyBufferAddress ), copyCount, stride ); - } - - // wrapper function for command vkCmdCopyMemoryToImageIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectNV.html - VULKAN_HPP_INLINE void - CommandBuffer::copyMemoryToImageIndirectNV( DeviceAddress copyBufferAddress, - uint32_t stride, - VULKAN_HPP_NAMESPACE::Image dstImage, - ImageLayout dstImageLayout, - ArrayProxy const & imageSubresources ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToImageIndirectNV && - "Function requires " ); - - getDispatcher()->vkCmdCopyMemoryToImageIndirectNV( static_cast( m_commandBuffer ), - static_cast( copyBufferAddress ), - imageSubresources.size(), - stride, - static_cast( dstImage ), - static_cast( dstImageLayout ), - reinterpret_cast( imageSubresources.data() ) ); - } - - //=== VK_NV_memory_decompression === - - // wrapper function for command vkCmdDecompressMemoryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryNV.html - VULKAN_HPP_INLINE void - CommandBuffer::decompressMemoryNV( ArrayProxy const & decompressMemoryRegions ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryNV && "Function requires " ); - - getDispatcher()->vkCmdDecompressMemoryNV( static_cast( m_commandBuffer ), - decompressMemoryRegions.size(), - reinterpret_cast( decompressMemoryRegions.data() ) ); - } - - // wrapper function for command vkCmdDecompressMemoryIndirectCountNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountNV.html - VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountNV( DeviceAddress indirectCommandsAddress, - DeviceAddress indirectCommandsCountAddress, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryIndirectCountNV && - "Function requires " ); - - getDispatcher()->vkCmdDecompressMemoryIndirectCountNV( static_cast( m_commandBuffer ), - static_cast( indirectCommandsAddress ), - static_cast( indirectCommandsCountAddress ), - stride ); - } - - //=== VK_NV_device_generated_commands_compute === - - // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV && - "Function requires " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetPipelineIndirectMemoryRequirementsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectMemoryRequirementsNV.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getPipelineIndirectMemoryRequirementsNV( const ComputePipelineCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV && - "Function requires " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetPipelineIndirectMemoryRequirementsNV( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkCmdUpdatePipelineIndirectBufferNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdUpdatePipelineIndirectBufferNV.html - VULKAN_HPP_INLINE void CommandBuffer::updatePipelineIndirectBufferNV( PipelineBindPoint pipelineBindPoint, - VULKAN_HPP_NAMESPACE::Pipeline pipeline ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdUpdatePipelineIndirectBufferNV && - "Function requires " ); - - getDispatcher()->vkCmdUpdatePipelineIndirectBufferNV( - static_cast( m_commandBuffer ), static_cast( pipelineBindPoint ), static_cast( pipeline ) ); - } - - // wrapper function for command vkGetPipelineIndirectDeviceAddressNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineIndirectDeviceAddressNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE DeviceAddress - Device::getPipelineIndirectAddressNV( const PipelineIndirectDeviceAddressInfoNV & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineIndirectDeviceAddressNV && - "Function requires " ); - - VkDeviceAddress result = getDispatcher()->vkGetPipelineIndirectDeviceAddressNV( - static_cast( m_device ), reinterpret_cast( &info ) ); - - return static_cast( result ); - } - -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_external_memory === - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer * buffer, - NativeBufferPropertiesOHOS * pProperties ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetNativeBufferPropertiesOHOS && "Function requires " ); - return static_cast( getDispatcher()->vkGetNativeBufferPropertiesOHOS( - static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); - } - - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetNativeBufferPropertiesOHOS && "Function requires " ); - - NativeBufferPropertiesOHOS properties; - Result result = static_cast( getDispatcher()->vkGetNativeBufferPropertiesOHOS( - static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getNativeBufferPropertiesOHOS" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetNativeBufferPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetNativeBufferPropertiesOHOS.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getNativeBufferPropertiesOHOS( const struct OH_NativeBuffer & buffer ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetNativeBufferPropertiesOHOS && "Function requires " ); - - StructureChain structureChain; - NativeBufferPropertiesOHOS & properties = structureChain.template get(); - Result result = static_cast( getDispatcher()->vkGetNativeBufferPropertiesOHOS( - static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getNativeBufferPropertiesOHOS" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); - } - - // wrapper function for command vkGetMemoryNativeBufferOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryNativeBufferOHOS.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryNativeBufferOHOS( const MemoryGetNativeBufferInfoOHOS & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryNativeBufferOHOS && "Function requires " ); - - struct OH_NativeBuffer * buffer; - Result result = static_cast( getDispatcher()->vkGetMemoryNativeBufferOHOS( - static_cast( m_device ), reinterpret_cast( &info ), &buffer ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryNativeBufferOHOS" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( buffer ) ); - } -# endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_EXT_extended_dynamic_state3 === - - // wrapper function for command vkCmdSetDepthClampEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClampEnableEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetDepthClampEnableEXT( static_cast( m_commandBuffer ), static_cast( depthClampEnable ) ); - } - - // wrapper function for command vkCmdSetPolygonModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetPolygonModeEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setPolygonModeEXT( PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPolygonModeEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetPolygonModeEXT( static_cast( m_commandBuffer ), static_cast( polygonMode ) ); - } - - // wrapper function for command vkCmdSetRasterizationSamplesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationSamplesEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setRasterizationSamplesEXT( SampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizationSamplesEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetRasterizationSamplesEXT( static_cast( m_commandBuffer ), - static_cast( rasterizationSamples ) ); - } - - // wrapper function for command vkCmdSetSampleMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleMaskEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setSampleMaskEXT( SampleCountFlagBits samples, ArrayProxy const & sampleMask ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleMaskEXT && - "Function requires or " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( sampleMask.size() == ( static_cast( samples ) + 31 ) / 32 ); -# else - if ( sampleMask.size() != ( static_cast( samples ) + 31 ) / 32 ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::CommandBuffer::setSampleMaskEXT: sampleMask.size() != ( static_cast( samples ) + 31 ) / 32" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdSetSampleMaskEXT( static_cast( m_commandBuffer ), - static_cast( samples ), - reinterpret_cast( sampleMask.data() ) ); - } - - // wrapper function for command vkCmdSetAlphaToCoverageEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToCoverageEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setAlphaToCoverageEnableEXT( Bool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAlphaToCoverageEnableEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetAlphaToCoverageEnableEXT( static_cast( m_commandBuffer ), static_cast( alphaToCoverageEnable ) ); - } - - // wrapper function for command vkCmdSetAlphaToOneEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAlphaToOneEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setAlphaToOneEnableEXT( Bool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAlphaToOneEnableEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetAlphaToOneEnableEXT( static_cast( m_commandBuffer ), static_cast( alphaToOneEnable ) ); - } - - // wrapper function for command vkCmdSetLogicOpEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLogicOpEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEnableEXT( Bool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEnableEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetLogicOpEnableEXT( static_cast( m_commandBuffer ), static_cast( logicOpEnable ) ); - } - - // wrapper function for command vkCmdSetColorBlendEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( uint32_t firstAttachment, - ArrayProxy const & colorBlendEnables ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendEnableEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetColorBlendEnableEXT( static_cast( m_commandBuffer ), - firstAttachment, - colorBlendEnables.size(), - reinterpret_cast( colorBlendEnables.data() ) ); - } - - // wrapper function for command vkCmdSetColorBlendEquationEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendEquationEXT.html - VULKAN_HPP_INLINE void - CommandBuffer::setColorBlendEquationEXT( uint32_t firstAttachment, - ArrayProxy const & colorBlendEquations ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendEquationEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetColorBlendEquationEXT( static_cast( m_commandBuffer ), - firstAttachment, - colorBlendEquations.size(), - reinterpret_cast( colorBlendEquations.data() ) ); - } - - // wrapper function for command vkCmdSetColorWriteMaskEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorWriteMaskEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setColorWriteMaskEXT( uint32_t firstAttachment, - ArrayProxy const & colorWriteMasks ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteMaskEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetColorWriteMaskEXT( static_cast( m_commandBuffer ), - firstAttachment, - colorWriteMasks.size(), - reinterpret_cast( colorWriteMasks.data() ) ); - } - - // wrapper function for command vkCmdSetTessellationDomainOriginEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetTessellationDomainOriginEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setTessellationDomainOriginEXT( TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetTessellationDomainOriginEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetTessellationDomainOriginEXT( static_cast( m_commandBuffer ), - static_cast( domainOrigin ) ); - } - - // wrapper function for command vkCmdSetRasterizationStreamEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRasterizationStreamEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizationStreamEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetRasterizationStreamEXT( static_cast( m_commandBuffer ), rasterizationStream ); - } - - // wrapper function for command vkCmdSetConservativeRasterizationModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetConservativeRasterizationModeEXT.html - VULKAN_HPP_INLINE void - CommandBuffer::setConservativeRasterizationModeEXT( ConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetConservativeRasterizationModeEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetConservativeRasterizationModeEXT( static_cast( m_commandBuffer ), - static_cast( conservativeRasterizationMode ) ); - } - - // wrapper function for command vkCmdSetExtraPrimitiveOverestimationSizeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetExtraPrimitiveOverestimationSizeEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExtraPrimitiveOverestimationSizeEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetExtraPrimitiveOverestimationSizeEXT( static_cast( m_commandBuffer ), extraPrimitiveOverestimationSize ); - } - - // wrapper function for command vkCmdSetDepthClipEnableEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthClipEnableEXT( Bool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClipEnableEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetDepthClipEnableEXT( static_cast( m_commandBuffer ), static_cast( depthClipEnable ) ); - } - - // wrapper function for command vkCmdSetSampleLocationsEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetSampleLocationsEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEnableEXT( Bool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEnableEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetSampleLocationsEnableEXT( static_cast( m_commandBuffer ), static_cast( sampleLocationsEnable ) ); - } - - // wrapper function for command vkCmdSetColorBlendAdvancedEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetColorBlendAdvancedEXT.html - VULKAN_HPP_INLINE void - CommandBuffer::setColorBlendAdvancedEXT( uint32_t firstAttachment, - ArrayProxy const & colorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendAdvancedEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetColorBlendAdvancedEXT( static_cast( m_commandBuffer ), - firstAttachment, - colorBlendAdvanced.size(), - reinterpret_cast( colorBlendAdvanced.data() ) ); - } - - // wrapper function for command vkCmdSetProvokingVertexModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetProvokingVertexModeEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setProvokingVertexModeEXT( ProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetProvokingVertexModeEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetProvokingVertexModeEXT( static_cast( m_commandBuffer ), - static_cast( provokingVertexMode ) ); - } - - // wrapper function for command vkCmdSetLineRasterizationModeEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineRasterizationModeEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setLineRasterizationModeEXT( LineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineRasterizationModeEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetLineRasterizationModeEXT( static_cast( m_commandBuffer ), - static_cast( lineRasterizationMode ) ); - } - - // wrapper function for command vkCmdSetLineStippleEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEnableEXT( Bool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEnableEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetLineStippleEnableEXT( static_cast( m_commandBuffer ), static_cast( stippledLineEnable ) ); - } - - // wrapper function for command vkCmdSetDepthClipNegativeOneToOneEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClipNegativeOneToOneEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthClipNegativeOneToOneEXT( Bool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClipNegativeOneToOneEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetDepthClipNegativeOneToOneEXT( static_cast( m_commandBuffer ), static_cast( negativeOneToOne ) ); - } - - // wrapper function for command vkCmdSetViewportWScalingEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportWScalingEnableNV.html - VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingEnableNV( Bool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWScalingEnableNV && - "Function requires or " ); - - getDispatcher()->vkCmdSetViewportWScalingEnableNV( static_cast( m_commandBuffer ), static_cast( viewportWScalingEnable ) ); - } - - // wrapper function for command vkCmdSetViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetViewportSwizzleNV.html - VULKAN_HPP_INLINE void CommandBuffer::setViewportSwizzleNV( uint32_t firstViewport, - ArrayProxy const & viewportSwizzles ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportSwizzleNV && - "Function requires or " ); - - getDispatcher()->vkCmdSetViewportSwizzleNV( static_cast( m_commandBuffer ), - firstViewport, - viewportSwizzles.size(), - reinterpret_cast( viewportSwizzles.data() ) ); - } - - // wrapper function for command vkCmdSetCoverageToColorEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorEnableNV.html - VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorEnableNV( Bool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageToColorEnableNV && - "Function requires or " ); - - getDispatcher()->vkCmdSetCoverageToColorEnableNV( static_cast( m_commandBuffer ), static_cast( coverageToColorEnable ) ); - } - - // wrapper function for command vkCmdSetCoverageToColorLocationNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageToColorLocationNV.html - VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageToColorLocationNV && - "Function requires or " ); - - getDispatcher()->vkCmdSetCoverageToColorLocationNV( static_cast( m_commandBuffer ), coverageToColorLocation ); - } - - // wrapper function for command vkCmdSetCoverageModulationModeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationModeNV.html - VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationModeNV( CoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationModeNV && - "Function requires or " ); - - getDispatcher()->vkCmdSetCoverageModulationModeNV( static_cast( m_commandBuffer ), - static_cast( coverageModulationMode ) ); - } - - // wrapper function for command vkCmdSetCoverageModulationTableEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableEnableNV.html - VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableEnableNV( Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationTableEnableNV && - "Function requires or " ); - - getDispatcher()->vkCmdSetCoverageModulationTableEnableNV( static_cast( m_commandBuffer ), - static_cast( coverageModulationTableEnable ) ); - } - - // wrapper function for command vkCmdSetCoverageModulationTableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageModulationTableNV.html - VULKAN_HPP_INLINE void CommandBuffer::setCoverageModulationTableNV( ArrayProxy const & coverageModulationTable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationTableNV && - "Function requires or " ); - - getDispatcher()->vkCmdSetCoverageModulationTableNV( - static_cast( m_commandBuffer ), coverageModulationTable.size(), coverageModulationTable.data() ); - } - - // wrapper function for command vkCmdSetShadingRateImageEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetShadingRateImageEnableNV.html - VULKAN_HPP_INLINE void CommandBuffer::setShadingRateImageEnableNV( Bool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetShadingRateImageEnableNV && - "Function requires or " ); - - getDispatcher()->vkCmdSetShadingRateImageEnableNV( static_cast( m_commandBuffer ), static_cast( shadingRateImageEnable ) ); - } - - // wrapper function for command vkCmdSetRepresentativeFragmentTestEnableNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetRepresentativeFragmentTestEnableNV.html - VULKAN_HPP_INLINE void CommandBuffer::setRepresentativeFragmentTestEnableNV( Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRepresentativeFragmentTestEnableNV && - "Function requires or " ); - - getDispatcher()->vkCmdSetRepresentativeFragmentTestEnableNV( static_cast( m_commandBuffer ), - static_cast( representativeFragmentTestEnable ) ); - } - - // wrapper function for command vkCmdSetCoverageReductionModeNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetCoverageReductionModeNV.html - VULKAN_HPP_INLINE void CommandBuffer::setCoverageReductionModeNV( CoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageReductionModeNV && - "Function requires or " ); - - getDispatcher()->vkCmdSetCoverageReductionModeNV( static_cast( m_commandBuffer ), - static_cast( coverageReductionMode ) ); - } - - //=== VK_ARM_tensors === - - // wrapper function for command vkCreateTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createTensorARM( TensorCreateInfoARM const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateTensorARM && "Function requires " ); - - VULKAN_HPP_NAMESPACE::TensorARM tensor; - Result result = static_cast( getDispatcher()->vkCreateTensorARM( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &tensor ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createTensorARM" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, TensorARM( *this, *reinterpret_cast( &tensor ), allocator ) ); - } - - // wrapper function for command vkCreateTensorViewARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateTensorViewARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createTensorViewARM( TensorViewCreateInfoARM const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateTensorViewARM && "Function requires " ); - - VULKAN_HPP_NAMESPACE::TensorViewARM view; - Result result = static_cast( getDispatcher()->vkCreateTensorViewARM( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &view ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createTensorViewARM" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, TensorViewARM( *this, *reinterpret_cast( &view ), allocator ) ); - } - - // wrapper function for command vkGetTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorMemoryRequirementsARM && "Function requires " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetTensorMemoryRequirementsARM( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorMemoryRequirementsARM.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getTensorMemoryRequirementsARM( const TensorMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorMemoryRequirementsARM && "Function requires " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetTensorMemoryRequirementsARM( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkBindTensorMemoryARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindTensorMemoryARM.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::bindTensorMemoryARM( ArrayProxy const & bindInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBindTensorMemoryARM && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkBindTensorMemoryARM( - static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindTensorMemoryARM" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceTensorMemoryRequirementsARM && - "Function requires " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetDeviceTensorMemoryRequirementsARM( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDeviceTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceTensorMemoryRequirementsARM.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getTensorMemoryRequirementsARM( const DeviceTensorMemoryRequirementsARM & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceTensorMemoryRequirementsARM && - "Function requires " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetDeviceTensorMemoryRequirementsARM( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkCmdCopyTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyTensorARM.html - VULKAN_HPP_INLINE void CommandBuffer::copyTensorARM( const CopyTensorInfoARM & copyTensorInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyTensorARM && "Function requires " ); - - getDispatcher()->vkCmdCopyTensorARM( static_cast( m_commandBuffer ), reinterpret_cast( ©TensorInfo ) ); - } - - // wrapper function for command vkGetPhysicalDeviceExternalTensorPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceExternalTensorPropertiesARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ExternalTensorPropertiesARM - PhysicalDevice::getExternalTensorPropertiesARM( const PhysicalDeviceExternalTensorInfoARM & externalTensorInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceExternalTensorPropertiesARM && - "Function requires " ); - - ExternalTensorPropertiesARM externalTensorProperties; - getDispatcher()->vkGetPhysicalDeviceExternalTensorPropertiesARM( static_cast( m_physicalDevice ), - reinterpret_cast( &externalTensorInfo ), - reinterpret_cast( &externalTensorProperties ) ); - - return externalTensorProperties; - } - - // wrapper function for command vkGetTensorOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorOpaqueCaptureDescriptorDataARM.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getTensorOpaqueCaptureDescriptorDataARM( const TensorCaptureDescriptorDataInfoARM & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorOpaqueCaptureDescriptorDataARM && - "Function requires " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkGetTensorOpaqueCaptureDescriptorDataARM( - static_cast( m_device ), reinterpret_cast( &info ), &data ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getTensorOpaqueCaptureDescriptorDataARM" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkGetTensorViewOpaqueCaptureDescriptorDataARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetTensorViewOpaqueCaptureDescriptorDataARM.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getTensorViewOpaqueCaptureDescriptorDataARM( const TensorViewCaptureDescriptorDataInfoARM & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetTensorViewOpaqueCaptureDescriptorDataARM && - "Function requires " ); - - DataType data; - Result result = static_cast( getDispatcher()->vkGetTensorViewOpaqueCaptureDescriptorDataARM( - static_cast( m_device ), reinterpret_cast( &info ), &data ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getTensorViewOpaqueCaptureDescriptorDataARM" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - //=== VK_EXT_shader_module_identifier === - - // wrapper function for command vkGetShaderModuleIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleIdentifierEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ShaderModuleIdentifierEXT ShaderModule::getIdentifierEXT() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderModuleIdentifierEXT && - "Function requires " ); - - ShaderModuleIdentifierEXT identifier; - getDispatcher()->vkGetShaderModuleIdentifierEXT( - static_cast( m_device ), static_cast( m_shaderModule ), reinterpret_cast( &identifier ) ); - - return identifier; - } - - // wrapper function for command vkGetShaderModuleCreateInfoIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderModuleCreateInfoIdentifierEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE ShaderModuleIdentifierEXT - Device::getShaderModuleCreateInfoIdentifierEXT( const ShaderModuleCreateInfo & createInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderModuleCreateInfoIdentifierEXT && - "Function requires " ); - - ShaderModuleIdentifierEXT identifier; - getDispatcher()->vkGetShaderModuleCreateInfoIdentifierEXT( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( &identifier ) ); - - return identifier; - } - - //=== VK_NV_optical_flow === - - // wrapper function for command vkGetPhysicalDeviceOpticalFlowImageFormatsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceOpticalFlowImageFormatsNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getOpticalFlowImageFormatsNV( const OpticalFlowImageFormatInfoNV & opticalFlowImageFormatInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV && - "Function requires " ); - - std::vector imageFormatProperties; - uint32_t formatCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV( - static_cast( m_physicalDevice ), - reinterpret_cast( &opticalFlowImageFormatInfo ), - &formatCount, - nullptr ) ); - if ( ( result == Result::eSuccess ) && formatCount ) - { - imageFormatProperties.resize( formatCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV( - static_cast( m_physicalDevice ), - reinterpret_cast( &opticalFlowImageFormatInfo ), - &formatCount, - reinterpret_cast( imageFormatProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getOpticalFlowImageFormatsNV" ); - VULKAN_HPP_ASSERT( formatCount <= imageFormatProperties.size() ); - if ( formatCount < imageFormatProperties.size() ) - { - imageFormatProperties.resize( formatCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( imageFormatProperties ) ); - } - - // wrapper function for command vkCreateOpticalFlowSessionNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateOpticalFlowSessionNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createOpticalFlowSessionNV( OpticalFlowSessionCreateInfoNV const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateOpticalFlowSessionNV && "Function requires " ); - - VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session; - Result result = - static_cast( getDispatcher()->vkCreateOpticalFlowSessionNV( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &session ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createOpticalFlowSessionNV" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, OpticalFlowSessionNV( *this, *reinterpret_cast( &session ), allocator ) ); - } - - // wrapper function for command vkBindOpticalFlowSessionImageNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindOpticalFlowSessionImageNV.html - VULKAN_HPP_INLINE typename ResultValueType::type - OpticalFlowSessionNV::bindImage( OpticalFlowSessionBindingPointNV bindingPoint, VULKAN_HPP_NAMESPACE::ImageView view, ImageLayout layout ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBindOpticalFlowSessionImageNV && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkBindOpticalFlowSessionImageNV( static_cast( m_device ), - static_cast( m_opticalFlowSessionNV ), - static_cast( bindingPoint ), - static_cast( view ), - static_cast( layout ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::OpticalFlowSessionNV::bindImage" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCmdOpticalFlowExecuteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdOpticalFlowExecuteNV.html - VULKAN_HPP_INLINE void CommandBuffer::opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, - const OpticalFlowExecuteInfoNV & executeInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdOpticalFlowExecuteNV && "Function requires " ); - - getDispatcher()->vkCmdOpticalFlowExecuteNV( static_cast( m_commandBuffer ), - static_cast( session ), - reinterpret_cast( &executeInfo ) ); - } - - //=== VK_KHR_maintenance5 === - - // wrapper function for command vkCmdBindIndexBuffer2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindIndexBuffer2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::bindIndexBuffer2KHR( VULKAN_HPP_NAMESPACE::Buffer buffer, - DeviceSize offset, - DeviceSize size, - IndexType indexType ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindIndexBuffer2KHR && - "Function requires or " ); - - getDispatcher()->vkCmdBindIndexBuffer2KHR( static_cast( m_commandBuffer ), - static_cast( buffer ), - static_cast( offset ), - static_cast( size ), - static_cast( indexType ) ); - } - - // wrapper function for command vkGetRenderingAreaGranularityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetRenderingAreaGranularityKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Extent2D - Device::getRenderingAreaGranularityKHR( const RenderingAreaInfo & renderingAreaInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetRenderingAreaGranularityKHR && - "Function requires or " ); - - Extent2D granularity; - getDispatcher()->vkGetRenderingAreaGranularityKHR( static_cast( m_device ), - reinterpret_cast( &renderingAreaInfo ), - reinterpret_cast( &granularity ) ); - - return granularity; - } - - // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 - Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR && - "Function requires or " ); - - SubresourceLayout2 layout; - getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &layout ) ); - - return layout; - } - - // wrapper function for command vkGetDeviceImageSubresourceLayoutKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDeviceImageSubresourceLayoutKHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getImageSubresourceLayoutKHR( const DeviceImageSubresourceInfo & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR && - "Function requires or " ); - - StructureChain structureChain; - SubresourceLayout2 & layout = structureChain.template get(); - getDispatcher()->vkGetDeviceImageSubresourceLayoutKHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &layout ) ); - - return structureChain; - } - - // wrapper function for command vkGetImageSubresourceLayout2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE SubresourceLayout2 Image::getSubresourceLayout2KHR( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkGetImageSubresourceLayout2KHR && - "Function requires or or or " ); - - SubresourceLayout2 layout; - getDispatcher()->vkGetImageSubresourceLayout2KHR( static_cast( m_device ), - static_cast( m_image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return layout; - } - - // wrapper function for command vkGetImageSubresourceLayout2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetImageSubresourceLayout2KHR.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Image::getSubresourceLayout2KHR( const ImageSubresource2 & subresource ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkGetImageSubresourceLayout2KHR && - "Function requires or or or " ); - - StructureChain structureChain; - SubresourceLayout2 & layout = structureChain.template get(); - getDispatcher()->vkGetImageSubresourceLayout2KHR( static_cast( m_device ), - static_cast( m_image ), - reinterpret_cast( &subresource ), - reinterpret_cast( &layout ) ); - - return structureChain; - } - - //=== VK_AMD_anti_lag === - - // wrapper function for command vkAntiLagUpdateAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkAntiLagUpdateAMD.html - VULKAN_HPP_INLINE void Device::antiLagUpdateAMD( const AntiLagDataAMD & data ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkAntiLagUpdateAMD && "Function requires " ); - - getDispatcher()->vkAntiLagUpdateAMD( static_cast( m_device ), reinterpret_cast( &data ) ); - } - - //=== VK_KHR_present_wait2 === - - // wrapper function for command vkWaitForPresent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkWaitForPresent2KHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result SwapchainKHR::waitForPresent2( const PresentWait2InfoKHR & presentWait2Info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForPresent2KHR && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkWaitForPresent2KHR( static_cast( m_device ), - static_cast( m_swapchainKHR ), - reinterpret_cast( &presentWait2Info ) ) ); - -# if defined( VULKAN_HPP_HANDLE_ERROR_OUT_OF_DATE_AS_SUCCESS ) - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::waitForPresent2", - { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR, Result::eErrorOutOfDateKHR } ); -# else - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::waitForPresent2", { Result::eSuccess, Result::eTimeout, Result::eSuboptimalKHR } ); -# endif - - return static_cast( result ); - } - - //=== VK_EXT_shader_object === - - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createShadersEXT( ArrayProxy const & createInfos, Optional allocator ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateShadersEXT && "Function requires " ); - - std::vector shaders( createInfos.size() ); - Result result = static_cast( getDispatcher()->vkCreateShadersEXT( static_cast( m_device ), - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( shaders.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createShadersEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); - std::vector shadersRAII; - if ( result == Result::eSuccess ) - { - shadersRAII.reserve( shaders.size() ); - for ( auto & shader : shaders ) - { - shadersRAII.emplace_back( *this, *reinterpret_cast( &shader ), allocator, result ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( shadersRAII ) ); - } - - // wrapper function for command vkCreateShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateShadersEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createShaderEXT( ShaderCreateInfoEXT const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateShadersEXT && "Function requires " ); - - VULKAN_HPP_NAMESPACE::ShaderEXT shader; - Result result = static_cast( getDispatcher()->vkCreateShadersEXT( static_cast( m_device ), - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &shader ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createShaderEXT", { Result::eSuccess, Result::eIncompatibleShaderBinaryEXT } ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, ShaderEXT( *this, *reinterpret_cast( &shader ), allocator, result ) ); - } - - // wrapper function for command vkGetShaderBinaryDataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetShaderBinaryDataEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type ShaderEXT::getBinaryData() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderBinaryDataEXT && "Function requires " ); - - std::vector data; - size_t dataSize; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetShaderBinaryDataEXT( static_cast( m_device ), static_cast( m_shaderEXT ), &dataSize, nullptr ) ); - if ( ( result == Result::eSuccess ) && dataSize ) - { - data.resize( dataSize ); - result = static_cast( getDispatcher()->vkGetShaderBinaryDataEXT( - static_cast( m_device ), static_cast( m_shaderEXT ), &dataSize, reinterpret_cast( data.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::ShaderEXT::getBinaryData" ); - VULKAN_HPP_ASSERT( dataSize <= data.size() ); - if ( dataSize < data.size() ) - { - data.resize( dataSize ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data ) ); - } - - // wrapper function for command vkCmdBindShadersEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindShadersEXT.html - VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( ArrayProxy const & stages, - ArrayProxy const & shaders ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadersEXT && "Function requires " ); -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( stages.size() == shaders.size() ); -# else - if ( stages.size() != shaders.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindShadersEXT: stages.size() != shaders.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - - getDispatcher()->vkCmdBindShadersEXT( static_cast( m_commandBuffer ), - stages.size(), - reinterpret_cast( stages.data() ), - reinterpret_cast( shaders.data() ) ); - } - - // wrapper function for command vkCmdSetDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDepthClampRangeEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setDepthClampRangeEXT( DepthClampModeEXT depthClampMode, - Optional depthClampRange ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClampRangeEXT && - "Function requires or " ); - - getDispatcher()->vkCmdSetDepthClampRangeEXT( static_cast( m_commandBuffer ), - static_cast( depthClampMode ), - reinterpret_cast( depthClampRange.get() ) ); - } - - //=== VK_KHR_pipeline_binary === - - // wrapper function for command vkCreatePipelineBinariesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreatePipelineBinariesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createPipelineBinariesKHR( PipelineBinaryCreateInfoKHR const & createInfo, Optional allocator ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreatePipelineBinariesKHR && "Function requires " ); - - std::vector pipelineBinaries; - PipelineBinaryHandlesInfoKHR binaries; - Result result; - if ( createInfo.pKeysAndDataInfo ) - { - VULKAN_HPP_ASSERT( !createInfo.pipeline && !createInfo.pPipelineCreateInfo ); - pipelineBinaries.resize( createInfo.pKeysAndDataInfo->binaryCount ); - binaries.pipelineBinaryCount = createInfo.pKeysAndDataInfo->binaryCount; - binaries.pPipelineBinaries = pipelineBinaries.data(); - result = static_cast( getDispatcher()->vkCreatePipelineBinariesKHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - } - else - { - VULKAN_HPP_ASSERT( !createInfo.pipeline ^ !createInfo.pPipelineCreateInfo ); - result = static_cast( getDispatcher()->vkCreatePipelineBinariesKHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - if ( result == Result::eSuccess ) - { - pipelineBinaries.resize( binaries.pipelineBinaryCount ); - binaries.pPipelineBinaries = pipelineBinaries.data(); - result = static_cast( getDispatcher()->vkCreatePipelineBinariesKHR( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &binaries ) ) ); - } - } - - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createPipelineBinariesKHR", - { Result::eSuccess, Result::eIncomplete, Result::ePipelineBinaryMissingKHR } ); - std::vector pipelineBinariesRAII; - if ( result == Result::eSuccess ) - { - pipelineBinariesRAII.reserve( pipelineBinaries.size() ); - for ( auto & pipelineBinary : pipelineBinaries ) - { - pipelineBinariesRAII.emplace_back( *this, *reinterpret_cast( &pipelineBinary ), allocator, result ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelineBinariesRAII ) ); - } - - // wrapper function for command vkGetPipelineKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineKeyKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getPipelineKeyKHR( Optional pipelineCreateInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineKeyKHR && "Function requires " ); - - PipelineBinaryKeyKHR pipelineKey; - Result result = static_cast( getDispatcher()->vkGetPipelineKeyKHR( static_cast( m_device ), - reinterpret_cast( pipelineCreateInfo.get() ), - reinterpret_cast( &pipelineKey ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelineKeyKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelineKey ) ); - } - - // wrapper function for command vkGetPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPipelineBinaryDataKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>>::type - Device::getPipelineBinaryDataKHR( const PipelineBinaryDataInfoKHR & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPipelineBinaryDataKHR && "Function requires " ); - - std::pair> data_; - PipelineBinaryKeyKHR & pipelineBinaryKey = data_.first; - std::vector & pipelineBinaryData = data_.second; - size_t pipelineBinaryDataSize; - Result result = static_cast( getDispatcher()->vkGetPipelineBinaryDataKHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &pipelineBinaryKey ), - &pipelineBinaryDataSize, - nullptr ) ); - if ( result == Result::eSuccess ) - { - pipelineBinaryData.resize( pipelineBinaryDataSize ); - result = static_cast( getDispatcher()->vkGetPipelineBinaryDataKHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &pipelineBinaryKey ), - &pipelineBinaryDataSize, - reinterpret_cast( pipelineBinaryData.data() ) ) ); - } - - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getPipelineBinaryDataKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkReleaseCapturedPipelineDataKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseCapturedPipelineDataKHR.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::releaseCapturedPipelineDataKHR( const ReleaseCapturedPipelineDataInfoKHR & info, - Optional allocator ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseCapturedPipelineDataKHR && "Function requires " ); - - Result result = - static_cast( getDispatcher()->vkReleaseCapturedPipelineDataKHR( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( allocator.get() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::releaseCapturedPipelineDataKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - //=== VK_QCOM_tile_properties === - - // wrapper function for command vkGetFramebufferTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetFramebufferTilePropertiesQCOM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type Framebuffer::getTilePropertiesQCOM() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetFramebufferTilePropertiesQCOM && - "Function requires " ); - - std::vector properties; - uint32_t propertiesCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetFramebufferTilePropertiesQCOM( - static_cast( m_device ), static_cast( m_framebuffer ), &propertiesCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertiesCount ) - { - properties.resize( propertiesCount ); - result = static_cast( getDispatcher()->vkGetFramebufferTilePropertiesQCOM( static_cast( m_device ), - static_cast( m_framebuffer ), - &propertiesCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Framebuffer::getTilePropertiesQCOM" ); - VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); - if ( propertiesCount < properties.size() ) - { - properties.resize( propertiesCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetDynamicRenderingTilePropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDynamicRenderingTilePropertiesQCOM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getDynamicRenderingTilePropertiesQCOM( const RenderingInfo & renderingInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDynamicRenderingTilePropertiesQCOM && - "Function requires " ); - - TilePropertiesQCOM properties; - Result result = - static_cast( getDispatcher()->vkGetDynamicRenderingTilePropertiesQCOM( static_cast( m_device ), - reinterpret_cast( &renderingInfo ), - reinterpret_cast( &properties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getDynamicRenderingTilePropertiesQCOM" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - //=== VK_KHR_swapchain_maintenance1 === - - // wrapper function for command vkReleaseSwapchainImagesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkReleaseSwapchainImagesKHR.html - VULKAN_HPP_INLINE typename ResultValueType::type Device::releaseSwapchainImagesKHR( const ReleaseSwapchainImagesInfoKHR & releaseInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkReleaseSwapchainImagesKHR && - "Function requires or " ); - - Result result = static_cast( getDispatcher()->vkReleaseSwapchainImagesKHR( - static_cast( m_device ), reinterpret_cast( &releaseInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::releaseSwapchainImagesKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - //=== VK_NV_cooperative_vector === - - // wrapper function for command vkGetPhysicalDeviceCooperativeVectorPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeVectorPropertiesNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCooperativeVectorPropertiesNV() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeVectorPropertiesNV && - "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceCooperativeVectorPropertiesNV( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeVectorPropertiesNV( - static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCooperativeVectorPropertiesNV" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkConvertCooperativeVectorMatrixNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::convertCooperativeVectorMatrixNV( const ConvertCooperativeVectorMatrixInfoNV & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkConvertCooperativeVectorMatrixNV && - "Function requires " ); - - Result result = static_cast( getDispatcher()->vkConvertCooperativeVectorMatrixNV( - static_cast( m_device ), reinterpret_cast( &info ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::convertCooperativeVectorMatrixNV", { Result::eSuccess, Result::eIncomplete } ); - - return static_cast( result ); - } - - // wrapper function for command vkCmdConvertCooperativeVectorMatrixNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdConvertCooperativeVectorMatrixNV.html - VULKAN_HPP_INLINE void - CommandBuffer::convertCooperativeVectorMatrixNV( ArrayProxy const & infos ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdConvertCooperativeVectorMatrixNV && - "Function requires " ); - - getDispatcher()->vkCmdConvertCooperativeVectorMatrixNV( - static_cast( m_commandBuffer ), infos.size(), reinterpret_cast( infos.data() ) ); - } - - //=== VK_NV_low_latency2 === - - // wrapper function for command vkSetLatencySleepModeNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencySleepModeNV.html - VULKAN_HPP_INLINE typename ResultValueType::type SwapchainKHR::setLatencySleepModeNV( const LatencySleepModeInfoNV & sleepModeInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencySleepModeNV && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkSetLatencySleepModeNV( static_cast( m_device ), - static_cast( m_swapchainKHR ), - reinterpret_cast( &sleepModeInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::setLatencySleepModeNV" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkLatencySleepNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkLatencySleepNV.html - VULKAN_HPP_INLINE typename ResultValueType::type SwapchainKHR::latencySleepNV( const LatencySleepInfoNV & sleepInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkLatencySleepNV && "Function requires " ); - - Result result = static_cast( getDispatcher()->vkLatencySleepNV( - static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( &sleepInfo ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::SwapchainKHR::latencySleepNV" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html - VULKAN_HPP_INLINE void SwapchainKHR::setLatencyMarkerNV( const SetLatencyMarkerInfoNV & latencyMarkerInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencyMarkerNV && "Function requires " ); - - getDispatcher()->vkSetLatencyMarkerNV( static_cast( m_device ), - static_cast( m_swapchainKHR ), - reinterpret_cast( &latencyMarkerInfo ) ); - } - - // wrapper function for command vkGetLatencyTimingsNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetLatencyTimingsNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector SwapchainKHR::getLatencyTimingsNV() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetLatencyTimingsNV && "Function requires " ); - - std::vector timings; - GetLatencyMarkerInfoNV latencyMarkerInfo; - getDispatcher()->vkGetLatencyTimingsNV( - static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( &latencyMarkerInfo ) ); - timings.resize( latencyMarkerInfo.timingCount ); - latencyMarkerInfo.pTimings = timings.data(); - getDispatcher()->vkGetLatencyTimingsNV( - static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( &latencyMarkerInfo ) ); - - return timings; - } - - // wrapper function for command vkQueueNotifyOutOfBandNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkQueueNotifyOutOfBandNV.html - VULKAN_HPP_INLINE void Queue::notifyOutOfBandNV( const OutOfBandQueueTypeInfoNV & queueTypeInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkQueueNotifyOutOfBandNV && "Function requires " ); - - getDispatcher()->vkQueueNotifyOutOfBandNV( static_cast( m_queue ), reinterpret_cast( &queueTypeInfo ) ); - } - - //=== VK_KHR_cooperative_matrix === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCooperativeMatrixPropertiesKHR() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR && - "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR( - static_cast( m_physicalDevice ), &propertyCount, reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixPropertiesKHR" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - //=== VK_ARM_data_graph === - - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::createDataGraphPipelinesARM( Optional const & deferredOperation, - Optional const & pipelineCache, - ArrayProxy const & createInfos, - Optional allocator ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDataGraphPipelinesARM && "Function requires " ); - - std::vector pipelines( createInfos.size() ); - Result result = - static_cast( getDispatcher()->vkCreateDataGraphPipelinesARM( static_cast( m_device ), - deferredOperation ? static_cast( **deferredOperation ) : 0, - pipelineCache ? static_cast( **pipelineCache ) : 0, - createInfos.size(), - reinterpret_cast( createInfos.data() ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( pipelines.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDataGraphPipelinesARM", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - std::vector pipelinesRAII; - if ( result == Result::eSuccess ) - { - pipelinesRAII.reserve( pipelines.size() ); - for ( auto & pipeline : pipelines ) - { - pipelinesRAII.emplace_back( *this, *reinterpret_cast( &pipeline ), allocator, result ); - } - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( pipelinesRAII ) ); - } - - // wrapper function for command vkCreateDataGraphPipelinesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelinesARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createDataGraphPipelineARM( Optional const & deferredOperation, - Optional const & pipelineCache, - DataGraphPipelineCreateInfoARM const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDataGraphPipelinesARM && "Function requires " ); - - VULKAN_HPP_NAMESPACE::Pipeline pipeline; - Result result = - static_cast( getDispatcher()->vkCreateDataGraphPipelinesARM( static_cast( m_device ), - deferredOperation ? static_cast( **deferredOperation ) : 0, - pipelineCache ? static_cast( **pipelineCache ) : 0, - 1, - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &pipeline ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( - result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDataGraphPipelineARM", { Result::eSuccess, Result::ePipelineCompileRequiredEXT } ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, Pipeline( *this, *reinterpret_cast( &pipeline ), allocator, result ) ); - } - - // wrapper function for command vkCreateDataGraphPipelineSessionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateDataGraphPipelineSessionARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createDataGraphPipelineSessionARM( DataGraphPipelineSessionCreateInfoARM const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateDataGraphPipelineSessionARM && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM session; - Result result = static_cast( - getDispatcher()->vkCreateDataGraphPipelineSessionARM( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &session ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createDataGraphPipelineSessionARM" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, DataGraphPipelineSessionARM( *this, *reinterpret_cast( &session ), allocator ) ); - } - - // wrapper function for command vkGetDataGraphPipelineSessionBindPointRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionBindPointRequirementsARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getDataGraphPipelineSessionBindPointRequirementsARM( const DataGraphPipelineSessionBindPointRequirementsInfoARM & info ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDataGraphPipelineSessionBindPointRequirementsARM && - "Function requires " ); - - std::vector bindPointRequirements; - uint32_t bindPointRequirementCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetDataGraphPipelineSessionBindPointRequirementsARM( - static_cast( m_device ), - reinterpret_cast( &info ), - &bindPointRequirementCount, - nullptr ) ); - if ( ( result == Result::eSuccess ) && bindPointRequirementCount ) - { - bindPointRequirements.resize( bindPointRequirementCount ); - result = static_cast( getDispatcher()->vkGetDataGraphPipelineSessionBindPointRequirementsARM( - static_cast( m_device ), - reinterpret_cast( &info ), - &bindPointRequirementCount, - reinterpret_cast( bindPointRequirements.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getDataGraphPipelineSessionBindPointRequirementsARM" ); - VULKAN_HPP_ASSERT( bindPointRequirementCount <= bindPointRequirements.size() ); - if ( bindPointRequirementCount < bindPointRequirements.size() ) - { - bindPointRequirements.resize( bindPointRequirementCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( bindPointRequirements ) ); - } - - // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDataGraphPipelineSessionMemoryRequirementsARM && - "Function requires " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetDataGraphPipelineSessionMemoryRequirementsARM( - static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetDataGraphPipelineSessionMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineSessionMemoryRequirementsARM.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getDataGraphPipelineSessionMemoryRequirementsARM( const DataGraphPipelineSessionMemoryRequirementsInfoARM & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDataGraphPipelineSessionMemoryRequirementsARM && - "Function requires " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetDataGraphPipelineSessionMemoryRequirementsARM( - static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkBindDataGraphPipelineSessionMemoryARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkBindDataGraphPipelineSessionMemoryARM.html - VULKAN_HPP_INLINE typename ResultValueType::type - Device::bindDataGraphPipelineSessionMemoryARM( ArrayProxy const & bindInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkBindDataGraphPipelineSessionMemoryARM && - "Function requires " ); - - Result result = static_cast( getDispatcher()->vkBindDataGraphPipelineSessionMemoryARM( - static_cast( m_device ), bindInfos.size(), reinterpret_cast( bindInfos.data() ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::bindDataGraphPipelineSessionMemoryARM" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result ); - } - - // wrapper function for command vkCmdDispatchDataGraphARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchDataGraphARM.html - VULKAN_HPP_INLINE void CommandBuffer::dispatchDataGraphARM( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM session, - Optional info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchDataGraphARM && "Function requires " ); - - getDispatcher()->vkCmdDispatchDataGraphARM( static_cast( m_commandBuffer ), - static_cast( session ), - reinterpret_cast( info.get() ) ); - } - - // wrapper function for command vkGetDataGraphPipelineAvailablePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelineAvailablePropertiesARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getDataGraphPipelineAvailablePropertiesARM( const DataGraphPipelineInfoARM & pipelineInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDataGraphPipelineAvailablePropertiesARM && - "Function requires " ); - - std::vector properties; - uint32_t propertiesCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetDataGraphPipelineAvailablePropertiesARM( - static_cast( m_device ), reinterpret_cast( &pipelineInfo ), &propertiesCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertiesCount ) - { - properties.resize( propertiesCount ); - result = static_cast( - getDispatcher()->vkGetDataGraphPipelineAvailablePropertiesARM( static_cast( m_device ), - reinterpret_cast( &pipelineInfo ), - &propertiesCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getDataGraphPipelineAvailablePropertiesARM" ); - VULKAN_HPP_ASSERT( propertiesCount <= properties.size() ); - if ( propertiesCount < properties.size() ) - { - properties.resize( propertiesCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetDataGraphPipelinePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetDataGraphPipelinePropertiesARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result - Device::getDataGraphPipelinePropertiesARM( const DataGraphPipelineInfoARM * pPipelineInfo, - uint32_t propertiesCount, - DataGraphPipelinePropertyQueryResultARM * pProperties ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetDataGraphPipelinePropertiesARM && - "Function requires " ); - return static_cast( - getDispatcher()->vkGetDataGraphPipelinePropertiesARM( static_cast( m_device ), - reinterpret_cast( pPipelineInfo ), - propertiesCount, - reinterpret_cast( pProperties ) ) ); - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getQueueFamilyDataGraphPropertiesARM( uint32_t queueFamilyIndex ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM && - "Function requires " ); - - std::vector queueFamilyDataGraphProperties; - uint32_t queueFamilyDataGraphPropertyCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( - static_cast( m_physicalDevice ), queueFamilyIndex, &queueFamilyDataGraphPropertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && queueFamilyDataGraphPropertyCount ) - { - queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM( - static_cast( m_physicalDevice ), - queueFamilyIndex, - &queueFamilyDataGraphPropertyCount, - reinterpret_cast( queueFamilyDataGraphProperties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getQueueFamilyDataGraphPropertiesARM" ); - VULKAN_HPP_ASSERT( queueFamilyDataGraphPropertyCount <= queueFamilyDataGraphProperties.size() ); - if ( queueFamilyDataGraphPropertyCount < queueFamilyDataGraphProperties.size() ) - { - queueFamilyDataGraphProperties.resize( queueFamilyDataGraphPropertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( queueFamilyDataGraphProperties ) ); - } - - // wrapper function for command vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE QueueFamilyDataGraphProcessingEnginePropertiesARM - PhysicalDevice::getQueueFamilyDataGraphProcessingEnginePropertiesARM( - const PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & queueFamilyDataGraphProcessingEngineInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM && - "Function requires " ); - - QueueFamilyDataGraphProcessingEnginePropertiesARM queueFamilyDataGraphProcessingEngineProperties; - getDispatcher()->vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM( - static_cast( m_physicalDevice ), - reinterpret_cast( &queueFamilyDataGraphProcessingEngineInfo ), - reinterpret_cast( &queueFamilyDataGraphProcessingEngineProperties ) ); - - return queueFamilyDataGraphProcessingEngineProperties; - } - - //=== VK_EXT_attachment_feedback_loop_dynamic_state === - - // wrapper function for command vkCmdSetAttachmentFeedbackLoopEnableEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetAttachmentFeedbackLoopEnableEXT.html - VULKAN_HPP_INLINE void CommandBuffer::setAttachmentFeedbackLoopEnableEXT( ImageAspectFlags aspectMask ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAttachmentFeedbackLoopEnableEXT && - "Function requires " ); - - getDispatcher()->vkCmdSetAttachmentFeedbackLoopEnableEXT( static_cast( m_commandBuffer ), - static_cast( aspectMask ) ); - } - -# if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_external_memory_screen_buffer === - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::getScreenBufferPropertiesQNX( const struct _screen_buffer * buffer, - ScreenBufferPropertiesQNX * pProperties ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetScreenBufferPropertiesQNX && - "Function requires " ); - return static_cast( getDispatcher()->vkGetScreenBufferPropertiesQNX( - static_cast( m_device ), buffer, reinterpret_cast( pProperties ) ) ); - } - - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetScreenBufferPropertiesQNX && - "Function requires " ); - - ScreenBufferPropertiesQNX properties; - Result result = static_cast( getDispatcher()->vkGetScreenBufferPropertiesQNX( - static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - - // wrapper function for command vkGetScreenBufferPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetScreenBufferPropertiesQNX.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getScreenBufferPropertiesQNX( const struct _screen_buffer & buffer ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetScreenBufferPropertiesQNX && - "Function requires " ); - - StructureChain structureChain; - ScreenBufferPropertiesQNX & properties = structureChain.template get(); - Result result = static_cast( getDispatcher()->vkGetScreenBufferPropertiesQNX( - static_cast( m_device ), &buffer, reinterpret_cast( &properties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getScreenBufferPropertiesQNX" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( structureChain ) ); - } -# endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_KHR_line_rasterization === - - // wrapper function for command vkCmdSetLineStippleKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetLineStippleKHR.html - VULKAN_HPP_INLINE void CommandBuffer::setLineStippleKHR( uint32_t lineStippleFactor, uint16_t lineStipplePattern ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleKHR && - "Function requires or or " ); - - getDispatcher()->vkCmdSetLineStippleKHR( static_cast( m_commandBuffer ), lineStippleFactor, lineStipplePattern ); - } - - //=== VK_KHR_calibrated_timestamps === - - // wrapper function for command vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCalibrateableTimeDomainsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type PhysicalDevice::getCalibrateableTimeDomainsKHR() const - { - VULKAN_HPP_ASSERT( - getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR && - "Function requires or " ); - - std::vector timeDomains; - uint32_t timeDomainCount; - Result result; - do - { - result = static_cast( - getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( static_cast( m_physicalDevice ), &timeDomainCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && timeDomainCount ) - { - timeDomains.resize( timeDomainCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceCalibrateableTimeDomainsKHR( - static_cast( m_physicalDevice ), &timeDomainCount, reinterpret_cast( timeDomains.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCalibrateableTimeDomainsKHR" ); - VULKAN_HPP_ASSERT( timeDomainCount <= timeDomains.size() ); - if ( timeDomainCount < timeDomains.size() ) - { - timeDomains.resize( timeDomainCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( timeDomains ) ); - } - - // wrapper function for command vkGetCalibratedTimestampsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType, uint64_t>>::type - Device::getCalibratedTimestampsKHR( ArrayProxy const & timestampInfos ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsKHR && - "Function requires or " ); - - std::pair, uint64_t> data_( std::piecewise_construct, std::forward_as_tuple( timestampInfos.size() ), std::forward_as_tuple( 0 ) ); - std::vector & timestamps = data_.first; - uint64_t & maxDeviation = data_.second; - Result result = - static_cast( getDispatcher()->vkGetCalibratedTimestampsKHR( static_cast( m_device ), - timestampInfos.size(), - reinterpret_cast( timestampInfos.data() ), - timestamps.data(), - &maxDeviation ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getCalibratedTimestampsKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); - } - - // wrapper function for command vkGetCalibratedTimestampsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetCalibratedTimestampsKHR.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - Device::getCalibratedTimestampKHR( const CalibratedTimestampInfoKHR & timestampInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetCalibratedTimestampsKHR && - "Function requires or " ); - - std::pair data_; - uint64_t & timestamp = data_.first; - uint64_t & maxDeviation = data_.second; - Result result = static_cast( getDispatcher()->vkGetCalibratedTimestampsKHR( - static_cast( m_device ), 1, reinterpret_cast( ×tampInfo ), ×tamp, &maxDeviation ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getCalibratedTimestampKHR" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); - } - - //=== VK_KHR_maintenance6 === - - // wrapper function for command vkCmdBindDescriptorSets2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorSets2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorSets2KHR( const BindDescriptorSetsInfo & bindDescriptorSetsInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorSets2KHR && - "Function requires or " ); - - getDispatcher()->vkCmdBindDescriptorSets2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( &bindDescriptorSetsInfo ) ); - } - - // wrapper function for command vkCmdPushConstants2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushConstants2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::pushConstants2KHR( const PushConstantsInfo & pushConstantsInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushConstants2KHR && "Function requires or " ); - - getDispatcher()->vkCmdPushConstants2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( &pushConstantsInfo ) ); - } - - // wrapper function for command vkCmdPushDescriptorSet2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSet2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::pushDescriptorSet2KHR( const PushDescriptorSetInfo & pushDescriptorSetInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSet2KHR && - "Function requires or " ); - - getDispatcher()->vkCmdPushDescriptorSet2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( &pushDescriptorSetInfo ) ); - } - - // wrapper function for command vkCmdPushDescriptorSetWithTemplate2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPushDescriptorSetWithTemplate2KHR.html - VULKAN_HPP_INLINE void - CommandBuffer::pushDescriptorSetWithTemplate2KHR( const PushDescriptorSetWithTemplateInfo & pushDescriptorSetWithTemplateInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPushDescriptorSetWithTemplate2KHR && - "Function requires or " ); - - getDispatcher()->vkCmdPushDescriptorSetWithTemplate2KHR( - static_cast( m_commandBuffer ), reinterpret_cast( &pushDescriptorSetWithTemplateInfo ) ); - } - - // wrapper function for command vkCmdSetDescriptorBufferOffsets2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetDescriptorBufferOffsets2EXT.html - VULKAN_HPP_INLINE void - CommandBuffer::setDescriptorBufferOffsets2EXT( const SetDescriptorBufferOffsetsInfoEXT & setDescriptorBufferOffsetsInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDescriptorBufferOffsets2EXT && - "Function requires " ); - - getDispatcher()->vkCmdSetDescriptorBufferOffsets2EXT( static_cast( m_commandBuffer ), - reinterpret_cast( &setDescriptorBufferOffsetsInfo ) ); - } - - // wrapper function for command vkCmdBindDescriptorBufferEmbeddedSamplers2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindDescriptorBufferEmbeddedSamplers2EXT.html - VULKAN_HPP_INLINE void CommandBuffer::bindDescriptorBufferEmbeddedSamplers2EXT( - const BindDescriptorBufferEmbeddedSamplersInfoEXT & bindDescriptorBufferEmbeddedSamplersInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplers2EXT && - "Function requires " ); - - getDispatcher()->vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( - static_cast( m_commandBuffer ), - reinterpret_cast( &bindDescriptorBufferEmbeddedSamplersInfo ) ); - } - - //=== VK_QCOM_tile_memory_heap === - - // wrapper function for command vkCmdBindTileMemoryQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBindTileMemoryQCOM.html - VULKAN_HPP_INLINE void CommandBuffer::bindTileMemoryQCOM( Optional tileMemoryBindInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindTileMemoryQCOM && "Function requires " ); - - getDispatcher()->vkCmdBindTileMemoryQCOM( static_cast( m_commandBuffer ), - reinterpret_cast( tileMemoryBindInfo.get() ) ); - } - - //=== VK_KHR_copy_memory_indirect === - - // wrapper function for command vkCmdCopyMemoryIndirectKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryIndirectKHR.html - VULKAN_HPP_INLINE void CommandBuffer::copyMemoryIndirectKHR( const CopyMemoryIndirectInfoKHR & copyMemoryIndirectInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryIndirectKHR && "Function requires " ); - - getDispatcher()->vkCmdCopyMemoryIndirectKHR( static_cast( m_commandBuffer ), - reinterpret_cast( ©MemoryIndirectInfo ) ); - } - - // wrapper function for command vkCmdCopyMemoryToImageIndirectKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdCopyMemoryToImageIndirectKHR.html - VULKAN_HPP_INLINE void - CommandBuffer::copyMemoryToImageIndirectKHR( const CopyMemoryToImageIndirectInfoKHR & copyMemoryToImageIndirectInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdCopyMemoryToImageIndirectKHR && - "Function requires " ); - - getDispatcher()->vkCmdCopyMemoryToImageIndirectKHR( static_cast( m_commandBuffer ), - reinterpret_cast( ©MemoryToImageIndirectInfo ) ); - } - - //=== VK_EXT_memory_decompression === - - // wrapper function for command vkCmdDecompressMemoryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryEXT.html - VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryEXT( const DecompressMemoryInfoEXT & decompressMemoryInfoEXT ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryEXT && "Function requires " ); - - getDispatcher()->vkCmdDecompressMemoryEXT( static_cast( m_commandBuffer ), - reinterpret_cast( &decompressMemoryInfoEXT ) ); - } - - // wrapper function for command vkCmdDecompressMemoryIndirectCountEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDecompressMemoryIndirectCountEXT.html - VULKAN_HPP_INLINE void CommandBuffer::decompressMemoryIndirectCountEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod, - DeviceAddress indirectCommandsAddress, - DeviceAddress indirectCommandsCountAddress, - uint32_t maxDecompressionCount, - uint32_t stride ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDecompressMemoryIndirectCountEXT && - "Function requires " ); - - getDispatcher()->vkCmdDecompressMemoryIndirectCountEXT( static_cast( m_commandBuffer ), - static_cast( decompressionMethod ), - static_cast( indirectCommandsAddress ), - static_cast( indirectCommandsCountAddress ), - maxDecompressionCount, - stride ); - } - - //=== VK_NV_external_compute_queue === - - // wrapper function for command vkCreateExternalComputeQueueNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createExternalComputeQueueNV( ExternalComputeQueueCreateInfoNV const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateExternalComputeQueueNV && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue; - Result result = - static_cast( getDispatcher()->vkCreateExternalComputeQueueNV( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &externalQueue ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createExternalComputeQueueNV" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, ExternalComputeQueueNV( *this, *reinterpret_cast( &externalQueue ), allocator ) ); - } - - // wrapper function for command vkGetExternalComputeQueueDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair ExternalComputeQueueNV::getData() const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetExternalComputeQueueDataNV && - "Function requires " ); - - std::pair data_; - ExternalComputeQueueDataParamsNV & arams = data_.first; - DataType & data = data_.second; - getDispatcher()->vkGetExternalComputeQueueDataNV( - static_cast( m_externalComputeQueueNV ), reinterpret_cast( &arams ), &data ); - - return data_; - } - - //=== VK_NV_cluster_acceleration_structure === - - // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetClusterAccelerationStructureBuildSizesNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR - Device::getClusterAccelerationStructureBuildSizesNV( const ClusterAccelerationStructureInputInfoNV & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetClusterAccelerationStructureBuildSizesNV && - "Function requires " ); - - AccelerationStructureBuildSizesInfoKHR sizeInfo; - getDispatcher()->vkGetClusterAccelerationStructureBuildSizesNV( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &sizeInfo ) ); - - return sizeInfo; - } - - // wrapper function for command vkCmdBuildClusterAccelerationStructureIndirectNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildClusterAccelerationStructureIndirectNV.html - VULKAN_HPP_INLINE void - CommandBuffer::buildClusterAccelerationStructureIndirectNV( const ClusterAccelerationStructureCommandsInfoNV & commandInfos ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildClusterAccelerationStructureIndirectNV && - "Function requires " ); - - getDispatcher()->vkCmdBuildClusterAccelerationStructureIndirectNV( - static_cast( m_commandBuffer ), reinterpret_cast( &commandInfos ) ); - } - - //=== VK_NV_partitioned_acceleration_structure === - - // wrapper function for command vkGetPartitionedAccelerationStructuresBuildSizesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPartitionedAccelerationStructuresBuildSizesNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE AccelerationStructureBuildSizesInfoKHR - Device::getPartitionedAccelerationStructuresBuildSizesNV( const PartitionedAccelerationStructureInstancesInputNV & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPartitionedAccelerationStructuresBuildSizesNV && - "Function requires " ); - - AccelerationStructureBuildSizesInfoKHR sizeInfo; - getDispatcher()->vkGetPartitionedAccelerationStructuresBuildSizesNV( - static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &sizeInfo ) ); - - return sizeInfo; - } - - // wrapper function for command vkCmdBuildPartitionedAccelerationStructuresNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBuildPartitionedAccelerationStructuresNV.html - VULKAN_HPP_INLINE void - CommandBuffer::buildPartitionedAccelerationStructuresNV( const BuildPartitionedAccelerationStructureInfoNV & buildInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBuildPartitionedAccelerationStructuresNV && - "Function requires " ); - - getDispatcher()->vkCmdBuildPartitionedAccelerationStructuresNV( static_cast( m_commandBuffer ), - reinterpret_cast( &buildInfo ) ); - } - - //=== VK_EXT_device_generated_commands === - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE MemoryRequirements2 - Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsEXT && - "Function requires " ); - - MemoryRequirements2 memoryRequirements; - getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsEXT( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return memoryRequirements; - } - - // wrapper function for command vkGetGeneratedCommandsMemoryRequirementsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetGeneratedCommandsMemoryRequirementsEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE StructureChain - Device::getGeneratedCommandsMemoryRequirementsEXT( const GeneratedCommandsMemoryRequirementsInfoEXT & info ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsEXT && - "Function requires " ); - - StructureChain structureChain; - MemoryRequirements2 & memoryRequirements = structureChain.template get(); - getDispatcher()->vkGetGeneratedCommandsMemoryRequirementsEXT( static_cast( m_device ), - reinterpret_cast( &info ), - reinterpret_cast( &memoryRequirements ) ); - - return structureChain; - } - - // wrapper function for command vkCmdPreprocessGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdPreprocessGeneratedCommandsEXT.html - VULKAN_HPP_INLINE void CommandBuffer::preprocessGeneratedCommandsEXT( const GeneratedCommandsInfoEXT & generatedCommandsInfo, - VULKAN_HPP_NAMESPACE::CommandBuffer stateCommandBuffer ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdPreprocessGeneratedCommandsEXT && - "Function requires " ); - - getDispatcher()->vkCmdPreprocessGeneratedCommandsEXT( static_cast( m_commandBuffer ), - reinterpret_cast( &generatedCommandsInfo ), - static_cast( stateCommandBuffer ) ); - } - - // wrapper function for command vkCmdExecuteGeneratedCommandsEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdExecuteGeneratedCommandsEXT.html - VULKAN_HPP_INLINE void CommandBuffer::executeGeneratedCommandsEXT( Bool32 isPreprocessed, - const GeneratedCommandsInfoEXT & generatedCommandsInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdExecuteGeneratedCommandsEXT && - "Function requires " ); - - getDispatcher()->vkCmdExecuteGeneratedCommandsEXT( static_cast( m_commandBuffer ), - static_cast( isPreprocessed ), - reinterpret_cast( &generatedCommandsInfo ) ); - } - - // wrapper function for command vkCreateIndirectCommandsLayoutEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectCommandsLayoutEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createIndirectCommandsLayoutEXT( IndirectCommandsLayoutCreateInfoEXT const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateIndirectCommandsLayoutEXT && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT indirectCommandsLayout; - Result result = - static_cast( getDispatcher()->vkCreateIndirectCommandsLayoutEXT( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &indirectCommandsLayout ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createIndirectCommandsLayoutEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, IndirectCommandsLayoutEXT( *this, *reinterpret_cast( &indirectCommandsLayout ), allocator ) ); - } - - // wrapper function for command vkCreateIndirectExecutionSetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateIndirectExecutionSetEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::createIndirectExecutionSetEXT( IndirectExecutionSetCreateInfoEXT const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateIndirectExecutionSetEXT && - "Function requires " ); - - VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT indirectExecutionSet; - Result result = - static_cast( getDispatcher()->vkCreateIndirectExecutionSetEXT( static_cast( m_device ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &indirectExecutionSet ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::createIndirectExecutionSetEXT" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( - result, IndirectExecutionSetEXT( *this, *reinterpret_cast( &indirectExecutionSet ), allocator ) ); - } - - // wrapper function for command vkUpdateIndirectExecutionSetPipelineEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetPipelineEXT.html - VULKAN_HPP_INLINE void - IndirectExecutionSetEXT::updatePipeline( ArrayProxy const & executionSetWrites ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateIndirectExecutionSetPipelineEXT && - "Function requires " ); - - getDispatcher()->vkUpdateIndirectExecutionSetPipelineEXT( static_cast( m_device ), - static_cast( m_indirectExecutionSetEXT ), - executionSetWrites.size(), - reinterpret_cast( executionSetWrites.data() ) ); - } - - // wrapper function for command vkUpdateIndirectExecutionSetShaderEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkUpdateIndirectExecutionSetShaderEXT.html - VULKAN_HPP_INLINE void - IndirectExecutionSetEXT::updateShader( ArrayProxy const & executionSetWrites ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkUpdateIndirectExecutionSetShaderEXT && - "Function requires " ); - - getDispatcher()->vkUpdateIndirectExecutionSetShaderEXT( static_cast( m_device ), - static_cast( m_indirectExecutionSetEXT ), - executionSetWrites.size(), - reinterpret_cast( executionSetWrites.data() ) ); - } - -# if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - - // wrapper function for command vkCreateSurfaceOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateSurfaceOHOS.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Instance::createSurfaceOHOS( SurfaceCreateInfoOHOS const & createInfo, - Optional allocator ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCreateSurfaceOHOS && "Function requires " ); - - VULKAN_HPP_NAMESPACE::SurfaceKHR surface; - Result result = static_cast( getDispatcher()->vkCreateSurfaceOHOS( static_cast( m_instance ), - reinterpret_cast( &createInfo ), - reinterpret_cast( allocator.get() ), - reinterpret_cast( &surface ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Instance::createSurfaceOHOS" ); - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, SurfaceKHR( *this, *reinterpret_cast( &surface ), allocator ) ); - } -# endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_NV_cooperative_matrix2 === - - // wrapper function for command vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type - PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV() const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV && - "Function requires " ); - - std::vector properties; - uint32_t propertyCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( - static_cast( m_physicalDevice ), &propertyCount, nullptr ) ); - if ( ( result == Result::eSuccess ) && propertyCount ) - { - properties.resize( propertyCount ); - result = static_cast( getDispatcher()->vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV( - static_cast( m_physicalDevice ), - &propertyCount, - reinterpret_cast( properties.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::getCooperativeMatrixFlexibleDimensionsPropertiesNV" ); - VULKAN_HPP_ASSERT( propertyCount <= properties.size() ); - if ( propertyCount < properties.size() ) - { - properties.resize( propertyCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( properties ) ); - } - -# if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_external_memory_metal === - - // wrapper function for command vkGetMemoryMetalHandleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandleEXT.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryMetalHandleEXT( const MemoryGetMetalHandleInfoEXT & getMetalHandleInfo ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryMetalHandleEXT && "Function requires " ); - - void * handle; - Result result = static_cast( getDispatcher()->vkGetMemoryMetalHandleEXT( - static_cast( m_device ), reinterpret_cast( &getMetalHandleInfo ), &handle ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryMetalHandleEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( handle ) ); - } - - // wrapper function for command vkGetMemoryMetalHandlePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetMemoryMetalHandlePropertiesEXT.html - template - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type - Device::getMemoryMetalHandlePropertiesEXT( ExternalMemoryHandleTypeFlagBits handleType, HandleType const & handle ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryMetalHandlePropertiesEXT && - "Function requires " ); - - MemoryMetalHandlePropertiesEXT memoryMetalHandleProperties; - Result result = static_cast( - getDispatcher()->vkGetMemoryMetalHandlePropertiesEXT( static_cast( m_device ), - static_cast( handleType ), - reinterpret_cast( &handle ), - reinterpret_cast( &memoryMetalHandleProperties ) ) ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_RAII_NAMESPACE_STRING "::Device::getMemoryMetalHandlePropertiesEXT" ); - - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( memoryMetalHandleProperties ) ); - } -# endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_ARM_performance_counters_by_region === - - // wrapper function for command vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM.html - VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE - typename ResultValueType, std::vector>>::type - PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM( uint32_t queueFamilyIndex ) const - { - VULKAN_HPP_ASSERT( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM && - "Function requires " ); - - std::pair, std::vector> data_; - std::vector & counters = data_.first; - std::vector & counterDescriptions = data_.second; - uint32_t counterCount; - Result result; - do - { - result = static_cast( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( - static_cast( m_physicalDevice ), queueFamilyIndex, &counterCount, nullptr, nullptr ) ); - if ( ( result == Result::eSuccess ) && counterCount ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - result = static_cast( getDispatcher()->vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM( - static_cast( m_physicalDevice ), - queueFamilyIndex, - &counterCount, - reinterpret_cast( counters.data() ), - reinterpret_cast( counterDescriptions.data() ) ) ); - } - } while ( result == Result::eIncomplete ); - VULKAN_HPP_NAMESPACE::detail::resultCheck( result, - VULKAN_HPP_RAII_NAMESPACE_STRING "::PhysicalDevice::enumerateQueueFamilyPerformanceCountersByRegionARM" ); - VULKAN_HPP_ASSERT( counterCount <= counters.size() ); - if ( counterCount < counters.size() ) - { - counters.resize( counterCount ); - counterDescriptions.resize( counterCount ); - } - return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( data_ ) ); - } - - //=== VK_EXT_fragment_density_map_offset === - - // wrapper function for command vkCmdEndRendering2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2EXT.html - VULKAN_HPP_INLINE void CommandBuffer::endRendering2EXT( Optional renderingEndInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRendering2EXT && - "Function requires or " ); - - getDispatcher()->vkCmdEndRendering2EXT( static_cast( m_commandBuffer ), - reinterpret_cast( renderingEndInfo.get() ) ); - } - - //=== VK_EXT_custom_resolve === - - // wrapper function for command vkCmdBeginCustomResolveEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginCustomResolveEXT.html - VULKAN_HPP_INLINE void CommandBuffer::beginCustomResolveEXT( Optional beginCustomResolveInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginCustomResolveEXT && "Function requires " ); - - getDispatcher()->vkCmdBeginCustomResolveEXT( static_cast( m_commandBuffer ), - reinterpret_cast( beginCustomResolveInfo.get() ) ); - } - - //=== VK_KHR_maintenance10 === - - // wrapper function for command vkCmdEndRendering2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndRendering2KHR.html - VULKAN_HPP_INLINE void CommandBuffer::endRendering2KHR( Optional renderingEndInfo ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndRendering2KHR && - "Function requires or " ); - - getDispatcher()->vkCmdEndRendering2KHR( static_cast( m_commandBuffer ), - reinterpret_cast( renderingEndInfo.get() ) ); - } - - //=== VK_NV_compute_occupancy_priority === - - // wrapper function for command vkCmdSetComputeOccupancyPriorityNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetComputeOccupancyPriorityNV.html - VULKAN_HPP_INLINE void CommandBuffer::setComputeOccupancyPriorityNV( const ComputeOccupancyPriorityParametersNV & parameters ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetComputeOccupancyPriorityNV && - "Function requires " ); - - getDispatcher()->vkCmdSetComputeOccupancyPriorityNV( static_cast( m_commandBuffer ), - reinterpret_cast( ¶meters ) ); - } - - //==================== - //=== RAII Helpers === - //==================== - - template - std::vector filterCppTypes( std::vector const & raiiTypes ) - { - std::vector cppTypes( raiiTypes.size() ); - std::transform( raiiTypes.begin(), raiiTypes.end(), cppTypes.begin(), []( RAIIType const & d ) { return *d; } ); - return cppTypes; - } - - template - std::vector filterCppTypes( std::vector const & raiiTypes, UnaryPredicate p ) - { - std::vector cppTypes; - for ( auto const & t : raiiTypes ) - { - if ( p( t ) ) - { - cppTypes.push_back( *t ); - } - } - return cppTypes; - } - - } // namespace VULKAN_HPP_RAII_NAMESPACE -} // namespace VULKAN_HPP_NAMESPACE -#endif -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_screen.h b/lib/vulkan-headers/include/vulkan/vulkan_screen.h deleted file mode 100644 index 15e9d09028f..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_screen.h +++ /dev/null @@ -1,114 +0,0 @@ -#ifndef VULKAN_SCREEN_H_ -#define VULKAN_SCREEN_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_QNX_screen_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_QNX_screen_surface 1 -#define VK_QNX_SCREEN_SURFACE_SPEC_VERSION 1 -#define VK_QNX_SCREEN_SURFACE_EXTENSION_NAME "VK_QNX_screen_surface" -typedef VkFlags VkScreenSurfaceCreateFlagsQNX; -typedef struct VkScreenSurfaceCreateInfoQNX { - VkStructureType sType; - const void* pNext; - VkScreenSurfaceCreateFlagsQNX flags; - struct _screen_context* context; - struct _screen_window* window; -} VkScreenSurfaceCreateInfoQNX; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateScreenSurfaceQNX)(VkInstance instance, const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateScreenSurfaceQNX( - VkInstance instance, - const VkScreenSurfaceCreateInfoQNX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceScreenPresentationSupportQNX( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct _screen_window* window); -#endif -#endif - - -// VK_QNX_external_memory_screen_buffer is a preprocessor guard. Do not pass it to API calls. -#define VK_QNX_external_memory_screen_buffer 1 -#define VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_SPEC_VERSION 1 -#define VK_QNX_EXTERNAL_MEMORY_SCREEN_BUFFER_EXTENSION_NAME "VK_QNX_external_memory_screen_buffer" -typedef struct VkScreenBufferPropertiesQNX { - VkStructureType sType; - void* pNext; - VkDeviceSize allocationSize; - uint32_t memoryTypeBits; -} VkScreenBufferPropertiesQNX; - -typedef struct VkScreenBufferFormatPropertiesQNX { - VkStructureType sType; - void* pNext; - VkFormat format; - uint64_t externalFormat; - uint64_t screenUsage; - VkFormatFeatureFlags formatFeatures; - VkComponentMapping samplerYcbcrConversionComponents; - VkSamplerYcbcrModelConversion suggestedYcbcrModel; - VkSamplerYcbcrRange suggestedYcbcrRange; - VkChromaLocation suggestedXChromaOffset; - VkChromaLocation suggestedYChromaOffset; -} VkScreenBufferFormatPropertiesQNX; - -typedef struct VkImportScreenBufferInfoQNX { - VkStructureType sType; - const void* pNext; - struct _screen_buffer* buffer; -} VkImportScreenBufferInfoQNX; - -typedef struct VkExternalFormatQNX { - VkStructureType sType; - void* pNext; - uint64_t externalFormat; -} VkExternalFormatQNX; - -typedef struct VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX { - VkStructureType sType; - void* pNext; - VkBool32 screenBufferImport; -} VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; - -typedef VkResult (VKAPI_PTR *PFN_vkGetScreenBufferPropertiesQNX)(VkDevice device, const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetScreenBufferPropertiesQNX( - VkDevice device, - const struct _screen_buffer* buffer, - VkScreenBufferPropertiesQNX* pProperties); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_shared.hpp b/lib/vulkan-headers/include/vulkan/vulkan_shared.hpp deleted file mode 100644 index 9fe99de2365..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_shared.hpp +++ /dev/null @@ -1,1197 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_SHARED_HPP -#define VULKAN_SHARED_HPP - -#include - -#if !defined( VULKAN_HPP_CXX_MODULE ) -# include // std::atomic_size_t -#endif - -namespace VULKAN_HPP_NAMESPACE -{ -#if !defined( VULKAN_HPP_NO_SMART_HANDLE ) - template - class SharedHandleTraits; - - class NoDestructor - { - }; - - template - struct HasDestructorType : std::false_type - { - }; - - template - struct HasDestructorType::DestructorType() )> : std::true_type - { - }; - - template - struct GetDestructorType - { - using type = NoDestructor; - }; - - template - struct GetDestructorType::value>::type> - { - using type = typename SharedHandleTraits::DestructorType; - }; - - template - using DestructorTypeOf = typename GetDestructorType::type; - - template - struct HasDestructor : std::integral_constant, NoDestructor>::value> - { - }; - - template - struct HasPoolType : std::false_type - { - }; - - template - struct HasPoolType::deleter::PoolTypeExport() )> : std::true_type - { - }; - - template - struct GetPoolType - { - using type = NoDestructor; - }; - - template - struct GetPoolType::value>::type> - { - using type = typename SharedHandleTraits::deleter::PoolTypeExport; - }; - - //===================================================================================================================== - - template - class SharedHandle; - - template - struct SharedHeader - { - SharedHeader( SharedHandle parent, Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT - : parent( std::move( parent ) ) - , deleter( std::move( deleter ) ) - { - } - - SharedHandle parent; - Deleter deleter; - }; - - template - struct SharedHeader - { - SharedHeader( Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {} - - Deleter deleter; - }; - - //===================================================================================================================== - - template - class ReferenceCounter - { - public: - template - ReferenceCounter( Args &&... control_args ) : m_header( std::forward( control_args )... ) - { - } - - ReferenceCounter( const ReferenceCounter & ) = delete; - ReferenceCounter & operator=( const ReferenceCounter & ) = delete; - - public: - size_t addRef() VULKAN_HPP_NOEXCEPT - { - // Relaxed memory order is sufficient since this does not impose any ordering on other operations - return m_ref_cnt.fetch_add( 1, std::memory_order_relaxed ); - } - - size_t release() VULKAN_HPP_NOEXCEPT - { - // A release memory order to ensure that all releases are ordered - return m_ref_cnt.fetch_sub( 1, std::memory_order_release ); - } - - public: - std::atomic_size_t m_ref_cnt{ 1 }; - HeaderType m_header; - }; - - //===================================================================================================================== - - template > - class SharedHandleBase - { - public: - SharedHandleBase() = default; - - template - SharedHandleBase( HandleType handle, Args &&... control_args ) - : m_control( new ReferenceCounter( std::forward( control_args )... ) ), m_handle( handle ) - { - } - - SharedHandleBase( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT - { - o.addRef(); - m_handle = o.m_handle; - m_control = o.m_control; - } - - SharedHandleBase( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT - : m_control( o.m_control ) - , m_handle( o.m_handle ) - { - o.m_handle = nullptr; - o.m_control = nullptr; - } - - SharedHandleBase & operator=( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT - { - SharedHandleBase( o ).swap( *this ); - return *this; - } - - SharedHandleBase & operator=( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT - { - SharedHandleBase( std::move( o ) ).swap( *this ); - return *this; - } - - ~SharedHandleBase() - { - // only this function owns the last reference to the control block - // the same principle is used in the default deleter of std::shared_ptr - if ( m_control && ( m_control->release() == 1 ) ) - { - // noop in x86, but does thread synchronization in ARM - // it is required to ensure that last thread is getting to destroy the control block - // by ordering all atomic operations before this fence - std::atomic_thread_fence( std::memory_order_acquire ); - ForwardType::internalDestroy( getHeader(), m_handle ); - delete m_control; - } - } - - public: - HandleType get() const VULKAN_HPP_NOEXCEPT - { - return m_handle; - } - - HandleType operator*() const VULKAN_HPP_NOEXCEPT - { - return m_handle; - } - - explicit operator bool() const VULKAN_HPP_NOEXCEPT - { - return bool( m_handle ); - } - -# if defined( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST ) - operator HandleType() const VULKAN_HPP_NOEXCEPT - { - return m_handle; - } -# endif - - const HandleType * operator->() const VULKAN_HPP_NOEXCEPT - { - return &m_handle; - } - - HandleType * operator->() VULKAN_HPP_NOEXCEPT - { - return &m_handle; - } - - void reset() VULKAN_HPP_NOEXCEPT - { - SharedHandleBase().swap( *this ); - } - - void swap( SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT - { - std::swap( m_handle, o.m_handle ); - std::swap( m_control, o.m_control ); - } - - template - typename std::enable_if::value, const SharedHandle> &>::type getDestructorType() const VULKAN_HPP_NOEXCEPT - { - return getHeader().parent; - } - - protected: - template - static typename std::enable_if::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT - { - control.deleter.destroy( handle ); - } - - template - static typename std::enable_if::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT - { - control.deleter.destroy( control.parent.get(), handle ); - } - - const HeaderType & getHeader() const VULKAN_HPP_NOEXCEPT - { - return m_control->m_header; - } - - private: - void addRef() const VULKAN_HPP_NOEXCEPT - { - if ( m_control ) - m_control->addRef(); - } - - protected: - ReferenceCounter * m_control = nullptr; - HandleType m_handle{}; - }; - - template - class SharedHandle : public SharedHandleBase, typename SharedHandleTraits::deleter>> - { - private: - using BaseType = SharedHandleBase, typename SharedHandleTraits::deleter>>; - using DeleterType = typename SharedHandleTraits::deleter; - friend BaseType; - - public: - SharedHandle() = default; - - template ::value && !HasPoolType::value>::type> - explicit SharedHandle( HandleType handle, - SharedHandle> parent, - DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT - : BaseType( handle, std::move( parent ), std::move( deleter ) ) - { - } - - template ::value && HasPoolType::value>::type> - explicit SharedHandle( HandleType handle, - SharedHandle> parent, - SharedHandle::type> pool, - const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT - : BaseType( handle, std::move( parent ), DeleterType{ std::move( pool ), dispatch } ) - { - } - - template ::value>::type> - explicit SharedHandle( HandleType handle, DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT - : BaseType( handle, std::move( deleter ) ) - { - } - - protected: - using BaseType::internalDestroy; - }; - - namespace detail - { -// Silence the function cast warnings. -# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER ) -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wcast-function-type" -# elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER ) -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wcast-function-type" -# endif - - template - class ObjectDestroyShared - { - public: - using DestructorType = typename SharedHandleTraits::DestructorType; - - using DestroyFunctionPointerType = - typename std::conditional::value, - void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const, - void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type; - - using SelectorType = typename std::conditional::value, DestructorType, HandleType>::type; - - ObjectDestroyShared( Optional allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) - : m_destroy( reinterpret_cast( static_cast( &SelectorType::destroy ) ) ) - , m_dispatch( &dispatch ) - , m_allocationCallbacks( allocationCallbacks ) - { - } - - public: - template - typename std::enable_if::value, void>::type destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_destroy && m_dispatch ); - ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch ); - } - - template - typename std::enable_if::value, void>::type destroy( HandleType handle ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_destroy && m_dispatch ); - ( handle.*m_destroy )( m_allocationCallbacks, *m_dispatch ); - } - - private: - DestroyFunctionPointerType m_destroy = nullptr; - const Dispatcher * m_dispatch = nullptr; - Optional m_allocationCallbacks = nullptr; - }; - - template - class ObjectFreeShared - { - public: - using DestructorType = typename SharedHandleTraits::DestructorType; - - using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const; - - ObjectFreeShared( Optional allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ), - const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) - : m_destroy( reinterpret_cast( static_cast( &DestructorType::free ) ) ) - , m_dispatch( &dispatch ) - , m_allocationCallbacks( allocationCallbacks ) - { - } - - public: - void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_destroy && m_dispatch ); - ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch ); - } - - private: - DestroyFunctionPointerType m_destroy = nullptr; - const Dispatcher * m_dispatch = nullptr; - Optional m_allocationCallbacks = nullptr; - }; - - template - class ObjectReleaseShared - { - public: - using DestructorType = typename SharedHandleTraits::DestructorType; - - using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const; - - ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) - : m_destroy( reinterpret_cast( static_cast( &DestructorType::release ) ) ), m_dispatch( &dispatch ) - { - } - - public: - void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_destroy && m_dispatch ); - ( parent.*m_destroy )( handle, *m_dispatch ); - } - - private: - DestroyFunctionPointerType m_destroy = nullptr; - const Dispatcher * m_dispatch = nullptr; - }; - - template - class PoolFreeShared - { - public: - using DestructorType = typename SharedHandleTraits::DestructorType; - - using PoolTypeExport = PoolType; - - using ReturnType = decltype( std::declval().free( PoolType(), 0u, nullptr, Dispatcher() ) ); - - using DestroyFunctionPointerType = ReturnType ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const; - - PoolFreeShared() = default; - - PoolFreeShared( SharedHandle pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) - : m_destroy( reinterpret_cast( static_cast( &DestructorType::free ) ) ) - , m_dispatch( &dispatch ) - , m_pool( std::move( pool ) ) - { - } - - public: - void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( m_destroy && m_dispatch && m_pool ); - ( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch ); - } - - private: - DestroyFunctionPointerType m_destroy = nullptr; - const Dispatcher * m_dispatch = nullptr; - SharedHandle m_pool{}; - }; - -# if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER ) -# pragma GCC diagnostic pop -# elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER ) -# pragma clang diagnostic pop -# endif - } // namespace detail - - //====================== - //=== SHARED HANDLEs === - //====================== - - //=== VK_VERSION_1_0 === - template <> - class SharedHandleTraits - { - public: - using DestructorType = NoDestructor; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedInstance = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = NoDestructor; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedDevice = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectFreeShared; - }; - - using SharedDeviceMemory = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedFence = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedSemaphore = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedQueryPool = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedBuffer = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedImage = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedImageView = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedCommandPool = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::PoolFreeShared; - }; - - using SharedCommandBuffer = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedEvent = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedBufferView = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedShaderModule = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedPipelineCache = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedPipeline = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedPipelineLayout = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedSampler = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedDescriptorPool = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::PoolFreeShared; - }; - - using SharedDescriptorSet = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedDescriptorSetLayout = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedFramebuffer = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedRenderPass = SharedHandle; - - //=== VK_VERSION_1_1 === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedDescriptorUpdateTemplate = SharedHandle; - using SharedDescriptorUpdateTemplateKHR = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedSamplerYcbcrConversion = SharedHandle; - using SharedSamplerYcbcrConversionKHR = SharedHandle; - - //=== VK_VERSION_1_3 === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedPrivateDataSlot = SharedHandle; - using SharedPrivateDataSlotEXT = SharedHandle; - - //=== VK_KHR_surface === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Instance; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedSurfaceKHR = SharedHandle; - - //=== VK_KHR_swapchain === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedSwapchainKHR = SharedHandle; - - //=== VK_KHR_display === - template <> - class SharedHandleTraits - { - public: - using DestructorType = PhysicalDevice; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedDisplayKHR = SharedHandle; - - //=== VK_EXT_debug_report === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Instance; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedDebugReportCallbackEXT = SharedHandle; - - //=== VK_KHR_video_queue === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedVideoSessionKHR = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedVideoSessionParametersKHR = SharedHandle; - - //=== VK_NVX_binary_import === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedCuModuleNVX = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedCuFunctionNVX = SharedHandle; - - //=== VK_EXT_debug_utils === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Instance; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedDebugUtilsMessengerEXT = SharedHandle; - - //=== VK_EXT_descriptor_heap === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedTensorARM = SharedHandle; - - //=== VK_KHR_acceleration_structure === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedAccelerationStructureKHR = SharedHandle; - - //=== VK_EXT_validation_cache === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedValidationCacheEXT = SharedHandle; - - //=== VK_NV_ray_tracing === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedAccelerationStructureNV = SharedHandle; - - //=== VK_INTEL_performance_query === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedPerformanceConfigurationINTEL = SharedHandle; - - //=== VK_KHR_deferred_host_operations === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedDeferredOperationKHR = SharedHandle; - - //=== VK_NV_device_generated_commands === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedIndirectCommandsLayoutNV = SharedHandle; - -# if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_cuda_kernel_launch === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedCudaModuleNV = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedCudaFunctionNV = SharedHandle; -# endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -# if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedBufferCollectionFUCHSIA = SharedHandle; -# endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_EXT_opacity_micromap === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedMicromapEXT = SharedHandle; - - //=== VK_ARM_tensors === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedTensorViewARM = SharedHandle; - - //=== VK_NV_optical_flow === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedOpticalFlowSessionNV = SharedHandle; - - //=== VK_EXT_shader_object === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedShaderEXT = SharedHandle; - - //=== VK_KHR_pipeline_binary === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedPipelineBinaryKHR = SharedHandle; - - //=== VK_ARM_data_graph === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedDataGraphPipelineSessionARM = SharedHandle; - - //=== VK_NV_external_compute_queue === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedExternalComputeQueueNV = SharedHandle; - - //=== VK_EXT_device_generated_commands === - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedIndirectCommandsLayoutEXT = SharedHandle; - - template <> - class SharedHandleTraits - { - public: - using DestructorType = Device; - using deleter = detail::ObjectDestroyShared; - }; - - using SharedIndirectExecutionSetEXT = SharedHandle; - - // a number of SharedHandle specializations - enum class SwapchainOwns - { - no, - yes, - }; - - struct ImageHeader : SharedHeader, typename SharedHandleTraits::deleter> - { - ImageHeader( SharedHandle> parent, - typename SharedHandleTraits::deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits::deleter() ), - SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT - : SharedHeader, typename SharedHandleTraits::deleter>( std::move( parent ), std::move( deleter ) ) - , swapchainOwned( swapchainOwned ) - { - } - - SwapchainOwns swapchainOwned = SwapchainOwns::no; - }; - - template <> - class SharedHandle : public SharedHandleBase - { - using BaseType = SharedHandleBase; - using DeleterType = typename SharedHandleTraits::deleter; - friend BaseType; - - public: - SharedHandle() = default; - - explicit SharedHandle( Image handle, - SharedHandle> parent, - SwapchainOwns swapchain_owned VULKAN_HPP_DEFAULT_ASSIGNMENT( SwapchainOwns::no ), - DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT - : BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned ) - { - } - - protected: - static void internalDestroy( const ImageHeader & control, Image handle ) VULKAN_HPP_NOEXCEPT - { - if ( control.swapchainOwned == SwapchainOwns::no ) - { - control.deleter.destroy( control.parent.get(), handle ); - } - } - }; - - struct SwapchainHeader - { - SwapchainHeader( SharedHandle surface, - SharedHandle> parent, - typename SharedHandleTraits::deleter deleter - VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits::deleter() ) ) VULKAN_HPP_NOEXCEPT - : surface( std::move( surface ) ) - , parent( std::move( parent ) ) - , deleter( std::move( deleter ) ) - { - } - - SharedHandle surface; - SharedHandle> parent; - typename SharedHandleTraits::deleter deleter; - }; - - template <> - class SharedHandle : public SharedHandleBase - { - using BaseType = SharedHandleBase; - using DeleterType = typename SharedHandleTraits::deleter; - friend BaseType; - - public: - SharedHandle() = default; - - explicit SharedHandle( SwapchainKHR handle, - SharedHandle> parent, - SharedHandle surface, - DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT - : BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) ) - { - } - - public: - const SharedHandle & getSurface() const VULKAN_HPP_NOEXCEPT - { - return getHeader().surface; - } - - protected: - using BaseType::internalDestroy; - }; - - template - class SharedHandleBaseNoDestroy : public SharedHandleBase - { - public: - using SharedHandleBase::SharedHandleBase; - - const DestructorType & getDestructorType() const VULKAN_HPP_NOEXCEPT - { - return SharedHandleBase::getHeader(); - } - - protected: - static void internalDestroy( const DestructorType &, HandleType ) VULKAN_HPP_NOEXCEPT {} - }; - - //=== VK_VERSION_1_0 === - - template <> - class SharedHandle : public SharedHandleBaseNoDestroy - { - friend SharedHandleBase; - - public: - SharedHandle() = default; - - explicit SharedHandle( PhysicalDevice handle, SharedInstance parent ) noexcept - : SharedHandleBaseNoDestroy( handle, std::move( parent ) ) - { - } - }; - - using SharedPhysicalDevice = SharedHandle; - - template <> - class SharedHandle : public SharedHandleBaseNoDestroy - { - friend SharedHandleBase; - - public: - SharedHandle() = default; - - explicit SharedHandle( Queue handle, SharedDevice parent ) noexcept : SharedHandleBaseNoDestroy( handle, std::move( parent ) ) {} - }; - - using SharedQueue = SharedHandle; - - //=== VK_KHR_display === - - template <> - class SharedHandle : public SharedHandleBaseNoDestroy - { - friend SharedHandleBase; - - public: - SharedHandle() = default; - - explicit SharedHandle( DisplayModeKHR handle, SharedDisplayKHR parent ) noexcept - : SharedHandleBaseNoDestroy( handle, std::move( parent ) ) - { - } - }; - - using SharedDisplayModeKHR = SharedHandle; -#endif // !VULKAN_HPP_NO_SMART_HANDLE -} // namespace VULKAN_HPP_NAMESPACE -#endif // VULKAN_SHARED_HPP diff --git a/lib/vulkan-headers/include/vulkan/vulkan_static_assertions.hpp b/lib/vulkan-headers/include/vulkan/vulkan_static_assertions.hpp deleted file mode 100644 index 62992e01fbd..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_static_assertions.hpp +++ /dev/null @@ -1,9861 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_STATIC_ASSERTIONS_HPP -#define VULKAN_STATIC_ASSERTIONS_HPP - -#include - -//========================= -//=== static_assertions === -//========================= - -//=== VK_VERSION_1_0 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Instance ) == sizeof( VkInstance ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Instance is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Instance is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice ) == sizeof( VkPhysicalDevice ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "PhysicalDevice is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevice is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Device ) == sizeof( VkDevice ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Device is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Device is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Queue ) == sizeof( VkQueue ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Queue is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Queue is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemory ) == sizeof( VkDeviceMemory ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DeviceMemory is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DeviceMemory is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Fence ) == sizeof( VkFence ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Fence is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Fence is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Semaphore ) == sizeof( VkSemaphore ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Semaphore is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Semaphore is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPool ) == sizeof( VkQueryPool ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "QueryPool is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "QueryPool is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Buffer ) == sizeof( VkBuffer ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Buffer is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Buffer is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Image ) == sizeof( VkImage ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Image is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Image is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageView ) == sizeof( VkImageView ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "ImageView is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageView is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandPool ) == sizeof( VkCommandPool ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CommandPool is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CommandPool is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBuffer ) == sizeof( VkCommandBuffer ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CommandBuffer is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CommandBuffer is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Event ) == sizeof( VkEvent ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Event is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Event is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferView ) == sizeof( VkBufferView ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "BufferView is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "BufferView is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModule ) == sizeof( VkShaderModule ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "ShaderModule is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ShaderModule is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCache ) == sizeof( VkPipelineCache ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "PipelineCache is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PipelineCache is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Pipeline ) == sizeof( VkPipeline ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Pipeline is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Pipeline is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayout ) == sizeof( VkPipelineLayout ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "PipelineLayout is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineLayout is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Sampler ) == sizeof( VkSampler ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Sampler is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Sampler is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPool ) == sizeof( VkDescriptorPool ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DescriptorPool is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorPool is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSet ) == sizeof( VkDescriptorSet ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DescriptorSet is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DescriptorSet is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayout ) == sizeof( VkDescriptorSetLayout ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DescriptorSetLayout is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorSetLayout is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Framebuffer ) == sizeof( VkFramebuffer ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "Framebuffer is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Framebuffer is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPass ) == sizeof( VkRenderPass ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "RenderPass is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "RenderPass is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Extent2D ) == sizeof( VkExtent2D ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Extent2D is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Extent3D ) == sizeof( VkExtent3D ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Extent3D is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Offset2D ) == sizeof( VkOffset2D ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Offset2D is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Offset3D ) == sizeof( VkOffset3D ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Offset3D is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Rect2D ) == sizeof( VkRect2D ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Rect2D is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BaseInStructure ) == sizeof( VkBaseInStructure ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BaseInStructure is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BaseOutStructure ) == sizeof( VkBaseOutStructure ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BaseOutStructure is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier ) == sizeof( VkBufferMemoryBarrier ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferMemoryBarrier is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier ) == sizeof( VkImageMemoryBarrier ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageMemoryBarrier is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryBarrier ) == sizeof( VkMemoryBarrier ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MemoryBarrier is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AllocationCallbacks ) == sizeof( VkAllocationCallbacks ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AllocationCallbacks is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ApplicationInfo ) == sizeof( VkApplicationInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ApplicationInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FormatProperties ) == sizeof( VkFormatProperties ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FormatProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageFormatProperties ) == sizeof( VkImageFormatProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageFormatProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::InstanceCreateInfo ) == sizeof( VkInstanceCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "InstanceCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryHeap ) == sizeof( VkMemoryHeap ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MemoryHeap is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryType ) == sizeof( VkMemoryType ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MemoryType is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures ) == sizeof( VkPhysicalDeviceFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLimits ) == sizeof( VkPhysicalDeviceLimits ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceLimits is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties ) == sizeof( VkPhysicalDeviceMemoryProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMemoryProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties ) == sizeof( VkPhysicalDeviceProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseProperties ) == sizeof( VkPhysicalDeviceSparseProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSparseProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyProperties ) == sizeof( VkQueueFamilyProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueueFamilyProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceCreateInfo ) == sizeof( VkDeviceCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceQueueCreateInfo ) == sizeof( VkDeviceQueueCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceQueueCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExtensionProperties ) == sizeof( VkExtensionProperties ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExtensionProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LayerProperties ) == sizeof( VkLayerProperties ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "LayerProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubmitInfo ) == sizeof( VkSubmitInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SubmitInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MappedMemoryRange ) == sizeof( VkMappedMemoryRange ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MappedMemoryRange is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryAllocateInfo ) == sizeof( VkMemoryAllocateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryAllocateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryRequirements ) == sizeof( VkMemoryRequirements ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryRequirements is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindSparseInfo ) == sizeof( VkBindSparseInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindSparseInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSubresource ) == sizeof( VkImageSubresource ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageSubresource is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseBufferMemoryBindInfo ) == sizeof( VkSparseBufferMemoryBindInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SparseBufferMemoryBindInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties ) == sizeof( VkSparseImageFormatProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SparseImageFormatProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageMemoryBind ) == sizeof( VkSparseImageMemoryBind ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SparseImageMemoryBind is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageMemoryBindInfo ) == sizeof( VkSparseImageMemoryBindInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SparseImageMemoryBindInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements ) == sizeof( VkSparseImageMemoryRequirements ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SparseImageMemoryRequirements is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageOpaqueMemoryBindInfo ) == sizeof( VkSparseImageOpaqueMemoryBindInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SparseImageOpaqueMemoryBindInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseMemoryBind ) == sizeof( VkSparseMemoryBind ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SparseMemoryBind is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FenceCreateInfo ) == sizeof( VkFenceCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FenceCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreCreateInfo ) == sizeof( VkSemaphoreCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SemaphoreCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPoolCreateInfo ) == sizeof( VkQueryPoolCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueryPoolCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCreateInfo ) == sizeof( VkBufferCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCreateInfo ) == sizeof( VkImageCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubresourceLayout ) == sizeof( VkSubresourceLayout ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubresourceLayout is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ComponentMapping ) == sizeof( VkComponentMapping ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ComponentMapping is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSubresourceRange ) == sizeof( VkImageSubresourceRange ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageSubresourceRange is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewCreateInfo ) == sizeof( VkImageViewCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageViewCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandPoolCreateInfo ) == sizeof( VkCommandPoolCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CommandPoolCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferAllocateInfo ) == sizeof( VkCommandBufferAllocateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CommandBufferAllocateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferBeginInfo ) == sizeof( VkCommandBufferBeginInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CommandBufferBeginInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceInfo ) == sizeof( VkCommandBufferInheritanceInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CommandBufferInheritanceInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCopy ) == sizeof( VkBufferCopy ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "BufferCopy is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferImageCopy ) == sizeof( VkBufferImageCopy ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferImageCopy is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCopy ) == sizeof( VkImageCopy ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageCopy is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSubresourceLayers ) == sizeof( VkImageSubresourceLayers ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageSubresourceLayers is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchIndirectCommand ) == sizeof( VkDispatchIndirectCommand ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DispatchIndirectCommand is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionOne ) == sizeof( VkPipelineCacheHeaderVersionOne ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineCacheHeaderVersionOne is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::EventCreateInfo ) == sizeof( VkEventCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "EventCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferViewCreateInfo ) == sizeof( VkBufferViewCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferViewCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModuleCreateInfo ) == sizeof( VkShaderModuleCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ShaderModuleCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCacheCreateInfo ) == sizeof( VkPipelineCacheCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineCacheCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ComputePipelineCreateInfo ) == sizeof( VkComputePipelineCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ComputePipelineCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineShaderStageCreateInfo ) == sizeof( VkPipelineShaderStageCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineShaderStageCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SpecializationInfo ) == sizeof( VkSpecializationInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SpecializationInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SpecializationMapEntry ) == sizeof( VkSpecializationMapEntry ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SpecializationMapEntry is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineLayoutCreateInfo ) == sizeof( VkPipelineLayoutCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineLayoutCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushConstantRange ) == sizeof( VkPushConstantRange ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PushConstantRange is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCreateInfo ) == sizeof( VkSamplerCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyDescriptorSet ) == sizeof( VkCopyDescriptorSet ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyDescriptorSet is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorBufferInfo ) == sizeof( VkDescriptorBufferInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorBufferInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorImageInfo ) == sizeof( VkDescriptorImageInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorImageInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPoolCreateInfo ) == sizeof( VkDescriptorPoolCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorPoolCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPoolSize ) == sizeof( VkDescriptorPoolSize ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorPoolSize is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetAllocateInfo ) == sizeof( VkDescriptorSetAllocateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorSetAllocateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBinding ) == sizeof( VkDescriptorSetLayoutBinding ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorSetLayoutBinding is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutCreateInfo ) == sizeof( VkDescriptorSetLayoutCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorSetLayoutCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSet ) == sizeof( VkWriteDescriptorSet ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "WriteDescriptorSet is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClearColorValue ) == sizeof( VkClearColorValue ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClearColorValue is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawIndexedIndirectCommand ) == sizeof( VkDrawIndexedIndirectCommand ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DrawIndexedIndirectCommand is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawIndirectCommand ) == sizeof( VkDrawIndirectCommand ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DrawIndirectCommand is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GraphicsPipelineCreateInfo ) == sizeof( VkGraphicsPipelineCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GraphicsPipelineCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineColorBlendAttachmentState ) == sizeof( VkPipelineColorBlendAttachmentState ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineColorBlendAttachmentState is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineColorBlendStateCreateInfo ) == sizeof( VkPipelineColorBlendStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineColorBlendStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineDepthStencilStateCreateInfo ) == sizeof( VkPipelineDepthStencilStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineDepthStencilStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineDynamicStateCreateInfo ) == sizeof( VkPipelineDynamicStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineDynamicStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineInputAssemblyStateCreateInfo ) == sizeof( VkPipelineInputAssemblyStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineInputAssemblyStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineMultisampleStateCreateInfo ) == sizeof( VkPipelineMultisampleStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineMultisampleStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateCreateInfo ) == sizeof( VkPipelineRasterizationStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineRasterizationStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineTessellationStateCreateInfo ) == sizeof( VkPipelineTessellationStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineTessellationStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineVertexInputStateCreateInfo ) == sizeof( VkPipelineVertexInputStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineVertexInputStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportStateCreateInfo ) == sizeof( VkPipelineViewportStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineViewportStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StencilOpState ) == sizeof( VkStencilOpState ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "StencilOpState is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription ) == sizeof( VkVertexInputAttributeDescription ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VertexInputAttributeDescription is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription ) == sizeof( VkVertexInputBindingDescription ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VertexInputBindingDescription is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Viewport ) == sizeof( VkViewport ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "Viewport is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentDescription ) == sizeof( VkAttachmentDescription ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AttachmentDescription is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentReference ) == sizeof( VkAttachmentReference ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AttachmentReference is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FramebufferCreateInfo ) == sizeof( VkFramebufferCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FramebufferCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo ) == sizeof( VkRenderPassCreateInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassDependency ) == sizeof( VkSubpassDependency ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubpassDependency is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassDescription ) == sizeof( VkSubpassDescription ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubpassDescription is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClearAttachment ) == sizeof( VkClearAttachment ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClearAttachment is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClearDepthStencilValue ) == sizeof( VkClearDepthStencilValue ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClearDepthStencilValue is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClearRect ) == sizeof( VkClearRect ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ClearRect is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClearValue ) == sizeof( VkClearValue ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ClearValue is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageBlit ) == sizeof( VkImageBlit ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageBlit is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageResolve ) == sizeof( VkImageResolve ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageResolve is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassBeginInfo ) == sizeof( VkRenderPassBeginInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassBeginInfo is not nothrow_move_constructible!" ); - -//=== VK_VERSION_1_1 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplate ) == sizeof( VkDescriptorUpdateTemplate ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "DescriptorUpdateTemplate is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorUpdateTemplate is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion ) == sizeof( VkSamplerYcbcrConversion ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "SamplerYcbcrConversion is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerYcbcrConversion is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindBufferMemoryInfo ) == sizeof( VkBindBufferMemoryInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindBufferMemoryInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindImageMemoryInfo ) == sizeof( VkBindImageMemoryInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindImageMemoryInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryDedicatedRequirements ) == sizeof( VkMemoryDedicatedRequirements ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryDedicatedRequirements is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfo ) == sizeof( VkMemoryDedicatedAllocateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryDedicatedAllocateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryAllocateFlagsInfo ) == sizeof( VkMemoryAllocateFlagsInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryAllocateFlagsInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupCommandBufferBeginInfo ) == sizeof( VkDeviceGroupCommandBufferBeginInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceGroupCommandBufferBeginInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupSubmitInfo ) == sizeof( VkDeviceGroupSubmitInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceGroupSubmitInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupBindSparseInfo ) == sizeof( VkDeviceGroupBindSparseInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceGroupBindSparseInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindBufferMemoryDeviceGroupInfo ) == sizeof( VkBindBufferMemoryDeviceGroupInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindBufferMemoryDeviceGroupInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindImageMemoryDeviceGroupInfo ) == sizeof( VkBindImageMemoryDeviceGroupInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindImageMemoryDeviceGroupInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGroupProperties ) == sizeof( VkPhysicalDeviceGroupProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceGroupProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupDeviceCreateInfo ) == sizeof( VkDeviceGroupDeviceCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceGroupDeviceCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferMemoryRequirementsInfo2 ) == sizeof( VkBufferMemoryRequirementsInfo2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferMemoryRequirementsInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageMemoryRequirementsInfo2 ) == sizeof( VkImageMemoryRequirementsInfo2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageMemoryRequirementsInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSparseMemoryRequirementsInfo2 ) == sizeof( VkImageSparseMemoryRequirementsInfo2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageSparseMemoryRequirementsInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryRequirements2 ) == sizeof( VkMemoryRequirements2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryRequirements2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageMemoryRequirements2 ) == sizeof( VkSparseImageMemoryRequirements2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SparseImageMemoryRequirements2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFeatures2 ) == sizeof( VkPhysicalDeviceFeatures2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFeatures2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProperties2 ) == sizeof( VkPhysicalDeviceProperties2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceProperties2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FormatProperties2 ) == sizeof( VkFormatProperties2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FormatProperties2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageFormatProperties2 ) == sizeof( VkImageFormatProperties2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageFormatProperties2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageFormatInfo2 ) == sizeof( VkPhysicalDeviceImageFormatInfo2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageFormatInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyProperties2 ) == sizeof( VkQueueFamilyProperties2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueueFamilyProperties2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryProperties2 ) == sizeof( VkPhysicalDeviceMemoryProperties2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMemoryProperties2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SparseImageFormatProperties2 ) == sizeof( VkSparseImageFormatProperties2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SparseImageFormatProperties2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSparseImageFormatInfo2 ) == sizeof( VkPhysicalDeviceSparseImageFormatInfo2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSparseImageFormatInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewUsageCreateInfo ) == sizeof( VkImageViewUsageCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageViewUsageCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryFeatures ) == sizeof( VkPhysicalDeviceProtectedMemoryFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceProtectedMemoryFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProtectedMemoryProperties ) == sizeof( VkPhysicalDeviceProtectedMemoryProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceProtectedMemoryProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceQueueInfo2 ) == sizeof( VkDeviceQueueInfo2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceQueueInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ProtectedSubmitInfo ) == sizeof( VkProtectedSubmitInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ProtectedSubmitInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindImagePlaneMemoryInfo ) == sizeof( VkBindImagePlaneMemoryInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindImagePlaneMemoryInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImagePlaneMemoryRequirementsInfo ) == sizeof( VkImagePlaneMemoryRequirementsInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImagePlaneMemoryRequirementsInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryProperties ) == sizeof( VkExternalMemoryProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalMemoryProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalImageFormatInfo ) == sizeof( VkPhysicalDeviceExternalImageFormatInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExternalImageFormatInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalImageFormatProperties ) == sizeof( VkExternalImageFormatProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalImageFormatProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalBufferInfo ) == sizeof( VkPhysicalDeviceExternalBufferInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExternalBufferInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalBufferProperties ) == sizeof( VkExternalBufferProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalBufferProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceIDProperties ) == sizeof( VkPhysicalDeviceIDProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceIDProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfo ) == sizeof( VkExternalMemoryImageCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalMemoryImageCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryBufferCreateInfo ) == sizeof( VkExternalMemoryBufferCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalMemoryBufferCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfo ) == sizeof( VkExportMemoryAllocateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMemoryAllocateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFenceInfo ) == sizeof( VkPhysicalDeviceExternalFenceInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExternalFenceInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalFenceProperties ) == sizeof( VkExternalFenceProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalFenceProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportFenceCreateInfo ) == sizeof( VkExportFenceCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportFenceCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportSemaphoreCreateInfo ) == sizeof( VkExportSemaphoreCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportSemaphoreCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalSemaphoreInfo ) == sizeof( VkPhysicalDeviceExternalSemaphoreInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExternalSemaphoreInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalSemaphoreProperties ) == sizeof( VkExternalSemaphoreProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalSemaphoreProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupProperties ) == sizeof( VkPhysicalDeviceSubgroupProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSubgroupProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice16BitStorageFeatures ) == sizeof( VkPhysicalDevice16BitStorageFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevice16BitStorageFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVariablePointersFeatures ) == sizeof( VkPhysicalDeviceVariablePointersFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVariablePointersFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateEntry ) == sizeof( VkDescriptorUpdateTemplateEntry ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorUpdateTemplateEntry is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorUpdateTemplateCreateInfo ) == sizeof( VkDescriptorUpdateTemplateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorUpdateTemplateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance3Properties ) == sizeof( VkPhysicalDeviceMaintenance3Properties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance3Properties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutSupport ) == sizeof( VkDescriptorSetLayoutSupport ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorSetLayoutSupport is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionCreateInfo ) == sizeof( VkSamplerYcbcrConversionCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerYcbcrConversionCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionInfo ) == sizeof( VkSamplerYcbcrConversionInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerYcbcrConversionInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerYcbcrConversionFeatures ) == - sizeof( VkPhysicalDeviceSamplerYcbcrConversionFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSamplerYcbcrConversionFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionImageFormatProperties ) == - sizeof( VkSamplerYcbcrConversionImageFormatProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerYcbcrConversionImageFormatProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupRenderPassBeginInfo ) == sizeof( VkDeviceGroupRenderPassBeginInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceGroupRenderPassBeginInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePointClippingProperties ) == sizeof( VkPhysicalDevicePointClippingProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePointClippingProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassInputAttachmentAspectCreateInfo ) == sizeof( VkRenderPassInputAttachmentAspectCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassInputAttachmentAspectCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::InputAttachmentAspectReference ) == sizeof( VkInputAttachmentAspectReference ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "InputAttachmentAspectReference is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineTessellationDomainOriginStateCreateInfo ) == - sizeof( VkPipelineTessellationDomainOriginStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineTessellationDomainOriginStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassMultiviewCreateInfo ) == sizeof( VkRenderPassMultiviewCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassMultiviewCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewFeatures ) == sizeof( VkPhysicalDeviceMultiviewFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMultiviewFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewProperties ) == sizeof( VkPhysicalDeviceMultiviewProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMultiviewProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDrawParametersFeatures ) == sizeof( VkPhysicalDeviceShaderDrawParametersFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderDrawParametersFeatures is not nothrow_move_constructible!" ); - -//=== VK_VERSION_1_2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Features ) == sizeof( VkPhysicalDeviceVulkan11Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVulkan11Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan11Properties ) == sizeof( VkPhysicalDeviceVulkan11Properties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVulkan11Properties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Features ) == sizeof( VkPhysicalDeviceVulkan12Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVulkan12Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan12Properties ) == sizeof( VkPhysicalDeviceVulkan12Properties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVulkan12Properties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageFormatListCreateInfo ) == sizeof( VkImageFormatListCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageFormatListCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ConformanceVersion ) == sizeof( VkConformanceVersion ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ConformanceVersion is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDriverProperties ) == sizeof( VkPhysicalDeviceDriverProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDriverProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkanMemoryModelFeatures ) == sizeof( VkPhysicalDeviceVulkanMemoryModelFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVulkanMemoryModelFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostQueryResetFeatures ) == sizeof( VkPhysicalDeviceHostQueryResetFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceHostQueryResetFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreFeatures ) == sizeof( VkPhysicalDeviceTimelineSemaphoreFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTimelineSemaphoreFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTimelineSemaphoreProperties ) == sizeof( VkPhysicalDeviceTimelineSemaphoreProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTimelineSemaphoreProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreTypeCreateInfo ) == sizeof( VkSemaphoreTypeCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SemaphoreTypeCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TimelineSemaphoreSubmitInfo ) == sizeof( VkTimelineSemaphoreSubmitInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TimelineSemaphoreSubmitInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreWaitInfo ) == sizeof( VkSemaphoreWaitInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SemaphoreWaitInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreSignalInfo ) == sizeof( VkSemaphoreSignalInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SemaphoreSignalInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeatures ) == sizeof( VkPhysicalDeviceBufferDeviceAddressFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceBufferDeviceAddressFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferDeviceAddressInfo ) == sizeof( VkBufferDeviceAddressInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferDeviceAddressInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferOpaqueCaptureAddressCreateInfo ) == sizeof( VkBufferOpaqueCaptureAddressCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferOpaqueCaptureAddressCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryOpaqueCaptureAddressAllocateInfo ) == sizeof( VkMemoryOpaqueCaptureAddressAllocateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryOpaqueCaptureAddressAllocateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemoryOpaqueCaptureAddressInfo ) == sizeof( VkDeviceMemoryOpaqueCaptureAddressInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceMemoryOpaqueCaptureAddressInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice8BitStorageFeatures ) == sizeof( VkPhysicalDevice8BitStorageFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevice8BitStorageFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicInt64Features ) == sizeof( VkPhysicalDeviceShaderAtomicInt64Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderAtomicInt64Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat16Int8Features ) == sizeof( VkPhysicalDeviceShaderFloat16Int8Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderFloat16Int8Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFloatControlsProperties ) == sizeof( VkPhysicalDeviceFloatControlsProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFloatControlsProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutBindingFlagsCreateInfo ) == sizeof( VkDescriptorSetLayoutBindingFlagsCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorSetLayoutBindingFlagsCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingFeatures ) == sizeof( VkPhysicalDeviceDescriptorIndexingFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorIndexingFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorIndexingProperties ) == sizeof( VkPhysicalDeviceDescriptorIndexingProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorIndexingProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountAllocateInfo ) == - sizeof( VkDescriptorSetVariableDescriptorCountAllocateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorSetVariableDescriptorCountAllocateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetVariableDescriptorCountLayoutSupport ) == - sizeof( VkDescriptorSetVariableDescriptorCountLayoutSupport ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorSetVariableDescriptorCountLayoutSupport is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceScalarBlockLayoutFeatures ) == sizeof( VkPhysicalDeviceScalarBlockLayoutFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceScalarBlockLayoutFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerReductionModeCreateInfo ) == sizeof( VkSamplerReductionModeCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerReductionModeCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSamplerFilterMinmaxProperties ) == - sizeof( VkPhysicalDeviceSamplerFilterMinmaxProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSamplerFilterMinmaxProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceUniformBufferStandardLayoutFeatures ) == - sizeof( VkPhysicalDeviceUniformBufferStandardLayoutFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceUniformBufferStandardLayoutFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupExtendedTypesFeatures ) == - sizeof( VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderSubgroupExtendedTypesFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassCreateInfo2 ) == sizeof( VkRenderPassCreateInfo2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassCreateInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentDescription2 ) == sizeof( VkAttachmentDescription2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AttachmentDescription2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentReference2 ) == sizeof( VkAttachmentReference2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AttachmentReference2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassDescription2 ) == sizeof( VkSubpassDescription2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubpassDescription2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassDependency2 ) == sizeof( VkSubpassDependency2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubpassDependency2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassBeginInfo ) == sizeof( VkSubpassBeginInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubpassBeginInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassEndInfo ) == sizeof( VkSubpassEndInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubpassEndInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassDescriptionDepthStencilResolve ) == sizeof( VkSubpassDescriptionDepthStencilResolve ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubpassDescriptionDepthStencilResolve is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthStencilResolveProperties ) == - sizeof( VkPhysicalDeviceDepthStencilResolveProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDepthStencilResolveProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageStencilUsageCreateInfo ) == sizeof( VkImageStencilUsageCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageStencilUsageCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImagelessFramebufferFeatures ) == sizeof( VkPhysicalDeviceImagelessFramebufferFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImagelessFramebufferFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FramebufferAttachmentsCreateInfo ) == sizeof( VkFramebufferAttachmentsCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FramebufferAttachmentsCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FramebufferAttachmentImageInfo ) == sizeof( VkFramebufferAttachmentImageInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FramebufferAttachmentImageInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassAttachmentBeginInfo ) == sizeof( VkRenderPassAttachmentBeginInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassAttachmentBeginInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSeparateDepthStencilLayoutsFeatures ) == - sizeof( VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSeparateDepthStencilLayoutsFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentReferenceStencilLayout ) == sizeof( VkAttachmentReferenceStencilLayout ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AttachmentReferenceStencilLayout is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentDescriptionStencilLayout ) == sizeof( VkAttachmentDescriptionStencilLayout ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AttachmentDescriptionStencilLayout is not nothrow_move_constructible!" ); - -//=== VK_VERSION_1_3 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlot ) == sizeof( VkPrivateDataSlot ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "PrivateDataSlot is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PrivateDataSlot is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Features ) == sizeof( VkPhysicalDeviceVulkan13Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVulkan13Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan13Properties ) == sizeof( VkPhysicalDeviceVulkan13Properties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVulkan13Properties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceToolProperties ) == sizeof( VkPhysicalDeviceToolProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceToolProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePrivateDataFeatures ) == sizeof( VkPhysicalDevicePrivateDataFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePrivateDataFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DevicePrivateDataCreateInfo ) == sizeof( VkDevicePrivateDataCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DevicePrivateDataCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PrivateDataSlotCreateInfo ) == sizeof( VkPrivateDataSlotCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PrivateDataSlotCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryBarrier2 ) == sizeof( VkMemoryBarrier2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryBarrier2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferMemoryBarrier2 ) == sizeof( VkBufferMemoryBarrier2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferMemoryBarrier2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageMemoryBarrier2 ) == sizeof( VkImageMemoryBarrier2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageMemoryBarrier2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DependencyInfo ) == sizeof( VkDependencyInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DependencyInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubmitInfo2 ) == sizeof( VkSubmitInfo2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SubmitInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreSubmitInfo ) == sizeof( VkSemaphoreSubmitInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SemaphoreSubmitInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferSubmitInfo ) == sizeof( VkCommandBufferSubmitInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CommandBufferSubmitInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSynchronization2Features ) == sizeof( VkPhysicalDeviceSynchronization2Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSynchronization2Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyBufferInfo2 ) == sizeof( VkCopyBufferInfo2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyBufferInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyImageInfo2 ) == sizeof( VkCopyImageInfo2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyImageInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyBufferToImageInfo2 ) == sizeof( VkCopyBufferToImageInfo2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyBufferToImageInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyImageToBufferInfo2 ) == sizeof( VkCopyImageToBufferInfo2 ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyImageToBufferInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCopy2 ) == sizeof( VkBufferCopy2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "BufferCopy2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCopy2 ) == sizeof( VkImageCopy2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageCopy2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferImageCopy2 ) == sizeof( VkBufferImageCopy2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferImageCopy2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTCHDRFeatures ) == - sizeof( VkPhysicalDeviceTextureCompressionASTCHDRFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTextureCompressionASTCHDRFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FormatProperties3 ) == sizeof( VkFormatProperties3 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FormatProperties3 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Features ) == sizeof( VkPhysicalDeviceMaintenance4Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance4Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance4Properties ) == sizeof( VkPhysicalDeviceMaintenance4Properties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance4Properties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceBufferMemoryRequirements ) == sizeof( VkDeviceBufferMemoryRequirements ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceBufferMemoryRequirements is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceImageMemoryRequirements ) == sizeof( VkDeviceImageMemoryRequirements ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceImageMemoryRequirements is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCreationFeedbackCreateInfo ) == sizeof( VkPipelineCreationFeedbackCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineCreationFeedbackCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCreationFeedback ) == sizeof( VkPipelineCreationFeedback ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineCreationFeedback is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTerminateInvocationFeatures ) == - sizeof( VkPhysicalDeviceShaderTerminateInvocationFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderTerminateInvocationFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderDemoteToHelperInvocationFeatures ) == - sizeof( VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderDemoteToHelperInvocationFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCreationCacheControlFeatures ) == - sizeof( VkPhysicalDevicePipelineCreationCacheControlFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePipelineCreationCacheControlFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures ) == - sizeof( VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageRobustnessFeatures ) == sizeof( VkPhysicalDeviceImageRobustnessFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageRobustnessFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlFeatures ) == sizeof( VkPhysicalDeviceSubgroupSizeControlFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSubgroupSizeControlFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubgroupSizeControlProperties ) == - sizeof( VkPhysicalDeviceSubgroupSizeControlProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSubgroupSizeControlProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineShaderStageRequiredSubgroupSizeCreateInfo ) == - sizeof( VkPipelineShaderStageRequiredSubgroupSizeCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineShaderStageRequiredSubgroupSizeCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockFeatures ) == sizeof( VkPhysicalDeviceInlineUniformBlockFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceInlineUniformBlockFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceInlineUniformBlockProperties ) == sizeof( VkPhysicalDeviceInlineUniformBlockProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceInlineUniformBlockProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetInlineUniformBlock ) == sizeof( VkWriteDescriptorSetInlineUniformBlock ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "WriteDescriptorSetInlineUniformBlock is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorPoolInlineUniformBlockCreateInfo ) == sizeof( VkDescriptorPoolInlineUniformBlockCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorPoolInlineUniformBlockCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductFeatures ) == - sizeof( VkPhysicalDeviceShaderIntegerDotProductFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderIntegerDotProductFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerDotProductProperties ) == - sizeof( VkPhysicalDeviceShaderIntegerDotProductProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderIntegerDotProductProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentProperties ) == - sizeof( VkPhysicalDeviceTexelBufferAlignmentProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTexelBufferAlignmentProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BlitImageInfo2 ) == sizeof( VkBlitImageInfo2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BlitImageInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageBlit2 ) == sizeof( VkImageBlit2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageBlit2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ResolveImageInfo2 ) == sizeof( VkResolveImageInfo2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ResolveImageInfo2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageResolve2 ) == sizeof( VkImageResolve2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ImageResolve2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingInfo ) == sizeof( VkRenderingInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "RenderingInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingAttachmentInfo ) == sizeof( VkRenderingAttachmentInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderingAttachmentInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRenderingCreateInfo ) == sizeof( VkPipelineRenderingCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineRenderingCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingFeatures ) == sizeof( VkPhysicalDeviceDynamicRenderingFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDynamicRenderingFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderingInfo ) == sizeof( VkCommandBufferInheritanceRenderingInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CommandBufferInheritanceRenderingInfo is not nothrow_move_constructible!" ); - -//=== VK_VERSION_1_4 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Features ) == sizeof( VkPhysicalDeviceVulkan14Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVulkan14Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVulkan14Properties ) == sizeof( VkPhysicalDeviceVulkan14Properties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVulkan14Properties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceQueueGlobalPriorityCreateInfo ) == sizeof( VkDeviceQueueGlobalPriorityCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceQueueGlobalPriorityCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGlobalPriorityQueryFeatures ) == sizeof( VkPhysicalDeviceGlobalPriorityQueryFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceGlobalPriorityQueryFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyGlobalPriorityProperties ) == sizeof( VkQueueFamilyGlobalPriorityProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueueFamilyGlobalPriorityProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceIndexTypeUint8Features ) == sizeof( VkPhysicalDeviceIndexTypeUint8Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceIndexTypeUint8Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMapInfo ) == sizeof( VkMemoryMapInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MemoryMapInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryUnmapInfo ) == sizeof( VkMemoryUnmapInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryUnmapInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Features ) == sizeof( VkPhysicalDeviceMaintenance5Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance5Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance5Properties ) == sizeof( VkPhysicalDeviceMaintenance5Properties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance5Properties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceImageSubresourceInfo ) == sizeof( VkDeviceImageSubresourceInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceImageSubresourceInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSubresource2 ) == sizeof( VkImageSubresource2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageSubresource2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubresourceLayout2 ) == sizeof( VkSubresourceLayout2 ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubresourceLayout2 is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferUsageFlags2CreateInfo ) == sizeof( VkBufferUsageFlags2CreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferUsageFlags2CreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Features ) == sizeof( VkPhysicalDeviceMaintenance6Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance6Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance6Properties ) == sizeof( VkPhysicalDeviceMaintenance6Properties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance6Properties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindMemoryStatus ) == sizeof( VkBindMemoryStatus ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindMemoryStatus is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyFeatures ) == sizeof( VkPhysicalDeviceHostImageCopyFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceHostImageCopyFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHostImageCopyProperties ) == sizeof( VkPhysicalDeviceHostImageCopyProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceHostImageCopyProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryToImageCopy ) == sizeof( VkMemoryToImageCopy ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryToImageCopy is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageToMemoryCopy ) == sizeof( VkImageToMemoryCopy ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageToMemoryCopy is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToImageInfo ) == sizeof( VkCopyMemoryToImageInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyMemoryToImageInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyImageToMemoryInfo ) == sizeof( VkCopyImageToMemoryInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyImageToMemoryInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyImageToImageInfo ) == sizeof( VkCopyImageToImageInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyImageToImageInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HostImageLayoutTransitionInfo ) == sizeof( VkHostImageLayoutTransitionInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "HostImageLayoutTransitionInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubresourceHostMemcpySize ) == sizeof( VkSubresourceHostMemcpySize ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubresourceHostMemcpySize is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HostImageCopyDevicePerformanceQuery ) == sizeof( VkHostImageCopyDevicePerformanceQuery ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "HostImageCopyDevicePerformanceQuery is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupRotateFeatures ) == sizeof( VkPhysicalDeviceShaderSubgroupRotateFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderSubgroupRotateFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloatControls2Features ) == sizeof( VkPhysicalDeviceShaderFloatControls2Features ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderFloatControls2Features is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderExpectAssumeFeatures ) == sizeof( VkPhysicalDeviceShaderExpectAssumeFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderExpectAssumeFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCreateFlags2CreateInfo ) == sizeof( VkPipelineCreateFlags2CreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineCreateFlags2CreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePushDescriptorProperties ) == sizeof( VkPhysicalDevicePushDescriptorProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePushDescriptorProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindDescriptorSetsInfo ) == sizeof( VkBindDescriptorSetsInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindDescriptorSetsInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushConstantsInfo ) == sizeof( VkPushConstantsInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PushConstantsInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushDescriptorSetInfo ) == sizeof( VkPushDescriptorSetInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PushDescriptorSetInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushDescriptorSetWithTemplateInfo ) == sizeof( VkPushDescriptorSetWithTemplateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PushDescriptorSetWithTemplateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineProtectedAccessFeatures ) == - sizeof( VkPhysicalDevicePipelineProtectedAccessFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePipelineProtectedAccessFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessFeatures ) == sizeof( VkPhysicalDevicePipelineRobustnessFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePipelineRobustnessFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineRobustnessProperties ) == sizeof( VkPhysicalDevicePipelineRobustnessProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePipelineRobustnessProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRobustnessCreateInfo ) == sizeof( VkPipelineRobustnessCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineRobustnessCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationFeatures ) == sizeof( VkPhysicalDeviceLineRasterizationFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceLineRasterizationFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLineRasterizationProperties ) == sizeof( VkPhysicalDeviceLineRasterizationProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceLineRasterizationProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationLineStateCreateInfo ) == sizeof( VkPipelineRasterizationLineStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineRasterizationLineStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorProperties ) == - sizeof( VkPhysicalDeviceVertexAttributeDivisorProperties ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVertexAttributeDivisorProperties is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputBindingDivisorDescription ) == sizeof( VkVertexInputBindingDivisorDescription ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VertexInputBindingDivisorDescription is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineVertexInputDivisorStateCreateInfo ) == sizeof( VkPipelineVertexInputDivisorStateCreateInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineVertexInputDivisorStateCreateInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorFeatures ) == - sizeof( VkPhysicalDeviceVertexAttributeDivisorFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVertexAttributeDivisorFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingAreaInfo ) == sizeof( VkRenderingAreaInfo ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderingAreaInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingLocalReadFeatures ) == - sizeof( VkPhysicalDeviceDynamicRenderingLocalReadFeatures ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDynamicRenderingLocalReadFeatures is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingAttachmentLocationInfo ) == sizeof( VkRenderingAttachmentLocationInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderingAttachmentLocationInfo is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingInputAttachmentIndexInfo ) == sizeof( VkRenderingInputAttachmentIndexInfo ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderingInputAttachmentIndexInfo is not nothrow_move_constructible!" ); - -//=== VK_KHR_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceKHR ) == sizeof( VkSurfaceKHR ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "SurfaceKHR is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SurfaceKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesKHR ) == sizeof( VkSurfaceCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceFormatKHR ) == sizeof( VkSurfaceFormatKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceFormatKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_swapchain === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainKHR ) == sizeof( VkSwapchainKHR ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "SwapchainKHR is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SwapchainKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainCreateInfoKHR ) == sizeof( VkSwapchainCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentInfoKHR ) == sizeof( VkPresentInfoKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PresentInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageSwapchainCreateInfoKHR ) == sizeof( VkImageSwapchainCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageSwapchainCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindImageMemorySwapchainInfoKHR ) == sizeof( VkBindImageMemorySwapchainInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindImageMemorySwapchainInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AcquireNextImageInfoKHR ) == sizeof( VkAcquireNextImageInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AcquireNextImageInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupPresentCapabilitiesKHR ) == sizeof( VkDeviceGroupPresentCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceGroupPresentCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupPresentInfoKHR ) == sizeof( VkDeviceGroupPresentInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceGroupPresentInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceGroupSwapchainCreateInfoKHR ) == sizeof( VkDeviceGroupSwapchainCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceGroupSwapchainCreateInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_display === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayKHR ) == sizeof( VkDisplayKHR ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DisplayKHR is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "DisplayKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeKHR ) == sizeof( VkDisplayModeKHR ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DisplayModeKHR is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayModeKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeCreateInfoKHR ) == sizeof( VkDisplayModeCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayModeCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeParametersKHR ) == sizeof( VkDisplayModeParametersKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayModeParametersKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModePropertiesKHR ) == sizeof( VkDisplayModePropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayModePropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilitiesKHR ) == sizeof( VkDisplayPlaneCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayPlaneCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPlanePropertiesKHR ) == sizeof( VkDisplayPlanePropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayPlanePropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPropertiesKHR ) == sizeof( VkDisplayPropertiesKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplaySurfaceCreateInfoKHR ) == sizeof( VkDisplaySurfaceCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplaySurfaceCreateInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_display_swapchain === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPresentInfoKHR ) == sizeof( VkDisplayPresentInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayPresentInfoKHR is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) -//=== VK_KHR_xlib_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::XlibSurfaceCreateInfoKHR ) == sizeof( VkXlibSurfaceCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "XlibSurfaceCreateInfoKHR is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) -//=== VK_KHR_xcb_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::XcbSurfaceCreateInfoKHR ) == sizeof( VkXcbSurfaceCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "XcbSurfaceCreateInfoKHR is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) -//=== VK_KHR_wayland_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WaylandSurfaceCreateInfoKHR ) == sizeof( VkWaylandSurfaceCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "WaylandSurfaceCreateInfoKHR is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) -//=== VK_KHR_android_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidSurfaceCreateInfoKHR ) == sizeof( VkAndroidSurfaceCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AndroidSurfaceCreateInfoKHR is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) -//=== VK_KHR_win32_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Win32SurfaceCreateInfoKHR ) == sizeof( VkWin32SurfaceCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "Win32SurfaceCreateInfoKHR is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -//=== VK_EXT_debug_report === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT ) == sizeof( VkDebugReportCallbackEXT ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "DebugReportCallbackEXT is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DebugReportCallbackEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugReportCallbackCreateInfoEXT ) == sizeof( VkDebugReportCallbackCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DebugReportCallbackCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_AMD_rasterization_order === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateRasterizationOrderAMD ) == - sizeof( VkPipelineRasterizationStateRasterizationOrderAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineRasterizationStateRasterizationOrderAMD is not nothrow_move_constructible!" ); - -//=== VK_EXT_debug_marker === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugMarkerObjectNameInfoEXT ) == sizeof( VkDebugMarkerObjectNameInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DebugMarkerObjectNameInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugMarkerObjectTagInfoEXT ) == sizeof( VkDebugMarkerObjectTagInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DebugMarkerObjectTagInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugMarkerMarkerInfoEXT ) == sizeof( VkDebugMarkerMarkerInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DebugMarkerMarkerInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_queue === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionKHR ) == sizeof( VkVideoSessionKHR ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "VideoSessionKHR is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoSessionKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR ) == sizeof( VkVideoSessionParametersKHR ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "VideoSessionParametersKHR is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoSessionParametersKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyQueryResultStatusPropertiesKHR ) == sizeof( VkQueueFamilyQueryResultStatusPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueueFamilyQueryResultStatusPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyVideoPropertiesKHR ) == sizeof( VkQueueFamilyVideoPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueueFamilyVideoPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoProfileInfoKHR ) == sizeof( VkVideoProfileInfoKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoProfileInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoProfileListInfoKHR ) == sizeof( VkVideoProfileListInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoProfileListInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoCapabilitiesKHR ) == sizeof( VkVideoCapabilitiesKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoFormatInfoKHR ) == sizeof( VkPhysicalDeviceVideoFormatInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVideoFormatInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoFormatPropertiesKHR ) == sizeof( VkVideoFormatPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoFormatPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoPictureResourceInfoKHR ) == sizeof( VkVideoPictureResourceInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoPictureResourceInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoReferenceSlotInfoKHR ) == sizeof( VkVideoReferenceSlotInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoReferenceSlotInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionMemoryRequirementsKHR ) == sizeof( VkVideoSessionMemoryRequirementsKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoSessionMemoryRequirementsKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindVideoSessionMemoryInfoKHR ) == sizeof( VkBindVideoSessionMemoryInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindVideoSessionMemoryInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionCreateInfoKHR ) == sizeof( VkVideoSessionCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoSessionCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersCreateInfoKHR ) == sizeof( VkVideoSessionParametersCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoSessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR ) == sizeof( VkVideoSessionParametersUpdateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoSessionParametersUpdateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoBeginCodingInfoKHR ) == sizeof( VkVideoBeginCodingInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoBeginCodingInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEndCodingInfoKHR ) == sizeof( VkVideoEndCodingInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEndCodingInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoCodingControlInfoKHR ) == sizeof( VkVideoCodingControlInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoCodingControlInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_decode_queue === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeCapabilitiesKHR ) == sizeof( VkVideoDecodeCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeUsageInfoKHR ) == sizeof( VkVideoDecodeUsageInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeUsageInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeInfoKHR ) == sizeof( VkVideoDecodeInfoKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_dedicated_allocation === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DedicatedAllocationImageCreateInfoNV ) == sizeof( VkDedicatedAllocationImageCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DedicatedAllocationImageCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DedicatedAllocationBufferCreateInfoNV ) == sizeof( VkDedicatedAllocationBufferCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DedicatedAllocationBufferCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DedicatedAllocationMemoryAllocateInfoNV ) == sizeof( VkDedicatedAllocationMemoryAllocateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DedicatedAllocationMemoryAllocateInfoNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_transform_feedback === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackFeaturesEXT ) == sizeof( VkPhysicalDeviceTransformFeedbackFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTransformFeedbackFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTransformFeedbackPropertiesEXT ) == - sizeof( VkPhysicalDeviceTransformFeedbackPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTransformFeedbackPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationStateStreamCreateInfoEXT ) == - sizeof( VkPipelineRasterizationStateStreamCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineRasterizationStateStreamCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_NVX_binary_import === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuModuleNVX ) == sizeof( VkCuModuleNVX ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CuModuleNVX is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CuModuleNVX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionNVX ) == sizeof( VkCuFunctionNVX ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CuFunctionNVX is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CuFunctionNVX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuModuleCreateInfoNVX ) == sizeof( VkCuModuleCreateInfoNVX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CuModuleCreateInfoNVX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuModuleTexturingModeCreateInfoNVX ) == sizeof( VkCuModuleTexturingModeCreateInfoNVX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CuModuleTexturingModeCreateInfoNVX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuFunctionCreateInfoNVX ) == sizeof( VkCuFunctionCreateInfoNVX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CuFunctionCreateInfoNVX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CuLaunchInfoNVX ) == sizeof( VkCuLaunchInfoNVX ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CuLaunchInfoNVX is not nothrow_move_constructible!" ); - -//=== VK_NVX_image_view_handle === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewHandleInfoNVX ) == sizeof( VkImageViewHandleInfoNVX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageViewHandleInfoNVX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewAddressPropertiesNVX ) == sizeof( VkImageViewAddressPropertiesNVX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageViewAddressPropertiesNVX is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_encode_h264 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264CapabilitiesKHR ) == sizeof( VkVideoEncodeH264CapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264CapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264QualityLevelPropertiesKHR ) == sizeof( VkVideoEncodeH264QualityLevelPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264QualityLevelPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionCreateInfoKHR ) == sizeof( VkVideoEncodeH264SessionCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264SessionCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersCreateInfoKHR ) == - sizeof( VkVideoEncodeH264SessionParametersCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersAddInfoKHR ) == sizeof( VkVideoEncodeH264SessionParametersAddInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264SessionParametersAddInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersGetInfoKHR ) == sizeof( VkVideoEncodeH264SessionParametersGetInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264SessionParametersGetInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264SessionParametersFeedbackInfoKHR ) == - sizeof( VkVideoEncodeH264SessionParametersFeedbackInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264SessionParametersFeedbackInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264PictureInfoKHR ) == sizeof( VkVideoEncodeH264PictureInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264PictureInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264DpbSlotInfoKHR ) == sizeof( VkVideoEncodeH264DpbSlotInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264DpbSlotInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264NaluSliceInfoKHR ) == sizeof( VkVideoEncodeH264NaluSliceInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264NaluSliceInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264ProfileInfoKHR ) == sizeof( VkVideoEncodeH264ProfileInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264ProfileInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlInfoKHR ) == sizeof( VkVideoEncodeH264RateControlInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264RateControlInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264RateControlLayerInfoKHR ) == sizeof( VkVideoEncodeH264RateControlLayerInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264RateControlLayerInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264QpKHR ) == sizeof( VkVideoEncodeH264QpKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264QpKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264FrameSizeKHR ) == sizeof( VkVideoEncodeH264FrameSizeKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264FrameSizeKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264GopRemainingFrameInfoKHR ) == sizeof( VkVideoEncodeH264GopRemainingFrameInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264GopRemainingFrameInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_encode_h265 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265CapabilitiesKHR ) == sizeof( VkVideoEncodeH265CapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265CapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionCreateInfoKHR ) == sizeof( VkVideoEncodeH265SessionCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265SessionCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265QualityLevelPropertiesKHR ) == sizeof( VkVideoEncodeH265QualityLevelPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265QualityLevelPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersCreateInfoKHR ) == - sizeof( VkVideoEncodeH265SessionParametersCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersAddInfoKHR ) == sizeof( VkVideoEncodeH265SessionParametersAddInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265SessionParametersAddInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersGetInfoKHR ) == sizeof( VkVideoEncodeH265SessionParametersGetInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265SessionParametersGetInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265SessionParametersFeedbackInfoKHR ) == - sizeof( VkVideoEncodeH265SessionParametersFeedbackInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265SessionParametersFeedbackInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265PictureInfoKHR ) == sizeof( VkVideoEncodeH265PictureInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265PictureInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265DpbSlotInfoKHR ) == sizeof( VkVideoEncodeH265DpbSlotInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265DpbSlotInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265NaluSliceSegmentInfoKHR ) == sizeof( VkVideoEncodeH265NaluSliceSegmentInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265NaluSliceSegmentInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265ProfileInfoKHR ) == sizeof( VkVideoEncodeH265ProfileInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265ProfileInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlInfoKHR ) == sizeof( VkVideoEncodeH265RateControlInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265RateControlInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265RateControlLayerInfoKHR ) == sizeof( VkVideoEncodeH265RateControlLayerInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265RateControlLayerInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265QpKHR ) == sizeof( VkVideoEncodeH265QpKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265QpKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265FrameSizeKHR ) == sizeof( VkVideoEncodeH265FrameSizeKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265FrameSizeKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265GopRemainingFrameInfoKHR ) == sizeof( VkVideoEncodeH265GopRemainingFrameInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265GopRemainingFrameInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_decode_h264 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264ProfileInfoKHR ) == sizeof( VkVideoDecodeH264ProfileInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH264ProfileInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264CapabilitiesKHR ) == sizeof( VkVideoDecodeH264CapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH264CapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersCreateInfoKHR ) == - sizeof( VkVideoDecodeH264SessionParametersCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH264SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264SessionParametersAddInfoKHR ) == sizeof( VkVideoDecodeH264SessionParametersAddInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH264SessionParametersAddInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264PictureInfoKHR ) == sizeof( VkVideoDecodeH264PictureInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH264PictureInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264DpbSlotInfoKHR ) == sizeof( VkVideoDecodeH264DpbSlotInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH264DpbSlotInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_AMD_texture_gather_bias_lod === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TextureLODGatherFormatPropertiesAMD ) == sizeof( VkTextureLODGatherFormatPropertiesAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TextureLODGatherFormatPropertiesAMD is not nothrow_move_constructible!" ); - -//=== VK_AMD_shader_info === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderResourceUsageAMD ) == sizeof( VkShaderResourceUsageAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ShaderResourceUsageAMD is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderStatisticsInfoAMD ) == sizeof( VkShaderStatisticsInfoAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ShaderStatisticsInfoAMD is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_GGP ) -//=== VK_GGP_stream_descriptor_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StreamDescriptorSurfaceCreateInfoGGP ) == sizeof( VkStreamDescriptorSurfaceCreateInfoGGP ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "StreamDescriptorSurfaceCreateInfoGGP is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_GGP*/ - -//=== VK_NV_corner_sampled_image === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCornerSampledImageFeaturesNV ) == sizeof( VkPhysicalDeviceCornerSampledImageFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCornerSampledImageFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_NV_external_memory_capabilities === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalImageFormatPropertiesNV ) == sizeof( VkExternalImageFormatPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalImageFormatPropertiesNV is not nothrow_move_constructible!" ); - -//=== VK_NV_external_memory === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryImageCreateInfoNV ) == sizeof( VkExternalMemoryImageCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalMemoryImageCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMemoryAllocateInfoNV ) == sizeof( VkExportMemoryAllocateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMemoryAllocateInfoNV is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) -//=== VK_NV_external_memory_win32 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoNV ) == sizeof( VkImportMemoryWin32HandleInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportMemoryWin32HandleInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoNV ) == sizeof( VkExportMemoryWin32HandleInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMemoryWin32HandleInfoNV is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) -//=== VK_NV_win32_keyed_mutex === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoNV ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "Win32KeyedMutexAcquireReleaseInfoNV is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -//=== VK_EXT_validation_flags === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationFlagsEXT ) == sizeof( VkValidationFlagsEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ValidationFlagsEXT is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_VI_NN ) -//=== VK_NN_vi_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ViSurfaceCreateInfoNN ) == sizeof( VkViSurfaceCreateInfoNN ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ViSurfaceCreateInfoNN is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_VI_NN*/ - -//=== VK_EXT_astc_decode_mode === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewASTCDecodeModeEXT ) == sizeof( VkImageViewASTCDecodeModeEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageViewASTCDecodeModeEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceASTCDecodeFeaturesEXT ) == sizeof( VkPhysicalDeviceASTCDecodeFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceASTCDecodeFeaturesEXT is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) -//=== VK_KHR_external_memory_win32 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryWin32HandleInfoKHR ) == sizeof( VkImportMemoryWin32HandleInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportMemoryWin32HandleInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMemoryWin32HandleInfoKHR ) == sizeof( VkExportMemoryWin32HandleInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMemoryWin32HandleInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryWin32HandlePropertiesKHR ) == sizeof( VkMemoryWin32HandlePropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryWin32HandlePropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetWin32HandleInfoKHR ) == sizeof( VkMemoryGetWin32HandleInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryGetWin32HandleInfoKHR is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -//=== VK_KHR_external_memory_fd === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryFdInfoKHR ) == sizeof( VkImportMemoryFdInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportMemoryFdInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryFdPropertiesKHR ) == sizeof( VkMemoryFdPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryFdPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetFdInfoKHR ) == sizeof( VkMemoryGetFdInfoKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryGetFdInfoKHR is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) -//=== VK_KHR_win32_keyed_mutex === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::Win32KeyedMutexAcquireReleaseInfoKHR ) == sizeof( VkWin32KeyedMutexAcquireReleaseInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "Win32KeyedMutexAcquireReleaseInfoKHR is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) -//=== VK_KHR_external_semaphore_win32 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportSemaphoreWin32HandleInfoKHR ) == sizeof( VkImportSemaphoreWin32HandleInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportSemaphoreWin32HandleInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportSemaphoreWin32HandleInfoKHR ) == sizeof( VkExportSemaphoreWin32HandleInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportSemaphoreWin32HandleInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::D3D12FenceSubmitInfoKHR ) == sizeof( VkD3D12FenceSubmitInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "D3D12FenceSubmitInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreGetWin32HandleInfoKHR ) == sizeof( VkSemaphoreGetWin32HandleInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SemaphoreGetWin32HandleInfoKHR is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -//=== VK_KHR_external_semaphore_fd === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportSemaphoreFdInfoKHR ) == sizeof( VkImportSemaphoreFdInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportSemaphoreFdInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreGetFdInfoKHR ) == sizeof( VkSemaphoreGetFdInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SemaphoreGetFdInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_EXT_conditional_rendering === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ConditionalRenderingBeginInfoEXT ) == sizeof( VkConditionalRenderingBeginInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ConditionalRenderingBeginInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceConditionalRenderingFeaturesEXT ) == - sizeof( VkPhysicalDeviceConditionalRenderingFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceConditionalRenderingFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceConditionalRenderingInfoEXT ) == - sizeof( VkCommandBufferInheritanceConditionalRenderingInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CommandBufferInheritanceConditionalRenderingInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_incremental_present === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentRegionsKHR ) == sizeof( VkPresentRegionsKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PresentRegionsKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentRegionKHR ) == sizeof( VkPresentRegionKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PresentRegionKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RectLayerKHR ) == sizeof( VkRectLayerKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "RectLayerKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_clip_space_w_scaling === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ViewportWScalingNV ) == sizeof( VkViewportWScalingNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ViewportWScalingNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportWScalingStateCreateInfoNV ) == sizeof( VkPipelineViewportWScalingStateCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineViewportWScalingStateCreateInfoNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_display_surface_counter === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2EXT ) == sizeof( VkSurfaceCapabilities2EXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceCapabilities2EXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_display_control === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPowerInfoEXT ) == sizeof( VkDisplayPowerInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayPowerInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceEventInfoEXT ) == sizeof( VkDeviceEventInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceEventInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayEventInfoEXT ) == sizeof( VkDisplayEventInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayEventInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainCounterCreateInfoEXT ) == sizeof( VkSwapchainCounterCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainCounterCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_GOOGLE_display_timing === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE ) == sizeof( VkRefreshCycleDurationGOOGLE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RefreshCycleDurationGOOGLE is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PastPresentationTimingGOOGLE ) == sizeof( VkPastPresentationTimingGOOGLE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PastPresentationTimingGOOGLE is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimesInfoGOOGLE ) == sizeof( VkPresentTimesInfoGOOGLE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PresentTimesInfoGOOGLE is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimeGOOGLE ) == sizeof( VkPresentTimeGOOGLE ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PresentTimeGOOGLE is not nothrow_move_constructible!" ); - -//=== VK_NVX_multiview_per_view_attributes === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ) == - sizeof( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultiviewPerViewAttributesInfoNVX ) == sizeof( VkMultiviewPerViewAttributesInfoNVX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MultiviewPerViewAttributesInfoNVX is not nothrow_move_constructible!" ); - -//=== VK_NV_viewport_swizzle === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ViewportSwizzleNV ) == sizeof( VkViewportSwizzleNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ViewportSwizzleNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportSwizzleStateCreateInfoNV ) == sizeof( VkPipelineViewportSwizzleStateCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineViewportSwizzleStateCreateInfoNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_discard_rectangles === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiscardRectanglePropertiesEXT ) == - sizeof( VkPhysicalDeviceDiscardRectanglePropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDiscardRectanglePropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineDiscardRectangleStateCreateInfoEXT ) == sizeof( VkPipelineDiscardRectangleStateCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineDiscardRectangleStateCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_conservative_rasterization === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceConservativeRasterizationPropertiesEXT ) == - sizeof( VkPhysicalDeviceConservativeRasterizationPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceConservativeRasterizationPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationConservativeStateCreateInfoEXT ) == - sizeof( VkPipelineRasterizationConservativeStateCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineRasterizationConservativeStateCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_depth_clip_enable === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipEnableFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDepthClipEnableFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationDepthClipStateCreateInfoEXT ) == - sizeof( VkPipelineRasterizationDepthClipStateCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineRasterizationDepthClipStateCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_hdr_metadata === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HdrMetadataEXT ) == sizeof( VkHdrMetadataEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "HdrMetadataEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::XYColorEXT ) == sizeof( VkXYColorEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "XYColorEXT is not nothrow_move_constructible!" ); - -//=== VK_IMG_relaxed_line_rasterization === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRelaxedLineRasterizationFeaturesIMG ) == - sizeof( VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRelaxedLineRasterizationFeaturesIMG is not nothrow_move_constructible!" ); - -//=== VK_KHR_shared_presentable_image === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SharedPresentSurfaceCapabilitiesKHR ) == sizeof( VkSharedPresentSurfaceCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SharedPresentSurfaceCapabilitiesKHR is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) -//=== VK_KHR_external_fence_win32 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportFenceWin32HandleInfoKHR ) == sizeof( VkImportFenceWin32HandleInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportFenceWin32HandleInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportFenceWin32HandleInfoKHR ) == sizeof( VkExportFenceWin32HandleInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportFenceWin32HandleInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FenceGetWin32HandleInfoKHR ) == sizeof( VkFenceGetWin32HandleInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FenceGetWin32HandleInfoKHR is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -//=== VK_KHR_external_fence_fd === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportFenceFdInfoKHR ) == sizeof( VkImportFenceFdInfoKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportFenceFdInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FenceGetFdInfoKHR ) == sizeof( VkFenceGetFdInfoKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FenceGetFdInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_performance_query === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryFeaturesKHR ) == sizeof( VkPhysicalDevicePerformanceQueryFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePerformanceQueryFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceQueryPropertiesKHR ) == - sizeof( VkPhysicalDevicePerformanceQueryPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePerformanceQueryPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceCounterKHR ) == sizeof( VkPerformanceCounterKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceCounterKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionKHR ) == sizeof( VkPerformanceCounterDescriptionKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceCounterDescriptionKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceCreateInfoKHR ) == sizeof( VkQueryPoolPerformanceCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueryPoolPerformanceCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceCounterResultKHR ) == sizeof( VkPerformanceCounterResultKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceCounterResultKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AcquireProfilingLockInfoKHR ) == sizeof( VkAcquireProfilingLockInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AcquireProfilingLockInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceQuerySubmitInfoKHR ) == sizeof( VkPerformanceQuerySubmitInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceQuerySubmitInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_get_surface_capabilities2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSurfaceInfo2KHR ) == sizeof( VkPhysicalDeviceSurfaceInfo2KHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSurfaceInfo2KHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilities2KHR ) == sizeof( VkSurfaceCapabilities2KHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceCapabilities2KHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceFormat2KHR ) == sizeof( VkSurfaceFormat2KHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceFormat2KHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_get_display_properties2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayProperties2KHR ) == sizeof( VkDisplayProperties2KHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayProperties2KHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPlaneProperties2KHR ) == sizeof( VkDisplayPlaneProperties2KHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayPlaneProperties2KHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeProperties2KHR ) == sizeof( VkDisplayModeProperties2KHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayModeProperties2KHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPlaneInfo2KHR ) == sizeof( VkDisplayPlaneInfo2KHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayPlaneInfo2KHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayPlaneCapabilities2KHR ) == sizeof( VkDisplayPlaneCapabilities2KHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayPlaneCapabilities2KHR is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_IOS_MVK ) -//=== VK_MVK_ios_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IOSSurfaceCreateInfoMVK ) == sizeof( VkIOSSurfaceCreateInfoMVK ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IOSSurfaceCreateInfoMVK is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) -//=== VK_MVK_macos_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MacOSSurfaceCreateInfoMVK ) == sizeof( VkMacOSSurfaceCreateInfoMVK ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MacOSSurfaceCreateInfoMVK is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - -//=== VK_EXT_debug_utils === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT ) == sizeof( VkDebugUtilsMessengerEXT ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "DebugUtilsMessengerEXT is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DebugUtilsMessengerEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsLabelEXT ) == sizeof( VkDebugUtilsLabelEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DebugUtilsLabelEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCallbackDataEXT ) == sizeof( VkDebugUtilsMessengerCallbackDataEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DebugUtilsMessengerCallbackDataEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsMessengerCreateInfoEXT ) == sizeof( VkDebugUtilsMessengerCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DebugUtilsMessengerCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsObjectNameInfoEXT ) == sizeof( VkDebugUtilsObjectNameInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DebugUtilsObjectNameInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DebugUtilsObjectTagInfoEXT ) == sizeof( VkDebugUtilsObjectTagInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DebugUtilsObjectTagInfoEXT is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) -//=== VK_ANDROID_external_memory_android_hardware_buffer === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferUsageANDROID ) == sizeof( VkAndroidHardwareBufferUsageANDROID ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AndroidHardwareBufferUsageANDROID is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferPropertiesANDROID ) == sizeof( VkAndroidHardwareBufferPropertiesANDROID ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AndroidHardwareBufferPropertiesANDROID is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatPropertiesANDROID ) == - sizeof( VkAndroidHardwareBufferFormatPropertiesANDROID ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AndroidHardwareBufferFormatPropertiesANDROID is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportAndroidHardwareBufferInfoANDROID ) == sizeof( VkImportAndroidHardwareBufferInfoANDROID ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportAndroidHardwareBufferInfoANDROID is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetAndroidHardwareBufferInfoANDROID ) == sizeof( VkMemoryGetAndroidHardwareBufferInfoANDROID ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryGetAndroidHardwareBufferInfoANDROID is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalFormatANDROID ) == sizeof( VkExternalFormatANDROID ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalFormatANDROID is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatProperties2ANDROID ) == - sizeof( VkAndroidHardwareBufferFormatProperties2ANDROID ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AndroidHardwareBufferFormatProperties2ANDROID is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) -//=== VK_AMDX_shader_enqueue === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueueFeaturesAMDX ) == sizeof( VkPhysicalDeviceShaderEnqueueFeaturesAMDX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderEnqueueFeaturesAMDX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEnqueuePropertiesAMDX ) == sizeof( VkPhysicalDeviceShaderEnqueuePropertiesAMDX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderEnqueuePropertiesAMDX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineScratchSizeAMDX ) == sizeof( VkExecutionGraphPipelineScratchSizeAMDX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExecutionGraphPipelineScratchSizeAMDX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExecutionGraphPipelineCreateInfoAMDX ) == sizeof( VkExecutionGraphPipelineCreateInfoAMDX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExecutionGraphPipelineCreateInfoAMDX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchGraphInfoAMDX ) == sizeof( VkDispatchGraphInfoAMDX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DispatchGraphInfoAMDX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchGraphCountInfoAMDX ) == sizeof( VkDispatchGraphCountInfoAMDX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DispatchGraphCountInfoAMDX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineShaderStageNodeCreateInfoAMDX ) == sizeof( VkPipelineShaderStageNodeCreateInfoAMDX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineShaderStageNodeCreateInfoAMDX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstAMDX ) == sizeof( VkDeviceOrHostAddressConstAMDX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceOrHostAddressConstAMDX is not nothrow_move_constructible!" ); -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -//=== VK_EXT_descriptor_heap === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorARM ) == sizeof( VkTensorARM ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "TensorARM is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "TensorARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HostAddressRangeEXT ) == sizeof( VkHostAddressRangeEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "HostAddressRangeEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HostAddressRangeConstEXT ) == sizeof( VkHostAddressRangeConstEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "HostAddressRangeConstEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceAddressRangeEXT ) == sizeof( VkDeviceAddressRangeEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceAddressRangeEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TexelBufferDescriptorInfoEXT ) == sizeof( VkTexelBufferDescriptorInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TexelBufferDescriptorInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageDescriptorInfoEXT ) == sizeof( VkImageDescriptorInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageDescriptorInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ResourceDescriptorInfoEXT ) == sizeof( VkResourceDescriptorInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ResourceDescriptorInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ResourceDescriptorDataEXT ) == sizeof( VkResourceDescriptorDataEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ResourceDescriptorDataEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindHeapInfoEXT ) == sizeof( VkBindHeapInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindHeapInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushDataInfoEXT ) == sizeof( VkPushDataInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PushDataInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceConstantOffsetEXT ) == sizeof( VkDescriptorMappingSourceConstantOffsetEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorMappingSourceConstantOffsetEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourcePushIndexEXT ) == sizeof( VkDescriptorMappingSourcePushIndexEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorMappingSourcePushIndexEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexEXT ) == sizeof( VkDescriptorMappingSourceIndirectIndexEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorMappingSourceIndirectIndexEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceHeapDataEXT ) == sizeof( VkDescriptorMappingSourceHeapDataEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorMappingSourceHeapDataEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectAddressEXT ) == sizeof( VkDescriptorMappingSourceIndirectAddressEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorMappingSourceIndirectAddressEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceShaderRecordIndexEXT ) == - sizeof( VkDescriptorMappingSourceShaderRecordIndexEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorMappingSourceShaderRecordIndexEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceDataEXT ) == sizeof( VkDescriptorMappingSourceDataEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorMappingSourceDataEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorMappingSourceIndirectIndexArrayEXT ) == - sizeof( VkDescriptorMappingSourceIndirectIndexArrayEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorMappingSourceIndirectIndexArrayEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetAndBindingMappingEXT ) == sizeof( VkDescriptorSetAndBindingMappingEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorSetAndBindingMappingEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderDescriptorSetAndBindingMappingInfoEXT ) == - sizeof( VkShaderDescriptorSetAndBindingMappingInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ShaderDescriptorSetAndBindingMappingInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpaqueCaptureDataCreateInfoEXT ) == sizeof( VkOpaqueCaptureDataCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "OpaqueCaptureDataCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorHeapFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorHeapFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapPropertiesEXT ) == sizeof( VkPhysicalDeviceDescriptorHeapPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorHeapPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceDescriptorHeapInfoEXT ) == - sizeof( VkCommandBufferInheritanceDescriptorHeapInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CommandBufferInheritanceDescriptorHeapInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorIndexCreateInfoEXT ) == sizeof( VkSamplerCustomBorderColorIndexCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerCustomBorderColorIndexCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutPushDataTokenNV ) == sizeof( VkIndirectCommandsLayoutPushDataTokenNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsLayoutPushDataTokenNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubsampledImageFormatPropertiesEXT ) == sizeof( VkSubsampledImageFormatPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubsampledImageFormatPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorViewCreateInfoARM ) == sizeof( VkTensorViewCreateInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TensorViewCreateInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorHeapTensorPropertiesARM ) == - sizeof( VkPhysicalDeviceDescriptorHeapTensorPropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorHeapTensorPropertiesARM is not nothrow_move_constructible!" ); - -//=== VK_AMD_mixed_attachment_samples === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentSampleCountInfoAMD ) == sizeof( VkAttachmentSampleCountInfoAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AttachmentSampleCountInfoAMD is not nothrow_move_constructible!" ); - -//=== VK_KHR_shader_bfloat16 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderBfloat16FeaturesKHR ) == sizeof( VkPhysicalDeviceShaderBfloat16FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderBfloat16FeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_EXT_sample_locations === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SampleLocationEXT ) == sizeof( VkSampleLocationEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SampleLocationEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SampleLocationsInfoEXT ) == sizeof( VkSampleLocationsInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SampleLocationsInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentSampleLocationsEXT ) == sizeof( VkAttachmentSampleLocationsEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AttachmentSampleLocationsEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassSampleLocationsEXT ) == sizeof( VkSubpassSampleLocationsEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubpassSampleLocationsEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassSampleLocationsBeginInfoEXT ) == sizeof( VkRenderPassSampleLocationsBeginInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassSampleLocationsBeginInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineSampleLocationsStateCreateInfoEXT ) == sizeof( VkPipelineSampleLocationsStateCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineSampleLocationsStateCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSampleLocationsPropertiesEXT ) == sizeof( VkPhysicalDeviceSampleLocationsPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSampleLocationsPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultisamplePropertiesEXT ) == sizeof( VkMultisamplePropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MultisamplePropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_blend_operation_advanced === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedFeaturesEXT ) == - sizeof( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceBlendOperationAdvancedFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceBlendOperationAdvancedPropertiesEXT ) == - sizeof( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceBlendOperationAdvancedPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineColorBlendAdvancedStateCreateInfoEXT ) == - sizeof( VkPipelineColorBlendAdvancedStateCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineColorBlendAdvancedStateCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_NV_fragment_coverage_to_color === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCoverageToColorStateCreateInfoNV ) == sizeof( VkPipelineCoverageToColorStateCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineCoverageToColorStateCreateInfoNV is not nothrow_move_constructible!" ); - -//=== VK_KHR_acceleration_structure === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureKHR ) == sizeof( VkAccelerationStructureKHR ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "AccelerationStructureKHR is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressKHR ) == sizeof( VkDeviceOrHostAddressKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceOrHostAddressKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceOrHostAddressConstKHR ) == sizeof( VkDeviceOrHostAddressConstKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceOrHostAddressConstKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildRangeInfoKHR ) == sizeof( VkAccelerationStructureBuildRangeInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureBuildRangeInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AabbPositionsKHR ) == sizeof( VkAabbPositionsKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AabbPositionsKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryTrianglesDataKHR ) == - sizeof( VkAccelerationStructureGeometryTrianglesDataKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureGeometryTrianglesDataKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TransformMatrixKHR ) == sizeof( VkTransformMatrixKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TransformMatrixKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildGeometryInfoKHR ) == sizeof( VkAccelerationStructureBuildGeometryInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureBuildGeometryInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryAabbsDataKHR ) == sizeof( VkAccelerationStructureGeometryAabbsDataKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureGeometryAabbsDataKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureInstanceKHR ) == sizeof( VkAccelerationStructureInstanceKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureInstanceKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryInstancesDataKHR ) == - sizeof( VkAccelerationStructureGeometryInstancesDataKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureGeometryInstancesDataKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryDataKHR ) == sizeof( VkAccelerationStructureGeometryDataKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureGeometryDataKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryKHR ) == sizeof( VkAccelerationStructureGeometryKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureGeometryKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoKHR ) == sizeof( VkAccelerationStructureCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureKHR ) == sizeof( VkWriteDescriptorSetAccelerationStructureKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "WriteDescriptorSetAccelerationStructureKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructureFeaturesKHR ) == - sizeof( VkPhysicalDeviceAccelerationStructureFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceAccelerationStructureFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAccelerationStructurePropertiesKHR ) == - sizeof( VkPhysicalDeviceAccelerationStructurePropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceAccelerationStructurePropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureDeviceAddressInfoKHR ) == sizeof( VkAccelerationStructureDeviceAddressInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureDeviceAddressInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureVersionInfoKHR ) == sizeof( VkAccelerationStructureVersionInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureVersionInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureToMemoryInfoKHR ) == sizeof( VkCopyAccelerationStructureToMemoryInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyAccelerationStructureToMemoryInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToAccelerationStructureInfoKHR ) == sizeof( VkCopyMemoryToAccelerationStructureInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyMemoryToAccelerationStructureInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyAccelerationStructureInfoKHR ) == sizeof( VkCopyAccelerationStructureInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyAccelerationStructureInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureBuildSizesInfoKHR ) == sizeof( VkAccelerationStructureBuildSizesInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureBuildSizesInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_ray_tracing_pipeline === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoKHR ) == sizeof( VkRayTracingShaderGroupCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RayTracingShaderGroupCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoKHR ) == sizeof( VkRayTracingPipelineCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RayTracingPipelineCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelineFeaturesKHR ) == - sizeof( VkPhysicalDeviceRayTracingPipelineFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingPipelineFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPipelinePropertiesKHR ) == - sizeof( VkPhysicalDeviceRayTracingPipelinePropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingPipelinePropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRegionKHR ) == sizeof( VkStridedDeviceAddressRegionKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "StridedDeviceAddressRegionKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommandKHR ) == sizeof( VkTraceRaysIndirectCommandKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TraceRaysIndirectCommandKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingPipelineInterfaceCreateInfoKHR ) == sizeof( VkRayTracingPipelineInterfaceCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RayTracingPipelineInterfaceCreateInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_ray_query === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayQueryFeaturesKHR ) == sizeof( VkPhysicalDeviceRayQueryFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayQueryFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_framebuffer_mixed_samples === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCoverageModulationStateCreateInfoNV ) == - sizeof( VkPipelineCoverageModulationStateCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineCoverageModulationStateCreateInfoNV is not nothrow_move_constructible!" ); - -//=== VK_NV_shader_sm_builtins === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsPropertiesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderSMBuiltinsPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSMBuiltinsFeaturesNV ) == sizeof( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderSMBuiltinsFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_image_drm_format_modifier === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesListEXT ) == sizeof( VkDrmFormatModifierPropertiesListEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DrmFormatModifierPropertiesListEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesEXT ) == sizeof( VkDrmFormatModifierPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DrmFormatModifierPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageDrmFormatModifierInfoEXT ) == - sizeof( VkPhysicalDeviceImageDrmFormatModifierInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageDrmFormatModifierInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierListCreateInfoEXT ) == sizeof( VkImageDrmFormatModifierListCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageDrmFormatModifierListCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierExplicitCreateInfoEXT ) == - sizeof( VkImageDrmFormatModifierExplicitCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageDrmFormatModifierExplicitCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageDrmFormatModifierPropertiesEXT ) == sizeof( VkImageDrmFormatModifierPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageDrmFormatModifierPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrmFormatModifierPropertiesList2EXT ) == sizeof( VkDrmFormatModifierPropertiesList2EXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DrmFormatModifierPropertiesList2EXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrmFormatModifierProperties2EXT ) == sizeof( VkDrmFormatModifierProperties2EXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DrmFormatModifierProperties2EXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_validation_cache === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheEXT ) == sizeof( VkValidationCacheEXT ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "ValidationCacheEXT is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ValidationCacheEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationCacheCreateInfoEXT ) == sizeof( VkValidationCacheCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ValidationCacheCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModuleValidationCacheCreateInfoEXT ) == sizeof( VkShaderModuleValidationCacheCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ShaderModuleValidationCacheCreateInfoEXT is not nothrow_move_constructible!" ); - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) -//=== VK_KHR_portability_subset === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetFeaturesKHR ) == sizeof( VkPhysicalDevicePortabilitySubsetFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePortabilitySubsetFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePortabilitySubsetPropertiesKHR ) == - sizeof( VkPhysicalDevicePortabilitySubsetPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePortabilitySubsetPropertiesKHR is not nothrow_move_constructible!" ); -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -//=== VK_NV_shading_rate_image === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShadingRatePaletteNV ) == sizeof( VkShadingRatePaletteNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ShadingRatePaletteNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportShadingRateImageStateCreateInfoNV ) == - sizeof( VkPipelineViewportShadingRateImageStateCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineViewportShadingRateImageStateCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImageFeaturesNV ) == sizeof( VkPhysicalDeviceShadingRateImageFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShadingRateImageFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShadingRateImagePropertiesNV ) == sizeof( VkPhysicalDeviceShadingRateImagePropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShadingRateImagePropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CoarseSampleLocationNV ) == sizeof( VkCoarseSampleLocationNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CoarseSampleLocationNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CoarseSampleOrderCustomNV ) == sizeof( VkCoarseSampleOrderCustomNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CoarseSampleOrderCustomNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportCoarseSampleOrderStateCreateInfoNV ) == - sizeof( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineViewportCoarseSampleOrderStateCreateInfoNV is not nothrow_move_constructible!" ); - -//=== VK_NV_ray_tracing === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureNV ) == sizeof( VkAccelerationStructureNV ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "AccelerationStructureNV is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingShaderGroupCreateInfoNV ) == sizeof( VkRayTracingShaderGroupCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RayTracingShaderGroupCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingPipelineCreateInfoNV ) == sizeof( VkRayTracingPipelineCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RayTracingPipelineCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeometryTrianglesNV ) == sizeof( VkGeometryTrianglesNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GeometryTrianglesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeometryAABBNV ) == sizeof( VkGeometryAABBNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GeometryAABBNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeometryDataNV ) == sizeof( VkGeometryDataNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GeometryDataNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeometryNV ) == sizeof( VkGeometryNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "GeometryNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureInfoNV ) == sizeof( VkAccelerationStructureInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureCreateInfoNV ) == sizeof( VkAccelerationStructureCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindAccelerationStructureMemoryInfoNV ) == sizeof( VkBindAccelerationStructureMemoryInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindAccelerationStructureMemoryInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetAccelerationStructureNV ) == sizeof( VkWriteDescriptorSetAccelerationStructureNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "WriteDescriptorSetAccelerationStructureNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMemoryRequirementsInfoNV ) == - sizeof( VkAccelerationStructureMemoryRequirementsInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureMemoryRequirementsInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPropertiesNV ) == sizeof( VkPhysicalDeviceRayTracingPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingPropertiesNV is not nothrow_move_constructible!" ); - -//=== VK_NV_representative_fragment_test === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRepresentativeFragmentTestFeaturesNV ) == - sizeof( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRepresentativeFragmentTestFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRepresentativeFragmentTestStateCreateInfoNV ) == - sizeof( VkPipelineRepresentativeFragmentTestStateCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineRepresentativeFragmentTestStateCreateInfoNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_filter_cubic === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewImageFormatInfoEXT ) == sizeof( VkPhysicalDeviceImageViewImageFormatInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageViewImageFormatInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FilterCubicImageViewImageFormatPropertiesEXT ) == - sizeof( VkFilterCubicImageViewImageFormatPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FilterCubicImageViewImageFormatPropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_external_memory_host === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryHostPointerInfoEXT ) == sizeof( VkImportMemoryHostPointerInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportMemoryHostPointerInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryHostPointerPropertiesEXT ) == sizeof( VkMemoryHostPointerPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryHostPointerPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryHostPropertiesEXT ) == - sizeof( VkPhysicalDeviceExternalMemoryHostPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExternalMemoryHostPropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_shader_clock === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderClockFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderClockFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderClockFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_AMD_pipeline_compiler_control === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCompilerControlCreateInfoAMD ) == sizeof( VkPipelineCompilerControlCreateInfoAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineCompilerControlCreateInfoAMD is not nothrow_move_constructible!" ); - -//=== VK_AMD_shader_core_properties === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesAMD ) == sizeof( VkPhysicalDeviceShaderCorePropertiesAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderCorePropertiesAMD is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_decode_h265 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265ProfileInfoKHR ) == sizeof( VkVideoDecodeH265ProfileInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH265ProfileInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265CapabilitiesKHR ) == sizeof( VkVideoDecodeH265CapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH265CapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersCreateInfoKHR ) == - sizeof( VkVideoDecodeH265SessionParametersCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH265SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265SessionParametersAddInfoKHR ) == sizeof( VkVideoDecodeH265SessionParametersAddInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH265SessionParametersAddInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265PictureInfoKHR ) == sizeof( VkVideoDecodeH265PictureInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH265PictureInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265DpbSlotInfoKHR ) == sizeof( VkVideoDecodeH265DpbSlotInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH265DpbSlotInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_AMD_memory_overallocation_behavior === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemoryOverallocationCreateInfoAMD ) == sizeof( VkDeviceMemoryOverallocationCreateInfoAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceMemoryOverallocationCreateInfoAMD is not nothrow_move_constructible!" ); - -//=== VK_EXT_vertex_attribute_divisor === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeDivisorPropertiesEXT ) == - sizeof( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVertexAttributeDivisorPropertiesEXT is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_GGP ) -//=== VK_GGP_frame_token === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentFrameTokenGGP ) == sizeof( VkPresentFrameTokenGGP ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PresentFrameTokenGGP is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_GGP*/ - -//=== VK_NV_mesh_shader === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesNV ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMeshShaderFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesNV ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMeshShaderPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandNV ) == sizeof( VkDrawMeshTasksIndirectCommandNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DrawMeshTasksIndirectCommandNV is not nothrow_move_constructible!" ); - -//=== VK_NV_shader_image_footprint === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageFootprintFeaturesNV ) == - sizeof( VkPhysicalDeviceShaderImageFootprintFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderImageFootprintFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_NV_scissor_exclusive === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportExclusiveScissorStateCreateInfoNV ) == - sizeof( VkPipelineViewportExclusiveScissorStateCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineViewportExclusiveScissorStateCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExclusiveScissorFeaturesNV ) == sizeof( VkPhysicalDeviceExclusiveScissorFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExclusiveScissorFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_NV_device_diagnostic_checkpoints === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointPropertiesNV ) == sizeof( VkQueueFamilyCheckpointPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueueFamilyCheckpointPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CheckpointDataNV ) == sizeof( VkCheckpointDataNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CheckpointDataNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyCheckpointProperties2NV ) == sizeof( VkQueueFamilyCheckpointProperties2NV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueueFamilyCheckpointProperties2NV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CheckpointData2NV ) == sizeof( VkCheckpointData2NV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CheckpointData2NV is not nothrow_move_constructible!" ); - -//=== VK_EXT_present_timing === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentTimingFeaturesEXT ) == sizeof( VkPhysicalDevicePresentTimingFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePresentTimingFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimingSurfaceCapabilitiesEXT ) == sizeof( VkPresentTimingSurfaceCapabilitiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PresentTimingSurfaceCapabilitiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainCalibratedTimestampInfoEXT ) == sizeof( VkSwapchainCalibratedTimestampInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainCalibratedTimestampInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainTimingPropertiesEXT ) == sizeof( VkSwapchainTimingPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainTimingPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainTimeDomainPropertiesEXT ) == sizeof( VkSwapchainTimeDomainPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainTimeDomainPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PastPresentationTimingInfoEXT ) == sizeof( VkPastPresentationTimingInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PastPresentationTimingInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PastPresentationTimingPropertiesEXT ) == sizeof( VkPastPresentationTimingPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PastPresentationTimingPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PastPresentationTimingEXT ) == sizeof( VkPastPresentationTimingEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PastPresentationTimingEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimingsInfoEXT ) == sizeof( VkPresentTimingsInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PresentTimingsInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentTimingInfoEXT ) == sizeof( VkPresentTimingInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PresentTimingInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentStageTimeEXT ) == sizeof( VkPresentStageTimeEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PresentStageTimeEXT is not nothrow_move_constructible!" ); - -//=== VK_INTEL_shader_integer_functions2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ) == - sizeof( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL is not nothrow_move_constructible!" ); - -//=== VK_INTEL_performance_query === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL ) == sizeof( VkPerformanceConfigurationINTEL ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "PerformanceConfigurationINTEL is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceConfigurationINTEL is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceValueDataINTEL ) == sizeof( VkPerformanceValueDataINTEL ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceValueDataINTEL is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceValueINTEL ) == sizeof( VkPerformanceValueINTEL ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceValueINTEL is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::InitializePerformanceApiInfoINTEL ) == sizeof( VkInitializePerformanceApiInfoINTEL ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "InitializePerformanceApiInfoINTEL is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPoolPerformanceQueryCreateInfoINTEL ) == sizeof( VkQueryPoolPerformanceQueryCreateInfoINTEL ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueryPoolPerformanceQueryCreateInfoINTEL is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceMarkerInfoINTEL ) == sizeof( VkPerformanceMarkerInfoINTEL ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceMarkerInfoINTEL is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceStreamMarkerInfoINTEL ) == sizeof( VkPerformanceStreamMarkerInfoINTEL ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceStreamMarkerInfoINTEL is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceOverrideInfoINTEL ) == sizeof( VkPerformanceOverrideInfoINTEL ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceOverrideInfoINTEL is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceConfigurationAcquireInfoINTEL ) == sizeof( VkPerformanceConfigurationAcquireInfoINTEL ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceConfigurationAcquireInfoINTEL is not nothrow_move_constructible!" ); - -//=== VK_EXT_pci_bus_info === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePCIBusInfoPropertiesEXT ) == sizeof( VkPhysicalDevicePCIBusInfoPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePCIBusInfoPropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_AMD_display_native_hdr === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayNativeHdrSurfaceCapabilitiesAMD ) == sizeof( VkDisplayNativeHdrSurfaceCapabilitiesAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayNativeHdrSurfaceCapabilitiesAMD is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainDisplayNativeHdrCreateInfoAMD ) == sizeof( VkSwapchainDisplayNativeHdrCreateInfoAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainDisplayNativeHdrCreateInfoAMD is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_FUCHSIA ) -//=== VK_FUCHSIA_imagepipe_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImagePipeSurfaceCreateInfoFUCHSIA ) == sizeof( VkImagePipeSurfaceCreateInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImagePipeSurfaceCreateInfoFUCHSIA is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) -//=== VK_EXT_metal_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MetalSurfaceCreateInfoEXT ) == sizeof( VkMetalSurfaceCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MetalSurfaceCreateInfoEXT is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -//=== VK_EXT_fragment_density_map === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapFeaturesEXT ) == - sizeof( VkPhysicalDeviceFragmentDensityMapFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentDensityMapFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapPropertiesEXT ) == - sizeof( VkPhysicalDeviceFragmentDensityMapPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentDensityMapPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapCreateInfoEXT ) == sizeof( VkRenderPassFragmentDensityMapCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassFragmentDensityMapCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingFragmentDensityMapAttachmentInfoEXT ) == - sizeof( VkRenderingFragmentDensityMapAttachmentInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderingFragmentDensityMapAttachmentInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_fragment_shading_rate === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FragmentShadingRateAttachmentInfoKHR ) == sizeof( VkFragmentShadingRateAttachmentInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FragmentShadingRateAttachmentInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateStateCreateInfoKHR ) == - sizeof( VkPipelineFragmentShadingRateStateCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineFragmentShadingRateStateCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateFeaturesKHR ) == - sizeof( VkPhysicalDeviceFragmentShadingRateFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentShadingRateFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRatePropertiesKHR ) == - sizeof( VkPhysicalDeviceFragmentShadingRatePropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentShadingRatePropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateKHR ) == sizeof( VkPhysicalDeviceFragmentShadingRateKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentShadingRateKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingFragmentShadingRateAttachmentInfoKHR ) == - sizeof( VkRenderingFragmentShadingRateAttachmentInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderingFragmentShadingRateAttachmentInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_AMD_shader_core_properties2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreProperties2AMD ) == sizeof( VkPhysicalDeviceShaderCoreProperties2AMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderCoreProperties2AMD is not nothrow_move_constructible!" ); - -//=== VK_AMD_device_coherent_memory === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoherentMemoryFeaturesAMD ) == sizeof( VkPhysicalDeviceCoherentMemoryFeaturesAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCoherentMemoryFeaturesAMD is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_image_atomic_int64 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderImageAtomicInt64FeaturesEXT ) == - sizeof( VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_shader_quad_control === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderQuadControlFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderQuadControlFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderQuadControlFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_EXT_memory_budget === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryBudgetPropertiesEXT ) == sizeof( VkPhysicalDeviceMemoryBudgetPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMemoryBudgetPropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_memory_priority === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryPriorityFeaturesEXT ) == sizeof( VkPhysicalDeviceMemoryPriorityFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMemoryPriorityFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryPriorityAllocateInfoEXT ) == sizeof( VkMemoryPriorityAllocateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryPriorityAllocateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_surface_protected_capabilities === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceProtectedCapabilitiesKHR ) == sizeof( VkSurfaceProtectedCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceProtectedCapabilitiesKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_dedicated_allocation_image_aliasing === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ) == - sizeof( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_buffer_device_address === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceBufferDeviceAddressFeaturesEXT ) == - sizeof( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceBufferDeviceAddressFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferDeviceAddressCreateInfoEXT ) == sizeof( VkBufferDeviceAddressCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferDeviceAddressCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_validation_features === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ValidationFeaturesEXT ) == sizeof( VkValidationFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ValidationFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_present_wait === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWaitFeaturesKHR ) == sizeof( VkPhysicalDevicePresentWaitFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePresentWaitFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_cooperative_matrix === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesNV ) == sizeof( VkCooperativeMatrixPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CooperativeMatrixPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCooperativeMatrixFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesNV ) == - sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCooperativeMatrixPropertiesNV is not nothrow_move_constructible!" ); - -//=== VK_NV_coverage_reduction_mode === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCoverageReductionModeFeaturesNV ) == - sizeof( VkPhysicalDeviceCoverageReductionModeFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCoverageReductionModeFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCoverageReductionStateCreateInfoNV ) == sizeof( VkPipelineCoverageReductionStateCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineCoverageReductionStateCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FramebufferMixedSamplesCombinationNV ) == sizeof( VkFramebufferMixedSamplesCombinationNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FramebufferMixedSamplesCombinationNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_fragment_shader_interlock === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderInterlockFeaturesEXT ) == - sizeof( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentShaderInterlockFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_ycbcr_image_arrays === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrImageArraysFeaturesEXT ) == sizeof( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceYcbcrImageArraysFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_provoking_vertex === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexFeaturesEXT ) == sizeof( VkPhysicalDeviceProvokingVertexFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceProvokingVertexFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceProvokingVertexPropertiesEXT ) == sizeof( VkPhysicalDeviceProvokingVertexPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceProvokingVertexPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineRasterizationProvokingVertexStateCreateInfoEXT ) == - sizeof( VkPipelineRasterizationProvokingVertexStateCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineRasterizationProvokingVertexStateCreateInfoEXT is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) -//=== VK_EXT_full_screen_exclusive === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveInfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceFullScreenExclusiveInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesFullScreenExclusiveEXT ) == sizeof( VkSurfaceCapabilitiesFullScreenExclusiveEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceCapabilitiesFullScreenExclusiveEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceFullScreenExclusiveWin32InfoEXT ) == sizeof( VkSurfaceFullScreenExclusiveWin32InfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceFullScreenExclusiveWin32InfoEXT is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -//=== VK_EXT_headless_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HeadlessSurfaceCreateInfoEXT ) == sizeof( VkHeadlessSurfaceCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "HeadlessSurfaceCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_atomic_float === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloatFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderAtomicFloatFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_extended_dynamic_state === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicStateFeaturesEXT ) == - sizeof( VkPhysicalDeviceExtendedDynamicStateFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExtendedDynamicStateFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_deferred_host_operations === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeferredOperationKHR ) == sizeof( VkDeferredOperationKHR ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "DeferredOperationKHR is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeferredOperationKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_pipeline_executable_properties === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ) == - sizeof( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineInfoKHR ) == sizeof( VkPipelineInfoKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineExecutablePropertiesKHR ) == sizeof( VkPipelineExecutablePropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineExecutablePropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineExecutableInfoKHR ) == sizeof( VkPipelineExecutableInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineExecutableInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticValueKHR ) == sizeof( VkPipelineExecutableStatisticValueKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineExecutableStatisticValueKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineExecutableStatisticKHR ) == sizeof( VkPipelineExecutableStatisticKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineExecutableStatisticKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineExecutableInternalRepresentationKHR ) == - sizeof( VkPipelineExecutableInternalRepresentationKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineExecutableInternalRepresentationKHR is not nothrow_move_constructible!" ); - -//=== VK_EXT_map_memory_placed === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedFeaturesEXT ) == sizeof( VkPhysicalDeviceMapMemoryPlacedFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMapMemoryPlacedFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMapMemoryPlacedPropertiesEXT ) == sizeof( VkPhysicalDeviceMapMemoryPlacedPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMapMemoryPlacedPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMapPlacedInfoEXT ) == sizeof( VkMemoryMapPlacedInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryMapPlacedInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_atomic_float2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat2FeaturesEXT ) == - sizeof( VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderAtomicFloat2FeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_NV_device_generated_commands === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV ) == sizeof( VkIndirectCommandsLayoutNV ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "IndirectCommandsLayoutNV is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsLayoutNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesNV ) == - sizeof( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDeviceGeneratedCommandsPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV ) == - sizeof( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDeviceGeneratedCommandsFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GraphicsShaderGroupCreateInfoNV ) == sizeof( VkGraphicsShaderGroupCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GraphicsShaderGroupCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GraphicsPipelineShaderGroupsCreateInfoNV ) == sizeof( VkGraphicsPipelineShaderGroupsCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GraphicsPipelineShaderGroupsCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindShaderGroupIndirectCommandNV ) == sizeof( VkBindShaderGroupIndirectCommandNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindShaderGroupIndirectCommandNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandNV ) == sizeof( VkBindIndexBufferIndirectCommandNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindIndexBufferIndirectCommandNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandNV ) == sizeof( VkBindVertexBufferIndirectCommandNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindVertexBufferIndirectCommandNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetStateFlagsIndirectCommandNV ) == sizeof( VkSetStateFlagsIndirectCommandNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SetStateFlagsIndirectCommandNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsStreamNV ) == sizeof( VkIndirectCommandsStreamNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsStreamNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenNV ) == sizeof( VkIndirectCommandsLayoutTokenNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsLayoutTokenNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoNV ) == sizeof( VkIndirectCommandsLayoutCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsLayoutCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoNV ) == sizeof( VkGeneratedCommandsInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GeneratedCommandsInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoNV ) == sizeof( VkGeneratedCommandsMemoryRequirementsInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GeneratedCommandsMemoryRequirementsInfoNV is not nothrow_move_constructible!" ); - -//=== VK_NV_inherited_viewport_scissor === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceInheritedViewportScissorFeaturesNV ) == - sizeof( VkPhysicalDeviceInheritedViewportScissorFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceInheritedViewportScissorFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceViewportScissorInfoNV ) == - sizeof( VkCommandBufferInheritanceViewportScissorInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CommandBufferInheritanceViewportScissorInfoNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_texel_buffer_alignment === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTexelBufferAlignmentFeaturesEXT ) == - sizeof( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTexelBufferAlignmentFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_QCOM_render_pass_transform === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassTransformBeginInfoQCOM ) == sizeof( VkRenderPassTransformBeginInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassTransformBeginInfoQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CommandBufferInheritanceRenderPassTransformInfoQCOM ) == - sizeof( VkCommandBufferInheritanceRenderPassTransformInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CommandBufferInheritanceRenderPassTransformInfoQCOM is not nothrow_move_constructible!" ); - -//=== VK_EXT_depth_bias_control === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthBiasControlFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthBiasControlFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDepthBiasControlFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DepthBiasInfoEXT ) == sizeof( VkDepthBiasInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DepthBiasInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DepthBiasRepresentationInfoEXT ) == sizeof( VkDepthBiasRepresentationInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DepthBiasRepresentationInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_device_memory_report === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceMemoryReportFeaturesEXT ) == - sizeof( VkPhysicalDeviceDeviceMemoryReportFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDeviceMemoryReportFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceDeviceMemoryReportCreateInfoEXT ) == sizeof( VkDeviceDeviceMemoryReportCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceDeviceMemoryReportCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceMemoryReportCallbackDataEXT ) == sizeof( VkDeviceMemoryReportCallbackDataEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceMemoryReportCallbackDataEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_custom_border_color === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCustomBorderColorCreateInfoEXT ) == sizeof( VkSamplerCustomBorderColorCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerCustomBorderColorCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorPropertiesEXT ) == - sizeof( VkPhysicalDeviceCustomBorderColorPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCustomBorderColorPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomBorderColorFeaturesEXT ) == sizeof( VkPhysicalDeviceCustomBorderColorFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCustomBorderColorFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_texture_compression_astc_3d === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTextureCompressionASTC3DFeaturesEXT ) == - sizeof( VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTextureCompressionASTC3DFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_pipeline_library === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineLibraryCreateInfoKHR ) == sizeof( VkPipelineLibraryCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineLibraryCreateInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_present_barrier === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentBarrierFeaturesNV ) == sizeof( VkPhysicalDevicePresentBarrierFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePresentBarrierFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentBarrierNV ) == sizeof( VkSurfaceCapabilitiesPresentBarrierNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceCapabilitiesPresentBarrierNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainPresentBarrierCreateInfoNV ) == sizeof( VkSwapchainPresentBarrierCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainPresentBarrierCreateInfoNV is not nothrow_move_constructible!" ); - -//=== VK_KHR_present_id === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentIdKHR ) == sizeof( VkPresentIdKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PresentIdKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentIdFeaturesKHR ) == sizeof( VkPhysicalDevicePresentIdFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePresentIdFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_encode_queue === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeInfoKHR ) == sizeof( VkVideoEncodeInfoKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeCapabilitiesKHR ) == sizeof( VkVideoEncodeCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryPoolVideoEncodeFeedbackCreateInfoKHR ) == sizeof( VkQueryPoolVideoEncodeFeedbackCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueryPoolVideoEncodeFeedbackCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeUsageInfoKHR ) == sizeof( VkVideoEncodeUsageInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeUsageInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlInfoKHR ) == sizeof( VkVideoEncodeRateControlInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeRateControlInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeRateControlLayerInfoKHR ) == sizeof( VkVideoEncodeRateControlLayerInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeRateControlLayerInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQualityLevelInfoKHR ) == - sizeof( VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVideoEncodeQualityLevelInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelPropertiesKHR ) == sizeof( VkVideoEncodeQualityLevelPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeQualityLevelPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQualityLevelInfoKHR ) == sizeof( VkVideoEncodeQualityLevelInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeQualityLevelInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersGetInfoKHR ) == sizeof( VkVideoEncodeSessionParametersGetInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeSessionParametersGetInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeSessionParametersFeedbackInfoKHR ) == - sizeof( VkVideoEncodeSessionParametersFeedbackInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeSessionParametersFeedbackInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_device_diagnostics_config === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDiagnosticsConfigFeaturesNV ) == sizeof( VkPhysicalDeviceDiagnosticsConfigFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDiagnosticsConfigFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigCreateInfoNV ) == sizeof( VkDeviceDiagnosticsConfigCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceDiagnosticsConfigCreateInfoNV is not nothrow_move_constructible!" ); - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) -//=== VK_NV_cuda_kernel_launch === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CudaModuleNV ) == sizeof( VkCudaModuleNV ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CudaModuleNV is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "CudaModuleNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CudaFunctionNV ) == sizeof( VkCudaFunctionNV ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "CudaFunctionNV is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CudaFunctionNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CudaModuleCreateInfoNV ) == sizeof( VkCudaModuleCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CudaModuleCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CudaFunctionCreateInfoNV ) == sizeof( VkCudaFunctionCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CudaFunctionCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV ) == sizeof( VkCudaLaunchInfoNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CudaLaunchInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchFeaturesNV ) == sizeof( VkPhysicalDeviceCudaKernelLaunchFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCudaKernelLaunchFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV ) == sizeof( VkPhysicalDeviceCudaKernelLaunchPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCudaKernelLaunchPropertiesNV is not nothrow_move_constructible!" ); -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -//=== VK_QCOM_tile_shading === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM ) == sizeof( VkPhysicalDeviceTileShadingFeaturesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTileShadingFeaturesQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM ) == sizeof( VkPhysicalDeviceTileShadingPropertiesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTileShadingPropertiesQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM ) == sizeof( VkRenderPassTileShadingCreateInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassTileShadingCreateInfoQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM ) == sizeof( VkPerTileBeginInfoQCOM ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerTileBeginInfoQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM ) == sizeof( VkPerTileEndInfoQCOM ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerTileEndInfoQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM ) == sizeof( VkDispatchTileInfoQCOM ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DispatchTileInfoQCOM is not nothrow_move_constructible!" ); - -//=== VK_NV_low_latency === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV ) == sizeof( VkQueryLowLatencySupportNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueryLowLatencySupportNV is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_METAL_EXT ) -//=== VK_EXT_metal_objects === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalObjectCreateInfoEXT ) == sizeof( VkExportMetalObjectCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMetalObjectCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalObjectsInfoEXT ) == sizeof( VkExportMetalObjectsInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMetalObjectsInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalDeviceInfoEXT ) == sizeof( VkExportMetalDeviceInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMetalDeviceInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalCommandQueueInfoEXT ) == sizeof( VkExportMetalCommandQueueInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMetalCommandQueueInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalBufferInfoEXT ) == sizeof( VkExportMetalBufferInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMetalBufferInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMetalBufferInfoEXT ) == sizeof( VkImportMetalBufferInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportMetalBufferInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalTextureInfoEXT ) == sizeof( VkExportMetalTextureInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMetalTextureInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMetalTextureInfoEXT ) == sizeof( VkImportMetalTextureInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportMetalTextureInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalIOSurfaceInfoEXT ) == sizeof( VkExportMetalIOSurfaceInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMetalIOSurfaceInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMetalIOSurfaceInfoEXT ) == sizeof( VkImportMetalIOSurfaceInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportMetalIOSurfaceInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExportMetalSharedEventInfoEXT ) == sizeof( VkExportMetalSharedEventInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExportMetalSharedEventInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMetalSharedEventInfoEXT ) == sizeof( VkImportMetalSharedEventInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportMetalSharedEventInfoEXT is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -//=== VK_EXT_descriptor_buffer === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferPropertiesEXT ) == - sizeof( VkPhysicalDeviceDescriptorBufferPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorBufferPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT ) == - sizeof( VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferFeaturesEXT ) == sizeof( VkPhysicalDeviceDescriptorBufferFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorBufferFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorAddressInfoEXT ) == sizeof( VkDescriptorAddressInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorAddressInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingInfoEXT ) == sizeof( VkDescriptorBufferBindingInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorBufferBindingInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorBufferBindingPushDescriptorBufferHandleEXT ) == - sizeof( VkDescriptorBufferBindingPushDescriptorBufferHandleEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorBufferBindingPushDescriptorBufferHandleEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorDataEXT ) == sizeof( VkDescriptorDataEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorDataEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorGetInfoEXT ) == sizeof( VkDescriptorGetInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorGetInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCaptureDescriptorDataInfoEXT ) == sizeof( VkBufferCaptureDescriptorDataInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferCaptureDescriptorDataInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCaptureDescriptorDataInfoEXT ) == sizeof( VkImageCaptureDescriptorDataInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageCaptureDescriptorDataInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewCaptureDescriptorDataInfoEXT ) == sizeof( VkImageViewCaptureDescriptorDataInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageViewCaptureDescriptorDataInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCaptureDescriptorDataInfoEXT ) == sizeof( VkSamplerCaptureDescriptorDataInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerCaptureDescriptorDataInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpaqueCaptureDescriptorDataCreateInfoEXT ) == sizeof( VkOpaqueCaptureDescriptorDataCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "OpaqueCaptureDescriptorDataCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureCaptureDescriptorDataInfoEXT ) == - sizeof( VkAccelerationStructureCaptureDescriptorDataInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureCaptureDescriptorDataInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_graphics_pipeline_library === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT ) == - sizeof( VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT ) == - sizeof( VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GraphicsPipelineLibraryCreateInfoEXT ) == sizeof( VkGraphicsPipelineLibraryCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GraphicsPipelineLibraryCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_AMD_shader_early_and_late_fragment_tests === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ) == - sizeof( VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD is not nothrow_move_constructible!" ); - -//=== VK_KHR_fragment_shader_barycentric === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR ) == - sizeof( VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentShaderBarycentricFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShaderBarycentricPropertiesKHR ) == - sizeof( VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentShaderBarycentricPropertiesKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_shader_subgroup_uniform_control_flow === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ) == - sizeof( VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_fragment_shading_rate_enums === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsFeaturesNV ) == - sizeof( VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentShadingRateEnumsFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentShadingRateEnumsPropertiesNV ) == - sizeof( VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentShadingRateEnumsPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineFragmentShadingRateEnumStateCreateInfoNV ) == - sizeof( VkPipelineFragmentShadingRateEnumStateCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineFragmentShadingRateEnumStateCreateInfoNV is not nothrow_move_constructible!" ); - -//=== VK_NV_ray_tracing_motion_blur === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryMotionTrianglesDataNV ) == - sizeof( VkAccelerationStructureGeometryMotionTrianglesDataNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureGeometryMotionTrianglesDataNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInfoNV ) == sizeof( VkAccelerationStructureMotionInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureMotionInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceNV ) == sizeof( VkAccelerationStructureMotionInstanceNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureMotionInstanceNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMotionInstanceDataNV ) == sizeof( VkAccelerationStructureMotionInstanceDataNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureMotionInstanceDataNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureMatrixMotionInstanceNV ) == - sizeof( VkAccelerationStructureMatrixMotionInstanceNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureMatrixMotionInstanceNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureSRTMotionInstanceNV ) == sizeof( VkAccelerationStructureSRTMotionInstanceNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureSRTMotionInstanceNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SRTDataNV ) == sizeof( VkSRTDataNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "SRTDataNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMotionBlurFeaturesNV ) == - sizeof( VkPhysicalDeviceRayTracingMotionBlurFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingMotionBlurFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_mesh_shader === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderFeaturesEXT ) == sizeof( VkPhysicalDeviceMeshShaderFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMeshShaderFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMeshShaderPropertiesEXT ) == sizeof( VkPhysicalDeviceMeshShaderPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMeshShaderPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawMeshTasksIndirectCommandEXT ) == sizeof( VkDrawMeshTasksIndirectCommandEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DrawMeshTasksIndirectCommandEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_ycbcr_2plane_444_formats === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT ) == - sizeof( VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_fragment_density_map2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2FeaturesEXT ) == - sizeof( VkPhysicalDeviceFragmentDensityMap2FeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentDensityMap2FeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMap2PropertiesEXT ) == - sizeof( VkPhysicalDeviceFragmentDensityMap2PropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentDensityMap2PropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_QCOM_rotated_copy_commands === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyCommandTransformInfoQCOM ) == sizeof( VkCopyCommandTransformInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyCommandTransformInfoQCOM is not nothrow_move_constructible!" ); - -//=== VK_KHR_workgroup_memory_explicit_layout === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ) == - sizeof( VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_EXT_image_compression_control === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlFeaturesEXT ) == - sizeof( VkPhysicalDeviceImageCompressionControlFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageCompressionControlFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCompressionControlEXT ) == sizeof( VkImageCompressionControlEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageCompressionControlEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageCompressionPropertiesEXT ) == sizeof( VkImageCompressionPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageCompressionPropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_attachment_feedback_loop_layout === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ) == - sizeof( VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_4444_formats === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevice4444FormatsFeaturesEXT ) == sizeof( VkPhysicalDevice4444FormatsFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevice4444FormatsFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_device_fault === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFaultFeaturesEXT ) == sizeof( VkPhysicalDeviceFaultFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFaultFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultCountsEXT ) == sizeof( VkDeviceFaultCountsEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceFaultCountsEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultInfoEXT ) == sizeof( VkDeviceFaultInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceFaultInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultAddressInfoEXT ) == sizeof( VkDeviceFaultAddressInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceFaultAddressInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultVendorInfoEXT ) == sizeof( VkDeviceFaultVendorInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceFaultVendorInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceFaultVendorBinaryHeaderVersionOneEXT ) == sizeof( VkDeviceFaultVendorBinaryHeaderVersionOneEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceFaultVendorBinaryHeaderVersionOneEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_rgba10x6_formats === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRGBA10X6FormatsFeaturesEXT ) == sizeof( VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRGBA10X6FormatsFeaturesEXT is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) -//=== VK_EXT_directfb_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DirectFBSurfaceCreateInfoEXT ) == sizeof( VkDirectFBSurfaceCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DirectFBSurfaceCreateInfoEXT is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - -//=== VK_EXT_vertex_input_dynamic_state === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexInputDynamicStateFeaturesEXT ) == - sizeof( VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVertexInputDynamicStateFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputBindingDescription2EXT ) == sizeof( VkVertexInputBindingDescription2EXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VertexInputBindingDescription2EXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VertexInputAttributeDescription2EXT ) == sizeof( VkVertexInputAttributeDescription2EXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VertexInputAttributeDescription2EXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_physical_device_drm === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDrmPropertiesEXT ) == sizeof( VkPhysicalDeviceDrmPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDrmPropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_device_address_binding_report === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAddressBindingReportFeaturesEXT ) == - sizeof( VkPhysicalDeviceAddressBindingReportFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceAddressBindingReportFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceAddressBindingCallbackDataEXT ) == sizeof( VkDeviceAddressBindingCallbackDataEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceAddressBindingCallbackDataEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_depth_clip_control === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClipControlFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClipControlFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDepthClipControlFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClipControlCreateInfoEXT ) == - sizeof( VkPipelineViewportDepthClipControlCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineViewportDepthClipControlCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_primitive_topology_list_restart === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT ) == - sizeof( VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_FUCHSIA ) -//=== VK_FUCHSIA_external_memory === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryZirconHandleInfoFUCHSIA ) == sizeof( VkImportMemoryZirconHandleInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportMemoryZirconHandleInfoFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryZirconHandlePropertiesFUCHSIA ) == sizeof( VkMemoryZirconHandlePropertiesFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryZirconHandlePropertiesFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetZirconHandleInfoFUCHSIA ) == sizeof( VkMemoryGetZirconHandleInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryGetZirconHandleInfoFUCHSIA is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) -//=== VK_FUCHSIA_external_semaphore === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportSemaphoreZirconHandleInfoFUCHSIA ) == sizeof( VkImportSemaphoreZirconHandleInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportSemaphoreZirconHandleInfoFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SemaphoreGetZirconHandleInfoFUCHSIA ) == sizeof( VkSemaphoreGetZirconHandleInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SemaphoreGetZirconHandleInfoFUCHSIA is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) -//=== VK_FUCHSIA_buffer_collection === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA ) == sizeof( VkBufferCollectionFUCHSIA ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "BufferCollectionFUCHSIA is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferCollectionFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionCreateInfoFUCHSIA ) == sizeof( VkBufferCollectionCreateInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferCollectionCreateInfoFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryBufferCollectionFUCHSIA ) == sizeof( VkImportMemoryBufferCollectionFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportMemoryBufferCollectionFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionImageCreateInfoFUCHSIA ) == sizeof( VkBufferCollectionImageCreateInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferCollectionImageCreateInfoFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferConstraintsInfoFUCHSIA ) == sizeof( VkBufferConstraintsInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferConstraintsInfoFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionBufferCreateInfoFUCHSIA ) == sizeof( VkBufferCollectionBufferCreateInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferCollectionBufferCreateInfoFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA ) == sizeof( VkBufferCollectionPropertiesFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferCollectionPropertiesFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SysmemColorSpaceFUCHSIA ) == sizeof( VkSysmemColorSpaceFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SysmemColorSpaceFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageConstraintsInfoFUCHSIA ) == sizeof( VkImageConstraintsInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageConstraintsInfoFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageFormatConstraintsInfoFUCHSIA ) == sizeof( VkImageFormatConstraintsInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageFormatConstraintsInfoFUCHSIA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BufferCollectionConstraintsInfoFUCHSIA ) == sizeof( VkBufferCollectionConstraintsInfoFUCHSIA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BufferCollectionConstraintsInfoFUCHSIA is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -//=== VK_HUAWEI_subpass_shading === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassShadingPipelineCreateInfoHUAWEI ) == sizeof( VkSubpassShadingPipelineCreateInfoHUAWEI ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubpassShadingPipelineCreateInfoHUAWEI is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingFeaturesHUAWEI ) == sizeof( VkPhysicalDeviceSubpassShadingFeaturesHUAWEI ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSubpassShadingFeaturesHUAWEI is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassShadingPropertiesHUAWEI ) == - sizeof( VkPhysicalDeviceSubpassShadingPropertiesHUAWEI ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSubpassShadingPropertiesHUAWEI is not nothrow_move_constructible!" ); - -//=== VK_HUAWEI_invocation_mask === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceInvocationMaskFeaturesHUAWEI ) == sizeof( VkPhysicalDeviceInvocationMaskFeaturesHUAWEI ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceInvocationMaskFeaturesHUAWEI is not nothrow_move_constructible!" ); - -//=== VK_NV_external_memory_rdma === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetRemoteAddressInfoNV ) == sizeof( VkMemoryGetRemoteAddressInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryGetRemoteAddressInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryRDMAFeaturesNV ) == sizeof( VkPhysicalDeviceExternalMemoryRDMAFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExternalMemoryRDMAFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_pipeline_properties === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelinePropertiesIdentifierEXT ) == sizeof( VkPipelinePropertiesIdentifierEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelinePropertiesIdentifierEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelinePropertiesFeaturesEXT ) == - sizeof( VkPhysicalDevicePipelinePropertiesFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePipelinePropertiesFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_frame_boundary === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFrameBoundaryFeaturesEXT ) == sizeof( VkPhysicalDeviceFrameBoundaryFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFrameBoundaryFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FrameBoundaryEXT ) == sizeof( VkFrameBoundaryEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FrameBoundaryEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_multisampled_render_to_single_sampled === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ) == - sizeof( VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SubpassResolvePerformanceQueryEXT ) == sizeof( VkSubpassResolvePerformanceQueryEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SubpassResolvePerformanceQueryEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultisampledRenderToSingleSampledInfoEXT ) == sizeof( VkMultisampledRenderToSingleSampledInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MultisampledRenderToSingleSampledInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_extended_dynamic_state2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState2FeaturesEXT ) == - sizeof( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExtendedDynamicState2FeaturesEXT is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) -//=== VK_QNX_screen_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ScreenSurfaceCreateInfoQNX ) == sizeof( VkScreenSurfaceCreateInfoQNX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ScreenSurfaceCreateInfoQNX is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - -//=== VK_EXT_color_write_enable === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceColorWriteEnableFeaturesEXT ) == sizeof( VkPhysicalDeviceColorWriteEnableFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceColorWriteEnableFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineColorWriteCreateInfoEXT ) == sizeof( VkPipelineColorWriteCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineColorWriteCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_primitives_generated_query === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT ) == - sizeof( VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_ray_tracing_maintenance1 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingMaintenance1FeaturesKHR ) == - sizeof( VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingMaintenance1FeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TraceRaysIndirectCommand2KHR ) == sizeof( VkTraceRaysIndirectCommand2KHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TraceRaysIndirectCommand2KHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_shader_untyped_pointers === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUntypedPointersFeaturesKHR ) == - sizeof( VkPhysicalDeviceShaderUntypedPointersFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderUntypedPointersFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_VALVE_video_encode_rgb_conversion === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE ) == - sizeof( VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeRgbConversionCapabilitiesVALVE ) == sizeof( VkVideoEncodeRgbConversionCapabilitiesVALVE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeRgbConversionCapabilitiesVALVE is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeProfileRgbConversionInfoVALVE ) == sizeof( VkVideoEncodeProfileRgbConversionInfoVALVE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeProfileRgbConversionInfoVALVE is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeSessionRgbConversionCreateInfoVALVE ) == - sizeof( VkVideoEncodeSessionRgbConversionCreateInfoVALVE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeSessionRgbConversionCreateInfoVALVE is not nothrow_move_constructible!" ); - -//=== VK_EXT_image_view_min_lod === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageViewMinLodFeaturesEXT ) == sizeof( VkPhysicalDeviceImageViewMinLodFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageViewMinLodFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewMinLodCreateInfoEXT ) == sizeof( VkImageViewMinLodCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageViewMinLodCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_multi_draw === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawFeaturesEXT ) == sizeof( VkPhysicalDeviceMultiDrawFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMultiDrawFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiDrawPropertiesEXT ) == sizeof( VkPhysicalDeviceMultiDrawPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMultiDrawPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultiDrawInfoEXT ) == sizeof( VkMultiDrawInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MultiDrawInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultiDrawIndexedInfoEXT ) == sizeof( VkMultiDrawIndexedInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MultiDrawIndexedInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_image_2d_view_of_3d === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImage2DViewOf3DFeaturesEXT ) == sizeof( VkPhysicalDeviceImage2DViewOf3DFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImage2DViewOf3DFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_tile_image === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderTileImageFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderTileImageFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT ) == sizeof( VkPhysicalDeviceShaderTileImagePropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderTileImagePropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_opacity_micromap === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapEXT ) == sizeof( VkMicromapEXT ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "MicromapEXT is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "MicromapEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT ) == sizeof( VkMicromapBuildInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MicromapBuildInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapUsageEXT ) == sizeof( VkMicromapUsageEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MicromapUsageEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapCreateInfoEXT ) == sizeof( VkMicromapCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MicromapCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapFeaturesEXT ) == sizeof( VkPhysicalDeviceOpacityMicromapFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceOpacityMicromapFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpacityMicromapPropertiesEXT ) == sizeof( VkPhysicalDeviceOpacityMicromapPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceOpacityMicromapPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapVersionInfoEXT ) == sizeof( VkMicromapVersionInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MicromapVersionInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMicromapToMemoryInfoEXT ) == sizeof( VkCopyMicromapToMemoryInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyMicromapToMemoryInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToMicromapInfoEXT ) == sizeof( VkCopyMemoryToMicromapInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyMemoryToMicromapInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMicromapInfoEXT ) == sizeof( VkCopyMicromapInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyMicromapInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapBuildSizesInfoEXT ) == sizeof( VkMicromapBuildSizesInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MicromapBuildSizesInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesOpacityMicromapEXT ) == - sizeof( VkAccelerationStructureTrianglesOpacityMicromapEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureTrianglesOpacityMicromapEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapTriangleEXT ) == sizeof( VkMicromapTriangleEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MicromapTriangleEXT is not nothrow_move_constructible!" ); - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) -//=== VK_NV_displacement_micromap === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapFeaturesNV ) == - sizeof( VkPhysicalDeviceDisplacementMicromapFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDisplacementMicromapFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDisplacementMicromapPropertiesNV ) == - sizeof( VkPhysicalDeviceDisplacementMicromapPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDisplacementMicromapPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureTrianglesDisplacementMicromapNV ) == - sizeof( VkAccelerationStructureTrianglesDisplacementMicromapNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureTrianglesDisplacementMicromapNV is not nothrow_move_constructible!" ); -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -//=== VK_HUAWEI_cluster_culling_shader === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderFeaturesHUAWEI ) == - sizeof( VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceClusterCullingShaderFeaturesHUAWEI is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderPropertiesHUAWEI ) == - sizeof( VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceClusterCullingShaderPropertiesHUAWEI is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI ) == - sizeof( VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI is not nothrow_move_constructible!" ); - -//=== VK_EXT_border_color_swizzle === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceBorderColorSwizzleFeaturesEXT ) == - sizeof( VkPhysicalDeviceBorderColorSwizzleFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceBorderColorSwizzleFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerBorderColorComponentMappingCreateInfoEXT ) == - sizeof( VkSamplerBorderColorComponentMappingCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerBorderColorComponentMappingCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_pageable_device_local_memory === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT ) == - sizeof( VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_ARM_shader_core_properties === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCorePropertiesARM ) == sizeof( VkPhysicalDeviceShaderCorePropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderCorePropertiesARM is not nothrow_move_constructible!" ); - -//=== VK_ARM_scheduling_controls === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceQueueShaderCoreControlCreateInfoARM ) == sizeof( VkDeviceQueueShaderCoreControlCreateInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceQueueShaderCoreControlCreateInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsFeaturesARM ) == - sizeof( VkPhysicalDeviceSchedulingControlsFeaturesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSchedulingControlsFeaturesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSchedulingControlsPropertiesARM ) == - sizeof( VkPhysicalDeviceSchedulingControlsPropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSchedulingControlsPropertiesARM is not nothrow_move_constructible!" ); - -//=== VK_EXT_image_sliced_view_of_3d === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageSlicedViewOf3DFeaturesEXT ) == - sizeof( VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageSlicedViewOf3DFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewSlicedCreateInfoEXT ) == sizeof( VkImageViewSlicedCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageViewSlicedCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_VALVE_descriptor_set_host_mapping === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE ) == - sizeof( VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetBindingReferenceVALVE ) == sizeof( VkDescriptorSetBindingReferenceVALVE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorSetBindingReferenceVALVE is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorSetLayoutHostMappingInfoVALVE ) == sizeof( VkDescriptorSetLayoutHostMappingInfoVALVE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorSetLayoutHostMappingInfoVALVE is not nothrow_move_constructible!" ); - -//=== VK_EXT_non_seamless_cube_map === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceNonSeamlessCubeMapFeaturesEXT ) == - sizeof( VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceNonSeamlessCubeMapFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_ARM_render_pass_striped === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedFeaturesARM ) == sizeof( VkPhysicalDeviceRenderPassStripedFeaturesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRenderPassStripedFeaturesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRenderPassStripedPropertiesARM ) == - sizeof( VkPhysicalDeviceRenderPassStripedPropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRenderPassStripedPropertiesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassStripeBeginInfoARM ) == sizeof( VkRenderPassStripeBeginInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassStripeBeginInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassStripeInfoARM ) == sizeof( VkRenderPassStripeInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassStripeInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassStripeSubmitInfoARM ) == sizeof( VkRenderPassStripeSubmitInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassStripeSubmitInfoARM is not nothrow_move_constructible!" ); - -//=== VK_NV_copy_memory_indirect === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesNV ) == sizeof( VkPhysicalDeviceCopyMemoryIndirectFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCopyMemoryIndirectFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_NV_memory_decompression === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionNV ) == sizeof( VkDecompressMemoryRegionNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DecompressMemoryRegionNV is not nothrow_move_constructible!" ); - -//=== VK_NV_device_generated_commands_compute === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ) == - sizeof( VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ComputePipelineIndirectBufferInfoNV ) == sizeof( VkComputePipelineIndirectBufferInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ComputePipelineIndirectBufferInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineIndirectDeviceAddressInfoNV ) == sizeof( VkPipelineIndirectDeviceAddressInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineIndirectDeviceAddressInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindPipelineIndirectCommandNV ) == sizeof( VkBindPipelineIndirectCommandNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindPipelineIndirectCommandNV is not nothrow_move_constructible!" ); - -//=== VK_NV_ray_tracing_linear_swept_spheres === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV ) == - sizeof( VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometryLinearSweptSpheresDataNV ) == - sizeof( VkAccelerationStructureGeometryLinearSweptSpheresDataNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureGeometryLinearSweptSpheresDataNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureGeometrySpheresDataNV ) == sizeof( VkAccelerationStructureGeometrySpheresDataNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureGeometrySpheresDataNV is not nothrow_move_constructible!" ); - -//=== VK_NV_linear_color_attachment === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLinearColorAttachmentFeaturesNV ) == - sizeof( VkPhysicalDeviceLinearColorAttachmentFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceLinearColorAttachmentFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_KHR_shader_maximal_reconvergence === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR ) == - sizeof( VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_EXT_image_compression_control_swapchain === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT ) == - sizeof( VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_QCOM_image_processing === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageViewSampleWeightCreateInfoQCOM ) == sizeof( VkImageViewSampleWeightCreateInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageViewSampleWeightCreateInfoQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingFeaturesQCOM ) == sizeof( VkPhysicalDeviceImageProcessingFeaturesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageProcessingFeaturesQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessingPropertiesQCOM ) == - sizeof( VkPhysicalDeviceImageProcessingPropertiesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageProcessingPropertiesQCOM is not nothrow_move_constructible!" ); - -//=== VK_EXT_nested_command_buffer === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferFeaturesEXT ) == - sizeof( VkPhysicalDeviceNestedCommandBufferFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceNestedCommandBufferFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceNestedCommandBufferPropertiesEXT ) == - sizeof( VkPhysicalDeviceNestedCommandBufferPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceNestedCommandBufferPropertiesEXT is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_OHOS ) -//=== VK_OHOS_external_memory === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::NativeBufferUsageOHOS ) == sizeof( VkNativeBufferUsageOHOS ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "NativeBufferUsageOHOS is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::NativeBufferPropertiesOHOS ) == sizeof( VkNativeBufferPropertiesOHOS ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "NativeBufferPropertiesOHOS is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::NativeBufferFormatPropertiesOHOS ) == sizeof( VkNativeBufferFormatPropertiesOHOS ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "NativeBufferFormatPropertiesOHOS is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportNativeBufferInfoOHOS ) == sizeof( VkImportNativeBufferInfoOHOS ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportNativeBufferInfoOHOS is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetNativeBufferInfoOHOS ) == sizeof( VkMemoryGetNativeBufferInfoOHOS ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryGetNativeBufferInfoOHOS is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalFormatOHOS ) == sizeof( VkExternalFormatOHOS ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalFormatOHOS is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_OHOS*/ - -//=== VK_EXT_external_memory_acquire_unmodified === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryAcquireUnmodifiedEXT ) == sizeof( VkExternalMemoryAcquireUnmodifiedEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalMemoryAcquireUnmodifiedEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_extended_dynamic_state3 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3FeaturesEXT ) == - sizeof( VkPhysicalDeviceExtendedDynamicState3FeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExtendedDynamicState3FeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedDynamicState3PropertiesEXT ) == - sizeof( VkPhysicalDeviceExtendedDynamicState3PropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExtendedDynamicState3PropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ColorBlendEquationEXT ) == sizeof( VkColorBlendEquationEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ColorBlendEquationEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ColorBlendAdvancedEXT ) == sizeof( VkColorBlendAdvancedEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ColorBlendAdvancedEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_subpass_merge_feedback === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSubpassMergeFeedbackFeaturesEXT ) == - sizeof( VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSubpassMergeFeedbackFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassCreationControlEXT ) == sizeof( VkRenderPassCreationControlEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassCreationControlEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackInfoEXT ) == sizeof( VkRenderPassCreationFeedbackInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassCreationFeedbackInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassCreationFeedbackCreateInfoEXT ) == sizeof( VkRenderPassCreationFeedbackCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassCreationFeedbackCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackInfoEXT ) == sizeof( VkRenderPassSubpassFeedbackInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassSubpassFeedbackInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassSubpassFeedbackCreateInfoEXT ) == sizeof( VkRenderPassSubpassFeedbackCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassSubpassFeedbackCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_LUNARG_direct_driver_loading === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DirectDriverLoadingInfoLUNARG ) == sizeof( VkDirectDriverLoadingInfoLUNARG ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DirectDriverLoadingInfoLUNARG is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DirectDriverLoadingListLUNARG ) == sizeof( VkDirectDriverLoadingListLUNARG ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DirectDriverLoadingListLUNARG is not nothrow_move_constructible!" ); - -//=== VK_ARM_tensors === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorARM ) == sizeof( VkTensorARM ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "TensorARM is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "TensorARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorViewARM ) == sizeof( VkTensorViewARM ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "TensorViewARM is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "TensorViewARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorDescriptionARM ) == sizeof( VkTensorDescriptionARM ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TensorDescriptionARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorCreateInfoARM ) == sizeof( VkTensorCreateInfoARM ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TensorCreateInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorMemoryRequirementsInfoARM ) == sizeof( VkTensorMemoryRequirementsInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TensorMemoryRequirementsInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindTensorMemoryInfoARM ) == sizeof( VkBindTensorMemoryInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindTensorMemoryInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetTensorARM ) == sizeof( VkWriteDescriptorSetTensorARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "WriteDescriptorSetTensorARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorFormatPropertiesARM ) == sizeof( VkTensorFormatPropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TensorFormatPropertiesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorPropertiesARM ) == sizeof( VkPhysicalDeviceTensorPropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTensorPropertiesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorMemoryBarrierARM ) == sizeof( VkTensorMemoryBarrierARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TensorMemoryBarrierARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorDependencyInfoARM ) == sizeof( VkTensorDependencyInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TensorDependencyInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTensorFeaturesARM ) == sizeof( VkPhysicalDeviceTensorFeaturesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTensorFeaturesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DeviceTensorMemoryRequirementsARM ) == sizeof( VkDeviceTensorMemoryRequirementsARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DeviceTensorMemoryRequirementsARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyTensorInfoARM ) == sizeof( VkCopyTensorInfoARM ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyTensorInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorCopyARM ) == sizeof( VkTensorCopyARM ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "TensorCopyARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryDedicatedAllocateInfoTensorARM ) == sizeof( VkMemoryDedicatedAllocateInfoTensorARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryDedicatedAllocateInfoTensorARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalTensorInfoARM ) == sizeof( VkPhysicalDeviceExternalTensorInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExternalTensorInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalTensorPropertiesARM ) == sizeof( VkExternalTensorPropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalTensorPropertiesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalMemoryTensorCreateInfoARM ) == sizeof( VkExternalMemoryTensorCreateInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalMemoryTensorCreateInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorFeaturesARM ) == - sizeof( VkPhysicalDeviceDescriptorBufferTensorFeaturesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorBufferTensorFeaturesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorBufferTensorPropertiesARM ) == - sizeof( VkPhysicalDeviceDescriptorBufferTensorPropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorBufferTensorPropertiesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DescriptorGetTensorInfoARM ) == sizeof( VkDescriptorGetTensorInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DescriptorGetTensorInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorCaptureDescriptorDataInfoARM ) == sizeof( VkTensorCaptureDescriptorDataInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TensorCaptureDescriptorDataInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TensorViewCaptureDescriptorDataInfoARM ) == sizeof( VkTensorViewCaptureDescriptorDataInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TensorViewCaptureDescriptorDataInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::FrameBoundaryTensorsARM ) == sizeof( VkFrameBoundaryTensorsARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "FrameBoundaryTensorsARM is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_module_identifier === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierFeaturesEXT ) == - sizeof( VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderModuleIdentifierFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderModuleIdentifierPropertiesEXT ) == - sizeof( VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderModuleIdentifierPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineShaderStageModuleIdentifierCreateInfoEXT ) == - sizeof( VkPipelineShaderStageModuleIdentifierCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineShaderStageModuleIdentifierCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderModuleIdentifierEXT ) == sizeof( VkShaderModuleIdentifierEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ShaderModuleIdentifierEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_rasterization_order_attachment_access === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ) == - sizeof( VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_NV_optical_flow === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV ) == sizeof( VkOpticalFlowSessionNV ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "OpticalFlowSessionNV is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "OpticalFlowSessionNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowFeaturesNV ) == sizeof( VkPhysicalDeviceOpticalFlowFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceOpticalFlowFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceOpticalFlowPropertiesNV ) == sizeof( VkPhysicalDeviceOpticalFlowPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceOpticalFlowPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatInfoNV ) == sizeof( VkOpticalFlowImageFormatInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "OpticalFlowImageFormatInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowImageFormatPropertiesNV ) == sizeof( VkOpticalFlowImageFormatPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "OpticalFlowImageFormatPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV ) == sizeof( VkOpticalFlowSessionCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "OpticalFlowSessionCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreatePrivateDataInfoNV ) == sizeof( VkOpticalFlowSessionCreatePrivateDataInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "OpticalFlowSessionCreatePrivateDataInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV ) == sizeof( VkOpticalFlowExecuteInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "OpticalFlowExecuteInfoNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_legacy_dithering === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyDitheringFeaturesEXT ) == sizeof( VkPhysicalDeviceLegacyDitheringFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceLegacyDitheringFeaturesEXT is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) -//=== VK_ANDROID_external_format_resolve === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolveFeaturesANDROID ) == - sizeof( VkPhysicalDeviceExternalFormatResolveFeaturesANDROID ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExternalFormatResolveFeaturesANDROID is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalFormatResolvePropertiesANDROID ) == - sizeof( VkPhysicalDeviceExternalFormatResolvePropertiesANDROID ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExternalFormatResolvePropertiesANDROID is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AndroidHardwareBufferFormatResolvePropertiesANDROID ) == - sizeof( VkAndroidHardwareBufferFormatResolvePropertiesANDROID ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AndroidHardwareBufferFormatResolvePropertiesANDROID is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -//=== VK_AMD_anti_lag === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAntiLagFeaturesAMD ) == sizeof( VkPhysicalDeviceAntiLagFeaturesAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceAntiLagFeaturesAMD is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AntiLagDataAMD ) == sizeof( VkAntiLagDataAMD ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AntiLagDataAMD is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AntiLagPresentationInfoAMD ) == sizeof( VkAntiLagPresentationInfoAMD ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AntiLagPresentationInfoAMD is not nothrow_move_constructible!" ); - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) -//=== VK_AMDX_dense_geometry_format === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDenseGeometryFormatFeaturesAMDX ) == - sizeof( VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDenseGeometryFormatFeaturesAMDX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AccelerationStructureDenseGeometryFormatTrianglesDataAMDX ) == - sizeof( VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AccelerationStructureDenseGeometryFormatTrianglesDataAMDX is not nothrow_move_constructible!" ); -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -//=== VK_KHR_present_id2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentId2KHR ) == sizeof( VkSurfaceCapabilitiesPresentId2KHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceCapabilitiesPresentId2KHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentId2KHR ) == sizeof( VkPresentId2KHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "PresentId2KHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentId2FeaturesKHR ) == sizeof( VkPhysicalDevicePresentId2FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePresentId2FeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_present_wait2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCapabilitiesPresentWait2KHR ) == sizeof( VkSurfaceCapabilitiesPresentWait2KHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceCapabilitiesPresentWait2KHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentWait2FeaturesKHR ) == sizeof( VkPhysicalDevicePresentWait2FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePresentWait2FeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PresentWait2InfoKHR ) == sizeof( VkPresentWait2InfoKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PresentWait2InfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_ray_tracing_position_fetch === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingPositionFetchFeaturesKHR ) == - sizeof( VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingPositionFetchFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_object === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderEXT ) == sizeof( VkShaderEXT ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "ShaderEXT is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ShaderEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderObjectFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderObjectFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT ) == sizeof( VkPhysicalDeviceShaderObjectPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderObjectPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT ) == sizeof( VkShaderCreateInfoEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ShaderCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_pipeline_binary === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryKHR ) == sizeof( VkPipelineBinaryKHR ), "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, "PipelineBinaryKHR is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineBinaryKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryFeaturesKHR ) == sizeof( VkPhysicalDevicePipelineBinaryFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePipelineBinaryFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineBinaryPropertiesKHR ) == sizeof( VkPhysicalDevicePipelineBinaryPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePipelineBinaryPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DevicePipelineBinaryInternalCacheControlKHR ) == - sizeof( VkDevicePipelineBinaryInternalCacheControlKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DevicePipelineBinaryInternalCacheControlKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryKeyKHR ) == sizeof( VkPipelineBinaryKeyKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineBinaryKeyKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryDataKHR ) == sizeof( VkPipelineBinaryDataKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineBinaryDataKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryKeysAndDataKHR ) == sizeof( VkPipelineBinaryKeysAndDataKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineBinaryKeysAndDataKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryCreateInfoKHR ) == sizeof( VkPipelineBinaryCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineBinaryCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryInfoKHR ) == sizeof( VkPipelineBinaryInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineBinaryInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ReleaseCapturedPipelineDataInfoKHR ) == sizeof( VkReleaseCapturedPipelineDataInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ReleaseCapturedPipelineDataInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryDataInfoKHR ) == sizeof( VkPipelineBinaryDataInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineBinaryDataInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCreateInfoKHR ) == sizeof( VkPipelineCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineBinaryHandlesInfoKHR ) == sizeof( VkPipelineBinaryHandlesInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineBinaryHandlesInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_QCOM_tile_properties === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM ) == sizeof( VkPhysicalDeviceTilePropertiesFeaturesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTilePropertiesFeaturesQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TilePropertiesQCOM ) == sizeof( VkTilePropertiesQCOM ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TilePropertiesQCOM is not nothrow_move_constructible!" ); - -//=== VK_SEC_amigo_profiling === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAmigoProfilingFeaturesSEC ) == sizeof( VkPhysicalDeviceAmigoProfilingFeaturesSEC ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceAmigoProfilingFeaturesSEC is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AmigoProfilingSubmitInfoSEC ) == sizeof( VkAmigoProfilingSubmitInfoSEC ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AmigoProfilingSubmitInfoSEC is not nothrow_move_constructible!" ); - -//=== VK_KHR_surface_maintenance1 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfacePresentModeKHR ) == sizeof( VkSurfacePresentModeKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfacePresentModeKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfacePresentScalingCapabilitiesKHR ) == sizeof( VkSurfacePresentScalingCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfacePresentScalingCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfacePresentModeCompatibilityKHR ) == sizeof( VkSurfacePresentModeCompatibilityKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfacePresentModeCompatibilityKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_swapchain_maintenance1 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceSwapchainMaintenance1FeaturesKHR ) == - sizeof( VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceSwapchainMaintenance1FeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainPresentFenceInfoKHR ) == sizeof( VkSwapchainPresentFenceInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainPresentFenceInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainPresentModesCreateInfoKHR ) == sizeof( VkSwapchainPresentModesCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainPresentModesCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainPresentModeInfoKHR ) == sizeof( VkSwapchainPresentModeInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainPresentModeInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainPresentScalingCreateInfoKHR ) == sizeof( VkSwapchainPresentScalingCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainPresentScalingCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ReleaseSwapchainImagesInfoKHR ) == sizeof( VkReleaseSwapchainImagesInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ReleaseSwapchainImagesInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_QCOM_multiview_per_view_viewports === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM ) == - sizeof( VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM is not nothrow_move_constructible!" ); - -//=== VK_NV_ray_tracing_invocation_reorder === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesNV ) == - sizeof( VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingInvocationReorderPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesNV ) == - sizeof( VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingInvocationReorderFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_NV_cooperative_vector === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorPropertiesNV ) == - sizeof( VkPhysicalDeviceCooperativeVectorPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCooperativeVectorPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeVectorFeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeVectorFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCooperativeVectorFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeVectorPropertiesNV ) == sizeof( VkCooperativeVectorPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CooperativeVectorPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ConvertCooperativeVectorMatrixInfoNV ) == sizeof( VkConvertCooperativeVectorMatrixInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ConvertCooperativeVectorMatrixInfoNV is not nothrow_move_constructible!" ); - -//=== VK_NV_extended_sparse_address_space === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV ) == - sizeof( VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExtendedSparseAddressSpacePropertiesNV ) == - sizeof( VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExtendedSparseAddressSpacePropertiesNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_mutable_descriptor_type === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMutableDescriptorTypeFeaturesEXT ) == - sizeof( VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMutableDescriptorTypeFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeListEXT ) == sizeof( VkMutableDescriptorTypeListEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MutableDescriptorTypeListEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MutableDescriptorTypeCreateInfoEXT ) == sizeof( VkMutableDescriptorTypeCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MutableDescriptorTypeCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_legacy_vertex_attributes === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesFeaturesEXT ) == - sizeof( VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceLegacyVertexAttributesFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLegacyVertexAttributesPropertiesEXT ) == - sizeof( VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceLegacyVertexAttributesPropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_layer_settings === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LayerSettingsCreateInfoEXT ) == sizeof( VkLayerSettingsCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "LayerSettingsCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LayerSettingEXT ) == sizeof( VkLayerSettingEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "LayerSettingEXT is not nothrow_move_constructible!" ); - -//=== VK_ARM_shader_core_builtins === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsFeaturesARM ) == - sizeof( VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderCoreBuiltinsFeaturesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderCoreBuiltinsPropertiesARM ) == - sizeof( VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderCoreBuiltinsPropertiesARM is not nothrow_move_constructible!" ); - -//=== VK_EXT_pipeline_library_group_handles === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT ) == - sizeof( VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_dynamic_rendering_unused_attachments === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ) == - sizeof( VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_internally_synchronized_queues === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR ) == - sizeof( VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_low_latency2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySleepModeInfoNV ) == sizeof( VkLatencySleepModeInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "LatencySleepModeInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySleepInfoNV ) == sizeof( VkLatencySleepInfoNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "LatencySleepInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetLatencyMarkerInfoNV ) == sizeof( VkSetLatencyMarkerInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SetLatencyMarkerInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV ) == sizeof( VkGetLatencyMarkerInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GetLatencyMarkerInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencyTimingsFrameReportNV ) == sizeof( VkLatencyTimingsFrameReportNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "LatencyTimingsFrameReportNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySubmissionPresentIdNV ) == sizeof( VkLatencySubmissionPresentIdNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "LatencySubmissionPresentIdNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SwapchainLatencyCreateInfoNV ) == sizeof( VkSwapchainLatencyCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SwapchainLatencyCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::OutOfBandQueueTypeInfoNV ) == sizeof( VkOutOfBandQueueTypeInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "OutOfBandQueueTypeInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::LatencySurfaceCapabilitiesNV ) == sizeof( VkLatencySurfaceCapabilitiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "LatencySurfaceCapabilitiesNV is not nothrow_move_constructible!" ); - -//=== VK_KHR_cooperative_matrix === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeMatrixPropertiesKHR ) == sizeof( VkCooperativeMatrixPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CooperativeMatrixPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixFeaturesKHR ) == sizeof( VkPhysicalDeviceCooperativeMatrixFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCooperativeMatrixFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrixPropertiesKHR ) == - sizeof( VkPhysicalDeviceCooperativeMatrixPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCooperativeMatrixPropertiesKHR is not nothrow_move_constructible!" ); - -//=== VK_ARM_data_graph === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionARM ) == sizeof( VkDataGraphPipelineSessionARM ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "DataGraphPipelineSessionARM is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineSessionARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphFeaturesARM ) == sizeof( VkPhysicalDeviceDataGraphFeaturesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDataGraphFeaturesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantARM ) == sizeof( VkDataGraphPipelineConstantARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineConstantARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineResourceInfoARM ) == sizeof( VkDataGraphPipelineResourceInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineResourceInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineCompilerControlCreateInfoARM ) == - sizeof( VkDataGraphPipelineCompilerControlCreateInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineCompilerControlCreateInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineCreateInfoARM ) == sizeof( VkDataGraphPipelineCreateInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineCreateInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineShaderModuleCreateInfoARM ) == sizeof( VkDataGraphPipelineShaderModuleCreateInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineShaderModuleCreateInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionCreateInfoARM ) == sizeof( VkDataGraphPipelineSessionCreateInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineSessionCreateInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementsInfoARM ) == - sizeof( VkDataGraphPipelineSessionBindPointRequirementsInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineSessionBindPointRequirementsInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionBindPointRequirementARM ) == - sizeof( VkDataGraphPipelineSessionBindPointRequirementARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineSessionBindPointRequirementARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineSessionMemoryRequirementsInfoARM ) == - sizeof( VkDataGraphPipelineSessionMemoryRequirementsInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineSessionMemoryRequirementsInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindDataGraphPipelineSessionMemoryInfoARM ) == sizeof( VkBindDataGraphPipelineSessionMemoryInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindDataGraphPipelineSessionMemoryInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineInfoARM ) == sizeof( VkDataGraphPipelineInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelinePropertyQueryResultARM ) == sizeof( VkDataGraphPipelinePropertyQueryResultARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelinePropertyQueryResultARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineIdentifierCreateInfoARM ) == sizeof( VkDataGraphPipelineIdentifierCreateInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineIdentifierCreateInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineDispatchInfoARM ) == sizeof( VkDataGraphPipelineDispatchInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineDispatchInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphProcessingEngineARM ) == sizeof( VkPhysicalDeviceDataGraphProcessingEngineARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDataGraphProcessingEngineARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphPropertiesARM ) == sizeof( VkQueueFamilyDataGraphPropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueueFamilyDataGraphPropertiesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphProcessingEngineCreateInfoARM ) == sizeof( VkDataGraphProcessingEngineCreateInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphProcessingEngineCreateInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM ) == - sizeof( VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyDataGraphProcessingEnginePropertiesARM ) == - sizeof( VkQueueFamilyDataGraphProcessingEnginePropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueueFamilyDataGraphProcessingEnginePropertiesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphOperationSupportARM ) == sizeof( VkPhysicalDeviceDataGraphOperationSupportARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDataGraphOperationSupportARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM ) == - sizeof( VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM is not nothrow_move_constructible!" ); - -//=== VK_QCOM_multiview_per_view_render_areas === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ) == - sizeof( VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM ) == - sizeof( VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM is not nothrow_move_constructible!" ); - -//=== VK_KHR_compute_shader_derivatives === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesFeaturesKHR ) == - sizeof( VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceComputeShaderDerivativesFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeShaderDerivativesPropertiesKHR ) == - sizeof( VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceComputeShaderDerivativesPropertiesKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_decode_av1 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1ProfileInfoKHR ) == sizeof( VkVideoDecodeAV1ProfileInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeAV1ProfileInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1CapabilitiesKHR ) == sizeof( VkVideoDecodeAV1CapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeAV1CapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1SessionParametersCreateInfoKHR ) == - sizeof( VkVideoDecodeAV1SessionParametersCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeAV1SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1PictureInfoKHR ) == sizeof( VkVideoDecodeAV1PictureInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeAV1PictureInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1DpbSlotInfoKHR ) == sizeof( VkVideoDecodeAV1DpbSlotInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeAV1DpbSlotInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_encode_av1 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeAV1FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoEncodeAV1FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVideoEncodeAV1FeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1CapabilitiesKHR ) == sizeof( VkVideoEncodeAV1CapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1CapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QualityLevelPropertiesKHR ) == sizeof( VkVideoEncodeAV1QualityLevelPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1QualityLevelPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionCreateInfoKHR ) == sizeof( VkVideoEncodeAV1SessionCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1SessionCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1SessionParametersCreateInfoKHR ) == - sizeof( VkVideoEncodeAV1SessionParametersCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1SessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1PictureInfoKHR ) == sizeof( VkVideoEncodeAV1PictureInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1PictureInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1DpbSlotInfoKHR ) == sizeof( VkVideoEncodeAV1DpbSlotInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1DpbSlotInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1ProfileInfoKHR ) == sizeof( VkVideoEncodeAV1ProfileInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1ProfileInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QIndexKHR ) == sizeof( VkVideoEncodeAV1QIndexKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1QIndexKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1FrameSizeKHR ) == sizeof( VkVideoEncodeAV1FrameSizeKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1FrameSizeKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1GopRemainingFrameInfoKHR ) == sizeof( VkVideoEncodeAV1GopRemainingFrameInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1GopRemainingFrameInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlInfoKHR ) == sizeof( VkVideoEncodeAV1RateControlInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1RateControlInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1RateControlLayerInfoKHR ) == sizeof( VkVideoEncodeAV1RateControlLayerInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1RateControlLayerInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_decode_vp9 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoDecodeVP9FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoDecodeVP9FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVideoDecodeVP9FeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeVP9ProfileInfoKHR ) == sizeof( VkVideoDecodeVP9ProfileInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeVP9ProfileInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeVP9CapabilitiesKHR ) == sizeof( VkVideoDecodeVP9CapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeVP9CapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeVP9PictureInfoKHR ) == sizeof( VkVideoDecodeVP9PictureInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeVP9PictureInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_maintenance1 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance1FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance1FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVideoMaintenance1FeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoInlineQueryInfoKHR ) == sizeof( VkVideoInlineQueryInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoInlineQueryInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_per_stage_descriptor_set === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePerStageDescriptorSetFeaturesNV ) == - sizeof( VkPhysicalDevicePerStageDescriptorSetFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePerStageDescriptorSetFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_QCOM_image_processing2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2FeaturesQCOM ) == sizeof( VkPhysicalDeviceImageProcessing2FeaturesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageProcessing2FeaturesQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageProcessing2PropertiesQCOM ) == - sizeof( VkPhysicalDeviceImageProcessing2PropertiesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageProcessing2PropertiesQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerBlockMatchWindowCreateInfoQCOM ) == sizeof( VkSamplerBlockMatchWindowCreateInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerBlockMatchWindowCreateInfoQCOM is not nothrow_move_constructible!" ); - -//=== VK_QCOM_filter_cubic_weights === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicWeightsFeaturesQCOM ) == sizeof( VkPhysicalDeviceCubicWeightsFeaturesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCubicWeightsFeaturesQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerCubicWeightsCreateInfoQCOM ) == sizeof( VkSamplerCubicWeightsCreateInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerCubicWeightsCreateInfoQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BlitImageCubicWeightsInfoQCOM ) == sizeof( VkBlitImageCubicWeightsInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BlitImageCubicWeightsInfoQCOM is not nothrow_move_constructible!" ); - -//=== VK_QCOM_ycbcr_degamma === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceYcbcrDegammaFeaturesQCOM ) == sizeof( VkPhysicalDeviceYcbcrDegammaFeaturesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceYcbcrDegammaFeaturesQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ) == - sizeof( VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM is not nothrow_move_constructible!" ); - -//=== VK_QCOM_filter_cubic_clamp === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCubicClampFeaturesQCOM ) == sizeof( VkPhysicalDeviceCubicClampFeaturesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCubicClampFeaturesQCOM is not nothrow_move_constructible!" ); - -//=== VK_EXT_attachment_feedback_loop_dynamic_state === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ) == - sizeof( VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_unified_image_layouts === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceUnifiedImageLayoutsFeaturesKHR ) == - sizeof( VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceUnifiedImageLayoutsFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::AttachmentFeedbackLoopInfoEXT ) == sizeof( VkAttachmentFeedbackLoopInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "AttachmentFeedbackLoopInfoEXT is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) -//=== VK_QNX_external_memory_screen_buffer === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ScreenBufferPropertiesQNX ) == sizeof( VkScreenBufferPropertiesQNX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ScreenBufferPropertiesQNX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ScreenBufferFormatPropertiesQNX ) == sizeof( VkScreenBufferFormatPropertiesQNX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ScreenBufferFormatPropertiesQNX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportScreenBufferInfoQNX ) == sizeof( VkImportScreenBufferInfoQNX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportScreenBufferInfoQNX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalFormatQNX ) == sizeof( VkExternalFormatQNX ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalFormatQNX is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX ) == - sizeof( VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - -//=== VK_MSFT_layered_driver === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredDriverPropertiesMSFT ) == sizeof( VkPhysicalDeviceLayeredDriverPropertiesMSFT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceLayeredDriverPropertiesMSFT is not nothrow_move_constructible!" ); - -//=== VK_KHR_calibrated_timestamps === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR ) == sizeof( VkCalibratedTimestampInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CalibratedTimestampInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_maintenance6 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetDescriptorBufferOffsetsInfoEXT ) == sizeof( VkSetDescriptorBufferOffsetsInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SetDescriptorBufferOffsetsInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindDescriptorBufferEmbeddedSamplersInfoEXT ) == - sizeof( VkBindDescriptorBufferEmbeddedSamplersInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindDescriptorBufferEmbeddedSamplersInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_NV_descriptor_pool_overallocation === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDescriptorPoolOverallocationFeaturesNV ) == - sizeof( VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_QCOM_tile_memory_heap === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapFeaturesQCOM ) == sizeof( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTileMemoryHeapFeaturesQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileMemoryHeapPropertiesQCOM ) == sizeof( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceTileMemoryHeapPropertiesQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemoryRequirementsQCOM ) == sizeof( VkTileMemoryRequirementsQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TileMemoryRequirementsQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemoryBindInfoQCOM ) == sizeof( VkTileMemoryBindInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TileMemoryBindInfoQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::TileMemorySizeInfoQCOM ) == sizeof( VkTileMemorySizeInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "TileMemorySizeInfoQCOM is not nothrow_move_constructible!" ); - -//=== VK_KHR_copy_memory_indirect === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StridedDeviceAddressRangeKHR ) == sizeof( VkStridedDeviceAddressRangeKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "StridedDeviceAddressRangeKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectCommandKHR ) == sizeof( VkCopyMemoryIndirectCommandKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyMemoryIndirectCommandKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryIndirectInfoKHR ) == sizeof( VkCopyMemoryIndirectInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyMemoryIndirectInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectCommandKHR ) == sizeof( VkCopyMemoryToImageIndirectCommandKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyMemoryToImageIndirectCommandKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CopyMemoryToImageIndirectInfoKHR ) == sizeof( VkCopyMemoryToImageIndirectInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CopyMemoryToImageIndirectInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectFeaturesKHR ) == - sizeof( VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCopyMemoryIndirectFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCopyMemoryIndirectPropertiesKHR ) == - sizeof( VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCopyMemoryIndirectPropertiesKHR is not nothrow_move_constructible!" ); - -//=== VK_EXT_memory_decompression === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DecompressMemoryInfoEXT ) == sizeof( VkDecompressMemoryInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DecompressMemoryInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DecompressMemoryRegionEXT ) == sizeof( VkDecompressMemoryRegionEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DecompressMemoryRegionEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionFeaturesEXT ) == - sizeof( VkPhysicalDeviceMemoryDecompressionFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMemoryDecompressionFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMemoryDecompressionPropertiesEXT ) == - sizeof( VkPhysicalDeviceMemoryDecompressionPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMemoryDecompressionPropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_NV_display_stereo === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplaySurfaceStereoCreateInfoNV ) == sizeof( VkDisplaySurfaceStereoCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplaySurfaceStereoCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DisplayModeStereoPropertiesNV ) == sizeof( VkDisplayModeStereoPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DisplayModeStereoPropertiesNV is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_encode_intra_refresh === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshCapabilitiesKHR ) == sizeof( VkVideoEncodeIntraRefreshCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeIntraRefreshCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeSessionIntraRefreshCreateInfoKHR ) == - sizeof( VkVideoEncodeSessionIntraRefreshCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeSessionIntraRefreshCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeIntraRefreshInfoKHR ) == sizeof( VkVideoEncodeIntraRefreshInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeIntraRefreshInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoReferenceIntraRefreshInfoKHR ) == sizeof( VkVideoReferenceIntraRefreshInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoReferenceIntraRefreshInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR ) == - sizeof( VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_encode_quantization_map === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapCapabilitiesKHR ) == sizeof( VkVideoEncodeQuantizationMapCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeQuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoFormatQuantizationMapPropertiesKHR ) == sizeof( VkVideoFormatQuantizationMapPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoFormatQuantizationMapPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapInfoKHR ) == sizeof( VkVideoEncodeQuantizationMapInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeQuantizationMapInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeQuantizationMapSessionParametersCreateInfoKHR ) == - sizeof( VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeQuantizationMapSessionParametersCreateInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR ) == - sizeof( VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH264QuantizationMapCapabilitiesKHR ) == - sizeof( VkVideoEncodeH264QuantizationMapCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH264QuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeH265QuantizationMapCapabilitiesKHR ) == - sizeof( VkVideoEncodeH265QuantizationMapCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeH265QuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoFormatH265QuantizationMapPropertiesKHR ) == - sizeof( VkVideoFormatH265QuantizationMapPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoFormatH265QuantizationMapPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoEncodeAV1QuantizationMapCapabilitiesKHR ) == - sizeof( VkVideoEncodeAV1QuantizationMapCapabilitiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoEncodeAV1QuantizationMapCapabilitiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoFormatAV1QuantizationMapPropertiesKHR ) == sizeof( VkVideoFormatAV1QuantizationMapPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoFormatAV1QuantizationMapPropertiesKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_raw_access_chains === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV ) == sizeof( VkPhysicalDeviceRawAccessChainsFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRawAccessChainsFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_NV_external_compute_queue === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV ) == sizeof( VkExternalComputeQueueNV ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "ExternalComputeQueueNV is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalComputeQueueNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV ) == sizeof( VkExternalComputeQueueDeviceCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalComputeQueueDeviceCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV ) == sizeof( VkExternalComputeQueueCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalComputeQueueCreateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV ) == sizeof( VkExternalComputeQueueDataParamsNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ExternalComputeQueueDataParamsNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV ) == - sizeof( VkPhysicalDeviceExternalComputeQueuePropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceExternalComputeQueuePropertiesNV is not nothrow_move_constructible!" ); - -//=== VK_KHR_shader_relaxed_extended_instruction === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ) == - sizeof( VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_command_buffer_inheritance === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCommandBufferInheritanceFeaturesNV ) == - sizeof( VkPhysicalDeviceCommandBufferInheritanceFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCommandBufferInheritanceFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_KHR_maintenance7 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance7FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance7FeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance7PropertiesKHR ) == sizeof( VkPhysicalDeviceMaintenance7PropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance7PropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesListKHR ) == sizeof( VkPhysicalDeviceLayeredApiPropertiesListKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceLayeredApiPropertiesListKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiPropertiesKHR ) == sizeof( VkPhysicalDeviceLayeredApiPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceLayeredApiPropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceLayeredApiVulkanPropertiesKHR ) == - sizeof( VkPhysicalDeviceLayeredApiVulkanPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceLayeredApiVulkanPropertiesKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_shader_atomic_float16_vector === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ) == - sizeof( VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_replicated_composites === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderReplicatedCompositesFeaturesEXT ) == - sizeof( VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderReplicatedCompositesFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_float8 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFloat8FeaturesEXT ) == sizeof( VkPhysicalDeviceShaderFloat8FeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderFloat8FeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_NV_ray_tracing_validation === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingValidationFeaturesNV ) == - sizeof( VkPhysicalDeviceRayTracingValidationFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingValidationFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_NV_cluster_acceleration_structure === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructureFeaturesNV ) == - sizeof( VkPhysicalDeviceClusterAccelerationStructureFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceClusterAccelerationStructureFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceClusterAccelerationStructurePropertiesNV ) == - sizeof( VkPhysicalDeviceClusterAccelerationStructurePropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceClusterAccelerationStructurePropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureClustersBottomLevelInputNV ) == - sizeof( VkClusterAccelerationStructureClustersBottomLevelInputNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureClustersBottomLevelInputNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureTriangleClusterInputNV ) == - sizeof( VkClusterAccelerationStructureTriangleClusterInputNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureTriangleClusterInputNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInputNV ) == - sizeof( VkClusterAccelerationStructureMoveObjectsInputNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureMoveObjectsInputNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureOpInputNV ) == sizeof( VkClusterAccelerationStructureOpInputNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureOpInputNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInputInfoNV ) == sizeof( VkClusterAccelerationStructureInputInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureInputInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureCommandsInfoNV ) == sizeof( VkClusterAccelerationStructureCommandsInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureCommandsInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::StridedDeviceAddressNV ) == sizeof( VkStridedDeviceAddressNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "StridedDeviceAddressNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV ) == - sizeof( VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureMoveObjectsInfoNV ) == - sizeof( VkClusterAccelerationStructureMoveObjectsInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureMoveObjectsInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildClustersBottomLevelInfoNV ) == - sizeof( VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureBuildClustersBottomLevelInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterInfoNV ) == - sizeof( VkClusterAccelerationStructureBuildTriangleClusterInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureBuildTriangleClusterInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV ) == - sizeof( VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureInstantiateClusterInfoNV ) == - sizeof( VkClusterAccelerationStructureInstantiateClusterInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureInstantiateClusterInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ClusterAccelerationStructureGetTemplateIndicesInfoNV ) == - sizeof( VkClusterAccelerationStructureGetTemplateIndicesInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ClusterAccelerationStructureGetTemplateIndicesInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RayTracingPipelineClusterAccelerationStructureCreateInfoNV ) == - sizeof( VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RayTracingPipelineClusterAccelerationStructureCreateInfoNV is not nothrow_move_constructible!" ); - -//=== VK_NV_partitioned_acceleration_structure === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructureFeaturesNV ) == - sizeof( VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePartitionedAccelerationStructureFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePartitionedAccelerationStructurePropertiesNV ) == - sizeof( VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePartitionedAccelerationStructurePropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureFlagsNV ) == sizeof( VkPartitionedAccelerationStructureFlagsNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PartitionedAccelerationStructureFlagsNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureIndirectCommandNV ) == - sizeof( VkBuildPartitionedAccelerationStructureIndirectCommandNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BuildPartitionedAccelerationStructureIndirectCommandNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWriteInstanceDataNV ) == - sizeof( VkPartitionedAccelerationStructureWriteInstanceDataNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PartitionedAccelerationStructureWriteInstanceDataNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureUpdateInstanceDataNV ) == - sizeof( VkPartitionedAccelerationStructureUpdateInstanceDataNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PartitionedAccelerationStructureUpdateInstanceDataNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureWritePartitionTranslationDataNV ) == - sizeof( VkPartitionedAccelerationStructureWritePartitionTranslationDataNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PartitionedAccelerationStructureWritePartitionTranslationDataNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteDescriptorSetPartitionedAccelerationStructureNV ) == - sizeof( VkWriteDescriptorSetPartitionedAccelerationStructureNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "WriteDescriptorSetPartitionedAccelerationStructureNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PartitionedAccelerationStructureInstancesInputNV ) == - sizeof( VkPartitionedAccelerationStructureInstancesInputNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PartitionedAccelerationStructureInstancesInputNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BuildPartitionedAccelerationStructureInfoNV ) == - sizeof( VkBuildPartitionedAccelerationStructureInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BuildPartitionedAccelerationStructureInfoNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_device_generated_commands === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT ) == sizeof( VkIndirectCommandsLayoutEXT ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "IndirectCommandsLayoutEXT is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsLayoutEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT ) == sizeof( VkIndirectExecutionSetEXT ), - "handle and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, - "IndirectExecutionSetEXT is not copy_constructible!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectExecutionSetEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT ) == - sizeof( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT ) == - sizeof( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsMemoryRequirementsInfoEXT ) == sizeof( VkGeneratedCommandsMemoryRequirementsInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GeneratedCommandsMemoryRequirementsInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetCreateInfoEXT ) == sizeof( VkIndirectExecutionSetCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectExecutionSetCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetInfoEXT ) == sizeof( VkIndirectExecutionSetInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectExecutionSetInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetPipelineInfoEXT ) == sizeof( VkIndirectExecutionSetPipelineInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectExecutionSetPipelineInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderInfoEXT ) == sizeof( VkIndirectExecutionSetShaderInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectExecutionSetShaderInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsInfoEXT ) == sizeof( VkGeneratedCommandsInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GeneratedCommandsInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetPipelineEXT ) == sizeof( VkWriteIndirectExecutionSetPipelineEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "WriteIndirectExecutionSetPipelineEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutCreateInfoEXT ) == sizeof( VkIndirectCommandsLayoutCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsLayoutCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutTokenEXT ) == sizeof( VkIndirectCommandsLayoutTokenEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsLayoutTokenEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DrawIndirectCountIndirectCommandEXT ) == sizeof( VkDrawIndirectCountIndirectCommandEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DrawIndirectCountIndirectCommandEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsVertexBufferTokenEXT ) == sizeof( VkIndirectCommandsVertexBufferTokenEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsVertexBufferTokenEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindVertexBufferIndirectCommandEXT ) == sizeof( VkBindVertexBufferIndirectCommandEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindVertexBufferIndirectCommandEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsIndexBufferTokenEXT ) == sizeof( VkIndirectCommandsIndexBufferTokenEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsIndexBufferTokenEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BindIndexBufferIndirectCommandEXT ) == sizeof( VkBindIndexBufferIndirectCommandEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BindIndexBufferIndirectCommandEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsPushConstantTokenEXT ) == sizeof( VkIndirectCommandsPushConstantTokenEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsPushConstantTokenEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsExecutionSetTokenEXT ) == sizeof( VkIndirectCommandsExecutionSetTokenEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsExecutionSetTokenEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectCommandsTokenDataEXT ) == sizeof( VkIndirectCommandsTokenDataEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectCommandsTokenDataEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::IndirectExecutionSetShaderLayoutInfoEXT ) == sizeof( VkIndirectExecutionSetShaderLayoutInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "IndirectExecutionSetShaderLayoutInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsPipelineInfoEXT ) == sizeof( VkGeneratedCommandsPipelineInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GeneratedCommandsPipelineInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::GeneratedCommandsShaderInfoEXT ) == sizeof( VkGeneratedCommandsShaderInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "GeneratedCommandsShaderInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::WriteIndirectExecutionSetShaderEXT ) == sizeof( VkWriteIndirectExecutionSetShaderEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "WriteIndirectExecutionSetShaderEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_maintenance8 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryBarrierAccessFlags3KHR ) == sizeof( VkMemoryBarrierAccessFlags3KHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryBarrierAccessFlags3KHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance8FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance8FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance8FeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_MESA_image_alignment_control === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlFeaturesMESA ) == - sizeof( VkPhysicalDeviceImageAlignmentControlFeaturesMESA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageAlignmentControlFeaturesMESA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceImageAlignmentControlPropertiesMESA ) == - sizeof( VkPhysicalDeviceImageAlignmentControlPropertiesMESA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceImageAlignmentControlPropertiesMESA is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImageAlignmentControlCreateInfoMESA ) == sizeof( VkImageAlignmentControlCreateInfoMESA ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImageAlignmentControlCreateInfoMESA is not nothrow_move_constructible!" ); - -//=== VK_KHR_shader_fma === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderFmaFeaturesKHR ) == sizeof( VkPhysicalDeviceShaderFmaFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderFmaFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_NV_push_constant_bank === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PushConstantBankInfoNV ) == sizeof( VkPushConstantBankInfoNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PushConstantBankInfoNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankFeaturesNV ) == sizeof( VkPhysicalDevicePushConstantBankFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePushConstantBankFeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePushConstantBankPropertiesNV ) == sizeof( VkPhysicalDevicePushConstantBankPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePushConstantBankPropertiesNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_ray_tracing_invocation_reorder === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderPropertiesEXT ) == - sizeof( VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingInvocationReorderPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRayTracingInvocationReorderFeaturesEXT ) == - sizeof( VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRayTracingInvocationReorderFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_depth_clamp_control === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampControlFeaturesEXT ) == sizeof( VkPhysicalDeviceDepthClampControlFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDepthClampControlFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineViewportDepthClampControlCreateInfoEXT ) == - sizeof( VkPipelineViewportDepthClampControlCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineViewportDepthClampControlCreateInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DepthClampRangeEXT ) == sizeof( VkDepthClampRangeEXT ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DepthClampRangeEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_maintenance9 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance9FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance9FeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance9PropertiesKHR ) == sizeof( VkPhysicalDeviceMaintenance9PropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance9PropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueueFamilyOwnershipTransferPropertiesKHR ) == sizeof( VkQueueFamilyOwnershipTransferPropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "QueueFamilyOwnershipTransferPropertiesKHR is not nothrow_move_constructible!" ); - -//=== VK_KHR_video_maintenance2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVideoMaintenance2FeaturesKHR ) == sizeof( VkPhysicalDeviceVideoMaintenance2FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVideoMaintenance2FeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH264InlineSessionParametersInfoKHR ) == - sizeof( VkVideoDecodeH264InlineSessionParametersInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH264InlineSessionParametersInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeH265InlineSessionParametersInfoKHR ) == - sizeof( VkVideoDecodeH265InlineSessionParametersInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeH265InlineSessionParametersInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::VideoDecodeAV1InlineSessionParametersInfoKHR ) == - sizeof( VkVideoDecodeAV1InlineSessionParametersInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "VideoDecodeAV1InlineSessionParametersInfoKHR is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_OHOS ) -//=== VK_OHOS_surface === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SurfaceCreateInfoOHOS ) == sizeof( VkSurfaceCreateInfoOHOS ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SurfaceCreateInfoOHOS is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_OHOS*/ - -//=== VK_HUAWEI_hdr_vivid === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceHdrVividFeaturesHUAWEI ) == sizeof( VkPhysicalDeviceHdrVividFeaturesHUAWEI ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceHdrVividFeaturesHUAWEI is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::HdrVividDynamicMetadataHUAWEI ) == sizeof( VkHdrVividDynamicMetadataHUAWEI ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "HdrVividDynamicMetadataHUAWEI is not nothrow_move_constructible!" ); - -//=== VK_NV_cooperative_matrix2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CooperativeMatrixFlexibleDimensionsPropertiesNV ) == - sizeof( VkCooperativeMatrixFlexibleDimensionsPropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CooperativeMatrixFlexibleDimensionsPropertiesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2FeaturesNV ) == sizeof( VkPhysicalDeviceCooperativeMatrix2FeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCooperativeMatrix2FeaturesNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCooperativeMatrix2PropertiesNV ) == - sizeof( VkPhysicalDeviceCooperativeMatrix2PropertiesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCooperativeMatrix2PropertiesNV is not nothrow_move_constructible!" ); - -//=== VK_ARM_pipeline_opacity_micromap === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineOpacityMicromapFeaturesARM ) == - sizeof( VkPhysicalDevicePipelineOpacityMicromapFeaturesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePipelineOpacityMicromapFeaturesARM is not nothrow_move_constructible!" ); - -#if defined( VK_USE_PLATFORM_METAL_EXT ) -//=== VK_EXT_external_memory_metal === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ImportMemoryMetalHandleInfoEXT ) == sizeof( VkImportMemoryMetalHandleInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ImportMemoryMetalHandleInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryMetalHandlePropertiesEXT ) == sizeof( VkMemoryMetalHandlePropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryMetalHandlePropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MemoryGetMetalHandleInfoEXT ) == sizeof( VkMemoryGetMetalHandleInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "MemoryGetMetalHandleInfoEXT is not nothrow_move_constructible!" ); -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -//=== VK_KHR_depth_clamp_zero_one === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDepthClampZeroOneFeaturesKHR ) == sizeof( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDepthClampZeroOneFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_ARM_performance_counters_by_region === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionFeaturesARM ) == - sizeof( VkPhysicalDevicePerformanceCountersByRegionFeaturesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePerformanceCountersByRegionFeaturesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePerformanceCountersByRegionPropertiesARM ) == - sizeof( VkPhysicalDevicePerformanceCountersByRegionPropertiesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePerformanceCountersByRegionPropertiesARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceCounterARM ) == sizeof( VkPerformanceCounterARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceCounterARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerformanceCounterDescriptionARM ) == sizeof( VkPerformanceCounterDescriptionARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PerformanceCounterDescriptionARM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassPerformanceCountersByRegionBeginInfoARM ) == - sizeof( VkRenderPassPerformanceCountersByRegionBeginInfoARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassPerformanceCountersByRegionBeginInfoARM is not nothrow_move_constructible!" ); - -//=== VK_EXT_vertex_attribute_robustness === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceVertexAttributeRobustnessFeaturesEXT ) == - sizeof( VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_ARM_format_pack === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFormatPackFeaturesARM ) == sizeof( VkPhysicalDeviceFormatPackFeaturesARM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFormatPackFeaturesARM is not nothrow_move_constructible!" ); - -//=== VK_VALVE_fragment_density_map_layered === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE ) == - sizeof( VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE ) == - sizeof( VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineFragmentDensityMapLayeredCreateInfoVALVE ) == - sizeof( VkPipelineFragmentDensityMapLayeredCreateInfoVALVE ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineFragmentDensityMapLayeredCreateInfoVALVE is not nothrow_move_constructible!" ); - -//=== VK_KHR_robustness2 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2FeaturesKHR ) == sizeof( VkPhysicalDeviceRobustness2FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRobustness2FeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceRobustness2PropertiesKHR ) == sizeof( VkPhysicalDeviceRobustness2PropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceRobustness2PropertiesKHR is not nothrow_move_constructible!" ); - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) -//=== VK_NV_present_metering === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::SetPresentConfigNV ) == sizeof( VkSetPresentConfigNV ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "SetPresentConfigNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentMeteringFeaturesNV ) == sizeof( VkPhysicalDevicePresentMeteringFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePresentMeteringFeaturesNV is not nothrow_move_constructible!" ); -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -//=== VK_EXT_fragment_density_map_offset === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ) == - sizeof( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ) == - sizeof( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassFragmentDensityMapOffsetEndInfoEXT ) == - sizeof( VkRenderPassFragmentDensityMapOffsetEndInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderPassFragmentDensityMapOffsetEndInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_zero_initialize_device_memory === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT ) == - sizeof( VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_KHR_present_mode_fifo_latest_ready === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR ) == - sizeof( VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_64bit_indexing === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShader64BitIndexingFeaturesEXT ) == - sizeof( VkPhysicalDeviceShader64BitIndexingFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShader64BitIndexingFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_EXT_custom_resolve === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceCustomResolveFeaturesEXT ) == sizeof( VkPhysicalDeviceCustomResolveFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceCustomResolveFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::BeginCustomResolveInfoEXT ) == sizeof( VkBeginCustomResolveInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "BeginCustomResolveInfoEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::CustomResolveCreateInfoEXT ) == sizeof( VkCustomResolveCreateInfoEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "CustomResolveCreateInfoEXT is not nothrow_move_constructible!" ); - -//=== VK_QCOM_data_graph_model === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PipelineCacheHeaderVersionDataGraphQCOM ) == sizeof( VkPipelineCacheHeaderVersionDataGraphQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PipelineCacheHeaderVersionDataGraphQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DataGraphPipelineBuiltinModelCreateInfoQCOM ) == - sizeof( VkDataGraphPipelineBuiltinModelCreateInfoQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "DataGraphPipelineBuiltinModelCreateInfoQCOM is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceDataGraphModelFeaturesQCOM ) == sizeof( VkPhysicalDeviceDataGraphModelFeaturesQCOM ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceDataGraphModelFeaturesQCOM is not nothrow_move_constructible!" ); - -//=== VK_KHR_maintenance10 === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10FeaturesKHR ) == sizeof( VkPhysicalDeviceMaintenance10FeaturesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance10FeaturesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceMaintenance10PropertiesKHR ) == sizeof( VkPhysicalDeviceMaintenance10PropertiesKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceMaintenance10PropertiesKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingEndInfoKHR ) == sizeof( VkRenderingEndInfoKHR ), "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderingEndInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderingAttachmentFlagsInfoKHR ) == sizeof( VkRenderingAttachmentFlagsInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "RenderingAttachmentFlagsInfoKHR is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ResolveImageModeInfoKHR ) == sizeof( VkResolveImageModeInfoKHR ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ResolveImageModeInfoKHR is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_long_vector === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderLongVectorFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderLongVectorFeaturesEXT is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderLongVectorPropertiesEXT ) == - sizeof( VkPhysicalDeviceShaderLongVectorPropertiesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderLongVectorPropertiesEXT is not nothrow_move_constructible!" ); - -//=== VK_SEC_pipeline_cache_incremental_mode === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC ) == - sizeof( VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_uniform_buffer_unsized_array === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT ) == - sizeof( VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT is not nothrow_move_constructible!" ); - -//=== VK_NV_compute_occupancy_priority === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ComputeOccupancyPriorityParametersNV ) == sizeof( VkComputeOccupancyPriorityParametersNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "ComputeOccupancyPriorityParametersNV is not nothrow_move_constructible!" ); - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceComputeOccupancyPriorityFeaturesNV ) == - sizeof( VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceComputeOccupancyPriorityFeaturesNV is not nothrow_move_constructible!" ); - -//=== VK_EXT_shader_subgroup_partitioned === - -VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT ) == - sizeof( VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT ), - "struct and wrapper have different size!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, - "struct wrapper is not a standard layout!" ); -VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, - "PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT is not nothrow_move_constructible!" ); - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_structs.hpp b/lib/vulkan-headers/include/vulkan/vulkan_structs.hpp deleted file mode 100644 index 36e2f1e5c01..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_structs.hpp +++ /dev/null @@ -1,206351 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_STRUCTS_HPP -#define VULKAN_STRUCTS_HPP - -// include-what-you-use: make sure, vulkan.hpp is used by code-completers -// IWYU pragma: private, include "vulkan/vulkan.hpp" - -#if !defined( VULKAN_HPP_CXX_MODULE ) -# include // strcmp -#endif - -namespace VULKAN_HPP_NAMESPACE -{ - - //=============== - //=== STRUCTS === - //=============== - - // wrapper struct for struct VkAabbPositionsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAabbPositionsKHR.html - struct AabbPositionsKHR - { - using NativeType = VkAabbPositionsKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - AabbPositionsKHR( float minX_ = {}, float minY_ = {}, float minZ_ = {}, float maxX_ = {}, float maxY_ = {}, float maxZ_ = {} ) VULKAN_HPP_NOEXCEPT - : minX{ minX_ } - , minY{ minY_ } - , minZ{ minZ_ } - , maxX{ maxX_ } - , maxY{ maxY_ } - , maxZ{ maxZ_ } - { - } - - VULKAN_HPP_CONSTEXPR AabbPositionsKHR( AabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AabbPositionsKHR( VkAabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT : AabbPositionsKHR( *reinterpret_cast( &rhs ) ) {} - - AabbPositionsKHR & operator=( AabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AabbPositionsKHR & operator=( VkAabbPositionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMinX( float minX_ ) & VULKAN_HPP_NOEXCEPT - { - minX = minX_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMinX( float minX_ ) && VULKAN_HPP_NOEXCEPT - { - minX = minX_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMinY( float minY_ ) & VULKAN_HPP_NOEXCEPT - { - minY = minY_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMinY( float minY_ ) && VULKAN_HPP_NOEXCEPT - { - minY = minY_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMinZ( float minZ_ ) & VULKAN_HPP_NOEXCEPT - { - minZ = minZ_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMinZ( float minZ_ ) && VULKAN_HPP_NOEXCEPT - { - minZ = minZ_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMaxX( float maxX_ ) & VULKAN_HPP_NOEXCEPT - { - maxX = maxX_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMaxX( float maxX_ ) && VULKAN_HPP_NOEXCEPT - { - maxX = maxX_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMaxY( float maxY_ ) & VULKAN_HPP_NOEXCEPT - { - maxY = maxY_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMaxY( float maxY_ ) && VULKAN_HPP_NOEXCEPT - { - maxY = maxY_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR & setMaxZ( float maxZ_ ) & VULKAN_HPP_NOEXCEPT - { - maxZ = maxZ_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AabbPositionsKHR && setMaxZ( float maxZ_ ) && VULKAN_HPP_NOEXCEPT - { - maxZ = maxZ_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAabbPositionsKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAabbPositionsKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAabbPositionsKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAabbPositionsKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( minX, minY, minZ, maxX, maxY, maxZ ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AabbPositionsKHR const & ) const = default; -#else - bool operator==( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( minX == rhs.minX ) && ( minY == rhs.minY ) && ( minZ == rhs.minZ ) && ( maxX == rhs.maxX ) && ( maxY == rhs.maxY ) && ( maxZ == rhs.maxZ ); -# endif - } - - bool operator!=( AabbPositionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - float minX = {}; - float minY = {}; - float minZ = {}; - float maxX = {}; - float maxY = {}; - float maxZ = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AabbPositionsKHR; - }; -#endif - using AabbPositionsNV = AabbPositionsKHR; - - union DeviceOrHostAddressConstKHR - { - using NativeType = VkDeviceOrHostAddressConstKHR; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR( DeviceAddress deviceAddress_ = {} ) : deviceAddress( deviceAddress_ ) {} - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR( const void * hostAddress_ ) : hostAddress( hostAddress_ ) {} -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR & setHostAddress( const void * hostAddress_ ) & VULKAN_HPP_NOEXCEPT - { - hostAddress = hostAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstKHR && setHostAddress( const void * hostAddress_ ) && VULKAN_HPP_NOEXCEPT - { - hostAddress = hostAddress_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceOrHostAddressConstKHR const &() const - { - return *reinterpret_cast( this ); - } - - operator VkDeviceOrHostAddressConstKHR &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - DeviceAddress deviceAddress; - const void * hostAddress; -#else - VkDeviceAddress deviceAddress; - const void * hostAddress; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceOrHostAddressConstKHR; - }; -#endif - - // wrapper struct for struct VkAccelerationStructureGeometryTrianglesDataKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryTrianglesDataKHR.html - struct AccelerationStructureGeometryTrianglesDataKHR - { - using NativeType = VkAccelerationStructureGeometryTrianglesDataKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR( Format vertexFormat_ = Format::eUndefined, - DeviceOrHostAddressConstKHR vertexData_ = {}, - DeviceSize vertexStride_ = {}, - uint32_t maxVertex_ = {}, - IndexType indexType_ = IndexType::eUint16, - DeviceOrHostAddressConstKHR indexData_ = {}, - DeviceOrHostAddressConstKHR transformData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vertexFormat{ vertexFormat_ } - , vertexData{ vertexData_ } - , vertexStride{ vertexStride_ } - , maxVertex{ maxVertex_ } - , indexType{ indexType_ } - , indexData{ indexData_ } - , transformData{ transformData_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - AccelerationStructureGeometryTrianglesDataKHR( AccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureGeometryTrianglesDataKHR( VkAccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureGeometryTrianglesDataKHR( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureGeometryTrianglesDataKHR & operator=( AccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureGeometryTrianglesDataKHR & operator=( VkAccelerationStructureGeometryTrianglesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT - { - vertexFormat = vertexFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT - { - vertexFormat = vertexFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexData = vertexData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexData = vertexData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT - { - vertexStride = vertexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT - { - vertexStride = vertexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setMaxVertex( uint32_t maxVertex_ ) & VULKAN_HPP_NOEXCEPT - { - maxVertex = maxVertex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setMaxVertex( uint32_t maxVertex_ ) && VULKAN_HPP_NOEXCEPT - { - maxVertex = maxVertex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) & VULKAN_HPP_NOEXCEPT - { - indexData = indexData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) && - VULKAN_HPP_NOEXCEPT - { - indexData = indexData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR & setTransformData( DeviceOrHostAddressConstKHR const & transformData_ ) & - VULKAN_HPP_NOEXCEPT - { - transformData = transformData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryTrianglesDataKHR && setTransformData( DeviceOrHostAddressConstKHR const & transformData_ ) && - VULKAN_HPP_NOEXCEPT - { - transformData = transformData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureGeometryTrianglesDataKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryTrianglesDataKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryTrianglesDataKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryTrianglesDataKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, vertexFormat, vertexData, vertexStride, maxVertex, indexType, indexData, transformData ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureGeometryTrianglesDataKHR; - const void * pNext = {}; - Format vertexFormat = Format::eUndefined; - DeviceOrHostAddressConstKHR vertexData = {}; - DeviceSize vertexStride = {}; - uint32_t maxVertex = {}; - IndexType indexType = IndexType::eUint16; - DeviceOrHostAddressConstKHR indexData = {}; - DeviceOrHostAddressConstKHR transformData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureGeometryTrianglesDataKHR; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureGeometryTrianglesDataKHR; - }; - - // wrapper struct for struct VkAccelerationStructureGeometryAabbsDataKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryAabbsDataKHR.html - struct AccelerationStructureGeometryAabbsDataKHR - { - using NativeType = VkAccelerationStructureGeometryAabbsDataKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryAabbsDataKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR( DeviceOrHostAddressConstKHR data_ = {}, - DeviceSize stride_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , data{ data_ } - , stride{ stride_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR( AccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureGeometryAabbsDataKHR( VkAccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureGeometryAabbsDataKHR( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureGeometryAabbsDataKHR & operator=( AccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureGeometryAabbsDataKHR & operator=( VkAccelerationStructureGeometryAabbsDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR & setData( DeviceOrHostAddressConstKHR const & data_ ) & VULKAN_HPP_NOEXCEPT - { - data = data_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR && setData( DeviceOrHostAddressConstKHR const & data_ ) && VULKAN_HPP_NOEXCEPT - { - data = data_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR & setStride( DeviceSize stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryAabbsDataKHR && setStride( DeviceSize stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureGeometryAabbsDataKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryAabbsDataKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryAabbsDataKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryAabbsDataKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, data, stride ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureGeometryAabbsDataKHR; - const void * pNext = {}; - DeviceOrHostAddressConstKHR data = {}; - DeviceSize stride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureGeometryAabbsDataKHR; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureGeometryAabbsDataKHR; - }; - - // wrapper struct for struct VkAccelerationStructureGeometryInstancesDataKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryInstancesDataKHR.html - struct AccelerationStructureGeometryInstancesDataKHR - { - using NativeType = VkAccelerationStructureGeometryInstancesDataKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryInstancesDataKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR( Bool32 arrayOfPointers_ = {}, - DeviceOrHostAddressConstKHR data_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , arrayOfPointers{ arrayOfPointers_ } - , data{ data_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - AccelerationStructureGeometryInstancesDataKHR( AccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureGeometryInstancesDataKHR( VkAccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureGeometryInstancesDataKHR( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureGeometryInstancesDataKHR & operator=( AccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureGeometryInstancesDataKHR & operator=( VkAccelerationStructureGeometryInstancesDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR & setArrayOfPointers( Bool32 arrayOfPointers_ ) & VULKAN_HPP_NOEXCEPT - { - arrayOfPointers = arrayOfPointers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR && setArrayOfPointers( Bool32 arrayOfPointers_ ) && VULKAN_HPP_NOEXCEPT - { - arrayOfPointers = arrayOfPointers_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR & setData( DeviceOrHostAddressConstKHR const & data_ ) & VULKAN_HPP_NOEXCEPT - { - data = data_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryInstancesDataKHR && setData( DeviceOrHostAddressConstKHR const & data_ ) && VULKAN_HPP_NOEXCEPT - { - data = data_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureGeometryInstancesDataKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryInstancesDataKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryInstancesDataKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryInstancesDataKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, arrayOfPointers, data ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureGeometryInstancesDataKHR; - const void * pNext = {}; - Bool32 arrayOfPointers = {}; - DeviceOrHostAddressConstKHR data = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureGeometryInstancesDataKHR; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureGeometryInstancesDataKHR; - }; - - union AccelerationStructureGeometryDataKHR - { - using NativeType = VkAccelerationStructureGeometryDataKHR; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR( AccelerationStructureGeometryTrianglesDataKHR triangles_ = {} ) : triangles( triangles_ ) {} - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR( AccelerationStructureGeometryAabbsDataKHR aabbs_ ) : aabbs( aabbs_ ) {} - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR( AccelerationStructureGeometryInstancesDataKHR instances_ ) : instances( instances_ ) {} -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR & setTriangles( AccelerationStructureGeometryTrianglesDataKHR const & triangles_ ) & - VULKAN_HPP_NOEXCEPT - { - triangles = triangles_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR && setTriangles( AccelerationStructureGeometryTrianglesDataKHR const & triangles_ ) && - VULKAN_HPP_NOEXCEPT - { - triangles = triangles_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR & setAabbs( AccelerationStructureGeometryAabbsDataKHR const & aabbs_ ) & VULKAN_HPP_NOEXCEPT - { - aabbs = aabbs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR && setAabbs( AccelerationStructureGeometryAabbsDataKHR const & aabbs_ ) && VULKAN_HPP_NOEXCEPT - { - aabbs = aabbs_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR & setInstances( AccelerationStructureGeometryInstancesDataKHR const & instances_ ) & - VULKAN_HPP_NOEXCEPT - { - instances = instances_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryDataKHR && setInstances( AccelerationStructureGeometryInstancesDataKHR const & instances_ ) && - VULKAN_HPP_NOEXCEPT - { - instances = instances_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureGeometryDataKHR const &() const - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryDataKHR &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - AccelerationStructureGeometryTrianglesDataKHR triangles; - AccelerationStructureGeometryAabbsDataKHR aabbs; - AccelerationStructureGeometryInstancesDataKHR instances; -#else - VkAccelerationStructureGeometryTrianglesDataKHR triangles; - VkAccelerationStructureGeometryAabbsDataKHR aabbs; - VkAccelerationStructureGeometryInstancesDataKHR instances; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureGeometryDataKHR; - }; -#endif - - // wrapper struct for struct VkAccelerationStructureGeometryKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryKHR.html - struct AccelerationStructureGeometryKHR - { - using NativeType = VkAccelerationStructureGeometryKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR( GeometryTypeKHR geometryType_ = GeometryTypeKHR::eTriangles, - AccelerationStructureGeometryDataKHR geometry_ = {}, - GeometryFlagsKHR flags_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , geometryType{ geometryType_ } - , geometry{ geometry_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR( AccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureGeometryKHR( VkAccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureGeometryKHR( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureGeometryKHR & operator=( AccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureGeometryKHR & operator=( VkAccelerationStructureGeometryKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setGeometryType( GeometryTypeKHR geometryType_ ) & VULKAN_HPP_NOEXCEPT - { - geometryType = geometryType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setGeometryType( GeometryTypeKHR geometryType_ ) && VULKAN_HPP_NOEXCEPT - { - geometryType = geometryType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setGeometry( AccelerationStructureGeometryDataKHR const & geometry_ ) & VULKAN_HPP_NOEXCEPT - { - geometry = geometry_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setGeometry( AccelerationStructureGeometryDataKHR const & geometry_ ) && VULKAN_HPP_NOEXCEPT - { - geometry = geometry_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR & setFlags( GeometryFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryKHR && setFlags( GeometryFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureGeometryKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, geometryType, geometry, flags ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureGeometryKHR; - const void * pNext = {}; - GeometryTypeKHR geometryType = GeometryTypeKHR::eTriangles; - AccelerationStructureGeometryDataKHR geometry = {}; - GeometryFlagsKHR flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureGeometryKHR; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureGeometryKHR; - }; - - union DeviceOrHostAddressKHR - { - using NativeType = VkDeviceOrHostAddressKHR; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR( DeviceAddress deviceAddress_ = {} ) : deviceAddress( deviceAddress_ ) {} - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR( void * hostAddress_ ) : hostAddress( hostAddress_ ) {} -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR & setHostAddress( void * hostAddress_ ) & VULKAN_HPP_NOEXCEPT - { - hostAddress = hostAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressKHR && setHostAddress( void * hostAddress_ ) && VULKAN_HPP_NOEXCEPT - { - hostAddress = hostAddress_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceOrHostAddressKHR const &() const - { - return *reinterpret_cast( this ); - } - - operator VkDeviceOrHostAddressKHR &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - DeviceAddress deviceAddress; - void * hostAddress; -#else - VkDeviceAddress deviceAddress; - void * hostAddress; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceOrHostAddressKHR; - }; -#endif - - // wrapper struct for struct VkAccelerationStructureBuildGeometryInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildGeometryInfoKHR.html - struct AccelerationStructureBuildGeometryInfoKHR - { - using NativeType = VkAccelerationStructureBuildGeometryInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureBuildGeometryInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR( AccelerationStructureTypeKHR type_ = AccelerationStructureTypeKHR::eTopLevel, - BuildAccelerationStructureFlagsKHR flags_ = {}, - BuildAccelerationStructureModeKHR mode_ = BuildAccelerationStructureModeKHR::eBuild, - AccelerationStructureKHR srcAccelerationStructure_ = {}, - AccelerationStructureKHR dstAccelerationStructure_ = {}, - uint32_t geometryCount_ = {}, - const AccelerationStructureGeometryKHR * pGeometries_ = {}, - const AccelerationStructureGeometryKHR * const * ppGeometries_ = {}, - DeviceOrHostAddressKHR scratchData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , flags{ flags_ } - , mode{ mode_ } - , srcAccelerationStructure{ srcAccelerationStructure_ } - , dstAccelerationStructure{ dstAccelerationStructure_ } - , geometryCount{ geometryCount_ } - , pGeometries{ pGeometries_ } - , ppGeometries{ ppGeometries_ } - , scratchData{ scratchData_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR( AccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureBuildGeometryInfoKHR( VkAccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureBuildGeometryInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AccelerationStructureBuildGeometryInfoKHR( AccelerationStructureTypeKHR type_, - BuildAccelerationStructureFlagsKHR flags_, - BuildAccelerationStructureModeKHR mode_, - AccelerationStructureKHR srcAccelerationStructure_, - AccelerationStructureKHR dstAccelerationStructure_, - ArrayProxyNoTemporaries const & geometries_, - ArrayProxyNoTemporaries const & pGeometries_ = {}, - DeviceOrHostAddressKHR scratchData_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , type( type_ ) - , flags( flags_ ) - , mode( mode_ ) - , srcAccelerationStructure( srcAccelerationStructure_ ) - , dstAccelerationStructure( dstAccelerationStructure_ ) - , geometryCount( static_cast( !geometries_.empty() ? geometries_.size() : pGeometries_.size() ) ) - , pGeometries( geometries_.data() ) - , ppGeometries( pGeometries_.data() ) - , scratchData( scratchData_ ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( ( !geometries_.empty() + !pGeometries_.empty() ) <= 1 ); -# else - if ( 1 < ( !geometries_.empty() + !pGeometries_.empty() ) ) - { - throw LogicError( - VULKAN_HPP_NAMESPACE_STRING - "::AccelerationStructureBuildGeometryInfoKHR::AccelerationStructureBuildGeometryInfoKHR: 1 < ( !geometries_.empty() + !pGeometries_.empty() )" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - AccelerationStructureBuildGeometryInfoKHR & operator=( AccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureBuildGeometryInfoKHR & operator=( VkAccelerationStructureBuildGeometryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setType( AccelerationStructureTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setType( AccelerationStructureTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setFlags( BuildAccelerationStructureFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setFlags( BuildAccelerationStructureFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setMode( BuildAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setMode( BuildAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setSrcAccelerationStructure( AccelerationStructureKHR srcAccelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - srcAccelerationStructure = srcAccelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setSrcAccelerationStructure( AccelerationStructureKHR srcAccelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - srcAccelerationStructure = srcAccelerationStructure_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setDstAccelerationStructure( AccelerationStructureKHR dstAccelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - dstAccelerationStructure = dstAccelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setDstAccelerationStructure( AccelerationStructureKHR dstAccelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - dstAccelerationStructure = dstAccelerationStructure_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setGeometryCount( uint32_t geometryCount_ ) & VULKAN_HPP_NOEXCEPT - { - geometryCount = geometryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setGeometryCount( uint32_t geometryCount_ ) && VULKAN_HPP_NOEXCEPT - { - geometryCount = geometryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setPGeometries( const AccelerationStructureGeometryKHR * pGeometries_ ) & - VULKAN_HPP_NOEXCEPT - { - pGeometries = pGeometries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setPGeometries( const AccelerationStructureGeometryKHR * pGeometries_ ) && - VULKAN_HPP_NOEXCEPT - { - pGeometries = pGeometries_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AccelerationStructureBuildGeometryInfoKHR & - setGeometries( ArrayProxyNoTemporaries const & geometries_ ) VULKAN_HPP_NOEXCEPT - { - geometryCount = static_cast( geometries_.size() ); - pGeometries = geometries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setPpGeometries( const AccelerationStructureGeometryKHR * const * ppGeometries_ ) & - VULKAN_HPP_NOEXCEPT - { - ppGeometries = ppGeometries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setPpGeometries( const AccelerationStructureGeometryKHR * const * ppGeometries_ ) && - VULKAN_HPP_NOEXCEPT - { - ppGeometries = ppGeometries_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AccelerationStructureBuildGeometryInfoKHR & - setPGeometries( ArrayProxyNoTemporaries const & pGeometries_ ) VULKAN_HPP_NOEXCEPT - { - geometryCount = static_cast( pGeometries_.size() ); - ppGeometries = pGeometries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR & setScratchData( DeviceOrHostAddressKHR const & scratchData_ ) & VULKAN_HPP_NOEXCEPT - { - scratchData = scratchData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildGeometryInfoKHR && setScratchData( DeviceOrHostAddressKHR const & scratchData_ ) && VULKAN_HPP_NOEXCEPT - { - scratchData = scratchData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureBuildGeometryInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureBuildGeometryInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureBuildGeometryInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureBuildGeometryInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, type, flags, mode, srcAccelerationStructure, dstAccelerationStructure, geometryCount, pGeometries, ppGeometries, scratchData ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureBuildGeometryInfoKHR; - const void * pNext = {}; - AccelerationStructureTypeKHR type = AccelerationStructureTypeKHR::eTopLevel; - BuildAccelerationStructureFlagsKHR flags = {}; - BuildAccelerationStructureModeKHR mode = BuildAccelerationStructureModeKHR::eBuild; - AccelerationStructureKHR srcAccelerationStructure = {}; - AccelerationStructureKHR dstAccelerationStructure = {}; - uint32_t geometryCount = {}; - const AccelerationStructureGeometryKHR * pGeometries = {}; - const AccelerationStructureGeometryKHR * const * ppGeometries = {}; - DeviceOrHostAddressKHR scratchData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureBuildGeometryInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureBuildGeometryInfoKHR; - }; - - // wrapper struct for struct VkAccelerationStructureBuildRangeInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildRangeInfoKHR.html - struct AccelerationStructureBuildRangeInfoKHR - { - using NativeType = VkAccelerationStructureBuildRangeInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AccelerationStructureBuildRangeInfoKHR( uint32_t primitiveCount_ = {}, - uint32_t primitiveOffset_ = {}, - uint32_t firstVertex_ = {}, - uint32_t transformOffset_ = {} ) VULKAN_HPP_NOEXCEPT - : primitiveCount{ primitiveCount_ } - , primitiveOffset{ primitiveOffset_ } - , firstVertex{ firstVertex_ } - , transformOffset{ transformOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR AccelerationStructureBuildRangeInfoKHR( AccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureBuildRangeInfoKHR( VkAccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureBuildRangeInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureBuildRangeInfoKHR & operator=( AccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureBuildRangeInfoKHR & operator=( VkAccelerationStructureBuildRangeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setPrimitiveCount( uint32_t primitiveCount_ ) & VULKAN_HPP_NOEXCEPT - { - primitiveCount = primitiveCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setPrimitiveCount( uint32_t primitiveCount_ ) && VULKAN_HPP_NOEXCEPT - { - primitiveCount = primitiveCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setPrimitiveOffset( uint32_t primitiveOffset_ ) & VULKAN_HPP_NOEXCEPT - { - primitiveOffset = primitiveOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setPrimitiveOffset( uint32_t primitiveOffset_ ) && VULKAN_HPP_NOEXCEPT - { - primitiveOffset = primitiveOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setFirstVertex( uint32_t firstVertex_ ) & VULKAN_HPP_NOEXCEPT - { - firstVertex = firstVertex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setFirstVertex( uint32_t firstVertex_ ) && VULKAN_HPP_NOEXCEPT - { - firstVertex = firstVertex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR & setTransformOffset( uint32_t transformOffset_ ) & VULKAN_HPP_NOEXCEPT - { - transformOffset = transformOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureBuildRangeInfoKHR && setTransformOffset( uint32_t transformOffset_ ) && VULKAN_HPP_NOEXCEPT - { - transformOffset = transformOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureBuildRangeInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureBuildRangeInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureBuildRangeInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureBuildRangeInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( primitiveCount, primitiveOffset, firstVertex, transformOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureBuildRangeInfoKHR const & ) const = default; -#else - bool operator==( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( primitiveCount == rhs.primitiveCount ) && ( primitiveOffset == rhs.primitiveOffset ) && ( firstVertex == rhs.firstVertex ) && - ( transformOffset == rhs.transformOffset ); -# endif - } - - bool operator!=( AccelerationStructureBuildRangeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t primitiveCount = {}; - uint32_t primitiveOffset = {}; - uint32_t firstVertex = {}; - uint32_t transformOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureBuildRangeInfoKHR; - }; -#endif - - // wrapper struct for struct VkAccelerationStructureBuildSizesInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureBuildSizesInfoKHR.html - struct AccelerationStructureBuildSizesInfoKHR - { - using NativeType = VkAccelerationStructureBuildSizesInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureBuildSizesInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AccelerationStructureBuildSizesInfoKHR( DeviceSize accelerationStructureSize_ = {}, - DeviceSize updateScratchSize_ = {}, - DeviceSize buildScratchSize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , accelerationStructureSize{ accelerationStructureSize_ } - , updateScratchSize{ updateScratchSize_ } - , buildScratchSize{ buildScratchSize_ } - { - } - - VULKAN_HPP_CONSTEXPR AccelerationStructureBuildSizesInfoKHR( AccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureBuildSizesInfoKHR( VkAccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureBuildSizesInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureBuildSizesInfoKHR & operator=( AccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureBuildSizesInfoKHR & operator=( VkAccelerationStructureBuildSizesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkAccelerationStructureBuildSizesInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureBuildSizesInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureBuildSizesInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureBuildSizesInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, accelerationStructureSize, updateScratchSize, buildScratchSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureBuildSizesInfoKHR const & ) const = default; -#else - bool operator==( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureSize == rhs.accelerationStructureSize ) && - ( updateScratchSize == rhs.updateScratchSize ) && ( buildScratchSize == rhs.buildScratchSize ); -# endif - } - - bool operator!=( AccelerationStructureBuildSizesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureBuildSizesInfoKHR; - void * pNext = {}; - DeviceSize accelerationStructureSize = {}; - DeviceSize updateScratchSize = {}; - DeviceSize buildScratchSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureBuildSizesInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureBuildSizesInfoKHR; - }; - - // wrapper struct for struct VkAccelerationStructureCaptureDescriptorDataInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCaptureDescriptorDataInfoEXT.html - struct AccelerationStructureCaptureDescriptorDataInfoEXT - { - using NativeType = VkAccelerationStructureCaptureDescriptorDataInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AccelerationStructureCaptureDescriptorDataInfoEXT( AccelerationStructureKHR accelerationStructure_ = {}, - AccelerationStructureNV accelerationStructureNV_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , accelerationStructure{ accelerationStructure_ } - , accelerationStructureNV{ accelerationStructureNV_ } - { - } - - VULKAN_HPP_CONSTEXPR - AccelerationStructureCaptureDescriptorDataInfoEXT( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureCaptureDescriptorDataInfoEXT( VkAccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureCaptureDescriptorDataInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureCaptureDescriptorDataInfoEXT & - operator=( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureCaptureDescriptorDataInfoEXT & operator=( VkAccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT & setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT && setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT & setAccelerationStructureNV( AccelerationStructureNV accelerationStructureNV_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructureNV = accelerationStructureNV_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCaptureDescriptorDataInfoEXT && - setAccelerationStructureNV( AccelerationStructureNV accelerationStructureNV_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructureNV = accelerationStructureNV_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, accelerationStructure, accelerationStructureNV ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureCaptureDescriptorDataInfoEXT const & ) const = default; -#else - bool operator==( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ) && - ( accelerationStructureNV == rhs.accelerationStructureNV ); -# endif - } - - bool operator!=( AccelerationStructureCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT; - const void * pNext = {}; - AccelerationStructureKHR accelerationStructure = {}; - AccelerationStructureNV accelerationStructureNV = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureCaptureDescriptorDataInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureCaptureDescriptorDataInfoEXT; - }; - - // wrapper struct for struct VkAccelerationStructureCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateInfoKHR.html - struct AccelerationStructureCreateInfoKHR - { - using NativeType = VkAccelerationStructureCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoKHR( AccelerationStructureCreateFlagsKHR createFlags_ = {}, - Buffer buffer_ = {}, - DeviceSize offset_ = {}, - DeviceSize size_ = {}, - AccelerationStructureTypeKHR type_ = AccelerationStructureTypeKHR::eTopLevel, - DeviceAddress deviceAddress_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , createFlags{ createFlags_ } - , buffer{ buffer_ } - , offset{ offset_ } - , size{ size_ } - , type{ type_ } - , deviceAddress{ deviceAddress_ } - { - } - - VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoKHR( AccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureCreateInfoKHR( VkAccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureCreateInfoKHR & operator=( AccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureCreateInfoKHR & operator=( VkAccelerationStructureCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setCreateFlags( AccelerationStructureCreateFlagsKHR createFlags_ ) & VULKAN_HPP_NOEXCEPT - { - createFlags = createFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setCreateFlags( AccelerationStructureCreateFlagsKHR createFlags_ ) && VULKAN_HPP_NOEXCEPT - { - createFlags = createFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setType( AccelerationStructureTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setType( AccelerationStructureTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureCreateInfoKHR const & ) const = default; -#else - bool operator==( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && - ( size == rhs.size ) && ( type == rhs.type ) && ( deviceAddress == rhs.deviceAddress ); -# endif - } - - bool operator!=( AccelerationStructureCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureCreateInfoKHR; - const void * pNext = {}; - AccelerationStructureCreateFlagsKHR createFlags = {}; - Buffer buffer = {}; - DeviceSize offset = {}; - DeviceSize size = {}; - AccelerationStructureTypeKHR type = AccelerationStructureTypeKHR::eTopLevel; - DeviceAddress deviceAddress = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureCreateInfoKHR; - }; - - // wrapper struct for struct VkGeometryTrianglesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryTrianglesNV.html - struct GeometryTrianglesNV - { - using NativeType = VkGeometryTrianglesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryTrianglesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( Buffer vertexData_ = {}, - DeviceSize vertexOffset_ = {}, - uint32_t vertexCount_ = {}, - DeviceSize vertexStride_ = {}, - Format vertexFormat_ = Format::eUndefined, - Buffer indexData_ = {}, - DeviceSize indexOffset_ = {}, - uint32_t indexCount_ = {}, - IndexType indexType_ = IndexType::eUint16, - Buffer transformData_ = {}, - DeviceSize transformOffset_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vertexData{ vertexData_ } - , vertexOffset{ vertexOffset_ } - , vertexCount{ vertexCount_ } - , vertexStride{ vertexStride_ } - , vertexFormat{ vertexFormat_ } - , indexData{ indexData_ } - , indexOffset{ indexOffset_ } - , indexCount{ indexCount_ } - , indexType{ indexType_ } - , transformData{ transformData_ } - , transformOffset{ transformOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR GeometryTrianglesNV( GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GeometryTrianglesNV( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryTrianglesNV( *reinterpret_cast( &rhs ) ) - { - } - - GeometryTrianglesNV & operator=( GeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GeometryTrianglesNV & operator=( VkGeometryTrianglesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexData( Buffer vertexData_ ) & VULKAN_HPP_NOEXCEPT - { - vertexData = vertexData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexData( Buffer vertexData_ ) && VULKAN_HPP_NOEXCEPT - { - vertexData = vertexData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexOffset( DeviceSize vertexOffset_ ) & VULKAN_HPP_NOEXCEPT - { - vertexOffset = vertexOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexOffset( DeviceSize vertexOffset_ ) && VULKAN_HPP_NOEXCEPT - { - vertexOffset = vertexOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT - { - vertexCount = vertexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT - { - vertexCount = vertexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT - { - vertexStride = vertexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT - { - vertexStride = vertexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT - { - vertexFormat = vertexFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT - { - vertexFormat = vertexFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexData( Buffer indexData_ ) & VULKAN_HPP_NOEXCEPT - { - indexData = indexData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexData( Buffer indexData_ ) && VULKAN_HPP_NOEXCEPT - { - indexData = indexData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexOffset( DeviceSize indexOffset_ ) & VULKAN_HPP_NOEXCEPT - { - indexOffset = indexOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexOffset( DeviceSize indexOffset_ ) && VULKAN_HPP_NOEXCEPT - { - indexOffset = indexOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexCount( uint32_t indexCount_ ) & VULKAN_HPP_NOEXCEPT - { - indexCount = indexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexCount( uint32_t indexCount_ ) && VULKAN_HPP_NOEXCEPT - { - indexCount = indexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setTransformData( Buffer transformData_ ) & VULKAN_HPP_NOEXCEPT - { - transformData = transformData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setTransformData( Buffer transformData_ ) && VULKAN_HPP_NOEXCEPT - { - transformData = transformData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV & setTransformOffset( DeviceSize transformOffset_ ) & VULKAN_HPP_NOEXCEPT - { - transformOffset = transformOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryTrianglesNV && setTransformOffset( DeviceSize transformOffset_ ) && VULKAN_HPP_NOEXCEPT - { - transformOffset = transformOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGeometryTrianglesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeometryTrianglesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeometryTrianglesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGeometryTrianglesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - vertexData, - vertexOffset, - vertexCount, - vertexStride, - vertexFormat, - indexData, - indexOffset, - indexCount, - indexType, - transformData, - transformOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GeometryTrianglesNV const & ) const = default; -#else - bool operator==( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexData == rhs.vertexData ) && ( vertexOffset == rhs.vertexOffset ) && - ( vertexCount == rhs.vertexCount ) && ( vertexStride == rhs.vertexStride ) && ( vertexFormat == rhs.vertexFormat ) && - ( indexData == rhs.indexData ) && ( indexOffset == rhs.indexOffset ) && ( indexCount == rhs.indexCount ) && ( indexType == rhs.indexType ) && - ( transformData == rhs.transformData ) && ( transformOffset == rhs.transformOffset ); -# endif - } - - bool operator!=( GeometryTrianglesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGeometryTrianglesNV; - const void * pNext = {}; - Buffer vertexData = {}; - DeviceSize vertexOffset = {}; - uint32_t vertexCount = {}; - DeviceSize vertexStride = {}; - Format vertexFormat = Format::eUndefined; - Buffer indexData = {}; - DeviceSize indexOffset = {}; - uint32_t indexCount = {}; - IndexType indexType = IndexType::eUint16; - Buffer transformData = {}; - DeviceSize transformOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GeometryTrianglesNV; - }; -#endif - - template <> - struct CppType - { - using Type = GeometryTrianglesNV; - }; - - // wrapper struct for struct VkGeometryAABBNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryAABBNV.html - struct GeometryAABBNV - { - using NativeType = VkGeometryAABBNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryAabbNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GeometryAABBNV( - Buffer aabbData_ = {}, uint32_t numAABBs_ = {}, uint32_t stride_ = {}, DeviceSize offset_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , aabbData{ aabbData_ } - , numAABBs{ numAABBs_ } - , stride{ stride_ } - , offset{ offset_ } - { - } - - VULKAN_HPP_CONSTEXPR GeometryAABBNV( GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GeometryAABBNV( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryAABBNV( *reinterpret_cast( &rhs ) ) {} - - GeometryAABBNV & operator=( GeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GeometryAABBNV & operator=( VkGeometryAABBNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setAabbData( Buffer aabbData_ ) & VULKAN_HPP_NOEXCEPT - { - aabbData = aabbData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setAabbData( Buffer aabbData_ ) && VULKAN_HPP_NOEXCEPT - { - aabbData = aabbData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setNumAABBs( uint32_t numAABBs_ ) & VULKAN_HPP_NOEXCEPT - { - numAABBs = numAABBs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setNumAABBs( uint32_t numAABBs_ ) && VULKAN_HPP_NOEXCEPT - { - numAABBs = numAABBs_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryAABBNV && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGeometryAABBNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeometryAABBNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeometryAABBNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGeometryAABBNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, aabbData, numAABBs, stride, offset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GeometryAABBNV const & ) const = default; -#else - bool operator==( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aabbData == rhs.aabbData ) && ( numAABBs == rhs.numAABBs ) && ( stride == rhs.stride ) && - ( offset == rhs.offset ); -# endif - } - - bool operator!=( GeometryAABBNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGeometryAabbNV; - const void * pNext = {}; - Buffer aabbData = {}; - uint32_t numAABBs = {}; - uint32_t stride = {}; - DeviceSize offset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GeometryAABBNV; - }; -#endif - - template <> - struct CppType - { - using Type = GeometryAABBNV; - }; - - // wrapper struct for struct VkGeometryDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryDataNV.html - struct GeometryDataNV - { - using NativeType = VkGeometryDataNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GeometryDataNV( GeometryTrianglesNV triangles_ = {}, GeometryAABBNV aabbs_ = {} ) VULKAN_HPP_NOEXCEPT - : triangles{ triangles_ } - , aabbs{ aabbs_ } - { - } - - VULKAN_HPP_CONSTEXPR GeometryDataNV( GeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GeometryDataNV( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryDataNV( *reinterpret_cast( &rhs ) ) {} - - GeometryDataNV & operator=( GeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GeometryDataNV & operator=( VkGeometryDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GeometryDataNV & setTriangles( GeometryTrianglesNV const & triangles_ ) & VULKAN_HPP_NOEXCEPT - { - triangles = triangles_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryDataNV && setTriangles( GeometryTrianglesNV const & triangles_ ) && VULKAN_HPP_NOEXCEPT - { - triangles = triangles_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryDataNV & setAabbs( GeometryAABBNV const & aabbs_ ) & VULKAN_HPP_NOEXCEPT - { - aabbs = aabbs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryDataNV && setAabbs( GeometryAABBNV const & aabbs_ ) && VULKAN_HPP_NOEXCEPT - { - aabbs = aabbs_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGeometryDataNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeometryDataNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeometryDataNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGeometryDataNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( triangles, aabbs ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GeometryDataNV const & ) const = default; -#else - bool operator==( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( triangles == rhs.triangles ) && ( aabbs == rhs.aabbs ); -# endif - } - - bool operator!=( GeometryDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - GeometryTrianglesNV triangles = {}; - GeometryAABBNV aabbs = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GeometryDataNV; - }; -#endif - - // wrapper struct for struct VkGeometryNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeometryNV.html - struct GeometryNV - { - using NativeType = VkGeometryNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeometryNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GeometryNV( GeometryTypeKHR geometryType_ = GeometryTypeKHR::eTriangles, - GeometryDataNV geometry_ = {}, - GeometryFlagsKHR flags_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , geometryType{ geometryType_ } - , geometry{ geometry_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR GeometryNV( GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GeometryNV( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT : GeometryNV( *reinterpret_cast( &rhs ) ) {} - - GeometryNV & operator=( GeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GeometryNV & operator=( VkGeometryNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GeometryNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryNV & setGeometryType( GeometryTypeKHR geometryType_ ) & VULKAN_HPP_NOEXCEPT - { - geometryType = geometryType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryNV && setGeometryType( GeometryTypeKHR geometryType_ ) && VULKAN_HPP_NOEXCEPT - { - geometryType = geometryType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryNV & setGeometry( GeometryDataNV const & geometry_ ) & VULKAN_HPP_NOEXCEPT - { - geometry = geometry_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryNV && setGeometry( GeometryDataNV const & geometry_ ) && VULKAN_HPP_NOEXCEPT - { - geometry = geometry_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeometryNV & setFlags( GeometryFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeometryNV && setFlags( GeometryFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGeometryNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeometryNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeometryNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGeometryNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, geometryType, geometry, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GeometryNV const & ) const = default; -#else - bool operator==( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( geometryType == rhs.geometryType ) && ( geometry == rhs.geometry ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( GeometryNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGeometryNV; - const void * pNext = {}; - GeometryTypeKHR geometryType = GeometryTypeKHR::eTriangles; - GeometryDataNV geometry = {}; - GeometryFlagsKHR flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GeometryNV; - }; -#endif - - template <> - struct CppType - { - using Type = GeometryNV; - }; - - // wrapper struct for struct VkAccelerationStructureInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureInfoNV.html - struct AccelerationStructureInfoNV - { - using NativeType = VkAccelerationStructureInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( AccelerationStructureTypeNV type_ = {}, - BuildAccelerationStructureFlagsNV flags_ = {}, - uint32_t instanceCount_ = {}, - uint32_t geometryCount_ = {}, - const GeometryNV * pGeometries_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , flags{ flags_ } - , instanceCount{ instanceCount_ } - , geometryCount{ geometryCount_ } - , pGeometries{ pGeometries_ } - { - } - - VULKAN_HPP_CONSTEXPR AccelerationStructureInfoNV( AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureInfoNV( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AccelerationStructureInfoNV( AccelerationStructureTypeNV type_, - BuildAccelerationStructureFlagsNV flags_, - uint32_t instanceCount_, - ArrayProxyNoTemporaries const & geometries_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , type( type_ ) - , flags( flags_ ) - , instanceCount( instanceCount_ ) - , geometryCount( static_cast( geometries_.size() ) ) - , pGeometries( geometries_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - AccelerationStructureInfoNV & operator=( AccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureInfoNV & operator=( VkAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setType( AccelerationStructureTypeNV type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setType( AccelerationStructureTypeNV type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setFlags( BuildAccelerationStructureFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setFlags( BuildAccelerationStructureFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setInstanceCount( uint32_t instanceCount_ ) & VULKAN_HPP_NOEXCEPT - { - instanceCount = instanceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setInstanceCount( uint32_t instanceCount_ ) && VULKAN_HPP_NOEXCEPT - { - instanceCount = instanceCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setGeometryCount( uint32_t geometryCount_ ) & VULKAN_HPP_NOEXCEPT - { - geometryCount = geometryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setGeometryCount( uint32_t geometryCount_ ) && VULKAN_HPP_NOEXCEPT - { - geometryCount = geometryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV & setPGeometries( const GeometryNV * pGeometries_ ) & VULKAN_HPP_NOEXCEPT - { - pGeometries = pGeometries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInfoNV && setPGeometries( const GeometryNV * pGeometries_ ) && VULKAN_HPP_NOEXCEPT - { - pGeometries = pGeometries_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AccelerationStructureInfoNV & setGeometries( ArrayProxyNoTemporaries const & geometries_ ) VULKAN_HPP_NOEXCEPT - { - geometryCount = static_cast( geometries_.size() ); - pGeometries = geometries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, type, flags, instanceCount, geometryCount, pGeometries ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureInfoNV const & ) const = default; -#else - bool operator==( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( flags == rhs.flags ) && ( instanceCount == rhs.instanceCount ) && - ( geometryCount == rhs.geometryCount ) && ( pGeometries == rhs.pGeometries ); -# endif - } - - bool operator!=( AccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureInfoNV; - const void * pNext = {}; - AccelerationStructureTypeNV type = {}; - BuildAccelerationStructureFlagsNV flags = {}; - uint32_t instanceCount = {}; - uint32_t geometryCount = {}; - const GeometryNV * pGeometries = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureInfoNV; - }; - - // wrapper struct for struct VkAccelerationStructureCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureCreateInfoNV.html - struct AccelerationStructureCreateInfoNV - { - using NativeType = VkAccelerationStructureCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( DeviceSize compactedSize_ = {}, - AccelerationStructureInfoNV info_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , compactedSize{ compactedSize_ } - , info{ info_ } - { - } - - VULKAN_HPP_CONSTEXPR AccelerationStructureCreateInfoNV( AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureCreateInfoNV( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureCreateInfoNV & operator=( AccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureCreateInfoNV & operator=( VkAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV & setCompactedSize( DeviceSize compactedSize_ ) & VULKAN_HPP_NOEXCEPT - { - compactedSize = compactedSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV && setCompactedSize( DeviceSize compactedSize_ ) && VULKAN_HPP_NOEXCEPT - { - compactedSize = compactedSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV & setInfo( AccelerationStructureInfoNV const & info_ ) & VULKAN_HPP_NOEXCEPT - { - info = info_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureCreateInfoNV && setInfo( AccelerationStructureInfoNV const & info_ ) && VULKAN_HPP_NOEXCEPT - { - info = info_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, compactedSize, info ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureCreateInfoNV const & ) const = default; -#else - bool operator==( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compactedSize == rhs.compactedSize ) && ( info == rhs.info ); -# endif - } - - bool operator!=( AccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureCreateInfoNV; - const void * pNext = {}; - DeviceSize compactedSize = {}; - AccelerationStructureInfoNV info = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureCreateInfoNV; - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX.html - struct AccelerationStructureDenseGeometryFormatTrianglesDataAMDX - { - using NativeType = VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( DeviceOrHostAddressConstKHR compressedData_ = {}, - DeviceSize dataSize_ = {}, - uint32_t numTriangles_ = {}, - uint32_t numVertices_ = {}, - uint32_t maxPrimitiveIndex_ = {}, - uint32_t maxGeometryIndex_ = {}, - CompressedTriangleFormatAMDX format_ = CompressedTriangleFormatAMDX::eDgf1, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , compressedData{ compressedData_ } - , dataSize{ dataSize_ } - , numTriangles{ numTriangles_ } - , numVertices{ numVertices_ } - , maxPrimitiveIndex{ maxPrimitiveIndex_ } - , maxGeometryIndex{ maxGeometryIndex_ } - , format{ format_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureDenseGeometryFormatTrianglesDataAMDX( - *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & - operator=( AccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & - operator=( VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & - setCompressedData( DeviceOrHostAddressConstKHR const & compressedData_ ) & - VULKAN_HPP_NOEXCEPT - { - compressedData = compressedData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && - setCompressedData( DeviceOrHostAddressConstKHR const & compressedData_ ) && - VULKAN_HPP_NOEXCEPT - { - compressedData = compressedData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setDataSize( DeviceSize dataSize_ ) & VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setDataSize( DeviceSize dataSize_ ) && VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setNumTriangles( uint32_t numTriangles_ ) & VULKAN_HPP_NOEXCEPT - { - numTriangles = numTriangles_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setNumTriangles( uint32_t numTriangles_ ) && VULKAN_HPP_NOEXCEPT - { - numTriangles = numTriangles_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setNumVertices( uint32_t numVertices_ ) & VULKAN_HPP_NOEXCEPT - { - numVertices = numVertices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setNumVertices( uint32_t numVertices_ ) && VULKAN_HPP_NOEXCEPT - { - numVertices = numVertices_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setMaxPrimitiveIndex( uint32_t maxPrimitiveIndex_ ) & - VULKAN_HPP_NOEXCEPT - { - maxPrimitiveIndex = maxPrimitiveIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setMaxPrimitiveIndex( uint32_t maxPrimitiveIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - maxPrimitiveIndex = maxPrimitiveIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setMaxGeometryIndex( uint32_t maxGeometryIndex_ ) & VULKAN_HPP_NOEXCEPT - { - maxGeometryIndex = maxGeometryIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setMaxGeometryIndex( uint32_t maxGeometryIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - maxGeometryIndex = maxGeometryIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX & setFormat( CompressedTriangleFormatAMDX format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDenseGeometryFormatTrianglesDataAMDX && setFormat( CompressedTriangleFormatAMDX format_ ) && - VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureDenseGeometryFormatTrianglesDataAMDX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, compressedData, dataSize, numTriangles, numVertices, maxPrimitiveIndex, maxGeometryIndex, format ); - } -# endif - - public: - StructureType sType = StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX; - const void * pNext = {}; - DeviceOrHostAddressConstKHR compressedData = {}; - DeviceSize dataSize = {}; - uint32_t numTriangles = {}; - uint32_t numVertices = {}; - uint32_t maxPrimitiveIndex = {}; - uint32_t maxGeometryIndex = {}; - CompressedTriangleFormatAMDX format = CompressedTriangleFormatAMDX::eDgf1; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureDenseGeometryFormatTrianglesDataAMDX; - }; -# endif - - template <> - struct CppType - { - using Type = AccelerationStructureDenseGeometryFormatTrianglesDataAMDX; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkAccelerationStructureDeviceAddressInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureDeviceAddressInfoKHR.html - struct AccelerationStructureDeviceAddressInfoKHR - { - using NativeType = VkAccelerationStructureDeviceAddressInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureDeviceAddressInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AccelerationStructureDeviceAddressInfoKHR( AccelerationStructureKHR accelerationStructure_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , accelerationStructure{ accelerationStructure_ } - { - } - - VULKAN_HPP_CONSTEXPR AccelerationStructureDeviceAddressInfoKHR( AccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureDeviceAddressInfoKHR( VkAccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureDeviceAddressInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureDeviceAddressInfoKHR & operator=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureDeviceAddressInfoKHR & operator=( VkAccelerationStructureDeviceAddressInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR & setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureDeviceAddressInfoKHR && setAccelerationStructure( AccelerationStructureKHR accelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureDeviceAddressInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureDeviceAddressInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureDeviceAddressInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureDeviceAddressInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, accelerationStructure ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureDeviceAddressInfoKHR const & ) const = default; -#else - bool operator==( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ); -# endif - } - - bool operator!=( AccelerationStructureDeviceAddressInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureDeviceAddressInfoKHR; - const void * pNext = {}; - AccelerationStructureKHR accelerationStructure = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureDeviceAddressInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureDeviceAddressInfoKHR; - }; - - // wrapper struct for struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryLinearSweptSpheresDataNV.html - struct AccelerationStructureGeometryLinearSweptSpheresDataNV - { - using NativeType = VkAccelerationStructureGeometryLinearSweptSpheresDataNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryLinearSweptSpheresDataNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - AccelerationStructureGeometryLinearSweptSpheresDataNV( Format vertexFormat_ = Format::eUndefined, - DeviceOrHostAddressConstKHR vertexData_ = {}, - DeviceSize vertexStride_ = {}, - Format radiusFormat_ = Format::eUndefined, - DeviceOrHostAddressConstKHR radiusData_ = {}, - DeviceSize radiusStride_ = {}, - IndexType indexType_ = IndexType::eUint16, - DeviceOrHostAddressConstKHR indexData_ = {}, - DeviceSize indexStride_ = {}, - RayTracingLssIndexingModeNV indexingMode_ = RayTracingLssIndexingModeNV::eList, - RayTracingLssPrimitiveEndCapsModeNV endCapsMode_ = RayTracingLssPrimitiveEndCapsModeNV::eNone, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vertexFormat{ vertexFormat_ } - , vertexData{ vertexData_ } - , vertexStride{ vertexStride_ } - , radiusFormat{ radiusFormat_ } - , radiusData{ radiusData_ } - , radiusStride{ radiusStride_ } - , indexType{ indexType_ } - , indexData{ indexData_ } - , indexStride{ indexStride_ } - , indexingMode{ indexingMode_ } - , endCapsMode{ endCapsMode_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - AccelerationStructureGeometryLinearSweptSpheresDataNV( AccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureGeometryLinearSweptSpheresDataNV( VkAccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureGeometryLinearSweptSpheresDataNV( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureGeometryLinearSweptSpheresDataNV & - operator=( AccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureGeometryLinearSweptSpheresDataNV & operator=( VkAccelerationStructureGeometryLinearSweptSpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT - { - vertexFormat = vertexFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT - { - vertexFormat = vertexFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexData = vertexData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexData = vertexData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT - { - vertexStride = vertexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT - { - vertexStride = vertexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setRadiusFormat( Format radiusFormat_ ) & VULKAN_HPP_NOEXCEPT - { - radiusFormat = radiusFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setRadiusFormat( Format radiusFormat_ ) && VULKAN_HPP_NOEXCEPT - { - radiusFormat = radiusFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) & - VULKAN_HPP_NOEXCEPT - { - radiusData = radiusData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) && - VULKAN_HPP_NOEXCEPT - { - radiusData = radiusData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setRadiusStride( DeviceSize radiusStride_ ) & VULKAN_HPP_NOEXCEPT - { - radiusStride = radiusStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setRadiusStride( DeviceSize radiusStride_ ) && VULKAN_HPP_NOEXCEPT - { - radiusStride = radiusStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) & - VULKAN_HPP_NOEXCEPT - { - indexData = indexData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) && - VULKAN_HPP_NOEXCEPT - { - indexData = indexData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT - { - indexStride = indexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT - { - indexStride = indexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setIndexingMode( RayTracingLssIndexingModeNV indexingMode_ ) & - VULKAN_HPP_NOEXCEPT - { - indexingMode = indexingMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setIndexingMode( RayTracingLssIndexingModeNV indexingMode_ ) && - VULKAN_HPP_NOEXCEPT - { - indexingMode = indexingMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV & setEndCapsMode( RayTracingLssPrimitiveEndCapsModeNV endCapsMode_ ) & - VULKAN_HPP_NOEXCEPT - { - endCapsMode = endCapsMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryLinearSweptSpheresDataNV && setEndCapsMode( RayTracingLssPrimitiveEndCapsModeNV endCapsMode_ ) && - VULKAN_HPP_NOEXCEPT - { - endCapsMode = endCapsMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryLinearSweptSpheresDataNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - vertexFormat, - vertexData, - vertexStride, - radiusFormat, - radiusData, - radiusStride, - indexType, - indexData, - indexStride, - indexingMode, - endCapsMode ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureGeometryLinearSweptSpheresDataNV; - const void * pNext = {}; - Format vertexFormat = Format::eUndefined; - DeviceOrHostAddressConstKHR vertexData = {}; - DeviceSize vertexStride = {}; - Format radiusFormat = Format::eUndefined; - DeviceOrHostAddressConstKHR radiusData = {}; - DeviceSize radiusStride = {}; - IndexType indexType = IndexType::eUint16; - DeviceOrHostAddressConstKHR indexData = {}; - DeviceSize indexStride = {}; - RayTracingLssIndexingModeNV indexingMode = RayTracingLssIndexingModeNV::eList; - RayTracingLssPrimitiveEndCapsModeNV endCapsMode = RayTracingLssPrimitiveEndCapsModeNV::eNone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureGeometryLinearSweptSpheresDataNV; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureGeometryLinearSweptSpheresDataNV; - }; - - // wrapper struct for struct VkAccelerationStructureGeometryMotionTrianglesDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometryMotionTrianglesDataNV.html - struct AccelerationStructureGeometryMotionTrianglesDataNV - { - using NativeType = VkAccelerationStructureGeometryMotionTrianglesDataNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV( DeviceOrHostAddressConstKHR vertexData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vertexData{ vertexData_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - AccelerationStructureGeometryMotionTrianglesDataNV( AccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureGeometryMotionTrianglesDataNV( VkAccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureGeometryMotionTrianglesDataNV( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureGeometryMotionTrianglesDataNV & - operator=( AccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureGeometryMotionTrianglesDataNV & operator=( VkAccelerationStructureGeometryMotionTrianglesDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexData = vertexData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometryMotionTrianglesDataNV && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexData = vertexData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureGeometryMotionTrianglesDataNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryMotionTrianglesDataNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryMotionTrianglesDataNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometryMotionTrianglesDataNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, vertexData ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV; - const void * pNext = {}; - DeviceOrHostAddressConstKHR vertexData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureGeometryMotionTrianglesDataNV; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureGeometryMotionTrianglesDataNV; - }; - - // wrapper struct for struct VkAccelerationStructureGeometrySpheresDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureGeometrySpheresDataNV.html - struct AccelerationStructureGeometrySpheresDataNV - { - using NativeType = VkAccelerationStructureGeometrySpheresDataNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureGeometrySpheresDataNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV( Format vertexFormat_ = Format::eUndefined, - DeviceOrHostAddressConstKHR vertexData_ = {}, - DeviceSize vertexStride_ = {}, - Format radiusFormat_ = Format::eUndefined, - DeviceOrHostAddressConstKHR radiusData_ = {}, - DeviceSize radiusStride_ = {}, - IndexType indexType_ = IndexType::eUint16, - DeviceOrHostAddressConstKHR indexData_ = {}, - DeviceSize indexStride_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vertexFormat{ vertexFormat_ } - , vertexData{ vertexData_ } - , vertexStride{ vertexStride_ } - , radiusFormat{ radiusFormat_ } - , radiusData{ radiusData_ } - , radiusStride{ radiusStride_ } - , indexType{ indexType_ } - , indexData{ indexData_ } - , indexStride{ indexStride_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV( AccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureGeometrySpheresDataNV( VkAccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureGeometrySpheresDataNV( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureGeometrySpheresDataNV & operator=( AccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureGeometrySpheresDataNV & operator=( VkAccelerationStructureGeometrySpheresDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT - { - vertexFormat = vertexFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT - { - vertexFormat = vertexFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) & VULKAN_HPP_NOEXCEPT - { - vertexData = vertexData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setVertexData( DeviceOrHostAddressConstKHR const & vertexData_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexData = vertexData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setVertexStride( DeviceSize vertexStride_ ) & VULKAN_HPP_NOEXCEPT - { - vertexStride = vertexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setVertexStride( DeviceSize vertexStride_ ) && VULKAN_HPP_NOEXCEPT - { - vertexStride = vertexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setRadiusFormat( Format radiusFormat_ ) & VULKAN_HPP_NOEXCEPT - { - radiusFormat = radiusFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setRadiusFormat( Format radiusFormat_ ) && VULKAN_HPP_NOEXCEPT - { - radiusFormat = radiusFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) & VULKAN_HPP_NOEXCEPT - { - radiusData = radiusData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setRadiusData( DeviceOrHostAddressConstKHR const & radiusData_ ) && - VULKAN_HPP_NOEXCEPT - { - radiusData = radiusData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setRadiusStride( DeviceSize radiusStride_ ) & VULKAN_HPP_NOEXCEPT - { - radiusStride = radiusStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setRadiusStride( DeviceSize radiusStride_ ) && VULKAN_HPP_NOEXCEPT - { - radiusStride = radiusStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) & VULKAN_HPP_NOEXCEPT - { - indexData = indexData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setIndexData( DeviceOrHostAddressConstKHR const & indexData_ ) && VULKAN_HPP_NOEXCEPT - { - indexData = indexData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT - { - indexStride = indexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureGeometrySpheresDataNV && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT - { - indexStride = indexStride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureGeometrySpheresDataNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometrySpheresDataNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometrySpheresDataNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureGeometrySpheresDataNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, vertexFormat, vertexData, vertexStride, radiusFormat, radiusData, radiusStride, indexType, indexData, indexStride ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureGeometrySpheresDataNV; - const void * pNext = {}; - Format vertexFormat = Format::eUndefined; - DeviceOrHostAddressConstKHR vertexData = {}; - DeviceSize vertexStride = {}; - Format radiusFormat = Format::eUndefined; - DeviceOrHostAddressConstKHR radiusData = {}; - DeviceSize radiusStride = {}; - IndexType indexType = IndexType::eUint16; - DeviceOrHostAddressConstKHR indexData = {}; - DeviceSize indexStride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureGeometrySpheresDataNV; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureGeometrySpheresDataNV; - }; - - // wrapper struct for struct VkTransformMatrixKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTransformMatrixKHR.html - struct TransformMatrixKHR - { - using NativeType = VkTransformMatrixKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR( std::array, 3> const & matrix_ = {} ) VULKAN_HPP_NOEXCEPT : matrix{ matrix_ } {} - - VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR( TransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TransformMatrixKHR( VkTransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT : TransformMatrixKHR( *reinterpret_cast( &rhs ) ) {} - - TransformMatrixKHR & operator=( TransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TransformMatrixKHR & operator=( VkTransformMatrixKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR & setMatrix( std::array, 3> matrix_ ) & VULKAN_HPP_NOEXCEPT - { - matrix = matrix_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TransformMatrixKHR && setMatrix( std::array, 3> matrix_ ) && VULKAN_HPP_NOEXCEPT - { - matrix = matrix_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTransformMatrixKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTransformMatrixKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTransformMatrixKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTransformMatrixKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( matrix ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TransformMatrixKHR const & ) const = default; -#else - bool operator==( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( matrix == rhs.matrix ); -# endif - } - - bool operator!=( TransformMatrixKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ArrayWrapper2D matrix = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TransformMatrixKHR; - }; -#endif - using TransformMatrixNV = TransformMatrixKHR; - - // wrapper struct for struct VkAccelerationStructureInstanceKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureInstanceKHR.html - struct AccelerationStructureInstanceKHR - { - using NativeType = VkAccelerationStructureInstanceKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR( TransformMatrixKHR transform_ = {}, - uint32_t instanceCustomIndex_ = {}, - uint32_t mask_ = {}, - uint32_t instanceShaderBindingTableRecordOffset_ = {}, - GeometryInstanceFlagsKHR flags_ = {}, - uint64_t accelerationStructureReference_ = {} ) VULKAN_HPP_NOEXCEPT - : transform{ transform_ } - , instanceCustomIndex{ instanceCustomIndex_ } - , mask{ mask_ } - , instanceShaderBindingTableRecordOffset{ instanceShaderBindingTableRecordOffset_ } - , flags{ flags_ } - , accelerationStructureReference{ accelerationStructureReference_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR( AccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureInstanceKHR( VkAccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureInstanceKHR( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureInstanceKHR & operator=( AccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureInstanceKHR & operator=( VkAccelerationStructureInstanceKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setTransform( TransformMatrixKHR const & transform_ ) & VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setTransform( TransformMatrixKHR const & transform_ ) && VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) & VULKAN_HPP_NOEXCEPT - { - instanceCustomIndex = instanceCustomIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) && VULKAN_HPP_NOEXCEPT - { - instanceCustomIndex = instanceCustomIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setMask( uint32_t mask_ ) & VULKAN_HPP_NOEXCEPT - { - mask = mask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setMask( uint32_t mask_ ) && VULKAN_HPP_NOEXCEPT - { - mask = mask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) & - VULKAN_HPP_NOEXCEPT - { - instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) && - VULKAN_HPP_NOEXCEPT - { - instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; - return std::move( *this ); - } - - AccelerationStructureInstanceKHR & setFlags( GeometryInstanceFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = *reinterpret_cast( &flags_ ); - return *this; - } - - AccelerationStructureInstanceKHR && setFlags( GeometryInstanceFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = *reinterpret_cast( &flags_ ); - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR & setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructureReference = accelerationStructureReference_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureInstanceKHR && setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructureReference = accelerationStructureReference_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureInstanceKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureInstanceKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureInstanceKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureInstanceKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( transform, instanceCustomIndex, mask, instanceShaderBindingTableRecordOffset, flags, accelerationStructureReference ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureInstanceKHR const & ) const = default; -#else - bool operator==( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( transform == rhs.transform ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) && ( mask == rhs.mask ) && - ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && ( flags == rhs.flags ) && - ( accelerationStructureReference == rhs.accelerationStructureReference ); -# endif - } - - bool operator!=( AccelerationStructureInstanceKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - TransformMatrixKHR transform = {}; - uint32_t instanceCustomIndex : 24; - uint32_t mask : 8; - uint32_t instanceShaderBindingTableRecordOffset : 24; - VkGeometryInstanceFlagsKHR flags : 8; - uint64_t accelerationStructureReference = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureInstanceKHR; - }; -#endif - using AccelerationStructureInstanceNV = AccelerationStructureInstanceKHR; - - // wrapper struct for struct VkAccelerationStructureMatrixMotionInstanceNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMatrixMotionInstanceNV.html - struct AccelerationStructureMatrixMotionInstanceNV - { - using NativeType = VkAccelerationStructureMatrixMotionInstanceNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV( TransformMatrixKHR transformT0_ = {}, - TransformMatrixKHR transformT1_ = {}, - uint32_t instanceCustomIndex_ = {}, - uint32_t mask_ = {}, - uint32_t instanceShaderBindingTableRecordOffset_ = {}, - GeometryInstanceFlagsKHR flags_ = {}, - uint64_t accelerationStructureReference_ = {} ) VULKAN_HPP_NOEXCEPT - : transformT0{ transformT0_ } - , transformT1{ transformT1_ } - , instanceCustomIndex{ instanceCustomIndex_ } - , mask{ mask_ } - , instanceShaderBindingTableRecordOffset{ instanceShaderBindingTableRecordOffset_ } - , flags{ flags_ } - , accelerationStructureReference{ accelerationStructureReference_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - AccelerationStructureMatrixMotionInstanceNV( AccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureMatrixMotionInstanceNV( VkAccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureMatrixMotionInstanceNV( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureMatrixMotionInstanceNV & operator=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureMatrixMotionInstanceNV & operator=( VkAccelerationStructureMatrixMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setTransformT0( TransformMatrixKHR const & transformT0_ ) & VULKAN_HPP_NOEXCEPT - { - transformT0 = transformT0_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setTransformT0( TransformMatrixKHR const & transformT0_ ) && VULKAN_HPP_NOEXCEPT - { - transformT0 = transformT0_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setTransformT1( TransformMatrixKHR const & transformT1_ ) & VULKAN_HPP_NOEXCEPT - { - transformT1 = transformT1_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setTransformT1( TransformMatrixKHR const & transformT1_ ) && VULKAN_HPP_NOEXCEPT - { - transformT1 = transformT1_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) & VULKAN_HPP_NOEXCEPT - { - instanceCustomIndex = instanceCustomIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) && VULKAN_HPP_NOEXCEPT - { - instanceCustomIndex = instanceCustomIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setMask( uint32_t mask_ ) & VULKAN_HPP_NOEXCEPT - { - mask = mask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setMask( uint32_t mask_ ) && VULKAN_HPP_NOEXCEPT - { - mask = mask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & - setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) & - VULKAN_HPP_NOEXCEPT - { - instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && - setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) && - VULKAN_HPP_NOEXCEPT - { - instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; - return std::move( *this ); - } - - AccelerationStructureMatrixMotionInstanceNV & setFlags( GeometryInstanceFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = *reinterpret_cast( &flags_ ); - return *this; - } - - AccelerationStructureMatrixMotionInstanceNV && setFlags( GeometryInstanceFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = *reinterpret_cast( &flags_ ); - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV & setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructureReference = accelerationStructureReference_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMatrixMotionInstanceNV && setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructureReference = accelerationStructureReference_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureMatrixMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureMatrixMotionInstanceNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureMatrixMotionInstanceNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureMatrixMotionInstanceNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( transformT0, transformT1, instanceCustomIndex, mask, instanceShaderBindingTableRecordOffset, flags, accelerationStructureReference ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureMatrixMotionInstanceNV const & ) const = default; -#else - bool operator==( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) && - ( mask == rhs.mask ) && ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && ( flags == rhs.flags ) && - ( accelerationStructureReference == rhs.accelerationStructureReference ); -# endif - } - - bool operator!=( AccelerationStructureMatrixMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - TransformMatrixKHR transformT0 = {}; - TransformMatrixKHR transformT1 = {}; - uint32_t instanceCustomIndex : 24; - uint32_t mask : 8; - uint32_t instanceShaderBindingTableRecordOffset : 24; - VkGeometryInstanceFlagsKHR flags : 8; - uint64_t accelerationStructureReference = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureMatrixMotionInstanceNV; - }; -#endif - - // wrapper struct for struct VkAccelerationStructureMemoryRequirementsInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMemoryRequirementsInfoNV.html - struct AccelerationStructureMemoryRequirementsInfoNV - { - using NativeType = VkAccelerationStructureMemoryRequirementsInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AccelerationStructureMemoryRequirementsInfoNV( - AccelerationStructureMemoryRequirementsTypeNV type_ = AccelerationStructureMemoryRequirementsTypeNV::eObject, - AccelerationStructureNV accelerationStructure_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , accelerationStructure{ accelerationStructure_ } - { - } - - VULKAN_HPP_CONSTEXPR - AccelerationStructureMemoryRequirementsInfoNV( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureMemoryRequirementsInfoNV( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureMemoryRequirementsInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureMemoryRequirementsInfoNV & operator=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureMemoryRequirementsInfoNV & operator=( VkAccelerationStructureMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV & setType( AccelerationStructureMemoryRequirementsTypeNV type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV && setType( AccelerationStructureMemoryRequirementsTypeNV type_ ) && - VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMemoryRequirementsInfoNV && setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureMemoryRequirementsInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureMemoryRequirementsInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, type, accelerationStructure ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureMemoryRequirementsInfoNV const & ) const = default; -#else - bool operator==( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( accelerationStructure == rhs.accelerationStructure ); -# endif - } - - bool operator!=( AccelerationStructureMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureMemoryRequirementsInfoNV; - const void * pNext = {}; - AccelerationStructureMemoryRequirementsTypeNV type = AccelerationStructureMemoryRequirementsTypeNV::eObject; - AccelerationStructureNV accelerationStructure = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureMemoryRequirementsInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureMemoryRequirementsInfoNV; - }; - - // wrapper struct for struct VkAccelerationStructureMotionInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInfoNV.html - struct AccelerationStructureMotionInfoNV - { - using NativeType = VkAccelerationStructureMotionInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureMotionInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AccelerationStructureMotionInfoNV( uint32_t maxInstances_ = {}, - AccelerationStructureMotionInfoFlagsNV flags_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxInstances{ maxInstances_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR AccelerationStructureMotionInfoNV( AccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureMotionInfoNV( VkAccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureMotionInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureMotionInfoNV & operator=( AccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureMotionInfoNV & operator=( VkAccelerationStructureMotionInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV & setMaxInstances( uint32_t maxInstances_ ) & VULKAN_HPP_NOEXCEPT - { - maxInstances = maxInstances_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV && setMaxInstances( uint32_t maxInstances_ ) && VULKAN_HPP_NOEXCEPT - { - maxInstances = maxInstances_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV & setFlags( AccelerationStructureMotionInfoFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInfoNV && setFlags( AccelerationStructureMotionInfoFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureMotionInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureMotionInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureMotionInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureMotionInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxInstances, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureMotionInfoNV const & ) const = default; -#else - bool operator==( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInstances == rhs.maxInstances ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( AccelerationStructureMotionInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureMotionInfoNV; - const void * pNext = {}; - uint32_t maxInstances = {}; - AccelerationStructureMotionInfoFlagsNV flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureMotionInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureMotionInfoNV; - }; - - // wrapper struct for struct VkSRTDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSRTDataNV.html - struct SRTDataNV - { - using NativeType = VkSRTDataNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SRTDataNV( float sx_ = {}, - float a_ = {}, - float b_ = {}, - float pvx_ = {}, - float sy_ = {}, - float c_ = {}, - float pvy_ = {}, - float sz_ = {}, - float pvz_ = {}, - float qx_ = {}, - float qy_ = {}, - float qz_ = {}, - float qw_ = {}, - float tx_ = {}, - float ty_ = {}, - float tz_ = {} ) VULKAN_HPP_NOEXCEPT - : sx{ sx_ } - , a{ a_ } - , b{ b_ } - , pvx{ pvx_ } - , sy{ sy_ } - , c{ c_ } - , pvy{ pvy_ } - , sz{ sz_ } - , pvz{ pvz_ } - , qx{ qx_ } - , qy{ qy_ } - , qz{ qz_ } - , qw{ qw_ } - , tx{ tx_ } - , ty{ ty_ } - , tz{ tz_ } - { - } - - VULKAN_HPP_CONSTEXPR SRTDataNV( SRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SRTDataNV( VkSRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT : SRTDataNV( *reinterpret_cast( &rhs ) ) {} - - SRTDataNV & operator=( SRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SRTDataNV & operator=( VkSRTDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setSx( float sx_ ) & VULKAN_HPP_NOEXCEPT - { - sx = sx_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setSx( float sx_ ) && VULKAN_HPP_NOEXCEPT - { - sx = sx_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setA( float a_ ) & VULKAN_HPP_NOEXCEPT - { - a = a_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setA( float a_ ) && VULKAN_HPP_NOEXCEPT - { - a = a_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setB( float b_ ) & VULKAN_HPP_NOEXCEPT - { - b = b_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setB( float b_ ) && VULKAN_HPP_NOEXCEPT - { - b = b_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setPvx( float pvx_ ) & VULKAN_HPP_NOEXCEPT - { - pvx = pvx_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setPvx( float pvx_ ) && VULKAN_HPP_NOEXCEPT - { - pvx = pvx_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setSy( float sy_ ) & VULKAN_HPP_NOEXCEPT - { - sy = sy_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setSy( float sy_ ) && VULKAN_HPP_NOEXCEPT - { - sy = sy_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setC( float c_ ) & VULKAN_HPP_NOEXCEPT - { - c = c_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setC( float c_ ) && VULKAN_HPP_NOEXCEPT - { - c = c_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setPvy( float pvy_ ) & VULKAN_HPP_NOEXCEPT - { - pvy = pvy_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setPvy( float pvy_ ) && VULKAN_HPP_NOEXCEPT - { - pvy = pvy_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setSz( float sz_ ) & VULKAN_HPP_NOEXCEPT - { - sz = sz_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setSz( float sz_ ) && VULKAN_HPP_NOEXCEPT - { - sz = sz_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setPvz( float pvz_ ) & VULKAN_HPP_NOEXCEPT - { - pvz = pvz_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setPvz( float pvz_ ) && VULKAN_HPP_NOEXCEPT - { - pvz = pvz_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQx( float qx_ ) & VULKAN_HPP_NOEXCEPT - { - qx = qx_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQx( float qx_ ) && VULKAN_HPP_NOEXCEPT - { - qx = qx_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQy( float qy_ ) & VULKAN_HPP_NOEXCEPT - { - qy = qy_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQy( float qy_ ) && VULKAN_HPP_NOEXCEPT - { - qy = qy_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQz( float qz_ ) & VULKAN_HPP_NOEXCEPT - { - qz = qz_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQz( float qz_ ) && VULKAN_HPP_NOEXCEPT - { - qz = qz_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setQw( float qw_ ) & VULKAN_HPP_NOEXCEPT - { - qw = qw_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setQw( float qw_ ) && VULKAN_HPP_NOEXCEPT - { - qw = qw_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setTx( float tx_ ) & VULKAN_HPP_NOEXCEPT - { - tx = tx_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setTx( float tx_ ) && VULKAN_HPP_NOEXCEPT - { - tx = tx_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setTy( float ty_ ) & VULKAN_HPP_NOEXCEPT - { - ty = ty_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setTy( float ty_ ) && VULKAN_HPP_NOEXCEPT - { - ty = ty_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV & setTz( float tz_ ) & VULKAN_HPP_NOEXCEPT - { - tz = tz_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SRTDataNV && setTz( float tz_ ) && VULKAN_HPP_NOEXCEPT - { - tz = tz_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSRTDataNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSRTDataNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSRTDataNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSRTDataNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sx, a, b, pvx, sy, c, pvy, sz, pvz, qx, qy, qz, qw, tx, ty, tz ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SRTDataNV const & ) const = default; -#else - bool operator==( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sx == rhs.sx ) && ( a == rhs.a ) && ( b == rhs.b ) && ( pvx == rhs.pvx ) && ( sy == rhs.sy ) && ( c == rhs.c ) && ( pvy == rhs.pvy ) && - ( sz == rhs.sz ) && ( pvz == rhs.pvz ) && ( qx == rhs.qx ) && ( qy == rhs.qy ) && ( qz == rhs.qz ) && ( qw == rhs.qw ) && ( tx == rhs.tx ) && - ( ty == rhs.ty ) && ( tz == rhs.tz ); -# endif - } - - bool operator!=( SRTDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - float sx = {}; - float a = {}; - float b = {}; - float pvx = {}; - float sy = {}; - float c = {}; - float pvy = {}; - float sz = {}; - float pvz = {}; - float qx = {}; - float qy = {}; - float qz = {}; - float qw = {}; - float tx = {}; - float ty = {}; - float tz = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SRTDataNV; - }; -#endif - - // wrapper struct for struct VkAccelerationStructureSRTMotionInstanceNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureSRTMotionInstanceNV.html - struct AccelerationStructureSRTMotionInstanceNV - { - using NativeType = VkAccelerationStructureSRTMotionInstanceNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AccelerationStructureSRTMotionInstanceNV( SRTDataNV transformT0_ = {}, - SRTDataNV transformT1_ = {}, - uint32_t instanceCustomIndex_ = {}, - uint32_t mask_ = {}, - uint32_t instanceShaderBindingTableRecordOffset_ = {}, - GeometryInstanceFlagsKHR flags_ = {}, - uint64_t accelerationStructureReference_ = {} ) VULKAN_HPP_NOEXCEPT - : transformT0{ transformT0_ } - , transformT1{ transformT1_ } - , instanceCustomIndex{ instanceCustomIndex_ } - , mask{ mask_ } - , instanceShaderBindingTableRecordOffset{ instanceShaderBindingTableRecordOffset_ } - , flags{ flags_ } - , accelerationStructureReference{ accelerationStructureReference_ } - { - } - - VULKAN_HPP_CONSTEXPR AccelerationStructureSRTMotionInstanceNV( AccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureSRTMotionInstanceNV( VkAccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureSRTMotionInstanceNV( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureSRTMotionInstanceNV & operator=( AccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureSRTMotionInstanceNV & operator=( VkAccelerationStructureSRTMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setTransformT0( SRTDataNV const & transformT0_ ) & VULKAN_HPP_NOEXCEPT - { - transformT0 = transformT0_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setTransformT0( SRTDataNV const & transformT0_ ) && VULKAN_HPP_NOEXCEPT - { - transformT0 = transformT0_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setTransformT1( SRTDataNV const & transformT1_ ) & VULKAN_HPP_NOEXCEPT - { - transformT1 = transformT1_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setTransformT1( SRTDataNV const & transformT1_ ) && VULKAN_HPP_NOEXCEPT - { - transformT1 = transformT1_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) & VULKAN_HPP_NOEXCEPT - { - instanceCustomIndex = instanceCustomIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setInstanceCustomIndex( uint32_t instanceCustomIndex_ ) && VULKAN_HPP_NOEXCEPT - { - instanceCustomIndex = instanceCustomIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setMask( uint32_t mask_ ) & VULKAN_HPP_NOEXCEPT - { - mask = mask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setMask( uint32_t mask_ ) && VULKAN_HPP_NOEXCEPT - { - mask = mask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & - setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) & - VULKAN_HPP_NOEXCEPT - { - instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && - setInstanceShaderBindingTableRecordOffset( uint32_t instanceShaderBindingTableRecordOffset_ ) && - VULKAN_HPP_NOEXCEPT - { - instanceShaderBindingTableRecordOffset = instanceShaderBindingTableRecordOffset_; - return std::move( *this ); - } - - AccelerationStructureSRTMotionInstanceNV & setFlags( GeometryInstanceFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = *reinterpret_cast( &flags_ ); - return *this; - } - - AccelerationStructureSRTMotionInstanceNV && setFlags( GeometryInstanceFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = *reinterpret_cast( &flags_ ); - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV & setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructureReference = accelerationStructureReference_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureSRTMotionInstanceNV && setAccelerationStructureReference( uint64_t accelerationStructureReference_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructureReference = accelerationStructureReference_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureSRTMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureSRTMotionInstanceNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureSRTMotionInstanceNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureSRTMotionInstanceNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( transformT0, transformT1, instanceCustomIndex, mask, instanceShaderBindingTableRecordOffset, flags, accelerationStructureReference ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureSRTMotionInstanceNV const & ) const = default; -#else - bool operator==( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( transformT0 == rhs.transformT0 ) && ( transformT1 == rhs.transformT1 ) && ( instanceCustomIndex == rhs.instanceCustomIndex ) && - ( mask == rhs.mask ) && ( instanceShaderBindingTableRecordOffset == rhs.instanceShaderBindingTableRecordOffset ) && ( flags == rhs.flags ) && - ( accelerationStructureReference == rhs.accelerationStructureReference ); -# endif - } - - bool operator!=( AccelerationStructureSRTMotionInstanceNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - SRTDataNV transformT0 = {}; - SRTDataNV transformT1 = {}; - uint32_t instanceCustomIndex : 24; - uint32_t mask : 8; - uint32_t instanceShaderBindingTableRecordOffset : 24; - VkGeometryInstanceFlagsKHR flags : 8; - uint64_t accelerationStructureReference = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureSRTMotionInstanceNV; - }; -#endif - - union AccelerationStructureMotionInstanceDataNV - { - using NativeType = VkAccelerationStructureMotionInstanceDataNV; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV( AccelerationStructureInstanceKHR staticInstance_ = {} ) - : staticInstance( staticInstance_ ) - { - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV( AccelerationStructureMatrixMotionInstanceNV matrixMotionInstance_ ) - : matrixMotionInstance( matrixMotionInstance_ ) - { - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV( AccelerationStructureSRTMotionInstanceNV srtMotionInstance_ ) - : srtMotionInstance( srtMotionInstance_ ) - { - } -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV & setStaticInstance( AccelerationStructureInstanceKHR const & staticInstance_ ) & - VULKAN_HPP_NOEXCEPT - { - staticInstance = staticInstance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV && setStaticInstance( AccelerationStructureInstanceKHR const & staticInstance_ ) && - VULKAN_HPP_NOEXCEPT - { - staticInstance = staticInstance_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV & - setMatrixMotionInstance( AccelerationStructureMatrixMotionInstanceNV const & matrixMotionInstance_ ) & - VULKAN_HPP_NOEXCEPT - { - matrixMotionInstance = matrixMotionInstance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV && - setMatrixMotionInstance( AccelerationStructureMatrixMotionInstanceNV const & matrixMotionInstance_ ) && - VULKAN_HPP_NOEXCEPT - { - matrixMotionInstance = matrixMotionInstance_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV & - setSrtMotionInstance( AccelerationStructureSRTMotionInstanceNV const & srtMotionInstance_ ) & - VULKAN_HPP_NOEXCEPT - { - srtMotionInstance = srtMotionInstance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceDataNV && - setSrtMotionInstance( AccelerationStructureSRTMotionInstanceNV const & srtMotionInstance_ ) && - VULKAN_HPP_NOEXCEPT - { - srtMotionInstance = srtMotionInstance_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureMotionInstanceDataNV const &() const - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureMotionInstanceDataNV &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - AccelerationStructureInstanceKHR staticInstance; - AccelerationStructureMatrixMotionInstanceNV matrixMotionInstance; - AccelerationStructureSRTMotionInstanceNV srtMotionInstance; -#else - VkAccelerationStructureInstanceKHR staticInstance; - VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance; - VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureMotionInstanceDataNV; - }; -#endif - - // wrapper struct for struct VkAccelerationStructureMotionInstanceNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureMotionInstanceNV.html - struct AccelerationStructureMotionInstanceNV - { - using NativeType = VkAccelerationStructureMotionInstanceNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - AccelerationStructureMotionInstanceNV( AccelerationStructureMotionInstanceTypeNV type_ = AccelerationStructureMotionInstanceTypeNV::eStatic, - AccelerationStructureMotionInstanceFlagsNV flags_ = {}, - AccelerationStructureMotionInstanceDataNV data_ = {} ) VULKAN_HPP_NOEXCEPT - : type{ type_ } - , flags{ flags_ } - , data{ data_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV( AccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureMotionInstanceNV( VkAccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureMotionInstanceNV( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureMotionInstanceNV & operator=( AccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureMotionInstanceNV & operator=( VkAccelerationStructureMotionInstanceNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV & setType( AccelerationStructureMotionInstanceTypeNV type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV && setType( AccelerationStructureMotionInstanceTypeNV type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV & setFlags( AccelerationStructureMotionInstanceFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV && setFlags( AccelerationStructureMotionInstanceFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV & setData( AccelerationStructureMotionInstanceDataNV const & data_ ) & VULKAN_HPP_NOEXCEPT - { - data = data_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureMotionInstanceNV && setData( AccelerationStructureMotionInstanceDataNV const & data_ ) && VULKAN_HPP_NOEXCEPT - { - data = data_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureMotionInstanceNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureMotionInstanceNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureMotionInstanceNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureMotionInstanceNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( type, flags, data ); - } -#endif - - public: - AccelerationStructureMotionInstanceTypeNV type = AccelerationStructureMotionInstanceTypeNV::eStatic; - AccelerationStructureMotionInstanceFlagsNV flags = {}; - AccelerationStructureMotionInstanceDataNV data = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureMotionInstanceNV; - }; -#endif - - // wrapper struct for struct VkMicromapUsageEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapUsageEXT.html - struct MicromapUsageEXT - { - using NativeType = VkMicromapUsageEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MicromapUsageEXT( uint32_t count_ = {}, uint32_t subdivisionLevel_ = {}, uint32_t format_ = {} ) VULKAN_HPP_NOEXCEPT - : count{ count_ } - , subdivisionLevel{ subdivisionLevel_ } - , format{ format_ } - { - } - - VULKAN_HPP_CONSTEXPR MicromapUsageEXT( MicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MicromapUsageEXT( VkMicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT : MicromapUsageEXT( *reinterpret_cast( &rhs ) ) {} - - MicromapUsageEXT & operator=( MicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MicromapUsageEXT & operator=( VkMicromapUsageEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT & setCount( uint32_t count_ ) & VULKAN_HPP_NOEXCEPT - { - count = count_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT && setCount( uint32_t count_ ) && VULKAN_HPP_NOEXCEPT - { - count = count_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT & setSubdivisionLevel( uint32_t subdivisionLevel_ ) & VULKAN_HPP_NOEXCEPT - { - subdivisionLevel = subdivisionLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT && setSubdivisionLevel( uint32_t subdivisionLevel_ ) && VULKAN_HPP_NOEXCEPT - { - subdivisionLevel = subdivisionLevel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT & setFormat( uint32_t format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapUsageEXT && setFormat( uint32_t format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMicromapUsageEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapUsageEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapUsageEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMicromapUsageEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( count, subdivisionLevel, format ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MicromapUsageEXT const & ) const = default; -#else - bool operator==( MicromapUsageEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( count == rhs.count ) && ( subdivisionLevel == rhs.subdivisionLevel ) && ( format == rhs.format ); -# endif - } - - bool operator!=( MicromapUsageEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t count = {}; - uint32_t subdivisionLevel = {}; - uint32_t format = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MicromapUsageEXT; - }; -#endif - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkAccelerationStructureTrianglesDisplacementMicromapNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTrianglesDisplacementMicromapNV.html - struct AccelerationStructureTrianglesDisplacementMicromapNV - { - using NativeType = VkAccelerationStructureTrianglesDisplacementMicromapNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV( Format displacementBiasAndScaleFormat_ = Format::eUndefined, - Format displacementVectorFormat_ = Format::eUndefined, - DeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer_ = {}, - DeviceSize displacementBiasAndScaleStride_ = {}, - DeviceOrHostAddressConstKHR displacementVectorBuffer_ = {}, - DeviceSize displacementVectorStride_ = {}, - DeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags_ = {}, - DeviceSize displacedMicromapPrimitiveFlagsStride_ = {}, - IndexType indexType_ = IndexType::eUint16, - DeviceOrHostAddressConstKHR indexBuffer_ = {}, - DeviceSize indexStride_ = {}, - uint32_t baseTriangle_ = {}, - uint32_t usageCountsCount_ = {}, - const MicromapUsageEXT * pUsageCounts_ = {}, - const MicromapUsageEXT * const * ppUsageCounts_ = {}, - MicromapEXT micromap_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , displacementBiasAndScaleFormat{ displacementBiasAndScaleFormat_ } - , displacementVectorFormat{ displacementVectorFormat_ } - , displacementBiasAndScaleBuffer{ displacementBiasAndScaleBuffer_ } - , displacementBiasAndScaleStride{ displacementBiasAndScaleStride_ } - , displacementVectorBuffer{ displacementVectorBuffer_ } - , displacementVectorStride{ displacementVectorStride_ } - , displacedMicromapPrimitiveFlags{ displacedMicromapPrimitiveFlags_ } - , displacedMicromapPrimitiveFlagsStride{ displacedMicromapPrimitiveFlagsStride_ } - , indexType{ indexType_ } - , indexBuffer{ indexBuffer_ } - , indexStride{ indexStride_ } - , baseTriangle{ baseTriangle_ } - , usageCountsCount{ usageCountsCount_ } - , pUsageCounts{ pUsageCounts_ } - , ppUsageCounts{ ppUsageCounts_ } - , micromap{ micromap_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - AccelerationStructureTrianglesDisplacementMicromapNV( AccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureTrianglesDisplacementMicromapNV( VkAccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureTrianglesDisplacementMicromapNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AccelerationStructureTrianglesDisplacementMicromapNV( Format displacementBiasAndScaleFormat_, - Format displacementVectorFormat_, - DeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer_, - DeviceSize displacementBiasAndScaleStride_, - DeviceOrHostAddressConstKHR displacementVectorBuffer_, - DeviceSize displacementVectorStride_, - DeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags_, - DeviceSize displacedMicromapPrimitiveFlagsStride_, - IndexType indexType_, - DeviceOrHostAddressConstKHR indexBuffer_, - DeviceSize indexStride_, - uint32_t baseTriangle_, - ArrayProxyNoTemporaries const & usageCounts_, - ArrayProxyNoTemporaries const & pUsageCounts_ = {}, - MicromapEXT micromap_ = {}, - void * pNext_ = nullptr ) - : pNext( pNext_ ) - , displacementBiasAndScaleFormat( displacementBiasAndScaleFormat_ ) - , displacementVectorFormat( displacementVectorFormat_ ) - , displacementBiasAndScaleBuffer( displacementBiasAndScaleBuffer_ ) - , displacementBiasAndScaleStride( displacementBiasAndScaleStride_ ) - , displacementVectorBuffer( displacementVectorBuffer_ ) - , displacementVectorStride( displacementVectorStride_ ) - , displacedMicromapPrimitiveFlags( displacedMicromapPrimitiveFlags_ ) - , displacedMicromapPrimitiveFlagsStride( displacedMicromapPrimitiveFlagsStride_ ) - , indexType( indexType_ ) - , indexBuffer( indexBuffer_ ) - , indexStride( indexStride_ ) - , baseTriangle( baseTriangle_ ) - , usageCountsCount( static_cast( usageCounts_.size() ) ) - , pUsageCounts( usageCounts_.data() ) - , ppUsageCounts( pUsageCounts_.data() ) - , micromap( micromap_ ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( usageCounts_.empty() || pUsageCounts_.empty() || ( usageCounts_.size() == pUsageCounts_.size() ) ); -# else - if ( !usageCounts_.empty() && !pUsageCounts_.empty() && ( usageCounts_.size() != pUsageCounts_.size() ) ) - { - throw LogicError( - VULKAN_HPP_NAMESPACE_STRING - "::AccelerationStructureTrianglesDisplacementMicromapNV::AccelerationStructureTrianglesDisplacementMicromapNV: !usageCounts_.empty() && !pUsageCounts_.empty() && ( usageCounts_.size() != pUsageCounts_.size() )" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - AccelerationStructureTrianglesDisplacementMicromapNV & - operator=( AccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureTrianglesDisplacementMicromapNV & operator=( VkAccelerationStructureTrianglesDisplacementMicromapNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setDisplacementBiasAndScaleFormat( Format displacementBiasAndScaleFormat_ ) & - VULKAN_HPP_NOEXCEPT - { - displacementBiasAndScaleFormat = displacementBiasAndScaleFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && - setDisplacementBiasAndScaleFormat( Format displacementBiasAndScaleFormat_ ) && - VULKAN_HPP_NOEXCEPT - { - displacementBiasAndScaleFormat = displacementBiasAndScaleFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setDisplacementVectorFormat( Format displacementVectorFormat_ ) & - VULKAN_HPP_NOEXCEPT - { - displacementVectorFormat = displacementVectorFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setDisplacementVectorFormat( Format displacementVectorFormat_ ) && - VULKAN_HPP_NOEXCEPT - { - displacementVectorFormat = displacementVectorFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & - setDisplacementBiasAndScaleBuffer( DeviceOrHostAddressConstKHR const & displacementBiasAndScaleBuffer_ ) & - VULKAN_HPP_NOEXCEPT - { - displacementBiasAndScaleBuffer = displacementBiasAndScaleBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && - setDisplacementBiasAndScaleBuffer( DeviceOrHostAddressConstKHR const & displacementBiasAndScaleBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - displacementBiasAndScaleBuffer = displacementBiasAndScaleBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & - setDisplacementBiasAndScaleStride( DeviceSize displacementBiasAndScaleStride_ ) & - VULKAN_HPP_NOEXCEPT - { - displacementBiasAndScaleStride = displacementBiasAndScaleStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && - setDisplacementBiasAndScaleStride( DeviceSize displacementBiasAndScaleStride_ ) && - VULKAN_HPP_NOEXCEPT - { - displacementBiasAndScaleStride = displacementBiasAndScaleStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & - setDisplacementVectorBuffer( DeviceOrHostAddressConstKHR const & displacementVectorBuffer_ ) & - VULKAN_HPP_NOEXCEPT - { - displacementVectorBuffer = displacementVectorBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && - setDisplacementVectorBuffer( DeviceOrHostAddressConstKHR const & displacementVectorBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - displacementVectorBuffer = displacementVectorBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setDisplacementVectorStride( DeviceSize displacementVectorStride_ ) & - VULKAN_HPP_NOEXCEPT - { - displacementVectorStride = displacementVectorStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setDisplacementVectorStride( DeviceSize displacementVectorStride_ ) && - VULKAN_HPP_NOEXCEPT - { - displacementVectorStride = displacementVectorStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & - setDisplacedMicromapPrimitiveFlags( DeviceOrHostAddressConstKHR const & displacedMicromapPrimitiveFlags_ ) & - VULKAN_HPP_NOEXCEPT - { - displacedMicromapPrimitiveFlags = displacedMicromapPrimitiveFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && - setDisplacedMicromapPrimitiveFlags( DeviceOrHostAddressConstKHR const & displacedMicromapPrimitiveFlags_ ) && - VULKAN_HPP_NOEXCEPT - { - displacedMicromapPrimitiveFlags = displacedMicromapPrimitiveFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & - setDisplacedMicromapPrimitiveFlagsStride( DeviceSize displacedMicromapPrimitiveFlagsStride_ ) & - VULKAN_HPP_NOEXCEPT - { - displacedMicromapPrimitiveFlagsStride = displacedMicromapPrimitiveFlagsStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && - setDisplacedMicromapPrimitiveFlagsStride( DeviceSize displacedMicromapPrimitiveFlagsStride_ ) && - VULKAN_HPP_NOEXCEPT - { - displacedMicromapPrimitiveFlagsStride = displacedMicromapPrimitiveFlagsStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) & - VULKAN_HPP_NOEXCEPT - { - indexBuffer = indexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - indexBuffer = indexBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT - { - indexStride = indexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT - { - indexStride = indexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setBaseTriangle( uint32_t baseTriangle_ ) & VULKAN_HPP_NOEXCEPT - { - baseTriangle = baseTriangle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setBaseTriangle( uint32_t baseTriangle_ ) && VULKAN_HPP_NOEXCEPT - { - baseTriangle = baseTriangle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setUsageCountsCount( uint32_t usageCountsCount_ ) & VULKAN_HPP_NOEXCEPT - { - usageCountsCount = usageCountsCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setUsageCountsCount( uint32_t usageCountsCount_ ) && VULKAN_HPP_NOEXCEPT - { - usageCountsCount = usageCountsCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) & - VULKAN_HPP_NOEXCEPT - { - pUsageCounts = pUsageCounts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) && - VULKAN_HPP_NOEXCEPT - { - pUsageCounts = pUsageCounts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AccelerationStructureTrianglesDisplacementMicromapNV & - setUsageCounts( ArrayProxyNoTemporaries const & usageCounts_ ) VULKAN_HPP_NOEXCEPT - { - usageCountsCount = static_cast( usageCounts_.size() ); - pUsageCounts = usageCounts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) & - VULKAN_HPP_NOEXCEPT - { - ppUsageCounts = ppUsageCounts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) && - VULKAN_HPP_NOEXCEPT - { - ppUsageCounts = ppUsageCounts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AccelerationStructureTrianglesDisplacementMicromapNV & - setPUsageCounts( ArrayProxyNoTemporaries const & pUsageCounts_ ) VULKAN_HPP_NOEXCEPT - { - usageCountsCount = static_cast( pUsageCounts_.size() ); - ppUsageCounts = pUsageCounts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV & setMicromap( MicromapEXT micromap_ ) & VULKAN_HPP_NOEXCEPT - { - micromap = micromap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesDisplacementMicromapNV && setMicromap( MicromapEXT micromap_ ) && VULKAN_HPP_NOEXCEPT - { - micromap = micromap_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureTrianglesDisplacementMicromapNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureTrianglesDisplacementMicromapNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureTrianglesDisplacementMicromapNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureTrianglesDisplacementMicromapNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - displacementBiasAndScaleFormat, - displacementVectorFormat, - displacementBiasAndScaleBuffer, - displacementBiasAndScaleStride, - displacementVectorBuffer, - displacementVectorStride, - displacedMicromapPrimitiveFlags, - displacedMicromapPrimitiveFlagsStride, - indexType, - indexBuffer, - indexStride, - baseTriangle, - usageCountsCount, - pUsageCounts, - ppUsageCounts, - micromap ); - } -# endif - - public: - StructureType sType = StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV; - void * pNext = {}; - Format displacementBiasAndScaleFormat = Format::eUndefined; - Format displacementVectorFormat = Format::eUndefined; - DeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer = {}; - DeviceSize displacementBiasAndScaleStride = {}; - DeviceOrHostAddressConstKHR displacementVectorBuffer = {}; - DeviceSize displacementVectorStride = {}; - DeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags = {}; - DeviceSize displacedMicromapPrimitiveFlagsStride = {}; - IndexType indexType = IndexType::eUint16; - DeviceOrHostAddressConstKHR indexBuffer = {}; - DeviceSize indexStride = {}; - uint32_t baseTriangle = {}; - uint32_t usageCountsCount = {}; - const MicromapUsageEXT * pUsageCounts = {}; - const MicromapUsageEXT * const * ppUsageCounts = {}; - MicromapEXT micromap = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureTrianglesDisplacementMicromapNV; - }; -# endif - - template <> - struct CppType - { - using Type = AccelerationStructureTrianglesDisplacementMicromapNV; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkAccelerationStructureTrianglesOpacityMicromapEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureTrianglesOpacityMicromapEXT.html - struct AccelerationStructureTrianglesOpacityMicromapEXT - { - using NativeType = VkAccelerationStructureTrianglesOpacityMicromapEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT( IndexType indexType_ = IndexType::eUint16, - DeviceOrHostAddressConstKHR indexBuffer_ = {}, - DeviceSize indexStride_ = {}, - uint32_t baseTriangle_ = {}, - uint32_t usageCountsCount_ = {}, - const MicromapUsageEXT * pUsageCounts_ = {}, - const MicromapUsageEXT * const * ppUsageCounts_ = {}, - MicromapEXT micromap_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , indexType{ indexType_ } - , indexBuffer{ indexBuffer_ } - , indexStride{ indexStride_ } - , baseTriangle{ baseTriangle_ } - , usageCountsCount{ usageCountsCount_ } - , pUsageCounts{ pUsageCounts_ } - , ppUsageCounts{ ppUsageCounts_ } - , micromap{ micromap_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - AccelerationStructureTrianglesOpacityMicromapEXT( AccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureTrianglesOpacityMicromapEXT( VkAccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureTrianglesOpacityMicromapEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AccelerationStructureTrianglesOpacityMicromapEXT( IndexType indexType_, - DeviceOrHostAddressConstKHR indexBuffer_, - DeviceSize indexStride_, - uint32_t baseTriangle_, - ArrayProxyNoTemporaries const & usageCounts_, - ArrayProxyNoTemporaries const & pUsageCounts_ = {}, - MicromapEXT micromap_ = {}, - void * pNext_ = nullptr ) - : pNext( pNext_ ) - , indexType( indexType_ ) - , indexBuffer( indexBuffer_ ) - , indexStride( indexStride_ ) - , baseTriangle( baseTriangle_ ) - , usageCountsCount( static_cast( !usageCounts_.empty() ? usageCounts_.size() : pUsageCounts_.size() ) ) - , pUsageCounts( usageCounts_.data() ) - , ppUsageCounts( pUsageCounts_.data() ) - , micromap( micromap_ ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( ( !usageCounts_.empty() + !pUsageCounts_.empty() ) <= 1 ); -# else - if ( 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() ) ) - { - throw LogicError( - VULKAN_HPP_NAMESPACE_STRING - "::AccelerationStructureTrianglesOpacityMicromapEXT::AccelerationStructureTrianglesOpacityMicromapEXT: 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() )" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - AccelerationStructureTrianglesOpacityMicromapEXT & operator=( AccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureTrianglesOpacityMicromapEXT & operator=( VkAccelerationStructureTrianglesOpacityMicromapEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) & - VULKAN_HPP_NOEXCEPT - { - indexBuffer = indexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setIndexBuffer( DeviceOrHostAddressConstKHR const & indexBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - indexBuffer = indexBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setIndexStride( DeviceSize indexStride_ ) & VULKAN_HPP_NOEXCEPT - { - indexStride = indexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setIndexStride( DeviceSize indexStride_ ) && VULKAN_HPP_NOEXCEPT - { - indexStride = indexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setBaseTriangle( uint32_t baseTriangle_ ) & VULKAN_HPP_NOEXCEPT - { - baseTriangle = baseTriangle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setBaseTriangle( uint32_t baseTriangle_ ) && VULKAN_HPP_NOEXCEPT - { - baseTriangle = baseTriangle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setUsageCountsCount( uint32_t usageCountsCount_ ) & VULKAN_HPP_NOEXCEPT - { - usageCountsCount = usageCountsCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setUsageCountsCount( uint32_t usageCountsCount_ ) && VULKAN_HPP_NOEXCEPT - { - usageCountsCount = usageCountsCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) & VULKAN_HPP_NOEXCEPT - { - pUsageCounts = pUsageCounts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) && VULKAN_HPP_NOEXCEPT - { - pUsageCounts = pUsageCounts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AccelerationStructureTrianglesOpacityMicromapEXT & - setUsageCounts( ArrayProxyNoTemporaries const & usageCounts_ ) VULKAN_HPP_NOEXCEPT - { - usageCountsCount = static_cast( usageCounts_.size() ); - pUsageCounts = usageCounts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) & - VULKAN_HPP_NOEXCEPT - { - ppUsageCounts = ppUsageCounts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) && - VULKAN_HPP_NOEXCEPT - { - ppUsageCounts = ppUsageCounts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AccelerationStructureTrianglesOpacityMicromapEXT & - setPUsageCounts( ArrayProxyNoTemporaries const & pUsageCounts_ ) VULKAN_HPP_NOEXCEPT - { - usageCountsCount = static_cast( pUsageCounts_.size() ); - ppUsageCounts = pUsageCounts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT & setMicromap( MicromapEXT micromap_ ) & VULKAN_HPP_NOEXCEPT - { - micromap = micromap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureTrianglesOpacityMicromapEXT && setMicromap( MicromapEXT micromap_ ) && VULKAN_HPP_NOEXCEPT - { - micromap = micromap_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureTrianglesOpacityMicromapEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureTrianglesOpacityMicromapEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureTrianglesOpacityMicromapEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureTrianglesOpacityMicromapEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, indexType, indexBuffer, indexStride, baseTriangle, usageCountsCount, pUsageCounts, ppUsageCounts, micromap ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT; - void * pNext = {}; - IndexType indexType = IndexType::eUint16; - DeviceOrHostAddressConstKHR indexBuffer = {}; - DeviceSize indexStride = {}; - uint32_t baseTriangle = {}; - uint32_t usageCountsCount = {}; - const MicromapUsageEXT * pUsageCounts = {}; - const MicromapUsageEXT * const * ppUsageCounts = {}; - MicromapEXT micromap = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureTrianglesOpacityMicromapEXT; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureTrianglesOpacityMicromapEXT; - }; - - // wrapper struct for struct VkAccelerationStructureVersionInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAccelerationStructureVersionInfoKHR.html - struct AccelerationStructureVersionInfoKHR - { - using NativeType = VkAccelerationStructureVersionInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAccelerationStructureVersionInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AccelerationStructureVersionInfoKHR( const uint8_t * pVersionData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pVersionData{ pVersionData_ } - { - } - - VULKAN_HPP_CONSTEXPR AccelerationStructureVersionInfoKHR( AccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AccelerationStructureVersionInfoKHR( VkAccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AccelerationStructureVersionInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - AccelerationStructureVersionInfoKHR & operator=( AccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AccelerationStructureVersionInfoKHR & operator=( VkAccelerationStructureVersionInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR & setPVersionData( const uint8_t * pVersionData_ ) & VULKAN_HPP_NOEXCEPT - { - pVersionData = pVersionData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AccelerationStructureVersionInfoKHR && setPVersionData( const uint8_t * pVersionData_ ) && VULKAN_HPP_NOEXCEPT - { - pVersionData = pVersionData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAccelerationStructureVersionInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureVersionInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAccelerationStructureVersionInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAccelerationStructureVersionInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pVersionData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AccelerationStructureVersionInfoKHR const & ) const = default; -#else - bool operator==( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData ); -# endif - } - - bool operator!=( AccelerationStructureVersionInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAccelerationStructureVersionInfoKHR; - const void * pNext = {}; - const uint8_t * pVersionData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AccelerationStructureVersionInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = AccelerationStructureVersionInfoKHR; - }; - - // wrapper struct for struct VkAcquireNextImageInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAcquireNextImageInfoKHR.html - struct AcquireNextImageInfoKHR - { - using NativeType = VkAcquireNextImageInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAcquireNextImageInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( SwapchainKHR swapchain_ = {}, - uint64_t timeout_ = {}, - Semaphore semaphore_ = {}, - Fence fence_ = {}, - uint32_t deviceMask_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchain{ swapchain_ } - , timeout{ timeout_ } - , semaphore{ semaphore_ } - , fence{ fence_ } - , deviceMask{ deviceMask_ } - { - } - - VULKAN_HPP_CONSTEXPR AcquireNextImageInfoKHR( AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AcquireNextImageInfoKHR( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AcquireNextImageInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - AcquireNextImageInfoKHR & operator=( AcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AcquireNextImageInfoKHR & operator=( VkAcquireNextImageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setTimeout( uint64_t timeout_ ) & VULKAN_HPP_NOEXCEPT - { - timeout = timeout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setTimeout( uint64_t timeout_ ) && VULKAN_HPP_NOEXCEPT - { - timeout = timeout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setFence( Fence fence_ ) & VULKAN_HPP_NOEXCEPT - { - fence = fence_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setFence( Fence fence_ ) && VULKAN_HPP_NOEXCEPT - { - fence = fence_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT - { - deviceMask = deviceMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AcquireNextImageInfoKHR && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT - { - deviceMask = deviceMask_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAcquireNextImageInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAcquireNextImageInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAcquireNextImageInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAcquireNextImageInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchain, timeout, semaphore, fence, deviceMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AcquireNextImageInfoKHR const & ) const = default; -#else - bool operator==( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( timeout == rhs.timeout ) && - ( semaphore == rhs.semaphore ) && ( fence == rhs.fence ) && ( deviceMask == rhs.deviceMask ); -# endif - } - - bool operator!=( AcquireNextImageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAcquireNextImageInfoKHR; - const void * pNext = {}; - SwapchainKHR swapchain = {}; - uint64_t timeout = {}; - Semaphore semaphore = {}; - Fence fence = {}; - uint32_t deviceMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AcquireNextImageInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = AcquireNextImageInfoKHR; - }; - - // wrapper struct for struct VkAcquireProfilingLockInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAcquireProfilingLockInfoKHR.html - struct AcquireProfilingLockInfoKHR - { - using NativeType = VkAcquireProfilingLockInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAcquireProfilingLockInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - AcquireProfilingLockInfoKHR( AcquireProfilingLockFlagsKHR flags_ = {}, uint64_t timeout_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , timeout{ timeout_ } - { - } - - VULKAN_HPP_CONSTEXPR AcquireProfilingLockInfoKHR( AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AcquireProfilingLockInfoKHR( VkAcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AcquireProfilingLockInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - AcquireProfilingLockInfoKHR & operator=( AcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AcquireProfilingLockInfoKHR & operator=( VkAcquireProfilingLockInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR & setFlags( AcquireProfilingLockFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR && setFlags( AcquireProfilingLockFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR & setTimeout( uint64_t timeout_ ) & VULKAN_HPP_NOEXCEPT - { - timeout = timeout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AcquireProfilingLockInfoKHR && setTimeout( uint64_t timeout_ ) && VULKAN_HPP_NOEXCEPT - { - timeout = timeout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAcquireProfilingLockInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAcquireProfilingLockInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAcquireProfilingLockInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAcquireProfilingLockInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, timeout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AcquireProfilingLockInfoKHR const & ) const = default; -#else - bool operator==( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( timeout == rhs.timeout ); -# endif - } - - bool operator!=( AcquireProfilingLockInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAcquireProfilingLockInfoKHR; - const void * pNext = {}; - AcquireProfilingLockFlagsKHR flags = {}; - uint64_t timeout = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AcquireProfilingLockInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = AcquireProfilingLockInfoKHR; - }; - - typedef void *( VKAPI_PTR * PFN_AllocationFunction )( void * pUserData, size_t size, size_t alignment, SystemAllocationScope allocationScope ); - - typedef void *( VKAPI_PTR * PFN_ReallocationFunction )( - void * pUserData, void * pOriginal, size_t size, size_t alignment, SystemAllocationScope allocationScope ); - - typedef void( VKAPI_PTR * PFN_FreeFunction )( void * pUserData, void * pMemory ); - - typedef void( VKAPI_PTR * PFN_InternalAllocationNotification )( void * pUserData, - size_t size, - InternalAllocationType allocationType, - SystemAllocationScope allocationScope ); - - typedef void( VKAPI_PTR * PFN_InternalFreeNotification )( void * pUserData, - size_t size, - InternalAllocationType allocationType, - SystemAllocationScope allocationScope ); - - // wrapper struct for struct VkAllocationCallbacks, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAllocationCallbacks.html - struct AllocationCallbacks - { - using NativeType = VkAllocationCallbacks; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AllocationCallbacks( void * pUserData_ = {}, - PFN_AllocationFunction pfnAllocation_ = {}, - PFN_ReallocationFunction pfnReallocation_ = {}, - PFN_FreeFunction pfnFree_ = {}, - PFN_InternalAllocationNotification pfnInternalAllocation_ = {}, - PFN_InternalFreeNotification pfnInternalFree_ = {} ) VULKAN_HPP_NOEXCEPT - : pUserData{ pUserData_ } - , pfnAllocation{ pfnAllocation_ } - , pfnReallocation{ pfnReallocation_ } - , pfnFree{ pfnFree_ } - , pfnInternalAllocation{ pfnInternalAllocation_ } - , pfnInternalFree{ pfnInternalFree_ } - { - } - - VULKAN_HPP_CONSTEXPR AllocationCallbacks( AllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AllocationCallbacks( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT : AllocationCallbacks( *reinterpret_cast( &rhs ) ) - { - } - -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic push -# if defined( __clang__ ) -# pragma clang diagnostic ignored "-Wunknown-warning-option" -# endif -# pragma GCC diagnostic ignored "-Wcast-function-type" -# endif - VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) - - AllocationCallbacks( void * pUserData_, - PFN_vkAllocationFunction pfnAllocation_, - PFN_vkReallocationFunction pfnReallocation_ = {}, - PFN_vkFreeFunction pfnFree_ = {}, - PFN_vkInternalAllocationNotification pfnInternalAllocation_ = {}, - PFN_vkInternalFreeNotification pfnInternalFree_ = {} ) VULKAN_HPP_NOEXCEPT - : AllocationCallbacks( pUserData_, - reinterpret_cast( pfnAllocation_ ), - reinterpret_cast( pfnReallocation_ ), - reinterpret_cast( pfnFree_ ), - reinterpret_cast( pfnInternalAllocation_ ), - reinterpret_cast( pfnInternalFree_ ) ) - { - } -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic pop -# endif - - AllocationCallbacks & operator=( AllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AllocationCallbacks & operator=( VkAllocationCallbacks const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT - { - pUserData = pUserData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT - { - pUserData = pUserData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnAllocation( PFN_AllocationFunction pfnAllocation_ ) & VULKAN_HPP_NOEXCEPT - { - pfnAllocation = pfnAllocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnAllocation( PFN_AllocationFunction pfnAllocation_ ) && VULKAN_HPP_NOEXCEPT - { - pfnAllocation = pfnAllocation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnReallocation( PFN_ReallocationFunction pfnReallocation_ ) & VULKAN_HPP_NOEXCEPT - { - pfnReallocation = pfnReallocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnReallocation( PFN_ReallocationFunction pfnReallocation_ ) && VULKAN_HPP_NOEXCEPT - { - pfnReallocation = pfnReallocation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnFree( PFN_FreeFunction pfnFree_ ) & VULKAN_HPP_NOEXCEPT - { - pfnFree = pfnFree_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnFree( PFN_FreeFunction pfnFree_ ) && VULKAN_HPP_NOEXCEPT - { - pfnFree = pfnFree_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalAllocation( PFN_InternalAllocationNotification pfnInternalAllocation_ ) & VULKAN_HPP_NOEXCEPT - { - pfnInternalAllocation = pfnInternalAllocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnInternalAllocation( PFN_InternalAllocationNotification pfnInternalAllocation_ ) && VULKAN_HPP_NOEXCEPT - { - pfnInternalAllocation = pfnInternalAllocation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks & setPfnInternalFree( PFN_InternalFreeNotification pfnInternalFree_ ) & VULKAN_HPP_NOEXCEPT - { - pfnInternalFree = pfnInternalFree_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AllocationCallbacks && setPfnInternalFree( PFN_InternalFreeNotification pfnInternalFree_ ) && VULKAN_HPP_NOEXCEPT - { - pfnInternalFree = pfnInternalFree_; - return std::move( *this ); - } - -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic push -# if defined( __clang__ ) -# pragma clang diagnostic ignored "-Wunknown-warning-option" -# endif -# pragma GCC diagnostic ignored "-Wcast-function-type" -# endif - VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) - - AllocationCallbacks & setPfnAllocation( PFN_vkAllocationFunction pfnAllocation_ ) VULKAN_HPP_NOEXCEPT - { - return setPfnAllocation( reinterpret_cast( pfnAllocation_ ) ); - } - - VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) - - AllocationCallbacks & setPfnReallocation( PFN_vkReallocationFunction pfnReallocation_ ) VULKAN_HPP_NOEXCEPT - { - return setPfnReallocation( reinterpret_cast( pfnReallocation_ ) ); - } - - VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) - - AllocationCallbacks & setPfnInternalAllocation( PFN_vkInternalAllocationNotification pfnInternalAllocation_ ) VULKAN_HPP_NOEXCEPT - { - return setPfnInternalAllocation( reinterpret_cast( pfnInternalAllocation_ ) ); - } - - VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) - - AllocationCallbacks & setPfnInternalFree( PFN_vkInternalFreeNotification pfnInternalFree_ ) VULKAN_HPP_NOEXCEPT - { - return setPfnInternalFree( reinterpret_cast( pfnInternalFree_ ) ); - } -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic pop -# endif -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAllocationCallbacks const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAllocationCallbacks &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAllocationCallbacks const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAllocationCallbacks *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( pUserData, pfnAllocation, pfnReallocation, pfnFree, pfnInternalAllocation, pfnInternalFree ); - } -#endif - - bool operator==( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT - { -#if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -#else - return ( pUserData == rhs.pUserData ) && ( pfnAllocation == rhs.pfnAllocation ) && ( pfnReallocation == rhs.pfnReallocation ) && - ( pfnFree == rhs.pfnFree ) && ( pfnInternalAllocation == rhs.pfnInternalAllocation ) && ( pfnInternalFree == rhs.pfnInternalFree ); -#endif - } - - bool operator!=( AllocationCallbacks const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - void * pUserData = {}; - PFN_AllocationFunction pfnAllocation = {}; - PFN_ReallocationFunction pfnReallocation = {}; - PFN_FreeFunction pfnFree = {}; - PFN_InternalAllocationNotification pfnInternalAllocation = {}; - PFN_InternalFreeNotification pfnInternalFree = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AllocationCallbacks; - }; -#endif - - // wrapper struct for struct VkAmigoProfilingSubmitInfoSEC, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAmigoProfilingSubmitInfoSEC.html - struct AmigoProfilingSubmitInfoSEC - { - using NativeType = VkAmigoProfilingSubmitInfoSEC; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAmigoProfilingSubmitInfoSEC; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - AmigoProfilingSubmitInfoSEC( uint64_t firstDrawTimestamp_ = {}, uint64_t swapBufferTimestamp_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , firstDrawTimestamp{ firstDrawTimestamp_ } - , swapBufferTimestamp{ swapBufferTimestamp_ } - { - } - - VULKAN_HPP_CONSTEXPR AmigoProfilingSubmitInfoSEC( AmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AmigoProfilingSubmitInfoSEC( VkAmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT - : AmigoProfilingSubmitInfoSEC( *reinterpret_cast( &rhs ) ) - { - } - - AmigoProfilingSubmitInfoSEC & operator=( AmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AmigoProfilingSubmitInfoSEC & operator=( VkAmigoProfilingSubmitInfoSEC const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC & setFirstDrawTimestamp( uint64_t firstDrawTimestamp_ ) & VULKAN_HPP_NOEXCEPT - { - firstDrawTimestamp = firstDrawTimestamp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC && setFirstDrawTimestamp( uint64_t firstDrawTimestamp_ ) && VULKAN_HPP_NOEXCEPT - { - firstDrawTimestamp = firstDrawTimestamp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC & setSwapBufferTimestamp( uint64_t swapBufferTimestamp_ ) & VULKAN_HPP_NOEXCEPT - { - swapBufferTimestamp = swapBufferTimestamp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AmigoProfilingSubmitInfoSEC && setSwapBufferTimestamp( uint64_t swapBufferTimestamp_ ) && VULKAN_HPP_NOEXCEPT - { - swapBufferTimestamp = swapBufferTimestamp_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAmigoProfilingSubmitInfoSEC const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAmigoProfilingSubmitInfoSEC &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAmigoProfilingSubmitInfoSEC const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAmigoProfilingSubmitInfoSEC *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, firstDrawTimestamp, swapBufferTimestamp ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AmigoProfilingSubmitInfoSEC const & ) const = default; -#else - bool operator==( AmigoProfilingSubmitInfoSEC const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( firstDrawTimestamp == rhs.firstDrawTimestamp ) && - ( swapBufferTimestamp == rhs.swapBufferTimestamp ); -# endif - } - - bool operator!=( AmigoProfilingSubmitInfoSEC const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAmigoProfilingSubmitInfoSEC; - const void * pNext = {}; - uint64_t firstDrawTimestamp = {}; - uint64_t swapBufferTimestamp = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AmigoProfilingSubmitInfoSEC; - }; -#endif - - template <> - struct CppType - { - using Type = AmigoProfilingSubmitInfoSEC; - }; - - // wrapper struct for struct VkComponentMapping, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkComponentMapping.html - struct ComponentMapping - { - using NativeType = VkComponentMapping; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ComponentMapping( ComponentSwizzle r_ = ComponentSwizzle::eIdentity, - ComponentSwizzle g_ = ComponentSwizzle::eIdentity, - ComponentSwizzle b_ = ComponentSwizzle::eIdentity, - ComponentSwizzle a_ = ComponentSwizzle::eIdentity ) VULKAN_HPP_NOEXCEPT - : r{ r_ } - , g{ g_ } - , b{ b_ } - , a{ a_ } - { - } - - VULKAN_HPP_CONSTEXPR ComponentMapping( ComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ComponentMapping( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT : ComponentMapping( *reinterpret_cast( &rhs ) ) {} - - ComponentMapping & operator=( ComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ComponentMapping & operator=( VkComponentMapping const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setR( ComponentSwizzle r_ ) & VULKAN_HPP_NOEXCEPT - { - r = r_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setR( ComponentSwizzle r_ ) && VULKAN_HPP_NOEXCEPT - { - r = r_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setG( ComponentSwizzle g_ ) & VULKAN_HPP_NOEXCEPT - { - g = g_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setG( ComponentSwizzle g_ ) && VULKAN_HPP_NOEXCEPT - { - g = g_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setB( ComponentSwizzle b_ ) & VULKAN_HPP_NOEXCEPT - { - b = b_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setB( ComponentSwizzle b_ ) && VULKAN_HPP_NOEXCEPT - { - b = b_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComponentMapping & setA( ComponentSwizzle a_ ) & VULKAN_HPP_NOEXCEPT - { - a = a_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComponentMapping && setA( ComponentSwizzle a_ ) && VULKAN_HPP_NOEXCEPT - { - a = a_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkComponentMapping const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkComponentMapping &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkComponentMapping const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkComponentMapping *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( r, g, b, a ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ComponentMapping const & ) const = default; -#else - bool operator==( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( r == rhs.r ) && ( g == rhs.g ) && ( b == rhs.b ) && ( a == rhs.a ); -# endif - } - - bool operator!=( ComponentMapping const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ComponentSwizzle r = ComponentSwizzle::eIdentity; - ComponentSwizzle g = ComponentSwizzle::eIdentity; - ComponentSwizzle b = ComponentSwizzle::eIdentity; - ComponentSwizzle a = ComponentSwizzle::eIdentity; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ComponentMapping; - }; -#endif - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - // wrapper struct for struct VkAndroidHardwareBufferFormatProperties2ANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatProperties2ANDROID.html - struct AndroidHardwareBufferFormatProperties2ANDROID - { - using NativeType = VkAndroidHardwareBufferFormatProperties2ANDROID; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferFormatProperties2ANDROID; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - AndroidHardwareBufferFormatProperties2ANDROID( Format format_ = Format::eUndefined, - uint64_t externalFormat_ = {}, - FormatFeatureFlags2 formatFeatures_ = {}, - ComponentMapping samplerYcbcrConversionComponents_ = {}, - SamplerYcbcrModelConversion suggestedYcbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, - SamplerYcbcrRange suggestedYcbcrRange_ = SamplerYcbcrRange::eItuFull, - ChromaLocation suggestedXChromaOffset_ = ChromaLocation::eCositedEven, - ChromaLocation suggestedYChromaOffset_ = ChromaLocation::eCositedEven, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , format{ format_ } - , externalFormat{ externalFormat_ } - , formatFeatures{ formatFeatures_ } - , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ } - , suggestedYcbcrModel{ suggestedYcbcrModel_ } - , suggestedYcbcrRange{ suggestedYcbcrRange_ } - , suggestedXChromaOffset{ suggestedXChromaOffset_ } - , suggestedYChromaOffset{ suggestedYChromaOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR - AndroidHardwareBufferFormatProperties2ANDROID( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AndroidHardwareBufferFormatProperties2ANDROID( VkAndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : AndroidHardwareBufferFormatProperties2ANDROID( *reinterpret_cast( &rhs ) ) - { - } - - AndroidHardwareBufferFormatProperties2ANDROID & operator=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AndroidHardwareBufferFormatProperties2ANDROID & operator=( VkAndroidHardwareBufferFormatProperties2ANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkAndroidHardwareBufferFormatProperties2ANDROID const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferFormatProperties2ANDROID &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferFormatProperties2ANDROID const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferFormatProperties2ANDROID *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - format, - externalFormat, - formatFeatures, - samplerYcbcrConversionComponents, - suggestedYcbcrModel, - suggestedYcbcrRange, - suggestedXChromaOffset, - suggestedYChromaOffset ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AndroidHardwareBufferFormatProperties2ANDROID const & ) const = default; -# else - bool operator==( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) && - ( formatFeatures == rhs.formatFeatures ) && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && - ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && - ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); -# endif - } - - bool operator!=( AndroidHardwareBufferFormatProperties2ANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eAndroidHardwareBufferFormatProperties2ANDROID; - void * pNext = {}; - Format format = Format::eUndefined; - uint64_t externalFormat = {}; - FormatFeatureFlags2 formatFeatures = {}; - ComponentMapping samplerYcbcrConversionComponents = {}; - SamplerYcbcrModelConversion suggestedYcbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; - SamplerYcbcrRange suggestedYcbcrRange = SamplerYcbcrRange::eItuFull; - ChromaLocation suggestedXChromaOffset = ChromaLocation::eCositedEven; - ChromaLocation suggestedYChromaOffset = ChromaLocation::eCositedEven; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AndroidHardwareBufferFormatProperties2ANDROID; - }; -# endif - - template <> - struct CppType - { - using Type = AndroidHardwareBufferFormatProperties2ANDROID; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - // wrapper struct for struct VkAndroidHardwareBufferFormatPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatPropertiesANDROID.html - struct AndroidHardwareBufferFormatPropertiesANDROID - { - using NativeType = VkAndroidHardwareBufferFormatPropertiesANDROID; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - AndroidHardwareBufferFormatPropertiesANDROID( Format format_ = Format::eUndefined, - uint64_t externalFormat_ = {}, - FormatFeatureFlags formatFeatures_ = {}, - ComponentMapping samplerYcbcrConversionComponents_ = {}, - SamplerYcbcrModelConversion suggestedYcbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, - SamplerYcbcrRange suggestedYcbcrRange_ = SamplerYcbcrRange::eItuFull, - ChromaLocation suggestedXChromaOffset_ = ChromaLocation::eCositedEven, - ChromaLocation suggestedYChromaOffset_ = ChromaLocation::eCositedEven, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , format{ format_ } - , externalFormat{ externalFormat_ } - , formatFeatures{ formatFeatures_ } - , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ } - , suggestedYcbcrModel{ suggestedYcbcrModel_ } - , suggestedYcbcrRange{ suggestedYcbcrRange_ } - , suggestedXChromaOffset{ suggestedXChromaOffset_ } - , suggestedYChromaOffset{ suggestedYChromaOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR AndroidHardwareBufferFormatPropertiesANDROID( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AndroidHardwareBufferFormatPropertiesANDROID( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : AndroidHardwareBufferFormatPropertiesANDROID( *reinterpret_cast( &rhs ) ) - { - } - - AndroidHardwareBufferFormatPropertiesANDROID & operator=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AndroidHardwareBufferFormatPropertiesANDROID & operator=( VkAndroidHardwareBufferFormatPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkAndroidHardwareBufferFormatPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferFormatPropertiesANDROID &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferFormatPropertiesANDROID const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferFormatPropertiesANDROID *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - format, - externalFormat, - formatFeatures, - samplerYcbcrConversionComponents, - suggestedYcbcrModel, - suggestedYcbcrRange, - suggestedXChromaOffset, - suggestedYChromaOffset ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AndroidHardwareBufferFormatPropertiesANDROID const & ) const = default; -# else - bool operator==( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) && - ( formatFeatures == rhs.formatFeatures ) && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && - ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && - ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); -# endif - } - - bool operator!=( AndroidHardwareBufferFormatPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eAndroidHardwareBufferFormatPropertiesANDROID; - void * pNext = {}; - Format format = Format::eUndefined; - uint64_t externalFormat = {}; - FormatFeatureFlags formatFeatures = {}; - ComponentMapping samplerYcbcrConversionComponents = {}; - SamplerYcbcrModelConversion suggestedYcbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; - SamplerYcbcrRange suggestedYcbcrRange = SamplerYcbcrRange::eItuFull; - ChromaLocation suggestedXChromaOffset = ChromaLocation::eCositedEven; - ChromaLocation suggestedYChromaOffset = ChromaLocation::eCositedEven; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AndroidHardwareBufferFormatPropertiesANDROID; - }; -# endif - - template <> - struct CppType - { - using Type = AndroidHardwareBufferFormatPropertiesANDROID; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - // wrapper struct for struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferFormatResolvePropertiesANDROID.html - struct AndroidHardwareBufferFormatResolvePropertiesANDROID - { - using NativeType = VkAndroidHardwareBufferFormatResolvePropertiesANDROID; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AndroidHardwareBufferFormatResolvePropertiesANDROID( Format colorAttachmentFormat_ = Format::eUndefined, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , colorAttachmentFormat{ colorAttachmentFormat_ } - { - } - - VULKAN_HPP_CONSTEXPR - AndroidHardwareBufferFormatResolvePropertiesANDROID( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AndroidHardwareBufferFormatResolvePropertiesANDROID( VkAndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : AndroidHardwareBufferFormatResolvePropertiesANDROID( *reinterpret_cast( &rhs ) ) - { - } - - AndroidHardwareBufferFormatResolvePropertiesANDROID & - operator=( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AndroidHardwareBufferFormatResolvePropertiesANDROID & operator=( VkAndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferFormatResolvePropertiesANDROID *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, colorAttachmentFormat ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AndroidHardwareBufferFormatResolvePropertiesANDROID const & ) const = default; -# else - bool operator==( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentFormat == rhs.colorAttachmentFormat ); -# endif - } - - bool operator!=( AndroidHardwareBufferFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID; - void * pNext = {}; - Format colorAttachmentFormat = Format::eUndefined; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AndroidHardwareBufferFormatResolvePropertiesANDROID; - }; -# endif - - template <> - struct CppType - { - using Type = AndroidHardwareBufferFormatResolvePropertiesANDROID; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - // wrapper struct for struct VkAndroidHardwareBufferPropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferPropertiesANDROID.html - struct AndroidHardwareBufferPropertiesANDROID - { - using NativeType = VkAndroidHardwareBufferPropertiesANDROID; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferPropertiesANDROID; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - AndroidHardwareBufferPropertiesANDROID( DeviceSize allocationSize_ = {}, uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , allocationSize{ allocationSize_ } - , memoryTypeBits{ memoryTypeBits_ } - { - } - - VULKAN_HPP_CONSTEXPR AndroidHardwareBufferPropertiesANDROID( AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AndroidHardwareBufferPropertiesANDROID( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : AndroidHardwareBufferPropertiesANDROID( *reinterpret_cast( &rhs ) ) - { - } - - AndroidHardwareBufferPropertiesANDROID & operator=( AndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AndroidHardwareBufferPropertiesANDROID & operator=( VkAndroidHardwareBufferPropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkAndroidHardwareBufferPropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferPropertiesANDROID &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferPropertiesANDROID const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferPropertiesANDROID *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, allocationSize, memoryTypeBits ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AndroidHardwareBufferPropertiesANDROID const & ) const = default; -# else - bool operator==( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeBits == rhs.memoryTypeBits ); -# endif - } - - bool operator!=( AndroidHardwareBufferPropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eAndroidHardwareBufferPropertiesANDROID; - void * pNext = {}; - DeviceSize allocationSize = {}; - uint32_t memoryTypeBits = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AndroidHardwareBufferPropertiesANDROID; - }; -# endif - - template <> - struct CppType - { - using Type = AndroidHardwareBufferPropertiesANDROID; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - // wrapper struct for struct VkAndroidHardwareBufferUsageANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidHardwareBufferUsageANDROID.html - struct AndroidHardwareBufferUsageANDROID - { - using NativeType = VkAndroidHardwareBufferUsageANDROID; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidHardwareBufferUsageANDROID; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AndroidHardwareBufferUsageANDROID( uint64_t androidHardwareBufferUsage_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , androidHardwareBufferUsage{ androidHardwareBufferUsage_ } - { - } - - VULKAN_HPP_CONSTEXPR AndroidHardwareBufferUsageANDROID( AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AndroidHardwareBufferUsageANDROID( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : AndroidHardwareBufferUsageANDROID( *reinterpret_cast( &rhs ) ) - { - } - - AndroidHardwareBufferUsageANDROID & operator=( AndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AndroidHardwareBufferUsageANDROID & operator=( VkAndroidHardwareBufferUsageANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkAndroidHardwareBufferUsageANDROID const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferUsageANDROID &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferUsageANDROID const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAndroidHardwareBufferUsageANDROID *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, androidHardwareBufferUsage ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AndroidHardwareBufferUsageANDROID const & ) const = default; -# else - bool operator==( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( androidHardwareBufferUsage == rhs.androidHardwareBufferUsage ); -# endif - } - - bool operator!=( AndroidHardwareBufferUsageANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eAndroidHardwareBufferUsageANDROID; - void * pNext = {}; - uint64_t androidHardwareBufferUsage = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AndroidHardwareBufferUsageANDROID; - }; -# endif - - template <> - struct CppType - { - using Type = AndroidHardwareBufferUsageANDROID; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - // wrapper struct for struct VkAndroidSurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAndroidSurfaceCreateInfoKHR.html - struct AndroidSurfaceCreateInfoKHR - { - using NativeType = VkAndroidSurfaceCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAndroidSurfaceCreateInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateFlagsKHR flags_ = {}, - struct ANativeWindow * window_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , window{ window_ } - { - } - - VULKAN_HPP_CONSTEXPR AndroidSurfaceCreateInfoKHR( AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AndroidSurfaceCreateInfoKHR( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : AndroidSurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - AndroidSurfaceCreateInfoKHR & operator=( AndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AndroidSurfaceCreateInfoKHR & operator=( VkAndroidSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR & setFlags( AndroidSurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR && setFlags( AndroidSurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR & setWindow( struct ANativeWindow * window_ ) & VULKAN_HPP_NOEXCEPT - { - window = window_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AndroidSurfaceCreateInfoKHR && setWindow( struct ANativeWindow * window_ ) && VULKAN_HPP_NOEXCEPT - { - window = window_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAndroidSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAndroidSurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAndroidSurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, window ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AndroidSurfaceCreateInfoKHR const & ) const = default; -# else - bool operator==( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); -# endif - } - - bool operator!=( AndroidSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eAndroidSurfaceCreateInfoKHR; - const void * pNext = {}; - AndroidSurfaceCreateFlagsKHR flags = {}; - struct ANativeWindow * window = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AndroidSurfaceCreateInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = AndroidSurfaceCreateInfoKHR; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - // wrapper struct for struct VkAntiLagPresentationInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagPresentationInfoAMD.html - struct AntiLagPresentationInfoAMD - { - using NativeType = VkAntiLagPresentationInfoAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAntiLagPresentationInfoAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - AntiLagPresentationInfoAMD( AntiLagStageAMD stage_ = AntiLagStageAMD::eInput, uint64_t frameIndex_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stage{ stage_ } - , frameIndex{ frameIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR AntiLagPresentationInfoAMD( AntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AntiLagPresentationInfoAMD( VkAntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : AntiLagPresentationInfoAMD( *reinterpret_cast( &rhs ) ) - { - } - - AntiLagPresentationInfoAMD & operator=( AntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AntiLagPresentationInfoAMD & operator=( VkAntiLagPresentationInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD & setStage( AntiLagStageAMD stage_ ) & VULKAN_HPP_NOEXCEPT - { - stage = stage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD && setStage( AntiLagStageAMD stage_ ) && VULKAN_HPP_NOEXCEPT - { - stage = stage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD & setFrameIndex( uint64_t frameIndex_ ) & VULKAN_HPP_NOEXCEPT - { - frameIndex = frameIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagPresentationInfoAMD && setFrameIndex( uint64_t frameIndex_ ) && VULKAN_HPP_NOEXCEPT - { - frameIndex = frameIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAntiLagPresentationInfoAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAntiLagPresentationInfoAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAntiLagPresentationInfoAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAntiLagPresentationInfoAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stage, frameIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AntiLagPresentationInfoAMD const & ) const = default; -#else - bool operator==( AntiLagPresentationInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && ( frameIndex == rhs.frameIndex ); -# endif - } - - bool operator!=( AntiLagPresentationInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAntiLagPresentationInfoAMD; - void * pNext = {}; - AntiLagStageAMD stage = AntiLagStageAMD::eInput; - uint64_t frameIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AntiLagPresentationInfoAMD; - }; -#endif - - template <> - struct CppType - { - using Type = AntiLagPresentationInfoAMD; - }; - - // wrapper struct for struct VkAntiLagDataAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAntiLagDataAMD.html - struct AntiLagDataAMD - { - using NativeType = VkAntiLagDataAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAntiLagDataAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AntiLagDataAMD( AntiLagModeAMD mode_ = AntiLagModeAMD::eDriverControl, - uint32_t maxFPS_ = {}, - const AntiLagPresentationInfoAMD * pPresentationInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , mode{ mode_ } - , maxFPS{ maxFPS_ } - , pPresentationInfo{ pPresentationInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR AntiLagDataAMD( AntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AntiLagDataAMD( VkAntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT : AntiLagDataAMD( *reinterpret_cast( &rhs ) ) {} - - AntiLagDataAMD & operator=( AntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AntiLagDataAMD & operator=( VkAntiLagDataAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setMode( AntiLagModeAMD mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setMode( AntiLagModeAMD mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setMaxFPS( uint32_t maxFPS_ ) & VULKAN_HPP_NOEXCEPT - { - maxFPS = maxFPS_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setMaxFPS( uint32_t maxFPS_ ) && VULKAN_HPP_NOEXCEPT - { - maxFPS = maxFPS_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD & setPPresentationInfo( const AntiLagPresentationInfoAMD * pPresentationInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pPresentationInfo = pPresentationInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AntiLagDataAMD && setPPresentationInfo( const AntiLagPresentationInfoAMD * pPresentationInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pPresentationInfo = pPresentationInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAntiLagDataAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAntiLagDataAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAntiLagDataAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAntiLagDataAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, mode, maxFPS, pPresentationInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AntiLagDataAMD const & ) const = default; -#else - bool operator==( AntiLagDataAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && ( maxFPS == rhs.maxFPS ) && - ( pPresentationInfo == rhs.pPresentationInfo ); -# endif - } - - bool operator!=( AntiLagDataAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAntiLagDataAMD; - const void * pNext = {}; - AntiLagModeAMD mode = AntiLagModeAMD::eDriverControl; - uint32_t maxFPS = {}; - const AntiLagPresentationInfoAMD * pPresentationInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AntiLagDataAMD; - }; -#endif - - template <> - struct CppType - { - using Type = AntiLagDataAMD; - }; - - // wrapper struct for struct VkApplicationInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkApplicationInfo.html - struct ApplicationInfo - { - using NativeType = VkApplicationInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eApplicationInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ApplicationInfo( const char * pApplicationName_ = {}, - uint32_t applicationVersion_ = {}, - const char * pEngineName_ = {}, - uint32_t engineVersion_ = {}, - uint32_t apiVersion_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pApplicationName{ pApplicationName_ } - , applicationVersion{ applicationVersion_ } - , pEngineName{ pEngineName_ } - , engineVersion{ engineVersion_ } - , apiVersion{ apiVersion_ } - { - } - - VULKAN_HPP_CONSTEXPR ApplicationInfo( ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ApplicationInfo( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT : ApplicationInfo( *reinterpret_cast( &rhs ) ) {} - - ApplicationInfo & operator=( ApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ApplicationInfo & operator=( VkApplicationInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setPApplicationName( const char * pApplicationName_ ) & VULKAN_HPP_NOEXCEPT - { - pApplicationName = pApplicationName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setPApplicationName( const char * pApplicationName_ ) && VULKAN_HPP_NOEXCEPT - { - pApplicationName = pApplicationName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setApplicationVersion( uint32_t applicationVersion_ ) & VULKAN_HPP_NOEXCEPT - { - applicationVersion = applicationVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setApplicationVersion( uint32_t applicationVersion_ ) && VULKAN_HPP_NOEXCEPT - { - applicationVersion = applicationVersion_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setPEngineName( const char * pEngineName_ ) & VULKAN_HPP_NOEXCEPT - { - pEngineName = pEngineName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setPEngineName( const char * pEngineName_ ) && VULKAN_HPP_NOEXCEPT - { - pEngineName = pEngineName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setEngineVersion( uint32_t engineVersion_ ) & VULKAN_HPP_NOEXCEPT - { - engineVersion = engineVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setEngineVersion( uint32_t engineVersion_ ) && VULKAN_HPP_NOEXCEPT - { - engineVersion = engineVersion_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo & setApiVersion( uint32_t apiVersion_ ) & VULKAN_HPP_NOEXCEPT - { - apiVersion = apiVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ApplicationInfo && setApiVersion( uint32_t apiVersion_ ) && VULKAN_HPP_NOEXCEPT - { - apiVersion = apiVersion_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkApplicationInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkApplicationInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkApplicationInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkApplicationInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pApplicationName, applicationVersion, pEngineName, engineVersion, apiVersion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( pApplicationName != rhs.pApplicationName ) - if ( auto cmp = strcmp( pApplicationName, rhs.pApplicationName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = applicationVersion <=> rhs.applicationVersion; cmp != 0 ) - return cmp; - if ( pEngineName != rhs.pEngineName ) - if ( auto cmp = strcmp( pEngineName, rhs.pEngineName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = engineVersion <=> rhs.engineVersion; cmp != 0 ) - return cmp; - if ( auto cmp = apiVersion <=> rhs.apiVersion; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( ( pApplicationName == rhs.pApplicationName ) || ( strcmp( pApplicationName, rhs.pApplicationName ) == 0 ) ) && - ( applicationVersion == rhs.applicationVersion ) && ( ( pEngineName == rhs.pEngineName ) || ( strcmp( pEngineName, rhs.pEngineName ) == 0 ) ) && - ( engineVersion == rhs.engineVersion ) && ( apiVersion == rhs.apiVersion ); - } - - bool operator!=( ApplicationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eApplicationInfo; - const void * pNext = {}; - const char * pApplicationName = {}; - uint32_t applicationVersion = {}; - const char * pEngineName = {}; - uint32_t engineVersion = {}; - uint32_t apiVersion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ApplicationInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ApplicationInfo; - }; - - // wrapper struct for struct VkAttachmentDescription, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescription.html - struct AttachmentDescription - { - using NativeType = VkAttachmentDescription; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AttachmentDescription( AttachmentDescriptionFlags flags_ = {}, - Format format_ = Format::eUndefined, - SampleCountFlagBits samples_ = SampleCountFlagBits::e1, - AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, - AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, - AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, - AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, - ImageLayout initialLayout_ = ImageLayout::eUndefined, - ImageLayout finalLayout_ = ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : flags{ flags_ } - , format{ format_ } - , samples{ samples_ } - , loadOp{ loadOp_ } - , storeOp{ storeOp_ } - , stencilLoadOp{ stencilLoadOp_ } - , stencilStoreOp{ stencilStoreOp_ } - , initialLayout{ initialLayout_ } - , finalLayout{ finalLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR AttachmentDescription( AttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AttachmentDescription( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT - : AttachmentDescription( *reinterpret_cast( &rhs ) ) - { - } - - AttachmentDescription & operator=( AttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AttachmentDescription & operator=( VkAttachmentDescription const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setFlags( AttachmentDescriptionFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setFlags( AttachmentDescriptionFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setSamples( SampleCountFlagBits samples_ ) & VULKAN_HPP_NOEXCEPT - { - samples = samples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setSamples( SampleCountFlagBits samples_ ) && VULKAN_HPP_NOEXCEPT - { - samples = samples_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setLoadOp( AttachmentLoadOp loadOp_ ) & VULKAN_HPP_NOEXCEPT - { - loadOp = loadOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setLoadOp( AttachmentLoadOp loadOp_ ) && VULKAN_HPP_NOEXCEPT - { - loadOp = loadOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setStoreOp( AttachmentStoreOp storeOp_ ) & VULKAN_HPP_NOEXCEPT - { - storeOp = storeOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setStoreOp( AttachmentStoreOp storeOp_ ) && VULKAN_HPP_NOEXCEPT - { - storeOp = storeOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) & VULKAN_HPP_NOEXCEPT - { - stencilLoadOp = stencilLoadOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) && VULKAN_HPP_NOEXCEPT - { - stencilLoadOp = stencilLoadOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) & VULKAN_HPP_NOEXCEPT - { - stencilStoreOp = stencilStoreOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) && VULKAN_HPP_NOEXCEPT - { - stencilStoreOp = stencilStoreOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setInitialLayout( ImageLayout initialLayout_ ) & VULKAN_HPP_NOEXCEPT - { - initialLayout = initialLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setInitialLayout( ImageLayout initialLayout_ ) && VULKAN_HPP_NOEXCEPT - { - initialLayout = initialLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription & setFinalLayout( ImageLayout finalLayout_ ) & VULKAN_HPP_NOEXCEPT - { - finalLayout = finalLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription && setFinalLayout( ImageLayout finalLayout_ ) && VULKAN_HPP_NOEXCEPT - { - finalLayout = finalLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAttachmentDescription const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentDescription &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentDescription const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAttachmentDescription *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AttachmentDescription const & ) const = default; -#else - bool operator==( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) && ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && - ( stencilLoadOp == rhs.stencilLoadOp ) && ( stencilStoreOp == rhs.stencilStoreOp ) && ( initialLayout == rhs.initialLayout ) && - ( finalLayout == rhs.finalLayout ); -# endif - } - - bool operator!=( AttachmentDescription const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - AttachmentDescriptionFlags flags = {}; - Format format = Format::eUndefined; - SampleCountFlagBits samples = SampleCountFlagBits::e1; - AttachmentLoadOp loadOp = AttachmentLoadOp::eLoad; - AttachmentStoreOp storeOp = AttachmentStoreOp::eStore; - AttachmentLoadOp stencilLoadOp = AttachmentLoadOp::eLoad; - AttachmentStoreOp stencilStoreOp = AttachmentStoreOp::eStore; - ImageLayout initialLayout = ImageLayout::eUndefined; - ImageLayout finalLayout = ImageLayout::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AttachmentDescription; - }; -#endif - - // wrapper struct for struct VkAttachmentDescription2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescription2.html - struct AttachmentDescription2 - { - using NativeType = VkAttachmentDescription2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentDescription2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AttachmentDescription2( AttachmentDescriptionFlags flags_ = {}, - Format format_ = Format::eUndefined, - SampleCountFlagBits samples_ = SampleCountFlagBits::e1, - AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, - AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, - AttachmentLoadOp stencilLoadOp_ = AttachmentLoadOp::eLoad, - AttachmentStoreOp stencilStoreOp_ = AttachmentStoreOp::eStore, - ImageLayout initialLayout_ = ImageLayout::eUndefined, - ImageLayout finalLayout_ = ImageLayout::eUndefined, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , format{ format_ } - , samples{ samples_ } - , loadOp{ loadOp_ } - , storeOp{ storeOp_ } - , stencilLoadOp{ stencilLoadOp_ } - , stencilStoreOp{ stencilStoreOp_ } - , initialLayout{ initialLayout_ } - , finalLayout{ finalLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR AttachmentDescription2( AttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AttachmentDescription2( VkAttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT - : AttachmentDescription2( *reinterpret_cast( &rhs ) ) - { - } - - AttachmentDescription2 & operator=( AttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AttachmentDescription2 & operator=( VkAttachmentDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setFlags( AttachmentDescriptionFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setFlags( AttachmentDescriptionFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setSamples( SampleCountFlagBits samples_ ) & VULKAN_HPP_NOEXCEPT - { - samples = samples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setSamples( SampleCountFlagBits samples_ ) && VULKAN_HPP_NOEXCEPT - { - samples = samples_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setLoadOp( AttachmentLoadOp loadOp_ ) & VULKAN_HPP_NOEXCEPT - { - loadOp = loadOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setLoadOp( AttachmentLoadOp loadOp_ ) && VULKAN_HPP_NOEXCEPT - { - loadOp = loadOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setStoreOp( AttachmentStoreOp storeOp_ ) & VULKAN_HPP_NOEXCEPT - { - storeOp = storeOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setStoreOp( AttachmentStoreOp storeOp_ ) && VULKAN_HPP_NOEXCEPT - { - storeOp = storeOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) & VULKAN_HPP_NOEXCEPT - { - stencilLoadOp = stencilLoadOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setStencilLoadOp( AttachmentLoadOp stencilLoadOp_ ) && VULKAN_HPP_NOEXCEPT - { - stencilLoadOp = stencilLoadOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) & VULKAN_HPP_NOEXCEPT - { - stencilStoreOp = stencilStoreOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setStencilStoreOp( AttachmentStoreOp stencilStoreOp_ ) && VULKAN_HPP_NOEXCEPT - { - stencilStoreOp = stencilStoreOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setInitialLayout( ImageLayout initialLayout_ ) & VULKAN_HPP_NOEXCEPT - { - initialLayout = initialLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setInitialLayout( ImageLayout initialLayout_ ) && VULKAN_HPP_NOEXCEPT - { - initialLayout = initialLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 & setFinalLayout( ImageLayout finalLayout_ ) & VULKAN_HPP_NOEXCEPT - { - finalLayout = finalLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescription2 && setFinalLayout( ImageLayout finalLayout_ ) && VULKAN_HPP_NOEXCEPT - { - finalLayout = finalLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAttachmentDescription2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentDescription2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentDescription2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAttachmentDescription2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, format, samples, loadOp, storeOp, stencilLoadOp, stencilStoreOp, initialLayout, finalLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AttachmentDescription2 const & ) const = default; -#else - bool operator==( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( format == rhs.format ) && ( samples == rhs.samples ) && - ( loadOp == rhs.loadOp ) && ( storeOp == rhs.storeOp ) && ( stencilLoadOp == rhs.stencilLoadOp ) && ( stencilStoreOp == rhs.stencilStoreOp ) && - ( initialLayout == rhs.initialLayout ) && ( finalLayout == rhs.finalLayout ); -# endif - } - - bool operator!=( AttachmentDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAttachmentDescription2; - const void * pNext = {}; - AttachmentDescriptionFlags flags = {}; - Format format = Format::eUndefined; - SampleCountFlagBits samples = SampleCountFlagBits::e1; - AttachmentLoadOp loadOp = AttachmentLoadOp::eLoad; - AttachmentStoreOp storeOp = AttachmentStoreOp::eStore; - AttachmentLoadOp stencilLoadOp = AttachmentLoadOp::eLoad; - AttachmentStoreOp stencilStoreOp = AttachmentStoreOp::eStore; - ImageLayout initialLayout = ImageLayout::eUndefined; - ImageLayout finalLayout = ImageLayout::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AttachmentDescription2; - }; -#endif - - template <> - struct CppType - { - using Type = AttachmentDescription2; - }; - - using AttachmentDescription2KHR = AttachmentDescription2; - - // wrapper struct for struct VkAttachmentDescriptionStencilLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentDescriptionStencilLayout.html - struct AttachmentDescriptionStencilLayout - { - using NativeType = VkAttachmentDescriptionStencilLayout; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentDescriptionStencilLayout; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayout( ImageLayout stencilInitialLayout_ = ImageLayout::eUndefined, - ImageLayout stencilFinalLayout_ = ImageLayout::eUndefined, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stencilInitialLayout{ stencilInitialLayout_ } - , stencilFinalLayout{ stencilFinalLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR AttachmentDescriptionStencilLayout( AttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AttachmentDescriptionStencilLayout( VkAttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT - : AttachmentDescriptionStencilLayout( *reinterpret_cast( &rhs ) ) - { - } - - AttachmentDescriptionStencilLayout & operator=( AttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AttachmentDescriptionStencilLayout & operator=( VkAttachmentDescriptionStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout & setStencilInitialLayout( ImageLayout stencilInitialLayout_ ) & VULKAN_HPP_NOEXCEPT - { - stencilInitialLayout = stencilInitialLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout && setStencilInitialLayout( ImageLayout stencilInitialLayout_ ) && VULKAN_HPP_NOEXCEPT - { - stencilInitialLayout = stencilInitialLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout & setStencilFinalLayout( ImageLayout stencilFinalLayout_ ) & VULKAN_HPP_NOEXCEPT - { - stencilFinalLayout = stencilFinalLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentDescriptionStencilLayout && setStencilFinalLayout( ImageLayout stencilFinalLayout_ ) && VULKAN_HPP_NOEXCEPT - { - stencilFinalLayout = stencilFinalLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAttachmentDescriptionStencilLayout const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentDescriptionStencilLayout &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentDescriptionStencilLayout const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAttachmentDescriptionStencilLayout *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stencilInitialLayout, stencilFinalLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AttachmentDescriptionStencilLayout const & ) const = default; -#else - bool operator==( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilInitialLayout == rhs.stencilInitialLayout ) && - ( stencilFinalLayout == rhs.stencilFinalLayout ); -# endif - } - - bool operator!=( AttachmentDescriptionStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAttachmentDescriptionStencilLayout; - void * pNext = {}; - ImageLayout stencilInitialLayout = ImageLayout::eUndefined; - ImageLayout stencilFinalLayout = ImageLayout::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AttachmentDescriptionStencilLayout; - }; -#endif - - template <> - struct CppType - { - using Type = AttachmentDescriptionStencilLayout; - }; - - using AttachmentDescriptionStencilLayoutKHR = AttachmentDescriptionStencilLayout; - - // wrapper struct for struct VkAttachmentFeedbackLoopInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentFeedbackLoopInfoEXT.html - struct AttachmentFeedbackLoopInfoEXT - { - using NativeType = VkAttachmentFeedbackLoopInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentFeedbackLoopInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AttachmentFeedbackLoopInfoEXT( Bool32 feedbackLoopEnable_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , feedbackLoopEnable{ feedbackLoopEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR AttachmentFeedbackLoopInfoEXT( AttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AttachmentFeedbackLoopInfoEXT( VkAttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : AttachmentFeedbackLoopInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - AttachmentFeedbackLoopInfoEXT & operator=( AttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AttachmentFeedbackLoopInfoEXT & operator=( VkAttachmentFeedbackLoopInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT & setFeedbackLoopEnable( Bool32 feedbackLoopEnable_ ) & VULKAN_HPP_NOEXCEPT - { - feedbackLoopEnable = feedbackLoopEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentFeedbackLoopInfoEXT && setFeedbackLoopEnable( Bool32 feedbackLoopEnable_ ) && VULKAN_HPP_NOEXCEPT - { - feedbackLoopEnable = feedbackLoopEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAttachmentFeedbackLoopInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentFeedbackLoopInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentFeedbackLoopInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAttachmentFeedbackLoopInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, feedbackLoopEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AttachmentFeedbackLoopInfoEXT const & ) const = default; -#else - bool operator==( AttachmentFeedbackLoopInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( feedbackLoopEnable == rhs.feedbackLoopEnable ); -# endif - } - - bool operator!=( AttachmentFeedbackLoopInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAttachmentFeedbackLoopInfoEXT; - const void * pNext = {}; - Bool32 feedbackLoopEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AttachmentFeedbackLoopInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = AttachmentFeedbackLoopInfoEXT; - }; - - // wrapper struct for struct VkAttachmentReference, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentReference.html - struct AttachmentReference - { - using NativeType = VkAttachmentReference; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AttachmentReference( uint32_t attachment_ = {}, ImageLayout layout_ = ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : attachment{ attachment_ } - , layout{ layout_ } - { - } - - VULKAN_HPP_CONSTEXPR AttachmentReference( AttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AttachmentReference( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT : AttachmentReference( *reinterpret_cast( &rhs ) ) - { - } - - AttachmentReference & operator=( AttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AttachmentReference & operator=( VkAttachmentReference const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AttachmentReference & setAttachment( uint32_t attachment_ ) & VULKAN_HPP_NOEXCEPT - { - attachment = attachment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReference && setAttachment( uint32_t attachment_ ) && VULKAN_HPP_NOEXCEPT - { - attachment = attachment_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReference & setLayout( ImageLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReference && setLayout( ImageLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAttachmentReference const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentReference &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentReference const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAttachmentReference *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( attachment, layout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AttachmentReference const & ) const = default; -#else - bool operator==( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( attachment == rhs.attachment ) && ( layout == rhs.layout ); -# endif - } - - bool operator!=( AttachmentReference const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t attachment = {}; - ImageLayout layout = ImageLayout::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AttachmentReference; - }; -#endif - - // wrapper struct for struct VkAttachmentReference2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentReference2.html - struct AttachmentReference2 - { - using NativeType = VkAttachmentReference2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentReference2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AttachmentReference2( uint32_t attachment_ = {}, - ImageLayout layout_ = ImageLayout::eUndefined, - ImageAspectFlags aspectMask_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , attachment{ attachment_ } - , layout{ layout_ } - , aspectMask{ aspectMask_ } - { - } - - VULKAN_HPP_CONSTEXPR AttachmentReference2( AttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AttachmentReference2( VkAttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT - : AttachmentReference2( *reinterpret_cast( &rhs ) ) - { - } - - AttachmentReference2 & operator=( AttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AttachmentReference2 & operator=( VkAttachmentReference2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setAttachment( uint32_t attachment_ ) & VULKAN_HPP_NOEXCEPT - { - attachment = attachment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setAttachment( uint32_t attachment_ ) && VULKAN_HPP_NOEXCEPT - { - attachment = attachment_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setLayout( ImageLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setLayout( ImageLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReference2 && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAttachmentReference2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentReference2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentReference2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAttachmentReference2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, attachment, layout, aspectMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AttachmentReference2 const & ) const = default; -#else - bool operator==( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachment == rhs.attachment ) && ( layout == rhs.layout ) && - ( aspectMask == rhs.aspectMask ); -# endif - } - - bool operator!=( AttachmentReference2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAttachmentReference2; - const void * pNext = {}; - uint32_t attachment = {}; - ImageLayout layout = ImageLayout::eUndefined; - ImageAspectFlags aspectMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AttachmentReference2; - }; -#endif - - template <> - struct CppType - { - using Type = AttachmentReference2; - }; - - using AttachmentReference2KHR = AttachmentReference2; - - // wrapper struct for struct VkAttachmentReferenceStencilLayout, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentReferenceStencilLayout.html - struct AttachmentReferenceStencilLayout - { - using NativeType = VkAttachmentReferenceStencilLayout; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentReferenceStencilLayout; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayout( ImageLayout stencilLayout_ = ImageLayout::eUndefined, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stencilLayout{ stencilLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR AttachmentReferenceStencilLayout( AttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AttachmentReferenceStencilLayout( VkAttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT - : AttachmentReferenceStencilLayout( *reinterpret_cast( &rhs ) ) - { - } - - AttachmentReferenceStencilLayout & operator=( AttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AttachmentReferenceStencilLayout & operator=( VkAttachmentReferenceStencilLayout const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout & setStencilLayout( ImageLayout stencilLayout_ ) & VULKAN_HPP_NOEXCEPT - { - stencilLayout = stencilLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentReferenceStencilLayout && setStencilLayout( ImageLayout stencilLayout_ ) && VULKAN_HPP_NOEXCEPT - { - stencilLayout = stencilLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAttachmentReferenceStencilLayout const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentReferenceStencilLayout &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentReferenceStencilLayout const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAttachmentReferenceStencilLayout *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stencilLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AttachmentReferenceStencilLayout const & ) const = default; -#else - bool operator==( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilLayout == rhs.stencilLayout ); -# endif - } - - bool operator!=( AttachmentReferenceStencilLayout const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAttachmentReferenceStencilLayout; - void * pNext = {}; - ImageLayout stencilLayout = ImageLayout::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AttachmentReferenceStencilLayout; - }; -#endif - - template <> - struct CppType - { - using Type = AttachmentReferenceStencilLayout; - }; - - using AttachmentReferenceStencilLayoutKHR = AttachmentReferenceStencilLayout; - - // wrapper struct for struct VkAttachmentSampleCountInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentSampleCountInfoAMD.html - struct AttachmentSampleCountInfoAMD - { - using NativeType = VkAttachmentSampleCountInfoAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eAttachmentSampleCountInfoAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AttachmentSampleCountInfoAMD( uint32_t colorAttachmentCount_ = {}, - const SampleCountFlagBits * pColorAttachmentSamples_ = {}, - SampleCountFlagBits depthStencilAttachmentSamples_ = SampleCountFlagBits::e1, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , colorAttachmentCount{ colorAttachmentCount_ } - , pColorAttachmentSamples{ pColorAttachmentSamples_ } - , depthStencilAttachmentSamples{ depthStencilAttachmentSamples_ } - { - } - - VULKAN_HPP_CONSTEXPR AttachmentSampleCountInfoAMD( AttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AttachmentSampleCountInfoAMD( VkAttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : AttachmentSampleCountInfoAMD( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AttachmentSampleCountInfoAMD( ArrayProxyNoTemporaries const & colorAttachmentSamples_, - SampleCountFlagBits depthStencilAttachmentSamples_ = SampleCountFlagBits::e1, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , colorAttachmentCount( static_cast( colorAttachmentSamples_.size() ) ) - , pColorAttachmentSamples( colorAttachmentSamples_.data() ) - , depthStencilAttachmentSamples( depthStencilAttachmentSamples_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - AttachmentSampleCountInfoAMD & operator=( AttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AttachmentSampleCountInfoAMD & operator=( VkAttachmentSampleCountInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setPColorAttachmentSamples( const SampleCountFlagBits * pColorAttachmentSamples_ ) & - VULKAN_HPP_NOEXCEPT - { - pColorAttachmentSamples = pColorAttachmentSamples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setPColorAttachmentSamples( const SampleCountFlagBits * pColorAttachmentSamples_ ) && - VULKAN_HPP_NOEXCEPT - { - pColorAttachmentSamples = pColorAttachmentSamples_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - AttachmentSampleCountInfoAMD & - setColorAttachmentSamples( ArrayProxyNoTemporaries const & colorAttachmentSamples_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( colorAttachmentSamples_.size() ); - pColorAttachmentSamples = colorAttachmentSamples_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD & setDepthStencilAttachmentSamples( SampleCountFlagBits depthStencilAttachmentSamples_ ) & - VULKAN_HPP_NOEXCEPT - { - depthStencilAttachmentSamples = depthStencilAttachmentSamples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleCountInfoAMD && setDepthStencilAttachmentSamples( SampleCountFlagBits depthStencilAttachmentSamples_ ) && - VULKAN_HPP_NOEXCEPT - { - depthStencilAttachmentSamples = depthStencilAttachmentSamples_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAttachmentSampleCountInfoAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentSampleCountInfoAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentSampleCountInfoAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAttachmentSampleCountInfoAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentSamples, depthStencilAttachmentSamples ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AttachmentSampleCountInfoAMD const & ) const = default; -#else - bool operator==( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachmentSamples == rhs.pColorAttachmentSamples ) && ( depthStencilAttachmentSamples == rhs.depthStencilAttachmentSamples ); -# endif - } - - bool operator!=( AttachmentSampleCountInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eAttachmentSampleCountInfoAMD; - const void * pNext = {}; - uint32_t colorAttachmentCount = {}; - const SampleCountFlagBits * pColorAttachmentSamples = {}; - SampleCountFlagBits depthStencilAttachmentSamples = SampleCountFlagBits::e1; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AttachmentSampleCountInfoAMD; - }; -#endif - - template <> - struct CppType - { - using Type = AttachmentSampleCountInfoAMD; - }; - - using AttachmentSampleCountInfoNV = AttachmentSampleCountInfoAMD; - - // wrapper struct for struct VkExtent2D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExtent2D.html - struct Extent2D - { - using NativeType = VkExtent2D; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR Extent2D( uint32_t width_ = {}, uint32_t height_ = {} ) VULKAN_HPP_NOEXCEPT - : width{ width_ } - , height{ height_ } - { - } - - VULKAN_HPP_CONSTEXPR Extent2D( Extent2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - Extent2D( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT : Extent2D( *reinterpret_cast( &rhs ) ) {} - - Extent2D & operator=( Extent2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - Extent2D & operator=( VkExtent2D const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 Extent2D & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT - { - width = width_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Extent2D && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT - { - width = width_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Extent2D & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT - { - height = height_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Extent2D && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT - { - height = height_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExtent2D const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExtent2D &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExtent2D const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExtent2D *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( width, height ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( Extent2D const & ) const = default; -#else - bool operator==( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( width == rhs.width ) && ( height == rhs.height ); -# endif - } - - bool operator!=( Extent2D const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t width = {}; - uint32_t height = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = Extent2D; - }; -#endif - - // wrapper struct for struct VkSampleLocationEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleLocationEXT.html - struct SampleLocationEXT - { - using NativeType = VkSampleLocationEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SampleLocationEXT( float x_ = {}, float y_ = {} ) VULKAN_HPP_NOEXCEPT - : x{ x_ } - , y{ y_ } - { - } - - VULKAN_HPP_CONSTEXPR SampleLocationEXT( SampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SampleLocationEXT( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT : SampleLocationEXT( *reinterpret_cast( &rhs ) ) {} - - SampleLocationEXT & operator=( SampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SampleLocationEXT & operator=( VkSampleLocationEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT & setX( float x_ ) & VULKAN_HPP_NOEXCEPT - { - x = x_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT && setX( float x_ ) && VULKAN_HPP_NOEXCEPT - { - x = x_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT & setY( float y_ ) & VULKAN_HPP_NOEXCEPT - { - y = y_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationEXT && setY( float y_ ) && VULKAN_HPP_NOEXCEPT - { - y = y_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSampleLocationEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSampleLocationEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSampleLocationEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSampleLocationEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( x, y ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SampleLocationEXT const & ) const = default; -#else - bool operator==( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( x == rhs.x ) && ( y == rhs.y ); -# endif - } - - bool operator!=( SampleLocationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - float x = {}; - float y = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SampleLocationEXT; - }; -#endif - - // wrapper struct for struct VkSampleLocationsInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSampleLocationsInfoEXT.html - struct SampleLocationsInfoEXT - { - using NativeType = VkSampleLocationsInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSampleLocationsInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_ = SampleCountFlagBits::e1, - Extent2D sampleLocationGridSize_ = {}, - uint32_t sampleLocationsCount_ = {}, - const SampleLocationEXT * pSampleLocations_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , sampleLocationsPerPixel{ sampleLocationsPerPixel_ } - , sampleLocationGridSize{ sampleLocationGridSize_ } - , sampleLocationsCount{ sampleLocationsCount_ } - , pSampleLocations{ pSampleLocations_ } - { - } - - VULKAN_HPP_CONSTEXPR SampleLocationsInfoEXT( SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SampleLocationsInfoEXT( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SampleLocationsInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SampleLocationsInfoEXT( SampleCountFlagBits sampleLocationsPerPixel_, - Extent2D sampleLocationGridSize_, - ArrayProxyNoTemporaries const & sampleLocations_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , sampleLocationsPerPixel( sampleLocationsPerPixel_ ) - , sampleLocationGridSize( sampleLocationGridSize_ ) - , sampleLocationsCount( static_cast( sampleLocations_.size() ) ) - , pSampleLocations( sampleLocations_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SampleLocationsInfoEXT & operator=( SampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SampleLocationsInfoEXT & operator=( VkSampleLocationsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ ) & VULKAN_HPP_NOEXCEPT - { - sampleLocationsPerPixel = sampleLocationsPerPixel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setSampleLocationsPerPixel( SampleCountFlagBits sampleLocationsPerPixel_ ) && VULKAN_HPP_NOEXCEPT - { - sampleLocationsPerPixel = sampleLocationsPerPixel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setSampleLocationGridSize( Extent2D const & sampleLocationGridSize_ ) & VULKAN_HPP_NOEXCEPT - { - sampleLocationGridSize = sampleLocationGridSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setSampleLocationGridSize( Extent2D const & sampleLocationGridSize_ ) && VULKAN_HPP_NOEXCEPT - { - sampleLocationGridSize = sampleLocationGridSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setSampleLocationsCount( uint32_t sampleLocationsCount_ ) & VULKAN_HPP_NOEXCEPT - { - sampleLocationsCount = sampleLocationsCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setSampleLocationsCount( uint32_t sampleLocationsCount_ ) && VULKAN_HPP_NOEXCEPT - { - sampleLocationsCount = sampleLocationsCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT & setPSampleLocations( const SampleLocationEXT * pSampleLocations_ ) & VULKAN_HPP_NOEXCEPT - { - pSampleLocations = pSampleLocations_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SampleLocationsInfoEXT && setPSampleLocations( const SampleLocationEXT * pSampleLocations_ ) && VULKAN_HPP_NOEXCEPT - { - pSampleLocations = pSampleLocations_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SampleLocationsInfoEXT & setSampleLocations( ArrayProxyNoTemporaries const & sampleLocations_ ) VULKAN_HPP_NOEXCEPT - { - sampleLocationsCount = static_cast( sampleLocations_.size() ); - pSampleLocations = sampleLocations_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSampleLocationsInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSampleLocationsInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSampleLocationsInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSampleLocationsInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, sampleLocationsPerPixel, sampleLocationGridSize, sampleLocationsCount, pSampleLocations ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SampleLocationsInfoEXT const & ) const = default; -#else - bool operator==( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleLocationsPerPixel == rhs.sampleLocationsPerPixel ) && - ( sampleLocationGridSize == rhs.sampleLocationGridSize ) && ( sampleLocationsCount == rhs.sampleLocationsCount ) && - ( pSampleLocations == rhs.pSampleLocations ); -# endif - } - - bool operator!=( SampleLocationsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSampleLocationsInfoEXT; - const void * pNext = {}; - SampleCountFlagBits sampleLocationsPerPixel = SampleCountFlagBits::e1; - Extent2D sampleLocationGridSize = {}; - uint32_t sampleLocationsCount = {}; - const SampleLocationEXT * pSampleLocations = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SampleLocationsInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SampleLocationsInfoEXT; - }; - - // wrapper struct for struct VkAttachmentSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkAttachmentSampleLocationsEXT.html - struct AttachmentSampleLocationsEXT - { - using NativeType = VkAttachmentSampleLocationsEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( uint32_t attachmentIndex_ = {}, SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT - : attachmentIndex{ attachmentIndex_ } - , sampleLocationsInfo{ sampleLocationsInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR AttachmentSampleLocationsEXT( AttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - AttachmentSampleLocationsEXT( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : AttachmentSampleLocationsEXT( *reinterpret_cast( &rhs ) ) - { - } - - AttachmentSampleLocationsEXT & operator=( AttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - AttachmentSampleLocationsEXT & operator=( VkAttachmentSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT & setAttachmentIndex( uint32_t attachmentIndex_ ) & VULKAN_HPP_NOEXCEPT - { - attachmentIndex = attachmentIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT && setAttachmentIndex( uint32_t attachmentIndex_ ) && VULKAN_HPP_NOEXCEPT - { - attachmentIndex = attachmentIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT & setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) & VULKAN_HPP_NOEXCEPT - { - sampleLocationsInfo = sampleLocationsInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 AttachmentSampleLocationsEXT && setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) && VULKAN_HPP_NOEXCEPT - { - sampleLocationsInfo = sampleLocationsInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkAttachmentSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkAttachmentSampleLocationsEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkAttachmentSampleLocationsEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( attachmentIndex, sampleLocationsInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( AttachmentSampleLocationsEXT const & ) const = default; -#else - bool operator==( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( attachmentIndex == rhs.attachmentIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); -# endif - } - - bool operator!=( AttachmentSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t attachmentIndex = {}; - SampleLocationsInfoEXT sampleLocationsInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = AttachmentSampleLocationsEXT; - }; -#endif - - // wrapper struct for struct VkBaseInStructure, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBaseInStructure.html - struct BaseInStructure - { - using NativeType = VkBaseInStructure; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - BaseInStructure( StructureType sType_ = StructureType::eApplicationInfo, const struct BaseInStructure * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : sType{ sType_ } - , pNext{ pNext_ } - { - } - - BaseInStructure( BaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BaseInStructure( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT : BaseInStructure( *reinterpret_cast( &rhs ) ) {} - - BaseInStructure & operator=( BaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BaseInStructure & operator=( VkBaseInStructure const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BaseInStructure & setPNext( const struct BaseInStructure * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BaseInStructure && setPNext( const struct BaseInStructure * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBaseInStructure const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBaseInStructure &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBaseInStructure const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBaseInStructure *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BaseInStructure const & ) const = default; -#else - bool operator==( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); -# endif - } - - bool operator!=( BaseInStructure const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eApplicationInfo; - const struct BaseInStructure * pNext = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BaseInStructure; - }; -#endif - - // wrapper struct for struct VkBaseOutStructure, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBaseOutStructure.html - struct BaseOutStructure - { - using NativeType = VkBaseOutStructure; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - BaseOutStructure( StructureType sType_ = StructureType::eApplicationInfo, struct BaseOutStructure * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : sType{ sType_ } - , pNext{ pNext_ } - { - } - - BaseOutStructure( BaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BaseOutStructure( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT : BaseOutStructure( *reinterpret_cast( &rhs ) ) {} - - BaseOutStructure & operator=( BaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BaseOutStructure & operator=( VkBaseOutStructure const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BaseOutStructure & setPNext( struct BaseOutStructure * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BaseOutStructure && setPNext( struct BaseOutStructure * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBaseOutStructure const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBaseOutStructure &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBaseOutStructure const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBaseOutStructure *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BaseOutStructure const & ) const = default; -#else - bool operator==( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); -# endif - } - - bool operator!=( BaseOutStructure const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eApplicationInfo; - struct BaseOutStructure * pNext = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BaseOutStructure; - }; -#endif - - // wrapper struct for struct VkBeginCustomResolveInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBeginCustomResolveInfoEXT.html - struct BeginCustomResolveInfoEXT - { - using NativeType = VkBeginCustomResolveInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBeginCustomResolveInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BeginCustomResolveInfoEXT( void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} - - VULKAN_HPP_CONSTEXPR BeginCustomResolveInfoEXT( BeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BeginCustomResolveInfoEXT( VkBeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : BeginCustomResolveInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - BeginCustomResolveInfoEXT & operator=( BeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BeginCustomResolveInfoEXT & operator=( VkBeginCustomResolveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BeginCustomResolveInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BeginCustomResolveInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBeginCustomResolveInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBeginCustomResolveInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBeginCustomResolveInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBeginCustomResolveInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BeginCustomResolveInfoEXT const & ) const = default; -#else - bool operator==( BeginCustomResolveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); -# endif - } - - bool operator!=( BeginCustomResolveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBeginCustomResolveInfoEXT; - void * pNext = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BeginCustomResolveInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = BeginCustomResolveInfoEXT; - }; - - // wrapper struct for struct VkBindAccelerationStructureMemoryInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindAccelerationStructureMemoryInfoNV.html - struct BindAccelerationStructureMemoryInfoNV - { - using NativeType = VkBindAccelerationStructureMemoryInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindAccelerationStructureMemoryInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_ = {}, - DeviceMemory memory_ = {}, - DeviceSize memoryOffset_ = {}, - uint32_t deviceIndexCount_ = {}, - const uint32_t * pDeviceIndices_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , accelerationStructure{ accelerationStructure_ } - , memory{ memory_ } - , memoryOffset{ memoryOffset_ } - , deviceIndexCount{ deviceIndexCount_ } - , pDeviceIndices{ pDeviceIndices_ } - { - } - - VULKAN_HPP_CONSTEXPR BindAccelerationStructureMemoryInfoNV( BindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindAccelerationStructureMemoryInfoNV( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : BindAccelerationStructureMemoryInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindAccelerationStructureMemoryInfoNV( AccelerationStructureNV accelerationStructure_, - DeviceMemory memory_, - DeviceSize memoryOffset_, - ArrayProxyNoTemporaries const & deviceIndices_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , accelerationStructure( accelerationStructure_ ) - , memory( memory_ ) - , memoryOffset( memoryOffset_ ) - , deviceIndexCount( static_cast( deviceIndices_.size() ) ) - , pDeviceIndices( deviceIndices_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - BindAccelerationStructureMemoryInfoNV & operator=( BindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindAccelerationStructureMemoryInfoNV & operator=( VkBindAccelerationStructureMemoryInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setAccelerationStructure( AccelerationStructureNV accelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setDeviceIndexCount( uint32_t deviceIndexCount_ ) & VULKAN_HPP_NOEXCEPT - { - deviceIndexCount = deviceIndexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setDeviceIndexCount( uint32_t deviceIndexCount_ ) && VULKAN_HPP_NOEXCEPT - { - deviceIndexCount = deviceIndexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV & setPDeviceIndices( const uint32_t * pDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pDeviceIndices = pDeviceIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindAccelerationStructureMemoryInfoNV && setPDeviceIndices( const uint32_t * pDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pDeviceIndices = pDeviceIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindAccelerationStructureMemoryInfoNV & setDeviceIndices( ArrayProxyNoTemporaries const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT - { - deviceIndexCount = static_cast( deviceIndices_.size() ); - pDeviceIndices = deviceIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindAccelerationStructureMemoryInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindAccelerationStructureMemoryInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindAccelerationStructureMemoryInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindAccelerationStructureMemoryInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, accelerationStructure, memory, memoryOffset, deviceIndexCount, pDeviceIndices ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindAccelerationStructureMemoryInfoNV const & ) const = default; -#else - bool operator==( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ) && ( memory == rhs.memory ) && - ( memoryOffset == rhs.memoryOffset ) && ( deviceIndexCount == rhs.deviceIndexCount ) && ( pDeviceIndices == rhs.pDeviceIndices ); -# endif - } - - bool operator!=( BindAccelerationStructureMemoryInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindAccelerationStructureMemoryInfoNV; - const void * pNext = {}; - AccelerationStructureNV accelerationStructure = {}; - DeviceMemory memory = {}; - DeviceSize memoryOffset = {}; - uint32_t deviceIndexCount = {}; - const uint32_t * pDeviceIndices = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindAccelerationStructureMemoryInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = BindAccelerationStructureMemoryInfoNV; - }; - - // wrapper struct for struct VkBindBufferMemoryDeviceGroupInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindBufferMemoryDeviceGroupInfo.html - struct BindBufferMemoryDeviceGroupInfo - { - using NativeType = VkBindBufferMemoryDeviceGroupInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindBufferMemoryDeviceGroupInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = {}, - const uint32_t * pDeviceIndices_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceIndexCount{ deviceIndexCount_ } - , pDeviceIndices{ pDeviceIndices_ } - { - } - - VULKAN_HPP_CONSTEXPR BindBufferMemoryDeviceGroupInfo( BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindBufferMemoryDeviceGroupInfo( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : BindBufferMemoryDeviceGroupInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindBufferMemoryDeviceGroupInfo( ArrayProxyNoTemporaries const & deviceIndices_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), deviceIndexCount( static_cast( deviceIndices_.size() ) ), pDeviceIndices( deviceIndices_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - BindBufferMemoryDeviceGroupInfo & operator=( BindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindBufferMemoryDeviceGroupInfo & operator=( VkBindBufferMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo & setDeviceIndexCount( uint32_t deviceIndexCount_ ) & VULKAN_HPP_NOEXCEPT - { - deviceIndexCount = deviceIndexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo && setDeviceIndexCount( uint32_t deviceIndexCount_ ) && VULKAN_HPP_NOEXCEPT - { - deviceIndexCount = deviceIndexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo & setPDeviceIndices( const uint32_t * pDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pDeviceIndices = pDeviceIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryDeviceGroupInfo && setPDeviceIndices( const uint32_t * pDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pDeviceIndices = pDeviceIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindBufferMemoryDeviceGroupInfo & setDeviceIndices( ArrayProxyNoTemporaries const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT - { - deviceIndexCount = static_cast( deviceIndices_.size() ); - pDeviceIndices = deviceIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindBufferMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindBufferMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindBufferMemoryDeviceGroupInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindBufferMemoryDeviceGroupInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindBufferMemoryDeviceGroupInfo const & ) const = default; -#else - bool operator==( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && ( pDeviceIndices == rhs.pDeviceIndices ); -# endif - } - - bool operator!=( BindBufferMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindBufferMemoryDeviceGroupInfo; - const void * pNext = {}; - uint32_t deviceIndexCount = {}; - const uint32_t * pDeviceIndices = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindBufferMemoryDeviceGroupInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BindBufferMemoryDeviceGroupInfo; - }; - - using BindBufferMemoryDeviceGroupInfoKHR = BindBufferMemoryDeviceGroupInfo; - - // wrapper struct for struct VkBindBufferMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindBufferMemoryInfo.html - struct BindBufferMemoryInfo - { - using NativeType = VkBindBufferMemoryInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindBufferMemoryInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - BindBufferMemoryInfo( Buffer buffer_ = {}, DeviceMemory memory_ = {}, DeviceSize memoryOffset_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , buffer{ buffer_ } - , memory{ memory_ } - , memoryOffset{ memoryOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR BindBufferMemoryInfo( BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindBufferMemoryInfo( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : BindBufferMemoryInfo( *reinterpret_cast( &rhs ) ) - { - } - - BindBufferMemoryInfo & operator=( BindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindBufferMemoryInfo & operator=( VkBindBufferMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindBufferMemoryInfo && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindBufferMemoryInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindBufferMemoryInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindBufferMemoryInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindBufferMemoryInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, buffer, memory, memoryOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindBufferMemoryInfo const & ) const = default; -#else - bool operator==( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ); -# endif - } - - bool operator!=( BindBufferMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindBufferMemoryInfo; - const void * pNext = {}; - Buffer buffer = {}; - DeviceMemory memory = {}; - DeviceSize memoryOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindBufferMemoryInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BindBufferMemoryInfo; - }; - - using BindBufferMemoryInfoKHR = BindBufferMemoryInfo; - - // wrapper struct for struct VkBindDataGraphPipelineSessionMemoryInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindDataGraphPipelineSessionMemoryInfoARM.html - struct BindDataGraphPipelineSessionMemoryInfoARM - { - using NativeType = VkBindDataGraphPipelineSessionMemoryInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindDataGraphPipelineSessionMemoryInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - BindDataGraphPipelineSessionMemoryInfoARM( DataGraphPipelineSessionARM session_ = {}, - DataGraphPipelineSessionBindPointARM bindPoint_ = DataGraphPipelineSessionBindPointARM::eTransient, - uint32_t objectIndex_ = {}, - DeviceMemory memory_ = {}, - DeviceSize memoryOffset_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , session{ session_ } - , bindPoint{ bindPoint_ } - , objectIndex{ objectIndex_ } - , memory{ memory_ } - , memoryOffset{ memoryOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR BindDataGraphPipelineSessionMemoryInfoARM( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindDataGraphPipelineSessionMemoryInfoARM( VkBindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : BindDataGraphPipelineSessionMemoryInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - BindDataGraphPipelineSessionMemoryInfoARM & operator=( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindDataGraphPipelineSessionMemoryInfoARM & operator=( VkBindDataGraphPipelineSessionMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setSession( DataGraphPipelineSessionARM session_ ) & VULKAN_HPP_NOEXCEPT - { - session = session_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setSession( DataGraphPipelineSessionARM session_ ) && VULKAN_HPP_NOEXCEPT - { - session = session_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) & VULKAN_HPP_NOEXCEPT - { - bindPoint = bindPoint_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) && VULKAN_HPP_NOEXCEPT - { - bindPoint = bindPoint_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setObjectIndex( uint32_t objectIndex_ ) & VULKAN_HPP_NOEXCEPT - { - objectIndex = objectIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setObjectIndex( uint32_t objectIndex_ ) && VULKAN_HPP_NOEXCEPT - { - objectIndex = objectIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDataGraphPipelineSessionMemoryInfoARM && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindDataGraphPipelineSessionMemoryInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindDataGraphPipelineSessionMemoryInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindDataGraphPipelineSessionMemoryInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindDataGraphPipelineSessionMemoryInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, session, bindPoint, objectIndex, memory, memoryOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindDataGraphPipelineSessionMemoryInfoARM const & ) const = default; -#else - bool operator==( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( session == rhs.session ) && ( bindPoint == rhs.bindPoint ) && - ( objectIndex == rhs.objectIndex ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ); -# endif - } - - bool operator!=( BindDataGraphPipelineSessionMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindDataGraphPipelineSessionMemoryInfoARM; - const void * pNext = {}; - DataGraphPipelineSessionARM session = {}; - DataGraphPipelineSessionBindPointARM bindPoint = DataGraphPipelineSessionBindPointARM::eTransient; - uint32_t objectIndex = {}; - DeviceMemory memory = {}; - DeviceSize memoryOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindDataGraphPipelineSessionMemoryInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = BindDataGraphPipelineSessionMemoryInfoARM; - }; - - // wrapper struct for struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindDescriptorBufferEmbeddedSamplersInfoEXT.html - struct BindDescriptorBufferEmbeddedSamplersInfoEXT - { - using NativeType = VkBindDescriptorBufferEmbeddedSamplersInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindDescriptorBufferEmbeddedSamplersInfoEXT( ShaderStageFlags stageFlags_ = {}, - PipelineLayout layout_ = {}, - uint32_t set_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stageFlags{ stageFlags_ } - , layout{ layout_ } - , set{ set_ } - { - } - - VULKAN_HPP_CONSTEXPR BindDescriptorBufferEmbeddedSamplersInfoEXT( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindDescriptorBufferEmbeddedSamplersInfoEXT( VkBindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : BindDescriptorBufferEmbeddedSamplersInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - BindDescriptorBufferEmbeddedSamplersInfoEXT & operator=( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindDescriptorBufferEmbeddedSamplersInfoEXT & operator=( VkBindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT - { - set = set_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorBufferEmbeddedSamplersInfoEXT && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT - { - set = set_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindDescriptorBufferEmbeddedSamplersInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stageFlags, layout, set ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindDescriptorBufferEmbeddedSamplersInfoEXT const & ) const = default; -#else - bool operator==( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( set == rhs.set ); -# endif - } - - bool operator!=( BindDescriptorBufferEmbeddedSamplersInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT; - const void * pNext = {}; - ShaderStageFlags stageFlags = {}; - PipelineLayout layout = {}; - uint32_t set = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindDescriptorBufferEmbeddedSamplersInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = BindDescriptorBufferEmbeddedSamplersInfoEXT; - }; - - // wrapper struct for struct VkBindDescriptorSetsInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindDescriptorSetsInfo.html - struct BindDescriptorSetsInfo - { - using NativeType = VkBindDescriptorSetsInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindDescriptorSetsInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindDescriptorSetsInfo( ShaderStageFlags stageFlags_ = {}, - PipelineLayout layout_ = {}, - uint32_t firstSet_ = {}, - uint32_t descriptorSetCount_ = {}, - const DescriptorSet * pDescriptorSets_ = {}, - uint32_t dynamicOffsetCount_ = {}, - const uint32_t * pDynamicOffsets_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stageFlags{ stageFlags_ } - , layout{ layout_ } - , firstSet{ firstSet_ } - , descriptorSetCount{ descriptorSetCount_ } - , pDescriptorSets{ pDescriptorSets_ } - , dynamicOffsetCount{ dynamicOffsetCount_ } - , pDynamicOffsets{ pDynamicOffsets_ } - { - } - - VULKAN_HPP_CONSTEXPR BindDescriptorSetsInfo( BindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindDescriptorSetsInfo( VkBindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : BindDescriptorSetsInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindDescriptorSetsInfo( ShaderStageFlags stageFlags_, - PipelineLayout layout_, - uint32_t firstSet_, - ArrayProxyNoTemporaries const & descriptorSets_, - ArrayProxyNoTemporaries const & dynamicOffsets_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , stageFlags( stageFlags_ ) - , layout( layout_ ) - , firstSet( firstSet_ ) - , descriptorSetCount( static_cast( descriptorSets_.size() ) ) - , pDescriptorSets( descriptorSets_.data() ) - , dynamicOffsetCount( static_cast( dynamicOffsets_.size() ) ) - , pDynamicOffsets( dynamicOffsets_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - BindDescriptorSetsInfo & operator=( BindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindDescriptorSetsInfo & operator=( VkBindDescriptorSetsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setFirstSet( uint32_t firstSet_ ) & VULKAN_HPP_NOEXCEPT - { - firstSet = firstSet_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setFirstSet( uint32_t firstSet_ ) && VULKAN_HPP_NOEXCEPT - { - firstSet = firstSet_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setDescriptorSetCount( uint32_t descriptorSetCount_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorSetCount = descriptorSetCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setDescriptorSetCount( uint32_t descriptorSetCount_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorSetCount = descriptorSetCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setPDescriptorSets( const DescriptorSet * pDescriptorSets_ ) & VULKAN_HPP_NOEXCEPT - { - pDescriptorSets = pDescriptorSets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setPDescriptorSets( const DescriptorSet * pDescriptorSets_ ) && VULKAN_HPP_NOEXCEPT - { - pDescriptorSets = pDescriptorSets_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindDescriptorSetsInfo & setDescriptorSets( ArrayProxyNoTemporaries const & descriptorSets_ ) VULKAN_HPP_NOEXCEPT - { - descriptorSetCount = static_cast( descriptorSets_.size() ); - pDescriptorSets = descriptorSets_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setDynamicOffsetCount( uint32_t dynamicOffsetCount_ ) & VULKAN_HPP_NOEXCEPT - { - dynamicOffsetCount = dynamicOffsetCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setDynamicOffsetCount( uint32_t dynamicOffsetCount_ ) && VULKAN_HPP_NOEXCEPT - { - dynamicOffsetCount = dynamicOffsetCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo & setPDynamicOffsets( const uint32_t * pDynamicOffsets_ ) & VULKAN_HPP_NOEXCEPT - { - pDynamicOffsets = pDynamicOffsets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindDescriptorSetsInfo && setPDynamicOffsets( const uint32_t * pDynamicOffsets_ ) && VULKAN_HPP_NOEXCEPT - { - pDynamicOffsets = pDynamicOffsets_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindDescriptorSetsInfo & setDynamicOffsets( ArrayProxyNoTemporaries const & dynamicOffsets_ ) VULKAN_HPP_NOEXCEPT - { - dynamicOffsetCount = static_cast( dynamicOffsets_.size() ); - pDynamicOffsets = dynamicOffsets_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindDescriptorSetsInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindDescriptorSetsInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindDescriptorSetsInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindDescriptorSetsInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stageFlags, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindDescriptorSetsInfo const & ) const = default; -#else - bool operator==( BindDescriptorSetsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( firstSet == rhs.firstSet ) && - ( descriptorSetCount == rhs.descriptorSetCount ) && ( pDescriptorSets == rhs.pDescriptorSets ) && - ( dynamicOffsetCount == rhs.dynamicOffsetCount ) && ( pDynamicOffsets == rhs.pDynamicOffsets ); -# endif - } - - bool operator!=( BindDescriptorSetsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindDescriptorSetsInfo; - const void * pNext = {}; - ShaderStageFlags stageFlags = {}; - PipelineLayout layout = {}; - uint32_t firstSet = {}; - uint32_t descriptorSetCount = {}; - const DescriptorSet * pDescriptorSets = {}; - uint32_t dynamicOffsetCount = {}; - const uint32_t * pDynamicOffsets = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindDescriptorSetsInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BindDescriptorSetsInfo; - }; - - using BindDescriptorSetsInfoKHR = BindDescriptorSetsInfo; - - // wrapper struct for struct VkDeviceAddressRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressRangeEXT.html - struct DeviceAddressRangeEXT - { - using NativeType = VkDeviceAddressRangeEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceAddressRangeEXT( DeviceAddress address_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT - : address{ address_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceAddressRangeEXT( DeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceAddressRangeEXT( VkDeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceAddressRangeEXT( *reinterpret_cast( &rhs ) ) - { - } - - DeviceAddressRangeEXT & operator=( DeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceAddressRangeEXT & operator=( VkDeviceAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT - { - address = address_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT - { - address = address_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressRangeEXT && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceAddressRangeEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceAddressRangeEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceAddressRangeEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceAddressRangeEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( address, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceAddressRangeEXT const & ) const = default; -#else - bool operator==( DeviceAddressRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( address == rhs.address ) && ( size == rhs.size ); -# endif - } - - bool operator!=( DeviceAddressRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress address = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceAddressRangeEXT; - }; -#endif - - // wrapper struct for struct VkBindHeapInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindHeapInfoEXT.html - struct BindHeapInfoEXT - { - using NativeType = VkBindHeapInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindHeapInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindHeapInfoEXT( DeviceAddressRangeEXT heapRange_ = {}, - DeviceSize reservedRangeOffset_ = {}, - DeviceSize reservedRangeSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , heapRange{ heapRange_ } - , reservedRangeOffset{ reservedRangeOffset_ } - , reservedRangeSize{ reservedRangeSize_ } - { - } - - VULKAN_HPP_CONSTEXPR BindHeapInfoEXT( BindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindHeapInfoEXT( VkBindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : BindHeapInfoEXT( *reinterpret_cast( &rhs ) ) {} - - BindHeapInfoEXT & operator=( BindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindHeapInfoEXT & operator=( VkBindHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setHeapRange( DeviceAddressRangeEXT const & heapRange_ ) & VULKAN_HPP_NOEXCEPT - { - heapRange = heapRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setHeapRange( DeviceAddressRangeEXT const & heapRange_ ) && VULKAN_HPP_NOEXCEPT - { - heapRange = heapRange_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setReservedRangeOffset( DeviceSize reservedRangeOffset_ ) & VULKAN_HPP_NOEXCEPT - { - reservedRangeOffset = reservedRangeOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setReservedRangeOffset( DeviceSize reservedRangeOffset_ ) && VULKAN_HPP_NOEXCEPT - { - reservedRangeOffset = reservedRangeOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT & setReservedRangeSize( DeviceSize reservedRangeSize_ ) & VULKAN_HPP_NOEXCEPT - { - reservedRangeSize = reservedRangeSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindHeapInfoEXT && setReservedRangeSize( DeviceSize reservedRangeSize_ ) && VULKAN_HPP_NOEXCEPT - { - reservedRangeSize = reservedRangeSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindHeapInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindHeapInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindHeapInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindHeapInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, heapRange, reservedRangeOffset, reservedRangeSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindHeapInfoEXT const & ) const = default; -#else - bool operator==( BindHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapRange == rhs.heapRange ) && ( reservedRangeOffset == rhs.reservedRangeOffset ) && - ( reservedRangeSize == rhs.reservedRangeSize ); -# endif - } - - bool operator!=( BindHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindHeapInfoEXT; - const void * pNext = {}; - DeviceAddressRangeEXT heapRange = {}; - DeviceSize reservedRangeOffset = {}; - DeviceSize reservedRangeSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindHeapInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = BindHeapInfoEXT; - }; - - // wrapper struct for struct VkOffset2D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOffset2D.html - struct Offset2D - { - using NativeType = VkOffset2D; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR Offset2D( int32_t x_ = {}, int32_t y_ = {} ) VULKAN_HPP_NOEXCEPT - : x{ x_ } - , y{ y_ } - { - } - - VULKAN_HPP_CONSTEXPR Offset2D( Offset2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - Offset2D( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT : Offset2D( *reinterpret_cast( &rhs ) ) {} - - Offset2D & operator=( Offset2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - Offset2D & operator=( VkOffset2D const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 Offset2D & setX( int32_t x_ ) & VULKAN_HPP_NOEXCEPT - { - x = x_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Offset2D && setX( int32_t x_ ) && VULKAN_HPP_NOEXCEPT - { - x = x_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Offset2D & setY( int32_t y_ ) & VULKAN_HPP_NOEXCEPT - { - y = y_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Offset2D && setY( int32_t y_ ) && VULKAN_HPP_NOEXCEPT - { - y = y_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkOffset2D const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOffset2D &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOffset2D const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkOffset2D *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( x, y ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( Offset2D const & ) const = default; -#else - bool operator==( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( x == rhs.x ) && ( y == rhs.y ); -# endif - } - - bool operator!=( Offset2D const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - int32_t x = {}; - int32_t y = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = Offset2D; - }; -#endif - - // wrapper struct for struct VkRect2D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRect2D.html - struct Rect2D - { - using NativeType = VkRect2D; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR Rect2D( Offset2D offset_ = {}, Extent2D extent_ = {} ) VULKAN_HPP_NOEXCEPT - : offset{ offset_ } - , extent{ extent_ } - { - } - - VULKAN_HPP_CONSTEXPR Rect2D( Rect2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - Rect2D( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT : Rect2D( *reinterpret_cast( &rhs ) ) {} - - Rect2D & operator=( Rect2D const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - Rect2D & operator=( VkRect2D const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 Rect2D & setOffset( Offset2D const & offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Rect2D && setOffset( Offset2D const & offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Rect2D & setExtent( Extent2D const & extent_ ) & VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Rect2D && setExtent( Extent2D const & extent_ ) && VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRect2D const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRect2D &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRect2D const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRect2D *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( offset, extent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( Rect2D const & ) const = default; -#else - bool operator==( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( offset == rhs.offset ) && ( extent == rhs.extent ); -# endif - } - - bool operator!=( Rect2D const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Offset2D offset = {}; - Extent2D extent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = Rect2D; - }; -#endif - - // wrapper struct for struct VkBindImageMemoryDeviceGroupInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImageMemoryDeviceGroupInfo.html - struct BindImageMemoryDeviceGroupInfo - { - using NativeType = VkBindImageMemoryDeviceGroupInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemoryDeviceGroupInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( uint32_t deviceIndexCount_ = {}, - const uint32_t * pDeviceIndices_ = {}, - uint32_t splitInstanceBindRegionCount_ = {}, - const Rect2D * pSplitInstanceBindRegions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceIndexCount{ deviceIndexCount_ } - , pDeviceIndices{ pDeviceIndices_ } - , splitInstanceBindRegionCount{ splitInstanceBindRegionCount_ } - , pSplitInstanceBindRegions{ pSplitInstanceBindRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR BindImageMemoryDeviceGroupInfo( BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindImageMemoryDeviceGroupInfo( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : BindImageMemoryDeviceGroupInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindImageMemoryDeviceGroupInfo( ArrayProxyNoTemporaries const & deviceIndices_, - ArrayProxyNoTemporaries const & splitInstanceBindRegions_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , deviceIndexCount( static_cast( deviceIndices_.size() ) ) - , pDeviceIndices( deviceIndices_.data() ) - , splitInstanceBindRegionCount( static_cast( splitInstanceBindRegions_.size() ) ) - , pSplitInstanceBindRegions( splitInstanceBindRegions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - BindImageMemoryDeviceGroupInfo & operator=( BindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindImageMemoryDeviceGroupInfo & operator=( VkBindImageMemoryDeviceGroupInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setDeviceIndexCount( uint32_t deviceIndexCount_ ) & VULKAN_HPP_NOEXCEPT - { - deviceIndexCount = deviceIndexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setDeviceIndexCount( uint32_t deviceIndexCount_ ) && VULKAN_HPP_NOEXCEPT - { - deviceIndexCount = deviceIndexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setPDeviceIndices( const uint32_t * pDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pDeviceIndices = pDeviceIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setPDeviceIndices( const uint32_t * pDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pDeviceIndices = pDeviceIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindImageMemoryDeviceGroupInfo & setDeviceIndices( ArrayProxyNoTemporaries const & deviceIndices_ ) VULKAN_HPP_NOEXCEPT - { - deviceIndexCount = static_cast( deviceIndices_.size() ); - pDeviceIndices = deviceIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setSplitInstanceBindRegionCount( uint32_t splitInstanceBindRegionCount_ ) & VULKAN_HPP_NOEXCEPT - { - splitInstanceBindRegionCount = splitInstanceBindRegionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setSplitInstanceBindRegionCount( uint32_t splitInstanceBindRegionCount_ ) && VULKAN_HPP_NOEXCEPT - { - splitInstanceBindRegionCount = splitInstanceBindRegionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo & setPSplitInstanceBindRegions( const Rect2D * pSplitInstanceBindRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pSplitInstanceBindRegions = pSplitInstanceBindRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryDeviceGroupInfo && setPSplitInstanceBindRegions( const Rect2D * pSplitInstanceBindRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pSplitInstanceBindRegions = pSplitInstanceBindRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindImageMemoryDeviceGroupInfo & setSplitInstanceBindRegions( ArrayProxyNoTemporaries const & splitInstanceBindRegions_ ) VULKAN_HPP_NOEXCEPT - { - splitInstanceBindRegionCount = static_cast( splitInstanceBindRegions_.size() ); - pSplitInstanceBindRegions = splitInstanceBindRegions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindImageMemoryDeviceGroupInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindImageMemoryDeviceGroupInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindImageMemoryDeviceGroupInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindImageMemoryDeviceGroupInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceIndexCount, pDeviceIndices, splitInstanceBindRegionCount, pSplitInstanceBindRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindImageMemoryDeviceGroupInfo const & ) const = default; -#else - bool operator==( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndexCount == rhs.deviceIndexCount ) && ( pDeviceIndices == rhs.pDeviceIndices ) && - ( splitInstanceBindRegionCount == rhs.splitInstanceBindRegionCount ) && ( pSplitInstanceBindRegions == rhs.pSplitInstanceBindRegions ); -# endif - } - - bool operator!=( BindImageMemoryDeviceGroupInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindImageMemoryDeviceGroupInfo; - const void * pNext = {}; - uint32_t deviceIndexCount = {}; - const uint32_t * pDeviceIndices = {}; - uint32_t splitInstanceBindRegionCount = {}; - const Rect2D * pSplitInstanceBindRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindImageMemoryDeviceGroupInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BindImageMemoryDeviceGroupInfo; - }; - - using BindImageMemoryDeviceGroupInfoKHR = BindImageMemoryDeviceGroupInfo; - - // wrapper struct for struct VkBindImageMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImageMemoryInfo.html - struct BindImageMemoryInfo - { - using NativeType = VkBindImageMemoryInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemoryInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - BindImageMemoryInfo( Image image_ = {}, DeviceMemory memory_ = {}, DeviceSize memoryOffset_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , image{ image_ } - , memory{ memory_ } - , memoryOffset{ memoryOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR BindImageMemoryInfo( BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindImageMemoryInfo( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT : BindImageMemoryInfo( *reinterpret_cast( &rhs ) ) - { - } - - BindImageMemoryInfo & operator=( BindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindImageMemoryInfo & operator=( VkBindImageMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemoryInfo && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindImageMemoryInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindImageMemoryInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindImageMemoryInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindImageMemoryInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, image, memory, memoryOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindImageMemoryInfo const & ) const = default; -#else - bool operator==( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ); -# endif - } - - bool operator!=( BindImageMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindImageMemoryInfo; - const void * pNext = {}; - Image image = {}; - DeviceMemory memory = {}; - DeviceSize memoryOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindImageMemoryInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BindImageMemoryInfo; - }; - - using BindImageMemoryInfoKHR = BindImageMemoryInfo; - - // wrapper struct for struct VkBindImageMemorySwapchainInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImageMemorySwapchainInfoKHR.html - struct BindImageMemorySwapchainInfoKHR - { - using NativeType = VkBindImageMemorySwapchainInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImageMemorySwapchainInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - BindImageMemorySwapchainInfoKHR( SwapchainKHR swapchain_ = {}, uint32_t imageIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchain{ swapchain_ } - , imageIndex{ imageIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR BindImageMemorySwapchainInfoKHR( BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindImageMemorySwapchainInfoKHR( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : BindImageMemorySwapchainInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - BindImageMemorySwapchainInfoKHR & operator=( BindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindImageMemorySwapchainInfoKHR & operator=( VkBindImageMemorySwapchainInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR & setImageIndex( uint32_t imageIndex_ ) & VULKAN_HPP_NOEXCEPT - { - imageIndex = imageIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImageMemorySwapchainInfoKHR && setImageIndex( uint32_t imageIndex_ ) && VULKAN_HPP_NOEXCEPT - { - imageIndex = imageIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindImageMemorySwapchainInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindImageMemorySwapchainInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindImageMemorySwapchainInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindImageMemorySwapchainInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchain, imageIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindImageMemorySwapchainInfoKHR const & ) const = default; -#else - bool operator==( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( imageIndex == rhs.imageIndex ); -# endif - } - - bool operator!=( BindImageMemorySwapchainInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindImageMemorySwapchainInfoKHR; - const void * pNext = {}; - SwapchainKHR swapchain = {}; - uint32_t imageIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindImageMemorySwapchainInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = BindImageMemorySwapchainInfoKHR; - }; - - // wrapper struct for struct VkBindImagePlaneMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindImagePlaneMemoryInfo.html - struct BindImagePlaneMemoryInfo - { - using NativeType = VkBindImagePlaneMemoryInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindImagePlaneMemoryInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , planeAspect{ planeAspect_ } - { - } - - VULKAN_HPP_CONSTEXPR BindImagePlaneMemoryInfo( BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindImagePlaneMemoryInfo( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : BindImagePlaneMemoryInfo( *reinterpret_cast( &rhs ) ) - { - } - - BindImagePlaneMemoryInfo & operator=( BindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindImagePlaneMemoryInfo & operator=( VkBindImagePlaneMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo & setPlaneAspect( ImageAspectFlagBits planeAspect_ ) & VULKAN_HPP_NOEXCEPT - { - planeAspect = planeAspect_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindImagePlaneMemoryInfo && setPlaneAspect( ImageAspectFlagBits planeAspect_ ) && VULKAN_HPP_NOEXCEPT - { - planeAspect = planeAspect_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindImagePlaneMemoryInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindImagePlaneMemoryInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindImagePlaneMemoryInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindImagePlaneMemoryInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, planeAspect ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindImagePlaneMemoryInfo const & ) const = default; -#else - bool operator==( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect ); -# endif - } - - bool operator!=( BindImagePlaneMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindImagePlaneMemoryInfo; - const void * pNext = {}; - ImageAspectFlagBits planeAspect = ImageAspectFlagBits::eColor; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindImagePlaneMemoryInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BindImagePlaneMemoryInfo; - }; - - using BindImagePlaneMemoryInfoKHR = BindImagePlaneMemoryInfo; - - // wrapper struct for struct VkBindIndexBufferIndirectCommandEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindIndexBufferIndirectCommandEXT.html - struct BindIndexBufferIndirectCommandEXT - { - using NativeType = VkBindIndexBufferIndirectCommandEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - BindIndexBufferIndirectCommandEXT( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, IndexType indexType_ = IndexType::eUint16 ) VULKAN_HPP_NOEXCEPT - : bufferAddress{ bufferAddress_ } - , size{ size_ } - , indexType{ indexType_ } - { - } - - VULKAN_HPP_CONSTEXPR BindIndexBufferIndirectCommandEXT( BindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindIndexBufferIndirectCommandEXT( VkBindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : BindIndexBufferIndirectCommandEXT( *reinterpret_cast( &rhs ) ) - { - } - - BindIndexBufferIndirectCommandEXT & operator=( BindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindIndexBufferIndirectCommandEXT & operator=( VkBindIndexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT - { - bufferAddress = bufferAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT - { - bufferAddress = bufferAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandEXT && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindIndexBufferIndirectCommandEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindIndexBufferIndirectCommandEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindIndexBufferIndirectCommandEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindIndexBufferIndirectCommandEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( bufferAddress, size, indexType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindIndexBufferIndirectCommandEXT const & ) const = default; -#else - bool operator==( BindIndexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType ); -# endif - } - - bool operator!=( BindIndexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress bufferAddress = {}; - uint32_t size = {}; - IndexType indexType = IndexType::eUint16; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindIndexBufferIndirectCommandEXT; - }; -#endif - - // wrapper struct for struct VkBindIndexBufferIndirectCommandNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindIndexBufferIndirectCommandNV.html - struct BindIndexBufferIndirectCommandNV - { - using NativeType = VkBindIndexBufferIndirectCommandNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - BindIndexBufferIndirectCommandNV( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, IndexType indexType_ = IndexType::eUint16 ) VULKAN_HPP_NOEXCEPT - : bufferAddress{ bufferAddress_ } - , size{ size_ } - , indexType{ indexType_ } - { - } - - VULKAN_HPP_CONSTEXPR BindIndexBufferIndirectCommandNV( BindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindIndexBufferIndirectCommandNV( VkBindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - : BindIndexBufferIndirectCommandNV( *reinterpret_cast( &rhs ) ) - { - } - - BindIndexBufferIndirectCommandNV & operator=( BindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindIndexBufferIndirectCommandNV & operator=( VkBindIndexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT - { - bufferAddress = bufferAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT - { - bufferAddress = bufferAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV & setIndexType( IndexType indexType_ ) & VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindIndexBufferIndirectCommandNV && setIndexType( IndexType indexType_ ) && VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindIndexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindIndexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindIndexBufferIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindIndexBufferIndirectCommandNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( bufferAddress, size, indexType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindIndexBufferIndirectCommandNV const & ) const = default; -#else - bool operator==( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( indexType == rhs.indexType ); -# endif - } - - bool operator!=( BindIndexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress bufferAddress = {}; - uint32_t size = {}; - IndexType indexType = IndexType::eUint16; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindIndexBufferIndirectCommandNV; - }; -#endif - - // wrapper struct for struct VkBindMemoryStatus, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindMemoryStatus.html - struct BindMemoryStatus - { - using NativeType = VkBindMemoryStatus; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindMemoryStatus; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindMemoryStatus( Result * pResult_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pResult{ pResult_ } - { - } - - VULKAN_HPP_CONSTEXPR BindMemoryStatus( BindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindMemoryStatus( VkBindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT : BindMemoryStatus( *reinterpret_cast( &rhs ) ) {} - - BindMemoryStatus & operator=( BindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindMemoryStatus & operator=( VkBindMemoryStatus const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus & setPResult( Result * pResult_ ) & VULKAN_HPP_NOEXCEPT - { - pResult = pResult_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindMemoryStatus && setPResult( Result * pResult_ ) && VULKAN_HPP_NOEXCEPT - { - pResult = pResult_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindMemoryStatus const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindMemoryStatus &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindMemoryStatus const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindMemoryStatus *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pResult ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindMemoryStatus const & ) const = default; -#else - bool operator==( BindMemoryStatus const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pResult == rhs.pResult ); -# endif - } - - bool operator!=( BindMemoryStatus const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindMemoryStatus; - const void * pNext = {}; - Result * pResult = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindMemoryStatus; - }; -#endif - - template <> - struct CppType - { - using Type = BindMemoryStatus; - }; - - using BindMemoryStatusKHR = BindMemoryStatus; - - // wrapper struct for struct VkBindPipelineIndirectCommandNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindPipelineIndirectCommandNV.html - struct BindPipelineIndirectCommandNV - { - using NativeType = VkBindPipelineIndirectCommandNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindPipelineIndirectCommandNV( DeviceAddress pipelineAddress_ = {} ) VULKAN_HPP_NOEXCEPT : pipelineAddress{ pipelineAddress_ } {} - - VULKAN_HPP_CONSTEXPR BindPipelineIndirectCommandNV( BindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindPipelineIndirectCommandNV( VkBindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - : BindPipelineIndirectCommandNV( *reinterpret_cast( &rhs ) ) - { - } - - BindPipelineIndirectCommandNV & operator=( BindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindPipelineIndirectCommandNV & operator=( VkBindPipelineIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindPipelineIndirectCommandNV & setPipelineAddress( DeviceAddress pipelineAddress_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineAddress = pipelineAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindPipelineIndirectCommandNV && setPipelineAddress( DeviceAddress pipelineAddress_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineAddress = pipelineAddress_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindPipelineIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindPipelineIndirectCommandNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindPipelineIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindPipelineIndirectCommandNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( pipelineAddress ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindPipelineIndirectCommandNV const & ) const = default; -#else - bool operator==( BindPipelineIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( pipelineAddress == rhs.pipelineAddress ); -# endif - } - - bool operator!=( BindPipelineIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress pipelineAddress = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindPipelineIndirectCommandNV; - }; -#endif - - // wrapper struct for struct VkBindShaderGroupIndirectCommandNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindShaderGroupIndirectCommandNV.html - struct BindShaderGroupIndirectCommandNV - { - using NativeType = VkBindShaderGroupIndirectCommandNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindShaderGroupIndirectCommandNV( uint32_t groupIndex_ = {} ) VULKAN_HPP_NOEXCEPT : groupIndex{ groupIndex_ } {} - - VULKAN_HPP_CONSTEXPR BindShaderGroupIndirectCommandNV( BindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindShaderGroupIndirectCommandNV( VkBindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - : BindShaderGroupIndirectCommandNV( *reinterpret_cast( &rhs ) ) - { - } - - BindShaderGroupIndirectCommandNV & operator=( BindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindShaderGroupIndirectCommandNV & operator=( VkBindShaderGroupIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindShaderGroupIndirectCommandNV & setGroupIndex( uint32_t groupIndex_ ) & VULKAN_HPP_NOEXCEPT - { - groupIndex = groupIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindShaderGroupIndirectCommandNV && setGroupIndex( uint32_t groupIndex_ ) && VULKAN_HPP_NOEXCEPT - { - groupIndex = groupIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindShaderGroupIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindShaderGroupIndirectCommandNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindShaderGroupIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindShaderGroupIndirectCommandNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( groupIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindShaderGroupIndirectCommandNV const & ) const = default; -#else - bool operator==( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( groupIndex == rhs.groupIndex ); -# endif - } - - bool operator!=( BindShaderGroupIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t groupIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindShaderGroupIndirectCommandNV; - }; -#endif - - // wrapper struct for struct VkSparseMemoryBind, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseMemoryBind.html - struct SparseMemoryBind - { - using NativeType = VkSparseMemoryBind; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SparseMemoryBind( DeviceSize resourceOffset_ = {}, - DeviceSize size_ = {}, - DeviceMemory memory_ = {}, - DeviceSize memoryOffset_ = {}, - SparseMemoryBindFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT - : resourceOffset{ resourceOffset_ } - , size{ size_ } - , memory{ memory_ } - , memoryOffset{ memoryOffset_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR SparseMemoryBind( SparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SparseMemoryBind( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT : SparseMemoryBind( *reinterpret_cast( &rhs ) ) {} - - SparseMemoryBind & operator=( SparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SparseMemoryBind & operator=( VkSparseMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setResourceOffset( DeviceSize resourceOffset_ ) & VULKAN_HPP_NOEXCEPT - { - resourceOffset = resourceOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setResourceOffset( DeviceSize resourceOffset_ ) && VULKAN_HPP_NOEXCEPT - { - resourceOffset = resourceOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind & setFlags( SparseMemoryBindFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseMemoryBind && setFlags( SparseMemoryBindFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSparseMemoryBind const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseMemoryBind &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseMemoryBind const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSparseMemoryBind *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( resourceOffset, size, memory, memoryOffset, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SparseMemoryBind const & ) const = default; -#else - bool operator==( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( resourceOffset == rhs.resourceOffset ) && ( size == rhs.size ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ) && - ( flags == rhs.flags ); -# endif - } - - bool operator!=( SparseMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceSize resourceOffset = {}; - DeviceSize size = {}; - DeviceMemory memory = {}; - DeviceSize memoryOffset = {}; - SparseMemoryBindFlags flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SparseMemoryBind; - }; -#endif - - // wrapper struct for struct VkSparseBufferMemoryBindInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseBufferMemoryBindInfo.html - struct SparseBufferMemoryBindInfo - { - using NativeType = VkSparseBufferMemoryBindInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SparseBufferMemoryBindInfo( Buffer buffer_ = {}, uint32_t bindCount_ = {}, const SparseMemoryBind * pBinds_ = {} ) VULKAN_HPP_NOEXCEPT - : buffer{ buffer_ } - , bindCount{ bindCount_ } - , pBinds{ pBinds_ } - { - } - - VULKAN_HPP_CONSTEXPR SparseBufferMemoryBindInfo( SparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SparseBufferMemoryBindInfo( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : SparseBufferMemoryBindInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SparseBufferMemoryBindInfo( Buffer buffer_, ArrayProxyNoTemporaries const & binds_ ) - : buffer( buffer_ ), bindCount( static_cast( binds_.size() ) ), pBinds( binds_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SparseBufferMemoryBindInfo & operator=( SparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SparseBufferMemoryBindInfo & operator=( VkSparseBufferMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo & setBindCount( uint32_t bindCount_ ) & VULKAN_HPP_NOEXCEPT - { - bindCount = bindCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo && setBindCount( uint32_t bindCount_ ) && VULKAN_HPP_NOEXCEPT - { - bindCount = bindCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo & setPBinds( const SparseMemoryBind * pBinds_ ) & VULKAN_HPP_NOEXCEPT - { - pBinds = pBinds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseBufferMemoryBindInfo && setPBinds( const SparseMemoryBind * pBinds_ ) && VULKAN_HPP_NOEXCEPT - { - pBinds = pBinds_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SparseBufferMemoryBindInfo & setBinds( ArrayProxyNoTemporaries const & binds_ ) VULKAN_HPP_NOEXCEPT - { - bindCount = static_cast( binds_.size() ); - pBinds = binds_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSparseBufferMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseBufferMemoryBindInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseBufferMemoryBindInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSparseBufferMemoryBindInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( buffer, bindCount, pBinds ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SparseBufferMemoryBindInfo const & ) const = default; -#else - bool operator==( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( buffer == rhs.buffer ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); -# endif - } - - bool operator!=( SparseBufferMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Buffer buffer = {}; - uint32_t bindCount = {}; - const SparseMemoryBind * pBinds = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SparseBufferMemoryBindInfo; - }; -#endif - - // wrapper struct for struct VkSparseImageOpaqueMemoryBindInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageOpaqueMemoryBindInfo.html - struct SparseImageOpaqueMemoryBindInfo - { - using NativeType = VkSparseImageOpaqueMemoryBindInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - SparseImageOpaqueMemoryBindInfo( Image image_ = {}, uint32_t bindCount_ = {}, const SparseMemoryBind * pBinds_ = {} ) VULKAN_HPP_NOEXCEPT - : image{ image_ } - , bindCount{ bindCount_ } - , pBinds{ pBinds_ } - { - } - - VULKAN_HPP_CONSTEXPR SparseImageOpaqueMemoryBindInfo( SparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SparseImageOpaqueMemoryBindInfo( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : SparseImageOpaqueMemoryBindInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SparseImageOpaqueMemoryBindInfo( Image image_, ArrayProxyNoTemporaries const & binds_ ) - : image( image_ ), bindCount( static_cast( binds_.size() ) ), pBinds( binds_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SparseImageOpaqueMemoryBindInfo & operator=( SparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SparseImageOpaqueMemoryBindInfo & operator=( VkSparseImageOpaqueMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo & setBindCount( uint32_t bindCount_ ) & VULKAN_HPP_NOEXCEPT - { - bindCount = bindCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo && setBindCount( uint32_t bindCount_ ) && VULKAN_HPP_NOEXCEPT - { - bindCount = bindCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo & setPBinds( const SparseMemoryBind * pBinds_ ) & VULKAN_HPP_NOEXCEPT - { - pBinds = pBinds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageOpaqueMemoryBindInfo && setPBinds( const SparseMemoryBind * pBinds_ ) && VULKAN_HPP_NOEXCEPT - { - pBinds = pBinds_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SparseImageOpaqueMemoryBindInfo & setBinds( ArrayProxyNoTemporaries const & binds_ ) VULKAN_HPP_NOEXCEPT - { - bindCount = static_cast( binds_.size() ); - pBinds = binds_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSparseImageOpaqueMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageOpaqueMemoryBindInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageOpaqueMemoryBindInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSparseImageOpaqueMemoryBindInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( image, bindCount, pBinds ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SparseImageOpaqueMemoryBindInfo const & ) const = default; -#else - bool operator==( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); -# endif - } - - bool operator!=( SparseImageOpaqueMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Image image = {}; - uint32_t bindCount = {}; - const SparseMemoryBind * pBinds = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SparseImageOpaqueMemoryBindInfo; - }; -#endif - - // wrapper struct for struct VkImageSubresource, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSubresource.html - struct ImageSubresource - { - using NativeType = VkImageSubresource; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageSubresource( ImageAspectFlags aspectMask_ = {}, uint32_t mipLevel_ = {}, uint32_t arrayLayer_ = {} ) VULKAN_HPP_NOEXCEPT - : aspectMask{ aspectMask_ } - , mipLevel{ mipLevel_ } - , arrayLayer{ arrayLayer_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageSubresource( ImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageSubresource( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT : ImageSubresource( *reinterpret_cast( &rhs ) ) {} - - ImageSubresource & operator=( ImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageSubresource & operator=( VkImageSubresource const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageSubresource & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresource && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresource & setMipLevel( uint32_t mipLevel_ ) & VULKAN_HPP_NOEXCEPT - { - mipLevel = mipLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresource && setMipLevel( uint32_t mipLevel_ ) && VULKAN_HPP_NOEXCEPT - { - mipLevel = mipLevel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresource & setArrayLayer( uint32_t arrayLayer_ ) & VULKAN_HPP_NOEXCEPT - { - arrayLayer = arrayLayer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresource && setArrayLayer( uint32_t arrayLayer_ ) && VULKAN_HPP_NOEXCEPT - { - arrayLayer = arrayLayer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageSubresource const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSubresource &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSubresource const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageSubresource *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( aspectMask, mipLevel, arrayLayer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageSubresource const & ) const = default; -#else - bool operator==( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( arrayLayer == rhs.arrayLayer ); -# endif - } - - bool operator!=( ImageSubresource const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ImageAspectFlags aspectMask = {}; - uint32_t mipLevel = {}; - uint32_t arrayLayer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageSubresource; - }; -#endif - - // wrapper struct for struct VkOffset3D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOffset3D.html - struct Offset3D - { - using NativeType = VkOffset3D; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR Offset3D( int32_t x_ = {}, int32_t y_ = {}, int32_t z_ = {} ) VULKAN_HPP_NOEXCEPT - : x{ x_ } - , y{ y_ } - , z{ z_ } - { - } - - VULKAN_HPP_CONSTEXPR Offset3D( Offset3D const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - Offset3D( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT : Offset3D( *reinterpret_cast( &rhs ) ) {} - - explicit Offset3D( Offset2D const & offset2D, int32_t z_ = {} ) : x( offset2D.x ), y( offset2D.y ), z( z_ ) {} - - Offset3D & operator=( Offset3D const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - Offset3D & operator=( VkOffset3D const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 Offset3D & setX( int32_t x_ ) & VULKAN_HPP_NOEXCEPT - { - x = x_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Offset3D && setX( int32_t x_ ) && VULKAN_HPP_NOEXCEPT - { - x = x_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Offset3D & setY( int32_t y_ ) & VULKAN_HPP_NOEXCEPT - { - y = y_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Offset3D && setY( int32_t y_ ) && VULKAN_HPP_NOEXCEPT - { - y = y_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Offset3D & setZ( int32_t z_ ) & VULKAN_HPP_NOEXCEPT - { - z = z_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Offset3D && setZ( int32_t z_ ) && VULKAN_HPP_NOEXCEPT - { - z = z_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkOffset3D const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOffset3D &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOffset3D const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkOffset3D *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( x, y, z ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( Offset3D const & ) const = default; -#else - bool operator==( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ); -# endif - } - - bool operator!=( Offset3D const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - int32_t x = {}; - int32_t y = {}; - int32_t z = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = Offset3D; - }; -#endif - - // wrapper struct for struct VkExtent3D, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExtent3D.html - struct Extent3D - { - using NativeType = VkExtent3D; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR Extent3D( uint32_t width_ = {}, uint32_t height_ = {}, uint32_t depth_ = {} ) VULKAN_HPP_NOEXCEPT - : width{ width_ } - , height{ height_ } - , depth{ depth_ } - { - } - - VULKAN_HPP_CONSTEXPR Extent3D( Extent3D const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - Extent3D( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT : Extent3D( *reinterpret_cast( &rhs ) ) {} - - explicit Extent3D( Extent2D const & extent2D, uint32_t depth_ = {} ) : width( extent2D.width ), height( extent2D.height ), depth( depth_ ) {} - - Extent3D & operator=( Extent3D const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - Extent3D & operator=( VkExtent3D const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 Extent3D & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT - { - width = width_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Extent3D && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT - { - width = width_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Extent3D & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT - { - height = height_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Extent3D && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT - { - height = height_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Extent3D & setDepth( uint32_t depth_ ) & VULKAN_HPP_NOEXCEPT - { - depth = depth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Extent3D && setDepth( uint32_t depth_ ) && VULKAN_HPP_NOEXCEPT - { - depth = depth_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExtent3D const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExtent3D &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExtent3D const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExtent3D *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( width, height, depth ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( Extent3D const & ) const = default; -#else - bool operator==( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth ); -# endif - } - - bool operator!=( Extent3D const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t width = {}; - uint32_t height = {}; - uint32_t depth = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = Extent3D; - }; -#endif - - // wrapper struct for struct VkSparseImageMemoryBind, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageMemoryBind.html - struct SparseImageMemoryBind - { - using NativeType = VkSparseImageMemoryBind; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SparseImageMemoryBind( ImageSubresource subresource_ = {}, - Offset3D offset_ = {}, - Extent3D extent_ = {}, - DeviceMemory memory_ = {}, - DeviceSize memoryOffset_ = {}, - SparseMemoryBindFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT - : subresource{ subresource_ } - , offset{ offset_ } - , extent{ extent_ } - , memory{ memory_ } - , memoryOffset{ memoryOffset_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR SparseImageMemoryBind( SparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SparseImageMemoryBind( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT - : SparseImageMemoryBind( *reinterpret_cast( &rhs ) ) - { - } - - SparseImageMemoryBind & operator=( SparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SparseImageMemoryBind & operator=( VkSparseImageMemoryBind const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setSubresource( ImageSubresource const & subresource_ ) & VULKAN_HPP_NOEXCEPT - { - subresource = subresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setSubresource( ImageSubresource const & subresource_ ) && VULKAN_HPP_NOEXCEPT - { - subresource = subresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setOffset( Offset3D const & offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setOffset( Offset3D const & offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind & setFlags( SparseMemoryBindFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBind && setFlags( SparseMemoryBindFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSparseImageMemoryBind const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageMemoryBind &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageMemoryBind const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSparseImageMemoryBind *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( subresource, offset, extent, memory, memoryOffset, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SparseImageMemoryBind const & ) const = default; -#else - bool operator==( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( subresource == rhs.subresource ) && ( offset == rhs.offset ) && ( extent == rhs.extent ) && ( memory == rhs.memory ) && - ( memoryOffset == rhs.memoryOffset ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( SparseImageMemoryBind const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ImageSubresource subresource = {}; - Offset3D offset = {}; - Extent3D extent = {}; - DeviceMemory memory = {}; - DeviceSize memoryOffset = {}; - SparseMemoryBindFlags flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SparseImageMemoryBind; - }; -#endif - - // wrapper struct for struct VkSparseImageMemoryBindInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageMemoryBindInfo.html - struct SparseImageMemoryBindInfo - { - using NativeType = VkSparseImageMemoryBindInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - SparseImageMemoryBindInfo( Image image_ = {}, uint32_t bindCount_ = {}, const SparseImageMemoryBind * pBinds_ = {} ) VULKAN_HPP_NOEXCEPT - : image{ image_ } - , bindCount{ bindCount_ } - , pBinds{ pBinds_ } - { - } - - VULKAN_HPP_CONSTEXPR SparseImageMemoryBindInfo( SparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SparseImageMemoryBindInfo( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : SparseImageMemoryBindInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SparseImageMemoryBindInfo( Image image_, ArrayProxyNoTemporaries const & binds_ ) - : image( image_ ), bindCount( static_cast( binds_.size() ) ), pBinds( binds_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SparseImageMemoryBindInfo & operator=( SparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SparseImageMemoryBindInfo & operator=( VkSparseImageMemoryBindInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo & setBindCount( uint32_t bindCount_ ) & VULKAN_HPP_NOEXCEPT - { - bindCount = bindCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo && setBindCount( uint32_t bindCount_ ) && VULKAN_HPP_NOEXCEPT - { - bindCount = bindCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo & setPBinds( const SparseImageMemoryBind * pBinds_ ) & VULKAN_HPP_NOEXCEPT - { - pBinds = pBinds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SparseImageMemoryBindInfo && setPBinds( const SparseImageMemoryBind * pBinds_ ) && VULKAN_HPP_NOEXCEPT - { - pBinds = pBinds_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SparseImageMemoryBindInfo & setBinds( ArrayProxyNoTemporaries const & binds_ ) VULKAN_HPP_NOEXCEPT - { - bindCount = static_cast( binds_.size() ); - pBinds = binds_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSparseImageMemoryBindInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageMemoryBindInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageMemoryBindInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSparseImageMemoryBindInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( image, bindCount, pBinds ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SparseImageMemoryBindInfo const & ) const = default; -#else - bool operator==( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( image == rhs.image ) && ( bindCount == rhs.bindCount ) && ( pBinds == rhs.pBinds ); -# endif - } - - bool operator!=( SparseImageMemoryBindInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Image image = {}; - uint32_t bindCount = {}; - const SparseImageMemoryBind * pBinds = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SparseImageMemoryBindInfo; - }; -#endif - - // wrapper struct for struct VkBindSparseInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindSparseInfo.html - struct BindSparseInfo - { - using NativeType = VkBindSparseInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindSparseInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindSparseInfo( uint32_t waitSemaphoreCount_ = {}, - const Semaphore * pWaitSemaphores_ = {}, - uint32_t bufferBindCount_ = {}, - const SparseBufferMemoryBindInfo * pBufferBinds_ = {}, - uint32_t imageOpaqueBindCount_ = {}, - const SparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds_ = {}, - uint32_t imageBindCount_ = {}, - const SparseImageMemoryBindInfo * pImageBinds_ = {}, - uint32_t signalSemaphoreCount_ = {}, - const Semaphore * pSignalSemaphores_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , waitSemaphoreCount{ waitSemaphoreCount_ } - , pWaitSemaphores{ pWaitSemaphores_ } - , bufferBindCount{ bufferBindCount_ } - , pBufferBinds{ pBufferBinds_ } - , imageOpaqueBindCount{ imageOpaqueBindCount_ } - , pImageOpaqueBinds{ pImageOpaqueBinds_ } - , imageBindCount{ imageBindCount_ } - , pImageBinds{ pImageBinds_ } - , signalSemaphoreCount{ signalSemaphoreCount_ } - , pSignalSemaphores{ pSignalSemaphores_ } - { - } - - VULKAN_HPP_CONSTEXPR BindSparseInfo( BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindSparseInfo( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT : BindSparseInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindSparseInfo( ArrayProxyNoTemporaries const & waitSemaphores_, - ArrayProxyNoTemporaries const & bufferBinds_ = {}, - ArrayProxyNoTemporaries const & imageOpaqueBinds_ = {}, - ArrayProxyNoTemporaries const & imageBinds_ = {}, - ArrayProxyNoTemporaries const & signalSemaphores_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , waitSemaphoreCount( static_cast( waitSemaphores_.size() ) ) - , pWaitSemaphores( waitSemaphores_.data() ) - , bufferBindCount( static_cast( bufferBinds_.size() ) ) - , pBufferBinds( bufferBinds_.data() ) - , imageOpaqueBindCount( static_cast( imageOpaqueBinds_.size() ) ) - , pImageOpaqueBinds( imageOpaqueBinds_.data() ) - , imageBindCount( static_cast( imageBinds_.size() ) ) - , pImageBinds( imageBinds_.data() ) - , signalSemaphoreCount( static_cast( signalSemaphores_.size() ) ) - , pSignalSemaphores( signalSemaphores_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - BindSparseInfo & operator=( BindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindSparseInfo & operator=( VkBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = waitSemaphoreCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) & VULKAN_HPP_NOEXCEPT - { - pWaitSemaphores = pWaitSemaphores_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) && VULKAN_HPP_NOEXCEPT - { - pWaitSemaphores = pWaitSemaphores_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindSparseInfo & setWaitSemaphores( ArrayProxyNoTemporaries const & waitSemaphores_ ) VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = static_cast( waitSemaphores_.size() ); - pWaitSemaphores = waitSemaphores_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setBufferBindCount( uint32_t bufferBindCount_ ) & VULKAN_HPP_NOEXCEPT - { - bufferBindCount = bufferBindCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setBufferBindCount( uint32_t bufferBindCount_ ) && VULKAN_HPP_NOEXCEPT - { - bufferBindCount = bufferBindCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPBufferBinds( const SparseBufferMemoryBindInfo * pBufferBinds_ ) & VULKAN_HPP_NOEXCEPT - { - pBufferBinds = pBufferBinds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPBufferBinds( const SparseBufferMemoryBindInfo * pBufferBinds_ ) && VULKAN_HPP_NOEXCEPT - { - pBufferBinds = pBufferBinds_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindSparseInfo & setBufferBinds( ArrayProxyNoTemporaries const & bufferBinds_ ) VULKAN_HPP_NOEXCEPT - { - bufferBindCount = static_cast( bufferBinds_.size() ); - pBufferBinds = bufferBinds_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) & VULKAN_HPP_NOEXCEPT - { - imageOpaqueBindCount = imageOpaqueBindCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setImageOpaqueBindCount( uint32_t imageOpaqueBindCount_ ) && VULKAN_HPP_NOEXCEPT - { - imageOpaqueBindCount = imageOpaqueBindCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds_ ) & VULKAN_HPP_NOEXCEPT - { - pImageOpaqueBinds = pImageOpaqueBinds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPImageOpaqueBinds( const SparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds_ ) && VULKAN_HPP_NOEXCEPT - { - pImageOpaqueBinds = pImageOpaqueBinds_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindSparseInfo & setImageOpaqueBinds( ArrayProxyNoTemporaries const & imageOpaqueBinds_ ) VULKAN_HPP_NOEXCEPT - { - imageOpaqueBindCount = static_cast( imageOpaqueBinds_.size() ); - pImageOpaqueBinds = imageOpaqueBinds_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setImageBindCount( uint32_t imageBindCount_ ) & VULKAN_HPP_NOEXCEPT - { - imageBindCount = imageBindCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setImageBindCount( uint32_t imageBindCount_ ) && VULKAN_HPP_NOEXCEPT - { - imageBindCount = imageBindCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPImageBinds( const SparseImageMemoryBindInfo * pImageBinds_ ) & VULKAN_HPP_NOEXCEPT - { - pImageBinds = pImageBinds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPImageBinds( const SparseImageMemoryBindInfo * pImageBinds_ ) && VULKAN_HPP_NOEXCEPT - { - pImageBinds = pImageBinds_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindSparseInfo & setImageBinds( ArrayProxyNoTemporaries const & imageBinds_ ) VULKAN_HPP_NOEXCEPT - { - imageBindCount = static_cast( imageBinds_.size() ); - pImageBinds = imageBinds_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT - { - signalSemaphoreCount = signalSemaphoreCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT - { - signalSemaphoreCount = signalSemaphoreCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo & setPSignalSemaphores( const Semaphore * pSignalSemaphores_ ) & VULKAN_HPP_NOEXCEPT - { - pSignalSemaphores = pSignalSemaphores_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindSparseInfo && setPSignalSemaphores( const Semaphore * pSignalSemaphores_ ) && VULKAN_HPP_NOEXCEPT - { - pSignalSemaphores = pSignalSemaphores_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BindSparseInfo & setSignalSemaphores( ArrayProxyNoTemporaries const & signalSemaphores_ ) VULKAN_HPP_NOEXCEPT - { - signalSemaphoreCount = static_cast( signalSemaphores_.size() ); - pSignalSemaphores = signalSemaphores_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindSparseInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindSparseInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindSparseInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - waitSemaphoreCount, - pWaitSemaphores, - bufferBindCount, - pBufferBinds, - imageOpaqueBindCount, - pImageOpaqueBinds, - imageBindCount, - pImageBinds, - signalSemaphoreCount, - pSignalSemaphores ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindSparseInfo const & ) const = default; -#else - bool operator==( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && - ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( bufferBindCount == rhs.bufferBindCount ) && ( pBufferBinds == rhs.pBufferBinds ) && - ( imageOpaqueBindCount == rhs.imageOpaqueBindCount ) && ( pImageOpaqueBinds == rhs.pImageOpaqueBinds ) && - ( imageBindCount == rhs.imageBindCount ) && ( pImageBinds == rhs.pImageBinds ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && - ( pSignalSemaphores == rhs.pSignalSemaphores ); -# endif - } - - bool operator!=( BindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindSparseInfo; - const void * pNext = {}; - uint32_t waitSemaphoreCount = {}; - const Semaphore * pWaitSemaphores = {}; - uint32_t bufferBindCount = {}; - const SparseBufferMemoryBindInfo * pBufferBinds = {}; - uint32_t imageOpaqueBindCount = {}; - const SparseImageOpaqueMemoryBindInfo * pImageOpaqueBinds = {}; - uint32_t imageBindCount = {}; - const SparseImageMemoryBindInfo * pImageBinds = {}; - uint32_t signalSemaphoreCount = {}; - const Semaphore * pSignalSemaphores = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindSparseInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BindSparseInfo; - }; - - // wrapper struct for struct VkBindTensorMemoryInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindTensorMemoryInfoARM.html - struct BindTensorMemoryInfoARM - { - using NativeType = VkBindTensorMemoryInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindTensorMemoryInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindTensorMemoryInfoARM( TensorARM tensor_ = {}, - DeviceMemory memory_ = {}, - DeviceSize memoryOffset_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensor{ tensor_ } - , memory{ memory_ } - , memoryOffset{ memoryOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR BindTensorMemoryInfoARM( BindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindTensorMemoryInfoARM( VkBindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : BindTensorMemoryInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - BindTensorMemoryInfoARM & operator=( BindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindTensorMemoryInfoARM & operator=( VkBindTensorMemoryInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindTensorMemoryInfoARM && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindTensorMemoryInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindTensorMemoryInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindTensorMemoryInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindTensorMemoryInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tensor, memory, memoryOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindTensorMemoryInfoARM const & ) const = default; -#else - bool operator==( BindTensorMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensor == rhs.tensor ) && ( memory == rhs.memory ) && ( memoryOffset == rhs.memoryOffset ); -# endif - } - - bool operator!=( BindTensorMemoryInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindTensorMemoryInfoARM; - const void * pNext = {}; - TensorARM tensor = {}; - DeviceMemory memory = {}; - DeviceSize memoryOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindTensorMemoryInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = BindTensorMemoryInfoARM; - }; - - // wrapper struct for struct VkBindVertexBufferIndirectCommandEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVertexBufferIndirectCommandEXT.html - struct BindVertexBufferIndirectCommandEXT - { - using NativeType = VkBindVertexBufferIndirectCommandEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandEXT( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, uint32_t stride_ = {} ) VULKAN_HPP_NOEXCEPT - : bufferAddress{ bufferAddress_ } - , size{ size_ } - , stride{ stride_ } - { - } - - VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandEXT( BindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindVertexBufferIndirectCommandEXT( VkBindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : BindVertexBufferIndirectCommandEXT( *reinterpret_cast( &rhs ) ) - { - } - - BindVertexBufferIndirectCommandEXT & operator=( BindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindVertexBufferIndirectCommandEXT & operator=( VkBindVertexBufferIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT - { - bufferAddress = bufferAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT - { - bufferAddress = bufferAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandEXT && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindVertexBufferIndirectCommandEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindVertexBufferIndirectCommandEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindVertexBufferIndirectCommandEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindVertexBufferIndirectCommandEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( bufferAddress, size, stride ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindVertexBufferIndirectCommandEXT const & ) const = default; -#else - bool operator==( BindVertexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride ); -# endif - } - - bool operator!=( BindVertexBufferIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress bufferAddress = {}; - uint32_t size = {}; - uint32_t stride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindVertexBufferIndirectCommandEXT; - }; -#endif - - // wrapper struct for struct VkBindVertexBufferIndirectCommandNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVertexBufferIndirectCommandNV.html - struct BindVertexBufferIndirectCommandNV - { - using NativeType = VkBindVertexBufferIndirectCommandNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandNV( DeviceAddress bufferAddress_ = {}, uint32_t size_ = {}, uint32_t stride_ = {} ) VULKAN_HPP_NOEXCEPT - : bufferAddress{ bufferAddress_ } - , size{ size_ } - , stride{ stride_ } - { - } - - VULKAN_HPP_CONSTEXPR BindVertexBufferIndirectCommandNV( BindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindVertexBufferIndirectCommandNV( VkBindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - : BindVertexBufferIndirectCommandNV( *reinterpret_cast( &rhs ) ) - { - } - - BindVertexBufferIndirectCommandNV & operator=( BindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindVertexBufferIndirectCommandNV & operator=( VkBindVertexBufferIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT - { - bufferAddress = bufferAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT - { - bufferAddress = bufferAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindVertexBufferIndirectCommandNV && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindVertexBufferIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindVertexBufferIndirectCommandNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindVertexBufferIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindVertexBufferIndirectCommandNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( bufferAddress, size, stride ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindVertexBufferIndirectCommandNV const & ) const = default; -#else - bool operator==( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( bufferAddress == rhs.bufferAddress ) && ( size == rhs.size ) && ( stride == rhs.stride ); -# endif - } - - bool operator!=( BindVertexBufferIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress bufferAddress = {}; - uint32_t size = {}; - uint32_t stride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindVertexBufferIndirectCommandNV; - }; -#endif - - // wrapper struct for struct VkBindVideoSessionMemoryInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBindVideoSessionMemoryInfoKHR.html - struct BindVideoSessionMemoryInfoKHR - { - using NativeType = VkBindVideoSessionMemoryInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBindVideoSessionMemoryInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BindVideoSessionMemoryInfoKHR( uint32_t memoryBindIndex_ = {}, - DeviceMemory memory_ = {}, - DeviceSize memoryOffset_ = {}, - DeviceSize memorySize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryBindIndex{ memoryBindIndex_ } - , memory{ memory_ } - , memoryOffset{ memoryOffset_ } - , memorySize{ memorySize_ } - { - } - - VULKAN_HPP_CONSTEXPR BindVideoSessionMemoryInfoKHR( BindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BindVideoSessionMemoryInfoKHR( VkBindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : BindVideoSessionMemoryInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - BindVideoSessionMemoryInfoKHR & operator=( BindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BindVideoSessionMemoryInfoKHR & operator=( VkBindVideoSessionMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemoryBindIndex( uint32_t memoryBindIndex_ ) & VULKAN_HPP_NOEXCEPT - { - memoryBindIndex = memoryBindIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemoryBindIndex( uint32_t memoryBindIndex_ ) && VULKAN_HPP_NOEXCEPT - { - memoryBindIndex = memoryBindIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemoryOffset( DeviceSize memoryOffset_ ) & VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemoryOffset( DeviceSize memoryOffset_ ) && VULKAN_HPP_NOEXCEPT - { - memoryOffset = memoryOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR & setMemorySize( DeviceSize memorySize_ ) & VULKAN_HPP_NOEXCEPT - { - memorySize = memorySize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BindVideoSessionMemoryInfoKHR && setMemorySize( DeviceSize memorySize_ ) && VULKAN_HPP_NOEXCEPT - { - memorySize = memorySize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBindVideoSessionMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindVideoSessionMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBindVideoSessionMemoryInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBindVideoSessionMemoryInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryBindIndex, memory, memoryOffset, memorySize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BindVideoSessionMemoryInfoKHR const & ) const = default; -#else - bool operator==( BindVideoSessionMemoryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && ( memory == rhs.memory ) && - ( memoryOffset == rhs.memoryOffset ) && ( memorySize == rhs.memorySize ); -# endif - } - - bool operator!=( BindVideoSessionMemoryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBindVideoSessionMemoryInfoKHR; - const void * pNext = {}; - uint32_t memoryBindIndex = {}; - DeviceMemory memory = {}; - DeviceSize memoryOffset = {}; - DeviceSize memorySize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BindVideoSessionMemoryInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = BindVideoSessionMemoryInfoKHR; - }; - - // wrapper struct for struct VkBlitImageCubicWeightsInfoQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlitImageCubicWeightsInfoQCOM.html - struct BlitImageCubicWeightsInfoQCOM - { - using NativeType = VkBlitImageCubicWeightsInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBlitImageCubicWeightsInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BlitImageCubicWeightsInfoQCOM( CubicFilterWeightsQCOM cubicWeights_ = CubicFilterWeightsQCOM::eCatmullRom, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cubicWeights{ cubicWeights_ } - { - } - - VULKAN_HPP_CONSTEXPR BlitImageCubicWeightsInfoQCOM( BlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BlitImageCubicWeightsInfoQCOM( VkBlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : BlitImageCubicWeightsInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - BlitImageCubicWeightsInfoQCOM & operator=( BlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BlitImageCubicWeightsInfoQCOM & operator=( VkBlitImageCubicWeightsInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM & setCubicWeights( CubicFilterWeightsQCOM cubicWeights_ ) & VULKAN_HPP_NOEXCEPT - { - cubicWeights = cubicWeights_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageCubicWeightsInfoQCOM && setCubicWeights( CubicFilterWeightsQCOM cubicWeights_ ) && VULKAN_HPP_NOEXCEPT - { - cubicWeights = cubicWeights_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBlitImageCubicWeightsInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBlitImageCubicWeightsInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBlitImageCubicWeightsInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBlitImageCubicWeightsInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, cubicWeights ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BlitImageCubicWeightsInfoQCOM const & ) const = default; -#else - bool operator==( BlitImageCubicWeightsInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cubicWeights == rhs.cubicWeights ); -# endif - } - - bool operator!=( BlitImageCubicWeightsInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBlitImageCubicWeightsInfoQCOM; - const void * pNext = {}; - CubicFilterWeightsQCOM cubicWeights = CubicFilterWeightsQCOM::eCatmullRom; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BlitImageCubicWeightsInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = BlitImageCubicWeightsInfoQCOM; - }; - - // wrapper struct for struct VkImageSubresourceLayers, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSubresourceLayers.html - struct ImageSubresourceLayers - { - using NativeType = VkImageSubresourceLayers; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( ImageAspectFlags aspectMask_ = {}, - uint32_t mipLevel_ = {}, - uint32_t baseArrayLayer_ = {}, - uint32_t layerCount_ = {} ) VULKAN_HPP_NOEXCEPT - : aspectMask{ aspectMask_ } - , mipLevel{ mipLevel_ } - , baseArrayLayer{ baseArrayLayer_ } - , layerCount{ layerCount_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageSubresourceLayers( ImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageSubresourceLayers( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageSubresourceLayers( *reinterpret_cast( &rhs ) ) - { - } - - ImageSubresourceLayers & operator=( ImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageSubresourceLayers & operator=( VkImageSubresourceLayers const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setMipLevel( uint32_t mipLevel_ ) & VULKAN_HPP_NOEXCEPT - { - mipLevel = mipLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setMipLevel( uint32_t mipLevel_ ) && VULKAN_HPP_NOEXCEPT - { - mipLevel = mipLevel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setBaseArrayLayer( uint32_t baseArrayLayer_ ) & VULKAN_HPP_NOEXCEPT - { - baseArrayLayer = baseArrayLayer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setBaseArrayLayer( uint32_t baseArrayLayer_ ) && VULKAN_HPP_NOEXCEPT - { - baseArrayLayer = baseArrayLayer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceLayers && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageSubresourceLayers const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSubresourceLayers &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSubresourceLayers const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageSubresourceLayers *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( aspectMask, mipLevel, baseArrayLayer, layerCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageSubresourceLayers const & ) const = default; -#else - bool operator==( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( aspectMask == rhs.aspectMask ) && ( mipLevel == rhs.mipLevel ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); -# endif - } - - bool operator!=( ImageSubresourceLayers const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ImageAspectFlags aspectMask = {}; - uint32_t mipLevel = {}; - uint32_t baseArrayLayer = {}; - uint32_t layerCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageSubresourceLayers; - }; -#endif - - // wrapper struct for struct VkImageBlit2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageBlit2.html - struct ImageBlit2 - { - using NativeType = VkImageBlit2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageBlit2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 ImageBlit2( ImageSubresourceLayers srcSubresource_ = {}, - std::array const & srcOffsets_ = {}, - ImageSubresourceLayers dstSubresource_ = {}, - std::array const & dstOffsets_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcSubresource{ srcSubresource_ } - , srcOffsets{ srcOffsets_ } - , dstSubresource{ dstSubresource_ } - , dstOffsets{ dstOffsets_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit2( ImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageBlit2( VkImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageBlit2( *reinterpret_cast( &rhs ) ) {} - - ImageBlit2 & operator=( ImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageBlit2 & operator=( VkImageBlit2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setSrcOffsets( std::array const & srcOffsets_ ) & VULKAN_HPP_NOEXCEPT - { - srcOffsets = srcOffsets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setSrcOffsets( std::array const & srcOffsets_ ) && VULKAN_HPP_NOEXCEPT - { - srcOffsets = srcOffsets_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit2 & setDstOffsets( std::array const & dstOffsets_ ) & VULKAN_HPP_NOEXCEPT - { - dstOffsets = dstOffsets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit2 && setDstOffsets( std::array const & dstOffsets_ ) && VULKAN_HPP_NOEXCEPT - { - dstOffsets = dstOffsets_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageBlit2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageBlit2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageBlit2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageBlit2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ImageSubresourceLayers const &, - ArrayWrapper1D const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcSubresource, srcOffsets, dstSubresource, dstOffsets ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageBlit2 const & ) const = default; -#else - bool operator==( ImageBlit2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) && - ( dstSubresource == rhs.dstSubresource ) && ( dstOffsets == rhs.dstOffsets ); -# endif - } - - bool operator!=( ImageBlit2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageBlit2; - const void * pNext = {}; - ImageSubresourceLayers srcSubresource = {}; - ArrayWrapper1D srcOffsets = {}; - ImageSubresourceLayers dstSubresource = {}; - ArrayWrapper1D dstOffsets = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageBlit2; - }; -#endif - - template <> - struct CppType - { - using Type = ImageBlit2; - }; - - using ImageBlit2KHR = ImageBlit2; - - // wrapper struct for struct VkBlitImageInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBlitImageInfo2.html - struct BlitImageInfo2 - { - using NativeType = VkBlitImageInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBlitImageInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2( Image srcImage_ = {}, - ImageLayout srcImageLayout_ = ImageLayout::eUndefined, - Image dstImage_ = {}, - ImageLayout dstImageLayout_ = ImageLayout::eUndefined, - uint32_t regionCount_ = {}, - const ImageBlit2 * pRegions_ = {}, - Filter filter_ = Filter::eNearest, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcImage{ srcImage_ } - , srcImageLayout{ srcImageLayout_ } - , dstImage{ dstImage_ } - , dstImageLayout{ dstImageLayout_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - , filter{ filter_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2( BlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BlitImageInfo2( VkBlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : BlitImageInfo2( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BlitImageInfo2( Image srcImage_, - ImageLayout srcImageLayout_, - Image dstImage_, - ImageLayout dstImageLayout_, - ArrayProxyNoTemporaries const & regions_, - Filter filter_ = Filter::eNearest, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , srcImage( srcImage_ ) - , srcImageLayout( srcImageLayout_ ) - , dstImage( dstImage_ ) - , dstImageLayout( dstImageLayout_ ) - , regionCount( static_cast( regions_.size() ) ) - , pRegions( regions_.data() ) - , filter( filter_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - BlitImageInfo2 & operator=( BlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BlitImageInfo2 & operator=( VkBlitImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setPRegions( const ImageBlit2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setPRegions( const ImageBlit2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BlitImageInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 & setFilter( Filter filter_ ) & VULKAN_HPP_NOEXCEPT - { - filter = filter_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BlitImageInfo2 && setFilter( Filter filter_ ) && VULKAN_HPP_NOEXCEPT - { - filter = filter_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBlitImageInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBlitImageInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBlitImageInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBlitImageInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BlitImageInfo2 const & ) const = default; -#else - bool operator==( BlitImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) && - ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ) && - ( filter == rhs.filter ); -# endif - } - - bool operator!=( BlitImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBlitImageInfo2; - const void * pNext = {}; - Image srcImage = {}; - ImageLayout srcImageLayout = ImageLayout::eUndefined; - Image dstImage = {}; - ImageLayout dstImageLayout = ImageLayout::eUndefined; - uint32_t regionCount = {}; - const ImageBlit2 * pRegions = {}; - Filter filter = Filter::eNearest; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BlitImageInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = BlitImageInfo2; - }; - - using BlitImageInfo2KHR = BlitImageInfo2; - - // wrapper struct for struct VkBufferCaptureDescriptorDataInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCaptureDescriptorDataInfoEXT.html - struct BufferCaptureDescriptorDataInfoEXT - { - using NativeType = VkBufferCaptureDescriptorDataInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCaptureDescriptorDataInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferCaptureDescriptorDataInfoEXT( Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , buffer{ buffer_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferCaptureDescriptorDataInfoEXT( BufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferCaptureDescriptorDataInfoEXT( VkBufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferCaptureDescriptorDataInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - BufferCaptureDescriptorDataInfoEXT & operator=( BufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferCaptureDescriptorDataInfoEXT & operator=( VkBufferCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCaptureDescriptorDataInfoEXT && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, buffer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferCaptureDescriptorDataInfoEXT const & ) const = default; -#else - bool operator==( BufferCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); -# endif - } - - bool operator!=( BufferCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferCaptureDescriptorDataInfoEXT; - const void * pNext = {}; - Buffer buffer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferCaptureDescriptorDataInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = BufferCaptureDescriptorDataInfoEXT; - }; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkBufferCollectionBufferCreateInfoFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionBufferCreateInfoFUCHSIA.html - struct BufferCollectionBufferCreateInfoFUCHSIA - { - using NativeType = VkBufferCollectionBufferCreateInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCollectionBufferCreateInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferCollectionBufferCreateInfoFUCHSIA( BufferCollectionFUCHSIA collection_ = {}, - uint32_t index_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , collection{ collection_ } - , index{ index_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferCollectionBufferCreateInfoFUCHSIA( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferCollectionBufferCreateInfoFUCHSIA( VkBufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferCollectionBufferCreateInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - BufferCollectionBufferCreateInfoFUCHSIA & operator=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferCollectionBufferCreateInfoFUCHSIA & operator=( VkBufferCollectionBufferCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA & setCollection( BufferCollectionFUCHSIA collection_ ) & VULKAN_HPP_NOEXCEPT - { - collection = collection_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA && setCollection( BufferCollectionFUCHSIA collection_ ) && VULKAN_HPP_NOEXCEPT - { - collection = collection_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT - { - index = index_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionBufferCreateInfoFUCHSIA && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT - { - index = index_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferCollectionBufferCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCollectionBufferCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCollectionBufferCreateInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferCollectionBufferCreateInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, collection, index ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferCollectionBufferCreateInfoFUCHSIA const & ) const = default; -# else - bool operator==( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && ( index == rhs.index ); -# endif - } - - bool operator!=( BufferCollectionBufferCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eBufferCollectionBufferCreateInfoFUCHSIA; - const void * pNext = {}; - BufferCollectionFUCHSIA collection = {}; - uint32_t index = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferCollectionBufferCreateInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = BufferCollectionBufferCreateInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkBufferCollectionConstraintsInfoFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionConstraintsInfoFUCHSIA.html - struct BufferCollectionConstraintsInfoFUCHSIA - { - using NativeType = VkBufferCollectionConstraintsInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCollectionConstraintsInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferCollectionConstraintsInfoFUCHSIA( uint32_t minBufferCount_ = {}, - uint32_t maxBufferCount_ = {}, - uint32_t minBufferCountForCamping_ = {}, - uint32_t minBufferCountForDedicatedSlack_ = {}, - uint32_t minBufferCountForSharedSlack_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minBufferCount{ minBufferCount_ } - , maxBufferCount{ maxBufferCount_ } - , minBufferCountForCamping{ minBufferCountForCamping_ } - , minBufferCountForDedicatedSlack{ minBufferCountForDedicatedSlack_ } - , minBufferCountForSharedSlack{ minBufferCountForSharedSlack_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferCollectionConstraintsInfoFUCHSIA( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferCollectionConstraintsInfoFUCHSIA( VkBufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferCollectionConstraintsInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - BufferCollectionConstraintsInfoFUCHSIA & operator=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferCollectionConstraintsInfoFUCHSIA & operator=( VkBufferCollectionConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCount( uint32_t minBufferCount_ ) & VULKAN_HPP_NOEXCEPT - { - minBufferCount = minBufferCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCount( uint32_t minBufferCount_ ) && VULKAN_HPP_NOEXCEPT - { - minBufferCount = minBufferCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMaxBufferCount( uint32_t maxBufferCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxBufferCount = maxBufferCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMaxBufferCount( uint32_t maxBufferCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxBufferCount = maxBufferCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCountForCamping( uint32_t minBufferCountForCamping_ ) & VULKAN_HPP_NOEXCEPT - { - minBufferCountForCamping = minBufferCountForCamping_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCountForCamping( uint32_t minBufferCountForCamping_ ) && VULKAN_HPP_NOEXCEPT - { - minBufferCountForCamping = minBufferCountForCamping_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCountForDedicatedSlack( uint32_t minBufferCountForDedicatedSlack_ ) & - VULKAN_HPP_NOEXCEPT - { - minBufferCountForDedicatedSlack = minBufferCountForDedicatedSlack_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCountForDedicatedSlack( uint32_t minBufferCountForDedicatedSlack_ ) && - VULKAN_HPP_NOEXCEPT - { - minBufferCountForDedicatedSlack = minBufferCountForDedicatedSlack_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA & setMinBufferCountForSharedSlack( uint32_t minBufferCountForSharedSlack_ ) & - VULKAN_HPP_NOEXCEPT - { - minBufferCountForSharedSlack = minBufferCountForSharedSlack_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionConstraintsInfoFUCHSIA && setMinBufferCountForSharedSlack( uint32_t minBufferCountForSharedSlack_ ) && - VULKAN_HPP_NOEXCEPT - { - minBufferCountForSharedSlack = minBufferCountForSharedSlack_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferCollectionConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCollectionConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCollectionConstraintsInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferCollectionConstraintsInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minBufferCount, maxBufferCount, minBufferCountForCamping, minBufferCountForDedicatedSlack, minBufferCountForSharedSlack ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferCollectionConstraintsInfoFUCHSIA const & ) const = default; -# else - bool operator==( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minBufferCount == rhs.minBufferCount ) && ( maxBufferCount == rhs.maxBufferCount ) && - ( minBufferCountForCamping == rhs.minBufferCountForCamping ) && ( minBufferCountForDedicatedSlack == rhs.minBufferCountForDedicatedSlack ) && - ( minBufferCountForSharedSlack == rhs.minBufferCountForSharedSlack ); -# endif - } - - bool operator!=( BufferCollectionConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eBufferCollectionConstraintsInfoFUCHSIA; - const void * pNext = {}; - uint32_t minBufferCount = {}; - uint32_t maxBufferCount = {}; - uint32_t minBufferCountForCamping = {}; - uint32_t minBufferCountForDedicatedSlack = {}; - uint32_t minBufferCountForSharedSlack = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferCollectionConstraintsInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = BufferCollectionConstraintsInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkBufferCollectionCreateInfoFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionCreateInfoFUCHSIA.html - struct BufferCollectionCreateInfoFUCHSIA - { - using NativeType = VkBufferCollectionCreateInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCollectionCreateInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferCollectionCreateInfoFUCHSIA( zx_handle_t collectionToken_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , collectionToken{ collectionToken_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferCollectionCreateInfoFUCHSIA( BufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferCollectionCreateInfoFUCHSIA( VkBufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferCollectionCreateInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - BufferCollectionCreateInfoFUCHSIA & operator=( BufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferCollectionCreateInfoFUCHSIA & operator=( VkBufferCollectionCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA & setCollectionToken( zx_handle_t collectionToken_ ) & VULKAN_HPP_NOEXCEPT - { - collectionToken = collectionToken_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionCreateInfoFUCHSIA && setCollectionToken( zx_handle_t collectionToken_ ) && VULKAN_HPP_NOEXCEPT - { - collectionToken = collectionToken_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferCollectionCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCollectionCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCollectionCreateInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferCollectionCreateInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, collectionToken ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -# endif - - bool operator==( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &collectionToken, &rhs.collectionToken, sizeof( zx_handle_t ) ) == 0 ); - } - - bool operator!=( BufferCollectionCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eBufferCollectionCreateInfoFUCHSIA; - const void * pNext = {}; - zx_handle_t collectionToken = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferCollectionCreateInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = BufferCollectionCreateInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkBufferCollectionImageCreateInfoFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionImageCreateInfoFUCHSIA.html - struct BufferCollectionImageCreateInfoFUCHSIA - { - using NativeType = VkBufferCollectionImageCreateInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCollectionImageCreateInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferCollectionImageCreateInfoFUCHSIA( BufferCollectionFUCHSIA collection_ = {}, - uint32_t index_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , collection{ collection_ } - , index{ index_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferCollectionImageCreateInfoFUCHSIA( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferCollectionImageCreateInfoFUCHSIA( VkBufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferCollectionImageCreateInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - BufferCollectionImageCreateInfoFUCHSIA & operator=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferCollectionImageCreateInfoFUCHSIA & operator=( VkBufferCollectionImageCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA & setCollection( BufferCollectionFUCHSIA collection_ ) & VULKAN_HPP_NOEXCEPT - { - collection = collection_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA && setCollection( BufferCollectionFUCHSIA collection_ ) && VULKAN_HPP_NOEXCEPT - { - collection = collection_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT - { - index = index_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCollectionImageCreateInfoFUCHSIA && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT - { - index = index_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferCollectionImageCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCollectionImageCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCollectionImageCreateInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferCollectionImageCreateInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, collection, index ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferCollectionImageCreateInfoFUCHSIA const & ) const = default; -# else - bool operator==( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && ( index == rhs.index ); -# endif - } - - bool operator!=( BufferCollectionImageCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eBufferCollectionImageCreateInfoFUCHSIA; - const void * pNext = {}; - BufferCollectionFUCHSIA collection = {}; - uint32_t index = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferCollectionImageCreateInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = BufferCollectionImageCreateInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkSysmemColorSpaceFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSysmemColorSpaceFUCHSIA.html - struct SysmemColorSpaceFUCHSIA - { - using NativeType = VkSysmemColorSpaceFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSysmemColorSpaceFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SysmemColorSpaceFUCHSIA( uint32_t colorSpace_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , colorSpace{ colorSpace_ } - { - } - - VULKAN_HPP_CONSTEXPR SysmemColorSpaceFUCHSIA( SysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SysmemColorSpaceFUCHSIA( VkSysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : SysmemColorSpaceFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - SysmemColorSpaceFUCHSIA & operator=( SysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SysmemColorSpaceFUCHSIA & operator=( VkSysmemColorSpaceFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA & setColorSpace( uint32_t colorSpace_ ) & VULKAN_HPP_NOEXCEPT - { - colorSpace = colorSpace_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SysmemColorSpaceFUCHSIA && setColorSpace( uint32_t colorSpace_ ) && VULKAN_HPP_NOEXCEPT - { - colorSpace = colorSpace_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSysmemColorSpaceFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSysmemColorSpaceFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSysmemColorSpaceFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSysmemColorSpaceFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, colorSpace ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SysmemColorSpaceFUCHSIA const & ) const = default; -# else - bool operator==( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorSpace == rhs.colorSpace ); -# endif - } - - bool operator!=( SysmemColorSpaceFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eSysmemColorSpaceFUCHSIA; - const void * pNext = {}; - uint32_t colorSpace = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SysmemColorSpaceFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = SysmemColorSpaceFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkBufferCollectionPropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCollectionPropertiesFUCHSIA.html - struct BufferCollectionPropertiesFUCHSIA - { - using NativeType = VkBufferCollectionPropertiesFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCollectionPropertiesFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferCollectionPropertiesFUCHSIA( uint32_t memoryTypeBits_ = {}, - uint32_t bufferCount_ = {}, - uint32_t createInfoIndex_ = {}, - uint64_t sysmemPixelFormat_ = {}, - FormatFeatureFlags formatFeatures_ = {}, - SysmemColorSpaceFUCHSIA sysmemColorSpaceIndex_ = {}, - ComponentMapping samplerYcbcrConversionComponents_ = {}, - SamplerYcbcrModelConversion suggestedYcbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, - SamplerYcbcrRange suggestedYcbcrRange_ = SamplerYcbcrRange::eItuFull, - ChromaLocation suggestedXChromaOffset_ = ChromaLocation::eCositedEven, - ChromaLocation suggestedYChromaOffset_ = ChromaLocation::eCositedEven, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryTypeBits{ memoryTypeBits_ } - , bufferCount{ bufferCount_ } - , createInfoIndex{ createInfoIndex_ } - , sysmemPixelFormat{ sysmemPixelFormat_ } - , formatFeatures{ formatFeatures_ } - , sysmemColorSpaceIndex{ sysmemColorSpaceIndex_ } - , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ } - , suggestedYcbcrModel{ suggestedYcbcrModel_ } - , suggestedYcbcrRange{ suggestedYcbcrRange_ } - , suggestedXChromaOffset{ suggestedXChromaOffset_ } - , suggestedYChromaOffset{ suggestedYChromaOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferCollectionPropertiesFUCHSIA( BufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferCollectionPropertiesFUCHSIA( VkBufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferCollectionPropertiesFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - BufferCollectionPropertiesFUCHSIA & operator=( BufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferCollectionPropertiesFUCHSIA & operator=( VkBufferCollectionPropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkBufferCollectionPropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCollectionPropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCollectionPropertiesFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferCollectionPropertiesFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - memoryTypeBits, - bufferCount, - createInfoIndex, - sysmemPixelFormat, - formatFeatures, - sysmemColorSpaceIndex, - samplerYcbcrConversionComponents, - suggestedYcbcrModel, - suggestedYcbcrRange, - suggestedXChromaOffset, - suggestedYChromaOffset ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferCollectionPropertiesFUCHSIA const & ) const = default; -# else - bool operator==( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ) && ( bufferCount == rhs.bufferCount ) && - ( createInfoIndex == rhs.createInfoIndex ) && ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && ( formatFeatures == rhs.formatFeatures ) && - ( sysmemColorSpaceIndex == rhs.sysmemColorSpaceIndex ) && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && - ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && - ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); -# endif - } - - bool operator!=( BufferCollectionPropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eBufferCollectionPropertiesFUCHSIA; - void * pNext = {}; - uint32_t memoryTypeBits = {}; - uint32_t bufferCount = {}; - uint32_t createInfoIndex = {}; - uint64_t sysmemPixelFormat = {}; - FormatFeatureFlags formatFeatures = {}; - SysmemColorSpaceFUCHSIA sysmemColorSpaceIndex = {}; - ComponentMapping samplerYcbcrConversionComponents = {}; - SamplerYcbcrModelConversion suggestedYcbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; - SamplerYcbcrRange suggestedYcbcrRange = SamplerYcbcrRange::eItuFull; - ChromaLocation suggestedXChromaOffset = ChromaLocation::eCositedEven; - ChromaLocation suggestedYChromaOffset = ChromaLocation::eCositedEven; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferCollectionPropertiesFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = BufferCollectionPropertiesFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - // wrapper struct for struct VkBufferCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCreateInfo.html - struct BufferCreateInfo - { - using NativeType = VkBufferCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferCreateInfo( BufferCreateFlags flags_ = {}, - DeviceSize size_ = {}, - BufferUsageFlags usage_ = {}, - SharingMode sharingMode_ = SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = {}, - const uint32_t * pQueueFamilyIndices_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , size{ size_ } - , usage{ usage_ } - , sharingMode{ sharingMode_ } - , queueFamilyIndexCount{ queueFamilyIndexCount_ } - , pQueueFamilyIndices{ pQueueFamilyIndices_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferCreateInfo( BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferCreateInfo( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : BufferCreateInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BufferCreateInfo( BufferCreateFlags flags_, - DeviceSize size_, - BufferUsageFlags usage_, - SharingMode sharingMode_, - ArrayProxyNoTemporaries const & queueFamilyIndices_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , size( size_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( static_cast( queueFamilyIndices_.size() ) ) - , pQueueFamilyIndices( queueFamilyIndices_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - BufferCreateInfo & operator=( BufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferCreateInfo & operator=( VkBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setFlags( BufferCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setFlags( BufferCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setUsage( BufferUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setUsage( BufferUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setSharingMode( SharingMode sharingMode_ ) & VULKAN_HPP_NOEXCEPT - { - sharingMode = sharingMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setSharingMode( SharingMode sharingMode_ ) && VULKAN_HPP_NOEXCEPT - { - sharingMode = sharingMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) & VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) && VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo & setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCreateInfo && setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - BufferCreateInfo & setQueueFamilyIndices( ArrayProxyNoTemporaries const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = static_cast( queueFamilyIndices_.size() ); - pQueueFamilyIndices = queueFamilyIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, size, usage, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferCreateInfo const & ) const = default; -#else - bool operator==( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( size == rhs.size ) && ( usage == rhs.usage ) && - ( sharingMode == rhs.sharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); -# endif - } - - bool operator!=( BufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferCreateInfo; - const void * pNext = {}; - BufferCreateFlags flags = {}; - DeviceSize size = {}; - BufferUsageFlags usage = {}; - SharingMode sharingMode = SharingMode::eExclusive; - uint32_t queueFamilyIndexCount = {}; - const uint32_t * pQueueFamilyIndices = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BufferCreateInfo; - }; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkBufferConstraintsInfoFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferConstraintsInfoFUCHSIA.html - struct BufferConstraintsInfoFUCHSIA - { - using NativeType = VkBufferConstraintsInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferConstraintsInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferConstraintsInfoFUCHSIA( BufferCreateInfo createInfo_ = {}, - FormatFeatureFlags requiredFormatFeatures_ = {}, - BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , createInfo{ createInfo_ } - , requiredFormatFeatures{ requiredFormatFeatures_ } - , bufferCollectionConstraints{ bufferCollectionConstraints_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferConstraintsInfoFUCHSIA( BufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferConstraintsInfoFUCHSIA( VkBufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferConstraintsInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - BufferConstraintsInfoFUCHSIA & operator=( BufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferConstraintsInfoFUCHSIA & operator=( VkBufferConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA & setCreateInfo( BufferCreateInfo const & createInfo_ ) & VULKAN_HPP_NOEXCEPT - { - createInfo = createInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA && setCreateInfo( BufferCreateInfo const & createInfo_ ) && VULKAN_HPP_NOEXCEPT - { - createInfo = createInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA & setRequiredFormatFeatures( FormatFeatureFlags requiredFormatFeatures_ ) & VULKAN_HPP_NOEXCEPT - { - requiredFormatFeatures = requiredFormatFeatures_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA && setRequiredFormatFeatures( FormatFeatureFlags requiredFormatFeatures_ ) && VULKAN_HPP_NOEXCEPT - { - requiredFormatFeatures = requiredFormatFeatures_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA & - setBufferCollectionConstraints( BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraints_ ) & - VULKAN_HPP_NOEXCEPT - { - bufferCollectionConstraints = bufferCollectionConstraints_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferConstraintsInfoFUCHSIA && - setBufferCollectionConstraints( BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraints_ ) && - VULKAN_HPP_NOEXCEPT - { - bufferCollectionConstraints = bufferCollectionConstraints_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferConstraintsInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferConstraintsInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, createInfo, requiredFormatFeatures, bufferCollectionConstraints ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferConstraintsInfoFUCHSIA const & ) const = default; -# else - bool operator==( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createInfo == rhs.createInfo ) && ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && - ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ); -# endif - } - - bool operator!=( BufferConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eBufferConstraintsInfoFUCHSIA; - const void * pNext = {}; - BufferCreateInfo createInfo = {}; - FormatFeatureFlags requiredFormatFeatures = {}; - BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferConstraintsInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = BufferConstraintsInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - // wrapper struct for struct VkBufferCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCopy.html - struct BufferCopy - { - using NativeType = VkBufferCopy; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferCopy( DeviceSize srcOffset_ = {}, DeviceSize dstOffset_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT - : srcOffset{ srcOffset_ } - , dstOffset{ dstOffset_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferCopy( BufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferCopy( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT : BufferCopy( *reinterpret_cast( &rhs ) ) {} - - BufferCopy & operator=( BufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferCopy & operator=( VkBufferCopy const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferCopy & setSrcOffset( DeviceSize srcOffset_ ) & VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy && setSrcOffset( DeviceSize srcOffset_ ) && VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy & setDstOffset( DeviceSize dstOffset_ ) & VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy && setDstOffset( DeviceSize dstOffset_ ) && VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferCopy const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCopy &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCopy const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferCopy *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( srcOffset, dstOffset, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferCopy const & ) const = default; -#else - bool operator==( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size ); -# endif - } - - bool operator!=( BufferCopy const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceSize srcOffset = {}; - DeviceSize dstOffset = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferCopy; - }; -#endif - - // wrapper struct for struct VkBufferCopy2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferCopy2.html - struct BufferCopy2 - { - using NativeType = VkBufferCopy2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferCopy2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - BufferCopy2( DeviceSize srcOffset_ = {}, DeviceSize dstOffset_ = {}, DeviceSize size_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcOffset{ srcOffset_ } - , dstOffset{ dstOffset_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferCopy2( BufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferCopy2( VkBufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT : BufferCopy2( *reinterpret_cast( &rhs ) ) {} - - BufferCopy2 & operator=( BufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferCopy2 & operator=( VkBufferCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setSrcOffset( DeviceSize srcOffset_ ) & VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setSrcOffset( DeviceSize srcOffset_ ) && VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setDstOffset( DeviceSize dstOffset_ ) & VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setDstOffset( DeviceSize dstOffset_ ) && VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy2 & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferCopy2 && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferCopy2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCopy2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferCopy2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferCopy2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcOffset, dstOffset, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferCopy2 const & ) const = default; -#else - bool operator==( BufferCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcOffset == rhs.srcOffset ) && ( dstOffset == rhs.dstOffset ) && ( size == rhs.size ); -# endif - } - - bool operator!=( BufferCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferCopy2; - const void * pNext = {}; - DeviceSize srcOffset = {}; - DeviceSize dstOffset = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferCopy2; - }; -#endif - - template <> - struct CppType - { - using Type = BufferCopy2; - }; - - using BufferCopy2KHR = BufferCopy2; - - // wrapper struct for struct VkBufferDeviceAddressCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferDeviceAddressCreateInfoEXT.html - struct BufferDeviceAddressCreateInfoEXT - { - using NativeType = VkBufferDeviceAddressCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferDeviceAddressCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( DeviceAddress deviceAddress_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceAddress{ deviceAddress_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferDeviceAddressCreateInfoEXT( BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferDeviceAddressCreateInfoEXT( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferDeviceAddressCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - BufferDeviceAddressCreateInfoEXT & operator=( BufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferDeviceAddressCreateInfoEXT & operator=( VkBufferDeviceAddressCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressCreateInfoEXT && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferDeviceAddressCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferDeviceAddressCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferDeviceAddressCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferDeviceAddressCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceAddress ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferDeviceAddressCreateInfoEXT const & ) const = default; -#else - bool operator==( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ); -# endif - } - - bool operator!=( BufferDeviceAddressCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferDeviceAddressCreateInfoEXT; - const void * pNext = {}; - DeviceAddress deviceAddress = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferDeviceAddressCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = BufferDeviceAddressCreateInfoEXT; - }; - - // wrapper struct for struct VkBufferDeviceAddressInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferDeviceAddressInfo.html - struct BufferDeviceAddressInfo - { - using NativeType = VkBufferDeviceAddressInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferDeviceAddressInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfo( Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , buffer{ buffer_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferDeviceAddressInfo( BufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferDeviceAddressInfo( VkBufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferDeviceAddressInfo( *reinterpret_cast( &rhs ) ) - { - } - - BufferDeviceAddressInfo & operator=( BufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferDeviceAddressInfo & operator=( VkBufferDeviceAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferDeviceAddressInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferDeviceAddressInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferDeviceAddressInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferDeviceAddressInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferDeviceAddressInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, buffer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferDeviceAddressInfo const & ) const = default; -#else - bool operator==( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); -# endif - } - - bool operator!=( BufferDeviceAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferDeviceAddressInfo; - const void * pNext = {}; - Buffer buffer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferDeviceAddressInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BufferDeviceAddressInfo; - }; - - using BufferDeviceAddressInfoEXT = BufferDeviceAddressInfo; - using BufferDeviceAddressInfoKHR = BufferDeviceAddressInfo; - - // wrapper struct for struct VkBufferImageCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferImageCopy.html - struct BufferImageCopy - { - using NativeType = VkBufferImageCopy; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferImageCopy( DeviceSize bufferOffset_ = {}, - uint32_t bufferRowLength_ = {}, - uint32_t bufferImageHeight_ = {}, - ImageSubresourceLayers imageSubresource_ = {}, - Offset3D imageOffset_ = {}, - Extent3D imageExtent_ = {} ) VULKAN_HPP_NOEXCEPT - : bufferOffset{ bufferOffset_ } - , bufferRowLength{ bufferRowLength_ } - , bufferImageHeight{ bufferImageHeight_ } - , imageSubresource{ imageSubresource_ } - , imageOffset{ imageOffset_ } - , imageExtent{ imageExtent_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferImageCopy( BufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferImageCopy( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT : BufferImageCopy( *reinterpret_cast( &rhs ) ) {} - - BufferImageCopy & operator=( BufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferImageCopy & operator=( VkBufferImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setBufferOffset( DeviceSize bufferOffset_ ) & VULKAN_HPP_NOEXCEPT - { - bufferOffset = bufferOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setBufferOffset( DeviceSize bufferOffset_ ) && VULKAN_HPP_NOEXCEPT - { - bufferOffset = bufferOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setBufferRowLength( uint32_t bufferRowLength_ ) & VULKAN_HPP_NOEXCEPT - { - bufferRowLength = bufferRowLength_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setBufferRowLength( uint32_t bufferRowLength_ ) && VULKAN_HPP_NOEXCEPT - { - bufferRowLength = bufferRowLength_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setBufferImageHeight( uint32_t bufferImageHeight_ ) & VULKAN_HPP_NOEXCEPT - { - bufferImageHeight = bufferImageHeight_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setBufferImageHeight( uint32_t bufferImageHeight_ ) && VULKAN_HPP_NOEXCEPT - { - bufferImageHeight = bufferImageHeight_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT - { - imageOffset = imageOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT - { - imageOffset = imageOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferImageCopy const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferImageCopy &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferImageCopy const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferImageCopy *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferImageCopy const & ) const = default; -#else - bool operator==( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) && ( bufferImageHeight == rhs.bufferImageHeight ) && - ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent ); -# endif - } - - bool operator!=( BufferImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceSize bufferOffset = {}; - uint32_t bufferRowLength = {}; - uint32_t bufferImageHeight = {}; - ImageSubresourceLayers imageSubresource = {}; - Offset3D imageOffset = {}; - Extent3D imageExtent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferImageCopy; - }; -#endif - - // wrapper struct for struct VkBufferImageCopy2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferImageCopy2.html - struct BufferImageCopy2 - { - using NativeType = VkBufferImageCopy2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferImageCopy2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferImageCopy2( DeviceSize bufferOffset_ = {}, - uint32_t bufferRowLength_ = {}, - uint32_t bufferImageHeight_ = {}, - ImageSubresourceLayers imageSubresource_ = {}, - Offset3D imageOffset_ = {}, - Extent3D imageExtent_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , bufferOffset{ bufferOffset_ } - , bufferRowLength{ bufferRowLength_ } - , bufferImageHeight{ bufferImageHeight_ } - , imageSubresource{ imageSubresource_ } - , imageOffset{ imageOffset_ } - , imageExtent{ imageExtent_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferImageCopy2( BufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferImageCopy2( VkBufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT : BufferImageCopy2( *reinterpret_cast( &rhs ) ) {} - - BufferImageCopy2 & operator=( BufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferImageCopy2 & operator=( VkBufferImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setBufferOffset( DeviceSize bufferOffset_ ) & VULKAN_HPP_NOEXCEPT - { - bufferOffset = bufferOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setBufferOffset( DeviceSize bufferOffset_ ) && VULKAN_HPP_NOEXCEPT - { - bufferOffset = bufferOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setBufferRowLength( uint32_t bufferRowLength_ ) & VULKAN_HPP_NOEXCEPT - { - bufferRowLength = bufferRowLength_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setBufferRowLength( uint32_t bufferRowLength_ ) && VULKAN_HPP_NOEXCEPT - { - bufferRowLength = bufferRowLength_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setBufferImageHeight( uint32_t bufferImageHeight_ ) & VULKAN_HPP_NOEXCEPT - { - bufferImageHeight = bufferImageHeight_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setBufferImageHeight( uint32_t bufferImageHeight_ ) && VULKAN_HPP_NOEXCEPT - { - bufferImageHeight = bufferImageHeight_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT - { - imageOffset = imageOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT - { - imageOffset = imageOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferImageCopy2 && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferImageCopy2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferImageCopy2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferImageCopy2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferImageCopy2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, bufferOffset, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferImageCopy2 const & ) const = default; -#else - bool operator==( BufferImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferOffset == rhs.bufferOffset ) && ( bufferRowLength == rhs.bufferRowLength ) && - ( bufferImageHeight == rhs.bufferImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && - ( imageExtent == rhs.imageExtent ); -# endif - } - - bool operator!=( BufferImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferImageCopy2; - const void * pNext = {}; - DeviceSize bufferOffset = {}; - uint32_t bufferRowLength = {}; - uint32_t bufferImageHeight = {}; - ImageSubresourceLayers imageSubresource = {}; - Offset3D imageOffset = {}; - Extent3D imageExtent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferImageCopy2; - }; -#endif - - template <> - struct CppType - { - using Type = BufferImageCopy2; - }; - - using BufferImageCopy2KHR = BufferImageCopy2; - - // wrapper struct for struct VkBufferMemoryBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferMemoryBarrier.html - struct BufferMemoryBarrier - { - using NativeType = VkBufferMemoryBarrier; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryBarrier; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( AccessFlags srcAccessMask_ = {}, - AccessFlags dstAccessMask_ = {}, - uint32_t srcQueueFamilyIndex_ = {}, - uint32_t dstQueueFamilyIndex_ = {}, - Buffer buffer_ = {}, - DeviceSize offset_ = {}, - DeviceSize size_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcAccessMask{ srcAccessMask_ } - , dstAccessMask{ dstAccessMask_ } - , srcQueueFamilyIndex{ srcQueueFamilyIndex_ } - , dstQueueFamilyIndex{ dstQueueFamilyIndex_ } - , buffer{ buffer_ } - , offset{ offset_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferMemoryBarrier( BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferMemoryBarrier( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT : BufferMemoryBarrier( *reinterpret_cast( &rhs ) ) - { - } - - BufferMemoryBarrier & operator=( BufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferMemoryBarrier & operator=( VkBufferMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setSrcAccessMask( AccessFlags srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setDstAccessMask( AccessFlags dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferMemoryBarrier &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferMemoryBarrier const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferMemoryBarrier *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcAccessMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferMemoryBarrier const & ) const = default; -#else - bool operator==( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) && - ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) && - ( offset == rhs.offset ) && ( size == rhs.size ); -# endif - } - - bool operator!=( BufferMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferMemoryBarrier; - const void * pNext = {}; - AccessFlags srcAccessMask = {}; - AccessFlags dstAccessMask = {}; - uint32_t srcQueueFamilyIndex = {}; - uint32_t dstQueueFamilyIndex = {}; - Buffer buffer = {}; - DeviceSize offset = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferMemoryBarrier; - }; -#endif - - template <> - struct CppType - { - using Type = BufferMemoryBarrier; - }; - - // wrapper struct for struct VkBufferMemoryBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferMemoryBarrier2.html - struct BufferMemoryBarrier2 - { - using NativeType = VkBufferMemoryBarrier2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryBarrier2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferMemoryBarrier2( PipelineStageFlags2 srcStageMask_ = {}, - AccessFlags2 srcAccessMask_ = {}, - PipelineStageFlags2 dstStageMask_ = {}, - AccessFlags2 dstAccessMask_ = {}, - uint32_t srcQueueFamilyIndex_ = {}, - uint32_t dstQueueFamilyIndex_ = {}, - Buffer buffer_ = {}, - DeviceSize offset_ = {}, - DeviceSize size_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcStageMask{ srcStageMask_ } - , srcAccessMask{ srcAccessMask_ } - , dstStageMask{ dstStageMask_ } - , dstAccessMask{ dstAccessMask_ } - , srcQueueFamilyIndex{ srcQueueFamilyIndex_ } - , dstQueueFamilyIndex{ dstQueueFamilyIndex_ } - , buffer{ buffer_ } - , offset{ offset_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferMemoryBarrier2( BufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferMemoryBarrier2( VkBufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferMemoryBarrier2( *reinterpret_cast( &rhs ) ) - { - } - - BufferMemoryBarrier2 & operator=( BufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferMemoryBarrier2 & operator=( VkBufferMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryBarrier2 && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferMemoryBarrier2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferMemoryBarrier2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferMemoryBarrier2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferMemoryBarrier2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, buffer, offset, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferMemoryBarrier2 const & ) const = default; -#else - bool operator==( BufferMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && - ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && - ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( size == rhs.size ); -# endif - } - - bool operator!=( BufferMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferMemoryBarrier2; - const void * pNext = {}; - PipelineStageFlags2 srcStageMask = {}; - AccessFlags2 srcAccessMask = {}; - PipelineStageFlags2 dstStageMask = {}; - AccessFlags2 dstAccessMask = {}; - uint32_t srcQueueFamilyIndex = {}; - uint32_t dstQueueFamilyIndex = {}; - Buffer buffer = {}; - DeviceSize offset = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferMemoryBarrier2; - }; -#endif - - template <> - struct CppType - { - using Type = BufferMemoryBarrier2; - }; - - using BufferMemoryBarrier2KHR = BufferMemoryBarrier2; - - // wrapper struct for struct VkBufferMemoryRequirementsInfo2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferMemoryRequirementsInfo2.html - struct BufferMemoryRequirementsInfo2 - { - using NativeType = VkBufferMemoryRequirementsInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferMemoryRequirementsInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , buffer{ buffer_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferMemoryRequirementsInfo2( BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferMemoryRequirementsInfo2( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferMemoryRequirementsInfo2( *reinterpret_cast( &rhs ) ) - { - } - - BufferMemoryRequirementsInfo2 & operator=( BufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferMemoryRequirementsInfo2 & operator=( VkBufferMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferMemoryRequirementsInfo2 && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferMemoryRequirementsInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferMemoryRequirementsInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, buffer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferMemoryRequirementsInfo2 const & ) const = default; -#else - bool operator==( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); -# endif - } - - bool operator!=( BufferMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferMemoryRequirementsInfo2; - const void * pNext = {}; - Buffer buffer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferMemoryRequirementsInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = BufferMemoryRequirementsInfo2; - }; - - using BufferMemoryRequirementsInfo2KHR = BufferMemoryRequirementsInfo2; - - // wrapper struct for struct VkBufferOpaqueCaptureAddressCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferOpaqueCaptureAddressCreateInfo.html - struct BufferOpaqueCaptureAddressCreateInfo - { - using NativeType = VkBufferOpaqueCaptureAddressCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferOpaqueCaptureAddressCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferOpaqueCaptureAddressCreateInfo( uint64_t opaqueCaptureAddress_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , opaqueCaptureAddress{ opaqueCaptureAddress_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferOpaqueCaptureAddressCreateInfo( BufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferOpaqueCaptureAddressCreateInfo( VkBufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferOpaqueCaptureAddressCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - BufferOpaqueCaptureAddressCreateInfo & operator=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferOpaqueCaptureAddressCreateInfo & operator=( VkBufferOpaqueCaptureAddressCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo & setOpaqueCaptureAddress( uint64_t opaqueCaptureAddress_ ) & VULKAN_HPP_NOEXCEPT - { - opaqueCaptureAddress = opaqueCaptureAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferOpaqueCaptureAddressCreateInfo && setOpaqueCaptureAddress( uint64_t opaqueCaptureAddress_ ) && VULKAN_HPP_NOEXCEPT - { - opaqueCaptureAddress = opaqueCaptureAddress_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferOpaqueCaptureAddressCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferOpaqueCaptureAddressCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferOpaqueCaptureAddressCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferOpaqueCaptureAddressCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, opaqueCaptureAddress ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferOpaqueCaptureAddressCreateInfo const & ) const = default; -#else - bool operator==( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress ); -# endif - } - - bool operator!=( BufferOpaqueCaptureAddressCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferOpaqueCaptureAddressCreateInfo; - const void * pNext = {}; - uint64_t opaqueCaptureAddress = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferOpaqueCaptureAddressCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BufferOpaqueCaptureAddressCreateInfo; - }; - - using BufferOpaqueCaptureAddressCreateInfoKHR = BufferOpaqueCaptureAddressCreateInfo; - - // wrapper struct for struct VkBufferUsageFlags2CreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferUsageFlags2CreateInfo.html - struct BufferUsageFlags2CreateInfo - { - using NativeType = VkBufferUsageFlags2CreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferUsageFlags2CreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferUsageFlags2CreateInfo( BufferUsageFlags2 usage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , usage{ usage_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferUsageFlags2CreateInfo( BufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferUsageFlags2CreateInfo( VkBufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferUsageFlags2CreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - BufferUsageFlags2CreateInfo & operator=( BufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferUsageFlags2CreateInfo & operator=( VkBufferUsageFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo & setUsage( BufferUsageFlags2 usage_ ) & VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferUsageFlags2CreateInfo && setUsage( BufferUsageFlags2 usage_ ) && VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferUsageFlags2CreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferUsageFlags2CreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferUsageFlags2CreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferUsageFlags2CreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, usage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferUsageFlags2CreateInfo const & ) const = default; -#else - bool operator==( BufferUsageFlags2CreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage ); -# endif - } - - bool operator!=( BufferUsageFlags2CreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferUsageFlags2CreateInfo; - const void * pNext = {}; - BufferUsageFlags2 usage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferUsageFlags2CreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BufferUsageFlags2CreateInfo; - }; - - using BufferUsageFlags2CreateInfoKHR = BufferUsageFlags2CreateInfo; - - // wrapper struct for struct VkBufferViewCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkBufferViewCreateInfo.html - struct BufferViewCreateInfo - { - using NativeType = VkBufferViewCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBufferViewCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( BufferViewCreateFlags flags_ = {}, - Buffer buffer_ = {}, - Format format_ = Format::eUndefined, - DeviceSize offset_ = {}, - DeviceSize range_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , buffer{ buffer_ } - , format{ format_ } - , offset{ offset_ } - , range{ range_ } - { - } - - VULKAN_HPP_CONSTEXPR BufferViewCreateInfo( BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BufferViewCreateInfo( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : BufferViewCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - BufferViewCreateInfo & operator=( BufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BufferViewCreateInfo & operator=( VkBufferViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setFlags( BufferViewCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setFlags( BufferViewCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo & setRange( DeviceSize range_ ) & VULKAN_HPP_NOEXCEPT - { - range = range_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BufferViewCreateInfo && setRange( DeviceSize range_ ) && VULKAN_HPP_NOEXCEPT - { - range = range_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBufferViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferViewCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBufferViewCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBufferViewCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, buffer, format, offset, range ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BufferViewCreateInfo const & ) const = default; -#else - bool operator==( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( buffer == rhs.buffer ) && ( format == rhs.format ) && - ( offset == rhs.offset ) && ( range == rhs.range ); -# endif - } - - bool operator!=( BufferViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBufferViewCreateInfo; - const void * pNext = {}; - BufferViewCreateFlags flags = {}; - Buffer buffer = {}; - Format format = Format::eUndefined; - DeviceSize offset = {}; - DeviceSize range = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BufferViewCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = BufferViewCreateInfo; - }; - - // wrapper struct for struct VkStridedDeviceAddressNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressNV.html - struct StridedDeviceAddressNV - { - using NativeType = VkStridedDeviceAddressNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR StridedDeviceAddressNV( DeviceAddress startAddress_ = {}, DeviceSize strideInBytes_ = {} ) VULKAN_HPP_NOEXCEPT - : startAddress{ startAddress_ } - , strideInBytes{ strideInBytes_ } - { - } - - VULKAN_HPP_CONSTEXPR StridedDeviceAddressNV( StridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - StridedDeviceAddressNV( VkStridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT - : StridedDeviceAddressNV( *reinterpret_cast( &rhs ) ) - { - } - - StridedDeviceAddressNV & operator=( StridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - StridedDeviceAddressNV & operator=( VkStridedDeviceAddressNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV & setStartAddress( DeviceAddress startAddress_ ) & VULKAN_HPP_NOEXCEPT - { - startAddress = startAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV && setStartAddress( DeviceAddress startAddress_ ) && VULKAN_HPP_NOEXCEPT - { - startAddress = startAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV & setStrideInBytes( DeviceSize strideInBytes_ ) & VULKAN_HPP_NOEXCEPT - { - strideInBytes = strideInBytes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressNV && setStrideInBytes( DeviceSize strideInBytes_ ) && VULKAN_HPP_NOEXCEPT - { - strideInBytes = strideInBytes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkStridedDeviceAddressNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( startAddress, strideInBytes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( StridedDeviceAddressNV const & ) const = default; -#else - bool operator==( StridedDeviceAddressNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( startAddress == rhs.startAddress ) && ( strideInBytes == rhs.strideInBytes ); -# endif - } - - bool operator!=( StridedDeviceAddressNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress startAddress = {}; - DeviceSize strideInBytes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = StridedDeviceAddressNV; - }; -#endif - - // wrapper struct for struct VkBuildPartitionedAccelerationStructureIndirectCommandNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildPartitionedAccelerationStructureIndirectCommandNV.html - struct BuildPartitionedAccelerationStructureIndirectCommandNV - { - using NativeType = VkBuildPartitionedAccelerationStructureIndirectCommandNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureIndirectCommandNV( - PartitionedAccelerationStructureOpTypeNV opType_ = PartitionedAccelerationStructureOpTypeNV::eWriteInstance, - uint32_t argCount_ = {}, - StridedDeviceAddressNV argData_ = {} ) VULKAN_HPP_NOEXCEPT - : opType{ opType_ } - , argCount{ argCount_ } - , argData{ argData_ } - { - } - - VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureIndirectCommandNV( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - BuildPartitionedAccelerationStructureIndirectCommandNV( VkBuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - : BuildPartitionedAccelerationStructureIndirectCommandNV( *reinterpret_cast( &rhs ) ) - { - } - - BuildPartitionedAccelerationStructureIndirectCommandNV & - operator=( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BuildPartitionedAccelerationStructureIndirectCommandNV & - operator=( VkBuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV & setOpType( PartitionedAccelerationStructureOpTypeNV opType_ ) & - VULKAN_HPP_NOEXCEPT - { - opType = opType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV && setOpType( PartitionedAccelerationStructureOpTypeNV opType_ ) && - VULKAN_HPP_NOEXCEPT - { - opType = opType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV & setArgCount( uint32_t argCount_ ) & VULKAN_HPP_NOEXCEPT - { - argCount = argCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV && setArgCount( uint32_t argCount_ ) && VULKAN_HPP_NOEXCEPT - { - argCount = argCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV & setArgData( StridedDeviceAddressNV const & argData_ ) & VULKAN_HPP_NOEXCEPT - { - argData = argData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureIndirectCommandNV && setArgData( StridedDeviceAddressNV const & argData_ ) && - VULKAN_HPP_NOEXCEPT - { - argData = argData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBuildPartitionedAccelerationStructureIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBuildPartitionedAccelerationStructureIndirectCommandNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBuildPartitionedAccelerationStructureIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBuildPartitionedAccelerationStructureIndirectCommandNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( opType, argCount, argData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BuildPartitionedAccelerationStructureIndirectCommandNV const & ) const = default; -#else - bool operator==( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( opType == rhs.opType ) && ( argCount == rhs.argCount ) && ( argData == rhs.argData ); -# endif - } - - bool operator!=( BuildPartitionedAccelerationStructureIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - PartitionedAccelerationStructureOpTypeNV opType = PartitionedAccelerationStructureOpTypeNV::eWriteInstance; - uint32_t argCount = {}; - StridedDeviceAddressNV argData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BuildPartitionedAccelerationStructureIndirectCommandNV; - }; -#endif - - // wrapper struct for struct VkPartitionedAccelerationStructureInstancesInputNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureInstancesInputNV.html - struct PartitionedAccelerationStructureInstancesInputNV - { - using NativeType = VkPartitionedAccelerationStructureInstancesInputNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePartitionedAccelerationStructureInstancesInputNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PartitionedAccelerationStructureInstancesInputNV( BuildAccelerationStructureFlagsKHR flags_ = {}, - uint32_t instanceCount_ = {}, - uint32_t maxInstancePerPartitionCount_ = {}, - uint32_t partitionCount_ = {}, - uint32_t maxInstanceInGlobalPartitionCount_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , instanceCount{ instanceCount_ } - , maxInstancePerPartitionCount{ maxInstancePerPartitionCount_ } - , partitionCount{ partitionCount_ } - , maxInstanceInGlobalPartitionCount{ maxInstanceInGlobalPartitionCount_ } - { - } - - VULKAN_HPP_CONSTEXPR - PartitionedAccelerationStructureInstancesInputNV( PartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PartitionedAccelerationStructureInstancesInputNV( VkPartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PartitionedAccelerationStructureInstancesInputNV( *reinterpret_cast( &rhs ) ) - { - } - - PartitionedAccelerationStructureInstancesInputNV & operator=( PartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PartitionedAccelerationStructureInstancesInputNV & operator=( VkPartitionedAccelerationStructureInstancesInputNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setFlags( BuildAccelerationStructureFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setFlags( BuildAccelerationStructureFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setInstanceCount( uint32_t instanceCount_ ) & VULKAN_HPP_NOEXCEPT - { - instanceCount = instanceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setInstanceCount( uint32_t instanceCount_ ) && VULKAN_HPP_NOEXCEPT - { - instanceCount = instanceCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setMaxInstancePerPartitionCount( uint32_t maxInstancePerPartitionCount_ ) & - VULKAN_HPP_NOEXCEPT - { - maxInstancePerPartitionCount = maxInstancePerPartitionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setMaxInstancePerPartitionCount( uint32_t maxInstancePerPartitionCount_ ) && - VULKAN_HPP_NOEXCEPT - { - maxInstancePerPartitionCount = maxInstancePerPartitionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & setPartitionCount( uint32_t partitionCount_ ) & VULKAN_HPP_NOEXCEPT - { - partitionCount = partitionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && setPartitionCount( uint32_t partitionCount_ ) && VULKAN_HPP_NOEXCEPT - { - partitionCount = partitionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV & - setMaxInstanceInGlobalPartitionCount( uint32_t maxInstanceInGlobalPartitionCount_ ) & - VULKAN_HPP_NOEXCEPT - { - maxInstanceInGlobalPartitionCount = maxInstanceInGlobalPartitionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureInstancesInputNV && - setMaxInstanceInGlobalPartitionCount( uint32_t maxInstanceInGlobalPartitionCount_ ) && - VULKAN_HPP_NOEXCEPT - { - maxInstanceInGlobalPartitionCount = maxInstanceInGlobalPartitionCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPartitionedAccelerationStructureInstancesInputNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureInstancesInputNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureInstancesInputNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureInstancesInputNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, instanceCount, maxInstancePerPartitionCount, partitionCount, maxInstanceInGlobalPartitionCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PartitionedAccelerationStructureInstancesInputNV const & ) const = default; -#else - bool operator==( PartitionedAccelerationStructureInstancesInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( instanceCount == rhs.instanceCount ) && - ( maxInstancePerPartitionCount == rhs.maxInstancePerPartitionCount ) && ( partitionCount == rhs.partitionCount ) && - ( maxInstanceInGlobalPartitionCount == rhs.maxInstanceInGlobalPartitionCount ); -# endif - } - - bool operator!=( PartitionedAccelerationStructureInstancesInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePartitionedAccelerationStructureInstancesInputNV; - void * pNext = {}; - BuildAccelerationStructureFlagsKHR flags = {}; - uint32_t instanceCount = {}; - uint32_t maxInstancePerPartitionCount = {}; - uint32_t partitionCount = {}; - uint32_t maxInstanceInGlobalPartitionCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PartitionedAccelerationStructureInstancesInputNV; - }; -#endif - - template <> - struct CppType - { - using Type = PartitionedAccelerationStructureInstancesInputNV; - }; - - // wrapper struct for struct VkBuildPartitionedAccelerationStructureInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkBuildPartitionedAccelerationStructureInfoNV.html - struct BuildPartitionedAccelerationStructureInfoNV - { - using NativeType = VkBuildPartitionedAccelerationStructureInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eBuildPartitionedAccelerationStructureInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureInfoNV( PartitionedAccelerationStructureInstancesInputNV input_ = {}, - DeviceAddress srcAccelerationStructureData_ = {}, - DeviceAddress dstAccelerationStructureData_ = {}, - DeviceAddress scratchData_ = {}, - DeviceAddress srcInfos_ = {}, - DeviceAddress srcInfosCount_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , input{ input_ } - , srcAccelerationStructureData{ srcAccelerationStructureData_ } - , dstAccelerationStructureData{ dstAccelerationStructureData_ } - , scratchData{ scratchData_ } - , srcInfos{ srcInfos_ } - , srcInfosCount{ srcInfosCount_ } - { - } - - VULKAN_HPP_CONSTEXPR BuildPartitionedAccelerationStructureInfoNV( BuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - BuildPartitionedAccelerationStructureInfoNV( VkBuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : BuildPartitionedAccelerationStructureInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - BuildPartitionedAccelerationStructureInfoNV & operator=( BuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - BuildPartitionedAccelerationStructureInfoNV & operator=( VkBuildPartitionedAccelerationStructureInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setInput( PartitionedAccelerationStructureInstancesInputNV const & input_ ) & - VULKAN_HPP_NOEXCEPT - { - input = input_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setInput( PartitionedAccelerationStructureInstancesInputNV const & input_ ) && - VULKAN_HPP_NOEXCEPT - { - input = input_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setSrcAccelerationStructureData( DeviceAddress srcAccelerationStructureData_ ) & - VULKAN_HPP_NOEXCEPT - { - srcAccelerationStructureData = srcAccelerationStructureData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setSrcAccelerationStructureData( DeviceAddress srcAccelerationStructureData_ ) && - VULKAN_HPP_NOEXCEPT - { - srcAccelerationStructureData = srcAccelerationStructureData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setDstAccelerationStructureData( DeviceAddress dstAccelerationStructureData_ ) & - VULKAN_HPP_NOEXCEPT - { - dstAccelerationStructureData = dstAccelerationStructureData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setDstAccelerationStructureData( DeviceAddress dstAccelerationStructureData_ ) && - VULKAN_HPP_NOEXCEPT - { - dstAccelerationStructureData = dstAccelerationStructureData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setScratchData( DeviceAddress scratchData_ ) & VULKAN_HPP_NOEXCEPT - { - scratchData = scratchData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setScratchData( DeviceAddress scratchData_ ) && VULKAN_HPP_NOEXCEPT - { - scratchData = scratchData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setSrcInfos( DeviceAddress srcInfos_ ) & VULKAN_HPP_NOEXCEPT - { - srcInfos = srcInfos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setSrcInfos( DeviceAddress srcInfos_ ) && VULKAN_HPP_NOEXCEPT - { - srcInfos = srcInfos_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV & setSrcInfosCount( DeviceAddress srcInfosCount_ ) & VULKAN_HPP_NOEXCEPT - { - srcInfosCount = srcInfosCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 BuildPartitionedAccelerationStructureInfoNV && setSrcInfosCount( DeviceAddress srcInfosCount_ ) && VULKAN_HPP_NOEXCEPT - { - srcInfosCount = srcInfosCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkBuildPartitionedAccelerationStructureInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBuildPartitionedAccelerationStructureInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkBuildPartitionedAccelerationStructureInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkBuildPartitionedAccelerationStructureInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, input, srcAccelerationStructureData, dstAccelerationStructureData, scratchData, srcInfos, srcInfosCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( BuildPartitionedAccelerationStructureInfoNV const & ) const = default; -#else - bool operator==( BuildPartitionedAccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( input == rhs.input ) && - ( srcAccelerationStructureData == rhs.srcAccelerationStructureData ) && ( dstAccelerationStructureData == rhs.dstAccelerationStructureData ) && - ( scratchData == rhs.scratchData ) && ( srcInfos == rhs.srcInfos ) && ( srcInfosCount == rhs.srcInfosCount ); -# endif - } - - bool operator!=( BuildPartitionedAccelerationStructureInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eBuildPartitionedAccelerationStructureInfoNV; - void * pNext = {}; - PartitionedAccelerationStructureInstancesInputNV input = {}; - DeviceAddress srcAccelerationStructureData = {}; - DeviceAddress dstAccelerationStructureData = {}; - DeviceAddress scratchData = {}; - DeviceAddress srcInfos = {}; - DeviceAddress srcInfosCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = BuildPartitionedAccelerationStructureInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = BuildPartitionedAccelerationStructureInfoNV; - }; - - // wrapper struct for struct VkCalibratedTimestampInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCalibratedTimestampInfoKHR.html - struct CalibratedTimestampInfoKHR - { - using NativeType = VkCalibratedTimestampInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCalibratedTimestampInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoKHR( TimeDomainKHR timeDomain_ = TimeDomainKHR::eDevice, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , timeDomain{ timeDomain_ } - { - } - - VULKAN_HPP_CONSTEXPR CalibratedTimestampInfoKHR( CalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CalibratedTimestampInfoKHR( VkCalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : CalibratedTimestampInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - CalibratedTimestampInfoKHR & operator=( CalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CalibratedTimestampInfoKHR & operator=( VkCalibratedTimestampInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR & setTimeDomain( TimeDomainKHR timeDomain_ ) & VULKAN_HPP_NOEXCEPT - { - timeDomain = timeDomain_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CalibratedTimestampInfoKHR && setTimeDomain( TimeDomainKHR timeDomain_ ) && VULKAN_HPP_NOEXCEPT - { - timeDomain = timeDomain_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCalibratedTimestampInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCalibratedTimestampInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCalibratedTimestampInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCalibratedTimestampInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, timeDomain ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CalibratedTimestampInfoKHR const & ) const = default; -#else - bool operator==( CalibratedTimestampInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomain == rhs.timeDomain ); -# endif - } - - bool operator!=( CalibratedTimestampInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCalibratedTimestampInfoKHR; - const void * pNext = {}; - TimeDomainKHR timeDomain = TimeDomainKHR::eDevice; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CalibratedTimestampInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = CalibratedTimestampInfoKHR; - }; - - using CalibratedTimestampInfoEXT = CalibratedTimestampInfoKHR; - - // wrapper struct for struct VkCheckpointData2NV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCheckpointData2NV.html - struct CheckpointData2NV - { - using NativeType = VkCheckpointData2NV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCheckpointData2NV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CheckpointData2NV( PipelineStageFlags2 stage_ = {}, void * pCheckpointMarker_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stage{ stage_ } - , pCheckpointMarker{ pCheckpointMarker_ } - { - } - - VULKAN_HPP_CONSTEXPR CheckpointData2NV( CheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CheckpointData2NV( VkCheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT : CheckpointData2NV( *reinterpret_cast( &rhs ) ) {} - - CheckpointData2NV & operator=( CheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CheckpointData2NV & operator=( VkCheckpointData2NV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkCheckpointData2NV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCheckpointData2NV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCheckpointData2NV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCheckpointData2NV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stage, pCheckpointMarker ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CheckpointData2NV const & ) const = default; -#else - bool operator==( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && ( pCheckpointMarker == rhs.pCheckpointMarker ); -# endif - } - - bool operator!=( CheckpointData2NV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCheckpointData2NV; - void * pNext = {}; - PipelineStageFlags2 stage = {}; - void * pCheckpointMarker = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CheckpointData2NV; - }; -#endif - - template <> - struct CppType - { - using Type = CheckpointData2NV; - }; - - // wrapper struct for struct VkCheckpointDataNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCheckpointDataNV.html - struct CheckpointDataNV - { - using NativeType = VkCheckpointDataNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCheckpointDataNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CheckpointDataNV( PipelineStageFlagBits stage_ = PipelineStageFlagBits::eTopOfPipe, - void * pCheckpointMarker_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stage{ stage_ } - , pCheckpointMarker{ pCheckpointMarker_ } - { - } - - VULKAN_HPP_CONSTEXPR CheckpointDataNV( CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CheckpointDataNV( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT : CheckpointDataNV( *reinterpret_cast( &rhs ) ) {} - - CheckpointDataNV & operator=( CheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CheckpointDataNV & operator=( VkCheckpointDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkCheckpointDataNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCheckpointDataNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCheckpointDataNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCheckpointDataNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stage, pCheckpointMarker ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CheckpointDataNV const & ) const = default; -#else - bool operator==( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stage == rhs.stage ) && ( pCheckpointMarker == rhs.pCheckpointMarker ); -# endif - } - - bool operator!=( CheckpointDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCheckpointDataNV; - void * pNext = {}; - PipelineStageFlagBits stage = PipelineStageFlagBits::eTopOfPipe; - void * pCheckpointMarker = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CheckpointDataNV; - }; -#endif - - template <> - struct CppType - { - using Type = CheckpointDataNV; - }; - - union ClearColorValue - { - using NativeType = VkClearColorValue; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 ClearColorValue( const std::array & float32_ = {} ) : float32( float32_ ) {} - - VULKAN_HPP_CONSTEXPR ClearColorValue( float float32_0, float float32_1, float float32_2, float float32_3 ) - : float32{ { { float32_0, float32_1, float32_2, float32_3 } } } - { - } - - VULKAN_HPP_CONSTEXPR_14 ClearColorValue( const std::array & int32_ ) : int32( int32_ ) {} - - VULKAN_HPP_CONSTEXPR ClearColorValue( int32_t int32_0, int32_t int32_1, int32_t int32_2, int32_t int32_3 ) - : int32{ { { int32_0, int32_1, int32_2, int32_3 } } } - { - } - - VULKAN_HPP_CONSTEXPR_14 ClearColorValue( const std::array & uint32_ ) : uint32( uint32_ ) {} - - VULKAN_HPP_CONSTEXPR ClearColorValue( uint32_t uint32_0, uint32_t uint32_1, uint32_t uint32_2, uint32_t uint32_3 ) - : uint32{ { { uint32_0, uint32_1, uint32_2, uint32_3 } } } - { - } -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClearColorValue & setFloat32( std::array float32_ ) & VULKAN_HPP_NOEXCEPT - { - float32 = float32_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearColorValue && setFloat32( std::array float32_ ) && VULKAN_HPP_NOEXCEPT - { - float32 = float32_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClearColorValue & setInt32( std::array int32_ ) & VULKAN_HPP_NOEXCEPT - { - int32 = int32_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearColorValue && setInt32( std::array int32_ ) && VULKAN_HPP_NOEXCEPT - { - int32 = int32_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClearColorValue & setUint32( std::array uint32_ ) & VULKAN_HPP_NOEXCEPT - { - uint32 = uint32_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearColorValue && setUint32( std::array uint32_ ) && VULKAN_HPP_NOEXCEPT - { - uint32 = uint32_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClearColorValue const &() const - { - return *reinterpret_cast( this ); - } - - operator VkClearColorValue &() - { - return *reinterpret_cast( this ); - } - - ArrayWrapper1D float32; - ArrayWrapper1D int32; - ArrayWrapper1D uint32; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClearColorValue; - }; -#endif - - // wrapper struct for struct VkClearDepthStencilValue, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkClearDepthStencilValue.html - struct ClearDepthStencilValue - { - using NativeType = VkClearDepthStencilValue; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ClearDepthStencilValue( float depth_ = {}, uint32_t stencil_ = {} ) VULKAN_HPP_NOEXCEPT - : depth{ depth_ } - , stencil{ stencil_ } - { - } - - VULKAN_HPP_CONSTEXPR ClearDepthStencilValue( ClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ClearDepthStencilValue( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT - : ClearDepthStencilValue( *reinterpret_cast( &rhs ) ) - { - } - - ClearDepthStencilValue & operator=( ClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClearDepthStencilValue & operator=( VkClearDepthStencilValue const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue & setDepth( float depth_ ) & VULKAN_HPP_NOEXCEPT - { - depth = depth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue && setDepth( float depth_ ) && VULKAN_HPP_NOEXCEPT - { - depth = depth_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue & setStencil( uint32_t stencil_ ) & VULKAN_HPP_NOEXCEPT - { - stencil = stencil_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearDepthStencilValue && setStencil( uint32_t stencil_ ) && VULKAN_HPP_NOEXCEPT - { - stencil = stencil_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClearDepthStencilValue const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClearDepthStencilValue &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClearDepthStencilValue const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClearDepthStencilValue *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( depth, stencil ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClearDepthStencilValue const & ) const = default; -#else - bool operator==( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( depth == rhs.depth ) && ( stencil == rhs.stencil ); -# endif - } - - bool operator!=( ClearDepthStencilValue const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - float depth = {}; - uint32_t stencil = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClearDepthStencilValue; - }; -#endif - - union ClearValue - { - using NativeType = VkClearValue; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 ClearValue( ClearColorValue color_ = {} ) : color( color_ ) {} - - VULKAN_HPP_CONSTEXPR_14 ClearValue( ClearDepthStencilValue depthStencil_ ) : depthStencil( depthStencil_ ) {} -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClearValue & setColor( ClearColorValue const & color_ ) & VULKAN_HPP_NOEXCEPT - { - color = color_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearValue && setColor( ClearColorValue const & color_ ) && VULKAN_HPP_NOEXCEPT - { - color = color_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClearValue & setDepthStencil( ClearDepthStencilValue const & depthStencil_ ) & VULKAN_HPP_NOEXCEPT - { - depthStencil = depthStencil_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearValue && setDepthStencil( ClearDepthStencilValue const & depthStencil_ ) && VULKAN_HPP_NOEXCEPT - { - depthStencil = depthStencil_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClearValue const &() const - { - return *reinterpret_cast( this ); - } - - operator VkClearValue &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - ClearColorValue color; - ClearDepthStencilValue depthStencil; -#else - VkClearColorValue color; - VkClearDepthStencilValue depthStencil; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClearValue; - }; -#endif - - // wrapper struct for struct VkClearAttachment, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkClearAttachment.html - struct ClearAttachment - { - using NativeType = VkClearAttachment; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - ClearAttachment( ImageAspectFlags aspectMask_ = {}, uint32_t colorAttachment_ = {}, ClearValue clearValue_ = {} ) VULKAN_HPP_NOEXCEPT - : aspectMask{ aspectMask_ } - , colorAttachment{ colorAttachment_ } - , clearValue{ clearValue_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 ClearAttachment( ClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ClearAttachment( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT : ClearAttachment( *reinterpret_cast( &rhs ) ) {} - - ClearAttachment & operator=( ClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClearAttachment & operator=( VkClearAttachment const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClearAttachment & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearAttachment && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClearAttachment & setColorAttachment( uint32_t colorAttachment_ ) & VULKAN_HPP_NOEXCEPT - { - colorAttachment = colorAttachment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearAttachment && setColorAttachment( uint32_t colorAttachment_ ) && VULKAN_HPP_NOEXCEPT - { - colorAttachment = colorAttachment_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClearAttachment & setClearValue( ClearValue const & clearValue_ ) & VULKAN_HPP_NOEXCEPT - { - clearValue = clearValue_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearAttachment && setClearValue( ClearValue const & clearValue_ ) && VULKAN_HPP_NOEXCEPT - { - clearValue = clearValue_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClearAttachment const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClearAttachment &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClearAttachment const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClearAttachment *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( aspectMask, colorAttachment, clearValue ); - } -#endif - - public: - ImageAspectFlags aspectMask = {}; - uint32_t colorAttachment = {}; - ClearValue clearValue = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClearAttachment; - }; -#endif - - // wrapper struct for struct VkClearRect, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkClearRect.html - struct ClearRect - { - using NativeType = VkClearRect; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ClearRect( Rect2D rect_ = {}, uint32_t baseArrayLayer_ = {}, uint32_t layerCount_ = {} ) VULKAN_HPP_NOEXCEPT - : rect{ rect_ } - , baseArrayLayer{ baseArrayLayer_ } - , layerCount{ layerCount_ } - { - } - - VULKAN_HPP_CONSTEXPR ClearRect( ClearRect const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ClearRect( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT : ClearRect( *reinterpret_cast( &rhs ) ) {} - - ClearRect & operator=( ClearRect const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClearRect & operator=( VkClearRect const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClearRect & setRect( Rect2D const & rect_ ) & VULKAN_HPP_NOEXCEPT - { - rect = rect_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearRect && setRect( Rect2D const & rect_ ) && VULKAN_HPP_NOEXCEPT - { - rect = rect_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClearRect & setBaseArrayLayer( uint32_t baseArrayLayer_ ) & VULKAN_HPP_NOEXCEPT - { - baseArrayLayer = baseArrayLayer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearRect && setBaseArrayLayer( uint32_t baseArrayLayer_ ) && VULKAN_HPP_NOEXCEPT - { - baseArrayLayer = baseArrayLayer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClearRect & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClearRect && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClearRect const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClearRect &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClearRect const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClearRect *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( rect, baseArrayLayer, layerCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClearRect const & ) const = default; -#else - bool operator==( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( rect == rhs.rect ) && ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); -# endif - } - - bool operator!=( ClearRect const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Rect2D rect = {}; - uint32_t baseArrayLayer = {}; - uint32_t layerCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClearRect; - }; -#endif - - // wrapper struct for struct VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV.html - struct ClusterAccelerationStructureBuildClustersBottomLevelInfoNV - { - using NativeType = VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildClustersBottomLevelInfoNV( uint32_t clusterReferencesCount_ = {}, - uint32_t clusterReferencesStride_ = {}, - DeviceAddress clusterReferences_ = {} ) VULKAN_HPP_NOEXCEPT - : clusterReferencesCount{ clusterReferencesCount_ } - , clusterReferencesStride{ clusterReferencesStride_ } - , clusterReferences{ clusterReferences_ } - { - } - - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildClustersBottomLevelInfoNV( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureBuildClustersBottomLevelInfoNV( VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureBuildClustersBottomLevelInfoNV( - *reinterpret_cast( &rhs ) ) - { - } - - ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & - operator=( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & - operator=( VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & setClusterReferencesCount( uint32_t clusterReferencesCount_ ) & - VULKAN_HPP_NOEXCEPT - { - clusterReferencesCount = clusterReferencesCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV && setClusterReferencesCount( uint32_t clusterReferencesCount_ ) && - VULKAN_HPP_NOEXCEPT - { - clusterReferencesCount = clusterReferencesCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & setClusterReferencesStride( uint32_t clusterReferencesStride_ ) & - VULKAN_HPP_NOEXCEPT - { - clusterReferencesStride = clusterReferencesStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV && setClusterReferencesStride( uint32_t clusterReferencesStride_ ) && - VULKAN_HPP_NOEXCEPT - { - clusterReferencesStride = clusterReferencesStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV & setClusterReferences( DeviceAddress clusterReferences_ ) & - VULKAN_HPP_NOEXCEPT - { - clusterReferences = clusterReferences_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildClustersBottomLevelInfoNV && setClusterReferences( DeviceAddress clusterReferences_ ) && - VULKAN_HPP_NOEXCEPT - { - clusterReferences = clusterReferences_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( clusterReferencesCount, clusterReferencesStride, clusterReferences ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & ) const = default; -#else - bool operator==( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( clusterReferencesCount == rhs.clusterReferencesCount ) && ( clusterReferencesStride == rhs.clusterReferencesStride ) && - ( clusterReferences == rhs.clusterReferences ); -# endif - } - - bool operator!=( ClusterAccelerationStructureBuildClustersBottomLevelInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t clusterReferencesCount = {}; - uint32_t clusterReferencesStride = {}; - DeviceAddress clusterReferences = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureBuildClustersBottomLevelInfoNV; - }; -#endif - - // wrapper struct for struct VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.html - struct ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV - { - using NativeType = VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV( uint32_t geometryIndex_ = {}, - uint32_t reserved_ = {}, - uint32_t geometryFlags_ = {} ) VULKAN_HPP_NOEXCEPT - : geometryIndex{ geometryIndex_ } - , reserved{ reserved_ } - , geometryFlags{ geometryFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV( VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV( - *reinterpret_cast( &rhs ) ) - { - } - - ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & - operator=( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & - operator=( VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & setGeometryIndex( uint32_t geometryIndex_ ) & VULKAN_HPP_NOEXCEPT - { - geometryIndex = geometryIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV && setGeometryIndex( uint32_t geometryIndex_ ) && VULKAN_HPP_NOEXCEPT - { - geometryIndex = geometryIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & setReserved( uint32_t reserved_ ) & VULKAN_HPP_NOEXCEPT - { - reserved = reserved_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV && setReserved( uint32_t reserved_ ) && VULKAN_HPP_NOEXCEPT - { - reserved = reserved_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV & setGeometryFlags( uint32_t geometryFlags_ ) & VULKAN_HPP_NOEXCEPT - { - geometryFlags = geometryFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV && setGeometryFlags( uint32_t geometryFlags_ ) && VULKAN_HPP_NOEXCEPT - { - geometryFlags = geometryFlags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( geometryIndex, reserved, geometryFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & ) const = default; -#else - bool operator==( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( geometryIndex == rhs.geometryIndex ) && ( reserved == rhs.reserved ) && ( geometryFlags == rhs.geometryFlags ); -# endif - } - - bool operator!=( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t geometryIndex : 24; - uint32_t reserved : 5; - uint32_t geometryFlags : 3; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV; - }; -#endif - - // wrapper struct for struct VkClusterAccelerationStructureBuildTriangleClusterInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildTriangleClusterInfoNV.html - struct ClusterAccelerationStructureBuildTriangleClusterInfoNV - { - using NativeType = VkClusterAccelerationStructureBuildTriangleClusterInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterInfoNV( - uint32_t clusterID_ = {}, - ClusterAccelerationStructureClusterFlagsNV clusterFlags_ = {}, - uint32_t triangleCount_ = {}, - uint32_t vertexCount_ = {}, - uint32_t positionTruncateBitCount_ = {}, - uint32_t indexType_ = {}, - uint32_t opacityMicromapIndexType_ = {}, - ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags_ = {}, - uint16_t indexBufferStride_ = {}, - uint16_t vertexBufferStride_ = {}, - uint16_t geometryIndexAndFlagsBufferStride_ = {}, - uint16_t opacityMicromapIndexBufferStride_ = {}, - DeviceAddress indexBuffer_ = {}, - DeviceAddress vertexBuffer_ = {}, - DeviceAddress geometryIndexAndFlagsBuffer_ = {}, - DeviceAddress opacityMicromapArray_ = {}, - DeviceAddress opacityMicromapIndexBuffer_ = {} ) VULKAN_HPP_NOEXCEPT - : clusterID{ clusterID_ } - , clusterFlags{ clusterFlags_ } - , triangleCount{ triangleCount_ } - , vertexCount{ vertexCount_ } - , positionTruncateBitCount{ positionTruncateBitCount_ } - , indexType{ indexType_ } - , opacityMicromapIndexType{ opacityMicromapIndexType_ } - , baseGeometryIndexAndGeometryFlags{ baseGeometryIndexAndGeometryFlags_ } - , indexBufferStride{ indexBufferStride_ } - , vertexBufferStride{ vertexBufferStride_ } - , geometryIndexAndFlagsBufferStride{ geometryIndexAndFlagsBufferStride_ } - , opacityMicromapIndexBufferStride{ opacityMicromapIndexBufferStride_ } - , indexBuffer{ indexBuffer_ } - , vertexBuffer{ vertexBuffer_ } - , geometryIndexAndFlagsBuffer{ geometryIndexAndFlagsBuffer_ } - , opacityMicromapArray{ opacityMicromapArray_ } - , opacityMicromapIndexBuffer{ opacityMicromapIndexBuffer_ } - { - } - - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterInfoNV( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureBuildTriangleClusterInfoNV( VkClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureBuildTriangleClusterInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ClusterAccelerationStructureBuildTriangleClusterInfoNV & - operator=( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureBuildTriangleClusterInfoNV & - operator=( VkClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setClusterID( uint32_t clusterID_ ) & VULKAN_HPP_NOEXCEPT - { - clusterID = clusterID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setClusterID( uint32_t clusterID_ ) && VULKAN_HPP_NOEXCEPT - { - clusterID = clusterID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & - setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) & - VULKAN_HPP_NOEXCEPT - { - clusterFlags = clusterFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && - setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) && - VULKAN_HPP_NOEXCEPT - { - clusterFlags = clusterFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setTriangleCount( uint32_t triangleCount_ ) & VULKAN_HPP_NOEXCEPT - { - triangleCount = triangleCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setTriangleCount( uint32_t triangleCount_ ) && VULKAN_HPP_NOEXCEPT - { - triangleCount = triangleCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT - { - vertexCount = vertexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT - { - vertexCount = vertexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) & - VULKAN_HPP_NOEXCEPT - { - positionTruncateBitCount = positionTruncateBitCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) && - VULKAN_HPP_NOEXCEPT - { - positionTruncateBitCount = positionTruncateBitCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setIndexType( uint32_t indexType_ ) & VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setIndexType( uint32_t indexType_ ) && VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) & - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexType = opacityMicromapIndexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) && - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexType = opacityMicromapIndexType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & - setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) & - VULKAN_HPP_NOEXCEPT - { - baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && - setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) && - VULKAN_HPP_NOEXCEPT - { - baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setIndexBufferStride( uint16_t indexBufferStride_ ) & VULKAN_HPP_NOEXCEPT - { - indexBufferStride = indexBufferStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setIndexBufferStride( uint16_t indexBufferStride_ ) && VULKAN_HPP_NOEXCEPT - { - indexBufferStride = indexBufferStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setVertexBufferStride( uint16_t vertexBufferStride_ ) & VULKAN_HPP_NOEXCEPT - { - vertexBufferStride = vertexBufferStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setVertexBufferStride( uint16_t vertexBufferStride_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexBufferStride = vertexBufferStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & - setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) & - VULKAN_HPP_NOEXCEPT - { - geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && - setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) && - VULKAN_HPP_NOEXCEPT - { - geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & - setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) & - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && - setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) && - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setIndexBuffer( DeviceAddress indexBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - indexBuffer = indexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setIndexBuffer( DeviceAddress indexBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - indexBuffer = indexBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setVertexBuffer( DeviceAddress vertexBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - vertexBuffer = vertexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setVertexBuffer( DeviceAddress vertexBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - vertexBuffer = vertexBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & - setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) & - VULKAN_HPP_NOEXCEPT - { - geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && - setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) & - VULKAN_HPP_NOEXCEPT - { - opacityMicromapArray = opacityMicromapArray_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) && - VULKAN_HPP_NOEXCEPT - { - opacityMicromapArray = opacityMicromapArray_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV & - setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) & - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterInfoNV && - setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureBuildTriangleClusterInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( clusterID, - clusterFlags, - triangleCount, - vertexCount, - positionTruncateBitCount, - indexType, - opacityMicromapIndexType, - baseGeometryIndexAndGeometryFlags, - indexBufferStride, - vertexBufferStride, - geometryIndexAndFlagsBufferStride, - opacityMicromapIndexBufferStride, - indexBuffer, - vertexBuffer, - geometryIndexAndFlagsBuffer, - opacityMicromapArray, - opacityMicromapIndexBuffer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & ) const = default; -#else - bool operator==( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( clusterID == rhs.clusterID ) && ( clusterFlags == rhs.clusterFlags ) && ( triangleCount == rhs.triangleCount ) && - ( vertexCount == rhs.vertexCount ) && ( positionTruncateBitCount == rhs.positionTruncateBitCount ) && ( indexType == rhs.indexType ) && - ( opacityMicromapIndexType == rhs.opacityMicromapIndexType ) && ( baseGeometryIndexAndGeometryFlags == rhs.baseGeometryIndexAndGeometryFlags ) && - ( indexBufferStride == rhs.indexBufferStride ) && ( vertexBufferStride == rhs.vertexBufferStride ) && - ( geometryIndexAndFlagsBufferStride == rhs.geometryIndexAndFlagsBufferStride ) && - ( opacityMicromapIndexBufferStride == rhs.opacityMicromapIndexBufferStride ) && ( indexBuffer == rhs.indexBuffer ) && - ( vertexBuffer == rhs.vertexBuffer ) && ( geometryIndexAndFlagsBuffer == rhs.geometryIndexAndFlagsBuffer ) && - ( opacityMicromapArray == rhs.opacityMicromapArray ) && ( opacityMicromapIndexBuffer == rhs.opacityMicromapIndexBuffer ); -# endif - } - - bool operator!=( ClusterAccelerationStructureBuildTriangleClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t clusterID = {}; - ClusterAccelerationStructureClusterFlagsNV clusterFlags = {}; - uint32_t triangleCount : 9; - uint32_t vertexCount : 9; - uint32_t positionTruncateBitCount : 6; - uint32_t indexType : 4; - uint32_t opacityMicromapIndexType : 4; - ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags = {}; - uint16_t indexBufferStride = {}; - uint16_t vertexBufferStride = {}; - uint16_t geometryIndexAndFlagsBufferStride = {}; - uint16_t opacityMicromapIndexBufferStride = {}; - DeviceAddress indexBuffer = {}; - DeviceAddress vertexBuffer = {}; - DeviceAddress geometryIndexAndFlagsBuffer = {}; - DeviceAddress opacityMicromapArray = {}; - DeviceAddress opacityMicromapIndexBuffer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureBuildTriangleClusterInfoNV; - }; -#endif - - // wrapper struct for struct VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.html - struct ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV - { - using NativeType = VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV( - uint32_t clusterID_ = {}, - ClusterAccelerationStructureClusterFlagsNV clusterFlags_ = {}, - uint32_t triangleCount_ = {}, - uint32_t vertexCount_ = {}, - uint32_t positionTruncateBitCount_ = {}, - uint32_t indexType_ = {}, - uint32_t opacityMicromapIndexType_ = {}, - ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags_ = {}, - uint16_t indexBufferStride_ = {}, - uint16_t vertexBufferStride_ = {}, - uint16_t geometryIndexAndFlagsBufferStride_ = {}, - uint16_t opacityMicromapIndexBufferStride_ = {}, - DeviceAddress indexBuffer_ = {}, - DeviceAddress vertexBuffer_ = {}, - DeviceAddress geometryIndexAndFlagsBuffer_ = {}, - DeviceAddress opacityMicromapArray_ = {}, - DeviceAddress opacityMicromapIndexBuffer_ = {}, - DeviceAddress instantiationBoundingBoxLimit_ = {} ) VULKAN_HPP_NOEXCEPT - : clusterID{ clusterID_ } - , clusterFlags{ clusterFlags_ } - , triangleCount{ triangleCount_ } - , vertexCount{ vertexCount_ } - , positionTruncateBitCount{ positionTruncateBitCount_ } - , indexType{ indexType_ } - , opacityMicromapIndexType{ opacityMicromapIndexType_ } - , baseGeometryIndexAndGeometryFlags{ baseGeometryIndexAndGeometryFlags_ } - , indexBufferStride{ indexBufferStride_ } - , vertexBufferStride{ vertexBufferStride_ } - , geometryIndexAndFlagsBufferStride{ geometryIndexAndFlagsBufferStride_ } - , opacityMicromapIndexBufferStride{ opacityMicromapIndexBufferStride_ } - , indexBuffer{ indexBuffer_ } - , vertexBuffer{ vertexBuffer_ } - , geometryIndexAndFlagsBuffer{ geometryIndexAndFlagsBuffer_ } - , opacityMicromapArray{ opacityMicromapArray_ } - , opacityMicromapIndexBuffer{ opacityMicromapIndexBuffer_ } - , instantiationBoundingBoxLimit{ instantiationBoundingBoxLimit_ } - { - } - - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV( - ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV( VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) - VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV( - *reinterpret_cast( &rhs ) ) - { - } - - explicit ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV( - ClusterAccelerationStructureBuildTriangleClusterInfoNV const & clusterAccelerationStructureBuildTriangleClusterInfoNV, - DeviceAddress instantiationBoundingBoxLimit_ = {} ) - : clusterID( clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterID ) - , clusterFlags( clusterAccelerationStructureBuildTriangleClusterInfoNV.clusterFlags ) - , triangleCount( clusterAccelerationStructureBuildTriangleClusterInfoNV.triangleCount ) - , vertexCount( clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexCount ) - , positionTruncateBitCount( clusterAccelerationStructureBuildTriangleClusterInfoNV.positionTruncateBitCount ) - , indexType( clusterAccelerationStructureBuildTriangleClusterInfoNV.indexType ) - , opacityMicromapIndexType( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexType ) - , baseGeometryIndexAndGeometryFlags( clusterAccelerationStructureBuildTriangleClusterInfoNV.baseGeometryIndexAndGeometryFlags ) - , indexBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBufferStride ) - , vertexBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBufferStride ) - , geometryIndexAndFlagsBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBufferStride ) - , opacityMicromapIndexBufferStride( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBufferStride ) - , indexBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.indexBuffer ) - , vertexBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.vertexBuffer ) - , geometryIndexAndFlagsBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.geometryIndexAndFlagsBuffer ) - , opacityMicromapArray( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapArray ) - , opacityMicromapIndexBuffer( clusterAccelerationStructureBuildTriangleClusterInfoNV.opacityMicromapIndexBuffer ) - , instantiationBoundingBoxLimit( instantiationBoundingBoxLimit_ ) - { - } - - ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & - operator=( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & - operator=( VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setClusterID( uint32_t clusterID_ ) & VULKAN_HPP_NOEXCEPT - { - clusterID = clusterID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setClusterID( uint32_t clusterID_ ) && VULKAN_HPP_NOEXCEPT - { - clusterID = clusterID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & - setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) & - VULKAN_HPP_NOEXCEPT - { - clusterFlags = clusterFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && - setClusterFlags( ClusterAccelerationStructureClusterFlagsNV clusterFlags_ ) && - VULKAN_HPP_NOEXCEPT - { - clusterFlags = clusterFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setTriangleCount( uint32_t triangleCount_ ) & VULKAN_HPP_NOEXCEPT - { - triangleCount = triangleCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setTriangleCount( uint32_t triangleCount_ ) && VULKAN_HPP_NOEXCEPT - { - triangleCount = triangleCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT - { - vertexCount = vertexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT - { - vertexCount = vertexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) & - VULKAN_HPP_NOEXCEPT - { - positionTruncateBitCount = positionTruncateBitCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && - setPositionTruncateBitCount( uint32_t positionTruncateBitCount_ ) && - VULKAN_HPP_NOEXCEPT - { - positionTruncateBitCount = positionTruncateBitCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setIndexType( uint32_t indexType_ ) & VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setIndexType( uint32_t indexType_ ) && VULKAN_HPP_NOEXCEPT - { - indexType = indexType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) & - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexType = opacityMicromapIndexType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && - setOpacityMicromapIndexType( uint32_t opacityMicromapIndexType_ ) && - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexType = opacityMicromapIndexType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & - setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) & - VULKAN_HPP_NOEXCEPT - { - baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && - setBaseGeometryIndexAndGeometryFlags( ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV const & baseGeometryIndexAndGeometryFlags_ ) && - VULKAN_HPP_NOEXCEPT - { - baseGeometryIndexAndGeometryFlags = baseGeometryIndexAndGeometryFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setIndexBufferStride( uint16_t indexBufferStride_ ) & - VULKAN_HPP_NOEXCEPT - { - indexBufferStride = indexBufferStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setIndexBufferStride( uint16_t indexBufferStride_ ) && - VULKAN_HPP_NOEXCEPT - { - indexBufferStride = indexBufferStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setVertexBufferStride( uint16_t vertexBufferStride_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexBufferStride = vertexBufferStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setVertexBufferStride( uint16_t vertexBufferStride_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexBufferStride = vertexBufferStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & - setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) & - VULKAN_HPP_NOEXCEPT - { - geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && - setGeometryIndexAndFlagsBufferStride( uint16_t geometryIndexAndFlagsBufferStride_ ) && - VULKAN_HPP_NOEXCEPT - { - geometryIndexAndFlagsBufferStride = geometryIndexAndFlagsBufferStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & - setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) & - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && - setOpacityMicromapIndexBufferStride( uint16_t opacityMicromapIndexBufferStride_ ) && - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexBufferStride = opacityMicromapIndexBufferStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setIndexBuffer( DeviceAddress indexBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - indexBuffer = indexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setIndexBuffer( DeviceAddress indexBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - indexBuffer = indexBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setVertexBuffer( DeviceAddress vertexBuffer_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexBuffer = vertexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setVertexBuffer( DeviceAddress vertexBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexBuffer = vertexBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & - setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) & - VULKAN_HPP_NOEXCEPT - { - geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && - setGeometryIndexAndFlagsBuffer( DeviceAddress geometryIndexAndFlagsBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - geometryIndexAndFlagsBuffer = geometryIndexAndFlagsBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) & - VULKAN_HPP_NOEXCEPT - { - opacityMicromapArray = opacityMicromapArray_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && setOpacityMicromapArray( DeviceAddress opacityMicromapArray_ ) && - VULKAN_HPP_NOEXCEPT - { - opacityMicromapArray = opacityMicromapArray_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & - setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) & - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && - setOpacityMicromapIndexBuffer( DeviceAddress opacityMicromapIndexBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - opacityMicromapIndexBuffer = opacityMicromapIndexBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV & - setInstantiationBoundingBoxLimit( DeviceAddress instantiationBoundingBoxLimit_ ) & - VULKAN_HPP_NOEXCEPT - { - instantiationBoundingBoxLimit = instantiationBoundingBoxLimit_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV && - setInstantiationBoundingBoxLimit( DeviceAddress instantiationBoundingBoxLimit_ ) && - VULKAN_HPP_NOEXCEPT - { - instantiationBoundingBoxLimit = instantiationBoundingBoxLimit_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( clusterID, - clusterFlags, - triangleCount, - vertexCount, - positionTruncateBitCount, - indexType, - opacityMicromapIndexType, - baseGeometryIndexAndGeometryFlags, - indexBufferStride, - vertexBufferStride, - geometryIndexAndFlagsBufferStride, - opacityMicromapIndexBufferStride, - indexBuffer, - vertexBuffer, - geometryIndexAndFlagsBuffer, - opacityMicromapArray, - opacityMicromapIndexBuffer, - instantiationBoundingBoxLimit ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & ) const = default; -#else - bool operator==( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( clusterID == rhs.clusterID ) && ( clusterFlags == rhs.clusterFlags ) && ( triangleCount == rhs.triangleCount ) && - ( vertexCount == rhs.vertexCount ) && ( positionTruncateBitCount == rhs.positionTruncateBitCount ) && ( indexType == rhs.indexType ) && - ( opacityMicromapIndexType == rhs.opacityMicromapIndexType ) && ( baseGeometryIndexAndGeometryFlags == rhs.baseGeometryIndexAndGeometryFlags ) && - ( indexBufferStride == rhs.indexBufferStride ) && ( vertexBufferStride == rhs.vertexBufferStride ) && - ( geometryIndexAndFlagsBufferStride == rhs.geometryIndexAndFlagsBufferStride ) && - ( opacityMicromapIndexBufferStride == rhs.opacityMicromapIndexBufferStride ) && ( indexBuffer == rhs.indexBuffer ) && - ( vertexBuffer == rhs.vertexBuffer ) && ( geometryIndexAndFlagsBuffer == rhs.geometryIndexAndFlagsBuffer ) && - ( opacityMicromapArray == rhs.opacityMicromapArray ) && ( opacityMicromapIndexBuffer == rhs.opacityMicromapIndexBuffer ) && - ( instantiationBoundingBoxLimit == rhs.instantiationBoundingBoxLimit ); -# endif - } - - bool operator!=( ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t clusterID = {}; - ClusterAccelerationStructureClusterFlagsNV clusterFlags = {}; - uint32_t triangleCount : 9; - uint32_t vertexCount : 9; - uint32_t positionTruncateBitCount : 6; - uint32_t indexType : 4; - uint32_t opacityMicromapIndexType : 4; - ClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV baseGeometryIndexAndGeometryFlags = {}; - uint16_t indexBufferStride = {}; - uint16_t vertexBufferStride = {}; - uint16_t geometryIndexAndFlagsBufferStride = {}; - uint16_t opacityMicromapIndexBufferStride = {}; - DeviceAddress indexBuffer = {}; - DeviceAddress vertexBuffer = {}; - DeviceAddress geometryIndexAndFlagsBuffer = {}; - DeviceAddress opacityMicromapArray = {}; - DeviceAddress opacityMicromapIndexBuffer = {}; - DeviceAddress instantiationBoundingBoxLimit = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV; - }; -#endif - - // wrapper struct for struct VkClusterAccelerationStructureClustersBottomLevelInputNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureClustersBottomLevelInputNV.html - struct ClusterAccelerationStructureClustersBottomLevelInputNV - { - using NativeType = VkClusterAccelerationStructureClustersBottomLevelInputNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eClusterAccelerationStructureClustersBottomLevelInputNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureClustersBottomLevelInputNV( uint32_t maxTotalClusterCount_ = {}, - uint32_t maxClusterCountPerAccelerationStructure_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxTotalClusterCount{ maxTotalClusterCount_ } - , maxClusterCountPerAccelerationStructure{ maxClusterCountPerAccelerationStructure_ } - { - } - - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureClustersBottomLevelInputNV( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureClustersBottomLevelInputNV( VkClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureClustersBottomLevelInputNV( *reinterpret_cast( &rhs ) ) - { - } - - ClusterAccelerationStructureClustersBottomLevelInputNV & - operator=( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureClustersBottomLevelInputNV & - operator=( VkClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV & setMaxTotalClusterCount( uint32_t maxTotalClusterCount_ ) & - VULKAN_HPP_NOEXCEPT - { - maxTotalClusterCount = maxTotalClusterCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV && setMaxTotalClusterCount( uint32_t maxTotalClusterCount_ ) && - VULKAN_HPP_NOEXCEPT - { - maxTotalClusterCount = maxTotalClusterCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV & - setMaxClusterCountPerAccelerationStructure( uint32_t maxClusterCountPerAccelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - maxClusterCountPerAccelerationStructure = maxClusterCountPerAccelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureClustersBottomLevelInputNV && - setMaxClusterCountPerAccelerationStructure( uint32_t maxClusterCountPerAccelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - maxClusterCountPerAccelerationStructure = maxClusterCountPerAccelerationStructure_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureClustersBottomLevelInputNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureClustersBottomLevelInputNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureClustersBottomLevelInputNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureClustersBottomLevelInputNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxTotalClusterCount, maxClusterCountPerAccelerationStructure ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClusterAccelerationStructureClustersBottomLevelInputNV const & ) const = default; -#else - bool operator==( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTotalClusterCount == rhs.maxTotalClusterCount ) && - ( maxClusterCountPerAccelerationStructure == rhs.maxClusterCountPerAccelerationStructure ); -# endif - } - - bool operator!=( ClusterAccelerationStructureClustersBottomLevelInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eClusterAccelerationStructureClustersBottomLevelInputNV; - void * pNext = {}; - uint32_t maxTotalClusterCount = {}; - uint32_t maxClusterCountPerAccelerationStructure = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureClustersBottomLevelInputNV; - }; -#endif - - template <> - struct CppType - { - using Type = ClusterAccelerationStructureClustersBottomLevelInputNV; - }; - - // wrapper struct for struct VkClusterAccelerationStructureTriangleClusterInputNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureTriangleClusterInputNV.html - struct ClusterAccelerationStructureTriangleClusterInputNV - { - using NativeType = VkClusterAccelerationStructureTriangleClusterInputNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eClusterAccelerationStructureTriangleClusterInputNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureTriangleClusterInputNV( Format vertexFormat_ = Format::eUndefined, - uint32_t maxGeometryIndexValue_ = {}, - uint32_t maxClusterUniqueGeometryCount_ = {}, - uint32_t maxClusterTriangleCount_ = {}, - uint32_t maxClusterVertexCount_ = {}, - uint32_t maxTotalTriangleCount_ = {}, - uint32_t maxTotalVertexCount_ = {}, - uint32_t minPositionTruncateBitCount_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vertexFormat{ vertexFormat_ } - , maxGeometryIndexValue{ maxGeometryIndexValue_ } - , maxClusterUniqueGeometryCount{ maxClusterUniqueGeometryCount_ } - , maxClusterTriangleCount{ maxClusterTriangleCount_ } - , maxClusterVertexCount{ maxClusterVertexCount_ } - , maxTotalTriangleCount{ maxTotalTriangleCount_ } - , maxTotalVertexCount{ maxTotalVertexCount_ } - , minPositionTruncateBitCount{ minPositionTruncateBitCount_ } - { - } - - VULKAN_HPP_CONSTEXPR - ClusterAccelerationStructureTriangleClusterInputNV( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureTriangleClusterInputNV( VkClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureTriangleClusterInputNV( *reinterpret_cast( &rhs ) ) - { - } - - ClusterAccelerationStructureTriangleClusterInputNV & - operator=( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureTriangleClusterInputNV & operator=( VkClusterAccelerationStructureTriangleClusterInputNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setVertexFormat( Format vertexFormat_ ) & VULKAN_HPP_NOEXCEPT - { - vertexFormat = vertexFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setVertexFormat( Format vertexFormat_ ) && VULKAN_HPP_NOEXCEPT - { - vertexFormat = vertexFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxGeometryIndexValue( uint32_t maxGeometryIndexValue_ ) & - VULKAN_HPP_NOEXCEPT - { - maxGeometryIndexValue = maxGeometryIndexValue_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxGeometryIndexValue( uint32_t maxGeometryIndexValue_ ) && - VULKAN_HPP_NOEXCEPT - { - maxGeometryIndexValue = maxGeometryIndexValue_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxClusterUniqueGeometryCount( uint32_t maxClusterUniqueGeometryCount_ ) & - VULKAN_HPP_NOEXCEPT - { - maxClusterUniqueGeometryCount = maxClusterUniqueGeometryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxClusterUniqueGeometryCount( uint32_t maxClusterUniqueGeometryCount_ ) && - VULKAN_HPP_NOEXCEPT - { - maxClusterUniqueGeometryCount = maxClusterUniqueGeometryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxClusterTriangleCount( uint32_t maxClusterTriangleCount_ ) & - VULKAN_HPP_NOEXCEPT - { - maxClusterTriangleCount = maxClusterTriangleCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxClusterTriangleCount( uint32_t maxClusterTriangleCount_ ) && - VULKAN_HPP_NOEXCEPT - { - maxClusterTriangleCount = maxClusterTriangleCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxClusterVertexCount( uint32_t maxClusterVertexCount_ ) & - VULKAN_HPP_NOEXCEPT - { - maxClusterVertexCount = maxClusterVertexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxClusterVertexCount( uint32_t maxClusterVertexCount_ ) && - VULKAN_HPP_NOEXCEPT - { - maxClusterVertexCount = maxClusterVertexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxTotalTriangleCount( uint32_t maxTotalTriangleCount_ ) & - VULKAN_HPP_NOEXCEPT - { - maxTotalTriangleCount = maxTotalTriangleCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxTotalTriangleCount( uint32_t maxTotalTriangleCount_ ) && - VULKAN_HPP_NOEXCEPT - { - maxTotalTriangleCount = maxTotalTriangleCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMaxTotalVertexCount( uint32_t maxTotalVertexCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxTotalVertexCount = maxTotalVertexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMaxTotalVertexCount( uint32_t maxTotalVertexCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxTotalVertexCount = maxTotalVertexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV & setMinPositionTruncateBitCount( uint32_t minPositionTruncateBitCount_ ) & - VULKAN_HPP_NOEXCEPT - { - minPositionTruncateBitCount = minPositionTruncateBitCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureTriangleClusterInputNV && setMinPositionTruncateBitCount( uint32_t minPositionTruncateBitCount_ ) && - VULKAN_HPP_NOEXCEPT - { - minPositionTruncateBitCount = minPositionTruncateBitCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureTriangleClusterInputNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureTriangleClusterInputNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureTriangleClusterInputNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureTriangleClusterInputNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - vertexFormat, - maxGeometryIndexValue, - maxClusterUniqueGeometryCount, - maxClusterTriangleCount, - maxClusterVertexCount, - maxTotalTriangleCount, - maxTotalVertexCount, - minPositionTruncateBitCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClusterAccelerationStructureTriangleClusterInputNV const & ) const = default; -#else - bool operator==( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexFormat == rhs.vertexFormat ) && - ( maxGeometryIndexValue == rhs.maxGeometryIndexValue ) && ( maxClusterUniqueGeometryCount == rhs.maxClusterUniqueGeometryCount ) && - ( maxClusterTriangleCount == rhs.maxClusterTriangleCount ) && ( maxClusterVertexCount == rhs.maxClusterVertexCount ) && - ( maxTotalTriangleCount == rhs.maxTotalTriangleCount ) && ( maxTotalVertexCount == rhs.maxTotalVertexCount ) && - ( minPositionTruncateBitCount == rhs.minPositionTruncateBitCount ); -# endif - } - - bool operator!=( ClusterAccelerationStructureTriangleClusterInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eClusterAccelerationStructureTriangleClusterInputNV; - void * pNext = {}; - Format vertexFormat = Format::eUndefined; - uint32_t maxGeometryIndexValue = {}; - uint32_t maxClusterUniqueGeometryCount = {}; - uint32_t maxClusterTriangleCount = {}; - uint32_t maxClusterVertexCount = {}; - uint32_t maxTotalTriangleCount = {}; - uint32_t maxTotalVertexCount = {}; - uint32_t minPositionTruncateBitCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureTriangleClusterInputNV; - }; -#endif - - template <> - struct CppType - { - using Type = ClusterAccelerationStructureTriangleClusterInputNV; - }; - - // wrapper struct for struct VkClusterAccelerationStructureMoveObjectsInputNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureMoveObjectsInputNV.html - struct ClusterAccelerationStructureMoveObjectsInputNV - { - using NativeType = VkClusterAccelerationStructureMoveObjectsInputNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eClusterAccelerationStructureMoveObjectsInputNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - ClusterAccelerationStructureMoveObjectsInputNV( ClusterAccelerationStructureTypeNV type_ = ClusterAccelerationStructureTypeNV::eClustersBottomLevel, - Bool32 noMoveOverlap_ = {}, - DeviceSize maxMovedBytes_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , noMoveOverlap{ noMoveOverlap_ } - , maxMovedBytes{ maxMovedBytes_ } - { - } - - VULKAN_HPP_CONSTEXPR - ClusterAccelerationStructureMoveObjectsInputNV( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureMoveObjectsInputNV( VkClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureMoveObjectsInputNV( *reinterpret_cast( &rhs ) ) - { - } - - ClusterAccelerationStructureMoveObjectsInputNV & operator=( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureMoveObjectsInputNV & operator=( VkClusterAccelerationStructureMoveObjectsInputNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setType( ClusterAccelerationStructureTypeNV type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setType( ClusterAccelerationStructureTypeNV type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setNoMoveOverlap( Bool32 noMoveOverlap_ ) & VULKAN_HPP_NOEXCEPT - { - noMoveOverlap = noMoveOverlap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setNoMoveOverlap( Bool32 noMoveOverlap_ ) && VULKAN_HPP_NOEXCEPT - { - noMoveOverlap = noMoveOverlap_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV & setMaxMovedBytes( DeviceSize maxMovedBytes_ ) & VULKAN_HPP_NOEXCEPT - { - maxMovedBytes = maxMovedBytes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInputNV && setMaxMovedBytes( DeviceSize maxMovedBytes_ ) && VULKAN_HPP_NOEXCEPT - { - maxMovedBytes = maxMovedBytes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureMoveObjectsInputNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureMoveObjectsInputNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureMoveObjectsInputNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureMoveObjectsInputNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, type, noMoveOverlap, maxMovedBytes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClusterAccelerationStructureMoveObjectsInputNV const & ) const = default; -#else - bool operator==( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( noMoveOverlap == rhs.noMoveOverlap ) && - ( maxMovedBytes == rhs.maxMovedBytes ); -# endif - } - - bool operator!=( ClusterAccelerationStructureMoveObjectsInputNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eClusterAccelerationStructureMoveObjectsInputNV; - void * pNext = {}; - ClusterAccelerationStructureTypeNV type = ClusterAccelerationStructureTypeNV::eClustersBottomLevel; - Bool32 noMoveOverlap = {}; - DeviceSize maxMovedBytes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureMoveObjectsInputNV; - }; -#endif - - template <> - struct CppType - { - using Type = ClusterAccelerationStructureMoveObjectsInputNV; - }; - - union ClusterAccelerationStructureOpInputNV - { - using NativeType = VkClusterAccelerationStructureOpInputNV; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV( ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel_ = {} ) - : pClustersBottomLevel( pClustersBottomLevel_ ) - { - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV( ClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters_ ) - : pTriangleClusters( pTriangleClusters_ ) - { - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV( ClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects_ ) - : pMoveObjects( pMoveObjects_ ) - { - } -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV & - setPClustersBottomLevel( ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel_ ) & - VULKAN_HPP_NOEXCEPT - { - pClustersBottomLevel = pClustersBottomLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV && - setPClustersBottomLevel( ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel_ ) && - VULKAN_HPP_NOEXCEPT - { - pClustersBottomLevel = pClustersBottomLevel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV & - setPTriangleClusters( ClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters_ ) & - VULKAN_HPP_NOEXCEPT - { - pTriangleClusters = pTriangleClusters_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV && - setPTriangleClusters( ClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters_ ) && - VULKAN_HPP_NOEXCEPT - { - pTriangleClusters = pTriangleClusters_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV & setPMoveObjects( ClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects_ ) & - VULKAN_HPP_NOEXCEPT - { - pMoveObjects = pMoveObjects_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureOpInputNV && setPMoveObjects( ClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects_ ) && - VULKAN_HPP_NOEXCEPT - { - pMoveObjects = pMoveObjects_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureOpInputNV const &() const - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureOpInputNV &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - ClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel; - ClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters; - ClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects; -#else - VkClusterAccelerationStructureClustersBottomLevelInputNV * pClustersBottomLevel; - VkClusterAccelerationStructureTriangleClusterInputNV * pTriangleClusters; - VkClusterAccelerationStructureMoveObjectsInputNV * pMoveObjects; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureOpInputNV; - }; -#endif - - // wrapper struct for struct VkClusterAccelerationStructureInputInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureInputInfoNV.html - struct ClusterAccelerationStructureInputInfoNV - { - using NativeType = VkClusterAccelerationStructureInputInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eClusterAccelerationStructureInputInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - ClusterAccelerationStructureInputInfoNV( uint32_t maxAccelerationStructureCount_ = {}, - BuildAccelerationStructureFlagsKHR flags_ = {}, - ClusterAccelerationStructureOpTypeNV opType_ = ClusterAccelerationStructureOpTypeNV::eMoveObjects, - ClusterAccelerationStructureOpModeNV opMode_ = ClusterAccelerationStructureOpModeNV::eImplicitDestinations, - ClusterAccelerationStructureOpInputNV opInput_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxAccelerationStructureCount{ maxAccelerationStructureCount_ } - , flags{ flags_ } - , opType{ opType_ } - , opMode{ opMode_ } - , opInput{ opInput_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV( ClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureInputInfoNV( VkClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureInputInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ClusterAccelerationStructureInputInfoNV & operator=( ClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureInputInfoNV & operator=( VkClusterAccelerationStructureInputInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setMaxAccelerationStructureCount( uint32_t maxAccelerationStructureCount_ ) & - VULKAN_HPP_NOEXCEPT - { - maxAccelerationStructureCount = maxAccelerationStructureCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setMaxAccelerationStructureCount( uint32_t maxAccelerationStructureCount_ ) && - VULKAN_HPP_NOEXCEPT - { - maxAccelerationStructureCount = maxAccelerationStructureCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setFlags( BuildAccelerationStructureFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setFlags( BuildAccelerationStructureFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setOpType( ClusterAccelerationStructureOpTypeNV opType_ ) & VULKAN_HPP_NOEXCEPT - { - opType = opType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setOpType( ClusterAccelerationStructureOpTypeNV opType_ ) && VULKAN_HPP_NOEXCEPT - { - opType = opType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setOpMode( ClusterAccelerationStructureOpModeNV opMode_ ) & VULKAN_HPP_NOEXCEPT - { - opMode = opMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setOpMode( ClusterAccelerationStructureOpModeNV opMode_ ) && VULKAN_HPP_NOEXCEPT - { - opMode = opMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV & setOpInput( ClusterAccelerationStructureOpInputNV const & opInput_ ) & VULKAN_HPP_NOEXCEPT - { - opInput = opInput_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInputInfoNV && setOpInput( ClusterAccelerationStructureOpInputNV const & opInput_ ) && - VULKAN_HPP_NOEXCEPT - { - opInput = opInput_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureInputInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureInputInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureInputInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureInputInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxAccelerationStructureCount, flags, opType, opMode, opInput ); - } -#endif - - public: - StructureType sType = StructureType::eClusterAccelerationStructureInputInfoNV; - void * pNext = {}; - uint32_t maxAccelerationStructureCount = {}; - BuildAccelerationStructureFlagsKHR flags = {}; - ClusterAccelerationStructureOpTypeNV opType = ClusterAccelerationStructureOpTypeNV::eMoveObjects; - ClusterAccelerationStructureOpModeNV opMode = ClusterAccelerationStructureOpModeNV::eImplicitDestinations; - ClusterAccelerationStructureOpInputNV opInput = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureInputInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = ClusterAccelerationStructureInputInfoNV; - }; - - // wrapper struct for struct VkStridedDeviceAddressRegionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressRegionKHR.html - struct StridedDeviceAddressRegionKHR - { - using NativeType = VkStridedDeviceAddressRegionKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR StridedDeviceAddressRegionKHR( DeviceAddress deviceAddress_ = {}, DeviceSize stride_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT - : deviceAddress{ deviceAddress_ } - , stride{ stride_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR StridedDeviceAddressRegionKHR( StridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - StridedDeviceAddressRegionKHR( VkStridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : StridedDeviceAddressRegionKHR( *reinterpret_cast( &rhs ) ) - { - } - - StridedDeviceAddressRegionKHR & operator=( StridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - StridedDeviceAddressRegionKHR & operator=( VkStridedDeviceAddressRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR & setStride( DeviceSize stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR && setStride( DeviceSize stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRegionKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkStridedDeviceAddressRegionKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressRegionKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressRegionKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressRegionKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( deviceAddress, stride, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( StridedDeviceAddressRegionKHR const & ) const = default; -#else - bool operator==( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( deviceAddress == rhs.deviceAddress ) && ( stride == rhs.stride ) && ( size == rhs.size ); -# endif - } - - bool operator!=( StridedDeviceAddressRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress deviceAddress = {}; - DeviceSize stride = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = StridedDeviceAddressRegionKHR; - }; -#endif - - // wrapper struct for struct VkClusterAccelerationStructureCommandsInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureCommandsInfoNV.html - struct ClusterAccelerationStructureCommandsInfoNV - { - using NativeType = VkClusterAccelerationStructureCommandsInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eClusterAccelerationStructureCommandsInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV( ClusterAccelerationStructureInputInfoNV input_ = {}, - DeviceAddress dstImplicitData_ = {}, - DeviceAddress scratchData_ = {}, - StridedDeviceAddressRegionKHR dstAddressesArray_ = {}, - StridedDeviceAddressRegionKHR dstSizesArray_ = {}, - StridedDeviceAddressRegionKHR srcInfosArray_ = {}, - DeviceAddress srcInfosCount_ = {}, - ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , input{ input_ } - , dstImplicitData{ dstImplicitData_ } - , scratchData{ scratchData_ } - , dstAddressesArray{ dstAddressesArray_ } - , dstSizesArray{ dstSizesArray_ } - , srcInfosArray{ srcInfosArray_ } - , srcInfosCount{ srcInfosCount_ } - , addressResolutionFlags{ addressResolutionFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV( ClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureCommandsInfoNV( VkClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureCommandsInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ClusterAccelerationStructureCommandsInfoNV & operator=( ClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureCommandsInfoNV & operator=( VkClusterAccelerationStructureCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setInput( ClusterAccelerationStructureInputInfoNV const & input_ ) & - VULKAN_HPP_NOEXCEPT - { - input = input_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setInput( ClusterAccelerationStructureInputInfoNV const & input_ ) && - VULKAN_HPP_NOEXCEPT - { - input = input_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setDstImplicitData( DeviceAddress dstImplicitData_ ) & VULKAN_HPP_NOEXCEPT - { - dstImplicitData = dstImplicitData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setDstImplicitData( DeviceAddress dstImplicitData_ ) && VULKAN_HPP_NOEXCEPT - { - dstImplicitData = dstImplicitData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setScratchData( DeviceAddress scratchData_ ) & VULKAN_HPP_NOEXCEPT - { - scratchData = scratchData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setScratchData( DeviceAddress scratchData_ ) && VULKAN_HPP_NOEXCEPT - { - scratchData = scratchData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setDstAddressesArray( StridedDeviceAddressRegionKHR const & dstAddressesArray_ ) & - VULKAN_HPP_NOEXCEPT - { - dstAddressesArray = dstAddressesArray_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setDstAddressesArray( StridedDeviceAddressRegionKHR const & dstAddressesArray_ ) && - VULKAN_HPP_NOEXCEPT - { - dstAddressesArray = dstAddressesArray_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setDstSizesArray( StridedDeviceAddressRegionKHR const & dstSizesArray_ ) & - VULKAN_HPP_NOEXCEPT - { - dstSizesArray = dstSizesArray_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setDstSizesArray( StridedDeviceAddressRegionKHR const & dstSizesArray_ ) && - VULKAN_HPP_NOEXCEPT - { - dstSizesArray = dstSizesArray_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setSrcInfosArray( StridedDeviceAddressRegionKHR const & srcInfosArray_ ) & - VULKAN_HPP_NOEXCEPT - { - srcInfosArray = srcInfosArray_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setSrcInfosArray( StridedDeviceAddressRegionKHR const & srcInfosArray_ ) && - VULKAN_HPP_NOEXCEPT - { - srcInfosArray = srcInfosArray_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & setSrcInfosCount( DeviceAddress srcInfosCount_ ) & VULKAN_HPP_NOEXCEPT - { - srcInfosCount = srcInfosCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && setSrcInfosCount( DeviceAddress srcInfosCount_ ) && VULKAN_HPP_NOEXCEPT - { - srcInfosCount = srcInfosCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV & - setAddressResolutionFlags( ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags_ ) & - VULKAN_HPP_NOEXCEPT - { - addressResolutionFlags = addressResolutionFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureCommandsInfoNV && - setAddressResolutionFlags( ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags_ ) && - VULKAN_HPP_NOEXCEPT - { - addressResolutionFlags = addressResolutionFlags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureCommandsInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureCommandsInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureCommandsInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, input, dstImplicitData, scratchData, dstAddressesArray, dstSizesArray, srcInfosArray, srcInfosCount, addressResolutionFlags ); - } -#endif - - public: - StructureType sType = StructureType::eClusterAccelerationStructureCommandsInfoNV; - void * pNext = {}; - ClusterAccelerationStructureInputInfoNV input = {}; - DeviceAddress dstImplicitData = {}; - DeviceAddress scratchData = {}; - StridedDeviceAddressRegionKHR dstAddressesArray = {}; - StridedDeviceAddressRegionKHR dstSizesArray = {}; - StridedDeviceAddressRegionKHR srcInfosArray = {}; - DeviceAddress srcInfosCount = {}; - ClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureCommandsInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = ClusterAccelerationStructureCommandsInfoNV; - }; - - // wrapper struct for struct VkClusterAccelerationStructureGetTemplateIndicesInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureGetTemplateIndicesInfoNV.html - struct ClusterAccelerationStructureGetTemplateIndicesInfoNV - { - using NativeType = VkClusterAccelerationStructureGetTemplateIndicesInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureGetTemplateIndicesInfoNV( DeviceAddress clusterTemplateAddress_ = {} ) VULKAN_HPP_NOEXCEPT - : clusterTemplateAddress{ clusterTemplateAddress_ } - { - } - - VULKAN_HPP_CONSTEXPR - ClusterAccelerationStructureGetTemplateIndicesInfoNV( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureGetTemplateIndicesInfoNV( VkClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureGetTemplateIndicesInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ClusterAccelerationStructureGetTemplateIndicesInfoNV & - operator=( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureGetTemplateIndicesInfoNV & operator=( VkClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGetTemplateIndicesInfoNV & setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) & - VULKAN_HPP_NOEXCEPT - { - clusterTemplateAddress = clusterTemplateAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureGetTemplateIndicesInfoNV && setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) && - VULKAN_HPP_NOEXCEPT - { - clusterTemplateAddress = clusterTemplateAddress_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureGetTemplateIndicesInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( clusterTemplateAddress ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & ) const = default; -#else - bool operator==( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( clusterTemplateAddress == rhs.clusterTemplateAddress ); -# endif - } - - bool operator!=( ClusterAccelerationStructureGetTemplateIndicesInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress clusterTemplateAddress = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureGetTemplateIndicesInfoNV; - }; -#endif - - // wrapper struct for struct VkClusterAccelerationStructureInstantiateClusterInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureInstantiateClusterInfoNV.html - struct ClusterAccelerationStructureInstantiateClusterInfoNV - { - using NativeType = VkClusterAccelerationStructureInstantiateClusterInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureInstantiateClusterInfoNV( uint32_t clusterIdOffset_ = {}, - uint32_t geometryIndexOffset_ = {}, - uint32_t reserved_ = {}, - DeviceAddress clusterTemplateAddress_ = {}, - StridedDeviceAddressNV vertexBuffer_ = {} ) VULKAN_HPP_NOEXCEPT - : clusterIdOffset{ clusterIdOffset_ } - , geometryIndexOffset{ geometryIndexOffset_ } - , reserved{ reserved_ } - , clusterTemplateAddress{ clusterTemplateAddress_ } - , vertexBuffer{ vertexBuffer_ } - { - } - - VULKAN_HPP_CONSTEXPR - ClusterAccelerationStructureInstantiateClusterInfoNV( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureInstantiateClusterInfoNV( VkClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureInstantiateClusterInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ClusterAccelerationStructureInstantiateClusterInfoNV & - operator=( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureInstantiateClusterInfoNV & operator=( VkClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setClusterIdOffset( uint32_t clusterIdOffset_ ) & VULKAN_HPP_NOEXCEPT - { - clusterIdOffset = clusterIdOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setClusterIdOffset( uint32_t clusterIdOffset_ ) && VULKAN_HPP_NOEXCEPT - { - clusterIdOffset = clusterIdOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setGeometryIndexOffset( uint32_t geometryIndexOffset_ ) & VULKAN_HPP_NOEXCEPT - { - geometryIndexOffset = geometryIndexOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setGeometryIndexOffset( uint32_t geometryIndexOffset_ ) && - VULKAN_HPP_NOEXCEPT - { - geometryIndexOffset = geometryIndexOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setReserved( uint32_t reserved_ ) & VULKAN_HPP_NOEXCEPT - { - reserved = reserved_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setReserved( uint32_t reserved_ ) && VULKAN_HPP_NOEXCEPT - { - reserved = reserved_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) & - VULKAN_HPP_NOEXCEPT - { - clusterTemplateAddress = clusterTemplateAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setClusterTemplateAddress( DeviceAddress clusterTemplateAddress_ ) && - VULKAN_HPP_NOEXCEPT - { - clusterTemplateAddress = clusterTemplateAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV & setVertexBuffer( StridedDeviceAddressNV const & vertexBuffer_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexBuffer = vertexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureInstantiateClusterInfoNV && setVertexBuffer( StridedDeviceAddressNV const & vertexBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexBuffer = vertexBuffer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureInstantiateClusterInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureInstantiateClusterInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureInstantiateClusterInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureInstantiateClusterInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( clusterIdOffset, geometryIndexOffset, reserved, clusterTemplateAddress, vertexBuffer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClusterAccelerationStructureInstantiateClusterInfoNV const & ) const = default; -#else - bool operator==( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( clusterIdOffset == rhs.clusterIdOffset ) && ( geometryIndexOffset == rhs.geometryIndexOffset ) && ( reserved == rhs.reserved ) && - ( clusterTemplateAddress == rhs.clusterTemplateAddress ) && ( vertexBuffer == rhs.vertexBuffer ); -# endif - } - - bool operator!=( ClusterAccelerationStructureInstantiateClusterInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t clusterIdOffset = {}; - uint32_t geometryIndexOffset : 24; - uint32_t reserved : 8; - DeviceAddress clusterTemplateAddress = {}; - StridedDeviceAddressNV vertexBuffer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureInstantiateClusterInfoNV; - }; -#endif - - // wrapper struct for struct VkClusterAccelerationStructureMoveObjectsInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkClusterAccelerationStructureMoveObjectsInfoNV.html - struct ClusterAccelerationStructureMoveObjectsInfoNV - { - using NativeType = VkClusterAccelerationStructureMoveObjectsInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ClusterAccelerationStructureMoveObjectsInfoNV( DeviceAddress srcAccelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT - : srcAccelerationStructure{ srcAccelerationStructure_ } - { - } - - VULKAN_HPP_CONSTEXPR - ClusterAccelerationStructureMoveObjectsInfoNV( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ClusterAccelerationStructureMoveObjectsInfoNV( VkClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ClusterAccelerationStructureMoveObjectsInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ClusterAccelerationStructureMoveObjectsInfoNV & operator=( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ClusterAccelerationStructureMoveObjectsInfoNV & operator=( VkClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInfoNV & setSrcAccelerationStructure( DeviceAddress srcAccelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - srcAccelerationStructure = srcAccelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ClusterAccelerationStructureMoveObjectsInfoNV && setSrcAccelerationStructure( DeviceAddress srcAccelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - srcAccelerationStructure = srcAccelerationStructure_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkClusterAccelerationStructureMoveObjectsInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureMoveObjectsInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureMoveObjectsInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkClusterAccelerationStructureMoveObjectsInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( srcAccelerationStructure ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ClusterAccelerationStructureMoveObjectsInfoNV const & ) const = default; -#else - bool operator==( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( srcAccelerationStructure == rhs.srcAccelerationStructure ); -# endif - } - - bool operator!=( ClusterAccelerationStructureMoveObjectsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress srcAccelerationStructure = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ClusterAccelerationStructureMoveObjectsInfoNV; - }; -#endif - - // wrapper struct for struct VkCoarseSampleLocationNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoarseSampleLocationNV.html - struct CoarseSampleLocationNV - { - using NativeType = VkCoarseSampleLocationNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CoarseSampleLocationNV( uint32_t pixelX_ = {}, uint32_t pixelY_ = {}, uint32_t sample_ = {} ) VULKAN_HPP_NOEXCEPT - : pixelX{ pixelX_ } - , pixelY{ pixelY_ } - , sample{ sample_ } - { - } - - VULKAN_HPP_CONSTEXPR CoarseSampleLocationNV( CoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CoarseSampleLocationNV( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT - : CoarseSampleLocationNV( *reinterpret_cast( &rhs ) ) - { - } - - CoarseSampleLocationNV & operator=( CoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CoarseSampleLocationNV & operator=( VkCoarseSampleLocationNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV & setPixelX( uint32_t pixelX_ ) & VULKAN_HPP_NOEXCEPT - { - pixelX = pixelX_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV && setPixelX( uint32_t pixelX_ ) && VULKAN_HPP_NOEXCEPT - { - pixelX = pixelX_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV & setPixelY( uint32_t pixelY_ ) & VULKAN_HPP_NOEXCEPT - { - pixelY = pixelY_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV && setPixelY( uint32_t pixelY_ ) && VULKAN_HPP_NOEXCEPT - { - pixelY = pixelY_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV & setSample( uint32_t sample_ ) & VULKAN_HPP_NOEXCEPT - { - sample = sample_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleLocationNV && setSample( uint32_t sample_ ) && VULKAN_HPP_NOEXCEPT - { - sample = sample_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCoarseSampleLocationNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCoarseSampleLocationNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCoarseSampleLocationNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCoarseSampleLocationNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( pixelX, pixelY, sample ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CoarseSampleLocationNV const & ) const = default; -#else - bool operator==( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( pixelX == rhs.pixelX ) && ( pixelY == rhs.pixelY ) && ( sample == rhs.sample ); -# endif - } - - bool operator!=( CoarseSampleLocationNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t pixelX = {}; - uint32_t pixelY = {}; - uint32_t sample = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CoarseSampleLocationNV; - }; -#endif - - // wrapper struct for struct VkCoarseSampleOrderCustomNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCoarseSampleOrderCustomNV.html - struct CoarseSampleOrderCustomNV - { - using NativeType = VkCoarseSampleOrderCustomNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV shadingRate_ = ShadingRatePaletteEntryNV::eNoInvocations, - uint32_t sampleCount_ = {}, - uint32_t sampleLocationCount_ = {}, - const CoarseSampleLocationNV * pSampleLocations_ = {} ) VULKAN_HPP_NOEXCEPT - : shadingRate{ shadingRate_ } - , sampleCount{ sampleCount_ } - , sampleLocationCount{ sampleLocationCount_ } - , pSampleLocations{ pSampleLocations_ } - { - } - - VULKAN_HPP_CONSTEXPR CoarseSampleOrderCustomNV( CoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CoarseSampleOrderCustomNV( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT - : CoarseSampleOrderCustomNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CoarseSampleOrderCustomNV( ShadingRatePaletteEntryNV shadingRate_, - uint32_t sampleCount_, - ArrayProxyNoTemporaries const & sampleLocations_ ) - : shadingRate( shadingRate_ ) - , sampleCount( sampleCount_ ) - , sampleLocationCount( static_cast( sampleLocations_.size() ) ) - , pSampleLocations( sampleLocations_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CoarseSampleOrderCustomNV & operator=( CoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CoarseSampleOrderCustomNV & operator=( VkCoarseSampleOrderCustomNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setShadingRate( ShadingRatePaletteEntryNV shadingRate_ ) & VULKAN_HPP_NOEXCEPT - { - shadingRate = shadingRate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setShadingRate( ShadingRatePaletteEntryNV shadingRate_ ) && VULKAN_HPP_NOEXCEPT - { - shadingRate = shadingRate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setSampleCount( uint32_t sampleCount_ ) & VULKAN_HPP_NOEXCEPT - { - sampleCount = sampleCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setSampleCount( uint32_t sampleCount_ ) && VULKAN_HPP_NOEXCEPT - { - sampleCount = sampleCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setSampleLocationCount( uint32_t sampleLocationCount_ ) & VULKAN_HPP_NOEXCEPT - { - sampleLocationCount = sampleLocationCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setSampleLocationCount( uint32_t sampleLocationCount_ ) && VULKAN_HPP_NOEXCEPT - { - sampleLocationCount = sampleLocationCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV & setPSampleLocations( const CoarseSampleLocationNV * pSampleLocations_ ) & VULKAN_HPP_NOEXCEPT - { - pSampleLocations = pSampleLocations_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CoarseSampleOrderCustomNV && setPSampleLocations( const CoarseSampleLocationNV * pSampleLocations_ ) && VULKAN_HPP_NOEXCEPT - { - pSampleLocations = pSampleLocations_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CoarseSampleOrderCustomNV & setSampleLocations( ArrayProxyNoTemporaries const & sampleLocations_ ) VULKAN_HPP_NOEXCEPT - { - sampleLocationCount = static_cast( sampleLocations_.size() ); - pSampleLocations = sampleLocations_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCoarseSampleOrderCustomNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCoarseSampleOrderCustomNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCoarseSampleOrderCustomNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCoarseSampleOrderCustomNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( shadingRate, sampleCount, sampleLocationCount, pSampleLocations ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CoarseSampleOrderCustomNV const & ) const = default; -#else - bool operator==( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( shadingRate == rhs.shadingRate ) && ( sampleCount == rhs.sampleCount ) && ( sampleLocationCount == rhs.sampleLocationCount ) && - ( pSampleLocations == rhs.pSampleLocations ); -# endif - } - - bool operator!=( CoarseSampleOrderCustomNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ShadingRatePaletteEntryNV shadingRate = ShadingRatePaletteEntryNV::eNoInvocations; - uint32_t sampleCount = {}; - uint32_t sampleLocationCount = {}; - const CoarseSampleLocationNV * pSampleLocations = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CoarseSampleOrderCustomNV; - }; -#endif - - // wrapper struct for struct VkColorBlendAdvancedEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorBlendAdvancedEXT.html - struct ColorBlendAdvancedEXT - { - using NativeType = VkColorBlendAdvancedEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ColorBlendAdvancedEXT( BlendOp advancedBlendOp_ = BlendOp::eAdd, - Bool32 srcPremultiplied_ = {}, - Bool32 dstPremultiplied_ = {}, - BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated, - Bool32 clampResults_ = {} ) VULKAN_HPP_NOEXCEPT - : advancedBlendOp{ advancedBlendOp_ } - , srcPremultiplied{ srcPremultiplied_ } - , dstPremultiplied{ dstPremultiplied_ } - , blendOverlap{ blendOverlap_ } - , clampResults{ clampResults_ } - { - } - - VULKAN_HPP_CONSTEXPR ColorBlendAdvancedEXT( ColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ColorBlendAdvancedEXT( VkColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ColorBlendAdvancedEXT( *reinterpret_cast( &rhs ) ) - { - } - - ColorBlendAdvancedEXT & operator=( ColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ColorBlendAdvancedEXT & operator=( VkColorBlendAdvancedEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setAdvancedBlendOp( BlendOp advancedBlendOp_ ) & VULKAN_HPP_NOEXCEPT - { - advancedBlendOp = advancedBlendOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setAdvancedBlendOp( BlendOp advancedBlendOp_ ) && VULKAN_HPP_NOEXCEPT - { - advancedBlendOp = advancedBlendOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setSrcPremultiplied( Bool32 srcPremultiplied_ ) & VULKAN_HPP_NOEXCEPT - { - srcPremultiplied = srcPremultiplied_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setSrcPremultiplied( Bool32 srcPremultiplied_ ) && VULKAN_HPP_NOEXCEPT - { - srcPremultiplied = srcPremultiplied_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setDstPremultiplied( Bool32 dstPremultiplied_ ) & VULKAN_HPP_NOEXCEPT - { - dstPremultiplied = dstPremultiplied_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setDstPremultiplied( Bool32 dstPremultiplied_ ) && VULKAN_HPP_NOEXCEPT - { - dstPremultiplied = dstPremultiplied_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setBlendOverlap( BlendOverlapEXT blendOverlap_ ) & VULKAN_HPP_NOEXCEPT - { - blendOverlap = blendOverlap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setBlendOverlap( BlendOverlapEXT blendOverlap_ ) && VULKAN_HPP_NOEXCEPT - { - blendOverlap = blendOverlap_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT & setClampResults( Bool32 clampResults_ ) & VULKAN_HPP_NOEXCEPT - { - clampResults = clampResults_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendAdvancedEXT && setClampResults( Bool32 clampResults_ ) && VULKAN_HPP_NOEXCEPT - { - clampResults = clampResults_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkColorBlendAdvancedEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkColorBlendAdvancedEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkColorBlendAdvancedEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkColorBlendAdvancedEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( advancedBlendOp, srcPremultiplied, dstPremultiplied, blendOverlap, clampResults ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ColorBlendAdvancedEXT const & ) const = default; -#else - bool operator==( ColorBlendAdvancedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( advancedBlendOp == rhs.advancedBlendOp ) && ( srcPremultiplied == rhs.srcPremultiplied ) && ( dstPremultiplied == rhs.dstPremultiplied ) && - ( blendOverlap == rhs.blendOverlap ) && ( clampResults == rhs.clampResults ); -# endif - } - - bool operator!=( ColorBlendAdvancedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - BlendOp advancedBlendOp = BlendOp::eAdd; - Bool32 srcPremultiplied = {}; - Bool32 dstPremultiplied = {}; - BlendOverlapEXT blendOverlap = BlendOverlapEXT::eUncorrelated; - Bool32 clampResults = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ColorBlendAdvancedEXT; - }; -#endif - - // wrapper struct for struct VkColorBlendEquationEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkColorBlendEquationEXT.html - struct ColorBlendEquationEXT - { - using NativeType = VkColorBlendEquationEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ColorBlendEquationEXT( BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, - BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, - BlendOp colorBlendOp_ = BlendOp::eAdd, - BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, - BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, - BlendOp alphaBlendOp_ = BlendOp::eAdd ) VULKAN_HPP_NOEXCEPT - : srcColorBlendFactor{ srcColorBlendFactor_ } - , dstColorBlendFactor{ dstColorBlendFactor_ } - , colorBlendOp{ colorBlendOp_ } - , srcAlphaBlendFactor{ srcAlphaBlendFactor_ } - , dstAlphaBlendFactor{ dstAlphaBlendFactor_ } - , alphaBlendOp{ alphaBlendOp_ } - { - } - - VULKAN_HPP_CONSTEXPR ColorBlendEquationEXT( ColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ColorBlendEquationEXT( VkColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ColorBlendEquationEXT( *reinterpret_cast( &rhs ) ) - { - } - - ColorBlendEquationEXT & operator=( ColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ColorBlendEquationEXT & operator=( VkColorBlendEquationEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) & VULKAN_HPP_NOEXCEPT - { - srcColorBlendFactor = srcColorBlendFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) && VULKAN_HPP_NOEXCEPT - { - srcColorBlendFactor = srcColorBlendFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) & VULKAN_HPP_NOEXCEPT - { - dstColorBlendFactor = dstColorBlendFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) && VULKAN_HPP_NOEXCEPT - { - dstColorBlendFactor = dstColorBlendFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setColorBlendOp( BlendOp colorBlendOp_ ) & VULKAN_HPP_NOEXCEPT - { - colorBlendOp = colorBlendOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setColorBlendOp( BlendOp colorBlendOp_ ) && VULKAN_HPP_NOEXCEPT - { - colorBlendOp = colorBlendOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) & VULKAN_HPP_NOEXCEPT - { - srcAlphaBlendFactor = srcAlphaBlendFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) && VULKAN_HPP_NOEXCEPT - { - srcAlphaBlendFactor = srcAlphaBlendFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) & VULKAN_HPP_NOEXCEPT - { - dstAlphaBlendFactor = dstAlphaBlendFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) && VULKAN_HPP_NOEXCEPT - { - dstAlphaBlendFactor = dstAlphaBlendFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT & setAlphaBlendOp( BlendOp alphaBlendOp_ ) & VULKAN_HPP_NOEXCEPT - { - alphaBlendOp = alphaBlendOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ColorBlendEquationEXT && setAlphaBlendOp( BlendOp alphaBlendOp_ ) && VULKAN_HPP_NOEXCEPT - { - alphaBlendOp = alphaBlendOp_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkColorBlendEquationEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkColorBlendEquationEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkColorBlendEquationEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkColorBlendEquationEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( srcColorBlendFactor, dstColorBlendFactor, colorBlendOp, srcAlphaBlendFactor, dstAlphaBlendFactor, alphaBlendOp ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ColorBlendEquationEXT const & ) const = default; -#else - bool operator==( ColorBlendEquationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( srcColorBlendFactor == rhs.srcColorBlendFactor ) && ( dstColorBlendFactor == rhs.dstColorBlendFactor ) && ( colorBlendOp == rhs.colorBlendOp ) && - ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) && ( alphaBlendOp == rhs.alphaBlendOp ); -# endif - } - - bool operator!=( ColorBlendEquationEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - BlendFactor srcColorBlendFactor = BlendFactor::eZero; - BlendFactor dstColorBlendFactor = BlendFactor::eZero; - BlendOp colorBlendOp = BlendOp::eAdd; - BlendFactor srcAlphaBlendFactor = BlendFactor::eZero; - BlendFactor dstAlphaBlendFactor = BlendFactor::eZero; - BlendOp alphaBlendOp = BlendOp::eAdd; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ColorBlendEquationEXT; - }; -#endif - - // wrapper struct for struct VkCommandBufferAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferAllocateInfo.html - struct CommandBufferAllocateInfo - { - using NativeType = VkCommandBufferAllocateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferAllocateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( CommandPool commandPool_ = {}, - CommandBufferLevel level_ = CommandBufferLevel::ePrimary, - uint32_t commandBufferCount_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , commandPool{ commandPool_ } - , level{ level_ } - , commandBufferCount{ commandBufferCount_ } - { - } - - VULKAN_HPP_CONSTEXPR CommandBufferAllocateInfo( CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CommandBufferAllocateInfo( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : CommandBufferAllocateInfo( *reinterpret_cast( &rhs ) ) - { - } - - CommandBufferAllocateInfo & operator=( CommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CommandBufferAllocateInfo & operator=( VkCommandBufferAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setCommandPool( CommandPool commandPool_ ) & VULKAN_HPP_NOEXCEPT - { - commandPool = commandPool_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setCommandPool( CommandPool commandPool_ ) && VULKAN_HPP_NOEXCEPT - { - commandPool = commandPool_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setLevel( CommandBufferLevel level_ ) & VULKAN_HPP_NOEXCEPT - { - level = level_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setLevel( CommandBufferLevel level_ ) && VULKAN_HPP_NOEXCEPT - { - level = level_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo & setCommandBufferCount( uint32_t commandBufferCount_ ) & VULKAN_HPP_NOEXCEPT - { - commandBufferCount = commandBufferCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferAllocateInfo && setCommandBufferCount( uint32_t commandBufferCount_ ) && VULKAN_HPP_NOEXCEPT - { - commandBufferCount = commandBufferCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCommandBufferAllocateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferAllocateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferAllocateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCommandBufferAllocateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, commandPool, level, commandBufferCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CommandBufferAllocateInfo const & ) const = default; -#else - bool operator==( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandPool == rhs.commandPool ) && ( level == rhs.level ) && - ( commandBufferCount == rhs.commandBufferCount ); -# endif - } - - bool operator!=( CommandBufferAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCommandBufferAllocateInfo; - const void * pNext = {}; - CommandPool commandPool = {}; - CommandBufferLevel level = CommandBufferLevel::ePrimary; - uint32_t commandBufferCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CommandBufferAllocateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = CommandBufferAllocateInfo; - }; - - // wrapper struct for struct VkCommandBufferInheritanceInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceInfo.html - struct CommandBufferInheritanceInfo - { - using NativeType = VkCommandBufferInheritanceInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( RenderPass renderPass_ = {}, - uint32_t subpass_ = {}, - Framebuffer framebuffer_ = {}, - Bool32 occlusionQueryEnable_ = {}, - QueryControlFlags queryFlags_ = {}, - QueryPipelineStatisticFlags pipelineStatistics_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , renderPass{ renderPass_ } - , subpass{ subpass_ } - , framebuffer{ framebuffer_ } - , occlusionQueryEnable{ occlusionQueryEnable_ } - , queryFlags{ queryFlags_ } - , pipelineStatistics{ pipelineStatistics_ } - { - } - - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceInfo( CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CommandBufferInheritanceInfo( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : CommandBufferInheritanceInfo( *reinterpret_cast( &rhs ) ) - { - } - - CommandBufferInheritanceInfo & operator=( CommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CommandBufferInheritanceInfo & operator=( VkCommandBufferInheritanceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setRenderPass( RenderPass renderPass_ ) & VULKAN_HPP_NOEXCEPT - { - renderPass = renderPass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setRenderPass( RenderPass renderPass_ ) && VULKAN_HPP_NOEXCEPT - { - renderPass = renderPass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setSubpass( uint32_t subpass_ ) & VULKAN_HPP_NOEXCEPT - { - subpass = subpass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setSubpass( uint32_t subpass_ ) && VULKAN_HPP_NOEXCEPT - { - subpass = subpass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setFramebuffer( Framebuffer framebuffer_ ) & VULKAN_HPP_NOEXCEPT - { - framebuffer = framebuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setFramebuffer( Framebuffer framebuffer_ ) && VULKAN_HPP_NOEXCEPT - { - framebuffer = framebuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ ) & VULKAN_HPP_NOEXCEPT - { - occlusionQueryEnable = occlusionQueryEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setOcclusionQueryEnable( Bool32 occlusionQueryEnable_ ) && VULKAN_HPP_NOEXCEPT - { - occlusionQueryEnable = occlusionQueryEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setQueryFlags( QueryControlFlags queryFlags_ ) & VULKAN_HPP_NOEXCEPT - { - queryFlags = queryFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setQueryFlags( QueryControlFlags queryFlags_ ) && VULKAN_HPP_NOEXCEPT - { - queryFlags = queryFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo & setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineStatistics = pipelineStatistics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceInfo && setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineStatistics = pipelineStatistics_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCommandBufferInheritanceInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, renderPass, subpass, framebuffer, occlusionQueryEnable, queryFlags, pipelineStatistics ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CommandBufferInheritanceInfo const & ) const = default; -#else - bool operator==( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && ( subpass == rhs.subpass ) && - ( framebuffer == rhs.framebuffer ) && ( occlusionQueryEnable == rhs.occlusionQueryEnable ) && ( queryFlags == rhs.queryFlags ) && - ( pipelineStatistics == rhs.pipelineStatistics ); -# endif - } - - bool operator!=( CommandBufferInheritanceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCommandBufferInheritanceInfo; - const void * pNext = {}; - RenderPass renderPass = {}; - uint32_t subpass = {}; - Framebuffer framebuffer = {}; - Bool32 occlusionQueryEnable = {}; - QueryControlFlags queryFlags = {}; - QueryPipelineStatisticFlags pipelineStatistics = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CommandBufferInheritanceInfo; - }; -#endif - - template <> - struct CppType - { - using Type = CommandBufferInheritanceInfo; - }; - - // wrapper struct for struct VkCommandBufferBeginInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferBeginInfo.html - struct CommandBufferBeginInfo - { - using NativeType = VkCommandBufferBeginInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferBeginInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( CommandBufferUsageFlags flags_ = {}, - const CommandBufferInheritanceInfo * pInheritanceInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pInheritanceInfo{ pInheritanceInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR CommandBufferBeginInfo( CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CommandBufferBeginInfo( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : CommandBufferBeginInfo( *reinterpret_cast( &rhs ) ) - { - } - - CommandBufferBeginInfo & operator=( CommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CommandBufferBeginInfo & operator=( VkCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo & setFlags( CommandBufferUsageFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo && setFlags( CommandBufferUsageFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo & setPInheritanceInfo( const CommandBufferInheritanceInfo * pInheritanceInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pInheritanceInfo = pInheritanceInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferBeginInfo && setPInheritanceInfo( const CommandBufferInheritanceInfo * pInheritanceInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pInheritanceInfo = pInheritanceInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferBeginInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCommandBufferBeginInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, pInheritanceInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CommandBufferBeginInfo const & ) const = default; -#else - bool operator==( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pInheritanceInfo == rhs.pInheritanceInfo ); -# endif - } - - bool operator!=( CommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCommandBufferBeginInfo; - const void * pNext = {}; - CommandBufferUsageFlags flags = {}; - const CommandBufferInheritanceInfo * pInheritanceInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CommandBufferBeginInfo; - }; -#endif - - template <> - struct CppType - { - using Type = CommandBufferBeginInfo; - }; - - // wrapper struct for struct VkCommandBufferInheritanceConditionalRenderingInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceConditionalRenderingInfoEXT.html - struct CommandBufferInheritanceConditionalRenderingInfoEXT - { - using NativeType = VkCommandBufferInheritanceConditionalRenderingInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceConditionalRenderingInfoEXT( Bool32 conditionalRenderingEnable_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , conditionalRenderingEnable{ conditionalRenderingEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR - CommandBufferInheritanceConditionalRenderingInfoEXT( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CommandBufferInheritanceConditionalRenderingInfoEXT( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : CommandBufferInheritanceConditionalRenderingInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - CommandBufferInheritanceConditionalRenderingInfoEXT & - operator=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CommandBufferInheritanceConditionalRenderingInfoEXT & operator=( VkCommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT & setConditionalRenderingEnable( Bool32 conditionalRenderingEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - conditionalRenderingEnable = conditionalRenderingEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceConditionalRenderingInfoEXT && setConditionalRenderingEnable( Bool32 conditionalRenderingEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - conditionalRenderingEnable = conditionalRenderingEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceConditionalRenderingInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceConditionalRenderingInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceConditionalRenderingInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, conditionalRenderingEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CommandBufferInheritanceConditionalRenderingInfoEXT const & ) const = default; -#else - bool operator==( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRenderingEnable == rhs.conditionalRenderingEnable ); -# endif - } - - bool operator!=( CommandBufferInheritanceConditionalRenderingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT; - const void * pNext = {}; - Bool32 conditionalRenderingEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CommandBufferInheritanceConditionalRenderingInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = CommandBufferInheritanceConditionalRenderingInfoEXT; - }; - - // wrapper struct for struct VkCommandBufferInheritanceDescriptorHeapInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceDescriptorHeapInfoEXT.html - struct CommandBufferInheritanceDescriptorHeapInfoEXT - { - using NativeType = VkCommandBufferInheritanceDescriptorHeapInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceDescriptorHeapInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceDescriptorHeapInfoEXT( const BindHeapInfoEXT * pSamplerHeapBindInfo_ = {}, - const BindHeapInfoEXT * pResourceHeapBindInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pSamplerHeapBindInfo{ pSamplerHeapBindInfo_ } - , pResourceHeapBindInfo{ pResourceHeapBindInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR - CommandBufferInheritanceDescriptorHeapInfoEXT( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CommandBufferInheritanceDescriptorHeapInfoEXT( VkCommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : CommandBufferInheritanceDescriptorHeapInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - CommandBufferInheritanceDescriptorHeapInfoEXT & operator=( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CommandBufferInheritanceDescriptorHeapInfoEXT & operator=( VkCommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT & setPSamplerHeapBindInfo( const BindHeapInfoEXT * pSamplerHeapBindInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pSamplerHeapBindInfo = pSamplerHeapBindInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT && setPSamplerHeapBindInfo( const BindHeapInfoEXT * pSamplerHeapBindInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pSamplerHeapBindInfo = pSamplerHeapBindInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT & setPResourceHeapBindInfo( const BindHeapInfoEXT * pResourceHeapBindInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pResourceHeapBindInfo = pResourceHeapBindInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceDescriptorHeapInfoEXT && setPResourceHeapBindInfo( const BindHeapInfoEXT * pResourceHeapBindInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pResourceHeapBindInfo = pResourceHeapBindInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCommandBufferInheritanceDescriptorHeapInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceDescriptorHeapInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceDescriptorHeapInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceDescriptorHeapInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pSamplerHeapBindInfo, pResourceHeapBindInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CommandBufferInheritanceDescriptorHeapInfoEXT const & ) const = default; -#else - bool operator==( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSamplerHeapBindInfo == rhs.pSamplerHeapBindInfo ) && - ( pResourceHeapBindInfo == rhs.pResourceHeapBindInfo ); -# endif - } - - bool operator!=( CommandBufferInheritanceDescriptorHeapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCommandBufferInheritanceDescriptorHeapInfoEXT; - const void * pNext = {}; - const BindHeapInfoEXT * pSamplerHeapBindInfo = {}; - const BindHeapInfoEXT * pResourceHeapBindInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CommandBufferInheritanceDescriptorHeapInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = CommandBufferInheritanceDescriptorHeapInfoEXT; - }; - - // wrapper struct for struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceRenderPassTransformInfoQCOM.html - struct CommandBufferInheritanceRenderPassTransformInfoQCOM - { - using NativeType = VkCommandBufferInheritanceRenderPassTransformInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderPassTransformInfoQCOM( SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, - Rect2D renderArea_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , transform{ transform_ } - , renderArea{ renderArea_ } - { - } - - VULKAN_HPP_CONSTEXPR - CommandBufferInheritanceRenderPassTransformInfoQCOM( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CommandBufferInheritanceRenderPassTransformInfoQCOM( VkCommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : CommandBufferInheritanceRenderPassTransformInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - CommandBufferInheritanceRenderPassTransformInfoQCOM & - operator=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CommandBufferInheritanceRenderPassTransformInfoQCOM & operator=( VkCommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM & setTransform( SurfaceTransformFlagBitsKHR transform_ ) & VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM && setTransform( SurfaceTransformFlagBitsKHR transform_ ) && VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM & setRenderArea( Rect2D const & renderArea_ ) & VULKAN_HPP_NOEXCEPT - { - renderArea = renderArea_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderPassTransformInfoQCOM && setRenderArea( Rect2D const & renderArea_ ) && VULKAN_HPP_NOEXCEPT - { - renderArea = renderArea_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceRenderPassTransformInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, transform, renderArea ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CommandBufferInheritanceRenderPassTransformInfoQCOM const & ) const = default; -#else - bool operator==( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ) && ( renderArea == rhs.renderArea ); -# endif - } - - bool operator!=( CommandBufferInheritanceRenderPassTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM; - const void * pNext = {}; - SurfaceTransformFlagBitsKHR transform = SurfaceTransformFlagBitsKHR::eIdentity; - Rect2D renderArea = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = CommandBufferInheritanceRenderPassTransformInfoQCOM; - }; - - // wrapper struct for struct VkCommandBufferInheritanceRenderingInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceRenderingInfo.html - struct CommandBufferInheritanceRenderingInfo - { - using NativeType = VkCommandBufferInheritanceRenderingInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceRenderingInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderingInfo( RenderingFlags flags_ = {}, - uint32_t viewMask_ = {}, - uint32_t colorAttachmentCount_ = {}, - const Format * pColorAttachmentFormats_ = {}, - Format depthAttachmentFormat_ = Format::eUndefined, - Format stencilAttachmentFormat_ = Format::eUndefined, - SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , viewMask{ viewMask_ } - , colorAttachmentCount{ colorAttachmentCount_ } - , pColorAttachmentFormats{ pColorAttachmentFormats_ } - , depthAttachmentFormat{ depthAttachmentFormat_ } - , stencilAttachmentFormat{ stencilAttachmentFormat_ } - , rasterizationSamples{ rasterizationSamples_ } - { - } - - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceRenderingInfo( CommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CommandBufferInheritanceRenderingInfo( VkCommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : CommandBufferInheritanceRenderingInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CommandBufferInheritanceRenderingInfo( RenderingFlags flags_, - uint32_t viewMask_, - ArrayProxyNoTemporaries const & colorAttachmentFormats_, - Format depthAttachmentFormat_ = Format::eUndefined, - Format stencilAttachmentFormat_ = Format::eUndefined, - SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , viewMask( viewMask_ ) - , colorAttachmentCount( static_cast( colorAttachmentFormats_.size() ) ) - , pColorAttachmentFormats( colorAttachmentFormats_.data() ) - , depthAttachmentFormat( depthAttachmentFormat_ ) - , stencilAttachmentFormat( stencilAttachmentFormat_ ) - , rasterizationSamples( rasterizationSamples_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CommandBufferInheritanceRenderingInfo & operator=( CommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CommandBufferInheritanceRenderingInfo & operator=( VkCommandBufferInheritanceRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setFlags( RenderingFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setFlags( RenderingFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setViewMask( uint32_t viewMask_ ) & VULKAN_HPP_NOEXCEPT - { - viewMask = viewMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setViewMask( uint32_t viewMask_ ) && VULKAN_HPP_NOEXCEPT - { - viewMask = viewMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) & VULKAN_HPP_NOEXCEPT - { - pColorAttachmentFormats = pColorAttachmentFormats_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) && - VULKAN_HPP_NOEXCEPT - { - pColorAttachmentFormats = pColorAttachmentFormats_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CommandBufferInheritanceRenderingInfo & - setColorAttachmentFormats( ArrayProxyNoTemporaries const & colorAttachmentFormats_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( colorAttachmentFormats_.size() ); - pColorAttachmentFormats = colorAttachmentFormats_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setDepthAttachmentFormat( Format depthAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT - { - depthAttachmentFormat = depthAttachmentFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setDepthAttachmentFormat( Format depthAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT - { - depthAttachmentFormat = depthAttachmentFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT - { - stencilAttachmentFormat = stencilAttachmentFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT - { - stencilAttachmentFormat = stencilAttachmentFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo & setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) & VULKAN_HPP_NOEXCEPT - { - rasterizationSamples = rasterizationSamples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceRenderingInfo && setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) && VULKAN_HPP_NOEXCEPT - { - rasterizationSamples = rasterizationSamples_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCommandBufferInheritanceRenderingInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceRenderingInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceRenderingInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceRenderingInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, flags, viewMask, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat, rasterizationSamples ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CommandBufferInheritanceRenderingInfo const & ) const = default; -#else - bool operator==( CommandBufferInheritanceRenderingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( viewMask == rhs.viewMask ) && - ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && - ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ) && - ( rasterizationSamples == rhs.rasterizationSamples ); -# endif - } - - bool operator!=( CommandBufferInheritanceRenderingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCommandBufferInheritanceRenderingInfo; - const void * pNext = {}; - RenderingFlags flags = {}; - uint32_t viewMask = {}; - uint32_t colorAttachmentCount = {}; - const Format * pColorAttachmentFormats = {}; - Format depthAttachmentFormat = Format::eUndefined; - Format stencilAttachmentFormat = Format::eUndefined; - SampleCountFlagBits rasterizationSamples = SampleCountFlagBits::e1; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CommandBufferInheritanceRenderingInfo; - }; -#endif - - template <> - struct CppType - { - using Type = CommandBufferInheritanceRenderingInfo; - }; - - using CommandBufferInheritanceRenderingInfoKHR = CommandBufferInheritanceRenderingInfo; - - // wrapper struct for struct VkViewport, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViewport.html - struct Viewport - { - using NativeType = VkViewport; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - Viewport( float x_ = {}, float y_ = {}, float width_ = {}, float height_ = {}, float minDepth_ = {}, float maxDepth_ = {} ) VULKAN_HPP_NOEXCEPT - : x{ x_ } - , y{ y_ } - , width{ width_ } - , height{ height_ } - , minDepth{ minDepth_ } - , maxDepth{ maxDepth_ } - { - } - - VULKAN_HPP_CONSTEXPR Viewport( Viewport const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - Viewport( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT : Viewport( *reinterpret_cast( &rhs ) ) {} - - Viewport & operator=( Viewport const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - Viewport & operator=( VkViewport const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 Viewport & setX( float x_ ) & VULKAN_HPP_NOEXCEPT - { - x = x_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Viewport && setX( float x_ ) && VULKAN_HPP_NOEXCEPT - { - x = x_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Viewport & setY( float y_ ) & VULKAN_HPP_NOEXCEPT - { - y = y_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Viewport && setY( float y_ ) && VULKAN_HPP_NOEXCEPT - { - y = y_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Viewport & setWidth( float width_ ) & VULKAN_HPP_NOEXCEPT - { - width = width_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Viewport && setWidth( float width_ ) && VULKAN_HPP_NOEXCEPT - { - width = width_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Viewport & setHeight( float height_ ) & VULKAN_HPP_NOEXCEPT - { - height = height_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Viewport && setHeight( float height_ ) && VULKAN_HPP_NOEXCEPT - { - height = height_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Viewport & setMinDepth( float minDepth_ ) & VULKAN_HPP_NOEXCEPT - { - minDepth = minDepth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Viewport && setMinDepth( float minDepth_ ) && VULKAN_HPP_NOEXCEPT - { - minDepth = minDepth_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Viewport & setMaxDepth( float maxDepth_ ) & VULKAN_HPP_NOEXCEPT - { - maxDepth = maxDepth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Viewport && setMaxDepth( float maxDepth_ ) && VULKAN_HPP_NOEXCEPT - { - maxDepth = maxDepth_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkViewport const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkViewport &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkViewport const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkViewport *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( x, y, width, height, minDepth, maxDepth ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( Viewport const & ) const = default; -#else - bool operator==( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( x == rhs.x ) && ( y == rhs.y ) && ( width == rhs.width ) && ( height == rhs.height ) && ( minDepth == rhs.minDepth ) && - ( maxDepth == rhs.maxDepth ); -# endif - } - - bool operator!=( Viewport const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - float x = {}; - float y = {}; - float width = {}; - float height = {}; - float minDepth = {}; - float maxDepth = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = Viewport; - }; -#endif - - // wrapper struct for struct VkCommandBufferInheritanceViewportScissorInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferInheritanceViewportScissorInfoNV.html - struct CommandBufferInheritanceViewportScissorInfoNV - { - using NativeType = VkCommandBufferInheritanceViewportScissorInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferInheritanceViewportScissorInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CommandBufferInheritanceViewportScissorInfoNV( Bool32 viewportScissor2D_ = {}, - uint32_t viewportDepthCount_ = {}, - const Viewport * pViewportDepths_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , viewportScissor2D{ viewportScissor2D_ } - , viewportDepthCount{ viewportDepthCount_ } - , pViewportDepths{ pViewportDepths_ } - { - } - - VULKAN_HPP_CONSTEXPR - CommandBufferInheritanceViewportScissorInfoNV( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CommandBufferInheritanceViewportScissorInfoNV( VkCommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : CommandBufferInheritanceViewportScissorInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - CommandBufferInheritanceViewportScissorInfoNV & operator=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CommandBufferInheritanceViewportScissorInfoNV & operator=( VkCommandBufferInheritanceViewportScissorInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setViewportScissor2D( Bool32 viewportScissor2D_ ) & VULKAN_HPP_NOEXCEPT - { - viewportScissor2D = viewportScissor2D_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setViewportScissor2D( Bool32 viewportScissor2D_ ) && VULKAN_HPP_NOEXCEPT - { - viewportScissor2D = viewportScissor2D_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setViewportDepthCount( uint32_t viewportDepthCount_ ) & VULKAN_HPP_NOEXCEPT - { - viewportDepthCount = viewportDepthCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setViewportDepthCount( uint32_t viewportDepthCount_ ) && VULKAN_HPP_NOEXCEPT - { - viewportDepthCount = viewportDepthCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV & setPViewportDepths( const Viewport * pViewportDepths_ ) & VULKAN_HPP_NOEXCEPT - { - pViewportDepths = pViewportDepths_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferInheritanceViewportScissorInfoNV && setPViewportDepths( const Viewport * pViewportDepths_ ) && VULKAN_HPP_NOEXCEPT - { - pViewportDepths = pViewportDepths_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCommandBufferInheritanceViewportScissorInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceViewportScissorInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceViewportScissorInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCommandBufferInheritanceViewportScissorInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, viewportScissor2D, viewportDepthCount, pViewportDepths ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CommandBufferInheritanceViewportScissorInfoNV const & ) const = default; -#else - bool operator==( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportScissor2D == rhs.viewportScissor2D ) && - ( viewportDepthCount == rhs.viewportDepthCount ) && ( pViewportDepths == rhs.pViewportDepths ); -# endif - } - - bool operator!=( CommandBufferInheritanceViewportScissorInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCommandBufferInheritanceViewportScissorInfoNV; - const void * pNext = {}; - Bool32 viewportScissor2D = {}; - uint32_t viewportDepthCount = {}; - const Viewport * pViewportDepths = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CommandBufferInheritanceViewportScissorInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = CommandBufferInheritanceViewportScissorInfoNV; - }; - - // wrapper struct for struct VkCommandBufferSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandBufferSubmitInfo.html - struct CommandBufferSubmitInfo - { - using NativeType = VkCommandBufferSubmitInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandBufferSubmitInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - CommandBufferSubmitInfo( CommandBuffer commandBuffer_ = {}, uint32_t deviceMask_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , commandBuffer{ commandBuffer_ } - , deviceMask{ deviceMask_ } - { - } - - VULKAN_HPP_CONSTEXPR CommandBufferSubmitInfo( CommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CommandBufferSubmitInfo( VkCommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : CommandBufferSubmitInfo( *reinterpret_cast( &rhs ) ) - { - } - - CommandBufferSubmitInfo & operator=( CommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CommandBufferSubmitInfo & operator=( VkCommandBufferSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo & setCommandBuffer( CommandBuffer commandBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - commandBuffer = commandBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo && setCommandBuffer( CommandBuffer commandBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - commandBuffer = commandBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT - { - deviceMask = deviceMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandBufferSubmitInfo && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT - { - deviceMask = deviceMask_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCommandBufferSubmitInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferSubmitInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandBufferSubmitInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCommandBufferSubmitInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, commandBuffer, deviceMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CommandBufferSubmitInfo const & ) const = default; -#else - bool operator==( CommandBufferSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBuffer == rhs.commandBuffer ) && ( deviceMask == rhs.deviceMask ); -# endif - } - - bool operator!=( CommandBufferSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCommandBufferSubmitInfo; - const void * pNext = {}; - CommandBuffer commandBuffer = {}; - uint32_t deviceMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CommandBufferSubmitInfo; - }; -#endif - - template <> - struct CppType - { - using Type = CommandBufferSubmitInfo; - }; - - using CommandBufferSubmitInfoKHR = CommandBufferSubmitInfo; - - // wrapper struct for struct VkCommandPoolCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCommandPoolCreateInfo.html - struct CommandPoolCreateInfo - { - using NativeType = VkCommandPoolCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCommandPoolCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - CommandPoolCreateInfo( CommandPoolCreateFlags flags_ = {}, uint32_t queueFamilyIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , queueFamilyIndex{ queueFamilyIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR CommandPoolCreateInfo( CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CommandPoolCreateInfo( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : CommandPoolCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - CommandPoolCreateInfo & operator=( CommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CommandPoolCreateInfo & operator=( VkCommandPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo & setFlags( CommandPoolCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo && setFlags( CommandPoolCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CommandPoolCreateInfo && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCommandPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandPoolCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCommandPoolCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCommandPoolCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, queueFamilyIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CommandPoolCreateInfo const & ) const = default; -#else - bool operator==( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueFamilyIndex == rhs.queueFamilyIndex ); -# endif - } - - bool operator!=( CommandPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCommandPoolCreateInfo; - const void * pNext = {}; - CommandPoolCreateFlags flags = {}; - uint32_t queueFamilyIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CommandPoolCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = CommandPoolCreateInfo; - }; - - // wrapper struct for struct VkComputeOccupancyPriorityParametersNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkComputeOccupancyPriorityParametersNV.html - struct ComputeOccupancyPriorityParametersNV - { - using NativeType = VkComputeOccupancyPriorityParametersNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eComputeOccupancyPriorityParametersNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - ComputeOccupancyPriorityParametersNV( float occupancyPriority_ = {}, float occupancyThrottling_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , occupancyPriority{ occupancyPriority_ } - , occupancyThrottling{ occupancyThrottling_ } - { - } - - VULKAN_HPP_CONSTEXPR ComputeOccupancyPriorityParametersNV( ComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ComputeOccupancyPriorityParametersNV( VkComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ComputeOccupancyPriorityParametersNV( *reinterpret_cast( &rhs ) ) - { - } - - ComputeOccupancyPriorityParametersNV & operator=( ComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ComputeOccupancyPriorityParametersNV & operator=( VkComputeOccupancyPriorityParametersNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV & setOccupancyPriority( float occupancyPriority_ ) & VULKAN_HPP_NOEXCEPT - { - occupancyPriority = occupancyPriority_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV && setOccupancyPriority( float occupancyPriority_ ) && VULKAN_HPP_NOEXCEPT - { - occupancyPriority = occupancyPriority_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV & setOccupancyThrottling( float occupancyThrottling_ ) & VULKAN_HPP_NOEXCEPT - { - occupancyThrottling = occupancyThrottling_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputeOccupancyPriorityParametersNV && setOccupancyThrottling( float occupancyThrottling_ ) && VULKAN_HPP_NOEXCEPT - { - occupancyThrottling = occupancyThrottling_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkComputeOccupancyPriorityParametersNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkComputeOccupancyPriorityParametersNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkComputeOccupancyPriorityParametersNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkComputeOccupancyPriorityParametersNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, occupancyPriority, occupancyThrottling ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ComputeOccupancyPriorityParametersNV const & ) const = default; -#else - bool operator==( ComputeOccupancyPriorityParametersNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( occupancyPriority == rhs.occupancyPriority ) && - ( occupancyThrottling == rhs.occupancyThrottling ); -# endif - } - - bool operator!=( ComputeOccupancyPriorityParametersNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eComputeOccupancyPriorityParametersNV; - const void * pNext = {}; - float occupancyPriority = {}; - float occupancyThrottling = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ComputeOccupancyPriorityParametersNV; - }; -#endif - - template <> - struct CppType - { - using Type = ComputeOccupancyPriorityParametersNV; - }; - - // wrapper struct for struct VkSpecializationMapEntry, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpecializationMapEntry.html - struct SpecializationMapEntry - { - using NativeType = VkSpecializationMapEntry; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SpecializationMapEntry( uint32_t constantID_ = {}, uint32_t offset_ = {}, size_t size_ = {} ) VULKAN_HPP_NOEXCEPT - : constantID{ constantID_ } - , offset{ offset_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR SpecializationMapEntry( SpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SpecializationMapEntry( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT - : SpecializationMapEntry( *reinterpret_cast( &rhs ) ) - { - } - - SpecializationMapEntry & operator=( SpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SpecializationMapEntry & operator=( VkSpecializationMapEntry const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry & setConstantID( uint32_t constantID_ ) & VULKAN_HPP_NOEXCEPT - { - constantID = constantID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry && setConstantID( uint32_t constantID_ ) && VULKAN_HPP_NOEXCEPT - { - constantID = constantID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry & setSize( size_t size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SpecializationMapEntry && setSize( size_t size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSpecializationMapEntry const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSpecializationMapEntry &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSpecializationMapEntry const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSpecializationMapEntry *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( constantID, offset, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SpecializationMapEntry const & ) const = default; -#else - bool operator==( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( constantID == rhs.constantID ) && ( offset == rhs.offset ) && ( size == rhs.size ); -# endif - } - - bool operator!=( SpecializationMapEntry const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t constantID = {}; - uint32_t offset = {}; - size_t size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SpecializationMapEntry; - }; -#endif - - // wrapper struct for struct VkSpecializationInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSpecializationInfo.html - struct SpecializationInfo - { - using NativeType = VkSpecializationInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SpecializationInfo( uint32_t mapEntryCount_ = {}, - const SpecializationMapEntry * pMapEntries_ = {}, - size_t dataSize_ = {}, - const void * pData_ = {} ) VULKAN_HPP_NOEXCEPT - : mapEntryCount{ mapEntryCount_ } - , pMapEntries{ pMapEntries_ } - , dataSize{ dataSize_ } - , pData{ pData_ } - { - } - - VULKAN_HPP_CONSTEXPR SpecializationInfo( SpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SpecializationInfo( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SpecializationInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - SpecializationInfo( ArrayProxyNoTemporaries const & mapEntries_, ArrayProxyNoTemporaries const & data_ = {} ) - : mapEntryCount( static_cast( mapEntries_.size() ) ) - , pMapEntries( mapEntries_.data() ) - , dataSize( data_.size() * sizeof( T ) ) - , pData( data_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SpecializationInfo & operator=( SpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SpecializationInfo & operator=( VkSpecializationInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setMapEntryCount( uint32_t mapEntryCount_ ) & VULKAN_HPP_NOEXCEPT - { - mapEntryCount = mapEntryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setMapEntryCount( uint32_t mapEntryCount_ ) && VULKAN_HPP_NOEXCEPT - { - mapEntryCount = mapEntryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setPMapEntries( const SpecializationMapEntry * pMapEntries_ ) & VULKAN_HPP_NOEXCEPT - { - pMapEntries = pMapEntries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setPMapEntries( const SpecializationMapEntry * pMapEntries_ ) && VULKAN_HPP_NOEXCEPT - { - pMapEntries = pMapEntries_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SpecializationInfo & setMapEntries( ArrayProxyNoTemporaries const & mapEntries_ ) VULKAN_HPP_NOEXCEPT - { - mapEntryCount = static_cast( mapEntries_.size() ); - pMapEntries = mapEntries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SpecializationInfo & setPData( const void * pData_ ) & VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SpecializationInfo && setPData( const void * pData_ ) && VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - SpecializationInfo & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT - { - dataSize = data_.size() * sizeof( T ); - pData = data_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSpecializationInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSpecializationInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSpecializationInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSpecializationInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( mapEntryCount, pMapEntries, dataSize, pData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SpecializationInfo const & ) const = default; -#else - bool operator==( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( mapEntryCount == rhs.mapEntryCount ) && ( pMapEntries == rhs.pMapEntries ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); -# endif - } - - bool operator!=( SpecializationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t mapEntryCount = {}; - const SpecializationMapEntry * pMapEntries = {}; - size_t dataSize = {}; - const void * pData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SpecializationInfo; - }; -#endif - - // wrapper struct for struct VkPipelineShaderStageCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageCreateInfo.html - struct PipelineShaderStageCreateInfo - { - using NativeType = VkPipelineShaderStageCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( PipelineShaderStageCreateFlags flags_ = {}, - ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, - ShaderModule module_ = {}, - const char * pName_ = {}, - const SpecializationInfo * pSpecializationInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , stage{ stage_ } - , module{ module_ } - , pName{ pName_ } - , pSpecializationInfo{ pSpecializationInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineShaderStageCreateInfo( PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineShaderStageCreateInfo( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineShaderStageCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PipelineShaderStageCreateInfo & operator=( PipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineShaderStageCreateInfo & operator=( VkPipelineShaderStageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setFlags( PipelineShaderStageCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setFlags( PipelineShaderStageCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setStage( ShaderStageFlagBits stage_ ) & VULKAN_HPP_NOEXCEPT - { - stage = stage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setStage( ShaderStageFlagBits stage_ ) && VULKAN_HPP_NOEXCEPT - { - stage = stage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setModule( ShaderModule module_ ) & VULKAN_HPP_NOEXCEPT - { - module = module_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setModule( ShaderModule module_ ) && VULKAN_HPP_NOEXCEPT - { - module = module_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo & setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pSpecializationInfo = pSpecializationInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageCreateInfo && setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pSpecializationInfo = pSpecializationInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineShaderStageCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineShaderStageCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineShaderStageCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineShaderStageCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, stage, module, pName, pSpecializationInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = stage <=> rhs.stage; cmp != 0 ) - return cmp; - if ( auto cmp = module <=> rhs.module; cmp != 0 ) - return cmp; - if ( pName != rhs.pName ) - if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = pSpecializationInfo <=> rhs.pSpecializationInfo; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( module == rhs.module ) && - ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( pSpecializationInfo == rhs.pSpecializationInfo ); - } - - bool operator!=( PipelineShaderStageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::ePipelineShaderStageCreateInfo; - const void * pNext = {}; - PipelineShaderStageCreateFlags flags = {}; - ShaderStageFlagBits stage = ShaderStageFlagBits::eVertex; - ShaderModule module = {}; - const char * pName = {}; - const SpecializationInfo * pSpecializationInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineShaderStageCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineShaderStageCreateInfo; - }; - - // wrapper struct for struct VkComputePipelineCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkComputePipelineCreateInfo.html - struct ComputePipelineCreateInfo - { - using NativeType = VkComputePipelineCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eComputePipelineCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( PipelineCreateFlags flags_ = {}, - PipelineShaderStageCreateInfo stage_ = {}, - PipelineLayout layout_ = {}, - Pipeline basePipelineHandle_ = {}, - int32_t basePipelineIndex_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , stage{ stage_ } - , layout{ layout_ } - , basePipelineHandle{ basePipelineHandle_ } - , basePipelineIndex{ basePipelineIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR ComputePipelineCreateInfo( ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ComputePipelineCreateInfo( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : ComputePipelineCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - ComputePipelineCreateInfo & operator=( ComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ComputePipelineCreateInfo & operator=( VkComputePipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setFlags( PipelineCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setFlags( PipelineCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setStage( PipelineShaderStageCreateInfo const & stage_ ) & VULKAN_HPP_NOEXCEPT - { - stage = stage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setStage( PipelineShaderStageCreateInfo const & stage_ ) && VULKAN_HPP_NOEXCEPT - { - stage = stage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setBasePipelineHandle( Pipeline basePipelineHandle_ ) & VULKAN_HPP_NOEXCEPT - { - basePipelineHandle = basePipelineHandle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setBasePipelineHandle( Pipeline basePipelineHandle_ ) && VULKAN_HPP_NOEXCEPT - { - basePipelineHandle = basePipelineHandle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo & setBasePipelineIndex( int32_t basePipelineIndex_ ) & VULKAN_HPP_NOEXCEPT - { - basePipelineIndex = basePipelineIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineCreateInfo && setBasePipelineIndex( int32_t basePipelineIndex_ ) && VULKAN_HPP_NOEXCEPT - { - basePipelineIndex = basePipelineIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkComputePipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkComputePipelineCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkComputePipelineCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkComputePipelineCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, stage, layout, basePipelineHandle, basePipelineIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ComputePipelineCreateInfo const & ) const = default; -#else - bool operator==( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( layout == rhs.layout ) && - ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex ); -# endif - } - - bool operator!=( ComputePipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eComputePipelineCreateInfo; - const void * pNext = {}; - PipelineCreateFlags flags = {}; - PipelineShaderStageCreateInfo stage = {}; - PipelineLayout layout = {}; - Pipeline basePipelineHandle = {}; - int32_t basePipelineIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ComputePipelineCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ComputePipelineCreateInfo; - }; - - // wrapper struct for struct VkComputePipelineIndirectBufferInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkComputePipelineIndirectBufferInfoNV.html - struct ComputePipelineIndirectBufferInfoNV - { - using NativeType = VkComputePipelineIndirectBufferInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eComputePipelineIndirectBufferInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ComputePipelineIndirectBufferInfoNV( DeviceAddress deviceAddress_ = {}, - DeviceSize size_ = {}, - DeviceAddress pipelineDeviceAddressCaptureReplay_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceAddress{ deviceAddress_ } - , size{ size_ } - , pipelineDeviceAddressCaptureReplay{ pipelineDeviceAddressCaptureReplay_ } - { - } - - VULKAN_HPP_CONSTEXPR ComputePipelineIndirectBufferInfoNV( ComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ComputePipelineIndirectBufferInfoNV( VkComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ComputePipelineIndirectBufferInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ComputePipelineIndirectBufferInfoNV & operator=( ComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ComputePipelineIndirectBufferInfoNV & operator=( VkComputePipelineIndirectBufferInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV & setPipelineDeviceAddressCaptureReplay( DeviceAddress pipelineDeviceAddressCaptureReplay_ ) & - VULKAN_HPP_NOEXCEPT - { - pipelineDeviceAddressCaptureReplay = pipelineDeviceAddressCaptureReplay_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ComputePipelineIndirectBufferInfoNV && setPipelineDeviceAddressCaptureReplay( DeviceAddress pipelineDeviceAddressCaptureReplay_ ) && - VULKAN_HPP_NOEXCEPT - { - pipelineDeviceAddressCaptureReplay = pipelineDeviceAddressCaptureReplay_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkComputePipelineIndirectBufferInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkComputePipelineIndirectBufferInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkComputePipelineIndirectBufferInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkComputePipelineIndirectBufferInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceAddress, size, pipelineDeviceAddressCaptureReplay ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ComputePipelineIndirectBufferInfoNV const & ) const = default; -#else - bool operator==( ComputePipelineIndirectBufferInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) && ( size == rhs.size ) && - ( pipelineDeviceAddressCaptureReplay == rhs.pipelineDeviceAddressCaptureReplay ); -# endif - } - - bool operator!=( ComputePipelineIndirectBufferInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eComputePipelineIndirectBufferInfoNV; - const void * pNext = {}; - DeviceAddress deviceAddress = {}; - DeviceSize size = {}; - DeviceAddress pipelineDeviceAddressCaptureReplay = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ComputePipelineIndirectBufferInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = ComputePipelineIndirectBufferInfoNV; - }; - - // wrapper struct for struct VkConditionalRenderingBeginInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConditionalRenderingBeginInfoEXT.html - struct ConditionalRenderingBeginInfoEXT - { - using NativeType = VkConditionalRenderingBeginInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eConditionalRenderingBeginInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( Buffer buffer_ = {}, - DeviceSize offset_ = {}, - ConditionalRenderingFlagsEXT flags_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , buffer{ buffer_ } - , offset{ offset_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR ConditionalRenderingBeginInfoEXT( ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ConditionalRenderingBeginInfoEXT( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ConditionalRenderingBeginInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ConditionalRenderingBeginInfoEXT & operator=( ConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ConditionalRenderingBeginInfoEXT & operator=( VkConditionalRenderingBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT & setFlags( ConditionalRenderingFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConditionalRenderingBeginInfoEXT && setFlags( ConditionalRenderingFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkConditionalRenderingBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkConditionalRenderingBeginInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkConditionalRenderingBeginInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkConditionalRenderingBeginInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, buffer, offset, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ConditionalRenderingBeginInfoEXT const & ) const = default; -#else - bool operator==( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( ConditionalRenderingBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eConditionalRenderingBeginInfoEXT; - const void * pNext = {}; - Buffer buffer = {}; - DeviceSize offset = {}; - ConditionalRenderingFlagsEXT flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ConditionalRenderingBeginInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ConditionalRenderingBeginInfoEXT; - }; - - // wrapper struct for struct VkConformanceVersion, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkConformanceVersion.html - struct ConformanceVersion - { - using NativeType = VkConformanceVersion; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ConformanceVersion( uint8_t major_ = {}, uint8_t minor_ = {}, uint8_t subminor_ = {}, uint8_t patch_ = {} ) VULKAN_HPP_NOEXCEPT - : major{ major_ } - , minor{ minor_ } - , subminor{ subminor_ } - , patch{ patch_ } - { - } - - VULKAN_HPP_CONSTEXPR ConformanceVersion( ConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ConformanceVersion( VkConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT : ConformanceVersion( *reinterpret_cast( &rhs ) ) {} - - ConformanceVersion & operator=( ConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ConformanceVersion & operator=( VkConformanceVersion const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setMajor( uint8_t major_ ) & VULKAN_HPP_NOEXCEPT - { - major = major_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setMajor( uint8_t major_ ) && VULKAN_HPP_NOEXCEPT - { - major = major_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setMinor( uint8_t minor_ ) & VULKAN_HPP_NOEXCEPT - { - minor = minor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setMinor( uint8_t minor_ ) && VULKAN_HPP_NOEXCEPT - { - minor = minor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setSubminor( uint8_t subminor_ ) & VULKAN_HPP_NOEXCEPT - { - subminor = subminor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setSubminor( uint8_t subminor_ ) && VULKAN_HPP_NOEXCEPT - { - subminor = subminor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConformanceVersion & setPatch( uint8_t patch_ ) & VULKAN_HPP_NOEXCEPT - { - patch = patch_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConformanceVersion && setPatch( uint8_t patch_ ) && VULKAN_HPP_NOEXCEPT - { - patch = patch_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkConformanceVersion const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkConformanceVersion &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkConformanceVersion const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkConformanceVersion *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( major, minor, subminor, patch ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ConformanceVersion const & ) const = default; -#else - bool operator==( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( major == rhs.major ) && ( minor == rhs.minor ) && ( subminor == rhs.subminor ) && ( patch == rhs.patch ); -# endif - } - - bool operator!=( ConformanceVersion const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint8_t major = {}; - uint8_t minor = {}; - uint8_t subminor = {}; - uint8_t patch = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ConformanceVersion; - }; -#endif - using ConformanceVersionKHR = ConformanceVersion; - - // wrapper struct for struct VkConvertCooperativeVectorMatrixInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkConvertCooperativeVectorMatrixInfoNV.html - struct ConvertCooperativeVectorMatrixInfoNV - { - using NativeType = VkConvertCooperativeVectorMatrixInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eConvertCooperativeVectorMatrixInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV( size_t srcSize_ = {}, - DeviceOrHostAddressConstKHR srcData_ = {}, - size_t * pDstSize_ = {}, - DeviceOrHostAddressKHR dstData_ = {}, - ComponentTypeKHR srcComponentType_ = ComponentTypeKHR::eFloat16, - ComponentTypeKHR dstComponentType_ = ComponentTypeKHR::eFloat16, - uint32_t numRows_ = {}, - uint32_t numColumns_ = {}, - CooperativeVectorMatrixLayoutNV srcLayout_ = CooperativeVectorMatrixLayoutNV::eRowMajor, - size_t srcStride_ = {}, - CooperativeVectorMatrixLayoutNV dstLayout_ = CooperativeVectorMatrixLayoutNV::eRowMajor, - size_t dstStride_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcSize{ srcSize_ } - , srcData{ srcData_ } - , pDstSize{ pDstSize_ } - , dstData{ dstData_ } - , srcComponentType{ srcComponentType_ } - , dstComponentType{ dstComponentType_ } - , numRows{ numRows_ } - , numColumns{ numColumns_ } - , srcLayout{ srcLayout_ } - , srcStride{ srcStride_ } - , dstLayout{ dstLayout_ } - , dstStride{ dstStride_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV( ConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ConvertCooperativeVectorMatrixInfoNV( VkConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ConvertCooperativeVectorMatrixInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ConvertCooperativeVectorMatrixInfoNV & operator=( ConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ConvertCooperativeVectorMatrixInfoNV & operator=( VkConvertCooperativeVectorMatrixInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcSize( size_t srcSize_ ) & VULKAN_HPP_NOEXCEPT - { - srcSize = srcSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcSize( size_t srcSize_ ) && VULKAN_HPP_NOEXCEPT - { - srcSize = srcSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcData( DeviceOrHostAddressConstKHR const & srcData_ ) & VULKAN_HPP_NOEXCEPT - { - srcData = srcData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcData( DeviceOrHostAddressConstKHR const & srcData_ ) && VULKAN_HPP_NOEXCEPT - { - srcData = srcData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setPDstSize( size_t * pDstSize_ ) & VULKAN_HPP_NOEXCEPT - { - pDstSize = pDstSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setPDstSize( size_t * pDstSize_ ) && VULKAN_HPP_NOEXCEPT - { - pDstSize = pDstSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstData( DeviceOrHostAddressKHR const & dstData_ ) & VULKAN_HPP_NOEXCEPT - { - dstData = dstData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstData( DeviceOrHostAddressKHR const & dstData_ ) && VULKAN_HPP_NOEXCEPT - { - dstData = dstData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcComponentType( ComponentTypeKHR srcComponentType_ ) & VULKAN_HPP_NOEXCEPT - { - srcComponentType = srcComponentType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcComponentType( ComponentTypeKHR srcComponentType_ ) && VULKAN_HPP_NOEXCEPT - { - srcComponentType = srcComponentType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstComponentType( ComponentTypeKHR dstComponentType_ ) & VULKAN_HPP_NOEXCEPT - { - dstComponentType = dstComponentType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstComponentType( ComponentTypeKHR dstComponentType_ ) && VULKAN_HPP_NOEXCEPT - { - dstComponentType = dstComponentType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setNumRows( uint32_t numRows_ ) & VULKAN_HPP_NOEXCEPT - { - numRows = numRows_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setNumRows( uint32_t numRows_ ) && VULKAN_HPP_NOEXCEPT - { - numRows = numRows_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setNumColumns( uint32_t numColumns_ ) & VULKAN_HPP_NOEXCEPT - { - numColumns = numColumns_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setNumColumns( uint32_t numColumns_ ) && VULKAN_HPP_NOEXCEPT - { - numColumns = numColumns_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcLayout( CooperativeVectorMatrixLayoutNV srcLayout_ ) & VULKAN_HPP_NOEXCEPT - { - srcLayout = srcLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcLayout( CooperativeVectorMatrixLayoutNV srcLayout_ ) && VULKAN_HPP_NOEXCEPT - { - srcLayout = srcLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setSrcStride( size_t srcStride_ ) & VULKAN_HPP_NOEXCEPT - { - srcStride = srcStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setSrcStride( size_t srcStride_ ) && VULKAN_HPP_NOEXCEPT - { - srcStride = srcStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstLayout( CooperativeVectorMatrixLayoutNV dstLayout_ ) & VULKAN_HPP_NOEXCEPT - { - dstLayout = dstLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstLayout( CooperativeVectorMatrixLayoutNV dstLayout_ ) && VULKAN_HPP_NOEXCEPT - { - dstLayout = dstLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV & setDstStride( size_t dstStride_ ) & VULKAN_HPP_NOEXCEPT - { - dstStride = dstStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ConvertCooperativeVectorMatrixInfoNV && setDstStride( size_t dstStride_ ) && VULKAN_HPP_NOEXCEPT - { - dstStride = dstStride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkConvertCooperativeVectorMatrixInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkConvertCooperativeVectorMatrixInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkConvertCooperativeVectorMatrixInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkConvertCooperativeVectorMatrixInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - srcSize, - srcData, - pDstSize, - dstData, - srcComponentType, - dstComponentType, - numRows, - numColumns, - srcLayout, - srcStride, - dstLayout, - dstStride ); - } -#endif - - public: - StructureType sType = StructureType::eConvertCooperativeVectorMatrixInfoNV; - const void * pNext = {}; - size_t srcSize = {}; - DeviceOrHostAddressConstKHR srcData = {}; - size_t * pDstSize = {}; - DeviceOrHostAddressKHR dstData = {}; - ComponentTypeKHR srcComponentType = ComponentTypeKHR::eFloat16; - ComponentTypeKHR dstComponentType = ComponentTypeKHR::eFloat16; - uint32_t numRows = {}; - uint32_t numColumns = {}; - CooperativeVectorMatrixLayoutNV srcLayout = CooperativeVectorMatrixLayoutNV::eRowMajor; - size_t srcStride = {}; - CooperativeVectorMatrixLayoutNV dstLayout = CooperativeVectorMatrixLayoutNV::eRowMajor; - size_t dstStride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ConvertCooperativeVectorMatrixInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = ConvertCooperativeVectorMatrixInfoNV; - }; - - // wrapper struct for struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixFlexibleDimensionsPropertiesNV.html - struct CooperativeMatrixFlexibleDimensionsPropertiesNV - { - using NativeType = VkCooperativeMatrixFlexibleDimensionsPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CooperativeMatrixFlexibleDimensionsPropertiesNV( uint32_t MGranularity_ = {}, - uint32_t NGranularity_ = {}, - uint32_t KGranularity_ = {}, - ComponentTypeKHR AType_ = ComponentTypeKHR::eFloat16, - ComponentTypeKHR BType_ = ComponentTypeKHR::eFloat16, - ComponentTypeKHR CType_ = ComponentTypeKHR::eFloat16, - ComponentTypeKHR ResultType_ = ComponentTypeKHR::eFloat16, - Bool32 saturatingAccumulation_ = {}, - ScopeKHR scope_ = ScopeKHR::eDevice, - uint32_t workgroupInvocations_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , MGranularity{ MGranularity_ } - , NGranularity{ NGranularity_ } - , KGranularity{ KGranularity_ } - , AType{ AType_ } - , BType{ BType_ } - , CType{ CType_ } - , ResultType{ ResultType_ } - , saturatingAccumulation{ saturatingAccumulation_ } - , scope{ scope_ } - , workgroupInvocations{ workgroupInvocations_ } - { - } - - VULKAN_HPP_CONSTEXPR - CooperativeMatrixFlexibleDimensionsPropertiesNV( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CooperativeMatrixFlexibleDimensionsPropertiesNV( VkCooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : CooperativeMatrixFlexibleDimensionsPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - CooperativeMatrixFlexibleDimensionsPropertiesNV & operator=( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CooperativeMatrixFlexibleDimensionsPropertiesNV & operator=( VkCooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCooperativeMatrixFlexibleDimensionsPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, MGranularity, NGranularity, KGranularity, AType, BType, CType, ResultType, saturatingAccumulation, scope, workgroupInvocations ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CooperativeMatrixFlexibleDimensionsPropertiesNV const & ) const = default; -#else - bool operator==( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MGranularity == rhs.MGranularity ) && ( NGranularity == rhs.NGranularity ) && - ( KGranularity == rhs.KGranularity ) && ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) && - ( ResultType == rhs.ResultType ) && ( saturatingAccumulation == rhs.saturatingAccumulation ) && ( scope == rhs.scope ) && - ( workgroupInvocations == rhs.workgroupInvocations ); -# endif - } - - bool operator!=( CooperativeMatrixFlexibleDimensionsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV; - void * pNext = {}; - uint32_t MGranularity = {}; - uint32_t NGranularity = {}; - uint32_t KGranularity = {}; - ComponentTypeKHR AType = ComponentTypeKHR::eFloat16; - ComponentTypeKHR BType = ComponentTypeKHR::eFloat16; - ComponentTypeKHR CType = ComponentTypeKHR::eFloat16; - ComponentTypeKHR ResultType = ComponentTypeKHR::eFloat16; - Bool32 saturatingAccumulation = {}; - ScopeKHR scope = ScopeKHR::eDevice; - uint32_t workgroupInvocations = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CooperativeMatrixFlexibleDimensionsPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = CooperativeMatrixFlexibleDimensionsPropertiesNV; - }; - - // wrapper struct for struct VkCooperativeMatrixPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixPropertiesKHR.html - struct CooperativeMatrixPropertiesKHR - { - using NativeType = VkCooperativeMatrixPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCooperativeMatrixPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesKHR( uint32_t MSize_ = {}, - uint32_t NSize_ = {}, - uint32_t KSize_ = {}, - ComponentTypeKHR AType_ = ComponentTypeKHR::eFloat16, - ComponentTypeKHR BType_ = ComponentTypeKHR::eFloat16, - ComponentTypeKHR CType_ = ComponentTypeKHR::eFloat16, - ComponentTypeKHR ResultType_ = ComponentTypeKHR::eFloat16, - Bool32 saturatingAccumulation_ = {}, - ScopeKHR scope_ = ScopeKHR::eDevice, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , MSize{ MSize_ } - , NSize{ NSize_ } - , KSize{ KSize_ } - , AType{ AType_ } - , BType{ BType_ } - , CType{ CType_ } - , ResultType{ ResultType_ } - , saturatingAccumulation{ saturatingAccumulation_ } - , scope{ scope_ } - { - } - - VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesKHR( CooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CooperativeMatrixPropertiesKHR( VkCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : CooperativeMatrixPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - CooperativeMatrixPropertiesKHR & operator=( CooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CooperativeMatrixPropertiesKHR & operator=( VkCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkCooperativeMatrixPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCooperativeMatrixPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCooperativeMatrixPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCooperativeMatrixPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, ResultType, saturatingAccumulation, scope ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CooperativeMatrixPropertiesKHR const & ) const = default; -#else - bool operator==( CooperativeMatrixPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) && ( KSize == rhs.KSize ) && - ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) && ( ResultType == rhs.ResultType ) && - ( saturatingAccumulation == rhs.saturatingAccumulation ) && ( scope == rhs.scope ); -# endif - } - - bool operator!=( CooperativeMatrixPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCooperativeMatrixPropertiesKHR; - void * pNext = {}; - uint32_t MSize = {}; - uint32_t NSize = {}; - uint32_t KSize = {}; - ComponentTypeKHR AType = ComponentTypeKHR::eFloat16; - ComponentTypeKHR BType = ComponentTypeKHR::eFloat16; - ComponentTypeKHR CType = ComponentTypeKHR::eFloat16; - ComponentTypeKHR ResultType = ComponentTypeKHR::eFloat16; - Bool32 saturatingAccumulation = {}; - ScopeKHR scope = ScopeKHR::eDevice; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CooperativeMatrixPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = CooperativeMatrixPropertiesKHR; - }; - - // wrapper struct for struct VkCooperativeMatrixPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeMatrixPropertiesNV.html - struct CooperativeMatrixPropertiesNV - { - using NativeType = VkCooperativeMatrixPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCooperativeMatrixPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( uint32_t MSize_ = {}, - uint32_t NSize_ = {}, - uint32_t KSize_ = {}, - ComponentTypeNV AType_ = {}, - ComponentTypeNV BType_ = {}, - ComponentTypeNV CType_ = {}, - ComponentTypeNV DType_ = {}, - ScopeNV scope_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , MSize{ MSize_ } - , NSize{ NSize_ } - , KSize{ KSize_ } - , AType{ AType_ } - , BType{ BType_ } - , CType{ CType_ } - , DType{ DType_ } - , scope{ scope_ } - { - } - - VULKAN_HPP_CONSTEXPR CooperativeMatrixPropertiesNV( CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CooperativeMatrixPropertiesNV( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : CooperativeMatrixPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - CooperativeMatrixPropertiesNV & operator=( CooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CooperativeMatrixPropertiesNV & operator=( VkCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCooperativeMatrixPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCooperativeMatrixPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, MSize, NSize, KSize, AType, BType, CType, DType, scope ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CooperativeMatrixPropertiesNV const & ) const = default; -#else - bool operator==( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( MSize == rhs.MSize ) && ( NSize == rhs.NSize ) && ( KSize == rhs.KSize ) && - ( AType == rhs.AType ) && ( BType == rhs.BType ) && ( CType == rhs.CType ) && ( DType == rhs.DType ) && ( scope == rhs.scope ); -# endif - } - - bool operator!=( CooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCooperativeMatrixPropertiesNV; - void * pNext = {}; - uint32_t MSize = {}; - uint32_t NSize = {}; - uint32_t KSize = {}; - ComponentTypeNV AType = {}; - ComponentTypeNV BType = {}; - ComponentTypeNV CType = {}; - ComponentTypeNV DType = {}; - ScopeNV scope = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CooperativeMatrixPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = CooperativeMatrixPropertiesNV; - }; - - // wrapper struct for struct VkCooperativeVectorPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCooperativeVectorPropertiesNV.html - struct CooperativeVectorPropertiesNV - { - using NativeType = VkCooperativeVectorPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCooperativeVectorPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CooperativeVectorPropertiesNV( ComponentTypeKHR inputType_ = ComponentTypeKHR::eFloat16, - ComponentTypeKHR inputInterpretation_ = ComponentTypeKHR::eFloat16, - ComponentTypeKHR matrixInterpretation_ = ComponentTypeKHR::eFloat16, - ComponentTypeKHR biasInterpretation_ = ComponentTypeKHR::eFloat16, - ComponentTypeKHR resultType_ = ComponentTypeKHR::eFloat16, - Bool32 transpose_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , inputType{ inputType_ } - , inputInterpretation{ inputInterpretation_ } - , matrixInterpretation{ matrixInterpretation_ } - , biasInterpretation{ biasInterpretation_ } - , resultType{ resultType_ } - , transpose{ transpose_ } - { - } - - VULKAN_HPP_CONSTEXPR CooperativeVectorPropertiesNV( CooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CooperativeVectorPropertiesNV( VkCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : CooperativeVectorPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - CooperativeVectorPropertiesNV & operator=( CooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CooperativeVectorPropertiesNV & operator=( VkCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setInputType( ComponentTypeKHR inputType_ ) & VULKAN_HPP_NOEXCEPT - { - inputType = inputType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setInputType( ComponentTypeKHR inputType_ ) && VULKAN_HPP_NOEXCEPT - { - inputType = inputType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setInputInterpretation( ComponentTypeKHR inputInterpretation_ ) & VULKAN_HPP_NOEXCEPT - { - inputInterpretation = inputInterpretation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setInputInterpretation( ComponentTypeKHR inputInterpretation_ ) && VULKAN_HPP_NOEXCEPT - { - inputInterpretation = inputInterpretation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setMatrixInterpretation( ComponentTypeKHR matrixInterpretation_ ) & VULKAN_HPP_NOEXCEPT - { - matrixInterpretation = matrixInterpretation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setMatrixInterpretation( ComponentTypeKHR matrixInterpretation_ ) && VULKAN_HPP_NOEXCEPT - { - matrixInterpretation = matrixInterpretation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setBiasInterpretation( ComponentTypeKHR biasInterpretation_ ) & VULKAN_HPP_NOEXCEPT - { - biasInterpretation = biasInterpretation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setBiasInterpretation( ComponentTypeKHR biasInterpretation_ ) && VULKAN_HPP_NOEXCEPT - { - biasInterpretation = biasInterpretation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setResultType( ComponentTypeKHR resultType_ ) & VULKAN_HPP_NOEXCEPT - { - resultType = resultType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setResultType( ComponentTypeKHR resultType_ ) && VULKAN_HPP_NOEXCEPT - { - resultType = resultType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV & setTranspose( Bool32 transpose_ ) & VULKAN_HPP_NOEXCEPT - { - transpose = transpose_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CooperativeVectorPropertiesNV && setTranspose( Bool32 transpose_ ) && VULKAN_HPP_NOEXCEPT - { - transpose = transpose_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCooperativeVectorPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCooperativeVectorPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCooperativeVectorPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCooperativeVectorPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, inputType, inputInterpretation, matrixInterpretation, biasInterpretation, resultType, transpose ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CooperativeVectorPropertiesNV const & ) const = default; -#else - bool operator==( CooperativeVectorPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inputType == rhs.inputType ) && ( inputInterpretation == rhs.inputInterpretation ) && - ( matrixInterpretation == rhs.matrixInterpretation ) && ( biasInterpretation == rhs.biasInterpretation ) && ( resultType == rhs.resultType ) && - ( transpose == rhs.transpose ); -# endif - } - - bool operator!=( CooperativeVectorPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCooperativeVectorPropertiesNV; - void * pNext = {}; - ComponentTypeKHR inputType = ComponentTypeKHR::eFloat16; - ComponentTypeKHR inputInterpretation = ComponentTypeKHR::eFloat16; - ComponentTypeKHR matrixInterpretation = ComponentTypeKHR::eFloat16; - ComponentTypeKHR biasInterpretation = ComponentTypeKHR::eFloat16; - ComponentTypeKHR resultType = ComponentTypeKHR::eFloat16; - Bool32 transpose = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CooperativeVectorPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = CooperativeVectorPropertiesNV; - }; - - // wrapper struct for struct VkCopyAccelerationStructureInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyAccelerationStructureInfoKHR.html - struct CopyAccelerationStructureInfoKHR - { - using NativeType = VkCopyAccelerationStructureInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyAccelerationStructureInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyAccelerationStructureInfoKHR( AccelerationStructureKHR src_ = {}, - AccelerationStructureKHR dst_ = {}, - CopyAccelerationStructureModeKHR mode_ = CopyAccelerationStructureModeKHR::eClone, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , src{ src_ } - , dst{ dst_ } - , mode{ mode_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyAccelerationStructureInfoKHR( CopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyAccelerationStructureInfoKHR( VkCopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyAccelerationStructureInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - CopyAccelerationStructureInfoKHR & operator=( CopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyAccelerationStructureInfoKHR & operator=( VkCopyAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setSrc( AccelerationStructureKHR src_ ) & VULKAN_HPP_NOEXCEPT - { - src = src_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setSrc( AccelerationStructureKHR src_ ) && VULKAN_HPP_NOEXCEPT - { - src = src_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setDst( AccelerationStructureKHR dst_ ) & VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setDst( AccelerationStructureKHR dst_ ) && VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR & setMode( CopyAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureInfoKHR && setMode( CopyAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyAccelerationStructureInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyAccelerationStructureInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, src, dst, mode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyAccelerationStructureInfoKHR const & ) const = default; -#else - bool operator==( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) && ( mode == rhs.mode ); -# endif - } - - bool operator!=( CopyAccelerationStructureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyAccelerationStructureInfoKHR; - const void * pNext = {}; - AccelerationStructureKHR src = {}; - AccelerationStructureKHR dst = {}; - CopyAccelerationStructureModeKHR mode = CopyAccelerationStructureModeKHR::eClone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyAccelerationStructureInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = CopyAccelerationStructureInfoKHR; - }; - - // wrapper struct for struct VkCopyAccelerationStructureToMemoryInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyAccelerationStructureToMemoryInfoKHR.html - struct CopyAccelerationStructureToMemoryInfoKHR - { - using NativeType = VkCopyAccelerationStructureToMemoryInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR( AccelerationStructureKHR src_ = {}, - DeviceOrHostAddressKHR dst_ = {}, - CopyAccelerationStructureModeKHR mode_ = CopyAccelerationStructureModeKHR::eClone, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , src{ src_ } - , dst{ dst_ } - , mode{ mode_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR( CopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyAccelerationStructureToMemoryInfoKHR( VkCopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyAccelerationStructureToMemoryInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - CopyAccelerationStructureToMemoryInfoKHR & operator=( CopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyAccelerationStructureToMemoryInfoKHR & operator=( VkCopyAccelerationStructureToMemoryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setSrc( AccelerationStructureKHR src_ ) & VULKAN_HPP_NOEXCEPT - { - src = src_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setSrc( AccelerationStructureKHR src_ ) && VULKAN_HPP_NOEXCEPT - { - src = src_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setDst( DeviceOrHostAddressKHR const & dst_ ) & VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setDst( DeviceOrHostAddressKHR const & dst_ ) && VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR & setMode( CopyAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyAccelerationStructureToMemoryInfoKHR && setMode( CopyAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyAccelerationStructureToMemoryInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyAccelerationStructureToMemoryInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyAccelerationStructureToMemoryInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyAccelerationStructureToMemoryInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, src, dst, mode ); - } -#endif - - public: - StructureType sType = StructureType::eCopyAccelerationStructureToMemoryInfoKHR; - const void * pNext = {}; - AccelerationStructureKHR src = {}; - DeviceOrHostAddressKHR dst = {}; - CopyAccelerationStructureModeKHR mode = CopyAccelerationStructureModeKHR::eClone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyAccelerationStructureToMemoryInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = CopyAccelerationStructureToMemoryInfoKHR; - }; - - // wrapper struct for struct VkCopyBufferInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyBufferInfo2.html - struct CopyBufferInfo2 - { - using NativeType = VkCopyBufferInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyBufferInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyBufferInfo2( Buffer srcBuffer_ = {}, - Buffer dstBuffer_ = {}, - uint32_t regionCount_ = {}, - const BufferCopy2 * pRegions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcBuffer{ srcBuffer_ } - , dstBuffer{ dstBuffer_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyBufferInfo2( CopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyBufferInfo2( VkCopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : CopyBufferInfo2( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyBufferInfo2( Buffer srcBuffer_, Buffer dstBuffer_, ArrayProxyNoTemporaries const & regions_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), srcBuffer( srcBuffer_ ), dstBuffer( dstBuffer_ ), regionCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CopyBufferInfo2 & operator=( CopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyBufferInfo2 & operator=( VkCopyBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setSrcBuffer( Buffer srcBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - srcBuffer = srcBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setSrcBuffer( Buffer srcBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - srcBuffer = srcBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setDstBuffer( Buffer dstBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - dstBuffer = dstBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setDstBuffer( Buffer dstBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - dstBuffer = dstBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 & setPRegions( const BufferCopy2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferInfo2 && setPRegions( const BufferCopy2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyBufferInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyBufferInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyBufferInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyBufferInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyBufferInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcBuffer, dstBuffer, regionCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyBufferInfo2 const & ) const = default; -#else - bool operator==( CopyBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && ( dstBuffer == rhs.dstBuffer ) && - ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( CopyBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyBufferInfo2; - const void * pNext = {}; - Buffer srcBuffer = {}; - Buffer dstBuffer = {}; - uint32_t regionCount = {}; - const BufferCopy2 * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyBufferInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = CopyBufferInfo2; - }; - - using CopyBufferInfo2KHR = CopyBufferInfo2; - - // wrapper struct for struct VkCopyBufferToImageInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyBufferToImageInfo2.html - struct CopyBufferToImageInfo2 - { - using NativeType = VkCopyBufferToImageInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyBufferToImageInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyBufferToImageInfo2( Buffer srcBuffer_ = {}, - Image dstImage_ = {}, - ImageLayout dstImageLayout_ = ImageLayout::eUndefined, - uint32_t regionCount_ = {}, - const BufferImageCopy2 * pRegions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcBuffer{ srcBuffer_ } - , dstImage{ dstImage_ } - , dstImageLayout{ dstImageLayout_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyBufferToImageInfo2( CopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyBufferToImageInfo2( VkCopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyBufferToImageInfo2( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyBufferToImageInfo2( Buffer srcBuffer_, - Image dstImage_, - ImageLayout dstImageLayout_, - ArrayProxyNoTemporaries const & regions_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , srcBuffer( srcBuffer_ ) - , dstImage( dstImage_ ) - , dstImageLayout( dstImageLayout_ ) - , regionCount( static_cast( regions_.size() ) ) - , pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CopyBufferToImageInfo2 & operator=( CopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyBufferToImageInfo2 & operator=( VkCopyBufferToImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setSrcBuffer( Buffer srcBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - srcBuffer = srcBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setSrcBuffer( Buffer srcBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - srcBuffer = srcBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 & setPRegions( const BufferImageCopy2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyBufferToImageInfo2 && setPRegions( const BufferImageCopy2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyBufferToImageInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyBufferToImageInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyBufferToImageInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyBufferToImageInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyBufferToImageInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyBufferToImageInfo2 const & ) const = default; -#else - bool operator==( CopyBufferToImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcBuffer == rhs.srcBuffer ) && ( dstImage == rhs.dstImage ) && - ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( CopyBufferToImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyBufferToImageInfo2; - const void * pNext = {}; - Buffer srcBuffer = {}; - Image dstImage = {}; - ImageLayout dstImageLayout = ImageLayout::eUndefined; - uint32_t regionCount = {}; - const BufferImageCopy2 * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyBufferToImageInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = CopyBufferToImageInfo2; - }; - - using CopyBufferToImageInfo2KHR = CopyBufferToImageInfo2; - - // wrapper struct for struct VkCopyCommandTransformInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyCommandTransformInfoQCOM.html - struct CopyCommandTransformInfoQCOM - { - using NativeType = VkCopyCommandTransformInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyCommandTransformInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyCommandTransformInfoQCOM( SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , transform{ transform_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyCommandTransformInfoQCOM( CopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyCommandTransformInfoQCOM( VkCopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyCommandTransformInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - CopyCommandTransformInfoQCOM & operator=( CopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyCommandTransformInfoQCOM & operator=( VkCopyCommandTransformInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM & setTransform( SurfaceTransformFlagBitsKHR transform_ ) & VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyCommandTransformInfoQCOM && setTransform( SurfaceTransformFlagBitsKHR transform_ ) && VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyCommandTransformInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyCommandTransformInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyCommandTransformInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyCommandTransformInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, transform ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyCommandTransformInfoQCOM const & ) const = default; -#else - bool operator==( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ); -# endif - } - - bool operator!=( CopyCommandTransformInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyCommandTransformInfoQCOM; - const void * pNext = {}; - SurfaceTransformFlagBitsKHR transform = SurfaceTransformFlagBitsKHR::eIdentity; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyCommandTransformInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = CopyCommandTransformInfoQCOM; - }; - - // wrapper struct for struct VkCopyDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyDescriptorSet.html - struct CopyDescriptorSet - { - using NativeType = VkCopyDescriptorSet; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyDescriptorSet; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyDescriptorSet( DescriptorSet srcSet_ = {}, - uint32_t srcBinding_ = {}, - uint32_t srcArrayElement_ = {}, - DescriptorSet dstSet_ = {}, - uint32_t dstBinding_ = {}, - uint32_t dstArrayElement_ = {}, - uint32_t descriptorCount_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcSet{ srcSet_ } - , srcBinding{ srcBinding_ } - , srcArrayElement{ srcArrayElement_ } - , dstSet{ dstSet_ } - , dstBinding{ dstBinding_ } - , dstArrayElement{ dstArrayElement_ } - , descriptorCount{ descriptorCount_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyDescriptorSet( CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyDescriptorSet( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT : CopyDescriptorSet( *reinterpret_cast( &rhs ) ) {} - - CopyDescriptorSet & operator=( CopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyDescriptorSet & operator=( VkCopyDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setSrcSet( DescriptorSet srcSet_ ) & VULKAN_HPP_NOEXCEPT - { - srcSet = srcSet_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setSrcSet( DescriptorSet srcSet_ ) && VULKAN_HPP_NOEXCEPT - { - srcSet = srcSet_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setSrcBinding( uint32_t srcBinding_ ) & VULKAN_HPP_NOEXCEPT - { - srcBinding = srcBinding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setSrcBinding( uint32_t srcBinding_ ) && VULKAN_HPP_NOEXCEPT - { - srcBinding = srcBinding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setSrcArrayElement( uint32_t srcArrayElement_ ) & VULKAN_HPP_NOEXCEPT - { - srcArrayElement = srcArrayElement_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setSrcArrayElement( uint32_t srcArrayElement_ ) && VULKAN_HPP_NOEXCEPT - { - srcArrayElement = srcArrayElement_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDstSet( DescriptorSet dstSet_ ) & VULKAN_HPP_NOEXCEPT - { - dstSet = dstSet_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDstSet( DescriptorSet dstSet_ ) && VULKAN_HPP_NOEXCEPT - { - dstSet = dstSet_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDstBinding( uint32_t dstBinding_ ) & VULKAN_HPP_NOEXCEPT - { - dstBinding = dstBinding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDstBinding( uint32_t dstBinding_ ) && VULKAN_HPP_NOEXCEPT - { - dstBinding = dstBinding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDstArrayElement( uint32_t dstArrayElement_ ) & VULKAN_HPP_NOEXCEPT - { - dstArrayElement = dstArrayElement_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDstArrayElement( uint32_t dstArrayElement_ ) && VULKAN_HPP_NOEXCEPT - { - dstArrayElement = dstArrayElement_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorCount = descriptorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyDescriptorSet && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorCount = descriptorCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyDescriptorSet const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyDescriptorSet &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyDescriptorSet const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyDescriptorSet *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcSet, srcBinding, srcArrayElement, dstSet, dstBinding, dstArrayElement, descriptorCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyDescriptorSet const & ) const = default; -#else - bool operator==( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSet == rhs.srcSet ) && ( srcBinding == rhs.srcBinding ) && - ( srcArrayElement == rhs.srcArrayElement ) && ( dstSet == rhs.dstSet ) && ( dstBinding == rhs.dstBinding ) && - ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount ); -# endif - } - - bool operator!=( CopyDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyDescriptorSet; - const void * pNext = {}; - DescriptorSet srcSet = {}; - uint32_t srcBinding = {}; - uint32_t srcArrayElement = {}; - DescriptorSet dstSet = {}; - uint32_t dstBinding = {}; - uint32_t dstArrayElement = {}; - uint32_t descriptorCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyDescriptorSet; - }; -#endif - - template <> - struct CppType - { - using Type = CopyDescriptorSet; - }; - - // wrapper struct for struct VkImageCopy2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCopy2.html - struct ImageCopy2 - { - using NativeType = VkImageCopy2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCopy2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageCopy2( ImageSubresourceLayers srcSubresource_ = {}, - Offset3D srcOffset_ = {}, - ImageSubresourceLayers dstSubresource_ = {}, - Offset3D dstOffset_ = {}, - Extent3D extent_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcSubresource{ srcSubresource_ } - , srcOffset{ srcOffset_ } - , dstSubresource{ dstSubresource_ } - , dstOffset{ dstOffset_ } - , extent{ extent_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageCopy2( ImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageCopy2( VkImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageCopy2( *reinterpret_cast( &rhs ) ) {} - - ImageCopy2 & operator=( ImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageCopy2 & operator=( VkImageCopy2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setSrcOffset( Offset3D const & srcOffset_ ) & VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setSrcOffset( Offset3D const & srcOffset_ ) && VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setDstOffset( Offset3D const & dstOffset_ ) & VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setDstOffset( Offset3D const & dstOffset_ ) && VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy2 && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageCopy2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCopy2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCopy2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageCopy2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageCopy2 const & ) const = default; -#else - bool operator==( ImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && - ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); -# endif - } - - bool operator!=( ImageCopy2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageCopy2; - const void * pNext = {}; - ImageSubresourceLayers srcSubresource = {}; - Offset3D srcOffset = {}; - ImageSubresourceLayers dstSubresource = {}; - Offset3D dstOffset = {}; - Extent3D extent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageCopy2; - }; -#endif - - template <> - struct CppType - { - using Type = ImageCopy2; - }; - - using ImageCopy2KHR = ImageCopy2; - - // wrapper struct for struct VkCopyImageInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageInfo2.html - struct CopyImageInfo2 - { - using NativeType = VkCopyImageInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyImageInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyImageInfo2( Image srcImage_ = {}, - ImageLayout srcImageLayout_ = ImageLayout::eUndefined, - Image dstImage_ = {}, - ImageLayout dstImageLayout_ = ImageLayout::eUndefined, - uint32_t regionCount_ = {}, - const ImageCopy2 * pRegions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcImage{ srcImage_ } - , srcImageLayout{ srcImageLayout_ } - , dstImage{ dstImage_ } - , dstImageLayout{ dstImageLayout_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyImageInfo2( CopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyImageInfo2( VkCopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : CopyImageInfo2( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyImageInfo2( Image srcImage_, - ImageLayout srcImageLayout_, - Image dstImage_, - ImageLayout dstImageLayout_, - ArrayProxyNoTemporaries const & regions_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , srcImage( srcImage_ ) - , srcImageLayout( srcImageLayout_ ) - , dstImage( dstImage_ ) - , dstImageLayout( dstImageLayout_ ) - , regionCount( static_cast( regions_.size() ) ) - , pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CopyImageInfo2 & operator=( CopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyImageInfo2 & operator=( VkCopyImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 & setPRegions( const ImageCopy2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageInfo2 && setPRegions( const ImageCopy2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyImageInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyImageInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyImageInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyImageInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyImageInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyImageInfo2 const & ) const = default; -#else - bool operator==( CopyImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) && - ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( CopyImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyImageInfo2; - const void * pNext = {}; - Image srcImage = {}; - ImageLayout srcImageLayout = ImageLayout::eUndefined; - Image dstImage = {}; - ImageLayout dstImageLayout = ImageLayout::eUndefined; - uint32_t regionCount = {}; - const ImageCopy2 * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyImageInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = CopyImageInfo2; - }; - - using CopyImageInfo2KHR = CopyImageInfo2; - - // wrapper struct for struct VkCopyImageToBufferInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageToBufferInfo2.html - struct CopyImageToBufferInfo2 - { - using NativeType = VkCopyImageToBufferInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyImageToBufferInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyImageToBufferInfo2( Image srcImage_ = {}, - ImageLayout srcImageLayout_ = ImageLayout::eUndefined, - Buffer dstBuffer_ = {}, - uint32_t regionCount_ = {}, - const BufferImageCopy2 * pRegions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcImage{ srcImage_ } - , srcImageLayout{ srcImageLayout_ } - , dstBuffer{ dstBuffer_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyImageToBufferInfo2( CopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyImageToBufferInfo2( VkCopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyImageToBufferInfo2( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyImageToBufferInfo2( Image srcImage_, - ImageLayout srcImageLayout_, - Buffer dstBuffer_, - ArrayProxyNoTemporaries const & regions_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , srcImage( srcImage_ ) - , srcImageLayout( srcImageLayout_ ) - , dstBuffer( dstBuffer_ ) - , regionCount( static_cast( regions_.size() ) ) - , pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CopyImageToBufferInfo2 & operator=( CopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyImageToBufferInfo2 & operator=( VkCopyImageToBufferInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setDstBuffer( Buffer dstBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - dstBuffer = dstBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setDstBuffer( Buffer dstBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - dstBuffer = dstBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 & setPRegions( const BufferImageCopy2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToBufferInfo2 && setPRegions( const BufferImageCopy2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyImageToBufferInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyImageToBufferInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyImageToBufferInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyImageToBufferInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyImageToBufferInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyImageToBufferInfo2 const & ) const = default; -#else - bool operator==( CopyImageToBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) && - ( dstBuffer == rhs.dstBuffer ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( CopyImageToBufferInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyImageToBufferInfo2; - const void * pNext = {}; - Image srcImage = {}; - ImageLayout srcImageLayout = ImageLayout::eUndefined; - Buffer dstBuffer = {}; - uint32_t regionCount = {}; - const BufferImageCopy2 * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyImageToBufferInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = CopyImageToBufferInfo2; - }; - - using CopyImageToBufferInfo2KHR = CopyImageToBufferInfo2; - - // wrapper struct for struct VkCopyImageToImageInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageToImageInfo.html - struct CopyImageToImageInfo - { - using NativeType = VkCopyImageToImageInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyImageToImageInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyImageToImageInfo( HostImageCopyFlags flags_ = {}, - Image srcImage_ = {}, - ImageLayout srcImageLayout_ = ImageLayout::eUndefined, - Image dstImage_ = {}, - ImageLayout dstImageLayout_ = ImageLayout::eUndefined, - uint32_t regionCount_ = {}, - const ImageCopy2 * pRegions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , srcImage{ srcImage_ } - , srcImageLayout{ srcImageLayout_ } - , dstImage{ dstImage_ } - , dstImageLayout{ dstImageLayout_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyImageToImageInfo( CopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyImageToImageInfo( VkCopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyImageToImageInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyImageToImageInfo( HostImageCopyFlags flags_, - Image srcImage_, - ImageLayout srcImageLayout_, - Image dstImage_, - ImageLayout dstImageLayout_, - ArrayProxyNoTemporaries const & regions_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , srcImage( srcImage_ ) - , srcImageLayout( srcImageLayout_ ) - , dstImage( dstImage_ ) - , dstImageLayout( dstImageLayout_ ) - , regionCount( static_cast( regions_.size() ) ) - , pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CopyImageToImageInfo & operator=( CopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyImageToImageInfo & operator=( VkCopyImageToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setFlags( HostImageCopyFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setFlags( HostImageCopyFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo & setPRegions( const ImageCopy2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToImageInfo && setPRegions( const ImageCopy2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyImageToImageInfo & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyImageToImageInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyImageToImageInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyImageToImageInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyImageToImageInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyImageToImageInfo const & ) const = default; -#else - bool operator==( CopyImageToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcImage == rhs.srcImage ) && - ( srcImageLayout == rhs.srcImageLayout ) && ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && - ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( CopyImageToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyImageToImageInfo; - const void * pNext = {}; - HostImageCopyFlags flags = {}; - Image srcImage = {}; - ImageLayout srcImageLayout = ImageLayout::eUndefined; - Image dstImage = {}; - ImageLayout dstImageLayout = ImageLayout::eUndefined; - uint32_t regionCount = {}; - const ImageCopy2 * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyImageToImageInfo; - }; -#endif - - template <> - struct CppType - { - using Type = CopyImageToImageInfo; - }; - - using CopyImageToImageInfoEXT = CopyImageToImageInfo; - - // wrapper struct for struct VkImageToMemoryCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageToMemoryCopy.html - struct ImageToMemoryCopy - { - using NativeType = VkImageToMemoryCopy; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageToMemoryCopy; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageToMemoryCopy( void * pHostPointer_ = {}, - uint32_t memoryRowLength_ = {}, - uint32_t memoryImageHeight_ = {}, - ImageSubresourceLayers imageSubresource_ = {}, - Offset3D imageOffset_ = {}, - Extent3D imageExtent_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pHostPointer{ pHostPointer_ } - , memoryRowLength{ memoryRowLength_ } - , memoryImageHeight{ memoryImageHeight_ } - , imageSubresource{ imageSubresource_ } - , imageOffset{ imageOffset_ } - , imageExtent{ imageExtent_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageToMemoryCopy( ImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageToMemoryCopy( VkImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT : ImageToMemoryCopy( *reinterpret_cast( &rhs ) ) {} - - ImageToMemoryCopy & operator=( ImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageToMemoryCopy & operator=( VkImageToMemoryCopy const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setPHostPointer( void * pHostPointer_ ) & VULKAN_HPP_NOEXCEPT - { - pHostPointer = pHostPointer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setPHostPointer( void * pHostPointer_ ) && VULKAN_HPP_NOEXCEPT - { - pHostPointer = pHostPointer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setMemoryRowLength( uint32_t memoryRowLength_ ) & VULKAN_HPP_NOEXCEPT - { - memoryRowLength = memoryRowLength_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setMemoryRowLength( uint32_t memoryRowLength_ ) && VULKAN_HPP_NOEXCEPT - { - memoryRowLength = memoryRowLength_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setMemoryImageHeight( uint32_t memoryImageHeight_ ) & VULKAN_HPP_NOEXCEPT - { - memoryImageHeight = memoryImageHeight_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setMemoryImageHeight( uint32_t memoryImageHeight_ ) && VULKAN_HPP_NOEXCEPT - { - memoryImageHeight = memoryImageHeight_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT - { - imageOffset = imageOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT - { - imageOffset = imageOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageToMemoryCopy && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageToMemoryCopy const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageToMemoryCopy &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageToMemoryCopy const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageToMemoryCopy *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pHostPointer, memoryRowLength, memoryImageHeight, imageSubresource, imageOffset, imageExtent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageToMemoryCopy const & ) const = default; -#else - bool operator==( ImageToMemoryCopy const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pHostPointer == rhs.pHostPointer ) && ( memoryRowLength == rhs.memoryRowLength ) && - ( memoryImageHeight == rhs.memoryImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && - ( imageExtent == rhs.imageExtent ); -# endif - } - - bool operator!=( ImageToMemoryCopy const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageToMemoryCopy; - const void * pNext = {}; - void * pHostPointer = {}; - uint32_t memoryRowLength = {}; - uint32_t memoryImageHeight = {}; - ImageSubresourceLayers imageSubresource = {}; - Offset3D imageOffset = {}; - Extent3D imageExtent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageToMemoryCopy; - }; -#endif - - template <> - struct CppType - { - using Type = ImageToMemoryCopy; - }; - - using ImageToMemoryCopyEXT = ImageToMemoryCopy; - - // wrapper struct for struct VkCopyImageToMemoryInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyImageToMemoryInfo.html - struct CopyImageToMemoryInfo - { - using NativeType = VkCopyImageToMemoryInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyImageToMemoryInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyImageToMemoryInfo( HostImageCopyFlags flags_ = {}, - Image srcImage_ = {}, - ImageLayout srcImageLayout_ = ImageLayout::eUndefined, - uint32_t regionCount_ = {}, - const ImageToMemoryCopy * pRegions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , srcImage{ srcImage_ } - , srcImageLayout{ srcImageLayout_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyImageToMemoryInfo( CopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyImageToMemoryInfo( VkCopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyImageToMemoryInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyImageToMemoryInfo( HostImageCopyFlags flags_, - Image srcImage_, - ImageLayout srcImageLayout_, - ArrayProxyNoTemporaries const & regions_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , srcImage( srcImage_ ) - , srcImageLayout( srcImageLayout_ ) - , regionCount( static_cast( regions_.size() ) ) - , pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CopyImageToMemoryInfo & operator=( CopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyImageToMemoryInfo & operator=( VkCopyImageToMemoryInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setFlags( HostImageCopyFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setFlags( HostImageCopyFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo & setPRegions( const ImageToMemoryCopy * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyImageToMemoryInfo && setPRegions( const ImageToMemoryCopy * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyImageToMemoryInfo & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyImageToMemoryInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyImageToMemoryInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyImageToMemoryInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyImageToMemoryInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, srcImage, srcImageLayout, regionCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyImageToMemoryInfo const & ) const = default; -#else - bool operator==( CopyImageToMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcImage == rhs.srcImage ) && - ( srcImageLayout == rhs.srcImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( CopyImageToMemoryInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyImageToMemoryInfo; - const void * pNext = {}; - HostImageCopyFlags flags = {}; - Image srcImage = {}; - ImageLayout srcImageLayout = ImageLayout::eUndefined; - uint32_t regionCount = {}; - const ImageToMemoryCopy * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyImageToMemoryInfo; - }; -#endif - - template <> - struct CppType - { - using Type = CopyImageToMemoryInfo; - }; - - using CopyImageToMemoryInfoEXT = CopyImageToMemoryInfo; - - // wrapper struct for struct VkCopyMemoryIndirectCommandKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryIndirectCommandKHR.html - struct CopyMemoryIndirectCommandKHR - { - using NativeType = VkCopyMemoryIndirectCommandKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - CopyMemoryIndirectCommandKHR( DeviceAddress srcAddress_ = {}, DeviceAddress dstAddress_ = {}, DeviceSize size_ = {} ) VULKAN_HPP_NOEXCEPT - : srcAddress{ srcAddress_ } - , dstAddress{ dstAddress_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyMemoryIndirectCommandKHR( CopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyMemoryIndirectCommandKHR( VkCopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyMemoryIndirectCommandKHR( *reinterpret_cast( &rhs ) ) - { - } - - CopyMemoryIndirectCommandKHR & operator=( CopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyMemoryIndirectCommandKHR & operator=( VkCopyMemoryIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT - { - srcAddress = srcAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT - { - srcAddress = srcAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setDstAddress( DeviceAddress dstAddress_ ) & VULKAN_HPP_NOEXCEPT - { - dstAddress = dstAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR && setDstAddress( DeviceAddress dstAddress_ ) && VULKAN_HPP_NOEXCEPT - { - dstAddress = dstAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectCommandKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyMemoryIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryIndirectCommandKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyMemoryIndirectCommandKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( srcAddress, dstAddress, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyMemoryIndirectCommandKHR const & ) const = default; -#else - bool operator==( CopyMemoryIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( srcAddress == rhs.srcAddress ) && ( dstAddress == rhs.dstAddress ) && ( size == rhs.size ); -# endif - } - - bool operator!=( CopyMemoryIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress srcAddress = {}; - DeviceAddress dstAddress = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyMemoryIndirectCommandKHR; - }; -#endif - using CopyMemoryIndirectCommandNV = CopyMemoryIndirectCommandKHR; - - // wrapper struct for struct VkStridedDeviceAddressRangeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStridedDeviceAddressRangeKHR.html - struct StridedDeviceAddressRangeKHR - { - using NativeType = VkStridedDeviceAddressRangeKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( DeviceAddress address_ = {}, DeviceSize size_ = {}, DeviceSize stride_ = {} ) VULKAN_HPP_NOEXCEPT - : address{ address_ } - , size{ size_ } - , stride{ stride_ } - { - } - - VULKAN_HPP_CONSTEXPR StridedDeviceAddressRangeKHR( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - StridedDeviceAddressRangeKHR( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : StridedDeviceAddressRangeKHR( *reinterpret_cast( &rhs ) ) - { - } - - StridedDeviceAddressRangeKHR & operator=( StridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - StridedDeviceAddressRangeKHR & operator=( VkStridedDeviceAddressRangeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT - { - address = address_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT - { - address = address_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR & setStride( DeviceSize stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StridedDeviceAddressRangeKHR && setStride( DeviceSize stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkStridedDeviceAddressRangeKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressRangeKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressRangeKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkStridedDeviceAddressRangeKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( address, size, stride ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( StridedDeviceAddressRangeKHR const & ) const = default; -#else - bool operator==( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( address == rhs.address ) && ( size == rhs.size ) && ( stride == rhs.stride ); -# endif - } - - bool operator!=( StridedDeviceAddressRangeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress address = {}; - DeviceSize size = {}; - DeviceSize stride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = StridedDeviceAddressRangeKHR; - }; -#endif - - // wrapper struct for struct VkCopyMemoryIndirectInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryIndirectInfoKHR.html - struct CopyMemoryIndirectInfoKHR - { - using NativeType = VkCopyMemoryIndirectInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryIndirectInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyMemoryIndirectInfoKHR( AddressCopyFlagsKHR srcCopyFlags_ = {}, - AddressCopyFlagsKHR dstCopyFlags_ = {}, - uint32_t copyCount_ = {}, - StridedDeviceAddressRangeKHR copyAddressRange_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcCopyFlags{ srcCopyFlags_ } - , dstCopyFlags{ dstCopyFlags_ } - , copyCount{ copyCount_ } - , copyAddressRange{ copyAddressRange_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyMemoryIndirectInfoKHR( CopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyMemoryIndirectInfoKHR( VkCopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyMemoryIndirectInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - CopyMemoryIndirectInfoKHR & operator=( CopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyMemoryIndirectInfoKHR & operator=( VkCopyMemoryIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) & VULKAN_HPP_NOEXCEPT - { - srcCopyFlags = srcCopyFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) && VULKAN_HPP_NOEXCEPT - { - srcCopyFlags = srcCopyFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setDstCopyFlags( AddressCopyFlagsKHR dstCopyFlags_ ) & VULKAN_HPP_NOEXCEPT - { - dstCopyFlags = dstCopyFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setDstCopyFlags( AddressCopyFlagsKHR dstCopyFlags_ ) && VULKAN_HPP_NOEXCEPT - { - dstCopyFlags = dstCopyFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setCopyCount( uint32_t copyCount_ ) & VULKAN_HPP_NOEXCEPT - { - copyCount = copyCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setCopyCount( uint32_t copyCount_ ) && VULKAN_HPP_NOEXCEPT - { - copyCount = copyCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR & setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) & VULKAN_HPP_NOEXCEPT - { - copyAddressRange = copyAddressRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryIndirectInfoKHR && setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) && VULKAN_HPP_NOEXCEPT - { - copyAddressRange = copyAddressRange_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyMemoryIndirectInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryIndirectInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryIndirectInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyMemoryIndirectInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcCopyFlags, dstCopyFlags, copyCount, copyAddressRange ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyMemoryIndirectInfoKHR const & ) const = default; -#else - bool operator==( CopyMemoryIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcCopyFlags == rhs.srcCopyFlags ) && ( dstCopyFlags == rhs.dstCopyFlags ) && - ( copyCount == rhs.copyCount ) && ( copyAddressRange == rhs.copyAddressRange ); -# endif - } - - bool operator!=( CopyMemoryIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyMemoryIndirectInfoKHR; - const void * pNext = {}; - AddressCopyFlagsKHR srcCopyFlags = {}; - AddressCopyFlagsKHR dstCopyFlags = {}; - uint32_t copyCount = {}; - StridedDeviceAddressRangeKHR copyAddressRange = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyMemoryIndirectInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = CopyMemoryIndirectInfoKHR; - }; - - // wrapper struct for struct VkCopyMemoryToAccelerationStructureInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToAccelerationStructureInfoKHR.html - struct CopyMemoryToAccelerationStructureInfoKHR - { - using NativeType = VkCopyMemoryToAccelerationStructureInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR( DeviceOrHostAddressConstKHR src_ = {}, - AccelerationStructureKHR dst_ = {}, - CopyAccelerationStructureModeKHR mode_ = CopyAccelerationStructureModeKHR::eClone, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , src{ src_ } - , dst{ dst_ } - , mode{ mode_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR( CopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyMemoryToAccelerationStructureInfoKHR( VkCopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyMemoryToAccelerationStructureInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - CopyMemoryToAccelerationStructureInfoKHR & operator=( CopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyMemoryToAccelerationStructureInfoKHR & operator=( VkCopyMemoryToAccelerationStructureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setSrc( DeviceOrHostAddressConstKHR const & src_ ) & VULKAN_HPP_NOEXCEPT - { - src = src_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setSrc( DeviceOrHostAddressConstKHR const & src_ ) && VULKAN_HPP_NOEXCEPT - { - src = src_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setDst( AccelerationStructureKHR dst_ ) & VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setDst( AccelerationStructureKHR dst_ ) && VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR & setMode( CopyAccelerationStructureModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToAccelerationStructureInfoKHR && setMode( CopyAccelerationStructureModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyMemoryToAccelerationStructureInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryToAccelerationStructureInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryToAccelerationStructureInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyMemoryToAccelerationStructureInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, src, dst, mode ); - } -#endif - - public: - StructureType sType = StructureType::eCopyMemoryToAccelerationStructureInfoKHR; - const void * pNext = {}; - DeviceOrHostAddressConstKHR src = {}; - AccelerationStructureKHR dst = {}; - CopyAccelerationStructureModeKHR mode = CopyAccelerationStructureModeKHR::eClone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyMemoryToAccelerationStructureInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = CopyMemoryToAccelerationStructureInfoKHR; - }; - - // wrapper struct for struct VkCopyMemoryToImageIndirectCommandKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageIndirectCommandKHR.html - struct CopyMemoryToImageIndirectCommandKHR - { - using NativeType = VkCopyMemoryToImageIndirectCommandKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectCommandKHR( DeviceAddress srcAddress_ = {}, - uint32_t bufferRowLength_ = {}, - uint32_t bufferImageHeight_ = {}, - ImageSubresourceLayers imageSubresource_ = {}, - Offset3D imageOffset_ = {}, - Extent3D imageExtent_ = {} ) VULKAN_HPP_NOEXCEPT - : srcAddress{ srcAddress_ } - , bufferRowLength{ bufferRowLength_ } - , bufferImageHeight{ bufferImageHeight_ } - , imageSubresource{ imageSubresource_ } - , imageOffset{ imageOffset_ } - , imageExtent{ imageExtent_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectCommandKHR( CopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyMemoryToImageIndirectCommandKHR( VkCopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyMemoryToImageIndirectCommandKHR( *reinterpret_cast( &rhs ) ) - { - } - - CopyMemoryToImageIndirectCommandKHR & operator=( CopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyMemoryToImageIndirectCommandKHR & operator=( VkCopyMemoryToImageIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT - { - srcAddress = srcAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT - { - srcAddress = srcAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setBufferRowLength( uint32_t bufferRowLength_ ) & VULKAN_HPP_NOEXCEPT - { - bufferRowLength = bufferRowLength_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setBufferRowLength( uint32_t bufferRowLength_ ) && VULKAN_HPP_NOEXCEPT - { - bufferRowLength = bufferRowLength_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setBufferImageHeight( uint32_t bufferImageHeight_ ) & VULKAN_HPP_NOEXCEPT - { - bufferImageHeight = bufferImageHeight_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setBufferImageHeight( uint32_t bufferImageHeight_ ) && VULKAN_HPP_NOEXCEPT - { - bufferImageHeight = bufferImageHeight_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && - VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT - { - imageOffset = imageOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT - { - imageOffset = imageOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectCommandKHR && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyMemoryToImageIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryToImageIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryToImageIndirectCommandKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyMemoryToImageIndirectCommandKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( srcAddress, bufferRowLength, bufferImageHeight, imageSubresource, imageOffset, imageExtent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyMemoryToImageIndirectCommandKHR const & ) const = default; -#else - bool operator==( CopyMemoryToImageIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( srcAddress == rhs.srcAddress ) && ( bufferRowLength == rhs.bufferRowLength ) && ( bufferImageHeight == rhs.bufferImageHeight ) && - ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && ( imageExtent == rhs.imageExtent ); -# endif - } - - bool operator!=( CopyMemoryToImageIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress srcAddress = {}; - uint32_t bufferRowLength = {}; - uint32_t bufferImageHeight = {}; - ImageSubresourceLayers imageSubresource = {}; - Offset3D imageOffset = {}; - Extent3D imageExtent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyMemoryToImageIndirectCommandKHR; - }; -#endif - using CopyMemoryToImageIndirectCommandNV = CopyMemoryToImageIndirectCommandKHR; - - // wrapper struct for struct VkCopyMemoryToImageIndirectInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageIndirectInfoKHR.html - struct CopyMemoryToImageIndirectInfoKHR - { - using NativeType = VkCopyMemoryToImageIndirectInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryToImageIndirectInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectInfoKHR( AddressCopyFlagsKHR srcCopyFlags_ = {}, - uint32_t copyCount_ = {}, - StridedDeviceAddressRangeKHR copyAddressRange_ = {}, - Image dstImage_ = {}, - ImageLayout dstImageLayout_ = ImageLayout::eUndefined, - const ImageSubresourceLayers * pImageSubresources_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcCopyFlags{ srcCopyFlags_ } - , copyCount{ copyCount_ } - , copyAddressRange{ copyAddressRange_ } - , dstImage{ dstImage_ } - , dstImageLayout{ dstImageLayout_ } - , pImageSubresources{ pImageSubresources_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyMemoryToImageIndirectInfoKHR( CopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyMemoryToImageIndirectInfoKHR( VkCopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyMemoryToImageIndirectInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyMemoryToImageIndirectInfoKHR( AddressCopyFlagsKHR srcCopyFlags_, - StridedDeviceAddressRangeKHR copyAddressRange_, - Image dstImage_, - ImageLayout dstImageLayout_, - ArrayProxyNoTemporaries const & imageSubresources_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , srcCopyFlags( srcCopyFlags_ ) - , copyCount( static_cast( imageSubresources_.size() ) ) - , copyAddressRange( copyAddressRange_ ) - , dstImage( dstImage_ ) - , dstImageLayout( dstImageLayout_ ) - , pImageSubresources( imageSubresources_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CopyMemoryToImageIndirectInfoKHR & operator=( CopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyMemoryToImageIndirectInfoKHR & operator=( VkCopyMemoryToImageIndirectInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) & VULKAN_HPP_NOEXCEPT - { - srcCopyFlags = srcCopyFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setSrcCopyFlags( AddressCopyFlagsKHR srcCopyFlags_ ) && VULKAN_HPP_NOEXCEPT - { - srcCopyFlags = srcCopyFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setCopyCount( uint32_t copyCount_ ) & VULKAN_HPP_NOEXCEPT - { - copyCount = copyCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setCopyCount( uint32_t copyCount_ ) && VULKAN_HPP_NOEXCEPT - { - copyCount = copyCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) & - VULKAN_HPP_NOEXCEPT - { - copyAddressRange = copyAddressRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setCopyAddressRange( StridedDeviceAddressRangeKHR const & copyAddressRange_ ) && - VULKAN_HPP_NOEXCEPT - { - copyAddressRange = copyAddressRange_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR & setPImageSubresources( const ImageSubresourceLayers * pImageSubresources_ ) & VULKAN_HPP_NOEXCEPT - { - pImageSubresources = pImageSubresources_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageIndirectInfoKHR && setPImageSubresources( const ImageSubresourceLayers * pImageSubresources_ ) && - VULKAN_HPP_NOEXCEPT - { - pImageSubresources = pImageSubresources_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyMemoryToImageIndirectInfoKHR & - setImageSubresources( ArrayProxyNoTemporaries const & imageSubresources_ ) VULKAN_HPP_NOEXCEPT - { - copyCount = static_cast( imageSubresources_.size() ); - pImageSubresources = imageSubresources_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyMemoryToImageIndirectInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryToImageIndirectInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryToImageIndirectInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyMemoryToImageIndirectInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcCopyFlags, copyCount, copyAddressRange, dstImage, dstImageLayout, pImageSubresources ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyMemoryToImageIndirectInfoKHR const & ) const = default; -#else - bool operator==( CopyMemoryToImageIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcCopyFlags == rhs.srcCopyFlags ) && ( copyCount == rhs.copyCount ) && - ( copyAddressRange == rhs.copyAddressRange ) && ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && - ( pImageSubresources == rhs.pImageSubresources ); -# endif - } - - bool operator!=( CopyMemoryToImageIndirectInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyMemoryToImageIndirectInfoKHR; - const void * pNext = {}; - AddressCopyFlagsKHR srcCopyFlags = {}; - uint32_t copyCount = {}; - StridedDeviceAddressRangeKHR copyAddressRange = {}; - Image dstImage = {}; - ImageLayout dstImageLayout = ImageLayout::eUndefined; - const ImageSubresourceLayers * pImageSubresources = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyMemoryToImageIndirectInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = CopyMemoryToImageIndirectInfoKHR; - }; - - // wrapper struct for struct VkMemoryToImageCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryToImageCopy.html - struct MemoryToImageCopy - { - using NativeType = VkMemoryToImageCopy; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryToImageCopy; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryToImageCopy( const void * pHostPointer_ = {}, - uint32_t memoryRowLength_ = {}, - uint32_t memoryImageHeight_ = {}, - ImageSubresourceLayers imageSubresource_ = {}, - Offset3D imageOffset_ = {}, - Extent3D imageExtent_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pHostPointer{ pHostPointer_ } - , memoryRowLength{ memoryRowLength_ } - , memoryImageHeight{ memoryImageHeight_ } - , imageSubresource{ imageSubresource_ } - , imageOffset{ imageOffset_ } - , imageExtent{ imageExtent_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryToImageCopy( MemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryToImageCopy( VkMemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryToImageCopy( *reinterpret_cast( &rhs ) ) {} - - MemoryToImageCopy & operator=( MemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryToImageCopy & operator=( VkMemoryToImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setPHostPointer( const void * pHostPointer_ ) & VULKAN_HPP_NOEXCEPT - { - pHostPointer = pHostPointer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setPHostPointer( const void * pHostPointer_ ) && VULKAN_HPP_NOEXCEPT - { - pHostPointer = pHostPointer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setMemoryRowLength( uint32_t memoryRowLength_ ) & VULKAN_HPP_NOEXCEPT - { - memoryRowLength = memoryRowLength_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setMemoryRowLength( uint32_t memoryRowLength_ ) && VULKAN_HPP_NOEXCEPT - { - memoryRowLength = memoryRowLength_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setMemoryImageHeight( uint32_t memoryImageHeight_ ) & VULKAN_HPP_NOEXCEPT - { - memoryImageHeight = memoryImageHeight_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setMemoryImageHeight( uint32_t memoryImageHeight_ ) && VULKAN_HPP_NOEXCEPT - { - memoryImageHeight = memoryImageHeight_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setImageSubresource( ImageSubresourceLayers const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setImageOffset( Offset3D const & imageOffset_ ) & VULKAN_HPP_NOEXCEPT - { - imageOffset = imageOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setImageOffset( Offset3D const & imageOffset_ ) && VULKAN_HPP_NOEXCEPT - { - imageOffset = imageOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy & setImageExtent( Extent3D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryToImageCopy && setImageExtent( Extent3D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryToImageCopy const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryToImageCopy &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryToImageCopy const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryToImageCopy *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pHostPointer, memoryRowLength, memoryImageHeight, imageSubresource, imageOffset, imageExtent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryToImageCopy const & ) const = default; -#else - bool operator==( MemoryToImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pHostPointer == rhs.pHostPointer ) && ( memoryRowLength == rhs.memoryRowLength ) && - ( memoryImageHeight == rhs.memoryImageHeight ) && ( imageSubresource == rhs.imageSubresource ) && ( imageOffset == rhs.imageOffset ) && - ( imageExtent == rhs.imageExtent ); -# endif - } - - bool operator!=( MemoryToImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryToImageCopy; - const void * pNext = {}; - const void * pHostPointer = {}; - uint32_t memoryRowLength = {}; - uint32_t memoryImageHeight = {}; - ImageSubresourceLayers imageSubresource = {}; - Offset3D imageOffset = {}; - Extent3D imageExtent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryToImageCopy; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryToImageCopy; - }; - - using MemoryToImageCopyEXT = MemoryToImageCopy; - - // wrapper struct for struct VkCopyMemoryToImageInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToImageInfo.html - struct CopyMemoryToImageInfo - { - using NativeType = VkCopyMemoryToImageInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryToImageInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyMemoryToImageInfo( HostImageCopyFlags flags_ = {}, - Image dstImage_ = {}, - ImageLayout dstImageLayout_ = ImageLayout::eUndefined, - uint32_t regionCount_ = {}, - const MemoryToImageCopy * pRegions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , dstImage{ dstImage_ } - , dstImageLayout{ dstImageLayout_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyMemoryToImageInfo( CopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyMemoryToImageInfo( VkCopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyMemoryToImageInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyMemoryToImageInfo( HostImageCopyFlags flags_, - Image dstImage_, - ImageLayout dstImageLayout_, - ArrayProxyNoTemporaries const & regions_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , dstImage( dstImage_ ) - , dstImageLayout( dstImageLayout_ ) - , regionCount( static_cast( regions_.size() ) ) - , pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CopyMemoryToImageInfo & operator=( CopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyMemoryToImageInfo & operator=( VkCopyMemoryToImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setFlags( HostImageCopyFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setFlags( HostImageCopyFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo & setPRegions( const MemoryToImageCopy * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToImageInfo && setPRegions( const MemoryToImageCopy * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyMemoryToImageInfo & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyMemoryToImageInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryToImageInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryToImageInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyMemoryToImageInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, dstImage, dstImageLayout, regionCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyMemoryToImageInfo const & ) const = default; -#else - bool operator==( CopyMemoryToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dstImage == rhs.dstImage ) && - ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( CopyMemoryToImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyMemoryToImageInfo; - const void * pNext = {}; - HostImageCopyFlags flags = {}; - Image dstImage = {}; - ImageLayout dstImageLayout = ImageLayout::eUndefined; - uint32_t regionCount = {}; - const MemoryToImageCopy * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyMemoryToImageInfo; - }; -#endif - - template <> - struct CppType - { - using Type = CopyMemoryToImageInfo; - }; - - using CopyMemoryToImageInfoEXT = CopyMemoryToImageInfo; - - // wrapper struct for struct VkCopyMemoryToMicromapInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMemoryToMicromapInfoEXT.html - struct CopyMemoryToMicromapInfoEXT - { - using NativeType = VkCopyMemoryToMicromapInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMemoryToMicromapInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT( DeviceOrHostAddressConstKHR src_ = {}, - MicromapEXT dst_ = {}, - CopyMicromapModeEXT mode_ = CopyMicromapModeEXT::eClone, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , src{ src_ } - , dst{ dst_ } - , mode{ mode_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT( CopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyMemoryToMicromapInfoEXT( VkCopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyMemoryToMicromapInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - CopyMemoryToMicromapInfoEXT & operator=( CopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyMemoryToMicromapInfoEXT & operator=( VkCopyMemoryToMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setSrc( DeviceOrHostAddressConstKHR const & src_ ) & VULKAN_HPP_NOEXCEPT - { - src = src_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setSrc( DeviceOrHostAddressConstKHR const & src_ ) && VULKAN_HPP_NOEXCEPT - { - src = src_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setDst( MicromapEXT dst_ ) & VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setDst( MicromapEXT dst_ ) && VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT & setMode( CopyMicromapModeEXT mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMemoryToMicromapInfoEXT && setMode( CopyMicromapModeEXT mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyMemoryToMicromapInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryToMicromapInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMemoryToMicromapInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyMemoryToMicromapInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, src, dst, mode ); - } -#endif - - public: - StructureType sType = StructureType::eCopyMemoryToMicromapInfoEXT; - const void * pNext = {}; - DeviceOrHostAddressConstKHR src = {}; - MicromapEXT dst = {}; - CopyMicromapModeEXT mode = CopyMicromapModeEXT::eClone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyMemoryToMicromapInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = CopyMemoryToMicromapInfoEXT; - }; - - // wrapper struct for struct VkCopyMicromapInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMicromapInfoEXT.html - struct CopyMicromapInfoEXT - { - using NativeType = VkCopyMicromapInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMicromapInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyMicromapInfoEXT( MicromapEXT src_ = {}, - MicromapEXT dst_ = {}, - CopyMicromapModeEXT mode_ = CopyMicromapModeEXT::eClone, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , src{ src_ } - , dst{ dst_ } - , mode{ mode_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyMicromapInfoEXT( CopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyMicromapInfoEXT( VkCopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : CopyMicromapInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - CopyMicromapInfoEXT & operator=( CopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyMicromapInfoEXT & operator=( VkCopyMicromapInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setSrc( MicromapEXT src_ ) & VULKAN_HPP_NOEXCEPT - { - src = src_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setSrc( MicromapEXT src_ ) && VULKAN_HPP_NOEXCEPT - { - src = src_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setDst( MicromapEXT dst_ ) & VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setDst( MicromapEXT dst_ ) && VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT & setMode( CopyMicromapModeEXT mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapInfoEXT && setMode( CopyMicromapModeEXT mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyMicromapInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMicromapInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMicromapInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyMicromapInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, src, dst, mode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyMicromapInfoEXT const & ) const = default; -#else - bool operator==( CopyMicromapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( src == rhs.src ) && ( dst == rhs.dst ) && ( mode == rhs.mode ); -# endif - } - - bool operator!=( CopyMicromapInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyMicromapInfoEXT; - const void * pNext = {}; - MicromapEXT src = {}; - MicromapEXT dst = {}; - CopyMicromapModeEXT mode = CopyMicromapModeEXT::eClone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyMicromapInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = CopyMicromapInfoEXT; - }; - - // wrapper struct for struct VkCopyMicromapToMemoryInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyMicromapToMemoryInfoEXT.html - struct CopyMicromapToMemoryInfoEXT - { - using NativeType = VkCopyMicromapToMemoryInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyMicromapToMemoryInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT( MicromapEXT src_ = {}, - DeviceOrHostAddressKHR dst_ = {}, - CopyMicromapModeEXT mode_ = CopyMicromapModeEXT::eClone, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , src{ src_ } - , dst{ dst_ } - , mode{ mode_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT( CopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyMicromapToMemoryInfoEXT( VkCopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : CopyMicromapToMemoryInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - CopyMicromapToMemoryInfoEXT & operator=( CopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyMicromapToMemoryInfoEXT & operator=( VkCopyMicromapToMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setSrc( MicromapEXT src_ ) & VULKAN_HPP_NOEXCEPT - { - src = src_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setSrc( MicromapEXT src_ ) && VULKAN_HPP_NOEXCEPT - { - src = src_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setDst( DeviceOrHostAddressKHR const & dst_ ) & VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setDst( DeviceOrHostAddressKHR const & dst_ ) && VULKAN_HPP_NOEXCEPT - { - dst = dst_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT & setMode( CopyMicromapModeEXT mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyMicromapToMemoryInfoEXT && setMode( CopyMicromapModeEXT mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyMicromapToMemoryInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMicromapToMemoryInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyMicromapToMemoryInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyMicromapToMemoryInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, src, dst, mode ); - } -#endif - - public: - StructureType sType = StructureType::eCopyMicromapToMemoryInfoEXT; - const void * pNext = {}; - MicromapEXT src = {}; - DeviceOrHostAddressKHR dst = {}; - CopyMicromapModeEXT mode = CopyMicromapModeEXT::eClone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyMicromapToMemoryInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = CopyMicromapToMemoryInfoEXT; - }; - - // wrapper struct for struct VkTensorCopyARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCopyARM.html - struct TensorCopyARM - { - using NativeType = VkTensorCopyARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorCopyARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TensorCopyARM( uint32_t dimensionCount_ = {}, - const uint64_t * pSrcOffset_ = {}, - const uint64_t * pDstOffset_ = {}, - const uint64_t * pExtent_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dimensionCount{ dimensionCount_ } - , pSrcOffset{ pSrcOffset_ } - , pDstOffset{ pDstOffset_ } - , pExtent{ pExtent_ } - { - } - - VULKAN_HPP_CONSTEXPR TensorCopyARM( TensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TensorCopyARM( VkTensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT : TensorCopyARM( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TensorCopyARM( ArrayProxyNoTemporaries const & srcOffset_, - ArrayProxyNoTemporaries const & dstOffset_ = {}, - ArrayProxyNoTemporaries const & extent_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , dimensionCount( static_cast( srcOffset_.size() ) ) - , pSrcOffset( srcOffset_.data() ) - , pDstOffset( dstOffset_.data() ) - , pExtent( extent_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( srcOffset_.empty() || dstOffset_.empty() || ( srcOffset_.size() == dstOffset_.size() ) ); - VULKAN_HPP_ASSERT( srcOffset_.empty() || extent_.empty() || ( srcOffset_.size() == extent_.size() ) ); - VULKAN_HPP_ASSERT( dstOffset_.empty() || extent_.empty() || ( dstOffset_.size() == extent_.size() ) ); -# else - if ( !srcOffset_.empty() && !dstOffset_.empty() && ( srcOffset_.size() != dstOffset_.size() ) ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::TensorCopyARM::TensorCopyARM: !srcOffset_.empty() && !dstOffset_.empty() && ( srcOffset_.size() != dstOffset_.size() )" ); - } - if ( !srcOffset_.empty() && !extent_.empty() && ( srcOffset_.size() != extent_.size() ) ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::TensorCopyARM::TensorCopyARM: !srcOffset_.empty() && !extent_.empty() && ( srcOffset_.size() != extent_.size() )" ); - } - if ( !dstOffset_.empty() && !extent_.empty() && ( dstOffset_.size() != extent_.size() ) ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::TensorCopyARM::TensorCopyARM: !dstOffset_.empty() && !extent_.empty() && ( dstOffset_.size() != extent_.size() )" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - TensorCopyARM & operator=( TensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TensorCopyARM & operator=( VkTensorCopyARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setDimensionCount( uint32_t dimensionCount_ ) & VULKAN_HPP_NOEXCEPT - { - dimensionCount = dimensionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setDimensionCount( uint32_t dimensionCount_ ) && VULKAN_HPP_NOEXCEPT - { - dimensionCount = dimensionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPSrcOffset( const uint64_t * pSrcOffset_ ) & VULKAN_HPP_NOEXCEPT - { - pSrcOffset = pSrcOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPSrcOffset( const uint64_t * pSrcOffset_ ) && VULKAN_HPP_NOEXCEPT - { - pSrcOffset = pSrcOffset_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TensorCopyARM & setSrcOffset( ArrayProxyNoTemporaries const & srcOffset_ ) VULKAN_HPP_NOEXCEPT - { - dimensionCount = static_cast( srcOffset_.size() ); - pSrcOffset = srcOffset_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPDstOffset( const uint64_t * pDstOffset_ ) & VULKAN_HPP_NOEXCEPT - { - pDstOffset = pDstOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPDstOffset( const uint64_t * pDstOffset_ ) && VULKAN_HPP_NOEXCEPT - { - pDstOffset = pDstOffset_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TensorCopyARM & setDstOffset( ArrayProxyNoTemporaries const & dstOffset_ ) VULKAN_HPP_NOEXCEPT - { - dimensionCount = static_cast( dstOffset_.size() ); - pDstOffset = dstOffset_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 TensorCopyARM & setPExtent( const uint64_t * pExtent_ ) & VULKAN_HPP_NOEXCEPT - { - pExtent = pExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCopyARM && setPExtent( const uint64_t * pExtent_ ) && VULKAN_HPP_NOEXCEPT - { - pExtent = pExtent_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TensorCopyARM & setExtent( ArrayProxyNoTemporaries const & extent_ ) VULKAN_HPP_NOEXCEPT - { - dimensionCount = static_cast( extent_.size() ); - pExtent = extent_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTensorCopyARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorCopyARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorCopyARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTensorCopyARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dimensionCount, pSrcOffset, pDstOffset, pExtent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TensorCopyARM const & ) const = default; -#else - bool operator==( TensorCopyARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dimensionCount == rhs.dimensionCount ) && ( pSrcOffset == rhs.pSrcOffset ) && - ( pDstOffset == rhs.pDstOffset ) && ( pExtent == rhs.pExtent ); -# endif - } - - bool operator!=( TensorCopyARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTensorCopyARM; - const void * pNext = {}; - uint32_t dimensionCount = {}; - const uint64_t * pSrcOffset = {}; - const uint64_t * pDstOffset = {}; - const uint64_t * pExtent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TensorCopyARM; - }; -#endif - - template <> - struct CppType - { - using Type = TensorCopyARM; - }; - - // wrapper struct for struct VkCopyTensorInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCopyTensorInfoARM.html - struct CopyTensorInfoARM - { - using NativeType = VkCopyTensorInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCopyTensorInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CopyTensorInfoARM( TensorARM srcTensor_ = {}, - TensorARM dstTensor_ = {}, - uint32_t regionCount_ = {}, - const TensorCopyARM * pRegions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcTensor{ srcTensor_ } - , dstTensor{ dstTensor_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR CopyTensorInfoARM( CopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CopyTensorInfoARM( VkCopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT : CopyTensorInfoARM( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyTensorInfoARM( TensorARM srcTensor_, - TensorARM dstTensor_, - ArrayProxyNoTemporaries const & regions_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), srcTensor( srcTensor_ ), dstTensor( dstTensor_ ), regionCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CopyTensorInfoARM & operator=( CopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CopyTensorInfoARM & operator=( VkCopyTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setSrcTensor( TensorARM srcTensor_ ) & VULKAN_HPP_NOEXCEPT - { - srcTensor = srcTensor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setSrcTensor( TensorARM srcTensor_ ) && VULKAN_HPP_NOEXCEPT - { - srcTensor = srcTensor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setDstTensor( TensorARM dstTensor_ ) & VULKAN_HPP_NOEXCEPT - { - dstTensor = dstTensor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setDstTensor( TensorARM dstTensor_ ) && VULKAN_HPP_NOEXCEPT - { - dstTensor = dstTensor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM & setPRegions( const TensorCopyARM * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CopyTensorInfoARM && setPRegions( const TensorCopyARM * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CopyTensorInfoARM & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCopyTensorInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyTensorInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCopyTensorInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCopyTensorInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcTensor, dstTensor, regionCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CopyTensorInfoARM const & ) const = default; -#else - bool operator==( CopyTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcTensor == rhs.srcTensor ) && ( dstTensor == rhs.dstTensor ) && - ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( CopyTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCopyTensorInfoARM; - const void * pNext = {}; - TensorARM srcTensor = {}; - TensorARM dstTensor = {}; - uint32_t regionCount = {}; - const TensorCopyARM * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CopyTensorInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = CopyTensorInfoARM; - }; - - // wrapper struct for struct VkCuFunctionCreateInfoNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuFunctionCreateInfoNVX.html - struct CuFunctionCreateInfoNVX - { - using NativeType = VkCuFunctionCreateInfoNVX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCuFunctionCreateInfoNVX; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CuFunctionCreateInfoNVX( CuModuleNVX module_ = {}, const char * pName_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , module{ module_ } - , pName{ pName_ } - { - } - - VULKAN_HPP_CONSTEXPR CuFunctionCreateInfoNVX( CuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CuFunctionCreateInfoNVX( VkCuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : CuFunctionCreateInfoNVX( *reinterpret_cast( &rhs ) ) - { - } - - CuFunctionCreateInfoNVX & operator=( CuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CuFunctionCreateInfoNVX & operator=( VkCuFunctionCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX & setModule( CuModuleNVX module_ ) & VULKAN_HPP_NOEXCEPT - { - module = module_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX && setModule( CuModuleNVX module_ ) && VULKAN_HPP_NOEXCEPT - { - module = module_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuFunctionCreateInfoNVX && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCuFunctionCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCuFunctionCreateInfoNVX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCuFunctionCreateInfoNVX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCuFunctionCreateInfoNVX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, module, pName ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = module <=> rhs.module; cmp != 0 ) - return cmp; - if ( pName != rhs.pName ) - if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ); - } - - bool operator!=( CuFunctionCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eCuFunctionCreateInfoNVX; - const void * pNext = {}; - CuModuleNVX module = {}; - const char * pName = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CuFunctionCreateInfoNVX; - }; -#endif - - template <> - struct CppType - { - using Type = CuFunctionCreateInfoNVX; - }; - - // wrapper struct for struct VkCuLaunchInfoNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuLaunchInfoNVX.html - struct CuLaunchInfoNVX - { - using NativeType = VkCuLaunchInfoNVX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCuLaunchInfoNVX; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CuLaunchInfoNVX( CuFunctionNVX function_ = {}, - uint32_t gridDimX_ = {}, - uint32_t gridDimY_ = {}, - uint32_t gridDimZ_ = {}, - uint32_t blockDimX_ = {}, - uint32_t blockDimY_ = {}, - uint32_t blockDimZ_ = {}, - uint32_t sharedMemBytes_ = {}, - size_t paramCount_ = {}, - const void * const * pParams_ = {}, - size_t extraCount_ = {}, - const void * const * pExtras_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , function{ function_ } - , gridDimX{ gridDimX_ } - , gridDimY{ gridDimY_ } - , gridDimZ{ gridDimZ_ } - , blockDimX{ blockDimX_ } - , blockDimY{ blockDimY_ } - , blockDimZ{ blockDimZ_ } - , sharedMemBytes{ sharedMemBytes_ } - , paramCount{ paramCount_ } - , pParams{ pParams_ } - , extraCount{ extraCount_ } - , pExtras{ pExtras_ } - { - } - - VULKAN_HPP_CONSTEXPR CuLaunchInfoNVX( CuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CuLaunchInfoNVX( VkCuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT : CuLaunchInfoNVX( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CuLaunchInfoNVX( CuFunctionNVX function_, - uint32_t gridDimX_, - uint32_t gridDimY_, - uint32_t gridDimZ_, - uint32_t blockDimX_, - uint32_t blockDimY_, - uint32_t blockDimZ_, - uint32_t sharedMemBytes_, - ArrayProxyNoTemporaries const & params_, - ArrayProxyNoTemporaries const & extras_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , function( function_ ) - , gridDimX( gridDimX_ ) - , gridDimY( gridDimY_ ) - , gridDimZ( gridDimZ_ ) - , blockDimX( blockDimX_ ) - , blockDimY( blockDimY_ ) - , blockDimZ( blockDimZ_ ) - , sharedMemBytes( sharedMemBytes_ ) - , paramCount( params_.size() ) - , pParams( params_.data() ) - , extraCount( extras_.size() ) - , pExtras( extras_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CuLaunchInfoNVX & operator=( CuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CuLaunchInfoNVX & operator=( VkCuLaunchInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setFunction( CuFunctionNVX function_ ) & VULKAN_HPP_NOEXCEPT - { - function = function_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setFunction( CuFunctionNVX function_ ) && VULKAN_HPP_NOEXCEPT - { - function = function_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setGridDimX( uint32_t gridDimX_ ) & VULKAN_HPP_NOEXCEPT - { - gridDimX = gridDimX_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setGridDimX( uint32_t gridDimX_ ) && VULKAN_HPP_NOEXCEPT - { - gridDimX = gridDimX_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setGridDimY( uint32_t gridDimY_ ) & VULKAN_HPP_NOEXCEPT - { - gridDimY = gridDimY_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setGridDimY( uint32_t gridDimY_ ) && VULKAN_HPP_NOEXCEPT - { - gridDimY = gridDimY_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setGridDimZ( uint32_t gridDimZ_ ) & VULKAN_HPP_NOEXCEPT - { - gridDimZ = gridDimZ_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setGridDimZ( uint32_t gridDimZ_ ) && VULKAN_HPP_NOEXCEPT - { - gridDimZ = gridDimZ_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setBlockDimX( uint32_t blockDimX_ ) & VULKAN_HPP_NOEXCEPT - { - blockDimX = blockDimX_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setBlockDimX( uint32_t blockDimX_ ) && VULKAN_HPP_NOEXCEPT - { - blockDimX = blockDimX_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setBlockDimY( uint32_t blockDimY_ ) & VULKAN_HPP_NOEXCEPT - { - blockDimY = blockDimY_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setBlockDimY( uint32_t blockDimY_ ) && VULKAN_HPP_NOEXCEPT - { - blockDimY = blockDimY_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setBlockDimZ( uint32_t blockDimZ_ ) & VULKAN_HPP_NOEXCEPT - { - blockDimZ = blockDimZ_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setBlockDimZ( uint32_t blockDimZ_ ) && VULKAN_HPP_NOEXCEPT - { - blockDimZ = blockDimZ_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setSharedMemBytes( uint32_t sharedMemBytes_ ) & VULKAN_HPP_NOEXCEPT - { - sharedMemBytes = sharedMemBytes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setSharedMemBytes( uint32_t sharedMemBytes_ ) && VULKAN_HPP_NOEXCEPT - { - sharedMemBytes = sharedMemBytes_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setParamCount( size_t paramCount_ ) & VULKAN_HPP_NOEXCEPT - { - paramCount = paramCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setParamCount( size_t paramCount_ ) && VULKAN_HPP_NOEXCEPT - { - paramCount = paramCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setPParams( const void * const * pParams_ ) & VULKAN_HPP_NOEXCEPT - { - pParams = pParams_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setPParams( const void * const * pParams_ ) && VULKAN_HPP_NOEXCEPT - { - pParams = pParams_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CuLaunchInfoNVX & setParams( ArrayProxyNoTemporaries const & params_ ) VULKAN_HPP_NOEXCEPT - { - paramCount = params_.size(); - pParams = params_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setExtraCount( size_t extraCount_ ) & VULKAN_HPP_NOEXCEPT - { - extraCount = extraCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setExtraCount( size_t extraCount_ ) && VULKAN_HPP_NOEXCEPT - { - extraCount = extraCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX & setPExtras( const void * const * pExtras_ ) & VULKAN_HPP_NOEXCEPT - { - pExtras = pExtras_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuLaunchInfoNVX && setPExtras( const void * const * pExtras_ ) && VULKAN_HPP_NOEXCEPT - { - pExtras = pExtras_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CuLaunchInfoNVX & setExtras( ArrayProxyNoTemporaries const & extras_ ) VULKAN_HPP_NOEXCEPT - { - extraCount = extras_.size(); - pExtras = extras_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCuLaunchInfoNVX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCuLaunchInfoNVX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCuLaunchInfoNVX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCuLaunchInfoNVX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, function, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, paramCount, pParams, extraCount, pExtras ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CuLaunchInfoNVX const & ) const = default; -#else - bool operator==( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) && ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) && - ( gridDimZ == rhs.gridDimZ ) && ( blockDimX == rhs.blockDimX ) && ( blockDimY == rhs.blockDimY ) && ( blockDimZ == rhs.blockDimZ ) && - ( sharedMemBytes == rhs.sharedMemBytes ) && ( paramCount == rhs.paramCount ) && ( pParams == rhs.pParams ) && ( extraCount == rhs.extraCount ) && - ( pExtras == rhs.pExtras ); -# endif - } - - bool operator!=( CuLaunchInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCuLaunchInfoNVX; - const void * pNext = {}; - CuFunctionNVX function = {}; - uint32_t gridDimX = {}; - uint32_t gridDimY = {}; - uint32_t gridDimZ = {}; - uint32_t blockDimX = {}; - uint32_t blockDimY = {}; - uint32_t blockDimZ = {}; - uint32_t sharedMemBytes = {}; - size_t paramCount = {}; - const void * const * pParams = {}; - size_t extraCount = {}; - const void * const * pExtras = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CuLaunchInfoNVX; - }; -#endif - - template <> - struct CppType - { - using Type = CuLaunchInfoNVX; - }; - - // wrapper struct for struct VkCuModuleCreateInfoNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleCreateInfoNVX.html - struct CuModuleCreateInfoNVX - { - using NativeType = VkCuModuleCreateInfoNVX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCuModuleCreateInfoNVX; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CuModuleCreateInfoNVX( size_t dataSize_ = {}, const void * pData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dataSize{ dataSize_ } - , pData{ pData_ } - { - } - - VULKAN_HPP_CONSTEXPR CuModuleCreateInfoNVX( CuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CuModuleCreateInfoNVX( VkCuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : CuModuleCreateInfoNVX( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - CuModuleCreateInfoNVX( ArrayProxyNoTemporaries const & data_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CuModuleCreateInfoNVX & operator=( CuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CuModuleCreateInfoNVX & operator=( VkCuModuleCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX & setPData( const void * pData_ ) & VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuModuleCreateInfoNVX && setPData( const void * pData_ ) && VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - CuModuleCreateInfoNVX & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT - { - dataSize = data_.size() * sizeof( T ); - pData = data_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCuModuleCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCuModuleCreateInfoNVX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCuModuleCreateInfoNVX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCuModuleCreateInfoNVX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dataSize, pData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CuModuleCreateInfoNVX const & ) const = default; -#else - bool operator==( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); -# endif - } - - bool operator!=( CuModuleCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCuModuleCreateInfoNVX; - const void * pNext = {}; - size_t dataSize = {}; - const void * pData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CuModuleCreateInfoNVX; - }; -#endif - - template <> - struct CppType - { - using Type = CuModuleCreateInfoNVX; - }; - - // wrapper struct for struct VkCuModuleTexturingModeCreateInfoNVX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkCuModuleTexturingModeCreateInfoNVX.html - struct CuModuleTexturingModeCreateInfoNVX - { - using NativeType = VkCuModuleTexturingModeCreateInfoNVX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCuModuleTexturingModeCreateInfoNVX; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CuModuleTexturingModeCreateInfoNVX( Bool32 use64bitTexturing_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , use64bitTexturing{ use64bitTexturing_ } - { - } - - VULKAN_HPP_CONSTEXPR CuModuleTexturingModeCreateInfoNVX( CuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CuModuleTexturingModeCreateInfoNVX( VkCuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : CuModuleTexturingModeCreateInfoNVX( *reinterpret_cast( &rhs ) ) - { - } - - CuModuleTexturingModeCreateInfoNVX & operator=( CuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CuModuleTexturingModeCreateInfoNVX & operator=( VkCuModuleTexturingModeCreateInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX & setUse64bitTexturing( Bool32 use64bitTexturing_ ) & VULKAN_HPP_NOEXCEPT - { - use64bitTexturing = use64bitTexturing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CuModuleTexturingModeCreateInfoNVX && setUse64bitTexturing( Bool32 use64bitTexturing_ ) && VULKAN_HPP_NOEXCEPT - { - use64bitTexturing = use64bitTexturing_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCuModuleTexturingModeCreateInfoNVX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCuModuleTexturingModeCreateInfoNVX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCuModuleTexturingModeCreateInfoNVX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCuModuleTexturingModeCreateInfoNVX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, use64bitTexturing ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CuModuleTexturingModeCreateInfoNVX const & ) const = default; -#else - bool operator==( CuModuleTexturingModeCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( use64bitTexturing == rhs.use64bitTexturing ); -# endif - } - - bool operator!=( CuModuleTexturingModeCreateInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCuModuleTexturingModeCreateInfoNVX; - const void * pNext = {}; - Bool32 use64bitTexturing = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CuModuleTexturingModeCreateInfoNVX; - }; -#endif - - template <> - struct CppType - { - using Type = CuModuleTexturingModeCreateInfoNVX; - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkCudaFunctionCreateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaFunctionCreateInfoNV.html - struct CudaFunctionCreateInfoNV - { - using NativeType = VkCudaFunctionCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCudaFunctionCreateInfoNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CudaFunctionCreateInfoNV( CudaModuleNV module_ = {}, const char * pName_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , module{ module_ } - , pName{ pName_ } - { - } - - VULKAN_HPP_CONSTEXPR CudaFunctionCreateInfoNV( CudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CudaFunctionCreateInfoNV( VkCudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : CudaFunctionCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - CudaFunctionCreateInfoNV & operator=( CudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CudaFunctionCreateInfoNV & operator=( VkCudaFunctionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV & setModule( CudaModuleNV module_ ) & VULKAN_HPP_NOEXCEPT - { - module = module_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV && setModule( CudaModuleNV module_ ) && VULKAN_HPP_NOEXCEPT - { - module = module_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaFunctionCreateInfoNV && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCudaFunctionCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCudaFunctionCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCudaFunctionCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCudaFunctionCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, module, pName ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( CudaFunctionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = module <=> rhs.module; cmp != 0 ) - return cmp; - if ( pName != rhs.pName ) - if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -# endif - - bool operator==( CudaFunctionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ); - } - - bool operator!=( CudaFunctionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eCudaFunctionCreateInfoNV; - const void * pNext = {}; - CudaModuleNV module = {}; - const char * pName = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CudaFunctionCreateInfoNV; - }; -# endif - - template <> - struct CppType - { - using Type = CudaFunctionCreateInfoNV; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkCudaLaunchInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaLaunchInfoNV.html - struct CudaLaunchInfoNV - { - using NativeType = VkCudaLaunchInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCudaLaunchInfoNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CudaLaunchInfoNV( CudaFunctionNV function_ = {}, - uint32_t gridDimX_ = {}, - uint32_t gridDimY_ = {}, - uint32_t gridDimZ_ = {}, - uint32_t blockDimX_ = {}, - uint32_t blockDimY_ = {}, - uint32_t blockDimZ_ = {}, - uint32_t sharedMemBytes_ = {}, - size_t paramCount_ = {}, - const void * const * pParams_ = {}, - size_t extraCount_ = {}, - const void * const * pExtras_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , function{ function_ } - , gridDimX{ gridDimX_ } - , gridDimY{ gridDimY_ } - , gridDimZ{ gridDimZ_ } - , blockDimX{ blockDimX_ } - , blockDimY{ blockDimY_ } - , blockDimZ{ blockDimZ_ } - , sharedMemBytes{ sharedMemBytes_ } - , paramCount{ paramCount_ } - , pParams{ pParams_ } - , extraCount{ extraCount_ } - , pExtras{ pExtras_ } - { - } - - VULKAN_HPP_CONSTEXPR CudaLaunchInfoNV( CudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CudaLaunchInfoNV( VkCudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT : CudaLaunchInfoNV( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CudaLaunchInfoNV( CudaFunctionNV function_, - uint32_t gridDimX_, - uint32_t gridDimY_, - uint32_t gridDimZ_, - uint32_t blockDimX_, - uint32_t blockDimY_, - uint32_t blockDimZ_, - uint32_t sharedMemBytes_, - ArrayProxyNoTemporaries const & params_, - ArrayProxyNoTemporaries const & extras_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , function( function_ ) - , gridDimX( gridDimX_ ) - , gridDimY( gridDimY_ ) - , gridDimZ( gridDimZ_ ) - , blockDimX( blockDimX_ ) - , blockDimY( blockDimY_ ) - , blockDimZ( blockDimZ_ ) - , sharedMemBytes( sharedMemBytes_ ) - , paramCount( params_.size() ) - , pParams( params_.data() ) - , extraCount( extras_.size() ) - , pExtras( extras_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CudaLaunchInfoNV & operator=( CudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CudaLaunchInfoNV & operator=( VkCudaLaunchInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setFunction( CudaFunctionNV function_ ) & VULKAN_HPP_NOEXCEPT - { - function = function_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setFunction( CudaFunctionNV function_ ) && VULKAN_HPP_NOEXCEPT - { - function = function_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setGridDimX( uint32_t gridDimX_ ) & VULKAN_HPP_NOEXCEPT - { - gridDimX = gridDimX_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setGridDimX( uint32_t gridDimX_ ) && VULKAN_HPP_NOEXCEPT - { - gridDimX = gridDimX_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setGridDimY( uint32_t gridDimY_ ) & VULKAN_HPP_NOEXCEPT - { - gridDimY = gridDimY_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setGridDimY( uint32_t gridDimY_ ) && VULKAN_HPP_NOEXCEPT - { - gridDimY = gridDimY_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setGridDimZ( uint32_t gridDimZ_ ) & VULKAN_HPP_NOEXCEPT - { - gridDimZ = gridDimZ_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setGridDimZ( uint32_t gridDimZ_ ) && VULKAN_HPP_NOEXCEPT - { - gridDimZ = gridDimZ_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setBlockDimX( uint32_t blockDimX_ ) & VULKAN_HPP_NOEXCEPT - { - blockDimX = blockDimX_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setBlockDimX( uint32_t blockDimX_ ) && VULKAN_HPP_NOEXCEPT - { - blockDimX = blockDimX_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setBlockDimY( uint32_t blockDimY_ ) & VULKAN_HPP_NOEXCEPT - { - blockDimY = blockDimY_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setBlockDimY( uint32_t blockDimY_ ) && VULKAN_HPP_NOEXCEPT - { - blockDimY = blockDimY_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setBlockDimZ( uint32_t blockDimZ_ ) & VULKAN_HPP_NOEXCEPT - { - blockDimZ = blockDimZ_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setBlockDimZ( uint32_t blockDimZ_ ) && VULKAN_HPP_NOEXCEPT - { - blockDimZ = blockDimZ_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setSharedMemBytes( uint32_t sharedMemBytes_ ) & VULKAN_HPP_NOEXCEPT - { - sharedMemBytes = sharedMemBytes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setSharedMemBytes( uint32_t sharedMemBytes_ ) && VULKAN_HPP_NOEXCEPT - { - sharedMemBytes = sharedMemBytes_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setParamCount( size_t paramCount_ ) & VULKAN_HPP_NOEXCEPT - { - paramCount = paramCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setParamCount( size_t paramCount_ ) && VULKAN_HPP_NOEXCEPT - { - paramCount = paramCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setPParams( const void * const * pParams_ ) & VULKAN_HPP_NOEXCEPT - { - pParams = pParams_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setPParams( const void * const * pParams_ ) && VULKAN_HPP_NOEXCEPT - { - pParams = pParams_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CudaLaunchInfoNV & setParams( ArrayProxyNoTemporaries const & params_ ) VULKAN_HPP_NOEXCEPT - { - paramCount = params_.size(); - pParams = params_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setExtraCount( size_t extraCount_ ) & VULKAN_HPP_NOEXCEPT - { - extraCount = extraCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setExtraCount( size_t extraCount_ ) && VULKAN_HPP_NOEXCEPT - { - extraCount = extraCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV & setPExtras( const void * const * pExtras_ ) & VULKAN_HPP_NOEXCEPT - { - pExtras = pExtras_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaLaunchInfoNV && setPExtras( const void * const * pExtras_ ) && VULKAN_HPP_NOEXCEPT - { - pExtras = pExtras_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CudaLaunchInfoNV & setExtras( ArrayProxyNoTemporaries const & extras_ ) VULKAN_HPP_NOEXCEPT - { - extraCount = extras_.size(); - pExtras = extras_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCudaLaunchInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCudaLaunchInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCudaLaunchInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCudaLaunchInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, function, gridDimX, gridDimY, gridDimZ, blockDimX, blockDimY, blockDimZ, sharedMemBytes, paramCount, pParams, extraCount, pExtras ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CudaLaunchInfoNV const & ) const = default; -# else - bool operator==( CudaLaunchInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( function == rhs.function ) && ( gridDimX == rhs.gridDimX ) && ( gridDimY == rhs.gridDimY ) && - ( gridDimZ == rhs.gridDimZ ) && ( blockDimX == rhs.blockDimX ) && ( blockDimY == rhs.blockDimY ) && ( blockDimZ == rhs.blockDimZ ) && - ( sharedMemBytes == rhs.sharedMemBytes ) && ( paramCount == rhs.paramCount ) && ( pParams == rhs.pParams ) && ( extraCount == rhs.extraCount ) && - ( pExtras == rhs.pExtras ); -# endif - } - - bool operator!=( CudaLaunchInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eCudaLaunchInfoNV; - const void * pNext = {}; - CudaFunctionNV function = {}; - uint32_t gridDimX = {}; - uint32_t gridDimY = {}; - uint32_t gridDimZ = {}; - uint32_t blockDimX = {}; - uint32_t blockDimY = {}; - uint32_t blockDimZ = {}; - uint32_t sharedMemBytes = {}; - size_t paramCount = {}; - const void * const * pParams = {}; - size_t extraCount = {}; - const void * const * pExtras = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CudaLaunchInfoNV; - }; -# endif - - template <> - struct CppType - { - using Type = CudaLaunchInfoNV; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkCudaModuleCreateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCudaModuleCreateInfoNV.html - struct CudaModuleCreateInfoNV - { - using NativeType = VkCudaModuleCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCudaModuleCreateInfoNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CudaModuleCreateInfoNV( size_t dataSize_ = {}, const void * pData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dataSize{ dataSize_ } - , pData{ pData_ } - { - } - - VULKAN_HPP_CONSTEXPR CudaModuleCreateInfoNV( CudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CudaModuleCreateInfoNV( VkCudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : CudaModuleCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - CudaModuleCreateInfoNV( ArrayProxyNoTemporaries const & data_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CudaModuleCreateInfoNV & operator=( CudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CudaModuleCreateInfoNV & operator=( VkCudaModuleCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV & setPData( const void * pData_ ) & VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CudaModuleCreateInfoNV && setPData( const void * pData_ ) && VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - CudaModuleCreateInfoNV & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT - { - dataSize = data_.size() * sizeof( T ); - pData = data_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCudaModuleCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCudaModuleCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCudaModuleCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCudaModuleCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dataSize, pData ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CudaModuleCreateInfoNV const & ) const = default; -# else - bool operator==( CudaModuleCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); -# endif - } - - bool operator!=( CudaModuleCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eCudaModuleCreateInfoNV; - const void * pNext = {}; - size_t dataSize = {}; - const void * pData = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CudaModuleCreateInfoNV; - }; -# endif - - template <> - struct CppType - { - using Type = CudaModuleCreateInfoNV; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkCustomResolveCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkCustomResolveCreateInfoEXT.html - struct CustomResolveCreateInfoEXT - { - using NativeType = VkCustomResolveCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eCustomResolveCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR CustomResolveCreateInfoEXT( Bool32 customResolve_ = {}, - uint32_t colorAttachmentCount_ = {}, - const Format * pColorAttachmentFormats_ = {}, - Format depthAttachmentFormat_ = Format::eUndefined, - Format stencilAttachmentFormat_ = Format::eUndefined, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , customResolve{ customResolve_ } - , colorAttachmentCount{ colorAttachmentCount_ } - , pColorAttachmentFormats{ pColorAttachmentFormats_ } - , depthAttachmentFormat{ depthAttachmentFormat_ } - , stencilAttachmentFormat{ stencilAttachmentFormat_ } - { - } - - VULKAN_HPP_CONSTEXPR CustomResolveCreateInfoEXT( CustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - CustomResolveCreateInfoEXT( VkCustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : CustomResolveCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CustomResolveCreateInfoEXT( Bool32 customResolve_, - ArrayProxyNoTemporaries const & colorAttachmentFormats_, - Format depthAttachmentFormat_ = Format::eUndefined, - Format stencilAttachmentFormat_ = Format::eUndefined, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , customResolve( customResolve_ ) - , colorAttachmentCount( static_cast( colorAttachmentFormats_.size() ) ) - , pColorAttachmentFormats( colorAttachmentFormats_.data() ) - , depthAttachmentFormat( depthAttachmentFormat_ ) - , stencilAttachmentFormat( stencilAttachmentFormat_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - CustomResolveCreateInfoEXT & operator=( CustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - CustomResolveCreateInfoEXT & operator=( VkCustomResolveCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setCustomResolve( Bool32 customResolve_ ) & VULKAN_HPP_NOEXCEPT - { - customResolve = customResolve_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setCustomResolve( Bool32 customResolve_ ) && VULKAN_HPP_NOEXCEPT - { - customResolve = customResolve_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) & VULKAN_HPP_NOEXCEPT - { - pColorAttachmentFormats = pColorAttachmentFormats_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) && VULKAN_HPP_NOEXCEPT - { - pColorAttachmentFormats = pColorAttachmentFormats_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - CustomResolveCreateInfoEXT & setColorAttachmentFormats( ArrayProxyNoTemporaries const & colorAttachmentFormats_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( colorAttachmentFormats_.size() ); - pColorAttachmentFormats = colorAttachmentFormats_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setDepthAttachmentFormat( Format depthAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT - { - depthAttachmentFormat = depthAttachmentFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setDepthAttachmentFormat( Format depthAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT - { - depthAttachmentFormat = depthAttachmentFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT & setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT - { - stencilAttachmentFormat = stencilAttachmentFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 CustomResolveCreateInfoEXT && setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT - { - stencilAttachmentFormat = stencilAttachmentFormat_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkCustomResolveCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCustomResolveCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkCustomResolveCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkCustomResolveCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, customResolve, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( CustomResolveCreateInfoEXT const & ) const = default; -#else - bool operator==( CustomResolveCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customResolve == rhs.customResolve ) && - ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && - ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ); -# endif - } - - bool operator!=( CustomResolveCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eCustomResolveCreateInfoEXT; - const void * pNext = {}; - Bool32 customResolve = {}; - uint32_t colorAttachmentCount = {}; - const Format * pColorAttachmentFormats = {}; - Format depthAttachmentFormat = Format::eUndefined; - Format stencilAttachmentFormat = Format::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = CustomResolveCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = CustomResolveCreateInfoEXT; - }; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkD3D12FenceSubmitInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkD3D12FenceSubmitInfoKHR.html - struct D3D12FenceSubmitInfoKHR - { - using NativeType = VkD3D12FenceSubmitInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eD3D12FenceSubmitInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( uint32_t waitSemaphoreValuesCount_ = {}, - const uint64_t * pWaitSemaphoreValues_ = {}, - uint32_t signalSemaphoreValuesCount_ = {}, - const uint64_t * pSignalSemaphoreValues_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , waitSemaphoreValuesCount{ waitSemaphoreValuesCount_ } - , pWaitSemaphoreValues{ pWaitSemaphoreValues_ } - , signalSemaphoreValuesCount{ signalSemaphoreValuesCount_ } - , pSignalSemaphoreValues{ pSignalSemaphoreValues_ } - { - } - - VULKAN_HPP_CONSTEXPR D3D12FenceSubmitInfoKHR( D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - D3D12FenceSubmitInfoKHR( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : D3D12FenceSubmitInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - D3D12FenceSubmitInfoKHR( ArrayProxyNoTemporaries const & waitSemaphoreValues_, - ArrayProxyNoTemporaries const & signalSemaphoreValues_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , waitSemaphoreValuesCount( static_cast( waitSemaphoreValues_.size() ) ) - , pWaitSemaphoreValues( waitSemaphoreValues_.data() ) - , signalSemaphoreValuesCount( static_cast( signalSemaphoreValues_.size() ) ) - , pSignalSemaphoreValues( signalSemaphoreValues_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - D3D12FenceSubmitInfoKHR & operator=( D3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - D3D12FenceSubmitInfoKHR & operator=( VkD3D12FenceSubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) & VULKAN_HPP_NOEXCEPT - { - waitSemaphoreValuesCount = waitSemaphoreValuesCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setWaitSemaphoreValuesCount( uint32_t waitSemaphoreValuesCount_ ) && VULKAN_HPP_NOEXCEPT - { - waitSemaphoreValuesCount = waitSemaphoreValuesCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setPWaitSemaphoreValues( const uint64_t * pWaitSemaphoreValues_ ) & VULKAN_HPP_NOEXCEPT - { - pWaitSemaphoreValues = pWaitSemaphoreValues_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setPWaitSemaphoreValues( const uint64_t * pWaitSemaphoreValues_ ) && VULKAN_HPP_NOEXCEPT - { - pWaitSemaphoreValues = pWaitSemaphoreValues_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - D3D12FenceSubmitInfoKHR & setWaitSemaphoreValues( ArrayProxyNoTemporaries const & waitSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT - { - waitSemaphoreValuesCount = static_cast( waitSemaphoreValues_.size() ); - pWaitSemaphoreValues = waitSemaphoreValues_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) & VULKAN_HPP_NOEXCEPT - { - signalSemaphoreValuesCount = signalSemaphoreValuesCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setSignalSemaphoreValuesCount( uint32_t signalSemaphoreValuesCount_ ) && VULKAN_HPP_NOEXCEPT - { - signalSemaphoreValuesCount = signalSemaphoreValuesCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR & setPSignalSemaphoreValues( const uint64_t * pSignalSemaphoreValues_ ) & VULKAN_HPP_NOEXCEPT - { - pSignalSemaphoreValues = pSignalSemaphoreValues_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 D3D12FenceSubmitInfoKHR && setPSignalSemaphoreValues( const uint64_t * pSignalSemaphoreValues_ ) && VULKAN_HPP_NOEXCEPT - { - pSignalSemaphoreValues = pSignalSemaphoreValues_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - D3D12FenceSubmitInfoKHR & setSignalSemaphoreValues( ArrayProxyNoTemporaries const & signalSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT - { - signalSemaphoreValuesCount = static_cast( signalSemaphoreValues_.size() ); - pSignalSemaphoreValues = signalSemaphoreValues_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkD3D12FenceSubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkD3D12FenceSubmitInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkD3D12FenceSubmitInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkD3D12FenceSubmitInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, waitSemaphoreValuesCount, pWaitSemaphoreValues, signalSemaphoreValuesCount, pSignalSemaphoreValues ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( D3D12FenceSubmitInfoKHR const & ) const = default; -# else - bool operator==( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreValuesCount == rhs.waitSemaphoreValuesCount ) && - ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) && ( signalSemaphoreValuesCount == rhs.signalSemaphoreValuesCount ) && - ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); -# endif - } - - bool operator!=( D3D12FenceSubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eD3D12FenceSubmitInfoKHR; - const void * pNext = {}; - uint32_t waitSemaphoreValuesCount = {}; - const uint64_t * pWaitSemaphoreValues = {}; - uint32_t signalSemaphoreValuesCount = {}; - const uint64_t * pSignalSemaphoreValues = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = D3D12FenceSubmitInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = D3D12FenceSubmitInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - // wrapper struct for struct VkPhysicalDeviceDataGraphOperationSupportARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphOperationSupportARM.html - struct PhysicalDeviceDataGraphOperationSupportARM - { - using NativeType = VkPhysicalDeviceDataGraphOperationSupportARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM( - PhysicalDeviceDataGraphOperationTypeARM operationType_ = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet, - std::array const & name_ = {}, - uint32_t version_ = {} ) VULKAN_HPP_NOEXCEPT - : operationType{ operationType_ } - , name{ name_ } - , version{ version_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDataGraphOperationSupportARM( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDataGraphOperationSupportARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PhysicalDeviceDataGraphOperationSupportARM( PhysicalDeviceDataGraphOperationTypeARM operationType_, std::string const & name_, uint32_t version_ = {} ) - : operationType( operationType_ ), version( version_ ) - { - VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM ); -# if defined( _WIN32 ) - strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() ); -# else - strncpy( name, name_.data(), std::min( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) ); -# endif - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PhysicalDeviceDataGraphOperationSupportARM & operator=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDataGraphOperationSupportARM & operator=( VkPhysicalDeviceDataGraphOperationSupportARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) & - VULKAN_HPP_NOEXCEPT - { - operationType = operationType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM && setOperationType( PhysicalDeviceDataGraphOperationTypeARM operationType_ ) && - VULKAN_HPP_NOEXCEPT - { - operationType = operationType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & - setName( std::array name_ ) & - VULKAN_HPP_NOEXCEPT - { - name = name_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM && - setName( std::array name_ ) && - VULKAN_HPP_NOEXCEPT - { - name = name_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PhysicalDeviceDataGraphOperationSupportARM & setName( std::string const & name_ ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( name_.size() < VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM ); -# if defined( _WIN32 ) - strncpy_s( name, VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.data(), name_.size() ); -# else - strncpy( name, name_.data(), std::min( VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM, name_.size() ) ); -# endif - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM & setVersion( uint32_t version_ ) & VULKAN_HPP_NOEXCEPT - { - version = version_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphOperationSupportARM && setVersion( uint32_t version_ ) && VULKAN_HPP_NOEXCEPT - { - version = version_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDataGraphOperationSupportARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphOperationSupportARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphOperationSupportARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphOperationSupportARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - uint32_t const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( operationType, name, version ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = operationType <=> rhs.operationType; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = version <=> rhs.version; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( operationType == rhs.operationType ) && ( strcmp( name, rhs.name ) == 0 ) && ( version == rhs.version ); - } - - bool operator!=( PhysicalDeviceDataGraphOperationSupportARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - PhysicalDeviceDataGraphOperationTypeARM operationType = PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet; - ArrayWrapper1D name = {}; - uint32_t version = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDataGraphOperationSupportARM; - }; -#endif - - // wrapper struct for struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineBuiltinModelCreateInfoQCOM.html - struct DataGraphPipelineBuiltinModelCreateInfoQCOM - { - using NativeType = VkDataGraphPipelineBuiltinModelCreateInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pOperation{ pOperation_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - DataGraphPipelineBuiltinModelCreateInfoQCOM( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineBuiltinModelCreateInfoQCOM( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineBuiltinModelCreateInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineBuiltinModelCreateInfoQCOM & operator=( VkDataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM & setPOperation( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ ) & - VULKAN_HPP_NOEXCEPT - { - pOperation = pOperation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineBuiltinModelCreateInfoQCOM && setPOperation( const PhysicalDeviceDataGraphOperationSupportARM * pOperation_ ) && - VULKAN_HPP_NOEXCEPT - { - pOperation = pOperation_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineBuiltinModelCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pOperation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineBuiltinModelCreateInfoQCOM const & ) const = default; -#else - bool operator==( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pOperation == rhs.pOperation ); -# endif - } - - bool operator!=( DataGraphPipelineBuiltinModelCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM; - const void * pNext = {}; - const PhysicalDeviceDataGraphOperationSupportARM * pOperation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineBuiltinModelCreateInfoQCOM; - }; - - // wrapper struct for struct VkDataGraphPipelineCompilerControlCreateInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineCompilerControlCreateInfoARM.html - struct DataGraphPipelineCompilerControlCreateInfoARM - { - using NativeType = VkDataGraphPipelineCompilerControlCreateInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineCompilerControlCreateInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineCompilerControlCreateInfoARM( const char * pVendorOptions_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pVendorOptions{ pVendorOptions_ } - { - } - - VULKAN_HPP_CONSTEXPR - DataGraphPipelineCompilerControlCreateInfoARM( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineCompilerControlCreateInfoARM( VkDataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineCompilerControlCreateInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - DataGraphPipelineCompilerControlCreateInfoARM & operator=( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineCompilerControlCreateInfoARM & operator=( VkDataGraphPipelineCompilerControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM & setPVendorOptions( const char * pVendorOptions_ ) & VULKAN_HPP_NOEXCEPT - { - pVendorOptions = pVendorOptions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCompilerControlCreateInfoARM && setPVendorOptions( const char * pVendorOptions_ ) && VULKAN_HPP_NOEXCEPT - { - pVendorOptions = pVendorOptions_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineCompilerControlCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineCompilerControlCreateInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineCompilerControlCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineCompilerControlCreateInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pVendorOptions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( pVendorOptions != rhs.pVendorOptions ) - if ( auto cmp = strcmp( pVendorOptions, rhs.pVendorOptions ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( ( pVendorOptions == rhs.pVendorOptions ) || ( strcmp( pVendorOptions, rhs.pVendorOptions ) == 0 ) ); - } - - bool operator!=( DataGraphPipelineCompilerControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDataGraphPipelineCompilerControlCreateInfoARM; - const void * pNext = {}; - const char * pVendorOptions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineCompilerControlCreateInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineCompilerControlCreateInfoARM; - }; - - // wrapper struct for struct VkDataGraphPipelineConstantARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineConstantARM.html - struct DataGraphPipelineConstantARM - { - using NativeType = VkDataGraphPipelineConstantARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineConstantARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantARM( uint32_t id_ = {}, const void * pConstantData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , id{ id_ } - , pConstantData{ pConstantData_ } - { - } - - VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantARM( DataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineConstantARM( VkDataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineConstantARM( *reinterpret_cast( &rhs ) ) - { - } - - DataGraphPipelineConstantARM & operator=( DataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineConstantARM & operator=( VkDataGraphPipelineConstantARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM & setId( uint32_t id_ ) & VULKAN_HPP_NOEXCEPT - { - id = id_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM && setId( uint32_t id_ ) && VULKAN_HPP_NOEXCEPT - { - id = id_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM & setPConstantData( const void * pConstantData_ ) & VULKAN_HPP_NOEXCEPT - { - pConstantData = pConstantData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantARM && setPConstantData( const void * pConstantData_ ) && VULKAN_HPP_NOEXCEPT - { - pConstantData = pConstantData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineConstantARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineConstantARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineConstantARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineConstantARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, id, pConstantData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineConstantARM const & ) const = default; -#else - bool operator==( DataGraphPipelineConstantARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( id == rhs.id ) && ( pConstantData == rhs.pConstantData ); -# endif - } - - bool operator!=( DataGraphPipelineConstantARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineConstantARM; - const void * pNext = {}; - uint32_t id = {}; - const void * pConstantData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineConstantARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineConstantARM; - }; - - // wrapper struct for struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM.html - struct DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM - { - using NativeType = VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM( uint32_t dimension_ = {}, - uint32_t zeroCount_ = {}, - uint32_t groupSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dimension{ dimension_ } - , zeroCount{ zeroCount_ } - , groupSize{ groupSize_ } - { - } - - VULKAN_HPP_CONSTEXPR DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM( - DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM( VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) - VULKAN_HPP_NOEXCEPT - : DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM( - *reinterpret_cast( &rhs ) ) - { - } - - DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & - operator=( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & - operator=( VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setDimension( uint32_t dimension_ ) & VULKAN_HPP_NOEXCEPT - { - dimension = dimension_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setDimension( uint32_t dimension_ ) && VULKAN_HPP_NOEXCEPT - { - dimension = dimension_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setZeroCount( uint32_t zeroCount_ ) & VULKAN_HPP_NOEXCEPT - { - zeroCount = zeroCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setZeroCount( uint32_t zeroCount_ ) && VULKAN_HPP_NOEXCEPT - { - zeroCount = zeroCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM & setGroupSize( uint32_t groupSize_ ) & VULKAN_HPP_NOEXCEPT - { - groupSize = groupSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM && setGroupSize( uint32_t groupSize_ ) && VULKAN_HPP_NOEXCEPT - { - groupSize = groupSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dimension, zeroCount, groupSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & ) const = default; -#else - bool operator==( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dimension == rhs.dimension ) && ( zeroCount == rhs.zeroCount ) && - ( groupSize == rhs.groupSize ); -# endif - } - - bool operator!=( DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; - const void * pNext = {}; - uint32_t dimension = {}; - uint32_t zeroCount = {}; - uint32_t groupSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM; - }; - - // wrapper struct for struct VkDataGraphPipelineResourceInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineResourceInfoARM.html - struct DataGraphPipelineResourceInfoARM - { - using NativeType = VkDataGraphPipelineResourceInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineResourceInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineResourceInfoARM( uint32_t descriptorSet_ = {}, - uint32_t binding_ = {}, - uint32_t arrayElement_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorSet{ descriptorSet_ } - , binding{ binding_ } - , arrayElement{ arrayElement_ } - { - } - - VULKAN_HPP_CONSTEXPR DataGraphPipelineResourceInfoARM( DataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineResourceInfoARM( VkDataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineResourceInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - DataGraphPipelineResourceInfoARM & operator=( DataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineResourceInfoARM & operator=( VkDataGraphPipelineResourceInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setDescriptorSet( uint32_t descriptorSet_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorSet = descriptorSet_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setDescriptorSet( uint32_t descriptorSet_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorSet = descriptorSet_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM & setArrayElement( uint32_t arrayElement_ ) & VULKAN_HPP_NOEXCEPT - { - arrayElement = arrayElement_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineResourceInfoARM && setArrayElement( uint32_t arrayElement_ ) && VULKAN_HPP_NOEXCEPT - { - arrayElement = arrayElement_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineResourceInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineResourceInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineResourceInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineResourceInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorSet, binding, arrayElement ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineResourceInfoARM const & ) const = default; -#else - bool operator==( DataGraphPipelineResourceInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSet == rhs.descriptorSet ) && ( binding == rhs.binding ) && - ( arrayElement == rhs.arrayElement ); -# endif - } - - bool operator!=( DataGraphPipelineResourceInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineResourceInfoARM; - const void * pNext = {}; - uint32_t descriptorSet = {}; - uint32_t binding = {}; - uint32_t arrayElement = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineResourceInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineResourceInfoARM; - }; - - // wrapper struct for struct VkDataGraphPipelineCreateInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineCreateInfoARM.html - struct DataGraphPipelineCreateInfoARM - { - using NativeType = VkDataGraphPipelineCreateInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineCreateInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineCreateInfoARM( PipelineCreateFlags2KHR flags_ = {}, - PipelineLayout layout_ = {}, - uint32_t resourceInfoCount_ = {}, - const DataGraphPipelineResourceInfoARM * pResourceInfos_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , layout{ layout_ } - , resourceInfoCount{ resourceInfoCount_ } - , pResourceInfos{ pResourceInfos_ } - { - } - - VULKAN_HPP_CONSTEXPR DataGraphPipelineCreateInfoARM( DataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineCreateInfoARM( VkDataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineCreateInfoARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DataGraphPipelineCreateInfoARM( PipelineCreateFlags2KHR flags_, - PipelineLayout layout_, - ArrayProxyNoTemporaries const & resourceInfos_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , layout( layout_ ) - , resourceInfoCount( static_cast( resourceInfos_.size() ) ) - , pResourceInfos( resourceInfos_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DataGraphPipelineCreateInfoARM & operator=( DataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineCreateInfoARM & operator=( VkDataGraphPipelineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setFlags( PipelineCreateFlags2KHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setFlags( PipelineCreateFlags2KHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setResourceInfoCount( uint32_t resourceInfoCount_ ) & VULKAN_HPP_NOEXCEPT - { - resourceInfoCount = resourceInfoCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setResourceInfoCount( uint32_t resourceInfoCount_ ) && VULKAN_HPP_NOEXCEPT - { - resourceInfoCount = resourceInfoCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM & setPResourceInfos( const DataGraphPipelineResourceInfoARM * pResourceInfos_ ) & VULKAN_HPP_NOEXCEPT - { - pResourceInfos = pResourceInfos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineCreateInfoARM && setPResourceInfos( const DataGraphPipelineResourceInfoARM * pResourceInfos_ ) && - VULKAN_HPP_NOEXCEPT - { - pResourceInfos = pResourceInfos_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DataGraphPipelineCreateInfoARM & - setResourceInfos( ArrayProxyNoTemporaries const & resourceInfos_ ) VULKAN_HPP_NOEXCEPT - { - resourceInfoCount = static_cast( resourceInfos_.size() ); - pResourceInfos = resourceInfos_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineCreateInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineCreateInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, layout, resourceInfoCount, pResourceInfos ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineCreateInfoARM const & ) const = default; -#else - bool operator==( DataGraphPipelineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( layout == rhs.layout ) && - ( resourceInfoCount == rhs.resourceInfoCount ) && ( pResourceInfos == rhs.pResourceInfos ); -# endif - } - - bool operator!=( DataGraphPipelineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineCreateInfoARM; - const void * pNext = {}; - PipelineCreateFlags2KHR flags = {}; - PipelineLayout layout = {}; - uint32_t resourceInfoCount = {}; - const DataGraphPipelineResourceInfoARM * pResourceInfos = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineCreateInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineCreateInfoARM; - }; - - // wrapper struct for struct VkDataGraphPipelineDispatchInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineDispatchInfoARM.html - struct DataGraphPipelineDispatchInfoARM - { - using NativeType = VkDataGraphPipelineDispatchInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineDispatchInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineDispatchInfoARM( DataGraphPipelineDispatchFlagsARM flags_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR DataGraphPipelineDispatchInfoARM( DataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineDispatchInfoARM( VkDataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineDispatchInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - DataGraphPipelineDispatchInfoARM & operator=( DataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineDispatchInfoARM & operator=( VkDataGraphPipelineDispatchInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM & setFlags( DataGraphPipelineDispatchFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineDispatchInfoARM && setFlags( DataGraphPipelineDispatchFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineDispatchInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineDispatchInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineDispatchInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineDispatchInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineDispatchInfoARM const & ) const = default; -#else - bool operator==( DataGraphPipelineDispatchInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( DataGraphPipelineDispatchInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineDispatchInfoARM; - void * pNext = {}; - DataGraphPipelineDispatchFlagsARM flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineDispatchInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineDispatchInfoARM; - }; - - // wrapper struct for struct VkDataGraphPipelineIdentifierCreateInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineIdentifierCreateInfoARM.html - struct DataGraphPipelineIdentifierCreateInfoARM - { - using NativeType = VkDataGraphPipelineIdentifierCreateInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineIdentifierCreateInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineIdentifierCreateInfoARM( uint32_t identifierSize_ = {}, - const uint8_t * pIdentifier_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , identifierSize{ identifierSize_ } - , pIdentifier{ pIdentifier_ } - { - } - - VULKAN_HPP_CONSTEXPR DataGraphPipelineIdentifierCreateInfoARM( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineIdentifierCreateInfoARM( VkDataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineIdentifierCreateInfoARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DataGraphPipelineIdentifierCreateInfoARM( ArrayProxyNoTemporaries const & identifier_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), identifierSize( static_cast( identifier_.size() ) ), pIdentifier( identifier_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DataGraphPipelineIdentifierCreateInfoARM & operator=( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineIdentifierCreateInfoARM & operator=( VkDataGraphPipelineIdentifierCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM & setIdentifierSize( uint32_t identifierSize_ ) & VULKAN_HPP_NOEXCEPT - { - identifierSize = identifierSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM && setIdentifierSize( uint32_t identifierSize_ ) && VULKAN_HPP_NOEXCEPT - { - identifierSize = identifierSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM & setPIdentifier( const uint8_t * pIdentifier_ ) & VULKAN_HPP_NOEXCEPT - { - pIdentifier = pIdentifier_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineIdentifierCreateInfoARM && setPIdentifier( const uint8_t * pIdentifier_ ) && VULKAN_HPP_NOEXCEPT - { - pIdentifier = pIdentifier_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DataGraphPipelineIdentifierCreateInfoARM & setIdentifier( ArrayProxyNoTemporaries const & identifier_ ) VULKAN_HPP_NOEXCEPT - { - identifierSize = static_cast( identifier_.size() ); - pIdentifier = identifier_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineIdentifierCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineIdentifierCreateInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineIdentifierCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineIdentifierCreateInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, identifierSize, pIdentifier ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineIdentifierCreateInfoARM const & ) const = default; -#else - bool operator==( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( identifierSize == rhs.identifierSize ) && ( pIdentifier == rhs.pIdentifier ); -# endif - } - - bool operator!=( DataGraphPipelineIdentifierCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineIdentifierCreateInfoARM; - const void * pNext = {}; - uint32_t identifierSize = {}; - const uint8_t * pIdentifier = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineIdentifierCreateInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineIdentifierCreateInfoARM; - }; - - // wrapper struct for struct VkDataGraphPipelineInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineInfoARM.html - struct DataGraphPipelineInfoARM - { - using NativeType = VkDataGraphPipelineInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineInfoARM( Pipeline dataGraphPipeline_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dataGraphPipeline{ dataGraphPipeline_ } - { - } - - VULKAN_HPP_CONSTEXPR DataGraphPipelineInfoARM( DataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineInfoARM( VkDataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - DataGraphPipelineInfoARM & operator=( DataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineInfoARM & operator=( VkDataGraphPipelineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM & setDataGraphPipeline( Pipeline dataGraphPipeline_ ) & VULKAN_HPP_NOEXCEPT - { - dataGraphPipeline = dataGraphPipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineInfoARM && setDataGraphPipeline( Pipeline dataGraphPipeline_ ) && VULKAN_HPP_NOEXCEPT - { - dataGraphPipeline = dataGraphPipeline_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dataGraphPipeline ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineInfoARM const & ) const = default; -#else - bool operator==( DataGraphPipelineInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataGraphPipeline == rhs.dataGraphPipeline ); -# endif - } - - bool operator!=( DataGraphPipelineInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineInfoARM; - const void * pNext = {}; - Pipeline dataGraphPipeline = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineInfoARM; - }; - - // wrapper struct for struct VkDataGraphPipelinePropertyQueryResultARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelinePropertyQueryResultARM.html - struct DataGraphPipelinePropertyQueryResultARM - { - using NativeType = VkDataGraphPipelinePropertyQueryResultARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelinePropertyQueryResultARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelinePropertyQueryResultARM( DataGraphPipelinePropertyARM property_ = DataGraphPipelinePropertyARM::eCreationLog, - Bool32 isText_ = {}, - size_t dataSize_ = {}, - void * pData_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , property{ property_ } - , isText{ isText_ } - , dataSize{ dataSize_ } - , pData{ pData_ } - { - } - - VULKAN_HPP_CONSTEXPR DataGraphPipelinePropertyQueryResultARM( DataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelinePropertyQueryResultARM( VkDataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelinePropertyQueryResultARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - DataGraphPipelinePropertyQueryResultARM( DataGraphPipelinePropertyARM property_, - Bool32 isText_, - ArrayProxyNoTemporaries const & data_, - void * pNext_ = nullptr ) - : pNext( pNext_ ), property( property_ ), isText( isText_ ), dataSize( data_.size() * sizeof( T ) ), pData( data_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DataGraphPipelinePropertyQueryResultARM & operator=( DataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelinePropertyQueryResultARM & operator=( VkDataGraphPipelinePropertyQueryResultARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setProperty( DataGraphPipelinePropertyARM property_ ) & VULKAN_HPP_NOEXCEPT - { - property = property_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setProperty( DataGraphPipelinePropertyARM property_ ) && VULKAN_HPP_NOEXCEPT - { - property = property_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setIsText( Bool32 isText_ ) & VULKAN_HPP_NOEXCEPT - { - isText = isText_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setIsText( Bool32 isText_ ) && VULKAN_HPP_NOEXCEPT - { - isText = isText_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM & setPData( void * pData_ ) & VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelinePropertyQueryResultARM && setPData( void * pData_ ) && VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - DataGraphPipelinePropertyQueryResultARM & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT - { - dataSize = data_.size() * sizeof( T ); - pData = data_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelinePropertyQueryResultARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelinePropertyQueryResultARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelinePropertyQueryResultARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelinePropertyQueryResultARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, property, isText, dataSize, pData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelinePropertyQueryResultARM const & ) const = default; -#else - bool operator==( DataGraphPipelinePropertyQueryResultARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( property == rhs.property ) && ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) && - ( pData == rhs.pData ); -# endif - } - - bool operator!=( DataGraphPipelinePropertyQueryResultARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelinePropertyQueryResultARM; - void * pNext = {}; - DataGraphPipelinePropertyARM property = DataGraphPipelinePropertyARM::eCreationLog; - Bool32 isText = {}; - size_t dataSize = {}; - void * pData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelinePropertyQueryResultARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelinePropertyQueryResultARM; - }; - - // wrapper struct for struct VkDataGraphPipelineSessionBindPointRequirementARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointRequirementARM.html - struct DataGraphPipelineSessionBindPointRequirementARM - { - using NativeType = VkDataGraphPipelineSessionBindPointRequirementARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineSessionBindPointRequirementARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionBindPointRequirementARM( - DataGraphPipelineSessionBindPointARM bindPoint_ = DataGraphPipelineSessionBindPointARM::eTransient, - DataGraphPipelineSessionBindPointTypeARM bindPointType_ = DataGraphPipelineSessionBindPointTypeARM::eMemory, - uint32_t numObjects_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , bindPoint{ bindPoint_ } - , bindPointType{ bindPointType_ } - , numObjects{ numObjects_ } - { - } - - VULKAN_HPP_CONSTEXPR - DataGraphPipelineSessionBindPointRequirementARM( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineSessionBindPointRequirementARM( VkDataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineSessionBindPointRequirementARM( *reinterpret_cast( &rhs ) ) - { - } - - DataGraphPipelineSessionBindPointRequirementARM & operator=( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineSessionBindPointRequirementARM & operator=( VkDataGraphPipelineSessionBindPointRequirementARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDataGraphPipelineSessionBindPointRequirementARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionBindPointRequirementARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionBindPointRequirementARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionBindPointRequirementARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, bindPoint, bindPointType, numObjects ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineSessionBindPointRequirementARM const & ) const = default; -#else - bool operator==( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindPoint == rhs.bindPoint ) && ( bindPointType == rhs.bindPointType ) && - ( numObjects == rhs.numObjects ); -# endif - } - - bool operator!=( DataGraphPipelineSessionBindPointRequirementARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineSessionBindPointRequirementARM; - void * pNext = {}; - DataGraphPipelineSessionBindPointARM bindPoint = DataGraphPipelineSessionBindPointARM::eTransient; - DataGraphPipelineSessionBindPointTypeARM bindPointType = DataGraphPipelineSessionBindPointTypeARM::eMemory; - uint32_t numObjects = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineSessionBindPointRequirementARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineSessionBindPointRequirementARM; - }; - - // wrapper struct for struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionBindPointRequirementsInfoARM.html - struct DataGraphPipelineSessionBindPointRequirementsInfoARM - { - using NativeType = VkDataGraphPipelineSessionBindPointRequirementsInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineSessionBindPointRequirementsInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionBindPointRequirementsInfoARM( DataGraphPipelineSessionARM session_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , session{ session_ } - { - } - - VULKAN_HPP_CONSTEXPR - DataGraphPipelineSessionBindPointRequirementsInfoARM( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineSessionBindPointRequirementsInfoARM( VkDataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineSessionBindPointRequirementsInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - DataGraphPipelineSessionBindPointRequirementsInfoARM & - operator=( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineSessionBindPointRequirementsInfoARM & operator=( VkDataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM & setSession( DataGraphPipelineSessionARM session_ ) & VULKAN_HPP_NOEXCEPT - { - session = session_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionBindPointRequirementsInfoARM && setSession( DataGraphPipelineSessionARM session_ ) && VULKAN_HPP_NOEXCEPT - { - session = session_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionBindPointRequirementsInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, session ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineSessionBindPointRequirementsInfoARM const & ) const = default; -#else - bool operator==( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( session == rhs.session ); -# endif - } - - bool operator!=( DataGraphPipelineSessionBindPointRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineSessionBindPointRequirementsInfoARM; - const void * pNext = {}; - DataGraphPipelineSessionARM session = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineSessionBindPointRequirementsInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineSessionBindPointRequirementsInfoARM; - }; - - // wrapper struct for struct VkDataGraphPipelineSessionCreateInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionCreateInfoARM.html - struct DataGraphPipelineSessionCreateInfoARM - { - using NativeType = VkDataGraphPipelineSessionCreateInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineSessionCreateInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionCreateInfoARM( DataGraphPipelineSessionCreateFlagsARM flags_ = {}, - Pipeline dataGraphPipeline_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , dataGraphPipeline{ dataGraphPipeline_ } - { - } - - VULKAN_HPP_CONSTEXPR DataGraphPipelineSessionCreateInfoARM( DataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineSessionCreateInfoARM( VkDataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineSessionCreateInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - DataGraphPipelineSessionCreateInfoARM & operator=( DataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineSessionCreateInfoARM & operator=( VkDataGraphPipelineSessionCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM & setFlags( DataGraphPipelineSessionCreateFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM && setFlags( DataGraphPipelineSessionCreateFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM & setDataGraphPipeline( Pipeline dataGraphPipeline_ ) & VULKAN_HPP_NOEXCEPT - { - dataGraphPipeline = dataGraphPipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionCreateInfoARM && setDataGraphPipeline( Pipeline dataGraphPipeline_ ) && VULKAN_HPP_NOEXCEPT - { - dataGraphPipeline = dataGraphPipeline_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineSessionCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionCreateInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionCreateInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, dataGraphPipeline ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineSessionCreateInfoARM const & ) const = default; -#else - bool operator==( DataGraphPipelineSessionCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dataGraphPipeline == rhs.dataGraphPipeline ); -# endif - } - - bool operator!=( DataGraphPipelineSessionCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineSessionCreateInfoARM; - const void * pNext = {}; - DataGraphPipelineSessionCreateFlagsARM flags = {}; - Pipeline dataGraphPipeline = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineSessionCreateInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineSessionCreateInfoARM; - }; - - // wrapper struct for struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineSessionMemoryRequirementsInfoARM.html - struct DataGraphPipelineSessionMemoryRequirementsInfoARM - { - using NativeType = VkDataGraphPipelineSessionMemoryRequirementsInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineSessionMemoryRequirementsInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - DataGraphPipelineSessionMemoryRequirementsInfoARM( DataGraphPipelineSessionARM session_ = {}, - DataGraphPipelineSessionBindPointARM bindPoint_ = DataGraphPipelineSessionBindPointARM::eTransient, - uint32_t objectIndex_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , session{ session_ } - , bindPoint{ bindPoint_ } - , objectIndex{ objectIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR - DataGraphPipelineSessionMemoryRequirementsInfoARM( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineSessionMemoryRequirementsInfoARM( VkDataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineSessionMemoryRequirementsInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - DataGraphPipelineSessionMemoryRequirementsInfoARM & - operator=( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineSessionMemoryRequirementsInfoARM & operator=( VkDataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setSession( DataGraphPipelineSessionARM session_ ) & VULKAN_HPP_NOEXCEPT - { - session = session_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setSession( DataGraphPipelineSessionARM session_ ) && VULKAN_HPP_NOEXCEPT - { - session = session_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) & - VULKAN_HPP_NOEXCEPT - { - bindPoint = bindPoint_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setBindPoint( DataGraphPipelineSessionBindPointARM bindPoint_ ) && - VULKAN_HPP_NOEXCEPT - { - bindPoint = bindPoint_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM & setObjectIndex( uint32_t objectIndex_ ) & VULKAN_HPP_NOEXCEPT - { - objectIndex = objectIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineSessionMemoryRequirementsInfoARM && setObjectIndex( uint32_t objectIndex_ ) && VULKAN_HPP_NOEXCEPT - { - objectIndex = objectIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineSessionMemoryRequirementsInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, session, bindPoint, objectIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphPipelineSessionMemoryRequirementsInfoARM const & ) const = default; -#else - bool operator==( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( session == rhs.session ) && ( bindPoint == rhs.bindPoint ) && - ( objectIndex == rhs.objectIndex ); -# endif - } - - bool operator!=( DataGraphPipelineSessionMemoryRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphPipelineSessionMemoryRequirementsInfoARM; - const void * pNext = {}; - DataGraphPipelineSessionARM session = {}; - DataGraphPipelineSessionBindPointARM bindPoint = DataGraphPipelineSessionBindPointARM::eTransient; - uint32_t objectIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineSessionMemoryRequirementsInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineSessionMemoryRequirementsInfoARM; - }; - - // wrapper struct for struct VkDataGraphPipelineShaderModuleCreateInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphPipelineShaderModuleCreateInfoARM.html - struct DataGraphPipelineShaderModuleCreateInfoARM - { - using NativeType = VkDataGraphPipelineShaderModuleCreateInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphPipelineShaderModuleCreateInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphPipelineShaderModuleCreateInfoARM( ShaderModule module_ = {}, - const char * pName_ = {}, - const SpecializationInfo * pSpecializationInfo_ = {}, - uint32_t constantCount_ = {}, - const DataGraphPipelineConstantARM * pConstants_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , module{ module_ } - , pName{ pName_ } - , pSpecializationInfo{ pSpecializationInfo_ } - , constantCount{ constantCount_ } - , pConstants{ pConstants_ } - { - } - - VULKAN_HPP_CONSTEXPR DataGraphPipelineShaderModuleCreateInfoARM( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphPipelineShaderModuleCreateInfoARM( VkDataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphPipelineShaderModuleCreateInfoARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DataGraphPipelineShaderModuleCreateInfoARM( ShaderModule module_, - const char * pName_, - const SpecializationInfo * pSpecializationInfo_, - ArrayProxyNoTemporaries const & constants_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , module( module_ ) - , pName( pName_ ) - , pSpecializationInfo( pSpecializationInfo_ ) - , constantCount( static_cast( constants_.size() ) ) - , pConstants( constants_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DataGraphPipelineShaderModuleCreateInfoARM & operator=( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphPipelineShaderModuleCreateInfoARM & operator=( VkDataGraphPipelineShaderModuleCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setModule( ShaderModule module_ ) & VULKAN_HPP_NOEXCEPT - { - module = module_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setModule( ShaderModule module_ ) && VULKAN_HPP_NOEXCEPT - { - module = module_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pSpecializationInfo = pSpecializationInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pSpecializationInfo = pSpecializationInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setConstantCount( uint32_t constantCount_ ) & VULKAN_HPP_NOEXCEPT - { - constantCount = constantCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setConstantCount( uint32_t constantCount_ ) && VULKAN_HPP_NOEXCEPT - { - constantCount = constantCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM & setPConstants( const DataGraphPipelineConstantARM * pConstants_ ) & VULKAN_HPP_NOEXCEPT - { - pConstants = pConstants_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphPipelineShaderModuleCreateInfoARM && setPConstants( const DataGraphPipelineConstantARM * pConstants_ ) && - VULKAN_HPP_NOEXCEPT - { - pConstants = pConstants_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DataGraphPipelineShaderModuleCreateInfoARM & - setConstants( ArrayProxyNoTemporaries const & constants_ ) VULKAN_HPP_NOEXCEPT - { - constantCount = static_cast( constants_.size() ); - pConstants = constants_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphPipelineShaderModuleCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineShaderModuleCreateInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphPipelineShaderModuleCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphPipelineShaderModuleCreateInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, module, pName, pSpecializationInfo, constantCount, pConstants ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = module <=> rhs.module; cmp != 0 ) - return cmp; - if ( pName != rhs.pName ) - if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = pSpecializationInfo <=> rhs.pSpecializationInfo; cmp != 0 ) - return cmp; - if ( auto cmp = constantCount <=> rhs.constantCount; cmp != 0 ) - return cmp; - if ( auto cmp = pConstants <=> rhs.pConstants; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( module == rhs.module ) && - ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( pSpecializationInfo == rhs.pSpecializationInfo ) && - ( constantCount == rhs.constantCount ) && ( pConstants == rhs.pConstants ); - } - - bool operator!=( DataGraphPipelineShaderModuleCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDataGraphPipelineShaderModuleCreateInfoARM; - const void * pNext = {}; - ShaderModule module = {}; - const char * pName = {}; - const SpecializationInfo * pSpecializationInfo = {}; - uint32_t constantCount = {}; - const DataGraphPipelineConstantARM * pConstants = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphPipelineShaderModuleCreateInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphPipelineShaderModuleCreateInfoARM; - }; - - // wrapper struct for struct VkPhysicalDeviceDataGraphProcessingEngineARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphProcessingEngineARM.html - struct PhysicalDeviceDataGraphProcessingEngineARM - { - using NativeType = VkPhysicalDeviceDataGraphProcessingEngineARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphProcessingEngineARM( - PhysicalDeviceDataGraphProcessingEngineTypeARM type_ = PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault, - Bool32 isForeign_ = {} ) VULKAN_HPP_NOEXCEPT - : type{ type_ } - , isForeign{ isForeign_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphProcessingEngineARM( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDataGraphProcessingEngineARM( VkPhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDataGraphProcessingEngineARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDataGraphProcessingEngineARM & operator=( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDataGraphProcessingEngineARM & operator=( VkPhysicalDeviceDataGraphProcessingEngineARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM & setType( PhysicalDeviceDataGraphProcessingEngineTypeARM type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM && setType( PhysicalDeviceDataGraphProcessingEngineTypeARM type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM & setIsForeign( Bool32 isForeign_ ) & VULKAN_HPP_NOEXCEPT - { - isForeign = isForeign_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphProcessingEngineARM && setIsForeign( Bool32 isForeign_ ) && VULKAN_HPP_NOEXCEPT - { - isForeign = isForeign_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDataGraphProcessingEngineARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphProcessingEngineARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphProcessingEngineARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphProcessingEngineARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( type, isForeign ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDataGraphProcessingEngineARM const & ) const = default; -#else - bool operator==( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( type == rhs.type ) && ( isForeign == rhs.isForeign ); -# endif - } - - bool operator!=( PhysicalDeviceDataGraphProcessingEngineARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - PhysicalDeviceDataGraphProcessingEngineTypeARM type = PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault; - Bool32 isForeign = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDataGraphProcessingEngineARM; - }; -#endif - - // wrapper struct for struct VkDataGraphProcessingEngineCreateInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDataGraphProcessingEngineCreateInfoARM.html - struct DataGraphProcessingEngineCreateInfoARM - { - using NativeType = VkDataGraphProcessingEngineCreateInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDataGraphProcessingEngineCreateInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DataGraphProcessingEngineCreateInfoARM( uint32_t processingEngineCount_ = {}, - PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , processingEngineCount{ processingEngineCount_ } - , pProcessingEngines{ pProcessingEngines_ } - { - } - - VULKAN_HPP_CONSTEXPR DataGraphProcessingEngineCreateInfoARM( DataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DataGraphProcessingEngineCreateInfoARM( VkDataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DataGraphProcessingEngineCreateInfoARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DataGraphProcessingEngineCreateInfoARM( ArrayProxyNoTemporaries const & processingEngines_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), processingEngineCount( static_cast( processingEngines_.size() ) ), pProcessingEngines( processingEngines_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DataGraphProcessingEngineCreateInfoARM & operator=( DataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DataGraphProcessingEngineCreateInfoARM & operator=( VkDataGraphProcessingEngineCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM & setProcessingEngineCount( uint32_t processingEngineCount_ ) & VULKAN_HPP_NOEXCEPT - { - processingEngineCount = processingEngineCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM && setProcessingEngineCount( uint32_t processingEngineCount_ ) && VULKAN_HPP_NOEXCEPT - { - processingEngineCount = processingEngineCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM & setPProcessingEngines( PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines_ ) & - VULKAN_HPP_NOEXCEPT - { - pProcessingEngines = pProcessingEngines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DataGraphProcessingEngineCreateInfoARM && - setPProcessingEngines( PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines_ ) && - VULKAN_HPP_NOEXCEPT - { - pProcessingEngines = pProcessingEngines_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DataGraphProcessingEngineCreateInfoARM & - setProcessingEngines( ArrayProxyNoTemporaries const & processingEngines_ ) VULKAN_HPP_NOEXCEPT - { - processingEngineCount = static_cast( processingEngines_.size() ); - pProcessingEngines = processingEngines_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDataGraphProcessingEngineCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphProcessingEngineCreateInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDataGraphProcessingEngineCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDataGraphProcessingEngineCreateInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, processingEngineCount, pProcessingEngines ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DataGraphProcessingEngineCreateInfoARM const & ) const = default; -#else - bool operator==( DataGraphProcessingEngineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( processingEngineCount == rhs.processingEngineCount ) && - ( pProcessingEngines == rhs.pProcessingEngines ); -# endif - } - - bool operator!=( DataGraphProcessingEngineCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDataGraphProcessingEngineCreateInfoARM; - const void * pNext = {}; - uint32_t processingEngineCount = {}; - PhysicalDeviceDataGraphProcessingEngineARM * pProcessingEngines = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DataGraphProcessingEngineCreateInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DataGraphProcessingEngineCreateInfoARM; - }; - - // wrapper struct for struct VkDebugMarkerMarkerInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugMarkerMarkerInfoEXT.html - struct DebugMarkerMarkerInfoEXT - { - using NativeType = VkDebugMarkerMarkerInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerMarkerInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - DebugMarkerMarkerInfoEXT( const char * pMarkerName_ = {}, std::array const & color_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pMarkerName{ pMarkerName_ } - , color{ color_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT( DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DebugMarkerMarkerInfoEXT( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DebugMarkerMarkerInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - DebugMarkerMarkerInfoEXT & operator=( DebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DebugMarkerMarkerInfoEXT & operator=( VkDebugMarkerMarkerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT & setPMarkerName( const char * pMarkerName_ ) & VULKAN_HPP_NOEXCEPT - { - pMarkerName = pMarkerName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT && setPMarkerName( const char * pMarkerName_ ) && VULKAN_HPP_NOEXCEPT - { - pMarkerName = pMarkerName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT & setColor( std::array color_ ) & VULKAN_HPP_NOEXCEPT - { - color = color_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerMarkerInfoEXT && setColor( std::array color_ ) && VULKAN_HPP_NOEXCEPT - { - color = color_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDebugMarkerMarkerInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugMarkerMarkerInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugMarkerMarkerInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDebugMarkerMarkerInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pMarkerName, color ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::partial_ordering operator<=>( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( pMarkerName != rhs.pMarkerName ) - if ( auto cmp = strcmp( pMarkerName, rhs.pMarkerName ); cmp != 0 ) - return ( cmp < 0 ) ? std::partial_ordering::less : std::partial_ordering::greater; - if ( auto cmp = color <=> rhs.color; cmp != 0 ) - return cmp; - - return std::partial_ordering::equivalent; - } -#endif - - bool operator==( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ( pMarkerName == rhs.pMarkerName ) || ( strcmp( pMarkerName, rhs.pMarkerName ) == 0 ) ) && - ( color == rhs.color ); - } - - bool operator!=( DebugMarkerMarkerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDebugMarkerMarkerInfoEXT; - const void * pNext = {}; - const char * pMarkerName = {}; - ArrayWrapper1D color = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DebugMarkerMarkerInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DebugMarkerMarkerInfoEXT; - }; - - // wrapper struct for struct VkDebugMarkerObjectNameInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugMarkerObjectNameInfoEXT.html - struct DebugMarkerObjectNameInfoEXT - { - using NativeType = VkDebugMarkerObjectNameInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerObjectNameInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, - uint64_t object_ = {}, - const char * pObjectName_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , objectType{ objectType_ } - , object{ object_ } - , pObjectName{ pObjectName_ } - { - } - - VULKAN_HPP_CONSTEXPR DebugMarkerObjectNameInfoEXT( DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DebugMarkerObjectNameInfoEXT( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DebugMarkerObjectNameInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - DebugMarkerObjectNameInfoEXT & operator=( DebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DebugMarkerObjectNameInfoEXT & operator=( VkDebugMarkerObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ ) & VULKAN_HPP_NOEXCEPT - { - objectType = objectType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setObjectType( DebugReportObjectTypeEXT objectType_ ) && VULKAN_HPP_NOEXCEPT - { - objectType = objectType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setObject( uint64_t object_ ) & VULKAN_HPP_NOEXCEPT - { - object = object_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setObject( uint64_t object_ ) && VULKAN_HPP_NOEXCEPT - { - object = object_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT & setPObjectName( const char * pObjectName_ ) & VULKAN_HPP_NOEXCEPT - { - pObjectName = pObjectName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectNameInfoEXT && setPObjectName( const char * pObjectName_ ) && VULKAN_HPP_NOEXCEPT - { - pObjectName = pObjectName_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDebugMarkerObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugMarkerObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugMarkerObjectNameInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDebugMarkerObjectNameInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, objectType, object, pObjectName ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = objectType <=> rhs.objectType; cmp != 0 ) - return cmp; - if ( auto cmp = object <=> rhs.object; cmp != 0 ) - return cmp; - if ( pObjectName != rhs.pObjectName ) - if ( auto cmp = strcmp( pObjectName, rhs.pObjectName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( object == rhs.object ) && - ( ( pObjectName == rhs.pObjectName ) || ( strcmp( pObjectName, rhs.pObjectName ) == 0 ) ); - } - - bool operator!=( DebugMarkerObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDebugMarkerObjectNameInfoEXT; - const void * pNext = {}; - DebugReportObjectTypeEXT objectType = DebugReportObjectTypeEXT::eUnknown; - uint64_t object = {}; - const char * pObjectName = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DebugMarkerObjectNameInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DebugMarkerObjectNameInfoEXT; - }; - - // wrapper struct for struct VkDebugMarkerObjectTagInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugMarkerObjectTagInfoEXT.html - struct DebugMarkerObjectTagInfoEXT - { - using NativeType = VkDebugMarkerObjectTagInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugMarkerObjectTagInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( DebugReportObjectTypeEXT objectType_ = DebugReportObjectTypeEXT::eUnknown, - uint64_t object_ = {}, - uint64_t tagName_ = {}, - size_t tagSize_ = {}, - const void * pTag_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , objectType{ objectType_ } - , object{ object_ } - , tagName{ tagName_ } - , tagSize{ tagSize_ } - , pTag{ pTag_ } - { - } - - VULKAN_HPP_CONSTEXPR DebugMarkerObjectTagInfoEXT( DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DebugMarkerObjectTagInfoEXT( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DebugMarkerObjectTagInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - DebugMarkerObjectTagInfoEXT( - DebugReportObjectTypeEXT objectType_, uint64_t object_, uint64_t tagName_, ArrayProxyNoTemporaries const & tag_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), objectType( objectType_ ), object( object_ ), tagName( tagName_ ), tagSize( tag_.size() * sizeof( T ) ), pTag( tag_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DebugMarkerObjectTagInfoEXT & operator=( DebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DebugMarkerObjectTagInfoEXT & operator=( VkDebugMarkerObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setObjectType( DebugReportObjectTypeEXT objectType_ ) & VULKAN_HPP_NOEXCEPT - { - objectType = objectType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setObjectType( DebugReportObjectTypeEXT objectType_ ) && VULKAN_HPP_NOEXCEPT - { - objectType = objectType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setObject( uint64_t object_ ) & VULKAN_HPP_NOEXCEPT - { - object = object_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setObject( uint64_t object_ ) && VULKAN_HPP_NOEXCEPT - { - object = object_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setTagName( uint64_t tagName_ ) & VULKAN_HPP_NOEXCEPT - { - tagName = tagName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setTagName( uint64_t tagName_ ) && VULKAN_HPP_NOEXCEPT - { - tagName = tagName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setTagSize( size_t tagSize_ ) & VULKAN_HPP_NOEXCEPT - { - tagSize = tagSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setTagSize( size_t tagSize_ ) && VULKAN_HPP_NOEXCEPT - { - tagSize = tagSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT & setPTag( const void * pTag_ ) & VULKAN_HPP_NOEXCEPT - { - pTag = pTag_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugMarkerObjectTagInfoEXT && setPTag( const void * pTag_ ) && VULKAN_HPP_NOEXCEPT - { - pTag = pTag_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - DebugMarkerObjectTagInfoEXT & setTag( ArrayProxyNoTemporaries const & tag_ ) VULKAN_HPP_NOEXCEPT - { - tagSize = tag_.size() * sizeof( T ); - pTag = tag_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDebugMarkerObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugMarkerObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugMarkerObjectTagInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDebugMarkerObjectTagInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, objectType, object, tagName, tagSize, pTag ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DebugMarkerObjectTagInfoEXT const & ) const = default; -#else - bool operator==( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( object == rhs.object ) && ( tagName == rhs.tagName ) && - ( tagSize == rhs.tagSize ) && ( pTag == rhs.pTag ); -# endif - } - - bool operator!=( DebugMarkerObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDebugMarkerObjectTagInfoEXT; - const void * pNext = {}; - DebugReportObjectTypeEXT objectType = DebugReportObjectTypeEXT::eUnknown; - uint64_t object = {}; - uint64_t tagName = {}; - size_t tagSize = {}; - const void * pTag = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DebugMarkerObjectTagInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DebugMarkerObjectTagInfoEXT; - }; - - typedef Bool32( VKAPI_PTR * PFN_DebugReportCallbackEXT )( DebugReportFlagsEXT flags, - DebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char * pLayerPrefix, - const char * pMessage, - void * pUserData ); - - // wrapper struct for struct VkDebugReportCallbackCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugReportCallbackCreateInfoEXT.html - struct DebugReportCallbackCreateInfoEXT - { - using NativeType = VkDebugReportCallbackCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugReportCallbackCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_ = {}, - PFN_DebugReportCallbackEXT pfnCallback_ = {}, - void * pUserData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pfnCallback{ pfnCallback_ } - , pUserData{ pUserData_ } - { - } - - VULKAN_HPP_CONSTEXPR DebugReportCallbackCreateInfoEXT( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DebugReportCallbackCreateInfoEXT( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DebugReportCallbackCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic push -# if defined( __clang__ ) -# pragma clang diagnostic ignored "-Wunknown-warning-option" -# endif -# pragma GCC diagnostic ignored "-Wcast-function-type" -# endif - VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) - - DebugReportCallbackCreateInfoEXT( DebugReportFlagsEXT flags_, - PFN_vkDebugReportCallbackEXT pfnCallback_, - void * pUserData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : DebugReportCallbackCreateInfoEXT( flags_, reinterpret_cast( pfnCallback_ ), pUserData_, pNext_ ) - { - } -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic pop -# endif - - DebugReportCallbackCreateInfoEXT & operator=( DebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DebugReportCallbackCreateInfoEXT & operator=( VkDebugReportCallbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setFlags( DebugReportFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setFlags( DebugReportFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_DebugReportCallbackEXT pfnCallback_ ) & VULKAN_HPP_NOEXCEPT - { - pfnCallback = pfnCallback_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setPfnCallback( PFN_DebugReportCallbackEXT pfnCallback_ ) && VULKAN_HPP_NOEXCEPT - { - pfnCallback = pfnCallback_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT - { - pUserData = pUserData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugReportCallbackCreateInfoEXT && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT - { - pUserData = pUserData_; - return std::move( *this ); - } - -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic push -# if defined( __clang__ ) -# pragma clang diagnostic ignored "-Wunknown-warning-option" -# endif -# pragma GCC diagnostic ignored "-Wcast-function-type" -# endif - VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) - - DebugReportCallbackCreateInfoEXT & setPfnCallback( PFN_vkDebugReportCallbackEXT pfnCallback_ ) VULKAN_HPP_NOEXCEPT - { - return setPfnCallback( reinterpret_cast( pfnCallback_ ) ); - } -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic pop -# endif -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDebugReportCallbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugReportCallbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugReportCallbackCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDebugReportCallbackCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, pfnCallback, pUserData ); - } -#endif - - bool operator==( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -#if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -#else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pfnCallback == rhs.pfnCallback ) && ( pUserData == rhs.pUserData ); -#endif - } - - bool operator!=( DebugReportCallbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDebugReportCallbackCreateInfoEXT; - const void * pNext = {}; - DebugReportFlagsEXT flags = {}; - PFN_DebugReportCallbackEXT pfnCallback = {}; - void * pUserData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DebugReportCallbackCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DebugReportCallbackCreateInfoEXT; - }; - - // wrapper struct for struct VkDebugUtilsLabelEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsLabelEXT.html - struct DebugUtilsLabelEXT - { - using NativeType = VkDebugUtilsLabelEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsLabelEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - DebugUtilsLabelEXT( const char * pLabelName_ = {}, std::array const & color_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pLabelName{ pLabelName_ } - , color{ color_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT( DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DebugUtilsLabelEXT( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DebugUtilsLabelEXT( *reinterpret_cast( &rhs ) ) {} - - DebugUtilsLabelEXT & operator=( DebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DebugUtilsLabelEXT & operator=( VkDebugUtilsLabelEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT & setPLabelName( const char * pLabelName_ ) & VULKAN_HPP_NOEXCEPT - { - pLabelName = pLabelName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT && setPLabelName( const char * pLabelName_ ) && VULKAN_HPP_NOEXCEPT - { - pLabelName = pLabelName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT & setColor( std::array color_ ) & VULKAN_HPP_NOEXCEPT - { - color = color_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsLabelEXT && setColor( std::array color_ ) && VULKAN_HPP_NOEXCEPT - { - color = color_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDebugUtilsLabelEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugUtilsLabelEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugUtilsLabelEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDebugUtilsLabelEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pLabelName, color ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::partial_ordering operator<=>( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( pLabelName != rhs.pLabelName ) - if ( auto cmp = strcmp( pLabelName, rhs.pLabelName ); cmp != 0 ) - return ( cmp < 0 ) ? std::partial_ordering::less : std::partial_ordering::greater; - if ( auto cmp = color <=> rhs.color; cmp != 0 ) - return cmp; - - return std::partial_ordering::equivalent; - } -#endif - - bool operator==( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ( pLabelName == rhs.pLabelName ) || ( strcmp( pLabelName, rhs.pLabelName ) == 0 ) ) && - ( color == rhs.color ); - } - - bool operator!=( DebugUtilsLabelEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDebugUtilsLabelEXT; - const void * pNext = {}; - const char * pLabelName = {}; - ArrayWrapper1D color = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DebugUtilsLabelEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DebugUtilsLabelEXT; - }; - - // wrapper struct for struct VkDebugUtilsObjectNameInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsObjectNameInfoEXT.html - struct DebugUtilsObjectNameInfoEXT - { - using NativeType = VkDebugUtilsObjectNameInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsObjectNameInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( ObjectType objectType_ = ObjectType::eUnknown, - uint64_t objectHandle_ = {}, - const char * pObjectName_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , objectType{ objectType_ } - , objectHandle{ objectHandle_ } - , pObjectName{ pObjectName_ } - { - } - - VULKAN_HPP_CONSTEXPR DebugUtilsObjectNameInfoEXT( DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DebugUtilsObjectNameInfoEXT( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DebugUtilsObjectNameInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - DebugUtilsObjectNameInfoEXT & operator=( DebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DebugUtilsObjectNameInfoEXT & operator=( VkDebugUtilsObjectNameInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setObjectType( ObjectType objectType_ ) & VULKAN_HPP_NOEXCEPT - { - objectType = objectType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setObjectType( ObjectType objectType_ ) && VULKAN_HPP_NOEXCEPT - { - objectType = objectType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setObjectHandle( uint64_t objectHandle_ ) & VULKAN_HPP_NOEXCEPT - { - objectHandle = objectHandle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setObjectHandle( uint64_t objectHandle_ ) && VULKAN_HPP_NOEXCEPT - { - objectHandle = objectHandle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT & setPObjectName( const char * pObjectName_ ) & VULKAN_HPP_NOEXCEPT - { - pObjectName = pObjectName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectNameInfoEXT && setPObjectName( const char * pObjectName_ ) && VULKAN_HPP_NOEXCEPT - { - pObjectName = pObjectName_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDebugUtilsObjectNameInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugUtilsObjectNameInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugUtilsObjectNameInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDebugUtilsObjectNameInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, objectType, objectHandle, pObjectName ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = objectType <=> rhs.objectType; cmp != 0 ) - return cmp; - if ( auto cmp = objectHandle <=> rhs.objectHandle; cmp != 0 ) - return cmp; - if ( pObjectName != rhs.pObjectName ) - if ( auto cmp = strcmp( pObjectName, rhs.pObjectName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) && - ( ( pObjectName == rhs.pObjectName ) || ( strcmp( pObjectName, rhs.pObjectName ) == 0 ) ); - } - - bool operator!=( DebugUtilsObjectNameInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDebugUtilsObjectNameInfoEXT; - const void * pNext = {}; - ObjectType objectType = ObjectType::eUnknown; - uint64_t objectHandle = {}; - const char * pObjectName = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DebugUtilsObjectNameInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DebugUtilsObjectNameInfoEXT; - }; - - // wrapper struct for struct VkDebugUtilsMessengerCallbackDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCallbackDataEXT.html - struct DebugUtilsMessengerCallbackDataEXT - { - using NativeType = VkDebugUtilsMessengerCallbackDataEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsMessengerCallbackDataEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_ = {}, - const char * pMessageIdName_ = {}, - int32_t messageIdNumber_ = {}, - const char * pMessage_ = {}, - uint32_t queueLabelCount_ = {}, - const DebugUtilsLabelEXT * pQueueLabels_ = {}, - uint32_t cmdBufLabelCount_ = {}, - const DebugUtilsLabelEXT * pCmdBufLabels_ = {}, - uint32_t objectCount_ = {}, - const DebugUtilsObjectNameInfoEXT * pObjects_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pMessageIdName{ pMessageIdName_ } - , messageIdNumber{ messageIdNumber_ } - , pMessage{ pMessage_ } - , queueLabelCount{ queueLabelCount_ } - , pQueueLabels{ pQueueLabels_ } - , cmdBufLabelCount{ cmdBufLabelCount_ } - , pCmdBufLabels{ pCmdBufLabels_ } - , objectCount{ objectCount_ } - , pObjects{ pObjects_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DebugUtilsMessengerCallbackDataEXT( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DebugUtilsMessengerCallbackDataEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DebugUtilsMessengerCallbackDataEXT( DebugUtilsMessengerCallbackDataFlagsEXT flags_, - const char * pMessageIdName_, - int32_t messageIdNumber_, - const char * pMessage_, - ArrayProxyNoTemporaries const & queueLabels_, - ArrayProxyNoTemporaries const & cmdBufLabels_ = {}, - ArrayProxyNoTemporaries const & objects_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , pMessageIdName( pMessageIdName_ ) - , messageIdNumber( messageIdNumber_ ) - , pMessage( pMessage_ ) - , queueLabelCount( static_cast( queueLabels_.size() ) ) - , pQueueLabels( queueLabels_.data() ) - , cmdBufLabelCount( static_cast( cmdBufLabels_.size() ) ) - , pCmdBufLabels( cmdBufLabels_.data() ) - , objectCount( static_cast( objects_.size() ) ) - , pObjects( objects_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DebugUtilsMessengerCallbackDataEXT & operator=( DebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DebugUtilsMessengerCallbackDataEXT & operator=( VkDebugUtilsMessengerCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setFlags( DebugUtilsMessengerCallbackDataFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPMessageIdName( const char * pMessageIdName_ ) & VULKAN_HPP_NOEXCEPT - { - pMessageIdName = pMessageIdName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPMessageIdName( const char * pMessageIdName_ ) && VULKAN_HPP_NOEXCEPT - { - pMessageIdName = pMessageIdName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setMessageIdNumber( int32_t messageIdNumber_ ) & VULKAN_HPP_NOEXCEPT - { - messageIdNumber = messageIdNumber_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setMessageIdNumber( int32_t messageIdNumber_ ) && VULKAN_HPP_NOEXCEPT - { - messageIdNumber = messageIdNumber_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPMessage( const char * pMessage_ ) & VULKAN_HPP_NOEXCEPT - { - pMessage = pMessage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPMessage( const char * pMessage_ ) && VULKAN_HPP_NOEXCEPT - { - pMessage = pMessage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setQueueLabelCount( uint32_t queueLabelCount_ ) & VULKAN_HPP_NOEXCEPT - { - queueLabelCount = queueLabelCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setQueueLabelCount( uint32_t queueLabelCount_ ) && VULKAN_HPP_NOEXCEPT - { - queueLabelCount = queueLabelCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPQueueLabels( const DebugUtilsLabelEXT * pQueueLabels_ ) & VULKAN_HPP_NOEXCEPT - { - pQueueLabels = pQueueLabels_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPQueueLabels( const DebugUtilsLabelEXT * pQueueLabels_ ) && VULKAN_HPP_NOEXCEPT - { - pQueueLabels = pQueueLabels_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DebugUtilsMessengerCallbackDataEXT & setQueueLabels( ArrayProxyNoTemporaries const & queueLabels_ ) VULKAN_HPP_NOEXCEPT - { - queueLabelCount = static_cast( queueLabels_.size() ); - pQueueLabels = queueLabels_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setCmdBufLabelCount( uint32_t cmdBufLabelCount_ ) & VULKAN_HPP_NOEXCEPT - { - cmdBufLabelCount = cmdBufLabelCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setCmdBufLabelCount( uint32_t cmdBufLabelCount_ ) && VULKAN_HPP_NOEXCEPT - { - cmdBufLabelCount = cmdBufLabelCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPCmdBufLabels( const DebugUtilsLabelEXT * pCmdBufLabels_ ) & VULKAN_HPP_NOEXCEPT - { - pCmdBufLabels = pCmdBufLabels_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPCmdBufLabels( const DebugUtilsLabelEXT * pCmdBufLabels_ ) && VULKAN_HPP_NOEXCEPT - { - pCmdBufLabels = pCmdBufLabels_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DebugUtilsMessengerCallbackDataEXT & setCmdBufLabels( ArrayProxyNoTemporaries const & cmdBufLabels_ ) VULKAN_HPP_NOEXCEPT - { - cmdBufLabelCount = static_cast( cmdBufLabels_.size() ); - pCmdBufLabels = cmdBufLabels_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setObjectCount( uint32_t objectCount_ ) & VULKAN_HPP_NOEXCEPT - { - objectCount = objectCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setObjectCount( uint32_t objectCount_ ) && VULKAN_HPP_NOEXCEPT - { - objectCount = objectCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT & setPObjects( const DebugUtilsObjectNameInfoEXT * pObjects_ ) & VULKAN_HPP_NOEXCEPT - { - pObjects = pObjects_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCallbackDataEXT && setPObjects( const DebugUtilsObjectNameInfoEXT * pObjects_ ) && VULKAN_HPP_NOEXCEPT - { - pObjects = pObjects_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DebugUtilsMessengerCallbackDataEXT & setObjects( ArrayProxyNoTemporaries const & objects_ ) VULKAN_HPP_NOEXCEPT - { - objectCount = static_cast( objects_.size() ); - pObjects = objects_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDebugUtilsMessengerCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugUtilsMessengerCallbackDataEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugUtilsMessengerCallbackDataEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDebugUtilsMessengerCallbackDataEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, flags, pMessageIdName, messageIdNumber, pMessage, queueLabelCount, pQueueLabels, cmdBufLabelCount, pCmdBufLabels, objectCount, pObjects ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( pMessageIdName != rhs.pMessageIdName ) - if ( auto cmp = strcmp( pMessageIdName, rhs.pMessageIdName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = messageIdNumber <=> rhs.messageIdNumber; cmp != 0 ) - return cmp; - if ( pMessage != rhs.pMessage ) - if ( auto cmp = strcmp( pMessage, rhs.pMessage ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = queueLabelCount <=> rhs.queueLabelCount; cmp != 0 ) - return cmp; - if ( auto cmp = pQueueLabels <=> rhs.pQueueLabels; cmp != 0 ) - return cmp; - if ( auto cmp = cmdBufLabelCount <=> rhs.cmdBufLabelCount; cmp != 0 ) - return cmp; - if ( auto cmp = pCmdBufLabels <=> rhs.pCmdBufLabels; cmp != 0 ) - return cmp; - if ( auto cmp = objectCount <=> rhs.objectCount; cmp != 0 ) - return cmp; - if ( auto cmp = pObjects <=> rhs.pObjects; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( ( pMessageIdName == rhs.pMessageIdName ) || ( strcmp( pMessageIdName, rhs.pMessageIdName ) == 0 ) ) && - ( messageIdNumber == rhs.messageIdNumber ) && ( ( pMessage == rhs.pMessage ) || ( strcmp( pMessage, rhs.pMessage ) == 0 ) ) && - ( queueLabelCount == rhs.queueLabelCount ) && ( pQueueLabels == rhs.pQueueLabels ) && ( cmdBufLabelCount == rhs.cmdBufLabelCount ) && - ( pCmdBufLabels == rhs.pCmdBufLabels ) && ( objectCount == rhs.objectCount ) && ( pObjects == rhs.pObjects ); - } - - bool operator!=( DebugUtilsMessengerCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDebugUtilsMessengerCallbackDataEXT; - const void * pNext = {}; - DebugUtilsMessengerCallbackDataFlagsEXT flags = {}; - const char * pMessageIdName = {}; - int32_t messageIdNumber = {}; - const char * pMessage = {}; - uint32_t queueLabelCount = {}; - const DebugUtilsLabelEXT * pQueueLabels = {}; - uint32_t cmdBufLabelCount = {}; - const DebugUtilsLabelEXT * pCmdBufLabels = {}; - uint32_t objectCount = {}; - const DebugUtilsObjectNameInfoEXT * pObjects = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DebugUtilsMessengerCallbackDataEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DebugUtilsMessengerCallbackDataEXT; - }; - - typedef Bool32( VKAPI_PTR * PFN_DebugUtilsMessengerCallbackEXT )( DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - DebugUtilsMessageTypeFlagsEXT messageTypes, - const DebugUtilsMessengerCallbackDataEXT * pCallbackData, - void * pUserData ); - - // wrapper struct for struct VkDebugUtilsMessengerCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsMessengerCreateInfoEXT.html - struct DebugUtilsMessengerCreateInfoEXT - { - using NativeType = VkDebugUtilsMessengerCreateInfoEXT; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsMessengerCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_ = {}, - DebugUtilsMessageSeverityFlagsEXT messageSeverity_ = {}, - DebugUtilsMessageTypeFlagsEXT messageType_ = {}, - PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ = {}, - void * pUserData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , messageSeverity{ messageSeverity_ } - , messageType{ messageType_ } - , pfnUserCallback{ pfnUserCallback_ } - , pUserData{ pUserData_ } - { - } - - VULKAN_HPP_CONSTEXPR DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DebugUtilsMessengerCreateInfoEXT( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DebugUtilsMessengerCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic push -# if defined( __clang__ ) -# pragma clang diagnostic ignored "-Wunknown-warning-option" -# endif -# pragma GCC diagnostic ignored "-Wcast-function-type" -# endif - VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) - - DebugUtilsMessengerCreateInfoEXT( DebugUtilsMessengerCreateFlagsEXT flags_, - DebugUtilsMessageSeverityFlagsEXT messageSeverity_, - DebugUtilsMessageTypeFlagsEXT messageType_, - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_, - void * pUserData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : DebugUtilsMessengerCreateInfoEXT( - flags_, messageSeverity_, messageType_, reinterpret_cast( pfnUserCallback_ ), pUserData_, pNext_ ) - { - } -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic pop -# endif - - DebugUtilsMessengerCreateInfoEXT & operator=( DebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DebugUtilsMessengerCreateInfoEXT & operator=( VkDebugUtilsMessengerCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setFlags( DebugUtilsMessengerCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ ) & VULKAN_HPP_NOEXCEPT - { - messageSeverity = messageSeverity_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setMessageSeverity( DebugUtilsMessageSeverityFlagsEXT messageSeverity_ ) && VULKAN_HPP_NOEXCEPT - { - messageSeverity = messageSeverity_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ ) & VULKAN_HPP_NOEXCEPT - { - messageType = messageType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setMessageType( DebugUtilsMessageTypeFlagsEXT messageType_ ) && VULKAN_HPP_NOEXCEPT - { - messageType = messageType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ ) & VULKAN_HPP_NOEXCEPT - { - pfnUserCallback = pfnUserCallback_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setPfnUserCallback( PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback_ ) && VULKAN_HPP_NOEXCEPT - { - pfnUserCallback = pfnUserCallback_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT - { - pUserData = pUserData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsMessengerCreateInfoEXT && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT - { - pUserData = pUserData_; - return std::move( *this ); - } - -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic push -# if defined( __clang__ ) -# pragma clang diagnostic ignored "-Wunknown-warning-option" -# endif -# pragma GCC diagnostic ignored "-Wcast-function-type" -# endif - VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) - - DebugUtilsMessengerCreateInfoEXT & setPfnUserCallback( PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT - { - return setPfnUserCallback( reinterpret_cast( pfnUserCallback_ ) ); - } -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic pop -# endif -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDebugUtilsMessengerCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugUtilsMessengerCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugUtilsMessengerCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDebugUtilsMessengerCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, messageSeverity, messageType, pfnUserCallback, pUserData ); - } -#endif - - bool operator==( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -#if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -#else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( messageSeverity == rhs.messageSeverity ) && - ( messageType == rhs.messageType ) && ( pfnUserCallback == rhs.pfnUserCallback ) && ( pUserData == rhs.pUserData ); -#endif - } - - bool operator!=( DebugUtilsMessengerCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDebugUtilsMessengerCreateInfoEXT; - const void * pNext = {}; - DebugUtilsMessengerCreateFlagsEXT flags = {}; - DebugUtilsMessageSeverityFlagsEXT messageSeverity = {}; - DebugUtilsMessageTypeFlagsEXT messageType = {}; - PFN_DebugUtilsMessengerCallbackEXT pfnUserCallback = {}; - void * pUserData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DebugUtilsMessengerCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DebugUtilsMessengerCreateInfoEXT; - }; - - // wrapper struct for struct VkDebugUtilsObjectTagInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDebugUtilsObjectTagInfoEXT.html - struct DebugUtilsObjectTagInfoEXT - { - using NativeType = VkDebugUtilsObjectTagInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDebugUtilsObjectTagInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( ObjectType objectType_ = ObjectType::eUnknown, - uint64_t objectHandle_ = {}, - uint64_t tagName_ = {}, - size_t tagSize_ = {}, - const void * pTag_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , objectType{ objectType_ } - , objectHandle{ objectHandle_ } - , tagName{ tagName_ } - , tagSize{ tagSize_ } - , pTag{ pTag_ } - { - } - - VULKAN_HPP_CONSTEXPR DebugUtilsObjectTagInfoEXT( DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DebugUtilsObjectTagInfoEXT( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DebugUtilsObjectTagInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - DebugUtilsObjectTagInfoEXT( - ObjectType objectType_, uint64_t objectHandle_, uint64_t tagName_, ArrayProxyNoTemporaries const & tag_, const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , objectType( objectType_ ) - , objectHandle( objectHandle_ ) - , tagName( tagName_ ) - , tagSize( tag_.size() * sizeof( T ) ) - , pTag( tag_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DebugUtilsObjectTagInfoEXT & operator=( DebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DebugUtilsObjectTagInfoEXT & operator=( VkDebugUtilsObjectTagInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setObjectType( ObjectType objectType_ ) & VULKAN_HPP_NOEXCEPT - { - objectType = objectType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setObjectType( ObjectType objectType_ ) && VULKAN_HPP_NOEXCEPT - { - objectType = objectType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setObjectHandle( uint64_t objectHandle_ ) & VULKAN_HPP_NOEXCEPT - { - objectHandle = objectHandle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setObjectHandle( uint64_t objectHandle_ ) && VULKAN_HPP_NOEXCEPT - { - objectHandle = objectHandle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setTagName( uint64_t tagName_ ) & VULKAN_HPP_NOEXCEPT - { - tagName = tagName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setTagName( uint64_t tagName_ ) && VULKAN_HPP_NOEXCEPT - { - tagName = tagName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setTagSize( size_t tagSize_ ) & VULKAN_HPP_NOEXCEPT - { - tagSize = tagSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setTagSize( size_t tagSize_ ) && VULKAN_HPP_NOEXCEPT - { - tagSize = tagSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT & setPTag( const void * pTag_ ) & VULKAN_HPP_NOEXCEPT - { - pTag = pTag_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DebugUtilsObjectTagInfoEXT && setPTag( const void * pTag_ ) && VULKAN_HPP_NOEXCEPT - { - pTag = pTag_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - DebugUtilsObjectTagInfoEXT & setTag( ArrayProxyNoTemporaries const & tag_ ) VULKAN_HPP_NOEXCEPT - { - tagSize = tag_.size() * sizeof( T ); - pTag = tag_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDebugUtilsObjectTagInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugUtilsObjectTagInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDebugUtilsObjectTagInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDebugUtilsObjectTagInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, objectType, objectHandle, tagName, tagSize, pTag ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DebugUtilsObjectTagInfoEXT const & ) const = default; -#else - bool operator==( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) && - ( tagName == rhs.tagName ) && ( tagSize == rhs.tagSize ) && ( pTag == rhs.pTag ); -# endif - } - - bool operator!=( DebugUtilsObjectTagInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDebugUtilsObjectTagInfoEXT; - const void * pNext = {}; - ObjectType objectType = ObjectType::eUnknown; - uint64_t objectHandle = {}; - uint64_t tagName = {}; - size_t tagSize = {}; - const void * pTag = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DebugUtilsObjectTagInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DebugUtilsObjectTagInfoEXT; - }; - - // wrapper struct for struct VkDecompressMemoryRegionEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDecompressMemoryRegionEXT.html - struct DecompressMemoryRegionEXT - { - using NativeType = VkDecompressMemoryRegionEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DecompressMemoryRegionEXT( DeviceAddress srcAddress_ = {}, - DeviceAddress dstAddress_ = {}, - DeviceSize compressedSize_ = {}, - DeviceSize decompressedSize_ = {} ) VULKAN_HPP_NOEXCEPT - : srcAddress{ srcAddress_ } - , dstAddress{ dstAddress_ } - , compressedSize{ compressedSize_ } - , decompressedSize{ decompressedSize_ } - { - } - - VULKAN_HPP_CONSTEXPR DecompressMemoryRegionEXT( DecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DecompressMemoryRegionEXT( VkDecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DecompressMemoryRegionEXT( *reinterpret_cast( &rhs ) ) - { - } - - DecompressMemoryRegionEXT & operator=( DecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DecompressMemoryRegionEXT & operator=( VkDecompressMemoryRegionEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT - { - srcAddress = srcAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT - { - srcAddress = srcAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setDstAddress( DeviceAddress dstAddress_ ) & VULKAN_HPP_NOEXCEPT - { - dstAddress = dstAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setDstAddress( DeviceAddress dstAddress_ ) && VULKAN_HPP_NOEXCEPT - { - dstAddress = dstAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setCompressedSize( DeviceSize compressedSize_ ) & VULKAN_HPP_NOEXCEPT - { - compressedSize = compressedSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setCompressedSize( DeviceSize compressedSize_ ) && VULKAN_HPP_NOEXCEPT - { - compressedSize = compressedSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT & setDecompressedSize( DeviceSize decompressedSize_ ) & VULKAN_HPP_NOEXCEPT - { - decompressedSize = decompressedSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionEXT && setDecompressedSize( DeviceSize decompressedSize_ ) && VULKAN_HPP_NOEXCEPT - { - decompressedSize = decompressedSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDecompressMemoryRegionEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDecompressMemoryRegionEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDecompressMemoryRegionEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDecompressMemoryRegionEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( srcAddress, dstAddress, compressedSize, decompressedSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DecompressMemoryRegionEXT const & ) const = default; -#else - bool operator==( DecompressMemoryRegionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( srcAddress == rhs.srcAddress ) && ( dstAddress == rhs.dstAddress ) && ( compressedSize == rhs.compressedSize ) && - ( decompressedSize == rhs.decompressedSize ); -# endif - } - - bool operator!=( DecompressMemoryRegionEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress srcAddress = {}; - DeviceAddress dstAddress = {}; - DeviceSize compressedSize = {}; - DeviceSize decompressedSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DecompressMemoryRegionEXT; - }; -#endif - - // wrapper struct for struct VkDecompressMemoryInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDecompressMemoryInfoEXT.html - struct DecompressMemoryInfoEXT - { - using NativeType = VkDecompressMemoryInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDecompressMemoryInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DecompressMemoryInfoEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod_ = {}, - uint32_t regionCount_ = {}, - const DecompressMemoryRegionEXT * pRegions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , decompressionMethod{ decompressionMethod_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR DecompressMemoryInfoEXT( DecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DecompressMemoryInfoEXT( VkDecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DecompressMemoryInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DecompressMemoryInfoEXT( MemoryDecompressionMethodFlagsEXT decompressionMethod_, - ArrayProxyNoTemporaries const & regions_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), decompressionMethod( decompressionMethod_ ), regionCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DecompressMemoryInfoEXT & operator=( DecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DecompressMemoryInfoEXT & operator=( VkDecompressMemoryInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setDecompressionMethod( MemoryDecompressionMethodFlagsEXT decompressionMethod_ ) & VULKAN_HPP_NOEXCEPT - { - decompressionMethod = decompressionMethod_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setDecompressionMethod( MemoryDecompressionMethodFlagsEXT decompressionMethod_ ) && VULKAN_HPP_NOEXCEPT - { - decompressionMethod = decompressionMethod_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT & setPRegions( const DecompressMemoryRegionEXT * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryInfoEXT && setPRegions( const DecompressMemoryRegionEXT * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DecompressMemoryInfoEXT & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDecompressMemoryInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDecompressMemoryInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDecompressMemoryInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDecompressMemoryInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, decompressionMethod, regionCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DecompressMemoryInfoEXT const & ) const = default; -#else - bool operator==( DecompressMemoryInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decompressionMethod == rhs.decompressionMethod ) && ( regionCount == rhs.regionCount ) && - ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( DecompressMemoryInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDecompressMemoryInfoEXT; - const void * pNext = {}; - MemoryDecompressionMethodFlagsEXT decompressionMethod = {}; - uint32_t regionCount = {}; - const DecompressMemoryRegionEXT * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DecompressMemoryInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DecompressMemoryInfoEXT; - }; - - // wrapper struct for struct VkDecompressMemoryRegionNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDecompressMemoryRegionNV.html - struct DecompressMemoryRegionNV - { - using NativeType = VkDecompressMemoryRegionNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DecompressMemoryRegionNV( DeviceAddress srcAddress_ = {}, - DeviceAddress dstAddress_ = {}, - DeviceSize compressedSize_ = {}, - DeviceSize decompressedSize_ = {}, - MemoryDecompressionMethodFlagsNV decompressionMethod_ = {} ) VULKAN_HPP_NOEXCEPT - : srcAddress{ srcAddress_ } - , dstAddress{ dstAddress_ } - , compressedSize{ compressedSize_ } - , decompressedSize{ decompressedSize_ } - , decompressionMethod{ decompressionMethod_ } - { - } - - VULKAN_HPP_CONSTEXPR DecompressMemoryRegionNV( DecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DecompressMemoryRegionNV( VkDecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT - : DecompressMemoryRegionNV( *reinterpret_cast( &rhs ) ) - { - } - - DecompressMemoryRegionNV & operator=( DecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DecompressMemoryRegionNV & operator=( VkDecompressMemoryRegionNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setSrcAddress( DeviceAddress srcAddress_ ) & VULKAN_HPP_NOEXCEPT - { - srcAddress = srcAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setSrcAddress( DeviceAddress srcAddress_ ) && VULKAN_HPP_NOEXCEPT - { - srcAddress = srcAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setDstAddress( DeviceAddress dstAddress_ ) & VULKAN_HPP_NOEXCEPT - { - dstAddress = dstAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setDstAddress( DeviceAddress dstAddress_ ) && VULKAN_HPP_NOEXCEPT - { - dstAddress = dstAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setCompressedSize( DeviceSize compressedSize_ ) & VULKAN_HPP_NOEXCEPT - { - compressedSize = compressedSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setCompressedSize( DeviceSize compressedSize_ ) && VULKAN_HPP_NOEXCEPT - { - compressedSize = compressedSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setDecompressedSize( DeviceSize decompressedSize_ ) & VULKAN_HPP_NOEXCEPT - { - decompressedSize = decompressedSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setDecompressedSize( DeviceSize decompressedSize_ ) && VULKAN_HPP_NOEXCEPT - { - decompressedSize = decompressedSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV & setDecompressionMethod( MemoryDecompressionMethodFlagsNV decompressionMethod_ ) & VULKAN_HPP_NOEXCEPT - { - decompressionMethod = decompressionMethod_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DecompressMemoryRegionNV && setDecompressionMethod( MemoryDecompressionMethodFlagsNV decompressionMethod_ ) && VULKAN_HPP_NOEXCEPT - { - decompressionMethod = decompressionMethod_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDecompressMemoryRegionNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDecompressMemoryRegionNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDecompressMemoryRegionNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDecompressMemoryRegionNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( srcAddress, dstAddress, compressedSize, decompressedSize, decompressionMethod ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DecompressMemoryRegionNV const & ) const = default; -#else - bool operator==( DecompressMemoryRegionNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( srcAddress == rhs.srcAddress ) && ( dstAddress == rhs.dstAddress ) && ( compressedSize == rhs.compressedSize ) && - ( decompressedSize == rhs.decompressedSize ) && ( decompressionMethod == rhs.decompressionMethod ); -# endif - } - - bool operator!=( DecompressMemoryRegionNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress srcAddress = {}; - DeviceAddress dstAddress = {}; - DeviceSize compressedSize = {}; - DeviceSize decompressedSize = {}; - MemoryDecompressionMethodFlagsNV decompressionMethod = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DecompressMemoryRegionNV; - }; -#endif - - // wrapper struct for struct VkDedicatedAllocationBufferCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDedicatedAllocationBufferCreateInfoNV.html - struct DedicatedAllocationBufferCreateInfoNV - { - using NativeType = VkDedicatedAllocationBufferCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationBufferCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( Bool32 dedicatedAllocation_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dedicatedAllocation{ dedicatedAllocation_ } - { - } - - VULKAN_HPP_CONSTEXPR DedicatedAllocationBufferCreateInfoNV( DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DedicatedAllocationBufferCreateInfoNV( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : DedicatedAllocationBufferCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - DedicatedAllocationBufferCreateInfoNV & operator=( DedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DedicatedAllocationBufferCreateInfoNV & operator=( VkDedicatedAllocationBufferCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ ) & VULKAN_HPP_NOEXCEPT - { - dedicatedAllocation = dedicatedAllocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationBufferCreateInfoNV && setDedicatedAllocation( Bool32 dedicatedAllocation_ ) && VULKAN_HPP_NOEXCEPT - { - dedicatedAllocation = dedicatedAllocation_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDedicatedAllocationBufferCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDedicatedAllocationBufferCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDedicatedAllocationBufferCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDedicatedAllocationBufferCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dedicatedAllocation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DedicatedAllocationBufferCreateInfoNV const & ) const = default; -#else - bool operator==( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation ); -# endif - } - - bool operator!=( DedicatedAllocationBufferCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDedicatedAllocationBufferCreateInfoNV; - const void * pNext = {}; - Bool32 dedicatedAllocation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DedicatedAllocationBufferCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = DedicatedAllocationBufferCreateInfoNV; - }; - - // wrapper struct for struct VkDedicatedAllocationImageCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDedicatedAllocationImageCreateInfoNV.html - struct DedicatedAllocationImageCreateInfoNV - { - using NativeType = VkDedicatedAllocationImageCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationImageCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( Bool32 dedicatedAllocation_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dedicatedAllocation{ dedicatedAllocation_ } - { - } - - VULKAN_HPP_CONSTEXPR DedicatedAllocationImageCreateInfoNV( DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DedicatedAllocationImageCreateInfoNV( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : DedicatedAllocationImageCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - DedicatedAllocationImageCreateInfoNV & operator=( DedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DedicatedAllocationImageCreateInfoNV & operator=( VkDedicatedAllocationImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV & setDedicatedAllocation( Bool32 dedicatedAllocation_ ) & VULKAN_HPP_NOEXCEPT - { - dedicatedAllocation = dedicatedAllocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationImageCreateInfoNV && setDedicatedAllocation( Bool32 dedicatedAllocation_ ) && VULKAN_HPP_NOEXCEPT - { - dedicatedAllocation = dedicatedAllocation_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDedicatedAllocationImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDedicatedAllocationImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDedicatedAllocationImageCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDedicatedAllocationImageCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dedicatedAllocation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DedicatedAllocationImageCreateInfoNV const & ) const = default; -#else - bool operator==( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocation == rhs.dedicatedAllocation ); -# endif - } - - bool operator!=( DedicatedAllocationImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDedicatedAllocationImageCreateInfoNV; - const void * pNext = {}; - Bool32 dedicatedAllocation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DedicatedAllocationImageCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = DedicatedAllocationImageCreateInfoNV; - }; - - // wrapper struct for struct VkDedicatedAllocationMemoryAllocateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDedicatedAllocationMemoryAllocateInfoNV.html - struct DedicatedAllocationMemoryAllocateInfoNV - { - using NativeType = VkDedicatedAllocationMemoryAllocateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( Image image_ = {}, Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , image{ image_ } - , buffer{ buffer_ } - { - } - - VULKAN_HPP_CONSTEXPR DedicatedAllocationMemoryAllocateInfoNV( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DedicatedAllocationMemoryAllocateInfoNV( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : DedicatedAllocationMemoryAllocateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - DedicatedAllocationMemoryAllocateInfoNV & operator=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DedicatedAllocationMemoryAllocateInfoNV & operator=( VkDedicatedAllocationMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DedicatedAllocationMemoryAllocateInfoNV && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDedicatedAllocationMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDedicatedAllocationMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDedicatedAllocationMemoryAllocateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDedicatedAllocationMemoryAllocateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, image, buffer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DedicatedAllocationMemoryAllocateInfoNV const & ) const = default; -#else - bool operator==( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer ); -# endif - } - - bool operator!=( DedicatedAllocationMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDedicatedAllocationMemoryAllocateInfoNV; - const void * pNext = {}; - Image image = {}; - Buffer buffer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DedicatedAllocationMemoryAllocateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = DedicatedAllocationMemoryAllocateInfoNV; - }; - - // wrapper struct for struct VkMemoryBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryBarrier2.html - struct MemoryBarrier2 - { - using NativeType = VkMemoryBarrier2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryBarrier2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryBarrier2( PipelineStageFlags2 srcStageMask_ = {}, - AccessFlags2 srcAccessMask_ = {}, - PipelineStageFlags2 dstStageMask_ = {}, - AccessFlags2 dstAccessMask_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcStageMask{ srcStageMask_ } - , srcAccessMask{ srcAccessMask_ } - , dstStageMask{ dstStageMask_ } - , dstAccessMask{ dstAccessMask_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryBarrier2( MemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryBarrier2( VkMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryBarrier2( *reinterpret_cast( &rhs ) ) {} - - MemoryBarrier2 & operator=( MemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryBarrier2 & operator=( VkMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier2 && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryBarrier2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryBarrier2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryBarrier2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryBarrier2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryBarrier2 const & ) const = default; -#else - bool operator==( MemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && - ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask ); -# endif - } - - bool operator!=( MemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryBarrier2; - const void * pNext = {}; - PipelineStageFlags2 srcStageMask = {}; - AccessFlags2 srcAccessMask = {}; - PipelineStageFlags2 dstStageMask = {}; - AccessFlags2 dstAccessMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryBarrier2; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryBarrier2; - }; - - using MemoryBarrier2KHR = MemoryBarrier2; - - // wrapper struct for struct VkImageSubresourceRange, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSubresourceRange.html - struct ImageSubresourceRange - { - using NativeType = VkImageSubresourceRange; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageSubresourceRange( ImageAspectFlags aspectMask_ = {}, - uint32_t baseMipLevel_ = {}, - uint32_t levelCount_ = {}, - uint32_t baseArrayLayer_ = {}, - uint32_t layerCount_ = {} ) VULKAN_HPP_NOEXCEPT - : aspectMask{ aspectMask_ } - , baseMipLevel{ baseMipLevel_ } - , levelCount{ levelCount_ } - , baseArrayLayer{ baseArrayLayer_ } - , layerCount{ layerCount_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageSubresourceRange( ImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageSubresourceRange( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageSubresourceRange( *reinterpret_cast( &rhs ) ) - { - } - - ImageSubresourceRange & operator=( ImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageSubresourceRange & operator=( VkImageSubresourceRange const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setBaseMipLevel( uint32_t baseMipLevel_ ) & VULKAN_HPP_NOEXCEPT - { - baseMipLevel = baseMipLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setBaseMipLevel( uint32_t baseMipLevel_ ) && VULKAN_HPP_NOEXCEPT - { - baseMipLevel = baseMipLevel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setLevelCount( uint32_t levelCount_ ) & VULKAN_HPP_NOEXCEPT - { - levelCount = levelCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setLevelCount( uint32_t levelCount_ ) && VULKAN_HPP_NOEXCEPT - { - levelCount = levelCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setBaseArrayLayer( uint32_t baseArrayLayer_ ) & VULKAN_HPP_NOEXCEPT - { - baseArrayLayer = baseArrayLayer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setBaseArrayLayer( uint32_t baseArrayLayer_ ) && VULKAN_HPP_NOEXCEPT - { - baseArrayLayer = baseArrayLayer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresourceRange && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageSubresourceRange const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSubresourceRange &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSubresourceRange const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageSubresourceRange *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( aspectMask, baseMipLevel, levelCount, baseArrayLayer, layerCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageSubresourceRange const & ) const = default; -#else - bool operator==( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( aspectMask == rhs.aspectMask ) && ( baseMipLevel == rhs.baseMipLevel ) && ( levelCount == rhs.levelCount ) && - ( baseArrayLayer == rhs.baseArrayLayer ) && ( layerCount == rhs.layerCount ); -# endif - } - - bool operator!=( ImageSubresourceRange const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ImageAspectFlags aspectMask = {}; - uint32_t baseMipLevel = {}; - uint32_t levelCount = {}; - uint32_t baseArrayLayer = {}; - uint32_t layerCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageSubresourceRange; - }; -#endif - - // wrapper struct for struct VkImageMemoryBarrier2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageMemoryBarrier2.html - struct ImageMemoryBarrier2 - { - using NativeType = VkImageMemoryBarrier2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryBarrier2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageMemoryBarrier2( PipelineStageFlags2 srcStageMask_ = {}, - AccessFlags2 srcAccessMask_ = {}, - PipelineStageFlags2 dstStageMask_ = {}, - AccessFlags2 dstAccessMask_ = {}, - ImageLayout oldLayout_ = ImageLayout::eUndefined, - ImageLayout newLayout_ = ImageLayout::eUndefined, - uint32_t srcQueueFamilyIndex_ = {}, - uint32_t dstQueueFamilyIndex_ = {}, - Image image_ = {}, - ImageSubresourceRange subresourceRange_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcStageMask{ srcStageMask_ } - , srcAccessMask{ srcAccessMask_ } - , dstStageMask{ dstStageMask_ } - , dstAccessMask{ dstAccessMask_ } - , oldLayout{ oldLayout_ } - , newLayout{ newLayout_ } - , srcQueueFamilyIndex{ srcQueueFamilyIndex_ } - , dstQueueFamilyIndex{ dstQueueFamilyIndex_ } - , image{ image_ } - , subresourceRange{ subresourceRange_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageMemoryBarrier2( ImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageMemoryBarrier2( VkImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageMemoryBarrier2( *reinterpret_cast( &rhs ) ) - { - } - - ImageMemoryBarrier2 & operator=( ImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageMemoryBarrier2 & operator=( VkImageMemoryBarrier2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setOldLayout( ImageLayout oldLayout_ ) & VULKAN_HPP_NOEXCEPT - { - oldLayout = oldLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setOldLayout( ImageLayout oldLayout_ ) && VULKAN_HPP_NOEXCEPT - { - oldLayout = oldLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setNewLayout( ImageLayout newLayout_ ) & VULKAN_HPP_NOEXCEPT - { - newLayout = newLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setNewLayout( ImageLayout newLayout_ ) && VULKAN_HPP_NOEXCEPT - { - newLayout = newLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 & setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) & VULKAN_HPP_NOEXCEPT - { - subresourceRange = subresourceRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier2 && setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) && VULKAN_HPP_NOEXCEPT - { - subresourceRange = subresourceRange_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageMemoryBarrier2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageMemoryBarrier2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageMemoryBarrier2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageMemoryBarrier2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - srcStageMask, - srcAccessMask, - dstStageMask, - dstAccessMask, - oldLayout, - newLayout, - srcQueueFamilyIndex, - dstQueueFamilyIndex, - image, - subresourceRange ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageMemoryBarrier2 const & ) const = default; -#else - bool operator==( ImageMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && - ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask ) && ( oldLayout == rhs.oldLayout ) && - ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && - ( image == rhs.image ) && ( subresourceRange == rhs.subresourceRange ); -# endif - } - - bool operator!=( ImageMemoryBarrier2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageMemoryBarrier2; - const void * pNext = {}; - PipelineStageFlags2 srcStageMask = {}; - AccessFlags2 srcAccessMask = {}; - PipelineStageFlags2 dstStageMask = {}; - AccessFlags2 dstAccessMask = {}; - ImageLayout oldLayout = ImageLayout::eUndefined; - ImageLayout newLayout = ImageLayout::eUndefined; - uint32_t srcQueueFamilyIndex = {}; - uint32_t dstQueueFamilyIndex = {}; - Image image = {}; - ImageSubresourceRange subresourceRange = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageMemoryBarrier2; - }; -#endif - - template <> - struct CppType - { - using Type = ImageMemoryBarrier2; - }; - - using ImageMemoryBarrier2KHR = ImageMemoryBarrier2; - - // wrapper struct for struct VkDependencyInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDependencyInfo.html - struct DependencyInfo - { - using NativeType = VkDependencyInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDependencyInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DependencyInfo( DependencyFlags dependencyFlags_ = {}, - uint32_t memoryBarrierCount_ = {}, - const MemoryBarrier2 * pMemoryBarriers_ = {}, - uint32_t bufferMemoryBarrierCount_ = {}, - const BufferMemoryBarrier2 * pBufferMemoryBarriers_ = {}, - uint32_t imageMemoryBarrierCount_ = {}, - const ImageMemoryBarrier2 * pImageMemoryBarriers_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dependencyFlags{ dependencyFlags_ } - , memoryBarrierCount{ memoryBarrierCount_ } - , pMemoryBarriers{ pMemoryBarriers_ } - , bufferMemoryBarrierCount{ bufferMemoryBarrierCount_ } - , pBufferMemoryBarriers{ pBufferMemoryBarriers_ } - , imageMemoryBarrierCount{ imageMemoryBarrierCount_ } - , pImageMemoryBarriers{ pImageMemoryBarriers_ } - { - } - - VULKAN_HPP_CONSTEXPR DependencyInfo( DependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DependencyInfo( VkDependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT : DependencyInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DependencyInfo( DependencyFlags dependencyFlags_, - ArrayProxyNoTemporaries const & memoryBarriers_, - ArrayProxyNoTemporaries const & bufferMemoryBarriers_ = {}, - ArrayProxyNoTemporaries const & imageMemoryBarriers_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , dependencyFlags( dependencyFlags_ ) - , memoryBarrierCount( static_cast( memoryBarriers_.size() ) ) - , pMemoryBarriers( memoryBarriers_.data() ) - , bufferMemoryBarrierCount( static_cast( bufferMemoryBarriers_.size() ) ) - , pBufferMemoryBarriers( bufferMemoryBarriers_.data() ) - , imageMemoryBarrierCount( static_cast( imageMemoryBarriers_.size() ) ) - , pImageMemoryBarriers( imageMemoryBarriers_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DependencyInfo & operator=( DependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DependencyInfo & operator=( VkDependencyInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setDependencyFlags( DependencyFlags dependencyFlags_ ) & VULKAN_HPP_NOEXCEPT - { - dependencyFlags = dependencyFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setDependencyFlags( DependencyFlags dependencyFlags_ ) && VULKAN_HPP_NOEXCEPT - { - dependencyFlags = dependencyFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setMemoryBarrierCount( uint32_t memoryBarrierCount_ ) & VULKAN_HPP_NOEXCEPT - { - memoryBarrierCount = memoryBarrierCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setMemoryBarrierCount( uint32_t memoryBarrierCount_ ) && VULKAN_HPP_NOEXCEPT - { - memoryBarrierCount = memoryBarrierCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPMemoryBarriers( const MemoryBarrier2 * pMemoryBarriers_ ) & VULKAN_HPP_NOEXCEPT - { - pMemoryBarriers = pMemoryBarriers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPMemoryBarriers( const MemoryBarrier2 * pMemoryBarriers_ ) && VULKAN_HPP_NOEXCEPT - { - pMemoryBarriers = pMemoryBarriers_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DependencyInfo & setMemoryBarriers( ArrayProxyNoTemporaries const & memoryBarriers_ ) VULKAN_HPP_NOEXCEPT - { - memoryBarrierCount = static_cast( memoryBarriers_.size() ); - pMemoryBarriers = memoryBarriers_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setBufferMemoryBarrierCount( uint32_t bufferMemoryBarrierCount_ ) & VULKAN_HPP_NOEXCEPT - { - bufferMemoryBarrierCount = bufferMemoryBarrierCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setBufferMemoryBarrierCount( uint32_t bufferMemoryBarrierCount_ ) && VULKAN_HPP_NOEXCEPT - { - bufferMemoryBarrierCount = bufferMemoryBarrierCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPBufferMemoryBarriers( const BufferMemoryBarrier2 * pBufferMemoryBarriers_ ) & VULKAN_HPP_NOEXCEPT - { - pBufferMemoryBarriers = pBufferMemoryBarriers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPBufferMemoryBarriers( const BufferMemoryBarrier2 * pBufferMemoryBarriers_ ) && VULKAN_HPP_NOEXCEPT - { - pBufferMemoryBarriers = pBufferMemoryBarriers_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DependencyInfo & setBufferMemoryBarriers( ArrayProxyNoTemporaries const & bufferMemoryBarriers_ ) VULKAN_HPP_NOEXCEPT - { - bufferMemoryBarrierCount = static_cast( bufferMemoryBarriers_.size() ); - pBufferMemoryBarriers = bufferMemoryBarriers_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setImageMemoryBarrierCount( uint32_t imageMemoryBarrierCount_ ) & VULKAN_HPP_NOEXCEPT - { - imageMemoryBarrierCount = imageMemoryBarrierCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setImageMemoryBarrierCount( uint32_t imageMemoryBarrierCount_ ) && VULKAN_HPP_NOEXCEPT - { - imageMemoryBarrierCount = imageMemoryBarrierCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo & setPImageMemoryBarriers( const ImageMemoryBarrier2 * pImageMemoryBarriers_ ) & VULKAN_HPP_NOEXCEPT - { - pImageMemoryBarriers = pImageMemoryBarriers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DependencyInfo && setPImageMemoryBarriers( const ImageMemoryBarrier2 * pImageMemoryBarriers_ ) && VULKAN_HPP_NOEXCEPT - { - pImageMemoryBarriers = pImageMemoryBarriers_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DependencyInfo & setImageMemoryBarriers( ArrayProxyNoTemporaries const & imageMemoryBarriers_ ) VULKAN_HPP_NOEXCEPT - { - imageMemoryBarrierCount = static_cast( imageMemoryBarriers_.size() ); - pImageMemoryBarriers = imageMemoryBarriers_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDependencyInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDependencyInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDependencyInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDependencyInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - dependencyFlags, - memoryBarrierCount, - pMemoryBarriers, - bufferMemoryBarrierCount, - pBufferMemoryBarriers, - imageMemoryBarrierCount, - pImageMemoryBarriers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DependencyInfo const & ) const = default; -#else - bool operator==( DependencyInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dependencyFlags == rhs.dependencyFlags ) && - ( memoryBarrierCount == rhs.memoryBarrierCount ) && ( pMemoryBarriers == rhs.pMemoryBarriers ) && - ( bufferMemoryBarrierCount == rhs.bufferMemoryBarrierCount ) && ( pBufferMemoryBarriers == rhs.pBufferMemoryBarriers ) && - ( imageMemoryBarrierCount == rhs.imageMemoryBarrierCount ) && ( pImageMemoryBarriers == rhs.pImageMemoryBarriers ); -# endif - } - - bool operator!=( DependencyInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDependencyInfo; - const void * pNext = {}; - DependencyFlags dependencyFlags = {}; - uint32_t memoryBarrierCount = {}; - const MemoryBarrier2 * pMemoryBarriers = {}; - uint32_t bufferMemoryBarrierCount = {}; - const BufferMemoryBarrier2 * pBufferMemoryBarriers = {}; - uint32_t imageMemoryBarrierCount = {}; - const ImageMemoryBarrier2 * pImageMemoryBarriers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DependencyInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DependencyInfo; - }; - - using DependencyInfoKHR = DependencyInfo; - - // wrapper struct for struct VkDepthBiasInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthBiasInfoEXT.html - struct DepthBiasInfoEXT - { - using NativeType = VkDepthBiasInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDepthBiasInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DepthBiasInfoEXT( float depthBiasConstantFactor_ = {}, - float depthBiasClamp_ = {}, - float depthBiasSlopeFactor_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , depthBiasConstantFactor{ depthBiasConstantFactor_ } - , depthBiasClamp{ depthBiasClamp_ } - , depthBiasSlopeFactor{ depthBiasSlopeFactor_ } - { - } - - VULKAN_HPP_CONSTEXPR DepthBiasInfoEXT( DepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DepthBiasInfoEXT( VkDepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DepthBiasInfoEXT( *reinterpret_cast( &rhs ) ) {} - - DepthBiasInfoEXT & operator=( DepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DepthBiasInfoEXT & operator=( VkDepthBiasInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) & VULKAN_HPP_NOEXCEPT - { - depthBiasConstantFactor = depthBiasConstantFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) && VULKAN_HPP_NOEXCEPT - { - depthBiasConstantFactor = depthBiasConstantFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setDepthBiasClamp( float depthBiasClamp_ ) & VULKAN_HPP_NOEXCEPT - { - depthBiasClamp = depthBiasClamp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setDepthBiasClamp( float depthBiasClamp_ ) && VULKAN_HPP_NOEXCEPT - { - depthBiasClamp = depthBiasClamp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT & setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) & VULKAN_HPP_NOEXCEPT - { - depthBiasSlopeFactor = depthBiasSlopeFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasInfoEXT && setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) && VULKAN_HPP_NOEXCEPT - { - depthBiasSlopeFactor = depthBiasSlopeFactor_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDepthBiasInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDepthBiasInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDepthBiasInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDepthBiasInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DepthBiasInfoEXT const & ) const = default; -#else - bool operator==( DepthBiasInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) && - ( depthBiasClamp == rhs.depthBiasClamp ) && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor ); -# endif - } - - bool operator!=( DepthBiasInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDepthBiasInfoEXT; - const void * pNext = {}; - float depthBiasConstantFactor = {}; - float depthBiasClamp = {}; - float depthBiasSlopeFactor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DepthBiasInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DepthBiasInfoEXT; - }; - - // wrapper struct for struct VkDepthBiasRepresentationInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthBiasRepresentationInfoEXT.html - struct DepthBiasRepresentationInfoEXT - { - using NativeType = VkDepthBiasRepresentationInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDepthBiasRepresentationInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - DepthBiasRepresentationInfoEXT( DepthBiasRepresentationEXT depthBiasRepresentation_ = DepthBiasRepresentationEXT::eLeastRepresentableValueFormat, - Bool32 depthBiasExact_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , depthBiasRepresentation{ depthBiasRepresentation_ } - , depthBiasExact{ depthBiasExact_ } - { - } - - VULKAN_HPP_CONSTEXPR DepthBiasRepresentationInfoEXT( DepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DepthBiasRepresentationInfoEXT( VkDepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DepthBiasRepresentationInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - DepthBiasRepresentationInfoEXT & operator=( DepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DepthBiasRepresentationInfoEXT & operator=( VkDepthBiasRepresentationInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT & setDepthBiasRepresentation( DepthBiasRepresentationEXT depthBiasRepresentation_ ) & - VULKAN_HPP_NOEXCEPT - { - depthBiasRepresentation = depthBiasRepresentation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT && setDepthBiasRepresentation( DepthBiasRepresentationEXT depthBiasRepresentation_ ) && - VULKAN_HPP_NOEXCEPT - { - depthBiasRepresentation = depthBiasRepresentation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT & setDepthBiasExact( Bool32 depthBiasExact_ ) & VULKAN_HPP_NOEXCEPT - { - depthBiasExact = depthBiasExact_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DepthBiasRepresentationInfoEXT && setDepthBiasExact( Bool32 depthBiasExact_ ) && VULKAN_HPP_NOEXCEPT - { - depthBiasExact = depthBiasExact_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDepthBiasRepresentationInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDepthBiasRepresentationInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDepthBiasRepresentationInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDepthBiasRepresentationInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, depthBiasRepresentation, depthBiasExact ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DepthBiasRepresentationInfoEXT const & ) const = default; -#else - bool operator==( DepthBiasRepresentationInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthBiasRepresentation == rhs.depthBiasRepresentation ) && - ( depthBiasExact == rhs.depthBiasExact ); -# endif - } - - bool operator!=( DepthBiasRepresentationInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDepthBiasRepresentationInfoEXT; - const void * pNext = {}; - DepthBiasRepresentationEXT depthBiasRepresentation = DepthBiasRepresentationEXT::eLeastRepresentableValueFormat; - Bool32 depthBiasExact = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DepthBiasRepresentationInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DepthBiasRepresentationInfoEXT; - }; - - // wrapper struct for struct VkDepthClampRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDepthClampRangeEXT.html - struct DepthClampRangeEXT - { - using NativeType = VkDepthClampRangeEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DepthClampRangeEXT( float minDepthClamp_ = {}, float maxDepthClamp_ = {} ) VULKAN_HPP_NOEXCEPT - : minDepthClamp{ minDepthClamp_ } - , maxDepthClamp{ maxDepthClamp_ } - { - } - - VULKAN_HPP_CONSTEXPR DepthClampRangeEXT( DepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DepthClampRangeEXT( VkDepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DepthClampRangeEXT( *reinterpret_cast( &rhs ) ) {} - - DepthClampRangeEXT & operator=( DepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DepthClampRangeEXT & operator=( VkDepthClampRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT & setMinDepthClamp( float minDepthClamp_ ) & VULKAN_HPP_NOEXCEPT - { - minDepthClamp = minDepthClamp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT && setMinDepthClamp( float minDepthClamp_ ) && VULKAN_HPP_NOEXCEPT - { - minDepthClamp = minDepthClamp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT & setMaxDepthClamp( float maxDepthClamp_ ) & VULKAN_HPP_NOEXCEPT - { - maxDepthClamp = maxDepthClamp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DepthClampRangeEXT && setMaxDepthClamp( float maxDepthClamp_ ) && VULKAN_HPP_NOEXCEPT - { - maxDepthClamp = maxDepthClamp_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDepthClampRangeEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDepthClampRangeEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDepthClampRangeEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDepthClampRangeEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( minDepthClamp, maxDepthClamp ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DepthClampRangeEXT const & ) const = default; -#else - bool operator==( DepthClampRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( minDepthClamp == rhs.minDepthClamp ) && ( maxDepthClamp == rhs.maxDepthClamp ); -# endif - } - - bool operator!=( DepthClampRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - float minDepthClamp = {}; - float maxDepthClamp = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DepthClampRangeEXT; - }; -#endif - - // wrapper struct for struct VkDescriptorAddressInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorAddressInfoEXT.html - struct DescriptorAddressInfoEXT - { - using NativeType = VkDescriptorAddressInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorAddressInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorAddressInfoEXT( DeviceAddress address_ = {}, - DeviceSize range_ = {}, - Format format_ = Format::eUndefined, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , address{ address_ } - , range{ range_ } - , format{ format_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorAddressInfoEXT( DescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorAddressInfoEXT( VkDescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorAddressInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorAddressInfoEXT & operator=( DescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorAddressInfoEXT & operator=( VkDescriptorAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT - { - address = address_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT - { - address = address_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setRange( DeviceSize range_ ) & VULKAN_HPP_NOEXCEPT - { - range = range_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setRange( DeviceSize range_ ) && VULKAN_HPP_NOEXCEPT - { - range = range_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorAddressInfoEXT && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorAddressInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorAddressInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorAddressInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorAddressInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, address, range, format ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorAddressInfoEXT const & ) const = default; -#else - bool operator==( DescriptorAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( address == rhs.address ) && ( range == rhs.range ) && ( format == rhs.format ); -# endif - } - - bool operator!=( DescriptorAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorAddressInfoEXT; - void * pNext = {}; - DeviceAddress address = {}; - DeviceSize range = {}; - Format format = Format::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorAddressInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorAddressInfoEXT; - }; - - // wrapper struct for struct VkDescriptorBufferBindingInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBufferBindingInfoEXT.html - struct DescriptorBufferBindingInfoEXT - { - using NativeType = VkDescriptorBufferBindingInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorBufferBindingInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - DescriptorBufferBindingInfoEXT( DeviceAddress address_ = {}, BufferUsageFlags usage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , address{ address_ } - , usage{ usage_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorBufferBindingInfoEXT( DescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorBufferBindingInfoEXT( VkDescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorBufferBindingInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorBufferBindingInfoEXT & operator=( DescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorBufferBindingInfoEXT & operator=( VkDescriptorBufferBindingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT & setAddress( DeviceAddress address_ ) & VULKAN_HPP_NOEXCEPT - { - address = address_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT && setAddress( DeviceAddress address_ ) && VULKAN_HPP_NOEXCEPT - { - address = address_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT & setUsage( BufferUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingInfoEXT && setUsage( BufferUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorBufferBindingInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorBufferBindingInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorBufferBindingInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorBufferBindingInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, address, usage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorBufferBindingInfoEXT const & ) const = default; -#else - bool operator==( DescriptorBufferBindingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( address == rhs.address ) && ( usage == rhs.usage ); -# endif - } - - bool operator!=( DescriptorBufferBindingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorBufferBindingInfoEXT; - const void * pNext = {}; - DeviceAddress address = {}; - BufferUsageFlags usage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorBufferBindingInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorBufferBindingInfoEXT; - }; - - // wrapper struct for struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.html - struct DescriptorBufferBindingPushDescriptorBufferHandleEXT - { - using NativeType = VkDescriptorBufferBindingPushDescriptorBufferHandleEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorBufferBindingPushDescriptorBufferHandleEXT( Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , buffer{ buffer_ } - { - } - - VULKAN_HPP_CONSTEXPR - DescriptorBufferBindingPushDescriptorBufferHandleEXT( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorBufferBindingPushDescriptorBufferHandleEXT( VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorBufferBindingPushDescriptorBufferHandleEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorBufferBindingPushDescriptorBufferHandleEXT & - operator=( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorBufferBindingPushDescriptorBufferHandleEXT & operator=( VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferBindingPushDescriptorBufferHandleEXT && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorBufferBindingPushDescriptorBufferHandleEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, buffer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & ) const = default; -#else - bool operator==( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); -# endif - } - - bool operator!=( DescriptorBufferBindingPushDescriptorBufferHandleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT; - const void * pNext = {}; - Buffer buffer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorBufferBindingPushDescriptorBufferHandleEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorBufferBindingPushDescriptorBufferHandleEXT; - }; - - // wrapper struct for struct VkDescriptorBufferInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorBufferInfo.html - struct DescriptorBufferInfo - { - using NativeType = VkDescriptorBufferInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( Buffer buffer_ = {}, DeviceSize offset_ = {}, DeviceSize range_ = {} ) VULKAN_HPP_NOEXCEPT - : buffer{ buffer_ } - , offset{ offset_ } - , range{ range_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorBufferInfo( DescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorBufferInfo( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorBufferInfo( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorBufferInfo & operator=( DescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorBufferInfo & operator=( VkDescriptorBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo & setRange( DeviceSize range_ ) & VULKAN_HPP_NOEXCEPT - { - range = range_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorBufferInfo && setRange( DeviceSize range_ ) && VULKAN_HPP_NOEXCEPT - { - range = range_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorBufferInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorBufferInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorBufferInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorBufferInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( buffer, offset, range ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorBufferInfo const & ) const = default; -#else - bool operator==( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && ( range == rhs.range ); -# endif - } - - bool operator!=( DescriptorBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Buffer buffer = {}; - DeviceSize offset = {}; - DeviceSize range = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorBufferInfo; - }; -#endif - - // wrapper struct for struct VkDescriptorImageInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorImageInfo.html - struct DescriptorImageInfo - { - using NativeType = VkDescriptorImageInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - DescriptorImageInfo( Sampler sampler_ = {}, ImageView imageView_ = {}, ImageLayout imageLayout_ = ImageLayout::eUndefined ) VULKAN_HPP_NOEXCEPT - : sampler{ sampler_ } - , imageView{ imageView_ } - , imageLayout{ imageLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorImageInfo( DescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorImageInfo( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT : DescriptorImageInfo( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorImageInfo & operator=( DescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorImageInfo & operator=( VkDescriptorImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo & setSampler( Sampler sampler_ ) & VULKAN_HPP_NOEXCEPT - { - sampler = sampler_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo && setSampler( Sampler sampler_ ) && VULKAN_HPP_NOEXCEPT - { - sampler = sampler_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo & setImageLayout( ImageLayout imageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - imageLayout = imageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorImageInfo && setImageLayout( ImageLayout imageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - imageLayout = imageLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorImageInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorImageInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorImageInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorImageInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sampler, imageView, imageLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorImageInfo const & ) const = default; -#else - bool operator==( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sampler == rhs.sampler ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout ); -# endif - } - - bool operator!=( DescriptorImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Sampler sampler = {}; - ImageView imageView = {}; - ImageLayout imageLayout = ImageLayout::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorImageInfo; - }; -#endif - - union DescriptorDataEXT - { - using NativeType = VkDescriptorDataEXT; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( const Sampler * pSampler_ = {} ) : pSampler( pSampler_ ) {} - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( const DescriptorImageInfo * pDescriptorImageInfo_ ) : pCombinedImageSampler( pDescriptorImageInfo_ ) {} - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( const DescriptorAddressInfoEXT * pDescriptorAddressInfoEXT_ ) : pUniformTexelBuffer( pDescriptorAddressInfoEXT_ ) - { - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT( DeviceAddress accelerationStructure_ ) : accelerationStructure( accelerationStructure_ ) {} -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPSampler( const Sampler * pSampler_ ) & VULKAN_HPP_NOEXCEPT - { - pSampler = pSampler_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPSampler( const Sampler * pSampler_ ) && VULKAN_HPP_NOEXCEPT - { - pSampler = pSampler_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPCombinedImageSampler( const DescriptorImageInfo * pCombinedImageSampler_ ) & VULKAN_HPP_NOEXCEPT - { - pCombinedImageSampler = pCombinedImageSampler_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPCombinedImageSampler( const DescriptorImageInfo * pCombinedImageSampler_ ) && VULKAN_HPP_NOEXCEPT - { - pCombinedImageSampler = pCombinedImageSampler_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPInputAttachmentImage( const DescriptorImageInfo * pInputAttachmentImage_ ) & VULKAN_HPP_NOEXCEPT - { - pInputAttachmentImage = pInputAttachmentImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPInputAttachmentImage( const DescriptorImageInfo * pInputAttachmentImage_ ) && VULKAN_HPP_NOEXCEPT - { - pInputAttachmentImage = pInputAttachmentImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPSampledImage( const DescriptorImageInfo * pSampledImage_ ) & VULKAN_HPP_NOEXCEPT - { - pSampledImage = pSampledImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPSampledImage( const DescriptorImageInfo * pSampledImage_ ) && VULKAN_HPP_NOEXCEPT - { - pSampledImage = pSampledImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPStorageImage( const DescriptorImageInfo * pStorageImage_ ) & VULKAN_HPP_NOEXCEPT - { - pStorageImage = pStorageImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPStorageImage( const DescriptorImageInfo * pStorageImage_ ) && VULKAN_HPP_NOEXCEPT - { - pStorageImage = pStorageImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPUniformTexelBuffer( const DescriptorAddressInfoEXT * pUniformTexelBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - pUniformTexelBuffer = pUniformTexelBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPUniformTexelBuffer( const DescriptorAddressInfoEXT * pUniformTexelBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - pUniformTexelBuffer = pUniformTexelBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPStorageTexelBuffer( const DescriptorAddressInfoEXT * pStorageTexelBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - pStorageTexelBuffer = pStorageTexelBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPStorageTexelBuffer( const DescriptorAddressInfoEXT * pStorageTexelBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - pStorageTexelBuffer = pStorageTexelBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPUniformBuffer( const DescriptorAddressInfoEXT * pUniformBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - pUniformBuffer = pUniformBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPUniformBuffer( const DescriptorAddressInfoEXT * pUniformBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - pUniformBuffer = pUniformBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setPStorageBuffer( const DescriptorAddressInfoEXT * pStorageBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - pStorageBuffer = pStorageBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setPStorageBuffer( const DescriptorAddressInfoEXT * pStorageBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - pStorageBuffer = pStorageBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT & setAccelerationStructure( DeviceAddress accelerationStructure_ ) & VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorDataEXT && setAccelerationStructure( DeviceAddress accelerationStructure_ ) && VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorDataEXT const &() const - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorDataEXT &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - const Sampler * pSampler; - const DescriptorImageInfo * pCombinedImageSampler; - const DescriptorImageInfo * pInputAttachmentImage; - const DescriptorImageInfo * pSampledImage; - const DescriptorImageInfo * pStorageImage; - const DescriptorAddressInfoEXT * pUniformTexelBuffer; - const DescriptorAddressInfoEXT * pStorageTexelBuffer; - const DescriptorAddressInfoEXT * pUniformBuffer; - const DescriptorAddressInfoEXT * pStorageBuffer; - DeviceAddress accelerationStructure; -#else - const VkSampler * pSampler; - const VkDescriptorImageInfo * pCombinedImageSampler; - const VkDescriptorImageInfo * pInputAttachmentImage; - const VkDescriptorImageInfo * pSampledImage; - const VkDescriptorImageInfo * pStorageImage; - const VkDescriptorAddressInfoEXT * pUniformTexelBuffer; - const VkDescriptorAddressInfoEXT * pStorageTexelBuffer; - const VkDescriptorAddressInfoEXT * pUniformBuffer; - const VkDescriptorAddressInfoEXT * pStorageBuffer; - VkDeviceAddress accelerationStructure; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorDataEXT; - }; -#endif - - // wrapper struct for struct VkDescriptorGetInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorGetInfoEXT.html - struct DescriptorGetInfoEXT - { - using NativeType = VkDescriptorGetInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorGetInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - DescriptorGetInfoEXT( DescriptorType type_ = DescriptorType::eSampler, DescriptorDataEXT data_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , data{ data_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT( DescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorGetInfoEXT( VkDescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorGetInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorGetInfoEXT & operator=( DescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorGetInfoEXT & operator=( VkDescriptorGetInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT & setType( DescriptorType type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT && setType( DescriptorType type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT & setData( DescriptorDataEXT const & data_ ) & VULKAN_HPP_NOEXCEPT - { - data = data_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorGetInfoEXT && setData( DescriptorDataEXT const & data_ ) && VULKAN_HPP_NOEXCEPT - { - data = data_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorGetInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorGetInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorGetInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorGetInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, type, data ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorGetInfoEXT; - const void * pNext = {}; - DescriptorType type = DescriptorType::eSampler; - DescriptorDataEXT data = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorGetInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorGetInfoEXT; - }; - - // wrapper struct for struct VkDescriptorGetTensorInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorGetTensorInfoARM.html - struct DescriptorGetTensorInfoARM - { - using NativeType = VkDescriptorGetTensorInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorGetTensorInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorGetTensorInfoARM( TensorViewARM tensorView_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensorView{ tensorView_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorGetTensorInfoARM( DescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorGetTensorInfoARM( VkDescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorGetTensorInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorGetTensorInfoARM & operator=( DescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorGetTensorInfoARM & operator=( VkDescriptorGetTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM & setTensorView( TensorViewARM tensorView_ ) & VULKAN_HPP_NOEXCEPT - { - tensorView = tensorView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorGetTensorInfoARM && setTensorView( TensorViewARM tensorView_ ) && VULKAN_HPP_NOEXCEPT - { - tensorView = tensorView_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorGetTensorInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorGetTensorInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorGetTensorInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorGetTensorInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tensorView ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorGetTensorInfoARM const & ) const = default; -#else - bool operator==( DescriptorGetTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorView == rhs.tensorView ); -# endif - } - - bool operator!=( DescriptorGetTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorGetTensorInfoARM; - const void * pNext = {}; - TensorViewARM tensorView = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorGetTensorInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorGetTensorInfoARM; - }; - - // wrapper struct for struct VkSamplerCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCreateInfo.html - struct SamplerCreateInfo - { - using NativeType = VkSamplerCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SamplerCreateInfo( SamplerCreateFlags flags_ = {}, - Filter magFilter_ = Filter::eNearest, - Filter minFilter_ = Filter::eNearest, - SamplerMipmapMode mipmapMode_ = SamplerMipmapMode::eNearest, - SamplerAddressMode addressModeU_ = SamplerAddressMode::eRepeat, - SamplerAddressMode addressModeV_ = SamplerAddressMode::eRepeat, - SamplerAddressMode addressModeW_ = SamplerAddressMode::eRepeat, - float mipLodBias_ = {}, - Bool32 anisotropyEnable_ = {}, - float maxAnisotropy_ = {}, - Bool32 compareEnable_ = {}, - CompareOp compareOp_ = CompareOp::eNever, - float minLod_ = {}, - float maxLod_ = {}, - BorderColor borderColor_ = BorderColor::eFloatTransparentBlack, - Bool32 unnormalizedCoordinates_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , magFilter{ magFilter_ } - , minFilter{ minFilter_ } - , mipmapMode{ mipmapMode_ } - , addressModeU{ addressModeU_ } - , addressModeV{ addressModeV_ } - , addressModeW{ addressModeW_ } - , mipLodBias{ mipLodBias_ } - , anisotropyEnable{ anisotropyEnable_ } - , maxAnisotropy{ maxAnisotropy_ } - , compareEnable{ compareEnable_ } - , compareOp{ compareOp_ } - , minLod{ minLod_ } - , maxLod{ maxLod_ } - , borderColor{ borderColor_ } - , unnormalizedCoordinates{ unnormalizedCoordinates_ } - { - } - - VULKAN_HPP_CONSTEXPR SamplerCreateInfo( SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerCreateInfo( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SamplerCreateInfo( *reinterpret_cast( &rhs ) ) {} - - SamplerCreateInfo & operator=( SamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerCreateInfo & operator=( VkSamplerCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setFlags( SamplerCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setFlags( SamplerCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMagFilter( Filter magFilter_ ) & VULKAN_HPP_NOEXCEPT - { - magFilter = magFilter_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMagFilter( Filter magFilter_ ) && VULKAN_HPP_NOEXCEPT - { - magFilter = magFilter_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMinFilter( Filter minFilter_ ) & VULKAN_HPP_NOEXCEPT - { - minFilter = minFilter_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMinFilter( Filter minFilter_ ) && VULKAN_HPP_NOEXCEPT - { - minFilter = minFilter_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMipmapMode( SamplerMipmapMode mipmapMode_ ) & VULKAN_HPP_NOEXCEPT - { - mipmapMode = mipmapMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMipmapMode( SamplerMipmapMode mipmapMode_ ) && VULKAN_HPP_NOEXCEPT - { - mipmapMode = mipmapMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAddressModeU( SamplerAddressMode addressModeU_ ) & VULKAN_HPP_NOEXCEPT - { - addressModeU = addressModeU_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAddressModeU( SamplerAddressMode addressModeU_ ) && VULKAN_HPP_NOEXCEPT - { - addressModeU = addressModeU_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAddressModeV( SamplerAddressMode addressModeV_ ) & VULKAN_HPP_NOEXCEPT - { - addressModeV = addressModeV_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAddressModeV( SamplerAddressMode addressModeV_ ) && VULKAN_HPP_NOEXCEPT - { - addressModeV = addressModeV_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAddressModeW( SamplerAddressMode addressModeW_ ) & VULKAN_HPP_NOEXCEPT - { - addressModeW = addressModeW_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAddressModeW( SamplerAddressMode addressModeW_ ) && VULKAN_HPP_NOEXCEPT - { - addressModeW = addressModeW_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMipLodBias( float mipLodBias_ ) & VULKAN_HPP_NOEXCEPT - { - mipLodBias = mipLodBias_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMipLodBias( float mipLodBias_ ) && VULKAN_HPP_NOEXCEPT - { - mipLodBias = mipLodBias_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setAnisotropyEnable( Bool32 anisotropyEnable_ ) & VULKAN_HPP_NOEXCEPT - { - anisotropyEnable = anisotropyEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setAnisotropyEnable( Bool32 anisotropyEnable_ ) && VULKAN_HPP_NOEXCEPT - { - anisotropyEnable = anisotropyEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMaxAnisotropy( float maxAnisotropy_ ) & VULKAN_HPP_NOEXCEPT - { - maxAnisotropy = maxAnisotropy_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMaxAnisotropy( float maxAnisotropy_ ) && VULKAN_HPP_NOEXCEPT - { - maxAnisotropy = maxAnisotropy_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setCompareEnable( Bool32 compareEnable_ ) & VULKAN_HPP_NOEXCEPT - { - compareEnable = compareEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setCompareEnable( Bool32 compareEnable_ ) && VULKAN_HPP_NOEXCEPT - { - compareEnable = compareEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setCompareOp( CompareOp compareOp_ ) & VULKAN_HPP_NOEXCEPT - { - compareOp = compareOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setCompareOp( CompareOp compareOp_ ) && VULKAN_HPP_NOEXCEPT - { - compareOp = compareOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMinLod( float minLod_ ) & VULKAN_HPP_NOEXCEPT - { - minLod = minLod_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMinLod( float minLod_ ) && VULKAN_HPP_NOEXCEPT - { - minLod = minLod_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setMaxLod( float maxLod_ ) & VULKAN_HPP_NOEXCEPT - { - maxLod = maxLod_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setMaxLod( float maxLod_ ) && VULKAN_HPP_NOEXCEPT - { - maxLod = maxLod_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setBorderColor( BorderColor borderColor_ ) & VULKAN_HPP_NOEXCEPT - { - borderColor = borderColor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setBorderColor( BorderColor borderColor_ ) && VULKAN_HPP_NOEXCEPT - { - borderColor = borderColor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo & setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ ) & VULKAN_HPP_NOEXCEPT - { - unnormalizedCoordinates = unnormalizedCoordinates_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCreateInfo && setUnnormalizedCoordinates( Bool32 unnormalizedCoordinates_ ) && VULKAN_HPP_NOEXCEPT - { - unnormalizedCoordinates = unnormalizedCoordinates_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSamplerCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - magFilter, - minFilter, - mipmapMode, - addressModeU, - addressModeV, - addressModeW, - mipLodBias, - anisotropyEnable, - maxAnisotropy, - compareEnable, - compareOp, - minLod, - maxLod, - borderColor, - unnormalizedCoordinates ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SamplerCreateInfo const & ) const = default; -#else - bool operator==( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( magFilter == rhs.magFilter ) && ( minFilter == rhs.minFilter ) && - ( mipmapMode == rhs.mipmapMode ) && ( addressModeU == rhs.addressModeU ) && ( addressModeV == rhs.addressModeV ) && - ( addressModeW == rhs.addressModeW ) && ( mipLodBias == rhs.mipLodBias ) && ( anisotropyEnable == rhs.anisotropyEnable ) && - ( maxAnisotropy == rhs.maxAnisotropy ) && ( compareEnable == rhs.compareEnable ) && ( compareOp == rhs.compareOp ) && ( minLod == rhs.minLod ) && - ( maxLod == rhs.maxLod ) && ( borderColor == rhs.borderColor ) && ( unnormalizedCoordinates == rhs.unnormalizedCoordinates ); -# endif - } - - bool operator!=( SamplerCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerCreateInfo; - const void * pNext = {}; - SamplerCreateFlags flags = {}; - Filter magFilter = Filter::eNearest; - Filter minFilter = Filter::eNearest; - SamplerMipmapMode mipmapMode = SamplerMipmapMode::eNearest; - SamplerAddressMode addressModeU = SamplerAddressMode::eRepeat; - SamplerAddressMode addressModeV = SamplerAddressMode::eRepeat; - SamplerAddressMode addressModeW = SamplerAddressMode::eRepeat; - float mipLodBias = {}; - Bool32 anisotropyEnable = {}; - float maxAnisotropy = {}; - Bool32 compareEnable = {}; - CompareOp compareOp = CompareOp::eNever; - float minLod = {}; - float maxLod = {}; - BorderColor borderColor = BorderColor::eFloatTransparentBlack; - Bool32 unnormalizedCoordinates = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerCreateInfo; - }; - - // wrapper struct for struct VkDescriptorMappingSourceConstantOffsetEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceConstantOffsetEXT.html - struct DescriptorMappingSourceConstantOffsetEXT - { - using NativeType = VkDescriptorMappingSourceConstantOffsetEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceConstantOffsetEXT( uint32_t heapOffset_ = {}, - uint32_t heapArrayStride_ = {}, - const SamplerCreateInfo * pEmbeddedSampler_ = {}, - uint32_t samplerHeapOffset_ = {}, - uint32_t samplerHeapArrayStride_ = {} ) VULKAN_HPP_NOEXCEPT - : heapOffset{ heapOffset_ } - , heapArrayStride{ heapArrayStride_ } - , pEmbeddedSampler{ pEmbeddedSampler_ } - , samplerHeapOffset{ samplerHeapOffset_ } - , samplerHeapArrayStride{ samplerHeapArrayStride_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceConstantOffsetEXT( DescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorMappingSourceConstantOffsetEXT( VkDescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorMappingSourceConstantOffsetEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorMappingSourceConstantOffsetEXT & operator=( DescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorMappingSourceConstantOffsetEXT & operator=( VkDescriptorMappingSourceConstantOffsetEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT - { - heapArrayStride = heapArrayStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT - { - heapArrayStride = heapArrayStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) & VULKAN_HPP_NOEXCEPT - { - pEmbeddedSampler = pEmbeddedSampler_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) && - VULKAN_HPP_NOEXCEPT - { - pEmbeddedSampler = pEmbeddedSampler_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapOffset = samplerHeapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapOffset = samplerHeapOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapArrayStride = samplerHeapArrayStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceConstantOffsetEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapArrayStride = samplerHeapArrayStride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorMappingSourceConstantOffsetEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceConstantOffsetEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceConstantOffsetEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceConstantOffsetEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( heapOffset, heapArrayStride, pEmbeddedSampler, samplerHeapOffset, samplerHeapArrayStride ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorMappingSourceConstantOffsetEXT const & ) const = default; -#else - bool operator==( DescriptorMappingSourceConstantOffsetEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( heapOffset == rhs.heapOffset ) && ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) && - ( samplerHeapOffset == rhs.samplerHeapOffset ) && ( samplerHeapArrayStride == rhs.samplerHeapArrayStride ); -# endif - } - - bool operator!=( DescriptorMappingSourceConstantOffsetEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t heapOffset = {}; - uint32_t heapArrayStride = {}; - const SamplerCreateInfo * pEmbeddedSampler = {}; - uint32_t samplerHeapOffset = {}; - uint32_t samplerHeapArrayStride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorMappingSourceConstantOffsetEXT; - }; -#endif - - // wrapper struct for struct VkDescriptorMappingSourcePushIndexEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourcePushIndexEXT.html - struct DescriptorMappingSourcePushIndexEXT - { - using NativeType = VkDescriptorMappingSourcePushIndexEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorMappingSourcePushIndexEXT( uint32_t heapOffset_ = {}, - uint32_t pushOffset_ = {}, - uint32_t heapIndexStride_ = {}, - uint32_t heapArrayStride_ = {}, - const SamplerCreateInfo * pEmbeddedSampler_ = {}, - Bool32 useCombinedImageSamplerIndex_ = {}, - uint32_t samplerHeapOffset_ = {}, - uint32_t samplerPushOffset_ = {}, - uint32_t samplerHeapIndexStride_ = {}, - uint32_t samplerHeapArrayStride_ = {} ) VULKAN_HPP_NOEXCEPT - : heapOffset{ heapOffset_ } - , pushOffset{ pushOffset_ } - , heapIndexStride{ heapIndexStride_ } - , heapArrayStride{ heapArrayStride_ } - , pEmbeddedSampler{ pEmbeddedSampler_ } - , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ } - , samplerHeapOffset{ samplerHeapOffset_ } - , samplerPushOffset{ samplerPushOffset_ } - , samplerHeapIndexStride{ samplerHeapIndexStride_ } - , samplerHeapArrayStride{ samplerHeapArrayStride_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorMappingSourcePushIndexEXT( DescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorMappingSourcePushIndexEXT( VkDescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorMappingSourcePushIndexEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorMappingSourcePushIndexEXT & operator=( DescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorMappingSourcePushIndexEXT & operator=( VkDescriptorMappingSourcePushIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT - { - pushOffset = pushOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT - { - pushOffset = pushOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT - { - heapIndexStride = heapIndexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT - { - heapIndexStride = heapIndexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT - { - heapArrayStride = heapArrayStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT - { - heapArrayStride = heapArrayStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) & VULKAN_HPP_NOEXCEPT - { - pEmbeddedSampler = pEmbeddedSampler_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) && VULKAN_HPP_NOEXCEPT - { - pEmbeddedSampler = pEmbeddedSampler_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) & VULKAN_HPP_NOEXCEPT - { - useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapOffset = samplerHeapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapOffset = samplerHeapOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerPushOffset( uint32_t samplerPushOffset_ ) & VULKAN_HPP_NOEXCEPT - { - samplerPushOffset = samplerPushOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerPushOffset( uint32_t samplerPushOffset_ ) && VULKAN_HPP_NOEXCEPT - { - samplerPushOffset = samplerPushOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapIndexStride = samplerHeapIndexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapIndexStride = samplerHeapIndexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapArrayStride = samplerHeapArrayStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourcePushIndexEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapArrayStride = samplerHeapArrayStride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorMappingSourcePushIndexEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourcePushIndexEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourcePushIndexEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourcePushIndexEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( heapOffset, - pushOffset, - heapIndexStride, - heapArrayStride, - pEmbeddedSampler, - useCombinedImageSamplerIndex, - samplerHeapOffset, - samplerPushOffset, - samplerHeapIndexStride, - samplerHeapArrayStride ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorMappingSourcePushIndexEXT const & ) const = default; -#else - bool operator==( DescriptorMappingSourcePushIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset ) && ( heapIndexStride == rhs.heapIndexStride ) && - ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) && - ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) && - ( samplerPushOffset == rhs.samplerPushOffset ) && ( samplerHeapIndexStride == rhs.samplerHeapIndexStride ) && - ( samplerHeapArrayStride == rhs.samplerHeapArrayStride ); -# endif - } - - bool operator!=( DescriptorMappingSourcePushIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t heapOffset = {}; - uint32_t pushOffset = {}; - uint32_t heapIndexStride = {}; - uint32_t heapArrayStride = {}; - const SamplerCreateInfo * pEmbeddedSampler = {}; - Bool32 useCombinedImageSamplerIndex = {}; - uint32_t samplerHeapOffset = {}; - uint32_t samplerPushOffset = {}; - uint32_t samplerHeapIndexStride = {}; - uint32_t samplerHeapArrayStride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorMappingSourcePushIndexEXT; - }; -#endif - - // wrapper struct for struct VkDescriptorMappingSourceIndirectIndexEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceIndirectIndexEXT.html - struct DescriptorMappingSourceIndirectIndexEXT - { - using NativeType = VkDescriptorMappingSourceIndirectIndexEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexEXT( uint32_t heapOffset_ = {}, - uint32_t pushOffset_ = {}, - uint32_t addressOffset_ = {}, - uint32_t heapIndexStride_ = {}, - uint32_t heapArrayStride_ = {}, - const SamplerCreateInfo * pEmbeddedSampler_ = {}, - Bool32 useCombinedImageSamplerIndex_ = {}, - uint32_t samplerHeapOffset_ = {}, - uint32_t samplerPushOffset_ = {}, - uint32_t samplerAddressOffset_ = {}, - uint32_t samplerHeapIndexStride_ = {}, - uint32_t samplerHeapArrayStride_ = {} ) VULKAN_HPP_NOEXCEPT - : heapOffset{ heapOffset_ } - , pushOffset{ pushOffset_ } - , addressOffset{ addressOffset_ } - , heapIndexStride{ heapIndexStride_ } - , heapArrayStride{ heapArrayStride_ } - , pEmbeddedSampler{ pEmbeddedSampler_ } - , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ } - , samplerHeapOffset{ samplerHeapOffset_ } - , samplerPushOffset{ samplerPushOffset_ } - , samplerAddressOffset{ samplerAddressOffset_ } - , samplerHeapIndexStride{ samplerHeapIndexStride_ } - , samplerHeapArrayStride{ samplerHeapArrayStride_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexEXT( DescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorMappingSourceIndirectIndexEXT( VkDescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorMappingSourceIndirectIndexEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorMappingSourceIndirectIndexEXT & operator=( DescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorMappingSourceIndirectIndexEXT & operator=( VkDescriptorMappingSourceIndirectIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT - { - pushOffset = pushOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT - { - pushOffset = pushOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setAddressOffset( uint32_t addressOffset_ ) & VULKAN_HPP_NOEXCEPT - { - addressOffset = addressOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setAddressOffset( uint32_t addressOffset_ ) && VULKAN_HPP_NOEXCEPT - { - addressOffset = addressOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT - { - heapIndexStride = heapIndexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT - { - heapIndexStride = heapIndexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT - { - heapArrayStride = heapArrayStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT - { - heapArrayStride = heapArrayStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) & VULKAN_HPP_NOEXCEPT - { - pEmbeddedSampler = pEmbeddedSampler_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) && VULKAN_HPP_NOEXCEPT - { - pEmbeddedSampler = pEmbeddedSampler_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) & - VULKAN_HPP_NOEXCEPT - { - useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapOffset = samplerHeapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapOffset = samplerHeapOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerPushOffset( uint32_t samplerPushOffset_ ) & VULKAN_HPP_NOEXCEPT - { - samplerPushOffset = samplerPushOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerPushOffset( uint32_t samplerPushOffset_ ) && VULKAN_HPP_NOEXCEPT - { - samplerPushOffset = samplerPushOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) & VULKAN_HPP_NOEXCEPT - { - samplerAddressOffset = samplerAddressOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) && VULKAN_HPP_NOEXCEPT - { - samplerAddressOffset = samplerAddressOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapIndexStride = samplerHeapIndexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapIndexStride = samplerHeapIndexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapArrayStride = samplerHeapArrayStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapArrayStride = samplerHeapArrayStride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorMappingSourceIndirectIndexEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceIndirectIndexEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceIndirectIndexEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceIndirectIndexEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( heapOffset, - pushOffset, - addressOffset, - heapIndexStride, - heapArrayStride, - pEmbeddedSampler, - useCombinedImageSamplerIndex, - samplerHeapOffset, - samplerPushOffset, - samplerAddressOffset, - samplerHeapIndexStride, - samplerHeapArrayStride ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorMappingSourceIndirectIndexEXT const & ) const = default; -#else - bool operator==( DescriptorMappingSourceIndirectIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset ) && ( addressOffset == rhs.addressOffset ) && - ( heapIndexStride == rhs.heapIndexStride ) && ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) && - ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) && - ( samplerPushOffset == rhs.samplerPushOffset ) && ( samplerAddressOffset == rhs.samplerAddressOffset ) && - ( samplerHeapIndexStride == rhs.samplerHeapIndexStride ) && ( samplerHeapArrayStride == rhs.samplerHeapArrayStride ); -# endif - } - - bool operator!=( DescriptorMappingSourceIndirectIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t heapOffset = {}; - uint32_t pushOffset = {}; - uint32_t addressOffset = {}; - uint32_t heapIndexStride = {}; - uint32_t heapArrayStride = {}; - const SamplerCreateInfo * pEmbeddedSampler = {}; - Bool32 useCombinedImageSamplerIndex = {}; - uint32_t samplerHeapOffset = {}; - uint32_t samplerPushOffset = {}; - uint32_t samplerAddressOffset = {}; - uint32_t samplerHeapIndexStride = {}; - uint32_t samplerHeapArrayStride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorMappingSourceIndirectIndexEXT; - }; -#endif - - // wrapper struct for struct VkDescriptorMappingSourceIndirectIndexArrayEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceIndirectIndexArrayEXT.html - struct DescriptorMappingSourceIndirectIndexArrayEXT - { - using NativeType = VkDescriptorMappingSourceIndirectIndexArrayEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexArrayEXT( uint32_t heapOffset_ = {}, - uint32_t pushOffset_ = {}, - uint32_t addressOffset_ = {}, - uint32_t heapIndexStride_ = {}, - const SamplerCreateInfo * pEmbeddedSampler_ = {}, - Bool32 useCombinedImageSamplerIndex_ = {}, - uint32_t samplerHeapOffset_ = {}, - uint32_t samplerPushOffset_ = {}, - uint32_t samplerAddressOffset_ = {}, - uint32_t samplerHeapIndexStride_ = {} ) VULKAN_HPP_NOEXCEPT - : heapOffset{ heapOffset_ } - , pushOffset{ pushOffset_ } - , addressOffset{ addressOffset_ } - , heapIndexStride{ heapIndexStride_ } - , pEmbeddedSampler{ pEmbeddedSampler_ } - , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ } - , samplerHeapOffset{ samplerHeapOffset_ } - , samplerPushOffset{ samplerPushOffset_ } - , samplerAddressOffset{ samplerAddressOffset_ } - , samplerHeapIndexStride{ samplerHeapIndexStride_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectIndexArrayEXT( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorMappingSourceIndirectIndexArrayEXT( VkDescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorMappingSourceIndirectIndexArrayEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorMappingSourceIndirectIndexArrayEXT & operator=( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorMappingSourceIndirectIndexArrayEXT & operator=( VkDescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT - { - pushOffset = pushOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT - { - pushOffset = pushOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setAddressOffset( uint32_t addressOffset_ ) & VULKAN_HPP_NOEXCEPT - { - addressOffset = addressOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setAddressOffset( uint32_t addressOffset_ ) && VULKAN_HPP_NOEXCEPT - { - addressOffset = addressOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT - { - heapIndexStride = heapIndexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT - { - heapIndexStride = heapIndexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) & - VULKAN_HPP_NOEXCEPT - { - pEmbeddedSampler = pEmbeddedSampler_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) && - VULKAN_HPP_NOEXCEPT - { - pEmbeddedSampler = pEmbeddedSampler_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) & - VULKAN_HPP_NOEXCEPT - { - useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapOffset = samplerHeapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapOffset = samplerHeapOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerPushOffset( uint32_t samplerPushOffset_ ) & VULKAN_HPP_NOEXCEPT - { - samplerPushOffset = samplerPushOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerPushOffset( uint32_t samplerPushOffset_ ) && VULKAN_HPP_NOEXCEPT - { - samplerPushOffset = samplerPushOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) & VULKAN_HPP_NOEXCEPT - { - samplerAddressOffset = samplerAddressOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerAddressOffset( uint32_t samplerAddressOffset_ ) && VULKAN_HPP_NOEXCEPT - { - samplerAddressOffset = samplerAddressOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapIndexStride = samplerHeapIndexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectIndexArrayEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapIndexStride = samplerHeapIndexStride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorMappingSourceIndirectIndexArrayEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceIndirectIndexArrayEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceIndirectIndexArrayEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceIndirectIndexArrayEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( heapOffset, - pushOffset, - addressOffset, - heapIndexStride, - pEmbeddedSampler, - useCombinedImageSamplerIndex, - samplerHeapOffset, - samplerPushOffset, - samplerAddressOffset, - samplerHeapIndexStride ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorMappingSourceIndirectIndexArrayEXT const & ) const = default; -#else - bool operator==( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset ) && ( addressOffset == rhs.addressOffset ) && - ( heapIndexStride == rhs.heapIndexStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) && - ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) && - ( samplerPushOffset == rhs.samplerPushOffset ) && ( samplerAddressOffset == rhs.samplerAddressOffset ) && - ( samplerHeapIndexStride == rhs.samplerHeapIndexStride ); -# endif - } - - bool operator!=( DescriptorMappingSourceIndirectIndexArrayEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t heapOffset = {}; - uint32_t pushOffset = {}; - uint32_t addressOffset = {}; - uint32_t heapIndexStride = {}; - const SamplerCreateInfo * pEmbeddedSampler = {}; - Bool32 useCombinedImageSamplerIndex = {}; - uint32_t samplerHeapOffset = {}; - uint32_t samplerPushOffset = {}; - uint32_t samplerAddressOffset = {}; - uint32_t samplerHeapIndexStride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorMappingSourceIndirectIndexArrayEXT; - }; -#endif - - // wrapper struct for struct VkDescriptorMappingSourceHeapDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceHeapDataEXT.html - struct DescriptorMappingSourceHeapDataEXT - { - using NativeType = VkDescriptorMappingSourceHeapDataEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceHeapDataEXT( uint32_t heapOffset_ = {}, uint32_t pushOffset_ = {} ) VULKAN_HPP_NOEXCEPT - : heapOffset{ heapOffset_ } - , pushOffset{ pushOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceHeapDataEXT( DescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorMappingSourceHeapDataEXT( VkDescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorMappingSourceHeapDataEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorMappingSourceHeapDataEXT & operator=( DescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorMappingSourceHeapDataEXT & operator=( VkDescriptorMappingSourceHeapDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT - { - pushOffset = pushOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceHeapDataEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT - { - pushOffset = pushOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorMappingSourceHeapDataEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceHeapDataEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceHeapDataEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceHeapDataEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( heapOffset, pushOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorMappingSourceHeapDataEXT const & ) const = default; -#else - bool operator==( DescriptorMappingSourceHeapDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( heapOffset == rhs.heapOffset ) && ( pushOffset == rhs.pushOffset ); -# endif - } - - bool operator!=( DescriptorMappingSourceHeapDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t heapOffset = {}; - uint32_t pushOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorMappingSourceHeapDataEXT; - }; -#endif - - // wrapper struct for struct VkDescriptorMappingSourceIndirectAddressEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceIndirectAddressEXT.html - struct DescriptorMappingSourceIndirectAddressEXT - { - using NativeType = VkDescriptorMappingSourceIndirectAddressEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectAddressEXT( uint32_t pushOffset_ = {}, uint32_t addressOffset_ = {} ) VULKAN_HPP_NOEXCEPT - : pushOffset{ pushOffset_ } - , addressOffset{ addressOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceIndirectAddressEXT( DescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorMappingSourceIndirectAddressEXT( VkDescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorMappingSourceIndirectAddressEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorMappingSourceIndirectAddressEXT & operator=( DescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorMappingSourceIndirectAddressEXT & operator=( VkDescriptorMappingSourceIndirectAddressEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT & setPushOffset( uint32_t pushOffset_ ) & VULKAN_HPP_NOEXCEPT - { - pushOffset = pushOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT && setPushOffset( uint32_t pushOffset_ ) && VULKAN_HPP_NOEXCEPT - { - pushOffset = pushOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT & setAddressOffset( uint32_t addressOffset_ ) & VULKAN_HPP_NOEXCEPT - { - addressOffset = addressOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceIndirectAddressEXT && setAddressOffset( uint32_t addressOffset_ ) && VULKAN_HPP_NOEXCEPT - { - addressOffset = addressOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorMappingSourceIndirectAddressEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceIndirectAddressEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceIndirectAddressEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceIndirectAddressEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( pushOffset, addressOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorMappingSourceIndirectAddressEXT const & ) const = default; -#else - bool operator==( DescriptorMappingSourceIndirectAddressEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( pushOffset == rhs.pushOffset ) && ( addressOffset == rhs.addressOffset ); -# endif - } - - bool operator!=( DescriptorMappingSourceIndirectAddressEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t pushOffset = {}; - uint32_t addressOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorMappingSourceIndirectAddressEXT; - }; -#endif - - // wrapper struct for struct VkDescriptorMappingSourceShaderRecordIndexEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorMappingSourceShaderRecordIndexEXT.html - struct DescriptorMappingSourceShaderRecordIndexEXT - { - using NativeType = VkDescriptorMappingSourceShaderRecordIndexEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceShaderRecordIndexEXT( uint32_t heapOffset_ = {}, - uint32_t shaderRecordOffset_ = {}, - uint32_t heapIndexStride_ = {}, - uint32_t heapArrayStride_ = {}, - const SamplerCreateInfo * pEmbeddedSampler_ = {}, - Bool32 useCombinedImageSamplerIndex_ = {}, - uint32_t samplerHeapOffset_ = {}, - uint32_t samplerShaderRecordOffset_ = {}, - uint32_t samplerHeapIndexStride_ = {}, - uint32_t samplerHeapArrayStride_ = {} ) VULKAN_HPP_NOEXCEPT - : heapOffset{ heapOffset_ } - , shaderRecordOffset{ shaderRecordOffset_ } - , heapIndexStride{ heapIndexStride_ } - , heapArrayStride{ heapArrayStride_ } - , pEmbeddedSampler{ pEmbeddedSampler_ } - , useCombinedImageSamplerIndex{ useCombinedImageSamplerIndex_ } - , samplerHeapOffset{ samplerHeapOffset_ } - , samplerShaderRecordOffset{ samplerShaderRecordOffset_ } - , samplerHeapIndexStride{ samplerHeapIndexStride_ } - , samplerHeapArrayStride{ samplerHeapArrayStride_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorMappingSourceShaderRecordIndexEXT( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorMappingSourceShaderRecordIndexEXT( VkDescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorMappingSourceShaderRecordIndexEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorMappingSourceShaderRecordIndexEXT & operator=( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorMappingSourceShaderRecordIndexEXT & operator=( VkDescriptorMappingSourceShaderRecordIndexEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setHeapOffset( uint32_t heapOffset_ ) & VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setHeapOffset( uint32_t heapOffset_ ) && VULKAN_HPP_NOEXCEPT - { - heapOffset = heapOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setShaderRecordOffset( uint32_t shaderRecordOffset_ ) & VULKAN_HPP_NOEXCEPT - { - shaderRecordOffset = shaderRecordOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setShaderRecordOffset( uint32_t shaderRecordOffset_ ) && VULKAN_HPP_NOEXCEPT - { - shaderRecordOffset = shaderRecordOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setHeapIndexStride( uint32_t heapIndexStride_ ) & VULKAN_HPP_NOEXCEPT - { - heapIndexStride = heapIndexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setHeapIndexStride( uint32_t heapIndexStride_ ) && VULKAN_HPP_NOEXCEPT - { - heapIndexStride = heapIndexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setHeapArrayStride( uint32_t heapArrayStride_ ) & VULKAN_HPP_NOEXCEPT - { - heapArrayStride = heapArrayStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setHeapArrayStride( uint32_t heapArrayStride_ ) && VULKAN_HPP_NOEXCEPT - { - heapArrayStride = heapArrayStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) & - VULKAN_HPP_NOEXCEPT - { - pEmbeddedSampler = pEmbeddedSampler_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setPEmbeddedSampler( const SamplerCreateInfo * pEmbeddedSampler_ ) && - VULKAN_HPP_NOEXCEPT - { - pEmbeddedSampler = pEmbeddedSampler_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) & - VULKAN_HPP_NOEXCEPT - { - useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setUseCombinedImageSamplerIndex( Bool32 useCombinedImageSamplerIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - useCombinedImageSamplerIndex = useCombinedImageSamplerIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapOffset = samplerHeapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerHeapOffset( uint32_t samplerHeapOffset_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapOffset = samplerHeapOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerShaderRecordOffset( uint32_t samplerShaderRecordOffset_ ) & - VULKAN_HPP_NOEXCEPT - { - samplerShaderRecordOffset = samplerShaderRecordOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerShaderRecordOffset( uint32_t samplerShaderRecordOffset_ ) && - VULKAN_HPP_NOEXCEPT - { - samplerShaderRecordOffset = samplerShaderRecordOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapIndexStride = samplerHeapIndexStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerHeapIndexStride( uint32_t samplerHeapIndexStride_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapIndexStride = samplerHeapIndexStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT & setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) & VULKAN_HPP_NOEXCEPT - { - samplerHeapArrayStride = samplerHeapArrayStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceShaderRecordIndexEXT && setSamplerHeapArrayStride( uint32_t samplerHeapArrayStride_ ) && VULKAN_HPP_NOEXCEPT - { - samplerHeapArrayStride = samplerHeapArrayStride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorMappingSourceShaderRecordIndexEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceShaderRecordIndexEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceShaderRecordIndexEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceShaderRecordIndexEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( heapOffset, - shaderRecordOffset, - heapIndexStride, - heapArrayStride, - pEmbeddedSampler, - useCombinedImageSamplerIndex, - samplerHeapOffset, - samplerShaderRecordOffset, - samplerHeapIndexStride, - samplerHeapArrayStride ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorMappingSourceShaderRecordIndexEXT const & ) const = default; -#else - bool operator==( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( heapOffset == rhs.heapOffset ) && ( shaderRecordOffset == rhs.shaderRecordOffset ) && ( heapIndexStride == rhs.heapIndexStride ) && - ( heapArrayStride == rhs.heapArrayStride ) && ( pEmbeddedSampler == rhs.pEmbeddedSampler ) && - ( useCombinedImageSamplerIndex == rhs.useCombinedImageSamplerIndex ) && ( samplerHeapOffset == rhs.samplerHeapOffset ) && - ( samplerShaderRecordOffset == rhs.samplerShaderRecordOffset ) && ( samplerHeapIndexStride == rhs.samplerHeapIndexStride ) && - ( samplerHeapArrayStride == rhs.samplerHeapArrayStride ); -# endif - } - - bool operator!=( DescriptorMappingSourceShaderRecordIndexEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t heapOffset = {}; - uint32_t shaderRecordOffset = {}; - uint32_t heapIndexStride = {}; - uint32_t heapArrayStride = {}; - const SamplerCreateInfo * pEmbeddedSampler = {}; - Bool32 useCombinedImageSamplerIndex = {}; - uint32_t samplerHeapOffset = {}; - uint32_t samplerShaderRecordOffset = {}; - uint32_t samplerHeapIndexStride = {}; - uint32_t samplerHeapArrayStride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorMappingSourceShaderRecordIndexEXT; - }; -#endif - - union DescriptorMappingSourceDataEXT - { - using NativeType = VkDescriptorMappingSourceDataEXT; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceConstantOffsetEXT constantOffset_ = {} ) : constantOffset( constantOffset_ ) - { - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourcePushIndexEXT pushIndex_ ) : pushIndex( pushIndex_ ) {} - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceIndirectIndexEXT indirectIndex_ ) : indirectIndex( indirectIndex_ ) {} - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray_ ) - : indirectIndexArray( indirectIndexArray_ ) - { - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceHeapDataEXT heapData_ ) : heapData( heapData_ ) {} - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( uint32_t uint32_t_ ) : pushDataOffset( uint32_t_ ) {} - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceIndirectAddressEXT indirectAddress_ ) : indirectAddress( indirectAddress_ ) - { - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT( DescriptorMappingSourceShaderRecordIndexEXT shaderRecordIndex_ ) - : shaderRecordIndex( shaderRecordIndex_ ) - { - } -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setConstantOffset( DescriptorMappingSourceConstantOffsetEXT const & constantOffset_ ) & - VULKAN_HPP_NOEXCEPT - { - constantOffset = constantOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setConstantOffset( DescriptorMappingSourceConstantOffsetEXT const & constantOffset_ ) && - VULKAN_HPP_NOEXCEPT - { - constantOffset = constantOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setPushIndex( DescriptorMappingSourcePushIndexEXT const & pushIndex_ ) & VULKAN_HPP_NOEXCEPT - { - pushIndex = pushIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setPushIndex( DescriptorMappingSourcePushIndexEXT const & pushIndex_ ) && VULKAN_HPP_NOEXCEPT - { - pushIndex = pushIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setIndirectIndex( DescriptorMappingSourceIndirectIndexEXT const & indirectIndex_ ) & - VULKAN_HPP_NOEXCEPT - { - indirectIndex = indirectIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setIndirectIndex( DescriptorMappingSourceIndirectIndexEXT const & indirectIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - indirectIndex = indirectIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setIndirectIndexArray( DescriptorMappingSourceIndirectIndexArrayEXT const & indirectIndexArray_ ) & - VULKAN_HPP_NOEXCEPT - { - indirectIndexArray = indirectIndexArray_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && - setIndirectIndexArray( DescriptorMappingSourceIndirectIndexArrayEXT const & indirectIndexArray_ ) && - VULKAN_HPP_NOEXCEPT - { - indirectIndexArray = indirectIndexArray_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setHeapData( DescriptorMappingSourceHeapDataEXT const & heapData_ ) & VULKAN_HPP_NOEXCEPT - { - heapData = heapData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setHeapData( DescriptorMappingSourceHeapDataEXT const & heapData_ ) && VULKAN_HPP_NOEXCEPT - { - heapData = heapData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setPushDataOffset( uint32_t pushDataOffset_ ) & VULKAN_HPP_NOEXCEPT - { - pushDataOffset = pushDataOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setPushDataOffset( uint32_t pushDataOffset_ ) && VULKAN_HPP_NOEXCEPT - { - pushDataOffset = pushDataOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setPushAddressOffset( uint32_t pushAddressOffset_ ) & VULKAN_HPP_NOEXCEPT - { - pushAddressOffset = pushAddressOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setPushAddressOffset( uint32_t pushAddressOffset_ ) && VULKAN_HPP_NOEXCEPT - { - pushAddressOffset = pushAddressOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setIndirectAddress( DescriptorMappingSourceIndirectAddressEXT const & indirectAddress_ ) & - VULKAN_HPP_NOEXCEPT - { - indirectAddress = indirectAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setIndirectAddress( DescriptorMappingSourceIndirectAddressEXT const & indirectAddress_ ) && - VULKAN_HPP_NOEXCEPT - { - indirectAddress = indirectAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setShaderRecordIndex( DescriptorMappingSourceShaderRecordIndexEXT const & shaderRecordIndex_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderRecordIndex = shaderRecordIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setShaderRecordIndex( DescriptorMappingSourceShaderRecordIndexEXT const & shaderRecordIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderRecordIndex = shaderRecordIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setShaderRecordDataOffset( uint32_t shaderRecordDataOffset_ ) & VULKAN_HPP_NOEXCEPT - { - shaderRecordDataOffset = shaderRecordDataOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setShaderRecordDataOffset( uint32_t shaderRecordDataOffset_ ) && VULKAN_HPP_NOEXCEPT - { - shaderRecordDataOffset = shaderRecordDataOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT & setShaderRecordAddressOffset( uint32_t shaderRecordAddressOffset_ ) & VULKAN_HPP_NOEXCEPT - { - shaderRecordAddressOffset = shaderRecordAddressOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorMappingSourceDataEXT && setShaderRecordAddressOffset( uint32_t shaderRecordAddressOffset_ ) && VULKAN_HPP_NOEXCEPT - { - shaderRecordAddressOffset = shaderRecordAddressOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorMappingSourceDataEXT const &() const - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorMappingSourceDataEXT &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - DescriptorMappingSourceConstantOffsetEXT constantOffset; - DescriptorMappingSourcePushIndexEXT pushIndex; - DescriptorMappingSourceIndirectIndexEXT indirectIndex; - DescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray; - DescriptorMappingSourceHeapDataEXT heapData; - uint32_t pushDataOffset; - uint32_t pushAddressOffset; - DescriptorMappingSourceIndirectAddressEXT indirectAddress; - DescriptorMappingSourceShaderRecordIndexEXT shaderRecordIndex; - uint32_t shaderRecordDataOffset; - uint32_t shaderRecordAddressOffset; -#else - VkDescriptorMappingSourceConstantOffsetEXT constantOffset; - VkDescriptorMappingSourcePushIndexEXT pushIndex; - VkDescriptorMappingSourceIndirectIndexEXT indirectIndex; - VkDescriptorMappingSourceIndirectIndexArrayEXT indirectIndexArray; - VkDescriptorMappingSourceHeapDataEXT heapData; - uint32_t pushDataOffset; - uint32_t pushAddressOffset; - VkDescriptorMappingSourceIndirectAddressEXT indirectAddress; - VkDescriptorMappingSourceShaderRecordIndexEXT shaderRecordIndex; - uint32_t shaderRecordDataOffset; - uint32_t shaderRecordAddressOffset; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorMappingSourceDataEXT; - }; -#endif - - // wrapper struct for struct VkDescriptorPoolSize, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolSize.html - struct DescriptorPoolSize - { - using NativeType = VkDescriptorPoolSize; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorPoolSize( DescriptorType type_ = DescriptorType::eSampler, uint32_t descriptorCount_ = {} ) VULKAN_HPP_NOEXCEPT - : type{ type_ } - , descriptorCount{ descriptorCount_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorPoolSize( DescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorPoolSize( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT : DescriptorPoolSize( *reinterpret_cast( &rhs ) ) {} - - DescriptorPoolSize & operator=( DescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorPoolSize & operator=( VkDescriptorPoolSize const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize & setType( DescriptorType type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize && setType( DescriptorType type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorCount = descriptorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolSize && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorCount = descriptorCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorPoolSize const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorPoolSize &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorPoolSize const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorPoolSize *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( type, descriptorCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorPoolSize const & ) const = default; -#else - bool operator==( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( type == rhs.type ) && ( descriptorCount == rhs.descriptorCount ); -# endif - } - - bool operator!=( DescriptorPoolSize const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DescriptorType type = DescriptorType::eSampler; - uint32_t descriptorCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorPoolSize; - }; -#endif - - // wrapper struct for struct VkDescriptorPoolCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolCreateInfo.html - struct DescriptorPoolCreateInfo - { - using NativeType = VkDescriptorPoolCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorPoolCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_ = {}, - uint32_t maxSets_ = {}, - uint32_t poolSizeCount_ = {}, - const DescriptorPoolSize * pPoolSizes_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , maxSets{ maxSets_ } - , poolSizeCount{ poolSizeCount_ } - , pPoolSizes{ pPoolSizes_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorPoolCreateInfo( DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorPoolCreateInfo( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorPoolCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorPoolCreateInfo( DescriptorPoolCreateFlags flags_, - uint32_t maxSets_, - ArrayProxyNoTemporaries const & poolSizes_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), flags( flags_ ), maxSets( maxSets_ ), poolSizeCount( static_cast( poolSizes_.size() ) ), pPoolSizes( poolSizes_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DescriptorPoolCreateInfo & operator=( DescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorPoolCreateInfo & operator=( VkDescriptorPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setFlags( DescriptorPoolCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setFlags( DescriptorPoolCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setMaxSets( uint32_t maxSets_ ) & VULKAN_HPP_NOEXCEPT - { - maxSets = maxSets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setMaxSets( uint32_t maxSets_ ) && VULKAN_HPP_NOEXCEPT - { - maxSets = maxSets_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setPoolSizeCount( uint32_t poolSizeCount_ ) & VULKAN_HPP_NOEXCEPT - { - poolSizeCount = poolSizeCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setPoolSizeCount( uint32_t poolSizeCount_ ) && VULKAN_HPP_NOEXCEPT - { - poolSizeCount = poolSizeCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo & setPPoolSizes( const DescriptorPoolSize * pPoolSizes_ ) & VULKAN_HPP_NOEXCEPT - { - pPoolSizes = pPoolSizes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolCreateInfo && setPPoolSizes( const DescriptorPoolSize * pPoolSizes_ ) && VULKAN_HPP_NOEXCEPT - { - pPoolSizes = pPoolSizes_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorPoolCreateInfo & setPoolSizes( ArrayProxyNoTemporaries const & poolSizes_ ) VULKAN_HPP_NOEXCEPT - { - poolSizeCount = static_cast( poolSizes_.size() ); - pPoolSizes = poolSizes_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorPoolCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorPoolCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorPoolCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, maxSets, poolSizeCount, pPoolSizes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorPoolCreateInfo const & ) const = default; -#else - bool operator==( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( maxSets == rhs.maxSets ) && - ( poolSizeCount == rhs.poolSizeCount ) && ( pPoolSizes == rhs.pPoolSizes ); -# endif - } - - bool operator!=( DescriptorPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorPoolCreateInfo; - const void * pNext = {}; - DescriptorPoolCreateFlags flags = {}; - uint32_t maxSets = {}; - uint32_t poolSizeCount = {}; - const DescriptorPoolSize * pPoolSizes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorPoolCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorPoolCreateInfo; - }; - - // wrapper struct for struct VkDescriptorPoolInlineUniformBlockCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorPoolInlineUniformBlockCreateInfo.html - struct DescriptorPoolInlineUniformBlockCreateInfo - { - using NativeType = VkDescriptorPoolInlineUniformBlockCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfo( uint32_t maxInlineUniformBlockBindings_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxInlineUniformBlockBindings{ maxInlineUniformBlockBindings_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorPoolInlineUniformBlockCreateInfo( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorPoolInlineUniformBlockCreateInfo( VkDescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorPoolInlineUniformBlockCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorPoolInlineUniformBlockCreateInfo & operator=( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorPoolInlineUniformBlockCreateInfo & operator=( VkDescriptorPoolInlineUniformBlockCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo & setMaxInlineUniformBlockBindings( uint32_t maxInlineUniformBlockBindings_ ) & - VULKAN_HPP_NOEXCEPT - { - maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorPoolInlineUniformBlockCreateInfo && setMaxInlineUniformBlockBindings( uint32_t maxInlineUniformBlockBindings_ ) && - VULKAN_HPP_NOEXCEPT - { - maxInlineUniformBlockBindings = maxInlineUniformBlockBindings_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorPoolInlineUniformBlockCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorPoolInlineUniformBlockCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorPoolInlineUniformBlockCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorPoolInlineUniformBlockCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxInlineUniformBlockBindings ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorPoolInlineUniformBlockCreateInfo const & ) const = default; -#else - bool operator==( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInlineUniformBlockBindings == rhs.maxInlineUniformBlockBindings ); -# endif - } - - bool operator!=( DescriptorPoolInlineUniformBlockCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorPoolInlineUniformBlockCreateInfo; - const void * pNext = {}; - uint32_t maxInlineUniformBlockBindings = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorPoolInlineUniformBlockCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorPoolInlineUniformBlockCreateInfo; - }; - - using DescriptorPoolInlineUniformBlockCreateInfoEXT = DescriptorPoolInlineUniformBlockCreateInfo; - - // wrapper struct for struct VkDescriptorSetAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetAllocateInfo.html - struct DescriptorSetAllocateInfo - { - using NativeType = VkDescriptorSetAllocateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetAllocateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( DescriptorPool descriptorPool_ = {}, - uint32_t descriptorSetCount_ = {}, - const DescriptorSetLayout * pSetLayouts_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorPool{ descriptorPool_ } - , descriptorSetCount{ descriptorSetCount_ } - , pSetLayouts{ pSetLayouts_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorSetAllocateInfo( DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorSetAllocateInfo( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorSetAllocateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorSetAllocateInfo( DescriptorPool descriptorPool_, - ArrayProxyNoTemporaries const & setLayouts_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), descriptorPool( descriptorPool_ ), descriptorSetCount( static_cast( setLayouts_.size() ) ), pSetLayouts( setLayouts_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DescriptorSetAllocateInfo & operator=( DescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorSetAllocateInfo & operator=( VkDescriptorSetAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setDescriptorPool( DescriptorPool descriptorPool_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorPool = descriptorPool_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setDescriptorPool( DescriptorPool descriptorPool_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorPool = descriptorPool_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setDescriptorSetCount( uint32_t descriptorSetCount_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorSetCount = descriptorSetCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setDescriptorSetCount( uint32_t descriptorSetCount_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorSetCount = descriptorSetCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo & setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) & VULKAN_HPP_NOEXCEPT - { - pSetLayouts = pSetLayouts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAllocateInfo && setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) && VULKAN_HPP_NOEXCEPT - { - pSetLayouts = pSetLayouts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorSetAllocateInfo & setSetLayouts( ArrayProxyNoTemporaries const & setLayouts_ ) VULKAN_HPP_NOEXCEPT - { - descriptorSetCount = static_cast( setLayouts_.size() ); - pSetLayouts = setLayouts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorSetAllocateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetAllocateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetAllocateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorSetAllocateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorPool, descriptorSetCount, pSetLayouts ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorSetAllocateInfo const & ) const = default; -#else - bool operator==( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPool == rhs.descriptorPool ) && ( descriptorSetCount == rhs.descriptorSetCount ) && - ( pSetLayouts == rhs.pSetLayouts ); -# endif - } - - bool operator!=( DescriptorSetAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorSetAllocateInfo; - const void * pNext = {}; - DescriptorPool descriptorPool = {}; - uint32_t descriptorSetCount = {}; - const DescriptorSetLayout * pSetLayouts = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorSetAllocateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorSetAllocateInfo; - }; - - // wrapper struct for struct VkDescriptorSetAndBindingMappingEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetAndBindingMappingEXT.html - struct DescriptorSetAndBindingMappingEXT - { - using NativeType = VkDescriptorSetAndBindingMappingEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetAndBindingMappingEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT( uint32_t descriptorSet_ = {}, - uint32_t firstBinding_ = {}, - uint32_t bindingCount_ = {}, - SpirvResourceTypeFlagsEXT resourceMask_ = {}, - DescriptorMappingSourceEXT source_ = DescriptorMappingSourceEXT::eHeapWithConstantOffset, - DescriptorMappingSourceDataEXT sourceData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorSet{ descriptorSet_ } - , firstBinding{ firstBinding_ } - , bindingCount{ bindingCount_ } - , resourceMask{ resourceMask_ } - , source{ source_ } - , sourceData{ sourceData_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT( DescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorSetAndBindingMappingEXT( VkDescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorSetAndBindingMappingEXT( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorSetAndBindingMappingEXT & operator=( DescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorSetAndBindingMappingEXT & operator=( VkDescriptorSetAndBindingMappingEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setDescriptorSet( uint32_t descriptorSet_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorSet = descriptorSet_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setDescriptorSet( uint32_t descriptorSet_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorSet = descriptorSet_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setFirstBinding( uint32_t firstBinding_ ) & VULKAN_HPP_NOEXCEPT - { - firstBinding = firstBinding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setFirstBinding( uint32_t firstBinding_ ) && VULKAN_HPP_NOEXCEPT - { - firstBinding = firstBinding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setBindingCount( uint32_t bindingCount_ ) & VULKAN_HPP_NOEXCEPT - { - bindingCount = bindingCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setBindingCount( uint32_t bindingCount_ ) && VULKAN_HPP_NOEXCEPT - { - bindingCount = bindingCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setResourceMask( SpirvResourceTypeFlagsEXT resourceMask_ ) & VULKAN_HPP_NOEXCEPT - { - resourceMask = resourceMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setResourceMask( SpirvResourceTypeFlagsEXT resourceMask_ ) && VULKAN_HPP_NOEXCEPT - { - resourceMask = resourceMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setSource( DescriptorMappingSourceEXT source_ ) & VULKAN_HPP_NOEXCEPT - { - source = source_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setSource( DescriptorMappingSourceEXT source_ ) && VULKAN_HPP_NOEXCEPT - { - source = source_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT & setSourceData( DescriptorMappingSourceDataEXT const & sourceData_ ) & VULKAN_HPP_NOEXCEPT - { - sourceData = sourceData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetAndBindingMappingEXT && setSourceData( DescriptorMappingSourceDataEXT const & sourceData_ ) && VULKAN_HPP_NOEXCEPT - { - sourceData = sourceData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorSetAndBindingMappingEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetAndBindingMappingEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetAndBindingMappingEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorSetAndBindingMappingEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorSet, firstBinding, bindingCount, resourceMask, source, sourceData ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorSetAndBindingMappingEXT; - const void * pNext = {}; - uint32_t descriptorSet = {}; - uint32_t firstBinding = {}; - uint32_t bindingCount = {}; - SpirvResourceTypeFlagsEXT resourceMask = {}; - DescriptorMappingSourceEXT source = DescriptorMappingSourceEXT::eHeapWithConstantOffset; - DescriptorMappingSourceDataEXT sourceData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorSetAndBindingMappingEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorSetAndBindingMappingEXT; - }; - - // wrapper struct for struct VkDescriptorSetBindingReferenceVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetBindingReferenceVALVE.html - struct DescriptorSetBindingReferenceVALVE - { - using NativeType = VkDescriptorSetBindingReferenceVALVE; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetBindingReferenceVALVE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorSetBindingReferenceVALVE( DescriptorSetLayout descriptorSetLayout_ = {}, - uint32_t binding_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorSetLayout{ descriptorSetLayout_ } - , binding{ binding_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorSetBindingReferenceVALVE( DescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorSetBindingReferenceVALVE( VkDescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorSetBindingReferenceVALVE( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorSetBindingReferenceVALVE & operator=( DescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorSetBindingReferenceVALVE & operator=( VkDescriptorSetBindingReferenceVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE & setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorSetLayout = descriptorSetLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE && setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorSetLayout = descriptorSetLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetBindingReferenceVALVE && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorSetBindingReferenceVALVE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetBindingReferenceVALVE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetBindingReferenceVALVE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorSetBindingReferenceVALVE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorSetLayout, binding ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorSetBindingReferenceVALVE const & ) const = default; -#else - bool operator==( DescriptorSetBindingReferenceVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetLayout == rhs.descriptorSetLayout ) && ( binding == rhs.binding ); -# endif - } - - bool operator!=( DescriptorSetBindingReferenceVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorSetBindingReferenceVALVE; - const void * pNext = {}; - DescriptorSetLayout descriptorSetLayout = {}; - uint32_t binding = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorSetBindingReferenceVALVE; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorSetBindingReferenceVALVE; - }; - - // wrapper struct for struct VkDescriptorSetLayoutBinding, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutBinding.html - struct DescriptorSetLayoutBinding - { - using NativeType = VkDescriptorSetLayoutBinding; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( uint32_t binding_ = {}, - DescriptorType descriptorType_ = DescriptorType::eSampler, - uint32_t descriptorCount_ = {}, - ShaderStageFlags stageFlags_ = {}, - const Sampler * pImmutableSamplers_ = {} ) VULKAN_HPP_NOEXCEPT - : binding{ binding_ } - , descriptorType{ descriptorType_ } - , descriptorCount{ descriptorCount_ } - , stageFlags{ stageFlags_ } - , pImmutableSamplers{ pImmutableSamplers_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBinding( DescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorSetLayoutBinding( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorSetLayoutBinding( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorSetLayoutBinding( uint32_t binding_, - DescriptorType descriptorType_, - ShaderStageFlags stageFlags_, - ArrayProxyNoTemporaries const & immutableSamplers_ ) - : binding( binding_ ) - , descriptorType( descriptorType_ ) - , descriptorCount( static_cast( immutableSamplers_.size() ) ) - , stageFlags( stageFlags_ ) - , pImmutableSamplers( immutableSamplers_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DescriptorSetLayoutBinding & operator=( DescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorSetLayoutBinding & operator=( VkDescriptorSetLayoutBinding const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setDescriptorType( DescriptorType descriptorType_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorType = descriptorType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setDescriptorType( DescriptorType descriptorType_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorType = descriptorType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorCount = descriptorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorCount = descriptorCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding & setPImmutableSamplers( const Sampler * pImmutableSamplers_ ) & VULKAN_HPP_NOEXCEPT - { - pImmutableSamplers = pImmutableSamplers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBinding && setPImmutableSamplers( const Sampler * pImmutableSamplers_ ) && VULKAN_HPP_NOEXCEPT - { - pImmutableSamplers = pImmutableSamplers_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorSetLayoutBinding & setImmutableSamplers( ArrayProxyNoTemporaries const & immutableSamplers_ ) VULKAN_HPP_NOEXCEPT - { - descriptorCount = static_cast( immutableSamplers_.size() ); - pImmutableSamplers = immutableSamplers_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorSetLayoutBinding const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutBinding &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutBinding const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutBinding *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( binding, descriptorType, descriptorCount, stageFlags, pImmutableSamplers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorSetLayoutBinding const & ) const = default; -#else - bool operator==( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( binding == rhs.binding ) && ( descriptorType == rhs.descriptorType ) && ( descriptorCount == rhs.descriptorCount ) && - ( stageFlags == rhs.stageFlags ) && ( pImmutableSamplers == rhs.pImmutableSamplers ); -# endif - } - - bool operator!=( DescriptorSetLayoutBinding const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t binding = {}; - DescriptorType descriptorType = DescriptorType::eSampler; - uint32_t descriptorCount = {}; - ShaderStageFlags stageFlags = {}; - const Sampler * pImmutableSamplers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorSetLayoutBinding; - }; -#endif - - // wrapper struct for struct VkDescriptorSetLayoutBindingFlagsCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutBindingFlagsCreateInfo.html - struct DescriptorSetLayoutBindingFlagsCreateInfo - { - using NativeType = VkDescriptorSetLayoutBindingFlagsCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfo( uint32_t bindingCount_ = {}, - const DescriptorBindingFlags * pBindingFlags_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , bindingCount{ bindingCount_ } - , pBindingFlags{ pBindingFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutBindingFlagsCreateInfo( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorSetLayoutBindingFlagsCreateInfo( VkDescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorSetLayoutBindingFlagsCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorSetLayoutBindingFlagsCreateInfo( ArrayProxyNoTemporaries const & bindingFlags_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), bindingCount( static_cast( bindingFlags_.size() ) ), pBindingFlags( bindingFlags_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DescriptorSetLayoutBindingFlagsCreateInfo & operator=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorSetLayoutBindingFlagsCreateInfo & operator=( VkDescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo & setBindingCount( uint32_t bindingCount_ ) & VULKAN_HPP_NOEXCEPT - { - bindingCount = bindingCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo && setBindingCount( uint32_t bindingCount_ ) && VULKAN_HPP_NOEXCEPT - { - bindingCount = bindingCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo & setPBindingFlags( const DescriptorBindingFlags * pBindingFlags_ ) & VULKAN_HPP_NOEXCEPT - { - pBindingFlags = pBindingFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutBindingFlagsCreateInfo && setPBindingFlags( const DescriptorBindingFlags * pBindingFlags_ ) && - VULKAN_HPP_NOEXCEPT - { - pBindingFlags = pBindingFlags_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorSetLayoutBindingFlagsCreateInfo & - setBindingFlags( ArrayProxyNoTemporaries const & bindingFlags_ ) VULKAN_HPP_NOEXCEPT - { - bindingCount = static_cast( bindingFlags_.size() ); - pBindingFlags = bindingFlags_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorSetLayoutBindingFlagsCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutBindingFlagsCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutBindingFlagsCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutBindingFlagsCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, bindingCount, pBindingFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorSetLayoutBindingFlagsCreateInfo const & ) const = default; -#else - bool operator==( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bindingCount == rhs.bindingCount ) && ( pBindingFlags == rhs.pBindingFlags ); -# endif - } - - bool operator!=( DescriptorSetLayoutBindingFlagsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo; - const void * pNext = {}; - uint32_t bindingCount = {}; - const DescriptorBindingFlags * pBindingFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorSetLayoutBindingFlagsCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorSetLayoutBindingFlagsCreateInfo; - }; - - using DescriptorSetLayoutBindingFlagsCreateInfoEXT = DescriptorSetLayoutBindingFlagsCreateInfo; - - // wrapper struct for struct VkDescriptorSetLayoutCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutCreateInfo.html - struct DescriptorSetLayoutCreateInfo - { - using NativeType = VkDescriptorSetLayoutCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_ = {}, - uint32_t bindingCount_ = {}, - const DescriptorSetLayoutBinding * pBindings_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , bindingCount{ bindingCount_ } - , pBindings{ pBindings_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorSetLayoutCreateInfo( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorSetLayoutCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorSetLayoutCreateInfo( DescriptorSetLayoutCreateFlags flags_, - ArrayProxyNoTemporaries const & bindings_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), flags( flags_ ), bindingCount( static_cast( bindings_.size() ) ), pBindings( bindings_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DescriptorSetLayoutCreateInfo & operator=( DescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorSetLayoutCreateInfo & operator=( VkDescriptorSetLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setFlags( DescriptorSetLayoutCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setFlags( DescriptorSetLayoutCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setBindingCount( uint32_t bindingCount_ ) & VULKAN_HPP_NOEXCEPT - { - bindingCount = bindingCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setBindingCount( uint32_t bindingCount_ ) && VULKAN_HPP_NOEXCEPT - { - bindingCount = bindingCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo & setPBindings( const DescriptorSetLayoutBinding * pBindings_ ) & VULKAN_HPP_NOEXCEPT - { - pBindings = pBindings_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutCreateInfo && setPBindings( const DescriptorSetLayoutBinding * pBindings_ ) && VULKAN_HPP_NOEXCEPT - { - pBindings = pBindings_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorSetLayoutCreateInfo & setBindings( ArrayProxyNoTemporaries const & bindings_ ) VULKAN_HPP_NOEXCEPT - { - bindingCount = static_cast( bindings_.size() ); - pBindings = bindings_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorSetLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, bindingCount, pBindings ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorSetLayoutCreateInfo const & ) const = default; -#else - bool operator==( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( bindingCount == rhs.bindingCount ) && - ( pBindings == rhs.pBindings ); -# endif - } - - bool operator!=( DescriptorSetLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorSetLayoutCreateInfo; - const void * pNext = {}; - DescriptorSetLayoutCreateFlags flags = {}; - uint32_t bindingCount = {}; - const DescriptorSetLayoutBinding * pBindings = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorSetLayoutCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorSetLayoutCreateInfo; - }; - - // wrapper struct for struct VkDescriptorSetLayoutHostMappingInfoVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutHostMappingInfoVALVE.html - struct DescriptorSetLayoutHostMappingInfoVALVE - { - using NativeType = VkDescriptorSetLayoutHostMappingInfoVALVE; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutHostMappingInfoVALVE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - DescriptorSetLayoutHostMappingInfoVALVE( size_t descriptorOffset_ = {}, uint32_t descriptorSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorOffset{ descriptorOffset_ } - , descriptorSize{ descriptorSize_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutHostMappingInfoVALVE( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorSetLayoutHostMappingInfoVALVE( VkDescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorSetLayoutHostMappingInfoVALVE( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorSetLayoutHostMappingInfoVALVE & operator=( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorSetLayoutHostMappingInfoVALVE & operator=( VkDescriptorSetLayoutHostMappingInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE & setDescriptorOffset( size_t descriptorOffset_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorOffset = descriptorOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE && setDescriptorOffset( size_t descriptorOffset_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorOffset = descriptorOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE & setDescriptorSize( uint32_t descriptorSize_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorSize = descriptorSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetLayoutHostMappingInfoVALVE && setDescriptorSize( uint32_t descriptorSize_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorSize = descriptorSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorSetLayoutHostMappingInfoVALVE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutHostMappingInfoVALVE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutHostMappingInfoVALVE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutHostMappingInfoVALVE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorOffset, descriptorSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorSetLayoutHostMappingInfoVALVE const & ) const = default; -#else - bool operator==( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorOffset == rhs.descriptorOffset ) && ( descriptorSize == rhs.descriptorSize ); -# endif - } - - bool operator!=( DescriptorSetLayoutHostMappingInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorSetLayoutHostMappingInfoVALVE; - void * pNext = {}; - size_t descriptorOffset = {}; - uint32_t descriptorSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorSetLayoutHostMappingInfoVALVE; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorSetLayoutHostMappingInfoVALVE; - }; - - // wrapper struct for struct VkDescriptorSetLayoutSupport, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetLayoutSupport.html - struct DescriptorSetLayoutSupport - { - using NativeType = VkDescriptorSetLayoutSupport; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetLayoutSupport; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( Bool32 supported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , supported{ supported_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorSetLayoutSupport( DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorSetLayoutSupport( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorSetLayoutSupport( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorSetLayoutSupport & operator=( DescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorSetLayoutSupport & operator=( VkDescriptorSetLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDescriptorSetLayoutSupport const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutSupport &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutSupport const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorSetLayoutSupport *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, supported ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorSetLayoutSupport const & ) const = default; -#else - bool operator==( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supported == rhs.supported ); -# endif - } - - bool operator!=( DescriptorSetLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorSetLayoutSupport; - void * pNext = {}; - Bool32 supported = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorSetLayoutSupport; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorSetLayoutSupport; - }; - - using DescriptorSetLayoutSupportKHR = DescriptorSetLayoutSupport; - - // wrapper struct for struct VkDescriptorSetVariableDescriptorCountAllocateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountAllocateInfo.html - struct DescriptorSetVariableDescriptorCountAllocateInfo - { - using NativeType = VkDescriptorSetVariableDescriptorCountAllocateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountAllocateInfo( uint32_t descriptorSetCount_ = {}, - const uint32_t * pDescriptorCounts_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorSetCount{ descriptorSetCount_ } - , pDescriptorCounts{ pDescriptorCounts_ } - { - } - - VULKAN_HPP_CONSTEXPR - DescriptorSetVariableDescriptorCountAllocateInfo( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorSetVariableDescriptorCountAllocateInfo( VkDescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorSetVariableDescriptorCountAllocateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorSetVariableDescriptorCountAllocateInfo( ArrayProxyNoTemporaries const & descriptorCounts_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), descriptorSetCount( static_cast( descriptorCounts_.size() ) ), pDescriptorCounts( descriptorCounts_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DescriptorSetVariableDescriptorCountAllocateInfo & operator=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorSetVariableDescriptorCountAllocateInfo & operator=( VkDescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo & setDescriptorSetCount( uint32_t descriptorSetCount_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorSetCount = descriptorSetCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo && setDescriptorSetCount( uint32_t descriptorSetCount_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorSetCount = descriptorSetCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo & setPDescriptorCounts( const uint32_t * pDescriptorCounts_ ) & VULKAN_HPP_NOEXCEPT - { - pDescriptorCounts = pDescriptorCounts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorSetVariableDescriptorCountAllocateInfo && setPDescriptorCounts( const uint32_t * pDescriptorCounts_ ) && - VULKAN_HPP_NOEXCEPT - { - pDescriptorCounts = pDescriptorCounts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorSetVariableDescriptorCountAllocateInfo & - setDescriptorCounts( ArrayProxyNoTemporaries const & descriptorCounts_ ) VULKAN_HPP_NOEXCEPT - { - descriptorSetCount = static_cast( descriptorCounts_.size() ); - pDescriptorCounts = descriptorCounts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorSetVariableDescriptorCountAllocateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetVariableDescriptorCountAllocateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetVariableDescriptorCountAllocateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorSetVariableDescriptorCountAllocateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorSetCount, pDescriptorCounts ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorSetVariableDescriptorCountAllocateInfo const & ) const = default; -#else - bool operator==( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetCount == rhs.descriptorSetCount ) && - ( pDescriptorCounts == rhs.pDescriptorCounts ); -# endif - } - - bool operator!=( DescriptorSetVariableDescriptorCountAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo; - const void * pNext = {}; - uint32_t descriptorSetCount = {}; - const uint32_t * pDescriptorCounts = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorSetVariableDescriptorCountAllocateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorSetVariableDescriptorCountAllocateInfo; - }; - - using DescriptorSetVariableDescriptorCountAllocateInfoEXT = DescriptorSetVariableDescriptorCountAllocateInfo; - - // wrapper struct for struct VkDescriptorSetVariableDescriptorCountLayoutSupport, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorSetVariableDescriptorCountLayoutSupport.html - struct DescriptorSetVariableDescriptorCountLayoutSupport - { - using NativeType = VkDescriptorSetVariableDescriptorCountLayoutSupport; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorSetVariableDescriptorCountLayoutSupport( uint32_t maxVariableDescriptorCount_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxVariableDescriptorCount{ maxVariableDescriptorCount_ } - { - } - - VULKAN_HPP_CONSTEXPR - DescriptorSetVariableDescriptorCountLayoutSupport( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorSetVariableDescriptorCountLayoutSupport( VkDescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorSetVariableDescriptorCountLayoutSupport( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorSetVariableDescriptorCountLayoutSupport & - operator=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorSetVariableDescriptorCountLayoutSupport & operator=( VkDescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDescriptorSetVariableDescriptorCountLayoutSupport const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetVariableDescriptorCountLayoutSupport &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorSetVariableDescriptorCountLayoutSupport const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorSetVariableDescriptorCountLayoutSupport *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxVariableDescriptorCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorSetVariableDescriptorCountLayoutSupport const & ) const = default; -#else - bool operator==( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVariableDescriptorCount == rhs.maxVariableDescriptorCount ); -# endif - } - - bool operator!=( DescriptorSetVariableDescriptorCountLayoutSupport const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport; - void * pNext = {}; - uint32_t maxVariableDescriptorCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorSetVariableDescriptorCountLayoutSupport; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorSetVariableDescriptorCountLayoutSupport; - }; - - using DescriptorSetVariableDescriptorCountLayoutSupportEXT = DescriptorSetVariableDescriptorCountLayoutSupport; - - // wrapper struct for struct VkDescriptorUpdateTemplateEntry, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateEntry.html - struct DescriptorUpdateTemplateEntry - { - using NativeType = VkDescriptorUpdateTemplateEntry; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( uint32_t dstBinding_ = {}, - uint32_t dstArrayElement_ = {}, - uint32_t descriptorCount_ = {}, - DescriptorType descriptorType_ = DescriptorType::eSampler, - size_t offset_ = {}, - size_t stride_ = {} ) VULKAN_HPP_NOEXCEPT - : dstBinding{ dstBinding_ } - , dstArrayElement{ dstArrayElement_ } - , descriptorCount{ descriptorCount_ } - , descriptorType{ descriptorType_ } - , offset{ offset_ } - , stride{ stride_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateEntry( DescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorUpdateTemplateEntry( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorUpdateTemplateEntry( *reinterpret_cast( &rhs ) ) - { - } - - DescriptorUpdateTemplateEntry & operator=( DescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorUpdateTemplateEntry & operator=( VkDescriptorUpdateTemplateEntry const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDstBinding( uint32_t dstBinding_ ) & VULKAN_HPP_NOEXCEPT - { - dstBinding = dstBinding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDstBinding( uint32_t dstBinding_ ) && VULKAN_HPP_NOEXCEPT - { - dstBinding = dstBinding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDstArrayElement( uint32_t dstArrayElement_ ) & VULKAN_HPP_NOEXCEPT - { - dstArrayElement = dstArrayElement_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDstArrayElement( uint32_t dstArrayElement_ ) && VULKAN_HPP_NOEXCEPT - { - dstArrayElement = dstArrayElement_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorCount = descriptorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorCount = descriptorCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setDescriptorType( DescriptorType descriptorType_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorType = descriptorType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setDescriptorType( DescriptorType descriptorType_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorType = descriptorType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setOffset( size_t offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setOffset( size_t offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry & setStride( size_t stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateEntry && setStride( size_t stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorUpdateTemplateEntry const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorUpdateTemplateEntry &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorUpdateTemplateEntry const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorUpdateTemplateEntry *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( dstBinding, dstArrayElement, descriptorCount, descriptorType, offset, stride ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorUpdateTemplateEntry const & ) const = default; -#else - bool operator==( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( dstBinding == rhs.dstBinding ) && ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount ) && - ( descriptorType == rhs.descriptorType ) && ( offset == rhs.offset ) && ( stride == rhs.stride ); -# endif - } - - bool operator!=( DescriptorUpdateTemplateEntry const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t dstBinding = {}; - uint32_t dstArrayElement = {}; - uint32_t descriptorCount = {}; - DescriptorType descriptorType = DescriptorType::eSampler; - size_t offset = {}; - size_t stride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorUpdateTemplateEntry; - }; -#endif - using DescriptorUpdateTemplateEntryKHR = DescriptorUpdateTemplateEntry; - - // wrapper struct for struct VkDescriptorUpdateTemplateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDescriptorUpdateTemplateCreateInfo.html - struct DescriptorUpdateTemplateCreateInfo - { - using NativeType = VkDescriptorUpdateTemplateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDescriptorUpdateTemplateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_ = {}, - uint32_t descriptorUpdateEntryCount_ = {}, - const DescriptorUpdateTemplateEntry * pDescriptorUpdateEntries_ = {}, - DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet, - DescriptorSetLayout descriptorSetLayout_ = {}, - PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, - PipelineLayout pipelineLayout_ = {}, - uint32_t set_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , descriptorUpdateEntryCount{ descriptorUpdateEntryCount_ } - , pDescriptorUpdateEntries{ pDescriptorUpdateEntries_ } - , templateType{ templateType_ } - , descriptorSetLayout{ descriptorSetLayout_ } - , pipelineBindPoint{ pipelineBindPoint_ } - , pipelineLayout{ pipelineLayout_ } - , set{ set_ } - { - } - - VULKAN_HPP_CONSTEXPR DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DescriptorUpdateTemplateCreateInfo( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DescriptorUpdateTemplateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorUpdateTemplateCreateInfo( DescriptorUpdateTemplateCreateFlags flags_, - ArrayProxyNoTemporaries const & descriptorUpdateEntries_, - DescriptorUpdateTemplateType templateType_ = DescriptorUpdateTemplateType::eDescriptorSet, - DescriptorSetLayout descriptorSetLayout_ = {}, - PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, - PipelineLayout pipelineLayout_ = {}, - uint32_t set_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , descriptorUpdateEntryCount( static_cast( descriptorUpdateEntries_.size() ) ) - , pDescriptorUpdateEntries( descriptorUpdateEntries_.data() ) - , templateType( templateType_ ) - , descriptorSetLayout( descriptorSetLayout_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , pipelineLayout( pipelineLayout_ ) - , set( set_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DescriptorUpdateTemplateCreateInfo & operator=( DescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DescriptorUpdateTemplateCreateInfo & operator=( VkDescriptorUpdateTemplateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setFlags( DescriptorUpdateTemplateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setFlags( DescriptorUpdateTemplateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorUpdateEntryCount = descriptorUpdateEntryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setDescriptorUpdateEntryCount( uint32_t descriptorUpdateEntryCount_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorUpdateEntryCount = descriptorUpdateEntryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & - setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry * pDescriptorUpdateEntries_ ) & - VULKAN_HPP_NOEXCEPT - { - pDescriptorUpdateEntries = pDescriptorUpdateEntries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && - setPDescriptorUpdateEntries( const DescriptorUpdateTemplateEntry * pDescriptorUpdateEntries_ ) && - VULKAN_HPP_NOEXCEPT - { - pDescriptorUpdateEntries = pDescriptorUpdateEntries_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DescriptorUpdateTemplateCreateInfo & - setDescriptorUpdateEntries( ArrayProxyNoTemporaries const & descriptorUpdateEntries_ ) VULKAN_HPP_NOEXCEPT - { - descriptorUpdateEntryCount = static_cast( descriptorUpdateEntries_.size() ); - pDescriptorUpdateEntries = descriptorUpdateEntries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setTemplateType( DescriptorUpdateTemplateType templateType_ ) & VULKAN_HPP_NOEXCEPT - { - templateType = templateType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setTemplateType( DescriptorUpdateTemplateType templateType_ ) && VULKAN_HPP_NOEXCEPT - { - templateType = templateType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorSetLayout = descriptorSetLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setDescriptorSetLayout( DescriptorSetLayout descriptorSetLayout_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorSetLayout = descriptorSetLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setPipelineLayout( PipelineLayout pipelineLayout_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineLayout = pipelineLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setPipelineLayout( PipelineLayout pipelineLayout_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineLayout = pipelineLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT - { - set = set_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DescriptorUpdateTemplateCreateInfo && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT - { - set = set_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDescriptorUpdateTemplateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorUpdateTemplateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDescriptorUpdateTemplateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDescriptorUpdateTemplateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, flags, descriptorUpdateEntryCount, pDescriptorUpdateEntries, templateType, descriptorSetLayout, pipelineBindPoint, pipelineLayout, set ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DescriptorUpdateTemplateCreateInfo const & ) const = default; -#else - bool operator==( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( descriptorUpdateEntryCount == rhs.descriptorUpdateEntryCount ) && - ( pDescriptorUpdateEntries == rhs.pDescriptorUpdateEntries ) && ( templateType == rhs.templateType ) && - ( descriptorSetLayout == rhs.descriptorSetLayout ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipelineLayout == rhs.pipelineLayout ) && - ( set == rhs.set ); -# endif - } - - bool operator!=( DescriptorUpdateTemplateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDescriptorUpdateTemplateCreateInfo; - const void * pNext = {}; - DescriptorUpdateTemplateCreateFlags flags = {}; - uint32_t descriptorUpdateEntryCount = {}; - const DescriptorUpdateTemplateEntry * pDescriptorUpdateEntries = {}; - DescriptorUpdateTemplateType templateType = DescriptorUpdateTemplateType::eDescriptorSet; - DescriptorSetLayout descriptorSetLayout = {}; - PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; - PipelineLayout pipelineLayout = {}; - uint32_t set = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DescriptorUpdateTemplateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DescriptorUpdateTemplateCreateInfo; - }; - - using DescriptorUpdateTemplateCreateInfoKHR = DescriptorUpdateTemplateCreateInfo; - - // wrapper struct for struct VkDeviceAddressBindingCallbackDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceAddressBindingCallbackDataEXT.html - struct DeviceAddressBindingCallbackDataEXT - { - using NativeType = VkDeviceAddressBindingCallbackDataEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceAddressBindingCallbackDataEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceAddressBindingCallbackDataEXT( DeviceAddressBindingFlagsEXT flags_ = {}, - DeviceAddress baseAddress_ = {}, - DeviceSize size_ = {}, - DeviceAddressBindingTypeEXT bindingType_ = DeviceAddressBindingTypeEXT::eBind, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , baseAddress{ baseAddress_ } - , size{ size_ } - , bindingType{ bindingType_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceAddressBindingCallbackDataEXT( DeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceAddressBindingCallbackDataEXT( VkDeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceAddressBindingCallbackDataEXT( *reinterpret_cast( &rhs ) ) - { - } - - DeviceAddressBindingCallbackDataEXT & operator=( DeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceAddressBindingCallbackDataEXT & operator=( VkDeviceAddressBindingCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setFlags( DeviceAddressBindingFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setFlags( DeviceAddressBindingFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setBaseAddress( DeviceAddress baseAddress_ ) & VULKAN_HPP_NOEXCEPT - { - baseAddress = baseAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setBaseAddress( DeviceAddress baseAddress_ ) && VULKAN_HPP_NOEXCEPT - { - baseAddress = baseAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT & setBindingType( DeviceAddressBindingTypeEXT bindingType_ ) & VULKAN_HPP_NOEXCEPT - { - bindingType = bindingType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceAddressBindingCallbackDataEXT && setBindingType( DeviceAddressBindingTypeEXT bindingType_ ) && VULKAN_HPP_NOEXCEPT - { - bindingType = bindingType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceAddressBindingCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceAddressBindingCallbackDataEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceAddressBindingCallbackDataEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceAddressBindingCallbackDataEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, baseAddress, size, bindingType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceAddressBindingCallbackDataEXT const & ) const = default; -#else - bool operator==( DeviceAddressBindingCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( baseAddress == rhs.baseAddress ) && ( size == rhs.size ) && - ( bindingType == rhs.bindingType ); -# endif - } - - bool operator!=( DeviceAddressBindingCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceAddressBindingCallbackDataEXT; - void * pNext = {}; - DeviceAddressBindingFlagsEXT flags = {}; - DeviceAddress baseAddress = {}; - DeviceSize size = {}; - DeviceAddressBindingTypeEXT bindingType = DeviceAddressBindingTypeEXT::eBind; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceAddressBindingCallbackDataEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceAddressBindingCallbackDataEXT; - }; - - // wrapper struct for struct VkDeviceBufferMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceBufferMemoryRequirements.html - struct DeviceBufferMemoryRequirements - { - using NativeType = VkDeviceBufferMemoryRequirements; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceBufferMemoryRequirements; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceBufferMemoryRequirements( const BufferCreateInfo * pCreateInfo_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pCreateInfo{ pCreateInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceBufferMemoryRequirements( DeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceBufferMemoryRequirements( VkDeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceBufferMemoryRequirements( *reinterpret_cast( &rhs ) ) - { - } - - DeviceBufferMemoryRequirements & operator=( DeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceBufferMemoryRequirements & operator=( VkDeviceBufferMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements & setPCreateInfo( const BufferCreateInfo * pCreateInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pCreateInfo = pCreateInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceBufferMemoryRequirements && setPCreateInfo( const BufferCreateInfo * pCreateInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pCreateInfo = pCreateInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceBufferMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceBufferMemoryRequirements &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceBufferMemoryRequirements const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceBufferMemoryRequirements *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pCreateInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceBufferMemoryRequirements const & ) const = default; -#else - bool operator==( DeviceBufferMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ); -# endif - } - - bool operator!=( DeviceBufferMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceBufferMemoryRequirements; - const void * pNext = {}; - const BufferCreateInfo * pCreateInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceBufferMemoryRequirements; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceBufferMemoryRequirements; - }; - - using DeviceBufferMemoryRequirementsKHR = DeviceBufferMemoryRequirements; - - // wrapper struct for struct VkDeviceQueueCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueCreateInfo.html - struct DeviceQueueCreateInfo - { - using NativeType = VkDeviceQueueCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_ = {}, - uint32_t queueFamilyIndex_ = {}, - uint32_t queueCount_ = {}, - const float * pQueuePriorities_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , queueFamilyIndex{ queueFamilyIndex_ } - , queueCount{ queueCount_ } - , pQueuePriorities{ pQueuePriorities_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceQueueCreateInfo( DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceQueueCreateInfo( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceQueueCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceQueueCreateInfo( DeviceQueueCreateFlags flags_, - uint32_t queueFamilyIndex_, - ArrayProxyNoTemporaries const & queuePriorities_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - , queueCount( static_cast( queuePriorities_.size() ) ) - , pQueuePriorities( queuePriorities_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DeviceQueueCreateInfo & operator=( DeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceQueueCreateInfo & operator=( VkDeviceQueueCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setFlags( DeviceQueueCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setFlags( DeviceQueueCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setQueueCount( uint32_t queueCount_ ) & VULKAN_HPP_NOEXCEPT - { - queueCount = queueCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setQueueCount( uint32_t queueCount_ ) && VULKAN_HPP_NOEXCEPT - { - queueCount = queueCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo & setPQueuePriorities( const float * pQueuePriorities_ ) & VULKAN_HPP_NOEXCEPT - { - pQueuePriorities = pQueuePriorities_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueCreateInfo && setPQueuePriorities( const float * pQueuePriorities_ ) && VULKAN_HPP_NOEXCEPT - { - pQueuePriorities = pQueuePriorities_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceQueueCreateInfo & setQueuePriorities( ArrayProxyNoTemporaries const & queuePriorities_ ) VULKAN_HPP_NOEXCEPT - { - queueCount = static_cast( queuePriorities_.size() ); - pQueuePriorities = queuePriorities_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceQueueCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceQueueCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceQueueCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceQueueCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, queueFamilyIndex, queueCount, pQueuePriorities ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceQueueCreateInfo const & ) const = default; -#else - bool operator==( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && - ( queueCount == rhs.queueCount ) && ( pQueuePriorities == rhs.pQueuePriorities ); -# endif - } - - bool operator!=( DeviceQueueCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceQueueCreateInfo; - const void * pNext = {}; - DeviceQueueCreateFlags flags = {}; - uint32_t queueFamilyIndex = {}; - uint32_t queueCount = {}; - const float * pQueuePriorities = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceQueueCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceQueueCreateInfo; - }; - - // wrapper struct for struct VkPhysicalDeviceFeatures, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFeatures.html - struct PhysicalDeviceFeatures - { - using NativeType = VkPhysicalDeviceFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures( Bool32 robustBufferAccess_ = {}, - Bool32 fullDrawIndexUint32_ = {}, - Bool32 imageCubeArray_ = {}, - Bool32 independentBlend_ = {}, - Bool32 geometryShader_ = {}, - Bool32 tessellationShader_ = {}, - Bool32 sampleRateShading_ = {}, - Bool32 dualSrcBlend_ = {}, - Bool32 logicOp_ = {}, - Bool32 multiDrawIndirect_ = {}, - Bool32 drawIndirectFirstInstance_ = {}, - Bool32 depthClamp_ = {}, - Bool32 depthBiasClamp_ = {}, - Bool32 fillModeNonSolid_ = {}, - Bool32 depthBounds_ = {}, - Bool32 wideLines_ = {}, - Bool32 largePoints_ = {}, - Bool32 alphaToOne_ = {}, - Bool32 multiViewport_ = {}, - Bool32 samplerAnisotropy_ = {}, - Bool32 textureCompressionETC2_ = {}, - Bool32 textureCompressionASTC_LDR_ = {}, - Bool32 textureCompressionBC_ = {}, - Bool32 occlusionQueryPrecise_ = {}, - Bool32 pipelineStatisticsQuery_ = {}, - Bool32 vertexPipelineStoresAndAtomics_ = {}, - Bool32 fragmentStoresAndAtomics_ = {}, - Bool32 shaderTessellationAndGeometryPointSize_ = {}, - Bool32 shaderImageGatherExtended_ = {}, - Bool32 shaderStorageImageExtendedFormats_ = {}, - Bool32 shaderStorageImageMultisample_ = {}, - Bool32 shaderStorageImageReadWithoutFormat_ = {}, - Bool32 shaderStorageImageWriteWithoutFormat_ = {}, - Bool32 shaderUniformBufferArrayDynamicIndexing_ = {}, - Bool32 shaderSampledImageArrayDynamicIndexing_ = {}, - Bool32 shaderStorageBufferArrayDynamicIndexing_ = {}, - Bool32 shaderStorageImageArrayDynamicIndexing_ = {}, - Bool32 shaderClipDistance_ = {}, - Bool32 shaderCullDistance_ = {}, - Bool32 shaderFloat64_ = {}, - Bool32 shaderInt64_ = {}, - Bool32 shaderInt16_ = {}, - Bool32 shaderResourceResidency_ = {}, - Bool32 shaderResourceMinLod_ = {}, - Bool32 sparseBinding_ = {}, - Bool32 sparseResidencyBuffer_ = {}, - Bool32 sparseResidencyImage2D_ = {}, - Bool32 sparseResidencyImage3D_ = {}, - Bool32 sparseResidency2Samples_ = {}, - Bool32 sparseResidency4Samples_ = {}, - Bool32 sparseResidency8Samples_ = {}, - Bool32 sparseResidency16Samples_ = {}, - Bool32 sparseResidencyAliased_ = {}, - Bool32 variableMultisampleRate_ = {}, - Bool32 inheritedQueries_ = {} ) VULKAN_HPP_NOEXCEPT - : robustBufferAccess{ robustBufferAccess_ } - , fullDrawIndexUint32{ fullDrawIndexUint32_ } - , imageCubeArray{ imageCubeArray_ } - , independentBlend{ independentBlend_ } - , geometryShader{ geometryShader_ } - , tessellationShader{ tessellationShader_ } - , sampleRateShading{ sampleRateShading_ } - , dualSrcBlend{ dualSrcBlend_ } - , logicOp{ logicOp_ } - , multiDrawIndirect{ multiDrawIndirect_ } - , drawIndirectFirstInstance{ drawIndirectFirstInstance_ } - , depthClamp{ depthClamp_ } - , depthBiasClamp{ depthBiasClamp_ } - , fillModeNonSolid{ fillModeNonSolid_ } - , depthBounds{ depthBounds_ } - , wideLines{ wideLines_ } - , largePoints{ largePoints_ } - , alphaToOne{ alphaToOne_ } - , multiViewport{ multiViewport_ } - , samplerAnisotropy{ samplerAnisotropy_ } - , textureCompressionETC2{ textureCompressionETC2_ } - , textureCompressionASTC_LDR{ textureCompressionASTC_LDR_ } - , textureCompressionBC{ textureCompressionBC_ } - , occlusionQueryPrecise{ occlusionQueryPrecise_ } - , pipelineStatisticsQuery{ pipelineStatisticsQuery_ } - , vertexPipelineStoresAndAtomics{ vertexPipelineStoresAndAtomics_ } - , fragmentStoresAndAtomics{ fragmentStoresAndAtomics_ } - , shaderTessellationAndGeometryPointSize{ shaderTessellationAndGeometryPointSize_ } - , shaderImageGatherExtended{ shaderImageGatherExtended_ } - , shaderStorageImageExtendedFormats{ shaderStorageImageExtendedFormats_ } - , shaderStorageImageMultisample{ shaderStorageImageMultisample_ } - , shaderStorageImageReadWithoutFormat{ shaderStorageImageReadWithoutFormat_ } - , shaderStorageImageWriteWithoutFormat{ shaderStorageImageWriteWithoutFormat_ } - , shaderUniformBufferArrayDynamicIndexing{ shaderUniformBufferArrayDynamicIndexing_ } - , shaderSampledImageArrayDynamicIndexing{ shaderSampledImageArrayDynamicIndexing_ } - , shaderStorageBufferArrayDynamicIndexing{ shaderStorageBufferArrayDynamicIndexing_ } - , shaderStorageImageArrayDynamicIndexing{ shaderStorageImageArrayDynamicIndexing_ } - , shaderClipDistance{ shaderClipDistance_ } - , shaderCullDistance{ shaderCullDistance_ } - , shaderFloat64{ shaderFloat64_ } - , shaderInt64{ shaderInt64_ } - , shaderInt16{ shaderInt16_ } - , shaderResourceResidency{ shaderResourceResidency_ } - , shaderResourceMinLod{ shaderResourceMinLod_ } - , sparseBinding{ sparseBinding_ } - , sparseResidencyBuffer{ sparseResidencyBuffer_ } - , sparseResidencyImage2D{ sparseResidencyImage2D_ } - , sparseResidencyImage3D{ sparseResidencyImage3D_ } - , sparseResidency2Samples{ sparseResidency2Samples_ } - , sparseResidency4Samples{ sparseResidency4Samples_ } - , sparseResidency8Samples{ sparseResidency8Samples_ } - , sparseResidency16Samples{ sparseResidency16Samples_ } - , sparseResidencyAliased{ sparseResidencyAliased_ } - , variableMultisampleRate{ variableMultisampleRate_ } - , inheritedQueries{ inheritedQueries_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures( PhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFeatures( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFeatures & operator=( PhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFeatures & operator=( VkPhysicalDeviceFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setRobustBufferAccess( Bool32 robustBufferAccess_ ) & VULKAN_HPP_NOEXCEPT - { - robustBufferAccess = robustBufferAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setRobustBufferAccess( Bool32 robustBufferAccess_ ) && VULKAN_HPP_NOEXCEPT - { - robustBufferAccess = robustBufferAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ ) & VULKAN_HPP_NOEXCEPT - { - fullDrawIndexUint32 = fullDrawIndexUint32_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setFullDrawIndexUint32( Bool32 fullDrawIndexUint32_ ) && VULKAN_HPP_NOEXCEPT - { - fullDrawIndexUint32 = fullDrawIndexUint32_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setImageCubeArray( Bool32 imageCubeArray_ ) & VULKAN_HPP_NOEXCEPT - { - imageCubeArray = imageCubeArray_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setImageCubeArray( Bool32 imageCubeArray_ ) && VULKAN_HPP_NOEXCEPT - { - imageCubeArray = imageCubeArray_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setIndependentBlend( Bool32 independentBlend_ ) & VULKAN_HPP_NOEXCEPT - { - independentBlend = independentBlend_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setIndependentBlend( Bool32 independentBlend_ ) && VULKAN_HPP_NOEXCEPT - { - independentBlend = independentBlend_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setGeometryShader( Bool32 geometryShader_ ) & VULKAN_HPP_NOEXCEPT - { - geometryShader = geometryShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setGeometryShader( Bool32 geometryShader_ ) && VULKAN_HPP_NOEXCEPT - { - geometryShader = geometryShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTessellationShader( Bool32 tessellationShader_ ) & VULKAN_HPP_NOEXCEPT - { - tessellationShader = tessellationShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTessellationShader( Bool32 tessellationShader_ ) && VULKAN_HPP_NOEXCEPT - { - tessellationShader = tessellationShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSampleRateShading( Bool32 sampleRateShading_ ) & VULKAN_HPP_NOEXCEPT - { - sampleRateShading = sampleRateShading_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSampleRateShading( Bool32 sampleRateShading_ ) && VULKAN_HPP_NOEXCEPT - { - sampleRateShading = sampleRateShading_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDualSrcBlend( Bool32 dualSrcBlend_ ) & VULKAN_HPP_NOEXCEPT - { - dualSrcBlend = dualSrcBlend_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDualSrcBlend( Bool32 dualSrcBlend_ ) && VULKAN_HPP_NOEXCEPT - { - dualSrcBlend = dualSrcBlend_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setLogicOp( Bool32 logicOp_ ) & VULKAN_HPP_NOEXCEPT - { - logicOp = logicOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setLogicOp( Bool32 logicOp_ ) && VULKAN_HPP_NOEXCEPT - { - logicOp = logicOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setMultiDrawIndirect( Bool32 multiDrawIndirect_ ) & VULKAN_HPP_NOEXCEPT - { - multiDrawIndirect = multiDrawIndirect_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setMultiDrawIndirect( Bool32 multiDrawIndirect_ ) && VULKAN_HPP_NOEXCEPT - { - multiDrawIndirect = multiDrawIndirect_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ ) & VULKAN_HPP_NOEXCEPT - { - drawIndirectFirstInstance = drawIndirectFirstInstance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDrawIndirectFirstInstance( Bool32 drawIndirectFirstInstance_ ) && VULKAN_HPP_NOEXCEPT - { - drawIndirectFirstInstance = drawIndirectFirstInstance_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDepthClamp( Bool32 depthClamp_ ) & VULKAN_HPP_NOEXCEPT - { - depthClamp = depthClamp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDepthClamp( Bool32 depthClamp_ ) && VULKAN_HPP_NOEXCEPT - { - depthClamp = depthClamp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDepthBiasClamp( Bool32 depthBiasClamp_ ) & VULKAN_HPP_NOEXCEPT - { - depthBiasClamp = depthBiasClamp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDepthBiasClamp( Bool32 depthBiasClamp_ ) && VULKAN_HPP_NOEXCEPT - { - depthBiasClamp = depthBiasClamp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setFillModeNonSolid( Bool32 fillModeNonSolid_ ) & VULKAN_HPP_NOEXCEPT - { - fillModeNonSolid = fillModeNonSolid_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setFillModeNonSolid( Bool32 fillModeNonSolid_ ) && VULKAN_HPP_NOEXCEPT - { - fillModeNonSolid = fillModeNonSolid_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setDepthBounds( Bool32 depthBounds_ ) & VULKAN_HPP_NOEXCEPT - { - depthBounds = depthBounds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setDepthBounds( Bool32 depthBounds_ ) && VULKAN_HPP_NOEXCEPT - { - depthBounds = depthBounds_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setWideLines( Bool32 wideLines_ ) & VULKAN_HPP_NOEXCEPT - { - wideLines = wideLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setWideLines( Bool32 wideLines_ ) && VULKAN_HPP_NOEXCEPT - { - wideLines = wideLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setLargePoints( Bool32 largePoints_ ) & VULKAN_HPP_NOEXCEPT - { - largePoints = largePoints_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setLargePoints( Bool32 largePoints_ ) && VULKAN_HPP_NOEXCEPT - { - largePoints = largePoints_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setAlphaToOne( Bool32 alphaToOne_ ) & VULKAN_HPP_NOEXCEPT - { - alphaToOne = alphaToOne_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setAlphaToOne( Bool32 alphaToOne_ ) && VULKAN_HPP_NOEXCEPT - { - alphaToOne = alphaToOne_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setMultiViewport( Bool32 multiViewport_ ) & VULKAN_HPP_NOEXCEPT - { - multiViewport = multiViewport_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setMultiViewport( Bool32 multiViewport_ ) && VULKAN_HPP_NOEXCEPT - { - multiViewport = multiViewport_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSamplerAnisotropy( Bool32 samplerAnisotropy_ ) & VULKAN_HPP_NOEXCEPT - { - samplerAnisotropy = samplerAnisotropy_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSamplerAnisotropy( Bool32 samplerAnisotropy_ ) && VULKAN_HPP_NOEXCEPT - { - samplerAnisotropy = samplerAnisotropy_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTextureCompressionETC2( Bool32 textureCompressionETC2_ ) & VULKAN_HPP_NOEXCEPT - { - textureCompressionETC2 = textureCompressionETC2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTextureCompressionETC2( Bool32 textureCompressionETC2_ ) && VULKAN_HPP_NOEXCEPT - { - textureCompressionETC2 = textureCompressionETC2_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ ) & VULKAN_HPP_NOEXCEPT - { - textureCompressionASTC_LDR = textureCompressionASTC_LDR_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTextureCompressionASTC_LDR( Bool32 textureCompressionASTC_LDR_ ) && VULKAN_HPP_NOEXCEPT - { - textureCompressionASTC_LDR = textureCompressionASTC_LDR_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setTextureCompressionBC( Bool32 textureCompressionBC_ ) & VULKAN_HPP_NOEXCEPT - { - textureCompressionBC = textureCompressionBC_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setTextureCompressionBC( Bool32 textureCompressionBC_ ) && VULKAN_HPP_NOEXCEPT - { - textureCompressionBC = textureCompressionBC_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ ) & VULKAN_HPP_NOEXCEPT - { - occlusionQueryPrecise = occlusionQueryPrecise_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setOcclusionQueryPrecise( Bool32 occlusionQueryPrecise_ ) && VULKAN_HPP_NOEXCEPT - { - occlusionQueryPrecise = occlusionQueryPrecise_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineStatisticsQuery = pipelineStatisticsQuery_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setPipelineStatisticsQuery( Bool32 pipelineStatisticsQuery_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineStatisticsQuery = pipelineStatisticsQuery_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ ) & VULKAN_HPP_NOEXCEPT - { - vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setVertexPipelineStoresAndAtomics( Bool32 vertexPipelineStoresAndAtomics_ ) && VULKAN_HPP_NOEXCEPT - { - vertexPipelineStoresAndAtomics = vertexPipelineStoresAndAtomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ ) & VULKAN_HPP_NOEXCEPT - { - fragmentStoresAndAtomics = fragmentStoresAndAtomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setFragmentStoresAndAtomics( Bool32 fragmentStoresAndAtomics_ ) && VULKAN_HPP_NOEXCEPT - { - fragmentStoresAndAtomics = fragmentStoresAndAtomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderTessellationAndGeometryPointSize( Bool32 shaderTessellationAndGeometryPointSize_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderTessellationAndGeometryPointSize = shaderTessellationAndGeometryPointSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ ) & VULKAN_HPP_NOEXCEPT - { - shaderImageGatherExtended = shaderImageGatherExtended_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderImageGatherExtended( Bool32 shaderImageGatherExtended_ ) && VULKAN_HPP_NOEXCEPT - { - shaderImageGatherExtended = shaderImageGatherExtended_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ ) & VULKAN_HPP_NOEXCEPT - { - shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageImageExtendedFormats( Bool32 shaderStorageImageExtendedFormats_ ) && VULKAN_HPP_NOEXCEPT - { - shaderStorageImageExtendedFormats = shaderStorageImageExtendedFormats_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ ) & VULKAN_HPP_NOEXCEPT - { - shaderStorageImageMultisample = shaderStorageImageMultisample_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageImageMultisample( Bool32 shaderStorageImageMultisample_ ) && VULKAN_HPP_NOEXCEPT - { - shaderStorageImageMultisample = shaderStorageImageMultisample_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ ) & VULKAN_HPP_NOEXCEPT - { - shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageImageReadWithoutFormat( Bool32 shaderStorageImageReadWithoutFormat_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageImageReadWithoutFormat = shaderStorageImageReadWithoutFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageImageWriteWithoutFormat( Bool32 shaderStorageImageWriteWithoutFormat_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageImageWriteWithoutFormat = shaderStorageImageWriteWithoutFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderUniformBufferArrayDynamicIndexing( Bool32 shaderUniformBufferArrayDynamicIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderUniformBufferArrayDynamicIndexing = shaderUniformBufferArrayDynamicIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderSampledImageArrayDynamicIndexing( Bool32 shaderSampledImageArrayDynamicIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSampledImageArrayDynamicIndexing = shaderSampledImageArrayDynamicIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageBufferArrayDynamicIndexing( Bool32 shaderStorageBufferArrayDynamicIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageBufferArrayDynamicIndexing = shaderStorageBufferArrayDynamicIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderStorageImageArrayDynamicIndexing( Bool32 shaderStorageImageArrayDynamicIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageImageArrayDynamicIndexing = shaderStorageImageArrayDynamicIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderClipDistance( Bool32 shaderClipDistance_ ) & VULKAN_HPP_NOEXCEPT - { - shaderClipDistance = shaderClipDistance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderClipDistance( Bool32 shaderClipDistance_ ) && VULKAN_HPP_NOEXCEPT - { - shaderClipDistance = shaderClipDistance_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderCullDistance( Bool32 shaderCullDistance_ ) & VULKAN_HPP_NOEXCEPT - { - shaderCullDistance = shaderCullDistance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderCullDistance( Bool32 shaderCullDistance_ ) && VULKAN_HPP_NOEXCEPT - { - shaderCullDistance = shaderCullDistance_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderFloat64( Bool32 shaderFloat64_ ) & VULKAN_HPP_NOEXCEPT - { - shaderFloat64 = shaderFloat64_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderFloat64( Bool32 shaderFloat64_ ) && VULKAN_HPP_NOEXCEPT - { - shaderFloat64 = shaderFloat64_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderInt64( Bool32 shaderInt64_ ) & VULKAN_HPP_NOEXCEPT - { - shaderInt64 = shaderInt64_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderInt64( Bool32 shaderInt64_ ) && VULKAN_HPP_NOEXCEPT - { - shaderInt64 = shaderInt64_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderInt16( Bool32 shaderInt16_ ) & VULKAN_HPP_NOEXCEPT - { - shaderInt16 = shaderInt16_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderInt16( Bool32 shaderInt16_ ) && VULKAN_HPP_NOEXCEPT - { - shaderInt16 = shaderInt16_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderResourceResidency( Bool32 shaderResourceResidency_ ) & VULKAN_HPP_NOEXCEPT - { - shaderResourceResidency = shaderResourceResidency_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderResourceResidency( Bool32 shaderResourceResidency_ ) && VULKAN_HPP_NOEXCEPT - { - shaderResourceResidency = shaderResourceResidency_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setShaderResourceMinLod( Bool32 shaderResourceMinLod_ ) & VULKAN_HPP_NOEXCEPT - { - shaderResourceMinLod = shaderResourceMinLod_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setShaderResourceMinLod( Bool32 shaderResourceMinLod_ ) && VULKAN_HPP_NOEXCEPT - { - shaderResourceMinLod = shaderResourceMinLod_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseBinding( Bool32 sparseBinding_ ) & VULKAN_HPP_NOEXCEPT - { - sparseBinding = sparseBinding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseBinding( Bool32 sparseBinding_ ) && VULKAN_HPP_NOEXCEPT - { - sparseBinding = sparseBinding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - sparseResidencyBuffer = sparseResidencyBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidencyBuffer( Bool32 sparseResidencyBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - sparseResidencyBuffer = sparseResidencyBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ ) & VULKAN_HPP_NOEXCEPT - { - sparseResidencyImage2D = sparseResidencyImage2D_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidencyImage2D( Bool32 sparseResidencyImage2D_ ) && VULKAN_HPP_NOEXCEPT - { - sparseResidencyImage2D = sparseResidencyImage2D_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ ) & VULKAN_HPP_NOEXCEPT - { - sparseResidencyImage3D = sparseResidencyImage3D_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidencyImage3D( Bool32 sparseResidencyImage3D_ ) && VULKAN_HPP_NOEXCEPT - { - sparseResidencyImage3D = sparseResidencyImage3D_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidency2Samples( Bool32 sparseResidency2Samples_ ) & VULKAN_HPP_NOEXCEPT - { - sparseResidency2Samples = sparseResidency2Samples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidency2Samples( Bool32 sparseResidency2Samples_ ) && VULKAN_HPP_NOEXCEPT - { - sparseResidency2Samples = sparseResidency2Samples_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidency4Samples( Bool32 sparseResidency4Samples_ ) & VULKAN_HPP_NOEXCEPT - { - sparseResidency4Samples = sparseResidency4Samples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidency4Samples( Bool32 sparseResidency4Samples_ ) && VULKAN_HPP_NOEXCEPT - { - sparseResidency4Samples = sparseResidency4Samples_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidency8Samples( Bool32 sparseResidency8Samples_ ) & VULKAN_HPP_NOEXCEPT - { - sparseResidency8Samples = sparseResidency8Samples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidency8Samples( Bool32 sparseResidency8Samples_ ) && VULKAN_HPP_NOEXCEPT - { - sparseResidency8Samples = sparseResidency8Samples_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidency16Samples( Bool32 sparseResidency16Samples_ ) & VULKAN_HPP_NOEXCEPT - { - sparseResidency16Samples = sparseResidency16Samples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidency16Samples( Bool32 sparseResidency16Samples_ ) && VULKAN_HPP_NOEXCEPT - { - sparseResidency16Samples = sparseResidency16Samples_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setSparseResidencyAliased( Bool32 sparseResidencyAliased_ ) & VULKAN_HPP_NOEXCEPT - { - sparseResidencyAliased = sparseResidencyAliased_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setSparseResidencyAliased( Bool32 sparseResidencyAliased_ ) && VULKAN_HPP_NOEXCEPT - { - sparseResidencyAliased = sparseResidencyAliased_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setVariableMultisampleRate( Bool32 variableMultisampleRate_ ) & VULKAN_HPP_NOEXCEPT - { - variableMultisampleRate = variableMultisampleRate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setVariableMultisampleRate( Bool32 variableMultisampleRate_ ) && VULKAN_HPP_NOEXCEPT - { - variableMultisampleRate = variableMultisampleRate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures & setInheritedQueries( Bool32 inheritedQueries_ ) & VULKAN_HPP_NOEXCEPT - { - inheritedQueries = inheritedQueries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures && setInheritedQueries( Bool32 inheritedQueries_ ) && VULKAN_HPP_NOEXCEPT - { - inheritedQueries = inheritedQueries_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( robustBufferAccess, - fullDrawIndexUint32, - imageCubeArray, - independentBlend, - geometryShader, - tessellationShader, - sampleRateShading, - dualSrcBlend, - logicOp, - multiDrawIndirect, - drawIndirectFirstInstance, - depthClamp, - depthBiasClamp, - fillModeNonSolid, - depthBounds, - wideLines, - largePoints, - alphaToOne, - multiViewport, - samplerAnisotropy, - textureCompressionETC2, - textureCompressionASTC_LDR, - textureCompressionBC, - occlusionQueryPrecise, - pipelineStatisticsQuery, - vertexPipelineStoresAndAtomics, - fragmentStoresAndAtomics, - shaderTessellationAndGeometryPointSize, - shaderImageGatherExtended, - shaderStorageImageExtendedFormats, - shaderStorageImageMultisample, - shaderStorageImageReadWithoutFormat, - shaderStorageImageWriteWithoutFormat, - shaderUniformBufferArrayDynamicIndexing, - shaderSampledImageArrayDynamicIndexing, - shaderStorageBufferArrayDynamicIndexing, - shaderStorageImageArrayDynamicIndexing, - shaderClipDistance, - shaderCullDistance, - shaderFloat64, - shaderInt64, - shaderInt16, - shaderResourceResidency, - shaderResourceMinLod, - sparseBinding, - sparseResidencyBuffer, - sparseResidencyImage2D, - sparseResidencyImage3D, - sparseResidency2Samples, - sparseResidency4Samples, - sparseResidency8Samples, - sparseResidency16Samples, - sparseResidencyAliased, - variableMultisampleRate, - inheritedQueries ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( robustBufferAccess == rhs.robustBufferAccess ) && ( fullDrawIndexUint32 == rhs.fullDrawIndexUint32 ) && - ( imageCubeArray == rhs.imageCubeArray ) && ( independentBlend == rhs.independentBlend ) && ( geometryShader == rhs.geometryShader ) && - ( tessellationShader == rhs.tessellationShader ) && ( sampleRateShading == rhs.sampleRateShading ) && ( dualSrcBlend == rhs.dualSrcBlend ) && - ( logicOp == rhs.logicOp ) && ( multiDrawIndirect == rhs.multiDrawIndirect ) && ( drawIndirectFirstInstance == rhs.drawIndirectFirstInstance ) && - ( depthClamp == rhs.depthClamp ) && ( depthBiasClamp == rhs.depthBiasClamp ) && ( fillModeNonSolid == rhs.fillModeNonSolid ) && - ( depthBounds == rhs.depthBounds ) && ( wideLines == rhs.wideLines ) && ( largePoints == rhs.largePoints ) && ( alphaToOne == rhs.alphaToOne ) && - ( multiViewport == rhs.multiViewport ) && ( samplerAnisotropy == rhs.samplerAnisotropy ) && - ( textureCompressionETC2 == rhs.textureCompressionETC2 ) && ( textureCompressionASTC_LDR == rhs.textureCompressionASTC_LDR ) && - ( textureCompressionBC == rhs.textureCompressionBC ) && ( occlusionQueryPrecise == rhs.occlusionQueryPrecise ) && - ( pipelineStatisticsQuery == rhs.pipelineStatisticsQuery ) && ( vertexPipelineStoresAndAtomics == rhs.vertexPipelineStoresAndAtomics ) && - ( fragmentStoresAndAtomics == rhs.fragmentStoresAndAtomics ) && - ( shaderTessellationAndGeometryPointSize == rhs.shaderTessellationAndGeometryPointSize ) && - ( shaderImageGatherExtended == rhs.shaderImageGatherExtended ) && ( shaderStorageImageExtendedFormats == rhs.shaderStorageImageExtendedFormats ) && - ( shaderStorageImageMultisample == rhs.shaderStorageImageMultisample ) && - ( shaderStorageImageReadWithoutFormat == rhs.shaderStorageImageReadWithoutFormat ) && - ( shaderStorageImageWriteWithoutFormat == rhs.shaderStorageImageWriteWithoutFormat ) && - ( shaderUniformBufferArrayDynamicIndexing == rhs.shaderUniformBufferArrayDynamicIndexing ) && - ( shaderSampledImageArrayDynamicIndexing == rhs.shaderSampledImageArrayDynamicIndexing ) && - ( shaderStorageBufferArrayDynamicIndexing == rhs.shaderStorageBufferArrayDynamicIndexing ) && - ( shaderStorageImageArrayDynamicIndexing == rhs.shaderStorageImageArrayDynamicIndexing ) && ( shaderClipDistance == rhs.shaderClipDistance ) && - ( shaderCullDistance == rhs.shaderCullDistance ) && ( shaderFloat64 == rhs.shaderFloat64 ) && ( shaderInt64 == rhs.shaderInt64 ) && - ( shaderInt16 == rhs.shaderInt16 ) && ( shaderResourceResidency == rhs.shaderResourceResidency ) && - ( shaderResourceMinLod == rhs.shaderResourceMinLod ) && ( sparseBinding == rhs.sparseBinding ) && - ( sparseResidencyBuffer == rhs.sparseResidencyBuffer ) && ( sparseResidencyImage2D == rhs.sparseResidencyImage2D ) && - ( sparseResidencyImage3D == rhs.sparseResidencyImage3D ) && ( sparseResidency2Samples == rhs.sparseResidency2Samples ) && - ( sparseResidency4Samples == rhs.sparseResidency4Samples ) && ( sparseResidency8Samples == rhs.sparseResidency8Samples ) && - ( sparseResidency16Samples == rhs.sparseResidency16Samples ) && ( sparseResidencyAliased == rhs.sparseResidencyAliased ) && - ( variableMultisampleRate == rhs.variableMultisampleRate ) && ( inheritedQueries == rhs.inheritedQueries ); -# endif - } - - bool operator!=( PhysicalDeviceFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Bool32 robustBufferAccess = {}; - Bool32 fullDrawIndexUint32 = {}; - Bool32 imageCubeArray = {}; - Bool32 independentBlend = {}; - Bool32 geometryShader = {}; - Bool32 tessellationShader = {}; - Bool32 sampleRateShading = {}; - Bool32 dualSrcBlend = {}; - Bool32 logicOp = {}; - Bool32 multiDrawIndirect = {}; - Bool32 drawIndirectFirstInstance = {}; - Bool32 depthClamp = {}; - Bool32 depthBiasClamp = {}; - Bool32 fillModeNonSolid = {}; - Bool32 depthBounds = {}; - Bool32 wideLines = {}; - Bool32 largePoints = {}; - Bool32 alphaToOne = {}; - Bool32 multiViewport = {}; - Bool32 samplerAnisotropy = {}; - Bool32 textureCompressionETC2 = {}; - Bool32 textureCompressionASTC_LDR = {}; - Bool32 textureCompressionBC = {}; - Bool32 occlusionQueryPrecise = {}; - Bool32 pipelineStatisticsQuery = {}; - Bool32 vertexPipelineStoresAndAtomics = {}; - Bool32 fragmentStoresAndAtomics = {}; - Bool32 shaderTessellationAndGeometryPointSize = {}; - Bool32 shaderImageGatherExtended = {}; - Bool32 shaderStorageImageExtendedFormats = {}; - Bool32 shaderStorageImageMultisample = {}; - Bool32 shaderStorageImageReadWithoutFormat = {}; - Bool32 shaderStorageImageWriteWithoutFormat = {}; - Bool32 shaderUniformBufferArrayDynamicIndexing = {}; - Bool32 shaderSampledImageArrayDynamicIndexing = {}; - Bool32 shaderStorageBufferArrayDynamicIndexing = {}; - Bool32 shaderStorageImageArrayDynamicIndexing = {}; - Bool32 shaderClipDistance = {}; - Bool32 shaderCullDistance = {}; - Bool32 shaderFloat64 = {}; - Bool32 shaderInt64 = {}; - Bool32 shaderInt16 = {}; - Bool32 shaderResourceResidency = {}; - Bool32 shaderResourceMinLod = {}; - Bool32 sparseBinding = {}; - Bool32 sparseResidencyBuffer = {}; - Bool32 sparseResidencyImage2D = {}; - Bool32 sparseResidencyImage3D = {}; - Bool32 sparseResidency2Samples = {}; - Bool32 sparseResidency4Samples = {}; - Bool32 sparseResidency8Samples = {}; - Bool32 sparseResidency16Samples = {}; - Bool32 sparseResidencyAliased = {}; - Bool32 variableMultisampleRate = {}; - Bool32 inheritedQueries = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFeatures; - }; -#endif - - // wrapper struct for struct VkDeviceCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceCreateInfo.html - struct DeviceCreateInfo - { - using NativeType = VkDeviceCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - -# if defined( _MSC_VER ) -# pragma warning( push ) -# pragma warning( disable : 4996 ) // 'function': was declared deprecated -# elif defined( __clang__ ) -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wdeprecated-declarations" -# elif defined( __GNUC__ ) -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# else -// unknown compiler... just ignore the warnings for yourselves ;) -# endif - - VULKAN_HPP_CONSTEXPR_17 DeviceCreateInfo( DeviceCreateFlags flags_ = {}, - uint32_t queueCreateInfoCount_ = {}, - const DeviceQueueCreateInfo * pQueueCreateInfos_ = {}, - uint32_t enabledLayerCount_ = {}, - const char * const * ppEnabledLayerNames_ = {}, - uint32_t enabledExtensionCount_ = {}, - const char * const * ppEnabledExtensionNames_ = {}, - const PhysicalDeviceFeatures * pEnabledFeatures_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , queueCreateInfoCount{ queueCreateInfoCount_ } - , pQueueCreateInfos{ pQueueCreateInfos_ } - , enabledLayerCount{ enabledLayerCount_ } - , ppEnabledLayerNames{ ppEnabledLayerNames_ } - , enabledExtensionCount{ enabledExtensionCount_ } - , ppEnabledExtensionNames{ ppEnabledExtensionNames_ } - , pEnabledFeatures{ pEnabledFeatures_ } - { - } - - VULKAN_HPP_CONSTEXPR_17 DeviceCreateInfo( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceCreateInfo( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceCreateInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceCreateInfo( DeviceCreateFlags flags_, - ArrayProxyNoTemporaries const & queueCreateInfos_, - ArrayProxyNoTemporaries const & pEnabledLayerNames_ = {}, - ArrayProxyNoTemporaries const & pEnabledExtensionNames_ = {}, - const PhysicalDeviceFeatures * pEnabledFeatures_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , queueCreateInfoCount( static_cast( queueCreateInfos_.size() ) ) - , pQueueCreateInfos( queueCreateInfos_.data() ) - , enabledLayerCount( static_cast( pEnabledLayerNames_.size() ) ) - , ppEnabledLayerNames( pEnabledLayerNames_.data() ) - , enabledExtensionCount( static_cast( pEnabledExtensionNames_.size() ) ) - , ppEnabledExtensionNames( pEnabledExtensionNames_.data() ) - , pEnabledFeatures( pEnabledFeatures_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DeviceCreateInfo & operator=( DeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - -# if defined( _MSC_VER ) -# pragma warning( pop ) -# elif defined( __clang__ ) -# pragma clang diagnostic pop -# elif defined( __GNUC__ ) -# pragma GCC diagnostic pop -# else -// unknown compiler... just ignore the warnings for yourselves ;) -# endif - -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceCreateInfo & operator=( VkDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - pNext = rhs.pNext; - flags = static_cast( rhs.flags ); - queueCreateInfoCount = rhs.queueCreateInfoCount; - pQueueCreateInfos = reinterpret_cast( rhs.pQueueCreateInfos ); - enabledExtensionCount = rhs.enabledExtensionCount; - ppEnabledExtensionNames = rhs.ppEnabledExtensionNames; - pEnabledFeatures = reinterpret_cast( rhs.pEnabledFeatures ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setFlags( DeviceCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setFlags( DeviceCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ ) & VULKAN_HPP_NOEXCEPT - { - queueCreateInfoCount = queueCreateInfoCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setQueueCreateInfoCount( uint32_t queueCreateInfoCount_ ) && VULKAN_HPP_NOEXCEPT - { - queueCreateInfoCount = queueCreateInfoCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPQueueCreateInfos( const DeviceQueueCreateInfo * pQueueCreateInfos_ ) & VULKAN_HPP_NOEXCEPT - { - pQueueCreateInfos = pQueueCreateInfos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setPQueueCreateInfos( const DeviceQueueCreateInfo * pQueueCreateInfos_ ) && VULKAN_HPP_NOEXCEPT - { - pQueueCreateInfos = pQueueCreateInfos_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceCreateInfo & setQueueCreateInfos( ArrayProxyNoTemporaries const & queueCreateInfos_ ) VULKAN_HPP_NOEXCEPT - { - queueCreateInfoCount = static_cast( queueCreateInfos_.size() ); - pQueueCreateInfos = queueCreateInfos_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_DEPRECATED( "ignored" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ ) & VULKAN_HPP_NOEXCEPT - { - detail::ignore( enabledLayerCount_ ); - return *this; - } - - VULKAN_HPP_DEPRECATED( "ignored" ) VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setEnabledLayerCount( uint32_t enabledLayerCount_ ) && VULKAN_HPP_NOEXCEPT - { - detail::ignore( enabledLayerCount_ ); - return std::move( *this ); - } - - VULKAN_HPP_DEPRECATED( "ignored" ) - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPpEnabledLayerNames( const char * const * ppEnabledLayerNames_ ) & VULKAN_HPP_NOEXCEPT - { - detail::ignore( ppEnabledLayerNames_ ); - return *this; - } - - VULKAN_HPP_DEPRECATED( "ignored" ) - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setPpEnabledLayerNames( const char * const * ppEnabledLayerNames_ ) && VULKAN_HPP_NOEXCEPT - { - detail::ignore( ppEnabledLayerNames_ ); - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VULKAN_HPP_DEPRECATED( "ignored" ) - DeviceCreateInfo & setPEnabledLayerNames( ArrayProxyNoTemporaries const & pEnabledLayerNames_ ) VULKAN_HPP_NOEXCEPT - { - detail::ignore( pEnabledLayerNames_ ); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) & VULKAN_HPP_NOEXCEPT - { - enabledExtensionCount = enabledExtensionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) && VULKAN_HPP_NOEXCEPT - { - enabledExtensionCount = enabledExtensionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPpEnabledExtensionNames( const char * const * ppEnabledExtensionNames_ ) & VULKAN_HPP_NOEXCEPT - { - ppEnabledExtensionNames = ppEnabledExtensionNames_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setPpEnabledExtensionNames( const char * const * ppEnabledExtensionNames_ ) && VULKAN_HPP_NOEXCEPT - { - ppEnabledExtensionNames = ppEnabledExtensionNames_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceCreateInfo & setPEnabledExtensionNames( ArrayProxyNoTemporaries const & pEnabledExtensionNames_ ) VULKAN_HPP_NOEXCEPT - { - enabledExtensionCount = static_cast( pEnabledExtensionNames_.size() ); - ppEnabledExtensionNames = pEnabledExtensionNames_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo & setPEnabledFeatures( const PhysicalDeviceFeatures * pEnabledFeatures_ ) & VULKAN_HPP_NOEXCEPT - { - pEnabledFeatures = pEnabledFeatures_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceCreateInfo && setPEnabledFeatures( const PhysicalDeviceFeatures * pEnabledFeatures_ ) && VULKAN_HPP_NOEXCEPT - { - pEnabledFeatures = pEnabledFeatures_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - queueCreateInfoCount, - pQueueCreateInfos, - enabledLayerCount, - ppEnabledLayerNames, - enabledExtensionCount, - ppEnabledExtensionNames, - pEnabledFeatures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = queueCreateInfoCount <=> rhs.queueCreateInfoCount; cmp != 0 ) - return cmp; - if ( auto cmp = pQueueCreateInfos <=> rhs.pQueueCreateInfos; cmp != 0 ) - return cmp; - if ( auto cmp = enabledExtensionCount <=> rhs.enabledExtensionCount; cmp != 0 ) - return cmp; - for ( size_t i = 0; i < enabledExtensionCount; ++i ) - { - if ( ppEnabledExtensionNames[i] != rhs.ppEnabledExtensionNames[i] ) - if ( auto cmp = strcmp( ppEnabledExtensionNames[i], rhs.ppEnabledExtensionNames[i] ); cmp != 0 ) - return cmp < 0 ? std::strong_ordering::less : std::strong_ordering::greater; - } - if ( auto cmp = pEnabledFeatures <=> rhs.pEnabledFeatures; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueCreateInfoCount == rhs.queueCreateInfoCount ) && - ( pQueueCreateInfos == rhs.pQueueCreateInfos ) && ( enabledExtensionCount == rhs.enabledExtensionCount ) && - std::equal( ppEnabledExtensionNames, - ppEnabledExtensionNames + enabledExtensionCount, - rhs.ppEnabledExtensionNames, - []( char const * left, char const * right ) { return ( left == right ) || ( strcmp( left, right ) == 0 ); } ) && - ( pEnabledFeatures == rhs.pEnabledFeatures ); - } - - bool operator!=( DeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDeviceCreateInfo; - const void * pNext = {}; - DeviceCreateFlags flags = {}; - uint32_t queueCreateInfoCount = {}; - const DeviceQueueCreateInfo * pQueueCreateInfos = {}; - VULKAN_HPP_DEPRECATED( "ignored" ) uint32_t enabledLayerCount = {}; - VULKAN_HPP_DEPRECATED( "ignored" ) const char * const * ppEnabledLayerNames = {}; - uint32_t enabledExtensionCount = {}; - const char * const * ppEnabledExtensionNames = {}; - const PhysicalDeviceFeatures * pEnabledFeatures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceCreateInfo; - }; - - // wrapper struct for struct VkDeviceMemoryReportCallbackDataEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryReportCallbackDataEXT.html - struct DeviceMemoryReportCallbackDataEXT - { - using NativeType = VkDeviceMemoryReportCallbackDataEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryReportCallbackDataEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT( DeviceMemoryReportFlagsEXT flags_ = {}, - DeviceMemoryReportEventTypeEXT type_ = DeviceMemoryReportEventTypeEXT::eAllocate, - uint64_t memoryObjectId_ = {}, - DeviceSize size_ = {}, - ObjectType objectType_ = ObjectType::eUnknown, - uint64_t objectHandle_ = {}, - uint32_t heapIndex_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , type{ type_ } - , memoryObjectId{ memoryObjectId_ } - , size{ size_ } - , objectType{ objectType_ } - , objectHandle{ objectHandle_ } - , heapIndex{ heapIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceMemoryReportCallbackDataEXT( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceMemoryReportCallbackDataEXT( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceMemoryReportCallbackDataEXT( *reinterpret_cast( &rhs ) ) - { - } - - DeviceMemoryReportCallbackDataEXT & operator=( DeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceMemoryReportCallbackDataEXT & operator=( VkDeviceMemoryReportCallbackDataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDeviceMemoryReportCallbackDataEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceMemoryReportCallbackDataEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceMemoryReportCallbackDataEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceMemoryReportCallbackDataEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, type, memoryObjectId, size, objectType, objectHandle, heapIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceMemoryReportCallbackDataEXT const & ) const = default; -#else - bool operator==( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( type == rhs.type ) && ( memoryObjectId == rhs.memoryObjectId ) && - ( size == rhs.size ) && ( objectType == rhs.objectType ) && ( objectHandle == rhs.objectHandle ) && ( heapIndex == rhs.heapIndex ); -# endif - } - - bool operator!=( DeviceMemoryReportCallbackDataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceMemoryReportCallbackDataEXT; - void * pNext = {}; - DeviceMemoryReportFlagsEXT flags = {}; - DeviceMemoryReportEventTypeEXT type = DeviceMemoryReportEventTypeEXT::eAllocate; - uint64_t memoryObjectId = {}; - DeviceSize size = {}; - ObjectType objectType = ObjectType::eUnknown; - uint64_t objectHandle = {}; - uint32_t heapIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceMemoryReportCallbackDataEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceMemoryReportCallbackDataEXT; - }; - - typedef void( VKAPI_PTR * PFN_DeviceMemoryReportCallbackEXT )( const DeviceMemoryReportCallbackDataEXT * pCallbackData, void * pUserData ); - - // wrapper struct for struct VkDeviceDeviceMemoryReportCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceDeviceMemoryReportCreateInfoEXT.html - struct DeviceDeviceMemoryReportCreateInfoEXT - { - using NativeType = VkDeviceDeviceMemoryReportCreateInfoEXT; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceDeviceMemoryReportCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceDeviceMemoryReportCreateInfoEXT( DeviceMemoryReportFlagsEXT flags_ = {}, - PFN_DeviceMemoryReportCallbackEXT pfnUserCallback_ = {}, - void * pUserData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pfnUserCallback{ pfnUserCallback_ } - , pUserData{ pUserData_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceDeviceMemoryReportCreateInfoEXT( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceDeviceMemoryReportCreateInfoEXT( VkDeviceDeviceMemoryReportCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceDeviceMemoryReportCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic push -# if defined( __clang__ ) -# pragma clang diagnostic ignored "-Wunknown-warning-option" -# endif -# pragma GCC diagnostic ignored "-Wcast-function-type" -# endif - VULKAN_HPP_DEPRECATED( "This constructor is deprecated. Use the one taking function pointer types from the vk-namespace instead." ) - - DeviceDeviceMemoryReportCreateInfoEXT( DeviceMemoryReportFlagsEXT flags_, - PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_, - void * pUserData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : DeviceDeviceMemoryReportCreateInfoEXT( flags_, reinterpret_cast( pfnUserCallback_ ), pUserData_, pNext_ ) - { - } -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic pop -# endif - - DeviceDeviceMemoryReportCreateInfoEXT & operator=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceDeviceMemoryReportCreateInfoEXT & operator=( VkDeviceDeviceMemoryReportCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT & setFlags( DeviceMemoryReportFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT && setFlags( DeviceMemoryReportFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT & setPfnUserCallback( PFN_DeviceMemoryReportCallbackEXT pfnUserCallback_ ) & - VULKAN_HPP_NOEXCEPT - { - pfnUserCallback = pfnUserCallback_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT && setPfnUserCallback( PFN_DeviceMemoryReportCallbackEXT pfnUserCallback_ ) && - VULKAN_HPP_NOEXCEPT - { - pfnUserCallback = pfnUserCallback_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT - { - pUserData = pUserData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceDeviceMemoryReportCreateInfoEXT && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT - { - pUserData = pUserData_; - return std::move( *this ); - } - -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic push -# if defined( __clang__ ) -# pragma clang diagnostic ignored "-Wunknown-warning-option" -# endif -# pragma GCC diagnostic ignored "-Wcast-function-type" -# endif - VULKAN_HPP_DEPRECATED( "This setter is deprecated. Use the one taking a function pointer type from the vk-namespace instead." ) - - DeviceDeviceMemoryReportCreateInfoEXT & setPfnUserCallback( PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback_ ) VULKAN_HPP_NOEXCEPT - { - return setPfnUserCallback( reinterpret_cast( pfnUserCallback_ ) ); - } -# if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic pop -# endif -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceDeviceMemoryReportCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceDeviceMemoryReportCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceDeviceMemoryReportCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceDeviceMemoryReportCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, pfnUserCallback, pUserData ); - } -#endif - - bool operator==( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -#if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -#else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pfnUserCallback == rhs.pfnUserCallback ) && - ( pUserData == rhs.pUserData ); -#endif - } - - bool operator!=( DeviceDeviceMemoryReportCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDeviceDeviceMemoryReportCreateInfoEXT; - const void * pNext = {}; - DeviceMemoryReportFlagsEXT flags = {}; - PFN_DeviceMemoryReportCallbackEXT pfnUserCallback = {}; - void * pUserData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceDeviceMemoryReportCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceDeviceMemoryReportCreateInfoEXT; - }; - - // wrapper struct for struct VkDeviceDiagnosticsConfigCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceDiagnosticsConfigCreateInfoNV.html - struct DeviceDiagnosticsConfigCreateInfoNV - { - using NativeType = VkDeviceDiagnosticsConfigCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceDiagnosticsConfigCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigCreateInfoNV( DeviceDiagnosticsConfigFlagsNV flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceDiagnosticsConfigCreateInfoNV( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceDiagnosticsConfigCreateInfoNV( VkDeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceDiagnosticsConfigCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - DeviceDiagnosticsConfigCreateInfoNV & operator=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceDiagnosticsConfigCreateInfoNV & operator=( VkDeviceDiagnosticsConfigCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceDiagnosticsConfigCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceDiagnosticsConfigCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceDiagnosticsConfigCreateInfoNV & setFlags( DeviceDiagnosticsConfigFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceDiagnosticsConfigCreateInfoNV && setFlags( DeviceDiagnosticsConfigFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceDiagnosticsConfigCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceDiagnosticsConfigCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceDiagnosticsConfigCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceDiagnosticsConfigCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceDiagnosticsConfigCreateInfoNV const & ) const = default; -#else - bool operator==( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( DeviceDiagnosticsConfigCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceDiagnosticsConfigCreateInfoNV; - const void * pNext = {}; - DeviceDiagnosticsConfigFlagsNV flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceDiagnosticsConfigCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceDiagnosticsConfigCreateInfoNV; - }; - - // wrapper struct for struct VkDeviceEventInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceEventInfoEXT.html - struct DeviceEventInfoEXT - { - using NativeType = VkDeviceEventInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceEventInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( DeviceEventTypeEXT deviceEvent_ = DeviceEventTypeEXT::eDisplayHotplug, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceEvent{ deviceEvent_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceEventInfoEXT( DeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceEventInfoEXT( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceEventInfoEXT( *reinterpret_cast( &rhs ) ) {} - - DeviceEventInfoEXT & operator=( DeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceEventInfoEXT & operator=( VkDeviceEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceEventInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceEventInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceEventInfoEXT & setDeviceEvent( DeviceEventTypeEXT deviceEvent_ ) & VULKAN_HPP_NOEXCEPT - { - deviceEvent = deviceEvent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceEventInfoEXT && setDeviceEvent( DeviceEventTypeEXT deviceEvent_ ) && VULKAN_HPP_NOEXCEPT - { - deviceEvent = deviceEvent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceEventInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceEventInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceEventInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceEvent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceEventInfoEXT const & ) const = default; -#else - bool operator==( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceEvent == rhs.deviceEvent ); -# endif - } - - bool operator!=( DeviceEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceEventInfoEXT; - const void * pNext = {}; - DeviceEventTypeEXT deviceEvent = DeviceEventTypeEXT::eDisplayHotplug; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceEventInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceEventInfoEXT; - }; - - // wrapper struct for struct VkDeviceFaultAddressInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultAddressInfoEXT.html - struct DeviceFaultAddressInfoEXT - { - using NativeType = VkDeviceFaultAddressInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceFaultAddressInfoEXT( DeviceFaultAddressTypeEXT addressType_ = DeviceFaultAddressTypeEXT::eNone, - DeviceAddress reportedAddress_ = {}, - DeviceSize addressPrecision_ = {} ) VULKAN_HPP_NOEXCEPT - : addressType{ addressType_ } - , reportedAddress{ reportedAddress_ } - , addressPrecision{ addressPrecision_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceFaultAddressInfoEXT( DeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceFaultAddressInfoEXT( VkDeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceFaultAddressInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - DeviceFaultAddressInfoEXT & operator=( DeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceFaultAddressInfoEXT & operator=( VkDeviceFaultAddressInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT & setAddressType( DeviceFaultAddressTypeEXT addressType_ ) & VULKAN_HPP_NOEXCEPT - { - addressType = addressType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT && setAddressType( DeviceFaultAddressTypeEXT addressType_ ) && VULKAN_HPP_NOEXCEPT - { - addressType = addressType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT & setReportedAddress( DeviceAddress reportedAddress_ ) & VULKAN_HPP_NOEXCEPT - { - reportedAddress = reportedAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT && setReportedAddress( DeviceAddress reportedAddress_ ) && VULKAN_HPP_NOEXCEPT - { - reportedAddress = reportedAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT & setAddressPrecision( DeviceSize addressPrecision_ ) & VULKAN_HPP_NOEXCEPT - { - addressPrecision = addressPrecision_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultAddressInfoEXT && setAddressPrecision( DeviceSize addressPrecision_ ) && VULKAN_HPP_NOEXCEPT - { - addressPrecision = addressPrecision_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceFaultAddressInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceFaultAddressInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceFaultAddressInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceFaultAddressInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( addressType, reportedAddress, addressPrecision ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceFaultAddressInfoEXT const & ) const = default; -#else - bool operator==( DeviceFaultAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( addressType == rhs.addressType ) && ( reportedAddress == rhs.reportedAddress ) && ( addressPrecision == rhs.addressPrecision ); -# endif - } - - bool operator!=( DeviceFaultAddressInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceFaultAddressTypeEXT addressType = DeviceFaultAddressTypeEXT::eNone; - DeviceAddress reportedAddress = {}; - DeviceSize addressPrecision = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceFaultAddressInfoEXT; - }; -#endif - - // wrapper struct for struct VkDeviceFaultCountsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultCountsEXT.html - struct DeviceFaultCountsEXT - { - using NativeType = VkDeviceFaultCountsEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceFaultCountsEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceFaultCountsEXT( uint32_t addressInfoCount_ = {}, - uint32_t vendorInfoCount_ = {}, - DeviceSize vendorBinarySize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , addressInfoCount{ addressInfoCount_ } - , vendorInfoCount{ vendorInfoCount_ } - , vendorBinarySize{ vendorBinarySize_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceFaultCountsEXT( DeviceFaultCountsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceFaultCountsEXT( VkDeviceFaultCountsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceFaultCountsEXT( *reinterpret_cast( &rhs ) ) - { - } - - DeviceFaultCountsEXT & operator=( DeviceFaultCountsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceFaultCountsEXT & operator=( VkDeviceFaultCountsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT & setAddressInfoCount( uint32_t addressInfoCount_ ) & VULKAN_HPP_NOEXCEPT - { - addressInfoCount = addressInfoCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT && setAddressInfoCount( uint32_t addressInfoCount_ ) && VULKAN_HPP_NOEXCEPT - { - addressInfoCount = addressInfoCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT & setVendorInfoCount( uint32_t vendorInfoCount_ ) & VULKAN_HPP_NOEXCEPT - { - vendorInfoCount = vendorInfoCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT && setVendorInfoCount( uint32_t vendorInfoCount_ ) && VULKAN_HPP_NOEXCEPT - { - vendorInfoCount = vendorInfoCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT & setVendorBinarySize( DeviceSize vendorBinarySize_ ) & VULKAN_HPP_NOEXCEPT - { - vendorBinarySize = vendorBinarySize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultCountsEXT && setVendorBinarySize( DeviceSize vendorBinarySize_ ) && VULKAN_HPP_NOEXCEPT - { - vendorBinarySize = vendorBinarySize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceFaultCountsEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceFaultCountsEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceFaultCountsEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceFaultCountsEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, addressInfoCount, vendorInfoCount, vendorBinarySize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceFaultCountsEXT const & ) const = default; -#else - bool operator==( DeviceFaultCountsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( addressInfoCount == rhs.addressInfoCount ) && ( vendorInfoCount == rhs.vendorInfoCount ) && - ( vendorBinarySize == rhs.vendorBinarySize ); -# endif - } - - bool operator!=( DeviceFaultCountsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceFaultCountsEXT; - void * pNext = {}; - uint32_t addressInfoCount = {}; - uint32_t vendorInfoCount = {}; - DeviceSize vendorBinarySize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceFaultCountsEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceFaultCountsEXT; - }; - - // wrapper struct for struct VkDeviceFaultVendorInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorInfoEXT.html - struct DeviceFaultVendorInfoEXT - { - using NativeType = VkDeviceFaultVendorInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT( std::array const & description_ = {}, - uint64_t vendorFaultCode_ = {}, - uint64_t vendorFaultData_ = {} ) VULKAN_HPP_NOEXCEPT - : description{ description_ } - , vendorFaultCode{ vendorFaultCode_ } - , vendorFaultData{ vendorFaultData_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT( DeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceFaultVendorInfoEXT( VkDeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceFaultVendorInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceFaultVendorInfoEXT( std::string const & description_, uint64_t vendorFaultCode_ = {}, uint64_t vendorFaultData_ = {} ) - : vendorFaultCode( vendorFaultCode_ ), vendorFaultData( vendorFaultData_ ) - { - VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); -# if defined( _WIN32 ) - strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); -# else - strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); -# endif - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DeviceFaultVendorInfoEXT & operator=( DeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceFaultVendorInfoEXT & operator=( VkDeviceFaultVendorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT & setDescription( std::array description_ ) & VULKAN_HPP_NOEXCEPT - { - description = description_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT && setDescription( std::array description_ ) && VULKAN_HPP_NOEXCEPT - { - description = description_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceFaultVendorInfoEXT & setDescription( std::string const & description_ ) VULKAN_HPP_NOEXCEPT - { - VULKAN_HPP_ASSERT( description_.size() < VK_MAX_DESCRIPTION_SIZE ); -# if defined( _WIN32 ) - strncpy_s( description, VK_MAX_DESCRIPTION_SIZE, description_.data(), description_.size() ); -# else - strncpy( description, description_.data(), std::min( VK_MAX_DESCRIPTION_SIZE, description_.size() ) ); -# endif - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT & setVendorFaultCode( uint64_t vendorFaultCode_ ) & VULKAN_HPP_NOEXCEPT - { - vendorFaultCode = vendorFaultCode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT && setVendorFaultCode( uint64_t vendorFaultCode_ ) && VULKAN_HPP_NOEXCEPT - { - vendorFaultCode = vendorFaultCode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT & setVendorFaultData( uint64_t vendorFaultData_ ) & VULKAN_HPP_NOEXCEPT - { - vendorFaultData = vendorFaultData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorInfoEXT && setVendorFaultData( uint64_t vendorFaultData_ ) && VULKAN_HPP_NOEXCEPT - { - vendorFaultData = vendorFaultData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceFaultVendorInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceFaultVendorInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceFaultVendorInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceFaultVendorInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, uint64_t const &, uint64_t const &> reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( description, vendorFaultCode, vendorFaultData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = vendorFaultCode <=> rhs.vendorFaultCode; cmp != 0 ) - return cmp; - if ( auto cmp = vendorFaultData <=> rhs.vendorFaultData; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( strcmp( description, rhs.description ) == 0 ) && ( vendorFaultCode == rhs.vendorFaultCode ) && ( vendorFaultData == rhs.vendorFaultData ); - } - - bool operator!=( DeviceFaultVendorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - ArrayWrapper1D description = {}; - uint64_t vendorFaultCode = {}; - uint64_t vendorFaultData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceFaultVendorInfoEXT; - }; -#endif - - // wrapper struct for struct VkDeviceFaultInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultInfoEXT.html - struct DeviceFaultInfoEXT - { - using NativeType = VkDeviceFaultInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceFaultInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT( std::array const & description_ = {}, - DeviceFaultAddressInfoEXT * pAddressInfos_ = {}, - DeviceFaultVendorInfoEXT * pVendorInfos_ = {}, - void * pVendorBinaryData_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , description{ description_ } - , pAddressInfos{ pAddressInfos_ } - , pVendorInfos{ pVendorInfos_ } - , pVendorBinaryData{ pVendorBinaryData_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultInfoEXT( DeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceFaultInfoEXT( VkDeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceFaultInfoEXT( *reinterpret_cast( &rhs ) ) {} - - DeviceFaultInfoEXT & operator=( DeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceFaultInfoEXT & operator=( VkDeviceFaultInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDeviceFaultInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceFaultInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceFaultInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceFaultInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - DeviceFaultAddressInfoEXT * const &, - DeviceFaultVendorInfoEXT * const &, - void * const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, description, pAddressInfos, pVendorInfos, pVendorBinaryData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( DeviceFaultInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = pAddressInfos <=> rhs.pAddressInfos; cmp != 0 ) - return cmp; - if ( auto cmp = pVendorInfos <=> rhs.pVendorInfos; cmp != 0 ) - return cmp; - if ( auto cmp = pVendorBinaryData <=> rhs.pVendorBinaryData; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( DeviceFaultInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( strcmp( description, rhs.description ) == 0 ) && ( pAddressInfos == rhs.pAddressInfos ) && - ( pVendorInfos == rhs.pVendorInfos ) && ( pVendorBinaryData == rhs.pVendorBinaryData ); - } - - bool operator!=( DeviceFaultInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDeviceFaultInfoEXT; - void * pNext = {}; - ArrayWrapper1D description = {}; - DeviceFaultAddressInfoEXT * pAddressInfos = {}; - DeviceFaultVendorInfoEXT * pVendorInfos = {}; - void * pVendorBinaryData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceFaultInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceFaultInfoEXT; - }; - - // wrapper struct for struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceFaultVendorBinaryHeaderVersionOneEXT.html - struct DeviceFaultVendorBinaryHeaderVersionOneEXT - { - using NativeType = VkDeviceFaultVendorBinaryHeaderVersionOneEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - DeviceFaultVendorBinaryHeaderVersionOneEXT( uint32_t headerSize_ = {}, - DeviceFaultVendorBinaryHeaderVersionEXT headerVersion_ = DeviceFaultVendorBinaryHeaderVersionEXT::eOne, - uint32_t vendorID_ = {}, - uint32_t deviceID_ = {}, - uint32_t driverVersion_ = {}, - std::array const & pipelineCacheUUID_ = {}, - uint32_t applicationNameOffset_ = {}, - uint32_t applicationVersion_ = {}, - uint32_t engineNameOffset_ = {}, - uint32_t engineVersion_ = {}, - uint32_t apiVersion_ = {} ) VULKAN_HPP_NOEXCEPT - : headerSize{ headerSize_ } - , headerVersion{ headerVersion_ } - , vendorID{ vendorID_ } - , deviceID{ deviceID_ } - , driverVersion{ driverVersion_ } - , pipelineCacheUUID{ pipelineCacheUUID_ } - , applicationNameOffset{ applicationNameOffset_ } - , applicationVersion{ applicationVersion_ } - , engineNameOffset{ engineNameOffset_ } - , engineVersion{ engineVersion_ } - , apiVersion{ apiVersion_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceFaultVendorBinaryHeaderVersionOneEXT( VkDeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceFaultVendorBinaryHeaderVersionOneEXT( *reinterpret_cast( &rhs ) ) - { - } - - DeviceFaultVendorBinaryHeaderVersionOneEXT & operator=( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceFaultVendorBinaryHeaderVersionOneEXT & operator=( VkDeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setHeaderSize( uint32_t headerSize_ ) & VULKAN_HPP_NOEXCEPT - { - headerSize = headerSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setHeaderSize( uint32_t headerSize_ ) && VULKAN_HPP_NOEXCEPT - { - headerSize = headerSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setHeaderVersion( DeviceFaultVendorBinaryHeaderVersionEXT headerVersion_ ) & - VULKAN_HPP_NOEXCEPT - { - headerVersion = headerVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setHeaderVersion( DeviceFaultVendorBinaryHeaderVersionEXT headerVersion_ ) && - VULKAN_HPP_NOEXCEPT - { - headerVersion = headerVersion_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setVendorID( uint32_t vendorID_ ) & VULKAN_HPP_NOEXCEPT - { - vendorID = vendorID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setVendorID( uint32_t vendorID_ ) && VULKAN_HPP_NOEXCEPT - { - vendorID = vendorID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setDeviceID( uint32_t deviceID_ ) & VULKAN_HPP_NOEXCEPT - { - deviceID = deviceID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setDeviceID( uint32_t deviceID_ ) && VULKAN_HPP_NOEXCEPT - { - deviceID = deviceID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setDriverVersion( uint32_t driverVersion_ ) & VULKAN_HPP_NOEXCEPT - { - driverVersion = driverVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setDriverVersion( uint32_t driverVersion_ ) && VULKAN_HPP_NOEXCEPT - { - driverVersion = driverVersion_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setPipelineCacheUUID( std::array pipelineCacheUUID_ ) & - VULKAN_HPP_NOEXCEPT - { - pipelineCacheUUID = pipelineCacheUUID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setPipelineCacheUUID( std::array pipelineCacheUUID_ ) && - VULKAN_HPP_NOEXCEPT - { - pipelineCacheUUID = pipelineCacheUUID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setApplicationNameOffset( uint32_t applicationNameOffset_ ) & VULKAN_HPP_NOEXCEPT - { - applicationNameOffset = applicationNameOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setApplicationNameOffset( uint32_t applicationNameOffset_ ) && VULKAN_HPP_NOEXCEPT - { - applicationNameOffset = applicationNameOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setApplicationVersion( uint32_t applicationVersion_ ) & VULKAN_HPP_NOEXCEPT - { - applicationVersion = applicationVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setApplicationVersion( uint32_t applicationVersion_ ) && VULKAN_HPP_NOEXCEPT - { - applicationVersion = applicationVersion_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setEngineNameOffset( uint32_t engineNameOffset_ ) & VULKAN_HPP_NOEXCEPT - { - engineNameOffset = engineNameOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setEngineNameOffset( uint32_t engineNameOffset_ ) && VULKAN_HPP_NOEXCEPT - { - engineNameOffset = engineNameOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setEngineVersion( uint32_t engineVersion_ ) & VULKAN_HPP_NOEXCEPT - { - engineVersion = engineVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setEngineVersion( uint32_t engineVersion_ ) && VULKAN_HPP_NOEXCEPT - { - engineVersion = engineVersion_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT & setApiVersion( uint32_t apiVersion_ ) & VULKAN_HPP_NOEXCEPT - { - apiVersion = apiVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceFaultVendorBinaryHeaderVersionOneEXT && setApiVersion( uint32_t apiVersion_ ) && VULKAN_HPP_NOEXCEPT - { - apiVersion = apiVersion_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceFaultVendorBinaryHeaderVersionOneEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( headerSize, - headerVersion, - vendorID, - deviceID, - driverVersion, - pipelineCacheUUID, - applicationNameOffset, - applicationVersion, - engineNameOffset, - engineVersion, - apiVersion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceFaultVendorBinaryHeaderVersionOneEXT const & ) const = default; -#else - bool operator==( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && - ( driverVersion == rhs.driverVersion ) && ( pipelineCacheUUID == rhs.pipelineCacheUUID ) && - ( applicationNameOffset == rhs.applicationNameOffset ) && ( applicationVersion == rhs.applicationVersion ) && - ( engineNameOffset == rhs.engineNameOffset ) && ( engineVersion == rhs.engineVersion ) && ( apiVersion == rhs.apiVersion ); -# endif - } - - bool operator!=( DeviceFaultVendorBinaryHeaderVersionOneEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t headerSize = {}; - DeviceFaultVendorBinaryHeaderVersionEXT headerVersion = DeviceFaultVendorBinaryHeaderVersionEXT::eOne; - uint32_t vendorID = {}; - uint32_t deviceID = {}; - uint32_t driverVersion = {}; - ArrayWrapper1D pipelineCacheUUID = {}; - uint32_t applicationNameOffset = {}; - uint32_t applicationVersion = {}; - uint32_t engineNameOffset = {}; - uint32_t engineVersion = {}; - uint32_t apiVersion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceFaultVendorBinaryHeaderVersionOneEXT; - }; -#endif - - // wrapper struct for struct VkDeviceGroupBindSparseInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupBindSparseInfo.html - struct DeviceGroupBindSparseInfo - { - using NativeType = VkDeviceGroupBindSparseInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupBindSparseInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - DeviceGroupBindSparseInfo( uint32_t resourceDeviceIndex_ = {}, uint32_t memoryDeviceIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , resourceDeviceIndex{ resourceDeviceIndex_ } - , memoryDeviceIndex{ memoryDeviceIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceGroupBindSparseInfo( DeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceGroupBindSparseInfo( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceGroupBindSparseInfo( *reinterpret_cast( &rhs ) ) - { - } - - DeviceGroupBindSparseInfo & operator=( DeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceGroupBindSparseInfo & operator=( VkDeviceGroupBindSparseInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo & setResourceDeviceIndex( uint32_t resourceDeviceIndex_ ) & VULKAN_HPP_NOEXCEPT - { - resourceDeviceIndex = resourceDeviceIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo && setResourceDeviceIndex( uint32_t resourceDeviceIndex_ ) && VULKAN_HPP_NOEXCEPT - { - resourceDeviceIndex = resourceDeviceIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo & setMemoryDeviceIndex( uint32_t memoryDeviceIndex_ ) & VULKAN_HPP_NOEXCEPT - { - memoryDeviceIndex = memoryDeviceIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupBindSparseInfo && setMemoryDeviceIndex( uint32_t memoryDeviceIndex_ ) && VULKAN_HPP_NOEXCEPT - { - memoryDeviceIndex = memoryDeviceIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceGroupBindSparseInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupBindSparseInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupBindSparseInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceGroupBindSparseInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, resourceDeviceIndex, memoryDeviceIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceGroupBindSparseInfo const & ) const = default; -#else - bool operator==( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( resourceDeviceIndex == rhs.resourceDeviceIndex ) && - ( memoryDeviceIndex == rhs.memoryDeviceIndex ); -# endif - } - - bool operator!=( DeviceGroupBindSparseInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceGroupBindSparseInfo; - const void * pNext = {}; - uint32_t resourceDeviceIndex = {}; - uint32_t memoryDeviceIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceGroupBindSparseInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceGroupBindSparseInfo; - }; - - using DeviceGroupBindSparseInfoKHR = DeviceGroupBindSparseInfo; - - // wrapper struct for struct VkDeviceGroupCommandBufferBeginInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupCommandBufferBeginInfo.html - struct DeviceGroupCommandBufferBeginInfo - { - using NativeType = VkDeviceGroupCommandBufferBeginInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupCommandBufferBeginInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( uint32_t deviceMask_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceMask{ deviceMask_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceGroupCommandBufferBeginInfo( DeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceGroupCommandBufferBeginInfo( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceGroupCommandBufferBeginInfo( *reinterpret_cast( &rhs ) ) - { - } - - DeviceGroupCommandBufferBeginInfo & operator=( DeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceGroupCommandBufferBeginInfo & operator=( VkDeviceGroupCommandBufferBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceGroupCommandBufferBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupCommandBufferBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupCommandBufferBeginInfo & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT - { - deviceMask = deviceMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupCommandBufferBeginInfo && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT - { - deviceMask = deviceMask_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceGroupCommandBufferBeginInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupCommandBufferBeginInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupCommandBufferBeginInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceGroupCommandBufferBeginInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceGroupCommandBufferBeginInfo const & ) const = default; -#else - bool operator==( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ); -# endif - } - - bool operator!=( DeviceGroupCommandBufferBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceGroupCommandBufferBeginInfo; - const void * pNext = {}; - uint32_t deviceMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceGroupCommandBufferBeginInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceGroupCommandBufferBeginInfo; - }; - - using DeviceGroupCommandBufferBeginInfoKHR = DeviceGroupCommandBufferBeginInfo; - - // wrapper struct for struct VkDeviceGroupDeviceCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupDeviceCreateInfo.html - struct DeviceGroupDeviceCreateInfo - { - using NativeType = VkDeviceGroupDeviceCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupDeviceCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( uint32_t physicalDeviceCount_ = {}, - const PhysicalDevice * pPhysicalDevices_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , physicalDeviceCount{ physicalDeviceCount_ } - , pPhysicalDevices{ pPhysicalDevices_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceGroupDeviceCreateInfo( DeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceGroupDeviceCreateInfo( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceGroupDeviceCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceGroupDeviceCreateInfo( ArrayProxyNoTemporaries const & physicalDevices_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), physicalDeviceCount( static_cast( physicalDevices_.size() ) ), pPhysicalDevices( physicalDevices_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DeviceGroupDeviceCreateInfo & operator=( DeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceGroupDeviceCreateInfo & operator=( VkDeviceGroupDeviceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo & setPhysicalDeviceCount( uint32_t physicalDeviceCount_ ) & VULKAN_HPP_NOEXCEPT - { - physicalDeviceCount = physicalDeviceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo && setPhysicalDeviceCount( uint32_t physicalDeviceCount_ ) && VULKAN_HPP_NOEXCEPT - { - physicalDeviceCount = physicalDeviceCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo & setPPhysicalDevices( const PhysicalDevice * pPhysicalDevices_ ) & VULKAN_HPP_NOEXCEPT - { - pPhysicalDevices = pPhysicalDevices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupDeviceCreateInfo && setPPhysicalDevices( const PhysicalDevice * pPhysicalDevices_ ) && VULKAN_HPP_NOEXCEPT - { - pPhysicalDevices = pPhysicalDevices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceGroupDeviceCreateInfo & setPhysicalDevices( ArrayProxyNoTemporaries const & physicalDevices_ ) VULKAN_HPP_NOEXCEPT - { - physicalDeviceCount = static_cast( physicalDevices_.size() ); - pPhysicalDevices = physicalDevices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceGroupDeviceCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupDeviceCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupDeviceCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceGroupDeviceCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, physicalDeviceCount, pPhysicalDevices ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceGroupDeviceCreateInfo const & ) const = default; -#else - bool operator==( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) && - ( pPhysicalDevices == rhs.pPhysicalDevices ); -# endif - } - - bool operator!=( DeviceGroupDeviceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceGroupDeviceCreateInfo; - const void * pNext = {}; - uint32_t physicalDeviceCount = {}; - const PhysicalDevice * pPhysicalDevices = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceGroupDeviceCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceGroupDeviceCreateInfo; - }; - - using DeviceGroupDeviceCreateInfoKHR = DeviceGroupDeviceCreateInfo; - - // wrapper struct for struct VkDeviceGroupPresentCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupPresentCapabilitiesKHR.html - struct DeviceGroupPresentCapabilitiesKHR - { - using NativeType = VkDeviceGroupPresentCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupPresentCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentCapabilitiesKHR( std::array const & presentMask_ = {}, - DeviceGroupPresentModeFlagsKHR modes_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentMask{ presentMask_ } - , modes{ modes_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentCapabilitiesKHR( DeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceGroupPresentCapabilitiesKHR( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceGroupPresentCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - DeviceGroupPresentCapabilitiesKHR & operator=( DeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceGroupPresentCapabilitiesKHR & operator=( VkDeviceGroupPresentCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDeviceGroupPresentCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupPresentCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupPresentCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceGroupPresentCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, DeviceGroupPresentModeFlagsKHR const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentMask, modes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceGroupPresentCapabilitiesKHR const & ) const = default; -#else - bool operator==( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMask == rhs.presentMask ) && ( modes == rhs.modes ); -# endif - } - - bool operator!=( DeviceGroupPresentCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceGroupPresentCapabilitiesKHR; - void * pNext = {}; - ArrayWrapper1D presentMask = {}; - DeviceGroupPresentModeFlagsKHR modes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceGroupPresentCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceGroupPresentCapabilitiesKHR; - }; - - // wrapper struct for struct VkDeviceGroupPresentInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupPresentInfoKHR.html - struct DeviceGroupPresentInfoKHR - { - using NativeType = VkDeviceGroupPresentInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupPresentInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( uint32_t swapchainCount_ = {}, - const uint32_t * pDeviceMasks_ = {}, - DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchainCount{ swapchainCount_ } - , pDeviceMasks{ pDeviceMasks_ } - , mode{ mode_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceGroupPresentInfoKHR( DeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceGroupPresentInfoKHR( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceGroupPresentInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceGroupPresentInfoKHR( ArrayProxyNoTemporaries const & deviceMasks_, - DeviceGroupPresentModeFlagBitsKHR mode_ = DeviceGroupPresentModeFlagBitsKHR::eLocal, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), swapchainCount( static_cast( deviceMasks_.size() ) ), pDeviceMasks( deviceMasks_.data() ), mode( mode_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DeviceGroupPresentInfoKHR & operator=( DeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceGroupPresentInfoKHR & operator=( VkDeviceGroupPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR & setPDeviceMasks( const uint32_t * pDeviceMasks_ ) & VULKAN_HPP_NOEXCEPT - { - pDeviceMasks = pDeviceMasks_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR && setPDeviceMasks( const uint32_t * pDeviceMasks_ ) && VULKAN_HPP_NOEXCEPT - { - pDeviceMasks = pDeviceMasks_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceGroupPresentInfoKHR & setDeviceMasks( ArrayProxyNoTemporaries const & deviceMasks_ ) VULKAN_HPP_NOEXCEPT - { - swapchainCount = static_cast( deviceMasks_.size() ); - pDeviceMasks = deviceMasks_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR & setMode( DeviceGroupPresentModeFlagBitsKHR mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupPresentInfoKHR && setMode( DeviceGroupPresentModeFlagBitsKHR mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceGroupPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupPresentInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupPresentInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceGroupPresentInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchainCount, pDeviceMasks, mode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceGroupPresentInfoKHR const & ) const = default; -#else - bool operator==( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pDeviceMasks == rhs.pDeviceMasks ) && - ( mode == rhs.mode ); -# endif - } - - bool operator!=( DeviceGroupPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceGroupPresentInfoKHR; - const void * pNext = {}; - uint32_t swapchainCount = {}; - const uint32_t * pDeviceMasks = {}; - DeviceGroupPresentModeFlagBitsKHR mode = DeviceGroupPresentModeFlagBitsKHR::eLocal; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceGroupPresentInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceGroupPresentInfoKHR; - }; - - // wrapper struct for struct VkDeviceGroupRenderPassBeginInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupRenderPassBeginInfo.html - struct DeviceGroupRenderPassBeginInfo - { - using NativeType = VkDeviceGroupRenderPassBeginInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupRenderPassBeginInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_ = {}, - uint32_t deviceRenderAreaCount_ = {}, - const Rect2D * pDeviceRenderAreas_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceMask{ deviceMask_ } - , deviceRenderAreaCount{ deviceRenderAreaCount_ } - , pDeviceRenderAreas{ pDeviceRenderAreas_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceGroupRenderPassBeginInfo( DeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceGroupRenderPassBeginInfo( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceGroupRenderPassBeginInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceGroupRenderPassBeginInfo( uint32_t deviceMask_, ArrayProxyNoTemporaries const & deviceRenderAreas_, const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , deviceMask( deviceMask_ ) - , deviceRenderAreaCount( static_cast( deviceRenderAreas_.size() ) ) - , pDeviceRenderAreas( deviceRenderAreas_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DeviceGroupRenderPassBeginInfo & operator=( DeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceGroupRenderPassBeginInfo & operator=( VkDeviceGroupRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT - { - deviceMask = deviceMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT - { - deviceMask = deviceMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo & setDeviceRenderAreaCount( uint32_t deviceRenderAreaCount_ ) & VULKAN_HPP_NOEXCEPT - { - deviceRenderAreaCount = deviceRenderAreaCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo && setDeviceRenderAreaCount( uint32_t deviceRenderAreaCount_ ) && VULKAN_HPP_NOEXCEPT - { - deviceRenderAreaCount = deviceRenderAreaCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo & setPDeviceRenderAreas( const Rect2D * pDeviceRenderAreas_ ) & VULKAN_HPP_NOEXCEPT - { - pDeviceRenderAreas = pDeviceRenderAreas_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupRenderPassBeginInfo && setPDeviceRenderAreas( const Rect2D * pDeviceRenderAreas_ ) && VULKAN_HPP_NOEXCEPT - { - pDeviceRenderAreas = pDeviceRenderAreas_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceGroupRenderPassBeginInfo & setDeviceRenderAreas( ArrayProxyNoTemporaries const & deviceRenderAreas_ ) VULKAN_HPP_NOEXCEPT - { - deviceRenderAreaCount = static_cast( deviceRenderAreas_.size() ); - pDeviceRenderAreas = deviceRenderAreas_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceGroupRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupRenderPassBeginInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceGroupRenderPassBeginInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceMask, deviceRenderAreaCount, pDeviceRenderAreas ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceGroupRenderPassBeginInfo const & ) const = default; -#else - bool operator==( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMask == rhs.deviceMask ) && ( deviceRenderAreaCount == rhs.deviceRenderAreaCount ) && - ( pDeviceRenderAreas == rhs.pDeviceRenderAreas ); -# endif - } - - bool operator!=( DeviceGroupRenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceGroupRenderPassBeginInfo; - const void * pNext = {}; - uint32_t deviceMask = {}; - uint32_t deviceRenderAreaCount = {}; - const Rect2D * pDeviceRenderAreas = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceGroupRenderPassBeginInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceGroupRenderPassBeginInfo; - }; - - using DeviceGroupRenderPassBeginInfoKHR = DeviceGroupRenderPassBeginInfo; - - // wrapper struct for struct VkDeviceGroupSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupSubmitInfo.html - struct DeviceGroupSubmitInfo - { - using NativeType = VkDeviceGroupSubmitInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupSubmitInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( uint32_t waitSemaphoreCount_ = {}, - const uint32_t * pWaitSemaphoreDeviceIndices_ = {}, - uint32_t commandBufferCount_ = {}, - const uint32_t * pCommandBufferDeviceMasks_ = {}, - uint32_t signalSemaphoreCount_ = {}, - const uint32_t * pSignalSemaphoreDeviceIndices_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , waitSemaphoreCount{ waitSemaphoreCount_ } - , pWaitSemaphoreDeviceIndices{ pWaitSemaphoreDeviceIndices_ } - , commandBufferCount{ commandBufferCount_ } - , pCommandBufferDeviceMasks{ pCommandBufferDeviceMasks_ } - , signalSemaphoreCount{ signalSemaphoreCount_ } - , pSignalSemaphoreDeviceIndices{ pSignalSemaphoreDeviceIndices_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceGroupSubmitInfo( DeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceGroupSubmitInfo( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceGroupSubmitInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceGroupSubmitInfo( ArrayProxyNoTemporaries const & waitSemaphoreDeviceIndices_, - ArrayProxyNoTemporaries const & commandBufferDeviceMasks_ = {}, - ArrayProxyNoTemporaries const & signalSemaphoreDeviceIndices_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , waitSemaphoreCount( static_cast( waitSemaphoreDeviceIndices_.size() ) ) - , pWaitSemaphoreDeviceIndices( waitSemaphoreDeviceIndices_.data() ) - , commandBufferCount( static_cast( commandBufferDeviceMasks_.size() ) ) - , pCommandBufferDeviceMasks( commandBufferDeviceMasks_.data() ) - , signalSemaphoreCount( static_cast( signalSemaphoreDeviceIndices_.size() ) ) - , pSignalSemaphoreDeviceIndices( signalSemaphoreDeviceIndices_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DeviceGroupSubmitInfo & operator=( DeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceGroupSubmitInfo & operator=( VkDeviceGroupSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = waitSemaphoreCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setPWaitSemaphoreDeviceIndices( const uint32_t * pWaitSemaphoreDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setPWaitSemaphoreDeviceIndices( const uint32_t * pWaitSemaphoreDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pWaitSemaphoreDeviceIndices = pWaitSemaphoreDeviceIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceGroupSubmitInfo & setWaitSemaphoreDeviceIndices( ArrayProxyNoTemporaries const & waitSemaphoreDeviceIndices_ ) VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = static_cast( waitSemaphoreDeviceIndices_.size() ); - pWaitSemaphoreDeviceIndices = waitSemaphoreDeviceIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setCommandBufferCount( uint32_t commandBufferCount_ ) & VULKAN_HPP_NOEXCEPT - { - commandBufferCount = commandBufferCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setCommandBufferCount( uint32_t commandBufferCount_ ) && VULKAN_HPP_NOEXCEPT - { - commandBufferCount = commandBufferCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setPCommandBufferDeviceMasks( const uint32_t * pCommandBufferDeviceMasks_ ) & VULKAN_HPP_NOEXCEPT - { - pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setPCommandBufferDeviceMasks( const uint32_t * pCommandBufferDeviceMasks_ ) && VULKAN_HPP_NOEXCEPT - { - pCommandBufferDeviceMasks = pCommandBufferDeviceMasks_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceGroupSubmitInfo & setCommandBufferDeviceMasks( ArrayProxyNoTemporaries const & commandBufferDeviceMasks_ ) VULKAN_HPP_NOEXCEPT - { - commandBufferCount = static_cast( commandBufferDeviceMasks_.size() ); - pCommandBufferDeviceMasks = commandBufferDeviceMasks_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT - { - signalSemaphoreCount = signalSemaphoreCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT - { - signalSemaphoreCount = signalSemaphoreCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo & setPSignalSemaphoreDeviceIndices( const uint32_t * pSignalSemaphoreDeviceIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSubmitInfo && setPSignalSemaphoreDeviceIndices( const uint32_t * pSignalSemaphoreDeviceIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pSignalSemaphoreDeviceIndices = pSignalSemaphoreDeviceIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DeviceGroupSubmitInfo & setSignalSemaphoreDeviceIndices( ArrayProxyNoTemporaries const & signalSemaphoreDeviceIndices_ ) VULKAN_HPP_NOEXCEPT - { - signalSemaphoreCount = static_cast( signalSemaphoreDeviceIndices_.size() ); - pSignalSemaphoreDeviceIndices = signalSemaphoreDeviceIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceGroupSubmitInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupSubmitInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupSubmitInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceGroupSubmitInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - waitSemaphoreCount, - pWaitSemaphoreDeviceIndices, - commandBufferCount, - pCommandBufferDeviceMasks, - signalSemaphoreCount, - pSignalSemaphoreDeviceIndices ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceGroupSubmitInfo const & ) const = default; -#else - bool operator==( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && - ( pWaitSemaphoreDeviceIndices == rhs.pWaitSemaphoreDeviceIndices ) && ( commandBufferCount == rhs.commandBufferCount ) && - ( pCommandBufferDeviceMasks == rhs.pCommandBufferDeviceMasks ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && - ( pSignalSemaphoreDeviceIndices == rhs.pSignalSemaphoreDeviceIndices ); -# endif - } - - bool operator!=( DeviceGroupSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceGroupSubmitInfo; - const void * pNext = {}; - uint32_t waitSemaphoreCount = {}; - const uint32_t * pWaitSemaphoreDeviceIndices = {}; - uint32_t commandBufferCount = {}; - const uint32_t * pCommandBufferDeviceMasks = {}; - uint32_t signalSemaphoreCount = {}; - const uint32_t * pSignalSemaphoreDeviceIndices = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceGroupSubmitInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceGroupSubmitInfo; - }; - - using DeviceGroupSubmitInfoKHR = DeviceGroupSubmitInfo; - - // wrapper struct for struct VkDeviceGroupSwapchainCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceGroupSwapchainCreateInfoKHR.html - struct DeviceGroupSwapchainCreateInfoKHR - { - using NativeType = VkDeviceGroupSwapchainCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( DeviceGroupPresentModeFlagsKHR modes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , modes{ modes_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceGroupSwapchainCreateInfoKHR( DeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceGroupSwapchainCreateInfoKHR( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceGroupSwapchainCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - DeviceGroupSwapchainCreateInfoKHR & operator=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceGroupSwapchainCreateInfoKHR & operator=( VkDeviceGroupSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSwapchainCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSwapchainCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSwapchainCreateInfoKHR & setModes( DeviceGroupPresentModeFlagsKHR modes_ ) & VULKAN_HPP_NOEXCEPT - { - modes = modes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceGroupSwapchainCreateInfoKHR && setModes( DeviceGroupPresentModeFlagsKHR modes_ ) && VULKAN_HPP_NOEXCEPT - { - modes = modes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceGroupSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceGroupSwapchainCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceGroupSwapchainCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, modes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceGroupSwapchainCreateInfoKHR const & ) const = default; -#else - bool operator==( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( modes == rhs.modes ); -# endif - } - - bool operator!=( DeviceGroupSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceGroupSwapchainCreateInfoKHR; - const void * pNext = {}; - DeviceGroupPresentModeFlagsKHR modes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceGroupSwapchainCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceGroupSwapchainCreateInfoKHR; - }; - - // wrapper struct for struct VkImageCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCreateInfo.html - struct ImageCreateInfo - { - using NativeType = VkImageCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageCreateInfo( ImageCreateFlags flags_ = {}, - ImageType imageType_ = ImageType::e1D, - Format format_ = Format::eUndefined, - Extent3D extent_ = {}, - uint32_t mipLevels_ = {}, - uint32_t arrayLayers_ = {}, - SampleCountFlagBits samples_ = SampleCountFlagBits::e1, - ImageTiling tiling_ = ImageTiling::eOptimal, - ImageUsageFlags usage_ = {}, - SharingMode sharingMode_ = SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = {}, - const uint32_t * pQueueFamilyIndices_ = {}, - ImageLayout initialLayout_ = ImageLayout::eUndefined, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , imageType{ imageType_ } - , format{ format_ } - , extent{ extent_ } - , mipLevels{ mipLevels_ } - , arrayLayers{ arrayLayers_ } - , samples{ samples_ } - , tiling{ tiling_ } - , usage{ usage_ } - , sharingMode{ sharingMode_ } - , queueFamilyIndexCount{ queueFamilyIndexCount_ } - , pQueueFamilyIndices{ pQueueFamilyIndices_ } - , initialLayout{ initialLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageCreateInfo( ImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageCreateInfo( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : ImageCreateInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageCreateInfo( ImageCreateFlags flags_, - ImageType imageType_, - Format format_, - Extent3D extent_, - uint32_t mipLevels_, - uint32_t arrayLayers_, - SampleCountFlagBits samples_, - ImageTiling tiling_, - ImageUsageFlags usage_, - SharingMode sharingMode_, - ArrayProxyNoTemporaries const & queueFamilyIndices_, - ImageLayout initialLayout_ = ImageLayout::eUndefined, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , imageType( imageType_ ) - , format( format_ ) - , extent( extent_ ) - , mipLevels( mipLevels_ ) - , arrayLayers( arrayLayers_ ) - , samples( samples_ ) - , tiling( tiling_ ) - , usage( usage_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( static_cast( queueFamilyIndices_.size() ) ) - , pQueueFamilyIndices( queueFamilyIndices_.data() ) - , initialLayout( initialLayout_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ImageCreateInfo & operator=( ImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageCreateInfo & operator=( VkImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setFlags( ImageCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setFlags( ImageCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setImageType( ImageType imageType_ ) & VULKAN_HPP_NOEXCEPT - { - imageType = imageType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setImageType( ImageType imageType_ ) && VULKAN_HPP_NOEXCEPT - { - imageType = imageType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setMipLevels( uint32_t mipLevels_ ) & VULKAN_HPP_NOEXCEPT - { - mipLevels = mipLevels_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setMipLevels( uint32_t mipLevels_ ) && VULKAN_HPP_NOEXCEPT - { - mipLevels = mipLevels_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setArrayLayers( uint32_t arrayLayers_ ) & VULKAN_HPP_NOEXCEPT - { - arrayLayers = arrayLayers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setArrayLayers( uint32_t arrayLayers_ ) && VULKAN_HPP_NOEXCEPT - { - arrayLayers = arrayLayers_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setSamples( SampleCountFlagBits samples_ ) & VULKAN_HPP_NOEXCEPT - { - samples = samples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setSamples( SampleCountFlagBits samples_ ) && VULKAN_HPP_NOEXCEPT - { - samples = samples_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setTiling( ImageTiling tiling_ ) & VULKAN_HPP_NOEXCEPT - { - tiling = tiling_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setTiling( ImageTiling tiling_ ) && VULKAN_HPP_NOEXCEPT - { - tiling = tiling_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setUsage( ImageUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setUsage( ImageUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setSharingMode( SharingMode sharingMode_ ) & VULKAN_HPP_NOEXCEPT - { - sharingMode = sharingMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setSharingMode( SharingMode sharingMode_ ) && VULKAN_HPP_NOEXCEPT - { - sharingMode = sharingMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) & VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) && VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageCreateInfo & setQueueFamilyIndices( ArrayProxyNoTemporaries const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = static_cast( queueFamilyIndices_.size() ); - pQueueFamilyIndices = queueFamilyIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo & setInitialLayout( ImageLayout initialLayout_ ) & VULKAN_HPP_NOEXCEPT - { - initialLayout = initialLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCreateInfo && setInitialLayout( ImageLayout initialLayout_ ) && VULKAN_HPP_NOEXCEPT - { - initialLayout = initialLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - imageType, - format, - extent, - mipLevels, - arrayLayers, - samples, - tiling, - usage, - sharingMode, - queueFamilyIndexCount, - pQueueFamilyIndices, - initialLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageCreateInfo const & ) const = default; -#else - bool operator==( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( imageType == rhs.imageType ) && ( format == rhs.format ) && - ( extent == rhs.extent ) && ( mipLevels == rhs.mipLevels ) && ( arrayLayers == rhs.arrayLayers ) && ( samples == rhs.samples ) && - ( tiling == rhs.tiling ) && ( usage == rhs.usage ) && ( sharingMode == rhs.sharingMode ) && - ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && - ( initialLayout == rhs.initialLayout ); -# endif - } - - bool operator!=( ImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageCreateInfo; - const void * pNext = {}; - ImageCreateFlags flags = {}; - ImageType imageType = ImageType::e1D; - Format format = Format::eUndefined; - Extent3D extent = {}; - uint32_t mipLevels = {}; - uint32_t arrayLayers = {}; - SampleCountFlagBits samples = SampleCountFlagBits::e1; - ImageTiling tiling = ImageTiling::eOptimal; - ImageUsageFlags usage = {}; - SharingMode sharingMode = SharingMode::eExclusive; - uint32_t queueFamilyIndexCount = {}; - const uint32_t * pQueueFamilyIndices = {}; - ImageLayout initialLayout = ImageLayout::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ImageCreateInfo; - }; - - // wrapper struct for struct VkDeviceImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceImageMemoryRequirements.html - struct DeviceImageMemoryRequirements - { - using NativeType = VkDeviceImageMemoryRequirements; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceImageMemoryRequirements; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceImageMemoryRequirements( const ImageCreateInfo * pCreateInfo_ = {}, - ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pCreateInfo{ pCreateInfo_ } - , planeAspect{ planeAspect_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceImageMemoryRequirements( DeviceImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceImageMemoryRequirements( VkDeviceImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceImageMemoryRequirements( *reinterpret_cast( &rhs ) ) - { - } - - DeviceImageMemoryRequirements & operator=( DeviceImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceImageMemoryRequirements & operator=( VkDeviceImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements & setPCreateInfo( const ImageCreateInfo * pCreateInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pCreateInfo = pCreateInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements && setPCreateInfo( const ImageCreateInfo * pCreateInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pCreateInfo = pCreateInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements & setPlaneAspect( ImageAspectFlagBits planeAspect_ ) & VULKAN_HPP_NOEXCEPT - { - planeAspect = planeAspect_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceImageMemoryRequirements && setPlaneAspect( ImageAspectFlagBits planeAspect_ ) && VULKAN_HPP_NOEXCEPT - { - planeAspect = planeAspect_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceImageMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceImageMemoryRequirements &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceImageMemoryRequirements const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceImageMemoryRequirements *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pCreateInfo, planeAspect ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceImageMemoryRequirements const & ) const = default; -#else - bool operator==( DeviceImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) && ( planeAspect == rhs.planeAspect ); -# endif - } - - bool operator!=( DeviceImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceImageMemoryRequirements; - const void * pNext = {}; - const ImageCreateInfo * pCreateInfo = {}; - ImageAspectFlagBits planeAspect = ImageAspectFlagBits::eColor; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceImageMemoryRequirements; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceImageMemoryRequirements; - }; - - using DeviceImageMemoryRequirementsKHR = DeviceImageMemoryRequirements; - - // wrapper struct for struct VkImageSubresource2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSubresource2.html - struct ImageSubresource2 - { - using NativeType = VkImageSubresource2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageSubresource2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageSubresource2( ImageSubresource imageSubresource_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageSubresource{ imageSubresource_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageSubresource2( ImageSubresource2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageSubresource2( VkImageSubresource2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageSubresource2( *reinterpret_cast( &rhs ) ) {} - - ImageSubresource2 & operator=( ImageSubresource2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageSubresource2 & operator=( VkImageSubresource2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageSubresource2 & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresource2 && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresource2 & setImageSubresource( ImageSubresource const & imageSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSubresource2 && setImageSubresource( ImageSubresource const & imageSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - imageSubresource = imageSubresource_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageSubresource2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSubresource2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSubresource2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageSubresource2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageSubresource ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageSubresource2 const & ) const = default; -#else - bool operator==( ImageSubresource2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageSubresource == rhs.imageSubresource ); -# endif - } - - bool operator!=( ImageSubresource2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageSubresource2; - void * pNext = {}; - ImageSubresource imageSubresource = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageSubresource2; - }; -#endif - - template <> - struct CppType - { - using Type = ImageSubresource2; - }; - - using ImageSubresource2EXT = ImageSubresource2; - using ImageSubresource2KHR = ImageSubresource2; - - // wrapper struct for struct VkDeviceImageSubresourceInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceImageSubresourceInfo.html - struct DeviceImageSubresourceInfo - { - using NativeType = VkDeviceImageSubresourceInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceImageSubresourceInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceImageSubresourceInfo( const ImageCreateInfo * pCreateInfo_ = {}, - const ImageSubresource2 * pSubresource_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pCreateInfo{ pCreateInfo_ } - , pSubresource{ pSubresource_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceImageSubresourceInfo( DeviceImageSubresourceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceImageSubresourceInfo( VkDeviceImageSubresourceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceImageSubresourceInfo( *reinterpret_cast( &rhs ) ) - { - } - - DeviceImageSubresourceInfo & operator=( DeviceImageSubresourceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceImageSubresourceInfo & operator=( VkDeviceImageSubresourceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo & setPCreateInfo( const ImageCreateInfo * pCreateInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pCreateInfo = pCreateInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo && setPCreateInfo( const ImageCreateInfo * pCreateInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pCreateInfo = pCreateInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo & setPSubresource( const ImageSubresource2 * pSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - pSubresource = pSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceImageSubresourceInfo && setPSubresource( const ImageSubresource2 * pSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - pSubresource = pSubresource_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceImageSubresourceInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceImageSubresourceInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceImageSubresourceInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceImageSubresourceInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pCreateInfo, pSubresource ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceImageSubresourceInfo const & ) const = default; -#else - bool operator==( DeviceImageSubresourceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ) && ( pSubresource == rhs.pSubresource ); -# endif - } - - bool operator!=( DeviceImageSubresourceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceImageSubresourceInfo; - const void * pNext = {}; - const ImageCreateInfo * pCreateInfo = {}; - const ImageSubresource2 * pSubresource = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceImageSubresourceInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceImageSubresourceInfo; - }; - - using DeviceImageSubresourceInfoKHR = DeviceImageSubresourceInfo; - - // wrapper struct for struct VkDeviceMemoryOpaqueCaptureAddressInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryOpaqueCaptureAddressInfo.html - struct DeviceMemoryOpaqueCaptureAddressInfo - { - using NativeType = VkDeviceMemoryOpaqueCaptureAddressInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryOpaqueCaptureAddressInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceMemoryOpaqueCaptureAddressInfo( DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memory{ memory_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceMemoryOpaqueCaptureAddressInfo( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceMemoryOpaqueCaptureAddressInfo( VkDeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceMemoryOpaqueCaptureAddressInfo( *reinterpret_cast( &rhs ) ) - { - } - - DeviceMemoryOpaqueCaptureAddressInfo & operator=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceMemoryOpaqueCaptureAddressInfo & operator=( VkDeviceMemoryOpaqueCaptureAddressInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOpaqueCaptureAddressInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOpaqueCaptureAddressInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOpaqueCaptureAddressInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOpaqueCaptureAddressInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceMemoryOpaqueCaptureAddressInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceMemoryOpaqueCaptureAddressInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceMemoryOpaqueCaptureAddressInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceMemoryOpaqueCaptureAddressInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memory ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceMemoryOpaqueCaptureAddressInfo const & ) const = default; -#else - bool operator==( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); -# endif - } - - bool operator!=( DeviceMemoryOpaqueCaptureAddressInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceMemoryOpaqueCaptureAddressInfo; - const void * pNext = {}; - DeviceMemory memory = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceMemoryOpaqueCaptureAddressInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceMemoryOpaqueCaptureAddressInfo; - }; - - using DeviceMemoryOpaqueCaptureAddressInfoKHR = DeviceMemoryOpaqueCaptureAddressInfo; - - // wrapper struct for struct VkDeviceMemoryOverallocationCreateInfoAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceMemoryOverallocationCreateInfoAMD.html - struct DeviceMemoryOverallocationCreateInfoAMD - { - using NativeType = VkDeviceMemoryOverallocationCreateInfoAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - DeviceMemoryOverallocationCreateInfoAMD( MemoryOverallocationBehaviorAMD overallocationBehavior_ = MemoryOverallocationBehaviorAMD::eDefault, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , overallocationBehavior{ overallocationBehavior_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceMemoryOverallocationCreateInfoAMD( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceMemoryOverallocationCreateInfoAMD( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceMemoryOverallocationCreateInfoAMD( *reinterpret_cast( &rhs ) ) - { - } - - DeviceMemoryOverallocationCreateInfoAMD & operator=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceMemoryOverallocationCreateInfoAMD & operator=( VkDeviceMemoryOverallocationCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOverallocationCreateInfoAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOverallocationCreateInfoAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOverallocationCreateInfoAMD & setOverallocationBehavior( MemoryOverallocationBehaviorAMD overallocationBehavior_ ) & - VULKAN_HPP_NOEXCEPT - { - overallocationBehavior = overallocationBehavior_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceMemoryOverallocationCreateInfoAMD && setOverallocationBehavior( MemoryOverallocationBehaviorAMD overallocationBehavior_ ) && - VULKAN_HPP_NOEXCEPT - { - overallocationBehavior = overallocationBehavior_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceMemoryOverallocationCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceMemoryOverallocationCreateInfoAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceMemoryOverallocationCreateInfoAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceMemoryOverallocationCreateInfoAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, overallocationBehavior ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceMemoryOverallocationCreateInfoAMD const & ) const = default; -#else - bool operator==( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( overallocationBehavior == rhs.overallocationBehavior ); -# endif - } - - bool operator!=( DeviceMemoryOverallocationCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceMemoryOverallocationCreateInfoAMD; - const void * pNext = {}; - MemoryOverallocationBehaviorAMD overallocationBehavior = MemoryOverallocationBehaviorAMD::eDefault; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceMemoryOverallocationCreateInfoAMD; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceMemoryOverallocationCreateInfoAMD; - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - union DeviceOrHostAddressConstAMDX - { - using NativeType = VkDeviceOrHostAddressConstAMDX; -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX( DeviceAddress deviceAddress_ = {} ) : deviceAddress( deviceAddress_ ) {} - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX( const void * hostAddress_ ) : hostAddress( hostAddress_ ) {} -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX & setHostAddress( const void * hostAddress_ ) & VULKAN_HPP_NOEXCEPT - { - hostAddress = hostAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceOrHostAddressConstAMDX && setHostAddress( const void * hostAddress_ ) && VULKAN_HPP_NOEXCEPT - { - hostAddress = hostAddress_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceOrHostAddressConstAMDX const &() const - { - return *reinterpret_cast( this ); - } - - operator VkDeviceOrHostAddressConstAMDX &() - { - return *reinterpret_cast( this ); - } - -# ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - DeviceAddress deviceAddress; - const void * hostAddress; -# else - VkDeviceAddress deviceAddress; - const void * hostAddress; -# endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceOrHostAddressConstAMDX; - }; -# endif -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkDevicePipelineBinaryInternalCacheControlKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDevicePipelineBinaryInternalCacheControlKHR.html - struct DevicePipelineBinaryInternalCacheControlKHR - { - using NativeType = VkDevicePipelineBinaryInternalCacheControlKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDevicePipelineBinaryInternalCacheControlKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DevicePipelineBinaryInternalCacheControlKHR( Bool32 disableInternalCache_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , disableInternalCache{ disableInternalCache_ } - { - } - - VULKAN_HPP_CONSTEXPR DevicePipelineBinaryInternalCacheControlKHR( DevicePipelineBinaryInternalCacheControlKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DevicePipelineBinaryInternalCacheControlKHR( VkDevicePipelineBinaryInternalCacheControlKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DevicePipelineBinaryInternalCacheControlKHR( *reinterpret_cast( &rhs ) ) - { - } - - DevicePipelineBinaryInternalCacheControlKHR & operator=( DevicePipelineBinaryInternalCacheControlKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DevicePipelineBinaryInternalCacheControlKHR & operator=( VkDevicePipelineBinaryInternalCacheControlKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DevicePipelineBinaryInternalCacheControlKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DevicePipelineBinaryInternalCacheControlKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DevicePipelineBinaryInternalCacheControlKHR & setDisableInternalCache( Bool32 disableInternalCache_ ) & VULKAN_HPP_NOEXCEPT - { - disableInternalCache = disableInternalCache_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DevicePipelineBinaryInternalCacheControlKHR && setDisableInternalCache( Bool32 disableInternalCache_ ) && VULKAN_HPP_NOEXCEPT - { - disableInternalCache = disableInternalCache_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDevicePipelineBinaryInternalCacheControlKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDevicePipelineBinaryInternalCacheControlKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDevicePipelineBinaryInternalCacheControlKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDevicePipelineBinaryInternalCacheControlKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, disableInternalCache ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DevicePipelineBinaryInternalCacheControlKHR const & ) const = default; -#else - bool operator==( DevicePipelineBinaryInternalCacheControlKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( disableInternalCache == rhs.disableInternalCache ); -# endif - } - - bool operator!=( DevicePipelineBinaryInternalCacheControlKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDevicePipelineBinaryInternalCacheControlKHR; - const void * pNext = {}; - Bool32 disableInternalCache = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DevicePipelineBinaryInternalCacheControlKHR; - }; -#endif - - template <> - struct CppType - { - using Type = DevicePipelineBinaryInternalCacheControlKHR; - }; - - // wrapper struct for struct VkDevicePrivateDataCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDevicePrivateDataCreateInfo.html - struct DevicePrivateDataCreateInfo - { - using NativeType = VkDevicePrivateDataCreateInfo; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDevicePrivateDataCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DevicePrivateDataCreateInfo( uint32_t privateDataSlotRequestCount_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , privateDataSlotRequestCount{ privateDataSlotRequestCount_ } - { - } - - VULKAN_HPP_CONSTEXPR DevicePrivateDataCreateInfo( DevicePrivateDataCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DevicePrivateDataCreateInfo( VkDevicePrivateDataCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DevicePrivateDataCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - DevicePrivateDataCreateInfo & operator=( DevicePrivateDataCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DevicePrivateDataCreateInfo & operator=( VkDevicePrivateDataCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DevicePrivateDataCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DevicePrivateDataCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DevicePrivateDataCreateInfo & setPrivateDataSlotRequestCount( uint32_t privateDataSlotRequestCount_ ) & VULKAN_HPP_NOEXCEPT - { - privateDataSlotRequestCount = privateDataSlotRequestCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DevicePrivateDataCreateInfo && setPrivateDataSlotRequestCount( uint32_t privateDataSlotRequestCount_ ) && VULKAN_HPP_NOEXCEPT - { - privateDataSlotRequestCount = privateDataSlotRequestCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDevicePrivateDataCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDevicePrivateDataCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDevicePrivateDataCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDevicePrivateDataCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, privateDataSlotRequestCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DevicePrivateDataCreateInfo const & ) const = default; -#else - bool operator==( DevicePrivateDataCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateDataSlotRequestCount == rhs.privateDataSlotRequestCount ); -# endif - } - - bool operator!=( DevicePrivateDataCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDevicePrivateDataCreateInfo; - const void * pNext = {}; - uint32_t privateDataSlotRequestCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DevicePrivateDataCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DevicePrivateDataCreateInfo; - }; - - using DevicePrivateDataCreateInfoEXT = DevicePrivateDataCreateInfo; - - // wrapper struct for struct VkDeviceQueueGlobalPriorityCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueGlobalPriorityCreateInfo.html - struct DeviceQueueGlobalPriorityCreateInfo - { - using NativeType = VkDeviceQueueGlobalPriorityCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueGlobalPriorityCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfo( QueueGlobalPriority globalPriority_ = QueueGlobalPriority::eLow, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , globalPriority{ globalPriority_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceQueueGlobalPriorityCreateInfo( DeviceQueueGlobalPriorityCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceQueueGlobalPriorityCreateInfo( VkDeviceQueueGlobalPriorityCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceQueueGlobalPriorityCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - DeviceQueueGlobalPriorityCreateInfo & operator=( DeviceQueueGlobalPriorityCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceQueueGlobalPriorityCreateInfo & operator=( VkDeviceQueueGlobalPriorityCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceQueueGlobalPriorityCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueGlobalPriorityCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueGlobalPriorityCreateInfo & setGlobalPriority( QueueGlobalPriority globalPriority_ ) & VULKAN_HPP_NOEXCEPT - { - globalPriority = globalPriority_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueGlobalPriorityCreateInfo && setGlobalPriority( QueueGlobalPriority globalPriority_ ) && VULKAN_HPP_NOEXCEPT - { - globalPriority = globalPriority_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceQueueGlobalPriorityCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceQueueGlobalPriorityCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceQueueGlobalPriorityCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceQueueGlobalPriorityCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, globalPriority ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceQueueGlobalPriorityCreateInfo const & ) const = default; -#else - bool operator==( DeviceQueueGlobalPriorityCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriority == rhs.globalPriority ); -# endif - } - - bool operator!=( DeviceQueueGlobalPriorityCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceQueueGlobalPriorityCreateInfo; - const void * pNext = {}; - QueueGlobalPriority globalPriority = QueueGlobalPriority::eLow; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceQueueGlobalPriorityCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceQueueGlobalPriorityCreateInfo; - }; - - using DeviceQueueGlobalPriorityCreateInfoEXT = DeviceQueueGlobalPriorityCreateInfo; - using DeviceQueueGlobalPriorityCreateInfoKHR = DeviceQueueGlobalPriorityCreateInfo; - - // wrapper struct for struct VkDeviceQueueInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueInfo2.html - struct DeviceQueueInfo2 - { - using NativeType = VkDeviceQueueInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( DeviceQueueCreateFlags flags_ = {}, - uint32_t queueFamilyIndex_ = {}, - uint32_t queueIndex_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , queueFamilyIndex{ queueFamilyIndex_ } - , queueIndex{ queueIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceQueueInfo2( DeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceQueueInfo2( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : DeviceQueueInfo2( *reinterpret_cast( &rhs ) ) {} - - DeviceQueueInfo2 & operator=( DeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceQueueInfo2 & operator=( VkDeviceQueueInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 & setFlags( DeviceQueueCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 && setFlags( DeviceQueueCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 & setQueueIndex( uint32_t queueIndex_ ) & VULKAN_HPP_NOEXCEPT - { - queueIndex = queueIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueInfo2 && setQueueIndex( uint32_t queueIndex_ ) && VULKAN_HPP_NOEXCEPT - { - queueIndex = queueIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceQueueInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceQueueInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceQueueInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceQueueInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, queueFamilyIndex, queueIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceQueueInfo2 const & ) const = default; -#else - bool operator==( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && - ( queueIndex == rhs.queueIndex ); -# endif - } - - bool operator!=( DeviceQueueInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceQueueInfo2; - const void * pNext = {}; - DeviceQueueCreateFlags flags = {}; - uint32_t queueFamilyIndex = {}; - uint32_t queueIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceQueueInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceQueueInfo2; - }; - - // wrapper struct for struct VkDeviceQueueShaderCoreControlCreateInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceQueueShaderCoreControlCreateInfoARM.html - struct DeviceQueueShaderCoreControlCreateInfoARM - { - using NativeType = VkDeviceQueueShaderCoreControlCreateInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceQueueShaderCoreControlCreateInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceQueueShaderCoreControlCreateInfoARM( uint32_t shaderCoreCount_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderCoreCount{ shaderCoreCount_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceQueueShaderCoreControlCreateInfoARM( DeviceQueueShaderCoreControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceQueueShaderCoreControlCreateInfoARM( VkDeviceQueueShaderCoreControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceQueueShaderCoreControlCreateInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - DeviceQueueShaderCoreControlCreateInfoARM & operator=( DeviceQueueShaderCoreControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceQueueShaderCoreControlCreateInfoARM & operator=( VkDeviceQueueShaderCoreControlCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceQueueShaderCoreControlCreateInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueShaderCoreControlCreateInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueShaderCoreControlCreateInfoARM & setShaderCoreCount( uint32_t shaderCoreCount_ ) & VULKAN_HPP_NOEXCEPT - { - shaderCoreCount = shaderCoreCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceQueueShaderCoreControlCreateInfoARM && setShaderCoreCount( uint32_t shaderCoreCount_ ) && VULKAN_HPP_NOEXCEPT - { - shaderCoreCount = shaderCoreCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceQueueShaderCoreControlCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceQueueShaderCoreControlCreateInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceQueueShaderCoreControlCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceQueueShaderCoreControlCreateInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderCoreCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceQueueShaderCoreControlCreateInfoARM const & ) const = default; -#else - bool operator==( DeviceQueueShaderCoreControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreCount == rhs.shaderCoreCount ); -# endif - } - - bool operator!=( DeviceQueueShaderCoreControlCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceQueueShaderCoreControlCreateInfoARM; - void * pNext = {}; - uint32_t shaderCoreCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceQueueShaderCoreControlCreateInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceQueueShaderCoreControlCreateInfoARM; - }; - - // wrapper struct for struct VkTensorDescriptionARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorDescriptionARM.html - struct TensorDescriptionARM - { - using NativeType = VkTensorDescriptionARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorDescriptionARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TensorDescriptionARM( TensorTilingARM tiling_ = TensorTilingARM::eOptimal, - Format format_ = Format::eUndefined, - uint32_t dimensionCount_ = {}, - const int64_t * pDimensions_ = {}, - const int64_t * pStrides_ = {}, - TensorUsageFlagsARM usage_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tiling{ tiling_ } - , format{ format_ } - , dimensionCount{ dimensionCount_ } - , pDimensions{ pDimensions_ } - , pStrides{ pStrides_ } - , usage{ usage_ } - { - } - - VULKAN_HPP_CONSTEXPR TensorDescriptionARM( TensorDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TensorDescriptionARM( VkTensorDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT - : TensorDescriptionARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TensorDescriptionARM( TensorTilingARM tiling_, - Format format_, - ArrayProxyNoTemporaries const & dimensions_, - ArrayProxyNoTemporaries const & strides_ = {}, - TensorUsageFlagsARM usage_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , tiling( tiling_ ) - , format( format_ ) - , dimensionCount( static_cast( dimensions_.size() ) ) - , pDimensions( dimensions_.data() ) - , pStrides( strides_.data() ) - , usage( usage_ ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( strides_.empty() || ( dimensions_.size() == strides_.size() ) ); -# else - if ( !strides_.empty() && ( dimensions_.size() != strides_.size() ) ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::TensorDescriptionARM::TensorDescriptionARM: !strides_.empty() && ( dimensions_.size() != strides_.size() )" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - TensorDescriptionARM & operator=( TensorDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TensorDescriptionARM & operator=( VkTensorDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setTiling( TensorTilingARM tiling_ ) & VULKAN_HPP_NOEXCEPT - { - tiling = tiling_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setTiling( TensorTilingARM tiling_ ) && VULKAN_HPP_NOEXCEPT - { - tiling = tiling_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setDimensionCount( uint32_t dimensionCount_ ) & VULKAN_HPP_NOEXCEPT - { - dimensionCount = dimensionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setDimensionCount( uint32_t dimensionCount_ ) && VULKAN_HPP_NOEXCEPT - { - dimensionCount = dimensionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setPDimensions( const int64_t * pDimensions_ ) & VULKAN_HPP_NOEXCEPT - { - pDimensions = pDimensions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setPDimensions( const int64_t * pDimensions_ ) && VULKAN_HPP_NOEXCEPT - { - pDimensions = pDimensions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TensorDescriptionARM & setDimensions( ArrayProxyNoTemporaries const & dimensions_ ) VULKAN_HPP_NOEXCEPT - { - dimensionCount = static_cast( dimensions_.size() ); - pDimensions = dimensions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setPStrides( const int64_t * pStrides_ ) & VULKAN_HPP_NOEXCEPT - { - pStrides = pStrides_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setPStrides( const int64_t * pStrides_ ) && VULKAN_HPP_NOEXCEPT - { - pStrides = pStrides_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TensorDescriptionARM & setStrides( ArrayProxyNoTemporaries const & strides_ ) VULKAN_HPP_NOEXCEPT - { - dimensionCount = static_cast( strides_.size() ); - pStrides = strides_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM & setUsage( TensorUsageFlagsARM usage_ ) & VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorDescriptionARM && setUsage( TensorUsageFlagsARM usage_ ) && VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTensorDescriptionARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorDescriptionARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorDescriptionARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTensorDescriptionARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tiling, format, dimensionCount, pDimensions, pStrides, usage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TensorDescriptionARM const & ) const = default; -#else - bool operator==( TensorDescriptionARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tiling == rhs.tiling ) && ( format == rhs.format ) && - ( dimensionCount == rhs.dimensionCount ) && ( pDimensions == rhs.pDimensions ) && ( pStrides == rhs.pStrides ) && ( usage == rhs.usage ); -# endif - } - - bool operator!=( TensorDescriptionARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTensorDescriptionARM; - const void * pNext = {}; - TensorTilingARM tiling = TensorTilingARM::eOptimal; - Format format = Format::eUndefined; - uint32_t dimensionCount = {}; - const int64_t * pDimensions = {}; - const int64_t * pStrides = {}; - TensorUsageFlagsARM usage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TensorDescriptionARM; - }; -#endif - - template <> - struct CppType - { - using Type = TensorDescriptionARM; - }; - - // wrapper struct for struct VkTensorCreateInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCreateInfoARM.html - struct TensorCreateInfoARM - { - using NativeType = VkTensorCreateInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorCreateInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TensorCreateInfoARM( TensorCreateFlagsARM flags_ = {}, - const TensorDescriptionARM * pDescription_ = {}, - SharingMode sharingMode_ = SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = {}, - const uint32_t * pQueueFamilyIndices_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pDescription{ pDescription_ } - , sharingMode{ sharingMode_ } - , queueFamilyIndexCount{ queueFamilyIndexCount_ } - , pQueueFamilyIndices{ pQueueFamilyIndices_ } - { - } - - VULKAN_HPP_CONSTEXPR TensorCreateInfoARM( TensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TensorCreateInfoARM( VkTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT : TensorCreateInfoARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TensorCreateInfoARM( TensorCreateFlagsARM flags_, - const TensorDescriptionARM * pDescription_, - SharingMode sharingMode_, - ArrayProxyNoTemporaries const & queueFamilyIndices_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , pDescription( pDescription_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( static_cast( queueFamilyIndices_.size() ) ) - , pQueueFamilyIndices( queueFamilyIndices_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - TensorCreateInfoARM & operator=( TensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TensorCreateInfoARM & operator=( VkTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setFlags( TensorCreateFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setFlags( TensorCreateFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setPDescription( const TensorDescriptionARM * pDescription_ ) & VULKAN_HPP_NOEXCEPT - { - pDescription = pDescription_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setPDescription( const TensorDescriptionARM * pDescription_ ) && VULKAN_HPP_NOEXCEPT - { - pDescription = pDescription_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setSharingMode( SharingMode sharingMode_ ) & VULKAN_HPP_NOEXCEPT - { - sharingMode = sharingMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setSharingMode( SharingMode sharingMode_ ) && VULKAN_HPP_NOEXCEPT - { - sharingMode = sharingMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) & VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) && VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM & setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCreateInfoARM && setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TensorCreateInfoARM & setQueueFamilyIndices( ArrayProxyNoTemporaries const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = static_cast( queueFamilyIndices_.size() ); - pQueueFamilyIndices = queueFamilyIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTensorCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorCreateInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTensorCreateInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, pDescription, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TensorCreateInfoARM const & ) const = default; -#else - bool operator==( TensorCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pDescription == rhs.pDescription ) && - ( sharingMode == rhs.sharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); -# endif - } - - bool operator!=( TensorCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTensorCreateInfoARM; - const void * pNext = {}; - TensorCreateFlagsARM flags = {}; - const TensorDescriptionARM * pDescription = {}; - SharingMode sharingMode = SharingMode::eExclusive; - uint32_t queueFamilyIndexCount = {}; - const uint32_t * pQueueFamilyIndices = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TensorCreateInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = TensorCreateInfoARM; - }; - - // wrapper struct for struct VkDeviceTensorMemoryRequirementsARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDeviceTensorMemoryRequirementsARM.html - struct DeviceTensorMemoryRequirementsARM - { - using NativeType = VkDeviceTensorMemoryRequirementsARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDeviceTensorMemoryRequirementsARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DeviceTensorMemoryRequirementsARM( const TensorCreateInfoARM * pCreateInfo_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pCreateInfo{ pCreateInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR DeviceTensorMemoryRequirementsARM( DeviceTensorMemoryRequirementsARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DeviceTensorMemoryRequirementsARM( VkDeviceTensorMemoryRequirementsARM const & rhs ) VULKAN_HPP_NOEXCEPT - : DeviceTensorMemoryRequirementsARM( *reinterpret_cast( &rhs ) ) - { - } - - DeviceTensorMemoryRequirementsARM & operator=( DeviceTensorMemoryRequirementsARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DeviceTensorMemoryRequirementsARM & operator=( VkDeviceTensorMemoryRequirementsARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DeviceTensorMemoryRequirementsARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceTensorMemoryRequirementsARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DeviceTensorMemoryRequirementsARM & setPCreateInfo( const TensorCreateInfoARM * pCreateInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pCreateInfo = pCreateInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DeviceTensorMemoryRequirementsARM && setPCreateInfo( const TensorCreateInfoARM * pCreateInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pCreateInfo = pCreateInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDeviceTensorMemoryRequirementsARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceTensorMemoryRequirementsARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDeviceTensorMemoryRequirementsARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDeviceTensorMemoryRequirementsARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pCreateInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DeviceTensorMemoryRequirementsARM const & ) const = default; -#else - bool operator==( DeviceTensorMemoryRequirementsARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pCreateInfo == rhs.pCreateInfo ); -# endif - } - - bool operator!=( DeviceTensorMemoryRequirementsARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDeviceTensorMemoryRequirementsARM; - const void * pNext = {}; - const TensorCreateInfoARM * pCreateInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DeviceTensorMemoryRequirementsARM; - }; -#endif - - template <> - struct CppType - { - using Type = DeviceTensorMemoryRequirementsARM; - }; - - typedef PFN_vkVoidFunction( VKAPI_PTR * PFN_GetInstanceProcAddrLUNARG )( Instance instance, const char * pName ); - - // wrapper struct for struct VkDirectDriverLoadingInfoLUNARG, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectDriverLoadingInfoLUNARG.html - struct DirectDriverLoadingInfoLUNARG - { - using NativeType = VkDirectDriverLoadingInfoLUNARG; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDirectDriverLoadingInfoLUNARG; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DirectDriverLoadingInfoLUNARG( DirectDriverLoadingFlagsLUNARG flags_ = {}, - PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pfnGetInstanceProcAddr{ pfnGetInstanceProcAddr_ } - { - } - - VULKAN_HPP_CONSTEXPR DirectDriverLoadingInfoLUNARG( DirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DirectDriverLoadingInfoLUNARG( VkDirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT - : DirectDriverLoadingInfoLUNARG( *reinterpret_cast( &rhs ) ) - { - } - - DirectDriverLoadingInfoLUNARG & operator=( DirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DirectDriverLoadingInfoLUNARG & operator=( VkDirectDriverLoadingInfoLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG & setFlags( DirectDriverLoadingFlagsLUNARG flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG && setFlags( DirectDriverLoadingFlagsLUNARG flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG & setPfnGetInstanceProcAddr( PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ ) & - VULKAN_HPP_NOEXCEPT - { - pfnGetInstanceProcAddr = pfnGetInstanceProcAddr_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingInfoLUNARG && setPfnGetInstanceProcAddr( PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr_ ) && - VULKAN_HPP_NOEXCEPT - { - pfnGetInstanceProcAddr = pfnGetInstanceProcAddr_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDirectDriverLoadingInfoLUNARG const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDirectDriverLoadingInfoLUNARG &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDirectDriverLoadingInfoLUNARG const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDirectDriverLoadingInfoLUNARG *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, pfnGetInstanceProcAddr ); - } -#endif - - bool operator==( DirectDriverLoadingInfoLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT - { -#if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -#else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pfnGetInstanceProcAddr == rhs.pfnGetInstanceProcAddr ); -#endif - } - - bool operator!=( DirectDriverLoadingInfoLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDirectDriverLoadingInfoLUNARG; - void * pNext = {}; - DirectDriverLoadingFlagsLUNARG flags = {}; - PFN_GetInstanceProcAddrLUNARG pfnGetInstanceProcAddr = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DirectDriverLoadingInfoLUNARG; - }; -#endif - - template <> - struct CppType - { - using Type = DirectDriverLoadingInfoLUNARG; - }; - - // wrapper struct for struct VkDirectDriverLoadingListLUNARG, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectDriverLoadingListLUNARG.html - struct DirectDriverLoadingListLUNARG - { - using NativeType = VkDirectDriverLoadingListLUNARG; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDirectDriverLoadingListLUNARG; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DirectDriverLoadingListLUNARG( DirectDriverLoadingModeLUNARG mode_ = DirectDriverLoadingModeLUNARG::eExclusive, - uint32_t driverCount_ = {}, - const DirectDriverLoadingInfoLUNARG * pDrivers_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , mode{ mode_ } - , driverCount{ driverCount_ } - , pDrivers{ pDrivers_ } - { - } - - VULKAN_HPP_CONSTEXPR DirectDriverLoadingListLUNARG( DirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DirectDriverLoadingListLUNARG( VkDirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT - : DirectDriverLoadingListLUNARG( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DirectDriverLoadingListLUNARG( DirectDriverLoadingModeLUNARG mode_, - ArrayProxyNoTemporaries const & drivers_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), mode( mode_ ), driverCount( static_cast( drivers_.size() ) ), pDrivers( drivers_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - DirectDriverLoadingListLUNARG & operator=( DirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DirectDriverLoadingListLUNARG & operator=( VkDirectDriverLoadingListLUNARG const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG & setMode( DirectDriverLoadingModeLUNARG mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG && setMode( DirectDriverLoadingModeLUNARG mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG & setDriverCount( uint32_t driverCount_ ) & VULKAN_HPP_NOEXCEPT - { - driverCount = driverCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG && setDriverCount( uint32_t driverCount_ ) && VULKAN_HPP_NOEXCEPT - { - driverCount = driverCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG & setPDrivers( const DirectDriverLoadingInfoLUNARG * pDrivers_ ) & VULKAN_HPP_NOEXCEPT - { - pDrivers = pDrivers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DirectDriverLoadingListLUNARG && setPDrivers( const DirectDriverLoadingInfoLUNARG * pDrivers_ ) && VULKAN_HPP_NOEXCEPT - { - pDrivers = pDrivers_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - DirectDriverLoadingListLUNARG & setDrivers( ArrayProxyNoTemporaries const & drivers_ ) VULKAN_HPP_NOEXCEPT - { - driverCount = static_cast( drivers_.size() ); - pDrivers = drivers_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDirectDriverLoadingListLUNARG const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDirectDriverLoadingListLUNARG &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDirectDriverLoadingListLUNARG const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDirectDriverLoadingListLUNARG *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, mode, driverCount, pDrivers ); - } -#endif - - bool operator==( DirectDriverLoadingListLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT - { -#if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -#else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && ( driverCount == rhs.driverCount ) && ( pDrivers == rhs.pDrivers ); -#endif - } - - bool operator!=( DirectDriverLoadingListLUNARG const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eDirectDriverLoadingListLUNARG; - const void * pNext = {}; - DirectDriverLoadingModeLUNARG mode = DirectDriverLoadingModeLUNARG::eExclusive; - uint32_t driverCount = {}; - const DirectDriverLoadingInfoLUNARG * pDrivers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DirectDriverLoadingListLUNARG; - }; -#endif - - template <> - struct CppType - { - using Type = DirectDriverLoadingListLUNARG; - }; - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - // wrapper struct for struct VkDirectFBSurfaceCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDirectFBSurfaceCreateInfoEXT.html - struct DirectFBSurfaceCreateInfoEXT - { - using NativeType = VkDirectFBSurfaceCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDirectfbSurfaceCreateInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DirectFBSurfaceCreateInfoEXT( DirectFBSurfaceCreateFlagsEXT flags_ = {}, - IDirectFB * dfb_ = {}, - IDirectFBSurface * surface_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , dfb{ dfb_ } - , surface{ surface_ } - { - } - - VULKAN_HPP_CONSTEXPR DirectFBSurfaceCreateInfoEXT( DirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DirectFBSurfaceCreateInfoEXT( VkDirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DirectFBSurfaceCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - DirectFBSurfaceCreateInfoEXT & operator=( DirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DirectFBSurfaceCreateInfoEXT & operator=( VkDirectFBSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT & setFlags( DirectFBSurfaceCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT && setFlags( DirectFBSurfaceCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT & setDfb( IDirectFB * dfb_ ) & VULKAN_HPP_NOEXCEPT - { - dfb = dfb_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT && setDfb( IDirectFB * dfb_ ) && VULKAN_HPP_NOEXCEPT - { - dfb = dfb_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT & setSurface( IDirectFBSurface * surface_ ) & VULKAN_HPP_NOEXCEPT - { - surface = surface_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DirectFBSurfaceCreateInfoEXT && setSurface( IDirectFBSurface * surface_ ) && VULKAN_HPP_NOEXCEPT - { - surface = surface_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDirectFBSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDirectFBSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDirectFBSurfaceCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDirectFBSurfaceCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, dfb, surface ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DirectFBSurfaceCreateInfoEXT const & ) const = default; -# else - bool operator==( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dfb == rhs.dfb ) && ( surface == rhs.surface ); -# endif - } - - bool operator!=( DirectFBSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eDirectfbSurfaceCreateInfoEXT; - const void * pNext = {}; - DirectFBSurfaceCreateFlagsEXT flags = {}; - IDirectFB * dfb = {}; - IDirectFBSurface * surface = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DirectFBSurfaceCreateInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = DirectFBSurfaceCreateInfoEXT; - }; -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkDispatchGraphCountInfoAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDispatchGraphCountInfoAMDX.html - struct DispatchGraphCountInfoAMDX - { - using NativeType = VkDispatchGraphCountInfoAMDX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - DispatchGraphCountInfoAMDX( uint32_t count_ = {}, DeviceOrHostAddressConstAMDX infos_ = {}, uint64_t stride_ = {} ) VULKAN_HPP_NOEXCEPT - : count{ count_ } - , infos{ infos_ } - , stride{ stride_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX( DispatchGraphCountInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DispatchGraphCountInfoAMDX( VkDispatchGraphCountInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - : DispatchGraphCountInfoAMDX( *reinterpret_cast( &rhs ) ) - { - } - - DispatchGraphCountInfoAMDX & operator=( DispatchGraphCountInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DispatchGraphCountInfoAMDX & operator=( VkDispatchGraphCountInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX & setCount( uint32_t count_ ) & VULKAN_HPP_NOEXCEPT - { - count = count_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX && setCount( uint32_t count_ ) && VULKAN_HPP_NOEXCEPT - { - count = count_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX & setInfos( DeviceOrHostAddressConstAMDX const & infos_ ) & VULKAN_HPP_NOEXCEPT - { - infos = infos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX && setInfos( DeviceOrHostAddressConstAMDX const & infos_ ) && VULKAN_HPP_NOEXCEPT - { - infos = infos_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX & setStride( uint64_t stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphCountInfoAMDX && setStride( uint64_t stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDispatchGraphCountInfoAMDX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDispatchGraphCountInfoAMDX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDispatchGraphCountInfoAMDX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDispatchGraphCountInfoAMDX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( count, infos, stride ); - } -# endif - - public: - uint32_t count = {}; - DeviceOrHostAddressConstAMDX infos = {}; - uint64_t stride = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DispatchGraphCountInfoAMDX; - }; -# endif -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkDispatchGraphInfoAMDX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDispatchGraphInfoAMDX.html - struct DispatchGraphInfoAMDX - { - using NativeType = VkDispatchGraphInfoAMDX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX( uint32_t nodeIndex_ = {}, - uint32_t payloadCount_ = {}, - DeviceOrHostAddressConstAMDX payloads_ = {}, - uint64_t payloadStride_ = {} ) VULKAN_HPP_NOEXCEPT - : nodeIndex{ nodeIndex_ } - , payloadCount{ payloadCount_ } - , payloads{ payloads_ } - , payloadStride{ payloadStride_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX( DispatchGraphInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DispatchGraphInfoAMDX( VkDispatchGraphInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - : DispatchGraphInfoAMDX( *reinterpret_cast( &rhs ) ) - { - } - - DispatchGraphInfoAMDX & operator=( DispatchGraphInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DispatchGraphInfoAMDX & operator=( VkDispatchGraphInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX & setNodeIndex( uint32_t nodeIndex_ ) & VULKAN_HPP_NOEXCEPT - { - nodeIndex = nodeIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX && setNodeIndex( uint32_t nodeIndex_ ) && VULKAN_HPP_NOEXCEPT - { - nodeIndex = nodeIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX & setPayloadCount( uint32_t payloadCount_ ) & VULKAN_HPP_NOEXCEPT - { - payloadCount = payloadCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX && setPayloadCount( uint32_t payloadCount_ ) && VULKAN_HPP_NOEXCEPT - { - payloadCount = payloadCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX & setPayloads( DeviceOrHostAddressConstAMDX const & payloads_ ) & VULKAN_HPP_NOEXCEPT - { - payloads = payloads_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX && setPayloads( DeviceOrHostAddressConstAMDX const & payloads_ ) && VULKAN_HPP_NOEXCEPT - { - payloads = payloads_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX & setPayloadStride( uint64_t payloadStride_ ) & VULKAN_HPP_NOEXCEPT - { - payloadStride = payloadStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DispatchGraphInfoAMDX && setPayloadStride( uint64_t payloadStride_ ) && VULKAN_HPP_NOEXCEPT - { - payloadStride = payloadStride_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDispatchGraphInfoAMDX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDispatchGraphInfoAMDX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDispatchGraphInfoAMDX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDispatchGraphInfoAMDX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( nodeIndex, payloadCount, payloads, payloadStride ); - } -# endif - - public: - uint32_t nodeIndex = {}; - uint32_t payloadCount = {}; - DeviceOrHostAddressConstAMDX payloads = {}; - uint64_t payloadStride = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DispatchGraphInfoAMDX; - }; -# endif -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkDispatchIndirectCommand, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDispatchIndirectCommand.html - struct DispatchIndirectCommand - { - using NativeType = VkDispatchIndirectCommand; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DispatchIndirectCommand( uint32_t x_ = {}, uint32_t y_ = {}, uint32_t z_ = {} ) VULKAN_HPP_NOEXCEPT - : x{ x_ } - , y{ y_ } - , z{ z_ } - { - } - - VULKAN_HPP_CONSTEXPR DispatchIndirectCommand( DispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DispatchIndirectCommand( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT - : DispatchIndirectCommand( *reinterpret_cast( &rhs ) ) - { - } - - DispatchIndirectCommand & operator=( DispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DispatchIndirectCommand & operator=( VkDispatchIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand & setX( uint32_t x_ ) & VULKAN_HPP_NOEXCEPT - { - x = x_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand && setX( uint32_t x_ ) && VULKAN_HPP_NOEXCEPT - { - x = x_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand & setY( uint32_t y_ ) & VULKAN_HPP_NOEXCEPT - { - y = y_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand && setY( uint32_t y_ ) && VULKAN_HPP_NOEXCEPT - { - y = y_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand & setZ( uint32_t z_ ) & VULKAN_HPP_NOEXCEPT - { - z = z_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DispatchIndirectCommand && setZ( uint32_t z_ ) && VULKAN_HPP_NOEXCEPT - { - z = z_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDispatchIndirectCommand const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDispatchIndirectCommand &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDispatchIndirectCommand const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDispatchIndirectCommand *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( x, y, z ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DispatchIndirectCommand const & ) const = default; -#else - bool operator==( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ); -# endif - } - - bool operator!=( DispatchIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t x = {}; - uint32_t y = {}; - uint32_t z = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DispatchIndirectCommand; - }; -#endif - - // wrapper struct for struct VkDispatchTileInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDispatchTileInfoQCOM.html - struct DispatchTileInfoQCOM - { - using NativeType = VkDispatchTileInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDispatchTileInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DispatchTileInfoQCOM( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} - - VULKAN_HPP_CONSTEXPR DispatchTileInfoQCOM( DispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DispatchTileInfoQCOM( VkDispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : DispatchTileInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - DispatchTileInfoQCOM & operator=( DispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DispatchTileInfoQCOM & operator=( VkDispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DispatchTileInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DispatchTileInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDispatchTileInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDispatchTileInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDispatchTileInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDispatchTileInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DispatchTileInfoQCOM const & ) const = default; -#else - bool operator==( DispatchTileInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); -# endif - } - - bool operator!=( DispatchTileInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDispatchTileInfoQCOM; - const void * pNext = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DispatchTileInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = DispatchTileInfoQCOM; - }; - - // wrapper struct for struct VkDisplayEventInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayEventInfoEXT.html - struct DisplayEventInfoEXT - { - using NativeType = VkDisplayEventInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayEventInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( DisplayEventTypeEXT displayEvent_ = DisplayEventTypeEXT::eFirstPixelOut, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , displayEvent{ displayEvent_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayEventInfoEXT( DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayEventInfoEXT( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DisplayEventInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - DisplayEventInfoEXT & operator=( DisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayEventInfoEXT & operator=( VkDisplayEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DisplayEventInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayEventInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplayEventInfoEXT & setDisplayEvent( DisplayEventTypeEXT displayEvent_ ) & VULKAN_HPP_NOEXCEPT - { - displayEvent = displayEvent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayEventInfoEXT && setDisplayEvent( DisplayEventTypeEXT displayEvent_ ) && VULKAN_HPP_NOEXCEPT - { - displayEvent = displayEvent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDisplayEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayEventInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayEventInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayEventInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, displayEvent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayEventInfoEXT const & ) const = default; -#else - bool operator==( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayEvent == rhs.displayEvent ); -# endif - } - - bool operator!=( DisplayEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplayEventInfoEXT; - const void * pNext = {}; - DisplayEventTypeEXT displayEvent = DisplayEventTypeEXT::eFirstPixelOut; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayEventInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DisplayEventInfoEXT; - }; - - // wrapper struct for struct VkDisplayModeParametersKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeParametersKHR.html - struct DisplayModeParametersKHR - { - using NativeType = VkDisplayModeParametersKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( Extent2D visibleRegion_ = {}, uint32_t refreshRate_ = {} ) VULKAN_HPP_NOEXCEPT - : visibleRegion{ visibleRegion_ } - , refreshRate{ refreshRate_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayModeParametersKHR( DisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayModeParametersKHR( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayModeParametersKHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayModeParametersKHR & operator=( DisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayModeParametersKHR & operator=( VkDisplayModeParametersKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DisplayModeParametersKHR & setVisibleRegion( Extent2D const & visibleRegion_ ) & VULKAN_HPP_NOEXCEPT - { - visibleRegion = visibleRegion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayModeParametersKHR && setVisibleRegion( Extent2D const & visibleRegion_ ) && VULKAN_HPP_NOEXCEPT - { - visibleRegion = visibleRegion_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplayModeParametersKHR & setRefreshRate( uint32_t refreshRate_ ) & VULKAN_HPP_NOEXCEPT - { - refreshRate = refreshRate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayModeParametersKHR && setRefreshRate( uint32_t refreshRate_ ) && VULKAN_HPP_NOEXCEPT - { - refreshRate = refreshRate_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDisplayModeParametersKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayModeParametersKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayModeParametersKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayModeParametersKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( visibleRegion, refreshRate ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayModeParametersKHR const & ) const = default; -#else - bool operator==( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( visibleRegion == rhs.visibleRegion ) && ( refreshRate == rhs.refreshRate ); -# endif - } - - bool operator!=( DisplayModeParametersKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Extent2D visibleRegion = {}; - uint32_t refreshRate = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayModeParametersKHR; - }; -#endif - - // wrapper struct for struct VkDisplayModeCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeCreateInfoKHR.html - struct DisplayModeCreateInfoKHR - { - using NativeType = VkDisplayModeCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( DisplayModeCreateFlagsKHR flags_ = {}, - DisplayModeParametersKHR parameters_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , parameters{ parameters_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayModeCreateInfoKHR( DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayModeCreateInfoKHR( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayModeCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayModeCreateInfoKHR & operator=( DisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayModeCreateInfoKHR & operator=( VkDisplayModeCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR & setFlags( DisplayModeCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR && setFlags( DisplayModeCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR & setParameters( DisplayModeParametersKHR const & parameters_ ) & VULKAN_HPP_NOEXCEPT - { - parameters = parameters_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayModeCreateInfoKHR && setParameters( DisplayModeParametersKHR const & parameters_ ) && VULKAN_HPP_NOEXCEPT - { - parameters = parameters_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDisplayModeCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayModeCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayModeCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayModeCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, parameters ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayModeCreateInfoKHR const & ) const = default; -#else - bool operator==( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( parameters == rhs.parameters ); -# endif - } - - bool operator!=( DisplayModeCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplayModeCreateInfoKHR; - const void * pNext = {}; - DisplayModeCreateFlagsKHR flags = {}; - DisplayModeParametersKHR parameters = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayModeCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = DisplayModeCreateInfoKHR; - }; - - // wrapper struct for struct VkDisplayModePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModePropertiesKHR.html - struct DisplayModePropertiesKHR - { - using NativeType = VkDisplayModePropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayModePropertiesKHR( DisplayModeKHR displayMode_ = {}, DisplayModeParametersKHR parameters_ = {} ) VULKAN_HPP_NOEXCEPT - : displayMode{ displayMode_ } - , parameters{ parameters_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayModePropertiesKHR( DisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayModePropertiesKHR( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayModePropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayModePropertiesKHR & operator=( DisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayModePropertiesKHR & operator=( VkDisplayModePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDisplayModePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayModePropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayModePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayModePropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( displayMode, parameters ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayModePropertiesKHR const & ) const = default; -#else - bool operator==( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( displayMode == rhs.displayMode ) && ( parameters == rhs.parameters ); -# endif - } - - bool operator!=( DisplayModePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DisplayModeKHR displayMode = {}; - DisplayModeParametersKHR parameters = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayModePropertiesKHR; - }; -#endif - - // wrapper struct for struct VkDisplayModeProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeProperties2KHR.html - struct DisplayModeProperties2KHR - { - using NativeType = VkDisplayModeProperties2KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeProperties2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayModeProperties2KHR( DisplayModePropertiesKHR displayModeProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , displayModeProperties{ displayModeProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayModeProperties2KHR( DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayModeProperties2KHR( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayModeProperties2KHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayModeProperties2KHR & operator=( DisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayModeProperties2KHR & operator=( VkDisplayModeProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDisplayModeProperties2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayModeProperties2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayModeProperties2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayModeProperties2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, displayModeProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayModeProperties2KHR const & ) const = default; -#else - bool operator==( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayModeProperties == rhs.displayModeProperties ); -# endif - } - - bool operator!=( DisplayModeProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplayModeProperties2KHR; - void * pNext = {}; - DisplayModePropertiesKHR displayModeProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayModeProperties2KHR; - }; -#endif - - template <> - struct CppType - { - using Type = DisplayModeProperties2KHR; - }; - - // wrapper struct for struct VkDisplayModeStereoPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayModeStereoPropertiesNV.html - struct DisplayModeStereoPropertiesNV - { - using NativeType = VkDisplayModeStereoPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayModeStereoPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayModeStereoPropertiesNV( Bool32 hdmi3DSupported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , hdmi3DSupported{ hdmi3DSupported_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayModeStereoPropertiesNV( DisplayModeStereoPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayModeStereoPropertiesNV( VkDisplayModeStereoPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayModeStereoPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - DisplayModeStereoPropertiesNV & operator=( DisplayModeStereoPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayModeStereoPropertiesNV & operator=( VkDisplayModeStereoPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDisplayModeStereoPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayModeStereoPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayModeStereoPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayModeStereoPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, hdmi3DSupported ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayModeStereoPropertiesNV const & ) const = default; -#else - bool operator==( DisplayModeStereoPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hdmi3DSupported == rhs.hdmi3DSupported ); -# endif - } - - bool operator!=( DisplayModeStereoPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplayModeStereoPropertiesNV; - void * pNext = {}; - Bool32 hdmi3DSupported = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayModeStereoPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = DisplayModeStereoPropertiesNV; - }; - - // wrapper struct for struct VkDisplayNativeHdrSurfaceCapabilitiesAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayNativeHdrSurfaceCapabilitiesAMD.html - struct DisplayNativeHdrSurfaceCapabilitiesAMD - { - using NativeType = VkDisplayNativeHdrSurfaceCapabilitiesAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayNativeHdrSurfaceCapabilitiesAMD( Bool32 localDimmingSupport_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , localDimmingSupport{ localDimmingSupport_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayNativeHdrSurfaceCapabilitiesAMD( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayNativeHdrSurfaceCapabilitiesAMD( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayNativeHdrSurfaceCapabilitiesAMD( *reinterpret_cast( &rhs ) ) - { - } - - DisplayNativeHdrSurfaceCapabilitiesAMD & operator=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayNativeHdrSurfaceCapabilitiesAMD & operator=( VkDisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayNativeHdrSurfaceCapabilitiesAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayNativeHdrSurfaceCapabilitiesAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayNativeHdrSurfaceCapabilitiesAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, localDimmingSupport ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayNativeHdrSurfaceCapabilitiesAMD const & ) const = default; -#else - bool operator==( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingSupport == rhs.localDimmingSupport ); -# endif - } - - bool operator!=( DisplayNativeHdrSurfaceCapabilitiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD; - void * pNext = {}; - Bool32 localDimmingSupport = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayNativeHdrSurfaceCapabilitiesAMD; - }; -#endif - - template <> - struct CppType - { - using Type = DisplayNativeHdrSurfaceCapabilitiesAMD; - }; - - // wrapper struct for struct VkDisplayPlaneCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneCapabilitiesKHR.html - struct DisplayPlaneCapabilitiesKHR - { - using NativeType = VkDisplayPlaneCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilitiesKHR( DisplayPlaneAlphaFlagsKHR supportedAlpha_ = {}, - Offset2D minSrcPosition_ = {}, - Offset2D maxSrcPosition_ = {}, - Extent2D minSrcExtent_ = {}, - Extent2D maxSrcExtent_ = {}, - Offset2D minDstPosition_ = {}, - Offset2D maxDstPosition_ = {}, - Extent2D minDstExtent_ = {}, - Extent2D maxDstExtent_ = {} ) VULKAN_HPP_NOEXCEPT - : supportedAlpha{ supportedAlpha_ } - , minSrcPosition{ minSrcPosition_ } - , maxSrcPosition{ maxSrcPosition_ } - , minSrcExtent{ minSrcExtent_ } - , maxSrcExtent{ maxSrcExtent_ } - , minDstPosition{ minDstPosition_ } - , maxDstPosition{ maxDstPosition_ } - , minDstExtent{ minDstExtent_ } - , maxDstExtent{ maxDstExtent_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilitiesKHR( DisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayPlaneCapabilitiesKHR( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayPlaneCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayPlaneCapabilitiesKHR & operator=( DisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayPlaneCapabilitiesKHR & operator=( VkDisplayPlaneCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDisplayPlaneCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPlaneCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPlaneCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayPlaneCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( supportedAlpha, minSrcPosition, maxSrcPosition, minSrcExtent, maxSrcExtent, minDstPosition, maxDstPosition, minDstExtent, maxDstExtent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayPlaneCapabilitiesKHR const & ) const = default; -#else - bool operator==( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( supportedAlpha == rhs.supportedAlpha ) && ( minSrcPosition == rhs.minSrcPosition ) && ( maxSrcPosition == rhs.maxSrcPosition ) && - ( minSrcExtent == rhs.minSrcExtent ) && ( maxSrcExtent == rhs.maxSrcExtent ) && ( minDstPosition == rhs.minDstPosition ) && - ( maxDstPosition == rhs.maxDstPosition ) && ( minDstExtent == rhs.minDstExtent ) && ( maxDstExtent == rhs.maxDstExtent ); -# endif - } - - bool operator!=( DisplayPlaneCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DisplayPlaneAlphaFlagsKHR supportedAlpha = {}; - Offset2D minSrcPosition = {}; - Offset2D maxSrcPosition = {}; - Extent2D minSrcExtent = {}; - Extent2D maxSrcExtent = {}; - Offset2D minDstPosition = {}; - Offset2D maxDstPosition = {}; - Extent2D minDstExtent = {}; - Extent2D maxDstExtent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayPlaneCapabilitiesKHR; - }; -#endif - - // wrapper struct for struct VkDisplayPlaneCapabilities2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneCapabilities2KHR.html - struct DisplayPlaneCapabilities2KHR - { - using NativeType = VkDisplayPlaneCapabilities2KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneCapabilities2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilities2KHR( DisplayPlaneCapabilitiesKHR capabilities_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , capabilities{ capabilities_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayPlaneCapabilities2KHR( DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayPlaneCapabilities2KHR( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayPlaneCapabilities2KHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayPlaneCapabilities2KHR & operator=( DisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayPlaneCapabilities2KHR & operator=( VkDisplayPlaneCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDisplayPlaneCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPlaneCapabilities2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPlaneCapabilities2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayPlaneCapabilities2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, capabilities ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayPlaneCapabilities2KHR const & ) const = default; -#else - bool operator==( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( capabilities == rhs.capabilities ); -# endif - } - - bool operator!=( DisplayPlaneCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplayPlaneCapabilities2KHR; - void * pNext = {}; - DisplayPlaneCapabilitiesKHR capabilities = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayPlaneCapabilities2KHR; - }; -#endif - - template <> - struct CppType - { - using Type = DisplayPlaneCapabilities2KHR; - }; - - // wrapper struct for struct VkDisplayPlaneInfo2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneInfo2KHR.html - struct DisplayPlaneInfo2KHR - { - using NativeType = VkDisplayPlaneInfo2KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneInfo2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( DisplayModeKHR mode_ = {}, uint32_t planeIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , mode{ mode_ } - , planeIndex{ planeIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayPlaneInfo2KHR( DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayPlaneInfo2KHR( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayPlaneInfo2KHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayPlaneInfo2KHR & operator=( DisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayPlaneInfo2KHR & operator=( VkDisplayPlaneInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR & setMode( DisplayModeKHR mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR && setMode( DisplayModeKHR mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR & setPlaneIndex( uint32_t planeIndex_ ) & VULKAN_HPP_NOEXCEPT - { - planeIndex = planeIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPlaneInfo2KHR && setPlaneIndex( uint32_t planeIndex_ ) && VULKAN_HPP_NOEXCEPT - { - planeIndex = planeIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDisplayPlaneInfo2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPlaneInfo2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPlaneInfo2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayPlaneInfo2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, mode, planeIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayPlaneInfo2KHR const & ) const = default; -#else - bool operator==( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mode == rhs.mode ) && ( planeIndex == rhs.planeIndex ); -# endif - } - - bool operator!=( DisplayPlaneInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplayPlaneInfo2KHR; - const void * pNext = {}; - DisplayModeKHR mode = {}; - uint32_t planeIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayPlaneInfo2KHR; - }; -#endif - - template <> - struct CppType - { - using Type = DisplayPlaneInfo2KHR; - }; - - // wrapper struct for struct VkDisplayPlanePropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlanePropertiesKHR.html - struct DisplayPlanePropertiesKHR - { - using NativeType = VkDisplayPlanePropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayPlanePropertiesKHR( DisplayKHR currentDisplay_ = {}, uint32_t currentStackIndex_ = {} ) VULKAN_HPP_NOEXCEPT - : currentDisplay{ currentDisplay_ } - , currentStackIndex{ currentStackIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayPlanePropertiesKHR( DisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayPlanePropertiesKHR( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayPlanePropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayPlanePropertiesKHR & operator=( DisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayPlanePropertiesKHR & operator=( VkDisplayPlanePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDisplayPlanePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPlanePropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPlanePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayPlanePropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( currentDisplay, currentStackIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayPlanePropertiesKHR const & ) const = default; -#else - bool operator==( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( currentDisplay == rhs.currentDisplay ) && ( currentStackIndex == rhs.currentStackIndex ); -# endif - } - - bool operator!=( DisplayPlanePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DisplayKHR currentDisplay = {}; - uint32_t currentStackIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayPlanePropertiesKHR; - }; -#endif - - // wrapper struct for struct VkDisplayPlaneProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPlaneProperties2KHR.html - struct DisplayPlaneProperties2KHR - { - using NativeType = VkDisplayPlaneProperties2KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPlaneProperties2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayPlaneProperties2KHR( DisplayPlanePropertiesKHR displayPlaneProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , displayPlaneProperties{ displayPlaneProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayPlaneProperties2KHR( DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayPlaneProperties2KHR( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayPlaneProperties2KHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayPlaneProperties2KHR & operator=( DisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayPlaneProperties2KHR & operator=( VkDisplayPlaneProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDisplayPlaneProperties2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPlaneProperties2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPlaneProperties2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayPlaneProperties2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, displayPlaneProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayPlaneProperties2KHR const & ) const = default; -#else - bool operator==( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayPlaneProperties == rhs.displayPlaneProperties ); -# endif - } - - bool operator!=( DisplayPlaneProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplayPlaneProperties2KHR; - void * pNext = {}; - DisplayPlanePropertiesKHR displayPlaneProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayPlaneProperties2KHR; - }; -#endif - - template <> - struct CppType - { - using Type = DisplayPlaneProperties2KHR; - }; - - // wrapper struct for struct VkDisplayPowerInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPowerInfoEXT.html - struct DisplayPowerInfoEXT - { - using NativeType = VkDisplayPowerInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPowerInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( DisplayPowerStateEXT powerState_ = DisplayPowerStateEXT::eOff, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , powerState{ powerState_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayPowerInfoEXT( DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayPowerInfoEXT( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : DisplayPowerInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - DisplayPowerInfoEXT & operator=( DisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayPowerInfoEXT & operator=( VkDisplayPowerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DisplayPowerInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPowerInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPowerInfoEXT & setPowerState( DisplayPowerStateEXT powerState_ ) & VULKAN_HPP_NOEXCEPT - { - powerState = powerState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPowerInfoEXT && setPowerState( DisplayPowerStateEXT powerState_ ) && VULKAN_HPP_NOEXCEPT - { - powerState = powerState_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDisplayPowerInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPowerInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPowerInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayPowerInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, powerState ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayPowerInfoEXT const & ) const = default; -#else - bool operator==( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( powerState == rhs.powerState ); -# endif - } - - bool operator!=( DisplayPowerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplayPowerInfoEXT; - const void * pNext = {}; - DisplayPowerStateEXT powerState = DisplayPowerStateEXT::eOff; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayPowerInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DisplayPowerInfoEXT; - }; - - // wrapper struct for struct VkDisplayPresentInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPresentInfoKHR.html - struct DisplayPresentInfoKHR - { - using NativeType = VkDisplayPresentInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayPresentInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - DisplayPresentInfoKHR( Rect2D srcRect_ = {}, Rect2D dstRect_ = {}, Bool32 persistent_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcRect{ srcRect_ } - , dstRect{ dstRect_ } - , persistent{ persistent_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayPresentInfoKHR( DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayPresentInfoKHR( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayPresentInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayPresentInfoKHR & operator=( DisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayPresentInfoKHR & operator=( VkDisplayPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR & setSrcRect( Rect2D const & srcRect_ ) & VULKAN_HPP_NOEXCEPT - { - srcRect = srcRect_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR && setSrcRect( Rect2D const & srcRect_ ) && VULKAN_HPP_NOEXCEPT - { - srcRect = srcRect_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR & setDstRect( Rect2D const & dstRect_ ) & VULKAN_HPP_NOEXCEPT - { - dstRect = dstRect_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR && setDstRect( Rect2D const & dstRect_ ) && VULKAN_HPP_NOEXCEPT - { - dstRect = dstRect_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR & setPersistent( Bool32 persistent_ ) & VULKAN_HPP_NOEXCEPT - { - persistent = persistent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplayPresentInfoKHR && setPersistent( Bool32 persistent_ ) && VULKAN_HPP_NOEXCEPT - { - persistent = persistent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDisplayPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPresentInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPresentInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayPresentInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcRect, dstRect, persistent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayPresentInfoKHR const & ) const = default; -#else - bool operator==( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcRect == rhs.srcRect ) && ( dstRect == rhs.dstRect ) && ( persistent == rhs.persistent ); -# endif - } - - bool operator!=( DisplayPresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplayPresentInfoKHR; - const void * pNext = {}; - Rect2D srcRect = {}; - Rect2D dstRect = {}; - Bool32 persistent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayPresentInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = DisplayPresentInfoKHR; - }; - - // wrapper struct for struct VkDisplayPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayPropertiesKHR.html - struct DisplayPropertiesKHR - { - using NativeType = VkDisplayPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayPropertiesKHR( DisplayKHR display_ = {}, - const char * displayName_ = {}, - Extent2D physicalDimensions_ = {}, - Extent2D physicalResolution_ = {}, - SurfaceTransformFlagsKHR supportedTransforms_ = {}, - Bool32 planeReorderPossible_ = {}, - Bool32 persistentContent_ = {} ) VULKAN_HPP_NOEXCEPT - : display{ display_ } - , displayName{ displayName_ } - , physicalDimensions{ physicalDimensions_ } - , physicalResolution{ physicalResolution_ } - , supportedTransforms{ supportedTransforms_ } - , planeReorderPossible{ planeReorderPossible_ } - , persistentContent{ persistentContent_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayPropertiesKHR( DisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayPropertiesKHR( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayPropertiesKHR & operator=( DisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayPropertiesKHR & operator=( VkDisplayPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDisplayPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( display, displayName, physicalDimensions, physicalResolution, supportedTransforms, planeReorderPossible, persistentContent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = display <=> rhs.display; cmp != 0 ) - return cmp; - if ( displayName != rhs.displayName ) - if ( auto cmp = strcmp( displayName, rhs.displayName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = physicalDimensions <=> rhs.physicalDimensions; cmp != 0 ) - return cmp; - if ( auto cmp = physicalResolution <=> rhs.physicalResolution; cmp != 0 ) - return cmp; - if ( auto cmp = supportedTransforms <=> rhs.supportedTransforms; cmp != 0 ) - return cmp; - if ( auto cmp = planeReorderPossible <=> rhs.planeReorderPossible; cmp != 0 ) - return cmp; - if ( auto cmp = persistentContent <=> rhs.persistentContent; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( display == rhs.display ) && ( ( displayName == rhs.displayName ) || ( strcmp( displayName, rhs.displayName ) == 0 ) ) && - ( physicalDimensions == rhs.physicalDimensions ) && ( physicalResolution == rhs.physicalResolution ) && - ( supportedTransforms == rhs.supportedTransforms ) && ( planeReorderPossible == rhs.planeReorderPossible ) && - ( persistentContent == rhs.persistentContent ); - } - - bool operator!=( DisplayPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - DisplayKHR display = {}; - const char * displayName = {}; - Extent2D physicalDimensions = {}; - Extent2D physicalResolution = {}; - SurfaceTransformFlagsKHR supportedTransforms = {}; - Bool32 planeReorderPossible = {}; - Bool32 persistentContent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayPropertiesKHR; - }; -#endif - - // wrapper struct for struct VkDisplayProperties2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayProperties2KHR.html - struct DisplayProperties2KHR - { - using NativeType = VkDisplayProperties2KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplayProperties2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplayProperties2KHR( DisplayPropertiesKHR displayProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , displayProperties{ displayProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplayProperties2KHR( DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplayProperties2KHR( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplayProperties2KHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplayProperties2KHR & operator=( DisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplayProperties2KHR & operator=( VkDisplayProperties2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDisplayProperties2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayProperties2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplayProperties2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplayProperties2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, displayProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplayProperties2KHR const & ) const = default; -#else - bool operator==( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayProperties == rhs.displayProperties ); -# endif - } - - bool operator!=( DisplayProperties2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplayProperties2KHR; - void * pNext = {}; - DisplayPropertiesKHR displayProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplayProperties2KHR; - }; -#endif - - template <> - struct CppType - { - using Type = DisplayProperties2KHR; - }; - - // wrapper struct for struct VkDisplaySurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplaySurfaceCreateInfoKHR.html - struct DisplaySurfaceCreateInfoKHR - { - using NativeType = VkDisplaySurfaceCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplaySurfaceCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateFlagsKHR flags_ = {}, - DisplayModeKHR displayMode_ = {}, - uint32_t planeIndex_ = {}, - uint32_t planeStackIndex_ = {}, - SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, - float globalAlpha_ = {}, - DisplayPlaneAlphaFlagBitsKHR alphaMode_ = DisplayPlaneAlphaFlagBitsKHR::eOpaque, - Extent2D imageExtent_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , displayMode{ displayMode_ } - , planeIndex{ planeIndex_ } - , planeStackIndex{ planeStackIndex_ } - , transform{ transform_ } - , globalAlpha{ globalAlpha_ } - , alphaMode{ alphaMode_ } - , imageExtent{ imageExtent_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplaySurfaceCreateInfoKHR( DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplaySurfaceCreateInfoKHR( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplaySurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - DisplaySurfaceCreateInfoKHR & operator=( DisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplaySurfaceCreateInfoKHR & operator=( VkDisplaySurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setFlags( DisplaySurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setFlags( DisplaySurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setDisplayMode( DisplayModeKHR displayMode_ ) & VULKAN_HPP_NOEXCEPT - { - displayMode = displayMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setDisplayMode( DisplayModeKHR displayMode_ ) && VULKAN_HPP_NOEXCEPT - { - displayMode = displayMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setPlaneIndex( uint32_t planeIndex_ ) & VULKAN_HPP_NOEXCEPT - { - planeIndex = planeIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setPlaneIndex( uint32_t planeIndex_ ) && VULKAN_HPP_NOEXCEPT - { - planeIndex = planeIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setPlaneStackIndex( uint32_t planeStackIndex_ ) & VULKAN_HPP_NOEXCEPT - { - planeStackIndex = planeStackIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setPlaneStackIndex( uint32_t planeStackIndex_ ) && VULKAN_HPP_NOEXCEPT - { - planeStackIndex = planeStackIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setTransform( SurfaceTransformFlagBitsKHR transform_ ) & VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setTransform( SurfaceTransformFlagBitsKHR transform_ ) && VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setGlobalAlpha( float globalAlpha_ ) & VULKAN_HPP_NOEXCEPT - { - globalAlpha = globalAlpha_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setGlobalAlpha( float globalAlpha_ ) && VULKAN_HPP_NOEXCEPT - { - globalAlpha = globalAlpha_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ ) & VULKAN_HPP_NOEXCEPT - { - alphaMode = alphaMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setAlphaMode( DisplayPlaneAlphaFlagBitsKHR alphaMode_ ) && VULKAN_HPP_NOEXCEPT - { - alphaMode = alphaMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR & setImageExtent( Extent2D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceCreateInfoKHR && setImageExtent( Extent2D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDisplaySurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplaySurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplaySurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplaySurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, displayMode, planeIndex, planeStackIndex, transform, globalAlpha, alphaMode, imageExtent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplaySurfaceCreateInfoKHR const & ) const = default; -#else - bool operator==( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( displayMode == rhs.displayMode ) && - ( planeIndex == rhs.planeIndex ) && ( planeStackIndex == rhs.planeStackIndex ) && ( transform == rhs.transform ) && - ( globalAlpha == rhs.globalAlpha ) && ( alphaMode == rhs.alphaMode ) && ( imageExtent == rhs.imageExtent ); -# endif - } - - bool operator!=( DisplaySurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplaySurfaceCreateInfoKHR; - const void * pNext = {}; - DisplaySurfaceCreateFlagsKHR flags = {}; - DisplayModeKHR displayMode = {}; - uint32_t planeIndex = {}; - uint32_t planeStackIndex = {}; - SurfaceTransformFlagBitsKHR transform = SurfaceTransformFlagBitsKHR::eIdentity; - float globalAlpha = {}; - DisplayPlaneAlphaFlagBitsKHR alphaMode = DisplayPlaneAlphaFlagBitsKHR::eOpaque; - Extent2D imageExtent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplaySurfaceCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = DisplaySurfaceCreateInfoKHR; - }; - - // wrapper struct for struct VkDisplaySurfaceStereoCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplaySurfaceStereoCreateInfoNV.html - struct DisplaySurfaceStereoCreateInfoNV - { - using NativeType = VkDisplaySurfaceStereoCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDisplaySurfaceStereoCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DisplaySurfaceStereoCreateInfoNV( DisplaySurfaceStereoTypeNV stereoType_ = DisplaySurfaceStereoTypeNV::eNone, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stereoType{ stereoType_ } - { - } - - VULKAN_HPP_CONSTEXPR DisplaySurfaceStereoCreateInfoNV( DisplaySurfaceStereoCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DisplaySurfaceStereoCreateInfoNV( VkDisplaySurfaceStereoCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : DisplaySurfaceStereoCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - DisplaySurfaceStereoCreateInfoNV & operator=( DisplaySurfaceStereoCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DisplaySurfaceStereoCreateInfoNV & operator=( VkDisplaySurfaceStereoCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceStereoCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceStereoCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceStereoCreateInfoNV & setStereoType( DisplaySurfaceStereoTypeNV stereoType_ ) & VULKAN_HPP_NOEXCEPT - { - stereoType = stereoType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DisplaySurfaceStereoCreateInfoNV && setStereoType( DisplaySurfaceStereoTypeNV stereoType_ ) && VULKAN_HPP_NOEXCEPT - { - stereoType = stereoType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDisplaySurfaceStereoCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplaySurfaceStereoCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDisplaySurfaceStereoCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDisplaySurfaceStereoCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stereoType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DisplaySurfaceStereoCreateInfoNV const & ) const = default; -#else - bool operator==( DisplaySurfaceStereoCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stereoType == rhs.stereoType ); -# endif - } - - bool operator!=( DisplaySurfaceStereoCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDisplaySurfaceStereoCreateInfoNV; - const void * pNext = {}; - DisplaySurfaceStereoTypeNV stereoType = DisplaySurfaceStereoTypeNV::eNone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DisplaySurfaceStereoCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = DisplaySurfaceStereoCreateInfoNV; - }; - - // wrapper struct for struct VkDrawIndexedIndirectCommand, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawIndexedIndirectCommand.html - struct DrawIndexedIndirectCommand - { - using NativeType = VkDrawIndexedIndirectCommand; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DrawIndexedIndirectCommand( uint32_t indexCount_ = {}, - uint32_t instanceCount_ = {}, - uint32_t firstIndex_ = {}, - int32_t vertexOffset_ = {}, - uint32_t firstInstance_ = {} ) VULKAN_HPP_NOEXCEPT - : indexCount{ indexCount_ } - , instanceCount{ instanceCount_ } - , firstIndex{ firstIndex_ } - , vertexOffset{ vertexOffset_ } - , firstInstance{ firstInstance_ } - { - } - - VULKAN_HPP_CONSTEXPR DrawIndexedIndirectCommand( DrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DrawIndexedIndirectCommand( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT - : DrawIndexedIndirectCommand( *reinterpret_cast( &rhs ) ) - { - } - - DrawIndexedIndirectCommand & operator=( DrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DrawIndexedIndirectCommand & operator=( VkDrawIndexedIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand & setIndexCount( uint32_t indexCount_ ) & VULKAN_HPP_NOEXCEPT - { - indexCount = indexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand && setIndexCount( uint32_t indexCount_ ) && VULKAN_HPP_NOEXCEPT - { - indexCount = indexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand & setInstanceCount( uint32_t instanceCount_ ) & VULKAN_HPP_NOEXCEPT - { - instanceCount = instanceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand && setInstanceCount( uint32_t instanceCount_ ) && VULKAN_HPP_NOEXCEPT - { - instanceCount = instanceCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand & setFirstIndex( uint32_t firstIndex_ ) & VULKAN_HPP_NOEXCEPT - { - firstIndex = firstIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand && setFirstIndex( uint32_t firstIndex_ ) && VULKAN_HPP_NOEXCEPT - { - firstIndex = firstIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand & setVertexOffset( int32_t vertexOffset_ ) & VULKAN_HPP_NOEXCEPT - { - vertexOffset = vertexOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand && setVertexOffset( int32_t vertexOffset_ ) && VULKAN_HPP_NOEXCEPT - { - vertexOffset = vertexOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand & setFirstInstance( uint32_t firstInstance_ ) & VULKAN_HPP_NOEXCEPT - { - firstInstance = firstInstance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndexedIndirectCommand && setFirstInstance( uint32_t firstInstance_ ) && VULKAN_HPP_NOEXCEPT - { - firstInstance = firstInstance_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDrawIndexedIndirectCommand const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrawIndexedIndirectCommand &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrawIndexedIndirectCommand const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDrawIndexedIndirectCommand *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( indexCount, instanceCount, firstIndex, vertexOffset, firstInstance ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DrawIndexedIndirectCommand const & ) const = default; -#else - bool operator==( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( indexCount == rhs.indexCount ) && ( instanceCount == rhs.instanceCount ) && ( firstIndex == rhs.firstIndex ) && - ( vertexOffset == rhs.vertexOffset ) && ( firstInstance == rhs.firstInstance ); -# endif - } - - bool operator!=( DrawIndexedIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t indexCount = {}; - uint32_t instanceCount = {}; - uint32_t firstIndex = {}; - int32_t vertexOffset = {}; - uint32_t firstInstance = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DrawIndexedIndirectCommand; - }; -#endif - - // wrapper struct for struct VkDrawIndirectCommand, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawIndirectCommand.html - struct DrawIndirectCommand - { - using NativeType = VkDrawIndirectCommand; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DrawIndirectCommand( uint32_t vertexCount_ = {}, - uint32_t instanceCount_ = {}, - uint32_t firstVertex_ = {}, - uint32_t firstInstance_ = {} ) VULKAN_HPP_NOEXCEPT - : vertexCount{ vertexCount_ } - , instanceCount{ instanceCount_ } - , firstVertex{ firstVertex_ } - , firstInstance{ firstInstance_ } - { - } - - VULKAN_HPP_CONSTEXPR DrawIndirectCommand( DrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DrawIndirectCommand( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT : DrawIndirectCommand( *reinterpret_cast( &rhs ) ) - { - } - - DrawIndirectCommand & operator=( DrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DrawIndirectCommand & operator=( VkDrawIndirectCommand const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT - { - vertexCount = vertexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT - { - vertexCount = vertexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand & setInstanceCount( uint32_t instanceCount_ ) & VULKAN_HPP_NOEXCEPT - { - instanceCount = instanceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand && setInstanceCount( uint32_t instanceCount_ ) && VULKAN_HPP_NOEXCEPT - { - instanceCount = instanceCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand & setFirstVertex( uint32_t firstVertex_ ) & VULKAN_HPP_NOEXCEPT - { - firstVertex = firstVertex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand && setFirstVertex( uint32_t firstVertex_ ) && VULKAN_HPP_NOEXCEPT - { - firstVertex = firstVertex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand & setFirstInstance( uint32_t firstInstance_ ) & VULKAN_HPP_NOEXCEPT - { - firstInstance = firstInstance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCommand && setFirstInstance( uint32_t firstInstance_ ) && VULKAN_HPP_NOEXCEPT - { - firstInstance = firstInstance_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDrawIndirectCommand const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrawIndirectCommand &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrawIndirectCommand const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDrawIndirectCommand *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( vertexCount, instanceCount, firstVertex, firstInstance ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DrawIndirectCommand const & ) const = default; -#else - bool operator==( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( vertexCount == rhs.vertexCount ) && ( instanceCount == rhs.instanceCount ) && ( firstVertex == rhs.firstVertex ) && - ( firstInstance == rhs.firstInstance ); -# endif - } - - bool operator!=( DrawIndirectCommand const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t vertexCount = {}; - uint32_t instanceCount = {}; - uint32_t firstVertex = {}; - uint32_t firstInstance = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DrawIndirectCommand; - }; -#endif - - // wrapper struct for struct VkDrawIndirectCountIndirectCommandEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawIndirectCountIndirectCommandEXT.html - struct DrawIndirectCountIndirectCommandEXT - { - using NativeType = VkDrawIndirectCountIndirectCommandEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - DrawIndirectCountIndirectCommandEXT( DeviceAddress bufferAddress_ = {}, uint32_t stride_ = {}, uint32_t commandCount_ = {} ) VULKAN_HPP_NOEXCEPT - : bufferAddress{ bufferAddress_ } - , stride{ stride_ } - , commandCount{ commandCount_ } - { - } - - VULKAN_HPP_CONSTEXPR DrawIndirectCountIndirectCommandEXT( DrawIndirectCountIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DrawIndirectCountIndirectCommandEXT( VkDrawIndirectCountIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DrawIndirectCountIndirectCommandEXT( *reinterpret_cast( &rhs ) ) - { - } - - DrawIndirectCountIndirectCommandEXT & operator=( DrawIndirectCountIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DrawIndirectCountIndirectCommandEXT & operator=( VkDrawIndirectCountIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT & setBufferAddress( DeviceAddress bufferAddress_ ) & VULKAN_HPP_NOEXCEPT - { - bufferAddress = bufferAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT && setBufferAddress( DeviceAddress bufferAddress_ ) && VULKAN_HPP_NOEXCEPT - { - bufferAddress = bufferAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT & setCommandCount( uint32_t commandCount_ ) & VULKAN_HPP_NOEXCEPT - { - commandCount = commandCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawIndirectCountIndirectCommandEXT && setCommandCount( uint32_t commandCount_ ) && VULKAN_HPP_NOEXCEPT - { - commandCount = commandCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDrawIndirectCountIndirectCommandEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrawIndirectCountIndirectCommandEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrawIndirectCountIndirectCommandEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDrawIndirectCountIndirectCommandEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( bufferAddress, stride, commandCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DrawIndirectCountIndirectCommandEXT const & ) const = default; -#else - bool operator==( DrawIndirectCountIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( bufferAddress == rhs.bufferAddress ) && ( stride == rhs.stride ) && ( commandCount == rhs.commandCount ); -# endif - } - - bool operator!=( DrawIndirectCountIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress bufferAddress = {}; - uint32_t stride = {}; - uint32_t commandCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DrawIndirectCountIndirectCommandEXT; - }; -#endif - - // wrapper struct for struct VkDrawMeshTasksIndirectCommandEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawMeshTasksIndirectCommandEXT.html - struct DrawMeshTasksIndirectCommandEXT - { - using NativeType = VkDrawMeshTasksIndirectCommandEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - DrawMeshTasksIndirectCommandEXT( uint32_t groupCountX_ = {}, uint32_t groupCountY_ = {}, uint32_t groupCountZ_ = {} ) VULKAN_HPP_NOEXCEPT - : groupCountX{ groupCountX_ } - , groupCountY{ groupCountY_ } - , groupCountZ{ groupCountZ_ } - { - } - - VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandEXT( DrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DrawMeshTasksIndirectCommandEXT( VkDrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DrawMeshTasksIndirectCommandEXT( *reinterpret_cast( &rhs ) ) - { - } - - DrawMeshTasksIndirectCommandEXT & operator=( DrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DrawMeshTasksIndirectCommandEXT & operator=( VkDrawMeshTasksIndirectCommandEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT & setGroupCountX( uint32_t groupCountX_ ) & VULKAN_HPP_NOEXCEPT - { - groupCountX = groupCountX_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT && setGroupCountX( uint32_t groupCountX_ ) && VULKAN_HPP_NOEXCEPT - { - groupCountX = groupCountX_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT & setGroupCountY( uint32_t groupCountY_ ) & VULKAN_HPP_NOEXCEPT - { - groupCountY = groupCountY_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT && setGroupCountY( uint32_t groupCountY_ ) && VULKAN_HPP_NOEXCEPT - { - groupCountY = groupCountY_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT & setGroupCountZ( uint32_t groupCountZ_ ) & VULKAN_HPP_NOEXCEPT - { - groupCountZ = groupCountZ_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandEXT && setGroupCountZ( uint32_t groupCountZ_ ) && VULKAN_HPP_NOEXCEPT - { - groupCountZ = groupCountZ_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDrawMeshTasksIndirectCommandEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrawMeshTasksIndirectCommandEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrawMeshTasksIndirectCommandEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDrawMeshTasksIndirectCommandEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( groupCountX, groupCountY, groupCountZ ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DrawMeshTasksIndirectCommandEXT const & ) const = default; -#else - bool operator==( DrawMeshTasksIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( groupCountX == rhs.groupCountX ) && ( groupCountY == rhs.groupCountY ) && ( groupCountZ == rhs.groupCountZ ); -# endif - } - - bool operator!=( DrawMeshTasksIndirectCommandEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t groupCountX = {}; - uint32_t groupCountY = {}; - uint32_t groupCountZ = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DrawMeshTasksIndirectCommandEXT; - }; -#endif - - // wrapper struct for struct VkDrawMeshTasksIndirectCommandNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrawMeshTasksIndirectCommandNV.html - struct DrawMeshTasksIndirectCommandNV - { - using NativeType = VkDrawMeshTasksIndirectCommandNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandNV( uint32_t taskCount_ = {}, uint32_t firstTask_ = {} ) VULKAN_HPP_NOEXCEPT - : taskCount{ taskCount_ } - , firstTask{ firstTask_ } - { - } - - VULKAN_HPP_CONSTEXPR DrawMeshTasksIndirectCommandNV( DrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DrawMeshTasksIndirectCommandNV( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - : DrawMeshTasksIndirectCommandNV( *reinterpret_cast( &rhs ) ) - { - } - - DrawMeshTasksIndirectCommandNV & operator=( DrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DrawMeshTasksIndirectCommandNV & operator=( VkDrawMeshTasksIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandNV & setTaskCount( uint32_t taskCount_ ) & VULKAN_HPP_NOEXCEPT - { - taskCount = taskCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandNV && setTaskCount( uint32_t taskCount_ ) && VULKAN_HPP_NOEXCEPT - { - taskCount = taskCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandNV & setFirstTask( uint32_t firstTask_ ) & VULKAN_HPP_NOEXCEPT - { - firstTask = firstTask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 DrawMeshTasksIndirectCommandNV && setFirstTask( uint32_t firstTask_ ) && VULKAN_HPP_NOEXCEPT - { - firstTask = firstTask_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkDrawMeshTasksIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrawMeshTasksIndirectCommandNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrawMeshTasksIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDrawMeshTasksIndirectCommandNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( taskCount, firstTask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DrawMeshTasksIndirectCommandNV const & ) const = default; -#else - bool operator==( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( taskCount == rhs.taskCount ) && ( firstTask == rhs.firstTask ); -# endif - } - - bool operator!=( DrawMeshTasksIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t taskCount = {}; - uint32_t firstTask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DrawMeshTasksIndirectCommandNV; - }; -#endif - - // wrapper struct for struct VkDrmFormatModifierProperties2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrmFormatModifierProperties2EXT.html - struct DrmFormatModifierProperties2EXT - { - using NativeType = VkDrmFormatModifierProperties2EXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DrmFormatModifierProperties2EXT( uint64_t drmFormatModifier_ = {}, - uint32_t drmFormatModifierPlaneCount_ = {}, - FormatFeatureFlags2 drmFormatModifierTilingFeatures_ = {} ) VULKAN_HPP_NOEXCEPT - : drmFormatModifier{ drmFormatModifier_ } - , drmFormatModifierPlaneCount{ drmFormatModifierPlaneCount_ } - , drmFormatModifierTilingFeatures{ drmFormatModifierTilingFeatures_ } - { - } - - VULKAN_HPP_CONSTEXPR DrmFormatModifierProperties2EXT( DrmFormatModifierProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DrmFormatModifierProperties2EXT( VkDrmFormatModifierProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DrmFormatModifierProperties2EXT( *reinterpret_cast( &rhs ) ) - { - } - - DrmFormatModifierProperties2EXT & operator=( DrmFormatModifierProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DrmFormatModifierProperties2EXT & operator=( VkDrmFormatModifierProperties2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDrmFormatModifierProperties2EXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrmFormatModifierProperties2EXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrmFormatModifierProperties2EXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDrmFormatModifierProperties2EXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DrmFormatModifierProperties2EXT const & ) const = default; -#else - bool operator==( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( drmFormatModifier == rhs.drmFormatModifier ) && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && - ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures ); -# endif - } - - bool operator!=( DrmFormatModifierProperties2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint64_t drmFormatModifier = {}; - uint32_t drmFormatModifierPlaneCount = {}; - FormatFeatureFlags2 drmFormatModifierTilingFeatures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DrmFormatModifierProperties2EXT; - }; -#endif - - // wrapper struct for struct VkDrmFormatModifierPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrmFormatModifierPropertiesEXT.html - struct DrmFormatModifierPropertiesEXT - { - using NativeType = VkDrmFormatModifierPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = {}, - uint32_t drmFormatModifierPlaneCount_ = {}, - FormatFeatureFlags drmFormatModifierTilingFeatures_ = {} ) VULKAN_HPP_NOEXCEPT - : drmFormatModifier{ drmFormatModifier_ } - , drmFormatModifierPlaneCount{ drmFormatModifierPlaneCount_ } - , drmFormatModifierTilingFeatures{ drmFormatModifierTilingFeatures_ } - { - } - - VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesEXT( DrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DrmFormatModifierPropertiesEXT( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DrmFormatModifierPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - DrmFormatModifierPropertiesEXT & operator=( DrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DrmFormatModifierPropertiesEXT & operator=( VkDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrmFormatModifierPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDrmFormatModifierPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( drmFormatModifier, drmFormatModifierPlaneCount, drmFormatModifierTilingFeatures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DrmFormatModifierPropertiesEXT const & ) const = default; -#else - bool operator==( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( drmFormatModifier == rhs.drmFormatModifier ) && ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && - ( drmFormatModifierTilingFeatures == rhs.drmFormatModifierTilingFeatures ); -# endif - } - - bool operator!=( DrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint64_t drmFormatModifier = {}; - uint32_t drmFormatModifierPlaneCount = {}; - FormatFeatureFlags drmFormatModifierTilingFeatures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DrmFormatModifierPropertiesEXT; - }; -#endif - - // wrapper struct for struct VkDrmFormatModifierPropertiesList2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrmFormatModifierPropertiesList2EXT.html - struct DrmFormatModifierPropertiesList2EXT - { - using NativeType = VkDrmFormatModifierPropertiesList2EXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDrmFormatModifierPropertiesList2EXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesList2EXT( uint32_t drmFormatModifierCount_ = {}, - DrmFormatModifierProperties2EXT * pDrmFormatModifierProperties_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , drmFormatModifierCount{ drmFormatModifierCount_ } - , pDrmFormatModifierProperties{ pDrmFormatModifierProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesList2EXT( DrmFormatModifierPropertiesList2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DrmFormatModifierPropertiesList2EXT( VkDrmFormatModifierPropertiesList2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DrmFormatModifierPropertiesList2EXT( *reinterpret_cast( &rhs ) ) - { - } - - DrmFormatModifierPropertiesList2EXT & operator=( DrmFormatModifierPropertiesList2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DrmFormatModifierPropertiesList2EXT & operator=( VkDrmFormatModifierPropertiesList2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDrmFormatModifierPropertiesList2EXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrmFormatModifierPropertiesList2EXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrmFormatModifierPropertiesList2EXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDrmFormatModifierPropertiesList2EXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DrmFormatModifierPropertiesList2EXT const & ) const = default; -#else - bool operator==( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && - ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties ); -# endif - } - - bool operator!=( DrmFormatModifierPropertiesList2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDrmFormatModifierPropertiesList2EXT; - void * pNext = {}; - uint32_t drmFormatModifierCount = {}; - DrmFormatModifierProperties2EXT * pDrmFormatModifierProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DrmFormatModifierPropertiesList2EXT; - }; -#endif - - template <> - struct CppType - { - using Type = DrmFormatModifierPropertiesList2EXT; - }; - - // wrapper struct for struct VkDrmFormatModifierPropertiesListEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkDrmFormatModifierPropertiesListEXT.html - struct DrmFormatModifierPropertiesListEXT - { - using NativeType = VkDrmFormatModifierPropertiesListEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDrmFormatModifierPropertiesListEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesListEXT( uint32_t drmFormatModifierCount_ = {}, - DrmFormatModifierPropertiesEXT * pDrmFormatModifierProperties_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , drmFormatModifierCount{ drmFormatModifierCount_ } - , pDrmFormatModifierProperties{ pDrmFormatModifierProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR DrmFormatModifierPropertiesListEXT( DrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - DrmFormatModifierPropertiesListEXT( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : DrmFormatModifierPropertiesListEXT( *reinterpret_cast( &rhs ) ) - { - } - - DrmFormatModifierPropertiesListEXT & operator=( DrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - DrmFormatModifierPropertiesListEXT & operator=( VkDrmFormatModifierPropertiesListEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkDrmFormatModifierPropertiesListEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrmFormatModifierPropertiesListEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkDrmFormatModifierPropertiesListEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkDrmFormatModifierPropertiesListEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifierProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( DrmFormatModifierPropertiesListEXT const & ) const = default; -#else - bool operator==( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && - ( pDrmFormatModifierProperties == rhs.pDrmFormatModifierProperties ); -# endif - } - - bool operator!=( DrmFormatModifierPropertiesListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eDrmFormatModifierPropertiesListEXT; - void * pNext = {}; - uint32_t drmFormatModifierCount = {}; - DrmFormatModifierPropertiesEXT * pDrmFormatModifierProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = DrmFormatModifierPropertiesListEXT; - }; -#endif - - template <> - struct CppType - { - using Type = DrmFormatModifierPropertiesListEXT; - }; - - // wrapper struct for struct VkEventCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkEventCreateInfo.html - struct EventCreateInfo - { - using NativeType = VkEventCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eEventCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR EventCreateInfo( EventCreateFlags flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR EventCreateInfo( EventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - EventCreateInfo( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : EventCreateInfo( *reinterpret_cast( &rhs ) ) {} - - EventCreateInfo & operator=( EventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - EventCreateInfo & operator=( VkEventCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 EventCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 EventCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 EventCreateInfo & setFlags( EventCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 EventCreateInfo && setFlags( EventCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkEventCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkEventCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkEventCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkEventCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( EventCreateInfo const & ) const = default; -#else - bool operator==( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( EventCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eEventCreateInfo; - const void * pNext = {}; - EventCreateFlags flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = EventCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = EventCreateInfo; - }; - - // wrapper struct for struct VkPipelineLibraryCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLibraryCreateInfoKHR.html - struct PipelineLibraryCreateInfoKHR - { - using NativeType = VkPipelineLibraryCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineLibraryCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PipelineLibraryCreateInfoKHR( uint32_t libraryCount_ = {}, const Pipeline * pLibraries_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , libraryCount{ libraryCount_ } - , pLibraries{ pLibraries_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineLibraryCreateInfoKHR( PipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineLibraryCreateInfoKHR( VkPipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineLibraryCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineLibraryCreateInfoKHR( ArrayProxyNoTemporaries const & libraries_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), libraryCount( static_cast( libraries_.size() ) ), pLibraries( libraries_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineLibraryCreateInfoKHR & operator=( PipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineLibraryCreateInfoKHR & operator=( VkPipelineLibraryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR & setLibraryCount( uint32_t libraryCount_ ) & VULKAN_HPP_NOEXCEPT - { - libraryCount = libraryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR && setLibraryCount( uint32_t libraryCount_ ) && VULKAN_HPP_NOEXCEPT - { - libraryCount = libraryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR & setPLibraries( const Pipeline * pLibraries_ ) & VULKAN_HPP_NOEXCEPT - { - pLibraries = pLibraries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLibraryCreateInfoKHR && setPLibraries( const Pipeline * pLibraries_ ) && VULKAN_HPP_NOEXCEPT - { - pLibraries = pLibraries_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineLibraryCreateInfoKHR & setLibraries( ArrayProxyNoTemporaries const & libraries_ ) VULKAN_HPP_NOEXCEPT - { - libraryCount = static_cast( libraries_.size() ); - pLibraries = libraries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineLibraryCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineLibraryCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineLibraryCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineLibraryCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, libraryCount, pLibraries ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineLibraryCreateInfoKHR const & ) const = default; -#else - bool operator==( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( libraryCount == rhs.libraryCount ) && ( pLibraries == rhs.pLibraries ); -# endif - } - - bool operator!=( PipelineLibraryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineLibraryCreateInfoKHR; - const void * pNext = {}; - uint32_t libraryCount = {}; - const Pipeline * pLibraries = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineLibraryCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineLibraryCreateInfoKHR; - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkExecutionGraphPipelineCreateInfoAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExecutionGraphPipelineCreateInfoAMDX.html - struct ExecutionGraphPipelineCreateInfoAMDX - { - using NativeType = VkExecutionGraphPipelineCreateInfoAMDX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExecutionGraphPipelineCreateInfoAMDX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExecutionGraphPipelineCreateInfoAMDX( PipelineCreateFlags flags_ = {}, - uint32_t stageCount_ = {}, - const PipelineShaderStageCreateInfo * pStages_ = {}, - const PipelineLibraryCreateInfoKHR * pLibraryInfo_ = {}, - PipelineLayout layout_ = {}, - Pipeline basePipelineHandle_ = {}, - int32_t basePipelineIndex_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , stageCount{ stageCount_ } - , pStages{ pStages_ } - , pLibraryInfo{ pLibraryInfo_ } - , layout{ layout_ } - , basePipelineHandle{ basePipelineHandle_ } - , basePipelineIndex{ basePipelineIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR ExecutionGraphPipelineCreateInfoAMDX( ExecutionGraphPipelineCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExecutionGraphPipelineCreateInfoAMDX( VkExecutionGraphPipelineCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - : ExecutionGraphPipelineCreateInfoAMDX( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ExecutionGraphPipelineCreateInfoAMDX( PipelineCreateFlags flags_, - ArrayProxyNoTemporaries const & stages_, - const PipelineLibraryCreateInfoKHR * pLibraryInfo_ = {}, - PipelineLayout layout_ = {}, - Pipeline basePipelineHandle_ = {}, - int32_t basePipelineIndex_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , stageCount( static_cast( stages_.size() ) ) - , pStages( stages_.data() ) - , pLibraryInfo( pLibraryInfo_ ) - , layout( layout_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ExecutionGraphPipelineCreateInfoAMDX & operator=( ExecutionGraphPipelineCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExecutionGraphPipelineCreateInfoAMDX & operator=( VkExecutionGraphPipelineCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setFlags( PipelineCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setFlags( PipelineCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setStageCount( uint32_t stageCount_ ) & VULKAN_HPP_NOEXCEPT - { - stageCount = stageCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setStageCount( uint32_t stageCount_ ) && VULKAN_HPP_NOEXCEPT - { - stageCount = stageCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setPStages( const PipelineShaderStageCreateInfo * pStages_ ) & VULKAN_HPP_NOEXCEPT - { - pStages = pStages_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setPStages( const PipelineShaderStageCreateInfo * pStages_ ) && VULKAN_HPP_NOEXCEPT - { - pStages = pStages_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ExecutionGraphPipelineCreateInfoAMDX & setStages( ArrayProxyNoTemporaries const & stages_ ) VULKAN_HPP_NOEXCEPT - { - stageCount = static_cast( stages_.size() ); - pStages = stages_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setPLibraryInfo( const PipelineLibraryCreateInfoKHR * pLibraryInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pLibraryInfo = pLibraryInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setPLibraryInfo( const PipelineLibraryCreateInfoKHR * pLibraryInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pLibraryInfo = pLibraryInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setBasePipelineHandle( Pipeline basePipelineHandle_ ) & VULKAN_HPP_NOEXCEPT - { - basePipelineHandle = basePipelineHandle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setBasePipelineHandle( Pipeline basePipelineHandle_ ) && VULKAN_HPP_NOEXCEPT - { - basePipelineHandle = basePipelineHandle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX & setBasePipelineIndex( int32_t basePipelineIndex_ ) & VULKAN_HPP_NOEXCEPT - { - basePipelineIndex = basePipelineIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineCreateInfoAMDX && setBasePipelineIndex( int32_t basePipelineIndex_ ) && VULKAN_HPP_NOEXCEPT - { - basePipelineIndex = basePipelineIndex_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExecutionGraphPipelineCreateInfoAMDX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExecutionGraphPipelineCreateInfoAMDX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExecutionGraphPipelineCreateInfoAMDX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExecutionGraphPipelineCreateInfoAMDX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, stageCount, pStages, pLibraryInfo, layout, basePipelineHandle, basePipelineIndex ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExecutionGraphPipelineCreateInfoAMDX const & ) const = default; -# else - bool operator==( ExecutionGraphPipelineCreateInfoAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && - ( pLibraryInfo == rhs.pLibraryInfo ) && ( layout == rhs.layout ) && ( basePipelineHandle == rhs.basePipelineHandle ) && - ( basePipelineIndex == rhs.basePipelineIndex ); -# endif - } - - bool operator!=( ExecutionGraphPipelineCreateInfoAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExecutionGraphPipelineCreateInfoAMDX; - const void * pNext = {}; - PipelineCreateFlags flags = {}; - uint32_t stageCount = {}; - const PipelineShaderStageCreateInfo * pStages = {}; - const PipelineLibraryCreateInfoKHR * pLibraryInfo = {}; - PipelineLayout layout = {}; - Pipeline basePipelineHandle = {}; - int32_t basePipelineIndex = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExecutionGraphPipelineCreateInfoAMDX; - }; -# endif - - template <> - struct CppType - { - using Type = ExecutionGraphPipelineCreateInfoAMDX; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkExecutionGraphPipelineScratchSizeAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExecutionGraphPipelineScratchSizeAMDX.html - struct ExecutionGraphPipelineScratchSizeAMDX - { - using NativeType = VkExecutionGraphPipelineScratchSizeAMDX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExecutionGraphPipelineScratchSizeAMDX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExecutionGraphPipelineScratchSizeAMDX( DeviceSize minSize_ = {}, - DeviceSize maxSize_ = {}, - DeviceSize sizeGranularity_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minSize{ minSize_ } - , maxSize{ maxSize_ } - , sizeGranularity{ sizeGranularity_ } - { - } - - VULKAN_HPP_CONSTEXPR ExecutionGraphPipelineScratchSizeAMDX( ExecutionGraphPipelineScratchSizeAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExecutionGraphPipelineScratchSizeAMDX( VkExecutionGraphPipelineScratchSizeAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - : ExecutionGraphPipelineScratchSizeAMDX( *reinterpret_cast( &rhs ) ) - { - } - - ExecutionGraphPipelineScratchSizeAMDX & operator=( ExecutionGraphPipelineScratchSizeAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExecutionGraphPipelineScratchSizeAMDX & operator=( VkExecutionGraphPipelineScratchSizeAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX & setMinSize( DeviceSize minSize_ ) & VULKAN_HPP_NOEXCEPT - { - minSize = minSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX && setMinSize( DeviceSize minSize_ ) && VULKAN_HPP_NOEXCEPT - { - minSize = minSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX & setMaxSize( DeviceSize maxSize_ ) & VULKAN_HPP_NOEXCEPT - { - maxSize = maxSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX && setMaxSize( DeviceSize maxSize_ ) && VULKAN_HPP_NOEXCEPT - { - maxSize = maxSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX & setSizeGranularity( DeviceSize sizeGranularity_ ) & VULKAN_HPP_NOEXCEPT - { - sizeGranularity = sizeGranularity_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExecutionGraphPipelineScratchSizeAMDX && setSizeGranularity( DeviceSize sizeGranularity_ ) && VULKAN_HPP_NOEXCEPT - { - sizeGranularity = sizeGranularity_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExecutionGraphPipelineScratchSizeAMDX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExecutionGraphPipelineScratchSizeAMDX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExecutionGraphPipelineScratchSizeAMDX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExecutionGraphPipelineScratchSizeAMDX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minSize, maxSize, sizeGranularity ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExecutionGraphPipelineScratchSizeAMDX const & ) const = default; -# else - bool operator==( ExecutionGraphPipelineScratchSizeAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSize == rhs.minSize ) && ( maxSize == rhs.maxSize ) && - ( sizeGranularity == rhs.sizeGranularity ); -# endif - } - - bool operator!=( ExecutionGraphPipelineScratchSizeAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExecutionGraphPipelineScratchSizeAMDX; - void * pNext = {}; - DeviceSize minSize = {}; - DeviceSize maxSize = {}; - DeviceSize sizeGranularity = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExecutionGraphPipelineScratchSizeAMDX; - }; -# endif - - template <> - struct CppType - { - using Type = ExecutionGraphPipelineScratchSizeAMDX; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkExportFenceCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportFenceCreateInfo.html - struct ExportFenceCreateInfo - { - using NativeType = VkExportFenceCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportFenceCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( ExternalFenceHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleTypes{ handleTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportFenceCreateInfo( ExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportFenceCreateInfo( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportFenceCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - ExportFenceCreateInfo & operator=( ExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportFenceCreateInfo & operator=( VkExportFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportFenceCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportFenceCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportFenceCreateInfo & setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportFenceCreateInfo && setHandleTypes( ExternalFenceHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportFenceCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportFenceCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportFenceCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportFenceCreateInfo const & ) const = default; -#else - bool operator==( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); -# endif - } - - bool operator!=( ExportFenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExportFenceCreateInfo; - const void * pNext = {}; - ExternalFenceHandleTypeFlags handleTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportFenceCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ExportFenceCreateInfo; - }; - - using ExportFenceCreateInfoKHR = ExportFenceCreateInfo; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkExportFenceWin32HandleInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportFenceWin32HandleInfoKHR.html - struct ExportFenceWin32HandleInfoKHR - { - using NativeType = VkExportFenceWin32HandleInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportFenceWin32HandleInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( const SECURITY_ATTRIBUTES * pAttributes_ = {}, - DWORD dwAccess_ = {}, - LPCWSTR name_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pAttributes{ pAttributes_ } - , dwAccess{ dwAccess_ } - , name{ name_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportFenceWin32HandleInfoKHR( ExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportFenceWin32HandleInfoKHR( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportFenceWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ExportFenceWin32HandleInfoKHR & operator=( ExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportFenceWin32HandleInfoKHR & operator=( VkExportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR & setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) & VULKAN_HPP_NOEXCEPT - { - pAttributes = pAttributes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR && setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) && VULKAN_HPP_NOEXCEPT - { - pAttributes = pAttributes_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR & setDwAccess( DWORD dwAccess_ ) & VULKAN_HPP_NOEXCEPT - { - dwAccess = dwAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR && setDwAccess( DWORD dwAccess_ ) && VULKAN_HPP_NOEXCEPT - { - dwAccess = dwAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT - { - name = name_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportFenceWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT - { - name = name_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportFenceWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportFenceWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pAttributes, dwAccess, name ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportFenceWin32HandleInfoKHR const & ) const = default; -# else - bool operator==( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); -# endif - } - - bool operator!=( ExportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportFenceWin32HandleInfoKHR; - const void * pNext = {}; - const SECURITY_ATTRIBUTES * pAttributes = {}; - DWORD dwAccess = {}; - LPCWSTR name = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportFenceWin32HandleInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = ExportFenceWin32HandleInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - // wrapper struct for struct VkExportMemoryAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMemoryAllocateInfo.html - struct ExportMemoryAllocateInfo - { - using NativeType = VkExportMemoryAllocateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryAllocateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleTypes{ handleTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfo( ExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMemoryAllocateInfo( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMemoryAllocateInfo( *reinterpret_cast( &rhs ) ) - { - } - - ExportMemoryAllocateInfo & operator=( ExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMemoryAllocateInfo & operator=( VkExportMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfo && setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMemoryAllocateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMemoryAllocateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMemoryAllocateInfo const & ) const = default; -#else - bool operator==( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); -# endif - } - - bool operator!=( ExportMemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExportMemoryAllocateInfo; - const void * pNext = {}; - ExternalMemoryHandleTypeFlags handleTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMemoryAllocateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ExportMemoryAllocateInfo; - }; - - using ExportMemoryAllocateInfoKHR = ExportMemoryAllocateInfo; - - // wrapper struct for struct VkExportMemoryAllocateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMemoryAllocateInfoNV.html - struct ExportMemoryAllocateInfoNV - { - using NativeType = VkExportMemoryAllocateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryAllocateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleTypes{ handleTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportMemoryAllocateInfoNV( ExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMemoryAllocateInfoNV( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMemoryAllocateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ExportMemoryAllocateInfoNV & operator=( ExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMemoryAllocateInfoNV & operator=( VkExportMemoryAllocateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfoNV & setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) & VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryAllocateInfoNV && setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) && VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMemoryAllocateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMemoryAllocateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMemoryAllocateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMemoryAllocateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMemoryAllocateInfoNV const & ) const = default; -#else - bool operator==( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); -# endif - } - - bool operator!=( ExportMemoryAllocateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExportMemoryAllocateInfoNV; - const void * pNext = {}; - ExternalMemoryHandleTypeFlagsNV handleTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMemoryAllocateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = ExportMemoryAllocateInfoNV; - }; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkExportMemoryWin32HandleInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMemoryWin32HandleInfoKHR.html - struct ExportMemoryWin32HandleInfoKHR - { - using NativeType = VkExportMemoryWin32HandleInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryWin32HandleInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( const SECURITY_ATTRIBUTES * pAttributes_ = {}, - DWORD dwAccess_ = {}, - LPCWSTR name_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pAttributes{ pAttributes_ } - , dwAccess{ dwAccess_ } - , name{ name_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoKHR( ExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMemoryWin32HandleInfoKHR( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMemoryWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ExportMemoryWin32HandleInfoKHR & operator=( ExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMemoryWin32HandleInfoKHR & operator=( VkExportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR & setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) & VULKAN_HPP_NOEXCEPT - { - pAttributes = pAttributes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR && setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) && VULKAN_HPP_NOEXCEPT - { - pAttributes = pAttributes_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR & setDwAccess( DWORD dwAccess_ ) & VULKAN_HPP_NOEXCEPT - { - dwAccess = dwAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR && setDwAccess( DWORD dwAccess_ ) && VULKAN_HPP_NOEXCEPT - { - dwAccess = dwAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT - { - name = name_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT - { - name = name_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMemoryWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMemoryWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pAttributes, dwAccess, name ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMemoryWin32HandleInfoKHR const & ) const = default; -# else - bool operator==( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); -# endif - } - - bool operator!=( ExportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportMemoryWin32HandleInfoKHR; - const void * pNext = {}; - const SECURITY_ATTRIBUTES * pAttributes = {}; - DWORD dwAccess = {}; - LPCWSTR name = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMemoryWin32HandleInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = ExportMemoryWin32HandleInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkExportMemoryWin32HandleInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMemoryWin32HandleInfoNV.html - struct ExportMemoryWin32HandleInfoNV - { - using NativeType = VkExportMemoryWin32HandleInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMemoryWin32HandleInfoNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - ExportMemoryWin32HandleInfoNV( const SECURITY_ATTRIBUTES * pAttributes_ = {}, DWORD dwAccess_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pAttributes{ pAttributes_ } - , dwAccess{ dwAccess_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportMemoryWin32HandleInfoNV( ExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMemoryWin32HandleInfoNV( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMemoryWin32HandleInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ExportMemoryWin32HandleInfoNV & operator=( ExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMemoryWin32HandleInfoNV & operator=( VkExportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV & setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) & VULKAN_HPP_NOEXCEPT - { - pAttributes = pAttributes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV && setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) && VULKAN_HPP_NOEXCEPT - { - pAttributes = pAttributes_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV & setDwAccess( DWORD dwAccess_ ) & VULKAN_HPP_NOEXCEPT - { - dwAccess = dwAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMemoryWin32HandleInfoNV && setDwAccess( DWORD dwAccess_ ) && VULKAN_HPP_NOEXCEPT - { - dwAccess = dwAccess_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMemoryWin32HandleInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMemoryWin32HandleInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pAttributes, dwAccess ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMemoryWin32HandleInfoNV const & ) const = default; -# else - bool operator==( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess ); -# endif - } - - bool operator!=( ExportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportMemoryWin32HandleInfoNV; - const void * pNext = {}; - const SECURITY_ATTRIBUTES * pAttributes = {}; - DWORD dwAccess = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMemoryWin32HandleInfoNV; - }; -# endif - - template <> - struct CppType - { - using Type = ExportMemoryWin32HandleInfoNV; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkExportMetalBufferInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalBufferInfoEXT.html - struct ExportMetalBufferInfoEXT - { - using NativeType = VkExportMetalBufferInfoEXT; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalBufferInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportMetalBufferInfoEXT( DeviceMemory memory_ = {}, MTLBuffer_id mtlBuffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memory{ memory_ } - , mtlBuffer{ mtlBuffer_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportMetalBufferInfoEXT( ExportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMetalBufferInfoEXT( VkExportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMetalBufferInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ExportMetalBufferInfoEXT & operator=( ExportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMetalBufferInfoEXT & operator=( VkExportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT & setMtlBuffer( MTLBuffer_id mtlBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - mtlBuffer = mtlBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalBufferInfoEXT && setMtlBuffer( MTLBuffer_id mtlBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - mtlBuffer = mtlBuffer_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMetalBufferInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalBufferInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalBufferInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMetalBufferInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memory, mtlBuffer ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMetalBufferInfoEXT const & ) const = default; -# else - bool operator==( ExportMetalBufferInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( mtlBuffer == rhs.mtlBuffer ); -# endif - } - - bool operator!=( ExportMetalBufferInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportMetalBufferInfoEXT; - const void * pNext = {}; - DeviceMemory memory = {}; - MTLBuffer_id mtlBuffer = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMetalBufferInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ExportMetalBufferInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkExportMetalCommandQueueInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalCommandQueueInfoEXT.html - struct ExportMetalCommandQueueInfoEXT - { - using NativeType = VkExportMetalCommandQueueInfoEXT; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalCommandQueueInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - ExportMetalCommandQueueInfoEXT( Queue queue_ = {}, MTLCommandQueue_id mtlCommandQueue_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , queue{ queue_ } - , mtlCommandQueue{ mtlCommandQueue_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportMetalCommandQueueInfoEXT( ExportMetalCommandQueueInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMetalCommandQueueInfoEXT( VkExportMetalCommandQueueInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMetalCommandQueueInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ExportMetalCommandQueueInfoEXT & operator=( ExportMetalCommandQueueInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMetalCommandQueueInfoEXT & operator=( VkExportMetalCommandQueueInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT & setQueue( Queue queue_ ) & VULKAN_HPP_NOEXCEPT - { - queue = queue_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT && setQueue( Queue queue_ ) && VULKAN_HPP_NOEXCEPT - { - queue = queue_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT & setMtlCommandQueue( MTLCommandQueue_id mtlCommandQueue_ ) & VULKAN_HPP_NOEXCEPT - { - mtlCommandQueue = mtlCommandQueue_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalCommandQueueInfoEXT && setMtlCommandQueue( MTLCommandQueue_id mtlCommandQueue_ ) && VULKAN_HPP_NOEXCEPT - { - mtlCommandQueue = mtlCommandQueue_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMetalCommandQueueInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalCommandQueueInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalCommandQueueInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMetalCommandQueueInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, queue, mtlCommandQueue ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMetalCommandQueueInfoEXT const & ) const = default; -# else - bool operator==( ExportMetalCommandQueueInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queue == rhs.queue ) && ( mtlCommandQueue == rhs.mtlCommandQueue ); -# endif - } - - bool operator!=( ExportMetalCommandQueueInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportMetalCommandQueueInfoEXT; - const void * pNext = {}; - Queue queue = {}; - MTLCommandQueue_id mtlCommandQueue = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMetalCommandQueueInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ExportMetalCommandQueueInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkExportMetalDeviceInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalDeviceInfoEXT.html - struct ExportMetalDeviceInfoEXT - { - using NativeType = VkExportMetalDeviceInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalDeviceInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportMetalDeviceInfoEXT( MTLDevice_id mtlDevice_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , mtlDevice{ mtlDevice_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportMetalDeviceInfoEXT( ExportMetalDeviceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMetalDeviceInfoEXT( VkExportMetalDeviceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMetalDeviceInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ExportMetalDeviceInfoEXT & operator=( ExportMetalDeviceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMetalDeviceInfoEXT & operator=( VkExportMetalDeviceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMetalDeviceInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalDeviceInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalDeviceInfoEXT & setMtlDevice( MTLDevice_id mtlDevice_ ) & VULKAN_HPP_NOEXCEPT - { - mtlDevice = mtlDevice_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalDeviceInfoEXT && setMtlDevice( MTLDevice_id mtlDevice_ ) && VULKAN_HPP_NOEXCEPT - { - mtlDevice = mtlDevice_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMetalDeviceInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalDeviceInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalDeviceInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMetalDeviceInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, mtlDevice ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMetalDeviceInfoEXT const & ) const = default; -# else - bool operator==( ExportMetalDeviceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mtlDevice == rhs.mtlDevice ); -# endif - } - - bool operator!=( ExportMetalDeviceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportMetalDeviceInfoEXT; - const void * pNext = {}; - MTLDevice_id mtlDevice = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMetalDeviceInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ExportMetalDeviceInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkExportMetalIOSurfaceInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalIOSurfaceInfoEXT.html - struct ExportMetalIOSurfaceInfoEXT - { - using NativeType = VkExportMetalIOSurfaceInfoEXT; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalIoSurfaceInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportMetalIOSurfaceInfoEXT( Image image_ = {}, IOSurfaceRef ioSurface_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , image{ image_ } - , ioSurface{ ioSurface_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportMetalIOSurfaceInfoEXT( ExportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMetalIOSurfaceInfoEXT( VkExportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMetalIOSurfaceInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ExportMetalIOSurfaceInfoEXT & operator=( ExportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMetalIOSurfaceInfoEXT & operator=( VkExportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT & setIoSurface( IOSurfaceRef ioSurface_ ) & VULKAN_HPP_NOEXCEPT - { - ioSurface = ioSurface_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalIOSurfaceInfoEXT && setIoSurface( IOSurfaceRef ioSurface_ ) && VULKAN_HPP_NOEXCEPT - { - ioSurface = ioSurface_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMetalIOSurfaceInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalIOSurfaceInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalIOSurfaceInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMetalIOSurfaceInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, image, ioSurface ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMetalIOSurfaceInfoEXT const & ) const = default; -# else - bool operator==( ExportMetalIOSurfaceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( ioSurface == rhs.ioSurface ); -# endif - } - - bool operator!=( ExportMetalIOSurfaceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportMetalIoSurfaceInfoEXT; - const void * pNext = {}; - Image image = {}; - IOSurfaceRef ioSurface = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMetalIOSurfaceInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ExportMetalIOSurfaceInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkExportMetalObjectCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalObjectCreateInfoEXT.html - struct ExportMetalObjectCreateInfoEXT - { - using NativeType = VkExportMetalObjectCreateInfoEXT; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalObjectCreateInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportMetalObjectCreateInfoEXT( ExportMetalObjectTypeFlagBitsEXT exportObjectType_ = ExportMetalObjectTypeFlagBitsEXT::eMetalDevice, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , exportObjectType{ exportObjectType_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportMetalObjectCreateInfoEXT( ExportMetalObjectCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMetalObjectCreateInfoEXT( VkExportMetalObjectCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMetalObjectCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ExportMetalObjectCreateInfoEXT & operator=( ExportMetalObjectCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMetalObjectCreateInfoEXT & operator=( VkExportMetalObjectCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectCreateInfoEXT & setExportObjectType( ExportMetalObjectTypeFlagBitsEXT exportObjectType_ ) & VULKAN_HPP_NOEXCEPT - { - exportObjectType = exportObjectType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectCreateInfoEXT && setExportObjectType( ExportMetalObjectTypeFlagBitsEXT exportObjectType_ ) && VULKAN_HPP_NOEXCEPT - { - exportObjectType = exportObjectType_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMetalObjectCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalObjectCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalObjectCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMetalObjectCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, exportObjectType ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMetalObjectCreateInfoEXT const & ) const = default; -# else - bool operator==( ExportMetalObjectCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exportObjectType == rhs.exportObjectType ); -# endif - } - - bool operator!=( ExportMetalObjectCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportMetalObjectCreateInfoEXT; - const void * pNext = {}; - ExportMetalObjectTypeFlagBitsEXT exportObjectType = ExportMetalObjectTypeFlagBitsEXT::eMetalDevice; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMetalObjectCreateInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ExportMetalObjectCreateInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkExportMetalObjectsInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalObjectsInfoEXT.html - struct ExportMetalObjectsInfoEXT - { - using NativeType = VkExportMetalObjectsInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalObjectsInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportMetalObjectsInfoEXT( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} - - VULKAN_HPP_CONSTEXPR ExportMetalObjectsInfoEXT( ExportMetalObjectsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMetalObjectsInfoEXT( VkExportMetalObjectsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMetalObjectsInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ExportMetalObjectsInfoEXT & operator=( ExportMetalObjectsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMetalObjectsInfoEXT & operator=( VkExportMetalObjectsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalObjectsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMetalObjectsInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalObjectsInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalObjectsInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMetalObjectsInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMetalObjectsInfoEXT const & ) const = default; -# else - bool operator==( ExportMetalObjectsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); -# endif - } - - bool operator!=( ExportMetalObjectsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportMetalObjectsInfoEXT; - const void * pNext = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMetalObjectsInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ExportMetalObjectsInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkExportMetalSharedEventInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalSharedEventInfoEXT.html - struct ExportMetalSharedEventInfoEXT - { - using NativeType = VkExportMetalSharedEventInfoEXT; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalSharedEventInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportMetalSharedEventInfoEXT( Semaphore semaphore_ = {}, - Event event_ = {}, - MTLSharedEvent_id mtlSharedEvent_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , semaphore{ semaphore_ } - , event{ event_ } - , mtlSharedEvent{ mtlSharedEvent_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportMetalSharedEventInfoEXT( ExportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMetalSharedEventInfoEXT( VkExportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMetalSharedEventInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ExportMetalSharedEventInfoEXT & operator=( ExportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMetalSharedEventInfoEXT & operator=( VkExportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT & setEvent( Event event_ ) & VULKAN_HPP_NOEXCEPT - { - event = event_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT && setEvent( Event event_ ) && VULKAN_HPP_NOEXCEPT - { - event = event_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT & setMtlSharedEvent( MTLSharedEvent_id mtlSharedEvent_ ) & VULKAN_HPP_NOEXCEPT - { - mtlSharedEvent = mtlSharedEvent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalSharedEventInfoEXT && setMtlSharedEvent( MTLSharedEvent_id mtlSharedEvent_ ) && VULKAN_HPP_NOEXCEPT - { - mtlSharedEvent = mtlSharedEvent_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMetalSharedEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalSharedEventInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalSharedEventInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMetalSharedEventInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, semaphore, event, mtlSharedEvent ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMetalSharedEventInfoEXT const & ) const = default; -# else - bool operator==( ExportMetalSharedEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( event == rhs.event ) && - ( mtlSharedEvent == rhs.mtlSharedEvent ); -# endif - } - - bool operator!=( ExportMetalSharedEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportMetalSharedEventInfoEXT; - const void * pNext = {}; - Semaphore semaphore = {}; - Event event = {}; - MTLSharedEvent_id mtlSharedEvent = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMetalSharedEventInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ExportMetalSharedEventInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkExportMetalTextureInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportMetalTextureInfoEXT.html - struct ExportMetalTextureInfoEXT - { - using NativeType = VkExportMetalTextureInfoEXT; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportMetalTextureInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportMetalTextureInfoEXT( Image image_ = {}, - ImageView imageView_ = {}, - BufferView bufferView_ = {}, - ImageAspectFlagBits plane_ = ImageAspectFlagBits::eColor, - MTLTexture_id mtlTexture_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , image{ image_ } - , imageView{ imageView_ } - , bufferView{ bufferView_ } - , plane{ plane_ } - , mtlTexture{ mtlTexture_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportMetalTextureInfoEXT( ExportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportMetalTextureInfoEXT( VkExportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportMetalTextureInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ExportMetalTextureInfoEXT & operator=( ExportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportMetalTextureInfoEXT & operator=( VkExportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setBufferView( BufferView bufferView_ ) & VULKAN_HPP_NOEXCEPT - { - bufferView = bufferView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setBufferView( BufferView bufferView_ ) && VULKAN_HPP_NOEXCEPT - { - bufferView = bufferView_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setPlane( ImageAspectFlagBits plane_ ) & VULKAN_HPP_NOEXCEPT - { - plane = plane_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setPlane( ImageAspectFlagBits plane_ ) && VULKAN_HPP_NOEXCEPT - { - plane = plane_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT & setMtlTexture( MTLTexture_id mtlTexture_ ) & VULKAN_HPP_NOEXCEPT - { - mtlTexture = mtlTexture_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportMetalTextureInfoEXT && setMtlTexture( MTLTexture_id mtlTexture_ ) && VULKAN_HPP_NOEXCEPT - { - mtlTexture = mtlTexture_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportMetalTextureInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalTextureInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportMetalTextureInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportMetalTextureInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, image, imageView, bufferView, plane, mtlTexture ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportMetalTextureInfoEXT const & ) const = default; -# else - bool operator==( ExportMetalTextureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( imageView == rhs.imageView ) && ( bufferView == rhs.bufferView ) && - ( plane == rhs.plane ) && ( mtlTexture == rhs.mtlTexture ); -# endif - } - - bool operator!=( ExportMetalTextureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportMetalTextureInfoEXT; - const void * pNext = {}; - Image image = {}; - ImageView imageView = {}; - BufferView bufferView = {}; - ImageAspectFlagBits plane = ImageAspectFlagBits::eColor; - MTLTexture_id mtlTexture = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportMetalTextureInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ExportMetalTextureInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - // wrapper struct for struct VkExportSemaphoreCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportSemaphoreCreateInfo.html - struct ExportSemaphoreCreateInfo - { - using NativeType = VkExportSemaphoreCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportSemaphoreCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( ExternalSemaphoreHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleTypes{ handleTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportSemaphoreCreateInfo( ExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportSemaphoreCreateInfo( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportSemaphoreCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - ExportSemaphoreCreateInfo & operator=( ExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportSemaphoreCreateInfo & operator=( VkExportSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreCreateInfo & setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreCreateInfo && setHandleTypes( ExternalSemaphoreHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportSemaphoreCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportSemaphoreCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportSemaphoreCreateInfo const & ) const = default; -#else - bool operator==( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); -# endif - } - - bool operator!=( ExportSemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExportSemaphoreCreateInfo; - const void * pNext = {}; - ExternalSemaphoreHandleTypeFlags handleTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportSemaphoreCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ExportSemaphoreCreateInfo; - }; - - using ExportSemaphoreCreateInfoKHR = ExportSemaphoreCreateInfo; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkExportSemaphoreWin32HandleInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExportSemaphoreWin32HandleInfoKHR.html - struct ExportSemaphoreWin32HandleInfoKHR - { - using NativeType = VkExportSemaphoreWin32HandleInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExportSemaphoreWin32HandleInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( const SECURITY_ATTRIBUTES * pAttributes_ = {}, - DWORD dwAccess_ = {}, - LPCWSTR name_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pAttributes{ pAttributes_ } - , dwAccess{ dwAccess_ } - , name{ name_ } - { - } - - VULKAN_HPP_CONSTEXPR ExportSemaphoreWin32HandleInfoKHR( ExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExportSemaphoreWin32HandleInfoKHR( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ExportSemaphoreWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ExportSemaphoreWin32HandleInfoKHR & operator=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExportSemaphoreWin32HandleInfoKHR & operator=( VkExportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR & setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) & VULKAN_HPP_NOEXCEPT - { - pAttributes = pAttributes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR && setPAttributes( const SECURITY_ATTRIBUTES * pAttributes_ ) && VULKAN_HPP_NOEXCEPT - { - pAttributes = pAttributes_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR & setDwAccess( DWORD dwAccess_ ) & VULKAN_HPP_NOEXCEPT - { - dwAccess = dwAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR && setDwAccess( DWORD dwAccess_ ) && VULKAN_HPP_NOEXCEPT - { - dwAccess = dwAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT - { - name = name_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExportSemaphoreWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT - { - name = name_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExportSemaphoreWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExportSemaphoreWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pAttributes, dwAccess, name ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExportSemaphoreWin32HandleInfoKHR const & ) const = default; -# else - bool operator==( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pAttributes == rhs.pAttributes ) && ( dwAccess == rhs.dwAccess ) && ( name == rhs.name ); -# endif - } - - bool operator!=( ExportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExportSemaphoreWin32HandleInfoKHR; - const void * pNext = {}; - const SECURITY_ATTRIBUTES * pAttributes = {}; - DWORD dwAccess = {}; - LPCWSTR name = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExportSemaphoreWin32HandleInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = ExportSemaphoreWin32HandleInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - // wrapper struct for struct VkExtensionProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExtensionProperties.html - struct ExtensionProperties - { - using NativeType = VkExtensionProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 ExtensionProperties( std::array const & extensionName_ = {}, - uint32_t specVersion_ = {} ) VULKAN_HPP_NOEXCEPT - : extensionName{ extensionName_ } - , specVersion{ specVersion_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 ExtensionProperties( ExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExtensionProperties( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT : ExtensionProperties( *reinterpret_cast( &rhs ) ) - { - } - - ExtensionProperties & operator=( ExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExtensionProperties & operator=( VkExtensionProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkExtensionProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExtensionProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExtensionProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExtensionProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( extensionName, specVersion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = strcmp( extensionName, rhs.extensionName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = specVersion <=> rhs.specVersion; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( strcmp( extensionName, rhs.extensionName ) == 0 ) && ( specVersion == rhs.specVersion ); - } - - bool operator!=( ExtensionProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - ArrayWrapper1D extensionName = {}; - uint32_t specVersion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExtensionProperties; - }; -#endif - - // wrapper struct for struct VkExternalMemoryProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryProperties.html - struct ExternalMemoryProperties - { - using NativeType = VkExternalMemoryProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalMemoryProperties( ExternalMemoryFeatureFlags externalMemoryFeatures_ = {}, - ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes_ = {}, - ExternalMemoryHandleTypeFlags compatibleHandleTypes_ = {} ) VULKAN_HPP_NOEXCEPT - : externalMemoryFeatures{ externalMemoryFeatures_ } - , exportFromImportedHandleTypes{ exportFromImportedHandleTypes_ } - , compatibleHandleTypes{ compatibleHandleTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalMemoryProperties( ExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalMemoryProperties( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalMemoryProperties( *reinterpret_cast( &rhs ) ) - { - } - - ExternalMemoryProperties & operator=( ExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalMemoryProperties & operator=( VkExternalMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkExternalMemoryProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalMemoryProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalMemoryProperties const & ) const = default; -#else - bool operator==( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( externalMemoryFeatures == rhs.externalMemoryFeatures ) && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && - ( compatibleHandleTypes == rhs.compatibleHandleTypes ); -# endif - } - - bool operator!=( ExternalMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ExternalMemoryFeatureFlags externalMemoryFeatures = {}; - ExternalMemoryHandleTypeFlags exportFromImportedHandleTypes = {}; - ExternalMemoryHandleTypeFlags compatibleHandleTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalMemoryProperties; - }; -#endif - using ExternalMemoryPropertiesKHR = ExternalMemoryProperties; - - // wrapper struct for struct VkExternalBufferProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalBufferProperties.html - struct ExternalBufferProperties - { - using NativeType = VkExternalBufferProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalBufferProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalBufferProperties( ExternalMemoryProperties externalMemoryProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , externalMemoryProperties{ externalMemoryProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalBufferProperties( ExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalBufferProperties( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalBufferProperties( *reinterpret_cast( &rhs ) ) - { - } - - ExternalBufferProperties & operator=( ExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalBufferProperties & operator=( VkExternalBufferProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkExternalBufferProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalBufferProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalBufferProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalBufferProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, externalMemoryProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalBufferProperties const & ) const = default; -#else - bool operator==( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryProperties == rhs.externalMemoryProperties ); -# endif - } - - bool operator!=( ExternalBufferProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalBufferProperties; - void * pNext = {}; - ExternalMemoryProperties externalMemoryProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalBufferProperties; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalBufferProperties; - }; - - using ExternalBufferPropertiesKHR = ExternalBufferProperties; - - // wrapper struct for struct VkExternalComputeQueueCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueCreateInfoNV.html - struct ExternalComputeQueueCreateInfoNV - { - using NativeType = VkExternalComputeQueueCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalComputeQueueCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalComputeQueueCreateInfoNV( Queue preferredQueue_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , preferredQueue{ preferredQueue_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalComputeQueueCreateInfoNV( ExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalComputeQueueCreateInfoNV( VkExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalComputeQueueCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ExternalComputeQueueCreateInfoNV & operator=( ExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalComputeQueueCreateInfoNV & operator=( VkExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueCreateInfoNV & setPreferredQueue( Queue preferredQueue_ ) & VULKAN_HPP_NOEXCEPT - { - preferredQueue = preferredQueue_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueCreateInfoNV && setPreferredQueue( Queue preferredQueue_ ) && VULKAN_HPP_NOEXCEPT - { - preferredQueue = preferredQueue_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalComputeQueueCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalComputeQueueCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalComputeQueueCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalComputeQueueCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, preferredQueue ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalComputeQueueCreateInfoNV const & ) const = default; -#else - bool operator==( ExternalComputeQueueCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredQueue == rhs.preferredQueue ); -# endif - } - - bool operator!=( ExternalComputeQueueCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalComputeQueueCreateInfoNV; - const void * pNext = {}; - Queue preferredQueue = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalComputeQueueCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalComputeQueueCreateInfoNV; - }; - - // wrapper struct for struct VkExternalComputeQueueDataParamsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueDataParamsNV.html - struct ExternalComputeQueueDataParamsNV - { - using NativeType = VkExternalComputeQueueDataParamsNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalComputeQueueDataParamsNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalComputeQueueDataParamsNV( uint32_t deviceIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceIndex{ deviceIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalComputeQueueDataParamsNV( ExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalComputeQueueDataParamsNV( VkExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalComputeQueueDataParamsNV( *reinterpret_cast( &rhs ) ) - { - } - - ExternalComputeQueueDataParamsNV & operator=( ExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalComputeQueueDataParamsNV & operator=( VkExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDataParamsNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDataParamsNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDataParamsNV & setDeviceIndex( uint32_t deviceIndex_ ) & VULKAN_HPP_NOEXCEPT - { - deviceIndex = deviceIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDataParamsNV && setDeviceIndex( uint32_t deviceIndex_ ) && VULKAN_HPP_NOEXCEPT - { - deviceIndex = deviceIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalComputeQueueDataParamsNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalComputeQueueDataParamsNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalComputeQueueDataParamsNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalComputeQueueDataParamsNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalComputeQueueDataParamsNV const & ) const = default; -#else - bool operator==( ExternalComputeQueueDataParamsNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndex == rhs.deviceIndex ); -# endif - } - - bool operator!=( ExternalComputeQueueDataParamsNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalComputeQueueDataParamsNV; - const void * pNext = {}; - uint32_t deviceIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalComputeQueueDataParamsNV; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalComputeQueueDataParamsNV; - }; - - // wrapper struct for struct VkExternalComputeQueueDeviceCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueDeviceCreateInfoNV.html - struct ExternalComputeQueueDeviceCreateInfoNV - { - using NativeType = VkExternalComputeQueueDeviceCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalComputeQueueDeviceCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalComputeQueueDeviceCreateInfoNV( uint32_t reservedExternalQueues_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , reservedExternalQueues{ reservedExternalQueues_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalComputeQueueDeviceCreateInfoNV( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalComputeQueueDeviceCreateInfoNV( VkExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalComputeQueueDeviceCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ExternalComputeQueueDeviceCreateInfoNV & operator=( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalComputeQueueDeviceCreateInfoNV & operator=( VkExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDeviceCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDeviceCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDeviceCreateInfoNV & setReservedExternalQueues( uint32_t reservedExternalQueues_ ) & VULKAN_HPP_NOEXCEPT - { - reservedExternalQueues = reservedExternalQueues_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDeviceCreateInfoNV && setReservedExternalQueues( uint32_t reservedExternalQueues_ ) && VULKAN_HPP_NOEXCEPT - { - reservedExternalQueues = reservedExternalQueues_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalComputeQueueDeviceCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalComputeQueueDeviceCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalComputeQueueDeviceCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalComputeQueueDeviceCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, reservedExternalQueues ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalComputeQueueDeviceCreateInfoNV const & ) const = default; -#else - bool operator==( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reservedExternalQueues == rhs.reservedExternalQueues ); -# endif - } - - bool operator!=( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalComputeQueueDeviceCreateInfoNV; - const void * pNext = {}; - uint32_t reservedExternalQueues = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalComputeQueueDeviceCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalComputeQueueDeviceCreateInfoNV; - }; - - // wrapper struct for struct VkExternalFenceProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceProperties.html - struct ExternalFenceProperties - { - using NativeType = VkExternalFenceProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFenceProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalFenceProperties( ExternalFenceHandleTypeFlags exportFromImportedHandleTypes_ = {}, - ExternalFenceHandleTypeFlags compatibleHandleTypes_ = {}, - ExternalFenceFeatureFlags externalFenceFeatures_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , exportFromImportedHandleTypes{ exportFromImportedHandleTypes_ } - , compatibleHandleTypes{ compatibleHandleTypes_ } - , externalFenceFeatures{ externalFenceFeatures_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalFenceProperties( ExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalFenceProperties( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalFenceProperties( *reinterpret_cast( &rhs ) ) - { - } - - ExternalFenceProperties & operator=( ExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalFenceProperties & operator=( VkExternalFenceProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkExternalFenceProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalFenceProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalFenceProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalFenceProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalFenceFeatures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalFenceProperties const & ) const = default; -#else - bool operator==( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && - ( compatibleHandleTypes == rhs.compatibleHandleTypes ) && ( externalFenceFeatures == rhs.externalFenceFeatures ); -# endif - } - - bool operator!=( ExternalFenceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalFenceProperties; - void * pNext = {}; - ExternalFenceHandleTypeFlags exportFromImportedHandleTypes = {}; - ExternalFenceHandleTypeFlags compatibleHandleTypes = {}; - ExternalFenceFeatureFlags externalFenceFeatures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalFenceProperties; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalFenceProperties; - }; - - using ExternalFencePropertiesKHR = ExternalFenceProperties; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - // wrapper struct for struct VkExternalFormatANDROID, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFormatANDROID.html - struct ExternalFormatANDROID - { - using NativeType = VkExternalFormatANDROID; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFormatANDROID; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( uint64_t externalFormat_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , externalFormat{ externalFormat_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalFormatANDROID( ExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalFormatANDROID( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalFormatANDROID( *reinterpret_cast( &rhs ) ) - { - } - - ExternalFormatANDROID & operator=( ExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalFormatANDROID & operator=( VkExternalFormatANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalFormatANDROID & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalFormatANDROID && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalFormatANDROID & setExternalFormat( uint64_t externalFormat_ ) & VULKAN_HPP_NOEXCEPT - { - externalFormat = externalFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalFormatANDROID && setExternalFormat( uint64_t externalFormat_ ) && VULKAN_HPP_NOEXCEPT - { - externalFormat = externalFormat_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalFormatANDROID const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalFormatANDROID &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalFormatANDROID const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalFormatANDROID *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, externalFormat ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalFormatANDROID const & ) const = default; -# else - bool operator==( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat ); -# endif - } - - bool operator!=( ExternalFormatANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExternalFormatANDROID; - void * pNext = {}; - uint64_t externalFormat = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalFormatANDROID; - }; -# endif - - template <> - struct CppType - { - using Type = ExternalFormatANDROID; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_OHOS ) - // wrapper struct for struct VkExternalFormatOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFormatOHOS.html - struct ExternalFormatOHOS - { - using NativeType = VkExternalFormatOHOS; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFormatOHOS; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalFormatOHOS( uint64_t externalFormat_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , externalFormat{ externalFormat_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalFormatOHOS( ExternalFormatOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalFormatOHOS( VkExternalFormatOHOS const & rhs ) VULKAN_HPP_NOEXCEPT : ExternalFormatOHOS( *reinterpret_cast( &rhs ) ) {} - - ExternalFormatOHOS & operator=( ExternalFormatOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalFormatOHOS & operator=( VkExternalFormatOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalFormatOHOS & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalFormatOHOS && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalFormatOHOS & setExternalFormat( uint64_t externalFormat_ ) & VULKAN_HPP_NOEXCEPT - { - externalFormat = externalFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalFormatOHOS && setExternalFormat( uint64_t externalFormat_ ) && VULKAN_HPP_NOEXCEPT - { - externalFormat = externalFormat_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalFormatOHOS const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalFormatOHOS &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalFormatOHOS const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalFormatOHOS *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, externalFormat ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalFormatOHOS const & ) const = default; -# else - bool operator==( ExternalFormatOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat ); -# endif - } - - bool operator!=( ExternalFormatOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExternalFormatOHOS; - void * pNext = {}; - uint64_t externalFormat = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalFormatOHOS; - }; -# endif - - template <> - struct CppType - { - using Type = ExternalFormatOHOS; - }; -#endif /*VK_USE_PLATFORM_OHOS*/ - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - // wrapper struct for struct VkExternalFormatQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFormatQNX.html - struct ExternalFormatQNX - { - using NativeType = VkExternalFormatQNX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalFormatQNX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalFormatQNX( uint64_t externalFormat_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , externalFormat{ externalFormat_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalFormatQNX( ExternalFormatQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalFormatQNX( VkExternalFormatQNX const & rhs ) VULKAN_HPP_NOEXCEPT : ExternalFormatQNX( *reinterpret_cast( &rhs ) ) {} - - ExternalFormatQNX & operator=( ExternalFormatQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalFormatQNX & operator=( VkExternalFormatQNX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalFormatQNX & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalFormatQNX && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalFormatQNX & setExternalFormat( uint64_t externalFormat_ ) & VULKAN_HPP_NOEXCEPT - { - externalFormat = externalFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalFormatQNX && setExternalFormat( uint64_t externalFormat_ ) && VULKAN_HPP_NOEXCEPT - { - externalFormat = externalFormat_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalFormatQNX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalFormatQNX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalFormatQNX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalFormatQNX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, externalFormat ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalFormatQNX const & ) const = default; -# else - bool operator==( ExternalFormatQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormat == rhs.externalFormat ); -# endif - } - - bool operator!=( ExternalFormatQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eExternalFormatQNX; - void * pNext = {}; - uint64_t externalFormat = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalFormatQNX; - }; -# endif - - template <> - struct CppType - { - using Type = ExternalFormatQNX; - }; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - // wrapper struct for struct VkExternalImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalImageFormatProperties.html - struct ExternalImageFormatProperties - { - using NativeType = VkExternalImageFormatProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalImageFormatProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalImageFormatProperties( ExternalMemoryProperties externalMemoryProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , externalMemoryProperties{ externalMemoryProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalImageFormatProperties( ExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalImageFormatProperties( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalImageFormatProperties( *reinterpret_cast( &rhs ) ) - { - } - - ExternalImageFormatProperties & operator=( ExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalImageFormatProperties & operator=( VkExternalImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkExternalImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalImageFormatProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalImageFormatProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalImageFormatProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, externalMemoryProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalImageFormatProperties const & ) const = default; -#else - bool operator==( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryProperties == rhs.externalMemoryProperties ); -# endif - } - - bool operator!=( ExternalImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalImageFormatProperties; - void * pNext = {}; - ExternalMemoryProperties externalMemoryProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalImageFormatProperties; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalImageFormatProperties; - }; - - using ExternalImageFormatPropertiesKHR = ExternalImageFormatProperties; - - // wrapper struct for struct VkImageFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatProperties.html - struct ImageFormatProperties - { - using NativeType = VkImageFormatProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageFormatProperties( Extent3D maxExtent_ = {}, - uint32_t maxMipLevels_ = {}, - uint32_t maxArrayLayers_ = {}, - SampleCountFlags sampleCounts_ = {}, - DeviceSize maxResourceSize_ = {} ) VULKAN_HPP_NOEXCEPT - : maxExtent{ maxExtent_ } - , maxMipLevels{ maxMipLevels_ } - , maxArrayLayers{ maxArrayLayers_ } - , sampleCounts{ sampleCounts_ } - , maxResourceSize{ maxResourceSize_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageFormatProperties( ImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageFormatProperties( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageFormatProperties( *reinterpret_cast( &rhs ) ) - { - } - - ImageFormatProperties & operator=( ImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageFormatProperties & operator=( VkImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageFormatProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageFormatProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageFormatProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( maxExtent, maxMipLevels, maxArrayLayers, sampleCounts, maxResourceSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageFormatProperties const & ) const = default; -#else - bool operator==( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( maxExtent == rhs.maxExtent ) && ( maxMipLevels == rhs.maxMipLevels ) && ( maxArrayLayers == rhs.maxArrayLayers ) && - ( sampleCounts == rhs.sampleCounts ) && ( maxResourceSize == rhs.maxResourceSize ); -# endif - } - - bool operator!=( ImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Extent3D maxExtent = {}; - uint32_t maxMipLevels = {}; - uint32_t maxArrayLayers = {}; - SampleCountFlags sampleCounts = {}; - DeviceSize maxResourceSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageFormatProperties; - }; -#endif - - // wrapper struct for struct VkExternalImageFormatPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalImageFormatPropertiesNV.html - struct ExternalImageFormatPropertiesNV - { - using NativeType = VkExternalImageFormatPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalImageFormatPropertiesNV( ImageFormatProperties imageFormatProperties_ = {}, - ExternalMemoryFeatureFlagsNV externalMemoryFeatures_ = {}, - ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes_ = {}, - ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes_ = {} ) VULKAN_HPP_NOEXCEPT - : imageFormatProperties{ imageFormatProperties_ } - , externalMemoryFeatures{ externalMemoryFeatures_ } - , exportFromImportedHandleTypes{ exportFromImportedHandleTypes_ } - , compatibleHandleTypes{ compatibleHandleTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalImageFormatPropertiesNV( ExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalImageFormatPropertiesNV( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalImageFormatPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - ExternalImageFormatPropertiesNV & operator=( ExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalImageFormatPropertiesNV & operator=( VkExternalImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkExternalImageFormatPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalImageFormatPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalImageFormatPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalImageFormatPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( imageFormatProperties, externalMemoryFeatures, exportFromImportedHandleTypes, compatibleHandleTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalImageFormatPropertiesNV const & ) const = default; -#else - bool operator==( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( imageFormatProperties == rhs.imageFormatProperties ) && ( externalMemoryFeatures == rhs.externalMemoryFeatures ) && - ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && ( compatibleHandleTypes == rhs.compatibleHandleTypes ); -# endif - } - - bool operator!=( ExternalImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ImageFormatProperties imageFormatProperties = {}; - ExternalMemoryFeatureFlagsNV externalMemoryFeatures = {}; - ExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes = {}; - ExternalMemoryHandleTypeFlagsNV compatibleHandleTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalImageFormatPropertiesNV; - }; -#endif - - // wrapper struct for struct VkExternalMemoryAcquireUnmodifiedEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryAcquireUnmodifiedEXT.html - struct ExternalMemoryAcquireUnmodifiedEXT - { - using NativeType = VkExternalMemoryAcquireUnmodifiedEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryAcquireUnmodifiedEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalMemoryAcquireUnmodifiedEXT( Bool32 acquireUnmodifiedMemory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , acquireUnmodifiedMemory{ acquireUnmodifiedMemory_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalMemoryAcquireUnmodifiedEXT( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalMemoryAcquireUnmodifiedEXT( VkExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalMemoryAcquireUnmodifiedEXT( *reinterpret_cast( &rhs ) ) - { - } - - ExternalMemoryAcquireUnmodifiedEXT & operator=( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalMemoryAcquireUnmodifiedEXT & operator=( VkExternalMemoryAcquireUnmodifiedEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT & setAcquireUnmodifiedMemory( Bool32 acquireUnmodifiedMemory_ ) & VULKAN_HPP_NOEXCEPT - { - acquireUnmodifiedMemory = acquireUnmodifiedMemory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryAcquireUnmodifiedEXT && setAcquireUnmodifiedMemory( Bool32 acquireUnmodifiedMemory_ ) && VULKAN_HPP_NOEXCEPT - { - acquireUnmodifiedMemory = acquireUnmodifiedMemory_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalMemoryAcquireUnmodifiedEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryAcquireUnmodifiedEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryAcquireUnmodifiedEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalMemoryAcquireUnmodifiedEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, acquireUnmodifiedMemory ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalMemoryAcquireUnmodifiedEXT const & ) const = default; -#else - bool operator==( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireUnmodifiedMemory == rhs.acquireUnmodifiedMemory ); -# endif - } - - bool operator!=( ExternalMemoryAcquireUnmodifiedEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalMemoryAcquireUnmodifiedEXT; - const void * pNext = {}; - Bool32 acquireUnmodifiedMemory = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalMemoryAcquireUnmodifiedEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalMemoryAcquireUnmodifiedEXT; - }; - - // wrapper struct for struct VkExternalMemoryBufferCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryBufferCreateInfo.html - struct ExternalMemoryBufferCreateInfo - { - using NativeType = VkExternalMemoryBufferCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryBufferCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleTypes{ handleTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalMemoryBufferCreateInfo( ExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalMemoryBufferCreateInfo( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalMemoryBufferCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - ExternalMemoryBufferCreateInfo & operator=( ExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalMemoryBufferCreateInfo & operator=( VkExternalMemoryBufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryBufferCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryBufferCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryBufferCreateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryBufferCreateInfo && setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalMemoryBufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryBufferCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryBufferCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalMemoryBufferCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalMemoryBufferCreateInfo const & ) const = default; -#else - bool operator==( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); -# endif - } - - bool operator!=( ExternalMemoryBufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalMemoryBufferCreateInfo; - const void * pNext = {}; - ExternalMemoryHandleTypeFlags handleTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalMemoryBufferCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalMemoryBufferCreateInfo; - }; - - using ExternalMemoryBufferCreateInfoKHR = ExternalMemoryBufferCreateInfo; - - // wrapper struct for struct VkExternalMemoryImageCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryImageCreateInfo.html - struct ExternalMemoryImageCreateInfo - { - using NativeType = VkExternalMemoryImageCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryImageCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( ExternalMemoryHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleTypes{ handleTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfo( ExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalMemoryImageCreateInfo( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalMemoryImageCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - ExternalMemoryImageCreateInfo & operator=( ExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalMemoryImageCreateInfo & operator=( VkExternalMemoryImageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfo & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfo && setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalMemoryImageCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryImageCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryImageCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalMemoryImageCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalMemoryImageCreateInfo const & ) const = default; -#else - bool operator==( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); -# endif - } - - bool operator!=( ExternalMemoryImageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalMemoryImageCreateInfo; - const void * pNext = {}; - ExternalMemoryHandleTypeFlags handleTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalMemoryImageCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalMemoryImageCreateInfo; - }; - - using ExternalMemoryImageCreateInfoKHR = ExternalMemoryImageCreateInfo; - - // wrapper struct for struct VkExternalMemoryImageCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryImageCreateInfoNV.html - struct ExternalMemoryImageCreateInfoNV - { - using NativeType = VkExternalMemoryImageCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryImageCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( ExternalMemoryHandleTypeFlagsNV handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleTypes{ handleTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalMemoryImageCreateInfoNV( ExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalMemoryImageCreateInfoNV( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalMemoryImageCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ExternalMemoryImageCreateInfoNV & operator=( ExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalMemoryImageCreateInfoNV & operator=( VkExternalMemoryImageCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfoNV & setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) & VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryImageCreateInfoNV && setHandleTypes( ExternalMemoryHandleTypeFlagsNV handleTypes_ ) && VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalMemoryImageCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryImageCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryImageCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalMemoryImageCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalMemoryImageCreateInfoNV const & ) const = default; -#else - bool operator==( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); -# endif - } - - bool operator!=( ExternalMemoryImageCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalMemoryImageCreateInfoNV; - const void * pNext = {}; - ExternalMemoryHandleTypeFlagsNV handleTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalMemoryImageCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalMemoryImageCreateInfoNV; - }; - - // wrapper struct for struct VkExternalMemoryTensorCreateInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalMemoryTensorCreateInfoARM.html - struct ExternalMemoryTensorCreateInfoARM - { - using NativeType = VkExternalMemoryTensorCreateInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalMemoryTensorCreateInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalMemoryTensorCreateInfoARM( ExternalMemoryHandleTypeFlags handleTypes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleTypes{ handleTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalMemoryTensorCreateInfoARM( ExternalMemoryTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalMemoryTensorCreateInfoARM( VkExternalMemoryTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalMemoryTensorCreateInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - ExternalMemoryTensorCreateInfoARM & operator=( ExternalMemoryTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalMemoryTensorCreateInfoARM & operator=( VkExternalMemoryTensorCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryTensorCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryTensorCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryTensorCreateInfoARM & setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) & VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalMemoryTensorCreateInfoARM && setHandleTypes( ExternalMemoryHandleTypeFlags handleTypes_ ) && VULKAN_HPP_NOEXCEPT - { - handleTypes = handleTypes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalMemoryTensorCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryTensorCreateInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalMemoryTensorCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalMemoryTensorCreateInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalMemoryTensorCreateInfoARM const & ) const = default; -#else - bool operator==( ExternalMemoryTensorCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleTypes == rhs.handleTypes ); -# endif - } - - bool operator!=( ExternalMemoryTensorCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalMemoryTensorCreateInfoARM; - const void * pNext = {}; - ExternalMemoryHandleTypeFlags handleTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalMemoryTensorCreateInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalMemoryTensorCreateInfoARM; - }; - - // wrapper struct for struct VkExternalSemaphoreProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalSemaphoreProperties.html - struct ExternalSemaphoreProperties - { - using NativeType = VkExternalSemaphoreProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalSemaphoreProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalSemaphoreProperties( ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes_ = {}, - ExternalSemaphoreHandleTypeFlags compatibleHandleTypes_ = {}, - ExternalSemaphoreFeatureFlags externalSemaphoreFeatures_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , exportFromImportedHandleTypes{ exportFromImportedHandleTypes_ } - , compatibleHandleTypes{ compatibleHandleTypes_ } - , externalSemaphoreFeatures{ externalSemaphoreFeatures_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalSemaphoreProperties( ExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalSemaphoreProperties( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalSemaphoreProperties( *reinterpret_cast( &rhs ) ) - { - } - - ExternalSemaphoreProperties & operator=( ExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalSemaphoreProperties & operator=( VkExternalSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkExternalSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalSemaphoreProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalSemaphoreProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalSemaphoreProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, exportFromImportedHandleTypes, compatibleHandleTypes, externalSemaphoreFeatures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalSemaphoreProperties const & ) const = default; -#else - bool operator==( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exportFromImportedHandleTypes == rhs.exportFromImportedHandleTypes ) && - ( compatibleHandleTypes == rhs.compatibleHandleTypes ) && ( externalSemaphoreFeatures == rhs.externalSemaphoreFeatures ); -# endif - } - - bool operator!=( ExternalSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalSemaphoreProperties; - void * pNext = {}; - ExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes = {}; - ExternalSemaphoreHandleTypeFlags compatibleHandleTypes = {}; - ExternalSemaphoreFeatureFlags externalSemaphoreFeatures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalSemaphoreProperties; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalSemaphoreProperties; - }; - - using ExternalSemaphorePropertiesKHR = ExternalSemaphoreProperties; - - // wrapper struct for struct VkExternalTensorPropertiesARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalTensorPropertiesARM.html - struct ExternalTensorPropertiesARM - { - using NativeType = VkExternalTensorPropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalTensorPropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ExternalTensorPropertiesARM( ExternalMemoryProperties externalMemoryProperties_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , externalMemoryProperties{ externalMemoryProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR ExternalTensorPropertiesARM( ExternalTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ExternalTensorPropertiesARM( VkExternalTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : ExternalTensorPropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - ExternalTensorPropertiesARM & operator=( ExternalTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ExternalTensorPropertiesARM & operator=( VkExternalTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ExternalTensorPropertiesARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalTensorPropertiesARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ExternalTensorPropertiesARM & setExternalMemoryProperties( ExternalMemoryProperties const & externalMemoryProperties_ ) & - VULKAN_HPP_NOEXCEPT - { - externalMemoryProperties = externalMemoryProperties_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ExternalTensorPropertiesARM && setExternalMemoryProperties( ExternalMemoryProperties const & externalMemoryProperties_ ) && - VULKAN_HPP_NOEXCEPT - { - externalMemoryProperties = externalMemoryProperties_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkExternalTensorPropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalTensorPropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkExternalTensorPropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkExternalTensorPropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, externalMemoryProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ExternalTensorPropertiesARM const & ) const = default; -#else - bool operator==( ExternalTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryProperties == rhs.externalMemoryProperties ); -# endif - } - - bool operator!=( ExternalTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eExternalTensorPropertiesARM; - const void * pNext = {}; - ExternalMemoryProperties externalMemoryProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ExternalTensorPropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = ExternalTensorPropertiesARM; - }; - - // wrapper struct for struct VkFenceCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceCreateInfo.html - struct FenceCreateInfo - { - using NativeType = VkFenceCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FenceCreateInfo( FenceCreateFlags flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR FenceCreateInfo( FenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FenceCreateInfo( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : FenceCreateInfo( *reinterpret_cast( &rhs ) ) {} - - FenceCreateInfo & operator=( FenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FenceCreateInfo & operator=( VkFenceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 FenceCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FenceCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FenceCreateInfo & setFlags( FenceCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FenceCreateInfo && setFlags( FenceCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkFenceCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFenceCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFenceCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFenceCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FenceCreateInfo const & ) const = default; -#else - bool operator==( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( FenceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFenceCreateInfo; - const void * pNext = {}; - FenceCreateFlags flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FenceCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = FenceCreateInfo; - }; - - // wrapper struct for struct VkFenceGetFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceGetFdInfoKHR.html - struct FenceGetFdInfoKHR - { - using NativeType = VkFenceGetFdInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceGetFdInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( Fence fence_ = {}, - ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fence{ fence_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR FenceGetFdInfoKHR( FenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FenceGetFdInfoKHR( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : FenceGetFdInfoKHR( *reinterpret_cast( &rhs ) ) {} - - FenceGetFdInfoKHR & operator=( FenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FenceGetFdInfoKHR & operator=( VkFenceGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR & setFence( Fence fence_ ) & VULKAN_HPP_NOEXCEPT - { - fence = fence_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR && setFence( Fence fence_ ) && VULKAN_HPP_NOEXCEPT - { - fence = fence_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FenceGetFdInfoKHR && setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkFenceGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFenceGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFenceGetFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFenceGetFdInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fence, handleType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FenceGetFdInfoKHR const & ) const = default; -#else - bool operator==( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( FenceGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFenceGetFdInfoKHR; - const void * pNext = {}; - Fence fence = {}; - ExternalFenceHandleTypeFlagBits handleType = ExternalFenceHandleTypeFlagBits::eOpaqueFd; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FenceGetFdInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = FenceGetFdInfoKHR; - }; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkFenceGetWin32HandleInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFenceGetWin32HandleInfoKHR.html - struct FenceGetWin32HandleInfoKHR - { - using NativeType = VkFenceGetWin32HandleInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFenceGetWin32HandleInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( Fence fence_ = {}, - ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fence{ fence_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR FenceGetWin32HandleInfoKHR( FenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FenceGetWin32HandleInfoKHR( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : FenceGetWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - FenceGetWin32HandleInfoKHR & operator=( FenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FenceGetWin32HandleInfoKHR & operator=( VkFenceGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR & setFence( Fence fence_ ) & VULKAN_HPP_NOEXCEPT - { - fence = fence_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR && setFence( Fence fence_ ) && VULKAN_HPP_NOEXCEPT - { - fence = fence_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FenceGetWin32HandleInfoKHR && setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkFenceGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFenceGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFenceGetWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFenceGetWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fence, handleType ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FenceGetWin32HandleInfoKHR const & ) const = default; -# else - bool operator==( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( FenceGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eFenceGetWin32HandleInfoKHR; - const void * pNext = {}; - Fence fence = {}; - ExternalFenceHandleTypeFlagBits handleType = ExternalFenceHandleTypeFlagBits::eOpaqueFd; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FenceGetWin32HandleInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = FenceGetWin32HandleInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - // wrapper struct for struct VkFilterCubicImageViewImageFormatPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFilterCubicImageViewImageFormatPropertiesEXT.html - struct FilterCubicImageViewImageFormatPropertiesEXT - { - using NativeType = VkFilterCubicImageViewImageFormatPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - FilterCubicImageViewImageFormatPropertiesEXT( Bool32 filterCubic_ = {}, Bool32 filterCubicMinmax_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , filterCubic{ filterCubic_ } - , filterCubicMinmax{ filterCubicMinmax_ } - { - } - - VULKAN_HPP_CONSTEXPR FilterCubicImageViewImageFormatPropertiesEXT( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FilterCubicImageViewImageFormatPropertiesEXT( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : FilterCubicImageViewImageFormatPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - FilterCubicImageViewImageFormatPropertiesEXT & operator=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FilterCubicImageViewImageFormatPropertiesEXT & operator=( VkFilterCubicImageViewImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkFilterCubicImageViewImageFormatPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFilterCubicImageViewImageFormatPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFilterCubicImageViewImageFormatPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFilterCubicImageViewImageFormatPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, filterCubic, filterCubicMinmax ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FilterCubicImageViewImageFormatPropertiesEXT const & ) const = default; -#else - bool operator==( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCubic == rhs.filterCubic ) && ( filterCubicMinmax == rhs.filterCubicMinmax ); -# endif - } - - bool operator!=( FilterCubicImageViewImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFilterCubicImageViewImageFormatPropertiesEXT; - void * pNext = {}; - Bool32 filterCubic = {}; - Bool32 filterCubicMinmax = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FilterCubicImageViewImageFormatPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = FilterCubicImageViewImageFormatPropertiesEXT; - }; - - // wrapper struct for struct VkFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatProperties.html - struct FormatProperties - { - using NativeType = VkFormatProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FormatProperties( FormatFeatureFlags linearTilingFeatures_ = {}, - FormatFeatureFlags optimalTilingFeatures_ = {}, - FormatFeatureFlags bufferFeatures_ = {} ) VULKAN_HPP_NOEXCEPT - : linearTilingFeatures{ linearTilingFeatures_ } - , optimalTilingFeatures{ optimalTilingFeatures_ } - , bufferFeatures{ bufferFeatures_ } - { - } - - VULKAN_HPP_CONSTEXPR FormatProperties( FormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FormatProperties( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT : FormatProperties( *reinterpret_cast( &rhs ) ) {} - - FormatProperties & operator=( FormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FormatProperties & operator=( VkFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkFormatProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFormatProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFormatProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFormatProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( linearTilingFeatures, optimalTilingFeatures, bufferFeatures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FormatProperties const & ) const = default; -#else - bool operator==( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( linearTilingFeatures == rhs.linearTilingFeatures ) && ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && - ( bufferFeatures == rhs.bufferFeatures ); -# endif - } - - bool operator!=( FormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - FormatFeatureFlags linearTilingFeatures = {}; - FormatFeatureFlags optimalTilingFeatures = {}; - FormatFeatureFlags bufferFeatures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FormatProperties; - }; -#endif - - // wrapper struct for struct VkFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatProperties2.html - struct FormatProperties2 - { - using NativeType = VkFormatProperties2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFormatProperties2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FormatProperties2( FormatProperties formatProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , formatProperties{ formatProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR FormatProperties2( FormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FormatProperties2( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT : FormatProperties2( *reinterpret_cast( &rhs ) ) {} - - FormatProperties2 & operator=( FormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FormatProperties2 & operator=( VkFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFormatProperties2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFormatProperties2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFormatProperties2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, formatProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FormatProperties2 const & ) const = default; -#else - bool operator==( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatProperties == rhs.formatProperties ); -# endif - } - - bool operator!=( FormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFormatProperties2; - void * pNext = {}; - FormatProperties formatProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FormatProperties2; - }; -#endif - - template <> - struct CppType - { - using Type = FormatProperties2; - }; - - using FormatProperties2KHR = FormatProperties2; - - // wrapper struct for struct VkFormatProperties3, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFormatProperties3.html - struct FormatProperties3 - { - using NativeType = VkFormatProperties3; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFormatProperties3; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FormatProperties3( FormatFeatureFlags2 linearTilingFeatures_ = {}, - FormatFeatureFlags2 optimalTilingFeatures_ = {}, - FormatFeatureFlags2 bufferFeatures_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , linearTilingFeatures{ linearTilingFeatures_ } - , optimalTilingFeatures{ optimalTilingFeatures_ } - , bufferFeatures{ bufferFeatures_ } - { - } - - VULKAN_HPP_CONSTEXPR FormatProperties3( FormatProperties3 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FormatProperties3( VkFormatProperties3 const & rhs ) VULKAN_HPP_NOEXCEPT : FormatProperties3( *reinterpret_cast( &rhs ) ) {} - - FormatProperties3 & operator=( FormatProperties3 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FormatProperties3 & operator=( VkFormatProperties3 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkFormatProperties3 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFormatProperties3 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFormatProperties3 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFormatProperties3 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, linearTilingFeatures, optimalTilingFeatures, bufferFeatures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FormatProperties3 const & ) const = default; -#else - bool operator==( FormatProperties3 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearTilingFeatures == rhs.linearTilingFeatures ) && - ( optimalTilingFeatures == rhs.optimalTilingFeatures ) && ( bufferFeatures == rhs.bufferFeatures ); -# endif - } - - bool operator!=( FormatProperties3 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFormatProperties3; - void * pNext = {}; - FormatFeatureFlags2 linearTilingFeatures = {}; - FormatFeatureFlags2 optimalTilingFeatures = {}; - FormatFeatureFlags2 bufferFeatures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FormatProperties3; - }; -#endif - - template <> - struct CppType - { - using Type = FormatProperties3; - }; - - using FormatProperties3KHR = FormatProperties3; - - // wrapper struct for struct VkFragmentShadingRateAttachmentInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFragmentShadingRateAttachmentInfoKHR.html - struct FragmentShadingRateAttachmentInfoKHR - { - using NativeType = VkFragmentShadingRateAttachmentInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFragmentShadingRateAttachmentInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FragmentShadingRateAttachmentInfoKHR( const AttachmentReference2 * pFragmentShadingRateAttachment_ = {}, - Extent2D shadingRateAttachmentTexelSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pFragmentShadingRateAttachment{ pFragmentShadingRateAttachment_ } - , shadingRateAttachmentTexelSize{ shadingRateAttachmentTexelSize_ } - { - } - - VULKAN_HPP_CONSTEXPR FragmentShadingRateAttachmentInfoKHR( FragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FragmentShadingRateAttachmentInfoKHR( VkFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : FragmentShadingRateAttachmentInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - FragmentShadingRateAttachmentInfoKHR & operator=( FragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FragmentShadingRateAttachmentInfoKHR & operator=( VkFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR & - setPFragmentShadingRateAttachment( const AttachmentReference2 * pFragmentShadingRateAttachment_ ) & - VULKAN_HPP_NOEXCEPT - { - pFragmentShadingRateAttachment = pFragmentShadingRateAttachment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR && - setPFragmentShadingRateAttachment( const AttachmentReference2 * pFragmentShadingRateAttachment_ ) && - VULKAN_HPP_NOEXCEPT - { - pFragmentShadingRateAttachment = pFragmentShadingRateAttachment_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR & setShadingRateAttachmentTexelSize( Extent2D const & shadingRateAttachmentTexelSize_ ) & - VULKAN_HPP_NOEXCEPT - { - shadingRateAttachmentTexelSize = shadingRateAttachmentTexelSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FragmentShadingRateAttachmentInfoKHR && setShadingRateAttachmentTexelSize( Extent2D const & shadingRateAttachmentTexelSize_ ) && - VULKAN_HPP_NOEXCEPT - { - shadingRateAttachmentTexelSize = shadingRateAttachmentTexelSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFragmentShadingRateAttachmentInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFragmentShadingRateAttachmentInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pFragmentShadingRateAttachment, shadingRateAttachmentTexelSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FragmentShadingRateAttachmentInfoKHR const & ) const = default; -#else - bool operator==( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pFragmentShadingRateAttachment == rhs.pFragmentShadingRateAttachment ) && - ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize ); -# endif - } - - bool operator!=( FragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFragmentShadingRateAttachmentInfoKHR; - const void * pNext = {}; - const AttachmentReference2 * pFragmentShadingRateAttachment = {}; - Extent2D shadingRateAttachmentTexelSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FragmentShadingRateAttachmentInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = FragmentShadingRateAttachmentInfoKHR; - }; - - // wrapper struct for struct VkFrameBoundaryEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrameBoundaryEXT.html - struct FrameBoundaryEXT - { - using NativeType = VkFrameBoundaryEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFrameBoundaryEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FrameBoundaryEXT( FrameBoundaryFlagsEXT flags_ = {}, - uint64_t frameID_ = {}, - uint32_t imageCount_ = {}, - const Image * pImages_ = {}, - uint32_t bufferCount_ = {}, - const Buffer * pBuffers_ = {}, - uint64_t tagName_ = {}, - size_t tagSize_ = {}, - const void * pTag_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , frameID{ frameID_ } - , imageCount{ imageCount_ } - , pImages{ pImages_ } - , bufferCount{ bufferCount_ } - , pBuffers{ pBuffers_ } - , tagName{ tagName_ } - , tagSize{ tagSize_ } - , pTag{ pTag_ } - { - } - - VULKAN_HPP_CONSTEXPR FrameBoundaryEXT( FrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FrameBoundaryEXT( VkFrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT : FrameBoundaryEXT( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - FrameBoundaryEXT( FrameBoundaryFlagsEXT flags_, - uint64_t frameID_, - ArrayProxyNoTemporaries const & images_, - ArrayProxyNoTemporaries const & buffers_ = {}, - uint64_t tagName_ = {}, - ArrayProxyNoTemporaries const & tag_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , frameID( frameID_ ) - , imageCount( static_cast( images_.size() ) ) - , pImages( images_.data() ) - , bufferCount( static_cast( buffers_.size() ) ) - , pBuffers( buffers_.data() ) - , tagName( tagName_ ) - , tagSize( tag_.size() * sizeof( T ) ) - , pTag( tag_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - FrameBoundaryEXT & operator=( FrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FrameBoundaryEXT & operator=( VkFrameBoundaryEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setFlags( FrameBoundaryFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setFlags( FrameBoundaryFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setFrameID( uint64_t frameID_ ) & VULKAN_HPP_NOEXCEPT - { - frameID = frameID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setFrameID( uint64_t frameID_ ) && VULKAN_HPP_NOEXCEPT - { - frameID = frameID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setImageCount( uint32_t imageCount_ ) & VULKAN_HPP_NOEXCEPT - { - imageCount = imageCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setImageCount( uint32_t imageCount_ ) && VULKAN_HPP_NOEXCEPT - { - imageCount = imageCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPImages( const Image * pImages_ ) & VULKAN_HPP_NOEXCEPT - { - pImages = pImages_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setPImages( const Image * pImages_ ) && VULKAN_HPP_NOEXCEPT - { - pImages = pImages_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - FrameBoundaryEXT & setImages( ArrayProxyNoTemporaries const & images_ ) VULKAN_HPP_NOEXCEPT - { - imageCount = static_cast( images_.size() ); - pImages = images_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setBufferCount( uint32_t bufferCount_ ) & VULKAN_HPP_NOEXCEPT - { - bufferCount = bufferCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setBufferCount( uint32_t bufferCount_ ) && VULKAN_HPP_NOEXCEPT - { - bufferCount = bufferCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPBuffers( const Buffer * pBuffers_ ) & VULKAN_HPP_NOEXCEPT - { - pBuffers = pBuffers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setPBuffers( const Buffer * pBuffers_ ) && VULKAN_HPP_NOEXCEPT - { - pBuffers = pBuffers_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - FrameBoundaryEXT & setBuffers( ArrayProxyNoTemporaries const & buffers_ ) VULKAN_HPP_NOEXCEPT - { - bufferCount = static_cast( buffers_.size() ); - pBuffers = buffers_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setTagName( uint64_t tagName_ ) & VULKAN_HPP_NOEXCEPT - { - tagName = tagName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setTagName( uint64_t tagName_ ) && VULKAN_HPP_NOEXCEPT - { - tagName = tagName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setTagSize( size_t tagSize_ ) & VULKAN_HPP_NOEXCEPT - { - tagSize = tagSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setTagSize( size_t tagSize_ ) && VULKAN_HPP_NOEXCEPT - { - tagSize = tagSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT & setPTag( const void * pTag_ ) & VULKAN_HPP_NOEXCEPT - { - pTag = pTag_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryEXT && setPTag( const void * pTag_ ) && VULKAN_HPP_NOEXCEPT - { - pTag = pTag_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - FrameBoundaryEXT & setTag( ArrayProxyNoTemporaries const & tag_ ) VULKAN_HPP_NOEXCEPT - { - tagSize = tag_.size() * sizeof( T ); - pTag = tag_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkFrameBoundaryEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFrameBoundaryEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFrameBoundaryEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFrameBoundaryEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, frameID, imageCount, pImages, bufferCount, pBuffers, tagName, tagSize, pTag ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FrameBoundaryEXT const & ) const = default; -#else - bool operator==( FrameBoundaryEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( frameID == rhs.frameID ) && ( imageCount == rhs.imageCount ) && - ( pImages == rhs.pImages ) && ( bufferCount == rhs.bufferCount ) && ( pBuffers == rhs.pBuffers ) && ( tagName == rhs.tagName ) && - ( tagSize == rhs.tagSize ) && ( pTag == rhs.pTag ); -# endif - } - - bool operator!=( FrameBoundaryEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFrameBoundaryEXT; - const void * pNext = {}; - FrameBoundaryFlagsEXT flags = {}; - uint64_t frameID = {}; - uint32_t imageCount = {}; - const Image * pImages = {}; - uint32_t bufferCount = {}; - const Buffer * pBuffers = {}; - uint64_t tagName = {}; - size_t tagSize = {}; - const void * pTag = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FrameBoundaryEXT; - }; -#endif - - template <> - struct CppType - { - using Type = FrameBoundaryEXT; - }; - - // wrapper struct for struct VkFrameBoundaryTensorsARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFrameBoundaryTensorsARM.html - struct FrameBoundaryTensorsARM - { - using NativeType = VkFrameBoundaryTensorsARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFrameBoundaryTensorsARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - FrameBoundaryTensorsARM( uint32_t tensorCount_ = {}, const TensorARM * pTensors_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensorCount{ tensorCount_ } - , pTensors{ pTensors_ } - { - } - - VULKAN_HPP_CONSTEXPR FrameBoundaryTensorsARM( FrameBoundaryTensorsARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FrameBoundaryTensorsARM( VkFrameBoundaryTensorsARM const & rhs ) VULKAN_HPP_NOEXCEPT - : FrameBoundaryTensorsARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - FrameBoundaryTensorsARM( ArrayProxyNoTemporaries const & tensors_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), tensorCount( static_cast( tensors_.size() ) ), pTensors( tensors_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - FrameBoundaryTensorsARM & operator=( FrameBoundaryTensorsARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FrameBoundaryTensorsARM & operator=( VkFrameBoundaryTensorsARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM & setTensorCount( uint32_t tensorCount_ ) & VULKAN_HPP_NOEXCEPT - { - tensorCount = tensorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM && setTensorCount( uint32_t tensorCount_ ) && VULKAN_HPP_NOEXCEPT - { - tensorCount = tensorCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM & setPTensors( const TensorARM * pTensors_ ) & VULKAN_HPP_NOEXCEPT - { - pTensors = pTensors_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FrameBoundaryTensorsARM && setPTensors( const TensorARM * pTensors_ ) && VULKAN_HPP_NOEXCEPT - { - pTensors = pTensors_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - FrameBoundaryTensorsARM & setTensors( ArrayProxyNoTemporaries const & tensors_ ) VULKAN_HPP_NOEXCEPT - { - tensorCount = static_cast( tensors_.size() ); - pTensors = tensors_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkFrameBoundaryTensorsARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFrameBoundaryTensorsARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFrameBoundaryTensorsARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFrameBoundaryTensorsARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tensorCount, pTensors ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FrameBoundaryTensorsARM const & ) const = default; -#else - bool operator==( FrameBoundaryTensorsARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorCount == rhs.tensorCount ) && ( pTensors == rhs.pTensors ); -# endif - } - - bool operator!=( FrameBoundaryTensorsARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFrameBoundaryTensorsARM; - const void * pNext = {}; - uint32_t tensorCount = {}; - const TensorARM * pTensors = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FrameBoundaryTensorsARM; - }; -#endif - - template <> - struct CppType - { - using Type = FrameBoundaryTensorsARM; - }; - - // wrapper struct for struct VkFramebufferAttachmentImageInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferAttachmentImageInfo.html - struct FramebufferAttachmentImageInfo - { - using NativeType = VkFramebufferAttachmentImageInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferAttachmentImageInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfo( ImageCreateFlags flags_ = {}, - ImageUsageFlags usage_ = {}, - uint32_t width_ = {}, - uint32_t height_ = {}, - uint32_t layerCount_ = {}, - uint32_t viewFormatCount_ = {}, - const Format * pViewFormats_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , usage{ usage_ } - , width{ width_ } - , height{ height_ } - , layerCount{ layerCount_ } - , viewFormatCount{ viewFormatCount_ } - , pViewFormats{ pViewFormats_ } - { - } - - VULKAN_HPP_CONSTEXPR FramebufferAttachmentImageInfo( FramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FramebufferAttachmentImageInfo( VkFramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : FramebufferAttachmentImageInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - FramebufferAttachmentImageInfo( ImageCreateFlags flags_, - ImageUsageFlags usage_, - uint32_t width_, - uint32_t height_, - uint32_t layerCount_, - ArrayProxyNoTemporaries const & viewFormats_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , usage( usage_ ) - , width( width_ ) - , height( height_ ) - , layerCount( layerCount_ ) - , viewFormatCount( static_cast( viewFormats_.size() ) ) - , pViewFormats( viewFormats_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - FramebufferAttachmentImageInfo & operator=( FramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FramebufferAttachmentImageInfo & operator=( VkFramebufferAttachmentImageInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setFlags( ImageCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setFlags( ImageCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setUsage( ImageUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setUsage( ImageUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT - { - width = width_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT - { - width = width_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT - { - height = height_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT - { - height = height_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setViewFormatCount( uint32_t viewFormatCount_ ) & VULKAN_HPP_NOEXCEPT - { - viewFormatCount = viewFormatCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setViewFormatCount( uint32_t viewFormatCount_ ) && VULKAN_HPP_NOEXCEPT - { - viewFormatCount = viewFormatCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo & setPViewFormats( const Format * pViewFormats_ ) & VULKAN_HPP_NOEXCEPT - { - pViewFormats = pViewFormats_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentImageInfo && setPViewFormats( const Format * pViewFormats_ ) && VULKAN_HPP_NOEXCEPT - { - pViewFormats = pViewFormats_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - FramebufferAttachmentImageInfo & setViewFormats( ArrayProxyNoTemporaries const & viewFormats_ ) VULKAN_HPP_NOEXCEPT - { - viewFormatCount = static_cast( viewFormats_.size() ); - pViewFormats = viewFormats_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkFramebufferAttachmentImageInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFramebufferAttachmentImageInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFramebufferAttachmentImageInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFramebufferAttachmentImageInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, usage, width, height, layerCount, viewFormatCount, pViewFormats ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FramebufferAttachmentImageInfo const & ) const = default; -#else - bool operator==( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) && ( width == rhs.width ) && - ( height == rhs.height ) && ( layerCount == rhs.layerCount ) && ( viewFormatCount == rhs.viewFormatCount ) && ( pViewFormats == rhs.pViewFormats ); -# endif - } - - bool operator!=( FramebufferAttachmentImageInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFramebufferAttachmentImageInfo; - const void * pNext = {}; - ImageCreateFlags flags = {}; - ImageUsageFlags usage = {}; - uint32_t width = {}; - uint32_t height = {}; - uint32_t layerCount = {}; - uint32_t viewFormatCount = {}; - const Format * pViewFormats = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FramebufferAttachmentImageInfo; - }; -#endif - - template <> - struct CppType - { - using Type = FramebufferAttachmentImageInfo; - }; - - using FramebufferAttachmentImageInfoKHR = FramebufferAttachmentImageInfo; - - // wrapper struct for struct VkFramebufferAttachmentsCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferAttachmentsCreateInfo.html - struct FramebufferAttachmentsCreateInfo - { - using NativeType = VkFramebufferAttachmentsCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferAttachmentsCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfo( uint32_t attachmentImageInfoCount_ = {}, - const FramebufferAttachmentImageInfo * pAttachmentImageInfos_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , attachmentImageInfoCount{ attachmentImageInfoCount_ } - , pAttachmentImageInfos{ pAttachmentImageInfos_ } - { - } - - VULKAN_HPP_CONSTEXPR FramebufferAttachmentsCreateInfo( FramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FramebufferAttachmentsCreateInfo( VkFramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : FramebufferAttachmentsCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - FramebufferAttachmentsCreateInfo( ArrayProxyNoTemporaries const & attachmentImageInfos_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , attachmentImageInfoCount( static_cast( attachmentImageInfos_.size() ) ) - , pAttachmentImageInfos( attachmentImageInfos_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - FramebufferAttachmentsCreateInfo & operator=( FramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FramebufferAttachmentsCreateInfo & operator=( VkFramebufferAttachmentsCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo & setAttachmentImageInfoCount( uint32_t attachmentImageInfoCount_ ) & VULKAN_HPP_NOEXCEPT - { - attachmentImageInfoCount = attachmentImageInfoCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo && setAttachmentImageInfoCount( uint32_t attachmentImageInfoCount_ ) && VULKAN_HPP_NOEXCEPT - { - attachmentImageInfoCount = attachmentImageInfoCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo & setPAttachmentImageInfos( const FramebufferAttachmentImageInfo * pAttachmentImageInfos_ ) & - VULKAN_HPP_NOEXCEPT - { - pAttachmentImageInfos = pAttachmentImageInfos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferAttachmentsCreateInfo && setPAttachmentImageInfos( const FramebufferAttachmentImageInfo * pAttachmentImageInfos_ ) && - VULKAN_HPP_NOEXCEPT - { - pAttachmentImageInfos = pAttachmentImageInfos_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - FramebufferAttachmentsCreateInfo & - setAttachmentImageInfos( ArrayProxyNoTemporaries const & attachmentImageInfos_ ) VULKAN_HPP_NOEXCEPT - { - attachmentImageInfoCount = static_cast( attachmentImageInfos_.size() ); - pAttachmentImageInfos = attachmentImageInfos_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkFramebufferAttachmentsCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFramebufferAttachmentsCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFramebufferAttachmentsCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFramebufferAttachmentsCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, attachmentImageInfoCount, pAttachmentImageInfos ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FramebufferAttachmentsCreateInfo const & ) const = default; -#else - bool operator==( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentImageInfoCount == rhs.attachmentImageInfoCount ) && - ( pAttachmentImageInfos == rhs.pAttachmentImageInfos ); -# endif - } - - bool operator!=( FramebufferAttachmentsCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFramebufferAttachmentsCreateInfo; - const void * pNext = {}; - uint32_t attachmentImageInfoCount = {}; - const FramebufferAttachmentImageInfo * pAttachmentImageInfos = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FramebufferAttachmentsCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = FramebufferAttachmentsCreateInfo; - }; - - using FramebufferAttachmentsCreateInfoKHR = FramebufferAttachmentsCreateInfo; - - // wrapper struct for struct VkFramebufferCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferCreateInfo.html - struct FramebufferCreateInfo - { - using NativeType = VkFramebufferCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( FramebufferCreateFlags flags_ = {}, - RenderPass renderPass_ = {}, - uint32_t attachmentCount_ = {}, - const ImageView * pAttachments_ = {}, - uint32_t width_ = {}, - uint32_t height_ = {}, - uint32_t layers_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , renderPass{ renderPass_ } - , attachmentCount{ attachmentCount_ } - , pAttachments{ pAttachments_ } - , width{ width_ } - , height{ height_ } - , layers{ layers_ } - { - } - - VULKAN_HPP_CONSTEXPR FramebufferCreateInfo( FramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FramebufferCreateInfo( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : FramebufferCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - FramebufferCreateInfo( FramebufferCreateFlags flags_, - RenderPass renderPass_, - ArrayProxyNoTemporaries const & attachments_, - uint32_t width_ = {}, - uint32_t height_ = {}, - uint32_t layers_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , renderPass( renderPass_ ) - , attachmentCount( static_cast( attachments_.size() ) ) - , pAttachments( attachments_.data() ) - , width( width_ ) - , height( height_ ) - , layers( layers_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - FramebufferCreateInfo & operator=( FramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FramebufferCreateInfo & operator=( VkFramebufferCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setFlags( FramebufferCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setFlags( FramebufferCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setRenderPass( RenderPass renderPass_ ) & VULKAN_HPP_NOEXCEPT - { - renderPass = renderPass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setRenderPass( RenderPass renderPass_ ) && VULKAN_HPP_NOEXCEPT - { - renderPass = renderPass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setPAttachments( const ImageView * pAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pAttachments = pAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setPAttachments( const ImageView * pAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pAttachments = pAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - FramebufferCreateInfo & setAttachments( ArrayProxyNoTemporaries const & attachments_ ) VULKAN_HPP_NOEXCEPT - { - attachmentCount = static_cast( attachments_.size() ); - pAttachments = attachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT - { - width = width_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT - { - width = width_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT - { - height = height_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT - { - height = height_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo & setLayers( uint32_t layers_ ) & VULKAN_HPP_NOEXCEPT - { - layers = layers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 FramebufferCreateInfo && setLayers( uint32_t layers_ ) && VULKAN_HPP_NOEXCEPT - { - layers = layers_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkFramebufferCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFramebufferCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFramebufferCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFramebufferCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, renderPass, attachmentCount, pAttachments, width, height, layers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FramebufferCreateInfo const & ) const = default; -#else - bool operator==( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( renderPass == rhs.renderPass ) && - ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) && ( width == rhs.width ) && ( height == rhs.height ) && - ( layers == rhs.layers ); -# endif - } - - bool operator!=( FramebufferCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFramebufferCreateInfo; - const void * pNext = {}; - FramebufferCreateFlags flags = {}; - RenderPass renderPass = {}; - uint32_t attachmentCount = {}; - const ImageView * pAttachments = {}; - uint32_t width = {}; - uint32_t height = {}; - uint32_t layers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FramebufferCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = FramebufferCreateInfo; - }; - - // wrapper struct for struct VkFramebufferMixedSamplesCombinationNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebufferMixedSamplesCombinationNV.html - struct FramebufferMixedSamplesCombinationNV - { - using NativeType = VkFramebufferMixedSamplesCombinationNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eFramebufferMixedSamplesCombinationNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR FramebufferMixedSamplesCombinationNV( CoverageReductionModeNV coverageReductionMode_ = CoverageReductionModeNV::eMerge, - SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, - SampleCountFlags depthStencilSamples_ = {}, - SampleCountFlags colorSamples_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , coverageReductionMode{ coverageReductionMode_ } - , rasterizationSamples{ rasterizationSamples_ } - , depthStencilSamples{ depthStencilSamples_ } - , colorSamples{ colorSamples_ } - { - } - - VULKAN_HPP_CONSTEXPR FramebufferMixedSamplesCombinationNV( FramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - FramebufferMixedSamplesCombinationNV( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT - : FramebufferMixedSamplesCombinationNV( *reinterpret_cast( &rhs ) ) - { - } - - FramebufferMixedSamplesCombinationNV & operator=( FramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - FramebufferMixedSamplesCombinationNV & operator=( VkFramebufferMixedSamplesCombinationNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkFramebufferMixedSamplesCombinationNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFramebufferMixedSamplesCombinationNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkFramebufferMixedSamplesCombinationNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkFramebufferMixedSamplesCombinationNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, coverageReductionMode, rasterizationSamples, depthStencilSamples, colorSamples ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( FramebufferMixedSamplesCombinationNV const & ) const = default; -#else - bool operator==( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode ) && - ( rasterizationSamples == rhs.rasterizationSamples ) && ( depthStencilSamples == rhs.depthStencilSamples ) && ( colorSamples == rhs.colorSamples ); -# endif - } - - bool operator!=( FramebufferMixedSamplesCombinationNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eFramebufferMixedSamplesCombinationNV; - void * pNext = {}; - CoverageReductionModeNV coverageReductionMode = CoverageReductionModeNV::eMerge; - SampleCountFlagBits rasterizationSamples = SampleCountFlagBits::e1; - SampleCountFlags depthStencilSamples = {}; - SampleCountFlags colorSamples = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = FramebufferMixedSamplesCombinationNV; - }; -#endif - - template <> - struct CppType - { - using Type = FramebufferMixedSamplesCombinationNV; - }; - - // wrapper struct for struct VkGeneratedCommandsInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsInfoEXT.html - struct GeneratedCommandsInfoEXT - { - using NativeType = VkGeneratedCommandsInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoEXT( ShaderStageFlags shaderStages_ = {}, - IndirectExecutionSetEXT indirectExecutionSet_ = {}, - IndirectCommandsLayoutEXT indirectCommandsLayout_ = {}, - DeviceAddress indirectAddress_ = {}, - DeviceSize indirectAddressSize_ = {}, - DeviceAddress preprocessAddress_ = {}, - DeviceSize preprocessSize_ = {}, - uint32_t maxSequenceCount_ = {}, - DeviceAddress sequenceCountAddress_ = {}, - uint32_t maxDrawCount_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderStages{ shaderStages_ } - , indirectExecutionSet{ indirectExecutionSet_ } - , indirectCommandsLayout{ indirectCommandsLayout_ } - , indirectAddress{ indirectAddress_ } - , indirectAddressSize{ indirectAddressSize_ } - , preprocessAddress{ preprocessAddress_ } - , preprocessSize{ preprocessSize_ } - , maxSequenceCount{ maxSequenceCount_ } - , sequenceCountAddress{ sequenceCountAddress_ } - , maxDrawCount{ maxDrawCount_ } - { - } - - VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoEXT( GeneratedCommandsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GeneratedCommandsInfoEXT( VkGeneratedCommandsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : GeneratedCommandsInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - GeneratedCommandsInfoEXT & operator=( GeneratedCommandsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GeneratedCommandsInfoEXT & operator=( VkGeneratedCommandsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setShaderStages( ShaderStageFlags shaderStages_ ) & VULKAN_HPP_NOEXCEPT - { - shaderStages = shaderStages_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setShaderStages( ShaderStageFlags shaderStages_ ) && VULKAN_HPP_NOEXCEPT - { - shaderStages = shaderStages_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setIndirectExecutionSet( IndirectExecutionSetEXT indirectExecutionSet_ ) & VULKAN_HPP_NOEXCEPT - { - indirectExecutionSet = indirectExecutionSet_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setIndirectExecutionSet( IndirectExecutionSetEXT indirectExecutionSet_ ) && VULKAN_HPP_NOEXCEPT - { - indirectExecutionSet = indirectExecutionSet_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setIndirectCommandsLayout( IndirectCommandsLayoutEXT indirectCommandsLayout_ ) & VULKAN_HPP_NOEXCEPT - { - indirectCommandsLayout = indirectCommandsLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setIndirectCommandsLayout( IndirectCommandsLayoutEXT indirectCommandsLayout_ ) && VULKAN_HPP_NOEXCEPT - { - indirectCommandsLayout = indirectCommandsLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setIndirectAddress( DeviceAddress indirectAddress_ ) & VULKAN_HPP_NOEXCEPT - { - indirectAddress = indirectAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setIndirectAddress( DeviceAddress indirectAddress_ ) && VULKAN_HPP_NOEXCEPT - { - indirectAddress = indirectAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setIndirectAddressSize( DeviceSize indirectAddressSize_ ) & VULKAN_HPP_NOEXCEPT - { - indirectAddressSize = indirectAddressSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setIndirectAddressSize( DeviceSize indirectAddressSize_ ) && VULKAN_HPP_NOEXCEPT - { - indirectAddressSize = indirectAddressSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setPreprocessAddress( DeviceAddress preprocessAddress_ ) & VULKAN_HPP_NOEXCEPT - { - preprocessAddress = preprocessAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setPreprocessAddress( DeviceAddress preprocessAddress_ ) && VULKAN_HPP_NOEXCEPT - { - preprocessAddress = preprocessAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setPreprocessSize( DeviceSize preprocessSize_ ) & VULKAN_HPP_NOEXCEPT - { - preprocessSize = preprocessSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setPreprocessSize( DeviceSize preprocessSize_ ) && VULKAN_HPP_NOEXCEPT - { - preprocessSize = preprocessSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setMaxSequenceCount( uint32_t maxSequenceCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxSequenceCount = maxSequenceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setMaxSequenceCount( uint32_t maxSequenceCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxSequenceCount = maxSequenceCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setSequenceCountAddress( DeviceAddress sequenceCountAddress_ ) & VULKAN_HPP_NOEXCEPT - { - sequenceCountAddress = sequenceCountAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setSequenceCountAddress( DeviceAddress sequenceCountAddress_ ) && VULKAN_HPP_NOEXCEPT - { - sequenceCountAddress = sequenceCountAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT & setMaxDrawCount( uint32_t maxDrawCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxDrawCount = maxDrawCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoEXT && setMaxDrawCount( uint32_t maxDrawCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxDrawCount = maxDrawCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGeneratedCommandsInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGeneratedCommandsInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - shaderStages, - indirectExecutionSet, - indirectCommandsLayout, - indirectAddress, - indirectAddressSize, - preprocessAddress, - preprocessSize, - maxSequenceCount, - sequenceCountAddress, - maxDrawCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GeneratedCommandsInfoEXT const & ) const = default; -#else - bool operator==( GeneratedCommandsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderStages == rhs.shaderStages ) && ( indirectExecutionSet == rhs.indirectExecutionSet ) && - ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && ( indirectAddress == rhs.indirectAddress ) && - ( indirectAddressSize == rhs.indirectAddressSize ) && ( preprocessAddress == rhs.preprocessAddress ) && ( preprocessSize == rhs.preprocessSize ) && - ( maxSequenceCount == rhs.maxSequenceCount ) && ( sequenceCountAddress == rhs.sequenceCountAddress ) && ( maxDrawCount == rhs.maxDrawCount ); -# endif - } - - bool operator!=( GeneratedCommandsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGeneratedCommandsInfoEXT; - const void * pNext = {}; - ShaderStageFlags shaderStages = {}; - IndirectExecutionSetEXT indirectExecutionSet = {}; - IndirectCommandsLayoutEXT indirectCommandsLayout = {}; - DeviceAddress indirectAddress = {}; - DeviceSize indirectAddressSize = {}; - DeviceAddress preprocessAddress = {}; - DeviceSize preprocessSize = {}; - uint32_t maxSequenceCount = {}; - DeviceAddress sequenceCountAddress = {}; - uint32_t maxDrawCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GeneratedCommandsInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = GeneratedCommandsInfoEXT; - }; - - // wrapper struct for struct VkIndirectCommandsStreamNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsStreamNV.html - struct IndirectCommandsStreamNV - { - using NativeType = VkIndirectCommandsStreamNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR IndirectCommandsStreamNV( Buffer buffer_ = {}, DeviceSize offset_ = {} ) VULKAN_HPP_NOEXCEPT - : buffer{ buffer_ } - , offset{ offset_ } - { - } - - VULKAN_HPP_CONSTEXPR IndirectCommandsStreamNV( IndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectCommandsStreamNV( VkIndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectCommandsStreamNV( *reinterpret_cast( &rhs ) ) - { - } - - IndirectCommandsStreamNV & operator=( IndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectCommandsStreamNV & operator=( VkIndirectCommandsStreamNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsStreamNV & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsStreamNV && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsStreamNV & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsStreamNV && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectCommandsStreamNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsStreamNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsStreamNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectCommandsStreamNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( buffer, offset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectCommandsStreamNV const & ) const = default; -#else - bool operator==( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( buffer == rhs.buffer ) && ( offset == rhs.offset ); -# endif - } - - bool operator!=( IndirectCommandsStreamNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Buffer buffer = {}; - DeviceSize offset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectCommandsStreamNV; - }; -#endif - - // wrapper struct for struct VkGeneratedCommandsInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsInfoNV.html - struct GeneratedCommandsInfoNV - { - using NativeType = VkGeneratedCommandsInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoNV( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, - Pipeline pipeline_ = {}, - IndirectCommandsLayoutNV indirectCommandsLayout_ = {}, - uint32_t streamCount_ = {}, - const IndirectCommandsStreamNV * pStreams_ = {}, - uint32_t sequencesCount_ = {}, - Buffer preprocessBuffer_ = {}, - DeviceSize preprocessOffset_ = {}, - DeviceSize preprocessSize_ = {}, - Buffer sequencesCountBuffer_ = {}, - DeviceSize sequencesCountOffset_ = {}, - Buffer sequencesIndexBuffer_ = {}, - DeviceSize sequencesIndexOffset_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineBindPoint{ pipelineBindPoint_ } - , pipeline{ pipeline_ } - , indirectCommandsLayout{ indirectCommandsLayout_ } - , streamCount{ streamCount_ } - , pStreams{ pStreams_ } - , sequencesCount{ sequencesCount_ } - , preprocessBuffer{ preprocessBuffer_ } - , preprocessOffset{ preprocessOffset_ } - , preprocessSize{ preprocessSize_ } - , sequencesCountBuffer{ sequencesCountBuffer_ } - , sequencesCountOffset{ sequencesCountOffset_ } - , sequencesIndexBuffer{ sequencesIndexBuffer_ } - , sequencesIndexOffset{ sequencesIndexOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR GeneratedCommandsInfoNV( GeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GeneratedCommandsInfoNV( VkGeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : GeneratedCommandsInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GeneratedCommandsInfoNV( PipelineBindPoint pipelineBindPoint_, - Pipeline pipeline_, - IndirectCommandsLayoutNV indirectCommandsLayout_, - ArrayProxyNoTemporaries const & streams_, - uint32_t sequencesCount_ = {}, - Buffer preprocessBuffer_ = {}, - DeviceSize preprocessOffset_ = {}, - DeviceSize preprocessSize_ = {}, - Buffer sequencesCountBuffer_ = {}, - DeviceSize sequencesCountOffset_ = {}, - Buffer sequencesIndexBuffer_ = {}, - DeviceSize sequencesIndexOffset_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , pipeline( pipeline_ ) - , indirectCommandsLayout( indirectCommandsLayout_ ) - , streamCount( static_cast( streams_.size() ) ) - , pStreams( streams_.data() ) - , sequencesCount( sequencesCount_ ) - , preprocessBuffer( preprocessBuffer_ ) - , preprocessOffset( preprocessOffset_ ) - , preprocessSize( preprocessSize_ ) - , sequencesCountBuffer( sequencesCountBuffer_ ) - , sequencesCountOffset( sequencesCountOffset_ ) - , sequencesIndexBuffer( sequencesIndexBuffer_ ) - , sequencesIndexOffset( sequencesIndexOffset_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - GeneratedCommandsInfoNV & operator=( GeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GeneratedCommandsInfoNV & operator=( VkGeneratedCommandsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setIndirectCommandsLayout( IndirectCommandsLayoutNV indirectCommandsLayout_ ) & VULKAN_HPP_NOEXCEPT - { - indirectCommandsLayout = indirectCommandsLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setIndirectCommandsLayout( IndirectCommandsLayoutNV indirectCommandsLayout_ ) && VULKAN_HPP_NOEXCEPT - { - indirectCommandsLayout = indirectCommandsLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setStreamCount( uint32_t streamCount_ ) & VULKAN_HPP_NOEXCEPT - { - streamCount = streamCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setStreamCount( uint32_t streamCount_ ) && VULKAN_HPP_NOEXCEPT - { - streamCount = streamCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPStreams( const IndirectCommandsStreamNV * pStreams_ ) & VULKAN_HPP_NOEXCEPT - { - pStreams = pStreams_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPStreams( const IndirectCommandsStreamNV * pStreams_ ) && VULKAN_HPP_NOEXCEPT - { - pStreams = pStreams_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GeneratedCommandsInfoNV & setStreams( ArrayProxyNoTemporaries const & streams_ ) VULKAN_HPP_NOEXCEPT - { - streamCount = static_cast( streams_.size() ); - pStreams = streams_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setSequencesCount( uint32_t sequencesCount_ ) & VULKAN_HPP_NOEXCEPT - { - sequencesCount = sequencesCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setSequencesCount( uint32_t sequencesCount_ ) && VULKAN_HPP_NOEXCEPT - { - sequencesCount = sequencesCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPreprocessBuffer( Buffer preprocessBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - preprocessBuffer = preprocessBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPreprocessBuffer( Buffer preprocessBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - preprocessBuffer = preprocessBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPreprocessOffset( DeviceSize preprocessOffset_ ) & VULKAN_HPP_NOEXCEPT - { - preprocessOffset = preprocessOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPreprocessOffset( DeviceSize preprocessOffset_ ) && VULKAN_HPP_NOEXCEPT - { - preprocessOffset = preprocessOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setPreprocessSize( DeviceSize preprocessSize_ ) & VULKAN_HPP_NOEXCEPT - { - preprocessSize = preprocessSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setPreprocessSize( DeviceSize preprocessSize_ ) && VULKAN_HPP_NOEXCEPT - { - preprocessSize = preprocessSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setSequencesCountBuffer( Buffer sequencesCountBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - sequencesCountBuffer = sequencesCountBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setSequencesCountBuffer( Buffer sequencesCountBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - sequencesCountBuffer = sequencesCountBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setSequencesCountOffset( DeviceSize sequencesCountOffset_ ) & VULKAN_HPP_NOEXCEPT - { - sequencesCountOffset = sequencesCountOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setSequencesCountOffset( DeviceSize sequencesCountOffset_ ) && VULKAN_HPP_NOEXCEPT - { - sequencesCountOffset = sequencesCountOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - sequencesIndexBuffer = sequencesIndexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setSequencesIndexBuffer( Buffer sequencesIndexBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - sequencesIndexBuffer = sequencesIndexBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV & setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ ) & VULKAN_HPP_NOEXCEPT - { - sequencesIndexOffset = sequencesIndexOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsInfoNV && setSequencesIndexOffset( DeviceSize sequencesIndexOffset_ ) && VULKAN_HPP_NOEXCEPT - { - sequencesIndexOffset = sequencesIndexOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGeneratedCommandsInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGeneratedCommandsInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - pipelineBindPoint, - pipeline, - indirectCommandsLayout, - streamCount, - pStreams, - sequencesCount, - preprocessBuffer, - preprocessOffset, - preprocessSize, - sequencesCountBuffer, - sequencesCountOffset, - sequencesIndexBuffer, - sequencesIndexOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GeneratedCommandsInfoNV const & ) const = default; -#else - bool operator==( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipeline == rhs.pipeline ) && - ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && ( streamCount == rhs.streamCount ) && ( pStreams == rhs.pStreams ) && - ( sequencesCount == rhs.sequencesCount ) && ( preprocessBuffer == rhs.preprocessBuffer ) && ( preprocessOffset == rhs.preprocessOffset ) && - ( preprocessSize == rhs.preprocessSize ) && ( sequencesCountBuffer == rhs.sequencesCountBuffer ) && - ( sequencesCountOffset == rhs.sequencesCountOffset ) && ( sequencesIndexBuffer == rhs.sequencesIndexBuffer ) && - ( sequencesIndexOffset == rhs.sequencesIndexOffset ); -# endif - } - - bool operator!=( GeneratedCommandsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGeneratedCommandsInfoNV; - const void * pNext = {}; - PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; - Pipeline pipeline = {}; - IndirectCommandsLayoutNV indirectCommandsLayout = {}; - uint32_t streamCount = {}; - const IndirectCommandsStreamNV * pStreams = {}; - uint32_t sequencesCount = {}; - Buffer preprocessBuffer = {}; - DeviceSize preprocessOffset = {}; - DeviceSize preprocessSize = {}; - Buffer sequencesCountBuffer = {}; - DeviceSize sequencesCountOffset = {}; - Buffer sequencesIndexBuffer = {}; - DeviceSize sequencesIndexOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GeneratedCommandsInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = GeneratedCommandsInfoNV; - }; - - // wrapper struct for struct VkGeneratedCommandsMemoryRequirementsInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsMemoryRequirementsInfoEXT.html - struct GeneratedCommandsMemoryRequirementsInfoEXT - { - using NativeType = VkGeneratedCommandsMemoryRequirementsInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsMemoryRequirementsInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoEXT( IndirectExecutionSetEXT indirectExecutionSet_ = {}, - IndirectCommandsLayoutEXT indirectCommandsLayout_ = {}, - uint32_t maxSequenceCount_ = {}, - uint32_t maxDrawCount_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , indirectExecutionSet{ indirectExecutionSet_ } - , indirectCommandsLayout{ indirectCommandsLayout_ } - , maxSequenceCount{ maxSequenceCount_ } - , maxDrawCount{ maxDrawCount_ } - { - } - - VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoEXT( GeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GeneratedCommandsMemoryRequirementsInfoEXT( VkGeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : GeneratedCommandsMemoryRequirementsInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - GeneratedCommandsMemoryRequirementsInfoEXT & operator=( GeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GeneratedCommandsMemoryRequirementsInfoEXT & operator=( VkGeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT & setIndirectExecutionSet( IndirectExecutionSetEXT indirectExecutionSet_ ) & - VULKAN_HPP_NOEXCEPT - { - indirectExecutionSet = indirectExecutionSet_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT && setIndirectExecutionSet( IndirectExecutionSetEXT indirectExecutionSet_ ) && - VULKAN_HPP_NOEXCEPT - { - indirectExecutionSet = indirectExecutionSet_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT & setIndirectCommandsLayout( IndirectCommandsLayoutEXT indirectCommandsLayout_ ) & - VULKAN_HPP_NOEXCEPT - { - indirectCommandsLayout = indirectCommandsLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT && setIndirectCommandsLayout( IndirectCommandsLayoutEXT indirectCommandsLayout_ ) && - VULKAN_HPP_NOEXCEPT - { - indirectCommandsLayout = indirectCommandsLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT & setMaxSequenceCount( uint32_t maxSequenceCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxSequenceCount = maxSequenceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT && setMaxSequenceCount( uint32_t maxSequenceCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxSequenceCount = maxSequenceCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT & setMaxDrawCount( uint32_t maxDrawCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxDrawCount = maxDrawCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoEXT && setMaxDrawCount( uint32_t maxDrawCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxDrawCount = maxDrawCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGeneratedCommandsMemoryRequirementsInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsMemoryRequirementsInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsMemoryRequirementsInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGeneratedCommandsMemoryRequirementsInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, indirectExecutionSet, indirectCommandsLayout, maxSequenceCount, maxDrawCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GeneratedCommandsMemoryRequirementsInfoEXT const & ) const = default; -#else - bool operator==( GeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indirectExecutionSet == rhs.indirectExecutionSet ) && - ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && ( maxSequenceCount == rhs.maxSequenceCount ) && ( maxDrawCount == rhs.maxDrawCount ); -# endif - } - - bool operator!=( GeneratedCommandsMemoryRequirementsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGeneratedCommandsMemoryRequirementsInfoEXT; - const void * pNext = {}; - IndirectExecutionSetEXT indirectExecutionSet = {}; - IndirectCommandsLayoutEXT indirectCommandsLayout = {}; - uint32_t maxSequenceCount = {}; - uint32_t maxDrawCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GeneratedCommandsMemoryRequirementsInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = GeneratedCommandsMemoryRequirementsInfoEXT; - }; - - // wrapper struct for struct VkGeneratedCommandsMemoryRequirementsInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsMemoryRequirementsInfoNV.html - struct GeneratedCommandsMemoryRequirementsInfoNV - { - using NativeType = VkGeneratedCommandsMemoryRequirementsInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsMemoryRequirementsInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoNV( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, - Pipeline pipeline_ = {}, - IndirectCommandsLayoutNV indirectCommandsLayout_ = {}, - uint32_t maxSequencesCount_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineBindPoint{ pipelineBindPoint_ } - , pipeline{ pipeline_ } - , indirectCommandsLayout{ indirectCommandsLayout_ } - , maxSequencesCount{ maxSequencesCount_ } - { - } - - VULKAN_HPP_CONSTEXPR GeneratedCommandsMemoryRequirementsInfoNV( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GeneratedCommandsMemoryRequirementsInfoNV( VkGeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : GeneratedCommandsMemoryRequirementsInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - GeneratedCommandsMemoryRequirementsInfoNV & operator=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GeneratedCommandsMemoryRequirementsInfoNV & operator=( VkGeneratedCommandsMemoryRequirementsInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV & setIndirectCommandsLayout( IndirectCommandsLayoutNV indirectCommandsLayout_ ) & - VULKAN_HPP_NOEXCEPT - { - indirectCommandsLayout = indirectCommandsLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV && setIndirectCommandsLayout( IndirectCommandsLayoutNV indirectCommandsLayout_ ) && - VULKAN_HPP_NOEXCEPT - { - indirectCommandsLayout = indirectCommandsLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV & setMaxSequencesCount( uint32_t maxSequencesCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxSequencesCount = maxSequencesCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsMemoryRequirementsInfoNV && setMaxSequencesCount( uint32_t maxSequencesCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxSequencesCount = maxSequencesCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGeneratedCommandsMemoryRequirementsInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsMemoryRequirementsInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsMemoryRequirementsInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGeneratedCommandsMemoryRequirementsInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineBindPoint, pipeline, indirectCommandsLayout, maxSequencesCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GeneratedCommandsMemoryRequirementsInfoNV const & ) const = default; -#else - bool operator==( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipeline == rhs.pipeline ) && - ( indirectCommandsLayout == rhs.indirectCommandsLayout ) && ( maxSequencesCount == rhs.maxSequencesCount ); -# endif - } - - bool operator!=( GeneratedCommandsMemoryRequirementsInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGeneratedCommandsMemoryRequirementsInfoNV; - const void * pNext = {}; - PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; - Pipeline pipeline = {}; - IndirectCommandsLayoutNV indirectCommandsLayout = {}; - uint32_t maxSequencesCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GeneratedCommandsMemoryRequirementsInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = GeneratedCommandsMemoryRequirementsInfoNV; - }; - - // wrapper struct for struct VkGeneratedCommandsPipelineInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsPipelineInfoEXT.html - struct GeneratedCommandsPipelineInfoEXT - { - using NativeType = VkGeneratedCommandsPipelineInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsPipelineInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GeneratedCommandsPipelineInfoEXT( Pipeline pipeline_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipeline{ pipeline_ } - { - } - - VULKAN_HPP_CONSTEXPR GeneratedCommandsPipelineInfoEXT( GeneratedCommandsPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GeneratedCommandsPipelineInfoEXT( VkGeneratedCommandsPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : GeneratedCommandsPipelineInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - GeneratedCommandsPipelineInfoEXT & operator=( GeneratedCommandsPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GeneratedCommandsPipelineInfoEXT & operator=( VkGeneratedCommandsPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsPipelineInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsPipelineInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsPipelineInfoEXT & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsPipelineInfoEXT && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGeneratedCommandsPipelineInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsPipelineInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsPipelineInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGeneratedCommandsPipelineInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipeline ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GeneratedCommandsPipelineInfoEXT const & ) const = default; -#else - bool operator==( GeneratedCommandsPipelineInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ); -# endif - } - - bool operator!=( GeneratedCommandsPipelineInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGeneratedCommandsPipelineInfoEXT; - void * pNext = {}; - Pipeline pipeline = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GeneratedCommandsPipelineInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = GeneratedCommandsPipelineInfoEXT; - }; - - // wrapper struct for struct VkGeneratedCommandsShaderInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGeneratedCommandsShaderInfoEXT.html - struct GeneratedCommandsShaderInfoEXT - { - using NativeType = VkGeneratedCommandsShaderInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGeneratedCommandsShaderInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - GeneratedCommandsShaderInfoEXT( uint32_t shaderCount_ = {}, const ShaderEXT * pShaders_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderCount{ shaderCount_ } - , pShaders{ pShaders_ } - { - } - - VULKAN_HPP_CONSTEXPR GeneratedCommandsShaderInfoEXT( GeneratedCommandsShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GeneratedCommandsShaderInfoEXT( VkGeneratedCommandsShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : GeneratedCommandsShaderInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GeneratedCommandsShaderInfoEXT( ArrayProxyNoTemporaries const & shaders_, void * pNext_ = nullptr ) - : pNext( pNext_ ), shaderCount( static_cast( shaders_.size() ) ), pShaders( shaders_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - GeneratedCommandsShaderInfoEXT & operator=( GeneratedCommandsShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GeneratedCommandsShaderInfoEXT & operator=( VkGeneratedCommandsShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT & setShaderCount( uint32_t shaderCount_ ) & VULKAN_HPP_NOEXCEPT - { - shaderCount = shaderCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT && setShaderCount( uint32_t shaderCount_ ) && VULKAN_HPP_NOEXCEPT - { - shaderCount = shaderCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT & setPShaders( const ShaderEXT * pShaders_ ) & VULKAN_HPP_NOEXCEPT - { - pShaders = pShaders_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GeneratedCommandsShaderInfoEXT && setPShaders( const ShaderEXT * pShaders_ ) && VULKAN_HPP_NOEXCEPT - { - pShaders = pShaders_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GeneratedCommandsShaderInfoEXT & setShaders( ArrayProxyNoTemporaries const & shaders_ ) VULKAN_HPP_NOEXCEPT - { - shaderCount = static_cast( shaders_.size() ); - pShaders = shaders_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGeneratedCommandsShaderInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsShaderInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGeneratedCommandsShaderInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGeneratedCommandsShaderInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderCount, pShaders ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GeneratedCommandsShaderInfoEXT const & ) const = default; -#else - bool operator==( GeneratedCommandsShaderInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCount == rhs.shaderCount ) && ( pShaders == rhs.pShaders ); -# endif - } - - bool operator!=( GeneratedCommandsShaderInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGeneratedCommandsShaderInfoEXT; - void * pNext = {}; - uint32_t shaderCount = {}; - const ShaderEXT * pShaders = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GeneratedCommandsShaderInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = GeneratedCommandsShaderInfoEXT; - }; - - // wrapper struct for struct VkLatencyTimingsFrameReportNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencyTimingsFrameReportNV.html - struct LatencyTimingsFrameReportNV - { - using NativeType = VkLatencyTimingsFrameReportNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencyTimingsFrameReportNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR LatencyTimingsFrameReportNV( uint64_t presentID_ = {}, - uint64_t inputSampleTimeUs_ = {}, - uint64_t simStartTimeUs_ = {}, - uint64_t simEndTimeUs_ = {}, - uint64_t renderSubmitStartTimeUs_ = {}, - uint64_t renderSubmitEndTimeUs_ = {}, - uint64_t presentStartTimeUs_ = {}, - uint64_t presentEndTimeUs_ = {}, - uint64_t driverStartTimeUs_ = {}, - uint64_t driverEndTimeUs_ = {}, - uint64_t osRenderQueueStartTimeUs_ = {}, - uint64_t osRenderQueueEndTimeUs_ = {}, - uint64_t gpuRenderStartTimeUs_ = {}, - uint64_t gpuRenderEndTimeUs_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentID{ presentID_ } - , inputSampleTimeUs{ inputSampleTimeUs_ } - , simStartTimeUs{ simStartTimeUs_ } - , simEndTimeUs{ simEndTimeUs_ } - , renderSubmitStartTimeUs{ renderSubmitStartTimeUs_ } - , renderSubmitEndTimeUs{ renderSubmitEndTimeUs_ } - , presentStartTimeUs{ presentStartTimeUs_ } - , presentEndTimeUs{ presentEndTimeUs_ } - , driverStartTimeUs{ driverStartTimeUs_ } - , driverEndTimeUs{ driverEndTimeUs_ } - , osRenderQueueStartTimeUs{ osRenderQueueStartTimeUs_ } - , osRenderQueueEndTimeUs{ osRenderQueueEndTimeUs_ } - , gpuRenderStartTimeUs{ gpuRenderStartTimeUs_ } - , gpuRenderEndTimeUs{ gpuRenderEndTimeUs_ } - { - } - - VULKAN_HPP_CONSTEXPR LatencyTimingsFrameReportNV( LatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - LatencyTimingsFrameReportNV( VkLatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT - : LatencyTimingsFrameReportNV( *reinterpret_cast( &rhs ) ) - { - } - - LatencyTimingsFrameReportNV & operator=( LatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - LatencyTimingsFrameReportNV & operator=( VkLatencyTimingsFrameReportNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkLatencyTimingsFrameReportNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLatencyTimingsFrameReportNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLatencyTimingsFrameReportNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkLatencyTimingsFrameReportNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - presentID, - inputSampleTimeUs, - simStartTimeUs, - simEndTimeUs, - renderSubmitStartTimeUs, - renderSubmitEndTimeUs, - presentStartTimeUs, - presentEndTimeUs, - driverStartTimeUs, - driverEndTimeUs, - osRenderQueueStartTimeUs, - osRenderQueueEndTimeUs, - gpuRenderStartTimeUs, - gpuRenderEndTimeUs ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( LatencyTimingsFrameReportNV const & ) const = default; -#else - bool operator==( LatencyTimingsFrameReportNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID ) && ( inputSampleTimeUs == rhs.inputSampleTimeUs ) && - ( simStartTimeUs == rhs.simStartTimeUs ) && ( simEndTimeUs == rhs.simEndTimeUs ) && ( renderSubmitStartTimeUs == rhs.renderSubmitStartTimeUs ) && - ( renderSubmitEndTimeUs == rhs.renderSubmitEndTimeUs ) && ( presentStartTimeUs == rhs.presentStartTimeUs ) && - ( presentEndTimeUs == rhs.presentEndTimeUs ) && ( driverStartTimeUs == rhs.driverStartTimeUs ) && ( driverEndTimeUs == rhs.driverEndTimeUs ) && - ( osRenderQueueStartTimeUs == rhs.osRenderQueueStartTimeUs ) && ( osRenderQueueEndTimeUs == rhs.osRenderQueueEndTimeUs ) && - ( gpuRenderStartTimeUs == rhs.gpuRenderStartTimeUs ) && ( gpuRenderEndTimeUs == rhs.gpuRenderEndTimeUs ); -# endif - } - - bool operator!=( LatencyTimingsFrameReportNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eLatencyTimingsFrameReportNV; - void * pNext = {}; - uint64_t presentID = {}; - uint64_t inputSampleTimeUs = {}; - uint64_t simStartTimeUs = {}; - uint64_t simEndTimeUs = {}; - uint64_t renderSubmitStartTimeUs = {}; - uint64_t renderSubmitEndTimeUs = {}; - uint64_t presentStartTimeUs = {}; - uint64_t presentEndTimeUs = {}; - uint64_t driverStartTimeUs = {}; - uint64_t driverEndTimeUs = {}; - uint64_t osRenderQueueStartTimeUs = {}; - uint64_t osRenderQueueEndTimeUs = {}; - uint64_t gpuRenderStartTimeUs = {}; - uint64_t gpuRenderEndTimeUs = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = LatencyTimingsFrameReportNV; - }; -#endif - - template <> - struct CppType - { - using Type = LatencyTimingsFrameReportNV; - }; - - // wrapper struct for struct VkGetLatencyMarkerInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGetLatencyMarkerInfoNV.html - struct GetLatencyMarkerInfoNV - { - using NativeType = VkGetLatencyMarkerInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGetLatencyMarkerInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - GetLatencyMarkerInfoNV( uint32_t timingCount_ = {}, LatencyTimingsFrameReportNV * pTimings_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , timingCount{ timingCount_ } - , pTimings{ pTimings_ } - { - } - - VULKAN_HPP_CONSTEXPR GetLatencyMarkerInfoNV( GetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GetLatencyMarkerInfoNV( VkGetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : GetLatencyMarkerInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GetLatencyMarkerInfoNV( ArrayProxyNoTemporaries const & timings_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), timingCount( static_cast( timings_.size() ) ), pTimings( timings_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - GetLatencyMarkerInfoNV & operator=( GetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GetLatencyMarkerInfoNV & operator=( VkGetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV & setTimingCount( uint32_t timingCount_ ) & VULKAN_HPP_NOEXCEPT - { - timingCount = timingCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV && setTimingCount( uint32_t timingCount_ ) && VULKAN_HPP_NOEXCEPT - { - timingCount = timingCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV & setPTimings( LatencyTimingsFrameReportNV * pTimings_ ) & VULKAN_HPP_NOEXCEPT - { - pTimings = pTimings_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GetLatencyMarkerInfoNV && setPTimings( LatencyTimingsFrameReportNV * pTimings_ ) && VULKAN_HPP_NOEXCEPT - { - pTimings = pTimings_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GetLatencyMarkerInfoNV & setTimings( ArrayProxyNoTemporaries const & timings_ ) VULKAN_HPP_NOEXCEPT - { - timingCount = static_cast( timings_.size() ); - pTimings = timings_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGetLatencyMarkerInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGetLatencyMarkerInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGetLatencyMarkerInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGetLatencyMarkerInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, timingCount, pTimings ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GetLatencyMarkerInfoNV const & ) const = default; -#else - bool operator==( GetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timingCount == rhs.timingCount ) && ( pTimings == rhs.pTimings ); -# endif - } - - bool operator!=( GetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGetLatencyMarkerInfoNV; - const void * pNext = {}; - uint32_t timingCount = {}; - LatencyTimingsFrameReportNV * pTimings = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GetLatencyMarkerInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = GetLatencyMarkerInfoNV; - }; - - // wrapper struct for struct VkVertexInputBindingDescription, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputBindingDescription.html - struct VertexInputBindingDescription - { - using NativeType = VkVertexInputBindingDescription; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VertexInputBindingDescription( uint32_t binding_ = {}, uint32_t stride_ = {}, VertexInputRate inputRate_ = VertexInputRate::eVertex ) VULKAN_HPP_NOEXCEPT - : binding{ binding_ } - , stride{ stride_ } - , inputRate{ inputRate_ } - { - } - - VULKAN_HPP_CONSTEXPR VertexInputBindingDescription( VertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VertexInputBindingDescription( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT - : VertexInputBindingDescription( *reinterpret_cast( &rhs ) ) - { - } - - VertexInputBindingDescription & operator=( VertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VertexInputBindingDescription & operator=( VkVertexInputBindingDescription const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription & setInputRate( VertexInputRate inputRate_ ) & VULKAN_HPP_NOEXCEPT - { - inputRate = inputRate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription && setInputRate( VertexInputRate inputRate_ ) && VULKAN_HPP_NOEXCEPT - { - inputRate = inputRate_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVertexInputBindingDescription const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVertexInputBindingDescription &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVertexInputBindingDescription const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVertexInputBindingDescription *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( binding, stride, inputRate ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VertexInputBindingDescription const & ) const = default; -#else - bool operator==( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( binding == rhs.binding ) && ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ); -# endif - } - - bool operator!=( VertexInputBindingDescription const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t binding = {}; - uint32_t stride = {}; - VertexInputRate inputRate = VertexInputRate::eVertex; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VertexInputBindingDescription; - }; -#endif - - // wrapper struct for struct VkVertexInputAttributeDescription, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputAttributeDescription.html - struct VertexInputAttributeDescription - { - using NativeType = VkVertexInputAttributeDescription; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription( uint32_t location_ = {}, - uint32_t binding_ = {}, - Format format_ = Format::eUndefined, - uint32_t offset_ = {} ) VULKAN_HPP_NOEXCEPT - : location{ location_ } - , binding{ binding_ } - , format{ format_ } - , offset{ offset_ } - { - } - - VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription( VertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VertexInputAttributeDescription( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT - : VertexInputAttributeDescription( *reinterpret_cast( &rhs ) ) - { - } - - VertexInputAttributeDescription & operator=( VertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VertexInputAttributeDescription & operator=( VkVertexInputAttributeDescription const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription & setLocation( uint32_t location_ ) & VULKAN_HPP_NOEXCEPT - { - location = location_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription && setLocation( uint32_t location_ ) && VULKAN_HPP_NOEXCEPT - { - location = location_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVertexInputAttributeDescription const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVertexInputAttributeDescription &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVertexInputAttributeDescription const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVertexInputAttributeDescription *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( location, binding, format, offset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VertexInputAttributeDescription const & ) const = default; -#else - bool operator==( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( location == rhs.location ) && ( binding == rhs.binding ) && ( format == rhs.format ) && ( offset == rhs.offset ); -# endif - } - - bool operator!=( VertexInputAttributeDescription const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t location = {}; - uint32_t binding = {}; - Format format = Format::eUndefined; - uint32_t offset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VertexInputAttributeDescription; - }; -#endif - - // wrapper struct for struct VkPipelineVertexInputStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineVertexInputStateCreateInfo.html - struct PipelineVertexInputStateCreateInfo - { - using NativeType = VkPipelineVertexInputStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineVertexInputStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_ = {}, - uint32_t vertexBindingDescriptionCount_ = {}, - const VertexInputBindingDescription * pVertexBindingDescriptions_ = {}, - uint32_t vertexAttributeDescriptionCount_ = {}, - const VertexInputAttributeDescription * pVertexAttributeDescriptions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , vertexBindingDescriptionCount{ vertexBindingDescriptionCount_ } - , pVertexBindingDescriptions{ pVertexBindingDescriptions_ } - , vertexAttributeDescriptionCount{ vertexAttributeDescriptionCount_ } - , pVertexAttributeDescriptions{ pVertexAttributeDescriptions_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineVertexInputStateCreateInfo( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineVertexInputStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineVertexInputStateCreateInfo( PipelineVertexInputStateCreateFlags flags_, - ArrayProxyNoTemporaries const & vertexBindingDescriptions_, - ArrayProxyNoTemporaries const & vertexAttributeDescriptions_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , vertexBindingDescriptionCount( static_cast( vertexBindingDescriptions_.size() ) ) - , pVertexBindingDescriptions( vertexBindingDescriptions_.data() ) - , vertexAttributeDescriptionCount( static_cast( vertexAttributeDescriptions_.size() ) ) - , pVertexAttributeDescriptions( vertexAttributeDescriptions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineVertexInputStateCreateInfo & operator=( PipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineVertexInputStateCreateInfo & operator=( VkPipelineVertexInputStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & setFlags( PipelineVertexInputStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && setFlags( PipelineVertexInputStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexBindingDescriptionCount = vertexBindingDescriptionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && setVertexBindingDescriptionCount( uint32_t vertexBindingDescriptionCount_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexBindingDescriptionCount = vertexBindingDescriptionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & - setPVertexBindingDescriptions( const VertexInputBindingDescription * pVertexBindingDescriptions_ ) & - VULKAN_HPP_NOEXCEPT - { - pVertexBindingDescriptions = pVertexBindingDescriptions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && - setPVertexBindingDescriptions( const VertexInputBindingDescription * pVertexBindingDescriptions_ ) && - VULKAN_HPP_NOEXCEPT - { - pVertexBindingDescriptions = pVertexBindingDescriptions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineVertexInputStateCreateInfo & - setVertexBindingDescriptions( ArrayProxyNoTemporaries const & vertexBindingDescriptions_ ) VULKAN_HPP_NOEXCEPT - { - vertexBindingDescriptionCount = static_cast( vertexBindingDescriptions_.size() ); - pVertexBindingDescriptions = vertexBindingDescriptions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && setVertexAttributeDescriptionCount( uint32_t vertexAttributeDescriptionCount_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexAttributeDescriptionCount = vertexAttributeDescriptionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo & - setPVertexAttributeDescriptions( const VertexInputAttributeDescription * pVertexAttributeDescriptions_ ) & - VULKAN_HPP_NOEXCEPT - { - pVertexAttributeDescriptions = pVertexAttributeDescriptions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputStateCreateInfo && - setPVertexAttributeDescriptions( const VertexInputAttributeDescription * pVertexAttributeDescriptions_ ) && - VULKAN_HPP_NOEXCEPT - { - pVertexAttributeDescriptions = pVertexAttributeDescriptions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineVertexInputStateCreateInfo & - setVertexAttributeDescriptions( ArrayProxyNoTemporaries const & vertexAttributeDescriptions_ ) VULKAN_HPP_NOEXCEPT - { - vertexAttributeDescriptionCount = static_cast( vertexAttributeDescriptions_.size() ); - pVertexAttributeDescriptions = vertexAttributeDescriptions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineVertexInputStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineVertexInputStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineVertexInputStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineVertexInputStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, flags, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineVertexInputStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( vertexBindingDescriptionCount == rhs.vertexBindingDescriptionCount ) && ( pVertexBindingDescriptions == rhs.pVertexBindingDescriptions ) && - ( vertexAttributeDescriptionCount == rhs.vertexAttributeDescriptionCount ) && ( pVertexAttributeDescriptions == rhs.pVertexAttributeDescriptions ); -# endif - } - - bool operator!=( PipelineVertexInputStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineVertexInputStateCreateInfo; - const void * pNext = {}; - PipelineVertexInputStateCreateFlags flags = {}; - uint32_t vertexBindingDescriptionCount = {}; - const VertexInputBindingDescription * pVertexBindingDescriptions = {}; - uint32_t vertexAttributeDescriptionCount = {}; - const VertexInputAttributeDescription * pVertexAttributeDescriptions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineVertexInputStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineVertexInputStateCreateInfo; - }; - - // wrapper struct for struct VkPipelineInputAssemblyStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineInputAssemblyStateCreateInfo.html - struct PipelineInputAssemblyStateCreateInfo - { - using NativeType = VkPipelineInputAssemblyStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineInputAssemblyStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateFlags flags_ = {}, - PrimitiveTopology topology_ = PrimitiveTopology::ePointList, - Bool32 primitiveRestartEnable_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , topology{ topology_ } - , primitiveRestartEnable{ primitiveRestartEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineInputAssemblyStateCreateInfo( PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineInputAssemblyStateCreateInfo( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineInputAssemblyStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PipelineInputAssemblyStateCreateInfo & operator=( PipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineInputAssemblyStateCreateInfo & operator=( VkPipelineInputAssemblyStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo & setFlags( PipelineInputAssemblyStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo && setFlags( PipelineInputAssemblyStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo & setTopology( PrimitiveTopology topology_ ) & VULKAN_HPP_NOEXCEPT - { - topology = topology_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo && setTopology( PrimitiveTopology topology_ ) && VULKAN_HPP_NOEXCEPT - { - topology = topology_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo & setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ ) & VULKAN_HPP_NOEXCEPT - { - primitiveRestartEnable = primitiveRestartEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineInputAssemblyStateCreateInfo && setPrimitiveRestartEnable( Bool32 primitiveRestartEnable_ ) && VULKAN_HPP_NOEXCEPT - { - primitiveRestartEnable = primitiveRestartEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineInputAssemblyStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineInputAssemblyStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineInputAssemblyStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineInputAssemblyStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, topology, primitiveRestartEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineInputAssemblyStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( topology == rhs.topology ) && - ( primitiveRestartEnable == rhs.primitiveRestartEnable ); -# endif - } - - bool operator!=( PipelineInputAssemblyStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineInputAssemblyStateCreateInfo; - const void * pNext = {}; - PipelineInputAssemblyStateCreateFlags flags = {}; - PrimitiveTopology topology = PrimitiveTopology::ePointList; - Bool32 primitiveRestartEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineInputAssemblyStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineInputAssemblyStateCreateInfo; - }; - - // wrapper struct for struct VkPipelineTessellationStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineTessellationStateCreateInfo.html - struct PipelineTessellationStateCreateInfo - { - using NativeType = VkPipelineTessellationStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineTessellationStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateFlags flags_ = {}, - uint32_t patchControlPoints_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , patchControlPoints{ patchControlPoints_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineTessellationStateCreateInfo( PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineTessellationStateCreateInfo( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineTessellationStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PipelineTessellationStateCreateInfo & operator=( PipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineTessellationStateCreateInfo & operator=( VkPipelineTessellationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo & setFlags( PipelineTessellationStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo && setFlags( PipelineTessellationStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo & setPatchControlPoints( uint32_t patchControlPoints_ ) & VULKAN_HPP_NOEXCEPT - { - patchControlPoints = patchControlPoints_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineTessellationStateCreateInfo && setPatchControlPoints( uint32_t patchControlPoints_ ) && VULKAN_HPP_NOEXCEPT - { - patchControlPoints = patchControlPoints_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineTessellationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineTessellationStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineTessellationStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineTessellationStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, patchControlPoints ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineTessellationStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( patchControlPoints == rhs.patchControlPoints ); -# endif - } - - bool operator!=( PipelineTessellationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineTessellationStateCreateInfo; - const void * pNext = {}; - PipelineTessellationStateCreateFlags flags = {}; - uint32_t patchControlPoints = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineTessellationStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineTessellationStateCreateInfo; - }; - - // wrapper struct for struct VkPipelineViewportStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportStateCreateInfo.html - struct PipelineViewportStateCreateInfo - { - using NativeType = VkPipelineViewportStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_ = {}, - uint32_t viewportCount_ = {}, - const Viewport * pViewports_ = {}, - uint32_t scissorCount_ = {}, - const Rect2D * pScissors_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , viewportCount{ viewportCount_ } - , pViewports{ pViewports_ } - , scissorCount{ scissorCount_ } - , pScissors{ pScissors_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineViewportStateCreateInfo( PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineViewportStateCreateInfo( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineViewportStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportStateCreateInfo( PipelineViewportStateCreateFlags flags_, - ArrayProxyNoTemporaries const & viewports_, - ArrayProxyNoTemporaries const & scissors_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , viewportCount( static_cast( viewports_.size() ) ) - , pViewports( viewports_.data() ) - , scissorCount( static_cast( scissors_.size() ) ) - , pScissors( scissors_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineViewportStateCreateInfo & operator=( PipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineViewportStateCreateInfo & operator=( VkPipelineViewportStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setFlags( PipelineViewportStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setFlags( PipelineViewportStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setViewportCount( uint32_t viewportCount_ ) & VULKAN_HPP_NOEXCEPT - { - viewportCount = viewportCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setViewportCount( uint32_t viewportCount_ ) && VULKAN_HPP_NOEXCEPT - { - viewportCount = viewportCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setPViewports( const Viewport * pViewports_ ) & VULKAN_HPP_NOEXCEPT - { - pViewports = pViewports_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setPViewports( const Viewport * pViewports_ ) && VULKAN_HPP_NOEXCEPT - { - pViewports = pViewports_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportStateCreateInfo & setViewports( ArrayProxyNoTemporaries const & viewports_ ) VULKAN_HPP_NOEXCEPT - { - viewportCount = static_cast( viewports_.size() ); - pViewports = viewports_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setScissorCount( uint32_t scissorCount_ ) & VULKAN_HPP_NOEXCEPT - { - scissorCount = scissorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setScissorCount( uint32_t scissorCount_ ) && VULKAN_HPP_NOEXCEPT - { - scissorCount = scissorCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo & setPScissors( const Rect2D * pScissors_ ) & VULKAN_HPP_NOEXCEPT - { - pScissors = pScissors_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportStateCreateInfo && setPScissors( const Rect2D * pScissors_ ) && VULKAN_HPP_NOEXCEPT - { - pScissors = pScissors_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportStateCreateInfo & setScissors( ArrayProxyNoTemporaries const & scissors_ ) VULKAN_HPP_NOEXCEPT - { - scissorCount = static_cast( scissors_.size() ); - pScissors = scissors_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineViewportStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineViewportStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, viewportCount, pViewports, scissorCount, pScissors ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineViewportStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( viewportCount == rhs.viewportCount ) && - ( pViewports == rhs.pViewports ) && ( scissorCount == rhs.scissorCount ) && ( pScissors == rhs.pScissors ); -# endif - } - - bool operator!=( PipelineViewportStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineViewportStateCreateInfo; - const void * pNext = {}; - PipelineViewportStateCreateFlags flags = {}; - uint32_t viewportCount = {}; - const Viewport * pViewports = {}; - uint32_t scissorCount = {}; - const Rect2D * pScissors = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineViewportStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineViewportStateCreateInfo; - }; - - // wrapper struct for struct VkPipelineRasterizationStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateCreateInfo.html - struct PipelineRasterizationStateCreateInfo - { - using NativeType = VkPipelineRasterizationStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateFlags flags_ = {}, - Bool32 depthClampEnable_ = {}, - Bool32 rasterizerDiscardEnable_ = {}, - PolygonMode polygonMode_ = PolygonMode::eFill, - CullModeFlags cullMode_ = {}, - FrontFace frontFace_ = FrontFace::eCounterClockwise, - Bool32 depthBiasEnable_ = {}, - float depthBiasConstantFactor_ = {}, - float depthBiasClamp_ = {}, - float depthBiasSlopeFactor_ = {}, - float lineWidth_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , depthClampEnable{ depthClampEnable_ } - , rasterizerDiscardEnable{ rasterizerDiscardEnable_ } - , polygonMode{ polygonMode_ } - , cullMode{ cullMode_ } - , frontFace{ frontFace_ } - , depthBiasEnable{ depthBiasEnable_ } - , depthBiasConstantFactor{ depthBiasConstantFactor_ } - , depthBiasClamp{ depthBiasClamp_ } - , depthBiasSlopeFactor{ depthBiasSlopeFactor_ } - , lineWidth{ lineWidth_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineRasterizationStateCreateInfo( PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineRasterizationStateCreateInfo( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineRasterizationStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PipelineRasterizationStateCreateInfo & operator=( PipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineRasterizationStateCreateInfo & operator=( VkPipelineRasterizationStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setFlags( PipelineRasterizationStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setFlags( PipelineRasterizationStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setDepthClampEnable( Bool32 depthClampEnable_ ) & VULKAN_HPP_NOEXCEPT - { - depthClampEnable = depthClampEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setDepthClampEnable( Bool32 depthClampEnable_ ) && VULKAN_HPP_NOEXCEPT - { - depthClampEnable = depthClampEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ ) & VULKAN_HPP_NOEXCEPT - { - rasterizerDiscardEnable = rasterizerDiscardEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setRasterizerDiscardEnable( Bool32 rasterizerDiscardEnable_ ) && VULKAN_HPP_NOEXCEPT - { - rasterizerDiscardEnable = rasterizerDiscardEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setPolygonMode( PolygonMode polygonMode_ ) & VULKAN_HPP_NOEXCEPT - { - polygonMode = polygonMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setPolygonMode( PolygonMode polygonMode_ ) && VULKAN_HPP_NOEXCEPT - { - polygonMode = polygonMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setCullMode( CullModeFlags cullMode_ ) & VULKAN_HPP_NOEXCEPT - { - cullMode = cullMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setCullMode( CullModeFlags cullMode_ ) && VULKAN_HPP_NOEXCEPT - { - cullMode = cullMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setFrontFace( FrontFace frontFace_ ) & VULKAN_HPP_NOEXCEPT - { - frontFace = frontFace_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setFrontFace( FrontFace frontFace_ ) && VULKAN_HPP_NOEXCEPT - { - frontFace = frontFace_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setDepthBiasEnable( Bool32 depthBiasEnable_ ) & VULKAN_HPP_NOEXCEPT - { - depthBiasEnable = depthBiasEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setDepthBiasEnable( Bool32 depthBiasEnable_ ) && VULKAN_HPP_NOEXCEPT - { - depthBiasEnable = depthBiasEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) & VULKAN_HPP_NOEXCEPT - { - depthBiasConstantFactor = depthBiasConstantFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setDepthBiasConstantFactor( float depthBiasConstantFactor_ ) && VULKAN_HPP_NOEXCEPT - { - depthBiasConstantFactor = depthBiasConstantFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setDepthBiasClamp( float depthBiasClamp_ ) & VULKAN_HPP_NOEXCEPT - { - depthBiasClamp = depthBiasClamp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setDepthBiasClamp( float depthBiasClamp_ ) && VULKAN_HPP_NOEXCEPT - { - depthBiasClamp = depthBiasClamp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) & VULKAN_HPP_NOEXCEPT - { - depthBiasSlopeFactor = depthBiasSlopeFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setDepthBiasSlopeFactor( float depthBiasSlopeFactor_ ) && VULKAN_HPP_NOEXCEPT - { - depthBiasSlopeFactor = depthBiasSlopeFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo & setLineWidth( float lineWidth_ ) & VULKAN_HPP_NOEXCEPT - { - lineWidth = lineWidth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateCreateInfo && setLineWidth( float lineWidth_ ) && VULKAN_HPP_NOEXCEPT - { - lineWidth = lineWidth_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineRasterizationStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineRasterizationStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - depthClampEnable, - rasterizerDiscardEnable, - polygonMode, - cullMode, - frontFace, - depthBiasEnable, - depthBiasConstantFactor, - depthBiasClamp, - depthBiasSlopeFactor, - lineWidth ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineRasterizationStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( depthClampEnable == rhs.depthClampEnable ) && - ( rasterizerDiscardEnable == rhs.rasterizerDiscardEnable ) && ( polygonMode == rhs.polygonMode ) && ( cullMode == rhs.cullMode ) && - ( frontFace == rhs.frontFace ) && ( depthBiasEnable == rhs.depthBiasEnable ) && ( depthBiasConstantFactor == rhs.depthBiasConstantFactor ) && - ( depthBiasClamp == rhs.depthBiasClamp ) && ( depthBiasSlopeFactor == rhs.depthBiasSlopeFactor ) && ( lineWidth == rhs.lineWidth ); -# endif - } - - bool operator!=( PipelineRasterizationStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineRasterizationStateCreateInfo; - const void * pNext = {}; - PipelineRasterizationStateCreateFlags flags = {}; - Bool32 depthClampEnable = {}; - Bool32 rasterizerDiscardEnable = {}; - PolygonMode polygonMode = PolygonMode::eFill; - CullModeFlags cullMode = {}; - FrontFace frontFace = FrontFace::eCounterClockwise; - Bool32 depthBiasEnable = {}; - float depthBiasConstantFactor = {}; - float depthBiasClamp = {}; - float depthBiasSlopeFactor = {}; - float lineWidth = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineRasterizationStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineRasterizationStateCreateInfo; - }; - - // wrapper struct for struct VkPipelineMultisampleStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineMultisampleStateCreateInfo.html - struct PipelineMultisampleStateCreateInfo - { - using NativeType = VkPipelineMultisampleStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineMultisampleStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateFlags flags_ = {}, - SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, - Bool32 sampleShadingEnable_ = {}, - float minSampleShading_ = {}, - const SampleMask * pSampleMask_ = {}, - Bool32 alphaToCoverageEnable_ = {}, - Bool32 alphaToOneEnable_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , rasterizationSamples{ rasterizationSamples_ } - , sampleShadingEnable{ sampleShadingEnable_ } - , minSampleShading{ minSampleShading_ } - , pSampleMask{ pSampleMask_ } - , alphaToCoverageEnable{ alphaToCoverageEnable_ } - , alphaToOneEnable{ alphaToOneEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineMultisampleStateCreateInfo( PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineMultisampleStateCreateInfo( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineMultisampleStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PipelineMultisampleStateCreateInfo & operator=( PipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineMultisampleStateCreateInfo & operator=( VkPipelineMultisampleStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setFlags( PipelineMultisampleStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setFlags( PipelineMultisampleStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) & VULKAN_HPP_NOEXCEPT - { - rasterizationSamples = rasterizationSamples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) && VULKAN_HPP_NOEXCEPT - { - rasterizationSamples = rasterizationSamples_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setSampleShadingEnable( Bool32 sampleShadingEnable_ ) & VULKAN_HPP_NOEXCEPT - { - sampleShadingEnable = sampleShadingEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setSampleShadingEnable( Bool32 sampleShadingEnable_ ) && VULKAN_HPP_NOEXCEPT - { - sampleShadingEnable = sampleShadingEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setMinSampleShading( float minSampleShading_ ) & VULKAN_HPP_NOEXCEPT - { - minSampleShading = minSampleShading_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setMinSampleShading( float minSampleShading_ ) && VULKAN_HPP_NOEXCEPT - { - minSampleShading = minSampleShading_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setPSampleMask( const SampleMask * pSampleMask_ ) & VULKAN_HPP_NOEXCEPT - { - pSampleMask = pSampleMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setPSampleMask( const SampleMask * pSampleMask_ ) && VULKAN_HPP_NOEXCEPT - { - pSampleMask = pSampleMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ ) & VULKAN_HPP_NOEXCEPT - { - alphaToCoverageEnable = alphaToCoverageEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setAlphaToCoverageEnable( Bool32 alphaToCoverageEnable_ ) && VULKAN_HPP_NOEXCEPT - { - alphaToCoverageEnable = alphaToCoverageEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo & setAlphaToOneEnable( Bool32 alphaToOneEnable_ ) & VULKAN_HPP_NOEXCEPT - { - alphaToOneEnable = alphaToOneEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineMultisampleStateCreateInfo && setAlphaToOneEnable( Bool32 alphaToOneEnable_ ) && VULKAN_HPP_NOEXCEPT - { - alphaToOneEnable = alphaToOneEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineMultisampleStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineMultisampleStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineMultisampleStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineMultisampleStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, rasterizationSamples, sampleShadingEnable, minSampleShading, pSampleMask, alphaToCoverageEnable, alphaToOneEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineMultisampleStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rasterizationSamples == rhs.rasterizationSamples ) && - ( sampleShadingEnable == rhs.sampleShadingEnable ) && ( minSampleShading == rhs.minSampleShading ) && ( pSampleMask == rhs.pSampleMask ) && - ( alphaToCoverageEnable == rhs.alphaToCoverageEnable ) && ( alphaToOneEnable == rhs.alphaToOneEnable ); -# endif - } - - bool operator!=( PipelineMultisampleStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineMultisampleStateCreateInfo; - const void * pNext = {}; - PipelineMultisampleStateCreateFlags flags = {}; - SampleCountFlagBits rasterizationSamples = SampleCountFlagBits::e1; - Bool32 sampleShadingEnable = {}; - float minSampleShading = {}; - const SampleMask * pSampleMask = {}; - Bool32 alphaToCoverageEnable = {}; - Bool32 alphaToOneEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineMultisampleStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineMultisampleStateCreateInfo; - }; - - // wrapper struct for struct VkStencilOpState, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkStencilOpState.html - struct StencilOpState - { - using NativeType = VkStencilOpState; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR StencilOpState( StencilOp failOp_ = StencilOp::eKeep, - StencilOp passOp_ = StencilOp::eKeep, - StencilOp depthFailOp_ = StencilOp::eKeep, - CompareOp compareOp_ = CompareOp::eNever, - uint32_t compareMask_ = {}, - uint32_t writeMask_ = {}, - uint32_t reference_ = {} ) VULKAN_HPP_NOEXCEPT - : failOp{ failOp_ } - , passOp{ passOp_ } - , depthFailOp{ depthFailOp_ } - , compareOp{ compareOp_ } - , compareMask{ compareMask_ } - , writeMask{ writeMask_ } - , reference{ reference_ } - { - } - - VULKAN_HPP_CONSTEXPR StencilOpState( StencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - StencilOpState( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT : StencilOpState( *reinterpret_cast( &rhs ) ) {} - - StencilOpState & operator=( StencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - StencilOpState & operator=( VkStencilOpState const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 StencilOpState & setFailOp( StencilOp failOp_ ) & VULKAN_HPP_NOEXCEPT - { - failOp = failOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState && setFailOp( StencilOp failOp_ ) && VULKAN_HPP_NOEXCEPT - { - failOp = failOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState & setPassOp( StencilOp passOp_ ) & VULKAN_HPP_NOEXCEPT - { - passOp = passOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState && setPassOp( StencilOp passOp_ ) && VULKAN_HPP_NOEXCEPT - { - passOp = passOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState & setDepthFailOp( StencilOp depthFailOp_ ) & VULKAN_HPP_NOEXCEPT - { - depthFailOp = depthFailOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState && setDepthFailOp( StencilOp depthFailOp_ ) && VULKAN_HPP_NOEXCEPT - { - depthFailOp = depthFailOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState & setCompareOp( CompareOp compareOp_ ) & VULKAN_HPP_NOEXCEPT - { - compareOp = compareOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState && setCompareOp( CompareOp compareOp_ ) && VULKAN_HPP_NOEXCEPT - { - compareOp = compareOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState & setCompareMask( uint32_t compareMask_ ) & VULKAN_HPP_NOEXCEPT - { - compareMask = compareMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState && setCompareMask( uint32_t compareMask_ ) && VULKAN_HPP_NOEXCEPT - { - compareMask = compareMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState & setWriteMask( uint32_t writeMask_ ) & VULKAN_HPP_NOEXCEPT - { - writeMask = writeMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState && setWriteMask( uint32_t writeMask_ ) && VULKAN_HPP_NOEXCEPT - { - writeMask = writeMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState & setReference( uint32_t reference_ ) & VULKAN_HPP_NOEXCEPT - { - reference = reference_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StencilOpState && setReference( uint32_t reference_ ) && VULKAN_HPP_NOEXCEPT - { - reference = reference_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkStencilOpState const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStencilOpState &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStencilOpState const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkStencilOpState *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( failOp, passOp, depthFailOp, compareOp, compareMask, writeMask, reference ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( StencilOpState const & ) const = default; -#else - bool operator==( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( failOp == rhs.failOp ) && ( passOp == rhs.passOp ) && ( depthFailOp == rhs.depthFailOp ) && ( compareOp == rhs.compareOp ) && - ( compareMask == rhs.compareMask ) && ( writeMask == rhs.writeMask ) && ( reference == rhs.reference ); -# endif - } - - bool operator!=( StencilOpState const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StencilOp failOp = StencilOp::eKeep; - StencilOp passOp = StencilOp::eKeep; - StencilOp depthFailOp = StencilOp::eKeep; - CompareOp compareOp = CompareOp::eNever; - uint32_t compareMask = {}; - uint32_t writeMask = {}; - uint32_t reference = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = StencilOpState; - }; -#endif - - // wrapper struct for struct VkPipelineDepthStencilStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDepthStencilStateCreateInfo.html - struct PipelineDepthStencilStateCreateInfo - { - using NativeType = VkPipelineDepthStencilStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDepthStencilStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateFlags flags_ = {}, - Bool32 depthTestEnable_ = {}, - Bool32 depthWriteEnable_ = {}, - CompareOp depthCompareOp_ = CompareOp::eNever, - Bool32 depthBoundsTestEnable_ = {}, - Bool32 stencilTestEnable_ = {}, - StencilOpState front_ = {}, - StencilOpState back_ = {}, - float minDepthBounds_ = {}, - float maxDepthBounds_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , depthTestEnable{ depthTestEnable_ } - , depthWriteEnable{ depthWriteEnable_ } - , depthCompareOp{ depthCompareOp_ } - , depthBoundsTestEnable{ depthBoundsTestEnable_ } - , stencilTestEnable{ stencilTestEnable_ } - , front{ front_ } - , back{ back_ } - , minDepthBounds{ minDepthBounds_ } - , maxDepthBounds{ maxDepthBounds_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineDepthStencilStateCreateInfo( PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineDepthStencilStateCreateInfo( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineDepthStencilStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PipelineDepthStencilStateCreateInfo & operator=( PipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineDepthStencilStateCreateInfo & operator=( VkPipelineDepthStencilStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setFlags( PipelineDepthStencilStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setFlags( PipelineDepthStencilStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setDepthTestEnable( Bool32 depthTestEnable_ ) & VULKAN_HPP_NOEXCEPT - { - depthTestEnable = depthTestEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setDepthTestEnable( Bool32 depthTestEnable_ ) && VULKAN_HPP_NOEXCEPT - { - depthTestEnable = depthTestEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setDepthWriteEnable( Bool32 depthWriteEnable_ ) & VULKAN_HPP_NOEXCEPT - { - depthWriteEnable = depthWriteEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setDepthWriteEnable( Bool32 depthWriteEnable_ ) && VULKAN_HPP_NOEXCEPT - { - depthWriteEnable = depthWriteEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setDepthCompareOp( CompareOp depthCompareOp_ ) & VULKAN_HPP_NOEXCEPT - { - depthCompareOp = depthCompareOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setDepthCompareOp( CompareOp depthCompareOp_ ) && VULKAN_HPP_NOEXCEPT - { - depthCompareOp = depthCompareOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ ) & VULKAN_HPP_NOEXCEPT - { - depthBoundsTestEnable = depthBoundsTestEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setDepthBoundsTestEnable( Bool32 depthBoundsTestEnable_ ) && VULKAN_HPP_NOEXCEPT - { - depthBoundsTestEnable = depthBoundsTestEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setStencilTestEnable( Bool32 stencilTestEnable_ ) & VULKAN_HPP_NOEXCEPT - { - stencilTestEnable = stencilTestEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setStencilTestEnable( Bool32 stencilTestEnable_ ) && VULKAN_HPP_NOEXCEPT - { - stencilTestEnable = stencilTestEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setFront( StencilOpState const & front_ ) & VULKAN_HPP_NOEXCEPT - { - front = front_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setFront( StencilOpState const & front_ ) && VULKAN_HPP_NOEXCEPT - { - front = front_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setBack( StencilOpState const & back_ ) & VULKAN_HPP_NOEXCEPT - { - back = back_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setBack( StencilOpState const & back_ ) && VULKAN_HPP_NOEXCEPT - { - back = back_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setMinDepthBounds( float minDepthBounds_ ) & VULKAN_HPP_NOEXCEPT - { - minDepthBounds = minDepthBounds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setMinDepthBounds( float minDepthBounds_ ) && VULKAN_HPP_NOEXCEPT - { - minDepthBounds = minDepthBounds_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo & setMaxDepthBounds( float maxDepthBounds_ ) & VULKAN_HPP_NOEXCEPT - { - maxDepthBounds = maxDepthBounds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDepthStencilStateCreateInfo && setMaxDepthBounds( float maxDepthBounds_ ) && VULKAN_HPP_NOEXCEPT - { - maxDepthBounds = maxDepthBounds_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineDepthStencilStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineDepthStencilStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineDepthStencilStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineDepthStencilStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - depthTestEnable, - depthWriteEnable, - depthCompareOp, - depthBoundsTestEnable, - stencilTestEnable, - front, - back, - minDepthBounds, - maxDepthBounds ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineDepthStencilStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( depthTestEnable == rhs.depthTestEnable ) && - ( depthWriteEnable == rhs.depthWriteEnable ) && ( depthCompareOp == rhs.depthCompareOp ) && - ( depthBoundsTestEnable == rhs.depthBoundsTestEnable ) && ( stencilTestEnable == rhs.stencilTestEnable ) && ( front == rhs.front ) && - ( back == rhs.back ) && ( minDepthBounds == rhs.minDepthBounds ) && ( maxDepthBounds == rhs.maxDepthBounds ); -# endif - } - - bool operator!=( PipelineDepthStencilStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineDepthStencilStateCreateInfo; - const void * pNext = {}; - PipelineDepthStencilStateCreateFlags flags = {}; - Bool32 depthTestEnable = {}; - Bool32 depthWriteEnable = {}; - CompareOp depthCompareOp = CompareOp::eNever; - Bool32 depthBoundsTestEnable = {}; - Bool32 stencilTestEnable = {}; - StencilOpState front = {}; - StencilOpState back = {}; - float minDepthBounds = {}; - float maxDepthBounds = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineDepthStencilStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineDepthStencilStateCreateInfo; - }; - - // wrapper struct for struct VkPipelineColorBlendAttachmentState, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendAttachmentState.html - struct PipelineColorBlendAttachmentState - { - using NativeType = VkPipelineColorBlendAttachmentState; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( Bool32 blendEnable_ = {}, - BlendFactor srcColorBlendFactor_ = BlendFactor::eZero, - BlendFactor dstColorBlendFactor_ = BlendFactor::eZero, - BlendOp colorBlendOp_ = BlendOp::eAdd, - BlendFactor srcAlphaBlendFactor_ = BlendFactor::eZero, - BlendFactor dstAlphaBlendFactor_ = BlendFactor::eZero, - BlendOp alphaBlendOp_ = BlendOp::eAdd, - ColorComponentFlags colorWriteMask_ = {} ) VULKAN_HPP_NOEXCEPT - : blendEnable{ blendEnable_ } - , srcColorBlendFactor{ srcColorBlendFactor_ } - , dstColorBlendFactor{ dstColorBlendFactor_ } - , colorBlendOp{ colorBlendOp_ } - , srcAlphaBlendFactor{ srcAlphaBlendFactor_ } - , dstAlphaBlendFactor{ dstAlphaBlendFactor_ } - , alphaBlendOp{ alphaBlendOp_ } - , colorWriteMask{ colorWriteMask_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineColorBlendAttachmentState( PipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineColorBlendAttachmentState( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineColorBlendAttachmentState( *reinterpret_cast( &rhs ) ) - { - } - - PipelineColorBlendAttachmentState & operator=( PipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineColorBlendAttachmentState & operator=( VkPipelineColorBlendAttachmentState const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setBlendEnable( Bool32 blendEnable_ ) & VULKAN_HPP_NOEXCEPT - { - blendEnable = blendEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setBlendEnable( Bool32 blendEnable_ ) && VULKAN_HPP_NOEXCEPT - { - blendEnable = blendEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) & VULKAN_HPP_NOEXCEPT - { - srcColorBlendFactor = srcColorBlendFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setSrcColorBlendFactor( BlendFactor srcColorBlendFactor_ ) && VULKAN_HPP_NOEXCEPT - { - srcColorBlendFactor = srcColorBlendFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) & VULKAN_HPP_NOEXCEPT - { - dstColorBlendFactor = dstColorBlendFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setDstColorBlendFactor( BlendFactor dstColorBlendFactor_ ) && VULKAN_HPP_NOEXCEPT - { - dstColorBlendFactor = dstColorBlendFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setColorBlendOp( BlendOp colorBlendOp_ ) & VULKAN_HPP_NOEXCEPT - { - colorBlendOp = colorBlendOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setColorBlendOp( BlendOp colorBlendOp_ ) && VULKAN_HPP_NOEXCEPT - { - colorBlendOp = colorBlendOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) & VULKAN_HPP_NOEXCEPT - { - srcAlphaBlendFactor = srcAlphaBlendFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setSrcAlphaBlendFactor( BlendFactor srcAlphaBlendFactor_ ) && VULKAN_HPP_NOEXCEPT - { - srcAlphaBlendFactor = srcAlphaBlendFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) & VULKAN_HPP_NOEXCEPT - { - dstAlphaBlendFactor = dstAlphaBlendFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setDstAlphaBlendFactor( BlendFactor dstAlphaBlendFactor_ ) && VULKAN_HPP_NOEXCEPT - { - dstAlphaBlendFactor = dstAlphaBlendFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setAlphaBlendOp( BlendOp alphaBlendOp_ ) & VULKAN_HPP_NOEXCEPT - { - alphaBlendOp = alphaBlendOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setAlphaBlendOp( BlendOp alphaBlendOp_ ) && VULKAN_HPP_NOEXCEPT - { - alphaBlendOp = alphaBlendOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState & setColorWriteMask( ColorComponentFlags colorWriteMask_ ) & VULKAN_HPP_NOEXCEPT - { - colorWriteMask = colorWriteMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAttachmentState && setColorWriteMask( ColorComponentFlags colorWriteMask_ ) && VULKAN_HPP_NOEXCEPT - { - colorWriteMask = colorWriteMask_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineColorBlendAttachmentState const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineColorBlendAttachmentState &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineColorBlendAttachmentState const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineColorBlendAttachmentState *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - blendEnable, srcColorBlendFactor, dstColorBlendFactor, colorBlendOp, srcAlphaBlendFactor, dstAlphaBlendFactor, alphaBlendOp, colorWriteMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineColorBlendAttachmentState const & ) const = default; -#else - bool operator==( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( blendEnable == rhs.blendEnable ) && ( srcColorBlendFactor == rhs.srcColorBlendFactor ) && ( dstColorBlendFactor == rhs.dstColorBlendFactor ) && - ( colorBlendOp == rhs.colorBlendOp ) && ( srcAlphaBlendFactor == rhs.srcAlphaBlendFactor ) && ( dstAlphaBlendFactor == rhs.dstAlphaBlendFactor ) && - ( alphaBlendOp == rhs.alphaBlendOp ) && ( colorWriteMask == rhs.colorWriteMask ); -# endif - } - - bool operator!=( PipelineColorBlendAttachmentState const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Bool32 blendEnable = {}; - BlendFactor srcColorBlendFactor = BlendFactor::eZero; - BlendFactor dstColorBlendFactor = BlendFactor::eZero; - BlendOp colorBlendOp = BlendOp::eAdd; - BlendFactor srcAlphaBlendFactor = BlendFactor::eZero; - BlendFactor dstAlphaBlendFactor = BlendFactor::eZero; - BlendOp alphaBlendOp = BlendOp::eAdd; - ColorComponentFlags colorWriteMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineColorBlendAttachmentState; - }; -#endif - - // wrapper struct for struct VkPipelineColorBlendStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendStateCreateInfo.html - struct PipelineColorBlendStateCreateInfo - { - using NativeType = VkPipelineColorBlendStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineColorBlendStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_ = {}, - Bool32 logicOpEnable_ = {}, - LogicOp logicOp_ = LogicOp::eClear, - uint32_t attachmentCount_ = {}, - const PipelineColorBlendAttachmentState * pAttachments_ = {}, - std::array const & blendConstants_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , logicOpEnable{ logicOpEnable_ } - , logicOp{ logicOp_ } - , attachmentCount{ attachmentCount_ } - , pAttachments{ pAttachments_ } - , blendConstants{ blendConstants_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineColorBlendStateCreateInfo( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineColorBlendStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineColorBlendStateCreateInfo( PipelineColorBlendStateCreateFlags flags_, - Bool32 logicOpEnable_, - LogicOp logicOp_, - ArrayProxyNoTemporaries const & attachments_, - std::array const & blendConstants_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , logicOpEnable( logicOpEnable_ ) - , logicOp( logicOp_ ) - , attachmentCount( static_cast( attachments_.size() ) ) - , pAttachments( attachments_.data() ) - , blendConstants( blendConstants_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineColorBlendStateCreateInfo & operator=( PipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineColorBlendStateCreateInfo & operator=( VkPipelineColorBlendStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setFlags( PipelineColorBlendStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setFlags( PipelineColorBlendStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setLogicOpEnable( Bool32 logicOpEnable_ ) & VULKAN_HPP_NOEXCEPT - { - logicOpEnable = logicOpEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setLogicOpEnable( Bool32 logicOpEnable_ ) && VULKAN_HPP_NOEXCEPT - { - logicOpEnable = logicOpEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setLogicOp( LogicOp logicOp_ ) & VULKAN_HPP_NOEXCEPT - { - logicOp = logicOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setLogicOp( LogicOp logicOp_ ) && VULKAN_HPP_NOEXCEPT - { - logicOp = logicOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setPAttachments( const PipelineColorBlendAttachmentState * pAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pAttachments = pAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setPAttachments( const PipelineColorBlendAttachmentState * pAttachments_ ) && - VULKAN_HPP_NOEXCEPT - { - pAttachments = pAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineColorBlendStateCreateInfo & - setAttachments( ArrayProxyNoTemporaries const & attachments_ ) VULKAN_HPP_NOEXCEPT - { - attachmentCount = static_cast( attachments_.size() ); - pAttachments = attachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo & setBlendConstants( std::array blendConstants_ ) & VULKAN_HPP_NOEXCEPT - { - blendConstants = blendConstants_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendStateCreateInfo && setBlendConstants( std::array blendConstants_ ) && VULKAN_HPP_NOEXCEPT - { - blendConstants = blendConstants_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineColorBlendStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineColorBlendStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineColorBlendStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineColorBlendStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, logicOpEnable, logicOp, attachmentCount, pAttachments, blendConstants ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineColorBlendStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( logicOpEnable == rhs.logicOpEnable ) && - ( logicOp == rhs.logicOp ) && ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ) && - ( blendConstants == rhs.blendConstants ); -# endif - } - - bool operator!=( PipelineColorBlendStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineColorBlendStateCreateInfo; - const void * pNext = {}; - PipelineColorBlendStateCreateFlags flags = {}; - Bool32 logicOpEnable = {}; - LogicOp logicOp = LogicOp::eClear; - uint32_t attachmentCount = {}; - const PipelineColorBlendAttachmentState * pAttachments = {}; - ArrayWrapper1D blendConstants = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineColorBlendStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineColorBlendStateCreateInfo; - }; - - // wrapper struct for struct VkPipelineDynamicStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDynamicStateCreateInfo.html - struct PipelineDynamicStateCreateInfo - { - using NativeType = VkPipelineDynamicStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDynamicStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_ = {}, - uint32_t dynamicStateCount_ = {}, - const DynamicState * pDynamicStates_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , dynamicStateCount{ dynamicStateCount_ } - , pDynamicStates{ pDynamicStates_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineDynamicStateCreateInfo( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineDynamicStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineDynamicStateCreateInfo( PipelineDynamicStateCreateFlags flags_, - ArrayProxyNoTemporaries const & dynamicStates_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), flags( flags_ ), dynamicStateCount( static_cast( dynamicStates_.size() ) ), pDynamicStates( dynamicStates_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineDynamicStateCreateInfo & operator=( PipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineDynamicStateCreateInfo & operator=( VkPipelineDynamicStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo & setFlags( PipelineDynamicStateCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo && setFlags( PipelineDynamicStateCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo & setDynamicStateCount( uint32_t dynamicStateCount_ ) & VULKAN_HPP_NOEXCEPT - { - dynamicStateCount = dynamicStateCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo && setDynamicStateCount( uint32_t dynamicStateCount_ ) && VULKAN_HPP_NOEXCEPT - { - dynamicStateCount = dynamicStateCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo & setPDynamicStates( const DynamicState * pDynamicStates_ ) & VULKAN_HPP_NOEXCEPT - { - pDynamicStates = pDynamicStates_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDynamicStateCreateInfo && setPDynamicStates( const DynamicState * pDynamicStates_ ) && VULKAN_HPP_NOEXCEPT - { - pDynamicStates = pDynamicStates_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineDynamicStateCreateInfo & setDynamicStates( ArrayProxyNoTemporaries const & dynamicStates_ ) VULKAN_HPP_NOEXCEPT - { - dynamicStateCount = static_cast( dynamicStates_.size() ); - pDynamicStates = dynamicStates_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineDynamicStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineDynamicStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineDynamicStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineDynamicStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, dynamicStateCount, pDynamicStates ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineDynamicStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dynamicStateCount == rhs.dynamicStateCount ) && - ( pDynamicStates == rhs.pDynamicStates ); -# endif - } - - bool operator!=( PipelineDynamicStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineDynamicStateCreateInfo; - const void * pNext = {}; - PipelineDynamicStateCreateFlags flags = {}; - uint32_t dynamicStateCount = {}; - const DynamicState * pDynamicStates = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineDynamicStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineDynamicStateCreateInfo; - }; - - // wrapper struct for struct VkGraphicsPipelineCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineCreateInfo.html - struct GraphicsPipelineCreateInfo - { - using NativeType = VkGraphicsPipelineCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsPipelineCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo( PipelineCreateFlags flags_ = {}, - uint32_t stageCount_ = {}, - const PipelineShaderStageCreateInfo * pStages_ = {}, - const PipelineVertexInputStateCreateInfo * pVertexInputState_ = {}, - const PipelineInputAssemblyStateCreateInfo * pInputAssemblyState_ = {}, - const PipelineTessellationStateCreateInfo * pTessellationState_ = {}, - const PipelineViewportStateCreateInfo * pViewportState_ = {}, - const PipelineRasterizationStateCreateInfo * pRasterizationState_ = {}, - const PipelineMultisampleStateCreateInfo * pMultisampleState_ = {}, - const PipelineDepthStencilStateCreateInfo * pDepthStencilState_ = {}, - const PipelineColorBlendStateCreateInfo * pColorBlendState_ = {}, - const PipelineDynamicStateCreateInfo * pDynamicState_ = {}, - PipelineLayout layout_ = {}, - RenderPass renderPass_ = {}, - uint32_t subpass_ = {}, - Pipeline basePipelineHandle_ = {}, - int32_t basePipelineIndex_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , stageCount{ stageCount_ } - , pStages{ pStages_ } - , pVertexInputState{ pVertexInputState_ } - , pInputAssemblyState{ pInputAssemblyState_ } - , pTessellationState{ pTessellationState_ } - , pViewportState{ pViewportState_ } - , pRasterizationState{ pRasterizationState_ } - , pMultisampleState{ pMultisampleState_ } - , pDepthStencilState{ pDepthStencilState_ } - , pColorBlendState{ pColorBlendState_ } - , pDynamicState{ pDynamicState_ } - , layout{ layout_ } - , renderPass{ renderPass_ } - , subpass{ subpass_ } - , basePipelineHandle{ basePipelineHandle_ } - , basePipelineIndex{ basePipelineIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo( GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GraphicsPipelineCreateInfo( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : GraphicsPipelineCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GraphicsPipelineCreateInfo( PipelineCreateFlags flags_, - ArrayProxyNoTemporaries const & stages_, - const PipelineVertexInputStateCreateInfo * pVertexInputState_ = {}, - const PipelineInputAssemblyStateCreateInfo * pInputAssemblyState_ = {}, - const PipelineTessellationStateCreateInfo * pTessellationState_ = {}, - const PipelineViewportStateCreateInfo * pViewportState_ = {}, - const PipelineRasterizationStateCreateInfo * pRasterizationState_ = {}, - const PipelineMultisampleStateCreateInfo * pMultisampleState_ = {}, - const PipelineDepthStencilStateCreateInfo * pDepthStencilState_ = {}, - const PipelineColorBlendStateCreateInfo * pColorBlendState_ = {}, - const PipelineDynamicStateCreateInfo * pDynamicState_ = {}, - PipelineLayout layout_ = {}, - RenderPass renderPass_ = {}, - uint32_t subpass_ = {}, - Pipeline basePipelineHandle_ = {}, - int32_t basePipelineIndex_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , stageCount( static_cast( stages_.size() ) ) - , pStages( stages_.data() ) - , pVertexInputState( pVertexInputState_ ) - , pInputAssemblyState( pInputAssemblyState_ ) - , pTessellationState( pTessellationState_ ) - , pViewportState( pViewportState_ ) - , pRasterizationState( pRasterizationState_ ) - , pMultisampleState( pMultisampleState_ ) - , pDepthStencilState( pDepthStencilState_ ) - , pColorBlendState( pColorBlendState_ ) - , pDynamicState( pDynamicState_ ) - , layout( layout_ ) - , renderPass( renderPass_ ) - , subpass( subpass_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - GraphicsPipelineCreateInfo & operator=( GraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GraphicsPipelineCreateInfo & operator=( VkGraphicsPipelineCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setFlags( PipelineCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setFlags( PipelineCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setStageCount( uint32_t stageCount_ ) & VULKAN_HPP_NOEXCEPT - { - stageCount = stageCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setStageCount( uint32_t stageCount_ ) && VULKAN_HPP_NOEXCEPT - { - stageCount = stageCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPStages( const PipelineShaderStageCreateInfo * pStages_ ) & VULKAN_HPP_NOEXCEPT - { - pStages = pStages_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPStages( const PipelineShaderStageCreateInfo * pStages_ ) && VULKAN_HPP_NOEXCEPT - { - pStages = pStages_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GraphicsPipelineCreateInfo & setStages( ArrayProxyNoTemporaries const & stages_ ) VULKAN_HPP_NOEXCEPT - { - stageCount = static_cast( stages_.size() ); - pStages = stages_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPVertexInputState( const PipelineVertexInputStateCreateInfo * pVertexInputState_ ) & - VULKAN_HPP_NOEXCEPT - { - pVertexInputState = pVertexInputState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPVertexInputState( const PipelineVertexInputStateCreateInfo * pVertexInputState_ ) && - VULKAN_HPP_NOEXCEPT - { - pVertexInputState = pVertexInputState_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo * pInputAssemblyState_ ) & - VULKAN_HPP_NOEXCEPT - { - pInputAssemblyState = pInputAssemblyState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPInputAssemblyState( const PipelineInputAssemblyStateCreateInfo * pInputAssemblyState_ ) && - VULKAN_HPP_NOEXCEPT - { - pInputAssemblyState = pInputAssemblyState_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPTessellationState( const PipelineTessellationStateCreateInfo * pTessellationState_ ) & - VULKAN_HPP_NOEXCEPT - { - pTessellationState = pTessellationState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPTessellationState( const PipelineTessellationStateCreateInfo * pTessellationState_ ) && - VULKAN_HPP_NOEXCEPT - { - pTessellationState = pTessellationState_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPViewportState( const PipelineViewportStateCreateInfo * pViewportState_ ) & VULKAN_HPP_NOEXCEPT - { - pViewportState = pViewportState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPViewportState( const PipelineViewportStateCreateInfo * pViewportState_ ) && VULKAN_HPP_NOEXCEPT - { - pViewportState = pViewportState_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPRasterizationState( const PipelineRasterizationStateCreateInfo * pRasterizationState_ ) & - VULKAN_HPP_NOEXCEPT - { - pRasterizationState = pRasterizationState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPRasterizationState( const PipelineRasterizationStateCreateInfo * pRasterizationState_ ) && - VULKAN_HPP_NOEXCEPT - { - pRasterizationState = pRasterizationState_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPMultisampleState( const PipelineMultisampleStateCreateInfo * pMultisampleState_ ) & - VULKAN_HPP_NOEXCEPT - { - pMultisampleState = pMultisampleState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPMultisampleState( const PipelineMultisampleStateCreateInfo * pMultisampleState_ ) && - VULKAN_HPP_NOEXCEPT - { - pMultisampleState = pMultisampleState_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPDepthStencilState( const PipelineDepthStencilStateCreateInfo * pDepthStencilState_ ) & - VULKAN_HPP_NOEXCEPT - { - pDepthStencilState = pDepthStencilState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPDepthStencilState( const PipelineDepthStencilStateCreateInfo * pDepthStencilState_ ) && - VULKAN_HPP_NOEXCEPT - { - pDepthStencilState = pDepthStencilState_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPColorBlendState( const PipelineColorBlendStateCreateInfo * pColorBlendState_ ) & - VULKAN_HPP_NOEXCEPT - { - pColorBlendState = pColorBlendState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPColorBlendState( const PipelineColorBlendStateCreateInfo * pColorBlendState_ ) && - VULKAN_HPP_NOEXCEPT - { - pColorBlendState = pColorBlendState_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setPDynamicState( const PipelineDynamicStateCreateInfo * pDynamicState_ ) & VULKAN_HPP_NOEXCEPT - { - pDynamicState = pDynamicState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setPDynamicState( const PipelineDynamicStateCreateInfo * pDynamicState_ ) && VULKAN_HPP_NOEXCEPT - { - pDynamicState = pDynamicState_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setRenderPass( RenderPass renderPass_ ) & VULKAN_HPP_NOEXCEPT - { - renderPass = renderPass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setRenderPass( RenderPass renderPass_ ) && VULKAN_HPP_NOEXCEPT - { - renderPass = renderPass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setSubpass( uint32_t subpass_ ) & VULKAN_HPP_NOEXCEPT - { - subpass = subpass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setSubpass( uint32_t subpass_ ) && VULKAN_HPP_NOEXCEPT - { - subpass = subpass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setBasePipelineHandle( Pipeline basePipelineHandle_ ) & VULKAN_HPP_NOEXCEPT - { - basePipelineHandle = basePipelineHandle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setBasePipelineHandle( Pipeline basePipelineHandle_ ) && VULKAN_HPP_NOEXCEPT - { - basePipelineHandle = basePipelineHandle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo & setBasePipelineIndex( int32_t basePipelineIndex_ ) & VULKAN_HPP_NOEXCEPT - { - basePipelineIndex = basePipelineIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineCreateInfo && setBasePipelineIndex( int32_t basePipelineIndex_ ) && VULKAN_HPP_NOEXCEPT - { - basePipelineIndex = basePipelineIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGraphicsPipelineCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGraphicsPipelineCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGraphicsPipelineCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGraphicsPipelineCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - stageCount, - pStages, - pVertexInputState, - pInputAssemblyState, - pTessellationState, - pViewportState, - pRasterizationState, - pMultisampleState, - pDepthStencilState, - pColorBlendState, - pDynamicState, - layout, - renderPass, - subpass, - basePipelineHandle, - basePipelineIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GraphicsPipelineCreateInfo const & ) const = default; -#else - bool operator==( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && - ( pVertexInputState == rhs.pVertexInputState ) && ( pInputAssemblyState == rhs.pInputAssemblyState ) && - ( pTessellationState == rhs.pTessellationState ) && ( pViewportState == rhs.pViewportState ) && - ( pRasterizationState == rhs.pRasterizationState ) && ( pMultisampleState == rhs.pMultisampleState ) && - ( pDepthStencilState == rhs.pDepthStencilState ) && ( pColorBlendState == rhs.pColorBlendState ) && ( pDynamicState == rhs.pDynamicState ) && - ( layout == rhs.layout ) && ( renderPass == rhs.renderPass ) && ( subpass == rhs.subpass ) && ( basePipelineHandle == rhs.basePipelineHandle ) && - ( basePipelineIndex == rhs.basePipelineIndex ); -# endif - } - - bool operator!=( GraphicsPipelineCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGraphicsPipelineCreateInfo; - const void * pNext = {}; - PipelineCreateFlags flags = {}; - uint32_t stageCount = {}; - const PipelineShaderStageCreateInfo * pStages = {}; - const PipelineVertexInputStateCreateInfo * pVertexInputState = {}; - const PipelineInputAssemblyStateCreateInfo * pInputAssemblyState = {}; - const PipelineTessellationStateCreateInfo * pTessellationState = {}; - const PipelineViewportStateCreateInfo * pViewportState = {}; - const PipelineRasterizationStateCreateInfo * pRasterizationState = {}; - const PipelineMultisampleStateCreateInfo * pMultisampleState = {}; - const PipelineDepthStencilStateCreateInfo * pDepthStencilState = {}; - const PipelineColorBlendStateCreateInfo * pColorBlendState = {}; - const PipelineDynamicStateCreateInfo * pDynamicState = {}; - PipelineLayout layout = {}; - RenderPass renderPass = {}; - uint32_t subpass = {}; - Pipeline basePipelineHandle = {}; - int32_t basePipelineIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GraphicsPipelineCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = GraphicsPipelineCreateInfo; - }; - - // wrapper struct for struct VkGraphicsPipelineLibraryCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineLibraryCreateInfoEXT.html - struct GraphicsPipelineLibraryCreateInfoEXT - { - using NativeType = VkGraphicsPipelineLibraryCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsPipelineLibraryCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GraphicsPipelineLibraryCreateInfoEXT( GraphicsPipelineLibraryFlagsEXT flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR GraphicsPipelineLibraryCreateInfoEXT( GraphicsPipelineLibraryCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GraphicsPipelineLibraryCreateInfoEXT( VkGraphicsPipelineLibraryCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : GraphicsPipelineLibraryCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - GraphicsPipelineLibraryCreateInfoEXT & operator=( GraphicsPipelineLibraryCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GraphicsPipelineLibraryCreateInfoEXT & operator=( VkGraphicsPipelineLibraryCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineLibraryCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineLibraryCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineLibraryCreateInfoEXT & setFlags( GraphicsPipelineLibraryFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineLibraryCreateInfoEXT && setFlags( GraphicsPipelineLibraryFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGraphicsPipelineLibraryCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGraphicsPipelineLibraryCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGraphicsPipelineLibraryCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGraphicsPipelineLibraryCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GraphicsPipelineLibraryCreateInfoEXT const & ) const = default; -#else - bool operator==( GraphicsPipelineLibraryCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( GraphicsPipelineLibraryCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGraphicsPipelineLibraryCreateInfoEXT; - const void * pNext = {}; - GraphicsPipelineLibraryFlagsEXT flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GraphicsPipelineLibraryCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = GraphicsPipelineLibraryCreateInfoEXT; - }; - - // wrapper struct for struct VkGraphicsShaderGroupCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsShaderGroupCreateInfoNV.html - struct GraphicsShaderGroupCreateInfoNV - { - using NativeType = VkGraphicsShaderGroupCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsShaderGroupCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GraphicsShaderGroupCreateInfoNV( uint32_t stageCount_ = {}, - const PipelineShaderStageCreateInfo * pStages_ = {}, - const PipelineVertexInputStateCreateInfo * pVertexInputState_ = {}, - const PipelineTessellationStateCreateInfo * pTessellationState_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stageCount{ stageCount_ } - , pStages{ pStages_ } - , pVertexInputState{ pVertexInputState_ } - , pTessellationState{ pTessellationState_ } - { - } - - VULKAN_HPP_CONSTEXPR GraphicsShaderGroupCreateInfoNV( GraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GraphicsShaderGroupCreateInfoNV( VkGraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : GraphicsShaderGroupCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GraphicsShaderGroupCreateInfoNV( ArrayProxyNoTemporaries const & stages_, - const PipelineVertexInputStateCreateInfo * pVertexInputState_ = {}, - const PipelineTessellationStateCreateInfo * pTessellationState_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , stageCount( static_cast( stages_.size() ) ) - , pStages( stages_.data() ) - , pVertexInputState( pVertexInputState_ ) - , pTessellationState( pTessellationState_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - GraphicsShaderGroupCreateInfoNV & operator=( GraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GraphicsShaderGroupCreateInfoNV & operator=( VkGraphicsShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV & setStageCount( uint32_t stageCount_ ) & VULKAN_HPP_NOEXCEPT - { - stageCount = stageCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV && setStageCount( uint32_t stageCount_ ) && VULKAN_HPP_NOEXCEPT - { - stageCount = stageCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV & setPStages( const PipelineShaderStageCreateInfo * pStages_ ) & VULKAN_HPP_NOEXCEPT - { - pStages = pStages_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV && setPStages( const PipelineShaderStageCreateInfo * pStages_ ) && VULKAN_HPP_NOEXCEPT - { - pStages = pStages_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GraphicsShaderGroupCreateInfoNV & setStages( ArrayProxyNoTemporaries const & stages_ ) VULKAN_HPP_NOEXCEPT - { - stageCount = static_cast( stages_.size() ); - pStages = stages_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV & setPVertexInputState( const PipelineVertexInputStateCreateInfo * pVertexInputState_ ) & - VULKAN_HPP_NOEXCEPT - { - pVertexInputState = pVertexInputState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV && setPVertexInputState( const PipelineVertexInputStateCreateInfo * pVertexInputState_ ) && - VULKAN_HPP_NOEXCEPT - { - pVertexInputState = pVertexInputState_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV & setPTessellationState( const PipelineTessellationStateCreateInfo * pTessellationState_ ) & - VULKAN_HPP_NOEXCEPT - { - pTessellationState = pTessellationState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsShaderGroupCreateInfoNV && setPTessellationState( const PipelineTessellationStateCreateInfo * pTessellationState_ ) && - VULKAN_HPP_NOEXCEPT - { - pTessellationState = pTessellationState_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGraphicsShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGraphicsShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGraphicsShaderGroupCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGraphicsShaderGroupCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stageCount, pStages, pVertexInputState, pTessellationState ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GraphicsShaderGroupCreateInfoNV const & ) const = default; -#else - bool operator==( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && - ( pVertexInputState == rhs.pVertexInputState ) && ( pTessellationState == rhs.pTessellationState ); -# endif - } - - bool operator!=( GraphicsShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGraphicsShaderGroupCreateInfoNV; - const void * pNext = {}; - uint32_t stageCount = {}; - const PipelineShaderStageCreateInfo * pStages = {}; - const PipelineVertexInputStateCreateInfo * pVertexInputState = {}; - const PipelineTessellationStateCreateInfo * pTessellationState = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GraphicsShaderGroupCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = GraphicsShaderGroupCreateInfoNV; - }; - - // wrapper struct for struct VkGraphicsPipelineShaderGroupsCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkGraphicsPipelineShaderGroupsCreateInfoNV.html - struct GraphicsPipelineShaderGroupsCreateInfoNV - { - using NativeType = VkGraphicsPipelineShaderGroupsCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR GraphicsPipelineShaderGroupsCreateInfoNV( uint32_t groupCount_ = {}, - const GraphicsShaderGroupCreateInfoNV * pGroups_ = {}, - uint32_t pipelineCount_ = {}, - const Pipeline * pPipelines_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , groupCount{ groupCount_ } - , pGroups{ pGroups_ } - , pipelineCount{ pipelineCount_ } - , pPipelines{ pPipelines_ } - { - } - - VULKAN_HPP_CONSTEXPR GraphicsPipelineShaderGroupsCreateInfoNV( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - GraphicsPipelineShaderGroupsCreateInfoNV( VkGraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : GraphicsPipelineShaderGroupsCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GraphicsPipelineShaderGroupsCreateInfoNV( ArrayProxyNoTemporaries const & groups_, - ArrayProxyNoTemporaries const & pipelines_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , groupCount( static_cast( groups_.size() ) ) - , pGroups( groups_.data() ) - , pipelineCount( static_cast( pipelines_.size() ) ) - , pPipelines( pipelines_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - GraphicsPipelineShaderGroupsCreateInfoNV & operator=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - GraphicsPipelineShaderGroupsCreateInfoNV & operator=( VkGraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV & setGroupCount( uint32_t groupCount_ ) & VULKAN_HPP_NOEXCEPT - { - groupCount = groupCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV && setGroupCount( uint32_t groupCount_ ) && VULKAN_HPP_NOEXCEPT - { - groupCount = groupCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV & setPGroups( const GraphicsShaderGroupCreateInfoNV * pGroups_ ) & VULKAN_HPP_NOEXCEPT - { - pGroups = pGroups_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV && setPGroups( const GraphicsShaderGroupCreateInfoNV * pGroups_ ) && VULKAN_HPP_NOEXCEPT - { - pGroups = pGroups_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GraphicsPipelineShaderGroupsCreateInfoNV & setGroups( ArrayProxyNoTemporaries const & groups_ ) VULKAN_HPP_NOEXCEPT - { - groupCount = static_cast( groups_.size() ); - pGroups = groups_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV & setPipelineCount( uint32_t pipelineCount_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineCount = pipelineCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV && setPipelineCount( uint32_t pipelineCount_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineCount = pipelineCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV & setPPipelines( const Pipeline * pPipelines_ ) & VULKAN_HPP_NOEXCEPT - { - pPipelines = pPipelines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 GraphicsPipelineShaderGroupsCreateInfoNV && setPPipelines( const Pipeline * pPipelines_ ) && VULKAN_HPP_NOEXCEPT - { - pPipelines = pPipelines_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - GraphicsPipelineShaderGroupsCreateInfoNV & setPipelines( ArrayProxyNoTemporaries const & pipelines_ ) VULKAN_HPP_NOEXCEPT - { - pipelineCount = static_cast( pipelines_.size() ); - pPipelines = pipelines_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkGraphicsPipelineShaderGroupsCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGraphicsPipelineShaderGroupsCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkGraphicsPipelineShaderGroupsCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkGraphicsPipelineShaderGroupsCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, groupCount, pGroups, pipelineCount, pPipelines ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( GraphicsPipelineShaderGroupsCreateInfoNV const & ) const = default; -#else - bool operator==( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( groupCount == rhs.groupCount ) && ( pGroups == rhs.pGroups ) && - ( pipelineCount == rhs.pipelineCount ) && ( pPipelines == rhs.pPipelines ); -# endif - } - - bool operator!=( GraphicsPipelineShaderGroupsCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV; - const void * pNext = {}; - uint32_t groupCount = {}; - const GraphicsShaderGroupCreateInfoNV * pGroups = {}; - uint32_t pipelineCount = {}; - const Pipeline * pPipelines = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = GraphicsPipelineShaderGroupsCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = GraphicsPipelineShaderGroupsCreateInfoNV; - }; - - // wrapper struct for struct VkXYColorEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXYColorEXT.html - struct XYColorEXT - { - using NativeType = VkXYColorEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR XYColorEXT( float x_ = {}, float y_ = {} ) VULKAN_HPP_NOEXCEPT - : x{ x_ } - , y{ y_ } - { - } - - VULKAN_HPP_CONSTEXPR XYColorEXT( XYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - XYColorEXT( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT : XYColorEXT( *reinterpret_cast( &rhs ) ) {} - - XYColorEXT & operator=( XYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - XYColorEXT & operator=( VkXYColorEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 XYColorEXT & setX( float x_ ) & VULKAN_HPP_NOEXCEPT - { - x = x_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 XYColorEXT && setX( float x_ ) && VULKAN_HPP_NOEXCEPT - { - x = x_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 XYColorEXT & setY( float y_ ) & VULKAN_HPP_NOEXCEPT - { - y = y_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 XYColorEXT && setY( float y_ ) && VULKAN_HPP_NOEXCEPT - { - y = y_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkXYColorEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkXYColorEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkXYColorEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkXYColorEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( x, y ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( XYColorEXT const & ) const = default; -#else - bool operator==( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( x == rhs.x ) && ( y == rhs.y ); -# endif - } - - bool operator!=( XYColorEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - float x = {}; - float y = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = XYColorEXT; - }; -#endif - - // wrapper struct for struct VkHdrMetadataEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHdrMetadataEXT.html - struct HdrMetadataEXT - { - using NativeType = VkHdrMetadataEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHdrMetadataEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR HdrMetadataEXT( XYColorEXT displayPrimaryRed_ = {}, - XYColorEXT displayPrimaryGreen_ = {}, - XYColorEXT displayPrimaryBlue_ = {}, - XYColorEXT whitePoint_ = {}, - float maxLuminance_ = {}, - float minLuminance_ = {}, - float maxContentLightLevel_ = {}, - float maxFrameAverageLightLevel_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , displayPrimaryRed{ displayPrimaryRed_ } - , displayPrimaryGreen{ displayPrimaryGreen_ } - , displayPrimaryBlue{ displayPrimaryBlue_ } - , whitePoint{ whitePoint_ } - , maxLuminance{ maxLuminance_ } - , minLuminance{ minLuminance_ } - , maxContentLightLevel{ maxContentLightLevel_ } - , maxFrameAverageLightLevel{ maxFrameAverageLightLevel_ } - { - } - - VULKAN_HPP_CONSTEXPR HdrMetadataEXT( HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - HdrMetadataEXT( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT : HdrMetadataEXT( *reinterpret_cast( &rhs ) ) {} - - HdrMetadataEXT & operator=( HdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - HdrMetadataEXT & operator=( VkHdrMetadataEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setDisplayPrimaryRed( XYColorEXT const & displayPrimaryRed_ ) & VULKAN_HPP_NOEXCEPT - { - displayPrimaryRed = displayPrimaryRed_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setDisplayPrimaryRed( XYColorEXT const & displayPrimaryRed_ ) && VULKAN_HPP_NOEXCEPT - { - displayPrimaryRed = displayPrimaryRed_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setDisplayPrimaryGreen( XYColorEXT const & displayPrimaryGreen_ ) & VULKAN_HPP_NOEXCEPT - { - displayPrimaryGreen = displayPrimaryGreen_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setDisplayPrimaryGreen( XYColorEXT const & displayPrimaryGreen_ ) && VULKAN_HPP_NOEXCEPT - { - displayPrimaryGreen = displayPrimaryGreen_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setDisplayPrimaryBlue( XYColorEXT const & displayPrimaryBlue_ ) & VULKAN_HPP_NOEXCEPT - { - displayPrimaryBlue = displayPrimaryBlue_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setDisplayPrimaryBlue( XYColorEXT const & displayPrimaryBlue_ ) && VULKAN_HPP_NOEXCEPT - { - displayPrimaryBlue = displayPrimaryBlue_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setWhitePoint( XYColorEXT const & whitePoint_ ) & VULKAN_HPP_NOEXCEPT - { - whitePoint = whitePoint_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setWhitePoint( XYColorEXT const & whitePoint_ ) && VULKAN_HPP_NOEXCEPT - { - whitePoint = whitePoint_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setMaxLuminance( float maxLuminance_ ) & VULKAN_HPP_NOEXCEPT - { - maxLuminance = maxLuminance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setMaxLuminance( float maxLuminance_ ) && VULKAN_HPP_NOEXCEPT - { - maxLuminance = maxLuminance_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setMinLuminance( float minLuminance_ ) & VULKAN_HPP_NOEXCEPT - { - minLuminance = minLuminance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setMinLuminance( float minLuminance_ ) && VULKAN_HPP_NOEXCEPT - { - minLuminance = minLuminance_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setMaxContentLightLevel( float maxContentLightLevel_ ) & VULKAN_HPP_NOEXCEPT - { - maxContentLightLevel = maxContentLightLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setMaxContentLightLevel( float maxContentLightLevel_ ) && VULKAN_HPP_NOEXCEPT - { - maxContentLightLevel = maxContentLightLevel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT & setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ ) & VULKAN_HPP_NOEXCEPT - { - maxFrameAverageLightLevel = maxFrameAverageLightLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrMetadataEXT && setMaxFrameAverageLightLevel( float maxFrameAverageLightLevel_ ) && VULKAN_HPP_NOEXCEPT - { - maxFrameAverageLightLevel = maxFrameAverageLightLevel_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkHdrMetadataEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHdrMetadataEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHdrMetadataEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkHdrMetadataEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - displayPrimaryRed, - displayPrimaryGreen, - displayPrimaryBlue, - whitePoint, - maxLuminance, - minLuminance, - maxContentLightLevel, - maxFrameAverageLightLevel ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( HdrMetadataEXT const & ) const = default; -#else - bool operator==( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displayPrimaryRed == rhs.displayPrimaryRed ) && - ( displayPrimaryGreen == rhs.displayPrimaryGreen ) && ( displayPrimaryBlue == rhs.displayPrimaryBlue ) && ( whitePoint == rhs.whitePoint ) && - ( maxLuminance == rhs.maxLuminance ) && ( minLuminance == rhs.minLuminance ) && ( maxContentLightLevel == rhs.maxContentLightLevel ) && - ( maxFrameAverageLightLevel == rhs.maxFrameAverageLightLevel ); -# endif - } - - bool operator!=( HdrMetadataEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eHdrMetadataEXT; - const void * pNext = {}; - XYColorEXT displayPrimaryRed = {}; - XYColorEXT displayPrimaryGreen = {}; - XYColorEXT displayPrimaryBlue = {}; - XYColorEXT whitePoint = {}; - float maxLuminance = {}; - float minLuminance = {}; - float maxContentLightLevel = {}; - float maxFrameAverageLightLevel = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = HdrMetadataEXT; - }; -#endif - - template <> - struct CppType - { - using Type = HdrMetadataEXT; - }; - - // wrapper struct for struct VkHdrVividDynamicMetadataHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkHdrVividDynamicMetadataHUAWEI.html - struct HdrVividDynamicMetadataHUAWEI - { - using NativeType = VkHdrVividDynamicMetadataHUAWEI; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHdrVividDynamicMetadataHUAWEI; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - HdrVividDynamicMetadataHUAWEI( size_t dynamicMetadataSize_ = {}, const void * pDynamicMetadata_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dynamicMetadataSize{ dynamicMetadataSize_ } - , pDynamicMetadata{ pDynamicMetadata_ } - { - } - - VULKAN_HPP_CONSTEXPR HdrVividDynamicMetadataHUAWEI( HdrVividDynamicMetadataHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - HdrVividDynamicMetadataHUAWEI( VkHdrVividDynamicMetadataHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - : HdrVividDynamicMetadataHUAWEI( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - HdrVividDynamicMetadataHUAWEI( ArrayProxyNoTemporaries const & dynamicMetadata_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), dynamicMetadataSize( dynamicMetadata_.size() * sizeof( T ) ), pDynamicMetadata( dynamicMetadata_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - HdrVividDynamicMetadataHUAWEI & operator=( HdrVividDynamicMetadataHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - HdrVividDynamicMetadataHUAWEI & operator=( VkHdrVividDynamicMetadataHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI & setDynamicMetadataSize( size_t dynamicMetadataSize_ ) & VULKAN_HPP_NOEXCEPT - { - dynamicMetadataSize = dynamicMetadataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI && setDynamicMetadataSize( size_t dynamicMetadataSize_ ) && VULKAN_HPP_NOEXCEPT - { - dynamicMetadataSize = dynamicMetadataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI & setPDynamicMetadata( const void * pDynamicMetadata_ ) & VULKAN_HPP_NOEXCEPT - { - pDynamicMetadata = pDynamicMetadata_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HdrVividDynamicMetadataHUAWEI && setPDynamicMetadata( const void * pDynamicMetadata_ ) && VULKAN_HPP_NOEXCEPT - { - pDynamicMetadata = pDynamicMetadata_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - HdrVividDynamicMetadataHUAWEI & setDynamicMetadata( ArrayProxyNoTemporaries const & dynamicMetadata_ ) VULKAN_HPP_NOEXCEPT - { - dynamicMetadataSize = dynamicMetadata_.size() * sizeof( T ); - pDynamicMetadata = dynamicMetadata_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkHdrVividDynamicMetadataHUAWEI const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHdrVividDynamicMetadataHUAWEI &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHdrVividDynamicMetadataHUAWEI const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkHdrVividDynamicMetadataHUAWEI *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dynamicMetadataSize, pDynamicMetadata ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( HdrVividDynamicMetadataHUAWEI const & ) const = default; -#else - bool operator==( HdrVividDynamicMetadataHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicMetadataSize == rhs.dynamicMetadataSize ) && - ( pDynamicMetadata == rhs.pDynamicMetadata ); -# endif - } - - bool operator!=( HdrVividDynamicMetadataHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eHdrVividDynamicMetadataHUAWEI; - const void * pNext = {}; - size_t dynamicMetadataSize = {}; - const void * pDynamicMetadata = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = HdrVividDynamicMetadataHUAWEI; - }; -#endif - - template <> - struct CppType - { - using Type = HdrVividDynamicMetadataHUAWEI; - }; - - // wrapper struct for struct VkHeadlessSurfaceCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHeadlessSurfaceCreateInfoEXT.html - struct HeadlessSurfaceCreateInfoEXT - { - using NativeType = VkHeadlessSurfaceCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHeadlessSurfaceCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( HeadlessSurfaceCreateFlagsEXT flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR HeadlessSurfaceCreateInfoEXT( HeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - HeadlessSurfaceCreateInfoEXT( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : HeadlessSurfaceCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - HeadlessSurfaceCreateInfoEXT & operator=( HeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - HeadlessSurfaceCreateInfoEXT & operator=( VkHeadlessSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 HeadlessSurfaceCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HeadlessSurfaceCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HeadlessSurfaceCreateInfoEXT & setFlags( HeadlessSurfaceCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HeadlessSurfaceCreateInfoEXT && setFlags( HeadlessSurfaceCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkHeadlessSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHeadlessSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHeadlessSurfaceCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkHeadlessSurfaceCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( HeadlessSurfaceCreateInfoEXT const & ) const = default; -#else - bool operator==( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( HeadlessSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eHeadlessSurfaceCreateInfoEXT; - const void * pNext = {}; - HeadlessSurfaceCreateFlagsEXT flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = HeadlessSurfaceCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = HeadlessSurfaceCreateInfoEXT; - }; - - // wrapper struct for struct VkHostAddressRangeConstEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostAddressRangeConstEXT.html - struct HostAddressRangeConstEXT - { - using NativeType = VkHostAddressRangeConstEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR HostAddressRangeConstEXT( const void * address_ = {}, size_t size_ = {} ) VULKAN_HPP_NOEXCEPT - : address{ address_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR HostAddressRangeConstEXT( HostAddressRangeConstEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - HostAddressRangeConstEXT( VkHostAddressRangeConstEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : HostAddressRangeConstEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - HostAddressRangeConstEXT( ArrayProxyNoTemporaries const & address_ ) : address( address_.data() ), size( address_.size() * sizeof( T ) ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - HostAddressRangeConstEXT & operator=( HostAddressRangeConstEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - HostAddressRangeConstEXT & operator=( VkHostAddressRangeConstEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 HostAddressRangeConstEXT & setAddress( const void * address_ ) & VULKAN_HPP_NOEXCEPT - { - address = address_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HostAddressRangeConstEXT && setAddress( const void * address_ ) && VULKAN_HPP_NOEXCEPT - { - address = address_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - HostAddressRangeConstEXT & setAddress( ArrayProxyNoTemporaries const & address_ ) VULKAN_HPP_NOEXCEPT - { - size = address_.size() * sizeof( T ); - address = address_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 HostAddressRangeConstEXT & setSize( size_t size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HostAddressRangeConstEXT && setSize( size_t size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkHostAddressRangeConstEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHostAddressRangeConstEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHostAddressRangeConstEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkHostAddressRangeConstEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( address, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( HostAddressRangeConstEXT const & ) const = default; -#else - bool operator==( HostAddressRangeConstEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( address == rhs.address ) && ( size == rhs.size ); -# endif - } - - bool operator!=( HostAddressRangeConstEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - const void * address = {}; - size_t size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = HostAddressRangeConstEXT; - }; -#endif - - // wrapper struct for struct VkHostAddressRangeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostAddressRangeEXT.html - struct HostAddressRangeEXT - { - using NativeType = VkHostAddressRangeEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR HostAddressRangeEXT( void * address_ = {}, size_t size_ = {} ) VULKAN_HPP_NOEXCEPT - : address{ address_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR HostAddressRangeEXT( HostAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - HostAddressRangeEXT( VkHostAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT : HostAddressRangeEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - HostAddressRangeEXT( ArrayProxyNoTemporaries const & address_ ) : address( address_.data() ), size( address_.size() * sizeof( T ) ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - HostAddressRangeEXT & operator=( HostAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - HostAddressRangeEXT & operator=( VkHostAddressRangeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 HostAddressRangeEXT & setAddress( void * address_ ) & VULKAN_HPP_NOEXCEPT - { - address = address_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HostAddressRangeEXT && setAddress( void * address_ ) && VULKAN_HPP_NOEXCEPT - { - address = address_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - HostAddressRangeEXT & setAddress( ArrayProxyNoTemporaries const & address_ ) VULKAN_HPP_NOEXCEPT - { - size = address_.size() * sizeof( T ); - address = address_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 HostAddressRangeEXT & setSize( size_t size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HostAddressRangeEXT && setSize( size_t size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkHostAddressRangeEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHostAddressRangeEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHostAddressRangeEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkHostAddressRangeEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( address, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( HostAddressRangeEXT const & ) const = default; -#else - bool operator==( HostAddressRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( address == rhs.address ) && ( size == rhs.size ); -# endif - } - - bool operator!=( HostAddressRangeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - void * address = {}; - size_t size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = HostAddressRangeEXT; - }; -#endif - - // wrapper struct for struct VkHostImageCopyDevicePerformanceQuery, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostImageCopyDevicePerformanceQuery.html - struct HostImageCopyDevicePerformanceQuery - { - using NativeType = VkHostImageCopyDevicePerformanceQuery; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHostImageCopyDevicePerformanceQuery; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - HostImageCopyDevicePerformanceQuery( Bool32 optimalDeviceAccess_ = {}, Bool32 identicalMemoryLayout_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , optimalDeviceAccess{ optimalDeviceAccess_ } - , identicalMemoryLayout{ identicalMemoryLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR HostImageCopyDevicePerformanceQuery( HostImageCopyDevicePerformanceQuery const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - HostImageCopyDevicePerformanceQuery( VkHostImageCopyDevicePerformanceQuery const & rhs ) VULKAN_HPP_NOEXCEPT - : HostImageCopyDevicePerformanceQuery( *reinterpret_cast( &rhs ) ) - { - } - - HostImageCopyDevicePerformanceQuery & operator=( HostImageCopyDevicePerformanceQuery const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - HostImageCopyDevicePerformanceQuery & operator=( VkHostImageCopyDevicePerformanceQuery const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkHostImageCopyDevicePerformanceQuery const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHostImageCopyDevicePerformanceQuery &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHostImageCopyDevicePerformanceQuery const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkHostImageCopyDevicePerformanceQuery *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, optimalDeviceAccess, identicalMemoryLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( HostImageCopyDevicePerformanceQuery const & ) const = default; -#else - bool operator==( HostImageCopyDevicePerformanceQuery const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( optimalDeviceAccess == rhs.optimalDeviceAccess ) && - ( identicalMemoryLayout == rhs.identicalMemoryLayout ); -# endif - } - - bool operator!=( HostImageCopyDevicePerformanceQuery const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eHostImageCopyDevicePerformanceQuery; - void * pNext = {}; - Bool32 optimalDeviceAccess = {}; - Bool32 identicalMemoryLayout = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = HostImageCopyDevicePerformanceQuery; - }; -#endif - - template <> - struct CppType - { - using Type = HostImageCopyDevicePerformanceQuery; - }; - - using HostImageCopyDevicePerformanceQueryEXT = HostImageCopyDevicePerformanceQuery; - - // wrapper struct for struct VkHostImageLayoutTransitionInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkHostImageLayoutTransitionInfo.html - struct HostImageLayoutTransitionInfo - { - using NativeType = VkHostImageLayoutTransitionInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eHostImageLayoutTransitionInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR HostImageLayoutTransitionInfo( Image image_ = {}, - ImageLayout oldLayout_ = ImageLayout::eUndefined, - ImageLayout newLayout_ = ImageLayout::eUndefined, - ImageSubresourceRange subresourceRange_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , image{ image_ } - , oldLayout{ oldLayout_ } - , newLayout{ newLayout_ } - , subresourceRange{ subresourceRange_ } - { - } - - VULKAN_HPP_CONSTEXPR HostImageLayoutTransitionInfo( HostImageLayoutTransitionInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - HostImageLayoutTransitionInfo( VkHostImageLayoutTransitionInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : HostImageLayoutTransitionInfo( *reinterpret_cast( &rhs ) ) - { - } - - HostImageLayoutTransitionInfo & operator=( HostImageLayoutTransitionInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - HostImageLayoutTransitionInfo & operator=( VkHostImageLayoutTransitionInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo & setOldLayout( ImageLayout oldLayout_ ) & VULKAN_HPP_NOEXCEPT - { - oldLayout = oldLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo && setOldLayout( ImageLayout oldLayout_ ) && VULKAN_HPP_NOEXCEPT - { - oldLayout = oldLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo & setNewLayout( ImageLayout newLayout_ ) & VULKAN_HPP_NOEXCEPT - { - newLayout = newLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo && setNewLayout( ImageLayout newLayout_ ) && VULKAN_HPP_NOEXCEPT - { - newLayout = newLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo & setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) & VULKAN_HPP_NOEXCEPT - { - subresourceRange = subresourceRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 HostImageLayoutTransitionInfo && setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) && VULKAN_HPP_NOEXCEPT - { - subresourceRange = subresourceRange_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkHostImageLayoutTransitionInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHostImageLayoutTransitionInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkHostImageLayoutTransitionInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkHostImageLayoutTransitionInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, image, oldLayout, newLayout, subresourceRange ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( HostImageLayoutTransitionInfo const & ) const = default; -#else - bool operator==( HostImageLayoutTransitionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( oldLayout == rhs.oldLayout ) && ( newLayout == rhs.newLayout ) && - ( subresourceRange == rhs.subresourceRange ); -# endif - } - - bool operator!=( HostImageLayoutTransitionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eHostImageLayoutTransitionInfo; - const void * pNext = {}; - Image image = {}; - ImageLayout oldLayout = ImageLayout::eUndefined; - ImageLayout newLayout = ImageLayout::eUndefined; - ImageSubresourceRange subresourceRange = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = HostImageLayoutTransitionInfo; - }; -#endif - - template <> - struct CppType - { - using Type = HostImageLayoutTransitionInfo; - }; - - using HostImageLayoutTransitionInfoEXT = HostImageLayoutTransitionInfo; - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - // wrapper struct for struct VkIOSSurfaceCreateInfoMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkIOSSurfaceCreateInfoMVK.html - struct IOSSurfaceCreateInfoMVK - { - using NativeType = VkIOSSurfaceCreateInfoMVK; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIosSurfaceCreateInfoMVK; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - IOSSurfaceCreateInfoMVK( IOSSurfaceCreateFlagsMVK flags_ = {}, const void * pView_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pView{ pView_ } - { - } - - VULKAN_HPP_CONSTEXPR IOSSurfaceCreateInfoMVK( IOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IOSSurfaceCreateInfoMVK( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - : IOSSurfaceCreateInfoMVK( *reinterpret_cast( &rhs ) ) - { - } - - IOSSurfaceCreateInfoMVK & operator=( IOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IOSSurfaceCreateInfoMVK & operator=( VkIOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK & setFlags( IOSSurfaceCreateFlagsMVK flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK && setFlags( IOSSurfaceCreateFlagsMVK flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK & setPView( const void * pView_ ) & VULKAN_HPP_NOEXCEPT - { - pView = pView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IOSSurfaceCreateInfoMVK && setPView( const void * pView_ ) && VULKAN_HPP_NOEXCEPT - { - pView = pView_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIOSSurfaceCreateInfoMVK const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIOSSurfaceCreateInfoMVK *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, pView ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IOSSurfaceCreateInfoMVK const & ) const = default; -# else - bool operator==( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView ); -# endif - } - - bool operator!=( IOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eIosSurfaceCreateInfoMVK; - const void * pNext = {}; - IOSSurfaceCreateFlagsMVK flags = {}; - const void * pView = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IOSSurfaceCreateInfoMVK; - }; -# endif - - template <> - struct CppType - { - using Type = IOSSurfaceCreateInfoMVK; - }; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - - // wrapper struct for struct VkImageAlignmentControlCreateInfoMESA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageAlignmentControlCreateInfoMESA.html - struct ImageAlignmentControlCreateInfoMESA - { - using NativeType = VkImageAlignmentControlCreateInfoMESA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageAlignmentControlCreateInfoMESA; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageAlignmentControlCreateInfoMESA( uint32_t maximumRequestedAlignment_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maximumRequestedAlignment{ maximumRequestedAlignment_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageAlignmentControlCreateInfoMESA( ImageAlignmentControlCreateInfoMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageAlignmentControlCreateInfoMESA( VkImageAlignmentControlCreateInfoMESA const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageAlignmentControlCreateInfoMESA( *reinterpret_cast( &rhs ) ) - { - } - - ImageAlignmentControlCreateInfoMESA & operator=( ImageAlignmentControlCreateInfoMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageAlignmentControlCreateInfoMESA & operator=( VkImageAlignmentControlCreateInfoMESA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageAlignmentControlCreateInfoMESA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageAlignmentControlCreateInfoMESA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageAlignmentControlCreateInfoMESA & setMaximumRequestedAlignment( uint32_t maximumRequestedAlignment_ ) & VULKAN_HPP_NOEXCEPT - { - maximumRequestedAlignment = maximumRequestedAlignment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageAlignmentControlCreateInfoMESA && setMaximumRequestedAlignment( uint32_t maximumRequestedAlignment_ ) && VULKAN_HPP_NOEXCEPT - { - maximumRequestedAlignment = maximumRequestedAlignment_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageAlignmentControlCreateInfoMESA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageAlignmentControlCreateInfoMESA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageAlignmentControlCreateInfoMESA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageAlignmentControlCreateInfoMESA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maximumRequestedAlignment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageAlignmentControlCreateInfoMESA const & ) const = default; -#else - bool operator==( ImageAlignmentControlCreateInfoMESA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maximumRequestedAlignment == rhs.maximumRequestedAlignment ); -# endif - } - - bool operator!=( ImageAlignmentControlCreateInfoMESA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageAlignmentControlCreateInfoMESA; - const void * pNext = {}; - uint32_t maximumRequestedAlignment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageAlignmentControlCreateInfoMESA; - }; -#endif - - template <> - struct CppType - { - using Type = ImageAlignmentControlCreateInfoMESA; - }; - - // wrapper struct for struct VkImageBlit, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageBlit.html - struct ImageBlit - { - using NativeType = VkImageBlit; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 ImageBlit( ImageSubresourceLayers srcSubresource_ = {}, - std::array const & srcOffsets_ = {}, - ImageSubresourceLayers dstSubresource_ = {}, - std::array const & dstOffsets_ = {} ) VULKAN_HPP_NOEXCEPT - : srcSubresource{ srcSubresource_ } - , srcOffsets{ srcOffsets_ } - , dstSubresource{ dstSubresource_ } - , dstOffsets{ dstOffsets_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit( ImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageBlit( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT : ImageBlit( *reinterpret_cast( &rhs ) ) {} - - ImageBlit & operator=( ImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageBlit & operator=( VkImageBlit const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageBlit & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit & setSrcOffsets( std::array const & srcOffsets_ ) & VULKAN_HPP_NOEXCEPT - { - srcOffsets = srcOffsets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit && setSrcOffsets( std::array const & srcOffsets_ ) && VULKAN_HPP_NOEXCEPT - { - srcOffsets = srcOffsets_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit & setDstOffsets( std::array const & dstOffsets_ ) & VULKAN_HPP_NOEXCEPT - { - dstOffsets = dstOffsets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageBlit && setDstOffsets( std::array const & dstOffsets_ ) && VULKAN_HPP_NOEXCEPT - { - dstOffsets = dstOffsets_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageBlit const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageBlit &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageBlit const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageBlit *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, ImageSubresourceLayers const &, ArrayWrapper1D const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( srcSubresource, srcOffsets, dstSubresource, dstOffsets ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageBlit const & ) const = default; -#else - bool operator==( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( srcSubresource == rhs.srcSubresource ) && ( srcOffsets == rhs.srcOffsets ) && ( dstSubresource == rhs.dstSubresource ) && - ( dstOffsets == rhs.dstOffsets ); -# endif - } - - bool operator!=( ImageBlit const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ImageSubresourceLayers srcSubresource = {}; - ArrayWrapper1D srcOffsets = {}; - ImageSubresourceLayers dstSubresource = {}; - ArrayWrapper1D dstOffsets = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageBlit; - }; -#endif - - // wrapper struct for struct VkImageCaptureDescriptorDataInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCaptureDescriptorDataInfoEXT.html - struct ImageCaptureDescriptorDataInfoEXT - { - using NativeType = VkImageCaptureDescriptorDataInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCaptureDescriptorDataInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageCaptureDescriptorDataInfoEXT( Image image_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , image{ image_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageCaptureDescriptorDataInfoEXT( ImageCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageCaptureDescriptorDataInfoEXT( VkImageCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageCaptureDescriptorDataInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImageCaptureDescriptorDataInfoEXT & operator=( ImageCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageCaptureDescriptorDataInfoEXT & operator=( VkImageCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageCaptureDescriptorDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCaptureDescriptorDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCaptureDescriptorDataInfoEXT & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCaptureDescriptorDataInfoEXT && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, image ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageCaptureDescriptorDataInfoEXT const & ) const = default; -#else - bool operator==( ImageCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); -# endif - } - - bool operator!=( ImageCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageCaptureDescriptorDataInfoEXT; - const void * pNext = {}; - Image image = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageCaptureDescriptorDataInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImageCaptureDescriptorDataInfoEXT; - }; - - // wrapper struct for struct VkImageCompressionControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionControlEXT.html - struct ImageCompressionControlEXT - { - using NativeType = VkImageCompressionControlEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCompressionControlEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageCompressionControlEXT( ImageCompressionFlagsEXT flags_ = {}, - uint32_t compressionControlPlaneCount_ = {}, - ImageCompressionFixedRateFlagsEXT * pFixedRateFlags_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , compressionControlPlaneCount{ compressionControlPlaneCount_ } - , pFixedRateFlags{ pFixedRateFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageCompressionControlEXT( ImageCompressionControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageCompressionControlEXT( VkImageCompressionControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageCompressionControlEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageCompressionControlEXT( ImageCompressionFlagsEXT flags_, - ArrayProxyNoTemporaries const & fixedRateFlags_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , compressionControlPlaneCount( static_cast( fixedRateFlags_.size() ) ) - , pFixedRateFlags( fixedRateFlags_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ImageCompressionControlEXT & operator=( ImageCompressionControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageCompressionControlEXT & operator=( VkImageCompressionControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT & setFlags( ImageCompressionFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT && setFlags( ImageCompressionFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT & setCompressionControlPlaneCount( uint32_t compressionControlPlaneCount_ ) & VULKAN_HPP_NOEXCEPT - { - compressionControlPlaneCount = compressionControlPlaneCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT && setCompressionControlPlaneCount( uint32_t compressionControlPlaneCount_ ) && VULKAN_HPP_NOEXCEPT - { - compressionControlPlaneCount = compressionControlPlaneCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT & setPFixedRateFlags( ImageCompressionFixedRateFlagsEXT * pFixedRateFlags_ ) & VULKAN_HPP_NOEXCEPT - { - pFixedRateFlags = pFixedRateFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCompressionControlEXT && setPFixedRateFlags( ImageCompressionFixedRateFlagsEXT * pFixedRateFlags_ ) && VULKAN_HPP_NOEXCEPT - { - pFixedRateFlags = pFixedRateFlags_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageCompressionControlEXT & setFixedRateFlags( ArrayProxyNoTemporaries const & fixedRateFlags_ ) VULKAN_HPP_NOEXCEPT - { - compressionControlPlaneCount = static_cast( fixedRateFlags_.size() ); - pFixedRateFlags = fixedRateFlags_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageCompressionControlEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCompressionControlEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCompressionControlEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageCompressionControlEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, compressionControlPlaneCount, pFixedRateFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageCompressionControlEXT const & ) const = default; -#else - bool operator==( ImageCompressionControlEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( compressionControlPlaneCount == rhs.compressionControlPlaneCount ) && ( pFixedRateFlags == rhs.pFixedRateFlags ); -# endif - } - - bool operator!=( ImageCompressionControlEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageCompressionControlEXT; - const void * pNext = {}; - ImageCompressionFlagsEXT flags = {}; - uint32_t compressionControlPlaneCount = {}; - ImageCompressionFixedRateFlagsEXT * pFixedRateFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageCompressionControlEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImageCompressionControlEXT; - }; - - // wrapper struct for struct VkImageCompressionPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCompressionPropertiesEXT.html - struct ImageCompressionPropertiesEXT - { - using NativeType = VkImageCompressionPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageCompressionPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageCompressionPropertiesEXT( ImageCompressionFlagsEXT imageCompressionFlags_ = {}, - ImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageCompressionFlags{ imageCompressionFlags_ } - , imageCompressionFixedRateFlags{ imageCompressionFixedRateFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageCompressionPropertiesEXT( ImageCompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageCompressionPropertiesEXT( VkImageCompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageCompressionPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImageCompressionPropertiesEXT & operator=( ImageCompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageCompressionPropertiesEXT & operator=( VkImageCompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkImageCompressionPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCompressionPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCompressionPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageCompressionPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageCompressionFlags, imageCompressionFixedRateFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageCompressionPropertiesEXT const & ) const = default; -#else - bool operator==( ImageCompressionPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCompressionFlags == rhs.imageCompressionFlags ) && - ( imageCompressionFixedRateFlags == rhs.imageCompressionFixedRateFlags ); -# endif - } - - bool operator!=( ImageCompressionPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageCompressionPropertiesEXT; - void * pNext = {}; - ImageCompressionFlagsEXT imageCompressionFlags = {}; - ImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageCompressionPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImageCompressionPropertiesEXT; - }; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkImageFormatConstraintsInfoFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatConstraintsInfoFUCHSIA.html - struct ImageFormatConstraintsInfoFUCHSIA - { - using NativeType = VkImageFormatConstraintsInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatConstraintsInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageFormatConstraintsInfoFUCHSIA( ImageCreateInfo imageCreateInfo_ = {}, - FormatFeatureFlags requiredFormatFeatures_ = {}, - ImageFormatConstraintsFlagsFUCHSIA flags_ = {}, - uint64_t sysmemPixelFormat_ = {}, - uint32_t colorSpaceCount_ = {}, - const SysmemColorSpaceFUCHSIA * pColorSpaces_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageCreateInfo{ imageCreateInfo_ } - , requiredFormatFeatures{ requiredFormatFeatures_ } - , flags{ flags_ } - , sysmemPixelFormat{ sysmemPixelFormat_ } - , colorSpaceCount{ colorSpaceCount_ } - , pColorSpaces{ pColorSpaces_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageFormatConstraintsInfoFUCHSIA( ImageFormatConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageFormatConstraintsInfoFUCHSIA( VkImageFormatConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageFormatConstraintsInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageFormatConstraintsInfoFUCHSIA( ImageCreateInfo imageCreateInfo_, - FormatFeatureFlags requiredFormatFeatures_, - ImageFormatConstraintsFlagsFUCHSIA flags_, - uint64_t sysmemPixelFormat_, - ArrayProxyNoTemporaries const & colorSpaces_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , imageCreateInfo( imageCreateInfo_ ) - , requiredFormatFeatures( requiredFormatFeatures_ ) - , flags( flags_ ) - , sysmemPixelFormat( sysmemPixelFormat_ ) - , colorSpaceCount( static_cast( colorSpaces_.size() ) ) - , pColorSpaces( colorSpaces_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ImageFormatConstraintsInfoFUCHSIA & operator=( ImageFormatConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageFormatConstraintsInfoFUCHSIA & operator=( VkImageFormatConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setImageCreateInfo( ImageCreateInfo const & imageCreateInfo_ ) & VULKAN_HPP_NOEXCEPT - { - imageCreateInfo = imageCreateInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setImageCreateInfo( ImageCreateInfo const & imageCreateInfo_ ) && VULKAN_HPP_NOEXCEPT - { - imageCreateInfo = imageCreateInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setRequiredFormatFeatures( FormatFeatureFlags requiredFormatFeatures_ ) & VULKAN_HPP_NOEXCEPT - { - requiredFormatFeatures = requiredFormatFeatures_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setRequiredFormatFeatures( FormatFeatureFlags requiredFormatFeatures_ ) && VULKAN_HPP_NOEXCEPT - { - requiredFormatFeatures = requiredFormatFeatures_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setFlags( ImageFormatConstraintsFlagsFUCHSIA flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setFlags( ImageFormatConstraintsFlagsFUCHSIA flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setSysmemPixelFormat( uint64_t sysmemPixelFormat_ ) & VULKAN_HPP_NOEXCEPT - { - sysmemPixelFormat = sysmemPixelFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setSysmemPixelFormat( uint64_t sysmemPixelFormat_ ) && VULKAN_HPP_NOEXCEPT - { - sysmemPixelFormat = sysmemPixelFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setColorSpaceCount( uint32_t colorSpaceCount_ ) & VULKAN_HPP_NOEXCEPT - { - colorSpaceCount = colorSpaceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setColorSpaceCount( uint32_t colorSpaceCount_ ) && VULKAN_HPP_NOEXCEPT - { - colorSpaceCount = colorSpaceCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA & setPColorSpaces( const SysmemColorSpaceFUCHSIA * pColorSpaces_ ) & VULKAN_HPP_NOEXCEPT - { - pColorSpaces = pColorSpaces_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatConstraintsInfoFUCHSIA && setPColorSpaces( const SysmemColorSpaceFUCHSIA * pColorSpaces_ ) && VULKAN_HPP_NOEXCEPT - { - pColorSpaces = pColorSpaces_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageFormatConstraintsInfoFUCHSIA & setColorSpaces( ArrayProxyNoTemporaries const & colorSpaces_ ) VULKAN_HPP_NOEXCEPT - { - colorSpaceCount = static_cast( colorSpaces_.size() ); - pColorSpaces = colorSpaces_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageFormatConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageFormatConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageFormatConstraintsInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageFormatConstraintsInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageCreateInfo, requiredFormatFeatures, flags, sysmemPixelFormat, colorSpaceCount, pColorSpaces ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageFormatConstraintsInfoFUCHSIA const & ) const = default; -# else - bool operator==( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCreateInfo == rhs.imageCreateInfo ) && - ( requiredFormatFeatures == rhs.requiredFormatFeatures ) && ( flags == rhs.flags ) && ( sysmemPixelFormat == rhs.sysmemPixelFormat ) && - ( colorSpaceCount == rhs.colorSpaceCount ) && ( pColorSpaces == rhs.pColorSpaces ); -# endif - } - - bool operator!=( ImageFormatConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImageFormatConstraintsInfoFUCHSIA; - const void * pNext = {}; - ImageCreateInfo imageCreateInfo = {}; - FormatFeatureFlags requiredFormatFeatures = {}; - ImageFormatConstraintsFlagsFUCHSIA flags = {}; - uint64_t sysmemPixelFormat = {}; - uint32_t colorSpaceCount = {}; - const SysmemColorSpaceFUCHSIA * pColorSpaces = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageFormatConstraintsInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = ImageFormatConstraintsInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkImageConstraintsInfoFUCHSIA, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageConstraintsInfoFUCHSIA.html - struct ImageConstraintsInfoFUCHSIA - { - using NativeType = VkImageConstraintsInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageConstraintsInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFUCHSIA( uint32_t formatConstraintsCount_ = {}, - const ImageFormatConstraintsInfoFUCHSIA * pFormatConstraints_ = {}, - BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints_ = {}, - ImageConstraintsInfoFlagsFUCHSIA flags_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , formatConstraintsCount{ formatConstraintsCount_ } - , pFormatConstraints{ pFormatConstraints_ } - , bufferCollectionConstraints{ bufferCollectionConstraints_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageConstraintsInfoFUCHSIA( ImageConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageConstraintsInfoFUCHSIA( VkImageConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageConstraintsInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageConstraintsInfoFUCHSIA( ArrayProxyNoTemporaries const & formatConstraints_, - BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints_ = {}, - ImageConstraintsInfoFlagsFUCHSIA flags_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , formatConstraintsCount( static_cast( formatConstraints_.size() ) ) - , pFormatConstraints( formatConstraints_.data() ) - , bufferCollectionConstraints( bufferCollectionConstraints_ ) - , flags( flags_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ImageConstraintsInfoFUCHSIA & operator=( ImageConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageConstraintsInfoFUCHSIA & operator=( VkImageConstraintsInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA & setFormatConstraintsCount( uint32_t formatConstraintsCount_ ) & VULKAN_HPP_NOEXCEPT - { - formatConstraintsCount = formatConstraintsCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA && setFormatConstraintsCount( uint32_t formatConstraintsCount_ ) && VULKAN_HPP_NOEXCEPT - { - formatConstraintsCount = formatConstraintsCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA & setPFormatConstraints( const ImageFormatConstraintsInfoFUCHSIA * pFormatConstraints_ ) & - VULKAN_HPP_NOEXCEPT - { - pFormatConstraints = pFormatConstraints_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA && setPFormatConstraints( const ImageFormatConstraintsInfoFUCHSIA * pFormatConstraints_ ) && - VULKAN_HPP_NOEXCEPT - { - pFormatConstraints = pFormatConstraints_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageConstraintsInfoFUCHSIA & - setFormatConstraints( ArrayProxyNoTemporaries const & formatConstraints_ ) VULKAN_HPP_NOEXCEPT - { - formatConstraintsCount = static_cast( formatConstraints_.size() ); - pFormatConstraints = formatConstraints_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA & - setBufferCollectionConstraints( BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraints_ ) & - VULKAN_HPP_NOEXCEPT - { - bufferCollectionConstraints = bufferCollectionConstraints_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA && - setBufferCollectionConstraints( BufferCollectionConstraintsInfoFUCHSIA const & bufferCollectionConstraints_ ) && - VULKAN_HPP_NOEXCEPT - { - bufferCollectionConstraints = bufferCollectionConstraints_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA & setFlags( ImageConstraintsInfoFlagsFUCHSIA flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageConstraintsInfoFUCHSIA && setFlags( ImageConstraintsInfoFlagsFUCHSIA flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageConstraintsInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageConstraintsInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageConstraintsInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageConstraintsInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, formatConstraintsCount, pFormatConstraints, bufferCollectionConstraints, flags ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageConstraintsInfoFUCHSIA const & ) const = default; -# else - bool operator==( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatConstraintsCount == rhs.formatConstraintsCount ) && - ( pFormatConstraints == rhs.pFormatConstraints ) && ( bufferCollectionConstraints == rhs.bufferCollectionConstraints ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( ImageConstraintsInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImageConstraintsInfoFUCHSIA; - const void * pNext = {}; - uint32_t formatConstraintsCount = {}; - const ImageFormatConstraintsInfoFUCHSIA * pFormatConstraints = {}; - BufferCollectionConstraintsInfoFUCHSIA bufferCollectionConstraints = {}; - ImageConstraintsInfoFlagsFUCHSIA flags = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageConstraintsInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = ImageConstraintsInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - // wrapper struct for struct VkImageCopy, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageCopy.html - struct ImageCopy - { - using NativeType = VkImageCopy; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageCopy( ImageSubresourceLayers srcSubresource_ = {}, - Offset3D srcOffset_ = {}, - ImageSubresourceLayers dstSubresource_ = {}, - Offset3D dstOffset_ = {}, - Extent3D extent_ = {} ) VULKAN_HPP_NOEXCEPT - : srcSubresource{ srcSubresource_ } - , srcOffset{ srcOffset_ } - , dstSubresource{ dstSubresource_ } - , dstOffset{ dstOffset_ } - , extent{ extent_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageCopy( ImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageCopy( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT : ImageCopy( *reinterpret_cast( &rhs ) ) {} - - ImageCopy & operator=( ImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageCopy & operator=( VkImageCopy const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageCopy & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy & setSrcOffset( Offset3D const & srcOffset_ ) & VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy && setSrcOffset( Offset3D const & srcOffset_ ) && VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy & setDstOffset( Offset3D const & dstOffset_ ) & VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy && setDstOffset( Offset3D const & dstOffset_ ) && VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageCopy && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageCopy const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCopy &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageCopy const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageCopy *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageCopy const & ) const = default; -#else - bool operator==( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) && - ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); -# endif - } - - bool operator!=( ImageCopy const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ImageSubresourceLayers srcSubresource = {}; - Offset3D srcOffset = {}; - ImageSubresourceLayers dstSubresource = {}; - Offset3D dstOffset = {}; - Extent3D extent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageCopy; - }; -#endif - - // wrapper struct for struct VkImageViewCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewCreateInfo.html - struct ImageViewCreateInfo - { - using NativeType = VkImageViewCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( ImageViewCreateFlags flags_ = {}, - Image image_ = {}, - ImageViewType viewType_ = ImageViewType::e1D, - Format format_ = Format::eUndefined, - ComponentMapping components_ = {}, - ImageSubresourceRange subresourceRange_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , image{ image_ } - , viewType{ viewType_ } - , format{ format_ } - , components{ components_ } - , subresourceRange{ subresourceRange_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageViewCreateInfo( ImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageViewCreateInfo( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : ImageViewCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - ImageViewCreateInfo & operator=( ImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageViewCreateInfo & operator=( VkImageViewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setFlags( ImageViewCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setFlags( ImageViewCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setViewType( ImageViewType viewType_ ) & VULKAN_HPP_NOEXCEPT - { - viewType = viewType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setViewType( ImageViewType viewType_ ) && VULKAN_HPP_NOEXCEPT - { - viewType = viewType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setComponents( ComponentMapping const & components_ ) & VULKAN_HPP_NOEXCEPT - { - components = components_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setComponents( ComponentMapping const & components_ ) && VULKAN_HPP_NOEXCEPT - { - components = components_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo & setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) & VULKAN_HPP_NOEXCEPT - { - subresourceRange = subresourceRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCreateInfo && setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) && VULKAN_HPP_NOEXCEPT - { - subresourceRange = subresourceRange_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageViewCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageViewCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, image, viewType, format, components, subresourceRange ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageViewCreateInfo const & ) const = default; -#else - bool operator==( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( image == rhs.image ) && ( viewType == rhs.viewType ) && - ( format == rhs.format ) && ( components == rhs.components ) && ( subresourceRange == rhs.subresourceRange ); -# endif - } - - bool operator!=( ImageViewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageViewCreateInfo; - const void * pNext = {}; - ImageViewCreateFlags flags = {}; - Image image = {}; - ImageViewType viewType = ImageViewType::e1D; - Format format = Format::eUndefined; - ComponentMapping components = {}; - ImageSubresourceRange subresourceRange = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageViewCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ImageViewCreateInfo; - }; - - // wrapper struct for struct VkImageDescriptorInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageDescriptorInfoEXT.html - struct ImageDescriptorInfoEXT - { - using NativeType = VkImageDescriptorInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDescriptorInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageDescriptorInfoEXT( const ImageViewCreateInfo * pView_ = {}, - ImageLayout layout_ = ImageLayout::eUndefined, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pView{ pView_ } - , layout{ layout_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageDescriptorInfoEXT( ImageDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageDescriptorInfoEXT( VkImageDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageDescriptorInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImageDescriptorInfoEXT & operator=( ImageDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageDescriptorInfoEXT & operator=( VkImageDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT & setPView( const ImageViewCreateInfo * pView_ ) & VULKAN_HPP_NOEXCEPT - { - pView = pView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT && setPView( const ImageViewCreateInfo * pView_ ) && VULKAN_HPP_NOEXCEPT - { - pView = pView_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT & setLayout( ImageLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageDescriptorInfoEXT && setLayout( ImageLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageDescriptorInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageDescriptorInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageDescriptorInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageDescriptorInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pView, layout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageDescriptorInfoEXT const & ) const = default; -#else - bool operator==( ImageDescriptorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pView == rhs.pView ) && ( layout == rhs.layout ); -# endif - } - - bool operator!=( ImageDescriptorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageDescriptorInfoEXT; - const void * pNext = {}; - const ImageViewCreateInfo * pView = {}; - ImageLayout layout = ImageLayout::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageDescriptorInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImageDescriptorInfoEXT; - }; - - // wrapper struct for struct VkSubresourceLayout, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubresourceLayout.html - struct SubresourceLayout - { - using NativeType = VkSubresourceLayout; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubresourceLayout( - DeviceSize offset_ = {}, DeviceSize size_ = {}, DeviceSize rowPitch_ = {}, DeviceSize arrayPitch_ = {}, DeviceSize depthPitch_ = {} ) VULKAN_HPP_NOEXCEPT - : offset{ offset_ } - , size{ size_ } - , rowPitch{ rowPitch_ } - , arrayPitch{ arrayPitch_ } - , depthPitch{ depthPitch_ } - { - } - - VULKAN_HPP_CONSTEXPR SubresourceLayout( SubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubresourceLayout( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT : SubresourceLayout( *reinterpret_cast( &rhs ) ) {} - - SubresourceLayout & operator=( SubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubresourceLayout & operator=( VkSubresourceLayout const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubresourceLayout && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubresourceLayout && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setRowPitch( DeviceSize rowPitch_ ) & VULKAN_HPP_NOEXCEPT - { - rowPitch = rowPitch_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubresourceLayout && setRowPitch( DeviceSize rowPitch_ ) && VULKAN_HPP_NOEXCEPT - { - rowPitch = rowPitch_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setArrayPitch( DeviceSize arrayPitch_ ) & VULKAN_HPP_NOEXCEPT - { - arrayPitch = arrayPitch_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubresourceLayout && setArrayPitch( DeviceSize arrayPitch_ ) && VULKAN_HPP_NOEXCEPT - { - arrayPitch = arrayPitch_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubresourceLayout & setDepthPitch( DeviceSize depthPitch_ ) & VULKAN_HPP_NOEXCEPT - { - depthPitch = depthPitch_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubresourceLayout && setDepthPitch( DeviceSize depthPitch_ ) && VULKAN_HPP_NOEXCEPT - { - depthPitch = depthPitch_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubresourceLayout const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubresourceLayout &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubresourceLayout const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubresourceLayout *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( offset, size, rowPitch, arrayPitch, depthPitch ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubresourceLayout const & ) const = default; -#else - bool operator==( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( offset == rhs.offset ) && ( size == rhs.size ) && ( rowPitch == rhs.rowPitch ) && ( arrayPitch == rhs.arrayPitch ) && - ( depthPitch == rhs.depthPitch ); -# endif - } - - bool operator!=( SubresourceLayout const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceSize offset = {}; - DeviceSize size = {}; - DeviceSize rowPitch = {}; - DeviceSize arrayPitch = {}; - DeviceSize depthPitch = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubresourceLayout; - }; -#endif - - // wrapper struct for struct VkImageDrmFormatModifierExplicitCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageDrmFormatModifierExplicitCreateInfoEXT.html - struct ImageDrmFormatModifierExplicitCreateInfoEXT - { - using NativeType = VkImageDrmFormatModifierExplicitCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_ = {}, - uint32_t drmFormatModifierPlaneCount_ = {}, - const SubresourceLayout * pPlaneLayouts_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , drmFormatModifier{ drmFormatModifier_ } - , drmFormatModifierPlaneCount{ drmFormatModifierPlaneCount_ } - , pPlaneLayouts{ pPlaneLayouts_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierExplicitCreateInfoEXT( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageDrmFormatModifierExplicitCreateInfoEXT( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageDrmFormatModifierExplicitCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageDrmFormatModifierExplicitCreateInfoEXT( uint64_t drmFormatModifier_, - ArrayProxyNoTemporaries const & planeLayouts_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , drmFormatModifier( drmFormatModifier_ ) - , drmFormatModifierPlaneCount( static_cast( planeLayouts_.size() ) ) - , pPlaneLayouts( planeLayouts_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ImageDrmFormatModifierExplicitCreateInfoEXT & operator=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageDrmFormatModifierExplicitCreateInfoEXT & operator=( VkImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT & setDrmFormatModifier( uint64_t drmFormatModifier_ ) & VULKAN_HPP_NOEXCEPT - { - drmFormatModifier = drmFormatModifier_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT && setDrmFormatModifier( uint64_t drmFormatModifier_ ) && VULKAN_HPP_NOEXCEPT - { - drmFormatModifier = drmFormatModifier_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT & setDrmFormatModifierPlaneCount( uint32_t drmFormatModifierPlaneCount_ ) & - VULKAN_HPP_NOEXCEPT - { - drmFormatModifierPlaneCount = drmFormatModifierPlaneCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT && setDrmFormatModifierPlaneCount( uint32_t drmFormatModifierPlaneCount_ ) && - VULKAN_HPP_NOEXCEPT - { - drmFormatModifierPlaneCount = drmFormatModifierPlaneCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT & setPPlaneLayouts( const SubresourceLayout * pPlaneLayouts_ ) & VULKAN_HPP_NOEXCEPT - { - pPlaneLayouts = pPlaneLayouts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierExplicitCreateInfoEXT && setPPlaneLayouts( const SubresourceLayout * pPlaneLayouts_ ) && VULKAN_HPP_NOEXCEPT - { - pPlaneLayouts = pPlaneLayouts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageDrmFormatModifierExplicitCreateInfoEXT & setPlaneLayouts( ArrayProxyNoTemporaries const & planeLayouts_ ) VULKAN_HPP_NOEXCEPT - { - drmFormatModifierPlaneCount = static_cast( planeLayouts_.size() ); - pPlaneLayouts = planeLayouts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageDrmFormatModifierExplicitCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageDrmFormatModifierExplicitCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageDrmFormatModifierExplicitCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageDrmFormatModifierExplicitCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, drmFormatModifier, drmFormatModifierPlaneCount, pPlaneLayouts ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageDrmFormatModifierExplicitCreateInfoEXT const & ) const = default; -#else - bool operator==( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) && - ( drmFormatModifierPlaneCount == rhs.drmFormatModifierPlaneCount ) && ( pPlaneLayouts == rhs.pPlaneLayouts ); -# endif - } - - bool operator!=( ImageDrmFormatModifierExplicitCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT; - const void * pNext = {}; - uint64_t drmFormatModifier = {}; - uint32_t drmFormatModifierPlaneCount = {}; - const SubresourceLayout * pPlaneLayouts = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageDrmFormatModifierExplicitCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImageDrmFormatModifierExplicitCreateInfoEXT; - }; - - // wrapper struct for struct VkImageDrmFormatModifierListCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageDrmFormatModifierListCreateInfoEXT.html - struct ImageDrmFormatModifierListCreateInfoEXT - { - using NativeType = VkImageDrmFormatModifierListCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierListCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( uint32_t drmFormatModifierCount_ = {}, - const uint64_t * pDrmFormatModifiers_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , drmFormatModifierCount{ drmFormatModifierCount_ } - , pDrmFormatModifiers{ pDrmFormatModifiers_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierListCreateInfoEXT( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageDrmFormatModifierListCreateInfoEXT( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageDrmFormatModifierListCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageDrmFormatModifierListCreateInfoEXT( ArrayProxyNoTemporaries const & drmFormatModifiers_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), drmFormatModifierCount( static_cast( drmFormatModifiers_.size() ) ), pDrmFormatModifiers( drmFormatModifiers_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ImageDrmFormatModifierListCreateInfoEXT & operator=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageDrmFormatModifierListCreateInfoEXT & operator=( VkImageDrmFormatModifierListCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT & setDrmFormatModifierCount( uint32_t drmFormatModifierCount_ ) & VULKAN_HPP_NOEXCEPT - { - drmFormatModifierCount = drmFormatModifierCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT && setDrmFormatModifierCount( uint32_t drmFormatModifierCount_ ) && VULKAN_HPP_NOEXCEPT - { - drmFormatModifierCount = drmFormatModifierCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT & setPDrmFormatModifiers( const uint64_t * pDrmFormatModifiers_ ) & VULKAN_HPP_NOEXCEPT - { - pDrmFormatModifiers = pDrmFormatModifiers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageDrmFormatModifierListCreateInfoEXT && setPDrmFormatModifiers( const uint64_t * pDrmFormatModifiers_ ) && VULKAN_HPP_NOEXCEPT - { - pDrmFormatModifiers = pDrmFormatModifiers_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageDrmFormatModifierListCreateInfoEXT & setDrmFormatModifiers( ArrayProxyNoTemporaries const & drmFormatModifiers_ ) VULKAN_HPP_NOEXCEPT - { - drmFormatModifierCount = static_cast( drmFormatModifiers_.size() ); - pDrmFormatModifiers = drmFormatModifiers_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageDrmFormatModifierListCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageDrmFormatModifierListCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageDrmFormatModifierListCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageDrmFormatModifierListCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, drmFormatModifierCount, pDrmFormatModifiers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageDrmFormatModifierListCreateInfoEXT const & ) const = default; -#else - bool operator==( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifierCount == rhs.drmFormatModifierCount ) && - ( pDrmFormatModifiers == rhs.pDrmFormatModifiers ); -# endif - } - - bool operator!=( ImageDrmFormatModifierListCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageDrmFormatModifierListCreateInfoEXT; - const void * pNext = {}; - uint32_t drmFormatModifierCount = {}; - const uint64_t * pDrmFormatModifiers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageDrmFormatModifierListCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImageDrmFormatModifierListCreateInfoEXT; - }; - - // wrapper struct for struct VkImageDrmFormatModifierPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageDrmFormatModifierPropertiesEXT.html - struct ImageDrmFormatModifierPropertiesEXT - { - using NativeType = VkImageDrmFormatModifierPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageDrmFormatModifierPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierPropertiesEXT( uint64_t drmFormatModifier_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , drmFormatModifier{ drmFormatModifier_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageDrmFormatModifierPropertiesEXT( ImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageDrmFormatModifierPropertiesEXT( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageDrmFormatModifierPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImageDrmFormatModifierPropertiesEXT & operator=( ImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageDrmFormatModifierPropertiesEXT & operator=( VkImageDrmFormatModifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkImageDrmFormatModifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageDrmFormatModifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageDrmFormatModifierPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageDrmFormatModifierPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, drmFormatModifier ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageDrmFormatModifierPropertiesEXT const & ) const = default; -#else - bool operator==( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ); -# endif - } - - bool operator!=( ImageDrmFormatModifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageDrmFormatModifierPropertiesEXT; - void * pNext = {}; - uint64_t drmFormatModifier = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageDrmFormatModifierPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImageDrmFormatModifierPropertiesEXT; - }; - - // wrapper struct for struct VkImageFormatListCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatListCreateInfo.html - struct ImageFormatListCreateInfo - { - using NativeType = VkImageFormatListCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatListCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - ImageFormatListCreateInfo( uint32_t viewFormatCount_ = {}, const Format * pViewFormats_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , viewFormatCount{ viewFormatCount_ } - , pViewFormats{ pViewFormats_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageFormatListCreateInfo( ImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageFormatListCreateInfo( VkImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageFormatListCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageFormatListCreateInfo( ArrayProxyNoTemporaries const & viewFormats_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), viewFormatCount( static_cast( viewFormats_.size() ) ), pViewFormats( viewFormats_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ImageFormatListCreateInfo & operator=( ImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageFormatListCreateInfo & operator=( VkImageFormatListCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo & setViewFormatCount( uint32_t viewFormatCount_ ) & VULKAN_HPP_NOEXCEPT - { - viewFormatCount = viewFormatCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo && setViewFormatCount( uint32_t viewFormatCount_ ) && VULKAN_HPP_NOEXCEPT - { - viewFormatCount = viewFormatCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo & setPViewFormats( const Format * pViewFormats_ ) & VULKAN_HPP_NOEXCEPT - { - pViewFormats = pViewFormats_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageFormatListCreateInfo && setPViewFormats( const Format * pViewFormats_ ) && VULKAN_HPP_NOEXCEPT - { - pViewFormats = pViewFormats_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ImageFormatListCreateInfo & setViewFormats( ArrayProxyNoTemporaries const & viewFormats_ ) VULKAN_HPP_NOEXCEPT - { - viewFormatCount = static_cast( viewFormats_.size() ); - pViewFormats = viewFormats_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageFormatListCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageFormatListCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageFormatListCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageFormatListCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, viewFormatCount, pViewFormats ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageFormatListCreateInfo const & ) const = default; -#else - bool operator==( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewFormatCount == rhs.viewFormatCount ) && ( pViewFormats == rhs.pViewFormats ); -# endif - } - - bool operator!=( ImageFormatListCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageFormatListCreateInfo; - const void * pNext = {}; - uint32_t viewFormatCount = {}; - const Format * pViewFormats = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageFormatListCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ImageFormatListCreateInfo; - }; - - using ImageFormatListCreateInfoKHR = ImageFormatListCreateInfo; - - // wrapper struct for struct VkImageFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageFormatProperties2.html - struct ImageFormatProperties2 - { - using NativeType = VkImageFormatProperties2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageFormatProperties2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageFormatProperties2( ImageFormatProperties imageFormatProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageFormatProperties{ imageFormatProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageFormatProperties2( ImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageFormatProperties2( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageFormatProperties2( *reinterpret_cast( &rhs ) ) - { - } - - ImageFormatProperties2 & operator=( ImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageFormatProperties2 & operator=( VkImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageFormatProperties2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageFormatProperties2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageFormatProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageFormatProperties2 const & ) const = default; -#else - bool operator==( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFormatProperties == rhs.imageFormatProperties ); -# endif - } - - bool operator!=( ImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageFormatProperties2; - void * pNext = {}; - ImageFormatProperties imageFormatProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageFormatProperties2; - }; -#endif - - template <> - struct CppType - { - using Type = ImageFormatProperties2; - }; - - using ImageFormatProperties2KHR = ImageFormatProperties2; - - // wrapper struct for struct VkImageMemoryBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageMemoryBarrier.html - struct ImageMemoryBarrier - { - using NativeType = VkImageMemoryBarrier; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryBarrier; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( AccessFlags srcAccessMask_ = {}, - AccessFlags dstAccessMask_ = {}, - ImageLayout oldLayout_ = ImageLayout::eUndefined, - ImageLayout newLayout_ = ImageLayout::eUndefined, - uint32_t srcQueueFamilyIndex_ = {}, - uint32_t dstQueueFamilyIndex_ = {}, - Image image_ = {}, - ImageSubresourceRange subresourceRange_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcAccessMask{ srcAccessMask_ } - , dstAccessMask{ dstAccessMask_ } - , oldLayout{ oldLayout_ } - , newLayout{ newLayout_ } - , srcQueueFamilyIndex{ srcQueueFamilyIndex_ } - , dstQueueFamilyIndex{ dstQueueFamilyIndex_ } - , image{ image_ } - , subresourceRange{ subresourceRange_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageMemoryBarrier( ImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageMemoryBarrier( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT : ImageMemoryBarrier( *reinterpret_cast( &rhs ) ) {} - - ImageMemoryBarrier & operator=( ImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageMemoryBarrier & operator=( VkImageMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setSrcAccessMask( AccessFlags srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setDstAccessMask( AccessFlags dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setOldLayout( ImageLayout oldLayout_ ) & VULKAN_HPP_NOEXCEPT - { - oldLayout = oldLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setOldLayout( ImageLayout oldLayout_ ) && VULKAN_HPP_NOEXCEPT - { - oldLayout = oldLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setNewLayout( ImageLayout newLayout_ ) & VULKAN_HPP_NOEXCEPT - { - newLayout = newLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setNewLayout( ImageLayout newLayout_ ) && VULKAN_HPP_NOEXCEPT - { - newLayout = newLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier & setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) & VULKAN_HPP_NOEXCEPT - { - subresourceRange = subresourceRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryBarrier && setSubresourceRange( ImageSubresourceRange const & subresourceRange_ ) && VULKAN_HPP_NOEXCEPT - { - subresourceRange = subresourceRange_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageMemoryBarrier &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageMemoryBarrier const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageMemoryBarrier *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcAccessMask, dstAccessMask, oldLayout, newLayout, srcQueueFamilyIndex, dstQueueFamilyIndex, image, subresourceRange ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageMemoryBarrier const & ) const = default; -#else - bool operator==( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) && - ( oldLayout == rhs.oldLayout ) && ( newLayout == rhs.newLayout ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && - ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( image == rhs.image ) && ( subresourceRange == rhs.subresourceRange ); -# endif - } - - bool operator!=( ImageMemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageMemoryBarrier; - const void * pNext = {}; - AccessFlags srcAccessMask = {}; - AccessFlags dstAccessMask = {}; - ImageLayout oldLayout = ImageLayout::eUndefined; - ImageLayout newLayout = ImageLayout::eUndefined; - uint32_t srcQueueFamilyIndex = {}; - uint32_t dstQueueFamilyIndex = {}; - Image image = {}; - ImageSubresourceRange subresourceRange = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageMemoryBarrier; - }; -#endif - - template <> - struct CppType - { - using Type = ImageMemoryBarrier; - }; - - // wrapper struct for struct VkImageMemoryRequirementsInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageMemoryRequirementsInfo2.html - struct ImageMemoryRequirementsInfo2 - { - using NativeType = VkImageMemoryRequirementsInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageMemoryRequirementsInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( Image image_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , image{ image_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageMemoryRequirementsInfo2( ImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageMemoryRequirementsInfo2( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageMemoryRequirementsInfo2( *reinterpret_cast( &rhs ) ) - { - } - - ImageMemoryRequirementsInfo2 & operator=( ImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageMemoryRequirementsInfo2 & operator=( VkImageMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageMemoryRequirementsInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryRequirementsInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryRequirementsInfo2 & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageMemoryRequirementsInfo2 && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageMemoryRequirementsInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageMemoryRequirementsInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, image ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageMemoryRequirementsInfo2 const & ) const = default; -#else - bool operator==( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); -# endif - } - - bool operator!=( ImageMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageMemoryRequirementsInfo2; - const void * pNext = {}; - Image image = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageMemoryRequirementsInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = ImageMemoryRequirementsInfo2; - }; - - using ImageMemoryRequirementsInfo2KHR = ImageMemoryRequirementsInfo2; - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkImagePipeSurfaceCreateInfoFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImagePipeSurfaceCreateInfoFUCHSIA.html - struct ImagePipeSurfaceCreateInfoFUCHSIA - { - using NativeType = VkImagePipeSurfaceCreateInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ = {}, - zx_handle_t imagePipeHandle_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , imagePipeHandle{ imagePipeHandle_ } - { - } - - VULKAN_HPP_CONSTEXPR ImagePipeSurfaceCreateInfoFUCHSIA( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImagePipeSurfaceCreateInfoFUCHSIA( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : ImagePipeSurfaceCreateInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - ImagePipeSurfaceCreateInfoFUCHSIA & operator=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImagePipeSurfaceCreateInfoFUCHSIA & operator=( VkImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA & setFlags( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA && setFlags( ImagePipeSurfaceCreateFlagsFUCHSIA flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA & setImagePipeHandle( zx_handle_t imagePipeHandle_ ) & VULKAN_HPP_NOEXCEPT - { - imagePipeHandle = imagePipeHandle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImagePipeSurfaceCreateInfoFUCHSIA && setImagePipeHandle( zx_handle_t imagePipeHandle_ ) && VULKAN_HPP_NOEXCEPT - { - imagePipeHandle = imagePipeHandle_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImagePipeSurfaceCreateInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImagePipeSurfaceCreateInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImagePipeSurfaceCreateInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImagePipeSurfaceCreateInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, imagePipeHandle ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &imagePipeHandle, &rhs.imagePipeHandle, sizeof( zx_handle_t ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -# endif - - bool operator==( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( memcmp( &imagePipeHandle, &rhs.imagePipeHandle, sizeof( zx_handle_t ) ) == 0 ); - } - - bool operator!=( ImagePipeSurfaceCreateInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eImagepipeSurfaceCreateInfoFUCHSIA; - const void * pNext = {}; - ImagePipeSurfaceCreateFlagsFUCHSIA flags = {}; - zx_handle_t imagePipeHandle = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImagePipeSurfaceCreateInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = ImagePipeSurfaceCreateInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - // wrapper struct for struct VkImagePlaneMemoryRequirementsInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImagePlaneMemoryRequirementsInfo.html - struct ImagePlaneMemoryRequirementsInfo - { - using NativeType = VkImagePlaneMemoryRequirementsInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImagePlaneMemoryRequirementsInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( ImageAspectFlagBits planeAspect_ = ImageAspectFlagBits::eColor, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , planeAspect{ planeAspect_ } - { - } - - VULKAN_HPP_CONSTEXPR ImagePlaneMemoryRequirementsInfo( ImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImagePlaneMemoryRequirementsInfo( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : ImagePlaneMemoryRequirementsInfo( *reinterpret_cast( &rhs ) ) - { - } - - ImagePlaneMemoryRequirementsInfo & operator=( ImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImagePlaneMemoryRequirementsInfo & operator=( VkImagePlaneMemoryRequirementsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImagePlaneMemoryRequirementsInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImagePlaneMemoryRequirementsInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImagePlaneMemoryRequirementsInfo & setPlaneAspect( ImageAspectFlagBits planeAspect_ ) & VULKAN_HPP_NOEXCEPT - { - planeAspect = planeAspect_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImagePlaneMemoryRequirementsInfo && setPlaneAspect( ImageAspectFlagBits planeAspect_ ) && VULKAN_HPP_NOEXCEPT - { - planeAspect = planeAspect_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImagePlaneMemoryRequirementsInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImagePlaneMemoryRequirementsInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImagePlaneMemoryRequirementsInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImagePlaneMemoryRequirementsInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, planeAspect ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImagePlaneMemoryRequirementsInfo const & ) const = default; -#else - bool operator==( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( planeAspect == rhs.planeAspect ); -# endif - } - - bool operator!=( ImagePlaneMemoryRequirementsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImagePlaneMemoryRequirementsInfo; - const void * pNext = {}; - ImageAspectFlagBits planeAspect = ImageAspectFlagBits::eColor; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImagePlaneMemoryRequirementsInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ImagePlaneMemoryRequirementsInfo; - }; - - using ImagePlaneMemoryRequirementsInfoKHR = ImagePlaneMemoryRequirementsInfo; - - // wrapper struct for struct VkImageResolve, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageResolve.html - struct ImageResolve - { - using NativeType = VkImageResolve; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageResolve( ImageSubresourceLayers srcSubresource_ = {}, - Offset3D srcOffset_ = {}, - ImageSubresourceLayers dstSubresource_ = {}, - Offset3D dstOffset_ = {}, - Extent3D extent_ = {} ) VULKAN_HPP_NOEXCEPT - : srcSubresource{ srcSubresource_ } - , srcOffset{ srcOffset_ } - , dstSubresource{ dstSubresource_ } - , dstOffset{ dstOffset_ } - , extent{ extent_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageResolve( ImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageResolve( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT : ImageResolve( *reinterpret_cast( &rhs ) ) {} - - ImageResolve & operator=( ImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageResolve & operator=( VkImageResolve const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageResolve & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve & setSrcOffset( Offset3D const & srcOffset_ ) & VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve && setSrcOffset( Offset3D const & srcOffset_ ) && VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve & setDstOffset( Offset3D const & dstOffset_ ) & VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve && setDstOffset( Offset3D const & dstOffset_ ) && VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageResolve const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageResolve &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageResolve const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageResolve *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageResolve const & ) const = default; -#else - bool operator==( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && ( dstSubresource == rhs.dstSubresource ) && - ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); -# endif - } - - bool operator!=( ImageResolve const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ImageSubresourceLayers srcSubresource = {}; - Offset3D srcOffset = {}; - ImageSubresourceLayers dstSubresource = {}; - Offset3D dstOffset = {}; - Extent3D extent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageResolve; - }; -#endif - - // wrapper struct for struct VkImageResolve2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageResolve2.html - struct ImageResolve2 - { - using NativeType = VkImageResolve2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageResolve2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageResolve2( ImageSubresourceLayers srcSubresource_ = {}, - Offset3D srcOffset_ = {}, - ImageSubresourceLayers dstSubresource_ = {}, - Offset3D dstOffset_ = {}, - Extent3D extent_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcSubresource{ srcSubresource_ } - , srcOffset{ srcOffset_ } - , dstSubresource{ dstSubresource_ } - , dstOffset{ dstOffset_ } - , extent{ extent_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageResolve2( ImageResolve2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageResolve2( VkImageResolve2 const & rhs ) VULKAN_HPP_NOEXCEPT : ImageResolve2( *reinterpret_cast( &rhs ) ) {} - - ImageResolve2 & operator=( ImageResolve2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageResolve2 & operator=( VkImageResolve2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setSrcSubresource( ImageSubresourceLayers const & srcSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - srcSubresource = srcSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setSrcOffset( Offset3D const & srcOffset_ ) & VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setSrcOffset( Offset3D const & srcOffset_ ) && VULKAN_HPP_NOEXCEPT - { - srcOffset = srcOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) & VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setDstSubresource( ImageSubresourceLayers const & dstSubresource_ ) && VULKAN_HPP_NOEXCEPT - { - dstSubresource = dstSubresource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setDstOffset( Offset3D const & dstOffset_ ) & VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setDstOffset( Offset3D const & dstOffset_ ) && VULKAN_HPP_NOEXCEPT - { - dstOffset = dstOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 & setExtent( Extent3D const & extent_ ) & VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageResolve2 && setExtent( Extent3D const & extent_ ) && VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageResolve2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageResolve2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageResolve2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageResolve2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcSubresource, srcOffset, dstSubresource, dstOffset, extent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageResolve2 const & ) const = default; -#else - bool operator==( ImageResolve2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubresource == rhs.srcSubresource ) && ( srcOffset == rhs.srcOffset ) && - ( dstSubresource == rhs.dstSubresource ) && ( dstOffset == rhs.dstOffset ) && ( extent == rhs.extent ); -# endif - } - - bool operator!=( ImageResolve2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageResolve2; - const void * pNext = {}; - ImageSubresourceLayers srcSubresource = {}; - Offset3D srcOffset = {}; - ImageSubresourceLayers dstSubresource = {}; - Offset3D dstOffset = {}; - Extent3D extent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageResolve2; - }; -#endif - - template <> - struct CppType - { - using Type = ImageResolve2; - }; - - using ImageResolve2KHR = ImageResolve2; - - // wrapper struct for struct VkImageSparseMemoryRequirementsInfo2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSparseMemoryRequirementsInfo2.html - struct ImageSparseMemoryRequirementsInfo2 - { - using NativeType = VkImageSparseMemoryRequirementsInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageSparseMemoryRequirementsInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( Image image_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , image{ image_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageSparseMemoryRequirementsInfo2( ImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageSparseMemoryRequirementsInfo2( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageSparseMemoryRequirementsInfo2( *reinterpret_cast( &rhs ) ) - { - } - - ImageSparseMemoryRequirementsInfo2 & operator=( ImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageSparseMemoryRequirementsInfo2 & operator=( VkImageSparseMemoryRequirementsInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageSparseMemoryRequirementsInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSparseMemoryRequirementsInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSparseMemoryRequirementsInfo2 & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSparseMemoryRequirementsInfo2 && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageSparseMemoryRequirementsInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSparseMemoryRequirementsInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSparseMemoryRequirementsInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageSparseMemoryRequirementsInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, image ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageSparseMemoryRequirementsInfo2 const & ) const = default; -#else - bool operator==( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ); -# endif - } - - bool operator!=( ImageSparseMemoryRequirementsInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageSparseMemoryRequirementsInfo2; - const void * pNext = {}; - Image image = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageSparseMemoryRequirementsInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = ImageSparseMemoryRequirementsInfo2; - }; - - using ImageSparseMemoryRequirementsInfo2KHR = ImageSparseMemoryRequirementsInfo2; - - // wrapper struct for struct VkImageStencilUsageCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageStencilUsageCreateInfo.html - struct ImageStencilUsageCreateInfo - { - using NativeType = VkImageStencilUsageCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageStencilUsageCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfo( ImageUsageFlags stencilUsage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stencilUsage{ stencilUsage_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageStencilUsageCreateInfo( ImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageStencilUsageCreateInfo( VkImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageStencilUsageCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - ImageStencilUsageCreateInfo & operator=( ImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageStencilUsageCreateInfo & operator=( VkImageStencilUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageStencilUsageCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageStencilUsageCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageStencilUsageCreateInfo & setStencilUsage( ImageUsageFlags stencilUsage_ ) & VULKAN_HPP_NOEXCEPT - { - stencilUsage = stencilUsage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageStencilUsageCreateInfo && setStencilUsage( ImageUsageFlags stencilUsage_ ) && VULKAN_HPP_NOEXCEPT - { - stencilUsage = stencilUsage_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageStencilUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageStencilUsageCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageStencilUsageCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageStencilUsageCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stencilUsage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageStencilUsageCreateInfo const & ) const = default; -#else - bool operator==( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stencilUsage == rhs.stencilUsage ); -# endif - } - - bool operator!=( ImageStencilUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageStencilUsageCreateInfo; - const void * pNext = {}; - ImageUsageFlags stencilUsage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageStencilUsageCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ImageStencilUsageCreateInfo; - }; - - using ImageStencilUsageCreateInfoEXT = ImageStencilUsageCreateInfo; - - // wrapper struct for struct VkImageSwapchainCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageSwapchainCreateInfoKHR.html - struct ImageSwapchainCreateInfoKHR - { - using NativeType = VkImageSwapchainCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageSwapchainCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( SwapchainKHR swapchain_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchain{ swapchain_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageSwapchainCreateInfoKHR( ImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageSwapchainCreateInfoKHR( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageSwapchainCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ImageSwapchainCreateInfoKHR & operator=( ImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageSwapchainCreateInfoKHR & operator=( VkImageSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageSwapchainCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSwapchainCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageSwapchainCreateInfoKHR & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageSwapchainCreateInfoKHR && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageSwapchainCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageSwapchainCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchain ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageSwapchainCreateInfoKHR const & ) const = default; -#else - bool operator==( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ); -# endif - } - - bool operator!=( ImageSwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageSwapchainCreateInfoKHR; - const void * pNext = {}; - SwapchainKHR swapchain = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageSwapchainCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = ImageSwapchainCreateInfoKHR; - }; - - // wrapper struct for struct VkImageViewASTCDecodeModeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewASTCDecodeModeEXT.html - struct ImageViewASTCDecodeModeEXT - { - using NativeType = VkImageViewASTCDecodeModeEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewAstcDecodeModeEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( Format decodeMode_ = Format::eUndefined, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , decodeMode{ decodeMode_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageViewASTCDecodeModeEXT( ImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageViewASTCDecodeModeEXT( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageViewASTCDecodeModeEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImageViewASTCDecodeModeEXT & operator=( ImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageViewASTCDecodeModeEXT & operator=( VkImageViewASTCDecodeModeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageViewASTCDecodeModeEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewASTCDecodeModeEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewASTCDecodeModeEXT & setDecodeMode( Format decodeMode_ ) & VULKAN_HPP_NOEXCEPT - { - decodeMode = decodeMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewASTCDecodeModeEXT && setDecodeMode( Format decodeMode_ ) && VULKAN_HPP_NOEXCEPT - { - decodeMode = decodeMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageViewASTCDecodeModeEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewASTCDecodeModeEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewASTCDecodeModeEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageViewASTCDecodeModeEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, decodeMode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageViewASTCDecodeModeEXT const & ) const = default; -#else - bool operator==( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeMode == rhs.decodeMode ); -# endif - } - - bool operator!=( ImageViewASTCDecodeModeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageViewAstcDecodeModeEXT; - const void * pNext = {}; - Format decodeMode = Format::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageViewASTCDecodeModeEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImageViewASTCDecodeModeEXT; - }; - - // wrapper struct for struct VkImageViewAddressPropertiesNVX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewAddressPropertiesNVX.html - struct ImageViewAddressPropertiesNVX - { - using NativeType = VkImageViewAddressPropertiesNVX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewAddressPropertiesNVX; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageViewAddressPropertiesNVX( DeviceAddress deviceAddress_ = {}, DeviceSize size_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceAddress{ deviceAddress_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageViewAddressPropertiesNVX( ImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageViewAddressPropertiesNVX( VkImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageViewAddressPropertiesNVX( *reinterpret_cast( &rhs ) ) - { - } - - ImageViewAddressPropertiesNVX & operator=( ImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageViewAddressPropertiesNVX & operator=( VkImageViewAddressPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkImageViewAddressPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewAddressPropertiesNVX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewAddressPropertiesNVX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageViewAddressPropertiesNVX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceAddress, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageViewAddressPropertiesNVX const & ) const = default; -#else - bool operator==( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceAddress == rhs.deviceAddress ) && ( size == rhs.size ); -# endif - } - - bool operator!=( ImageViewAddressPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageViewAddressPropertiesNVX; - void * pNext = {}; - DeviceAddress deviceAddress = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageViewAddressPropertiesNVX; - }; -#endif - - template <> - struct CppType - { - using Type = ImageViewAddressPropertiesNVX; - }; - - // wrapper struct for struct VkImageViewCaptureDescriptorDataInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewCaptureDescriptorDataInfoEXT.html - struct ImageViewCaptureDescriptorDataInfoEXT - { - using NativeType = VkImageViewCaptureDescriptorDataInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewCaptureDescriptorDataInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageViewCaptureDescriptorDataInfoEXT( ImageView imageView_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageView{ imageView_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageViewCaptureDescriptorDataInfoEXT( ImageViewCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageViewCaptureDescriptorDataInfoEXT( VkImageViewCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageViewCaptureDescriptorDataInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImageViewCaptureDescriptorDataInfoEXT & operator=( ImageViewCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageViewCaptureDescriptorDataInfoEXT & operator=( VkImageViewCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageViewCaptureDescriptorDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCaptureDescriptorDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCaptureDescriptorDataInfoEXT & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewCaptureDescriptorDataInfoEXT && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageViewCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageViewCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageView ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageViewCaptureDescriptorDataInfoEXT const & ) const = default; -#else - bool operator==( ImageViewCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ); -# endif - } - - bool operator!=( ImageViewCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageViewCaptureDescriptorDataInfoEXT; - const void * pNext = {}; - ImageView imageView = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageViewCaptureDescriptorDataInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImageViewCaptureDescriptorDataInfoEXT; - }; - - // wrapper struct for struct VkImageViewHandleInfoNVX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewHandleInfoNVX.html - struct ImageViewHandleInfoNVX - { - using NativeType = VkImageViewHandleInfoNVX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewHandleInfoNVX; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( ImageView imageView_ = {}, - DescriptorType descriptorType_ = DescriptorType::eSampler, - Sampler sampler_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageView{ imageView_ } - , descriptorType{ descriptorType_ } - , sampler{ sampler_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageViewHandleInfoNVX( ImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageViewHandleInfoNVX( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageViewHandleInfoNVX( *reinterpret_cast( &rhs ) ) - { - } - - ImageViewHandleInfoNVX & operator=( ImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageViewHandleInfoNVX & operator=( VkImageViewHandleInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX & setDescriptorType( DescriptorType descriptorType_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorType = descriptorType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX && setDescriptorType( DescriptorType descriptorType_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorType = descriptorType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX & setSampler( Sampler sampler_ ) & VULKAN_HPP_NOEXCEPT - { - sampler = sampler_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewHandleInfoNVX && setSampler( Sampler sampler_ ) && VULKAN_HPP_NOEXCEPT - { - sampler = sampler_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageViewHandleInfoNVX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewHandleInfoNVX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewHandleInfoNVX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageViewHandleInfoNVX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageView, descriptorType, sampler ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageViewHandleInfoNVX const & ) const = default; -#else - bool operator==( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && ( descriptorType == rhs.descriptorType ) && - ( sampler == rhs.sampler ); -# endif - } - - bool operator!=( ImageViewHandleInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageViewHandleInfoNVX; - const void * pNext = {}; - ImageView imageView = {}; - DescriptorType descriptorType = DescriptorType::eSampler; - Sampler sampler = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageViewHandleInfoNVX; - }; -#endif - - template <> - struct CppType - { - using Type = ImageViewHandleInfoNVX; - }; - - // wrapper struct for struct VkImageViewMinLodCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewMinLodCreateInfoEXT.html - struct ImageViewMinLodCreateInfoEXT - { - using NativeType = VkImageViewMinLodCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewMinLodCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageViewMinLodCreateInfoEXT( float minLod_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minLod{ minLod_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageViewMinLodCreateInfoEXT( ImageViewMinLodCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageViewMinLodCreateInfoEXT( VkImageViewMinLodCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageViewMinLodCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImageViewMinLodCreateInfoEXT & operator=( ImageViewMinLodCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageViewMinLodCreateInfoEXT & operator=( VkImageViewMinLodCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageViewMinLodCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewMinLodCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewMinLodCreateInfoEXT & setMinLod( float minLod_ ) & VULKAN_HPP_NOEXCEPT - { - minLod = minLod_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewMinLodCreateInfoEXT && setMinLod( float minLod_ ) && VULKAN_HPP_NOEXCEPT - { - minLod = minLod_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageViewMinLodCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewMinLodCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewMinLodCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageViewMinLodCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minLod ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageViewMinLodCreateInfoEXT const & ) const = default; -#else - bool operator==( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod ); -# endif - } - - bool operator!=( ImageViewMinLodCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageViewMinLodCreateInfoEXT; - const void * pNext = {}; - float minLod = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageViewMinLodCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImageViewMinLodCreateInfoEXT; - }; - - // wrapper struct for struct VkImageViewSampleWeightCreateInfoQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewSampleWeightCreateInfoQCOM.html - struct ImageViewSampleWeightCreateInfoQCOM - { - using NativeType = VkImageViewSampleWeightCreateInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewSampleWeightCreateInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageViewSampleWeightCreateInfoQCOM( Offset2D filterCenter_ = {}, - Extent2D filterSize_ = {}, - uint32_t numPhases_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , filterCenter{ filterCenter_ } - , filterSize{ filterSize_ } - , numPhases{ numPhases_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageViewSampleWeightCreateInfoQCOM( ImageViewSampleWeightCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageViewSampleWeightCreateInfoQCOM( VkImageViewSampleWeightCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageViewSampleWeightCreateInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - ImageViewSampleWeightCreateInfoQCOM & operator=( ImageViewSampleWeightCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageViewSampleWeightCreateInfoQCOM & operator=( VkImageViewSampleWeightCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM & setFilterCenter( Offset2D const & filterCenter_ ) & VULKAN_HPP_NOEXCEPT - { - filterCenter = filterCenter_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM && setFilterCenter( Offset2D const & filterCenter_ ) && VULKAN_HPP_NOEXCEPT - { - filterCenter = filterCenter_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM & setFilterSize( Extent2D const & filterSize_ ) & VULKAN_HPP_NOEXCEPT - { - filterSize = filterSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM && setFilterSize( Extent2D const & filterSize_ ) && VULKAN_HPP_NOEXCEPT - { - filterSize = filterSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM & setNumPhases( uint32_t numPhases_ ) & VULKAN_HPP_NOEXCEPT - { - numPhases = numPhases_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSampleWeightCreateInfoQCOM && setNumPhases( uint32_t numPhases_ ) && VULKAN_HPP_NOEXCEPT - { - numPhases = numPhases_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageViewSampleWeightCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewSampleWeightCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewSampleWeightCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageViewSampleWeightCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, filterCenter, filterSize, numPhases ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageViewSampleWeightCreateInfoQCOM const & ) const = default; -#else - bool operator==( ImageViewSampleWeightCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterCenter == rhs.filterCenter ) && ( filterSize == rhs.filterSize ) && - ( numPhases == rhs.numPhases ); -# endif - } - - bool operator!=( ImageViewSampleWeightCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageViewSampleWeightCreateInfoQCOM; - const void * pNext = {}; - Offset2D filterCenter = {}; - Extent2D filterSize = {}; - uint32_t numPhases = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageViewSampleWeightCreateInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = ImageViewSampleWeightCreateInfoQCOM; - }; - - // wrapper struct for struct VkImageViewSlicedCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewSlicedCreateInfoEXT.html - struct ImageViewSlicedCreateInfoEXT - { - using NativeType = VkImageViewSlicedCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewSlicedCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - ImageViewSlicedCreateInfoEXT( uint32_t sliceOffset_ = {}, uint32_t sliceCount_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , sliceOffset{ sliceOffset_ } - , sliceCount{ sliceCount_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageViewSlicedCreateInfoEXT( ImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageViewSlicedCreateInfoEXT( VkImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageViewSlicedCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImageViewSlicedCreateInfoEXT & operator=( ImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageViewSlicedCreateInfoEXT & operator=( VkImageViewSlicedCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT & setSliceOffset( uint32_t sliceOffset_ ) & VULKAN_HPP_NOEXCEPT - { - sliceOffset = sliceOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT && setSliceOffset( uint32_t sliceOffset_ ) && VULKAN_HPP_NOEXCEPT - { - sliceOffset = sliceOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT & setSliceCount( uint32_t sliceCount_ ) & VULKAN_HPP_NOEXCEPT - { - sliceCount = sliceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewSlicedCreateInfoEXT && setSliceCount( uint32_t sliceCount_ ) && VULKAN_HPP_NOEXCEPT - { - sliceCount = sliceCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageViewSlicedCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewSlicedCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewSlicedCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageViewSlicedCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, sliceOffset, sliceCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageViewSlicedCreateInfoEXT const & ) const = default; -#else - bool operator==( ImageViewSlicedCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sliceOffset == rhs.sliceOffset ) && ( sliceCount == rhs.sliceCount ); -# endif - } - - bool operator!=( ImageViewSlicedCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageViewSlicedCreateInfoEXT; - const void * pNext = {}; - uint32_t sliceOffset = {}; - uint32_t sliceCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageViewSlicedCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImageViewSlicedCreateInfoEXT; - }; - - // wrapper struct for struct VkImageViewUsageCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImageViewUsageCreateInfo.html - struct ImageViewUsageCreateInfo - { - using NativeType = VkImageViewUsageCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImageViewUsageCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( ImageUsageFlags usage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , usage{ usage_ } - { - } - - VULKAN_HPP_CONSTEXPR ImageViewUsageCreateInfo( ImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImageViewUsageCreateInfo( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : ImageViewUsageCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - ImageViewUsageCreateInfo & operator=( ImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImageViewUsageCreateInfo & operator=( VkImageViewUsageCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImageViewUsageCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewUsageCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewUsageCreateInfo & setUsage( ImageUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImageViewUsageCreateInfo && setUsage( ImageUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImageViewUsageCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewUsageCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImageViewUsageCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImageViewUsageCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, usage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImageViewUsageCreateInfo const & ) const = default; -#else - bool operator==( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage ); -# endif - } - - bool operator!=( ImageViewUsageCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImageViewUsageCreateInfo; - const void * pNext = {}; - ImageUsageFlags usage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImageViewUsageCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ImageViewUsageCreateInfo; - }; - - using ImageViewUsageCreateInfoKHR = ImageViewUsageCreateInfo; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - // wrapper struct for struct VkImportAndroidHardwareBufferInfoANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportAndroidHardwareBufferInfoANDROID.html - struct ImportAndroidHardwareBufferInfoANDROID - { - using NativeType = VkImportAndroidHardwareBufferInfoANDROID; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportAndroidHardwareBufferInfoANDROID; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( struct AHardwareBuffer * buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , buffer{ buffer_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportAndroidHardwareBufferInfoANDROID( ImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportAndroidHardwareBufferInfoANDROID( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportAndroidHardwareBufferInfoANDROID( *reinterpret_cast( &rhs ) ) - { - } - - ImportAndroidHardwareBufferInfoANDROID & operator=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportAndroidHardwareBufferInfoANDROID & operator=( VkImportAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportAndroidHardwareBufferInfoANDROID & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportAndroidHardwareBufferInfoANDROID && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportAndroidHardwareBufferInfoANDROID & setBuffer( struct AHardwareBuffer * buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportAndroidHardwareBufferInfoANDROID && setBuffer( struct AHardwareBuffer * buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportAndroidHardwareBufferInfoANDROID const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportAndroidHardwareBufferInfoANDROID *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, buffer ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportAndroidHardwareBufferInfoANDROID const & ) const = default; -# else - bool operator==( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); -# endif - } - - bool operator!=( ImportAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportAndroidHardwareBufferInfoANDROID; - const void * pNext = {}; - struct AHardwareBuffer * buffer = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportAndroidHardwareBufferInfoANDROID; - }; -# endif - - template <> - struct CppType - { - using Type = ImportAndroidHardwareBufferInfoANDROID; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - // wrapper struct for struct VkImportFenceFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportFenceFdInfoKHR.html - struct ImportFenceFdInfoKHR - { - using NativeType = VkImportFenceFdInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportFenceFdInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( Fence fence_ = {}, - FenceImportFlags flags_ = {}, - ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, - int fd_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fence{ fence_ } - , flags{ flags_ } - , handleType{ handleType_ } - , fd{ fd_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportFenceFdInfoKHR( ImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportFenceFdInfoKHR( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportFenceFdInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ImportFenceFdInfoKHR & operator=( ImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportFenceFdInfoKHR & operator=( VkImportFenceFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR & setFence( Fence fence_ ) & VULKAN_HPP_NOEXCEPT - { - fence = fence_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR && setFence( Fence fence_ ) && VULKAN_HPP_NOEXCEPT - { - fence = fence_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR & setFlags( FenceImportFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR && setFlags( FenceImportFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR && setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR & setFd( int fd_ ) & VULKAN_HPP_NOEXCEPT - { - fd = fd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceFdInfoKHR && setFd( int fd_ ) && VULKAN_HPP_NOEXCEPT - { - fd = fd_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportFenceFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportFenceFdInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportFenceFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportFenceFdInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fence, flags, handleType, fd ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportFenceFdInfoKHR const & ) const = default; -#else - bool operator==( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && - ( fd == rhs.fd ); -# endif - } - - bool operator!=( ImportFenceFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImportFenceFdInfoKHR; - const void * pNext = {}; - Fence fence = {}; - FenceImportFlags flags = {}; - ExternalFenceHandleTypeFlagBits handleType = ExternalFenceHandleTypeFlagBits::eOpaqueFd; - int fd = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportFenceFdInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = ImportFenceFdInfoKHR; - }; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkImportFenceWin32HandleInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportFenceWin32HandleInfoKHR.html - struct ImportFenceWin32HandleInfoKHR - { - using NativeType = VkImportFenceWin32HandleInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportFenceWin32HandleInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( Fence fence_ = {}, - FenceImportFlags flags_ = {}, - ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = {}, - LPCWSTR name_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fence{ fence_ } - , flags{ flags_ } - , handleType{ handleType_ } - , handle{ handle_ } - , name{ name_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportFenceWin32HandleInfoKHR( ImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportFenceWin32HandleInfoKHR( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportFenceWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ImportFenceWin32HandleInfoKHR & operator=( ImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportFenceWin32HandleInfoKHR & operator=( VkImportFenceWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setFence( Fence fence_ ) & VULKAN_HPP_NOEXCEPT - { - fence = fence_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setFence( Fence fence_ ) && VULKAN_HPP_NOEXCEPT - { - fence = fence_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setFlags( FenceImportFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setFlags( FenceImportFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setHandle( HANDLE handle_ ) & VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setHandle( HANDLE handle_ ) && VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT - { - name = name_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportFenceWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT - { - name = name_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportFenceWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportFenceWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportFenceWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportFenceWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fence, flags, handleType, handle, name ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportFenceWin32HandleInfoKHR const & ) const = default; -# else - bool operator==( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fence == rhs.fence ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && - ( handle == rhs.handle ) && ( name == rhs.name ); -# endif - } - - bool operator!=( ImportFenceWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportFenceWin32HandleInfoKHR; - const void * pNext = {}; - Fence fence = {}; - FenceImportFlags flags = {}; - ExternalFenceHandleTypeFlagBits handleType = ExternalFenceHandleTypeFlagBits::eOpaqueFd; - HANDLE handle = {}; - LPCWSTR name = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportFenceWin32HandleInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = ImportFenceWin32HandleInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkImportMemoryBufferCollectionFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryBufferCollectionFUCHSIA.html - struct ImportMemoryBufferCollectionFUCHSIA - { - using NativeType = VkImportMemoryBufferCollectionFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryBufferCollectionFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - ImportMemoryBufferCollectionFUCHSIA( BufferCollectionFUCHSIA collection_ = {}, uint32_t index_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , collection{ collection_ } - , index{ index_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportMemoryBufferCollectionFUCHSIA( ImportMemoryBufferCollectionFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportMemoryBufferCollectionFUCHSIA( VkImportMemoryBufferCollectionFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportMemoryBufferCollectionFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - ImportMemoryBufferCollectionFUCHSIA & operator=( ImportMemoryBufferCollectionFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportMemoryBufferCollectionFUCHSIA & operator=( VkImportMemoryBufferCollectionFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA & setCollection( BufferCollectionFUCHSIA collection_ ) & VULKAN_HPP_NOEXCEPT - { - collection = collection_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA && setCollection( BufferCollectionFUCHSIA collection_ ) && VULKAN_HPP_NOEXCEPT - { - collection = collection_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT - { - index = index_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryBufferCollectionFUCHSIA && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT - { - index = index_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportMemoryBufferCollectionFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryBufferCollectionFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryBufferCollectionFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportMemoryBufferCollectionFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, collection, index ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportMemoryBufferCollectionFUCHSIA const & ) const = default; -# else - bool operator==( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( collection == rhs.collection ) && ( index == rhs.index ); -# endif - } - - bool operator!=( ImportMemoryBufferCollectionFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportMemoryBufferCollectionFUCHSIA; - const void * pNext = {}; - BufferCollectionFUCHSIA collection = {}; - uint32_t index = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportMemoryBufferCollectionFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = ImportMemoryBufferCollectionFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - // wrapper struct for struct VkImportMemoryFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryFdInfoKHR.html - struct ImportMemoryFdInfoKHR - { - using NativeType = VkImportMemoryFdInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryFdInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - int fd_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleType{ handleType_ } - , fd{ fd_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportMemoryFdInfoKHR( ImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportMemoryFdInfoKHR( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportMemoryFdInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ImportMemoryFdInfoKHR & operator=( ImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportMemoryFdInfoKHR & operator=( VkImportMemoryFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR & setFd( int fd_ ) & VULKAN_HPP_NOEXCEPT - { - fd = fd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryFdInfoKHR && setFd( int fd_ ) && VULKAN_HPP_NOEXCEPT - { - fd = fd_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportMemoryFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryFdInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportMemoryFdInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleType, fd ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportMemoryFdInfoKHR const & ) const = default; -#else - bool operator==( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( fd == rhs.fd ); -# endif - } - - bool operator!=( ImportMemoryFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImportMemoryFdInfoKHR; - const void * pNext = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - int fd = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportMemoryFdInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = ImportMemoryFdInfoKHR; - }; - - // wrapper struct for struct VkImportMemoryHostPointerInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryHostPointerInfoEXT.html - struct ImportMemoryHostPointerInfoEXT - { - using NativeType = VkImportMemoryHostPointerInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryHostPointerInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - void * pHostPointer_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleType{ handleType_ } - , pHostPointer{ pHostPointer_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportMemoryHostPointerInfoEXT( ImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportMemoryHostPointerInfoEXT( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportMemoryHostPointerInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImportMemoryHostPointerInfoEXT & operator=( ImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportMemoryHostPointerInfoEXT & operator=( VkImportMemoryHostPointerInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT & setPHostPointer( void * pHostPointer_ ) & VULKAN_HPP_NOEXCEPT - { - pHostPointer = pHostPointer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryHostPointerInfoEXT && setPHostPointer( void * pHostPointer_ ) && VULKAN_HPP_NOEXCEPT - { - pHostPointer = pHostPointer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportMemoryHostPointerInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryHostPointerInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryHostPointerInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportMemoryHostPointerInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleType, pHostPointer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportMemoryHostPointerInfoEXT const & ) const = default; -#else - bool operator==( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( pHostPointer == rhs.pHostPointer ); -# endif - } - - bool operator!=( ImportMemoryHostPointerInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImportMemoryHostPointerInfoEXT; - const void * pNext = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - void * pHostPointer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportMemoryHostPointerInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ImportMemoryHostPointerInfoEXT; - }; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkImportMemoryMetalHandleInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryMetalHandleInfoEXT.html - struct ImportMemoryMetalHandleInfoEXT - { - using NativeType = VkImportMemoryMetalHandleInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryMetalHandleInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportMemoryMetalHandleInfoEXT( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - void * handle_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleType{ handleType_ } - , handle{ handle_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportMemoryMetalHandleInfoEXT( ImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportMemoryMetalHandleInfoEXT( VkImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportMemoryMetalHandleInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImportMemoryMetalHandleInfoEXT & operator=( ImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportMemoryMetalHandleInfoEXT & operator=( VkImportMemoryMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT & setHandle( void * handle_ ) & VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryMetalHandleInfoEXT && setHandle( void * handle_ ) && VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportMemoryMetalHandleInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryMetalHandleInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryMetalHandleInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportMemoryMetalHandleInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleType, handle ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportMemoryMetalHandleInfoEXT const & ) const = default; -# else - bool operator==( ImportMemoryMetalHandleInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ); -# endif - } - - bool operator!=( ImportMemoryMetalHandleInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportMemoryMetalHandleInfoEXT; - const void * pNext = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - void * handle = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportMemoryMetalHandleInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ImportMemoryMetalHandleInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkImportMemoryWin32HandleInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryWin32HandleInfoKHR.html - struct ImportMemoryWin32HandleInfoKHR - { - using NativeType = VkImportMemoryWin32HandleInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryWin32HandleInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = {}, - LPCWSTR name_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleType{ handleType_ } - , handle{ handle_ } - , name{ name_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoKHR( ImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportMemoryWin32HandleInfoKHR( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportMemoryWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ImportMemoryWin32HandleInfoKHR & operator=( ImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportMemoryWin32HandleInfoKHR & operator=( VkImportMemoryWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR & setHandle( HANDLE handle_ ) & VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR && setHandle( HANDLE handle_ ) && VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT - { - name = name_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT - { - name = name_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportMemoryWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportMemoryWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleType, handle, name ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportMemoryWin32HandleInfoKHR const & ) const = default; -# else - bool operator==( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ) && ( name == rhs.name ); -# endif - } - - bool operator!=( ImportMemoryWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportMemoryWin32HandleInfoKHR; - const void * pNext = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - HANDLE handle = {}; - LPCWSTR name = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportMemoryWin32HandleInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = ImportMemoryWin32HandleInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkImportMemoryWin32HandleInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryWin32HandleInfoNV.html - struct ImportMemoryWin32HandleInfoNV - { - using NativeType = VkImportMemoryWin32HandleInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryWin32HandleInfoNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - ImportMemoryWin32HandleInfoNV( ExternalMemoryHandleTypeFlagsNV handleType_ = {}, HANDLE handle_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleType{ handleType_ } - , handle{ handle_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportMemoryWin32HandleInfoNV( ImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportMemoryWin32HandleInfoNV( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportMemoryWin32HandleInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - ImportMemoryWin32HandleInfoNV & operator=( ImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportMemoryWin32HandleInfoNV & operator=( VkImportMemoryWin32HandleInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV & setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV && setHandleType( ExternalMemoryHandleTypeFlagsNV handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV & setHandle( HANDLE handle_ ) & VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryWin32HandleInfoNV && setHandle( HANDLE handle_ ) && VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportMemoryWin32HandleInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryWin32HandleInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryWin32HandleInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportMemoryWin32HandleInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleType, handle ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportMemoryWin32HandleInfoNV const & ) const = default; -# else - bool operator==( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && ( handle == rhs.handle ); -# endif - } - - bool operator!=( ImportMemoryWin32HandleInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportMemoryWin32HandleInfoNV; - const void * pNext = {}; - ExternalMemoryHandleTypeFlagsNV handleType = {}; - HANDLE handle = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportMemoryWin32HandleInfoNV; - }; -# endif - - template <> - struct CppType - { - using Type = ImportMemoryWin32HandleInfoNV; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkImportMemoryZirconHandleInfoFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMemoryZirconHandleInfoFUCHSIA.html - struct ImportMemoryZirconHandleInfoFUCHSIA - { - using NativeType = VkImportMemoryZirconHandleInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMemoryZirconHandleInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportMemoryZirconHandleInfoFUCHSIA( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - zx_handle_t handle_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleType{ handleType_ } - , handle{ handle_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportMemoryZirconHandleInfoFUCHSIA( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportMemoryZirconHandleInfoFUCHSIA( VkImportMemoryZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportMemoryZirconHandleInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - ImportMemoryZirconHandleInfoFUCHSIA & operator=( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportMemoryZirconHandleInfoFUCHSIA & operator=( VkImportMemoryZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA & setHandle( zx_handle_t handle_ ) & VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMemoryZirconHandleInfoFUCHSIA && setHandle( zx_handle_t handle_ ) && VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportMemoryZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMemoryZirconHandleInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportMemoryZirconHandleInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleType, handle ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = handleType <=> rhs.handleType; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &handle, &rhs.handle, sizeof( zx_handle_t ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -# endif - - bool operator==( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ) && - ( memcmp( &handle, &rhs.handle, sizeof( zx_handle_t ) ) == 0 ); - } - - bool operator!=( ImportMemoryZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eImportMemoryZirconHandleInfoFUCHSIA; - const void * pNext = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - zx_handle_t handle = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportMemoryZirconHandleInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = ImportMemoryZirconHandleInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkImportMetalBufferInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMetalBufferInfoEXT.html - struct ImportMetalBufferInfoEXT - { - using NativeType = VkImportMetalBufferInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMetalBufferInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportMetalBufferInfoEXT( MTLBuffer_id mtlBuffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , mtlBuffer{ mtlBuffer_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportMetalBufferInfoEXT( ImportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportMetalBufferInfoEXT( VkImportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportMetalBufferInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImportMetalBufferInfoEXT & operator=( ImportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportMetalBufferInfoEXT & operator=( VkImportMetalBufferInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportMetalBufferInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalBufferInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalBufferInfoEXT & setMtlBuffer( MTLBuffer_id mtlBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - mtlBuffer = mtlBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalBufferInfoEXT && setMtlBuffer( MTLBuffer_id mtlBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - mtlBuffer = mtlBuffer_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportMetalBufferInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMetalBufferInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMetalBufferInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportMetalBufferInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, mtlBuffer ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportMetalBufferInfoEXT const & ) const = default; -# else - bool operator==( ImportMetalBufferInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mtlBuffer == rhs.mtlBuffer ); -# endif - } - - bool operator!=( ImportMetalBufferInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportMetalBufferInfoEXT; - const void * pNext = {}; - MTLBuffer_id mtlBuffer = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportMetalBufferInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ImportMetalBufferInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkImportMetalIOSurfaceInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMetalIOSurfaceInfoEXT.html - struct ImportMetalIOSurfaceInfoEXT - { - using NativeType = VkImportMetalIOSurfaceInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMetalIoSurfaceInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportMetalIOSurfaceInfoEXT( IOSurfaceRef ioSurface_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , ioSurface{ ioSurface_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportMetalIOSurfaceInfoEXT( ImportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportMetalIOSurfaceInfoEXT( VkImportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportMetalIOSurfaceInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImportMetalIOSurfaceInfoEXT & operator=( ImportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportMetalIOSurfaceInfoEXT & operator=( VkImportMetalIOSurfaceInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportMetalIOSurfaceInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalIOSurfaceInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalIOSurfaceInfoEXT & setIoSurface( IOSurfaceRef ioSurface_ ) & VULKAN_HPP_NOEXCEPT - { - ioSurface = ioSurface_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalIOSurfaceInfoEXT && setIoSurface( IOSurfaceRef ioSurface_ ) && VULKAN_HPP_NOEXCEPT - { - ioSurface = ioSurface_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportMetalIOSurfaceInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMetalIOSurfaceInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMetalIOSurfaceInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportMetalIOSurfaceInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, ioSurface ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportMetalIOSurfaceInfoEXT const & ) const = default; -# else - bool operator==( ImportMetalIOSurfaceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ioSurface == rhs.ioSurface ); -# endif - } - - bool operator!=( ImportMetalIOSurfaceInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportMetalIoSurfaceInfoEXT; - const void * pNext = {}; - IOSurfaceRef ioSurface = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportMetalIOSurfaceInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ImportMetalIOSurfaceInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkImportMetalSharedEventInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMetalSharedEventInfoEXT.html - struct ImportMetalSharedEventInfoEXT - { - using NativeType = VkImportMetalSharedEventInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMetalSharedEventInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportMetalSharedEventInfoEXT( MTLSharedEvent_id mtlSharedEvent_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , mtlSharedEvent{ mtlSharedEvent_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportMetalSharedEventInfoEXT( ImportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportMetalSharedEventInfoEXT( VkImportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportMetalSharedEventInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImportMetalSharedEventInfoEXT & operator=( ImportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportMetalSharedEventInfoEXT & operator=( VkImportMetalSharedEventInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportMetalSharedEventInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalSharedEventInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalSharedEventInfoEXT & setMtlSharedEvent( MTLSharedEvent_id mtlSharedEvent_ ) & VULKAN_HPP_NOEXCEPT - { - mtlSharedEvent = mtlSharedEvent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalSharedEventInfoEXT && setMtlSharedEvent( MTLSharedEvent_id mtlSharedEvent_ ) && VULKAN_HPP_NOEXCEPT - { - mtlSharedEvent = mtlSharedEvent_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportMetalSharedEventInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMetalSharedEventInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMetalSharedEventInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportMetalSharedEventInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, mtlSharedEvent ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportMetalSharedEventInfoEXT const & ) const = default; -# else - bool operator==( ImportMetalSharedEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mtlSharedEvent == rhs.mtlSharedEvent ); -# endif - } - - bool operator!=( ImportMetalSharedEventInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportMetalSharedEventInfoEXT; - const void * pNext = {}; - MTLSharedEvent_id mtlSharedEvent = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportMetalSharedEventInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ImportMetalSharedEventInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkImportMetalTextureInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportMetalTextureInfoEXT.html - struct ImportMetalTextureInfoEXT - { - using NativeType = VkImportMetalTextureInfoEXT; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportMetalTextureInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportMetalTextureInfoEXT( ImageAspectFlagBits plane_ = ImageAspectFlagBits::eColor, - MTLTexture_id mtlTexture_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , plane{ plane_ } - , mtlTexture{ mtlTexture_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportMetalTextureInfoEXT( ImportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportMetalTextureInfoEXT( VkImportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportMetalTextureInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ImportMetalTextureInfoEXT & operator=( ImportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportMetalTextureInfoEXT & operator=( VkImportMetalTextureInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT & setPlane( ImageAspectFlagBits plane_ ) & VULKAN_HPP_NOEXCEPT - { - plane = plane_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT && setPlane( ImageAspectFlagBits plane_ ) && VULKAN_HPP_NOEXCEPT - { - plane = plane_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT & setMtlTexture( MTLTexture_id mtlTexture_ ) & VULKAN_HPP_NOEXCEPT - { - mtlTexture = mtlTexture_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportMetalTextureInfoEXT && setMtlTexture( MTLTexture_id mtlTexture_ ) && VULKAN_HPP_NOEXCEPT - { - mtlTexture = mtlTexture_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportMetalTextureInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMetalTextureInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportMetalTextureInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportMetalTextureInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, plane, mtlTexture ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportMetalTextureInfoEXT const & ) const = default; -# else - bool operator==( ImportMetalTextureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( plane == rhs.plane ) && ( mtlTexture == rhs.mtlTexture ); -# endif - } - - bool operator!=( ImportMetalTextureInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportMetalTextureInfoEXT; - const void * pNext = {}; - ImageAspectFlagBits plane = ImageAspectFlagBits::eColor; - MTLTexture_id mtlTexture = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportMetalTextureInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = ImportMetalTextureInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_OHOS ) - // wrapper struct for struct VkImportNativeBufferInfoOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportNativeBufferInfoOHOS.html - struct ImportNativeBufferInfoOHOS - { - using NativeType = VkImportNativeBufferInfoOHOS; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportNativeBufferInfoOHOS; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportNativeBufferInfoOHOS( struct OH_NativeBuffer * buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , buffer{ buffer_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportNativeBufferInfoOHOS( ImportNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportNativeBufferInfoOHOS( VkImportNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportNativeBufferInfoOHOS( *reinterpret_cast( &rhs ) ) - { - } - - ImportNativeBufferInfoOHOS & operator=( ImportNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportNativeBufferInfoOHOS & operator=( VkImportNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportNativeBufferInfoOHOS & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportNativeBufferInfoOHOS && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportNativeBufferInfoOHOS & setBuffer( struct OH_NativeBuffer * buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportNativeBufferInfoOHOS && setBuffer( struct OH_NativeBuffer * buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportNativeBufferInfoOHOS const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportNativeBufferInfoOHOS &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportNativeBufferInfoOHOS const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportNativeBufferInfoOHOS *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, buffer ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportNativeBufferInfoOHOS const & ) const = default; -# else - bool operator==( ImportNativeBufferInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); -# endif - } - - bool operator!=( ImportNativeBufferInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportNativeBufferInfoOHOS; - const void * pNext = {}; - struct OH_NativeBuffer * buffer = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportNativeBufferInfoOHOS; - }; -# endif - - template <> - struct CppType - { - using Type = ImportNativeBufferInfoOHOS; - }; -#endif /*VK_USE_PLATFORM_OHOS*/ - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - // wrapper struct for struct VkImportScreenBufferInfoQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportScreenBufferInfoQNX.html - struct ImportScreenBufferInfoQNX - { - using NativeType = VkImportScreenBufferInfoQNX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportScreenBufferInfoQNX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportScreenBufferInfoQNX( struct _screen_buffer * buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , buffer{ buffer_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportScreenBufferInfoQNX( ImportScreenBufferInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportScreenBufferInfoQNX( VkImportScreenBufferInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportScreenBufferInfoQNX( *reinterpret_cast( &rhs ) ) - { - } - - ImportScreenBufferInfoQNX & operator=( ImportScreenBufferInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportScreenBufferInfoQNX & operator=( VkImportScreenBufferInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportScreenBufferInfoQNX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportScreenBufferInfoQNX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportScreenBufferInfoQNX & setBuffer( struct _screen_buffer * buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportScreenBufferInfoQNX && setBuffer( struct _screen_buffer * buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportScreenBufferInfoQNX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportScreenBufferInfoQNX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportScreenBufferInfoQNX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportScreenBufferInfoQNX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, buffer ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportScreenBufferInfoQNX const & ) const = default; -# else - bool operator==( ImportScreenBufferInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( buffer == rhs.buffer ); -# endif - } - - bool operator!=( ImportScreenBufferInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportScreenBufferInfoQNX; - const void * pNext = {}; - struct _screen_buffer * buffer = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportScreenBufferInfoQNX; - }; -# endif - - template <> - struct CppType - { - using Type = ImportScreenBufferInfoQNX; - }; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - // wrapper struct for struct VkImportSemaphoreFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportSemaphoreFdInfoKHR.html - struct ImportSemaphoreFdInfoKHR - { - using NativeType = VkImportSemaphoreFdInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportSemaphoreFdInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( Semaphore semaphore_ = {}, - SemaphoreImportFlags flags_ = {}, - ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - int fd_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , semaphore{ semaphore_ } - , flags{ flags_ } - , handleType{ handleType_ } - , fd{ fd_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportSemaphoreFdInfoKHR( ImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportSemaphoreFdInfoKHR( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportSemaphoreFdInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ImportSemaphoreFdInfoKHR & operator=( ImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportSemaphoreFdInfoKHR & operator=( VkImportSemaphoreFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR & setFlags( SemaphoreImportFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR && setFlags( SemaphoreImportFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR & setFd( int fd_ ) & VULKAN_HPP_NOEXCEPT - { - fd = fd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreFdInfoKHR && setFd( int fd_ ) && VULKAN_HPP_NOEXCEPT - { - fd = fd_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportSemaphoreFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportSemaphoreFdInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportSemaphoreFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportSemaphoreFdInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, semaphore, flags, handleType, fd ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportSemaphoreFdInfoKHR const & ) const = default; -#else - bool operator==( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && - ( fd == rhs.fd ); -# endif - } - - bool operator!=( ImportSemaphoreFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eImportSemaphoreFdInfoKHR; - const void * pNext = {}; - Semaphore semaphore = {}; - SemaphoreImportFlags flags = {}; - ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; - int fd = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportSemaphoreFdInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = ImportSemaphoreFdInfoKHR; - }; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkImportSemaphoreWin32HandleInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportSemaphoreWin32HandleInfoKHR.html - struct ImportSemaphoreWin32HandleInfoKHR - { - using NativeType = VkImportSemaphoreWin32HandleInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportSemaphoreWin32HandleInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( Semaphore semaphore_ = {}, - SemaphoreImportFlags flags_ = {}, - ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - HANDLE handle_ = {}, - LPCWSTR name_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , semaphore{ semaphore_ } - , flags{ flags_ } - , handleType{ handleType_ } - , handle{ handle_ } - , name{ name_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportSemaphoreWin32HandleInfoKHR( ImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportSemaphoreWin32HandleInfoKHR( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportSemaphoreWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ImportSemaphoreWin32HandleInfoKHR & operator=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportSemaphoreWin32HandleInfoKHR & operator=( VkImportSemaphoreWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setFlags( SemaphoreImportFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setFlags( SemaphoreImportFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setHandle( HANDLE handle_ ) & VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setHandle( HANDLE handle_ ) && VULKAN_HPP_NOEXCEPT - { - handle = handle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR & setName( LPCWSTR name_ ) & VULKAN_HPP_NOEXCEPT - { - name = name_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreWin32HandleInfoKHR && setName( LPCWSTR name_ ) && VULKAN_HPP_NOEXCEPT - { - name = name_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportSemaphoreWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportSemaphoreWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportSemaphoreWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportSemaphoreWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, semaphore, flags, handleType, handle, name ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ImportSemaphoreWin32HandleInfoKHR const & ) const = default; -# else - bool operator==( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && - ( handle == rhs.handle ) && ( name == rhs.name ); -# endif - } - - bool operator!=( ImportSemaphoreWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eImportSemaphoreWin32HandleInfoKHR; - const void * pNext = {}; - Semaphore semaphore = {}; - SemaphoreImportFlags flags = {}; - ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; - HANDLE handle = {}; - LPCWSTR name = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportSemaphoreWin32HandleInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = ImportSemaphoreWin32HandleInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkImportSemaphoreZirconHandleInfoFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkImportSemaphoreZirconHandleInfoFUCHSIA.html - struct ImportSemaphoreZirconHandleInfoFUCHSIA - { - using NativeType = VkImportSemaphoreZirconHandleInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eImportSemaphoreZirconHandleInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - ImportSemaphoreZirconHandleInfoFUCHSIA( Semaphore semaphore_ = {}, - SemaphoreImportFlags flags_ = {}, - ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - zx_handle_t zirconHandle_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , semaphore{ semaphore_ } - , flags{ flags_ } - , handleType{ handleType_ } - , zirconHandle{ zirconHandle_ } - { - } - - VULKAN_HPP_CONSTEXPR ImportSemaphoreZirconHandleInfoFUCHSIA( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ImportSemaphoreZirconHandleInfoFUCHSIA( VkImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : ImportSemaphoreZirconHandleInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - ImportSemaphoreZirconHandleInfoFUCHSIA & operator=( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ImportSemaphoreZirconHandleInfoFUCHSIA & operator=( VkImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA & setFlags( SemaphoreImportFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA && setFlags( SemaphoreImportFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA & setZirconHandle( zx_handle_t zirconHandle_ ) & VULKAN_HPP_NOEXCEPT - { - zirconHandle = zirconHandle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ImportSemaphoreZirconHandleInfoFUCHSIA && setZirconHandle( zx_handle_t zirconHandle_ ) && VULKAN_HPP_NOEXCEPT - { - zirconHandle = zirconHandle_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkImportSemaphoreZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportSemaphoreZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkImportSemaphoreZirconHandleInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkImportSemaphoreZirconHandleInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, semaphore, flags, handleType, zirconHandle ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = semaphore <=> rhs.semaphore; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = handleType <=> rhs.handleType; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &zirconHandle, &rhs.zirconHandle, sizeof( zx_handle_t ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -# endif - - bool operator==( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( flags == rhs.flags ) && ( handleType == rhs.handleType ) && - ( memcmp( &zirconHandle, &rhs.zirconHandle, sizeof( zx_handle_t ) ) == 0 ); - } - - bool operator!=( ImportSemaphoreZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eImportSemaphoreZirconHandleInfoFUCHSIA; - const void * pNext = {}; - Semaphore semaphore = {}; - SemaphoreImportFlags flags = {}; - ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; - zx_handle_t zirconHandle = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ImportSemaphoreZirconHandleInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = ImportSemaphoreZirconHandleInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - // wrapper struct for struct VkIndirectCommandsExecutionSetTokenEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsExecutionSetTokenEXT.html - struct IndirectCommandsExecutionSetTokenEXT - { - using NativeType = VkIndirectCommandsExecutionSetTokenEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR IndirectCommandsExecutionSetTokenEXT( IndirectExecutionSetInfoTypeEXT type_ = IndirectExecutionSetInfoTypeEXT::ePipelines, - ShaderStageFlags shaderStages_ = {} ) VULKAN_HPP_NOEXCEPT - : type{ type_ } - , shaderStages{ shaderStages_ } - { - } - - VULKAN_HPP_CONSTEXPR IndirectCommandsExecutionSetTokenEXT( IndirectCommandsExecutionSetTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectCommandsExecutionSetTokenEXT( VkIndirectCommandsExecutionSetTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectCommandsExecutionSetTokenEXT( *reinterpret_cast( &rhs ) ) - { - } - - IndirectCommandsExecutionSetTokenEXT & operator=( IndirectCommandsExecutionSetTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectCommandsExecutionSetTokenEXT & operator=( VkIndirectCommandsExecutionSetTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsExecutionSetTokenEXT & setType( IndirectExecutionSetInfoTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsExecutionSetTokenEXT && setType( IndirectExecutionSetInfoTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsExecutionSetTokenEXT & setShaderStages( ShaderStageFlags shaderStages_ ) & VULKAN_HPP_NOEXCEPT - { - shaderStages = shaderStages_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsExecutionSetTokenEXT && setShaderStages( ShaderStageFlags shaderStages_ ) && VULKAN_HPP_NOEXCEPT - { - shaderStages = shaderStages_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectCommandsExecutionSetTokenEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsExecutionSetTokenEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsExecutionSetTokenEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectCommandsExecutionSetTokenEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( type, shaderStages ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectCommandsExecutionSetTokenEXT const & ) const = default; -#else - bool operator==( IndirectCommandsExecutionSetTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( type == rhs.type ) && ( shaderStages == rhs.shaderStages ); -# endif - } - - bool operator!=( IndirectCommandsExecutionSetTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - IndirectExecutionSetInfoTypeEXT type = IndirectExecutionSetInfoTypeEXT::ePipelines; - ShaderStageFlags shaderStages = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectCommandsExecutionSetTokenEXT; - }; -#endif - - // wrapper struct for struct VkIndirectCommandsIndexBufferTokenEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsIndexBufferTokenEXT.html - struct IndirectCommandsIndexBufferTokenEXT - { - using NativeType = VkIndirectCommandsIndexBufferTokenEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR IndirectCommandsIndexBufferTokenEXT( - IndirectCommandsInputModeFlagBitsEXT mode_ = IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer ) VULKAN_HPP_NOEXCEPT : mode{ mode_ } - { - } - - VULKAN_HPP_CONSTEXPR IndirectCommandsIndexBufferTokenEXT( IndirectCommandsIndexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectCommandsIndexBufferTokenEXT( VkIndirectCommandsIndexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectCommandsIndexBufferTokenEXT( *reinterpret_cast( &rhs ) ) - { - } - - IndirectCommandsIndexBufferTokenEXT & operator=( IndirectCommandsIndexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectCommandsIndexBufferTokenEXT & operator=( VkIndirectCommandsIndexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsIndexBufferTokenEXT & setMode( IndirectCommandsInputModeFlagBitsEXT mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsIndexBufferTokenEXT && setMode( IndirectCommandsInputModeFlagBitsEXT mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectCommandsIndexBufferTokenEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsIndexBufferTokenEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsIndexBufferTokenEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectCommandsIndexBufferTokenEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( mode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectCommandsIndexBufferTokenEXT const & ) const = default; -#else - bool operator==( IndirectCommandsIndexBufferTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( mode == rhs.mode ); -# endif - } - - bool operator!=( IndirectCommandsIndexBufferTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - IndirectCommandsInputModeFlagBitsEXT mode = IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectCommandsIndexBufferTokenEXT; - }; -#endif - - // wrapper struct for struct VkPushConstantRange, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushConstantRange.html - struct PushConstantRange - { - using NativeType = VkPushConstantRange; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PushConstantRange( ShaderStageFlags stageFlags_ = {}, uint32_t offset_ = {}, uint32_t size_ = {} ) VULKAN_HPP_NOEXCEPT - : stageFlags{ stageFlags_ } - , offset{ offset_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR PushConstantRange( PushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PushConstantRange( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT : PushConstantRange( *reinterpret_cast( &rhs ) ) {} - - PushConstantRange & operator=( PushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PushConstantRange & operator=( VkPushConstantRange const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PushConstantRange & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantRange && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantRange & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantRange && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantRange & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantRange && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPushConstantRange const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushConstantRange &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushConstantRange const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPushConstantRange *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( stageFlags, offset, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PushConstantRange const & ) const = default; -#else - bool operator==( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( stageFlags == rhs.stageFlags ) && ( offset == rhs.offset ) && ( size == rhs.size ); -# endif - } - - bool operator!=( PushConstantRange const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ShaderStageFlags stageFlags = {}; - uint32_t offset = {}; - uint32_t size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PushConstantRange; - }; -#endif - - // wrapper struct for struct VkIndirectCommandsPushConstantTokenEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsPushConstantTokenEXT.html - struct IndirectCommandsPushConstantTokenEXT - { - using NativeType = VkIndirectCommandsPushConstantTokenEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR IndirectCommandsPushConstantTokenEXT( PushConstantRange updateRange_ = {} ) VULKAN_HPP_NOEXCEPT : updateRange{ updateRange_ } {} - - VULKAN_HPP_CONSTEXPR IndirectCommandsPushConstantTokenEXT( IndirectCommandsPushConstantTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectCommandsPushConstantTokenEXT( VkIndirectCommandsPushConstantTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectCommandsPushConstantTokenEXT( *reinterpret_cast( &rhs ) ) - { - } - - IndirectCommandsPushConstantTokenEXT & operator=( IndirectCommandsPushConstantTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectCommandsPushConstantTokenEXT & operator=( VkIndirectCommandsPushConstantTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsPushConstantTokenEXT & setUpdateRange( PushConstantRange const & updateRange_ ) & VULKAN_HPP_NOEXCEPT - { - updateRange = updateRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsPushConstantTokenEXT && setUpdateRange( PushConstantRange const & updateRange_ ) && VULKAN_HPP_NOEXCEPT - { - updateRange = updateRange_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectCommandsPushConstantTokenEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsPushConstantTokenEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsPushConstantTokenEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectCommandsPushConstantTokenEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( updateRange ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectCommandsPushConstantTokenEXT const & ) const = default; -#else - bool operator==( IndirectCommandsPushConstantTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( updateRange == rhs.updateRange ); -# endif - } - - bool operator!=( IndirectCommandsPushConstantTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - PushConstantRange updateRange = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectCommandsPushConstantTokenEXT; - }; -#endif - - // wrapper struct for struct VkIndirectCommandsVertexBufferTokenEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsVertexBufferTokenEXT.html - struct IndirectCommandsVertexBufferTokenEXT - { - using NativeType = VkIndirectCommandsVertexBufferTokenEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR IndirectCommandsVertexBufferTokenEXT( uint32_t vertexBindingUnit_ = {} ) VULKAN_HPP_NOEXCEPT : vertexBindingUnit{ vertexBindingUnit_ } - { - } - - VULKAN_HPP_CONSTEXPR IndirectCommandsVertexBufferTokenEXT( IndirectCommandsVertexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectCommandsVertexBufferTokenEXT( VkIndirectCommandsVertexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectCommandsVertexBufferTokenEXT( *reinterpret_cast( &rhs ) ) - { - } - - IndirectCommandsVertexBufferTokenEXT & operator=( IndirectCommandsVertexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectCommandsVertexBufferTokenEXT & operator=( VkIndirectCommandsVertexBufferTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsVertexBufferTokenEXT & setVertexBindingUnit( uint32_t vertexBindingUnit_ ) & VULKAN_HPP_NOEXCEPT - { - vertexBindingUnit = vertexBindingUnit_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsVertexBufferTokenEXT && setVertexBindingUnit( uint32_t vertexBindingUnit_ ) && VULKAN_HPP_NOEXCEPT - { - vertexBindingUnit = vertexBindingUnit_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectCommandsVertexBufferTokenEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsVertexBufferTokenEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsVertexBufferTokenEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectCommandsVertexBufferTokenEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( vertexBindingUnit ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectCommandsVertexBufferTokenEXT const & ) const = default; -#else - bool operator==( IndirectCommandsVertexBufferTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( vertexBindingUnit == rhs.vertexBindingUnit ); -# endif - } - - bool operator!=( IndirectCommandsVertexBufferTokenEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t vertexBindingUnit = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectCommandsVertexBufferTokenEXT; - }; -#endif - - union IndirectCommandsTokenDataEXT - { - using NativeType = VkIndirectCommandsTokenDataEXT; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT( const IndirectCommandsPushConstantTokenEXT * pPushConstant_ = {} ) : pPushConstant( pPushConstant_ ) - { - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT( const IndirectCommandsVertexBufferTokenEXT * pVertexBuffer_ ) : pVertexBuffer( pVertexBuffer_ ) {} - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT( const IndirectCommandsIndexBufferTokenEXT * pIndexBuffer_ ) : pIndexBuffer( pIndexBuffer_ ) {} - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT( const IndirectCommandsExecutionSetTokenEXT * pExecutionSet_ ) : pExecutionSet( pExecutionSet_ ) {} -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT & setPPushConstant( const IndirectCommandsPushConstantTokenEXT * pPushConstant_ ) & VULKAN_HPP_NOEXCEPT - { - pPushConstant = pPushConstant_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT && setPPushConstant( const IndirectCommandsPushConstantTokenEXT * pPushConstant_ ) && - VULKAN_HPP_NOEXCEPT - { - pPushConstant = pPushConstant_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT & setPVertexBuffer( const IndirectCommandsVertexBufferTokenEXT * pVertexBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - pVertexBuffer = pVertexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT && setPVertexBuffer( const IndirectCommandsVertexBufferTokenEXT * pVertexBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - pVertexBuffer = pVertexBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT & setPIndexBuffer( const IndirectCommandsIndexBufferTokenEXT * pIndexBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - pIndexBuffer = pIndexBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT && setPIndexBuffer( const IndirectCommandsIndexBufferTokenEXT * pIndexBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - pIndexBuffer = pIndexBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT & setPExecutionSet( const IndirectCommandsExecutionSetTokenEXT * pExecutionSet_ ) & VULKAN_HPP_NOEXCEPT - { - pExecutionSet = pExecutionSet_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsTokenDataEXT && setPExecutionSet( const IndirectCommandsExecutionSetTokenEXT * pExecutionSet_ ) && - VULKAN_HPP_NOEXCEPT - { - pExecutionSet = pExecutionSet_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectCommandsTokenDataEXT const &() const - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsTokenDataEXT &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - const IndirectCommandsPushConstantTokenEXT * pPushConstant; - const IndirectCommandsVertexBufferTokenEXT * pVertexBuffer; - const IndirectCommandsIndexBufferTokenEXT * pIndexBuffer; - const IndirectCommandsExecutionSetTokenEXT * pExecutionSet; -#else - const VkIndirectCommandsPushConstantTokenEXT * pPushConstant; - const VkIndirectCommandsVertexBufferTokenEXT * pVertexBuffer; - const VkIndirectCommandsIndexBufferTokenEXT * pIndexBuffer; - const VkIndirectCommandsExecutionSetTokenEXT * pExecutionSet; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectCommandsTokenDataEXT; - }; -#endif - - // wrapper struct for struct VkIndirectCommandsLayoutTokenEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutTokenEXT.html - struct IndirectCommandsLayoutTokenEXT - { - using NativeType = VkIndirectCommandsLayoutTokenEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutTokenEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT( IndirectCommandsTokenTypeEXT type_ = IndirectCommandsTokenTypeEXT::eExecutionSet, - IndirectCommandsTokenDataEXT data_ = {}, - uint32_t offset_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , data{ data_ } - , offset{ offset_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT( IndirectCommandsLayoutTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectCommandsLayoutTokenEXT( VkIndirectCommandsLayoutTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectCommandsLayoutTokenEXT( *reinterpret_cast( &rhs ) ) - { - } - - IndirectCommandsLayoutTokenEXT & operator=( IndirectCommandsLayoutTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectCommandsLayoutTokenEXT & operator=( VkIndirectCommandsLayoutTokenEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT & setType( IndirectCommandsTokenTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT && setType( IndirectCommandsTokenTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT & setData( IndirectCommandsTokenDataEXT const & data_ ) & VULKAN_HPP_NOEXCEPT - { - data = data_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT && setData( IndirectCommandsTokenDataEXT const & data_ ) && VULKAN_HPP_NOEXCEPT - { - data = data_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenEXT && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectCommandsLayoutTokenEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutTokenEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutTokenEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutTokenEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, type, data, offset ); - } -#endif - - public: - StructureType sType = StructureType::eIndirectCommandsLayoutTokenEXT; - const void * pNext = {}; - IndirectCommandsTokenTypeEXT type = IndirectCommandsTokenTypeEXT::eExecutionSet; - IndirectCommandsTokenDataEXT data = {}; - uint32_t offset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectCommandsLayoutTokenEXT; - }; -#endif - - template <> - struct CppType - { - using Type = IndirectCommandsLayoutTokenEXT; - }; - - // wrapper struct for struct VkIndirectCommandsLayoutCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutCreateInfoEXT.html - struct IndirectCommandsLayoutCreateInfoEXT - { - using NativeType = VkIndirectCommandsLayoutCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoEXT( IndirectCommandsLayoutUsageFlagsEXT flags_ = {}, - ShaderStageFlags shaderStages_ = {}, - uint32_t indirectStride_ = {}, - PipelineLayout pipelineLayout_ = {}, - uint32_t tokenCount_ = {}, - const IndirectCommandsLayoutTokenEXT * pTokens_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , shaderStages{ shaderStages_ } - , indirectStride{ indirectStride_ } - , pipelineLayout{ pipelineLayout_ } - , tokenCount{ tokenCount_ } - , pTokens{ pTokens_ } - { - } - - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoEXT( IndirectCommandsLayoutCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectCommandsLayoutCreateInfoEXT( VkIndirectCommandsLayoutCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectCommandsLayoutCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectCommandsLayoutCreateInfoEXT( IndirectCommandsLayoutUsageFlagsEXT flags_, - ShaderStageFlags shaderStages_, - uint32_t indirectStride_, - PipelineLayout pipelineLayout_, - ArrayProxyNoTemporaries const & tokens_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , shaderStages( shaderStages_ ) - , indirectStride( indirectStride_ ) - , pipelineLayout( pipelineLayout_ ) - , tokenCount( static_cast( tokens_.size() ) ) - , pTokens( tokens_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - IndirectCommandsLayoutCreateInfoEXT & operator=( IndirectCommandsLayoutCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectCommandsLayoutCreateInfoEXT & operator=( VkIndirectCommandsLayoutCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setFlags( IndirectCommandsLayoutUsageFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setFlags( IndirectCommandsLayoutUsageFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setShaderStages( ShaderStageFlags shaderStages_ ) & VULKAN_HPP_NOEXCEPT - { - shaderStages = shaderStages_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setShaderStages( ShaderStageFlags shaderStages_ ) && VULKAN_HPP_NOEXCEPT - { - shaderStages = shaderStages_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setIndirectStride( uint32_t indirectStride_ ) & VULKAN_HPP_NOEXCEPT - { - indirectStride = indirectStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setIndirectStride( uint32_t indirectStride_ ) && VULKAN_HPP_NOEXCEPT - { - indirectStride = indirectStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setPipelineLayout( PipelineLayout pipelineLayout_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineLayout = pipelineLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setPipelineLayout( PipelineLayout pipelineLayout_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineLayout = pipelineLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setTokenCount( uint32_t tokenCount_ ) & VULKAN_HPP_NOEXCEPT - { - tokenCount = tokenCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setTokenCount( uint32_t tokenCount_ ) && VULKAN_HPP_NOEXCEPT - { - tokenCount = tokenCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT & setPTokens( const IndirectCommandsLayoutTokenEXT * pTokens_ ) & VULKAN_HPP_NOEXCEPT - { - pTokens = pTokens_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoEXT && setPTokens( const IndirectCommandsLayoutTokenEXT * pTokens_ ) && VULKAN_HPP_NOEXCEPT - { - pTokens = pTokens_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectCommandsLayoutCreateInfoEXT & setTokens( ArrayProxyNoTemporaries const & tokens_ ) VULKAN_HPP_NOEXCEPT - { - tokenCount = static_cast( tokens_.size() ); - pTokens = tokens_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectCommandsLayoutCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, shaderStages, indirectStride, pipelineLayout, tokenCount, pTokens ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectCommandsLayoutCreateInfoEXT const & ) const = default; -#else - bool operator==( IndirectCommandsLayoutCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( shaderStages == rhs.shaderStages ) && - ( indirectStride == rhs.indirectStride ) && ( pipelineLayout == rhs.pipelineLayout ) && ( tokenCount == rhs.tokenCount ) && - ( pTokens == rhs.pTokens ); -# endif - } - - bool operator!=( IndirectCommandsLayoutCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoEXT; - const void * pNext = {}; - IndirectCommandsLayoutUsageFlagsEXT flags = {}; - ShaderStageFlags shaderStages = {}; - uint32_t indirectStride = {}; - PipelineLayout pipelineLayout = {}; - uint32_t tokenCount = {}; - const IndirectCommandsLayoutTokenEXT * pTokens = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectCommandsLayoutCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = IndirectCommandsLayoutCreateInfoEXT; - }; - - // wrapper struct for struct VkIndirectCommandsLayoutTokenNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutTokenNV.html - struct IndirectCommandsLayoutTokenNV - { - using NativeType = VkIndirectCommandsLayoutTokenNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutTokenNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNV( IndirectCommandsTokenTypeNV tokenType_ = IndirectCommandsTokenTypeNV::eShaderGroup, - uint32_t stream_ = {}, - uint32_t offset_ = {}, - uint32_t vertexBindingUnit_ = {}, - Bool32 vertexDynamicStride_ = {}, - PipelineLayout pushconstantPipelineLayout_ = {}, - ShaderStageFlags pushconstantShaderStageFlags_ = {}, - uint32_t pushconstantOffset_ = {}, - uint32_t pushconstantSize_ = {}, - IndirectStateFlagsNV indirectStateFlags_ = {}, - uint32_t indexTypeCount_ = {}, - const IndexType * pIndexTypes_ = {}, - const uint32_t * pIndexTypeValues_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tokenType{ tokenType_ } - , stream{ stream_ } - , offset{ offset_ } - , vertexBindingUnit{ vertexBindingUnit_ } - , vertexDynamicStride{ vertexDynamicStride_ } - , pushconstantPipelineLayout{ pushconstantPipelineLayout_ } - , pushconstantShaderStageFlags{ pushconstantShaderStageFlags_ } - , pushconstantOffset{ pushconstantOffset_ } - , pushconstantSize{ pushconstantSize_ } - , indirectStateFlags{ indirectStateFlags_ } - , indexTypeCount{ indexTypeCount_ } - , pIndexTypes{ pIndexTypes_ } - , pIndexTypeValues{ pIndexTypeValues_ } - { - } - - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutTokenNV( IndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectCommandsLayoutTokenNV( VkIndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectCommandsLayoutTokenNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectCommandsLayoutTokenNV( IndirectCommandsTokenTypeNV tokenType_, - uint32_t stream_, - uint32_t offset_, - uint32_t vertexBindingUnit_, - Bool32 vertexDynamicStride_, - PipelineLayout pushconstantPipelineLayout_, - ShaderStageFlags pushconstantShaderStageFlags_, - uint32_t pushconstantOffset_, - uint32_t pushconstantSize_, - IndirectStateFlagsNV indirectStateFlags_, - ArrayProxyNoTemporaries const & indexTypes_, - ArrayProxyNoTemporaries const & indexTypeValues_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , tokenType( tokenType_ ) - , stream( stream_ ) - , offset( offset_ ) - , vertexBindingUnit( vertexBindingUnit_ ) - , vertexDynamicStride( vertexDynamicStride_ ) - , pushconstantPipelineLayout( pushconstantPipelineLayout_ ) - , pushconstantShaderStageFlags( pushconstantShaderStageFlags_ ) - , pushconstantOffset( pushconstantOffset_ ) - , pushconstantSize( pushconstantSize_ ) - , indirectStateFlags( indirectStateFlags_ ) - , indexTypeCount( static_cast( indexTypes_.size() ) ) - , pIndexTypes( indexTypes_.data() ) - , pIndexTypeValues( indexTypeValues_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( indexTypes_.size() == indexTypeValues_.size() ); -# else - if ( indexTypes_.size() != indexTypeValues_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::IndirectCommandsLayoutTokenNV::IndirectCommandsLayoutTokenNV: indexTypes_.size() != indexTypeValues_.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - IndirectCommandsLayoutTokenNV & operator=( IndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectCommandsLayoutTokenNV & operator=( VkIndirectCommandsLayoutTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setTokenType( IndirectCommandsTokenTypeNV tokenType_ ) & VULKAN_HPP_NOEXCEPT - { - tokenType = tokenType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setTokenType( IndirectCommandsTokenTypeNV tokenType_ ) && VULKAN_HPP_NOEXCEPT - { - tokenType = tokenType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setStream( uint32_t stream_ ) & VULKAN_HPP_NOEXCEPT - { - stream = stream_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setStream( uint32_t stream_ ) && VULKAN_HPP_NOEXCEPT - { - stream = stream_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setVertexBindingUnit( uint32_t vertexBindingUnit_ ) & VULKAN_HPP_NOEXCEPT - { - vertexBindingUnit = vertexBindingUnit_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setVertexBindingUnit( uint32_t vertexBindingUnit_ ) && VULKAN_HPP_NOEXCEPT - { - vertexBindingUnit = vertexBindingUnit_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setVertexDynamicStride( Bool32 vertexDynamicStride_ ) & VULKAN_HPP_NOEXCEPT - { - vertexDynamicStride = vertexDynamicStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setVertexDynamicStride( Bool32 vertexDynamicStride_ ) && VULKAN_HPP_NOEXCEPT - { - vertexDynamicStride = vertexDynamicStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPushconstantPipelineLayout( PipelineLayout pushconstantPipelineLayout_ ) & VULKAN_HPP_NOEXCEPT - { - pushconstantPipelineLayout = pushconstantPipelineLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPushconstantPipelineLayout( PipelineLayout pushconstantPipelineLayout_ ) && VULKAN_HPP_NOEXCEPT - { - pushconstantPipelineLayout = pushconstantPipelineLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPushconstantShaderStageFlags( ShaderStageFlags pushconstantShaderStageFlags_ ) & - VULKAN_HPP_NOEXCEPT - { - pushconstantShaderStageFlags = pushconstantShaderStageFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPushconstantShaderStageFlags( ShaderStageFlags pushconstantShaderStageFlags_ ) && - VULKAN_HPP_NOEXCEPT - { - pushconstantShaderStageFlags = pushconstantShaderStageFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPushconstantOffset( uint32_t pushconstantOffset_ ) & VULKAN_HPP_NOEXCEPT - { - pushconstantOffset = pushconstantOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPushconstantOffset( uint32_t pushconstantOffset_ ) && VULKAN_HPP_NOEXCEPT - { - pushconstantOffset = pushconstantOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPushconstantSize( uint32_t pushconstantSize_ ) & VULKAN_HPP_NOEXCEPT - { - pushconstantSize = pushconstantSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPushconstantSize( uint32_t pushconstantSize_ ) && VULKAN_HPP_NOEXCEPT - { - pushconstantSize = pushconstantSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setIndirectStateFlags( IndirectStateFlagsNV indirectStateFlags_ ) & VULKAN_HPP_NOEXCEPT - { - indirectStateFlags = indirectStateFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setIndirectStateFlags( IndirectStateFlagsNV indirectStateFlags_ ) && VULKAN_HPP_NOEXCEPT - { - indirectStateFlags = indirectStateFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setIndexTypeCount( uint32_t indexTypeCount_ ) & VULKAN_HPP_NOEXCEPT - { - indexTypeCount = indexTypeCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setIndexTypeCount( uint32_t indexTypeCount_ ) && VULKAN_HPP_NOEXCEPT - { - indexTypeCount = indexTypeCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPIndexTypes( const IndexType * pIndexTypes_ ) & VULKAN_HPP_NOEXCEPT - { - pIndexTypes = pIndexTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPIndexTypes( const IndexType * pIndexTypes_ ) && VULKAN_HPP_NOEXCEPT - { - pIndexTypes = pIndexTypes_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectCommandsLayoutTokenNV & setIndexTypes( ArrayProxyNoTemporaries const & indexTypes_ ) VULKAN_HPP_NOEXCEPT - { - indexTypeCount = static_cast( indexTypes_.size() ); - pIndexTypes = indexTypes_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV & setPIndexTypeValues( const uint32_t * pIndexTypeValues_ ) & VULKAN_HPP_NOEXCEPT - { - pIndexTypeValues = pIndexTypeValues_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutTokenNV && setPIndexTypeValues( const uint32_t * pIndexTypeValues_ ) && VULKAN_HPP_NOEXCEPT - { - pIndexTypeValues = pIndexTypeValues_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectCommandsLayoutTokenNV & setIndexTypeValues( ArrayProxyNoTemporaries const & indexTypeValues_ ) VULKAN_HPP_NOEXCEPT - { - indexTypeCount = static_cast( indexTypeValues_.size() ); - pIndexTypeValues = indexTypeValues_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectCommandsLayoutTokenNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutTokenNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutTokenNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutTokenNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - tokenType, - stream, - offset, - vertexBindingUnit, - vertexDynamicStride, - pushconstantPipelineLayout, - pushconstantShaderStageFlags, - pushconstantOffset, - pushconstantSize, - indirectStateFlags, - indexTypeCount, - pIndexTypes, - pIndexTypeValues ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectCommandsLayoutTokenNV const & ) const = default; -#else - bool operator==( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tokenType == rhs.tokenType ) && ( stream == rhs.stream ) && ( offset == rhs.offset ) && - ( vertexBindingUnit == rhs.vertexBindingUnit ) && ( vertexDynamicStride == rhs.vertexDynamicStride ) && - ( pushconstantPipelineLayout == rhs.pushconstantPipelineLayout ) && ( pushconstantShaderStageFlags == rhs.pushconstantShaderStageFlags ) && - ( pushconstantOffset == rhs.pushconstantOffset ) && ( pushconstantSize == rhs.pushconstantSize ) && - ( indirectStateFlags == rhs.indirectStateFlags ) && ( indexTypeCount == rhs.indexTypeCount ) && ( pIndexTypes == rhs.pIndexTypes ) && - ( pIndexTypeValues == rhs.pIndexTypeValues ); -# endif - } - - bool operator!=( IndirectCommandsLayoutTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eIndirectCommandsLayoutTokenNV; - const void * pNext = {}; - IndirectCommandsTokenTypeNV tokenType = IndirectCommandsTokenTypeNV::eShaderGroup; - uint32_t stream = {}; - uint32_t offset = {}; - uint32_t vertexBindingUnit = {}; - Bool32 vertexDynamicStride = {}; - PipelineLayout pushconstantPipelineLayout = {}; - ShaderStageFlags pushconstantShaderStageFlags = {}; - uint32_t pushconstantOffset = {}; - uint32_t pushconstantSize = {}; - IndirectStateFlagsNV indirectStateFlags = {}; - uint32_t indexTypeCount = {}; - const IndexType * pIndexTypes = {}; - const uint32_t * pIndexTypeValues = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectCommandsLayoutTokenNV; - }; -#endif - - template <> - struct CppType - { - using Type = IndirectCommandsLayoutTokenNV; - }; - - // wrapper struct for struct VkIndirectCommandsLayoutCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutCreateInfoNV.html - struct IndirectCommandsLayoutCreateInfoNV - { - using NativeType = VkIndirectCommandsLayoutCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNV( IndirectCommandsLayoutUsageFlagsNV flags_ = {}, - PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, - uint32_t tokenCount_ = {}, - const IndirectCommandsLayoutTokenNV * pTokens_ = {}, - uint32_t streamCount_ = {}, - const uint32_t * pStreamStrides_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pipelineBindPoint{ pipelineBindPoint_ } - , tokenCount{ tokenCount_ } - , pTokens{ pTokens_ } - , streamCount{ streamCount_ } - , pStreamStrides{ pStreamStrides_ } - { - } - - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutCreateInfoNV( IndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectCommandsLayoutCreateInfoNV( VkIndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectCommandsLayoutCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectCommandsLayoutCreateInfoNV( IndirectCommandsLayoutUsageFlagsNV flags_, - PipelineBindPoint pipelineBindPoint_, - ArrayProxyNoTemporaries const & tokens_, - ArrayProxyNoTemporaries const & streamStrides_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , tokenCount( static_cast( tokens_.size() ) ) - , pTokens( tokens_.data() ) - , streamCount( static_cast( streamStrides_.size() ) ) - , pStreamStrides( streamStrides_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - IndirectCommandsLayoutCreateInfoNV & operator=( IndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectCommandsLayoutCreateInfoNV & operator=( VkIndirectCommandsLayoutCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setFlags( IndirectCommandsLayoutUsageFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setFlags( IndirectCommandsLayoutUsageFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setTokenCount( uint32_t tokenCount_ ) & VULKAN_HPP_NOEXCEPT - { - tokenCount = tokenCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setTokenCount( uint32_t tokenCount_ ) && VULKAN_HPP_NOEXCEPT - { - tokenCount = tokenCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setPTokens( const IndirectCommandsLayoutTokenNV * pTokens_ ) & VULKAN_HPP_NOEXCEPT - { - pTokens = pTokens_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setPTokens( const IndirectCommandsLayoutTokenNV * pTokens_ ) && VULKAN_HPP_NOEXCEPT - { - pTokens = pTokens_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectCommandsLayoutCreateInfoNV & setTokens( ArrayProxyNoTemporaries const & tokens_ ) VULKAN_HPP_NOEXCEPT - { - tokenCount = static_cast( tokens_.size() ); - pTokens = tokens_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setStreamCount( uint32_t streamCount_ ) & VULKAN_HPP_NOEXCEPT - { - streamCount = streamCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setStreamCount( uint32_t streamCount_ ) && VULKAN_HPP_NOEXCEPT - { - streamCount = streamCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV & setPStreamStrides( const uint32_t * pStreamStrides_ ) & VULKAN_HPP_NOEXCEPT - { - pStreamStrides = pStreamStrides_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutCreateInfoNV && setPStreamStrides( const uint32_t * pStreamStrides_ ) && VULKAN_HPP_NOEXCEPT - { - pStreamStrides = pStreamStrides_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectCommandsLayoutCreateInfoNV & setStreamStrides( ArrayProxyNoTemporaries const & streamStrides_ ) VULKAN_HPP_NOEXCEPT - { - streamCount = static_cast( streamStrides_.size() ); - pStreamStrides = streamStrides_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectCommandsLayoutCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, pipelineBindPoint, tokenCount, pTokens, streamCount, pStreamStrides ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectCommandsLayoutCreateInfoNV const & ) const = default; -#else - bool operator==( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && - ( tokenCount == rhs.tokenCount ) && ( pTokens == rhs.pTokens ) && ( streamCount == rhs.streamCount ) && ( pStreamStrides == rhs.pStreamStrides ); -# endif - } - - bool operator!=( IndirectCommandsLayoutCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eIndirectCommandsLayoutCreateInfoNV; - const void * pNext = {}; - IndirectCommandsLayoutUsageFlagsNV flags = {}; - PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; - uint32_t tokenCount = {}; - const IndirectCommandsLayoutTokenNV * pTokens = {}; - uint32_t streamCount = {}; - const uint32_t * pStreamStrides = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectCommandsLayoutCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = IndirectCommandsLayoutCreateInfoNV; - }; - - // wrapper struct for struct VkIndirectCommandsLayoutPushDataTokenNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectCommandsLayoutPushDataTokenNV.html - struct IndirectCommandsLayoutPushDataTokenNV - { - using NativeType = VkIndirectCommandsLayoutPushDataTokenNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectCommandsLayoutPushDataTokenNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - IndirectCommandsLayoutPushDataTokenNV( uint32_t pushDataOffset_ = {}, uint32_t pushDataSize_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pushDataOffset{ pushDataOffset_ } - , pushDataSize{ pushDataSize_ } - { - } - - VULKAN_HPP_CONSTEXPR IndirectCommandsLayoutPushDataTokenNV( IndirectCommandsLayoutPushDataTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectCommandsLayoutPushDataTokenNV( VkIndirectCommandsLayoutPushDataTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectCommandsLayoutPushDataTokenNV( *reinterpret_cast( &rhs ) ) - { - } - - IndirectCommandsLayoutPushDataTokenNV & operator=( IndirectCommandsLayoutPushDataTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectCommandsLayoutPushDataTokenNV & operator=( VkIndirectCommandsLayoutPushDataTokenNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV & setPushDataOffset( uint32_t pushDataOffset_ ) & VULKAN_HPP_NOEXCEPT - { - pushDataOffset = pushDataOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV && setPushDataOffset( uint32_t pushDataOffset_ ) && VULKAN_HPP_NOEXCEPT - { - pushDataOffset = pushDataOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV & setPushDataSize( uint32_t pushDataSize_ ) & VULKAN_HPP_NOEXCEPT - { - pushDataSize = pushDataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectCommandsLayoutPushDataTokenNV && setPushDataSize( uint32_t pushDataSize_ ) && VULKAN_HPP_NOEXCEPT - { - pushDataSize = pushDataSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectCommandsLayoutPushDataTokenNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutPushDataTokenNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutPushDataTokenNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectCommandsLayoutPushDataTokenNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pushDataOffset, pushDataSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectCommandsLayoutPushDataTokenNV const & ) const = default; -#else - bool operator==( IndirectCommandsLayoutPushDataTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pushDataOffset == rhs.pushDataOffset ) && ( pushDataSize == rhs.pushDataSize ); -# endif - } - - bool operator!=( IndirectCommandsLayoutPushDataTokenNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eIndirectCommandsLayoutPushDataTokenNV; - const void * pNext = {}; - uint32_t pushDataOffset = {}; - uint32_t pushDataSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectCommandsLayoutPushDataTokenNV; - }; -#endif - - template <> - struct CppType - { - using Type = IndirectCommandsLayoutPushDataTokenNV; - }; - - // wrapper struct for struct VkIndirectExecutionSetPipelineInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetPipelineInfoEXT.html - struct IndirectExecutionSetPipelineInfoEXT - { - using NativeType = VkIndirectExecutionSetPipelineInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectExecutionSetPipelineInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - IndirectExecutionSetPipelineInfoEXT( Pipeline initialPipeline_ = {}, uint32_t maxPipelineCount_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , initialPipeline{ initialPipeline_ } - , maxPipelineCount{ maxPipelineCount_ } - { - } - - VULKAN_HPP_CONSTEXPR IndirectExecutionSetPipelineInfoEXT( IndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectExecutionSetPipelineInfoEXT( VkIndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectExecutionSetPipelineInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - IndirectExecutionSetPipelineInfoEXT & operator=( IndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectExecutionSetPipelineInfoEXT & operator=( VkIndirectExecutionSetPipelineInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT & setInitialPipeline( Pipeline initialPipeline_ ) & VULKAN_HPP_NOEXCEPT - { - initialPipeline = initialPipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT && setInitialPipeline( Pipeline initialPipeline_ ) && VULKAN_HPP_NOEXCEPT - { - initialPipeline = initialPipeline_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT & setMaxPipelineCount( uint32_t maxPipelineCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxPipelineCount = maxPipelineCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetPipelineInfoEXT && setMaxPipelineCount( uint32_t maxPipelineCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxPipelineCount = maxPipelineCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectExecutionSetPipelineInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetPipelineInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetPipelineInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetPipelineInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, initialPipeline, maxPipelineCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectExecutionSetPipelineInfoEXT const & ) const = default; -#else - bool operator==( IndirectExecutionSetPipelineInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( initialPipeline == rhs.initialPipeline ) && ( maxPipelineCount == rhs.maxPipelineCount ); -# endif - } - - bool operator!=( IndirectExecutionSetPipelineInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eIndirectExecutionSetPipelineInfoEXT; - const void * pNext = {}; - Pipeline initialPipeline = {}; - uint32_t maxPipelineCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectExecutionSetPipelineInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = IndirectExecutionSetPipelineInfoEXT; - }; - - // wrapper struct for struct VkIndirectExecutionSetShaderLayoutInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetShaderLayoutInfoEXT.html - struct IndirectExecutionSetShaderLayoutInfoEXT - { - using NativeType = VkIndirectExecutionSetShaderLayoutInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectExecutionSetShaderLayoutInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderLayoutInfoEXT( uint32_t setLayoutCount_ = {}, - const DescriptorSetLayout * pSetLayouts_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , setLayoutCount{ setLayoutCount_ } - , pSetLayouts{ pSetLayouts_ } - { - } - - VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderLayoutInfoEXT( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectExecutionSetShaderLayoutInfoEXT( VkIndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectExecutionSetShaderLayoutInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectExecutionSetShaderLayoutInfoEXT( ArrayProxyNoTemporaries const & setLayouts_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), setLayoutCount( static_cast( setLayouts_.size() ) ), pSetLayouts( setLayouts_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - IndirectExecutionSetShaderLayoutInfoEXT & operator=( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectExecutionSetShaderLayoutInfoEXT & operator=( VkIndirectExecutionSetShaderLayoutInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT & setSetLayoutCount( uint32_t setLayoutCount_ ) & VULKAN_HPP_NOEXCEPT - { - setLayoutCount = setLayoutCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT && setSetLayoutCount( uint32_t setLayoutCount_ ) && VULKAN_HPP_NOEXCEPT - { - setLayoutCount = setLayoutCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT & setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) & VULKAN_HPP_NOEXCEPT - { - pSetLayouts = pSetLayouts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderLayoutInfoEXT && setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) && VULKAN_HPP_NOEXCEPT - { - pSetLayouts = pSetLayouts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectExecutionSetShaderLayoutInfoEXT & setSetLayouts( ArrayProxyNoTemporaries const & setLayouts_ ) VULKAN_HPP_NOEXCEPT - { - setLayoutCount = static_cast( setLayouts_.size() ); - pSetLayouts = setLayouts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectExecutionSetShaderLayoutInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetShaderLayoutInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetShaderLayoutInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetShaderLayoutInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, setLayoutCount, pSetLayouts ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectExecutionSetShaderLayoutInfoEXT const & ) const = default; -#else - bool operator==( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( setLayoutCount == rhs.setLayoutCount ) && ( pSetLayouts == rhs.pSetLayouts ); -# endif - } - - bool operator!=( IndirectExecutionSetShaderLayoutInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eIndirectExecutionSetShaderLayoutInfoEXT; - const void * pNext = {}; - uint32_t setLayoutCount = {}; - const DescriptorSetLayout * pSetLayouts = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectExecutionSetShaderLayoutInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = IndirectExecutionSetShaderLayoutInfoEXT; - }; - - // wrapper struct for struct VkIndirectExecutionSetShaderInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetShaderInfoEXT.html - struct IndirectExecutionSetShaderInfoEXT - { - using NativeType = VkIndirectExecutionSetShaderInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectExecutionSetShaderInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderInfoEXT( uint32_t shaderCount_ = {}, - const ShaderEXT * pInitialShaders_ = {}, - const IndirectExecutionSetShaderLayoutInfoEXT * pSetLayoutInfos_ = {}, - uint32_t maxShaderCount_ = {}, - uint32_t pushConstantRangeCount_ = {}, - const PushConstantRange * pPushConstantRanges_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderCount{ shaderCount_ } - , pInitialShaders{ pInitialShaders_ } - , pSetLayoutInfos{ pSetLayoutInfos_ } - , maxShaderCount{ maxShaderCount_ } - , pushConstantRangeCount{ pushConstantRangeCount_ } - , pPushConstantRanges{ pPushConstantRanges_ } - { - } - - VULKAN_HPP_CONSTEXPR IndirectExecutionSetShaderInfoEXT( IndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectExecutionSetShaderInfoEXT( VkIndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectExecutionSetShaderInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectExecutionSetShaderInfoEXT( ArrayProxyNoTemporaries const & initialShaders_, - ArrayProxyNoTemporaries const & setLayoutInfos_ = {}, - uint32_t maxShaderCount_ = {}, - ArrayProxyNoTemporaries const & pushConstantRanges_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , shaderCount( static_cast( initialShaders_.size() ) ) - , pInitialShaders( initialShaders_.data() ) - , pSetLayoutInfos( setLayoutInfos_.data() ) - , maxShaderCount( maxShaderCount_ ) - , pushConstantRangeCount( static_cast( pushConstantRanges_.size() ) ) - , pPushConstantRanges( pushConstantRanges_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( setLayoutInfos_.empty() || ( initialShaders_.size() == setLayoutInfos_.size() ) ); -# else - if ( !setLayoutInfos_.empty() && ( initialShaders_.size() != setLayoutInfos_.size() ) ) - { - throw LogicError( - VULKAN_HPP_NAMESPACE_STRING - "::IndirectExecutionSetShaderInfoEXT::IndirectExecutionSetShaderInfoEXT: !setLayoutInfos_.empty() && ( initialShaders_.size() != setLayoutInfos_.size() )" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - IndirectExecutionSetShaderInfoEXT & operator=( IndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectExecutionSetShaderInfoEXT & operator=( VkIndirectExecutionSetShaderInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setShaderCount( uint32_t shaderCount_ ) & VULKAN_HPP_NOEXCEPT - { - shaderCount = shaderCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setShaderCount( uint32_t shaderCount_ ) && VULKAN_HPP_NOEXCEPT - { - shaderCount = shaderCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPInitialShaders( const ShaderEXT * pInitialShaders_ ) & VULKAN_HPP_NOEXCEPT - { - pInitialShaders = pInitialShaders_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setPInitialShaders( const ShaderEXT * pInitialShaders_ ) && VULKAN_HPP_NOEXCEPT - { - pInitialShaders = pInitialShaders_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectExecutionSetShaderInfoEXT & setInitialShaders( ArrayProxyNoTemporaries const & initialShaders_ ) VULKAN_HPP_NOEXCEPT - { - shaderCount = static_cast( initialShaders_.size() ); - pInitialShaders = initialShaders_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPSetLayoutInfos( const IndirectExecutionSetShaderLayoutInfoEXT * pSetLayoutInfos_ ) & - VULKAN_HPP_NOEXCEPT - { - pSetLayoutInfos = pSetLayoutInfos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setPSetLayoutInfos( const IndirectExecutionSetShaderLayoutInfoEXT * pSetLayoutInfos_ ) && - VULKAN_HPP_NOEXCEPT - { - pSetLayoutInfos = pSetLayoutInfos_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectExecutionSetShaderInfoEXT & - setSetLayoutInfos( ArrayProxyNoTemporaries const & setLayoutInfos_ ) VULKAN_HPP_NOEXCEPT - { - shaderCount = static_cast( setLayoutInfos_.size() ); - pSetLayoutInfos = setLayoutInfos_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setMaxShaderCount( uint32_t maxShaderCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxShaderCount = maxShaderCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setMaxShaderCount( uint32_t maxShaderCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxShaderCount = maxShaderCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) & VULKAN_HPP_NOEXCEPT - { - pushConstantRangeCount = pushConstantRangeCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) && VULKAN_HPP_NOEXCEPT - { - pushConstantRangeCount = pushConstantRangeCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT & setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) & VULKAN_HPP_NOEXCEPT - { - pPushConstantRanges = pPushConstantRanges_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetShaderInfoEXT && setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) && VULKAN_HPP_NOEXCEPT - { - pPushConstantRanges = pPushConstantRanges_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - IndirectExecutionSetShaderInfoEXT & - setPushConstantRanges( ArrayProxyNoTemporaries const & pushConstantRanges_ ) VULKAN_HPP_NOEXCEPT - { - pushConstantRangeCount = static_cast( pushConstantRanges_.size() ); - pPushConstantRanges = pushConstantRanges_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectExecutionSetShaderInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetShaderInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetShaderInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetShaderInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderCount, pInitialShaders, pSetLayoutInfos, maxShaderCount, pushConstantRangeCount, pPushConstantRanges ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( IndirectExecutionSetShaderInfoEXT const & ) const = default; -#else - bool operator==( IndirectExecutionSetShaderInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCount == rhs.shaderCount ) && ( pInitialShaders == rhs.pInitialShaders ) && - ( pSetLayoutInfos == rhs.pSetLayoutInfos ) && ( maxShaderCount == rhs.maxShaderCount ) && - ( pushConstantRangeCount == rhs.pushConstantRangeCount ) && ( pPushConstantRanges == rhs.pPushConstantRanges ); -# endif - } - - bool operator!=( IndirectExecutionSetShaderInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eIndirectExecutionSetShaderInfoEXT; - const void * pNext = {}; - uint32_t shaderCount = {}; - const ShaderEXT * pInitialShaders = {}; - const IndirectExecutionSetShaderLayoutInfoEXT * pSetLayoutInfos = {}; - uint32_t maxShaderCount = {}; - uint32_t pushConstantRangeCount = {}; - const PushConstantRange * pPushConstantRanges = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectExecutionSetShaderInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = IndirectExecutionSetShaderInfoEXT; - }; - - union IndirectExecutionSetInfoEXT - { - using NativeType = VkIndirectExecutionSetInfoEXT; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT( const IndirectExecutionSetPipelineInfoEXT * pPipelineInfo_ = {} ) : pPipelineInfo( pPipelineInfo_ ) {} - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT( const IndirectExecutionSetShaderInfoEXT * pShaderInfo_ ) : pShaderInfo( pShaderInfo_ ) {} -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT & setPPipelineInfo( const IndirectExecutionSetPipelineInfoEXT * pPipelineInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pPipelineInfo = pPipelineInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT && setPPipelineInfo( const IndirectExecutionSetPipelineInfoEXT * pPipelineInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pPipelineInfo = pPipelineInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT & setPShaderInfo( const IndirectExecutionSetShaderInfoEXT * pShaderInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pShaderInfo = pShaderInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetInfoEXT && setPShaderInfo( const IndirectExecutionSetShaderInfoEXT * pShaderInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pShaderInfo = pShaderInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectExecutionSetInfoEXT const &() const - { - return *reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetInfoEXT &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - const IndirectExecutionSetPipelineInfoEXT * pPipelineInfo; - const IndirectExecutionSetShaderInfoEXT * pShaderInfo; -#else - const VkIndirectExecutionSetPipelineInfoEXT * pPipelineInfo; - const VkIndirectExecutionSetShaderInfoEXT * pShaderInfo; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectExecutionSetInfoEXT; - }; -#endif - - // wrapper struct for struct VkIndirectExecutionSetCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkIndirectExecutionSetCreateInfoEXT.html - struct IndirectExecutionSetCreateInfoEXT - { - using NativeType = VkIndirectExecutionSetCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eIndirectExecutionSetCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT( IndirectExecutionSetInfoTypeEXT type_ = IndirectExecutionSetInfoTypeEXT::ePipelines, - IndirectExecutionSetInfoEXT info_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , info{ info_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT( IndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - IndirectExecutionSetCreateInfoEXT( VkIndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : IndirectExecutionSetCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - IndirectExecutionSetCreateInfoEXT & operator=( IndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - IndirectExecutionSetCreateInfoEXT & operator=( VkIndirectExecutionSetCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT & setType( IndirectExecutionSetInfoTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT && setType( IndirectExecutionSetInfoTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT & setInfo( IndirectExecutionSetInfoEXT const & info_ ) & VULKAN_HPP_NOEXCEPT - { - info = info_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 IndirectExecutionSetCreateInfoEXT && setInfo( IndirectExecutionSetInfoEXT const & info_ ) && VULKAN_HPP_NOEXCEPT - { - info = info_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkIndirectExecutionSetCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkIndirectExecutionSetCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, type, info ); - } -#endif - - public: - StructureType sType = StructureType::eIndirectExecutionSetCreateInfoEXT; - const void * pNext = {}; - IndirectExecutionSetInfoTypeEXT type = IndirectExecutionSetInfoTypeEXT::ePipelines; - IndirectExecutionSetInfoEXT info = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = IndirectExecutionSetCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = IndirectExecutionSetCreateInfoEXT; - }; - - // wrapper struct for struct VkInitializePerformanceApiInfoINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkInitializePerformanceApiInfoINTEL.html - struct InitializePerformanceApiInfoINTEL - { - using NativeType = VkInitializePerformanceApiInfoINTEL; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eInitializePerformanceApiInfoINTEL; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( void * pUserData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pUserData{ pUserData_ } - { - } - - VULKAN_HPP_CONSTEXPR InitializePerformanceApiInfoINTEL( InitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - InitializePerformanceApiInfoINTEL( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : InitializePerformanceApiInfoINTEL( *reinterpret_cast( &rhs ) ) - { - } - - InitializePerformanceApiInfoINTEL & operator=( InitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - InitializePerformanceApiInfoINTEL & operator=( VkInitializePerformanceApiInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 InitializePerformanceApiInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InitializePerformanceApiInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 InitializePerformanceApiInfoINTEL & setPUserData( void * pUserData_ ) & VULKAN_HPP_NOEXCEPT - { - pUserData = pUserData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InitializePerformanceApiInfoINTEL && setPUserData( void * pUserData_ ) && VULKAN_HPP_NOEXCEPT - { - pUserData = pUserData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkInitializePerformanceApiInfoINTEL const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkInitializePerformanceApiInfoINTEL &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkInitializePerformanceApiInfoINTEL const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkInitializePerformanceApiInfoINTEL *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pUserData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( InitializePerformanceApiInfoINTEL const & ) const = default; -#else - bool operator==( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pUserData == rhs.pUserData ); -# endif - } - - bool operator!=( InitializePerformanceApiInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eInitializePerformanceApiInfoINTEL; - const void * pNext = {}; - void * pUserData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = InitializePerformanceApiInfoINTEL; - }; -#endif - - template <> - struct CppType - { - using Type = InitializePerformanceApiInfoINTEL; - }; - - // wrapper struct for struct VkInputAttachmentAspectReference, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkInputAttachmentAspectReference.html - struct InputAttachmentAspectReference - { - using NativeType = VkInputAttachmentAspectReference; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - InputAttachmentAspectReference( uint32_t subpass_ = {}, uint32_t inputAttachmentIndex_ = {}, ImageAspectFlags aspectMask_ = {} ) VULKAN_HPP_NOEXCEPT - : subpass{ subpass_ } - , inputAttachmentIndex{ inputAttachmentIndex_ } - , aspectMask{ aspectMask_ } - { - } - - VULKAN_HPP_CONSTEXPR InputAttachmentAspectReference( InputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - InputAttachmentAspectReference( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT - : InputAttachmentAspectReference( *reinterpret_cast( &rhs ) ) - { - } - - InputAttachmentAspectReference & operator=( InputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - InputAttachmentAspectReference & operator=( VkInputAttachmentAspectReference const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference & setSubpass( uint32_t subpass_ ) & VULKAN_HPP_NOEXCEPT - { - subpass = subpass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference && setSubpass( uint32_t subpass_ ) && VULKAN_HPP_NOEXCEPT - { - subpass = subpass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference & setInputAttachmentIndex( uint32_t inputAttachmentIndex_ ) & VULKAN_HPP_NOEXCEPT - { - inputAttachmentIndex = inputAttachmentIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference && setInputAttachmentIndex( uint32_t inputAttachmentIndex_ ) && VULKAN_HPP_NOEXCEPT - { - inputAttachmentIndex = inputAttachmentIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference & setAspectMask( ImageAspectFlags aspectMask_ ) & VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InputAttachmentAspectReference && setAspectMask( ImageAspectFlags aspectMask_ ) && VULKAN_HPP_NOEXCEPT - { - aspectMask = aspectMask_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkInputAttachmentAspectReference const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkInputAttachmentAspectReference &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkInputAttachmentAspectReference const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkInputAttachmentAspectReference *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( subpass, inputAttachmentIndex, aspectMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( InputAttachmentAspectReference const & ) const = default; -#else - bool operator==( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( subpass == rhs.subpass ) && ( inputAttachmentIndex == rhs.inputAttachmentIndex ) && ( aspectMask == rhs.aspectMask ); -# endif - } - - bool operator!=( InputAttachmentAspectReference const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t subpass = {}; - uint32_t inputAttachmentIndex = {}; - ImageAspectFlags aspectMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = InputAttachmentAspectReference; - }; -#endif - using InputAttachmentAspectReferenceKHR = InputAttachmentAspectReference; - - // wrapper struct for struct VkInstanceCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkInstanceCreateInfo.html - struct InstanceCreateInfo - { - using NativeType = VkInstanceCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eInstanceCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR InstanceCreateInfo( InstanceCreateFlags flags_ = {}, - const ApplicationInfo * pApplicationInfo_ = {}, - uint32_t enabledLayerCount_ = {}, - const char * const * ppEnabledLayerNames_ = {}, - uint32_t enabledExtensionCount_ = {}, - const char * const * ppEnabledExtensionNames_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pApplicationInfo{ pApplicationInfo_ } - , enabledLayerCount{ enabledLayerCount_ } - , ppEnabledLayerNames{ ppEnabledLayerNames_ } - , enabledExtensionCount{ enabledExtensionCount_ } - , ppEnabledExtensionNames{ ppEnabledExtensionNames_ } - { - } - - VULKAN_HPP_CONSTEXPR InstanceCreateInfo( InstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - InstanceCreateInfo( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : InstanceCreateInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - InstanceCreateInfo( InstanceCreateFlags flags_, - const ApplicationInfo * pApplicationInfo_, - ArrayProxyNoTemporaries const & pEnabledLayerNames_, - ArrayProxyNoTemporaries const & pEnabledExtensionNames_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , pApplicationInfo( pApplicationInfo_ ) - , enabledLayerCount( static_cast( pEnabledLayerNames_.size() ) ) - , ppEnabledLayerNames( pEnabledLayerNames_.data() ) - , enabledExtensionCount( static_cast( pEnabledExtensionNames_.size() ) ) - , ppEnabledExtensionNames( pEnabledExtensionNames_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - InstanceCreateInfo & operator=( InstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - InstanceCreateInfo & operator=( VkInstanceCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setFlags( InstanceCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setFlags( InstanceCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setPApplicationInfo( const ApplicationInfo * pApplicationInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pApplicationInfo = pApplicationInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setPApplicationInfo( const ApplicationInfo * pApplicationInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pApplicationInfo = pApplicationInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setEnabledLayerCount( uint32_t enabledLayerCount_ ) & VULKAN_HPP_NOEXCEPT - { - enabledLayerCount = enabledLayerCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setEnabledLayerCount( uint32_t enabledLayerCount_ ) && VULKAN_HPP_NOEXCEPT - { - enabledLayerCount = enabledLayerCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setPpEnabledLayerNames( const char * const * ppEnabledLayerNames_ ) & VULKAN_HPP_NOEXCEPT - { - ppEnabledLayerNames = ppEnabledLayerNames_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setPpEnabledLayerNames( const char * const * ppEnabledLayerNames_ ) && VULKAN_HPP_NOEXCEPT - { - ppEnabledLayerNames = ppEnabledLayerNames_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - InstanceCreateInfo & setPEnabledLayerNames( ArrayProxyNoTemporaries const & pEnabledLayerNames_ ) VULKAN_HPP_NOEXCEPT - { - enabledLayerCount = static_cast( pEnabledLayerNames_.size() ); - ppEnabledLayerNames = pEnabledLayerNames_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) & VULKAN_HPP_NOEXCEPT - { - enabledExtensionCount = enabledExtensionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setEnabledExtensionCount( uint32_t enabledExtensionCount_ ) && VULKAN_HPP_NOEXCEPT - { - enabledExtensionCount = enabledExtensionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo & setPpEnabledExtensionNames( const char * const * ppEnabledExtensionNames_ ) & VULKAN_HPP_NOEXCEPT - { - ppEnabledExtensionNames = ppEnabledExtensionNames_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 InstanceCreateInfo && setPpEnabledExtensionNames( const char * const * ppEnabledExtensionNames_ ) && VULKAN_HPP_NOEXCEPT - { - ppEnabledExtensionNames = ppEnabledExtensionNames_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - InstanceCreateInfo & setPEnabledExtensionNames( ArrayProxyNoTemporaries const & pEnabledExtensionNames_ ) VULKAN_HPP_NOEXCEPT - { - enabledExtensionCount = static_cast( pEnabledExtensionNames_.size() ); - ppEnabledExtensionNames = pEnabledExtensionNames_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkInstanceCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkInstanceCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkInstanceCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkInstanceCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, pApplicationInfo, enabledLayerCount, ppEnabledLayerNames, enabledExtensionCount, ppEnabledExtensionNames ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = pApplicationInfo <=> rhs.pApplicationInfo; cmp != 0 ) - return cmp; - if ( auto cmp = enabledLayerCount <=> rhs.enabledLayerCount; cmp != 0 ) - return cmp; - for ( size_t i = 0; i < enabledLayerCount; ++i ) - { - if ( ppEnabledLayerNames[i] != rhs.ppEnabledLayerNames[i] ) - if ( auto cmp = strcmp( ppEnabledLayerNames[i], rhs.ppEnabledLayerNames[i] ); cmp != 0 ) - return cmp < 0 ? std::strong_ordering::less : std::strong_ordering::greater; - } - if ( auto cmp = enabledExtensionCount <=> rhs.enabledExtensionCount; cmp != 0 ) - return cmp; - for ( size_t i = 0; i < enabledExtensionCount; ++i ) - { - if ( ppEnabledExtensionNames[i] != rhs.ppEnabledExtensionNames[i] ) - if ( auto cmp = strcmp( ppEnabledExtensionNames[i], rhs.ppEnabledExtensionNames[i] ); cmp != 0 ) - return cmp < 0 ? std::strong_ordering::less : std::strong_ordering::greater; - } - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pApplicationInfo == rhs.pApplicationInfo ) && - ( enabledLayerCount == rhs.enabledLayerCount ) && - std::equal( ppEnabledLayerNames, - ppEnabledLayerNames + enabledLayerCount, - rhs.ppEnabledLayerNames, - []( char const * left, char const * right ) { return ( left == right ) || ( strcmp( left, right ) == 0 ); } ) && - ( enabledExtensionCount == rhs.enabledExtensionCount ) && - std::equal( ppEnabledExtensionNames, - ppEnabledExtensionNames + enabledExtensionCount, - rhs.ppEnabledExtensionNames, - []( char const * left, char const * right ) { return ( left == right ) || ( strcmp( left, right ) == 0 ); } ); - } - - bool operator!=( InstanceCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eInstanceCreateInfo; - const void * pNext = {}; - InstanceCreateFlags flags = {}; - const ApplicationInfo * pApplicationInfo = {}; - uint32_t enabledLayerCount = {}; - const char * const * ppEnabledLayerNames = {}; - uint32_t enabledExtensionCount = {}; - const char * const * ppEnabledExtensionNames = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = InstanceCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = InstanceCreateInfo; - }; - - // wrapper struct for struct VkLatencySleepInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencySleepInfoNV.html - struct LatencySleepInfoNV - { - using NativeType = VkLatencySleepInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySleepInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR LatencySleepInfoNV( Semaphore signalSemaphore_ = {}, uint64_t value_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , signalSemaphore{ signalSemaphore_ } - , value{ value_ } - { - } - - VULKAN_HPP_CONSTEXPR LatencySleepInfoNV( LatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - LatencySleepInfoNV( VkLatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT : LatencySleepInfoNV( *reinterpret_cast( &rhs ) ) {} - - LatencySleepInfoNV & operator=( LatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - LatencySleepInfoNV & operator=( VkLatencySleepInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV & setSignalSemaphore( Semaphore signalSemaphore_ ) & VULKAN_HPP_NOEXCEPT - { - signalSemaphore = signalSemaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV && setSignalSemaphore( Semaphore signalSemaphore_ ) && VULKAN_HPP_NOEXCEPT - { - signalSemaphore = signalSemaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV & setValue( uint64_t value_ ) & VULKAN_HPP_NOEXCEPT - { - value = value_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepInfoNV && setValue( uint64_t value_ ) && VULKAN_HPP_NOEXCEPT - { - value = value_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkLatencySleepInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLatencySleepInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLatencySleepInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkLatencySleepInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, signalSemaphore, value ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( LatencySleepInfoNV const & ) const = default; -#else - bool operator==( LatencySleepInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( signalSemaphore == rhs.signalSemaphore ) && ( value == rhs.value ); -# endif - } - - bool operator!=( LatencySleepInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eLatencySleepInfoNV; - const void * pNext = {}; - Semaphore signalSemaphore = {}; - uint64_t value = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = LatencySleepInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = LatencySleepInfoNV; - }; - - // wrapper struct for struct VkLatencySleepModeInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencySleepModeInfoNV.html - struct LatencySleepModeInfoNV - { - using NativeType = VkLatencySleepModeInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySleepModeInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR LatencySleepModeInfoNV( Bool32 lowLatencyMode_ = {}, - Bool32 lowLatencyBoost_ = {}, - uint32_t minimumIntervalUs_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , lowLatencyMode{ lowLatencyMode_ } - , lowLatencyBoost{ lowLatencyBoost_ } - , minimumIntervalUs{ minimumIntervalUs_ } - { - } - - VULKAN_HPP_CONSTEXPR LatencySleepModeInfoNV( LatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - LatencySleepModeInfoNV( VkLatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : LatencySleepModeInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - LatencySleepModeInfoNV & operator=( LatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - LatencySleepModeInfoNV & operator=( VkLatencySleepModeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setLowLatencyMode( Bool32 lowLatencyMode_ ) & VULKAN_HPP_NOEXCEPT - { - lowLatencyMode = lowLatencyMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV && setLowLatencyMode( Bool32 lowLatencyMode_ ) && VULKAN_HPP_NOEXCEPT - { - lowLatencyMode = lowLatencyMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setLowLatencyBoost( Bool32 lowLatencyBoost_ ) & VULKAN_HPP_NOEXCEPT - { - lowLatencyBoost = lowLatencyBoost_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV && setLowLatencyBoost( Bool32 lowLatencyBoost_ ) && VULKAN_HPP_NOEXCEPT - { - lowLatencyBoost = lowLatencyBoost_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV & setMinimumIntervalUs( uint32_t minimumIntervalUs_ ) & VULKAN_HPP_NOEXCEPT - { - minimumIntervalUs = minimumIntervalUs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySleepModeInfoNV && setMinimumIntervalUs( uint32_t minimumIntervalUs_ ) && VULKAN_HPP_NOEXCEPT - { - minimumIntervalUs = minimumIntervalUs_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkLatencySleepModeInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLatencySleepModeInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLatencySleepModeInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkLatencySleepModeInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, lowLatencyMode, lowLatencyBoost, minimumIntervalUs ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( LatencySleepModeInfoNV const & ) const = default; -#else - bool operator==( LatencySleepModeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lowLatencyMode == rhs.lowLatencyMode ) && ( lowLatencyBoost == rhs.lowLatencyBoost ) && - ( minimumIntervalUs == rhs.minimumIntervalUs ); -# endif - } - - bool operator!=( LatencySleepModeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eLatencySleepModeInfoNV; - const void * pNext = {}; - Bool32 lowLatencyMode = {}; - Bool32 lowLatencyBoost = {}; - uint32_t minimumIntervalUs = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = LatencySleepModeInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = LatencySleepModeInfoNV; - }; - - // wrapper struct for struct VkLatencySubmissionPresentIdNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencySubmissionPresentIdNV.html - struct LatencySubmissionPresentIdNV - { - using NativeType = VkLatencySubmissionPresentIdNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySubmissionPresentIdNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR LatencySubmissionPresentIdNV( uint64_t presentID_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentID{ presentID_ } - { - } - - VULKAN_HPP_CONSTEXPR LatencySubmissionPresentIdNV( LatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - LatencySubmissionPresentIdNV( VkLatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT - : LatencySubmissionPresentIdNV( *reinterpret_cast( &rhs ) ) - { - } - - LatencySubmissionPresentIdNV & operator=( LatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - LatencySubmissionPresentIdNV & operator=( VkLatencySubmissionPresentIdNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 LatencySubmissionPresentIdNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySubmissionPresentIdNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LatencySubmissionPresentIdNV & setPresentID( uint64_t presentID_ ) & VULKAN_HPP_NOEXCEPT - { - presentID = presentID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySubmissionPresentIdNV && setPresentID( uint64_t presentID_ ) && VULKAN_HPP_NOEXCEPT - { - presentID = presentID_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkLatencySubmissionPresentIdNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLatencySubmissionPresentIdNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLatencySubmissionPresentIdNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkLatencySubmissionPresentIdNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentID ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( LatencySubmissionPresentIdNV const & ) const = default; -#else - bool operator==( LatencySubmissionPresentIdNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID ); -# endif - } - - bool operator!=( LatencySubmissionPresentIdNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eLatencySubmissionPresentIdNV; - const void * pNext = {}; - uint64_t presentID = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = LatencySubmissionPresentIdNV; - }; -#endif - - template <> - struct CppType - { - using Type = LatencySubmissionPresentIdNV; - }; - - // wrapper struct for struct VkLatencySurfaceCapabilitiesNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLatencySurfaceCapabilitiesNV.html - struct LatencySurfaceCapabilitiesNV - { - using NativeType = VkLatencySurfaceCapabilitiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLatencySurfaceCapabilitiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - LatencySurfaceCapabilitiesNV( uint32_t presentModeCount_ = {}, PresentModeKHR * pPresentModes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentModeCount{ presentModeCount_ } - , pPresentModes{ pPresentModes_ } - { - } - - VULKAN_HPP_CONSTEXPR LatencySurfaceCapabilitiesNV( LatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - LatencySurfaceCapabilitiesNV( VkLatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : LatencySurfaceCapabilitiesNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - LatencySurfaceCapabilitiesNV( ArrayProxyNoTemporaries const & presentModes_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), presentModeCount( static_cast( presentModes_.size() ) ), pPresentModes( presentModes_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - LatencySurfaceCapabilitiesNV & operator=( LatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - LatencySurfaceCapabilitiesNV & operator=( VkLatencySurfaceCapabilitiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV & setPresentModeCount( uint32_t presentModeCount_ ) & VULKAN_HPP_NOEXCEPT - { - presentModeCount = presentModeCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV && setPresentModeCount( uint32_t presentModeCount_ ) && VULKAN_HPP_NOEXCEPT - { - presentModeCount = presentModeCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV & setPPresentModes( PresentModeKHR * pPresentModes_ ) & VULKAN_HPP_NOEXCEPT - { - pPresentModes = pPresentModes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LatencySurfaceCapabilitiesNV && setPPresentModes( PresentModeKHR * pPresentModes_ ) && VULKAN_HPP_NOEXCEPT - { - pPresentModes = pPresentModes_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - LatencySurfaceCapabilitiesNV & setPresentModes( ArrayProxyNoTemporaries const & presentModes_ ) VULKAN_HPP_NOEXCEPT - { - presentModeCount = static_cast( presentModes_.size() ); - pPresentModes = presentModes_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkLatencySurfaceCapabilitiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLatencySurfaceCapabilitiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLatencySurfaceCapabilitiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkLatencySurfaceCapabilitiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentModeCount, pPresentModes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( LatencySurfaceCapabilitiesNV const & ) const = default; -#else - bool operator==( LatencySurfaceCapabilitiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeCount == rhs.presentModeCount ) && ( pPresentModes == rhs.pPresentModes ); -# endif - } - - bool operator!=( LatencySurfaceCapabilitiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eLatencySurfaceCapabilitiesNV; - const void * pNext = {}; - uint32_t presentModeCount = {}; - PresentModeKHR * pPresentModes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = LatencySurfaceCapabilitiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = LatencySurfaceCapabilitiesNV; - }; - - // wrapper struct for struct VkLayerProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayerProperties.html - struct LayerProperties - { - using NativeType = VkLayerProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 LayerProperties( std::array const & layerName_ = {}, - uint32_t specVersion_ = {}, - uint32_t implementationVersion_ = {}, - std::array const & description_ = {} ) VULKAN_HPP_NOEXCEPT - : layerName{ layerName_ } - , specVersion{ specVersion_ } - , implementationVersion{ implementationVersion_ } - , description{ description_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 LayerProperties( LayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - LayerProperties( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT : LayerProperties( *reinterpret_cast( &rhs ) ) {} - - LayerProperties & operator=( LayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - LayerProperties & operator=( VkLayerProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkLayerProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLayerProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLayerProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkLayerProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple const &, uint32_t const &, uint32_t const &, ArrayWrapper1D const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( layerName, specVersion, implementationVersion, description ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = strcmp( layerName, rhs.layerName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = specVersion <=> rhs.specVersion; cmp != 0 ) - return cmp; - if ( auto cmp = implementationVersion <=> rhs.implementationVersion; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( strcmp( layerName, rhs.layerName ) == 0 ) && ( specVersion == rhs.specVersion ) && ( implementationVersion == rhs.implementationVersion ) && - ( strcmp( description, rhs.description ) == 0 ); - } - - bool operator!=( LayerProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - ArrayWrapper1D layerName = {}; - uint32_t specVersion = {}; - uint32_t implementationVersion = {}; - ArrayWrapper1D description = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = LayerProperties; - }; -#endif - - // wrapper struct for struct VkLayerSettingEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayerSettingEXT.html - struct LayerSettingEXT - { - using NativeType = VkLayerSettingEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR LayerSettingEXT( const char * pLayerName_ = {}, - const char * pSettingName_ = {}, - LayerSettingTypeEXT type_ = LayerSettingTypeEXT::eBool32, - uint32_t valueCount_ = {}, - const void * pValues_ = {} ) VULKAN_HPP_NOEXCEPT - : pLayerName{ pLayerName_ } - , pSettingName{ pSettingName_ } - , type{ type_ } - , valueCount{ valueCount_ } - , pValues{ pValues_ } - { - } - - VULKAN_HPP_CONSTEXPR LayerSettingEXT( LayerSettingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - LayerSettingEXT( VkLayerSettingEXT const & rhs ) VULKAN_HPP_NOEXCEPT : LayerSettingEXT( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - // NOTE: you need to provide the type because Bool32 and uint32_t are indistinguishable! - LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) - : pLayerName( pLayerName_ ) - , pSettingName( pSettingName_ ) - , type( type_ ) - , valueCount( static_cast( values_.size() ) ) - , pValues( values_.data() ) - { - VULKAN_HPP_ASSERT( isSameType( type ) ); - } - - LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) - : pLayerName( pLayerName_ ) - , pSettingName( pSettingName_ ) - , type( type_ ) - , valueCount( static_cast( values_.size() ) ) - , pValues( values_.data() ) - { - VULKAN_HPP_ASSERT( isSameType( type ) ); - } - - LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) - : pLayerName( pLayerName_ ) - , pSettingName( pSettingName_ ) - , type( type_ ) - , valueCount( static_cast( values_.size() ) ) - , pValues( values_.data() ) - { - VULKAN_HPP_ASSERT( isSameType( type ) ); - } - - LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) - : pLayerName( pLayerName_ ) - , pSettingName( pSettingName_ ) - , type( type_ ) - , valueCount( static_cast( values_.size() ) ) - , pValues( values_.data() ) - { - VULKAN_HPP_ASSERT( isSameType( type ) ); - } - - LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) - : pLayerName( pLayerName_ ) - , pSettingName( pSettingName_ ) - , type( type_ ) - , valueCount( static_cast( values_.size() ) ) - , pValues( values_.data() ) - { - VULKAN_HPP_ASSERT( isSameType( type ) ); - } - - LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) - : pLayerName( pLayerName_ ) - , pSettingName( pSettingName_ ) - , type( type_ ) - , valueCount( static_cast( values_.size() ) ) - , pValues( values_.data() ) - { - VULKAN_HPP_ASSERT( isSameType( type ) ); - } - - LayerSettingEXT( char const * pLayerName_, char const * pSettingName_, LayerSettingTypeEXT type_, ArrayProxyNoTemporaries const & values_ ) - : pLayerName( pLayerName_ ) - , pSettingName( pSettingName_ ) - , type( type_ ) - , valueCount( static_cast( values_.size() ) ) - , pValues( values_.data() ) - { - VULKAN_HPP_ASSERT( isSameType( type ) ); - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - LayerSettingEXT & operator=( LayerSettingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - LayerSettingEXT & operator=( VkLayerSettingEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT & setPLayerName( const char * pLayerName_ ) & VULKAN_HPP_NOEXCEPT - { - pLayerName = pLayerName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT && setPLayerName( const char * pLayerName_ ) && VULKAN_HPP_NOEXCEPT - { - pLayerName = pLayerName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT & setPSettingName( const char * pSettingName_ ) & VULKAN_HPP_NOEXCEPT - { - pSettingName = pSettingName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT && setPSettingName( const char * pSettingName_ ) && VULKAN_HPP_NOEXCEPT - { - pSettingName = pSettingName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT & setType( LayerSettingTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT && setType( LayerSettingTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT & setValueCount( uint32_t valueCount_ ) & VULKAN_HPP_NOEXCEPT - { - valueCount = valueCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingEXT && setValueCount( uint32_t valueCount_ ) && VULKAN_HPP_NOEXCEPT - { - valueCount = valueCount_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT - { - valueCount = static_cast( values_.size() ); - pValues = values_.data(); - return *this; - } - - LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT - { - valueCount = static_cast( values_.size() ); - pValues = values_.data(); - return *this; - } - - LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT - { - valueCount = static_cast( values_.size() ); - pValues = values_.data(); - return *this; - } - - LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT - { - valueCount = static_cast( values_.size() ); - pValues = values_.data(); - return *this; - } - - LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT - { - valueCount = static_cast( values_.size() ); - pValues = values_.data(); - return *this; - } - - LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT - { - valueCount = static_cast( values_.size() ); - pValues = values_.data(); - return *this; - } - - LayerSettingEXT & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT - { - valueCount = static_cast( values_.size() ); - pValues = values_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkLayerSettingEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLayerSettingEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLayerSettingEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkLayerSettingEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( pLayerName, pSettingName, type, valueCount, pValues ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( LayerSettingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( pLayerName != rhs.pLayerName ) - if ( auto cmp = strcmp( pLayerName, rhs.pLayerName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( pSettingName != rhs.pSettingName ) - if ( auto cmp = strcmp( pSettingName, rhs.pSettingName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = type <=> rhs.type; cmp != 0 ) - return cmp; - if ( auto cmp = valueCount <=> rhs.valueCount; cmp != 0 ) - return cmp; - if ( auto cmp = pValues <=> rhs.pValues; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( LayerSettingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( ( pLayerName == rhs.pLayerName ) || ( strcmp( pLayerName, rhs.pLayerName ) == 0 ) ) && - ( ( pSettingName == rhs.pSettingName ) || ( strcmp( pSettingName, rhs.pSettingName ) == 0 ) ) && ( type == rhs.type ) && - ( valueCount == rhs.valueCount ) && ( pValues == rhs.pValues ); - } - - bool operator!=( LayerSettingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - const char * pLayerName = {}; - const char * pSettingName = {}; - LayerSettingTypeEXT type = LayerSettingTypeEXT::eBool32; - uint32_t valueCount = {}; - const void * pValues = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = LayerSettingEXT; - }; -#endif - - // wrapper struct for struct VkLayerSettingsCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkLayerSettingsCreateInfoEXT.html - struct LayerSettingsCreateInfoEXT - { - using NativeType = VkLayerSettingsCreateInfoEXT; - - static const bool allowDuplicate = true; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eLayerSettingsCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - LayerSettingsCreateInfoEXT( uint32_t settingCount_ = {}, const LayerSettingEXT * pSettings_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , settingCount{ settingCount_ } - , pSettings{ pSettings_ } - { - } - - VULKAN_HPP_CONSTEXPR LayerSettingsCreateInfoEXT( LayerSettingsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - LayerSettingsCreateInfoEXT( VkLayerSettingsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : LayerSettingsCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - LayerSettingsCreateInfoEXT( ArrayProxyNoTemporaries const & settings_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), settingCount( static_cast( settings_.size() ) ), pSettings( settings_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - LayerSettingsCreateInfoEXT & operator=( LayerSettingsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - LayerSettingsCreateInfoEXT & operator=( VkLayerSettingsCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT & setSettingCount( uint32_t settingCount_ ) & VULKAN_HPP_NOEXCEPT - { - settingCount = settingCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT && setSettingCount( uint32_t settingCount_ ) && VULKAN_HPP_NOEXCEPT - { - settingCount = settingCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT & setPSettings( const LayerSettingEXT * pSettings_ ) & VULKAN_HPP_NOEXCEPT - { - pSettings = pSettings_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 LayerSettingsCreateInfoEXT && setPSettings( const LayerSettingEXT * pSettings_ ) && VULKAN_HPP_NOEXCEPT - { - pSettings = pSettings_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - LayerSettingsCreateInfoEXT & setSettings( ArrayProxyNoTemporaries const & settings_ ) VULKAN_HPP_NOEXCEPT - { - settingCount = static_cast( settings_.size() ); - pSettings = settings_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkLayerSettingsCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLayerSettingsCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkLayerSettingsCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkLayerSettingsCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, settingCount, pSettings ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( LayerSettingsCreateInfoEXT const & ) const = default; -#else - bool operator==( LayerSettingsCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( settingCount == rhs.settingCount ) && ( pSettings == rhs.pSettings ); -# endif - } - - bool operator!=( LayerSettingsCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eLayerSettingsCreateInfoEXT; - const void * pNext = {}; - uint32_t settingCount = {}; - const LayerSettingEXT * pSettings = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = LayerSettingsCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = LayerSettingsCreateInfoEXT; - }; - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - // wrapper struct for struct VkMacOSSurfaceCreateInfoMVK, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMacOSSurfaceCreateInfoMVK.html - struct MacOSSurfaceCreateInfoMVK - { - using NativeType = VkMacOSSurfaceCreateInfoMVK; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMacosSurfaceCreateInfoMVK; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateFlagsMVK flags_ = {}, const void * pView_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pView{ pView_ } - { - } - - VULKAN_HPP_CONSTEXPR MacOSSurfaceCreateInfoMVK( MacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MacOSSurfaceCreateInfoMVK( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - : MacOSSurfaceCreateInfoMVK( *reinterpret_cast( &rhs ) ) - { - } - - MacOSSurfaceCreateInfoMVK & operator=( MacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MacOSSurfaceCreateInfoMVK & operator=( VkMacOSSurfaceCreateInfoMVK const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK & setFlags( MacOSSurfaceCreateFlagsMVK flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK && setFlags( MacOSSurfaceCreateFlagsMVK flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK & setPView( const void * pView_ ) & VULKAN_HPP_NOEXCEPT - { - pView = pView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MacOSSurfaceCreateInfoMVK && setPView( const void * pView_ ) && VULKAN_HPP_NOEXCEPT - { - pView = pView_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMacOSSurfaceCreateInfoMVK const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMacOSSurfaceCreateInfoMVK &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMacOSSurfaceCreateInfoMVK const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMacOSSurfaceCreateInfoMVK *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, pView ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MacOSSurfaceCreateInfoMVK const & ) const = default; -# else - bool operator==( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pView == rhs.pView ); -# endif - } - - bool operator!=( MacOSSurfaceCreateInfoMVK const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eMacosSurfaceCreateInfoMVK; - const void * pNext = {}; - MacOSSurfaceCreateFlagsMVK flags = {}; - const void * pView = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MacOSSurfaceCreateInfoMVK; - }; -# endif - - template <> - struct CppType - { - using Type = MacOSSurfaceCreateInfoMVK; - }; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - // wrapper struct for struct VkMappedMemoryRange, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMappedMemoryRange.html - struct MappedMemoryRange - { - using NativeType = VkMappedMemoryRange; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMappedMemoryRange; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - MappedMemoryRange( DeviceMemory memory_ = {}, DeviceSize offset_ = {}, DeviceSize size_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memory{ memory_ } - , offset{ offset_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR MappedMemoryRange( MappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MappedMemoryRange( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT : MappedMemoryRange( *reinterpret_cast( &rhs ) ) {} - - MappedMemoryRange & operator=( MappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MappedMemoryRange & operator=( VkMappedMemoryRange const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MappedMemoryRange && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMappedMemoryRange const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMappedMemoryRange &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMappedMemoryRange const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMappedMemoryRange *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memory, offset, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MappedMemoryRange const & ) const = default; -#else - bool operator==( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) && ( size == rhs.size ); -# endif - } - - bool operator!=( MappedMemoryRange const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMappedMemoryRange; - const void * pNext = {}; - DeviceMemory memory = {}; - DeviceSize offset = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MappedMemoryRange; - }; -#endif - - template <> - struct CppType - { - using Type = MappedMemoryRange; - }; - - // wrapper struct for struct VkMemoryAllocateFlagsInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryAllocateFlagsInfo.html - struct MemoryAllocateFlagsInfo - { - using NativeType = VkMemoryAllocateFlagsInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryAllocateFlagsInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - MemoryAllocateFlagsInfo( MemoryAllocateFlags flags_ = {}, uint32_t deviceMask_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , deviceMask{ deviceMask_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryAllocateFlagsInfo( MemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryAllocateFlagsInfo( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryAllocateFlagsInfo( *reinterpret_cast( &rhs ) ) - { - } - - MemoryAllocateFlagsInfo & operator=( MemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryAllocateFlagsInfo & operator=( VkMemoryAllocateFlagsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo & setFlags( MemoryAllocateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo && setFlags( MemoryAllocateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo & setDeviceMask( uint32_t deviceMask_ ) & VULKAN_HPP_NOEXCEPT - { - deviceMask = deviceMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateFlagsInfo && setDeviceMask( uint32_t deviceMask_ ) && VULKAN_HPP_NOEXCEPT - { - deviceMask = deviceMask_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryAllocateFlagsInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryAllocateFlagsInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryAllocateFlagsInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryAllocateFlagsInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, deviceMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryAllocateFlagsInfo const & ) const = default; -#else - bool operator==( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( deviceMask == rhs.deviceMask ); -# endif - } - - bool operator!=( MemoryAllocateFlagsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryAllocateFlagsInfo; - const void * pNext = {}; - MemoryAllocateFlags flags = {}; - uint32_t deviceMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryAllocateFlagsInfo; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryAllocateFlagsInfo; - }; - - using MemoryAllocateFlagsInfoKHR = MemoryAllocateFlagsInfo; - - // wrapper struct for struct VkMemoryAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryAllocateInfo.html - struct MemoryAllocateInfo - { - using NativeType = VkMemoryAllocateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryAllocateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - MemoryAllocateInfo( DeviceSize allocationSize_ = {}, uint32_t memoryTypeIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , allocationSize{ allocationSize_ } - , memoryTypeIndex{ memoryTypeIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryAllocateInfo( MemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryAllocateInfo( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryAllocateInfo( *reinterpret_cast( &rhs ) ) {} - - MemoryAllocateInfo & operator=( MemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryAllocateInfo & operator=( VkMemoryAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo & setAllocationSize( DeviceSize allocationSize_ ) & VULKAN_HPP_NOEXCEPT - { - allocationSize = allocationSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo && setAllocationSize( DeviceSize allocationSize_ ) && VULKAN_HPP_NOEXCEPT - { - allocationSize = allocationSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo & setMemoryTypeIndex( uint32_t memoryTypeIndex_ ) & VULKAN_HPP_NOEXCEPT - { - memoryTypeIndex = memoryTypeIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryAllocateInfo && setMemoryTypeIndex( uint32_t memoryTypeIndex_ ) && VULKAN_HPP_NOEXCEPT - { - memoryTypeIndex = memoryTypeIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryAllocateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryAllocateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryAllocateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryAllocateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, allocationSize, memoryTypeIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryAllocateInfo const & ) const = default; -#else - bool operator==( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeIndex == rhs.memoryTypeIndex ); -# endif - } - - bool operator!=( MemoryAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryAllocateInfo; - const void * pNext = {}; - DeviceSize allocationSize = {}; - uint32_t memoryTypeIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryAllocateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryAllocateInfo; - }; - - // wrapper struct for struct VkMemoryBarrier, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryBarrier.html - struct MemoryBarrier - { - using NativeType = VkMemoryBarrier; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryBarrier; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryBarrier( AccessFlags srcAccessMask_ = {}, AccessFlags dstAccessMask_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcAccessMask{ srcAccessMask_ } - , dstAccessMask{ dstAccessMask_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryBarrier( MemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryBarrier( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryBarrier( *reinterpret_cast( &rhs ) ) {} - - MemoryBarrier & operator=( MemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryBarrier & operator=( VkMemoryBarrier const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier & setSrcAccessMask( AccessFlags srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier && setSrcAccessMask( AccessFlags srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier & setDstAccessMask( AccessFlags dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrier && setDstAccessMask( AccessFlags dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryBarrier const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryBarrier &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryBarrier const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryBarrier *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcAccessMask, dstAccessMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryBarrier const & ) const = default; -#else - bool operator==( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ); -# endif - } - - bool operator!=( MemoryBarrier const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryBarrier; - const void * pNext = {}; - AccessFlags srcAccessMask = {}; - AccessFlags dstAccessMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryBarrier; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryBarrier; - }; - - // wrapper struct for struct VkMemoryBarrierAccessFlags3KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryBarrierAccessFlags3KHR.html - struct MemoryBarrierAccessFlags3KHR - { - using NativeType = VkMemoryBarrierAccessFlags3KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryBarrierAccessFlags3KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryBarrierAccessFlags3KHR( AccessFlags3KHR srcAccessMask3_ = {}, - AccessFlags3KHR dstAccessMask3_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcAccessMask3{ srcAccessMask3_ } - , dstAccessMask3{ dstAccessMask3_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryBarrierAccessFlags3KHR( MemoryBarrierAccessFlags3KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryBarrierAccessFlags3KHR( VkMemoryBarrierAccessFlags3KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryBarrierAccessFlags3KHR( *reinterpret_cast( &rhs ) ) - { - } - - MemoryBarrierAccessFlags3KHR & operator=( MemoryBarrierAccessFlags3KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryBarrierAccessFlags3KHR & operator=( VkMemoryBarrierAccessFlags3KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR & setSrcAccessMask3( AccessFlags3KHR srcAccessMask3_ ) & VULKAN_HPP_NOEXCEPT - { - srcAccessMask3 = srcAccessMask3_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR && setSrcAccessMask3( AccessFlags3KHR srcAccessMask3_ ) && VULKAN_HPP_NOEXCEPT - { - srcAccessMask3 = srcAccessMask3_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR & setDstAccessMask3( AccessFlags3KHR dstAccessMask3_ ) & VULKAN_HPP_NOEXCEPT - { - dstAccessMask3 = dstAccessMask3_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryBarrierAccessFlags3KHR && setDstAccessMask3( AccessFlags3KHR dstAccessMask3_ ) && VULKAN_HPP_NOEXCEPT - { - dstAccessMask3 = dstAccessMask3_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryBarrierAccessFlags3KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryBarrierAccessFlags3KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryBarrierAccessFlags3KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryBarrierAccessFlags3KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcAccessMask3, dstAccessMask3 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryBarrierAccessFlags3KHR const & ) const = default; -#else - bool operator==( MemoryBarrierAccessFlags3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcAccessMask3 == rhs.srcAccessMask3 ) && ( dstAccessMask3 == rhs.dstAccessMask3 ); -# endif - } - - bool operator!=( MemoryBarrierAccessFlags3KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryBarrierAccessFlags3KHR; - const void * pNext = {}; - AccessFlags3KHR srcAccessMask3 = {}; - AccessFlags3KHR dstAccessMask3 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryBarrierAccessFlags3KHR; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryBarrierAccessFlags3KHR; - }; - - // wrapper struct for struct VkMemoryDedicatedAllocateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDedicatedAllocateInfo.html - struct MemoryDedicatedAllocateInfo - { - using NativeType = VkMemoryDedicatedAllocateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedAllocateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( Image image_ = {}, Buffer buffer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , image{ image_ } - , buffer{ buffer_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfo( MemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryDedicatedAllocateInfo( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryDedicatedAllocateInfo( *reinterpret_cast( &rhs ) ) - { - } - - MemoryDedicatedAllocateInfo & operator=( MemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryDedicatedAllocateInfo & operator=( VkMemoryDedicatedAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo & setImage( Image image_ ) & VULKAN_HPP_NOEXCEPT - { - image = image_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo && setImage( Image image_ ) && VULKAN_HPP_NOEXCEPT - { - image = image_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfo && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryDedicatedAllocateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryDedicatedAllocateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryDedicatedAllocateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryDedicatedAllocateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, image, buffer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryDedicatedAllocateInfo const & ) const = default; -#else - bool operator==( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image == rhs.image ) && ( buffer == rhs.buffer ); -# endif - } - - bool operator!=( MemoryDedicatedAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryDedicatedAllocateInfo; - const void * pNext = {}; - Image image = {}; - Buffer buffer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryDedicatedAllocateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryDedicatedAllocateInfo; - }; - - using MemoryDedicatedAllocateInfoKHR = MemoryDedicatedAllocateInfo; - - // wrapper struct for struct VkMemoryDedicatedAllocateInfoTensorARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDedicatedAllocateInfoTensorARM.html - struct MemoryDedicatedAllocateInfoTensorARM - { - using NativeType = VkMemoryDedicatedAllocateInfoTensorARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedAllocateInfoTensorARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfoTensorARM( TensorARM tensor_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensor{ tensor_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryDedicatedAllocateInfoTensorARM( MemoryDedicatedAllocateInfoTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryDedicatedAllocateInfoTensorARM( VkMemoryDedicatedAllocateInfoTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryDedicatedAllocateInfoTensorARM( *reinterpret_cast( &rhs ) ) - { - } - - MemoryDedicatedAllocateInfoTensorARM & operator=( MemoryDedicatedAllocateInfoTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryDedicatedAllocateInfoTensorARM & operator=( VkMemoryDedicatedAllocateInfoTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfoTensorARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfoTensorARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfoTensorARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryDedicatedAllocateInfoTensorARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryDedicatedAllocateInfoTensorARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryDedicatedAllocateInfoTensorARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryDedicatedAllocateInfoTensorARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryDedicatedAllocateInfoTensorARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tensor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryDedicatedAllocateInfoTensorARM const & ) const = default; -#else - bool operator==( MemoryDedicatedAllocateInfoTensorARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensor == rhs.tensor ); -# endif - } - - bool operator!=( MemoryDedicatedAllocateInfoTensorARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryDedicatedAllocateInfoTensorARM; - const void * pNext = {}; - TensorARM tensor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryDedicatedAllocateInfoTensorARM; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryDedicatedAllocateInfoTensorARM; - }; - - // wrapper struct for struct VkMemoryDedicatedRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryDedicatedRequirements.html - struct MemoryDedicatedRequirements - { - using NativeType = VkMemoryDedicatedRequirements; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryDedicatedRequirements; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryDedicatedRequirements( Bool32 prefersDedicatedAllocation_ = {}, - Bool32 requiresDedicatedAllocation_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , prefersDedicatedAllocation{ prefersDedicatedAllocation_ } - , requiresDedicatedAllocation{ requiresDedicatedAllocation_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryDedicatedRequirements( MemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryDedicatedRequirements( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryDedicatedRequirements( *reinterpret_cast( &rhs ) ) - { - } - - MemoryDedicatedRequirements & operator=( MemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryDedicatedRequirements & operator=( VkMemoryDedicatedRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkMemoryDedicatedRequirements const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryDedicatedRequirements &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryDedicatedRequirements const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryDedicatedRequirements *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, prefersDedicatedAllocation, requiresDedicatedAllocation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryDedicatedRequirements const & ) const = default; -#else - bool operator==( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( prefersDedicatedAllocation == rhs.prefersDedicatedAllocation ) && - ( requiresDedicatedAllocation == rhs.requiresDedicatedAllocation ); -# endif - } - - bool operator!=( MemoryDedicatedRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryDedicatedRequirements; - void * pNext = {}; - Bool32 prefersDedicatedAllocation = {}; - Bool32 requiresDedicatedAllocation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryDedicatedRequirements; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryDedicatedRequirements; - }; - - using MemoryDedicatedRequirementsKHR = MemoryDedicatedRequirements; - - // wrapper struct for struct VkMemoryFdPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryFdPropertiesKHR.html - struct MemoryFdPropertiesKHR - { - using NativeType = VkMemoryFdPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryFdPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryFdPropertiesKHR( uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryTypeBits{ memoryTypeBits_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryFdPropertiesKHR( MemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryFdPropertiesKHR( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryFdPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - MemoryFdPropertiesKHR & operator=( MemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryFdPropertiesKHR & operator=( VkMemoryFdPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkMemoryFdPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryFdPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryFdPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryFdPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryTypeBits ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryFdPropertiesKHR const & ) const = default; -#else - bool operator==( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); -# endif - } - - bool operator!=( MemoryFdPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryFdPropertiesKHR; - void * pNext = {}; - uint32_t memoryTypeBits = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryFdPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryFdPropertiesKHR; - }; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - // wrapper struct for struct VkMemoryGetAndroidHardwareBufferInfoANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetAndroidHardwareBufferInfoANDROID.html - struct MemoryGetAndroidHardwareBufferInfoANDROID - { - using NativeType = VkMemoryGetAndroidHardwareBufferInfoANDROID; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memory{ memory_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryGetAndroidHardwareBufferInfoANDROID( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryGetAndroidHardwareBufferInfoANDROID( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryGetAndroidHardwareBufferInfoANDROID( *reinterpret_cast( &rhs ) ) - { - } - - MemoryGetAndroidHardwareBufferInfoANDROID & operator=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryGetAndroidHardwareBufferInfoANDROID & operator=( VkMemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryGetAndroidHardwareBufferInfoANDROID & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetAndroidHardwareBufferInfoANDROID && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetAndroidHardwareBufferInfoANDROID & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetAndroidHardwareBufferInfoANDROID && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryGetAndroidHardwareBufferInfoANDROID const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetAndroidHardwareBufferInfoANDROID &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetAndroidHardwareBufferInfoANDROID const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryGetAndroidHardwareBufferInfoANDROID *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memory ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryGetAndroidHardwareBufferInfoANDROID const & ) const = default; -# else - bool operator==( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); -# endif - } - - bool operator!=( MemoryGetAndroidHardwareBufferInfoANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID; - const void * pNext = {}; - DeviceMemory memory = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryGetAndroidHardwareBufferInfoANDROID; - }; -# endif - - template <> - struct CppType - { - using Type = MemoryGetAndroidHardwareBufferInfoANDROID; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - // wrapper struct for struct VkMemoryGetFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetFdInfoKHR.html - struct MemoryGetFdInfoKHR - { - using NativeType = VkMemoryGetFdInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetFdInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( DeviceMemory memory_ = {}, - ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memory{ memory_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryGetFdInfoKHR( MemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryGetFdInfoKHR( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryGetFdInfoKHR( *reinterpret_cast( &rhs ) ) {} - - MemoryGetFdInfoKHR & operator=( MemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryGetFdInfoKHR & operator=( VkMemoryGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetFdInfoKHR && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryGetFdInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memory, handleType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryGetFdInfoKHR const & ) const = default; -#else - bool operator==( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( MemoryGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryGetFdInfoKHR; - const void * pNext = {}; - DeviceMemory memory = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryGetFdInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryGetFdInfoKHR; - }; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkMemoryGetMetalHandleInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetMetalHandleInfoEXT.html - struct MemoryGetMetalHandleInfoEXT - { - using NativeType = VkMemoryGetMetalHandleInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetMetalHandleInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryGetMetalHandleInfoEXT( DeviceMemory memory_ = {}, - ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memory{ memory_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryGetMetalHandleInfoEXT( MemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryGetMetalHandleInfoEXT( VkMemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryGetMetalHandleInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - MemoryGetMetalHandleInfoEXT & operator=( MemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryGetMetalHandleInfoEXT & operator=( VkMemoryGetMetalHandleInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetMetalHandleInfoEXT && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryGetMetalHandleInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetMetalHandleInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetMetalHandleInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryGetMetalHandleInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memory, handleType ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryGetMetalHandleInfoEXT const & ) const = default; -# else - bool operator==( MemoryGetMetalHandleInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( MemoryGetMetalHandleInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eMemoryGetMetalHandleInfoEXT; - const void * pNext = {}; - DeviceMemory memory = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryGetMetalHandleInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = MemoryGetMetalHandleInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - -#if defined( VK_USE_PLATFORM_OHOS ) - // wrapper struct for struct VkMemoryGetNativeBufferInfoOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetNativeBufferInfoOHOS.html - struct MemoryGetNativeBufferInfoOHOS - { - using NativeType = VkMemoryGetNativeBufferInfoOHOS; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetNativeBufferInfoOHOS; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryGetNativeBufferInfoOHOS( DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memory{ memory_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryGetNativeBufferInfoOHOS( MemoryGetNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryGetNativeBufferInfoOHOS( VkMemoryGetNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryGetNativeBufferInfoOHOS( *reinterpret_cast( &rhs ) ) - { - } - - MemoryGetNativeBufferInfoOHOS & operator=( MemoryGetNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryGetNativeBufferInfoOHOS & operator=( VkMemoryGetNativeBufferInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryGetNativeBufferInfoOHOS & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetNativeBufferInfoOHOS && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetNativeBufferInfoOHOS & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetNativeBufferInfoOHOS && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryGetNativeBufferInfoOHOS const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetNativeBufferInfoOHOS &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetNativeBufferInfoOHOS const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryGetNativeBufferInfoOHOS *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memory ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryGetNativeBufferInfoOHOS const & ) const = default; -# else - bool operator==( MemoryGetNativeBufferInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); -# endif - } - - bool operator!=( MemoryGetNativeBufferInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eMemoryGetNativeBufferInfoOHOS; - const void * pNext = {}; - DeviceMemory memory = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryGetNativeBufferInfoOHOS; - }; -# endif - - template <> - struct CppType - { - using Type = MemoryGetNativeBufferInfoOHOS; - }; -#endif /*VK_USE_PLATFORM_OHOS*/ - - // wrapper struct for struct VkMemoryGetRemoteAddressInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetRemoteAddressInfoNV.html - struct MemoryGetRemoteAddressInfoNV - { - using NativeType = VkMemoryGetRemoteAddressInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetRemoteAddressInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryGetRemoteAddressInfoNV( DeviceMemory memory_ = {}, - ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memory{ memory_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryGetRemoteAddressInfoNV( MemoryGetRemoteAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryGetRemoteAddressInfoNV( VkMemoryGetRemoteAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryGetRemoteAddressInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - MemoryGetRemoteAddressInfoNV & operator=( MemoryGetRemoteAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryGetRemoteAddressInfoNV & operator=( VkMemoryGetRemoteAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetRemoteAddressInfoNV && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryGetRemoteAddressInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetRemoteAddressInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetRemoteAddressInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryGetRemoteAddressInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memory, handleType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryGetRemoteAddressInfoNV const & ) const = default; -#else - bool operator==( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( MemoryGetRemoteAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryGetRemoteAddressInfoNV; - const void * pNext = {}; - DeviceMemory memory = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryGetRemoteAddressInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryGetRemoteAddressInfoNV; - }; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkMemoryGetWin32HandleInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetWin32HandleInfoKHR.html - struct MemoryGetWin32HandleInfoKHR - { - using NativeType = VkMemoryGetWin32HandleInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetWin32HandleInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( DeviceMemory memory_ = {}, - ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memory{ memory_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryGetWin32HandleInfoKHR( MemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryGetWin32HandleInfoKHR( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryGetWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - MemoryGetWin32HandleInfoKHR & operator=( MemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryGetWin32HandleInfoKHR & operator=( VkMemoryGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetWin32HandleInfoKHR && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryGetWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memory, handleType ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryGetWin32HandleInfoKHR const & ) const = default; -# else - bool operator==( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( MemoryGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eMemoryGetWin32HandleInfoKHR; - const void * pNext = {}; - DeviceMemory memory = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryGetWin32HandleInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = MemoryGetWin32HandleInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkMemoryGetZirconHandleInfoFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryGetZirconHandleInfoFUCHSIA.html - struct MemoryGetZirconHandleInfoFUCHSIA - { - using NativeType = VkMemoryGetZirconHandleInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryGetZirconHandleInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryGetZirconHandleInfoFUCHSIA( DeviceMemory memory_ = {}, - ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memory{ memory_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryGetZirconHandleInfoFUCHSIA( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryGetZirconHandleInfoFUCHSIA( VkMemoryGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryGetZirconHandleInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - MemoryGetZirconHandleInfoFUCHSIA & operator=( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryGetZirconHandleInfoFUCHSIA & operator=( VkMemoryGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryGetZirconHandleInfoFUCHSIA && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryGetZirconHandleInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryGetZirconHandleInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memory, handleType ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryGetZirconHandleInfoFUCHSIA const & ) const = default; -# else - bool operator==( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( MemoryGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eMemoryGetZirconHandleInfoFUCHSIA; - const void * pNext = {}; - DeviceMemory memory = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryGetZirconHandleInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = MemoryGetZirconHandleInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - // wrapper struct for struct VkMemoryHeap, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryHeap.html - struct MemoryHeap - { - using NativeType = VkMemoryHeap; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryHeap( DeviceSize size_ = {}, MemoryHeapFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT - : size{ size_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryHeap( MemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryHeap( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryHeap( *reinterpret_cast( &rhs ) ) {} - - MemoryHeap & operator=( MemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryHeap & operator=( VkMemoryHeap const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkMemoryHeap const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryHeap &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryHeap const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryHeap *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( size, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryHeap const & ) const = default; -#else - bool operator==( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( size == rhs.size ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( MemoryHeap const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceSize size = {}; - MemoryHeapFlags flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryHeap; - }; -#endif - - // wrapper struct for struct VkMemoryHostPointerPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryHostPointerPropertiesEXT.html - struct MemoryHostPointerPropertiesEXT - { - using NativeType = VkMemoryHostPointerPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryHostPointerPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryHostPointerPropertiesEXT( uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryTypeBits{ memoryTypeBits_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryHostPointerPropertiesEXT( MemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryHostPointerPropertiesEXT( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryHostPointerPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - MemoryHostPointerPropertiesEXT & operator=( MemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryHostPointerPropertiesEXT & operator=( VkMemoryHostPointerPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkMemoryHostPointerPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryHostPointerPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryHostPointerPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryHostPointerPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryTypeBits ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryHostPointerPropertiesEXT const & ) const = default; -#else - bool operator==( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); -# endif - } - - bool operator!=( MemoryHostPointerPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryHostPointerPropertiesEXT; - void * pNext = {}; - uint32_t memoryTypeBits = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryHostPointerPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryHostPointerPropertiesEXT; - }; - - // wrapper struct for struct VkMemoryMapInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMapInfo.html - struct MemoryMapInfo - { - using NativeType = VkMemoryMapInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryMapInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryMapInfo( - MemoryMapFlags flags_ = {}, DeviceMemory memory_ = {}, DeviceSize offset_ = {}, DeviceSize size_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , memory{ memory_ } - , offset{ offset_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryMapInfo( MemoryMapInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryMapInfo( VkMemoryMapInfo const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryMapInfo( *reinterpret_cast( &rhs ) ) {} - - MemoryMapInfo & operator=( MemoryMapInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryMapInfo & operator=( VkMemoryMapInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo & setFlags( MemoryMapFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo && setFlags( MemoryMapFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapInfo && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryMapInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryMapInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryMapInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryMapInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, memory, offset, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryMapInfo const & ) const = default; -#else - bool operator==( MemoryMapInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( memory == rhs.memory ) && ( offset == rhs.offset ) && - ( size == rhs.size ); -# endif - } - - bool operator!=( MemoryMapInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryMapInfo; - const void * pNext = {}; - MemoryMapFlags flags = {}; - DeviceMemory memory = {}; - DeviceSize offset = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryMapInfo; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryMapInfo; - }; - - using MemoryMapInfoKHR = MemoryMapInfo; - - // wrapper struct for struct VkMemoryMapPlacedInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMapPlacedInfoEXT.html - struct MemoryMapPlacedInfoEXT - { - using NativeType = VkMemoryMapPlacedInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryMapPlacedInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryMapPlacedInfoEXT( void * pPlacedAddress_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pPlacedAddress{ pPlacedAddress_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryMapPlacedInfoEXT( MemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryMapPlacedInfoEXT( VkMemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryMapPlacedInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - MemoryMapPlacedInfoEXT & operator=( MemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryMapPlacedInfoEXT & operator=( VkMemoryMapPlacedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryMapPlacedInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapPlacedInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapPlacedInfoEXT & setPPlacedAddress( void * pPlacedAddress_ ) & VULKAN_HPP_NOEXCEPT - { - pPlacedAddress = pPlacedAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryMapPlacedInfoEXT && setPPlacedAddress( void * pPlacedAddress_ ) && VULKAN_HPP_NOEXCEPT - { - pPlacedAddress = pPlacedAddress_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryMapPlacedInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryMapPlacedInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryMapPlacedInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryMapPlacedInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pPlacedAddress ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryMapPlacedInfoEXT const & ) const = default; -#else - bool operator==( MemoryMapPlacedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pPlacedAddress == rhs.pPlacedAddress ); -# endif - } - - bool operator!=( MemoryMapPlacedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryMapPlacedInfoEXT; - const void * pNext = {}; - void * pPlacedAddress = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryMapPlacedInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryMapPlacedInfoEXT; - }; - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkMemoryMetalHandlePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryMetalHandlePropertiesEXT.html - struct MemoryMetalHandlePropertiesEXT - { - using NativeType = VkMemoryMetalHandlePropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryMetalHandlePropertiesEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryMetalHandlePropertiesEXT( uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryTypeBits{ memoryTypeBits_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryMetalHandlePropertiesEXT( MemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryMetalHandlePropertiesEXT( VkMemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryMetalHandlePropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - MemoryMetalHandlePropertiesEXT & operator=( MemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryMetalHandlePropertiesEXT & operator=( VkMemoryMetalHandlePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkMemoryMetalHandlePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryMetalHandlePropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryMetalHandlePropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryMetalHandlePropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryTypeBits ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryMetalHandlePropertiesEXT const & ) const = default; -# else - bool operator==( MemoryMetalHandlePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); -# endif - } - - bool operator!=( MemoryMetalHandlePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eMemoryMetalHandlePropertiesEXT; - void * pNext = {}; - uint32_t memoryTypeBits = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryMetalHandlePropertiesEXT; - }; -# endif - - template <> - struct CppType - { - using Type = MemoryMetalHandlePropertiesEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - // wrapper struct for struct VkMemoryOpaqueCaptureAddressAllocateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryOpaqueCaptureAddressAllocateInfo.html - struct MemoryOpaqueCaptureAddressAllocateInfo - { - using NativeType = VkMemoryOpaqueCaptureAddressAllocateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryOpaqueCaptureAddressAllocateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryOpaqueCaptureAddressAllocateInfo( uint64_t opaqueCaptureAddress_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , opaqueCaptureAddress{ opaqueCaptureAddress_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryOpaqueCaptureAddressAllocateInfo( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryOpaqueCaptureAddressAllocateInfo( VkMemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryOpaqueCaptureAddressAllocateInfo( *reinterpret_cast( &rhs ) ) - { - } - - MemoryOpaqueCaptureAddressAllocateInfo & operator=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryOpaqueCaptureAddressAllocateInfo & operator=( VkMemoryOpaqueCaptureAddressAllocateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryOpaqueCaptureAddressAllocateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryOpaqueCaptureAddressAllocateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryOpaqueCaptureAddressAllocateInfo & setOpaqueCaptureAddress( uint64_t opaqueCaptureAddress_ ) & VULKAN_HPP_NOEXCEPT - { - opaqueCaptureAddress = opaqueCaptureAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryOpaqueCaptureAddressAllocateInfo && setOpaqueCaptureAddress( uint64_t opaqueCaptureAddress_ ) && VULKAN_HPP_NOEXCEPT - { - opaqueCaptureAddress = opaqueCaptureAddress_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryOpaqueCaptureAddressAllocateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryOpaqueCaptureAddressAllocateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryOpaqueCaptureAddressAllocateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryOpaqueCaptureAddressAllocateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, opaqueCaptureAddress ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryOpaqueCaptureAddressAllocateInfo const & ) const = default; -#else - bool operator==( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureAddress == rhs.opaqueCaptureAddress ); -# endif - } - - bool operator!=( MemoryOpaqueCaptureAddressAllocateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryOpaqueCaptureAddressAllocateInfo; - const void * pNext = {}; - uint64_t opaqueCaptureAddress = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryOpaqueCaptureAddressAllocateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryOpaqueCaptureAddressAllocateInfo; - }; - - using MemoryOpaqueCaptureAddressAllocateInfoKHR = MemoryOpaqueCaptureAddressAllocateInfo; - - // wrapper struct for struct VkMemoryPriorityAllocateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryPriorityAllocateInfoEXT.html - struct MemoryPriorityAllocateInfoEXT - { - using NativeType = VkMemoryPriorityAllocateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryPriorityAllocateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( float priority_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , priority{ priority_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryPriorityAllocateInfoEXT( MemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryPriorityAllocateInfoEXT( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryPriorityAllocateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - MemoryPriorityAllocateInfoEXT & operator=( MemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryPriorityAllocateInfoEXT & operator=( VkMemoryPriorityAllocateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryPriorityAllocateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryPriorityAllocateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryPriorityAllocateInfoEXT & setPriority( float priority_ ) & VULKAN_HPP_NOEXCEPT - { - priority = priority_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryPriorityAllocateInfoEXT && setPriority( float priority_ ) && VULKAN_HPP_NOEXCEPT - { - priority = priority_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryPriorityAllocateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryPriorityAllocateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryPriorityAllocateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryPriorityAllocateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, priority ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryPriorityAllocateInfoEXT const & ) const = default; -#else - bool operator==( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priority == rhs.priority ); -# endif - } - - bool operator!=( MemoryPriorityAllocateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryPriorityAllocateInfoEXT; - const void * pNext = {}; - float priority = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryPriorityAllocateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryPriorityAllocateInfoEXT; - }; - - // wrapper struct for struct VkMemoryRequirements, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryRequirements.html - struct MemoryRequirements - { - using NativeType = VkMemoryRequirements; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryRequirements( DeviceSize size_ = {}, DeviceSize alignment_ = {}, uint32_t memoryTypeBits_ = {} ) VULKAN_HPP_NOEXCEPT - : size{ size_ } - , alignment{ alignment_ } - , memoryTypeBits{ memoryTypeBits_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryRequirements( MemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryRequirements( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryRequirements( *reinterpret_cast( &rhs ) ) {} - - MemoryRequirements & operator=( MemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryRequirements & operator=( VkMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryRequirements &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryRequirements const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryRequirements *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( size, alignment, memoryTypeBits ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryRequirements const & ) const = default; -#else - bool operator==( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( size == rhs.size ) && ( alignment == rhs.alignment ) && ( memoryTypeBits == rhs.memoryTypeBits ); -# endif - } - - bool operator!=( MemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceSize size = {}; - DeviceSize alignment = {}; - uint32_t memoryTypeBits = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryRequirements; - }; -#endif - - // wrapper struct for struct VkMemoryRequirements2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryRequirements2.html - struct MemoryRequirements2 - { - using NativeType = VkMemoryRequirements2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryRequirements2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryRequirements2( MemoryRequirements memoryRequirements_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryRequirements{ memoryRequirements_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryRequirements2( MemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryRequirements2( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryRequirements2( *reinterpret_cast( &rhs ) ) - { - } - - MemoryRequirements2 & operator=( MemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryRequirements2 & operator=( VkMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryRequirements2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryRequirements2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryRequirements ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryRequirements2 const & ) const = default; -#else - bool operator==( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements ); -# endif - } - - bool operator!=( MemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryRequirements2; - void * pNext = {}; - MemoryRequirements memoryRequirements = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryRequirements2; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryRequirements2; - }; - - using MemoryRequirements2KHR = MemoryRequirements2; - - // wrapper struct for struct VkMemoryType, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryType.html - struct MemoryType - { - using NativeType = VkMemoryType; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryType( MemoryPropertyFlags propertyFlags_ = {}, uint32_t heapIndex_ = {} ) VULKAN_HPP_NOEXCEPT - : propertyFlags{ propertyFlags_ } - , heapIndex{ heapIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryType( MemoryType const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryType( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryType( *reinterpret_cast( &rhs ) ) {} - - MemoryType & operator=( MemoryType const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryType & operator=( VkMemoryType const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkMemoryType const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryType &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryType const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryType *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( propertyFlags, heapIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryType const & ) const = default; -#else - bool operator==( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( propertyFlags == rhs.propertyFlags ) && ( heapIndex == rhs.heapIndex ); -# endif - } - - bool operator!=( MemoryType const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - MemoryPropertyFlags propertyFlags = {}; - uint32_t heapIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryType; - }; -#endif - - // wrapper struct for struct VkMemoryUnmapInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryUnmapInfo.html - struct MemoryUnmapInfo - { - using NativeType = VkMemoryUnmapInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryUnmapInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryUnmapInfo( MemoryUnmapFlags flags_ = {}, DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , memory{ memory_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryUnmapInfo( MemoryUnmapInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryUnmapInfo( VkMemoryUnmapInfo const & rhs ) VULKAN_HPP_NOEXCEPT : MemoryUnmapInfo( *reinterpret_cast( &rhs ) ) {} - - MemoryUnmapInfo & operator=( MemoryUnmapInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryUnmapInfo & operator=( VkMemoryUnmapInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo & setFlags( MemoryUnmapFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo && setFlags( MemoryUnmapFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MemoryUnmapInfo && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMemoryUnmapInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryUnmapInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryUnmapInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryUnmapInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, memory ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryUnmapInfo const & ) const = default; -#else - bool operator==( MemoryUnmapInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( memory == rhs.memory ); -# endif - } - - bool operator!=( MemoryUnmapInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMemoryUnmapInfo; - const void * pNext = {}; - MemoryUnmapFlags flags = {}; - DeviceMemory memory = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryUnmapInfo; - }; -#endif - - template <> - struct CppType - { - using Type = MemoryUnmapInfo; - }; - - using MemoryUnmapInfoKHR = MemoryUnmapInfo; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkMemoryWin32HandlePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryWin32HandlePropertiesKHR.html - struct MemoryWin32HandlePropertiesKHR - { - using NativeType = VkMemoryWin32HandlePropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryWin32HandlePropertiesKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryWin32HandlePropertiesKHR( uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryTypeBits{ memoryTypeBits_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryWin32HandlePropertiesKHR( MemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryWin32HandlePropertiesKHR( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryWin32HandlePropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - MemoryWin32HandlePropertiesKHR & operator=( MemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryWin32HandlePropertiesKHR & operator=( VkMemoryWin32HandlePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkMemoryWin32HandlePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryWin32HandlePropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryWin32HandlePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryWin32HandlePropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryTypeBits ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryWin32HandlePropertiesKHR const & ) const = default; -# else - bool operator==( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); -# endif - } - - bool operator!=( MemoryWin32HandlePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eMemoryWin32HandlePropertiesKHR; - void * pNext = {}; - uint32_t memoryTypeBits = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryWin32HandlePropertiesKHR; - }; -# endif - - template <> - struct CppType - { - using Type = MemoryWin32HandlePropertiesKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkMemoryZirconHandlePropertiesFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMemoryZirconHandlePropertiesFUCHSIA.html - struct MemoryZirconHandlePropertiesFUCHSIA - { - using NativeType = VkMemoryZirconHandlePropertiesFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMemoryZirconHandlePropertiesFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MemoryZirconHandlePropertiesFUCHSIA( uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryTypeBits{ memoryTypeBits_ } - { - } - - VULKAN_HPP_CONSTEXPR MemoryZirconHandlePropertiesFUCHSIA( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MemoryZirconHandlePropertiesFUCHSIA( VkMemoryZirconHandlePropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : MemoryZirconHandlePropertiesFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - MemoryZirconHandlePropertiesFUCHSIA & operator=( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MemoryZirconHandlePropertiesFUCHSIA & operator=( VkMemoryZirconHandlePropertiesFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkMemoryZirconHandlePropertiesFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryZirconHandlePropertiesFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMemoryZirconHandlePropertiesFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMemoryZirconHandlePropertiesFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryTypeBits ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MemoryZirconHandlePropertiesFUCHSIA const & ) const = default; -# else - bool operator==( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryTypeBits == rhs.memoryTypeBits ); -# endif - } - - bool operator!=( MemoryZirconHandlePropertiesFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eMemoryZirconHandlePropertiesFUCHSIA; - void * pNext = {}; - uint32_t memoryTypeBits = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MemoryZirconHandlePropertiesFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = MemoryZirconHandlePropertiesFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - // wrapper struct for struct VkMetalSurfaceCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMetalSurfaceCreateInfoEXT.html - struct MetalSurfaceCreateInfoEXT - { - using NativeType = VkMetalSurfaceCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMetalSurfaceCreateInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - MetalSurfaceCreateInfoEXT( MetalSurfaceCreateFlagsEXT flags_ = {}, const CAMetalLayer * pLayer_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pLayer{ pLayer_ } - { - } - - VULKAN_HPP_CONSTEXPR MetalSurfaceCreateInfoEXT( MetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MetalSurfaceCreateInfoEXT( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MetalSurfaceCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - MetalSurfaceCreateInfoEXT & operator=( MetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MetalSurfaceCreateInfoEXT & operator=( VkMetalSurfaceCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT & setFlags( MetalSurfaceCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT && setFlags( MetalSurfaceCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT & setPLayer( const CAMetalLayer * pLayer_ ) & VULKAN_HPP_NOEXCEPT - { - pLayer = pLayer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MetalSurfaceCreateInfoEXT && setPLayer( const CAMetalLayer * pLayer_ ) && VULKAN_HPP_NOEXCEPT - { - pLayer = pLayer_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMetalSurfaceCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMetalSurfaceCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMetalSurfaceCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMetalSurfaceCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, pLayer ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MetalSurfaceCreateInfoEXT const & ) const = default; -# else - bool operator==( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pLayer == rhs.pLayer ); -# endif - } - - bool operator!=( MetalSurfaceCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eMetalSurfaceCreateInfoEXT; - const void * pNext = {}; - MetalSurfaceCreateFlagsEXT flags = {}; - const CAMetalLayer * pLayer = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MetalSurfaceCreateInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = MetalSurfaceCreateInfoEXT; - }; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - // wrapper struct for struct VkMicromapBuildInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapBuildInfoEXT.html - struct MicromapBuildInfoEXT - { - using NativeType = VkMicromapBuildInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMicromapBuildInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT( MicromapTypeEXT type_ = MicromapTypeEXT::eOpacityMicromap, - BuildMicromapFlagsEXT flags_ = {}, - BuildMicromapModeEXT mode_ = BuildMicromapModeEXT::eBuild, - MicromapEXT dstMicromap_ = {}, - uint32_t usageCountsCount_ = {}, - const MicromapUsageEXT * pUsageCounts_ = {}, - const MicromapUsageEXT * const * ppUsageCounts_ = {}, - DeviceOrHostAddressConstKHR data_ = {}, - DeviceOrHostAddressKHR scratchData_ = {}, - DeviceOrHostAddressConstKHR triangleArray_ = {}, - DeviceSize triangleArrayStride_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , flags{ flags_ } - , mode{ mode_ } - , dstMicromap{ dstMicromap_ } - , usageCountsCount{ usageCountsCount_ } - , pUsageCounts{ pUsageCounts_ } - , ppUsageCounts{ ppUsageCounts_ } - , data{ data_ } - , scratchData{ scratchData_ } - , triangleArray{ triangleArray_ } - , triangleArrayStride{ triangleArrayStride_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT( MicromapBuildInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MicromapBuildInfoEXT( VkMicromapBuildInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MicromapBuildInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - MicromapBuildInfoEXT( MicromapTypeEXT type_, - BuildMicromapFlagsEXT flags_, - BuildMicromapModeEXT mode_, - MicromapEXT dstMicromap_, - ArrayProxyNoTemporaries const & usageCounts_, - ArrayProxyNoTemporaries const & pUsageCounts_ = {}, - DeviceOrHostAddressConstKHR data_ = {}, - DeviceOrHostAddressKHR scratchData_ = {}, - DeviceOrHostAddressConstKHR triangleArray_ = {}, - DeviceSize triangleArrayStride_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , type( type_ ) - , flags( flags_ ) - , mode( mode_ ) - , dstMicromap( dstMicromap_ ) - , usageCountsCount( static_cast( !usageCounts_.empty() ? usageCounts_.size() : pUsageCounts_.size() ) ) - , pUsageCounts( usageCounts_.data() ) - , ppUsageCounts( pUsageCounts_.data() ) - , data( data_ ) - , scratchData( scratchData_ ) - , triangleArray( triangleArray_ ) - , triangleArrayStride( triangleArrayStride_ ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( ( !usageCounts_.empty() + !pUsageCounts_.empty() ) <= 1 ); -# else - if ( 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() ) ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::MicromapBuildInfoEXT::MicromapBuildInfoEXT: 1 < ( !usageCounts_.empty() + !pUsageCounts_.empty() )" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - MicromapBuildInfoEXT & operator=( MicromapBuildInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MicromapBuildInfoEXT & operator=( VkMicromapBuildInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setType( MicromapTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setType( MicromapTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setFlags( BuildMicromapFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setFlags( BuildMicromapFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setMode( BuildMicromapModeEXT mode_ ) & VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setMode( BuildMicromapModeEXT mode_ ) && VULKAN_HPP_NOEXCEPT - { - mode = mode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setDstMicromap( MicromapEXT dstMicromap_ ) & VULKAN_HPP_NOEXCEPT - { - dstMicromap = dstMicromap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setDstMicromap( MicromapEXT dstMicromap_ ) && VULKAN_HPP_NOEXCEPT - { - dstMicromap = dstMicromap_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setUsageCountsCount( uint32_t usageCountsCount_ ) & VULKAN_HPP_NOEXCEPT - { - usageCountsCount = usageCountsCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setUsageCountsCount( uint32_t usageCountsCount_ ) && VULKAN_HPP_NOEXCEPT - { - usageCountsCount = usageCountsCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) & VULKAN_HPP_NOEXCEPT - { - pUsageCounts = pUsageCounts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setPUsageCounts( const MicromapUsageEXT * pUsageCounts_ ) && VULKAN_HPP_NOEXCEPT - { - pUsageCounts = pUsageCounts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - MicromapBuildInfoEXT & setUsageCounts( ArrayProxyNoTemporaries const & usageCounts_ ) VULKAN_HPP_NOEXCEPT - { - usageCountsCount = static_cast( usageCounts_.size() ); - pUsageCounts = usageCounts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) & VULKAN_HPP_NOEXCEPT - { - ppUsageCounts = ppUsageCounts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setPpUsageCounts( const MicromapUsageEXT * const * ppUsageCounts_ ) && VULKAN_HPP_NOEXCEPT - { - ppUsageCounts = ppUsageCounts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - MicromapBuildInfoEXT & setPUsageCounts( ArrayProxyNoTemporaries const & pUsageCounts_ ) VULKAN_HPP_NOEXCEPT - { - usageCountsCount = static_cast( pUsageCounts_.size() ); - ppUsageCounts = pUsageCounts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setData( DeviceOrHostAddressConstKHR const & data_ ) & VULKAN_HPP_NOEXCEPT - { - data = data_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setData( DeviceOrHostAddressConstKHR const & data_ ) && VULKAN_HPP_NOEXCEPT - { - data = data_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setScratchData( DeviceOrHostAddressKHR const & scratchData_ ) & VULKAN_HPP_NOEXCEPT - { - scratchData = scratchData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setScratchData( DeviceOrHostAddressKHR const & scratchData_ ) && VULKAN_HPP_NOEXCEPT - { - scratchData = scratchData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setTriangleArray( DeviceOrHostAddressConstKHR const & triangleArray_ ) & VULKAN_HPP_NOEXCEPT - { - triangleArray = triangleArray_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setTriangleArray( DeviceOrHostAddressConstKHR const & triangleArray_ ) && VULKAN_HPP_NOEXCEPT - { - triangleArray = triangleArray_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT & setTriangleArrayStride( DeviceSize triangleArrayStride_ ) & VULKAN_HPP_NOEXCEPT - { - triangleArrayStride = triangleArrayStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildInfoEXT && setTriangleArrayStride( DeviceSize triangleArrayStride_ ) && VULKAN_HPP_NOEXCEPT - { - triangleArrayStride = triangleArrayStride_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMicromapBuildInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapBuildInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapBuildInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMicromapBuildInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, type, flags, mode, dstMicromap, usageCountsCount, pUsageCounts, ppUsageCounts, data, scratchData, triangleArray, triangleArrayStride ); - } -#endif - - public: - StructureType sType = StructureType::eMicromapBuildInfoEXT; - const void * pNext = {}; - MicromapTypeEXT type = MicromapTypeEXT::eOpacityMicromap; - BuildMicromapFlagsEXT flags = {}; - BuildMicromapModeEXT mode = BuildMicromapModeEXT::eBuild; - MicromapEXT dstMicromap = {}; - uint32_t usageCountsCount = {}; - const MicromapUsageEXT * pUsageCounts = {}; - const MicromapUsageEXT * const * ppUsageCounts = {}; - DeviceOrHostAddressConstKHR data = {}; - DeviceOrHostAddressKHR scratchData = {}; - DeviceOrHostAddressConstKHR triangleArray = {}; - DeviceSize triangleArrayStride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MicromapBuildInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = MicromapBuildInfoEXT; - }; - - // wrapper struct for struct VkMicromapBuildSizesInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapBuildSizesInfoEXT.html - struct MicromapBuildSizesInfoEXT - { - using NativeType = VkMicromapBuildSizesInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMicromapBuildSizesInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MicromapBuildSizesInfoEXT( DeviceSize micromapSize_ = {}, - DeviceSize buildScratchSize_ = {}, - Bool32 discardable_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , micromapSize{ micromapSize_ } - , buildScratchSize{ buildScratchSize_ } - , discardable{ discardable_ } - { - } - - VULKAN_HPP_CONSTEXPR MicromapBuildSizesInfoEXT( MicromapBuildSizesInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MicromapBuildSizesInfoEXT( VkMicromapBuildSizesInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MicromapBuildSizesInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - MicromapBuildSizesInfoEXT & operator=( MicromapBuildSizesInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MicromapBuildSizesInfoEXT & operator=( VkMicromapBuildSizesInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT & setMicromapSize( DeviceSize micromapSize_ ) & VULKAN_HPP_NOEXCEPT - { - micromapSize = micromapSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT && setMicromapSize( DeviceSize micromapSize_ ) && VULKAN_HPP_NOEXCEPT - { - micromapSize = micromapSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT & setBuildScratchSize( DeviceSize buildScratchSize_ ) & VULKAN_HPP_NOEXCEPT - { - buildScratchSize = buildScratchSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT && setBuildScratchSize( DeviceSize buildScratchSize_ ) && VULKAN_HPP_NOEXCEPT - { - buildScratchSize = buildScratchSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT & setDiscardable( Bool32 discardable_ ) & VULKAN_HPP_NOEXCEPT - { - discardable = discardable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapBuildSizesInfoEXT && setDiscardable( Bool32 discardable_ ) && VULKAN_HPP_NOEXCEPT - { - discardable = discardable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMicromapBuildSizesInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapBuildSizesInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapBuildSizesInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMicromapBuildSizesInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, micromapSize, buildScratchSize, discardable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MicromapBuildSizesInfoEXT const & ) const = default; -#else - bool operator==( MicromapBuildSizesInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( micromapSize == rhs.micromapSize ) && ( buildScratchSize == rhs.buildScratchSize ) && - ( discardable == rhs.discardable ); -# endif - } - - bool operator!=( MicromapBuildSizesInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMicromapBuildSizesInfoEXT; - const void * pNext = {}; - DeviceSize micromapSize = {}; - DeviceSize buildScratchSize = {}; - Bool32 discardable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MicromapBuildSizesInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = MicromapBuildSizesInfoEXT; - }; - - // wrapper struct for struct VkMicromapCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapCreateInfoEXT.html - struct MicromapCreateInfoEXT - { - using NativeType = VkMicromapCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMicromapCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MicromapCreateInfoEXT( MicromapCreateFlagsEXT createFlags_ = {}, - Buffer buffer_ = {}, - DeviceSize offset_ = {}, - DeviceSize size_ = {}, - MicromapTypeEXT type_ = MicromapTypeEXT::eOpacityMicromap, - DeviceAddress deviceAddress_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , createFlags{ createFlags_ } - , buffer{ buffer_ } - , offset{ offset_ } - , size{ size_ } - , type{ type_ } - , deviceAddress{ deviceAddress_ } - { - } - - VULKAN_HPP_CONSTEXPR MicromapCreateInfoEXT( MicromapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MicromapCreateInfoEXT( VkMicromapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MicromapCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - MicromapCreateInfoEXT & operator=( MicromapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MicromapCreateInfoEXT & operator=( VkMicromapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setCreateFlags( MicromapCreateFlagsEXT createFlags_ ) & VULKAN_HPP_NOEXCEPT - { - createFlags = createFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setCreateFlags( MicromapCreateFlagsEXT createFlags_ ) && VULKAN_HPP_NOEXCEPT - { - createFlags = createFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setBuffer( Buffer buffer_ ) & VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setBuffer( Buffer buffer_ ) && VULKAN_HPP_NOEXCEPT - { - buffer = buffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setOffset( DeviceSize offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setOffset( DeviceSize offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setType( MicromapTypeEXT type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setType( MicromapTypeEXT type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT & setDeviceAddress( DeviceAddress deviceAddress_ ) & VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapCreateInfoEXT && setDeviceAddress( DeviceAddress deviceAddress_ ) && VULKAN_HPP_NOEXCEPT - { - deviceAddress = deviceAddress_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMicromapCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMicromapCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, createFlags, buffer, offset, size, type, deviceAddress ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MicromapCreateInfoEXT const & ) const = default; -#else - bool operator==( MicromapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( createFlags == rhs.createFlags ) && ( buffer == rhs.buffer ) && ( offset == rhs.offset ) && - ( size == rhs.size ) && ( type == rhs.type ) && ( deviceAddress == rhs.deviceAddress ); -# endif - } - - bool operator!=( MicromapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMicromapCreateInfoEXT; - const void * pNext = {}; - MicromapCreateFlagsEXT createFlags = {}; - Buffer buffer = {}; - DeviceSize offset = {}; - DeviceSize size = {}; - MicromapTypeEXT type = MicromapTypeEXT::eOpacityMicromap; - DeviceAddress deviceAddress = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MicromapCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = MicromapCreateInfoEXT; - }; - - // wrapper struct for struct VkMicromapTriangleEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapTriangleEXT.html - struct MicromapTriangleEXT - { - using NativeType = VkMicromapTriangleEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MicromapTriangleEXT( uint32_t dataOffset_ = {}, uint16_t subdivisionLevel_ = {}, uint16_t format_ = {} ) VULKAN_HPP_NOEXCEPT - : dataOffset{ dataOffset_ } - , subdivisionLevel{ subdivisionLevel_ } - , format{ format_ } - { - } - - VULKAN_HPP_CONSTEXPR MicromapTriangleEXT( MicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MicromapTriangleEXT( VkMicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT : MicromapTriangleEXT( *reinterpret_cast( &rhs ) ) - { - } - - MicromapTriangleEXT & operator=( MicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MicromapTriangleEXT & operator=( VkMicromapTriangleEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT & setDataOffset( uint32_t dataOffset_ ) & VULKAN_HPP_NOEXCEPT - { - dataOffset = dataOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT && setDataOffset( uint32_t dataOffset_ ) && VULKAN_HPP_NOEXCEPT - { - dataOffset = dataOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT & setSubdivisionLevel( uint16_t subdivisionLevel_ ) & VULKAN_HPP_NOEXCEPT - { - subdivisionLevel = subdivisionLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT && setSubdivisionLevel( uint16_t subdivisionLevel_ ) && VULKAN_HPP_NOEXCEPT - { - subdivisionLevel = subdivisionLevel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT & setFormat( uint16_t format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapTriangleEXT && setFormat( uint16_t format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMicromapTriangleEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapTriangleEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapTriangleEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMicromapTriangleEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( dataOffset, subdivisionLevel, format ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MicromapTriangleEXT const & ) const = default; -#else - bool operator==( MicromapTriangleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( dataOffset == rhs.dataOffset ) && ( subdivisionLevel == rhs.subdivisionLevel ) && ( format == rhs.format ); -# endif - } - - bool operator!=( MicromapTriangleEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t dataOffset = {}; - uint16_t subdivisionLevel = {}; - uint16_t format = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MicromapTriangleEXT; - }; -#endif - - // wrapper struct for struct VkMicromapVersionInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMicromapVersionInfoEXT.html - struct MicromapVersionInfoEXT - { - using NativeType = VkMicromapVersionInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMicromapVersionInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MicromapVersionInfoEXT( const uint8_t * pVersionData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pVersionData{ pVersionData_ } - { - } - - VULKAN_HPP_CONSTEXPR MicromapVersionInfoEXT( MicromapVersionInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MicromapVersionInfoEXT( VkMicromapVersionInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MicromapVersionInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - MicromapVersionInfoEXT & operator=( MicromapVersionInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MicromapVersionInfoEXT & operator=( VkMicromapVersionInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MicromapVersionInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapVersionInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MicromapVersionInfoEXT & setPVersionData( const uint8_t * pVersionData_ ) & VULKAN_HPP_NOEXCEPT - { - pVersionData = pVersionData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MicromapVersionInfoEXT && setPVersionData( const uint8_t * pVersionData_ ) && VULKAN_HPP_NOEXCEPT - { - pVersionData = pVersionData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMicromapVersionInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapVersionInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMicromapVersionInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMicromapVersionInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pVersionData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MicromapVersionInfoEXT const & ) const = default; -#else - bool operator==( MicromapVersionInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVersionData == rhs.pVersionData ); -# endif - } - - bool operator!=( MicromapVersionInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMicromapVersionInfoEXT; - const void * pNext = {}; - const uint8_t * pVersionData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MicromapVersionInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = MicromapVersionInfoEXT; - }; - - // wrapper struct for struct VkMultiDrawIndexedInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultiDrawIndexedInfoEXT.html - struct MultiDrawIndexedInfoEXT - { - using NativeType = VkMultiDrawIndexedInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MultiDrawIndexedInfoEXT( uint32_t firstIndex_ = {}, uint32_t indexCount_ = {}, int32_t vertexOffset_ = {} ) VULKAN_HPP_NOEXCEPT - : firstIndex{ firstIndex_ } - , indexCount{ indexCount_ } - , vertexOffset{ vertexOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR MultiDrawIndexedInfoEXT( MultiDrawIndexedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MultiDrawIndexedInfoEXT( VkMultiDrawIndexedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MultiDrawIndexedInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - MultiDrawIndexedInfoEXT & operator=( MultiDrawIndexedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MultiDrawIndexedInfoEXT & operator=( VkMultiDrawIndexedInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT & setFirstIndex( uint32_t firstIndex_ ) & VULKAN_HPP_NOEXCEPT - { - firstIndex = firstIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT && setFirstIndex( uint32_t firstIndex_ ) && VULKAN_HPP_NOEXCEPT - { - firstIndex = firstIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT & setIndexCount( uint32_t indexCount_ ) & VULKAN_HPP_NOEXCEPT - { - indexCount = indexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT && setIndexCount( uint32_t indexCount_ ) && VULKAN_HPP_NOEXCEPT - { - indexCount = indexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT & setVertexOffset( int32_t vertexOffset_ ) & VULKAN_HPP_NOEXCEPT - { - vertexOffset = vertexOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultiDrawIndexedInfoEXT && setVertexOffset( int32_t vertexOffset_ ) && VULKAN_HPP_NOEXCEPT - { - vertexOffset = vertexOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMultiDrawIndexedInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultiDrawIndexedInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultiDrawIndexedInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMultiDrawIndexedInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( firstIndex, indexCount, vertexOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MultiDrawIndexedInfoEXT const & ) const = default; -#else - bool operator==( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( firstIndex == rhs.firstIndex ) && ( indexCount == rhs.indexCount ) && ( vertexOffset == rhs.vertexOffset ); -# endif - } - - bool operator!=( MultiDrawIndexedInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t firstIndex = {}; - uint32_t indexCount = {}; - int32_t vertexOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MultiDrawIndexedInfoEXT; - }; -#endif - - // wrapper struct for struct VkMultiDrawInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultiDrawInfoEXT.html - struct MultiDrawInfoEXT - { - using NativeType = VkMultiDrawInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MultiDrawInfoEXT( uint32_t firstVertex_ = {}, uint32_t vertexCount_ = {} ) VULKAN_HPP_NOEXCEPT - : firstVertex{ firstVertex_ } - , vertexCount{ vertexCount_ } - { - } - - VULKAN_HPP_CONSTEXPR MultiDrawInfoEXT( MultiDrawInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MultiDrawInfoEXT( VkMultiDrawInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : MultiDrawInfoEXT( *reinterpret_cast( &rhs ) ) {} - - MultiDrawInfoEXT & operator=( MultiDrawInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MultiDrawInfoEXT & operator=( VkMultiDrawInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MultiDrawInfoEXT & setFirstVertex( uint32_t firstVertex_ ) & VULKAN_HPP_NOEXCEPT - { - firstVertex = firstVertex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultiDrawInfoEXT && setFirstVertex( uint32_t firstVertex_ ) && VULKAN_HPP_NOEXCEPT - { - firstVertex = firstVertex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MultiDrawInfoEXT & setVertexCount( uint32_t vertexCount_ ) & VULKAN_HPP_NOEXCEPT - { - vertexCount = vertexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultiDrawInfoEXT && setVertexCount( uint32_t vertexCount_ ) && VULKAN_HPP_NOEXCEPT - { - vertexCount = vertexCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMultiDrawInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultiDrawInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultiDrawInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMultiDrawInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( firstVertex, vertexCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MultiDrawInfoEXT const & ) const = default; -#else - bool operator==( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( firstVertex == rhs.firstVertex ) && ( vertexCount == rhs.vertexCount ); -# endif - } - - bool operator!=( MultiDrawInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t firstVertex = {}; - uint32_t vertexCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MultiDrawInfoEXT; - }; -#endif - - // wrapper struct for struct VkMultisamplePropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultisamplePropertiesEXT.html - struct MultisamplePropertiesEXT - { - using NativeType = VkMultisamplePropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultisamplePropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MultisamplePropertiesEXT( Extent2D maxSampleLocationGridSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxSampleLocationGridSize{ maxSampleLocationGridSize_ } - { - } - - VULKAN_HPP_CONSTEXPR MultisamplePropertiesEXT( MultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MultisamplePropertiesEXT( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MultisamplePropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - MultisamplePropertiesEXT & operator=( MultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MultisamplePropertiesEXT & operator=( VkMultisamplePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkMultisamplePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultisamplePropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultisamplePropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMultisamplePropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxSampleLocationGridSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MultisamplePropertiesEXT const & ) const = default; -#else - bool operator==( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ); -# endif - } - - bool operator!=( MultisamplePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMultisamplePropertiesEXT; - void * pNext = {}; - Extent2D maxSampleLocationGridSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MultisamplePropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = MultisamplePropertiesEXT; - }; - - // wrapper struct for struct VkMultisampledRenderToSingleSampledInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultisampledRenderToSingleSampledInfoEXT.html - struct MultisampledRenderToSingleSampledInfoEXT - { - using NativeType = VkMultisampledRenderToSingleSampledInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultisampledRenderToSingleSampledInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MultisampledRenderToSingleSampledInfoEXT( Bool32 multisampledRenderToSingleSampledEnable_ = {}, - SampleCountFlagBits rasterizationSamples_ = SampleCountFlagBits::e1, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , multisampledRenderToSingleSampledEnable{ multisampledRenderToSingleSampledEnable_ } - , rasterizationSamples{ rasterizationSamples_ } - { - } - - VULKAN_HPP_CONSTEXPR MultisampledRenderToSingleSampledInfoEXT( MultisampledRenderToSingleSampledInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MultisampledRenderToSingleSampledInfoEXT( VkMultisampledRenderToSingleSampledInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MultisampledRenderToSingleSampledInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - MultisampledRenderToSingleSampledInfoEXT & operator=( MultisampledRenderToSingleSampledInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MultisampledRenderToSingleSampledInfoEXT & operator=( VkMultisampledRenderToSingleSampledInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT & - setMultisampledRenderToSingleSampledEnable( Bool32 multisampledRenderToSingleSampledEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - multisampledRenderToSingleSampledEnable = multisampledRenderToSingleSampledEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT && - setMultisampledRenderToSingleSampledEnable( Bool32 multisampledRenderToSingleSampledEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - multisampledRenderToSingleSampledEnable = multisampledRenderToSingleSampledEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT & setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) & - VULKAN_HPP_NOEXCEPT - { - rasterizationSamples = rasterizationSamples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultisampledRenderToSingleSampledInfoEXT && setRasterizationSamples( SampleCountFlagBits rasterizationSamples_ ) && - VULKAN_HPP_NOEXCEPT - { - rasterizationSamples = rasterizationSamples_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMultisampledRenderToSingleSampledInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultisampledRenderToSingleSampledInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultisampledRenderToSingleSampledInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMultisampledRenderToSingleSampledInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, multisampledRenderToSingleSampledEnable, rasterizationSamples ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MultisampledRenderToSingleSampledInfoEXT const & ) const = default; -#else - bool operator==( MultisampledRenderToSingleSampledInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multisampledRenderToSingleSampledEnable == rhs.multisampledRenderToSingleSampledEnable ) && - ( rasterizationSamples == rhs.rasterizationSamples ); -# endif - } - - bool operator!=( MultisampledRenderToSingleSampledInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMultisampledRenderToSingleSampledInfoEXT; - const void * pNext = {}; - Bool32 multisampledRenderToSingleSampledEnable = {}; - SampleCountFlagBits rasterizationSamples = SampleCountFlagBits::e1; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MultisampledRenderToSingleSampledInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = MultisampledRenderToSingleSampledInfoEXT; - }; - - // wrapper struct for struct VkMultiviewPerViewAttributesInfoNVX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultiviewPerViewAttributesInfoNVX.html - struct MultiviewPerViewAttributesInfoNVX - { - using NativeType = VkMultiviewPerViewAttributesInfoNVX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultiviewPerViewAttributesInfoNVX; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MultiviewPerViewAttributesInfoNVX( Bool32 perViewAttributes_ = {}, - Bool32 perViewAttributesPositionXOnly_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , perViewAttributes{ perViewAttributes_ } - , perViewAttributesPositionXOnly{ perViewAttributesPositionXOnly_ } - { - } - - VULKAN_HPP_CONSTEXPR MultiviewPerViewAttributesInfoNVX( MultiviewPerViewAttributesInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MultiviewPerViewAttributesInfoNVX( VkMultiviewPerViewAttributesInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : MultiviewPerViewAttributesInfoNVX( *reinterpret_cast( &rhs ) ) - { - } - - MultiviewPerViewAttributesInfoNVX & operator=( MultiviewPerViewAttributesInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MultiviewPerViewAttributesInfoNVX & operator=( VkMultiviewPerViewAttributesInfoNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX & setPerViewAttributes( Bool32 perViewAttributes_ ) & VULKAN_HPP_NOEXCEPT - { - perViewAttributes = perViewAttributes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX && setPerViewAttributes( Bool32 perViewAttributes_ ) && VULKAN_HPP_NOEXCEPT - { - perViewAttributes = perViewAttributes_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX & setPerViewAttributesPositionXOnly( Bool32 perViewAttributesPositionXOnly_ ) & - VULKAN_HPP_NOEXCEPT - { - perViewAttributesPositionXOnly = perViewAttributesPositionXOnly_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewAttributesInfoNVX && setPerViewAttributesPositionXOnly( Bool32 perViewAttributesPositionXOnly_ ) && - VULKAN_HPP_NOEXCEPT - { - perViewAttributesPositionXOnly = perViewAttributesPositionXOnly_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMultiviewPerViewAttributesInfoNVX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultiviewPerViewAttributesInfoNVX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultiviewPerViewAttributesInfoNVX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMultiviewPerViewAttributesInfoNVX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, perViewAttributes, perViewAttributesPositionXOnly ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MultiviewPerViewAttributesInfoNVX const & ) const = default; -#else - bool operator==( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewAttributes == rhs.perViewAttributes ) && - ( perViewAttributesPositionXOnly == rhs.perViewAttributesPositionXOnly ); -# endif - } - - bool operator!=( MultiviewPerViewAttributesInfoNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMultiviewPerViewAttributesInfoNVX; - const void * pNext = {}; - Bool32 perViewAttributes = {}; - Bool32 perViewAttributesPositionXOnly = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MultiviewPerViewAttributesInfoNVX; - }; -#endif - - template <> - struct CppType - { - using Type = MultiviewPerViewAttributesInfoNVX; - }; - - // wrapper struct for struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.html - struct MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM - { - using NativeType = VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( uint32_t perViewRenderAreaCount_ = {}, - const Rect2D * pPerViewRenderAreas_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , perViewRenderAreaCount{ perViewRenderAreaCount_ } - , pPerViewRenderAreas{ pPerViewRenderAreas_ } - { - } - - VULKAN_HPP_CONSTEXPR - MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM( ArrayProxyNoTemporaries const & perViewRenderAreas_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), perViewRenderAreaCount( static_cast( perViewRenderAreas_.size() ) ), pPerViewRenderAreas( perViewRenderAreas_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & - operator=( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & operator=( VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & setPerViewRenderAreaCount( uint32_t perViewRenderAreaCount_ ) & - VULKAN_HPP_NOEXCEPT - { - perViewRenderAreaCount = perViewRenderAreaCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM && setPerViewRenderAreaCount( uint32_t perViewRenderAreaCount_ ) && - VULKAN_HPP_NOEXCEPT - { - perViewRenderAreaCount = perViewRenderAreaCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & setPPerViewRenderAreas( const Rect2D * pPerViewRenderAreas_ ) & - VULKAN_HPP_NOEXCEPT - { - pPerViewRenderAreas = pPerViewRenderAreas_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM && setPPerViewRenderAreas( const Rect2D * pPerViewRenderAreas_ ) && - VULKAN_HPP_NOEXCEPT - { - pPerViewRenderAreas = pPerViewRenderAreas_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM & - setPerViewRenderAreas( ArrayProxyNoTemporaries const & perViewRenderAreas_ ) VULKAN_HPP_NOEXCEPT - { - perViewRenderAreaCount = static_cast( perViewRenderAreas_.size() ); - pPerViewRenderAreas = perViewRenderAreas_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, perViewRenderAreaCount, pPerViewRenderAreas ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & ) const = default; -#else - bool operator==( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewRenderAreaCount == rhs.perViewRenderAreaCount ) && - ( pPerViewRenderAreas == rhs.pPerViewRenderAreas ); -# endif - } - - bool operator!=( MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; - const void * pNext = {}; - uint32_t perViewRenderAreaCount = {}; - const Rect2D * pPerViewRenderAreas = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; - }; - - // wrapper struct for struct VkMutableDescriptorTypeListEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkMutableDescriptorTypeListEXT.html - struct MutableDescriptorTypeListEXT - { - using NativeType = VkMutableDescriptorTypeListEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MutableDescriptorTypeListEXT( uint32_t descriptorTypeCount_ = {}, const DescriptorType * pDescriptorTypes_ = {} ) VULKAN_HPP_NOEXCEPT - : descriptorTypeCount{ descriptorTypeCount_ } - , pDescriptorTypes{ pDescriptorTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR MutableDescriptorTypeListEXT( MutableDescriptorTypeListEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MutableDescriptorTypeListEXT( VkMutableDescriptorTypeListEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MutableDescriptorTypeListEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - MutableDescriptorTypeListEXT( ArrayProxyNoTemporaries const & descriptorTypes_ ) - : descriptorTypeCount( static_cast( descriptorTypes_.size() ) ), pDescriptorTypes( descriptorTypes_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - MutableDescriptorTypeListEXT & operator=( MutableDescriptorTypeListEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MutableDescriptorTypeListEXT & operator=( VkMutableDescriptorTypeListEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeListEXT & setDescriptorTypeCount( uint32_t descriptorTypeCount_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorTypeCount = descriptorTypeCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeListEXT && setDescriptorTypeCount( uint32_t descriptorTypeCount_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorTypeCount = descriptorTypeCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeListEXT & setPDescriptorTypes( const DescriptorType * pDescriptorTypes_ ) & VULKAN_HPP_NOEXCEPT - { - pDescriptorTypes = pDescriptorTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeListEXT && setPDescriptorTypes( const DescriptorType * pDescriptorTypes_ ) && VULKAN_HPP_NOEXCEPT - { - pDescriptorTypes = pDescriptorTypes_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - MutableDescriptorTypeListEXT & setDescriptorTypes( ArrayProxyNoTemporaries const & descriptorTypes_ ) VULKAN_HPP_NOEXCEPT - { - descriptorTypeCount = static_cast( descriptorTypes_.size() ); - pDescriptorTypes = descriptorTypes_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMutableDescriptorTypeListEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMutableDescriptorTypeListEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMutableDescriptorTypeListEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMutableDescriptorTypeListEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( descriptorTypeCount, pDescriptorTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MutableDescriptorTypeListEXT const & ) const = default; -#else - bool operator==( MutableDescriptorTypeListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( descriptorTypeCount == rhs.descriptorTypeCount ) && ( pDescriptorTypes == rhs.pDescriptorTypes ); -# endif - } - - bool operator!=( MutableDescriptorTypeListEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t descriptorTypeCount = {}; - const DescriptorType * pDescriptorTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MutableDescriptorTypeListEXT; - }; -#endif - using MutableDescriptorTypeListVALVE = MutableDescriptorTypeListEXT; - - // wrapper struct for struct VkMutableDescriptorTypeCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMutableDescriptorTypeCreateInfoEXT.html - struct MutableDescriptorTypeCreateInfoEXT - { - using NativeType = VkMutableDescriptorTypeCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eMutableDescriptorTypeCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoEXT( uint32_t mutableDescriptorTypeListCount_ = {}, - const MutableDescriptorTypeListEXT * pMutableDescriptorTypeLists_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , mutableDescriptorTypeListCount{ mutableDescriptorTypeListCount_ } - , pMutableDescriptorTypeLists{ pMutableDescriptorTypeLists_ } - { - } - - VULKAN_HPP_CONSTEXPR MutableDescriptorTypeCreateInfoEXT( MutableDescriptorTypeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - MutableDescriptorTypeCreateInfoEXT( VkMutableDescriptorTypeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : MutableDescriptorTypeCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - MutableDescriptorTypeCreateInfoEXT( ArrayProxyNoTemporaries const & mutableDescriptorTypeLists_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , mutableDescriptorTypeListCount( static_cast( mutableDescriptorTypeLists_.size() ) ) - , pMutableDescriptorTypeLists( mutableDescriptorTypeLists_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - MutableDescriptorTypeCreateInfoEXT & operator=( MutableDescriptorTypeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - MutableDescriptorTypeCreateInfoEXT & operator=( VkMutableDescriptorTypeCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT & setMutableDescriptorTypeListCount( uint32_t mutableDescriptorTypeListCount_ ) & - VULKAN_HPP_NOEXCEPT - { - mutableDescriptorTypeListCount = mutableDescriptorTypeListCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT && setMutableDescriptorTypeListCount( uint32_t mutableDescriptorTypeListCount_ ) && - VULKAN_HPP_NOEXCEPT - { - mutableDescriptorTypeListCount = mutableDescriptorTypeListCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT & - setPMutableDescriptorTypeLists( const MutableDescriptorTypeListEXT * pMutableDescriptorTypeLists_ ) & - VULKAN_HPP_NOEXCEPT - { - pMutableDescriptorTypeLists = pMutableDescriptorTypeLists_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 MutableDescriptorTypeCreateInfoEXT && - setPMutableDescriptorTypeLists( const MutableDescriptorTypeListEXT * pMutableDescriptorTypeLists_ ) && - VULKAN_HPP_NOEXCEPT - { - pMutableDescriptorTypeLists = pMutableDescriptorTypeLists_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - MutableDescriptorTypeCreateInfoEXT & - setMutableDescriptorTypeLists( ArrayProxyNoTemporaries const & mutableDescriptorTypeLists_ ) VULKAN_HPP_NOEXCEPT - { - mutableDescriptorTypeListCount = static_cast( mutableDescriptorTypeLists_.size() ); - pMutableDescriptorTypeLists = mutableDescriptorTypeLists_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkMutableDescriptorTypeCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMutableDescriptorTypeCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkMutableDescriptorTypeCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkMutableDescriptorTypeCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, mutableDescriptorTypeListCount, pMutableDescriptorTypeLists ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( MutableDescriptorTypeCreateInfoEXT const & ) const = default; -#else - bool operator==( MutableDescriptorTypeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorTypeListCount == rhs.mutableDescriptorTypeListCount ) && - ( pMutableDescriptorTypeLists == rhs.pMutableDescriptorTypeLists ); -# endif - } - - bool operator!=( MutableDescriptorTypeCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eMutableDescriptorTypeCreateInfoEXT; - const void * pNext = {}; - uint32_t mutableDescriptorTypeListCount = {}; - const MutableDescriptorTypeListEXT * pMutableDescriptorTypeLists = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = MutableDescriptorTypeCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = MutableDescriptorTypeCreateInfoEXT; - }; - - using MutableDescriptorTypeCreateInfoVALVE = MutableDescriptorTypeCreateInfoEXT; - -#if defined( VK_USE_PLATFORM_OHOS ) - // wrapper struct for struct VkNativeBufferFormatPropertiesOHOS, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkNativeBufferFormatPropertiesOHOS.html - struct NativeBufferFormatPropertiesOHOS - { - using NativeType = VkNativeBufferFormatPropertiesOHOS; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eNativeBufferFormatPropertiesOHOS; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR NativeBufferFormatPropertiesOHOS( Format format_ = Format::eUndefined, - uint64_t externalFormat_ = {}, - FormatFeatureFlags formatFeatures_ = {}, - ComponentMapping samplerYcbcrConversionComponents_ = {}, - SamplerYcbcrModelConversion suggestedYcbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, - SamplerYcbcrRange suggestedYcbcrRange_ = SamplerYcbcrRange::eItuFull, - ChromaLocation suggestedXChromaOffset_ = ChromaLocation::eCositedEven, - ChromaLocation suggestedYChromaOffset_ = ChromaLocation::eCositedEven, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , format{ format_ } - , externalFormat{ externalFormat_ } - , formatFeatures{ formatFeatures_ } - , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ } - , suggestedYcbcrModel{ suggestedYcbcrModel_ } - , suggestedYcbcrRange{ suggestedYcbcrRange_ } - , suggestedXChromaOffset{ suggestedXChromaOffset_ } - , suggestedYChromaOffset{ suggestedYChromaOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR NativeBufferFormatPropertiesOHOS( NativeBufferFormatPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - NativeBufferFormatPropertiesOHOS( VkNativeBufferFormatPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - : NativeBufferFormatPropertiesOHOS( *reinterpret_cast( &rhs ) ) - { - } - - NativeBufferFormatPropertiesOHOS & operator=( NativeBufferFormatPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - NativeBufferFormatPropertiesOHOS & operator=( VkNativeBufferFormatPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkNativeBufferFormatPropertiesOHOS const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkNativeBufferFormatPropertiesOHOS &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkNativeBufferFormatPropertiesOHOS const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkNativeBufferFormatPropertiesOHOS *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - format, - externalFormat, - formatFeatures, - samplerYcbcrConversionComponents, - suggestedYcbcrModel, - suggestedYcbcrRange, - suggestedXChromaOffset, - suggestedYChromaOffset ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( NativeBufferFormatPropertiesOHOS const & ) const = default; -# else - bool operator==( NativeBufferFormatPropertiesOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) && - ( formatFeatures == rhs.formatFeatures ) && ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && - ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && - ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); -# endif - } - - bool operator!=( NativeBufferFormatPropertiesOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eNativeBufferFormatPropertiesOHOS; - void * pNext = {}; - Format format = Format::eUndefined; - uint64_t externalFormat = {}; - FormatFeatureFlags formatFeatures = {}; - ComponentMapping samplerYcbcrConversionComponents = {}; - SamplerYcbcrModelConversion suggestedYcbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; - SamplerYcbcrRange suggestedYcbcrRange = SamplerYcbcrRange::eItuFull; - ChromaLocation suggestedXChromaOffset = ChromaLocation::eCositedEven; - ChromaLocation suggestedYChromaOffset = ChromaLocation::eCositedEven; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = NativeBufferFormatPropertiesOHOS; - }; -# endif - - template <> - struct CppType - { - using Type = NativeBufferFormatPropertiesOHOS; - }; -#endif /*VK_USE_PLATFORM_OHOS*/ - -#if defined( VK_USE_PLATFORM_OHOS ) - // wrapper struct for struct VkNativeBufferPropertiesOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkNativeBufferPropertiesOHOS.html - struct NativeBufferPropertiesOHOS - { - using NativeType = VkNativeBufferPropertiesOHOS; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eNativeBufferPropertiesOHOS; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - NativeBufferPropertiesOHOS( DeviceSize allocationSize_ = {}, uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , allocationSize{ allocationSize_ } - , memoryTypeBits{ memoryTypeBits_ } - { - } - - VULKAN_HPP_CONSTEXPR NativeBufferPropertiesOHOS( NativeBufferPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - NativeBufferPropertiesOHOS( VkNativeBufferPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - : NativeBufferPropertiesOHOS( *reinterpret_cast( &rhs ) ) - { - } - - NativeBufferPropertiesOHOS & operator=( NativeBufferPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - NativeBufferPropertiesOHOS & operator=( VkNativeBufferPropertiesOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkNativeBufferPropertiesOHOS const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkNativeBufferPropertiesOHOS &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkNativeBufferPropertiesOHOS const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkNativeBufferPropertiesOHOS *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, allocationSize, memoryTypeBits ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( NativeBufferPropertiesOHOS const & ) const = default; -# else - bool operator==( NativeBufferPropertiesOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeBits == rhs.memoryTypeBits ); -# endif - } - - bool operator!=( NativeBufferPropertiesOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eNativeBufferPropertiesOHOS; - void * pNext = {}; - DeviceSize allocationSize = {}; - uint32_t memoryTypeBits = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = NativeBufferPropertiesOHOS; - }; -# endif - - template <> - struct CppType - { - using Type = NativeBufferPropertiesOHOS; - }; -#endif /*VK_USE_PLATFORM_OHOS*/ - -#if defined( VK_USE_PLATFORM_OHOS ) - // wrapper struct for struct VkNativeBufferUsageOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkNativeBufferUsageOHOS.html - struct NativeBufferUsageOHOS - { - using NativeType = VkNativeBufferUsageOHOS; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eNativeBufferUsageOHOS; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR NativeBufferUsageOHOS( uint64_t OHOSNativeBufferUsage_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , OHOSNativeBufferUsage{ OHOSNativeBufferUsage_ } - { - } - - VULKAN_HPP_CONSTEXPR NativeBufferUsageOHOS( NativeBufferUsageOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - NativeBufferUsageOHOS( VkNativeBufferUsageOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - : NativeBufferUsageOHOS( *reinterpret_cast( &rhs ) ) - { - } - - NativeBufferUsageOHOS & operator=( NativeBufferUsageOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - NativeBufferUsageOHOS & operator=( VkNativeBufferUsageOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkNativeBufferUsageOHOS const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkNativeBufferUsageOHOS &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkNativeBufferUsageOHOS const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkNativeBufferUsageOHOS *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, OHOSNativeBufferUsage ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( NativeBufferUsageOHOS const & ) const = default; -# else - bool operator==( NativeBufferUsageOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( OHOSNativeBufferUsage == rhs.OHOSNativeBufferUsage ); -# endif - } - - bool operator!=( NativeBufferUsageOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eNativeBufferUsageOHOS; - void * pNext = {}; - uint64_t OHOSNativeBufferUsage = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = NativeBufferUsageOHOS; - }; -# endif - - template <> - struct CppType - { - using Type = NativeBufferUsageOHOS; - }; -#endif /*VK_USE_PLATFORM_OHOS*/ - - // wrapper struct for struct VkOpaqueCaptureDataCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpaqueCaptureDataCreateInfoEXT.html - struct OpaqueCaptureDataCreateInfoEXT - { - using NativeType = VkOpaqueCaptureDataCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpaqueCaptureDataCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR OpaqueCaptureDataCreateInfoEXT( const HostAddressRangeConstEXT * pData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pData{ pData_ } - { - } - - VULKAN_HPP_CONSTEXPR OpaqueCaptureDataCreateInfoEXT( OpaqueCaptureDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - OpaqueCaptureDataCreateInfoEXT( VkOpaqueCaptureDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : OpaqueCaptureDataCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - OpaqueCaptureDataCreateInfoEXT & operator=( OpaqueCaptureDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - OpaqueCaptureDataCreateInfoEXT & operator=( VkOpaqueCaptureDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDataCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDataCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDataCreateInfoEXT & setPData( const HostAddressRangeConstEXT * pData_ ) & VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDataCreateInfoEXT && setPData( const HostAddressRangeConstEXT * pData_ ) && VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkOpaqueCaptureDataCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpaqueCaptureDataCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpaqueCaptureDataCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkOpaqueCaptureDataCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( OpaqueCaptureDataCreateInfoEXT const & ) const = default; -#else - bool operator==( OpaqueCaptureDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pData == rhs.pData ); -# endif - } - - bool operator!=( OpaqueCaptureDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eOpaqueCaptureDataCreateInfoEXT; - const void * pNext = {}; - const HostAddressRangeConstEXT * pData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = OpaqueCaptureDataCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = OpaqueCaptureDataCreateInfoEXT; - }; - - // wrapper struct for struct VkOpaqueCaptureDescriptorDataCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpaqueCaptureDescriptorDataCreateInfoEXT.html - struct OpaqueCaptureDescriptorDataCreateInfoEXT - { - using NativeType = VkOpaqueCaptureDescriptorDataCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpaqueCaptureDescriptorDataCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR OpaqueCaptureDescriptorDataCreateInfoEXT( const void * opaqueCaptureDescriptorData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , opaqueCaptureDescriptorData{ opaqueCaptureDescriptorData_ } - { - } - - VULKAN_HPP_CONSTEXPR OpaqueCaptureDescriptorDataCreateInfoEXT( OpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - OpaqueCaptureDescriptorDataCreateInfoEXT( VkOpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : OpaqueCaptureDescriptorDataCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - OpaqueCaptureDescriptorDataCreateInfoEXT & operator=( OpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - OpaqueCaptureDescriptorDataCreateInfoEXT & operator=( VkOpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDescriptorDataCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDescriptorDataCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDescriptorDataCreateInfoEXT & setOpaqueCaptureDescriptorData( const void * opaqueCaptureDescriptorData_ ) & - VULKAN_HPP_NOEXCEPT - { - opaqueCaptureDescriptorData = opaqueCaptureDescriptorData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpaqueCaptureDescriptorDataCreateInfoEXT && setOpaqueCaptureDescriptorData( const void * opaqueCaptureDescriptorData_ ) && - VULKAN_HPP_NOEXCEPT - { - opaqueCaptureDescriptorData = opaqueCaptureDescriptorData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkOpaqueCaptureDescriptorDataCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpaqueCaptureDescriptorDataCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpaqueCaptureDescriptorDataCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkOpaqueCaptureDescriptorDataCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, opaqueCaptureDescriptorData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( OpaqueCaptureDescriptorDataCreateInfoEXT const & ) const = default; -#else - bool operator==( OpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opaqueCaptureDescriptorData == rhs.opaqueCaptureDescriptorData ); -# endif - } - - bool operator!=( OpaqueCaptureDescriptorDataCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eOpaqueCaptureDescriptorDataCreateInfoEXT; - const void * pNext = {}; - const void * opaqueCaptureDescriptorData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = OpaqueCaptureDescriptorDataCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = OpaqueCaptureDescriptorDataCreateInfoEXT; - }; - - // wrapper struct for struct VkOpticalFlowExecuteInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowExecuteInfoNV.html - struct OpticalFlowExecuteInfoNV - { - using NativeType = VkOpticalFlowExecuteInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpticalFlowExecuteInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR OpticalFlowExecuteInfoNV( OpticalFlowExecuteFlagsNV flags_ = {}, - uint32_t regionCount_ = {}, - const Rect2D * pRegions_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR OpticalFlowExecuteInfoNV( OpticalFlowExecuteInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - OpticalFlowExecuteInfoNV( VkOpticalFlowExecuteInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : OpticalFlowExecuteInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - OpticalFlowExecuteInfoNV( OpticalFlowExecuteFlagsNV flags_, ArrayProxyNoTemporaries const & regions_, void * pNext_ = nullptr ) - : pNext( pNext_ ), flags( flags_ ), regionCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - OpticalFlowExecuteInfoNV & operator=( OpticalFlowExecuteInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - OpticalFlowExecuteInfoNV & operator=( VkOpticalFlowExecuteInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV & setFlags( OpticalFlowExecuteFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV && setFlags( OpticalFlowExecuteFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV & setPRegions( const Rect2D * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowExecuteInfoNV && setPRegions( const Rect2D * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - OpticalFlowExecuteInfoNV & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkOpticalFlowExecuteInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpticalFlowExecuteInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpticalFlowExecuteInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkOpticalFlowExecuteInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, regionCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( OpticalFlowExecuteInfoNV const & ) const = default; -#else - bool operator==( OpticalFlowExecuteInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( OpticalFlowExecuteInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eOpticalFlowExecuteInfoNV; - void * pNext = {}; - OpticalFlowExecuteFlagsNV flags = {}; - uint32_t regionCount = {}; - const Rect2D * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = OpticalFlowExecuteInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = OpticalFlowExecuteInfoNV; - }; - - // wrapper struct for struct VkOpticalFlowImageFormatInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowImageFormatInfoNV.html - struct OpticalFlowImageFormatInfoNV - { - using NativeType = VkOpticalFlowImageFormatInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpticalFlowImageFormatInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR OpticalFlowImageFormatInfoNV( OpticalFlowUsageFlagsNV usage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , usage{ usage_ } - { - } - - VULKAN_HPP_CONSTEXPR OpticalFlowImageFormatInfoNV( OpticalFlowImageFormatInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - OpticalFlowImageFormatInfoNV( VkOpticalFlowImageFormatInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : OpticalFlowImageFormatInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - OpticalFlowImageFormatInfoNV & operator=( OpticalFlowImageFormatInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - OpticalFlowImageFormatInfoNV & operator=( VkOpticalFlowImageFormatInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 OpticalFlowImageFormatInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowImageFormatInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowImageFormatInfoNV & setUsage( OpticalFlowUsageFlagsNV usage_ ) & VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowImageFormatInfoNV && setUsage( OpticalFlowUsageFlagsNV usage_ ) && VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkOpticalFlowImageFormatInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpticalFlowImageFormatInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpticalFlowImageFormatInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkOpticalFlowImageFormatInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, usage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( OpticalFlowImageFormatInfoNV const & ) const = default; -#else - bool operator==( OpticalFlowImageFormatInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( usage == rhs.usage ); -# endif - } - - bool operator!=( OpticalFlowImageFormatInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eOpticalFlowImageFormatInfoNV; - const void * pNext = {}; - OpticalFlowUsageFlagsNV usage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = OpticalFlowImageFormatInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = OpticalFlowImageFormatInfoNV; - }; - - // wrapper struct for struct VkOpticalFlowImageFormatPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowImageFormatPropertiesNV.html - struct OpticalFlowImageFormatPropertiesNV - { - using NativeType = VkOpticalFlowImageFormatPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpticalFlowImageFormatPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR OpticalFlowImageFormatPropertiesNV( Format format_ = Format::eUndefined, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , format{ format_ } - { - } - - VULKAN_HPP_CONSTEXPR OpticalFlowImageFormatPropertiesNV( OpticalFlowImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - OpticalFlowImageFormatPropertiesNV( VkOpticalFlowImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : OpticalFlowImageFormatPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - OpticalFlowImageFormatPropertiesNV & operator=( OpticalFlowImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - OpticalFlowImageFormatPropertiesNV & operator=( VkOpticalFlowImageFormatPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkOpticalFlowImageFormatPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpticalFlowImageFormatPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpticalFlowImageFormatPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkOpticalFlowImageFormatPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, format ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( OpticalFlowImageFormatPropertiesNV const & ) const = default; -#else - bool operator==( OpticalFlowImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ); -# endif - } - - bool operator!=( OpticalFlowImageFormatPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eOpticalFlowImageFormatPropertiesNV; - void * pNext = {}; - Format format = Format::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = OpticalFlowImageFormatPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = OpticalFlowImageFormatPropertiesNV; - }; - - // wrapper struct for struct VkOpticalFlowSessionCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreateInfoNV.html - struct OpticalFlowSessionCreateInfoNV - { - using NativeType = VkOpticalFlowSessionCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpticalFlowSessionCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR OpticalFlowSessionCreateInfoNV( uint32_t width_ = {}, - uint32_t height_ = {}, - Format imageFormat_ = Format::eUndefined, - Format flowVectorFormat_ = Format::eUndefined, - Format costFormat_ = Format::eUndefined, - OpticalFlowGridSizeFlagsNV outputGridSize_ = {}, - OpticalFlowGridSizeFlagsNV hintGridSize_ = {}, - OpticalFlowPerformanceLevelNV performanceLevel_ = OpticalFlowPerformanceLevelNV::eUnknown, - OpticalFlowSessionCreateFlagsNV flags_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , width{ width_ } - , height{ height_ } - , imageFormat{ imageFormat_ } - , flowVectorFormat{ flowVectorFormat_ } - , costFormat{ costFormat_ } - , outputGridSize{ outputGridSize_ } - , hintGridSize{ hintGridSize_ } - , performanceLevel{ performanceLevel_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR OpticalFlowSessionCreateInfoNV( OpticalFlowSessionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - OpticalFlowSessionCreateInfoNV( VkOpticalFlowSessionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : OpticalFlowSessionCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - OpticalFlowSessionCreateInfoNV & operator=( OpticalFlowSessionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - OpticalFlowSessionCreateInfoNV & operator=( VkOpticalFlowSessionCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT - { - width = width_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT - { - width = width_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT - { - height = height_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT - { - height = height_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setImageFormat( Format imageFormat_ ) & VULKAN_HPP_NOEXCEPT - { - imageFormat = imageFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setImageFormat( Format imageFormat_ ) && VULKAN_HPP_NOEXCEPT - { - imageFormat = imageFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setFlowVectorFormat( Format flowVectorFormat_ ) & VULKAN_HPP_NOEXCEPT - { - flowVectorFormat = flowVectorFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setFlowVectorFormat( Format flowVectorFormat_ ) && VULKAN_HPP_NOEXCEPT - { - flowVectorFormat = flowVectorFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setCostFormat( Format costFormat_ ) & VULKAN_HPP_NOEXCEPT - { - costFormat = costFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setCostFormat( Format costFormat_ ) && VULKAN_HPP_NOEXCEPT - { - costFormat = costFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setOutputGridSize( OpticalFlowGridSizeFlagsNV outputGridSize_ ) & VULKAN_HPP_NOEXCEPT - { - outputGridSize = outputGridSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setOutputGridSize( OpticalFlowGridSizeFlagsNV outputGridSize_ ) && VULKAN_HPP_NOEXCEPT - { - outputGridSize = outputGridSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setHintGridSize( OpticalFlowGridSizeFlagsNV hintGridSize_ ) & VULKAN_HPP_NOEXCEPT - { - hintGridSize = hintGridSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setHintGridSize( OpticalFlowGridSizeFlagsNV hintGridSize_ ) && VULKAN_HPP_NOEXCEPT - { - hintGridSize = hintGridSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setPerformanceLevel( OpticalFlowPerformanceLevelNV performanceLevel_ ) & VULKAN_HPP_NOEXCEPT - { - performanceLevel = performanceLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setPerformanceLevel( OpticalFlowPerformanceLevelNV performanceLevel_ ) && VULKAN_HPP_NOEXCEPT - { - performanceLevel = performanceLevel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV & setFlags( OpticalFlowSessionCreateFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreateInfoNV && setFlags( OpticalFlowSessionCreateFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkOpticalFlowSessionCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpticalFlowSessionCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpticalFlowSessionCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkOpticalFlowSessionCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, width, height, imageFormat, flowVectorFormat, costFormat, outputGridSize, hintGridSize, performanceLevel, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( OpticalFlowSessionCreateInfoNV const & ) const = default; -#else - bool operator==( OpticalFlowSessionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( width == rhs.width ) && ( height == rhs.height ) && ( imageFormat == rhs.imageFormat ) && - ( flowVectorFormat == rhs.flowVectorFormat ) && ( costFormat == rhs.costFormat ) && ( outputGridSize == rhs.outputGridSize ) && - ( hintGridSize == rhs.hintGridSize ) && ( performanceLevel == rhs.performanceLevel ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( OpticalFlowSessionCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eOpticalFlowSessionCreateInfoNV; - void * pNext = {}; - uint32_t width = {}; - uint32_t height = {}; - Format imageFormat = Format::eUndefined; - Format flowVectorFormat = Format::eUndefined; - Format costFormat = Format::eUndefined; - OpticalFlowGridSizeFlagsNV outputGridSize = {}; - OpticalFlowGridSizeFlagsNV hintGridSize = {}; - OpticalFlowPerformanceLevelNV performanceLevel = OpticalFlowPerformanceLevelNV::eUnknown; - OpticalFlowSessionCreateFlagsNV flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = OpticalFlowSessionCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = OpticalFlowSessionCreateInfoNV; - }; - - // wrapper struct for struct VkOpticalFlowSessionCreatePrivateDataInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkOpticalFlowSessionCreatePrivateDataInfoNV.html - struct OpticalFlowSessionCreatePrivateDataInfoNV - { - using NativeType = VkOpticalFlowSessionCreatePrivateDataInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR OpticalFlowSessionCreatePrivateDataInfoNV( uint32_t id_ = {}, - uint32_t size_ = {}, - const void * pPrivateData_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , id{ id_ } - , size{ size_ } - , pPrivateData{ pPrivateData_ } - { - } - - VULKAN_HPP_CONSTEXPR OpticalFlowSessionCreatePrivateDataInfoNV( OpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - OpticalFlowSessionCreatePrivateDataInfoNV( VkOpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : OpticalFlowSessionCreatePrivateDataInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - OpticalFlowSessionCreatePrivateDataInfoNV & operator=( OpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - OpticalFlowSessionCreatePrivateDataInfoNV & operator=( VkOpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV & setId( uint32_t id_ ) & VULKAN_HPP_NOEXCEPT - { - id = id_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV && setId( uint32_t id_ ) && VULKAN_HPP_NOEXCEPT - { - id = id_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV & setPPrivateData( const void * pPrivateData_ ) & VULKAN_HPP_NOEXCEPT - { - pPrivateData = pPrivateData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OpticalFlowSessionCreatePrivateDataInfoNV && setPPrivateData( const void * pPrivateData_ ) && VULKAN_HPP_NOEXCEPT - { - pPrivateData = pPrivateData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkOpticalFlowSessionCreatePrivateDataInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpticalFlowSessionCreatePrivateDataInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOpticalFlowSessionCreatePrivateDataInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkOpticalFlowSessionCreatePrivateDataInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, id, size, pPrivateData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( OpticalFlowSessionCreatePrivateDataInfoNV const & ) const = default; -#else - bool operator==( OpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( id == rhs.id ) && ( size == rhs.size ) && ( pPrivateData == rhs.pPrivateData ); -# endif - } - - bool operator!=( OpticalFlowSessionCreatePrivateDataInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV; - void * pNext = {}; - uint32_t id = {}; - uint32_t size = {}; - const void * pPrivateData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = OpticalFlowSessionCreatePrivateDataInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = OpticalFlowSessionCreatePrivateDataInfoNV; - }; - - // wrapper struct for struct VkOutOfBandQueueTypeInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkOutOfBandQueueTypeInfoNV.html - struct OutOfBandQueueTypeInfoNV - { - using NativeType = VkOutOfBandQueueTypeInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eOutOfBandQueueTypeInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR OutOfBandQueueTypeInfoNV( OutOfBandQueueTypeNV queueType_ = OutOfBandQueueTypeNV::eRender, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , queueType{ queueType_ } - { - } - - VULKAN_HPP_CONSTEXPR OutOfBandQueueTypeInfoNV( OutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - OutOfBandQueueTypeInfoNV( VkOutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : OutOfBandQueueTypeInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - OutOfBandQueueTypeInfoNV & operator=( OutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - OutOfBandQueueTypeInfoNV & operator=( VkOutOfBandQueueTypeInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 OutOfBandQueueTypeInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OutOfBandQueueTypeInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 OutOfBandQueueTypeInfoNV & setQueueType( OutOfBandQueueTypeNV queueType_ ) & VULKAN_HPP_NOEXCEPT - { - queueType = queueType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 OutOfBandQueueTypeInfoNV && setQueueType( OutOfBandQueueTypeNV queueType_ ) && VULKAN_HPP_NOEXCEPT - { - queueType = queueType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkOutOfBandQueueTypeInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOutOfBandQueueTypeInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkOutOfBandQueueTypeInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkOutOfBandQueueTypeInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, queueType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( OutOfBandQueueTypeInfoNV const & ) const = default; -#else - bool operator==( OutOfBandQueueTypeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueType == rhs.queueType ); -# endif - } - - bool operator!=( OutOfBandQueueTypeInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eOutOfBandQueueTypeInfoNV; - const void * pNext = {}; - OutOfBandQueueTypeNV queueType = OutOfBandQueueTypeNV::eRender; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = OutOfBandQueueTypeInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = OutOfBandQueueTypeInfoNV; - }; - - // wrapper struct for struct VkPartitionedAccelerationStructureFlagsNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureFlagsNV.html - struct PartitionedAccelerationStructureFlagsNV - { - using NativeType = VkPartitionedAccelerationStructureFlagsNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePartitionedAccelerationStructureFlagsNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PartitionedAccelerationStructureFlagsNV( Bool32 enablePartitionTranslation_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , enablePartitionTranslation{ enablePartitionTranslation_ } - { - } - - VULKAN_HPP_CONSTEXPR PartitionedAccelerationStructureFlagsNV( PartitionedAccelerationStructureFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PartitionedAccelerationStructureFlagsNV( VkPartitionedAccelerationStructureFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PartitionedAccelerationStructureFlagsNV( *reinterpret_cast( &rhs ) ) - { - } - - PartitionedAccelerationStructureFlagsNV & operator=( PartitionedAccelerationStructureFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PartitionedAccelerationStructureFlagsNV & operator=( VkPartitionedAccelerationStructureFlagsNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureFlagsNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureFlagsNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureFlagsNV & setEnablePartitionTranslation( Bool32 enablePartitionTranslation_ ) & VULKAN_HPP_NOEXCEPT - { - enablePartitionTranslation = enablePartitionTranslation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureFlagsNV && setEnablePartitionTranslation( Bool32 enablePartitionTranslation_ ) && - VULKAN_HPP_NOEXCEPT - { - enablePartitionTranslation = enablePartitionTranslation_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPartitionedAccelerationStructureFlagsNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureFlagsNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureFlagsNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureFlagsNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, enablePartitionTranslation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PartitionedAccelerationStructureFlagsNV const & ) const = default; -#else - bool operator==( PartitionedAccelerationStructureFlagsNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( enablePartitionTranslation == rhs.enablePartitionTranslation ); -# endif - } - - bool operator!=( PartitionedAccelerationStructureFlagsNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePartitionedAccelerationStructureFlagsNV; - void * pNext = {}; - Bool32 enablePartitionTranslation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PartitionedAccelerationStructureFlagsNV; - }; -#endif - - template <> - struct CppType - { - using Type = PartitionedAccelerationStructureFlagsNV; - }; - - // wrapper struct for struct VkPartitionedAccelerationStructureUpdateInstanceDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureUpdateInstanceDataNV.html - struct PartitionedAccelerationStructureUpdateInstanceDataNV - { - using NativeType = VkPartitionedAccelerationStructureUpdateInstanceDataNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PartitionedAccelerationStructureUpdateInstanceDataNV( uint32_t instanceIndex_ = {}, - uint32_t instanceContributionToHitGroupIndex_ = {}, - DeviceAddress accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT - : instanceIndex{ instanceIndex_ } - , instanceContributionToHitGroupIndex{ instanceContributionToHitGroupIndex_ } - , accelerationStructure{ accelerationStructure_ } - { - } - - VULKAN_HPP_CONSTEXPR - PartitionedAccelerationStructureUpdateInstanceDataNV( PartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PartitionedAccelerationStructureUpdateInstanceDataNV( VkPartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PartitionedAccelerationStructureUpdateInstanceDataNV( *reinterpret_cast( &rhs ) ) - { - } - - PartitionedAccelerationStructureUpdateInstanceDataNV & - operator=( PartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PartitionedAccelerationStructureUpdateInstanceDataNV & operator=( VkPartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV & setInstanceIndex( uint32_t instanceIndex_ ) & VULKAN_HPP_NOEXCEPT - { - instanceIndex = instanceIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV && setInstanceIndex( uint32_t instanceIndex_ ) && VULKAN_HPP_NOEXCEPT - { - instanceIndex = instanceIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV & - setInstanceContributionToHitGroupIndex( uint32_t instanceContributionToHitGroupIndex_ ) & - VULKAN_HPP_NOEXCEPT - { - instanceContributionToHitGroupIndex = instanceContributionToHitGroupIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV && - setInstanceContributionToHitGroupIndex( uint32_t instanceContributionToHitGroupIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - instanceContributionToHitGroupIndex = instanceContributionToHitGroupIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV & setAccelerationStructure( DeviceAddress accelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureUpdateInstanceDataNV && setAccelerationStructure( DeviceAddress accelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPartitionedAccelerationStructureUpdateInstanceDataNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureUpdateInstanceDataNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureUpdateInstanceDataNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureUpdateInstanceDataNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( instanceIndex, instanceContributionToHitGroupIndex, accelerationStructure ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PartitionedAccelerationStructureUpdateInstanceDataNV const & ) const = default; -#else - bool operator==( PartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( instanceIndex == rhs.instanceIndex ) && ( instanceContributionToHitGroupIndex == rhs.instanceContributionToHitGroupIndex ) && - ( accelerationStructure == rhs.accelerationStructure ); -# endif - } - - bool operator!=( PartitionedAccelerationStructureUpdateInstanceDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t instanceIndex = {}; - uint32_t instanceContributionToHitGroupIndex = {}; - DeviceAddress accelerationStructure = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PartitionedAccelerationStructureUpdateInstanceDataNV; - }; -#endif - - // wrapper struct for struct VkPartitionedAccelerationStructureWriteInstanceDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureWriteInstanceDataNV.html - struct PartitionedAccelerationStructureWriteInstanceDataNV - { - using NativeType = VkPartitionedAccelerationStructureWriteInstanceDataNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV( TransformMatrixKHR transform_ = {}, - std::array const & explicitAABB_ = {}, - uint32_t instanceID_ = {}, - uint32_t instanceMask_ = {}, - uint32_t instanceContributionToHitGroupIndex_ = {}, - PartitionedAccelerationStructureInstanceFlagsNV instanceFlags_ = {}, - uint32_t instanceIndex_ = {}, - uint32_t partitionIndex_ = {}, - DeviceAddress accelerationStructure_ = {} ) VULKAN_HPP_NOEXCEPT - : transform{ transform_ } - , explicitAABB{ explicitAABB_ } - , instanceID{ instanceID_ } - , instanceMask{ instanceMask_ } - , instanceContributionToHitGroupIndex{ instanceContributionToHitGroupIndex_ } - , instanceFlags{ instanceFlags_ } - , instanceIndex{ instanceIndex_ } - , partitionIndex{ partitionIndex_ } - , accelerationStructure{ accelerationStructure_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - PartitionedAccelerationStructureWriteInstanceDataNV( PartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PartitionedAccelerationStructureWriteInstanceDataNV( VkPartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PartitionedAccelerationStructureWriteInstanceDataNV( *reinterpret_cast( &rhs ) ) - { - } - - PartitionedAccelerationStructureWriteInstanceDataNV & - operator=( PartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PartitionedAccelerationStructureWriteInstanceDataNV & operator=( VkPartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setTransform( TransformMatrixKHR const & transform_ ) & VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setTransform( TransformMatrixKHR const & transform_ ) && VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setExplicitAABB( std::array explicitAABB_ ) & VULKAN_HPP_NOEXCEPT - { - explicitAABB = explicitAABB_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setExplicitAABB( std::array explicitAABB_ ) && VULKAN_HPP_NOEXCEPT - { - explicitAABB = explicitAABB_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setInstanceID( uint32_t instanceID_ ) & VULKAN_HPP_NOEXCEPT - { - instanceID = instanceID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setInstanceID( uint32_t instanceID_ ) && VULKAN_HPP_NOEXCEPT - { - instanceID = instanceID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setInstanceMask( uint32_t instanceMask_ ) & VULKAN_HPP_NOEXCEPT - { - instanceMask = instanceMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setInstanceMask( uint32_t instanceMask_ ) && VULKAN_HPP_NOEXCEPT - { - instanceMask = instanceMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & - setInstanceContributionToHitGroupIndex( uint32_t instanceContributionToHitGroupIndex_ ) & - VULKAN_HPP_NOEXCEPT - { - instanceContributionToHitGroupIndex = instanceContributionToHitGroupIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && - setInstanceContributionToHitGroupIndex( uint32_t instanceContributionToHitGroupIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - instanceContributionToHitGroupIndex = instanceContributionToHitGroupIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & - setInstanceFlags( PartitionedAccelerationStructureInstanceFlagsNV instanceFlags_ ) & - VULKAN_HPP_NOEXCEPT - { - instanceFlags = instanceFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && - setInstanceFlags( PartitionedAccelerationStructureInstanceFlagsNV instanceFlags_ ) && - VULKAN_HPP_NOEXCEPT - { - instanceFlags = instanceFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setInstanceIndex( uint32_t instanceIndex_ ) & VULKAN_HPP_NOEXCEPT - { - instanceIndex = instanceIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setInstanceIndex( uint32_t instanceIndex_ ) && VULKAN_HPP_NOEXCEPT - { - instanceIndex = instanceIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setPartitionIndex( uint32_t partitionIndex_ ) & VULKAN_HPP_NOEXCEPT - { - partitionIndex = partitionIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setPartitionIndex( uint32_t partitionIndex_ ) && VULKAN_HPP_NOEXCEPT - { - partitionIndex = partitionIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV & setAccelerationStructure( DeviceAddress accelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWriteInstanceDataNV && setAccelerationStructure( DeviceAddress accelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPartitionedAccelerationStructureWriteInstanceDataNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureWriteInstanceDataNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureWriteInstanceDataNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureWriteInstanceDataNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - PartitionedAccelerationStructureInstanceFlagsNV const &, - uint32_t const &, - uint32_t const &, - DeviceAddress const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( transform, - explicitAABB, - instanceID, - instanceMask, - instanceContributionToHitGroupIndex, - instanceFlags, - instanceIndex, - partitionIndex, - accelerationStructure ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PartitionedAccelerationStructureWriteInstanceDataNV const & ) const = default; -#else - bool operator==( PartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( transform == rhs.transform ) && ( explicitAABB == rhs.explicitAABB ) && ( instanceID == rhs.instanceID ) && - ( instanceMask == rhs.instanceMask ) && ( instanceContributionToHitGroupIndex == rhs.instanceContributionToHitGroupIndex ) && - ( instanceFlags == rhs.instanceFlags ) && ( instanceIndex == rhs.instanceIndex ) && ( partitionIndex == rhs.partitionIndex ) && - ( accelerationStructure == rhs.accelerationStructure ); -# endif - } - - bool operator!=( PartitionedAccelerationStructureWriteInstanceDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - TransformMatrixKHR transform = {}; - ArrayWrapper1D explicitAABB = {}; - uint32_t instanceID = {}; - uint32_t instanceMask = {}; - uint32_t instanceContributionToHitGroupIndex = {}; - PartitionedAccelerationStructureInstanceFlagsNV instanceFlags = {}; - uint32_t instanceIndex = {}; - uint32_t partitionIndex = {}; - DeviceAddress accelerationStructure = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PartitionedAccelerationStructureWriteInstanceDataNV; - }; -#endif - - // wrapper struct for struct VkPartitionedAccelerationStructureWritePartitionTranslationDataNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPartitionedAccelerationStructureWritePartitionTranslationDataNV.html - struct PartitionedAccelerationStructureWritePartitionTranslationDataNV - { - using NativeType = VkPartitionedAccelerationStructureWritePartitionTranslationDataNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - PartitionedAccelerationStructureWritePartitionTranslationDataNV( uint32_t partitionIndex_ = {}, - std::array const & partitionTranslation_ = {} ) VULKAN_HPP_NOEXCEPT - : partitionIndex{ partitionIndex_ } - , partitionTranslation{ partitionTranslation_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWritePartitionTranslationDataNV( - PartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PartitionedAccelerationStructureWritePartitionTranslationDataNV( VkPartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) - VULKAN_HPP_NOEXCEPT - : PartitionedAccelerationStructureWritePartitionTranslationDataNV( - *reinterpret_cast( &rhs ) ) - { - } - - PartitionedAccelerationStructureWritePartitionTranslationDataNV & - operator=( PartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PartitionedAccelerationStructureWritePartitionTranslationDataNV & - operator=( VkPartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWritePartitionTranslationDataNV & setPartitionIndex( uint32_t partitionIndex_ ) & - VULKAN_HPP_NOEXCEPT - { - partitionIndex = partitionIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWritePartitionTranslationDataNV && setPartitionIndex( uint32_t partitionIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - partitionIndex = partitionIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWritePartitionTranslationDataNV & - setPartitionTranslation( std::array partitionTranslation_ ) & - VULKAN_HPP_NOEXCEPT - { - partitionTranslation = partitionTranslation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PartitionedAccelerationStructureWritePartitionTranslationDataNV && - setPartitionTranslation( std::array partitionTranslation_ ) && - VULKAN_HPP_NOEXCEPT - { - partitionTranslation = partitionTranslation_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPartitionedAccelerationStructureWritePartitionTranslationDataNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureWritePartitionTranslationDataNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureWritePartitionTranslationDataNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPartitionedAccelerationStructureWritePartitionTranslationDataNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( partitionIndex, partitionTranslation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PartitionedAccelerationStructureWritePartitionTranslationDataNV const & ) const = default; -#else - bool operator==( PartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( partitionIndex == rhs.partitionIndex ) && ( partitionTranslation == rhs.partitionTranslation ); -# endif - } - - bool operator!=( PartitionedAccelerationStructureWritePartitionTranslationDataNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t partitionIndex = {}; - ArrayWrapper1D partitionTranslation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PartitionedAccelerationStructureWritePartitionTranslationDataNV; - }; -#endif - - // wrapper struct for struct VkPresentStageTimeEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentStageTimeEXT.html - struct PresentStageTimeEXT - { - using NativeType = VkPresentStageTimeEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PresentStageTimeEXT( PresentStageFlagsEXT stage_ = {}, uint64_t time_ = {} ) VULKAN_HPP_NOEXCEPT - : stage{ stage_ } - , time{ time_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentStageTimeEXT( PresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentStageTimeEXT( VkPresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT : PresentStageTimeEXT( *reinterpret_cast( &rhs ) ) - { - } - - PresentStageTimeEXT & operator=( PresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentStageTimeEXT & operator=( VkPresentStageTimeEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPresentStageTimeEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentStageTimeEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentStageTimeEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentStageTimeEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( stage, time ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentStageTimeEXT const & ) const = default; -#else - bool operator==( PresentStageTimeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( stage == rhs.stage ) && ( time == rhs.time ); -# endif - } - - bool operator!=( PresentStageTimeEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - PresentStageFlagsEXT stage = {}; - uint64_t time = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentStageTimeEXT; - }; -#endif - - // wrapper struct for struct VkPastPresentationTimingEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingEXT.html - struct PastPresentationTimingEXT - { - using NativeType = VkPastPresentationTimingEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePastPresentationTimingEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PastPresentationTimingEXT( uint64_t presentId_ = {}, - uint64_t targetTime_ = {}, - uint32_t presentStageCount_ = {}, - PresentStageTimeEXT * pPresentStages_ = {}, - TimeDomainKHR timeDomain_ = TimeDomainKHR::eDevice, - uint64_t timeDomainId_ = {}, - Bool32 reportComplete_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentId{ presentId_ } - , targetTime{ targetTime_ } - , presentStageCount{ presentStageCount_ } - , pPresentStages{ pPresentStages_ } - , timeDomain{ timeDomain_ } - , timeDomainId{ timeDomainId_ } - , reportComplete{ reportComplete_ } - { - } - - VULKAN_HPP_CONSTEXPR PastPresentationTimingEXT( PastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PastPresentationTimingEXT( VkPastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PastPresentationTimingEXT( *reinterpret_cast( &rhs ) ) - { - } - - PastPresentationTimingEXT & operator=( PastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PastPresentationTimingEXT & operator=( VkPastPresentationTimingEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPastPresentationTimingEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPastPresentationTimingEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPastPresentationTimingEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPastPresentationTimingEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentId, targetTime, presentStageCount, pPresentStages, timeDomain, timeDomainId, reportComplete ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PastPresentationTimingEXT const & ) const = default; -#else - bool operator==( PastPresentationTimingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId ) && ( targetTime == rhs.targetTime ) && - ( presentStageCount == rhs.presentStageCount ) && ( pPresentStages == rhs.pPresentStages ) && ( timeDomain == rhs.timeDomain ) && - ( timeDomainId == rhs.timeDomainId ) && ( reportComplete == rhs.reportComplete ); -# endif - } - - bool operator!=( PastPresentationTimingEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePastPresentationTimingEXT; - void * pNext = {}; - uint64_t presentId = {}; - uint64_t targetTime = {}; - uint32_t presentStageCount = {}; - PresentStageTimeEXT * pPresentStages = {}; - TimeDomainKHR timeDomain = TimeDomainKHR::eDevice; - uint64_t timeDomainId = {}; - Bool32 reportComplete = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PastPresentationTimingEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PastPresentationTimingEXT; - }; - - // wrapper struct for struct VkPastPresentationTimingGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingGOOGLE.html - struct PastPresentationTimingGOOGLE - { - using NativeType = VkPastPresentationTimingGOOGLE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PastPresentationTimingGOOGLE( uint32_t presentID_ = {}, - uint64_t desiredPresentTime_ = {}, - uint64_t actualPresentTime_ = {}, - uint64_t earliestPresentTime_ = {}, - uint64_t presentMargin_ = {} ) VULKAN_HPP_NOEXCEPT - : presentID{ presentID_ } - , desiredPresentTime{ desiredPresentTime_ } - , actualPresentTime{ actualPresentTime_ } - , earliestPresentTime{ earliestPresentTime_ } - , presentMargin{ presentMargin_ } - { - } - - VULKAN_HPP_CONSTEXPR PastPresentationTimingGOOGLE( PastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PastPresentationTimingGOOGLE( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - : PastPresentationTimingGOOGLE( *reinterpret_cast( &rhs ) ) - { - } - - PastPresentationTimingGOOGLE & operator=( PastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PastPresentationTimingGOOGLE & operator=( VkPastPresentationTimingGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPastPresentationTimingGOOGLE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPastPresentationTimingGOOGLE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPastPresentationTimingGOOGLE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPastPresentationTimingGOOGLE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( presentID, desiredPresentTime, actualPresentTime, earliestPresentTime, presentMargin ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PastPresentationTimingGOOGLE const & ) const = default; -#else - bool operator==( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ) && ( actualPresentTime == rhs.actualPresentTime ) && - ( earliestPresentTime == rhs.earliestPresentTime ) && ( presentMargin == rhs.presentMargin ); -# endif - } - - bool operator!=( PastPresentationTimingGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t presentID = {}; - uint64_t desiredPresentTime = {}; - uint64_t actualPresentTime = {}; - uint64_t earliestPresentTime = {}; - uint64_t presentMargin = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PastPresentationTimingGOOGLE; - }; -#endif - - // wrapper struct for struct VkPastPresentationTimingInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingInfoEXT.html - struct PastPresentationTimingInfoEXT - { - using NativeType = VkPastPresentationTimingInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePastPresentationTimingInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PastPresentationTimingInfoEXT( PastPresentationTimingFlagsEXT flags_ = {}, - SwapchainKHR swapchain_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , swapchain{ swapchain_ } - { - } - - VULKAN_HPP_CONSTEXPR PastPresentationTimingInfoEXT( PastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PastPresentationTimingInfoEXT( VkPastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PastPresentationTimingInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - PastPresentationTimingInfoEXT & operator=( PastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PastPresentationTimingInfoEXT & operator=( VkPastPresentationTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT & setFlags( PastPresentationTimingFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT && setFlags( PastPresentationTimingFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PastPresentationTimingInfoEXT && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPastPresentationTimingInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPastPresentationTimingInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPastPresentationTimingInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPastPresentationTimingInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, swapchain ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PastPresentationTimingInfoEXT const & ) const = default; -#else - bool operator==( PastPresentationTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( swapchain == rhs.swapchain ); -# endif - } - - bool operator!=( PastPresentationTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePastPresentationTimingInfoEXT; - const void * pNext = {}; - PastPresentationTimingFlagsEXT flags = {}; - SwapchainKHR swapchain = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PastPresentationTimingInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PastPresentationTimingInfoEXT; - }; - - // wrapper struct for struct VkPastPresentationTimingPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPastPresentationTimingPropertiesEXT.html - struct PastPresentationTimingPropertiesEXT - { - using NativeType = VkPastPresentationTimingPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePastPresentationTimingPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PastPresentationTimingPropertiesEXT( uint64_t timingPropertiesCounter_ = {}, - uint64_t timeDomainsCounter_ = {}, - uint32_t presentationTimingCount_ = {}, - PastPresentationTimingEXT * pPresentationTimings_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , timingPropertiesCounter{ timingPropertiesCounter_ } - , timeDomainsCounter{ timeDomainsCounter_ } - , presentationTimingCount{ presentationTimingCount_ } - , pPresentationTimings{ pPresentationTimings_ } - { - } - - VULKAN_HPP_CONSTEXPR PastPresentationTimingPropertiesEXT( PastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PastPresentationTimingPropertiesEXT( VkPastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PastPresentationTimingPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PastPresentationTimingPropertiesEXT & operator=( PastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PastPresentationTimingPropertiesEXT & operator=( VkPastPresentationTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPastPresentationTimingPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPastPresentationTimingPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPastPresentationTimingPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPastPresentationTimingPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, timingPropertiesCounter, timeDomainsCounter, presentationTimingCount, pPresentationTimings ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PastPresentationTimingPropertiesEXT const & ) const = default; -#else - bool operator==( PastPresentationTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timingPropertiesCounter == rhs.timingPropertiesCounter ) && - ( timeDomainsCounter == rhs.timeDomainsCounter ) && ( presentationTimingCount == rhs.presentationTimingCount ) && - ( pPresentationTimings == rhs.pPresentationTimings ); -# endif - } - - bool operator!=( PastPresentationTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePastPresentationTimingPropertiesEXT; - void * pNext = {}; - uint64_t timingPropertiesCounter = {}; - uint64_t timeDomainsCounter = {}; - uint32_t presentationTimingCount = {}; - PastPresentationTimingEXT * pPresentationTimings = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PastPresentationTimingPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PastPresentationTimingPropertiesEXT; - }; - - // wrapper struct for struct VkPerTileBeginInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerTileBeginInfoQCOM.html - struct PerTileBeginInfoQCOM - { - using NativeType = VkPerTileBeginInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerTileBeginInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PerTileBeginInfoQCOM( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} - - VULKAN_HPP_CONSTEXPR PerTileBeginInfoQCOM( PerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerTileBeginInfoQCOM( VkPerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PerTileBeginInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PerTileBeginInfoQCOM & operator=( PerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerTileBeginInfoQCOM & operator=( VkPerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PerTileBeginInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerTileBeginInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPerTileBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerTileBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerTileBeginInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerTileBeginInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PerTileBeginInfoQCOM const & ) const = default; -#else - bool operator==( PerTileBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); -# endif - } - - bool operator!=( PerTileBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePerTileBeginInfoQCOM; - const void * pNext = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerTileBeginInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PerTileBeginInfoQCOM; - }; - - // wrapper struct for struct VkPerTileEndInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerTileEndInfoQCOM.html - struct PerTileEndInfoQCOM - { - using NativeType = VkPerTileEndInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerTileEndInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PerTileEndInfoQCOM( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} - - VULKAN_HPP_CONSTEXPR PerTileEndInfoQCOM( PerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerTileEndInfoQCOM( VkPerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT : PerTileEndInfoQCOM( *reinterpret_cast( &rhs ) ) {} - - PerTileEndInfoQCOM & operator=( PerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerTileEndInfoQCOM & operator=( VkPerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PerTileEndInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerTileEndInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPerTileEndInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerTileEndInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerTileEndInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerTileEndInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PerTileEndInfoQCOM const & ) const = default; -#else - bool operator==( PerTileEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); -# endif - } - - bool operator!=( PerTileEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePerTileEndInfoQCOM; - const void * pNext = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerTileEndInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PerTileEndInfoQCOM; - }; - - // wrapper struct for struct VkPerformanceConfigurationAcquireInfoINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html - struct PerformanceConfigurationAcquireInfoINTEL - { - using NativeType = VkPerformanceConfigurationAcquireInfoINTEL; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceConfigurationAcquireInfoINTEL; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( - PerformanceConfigurationTypeINTEL type_ = PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - { - } - - VULKAN_HPP_CONSTEXPR PerformanceConfigurationAcquireInfoINTEL( PerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerformanceConfigurationAcquireInfoINTEL( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : PerformanceConfigurationAcquireInfoINTEL( *reinterpret_cast( &rhs ) ) - { - } - - PerformanceConfigurationAcquireInfoINTEL & operator=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerformanceConfigurationAcquireInfoINTEL & operator=( VkPerformanceConfigurationAcquireInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceConfigurationAcquireInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceConfigurationAcquireInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceConfigurationAcquireInfoINTEL & setType( PerformanceConfigurationTypeINTEL type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceConfigurationAcquireInfoINTEL && setType( PerformanceConfigurationTypeINTEL type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPerformanceConfigurationAcquireInfoINTEL const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceConfigurationAcquireInfoINTEL &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceConfigurationAcquireInfoINTEL const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerformanceConfigurationAcquireInfoINTEL *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, type ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PerformanceConfigurationAcquireInfoINTEL const & ) const = default; -#else - bool operator==( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ); -# endif - } - - bool operator!=( PerformanceConfigurationAcquireInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePerformanceConfigurationAcquireInfoINTEL; - const void * pNext = {}; - PerformanceConfigurationTypeINTEL type = PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceConfigurationAcquireInfoINTEL; - }; -#endif - - template <> - struct CppType - { - using Type = PerformanceConfigurationAcquireInfoINTEL; - }; - - // wrapper struct for struct VkPerformanceCounterARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterARM.html - struct PerformanceCounterARM - { - using NativeType = VkPerformanceCounterARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PerformanceCounterARM( uint32_t counterID_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , counterID{ counterID_ } - { - } - - VULKAN_HPP_CONSTEXPR PerformanceCounterARM( PerformanceCounterARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerformanceCounterARM( VkPerformanceCounterARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PerformanceCounterARM( *reinterpret_cast( &rhs ) ) - { - } - - PerformanceCounterARM & operator=( PerformanceCounterARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerformanceCounterARM & operator=( VkPerformanceCounterARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPerformanceCounterARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceCounterARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceCounterARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerformanceCounterARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, counterID ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PerformanceCounterARM const & ) const = default; -#else - bool operator==( PerformanceCounterARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterID == rhs.counterID ); -# endif - } - - bool operator!=( PerformanceCounterARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePerformanceCounterARM; - void * pNext = {}; - uint32_t counterID = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceCounterARM; - }; -#endif - - template <> - struct CppType - { - using Type = PerformanceCounterARM; - }; - - // wrapper struct for struct VkPerformanceCounterDescriptionARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionARM.html - struct PerformanceCounterDescriptionARM - { - using NativeType = VkPerformanceCounterDescriptionARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterDescriptionARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionARM( PerformanceCounterDescriptionFlagsARM flags_ = {}, - std::array const & name_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , name{ name_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionARM( PerformanceCounterDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerformanceCounterDescriptionARM( VkPerformanceCounterDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PerformanceCounterDescriptionARM( *reinterpret_cast( &rhs ) ) - { - } - - PerformanceCounterDescriptionARM & operator=( PerformanceCounterDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerformanceCounterDescriptionARM & operator=( VkPerformanceCounterDescriptionARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPerformanceCounterDescriptionARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceCounterDescriptionARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceCounterDescriptionARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerformanceCounterDescriptionARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, name ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PerformanceCounterDescriptionARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( PerformanceCounterDescriptionARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( strcmp( name, rhs.name ) == 0 ); - } - - bool operator!=( PerformanceCounterDescriptionARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::ePerformanceCounterDescriptionARM; - void * pNext = {}; - PerformanceCounterDescriptionFlagsARM flags = {}; - ArrayWrapper1D name = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceCounterDescriptionARM; - }; -#endif - - template <> - struct CppType - { - using Type = PerformanceCounterDescriptionARM; - }; - - // wrapper struct for struct VkPerformanceCounterDescriptionKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterDescriptionKHR.html - struct PerformanceCounterDescriptionKHR - { - using NativeType = VkPerformanceCounterDescriptionKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterDescriptionKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionKHR( PerformanceCounterDescriptionFlagsKHR flags_ = {}, - std::array const & name_ = {}, - std::array const & category_ = {}, - std::array const & description_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , name{ name_ } - , category{ category_ } - , description{ description_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterDescriptionKHR( PerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerformanceCounterDescriptionKHR( VkPerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PerformanceCounterDescriptionKHR( *reinterpret_cast( &rhs ) ) - { - } - - PerformanceCounterDescriptionKHR & operator=( PerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerformanceCounterDescriptionKHR & operator=( VkPerformanceCounterDescriptionKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPerformanceCounterDescriptionKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceCounterDescriptionKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceCounterDescriptionKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerformanceCounterDescriptionKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &, - ArrayWrapper1D const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, name, category, description ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = strcmp( category, rhs.category ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( strcmp( name, rhs.name ) == 0 ) && - ( strcmp( category, rhs.category ) == 0 ) && ( strcmp( description, rhs.description ) == 0 ); - } - - bool operator!=( PerformanceCounterDescriptionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::ePerformanceCounterDescriptionKHR; - void * pNext = {}; - PerformanceCounterDescriptionFlagsKHR flags = {}; - ArrayWrapper1D name = {}; - ArrayWrapper1D category = {}; - ArrayWrapper1D description = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceCounterDescriptionKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PerformanceCounterDescriptionKHR; - }; - - // wrapper struct for struct VkPerformanceCounterKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceCounterKHR.html - struct PerformanceCounterKHR - { - using NativeType = VkPerformanceCounterKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceCounterKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterKHR( PerformanceCounterUnitKHR unit_ = PerformanceCounterUnitKHR::eGeneric, - PerformanceCounterScopeKHR scope_ = PerformanceCounterScopeKHR::eCommandBuffer, - PerformanceCounterStorageKHR storage_ = PerformanceCounterStorageKHR::eInt32, - std::array const & uuid_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , unit{ unit_ } - , scope{ scope_ } - , storage{ storage_ } - , uuid{ uuid_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterKHR( PerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerformanceCounterKHR( VkPerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PerformanceCounterKHR( *reinterpret_cast( &rhs ) ) - { - } - - PerformanceCounterKHR & operator=( PerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerformanceCounterKHR & operator=( VkPerformanceCounterKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPerformanceCounterKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceCounterKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceCounterKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerformanceCounterKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, unit, scope, storage, uuid ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PerformanceCounterKHR const & ) const = default; -#else - bool operator==( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( unit == rhs.unit ) && ( scope == rhs.scope ) && ( storage == rhs.storage ) && - ( uuid == rhs.uuid ); -# endif - } - - bool operator!=( PerformanceCounterKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePerformanceCounterKHR; - void * pNext = {}; - PerformanceCounterUnitKHR unit = PerformanceCounterUnitKHR::eGeneric; - PerformanceCounterScopeKHR scope = PerformanceCounterScopeKHR::eCommandBuffer; - PerformanceCounterStorageKHR storage = PerformanceCounterStorageKHR::eInt32; - ArrayWrapper1D uuid = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceCounterKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PerformanceCounterKHR; - }; - - union PerformanceCounterResultKHR - { - using NativeType = VkPerformanceCounterResultKHR; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( int32_t int32_ = {} ) : int32( int32_ ) {} - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( int64_t int64_ ) : int64( int64_ ) {} - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( uint32_t uint32_ ) : uint32( uint32_ ) {} - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( uint64_t uint64_ ) : uint64( uint64_ ) {} - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( float float32_ ) : float32( float32_ ) {} - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR( double float64_ ) : float64( float64_ ) {} -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setInt32( int32_t int32_ ) & VULKAN_HPP_NOEXCEPT - { - int32 = int32_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setInt32( int32_t int32_ ) && VULKAN_HPP_NOEXCEPT - { - int32 = int32_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setInt64( int64_t int64_ ) & VULKAN_HPP_NOEXCEPT - { - int64 = int64_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setInt64( int64_t int64_ ) && VULKAN_HPP_NOEXCEPT - { - int64 = int64_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setUint32( uint32_t uint32_ ) & VULKAN_HPP_NOEXCEPT - { - uint32 = uint32_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setUint32( uint32_t uint32_ ) && VULKAN_HPP_NOEXCEPT - { - uint32 = uint32_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setUint64( uint64_t uint64_ ) & VULKAN_HPP_NOEXCEPT - { - uint64 = uint64_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setUint64( uint64_t uint64_ ) && VULKAN_HPP_NOEXCEPT - { - uint64 = uint64_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setFloat32( float float32_ ) & VULKAN_HPP_NOEXCEPT - { - float32 = float32_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setFloat32( float float32_ ) && VULKAN_HPP_NOEXCEPT - { - float32 = float32_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR & setFloat64( double float64_ ) & VULKAN_HPP_NOEXCEPT - { - float64 = float64_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceCounterResultKHR && setFloat64( double float64_ ) && VULKAN_HPP_NOEXCEPT - { - float64 = float64_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPerformanceCounterResultKHR const &() const - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceCounterResultKHR &() - { - return *reinterpret_cast( this ); - } - - int32_t int32; - int64_t int64; - uint32_t uint32; - uint64_t uint64; - float float32; - double float64; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceCounterResultKHR; - }; -#endif - - // wrapper struct for struct VkPerformanceMarkerInfoINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceMarkerInfoINTEL.html - struct PerformanceMarkerInfoINTEL - { - using NativeType = VkPerformanceMarkerInfoINTEL; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceMarkerInfoINTEL; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( uint64_t marker_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , marker{ marker_ } - { - } - - VULKAN_HPP_CONSTEXPR PerformanceMarkerInfoINTEL( PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerformanceMarkerInfoINTEL( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : PerformanceMarkerInfoINTEL( *reinterpret_cast( &rhs ) ) - { - } - - PerformanceMarkerInfoINTEL & operator=( PerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerformanceMarkerInfoINTEL & operator=( VkPerformanceMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceMarkerInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceMarkerInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceMarkerInfoINTEL & setMarker( uint64_t marker_ ) & VULKAN_HPP_NOEXCEPT - { - marker = marker_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceMarkerInfoINTEL && setMarker( uint64_t marker_ ) && VULKAN_HPP_NOEXCEPT - { - marker = marker_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPerformanceMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceMarkerInfoINTEL const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerformanceMarkerInfoINTEL *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, marker ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PerformanceMarkerInfoINTEL const & ) const = default; -#else - bool operator==( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker ); -# endif - } - - bool operator!=( PerformanceMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePerformanceMarkerInfoINTEL; - const void * pNext = {}; - uint64_t marker = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceMarkerInfoINTEL; - }; -#endif - - template <> - struct CppType - { - using Type = PerformanceMarkerInfoINTEL; - }; - - // wrapper struct for struct VkPerformanceOverrideInfoINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceOverrideInfoINTEL.html - struct PerformanceOverrideInfoINTEL - { - using NativeType = VkPerformanceOverrideInfoINTEL; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceOverrideInfoINTEL; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( PerformanceOverrideTypeINTEL type_ = PerformanceOverrideTypeINTEL::eNullHardware, - Bool32 enable_ = {}, - uint64_t parameter_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , enable{ enable_ } - , parameter{ parameter_ } - { - } - - VULKAN_HPP_CONSTEXPR PerformanceOverrideInfoINTEL( PerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerformanceOverrideInfoINTEL( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : PerformanceOverrideInfoINTEL( *reinterpret_cast( &rhs ) ) - { - } - - PerformanceOverrideInfoINTEL & operator=( PerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerformanceOverrideInfoINTEL & operator=( VkPerformanceOverrideInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL & setType( PerformanceOverrideTypeINTEL type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL && setType( PerformanceOverrideTypeINTEL type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL & setEnable( Bool32 enable_ ) & VULKAN_HPP_NOEXCEPT - { - enable = enable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL && setEnable( Bool32 enable_ ) && VULKAN_HPP_NOEXCEPT - { - enable = enable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL & setParameter( uint64_t parameter_ ) & VULKAN_HPP_NOEXCEPT - { - parameter = parameter_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceOverrideInfoINTEL && setParameter( uint64_t parameter_ ) && VULKAN_HPP_NOEXCEPT - { - parameter = parameter_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPerformanceOverrideInfoINTEL const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceOverrideInfoINTEL &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceOverrideInfoINTEL const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerformanceOverrideInfoINTEL *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, type, enable, parameter ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PerformanceOverrideInfoINTEL const & ) const = default; -#else - bool operator==( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( enable == rhs.enable ) && ( parameter == rhs.parameter ); -# endif - } - - bool operator!=( PerformanceOverrideInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePerformanceOverrideInfoINTEL; - const void * pNext = {}; - PerformanceOverrideTypeINTEL type = PerformanceOverrideTypeINTEL::eNullHardware; - Bool32 enable = {}; - uint64_t parameter = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceOverrideInfoINTEL; - }; -#endif - - template <> - struct CppType - { - using Type = PerformanceOverrideInfoINTEL; - }; - - // wrapper struct for struct VkPerformanceQuerySubmitInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceQuerySubmitInfoKHR.html - struct PerformanceQuerySubmitInfoKHR - { - using NativeType = VkPerformanceQuerySubmitInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceQuerySubmitInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PerformanceQuerySubmitInfoKHR( uint32_t counterPassIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , counterPassIndex{ counterPassIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR PerformanceQuerySubmitInfoKHR( PerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerformanceQuerySubmitInfoKHR( VkPerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PerformanceQuerySubmitInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - PerformanceQuerySubmitInfoKHR & operator=( PerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerformanceQuerySubmitInfoKHR & operator=( VkPerformanceQuerySubmitInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceQuerySubmitInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceQuerySubmitInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceQuerySubmitInfoKHR & setCounterPassIndex( uint32_t counterPassIndex_ ) & VULKAN_HPP_NOEXCEPT - { - counterPassIndex = counterPassIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceQuerySubmitInfoKHR && setCounterPassIndex( uint32_t counterPassIndex_ ) && VULKAN_HPP_NOEXCEPT - { - counterPassIndex = counterPassIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPerformanceQuerySubmitInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceQuerySubmitInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceQuerySubmitInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerformanceQuerySubmitInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, counterPassIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PerformanceQuerySubmitInfoKHR const & ) const = default; -#else - bool operator==( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterPassIndex == rhs.counterPassIndex ); -# endif - } - - bool operator!=( PerformanceQuerySubmitInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePerformanceQuerySubmitInfoKHR; - const void * pNext = {}; - uint32_t counterPassIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceQuerySubmitInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PerformanceQuerySubmitInfoKHR; - }; - - // wrapper struct for struct VkPerformanceStreamMarkerInfoINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceStreamMarkerInfoINTEL.html - struct PerformanceStreamMarkerInfoINTEL - { - using NativeType = VkPerformanceStreamMarkerInfoINTEL; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerformanceStreamMarkerInfoINTEL; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( uint32_t marker_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , marker{ marker_ } - { - } - - VULKAN_HPP_CONSTEXPR PerformanceStreamMarkerInfoINTEL( PerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerformanceStreamMarkerInfoINTEL( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : PerformanceStreamMarkerInfoINTEL( *reinterpret_cast( &rhs ) ) - { - } - - PerformanceStreamMarkerInfoINTEL & operator=( PerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerformanceStreamMarkerInfoINTEL & operator=( VkPerformanceStreamMarkerInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceStreamMarkerInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceStreamMarkerInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceStreamMarkerInfoINTEL & setMarker( uint32_t marker_ ) & VULKAN_HPP_NOEXCEPT - { - marker = marker_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceStreamMarkerInfoINTEL && setMarker( uint32_t marker_ ) && VULKAN_HPP_NOEXCEPT - { - marker = marker_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPerformanceStreamMarkerInfoINTEL const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceStreamMarkerInfoINTEL &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceStreamMarkerInfoINTEL const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerformanceStreamMarkerInfoINTEL *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, marker ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PerformanceStreamMarkerInfoINTEL const & ) const = default; -#else - bool operator==( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( marker == rhs.marker ); -# endif - } - - bool operator!=( PerformanceStreamMarkerInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePerformanceStreamMarkerInfoINTEL; - const void * pNext = {}; - uint32_t marker = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceStreamMarkerInfoINTEL; - }; -#endif - - template <> - struct CppType - { - using Type = PerformanceStreamMarkerInfoINTEL; - }; - - union PerformanceValueDataINTEL - { - using NativeType = VkPerformanceValueDataINTEL; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL( uint32_t value32_ = {} ) : value32( value32_ ) {} - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL( uint64_t value64_ ) : value64( value64_ ) {} - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL( float valueFloat_ ) : valueFloat( valueFloat_ ) {} - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL( const char * valueString_ ) : valueString( valueString_ ) {} -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL & setValue32( uint32_t value32_ ) & VULKAN_HPP_NOEXCEPT - { - value32 = value32_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL && setValue32( uint32_t value32_ ) && VULKAN_HPP_NOEXCEPT - { - value32 = value32_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL & setValue64( uint64_t value64_ ) & VULKAN_HPP_NOEXCEPT - { - value64 = value64_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL && setValue64( uint64_t value64_ ) && VULKAN_HPP_NOEXCEPT - { - value64 = value64_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL & setValueFloat( float valueFloat_ ) & VULKAN_HPP_NOEXCEPT - { - valueFloat = valueFloat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL && setValueFloat( float valueFloat_ ) && VULKAN_HPP_NOEXCEPT - { - valueFloat = valueFloat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL & setValueBool( Bool32 valueBool_ ) & VULKAN_HPP_NOEXCEPT - { - valueBool = valueBool_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL && setValueBool( Bool32 valueBool_ ) && VULKAN_HPP_NOEXCEPT - { - valueBool = valueBool_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL & setValueString( const char * valueString_ ) & VULKAN_HPP_NOEXCEPT - { - valueString = valueString_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueDataINTEL && setValueString( const char * valueString_ ) && VULKAN_HPP_NOEXCEPT - { - valueString = valueString_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPerformanceValueDataINTEL const &() const - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceValueDataINTEL &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - uint32_t value32; - uint64_t value64; - float valueFloat; - Bool32 valueBool; - const char * valueString; -#else - uint32_t value32; - uint64_t value64; - float valueFloat; - VkBool32 valueBool; - const char * valueString; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceValueDataINTEL; - }; -#endif - - // wrapper struct for struct VkPerformanceValueINTEL, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceValueINTEL.html - struct PerformanceValueINTEL - { - using NativeType = VkPerformanceValueINTEL; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PerformanceValueINTEL( PerformanceValueTypeINTEL type_ = PerformanceValueTypeINTEL::eUint32, - PerformanceValueDataINTEL data_ = {} ) VULKAN_HPP_NOEXCEPT - : type{ type_ } - , data{ data_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PerformanceValueINTEL( PerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PerformanceValueINTEL( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : PerformanceValueINTEL( *reinterpret_cast( &rhs ) ) - { - } - - PerformanceValueINTEL & operator=( PerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PerformanceValueINTEL & operator=( VkPerformanceValueINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPerformanceValueINTEL const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceValueINTEL &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPerformanceValueINTEL const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPerformanceValueINTEL *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( type, data ); - } -#endif - - public: - PerformanceValueTypeINTEL type = PerformanceValueTypeINTEL::eUint32; - PerformanceValueDataINTEL data = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PerformanceValueINTEL; - }; -#endif - - // wrapper struct for struct VkPhysicalDevice16BitStorageFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice16BitStorageFeatures.html - struct PhysicalDevice16BitStorageFeatures - { - using NativeType = VkPhysicalDevice16BitStorageFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevice16BitStorageFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( Bool32 storageBuffer16BitAccess_ = {}, - Bool32 uniformAndStorageBuffer16BitAccess_ = {}, - Bool32 storagePushConstant16_ = {}, - Bool32 storageInputOutput16_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , storageBuffer16BitAccess{ storageBuffer16BitAccess_ } - , uniformAndStorageBuffer16BitAccess{ uniformAndStorageBuffer16BitAccess_ } - , storagePushConstant16{ storagePushConstant16_ } - , storageInputOutput16{ storageInputOutput16_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevice16BitStorageFeatures( PhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevice16BitStorageFeatures( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevice16BitStorageFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevice16BitStorageFeatures & operator=( PhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevice16BitStorageFeatures & operator=( VkPhysicalDevice16BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures & setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) & VULKAN_HPP_NOEXCEPT - { - storageBuffer16BitAccess = storageBuffer16BitAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures && setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) && VULKAN_HPP_NOEXCEPT - { - storageBuffer16BitAccess = storageBuffer16BitAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures & setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures && setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures & setStoragePushConstant16( Bool32 storagePushConstant16_ ) & VULKAN_HPP_NOEXCEPT - { - storagePushConstant16 = storagePushConstant16_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures && setStoragePushConstant16( Bool32 storagePushConstant16_ ) && VULKAN_HPP_NOEXCEPT - { - storagePushConstant16 = storagePushConstant16_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures & setStorageInputOutput16( Bool32 storageInputOutput16_ ) & VULKAN_HPP_NOEXCEPT - { - storageInputOutput16 = storageInputOutput16_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice16BitStorageFeatures && setStorageInputOutput16( Bool32 storageInputOutput16_ ) && VULKAN_HPP_NOEXCEPT - { - storageInputOutput16 = storageInputOutput16_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevice16BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevice16BitStorageFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevice16BitStorageFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevice16BitStorageFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, storageBuffer16BitAccess, uniformAndStorageBuffer16BitAccess, storagePushConstant16, storageInputOutput16 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevice16BitStorageFeatures const & ) const = default; -#else - bool operator==( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) && - ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) && ( storagePushConstant16 == rhs.storagePushConstant16 ) && - ( storageInputOutput16 == rhs.storageInputOutput16 ); -# endif - } - - bool operator!=( PhysicalDevice16BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevice16BitStorageFeatures; - void * pNext = {}; - Bool32 storageBuffer16BitAccess = {}; - Bool32 uniformAndStorageBuffer16BitAccess = {}; - Bool32 storagePushConstant16 = {}; - Bool32 storageInputOutput16 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevice16BitStorageFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevice16BitStorageFeatures; - }; - - using PhysicalDevice16BitStorageFeaturesKHR = PhysicalDevice16BitStorageFeatures; - - // wrapper struct for struct VkPhysicalDevice4444FormatsFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice4444FormatsFeaturesEXT.html - struct PhysicalDevice4444FormatsFeaturesEXT - { - using NativeType = VkPhysicalDevice4444FormatsFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevice4444FormatsFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDevice4444FormatsFeaturesEXT( Bool32 formatA4R4G4B4_ = {}, Bool32 formatA4B4G4R4_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , formatA4R4G4B4{ formatA4R4G4B4_ } - , formatA4B4G4R4{ formatA4B4G4R4_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevice4444FormatsFeaturesEXT( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevice4444FormatsFeaturesEXT( VkPhysicalDevice4444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevice4444FormatsFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevice4444FormatsFeaturesEXT & operator=( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevice4444FormatsFeaturesEXT & operator=( VkPhysicalDevice4444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT & setFormatA4R4G4B4( Bool32 formatA4R4G4B4_ ) & VULKAN_HPP_NOEXCEPT - { - formatA4R4G4B4 = formatA4R4G4B4_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT && setFormatA4R4G4B4( Bool32 formatA4R4G4B4_ ) && VULKAN_HPP_NOEXCEPT - { - formatA4R4G4B4 = formatA4R4G4B4_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT & setFormatA4B4G4R4( Bool32 formatA4B4G4R4_ ) & VULKAN_HPP_NOEXCEPT - { - formatA4B4G4R4 = formatA4B4G4R4_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice4444FormatsFeaturesEXT && setFormatA4B4G4R4( Bool32 formatA4B4G4R4_ ) && VULKAN_HPP_NOEXCEPT - { - formatA4B4G4R4 = formatA4B4G4R4_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevice4444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevice4444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevice4444FormatsFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevice4444FormatsFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, formatA4R4G4B4, formatA4B4G4R4 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevice4444FormatsFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatA4R4G4B4 == rhs.formatA4R4G4B4 ) && ( formatA4B4G4R4 == rhs.formatA4B4G4R4 ); -# endif - } - - bool operator!=( PhysicalDevice4444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevice4444FormatsFeaturesEXT; - void * pNext = {}; - Bool32 formatA4R4G4B4 = {}; - Bool32 formatA4B4G4R4 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevice4444FormatsFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevice4444FormatsFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDevice8BitStorageFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevice8BitStorageFeatures.html - struct PhysicalDevice8BitStorageFeatures - { - using NativeType = VkPhysicalDevice8BitStorageFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevice8BitStorageFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeatures( Bool32 storageBuffer8BitAccess_ = {}, - Bool32 uniformAndStorageBuffer8BitAccess_ = {}, - Bool32 storagePushConstant8_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , storageBuffer8BitAccess{ storageBuffer8BitAccess_ } - , uniformAndStorageBuffer8BitAccess{ uniformAndStorageBuffer8BitAccess_ } - , storagePushConstant8{ storagePushConstant8_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevice8BitStorageFeatures( PhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevice8BitStorageFeatures( VkPhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevice8BitStorageFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevice8BitStorageFeatures & operator=( PhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevice8BitStorageFeatures & operator=( VkPhysicalDevice8BitStorageFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures & setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ ) & VULKAN_HPP_NOEXCEPT - { - storageBuffer8BitAccess = storageBuffer8BitAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures && setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ ) && VULKAN_HPP_NOEXCEPT - { - storageBuffer8BitAccess = storageBuffer8BitAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures & setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures && setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures & setStoragePushConstant8( Bool32 storagePushConstant8_ ) & VULKAN_HPP_NOEXCEPT - { - storagePushConstant8 = storagePushConstant8_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevice8BitStorageFeatures && setStoragePushConstant8( Bool32 storagePushConstant8_ ) && VULKAN_HPP_NOEXCEPT - { - storagePushConstant8 = storagePushConstant8_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevice8BitStorageFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevice8BitStorageFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevice8BitStorageFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevice8BitStorageFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, storageBuffer8BitAccess, uniformAndStorageBuffer8BitAccess, storagePushConstant8 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevice8BitStorageFeatures const & ) const = default; -#else - bool operator==( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) && - ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) && ( storagePushConstant8 == rhs.storagePushConstant8 ); -# endif - } - - bool operator!=( PhysicalDevice8BitStorageFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevice8BitStorageFeatures; - void * pNext = {}; - Bool32 storageBuffer8BitAccess = {}; - Bool32 uniformAndStorageBuffer8BitAccess = {}; - Bool32 storagePushConstant8 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevice8BitStorageFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevice8BitStorageFeatures; - }; - - using PhysicalDevice8BitStorageFeaturesKHR = PhysicalDevice8BitStorageFeatures; - - // wrapper struct for struct VkPhysicalDeviceASTCDecodeFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceASTCDecodeFeaturesEXT.html - struct PhysicalDeviceASTCDecodeFeaturesEXT - { - using NativeType = VkPhysicalDeviceASTCDecodeFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( Bool32 decodeModeSharedExponent_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , decodeModeSharedExponent{ decodeModeSharedExponent_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceASTCDecodeFeaturesEXT( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceASTCDecodeFeaturesEXT( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceASTCDecodeFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceASTCDecodeFeaturesEXT & operator=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceASTCDecodeFeaturesEXT & operator=( VkPhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceASTCDecodeFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceASTCDecodeFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceASTCDecodeFeaturesEXT & setDecodeModeSharedExponent( Bool32 decodeModeSharedExponent_ ) & VULKAN_HPP_NOEXCEPT - { - decodeModeSharedExponent = decodeModeSharedExponent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceASTCDecodeFeaturesEXT && setDecodeModeSharedExponent( Bool32 decodeModeSharedExponent_ ) && VULKAN_HPP_NOEXCEPT - { - decodeModeSharedExponent = decodeModeSharedExponent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceASTCDecodeFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceASTCDecodeFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceASTCDecodeFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceASTCDecodeFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, decodeModeSharedExponent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceASTCDecodeFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decodeModeSharedExponent == rhs.decodeModeSharedExponent ); -# endif - } - - bool operator!=( PhysicalDeviceASTCDecodeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT; - void * pNext = {}; - Bool32 decodeModeSharedExponent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceASTCDecodeFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceASTCDecodeFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceAccelerationStructureFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAccelerationStructureFeaturesKHR.html - struct PhysicalDeviceAccelerationStructureFeaturesKHR - { - using NativeType = VkPhysicalDeviceAccelerationStructureFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAccelerationStructureFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceAccelerationStructureFeaturesKHR( Bool32 accelerationStructure_ = {}, - Bool32 accelerationStructureCaptureReplay_ = {}, - Bool32 accelerationStructureIndirectBuild_ = {}, - Bool32 accelerationStructureHostCommands_ = {}, - Bool32 descriptorBindingAccelerationStructureUpdateAfterBind_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , accelerationStructure{ accelerationStructure_ } - , accelerationStructureCaptureReplay{ accelerationStructureCaptureReplay_ } - , accelerationStructureIndirectBuild{ accelerationStructureIndirectBuild_ } - , accelerationStructureHostCommands{ accelerationStructureHostCommands_ } - , descriptorBindingAccelerationStructureUpdateAfterBind{ descriptorBindingAccelerationStructureUpdateAfterBind_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceAccelerationStructureFeaturesKHR( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceAccelerationStructureFeaturesKHR( VkPhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceAccelerationStructureFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceAccelerationStructureFeaturesKHR & operator=( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceAccelerationStructureFeaturesKHR & operator=( VkPhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & setAccelerationStructure( Bool32 accelerationStructure_ ) & VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && setAccelerationStructure( Bool32 accelerationStructure_ ) && VULKAN_HPP_NOEXCEPT - { - accelerationStructure = accelerationStructure_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & - setAccelerationStructureCaptureReplay( Bool32 accelerationStructureCaptureReplay_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructureCaptureReplay = accelerationStructureCaptureReplay_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && - setAccelerationStructureCaptureReplay( Bool32 accelerationStructureCaptureReplay_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructureCaptureReplay = accelerationStructureCaptureReplay_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & - setAccelerationStructureIndirectBuild( Bool32 accelerationStructureIndirectBuild_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructureIndirectBuild = accelerationStructureIndirectBuild_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && - setAccelerationStructureIndirectBuild( Bool32 accelerationStructureIndirectBuild_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructureIndirectBuild = accelerationStructureIndirectBuild_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & setAccelerationStructureHostCommands( Bool32 accelerationStructureHostCommands_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructureHostCommands = accelerationStructureHostCommands_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && - setAccelerationStructureHostCommands( Bool32 accelerationStructureHostCommands_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructureHostCommands = accelerationStructureHostCommands_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR & - setDescriptorBindingAccelerationStructureUpdateAfterBind( Bool32 descriptorBindingAccelerationStructureUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingAccelerationStructureUpdateAfterBind = descriptorBindingAccelerationStructureUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAccelerationStructureFeaturesKHR && - setDescriptorBindingAccelerationStructureUpdateAfterBind( Bool32 descriptorBindingAccelerationStructureUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingAccelerationStructureUpdateAfterBind = descriptorBindingAccelerationStructureUpdateAfterBind_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceAccelerationStructureFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAccelerationStructureFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAccelerationStructureFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAccelerationStructureFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - accelerationStructure, - accelerationStructureCaptureReplay, - accelerationStructureIndirectBuild, - accelerationStructureHostCommands, - descriptorBindingAccelerationStructureUpdateAfterBind ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceAccelerationStructureFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructure == rhs.accelerationStructure ) && - ( accelerationStructureCaptureReplay == rhs.accelerationStructureCaptureReplay ) && - ( accelerationStructureIndirectBuild == rhs.accelerationStructureIndirectBuild ) && - ( accelerationStructureHostCommands == rhs.accelerationStructureHostCommands ) && - ( descriptorBindingAccelerationStructureUpdateAfterBind == rhs.descriptorBindingAccelerationStructureUpdateAfterBind ); -# endif - } - - bool operator!=( PhysicalDeviceAccelerationStructureFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceAccelerationStructureFeaturesKHR; - void * pNext = {}; - Bool32 accelerationStructure = {}; - Bool32 accelerationStructureCaptureReplay = {}; - Bool32 accelerationStructureIndirectBuild = {}; - Bool32 accelerationStructureHostCommands = {}; - Bool32 descriptorBindingAccelerationStructureUpdateAfterBind = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceAccelerationStructureFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceAccelerationStructureFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceAccelerationStructurePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAccelerationStructurePropertiesKHR.html - struct PhysicalDeviceAccelerationStructurePropertiesKHR - { - using NativeType = VkPhysicalDeviceAccelerationStructurePropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAccelerationStructurePropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceAccelerationStructurePropertiesKHR( uint64_t maxGeometryCount_ = {}, - uint64_t maxInstanceCount_ = {}, - uint64_t maxPrimitiveCount_ = {}, - uint32_t maxPerStageDescriptorAccelerationStructures_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures_ = {}, - uint32_t maxDescriptorSetAccelerationStructures_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures_ = {}, - uint32_t minAccelerationStructureScratchOffsetAlignment_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxGeometryCount{ maxGeometryCount_ } - , maxInstanceCount{ maxInstanceCount_ } - , maxPrimitiveCount{ maxPrimitiveCount_ } - , maxPerStageDescriptorAccelerationStructures{ maxPerStageDescriptorAccelerationStructures_ } - , maxPerStageDescriptorUpdateAfterBindAccelerationStructures{ maxPerStageDescriptorUpdateAfterBindAccelerationStructures_ } - , maxDescriptorSetAccelerationStructures{ maxDescriptorSetAccelerationStructures_ } - , maxDescriptorSetUpdateAfterBindAccelerationStructures{ maxDescriptorSetUpdateAfterBindAccelerationStructures_ } - , minAccelerationStructureScratchOffsetAlignment{ minAccelerationStructureScratchOffsetAlignment_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceAccelerationStructurePropertiesKHR( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceAccelerationStructurePropertiesKHR( VkPhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceAccelerationStructurePropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceAccelerationStructurePropertiesKHR & operator=( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceAccelerationStructurePropertiesKHR & operator=( VkPhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceAccelerationStructurePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAccelerationStructurePropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAccelerationStructurePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAccelerationStructurePropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - maxGeometryCount, - maxInstanceCount, - maxPrimitiveCount, - maxPerStageDescriptorAccelerationStructures, - maxPerStageDescriptorUpdateAfterBindAccelerationStructures, - maxDescriptorSetAccelerationStructures, - maxDescriptorSetUpdateAfterBindAccelerationStructures, - minAccelerationStructureScratchOffsetAlignment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceAccelerationStructurePropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGeometryCount == rhs.maxGeometryCount ) && ( maxInstanceCount == rhs.maxInstanceCount ) && - ( maxPrimitiveCount == rhs.maxPrimitiveCount ) && - ( maxPerStageDescriptorAccelerationStructures == rhs.maxPerStageDescriptorAccelerationStructures ) && - ( maxPerStageDescriptorUpdateAfterBindAccelerationStructures == rhs.maxPerStageDescriptorUpdateAfterBindAccelerationStructures ) && - ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ) && - ( maxDescriptorSetUpdateAfterBindAccelerationStructures == rhs.maxDescriptorSetUpdateAfterBindAccelerationStructures ) && - ( minAccelerationStructureScratchOffsetAlignment == rhs.minAccelerationStructureScratchOffsetAlignment ); -# endif - } - - bool operator!=( PhysicalDeviceAccelerationStructurePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceAccelerationStructurePropertiesKHR; - void * pNext = {}; - uint64_t maxGeometryCount = {}; - uint64_t maxInstanceCount = {}; - uint64_t maxPrimitiveCount = {}; - uint32_t maxPerStageDescriptorAccelerationStructures = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures = {}; - uint32_t maxDescriptorSetAccelerationStructures = {}; - uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures = {}; - uint32_t minAccelerationStructureScratchOffsetAlignment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceAccelerationStructurePropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceAccelerationStructurePropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceAddressBindingReportFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAddressBindingReportFeaturesEXT.html - struct PhysicalDeviceAddressBindingReportFeaturesEXT - { - using NativeType = VkPhysicalDeviceAddressBindingReportFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAddressBindingReportFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceAddressBindingReportFeaturesEXT( Bool32 reportAddressBinding_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , reportAddressBinding{ reportAddressBinding_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceAddressBindingReportFeaturesEXT( PhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceAddressBindingReportFeaturesEXT( VkPhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceAddressBindingReportFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceAddressBindingReportFeaturesEXT & operator=( PhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceAddressBindingReportFeaturesEXT & operator=( VkPhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAddressBindingReportFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAddressBindingReportFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAddressBindingReportFeaturesEXT & setReportAddressBinding( Bool32 reportAddressBinding_ ) & VULKAN_HPP_NOEXCEPT - { - reportAddressBinding = reportAddressBinding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAddressBindingReportFeaturesEXT && setReportAddressBinding( Bool32 reportAddressBinding_ ) && VULKAN_HPP_NOEXCEPT - { - reportAddressBinding = reportAddressBinding_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceAddressBindingReportFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAddressBindingReportFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAddressBindingReportFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAddressBindingReportFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, reportAddressBinding ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceAddressBindingReportFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reportAddressBinding == rhs.reportAddressBinding ); -# endif - } - - bool operator!=( PhysicalDeviceAddressBindingReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceAddressBindingReportFeaturesEXT; - void * pNext = {}; - Bool32 reportAddressBinding = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceAddressBindingReportFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceAddressBindingReportFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceAmigoProfilingFeaturesSEC, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAmigoProfilingFeaturesSEC.html - struct PhysicalDeviceAmigoProfilingFeaturesSEC - { - using NativeType = VkPhysicalDeviceAmigoProfilingFeaturesSEC; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceAmigoProfilingFeaturesSEC( Bool32 amigoProfiling_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , amigoProfiling{ amigoProfiling_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceAmigoProfilingFeaturesSEC( PhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceAmigoProfilingFeaturesSEC( VkPhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceAmigoProfilingFeaturesSEC( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceAmigoProfilingFeaturesSEC & operator=( PhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceAmigoProfilingFeaturesSEC & operator=( VkPhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAmigoProfilingFeaturesSEC & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAmigoProfilingFeaturesSEC && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAmigoProfilingFeaturesSEC & setAmigoProfiling( Bool32 amigoProfiling_ ) & VULKAN_HPP_NOEXCEPT - { - amigoProfiling = amigoProfiling_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAmigoProfilingFeaturesSEC && setAmigoProfiling( Bool32 amigoProfiling_ ) && VULKAN_HPP_NOEXCEPT - { - amigoProfiling = amigoProfiling_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceAmigoProfilingFeaturesSEC const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAmigoProfilingFeaturesSEC &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAmigoProfilingFeaturesSEC const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAmigoProfilingFeaturesSEC *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, amigoProfiling ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceAmigoProfilingFeaturesSEC const & ) const = default; -#else - bool operator==( PhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( amigoProfiling == rhs.amigoProfiling ); -# endif - } - - bool operator!=( PhysicalDeviceAmigoProfilingFeaturesSEC const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC; - void * pNext = {}; - Bool32 amigoProfiling = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceAmigoProfilingFeaturesSEC; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceAmigoProfilingFeaturesSEC; - }; - - // wrapper struct for struct VkPhysicalDeviceAntiLagFeaturesAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAntiLagFeaturesAMD.html - struct PhysicalDeviceAntiLagFeaturesAMD - { - using NativeType = VkPhysicalDeviceAntiLagFeaturesAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAntiLagFeaturesAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceAntiLagFeaturesAMD( Bool32 antiLag_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , antiLag{ antiLag_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceAntiLagFeaturesAMD( PhysicalDeviceAntiLagFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceAntiLagFeaturesAMD( VkPhysicalDeviceAntiLagFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceAntiLagFeaturesAMD( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceAntiLagFeaturesAMD & operator=( PhysicalDeviceAntiLagFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceAntiLagFeaturesAMD & operator=( VkPhysicalDeviceAntiLagFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAntiLagFeaturesAMD & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAntiLagFeaturesAMD && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAntiLagFeaturesAMD & setAntiLag( Bool32 antiLag_ ) & VULKAN_HPP_NOEXCEPT - { - antiLag = antiLag_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAntiLagFeaturesAMD && setAntiLag( Bool32 antiLag_ ) && VULKAN_HPP_NOEXCEPT - { - antiLag = antiLag_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceAntiLagFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAntiLagFeaturesAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAntiLagFeaturesAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAntiLagFeaturesAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, antiLag ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceAntiLagFeaturesAMD const & ) const = default; -#else - bool operator==( PhysicalDeviceAntiLagFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( antiLag == rhs.antiLag ); -# endif - } - - bool operator!=( PhysicalDeviceAntiLagFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceAntiLagFeaturesAMD; - void * pNext = {}; - Bool32 antiLag = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceAntiLagFeaturesAMD; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceAntiLagFeaturesAMD; - }; - - // wrapper struct for struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.html - struct PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT - { - using NativeType = VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( Bool32 attachmentFeedbackLoopDynamicState_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , attachmentFeedbackLoopDynamicState{ attachmentFeedbackLoopDynamicState_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT( - *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT & - operator=( PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT & - operator=( VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT & - setAttachmentFeedbackLoopDynamicState( Bool32 attachmentFeedbackLoopDynamicState_ ) & - VULKAN_HPP_NOEXCEPT - { - attachmentFeedbackLoopDynamicState = attachmentFeedbackLoopDynamicState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT && - setAttachmentFeedbackLoopDynamicState( Bool32 attachmentFeedbackLoopDynamicState_ ) && - VULKAN_HPP_NOEXCEPT - { - attachmentFeedbackLoopDynamicState = attachmentFeedbackLoopDynamicState_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, attachmentFeedbackLoopDynamicState ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentFeedbackLoopDynamicState == rhs.attachmentFeedbackLoopDynamicState ); -# endif - } - - bool operator!=( PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; - void * pNext = {}; - Bool32 attachmentFeedbackLoopDynamicState = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.html - struct PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT - { - using NativeType = VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( Bool32 attachmentFeedbackLoopLayout_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , attachmentFeedbackLoopLayout{ attachmentFeedbackLoopLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT & - operator=( PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT & operator=( VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT & setAttachmentFeedbackLoopLayout( Bool32 attachmentFeedbackLoopLayout_ ) & - VULKAN_HPP_NOEXCEPT - { - attachmentFeedbackLoopLayout = attachmentFeedbackLoopLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT && setAttachmentFeedbackLoopLayout( Bool32 attachmentFeedbackLoopLayout_ ) && - VULKAN_HPP_NOEXCEPT - { - attachmentFeedbackLoopLayout = attachmentFeedbackLoopLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, attachmentFeedbackLoopLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentFeedbackLoopLayout == rhs.attachmentFeedbackLoopLayout ); -# endif - } - - bool operator!=( PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; - void * pNext = {}; - Bool32 attachmentFeedbackLoopLayout = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.html - struct PhysicalDeviceBlendOperationAdvancedFeaturesEXT - { - using NativeType = VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedFeaturesEXT( Bool32 advancedBlendCoherentOperations_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , advancedBlendCoherentOperations{ advancedBlendCoherentOperations_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceBlendOperationAdvancedFeaturesEXT( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceBlendOperationAdvancedFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT & operator=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceBlendOperationAdvancedFeaturesEXT & operator=( VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBlendOperationAdvancedFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBlendOperationAdvancedFeaturesEXT & setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ ) & - VULKAN_HPP_NOEXCEPT - { - advancedBlendCoherentOperations = advancedBlendCoherentOperations_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBlendOperationAdvancedFeaturesEXT && setAdvancedBlendCoherentOperations( Bool32 advancedBlendCoherentOperations_ ) && - VULKAN_HPP_NOEXCEPT - { - advancedBlendCoherentOperations = advancedBlendCoherentOperations_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, advancedBlendCoherentOperations ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( advancedBlendCoherentOperations == rhs.advancedBlendCoherentOperations ); -# endif - } - - bool operator!=( PhysicalDeviceBlendOperationAdvancedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT; - void * pNext = {}; - Bool32 advancedBlendCoherentOperations = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.html - struct PhysicalDeviceBlendOperationAdvancedPropertiesEXT - { - using NativeType = VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceBlendOperationAdvancedPropertiesEXT( uint32_t advancedBlendMaxColorAttachments_ = {}, - Bool32 advancedBlendIndependentBlend_ = {}, - Bool32 advancedBlendNonPremultipliedSrcColor_ = {}, - Bool32 advancedBlendNonPremultipliedDstColor_ = {}, - Bool32 advancedBlendCorrelatedOverlap_ = {}, - Bool32 advancedBlendAllOperations_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , advancedBlendMaxColorAttachments{ advancedBlendMaxColorAttachments_ } - , advancedBlendIndependentBlend{ advancedBlendIndependentBlend_ } - , advancedBlendNonPremultipliedSrcColor{ advancedBlendNonPremultipliedSrcColor_ } - , advancedBlendNonPremultipliedDstColor{ advancedBlendNonPremultipliedDstColor_ } - , advancedBlendCorrelatedOverlap{ advancedBlendCorrelatedOverlap_ } - , advancedBlendAllOperations{ advancedBlendAllOperations_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceBlendOperationAdvancedPropertiesEXT( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceBlendOperationAdvancedPropertiesEXT( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceBlendOperationAdvancedPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceBlendOperationAdvancedPropertiesEXT & - operator=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceBlendOperationAdvancedPropertiesEXT & operator=( VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - advancedBlendMaxColorAttachments, - advancedBlendIndependentBlend, - advancedBlendNonPremultipliedSrcColor, - advancedBlendNonPremultipliedDstColor, - advancedBlendCorrelatedOverlap, - advancedBlendAllOperations ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( advancedBlendMaxColorAttachments == rhs.advancedBlendMaxColorAttachments ) && - ( advancedBlendIndependentBlend == rhs.advancedBlendIndependentBlend ) && - ( advancedBlendNonPremultipliedSrcColor == rhs.advancedBlendNonPremultipliedSrcColor ) && - ( advancedBlendNonPremultipliedDstColor == rhs.advancedBlendNonPremultipliedDstColor ) && - ( advancedBlendCorrelatedOverlap == rhs.advancedBlendCorrelatedOverlap ) && ( advancedBlendAllOperations == rhs.advancedBlendAllOperations ); -# endif - } - - bool operator!=( PhysicalDeviceBlendOperationAdvancedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT; - void * pNext = {}; - uint32_t advancedBlendMaxColorAttachments = {}; - Bool32 advancedBlendIndependentBlend = {}; - Bool32 advancedBlendNonPremultipliedSrcColor = {}; - Bool32 advancedBlendNonPremultipliedDstColor = {}; - Bool32 advancedBlendCorrelatedOverlap = {}; - Bool32 advancedBlendAllOperations = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceBlendOperationAdvancedPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.html - struct PhysicalDeviceBorderColorSwizzleFeaturesEXT - { - using NativeType = VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBorderColorSwizzleFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceBorderColorSwizzleFeaturesEXT( Bool32 borderColorSwizzle_ = {}, - Bool32 borderColorSwizzleFromImage_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , borderColorSwizzle{ borderColorSwizzle_ } - , borderColorSwizzleFromImage{ borderColorSwizzleFromImage_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceBorderColorSwizzleFeaturesEXT( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceBorderColorSwizzleFeaturesEXT( VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceBorderColorSwizzleFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceBorderColorSwizzleFeaturesEXT & operator=( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceBorderColorSwizzleFeaturesEXT & operator=( VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT & setBorderColorSwizzle( Bool32 borderColorSwizzle_ ) & VULKAN_HPP_NOEXCEPT - { - borderColorSwizzle = borderColorSwizzle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT && setBorderColorSwizzle( Bool32 borderColorSwizzle_ ) && VULKAN_HPP_NOEXCEPT - { - borderColorSwizzle = borderColorSwizzle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT & setBorderColorSwizzleFromImage( Bool32 borderColorSwizzleFromImage_ ) & - VULKAN_HPP_NOEXCEPT - { - borderColorSwizzleFromImage = borderColorSwizzleFromImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBorderColorSwizzleFeaturesEXT && setBorderColorSwizzleFromImage( Bool32 borderColorSwizzleFromImage_ ) && - VULKAN_HPP_NOEXCEPT - { - borderColorSwizzleFromImage = borderColorSwizzleFromImage_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, borderColorSwizzle, borderColorSwizzleFromImage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( borderColorSwizzle == rhs.borderColorSwizzle ) && - ( borderColorSwizzleFromImage == rhs.borderColorSwizzleFromImage ); -# endif - } - - bool operator!=( PhysicalDeviceBorderColorSwizzleFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceBorderColorSwizzleFeaturesEXT; - void * pNext = {}; - Bool32 borderColorSwizzle = {}; - Bool32 borderColorSwizzleFromImage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceBorderColorSwizzleFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceBorderColorSwizzleFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceBufferDeviceAddressFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceBufferDeviceAddressFeatures.html - struct PhysicalDeviceBufferDeviceAddressFeatures - { - using NativeType = VkPhysicalDeviceBufferDeviceAddressFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBufferDeviceAddressFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeatures( Bool32 bufferDeviceAddress_ = {}, - Bool32 bufferDeviceAddressCaptureReplay_ = {}, - Bool32 bufferDeviceAddressMultiDevice_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , bufferDeviceAddress{ bufferDeviceAddress_ } - , bufferDeviceAddressCaptureReplay{ bufferDeviceAddressCaptureReplay_ } - , bufferDeviceAddressMultiDevice{ bufferDeviceAddressMultiDevice_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeatures( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceBufferDeviceAddressFeatures( VkPhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceBufferDeviceAddressFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceBufferDeviceAddressFeatures & operator=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceBufferDeviceAddressFeatures & operator=( VkPhysicalDeviceBufferDeviceAddressFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures & setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) & VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddress = bufferDeviceAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures && setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) && VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddress = bufferDeviceAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures & setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) & - VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures && setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) && - VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures & setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) & - VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeatures && setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) && - VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceBufferDeviceAddressFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBufferDeviceAddressFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBufferDeviceAddressFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBufferDeviceAddressFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceBufferDeviceAddressFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && - ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && - ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); -# endif - } - - bool operator!=( PhysicalDeviceBufferDeviceAddressFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeatures; - void * pNext = {}; - Bool32 bufferDeviceAddress = {}; - Bool32 bufferDeviceAddressCaptureReplay = {}; - Bool32 bufferDeviceAddressMultiDevice = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceBufferDeviceAddressFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceBufferDeviceAddressFeatures; - }; - - using PhysicalDeviceBufferDeviceAddressFeaturesKHR = PhysicalDeviceBufferDeviceAddressFeatures; - - // wrapper struct for struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.html - struct PhysicalDeviceBufferDeviceAddressFeaturesEXT - { - using NativeType = VkPhysicalDeviceBufferDeviceAddressFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( Bool32 bufferDeviceAddress_ = {}, - Bool32 bufferDeviceAddressCaptureReplay_ = {}, - Bool32 bufferDeviceAddressMultiDevice_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , bufferDeviceAddress{ bufferDeviceAddress_ } - , bufferDeviceAddressCaptureReplay{ bufferDeviceAddressCaptureReplay_ } - , bufferDeviceAddressMultiDevice{ bufferDeviceAddressMultiDevice_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceBufferDeviceAddressFeaturesEXT( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceBufferDeviceAddressFeaturesEXT( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceBufferDeviceAddressFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceBufferDeviceAddressFeaturesEXT & operator=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceBufferDeviceAddressFeaturesEXT & operator=( VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) & VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddress = bufferDeviceAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT && setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) && VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddress = bufferDeviceAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) & - VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT && setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) && - VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT & setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) & - VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceBufferDeviceAddressFeaturesEXT && setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) && - VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, bufferDeviceAddress, bufferDeviceAddressCaptureReplay, bufferDeviceAddressMultiDevice ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && - ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && - ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ); -# endif - } - - bool operator!=( PhysicalDeviceBufferDeviceAddressFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT; - void * pNext = {}; - Bool32 bufferDeviceAddress = {}; - Bool32 bufferDeviceAddressCaptureReplay = {}; - Bool32 bufferDeviceAddressMultiDevice = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceBufferDeviceAddressFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceBufferDeviceAddressFeaturesEXT; - }; - - using PhysicalDeviceBufferAddressFeaturesEXT = PhysicalDeviceBufferDeviceAddressFeaturesEXT; - - // wrapper struct for struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.html - struct PhysicalDeviceClusterAccelerationStructureFeaturesNV - { - using NativeType = VkPhysicalDeviceClusterAccelerationStructureFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceClusterAccelerationStructureFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceClusterAccelerationStructureFeaturesNV( Bool32 clusterAccelerationStructure_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , clusterAccelerationStructure{ clusterAccelerationStructure_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceClusterAccelerationStructureFeaturesNV( PhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceClusterAccelerationStructureFeaturesNV( VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceClusterAccelerationStructureFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceClusterAccelerationStructureFeaturesNV & - operator=( PhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceClusterAccelerationStructureFeaturesNV & operator=( VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterAccelerationStructureFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterAccelerationStructureFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterAccelerationStructureFeaturesNV & setClusterAccelerationStructure( Bool32 clusterAccelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - clusterAccelerationStructure = clusterAccelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterAccelerationStructureFeaturesNV && setClusterAccelerationStructure( Bool32 clusterAccelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - clusterAccelerationStructure = clusterAccelerationStructure_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterAccelerationStructureFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterAccelerationStructureFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, clusterAccelerationStructure ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceClusterAccelerationStructureFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( clusterAccelerationStructure == rhs.clusterAccelerationStructure ); -# endif - } - - bool operator!=( PhysicalDeviceClusterAccelerationStructureFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceClusterAccelerationStructureFeaturesNV; - void * pNext = {}; - Bool32 clusterAccelerationStructure = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceClusterAccelerationStructureFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceClusterAccelerationStructureFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterAccelerationStructurePropertiesNV.html - struct PhysicalDeviceClusterAccelerationStructurePropertiesNV - { - using NativeType = VkPhysicalDeviceClusterAccelerationStructurePropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceClusterAccelerationStructurePropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceClusterAccelerationStructurePropertiesNV( uint32_t maxVerticesPerCluster_ = {}, - uint32_t maxTrianglesPerCluster_ = {}, - uint32_t clusterScratchByteAlignment_ = {}, - uint32_t clusterByteAlignment_ = {}, - uint32_t clusterTemplateByteAlignment_ = {}, - uint32_t clusterBottomLevelByteAlignment_ = {}, - uint32_t clusterTemplateBoundsByteAlignment_ = {}, - uint32_t maxClusterGeometryIndex_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxVerticesPerCluster{ maxVerticesPerCluster_ } - , maxTrianglesPerCluster{ maxTrianglesPerCluster_ } - , clusterScratchByteAlignment{ clusterScratchByteAlignment_ } - , clusterByteAlignment{ clusterByteAlignment_ } - , clusterTemplateByteAlignment{ clusterTemplateByteAlignment_ } - , clusterBottomLevelByteAlignment{ clusterBottomLevelByteAlignment_ } - , clusterTemplateBoundsByteAlignment{ clusterTemplateBoundsByteAlignment_ } - , maxClusterGeometryIndex{ maxClusterGeometryIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceClusterAccelerationStructurePropertiesNV( PhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceClusterAccelerationStructurePropertiesNV( VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceClusterAccelerationStructurePropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceClusterAccelerationStructurePropertiesNV & - operator=( PhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceClusterAccelerationStructurePropertiesNV & - operator=( VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterAccelerationStructurePropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterAccelerationStructurePropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterAccelerationStructurePropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - maxVerticesPerCluster, - maxTrianglesPerCluster, - clusterScratchByteAlignment, - clusterByteAlignment, - clusterTemplateByteAlignment, - clusterBottomLevelByteAlignment, - clusterTemplateBoundsByteAlignment, - maxClusterGeometryIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceClusterAccelerationStructurePropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVerticesPerCluster == rhs.maxVerticesPerCluster ) && - ( maxTrianglesPerCluster == rhs.maxTrianglesPerCluster ) && ( clusterScratchByteAlignment == rhs.clusterScratchByteAlignment ) && - ( clusterByteAlignment == rhs.clusterByteAlignment ) && ( clusterTemplateByteAlignment == rhs.clusterTemplateByteAlignment ) && - ( clusterBottomLevelByteAlignment == rhs.clusterBottomLevelByteAlignment ) && - ( clusterTemplateBoundsByteAlignment == rhs.clusterTemplateBoundsByteAlignment ) && ( maxClusterGeometryIndex == rhs.maxClusterGeometryIndex ); -# endif - } - - bool operator!=( PhysicalDeviceClusterAccelerationStructurePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceClusterAccelerationStructurePropertiesNV; - void * pNext = {}; - uint32_t maxVerticesPerCluster = {}; - uint32_t maxTrianglesPerCluster = {}; - uint32_t clusterScratchByteAlignment = {}; - uint32_t clusterByteAlignment = {}; - uint32_t clusterTemplateByteAlignment = {}; - uint32_t clusterBottomLevelByteAlignment = {}; - uint32_t clusterTemplateBoundsByteAlignment = {}; - uint32_t maxClusterGeometryIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceClusterAccelerationStructurePropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceClusterAccelerationStructurePropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.html - struct PhysicalDeviceClusterCullingShaderFeaturesHUAWEI - { - using NativeType = VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceClusterCullingShaderFeaturesHUAWEI; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceClusterCullingShaderFeaturesHUAWEI( Bool32 clustercullingShader_ = {}, - Bool32 multiviewClusterCullingShader_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , clustercullingShader{ clustercullingShader_ } - , multiviewClusterCullingShader{ multiviewClusterCullingShader_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceClusterCullingShaderFeaturesHUAWEI( PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceClusterCullingShaderFeaturesHUAWEI( VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceClusterCullingShaderFeaturesHUAWEI( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceClusterCullingShaderFeaturesHUAWEI & operator=( PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceClusterCullingShaderFeaturesHUAWEI & operator=( VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI & setClustercullingShader( Bool32 clustercullingShader_ ) & VULKAN_HPP_NOEXCEPT - { - clustercullingShader = clustercullingShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI && setClustercullingShader( Bool32 clustercullingShader_ ) && VULKAN_HPP_NOEXCEPT - { - clustercullingShader = clustercullingShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI & setMultiviewClusterCullingShader( Bool32 multiviewClusterCullingShader_ ) & - VULKAN_HPP_NOEXCEPT - { - multiviewClusterCullingShader = multiviewClusterCullingShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderFeaturesHUAWEI && setMultiviewClusterCullingShader( Bool32 multiviewClusterCullingShader_ ) && - VULKAN_HPP_NOEXCEPT - { - multiviewClusterCullingShader = multiviewClusterCullingShader_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, clustercullingShader, multiviewClusterCullingShader ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & ) const = default; -#else - bool operator==( PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( clustercullingShader == rhs.clustercullingShader ) && - ( multiviewClusterCullingShader == rhs.multiviewClusterCullingShader ); -# endif - } - - bool operator!=( PhysicalDeviceClusterCullingShaderFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceClusterCullingShaderFeaturesHUAWEI; - void * pNext = {}; - Bool32 clustercullingShader = {}; - Bool32 multiviewClusterCullingShader = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceClusterCullingShaderFeaturesHUAWEI; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceClusterCullingShaderFeaturesHUAWEI; - }; - - // wrapper struct for struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI.html - struct PhysicalDeviceClusterCullingShaderPropertiesHUAWEI - { - using NativeType = VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceClusterCullingShaderPropertiesHUAWEI; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderPropertiesHUAWEI( std::array const & maxWorkGroupCount_ = {}, - std::array const & maxWorkGroupSize_ = {}, - uint32_t maxOutputClusterCount_ = {}, - DeviceSize indirectBufferOffsetAlignment_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxWorkGroupCount{ maxWorkGroupCount_ } - , maxWorkGroupSize{ maxWorkGroupSize_ } - , maxOutputClusterCount{ maxOutputClusterCount_ } - , indirectBufferOffsetAlignment{ indirectBufferOffsetAlignment_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - PhysicalDeviceClusterCullingShaderPropertiesHUAWEI( PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceClusterCullingShaderPropertiesHUAWEI( VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceClusterCullingShaderPropertiesHUAWEI( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceClusterCullingShaderPropertiesHUAWEI & - operator=( PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceClusterCullingShaderPropertiesHUAWEI & operator=( VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &, - uint32_t const &, - DeviceSize const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxWorkGroupCount, maxWorkGroupSize, maxOutputClusterCount, indirectBufferOffsetAlignment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & ) const = default; -#else - bool operator==( PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxWorkGroupCount == rhs.maxWorkGroupCount ) && - ( maxWorkGroupSize == rhs.maxWorkGroupSize ) && ( maxOutputClusterCount == rhs.maxOutputClusterCount ) && - ( indirectBufferOffsetAlignment == rhs.indirectBufferOffsetAlignment ); -# endif - } - - bool operator!=( PhysicalDeviceClusterCullingShaderPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceClusterCullingShaderPropertiesHUAWEI; - void * pNext = {}; - ArrayWrapper1D maxWorkGroupCount = {}; - ArrayWrapper1D maxWorkGroupSize = {}; - uint32_t maxOutputClusterCount = {}; - DeviceSize indirectBufferOffsetAlignment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceClusterCullingShaderPropertiesHUAWEI; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceClusterCullingShaderPropertiesHUAWEI; - }; - - // wrapper struct for struct VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.html - struct PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI - { - using NativeType = VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( Bool32 clusterShadingRate_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , clusterShadingRate{ clusterShadingRate_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI & - operator=( PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI & operator=( VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI & setClusterShadingRate( Bool32 clusterShadingRate_ ) & VULKAN_HPP_NOEXCEPT - { - clusterShadingRate = clusterShadingRate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI && setClusterShadingRate( Bool32 clusterShadingRate_ ) && VULKAN_HPP_NOEXCEPT - { - clusterShadingRate = clusterShadingRate_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, clusterShadingRate ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & ) const = default; -#else - bool operator==( PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( clusterShadingRate == rhs.clusterShadingRate ); -# endif - } - - bool operator!=( PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; - void * pNext = {}; - Bool32 clusterShadingRate = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI; - }; - - // wrapper struct for struct VkPhysicalDeviceCoherentMemoryFeaturesAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCoherentMemoryFeaturesAMD.html - struct PhysicalDeviceCoherentMemoryFeaturesAMD - { - using NativeType = VkPhysicalDeviceCoherentMemoryFeaturesAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( Bool32 deviceCoherentMemory_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceCoherentMemory{ deviceCoherentMemory_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCoherentMemoryFeaturesAMD( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCoherentMemoryFeaturesAMD( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCoherentMemoryFeaturesAMD( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCoherentMemoryFeaturesAMD & operator=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCoherentMemoryFeaturesAMD & operator=( VkPhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoherentMemoryFeaturesAMD & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoherentMemoryFeaturesAMD && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoherentMemoryFeaturesAMD & setDeviceCoherentMemory( Bool32 deviceCoherentMemory_ ) & VULKAN_HPP_NOEXCEPT - { - deviceCoherentMemory = deviceCoherentMemory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoherentMemoryFeaturesAMD && setDeviceCoherentMemory( Bool32 deviceCoherentMemory_ ) && VULKAN_HPP_NOEXCEPT - { - deviceCoherentMemory = deviceCoherentMemory_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCoherentMemoryFeaturesAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCoherentMemoryFeaturesAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCoherentMemoryFeaturesAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceCoherentMemory ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCoherentMemoryFeaturesAMD const & ) const = default; -#else - bool operator==( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceCoherentMemory == rhs.deviceCoherentMemory ); -# endif - } - - bool operator!=( PhysicalDeviceCoherentMemoryFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD; - void * pNext = {}; - Bool32 deviceCoherentMemory = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCoherentMemoryFeaturesAMD; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCoherentMemoryFeaturesAMD; - }; - - // wrapper struct for struct VkPhysicalDeviceColorWriteEnableFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceColorWriteEnableFeaturesEXT.html - struct PhysicalDeviceColorWriteEnableFeaturesEXT - { - using NativeType = VkPhysicalDeviceColorWriteEnableFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceColorWriteEnableFeaturesEXT( Bool32 colorWriteEnable_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , colorWriteEnable{ colorWriteEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceColorWriteEnableFeaturesEXT( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceColorWriteEnableFeaturesEXT( VkPhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceColorWriteEnableFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceColorWriteEnableFeaturesEXT & operator=( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceColorWriteEnableFeaturesEXT & operator=( VkPhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceColorWriteEnableFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceColorWriteEnableFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceColorWriteEnableFeaturesEXT & setColorWriteEnable( Bool32 colorWriteEnable_ ) & VULKAN_HPP_NOEXCEPT - { - colorWriteEnable = colorWriteEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceColorWriteEnableFeaturesEXT && setColorWriteEnable( Bool32 colorWriteEnable_ ) && VULKAN_HPP_NOEXCEPT - { - colorWriteEnable = colorWriteEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceColorWriteEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceColorWriteEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceColorWriteEnableFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceColorWriteEnableFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, colorWriteEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceColorWriteEnableFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorWriteEnable == rhs.colorWriteEnable ); -# endif - } - - bool operator!=( PhysicalDeviceColorWriteEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT; - void * pNext = {}; - Bool32 colorWriteEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceColorWriteEnableFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceColorWriteEnableFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.html - struct PhysicalDeviceCommandBufferInheritanceFeaturesNV - { - using NativeType = VkPhysicalDeviceCommandBufferInheritanceFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCommandBufferInheritanceFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCommandBufferInheritanceFeaturesNV( Bool32 commandBufferInheritance_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , commandBufferInheritance{ commandBufferInheritance_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceCommandBufferInheritanceFeaturesNV( PhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCommandBufferInheritanceFeaturesNV( VkPhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCommandBufferInheritanceFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCommandBufferInheritanceFeaturesNV & operator=( PhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCommandBufferInheritanceFeaturesNV & operator=( VkPhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCommandBufferInheritanceFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCommandBufferInheritanceFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCommandBufferInheritanceFeaturesNV & setCommandBufferInheritance( Bool32 commandBufferInheritance_ ) & - VULKAN_HPP_NOEXCEPT - { - commandBufferInheritance = commandBufferInheritance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCommandBufferInheritanceFeaturesNV && setCommandBufferInheritance( Bool32 commandBufferInheritance_ ) && - VULKAN_HPP_NOEXCEPT - { - commandBufferInheritance = commandBufferInheritance_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCommandBufferInheritanceFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCommandBufferInheritanceFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCommandBufferInheritanceFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, commandBufferInheritance ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCommandBufferInheritanceFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( commandBufferInheritance == rhs.commandBufferInheritance ); -# endif - } - - bool operator!=( PhysicalDeviceCommandBufferInheritanceFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCommandBufferInheritanceFeaturesNV; - void * pNext = {}; - Bool32 commandBufferInheritance = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCommandBufferInheritanceFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCommandBufferInheritanceFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV.html - struct PhysicalDeviceComputeOccupancyPriorityFeaturesNV - { - using NativeType = VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceComputeOccupancyPriorityFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeOccupancyPriorityFeaturesNV( Bool32 computeOccupancyPriority_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , computeOccupancyPriority{ computeOccupancyPriority_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceComputeOccupancyPriorityFeaturesNV( PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceComputeOccupancyPriorityFeaturesNV( VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceComputeOccupancyPriorityFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceComputeOccupancyPriorityFeaturesNV & operator=( PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceComputeOccupancyPriorityFeaturesNV & operator=( VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeOccupancyPriorityFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeOccupancyPriorityFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeOccupancyPriorityFeaturesNV & setComputeOccupancyPriority( Bool32 computeOccupancyPriority_ ) & - VULKAN_HPP_NOEXCEPT - { - computeOccupancyPriority = computeOccupancyPriority_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeOccupancyPriorityFeaturesNV && setComputeOccupancyPriority( Bool32 computeOccupancyPriority_ ) && - VULKAN_HPP_NOEXCEPT - { - computeOccupancyPriority = computeOccupancyPriority_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, computeOccupancyPriority ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( computeOccupancyPriority == rhs.computeOccupancyPriority ); -# endif - } - - bool operator!=( PhysicalDeviceComputeOccupancyPriorityFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceComputeOccupancyPriorityFeaturesNV; - void * pNext = {}; - Bool32 computeOccupancyPriority = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceComputeOccupancyPriorityFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceComputeOccupancyPriorityFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.html - struct PhysicalDeviceComputeShaderDerivativesFeaturesKHR - { - using NativeType = VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesFeaturesKHR( Bool32 computeDerivativeGroupQuads_ = {}, - Bool32 computeDerivativeGroupLinear_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , computeDerivativeGroupQuads{ computeDerivativeGroupQuads_ } - , computeDerivativeGroupLinear{ computeDerivativeGroupLinear_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceComputeShaderDerivativesFeaturesKHR( PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceComputeShaderDerivativesFeaturesKHR( VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceComputeShaderDerivativesFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceComputeShaderDerivativesFeaturesKHR & - operator=( PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceComputeShaderDerivativesFeaturesKHR & operator=( VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR & setComputeDerivativeGroupQuads( Bool32 computeDerivativeGroupQuads_ ) & - VULKAN_HPP_NOEXCEPT - { - computeDerivativeGroupQuads = computeDerivativeGroupQuads_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR && setComputeDerivativeGroupQuads( Bool32 computeDerivativeGroupQuads_ ) && - VULKAN_HPP_NOEXCEPT - { - computeDerivativeGroupQuads = computeDerivativeGroupQuads_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR & setComputeDerivativeGroupLinear( Bool32 computeDerivativeGroupLinear_ ) & - VULKAN_HPP_NOEXCEPT - { - computeDerivativeGroupLinear = computeDerivativeGroupLinear_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceComputeShaderDerivativesFeaturesKHR && setComputeDerivativeGroupLinear( Bool32 computeDerivativeGroupLinear_ ) && - VULKAN_HPP_NOEXCEPT - { - computeDerivativeGroupLinear = computeDerivativeGroupLinear_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, computeDerivativeGroupQuads, computeDerivativeGroupLinear ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( computeDerivativeGroupQuads == rhs.computeDerivativeGroupQuads ) && - ( computeDerivativeGroupLinear == rhs.computeDerivativeGroupLinear ); -# endif - } - - bool operator!=( PhysicalDeviceComputeShaderDerivativesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesKHR; - void * pNext = {}; - Bool32 computeDerivativeGroupQuads = {}; - Bool32 computeDerivativeGroupLinear = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceComputeShaderDerivativesFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceComputeShaderDerivativesFeaturesKHR; - }; - - using PhysicalDeviceComputeShaderDerivativesFeaturesNV = PhysicalDeviceComputeShaderDerivativesFeaturesKHR; - - // wrapper struct for struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR.html - struct PhysicalDeviceComputeShaderDerivativesPropertiesKHR - { - using NativeType = VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceComputeShaderDerivativesPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceComputeShaderDerivativesPropertiesKHR( Bool32 meshAndTaskShaderDerivatives_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , meshAndTaskShaderDerivatives{ meshAndTaskShaderDerivatives_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceComputeShaderDerivativesPropertiesKHR( PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceComputeShaderDerivativesPropertiesKHR( VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceComputeShaderDerivativesPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceComputeShaderDerivativesPropertiesKHR & - operator=( PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceComputeShaderDerivativesPropertiesKHR & operator=( VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, meshAndTaskShaderDerivatives ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( meshAndTaskShaderDerivatives == rhs.meshAndTaskShaderDerivatives ); -# endif - } - - bool operator!=( PhysicalDeviceComputeShaderDerivativesPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceComputeShaderDerivativesPropertiesKHR; - void * pNext = {}; - Bool32 meshAndTaskShaderDerivatives = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceComputeShaderDerivativesPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceComputeShaderDerivativesPropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceConditionalRenderingFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceConditionalRenderingFeaturesEXT.html - struct PhysicalDeviceConditionalRenderingFeaturesEXT - { - using NativeType = VkPhysicalDeviceConditionalRenderingFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceConditionalRenderingFeaturesEXT( Bool32 conditionalRendering_ = {}, - Bool32 inheritedConditionalRendering_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , conditionalRendering{ conditionalRendering_ } - , inheritedConditionalRendering{ inheritedConditionalRendering_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceConditionalRenderingFeaturesEXT( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceConditionalRenderingFeaturesEXT( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceConditionalRenderingFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceConditionalRenderingFeaturesEXT & operator=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceConditionalRenderingFeaturesEXT & operator=( VkPhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT & setConditionalRendering( Bool32 conditionalRendering_ ) & VULKAN_HPP_NOEXCEPT - { - conditionalRendering = conditionalRendering_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT && setConditionalRendering( Bool32 conditionalRendering_ ) && VULKAN_HPP_NOEXCEPT - { - conditionalRendering = conditionalRendering_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT & setInheritedConditionalRendering( Bool32 inheritedConditionalRendering_ ) & - VULKAN_HPP_NOEXCEPT - { - inheritedConditionalRendering = inheritedConditionalRendering_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceConditionalRenderingFeaturesEXT && setInheritedConditionalRendering( Bool32 inheritedConditionalRendering_ ) && - VULKAN_HPP_NOEXCEPT - { - inheritedConditionalRendering = inheritedConditionalRendering_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceConditionalRenderingFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceConditionalRenderingFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceConditionalRenderingFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, conditionalRendering, inheritedConditionalRendering ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceConditionalRenderingFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conditionalRendering == rhs.conditionalRendering ) && - ( inheritedConditionalRendering == rhs.inheritedConditionalRendering ); -# endif - } - - bool operator!=( PhysicalDeviceConditionalRenderingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT; - void * pNext = {}; - Bool32 conditionalRendering = {}; - Bool32 inheritedConditionalRendering = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceConditionalRenderingFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceConditionalRenderingFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceConservativeRasterizationPropertiesEXT.html - struct PhysicalDeviceConservativeRasterizationPropertiesEXT - { - using NativeType = VkPhysicalDeviceConservativeRasterizationPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceConservativeRasterizationPropertiesEXT( float primitiveOverestimationSize_ = {}, - float maxExtraPrimitiveOverestimationSize_ = {}, - float extraPrimitiveOverestimationSizeGranularity_ = {}, - Bool32 primitiveUnderestimation_ = {}, - Bool32 conservativePointAndLineRasterization_ = {}, - Bool32 degenerateTrianglesRasterized_ = {}, - Bool32 degenerateLinesRasterized_ = {}, - Bool32 fullyCoveredFragmentShaderInputVariable_ = {}, - Bool32 conservativeRasterizationPostDepthCoverage_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , primitiveOverestimationSize{ primitiveOverestimationSize_ } - , maxExtraPrimitiveOverestimationSize{ maxExtraPrimitiveOverestimationSize_ } - , extraPrimitiveOverestimationSizeGranularity{ extraPrimitiveOverestimationSizeGranularity_ } - , primitiveUnderestimation{ primitiveUnderestimation_ } - , conservativePointAndLineRasterization{ conservativePointAndLineRasterization_ } - , degenerateTrianglesRasterized{ degenerateTrianglesRasterized_ } - , degenerateLinesRasterized{ degenerateLinesRasterized_ } - , fullyCoveredFragmentShaderInputVariable{ fullyCoveredFragmentShaderInputVariable_ } - , conservativeRasterizationPostDepthCoverage{ conservativeRasterizationPostDepthCoverage_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceConservativeRasterizationPropertiesEXT( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceConservativeRasterizationPropertiesEXT( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceConservativeRasterizationPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceConservativeRasterizationPropertiesEXT & - operator=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceConservativeRasterizationPropertiesEXT & operator=( VkPhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceConservativeRasterizationPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - primitiveOverestimationSize, - maxExtraPrimitiveOverestimationSize, - extraPrimitiveOverestimationSizeGranularity, - primitiveUnderestimation, - conservativePointAndLineRasterization, - degenerateTrianglesRasterized, - degenerateLinesRasterized, - fullyCoveredFragmentShaderInputVariable, - conservativeRasterizationPostDepthCoverage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceConservativeRasterizationPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( primitiveOverestimationSize == rhs.primitiveOverestimationSize ) && - ( maxExtraPrimitiveOverestimationSize == rhs.maxExtraPrimitiveOverestimationSize ) && - ( extraPrimitiveOverestimationSizeGranularity == rhs.extraPrimitiveOverestimationSizeGranularity ) && - ( primitiveUnderestimation == rhs.primitiveUnderestimation ) && - ( conservativePointAndLineRasterization == rhs.conservativePointAndLineRasterization ) && - ( degenerateTrianglesRasterized == rhs.degenerateTrianglesRasterized ) && ( degenerateLinesRasterized == rhs.degenerateLinesRasterized ) && - ( fullyCoveredFragmentShaderInputVariable == rhs.fullyCoveredFragmentShaderInputVariable ) && - ( conservativeRasterizationPostDepthCoverage == rhs.conservativeRasterizationPostDepthCoverage ); -# endif - } - - bool operator!=( PhysicalDeviceConservativeRasterizationPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT; - void * pNext = {}; - float primitiveOverestimationSize = {}; - float maxExtraPrimitiveOverestimationSize = {}; - float extraPrimitiveOverestimationSizeGranularity = {}; - Bool32 primitiveUnderestimation = {}; - Bool32 conservativePointAndLineRasterization = {}; - Bool32 degenerateTrianglesRasterized = {}; - Bool32 degenerateLinesRasterized = {}; - Bool32 fullyCoveredFragmentShaderInputVariable = {}; - Bool32 conservativeRasterizationPostDepthCoverage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceConservativeRasterizationPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrix2FeaturesNV.html - struct PhysicalDeviceCooperativeMatrix2FeaturesNV - { - using NativeType = VkPhysicalDeviceCooperativeMatrix2FeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2FeaturesNV( Bool32 cooperativeMatrixWorkgroupScope_ = {}, - Bool32 cooperativeMatrixFlexibleDimensions_ = {}, - Bool32 cooperativeMatrixReductions_ = {}, - Bool32 cooperativeMatrixConversions_ = {}, - Bool32 cooperativeMatrixPerElementOperations_ = {}, - Bool32 cooperativeMatrixTensorAddressing_ = {}, - Bool32 cooperativeMatrixBlockLoads_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cooperativeMatrixWorkgroupScope{ cooperativeMatrixWorkgroupScope_ } - , cooperativeMatrixFlexibleDimensions{ cooperativeMatrixFlexibleDimensions_ } - , cooperativeMatrixReductions{ cooperativeMatrixReductions_ } - , cooperativeMatrixConversions{ cooperativeMatrixConversions_ } - , cooperativeMatrixPerElementOperations{ cooperativeMatrixPerElementOperations_ } - , cooperativeMatrixTensorAddressing{ cooperativeMatrixTensorAddressing_ } - , cooperativeMatrixBlockLoads{ cooperativeMatrixBlockLoads_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2FeaturesNV( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCooperativeMatrix2FeaturesNV( VkPhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCooperativeMatrix2FeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCooperativeMatrix2FeaturesNV & operator=( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCooperativeMatrix2FeaturesNV & operator=( VkPhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixWorkgroupScope( Bool32 cooperativeMatrixWorkgroupScope_ ) & - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixWorkgroupScope = cooperativeMatrixWorkgroupScope_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setCooperativeMatrixWorkgroupScope( Bool32 cooperativeMatrixWorkgroupScope_ ) && - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixWorkgroupScope = cooperativeMatrixWorkgroupScope_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixFlexibleDimensions( Bool32 cooperativeMatrixFlexibleDimensions_ ) & - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixFlexibleDimensions = cooperativeMatrixFlexibleDimensions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && - setCooperativeMatrixFlexibleDimensions( Bool32 cooperativeMatrixFlexibleDimensions_ ) && - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixFlexibleDimensions = cooperativeMatrixFlexibleDimensions_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixReductions( Bool32 cooperativeMatrixReductions_ ) & - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixReductions = cooperativeMatrixReductions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setCooperativeMatrixReductions( Bool32 cooperativeMatrixReductions_ ) && - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixReductions = cooperativeMatrixReductions_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixConversions( Bool32 cooperativeMatrixConversions_ ) & - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixConversions = cooperativeMatrixConversions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setCooperativeMatrixConversions( Bool32 cooperativeMatrixConversions_ ) && - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixConversions = cooperativeMatrixConversions_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & - setCooperativeMatrixPerElementOperations( Bool32 cooperativeMatrixPerElementOperations_ ) & - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixPerElementOperations = cooperativeMatrixPerElementOperations_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && - setCooperativeMatrixPerElementOperations( Bool32 cooperativeMatrixPerElementOperations_ ) && - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixPerElementOperations = cooperativeMatrixPerElementOperations_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixTensorAddressing( Bool32 cooperativeMatrixTensorAddressing_ ) & - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixTensorAddressing = cooperativeMatrixTensorAddressing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setCooperativeMatrixTensorAddressing( Bool32 cooperativeMatrixTensorAddressing_ ) && - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixTensorAddressing = cooperativeMatrixTensorAddressing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV & setCooperativeMatrixBlockLoads( Bool32 cooperativeMatrixBlockLoads_ ) & - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixBlockLoads = cooperativeMatrixBlockLoads_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrix2FeaturesNV && setCooperativeMatrixBlockLoads( Bool32 cooperativeMatrixBlockLoads_ ) && - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixBlockLoads = cooperativeMatrixBlockLoads_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCooperativeMatrix2FeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrix2FeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrix2FeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrix2FeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - cooperativeMatrixWorkgroupScope, - cooperativeMatrixFlexibleDimensions, - cooperativeMatrixReductions, - cooperativeMatrixConversions, - cooperativeMatrixPerElementOperations, - cooperativeMatrixTensorAddressing, - cooperativeMatrixBlockLoads ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCooperativeMatrix2FeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrixWorkgroupScope == rhs.cooperativeMatrixWorkgroupScope ) && - ( cooperativeMatrixFlexibleDimensions == rhs.cooperativeMatrixFlexibleDimensions ) && - ( cooperativeMatrixReductions == rhs.cooperativeMatrixReductions ) && ( cooperativeMatrixConversions == rhs.cooperativeMatrixConversions ) && - ( cooperativeMatrixPerElementOperations == rhs.cooperativeMatrixPerElementOperations ) && - ( cooperativeMatrixTensorAddressing == rhs.cooperativeMatrixTensorAddressing ) && - ( cooperativeMatrixBlockLoads == rhs.cooperativeMatrixBlockLoads ); -# endif - } - - bool operator!=( PhysicalDeviceCooperativeMatrix2FeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV; - void * pNext = {}; - Bool32 cooperativeMatrixWorkgroupScope = {}; - Bool32 cooperativeMatrixFlexibleDimensions = {}; - Bool32 cooperativeMatrixReductions = {}; - Bool32 cooperativeMatrixConversions = {}; - Bool32 cooperativeMatrixPerElementOperations = {}; - Bool32 cooperativeMatrixTensorAddressing = {}; - Bool32 cooperativeMatrixBlockLoads = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrix2FeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrix2FeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrix2PropertiesNV.html - struct PhysicalDeviceCooperativeMatrix2PropertiesNV - { - using NativeType = VkPhysicalDeviceCooperativeMatrix2PropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2PropertiesNV( uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize_ = {}, - uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension_ = {}, - uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cooperativeMatrixWorkgroupScopeMaxWorkgroupSize{ cooperativeMatrixWorkgroupScopeMaxWorkgroupSize_ } - , cooperativeMatrixFlexibleDimensionsMaxDimension{ cooperativeMatrixFlexibleDimensionsMaxDimension_ } - , cooperativeMatrixWorkgroupScopeReservedSharedMemory{ cooperativeMatrixWorkgroupScopeReservedSharedMemory_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrix2PropertiesNV( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCooperativeMatrix2PropertiesNV( VkPhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCooperativeMatrix2PropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCooperativeMatrix2PropertiesNV & operator=( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCooperativeMatrix2PropertiesNV & operator=( VkPhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceCooperativeMatrix2PropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrix2PropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrix2PropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrix2PropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - cooperativeMatrixWorkgroupScopeMaxWorkgroupSize, - cooperativeMatrixFlexibleDimensionsMaxDimension, - cooperativeMatrixWorkgroupScopeReservedSharedMemory ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCooperativeMatrix2PropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( cooperativeMatrixWorkgroupScopeMaxWorkgroupSize == rhs.cooperativeMatrixWorkgroupScopeMaxWorkgroupSize ) && - ( cooperativeMatrixFlexibleDimensionsMaxDimension == rhs.cooperativeMatrixFlexibleDimensionsMaxDimension ) && - ( cooperativeMatrixWorkgroupScopeReservedSharedMemory == rhs.cooperativeMatrixWorkgroupScopeReservedSharedMemory ); -# endif - } - - bool operator!=( PhysicalDeviceCooperativeMatrix2PropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV; - void * pNext = {}; - uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = {}; - uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension = {}; - uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrix2PropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrix2PropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesKHR.html - struct PhysicalDeviceCooperativeMatrixFeaturesKHR - { - using NativeType = VkPhysicalDeviceCooperativeMatrixFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesKHR( Bool32 cooperativeMatrix_ = {}, - Bool32 cooperativeMatrixRobustBufferAccess_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cooperativeMatrix{ cooperativeMatrix_ } - , cooperativeMatrixRobustBufferAccess{ cooperativeMatrixRobustBufferAccess_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesKHR( PhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCooperativeMatrixFeaturesKHR( VkPhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCooperativeMatrixFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCooperativeMatrixFeaturesKHR & operator=( PhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCooperativeMatrixFeaturesKHR & operator=( VkPhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR & setCooperativeMatrix( Bool32 cooperativeMatrix_ ) & VULKAN_HPP_NOEXCEPT - { - cooperativeMatrix = cooperativeMatrix_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR && setCooperativeMatrix( Bool32 cooperativeMatrix_ ) && VULKAN_HPP_NOEXCEPT - { - cooperativeMatrix = cooperativeMatrix_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR & setCooperativeMatrixRobustBufferAccess( Bool32 cooperativeMatrixRobustBufferAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesKHR && - setCooperativeMatrixRobustBufferAccess( Bool32 cooperativeMatrixRobustBufferAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCooperativeMatrixFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) && - ( cooperativeMatrixRobustBufferAccess == rhs.cooperativeMatrixRobustBufferAccess ); -# endif - } - - bool operator!=( PhysicalDeviceCooperativeMatrixFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesKHR; - void * pNext = {}; - Bool32 cooperativeMatrix = {}; - Bool32 cooperativeMatrixRobustBufferAccess = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrixFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrixFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixFeaturesNV.html - struct PhysicalDeviceCooperativeMatrixFeaturesNV - { - using NativeType = VkPhysicalDeviceCooperativeMatrixFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( Bool32 cooperativeMatrix_ = {}, - Bool32 cooperativeMatrixRobustBufferAccess_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cooperativeMatrix{ cooperativeMatrix_ } - , cooperativeMatrixRobustBufferAccess{ cooperativeMatrixRobustBufferAccess_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixFeaturesNV( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCooperativeMatrixFeaturesNV( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCooperativeMatrixFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCooperativeMatrixFeaturesNV & operator=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCooperativeMatrixFeaturesNV & operator=( VkPhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrix( Bool32 cooperativeMatrix_ ) & VULKAN_HPP_NOEXCEPT - { - cooperativeMatrix = cooperativeMatrix_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV && setCooperativeMatrix( Bool32 cooperativeMatrix_ ) && VULKAN_HPP_NOEXCEPT - { - cooperativeMatrix = cooperativeMatrix_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV & setCooperativeMatrixRobustBufferAccess( Bool32 cooperativeMatrixRobustBufferAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeMatrixFeaturesNV && - setCooperativeMatrixRobustBufferAccess( Bool32 cooperativeMatrixRobustBufferAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - cooperativeMatrixRobustBufferAccess = cooperativeMatrixRobustBufferAccess_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, cooperativeMatrix, cooperativeMatrixRobustBufferAccess ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCooperativeMatrixFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrix == rhs.cooperativeMatrix ) && - ( cooperativeMatrixRobustBufferAccess == rhs.cooperativeMatrixRobustBufferAccess ); -# endif - } - - bool operator!=( PhysicalDeviceCooperativeMatrixFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV; - void * pNext = {}; - Bool32 cooperativeMatrix = {}; - Bool32 cooperativeMatrixRobustBufferAccess = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrixFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrixFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesKHR.html - struct PhysicalDeviceCooperativeMatrixPropertiesKHR - { - using NativeType = VkPhysicalDeviceCooperativeMatrixPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesKHR( ShaderStageFlags cooperativeMatrixSupportedStages_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cooperativeMatrixSupportedStages{ cooperativeMatrixSupportedStages_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesKHR( PhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCooperativeMatrixPropertiesKHR( VkPhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCooperativeMatrixPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCooperativeMatrixPropertiesKHR & operator=( PhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCooperativeMatrixPropertiesKHR & operator=( VkPhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceCooperativeMatrixPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, cooperativeMatrixSupportedStages ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages ); -# endif - } - - bool operator!=( PhysicalDeviceCooperativeMatrixPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR; - void * pNext = {}; - ShaderStageFlags cooperativeMatrixSupportedStages = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrixPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrixPropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceCooperativeMatrixPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeMatrixPropertiesNV.html - struct PhysicalDeviceCooperativeMatrixPropertiesNV - { - using NativeType = VkPhysicalDeviceCooperativeMatrixPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesNV( ShaderStageFlags cooperativeMatrixSupportedStages_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cooperativeMatrixSupportedStages{ cooperativeMatrixSupportedStages_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeMatrixPropertiesNV( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCooperativeMatrixPropertiesNV( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCooperativeMatrixPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCooperativeMatrixPropertiesNV & operator=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCooperativeMatrixPropertiesNV & operator=( VkPhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeMatrixPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, cooperativeMatrixSupportedStages ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCooperativeMatrixPropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeMatrixSupportedStages == rhs.cooperativeMatrixSupportedStages ); -# endif - } - - bool operator!=( PhysicalDeviceCooperativeMatrixPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV; - void * pNext = {}; - ShaderStageFlags cooperativeMatrixSupportedStages = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrixPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeMatrixPropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceCooperativeVectorFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeVectorFeaturesNV.html - struct PhysicalDeviceCooperativeVectorFeaturesNV - { - using NativeType = VkPhysicalDeviceCooperativeVectorFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeVectorFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeVectorFeaturesNV( Bool32 cooperativeVector_ = {}, - Bool32 cooperativeVectorTraining_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cooperativeVector{ cooperativeVector_ } - , cooperativeVectorTraining{ cooperativeVectorTraining_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeVectorFeaturesNV( PhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCooperativeVectorFeaturesNV( VkPhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCooperativeVectorFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCooperativeVectorFeaturesNV & operator=( PhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCooperativeVectorFeaturesNV & operator=( VkPhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV & setCooperativeVector( Bool32 cooperativeVector_ ) & VULKAN_HPP_NOEXCEPT - { - cooperativeVector = cooperativeVector_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV && setCooperativeVector( Bool32 cooperativeVector_ ) && VULKAN_HPP_NOEXCEPT - { - cooperativeVector = cooperativeVector_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV & setCooperativeVectorTraining( Bool32 cooperativeVectorTraining_ ) & VULKAN_HPP_NOEXCEPT - { - cooperativeVectorTraining = cooperativeVectorTraining_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCooperativeVectorFeaturesNV && setCooperativeVectorTraining( Bool32 cooperativeVectorTraining_ ) && - VULKAN_HPP_NOEXCEPT - { - cooperativeVectorTraining = cooperativeVectorTraining_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCooperativeVectorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeVectorFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeVectorFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeVectorFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, cooperativeVector, cooperativeVectorTraining ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCooperativeVectorFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeVector == rhs.cooperativeVector ) && - ( cooperativeVectorTraining == rhs.cooperativeVectorTraining ); -# endif - } - - bool operator!=( PhysicalDeviceCooperativeVectorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCooperativeVectorFeaturesNV; - void * pNext = {}; - Bool32 cooperativeVector = {}; - Bool32 cooperativeVectorTraining = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeVectorFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeVectorFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceCooperativeVectorPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCooperativeVectorPropertiesNV.html - struct PhysicalDeviceCooperativeVectorPropertiesNV - { - using NativeType = VkPhysicalDeviceCooperativeVectorPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCooperativeVectorPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeVectorPropertiesNV( ShaderStageFlags cooperativeVectorSupportedStages_ = {}, - Bool32 cooperativeVectorTrainingFloat16Accumulation_ = {}, - Bool32 cooperativeVectorTrainingFloat32Accumulation_ = {}, - uint32_t maxCooperativeVectorComponents_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cooperativeVectorSupportedStages{ cooperativeVectorSupportedStages_ } - , cooperativeVectorTrainingFloat16Accumulation{ cooperativeVectorTrainingFloat16Accumulation_ } - , cooperativeVectorTrainingFloat32Accumulation{ cooperativeVectorTrainingFloat32Accumulation_ } - , maxCooperativeVectorComponents{ maxCooperativeVectorComponents_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCooperativeVectorPropertiesNV( PhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCooperativeVectorPropertiesNV( VkPhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCooperativeVectorPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCooperativeVectorPropertiesNV & operator=( PhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCooperativeVectorPropertiesNV & operator=( VkPhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceCooperativeVectorPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeVectorPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeVectorPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCooperativeVectorPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - cooperativeVectorSupportedStages, - cooperativeVectorTrainingFloat16Accumulation, - cooperativeVectorTrainingFloat32Accumulation, - maxCooperativeVectorComponents ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCooperativeVectorPropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cooperativeVectorSupportedStages == rhs.cooperativeVectorSupportedStages ) && - ( cooperativeVectorTrainingFloat16Accumulation == rhs.cooperativeVectorTrainingFloat16Accumulation ) && - ( cooperativeVectorTrainingFloat32Accumulation == rhs.cooperativeVectorTrainingFloat32Accumulation ) && - ( maxCooperativeVectorComponents == rhs.maxCooperativeVectorComponents ); -# endif - } - - bool operator!=( PhysicalDeviceCooperativeVectorPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCooperativeVectorPropertiesNV; - void * pNext = {}; - ShaderStageFlags cooperativeVectorSupportedStages = {}; - Bool32 cooperativeVectorTrainingFloat16Accumulation = {}; - Bool32 cooperativeVectorTrainingFloat32Accumulation = {}; - uint32_t maxCooperativeVectorComponents = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeVectorPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCooperativeVectorPropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR.html - struct PhysicalDeviceCopyMemoryIndirectFeaturesKHR - { - using NativeType = VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectFeaturesKHR( Bool32 indirectMemoryCopy_ = {}, - Bool32 indirectMemoryToImageCopy_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , indirectMemoryCopy{ indirectMemoryCopy_ } - , indirectMemoryToImageCopy{ indirectMemoryToImageCopy_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectFeaturesKHR( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCopyMemoryIndirectFeaturesKHR( VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCopyMemoryIndirectFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCopyMemoryIndirectFeaturesKHR & operator=( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCopyMemoryIndirectFeaturesKHR & operator=( VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR & setIndirectMemoryCopy( Bool32 indirectMemoryCopy_ ) & VULKAN_HPP_NOEXCEPT - { - indirectMemoryCopy = indirectMemoryCopy_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR && setIndirectMemoryCopy( Bool32 indirectMemoryCopy_ ) && VULKAN_HPP_NOEXCEPT - { - indirectMemoryCopy = indirectMemoryCopy_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR & setIndirectMemoryToImageCopy( Bool32 indirectMemoryToImageCopy_ ) & - VULKAN_HPP_NOEXCEPT - { - indirectMemoryToImageCopy = indirectMemoryToImageCopy_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesKHR && setIndirectMemoryToImageCopy( Bool32 indirectMemoryToImageCopy_ ) && - VULKAN_HPP_NOEXCEPT - { - indirectMemoryToImageCopy = indirectMemoryToImageCopy_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, indirectMemoryCopy, indirectMemoryToImageCopy ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indirectMemoryCopy == rhs.indirectMemoryCopy ) && - ( indirectMemoryToImageCopy == rhs.indirectMemoryToImageCopy ); -# endif - } - - bool operator!=( PhysicalDeviceCopyMemoryIndirectFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesKHR; - void * pNext = {}; - Bool32 indirectMemoryCopy = {}; - Bool32 indirectMemoryToImageCopy = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCopyMemoryIndirectFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCopyMemoryIndirectFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.html - struct PhysicalDeviceCopyMemoryIndirectFeaturesNV - { - using NativeType = VkPhysicalDeviceCopyMemoryIndirectFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectFeaturesNV( Bool32 indirectCopy_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , indirectCopy{ indirectCopy_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectFeaturesNV( PhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCopyMemoryIndirectFeaturesNV( VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCopyMemoryIndirectFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCopyMemoryIndirectFeaturesNV & operator=( PhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCopyMemoryIndirectFeaturesNV & operator=( VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesNV & setIndirectCopy( Bool32 indirectCopy_ ) & VULKAN_HPP_NOEXCEPT - { - indirectCopy = indirectCopy_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCopyMemoryIndirectFeaturesNV && setIndirectCopy( Bool32 indirectCopy_ ) && VULKAN_HPP_NOEXCEPT - { - indirectCopy = indirectCopy_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCopyMemoryIndirectFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCopyMemoryIndirectFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, indirectCopy ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCopyMemoryIndirectFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indirectCopy == rhs.indirectCopy ); -# endif - } - - bool operator!=( PhysicalDeviceCopyMemoryIndirectFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesNV; - void * pNext = {}; - Bool32 indirectCopy = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCopyMemoryIndirectFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCopyMemoryIndirectFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR.html - struct PhysicalDeviceCopyMemoryIndirectPropertiesKHR - { - using NativeType = VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCopyMemoryIndirectPropertiesKHR( QueueFlags supportedQueues_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , supportedQueues{ supportedQueues_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceCopyMemoryIndirectPropertiesKHR( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCopyMemoryIndirectPropertiesKHR( VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCopyMemoryIndirectPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCopyMemoryIndirectPropertiesKHR & operator=( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCopyMemoryIndirectPropertiesKHR & operator=( VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, supportedQueues ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedQueues == rhs.supportedQueues ); -# endif - } - - bool operator!=( PhysicalDeviceCopyMemoryIndirectPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesKHR; - void * pNext = {}; - QueueFlags supportedQueues = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCopyMemoryIndirectPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCopyMemoryIndirectPropertiesKHR; - }; - - using PhysicalDeviceCopyMemoryIndirectPropertiesNV = PhysicalDeviceCopyMemoryIndirectPropertiesKHR; - - // wrapper struct for struct VkPhysicalDeviceCornerSampledImageFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCornerSampledImageFeaturesNV.html - struct PhysicalDeviceCornerSampledImageFeaturesNV - { - using NativeType = VkPhysicalDeviceCornerSampledImageFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( Bool32 cornerSampledImage_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cornerSampledImage{ cornerSampledImage_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCornerSampledImageFeaturesNV( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCornerSampledImageFeaturesNV( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCornerSampledImageFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCornerSampledImageFeaturesNV & operator=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCornerSampledImageFeaturesNV & operator=( VkPhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCornerSampledImageFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCornerSampledImageFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCornerSampledImageFeaturesNV & setCornerSampledImage( Bool32 cornerSampledImage_ ) & VULKAN_HPP_NOEXCEPT - { - cornerSampledImage = cornerSampledImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCornerSampledImageFeaturesNV && setCornerSampledImage( Bool32 cornerSampledImage_ ) && VULKAN_HPP_NOEXCEPT - { - cornerSampledImage = cornerSampledImage_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCornerSampledImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCornerSampledImageFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCornerSampledImageFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCornerSampledImageFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, cornerSampledImage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCornerSampledImageFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cornerSampledImage == rhs.cornerSampledImage ); -# endif - } - - bool operator!=( PhysicalDeviceCornerSampledImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV; - void * pNext = {}; - Bool32 cornerSampledImage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCornerSampledImageFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCornerSampledImageFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceCoverageReductionModeFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCoverageReductionModeFeaturesNV.html - struct PhysicalDeviceCoverageReductionModeFeaturesNV - { - using NativeType = VkPhysicalDeviceCoverageReductionModeFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCoverageReductionModeFeaturesNV( Bool32 coverageReductionMode_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , coverageReductionMode{ coverageReductionMode_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceCoverageReductionModeFeaturesNV( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCoverageReductionModeFeaturesNV( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCoverageReductionModeFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCoverageReductionModeFeaturesNV & operator=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCoverageReductionModeFeaturesNV & operator=( VkPhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoverageReductionModeFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoverageReductionModeFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoverageReductionModeFeaturesNV & setCoverageReductionMode( Bool32 coverageReductionMode_ ) & VULKAN_HPP_NOEXCEPT - { - coverageReductionMode = coverageReductionMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCoverageReductionModeFeaturesNV && setCoverageReductionMode( Bool32 coverageReductionMode_ ) && VULKAN_HPP_NOEXCEPT - { - coverageReductionMode = coverageReductionMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCoverageReductionModeFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCoverageReductionModeFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCoverageReductionModeFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, coverageReductionMode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCoverageReductionModeFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( coverageReductionMode == rhs.coverageReductionMode ); -# endif - } - - bool operator!=( PhysicalDeviceCoverageReductionModeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV; - void * pNext = {}; - Bool32 coverageReductionMode = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCoverageReductionModeFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCoverageReductionModeFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceCubicClampFeaturesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCubicClampFeaturesQCOM.html - struct PhysicalDeviceCubicClampFeaturesQCOM - { - using NativeType = VkPhysicalDeviceCubicClampFeaturesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCubicClampFeaturesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCubicClampFeaturesQCOM( Bool32 cubicRangeClamp_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cubicRangeClamp{ cubicRangeClamp_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCubicClampFeaturesQCOM( PhysicalDeviceCubicClampFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCubicClampFeaturesQCOM( VkPhysicalDeviceCubicClampFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCubicClampFeaturesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCubicClampFeaturesQCOM & operator=( PhysicalDeviceCubicClampFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCubicClampFeaturesQCOM & operator=( VkPhysicalDeviceCubicClampFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicClampFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicClampFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicClampFeaturesQCOM & setCubicRangeClamp( Bool32 cubicRangeClamp_ ) & VULKAN_HPP_NOEXCEPT - { - cubicRangeClamp = cubicRangeClamp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicClampFeaturesQCOM && setCubicRangeClamp( Bool32 cubicRangeClamp_ ) && VULKAN_HPP_NOEXCEPT - { - cubicRangeClamp = cubicRangeClamp_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCubicClampFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCubicClampFeaturesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCubicClampFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCubicClampFeaturesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, cubicRangeClamp ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCubicClampFeaturesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceCubicClampFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cubicRangeClamp == rhs.cubicRangeClamp ); -# endif - } - - bool operator!=( PhysicalDeviceCubicClampFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCubicClampFeaturesQCOM; - void * pNext = {}; - Bool32 cubicRangeClamp = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCubicClampFeaturesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCubicClampFeaturesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceCubicWeightsFeaturesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCubicWeightsFeaturesQCOM.html - struct PhysicalDeviceCubicWeightsFeaturesQCOM - { - using NativeType = VkPhysicalDeviceCubicWeightsFeaturesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCubicWeightsFeaturesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCubicWeightsFeaturesQCOM( Bool32 selectableCubicWeights_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , selectableCubicWeights{ selectableCubicWeights_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCubicWeightsFeaturesQCOM( PhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCubicWeightsFeaturesQCOM( VkPhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCubicWeightsFeaturesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCubicWeightsFeaturesQCOM & operator=( PhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCubicWeightsFeaturesQCOM & operator=( VkPhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicWeightsFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicWeightsFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicWeightsFeaturesQCOM & setSelectableCubicWeights( Bool32 selectableCubicWeights_ ) & VULKAN_HPP_NOEXCEPT - { - selectableCubicWeights = selectableCubicWeights_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCubicWeightsFeaturesQCOM && setSelectableCubicWeights( Bool32 selectableCubicWeights_ ) && VULKAN_HPP_NOEXCEPT - { - selectableCubicWeights = selectableCubicWeights_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCubicWeightsFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCubicWeightsFeaturesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCubicWeightsFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCubicWeightsFeaturesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, selectableCubicWeights ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCubicWeightsFeaturesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( selectableCubicWeights == rhs.selectableCubicWeights ); -# endif - } - - bool operator!=( PhysicalDeviceCubicWeightsFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCubicWeightsFeaturesQCOM; - void * pNext = {}; - Bool32 selectableCubicWeights = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCubicWeightsFeaturesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCubicWeightsFeaturesQCOM; - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCudaKernelLaunchFeaturesNV.html - struct PhysicalDeviceCudaKernelLaunchFeaturesNV - { - using NativeType = VkPhysicalDeviceCudaKernelLaunchFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCudaKernelLaunchFeaturesNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCudaKernelLaunchFeaturesNV( Bool32 cudaKernelLaunchFeatures_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cudaKernelLaunchFeatures{ cudaKernelLaunchFeatures_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCudaKernelLaunchFeaturesNV( PhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCudaKernelLaunchFeaturesNV( VkPhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCudaKernelLaunchFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCudaKernelLaunchFeaturesNV & operator=( PhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCudaKernelLaunchFeaturesNV & operator=( VkPhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCudaKernelLaunchFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCudaKernelLaunchFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCudaKernelLaunchFeaturesNV & setCudaKernelLaunchFeatures( Bool32 cudaKernelLaunchFeatures_ ) & VULKAN_HPP_NOEXCEPT - { - cudaKernelLaunchFeatures = cudaKernelLaunchFeatures_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCudaKernelLaunchFeaturesNV && setCudaKernelLaunchFeatures( Bool32 cudaKernelLaunchFeatures_ ) && VULKAN_HPP_NOEXCEPT - { - cudaKernelLaunchFeatures = cudaKernelLaunchFeatures_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCudaKernelLaunchFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCudaKernelLaunchFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCudaKernelLaunchFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCudaKernelLaunchFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, cudaKernelLaunchFeatures ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCudaKernelLaunchFeaturesNV const & ) const = default; -# else - bool operator==( PhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cudaKernelLaunchFeatures == rhs.cudaKernelLaunchFeatures ); -# endif - } - - bool operator!=( PhysicalDeviceCudaKernelLaunchFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCudaKernelLaunchFeaturesNV; - void * pNext = {}; - Bool32 cudaKernelLaunchFeatures = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCudaKernelLaunchFeaturesNV; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCudaKernelLaunchFeaturesNV; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCudaKernelLaunchPropertiesNV.html - struct PhysicalDeviceCudaKernelLaunchPropertiesNV - { - using NativeType = VkPhysicalDeviceCudaKernelLaunchPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCudaKernelLaunchPropertiesNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCudaKernelLaunchPropertiesNV( uint32_t computeCapabilityMinor_ = {}, - uint32_t computeCapabilityMajor_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , computeCapabilityMinor{ computeCapabilityMinor_ } - , computeCapabilityMajor{ computeCapabilityMajor_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCudaKernelLaunchPropertiesNV( PhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCudaKernelLaunchPropertiesNV( VkPhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCudaKernelLaunchPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCudaKernelLaunchPropertiesNV & operator=( PhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCudaKernelLaunchPropertiesNV & operator=( VkPhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceCudaKernelLaunchPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCudaKernelLaunchPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCudaKernelLaunchPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCudaKernelLaunchPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, computeCapabilityMinor, computeCapabilityMajor ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCudaKernelLaunchPropertiesNV const & ) const = default; -# else - bool operator==( PhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( computeCapabilityMinor == rhs.computeCapabilityMinor ) && - ( computeCapabilityMajor == rhs.computeCapabilityMajor ); -# endif - } - - bool operator!=( PhysicalDeviceCudaKernelLaunchPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCudaKernelLaunchPropertiesNV; - void * pNext = {}; - uint32_t computeCapabilityMinor = {}; - uint32_t computeCapabilityMajor = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCudaKernelLaunchPropertiesNV; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCudaKernelLaunchPropertiesNV; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkPhysicalDeviceCustomBorderColorFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCustomBorderColorFeaturesEXT.html - struct PhysicalDeviceCustomBorderColorFeaturesEXT - { - using NativeType = VkPhysicalDeviceCustomBorderColorFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomBorderColorFeaturesEXT( Bool32 customBorderColors_ = {}, - Bool32 customBorderColorWithoutFormat_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , customBorderColors{ customBorderColors_ } - , customBorderColorWithoutFormat{ customBorderColorWithoutFormat_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomBorderColorFeaturesEXT( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCustomBorderColorFeaturesEXT( VkPhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCustomBorderColorFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCustomBorderColorFeaturesEXT & operator=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCustomBorderColorFeaturesEXT & operator=( VkPhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT & setCustomBorderColors( Bool32 customBorderColors_ ) & VULKAN_HPP_NOEXCEPT - { - customBorderColors = customBorderColors_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT && setCustomBorderColors( Bool32 customBorderColors_ ) && VULKAN_HPP_NOEXCEPT - { - customBorderColors = customBorderColors_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT & setCustomBorderColorWithoutFormat( Bool32 customBorderColorWithoutFormat_ ) & - VULKAN_HPP_NOEXCEPT - { - customBorderColorWithoutFormat = customBorderColorWithoutFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomBorderColorFeaturesEXT && setCustomBorderColorWithoutFormat( Bool32 customBorderColorWithoutFormat_ ) && - VULKAN_HPP_NOEXCEPT - { - customBorderColorWithoutFormat = customBorderColorWithoutFormat_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCustomBorderColorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCustomBorderColorFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCustomBorderColorFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCustomBorderColorFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, customBorderColors, customBorderColorWithoutFormat ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCustomBorderColorFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customBorderColors == rhs.customBorderColors ) && - ( customBorderColorWithoutFormat == rhs.customBorderColorWithoutFormat ); -# endif - } - - bool operator!=( PhysicalDeviceCustomBorderColorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT; - void * pNext = {}; - Bool32 customBorderColors = {}; - Bool32 customBorderColorWithoutFormat = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCustomBorderColorFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCustomBorderColorFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceCustomBorderColorPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCustomBorderColorPropertiesEXT.html - struct PhysicalDeviceCustomBorderColorPropertiesEXT - { - using NativeType = VkPhysicalDeviceCustomBorderColorPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomBorderColorPropertiesEXT( uint32_t maxCustomBorderColorSamplers_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxCustomBorderColorSamplers{ maxCustomBorderColorSamplers_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomBorderColorPropertiesEXT( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCustomBorderColorPropertiesEXT( VkPhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCustomBorderColorPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCustomBorderColorPropertiesEXT & operator=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCustomBorderColorPropertiesEXT & operator=( VkPhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceCustomBorderColorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCustomBorderColorPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCustomBorderColorPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCustomBorderColorPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxCustomBorderColorSamplers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCustomBorderColorPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxCustomBorderColorSamplers == rhs.maxCustomBorderColorSamplers ); -# endif - } - - bool operator!=( PhysicalDeviceCustomBorderColorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT; - void * pNext = {}; - uint32_t maxCustomBorderColorSamplers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCustomBorderColorPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCustomBorderColorPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceCustomResolveFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceCustomResolveFeaturesEXT.html - struct PhysicalDeviceCustomResolveFeaturesEXT - { - using NativeType = VkPhysicalDeviceCustomResolveFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceCustomResolveFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomResolveFeaturesEXT( Bool32 customResolve_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , customResolve{ customResolve_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceCustomResolveFeaturesEXT( PhysicalDeviceCustomResolveFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceCustomResolveFeaturesEXT( VkPhysicalDeviceCustomResolveFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceCustomResolveFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceCustomResolveFeaturesEXT & operator=( PhysicalDeviceCustomResolveFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceCustomResolveFeaturesEXT & operator=( VkPhysicalDeviceCustomResolveFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomResolveFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomResolveFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomResolveFeaturesEXT & setCustomResolve( Bool32 customResolve_ ) & VULKAN_HPP_NOEXCEPT - { - customResolve = customResolve_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceCustomResolveFeaturesEXT && setCustomResolve( Bool32 customResolve_ ) && VULKAN_HPP_NOEXCEPT - { - customResolve = customResolve_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceCustomResolveFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCustomResolveFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCustomResolveFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceCustomResolveFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, customResolve ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceCustomResolveFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceCustomResolveFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( customResolve == rhs.customResolve ); -# endif - } - - bool operator!=( PhysicalDeviceCustomResolveFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceCustomResolveFeaturesEXT; - void * pNext = {}; - Bool32 customResolve = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceCustomResolveFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceCustomResolveFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDataGraphFeaturesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphFeaturesARM.html - struct PhysicalDeviceDataGraphFeaturesARM - { - using NativeType = VkPhysicalDeviceDataGraphFeaturesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDataGraphFeaturesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphFeaturesARM( Bool32 dataGraph_ = {}, - Bool32 dataGraphUpdateAfterBind_ = {}, - Bool32 dataGraphSpecializationConstants_ = {}, - Bool32 dataGraphDescriptorBuffer_ = {}, - Bool32 dataGraphShaderModule_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dataGraph{ dataGraph_ } - , dataGraphUpdateAfterBind{ dataGraphUpdateAfterBind_ } - , dataGraphSpecializationConstants{ dataGraphSpecializationConstants_ } - , dataGraphDescriptorBuffer{ dataGraphDescriptorBuffer_ } - , dataGraphShaderModule{ dataGraphShaderModule_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphFeaturesARM( PhysicalDeviceDataGraphFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDataGraphFeaturesARM( VkPhysicalDeviceDataGraphFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDataGraphFeaturesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDataGraphFeaturesARM & operator=( PhysicalDeviceDataGraphFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDataGraphFeaturesARM & operator=( VkPhysicalDeviceDataGraphFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setDataGraph( Bool32 dataGraph_ ) & VULKAN_HPP_NOEXCEPT - { - dataGraph = dataGraph_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setDataGraph( Bool32 dataGraph_ ) && VULKAN_HPP_NOEXCEPT - { - dataGraph = dataGraph_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setDataGraphUpdateAfterBind( Bool32 dataGraphUpdateAfterBind_ ) & VULKAN_HPP_NOEXCEPT - { - dataGraphUpdateAfterBind = dataGraphUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setDataGraphUpdateAfterBind( Bool32 dataGraphUpdateAfterBind_ ) && VULKAN_HPP_NOEXCEPT - { - dataGraphUpdateAfterBind = dataGraphUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setDataGraphSpecializationConstants( Bool32 dataGraphSpecializationConstants_ ) & - VULKAN_HPP_NOEXCEPT - { - dataGraphSpecializationConstants = dataGraphSpecializationConstants_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setDataGraphSpecializationConstants( Bool32 dataGraphSpecializationConstants_ ) && - VULKAN_HPP_NOEXCEPT - { - dataGraphSpecializationConstants = dataGraphSpecializationConstants_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setDataGraphDescriptorBuffer( Bool32 dataGraphDescriptorBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - dataGraphDescriptorBuffer = dataGraphDescriptorBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setDataGraphDescriptorBuffer( Bool32 dataGraphDescriptorBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - dataGraphDescriptorBuffer = dataGraphDescriptorBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM & setDataGraphShaderModule( Bool32 dataGraphShaderModule_ ) & VULKAN_HPP_NOEXCEPT - { - dataGraphShaderModule = dataGraphShaderModule_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphFeaturesARM && setDataGraphShaderModule( Bool32 dataGraphShaderModule_ ) && VULKAN_HPP_NOEXCEPT - { - dataGraphShaderModule = dataGraphShaderModule_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDataGraphFeaturesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphFeaturesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphFeaturesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphFeaturesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dataGraph, dataGraphUpdateAfterBind, dataGraphSpecializationConstants, dataGraphDescriptorBuffer, dataGraphShaderModule ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDataGraphFeaturesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceDataGraphFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataGraph == rhs.dataGraph ) && - ( dataGraphUpdateAfterBind == rhs.dataGraphUpdateAfterBind ) && ( dataGraphSpecializationConstants == rhs.dataGraphSpecializationConstants ) && - ( dataGraphDescriptorBuffer == rhs.dataGraphDescriptorBuffer ) && ( dataGraphShaderModule == rhs.dataGraphShaderModule ); -# endif - } - - bool operator!=( PhysicalDeviceDataGraphFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDataGraphFeaturesARM; - void * pNext = {}; - Bool32 dataGraph = {}; - Bool32 dataGraphUpdateAfterBind = {}; - Bool32 dataGraphSpecializationConstants = {}; - Bool32 dataGraphDescriptorBuffer = {}; - Bool32 dataGraphShaderModule = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDataGraphFeaturesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDataGraphFeaturesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceDataGraphModelFeaturesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDataGraphModelFeaturesQCOM.html - struct PhysicalDeviceDataGraphModelFeaturesQCOM - { - using NativeType = VkPhysicalDeviceDataGraphModelFeaturesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphModelFeaturesQCOM( Bool32 dataGraphModel_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dataGraphModel{ dataGraphModel_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDataGraphModelFeaturesQCOM( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDataGraphModelFeaturesQCOM( VkPhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDataGraphModelFeaturesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDataGraphModelFeaturesQCOM & operator=( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDataGraphModelFeaturesQCOM & operator=( VkPhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM & setDataGraphModel( Bool32 dataGraphModel_ ) & VULKAN_HPP_NOEXCEPT - { - dataGraphModel = dataGraphModel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDataGraphModelFeaturesQCOM && setDataGraphModel( Bool32 dataGraphModel_ ) && VULKAN_HPP_NOEXCEPT - { - dataGraphModel = dataGraphModel_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDataGraphModelFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphModelFeaturesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphModelFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDataGraphModelFeaturesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dataGraphModel ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDataGraphModelFeaturesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataGraphModel == rhs.dataGraphModel ); -# endif - } - - bool operator!=( PhysicalDeviceDataGraphModelFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM; - void * pNext = {}; - Bool32 dataGraphModel = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDataGraphModelFeaturesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDataGraphModelFeaturesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.html - struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV - { - using NativeType = VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( Bool32 dedicatedAllocationImageAliasing_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dedicatedAllocationImageAliasing{ dedicatedAllocationImageAliasing_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & - operator=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & - operator=( VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV & - setDedicatedAllocationImageAliasing( Bool32 dedicatedAllocationImageAliasing_ ) & - VULKAN_HPP_NOEXCEPT - { - dedicatedAllocationImageAliasing = dedicatedAllocationImageAliasing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV && - setDedicatedAllocationImageAliasing( Bool32 dedicatedAllocationImageAliasing_ ) && - VULKAN_HPP_NOEXCEPT - { - dedicatedAllocationImageAliasing = dedicatedAllocationImageAliasing_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dedicatedAllocationImageAliasing ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dedicatedAllocationImageAliasing == rhs.dedicatedAllocationImageAliasing ); -# endif - } - - bool operator!=( PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - void * pNext = {}; - Bool32 dedicatedAllocationImageAliasing = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX.html - struct PhysicalDeviceDenseGeometryFormatFeaturesAMDX - { - using NativeType = VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDenseGeometryFormatFeaturesAMDX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDenseGeometryFormatFeaturesAMDX( Bool32 denseGeometryFormat_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , denseGeometryFormat{ denseGeometryFormat_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDenseGeometryFormatFeaturesAMDX( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDenseGeometryFormatFeaturesAMDX( VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDenseGeometryFormatFeaturesAMDX( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDenseGeometryFormatFeaturesAMDX & operator=( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDenseGeometryFormatFeaturesAMDX & operator=( VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDenseGeometryFormatFeaturesAMDX & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDenseGeometryFormatFeaturesAMDX && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDenseGeometryFormatFeaturesAMDX & setDenseGeometryFormat( Bool32 denseGeometryFormat_ ) & VULKAN_HPP_NOEXCEPT - { - denseGeometryFormat = denseGeometryFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDenseGeometryFormatFeaturesAMDX && setDenseGeometryFormat( Bool32 denseGeometryFormat_ ) && VULKAN_HPP_NOEXCEPT - { - denseGeometryFormat = denseGeometryFormat_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDenseGeometryFormatFeaturesAMDX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, denseGeometryFormat ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & ) const = default; -# else - bool operator==( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( denseGeometryFormat == rhs.denseGeometryFormat ); -# endif - } - - bool operator!=( PhysicalDeviceDenseGeometryFormatFeaturesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDenseGeometryFormatFeaturesAMDX; - void * pNext = {}; - Bool32 denseGeometryFormat = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDenseGeometryFormatFeaturesAMDX; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDenseGeometryFormatFeaturesAMDX; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkPhysicalDeviceDepthBiasControlFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthBiasControlFeaturesEXT.html - struct PhysicalDeviceDepthBiasControlFeaturesEXT - { - using NativeType = VkPhysicalDeviceDepthBiasControlFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthBiasControlFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthBiasControlFeaturesEXT( Bool32 depthBiasControl_ = {}, - Bool32 leastRepresentableValueForceUnormRepresentation_ = {}, - Bool32 floatRepresentation_ = {}, - Bool32 depthBiasExact_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , depthBiasControl{ depthBiasControl_ } - , leastRepresentableValueForceUnormRepresentation{ leastRepresentableValueForceUnormRepresentation_ } - , floatRepresentation{ floatRepresentation_ } - , depthBiasExact{ depthBiasExact_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthBiasControlFeaturesEXT( PhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDepthBiasControlFeaturesEXT( VkPhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDepthBiasControlFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDepthBiasControlFeaturesEXT & operator=( PhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDepthBiasControlFeaturesEXT & operator=( VkPhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT & setDepthBiasControl( Bool32 depthBiasControl_ ) & VULKAN_HPP_NOEXCEPT - { - depthBiasControl = depthBiasControl_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT && setDepthBiasControl( Bool32 depthBiasControl_ ) && VULKAN_HPP_NOEXCEPT - { - depthBiasControl = depthBiasControl_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT & - setLeastRepresentableValueForceUnormRepresentation( Bool32 leastRepresentableValueForceUnormRepresentation_ ) & - VULKAN_HPP_NOEXCEPT - { - leastRepresentableValueForceUnormRepresentation = leastRepresentableValueForceUnormRepresentation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT && - setLeastRepresentableValueForceUnormRepresentation( Bool32 leastRepresentableValueForceUnormRepresentation_ ) && - VULKAN_HPP_NOEXCEPT - { - leastRepresentableValueForceUnormRepresentation = leastRepresentableValueForceUnormRepresentation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT & setFloatRepresentation( Bool32 floatRepresentation_ ) & VULKAN_HPP_NOEXCEPT - { - floatRepresentation = floatRepresentation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT && setFloatRepresentation( Bool32 floatRepresentation_ ) && VULKAN_HPP_NOEXCEPT - { - floatRepresentation = floatRepresentation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT & setDepthBiasExact( Bool32 depthBiasExact_ ) & VULKAN_HPP_NOEXCEPT - { - depthBiasExact = depthBiasExact_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthBiasControlFeaturesEXT && setDepthBiasExact( Bool32 depthBiasExact_ ) && VULKAN_HPP_NOEXCEPT - { - depthBiasExact = depthBiasExact_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDepthBiasControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthBiasControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthBiasControlFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthBiasControlFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, depthBiasControl, leastRepresentableValueForceUnormRepresentation, floatRepresentation, depthBiasExact ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDepthBiasControlFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthBiasControl == rhs.depthBiasControl ) && - ( leastRepresentableValueForceUnormRepresentation == rhs.leastRepresentableValueForceUnormRepresentation ) && - ( floatRepresentation == rhs.floatRepresentation ) && ( depthBiasExact == rhs.depthBiasExact ); -# endif - } - - bool operator!=( PhysicalDeviceDepthBiasControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDepthBiasControlFeaturesEXT; - void * pNext = {}; - Bool32 depthBiasControl = {}; - Bool32 leastRepresentableValueForceUnormRepresentation = {}; - Bool32 floatRepresentation = {}; - Bool32 depthBiasExact = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDepthBiasControlFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDepthBiasControlFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDepthClampControlFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClampControlFeaturesEXT.html - struct PhysicalDeviceDepthClampControlFeaturesEXT - { - using NativeType = VkPhysicalDeviceDepthClampControlFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampControlFeaturesEXT( Bool32 depthClampControl_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , depthClampControl{ depthClampControl_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampControlFeaturesEXT( PhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDepthClampControlFeaturesEXT( VkPhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDepthClampControlFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDepthClampControlFeaturesEXT & operator=( PhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDepthClampControlFeaturesEXT & operator=( VkPhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampControlFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampControlFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampControlFeaturesEXT & setDepthClampControl( Bool32 depthClampControl_ ) & VULKAN_HPP_NOEXCEPT - { - depthClampControl = depthClampControl_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampControlFeaturesEXT && setDepthClampControl( Bool32 depthClampControl_ ) && VULKAN_HPP_NOEXCEPT - { - depthClampControl = depthClampControl_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDepthClampControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClampControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClampControlFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClampControlFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, depthClampControl ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDepthClampControlFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClampControl == rhs.depthClampControl ); -# endif - } - - bool operator!=( PhysicalDeviceDepthClampControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT; - void * pNext = {}; - Bool32 depthClampControl = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDepthClampControlFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDepthClampControlFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.html - struct PhysicalDeviceDepthClampZeroOneFeaturesKHR - { - using NativeType = VkPhysicalDeviceDepthClampZeroOneFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampZeroOneFeaturesKHR( Bool32 depthClampZeroOne_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , depthClampZeroOne{ depthClampZeroOne_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClampZeroOneFeaturesKHR( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDepthClampZeroOneFeaturesKHR( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDepthClampZeroOneFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDepthClampZeroOneFeaturesKHR & operator=( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDepthClampZeroOneFeaturesKHR & operator=( VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesKHR & setDepthClampZeroOne( Bool32 depthClampZeroOne_ ) & VULKAN_HPP_NOEXCEPT - { - depthClampZeroOne = depthClampZeroOne_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClampZeroOneFeaturesKHR && setDepthClampZeroOne( Bool32 depthClampZeroOne_ ) && VULKAN_HPP_NOEXCEPT - { - depthClampZeroOne = depthClampZeroOne_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClampZeroOneFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClampZeroOneFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, depthClampZeroOne ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClampZeroOne == rhs.depthClampZeroOne ); -# endif - } - - bool operator!=( PhysicalDeviceDepthClampZeroOneFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR; - void * pNext = {}; - Bool32 depthClampZeroOne = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDepthClampZeroOneFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDepthClampZeroOneFeaturesKHR; - }; - - using PhysicalDeviceDepthClampZeroOneFeaturesEXT = PhysicalDeviceDepthClampZeroOneFeaturesKHR; - - // wrapper struct for struct VkPhysicalDeviceDepthClipControlFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClipControlFeaturesEXT.html - struct PhysicalDeviceDepthClipControlFeaturesEXT - { - using NativeType = VkPhysicalDeviceDepthClipControlFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClipControlFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipControlFeaturesEXT( Bool32 depthClipControl_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , depthClipControl{ depthClipControl_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipControlFeaturesEXT( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDepthClipControlFeaturesEXT( VkPhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDepthClipControlFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDepthClipControlFeaturesEXT & operator=( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDepthClipControlFeaturesEXT & operator=( VkPhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipControlFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipControlFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipControlFeaturesEXT & setDepthClipControl( Bool32 depthClipControl_ ) & VULKAN_HPP_NOEXCEPT - { - depthClipControl = depthClipControl_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipControlFeaturesEXT && setDepthClipControl( Bool32 depthClipControl_ ) && VULKAN_HPP_NOEXCEPT - { - depthClipControl = depthClipControl_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDepthClipControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClipControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClipControlFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClipControlFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, depthClipControl ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDepthClipControlFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipControl == rhs.depthClipControl ); -# endif - } - - bool operator!=( PhysicalDeviceDepthClipControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDepthClipControlFeaturesEXT; - void * pNext = {}; - Bool32 depthClipControl = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDepthClipControlFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDepthClipControlFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDepthClipEnableFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthClipEnableFeaturesEXT.html - struct PhysicalDeviceDepthClipEnableFeaturesEXT - { - using NativeType = VkPhysicalDeviceDepthClipEnableFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( Bool32 depthClipEnable_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , depthClipEnable{ depthClipEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthClipEnableFeaturesEXT( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDepthClipEnableFeaturesEXT( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDepthClipEnableFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDepthClipEnableFeaturesEXT & operator=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDepthClipEnableFeaturesEXT & operator=( VkPhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipEnableFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipEnableFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipEnableFeaturesEXT & setDepthClipEnable( Bool32 depthClipEnable_ ) & VULKAN_HPP_NOEXCEPT - { - depthClipEnable = depthClipEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDepthClipEnableFeaturesEXT && setDepthClipEnable( Bool32 depthClipEnable_ ) && VULKAN_HPP_NOEXCEPT - { - depthClipEnable = depthClipEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClipEnableFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClipEnableFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthClipEnableFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, depthClipEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDepthClipEnableFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClipEnable == rhs.depthClipEnable ); -# endif - } - - bool operator!=( PhysicalDeviceDepthClipEnableFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT; - void * pNext = {}; - Bool32 depthClipEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDepthClipEnableFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDepthClipEnableFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDepthStencilResolveProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDepthStencilResolveProperties.html - struct PhysicalDeviceDepthStencilResolveProperties - { - using NativeType = VkPhysicalDeviceDepthStencilResolveProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDepthStencilResolveProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthStencilResolveProperties( ResolveModeFlags supportedDepthResolveModes_ = {}, - ResolveModeFlags supportedStencilResolveModes_ = {}, - Bool32 independentResolveNone_ = {}, - Bool32 independentResolve_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , supportedDepthResolveModes{ supportedDepthResolveModes_ } - , supportedStencilResolveModes{ supportedStencilResolveModes_ } - , independentResolveNone{ independentResolveNone_ } - , independentResolve{ independentResolve_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDepthStencilResolveProperties( PhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDepthStencilResolveProperties( VkPhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDepthStencilResolveProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDepthStencilResolveProperties & operator=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDepthStencilResolveProperties & operator=( VkPhysicalDeviceDepthStencilResolveProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDepthStencilResolveProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthStencilResolveProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthStencilResolveProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDepthStencilResolveProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, supportedDepthResolveModes, supportedStencilResolveModes, independentResolveNone, independentResolve ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDepthStencilResolveProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) && - ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) && ( independentResolveNone == rhs.independentResolveNone ) && - ( independentResolve == rhs.independentResolve ); -# endif - } - - bool operator!=( PhysicalDeviceDepthStencilResolveProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDepthStencilResolveProperties; - void * pNext = {}; - ResolveModeFlags supportedDepthResolveModes = {}; - ResolveModeFlags supportedStencilResolveModes = {}; - Bool32 independentResolveNone = {}; - Bool32 independentResolve = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDepthStencilResolveProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDepthStencilResolveProperties; - }; - - using PhysicalDeviceDepthStencilResolvePropertiesKHR = PhysicalDeviceDepthStencilResolveProperties; - - // wrapper struct for struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.html - struct PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT - { - using NativeType = VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( size_t combinedImageSamplerDensityMapDescriptorSize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , combinedImageSamplerDensityMapDescriptorSize{ combinedImageSamplerDensityMapDescriptorSize_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT & - operator=( PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT & operator=( VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, combinedImageSamplerDensityMapDescriptorSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( combinedImageSamplerDensityMapDescriptorSize == rhs.combinedImageSamplerDensityMapDescriptorSize ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; - void * pNext = {}; - size_t combinedImageSamplerDensityMapDescriptorSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDescriptorBufferFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferFeaturesEXT.html - struct PhysicalDeviceDescriptorBufferFeaturesEXT - { - using NativeType = VkPhysicalDeviceDescriptorBufferFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorBufferFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferFeaturesEXT( Bool32 descriptorBuffer_ = {}, - Bool32 descriptorBufferCaptureReplay_ = {}, - Bool32 descriptorBufferImageLayoutIgnored_ = {}, - Bool32 descriptorBufferPushDescriptors_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorBuffer{ descriptorBuffer_ } - , descriptorBufferCaptureReplay{ descriptorBufferCaptureReplay_ } - , descriptorBufferImageLayoutIgnored{ descriptorBufferImageLayoutIgnored_ } - , descriptorBufferPushDescriptors{ descriptorBufferPushDescriptors_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferFeaturesEXT( PhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorBufferFeaturesEXT( VkPhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorBufferFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorBufferFeaturesEXT & operator=( PhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorBufferFeaturesEXT & operator=( VkPhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT & setDescriptorBuffer( Bool32 descriptorBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorBuffer = descriptorBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT && setDescriptorBuffer( Bool32 descriptorBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorBuffer = descriptorBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT & setDescriptorBufferCaptureReplay( Bool32 descriptorBufferCaptureReplay_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBufferCaptureReplay = descriptorBufferCaptureReplay_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT && setDescriptorBufferCaptureReplay( Bool32 descriptorBufferCaptureReplay_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBufferCaptureReplay = descriptorBufferCaptureReplay_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT & setDescriptorBufferImageLayoutIgnored( Bool32 descriptorBufferImageLayoutIgnored_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBufferImageLayoutIgnored = descriptorBufferImageLayoutIgnored_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT && setDescriptorBufferImageLayoutIgnored( Bool32 descriptorBufferImageLayoutIgnored_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBufferImageLayoutIgnored = descriptorBufferImageLayoutIgnored_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT & setDescriptorBufferPushDescriptors( Bool32 descriptorBufferPushDescriptors_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBufferPushDescriptors = descriptorBufferPushDescriptors_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferFeaturesEXT && setDescriptorBufferPushDescriptors( Bool32 descriptorBufferPushDescriptors_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBufferPushDescriptors = descriptorBufferPushDescriptors_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDescriptorBufferFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorBuffer, descriptorBufferCaptureReplay, descriptorBufferImageLayoutIgnored, descriptorBufferPushDescriptors ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorBufferFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorBuffer == rhs.descriptorBuffer ) && - ( descriptorBufferCaptureReplay == rhs.descriptorBufferCaptureReplay ) && - ( descriptorBufferImageLayoutIgnored == rhs.descriptorBufferImageLayoutIgnored ) && - ( descriptorBufferPushDescriptors == rhs.descriptorBufferPushDescriptors ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorBufferFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorBufferFeaturesEXT; - void * pNext = {}; - Bool32 descriptorBuffer = {}; - Bool32 descriptorBufferCaptureReplay = {}; - Bool32 descriptorBufferImageLayoutIgnored = {}; - Bool32 descriptorBufferPushDescriptors = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorBufferFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorBufferFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDescriptorBufferPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferPropertiesEXT.html - struct PhysicalDeviceDescriptorBufferPropertiesEXT - { - using NativeType = VkPhysicalDeviceDescriptorBufferPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorBufferPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferPropertiesEXT( Bool32 combinedImageSamplerDescriptorSingleArray_ = {}, - Bool32 bufferlessPushDescriptors_ = {}, - Bool32 allowSamplerImageViewPostSubmitCreation_ = {}, - DeviceSize descriptorBufferOffsetAlignment_ = {}, - uint32_t maxDescriptorBufferBindings_ = {}, - uint32_t maxResourceDescriptorBufferBindings_ = {}, - uint32_t maxSamplerDescriptorBufferBindings_ = {}, - uint32_t maxEmbeddedImmutableSamplerBindings_ = {}, - uint32_t maxEmbeddedImmutableSamplers_ = {}, - size_t bufferCaptureReplayDescriptorDataSize_ = {}, - size_t imageCaptureReplayDescriptorDataSize_ = {}, - size_t imageViewCaptureReplayDescriptorDataSize_ = {}, - size_t samplerCaptureReplayDescriptorDataSize_ = {}, - size_t accelerationStructureCaptureReplayDescriptorDataSize_ = {}, - size_t samplerDescriptorSize_ = {}, - size_t combinedImageSamplerDescriptorSize_ = {}, - size_t sampledImageDescriptorSize_ = {}, - size_t storageImageDescriptorSize_ = {}, - size_t uniformTexelBufferDescriptorSize_ = {}, - size_t robustUniformTexelBufferDescriptorSize_ = {}, - size_t storageTexelBufferDescriptorSize_ = {}, - size_t robustStorageTexelBufferDescriptorSize_ = {}, - size_t uniformBufferDescriptorSize_ = {}, - size_t robustUniformBufferDescriptorSize_ = {}, - size_t storageBufferDescriptorSize_ = {}, - size_t robustStorageBufferDescriptorSize_ = {}, - size_t inputAttachmentDescriptorSize_ = {}, - size_t accelerationStructureDescriptorSize_ = {}, - DeviceSize maxSamplerDescriptorBufferRange_ = {}, - DeviceSize maxResourceDescriptorBufferRange_ = {}, - DeviceSize samplerDescriptorBufferAddressSpaceSize_ = {}, - DeviceSize resourceDescriptorBufferAddressSpaceSize_ = {}, - DeviceSize descriptorBufferAddressSpaceSize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , combinedImageSamplerDescriptorSingleArray{ combinedImageSamplerDescriptorSingleArray_ } - , bufferlessPushDescriptors{ bufferlessPushDescriptors_ } - , allowSamplerImageViewPostSubmitCreation{ allowSamplerImageViewPostSubmitCreation_ } - , descriptorBufferOffsetAlignment{ descriptorBufferOffsetAlignment_ } - , maxDescriptorBufferBindings{ maxDescriptorBufferBindings_ } - , maxResourceDescriptorBufferBindings{ maxResourceDescriptorBufferBindings_ } - , maxSamplerDescriptorBufferBindings{ maxSamplerDescriptorBufferBindings_ } - , maxEmbeddedImmutableSamplerBindings{ maxEmbeddedImmutableSamplerBindings_ } - , maxEmbeddedImmutableSamplers{ maxEmbeddedImmutableSamplers_ } - , bufferCaptureReplayDescriptorDataSize{ bufferCaptureReplayDescriptorDataSize_ } - , imageCaptureReplayDescriptorDataSize{ imageCaptureReplayDescriptorDataSize_ } - , imageViewCaptureReplayDescriptorDataSize{ imageViewCaptureReplayDescriptorDataSize_ } - , samplerCaptureReplayDescriptorDataSize{ samplerCaptureReplayDescriptorDataSize_ } - , accelerationStructureCaptureReplayDescriptorDataSize{ accelerationStructureCaptureReplayDescriptorDataSize_ } - , samplerDescriptorSize{ samplerDescriptorSize_ } - , combinedImageSamplerDescriptorSize{ combinedImageSamplerDescriptorSize_ } - , sampledImageDescriptorSize{ sampledImageDescriptorSize_ } - , storageImageDescriptorSize{ storageImageDescriptorSize_ } - , uniformTexelBufferDescriptorSize{ uniformTexelBufferDescriptorSize_ } - , robustUniformTexelBufferDescriptorSize{ robustUniformTexelBufferDescriptorSize_ } - , storageTexelBufferDescriptorSize{ storageTexelBufferDescriptorSize_ } - , robustStorageTexelBufferDescriptorSize{ robustStorageTexelBufferDescriptorSize_ } - , uniformBufferDescriptorSize{ uniformBufferDescriptorSize_ } - , robustUniformBufferDescriptorSize{ robustUniformBufferDescriptorSize_ } - , storageBufferDescriptorSize{ storageBufferDescriptorSize_ } - , robustStorageBufferDescriptorSize{ robustStorageBufferDescriptorSize_ } - , inputAttachmentDescriptorSize{ inputAttachmentDescriptorSize_ } - , accelerationStructureDescriptorSize{ accelerationStructureDescriptorSize_ } - , maxSamplerDescriptorBufferRange{ maxSamplerDescriptorBufferRange_ } - , maxResourceDescriptorBufferRange{ maxResourceDescriptorBufferRange_ } - , samplerDescriptorBufferAddressSpaceSize{ samplerDescriptorBufferAddressSpaceSize_ } - , resourceDescriptorBufferAddressSpaceSize{ resourceDescriptorBufferAddressSpaceSize_ } - , descriptorBufferAddressSpaceSize{ descriptorBufferAddressSpaceSize_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferPropertiesEXT( PhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorBufferPropertiesEXT( VkPhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorBufferPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorBufferPropertiesEXT & operator=( PhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorBufferPropertiesEXT & operator=( VkPhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDescriptorBufferPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - combinedImageSamplerDescriptorSingleArray, - bufferlessPushDescriptors, - allowSamplerImageViewPostSubmitCreation, - descriptorBufferOffsetAlignment, - maxDescriptorBufferBindings, - maxResourceDescriptorBufferBindings, - maxSamplerDescriptorBufferBindings, - maxEmbeddedImmutableSamplerBindings, - maxEmbeddedImmutableSamplers, - bufferCaptureReplayDescriptorDataSize, - imageCaptureReplayDescriptorDataSize, - imageViewCaptureReplayDescriptorDataSize, - samplerCaptureReplayDescriptorDataSize, - accelerationStructureCaptureReplayDescriptorDataSize, - samplerDescriptorSize, - combinedImageSamplerDescriptorSize, - sampledImageDescriptorSize, - storageImageDescriptorSize, - uniformTexelBufferDescriptorSize, - robustUniformTexelBufferDescriptorSize, - storageTexelBufferDescriptorSize, - robustStorageTexelBufferDescriptorSize, - uniformBufferDescriptorSize, - robustUniformBufferDescriptorSize, - storageBufferDescriptorSize, - robustStorageBufferDescriptorSize, - inputAttachmentDescriptorSize, - accelerationStructureDescriptorSize, - maxSamplerDescriptorBufferRange, - maxResourceDescriptorBufferRange, - samplerDescriptorBufferAddressSpaceSize, - resourceDescriptorBufferAddressSpaceSize, - descriptorBufferAddressSpaceSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorBufferPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( combinedImageSamplerDescriptorSingleArray == rhs.combinedImageSamplerDescriptorSingleArray ) && - ( bufferlessPushDescriptors == rhs.bufferlessPushDescriptors ) && - ( allowSamplerImageViewPostSubmitCreation == rhs.allowSamplerImageViewPostSubmitCreation ) && - ( descriptorBufferOffsetAlignment == rhs.descriptorBufferOffsetAlignment ) && ( maxDescriptorBufferBindings == rhs.maxDescriptorBufferBindings ) && - ( maxResourceDescriptorBufferBindings == rhs.maxResourceDescriptorBufferBindings ) && - ( maxSamplerDescriptorBufferBindings == rhs.maxSamplerDescriptorBufferBindings ) && - ( maxEmbeddedImmutableSamplerBindings == rhs.maxEmbeddedImmutableSamplerBindings ) && - ( maxEmbeddedImmutableSamplers == rhs.maxEmbeddedImmutableSamplers ) && - ( bufferCaptureReplayDescriptorDataSize == rhs.bufferCaptureReplayDescriptorDataSize ) && - ( imageCaptureReplayDescriptorDataSize == rhs.imageCaptureReplayDescriptorDataSize ) && - ( imageViewCaptureReplayDescriptorDataSize == rhs.imageViewCaptureReplayDescriptorDataSize ) && - ( samplerCaptureReplayDescriptorDataSize == rhs.samplerCaptureReplayDescriptorDataSize ) && - ( accelerationStructureCaptureReplayDescriptorDataSize == rhs.accelerationStructureCaptureReplayDescriptorDataSize ) && - ( samplerDescriptorSize == rhs.samplerDescriptorSize ) && ( combinedImageSamplerDescriptorSize == rhs.combinedImageSamplerDescriptorSize ) && - ( sampledImageDescriptorSize == rhs.sampledImageDescriptorSize ) && ( storageImageDescriptorSize == rhs.storageImageDescriptorSize ) && - ( uniformTexelBufferDescriptorSize == rhs.uniformTexelBufferDescriptorSize ) && - ( robustUniformTexelBufferDescriptorSize == rhs.robustUniformTexelBufferDescriptorSize ) && - ( storageTexelBufferDescriptorSize == rhs.storageTexelBufferDescriptorSize ) && - ( robustStorageTexelBufferDescriptorSize == rhs.robustStorageTexelBufferDescriptorSize ) && - ( uniformBufferDescriptorSize == rhs.uniformBufferDescriptorSize ) && - ( robustUniformBufferDescriptorSize == rhs.robustUniformBufferDescriptorSize ) && - ( storageBufferDescriptorSize == rhs.storageBufferDescriptorSize ) && - ( robustStorageBufferDescriptorSize == rhs.robustStorageBufferDescriptorSize ) && - ( inputAttachmentDescriptorSize == rhs.inputAttachmentDescriptorSize ) && - ( accelerationStructureDescriptorSize == rhs.accelerationStructureDescriptorSize ) && - ( maxSamplerDescriptorBufferRange == rhs.maxSamplerDescriptorBufferRange ) && - ( maxResourceDescriptorBufferRange == rhs.maxResourceDescriptorBufferRange ) && - ( samplerDescriptorBufferAddressSpaceSize == rhs.samplerDescriptorBufferAddressSpaceSize ) && - ( resourceDescriptorBufferAddressSpaceSize == rhs.resourceDescriptorBufferAddressSpaceSize ) && - ( descriptorBufferAddressSpaceSize == rhs.descriptorBufferAddressSpaceSize ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorBufferPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorBufferPropertiesEXT; - void * pNext = {}; - Bool32 combinedImageSamplerDescriptorSingleArray = {}; - Bool32 bufferlessPushDescriptors = {}; - Bool32 allowSamplerImageViewPostSubmitCreation = {}; - DeviceSize descriptorBufferOffsetAlignment = {}; - uint32_t maxDescriptorBufferBindings = {}; - uint32_t maxResourceDescriptorBufferBindings = {}; - uint32_t maxSamplerDescriptorBufferBindings = {}; - uint32_t maxEmbeddedImmutableSamplerBindings = {}; - uint32_t maxEmbeddedImmutableSamplers = {}; - size_t bufferCaptureReplayDescriptorDataSize = {}; - size_t imageCaptureReplayDescriptorDataSize = {}; - size_t imageViewCaptureReplayDescriptorDataSize = {}; - size_t samplerCaptureReplayDescriptorDataSize = {}; - size_t accelerationStructureCaptureReplayDescriptorDataSize = {}; - size_t samplerDescriptorSize = {}; - size_t combinedImageSamplerDescriptorSize = {}; - size_t sampledImageDescriptorSize = {}; - size_t storageImageDescriptorSize = {}; - size_t uniformTexelBufferDescriptorSize = {}; - size_t robustUniformTexelBufferDescriptorSize = {}; - size_t storageTexelBufferDescriptorSize = {}; - size_t robustStorageTexelBufferDescriptorSize = {}; - size_t uniformBufferDescriptorSize = {}; - size_t robustUniformBufferDescriptorSize = {}; - size_t storageBufferDescriptorSize = {}; - size_t robustStorageBufferDescriptorSize = {}; - size_t inputAttachmentDescriptorSize = {}; - size_t accelerationStructureDescriptorSize = {}; - DeviceSize maxSamplerDescriptorBufferRange = {}; - DeviceSize maxResourceDescriptorBufferRange = {}; - DeviceSize samplerDescriptorBufferAddressSpaceSize = {}; - DeviceSize resourceDescriptorBufferAddressSpaceSize = {}; - DeviceSize descriptorBufferAddressSpaceSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorBufferPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorBufferPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferTensorFeaturesARM.html - struct PhysicalDeviceDescriptorBufferTensorFeaturesARM - { - using NativeType = VkPhysicalDeviceDescriptorBufferTensorFeaturesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorBufferTensorFeaturesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferTensorFeaturesARM( Bool32 descriptorBufferTensorDescriptors_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorBufferTensorDescriptors{ descriptorBufferTensorDescriptors_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDescriptorBufferTensorFeaturesARM( PhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorBufferTensorFeaturesARM( VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorBufferTensorFeaturesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorBufferTensorFeaturesARM & operator=( PhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorBufferTensorFeaturesARM & operator=( VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorFeaturesARM & - setDescriptorBufferTensorDescriptors( Bool32 descriptorBufferTensorDescriptors_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBufferTensorDescriptors = descriptorBufferTensorDescriptors_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorFeaturesARM && - setDescriptorBufferTensorDescriptors( Bool32 descriptorBufferTensorDescriptors_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBufferTensorDescriptors = descriptorBufferTensorDescriptors_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferTensorFeaturesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferTensorFeaturesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorBufferTensorDescriptors ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorBufferTensorFeaturesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorBufferTensorDescriptors == rhs.descriptorBufferTensorDescriptors ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorBufferTensorFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorBufferTensorFeaturesARM; - void * pNext = {}; - Bool32 descriptorBufferTensorDescriptors = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorBufferTensorFeaturesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorBufferTensorFeaturesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorBufferTensorPropertiesARM.html - struct PhysicalDeviceDescriptorBufferTensorPropertiesARM - { - using NativeType = VkPhysicalDeviceDescriptorBufferTensorPropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorBufferTensorPropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorBufferTensorPropertiesARM( size_t tensorCaptureReplayDescriptorDataSize_ = {}, - size_t tensorViewCaptureReplayDescriptorDataSize_ = {}, - size_t tensorDescriptorSize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensorCaptureReplayDescriptorDataSize{ tensorCaptureReplayDescriptorDataSize_ } - , tensorViewCaptureReplayDescriptorDataSize{ tensorViewCaptureReplayDescriptorDataSize_ } - , tensorDescriptorSize{ tensorDescriptorSize_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDescriptorBufferTensorPropertiesARM( PhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorBufferTensorPropertiesARM( VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorBufferTensorPropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorBufferTensorPropertiesARM & - operator=( PhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorBufferTensorPropertiesARM & operator=( VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM & - setTensorCaptureReplayDescriptorDataSize( size_t tensorCaptureReplayDescriptorDataSize_ ) & - VULKAN_HPP_NOEXCEPT - { - tensorCaptureReplayDescriptorDataSize = tensorCaptureReplayDescriptorDataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM && - setTensorCaptureReplayDescriptorDataSize( size_t tensorCaptureReplayDescriptorDataSize_ ) && - VULKAN_HPP_NOEXCEPT - { - tensorCaptureReplayDescriptorDataSize = tensorCaptureReplayDescriptorDataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM & - setTensorViewCaptureReplayDescriptorDataSize( size_t tensorViewCaptureReplayDescriptorDataSize_ ) & - VULKAN_HPP_NOEXCEPT - { - tensorViewCaptureReplayDescriptorDataSize = tensorViewCaptureReplayDescriptorDataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM && - setTensorViewCaptureReplayDescriptorDataSize( size_t tensorViewCaptureReplayDescriptorDataSize_ ) && - VULKAN_HPP_NOEXCEPT - { - tensorViewCaptureReplayDescriptorDataSize = tensorViewCaptureReplayDescriptorDataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM & setTensorDescriptorSize( size_t tensorDescriptorSize_ ) & VULKAN_HPP_NOEXCEPT - { - tensorDescriptorSize = tensorDescriptorSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorBufferTensorPropertiesARM && setTensorDescriptorSize( size_t tensorDescriptorSize_ ) && VULKAN_HPP_NOEXCEPT - { - tensorDescriptorSize = tensorDescriptorSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferTensorPropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferTensorPropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tensorCaptureReplayDescriptorDataSize, tensorViewCaptureReplayDescriptorDataSize, tensorDescriptorSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorBufferTensorPropertiesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorCaptureReplayDescriptorDataSize == rhs.tensorCaptureReplayDescriptorDataSize ) && - ( tensorViewCaptureReplayDescriptorDataSize == rhs.tensorViewCaptureReplayDescriptorDataSize ) && - ( tensorDescriptorSize == rhs.tensorDescriptorSize ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorBufferTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorBufferTensorPropertiesARM; - void * pNext = {}; - size_t tensorCaptureReplayDescriptorDataSize = {}; - size_t tensorViewCaptureReplayDescriptorDataSize = {}; - size_t tensorDescriptorSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorBufferTensorPropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorBufferTensorPropertiesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceDescriptorHeapFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorHeapFeaturesEXT.html - struct PhysicalDeviceDescriptorHeapFeaturesEXT - { - using NativeType = VkPhysicalDeviceDescriptorHeapFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorHeapFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorHeapFeaturesEXT( Bool32 descriptorHeap_ = {}, - Bool32 descriptorHeapCaptureReplay_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorHeap{ descriptorHeap_ } - , descriptorHeapCaptureReplay{ descriptorHeapCaptureReplay_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorHeapFeaturesEXT( PhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorHeapFeaturesEXT( VkPhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorHeapFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorHeapFeaturesEXT & operator=( PhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorHeapFeaturesEXT & operator=( VkPhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT & setDescriptorHeap( Bool32 descriptorHeap_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorHeap = descriptorHeap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT && setDescriptorHeap( Bool32 descriptorHeap_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorHeap = descriptorHeap_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT & setDescriptorHeapCaptureReplay( Bool32 descriptorHeapCaptureReplay_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorHeapCaptureReplay = descriptorHeapCaptureReplay_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorHeapFeaturesEXT && setDescriptorHeapCaptureReplay( Bool32 descriptorHeapCaptureReplay_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorHeapCaptureReplay = descriptorHeapCaptureReplay_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDescriptorHeapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorHeapFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorHeapFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorHeapFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorHeap, descriptorHeapCaptureReplay ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorHeapFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorHeap == rhs.descriptorHeap ) && - ( descriptorHeapCaptureReplay == rhs.descriptorHeapCaptureReplay ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorHeapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorHeapFeaturesEXT; - void * pNext = {}; - Bool32 descriptorHeap = {}; - Bool32 descriptorHeapCaptureReplay = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorHeapFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorHeapFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDescriptorHeapPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorHeapPropertiesEXT.html - struct PhysicalDeviceDescriptorHeapPropertiesEXT - { - using NativeType = VkPhysicalDeviceDescriptorHeapPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorHeapPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorHeapPropertiesEXT( DeviceSize samplerHeapAlignment_ = {}, - DeviceSize resourceHeapAlignment_ = {}, - DeviceSize maxSamplerHeapSize_ = {}, - DeviceSize maxResourceHeapSize_ = {}, - DeviceSize minSamplerHeapReservedRange_ = {}, - DeviceSize minSamplerHeapReservedRangeWithEmbedded_ = {}, - DeviceSize minResourceHeapReservedRange_ = {}, - DeviceSize samplerDescriptorSize_ = {}, - DeviceSize imageDescriptorSize_ = {}, - DeviceSize bufferDescriptorSize_ = {}, - DeviceSize samplerDescriptorAlignment_ = {}, - DeviceSize imageDescriptorAlignment_ = {}, - DeviceSize bufferDescriptorAlignment_ = {}, - DeviceSize maxPushDataSize_ = {}, - size_t imageCaptureReplayOpaqueDataSize_ = {}, - uint32_t maxDescriptorHeapEmbeddedSamplers_ = {}, - uint32_t samplerYcbcrConversionCount_ = {}, - Bool32 sparseDescriptorHeaps_ = {}, - Bool32 protectedDescriptorHeaps_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , samplerHeapAlignment{ samplerHeapAlignment_ } - , resourceHeapAlignment{ resourceHeapAlignment_ } - , maxSamplerHeapSize{ maxSamplerHeapSize_ } - , maxResourceHeapSize{ maxResourceHeapSize_ } - , minSamplerHeapReservedRange{ minSamplerHeapReservedRange_ } - , minSamplerHeapReservedRangeWithEmbedded{ minSamplerHeapReservedRangeWithEmbedded_ } - , minResourceHeapReservedRange{ minResourceHeapReservedRange_ } - , samplerDescriptorSize{ samplerDescriptorSize_ } - , imageDescriptorSize{ imageDescriptorSize_ } - , bufferDescriptorSize{ bufferDescriptorSize_ } - , samplerDescriptorAlignment{ samplerDescriptorAlignment_ } - , imageDescriptorAlignment{ imageDescriptorAlignment_ } - , bufferDescriptorAlignment{ bufferDescriptorAlignment_ } - , maxPushDataSize{ maxPushDataSize_ } - , imageCaptureReplayOpaqueDataSize{ imageCaptureReplayOpaqueDataSize_ } - , maxDescriptorHeapEmbeddedSamplers{ maxDescriptorHeapEmbeddedSamplers_ } - , samplerYcbcrConversionCount{ samplerYcbcrConversionCount_ } - , sparseDescriptorHeaps{ sparseDescriptorHeaps_ } - , protectedDescriptorHeaps{ protectedDescriptorHeaps_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorHeapPropertiesEXT( PhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorHeapPropertiesEXT( VkPhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorHeapPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorHeapPropertiesEXT & operator=( PhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorHeapPropertiesEXT & operator=( VkPhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDescriptorHeapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorHeapPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorHeapPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorHeapPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - samplerHeapAlignment, - resourceHeapAlignment, - maxSamplerHeapSize, - maxResourceHeapSize, - minSamplerHeapReservedRange, - minSamplerHeapReservedRangeWithEmbedded, - minResourceHeapReservedRange, - samplerDescriptorSize, - imageDescriptorSize, - bufferDescriptorSize, - samplerDescriptorAlignment, - imageDescriptorAlignment, - bufferDescriptorAlignment, - maxPushDataSize, - imageCaptureReplayOpaqueDataSize, - maxDescriptorHeapEmbeddedSamplers, - samplerYcbcrConversionCount, - sparseDescriptorHeaps, - protectedDescriptorHeaps ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorHeapPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( samplerHeapAlignment == rhs.samplerHeapAlignment ) && - ( resourceHeapAlignment == rhs.resourceHeapAlignment ) && ( maxSamplerHeapSize == rhs.maxSamplerHeapSize ) && - ( maxResourceHeapSize == rhs.maxResourceHeapSize ) && ( minSamplerHeapReservedRange == rhs.minSamplerHeapReservedRange ) && - ( minSamplerHeapReservedRangeWithEmbedded == rhs.minSamplerHeapReservedRangeWithEmbedded ) && - ( minResourceHeapReservedRange == rhs.minResourceHeapReservedRange ) && ( samplerDescriptorSize == rhs.samplerDescriptorSize ) && - ( imageDescriptorSize == rhs.imageDescriptorSize ) && ( bufferDescriptorSize == rhs.bufferDescriptorSize ) && - ( samplerDescriptorAlignment == rhs.samplerDescriptorAlignment ) && ( imageDescriptorAlignment == rhs.imageDescriptorAlignment ) && - ( bufferDescriptorAlignment == rhs.bufferDescriptorAlignment ) && ( maxPushDataSize == rhs.maxPushDataSize ) && - ( imageCaptureReplayOpaqueDataSize == rhs.imageCaptureReplayOpaqueDataSize ) && - ( maxDescriptorHeapEmbeddedSamplers == rhs.maxDescriptorHeapEmbeddedSamplers ) && - ( samplerYcbcrConversionCount == rhs.samplerYcbcrConversionCount ) && ( sparseDescriptorHeaps == rhs.sparseDescriptorHeaps ) && - ( protectedDescriptorHeaps == rhs.protectedDescriptorHeaps ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorHeapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorHeapPropertiesEXT; - void * pNext = {}; - DeviceSize samplerHeapAlignment = {}; - DeviceSize resourceHeapAlignment = {}; - DeviceSize maxSamplerHeapSize = {}; - DeviceSize maxResourceHeapSize = {}; - DeviceSize minSamplerHeapReservedRange = {}; - DeviceSize minSamplerHeapReservedRangeWithEmbedded = {}; - DeviceSize minResourceHeapReservedRange = {}; - DeviceSize samplerDescriptorSize = {}; - DeviceSize imageDescriptorSize = {}; - DeviceSize bufferDescriptorSize = {}; - DeviceSize samplerDescriptorAlignment = {}; - DeviceSize imageDescriptorAlignment = {}; - DeviceSize bufferDescriptorAlignment = {}; - DeviceSize maxPushDataSize = {}; - size_t imageCaptureReplayOpaqueDataSize = {}; - uint32_t maxDescriptorHeapEmbeddedSamplers = {}; - uint32_t samplerYcbcrConversionCount = {}; - Bool32 sparseDescriptorHeaps = {}; - Bool32 protectedDescriptorHeaps = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorHeapPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorHeapPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDescriptorHeapTensorPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorHeapTensorPropertiesARM.html - struct PhysicalDeviceDescriptorHeapTensorPropertiesARM - { - using NativeType = VkPhysicalDeviceDescriptorHeapTensorPropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorHeapTensorPropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorHeapTensorPropertiesARM( DeviceSize tensorDescriptorSize_ = {}, - DeviceSize tensorDescriptorAlignment_ = {}, - size_t tensorCaptureReplayOpaqueDataSize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensorDescriptorSize{ tensorDescriptorSize_ } - , tensorDescriptorAlignment{ tensorDescriptorAlignment_ } - , tensorCaptureReplayOpaqueDataSize{ tensorCaptureReplayOpaqueDataSize_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDescriptorHeapTensorPropertiesARM( PhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorHeapTensorPropertiesARM( VkPhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorHeapTensorPropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorHeapTensorPropertiesARM & operator=( PhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorHeapTensorPropertiesARM & operator=( VkPhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDescriptorHeapTensorPropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorHeapTensorPropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorHeapTensorPropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorHeapTensorPropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tensorDescriptorSize, tensorDescriptorAlignment, tensorCaptureReplayOpaqueDataSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorHeapTensorPropertiesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorDescriptorSize == rhs.tensorDescriptorSize ) && - ( tensorDescriptorAlignment == rhs.tensorDescriptorAlignment ) && ( tensorCaptureReplayOpaqueDataSize == rhs.tensorCaptureReplayOpaqueDataSize ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorHeapTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorHeapTensorPropertiesARM; - void * pNext = {}; - DeviceSize tensorDescriptorSize = {}; - DeviceSize tensorDescriptorAlignment = {}; - size_t tensorCaptureReplayOpaqueDataSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorHeapTensorPropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorHeapTensorPropertiesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceDescriptorIndexingFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorIndexingFeatures.html - struct PhysicalDeviceDescriptorIndexingFeatures - { - using NativeType = VkPhysicalDeviceDescriptorIndexingFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorIndexingFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeatures( Bool32 shaderInputAttachmentArrayDynamicIndexing_ = {}, - Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = {}, - Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = {}, - Bool32 shaderUniformBufferArrayNonUniformIndexing_ = {}, - Bool32 shaderSampledImageArrayNonUniformIndexing_ = {}, - Bool32 shaderStorageBufferArrayNonUniformIndexing_ = {}, - Bool32 shaderStorageImageArrayNonUniformIndexing_ = {}, - Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = {}, - Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = {}, - Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = {}, - Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = {}, - Bool32 descriptorBindingSampledImageUpdateAfterBind_ = {}, - Bool32 descriptorBindingStorageImageUpdateAfterBind_ = {}, - Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = {}, - Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = {}, - Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = {}, - Bool32 descriptorBindingUpdateUnusedWhilePending_ = {}, - Bool32 descriptorBindingPartiallyBound_ = {}, - Bool32 descriptorBindingVariableDescriptorCount_ = {}, - Bool32 runtimeDescriptorArray_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderInputAttachmentArrayDynamicIndexing{ shaderInputAttachmentArrayDynamicIndexing_ } - , shaderUniformTexelBufferArrayDynamicIndexing{ shaderUniformTexelBufferArrayDynamicIndexing_ } - , shaderStorageTexelBufferArrayDynamicIndexing{ shaderStorageTexelBufferArrayDynamicIndexing_ } - , shaderUniformBufferArrayNonUniformIndexing{ shaderUniformBufferArrayNonUniformIndexing_ } - , shaderSampledImageArrayNonUniformIndexing{ shaderSampledImageArrayNonUniformIndexing_ } - , shaderStorageBufferArrayNonUniformIndexing{ shaderStorageBufferArrayNonUniformIndexing_ } - , shaderStorageImageArrayNonUniformIndexing{ shaderStorageImageArrayNonUniformIndexing_ } - , shaderInputAttachmentArrayNonUniformIndexing{ shaderInputAttachmentArrayNonUniformIndexing_ } - , shaderUniformTexelBufferArrayNonUniformIndexing{ shaderUniformTexelBufferArrayNonUniformIndexing_ } - , shaderStorageTexelBufferArrayNonUniformIndexing{ shaderStorageTexelBufferArrayNonUniformIndexing_ } - , descriptorBindingUniformBufferUpdateAfterBind{ descriptorBindingUniformBufferUpdateAfterBind_ } - , descriptorBindingSampledImageUpdateAfterBind{ descriptorBindingSampledImageUpdateAfterBind_ } - , descriptorBindingStorageImageUpdateAfterBind{ descriptorBindingStorageImageUpdateAfterBind_ } - , descriptorBindingStorageBufferUpdateAfterBind{ descriptorBindingStorageBufferUpdateAfterBind_ } - , descriptorBindingUniformTexelBufferUpdateAfterBind{ descriptorBindingUniformTexelBufferUpdateAfterBind_ } - , descriptorBindingStorageTexelBufferUpdateAfterBind{ descriptorBindingStorageTexelBufferUpdateAfterBind_ } - , descriptorBindingUpdateUnusedWhilePending{ descriptorBindingUpdateUnusedWhilePending_ } - , descriptorBindingPartiallyBound{ descriptorBindingPartiallyBound_ } - , descriptorBindingVariableDescriptorCount{ descriptorBindingVariableDescriptorCount_ } - , runtimeDescriptorArray{ runtimeDescriptorArray_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingFeatures( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorIndexingFeatures( VkPhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorIndexingFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorIndexingFeatures & operator=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorIndexingFeatures & operator=( VkPhysicalDeviceDescriptorIndexingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & - setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && - setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures & setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ ) & VULKAN_HPP_NOEXCEPT - { - runtimeDescriptorArray = runtimeDescriptorArray_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorIndexingFeatures && setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ ) && VULKAN_HPP_NOEXCEPT - { - runtimeDescriptorArray = runtimeDescriptorArray_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDescriptorIndexingFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorIndexingFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorIndexingFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorIndexingFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - shaderInputAttachmentArrayDynamicIndexing, - shaderUniformTexelBufferArrayDynamicIndexing, - shaderStorageTexelBufferArrayDynamicIndexing, - shaderUniformBufferArrayNonUniformIndexing, - shaderSampledImageArrayNonUniformIndexing, - shaderStorageBufferArrayNonUniformIndexing, - shaderStorageImageArrayNonUniformIndexing, - shaderInputAttachmentArrayNonUniformIndexing, - shaderUniformTexelBufferArrayNonUniformIndexing, - shaderStorageTexelBufferArrayNonUniformIndexing, - descriptorBindingUniformBufferUpdateAfterBind, - descriptorBindingSampledImageUpdateAfterBind, - descriptorBindingStorageImageUpdateAfterBind, - descriptorBindingStorageBufferUpdateAfterBind, - descriptorBindingUniformTexelBufferUpdateAfterBind, - descriptorBindingStorageTexelBufferUpdateAfterBind, - descriptorBindingUpdateUnusedWhilePending, - descriptorBindingPartiallyBound, - descriptorBindingVariableDescriptorCount, - runtimeDescriptorArray ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorIndexingFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) && - ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) && - ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) && - ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) && - ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) && - ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) && - ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) && - ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) && - ( shaderUniformTexelBufferArrayNonUniformIndexing == rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) && - ( shaderStorageTexelBufferArrayNonUniformIndexing == rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) && - ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) && - ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) && - ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) && - ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) && - ( descriptorBindingUniformTexelBufferUpdateAfterBind == rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) && - ( descriptorBindingStorageTexelBufferUpdateAfterBind == rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) && - ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) && - ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) && - ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) && - ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorIndexingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingFeatures; - void * pNext = {}; - Bool32 shaderInputAttachmentArrayDynamicIndexing = {}; - Bool32 shaderUniformTexelBufferArrayDynamicIndexing = {}; - Bool32 shaderStorageTexelBufferArrayDynamicIndexing = {}; - Bool32 shaderUniformBufferArrayNonUniformIndexing = {}; - Bool32 shaderSampledImageArrayNonUniformIndexing = {}; - Bool32 shaderStorageBufferArrayNonUniformIndexing = {}; - Bool32 shaderStorageImageArrayNonUniformIndexing = {}; - Bool32 shaderInputAttachmentArrayNonUniformIndexing = {}; - Bool32 shaderUniformTexelBufferArrayNonUniformIndexing = {}; - Bool32 shaderStorageTexelBufferArrayNonUniformIndexing = {}; - Bool32 descriptorBindingUniformBufferUpdateAfterBind = {}; - Bool32 descriptorBindingSampledImageUpdateAfterBind = {}; - Bool32 descriptorBindingStorageImageUpdateAfterBind = {}; - Bool32 descriptorBindingStorageBufferUpdateAfterBind = {}; - Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind = {}; - Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind = {}; - Bool32 descriptorBindingUpdateUnusedWhilePending = {}; - Bool32 descriptorBindingPartiallyBound = {}; - Bool32 descriptorBindingVariableDescriptorCount = {}; - Bool32 runtimeDescriptorArray = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorIndexingFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorIndexingFeatures; - }; - - using PhysicalDeviceDescriptorIndexingFeaturesEXT = PhysicalDeviceDescriptorIndexingFeatures; - - // wrapper struct for struct VkPhysicalDeviceDescriptorIndexingProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorIndexingProperties.html - struct PhysicalDeviceDescriptorIndexingProperties - { - using NativeType = VkPhysicalDeviceDescriptorIndexingProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorIndexingProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingProperties( uint32_t maxUpdateAfterBindDescriptorsInAllPools_ = {}, - Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ = {}, - Bool32 shaderSampledImageArrayNonUniformIndexingNative_ = {}, - Bool32 shaderStorageBufferArrayNonUniformIndexingNative_ = {}, - Bool32 shaderStorageImageArrayNonUniformIndexingNative_ = {}, - Bool32 shaderInputAttachmentArrayNonUniformIndexingNative_ = {}, - Bool32 robustBufferAccessUpdateAfterBind_ = {}, - Bool32 quadDivergentImplicitLod_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments_ = {}, - uint32_t maxPerStageUpdateAfterBindResources_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindSamplers_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindSampledImages_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindStorageImages_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxUpdateAfterBindDescriptorsInAllPools{ maxUpdateAfterBindDescriptorsInAllPools_ } - , shaderUniformBufferArrayNonUniformIndexingNative{ shaderUniformBufferArrayNonUniformIndexingNative_ } - , shaderSampledImageArrayNonUniformIndexingNative{ shaderSampledImageArrayNonUniformIndexingNative_ } - , shaderStorageBufferArrayNonUniformIndexingNative{ shaderStorageBufferArrayNonUniformIndexingNative_ } - , shaderStorageImageArrayNonUniformIndexingNative{ shaderStorageImageArrayNonUniformIndexingNative_ } - , shaderInputAttachmentArrayNonUniformIndexingNative{ shaderInputAttachmentArrayNonUniformIndexingNative_ } - , robustBufferAccessUpdateAfterBind{ robustBufferAccessUpdateAfterBind_ } - , quadDivergentImplicitLod{ quadDivergentImplicitLod_ } - , maxPerStageDescriptorUpdateAfterBindSamplers{ maxPerStageDescriptorUpdateAfterBindSamplers_ } - , maxPerStageDescriptorUpdateAfterBindUniformBuffers{ maxPerStageDescriptorUpdateAfterBindUniformBuffers_ } - , maxPerStageDescriptorUpdateAfterBindStorageBuffers{ maxPerStageDescriptorUpdateAfterBindStorageBuffers_ } - , maxPerStageDescriptorUpdateAfterBindSampledImages{ maxPerStageDescriptorUpdateAfterBindSampledImages_ } - , maxPerStageDescriptorUpdateAfterBindStorageImages{ maxPerStageDescriptorUpdateAfterBindStorageImages_ } - , maxPerStageDescriptorUpdateAfterBindInputAttachments{ maxPerStageDescriptorUpdateAfterBindInputAttachments_ } - , maxPerStageUpdateAfterBindResources{ maxPerStageUpdateAfterBindResources_ } - , maxDescriptorSetUpdateAfterBindSamplers{ maxDescriptorSetUpdateAfterBindSamplers_ } - , maxDescriptorSetUpdateAfterBindUniformBuffers{ maxDescriptorSetUpdateAfterBindUniformBuffers_ } - , maxDescriptorSetUpdateAfterBindUniformBuffersDynamic{ maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ } - , maxDescriptorSetUpdateAfterBindStorageBuffers{ maxDescriptorSetUpdateAfterBindStorageBuffers_ } - , maxDescriptorSetUpdateAfterBindStorageBuffersDynamic{ maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ } - , maxDescriptorSetUpdateAfterBindSampledImages{ maxDescriptorSetUpdateAfterBindSampledImages_ } - , maxDescriptorSetUpdateAfterBindStorageImages{ maxDescriptorSetUpdateAfterBindStorageImages_ } - , maxDescriptorSetUpdateAfterBindInputAttachments{ maxDescriptorSetUpdateAfterBindInputAttachments_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorIndexingProperties( PhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorIndexingProperties( VkPhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorIndexingProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorIndexingProperties & operator=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorIndexingProperties & operator=( VkPhysicalDeviceDescriptorIndexingProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDescriptorIndexingProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorIndexingProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorIndexingProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorIndexingProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - maxUpdateAfterBindDescriptorsInAllPools, - shaderUniformBufferArrayNonUniformIndexingNative, - shaderSampledImageArrayNonUniformIndexingNative, - shaderStorageBufferArrayNonUniformIndexingNative, - shaderStorageImageArrayNonUniformIndexingNative, - shaderInputAttachmentArrayNonUniformIndexingNative, - robustBufferAccessUpdateAfterBind, - quadDivergentImplicitLod, - maxPerStageDescriptorUpdateAfterBindSamplers, - maxPerStageDescriptorUpdateAfterBindUniformBuffers, - maxPerStageDescriptorUpdateAfterBindStorageBuffers, - maxPerStageDescriptorUpdateAfterBindSampledImages, - maxPerStageDescriptorUpdateAfterBindStorageImages, - maxPerStageDescriptorUpdateAfterBindInputAttachments, - maxPerStageUpdateAfterBindResources, - maxDescriptorSetUpdateAfterBindSamplers, - maxDescriptorSetUpdateAfterBindUniformBuffers, - maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, - maxDescriptorSetUpdateAfterBindStorageBuffers, - maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, - maxDescriptorSetUpdateAfterBindSampledImages, - maxDescriptorSetUpdateAfterBindStorageImages, - maxDescriptorSetUpdateAfterBindInputAttachments ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorIndexingProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) && - ( shaderUniformBufferArrayNonUniformIndexingNative == rhs.shaderUniformBufferArrayNonUniformIndexingNative ) && - ( shaderSampledImageArrayNonUniformIndexingNative == rhs.shaderSampledImageArrayNonUniformIndexingNative ) && - ( shaderStorageBufferArrayNonUniformIndexingNative == rhs.shaderStorageBufferArrayNonUniformIndexingNative ) && - ( shaderStorageImageArrayNonUniformIndexingNative == rhs.shaderStorageImageArrayNonUniformIndexingNative ) && - ( shaderInputAttachmentArrayNonUniformIndexingNative == rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) && - ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) && ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) && - ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) && - ( maxPerStageDescriptorUpdateAfterBindUniformBuffers == rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) && - ( maxPerStageDescriptorUpdateAfterBindStorageBuffers == rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) && - ( maxPerStageDescriptorUpdateAfterBindSampledImages == rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) && - ( maxPerStageDescriptorUpdateAfterBindStorageImages == rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) && - ( maxPerStageDescriptorUpdateAfterBindInputAttachments == rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) && - ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) && - ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) && - ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) && - ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) && - ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) && - ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) && - ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) && - ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) && - ( maxDescriptorSetUpdateAfterBindInputAttachments == rhs.maxDescriptorSetUpdateAfterBindInputAttachments ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorIndexingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorIndexingProperties; - void * pNext = {}; - uint32_t maxUpdateAfterBindDescriptorsInAllPools = {}; - Bool32 shaderUniformBufferArrayNonUniformIndexingNative = {}; - Bool32 shaderSampledImageArrayNonUniformIndexingNative = {}; - Bool32 shaderStorageBufferArrayNonUniformIndexingNative = {}; - Bool32 shaderStorageImageArrayNonUniformIndexingNative = {}; - Bool32 shaderInputAttachmentArrayNonUniformIndexingNative = {}; - Bool32 robustBufferAccessUpdateAfterBind = {}; - Bool32 quadDivergentImplicitLod = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments = {}; - uint32_t maxPerStageUpdateAfterBindResources = {}; - uint32_t maxDescriptorSetUpdateAfterBindSamplers = {}; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers = {}; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = {}; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers = {}; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = {}; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages = {}; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages = {}; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorIndexingProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorIndexingProperties; - }; - - using PhysicalDeviceDescriptorIndexingPropertiesEXT = PhysicalDeviceDescriptorIndexingProperties; - - // wrapper struct for struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.html - struct PhysicalDeviceDescriptorPoolOverallocationFeaturesNV - { - using NativeType = VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( Bool32 descriptorPoolOverallocation_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorPoolOverallocation{ descriptorPoolOverallocation_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorPoolOverallocationFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorPoolOverallocationFeaturesNV & - operator=( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorPoolOverallocationFeaturesNV & operator=( VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorPoolOverallocationFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorPoolOverallocationFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorPoolOverallocationFeaturesNV & setDescriptorPoolOverallocation( Bool32 descriptorPoolOverallocation_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorPoolOverallocation = descriptorPoolOverallocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorPoolOverallocationFeaturesNV && setDescriptorPoolOverallocation( Bool32 descriptorPoolOverallocation_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorPoolOverallocation = descriptorPoolOverallocation_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorPoolOverallocation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorPoolOverallocation == rhs.descriptorPoolOverallocation ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorPoolOverallocationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV; - void * pNext = {}; - Bool32 descriptorPoolOverallocation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorPoolOverallocationFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.html - struct PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE - { - using NativeType = VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( Bool32 descriptorSetHostMapping_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorSetHostMapping{ descriptorSetHostMapping_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE & - operator=( PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE & operator=( VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE & setDescriptorSetHostMapping( Bool32 descriptorSetHostMapping_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorSetHostMapping = descriptorSetHostMapping_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE && setDescriptorSetHostMapping( Bool32 descriptorSetHostMapping_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorSetHostMapping = descriptorSetHostMapping_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorSetHostMapping ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & ) const = default; -#else - bool operator==( PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorSetHostMapping == rhs.descriptorSetHostMapping ); -# endif - } - - bool operator!=( PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; - void * pNext = {}; - Bool32 descriptorSetHostMapping = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; - }; - - // wrapper struct for struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.html - struct PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV - { - using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( Bool32 deviceGeneratedCompute_ = {}, - Bool32 deviceGeneratedComputePipelines_ = {}, - Bool32 deviceGeneratedComputeCaptureReplay_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceGeneratedCompute{ deviceGeneratedCompute_ } - , deviceGeneratedComputePipelines{ deviceGeneratedComputePipelines_ } - , deviceGeneratedComputeCaptureReplay{ deviceGeneratedComputeCaptureReplay_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & - operator=( PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & - operator=( VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & setDeviceGeneratedCompute( Bool32 deviceGeneratedCompute_ ) & - VULKAN_HPP_NOEXCEPT - { - deviceGeneratedCompute = deviceGeneratedCompute_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV && setDeviceGeneratedCompute( Bool32 deviceGeneratedCompute_ ) && - VULKAN_HPP_NOEXCEPT - { - deviceGeneratedCompute = deviceGeneratedCompute_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & - setDeviceGeneratedComputePipelines( Bool32 deviceGeneratedComputePipelines_ ) & - VULKAN_HPP_NOEXCEPT - { - deviceGeneratedComputePipelines = deviceGeneratedComputePipelines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV && - setDeviceGeneratedComputePipelines( Bool32 deviceGeneratedComputePipelines_ ) && - VULKAN_HPP_NOEXCEPT - { - deviceGeneratedComputePipelines = deviceGeneratedComputePipelines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV & - setDeviceGeneratedComputeCaptureReplay( Bool32 deviceGeneratedComputeCaptureReplay_ ) & - VULKAN_HPP_NOEXCEPT - { - deviceGeneratedComputeCaptureReplay = deviceGeneratedComputeCaptureReplay_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV && - setDeviceGeneratedComputeCaptureReplay( Bool32 deviceGeneratedComputeCaptureReplay_ ) && - VULKAN_HPP_NOEXCEPT - { - deviceGeneratedComputeCaptureReplay = deviceGeneratedComputeCaptureReplay_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceGeneratedCompute, deviceGeneratedComputePipelines, deviceGeneratedComputeCaptureReplay ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceGeneratedCompute == rhs.deviceGeneratedCompute ) && - ( deviceGeneratedComputePipelines == rhs.deviceGeneratedComputePipelines ) && - ( deviceGeneratedComputeCaptureReplay == rhs.deviceGeneratedComputeCaptureReplay ); -# endif - } - - bool operator!=( PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; - void * pNext = {}; - Bool32 deviceGeneratedCompute = {}; - Bool32 deviceGeneratedComputePipelines = {}; - Bool32 deviceGeneratedComputeCaptureReplay = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.html - struct PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT - { - using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( Bool32 deviceGeneratedCommands_ = {}, - Bool32 dynamicGeneratedPipelineLayout_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceGeneratedCommands{ deviceGeneratedCommands_ } - , dynamicGeneratedPipelineLayout{ dynamicGeneratedPipelineLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT & operator=( PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT & operator=( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT & setDeviceGeneratedCommands( Bool32 deviceGeneratedCommands_ ) & - VULKAN_HPP_NOEXCEPT - { - deviceGeneratedCommands = deviceGeneratedCommands_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT && setDeviceGeneratedCommands( Bool32 deviceGeneratedCommands_ ) && - VULKAN_HPP_NOEXCEPT - { - deviceGeneratedCommands = deviceGeneratedCommands_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT & setDynamicGeneratedPipelineLayout( Bool32 dynamicGeneratedPipelineLayout_ ) & - VULKAN_HPP_NOEXCEPT - { - dynamicGeneratedPipelineLayout = dynamicGeneratedPipelineLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT && setDynamicGeneratedPipelineLayout( Bool32 dynamicGeneratedPipelineLayout_ ) && - VULKAN_HPP_NOEXCEPT - { - dynamicGeneratedPipelineLayout = dynamicGeneratedPipelineLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceGeneratedCommands, dynamicGeneratedPipelineLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceGeneratedCommands == rhs.deviceGeneratedCommands ) && - ( dynamicGeneratedPipelineLayout == rhs.dynamicGeneratedPipelineLayout ); -# endif - } - - bool operator!=( PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; - void * pNext = {}; - Bool32 deviceGeneratedCommands = {}; - Bool32 dynamicGeneratedPipelineLayout = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.html - struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNV - { - using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( Bool32 deviceGeneratedCommands_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceGeneratedCommands{ deviceGeneratedCommands_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDeviceGeneratedCommandsFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & operator=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & operator=( VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesNV & setDeviceGeneratedCommands( Bool32 deviceGeneratedCommands_ ) & - VULKAN_HPP_NOEXCEPT - { - deviceGeneratedCommands = deviceGeneratedCommands_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceGeneratedCommandsFeaturesNV && setDeviceGeneratedCommands( Bool32 deviceGeneratedCommands_ ) && - VULKAN_HPP_NOEXCEPT - { - deviceGeneratedCommands = deviceGeneratedCommands_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceGeneratedCommands ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceGeneratedCommands == rhs.deviceGeneratedCommands ); -# endif - } - - bool operator!=( PhysicalDeviceDeviceGeneratedCommandsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV; - void * pNext = {}; - Bool32 deviceGeneratedCommands = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.html - struct PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT - { - using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT( uint32_t maxIndirectPipelineCount_ = {}, - uint32_t maxIndirectShaderObjectCount_ = {}, - uint32_t maxIndirectSequenceCount_ = {}, - uint32_t maxIndirectCommandsTokenCount_ = {}, - uint32_t maxIndirectCommandsTokenOffset_ = {}, - uint32_t maxIndirectCommandsIndirectStride_ = {}, - IndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes_ = {}, - ShaderStageFlags supportedIndirectCommandsShaderStages_ = {}, - ShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding_ = {}, - ShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding_ = {}, - Bool32 deviceGeneratedCommandsTransformFeedback_ = {}, - Bool32 deviceGeneratedCommandsMultiDrawIndirectCount_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxIndirectPipelineCount{ maxIndirectPipelineCount_ } - , maxIndirectShaderObjectCount{ maxIndirectShaderObjectCount_ } - , maxIndirectSequenceCount{ maxIndirectSequenceCount_ } - , maxIndirectCommandsTokenCount{ maxIndirectCommandsTokenCount_ } - , maxIndirectCommandsTokenOffset{ maxIndirectCommandsTokenOffset_ } - , maxIndirectCommandsIndirectStride{ maxIndirectCommandsIndirectStride_ } - , supportedIndirectCommandsInputModes{ supportedIndirectCommandsInputModes_ } - , supportedIndirectCommandsShaderStages{ supportedIndirectCommandsShaderStages_ } - , supportedIndirectCommandsShaderStagesPipelineBinding{ supportedIndirectCommandsShaderStagesPipelineBinding_ } - , supportedIndirectCommandsShaderStagesShaderBinding{ supportedIndirectCommandsShaderStagesShaderBinding_ } - , deviceGeneratedCommandsTransformFeedback{ deviceGeneratedCommandsTransformFeedback_ } - , deviceGeneratedCommandsMultiDrawIndirectCount{ deviceGeneratedCommandsMultiDrawIndirectCount_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT( PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT & - operator=( PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT & operator=( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - maxIndirectPipelineCount, - maxIndirectShaderObjectCount, - maxIndirectSequenceCount, - maxIndirectCommandsTokenCount, - maxIndirectCommandsTokenOffset, - maxIndirectCommandsIndirectStride, - supportedIndirectCommandsInputModes, - supportedIndirectCommandsShaderStages, - supportedIndirectCommandsShaderStagesPipelineBinding, - supportedIndirectCommandsShaderStagesShaderBinding, - deviceGeneratedCommandsTransformFeedback, - deviceGeneratedCommandsMultiDrawIndirectCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxIndirectPipelineCount == rhs.maxIndirectPipelineCount ) && - ( maxIndirectShaderObjectCount == rhs.maxIndirectShaderObjectCount ) && ( maxIndirectSequenceCount == rhs.maxIndirectSequenceCount ) && - ( maxIndirectCommandsTokenCount == rhs.maxIndirectCommandsTokenCount ) && - ( maxIndirectCommandsTokenOffset == rhs.maxIndirectCommandsTokenOffset ) && - ( maxIndirectCommandsIndirectStride == rhs.maxIndirectCommandsIndirectStride ) && - ( supportedIndirectCommandsInputModes == rhs.supportedIndirectCommandsInputModes ) && - ( supportedIndirectCommandsShaderStages == rhs.supportedIndirectCommandsShaderStages ) && - ( supportedIndirectCommandsShaderStagesPipelineBinding == rhs.supportedIndirectCommandsShaderStagesPipelineBinding ) && - ( supportedIndirectCommandsShaderStagesShaderBinding == rhs.supportedIndirectCommandsShaderStagesShaderBinding ) && - ( deviceGeneratedCommandsTransformFeedback == rhs.deviceGeneratedCommandsTransformFeedback ) && - ( deviceGeneratedCommandsMultiDrawIndirectCount == rhs.deviceGeneratedCommandsMultiDrawIndirectCount ); -# endif - } - - bool operator!=( PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; - void * pNext = {}; - uint32_t maxIndirectPipelineCount = {}; - uint32_t maxIndirectShaderObjectCount = {}; - uint32_t maxIndirectSequenceCount = {}; - uint32_t maxIndirectCommandsTokenCount = {}; - uint32_t maxIndirectCommandsTokenOffset = {}; - uint32_t maxIndirectCommandsIndirectStride = {}; - IndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes = {}; - ShaderStageFlags supportedIndirectCommandsShaderStages = {}; - ShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding = {}; - ShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding = {}; - Bool32 deviceGeneratedCommandsTransformFeedback = {}; - Bool32 deviceGeneratedCommandsMultiDrawIndirectCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.html - struct PhysicalDeviceDeviceGeneratedCommandsPropertiesNV - { - using NativeType = VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( uint32_t maxGraphicsShaderGroupCount_ = {}, - uint32_t maxIndirectSequenceCount_ = {}, - uint32_t maxIndirectCommandsTokenCount_ = {}, - uint32_t maxIndirectCommandsStreamCount_ = {}, - uint32_t maxIndirectCommandsTokenOffset_ = {}, - uint32_t maxIndirectCommandsStreamStride_ = {}, - uint32_t minSequencesCountBufferOffsetAlignment_ = {}, - uint32_t minSequencesIndexBufferOffsetAlignment_ = {}, - uint32_t minIndirectCommandsBufferOffsetAlignment_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxGraphicsShaderGroupCount{ maxGraphicsShaderGroupCount_ } - , maxIndirectSequenceCount{ maxIndirectSequenceCount_ } - , maxIndirectCommandsTokenCount{ maxIndirectCommandsTokenCount_ } - , maxIndirectCommandsStreamCount{ maxIndirectCommandsStreamCount_ } - , maxIndirectCommandsTokenOffset{ maxIndirectCommandsTokenOffset_ } - , maxIndirectCommandsStreamStride{ maxIndirectCommandsStreamStride_ } - , minSequencesCountBufferOffsetAlignment{ minSequencesCountBufferOffsetAlignment_ } - , minSequencesIndexBufferOffsetAlignment{ minSequencesIndexBufferOffsetAlignment_ } - , minIndirectCommandsBufferOffsetAlignment{ minIndirectCommandsBufferOffsetAlignment_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDeviceGeneratedCommandsPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDeviceGeneratedCommandsPropertiesNV & - operator=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDeviceGeneratedCommandsPropertiesNV & operator=( VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - maxGraphicsShaderGroupCount, - maxIndirectSequenceCount, - maxIndirectCommandsTokenCount, - maxIndirectCommandsStreamCount, - maxIndirectCommandsTokenOffset, - maxIndirectCommandsStreamStride, - minSequencesCountBufferOffsetAlignment, - minSequencesIndexBufferOffsetAlignment, - minIndirectCommandsBufferOffsetAlignment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGraphicsShaderGroupCount == rhs.maxGraphicsShaderGroupCount ) && - ( maxIndirectSequenceCount == rhs.maxIndirectSequenceCount ) && ( maxIndirectCommandsTokenCount == rhs.maxIndirectCommandsTokenCount ) && - ( maxIndirectCommandsStreamCount == rhs.maxIndirectCommandsStreamCount ) && - ( maxIndirectCommandsTokenOffset == rhs.maxIndirectCommandsTokenOffset ) && - ( maxIndirectCommandsStreamStride == rhs.maxIndirectCommandsStreamStride ) && - ( minSequencesCountBufferOffsetAlignment == rhs.minSequencesCountBufferOffsetAlignment ) && - ( minSequencesIndexBufferOffsetAlignment == rhs.minSequencesIndexBufferOffsetAlignment ) && - ( minIndirectCommandsBufferOffsetAlignment == rhs.minIndirectCommandsBufferOffsetAlignment ); -# endif - } - - bool operator!=( PhysicalDeviceDeviceGeneratedCommandsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV; - void * pNext = {}; - uint32_t maxGraphicsShaderGroupCount = {}; - uint32_t maxIndirectSequenceCount = {}; - uint32_t maxIndirectCommandsTokenCount = {}; - uint32_t maxIndirectCommandsStreamCount = {}; - uint32_t maxIndirectCommandsTokenOffset = {}; - uint32_t maxIndirectCommandsStreamStride = {}; - uint32_t minSequencesCountBufferOffsetAlignment = {}; - uint32_t minSequencesIndexBufferOffsetAlignment = {}; - uint32_t minIndirectCommandsBufferOffsetAlignment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceGeneratedCommandsPropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.html - struct PhysicalDeviceDeviceMemoryReportFeaturesEXT - { - using NativeType = VkPhysicalDeviceDeviceMemoryReportFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDeviceMemoryReportFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceMemoryReportFeaturesEXT( Bool32 deviceMemoryReport_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceMemoryReport{ deviceMemoryReport_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDeviceMemoryReportFeaturesEXT( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDeviceMemoryReportFeaturesEXT( VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDeviceMemoryReportFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDeviceMemoryReportFeaturesEXT & operator=( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDeviceMemoryReportFeaturesEXT & operator=( VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceMemoryReportFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceMemoryReportFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceMemoryReportFeaturesEXT & setDeviceMemoryReport( Bool32 deviceMemoryReport_ ) & VULKAN_HPP_NOEXCEPT - { - deviceMemoryReport = deviceMemoryReport_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDeviceMemoryReportFeaturesEXT && setDeviceMemoryReport( Bool32 deviceMemoryReport_ ) && VULKAN_HPP_NOEXCEPT - { - deviceMemoryReport = deviceMemoryReport_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceMemoryReport ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceMemoryReport == rhs.deviceMemoryReport ); -# endif - } - - bool operator!=( PhysicalDeviceDeviceMemoryReportFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDeviceMemoryReportFeaturesEXT; - void * pNext = {}; - Bool32 deviceMemoryReport = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceMemoryReportFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDeviceMemoryReportFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDiagnosticsConfigFeaturesNV.html - struct PhysicalDeviceDiagnosticsConfigFeaturesNV - { - using NativeType = VkPhysicalDeviceDiagnosticsConfigFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDiagnosticsConfigFeaturesNV( Bool32 diagnosticsConfig_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , diagnosticsConfig{ diagnosticsConfig_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDiagnosticsConfigFeaturesNV( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDiagnosticsConfigFeaturesNV( VkPhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDiagnosticsConfigFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDiagnosticsConfigFeaturesNV & operator=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDiagnosticsConfigFeaturesNV & operator=( VkPhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDiagnosticsConfigFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDiagnosticsConfigFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDiagnosticsConfigFeaturesNV & setDiagnosticsConfig( Bool32 diagnosticsConfig_ ) & VULKAN_HPP_NOEXCEPT - { - diagnosticsConfig = diagnosticsConfig_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDiagnosticsConfigFeaturesNV && setDiagnosticsConfig( Bool32 diagnosticsConfig_ ) && VULKAN_HPP_NOEXCEPT - { - diagnosticsConfig = diagnosticsConfig_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDiagnosticsConfigFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, diagnosticsConfig ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDiagnosticsConfigFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( diagnosticsConfig == rhs.diagnosticsConfig ); -# endif - } - - bool operator!=( PhysicalDeviceDiagnosticsConfigFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV; - void * pNext = {}; - Bool32 diagnosticsConfig = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDiagnosticsConfigFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDiagnosticsConfigFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceDiscardRectanglePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDiscardRectanglePropertiesEXT.html - struct PhysicalDeviceDiscardRectanglePropertiesEXT - { - using NativeType = VkPhysicalDeviceDiscardRectanglePropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDiscardRectanglePropertiesEXT( uint32_t maxDiscardRectangles_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxDiscardRectangles{ maxDiscardRectangles_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDiscardRectanglePropertiesEXT( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDiscardRectanglePropertiesEXT( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDiscardRectanglePropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDiscardRectanglePropertiesEXT & operator=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDiscardRectanglePropertiesEXT & operator=( VkPhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDiscardRectanglePropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDiscardRectanglePropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDiscardRectanglePropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxDiscardRectangles ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDiscardRectanglePropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDiscardRectangles == rhs.maxDiscardRectangles ); -# endif - } - - bool operator!=( PhysicalDeviceDiscardRectanglePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT; - void * pNext = {}; - uint32_t maxDiscardRectangles = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDiscardRectanglePropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDiscardRectanglePropertiesEXT; - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkPhysicalDeviceDisplacementMicromapFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDisplacementMicromapFeaturesNV.html - struct PhysicalDeviceDisplacementMicromapFeaturesNV - { - using NativeType = VkPhysicalDeviceDisplacementMicromapFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDisplacementMicromapFeaturesNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDisplacementMicromapFeaturesNV( Bool32 displacementMicromap_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , displacementMicromap{ displacementMicromap_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDisplacementMicromapFeaturesNV( PhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDisplacementMicromapFeaturesNV( VkPhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDisplacementMicromapFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDisplacementMicromapFeaturesNV & operator=( PhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDisplacementMicromapFeaturesNV & operator=( VkPhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDisplacementMicromapFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDisplacementMicromapFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDisplacementMicromapFeaturesNV & setDisplacementMicromap( Bool32 displacementMicromap_ ) & VULKAN_HPP_NOEXCEPT - { - displacementMicromap = displacementMicromap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDisplacementMicromapFeaturesNV && setDisplacementMicromap( Bool32 displacementMicromap_ ) && VULKAN_HPP_NOEXCEPT - { - displacementMicromap = displacementMicromap_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDisplacementMicromapFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDisplacementMicromapFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDisplacementMicromapFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDisplacementMicromapFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, displacementMicromap ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDisplacementMicromapFeaturesNV const & ) const = default; -# else - bool operator==( PhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( displacementMicromap == rhs.displacementMicromap ); -# endif - } - - bool operator!=( PhysicalDeviceDisplacementMicromapFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDisplacementMicromapFeaturesNV; - void * pNext = {}; - Bool32 displacementMicromap = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDisplacementMicromapFeaturesNV; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDisplacementMicromapFeaturesNV; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkPhysicalDeviceDisplacementMicromapPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDisplacementMicromapPropertiesNV.html - struct PhysicalDeviceDisplacementMicromapPropertiesNV - { - using NativeType = VkPhysicalDeviceDisplacementMicromapPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDisplacementMicromapPropertiesNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDisplacementMicromapPropertiesNV( uint32_t maxDisplacementMicromapSubdivisionLevel_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxDisplacementMicromapSubdivisionLevel{ maxDisplacementMicromapSubdivisionLevel_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDisplacementMicromapPropertiesNV( PhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDisplacementMicromapPropertiesNV( VkPhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDisplacementMicromapPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDisplacementMicromapPropertiesNV & operator=( PhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDisplacementMicromapPropertiesNV & operator=( VkPhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDisplacementMicromapPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDisplacementMicromapPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDisplacementMicromapPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDisplacementMicromapPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxDisplacementMicromapSubdivisionLevel ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDisplacementMicromapPropertiesNV const & ) const = default; -# else - bool operator==( PhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDisplacementMicromapSubdivisionLevel == rhs.maxDisplacementMicromapSubdivisionLevel ); -# endif - } - - bool operator!=( PhysicalDeviceDisplacementMicromapPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDisplacementMicromapPropertiesNV; - void * pNext = {}; - uint32_t maxDisplacementMicromapSubdivisionLevel = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDisplacementMicromapPropertiesNV; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDisplacementMicromapPropertiesNV; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkPhysicalDeviceDriverProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDriverProperties.html - struct PhysicalDeviceDriverProperties - { - using NativeType = VkPhysicalDeviceDriverProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDriverProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDriverProperties( DriverId driverID_ = DriverId::eAmdProprietary, - std::array const & driverName_ = {}, - std::array const & driverInfo_ = {}, - ConformanceVersion conformanceVersion_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , driverID{ driverID_ } - , driverName{ driverName_ } - , driverInfo{ driverInfo_ } - , conformanceVersion{ conformanceVersion_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDriverProperties( PhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDriverProperties( VkPhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDriverProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDriverProperties & operator=( PhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDriverProperties & operator=( VkPhysicalDeviceDriverProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDriverProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDriverProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDriverProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDriverProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &, - ConformanceVersion const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, driverID, driverName, driverInfo, conformanceVersion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = driverID <=> rhs.driverID; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( driverName, rhs.driverName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = strcmp( driverInfo, rhs.driverInfo ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = conformanceVersion <=> rhs.conformanceVersion; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && ( strcmp( driverName, rhs.driverName ) == 0 ) && - ( strcmp( driverInfo, rhs.driverInfo ) == 0 ) && ( conformanceVersion == rhs.conformanceVersion ); - } - - bool operator!=( PhysicalDeviceDriverProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::ePhysicalDeviceDriverProperties; - void * pNext = {}; - DriverId driverID = DriverId::eAmdProprietary; - ArrayWrapper1D driverName = {}; - ArrayWrapper1D driverInfo = {}; - ConformanceVersion conformanceVersion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDriverProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDriverProperties; - }; - - using PhysicalDeviceDriverPropertiesKHR = PhysicalDeviceDriverProperties; - - // wrapper struct for struct VkPhysicalDeviceDrmPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDrmPropertiesEXT.html - struct PhysicalDeviceDrmPropertiesEXT - { - using NativeType = VkPhysicalDeviceDrmPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDrmPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDrmPropertiesEXT( Bool32 hasPrimary_ = {}, - Bool32 hasRender_ = {}, - int64_t primaryMajor_ = {}, - int64_t primaryMinor_ = {}, - int64_t renderMajor_ = {}, - int64_t renderMinor_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , hasPrimary{ hasPrimary_ } - , hasRender{ hasRender_ } - , primaryMajor{ primaryMajor_ } - , primaryMinor{ primaryMinor_ } - , renderMajor{ renderMajor_ } - , renderMinor{ renderMinor_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDrmPropertiesEXT( PhysicalDeviceDrmPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDrmPropertiesEXT( VkPhysicalDeviceDrmPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDrmPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDrmPropertiesEXT & operator=( PhysicalDeviceDrmPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDrmPropertiesEXT & operator=( VkPhysicalDeviceDrmPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceDrmPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDrmPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDrmPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDrmPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, hasPrimary, hasRender, primaryMajor, primaryMinor, renderMajor, renderMinor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDrmPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasPrimary == rhs.hasPrimary ) && ( hasRender == rhs.hasRender ) && - ( primaryMajor == rhs.primaryMajor ) && ( primaryMinor == rhs.primaryMinor ) && ( renderMajor == rhs.renderMajor ) && - ( renderMinor == rhs.renderMinor ); -# endif - } - - bool operator!=( PhysicalDeviceDrmPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDrmPropertiesEXT; - void * pNext = {}; - Bool32 hasPrimary = {}; - Bool32 hasRender = {}; - int64_t primaryMajor = {}; - int64_t primaryMinor = {}; - int64_t renderMajor = {}; - int64_t renderMinor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDrmPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDrmPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceDynamicRenderingFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDynamicRenderingFeatures.html - struct PhysicalDeviceDynamicRenderingFeatures - { - using NativeType = VkPhysicalDeviceDynamicRenderingFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDynamicRenderingFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDynamicRenderingFeatures( Bool32 dynamicRendering_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dynamicRendering{ dynamicRendering_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDynamicRenderingFeatures( PhysicalDeviceDynamicRenderingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDynamicRenderingFeatures( VkPhysicalDeviceDynamicRenderingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDynamicRenderingFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDynamicRenderingFeatures & operator=( PhysicalDeviceDynamicRenderingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDynamicRenderingFeatures & operator=( VkPhysicalDeviceDynamicRenderingFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingFeatures & setDynamicRendering( Bool32 dynamicRendering_ ) & VULKAN_HPP_NOEXCEPT - { - dynamicRendering = dynamicRendering_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingFeatures && setDynamicRendering( Bool32 dynamicRendering_ ) && VULKAN_HPP_NOEXCEPT - { - dynamicRendering = dynamicRendering_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDynamicRenderingFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDynamicRenderingFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDynamicRenderingFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDynamicRenderingFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dynamicRendering ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDynamicRenderingFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceDynamicRenderingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRendering == rhs.dynamicRendering ); -# endif - } - - bool operator!=( PhysicalDeviceDynamicRenderingFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDynamicRenderingFeatures; - void * pNext = {}; - Bool32 dynamicRendering = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDynamicRenderingFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDynamicRenderingFeatures; - }; - - using PhysicalDeviceDynamicRenderingFeaturesKHR = PhysicalDeviceDynamicRenderingFeatures; - - // wrapper struct for struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDynamicRenderingLocalReadFeatures.html - struct PhysicalDeviceDynamicRenderingLocalReadFeatures - { - using NativeType = VkPhysicalDeviceDynamicRenderingLocalReadFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDynamicRenderingLocalReadFeatures( Bool32 dynamicRenderingLocalRead_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dynamicRenderingLocalRead{ dynamicRenderingLocalRead_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceDynamicRenderingLocalReadFeatures( PhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDynamicRenderingLocalReadFeatures( VkPhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDynamicRenderingLocalReadFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDynamicRenderingLocalReadFeatures & operator=( PhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDynamicRenderingLocalReadFeatures & operator=( VkPhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingLocalReadFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingLocalReadFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingLocalReadFeatures & setDynamicRenderingLocalRead( Bool32 dynamicRenderingLocalRead_ ) & - VULKAN_HPP_NOEXCEPT - { - dynamicRenderingLocalRead = dynamicRenderingLocalRead_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingLocalReadFeatures && setDynamicRenderingLocalRead( Bool32 dynamicRenderingLocalRead_ ) && - VULKAN_HPP_NOEXCEPT - { - dynamicRenderingLocalRead = dynamicRenderingLocalRead_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDynamicRenderingLocalReadFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDynamicRenderingLocalReadFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDynamicRenderingLocalReadFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDynamicRenderingLocalReadFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dynamicRenderingLocalRead ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDynamicRenderingLocalReadFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRenderingLocalRead == rhs.dynamicRenderingLocalRead ); -# endif - } - - bool operator!=( PhysicalDeviceDynamicRenderingLocalReadFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeatures; - void * pNext = {}; - Bool32 dynamicRenderingLocalRead = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDynamicRenderingLocalReadFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDynamicRenderingLocalReadFeatures; - }; - - using PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = PhysicalDeviceDynamicRenderingLocalReadFeatures; - - // wrapper struct for struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.html - struct PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT - { - using NativeType = VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( Bool32 dynamicRenderingUnusedAttachments_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dynamicRenderingUnusedAttachments{ dynamicRenderingUnusedAttachments_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT( - *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT & - operator=( PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT & - operator=( VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT & - setDynamicRenderingUnusedAttachments( Bool32 dynamicRenderingUnusedAttachments_ ) & - VULKAN_HPP_NOEXCEPT - { - dynamicRenderingUnusedAttachments = dynamicRenderingUnusedAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT && - setDynamicRenderingUnusedAttachments( Bool32 dynamicRenderingUnusedAttachments_ ) && - VULKAN_HPP_NOEXCEPT - { - dynamicRenderingUnusedAttachments = dynamicRenderingUnusedAttachments_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dynamicRenderingUnusedAttachments ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicRenderingUnusedAttachments == rhs.dynamicRenderingUnusedAttachments ); -# endif - } - - bool operator!=( PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; - void * pNext = {}; - Bool32 dynamicRenderingUnusedAttachments = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceExclusiveScissorFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExclusiveScissorFeaturesNV.html - struct PhysicalDeviceExclusiveScissorFeaturesNV - { - using NativeType = VkPhysicalDeviceExclusiveScissorFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( Bool32 exclusiveScissor_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , exclusiveScissor{ exclusiveScissor_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceExclusiveScissorFeaturesNV( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExclusiveScissorFeaturesNV( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExclusiveScissorFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExclusiveScissorFeaturesNV & operator=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExclusiveScissorFeaturesNV & operator=( VkPhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExclusiveScissorFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExclusiveScissorFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExclusiveScissorFeaturesNV & setExclusiveScissor( Bool32 exclusiveScissor_ ) & VULKAN_HPP_NOEXCEPT - { - exclusiveScissor = exclusiveScissor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExclusiveScissorFeaturesNV && setExclusiveScissor( Bool32 exclusiveScissor_ ) && VULKAN_HPP_NOEXCEPT - { - exclusiveScissor = exclusiveScissor_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExclusiveScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExclusiveScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExclusiveScissorFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExclusiveScissorFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, exclusiveScissor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExclusiveScissorFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissor == rhs.exclusiveScissor ); -# endif - } - - bool operator!=( PhysicalDeviceExclusiveScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV; - void * pNext = {}; - Bool32 exclusiveScissor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExclusiveScissorFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExclusiveScissorFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.html - struct PhysicalDeviceExtendedDynamicState2FeaturesEXT - { - using NativeType = VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicState2FeaturesEXT( Bool32 extendedDynamicState2_ = {}, - Bool32 extendedDynamicState2LogicOp_ = {}, - Bool32 extendedDynamicState2PatchControlPoints_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , extendedDynamicState2{ extendedDynamicState2_ } - , extendedDynamicState2LogicOp{ extendedDynamicState2LogicOp_ } - , extendedDynamicState2PatchControlPoints{ extendedDynamicState2PatchControlPoints_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExtendedDynamicState2FeaturesEXT( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExtendedDynamicState2FeaturesEXT( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExtendedDynamicState2FeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExtendedDynamicState2FeaturesEXT & operator=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExtendedDynamicState2FeaturesEXT & operator=( VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT & setExtendedDynamicState2( Bool32 extendedDynamicState2_ ) & VULKAN_HPP_NOEXCEPT - { - extendedDynamicState2 = extendedDynamicState2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT && setExtendedDynamicState2( Bool32 extendedDynamicState2_ ) && VULKAN_HPP_NOEXCEPT - { - extendedDynamicState2 = extendedDynamicState2_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT & setExtendedDynamicState2LogicOp( Bool32 extendedDynamicState2LogicOp_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState2LogicOp = extendedDynamicState2LogicOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT && setExtendedDynamicState2LogicOp( Bool32 extendedDynamicState2LogicOp_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState2LogicOp = extendedDynamicState2LogicOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT & - setExtendedDynamicState2PatchControlPoints( Bool32 extendedDynamicState2PatchControlPoints_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState2PatchControlPoints = extendedDynamicState2PatchControlPoints_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState2FeaturesEXT && - setExtendedDynamicState2PatchControlPoints( Bool32 extendedDynamicState2PatchControlPoints_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState2PatchControlPoints = extendedDynamicState2PatchControlPoints_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, extendedDynamicState2, extendedDynamicState2LogicOp, extendedDynamicState2PatchControlPoints ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState2 == rhs.extendedDynamicState2 ) && - ( extendedDynamicState2LogicOp == rhs.extendedDynamicState2LogicOp ) && - ( extendedDynamicState2PatchControlPoints == rhs.extendedDynamicState2PatchControlPoints ); -# endif - } - - bool operator!=( PhysicalDeviceExtendedDynamicState2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT; - void * pNext = {}; - Bool32 extendedDynamicState2 = {}; - Bool32 extendedDynamicState2LogicOp = {}; - Bool32 extendedDynamicState2PatchControlPoints = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedDynamicState2FeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedDynamicState2FeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.html - struct PhysicalDeviceExtendedDynamicState3FeaturesEXT - { - using NativeType = VkPhysicalDeviceExtendedDynamicState3FeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicState3FeaturesEXT( Bool32 extendedDynamicState3TessellationDomainOrigin_ = {}, - Bool32 extendedDynamicState3DepthClampEnable_ = {}, - Bool32 extendedDynamicState3PolygonMode_ = {}, - Bool32 extendedDynamicState3RasterizationSamples_ = {}, - Bool32 extendedDynamicState3SampleMask_ = {}, - Bool32 extendedDynamicState3AlphaToCoverageEnable_ = {}, - Bool32 extendedDynamicState3AlphaToOneEnable_ = {}, - Bool32 extendedDynamicState3LogicOpEnable_ = {}, - Bool32 extendedDynamicState3ColorBlendEnable_ = {}, - Bool32 extendedDynamicState3ColorBlendEquation_ = {}, - Bool32 extendedDynamicState3ColorWriteMask_ = {}, - Bool32 extendedDynamicState3RasterizationStream_ = {}, - Bool32 extendedDynamicState3ConservativeRasterizationMode_ = {}, - Bool32 extendedDynamicState3ExtraPrimitiveOverestimationSize_ = {}, - Bool32 extendedDynamicState3DepthClipEnable_ = {}, - Bool32 extendedDynamicState3SampleLocationsEnable_ = {}, - Bool32 extendedDynamicState3ColorBlendAdvanced_ = {}, - Bool32 extendedDynamicState3ProvokingVertexMode_ = {}, - Bool32 extendedDynamicState3LineRasterizationMode_ = {}, - Bool32 extendedDynamicState3LineStippleEnable_ = {}, - Bool32 extendedDynamicState3DepthClipNegativeOneToOne_ = {}, - Bool32 extendedDynamicState3ViewportWScalingEnable_ = {}, - Bool32 extendedDynamicState3ViewportSwizzle_ = {}, - Bool32 extendedDynamicState3CoverageToColorEnable_ = {}, - Bool32 extendedDynamicState3CoverageToColorLocation_ = {}, - Bool32 extendedDynamicState3CoverageModulationMode_ = {}, - Bool32 extendedDynamicState3CoverageModulationTableEnable_ = {}, - Bool32 extendedDynamicState3CoverageModulationTable_ = {}, - Bool32 extendedDynamicState3CoverageReductionMode_ = {}, - Bool32 extendedDynamicState3RepresentativeFragmentTestEnable_ = {}, - Bool32 extendedDynamicState3ShadingRateImageEnable_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , extendedDynamicState3TessellationDomainOrigin{ extendedDynamicState3TessellationDomainOrigin_ } - , extendedDynamicState3DepthClampEnable{ extendedDynamicState3DepthClampEnable_ } - , extendedDynamicState3PolygonMode{ extendedDynamicState3PolygonMode_ } - , extendedDynamicState3RasterizationSamples{ extendedDynamicState3RasterizationSamples_ } - , extendedDynamicState3SampleMask{ extendedDynamicState3SampleMask_ } - , extendedDynamicState3AlphaToCoverageEnable{ extendedDynamicState3AlphaToCoverageEnable_ } - , extendedDynamicState3AlphaToOneEnable{ extendedDynamicState3AlphaToOneEnable_ } - , extendedDynamicState3LogicOpEnable{ extendedDynamicState3LogicOpEnable_ } - , extendedDynamicState3ColorBlendEnable{ extendedDynamicState3ColorBlendEnable_ } - , extendedDynamicState3ColorBlendEquation{ extendedDynamicState3ColorBlendEquation_ } - , extendedDynamicState3ColorWriteMask{ extendedDynamicState3ColorWriteMask_ } - , extendedDynamicState3RasterizationStream{ extendedDynamicState3RasterizationStream_ } - , extendedDynamicState3ConservativeRasterizationMode{ extendedDynamicState3ConservativeRasterizationMode_ } - , extendedDynamicState3ExtraPrimitiveOverestimationSize{ extendedDynamicState3ExtraPrimitiveOverestimationSize_ } - , extendedDynamicState3DepthClipEnable{ extendedDynamicState3DepthClipEnable_ } - , extendedDynamicState3SampleLocationsEnable{ extendedDynamicState3SampleLocationsEnable_ } - , extendedDynamicState3ColorBlendAdvanced{ extendedDynamicState3ColorBlendAdvanced_ } - , extendedDynamicState3ProvokingVertexMode{ extendedDynamicState3ProvokingVertexMode_ } - , extendedDynamicState3LineRasterizationMode{ extendedDynamicState3LineRasterizationMode_ } - , extendedDynamicState3LineStippleEnable{ extendedDynamicState3LineStippleEnable_ } - , extendedDynamicState3DepthClipNegativeOneToOne{ extendedDynamicState3DepthClipNegativeOneToOne_ } - , extendedDynamicState3ViewportWScalingEnable{ extendedDynamicState3ViewportWScalingEnable_ } - , extendedDynamicState3ViewportSwizzle{ extendedDynamicState3ViewportSwizzle_ } - , extendedDynamicState3CoverageToColorEnable{ extendedDynamicState3CoverageToColorEnable_ } - , extendedDynamicState3CoverageToColorLocation{ extendedDynamicState3CoverageToColorLocation_ } - , extendedDynamicState3CoverageModulationMode{ extendedDynamicState3CoverageModulationMode_ } - , extendedDynamicState3CoverageModulationTableEnable{ extendedDynamicState3CoverageModulationTableEnable_ } - , extendedDynamicState3CoverageModulationTable{ extendedDynamicState3CoverageModulationTable_ } - , extendedDynamicState3CoverageReductionMode{ extendedDynamicState3CoverageReductionMode_ } - , extendedDynamicState3RepresentativeFragmentTestEnable{ extendedDynamicState3RepresentativeFragmentTestEnable_ } - , extendedDynamicState3ShadingRateImageEnable{ extendedDynamicState3ShadingRateImageEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExtendedDynamicState3FeaturesEXT( PhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExtendedDynamicState3FeaturesEXT( VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExtendedDynamicState3FeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExtendedDynamicState3FeaturesEXT & operator=( PhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExtendedDynamicState3FeaturesEXT & operator=( VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3TessellationDomainOrigin( Bool32 extendedDynamicState3TessellationDomainOrigin_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3TessellationDomainOrigin = extendedDynamicState3TessellationDomainOrigin_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3TessellationDomainOrigin( Bool32 extendedDynamicState3TessellationDomainOrigin_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3TessellationDomainOrigin = extendedDynamicState3TessellationDomainOrigin_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3DepthClampEnable( Bool32 extendedDynamicState3DepthClampEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3DepthClampEnable = extendedDynamicState3DepthClampEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3DepthClampEnable( Bool32 extendedDynamicState3DepthClampEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3DepthClampEnable = extendedDynamicState3DepthClampEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & setExtendedDynamicState3PolygonMode( Bool32 extendedDynamicState3PolygonMode_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3PolygonMode = extendedDynamicState3PolygonMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && setExtendedDynamicState3PolygonMode( Bool32 extendedDynamicState3PolygonMode_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3PolygonMode = extendedDynamicState3PolygonMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3RasterizationSamples( Bool32 extendedDynamicState3RasterizationSamples_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3RasterizationSamples = extendedDynamicState3RasterizationSamples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3RasterizationSamples( Bool32 extendedDynamicState3RasterizationSamples_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3RasterizationSamples = extendedDynamicState3RasterizationSamples_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & setExtendedDynamicState3SampleMask( Bool32 extendedDynamicState3SampleMask_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3SampleMask = extendedDynamicState3SampleMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && setExtendedDynamicState3SampleMask( Bool32 extendedDynamicState3SampleMask_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3SampleMask = extendedDynamicState3SampleMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3AlphaToCoverageEnable( Bool32 extendedDynamicState3AlphaToCoverageEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3AlphaToCoverageEnable = extendedDynamicState3AlphaToCoverageEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3AlphaToCoverageEnable( Bool32 extendedDynamicState3AlphaToCoverageEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3AlphaToCoverageEnable = extendedDynamicState3AlphaToCoverageEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3AlphaToOneEnable( Bool32 extendedDynamicState3AlphaToOneEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3AlphaToOneEnable = extendedDynamicState3AlphaToOneEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3AlphaToOneEnable( Bool32 extendedDynamicState3AlphaToOneEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3AlphaToOneEnable = extendedDynamicState3AlphaToOneEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3LogicOpEnable( Bool32 extendedDynamicState3LogicOpEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3LogicOpEnable = extendedDynamicState3LogicOpEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3LogicOpEnable( Bool32 extendedDynamicState3LogicOpEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3LogicOpEnable = extendedDynamicState3LogicOpEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3ColorBlendEnable( Bool32 extendedDynamicState3ColorBlendEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ColorBlendEnable = extendedDynamicState3ColorBlendEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3ColorBlendEnable( Bool32 extendedDynamicState3ColorBlendEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ColorBlendEnable = extendedDynamicState3ColorBlendEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3ColorBlendEquation( Bool32 extendedDynamicState3ColorBlendEquation_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ColorBlendEquation = extendedDynamicState3ColorBlendEquation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3ColorBlendEquation( Bool32 extendedDynamicState3ColorBlendEquation_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ColorBlendEquation = extendedDynamicState3ColorBlendEquation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3ColorWriteMask( Bool32 extendedDynamicState3ColorWriteMask_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ColorWriteMask = extendedDynamicState3ColorWriteMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3ColorWriteMask( Bool32 extendedDynamicState3ColorWriteMask_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ColorWriteMask = extendedDynamicState3ColorWriteMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3RasterizationStream( Bool32 extendedDynamicState3RasterizationStream_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3RasterizationStream = extendedDynamicState3RasterizationStream_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3RasterizationStream( Bool32 extendedDynamicState3RasterizationStream_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3RasterizationStream = extendedDynamicState3RasterizationStream_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3ConservativeRasterizationMode( Bool32 extendedDynamicState3ConservativeRasterizationMode_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ConservativeRasterizationMode = extendedDynamicState3ConservativeRasterizationMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3ConservativeRasterizationMode( Bool32 extendedDynamicState3ConservativeRasterizationMode_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ConservativeRasterizationMode = extendedDynamicState3ConservativeRasterizationMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3ExtraPrimitiveOverestimationSize( Bool32 extendedDynamicState3ExtraPrimitiveOverestimationSize_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ExtraPrimitiveOverestimationSize = extendedDynamicState3ExtraPrimitiveOverestimationSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3ExtraPrimitiveOverestimationSize( Bool32 extendedDynamicState3ExtraPrimitiveOverestimationSize_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ExtraPrimitiveOverestimationSize = extendedDynamicState3ExtraPrimitiveOverestimationSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3DepthClipEnable( Bool32 extendedDynamicState3DepthClipEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3DepthClipEnable = extendedDynamicState3DepthClipEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3DepthClipEnable( Bool32 extendedDynamicState3DepthClipEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3DepthClipEnable = extendedDynamicState3DepthClipEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3SampleLocationsEnable( Bool32 extendedDynamicState3SampleLocationsEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3SampleLocationsEnable = extendedDynamicState3SampleLocationsEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3SampleLocationsEnable( Bool32 extendedDynamicState3SampleLocationsEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3SampleLocationsEnable = extendedDynamicState3SampleLocationsEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3ColorBlendAdvanced( Bool32 extendedDynamicState3ColorBlendAdvanced_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ColorBlendAdvanced = extendedDynamicState3ColorBlendAdvanced_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3ColorBlendAdvanced( Bool32 extendedDynamicState3ColorBlendAdvanced_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ColorBlendAdvanced = extendedDynamicState3ColorBlendAdvanced_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3ProvokingVertexMode( Bool32 extendedDynamicState3ProvokingVertexMode_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ProvokingVertexMode = extendedDynamicState3ProvokingVertexMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3ProvokingVertexMode( Bool32 extendedDynamicState3ProvokingVertexMode_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ProvokingVertexMode = extendedDynamicState3ProvokingVertexMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3LineRasterizationMode( Bool32 extendedDynamicState3LineRasterizationMode_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3LineRasterizationMode = extendedDynamicState3LineRasterizationMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3LineRasterizationMode( Bool32 extendedDynamicState3LineRasterizationMode_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3LineRasterizationMode = extendedDynamicState3LineRasterizationMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3LineStippleEnable( Bool32 extendedDynamicState3LineStippleEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3LineStippleEnable = extendedDynamicState3LineStippleEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3LineStippleEnable( Bool32 extendedDynamicState3LineStippleEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3LineStippleEnable = extendedDynamicState3LineStippleEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3DepthClipNegativeOneToOne( Bool32 extendedDynamicState3DepthClipNegativeOneToOne_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3DepthClipNegativeOneToOne = extendedDynamicState3DepthClipNegativeOneToOne_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3DepthClipNegativeOneToOne( Bool32 extendedDynamicState3DepthClipNegativeOneToOne_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3DepthClipNegativeOneToOne = extendedDynamicState3DepthClipNegativeOneToOne_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3ViewportWScalingEnable( Bool32 extendedDynamicState3ViewportWScalingEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ViewportWScalingEnable = extendedDynamicState3ViewportWScalingEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3ViewportWScalingEnable( Bool32 extendedDynamicState3ViewportWScalingEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ViewportWScalingEnable = extendedDynamicState3ViewportWScalingEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3ViewportSwizzle( Bool32 extendedDynamicState3ViewportSwizzle_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ViewportSwizzle = extendedDynamicState3ViewportSwizzle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3ViewportSwizzle( Bool32 extendedDynamicState3ViewportSwizzle_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ViewportSwizzle = extendedDynamicState3ViewportSwizzle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3CoverageToColorEnable( Bool32 extendedDynamicState3CoverageToColorEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageToColorEnable = extendedDynamicState3CoverageToColorEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3CoverageToColorEnable( Bool32 extendedDynamicState3CoverageToColorEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageToColorEnable = extendedDynamicState3CoverageToColorEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3CoverageToColorLocation( Bool32 extendedDynamicState3CoverageToColorLocation_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageToColorLocation = extendedDynamicState3CoverageToColorLocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3CoverageToColorLocation( Bool32 extendedDynamicState3CoverageToColorLocation_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageToColorLocation = extendedDynamicState3CoverageToColorLocation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3CoverageModulationMode( Bool32 extendedDynamicState3CoverageModulationMode_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageModulationMode = extendedDynamicState3CoverageModulationMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3CoverageModulationMode( Bool32 extendedDynamicState3CoverageModulationMode_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageModulationMode = extendedDynamicState3CoverageModulationMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3CoverageModulationTableEnable( Bool32 extendedDynamicState3CoverageModulationTableEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageModulationTableEnable = extendedDynamicState3CoverageModulationTableEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3CoverageModulationTableEnable( Bool32 extendedDynamicState3CoverageModulationTableEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageModulationTableEnable = extendedDynamicState3CoverageModulationTableEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3CoverageModulationTable( Bool32 extendedDynamicState3CoverageModulationTable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageModulationTable = extendedDynamicState3CoverageModulationTable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3CoverageModulationTable( Bool32 extendedDynamicState3CoverageModulationTable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageModulationTable = extendedDynamicState3CoverageModulationTable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3CoverageReductionMode( Bool32 extendedDynamicState3CoverageReductionMode_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageReductionMode = extendedDynamicState3CoverageReductionMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3CoverageReductionMode( Bool32 extendedDynamicState3CoverageReductionMode_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3CoverageReductionMode = extendedDynamicState3CoverageReductionMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3RepresentativeFragmentTestEnable( Bool32 extendedDynamicState3RepresentativeFragmentTestEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3RepresentativeFragmentTestEnable = extendedDynamicState3RepresentativeFragmentTestEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3RepresentativeFragmentTestEnable( Bool32 extendedDynamicState3RepresentativeFragmentTestEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3RepresentativeFragmentTestEnable = extendedDynamicState3RepresentativeFragmentTestEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT & - setExtendedDynamicState3ShadingRateImageEnable( Bool32 extendedDynamicState3ShadingRateImageEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ShadingRateImageEnable = extendedDynamicState3ShadingRateImageEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicState3FeaturesEXT && - setExtendedDynamicState3ShadingRateImageEnable( Bool32 extendedDynamicState3ShadingRateImageEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedDynamicState3ShadingRateImageEnable = extendedDynamicState3ShadingRateImageEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicState3FeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicState3FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - extendedDynamicState3TessellationDomainOrigin, - extendedDynamicState3DepthClampEnable, - extendedDynamicState3PolygonMode, - extendedDynamicState3RasterizationSamples, - extendedDynamicState3SampleMask, - extendedDynamicState3AlphaToCoverageEnable, - extendedDynamicState3AlphaToOneEnable, - extendedDynamicState3LogicOpEnable, - extendedDynamicState3ColorBlendEnable, - extendedDynamicState3ColorBlendEquation, - extendedDynamicState3ColorWriteMask, - extendedDynamicState3RasterizationStream, - extendedDynamicState3ConservativeRasterizationMode, - extendedDynamicState3ExtraPrimitiveOverestimationSize, - extendedDynamicState3DepthClipEnable, - extendedDynamicState3SampleLocationsEnable, - extendedDynamicState3ColorBlendAdvanced, - extendedDynamicState3ProvokingVertexMode, - extendedDynamicState3LineRasterizationMode, - extendedDynamicState3LineStippleEnable, - extendedDynamicState3DepthClipNegativeOneToOne, - extendedDynamicState3ViewportWScalingEnable, - extendedDynamicState3ViewportSwizzle, - extendedDynamicState3CoverageToColorEnable, - extendedDynamicState3CoverageToColorLocation, - extendedDynamicState3CoverageModulationMode, - extendedDynamicState3CoverageModulationTableEnable, - extendedDynamicState3CoverageModulationTable, - extendedDynamicState3CoverageReductionMode, - extendedDynamicState3RepresentativeFragmentTestEnable, - extendedDynamicState3ShadingRateImageEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExtendedDynamicState3FeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( extendedDynamicState3TessellationDomainOrigin == rhs.extendedDynamicState3TessellationDomainOrigin ) && - ( extendedDynamicState3DepthClampEnable == rhs.extendedDynamicState3DepthClampEnable ) && - ( extendedDynamicState3PolygonMode == rhs.extendedDynamicState3PolygonMode ) && - ( extendedDynamicState3RasterizationSamples == rhs.extendedDynamicState3RasterizationSamples ) && - ( extendedDynamicState3SampleMask == rhs.extendedDynamicState3SampleMask ) && - ( extendedDynamicState3AlphaToCoverageEnable == rhs.extendedDynamicState3AlphaToCoverageEnable ) && - ( extendedDynamicState3AlphaToOneEnable == rhs.extendedDynamicState3AlphaToOneEnable ) && - ( extendedDynamicState3LogicOpEnable == rhs.extendedDynamicState3LogicOpEnable ) && - ( extendedDynamicState3ColorBlendEnable == rhs.extendedDynamicState3ColorBlendEnable ) && - ( extendedDynamicState3ColorBlendEquation == rhs.extendedDynamicState3ColorBlendEquation ) && - ( extendedDynamicState3ColorWriteMask == rhs.extendedDynamicState3ColorWriteMask ) && - ( extendedDynamicState3RasterizationStream == rhs.extendedDynamicState3RasterizationStream ) && - ( extendedDynamicState3ConservativeRasterizationMode == rhs.extendedDynamicState3ConservativeRasterizationMode ) && - ( extendedDynamicState3ExtraPrimitiveOverestimationSize == rhs.extendedDynamicState3ExtraPrimitiveOverestimationSize ) && - ( extendedDynamicState3DepthClipEnable == rhs.extendedDynamicState3DepthClipEnable ) && - ( extendedDynamicState3SampleLocationsEnable == rhs.extendedDynamicState3SampleLocationsEnable ) && - ( extendedDynamicState3ColorBlendAdvanced == rhs.extendedDynamicState3ColorBlendAdvanced ) && - ( extendedDynamicState3ProvokingVertexMode == rhs.extendedDynamicState3ProvokingVertexMode ) && - ( extendedDynamicState3LineRasterizationMode == rhs.extendedDynamicState3LineRasterizationMode ) && - ( extendedDynamicState3LineStippleEnable == rhs.extendedDynamicState3LineStippleEnable ) && - ( extendedDynamicState3DepthClipNegativeOneToOne == rhs.extendedDynamicState3DepthClipNegativeOneToOne ) && - ( extendedDynamicState3ViewportWScalingEnable == rhs.extendedDynamicState3ViewportWScalingEnable ) && - ( extendedDynamicState3ViewportSwizzle == rhs.extendedDynamicState3ViewportSwizzle ) && - ( extendedDynamicState3CoverageToColorEnable == rhs.extendedDynamicState3CoverageToColorEnable ) && - ( extendedDynamicState3CoverageToColorLocation == rhs.extendedDynamicState3CoverageToColorLocation ) && - ( extendedDynamicState3CoverageModulationMode == rhs.extendedDynamicState3CoverageModulationMode ) && - ( extendedDynamicState3CoverageModulationTableEnable == rhs.extendedDynamicState3CoverageModulationTableEnable ) && - ( extendedDynamicState3CoverageModulationTable == rhs.extendedDynamicState3CoverageModulationTable ) && - ( extendedDynamicState3CoverageReductionMode == rhs.extendedDynamicState3CoverageReductionMode ) && - ( extendedDynamicState3RepresentativeFragmentTestEnable == rhs.extendedDynamicState3RepresentativeFragmentTestEnable ) && - ( extendedDynamicState3ShadingRateImageEnable == rhs.extendedDynamicState3ShadingRateImageEnable ); -# endif - } - - bool operator!=( PhysicalDeviceExtendedDynamicState3FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT; - void * pNext = {}; - Bool32 extendedDynamicState3TessellationDomainOrigin = {}; - Bool32 extendedDynamicState3DepthClampEnable = {}; - Bool32 extendedDynamicState3PolygonMode = {}; - Bool32 extendedDynamicState3RasterizationSamples = {}; - Bool32 extendedDynamicState3SampleMask = {}; - Bool32 extendedDynamicState3AlphaToCoverageEnable = {}; - Bool32 extendedDynamicState3AlphaToOneEnable = {}; - Bool32 extendedDynamicState3LogicOpEnable = {}; - Bool32 extendedDynamicState3ColorBlendEnable = {}; - Bool32 extendedDynamicState3ColorBlendEquation = {}; - Bool32 extendedDynamicState3ColorWriteMask = {}; - Bool32 extendedDynamicState3RasterizationStream = {}; - Bool32 extendedDynamicState3ConservativeRasterizationMode = {}; - Bool32 extendedDynamicState3ExtraPrimitiveOverestimationSize = {}; - Bool32 extendedDynamicState3DepthClipEnable = {}; - Bool32 extendedDynamicState3SampleLocationsEnable = {}; - Bool32 extendedDynamicState3ColorBlendAdvanced = {}; - Bool32 extendedDynamicState3ProvokingVertexMode = {}; - Bool32 extendedDynamicState3LineRasterizationMode = {}; - Bool32 extendedDynamicState3LineStippleEnable = {}; - Bool32 extendedDynamicState3DepthClipNegativeOneToOne = {}; - Bool32 extendedDynamicState3ViewportWScalingEnable = {}; - Bool32 extendedDynamicState3ViewportSwizzle = {}; - Bool32 extendedDynamicState3CoverageToColorEnable = {}; - Bool32 extendedDynamicState3CoverageToColorLocation = {}; - Bool32 extendedDynamicState3CoverageModulationMode = {}; - Bool32 extendedDynamicState3CoverageModulationTableEnable = {}; - Bool32 extendedDynamicState3CoverageModulationTable = {}; - Bool32 extendedDynamicState3CoverageReductionMode = {}; - Bool32 extendedDynamicState3RepresentativeFragmentTestEnable = {}; - Bool32 extendedDynamicState3ShadingRateImageEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedDynamicState3FeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedDynamicState3FeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicState3PropertiesEXT.html - struct PhysicalDeviceExtendedDynamicState3PropertiesEXT - { - using NativeType = VkPhysicalDeviceExtendedDynamicState3PropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicState3PropertiesEXT( Bool32 dynamicPrimitiveTopologyUnrestricted_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dynamicPrimitiveTopologyUnrestricted{ dynamicPrimitiveTopologyUnrestricted_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExtendedDynamicState3PropertiesEXT( PhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExtendedDynamicState3PropertiesEXT( VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExtendedDynamicState3PropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExtendedDynamicState3PropertiesEXT & operator=( PhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExtendedDynamicState3PropertiesEXT & operator=( VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicState3PropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicState3PropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dynamicPrimitiveTopologyUnrestricted ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExtendedDynamicState3PropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dynamicPrimitiveTopologyUnrestricted == rhs.dynamicPrimitiveTopologyUnrestricted ); -# endif - } - - bool operator!=( PhysicalDeviceExtendedDynamicState3PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT; - void * pNext = {}; - Bool32 dynamicPrimitiveTopologyUnrestricted = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedDynamicState3PropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedDynamicState3PropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.html - struct PhysicalDeviceExtendedDynamicStateFeaturesEXT - { - using NativeType = VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedDynamicStateFeaturesEXT( Bool32 extendedDynamicState_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , extendedDynamicState{ extendedDynamicState_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExtendedDynamicStateFeaturesEXT( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExtendedDynamicStateFeaturesEXT( VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExtendedDynamicStateFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExtendedDynamicStateFeaturesEXT & operator=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExtendedDynamicStateFeaturesEXT & operator=( VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicStateFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicStateFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicStateFeaturesEXT & setExtendedDynamicState( Bool32 extendedDynamicState_ ) & VULKAN_HPP_NOEXCEPT - { - extendedDynamicState = extendedDynamicState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedDynamicStateFeaturesEXT && setExtendedDynamicState( Bool32 extendedDynamicState_ ) && VULKAN_HPP_NOEXCEPT - { - extendedDynamicState = extendedDynamicState_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, extendedDynamicState ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedDynamicState == rhs.extendedDynamicState ); -# endif - } - - bool operator!=( PhysicalDeviceExtendedDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT; - void * pNext = {}; - Bool32 extendedDynamicState = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedDynamicStateFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedDynamicStateFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.html - struct PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV - { - using NativeType = VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV( Bool32 extendedSparseAddressSpace_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , extendedSparseAddressSpace{ extendedSparseAddressSpace_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV( PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV( VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV & - operator=( PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV & operator=( VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV & setExtendedSparseAddressSpace( Bool32 extendedSparseAddressSpace_ ) & - VULKAN_HPP_NOEXCEPT - { - extendedSparseAddressSpace = extendedSparseAddressSpace_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV && setExtendedSparseAddressSpace( Bool32 extendedSparseAddressSpace_ ) && - VULKAN_HPP_NOEXCEPT - { - extendedSparseAddressSpace = extendedSparseAddressSpace_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, extendedSparseAddressSpace ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedSparseAddressSpace == rhs.extendedSparseAddressSpace ); -# endif - } - - bool operator!=( PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; - void * pNext = {}; - Bool32 extendedSparseAddressSpace = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV.html - struct PhysicalDeviceExtendedSparseAddressSpacePropertiesNV - { - using NativeType = VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExtendedSparseAddressSpacePropertiesNV( DeviceSize extendedSparseAddressSpaceSize_ = {}, - ImageUsageFlags extendedSparseImageUsageFlags_ = {}, - BufferUsageFlags extendedSparseBufferUsageFlags_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , extendedSparseAddressSpaceSize{ extendedSparseAddressSpaceSize_ } - , extendedSparseImageUsageFlags{ extendedSparseImageUsageFlags_ } - , extendedSparseBufferUsageFlags{ extendedSparseBufferUsageFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExtendedSparseAddressSpacePropertiesNV( PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExtendedSparseAddressSpacePropertiesNV( VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExtendedSparseAddressSpacePropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExtendedSparseAddressSpacePropertiesNV & - operator=( PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExtendedSparseAddressSpacePropertiesNV & operator=( VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, extendedSparseAddressSpaceSize, extendedSparseImageUsageFlags, extendedSparseBufferUsageFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( extendedSparseAddressSpaceSize == rhs.extendedSparseAddressSpaceSize ) && - ( extendedSparseImageUsageFlags == rhs.extendedSparseImageUsageFlags ) && ( extendedSparseBufferUsageFlags == rhs.extendedSparseBufferUsageFlags ); -# endif - } - - bool operator!=( PhysicalDeviceExtendedSparseAddressSpacePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV; - void * pNext = {}; - DeviceSize extendedSparseAddressSpaceSize = {}; - ImageUsageFlags extendedSparseImageUsageFlags = {}; - BufferUsageFlags extendedSparseBufferUsageFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedSparseAddressSpacePropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExtendedSparseAddressSpacePropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceExternalBufferInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalBufferInfo.html - struct PhysicalDeviceExternalBufferInfo - { - using NativeType = VkPhysicalDeviceExternalBufferInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalBufferInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( BufferCreateFlags flags_ = {}, - BufferUsageFlags usage_ = {}, - ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , usage{ usage_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalBufferInfo( PhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExternalBufferInfo( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExternalBufferInfo( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExternalBufferInfo & operator=( PhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExternalBufferInfo & operator=( VkPhysicalDeviceExternalBufferInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo & setFlags( BufferCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo && setFlags( BufferCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo & setUsage( BufferUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo && setUsage( BufferUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalBufferInfo && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExternalBufferInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalBufferInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalBufferInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalBufferInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, usage, handleType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExternalBufferInfo const & ) const = default; -#else - bool operator==( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( usage == rhs.usage ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( PhysicalDeviceExternalBufferInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExternalBufferInfo; - const void * pNext = {}; - BufferCreateFlags flags = {}; - BufferUsageFlags usage = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExternalBufferInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExternalBufferInfo; - }; - - using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; - - // wrapper struct for struct VkPhysicalDeviceExternalComputeQueuePropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalComputeQueuePropertiesNV.html - struct PhysicalDeviceExternalComputeQueuePropertiesNV - { - using NativeType = VkPhysicalDeviceExternalComputeQueuePropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalComputeQueuePropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalComputeQueuePropertiesNV( uint32_t externalDataSize_ = {}, - uint32_t maxExternalQueues_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , externalDataSize{ externalDataSize_ } - , maxExternalQueues{ maxExternalQueues_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExternalComputeQueuePropertiesNV( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExternalComputeQueuePropertiesNV( VkPhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExternalComputeQueuePropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExternalComputeQueuePropertiesNV & operator=( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExternalComputeQueuePropertiesNV & operator=( VkPhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceExternalComputeQueuePropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalComputeQueuePropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalComputeQueuePropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalComputeQueuePropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, externalDataSize, maxExternalQueues ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExternalComputeQueuePropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalDataSize == rhs.externalDataSize ) && ( maxExternalQueues == rhs.maxExternalQueues ); -# endif - } - - bool operator!=( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExternalComputeQueuePropertiesNV; - void * pNext = {}; - uint32_t externalDataSize = {}; - uint32_t maxExternalQueues = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExternalComputeQueuePropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExternalComputeQueuePropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceExternalFenceInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalFenceInfo.html - struct PhysicalDeviceExternalFenceInfo - { - using NativeType = VkPhysicalDeviceExternalFenceInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalFenceInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( ExternalFenceHandleTypeFlagBits handleType_ = ExternalFenceHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFenceInfo( PhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExternalFenceInfo( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExternalFenceInfo( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExternalFenceInfo & operator=( PhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExternalFenceInfo & operator=( VkPhysicalDeviceExternalFenceInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFenceInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFenceInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFenceInfo & setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFenceInfo && setHandleType( ExternalFenceHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExternalFenceInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalFenceInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalFenceInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalFenceInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExternalFenceInfo const & ) const = default; -#else - bool operator==( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( PhysicalDeviceExternalFenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExternalFenceInfo; - const void * pNext = {}; - ExternalFenceHandleTypeFlagBits handleType = ExternalFenceHandleTypeFlagBits::eOpaqueFd; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExternalFenceInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExternalFenceInfo; - }; - - using PhysicalDeviceExternalFenceInfoKHR = PhysicalDeviceExternalFenceInfo; - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - // wrapper struct for struct VkPhysicalDeviceExternalFormatResolveFeaturesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.html - struct PhysicalDeviceExternalFormatResolveFeaturesANDROID - { - using NativeType = VkPhysicalDeviceExternalFormatResolveFeaturesANDROID; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalFormatResolveFeaturesANDROID( Bool32 externalFormatResolve_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , externalFormatResolve{ externalFormatResolve_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExternalFormatResolveFeaturesANDROID( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExternalFormatResolveFeaturesANDROID( VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExternalFormatResolveFeaturesANDROID( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExternalFormatResolveFeaturesANDROID & - operator=( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExternalFormatResolveFeaturesANDROID & operator=( VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFormatResolveFeaturesANDROID & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFormatResolveFeaturesANDROID && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFormatResolveFeaturesANDROID & setExternalFormatResolve( Bool32 externalFormatResolve_ ) & VULKAN_HPP_NOEXCEPT - { - externalFormatResolve = externalFormatResolve_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalFormatResolveFeaturesANDROID && setExternalFormatResolve( Bool32 externalFormatResolve_ ) && - VULKAN_HPP_NOEXCEPT - { - externalFormatResolve = externalFormatResolve_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalFormatResolveFeaturesANDROID &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalFormatResolveFeaturesANDROID const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalFormatResolveFeaturesANDROID *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, externalFormatResolve ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & ) const = default; -# else - bool operator==( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalFormatResolve == rhs.externalFormatResolve ); -# endif - } - - bool operator!=( PhysicalDeviceExternalFormatResolveFeaturesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID; - void * pNext = {}; - Bool32 externalFormatResolve = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExternalFormatResolveFeaturesANDROID; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExternalFormatResolveFeaturesANDROID; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - // wrapper struct for struct VkPhysicalDeviceExternalFormatResolvePropertiesANDROID, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalFormatResolvePropertiesANDROID.html - struct PhysicalDeviceExternalFormatResolvePropertiesANDROID - { - using NativeType = VkPhysicalDeviceExternalFormatResolvePropertiesANDROID; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExternalFormatResolvePropertiesANDROID( Bool32 nullColorAttachmentWithExternalFormatResolve_ = {}, - ChromaLocation externalFormatResolveChromaOffsetX_ = ChromaLocation::eCositedEven, - ChromaLocation externalFormatResolveChromaOffsetY_ = ChromaLocation::eCositedEven, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , nullColorAttachmentWithExternalFormatResolve{ nullColorAttachmentWithExternalFormatResolve_ } - , externalFormatResolveChromaOffsetX{ externalFormatResolveChromaOffsetX_ } - , externalFormatResolveChromaOffsetY{ externalFormatResolveChromaOffsetY_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExternalFormatResolvePropertiesANDROID( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExternalFormatResolvePropertiesANDROID( VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExternalFormatResolvePropertiesANDROID( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExternalFormatResolvePropertiesANDROID & - operator=( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExternalFormatResolvePropertiesANDROID & operator=( VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalFormatResolvePropertiesANDROID &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalFormatResolvePropertiesANDROID const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalFormatResolvePropertiesANDROID *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, nullColorAttachmentWithExternalFormatResolve, externalFormatResolveChromaOffsetX, externalFormatResolveChromaOffsetY ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & ) const = default; -# else - bool operator==( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( nullColorAttachmentWithExternalFormatResolve == rhs.nullColorAttachmentWithExternalFormatResolve ) && - ( externalFormatResolveChromaOffsetX == rhs.externalFormatResolveChromaOffsetX ) && - ( externalFormatResolveChromaOffsetY == rhs.externalFormatResolveChromaOffsetY ); -# endif - } - - bool operator!=( PhysicalDeviceExternalFormatResolvePropertiesANDROID const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID; - void * pNext = {}; - Bool32 nullColorAttachmentWithExternalFormatResolve = {}; - ChromaLocation externalFormatResolveChromaOffsetX = ChromaLocation::eCositedEven; - ChromaLocation externalFormatResolveChromaOffsetY = ChromaLocation::eCositedEven; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExternalFormatResolvePropertiesANDROID; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExternalFormatResolvePropertiesANDROID; - }; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - - // wrapper struct for struct VkPhysicalDeviceExternalImageFormatInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalImageFormatInfo.html - struct PhysicalDeviceExternalImageFormatInfo - { - using NativeType = VkPhysicalDeviceExternalImageFormatInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalImageFormatInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalImageFormatInfo( PhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExternalImageFormatInfo( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExternalImageFormatInfo( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExternalImageFormatInfo & operator=( PhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExternalImageFormatInfo & operator=( VkPhysicalDeviceExternalImageFormatInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalImageFormatInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalImageFormatInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalImageFormatInfo & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalImageFormatInfo && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExternalImageFormatInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalImageFormatInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalImageFormatInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalImageFormatInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExternalImageFormatInfo const & ) const = default; -#else - bool operator==( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( PhysicalDeviceExternalImageFormatInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExternalImageFormatInfo; - const void * pNext = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExternalImageFormatInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExternalImageFormatInfo; - }; - - using PhysicalDeviceExternalImageFormatInfoKHR = PhysicalDeviceExternalImageFormatInfo; - - // wrapper struct for struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalMemoryHostPropertiesEXT.html - struct PhysicalDeviceExternalMemoryHostPropertiesEXT - { - using NativeType = VkPhysicalDeviceExternalMemoryHostPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryHostPropertiesEXT( DeviceSize minImportedHostPointerAlignment_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minImportedHostPointerAlignment{ minImportedHostPointerAlignment_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExternalMemoryHostPropertiesEXT( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExternalMemoryHostPropertiesEXT( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExternalMemoryHostPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExternalMemoryHostPropertiesEXT & operator=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExternalMemoryHostPropertiesEXT & operator=( VkPhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalMemoryHostPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minImportedHostPointerAlignment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExternalMemoryHostPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minImportedHostPointerAlignment == rhs.minImportedHostPointerAlignment ); -# endif - } - - bool operator!=( PhysicalDeviceExternalMemoryHostPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT; - void * pNext = {}; - DeviceSize minImportedHostPointerAlignment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExternalMemoryHostPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExternalMemoryHostPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.html - struct PhysicalDeviceExternalMemoryRDMAFeaturesNV - { - using NativeType = VkPhysicalDeviceExternalMemoryRDMAFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryRDMAFeaturesNV( Bool32 externalMemoryRDMA_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , externalMemoryRDMA{ externalMemoryRDMA_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryRDMAFeaturesNV( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExternalMemoryRDMAFeaturesNV( VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExternalMemoryRDMAFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExternalMemoryRDMAFeaturesNV & operator=( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExternalMemoryRDMAFeaturesNV & operator=( VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryRDMAFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryRDMAFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryRDMAFeaturesNV & setExternalMemoryRDMA( Bool32 externalMemoryRDMA_ ) & VULKAN_HPP_NOEXCEPT - { - externalMemoryRDMA = externalMemoryRDMA_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryRDMAFeaturesNV && setExternalMemoryRDMA( Bool32 externalMemoryRDMA_ ) && VULKAN_HPP_NOEXCEPT - { - externalMemoryRDMA = externalMemoryRDMA_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalMemoryRDMAFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, externalMemoryRDMA ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalMemoryRDMA == rhs.externalMemoryRDMA ); -# endif - } - - bool operator!=( PhysicalDeviceExternalMemoryRDMAFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV; - void * pNext = {}; - Bool32 externalMemoryRDMA = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExternalMemoryRDMAFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExternalMemoryRDMAFeaturesNV; - }; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - // wrapper struct for struct VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.html - struct PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX - { - using NativeType = VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( Bool32 screenBufferImport_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , screenBufferImport{ screenBufferImport_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX & - operator=( PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX & operator=( VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX & setScreenBufferImport( Bool32 screenBufferImport_ ) & VULKAN_HPP_NOEXCEPT - { - screenBufferImport = screenBufferImport_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX && setScreenBufferImport( Bool32 screenBufferImport_ ) && VULKAN_HPP_NOEXCEPT - { - screenBufferImport = screenBufferImport_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, screenBufferImport ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & ) const = default; -# else - bool operator==( PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( screenBufferImport == rhs.screenBufferImport ); -# endif - } - - bool operator!=( PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; - void * pNext = {}; - Bool32 screenBufferImport = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX; - }; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - // wrapper struct for struct VkPhysicalDeviceExternalSemaphoreInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalSemaphoreInfo.html - struct PhysicalDeviceExternalSemaphoreInfo - { - using NativeType = VkPhysicalDeviceExternalSemaphoreInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalSemaphoreInfo( PhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExternalSemaphoreInfo( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExternalSemaphoreInfo( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExternalSemaphoreInfo & operator=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExternalSemaphoreInfo & operator=( VkPhysicalDeviceExternalSemaphoreInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalSemaphoreInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalSemaphoreInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalSemaphoreInfo & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalSemaphoreInfo && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExternalSemaphoreInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalSemaphoreInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalSemaphoreInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalSemaphoreInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, handleType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExternalSemaphoreInfo const & ) const = default; -#else - bool operator==( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( PhysicalDeviceExternalSemaphoreInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExternalSemaphoreInfo; - const void * pNext = {}; - ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExternalSemaphoreInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExternalSemaphoreInfo; - }; - - using PhysicalDeviceExternalSemaphoreInfoKHR = PhysicalDeviceExternalSemaphoreInfo; - - // wrapper struct for struct VkPhysicalDeviceExternalTensorInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalTensorInfoARM.html - struct PhysicalDeviceExternalTensorInfoARM - { - using NativeType = VkPhysicalDeviceExternalTensorInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalTensorInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalTensorInfoARM( TensorCreateFlagsARM flags_ = {}, - const TensorDescriptionARM * pDescription_ = {}, - ExternalMemoryHandleTypeFlagBits handleType_ = ExternalMemoryHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pDescription{ pDescription_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalTensorInfoARM( PhysicalDeviceExternalTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceExternalTensorInfoARM( VkPhysicalDeviceExternalTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceExternalTensorInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceExternalTensorInfoARM & operator=( PhysicalDeviceExternalTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceExternalTensorInfoARM & operator=( VkPhysicalDeviceExternalTensorInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM & setFlags( TensorCreateFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM && setFlags( TensorCreateFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM & setPDescription( const TensorDescriptionARM * pDescription_ ) & VULKAN_HPP_NOEXCEPT - { - pDescription = pDescription_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM && setPDescription( const TensorDescriptionARM * pDescription_ ) && VULKAN_HPP_NOEXCEPT - { - pDescription = pDescription_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM & setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceExternalTensorInfoARM && setHandleType( ExternalMemoryHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceExternalTensorInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalTensorInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalTensorInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceExternalTensorInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, pDescription, handleType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceExternalTensorInfoARM const & ) const = default; -#else - bool operator==( PhysicalDeviceExternalTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pDescription == rhs.pDescription ) && - ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( PhysicalDeviceExternalTensorInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceExternalTensorInfoARM; - const void * pNext = {}; - TensorCreateFlagsARM flags = {}; - const TensorDescriptionARM * pDescription = {}; - ExternalMemoryHandleTypeFlagBits handleType = ExternalMemoryHandleTypeFlagBits::eOpaqueFd; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceExternalTensorInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceExternalTensorInfoARM; - }; - - // wrapper struct for struct VkPhysicalDeviceFaultFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFaultFeaturesEXT.html - struct PhysicalDeviceFaultFeaturesEXT - { - using NativeType = VkPhysicalDeviceFaultFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFaultFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFaultFeaturesEXT( Bool32 deviceFault_ = {}, Bool32 deviceFaultVendorBinary_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceFault{ deviceFault_ } - , deviceFaultVendorBinary{ deviceFaultVendorBinary_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceFaultFeaturesEXT( PhysicalDeviceFaultFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFaultFeaturesEXT( VkPhysicalDeviceFaultFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFaultFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFaultFeaturesEXT & operator=( PhysicalDeviceFaultFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFaultFeaturesEXT & operator=( VkPhysicalDeviceFaultFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT & setDeviceFault( Bool32 deviceFault_ ) & VULKAN_HPP_NOEXCEPT - { - deviceFault = deviceFault_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT && setDeviceFault( Bool32 deviceFault_ ) && VULKAN_HPP_NOEXCEPT - { - deviceFault = deviceFault_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT & setDeviceFaultVendorBinary( Bool32 deviceFaultVendorBinary_ ) & VULKAN_HPP_NOEXCEPT - { - deviceFaultVendorBinary = deviceFaultVendorBinary_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFaultFeaturesEXT && setDeviceFaultVendorBinary( Bool32 deviceFaultVendorBinary_ ) && VULKAN_HPP_NOEXCEPT - { - deviceFaultVendorBinary = deviceFaultVendorBinary_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFaultFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFaultFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFaultFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFaultFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceFault, deviceFaultVendorBinary ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFaultFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceFaultFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceFault == rhs.deviceFault ) && - ( deviceFaultVendorBinary == rhs.deviceFaultVendorBinary ); -# endif - } - - bool operator!=( PhysicalDeviceFaultFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFaultFeaturesEXT; - void * pNext = {}; - Bool32 deviceFault = {}; - Bool32 deviceFaultVendorBinary = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFaultFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFaultFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceFeatures2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFeatures2.html - struct PhysicalDeviceFeatures2 - { - using NativeType = VkPhysicalDeviceFeatures2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFeatures2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( PhysicalDeviceFeatures features_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , features{ features_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceFeatures2( PhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFeatures2( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFeatures2( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFeatures2 & operator=( PhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFeatures2 & operator=( VkPhysicalDeviceFeatures2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures2 & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures2 && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures2 & setFeatures( PhysicalDeviceFeatures const & features_ ) & VULKAN_HPP_NOEXCEPT - { - features = features_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFeatures2 && setFeatures( PhysicalDeviceFeatures const & features_ ) && VULKAN_HPP_NOEXCEPT - { - features = features_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFeatures2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFeatures2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFeatures2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFeatures2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, features ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFeatures2 const & ) const = default; -#else - bool operator==( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( features == rhs.features ); -# endif - } - - bool operator!=( PhysicalDeviceFeatures2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFeatures2; - void * pNext = {}; - PhysicalDeviceFeatures features = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFeatures2; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFeatures2; - }; - - using PhysicalDeviceFeatures2KHR = PhysicalDeviceFeatures2; - - // wrapper struct for struct VkPhysicalDeviceFloatControlsProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFloatControlsProperties.html - struct PhysicalDeviceFloatControlsProperties - { - using NativeType = VkPhysicalDeviceFloatControlsProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFloatControlsProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFloatControlsProperties( ShaderFloatControlsIndependence denormBehaviorIndependence_ = ShaderFloatControlsIndependence::e32BitOnly, - ShaderFloatControlsIndependence roundingModeIndependence_ = ShaderFloatControlsIndependence::e32BitOnly, - Bool32 shaderSignedZeroInfNanPreserveFloat16_ = {}, - Bool32 shaderSignedZeroInfNanPreserveFloat32_ = {}, - Bool32 shaderSignedZeroInfNanPreserveFloat64_ = {}, - Bool32 shaderDenormPreserveFloat16_ = {}, - Bool32 shaderDenormPreserveFloat32_ = {}, - Bool32 shaderDenormPreserveFloat64_ = {}, - Bool32 shaderDenormFlushToZeroFloat16_ = {}, - Bool32 shaderDenormFlushToZeroFloat32_ = {}, - Bool32 shaderDenormFlushToZeroFloat64_ = {}, - Bool32 shaderRoundingModeRTEFloat16_ = {}, - Bool32 shaderRoundingModeRTEFloat32_ = {}, - Bool32 shaderRoundingModeRTEFloat64_ = {}, - Bool32 shaderRoundingModeRTZFloat16_ = {}, - Bool32 shaderRoundingModeRTZFloat32_ = {}, - Bool32 shaderRoundingModeRTZFloat64_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , denormBehaviorIndependence{ denormBehaviorIndependence_ } - , roundingModeIndependence{ roundingModeIndependence_ } - , shaderSignedZeroInfNanPreserveFloat16{ shaderSignedZeroInfNanPreserveFloat16_ } - , shaderSignedZeroInfNanPreserveFloat32{ shaderSignedZeroInfNanPreserveFloat32_ } - , shaderSignedZeroInfNanPreserveFloat64{ shaderSignedZeroInfNanPreserveFloat64_ } - , shaderDenormPreserveFloat16{ shaderDenormPreserveFloat16_ } - , shaderDenormPreserveFloat32{ shaderDenormPreserveFloat32_ } - , shaderDenormPreserveFloat64{ shaderDenormPreserveFloat64_ } - , shaderDenormFlushToZeroFloat16{ shaderDenormFlushToZeroFloat16_ } - , shaderDenormFlushToZeroFloat32{ shaderDenormFlushToZeroFloat32_ } - , shaderDenormFlushToZeroFloat64{ shaderDenormFlushToZeroFloat64_ } - , shaderRoundingModeRTEFloat16{ shaderRoundingModeRTEFloat16_ } - , shaderRoundingModeRTEFloat32{ shaderRoundingModeRTEFloat32_ } - , shaderRoundingModeRTEFloat64{ shaderRoundingModeRTEFloat64_ } - , shaderRoundingModeRTZFloat16{ shaderRoundingModeRTZFloat16_ } - , shaderRoundingModeRTZFloat32{ shaderRoundingModeRTZFloat32_ } - , shaderRoundingModeRTZFloat64{ shaderRoundingModeRTZFloat64_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceFloatControlsProperties( PhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFloatControlsProperties( VkPhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFloatControlsProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFloatControlsProperties & operator=( PhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFloatControlsProperties & operator=( VkPhysicalDeviceFloatControlsProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceFloatControlsProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFloatControlsProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFloatControlsProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFloatControlsProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - denormBehaviorIndependence, - roundingModeIndependence, - shaderSignedZeroInfNanPreserveFloat16, - shaderSignedZeroInfNanPreserveFloat32, - shaderSignedZeroInfNanPreserveFloat64, - shaderDenormPreserveFloat16, - shaderDenormPreserveFloat32, - shaderDenormPreserveFloat64, - shaderDenormFlushToZeroFloat16, - shaderDenormFlushToZeroFloat32, - shaderDenormFlushToZeroFloat64, - shaderRoundingModeRTEFloat16, - shaderRoundingModeRTEFloat32, - shaderRoundingModeRTEFloat64, - shaderRoundingModeRTZFloat16, - shaderRoundingModeRTZFloat32, - shaderRoundingModeRTZFloat64 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFloatControlsProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) && - ( roundingModeIndependence == rhs.roundingModeIndependence ) && - ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) && - ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) && - ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) && - ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) && ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) && - ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) && ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) && - ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) && - ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) && ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) && - ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) && ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) && - ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) && ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) && - ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 ); -# endif - } - - bool operator!=( PhysicalDeviceFloatControlsProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFloatControlsProperties; - void * pNext = {}; - ShaderFloatControlsIndependence denormBehaviorIndependence = ShaderFloatControlsIndependence::e32BitOnly; - ShaderFloatControlsIndependence roundingModeIndependence = ShaderFloatControlsIndependence::e32BitOnly; - Bool32 shaderSignedZeroInfNanPreserveFloat16 = {}; - Bool32 shaderSignedZeroInfNanPreserveFloat32 = {}; - Bool32 shaderSignedZeroInfNanPreserveFloat64 = {}; - Bool32 shaderDenormPreserveFloat16 = {}; - Bool32 shaderDenormPreserveFloat32 = {}; - Bool32 shaderDenormPreserveFloat64 = {}; - Bool32 shaderDenormFlushToZeroFloat16 = {}; - Bool32 shaderDenormFlushToZeroFloat32 = {}; - Bool32 shaderDenormFlushToZeroFloat64 = {}; - Bool32 shaderRoundingModeRTEFloat16 = {}; - Bool32 shaderRoundingModeRTEFloat32 = {}; - Bool32 shaderRoundingModeRTEFloat64 = {}; - Bool32 shaderRoundingModeRTZFloat16 = {}; - Bool32 shaderRoundingModeRTZFloat32 = {}; - Bool32 shaderRoundingModeRTZFloat64 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFloatControlsProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFloatControlsProperties; - }; - - using PhysicalDeviceFloatControlsPropertiesKHR = PhysicalDeviceFloatControlsProperties; - - // wrapper struct for struct VkPhysicalDeviceFormatPackFeaturesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFormatPackFeaturesARM.html - struct PhysicalDeviceFormatPackFeaturesARM - { - using NativeType = VkPhysicalDeviceFormatPackFeaturesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFormatPackFeaturesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFormatPackFeaturesARM( Bool32 formatPack_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , formatPack{ formatPack_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceFormatPackFeaturesARM( PhysicalDeviceFormatPackFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFormatPackFeaturesARM( VkPhysicalDeviceFormatPackFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFormatPackFeaturesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFormatPackFeaturesARM & operator=( PhysicalDeviceFormatPackFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFormatPackFeaturesARM & operator=( VkPhysicalDeviceFormatPackFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFormatPackFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFormatPackFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFormatPackFeaturesARM & setFormatPack( Bool32 formatPack_ ) & VULKAN_HPP_NOEXCEPT - { - formatPack = formatPack_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFormatPackFeaturesARM && setFormatPack( Bool32 formatPack_ ) && VULKAN_HPP_NOEXCEPT - { - formatPack = formatPack_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFormatPackFeaturesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFormatPackFeaturesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFormatPackFeaturesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFormatPackFeaturesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, formatPack ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFormatPackFeaturesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceFormatPackFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatPack == rhs.formatPack ); -# endif - } - - bool operator!=( PhysicalDeviceFormatPackFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFormatPackFeaturesARM; - void * pNext = {}; - Bool32 formatPack = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFormatPackFeaturesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFormatPackFeaturesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.html - struct PhysicalDeviceFragmentDensityMap2FeaturesEXT - { - using NativeType = VkPhysicalDeviceFragmentDensityMap2FeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMap2FeaturesEXT( Bool32 fragmentDensityMapDeferred_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fragmentDensityMapDeferred{ fragmentDensityMapDeferred_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMap2FeaturesEXT( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentDensityMap2FeaturesEXT( VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentDensityMap2FeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentDensityMap2FeaturesEXT & operator=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentDensityMap2FeaturesEXT & operator=( VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMap2FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMap2FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMap2FeaturesEXT & setFragmentDensityMapDeferred( Bool32 fragmentDensityMapDeferred_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapDeferred = fragmentDensityMapDeferred_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMap2FeaturesEXT && setFragmentDensityMapDeferred( Bool32 fragmentDensityMapDeferred_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapDeferred = fragmentDensityMapDeferred_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fragmentDensityMapDeferred ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMapDeferred == rhs.fragmentDensityMapDeferred ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentDensityMap2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT; - void * pNext = {}; - Bool32 fragmentDensityMapDeferred = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMap2FeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMap2FeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.html - struct PhysicalDeviceFragmentDensityMap2PropertiesEXT - { - using NativeType = VkPhysicalDeviceFragmentDensityMap2PropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMap2PropertiesEXT( Bool32 subsampledLoads_ = {}, - Bool32 subsampledCoarseReconstructionEarlyAccess_ = {}, - uint32_t maxSubsampledArrayLayers_ = {}, - uint32_t maxDescriptorSetSubsampledSamplers_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , subsampledLoads{ subsampledLoads_ } - , subsampledCoarseReconstructionEarlyAccess{ subsampledCoarseReconstructionEarlyAccess_ } - , maxSubsampledArrayLayers{ maxSubsampledArrayLayers_ } - , maxDescriptorSetSubsampledSamplers{ maxDescriptorSetSubsampledSamplers_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentDensityMap2PropertiesEXT( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentDensityMap2PropertiesEXT( VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentDensityMap2PropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentDensityMap2PropertiesEXT & operator=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentDensityMap2PropertiesEXT & operator=( VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, subsampledLoads, subsampledCoarseReconstructionEarlyAccess, maxSubsampledArrayLayers, maxDescriptorSetSubsampledSamplers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledLoads == rhs.subsampledLoads ) && - ( subsampledCoarseReconstructionEarlyAccess == rhs.subsampledCoarseReconstructionEarlyAccess ) && - ( maxSubsampledArrayLayers == rhs.maxSubsampledArrayLayers ) && ( maxDescriptorSetSubsampledSamplers == rhs.maxDescriptorSetSubsampledSamplers ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentDensityMap2PropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT; - void * pNext = {}; - Bool32 subsampledLoads = {}; - Bool32 subsampledCoarseReconstructionEarlyAccess = {}; - uint32_t maxSubsampledArrayLayers = {}; - uint32_t maxDescriptorSetSubsampledSamplers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMap2PropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMap2PropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapFeaturesEXT.html - struct PhysicalDeviceFragmentDensityMapFeaturesEXT - { - using NativeType = VkPhysicalDeviceFragmentDensityMapFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapFeaturesEXT( Bool32 fragmentDensityMap_ = {}, - Bool32 fragmentDensityMapDynamic_ = {}, - Bool32 fragmentDensityMapNonSubsampledImages_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fragmentDensityMap{ fragmentDensityMap_ } - , fragmentDensityMapDynamic{ fragmentDensityMapDynamic_ } - , fragmentDensityMapNonSubsampledImages{ fragmentDensityMapNonSubsampledImages_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapFeaturesEXT( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentDensityMapFeaturesEXT( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentDensityMapFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentDensityMapFeaturesEXT & operator=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentDensityMapFeaturesEXT & operator=( VkPhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT & setFragmentDensityMap( Bool32 fragmentDensityMap_ ) & VULKAN_HPP_NOEXCEPT - { - fragmentDensityMap = fragmentDensityMap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT && setFragmentDensityMap( Bool32 fragmentDensityMap_ ) && VULKAN_HPP_NOEXCEPT - { - fragmentDensityMap = fragmentDensityMap_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT & setFragmentDensityMapDynamic( Bool32 fragmentDensityMapDynamic_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapDynamic = fragmentDensityMapDynamic_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT && setFragmentDensityMapDynamic( Bool32 fragmentDensityMapDynamic_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapDynamic = fragmentDensityMapDynamic_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT & - setFragmentDensityMapNonSubsampledImages( Bool32 fragmentDensityMapNonSubsampledImages_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapNonSubsampledImages = fragmentDensityMapNonSubsampledImages_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapFeaturesEXT && - setFragmentDensityMapNonSubsampledImages( Bool32 fragmentDensityMapNonSubsampledImages_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapNonSubsampledImages = fragmentDensityMapNonSubsampledImages_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fragmentDensityMap, fragmentDensityMapDynamic, fragmentDensityMapNonSubsampledImages ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentDensityMapFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMap == rhs.fragmentDensityMap ) && - ( fragmentDensityMapDynamic == rhs.fragmentDensityMapDynamic ) && - ( fragmentDensityMapNonSubsampledImages == rhs.fragmentDensityMapNonSubsampledImages ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentDensityMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT; - void * pNext = {}; - Bool32 fragmentDensityMap = {}; - Bool32 fragmentDensityMapDynamic = {}; - Bool32 fragmentDensityMapNonSubsampledImages = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE.html - struct PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE - { - using NativeType = VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE( Bool32 fragmentDensityMapLayered_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fragmentDensityMapLayered{ fragmentDensityMapLayered_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE( VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & - operator=( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & operator=( VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE & setFragmentDensityMapLayered( Bool32 fragmentDensityMapLayered_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapLayered = fragmentDensityMapLayered_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE && setFragmentDensityMapLayered( Bool32 fragmentDensityMapLayered_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapLayered = fragmentDensityMapLayered_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fragmentDensityMapLayered ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMapLayered == rhs.fragmentDensityMapLayered ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; - void * pNext = {}; - Bool32 fragmentDensityMapLayered = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE.html - struct PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE - { - using NativeType = VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE( uint32_t maxFragmentDensityMapLayers_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxFragmentDensityMapLayers{ maxFragmentDensityMapLayers_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE( VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE & - operator=( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE & - operator=( VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxFragmentDensityMapLayers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxFragmentDensityMapLayers == rhs.maxFragmentDensityMapLayers ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; - void * pNext = {}; - uint32_t maxFragmentDensityMapLayers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.html - struct PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT - { - using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( Bool32 fragmentDensityMapOffset_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fragmentDensityMapOffset{ fragmentDensityMapOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & - operator=( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & operator=( VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT & setFragmentDensityMapOffset( Bool32 fragmentDensityMapOffset_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapOffset = fragmentDensityMapOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT && setFragmentDensityMapOffset( Bool32 fragmentDensityMapOffset_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapOffset = fragmentDensityMapOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fragmentDensityMapOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMapOffset == rhs.fragmentDensityMapOffset ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; - void * pNext = {}; - Bool32 fragmentDensityMapOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; - }; - - using PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT; - - // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.html - struct PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT - { - using NativeType = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( Extent2D fragmentDensityOffsetGranularity_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fragmentDensityOffsetGranularity{ fragmentDensityOffsetGranularity_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT & - operator=( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT & operator=( VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fragmentDensityOffsetGranularity ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityOffsetGranularity == rhs.fragmentDensityOffsetGranularity ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; - void * pNext = {}; - Extent2D fragmentDensityOffsetGranularity = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; - }; - - using PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT; - - // wrapper struct for struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentDensityMapPropertiesEXT.html - struct PhysicalDeviceFragmentDensityMapPropertiesEXT - { - using NativeType = VkPhysicalDeviceFragmentDensityMapPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentDensityMapPropertiesEXT( Extent2D minFragmentDensityTexelSize_ = {}, - Extent2D maxFragmentDensityTexelSize_ = {}, - Bool32 fragmentDensityInvocations_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minFragmentDensityTexelSize{ minFragmentDensityTexelSize_ } - , maxFragmentDensityTexelSize{ maxFragmentDensityTexelSize_ } - , fragmentDensityInvocations{ fragmentDensityInvocations_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentDensityMapPropertiesEXT( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentDensityMapPropertiesEXT( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentDensityMapPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentDensityMapPropertiesEXT & operator=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentDensityMapPropertiesEXT & operator=( VkPhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentDensityMapPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minFragmentDensityTexelSize, maxFragmentDensityTexelSize, fragmentDensityInvocations ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentDensityMapPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minFragmentDensityTexelSize == rhs.minFragmentDensityTexelSize ) && - ( maxFragmentDensityTexelSize == rhs.maxFragmentDensityTexelSize ) && ( fragmentDensityInvocations == rhs.fragmentDensityInvocations ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentDensityMapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT; - void * pNext = {}; - Extent2D minFragmentDensityTexelSize = {}; - Extent2D maxFragmentDensityTexelSize = {}; - Bool32 fragmentDensityInvocations = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentDensityMapPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.html - struct PhysicalDeviceFragmentShaderBarycentricFeaturesKHR - { - using NativeType = VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricFeaturesKHR( Bool32 fragmentShaderBarycentric_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fragmentShaderBarycentric{ fragmentShaderBarycentric_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentShaderBarycentricFeaturesKHR( PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentShaderBarycentricFeaturesKHR( VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentShaderBarycentricFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentShaderBarycentricFeaturesKHR & - operator=( PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentShaderBarycentricFeaturesKHR & operator=( VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderBarycentricFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderBarycentricFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderBarycentricFeaturesKHR & setFragmentShaderBarycentric( Bool32 fragmentShaderBarycentric_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentShaderBarycentric = fragmentShaderBarycentric_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderBarycentricFeaturesKHR && setFragmentShaderBarycentric( Bool32 fragmentShaderBarycentric_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentShaderBarycentric = fragmentShaderBarycentric_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fragmentShaderBarycentric ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentShaderBarycentric == rhs.fragmentShaderBarycentric ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentShaderBarycentricFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR; - void * pNext = {}; - Bool32 fragmentShaderBarycentric = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; - }; - - using PhysicalDeviceFragmentShaderBarycentricFeaturesNV = PhysicalDeviceFragmentShaderBarycentricFeaturesKHR; - - // wrapper struct for struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR.html - struct PhysicalDeviceFragmentShaderBarycentricPropertiesKHR - { - using NativeType = VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderBarycentricPropertiesKHR( Bool32 triStripVertexOrderIndependentOfProvokingVertex_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , triStripVertexOrderIndependentOfProvokingVertex{ triStripVertexOrderIndependentOfProvokingVertex_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentShaderBarycentricPropertiesKHR( PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentShaderBarycentricPropertiesKHR( VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentShaderBarycentricPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentShaderBarycentricPropertiesKHR & - operator=( PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentShaderBarycentricPropertiesKHR & operator=( VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, triStripVertexOrderIndependentOfProvokingVertex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( triStripVertexOrderIndependentOfProvokingVertex == rhs.triStripVertexOrderIndependentOfProvokingVertex ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentShaderBarycentricPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR; - void * pNext = {}; - Bool32 triStripVertexOrderIndependentOfProvokingVertex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShaderBarycentricPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShaderBarycentricPropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.html - struct PhysicalDeviceFragmentShaderInterlockFeaturesEXT - { - using NativeType = VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShaderInterlockFeaturesEXT( Bool32 fragmentShaderSampleInterlock_ = {}, - Bool32 fragmentShaderPixelInterlock_ = {}, - Bool32 fragmentShaderShadingRateInterlock_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fragmentShaderSampleInterlock{ fragmentShaderSampleInterlock_ } - , fragmentShaderPixelInterlock{ fragmentShaderPixelInterlock_ } - , fragmentShaderShadingRateInterlock{ fragmentShaderShadingRateInterlock_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentShaderInterlockFeaturesEXT( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentShaderInterlockFeaturesEXT( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentShaderInterlockFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentShaderInterlockFeaturesEXT & operator=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentShaderInterlockFeaturesEXT & operator=( VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderSampleInterlock( Bool32 fragmentShaderSampleInterlock_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentShaderSampleInterlock = fragmentShaderSampleInterlock_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT && setFragmentShaderSampleInterlock( Bool32 fragmentShaderSampleInterlock_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentShaderSampleInterlock = fragmentShaderSampleInterlock_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT & setFragmentShaderPixelInterlock( Bool32 fragmentShaderPixelInterlock_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentShaderPixelInterlock = fragmentShaderPixelInterlock_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT && setFragmentShaderPixelInterlock( Bool32 fragmentShaderPixelInterlock_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentShaderPixelInterlock = fragmentShaderPixelInterlock_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT & - setFragmentShaderShadingRateInterlock( Bool32 fragmentShaderShadingRateInterlock_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentShaderShadingRateInterlock = fragmentShaderShadingRateInterlock_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShaderInterlockFeaturesEXT && - setFragmentShaderShadingRateInterlock( Bool32 fragmentShaderShadingRateInterlock_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentShaderShadingRateInterlock = fragmentShaderShadingRateInterlock_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fragmentShaderSampleInterlock, fragmentShaderPixelInterlock, fragmentShaderShadingRateInterlock ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentShaderSampleInterlock == rhs.fragmentShaderSampleInterlock ) && - ( fragmentShaderPixelInterlock == rhs.fragmentShaderPixelInterlock ) && - ( fragmentShaderShadingRateInterlock == rhs.fragmentShaderShadingRateInterlock ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentShaderInterlockFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT; - void * pNext = {}; - Bool32 fragmentShaderSampleInterlock = {}; - Bool32 fragmentShaderPixelInterlock = {}; - Bool32 fragmentShaderShadingRateInterlock = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.html - struct PhysicalDeviceFragmentShadingRateEnumsFeaturesNV - { - using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShadingRateEnumsFeaturesNV( Bool32 fragmentShadingRateEnums_ = {}, - Bool32 supersampleFragmentShadingRates_ = {}, - Bool32 noInvocationFragmentShadingRates_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fragmentShadingRateEnums{ fragmentShadingRateEnums_ } - , supersampleFragmentShadingRates{ supersampleFragmentShadingRates_ } - , noInvocationFragmentShadingRates{ noInvocationFragmentShadingRates_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentShadingRateEnumsFeaturesNV( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentShadingRateEnumsFeaturesNV( VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentShadingRateEnumsFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & operator=( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & operator=( VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & setFragmentShadingRateEnums( Bool32 fragmentShadingRateEnums_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentShadingRateEnums = fragmentShadingRateEnums_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV && setFragmentShadingRateEnums( Bool32 fragmentShadingRateEnums_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentShadingRateEnums = fragmentShadingRateEnums_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & setSupersampleFragmentShadingRates( Bool32 supersampleFragmentShadingRates_ ) & - VULKAN_HPP_NOEXCEPT - { - supersampleFragmentShadingRates = supersampleFragmentShadingRates_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV && setSupersampleFragmentShadingRates( Bool32 supersampleFragmentShadingRates_ ) && - VULKAN_HPP_NOEXCEPT - { - supersampleFragmentShadingRates = supersampleFragmentShadingRates_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV & setNoInvocationFragmentShadingRates( Bool32 noInvocationFragmentShadingRates_ ) & - VULKAN_HPP_NOEXCEPT - { - noInvocationFragmentShadingRates = noInvocationFragmentShadingRates_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateEnumsFeaturesNV && - setNoInvocationFragmentShadingRates( Bool32 noInvocationFragmentShadingRates_ ) && - VULKAN_HPP_NOEXCEPT - { - noInvocationFragmentShadingRates = noInvocationFragmentShadingRates_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fragmentShadingRateEnums, supersampleFragmentShadingRates, noInvocationFragmentShadingRates ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentShadingRateEnums == rhs.fragmentShadingRateEnums ) && - ( supersampleFragmentShadingRates == rhs.supersampleFragmentShadingRates ) && - ( noInvocationFragmentShadingRates == rhs.noInvocationFragmentShadingRates ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentShadingRateEnumsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV; - void * pNext = {}; - Bool32 fragmentShadingRateEnums = {}; - Bool32 supersampleFragmentShadingRates = {}; - Bool32 noInvocationFragmentShadingRates = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShadingRateEnumsFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.html - struct PhysicalDeviceFragmentShadingRateEnumsPropertiesNV - { - using NativeType = VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentShadingRateEnumsPropertiesNV( SampleCountFlagBits maxFragmentShadingRateInvocationCount_ = SampleCountFlagBits::e1, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxFragmentShadingRateInvocationCount{ maxFragmentShadingRateInvocationCount_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentShadingRateEnumsPropertiesNV( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentShadingRateEnumsPropertiesNV( VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentShadingRateEnumsPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentShadingRateEnumsPropertiesNV & - operator=( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentShadingRateEnumsPropertiesNV & operator=( VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxFragmentShadingRateInvocationCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxFragmentShadingRateInvocationCount == rhs.maxFragmentShadingRateInvocationCount ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentShadingRateEnumsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV; - void * pNext = {}; - SampleCountFlagBits maxFragmentShadingRateInvocationCount = SampleCountFlagBits::e1; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShadingRateEnumsPropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateFeaturesKHR.html - struct PhysicalDeviceFragmentShadingRateFeaturesKHR - { - using NativeType = VkPhysicalDeviceFragmentShadingRateFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShadingRateFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShadingRateFeaturesKHR( Bool32 pipelineFragmentShadingRate_ = {}, - Bool32 primitiveFragmentShadingRate_ = {}, - Bool32 attachmentFragmentShadingRate_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineFragmentShadingRate{ pipelineFragmentShadingRate_ } - , primitiveFragmentShadingRate{ primitiveFragmentShadingRate_ } - , attachmentFragmentShadingRate{ attachmentFragmentShadingRate_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShadingRateFeaturesKHR( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentShadingRateFeaturesKHR( VkPhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentShadingRateFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentShadingRateFeaturesKHR & operator=( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentShadingRateFeaturesKHR & operator=( VkPhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR & setPipelineFragmentShadingRate( Bool32 pipelineFragmentShadingRate_ ) & - VULKAN_HPP_NOEXCEPT - { - pipelineFragmentShadingRate = pipelineFragmentShadingRate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR && setPipelineFragmentShadingRate( Bool32 pipelineFragmentShadingRate_ ) && - VULKAN_HPP_NOEXCEPT - { - pipelineFragmentShadingRate = pipelineFragmentShadingRate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR & setPrimitiveFragmentShadingRate( Bool32 primitiveFragmentShadingRate_ ) & - VULKAN_HPP_NOEXCEPT - { - primitiveFragmentShadingRate = primitiveFragmentShadingRate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR && setPrimitiveFragmentShadingRate( Bool32 primitiveFragmentShadingRate_ ) && - VULKAN_HPP_NOEXCEPT - { - primitiveFragmentShadingRate = primitiveFragmentShadingRate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR & setAttachmentFragmentShadingRate( Bool32 attachmentFragmentShadingRate_ ) & - VULKAN_HPP_NOEXCEPT - { - attachmentFragmentShadingRate = attachmentFragmentShadingRate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFragmentShadingRateFeaturesKHR && setAttachmentFragmentShadingRate( Bool32 attachmentFragmentShadingRate_ ) && - VULKAN_HPP_NOEXCEPT - { - attachmentFragmentShadingRate = attachmentFragmentShadingRate_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineFragmentShadingRate, primitiveFragmentShadingRate, attachmentFragmentShadingRate ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentShadingRateFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineFragmentShadingRate == rhs.pipelineFragmentShadingRate ) && - ( primitiveFragmentShadingRate == rhs.primitiveFragmentShadingRate ) && ( attachmentFragmentShadingRate == rhs.attachmentFragmentShadingRate ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentShadingRateFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentShadingRateFeaturesKHR; - void * pNext = {}; - Bool32 pipelineFragmentShadingRate = {}; - Bool32 primitiveFragmentShadingRate = {}; - Bool32 attachmentFragmentShadingRate = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShadingRateFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShadingRateFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentShadingRateKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRateKHR.html - struct PhysicalDeviceFragmentShadingRateKHR - { - using NativeType = VkPhysicalDeviceFragmentShadingRateKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShadingRateKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentShadingRateKHR( SampleCountFlags sampleCounts_ = {}, Extent2D fragmentSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , sampleCounts{ sampleCounts_ } - , fragmentSize{ fragmentSize_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceFragmentShadingRateKHR( PhysicalDeviceFragmentShadingRateKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentShadingRateKHR( VkPhysicalDeviceFragmentShadingRateKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentShadingRateKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentShadingRateKHR & operator=( PhysicalDeviceFragmentShadingRateKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentShadingRateKHR & operator=( VkPhysicalDeviceFragmentShadingRateKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceFragmentShadingRateKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRateKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, sampleCounts, fragmentSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentShadingRateKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleCounts == rhs.sampleCounts ) && ( fragmentSize == rhs.fragmentSize ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentShadingRateKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentShadingRateKHR; - void * pNext = {}; - SampleCountFlags sampleCounts = {}; - Extent2D fragmentSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShadingRateKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShadingRateKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFragmentShadingRatePropertiesKHR.html - struct PhysicalDeviceFragmentShadingRatePropertiesKHR - { - using NativeType = VkPhysicalDeviceFragmentShadingRatePropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFragmentShadingRatePropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentShadingRatePropertiesKHR( Extent2D minFragmentShadingRateAttachmentTexelSize_ = {}, - Extent2D maxFragmentShadingRateAttachmentTexelSize_ = {}, - uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio_ = {}, - Bool32 primitiveFragmentShadingRateWithMultipleViewports_ = {}, - Bool32 layeredShadingRateAttachments_ = {}, - Bool32 fragmentShadingRateNonTrivialCombinerOps_ = {}, - Extent2D maxFragmentSize_ = {}, - uint32_t maxFragmentSizeAspectRatio_ = {}, - uint32_t maxFragmentShadingRateCoverageSamples_ = {}, - SampleCountFlagBits maxFragmentShadingRateRasterizationSamples_ = SampleCountFlagBits::e1, - Bool32 fragmentShadingRateWithShaderDepthStencilWrites_ = {}, - Bool32 fragmentShadingRateWithSampleMask_ = {}, - Bool32 fragmentShadingRateWithShaderSampleMask_ = {}, - Bool32 fragmentShadingRateWithConservativeRasterization_ = {}, - Bool32 fragmentShadingRateWithFragmentShaderInterlock_ = {}, - Bool32 fragmentShadingRateWithCustomSampleLocations_ = {}, - Bool32 fragmentShadingRateStrictMultiplyCombiner_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minFragmentShadingRateAttachmentTexelSize{ minFragmentShadingRateAttachmentTexelSize_ } - , maxFragmentShadingRateAttachmentTexelSize{ maxFragmentShadingRateAttachmentTexelSize_ } - , maxFragmentShadingRateAttachmentTexelSizeAspectRatio{ maxFragmentShadingRateAttachmentTexelSizeAspectRatio_ } - , primitiveFragmentShadingRateWithMultipleViewports{ primitiveFragmentShadingRateWithMultipleViewports_ } - , layeredShadingRateAttachments{ layeredShadingRateAttachments_ } - , fragmentShadingRateNonTrivialCombinerOps{ fragmentShadingRateNonTrivialCombinerOps_ } - , maxFragmentSize{ maxFragmentSize_ } - , maxFragmentSizeAspectRatio{ maxFragmentSizeAspectRatio_ } - , maxFragmentShadingRateCoverageSamples{ maxFragmentShadingRateCoverageSamples_ } - , maxFragmentShadingRateRasterizationSamples{ maxFragmentShadingRateRasterizationSamples_ } - , fragmentShadingRateWithShaderDepthStencilWrites{ fragmentShadingRateWithShaderDepthStencilWrites_ } - , fragmentShadingRateWithSampleMask{ fragmentShadingRateWithSampleMask_ } - , fragmentShadingRateWithShaderSampleMask{ fragmentShadingRateWithShaderSampleMask_ } - , fragmentShadingRateWithConservativeRasterization{ fragmentShadingRateWithConservativeRasterization_ } - , fragmentShadingRateWithFragmentShaderInterlock{ fragmentShadingRateWithFragmentShaderInterlock_ } - , fragmentShadingRateWithCustomSampleLocations{ fragmentShadingRateWithCustomSampleLocations_ } - , fragmentShadingRateStrictMultiplyCombiner{ fragmentShadingRateStrictMultiplyCombiner_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceFragmentShadingRatePropertiesKHR( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFragmentShadingRatePropertiesKHR( VkPhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFragmentShadingRatePropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFragmentShadingRatePropertiesKHR & operator=( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFragmentShadingRatePropertiesKHR & operator=( VkPhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFragmentShadingRatePropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - minFragmentShadingRateAttachmentTexelSize, - maxFragmentShadingRateAttachmentTexelSize, - maxFragmentShadingRateAttachmentTexelSizeAspectRatio, - primitiveFragmentShadingRateWithMultipleViewports, - layeredShadingRateAttachments, - fragmentShadingRateNonTrivialCombinerOps, - maxFragmentSize, - maxFragmentSizeAspectRatio, - maxFragmentShadingRateCoverageSamples, - maxFragmentShadingRateRasterizationSamples, - fragmentShadingRateWithShaderDepthStencilWrites, - fragmentShadingRateWithSampleMask, - fragmentShadingRateWithShaderSampleMask, - fragmentShadingRateWithConservativeRasterization, - fragmentShadingRateWithFragmentShaderInterlock, - fragmentShadingRateWithCustomSampleLocations, - fragmentShadingRateStrictMultiplyCombiner ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFragmentShadingRatePropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( minFragmentShadingRateAttachmentTexelSize == rhs.minFragmentShadingRateAttachmentTexelSize ) && - ( maxFragmentShadingRateAttachmentTexelSize == rhs.maxFragmentShadingRateAttachmentTexelSize ) && - ( maxFragmentShadingRateAttachmentTexelSizeAspectRatio == rhs.maxFragmentShadingRateAttachmentTexelSizeAspectRatio ) && - ( primitiveFragmentShadingRateWithMultipleViewports == rhs.primitiveFragmentShadingRateWithMultipleViewports ) && - ( layeredShadingRateAttachments == rhs.layeredShadingRateAttachments ) && - ( fragmentShadingRateNonTrivialCombinerOps == rhs.fragmentShadingRateNonTrivialCombinerOps ) && ( maxFragmentSize == rhs.maxFragmentSize ) && - ( maxFragmentSizeAspectRatio == rhs.maxFragmentSizeAspectRatio ) && - ( maxFragmentShadingRateCoverageSamples == rhs.maxFragmentShadingRateCoverageSamples ) && - ( maxFragmentShadingRateRasterizationSamples == rhs.maxFragmentShadingRateRasterizationSamples ) && - ( fragmentShadingRateWithShaderDepthStencilWrites == rhs.fragmentShadingRateWithShaderDepthStencilWrites ) && - ( fragmentShadingRateWithSampleMask == rhs.fragmentShadingRateWithSampleMask ) && - ( fragmentShadingRateWithShaderSampleMask == rhs.fragmentShadingRateWithShaderSampleMask ) && - ( fragmentShadingRateWithConservativeRasterization == rhs.fragmentShadingRateWithConservativeRasterization ) && - ( fragmentShadingRateWithFragmentShaderInterlock == rhs.fragmentShadingRateWithFragmentShaderInterlock ) && - ( fragmentShadingRateWithCustomSampleLocations == rhs.fragmentShadingRateWithCustomSampleLocations ) && - ( fragmentShadingRateStrictMultiplyCombiner == rhs.fragmentShadingRateStrictMultiplyCombiner ); -# endif - } - - bool operator!=( PhysicalDeviceFragmentShadingRatePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFragmentShadingRatePropertiesKHR; - void * pNext = {}; - Extent2D minFragmentShadingRateAttachmentTexelSize = {}; - Extent2D maxFragmentShadingRateAttachmentTexelSize = {}; - uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio = {}; - Bool32 primitiveFragmentShadingRateWithMultipleViewports = {}; - Bool32 layeredShadingRateAttachments = {}; - Bool32 fragmentShadingRateNonTrivialCombinerOps = {}; - Extent2D maxFragmentSize = {}; - uint32_t maxFragmentSizeAspectRatio = {}; - uint32_t maxFragmentShadingRateCoverageSamples = {}; - SampleCountFlagBits maxFragmentShadingRateRasterizationSamples = SampleCountFlagBits::e1; - Bool32 fragmentShadingRateWithShaderDepthStencilWrites = {}; - Bool32 fragmentShadingRateWithSampleMask = {}; - Bool32 fragmentShadingRateWithShaderSampleMask = {}; - Bool32 fragmentShadingRateWithConservativeRasterization = {}; - Bool32 fragmentShadingRateWithFragmentShaderInterlock = {}; - Bool32 fragmentShadingRateWithCustomSampleLocations = {}; - Bool32 fragmentShadingRateStrictMultiplyCombiner = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShadingRatePropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFragmentShadingRatePropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceFrameBoundaryFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceFrameBoundaryFeaturesEXT.html - struct PhysicalDeviceFrameBoundaryFeaturesEXT - { - using NativeType = VkPhysicalDeviceFrameBoundaryFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceFrameBoundaryFeaturesEXT( Bool32 frameBoundary_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , frameBoundary{ frameBoundary_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceFrameBoundaryFeaturesEXT( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceFrameBoundaryFeaturesEXT( VkPhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceFrameBoundaryFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceFrameBoundaryFeaturesEXT & operator=( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceFrameBoundaryFeaturesEXT & operator=( VkPhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT & setFrameBoundary( Bool32 frameBoundary_ ) & VULKAN_HPP_NOEXCEPT - { - frameBoundary = frameBoundary_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceFrameBoundaryFeaturesEXT && setFrameBoundary( Bool32 frameBoundary_ ) && VULKAN_HPP_NOEXCEPT - { - frameBoundary = frameBoundary_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceFrameBoundaryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFrameBoundaryFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFrameBoundaryFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceFrameBoundaryFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, frameBoundary ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceFrameBoundaryFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( frameBoundary == rhs.frameBoundary ); -# endif - } - - bool operator!=( PhysicalDeviceFrameBoundaryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT; - void * pNext = {}; - Bool32 frameBoundary = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceFrameBoundaryFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceFrameBoundaryFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceGlobalPriorityQueryFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGlobalPriorityQueryFeatures.html - struct PhysicalDeviceGlobalPriorityQueryFeatures - { - using NativeType = VkPhysicalDeviceGlobalPriorityQueryFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGlobalPriorityQueryFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceGlobalPriorityQueryFeatures( Bool32 globalPriorityQuery_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , globalPriorityQuery{ globalPriorityQuery_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceGlobalPriorityQueryFeatures( PhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceGlobalPriorityQueryFeatures( VkPhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceGlobalPriorityQueryFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceGlobalPriorityQueryFeatures & operator=( PhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceGlobalPriorityQueryFeatures & operator=( VkPhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGlobalPriorityQueryFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGlobalPriorityQueryFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGlobalPriorityQueryFeatures & setGlobalPriorityQuery( Bool32 globalPriorityQuery_ ) & VULKAN_HPP_NOEXCEPT - { - globalPriorityQuery = globalPriorityQuery_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGlobalPriorityQueryFeatures && setGlobalPriorityQuery( Bool32 globalPriorityQuery_ ) && VULKAN_HPP_NOEXCEPT - { - globalPriorityQuery = globalPriorityQuery_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceGlobalPriorityQueryFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGlobalPriorityQueryFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGlobalPriorityQueryFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGlobalPriorityQueryFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, globalPriorityQuery ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceGlobalPriorityQueryFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriorityQuery == rhs.globalPriorityQuery ); -# endif - } - - bool operator!=( PhysicalDeviceGlobalPriorityQueryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceGlobalPriorityQueryFeatures; - void * pNext = {}; - Bool32 globalPriorityQuery = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceGlobalPriorityQueryFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceGlobalPriorityQueryFeatures; - }; - - using PhysicalDeviceGlobalPriorityQueryFeaturesEXT = PhysicalDeviceGlobalPriorityQueryFeatures; - using PhysicalDeviceGlobalPriorityQueryFeaturesKHR = PhysicalDeviceGlobalPriorityQueryFeatures; - - // wrapper struct for struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.html - struct PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT - { - using NativeType = VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT( Bool32 graphicsPipelineLibrary_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , graphicsPipelineLibrary{ graphicsPipelineLibrary_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT( PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT( VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT & operator=( PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT & operator=( VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT & setGraphicsPipelineLibrary( Bool32 graphicsPipelineLibrary_ ) & - VULKAN_HPP_NOEXCEPT - { - graphicsPipelineLibrary = graphicsPipelineLibrary_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT && setGraphicsPipelineLibrary( Bool32 graphicsPipelineLibrary_ ) && - VULKAN_HPP_NOEXCEPT - { - graphicsPipelineLibrary = graphicsPipelineLibrary_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, graphicsPipelineLibrary ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( graphicsPipelineLibrary == rhs.graphicsPipelineLibrary ); -# endif - } - - bool operator!=( PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; - void * pNext = {}; - Bool32 graphicsPipelineLibrary = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.html - struct PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT - { - using NativeType = VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT( Bool32 graphicsPipelineLibraryFastLinking_ = {}, - Bool32 graphicsPipelineLibraryIndependentInterpolationDecoration_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , graphicsPipelineLibraryFastLinking{ graphicsPipelineLibraryFastLinking_ } - , graphicsPipelineLibraryIndependentInterpolationDecoration{ graphicsPipelineLibraryIndependentInterpolationDecoration_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT( PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT( VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT & - operator=( PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT & operator=( VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, graphicsPipelineLibraryFastLinking, graphicsPipelineLibraryIndependentInterpolationDecoration ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( graphicsPipelineLibraryFastLinking == rhs.graphicsPipelineLibraryFastLinking ) && - ( graphicsPipelineLibraryIndependentInterpolationDecoration == rhs.graphicsPipelineLibraryIndependentInterpolationDecoration ); -# endif - } - - bool operator!=( PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; - void * pNext = {}; - Bool32 graphicsPipelineLibraryFastLinking = {}; - Bool32 graphicsPipelineLibraryIndependentInterpolationDecoration = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceGroupProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceGroupProperties.html - struct PhysicalDeviceGroupProperties - { - using NativeType = VkPhysicalDeviceGroupProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceGroupProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGroupProperties( uint32_t physicalDeviceCount_ = {}, - std::array const & physicalDevices_ = {}, - Bool32 subsetAllocation_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , physicalDeviceCount{ physicalDeviceCount_ } - , physicalDevices{ physicalDevices_ } - , subsetAllocation{ subsetAllocation_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceGroupProperties( PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceGroupProperties( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceGroupProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceGroupProperties & operator=( PhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceGroupProperties & operator=( VkPhysicalDeviceGroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceGroupProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGroupProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGroupProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceGroupProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, Bool32 const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, physicalDeviceCount, physicalDevices, subsetAllocation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = physicalDeviceCount <=> rhs.physicalDeviceCount; cmp != 0 ) - return cmp; - for ( size_t i = 0; i < physicalDeviceCount; ++i ) - { - if ( auto cmp = physicalDevices[i] <=> rhs.physicalDevices[i]; cmp != 0 ) - return cmp; - } - if ( auto cmp = subsetAllocation <=> rhs.subsetAllocation; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( physicalDeviceCount == rhs.physicalDeviceCount ) && - ( memcmp( physicalDevices, rhs.physicalDevices, physicalDeviceCount * sizeof( PhysicalDevice ) ) == 0 ) && - ( subsetAllocation == rhs.subsetAllocation ); - } - - bool operator!=( PhysicalDeviceGroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::ePhysicalDeviceGroupProperties; - void * pNext = {}; - uint32_t physicalDeviceCount = {}; - ArrayWrapper1D physicalDevices = {}; - Bool32 subsetAllocation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceGroupProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceGroupProperties; - }; - - using PhysicalDeviceGroupPropertiesKHR = PhysicalDeviceGroupProperties; - - // wrapper struct for struct VkPhysicalDeviceHdrVividFeaturesHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceHdrVividFeaturesHUAWEI.html - struct PhysicalDeviceHdrVividFeaturesHUAWEI - { - using NativeType = VkPhysicalDeviceHdrVividFeaturesHUAWEI; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceHdrVividFeaturesHUAWEI; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceHdrVividFeaturesHUAWEI( Bool32 hdrVivid_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , hdrVivid{ hdrVivid_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceHdrVividFeaturesHUAWEI( PhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceHdrVividFeaturesHUAWEI( VkPhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceHdrVividFeaturesHUAWEI( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceHdrVividFeaturesHUAWEI & operator=( PhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceHdrVividFeaturesHUAWEI & operator=( VkPhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHdrVividFeaturesHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHdrVividFeaturesHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHdrVividFeaturesHUAWEI & setHdrVivid( Bool32 hdrVivid_ ) & VULKAN_HPP_NOEXCEPT - { - hdrVivid = hdrVivid_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHdrVividFeaturesHUAWEI && setHdrVivid( Bool32 hdrVivid_ ) && VULKAN_HPP_NOEXCEPT - { - hdrVivid = hdrVivid_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceHdrVividFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHdrVividFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHdrVividFeaturesHUAWEI const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHdrVividFeaturesHUAWEI *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, hdrVivid ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceHdrVividFeaturesHUAWEI const & ) const = default; -#else - bool operator==( PhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hdrVivid == rhs.hdrVivid ); -# endif - } - - bool operator!=( PhysicalDeviceHdrVividFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceHdrVividFeaturesHUAWEI; - void * pNext = {}; - Bool32 hdrVivid = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceHdrVividFeaturesHUAWEI; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceHdrVividFeaturesHUAWEI; - }; - - // wrapper struct for struct VkPhysicalDeviceHostImageCopyFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceHostImageCopyFeatures.html - struct PhysicalDeviceHostImageCopyFeatures - { - using NativeType = VkPhysicalDeviceHostImageCopyFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceHostImageCopyFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceHostImageCopyFeatures( Bool32 hostImageCopy_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , hostImageCopy{ hostImageCopy_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceHostImageCopyFeatures( PhysicalDeviceHostImageCopyFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceHostImageCopyFeatures( VkPhysicalDeviceHostImageCopyFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceHostImageCopyFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceHostImageCopyFeatures & operator=( PhysicalDeviceHostImageCopyFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceHostImageCopyFeatures & operator=( VkPhysicalDeviceHostImageCopyFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyFeatures & setHostImageCopy( Bool32 hostImageCopy_ ) & VULKAN_HPP_NOEXCEPT - { - hostImageCopy = hostImageCopy_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyFeatures && setHostImageCopy( Bool32 hostImageCopy_ ) && VULKAN_HPP_NOEXCEPT - { - hostImageCopy = hostImageCopy_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceHostImageCopyFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHostImageCopyFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHostImageCopyFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHostImageCopyFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, hostImageCopy ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceHostImageCopyFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceHostImageCopyFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostImageCopy == rhs.hostImageCopy ); -# endif - } - - bool operator!=( PhysicalDeviceHostImageCopyFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceHostImageCopyFeatures; - void * pNext = {}; - Bool32 hostImageCopy = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceHostImageCopyFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceHostImageCopyFeatures; - }; - - using PhysicalDeviceHostImageCopyFeaturesEXT = PhysicalDeviceHostImageCopyFeatures; - - // wrapper struct for struct VkPhysicalDeviceHostImageCopyProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceHostImageCopyProperties.html - struct PhysicalDeviceHostImageCopyProperties - { - using NativeType = VkPhysicalDeviceHostImageCopyProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceHostImageCopyProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties( uint32_t copySrcLayoutCount_ = {}, - ImageLayout * pCopySrcLayouts_ = {}, - uint32_t copyDstLayoutCount_ = {}, - ImageLayout * pCopyDstLayouts_ = {}, - std::array const & optimalTilingLayoutUUID_ = {}, - Bool32 identicalMemoryTypeRequirements_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , copySrcLayoutCount{ copySrcLayoutCount_ } - , pCopySrcLayouts{ pCopySrcLayouts_ } - , copyDstLayoutCount{ copyDstLayoutCount_ } - , pCopyDstLayouts{ pCopyDstLayouts_ } - , optimalTilingLayoutUUID{ optimalTilingLayoutUUID_ } - , identicalMemoryTypeRequirements{ identicalMemoryTypeRequirements_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties( PhysicalDeviceHostImageCopyProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceHostImageCopyProperties( VkPhysicalDeviceHostImageCopyProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceHostImageCopyProperties( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PhysicalDeviceHostImageCopyProperties( ArrayProxyNoTemporaries const & copySrcLayouts_, - ArrayProxyNoTemporaries const & copyDstLayouts_ = {}, - std::array const & optimalTilingLayoutUUID_ = {}, - Bool32 identicalMemoryTypeRequirements_ = {}, - void * pNext_ = nullptr ) - : pNext( pNext_ ) - , copySrcLayoutCount( static_cast( copySrcLayouts_.size() ) ) - , pCopySrcLayouts( copySrcLayouts_.data() ) - , copyDstLayoutCount( static_cast( copyDstLayouts_.size() ) ) - , pCopyDstLayouts( copyDstLayouts_.data() ) - , optimalTilingLayoutUUID( optimalTilingLayoutUUID_ ) - , identicalMemoryTypeRequirements( identicalMemoryTypeRequirements_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PhysicalDeviceHostImageCopyProperties & operator=( PhysicalDeviceHostImageCopyProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceHostImageCopyProperties & operator=( VkPhysicalDeviceHostImageCopyProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setCopySrcLayoutCount( uint32_t copySrcLayoutCount_ ) & VULKAN_HPP_NOEXCEPT - { - copySrcLayoutCount = copySrcLayoutCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setCopySrcLayoutCount( uint32_t copySrcLayoutCount_ ) && VULKAN_HPP_NOEXCEPT - { - copySrcLayoutCount = copySrcLayoutCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setPCopySrcLayouts( ImageLayout * pCopySrcLayouts_ ) & VULKAN_HPP_NOEXCEPT - { - pCopySrcLayouts = pCopySrcLayouts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setPCopySrcLayouts( ImageLayout * pCopySrcLayouts_ ) && VULKAN_HPP_NOEXCEPT - { - pCopySrcLayouts = pCopySrcLayouts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PhysicalDeviceHostImageCopyProperties & setCopySrcLayouts( ArrayProxyNoTemporaries const & copySrcLayouts_ ) VULKAN_HPP_NOEXCEPT - { - copySrcLayoutCount = static_cast( copySrcLayouts_.size() ); - pCopySrcLayouts = copySrcLayouts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setCopyDstLayoutCount( uint32_t copyDstLayoutCount_ ) & VULKAN_HPP_NOEXCEPT - { - copyDstLayoutCount = copyDstLayoutCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setCopyDstLayoutCount( uint32_t copyDstLayoutCount_ ) && VULKAN_HPP_NOEXCEPT - { - copyDstLayoutCount = copyDstLayoutCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setPCopyDstLayouts( ImageLayout * pCopyDstLayouts_ ) & VULKAN_HPP_NOEXCEPT - { - pCopyDstLayouts = pCopyDstLayouts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setPCopyDstLayouts( ImageLayout * pCopyDstLayouts_ ) && VULKAN_HPP_NOEXCEPT - { - pCopyDstLayouts = pCopyDstLayouts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PhysicalDeviceHostImageCopyProperties & setCopyDstLayouts( ArrayProxyNoTemporaries const & copyDstLayouts_ ) VULKAN_HPP_NOEXCEPT - { - copyDstLayoutCount = static_cast( copyDstLayouts_.size() ); - pCopyDstLayouts = copyDstLayouts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setOptimalTilingLayoutUUID( std::array optimalTilingLayoutUUID_ ) & - VULKAN_HPP_NOEXCEPT - { - optimalTilingLayoutUUID = optimalTilingLayoutUUID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setOptimalTilingLayoutUUID( std::array optimalTilingLayoutUUID_ ) && - VULKAN_HPP_NOEXCEPT - { - optimalTilingLayoutUUID = optimalTilingLayoutUUID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties & setIdenticalMemoryTypeRequirements( Bool32 identicalMemoryTypeRequirements_ ) & - VULKAN_HPP_NOEXCEPT - { - identicalMemoryTypeRequirements = identicalMemoryTypeRequirements_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostImageCopyProperties && setIdenticalMemoryTypeRequirements( Bool32 identicalMemoryTypeRequirements_ ) && - VULKAN_HPP_NOEXCEPT - { - identicalMemoryTypeRequirements = identicalMemoryTypeRequirements_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceHostImageCopyProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHostImageCopyProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHostImageCopyProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHostImageCopyProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - Bool32 const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, copySrcLayoutCount, pCopySrcLayouts, copyDstLayoutCount, pCopyDstLayouts, optimalTilingLayoutUUID, identicalMemoryTypeRequirements ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceHostImageCopyProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceHostImageCopyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( copySrcLayoutCount == rhs.copySrcLayoutCount ) && - ( pCopySrcLayouts == rhs.pCopySrcLayouts ) && ( copyDstLayoutCount == rhs.copyDstLayoutCount ) && ( pCopyDstLayouts == rhs.pCopyDstLayouts ) && - ( optimalTilingLayoutUUID == rhs.optimalTilingLayoutUUID ) && ( identicalMemoryTypeRequirements == rhs.identicalMemoryTypeRequirements ); -# endif - } - - bool operator!=( PhysicalDeviceHostImageCopyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceHostImageCopyProperties; - void * pNext = {}; - uint32_t copySrcLayoutCount = {}; - ImageLayout * pCopySrcLayouts = {}; - uint32_t copyDstLayoutCount = {}; - ImageLayout * pCopyDstLayouts = {}; - ArrayWrapper1D optimalTilingLayoutUUID = {}; - Bool32 identicalMemoryTypeRequirements = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceHostImageCopyProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceHostImageCopyProperties; - }; - - using PhysicalDeviceHostImageCopyPropertiesEXT = PhysicalDeviceHostImageCopyProperties; - - // wrapper struct for struct VkPhysicalDeviceHostQueryResetFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceHostQueryResetFeatures.html - struct PhysicalDeviceHostQueryResetFeatures - { - using NativeType = VkPhysicalDeviceHostQueryResetFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceHostQueryResetFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeatures( Bool32 hostQueryReset_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , hostQueryReset{ hostQueryReset_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceHostQueryResetFeatures( PhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceHostQueryResetFeatures( VkPhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceHostQueryResetFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceHostQueryResetFeatures & operator=( PhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceHostQueryResetFeatures & operator=( VkPhysicalDeviceHostQueryResetFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostQueryResetFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostQueryResetFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostQueryResetFeatures & setHostQueryReset( Bool32 hostQueryReset_ ) & VULKAN_HPP_NOEXCEPT - { - hostQueryReset = hostQueryReset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceHostQueryResetFeatures && setHostQueryReset( Bool32 hostQueryReset_ ) && VULKAN_HPP_NOEXCEPT - { - hostQueryReset = hostQueryReset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceHostQueryResetFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHostQueryResetFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHostQueryResetFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceHostQueryResetFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, hostQueryReset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceHostQueryResetFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hostQueryReset == rhs.hostQueryReset ); -# endif - } - - bool operator!=( PhysicalDeviceHostQueryResetFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceHostQueryResetFeatures; - void * pNext = {}; - Bool32 hostQueryReset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceHostQueryResetFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceHostQueryResetFeatures; - }; - - using PhysicalDeviceHostQueryResetFeaturesEXT = PhysicalDeviceHostQueryResetFeatures; - - // wrapper struct for struct VkPhysicalDeviceIDProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceIDProperties.html - struct PhysicalDeviceIDProperties - { - using NativeType = VkPhysicalDeviceIDProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceIdProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIDProperties( std::array const & deviceUUID_ = {}, - std::array const & driverUUID_ = {}, - std::array const & deviceLUID_ = {}, - uint32_t deviceNodeMask_ = {}, - Bool32 deviceLUIDValid_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceUUID{ deviceUUID_ } - , driverUUID{ driverUUID_ } - , deviceLUID{ deviceLUID_ } - , deviceNodeMask{ deviceNodeMask_ } - , deviceLUIDValid{ deviceLUIDValid_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIDProperties( PhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceIDProperties( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceIDProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceIDProperties & operator=( PhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceIDProperties & operator=( VkPhysicalDeviceIDProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceIDProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceIDProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceIDProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceIDProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &, - ArrayWrapper1D const &, - uint32_t const &, - Bool32 const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, deviceUUID, driverUUID, deviceLUID, deviceNodeMask, deviceLUIDValid ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceIDProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) && ( driverUUID == rhs.driverUUID ) && - ( deviceLUID == rhs.deviceLUID ) && ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ); -# endif - } - - bool operator!=( PhysicalDeviceIDProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceIdProperties; - void * pNext = {}; - ArrayWrapper1D deviceUUID = {}; - ArrayWrapper1D driverUUID = {}; - ArrayWrapper1D deviceLUID = {}; - uint32_t deviceNodeMask = {}; - Bool32 deviceLUIDValid = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceIDProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceIDProperties; - }; - - using PhysicalDeviceIDPropertiesKHR = PhysicalDeviceIDProperties; - - // wrapper struct for struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.html - struct PhysicalDeviceImage2DViewOf3DFeaturesEXT - { - using NativeType = VkPhysicalDeviceImage2DViewOf3DFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceImage2DViewOf3DFeaturesEXT( Bool32 image2DViewOf3D_ = {}, Bool32 sampler2DViewOf3D_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , image2DViewOf3D{ image2DViewOf3D_ } - , sampler2DViewOf3D{ sampler2DViewOf3D_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImage2DViewOf3DFeaturesEXT( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImage2DViewOf3DFeaturesEXT( VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImage2DViewOf3DFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImage2DViewOf3DFeaturesEXT & operator=( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImage2DViewOf3DFeaturesEXT & operator=( VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT & setImage2DViewOf3D( Bool32 image2DViewOf3D_ ) & VULKAN_HPP_NOEXCEPT - { - image2DViewOf3D = image2DViewOf3D_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT && setImage2DViewOf3D( Bool32 image2DViewOf3D_ ) && VULKAN_HPP_NOEXCEPT - { - image2DViewOf3D = image2DViewOf3D_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT & setSampler2DViewOf3D( Bool32 sampler2DViewOf3D_ ) & VULKAN_HPP_NOEXCEPT - { - sampler2DViewOf3D = sampler2DViewOf3D_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImage2DViewOf3DFeaturesEXT && setSampler2DViewOf3D( Bool32 sampler2DViewOf3D_ ) && VULKAN_HPP_NOEXCEPT - { - sampler2DViewOf3D = sampler2DViewOf3D_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImage2DViewOf3DFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImage2DViewOf3DFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, image2DViewOf3D, sampler2DViewOf3D ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image2DViewOf3D == rhs.image2DViewOf3D ) && ( sampler2DViewOf3D == rhs.sampler2DViewOf3D ); -# endif - } - - bool operator!=( PhysicalDeviceImage2DViewOf3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT; - void * pNext = {}; - Bool32 image2DViewOf3D = {}; - Bool32 sampler2DViewOf3D = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImage2DViewOf3DFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImage2DViewOf3DFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageAlignmentControlFeaturesMESA.html - struct PhysicalDeviceImageAlignmentControlFeaturesMESA - { - using NativeType = VkPhysicalDeviceImageAlignmentControlFeaturesMESA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageAlignmentControlFeaturesMESA( Bool32 imageAlignmentControl_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageAlignmentControl{ imageAlignmentControl_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceImageAlignmentControlFeaturesMESA( PhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageAlignmentControlFeaturesMESA( VkPhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageAlignmentControlFeaturesMESA( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageAlignmentControlFeaturesMESA & operator=( PhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageAlignmentControlFeaturesMESA & operator=( VkPhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageAlignmentControlFeaturesMESA & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageAlignmentControlFeaturesMESA && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageAlignmentControlFeaturesMESA & setImageAlignmentControl( Bool32 imageAlignmentControl_ ) & VULKAN_HPP_NOEXCEPT - { - imageAlignmentControl = imageAlignmentControl_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageAlignmentControlFeaturesMESA && setImageAlignmentControl( Bool32 imageAlignmentControl_ ) && VULKAN_HPP_NOEXCEPT - { - imageAlignmentControl = imageAlignmentControl_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImageAlignmentControlFeaturesMESA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageAlignmentControlFeaturesMESA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageAlignmentControlFeaturesMESA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageAlignmentControlFeaturesMESA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageAlignmentControl ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageAlignmentControlFeaturesMESA const & ) const = default; -#else - bool operator==( PhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageAlignmentControl == rhs.imageAlignmentControl ); -# endif - } - - bool operator!=( PhysicalDeviceImageAlignmentControlFeaturesMESA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA; - void * pNext = {}; - Bool32 imageAlignmentControl = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageAlignmentControlFeaturesMESA; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageAlignmentControlFeaturesMESA; - }; - - // wrapper struct for struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageAlignmentControlPropertiesMESA.html - struct PhysicalDeviceImageAlignmentControlPropertiesMESA - { - using NativeType = VkPhysicalDeviceImageAlignmentControlPropertiesMESA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageAlignmentControlPropertiesMESA( uint32_t supportedImageAlignmentMask_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , supportedImageAlignmentMask{ supportedImageAlignmentMask_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceImageAlignmentControlPropertiesMESA( PhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageAlignmentControlPropertiesMESA( VkPhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageAlignmentControlPropertiesMESA( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageAlignmentControlPropertiesMESA & - operator=( PhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageAlignmentControlPropertiesMESA & operator=( VkPhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceImageAlignmentControlPropertiesMESA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageAlignmentControlPropertiesMESA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageAlignmentControlPropertiesMESA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageAlignmentControlPropertiesMESA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, supportedImageAlignmentMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageAlignmentControlPropertiesMESA const & ) const = default; -#else - bool operator==( PhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedImageAlignmentMask == rhs.supportedImageAlignmentMask ); -# endif - } - - bool operator!=( PhysicalDeviceImageAlignmentControlPropertiesMESA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA; - void * pNext = {}; - uint32_t supportedImageAlignmentMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageAlignmentControlPropertiesMESA; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageAlignmentControlPropertiesMESA; - }; - - // wrapper struct for struct VkPhysicalDeviceImageCompressionControlFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageCompressionControlFeaturesEXT.html - struct PhysicalDeviceImageCompressionControlFeaturesEXT - { - using NativeType = VkPhysicalDeviceImageCompressionControlFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageCompressionControlFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageCompressionControlFeaturesEXT( Bool32 imageCompressionControl_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageCompressionControl{ imageCompressionControl_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceImageCompressionControlFeaturesEXT( PhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageCompressionControlFeaturesEXT( VkPhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageCompressionControlFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageCompressionControlFeaturesEXT & operator=( PhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageCompressionControlFeaturesEXT & operator=( VkPhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlFeaturesEXT & setImageCompressionControl( Bool32 imageCompressionControl_ ) & - VULKAN_HPP_NOEXCEPT - { - imageCompressionControl = imageCompressionControl_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlFeaturesEXT && setImageCompressionControl( Bool32 imageCompressionControl_ ) && - VULKAN_HPP_NOEXCEPT - { - imageCompressionControl = imageCompressionControl_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImageCompressionControlFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageCompressionControlFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageCompressionControlFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageCompressionControlFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageCompressionControl ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageCompressionControlFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCompressionControl == rhs.imageCompressionControl ); -# endif - } - - bool operator!=( PhysicalDeviceImageCompressionControlFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageCompressionControlFeaturesEXT; - void * pNext = {}; - Bool32 imageCompressionControl = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageCompressionControlFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageCompressionControlFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.html - struct PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT - { - using NativeType = VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( Bool32 imageCompressionControlSwapchain_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageCompressionControlSwapchain{ imageCompressionControlSwapchain_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT( - *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT & - operator=( PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT & - operator=( VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT & - setImageCompressionControlSwapchain( Bool32 imageCompressionControlSwapchain_ ) & - VULKAN_HPP_NOEXCEPT - { - imageCompressionControlSwapchain = imageCompressionControlSwapchain_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT && - setImageCompressionControlSwapchain( Bool32 imageCompressionControlSwapchain_ ) && - VULKAN_HPP_NOEXCEPT - { - imageCompressionControlSwapchain = imageCompressionControlSwapchain_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageCompressionControlSwapchain ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageCompressionControlSwapchain == rhs.imageCompressionControlSwapchain ); -# endif - } - - bool operator!=( PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; - void * pNext = {}; - Bool32 imageCompressionControlSwapchain = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageDrmFormatModifierInfoEXT.html - struct PhysicalDeviceImageDrmFormatModifierInfoEXT - { - using NativeType = VkPhysicalDeviceImageDrmFormatModifierInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_ = {}, - SharingMode sharingMode_ = SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = {}, - const uint32_t * pQueueFamilyIndices_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , drmFormatModifier{ drmFormatModifier_ } - , sharingMode{ sharingMode_ } - , queueFamilyIndexCount{ queueFamilyIndexCount_ } - , pQueueFamilyIndices{ pQueueFamilyIndices_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageDrmFormatModifierInfoEXT( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageDrmFormatModifierInfoEXT( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageDrmFormatModifierInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PhysicalDeviceImageDrmFormatModifierInfoEXT( uint64_t drmFormatModifier_, - SharingMode sharingMode_, - ArrayProxyNoTemporaries const & queueFamilyIndices_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , drmFormatModifier( drmFormatModifier_ ) - , sharingMode( sharingMode_ ) - , queueFamilyIndexCount( static_cast( queueFamilyIndices_.size() ) ) - , pQueueFamilyIndices( queueFamilyIndices_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PhysicalDeviceImageDrmFormatModifierInfoEXT & operator=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageDrmFormatModifierInfoEXT & operator=( VkPhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT & setDrmFormatModifier( uint64_t drmFormatModifier_ ) & VULKAN_HPP_NOEXCEPT - { - drmFormatModifier = drmFormatModifier_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT && setDrmFormatModifier( uint64_t drmFormatModifier_ ) && VULKAN_HPP_NOEXCEPT - { - drmFormatModifier = drmFormatModifier_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT & setSharingMode( SharingMode sharingMode_ ) & VULKAN_HPP_NOEXCEPT - { - sharingMode = sharingMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT && setSharingMode( SharingMode sharingMode_ ) && VULKAN_HPP_NOEXCEPT - { - sharingMode = sharingMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) & VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT && setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) && VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT & setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageDrmFormatModifierInfoEXT && setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) && - VULKAN_HPP_NOEXCEPT - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PhysicalDeviceImageDrmFormatModifierInfoEXT & - setQueueFamilyIndices( ArrayProxyNoTemporaries const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = static_cast( queueFamilyIndices_.size() ); - pQueueFamilyIndices = queueFamilyIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageDrmFormatModifierInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, drmFormatModifier, sharingMode, queueFamilyIndexCount, pQueueFamilyIndices ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageDrmFormatModifierInfoEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( drmFormatModifier == rhs.drmFormatModifier ) && ( sharingMode == rhs.sharingMode ) && - ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ); -# endif - } - - bool operator!=( PhysicalDeviceImageDrmFormatModifierInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT; - const void * pNext = {}; - uint64_t drmFormatModifier = {}; - SharingMode sharingMode = SharingMode::eExclusive; - uint32_t queueFamilyIndexCount = {}; - const uint32_t * pQueueFamilyIndices = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageDrmFormatModifierInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageDrmFormatModifierInfoEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceImageFormatInfo2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageFormatInfo2.html - struct PhysicalDeviceImageFormatInfo2 - { - using NativeType = VkPhysicalDeviceImageFormatInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageFormatInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( Format format_ = Format::eUndefined, - ImageType type_ = ImageType::e1D, - ImageTiling tiling_ = ImageTiling::eOptimal, - ImageUsageFlags usage_ = {}, - ImageCreateFlags flags_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , format{ format_ } - , type{ type_ } - , tiling{ tiling_ } - , usage{ usage_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageFormatInfo2( PhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageFormatInfo2( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageFormatInfo2( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageFormatInfo2 & operator=( PhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageFormatInfo2 & operator=( VkPhysicalDeviceImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setType( ImageType type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setType( ImageType type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setTiling( ImageTiling tiling_ ) & VULKAN_HPP_NOEXCEPT - { - tiling = tiling_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setTiling( ImageTiling tiling_ ) && VULKAN_HPP_NOEXCEPT - { - tiling = tiling_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setUsage( ImageUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setUsage( ImageUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 & setFlags( ImageCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageFormatInfo2 && setFlags( ImageCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageFormatInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageFormatInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, format, type, tiling, usage, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageFormatInfo2 const & ) const = default; -#else - bool operator==( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && ( tiling == rhs.tiling ) && - ( usage == rhs.usage ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( PhysicalDeviceImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageFormatInfo2; - const void * pNext = {}; - Format format = Format::eUndefined; - ImageType type = ImageType::e1D; - ImageTiling tiling = ImageTiling::eOptimal; - ImageUsageFlags usage = {}; - ImageCreateFlags flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageFormatInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageFormatInfo2; - }; - - using PhysicalDeviceImageFormatInfo2KHR = PhysicalDeviceImageFormatInfo2; - - // wrapper struct for struct VkPhysicalDeviceImageProcessing2FeaturesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessing2FeaturesQCOM.html - struct PhysicalDeviceImageProcessing2FeaturesQCOM - { - using NativeType = VkPhysicalDeviceImageProcessing2FeaturesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageProcessing2FeaturesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessing2FeaturesQCOM( Bool32 textureBlockMatch2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , textureBlockMatch2{ textureBlockMatch2_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessing2FeaturesQCOM( PhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageProcessing2FeaturesQCOM( VkPhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageProcessing2FeaturesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageProcessing2FeaturesQCOM & operator=( PhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageProcessing2FeaturesQCOM & operator=( VkPhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing2FeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing2FeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing2FeaturesQCOM & setTextureBlockMatch2( Bool32 textureBlockMatch2_ ) & VULKAN_HPP_NOEXCEPT - { - textureBlockMatch2 = textureBlockMatch2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessing2FeaturesQCOM && setTextureBlockMatch2( Bool32 textureBlockMatch2_ ) && VULKAN_HPP_NOEXCEPT - { - textureBlockMatch2 = textureBlockMatch2_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImageProcessing2FeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessing2FeaturesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessing2FeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessing2FeaturesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, textureBlockMatch2 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageProcessing2FeaturesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( textureBlockMatch2 == rhs.textureBlockMatch2 ); -# endif - } - - bool operator!=( PhysicalDeviceImageProcessing2FeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageProcessing2FeaturesQCOM; - void * pNext = {}; - Bool32 textureBlockMatch2 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageProcessing2FeaturesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageProcessing2FeaturesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceImageProcessing2PropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessing2PropertiesQCOM.html - struct PhysicalDeviceImageProcessing2PropertiesQCOM - { - using NativeType = VkPhysicalDeviceImageProcessing2PropertiesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageProcessing2PropertiesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessing2PropertiesQCOM( Extent2D maxBlockMatchWindow_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxBlockMatchWindow{ maxBlockMatchWindow_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessing2PropertiesQCOM( PhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageProcessing2PropertiesQCOM( VkPhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageProcessing2PropertiesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageProcessing2PropertiesQCOM & operator=( PhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageProcessing2PropertiesQCOM & operator=( VkPhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceImageProcessing2PropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessing2PropertiesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessing2PropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessing2PropertiesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxBlockMatchWindow ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageProcessing2PropertiesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBlockMatchWindow == rhs.maxBlockMatchWindow ); -# endif - } - - bool operator!=( PhysicalDeviceImageProcessing2PropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageProcessing2PropertiesQCOM; - void * pNext = {}; - Extent2D maxBlockMatchWindow = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageProcessing2PropertiesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageProcessing2PropertiesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceImageProcessingFeaturesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessingFeaturesQCOM.html - struct PhysicalDeviceImageProcessingFeaturesQCOM - { - using NativeType = VkPhysicalDeviceImageProcessingFeaturesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessingFeaturesQCOM( Bool32 textureSampleWeighted_ = {}, - Bool32 textureBoxFilter_ = {}, - Bool32 textureBlockMatch_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , textureSampleWeighted{ textureSampleWeighted_ } - , textureBoxFilter{ textureBoxFilter_ } - , textureBlockMatch{ textureBlockMatch_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessingFeaturesQCOM( PhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageProcessingFeaturesQCOM( VkPhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageProcessingFeaturesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageProcessingFeaturesQCOM & operator=( PhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageProcessingFeaturesQCOM & operator=( VkPhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM & setTextureSampleWeighted( Bool32 textureSampleWeighted_ ) & VULKAN_HPP_NOEXCEPT - { - textureSampleWeighted = textureSampleWeighted_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM && setTextureSampleWeighted( Bool32 textureSampleWeighted_ ) && VULKAN_HPP_NOEXCEPT - { - textureSampleWeighted = textureSampleWeighted_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM & setTextureBoxFilter( Bool32 textureBoxFilter_ ) & VULKAN_HPP_NOEXCEPT - { - textureBoxFilter = textureBoxFilter_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM && setTextureBoxFilter( Bool32 textureBoxFilter_ ) && VULKAN_HPP_NOEXCEPT - { - textureBoxFilter = textureBoxFilter_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM & setTextureBlockMatch( Bool32 textureBlockMatch_ ) & VULKAN_HPP_NOEXCEPT - { - textureBlockMatch = textureBlockMatch_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageProcessingFeaturesQCOM && setTextureBlockMatch( Bool32 textureBlockMatch_ ) && VULKAN_HPP_NOEXCEPT - { - textureBlockMatch = textureBlockMatch_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImageProcessingFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessingFeaturesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessingFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessingFeaturesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, textureSampleWeighted, textureBoxFilter, textureBlockMatch ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageProcessingFeaturesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( textureSampleWeighted == rhs.textureSampleWeighted ) && - ( textureBoxFilter == rhs.textureBoxFilter ) && ( textureBlockMatch == rhs.textureBlockMatch ); -# endif - } - - bool operator!=( PhysicalDeviceImageProcessingFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM; - void * pNext = {}; - Bool32 textureSampleWeighted = {}; - Bool32 textureBoxFilter = {}; - Bool32 textureBlockMatch = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageProcessingFeaturesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageProcessingFeaturesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceImageProcessingPropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageProcessingPropertiesQCOM.html - struct PhysicalDeviceImageProcessingPropertiesQCOM - { - using NativeType = VkPhysicalDeviceImageProcessingPropertiesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessingPropertiesQCOM( uint32_t maxWeightFilterPhases_ = {}, - Extent2D maxWeightFilterDimension_ = {}, - Extent2D maxBlockMatchRegion_ = {}, - Extent2D maxBoxFilterBlockSize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxWeightFilterPhases{ maxWeightFilterPhases_ } - , maxWeightFilterDimension{ maxWeightFilterDimension_ } - , maxBlockMatchRegion{ maxBlockMatchRegion_ } - , maxBoxFilterBlockSize{ maxBoxFilterBlockSize_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageProcessingPropertiesQCOM( PhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageProcessingPropertiesQCOM( VkPhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageProcessingPropertiesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageProcessingPropertiesQCOM & operator=( PhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageProcessingPropertiesQCOM & operator=( VkPhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceImageProcessingPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessingPropertiesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessingPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageProcessingPropertiesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxWeightFilterPhases, maxWeightFilterDimension, maxBlockMatchRegion, maxBoxFilterBlockSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageProcessingPropertiesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxWeightFilterPhases == rhs.maxWeightFilterPhases ) && - ( maxWeightFilterDimension == rhs.maxWeightFilterDimension ) && ( maxBlockMatchRegion == rhs.maxBlockMatchRegion ) && - ( maxBoxFilterBlockSize == rhs.maxBoxFilterBlockSize ); -# endif - } - - bool operator!=( PhysicalDeviceImageProcessingPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM; - void * pNext = {}; - uint32_t maxWeightFilterPhases = {}; - Extent2D maxWeightFilterDimension = {}; - Extent2D maxBlockMatchRegion = {}; - Extent2D maxBoxFilterBlockSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageProcessingPropertiesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageProcessingPropertiesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceImageRobustnessFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageRobustnessFeatures.html - struct PhysicalDeviceImageRobustnessFeatures - { - using NativeType = VkPhysicalDeviceImageRobustnessFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageRobustnessFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageRobustnessFeatures( Bool32 robustImageAccess_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , robustImageAccess{ robustImageAccess_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageRobustnessFeatures( PhysicalDeviceImageRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageRobustnessFeatures( VkPhysicalDeviceImageRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageRobustnessFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageRobustnessFeatures & operator=( PhysicalDeviceImageRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageRobustnessFeatures & operator=( VkPhysicalDeviceImageRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageRobustnessFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageRobustnessFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageRobustnessFeatures & setRobustImageAccess( Bool32 robustImageAccess_ ) & VULKAN_HPP_NOEXCEPT - { - robustImageAccess = robustImageAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageRobustnessFeatures && setRobustImageAccess( Bool32 robustImageAccess_ ) && VULKAN_HPP_NOEXCEPT - { - robustImageAccess = robustImageAccess_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImageRobustnessFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageRobustnessFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageRobustnessFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageRobustnessFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, robustImageAccess ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageRobustnessFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceImageRobustnessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess ); -# endif - } - - bool operator!=( PhysicalDeviceImageRobustnessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageRobustnessFeatures; - void * pNext = {}; - Bool32 robustImageAccess = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageRobustnessFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageRobustnessFeatures; - }; - - using PhysicalDeviceImageRobustnessFeaturesEXT = PhysicalDeviceImageRobustnessFeatures; - - // wrapper struct for struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.html - struct PhysicalDeviceImageSlicedViewOf3DFeaturesEXT - { - using NativeType = VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( Bool32 imageSlicedViewOf3D_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageSlicedViewOf3D{ imageSlicedViewOf3D_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageSlicedViewOf3DFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageSlicedViewOf3DFeaturesEXT & operator=( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageSlicedViewOf3DFeaturesEXT & operator=( VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT & setImageSlicedViewOf3D( Bool32 imageSlicedViewOf3D_ ) & VULKAN_HPP_NOEXCEPT - { - imageSlicedViewOf3D = imageSlicedViewOf3D_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageSlicedViewOf3DFeaturesEXT && setImageSlicedViewOf3D( Bool32 imageSlicedViewOf3D_ ) && VULKAN_HPP_NOEXCEPT - { - imageSlicedViewOf3D = imageSlicedViewOf3D_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageSlicedViewOf3D ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageSlicedViewOf3D == rhs.imageSlicedViewOf3D ); -# endif - } - - bool operator!=( PhysicalDeviceImageSlicedViewOf3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT; - void * pNext = {}; - Bool32 imageSlicedViewOf3D = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageSlicedViewOf3DFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageSlicedViewOf3DFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceImageViewImageFormatInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageViewImageFormatInfoEXT.html - struct PhysicalDeviceImageViewImageFormatInfoEXT - { - using NativeType = VkPhysicalDeviceImageViewImageFormatInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( ImageViewType imageViewType_ = ImageViewType::e1D, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageViewType{ imageViewType_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewImageFormatInfoEXT( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageViewImageFormatInfoEXT( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageViewImageFormatInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageViewImageFormatInfoEXT & operator=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageViewImageFormatInfoEXT & operator=( VkPhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewImageFormatInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewImageFormatInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewImageFormatInfoEXT & setImageViewType( ImageViewType imageViewType_ ) & VULKAN_HPP_NOEXCEPT - { - imageViewType = imageViewType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewImageFormatInfoEXT && setImageViewType( ImageViewType imageViewType_ ) && VULKAN_HPP_NOEXCEPT - { - imageViewType = imageViewType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImageViewImageFormatInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageViewImageFormatInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageViewImageFormatInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageViewImageFormatInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageViewType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageViewImageFormatInfoEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageViewType == rhs.imageViewType ); -# endif - } - - bool operator!=( PhysicalDeviceImageViewImageFormatInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT; - void * pNext = {}; - ImageViewType imageViewType = ImageViewType::e1D; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageViewImageFormatInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageViewImageFormatInfoEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceImageViewMinLodFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImageViewMinLodFeaturesEXT.html - struct PhysicalDeviceImageViewMinLodFeaturesEXT - { - using NativeType = VkPhysicalDeviceImageViewMinLodFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImageViewMinLodFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewMinLodFeaturesEXT( Bool32 minLod_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minLod{ minLod_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImageViewMinLodFeaturesEXT( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImageViewMinLodFeaturesEXT( VkPhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImageViewMinLodFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImageViewMinLodFeaturesEXT & operator=( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImageViewMinLodFeaturesEXT & operator=( VkPhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewMinLodFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewMinLodFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewMinLodFeaturesEXT & setMinLod( Bool32 minLod_ ) & VULKAN_HPP_NOEXCEPT - { - minLod = minLod_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImageViewMinLodFeaturesEXT && setMinLod( Bool32 minLod_ ) && VULKAN_HPP_NOEXCEPT - { - minLod = minLod_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImageViewMinLodFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageViewMinLodFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageViewMinLodFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImageViewMinLodFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minLod ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImageViewMinLodFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minLod == rhs.minLod ); -# endif - } - - bool operator!=( PhysicalDeviceImageViewMinLodFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImageViewMinLodFeaturesEXT; - void * pNext = {}; - Bool32 minLod = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImageViewMinLodFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImageViewMinLodFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceImagelessFramebufferFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceImagelessFramebufferFeatures.html - struct PhysicalDeviceImagelessFramebufferFeatures - { - using NativeType = VkPhysicalDeviceImagelessFramebufferFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceImagelessFramebufferFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeatures( Bool32 imagelessFramebuffer_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imagelessFramebuffer{ imagelessFramebuffer_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceImagelessFramebufferFeatures( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceImagelessFramebufferFeatures( VkPhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceImagelessFramebufferFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceImagelessFramebufferFeatures & operator=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceImagelessFramebufferFeatures & operator=( VkPhysicalDeviceImagelessFramebufferFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImagelessFramebufferFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImagelessFramebufferFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImagelessFramebufferFeatures & setImagelessFramebuffer( Bool32 imagelessFramebuffer_ ) & VULKAN_HPP_NOEXCEPT - { - imagelessFramebuffer = imagelessFramebuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceImagelessFramebufferFeatures && setImagelessFramebuffer( Bool32 imagelessFramebuffer_ ) && VULKAN_HPP_NOEXCEPT - { - imagelessFramebuffer = imagelessFramebuffer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceImagelessFramebufferFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImagelessFramebufferFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImagelessFramebufferFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceImagelessFramebufferFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imagelessFramebuffer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceImagelessFramebufferFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imagelessFramebuffer == rhs.imagelessFramebuffer ); -# endif - } - - bool operator!=( PhysicalDeviceImagelessFramebufferFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceImagelessFramebufferFeatures; - void * pNext = {}; - Bool32 imagelessFramebuffer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceImagelessFramebufferFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceImagelessFramebufferFeatures; - }; - - using PhysicalDeviceImagelessFramebufferFeaturesKHR = PhysicalDeviceImagelessFramebufferFeatures; - - // wrapper struct for struct VkPhysicalDeviceIndexTypeUint8Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceIndexTypeUint8Features.html - struct PhysicalDeviceIndexTypeUint8Features - { - using NativeType = VkPhysicalDeviceIndexTypeUint8Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceIndexTypeUint8Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8Features( Bool32 indexTypeUint8_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , indexTypeUint8{ indexTypeUint8_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceIndexTypeUint8Features( PhysicalDeviceIndexTypeUint8Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceIndexTypeUint8Features( VkPhysicalDeviceIndexTypeUint8Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceIndexTypeUint8Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceIndexTypeUint8Features & operator=( PhysicalDeviceIndexTypeUint8Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceIndexTypeUint8Features & operator=( VkPhysicalDeviceIndexTypeUint8Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8Features & setIndexTypeUint8( Bool32 indexTypeUint8_ ) & VULKAN_HPP_NOEXCEPT - { - indexTypeUint8 = indexTypeUint8_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceIndexTypeUint8Features && setIndexTypeUint8( Bool32 indexTypeUint8_ ) && VULKAN_HPP_NOEXCEPT - { - indexTypeUint8 = indexTypeUint8_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceIndexTypeUint8Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceIndexTypeUint8Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceIndexTypeUint8Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceIndexTypeUint8Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, indexTypeUint8 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceIndexTypeUint8Features const & ) const = default; -#else - bool operator==( PhysicalDeviceIndexTypeUint8Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( indexTypeUint8 == rhs.indexTypeUint8 ); -# endif - } - - bool operator!=( PhysicalDeviceIndexTypeUint8Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceIndexTypeUint8Features; - void * pNext = {}; - Bool32 indexTypeUint8 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceIndexTypeUint8Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceIndexTypeUint8Features; - }; - - using PhysicalDeviceIndexTypeUint8FeaturesEXT = PhysicalDeviceIndexTypeUint8Features; - using PhysicalDeviceIndexTypeUint8FeaturesKHR = PhysicalDeviceIndexTypeUint8Features; - - // wrapper struct for struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceInheritedViewportScissorFeaturesNV.html - struct PhysicalDeviceInheritedViewportScissorFeaturesNV - { - using NativeType = VkPhysicalDeviceInheritedViewportScissorFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInheritedViewportScissorFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceInheritedViewportScissorFeaturesNV( Bool32 inheritedViewportScissor2D_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , inheritedViewportScissor2D{ inheritedViewportScissor2D_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceInheritedViewportScissorFeaturesNV( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceInheritedViewportScissorFeaturesNV( VkPhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceInheritedViewportScissorFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceInheritedViewportScissorFeaturesNV & operator=( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceInheritedViewportScissorFeaturesNV & operator=( VkPhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInheritedViewportScissorFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInheritedViewportScissorFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInheritedViewportScissorFeaturesNV & setInheritedViewportScissor2D( Bool32 inheritedViewportScissor2D_ ) & - VULKAN_HPP_NOEXCEPT - { - inheritedViewportScissor2D = inheritedViewportScissor2D_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInheritedViewportScissorFeaturesNV && setInheritedViewportScissor2D( Bool32 inheritedViewportScissor2D_ ) && - VULKAN_HPP_NOEXCEPT - { - inheritedViewportScissor2D = inheritedViewportScissor2D_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInheritedViewportScissorFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, inheritedViewportScissor2D ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceInheritedViewportScissorFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inheritedViewportScissor2D == rhs.inheritedViewportScissor2D ); -# endif - } - - bool operator!=( PhysicalDeviceInheritedViewportScissorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceInheritedViewportScissorFeaturesNV; - void * pNext = {}; - Bool32 inheritedViewportScissor2D = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceInheritedViewportScissorFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceInheritedViewportScissorFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceInlineUniformBlockFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceInlineUniformBlockFeatures.html - struct PhysicalDeviceInlineUniformBlockFeatures - { - using NativeType = VkPhysicalDeviceInlineUniformBlockFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInlineUniformBlockFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeatures( Bool32 inlineUniformBlock_ = {}, - Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , inlineUniformBlock{ inlineUniformBlock_ } - , descriptorBindingInlineUniformBlockUpdateAfterBind{ descriptorBindingInlineUniformBlockUpdateAfterBind_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockFeatures( PhysicalDeviceInlineUniformBlockFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceInlineUniformBlockFeatures( VkPhysicalDeviceInlineUniformBlockFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceInlineUniformBlockFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceInlineUniformBlockFeatures & operator=( PhysicalDeviceInlineUniformBlockFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceInlineUniformBlockFeatures & operator=( VkPhysicalDeviceInlineUniformBlockFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures & setInlineUniformBlock( Bool32 inlineUniformBlock_ ) & VULKAN_HPP_NOEXCEPT - { - inlineUniformBlock = inlineUniformBlock_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures && setInlineUniformBlock( Bool32 inlineUniformBlock_ ) && VULKAN_HPP_NOEXCEPT - { - inlineUniformBlock = inlineUniformBlock_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures & - setDescriptorBindingInlineUniformBlockUpdateAfterBind( Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInlineUniformBlockFeatures && - setDescriptorBindingInlineUniformBlockUpdateAfterBind( Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceInlineUniformBlockFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInlineUniformBlockFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInlineUniformBlockFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInlineUniformBlockFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, inlineUniformBlock, descriptorBindingInlineUniformBlockUpdateAfterBind ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceInlineUniformBlockFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceInlineUniformBlockFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( inlineUniformBlock == rhs.inlineUniformBlock ) && - ( descriptorBindingInlineUniformBlockUpdateAfterBind == rhs.descriptorBindingInlineUniformBlockUpdateAfterBind ); -# endif - } - - bool operator!=( PhysicalDeviceInlineUniformBlockFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockFeatures; - void * pNext = {}; - Bool32 inlineUniformBlock = {}; - Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceInlineUniformBlockFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceInlineUniformBlockFeatures; - }; - - using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures; - - // wrapper struct for struct VkPhysicalDeviceInlineUniformBlockProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceInlineUniformBlockProperties.html - struct PhysicalDeviceInlineUniformBlockProperties - { - using NativeType = VkPhysicalDeviceInlineUniformBlockProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInlineUniformBlockProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockProperties( uint32_t maxInlineUniformBlockSize_ = {}, - uint32_t maxPerStageDescriptorInlineUniformBlocks_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ = {}, - uint32_t maxDescriptorSetInlineUniformBlocks_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxInlineUniformBlockSize{ maxInlineUniformBlockSize_ } - , maxPerStageDescriptorInlineUniformBlocks{ maxPerStageDescriptorInlineUniformBlocks_ } - , maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks{ maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ } - , maxDescriptorSetInlineUniformBlocks{ maxDescriptorSetInlineUniformBlocks_ } - , maxDescriptorSetUpdateAfterBindInlineUniformBlocks{ maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceInlineUniformBlockProperties( PhysicalDeviceInlineUniformBlockProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceInlineUniformBlockProperties( VkPhysicalDeviceInlineUniformBlockProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceInlineUniformBlockProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceInlineUniformBlockProperties & operator=( PhysicalDeviceInlineUniformBlockProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceInlineUniformBlockProperties & operator=( VkPhysicalDeviceInlineUniformBlockProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceInlineUniformBlockProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInlineUniformBlockProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInlineUniformBlockProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInlineUniformBlockProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - maxInlineUniformBlockSize, - maxPerStageDescriptorInlineUniformBlocks, - maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, - maxDescriptorSetInlineUniformBlocks, - maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceInlineUniformBlockProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceInlineUniformBlockProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) && - ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks ) && - ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ) && - ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks ) && - ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks == rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ); -# endif - } - - bool operator!=( PhysicalDeviceInlineUniformBlockProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceInlineUniformBlockProperties; - void * pNext = {}; - uint32_t maxInlineUniformBlockSize = {}; - uint32_t maxPerStageDescriptorInlineUniformBlocks = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = {}; - uint32_t maxDescriptorSetInlineUniformBlocks = {}; - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceInlineUniformBlockProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceInlineUniformBlockProperties; - }; - - using PhysicalDeviceInlineUniformBlockPropertiesEXT = PhysicalDeviceInlineUniformBlockProperties; - - // wrapper struct for struct VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR.html - struct PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR - { - using NativeType = VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR( Bool32 internallySynchronizedQueues_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , internallySynchronizedQueues{ internallySynchronizedQueues_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR( PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR( VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR & - operator=( PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR & operator=( VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR & setInternallySynchronizedQueues( Bool32 internallySynchronizedQueues_ ) & - VULKAN_HPP_NOEXCEPT - { - internallySynchronizedQueues = internallySynchronizedQueues_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR && setInternallySynchronizedQueues( Bool32 internallySynchronizedQueues_ ) && - VULKAN_HPP_NOEXCEPT - { - internallySynchronizedQueues = internallySynchronizedQueues_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, internallySynchronizedQueues ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( internallySynchronizedQueues == rhs.internallySynchronizedQueues ); -# endif - } - - bool operator!=( PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; - void * pNext = {}; - Bool32 internallySynchronizedQueues = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.html - struct PhysicalDeviceInvocationMaskFeaturesHUAWEI - { - using NativeType = VkPhysicalDeviceInvocationMaskFeaturesHUAWEI; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceInvocationMaskFeaturesHUAWEI; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceInvocationMaskFeaturesHUAWEI( Bool32 invocationMask_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , invocationMask{ invocationMask_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceInvocationMaskFeaturesHUAWEI( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceInvocationMaskFeaturesHUAWEI( VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceInvocationMaskFeaturesHUAWEI( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceInvocationMaskFeaturesHUAWEI & operator=( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceInvocationMaskFeaturesHUAWEI & operator=( VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInvocationMaskFeaturesHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInvocationMaskFeaturesHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInvocationMaskFeaturesHUAWEI & setInvocationMask( Bool32 invocationMask_ ) & VULKAN_HPP_NOEXCEPT - { - invocationMask = invocationMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceInvocationMaskFeaturesHUAWEI && setInvocationMask( Bool32 invocationMask_ ) && VULKAN_HPP_NOEXCEPT - { - invocationMask = invocationMask_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, invocationMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & ) const = default; -#else - bool operator==( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( invocationMask == rhs.invocationMask ); -# endif - } - - bool operator!=( PhysicalDeviceInvocationMaskFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceInvocationMaskFeaturesHUAWEI; - void * pNext = {}; - Bool32 invocationMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceInvocationMaskFeaturesHUAWEI; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceInvocationMaskFeaturesHUAWEI; - }; - - // wrapper struct for struct VkPhysicalDeviceLayeredApiPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiPropertiesKHR.html - struct PhysicalDeviceLayeredApiPropertiesKHR - { - using NativeType = VkPhysicalDeviceLayeredApiPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLayeredApiPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesKHR( uint32_t vendorID_ = {}, - uint32_t deviceID_ = {}, - PhysicalDeviceLayeredApiKHR layeredAPI_ = PhysicalDeviceLayeredApiKHR::eVulkan, - std::array const & deviceName_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vendorID{ vendorID_ } - , deviceID{ deviceID_ } - , layeredAPI{ layeredAPI_ } - , deviceName{ deviceName_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesKHR( PhysicalDeviceLayeredApiPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceLayeredApiPropertiesKHR( VkPhysicalDeviceLayeredApiPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceLayeredApiPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceLayeredApiPropertiesKHR & operator=( PhysicalDeviceLayeredApiPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceLayeredApiPropertiesKHR & operator=( VkPhysicalDeviceLayeredApiPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceLayeredApiPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredApiPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredApiPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredApiPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, vendorID, deviceID, layeredAPI, deviceName ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceLayeredApiPropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceLayeredApiPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && - ( layeredAPI == rhs.layeredAPI ) && ( deviceName == rhs.deviceName ); -# endif - } - - bool operator!=( PhysicalDeviceLayeredApiPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceLayeredApiPropertiesKHR; - void * pNext = {}; - uint32_t vendorID = {}; - uint32_t deviceID = {}; - PhysicalDeviceLayeredApiKHR layeredAPI = PhysicalDeviceLayeredApiKHR::eVulkan; - ArrayWrapper1D deviceName = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceLayeredApiPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceLayeredApiPropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceLayeredApiPropertiesListKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiPropertiesListKHR.html - struct PhysicalDeviceLayeredApiPropertiesListKHR - { - using NativeType = VkPhysicalDeviceLayeredApiPropertiesListKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLayeredApiPropertiesListKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR( uint32_t layeredApiCount_ = {}, - PhysicalDeviceLayeredApiPropertiesKHR * pLayeredApis_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , layeredApiCount{ layeredApiCount_ } - , pLayeredApis{ pLayeredApis_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR( PhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceLayeredApiPropertiesListKHR( VkPhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceLayeredApiPropertiesListKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PhysicalDeviceLayeredApiPropertiesListKHR( ArrayProxyNoTemporaries const & layeredApis_, void * pNext_ = nullptr ) - : pNext( pNext_ ), layeredApiCount( static_cast( layeredApis_.size() ) ), pLayeredApis( layeredApis_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PhysicalDeviceLayeredApiPropertiesListKHR & operator=( PhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceLayeredApiPropertiesListKHR & operator=( VkPhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR & setLayeredApiCount( uint32_t layeredApiCount_ ) & VULKAN_HPP_NOEXCEPT - { - layeredApiCount = layeredApiCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR && setLayeredApiCount( uint32_t layeredApiCount_ ) && VULKAN_HPP_NOEXCEPT - { - layeredApiCount = layeredApiCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR & setPLayeredApis( PhysicalDeviceLayeredApiPropertiesKHR * pLayeredApis_ ) & - VULKAN_HPP_NOEXCEPT - { - pLayeredApis = pLayeredApis_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiPropertiesListKHR && setPLayeredApis( PhysicalDeviceLayeredApiPropertiesKHR * pLayeredApis_ ) && - VULKAN_HPP_NOEXCEPT - { - pLayeredApis = pLayeredApis_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PhysicalDeviceLayeredApiPropertiesListKHR & - setLayeredApis( ArrayProxyNoTemporaries const & layeredApis_ ) VULKAN_HPP_NOEXCEPT - { - layeredApiCount = static_cast( layeredApis_.size() ); - pLayeredApis = layeredApis_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceLayeredApiPropertiesListKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredApiPropertiesListKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredApiPropertiesListKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredApiPropertiesListKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, layeredApiCount, pLayeredApis ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceLayeredApiPropertiesListKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( layeredApiCount == rhs.layeredApiCount ) && ( pLayeredApis == rhs.pLayeredApis ); -# endif - } - - bool operator!=( PhysicalDeviceLayeredApiPropertiesListKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceLayeredApiPropertiesListKHR; - void * pNext = {}; - uint32_t layeredApiCount = {}; - PhysicalDeviceLayeredApiPropertiesKHR * pLayeredApis = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceLayeredApiPropertiesListKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceLayeredApiPropertiesListKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceLimits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLimits.html - struct PhysicalDeviceLimits - { - using NativeType = VkPhysicalDeviceLimits; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLimits( uint32_t maxImageDimension1D_ = {}, - uint32_t maxImageDimension2D_ = {}, - uint32_t maxImageDimension3D_ = {}, - uint32_t maxImageDimensionCube_ = {}, - uint32_t maxImageArrayLayers_ = {}, - uint32_t maxTexelBufferElements_ = {}, - uint32_t maxUniformBufferRange_ = {}, - uint32_t maxStorageBufferRange_ = {}, - uint32_t maxPushConstantsSize_ = {}, - uint32_t maxMemoryAllocationCount_ = {}, - uint32_t maxSamplerAllocationCount_ = {}, - DeviceSize bufferImageGranularity_ = {}, - DeviceSize sparseAddressSpaceSize_ = {}, - uint32_t maxBoundDescriptorSets_ = {}, - uint32_t maxPerStageDescriptorSamplers_ = {}, - uint32_t maxPerStageDescriptorUniformBuffers_ = {}, - uint32_t maxPerStageDescriptorStorageBuffers_ = {}, - uint32_t maxPerStageDescriptorSampledImages_ = {}, - uint32_t maxPerStageDescriptorStorageImages_ = {}, - uint32_t maxPerStageDescriptorInputAttachments_ = {}, - uint32_t maxPerStageResources_ = {}, - uint32_t maxDescriptorSetSamplers_ = {}, - uint32_t maxDescriptorSetUniformBuffers_ = {}, - uint32_t maxDescriptorSetUniformBuffersDynamic_ = {}, - uint32_t maxDescriptorSetStorageBuffers_ = {}, - uint32_t maxDescriptorSetStorageBuffersDynamic_ = {}, - uint32_t maxDescriptorSetSampledImages_ = {}, - uint32_t maxDescriptorSetStorageImages_ = {}, - uint32_t maxDescriptorSetInputAttachments_ = {}, - uint32_t maxVertexInputAttributes_ = {}, - uint32_t maxVertexInputBindings_ = {}, - uint32_t maxVertexInputAttributeOffset_ = {}, - uint32_t maxVertexInputBindingStride_ = {}, - uint32_t maxVertexOutputComponents_ = {}, - uint32_t maxTessellationGenerationLevel_ = {}, - uint32_t maxTessellationPatchSize_ = {}, - uint32_t maxTessellationControlPerVertexInputComponents_ = {}, - uint32_t maxTessellationControlPerVertexOutputComponents_ = {}, - uint32_t maxTessellationControlPerPatchOutputComponents_ = {}, - uint32_t maxTessellationControlTotalOutputComponents_ = {}, - uint32_t maxTessellationEvaluationInputComponents_ = {}, - uint32_t maxTessellationEvaluationOutputComponents_ = {}, - uint32_t maxGeometryShaderInvocations_ = {}, - uint32_t maxGeometryInputComponents_ = {}, - uint32_t maxGeometryOutputComponents_ = {}, - uint32_t maxGeometryOutputVertices_ = {}, - uint32_t maxGeometryTotalOutputComponents_ = {}, - uint32_t maxFragmentInputComponents_ = {}, - uint32_t maxFragmentOutputAttachments_ = {}, - uint32_t maxFragmentDualSrcAttachments_ = {}, - uint32_t maxFragmentCombinedOutputResources_ = {}, - uint32_t maxComputeSharedMemorySize_ = {}, - std::array const & maxComputeWorkGroupCount_ = {}, - uint32_t maxComputeWorkGroupInvocations_ = {}, - std::array const & maxComputeWorkGroupSize_ = {}, - uint32_t subPixelPrecisionBits_ = {}, - uint32_t subTexelPrecisionBits_ = {}, - uint32_t mipmapPrecisionBits_ = {}, - uint32_t maxDrawIndexedIndexValue_ = {}, - uint32_t maxDrawIndirectCount_ = {}, - float maxSamplerLodBias_ = {}, - float maxSamplerAnisotropy_ = {}, - uint32_t maxViewports_ = {}, - std::array const & maxViewportDimensions_ = {}, - std::array const & viewportBoundsRange_ = {}, - uint32_t viewportSubPixelBits_ = {}, - size_t minMemoryMapAlignment_ = {}, - DeviceSize minTexelBufferOffsetAlignment_ = {}, - DeviceSize minUniformBufferOffsetAlignment_ = {}, - DeviceSize minStorageBufferOffsetAlignment_ = {}, - int32_t minTexelOffset_ = {}, - uint32_t maxTexelOffset_ = {}, - int32_t minTexelGatherOffset_ = {}, - uint32_t maxTexelGatherOffset_ = {}, - float minInterpolationOffset_ = {}, - float maxInterpolationOffset_ = {}, - uint32_t subPixelInterpolationOffsetBits_ = {}, - uint32_t maxFramebufferWidth_ = {}, - uint32_t maxFramebufferHeight_ = {}, - uint32_t maxFramebufferLayers_ = {}, - SampleCountFlags framebufferColorSampleCounts_ = {}, - SampleCountFlags framebufferDepthSampleCounts_ = {}, - SampleCountFlags framebufferStencilSampleCounts_ = {}, - SampleCountFlags framebufferNoAttachmentsSampleCounts_ = {}, - uint32_t maxColorAttachments_ = {}, - SampleCountFlags sampledImageColorSampleCounts_ = {}, - SampleCountFlags sampledImageIntegerSampleCounts_ = {}, - SampleCountFlags sampledImageDepthSampleCounts_ = {}, - SampleCountFlags sampledImageStencilSampleCounts_ = {}, - SampleCountFlags storageImageSampleCounts_ = {}, - uint32_t maxSampleMaskWords_ = {}, - Bool32 timestampComputeAndGraphics_ = {}, - float timestampPeriod_ = {}, - uint32_t maxClipDistances_ = {}, - uint32_t maxCullDistances_ = {}, - uint32_t maxCombinedClipAndCullDistances_ = {}, - uint32_t discreteQueuePriorities_ = {}, - std::array const & pointSizeRange_ = {}, - std::array const & lineWidthRange_ = {}, - float pointSizeGranularity_ = {}, - float lineWidthGranularity_ = {}, - Bool32 strictLines_ = {}, - Bool32 standardSampleLocations_ = {}, - DeviceSize optimalBufferCopyOffsetAlignment_ = {}, - DeviceSize optimalBufferCopyRowPitchAlignment_ = {}, - DeviceSize nonCoherentAtomSize_ = {} ) VULKAN_HPP_NOEXCEPT - : maxImageDimension1D{ maxImageDimension1D_ } - , maxImageDimension2D{ maxImageDimension2D_ } - , maxImageDimension3D{ maxImageDimension3D_ } - , maxImageDimensionCube{ maxImageDimensionCube_ } - , maxImageArrayLayers{ maxImageArrayLayers_ } - , maxTexelBufferElements{ maxTexelBufferElements_ } - , maxUniformBufferRange{ maxUniformBufferRange_ } - , maxStorageBufferRange{ maxStorageBufferRange_ } - , maxPushConstantsSize{ maxPushConstantsSize_ } - , maxMemoryAllocationCount{ maxMemoryAllocationCount_ } - , maxSamplerAllocationCount{ maxSamplerAllocationCount_ } - , bufferImageGranularity{ bufferImageGranularity_ } - , sparseAddressSpaceSize{ sparseAddressSpaceSize_ } - , maxBoundDescriptorSets{ maxBoundDescriptorSets_ } - , maxPerStageDescriptorSamplers{ maxPerStageDescriptorSamplers_ } - , maxPerStageDescriptorUniformBuffers{ maxPerStageDescriptorUniformBuffers_ } - , maxPerStageDescriptorStorageBuffers{ maxPerStageDescriptorStorageBuffers_ } - , maxPerStageDescriptorSampledImages{ maxPerStageDescriptorSampledImages_ } - , maxPerStageDescriptorStorageImages{ maxPerStageDescriptorStorageImages_ } - , maxPerStageDescriptorInputAttachments{ maxPerStageDescriptorInputAttachments_ } - , maxPerStageResources{ maxPerStageResources_ } - , maxDescriptorSetSamplers{ maxDescriptorSetSamplers_ } - , maxDescriptorSetUniformBuffers{ maxDescriptorSetUniformBuffers_ } - , maxDescriptorSetUniformBuffersDynamic{ maxDescriptorSetUniformBuffersDynamic_ } - , maxDescriptorSetStorageBuffers{ maxDescriptorSetStorageBuffers_ } - , maxDescriptorSetStorageBuffersDynamic{ maxDescriptorSetStorageBuffersDynamic_ } - , maxDescriptorSetSampledImages{ maxDescriptorSetSampledImages_ } - , maxDescriptorSetStorageImages{ maxDescriptorSetStorageImages_ } - , maxDescriptorSetInputAttachments{ maxDescriptorSetInputAttachments_ } - , maxVertexInputAttributes{ maxVertexInputAttributes_ } - , maxVertexInputBindings{ maxVertexInputBindings_ } - , maxVertexInputAttributeOffset{ maxVertexInputAttributeOffset_ } - , maxVertexInputBindingStride{ maxVertexInputBindingStride_ } - , maxVertexOutputComponents{ maxVertexOutputComponents_ } - , maxTessellationGenerationLevel{ maxTessellationGenerationLevel_ } - , maxTessellationPatchSize{ maxTessellationPatchSize_ } - , maxTessellationControlPerVertexInputComponents{ maxTessellationControlPerVertexInputComponents_ } - , maxTessellationControlPerVertexOutputComponents{ maxTessellationControlPerVertexOutputComponents_ } - , maxTessellationControlPerPatchOutputComponents{ maxTessellationControlPerPatchOutputComponents_ } - , maxTessellationControlTotalOutputComponents{ maxTessellationControlTotalOutputComponents_ } - , maxTessellationEvaluationInputComponents{ maxTessellationEvaluationInputComponents_ } - , maxTessellationEvaluationOutputComponents{ maxTessellationEvaluationOutputComponents_ } - , maxGeometryShaderInvocations{ maxGeometryShaderInvocations_ } - , maxGeometryInputComponents{ maxGeometryInputComponents_ } - , maxGeometryOutputComponents{ maxGeometryOutputComponents_ } - , maxGeometryOutputVertices{ maxGeometryOutputVertices_ } - , maxGeometryTotalOutputComponents{ maxGeometryTotalOutputComponents_ } - , maxFragmentInputComponents{ maxFragmentInputComponents_ } - , maxFragmentOutputAttachments{ maxFragmentOutputAttachments_ } - , maxFragmentDualSrcAttachments{ maxFragmentDualSrcAttachments_ } - , maxFragmentCombinedOutputResources{ maxFragmentCombinedOutputResources_ } - , maxComputeSharedMemorySize{ maxComputeSharedMemorySize_ } - , maxComputeWorkGroupCount{ maxComputeWorkGroupCount_ } - , maxComputeWorkGroupInvocations{ maxComputeWorkGroupInvocations_ } - , maxComputeWorkGroupSize{ maxComputeWorkGroupSize_ } - , subPixelPrecisionBits{ subPixelPrecisionBits_ } - , subTexelPrecisionBits{ subTexelPrecisionBits_ } - , mipmapPrecisionBits{ mipmapPrecisionBits_ } - , maxDrawIndexedIndexValue{ maxDrawIndexedIndexValue_ } - , maxDrawIndirectCount{ maxDrawIndirectCount_ } - , maxSamplerLodBias{ maxSamplerLodBias_ } - , maxSamplerAnisotropy{ maxSamplerAnisotropy_ } - , maxViewports{ maxViewports_ } - , maxViewportDimensions{ maxViewportDimensions_ } - , viewportBoundsRange{ viewportBoundsRange_ } - , viewportSubPixelBits{ viewportSubPixelBits_ } - , minMemoryMapAlignment{ minMemoryMapAlignment_ } - , minTexelBufferOffsetAlignment{ minTexelBufferOffsetAlignment_ } - , minUniformBufferOffsetAlignment{ minUniformBufferOffsetAlignment_ } - , minStorageBufferOffsetAlignment{ minStorageBufferOffsetAlignment_ } - , minTexelOffset{ minTexelOffset_ } - , maxTexelOffset{ maxTexelOffset_ } - , minTexelGatherOffset{ minTexelGatherOffset_ } - , maxTexelGatherOffset{ maxTexelGatherOffset_ } - , minInterpolationOffset{ minInterpolationOffset_ } - , maxInterpolationOffset{ maxInterpolationOffset_ } - , subPixelInterpolationOffsetBits{ subPixelInterpolationOffsetBits_ } - , maxFramebufferWidth{ maxFramebufferWidth_ } - , maxFramebufferHeight{ maxFramebufferHeight_ } - , maxFramebufferLayers{ maxFramebufferLayers_ } - , framebufferColorSampleCounts{ framebufferColorSampleCounts_ } - , framebufferDepthSampleCounts{ framebufferDepthSampleCounts_ } - , framebufferStencilSampleCounts{ framebufferStencilSampleCounts_ } - , framebufferNoAttachmentsSampleCounts{ framebufferNoAttachmentsSampleCounts_ } - , maxColorAttachments{ maxColorAttachments_ } - , sampledImageColorSampleCounts{ sampledImageColorSampleCounts_ } - , sampledImageIntegerSampleCounts{ sampledImageIntegerSampleCounts_ } - , sampledImageDepthSampleCounts{ sampledImageDepthSampleCounts_ } - , sampledImageStencilSampleCounts{ sampledImageStencilSampleCounts_ } - , storageImageSampleCounts{ storageImageSampleCounts_ } - , maxSampleMaskWords{ maxSampleMaskWords_ } - , timestampComputeAndGraphics{ timestampComputeAndGraphics_ } - , timestampPeriod{ timestampPeriod_ } - , maxClipDistances{ maxClipDistances_ } - , maxCullDistances{ maxCullDistances_ } - , maxCombinedClipAndCullDistances{ maxCombinedClipAndCullDistances_ } - , discreteQueuePriorities{ discreteQueuePriorities_ } - , pointSizeRange{ pointSizeRange_ } - , lineWidthRange{ lineWidthRange_ } - , pointSizeGranularity{ pointSizeGranularity_ } - , lineWidthGranularity{ lineWidthGranularity_ } - , strictLines{ strictLines_ } - , standardSampleLocations{ standardSampleLocations_ } - , optimalBufferCopyOffsetAlignment{ optimalBufferCopyOffsetAlignment_ } - , optimalBufferCopyRowPitchAlignment{ optimalBufferCopyRowPitchAlignment_ } - , nonCoherentAtomSize{ nonCoherentAtomSize_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLimits( PhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceLimits( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceLimits( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceLimits & operator=( PhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceLimits & operator=( VkPhysicalDeviceLimits const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceLimits const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLimits &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLimits const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLimits *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - uint32_t const &, - ArrayWrapper1D const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - float const &, - float const &, - uint32_t const &, - ArrayWrapper1D const &, - ArrayWrapper1D const &, - uint32_t const &, - size_t const &, - DeviceSize const &, - DeviceSize const &, - DeviceSize const &, - int32_t const &, - uint32_t const &, - int32_t const &, - uint32_t const &, - float const &, - float const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - SampleCountFlags const &, - SampleCountFlags const &, - SampleCountFlags const &, - SampleCountFlags const &, - uint32_t const &, - SampleCountFlags const &, - SampleCountFlags const &, - SampleCountFlags const &, - SampleCountFlags const &, - SampleCountFlags const &, - uint32_t const &, - Bool32 const &, - float const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - ArrayWrapper1D const &, - ArrayWrapper1D const &, - float const &, - float const &, - Bool32 const &, - Bool32 const &, - DeviceSize const &, - DeviceSize const &, - DeviceSize const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( maxImageDimension1D, - maxImageDimension2D, - maxImageDimension3D, - maxImageDimensionCube, - maxImageArrayLayers, - maxTexelBufferElements, - maxUniformBufferRange, - maxStorageBufferRange, - maxPushConstantsSize, - maxMemoryAllocationCount, - maxSamplerAllocationCount, - bufferImageGranularity, - sparseAddressSpaceSize, - maxBoundDescriptorSets, - maxPerStageDescriptorSamplers, - maxPerStageDescriptorUniformBuffers, - maxPerStageDescriptorStorageBuffers, - maxPerStageDescriptorSampledImages, - maxPerStageDescriptorStorageImages, - maxPerStageDescriptorInputAttachments, - maxPerStageResources, - maxDescriptorSetSamplers, - maxDescriptorSetUniformBuffers, - maxDescriptorSetUniformBuffersDynamic, - maxDescriptorSetStorageBuffers, - maxDescriptorSetStorageBuffersDynamic, - maxDescriptorSetSampledImages, - maxDescriptorSetStorageImages, - maxDescriptorSetInputAttachments, - maxVertexInputAttributes, - maxVertexInputBindings, - maxVertexInputAttributeOffset, - maxVertexInputBindingStride, - maxVertexOutputComponents, - maxTessellationGenerationLevel, - maxTessellationPatchSize, - maxTessellationControlPerVertexInputComponents, - maxTessellationControlPerVertexOutputComponents, - maxTessellationControlPerPatchOutputComponents, - maxTessellationControlTotalOutputComponents, - maxTessellationEvaluationInputComponents, - maxTessellationEvaluationOutputComponents, - maxGeometryShaderInvocations, - maxGeometryInputComponents, - maxGeometryOutputComponents, - maxGeometryOutputVertices, - maxGeometryTotalOutputComponents, - maxFragmentInputComponents, - maxFragmentOutputAttachments, - maxFragmentDualSrcAttachments, - maxFragmentCombinedOutputResources, - maxComputeSharedMemorySize, - maxComputeWorkGroupCount, - maxComputeWorkGroupInvocations, - maxComputeWorkGroupSize, - subPixelPrecisionBits, - subTexelPrecisionBits, - mipmapPrecisionBits, - maxDrawIndexedIndexValue, - maxDrawIndirectCount, - maxSamplerLodBias, - maxSamplerAnisotropy, - maxViewports, - maxViewportDimensions, - viewportBoundsRange, - viewportSubPixelBits, - minMemoryMapAlignment, - minTexelBufferOffsetAlignment, - minUniformBufferOffsetAlignment, - minStorageBufferOffsetAlignment, - minTexelOffset, - maxTexelOffset, - minTexelGatherOffset, - maxTexelGatherOffset, - minInterpolationOffset, - maxInterpolationOffset, - subPixelInterpolationOffsetBits, - maxFramebufferWidth, - maxFramebufferHeight, - maxFramebufferLayers, - framebufferColorSampleCounts, - framebufferDepthSampleCounts, - framebufferStencilSampleCounts, - framebufferNoAttachmentsSampleCounts, - maxColorAttachments, - sampledImageColorSampleCounts, - sampledImageIntegerSampleCounts, - sampledImageDepthSampleCounts, - sampledImageStencilSampleCounts, - storageImageSampleCounts, - maxSampleMaskWords, - timestampComputeAndGraphics, - timestampPeriod, - maxClipDistances, - maxCullDistances, - maxCombinedClipAndCullDistances, - discreteQueuePriorities, - pointSizeRange, - lineWidthRange, - pointSizeGranularity, - lineWidthGranularity, - strictLines, - standardSampleLocations, - optimalBufferCopyOffsetAlignment, - optimalBufferCopyRowPitchAlignment, - nonCoherentAtomSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceLimits const & ) const = default; -#else - bool operator==( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( maxImageDimension1D == rhs.maxImageDimension1D ) && ( maxImageDimension2D == rhs.maxImageDimension2D ) && - ( maxImageDimension3D == rhs.maxImageDimension3D ) && ( maxImageDimensionCube == rhs.maxImageDimensionCube ) && - ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && ( maxTexelBufferElements == rhs.maxTexelBufferElements ) && - ( maxUniformBufferRange == rhs.maxUniformBufferRange ) && ( maxStorageBufferRange == rhs.maxStorageBufferRange ) && - ( maxPushConstantsSize == rhs.maxPushConstantsSize ) && ( maxMemoryAllocationCount == rhs.maxMemoryAllocationCount ) && - ( maxSamplerAllocationCount == rhs.maxSamplerAllocationCount ) && ( bufferImageGranularity == rhs.bufferImageGranularity ) && - ( sparseAddressSpaceSize == rhs.sparseAddressSpaceSize ) && ( maxBoundDescriptorSets == rhs.maxBoundDescriptorSets ) && - ( maxPerStageDescriptorSamplers == rhs.maxPerStageDescriptorSamplers ) && - ( maxPerStageDescriptorUniformBuffers == rhs.maxPerStageDescriptorUniformBuffers ) && - ( maxPerStageDescriptorStorageBuffers == rhs.maxPerStageDescriptorStorageBuffers ) && - ( maxPerStageDescriptorSampledImages == rhs.maxPerStageDescriptorSampledImages ) && - ( maxPerStageDescriptorStorageImages == rhs.maxPerStageDescriptorStorageImages ) && - ( maxPerStageDescriptorInputAttachments == rhs.maxPerStageDescriptorInputAttachments ) && ( maxPerStageResources == rhs.maxPerStageResources ) && - ( maxDescriptorSetSamplers == rhs.maxDescriptorSetSamplers ) && ( maxDescriptorSetUniformBuffers == rhs.maxDescriptorSetUniformBuffers ) && - ( maxDescriptorSetUniformBuffersDynamic == rhs.maxDescriptorSetUniformBuffersDynamic ) && - ( maxDescriptorSetStorageBuffers == rhs.maxDescriptorSetStorageBuffers ) && - ( maxDescriptorSetStorageBuffersDynamic == rhs.maxDescriptorSetStorageBuffersDynamic ) && - ( maxDescriptorSetSampledImages == rhs.maxDescriptorSetSampledImages ) && ( maxDescriptorSetStorageImages == rhs.maxDescriptorSetStorageImages ) && - ( maxDescriptorSetInputAttachments == rhs.maxDescriptorSetInputAttachments ) && ( maxVertexInputAttributes == rhs.maxVertexInputAttributes ) && - ( maxVertexInputBindings == rhs.maxVertexInputBindings ) && ( maxVertexInputAttributeOffset == rhs.maxVertexInputAttributeOffset ) && - ( maxVertexInputBindingStride == rhs.maxVertexInputBindingStride ) && ( maxVertexOutputComponents == rhs.maxVertexOutputComponents ) && - ( maxTessellationGenerationLevel == rhs.maxTessellationGenerationLevel ) && ( maxTessellationPatchSize == rhs.maxTessellationPatchSize ) && - ( maxTessellationControlPerVertexInputComponents == rhs.maxTessellationControlPerVertexInputComponents ) && - ( maxTessellationControlPerVertexOutputComponents == rhs.maxTessellationControlPerVertexOutputComponents ) && - ( maxTessellationControlPerPatchOutputComponents == rhs.maxTessellationControlPerPatchOutputComponents ) && - ( maxTessellationControlTotalOutputComponents == rhs.maxTessellationControlTotalOutputComponents ) && - ( maxTessellationEvaluationInputComponents == rhs.maxTessellationEvaluationInputComponents ) && - ( maxTessellationEvaluationOutputComponents == rhs.maxTessellationEvaluationOutputComponents ) && - ( maxGeometryShaderInvocations == rhs.maxGeometryShaderInvocations ) && ( maxGeometryInputComponents == rhs.maxGeometryInputComponents ) && - ( maxGeometryOutputComponents == rhs.maxGeometryOutputComponents ) && ( maxGeometryOutputVertices == rhs.maxGeometryOutputVertices ) && - ( maxGeometryTotalOutputComponents == rhs.maxGeometryTotalOutputComponents ) && ( maxFragmentInputComponents == rhs.maxFragmentInputComponents ) && - ( maxFragmentOutputAttachments == rhs.maxFragmentOutputAttachments ) && ( maxFragmentDualSrcAttachments == rhs.maxFragmentDualSrcAttachments ) && - ( maxFragmentCombinedOutputResources == rhs.maxFragmentCombinedOutputResources ) && - ( maxComputeSharedMemorySize == rhs.maxComputeSharedMemorySize ) && ( maxComputeWorkGroupCount == rhs.maxComputeWorkGroupCount ) && - ( maxComputeWorkGroupInvocations == rhs.maxComputeWorkGroupInvocations ) && ( maxComputeWorkGroupSize == rhs.maxComputeWorkGroupSize ) && - ( subPixelPrecisionBits == rhs.subPixelPrecisionBits ) && ( subTexelPrecisionBits == rhs.subTexelPrecisionBits ) && - ( mipmapPrecisionBits == rhs.mipmapPrecisionBits ) && ( maxDrawIndexedIndexValue == rhs.maxDrawIndexedIndexValue ) && - ( maxDrawIndirectCount == rhs.maxDrawIndirectCount ) && ( maxSamplerLodBias == rhs.maxSamplerLodBias ) && - ( maxSamplerAnisotropy == rhs.maxSamplerAnisotropy ) && ( maxViewports == rhs.maxViewports ) && - ( maxViewportDimensions == rhs.maxViewportDimensions ) && ( viewportBoundsRange == rhs.viewportBoundsRange ) && - ( viewportSubPixelBits == rhs.viewportSubPixelBits ) && ( minMemoryMapAlignment == rhs.minMemoryMapAlignment ) && - ( minTexelBufferOffsetAlignment == rhs.minTexelBufferOffsetAlignment ) && - ( minUniformBufferOffsetAlignment == rhs.minUniformBufferOffsetAlignment ) && - ( minStorageBufferOffsetAlignment == rhs.minStorageBufferOffsetAlignment ) && ( minTexelOffset == rhs.minTexelOffset ) && - ( maxTexelOffset == rhs.maxTexelOffset ) && ( minTexelGatherOffset == rhs.minTexelGatherOffset ) && - ( maxTexelGatherOffset == rhs.maxTexelGatherOffset ) && ( minInterpolationOffset == rhs.minInterpolationOffset ) && - ( maxInterpolationOffset == rhs.maxInterpolationOffset ) && ( subPixelInterpolationOffsetBits == rhs.subPixelInterpolationOffsetBits ) && - ( maxFramebufferWidth == rhs.maxFramebufferWidth ) && ( maxFramebufferHeight == rhs.maxFramebufferHeight ) && - ( maxFramebufferLayers == rhs.maxFramebufferLayers ) && ( framebufferColorSampleCounts == rhs.framebufferColorSampleCounts ) && - ( framebufferDepthSampleCounts == rhs.framebufferDepthSampleCounts ) && ( framebufferStencilSampleCounts == rhs.framebufferStencilSampleCounts ) && - ( framebufferNoAttachmentsSampleCounts == rhs.framebufferNoAttachmentsSampleCounts ) && ( maxColorAttachments == rhs.maxColorAttachments ) && - ( sampledImageColorSampleCounts == rhs.sampledImageColorSampleCounts ) && - ( sampledImageIntegerSampleCounts == rhs.sampledImageIntegerSampleCounts ) && - ( sampledImageDepthSampleCounts == rhs.sampledImageDepthSampleCounts ) && - ( sampledImageStencilSampleCounts == rhs.sampledImageStencilSampleCounts ) && ( storageImageSampleCounts == rhs.storageImageSampleCounts ) && - ( maxSampleMaskWords == rhs.maxSampleMaskWords ) && ( timestampComputeAndGraphics == rhs.timestampComputeAndGraphics ) && - ( timestampPeriod == rhs.timestampPeriod ) && ( maxClipDistances == rhs.maxClipDistances ) && ( maxCullDistances == rhs.maxCullDistances ) && - ( maxCombinedClipAndCullDistances == rhs.maxCombinedClipAndCullDistances ) && ( discreteQueuePriorities == rhs.discreteQueuePriorities ) && - ( pointSizeRange == rhs.pointSizeRange ) && ( lineWidthRange == rhs.lineWidthRange ) && ( pointSizeGranularity == rhs.pointSizeGranularity ) && - ( lineWidthGranularity == rhs.lineWidthGranularity ) && ( strictLines == rhs.strictLines ) && - ( standardSampleLocations == rhs.standardSampleLocations ) && ( optimalBufferCopyOffsetAlignment == rhs.optimalBufferCopyOffsetAlignment ) && - ( optimalBufferCopyRowPitchAlignment == rhs.optimalBufferCopyRowPitchAlignment ) && ( nonCoherentAtomSize == rhs.nonCoherentAtomSize ); -# endif - } - - bool operator!=( PhysicalDeviceLimits const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t maxImageDimension1D = {}; - uint32_t maxImageDimension2D = {}; - uint32_t maxImageDimension3D = {}; - uint32_t maxImageDimensionCube = {}; - uint32_t maxImageArrayLayers = {}; - uint32_t maxTexelBufferElements = {}; - uint32_t maxUniformBufferRange = {}; - uint32_t maxStorageBufferRange = {}; - uint32_t maxPushConstantsSize = {}; - uint32_t maxMemoryAllocationCount = {}; - uint32_t maxSamplerAllocationCount = {}; - DeviceSize bufferImageGranularity = {}; - DeviceSize sparseAddressSpaceSize = {}; - uint32_t maxBoundDescriptorSets = {}; - uint32_t maxPerStageDescriptorSamplers = {}; - uint32_t maxPerStageDescriptorUniformBuffers = {}; - uint32_t maxPerStageDescriptorStorageBuffers = {}; - uint32_t maxPerStageDescriptorSampledImages = {}; - uint32_t maxPerStageDescriptorStorageImages = {}; - uint32_t maxPerStageDescriptorInputAttachments = {}; - uint32_t maxPerStageResources = {}; - uint32_t maxDescriptorSetSamplers = {}; - uint32_t maxDescriptorSetUniformBuffers = {}; - uint32_t maxDescriptorSetUniformBuffersDynamic = {}; - uint32_t maxDescriptorSetStorageBuffers = {}; - uint32_t maxDescriptorSetStorageBuffersDynamic = {}; - uint32_t maxDescriptorSetSampledImages = {}; - uint32_t maxDescriptorSetStorageImages = {}; - uint32_t maxDescriptorSetInputAttachments = {}; - uint32_t maxVertexInputAttributes = {}; - uint32_t maxVertexInputBindings = {}; - uint32_t maxVertexInputAttributeOffset = {}; - uint32_t maxVertexInputBindingStride = {}; - uint32_t maxVertexOutputComponents = {}; - uint32_t maxTessellationGenerationLevel = {}; - uint32_t maxTessellationPatchSize = {}; - uint32_t maxTessellationControlPerVertexInputComponents = {}; - uint32_t maxTessellationControlPerVertexOutputComponents = {}; - uint32_t maxTessellationControlPerPatchOutputComponents = {}; - uint32_t maxTessellationControlTotalOutputComponents = {}; - uint32_t maxTessellationEvaluationInputComponents = {}; - uint32_t maxTessellationEvaluationOutputComponents = {}; - uint32_t maxGeometryShaderInvocations = {}; - uint32_t maxGeometryInputComponents = {}; - uint32_t maxGeometryOutputComponents = {}; - uint32_t maxGeometryOutputVertices = {}; - uint32_t maxGeometryTotalOutputComponents = {}; - uint32_t maxFragmentInputComponents = {}; - uint32_t maxFragmentOutputAttachments = {}; - uint32_t maxFragmentDualSrcAttachments = {}; - uint32_t maxFragmentCombinedOutputResources = {}; - uint32_t maxComputeSharedMemorySize = {}; - ArrayWrapper1D maxComputeWorkGroupCount = {}; - uint32_t maxComputeWorkGroupInvocations = {}; - ArrayWrapper1D maxComputeWorkGroupSize = {}; - uint32_t subPixelPrecisionBits = {}; - uint32_t subTexelPrecisionBits = {}; - uint32_t mipmapPrecisionBits = {}; - uint32_t maxDrawIndexedIndexValue = {}; - uint32_t maxDrawIndirectCount = {}; - float maxSamplerLodBias = {}; - float maxSamplerAnisotropy = {}; - uint32_t maxViewports = {}; - ArrayWrapper1D maxViewportDimensions = {}; - ArrayWrapper1D viewportBoundsRange = {}; - uint32_t viewportSubPixelBits = {}; - size_t minMemoryMapAlignment = {}; - DeviceSize minTexelBufferOffsetAlignment = {}; - DeviceSize minUniformBufferOffsetAlignment = {}; - DeviceSize minStorageBufferOffsetAlignment = {}; - int32_t minTexelOffset = {}; - uint32_t maxTexelOffset = {}; - int32_t minTexelGatherOffset = {}; - uint32_t maxTexelGatherOffset = {}; - float minInterpolationOffset = {}; - float maxInterpolationOffset = {}; - uint32_t subPixelInterpolationOffsetBits = {}; - uint32_t maxFramebufferWidth = {}; - uint32_t maxFramebufferHeight = {}; - uint32_t maxFramebufferLayers = {}; - SampleCountFlags framebufferColorSampleCounts = {}; - SampleCountFlags framebufferDepthSampleCounts = {}; - SampleCountFlags framebufferStencilSampleCounts = {}; - SampleCountFlags framebufferNoAttachmentsSampleCounts = {}; - uint32_t maxColorAttachments = {}; - SampleCountFlags sampledImageColorSampleCounts = {}; - SampleCountFlags sampledImageIntegerSampleCounts = {}; - SampleCountFlags sampledImageDepthSampleCounts = {}; - SampleCountFlags sampledImageStencilSampleCounts = {}; - SampleCountFlags storageImageSampleCounts = {}; - uint32_t maxSampleMaskWords = {}; - Bool32 timestampComputeAndGraphics = {}; - float timestampPeriod = {}; - uint32_t maxClipDistances = {}; - uint32_t maxCullDistances = {}; - uint32_t maxCombinedClipAndCullDistances = {}; - uint32_t discreteQueuePriorities = {}; - ArrayWrapper1D pointSizeRange = {}; - ArrayWrapper1D lineWidthRange = {}; - float pointSizeGranularity = {}; - float lineWidthGranularity = {}; - Bool32 strictLines = {}; - Bool32 standardSampleLocations = {}; - DeviceSize optimalBufferCopyOffsetAlignment = {}; - DeviceSize optimalBufferCopyRowPitchAlignment = {}; - DeviceSize nonCoherentAtomSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceLimits; - }; -#endif - - // wrapper struct for struct VkPhysicalDeviceSparseProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSparseProperties.html - struct PhysicalDeviceSparseProperties - { - using NativeType = VkPhysicalDeviceSparseProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseProperties( Bool32 residencyStandard2DBlockShape_ = {}, - Bool32 residencyStandard2DMultisampleBlockShape_ = {}, - Bool32 residencyStandard3DBlockShape_ = {}, - Bool32 residencyAlignedMipSize_ = {}, - Bool32 residencyNonResidentStrict_ = {} ) VULKAN_HPP_NOEXCEPT - : residencyStandard2DBlockShape{ residencyStandard2DBlockShape_ } - , residencyStandard2DMultisampleBlockShape{ residencyStandard2DMultisampleBlockShape_ } - , residencyStandard3DBlockShape{ residencyStandard3DBlockShape_ } - , residencyAlignedMipSize{ residencyAlignedMipSize_ } - , residencyNonResidentStrict{ residencyNonResidentStrict_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseProperties( PhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSparseProperties( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSparseProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSparseProperties & operator=( PhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSparseProperties & operator=( VkPhysicalDeviceSparseProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceSparseProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSparseProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSparseProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSparseProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( residencyStandard2DBlockShape, - residencyStandard2DMultisampleBlockShape, - residencyStandard3DBlockShape, - residencyAlignedMipSize, - residencyNonResidentStrict ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSparseProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( residencyStandard2DBlockShape == rhs.residencyStandard2DBlockShape ) && - ( residencyStandard2DMultisampleBlockShape == rhs.residencyStandard2DMultisampleBlockShape ) && - ( residencyStandard3DBlockShape == rhs.residencyStandard3DBlockShape ) && ( residencyAlignedMipSize == rhs.residencyAlignedMipSize ) && - ( residencyNonResidentStrict == rhs.residencyNonResidentStrict ); -# endif - } - - bool operator!=( PhysicalDeviceSparseProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Bool32 residencyStandard2DBlockShape = {}; - Bool32 residencyStandard2DMultisampleBlockShape = {}; - Bool32 residencyStandard3DBlockShape = {}; - Bool32 residencyAlignedMipSize = {}; - Bool32 residencyNonResidentStrict = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSparseProperties; - }; -#endif - - // wrapper struct for struct VkPhysicalDeviceProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProperties.html - struct PhysicalDeviceProperties - { - using NativeType = VkPhysicalDeviceProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties( uint32_t apiVersion_ = {}, - uint32_t driverVersion_ = {}, - uint32_t vendorID_ = {}, - uint32_t deviceID_ = {}, - PhysicalDeviceType deviceType_ = PhysicalDeviceType::eOther, - std::array const & deviceName_ = {}, - std::array const & pipelineCacheUUID_ = {}, - PhysicalDeviceLimits limits_ = {}, - PhysicalDeviceSparseProperties sparseProperties_ = {} ) VULKAN_HPP_NOEXCEPT - : apiVersion{ apiVersion_ } - , driverVersion{ driverVersion_ } - , vendorID{ vendorID_ } - , deviceID{ deviceID_ } - , deviceType{ deviceType_ } - , deviceName{ deviceName_ } - , pipelineCacheUUID{ pipelineCacheUUID_ } - , limits{ limits_ } - , sparseProperties{ sparseProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties( PhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceProperties( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceProperties & operator=( PhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceProperties & operator=( VkPhysicalDeviceProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &, - PhysicalDeviceLimits const &, - PhysicalDeviceSparseProperties const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( apiVersion, driverVersion, vendorID, deviceID, deviceType, deviceName, pipelineCacheUUID, limits, sparseProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::partial_ordering operator<=>( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = apiVersion <=> rhs.apiVersion; cmp != 0 ) - return cmp; - if ( auto cmp = driverVersion <=> rhs.driverVersion; cmp != 0 ) - return cmp; - if ( auto cmp = vendorID <=> rhs.vendorID; cmp != 0 ) - return cmp; - if ( auto cmp = deviceID <=> rhs.deviceID; cmp != 0 ) - return cmp; - if ( auto cmp = deviceType <=> rhs.deviceType; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( deviceName, rhs.deviceName ); cmp != 0 ) - return ( cmp < 0 ) ? std::partial_ordering::less : std::partial_ordering::greater; - if ( auto cmp = pipelineCacheUUID <=> rhs.pipelineCacheUUID; cmp != 0 ) - return cmp; - if ( auto cmp = limits <=> rhs.limits; cmp != 0 ) - return cmp; - if ( auto cmp = sparseProperties <=> rhs.sparseProperties; cmp != 0 ) - return cmp; - - return std::partial_ordering::equivalent; - } -#endif - - bool operator==( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( apiVersion == rhs.apiVersion ) && ( driverVersion == rhs.driverVersion ) && ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && - ( deviceType == rhs.deviceType ) && ( strcmp( deviceName, rhs.deviceName ) == 0 ) && ( pipelineCacheUUID == rhs.pipelineCacheUUID ) && - ( limits == rhs.limits ) && ( sparseProperties == rhs.sparseProperties ); - } - - bool operator!=( PhysicalDeviceProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t apiVersion = {}; - uint32_t driverVersion = {}; - uint32_t vendorID = {}; - uint32_t deviceID = {}; - PhysicalDeviceType deviceType = PhysicalDeviceType::eOther; - ArrayWrapper1D deviceName = {}; - ArrayWrapper1D pipelineCacheUUID = {}; - PhysicalDeviceLimits limits = {}; - PhysicalDeviceSparseProperties sparseProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceProperties; - }; -#endif - - // wrapper struct for struct VkPhysicalDeviceProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProperties2.html - struct PhysicalDeviceProperties2 - { - using NativeType = VkPhysicalDeviceProperties2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProperties2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties2( PhysicalDeviceProperties properties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , properties{ properties_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProperties2( PhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceProperties2( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceProperties2( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceProperties2 & operator=( PhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceProperties2 & operator=( VkPhysicalDeviceProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceProperties2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProperties2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProperties2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProperties2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, properties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceProperties2 const & ) const = default; -#else - bool operator==( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); -# endif - } - - bool operator!=( PhysicalDeviceProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceProperties2; - void * pNext = {}; - PhysicalDeviceProperties properties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceProperties2; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceProperties2; - }; - - using PhysicalDeviceProperties2KHR = PhysicalDeviceProperties2; - - // wrapper struct for struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredApiVulkanPropertiesKHR.html - struct PhysicalDeviceLayeredApiVulkanPropertiesKHR - { - using NativeType = VkPhysicalDeviceLayeredApiVulkanPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLayeredApiVulkanPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLayeredApiVulkanPropertiesKHR( PhysicalDeviceProperties2 properties_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , properties{ properties_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - PhysicalDeviceLayeredApiVulkanPropertiesKHR( PhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceLayeredApiVulkanPropertiesKHR( VkPhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceLayeredApiVulkanPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceLayeredApiVulkanPropertiesKHR & operator=( PhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceLayeredApiVulkanPropertiesKHR & operator=( VkPhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceLayeredApiVulkanPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredApiVulkanPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredApiVulkanPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredApiVulkanPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, properties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceLayeredApiVulkanPropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); -# endif - } - - bool operator!=( PhysicalDeviceLayeredApiVulkanPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceLayeredApiVulkanPropertiesKHR; - void * pNext = {}; - PhysicalDeviceProperties2 properties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceLayeredApiVulkanPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceLayeredApiVulkanPropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceLayeredDriverPropertiesMSFT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLayeredDriverPropertiesMSFT.html - struct PhysicalDeviceLayeredDriverPropertiesMSFT - { - using NativeType = VkPhysicalDeviceLayeredDriverPropertiesMSFT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceLayeredDriverPropertiesMSFT( LayeredDriverUnderlyingApiMSFT underlyingAPI_ = LayeredDriverUnderlyingApiMSFT::eNone, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , underlyingAPI{ underlyingAPI_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceLayeredDriverPropertiesMSFT( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceLayeredDriverPropertiesMSFT( VkPhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceLayeredDriverPropertiesMSFT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceLayeredDriverPropertiesMSFT & operator=( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceLayeredDriverPropertiesMSFT & operator=( VkPhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceLayeredDriverPropertiesMSFT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredDriverPropertiesMSFT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredDriverPropertiesMSFT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLayeredDriverPropertiesMSFT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, underlyingAPI ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceLayeredDriverPropertiesMSFT const & ) const = default; -#else - bool operator==( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( underlyingAPI == rhs.underlyingAPI ); -# endif - } - - bool operator!=( PhysicalDeviceLayeredDriverPropertiesMSFT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT; - void * pNext = {}; - LayeredDriverUnderlyingApiMSFT underlyingAPI = LayeredDriverUnderlyingApiMSFT::eNone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceLayeredDriverPropertiesMSFT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceLayeredDriverPropertiesMSFT; - }; - - // wrapper struct for struct VkPhysicalDeviceLegacyDitheringFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLegacyDitheringFeaturesEXT.html - struct PhysicalDeviceLegacyDitheringFeaturesEXT - { - using NativeType = VkPhysicalDeviceLegacyDitheringFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceLegacyDitheringFeaturesEXT( Bool32 legacyDithering_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , legacyDithering{ legacyDithering_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceLegacyDitheringFeaturesEXT( PhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceLegacyDitheringFeaturesEXT( VkPhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceLegacyDitheringFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceLegacyDitheringFeaturesEXT & operator=( PhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceLegacyDitheringFeaturesEXT & operator=( VkPhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyDitheringFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyDitheringFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyDitheringFeaturesEXT & setLegacyDithering( Bool32 legacyDithering_ ) & VULKAN_HPP_NOEXCEPT - { - legacyDithering = legacyDithering_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyDitheringFeaturesEXT && setLegacyDithering( Bool32 legacyDithering_ ) && VULKAN_HPP_NOEXCEPT - { - legacyDithering = legacyDithering_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceLegacyDitheringFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLegacyDitheringFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLegacyDitheringFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLegacyDitheringFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, legacyDithering ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceLegacyDitheringFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( legacyDithering == rhs.legacyDithering ); -# endif - } - - bool operator!=( PhysicalDeviceLegacyDitheringFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT; - void * pNext = {}; - Bool32 legacyDithering = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceLegacyDitheringFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceLegacyDitheringFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.html - struct PhysicalDeviceLegacyVertexAttributesFeaturesEXT - { - using NativeType = VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLegacyVertexAttributesFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceLegacyVertexAttributesFeaturesEXT( Bool32 legacyVertexAttributes_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , legacyVertexAttributes{ legacyVertexAttributes_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceLegacyVertexAttributesFeaturesEXT( PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceLegacyVertexAttributesFeaturesEXT( VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceLegacyVertexAttributesFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceLegacyVertexAttributesFeaturesEXT & operator=( PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceLegacyVertexAttributesFeaturesEXT & operator=( VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyVertexAttributesFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyVertexAttributesFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyVertexAttributesFeaturesEXT & setLegacyVertexAttributes( Bool32 legacyVertexAttributes_ ) & VULKAN_HPP_NOEXCEPT - { - legacyVertexAttributes = legacyVertexAttributes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLegacyVertexAttributesFeaturesEXT && setLegacyVertexAttributes( Bool32 legacyVertexAttributes_ ) && - VULKAN_HPP_NOEXCEPT - { - legacyVertexAttributes = legacyVertexAttributes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, legacyVertexAttributes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( legacyVertexAttributes == rhs.legacyVertexAttributes ); -# endif - } - - bool operator!=( PhysicalDeviceLegacyVertexAttributesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceLegacyVertexAttributesFeaturesEXT; - void * pNext = {}; - Bool32 legacyVertexAttributes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceLegacyVertexAttributesFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceLegacyVertexAttributesFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT.html - struct PhysicalDeviceLegacyVertexAttributesPropertiesEXT - { - using NativeType = VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLegacyVertexAttributesPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceLegacyVertexAttributesPropertiesEXT( Bool32 nativeUnalignedPerformance_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , nativeUnalignedPerformance{ nativeUnalignedPerformance_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceLegacyVertexAttributesPropertiesEXT( PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceLegacyVertexAttributesPropertiesEXT( VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceLegacyVertexAttributesPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceLegacyVertexAttributesPropertiesEXT & - operator=( PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceLegacyVertexAttributesPropertiesEXT & operator=( VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, nativeUnalignedPerformance ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( nativeUnalignedPerformance == rhs.nativeUnalignedPerformance ); -# endif - } - - bool operator!=( PhysicalDeviceLegacyVertexAttributesPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceLegacyVertexAttributesPropertiesEXT; - void * pNext = {}; - Bool32 nativeUnalignedPerformance = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceLegacyVertexAttributesPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceLegacyVertexAttributesPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceLineRasterizationFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLineRasterizationFeatures.html - struct PhysicalDeviceLineRasterizationFeatures - { - using NativeType = VkPhysicalDeviceLineRasterizationFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLineRasterizationFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeatures( Bool32 rectangularLines_ = {}, - Bool32 bresenhamLines_ = {}, - Bool32 smoothLines_ = {}, - Bool32 stippledRectangularLines_ = {}, - Bool32 stippledBresenhamLines_ = {}, - Bool32 stippledSmoothLines_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rectangularLines{ rectangularLines_ } - , bresenhamLines{ bresenhamLines_ } - , smoothLines{ smoothLines_ } - , stippledRectangularLines{ stippledRectangularLines_ } - , stippledBresenhamLines{ stippledBresenhamLines_ } - , stippledSmoothLines{ stippledSmoothLines_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationFeatures( PhysicalDeviceLineRasterizationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceLineRasterizationFeatures( VkPhysicalDeviceLineRasterizationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceLineRasterizationFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceLineRasterizationFeatures & operator=( PhysicalDeviceLineRasterizationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceLineRasterizationFeatures & operator=( VkPhysicalDeviceLineRasterizationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setRectangularLines( Bool32 rectangularLines_ ) & VULKAN_HPP_NOEXCEPT - { - rectangularLines = rectangularLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setRectangularLines( Bool32 rectangularLines_ ) && VULKAN_HPP_NOEXCEPT - { - rectangularLines = rectangularLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setBresenhamLines( Bool32 bresenhamLines_ ) & VULKAN_HPP_NOEXCEPT - { - bresenhamLines = bresenhamLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setBresenhamLines( Bool32 bresenhamLines_ ) && VULKAN_HPP_NOEXCEPT - { - bresenhamLines = bresenhamLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setSmoothLines( Bool32 smoothLines_ ) & VULKAN_HPP_NOEXCEPT - { - smoothLines = smoothLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setSmoothLines( Bool32 smoothLines_ ) && VULKAN_HPP_NOEXCEPT - { - smoothLines = smoothLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setStippledRectangularLines( Bool32 stippledRectangularLines_ ) & VULKAN_HPP_NOEXCEPT - { - stippledRectangularLines = stippledRectangularLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setStippledRectangularLines( Bool32 stippledRectangularLines_ ) && VULKAN_HPP_NOEXCEPT - { - stippledRectangularLines = stippledRectangularLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setStippledBresenhamLines( Bool32 stippledBresenhamLines_ ) & VULKAN_HPP_NOEXCEPT - { - stippledBresenhamLines = stippledBresenhamLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setStippledBresenhamLines( Bool32 stippledBresenhamLines_ ) && VULKAN_HPP_NOEXCEPT - { - stippledBresenhamLines = stippledBresenhamLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures & setStippledSmoothLines( Bool32 stippledSmoothLines_ ) & VULKAN_HPP_NOEXCEPT - { - stippledSmoothLines = stippledSmoothLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLineRasterizationFeatures && setStippledSmoothLines( Bool32 stippledSmoothLines_ ) && VULKAN_HPP_NOEXCEPT - { - stippledSmoothLines = stippledSmoothLines_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceLineRasterizationFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLineRasterizationFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLineRasterizationFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLineRasterizationFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rectangularLines, bresenhamLines, smoothLines, stippledRectangularLines, stippledBresenhamLines, stippledSmoothLines ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceLineRasterizationFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceLineRasterizationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rectangularLines == rhs.rectangularLines ) && ( bresenhamLines == rhs.bresenhamLines ) && - ( smoothLines == rhs.smoothLines ) && ( stippledRectangularLines == rhs.stippledRectangularLines ) && - ( stippledBresenhamLines == rhs.stippledBresenhamLines ) && ( stippledSmoothLines == rhs.stippledSmoothLines ); -# endif - } - - bool operator!=( PhysicalDeviceLineRasterizationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceLineRasterizationFeatures; - void * pNext = {}; - Bool32 rectangularLines = {}; - Bool32 bresenhamLines = {}; - Bool32 smoothLines = {}; - Bool32 stippledRectangularLines = {}; - Bool32 stippledBresenhamLines = {}; - Bool32 stippledSmoothLines = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceLineRasterizationFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceLineRasterizationFeatures; - }; - - using PhysicalDeviceLineRasterizationFeaturesEXT = PhysicalDeviceLineRasterizationFeatures; - using PhysicalDeviceLineRasterizationFeaturesKHR = PhysicalDeviceLineRasterizationFeatures; - - // wrapper struct for struct VkPhysicalDeviceLineRasterizationProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLineRasterizationProperties.html - struct PhysicalDeviceLineRasterizationProperties - { - using NativeType = VkPhysicalDeviceLineRasterizationProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLineRasterizationProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationProperties( uint32_t lineSubPixelPrecisionBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , lineSubPixelPrecisionBits{ lineSubPixelPrecisionBits_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceLineRasterizationProperties( PhysicalDeviceLineRasterizationProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceLineRasterizationProperties( VkPhysicalDeviceLineRasterizationProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceLineRasterizationProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceLineRasterizationProperties & operator=( PhysicalDeviceLineRasterizationProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceLineRasterizationProperties & operator=( VkPhysicalDeviceLineRasterizationProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceLineRasterizationProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLineRasterizationProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLineRasterizationProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLineRasterizationProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, lineSubPixelPrecisionBits ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceLineRasterizationProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceLineRasterizationProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits ); -# endif - } - - bool operator!=( PhysicalDeviceLineRasterizationProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceLineRasterizationProperties; - void * pNext = {}; - uint32_t lineSubPixelPrecisionBits = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceLineRasterizationProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceLineRasterizationProperties; - }; - - using PhysicalDeviceLineRasterizationPropertiesEXT = PhysicalDeviceLineRasterizationProperties; - using PhysicalDeviceLineRasterizationPropertiesKHR = PhysicalDeviceLineRasterizationProperties; - - // wrapper struct for struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceLinearColorAttachmentFeaturesNV.html - struct PhysicalDeviceLinearColorAttachmentFeaturesNV - { - using NativeType = VkPhysicalDeviceLinearColorAttachmentFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceLinearColorAttachmentFeaturesNV( Bool32 linearColorAttachment_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , linearColorAttachment{ linearColorAttachment_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceLinearColorAttachmentFeaturesNV( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceLinearColorAttachmentFeaturesNV( VkPhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceLinearColorAttachmentFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceLinearColorAttachmentFeaturesNV & operator=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceLinearColorAttachmentFeaturesNV & operator=( VkPhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV & setLinearColorAttachment( Bool32 linearColorAttachment_ ) & VULKAN_HPP_NOEXCEPT - { - linearColorAttachment = linearColorAttachment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceLinearColorAttachmentFeaturesNV && setLinearColorAttachment( Bool32 linearColorAttachment_ ) && VULKAN_HPP_NOEXCEPT - { - linearColorAttachment = linearColorAttachment_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceLinearColorAttachmentFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, linearColorAttachment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceLinearColorAttachmentFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( linearColorAttachment == rhs.linearColorAttachment ); -# endif - } - - bool operator!=( PhysicalDeviceLinearColorAttachmentFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV; - void * pNext = {}; - Bool32 linearColorAttachment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceLinearColorAttachmentFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceLinearColorAttachmentFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceMaintenance10FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance10FeaturesKHR.html - struct PhysicalDeviceMaintenance10FeaturesKHR - { - using NativeType = VkPhysicalDeviceMaintenance10FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance10FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance10FeaturesKHR( Bool32 maintenance10_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maintenance10{ maintenance10_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance10FeaturesKHR( PhysicalDeviceMaintenance10FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance10FeaturesKHR( VkPhysicalDeviceMaintenance10FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance10FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance10FeaturesKHR & operator=( PhysicalDeviceMaintenance10FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance10FeaturesKHR & operator=( VkPhysicalDeviceMaintenance10FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance10FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance10FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance10FeaturesKHR & setMaintenance10( Bool32 maintenance10_ ) & VULKAN_HPP_NOEXCEPT - { - maintenance10 = maintenance10_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance10FeaturesKHR && setMaintenance10( Bool32 maintenance10_ ) && VULKAN_HPP_NOEXCEPT - { - maintenance10 = maintenance10_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMaintenance10FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance10FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance10FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance10FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maintenance10 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance10FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance10FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance10 == rhs.maintenance10 ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance10FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance10FeaturesKHR; - void * pNext = {}; - Bool32 maintenance10 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance10FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance10FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceMaintenance10PropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance10PropertiesKHR.html - struct PhysicalDeviceMaintenance10PropertiesKHR - { - using NativeType = VkPhysicalDeviceMaintenance10PropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance10PropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance10PropertiesKHR( Bool32 rgba4OpaqueBlackSwizzled_ = {}, - Bool32 resolveSrgbFormatAppliesTransferFunction_ = {}, - Bool32 resolveSrgbFormatSupportsTransferFunctionControl_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rgba4OpaqueBlackSwizzled{ rgba4OpaqueBlackSwizzled_ } - , resolveSrgbFormatAppliesTransferFunction{ resolveSrgbFormatAppliesTransferFunction_ } - , resolveSrgbFormatSupportsTransferFunctionControl{ resolveSrgbFormatSupportsTransferFunctionControl_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance10PropertiesKHR( PhysicalDeviceMaintenance10PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance10PropertiesKHR( VkPhysicalDeviceMaintenance10PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance10PropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance10PropertiesKHR & operator=( PhysicalDeviceMaintenance10PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance10PropertiesKHR & operator=( VkPhysicalDeviceMaintenance10PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMaintenance10PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance10PropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance10PropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance10PropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rgba4OpaqueBlackSwizzled, resolveSrgbFormatAppliesTransferFunction, resolveSrgbFormatSupportsTransferFunctionControl ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance10PropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance10PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rgba4OpaqueBlackSwizzled == rhs.rgba4OpaqueBlackSwizzled ) && - ( resolveSrgbFormatAppliesTransferFunction == rhs.resolveSrgbFormatAppliesTransferFunction ) && - ( resolveSrgbFormatSupportsTransferFunctionControl == rhs.resolveSrgbFormatSupportsTransferFunctionControl ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance10PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance10PropertiesKHR; - void * pNext = {}; - Bool32 rgba4OpaqueBlackSwizzled = {}; - Bool32 resolveSrgbFormatAppliesTransferFunction = {}; - Bool32 resolveSrgbFormatSupportsTransferFunctionControl = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance10PropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance10PropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceMaintenance3Properties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance3Properties.html - struct PhysicalDeviceMaintenance3Properties - { - using NativeType = VkPhysicalDeviceMaintenance3Properties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance3Properties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance3Properties( uint32_t maxPerSetDescriptors_ = {}, - DeviceSize maxMemoryAllocationSize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxPerSetDescriptors{ maxPerSetDescriptors_ } - , maxMemoryAllocationSize{ maxMemoryAllocationSize_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance3Properties( PhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance3Properties( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance3Properties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance3Properties & operator=( PhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance3Properties & operator=( VkPhysicalDeviceMaintenance3Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMaintenance3Properties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance3Properties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance3Properties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance3Properties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxPerSetDescriptors, maxMemoryAllocationSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance3Properties const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) && - ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance3Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance3Properties; - void * pNext = {}; - uint32_t maxPerSetDescriptors = {}; - DeviceSize maxMemoryAllocationSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance3Properties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance3Properties; - }; - - using PhysicalDeviceMaintenance3PropertiesKHR = PhysicalDeviceMaintenance3Properties; - - // wrapper struct for struct VkPhysicalDeviceMaintenance4Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance4Features.html - struct PhysicalDeviceMaintenance4Features - { - using NativeType = VkPhysicalDeviceMaintenance4Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance4Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance4Features( Bool32 maintenance4_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maintenance4{ maintenance4_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance4Features( PhysicalDeviceMaintenance4Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance4Features( VkPhysicalDeviceMaintenance4Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance4Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance4Features & operator=( PhysicalDeviceMaintenance4Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance4Features & operator=( VkPhysicalDeviceMaintenance4Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance4Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance4Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance4Features & setMaintenance4( Bool32 maintenance4_ ) & VULKAN_HPP_NOEXCEPT - { - maintenance4 = maintenance4_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance4Features && setMaintenance4( Bool32 maintenance4_ ) && VULKAN_HPP_NOEXCEPT - { - maintenance4 = maintenance4_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMaintenance4Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance4Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance4Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance4Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maintenance4 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance4Features const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance4Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance4 == rhs.maintenance4 ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance4Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance4Features; - void * pNext = {}; - Bool32 maintenance4 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance4Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance4Features; - }; - - using PhysicalDeviceMaintenance4FeaturesKHR = PhysicalDeviceMaintenance4Features; - - // wrapper struct for struct VkPhysicalDeviceMaintenance4Properties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance4Properties.html - struct PhysicalDeviceMaintenance4Properties - { - using NativeType = VkPhysicalDeviceMaintenance4Properties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance4Properties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance4Properties( DeviceSize maxBufferSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxBufferSize{ maxBufferSize_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance4Properties( PhysicalDeviceMaintenance4Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance4Properties( VkPhysicalDeviceMaintenance4Properties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance4Properties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance4Properties & operator=( PhysicalDeviceMaintenance4Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance4Properties & operator=( VkPhysicalDeviceMaintenance4Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMaintenance4Properties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance4Properties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance4Properties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance4Properties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxBufferSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance4Properties const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance4Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxBufferSize == rhs.maxBufferSize ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance4Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance4Properties; - void * pNext = {}; - DeviceSize maxBufferSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance4Properties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance4Properties; - }; - - using PhysicalDeviceMaintenance4PropertiesKHR = PhysicalDeviceMaintenance4Properties; - - // wrapper struct for struct VkPhysicalDeviceMaintenance5Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance5Features.html - struct PhysicalDeviceMaintenance5Features - { - using NativeType = VkPhysicalDeviceMaintenance5Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance5Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance5Features( Bool32 maintenance5_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maintenance5{ maintenance5_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance5Features( PhysicalDeviceMaintenance5Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance5Features( VkPhysicalDeviceMaintenance5Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance5Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance5Features & operator=( PhysicalDeviceMaintenance5Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance5Features & operator=( VkPhysicalDeviceMaintenance5Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance5Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance5Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance5Features & setMaintenance5( Bool32 maintenance5_ ) & VULKAN_HPP_NOEXCEPT - { - maintenance5 = maintenance5_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance5Features && setMaintenance5( Bool32 maintenance5_ ) && VULKAN_HPP_NOEXCEPT - { - maintenance5 = maintenance5_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMaintenance5Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance5Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance5Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance5Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maintenance5 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance5Features const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance5Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance5 == rhs.maintenance5 ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance5Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance5Features; - void * pNext = {}; - Bool32 maintenance5 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance5Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance5Features; - }; - - using PhysicalDeviceMaintenance5FeaturesKHR = PhysicalDeviceMaintenance5Features; - - // wrapper struct for struct VkPhysicalDeviceMaintenance5Properties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance5Properties.html - struct PhysicalDeviceMaintenance5Properties - { - using NativeType = VkPhysicalDeviceMaintenance5Properties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance5Properties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance5Properties( Bool32 earlyFragmentMultisampleCoverageAfterSampleCounting_ = {}, - Bool32 earlyFragmentSampleMaskTestBeforeSampleCounting_ = {}, - Bool32 depthStencilSwizzleOneSupport_ = {}, - Bool32 polygonModePointSize_ = {}, - Bool32 nonStrictSinglePixelWideLinesUseParallelogram_ = {}, - Bool32 nonStrictWideLinesUseParallelogram_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , earlyFragmentMultisampleCoverageAfterSampleCounting{ earlyFragmentMultisampleCoverageAfterSampleCounting_ } - , earlyFragmentSampleMaskTestBeforeSampleCounting{ earlyFragmentSampleMaskTestBeforeSampleCounting_ } - , depthStencilSwizzleOneSupport{ depthStencilSwizzleOneSupport_ } - , polygonModePointSize{ polygonModePointSize_ } - , nonStrictSinglePixelWideLinesUseParallelogram{ nonStrictSinglePixelWideLinesUseParallelogram_ } - , nonStrictWideLinesUseParallelogram{ nonStrictWideLinesUseParallelogram_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance5Properties( PhysicalDeviceMaintenance5Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance5Properties( VkPhysicalDeviceMaintenance5Properties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance5Properties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance5Properties & operator=( PhysicalDeviceMaintenance5Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance5Properties & operator=( VkPhysicalDeviceMaintenance5Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMaintenance5Properties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance5Properties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance5Properties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance5Properties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - earlyFragmentMultisampleCoverageAfterSampleCounting, - earlyFragmentSampleMaskTestBeforeSampleCounting, - depthStencilSwizzleOneSupport, - polygonModePointSize, - nonStrictSinglePixelWideLinesUseParallelogram, - nonStrictWideLinesUseParallelogram ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance5Properties const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance5Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( earlyFragmentMultisampleCoverageAfterSampleCounting == rhs.earlyFragmentMultisampleCoverageAfterSampleCounting ) && - ( earlyFragmentSampleMaskTestBeforeSampleCounting == rhs.earlyFragmentSampleMaskTestBeforeSampleCounting ) && - ( depthStencilSwizzleOneSupport == rhs.depthStencilSwizzleOneSupport ) && ( polygonModePointSize == rhs.polygonModePointSize ) && - ( nonStrictSinglePixelWideLinesUseParallelogram == rhs.nonStrictSinglePixelWideLinesUseParallelogram ) && - ( nonStrictWideLinesUseParallelogram == rhs.nonStrictWideLinesUseParallelogram ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance5Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance5Properties; - void * pNext = {}; - Bool32 earlyFragmentMultisampleCoverageAfterSampleCounting = {}; - Bool32 earlyFragmentSampleMaskTestBeforeSampleCounting = {}; - Bool32 depthStencilSwizzleOneSupport = {}; - Bool32 polygonModePointSize = {}; - Bool32 nonStrictSinglePixelWideLinesUseParallelogram = {}; - Bool32 nonStrictWideLinesUseParallelogram = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance5Properties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance5Properties; - }; - - using PhysicalDeviceMaintenance5PropertiesKHR = PhysicalDeviceMaintenance5Properties; - - // wrapper struct for struct VkPhysicalDeviceMaintenance6Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance6Features.html - struct PhysicalDeviceMaintenance6Features - { - using NativeType = VkPhysicalDeviceMaintenance6Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance6Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance6Features( Bool32 maintenance6_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maintenance6{ maintenance6_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance6Features( PhysicalDeviceMaintenance6Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance6Features( VkPhysicalDeviceMaintenance6Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance6Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance6Features & operator=( PhysicalDeviceMaintenance6Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance6Features & operator=( VkPhysicalDeviceMaintenance6Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance6Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance6Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance6Features & setMaintenance6( Bool32 maintenance6_ ) & VULKAN_HPP_NOEXCEPT - { - maintenance6 = maintenance6_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance6Features && setMaintenance6( Bool32 maintenance6_ ) && VULKAN_HPP_NOEXCEPT - { - maintenance6 = maintenance6_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMaintenance6Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance6Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance6Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance6Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maintenance6 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance6Features const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance6Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance6 == rhs.maintenance6 ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance6Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance6Features; - void * pNext = {}; - Bool32 maintenance6 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance6Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance6Features; - }; - - using PhysicalDeviceMaintenance6FeaturesKHR = PhysicalDeviceMaintenance6Features; - - // wrapper struct for struct VkPhysicalDeviceMaintenance6Properties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance6Properties.html - struct PhysicalDeviceMaintenance6Properties - { - using NativeType = VkPhysicalDeviceMaintenance6Properties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance6Properties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance6Properties( Bool32 blockTexelViewCompatibleMultipleLayers_ = {}, - uint32_t maxCombinedImageSamplerDescriptorCount_ = {}, - Bool32 fragmentShadingRateClampCombinerInputs_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , blockTexelViewCompatibleMultipleLayers{ blockTexelViewCompatibleMultipleLayers_ } - , maxCombinedImageSamplerDescriptorCount{ maxCombinedImageSamplerDescriptorCount_ } - , fragmentShadingRateClampCombinerInputs{ fragmentShadingRateClampCombinerInputs_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance6Properties( PhysicalDeviceMaintenance6Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance6Properties( VkPhysicalDeviceMaintenance6Properties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance6Properties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance6Properties & operator=( PhysicalDeviceMaintenance6Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance6Properties & operator=( VkPhysicalDeviceMaintenance6Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMaintenance6Properties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance6Properties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance6Properties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance6Properties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, blockTexelViewCompatibleMultipleLayers, maxCombinedImageSamplerDescriptorCount, fragmentShadingRateClampCombinerInputs ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance6Properties const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance6Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( blockTexelViewCompatibleMultipleLayers == rhs.blockTexelViewCompatibleMultipleLayers ) && - ( maxCombinedImageSamplerDescriptorCount == rhs.maxCombinedImageSamplerDescriptorCount ) && - ( fragmentShadingRateClampCombinerInputs == rhs.fragmentShadingRateClampCombinerInputs ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance6Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance6Properties; - void * pNext = {}; - Bool32 blockTexelViewCompatibleMultipleLayers = {}; - uint32_t maxCombinedImageSamplerDescriptorCount = {}; - Bool32 fragmentShadingRateClampCombinerInputs = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance6Properties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance6Properties; - }; - - using PhysicalDeviceMaintenance6PropertiesKHR = PhysicalDeviceMaintenance6Properties; - - // wrapper struct for struct VkPhysicalDeviceMaintenance7FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance7FeaturesKHR.html - struct PhysicalDeviceMaintenance7FeaturesKHR - { - using NativeType = VkPhysicalDeviceMaintenance7FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance7FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance7FeaturesKHR( Bool32 maintenance7_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maintenance7{ maintenance7_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance7FeaturesKHR( PhysicalDeviceMaintenance7FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance7FeaturesKHR( VkPhysicalDeviceMaintenance7FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance7FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance7FeaturesKHR & operator=( PhysicalDeviceMaintenance7FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance7FeaturesKHR & operator=( VkPhysicalDeviceMaintenance7FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance7FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance7FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance7FeaturesKHR & setMaintenance7( Bool32 maintenance7_ ) & VULKAN_HPP_NOEXCEPT - { - maintenance7 = maintenance7_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance7FeaturesKHR && setMaintenance7( Bool32 maintenance7_ ) && VULKAN_HPP_NOEXCEPT - { - maintenance7 = maintenance7_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMaintenance7FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance7FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance7FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance7FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maintenance7 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance7FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance7FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance7 == rhs.maintenance7 ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance7FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance7FeaturesKHR; - void * pNext = {}; - Bool32 maintenance7 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance7FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance7FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceMaintenance7PropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance7PropertiesKHR.html - struct PhysicalDeviceMaintenance7PropertiesKHR - { - using NativeType = VkPhysicalDeviceMaintenance7PropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance7PropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance7PropertiesKHR( Bool32 robustFragmentShadingRateAttachmentAccess_ = {}, - Bool32 separateDepthStencilAttachmentAccess_ = {}, - uint32_t maxDescriptorSetTotalUniformBuffersDynamic_ = {}, - uint32_t maxDescriptorSetTotalStorageBuffersDynamic_ = {}, - uint32_t maxDescriptorSetTotalBuffersDynamic_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindTotalBuffersDynamic_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , robustFragmentShadingRateAttachmentAccess{ robustFragmentShadingRateAttachmentAccess_ } - , separateDepthStencilAttachmentAccess{ separateDepthStencilAttachmentAccess_ } - , maxDescriptorSetTotalUniformBuffersDynamic{ maxDescriptorSetTotalUniformBuffersDynamic_ } - , maxDescriptorSetTotalStorageBuffersDynamic{ maxDescriptorSetTotalStorageBuffersDynamic_ } - , maxDescriptorSetTotalBuffersDynamic{ maxDescriptorSetTotalBuffersDynamic_ } - , maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic{ maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic_ } - , maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic{ maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic_ } - , maxDescriptorSetUpdateAfterBindTotalBuffersDynamic{ maxDescriptorSetUpdateAfterBindTotalBuffersDynamic_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance7PropertiesKHR( PhysicalDeviceMaintenance7PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance7PropertiesKHR( VkPhysicalDeviceMaintenance7PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance7PropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance7PropertiesKHR & operator=( PhysicalDeviceMaintenance7PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance7PropertiesKHR & operator=( VkPhysicalDeviceMaintenance7PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMaintenance7PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance7PropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance7PropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance7PropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - robustFragmentShadingRateAttachmentAccess, - separateDepthStencilAttachmentAccess, - maxDescriptorSetTotalUniformBuffersDynamic, - maxDescriptorSetTotalStorageBuffersDynamic, - maxDescriptorSetTotalBuffersDynamic, - maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic, - maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic, - maxDescriptorSetUpdateAfterBindTotalBuffersDynamic ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance7PropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance7PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( robustFragmentShadingRateAttachmentAccess == rhs.robustFragmentShadingRateAttachmentAccess ) && - ( separateDepthStencilAttachmentAccess == rhs.separateDepthStencilAttachmentAccess ) && - ( maxDescriptorSetTotalUniformBuffersDynamic == rhs.maxDescriptorSetTotalUniformBuffersDynamic ) && - ( maxDescriptorSetTotalStorageBuffersDynamic == rhs.maxDescriptorSetTotalStorageBuffersDynamic ) && - ( maxDescriptorSetTotalBuffersDynamic == rhs.maxDescriptorSetTotalBuffersDynamic ) && - ( maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic ) && - ( maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic ) && - ( maxDescriptorSetUpdateAfterBindTotalBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindTotalBuffersDynamic ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance7PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance7PropertiesKHR; - void * pNext = {}; - Bool32 robustFragmentShadingRateAttachmentAccess = {}; - Bool32 separateDepthStencilAttachmentAccess = {}; - uint32_t maxDescriptorSetTotalUniformBuffersDynamic = {}; - uint32_t maxDescriptorSetTotalStorageBuffersDynamic = {}; - uint32_t maxDescriptorSetTotalBuffersDynamic = {}; - uint32_t maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic = {}; - uint32_t maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic = {}; - uint32_t maxDescriptorSetUpdateAfterBindTotalBuffersDynamic = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance7PropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance7PropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceMaintenance8FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance8FeaturesKHR.html - struct PhysicalDeviceMaintenance8FeaturesKHR - { - using NativeType = VkPhysicalDeviceMaintenance8FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance8FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance8FeaturesKHR( Bool32 maintenance8_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maintenance8{ maintenance8_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance8FeaturesKHR( PhysicalDeviceMaintenance8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance8FeaturesKHR( VkPhysicalDeviceMaintenance8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance8FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance8FeaturesKHR & operator=( PhysicalDeviceMaintenance8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance8FeaturesKHR & operator=( VkPhysicalDeviceMaintenance8FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance8FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance8FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance8FeaturesKHR & setMaintenance8( Bool32 maintenance8_ ) & VULKAN_HPP_NOEXCEPT - { - maintenance8 = maintenance8_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance8FeaturesKHR && setMaintenance8( Bool32 maintenance8_ ) && VULKAN_HPP_NOEXCEPT - { - maintenance8 = maintenance8_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMaintenance8FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance8FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance8FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance8FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maintenance8 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance8FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance8FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance8 == rhs.maintenance8 ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance8FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance8FeaturesKHR; - void * pNext = {}; - Bool32 maintenance8 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance8FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance8FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceMaintenance9FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance9FeaturesKHR.html - struct PhysicalDeviceMaintenance9FeaturesKHR - { - using NativeType = VkPhysicalDeviceMaintenance9FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance9FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance9FeaturesKHR( Bool32 maintenance9_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maintenance9{ maintenance9_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance9FeaturesKHR( PhysicalDeviceMaintenance9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance9FeaturesKHR( VkPhysicalDeviceMaintenance9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance9FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance9FeaturesKHR & operator=( PhysicalDeviceMaintenance9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance9FeaturesKHR & operator=( VkPhysicalDeviceMaintenance9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance9FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance9FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance9FeaturesKHR & setMaintenance9( Bool32 maintenance9_ ) & VULKAN_HPP_NOEXCEPT - { - maintenance9 = maintenance9_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMaintenance9FeaturesKHR && setMaintenance9( Bool32 maintenance9_ ) && VULKAN_HPP_NOEXCEPT - { - maintenance9 = maintenance9_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMaintenance9FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance9FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance9FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance9FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maintenance9 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance9FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance9FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maintenance9 == rhs.maintenance9 ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance9FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance9FeaturesKHR; - void * pNext = {}; - Bool32 maintenance9 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance9FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance9FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceMaintenance9PropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMaintenance9PropertiesKHR.html - struct PhysicalDeviceMaintenance9PropertiesKHR - { - using NativeType = VkPhysicalDeviceMaintenance9PropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMaintenance9PropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceMaintenance9PropertiesKHR( Bool32 image2DViewOf3DSparse_ = {}, - DefaultVertexAttributeValueKHR defaultVertexAttributeValue_ = DefaultVertexAttributeValueKHR::eZeroZeroZeroZero, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , image2DViewOf3DSparse{ image2DViewOf3DSparse_ } - , defaultVertexAttributeValue{ defaultVertexAttributeValue_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMaintenance9PropertiesKHR( PhysicalDeviceMaintenance9PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMaintenance9PropertiesKHR( VkPhysicalDeviceMaintenance9PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMaintenance9PropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMaintenance9PropertiesKHR & operator=( PhysicalDeviceMaintenance9PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMaintenance9PropertiesKHR & operator=( VkPhysicalDeviceMaintenance9PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMaintenance9PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance9PropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance9PropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMaintenance9PropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, image2DViewOf3DSparse, defaultVertexAttributeValue ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMaintenance9PropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceMaintenance9PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( image2DViewOf3DSparse == rhs.image2DViewOf3DSparse ) && - ( defaultVertexAttributeValue == rhs.defaultVertexAttributeValue ); -# endif - } - - bool operator!=( PhysicalDeviceMaintenance9PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMaintenance9PropertiesKHR; - void * pNext = {}; - Bool32 image2DViewOf3DSparse = {}; - DefaultVertexAttributeValueKHR defaultVertexAttributeValue = DefaultVertexAttributeValueKHR::eZeroZeroZeroZero; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance9PropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMaintenance9PropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.html - struct PhysicalDeviceMapMemoryPlacedFeaturesEXT - { - using NativeType = VkPhysicalDeviceMapMemoryPlacedFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMapMemoryPlacedFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedFeaturesEXT( Bool32 memoryMapPlaced_ = {}, - Bool32 memoryMapRangePlaced_ = {}, - Bool32 memoryUnmapReserve_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryMapPlaced{ memoryMapPlaced_ } - , memoryMapRangePlaced{ memoryMapRangePlaced_ } - , memoryUnmapReserve{ memoryUnmapReserve_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedFeaturesEXT( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMapMemoryPlacedFeaturesEXT( VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMapMemoryPlacedFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMapMemoryPlacedFeaturesEXT & operator=( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMapMemoryPlacedFeaturesEXT & operator=( VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & setMemoryMapPlaced( Bool32 memoryMapPlaced_ ) & VULKAN_HPP_NOEXCEPT - { - memoryMapPlaced = memoryMapPlaced_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT && setMemoryMapPlaced( Bool32 memoryMapPlaced_ ) && VULKAN_HPP_NOEXCEPT - { - memoryMapPlaced = memoryMapPlaced_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & setMemoryMapRangePlaced( Bool32 memoryMapRangePlaced_ ) & VULKAN_HPP_NOEXCEPT - { - memoryMapRangePlaced = memoryMapRangePlaced_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT && setMemoryMapRangePlaced( Bool32 memoryMapRangePlaced_ ) && VULKAN_HPP_NOEXCEPT - { - memoryMapRangePlaced = memoryMapRangePlaced_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT & setMemoryUnmapReserve( Bool32 memoryUnmapReserve_ ) & VULKAN_HPP_NOEXCEPT - { - memoryUnmapReserve = memoryUnmapReserve_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMapMemoryPlacedFeaturesEXT && setMemoryUnmapReserve( Bool32 memoryUnmapReserve_ ) && VULKAN_HPP_NOEXCEPT - { - memoryUnmapReserve = memoryUnmapReserve_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMapMemoryPlacedFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMapMemoryPlacedFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryMapPlaced, memoryMapRangePlaced, memoryUnmapReserve ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryMapPlaced == rhs.memoryMapPlaced ) && - ( memoryMapRangePlaced == rhs.memoryMapRangePlaced ) && ( memoryUnmapReserve == rhs.memoryUnmapReserve ); -# endif - } - - bool operator!=( PhysicalDeviceMapMemoryPlacedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMapMemoryPlacedFeaturesEXT; - void * pNext = {}; - Bool32 memoryMapPlaced = {}; - Bool32 memoryMapRangePlaced = {}; - Bool32 memoryUnmapReserve = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMapMemoryPlacedFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMapMemoryPlacedFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMapMemoryPlacedPropertiesEXT.html - struct PhysicalDeviceMapMemoryPlacedPropertiesEXT - { - using NativeType = VkPhysicalDeviceMapMemoryPlacedPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMapMemoryPlacedPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedPropertiesEXT( DeviceSize minPlacedMemoryMapAlignment_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minPlacedMemoryMapAlignment{ minPlacedMemoryMapAlignment_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMapMemoryPlacedPropertiesEXT( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMapMemoryPlacedPropertiesEXT( VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMapMemoryPlacedPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMapMemoryPlacedPropertiesEXT & operator=( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMapMemoryPlacedPropertiesEXT & operator=( VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMapMemoryPlacedPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMapMemoryPlacedPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minPlacedMemoryMapAlignment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minPlacedMemoryMapAlignment == rhs.minPlacedMemoryMapAlignment ); -# endif - } - - bool operator!=( PhysicalDeviceMapMemoryPlacedPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMapMemoryPlacedPropertiesEXT; - void * pNext = {}; - DeviceSize minPlacedMemoryMapAlignment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMapMemoryPlacedPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMapMemoryPlacedPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceMemoryBudgetPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryBudgetPropertiesEXT.html - struct PhysicalDeviceMemoryBudgetPropertiesEXT - { - using NativeType = VkPhysicalDeviceMemoryBudgetPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryBudgetPropertiesEXT( std::array const & heapBudget_ = {}, - std::array const & heapUsage_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , heapBudget{ heapBudget_ } - , heapUsage{ heapUsage_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryBudgetPropertiesEXT( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMemoryBudgetPropertiesEXT( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMemoryBudgetPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMemoryBudgetPropertiesEXT & operator=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMemoryBudgetPropertiesEXT & operator=( VkPhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryBudgetPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryBudgetPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryBudgetPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, heapBudget, heapUsage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMemoryBudgetPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( heapBudget == rhs.heapBudget ) && ( heapUsage == rhs.heapUsage ); -# endif - } - - bool operator!=( PhysicalDeviceMemoryBudgetPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT; - void * pNext = {}; - ArrayWrapper1D heapBudget = {}; - ArrayWrapper1D heapUsage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMemoryBudgetPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMemoryBudgetPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceMemoryDecompressionFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryDecompressionFeaturesEXT.html - struct PhysicalDeviceMemoryDecompressionFeaturesEXT - { - using NativeType = VkPhysicalDeviceMemoryDecompressionFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryDecompressionFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryDecompressionFeaturesEXT( Bool32 memoryDecompression_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryDecompression{ memoryDecompression_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryDecompressionFeaturesEXT( PhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMemoryDecompressionFeaturesEXT( VkPhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMemoryDecompressionFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMemoryDecompressionFeaturesEXT & operator=( PhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMemoryDecompressionFeaturesEXT & operator=( VkPhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryDecompressionFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryDecompressionFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryDecompressionFeaturesEXT & setMemoryDecompression( Bool32 memoryDecompression_ ) & VULKAN_HPP_NOEXCEPT - { - memoryDecompression = memoryDecompression_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryDecompressionFeaturesEXT && setMemoryDecompression( Bool32 memoryDecompression_ ) && VULKAN_HPP_NOEXCEPT - { - memoryDecompression = memoryDecompression_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMemoryDecompressionFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryDecompressionFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryDecompressionFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryDecompressionFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryDecompression ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMemoryDecompressionFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryDecompression == rhs.memoryDecompression ); -# endif - } - - bool operator!=( PhysicalDeviceMemoryDecompressionFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMemoryDecompressionFeaturesEXT; - void * pNext = {}; - Bool32 memoryDecompression = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMemoryDecompressionFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMemoryDecompressionFeaturesEXT; - }; - - using PhysicalDeviceMemoryDecompressionFeaturesNV = PhysicalDeviceMemoryDecompressionFeaturesEXT; - - // wrapper struct for struct VkPhysicalDeviceMemoryDecompressionPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryDecompressionPropertiesEXT.html - struct PhysicalDeviceMemoryDecompressionPropertiesEXT - { - using NativeType = VkPhysicalDeviceMemoryDecompressionPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryDecompressionPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryDecompressionPropertiesEXT( MemoryDecompressionMethodFlagsEXT decompressionMethods_ = {}, - uint64_t maxDecompressionIndirectCount_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , decompressionMethods{ decompressionMethods_ } - , maxDecompressionIndirectCount{ maxDecompressionIndirectCount_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceMemoryDecompressionPropertiesEXT( PhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMemoryDecompressionPropertiesEXT( VkPhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMemoryDecompressionPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMemoryDecompressionPropertiesEXT & operator=( PhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMemoryDecompressionPropertiesEXT & operator=( VkPhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMemoryDecompressionPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryDecompressionPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryDecompressionPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryDecompressionPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, decompressionMethods, maxDecompressionIndirectCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMemoryDecompressionPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( decompressionMethods == rhs.decompressionMethods ) && - ( maxDecompressionIndirectCount == rhs.maxDecompressionIndirectCount ); -# endif - } - - bool operator!=( PhysicalDeviceMemoryDecompressionPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMemoryDecompressionPropertiesEXT; - void * pNext = {}; - MemoryDecompressionMethodFlagsEXT decompressionMethods = {}; - uint64_t maxDecompressionIndirectCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMemoryDecompressionPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMemoryDecompressionPropertiesEXT; - }; - - using PhysicalDeviceMemoryDecompressionPropertiesNV = PhysicalDeviceMemoryDecompressionPropertiesEXT; - - // wrapper struct for struct VkPhysicalDeviceMemoryPriorityFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryPriorityFeaturesEXT.html - struct PhysicalDeviceMemoryPriorityFeaturesEXT - { - using NativeType = VkPhysicalDeviceMemoryPriorityFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( Bool32 memoryPriority_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryPriority{ memoryPriority_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMemoryPriorityFeaturesEXT( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMemoryPriorityFeaturesEXT( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMemoryPriorityFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMemoryPriorityFeaturesEXT & operator=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMemoryPriorityFeaturesEXT & operator=( VkPhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryPriorityFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryPriorityFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryPriorityFeaturesEXT & setMemoryPriority( Bool32 memoryPriority_ ) & VULKAN_HPP_NOEXCEPT - { - memoryPriority = memoryPriority_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryPriorityFeaturesEXT && setMemoryPriority( Bool32 memoryPriority_ ) && VULKAN_HPP_NOEXCEPT - { - memoryPriority = memoryPriority_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryPriorityFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryPriorityFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryPriorityFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryPriority ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMemoryPriorityFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryPriority == rhs.memoryPriority ); -# endif - } - - bool operator!=( PhysicalDeviceMemoryPriorityFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT; - void * pNext = {}; - Bool32 memoryPriority = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMemoryPriorityFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMemoryPriorityFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceMemoryProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryProperties.html - struct PhysicalDeviceMemoryProperties - { - using NativeType = VkPhysicalDeviceMemoryProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties( uint32_t memoryTypeCount_ = {}, - std::array const & memoryTypes_ = {}, - uint32_t memoryHeapCount_ = {}, - std::array const & memoryHeaps_ = {} ) VULKAN_HPP_NOEXCEPT - : memoryTypeCount{ memoryTypeCount_ } - , memoryTypes{ memoryTypes_ } - , memoryHeapCount{ memoryHeapCount_ } - , memoryHeaps{ memoryHeaps_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties( PhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMemoryProperties( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMemoryProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMemoryProperties & operator=( PhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMemoryProperties & operator=( VkPhysicalDeviceMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMemoryProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - uint32_t const &, - ArrayWrapper1D const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( memoryTypeCount, memoryTypes, memoryHeapCount, memoryHeaps ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = memoryTypeCount <=> rhs.memoryTypeCount; cmp != 0 ) - return cmp; - for ( size_t i = 0; i < memoryTypeCount; ++i ) - { - if ( auto cmp = memoryTypes[i] <=> rhs.memoryTypes[i]; cmp != 0 ) - return cmp; - } - if ( auto cmp = memoryHeapCount <=> rhs.memoryHeapCount; cmp != 0 ) - return cmp; - for ( size_t i = 0; i < memoryHeapCount; ++i ) - { - if ( auto cmp = memoryHeaps[i] <=> rhs.memoryHeaps[i]; cmp != 0 ) - return cmp; - } - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( memoryTypeCount == rhs.memoryTypeCount ) && ( memcmp( memoryTypes, rhs.memoryTypes, memoryTypeCount * sizeof( MemoryType ) ) == 0 ) && - ( memoryHeapCount == rhs.memoryHeapCount ) && ( memcmp( memoryHeaps, rhs.memoryHeaps, memoryHeapCount * sizeof( MemoryHeap ) ) == 0 ); - } - - bool operator!=( PhysicalDeviceMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t memoryTypeCount = {}; - ArrayWrapper1D memoryTypes = {}; - uint32_t memoryHeapCount = {}; - ArrayWrapper1D memoryHeaps = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMemoryProperties; - }; -#endif - - // wrapper struct for struct VkPhysicalDeviceMemoryProperties2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMemoryProperties2.html - struct PhysicalDeviceMemoryProperties2 - { - using NativeType = VkPhysicalDeviceMemoryProperties2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMemoryProperties2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties2( PhysicalDeviceMemoryProperties memoryProperties_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryProperties{ memoryProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMemoryProperties2( PhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMemoryProperties2( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMemoryProperties2( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMemoryProperties2 & operator=( PhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMemoryProperties2 & operator=( VkPhysicalDeviceMemoryProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMemoryProperties2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryProperties2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryProperties2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMemoryProperties2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMemoryProperties2 const & ) const = default; -#else - bool operator==( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryProperties == rhs.memoryProperties ); -# endif - } - - bool operator!=( PhysicalDeviceMemoryProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMemoryProperties2; - void * pNext = {}; - PhysicalDeviceMemoryProperties memoryProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMemoryProperties2; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMemoryProperties2; - }; - - using PhysicalDeviceMemoryProperties2KHR = PhysicalDeviceMemoryProperties2; - - // wrapper struct for struct VkPhysicalDeviceMeshShaderFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderFeaturesEXT.html - struct PhysicalDeviceMeshShaderFeaturesEXT - { - using NativeType = VkPhysicalDeviceMeshShaderFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesEXT( Bool32 taskShader_ = {}, - Bool32 meshShader_ = {}, - Bool32 multiviewMeshShader_ = {}, - Bool32 primitiveFragmentShadingRateMeshShader_ = {}, - Bool32 meshShaderQueries_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , taskShader{ taskShader_ } - , meshShader{ meshShader_ } - , multiviewMeshShader{ multiviewMeshShader_ } - , primitiveFragmentShadingRateMeshShader{ primitiveFragmentShadingRateMeshShader_ } - , meshShaderQueries{ meshShaderQueries_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesEXT( PhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMeshShaderFeaturesEXT( VkPhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMeshShaderFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMeshShaderFeaturesEXT & operator=( PhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMeshShaderFeaturesEXT & operator=( VkPhysicalDeviceMeshShaderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setTaskShader( Bool32 taskShader_ ) & VULKAN_HPP_NOEXCEPT - { - taskShader = taskShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && setTaskShader( Bool32 taskShader_ ) && VULKAN_HPP_NOEXCEPT - { - taskShader = taskShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setMeshShader( Bool32 meshShader_ ) & VULKAN_HPP_NOEXCEPT - { - meshShader = meshShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && setMeshShader( Bool32 meshShader_ ) && VULKAN_HPP_NOEXCEPT - { - meshShader = meshShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setMultiviewMeshShader( Bool32 multiviewMeshShader_ ) & VULKAN_HPP_NOEXCEPT - { - multiviewMeshShader = multiviewMeshShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && setMultiviewMeshShader( Bool32 multiviewMeshShader_ ) && VULKAN_HPP_NOEXCEPT - { - multiviewMeshShader = multiviewMeshShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setPrimitiveFragmentShadingRateMeshShader( Bool32 primitiveFragmentShadingRateMeshShader_ ) & - VULKAN_HPP_NOEXCEPT - { - primitiveFragmentShadingRateMeshShader = primitiveFragmentShadingRateMeshShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && - setPrimitiveFragmentShadingRateMeshShader( Bool32 primitiveFragmentShadingRateMeshShader_ ) && - VULKAN_HPP_NOEXCEPT - { - primitiveFragmentShadingRateMeshShader = primitiveFragmentShadingRateMeshShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT & setMeshShaderQueries( Bool32 meshShaderQueries_ ) & VULKAN_HPP_NOEXCEPT - { - meshShaderQueries = meshShaderQueries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesEXT && setMeshShaderQueries( Bool32 meshShaderQueries_ ) && VULKAN_HPP_NOEXCEPT - { - meshShaderQueries = meshShaderQueries_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMeshShaderFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, taskShader, meshShader, multiviewMeshShader, primitiveFragmentShadingRateMeshShader, meshShaderQueries ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMeshShaderFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMeshShaderFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) && ( meshShader == rhs.meshShader ) && - ( multiviewMeshShader == rhs.multiviewMeshShader ) && ( primitiveFragmentShadingRateMeshShader == rhs.primitiveFragmentShadingRateMeshShader ) && - ( meshShaderQueries == rhs.meshShaderQueries ); -# endif - } - - bool operator!=( PhysicalDeviceMeshShaderFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesEXT; - void * pNext = {}; - Bool32 taskShader = {}; - Bool32 meshShader = {}; - Bool32 multiviewMeshShader = {}; - Bool32 primitiveFragmentShadingRateMeshShader = {}; - Bool32 meshShaderQueries = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMeshShaderFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMeshShaderFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceMeshShaderFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderFeaturesNV.html - struct PhysicalDeviceMeshShaderFeaturesNV - { - using NativeType = VkPhysicalDeviceMeshShaderFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( Bool32 taskShader_ = {}, Bool32 meshShader_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , taskShader{ taskShader_ } - , meshShader{ meshShader_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMeshShaderFeaturesNV( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMeshShaderFeaturesNV( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMeshShaderFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMeshShaderFeaturesNV & operator=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMeshShaderFeaturesNV & operator=( VkPhysicalDeviceMeshShaderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV & setTaskShader( Bool32 taskShader_ ) & VULKAN_HPP_NOEXCEPT - { - taskShader = taskShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV && setTaskShader( Bool32 taskShader_ ) && VULKAN_HPP_NOEXCEPT - { - taskShader = taskShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV & setMeshShader( Bool32 meshShader_ ) & VULKAN_HPP_NOEXCEPT - { - meshShader = meshShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderFeaturesNV && setMeshShader( Bool32 meshShader_ ) && VULKAN_HPP_NOEXCEPT - { - meshShader = meshShader_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMeshShaderFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, taskShader, meshShader ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMeshShaderFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( taskShader == rhs.taskShader ) && ( meshShader == rhs.meshShader ); -# endif - } - - bool operator!=( PhysicalDeviceMeshShaderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMeshShaderFeaturesNV; - void * pNext = {}; - Bool32 taskShader = {}; - Bool32 meshShader = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMeshShaderFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMeshShaderFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceMeshShaderPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderPropertiesEXT.html - struct PhysicalDeviceMeshShaderPropertiesEXT - { - using NativeType = VkPhysicalDeviceMeshShaderPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesEXT( uint32_t maxTaskWorkGroupTotalCount_ = {}, - std::array const & maxTaskWorkGroupCount_ = {}, - uint32_t maxTaskWorkGroupInvocations_ = {}, - std::array const & maxTaskWorkGroupSize_ = {}, - uint32_t maxTaskPayloadSize_ = {}, - uint32_t maxTaskSharedMemorySize_ = {}, - uint32_t maxTaskPayloadAndSharedMemorySize_ = {}, - uint32_t maxMeshWorkGroupTotalCount_ = {}, - std::array const & maxMeshWorkGroupCount_ = {}, - uint32_t maxMeshWorkGroupInvocations_ = {}, - std::array const & maxMeshWorkGroupSize_ = {}, - uint32_t maxMeshSharedMemorySize_ = {}, - uint32_t maxMeshPayloadAndSharedMemorySize_ = {}, - uint32_t maxMeshOutputMemorySize_ = {}, - uint32_t maxMeshPayloadAndOutputMemorySize_ = {}, - uint32_t maxMeshOutputComponents_ = {}, - uint32_t maxMeshOutputVertices_ = {}, - uint32_t maxMeshOutputPrimitives_ = {}, - uint32_t maxMeshOutputLayers_ = {}, - uint32_t maxMeshMultiviewViewCount_ = {}, - uint32_t meshOutputPerVertexGranularity_ = {}, - uint32_t meshOutputPerPrimitiveGranularity_ = {}, - uint32_t maxPreferredTaskWorkGroupInvocations_ = {}, - uint32_t maxPreferredMeshWorkGroupInvocations_ = {}, - Bool32 prefersLocalInvocationVertexOutput_ = {}, - Bool32 prefersLocalInvocationPrimitiveOutput_ = {}, - Bool32 prefersCompactVertexOutput_ = {}, - Bool32 prefersCompactPrimitiveOutput_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxTaskWorkGroupTotalCount{ maxTaskWorkGroupTotalCount_ } - , maxTaskWorkGroupCount{ maxTaskWorkGroupCount_ } - , maxTaskWorkGroupInvocations{ maxTaskWorkGroupInvocations_ } - , maxTaskWorkGroupSize{ maxTaskWorkGroupSize_ } - , maxTaskPayloadSize{ maxTaskPayloadSize_ } - , maxTaskSharedMemorySize{ maxTaskSharedMemorySize_ } - , maxTaskPayloadAndSharedMemorySize{ maxTaskPayloadAndSharedMemorySize_ } - , maxMeshWorkGroupTotalCount{ maxMeshWorkGroupTotalCount_ } - , maxMeshWorkGroupCount{ maxMeshWorkGroupCount_ } - , maxMeshWorkGroupInvocations{ maxMeshWorkGroupInvocations_ } - , maxMeshWorkGroupSize{ maxMeshWorkGroupSize_ } - , maxMeshSharedMemorySize{ maxMeshSharedMemorySize_ } - , maxMeshPayloadAndSharedMemorySize{ maxMeshPayloadAndSharedMemorySize_ } - , maxMeshOutputMemorySize{ maxMeshOutputMemorySize_ } - , maxMeshPayloadAndOutputMemorySize{ maxMeshPayloadAndOutputMemorySize_ } - , maxMeshOutputComponents{ maxMeshOutputComponents_ } - , maxMeshOutputVertices{ maxMeshOutputVertices_ } - , maxMeshOutputPrimitives{ maxMeshOutputPrimitives_ } - , maxMeshOutputLayers{ maxMeshOutputLayers_ } - , maxMeshMultiviewViewCount{ maxMeshMultiviewViewCount_ } - , meshOutputPerVertexGranularity{ meshOutputPerVertexGranularity_ } - , meshOutputPerPrimitiveGranularity{ meshOutputPerPrimitiveGranularity_ } - , maxPreferredTaskWorkGroupInvocations{ maxPreferredTaskWorkGroupInvocations_ } - , maxPreferredMeshWorkGroupInvocations{ maxPreferredMeshWorkGroupInvocations_ } - , prefersLocalInvocationVertexOutput{ prefersLocalInvocationVertexOutput_ } - , prefersLocalInvocationPrimitiveOutput{ prefersLocalInvocationPrimitiveOutput_ } - , prefersCompactVertexOutput{ prefersCompactVertexOutput_ } - , prefersCompactPrimitiveOutput{ prefersCompactPrimitiveOutput_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesEXT( PhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMeshShaderPropertiesEXT( VkPhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMeshShaderPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMeshShaderPropertiesEXT & operator=( PhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMeshShaderPropertiesEXT & operator=( VkPhysicalDeviceMeshShaderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMeshShaderPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - uint32_t const &, - ArrayWrapper1D const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - ArrayWrapper1D const &, - uint32_t const &, - ArrayWrapper1D const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - maxTaskWorkGroupTotalCount, - maxTaskWorkGroupCount, - maxTaskWorkGroupInvocations, - maxTaskWorkGroupSize, - maxTaskPayloadSize, - maxTaskSharedMemorySize, - maxTaskPayloadAndSharedMemorySize, - maxMeshWorkGroupTotalCount, - maxMeshWorkGroupCount, - maxMeshWorkGroupInvocations, - maxMeshWorkGroupSize, - maxMeshSharedMemorySize, - maxMeshPayloadAndSharedMemorySize, - maxMeshOutputMemorySize, - maxMeshPayloadAndOutputMemorySize, - maxMeshOutputComponents, - maxMeshOutputVertices, - maxMeshOutputPrimitives, - maxMeshOutputLayers, - maxMeshMultiviewViewCount, - meshOutputPerVertexGranularity, - meshOutputPerPrimitiveGranularity, - maxPreferredTaskWorkGroupInvocations, - maxPreferredMeshWorkGroupInvocations, - prefersLocalInvocationVertexOutput, - prefersLocalInvocationPrimitiveOutput, - prefersCompactVertexOutput, - prefersCompactPrimitiveOutput ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMeshShaderPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMeshShaderPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTaskWorkGroupTotalCount == rhs.maxTaskWorkGroupTotalCount ) && - ( maxTaskWorkGroupCount == rhs.maxTaskWorkGroupCount ) && ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations ) && - ( maxTaskWorkGroupSize == rhs.maxTaskWorkGroupSize ) && ( maxTaskPayloadSize == rhs.maxTaskPayloadSize ) && - ( maxTaskSharedMemorySize == rhs.maxTaskSharedMemorySize ) && ( maxTaskPayloadAndSharedMemorySize == rhs.maxTaskPayloadAndSharedMemorySize ) && - ( maxMeshWorkGroupTotalCount == rhs.maxMeshWorkGroupTotalCount ) && ( maxMeshWorkGroupCount == rhs.maxMeshWorkGroupCount ) && - ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations ) && ( maxMeshWorkGroupSize == rhs.maxMeshWorkGroupSize ) && - ( maxMeshSharedMemorySize == rhs.maxMeshSharedMemorySize ) && ( maxMeshPayloadAndSharedMemorySize == rhs.maxMeshPayloadAndSharedMemorySize ) && - ( maxMeshOutputMemorySize == rhs.maxMeshOutputMemorySize ) && ( maxMeshPayloadAndOutputMemorySize == rhs.maxMeshPayloadAndOutputMemorySize ) && - ( maxMeshOutputComponents == rhs.maxMeshOutputComponents ) && ( maxMeshOutputVertices == rhs.maxMeshOutputVertices ) && - ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives ) && ( maxMeshOutputLayers == rhs.maxMeshOutputLayers ) && - ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount ) && ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity ) && - ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity ) && - ( maxPreferredTaskWorkGroupInvocations == rhs.maxPreferredTaskWorkGroupInvocations ) && - ( maxPreferredMeshWorkGroupInvocations == rhs.maxPreferredMeshWorkGroupInvocations ) && - ( prefersLocalInvocationVertexOutput == rhs.prefersLocalInvocationVertexOutput ) && - ( prefersLocalInvocationPrimitiveOutput == rhs.prefersLocalInvocationPrimitiveOutput ) && - ( prefersCompactVertexOutput == rhs.prefersCompactVertexOutput ) && ( prefersCompactPrimitiveOutput == rhs.prefersCompactPrimitiveOutput ); -# endif - } - - bool operator!=( PhysicalDeviceMeshShaderPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesEXT; - void * pNext = {}; - uint32_t maxTaskWorkGroupTotalCount = {}; - ArrayWrapper1D maxTaskWorkGroupCount = {}; - uint32_t maxTaskWorkGroupInvocations = {}; - ArrayWrapper1D maxTaskWorkGroupSize = {}; - uint32_t maxTaskPayloadSize = {}; - uint32_t maxTaskSharedMemorySize = {}; - uint32_t maxTaskPayloadAndSharedMemorySize = {}; - uint32_t maxMeshWorkGroupTotalCount = {}; - ArrayWrapper1D maxMeshWorkGroupCount = {}; - uint32_t maxMeshWorkGroupInvocations = {}; - ArrayWrapper1D maxMeshWorkGroupSize = {}; - uint32_t maxMeshSharedMemorySize = {}; - uint32_t maxMeshPayloadAndSharedMemorySize = {}; - uint32_t maxMeshOutputMemorySize = {}; - uint32_t maxMeshPayloadAndOutputMemorySize = {}; - uint32_t maxMeshOutputComponents = {}; - uint32_t maxMeshOutputVertices = {}; - uint32_t maxMeshOutputPrimitives = {}; - uint32_t maxMeshOutputLayers = {}; - uint32_t maxMeshMultiviewViewCount = {}; - uint32_t meshOutputPerVertexGranularity = {}; - uint32_t meshOutputPerPrimitiveGranularity = {}; - uint32_t maxPreferredTaskWorkGroupInvocations = {}; - uint32_t maxPreferredMeshWorkGroupInvocations = {}; - Bool32 prefersLocalInvocationVertexOutput = {}; - Bool32 prefersLocalInvocationPrimitiveOutput = {}; - Bool32 prefersCompactVertexOutput = {}; - Bool32 prefersCompactPrimitiveOutput = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMeshShaderPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMeshShaderPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceMeshShaderPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMeshShaderPropertiesNV.html - struct PhysicalDeviceMeshShaderPropertiesNV - { - using NativeType = VkPhysicalDeviceMeshShaderPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesNV( uint32_t maxDrawMeshTasksCount_ = {}, - uint32_t maxTaskWorkGroupInvocations_ = {}, - std::array const & maxTaskWorkGroupSize_ = {}, - uint32_t maxTaskTotalMemorySize_ = {}, - uint32_t maxTaskOutputCount_ = {}, - uint32_t maxMeshWorkGroupInvocations_ = {}, - std::array const & maxMeshWorkGroupSize_ = {}, - uint32_t maxMeshTotalMemorySize_ = {}, - uint32_t maxMeshOutputVertices_ = {}, - uint32_t maxMeshOutputPrimitives_ = {}, - uint32_t maxMeshMultiviewViewCount_ = {}, - uint32_t meshOutputPerVertexGranularity_ = {}, - uint32_t meshOutputPerPrimitiveGranularity_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxDrawMeshTasksCount{ maxDrawMeshTasksCount_ } - , maxTaskWorkGroupInvocations{ maxTaskWorkGroupInvocations_ } - , maxTaskWorkGroupSize{ maxTaskWorkGroupSize_ } - , maxTaskTotalMemorySize{ maxTaskTotalMemorySize_ } - , maxTaskOutputCount{ maxTaskOutputCount_ } - , maxMeshWorkGroupInvocations{ maxMeshWorkGroupInvocations_ } - , maxMeshWorkGroupSize{ maxMeshWorkGroupSize_ } - , maxMeshTotalMemorySize{ maxMeshTotalMemorySize_ } - , maxMeshOutputVertices{ maxMeshOutputVertices_ } - , maxMeshOutputPrimitives{ maxMeshOutputPrimitives_ } - , maxMeshMultiviewViewCount{ maxMeshMultiviewViewCount_ } - , meshOutputPerVertexGranularity{ meshOutputPerVertexGranularity_ } - , meshOutputPerPrimitiveGranularity{ meshOutputPerPrimitiveGranularity_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMeshShaderPropertiesNV( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMeshShaderPropertiesNV( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMeshShaderPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMeshShaderPropertiesNV & operator=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMeshShaderPropertiesNV & operator=( VkPhysicalDeviceMeshShaderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMeshShaderPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMeshShaderPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - ArrayWrapper1D const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - maxDrawMeshTasksCount, - maxTaskWorkGroupInvocations, - maxTaskWorkGroupSize, - maxTaskTotalMemorySize, - maxTaskOutputCount, - maxMeshWorkGroupInvocations, - maxMeshWorkGroupSize, - maxMeshTotalMemorySize, - maxMeshOutputVertices, - maxMeshOutputPrimitives, - maxMeshMultiviewViewCount, - meshOutputPerVertexGranularity, - meshOutputPerPrimitiveGranularity ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMeshShaderPropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxDrawMeshTasksCount == rhs.maxDrawMeshTasksCount ) && - ( maxTaskWorkGroupInvocations == rhs.maxTaskWorkGroupInvocations ) && ( maxTaskWorkGroupSize == rhs.maxTaskWorkGroupSize ) && - ( maxTaskTotalMemorySize == rhs.maxTaskTotalMemorySize ) && ( maxTaskOutputCount == rhs.maxTaskOutputCount ) && - ( maxMeshWorkGroupInvocations == rhs.maxMeshWorkGroupInvocations ) && ( maxMeshWorkGroupSize == rhs.maxMeshWorkGroupSize ) && - ( maxMeshTotalMemorySize == rhs.maxMeshTotalMemorySize ) && ( maxMeshOutputVertices == rhs.maxMeshOutputVertices ) && - ( maxMeshOutputPrimitives == rhs.maxMeshOutputPrimitives ) && ( maxMeshMultiviewViewCount == rhs.maxMeshMultiviewViewCount ) && - ( meshOutputPerVertexGranularity == rhs.meshOutputPerVertexGranularity ) && - ( meshOutputPerPrimitiveGranularity == rhs.meshOutputPerPrimitiveGranularity ); -# endif - } - - bool operator!=( PhysicalDeviceMeshShaderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMeshShaderPropertiesNV; - void * pNext = {}; - uint32_t maxDrawMeshTasksCount = {}; - uint32_t maxTaskWorkGroupInvocations = {}; - ArrayWrapper1D maxTaskWorkGroupSize = {}; - uint32_t maxTaskTotalMemorySize = {}; - uint32_t maxTaskOutputCount = {}; - uint32_t maxMeshWorkGroupInvocations = {}; - ArrayWrapper1D maxMeshWorkGroupSize = {}; - uint32_t maxMeshTotalMemorySize = {}; - uint32_t maxMeshOutputVertices = {}; - uint32_t maxMeshOutputPrimitives = {}; - uint32_t maxMeshMultiviewViewCount = {}; - uint32_t meshOutputPerVertexGranularity = {}; - uint32_t meshOutputPerPrimitiveGranularity = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMeshShaderPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMeshShaderPropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceMultiDrawFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiDrawFeaturesEXT.html - struct PhysicalDeviceMultiDrawFeaturesEXT - { - using NativeType = VkPhysicalDeviceMultiDrawFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiDrawFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiDrawFeaturesEXT( Bool32 multiDraw_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , multiDraw{ multiDraw_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiDrawFeaturesEXT( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMultiDrawFeaturesEXT( VkPhysicalDeviceMultiDrawFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMultiDrawFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMultiDrawFeaturesEXT & operator=( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMultiDrawFeaturesEXT & operator=( VkPhysicalDeviceMultiDrawFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiDrawFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiDrawFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiDrawFeaturesEXT & setMultiDraw( Bool32 multiDraw_ ) & VULKAN_HPP_NOEXCEPT - { - multiDraw = multiDraw_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiDrawFeaturesEXT && setMultiDraw( Bool32 multiDraw_ ) && VULKAN_HPP_NOEXCEPT - { - multiDraw = multiDraw_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMultiDrawFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiDrawFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiDrawFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiDrawFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, multiDraw ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMultiDrawFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiDraw == rhs.multiDraw ); -# endif - } - - bool operator!=( PhysicalDeviceMultiDrawFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMultiDrawFeaturesEXT; - void * pNext = {}; - Bool32 multiDraw = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMultiDrawFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMultiDrawFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceMultiDrawPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiDrawPropertiesEXT.html - struct PhysicalDeviceMultiDrawPropertiesEXT - { - using NativeType = VkPhysicalDeviceMultiDrawPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiDrawPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiDrawPropertiesEXT( uint32_t maxMultiDrawCount_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxMultiDrawCount{ maxMultiDrawCount_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiDrawPropertiesEXT( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMultiDrawPropertiesEXT( VkPhysicalDeviceMultiDrawPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMultiDrawPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMultiDrawPropertiesEXT & operator=( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMultiDrawPropertiesEXT & operator=( VkPhysicalDeviceMultiDrawPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMultiDrawPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiDrawPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiDrawPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiDrawPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxMultiDrawCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMultiDrawPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiDrawCount == rhs.maxMultiDrawCount ); -# endif - } - - bool operator!=( PhysicalDeviceMultiDrawPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMultiDrawPropertiesEXT; - void * pNext = {}; - uint32_t maxMultiDrawCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMultiDrawPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMultiDrawPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.html - struct PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT - { - using NativeType = VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( Bool32 multisampledRenderToSingleSampled_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , multisampledRenderToSingleSampled{ multisampledRenderToSingleSampled_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT( - *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT & - operator=( PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT & - operator=( VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT & - setMultisampledRenderToSingleSampled( Bool32 multisampledRenderToSingleSampled_ ) & - VULKAN_HPP_NOEXCEPT - { - multisampledRenderToSingleSampled = multisampledRenderToSingleSampled_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT && - setMultisampledRenderToSingleSampled( Bool32 multisampledRenderToSingleSampled_ ) && - VULKAN_HPP_NOEXCEPT - { - multisampledRenderToSingleSampled = multisampledRenderToSingleSampled_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, multisampledRenderToSingleSampled ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multisampledRenderToSingleSampled == rhs.multisampledRenderToSingleSampled ); -# endif - } - - bool operator!=( PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; - void * pNext = {}; - Bool32 multisampledRenderToSingleSampled = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceMultiviewFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewFeatures.html - struct PhysicalDeviceMultiviewFeatures - { - using NativeType = VkPhysicalDeviceMultiviewFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( Bool32 multiview_ = {}, - Bool32 multiviewGeometryShader_ = {}, - Bool32 multiviewTessellationShader_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , multiview{ multiview_ } - , multiviewGeometryShader{ multiviewGeometryShader_ } - , multiviewTessellationShader{ multiviewTessellationShader_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewFeatures( PhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMultiviewFeatures( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMultiviewFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMultiviewFeatures & operator=( PhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMultiviewFeatures & operator=( VkPhysicalDeviceMultiviewFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures & setMultiview( Bool32 multiview_ ) & VULKAN_HPP_NOEXCEPT - { - multiview = multiview_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures && setMultiview( Bool32 multiview_ ) && VULKAN_HPP_NOEXCEPT - { - multiview = multiview_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures & setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ ) & VULKAN_HPP_NOEXCEPT - { - multiviewGeometryShader = multiviewGeometryShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures && setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ ) && VULKAN_HPP_NOEXCEPT - { - multiviewGeometryShader = multiviewGeometryShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures & setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ ) & VULKAN_HPP_NOEXCEPT - { - multiviewTessellationShader = multiviewTessellationShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewFeatures && setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ ) && VULKAN_HPP_NOEXCEPT - { - multiviewTessellationShader = multiviewTessellationShader_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMultiviewFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, multiview, multiviewGeometryShader, multiviewTessellationShader ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMultiviewFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiview == rhs.multiview ) && ( multiviewGeometryShader == rhs.multiviewGeometryShader ) && - ( multiviewTessellationShader == rhs.multiviewTessellationShader ); -# endif - } - - bool operator!=( PhysicalDeviceMultiviewFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMultiviewFeatures; - void * pNext = {}; - Bool32 multiview = {}; - Bool32 multiviewGeometryShader = {}; - Bool32 multiviewTessellationShader = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMultiviewFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMultiviewFeatures; - }; - - using PhysicalDeviceMultiviewFeaturesKHR = PhysicalDeviceMultiviewFeatures; - - // wrapper struct for struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.html - struct PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX - { - using NativeType = VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( Bool32 perViewPositionAllComponents_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , perViewPositionAllComponents{ perViewPositionAllComponents_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX & - operator=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX & operator=( VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, perViewPositionAllComponents ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & ) const = default; -#else - bool operator==( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perViewPositionAllComponents == rhs.perViewPositionAllComponents ); -# endif - } - - bool operator!=( PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - void * pNext = {}; - Bool32 perViewPositionAllComponents = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; - }; - - // wrapper struct for struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.html - struct PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM - { - using NativeType = VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( Bool32 multiviewPerViewRenderAreas_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , multiviewPerViewRenderAreas{ multiviewPerViewRenderAreas_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM & - operator=( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM & operator=( VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM & setMultiviewPerViewRenderAreas( Bool32 multiviewPerViewRenderAreas_ ) & - VULKAN_HPP_NOEXCEPT - { - multiviewPerViewRenderAreas = multiviewPerViewRenderAreas_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM && setMultiviewPerViewRenderAreas( Bool32 multiviewPerViewRenderAreas_ ) && - VULKAN_HPP_NOEXCEPT - { - multiviewPerViewRenderAreas = multiviewPerViewRenderAreas_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, multiviewPerViewRenderAreas ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiviewPerViewRenderAreas == rhs.multiviewPerViewRenderAreas ); -# endif - } - - bool operator!=( PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; - void * pNext = {}; - Bool32 multiviewPerViewRenderAreas = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.html - struct PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM - { - using NativeType = VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( Bool32 multiviewPerViewViewports_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , multiviewPerViewViewports{ multiviewPerViewViewports_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM & - operator=( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM & operator=( VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM & setMultiviewPerViewViewports( Bool32 multiviewPerViewViewports_ ) & - VULKAN_HPP_NOEXCEPT - { - multiviewPerViewViewports = multiviewPerViewViewports_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM && setMultiviewPerViewViewports( Bool32 multiviewPerViewViewports_ ) && - VULKAN_HPP_NOEXCEPT - { - multiviewPerViewViewports = multiviewPerViewViewports_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, multiviewPerViewViewports ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( multiviewPerViewViewports == rhs.multiviewPerViewViewports ); -# endif - } - - bool operator!=( PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; - void * pNext = {}; - Bool32 multiviewPerViewViewports = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceMultiviewProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMultiviewProperties.html - struct PhysicalDeviceMultiviewProperties - { - using NativeType = VkPhysicalDeviceMultiviewProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMultiviewProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewProperties( uint32_t maxMultiviewViewCount_ = {}, - uint32_t maxMultiviewInstanceIndex_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxMultiviewViewCount{ maxMultiviewViewCount_ } - , maxMultiviewInstanceIndex{ maxMultiviewInstanceIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceMultiviewProperties( PhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMultiviewProperties( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMultiviewProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMultiviewProperties & operator=( PhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMultiviewProperties & operator=( VkPhysicalDeviceMultiviewProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceMultiviewProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMultiviewProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxMultiviewViewCount, maxMultiviewInstanceIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMultiviewProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) && - ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ); -# endif - } - - bool operator!=( PhysicalDeviceMultiviewProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMultiviewProperties; - void * pNext = {}; - uint32_t maxMultiviewViewCount = {}; - uint32_t maxMultiviewInstanceIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMultiviewProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMultiviewProperties; - }; - - using PhysicalDeviceMultiviewPropertiesKHR = PhysicalDeviceMultiviewProperties; - - // wrapper struct for struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.html - struct PhysicalDeviceMutableDescriptorTypeFeaturesEXT - { - using NativeType = VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceMutableDescriptorTypeFeaturesEXT( Bool32 mutableDescriptorType_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , mutableDescriptorType{ mutableDescriptorType_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceMutableDescriptorTypeFeaturesEXT( PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceMutableDescriptorTypeFeaturesEXT( VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceMutableDescriptorTypeFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceMutableDescriptorTypeFeaturesEXT & operator=( PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceMutableDescriptorTypeFeaturesEXT & operator=( VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMutableDescriptorTypeFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMutableDescriptorTypeFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMutableDescriptorTypeFeaturesEXT & setMutableDescriptorType( Bool32 mutableDescriptorType_ ) & VULKAN_HPP_NOEXCEPT - { - mutableDescriptorType = mutableDescriptorType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceMutableDescriptorTypeFeaturesEXT && setMutableDescriptorType( Bool32 mutableDescriptorType_ ) && VULKAN_HPP_NOEXCEPT - { - mutableDescriptorType = mutableDescriptorType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, mutableDescriptorType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mutableDescriptorType == rhs.mutableDescriptorType ); -# endif - } - - bool operator!=( PhysicalDeviceMutableDescriptorTypeFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT; - void * pNext = {}; - Bool32 mutableDescriptorType = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceMutableDescriptorTypeFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceMutableDescriptorTypeFeaturesEXT; - }; - - using PhysicalDeviceMutableDescriptorTypeFeaturesVALVE = PhysicalDeviceMutableDescriptorTypeFeaturesEXT; - - // wrapper struct for struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceNestedCommandBufferFeaturesEXT.html - struct PhysicalDeviceNestedCommandBufferFeaturesEXT - { - using NativeType = VkPhysicalDeviceNestedCommandBufferFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceNestedCommandBufferFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceNestedCommandBufferFeaturesEXT( Bool32 nestedCommandBuffer_ = {}, - Bool32 nestedCommandBufferRendering_ = {}, - Bool32 nestedCommandBufferSimultaneousUse_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , nestedCommandBuffer{ nestedCommandBuffer_ } - , nestedCommandBufferRendering{ nestedCommandBufferRendering_ } - , nestedCommandBufferSimultaneousUse{ nestedCommandBufferSimultaneousUse_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceNestedCommandBufferFeaturesEXT( PhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceNestedCommandBufferFeaturesEXT( VkPhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceNestedCommandBufferFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceNestedCommandBufferFeaturesEXT & operator=( PhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceNestedCommandBufferFeaturesEXT & operator=( VkPhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT & setNestedCommandBuffer( Bool32 nestedCommandBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - nestedCommandBuffer = nestedCommandBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT && setNestedCommandBuffer( Bool32 nestedCommandBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - nestedCommandBuffer = nestedCommandBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT & setNestedCommandBufferRendering( Bool32 nestedCommandBufferRendering_ ) & - VULKAN_HPP_NOEXCEPT - { - nestedCommandBufferRendering = nestedCommandBufferRendering_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT && setNestedCommandBufferRendering( Bool32 nestedCommandBufferRendering_ ) && - VULKAN_HPP_NOEXCEPT - { - nestedCommandBufferRendering = nestedCommandBufferRendering_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT & setNestedCommandBufferSimultaneousUse( Bool32 nestedCommandBufferSimultaneousUse_ ) & - VULKAN_HPP_NOEXCEPT - { - nestedCommandBufferSimultaneousUse = nestedCommandBufferSimultaneousUse_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNestedCommandBufferFeaturesEXT && - setNestedCommandBufferSimultaneousUse( Bool32 nestedCommandBufferSimultaneousUse_ ) && - VULKAN_HPP_NOEXCEPT - { - nestedCommandBufferSimultaneousUse = nestedCommandBufferSimultaneousUse_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceNestedCommandBufferFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceNestedCommandBufferFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceNestedCommandBufferFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceNestedCommandBufferFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, nestedCommandBuffer, nestedCommandBufferRendering, nestedCommandBufferSimultaneousUse ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceNestedCommandBufferFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( nestedCommandBuffer == rhs.nestedCommandBuffer ) && - ( nestedCommandBufferRendering == rhs.nestedCommandBufferRendering ) && - ( nestedCommandBufferSimultaneousUse == rhs.nestedCommandBufferSimultaneousUse ); -# endif - } - - bool operator!=( PhysicalDeviceNestedCommandBufferFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceNestedCommandBufferFeaturesEXT; - void * pNext = {}; - Bool32 nestedCommandBuffer = {}; - Bool32 nestedCommandBufferRendering = {}; - Bool32 nestedCommandBufferSimultaneousUse = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceNestedCommandBufferFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceNestedCommandBufferFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceNestedCommandBufferPropertiesEXT.html - struct PhysicalDeviceNestedCommandBufferPropertiesEXT - { - using NativeType = VkPhysicalDeviceNestedCommandBufferPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceNestedCommandBufferPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceNestedCommandBufferPropertiesEXT( uint32_t maxCommandBufferNestingLevel_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxCommandBufferNestingLevel{ maxCommandBufferNestingLevel_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceNestedCommandBufferPropertiesEXT( PhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceNestedCommandBufferPropertiesEXT( VkPhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceNestedCommandBufferPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceNestedCommandBufferPropertiesEXT & operator=( PhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceNestedCommandBufferPropertiesEXT & operator=( VkPhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceNestedCommandBufferPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceNestedCommandBufferPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceNestedCommandBufferPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceNestedCommandBufferPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxCommandBufferNestingLevel ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceNestedCommandBufferPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxCommandBufferNestingLevel == rhs.maxCommandBufferNestingLevel ); -# endif - } - - bool operator!=( PhysicalDeviceNestedCommandBufferPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceNestedCommandBufferPropertiesEXT; - void * pNext = {}; - uint32_t maxCommandBufferNestingLevel = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceNestedCommandBufferPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceNestedCommandBufferPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.html - struct PhysicalDeviceNonSeamlessCubeMapFeaturesEXT - { - using NativeType = VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceNonSeamlessCubeMapFeaturesEXT( Bool32 nonSeamlessCubeMap_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , nonSeamlessCubeMap{ nonSeamlessCubeMap_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceNonSeamlessCubeMapFeaturesEXT( PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceNonSeamlessCubeMapFeaturesEXT( VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceNonSeamlessCubeMapFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceNonSeamlessCubeMapFeaturesEXT & operator=( PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceNonSeamlessCubeMapFeaturesEXT & operator=( VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT & setNonSeamlessCubeMap( Bool32 nonSeamlessCubeMap_ ) & VULKAN_HPP_NOEXCEPT - { - nonSeamlessCubeMap = nonSeamlessCubeMap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceNonSeamlessCubeMapFeaturesEXT && setNonSeamlessCubeMap( Bool32 nonSeamlessCubeMap_ ) && VULKAN_HPP_NOEXCEPT - { - nonSeamlessCubeMap = nonSeamlessCubeMap_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, nonSeamlessCubeMap ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( nonSeamlessCubeMap == rhs.nonSeamlessCubeMap ); -# endif - } - - bool operator!=( PhysicalDeviceNonSeamlessCubeMapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT; - void * pNext = {}; - Bool32 nonSeamlessCubeMap = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceNonSeamlessCubeMapFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceOpacityMicromapFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpacityMicromapFeaturesEXT.html - struct PhysicalDeviceOpacityMicromapFeaturesEXT - { - using NativeType = VkPhysicalDeviceOpacityMicromapFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceOpacityMicromapFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapFeaturesEXT( Bool32 micromap_ = {}, - Bool32 micromapCaptureReplay_ = {}, - Bool32 micromapHostCommands_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , micromap{ micromap_ } - , micromapCaptureReplay{ micromapCaptureReplay_ } - , micromapHostCommands{ micromapHostCommands_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapFeaturesEXT( PhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceOpacityMicromapFeaturesEXT( VkPhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceOpacityMicromapFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceOpacityMicromapFeaturesEXT & operator=( PhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceOpacityMicromapFeaturesEXT & operator=( VkPhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT & setMicromap( Bool32 micromap_ ) & VULKAN_HPP_NOEXCEPT - { - micromap = micromap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT && setMicromap( Bool32 micromap_ ) && VULKAN_HPP_NOEXCEPT - { - micromap = micromap_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT & setMicromapCaptureReplay( Bool32 micromapCaptureReplay_ ) & VULKAN_HPP_NOEXCEPT - { - micromapCaptureReplay = micromapCaptureReplay_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT && setMicromapCaptureReplay( Bool32 micromapCaptureReplay_ ) && VULKAN_HPP_NOEXCEPT - { - micromapCaptureReplay = micromapCaptureReplay_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT & setMicromapHostCommands( Bool32 micromapHostCommands_ ) & VULKAN_HPP_NOEXCEPT - { - micromapHostCommands = micromapHostCommands_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpacityMicromapFeaturesEXT && setMicromapHostCommands( Bool32 micromapHostCommands_ ) && VULKAN_HPP_NOEXCEPT - { - micromapHostCommands = micromapHostCommands_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceOpacityMicromapFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpacityMicromapFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpacityMicromapFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpacityMicromapFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, micromap, micromapCaptureReplay, micromapHostCommands ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceOpacityMicromapFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( micromap == rhs.micromap ) && ( micromapCaptureReplay == rhs.micromapCaptureReplay ) && - ( micromapHostCommands == rhs.micromapHostCommands ); -# endif - } - - bool operator!=( PhysicalDeviceOpacityMicromapFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceOpacityMicromapFeaturesEXT; - void * pNext = {}; - Bool32 micromap = {}; - Bool32 micromapCaptureReplay = {}; - Bool32 micromapHostCommands = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceOpacityMicromapFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceOpacityMicromapFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceOpacityMicromapPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpacityMicromapPropertiesEXT.html - struct PhysicalDeviceOpacityMicromapPropertiesEXT - { - using NativeType = VkPhysicalDeviceOpacityMicromapPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceOpacityMicromapPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapPropertiesEXT( uint32_t maxOpacity2StateSubdivisionLevel_ = {}, - uint32_t maxOpacity4StateSubdivisionLevel_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxOpacity2StateSubdivisionLevel{ maxOpacity2StateSubdivisionLevel_ } - , maxOpacity4StateSubdivisionLevel{ maxOpacity4StateSubdivisionLevel_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceOpacityMicromapPropertiesEXT( PhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceOpacityMicromapPropertiesEXT( VkPhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceOpacityMicromapPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceOpacityMicromapPropertiesEXT & operator=( PhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceOpacityMicromapPropertiesEXT & operator=( VkPhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceOpacityMicromapPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpacityMicromapPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpacityMicromapPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpacityMicromapPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxOpacity2StateSubdivisionLevel, maxOpacity4StateSubdivisionLevel ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceOpacityMicromapPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxOpacity2StateSubdivisionLevel == rhs.maxOpacity2StateSubdivisionLevel ) && - ( maxOpacity4StateSubdivisionLevel == rhs.maxOpacity4StateSubdivisionLevel ); -# endif - } - - bool operator!=( PhysicalDeviceOpacityMicromapPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceOpacityMicromapPropertiesEXT; - void * pNext = {}; - uint32_t maxOpacity2StateSubdivisionLevel = {}; - uint32_t maxOpacity4StateSubdivisionLevel = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceOpacityMicromapPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceOpacityMicromapPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceOpticalFlowFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpticalFlowFeaturesNV.html - struct PhysicalDeviceOpticalFlowFeaturesNV - { - using NativeType = VkPhysicalDeviceOpticalFlowFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceOpticalFlowFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceOpticalFlowFeaturesNV( Bool32 opticalFlow_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , opticalFlow{ opticalFlow_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceOpticalFlowFeaturesNV( PhysicalDeviceOpticalFlowFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceOpticalFlowFeaturesNV( VkPhysicalDeviceOpticalFlowFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceOpticalFlowFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceOpticalFlowFeaturesNV & operator=( PhysicalDeviceOpticalFlowFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceOpticalFlowFeaturesNV & operator=( VkPhysicalDeviceOpticalFlowFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpticalFlowFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpticalFlowFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpticalFlowFeaturesNV & setOpticalFlow( Bool32 opticalFlow_ ) & VULKAN_HPP_NOEXCEPT - { - opticalFlow = opticalFlow_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceOpticalFlowFeaturesNV && setOpticalFlow( Bool32 opticalFlow_ ) && VULKAN_HPP_NOEXCEPT - { - opticalFlow = opticalFlow_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceOpticalFlowFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpticalFlowFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpticalFlowFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpticalFlowFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, opticalFlow ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceOpticalFlowFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceOpticalFlowFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( opticalFlow == rhs.opticalFlow ); -# endif - } - - bool operator!=( PhysicalDeviceOpticalFlowFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceOpticalFlowFeaturesNV; - void * pNext = {}; - Bool32 opticalFlow = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceOpticalFlowFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceOpticalFlowFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceOpticalFlowPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceOpticalFlowPropertiesNV.html - struct PhysicalDeviceOpticalFlowPropertiesNV - { - using NativeType = VkPhysicalDeviceOpticalFlowPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceOpticalFlowPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceOpticalFlowPropertiesNV( OpticalFlowGridSizeFlagsNV supportedOutputGridSizes_ = {}, - OpticalFlowGridSizeFlagsNV supportedHintGridSizes_ = {}, - Bool32 hintSupported_ = {}, - Bool32 costSupported_ = {}, - Bool32 bidirectionalFlowSupported_ = {}, - Bool32 globalFlowSupported_ = {}, - uint32_t minWidth_ = {}, - uint32_t minHeight_ = {}, - uint32_t maxWidth_ = {}, - uint32_t maxHeight_ = {}, - uint32_t maxNumRegionsOfInterest_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , supportedOutputGridSizes{ supportedOutputGridSizes_ } - , supportedHintGridSizes{ supportedHintGridSizes_ } - , hintSupported{ hintSupported_ } - , costSupported{ costSupported_ } - , bidirectionalFlowSupported{ bidirectionalFlowSupported_ } - , globalFlowSupported{ globalFlowSupported_ } - , minWidth{ minWidth_ } - , minHeight{ minHeight_ } - , maxWidth{ maxWidth_ } - , maxHeight{ maxHeight_ } - , maxNumRegionsOfInterest{ maxNumRegionsOfInterest_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceOpticalFlowPropertiesNV( PhysicalDeviceOpticalFlowPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceOpticalFlowPropertiesNV( VkPhysicalDeviceOpticalFlowPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceOpticalFlowPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceOpticalFlowPropertiesNV & operator=( PhysicalDeviceOpticalFlowPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceOpticalFlowPropertiesNV & operator=( VkPhysicalDeviceOpticalFlowPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceOpticalFlowPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpticalFlowPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpticalFlowPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceOpticalFlowPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - supportedOutputGridSizes, - supportedHintGridSizes, - hintSupported, - costSupported, - bidirectionalFlowSupported, - globalFlowSupported, - minWidth, - minHeight, - maxWidth, - maxHeight, - maxNumRegionsOfInterest ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceOpticalFlowPropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceOpticalFlowPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedOutputGridSizes == rhs.supportedOutputGridSizes ) && - ( supportedHintGridSizes == rhs.supportedHintGridSizes ) && ( hintSupported == rhs.hintSupported ) && ( costSupported == rhs.costSupported ) && - ( bidirectionalFlowSupported == rhs.bidirectionalFlowSupported ) && ( globalFlowSupported == rhs.globalFlowSupported ) && - ( minWidth == rhs.minWidth ) && ( minHeight == rhs.minHeight ) && ( maxWidth == rhs.maxWidth ) && ( maxHeight == rhs.maxHeight ) && - ( maxNumRegionsOfInterest == rhs.maxNumRegionsOfInterest ); -# endif - } - - bool operator!=( PhysicalDeviceOpticalFlowPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceOpticalFlowPropertiesNV; - void * pNext = {}; - OpticalFlowGridSizeFlagsNV supportedOutputGridSizes = {}; - OpticalFlowGridSizeFlagsNV supportedHintGridSizes = {}; - Bool32 hintSupported = {}; - Bool32 costSupported = {}; - Bool32 bidirectionalFlowSupported = {}; - Bool32 globalFlowSupported = {}; - uint32_t minWidth = {}; - uint32_t minHeight = {}; - uint32_t maxWidth = {}; - uint32_t maxHeight = {}; - uint32_t maxNumRegionsOfInterest = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceOpticalFlowPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceOpticalFlowPropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDevicePCIBusInfoPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePCIBusInfoPropertiesEXT.html - struct PhysicalDevicePCIBusInfoPropertiesEXT - { - using NativeType = VkPhysicalDevicePCIBusInfoPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePCIBusInfoPropertiesEXT( - uint32_t pciDomain_ = {}, uint32_t pciBus_ = {}, uint32_t pciDevice_ = {}, uint32_t pciFunction_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pciDomain{ pciDomain_ } - , pciBus{ pciBus_ } - , pciDevice{ pciDevice_ } - , pciFunction{ pciFunction_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePCIBusInfoPropertiesEXT( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePCIBusInfoPropertiesEXT( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePCIBusInfoPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePCIBusInfoPropertiesEXT & operator=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePCIBusInfoPropertiesEXT & operator=( VkPhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDevicePCIBusInfoPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePCIBusInfoPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePCIBusInfoPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePCIBusInfoPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pciDomain, pciBus, pciDevice, pciFunction ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePCIBusInfoPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pciDomain == rhs.pciDomain ) && ( pciBus == rhs.pciBus ) && ( pciDevice == rhs.pciDevice ) && - ( pciFunction == rhs.pciFunction ); -# endif - } - - bool operator!=( PhysicalDevicePCIBusInfoPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePciBusInfoPropertiesEXT; - void * pNext = {}; - uint32_t pciDomain = {}; - uint32_t pciBus = {}; - uint32_t pciDevice = {}; - uint32_t pciFunction = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePCIBusInfoPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePCIBusInfoPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.html - struct PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT - { - using NativeType = VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT( Bool32 pageableDeviceLocalMemory_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pageableDeviceLocalMemory{ pageableDeviceLocalMemory_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT( VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT & - operator=( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT & operator=( VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT & setPageableDeviceLocalMemory( Bool32 pageableDeviceLocalMemory_ ) & - VULKAN_HPP_NOEXCEPT - { - pageableDeviceLocalMemory = pageableDeviceLocalMemory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT && setPageableDeviceLocalMemory( Bool32 pageableDeviceLocalMemory_ ) && - VULKAN_HPP_NOEXCEPT - { - pageableDeviceLocalMemory = pageableDeviceLocalMemory_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pageableDeviceLocalMemory ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pageableDeviceLocalMemory == rhs.pageableDeviceLocalMemory ); -# endif - } - - bool operator!=( PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; - void * pNext = {}; - Bool32 pageableDeviceLocalMemory = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.html - struct PhysicalDevicePartitionedAccelerationStructureFeaturesNV - { - using NativeType = VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePartitionedAccelerationStructureFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePartitionedAccelerationStructureFeaturesNV( Bool32 partitionedAccelerationStructure_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , partitionedAccelerationStructure{ partitionedAccelerationStructure_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePartitionedAccelerationStructureFeaturesNV( PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePartitionedAccelerationStructureFeaturesNV( VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePartitionedAccelerationStructureFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePartitionedAccelerationStructureFeaturesNV & - operator=( PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePartitionedAccelerationStructureFeaturesNV & - operator=( VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePartitionedAccelerationStructureFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePartitionedAccelerationStructureFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePartitionedAccelerationStructureFeaturesNV & - setPartitionedAccelerationStructure( Bool32 partitionedAccelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - partitionedAccelerationStructure = partitionedAccelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePartitionedAccelerationStructureFeaturesNV && - setPartitionedAccelerationStructure( Bool32 partitionedAccelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - partitionedAccelerationStructure = partitionedAccelerationStructure_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, partitionedAccelerationStructure ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( partitionedAccelerationStructure == rhs.partitionedAccelerationStructure ); -# endif - } - - bool operator!=( PhysicalDevicePartitionedAccelerationStructureFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePartitionedAccelerationStructureFeaturesNV; - void * pNext = {}; - Bool32 partitionedAccelerationStructure = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePartitionedAccelerationStructureFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePartitionedAccelerationStructureFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV.html - struct PhysicalDevicePartitionedAccelerationStructurePropertiesNV - { - using NativeType = VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePartitionedAccelerationStructurePropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePartitionedAccelerationStructurePropertiesNV( uint32_t maxPartitionCount_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxPartitionCount{ maxPartitionCount_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePartitionedAccelerationStructurePropertiesNV( PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePartitionedAccelerationStructurePropertiesNV( VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePartitionedAccelerationStructurePropertiesNV( - *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePartitionedAccelerationStructurePropertiesNV & - operator=( PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePartitionedAccelerationStructurePropertiesNV & - operator=( VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxPartitionCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPartitionCount == rhs.maxPartitionCount ); -# endif - } - - bool operator!=( PhysicalDevicePartitionedAccelerationStructurePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePartitionedAccelerationStructurePropertiesNV; - void * pNext = {}; - uint32_t maxPartitionCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePartitionedAccelerationStructurePropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePartitionedAccelerationStructurePropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePerStageDescriptorSetFeaturesNV.html - struct PhysicalDevicePerStageDescriptorSetFeaturesNV - { - using NativeType = VkPhysicalDevicePerStageDescriptorSetFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePerStageDescriptorSetFeaturesNV( Bool32 perStageDescriptorSet_ = {}, - Bool32 dynamicPipelineLayout_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , perStageDescriptorSet{ perStageDescriptorSet_ } - , dynamicPipelineLayout{ dynamicPipelineLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePerStageDescriptorSetFeaturesNV( PhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePerStageDescriptorSetFeaturesNV( VkPhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePerStageDescriptorSetFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePerStageDescriptorSetFeaturesNV & operator=( PhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePerStageDescriptorSetFeaturesNV & operator=( VkPhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV & setPerStageDescriptorSet( Bool32 perStageDescriptorSet_ ) & VULKAN_HPP_NOEXCEPT - { - perStageDescriptorSet = perStageDescriptorSet_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV && setPerStageDescriptorSet( Bool32 perStageDescriptorSet_ ) && VULKAN_HPP_NOEXCEPT - { - perStageDescriptorSet = perStageDescriptorSet_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV & setDynamicPipelineLayout( Bool32 dynamicPipelineLayout_ ) & VULKAN_HPP_NOEXCEPT - { - dynamicPipelineLayout = dynamicPipelineLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerStageDescriptorSetFeaturesNV && setDynamicPipelineLayout( Bool32 dynamicPipelineLayout_ ) && VULKAN_HPP_NOEXCEPT - { - dynamicPipelineLayout = dynamicPipelineLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePerStageDescriptorSetFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerStageDescriptorSetFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerStageDescriptorSetFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerStageDescriptorSetFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, perStageDescriptorSet, dynamicPipelineLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePerStageDescriptorSetFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( perStageDescriptorSet == rhs.perStageDescriptorSet ) && - ( dynamicPipelineLayout == rhs.dynamicPipelineLayout ); -# endif - } - - bool operator!=( PhysicalDevicePerStageDescriptorSetFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV; - void * pNext = {}; - Bool32 perStageDescriptorSet = {}; - Bool32 dynamicPipelineLayout = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePerStageDescriptorSetFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePerStageDescriptorSetFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDevicePerformanceCountersByRegionFeaturesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePerformanceCountersByRegionFeaturesARM.html - struct PhysicalDevicePerformanceCountersByRegionFeaturesARM - { - using NativeType = VkPhysicalDevicePerformanceCountersByRegionFeaturesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceCountersByRegionFeaturesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceCountersByRegionFeaturesARM( Bool32 performanceCountersByRegion_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , performanceCountersByRegion{ performanceCountersByRegion_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePerformanceCountersByRegionFeaturesARM( PhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePerformanceCountersByRegionFeaturesARM( VkPhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePerformanceCountersByRegionFeaturesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePerformanceCountersByRegionFeaturesARM & - operator=( PhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePerformanceCountersByRegionFeaturesARM & operator=( VkPhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceCountersByRegionFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceCountersByRegionFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceCountersByRegionFeaturesARM & setPerformanceCountersByRegion( Bool32 performanceCountersByRegion_ ) & - VULKAN_HPP_NOEXCEPT - { - performanceCountersByRegion = performanceCountersByRegion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceCountersByRegionFeaturesARM && setPerformanceCountersByRegion( Bool32 performanceCountersByRegion_ ) && - VULKAN_HPP_NOEXCEPT - { - performanceCountersByRegion = performanceCountersByRegion_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePerformanceCountersByRegionFeaturesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceCountersByRegionFeaturesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceCountersByRegionFeaturesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceCountersByRegionFeaturesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, performanceCountersByRegion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePerformanceCountersByRegionFeaturesARM const & ) const = default; -#else - bool operator==( PhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( performanceCountersByRegion == rhs.performanceCountersByRegion ); -# endif - } - - bool operator!=( PhysicalDevicePerformanceCountersByRegionFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePerformanceCountersByRegionFeaturesARM; - void * pNext = {}; - Bool32 performanceCountersByRegion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePerformanceCountersByRegionFeaturesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePerformanceCountersByRegionFeaturesARM; - }; - - // wrapper struct for struct VkPhysicalDevicePerformanceCountersByRegionPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePerformanceCountersByRegionPropertiesARM.html - struct PhysicalDevicePerformanceCountersByRegionPropertiesARM - { - using NativeType = VkPhysicalDevicePerformanceCountersByRegionPropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceCountersByRegionPropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceCountersByRegionPropertiesARM( uint32_t maxPerRegionPerformanceCounters_ = {}, - Extent2D performanceCounterRegionSize_ = {}, - uint32_t rowStrideAlignment_ = {}, - uint32_t regionAlignment_ = {}, - Bool32 identityTransformOrder_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxPerRegionPerformanceCounters{ maxPerRegionPerformanceCounters_ } - , performanceCounterRegionSize{ performanceCounterRegionSize_ } - , rowStrideAlignment{ rowStrideAlignment_ } - , regionAlignment{ regionAlignment_ } - , identityTransformOrder{ identityTransformOrder_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceCountersByRegionPropertiesARM( PhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePerformanceCountersByRegionPropertiesARM( VkPhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePerformanceCountersByRegionPropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePerformanceCountersByRegionPropertiesARM & - operator=( PhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePerformanceCountersByRegionPropertiesARM & - operator=( VkPhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDevicePerformanceCountersByRegionPropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceCountersByRegionPropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceCountersByRegionPropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceCountersByRegionPropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, maxPerRegionPerformanceCounters, performanceCounterRegionSize, rowStrideAlignment, regionAlignment, identityTransformOrder ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePerformanceCountersByRegionPropertiesARM const & ) const = default; -#else - bool operator==( PhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPerRegionPerformanceCounters == rhs.maxPerRegionPerformanceCounters ) && - ( performanceCounterRegionSize == rhs.performanceCounterRegionSize ) && ( rowStrideAlignment == rhs.rowStrideAlignment ) && - ( regionAlignment == rhs.regionAlignment ) && ( identityTransformOrder == rhs.identityTransformOrder ); -# endif - } - - bool operator!=( PhysicalDevicePerformanceCountersByRegionPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePerformanceCountersByRegionPropertiesARM; - void * pNext = {}; - uint32_t maxPerRegionPerformanceCounters = {}; - Extent2D performanceCounterRegionSize = {}; - uint32_t rowStrideAlignment = {}; - uint32_t regionAlignment = {}; - Bool32 identityTransformOrder = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePerformanceCountersByRegionPropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePerformanceCountersByRegionPropertiesARM; - }; - - // wrapper struct for struct VkPhysicalDevicePerformanceQueryFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePerformanceQueryFeaturesKHR.html - struct PhysicalDevicePerformanceQueryFeaturesKHR - { - using NativeType = VkPhysicalDevicePerformanceQueryFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryFeaturesKHR( Bool32 performanceCounterQueryPools_ = {}, - Bool32 performanceCounterMultipleQueryPools_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , performanceCounterQueryPools{ performanceCounterQueryPools_ } - , performanceCounterMultipleQueryPools{ performanceCounterMultipleQueryPools_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryFeaturesKHR( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePerformanceQueryFeaturesKHR( VkPhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePerformanceQueryFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePerformanceQueryFeaturesKHR & operator=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePerformanceQueryFeaturesKHR & operator=( VkPhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR & setPerformanceCounterQueryPools( Bool32 performanceCounterQueryPools_ ) & - VULKAN_HPP_NOEXCEPT - { - performanceCounterQueryPools = performanceCounterQueryPools_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR && setPerformanceCounterQueryPools( Bool32 performanceCounterQueryPools_ ) && - VULKAN_HPP_NOEXCEPT - { - performanceCounterQueryPools = performanceCounterQueryPools_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR & - setPerformanceCounterMultipleQueryPools( Bool32 performanceCounterMultipleQueryPools_ ) & - VULKAN_HPP_NOEXCEPT - { - performanceCounterMultipleQueryPools = performanceCounterMultipleQueryPools_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePerformanceQueryFeaturesKHR && - setPerformanceCounterMultipleQueryPools( Bool32 performanceCounterMultipleQueryPools_ ) && - VULKAN_HPP_NOEXCEPT - { - performanceCounterMultipleQueryPools = performanceCounterMultipleQueryPools_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePerformanceQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceQueryFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceQueryFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, performanceCounterQueryPools, performanceCounterMultipleQueryPools ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePerformanceQueryFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( performanceCounterQueryPools == rhs.performanceCounterQueryPools ) && - ( performanceCounterMultipleQueryPools == rhs.performanceCounterMultipleQueryPools ); -# endif - } - - bool operator!=( PhysicalDevicePerformanceQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR; - void * pNext = {}; - Bool32 performanceCounterQueryPools = {}; - Bool32 performanceCounterMultipleQueryPools = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePerformanceQueryFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePerformanceQueryFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDevicePerformanceQueryPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePerformanceQueryPropertiesKHR.html - struct PhysicalDevicePerformanceQueryPropertiesKHR - { - using NativeType = VkPhysicalDevicePerformanceQueryPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryPropertiesKHR( Bool32 allowCommandBufferQueryCopies_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , allowCommandBufferQueryCopies{ allowCommandBufferQueryCopies_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePerformanceQueryPropertiesKHR( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePerformanceQueryPropertiesKHR( VkPhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePerformanceQueryPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePerformanceQueryPropertiesKHR & operator=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePerformanceQueryPropertiesKHR & operator=( VkPhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDevicePerformanceQueryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceQueryPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceQueryPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePerformanceQueryPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, allowCommandBufferQueryCopies ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePerformanceQueryPropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allowCommandBufferQueryCopies == rhs.allowCommandBufferQueryCopies ); -# endif - } - - bool operator!=( PhysicalDevicePerformanceQueryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR; - void * pNext = {}; - Bool32 allowCommandBufferQueryCopies = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePerformanceQueryPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePerformanceQueryPropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDevicePipelineBinaryFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineBinaryFeaturesKHR.html - struct PhysicalDevicePipelineBinaryFeaturesKHR - { - using NativeType = VkPhysicalDevicePipelineBinaryFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineBinaryFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineBinaryFeaturesKHR( Bool32 pipelineBinaries_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineBinaries{ pipelineBinaries_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineBinaryFeaturesKHR( PhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePipelineBinaryFeaturesKHR( VkPhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePipelineBinaryFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePipelineBinaryFeaturesKHR & operator=( PhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePipelineBinaryFeaturesKHR & operator=( VkPhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineBinaryFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineBinaryFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineBinaryFeaturesKHR & setPipelineBinaries( Bool32 pipelineBinaries_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineBinaries = pipelineBinaries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineBinaryFeaturesKHR && setPipelineBinaries( Bool32 pipelineBinaries_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineBinaries = pipelineBinaries_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePipelineBinaryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineBinaryFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineBinaryFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineBinaryFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineBinaries ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePipelineBinaryFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBinaries == rhs.pipelineBinaries ); -# endif - } - - bool operator!=( PhysicalDevicePipelineBinaryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePipelineBinaryFeaturesKHR; - void * pNext = {}; - Bool32 pipelineBinaries = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePipelineBinaryFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePipelineBinaryFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDevicePipelineBinaryPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineBinaryPropertiesKHR.html - struct PhysicalDevicePipelineBinaryPropertiesKHR - { - using NativeType = VkPhysicalDevicePipelineBinaryPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineBinaryPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineBinaryPropertiesKHR( Bool32 pipelineBinaryInternalCache_ = {}, - Bool32 pipelineBinaryInternalCacheControl_ = {}, - Bool32 pipelineBinaryPrefersInternalCache_ = {}, - Bool32 pipelineBinaryPrecompiledInternalCache_ = {}, - Bool32 pipelineBinaryCompressedData_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineBinaryInternalCache{ pipelineBinaryInternalCache_ } - , pipelineBinaryInternalCacheControl{ pipelineBinaryInternalCacheControl_ } - , pipelineBinaryPrefersInternalCache{ pipelineBinaryPrefersInternalCache_ } - , pipelineBinaryPrecompiledInternalCache{ pipelineBinaryPrecompiledInternalCache_ } - , pipelineBinaryCompressedData{ pipelineBinaryCompressedData_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineBinaryPropertiesKHR( PhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePipelineBinaryPropertiesKHR( VkPhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePipelineBinaryPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePipelineBinaryPropertiesKHR & operator=( PhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePipelineBinaryPropertiesKHR & operator=( VkPhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDevicePipelineBinaryPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineBinaryPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineBinaryPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineBinaryPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - pipelineBinaryInternalCache, - pipelineBinaryInternalCacheControl, - pipelineBinaryPrefersInternalCache, - pipelineBinaryPrecompiledInternalCache, - pipelineBinaryCompressedData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePipelineBinaryPropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBinaryInternalCache == rhs.pipelineBinaryInternalCache ) && - ( pipelineBinaryInternalCacheControl == rhs.pipelineBinaryInternalCacheControl ) && - ( pipelineBinaryPrefersInternalCache == rhs.pipelineBinaryPrefersInternalCache ) && - ( pipelineBinaryPrecompiledInternalCache == rhs.pipelineBinaryPrecompiledInternalCache ) && - ( pipelineBinaryCompressedData == rhs.pipelineBinaryCompressedData ); -# endif - } - - bool operator!=( PhysicalDevicePipelineBinaryPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePipelineBinaryPropertiesKHR; - void * pNext = {}; - Bool32 pipelineBinaryInternalCache = {}; - Bool32 pipelineBinaryInternalCacheControl = {}; - Bool32 pipelineBinaryPrefersInternalCache = {}; - Bool32 pipelineBinaryPrecompiledInternalCache = {}; - Bool32 pipelineBinaryCompressedData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePipelineBinaryPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePipelineBinaryPropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC.html - struct PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC - { - using NativeType = VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC( Bool32 pipelineCacheIncrementalMode_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineCacheIncrementalMode{ pipelineCacheIncrementalMode_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC( PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC( VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC & - operator=( PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC & operator=( VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC & setPipelineCacheIncrementalMode( Bool32 pipelineCacheIncrementalMode_ ) & - VULKAN_HPP_NOEXCEPT - { - pipelineCacheIncrementalMode = pipelineCacheIncrementalMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC && setPipelineCacheIncrementalMode( Bool32 pipelineCacheIncrementalMode_ ) && - VULKAN_HPP_NOEXCEPT - { - pipelineCacheIncrementalMode = pipelineCacheIncrementalMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineCacheIncrementalMode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & ) const = default; -#else - bool operator==( PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineCacheIncrementalMode == rhs.pipelineCacheIncrementalMode ); -# endif - } - - bool operator!=( PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; - void * pNext = {}; - Bool32 pipelineCacheIncrementalMode = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC; - }; - - // wrapper struct for struct VkPhysicalDevicePipelineCreationCacheControlFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineCreationCacheControlFeatures.html - struct PhysicalDevicePipelineCreationCacheControlFeatures - { - using NativeType = VkPhysicalDevicePipelineCreationCacheControlFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineCreationCacheControlFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineCreationCacheControlFeatures( Bool32 pipelineCreationCacheControl_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineCreationCacheControl{ pipelineCreationCacheControl_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePipelineCreationCacheControlFeatures( PhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePipelineCreationCacheControlFeatures( VkPhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePipelineCreationCacheControlFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePipelineCreationCacheControlFeatures & - operator=( PhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePipelineCreationCacheControlFeatures & operator=( VkPhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCreationCacheControlFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCreationCacheControlFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCreationCacheControlFeatures & setPipelineCreationCacheControl( Bool32 pipelineCreationCacheControl_ ) & - VULKAN_HPP_NOEXCEPT - { - pipelineCreationCacheControl = pipelineCreationCacheControl_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineCreationCacheControlFeatures && setPipelineCreationCacheControl( Bool32 pipelineCreationCacheControl_ ) && - VULKAN_HPP_NOEXCEPT - { - pipelineCreationCacheControl = pipelineCreationCacheControl_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePipelineCreationCacheControlFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineCreationCacheControlFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineCreationCacheControlFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineCreationCacheControlFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineCreationCacheControl ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePipelineCreationCacheControlFeatures const & ) const = default; -#else - bool operator==( PhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineCreationCacheControl == rhs.pipelineCreationCacheControl ); -# endif - } - - bool operator!=( PhysicalDevicePipelineCreationCacheControlFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePipelineCreationCacheControlFeatures; - void * pNext = {}; - Bool32 pipelineCreationCacheControl = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePipelineCreationCacheControlFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePipelineCreationCacheControlFeatures; - }; - - using PhysicalDevicePipelineCreationCacheControlFeaturesEXT = PhysicalDevicePipelineCreationCacheControlFeatures; - - // wrapper struct for struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.html - struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHR - { - using NativeType = VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( Bool32 pipelineExecutableInfo_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineExecutableInfo{ pipelineExecutableInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePipelineExecutablePropertiesFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & - operator=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & operator=( VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineExecutablePropertiesFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineExecutablePropertiesFeaturesKHR & setPipelineExecutableInfo( Bool32 pipelineExecutableInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pipelineExecutableInfo = pipelineExecutableInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineExecutablePropertiesFeaturesKHR && setPipelineExecutableInfo( Bool32 pipelineExecutableInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pipelineExecutableInfo = pipelineExecutableInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineExecutableInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineExecutableInfo == rhs.pipelineExecutableInfo ); -# endif - } - - bool operator!=( PhysicalDevicePipelineExecutablePropertiesFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - void * pNext = {}; - Bool32 pipelineExecutableInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.html - struct PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT - { - using NativeType = VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( Bool32 pipelineLibraryGroupHandles_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineLibraryGroupHandles{ pipelineLibraryGroupHandles_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT & - operator=( PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT & operator=( VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT & setPipelineLibraryGroupHandles( Bool32 pipelineLibraryGroupHandles_ ) & - VULKAN_HPP_NOEXCEPT - { - pipelineLibraryGroupHandles = pipelineLibraryGroupHandles_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT && setPipelineLibraryGroupHandles( Bool32 pipelineLibraryGroupHandles_ ) && - VULKAN_HPP_NOEXCEPT - { - pipelineLibraryGroupHandles = pipelineLibraryGroupHandles_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineLibraryGroupHandles ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineLibraryGroupHandles == rhs.pipelineLibraryGroupHandles ); -# endif - } - - bool operator!=( PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; - void * pNext = {}; - Bool32 pipelineLibraryGroupHandles = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.html - struct PhysicalDevicePipelineOpacityMicromapFeaturesARM - { - using NativeType = VkPhysicalDevicePipelineOpacityMicromapFeaturesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineOpacityMicromapFeaturesARM( Bool32 pipelineOpacityMicromap_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineOpacityMicromap{ pipelineOpacityMicromap_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePipelineOpacityMicromapFeaturesARM( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePipelineOpacityMicromapFeaturesARM( VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePipelineOpacityMicromapFeaturesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePipelineOpacityMicromapFeaturesARM & operator=( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePipelineOpacityMicromapFeaturesARM & operator=( VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineOpacityMicromapFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineOpacityMicromapFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineOpacityMicromapFeaturesARM & setPipelineOpacityMicromap( Bool32 pipelineOpacityMicromap_ ) & - VULKAN_HPP_NOEXCEPT - { - pipelineOpacityMicromap = pipelineOpacityMicromap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineOpacityMicromapFeaturesARM && setPipelineOpacityMicromap( Bool32 pipelineOpacityMicromap_ ) && - VULKAN_HPP_NOEXCEPT - { - pipelineOpacityMicromap = pipelineOpacityMicromap_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineOpacityMicromapFeaturesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineOpacityMicromapFeaturesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineOpacityMicromap ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & ) const = default; -#else - bool operator==( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineOpacityMicromap == rhs.pipelineOpacityMicromap ); -# endif - } - - bool operator!=( PhysicalDevicePipelineOpacityMicromapFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM; - void * pNext = {}; - Bool32 pipelineOpacityMicromap = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePipelineOpacityMicromapFeaturesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePipelineOpacityMicromapFeaturesARM; - }; - - // wrapper struct for struct VkPhysicalDevicePipelinePropertiesFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelinePropertiesFeaturesEXT.html - struct PhysicalDevicePipelinePropertiesFeaturesEXT - { - using NativeType = VkPhysicalDevicePipelinePropertiesFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelinePropertiesFeaturesEXT( Bool32 pipelinePropertiesIdentifier_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelinePropertiesIdentifier{ pipelinePropertiesIdentifier_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelinePropertiesFeaturesEXT( PhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePipelinePropertiesFeaturesEXT( VkPhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePipelinePropertiesFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePipelinePropertiesFeaturesEXT & operator=( PhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePipelinePropertiesFeaturesEXT & operator=( VkPhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelinePropertiesFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelinePropertiesFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelinePropertiesFeaturesEXT & setPipelinePropertiesIdentifier( Bool32 pipelinePropertiesIdentifier_ ) & - VULKAN_HPP_NOEXCEPT - { - pipelinePropertiesIdentifier = pipelinePropertiesIdentifier_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelinePropertiesFeaturesEXT && setPipelinePropertiesIdentifier( Bool32 pipelinePropertiesIdentifier_ ) && - VULKAN_HPP_NOEXCEPT - { - pipelinePropertiesIdentifier = pipelinePropertiesIdentifier_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePipelinePropertiesFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelinePropertiesFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelinePropertiesFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelinePropertiesFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelinePropertiesIdentifier ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePipelinePropertiesFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelinePropertiesIdentifier == rhs.pipelinePropertiesIdentifier ); -# endif - } - - bool operator!=( PhysicalDevicePipelinePropertiesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT; - void * pNext = {}; - Bool32 pipelinePropertiesIdentifier = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePipelinePropertiesFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePipelinePropertiesFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDevicePipelineProtectedAccessFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineProtectedAccessFeatures.html - struct PhysicalDevicePipelineProtectedAccessFeatures - { - using NativeType = VkPhysicalDevicePipelineProtectedAccessFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineProtectedAccessFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineProtectedAccessFeatures( Bool32 pipelineProtectedAccess_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineProtectedAccess{ pipelineProtectedAccess_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePipelineProtectedAccessFeatures( PhysicalDevicePipelineProtectedAccessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePipelineProtectedAccessFeatures( VkPhysicalDevicePipelineProtectedAccessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePipelineProtectedAccessFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePipelineProtectedAccessFeatures & operator=( PhysicalDevicePipelineProtectedAccessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePipelineProtectedAccessFeatures & operator=( VkPhysicalDevicePipelineProtectedAccessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineProtectedAccessFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineProtectedAccessFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineProtectedAccessFeatures & setPipelineProtectedAccess( Bool32 pipelineProtectedAccess_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineProtectedAccess = pipelineProtectedAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineProtectedAccessFeatures && setPipelineProtectedAccess( Bool32 pipelineProtectedAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - pipelineProtectedAccess = pipelineProtectedAccess_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePipelineProtectedAccessFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineProtectedAccessFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineProtectedAccessFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineProtectedAccessFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineProtectedAccess ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePipelineProtectedAccessFeatures const & ) const = default; -#else - bool operator==( PhysicalDevicePipelineProtectedAccessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineProtectedAccess == rhs.pipelineProtectedAccess ); -# endif - } - - bool operator!=( PhysicalDevicePipelineProtectedAccessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePipelineProtectedAccessFeatures; - void * pNext = {}; - Bool32 pipelineProtectedAccess = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePipelineProtectedAccessFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePipelineProtectedAccessFeatures; - }; - - using PhysicalDevicePipelineProtectedAccessFeaturesEXT = PhysicalDevicePipelineProtectedAccessFeatures; - - // wrapper struct for struct VkPhysicalDevicePipelineRobustnessFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineRobustnessFeatures.html - struct PhysicalDevicePipelineRobustnessFeatures - { - using NativeType = VkPhysicalDevicePipelineRobustnessFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineRobustnessFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineRobustnessFeatures( Bool32 pipelineRobustness_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineRobustness{ pipelineRobustness_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineRobustnessFeatures( PhysicalDevicePipelineRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePipelineRobustnessFeatures( VkPhysicalDevicePipelineRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePipelineRobustnessFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePipelineRobustnessFeatures & operator=( PhysicalDevicePipelineRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePipelineRobustnessFeatures & operator=( VkPhysicalDevicePipelineRobustnessFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineRobustnessFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineRobustnessFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineRobustnessFeatures & setPipelineRobustness( Bool32 pipelineRobustness_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineRobustness = pipelineRobustness_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePipelineRobustnessFeatures && setPipelineRobustness( Bool32 pipelineRobustness_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineRobustness = pipelineRobustness_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePipelineRobustnessFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineRobustnessFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineRobustnessFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineRobustnessFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineRobustness ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePipelineRobustnessFeatures const & ) const = default; -#else - bool operator==( PhysicalDevicePipelineRobustnessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineRobustness == rhs.pipelineRobustness ); -# endif - } - - bool operator!=( PhysicalDevicePipelineRobustnessFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePipelineRobustnessFeatures; - void * pNext = {}; - Bool32 pipelineRobustness = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePipelineRobustnessFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePipelineRobustnessFeatures; - }; - - using PhysicalDevicePipelineRobustnessFeaturesEXT = PhysicalDevicePipelineRobustnessFeatures; - - // wrapper struct for struct VkPhysicalDevicePipelineRobustnessProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePipelineRobustnessProperties.html - struct PhysicalDevicePipelineRobustnessProperties - { - using NativeType = VkPhysicalDevicePipelineRobustnessProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePipelineRobustnessProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineRobustnessProperties( - PipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, - PipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, - PipelineRobustnessBufferBehavior defaultRobustnessVertexInputs_ = PipelineRobustnessBufferBehavior::eDeviceDefault, - PipelineRobustnessImageBehavior defaultRobustnessImages_ = PipelineRobustnessImageBehavior::eDeviceDefault, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , defaultRobustnessStorageBuffers{ defaultRobustnessStorageBuffers_ } - , defaultRobustnessUniformBuffers{ defaultRobustnessUniformBuffers_ } - , defaultRobustnessVertexInputs{ defaultRobustnessVertexInputs_ } - , defaultRobustnessImages{ defaultRobustnessImages_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePipelineRobustnessProperties( PhysicalDevicePipelineRobustnessProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePipelineRobustnessProperties( VkPhysicalDevicePipelineRobustnessProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePipelineRobustnessProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePipelineRobustnessProperties & operator=( PhysicalDevicePipelineRobustnessProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePipelineRobustnessProperties & operator=( VkPhysicalDevicePipelineRobustnessProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDevicePipelineRobustnessProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineRobustnessProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineRobustnessProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePipelineRobustnessProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, defaultRobustnessStorageBuffers, defaultRobustnessUniformBuffers, defaultRobustnessVertexInputs, defaultRobustnessImages ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePipelineRobustnessProperties const & ) const = default; -#else - bool operator==( PhysicalDevicePipelineRobustnessProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( defaultRobustnessStorageBuffers == rhs.defaultRobustnessStorageBuffers ) && - ( defaultRobustnessUniformBuffers == rhs.defaultRobustnessUniformBuffers ) && - ( defaultRobustnessVertexInputs == rhs.defaultRobustnessVertexInputs ) && ( defaultRobustnessImages == rhs.defaultRobustnessImages ); -# endif - } - - bool operator!=( PhysicalDevicePipelineRobustnessProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePipelineRobustnessProperties; - void * pNext = {}; - PipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; - PipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; - PipelineRobustnessBufferBehavior defaultRobustnessVertexInputs = PipelineRobustnessBufferBehavior::eDeviceDefault; - PipelineRobustnessImageBehavior defaultRobustnessImages = PipelineRobustnessImageBehavior::eDeviceDefault; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePipelineRobustnessProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePipelineRobustnessProperties; - }; - - using PhysicalDevicePipelineRobustnessPropertiesEXT = PhysicalDevicePipelineRobustnessProperties; - - // wrapper struct for struct VkPhysicalDevicePointClippingProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePointClippingProperties.html - struct PhysicalDevicePointClippingProperties - { - using NativeType = VkPhysicalDevicePointClippingProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePointClippingProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePointClippingProperties( PointClippingBehavior pointClippingBehavior_ = PointClippingBehavior::eAllClipPlanes, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pointClippingBehavior{ pointClippingBehavior_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePointClippingProperties( PhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePointClippingProperties( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePointClippingProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePointClippingProperties & operator=( PhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePointClippingProperties & operator=( VkPhysicalDevicePointClippingProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDevicePointClippingProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePointClippingProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePointClippingProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePointClippingProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pointClippingBehavior ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePointClippingProperties const & ) const = default; -#else - bool operator==( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pointClippingBehavior == rhs.pointClippingBehavior ); -# endif - } - - bool operator!=( PhysicalDevicePointClippingProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePointClippingProperties; - void * pNext = {}; - PointClippingBehavior pointClippingBehavior = PointClippingBehavior::eAllClipPlanes; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePointClippingProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePointClippingProperties; - }; - - using PhysicalDevicePointClippingPropertiesKHR = PhysicalDevicePointClippingProperties; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkPhysicalDevicePortabilitySubsetFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePortabilitySubsetFeaturesKHR.html - struct PhysicalDevicePortabilitySubsetFeaturesKHR - { - using NativeType = VkPhysicalDevicePortabilitySubsetFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePortabilitySubsetFeaturesKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePortabilitySubsetFeaturesKHR( Bool32 constantAlphaColorBlendFactors_ = {}, - Bool32 events_ = {}, - Bool32 imageViewFormatReinterpretation_ = {}, - Bool32 imageViewFormatSwizzle_ = {}, - Bool32 imageView2DOn3DImage_ = {}, - Bool32 multisampleArrayImage_ = {}, - Bool32 mutableComparisonSamplers_ = {}, - Bool32 pointPolygons_ = {}, - Bool32 samplerMipLodBias_ = {}, - Bool32 separateStencilMaskRef_ = {}, - Bool32 shaderSampleRateInterpolationFunctions_ = {}, - Bool32 tessellationIsolines_ = {}, - Bool32 tessellationPointMode_ = {}, - Bool32 triangleFans_ = {}, - Bool32 vertexAttributeAccessBeyondStride_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , constantAlphaColorBlendFactors{ constantAlphaColorBlendFactors_ } - , events{ events_ } - , imageViewFormatReinterpretation{ imageViewFormatReinterpretation_ } - , imageViewFormatSwizzle{ imageViewFormatSwizzle_ } - , imageView2DOn3DImage{ imageView2DOn3DImage_ } - , multisampleArrayImage{ multisampleArrayImage_ } - , mutableComparisonSamplers{ mutableComparisonSamplers_ } - , pointPolygons{ pointPolygons_ } - , samplerMipLodBias{ samplerMipLodBias_ } - , separateStencilMaskRef{ separateStencilMaskRef_ } - , shaderSampleRateInterpolationFunctions{ shaderSampleRateInterpolationFunctions_ } - , tessellationIsolines{ tessellationIsolines_ } - , tessellationPointMode{ tessellationPointMode_ } - , triangleFans{ triangleFans_ } - , vertexAttributeAccessBeyondStride{ vertexAttributeAccessBeyondStride_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePortabilitySubsetFeaturesKHR( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePortabilitySubsetFeaturesKHR( VkPhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePortabilitySubsetFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePortabilitySubsetFeaturesKHR & operator=( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePortabilitySubsetFeaturesKHR & operator=( VkPhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setConstantAlphaColorBlendFactors( Bool32 constantAlphaColorBlendFactors_ ) & - VULKAN_HPP_NOEXCEPT - { - constantAlphaColorBlendFactors = constantAlphaColorBlendFactors_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setConstantAlphaColorBlendFactors( Bool32 constantAlphaColorBlendFactors_ ) && - VULKAN_HPP_NOEXCEPT - { - constantAlphaColorBlendFactors = constantAlphaColorBlendFactors_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setEvents( Bool32 events_ ) & VULKAN_HPP_NOEXCEPT - { - events = events_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setEvents( Bool32 events_ ) && VULKAN_HPP_NOEXCEPT - { - events = events_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setImageViewFormatReinterpretation( Bool32 imageViewFormatReinterpretation_ ) & - VULKAN_HPP_NOEXCEPT - { - imageViewFormatReinterpretation = imageViewFormatReinterpretation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setImageViewFormatReinterpretation( Bool32 imageViewFormatReinterpretation_ ) && - VULKAN_HPP_NOEXCEPT - { - imageViewFormatReinterpretation = imageViewFormatReinterpretation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setImageViewFormatSwizzle( Bool32 imageViewFormatSwizzle_ ) & VULKAN_HPP_NOEXCEPT - { - imageViewFormatSwizzle = imageViewFormatSwizzle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setImageViewFormatSwizzle( Bool32 imageViewFormatSwizzle_ ) && VULKAN_HPP_NOEXCEPT - { - imageViewFormatSwizzle = imageViewFormatSwizzle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setImageView2DOn3DImage( Bool32 imageView2DOn3DImage_ ) & VULKAN_HPP_NOEXCEPT - { - imageView2DOn3DImage = imageView2DOn3DImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setImageView2DOn3DImage( Bool32 imageView2DOn3DImage_ ) && VULKAN_HPP_NOEXCEPT - { - imageView2DOn3DImage = imageView2DOn3DImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setMultisampleArrayImage( Bool32 multisampleArrayImage_ ) & VULKAN_HPP_NOEXCEPT - { - multisampleArrayImage = multisampleArrayImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setMultisampleArrayImage( Bool32 multisampleArrayImage_ ) && VULKAN_HPP_NOEXCEPT - { - multisampleArrayImage = multisampleArrayImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setMutableComparisonSamplers( Bool32 mutableComparisonSamplers_ ) & VULKAN_HPP_NOEXCEPT - { - mutableComparisonSamplers = mutableComparisonSamplers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setMutableComparisonSamplers( Bool32 mutableComparisonSamplers_ ) && - VULKAN_HPP_NOEXCEPT - { - mutableComparisonSamplers = mutableComparisonSamplers_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setPointPolygons( Bool32 pointPolygons_ ) & VULKAN_HPP_NOEXCEPT - { - pointPolygons = pointPolygons_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setPointPolygons( Bool32 pointPolygons_ ) && VULKAN_HPP_NOEXCEPT - { - pointPolygons = pointPolygons_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setSamplerMipLodBias( Bool32 samplerMipLodBias_ ) & VULKAN_HPP_NOEXCEPT - { - samplerMipLodBias = samplerMipLodBias_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setSamplerMipLodBias( Bool32 samplerMipLodBias_ ) && VULKAN_HPP_NOEXCEPT - { - samplerMipLodBias = samplerMipLodBias_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setSeparateStencilMaskRef( Bool32 separateStencilMaskRef_ ) & VULKAN_HPP_NOEXCEPT - { - separateStencilMaskRef = separateStencilMaskRef_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setSeparateStencilMaskRef( Bool32 separateStencilMaskRef_ ) && VULKAN_HPP_NOEXCEPT - { - separateStencilMaskRef = separateStencilMaskRef_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & - setShaderSampleRateInterpolationFunctions( Bool32 shaderSampleRateInterpolationFunctions_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSampleRateInterpolationFunctions = shaderSampleRateInterpolationFunctions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && - setShaderSampleRateInterpolationFunctions( Bool32 shaderSampleRateInterpolationFunctions_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSampleRateInterpolationFunctions = shaderSampleRateInterpolationFunctions_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setTessellationIsolines( Bool32 tessellationIsolines_ ) & VULKAN_HPP_NOEXCEPT - { - tessellationIsolines = tessellationIsolines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setTessellationIsolines( Bool32 tessellationIsolines_ ) && VULKAN_HPP_NOEXCEPT - { - tessellationIsolines = tessellationIsolines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setTessellationPointMode( Bool32 tessellationPointMode_ ) & VULKAN_HPP_NOEXCEPT - { - tessellationPointMode = tessellationPointMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setTessellationPointMode( Bool32 tessellationPointMode_ ) && VULKAN_HPP_NOEXCEPT - { - tessellationPointMode = tessellationPointMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setTriangleFans( Bool32 triangleFans_ ) & VULKAN_HPP_NOEXCEPT - { - triangleFans = triangleFans_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setTriangleFans( Bool32 triangleFans_ ) && VULKAN_HPP_NOEXCEPT - { - triangleFans = triangleFans_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR & setVertexAttributeAccessBeyondStride( Bool32 vertexAttributeAccessBeyondStride_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexAttributeAccessBeyondStride = vertexAttributeAccessBeyondStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePortabilitySubsetFeaturesKHR && setVertexAttributeAccessBeyondStride( Bool32 vertexAttributeAccessBeyondStride_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexAttributeAccessBeyondStride = vertexAttributeAccessBeyondStride_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePortabilitySubsetFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePortabilitySubsetFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePortabilitySubsetFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePortabilitySubsetFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - constantAlphaColorBlendFactors, - events, - imageViewFormatReinterpretation, - imageViewFormatSwizzle, - imageView2DOn3DImage, - multisampleArrayImage, - mutableComparisonSamplers, - pointPolygons, - samplerMipLodBias, - separateStencilMaskRef, - shaderSampleRateInterpolationFunctions, - tessellationIsolines, - tessellationPointMode, - triangleFans, - vertexAttributeAccessBeyondStride ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePortabilitySubsetFeaturesKHR const & ) const = default; -# else - bool operator==( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantAlphaColorBlendFactors == rhs.constantAlphaColorBlendFactors ) && - ( events == rhs.events ) && ( imageViewFormatReinterpretation == rhs.imageViewFormatReinterpretation ) && - ( imageViewFormatSwizzle == rhs.imageViewFormatSwizzle ) && ( imageView2DOn3DImage == rhs.imageView2DOn3DImage ) && - ( multisampleArrayImage == rhs.multisampleArrayImage ) && ( mutableComparisonSamplers == rhs.mutableComparisonSamplers ) && - ( pointPolygons == rhs.pointPolygons ) && ( samplerMipLodBias == rhs.samplerMipLodBias ) && - ( separateStencilMaskRef == rhs.separateStencilMaskRef ) && - ( shaderSampleRateInterpolationFunctions == rhs.shaderSampleRateInterpolationFunctions ) && ( tessellationIsolines == rhs.tessellationIsolines ) && - ( tessellationPointMode == rhs.tessellationPointMode ) && ( triangleFans == rhs.triangleFans ) && - ( vertexAttributeAccessBeyondStride == rhs.vertexAttributeAccessBeyondStride ); -# endif - } - - bool operator!=( PhysicalDevicePortabilitySubsetFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDevicePortabilitySubsetFeaturesKHR; - void * pNext = {}; - Bool32 constantAlphaColorBlendFactors = {}; - Bool32 events = {}; - Bool32 imageViewFormatReinterpretation = {}; - Bool32 imageViewFormatSwizzle = {}; - Bool32 imageView2DOn3DImage = {}; - Bool32 multisampleArrayImage = {}; - Bool32 mutableComparisonSamplers = {}; - Bool32 pointPolygons = {}; - Bool32 samplerMipLodBias = {}; - Bool32 separateStencilMaskRef = {}; - Bool32 shaderSampleRateInterpolationFunctions = {}; - Bool32 tessellationIsolines = {}; - Bool32 tessellationPointMode = {}; - Bool32 triangleFans = {}; - Bool32 vertexAttributeAccessBeyondStride = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePortabilitySubsetFeaturesKHR; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDevicePortabilitySubsetFeaturesKHR; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkPhysicalDevicePortabilitySubsetPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePortabilitySubsetPropertiesKHR.html - struct PhysicalDevicePortabilitySubsetPropertiesKHR - { - using NativeType = VkPhysicalDevicePortabilitySubsetPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePortabilitySubsetPropertiesKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePortabilitySubsetPropertiesKHR( uint32_t minVertexInputBindingStrideAlignment_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minVertexInputBindingStrideAlignment{ minVertexInputBindingStrideAlignment_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePortabilitySubsetPropertiesKHR( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePortabilitySubsetPropertiesKHR( VkPhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePortabilitySubsetPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePortabilitySubsetPropertiesKHR & operator=( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePortabilitySubsetPropertiesKHR & operator=( VkPhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDevicePortabilitySubsetPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePortabilitySubsetPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePortabilitySubsetPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePortabilitySubsetPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minVertexInputBindingStrideAlignment ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePortabilitySubsetPropertiesKHR const & ) const = default; -# else - bool operator==( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minVertexInputBindingStrideAlignment == rhs.minVertexInputBindingStrideAlignment ); -# endif - } - - bool operator!=( PhysicalDevicePortabilitySubsetPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDevicePortabilitySubsetPropertiesKHR; - void * pNext = {}; - uint32_t minVertexInputBindingStrideAlignment = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePortabilitySubsetPropertiesKHR; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDevicePortabilitySubsetPropertiesKHR; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkPhysicalDevicePresentBarrierFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentBarrierFeaturesNV.html - struct PhysicalDevicePresentBarrierFeaturesNV - { - using NativeType = VkPhysicalDevicePresentBarrierFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentBarrierFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentBarrierFeaturesNV( Bool32 presentBarrier_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentBarrier{ presentBarrier_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentBarrierFeaturesNV( PhysicalDevicePresentBarrierFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePresentBarrierFeaturesNV( VkPhysicalDevicePresentBarrierFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePresentBarrierFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePresentBarrierFeaturesNV & operator=( PhysicalDevicePresentBarrierFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePresentBarrierFeaturesNV & operator=( VkPhysicalDevicePresentBarrierFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentBarrierFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentBarrierFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentBarrierFeaturesNV & setPresentBarrier( Bool32 presentBarrier_ ) & VULKAN_HPP_NOEXCEPT - { - presentBarrier = presentBarrier_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentBarrierFeaturesNV && setPresentBarrier( Bool32 presentBarrier_ ) && VULKAN_HPP_NOEXCEPT - { - presentBarrier = presentBarrier_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePresentBarrierFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentBarrierFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentBarrierFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentBarrierFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentBarrier ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePresentBarrierFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDevicePresentBarrierFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentBarrier == rhs.presentBarrier ); -# endif - } - - bool operator!=( PhysicalDevicePresentBarrierFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePresentBarrierFeaturesNV; - void * pNext = {}; - Bool32 presentBarrier = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePresentBarrierFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePresentBarrierFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDevicePresentId2FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentId2FeaturesKHR.html - struct PhysicalDevicePresentId2FeaturesKHR - { - using NativeType = VkPhysicalDevicePresentId2FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentId2FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentId2FeaturesKHR( Bool32 presentId2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentId2{ presentId2_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentId2FeaturesKHR( PhysicalDevicePresentId2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePresentId2FeaturesKHR( VkPhysicalDevicePresentId2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePresentId2FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePresentId2FeaturesKHR & operator=( PhysicalDevicePresentId2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePresentId2FeaturesKHR & operator=( VkPhysicalDevicePresentId2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentId2FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentId2FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentId2FeaturesKHR & setPresentId2( Bool32 presentId2_ ) & VULKAN_HPP_NOEXCEPT - { - presentId2 = presentId2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentId2FeaturesKHR && setPresentId2( Bool32 presentId2_ ) && VULKAN_HPP_NOEXCEPT - { - presentId2 = presentId2_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePresentId2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentId2FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentId2FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentId2FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentId2 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePresentId2FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDevicePresentId2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId2 == rhs.presentId2 ); -# endif - } - - bool operator!=( PhysicalDevicePresentId2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePresentId2FeaturesKHR; - void * pNext = {}; - Bool32 presentId2 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePresentId2FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePresentId2FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDevicePresentIdFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentIdFeaturesKHR.html - struct PhysicalDevicePresentIdFeaturesKHR - { - using NativeType = VkPhysicalDevicePresentIdFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentIdFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentIdFeaturesKHR( Bool32 presentId_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentId{ presentId_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentIdFeaturesKHR( PhysicalDevicePresentIdFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePresentIdFeaturesKHR( VkPhysicalDevicePresentIdFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePresentIdFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePresentIdFeaturesKHR & operator=( PhysicalDevicePresentIdFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePresentIdFeaturesKHR & operator=( VkPhysicalDevicePresentIdFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentIdFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentIdFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentIdFeaturesKHR & setPresentId( Bool32 presentId_ ) & VULKAN_HPP_NOEXCEPT - { - presentId = presentId_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentIdFeaturesKHR && setPresentId( Bool32 presentId_ ) && VULKAN_HPP_NOEXCEPT - { - presentId = presentId_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePresentIdFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentIdFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentIdFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentIdFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentId ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePresentIdFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId ); -# endif - } - - bool operator!=( PhysicalDevicePresentIdFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePresentIdFeaturesKHR; - void * pNext = {}; - Bool32 presentId = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePresentIdFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePresentIdFeaturesKHR; - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkPhysicalDevicePresentMeteringFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentMeteringFeaturesNV.html - struct PhysicalDevicePresentMeteringFeaturesNV - { - using NativeType = VkPhysicalDevicePresentMeteringFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentMeteringFeaturesNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentMeteringFeaturesNV( Bool32 presentMetering_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentMetering{ presentMetering_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentMeteringFeaturesNV( PhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePresentMeteringFeaturesNV( VkPhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePresentMeteringFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePresentMeteringFeaturesNV & operator=( PhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePresentMeteringFeaturesNV & operator=( VkPhysicalDevicePresentMeteringFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentMeteringFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentMeteringFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentMeteringFeaturesNV & setPresentMetering( Bool32 presentMetering_ ) & VULKAN_HPP_NOEXCEPT - { - presentMetering = presentMetering_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentMeteringFeaturesNV && setPresentMetering( Bool32 presentMetering_ ) && VULKAN_HPP_NOEXCEPT - { - presentMetering = presentMetering_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePresentMeteringFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentMeteringFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentMeteringFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentMeteringFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentMetering ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePresentMeteringFeaturesNV const & ) const = default; -# else - bool operator==( PhysicalDevicePresentMeteringFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMetering == rhs.presentMetering ); -# endif - } - - bool operator!=( PhysicalDevicePresentMeteringFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDevicePresentMeteringFeaturesNV; - void * pNext = {}; - Bool32 presentMetering = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePresentMeteringFeaturesNV; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDevicePresentMeteringFeaturesNV; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR.html - struct PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR - { - using NativeType = VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR( Bool32 presentModeFifoLatestReady_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentModeFifoLatestReady{ presentModeFifoLatestReady_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR( PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR( VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR & - operator=( PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR & operator=( VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR & setPresentModeFifoLatestReady( Bool32 presentModeFifoLatestReady_ ) & - VULKAN_HPP_NOEXCEPT - { - presentModeFifoLatestReady = presentModeFifoLatestReady_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR && setPresentModeFifoLatestReady( Bool32 presentModeFifoLatestReady_ ) && - VULKAN_HPP_NOEXCEPT - { - presentModeFifoLatestReady = presentModeFifoLatestReady_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentModeFifoLatestReady ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeFifoLatestReady == rhs.presentModeFifoLatestReady ); -# endif - } - - bool operator!=( PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; - void * pNext = {}; - Bool32 presentModeFifoLatestReady = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; - }; - - using PhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR; - - // wrapper struct for struct VkPhysicalDevicePresentTimingFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentTimingFeaturesEXT.html - struct PhysicalDevicePresentTimingFeaturesEXT - { - using NativeType = VkPhysicalDevicePresentTimingFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentTimingFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentTimingFeaturesEXT( Bool32 presentTiming_ = {}, - Bool32 presentAtAbsoluteTime_ = {}, - Bool32 presentAtRelativeTime_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentTiming{ presentTiming_ } - , presentAtAbsoluteTime{ presentAtAbsoluteTime_ } - , presentAtRelativeTime{ presentAtRelativeTime_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentTimingFeaturesEXT( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePresentTimingFeaturesEXT( VkPhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePresentTimingFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePresentTimingFeaturesEXT & operator=( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePresentTimingFeaturesEXT & operator=( VkPhysicalDevicePresentTimingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPresentTiming( Bool32 presentTiming_ ) & VULKAN_HPP_NOEXCEPT - { - presentTiming = presentTiming_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT && setPresentTiming( Bool32 presentTiming_ ) && VULKAN_HPP_NOEXCEPT - { - presentTiming = presentTiming_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPresentAtAbsoluteTime( Bool32 presentAtAbsoluteTime_ ) & VULKAN_HPP_NOEXCEPT - { - presentAtAbsoluteTime = presentAtAbsoluteTime_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT && setPresentAtAbsoluteTime( Bool32 presentAtAbsoluteTime_ ) && VULKAN_HPP_NOEXCEPT - { - presentAtAbsoluteTime = presentAtAbsoluteTime_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT & setPresentAtRelativeTime( Bool32 presentAtRelativeTime_ ) & VULKAN_HPP_NOEXCEPT - { - presentAtRelativeTime = presentAtRelativeTime_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentTimingFeaturesEXT && setPresentAtRelativeTime( Bool32 presentAtRelativeTime_ ) && VULKAN_HPP_NOEXCEPT - { - presentAtRelativeTime = presentAtRelativeTime_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePresentTimingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentTimingFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentTimingFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentTimingFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentTiming, presentAtAbsoluteTime, presentAtRelativeTime ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePresentTimingFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentTiming == rhs.presentTiming ) && - ( presentAtAbsoluteTime == rhs.presentAtAbsoluteTime ) && ( presentAtRelativeTime == rhs.presentAtRelativeTime ); -# endif - } - - bool operator!=( PhysicalDevicePresentTimingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePresentTimingFeaturesEXT; - void * pNext = {}; - Bool32 presentTiming = {}; - Bool32 presentAtAbsoluteTime = {}; - Bool32 presentAtRelativeTime = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePresentTimingFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePresentTimingFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDevicePresentWait2FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentWait2FeaturesKHR.html - struct PhysicalDevicePresentWait2FeaturesKHR - { - using NativeType = VkPhysicalDevicePresentWait2FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentWait2FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentWait2FeaturesKHR( Bool32 presentWait2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentWait2{ presentWait2_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentWait2FeaturesKHR( PhysicalDevicePresentWait2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePresentWait2FeaturesKHR( VkPhysicalDevicePresentWait2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePresentWait2FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePresentWait2FeaturesKHR & operator=( PhysicalDevicePresentWait2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePresentWait2FeaturesKHR & operator=( VkPhysicalDevicePresentWait2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWait2FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWait2FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWait2FeaturesKHR & setPresentWait2( Bool32 presentWait2_ ) & VULKAN_HPP_NOEXCEPT - { - presentWait2 = presentWait2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWait2FeaturesKHR && setPresentWait2( Bool32 presentWait2_ ) && VULKAN_HPP_NOEXCEPT - { - presentWait2 = presentWait2_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePresentWait2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentWait2FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentWait2FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentWait2FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentWait2 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePresentWait2FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDevicePresentWait2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait2 == rhs.presentWait2 ); -# endif - } - - bool operator!=( PhysicalDevicePresentWait2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePresentWait2FeaturesKHR; - void * pNext = {}; - Bool32 presentWait2 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePresentWait2FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePresentWait2FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDevicePresentWaitFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePresentWaitFeaturesKHR.html - struct PhysicalDevicePresentWaitFeaturesKHR - { - using NativeType = VkPhysicalDevicePresentWaitFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePresentWaitFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentWaitFeaturesKHR( Bool32 presentWait_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentWait{ presentWait_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePresentWaitFeaturesKHR( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePresentWaitFeaturesKHR( VkPhysicalDevicePresentWaitFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePresentWaitFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePresentWaitFeaturesKHR & operator=( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePresentWaitFeaturesKHR & operator=( VkPhysicalDevicePresentWaitFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWaitFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWaitFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWaitFeaturesKHR & setPresentWait( Bool32 presentWait_ ) & VULKAN_HPP_NOEXCEPT - { - presentWait = presentWait_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePresentWaitFeaturesKHR && setPresentWait( Bool32 presentWait_ ) && VULKAN_HPP_NOEXCEPT - { - presentWait = presentWait_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePresentWaitFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentWaitFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentWaitFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePresentWaitFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentWait ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePresentWaitFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait == rhs.presentWait ); -# endif - } - - bool operator!=( PhysicalDevicePresentWaitFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePresentWaitFeaturesKHR; - void * pNext = {}; - Bool32 presentWait = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePresentWaitFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePresentWaitFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.html - struct PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT - { - using NativeType = VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( Bool32 primitiveTopologyListRestart_ = {}, - Bool32 primitiveTopologyPatchListRestart_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , primitiveTopologyListRestart{ primitiveTopologyListRestart_ } - , primitiveTopologyPatchListRestart{ primitiveTopologyPatchListRestart_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT & - operator=( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT & operator=( VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT & setPrimitiveTopologyListRestart( Bool32 primitiveTopologyListRestart_ ) & - VULKAN_HPP_NOEXCEPT - { - primitiveTopologyListRestart = primitiveTopologyListRestart_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT && setPrimitiveTopologyListRestart( Bool32 primitiveTopologyListRestart_ ) && - VULKAN_HPP_NOEXCEPT - { - primitiveTopologyListRestart = primitiveTopologyListRestart_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT & - setPrimitiveTopologyPatchListRestart( Bool32 primitiveTopologyPatchListRestart_ ) & - VULKAN_HPP_NOEXCEPT - { - primitiveTopologyPatchListRestart = primitiveTopologyPatchListRestart_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT && - setPrimitiveTopologyPatchListRestart( Bool32 primitiveTopologyPatchListRestart_ ) && - VULKAN_HPP_NOEXCEPT - { - primitiveTopologyPatchListRestart = primitiveTopologyPatchListRestart_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, primitiveTopologyListRestart, primitiveTopologyPatchListRestart ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( primitiveTopologyListRestart == rhs.primitiveTopologyListRestart ) && - ( primitiveTopologyPatchListRestart == rhs.primitiveTopologyPatchListRestart ); -# endif - } - - bool operator!=( PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; - void * pNext = {}; - Bool32 primitiveTopologyListRestart = {}; - Bool32 primitiveTopologyPatchListRestart = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.html - struct PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT - { - using NativeType = VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT( Bool32 primitivesGeneratedQuery_ = {}, - Bool32 primitivesGeneratedQueryWithRasterizerDiscard_ = {}, - Bool32 primitivesGeneratedQueryWithNonZeroStreams_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , primitivesGeneratedQuery{ primitivesGeneratedQuery_ } - , primitivesGeneratedQueryWithRasterizerDiscard{ primitivesGeneratedQueryWithRasterizerDiscard_ } - , primitivesGeneratedQueryWithNonZeroStreams{ primitivesGeneratedQueryWithNonZeroStreams_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT( PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT( VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & - operator=( PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & operator=( VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & setPrimitivesGeneratedQuery( Bool32 primitivesGeneratedQuery_ ) & - VULKAN_HPP_NOEXCEPT - { - primitivesGeneratedQuery = primitivesGeneratedQuery_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT && setPrimitivesGeneratedQuery( Bool32 primitivesGeneratedQuery_ ) && - VULKAN_HPP_NOEXCEPT - { - primitivesGeneratedQuery = primitivesGeneratedQuery_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & - setPrimitivesGeneratedQueryWithRasterizerDiscard( Bool32 primitivesGeneratedQueryWithRasterizerDiscard_ ) & - VULKAN_HPP_NOEXCEPT - { - primitivesGeneratedQueryWithRasterizerDiscard = primitivesGeneratedQueryWithRasterizerDiscard_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT && - setPrimitivesGeneratedQueryWithRasterizerDiscard( Bool32 primitivesGeneratedQueryWithRasterizerDiscard_ ) && - VULKAN_HPP_NOEXCEPT - { - primitivesGeneratedQueryWithRasterizerDiscard = primitivesGeneratedQueryWithRasterizerDiscard_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT & - setPrimitivesGeneratedQueryWithNonZeroStreams( Bool32 primitivesGeneratedQueryWithNonZeroStreams_ ) & - VULKAN_HPP_NOEXCEPT - { - primitivesGeneratedQueryWithNonZeroStreams = primitivesGeneratedQueryWithNonZeroStreams_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT && - setPrimitivesGeneratedQueryWithNonZeroStreams( Bool32 primitivesGeneratedQueryWithNonZeroStreams_ ) && - VULKAN_HPP_NOEXCEPT - { - primitivesGeneratedQueryWithNonZeroStreams = primitivesGeneratedQueryWithNonZeroStreams_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, primitivesGeneratedQuery, primitivesGeneratedQueryWithRasterizerDiscard, primitivesGeneratedQueryWithNonZeroStreams ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( primitivesGeneratedQuery == rhs.primitivesGeneratedQuery ) && - ( primitivesGeneratedQueryWithRasterizerDiscard == rhs.primitivesGeneratedQueryWithRasterizerDiscard ) && - ( primitivesGeneratedQueryWithNonZeroStreams == rhs.primitivesGeneratedQueryWithNonZeroStreams ); -# endif - } - - bool operator!=( PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; - void * pNext = {}; - Bool32 primitivesGeneratedQuery = {}; - Bool32 primitivesGeneratedQueryWithRasterizerDiscard = {}; - Bool32 primitivesGeneratedQueryWithNonZeroStreams = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDevicePrivateDataFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePrivateDataFeatures.html - struct PhysicalDevicePrivateDataFeatures - { - using NativeType = VkPhysicalDevicePrivateDataFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePrivateDataFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePrivateDataFeatures( Bool32 privateData_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , privateData{ privateData_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePrivateDataFeatures( PhysicalDevicePrivateDataFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePrivateDataFeatures( VkPhysicalDevicePrivateDataFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePrivateDataFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePrivateDataFeatures & operator=( PhysicalDevicePrivateDataFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePrivateDataFeatures & operator=( VkPhysicalDevicePrivateDataFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataFeatures & setPrivateData( Bool32 privateData_ ) & VULKAN_HPP_NOEXCEPT - { - privateData = privateData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePrivateDataFeatures && setPrivateData( Bool32 privateData_ ) && VULKAN_HPP_NOEXCEPT - { - privateData = privateData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePrivateDataFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePrivateDataFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePrivateDataFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePrivateDataFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, privateData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePrivateDataFeatures const & ) const = default; -#else - bool operator==( PhysicalDevicePrivateDataFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( privateData == rhs.privateData ); -# endif - } - - bool operator!=( PhysicalDevicePrivateDataFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePrivateDataFeatures; - void * pNext = {}; - Bool32 privateData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePrivateDataFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePrivateDataFeatures; - }; - - using PhysicalDevicePrivateDataFeaturesEXT = PhysicalDevicePrivateDataFeatures; - - // wrapper struct for struct VkPhysicalDeviceProtectedMemoryFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProtectedMemoryFeatures.html - struct PhysicalDeviceProtectedMemoryFeatures - { - using NativeType = VkPhysicalDeviceProtectedMemoryFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( Bool32 protectedMemory_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , protectedMemory{ protectedMemory_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryFeatures( PhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceProtectedMemoryFeatures( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceProtectedMemoryFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceProtectedMemoryFeatures & operator=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceProtectedMemoryFeatures & operator=( VkPhysicalDeviceProtectedMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProtectedMemoryFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProtectedMemoryFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProtectedMemoryFeatures & setProtectedMemory( Bool32 protectedMemory_ ) & VULKAN_HPP_NOEXCEPT - { - protectedMemory = protectedMemory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProtectedMemoryFeatures && setProtectedMemory( Bool32 protectedMemory_ ) && VULKAN_HPP_NOEXCEPT - { - protectedMemory = protectedMemory_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceProtectedMemoryFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProtectedMemoryFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProtectedMemoryFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProtectedMemoryFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, protectedMemory ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceProtectedMemoryFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedMemory == rhs.protectedMemory ); -# endif - } - - bool operator!=( PhysicalDeviceProtectedMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryFeatures; - void * pNext = {}; - Bool32 protectedMemory = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceProtectedMemoryFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceProtectedMemoryFeatures; - }; - - // wrapper struct for struct VkPhysicalDeviceProtectedMemoryProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProtectedMemoryProperties.html - struct PhysicalDeviceProtectedMemoryProperties - { - using NativeType = VkPhysicalDeviceProtectedMemoryProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProtectedMemoryProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryProperties( Bool32 protectedNoFault_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , protectedNoFault{ protectedNoFault_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceProtectedMemoryProperties( PhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceProtectedMemoryProperties( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceProtectedMemoryProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceProtectedMemoryProperties & operator=( PhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceProtectedMemoryProperties & operator=( VkPhysicalDeviceProtectedMemoryProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceProtectedMemoryProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProtectedMemoryProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProtectedMemoryProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProtectedMemoryProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, protectedNoFault ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceProtectedMemoryProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedNoFault == rhs.protectedNoFault ); -# endif - } - - bool operator!=( PhysicalDeviceProtectedMemoryProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceProtectedMemoryProperties; - void * pNext = {}; - Bool32 protectedNoFault = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceProtectedMemoryProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceProtectedMemoryProperties; - }; - - // wrapper struct for struct VkPhysicalDeviceProvokingVertexFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProvokingVertexFeaturesEXT.html - struct PhysicalDeviceProvokingVertexFeaturesEXT - { - using NativeType = VkPhysicalDeviceProvokingVertexFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProvokingVertexFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceProvokingVertexFeaturesEXT( Bool32 provokingVertexLast_ = {}, - Bool32 transformFeedbackPreservesProvokingVertex_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , provokingVertexLast{ provokingVertexLast_ } - , transformFeedbackPreservesProvokingVertex{ transformFeedbackPreservesProvokingVertex_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceProvokingVertexFeaturesEXT( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceProvokingVertexFeaturesEXT( VkPhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceProvokingVertexFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceProvokingVertexFeaturesEXT & operator=( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceProvokingVertexFeaturesEXT & operator=( VkPhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT & setProvokingVertexLast( Bool32 provokingVertexLast_ ) & VULKAN_HPP_NOEXCEPT - { - provokingVertexLast = provokingVertexLast_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT && setProvokingVertexLast( Bool32 provokingVertexLast_ ) && VULKAN_HPP_NOEXCEPT - { - provokingVertexLast = provokingVertexLast_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT & - setTransformFeedbackPreservesProvokingVertex( Bool32 transformFeedbackPreservesProvokingVertex_ ) & - VULKAN_HPP_NOEXCEPT - { - transformFeedbackPreservesProvokingVertex = transformFeedbackPreservesProvokingVertex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceProvokingVertexFeaturesEXT && - setTransformFeedbackPreservesProvokingVertex( Bool32 transformFeedbackPreservesProvokingVertex_ ) && - VULKAN_HPP_NOEXCEPT - { - transformFeedbackPreservesProvokingVertex = transformFeedbackPreservesProvokingVertex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceProvokingVertexFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProvokingVertexFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProvokingVertexFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProvokingVertexFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, provokingVertexLast, transformFeedbackPreservesProvokingVertex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceProvokingVertexFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexLast == rhs.provokingVertexLast ) && - ( transformFeedbackPreservesProvokingVertex == rhs.transformFeedbackPreservesProvokingVertex ); -# endif - } - - bool operator!=( PhysicalDeviceProvokingVertexFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceProvokingVertexFeaturesEXT; - void * pNext = {}; - Bool32 provokingVertexLast = {}; - Bool32 transformFeedbackPreservesProvokingVertex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceProvokingVertexFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceProvokingVertexFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceProvokingVertexPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceProvokingVertexPropertiesEXT.html - struct PhysicalDeviceProvokingVertexPropertiesEXT - { - using NativeType = VkPhysicalDeviceProvokingVertexPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceProvokingVertexPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceProvokingVertexPropertiesEXT( Bool32 provokingVertexModePerPipeline_ = {}, - Bool32 transformFeedbackPreservesTriangleFanProvokingVertex_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , provokingVertexModePerPipeline{ provokingVertexModePerPipeline_ } - , transformFeedbackPreservesTriangleFanProvokingVertex{ transformFeedbackPreservesTriangleFanProvokingVertex_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceProvokingVertexPropertiesEXT( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceProvokingVertexPropertiesEXT( VkPhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceProvokingVertexPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceProvokingVertexPropertiesEXT & operator=( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceProvokingVertexPropertiesEXT & operator=( VkPhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceProvokingVertexPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProvokingVertexPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProvokingVertexPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceProvokingVertexPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, provokingVertexModePerPipeline, transformFeedbackPreservesTriangleFanProvokingVertex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceProvokingVertexPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexModePerPipeline == rhs.provokingVertexModePerPipeline ) && - ( transformFeedbackPreservesTriangleFanProvokingVertex == rhs.transformFeedbackPreservesTriangleFanProvokingVertex ); -# endif - } - - bool operator!=( PhysicalDeviceProvokingVertexPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceProvokingVertexPropertiesEXT; - void * pNext = {}; - Bool32 provokingVertexModePerPipeline = {}; - Bool32 transformFeedbackPreservesTriangleFanProvokingVertex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceProvokingVertexPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceProvokingVertexPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDevicePushConstantBankFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePushConstantBankFeaturesNV.html - struct PhysicalDevicePushConstantBankFeaturesNV - { - using NativeType = VkPhysicalDevicePushConstantBankFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePushConstantBankFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePushConstantBankFeaturesNV( Bool32 pushConstantBank_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pushConstantBank{ pushConstantBank_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePushConstantBankFeaturesNV( PhysicalDevicePushConstantBankFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePushConstantBankFeaturesNV( VkPhysicalDevicePushConstantBankFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePushConstantBankFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePushConstantBankFeaturesNV & operator=( PhysicalDevicePushConstantBankFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePushConstantBankFeaturesNV & operator=( VkPhysicalDevicePushConstantBankFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePushConstantBankFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePushConstantBankFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePushConstantBankFeaturesNV & setPushConstantBank( Bool32 pushConstantBank_ ) & VULKAN_HPP_NOEXCEPT - { - pushConstantBank = pushConstantBank_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDevicePushConstantBankFeaturesNV && setPushConstantBank( Bool32 pushConstantBank_ ) && VULKAN_HPP_NOEXCEPT - { - pushConstantBank = pushConstantBank_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDevicePushConstantBankFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePushConstantBankFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePushConstantBankFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePushConstantBankFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pushConstantBank ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePushConstantBankFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDevicePushConstantBankFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pushConstantBank == rhs.pushConstantBank ); -# endif - } - - bool operator!=( PhysicalDevicePushConstantBankFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePushConstantBankFeaturesNV; - void * pNext = {}; - Bool32 pushConstantBank = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePushConstantBankFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePushConstantBankFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDevicePushConstantBankPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePushConstantBankPropertiesNV.html - struct PhysicalDevicePushConstantBankPropertiesNV - { - using NativeType = VkPhysicalDevicePushConstantBankPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePushConstantBankPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePushConstantBankPropertiesNV( uint32_t maxGraphicsPushConstantBanks_ = {}, - uint32_t maxComputePushConstantBanks_ = {}, - uint32_t maxGraphicsPushDataBanks_ = {}, - uint32_t maxComputePushDataBanks_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxGraphicsPushConstantBanks{ maxGraphicsPushConstantBanks_ } - , maxComputePushConstantBanks{ maxComputePushConstantBanks_ } - , maxGraphicsPushDataBanks{ maxGraphicsPushDataBanks_ } - , maxComputePushDataBanks{ maxComputePushDataBanks_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePushConstantBankPropertiesNV( PhysicalDevicePushConstantBankPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePushConstantBankPropertiesNV( VkPhysicalDevicePushConstantBankPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePushConstantBankPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePushConstantBankPropertiesNV & operator=( PhysicalDevicePushConstantBankPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePushConstantBankPropertiesNV & operator=( VkPhysicalDevicePushConstantBankPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDevicePushConstantBankPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePushConstantBankPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePushConstantBankPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePushConstantBankPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxGraphicsPushConstantBanks, maxComputePushConstantBanks, maxGraphicsPushDataBanks, maxComputePushDataBanks ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePushConstantBankPropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDevicePushConstantBankPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxGraphicsPushConstantBanks == rhs.maxGraphicsPushConstantBanks ) && - ( maxComputePushConstantBanks == rhs.maxComputePushConstantBanks ) && ( maxGraphicsPushDataBanks == rhs.maxGraphicsPushDataBanks ) && - ( maxComputePushDataBanks == rhs.maxComputePushDataBanks ); -# endif - } - - bool operator!=( PhysicalDevicePushConstantBankPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePushConstantBankPropertiesNV; - void * pNext = {}; - uint32_t maxGraphicsPushConstantBanks = {}; - uint32_t maxComputePushConstantBanks = {}; - uint32_t maxGraphicsPushDataBanks = {}; - uint32_t maxComputePushDataBanks = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePushConstantBankPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePushConstantBankPropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDevicePushDescriptorProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDevicePushDescriptorProperties.html - struct PhysicalDevicePushDescriptorProperties - { - using NativeType = VkPhysicalDevicePushDescriptorProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDevicePushDescriptorProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDevicePushDescriptorProperties( uint32_t maxPushDescriptors_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxPushDescriptors{ maxPushDescriptors_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDevicePushDescriptorProperties( PhysicalDevicePushDescriptorProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDevicePushDescriptorProperties( VkPhysicalDevicePushDescriptorProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDevicePushDescriptorProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDevicePushDescriptorProperties & operator=( PhysicalDevicePushDescriptorProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDevicePushDescriptorProperties & operator=( VkPhysicalDevicePushDescriptorProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDevicePushDescriptorProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePushDescriptorProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDevicePushDescriptorProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDevicePushDescriptorProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxPushDescriptors ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDevicePushDescriptorProperties const & ) const = default; -#else - bool operator==( PhysicalDevicePushDescriptorProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPushDescriptors == rhs.maxPushDescriptors ); -# endif - } - - bool operator!=( PhysicalDevicePushDescriptorProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDevicePushDescriptorProperties; - void * pNext = {}; - uint32_t maxPushDescriptors = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDevicePushDescriptorProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDevicePushDescriptorProperties; - }; - - using PhysicalDevicePushDescriptorPropertiesKHR = PhysicalDevicePushDescriptorProperties; - - // wrapper struct for struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM.html - struct PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM - { - using NativeType = VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM( - uint32_t queueFamilyIndex_ = {}, - PhysicalDeviceDataGraphProcessingEngineTypeARM engineType_ = PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , queueFamilyIndex{ queueFamilyIndex_ } - , engineType{ engineType_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM( PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM( VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM( - *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & - operator=( PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & - operator=( VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM & - setEngineType( PhysicalDeviceDataGraphProcessingEngineTypeARM engineType_ ) & - VULKAN_HPP_NOEXCEPT - { - engineType = engineType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM && - setEngineType( PhysicalDeviceDataGraphProcessingEngineTypeARM engineType_ ) && - VULKAN_HPP_NOEXCEPT - { - engineType = engineType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, queueFamilyIndex, engineType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & ) const = default; -#else - bool operator==( PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( engineType == rhs.engineType ); -# endif - } - - bool operator!=( PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; - const void * pNext = {}; - uint32_t queueFamilyIndex = {}; - PhysicalDeviceDataGraphProcessingEngineTypeARM engineType = PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM; - }; - - // wrapper struct for struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.html - struct PhysicalDeviceRGBA10X6FormatsFeaturesEXT - { - using NativeType = VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRgba10X6FormatsFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRGBA10X6FormatsFeaturesEXT( Bool32 formatRgba10x6WithoutYCbCrSampler_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , formatRgba10x6WithoutYCbCrSampler{ formatRgba10x6WithoutYCbCrSampler_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRGBA10X6FormatsFeaturesEXT( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRGBA10X6FormatsFeaturesEXT( VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRGBA10X6FormatsFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRGBA10X6FormatsFeaturesEXT & operator=( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRGBA10X6FormatsFeaturesEXT & operator=( VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRGBA10X6FormatsFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRGBA10X6FormatsFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRGBA10X6FormatsFeaturesEXT & setFormatRgba10x6WithoutYCbCrSampler( Bool32 formatRgba10x6WithoutYCbCrSampler_ ) & - VULKAN_HPP_NOEXCEPT - { - formatRgba10x6WithoutYCbCrSampler = formatRgba10x6WithoutYCbCrSampler_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRGBA10X6FormatsFeaturesEXT && setFormatRgba10x6WithoutYCbCrSampler( Bool32 formatRgba10x6WithoutYCbCrSampler_ ) && - VULKAN_HPP_NOEXCEPT - { - formatRgba10x6WithoutYCbCrSampler = formatRgba10x6WithoutYCbCrSampler_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, formatRgba10x6WithoutYCbCrSampler ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( formatRgba10x6WithoutYCbCrSampler == rhs.formatRgba10x6WithoutYCbCrSampler ); -# endif - } - - bool operator!=( PhysicalDeviceRGBA10X6FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRgba10X6FormatsFeaturesEXT; - void * pNext = {}; - Bool32 formatRgba10x6WithoutYCbCrSampler = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRGBA10X6FormatsFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRGBA10X6FormatsFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.html - struct PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT - { - using NativeType = VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( Bool32 rasterizationOrderColorAttachmentAccess_ = {}, - Bool32 rasterizationOrderDepthAttachmentAccess_ = {}, - Bool32 rasterizationOrderStencilAttachmentAccess_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rasterizationOrderColorAttachmentAccess{ rasterizationOrderColorAttachmentAccess_ } - , rasterizationOrderDepthAttachmentAccess{ rasterizationOrderDepthAttachmentAccess_ } - , rasterizationOrderStencilAttachmentAccess{ rasterizationOrderStencilAttachmentAccess_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT( - *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & - operator=( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & - operator=( VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & - setRasterizationOrderColorAttachmentAccess( Bool32 rasterizationOrderColorAttachmentAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - rasterizationOrderColorAttachmentAccess = rasterizationOrderColorAttachmentAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT && - setRasterizationOrderColorAttachmentAccess( Bool32 rasterizationOrderColorAttachmentAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - rasterizationOrderColorAttachmentAccess = rasterizationOrderColorAttachmentAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & - setRasterizationOrderDepthAttachmentAccess( Bool32 rasterizationOrderDepthAttachmentAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - rasterizationOrderDepthAttachmentAccess = rasterizationOrderDepthAttachmentAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT && - setRasterizationOrderDepthAttachmentAccess( Bool32 rasterizationOrderDepthAttachmentAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - rasterizationOrderDepthAttachmentAccess = rasterizationOrderDepthAttachmentAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT & - setRasterizationOrderStencilAttachmentAccess( Bool32 rasterizationOrderStencilAttachmentAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - rasterizationOrderStencilAttachmentAccess = rasterizationOrderStencilAttachmentAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT && - setRasterizationOrderStencilAttachmentAccess( Bool32 rasterizationOrderStencilAttachmentAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - rasterizationOrderStencilAttachmentAccess = rasterizationOrderStencilAttachmentAccess_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, rasterizationOrderColorAttachmentAccess, rasterizationOrderDepthAttachmentAccess, rasterizationOrderStencilAttachmentAccess ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrderColorAttachmentAccess == rhs.rasterizationOrderColorAttachmentAccess ) && - ( rasterizationOrderDepthAttachmentAccess == rhs.rasterizationOrderDepthAttachmentAccess ) && - ( rasterizationOrderStencilAttachmentAccess == rhs.rasterizationOrderStencilAttachmentAccess ); -# endif - } - - bool operator!=( PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; - void * pNext = {}; - Bool32 rasterizationOrderColorAttachmentAccess = {}; - Bool32 rasterizationOrderDepthAttachmentAccess = {}; - Bool32 rasterizationOrderStencilAttachmentAccess = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; - }; - - using PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; - - // wrapper struct for struct VkPhysicalDeviceRawAccessChainsFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRawAccessChainsFeaturesNV.html - struct PhysicalDeviceRawAccessChainsFeaturesNV - { - using NativeType = VkPhysicalDeviceRawAccessChainsFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRawAccessChainsFeaturesNV( Bool32 shaderRawAccessChains_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderRawAccessChains{ shaderRawAccessChains_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRawAccessChainsFeaturesNV( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRawAccessChainsFeaturesNV( VkPhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRawAccessChainsFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRawAccessChainsFeaturesNV & operator=( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRawAccessChainsFeaturesNV & operator=( VkPhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV & setShaderRawAccessChains( Bool32 shaderRawAccessChains_ ) & VULKAN_HPP_NOEXCEPT - { - shaderRawAccessChains = shaderRawAccessChains_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRawAccessChainsFeaturesNV && setShaderRawAccessChains( Bool32 shaderRawAccessChains_ ) && VULKAN_HPP_NOEXCEPT - { - shaderRawAccessChains = shaderRawAccessChains_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRawAccessChainsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRawAccessChainsFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRawAccessChainsFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRawAccessChainsFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderRawAccessChains ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRawAccessChainsFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderRawAccessChains == rhs.shaderRawAccessChains ); -# endif - } - - bool operator!=( PhysicalDeviceRawAccessChainsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV; - void * pNext = {}; - Bool32 shaderRawAccessChains = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRawAccessChainsFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRawAccessChainsFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceRayQueryFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayQueryFeaturesKHR.html - struct PhysicalDeviceRayQueryFeaturesKHR - { - using NativeType = VkPhysicalDeviceRayQueryFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayQueryFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayQueryFeaturesKHR( Bool32 rayQuery_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rayQuery{ rayQuery_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayQueryFeaturesKHR( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayQueryFeaturesKHR( VkPhysicalDeviceRayQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayQueryFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayQueryFeaturesKHR & operator=( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayQueryFeaturesKHR & operator=( VkPhysicalDeviceRayQueryFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayQueryFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayQueryFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayQueryFeaturesKHR & setRayQuery( Bool32 rayQuery_ ) & VULKAN_HPP_NOEXCEPT - { - rayQuery = rayQuery_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayQueryFeaturesKHR && setRayQuery( Bool32 rayQuery_ ) && VULKAN_HPP_NOEXCEPT - { - rayQuery = rayQuery_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRayQueryFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayQueryFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayQueryFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayQueryFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rayQuery ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayQueryFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayQuery == rhs.rayQuery ); -# endif - } - - bool operator!=( PhysicalDeviceRayQueryFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayQueryFeaturesKHR; - void * pNext = {}; - Bool32 rayQuery = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayQueryFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayQueryFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT.html - struct PhysicalDeviceRayTracingInvocationReorderFeaturesEXT - { - using NativeType = VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingInvocationReorderFeaturesEXT( Bool32 rayTracingInvocationReorder_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rayTracingInvocationReorder{ rayTracingInvocationReorder_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceRayTracingInvocationReorderFeaturesEXT( PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingInvocationReorderFeaturesEXT( VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingInvocationReorderFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingInvocationReorderFeaturesEXT & - operator=( PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingInvocationReorderFeaturesEXT & operator=( VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesEXT & setRayTracingInvocationReorder( Bool32 rayTracingInvocationReorder_ ) & - VULKAN_HPP_NOEXCEPT - { - rayTracingInvocationReorder = rayTracingInvocationReorder_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesEXT && setRayTracingInvocationReorder( Bool32 rayTracingInvocationReorder_ ) && - VULKAN_HPP_NOEXCEPT - { - rayTracingInvocationReorder = rayTracingInvocationReorder_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rayTracingInvocationReorder ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingInvocationReorder == rhs.rayTracingInvocationReorder ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingInvocationReorderFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesEXT; - void * pNext = {}; - Bool32 rayTracingInvocationReorder = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingInvocationReorderFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingInvocationReorderFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.html - struct PhysicalDeviceRayTracingInvocationReorderFeaturesNV - { - using NativeType = VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingInvocationReorderFeaturesNV( Bool32 rayTracingInvocationReorder_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rayTracingInvocationReorder{ rayTracingInvocationReorder_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceRayTracingInvocationReorderFeaturesNV( PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingInvocationReorderFeaturesNV( VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingInvocationReorderFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingInvocationReorderFeaturesNV & - operator=( PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingInvocationReorderFeaturesNV & operator=( VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesNV & setRayTracingInvocationReorder( Bool32 rayTracingInvocationReorder_ ) & - VULKAN_HPP_NOEXCEPT - { - rayTracingInvocationReorder = rayTracingInvocationReorder_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingInvocationReorderFeaturesNV && setRayTracingInvocationReorder( Bool32 rayTracingInvocationReorder_ ) && - VULKAN_HPP_NOEXCEPT - { - rayTracingInvocationReorder = rayTracingInvocationReorder_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rayTracingInvocationReorder ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingInvocationReorder == rhs.rayTracingInvocationReorder ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingInvocationReorderFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV; - void * pNext = {}; - Bool32 rayTracingInvocationReorder = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingInvocationReorderFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingInvocationReorderFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT.html - struct PhysicalDeviceRayTracingInvocationReorderPropertiesEXT - { - using NativeType = VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingInvocationReorderPropertiesEXT( - RayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint_ = RayTracingInvocationReorderModeEXT::eNone, - uint32_t maxShaderBindingTableRecordIndex_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rayTracingInvocationReorderReorderingHint{ rayTracingInvocationReorderReorderingHint_ } - , maxShaderBindingTableRecordIndex{ maxShaderBindingTableRecordIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingInvocationReorderPropertiesEXT( PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingInvocationReorderPropertiesEXT( VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingInvocationReorderPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingInvocationReorderPropertiesEXT & - operator=( PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingInvocationReorderPropertiesEXT & - operator=( VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rayTracingInvocationReorderReorderingHint, maxShaderBindingTableRecordIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && - ( rayTracingInvocationReorderReorderingHint == rhs.rayTracingInvocationReorderReorderingHint ) && - ( maxShaderBindingTableRecordIndex == rhs.maxShaderBindingTableRecordIndex ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingInvocationReorderPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesEXT; - void * pNext = {}; - RayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint = RayTracingInvocationReorderModeEXT::eNone; - uint32_t maxShaderBindingTableRecordIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingInvocationReorderPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingInvocationReorderPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV.html - struct PhysicalDeviceRayTracingInvocationReorderPropertiesNV - { - using NativeType = VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingInvocationReorderPropertiesNV( - RayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint_ = RayTracingInvocationReorderModeEXT::eNone, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rayTracingInvocationReorderReorderingHint{ rayTracingInvocationReorderReorderingHint_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceRayTracingInvocationReorderPropertiesNV( PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingInvocationReorderPropertiesNV( VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingInvocationReorderPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingInvocationReorderPropertiesNV & - operator=( PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingInvocationReorderPropertiesNV & operator=( VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rayTracingInvocationReorderReorderingHint ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingInvocationReorderReorderingHint == rhs.rayTracingInvocationReorderReorderingHint ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingInvocationReorderPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV; - void * pNext = {}; - RayTracingInvocationReorderModeEXT rayTracingInvocationReorderReorderingHint = RayTracingInvocationReorderModeEXT::eNone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingInvocationReorderPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingInvocationReorderPropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.html - struct PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV - { - using NativeType = VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV( Bool32 spheres_ = {}, Bool32 linearSweptSpheres_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , spheres{ spheres_ } - , linearSweptSpheres{ linearSweptSpheres_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV( PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV( VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV & - operator=( PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV & operator=( VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV & setSpheres( Bool32 spheres_ ) & VULKAN_HPP_NOEXCEPT - { - spheres = spheres_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV && setSpheres( Bool32 spheres_ ) && VULKAN_HPP_NOEXCEPT - { - spheres = spheres_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV & setLinearSweptSpheres( Bool32 linearSweptSpheres_ ) & VULKAN_HPP_NOEXCEPT - { - linearSweptSpheres = linearSweptSpheres_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV && setLinearSweptSpheres( Bool32 linearSweptSpheres_ ) && VULKAN_HPP_NOEXCEPT - { - linearSweptSpheres = linearSweptSpheres_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, spheres, linearSweptSpheres ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( spheres == rhs.spheres ) && ( linearSweptSpheres == rhs.linearSweptSpheres ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; - void * pNext = {}; - Bool32 spheres = {}; - Bool32 linearSweptSpheres = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.html - struct PhysicalDeviceRayTracingMaintenance1FeaturesKHR - { - using NativeType = VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingMaintenance1FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingMaintenance1FeaturesKHR( Bool32 rayTracingMaintenance1_ = {}, - Bool32 rayTracingPipelineTraceRaysIndirect2_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rayTracingMaintenance1{ rayTracingMaintenance1_ } - , rayTracingPipelineTraceRaysIndirect2{ rayTracingPipelineTraceRaysIndirect2_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceRayTracingMaintenance1FeaturesKHR( PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingMaintenance1FeaturesKHR( VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingMaintenance1FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingMaintenance1FeaturesKHR & operator=( PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingMaintenance1FeaturesKHR & operator=( VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR & setRayTracingMaintenance1( Bool32 rayTracingMaintenance1_ ) & VULKAN_HPP_NOEXCEPT - { - rayTracingMaintenance1 = rayTracingMaintenance1_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR && setRayTracingMaintenance1( Bool32 rayTracingMaintenance1_ ) && - VULKAN_HPP_NOEXCEPT - { - rayTracingMaintenance1 = rayTracingMaintenance1_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR & - setRayTracingPipelineTraceRaysIndirect2( Bool32 rayTracingPipelineTraceRaysIndirect2_ ) & - VULKAN_HPP_NOEXCEPT - { - rayTracingPipelineTraceRaysIndirect2 = rayTracingPipelineTraceRaysIndirect2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMaintenance1FeaturesKHR && - setRayTracingPipelineTraceRaysIndirect2( Bool32 rayTracingPipelineTraceRaysIndirect2_ ) && - VULKAN_HPP_NOEXCEPT - { - rayTracingPipelineTraceRaysIndirect2 = rayTracingPipelineTraceRaysIndirect2_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rayTracingMaintenance1, rayTracingPipelineTraceRaysIndirect2 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMaintenance1 == rhs.rayTracingMaintenance1 ) && - ( rayTracingPipelineTraceRaysIndirect2 == rhs.rayTracingPipelineTraceRaysIndirect2 ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingMaintenance1FeaturesKHR; - void * pNext = {}; - Bool32 rayTracingMaintenance1 = {}; - Bool32 rayTracingPipelineTraceRaysIndirect2 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingMaintenance1FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingMaintenance1FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.html - struct PhysicalDeviceRayTracingMotionBlurFeaturesNV - { - using NativeType = VkPhysicalDeviceRayTracingMotionBlurFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingMotionBlurFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingMotionBlurFeaturesNV( Bool32 rayTracingMotionBlur_ = {}, - Bool32 rayTracingMotionBlurPipelineTraceRaysIndirect_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rayTracingMotionBlur{ rayTracingMotionBlur_ } - , rayTracingMotionBlurPipelineTraceRaysIndirect{ rayTracingMotionBlurPipelineTraceRaysIndirect_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingMotionBlurFeaturesNV( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingMotionBlurFeaturesNV( VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingMotionBlurFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingMotionBlurFeaturesNV & operator=( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingMotionBlurFeaturesNV & operator=( VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV & setRayTracingMotionBlur( Bool32 rayTracingMotionBlur_ ) & VULKAN_HPP_NOEXCEPT - { - rayTracingMotionBlur = rayTracingMotionBlur_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV && setRayTracingMotionBlur( Bool32 rayTracingMotionBlur_ ) && VULKAN_HPP_NOEXCEPT - { - rayTracingMotionBlur = rayTracingMotionBlur_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV & - setRayTracingMotionBlurPipelineTraceRaysIndirect( Bool32 rayTracingMotionBlurPipelineTraceRaysIndirect_ ) & - VULKAN_HPP_NOEXCEPT - { - rayTracingMotionBlurPipelineTraceRaysIndirect = rayTracingMotionBlurPipelineTraceRaysIndirect_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingMotionBlurFeaturesNV && - setRayTracingMotionBlurPipelineTraceRaysIndirect( Bool32 rayTracingMotionBlurPipelineTraceRaysIndirect_ ) && - VULKAN_HPP_NOEXCEPT - { - rayTracingMotionBlurPipelineTraceRaysIndirect = rayTracingMotionBlurPipelineTraceRaysIndirect_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rayTracingMotionBlur, rayTracingMotionBlurPipelineTraceRaysIndirect ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingMotionBlur == rhs.rayTracingMotionBlur ) && - ( rayTracingMotionBlurPipelineTraceRaysIndirect == rhs.rayTracingMotionBlurPipelineTraceRaysIndirect ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingMotionBlurFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingMotionBlurFeaturesNV; - void * pNext = {}; - Bool32 rayTracingMotionBlur = {}; - Bool32 rayTracingMotionBlurPipelineTraceRaysIndirect = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingMotionBlurFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingMotionBlurFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPipelineFeaturesKHR.html - struct PhysicalDeviceRayTracingPipelineFeaturesKHR - { - using NativeType = VkPhysicalDeviceRayTracingPipelineFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPipelineFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPipelineFeaturesKHR( Bool32 rayTracingPipeline_ = {}, - Bool32 rayTracingPipelineShaderGroupHandleCaptureReplay_ = {}, - Bool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed_ = {}, - Bool32 rayTracingPipelineTraceRaysIndirect_ = {}, - Bool32 rayTraversalPrimitiveCulling_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rayTracingPipeline{ rayTracingPipeline_ } - , rayTracingPipelineShaderGroupHandleCaptureReplay{ rayTracingPipelineShaderGroupHandleCaptureReplay_ } - , rayTracingPipelineShaderGroupHandleCaptureReplayMixed{ rayTracingPipelineShaderGroupHandleCaptureReplayMixed_ } - , rayTracingPipelineTraceRaysIndirect{ rayTracingPipelineTraceRaysIndirect_ } - , rayTraversalPrimitiveCulling{ rayTraversalPrimitiveCulling_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPipelineFeaturesKHR( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingPipelineFeaturesKHR( VkPhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingPipelineFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingPipelineFeaturesKHR & operator=( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingPipelineFeaturesKHR & operator=( VkPhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & setRayTracingPipeline( Bool32 rayTracingPipeline_ ) & VULKAN_HPP_NOEXCEPT - { - rayTracingPipeline = rayTracingPipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && setRayTracingPipeline( Bool32 rayTracingPipeline_ ) && VULKAN_HPP_NOEXCEPT - { - rayTracingPipeline = rayTracingPipeline_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & - setRayTracingPipelineShaderGroupHandleCaptureReplay( Bool32 rayTracingPipelineShaderGroupHandleCaptureReplay_ ) & - VULKAN_HPP_NOEXCEPT - { - rayTracingPipelineShaderGroupHandleCaptureReplay = rayTracingPipelineShaderGroupHandleCaptureReplay_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && - setRayTracingPipelineShaderGroupHandleCaptureReplay( Bool32 rayTracingPipelineShaderGroupHandleCaptureReplay_ ) && - VULKAN_HPP_NOEXCEPT - { - rayTracingPipelineShaderGroupHandleCaptureReplay = rayTracingPipelineShaderGroupHandleCaptureReplay_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & - setRayTracingPipelineShaderGroupHandleCaptureReplayMixed( Bool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed_ ) & - VULKAN_HPP_NOEXCEPT - { - rayTracingPipelineShaderGroupHandleCaptureReplayMixed = rayTracingPipelineShaderGroupHandleCaptureReplayMixed_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && - setRayTracingPipelineShaderGroupHandleCaptureReplayMixed( Bool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed_ ) && - VULKAN_HPP_NOEXCEPT - { - rayTracingPipelineShaderGroupHandleCaptureReplayMixed = rayTracingPipelineShaderGroupHandleCaptureReplayMixed_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & - setRayTracingPipelineTraceRaysIndirect( Bool32 rayTracingPipelineTraceRaysIndirect_ ) & - VULKAN_HPP_NOEXCEPT - { - rayTracingPipelineTraceRaysIndirect = rayTracingPipelineTraceRaysIndirect_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && - setRayTracingPipelineTraceRaysIndirect( Bool32 rayTracingPipelineTraceRaysIndirect_ ) && - VULKAN_HPP_NOEXCEPT - { - rayTracingPipelineTraceRaysIndirect = rayTracingPipelineTraceRaysIndirect_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR & setRayTraversalPrimitiveCulling( Bool32 rayTraversalPrimitiveCulling_ ) & - VULKAN_HPP_NOEXCEPT - { - rayTraversalPrimitiveCulling = rayTraversalPrimitiveCulling_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPipelineFeaturesKHR && setRayTraversalPrimitiveCulling( Bool32 rayTraversalPrimitiveCulling_ ) && - VULKAN_HPP_NOEXCEPT - { - rayTraversalPrimitiveCulling = rayTraversalPrimitiveCulling_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPipelineFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - rayTracingPipeline, - rayTracingPipelineShaderGroupHandleCaptureReplay, - rayTracingPipelineShaderGroupHandleCaptureReplayMixed, - rayTracingPipelineTraceRaysIndirect, - rayTraversalPrimitiveCulling ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingPipelineFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPipeline == rhs.rayTracingPipeline ) && - ( rayTracingPipelineShaderGroupHandleCaptureReplay == rhs.rayTracingPipelineShaderGroupHandleCaptureReplay ) && - ( rayTracingPipelineShaderGroupHandleCaptureReplayMixed == rhs.rayTracingPipelineShaderGroupHandleCaptureReplayMixed ) && - ( rayTracingPipelineTraceRaysIndirect == rhs.rayTracingPipelineTraceRaysIndirect ) && - ( rayTraversalPrimitiveCulling == rhs.rayTraversalPrimitiveCulling ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingPipelineFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingPipelineFeaturesKHR; - void * pNext = {}; - Bool32 rayTracingPipeline = {}; - Bool32 rayTracingPipelineShaderGroupHandleCaptureReplay = {}; - Bool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed = {}; - Bool32 rayTracingPipelineTraceRaysIndirect = {}; - Bool32 rayTraversalPrimitiveCulling = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingPipelineFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingPipelineFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPipelinePropertiesKHR.html - struct PhysicalDeviceRayTracingPipelinePropertiesKHR - { - using NativeType = VkPhysicalDeviceRayTracingPipelinePropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPipelinePropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPipelinePropertiesKHR( uint32_t shaderGroupHandleSize_ = {}, - uint32_t maxRayRecursionDepth_ = {}, - uint32_t maxShaderGroupStride_ = {}, - uint32_t shaderGroupBaseAlignment_ = {}, - uint32_t shaderGroupHandleCaptureReplaySize_ = {}, - uint32_t maxRayDispatchInvocationCount_ = {}, - uint32_t shaderGroupHandleAlignment_ = {}, - uint32_t maxRayHitAttributeSize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderGroupHandleSize{ shaderGroupHandleSize_ } - , maxRayRecursionDepth{ maxRayRecursionDepth_ } - , maxShaderGroupStride{ maxShaderGroupStride_ } - , shaderGroupBaseAlignment{ shaderGroupBaseAlignment_ } - , shaderGroupHandleCaptureReplaySize{ shaderGroupHandleCaptureReplaySize_ } - , maxRayDispatchInvocationCount{ maxRayDispatchInvocationCount_ } - , shaderGroupHandleAlignment{ shaderGroupHandleAlignment_ } - , maxRayHitAttributeSize{ maxRayHitAttributeSize_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceRayTracingPipelinePropertiesKHR( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingPipelinePropertiesKHR( VkPhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingPipelinePropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingPipelinePropertiesKHR & operator=( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingPipelinePropertiesKHR & operator=( VkPhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPipelinePropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - shaderGroupHandleSize, - maxRayRecursionDepth, - maxShaderGroupStride, - shaderGroupBaseAlignment, - shaderGroupHandleCaptureReplaySize, - maxRayDispatchInvocationCount, - shaderGroupHandleAlignment, - maxRayHitAttributeSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingPipelinePropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) && - ( maxRayRecursionDepth == rhs.maxRayRecursionDepth ) && ( maxShaderGroupStride == rhs.maxShaderGroupStride ) && - ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) && ( shaderGroupHandleCaptureReplaySize == rhs.shaderGroupHandleCaptureReplaySize ) && - ( maxRayDispatchInvocationCount == rhs.maxRayDispatchInvocationCount ) && ( shaderGroupHandleAlignment == rhs.shaderGroupHandleAlignment ) && - ( maxRayHitAttributeSize == rhs.maxRayHitAttributeSize ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingPipelinePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingPipelinePropertiesKHR; - void * pNext = {}; - uint32_t shaderGroupHandleSize = {}; - uint32_t maxRayRecursionDepth = {}; - uint32_t maxShaderGroupStride = {}; - uint32_t shaderGroupBaseAlignment = {}; - uint32_t shaderGroupHandleCaptureReplaySize = {}; - uint32_t maxRayDispatchInvocationCount = {}; - uint32_t shaderGroupHandleAlignment = {}; - uint32_t maxRayHitAttributeSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingPipelinePropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingPipelinePropertiesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.html - struct PhysicalDeviceRayTracingPositionFetchFeaturesKHR - { - using NativeType = VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPositionFetchFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPositionFetchFeaturesKHR( Bool32 rayTracingPositionFetch_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rayTracingPositionFetch{ rayTracingPositionFetch_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceRayTracingPositionFetchFeaturesKHR( PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingPositionFetchFeaturesKHR( VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingPositionFetchFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingPositionFetchFeaturesKHR & operator=( PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingPositionFetchFeaturesKHR & operator=( VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPositionFetchFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPositionFetchFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPositionFetchFeaturesKHR & setRayTracingPositionFetch( Bool32 rayTracingPositionFetch_ ) & - VULKAN_HPP_NOEXCEPT - { - rayTracingPositionFetch = rayTracingPositionFetch_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingPositionFetchFeaturesKHR && setRayTracingPositionFetch( Bool32 rayTracingPositionFetch_ ) && - VULKAN_HPP_NOEXCEPT - { - rayTracingPositionFetch = rayTracingPositionFetch_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rayTracingPositionFetch ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingPositionFetch == rhs.rayTracingPositionFetch ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingPositionFetchFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingPositionFetchFeaturesKHR; - void * pNext = {}; - Bool32 rayTracingPositionFetch = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingPositionFetchFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingPositionFetchFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingPropertiesNV.html - struct PhysicalDeviceRayTracingPropertiesNV - { - using NativeType = VkPhysicalDeviceRayTracingPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesNV( uint32_t shaderGroupHandleSize_ = {}, - uint32_t maxRecursionDepth_ = {}, - uint32_t maxShaderGroupStride_ = {}, - uint32_t shaderGroupBaseAlignment_ = {}, - uint64_t maxGeometryCount_ = {}, - uint64_t maxInstanceCount_ = {}, - uint64_t maxTriangleCount_ = {}, - uint32_t maxDescriptorSetAccelerationStructures_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderGroupHandleSize{ shaderGroupHandleSize_ } - , maxRecursionDepth{ maxRecursionDepth_ } - , maxShaderGroupStride{ maxShaderGroupStride_ } - , shaderGroupBaseAlignment{ shaderGroupBaseAlignment_ } - , maxGeometryCount{ maxGeometryCount_ } - , maxInstanceCount{ maxInstanceCount_ } - , maxTriangleCount{ maxTriangleCount_ } - , maxDescriptorSetAccelerationStructures{ maxDescriptorSetAccelerationStructures_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingPropertiesNV( PhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingPropertiesNV( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingPropertiesNV & operator=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingPropertiesNV & operator=( VkPhysicalDeviceRayTracingPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceRayTracingPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - shaderGroupHandleSize, - maxRecursionDepth, - maxShaderGroupStride, - shaderGroupBaseAlignment, - maxGeometryCount, - maxInstanceCount, - maxTriangleCount, - maxDescriptorSetAccelerationStructures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingPropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderGroupHandleSize == rhs.shaderGroupHandleSize ) && - ( maxRecursionDepth == rhs.maxRecursionDepth ) && ( maxShaderGroupStride == rhs.maxShaderGroupStride ) && - ( shaderGroupBaseAlignment == rhs.shaderGroupBaseAlignment ) && ( maxGeometryCount == rhs.maxGeometryCount ) && - ( maxInstanceCount == rhs.maxInstanceCount ) && ( maxTriangleCount == rhs.maxTriangleCount ) && - ( maxDescriptorSetAccelerationStructures == rhs.maxDescriptorSetAccelerationStructures ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingPropertiesNV; - void * pNext = {}; - uint32_t shaderGroupHandleSize = {}; - uint32_t maxRecursionDepth = {}; - uint32_t maxShaderGroupStride = {}; - uint32_t shaderGroupBaseAlignment = {}; - uint64_t maxGeometryCount = {}; - uint64_t maxInstanceCount = {}; - uint64_t maxTriangleCount = {}; - uint32_t maxDescriptorSetAccelerationStructures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingPropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceRayTracingValidationFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRayTracingValidationFeaturesNV.html - struct PhysicalDeviceRayTracingValidationFeaturesNV - { - using NativeType = VkPhysicalDeviceRayTracingValidationFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingValidationFeaturesNV( Bool32 rayTracingValidation_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rayTracingValidation{ rayTracingValidation_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRayTracingValidationFeaturesNV( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRayTracingValidationFeaturesNV( VkPhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRayTracingValidationFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRayTracingValidationFeaturesNV & operator=( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRayTracingValidationFeaturesNV & operator=( VkPhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV & setRayTracingValidation( Bool32 rayTracingValidation_ ) & VULKAN_HPP_NOEXCEPT - { - rayTracingValidation = rayTracingValidation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRayTracingValidationFeaturesNV && setRayTracingValidation( Bool32 rayTracingValidation_ ) && VULKAN_HPP_NOEXCEPT - { - rayTracingValidation = rayTracingValidation_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRayTracingValidationFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingValidationFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingValidationFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRayTracingValidationFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rayTracingValidation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRayTracingValidationFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rayTracingValidation == rhs.rayTracingValidation ); -# endif - } - - bool operator!=( PhysicalDeviceRayTracingValidationFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV; - void * pNext = {}; - Bool32 rayTracingValidation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingValidationFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRayTracingValidationFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.html - struct PhysicalDeviceRelaxedLineRasterizationFeaturesIMG - { - using NativeType = VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRelaxedLineRasterizationFeaturesIMG; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRelaxedLineRasterizationFeaturesIMG( Bool32 relaxedLineRasterization_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , relaxedLineRasterization{ relaxedLineRasterization_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceRelaxedLineRasterizationFeaturesIMG( PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRelaxedLineRasterizationFeaturesIMG( VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRelaxedLineRasterizationFeaturesIMG( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRelaxedLineRasterizationFeaturesIMG & - operator=( PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRelaxedLineRasterizationFeaturesIMG & operator=( VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRelaxedLineRasterizationFeaturesIMG & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRelaxedLineRasterizationFeaturesIMG && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRelaxedLineRasterizationFeaturesIMG & setRelaxedLineRasterization( Bool32 relaxedLineRasterization_ ) & - VULKAN_HPP_NOEXCEPT - { - relaxedLineRasterization = relaxedLineRasterization_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRelaxedLineRasterizationFeaturesIMG && setRelaxedLineRasterization( Bool32 relaxedLineRasterization_ ) && - VULKAN_HPP_NOEXCEPT - { - relaxedLineRasterization = relaxedLineRasterization_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, relaxedLineRasterization ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & ) const = default; -#else - bool operator==( PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( relaxedLineRasterization == rhs.relaxedLineRasterization ); -# endif - } - - bool operator!=( PhysicalDeviceRelaxedLineRasterizationFeaturesIMG const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRelaxedLineRasterizationFeaturesIMG; - void * pNext = {}; - Bool32 relaxedLineRasterization = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRelaxedLineRasterizationFeaturesIMG; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRelaxedLineRasterizationFeaturesIMG; - }; - - // wrapper struct for struct VkPhysicalDeviceRenderPassStripedFeaturesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRenderPassStripedFeaturesARM.html - struct PhysicalDeviceRenderPassStripedFeaturesARM - { - using NativeType = VkPhysicalDeviceRenderPassStripedFeaturesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRenderPassStripedFeaturesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRenderPassStripedFeaturesARM( Bool32 renderPassStriped_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , renderPassStriped{ renderPassStriped_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRenderPassStripedFeaturesARM( PhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRenderPassStripedFeaturesARM( VkPhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRenderPassStripedFeaturesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRenderPassStripedFeaturesARM & operator=( PhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRenderPassStripedFeaturesARM & operator=( VkPhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRenderPassStripedFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRenderPassStripedFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRenderPassStripedFeaturesARM & setRenderPassStriped( Bool32 renderPassStriped_ ) & VULKAN_HPP_NOEXCEPT - { - renderPassStriped = renderPassStriped_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRenderPassStripedFeaturesARM && setRenderPassStriped( Bool32 renderPassStriped_ ) && VULKAN_HPP_NOEXCEPT - { - renderPassStriped = renderPassStriped_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRenderPassStripedFeaturesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRenderPassStripedFeaturesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRenderPassStripedFeaturesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRenderPassStripedFeaturesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, renderPassStriped ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRenderPassStripedFeaturesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPassStriped == rhs.renderPassStriped ); -# endif - } - - bool operator!=( PhysicalDeviceRenderPassStripedFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRenderPassStripedFeaturesARM; - void * pNext = {}; - Bool32 renderPassStriped = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRenderPassStripedFeaturesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRenderPassStripedFeaturesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceRenderPassStripedPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRenderPassStripedPropertiesARM.html - struct PhysicalDeviceRenderPassStripedPropertiesARM - { - using NativeType = VkPhysicalDeviceRenderPassStripedPropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRenderPassStripedPropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRenderPassStripedPropertiesARM( Extent2D renderPassStripeGranularity_ = {}, - uint32_t maxRenderPassStripes_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , renderPassStripeGranularity{ renderPassStripeGranularity_ } - , maxRenderPassStripes{ maxRenderPassStripes_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRenderPassStripedPropertiesARM( PhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRenderPassStripedPropertiesARM( VkPhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRenderPassStripedPropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRenderPassStripedPropertiesARM & operator=( PhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRenderPassStripedPropertiesARM & operator=( VkPhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceRenderPassStripedPropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRenderPassStripedPropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRenderPassStripedPropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRenderPassStripedPropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, renderPassStripeGranularity, maxRenderPassStripes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRenderPassStripedPropertiesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPassStripeGranularity == rhs.renderPassStripeGranularity ) && - ( maxRenderPassStripes == rhs.maxRenderPassStripes ); -# endif - } - - bool operator!=( PhysicalDeviceRenderPassStripedPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRenderPassStripedPropertiesARM; - void * pNext = {}; - Extent2D renderPassStripeGranularity = {}; - uint32_t maxRenderPassStripes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRenderPassStripedPropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRenderPassStripedPropertiesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.html - struct PhysicalDeviceRepresentativeFragmentTestFeaturesNV - { - using NativeType = VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRepresentativeFragmentTestFeaturesNV( Bool32 representativeFragmentTest_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , representativeFragmentTest{ representativeFragmentTest_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceRepresentativeFragmentTestFeaturesNV( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRepresentativeFragmentTestFeaturesNV( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRepresentativeFragmentTestFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRepresentativeFragmentTestFeaturesNV & - operator=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRepresentativeFragmentTestFeaturesNV & operator=( VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRepresentativeFragmentTestFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRepresentativeFragmentTestFeaturesNV & setRepresentativeFragmentTest( Bool32 representativeFragmentTest_ ) & - VULKAN_HPP_NOEXCEPT - { - representativeFragmentTest = representativeFragmentTest_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRepresentativeFragmentTestFeaturesNV && setRepresentativeFragmentTest( Bool32 representativeFragmentTest_ ) && - VULKAN_HPP_NOEXCEPT - { - representativeFragmentTest = representativeFragmentTest_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, representativeFragmentTest ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( representativeFragmentTest == rhs.representativeFragmentTest ); -# endif - } - - bool operator!=( PhysicalDeviceRepresentativeFragmentTestFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV; - void * pNext = {}; - Bool32 representativeFragmentTest = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceRobustness2FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2FeaturesKHR.html - struct PhysicalDeviceRobustness2FeaturesKHR - { - using NativeType = VkPhysicalDeviceRobustness2FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesKHR( Bool32 robustBufferAccess2_ = {}, - Bool32 robustImageAccess2_ = {}, - Bool32 nullDescriptor_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , robustBufferAccess2{ robustBufferAccess2_ } - , robustImageAccess2{ robustImageAccess2_ } - , nullDescriptor{ nullDescriptor_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2FeaturesKHR( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRobustness2FeaturesKHR( VkPhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRobustness2FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRobustness2FeaturesKHR & operator=( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRobustness2FeaturesKHR & operator=( VkPhysicalDeviceRobustness2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setRobustBufferAccess2( Bool32 robustBufferAccess2_ ) & VULKAN_HPP_NOEXCEPT - { - robustBufferAccess2 = robustBufferAccess2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR && setRobustBufferAccess2( Bool32 robustBufferAccess2_ ) && VULKAN_HPP_NOEXCEPT - { - robustBufferAccess2 = robustBufferAccess2_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setRobustImageAccess2( Bool32 robustImageAccess2_ ) & VULKAN_HPP_NOEXCEPT - { - robustImageAccess2 = robustImageAccess2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR && setRobustImageAccess2( Bool32 robustImageAccess2_ ) && VULKAN_HPP_NOEXCEPT - { - robustImageAccess2 = robustImageAccess2_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR & setNullDescriptor( Bool32 nullDescriptor_ ) & VULKAN_HPP_NOEXCEPT - { - nullDescriptor = nullDescriptor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceRobustness2FeaturesKHR && setNullDescriptor( Bool32 nullDescriptor_ ) && VULKAN_HPP_NOEXCEPT - { - nullDescriptor = nullDescriptor_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceRobustness2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRobustness2FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRobustness2FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRobustness2FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, robustBufferAccess2, robustImageAccess2, nullDescriptor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRobustness2FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustBufferAccess2 == rhs.robustBufferAccess2 ) && - ( robustImageAccess2 == rhs.robustImageAccess2 ) && ( nullDescriptor == rhs.nullDescriptor ); -# endif - } - - bool operator!=( PhysicalDeviceRobustness2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRobustness2FeaturesKHR; - void * pNext = {}; - Bool32 robustBufferAccess2 = {}; - Bool32 robustImageAccess2 = {}; - Bool32 nullDescriptor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRobustness2FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRobustness2FeaturesKHR; - }; - - using PhysicalDeviceRobustness2FeaturesEXT = PhysicalDeviceRobustness2FeaturesKHR; - - // wrapper struct for struct VkPhysicalDeviceRobustness2PropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceRobustness2PropertiesKHR.html - struct PhysicalDeviceRobustness2PropertiesKHR - { - using NativeType = VkPhysicalDeviceRobustness2PropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceRobustness2PropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesKHR( DeviceSize robustStorageBufferAccessSizeAlignment_ = {}, - DeviceSize robustUniformBufferAccessSizeAlignment_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , robustStorageBufferAccessSizeAlignment{ robustStorageBufferAccessSizeAlignment_ } - , robustUniformBufferAccessSizeAlignment{ robustUniformBufferAccessSizeAlignment_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceRobustness2PropertiesKHR( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceRobustness2PropertiesKHR( VkPhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceRobustness2PropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceRobustness2PropertiesKHR & operator=( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceRobustness2PropertiesKHR & operator=( VkPhysicalDeviceRobustness2PropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceRobustness2PropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRobustness2PropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRobustness2PropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceRobustness2PropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, robustStorageBufferAccessSizeAlignment, robustUniformBufferAccessSizeAlignment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceRobustness2PropertiesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustStorageBufferAccessSizeAlignment == rhs.robustStorageBufferAccessSizeAlignment ) && - ( robustUniformBufferAccessSizeAlignment == rhs.robustUniformBufferAccessSizeAlignment ); -# endif - } - - bool operator!=( PhysicalDeviceRobustness2PropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceRobustness2PropertiesKHR; - void * pNext = {}; - DeviceSize robustStorageBufferAccessSizeAlignment = {}; - DeviceSize robustUniformBufferAccessSizeAlignment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceRobustness2PropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceRobustness2PropertiesKHR; - }; - - using PhysicalDeviceRobustness2PropertiesEXT = PhysicalDeviceRobustness2PropertiesKHR; - - // wrapper struct for struct VkPhysicalDeviceSampleLocationsPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSampleLocationsPropertiesEXT.html - struct PhysicalDeviceSampleLocationsPropertiesEXT - { - using NativeType = VkPhysicalDeviceSampleLocationsPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSampleLocationsPropertiesEXT( SampleCountFlags sampleLocationSampleCounts_ = {}, - Extent2D maxSampleLocationGridSize_ = {}, - std::array const & sampleLocationCoordinateRange_ = {}, - uint32_t sampleLocationSubPixelBits_ = {}, - Bool32 variableSampleLocations_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , sampleLocationSampleCounts{ sampleLocationSampleCounts_ } - , maxSampleLocationGridSize{ maxSampleLocationGridSize_ } - , sampleLocationCoordinateRange{ sampleLocationCoordinateRange_ } - , sampleLocationSubPixelBits{ sampleLocationSubPixelBits_ } - , variableSampleLocations{ variableSampleLocations_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSampleLocationsPropertiesEXT( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSampleLocationsPropertiesEXT( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSampleLocationsPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSampleLocationsPropertiesEXT & operator=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSampleLocationsPropertiesEXT & operator=( VkPhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceSampleLocationsPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSampleLocationsPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSampleLocationsPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSampleLocationsPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - uint32_t const &, - Bool32 const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - sampleLocationSampleCounts, - maxSampleLocationGridSize, - sampleLocationCoordinateRange, - sampleLocationSubPixelBits, - variableSampleLocations ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSampleLocationsPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleLocationSampleCounts == rhs.sampleLocationSampleCounts ) && - ( maxSampleLocationGridSize == rhs.maxSampleLocationGridSize ) && ( sampleLocationCoordinateRange == rhs.sampleLocationCoordinateRange ) && - ( sampleLocationSubPixelBits == rhs.sampleLocationSubPixelBits ) && ( variableSampleLocations == rhs.variableSampleLocations ); -# endif - } - - bool operator!=( PhysicalDeviceSampleLocationsPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT; - void * pNext = {}; - SampleCountFlags sampleLocationSampleCounts = {}; - Extent2D maxSampleLocationGridSize = {}; - ArrayWrapper1D sampleLocationCoordinateRange = {}; - uint32_t sampleLocationSubPixelBits = {}; - Bool32 variableSampleLocations = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSampleLocationsPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSampleLocationsPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceSamplerFilterMinmaxProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSamplerFilterMinmaxProperties.html - struct PhysicalDeviceSamplerFilterMinmaxProperties - { - using NativeType = VkPhysicalDeviceSamplerFilterMinmaxProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerFilterMinmaxProperties( Bool32 filterMinmaxSingleComponentFormats_ = {}, - Bool32 filterMinmaxImageComponentMapping_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , filterMinmaxSingleComponentFormats{ filterMinmaxSingleComponentFormats_ } - , filterMinmaxImageComponentMapping{ filterMinmaxImageComponentMapping_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerFilterMinmaxProperties( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSamplerFilterMinmaxProperties( VkPhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSamplerFilterMinmaxProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSamplerFilterMinmaxProperties & operator=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSamplerFilterMinmaxProperties & operator=( VkPhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceSamplerFilterMinmaxProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSamplerFilterMinmaxProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSamplerFilterMinmaxProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSamplerFilterMinmaxProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, filterMinmaxSingleComponentFormats, filterMinmaxImageComponentMapping ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSamplerFilterMinmaxProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) && - ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ); -# endif - } - - bool operator!=( PhysicalDeviceSamplerFilterMinmaxProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties; - void * pNext = {}; - Bool32 filterMinmaxSingleComponentFormats = {}; - Bool32 filterMinmaxImageComponentMapping = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSamplerFilterMinmaxProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSamplerFilterMinmaxProperties; - }; - - using PhysicalDeviceSamplerFilterMinmaxPropertiesEXT = PhysicalDeviceSamplerFilterMinmaxProperties; - - // wrapper struct for struct VkPhysicalDeviceSamplerYcbcrConversionFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSamplerYcbcrConversionFeatures.html - struct PhysicalDeviceSamplerYcbcrConversionFeatures - { - using NativeType = VkPhysicalDeviceSamplerYcbcrConversionFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( Bool32 samplerYcbcrConversion_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , samplerYcbcrConversion{ samplerYcbcrConversion_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSamplerYcbcrConversionFeatures( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSamplerYcbcrConversionFeatures( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSamplerYcbcrConversionFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSamplerYcbcrConversionFeatures & operator=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSamplerYcbcrConversionFeatures & operator=( VkPhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSamplerYcbcrConversionFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSamplerYcbcrConversionFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSamplerYcbcrConversionFeatures & setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ ) & VULKAN_HPP_NOEXCEPT - { - samplerYcbcrConversion = samplerYcbcrConversion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSamplerYcbcrConversionFeatures && setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ ) && VULKAN_HPP_NOEXCEPT - { - samplerYcbcrConversion = samplerYcbcrConversion_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSamplerYcbcrConversionFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSamplerYcbcrConversionFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSamplerYcbcrConversionFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, samplerYcbcrConversion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSamplerYcbcrConversionFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ); -# endif - } - - bool operator!=( PhysicalDeviceSamplerYcbcrConversionFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures; - void * pNext = {}; - Bool32 samplerYcbcrConversion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSamplerYcbcrConversionFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSamplerYcbcrConversionFeatures; - }; - - using PhysicalDeviceSamplerYcbcrConversionFeaturesKHR = PhysicalDeviceSamplerYcbcrConversionFeatures; - - // wrapper struct for struct VkPhysicalDeviceScalarBlockLayoutFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceScalarBlockLayoutFeatures.html - struct PhysicalDeviceScalarBlockLayoutFeatures - { - using NativeType = VkPhysicalDeviceScalarBlockLayoutFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceScalarBlockLayoutFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeatures( Bool32 scalarBlockLayout_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , scalarBlockLayout{ scalarBlockLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceScalarBlockLayoutFeatures( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceScalarBlockLayoutFeatures( VkPhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceScalarBlockLayoutFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceScalarBlockLayoutFeatures & operator=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceScalarBlockLayoutFeatures & operator=( VkPhysicalDeviceScalarBlockLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceScalarBlockLayoutFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceScalarBlockLayoutFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceScalarBlockLayoutFeatures & setScalarBlockLayout( Bool32 scalarBlockLayout_ ) & VULKAN_HPP_NOEXCEPT - { - scalarBlockLayout = scalarBlockLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceScalarBlockLayoutFeatures && setScalarBlockLayout( Bool32 scalarBlockLayout_ ) && VULKAN_HPP_NOEXCEPT - { - scalarBlockLayout = scalarBlockLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceScalarBlockLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceScalarBlockLayoutFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceScalarBlockLayoutFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceScalarBlockLayoutFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, scalarBlockLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceScalarBlockLayoutFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalarBlockLayout == rhs.scalarBlockLayout ); -# endif - } - - bool operator!=( PhysicalDeviceScalarBlockLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceScalarBlockLayoutFeatures; - void * pNext = {}; - Bool32 scalarBlockLayout = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceScalarBlockLayoutFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceScalarBlockLayoutFeatures; - }; - - using PhysicalDeviceScalarBlockLayoutFeaturesEXT = PhysicalDeviceScalarBlockLayoutFeatures; - - // wrapper struct for struct VkPhysicalDeviceSchedulingControlsFeaturesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsFeaturesARM.html - struct PhysicalDeviceSchedulingControlsFeaturesARM - { - using NativeType = VkPhysicalDeviceSchedulingControlsFeaturesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSchedulingControlsFeaturesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSchedulingControlsFeaturesARM( Bool32 schedulingControls_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , schedulingControls{ schedulingControls_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSchedulingControlsFeaturesARM( PhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSchedulingControlsFeaturesARM( VkPhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSchedulingControlsFeaturesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSchedulingControlsFeaturesARM & operator=( PhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSchedulingControlsFeaturesARM & operator=( VkPhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSchedulingControlsFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSchedulingControlsFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSchedulingControlsFeaturesARM & setSchedulingControls( Bool32 schedulingControls_ ) & VULKAN_HPP_NOEXCEPT - { - schedulingControls = schedulingControls_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSchedulingControlsFeaturesARM && setSchedulingControls( Bool32 schedulingControls_ ) && VULKAN_HPP_NOEXCEPT - { - schedulingControls = schedulingControls_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceSchedulingControlsFeaturesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSchedulingControlsFeaturesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSchedulingControlsFeaturesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSchedulingControlsFeaturesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, schedulingControls ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSchedulingControlsFeaturesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( schedulingControls == rhs.schedulingControls ); -# endif - } - - bool operator!=( PhysicalDeviceSchedulingControlsFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSchedulingControlsFeaturesARM; - void * pNext = {}; - Bool32 schedulingControls = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSchedulingControlsFeaturesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSchedulingControlsFeaturesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceSchedulingControlsPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSchedulingControlsPropertiesARM.html - struct PhysicalDeviceSchedulingControlsPropertiesARM - { - using NativeType = VkPhysicalDeviceSchedulingControlsPropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSchedulingControlsPropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSchedulingControlsPropertiesARM( PhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , schedulingControlsFlags{ schedulingControlsFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceSchedulingControlsPropertiesARM( PhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSchedulingControlsPropertiesARM( VkPhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSchedulingControlsPropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSchedulingControlsPropertiesARM & operator=( PhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSchedulingControlsPropertiesARM & operator=( VkPhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceSchedulingControlsPropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSchedulingControlsPropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSchedulingControlsPropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSchedulingControlsPropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, schedulingControlsFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSchedulingControlsPropertiesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( schedulingControlsFlags == rhs.schedulingControlsFlags ); -# endif - } - - bool operator!=( PhysicalDeviceSchedulingControlsPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSchedulingControlsPropertiesARM; - void * pNext = {}; - PhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSchedulingControlsPropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSchedulingControlsPropertiesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.html - struct PhysicalDeviceSeparateDepthStencilLayoutsFeatures - { - using NativeType = VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSeparateDepthStencilLayoutsFeatures( Bool32 separateDepthStencilLayouts_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , separateDepthStencilLayouts{ separateDepthStencilLayouts_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceSeparateDepthStencilLayoutsFeatures( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSeparateDepthStencilLayoutsFeatures( VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSeparateDepthStencilLayoutsFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSeparateDepthStencilLayoutsFeatures & - operator=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSeparateDepthStencilLayoutsFeatures & operator=( VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSeparateDepthStencilLayoutsFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSeparateDepthStencilLayoutsFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSeparateDepthStencilLayoutsFeatures & setSeparateDepthStencilLayouts( Bool32 separateDepthStencilLayouts_ ) & - VULKAN_HPP_NOEXCEPT - { - separateDepthStencilLayouts = separateDepthStencilLayouts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSeparateDepthStencilLayoutsFeatures && setSeparateDepthStencilLayouts( Bool32 separateDepthStencilLayouts_ ) && - VULKAN_HPP_NOEXCEPT - { - separateDepthStencilLayouts = separateDepthStencilLayouts_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, separateDepthStencilLayouts ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts ); -# endif - } - - bool operator!=( PhysicalDeviceSeparateDepthStencilLayoutsFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures; - void * pNext = {}; - Bool32 separateDepthStencilLayouts = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; - }; - - using PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = PhysicalDeviceSeparateDepthStencilLayoutsFeatures; - - // wrapper struct for struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShader64BitIndexingFeaturesEXT.html - struct PhysicalDeviceShader64BitIndexingFeaturesEXT - { - using NativeType = VkPhysicalDeviceShader64BitIndexingFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShader64BitIndexingFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShader64BitIndexingFeaturesEXT( Bool32 shader64BitIndexing_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shader64BitIndexing{ shader64BitIndexing_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShader64BitIndexingFeaturesEXT( PhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShader64BitIndexingFeaturesEXT( VkPhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShader64BitIndexingFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShader64BitIndexingFeaturesEXT & operator=( PhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShader64BitIndexingFeaturesEXT & operator=( VkPhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShader64BitIndexingFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShader64BitIndexingFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShader64BitIndexingFeaturesEXT & setShader64BitIndexing( Bool32 shader64BitIndexing_ ) & VULKAN_HPP_NOEXCEPT - { - shader64BitIndexing = shader64BitIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShader64BitIndexingFeaturesEXT && setShader64BitIndexing( Bool32 shader64BitIndexing_ ) && VULKAN_HPP_NOEXCEPT - { - shader64BitIndexing = shader64BitIndexing_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShader64BitIndexingFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShader64BitIndexingFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShader64BitIndexingFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShader64BitIndexingFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shader64BitIndexing ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShader64BitIndexingFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shader64BitIndexing == rhs.shader64BitIndexing ); -# endif - } - - bool operator!=( PhysicalDeviceShader64BitIndexingFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShader64BitIndexingFeaturesEXT; - void * pNext = {}; - Bool32 shader64BitIndexing = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShader64BitIndexingFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShader64BitIndexingFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.html - struct PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV - { - using NativeType = VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( Bool32 shaderFloat16VectorAtomics_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderFloat16VectorAtomics{ shaderFloat16VectorAtomics_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & - operator=( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & operator=( VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV & setShaderFloat16VectorAtomics( Bool32 shaderFloat16VectorAtomics_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderFloat16VectorAtomics = shaderFloat16VectorAtomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV && setShaderFloat16VectorAtomics( Bool32 shaderFloat16VectorAtomics_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderFloat16VectorAtomics = shaderFloat16VectorAtomics_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderFloat16VectorAtomics ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16VectorAtomics == rhs.shaderFloat16VectorAtomics ); -# endif - } - - bool operator!=( PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; - void * pNext = {}; - Bool32 shaderFloat16VectorAtomics = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.html - struct PhysicalDeviceShaderAtomicFloat2FeaturesEXT - { - using NativeType = VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloat2FeaturesEXT( Bool32 shaderBufferFloat16Atomics_ = {}, - Bool32 shaderBufferFloat16AtomicAdd_ = {}, - Bool32 shaderBufferFloat16AtomicMinMax_ = {}, - Bool32 shaderBufferFloat32AtomicMinMax_ = {}, - Bool32 shaderBufferFloat64AtomicMinMax_ = {}, - Bool32 shaderSharedFloat16Atomics_ = {}, - Bool32 shaderSharedFloat16AtomicAdd_ = {}, - Bool32 shaderSharedFloat16AtomicMinMax_ = {}, - Bool32 shaderSharedFloat32AtomicMinMax_ = {}, - Bool32 shaderSharedFloat64AtomicMinMax_ = {}, - Bool32 shaderImageFloat32AtomicMinMax_ = {}, - Bool32 sparseImageFloat32AtomicMinMax_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderBufferFloat16Atomics{ shaderBufferFloat16Atomics_ } - , shaderBufferFloat16AtomicAdd{ shaderBufferFloat16AtomicAdd_ } - , shaderBufferFloat16AtomicMinMax{ shaderBufferFloat16AtomicMinMax_ } - , shaderBufferFloat32AtomicMinMax{ shaderBufferFloat32AtomicMinMax_ } - , shaderBufferFloat64AtomicMinMax{ shaderBufferFloat64AtomicMinMax_ } - , shaderSharedFloat16Atomics{ shaderSharedFloat16Atomics_ } - , shaderSharedFloat16AtomicAdd{ shaderSharedFloat16AtomicAdd_ } - , shaderSharedFloat16AtomicMinMax{ shaderSharedFloat16AtomicMinMax_ } - , shaderSharedFloat32AtomicMinMax{ shaderSharedFloat32AtomicMinMax_ } - , shaderSharedFloat64AtomicMinMax{ shaderSharedFloat64AtomicMinMax_ } - , shaderImageFloat32AtomicMinMax{ shaderImageFloat32AtomicMinMax_ } - , sparseImageFloat32AtomicMinMax{ sparseImageFloat32AtomicMinMax_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloat2FeaturesEXT( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderAtomicFloat2FeaturesEXT( VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderAtomicFloat2FeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderAtomicFloat2FeaturesEXT & operator=( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderAtomicFloat2FeaturesEXT & operator=( VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderBufferFloat16Atomics( Bool32 shaderBufferFloat16Atomics_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat16Atomics = shaderBufferFloat16Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderBufferFloat16Atomics( Bool32 shaderBufferFloat16Atomics_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat16Atomics = shaderBufferFloat16Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderBufferFloat16AtomicAdd( Bool32 shaderBufferFloat16AtomicAdd_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat16AtomicAdd = shaderBufferFloat16AtomicAdd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderBufferFloat16AtomicAdd( Bool32 shaderBufferFloat16AtomicAdd_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat16AtomicAdd = shaderBufferFloat16AtomicAdd_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderBufferFloat16AtomicMinMax( Bool32 shaderBufferFloat16AtomicMinMax_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat16AtomicMinMax = shaderBufferFloat16AtomicMinMax_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderBufferFloat16AtomicMinMax( Bool32 shaderBufferFloat16AtomicMinMax_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat16AtomicMinMax = shaderBufferFloat16AtomicMinMax_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderBufferFloat32AtomicMinMax( Bool32 shaderBufferFloat32AtomicMinMax_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat32AtomicMinMax = shaderBufferFloat32AtomicMinMax_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderBufferFloat32AtomicMinMax( Bool32 shaderBufferFloat32AtomicMinMax_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat32AtomicMinMax = shaderBufferFloat32AtomicMinMax_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderBufferFloat64AtomicMinMax( Bool32 shaderBufferFloat64AtomicMinMax_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat64AtomicMinMax = shaderBufferFloat64AtomicMinMax_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderBufferFloat64AtomicMinMax( Bool32 shaderBufferFloat64AtomicMinMax_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat64AtomicMinMax = shaderBufferFloat64AtomicMinMax_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderSharedFloat16Atomics( Bool32 shaderSharedFloat16Atomics_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat16Atomics = shaderSharedFloat16Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderSharedFloat16Atomics( Bool32 shaderSharedFloat16Atomics_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat16Atomics = shaderSharedFloat16Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderSharedFloat16AtomicAdd( Bool32 shaderSharedFloat16AtomicAdd_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat16AtomicAdd = shaderSharedFloat16AtomicAdd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderSharedFloat16AtomicAdd( Bool32 shaderSharedFloat16AtomicAdd_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat16AtomicAdd = shaderSharedFloat16AtomicAdd_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderSharedFloat16AtomicMinMax( Bool32 shaderSharedFloat16AtomicMinMax_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat16AtomicMinMax = shaderSharedFloat16AtomicMinMax_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderSharedFloat16AtomicMinMax( Bool32 shaderSharedFloat16AtomicMinMax_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat16AtomicMinMax = shaderSharedFloat16AtomicMinMax_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderSharedFloat32AtomicMinMax( Bool32 shaderSharedFloat32AtomicMinMax_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat32AtomicMinMax = shaderSharedFloat32AtomicMinMax_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderSharedFloat32AtomicMinMax( Bool32 shaderSharedFloat32AtomicMinMax_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat32AtomicMinMax = shaderSharedFloat32AtomicMinMax_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderSharedFloat64AtomicMinMax( Bool32 shaderSharedFloat64AtomicMinMax_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat64AtomicMinMax = shaderSharedFloat64AtomicMinMax_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderSharedFloat64AtomicMinMax( Bool32 shaderSharedFloat64AtomicMinMax_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat64AtomicMinMax = shaderSharedFloat64AtomicMinMax_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setShaderImageFloat32AtomicMinMax( Bool32 shaderImageFloat32AtomicMinMax_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderImageFloat32AtomicMinMax = shaderImageFloat32AtomicMinMax_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setShaderImageFloat32AtomicMinMax( Bool32 shaderImageFloat32AtomicMinMax_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderImageFloat32AtomicMinMax = shaderImageFloat32AtomicMinMax_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT & setSparseImageFloat32AtomicMinMax( Bool32 sparseImageFloat32AtomicMinMax_ ) & - VULKAN_HPP_NOEXCEPT - { - sparseImageFloat32AtomicMinMax = sparseImageFloat32AtomicMinMax_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloat2FeaturesEXT && setSparseImageFloat32AtomicMinMax( Bool32 sparseImageFloat32AtomicMinMax_ ) && - VULKAN_HPP_NOEXCEPT - { - sparseImageFloat32AtomicMinMax = sparseImageFloat32AtomicMinMax_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - shaderBufferFloat16Atomics, - shaderBufferFloat16AtomicAdd, - shaderBufferFloat16AtomicMinMax, - shaderBufferFloat32AtomicMinMax, - shaderBufferFloat64AtomicMinMax, - shaderSharedFloat16Atomics, - shaderSharedFloat16AtomicAdd, - shaderSharedFloat16AtomicMinMax, - shaderSharedFloat32AtomicMinMax, - shaderSharedFloat64AtomicMinMax, - shaderImageFloat32AtomicMinMax, - sparseImageFloat32AtomicMinMax ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBufferFloat16Atomics == rhs.shaderBufferFloat16Atomics ) && - ( shaderBufferFloat16AtomicAdd == rhs.shaderBufferFloat16AtomicAdd ) && - ( shaderBufferFloat16AtomicMinMax == rhs.shaderBufferFloat16AtomicMinMax ) && - ( shaderBufferFloat32AtomicMinMax == rhs.shaderBufferFloat32AtomicMinMax ) && - ( shaderBufferFloat64AtomicMinMax == rhs.shaderBufferFloat64AtomicMinMax ) && ( shaderSharedFloat16Atomics == rhs.shaderSharedFloat16Atomics ) && - ( shaderSharedFloat16AtomicAdd == rhs.shaderSharedFloat16AtomicAdd ) && - ( shaderSharedFloat16AtomicMinMax == rhs.shaderSharedFloat16AtomicMinMax ) && - ( shaderSharedFloat32AtomicMinMax == rhs.shaderSharedFloat32AtomicMinMax ) && - ( shaderSharedFloat64AtomicMinMax == rhs.shaderSharedFloat64AtomicMinMax ) && - ( shaderImageFloat32AtomicMinMax == rhs.shaderImageFloat32AtomicMinMax ) && - ( sparseImageFloat32AtomicMinMax == rhs.sparseImageFloat32AtomicMinMax ); -# endif - } - - bool operator!=( PhysicalDeviceShaderAtomicFloat2FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT; - void * pNext = {}; - Bool32 shaderBufferFloat16Atomics = {}; - Bool32 shaderBufferFloat16AtomicAdd = {}; - Bool32 shaderBufferFloat16AtomicMinMax = {}; - Bool32 shaderBufferFloat32AtomicMinMax = {}; - Bool32 shaderBufferFloat64AtomicMinMax = {}; - Bool32 shaderSharedFloat16Atomics = {}; - Bool32 shaderSharedFloat16AtomicAdd = {}; - Bool32 shaderSharedFloat16AtomicMinMax = {}; - Bool32 shaderSharedFloat32AtomicMinMax = {}; - Bool32 shaderSharedFloat64AtomicMinMax = {}; - Bool32 shaderImageFloat32AtomicMinMax = {}; - Bool32 sparseImageFloat32AtomicMinMax = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderAtomicFloat2FeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderAtomicFloat2FeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.html - struct PhysicalDeviceShaderAtomicFloatFeaturesEXT - { - using NativeType = VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloatFeaturesEXT( Bool32 shaderBufferFloat32Atomics_ = {}, - Bool32 shaderBufferFloat32AtomicAdd_ = {}, - Bool32 shaderBufferFloat64Atomics_ = {}, - Bool32 shaderBufferFloat64AtomicAdd_ = {}, - Bool32 shaderSharedFloat32Atomics_ = {}, - Bool32 shaderSharedFloat32AtomicAdd_ = {}, - Bool32 shaderSharedFloat64Atomics_ = {}, - Bool32 shaderSharedFloat64AtomicAdd_ = {}, - Bool32 shaderImageFloat32Atomics_ = {}, - Bool32 shaderImageFloat32AtomicAdd_ = {}, - Bool32 sparseImageFloat32Atomics_ = {}, - Bool32 sparseImageFloat32AtomicAdd_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderBufferFloat32Atomics{ shaderBufferFloat32Atomics_ } - , shaderBufferFloat32AtomicAdd{ shaderBufferFloat32AtomicAdd_ } - , shaderBufferFloat64Atomics{ shaderBufferFloat64Atomics_ } - , shaderBufferFloat64AtomicAdd{ shaderBufferFloat64AtomicAdd_ } - , shaderSharedFloat32Atomics{ shaderSharedFloat32Atomics_ } - , shaderSharedFloat32AtomicAdd{ shaderSharedFloat32AtomicAdd_ } - , shaderSharedFloat64Atomics{ shaderSharedFloat64Atomics_ } - , shaderSharedFloat64AtomicAdd{ shaderSharedFloat64AtomicAdd_ } - , shaderImageFloat32Atomics{ shaderImageFloat32Atomics_ } - , shaderImageFloat32AtomicAdd{ shaderImageFloat32AtomicAdd_ } - , sparseImageFloat32Atomics{ sparseImageFloat32Atomics_ } - , sparseImageFloat32AtomicAdd{ sparseImageFloat32AtomicAdd_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicFloatFeaturesEXT( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderAtomicFloatFeaturesEXT( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderAtomicFloatFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderAtomicFloatFeaturesEXT & operator=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderAtomicFloatFeaturesEXT & operator=( VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderBufferFloat32Atomics( Bool32 shaderBufferFloat32Atomics_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat32Atomics = shaderBufferFloat32Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderBufferFloat32Atomics( Bool32 shaderBufferFloat32Atomics_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat32Atomics = shaderBufferFloat32Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderBufferFloat32AtomicAdd( Bool32 shaderBufferFloat32AtomicAdd_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat32AtomicAdd = shaderBufferFloat32AtomicAdd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderBufferFloat32AtomicAdd( Bool32 shaderBufferFloat32AtomicAdd_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat32AtomicAdd = shaderBufferFloat32AtomicAdd_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderBufferFloat64Atomics( Bool32 shaderBufferFloat64Atomics_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat64Atomics = shaderBufferFloat64Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderBufferFloat64Atomics( Bool32 shaderBufferFloat64Atomics_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat64Atomics = shaderBufferFloat64Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderBufferFloat64AtomicAdd( Bool32 shaderBufferFloat64AtomicAdd_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat64AtomicAdd = shaderBufferFloat64AtomicAdd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderBufferFloat64AtomicAdd( Bool32 shaderBufferFloat64AtomicAdd_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderBufferFloat64AtomicAdd = shaderBufferFloat64AtomicAdd_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderSharedFloat32Atomics( Bool32 shaderSharedFloat32Atomics_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat32Atomics = shaderSharedFloat32Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderSharedFloat32Atomics( Bool32 shaderSharedFloat32Atomics_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat32Atomics = shaderSharedFloat32Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderSharedFloat32AtomicAdd( Bool32 shaderSharedFloat32AtomicAdd_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat32AtomicAdd = shaderSharedFloat32AtomicAdd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderSharedFloat32AtomicAdd( Bool32 shaderSharedFloat32AtomicAdd_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat32AtomicAdd = shaderSharedFloat32AtomicAdd_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderSharedFloat64Atomics( Bool32 shaderSharedFloat64Atomics_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat64Atomics = shaderSharedFloat64Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderSharedFloat64Atomics( Bool32 shaderSharedFloat64Atomics_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat64Atomics = shaderSharedFloat64Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderSharedFloat64AtomicAdd( Bool32 shaderSharedFloat64AtomicAdd_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat64AtomicAdd = shaderSharedFloat64AtomicAdd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderSharedFloat64AtomicAdd( Bool32 shaderSharedFloat64AtomicAdd_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSharedFloat64AtomicAdd = shaderSharedFloat64AtomicAdd_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderImageFloat32Atomics( Bool32 shaderImageFloat32Atomics_ ) & VULKAN_HPP_NOEXCEPT - { - shaderImageFloat32Atomics = shaderImageFloat32Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderImageFloat32Atomics( Bool32 shaderImageFloat32Atomics_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderImageFloat32Atomics = shaderImageFloat32Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setShaderImageFloat32AtomicAdd( Bool32 shaderImageFloat32AtomicAdd_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderImageFloat32AtomicAdd = shaderImageFloat32AtomicAdd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setShaderImageFloat32AtomicAdd( Bool32 shaderImageFloat32AtomicAdd_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderImageFloat32AtomicAdd = shaderImageFloat32AtomicAdd_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setSparseImageFloat32Atomics( Bool32 sparseImageFloat32Atomics_ ) & VULKAN_HPP_NOEXCEPT - { - sparseImageFloat32Atomics = sparseImageFloat32Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setSparseImageFloat32Atomics( Bool32 sparseImageFloat32Atomics_ ) && - VULKAN_HPP_NOEXCEPT - { - sparseImageFloat32Atomics = sparseImageFloat32Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT & setSparseImageFloat32AtomicAdd( Bool32 sparseImageFloat32AtomicAdd_ ) & - VULKAN_HPP_NOEXCEPT - { - sparseImageFloat32AtomicAdd = sparseImageFloat32AtomicAdd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicFloatFeaturesEXT && setSparseImageFloat32AtomicAdd( Bool32 sparseImageFloat32AtomicAdd_ ) && - VULKAN_HPP_NOEXCEPT - { - sparseImageFloat32AtomicAdd = sparseImageFloat32AtomicAdd_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - shaderBufferFloat32Atomics, - shaderBufferFloat32AtomicAdd, - shaderBufferFloat64Atomics, - shaderBufferFloat64AtomicAdd, - shaderSharedFloat32Atomics, - shaderSharedFloat32AtomicAdd, - shaderSharedFloat64Atomics, - shaderSharedFloat64AtomicAdd, - shaderImageFloat32Atomics, - shaderImageFloat32AtomicAdd, - sparseImageFloat32Atomics, - sparseImageFloat32AtomicAdd ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBufferFloat32Atomics == rhs.shaderBufferFloat32Atomics ) && - ( shaderBufferFloat32AtomicAdd == rhs.shaderBufferFloat32AtomicAdd ) && ( shaderBufferFloat64Atomics == rhs.shaderBufferFloat64Atomics ) && - ( shaderBufferFloat64AtomicAdd == rhs.shaderBufferFloat64AtomicAdd ) && ( shaderSharedFloat32Atomics == rhs.shaderSharedFloat32Atomics ) && - ( shaderSharedFloat32AtomicAdd == rhs.shaderSharedFloat32AtomicAdd ) && ( shaderSharedFloat64Atomics == rhs.shaderSharedFloat64Atomics ) && - ( shaderSharedFloat64AtomicAdd == rhs.shaderSharedFloat64AtomicAdd ) && ( shaderImageFloat32Atomics == rhs.shaderImageFloat32Atomics ) && - ( shaderImageFloat32AtomicAdd == rhs.shaderImageFloat32AtomicAdd ) && ( sparseImageFloat32Atomics == rhs.sparseImageFloat32Atomics ) && - ( sparseImageFloat32AtomicAdd == rhs.sparseImageFloat32AtomicAdd ); -# endif - } - - bool operator!=( PhysicalDeviceShaderAtomicFloatFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT; - void * pNext = {}; - Bool32 shaderBufferFloat32Atomics = {}; - Bool32 shaderBufferFloat32AtomicAdd = {}; - Bool32 shaderBufferFloat64Atomics = {}; - Bool32 shaderBufferFloat64AtomicAdd = {}; - Bool32 shaderSharedFloat32Atomics = {}; - Bool32 shaderSharedFloat32AtomicAdd = {}; - Bool32 shaderSharedFloat64Atomics = {}; - Bool32 shaderSharedFloat64AtomicAdd = {}; - Bool32 shaderImageFloat32Atomics = {}; - Bool32 shaderImageFloat32AtomicAdd = {}; - Bool32 sparseImageFloat32Atomics = {}; - Bool32 sparseImageFloat32AtomicAdd = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderAtomicFloatFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderAtomicFloatFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderAtomicInt64Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderAtomicInt64Features.html - struct PhysicalDeviceShaderAtomicInt64Features - { - using NativeType = VkPhysicalDeviceShaderAtomicInt64Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderAtomicInt64Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64Features( Bool32 shaderBufferInt64Atomics_ = {}, - Bool32 shaderSharedInt64Atomics_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderBufferInt64Atomics{ shaderBufferInt64Atomics_ } - , shaderSharedInt64Atomics{ shaderSharedInt64Atomics_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderAtomicInt64Features( PhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderAtomicInt64Features( VkPhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderAtomicInt64Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderAtomicInt64Features & operator=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderAtomicInt64Features & operator=( VkPhysicalDeviceShaderAtomicInt64Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features & setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ ) & VULKAN_HPP_NOEXCEPT - { - shaderBufferInt64Atomics = shaderBufferInt64Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features && setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ ) && VULKAN_HPP_NOEXCEPT - { - shaderBufferInt64Atomics = shaderBufferInt64Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features & setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ ) & VULKAN_HPP_NOEXCEPT - { - shaderSharedInt64Atomics = shaderSharedInt64Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderAtomicInt64Features && setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ ) && VULKAN_HPP_NOEXCEPT - { - shaderSharedInt64Atomics = shaderSharedInt64Atomics_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderAtomicInt64Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicInt64Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicInt64Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderAtomicInt64Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderBufferInt64Atomics, shaderSharedInt64Atomics ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderAtomicInt64Features const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) && - ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ); -# endif - } - - bool operator!=( PhysicalDeviceShaderAtomicInt64Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderAtomicInt64Features; - void * pNext = {}; - Bool32 shaderBufferInt64Atomics = {}; - Bool32 shaderSharedInt64Atomics = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderAtomicInt64Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderAtomicInt64Features; - }; - - using PhysicalDeviceShaderAtomicInt64FeaturesKHR = PhysicalDeviceShaderAtomicInt64Features; - - // wrapper struct for struct VkPhysicalDeviceShaderBfloat16FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderBfloat16FeaturesKHR.html - struct PhysicalDeviceShaderBfloat16FeaturesKHR - { - using NativeType = VkPhysicalDeviceShaderBfloat16FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderBfloat16FeaturesKHR( Bool32 shaderBFloat16Type_ = {}, - Bool32 shaderBFloat16DotProduct_ = {}, - Bool32 shaderBFloat16CooperativeMatrix_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderBFloat16Type{ shaderBFloat16Type_ } - , shaderBFloat16DotProduct{ shaderBFloat16DotProduct_ } - , shaderBFloat16CooperativeMatrix{ shaderBFloat16CooperativeMatrix_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderBfloat16FeaturesKHR( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderBfloat16FeaturesKHR( VkPhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderBfloat16FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderBfloat16FeaturesKHR & operator=( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderBfloat16FeaturesKHR & operator=( VkPhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR & setShaderBFloat16Type( Bool32 shaderBFloat16Type_ ) & VULKAN_HPP_NOEXCEPT - { - shaderBFloat16Type = shaderBFloat16Type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR && setShaderBFloat16Type( Bool32 shaderBFloat16Type_ ) && VULKAN_HPP_NOEXCEPT - { - shaderBFloat16Type = shaderBFloat16Type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR & setShaderBFloat16DotProduct( Bool32 shaderBFloat16DotProduct_ ) & VULKAN_HPP_NOEXCEPT - { - shaderBFloat16DotProduct = shaderBFloat16DotProduct_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR && setShaderBFloat16DotProduct( Bool32 shaderBFloat16DotProduct_ ) && VULKAN_HPP_NOEXCEPT - { - shaderBFloat16DotProduct = shaderBFloat16DotProduct_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR & setShaderBFloat16CooperativeMatrix( Bool32 shaderBFloat16CooperativeMatrix_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderBFloat16CooperativeMatrix = shaderBFloat16CooperativeMatrix_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderBfloat16FeaturesKHR && setShaderBFloat16CooperativeMatrix( Bool32 shaderBFloat16CooperativeMatrix_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderBFloat16CooperativeMatrix = shaderBFloat16CooperativeMatrix_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderBfloat16FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderBfloat16FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderBfloat16FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderBfloat16FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderBFloat16Type, shaderBFloat16DotProduct, shaderBFloat16CooperativeMatrix ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderBfloat16FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBFloat16Type == rhs.shaderBFloat16Type ) && - ( shaderBFloat16DotProduct == rhs.shaderBFloat16DotProduct ) && ( shaderBFloat16CooperativeMatrix == rhs.shaderBFloat16CooperativeMatrix ); -# endif - } - - bool operator!=( PhysicalDeviceShaderBfloat16FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR; - void * pNext = {}; - Bool32 shaderBFloat16Type = {}; - Bool32 shaderBFloat16DotProduct = {}; - Bool32 shaderBFloat16CooperativeMatrix = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderBfloat16FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderBfloat16FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderClockFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderClockFeaturesKHR.html - struct PhysicalDeviceShaderClockFeaturesKHR - { - using NativeType = VkPhysicalDeviceShaderClockFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderClockFeaturesKHR( Bool32 shaderSubgroupClock_ = {}, Bool32 shaderDeviceClock_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderSubgroupClock{ shaderSubgroupClock_ } - , shaderDeviceClock{ shaderDeviceClock_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderClockFeaturesKHR( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderClockFeaturesKHR( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderClockFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderClockFeaturesKHR & operator=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderClockFeaturesKHR & operator=( VkPhysicalDeviceShaderClockFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR & setShaderSubgroupClock( Bool32 shaderSubgroupClock_ ) & VULKAN_HPP_NOEXCEPT - { - shaderSubgroupClock = shaderSubgroupClock_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR && setShaderSubgroupClock( Bool32 shaderSubgroupClock_ ) && VULKAN_HPP_NOEXCEPT - { - shaderSubgroupClock = shaderSubgroupClock_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR & setShaderDeviceClock( Bool32 shaderDeviceClock_ ) & VULKAN_HPP_NOEXCEPT - { - shaderDeviceClock = shaderDeviceClock_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderClockFeaturesKHR && setShaderDeviceClock( Bool32 shaderDeviceClock_ ) && VULKAN_HPP_NOEXCEPT - { - shaderDeviceClock = shaderDeviceClock_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderClockFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderClockFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderClockFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderClockFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderSubgroupClock, shaderDeviceClock ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderClockFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupClock == rhs.shaderSubgroupClock ) && - ( shaderDeviceClock == rhs.shaderDeviceClock ); -# endif - } - - bool operator!=( PhysicalDeviceShaderClockFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderClockFeaturesKHR; - void * pNext = {}; - Bool32 shaderSubgroupClock = {}; - Bool32 shaderDeviceClock = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderClockFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderClockFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.html - struct PhysicalDeviceShaderCoreBuiltinsFeaturesARM - { - using NativeType = VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreBuiltinsFeaturesARM( Bool32 shaderCoreBuiltins_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderCoreBuiltins{ shaderCoreBuiltins_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreBuiltinsFeaturesARM( PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderCoreBuiltinsFeaturesARM( VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderCoreBuiltinsFeaturesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderCoreBuiltinsFeaturesARM & operator=( PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderCoreBuiltinsFeaturesARM & operator=( VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderCoreBuiltinsFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderCoreBuiltinsFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderCoreBuiltinsFeaturesARM & setShaderCoreBuiltins( Bool32 shaderCoreBuiltins_ ) & VULKAN_HPP_NOEXCEPT - { - shaderCoreBuiltins = shaderCoreBuiltins_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderCoreBuiltinsFeaturesARM && setShaderCoreBuiltins( Bool32 shaderCoreBuiltins_ ) && VULKAN_HPP_NOEXCEPT - { - shaderCoreBuiltins = shaderCoreBuiltins_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderCoreBuiltins ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreBuiltins == rhs.shaderCoreBuiltins ); -# endif - } - - bool operator!=( PhysicalDeviceShaderCoreBuiltinsFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM; - void * pNext = {}; - Bool32 shaderCoreBuiltins = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderCoreBuiltinsFeaturesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderCoreBuiltinsFeaturesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM.html - struct PhysicalDeviceShaderCoreBuiltinsPropertiesARM - { - using NativeType = VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreBuiltinsPropertiesARM( uint64_t shaderCoreMask_ = {}, - uint32_t shaderCoreCount_ = {}, - uint32_t shaderWarpsPerCore_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderCoreMask{ shaderCoreMask_ } - , shaderCoreCount{ shaderCoreCount_ } - , shaderWarpsPerCore{ shaderWarpsPerCore_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderCoreBuiltinsPropertiesARM( PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderCoreBuiltinsPropertiesARM( VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderCoreBuiltinsPropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderCoreBuiltinsPropertiesARM & operator=( PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderCoreBuiltinsPropertiesARM & operator=( VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderCoreMask, shaderCoreCount, shaderWarpsPerCore ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreMask == rhs.shaderCoreMask ) && ( shaderCoreCount == rhs.shaderCoreCount ) && - ( shaderWarpsPerCore == rhs.shaderWarpsPerCore ); -# endif - } - - bool operator!=( PhysicalDeviceShaderCoreBuiltinsPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM; - void * pNext = {}; - uint64_t shaderCoreMask = {}; - uint32_t shaderCoreCount = {}; - uint32_t shaderWarpsPerCore = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderCoreBuiltinsPropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderCoreBuiltinsPropertiesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderCoreProperties2AMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCoreProperties2AMD.html - struct PhysicalDeviceShaderCoreProperties2AMD - { - using NativeType = VkPhysicalDeviceShaderCoreProperties2AMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreProperties2AMD( ShaderCorePropertiesFlagsAMD shaderCoreFeatures_ = {}, - uint32_t activeComputeUnitCount_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderCoreFeatures{ shaderCoreFeatures_ } - , activeComputeUnitCount{ activeComputeUnitCount_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCoreProperties2AMD( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderCoreProperties2AMD( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderCoreProperties2AMD( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderCoreProperties2AMD & operator=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderCoreProperties2AMD & operator=( VkPhysicalDeviceShaderCoreProperties2AMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShaderCoreProperties2AMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCoreProperties2AMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCoreProperties2AMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCoreProperties2AMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderCoreFeatures, activeComputeUnitCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderCoreProperties2AMD const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderCoreFeatures == rhs.shaderCoreFeatures ) && - ( activeComputeUnitCount == rhs.activeComputeUnitCount ); -# endif - } - - bool operator!=( PhysicalDeviceShaderCoreProperties2AMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderCoreProperties2AMD; - void * pNext = {}; - ShaderCorePropertiesFlagsAMD shaderCoreFeatures = {}; - uint32_t activeComputeUnitCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderCoreProperties2AMD; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderCoreProperties2AMD; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderCorePropertiesAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCorePropertiesAMD.html - struct PhysicalDeviceShaderCorePropertiesAMD - { - using NativeType = VkPhysicalDeviceShaderCorePropertiesAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesAMD( uint32_t shaderEngineCount_ = {}, - uint32_t shaderArraysPerEngineCount_ = {}, - uint32_t computeUnitsPerShaderArray_ = {}, - uint32_t simdPerComputeUnit_ = {}, - uint32_t wavefrontsPerSimd_ = {}, - uint32_t wavefrontSize_ = {}, - uint32_t sgprsPerSimd_ = {}, - uint32_t minSgprAllocation_ = {}, - uint32_t maxSgprAllocation_ = {}, - uint32_t sgprAllocationGranularity_ = {}, - uint32_t vgprsPerSimd_ = {}, - uint32_t minVgprAllocation_ = {}, - uint32_t maxVgprAllocation_ = {}, - uint32_t vgprAllocationGranularity_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderEngineCount{ shaderEngineCount_ } - , shaderArraysPerEngineCount{ shaderArraysPerEngineCount_ } - , computeUnitsPerShaderArray{ computeUnitsPerShaderArray_ } - , simdPerComputeUnit{ simdPerComputeUnit_ } - , wavefrontsPerSimd{ wavefrontsPerSimd_ } - , wavefrontSize{ wavefrontSize_ } - , sgprsPerSimd{ sgprsPerSimd_ } - , minSgprAllocation{ minSgprAllocation_ } - , maxSgprAllocation{ maxSgprAllocation_ } - , sgprAllocationGranularity{ sgprAllocationGranularity_ } - , vgprsPerSimd{ vgprsPerSimd_ } - , minVgprAllocation{ minVgprAllocation_ } - , maxVgprAllocation{ maxVgprAllocation_ } - , vgprAllocationGranularity{ vgprAllocationGranularity_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesAMD( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderCorePropertiesAMD( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderCorePropertiesAMD( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderCorePropertiesAMD & operator=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderCorePropertiesAMD & operator=( VkPhysicalDeviceShaderCorePropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShaderCorePropertiesAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCorePropertiesAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCorePropertiesAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCorePropertiesAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - shaderEngineCount, - shaderArraysPerEngineCount, - computeUnitsPerShaderArray, - simdPerComputeUnit, - wavefrontsPerSimd, - wavefrontSize, - sgprsPerSimd, - minSgprAllocation, - maxSgprAllocation, - sgprAllocationGranularity, - vgprsPerSimd, - minVgprAllocation, - maxVgprAllocation, - vgprAllocationGranularity ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderCorePropertiesAMD const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEngineCount == rhs.shaderEngineCount ) && - ( shaderArraysPerEngineCount == rhs.shaderArraysPerEngineCount ) && ( computeUnitsPerShaderArray == rhs.computeUnitsPerShaderArray ) && - ( simdPerComputeUnit == rhs.simdPerComputeUnit ) && ( wavefrontsPerSimd == rhs.wavefrontsPerSimd ) && ( wavefrontSize == rhs.wavefrontSize ) && - ( sgprsPerSimd == rhs.sgprsPerSimd ) && ( minSgprAllocation == rhs.minSgprAllocation ) && ( maxSgprAllocation == rhs.maxSgprAllocation ) && - ( sgprAllocationGranularity == rhs.sgprAllocationGranularity ) && ( vgprsPerSimd == rhs.vgprsPerSimd ) && - ( minVgprAllocation == rhs.minVgprAllocation ) && ( maxVgprAllocation == rhs.maxVgprAllocation ) && - ( vgprAllocationGranularity == rhs.vgprAllocationGranularity ); -# endif - } - - bool operator!=( PhysicalDeviceShaderCorePropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesAMD; - void * pNext = {}; - uint32_t shaderEngineCount = {}; - uint32_t shaderArraysPerEngineCount = {}; - uint32_t computeUnitsPerShaderArray = {}; - uint32_t simdPerComputeUnit = {}; - uint32_t wavefrontsPerSimd = {}; - uint32_t wavefrontSize = {}; - uint32_t sgprsPerSimd = {}; - uint32_t minSgprAllocation = {}; - uint32_t maxSgprAllocation = {}; - uint32_t sgprAllocationGranularity = {}; - uint32_t vgprsPerSimd = {}; - uint32_t minVgprAllocation = {}; - uint32_t maxVgprAllocation = {}; - uint32_t vgprAllocationGranularity = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderCorePropertiesAMD; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderCorePropertiesAMD; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderCorePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderCorePropertiesARM.html - struct PhysicalDeviceShaderCorePropertiesARM - { - using NativeType = VkPhysicalDeviceShaderCorePropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderCorePropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesARM( uint32_t pixelRate_ = {}, - uint32_t texelRate_ = {}, - uint32_t fmaRate_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pixelRate{ pixelRate_ } - , texelRate{ texelRate_ } - , fmaRate{ fmaRate_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderCorePropertiesARM( PhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderCorePropertiesARM( VkPhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderCorePropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderCorePropertiesARM & operator=( PhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderCorePropertiesARM & operator=( VkPhysicalDeviceShaderCorePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShaderCorePropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCorePropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCorePropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderCorePropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pixelRate, texelRate, fmaRate ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderCorePropertiesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderCorePropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pixelRate == rhs.pixelRate ) && ( texelRate == rhs.texelRate ) && ( fmaRate == rhs.fmaRate ); -# endif - } - - bool operator!=( PhysicalDeviceShaderCorePropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderCorePropertiesARM; - void * pNext = {}; - uint32_t pixelRate = {}; - uint32_t texelRate = {}; - uint32_t fmaRate = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderCorePropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderCorePropertiesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.html - struct PhysicalDeviceShaderDemoteToHelperInvocationFeatures - { - using NativeType = VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDemoteToHelperInvocationFeatures( Bool32 shaderDemoteToHelperInvocation_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderDemoteToHelperInvocation{ shaderDemoteToHelperInvocation_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderDemoteToHelperInvocationFeatures( PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderDemoteToHelperInvocationFeatures( VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderDemoteToHelperInvocationFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderDemoteToHelperInvocationFeatures & - operator=( PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderDemoteToHelperInvocationFeatures & operator=( VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDemoteToHelperInvocationFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDemoteToHelperInvocationFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDemoteToHelperInvocationFeatures & setShaderDemoteToHelperInvocation( Bool32 shaderDemoteToHelperInvocation_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDemoteToHelperInvocationFeatures && - setShaderDemoteToHelperInvocation( Bool32 shaderDemoteToHelperInvocation_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderDemoteToHelperInvocation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation ); -# endif - } - - bool operator!=( PhysicalDeviceShaderDemoteToHelperInvocationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeatures; - void * pNext = {}; - Bool32 shaderDemoteToHelperInvocation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; - }; - - using PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = PhysicalDeviceShaderDemoteToHelperInvocationFeatures; - - // wrapper struct for struct VkPhysicalDeviceShaderDrawParametersFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderDrawParametersFeatures.html - struct PhysicalDeviceShaderDrawParametersFeatures - { - using NativeType = VkPhysicalDeviceShaderDrawParametersFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( Bool32 shaderDrawParameters_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderDrawParameters{ shaderDrawParameters_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderDrawParametersFeatures( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderDrawParametersFeatures( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderDrawParametersFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderDrawParametersFeatures & operator=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderDrawParametersFeatures & operator=( VkPhysicalDeviceShaderDrawParametersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDrawParametersFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDrawParametersFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDrawParametersFeatures & setShaderDrawParameters( Bool32 shaderDrawParameters_ ) & VULKAN_HPP_NOEXCEPT - { - shaderDrawParameters = shaderDrawParameters_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderDrawParametersFeatures && setShaderDrawParameters( Bool32 shaderDrawParameters_ ) && VULKAN_HPP_NOEXCEPT - { - shaderDrawParameters = shaderDrawParameters_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderDrawParametersFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderDrawParametersFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderDrawParametersFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderDrawParametersFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderDrawParameters ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderDrawParametersFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderDrawParameters == rhs.shaderDrawParameters ); -# endif - } - - bool operator!=( PhysicalDeviceShaderDrawParametersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderDrawParametersFeatures; - void * pNext = {}; - Bool32 shaderDrawParameters = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderDrawParametersFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderDrawParametersFeatures; - }; - - using PhysicalDeviceShaderDrawParameterFeatures = PhysicalDeviceShaderDrawParametersFeatures; - - // wrapper struct for struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.html - struct PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD - { - using NativeType = VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( Bool32 shaderEarlyAndLateFragmentTests_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderEarlyAndLateFragmentTests{ shaderEarlyAndLateFragmentTests_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD & - operator=( PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD & - operator=( VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD & - setShaderEarlyAndLateFragmentTests( Bool32 shaderEarlyAndLateFragmentTests_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderEarlyAndLateFragmentTests = shaderEarlyAndLateFragmentTests_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD && - setShaderEarlyAndLateFragmentTests( Bool32 shaderEarlyAndLateFragmentTests_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderEarlyAndLateFragmentTests = shaderEarlyAndLateFragmentTests_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderEarlyAndLateFragmentTests ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEarlyAndLateFragmentTests == rhs.shaderEarlyAndLateFragmentTests ); -# endif - } - - bool operator!=( PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; - void * pNext = {}; - Bool32 shaderEarlyAndLateFragmentTests = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkPhysicalDeviceShaderEnqueueFeaturesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderEnqueueFeaturesAMDX.html - struct PhysicalDeviceShaderEnqueueFeaturesAMDX - { - using NativeType = VkPhysicalDeviceShaderEnqueueFeaturesAMDX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderEnqueueFeaturesAMDX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderEnqueueFeaturesAMDX( Bool32 shaderEnqueue_ = {}, Bool32 shaderMeshEnqueue_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderEnqueue{ shaderEnqueue_ } - , shaderMeshEnqueue{ shaderMeshEnqueue_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderEnqueueFeaturesAMDX( PhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderEnqueueFeaturesAMDX( VkPhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderEnqueueFeaturesAMDX( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderEnqueueFeaturesAMDX & operator=( PhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderEnqueueFeaturesAMDX & operator=( VkPhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX & setShaderEnqueue( Bool32 shaderEnqueue_ ) & VULKAN_HPP_NOEXCEPT - { - shaderEnqueue = shaderEnqueue_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX && setShaderEnqueue( Bool32 shaderEnqueue_ ) && VULKAN_HPP_NOEXCEPT - { - shaderEnqueue = shaderEnqueue_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX & setShaderMeshEnqueue( Bool32 shaderMeshEnqueue_ ) & VULKAN_HPP_NOEXCEPT - { - shaderMeshEnqueue = shaderMeshEnqueue_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueueFeaturesAMDX && setShaderMeshEnqueue( Bool32 shaderMeshEnqueue_ ) && VULKAN_HPP_NOEXCEPT - { - shaderMeshEnqueue = shaderMeshEnqueue_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderEnqueueFeaturesAMDX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderEnqueueFeaturesAMDX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderEnqueueFeaturesAMDX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderEnqueueFeaturesAMDX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderEnqueue, shaderMeshEnqueue ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderEnqueueFeaturesAMDX const & ) const = default; -# else - bool operator==( PhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderEnqueue == rhs.shaderEnqueue ) && ( shaderMeshEnqueue == rhs.shaderMeshEnqueue ); -# endif - } - - bool operator!=( PhysicalDeviceShaderEnqueueFeaturesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderEnqueueFeaturesAMDX; - void * pNext = {}; - Bool32 shaderEnqueue = {}; - Bool32 shaderMeshEnqueue = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderEnqueueFeaturesAMDX; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderEnqueueFeaturesAMDX; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderEnqueuePropertiesAMDX.html - struct PhysicalDeviceShaderEnqueuePropertiesAMDX - { - using NativeType = VkPhysicalDeviceShaderEnqueuePropertiesAMDX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderEnqueuePropertiesAMDX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueuePropertiesAMDX( uint32_t maxExecutionGraphDepth_ = {}, - uint32_t maxExecutionGraphShaderOutputNodes_ = {}, - uint32_t maxExecutionGraphShaderPayloadSize_ = {}, - uint32_t maxExecutionGraphShaderPayloadCount_ = {}, - uint32_t executionGraphDispatchAddressAlignment_ = {}, - std::array const & maxExecutionGraphWorkgroupCount_ = {}, - uint32_t maxExecutionGraphWorkgroups_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxExecutionGraphDepth{ maxExecutionGraphDepth_ } - , maxExecutionGraphShaderOutputNodes{ maxExecutionGraphShaderOutputNodes_ } - , maxExecutionGraphShaderPayloadSize{ maxExecutionGraphShaderPayloadSize_ } - , maxExecutionGraphShaderPayloadCount{ maxExecutionGraphShaderPayloadCount_ } - , executionGraphDispatchAddressAlignment{ executionGraphDispatchAddressAlignment_ } - , maxExecutionGraphWorkgroupCount{ maxExecutionGraphWorkgroupCount_ } - , maxExecutionGraphWorkgroups{ maxExecutionGraphWorkgroups_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderEnqueuePropertiesAMDX( PhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderEnqueuePropertiesAMDX( VkPhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderEnqueuePropertiesAMDX( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderEnqueuePropertiesAMDX & operator=( PhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderEnqueuePropertiesAMDX & operator=( VkPhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShaderEnqueuePropertiesAMDX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderEnqueuePropertiesAMDX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderEnqueuePropertiesAMDX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderEnqueuePropertiesAMDX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - uint32_t const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - maxExecutionGraphDepth, - maxExecutionGraphShaderOutputNodes, - maxExecutionGraphShaderPayloadSize, - maxExecutionGraphShaderPayloadCount, - executionGraphDispatchAddressAlignment, - maxExecutionGraphWorkgroupCount, - maxExecutionGraphWorkgroups ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderEnqueuePropertiesAMDX const & ) const = default; -# else - bool operator==( PhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxExecutionGraphDepth == rhs.maxExecutionGraphDepth ) && - ( maxExecutionGraphShaderOutputNodes == rhs.maxExecutionGraphShaderOutputNodes ) && - ( maxExecutionGraphShaderPayloadSize == rhs.maxExecutionGraphShaderPayloadSize ) && - ( maxExecutionGraphShaderPayloadCount == rhs.maxExecutionGraphShaderPayloadCount ) && - ( executionGraphDispatchAddressAlignment == rhs.executionGraphDispatchAddressAlignment ) && - ( maxExecutionGraphWorkgroupCount == rhs.maxExecutionGraphWorkgroupCount ) && ( maxExecutionGraphWorkgroups == rhs.maxExecutionGraphWorkgroups ); -# endif - } - - bool operator!=( PhysicalDeviceShaderEnqueuePropertiesAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderEnqueuePropertiesAMDX; - void * pNext = {}; - uint32_t maxExecutionGraphDepth = {}; - uint32_t maxExecutionGraphShaderOutputNodes = {}; - uint32_t maxExecutionGraphShaderPayloadSize = {}; - uint32_t maxExecutionGraphShaderPayloadCount = {}; - uint32_t executionGraphDispatchAddressAlignment = {}; - ArrayWrapper1D maxExecutionGraphWorkgroupCount = {}; - uint32_t maxExecutionGraphWorkgroups = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderEnqueuePropertiesAMDX; - }; -# endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderEnqueuePropertiesAMDX; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkPhysicalDeviceShaderExpectAssumeFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderExpectAssumeFeatures.html - struct PhysicalDeviceShaderExpectAssumeFeatures - { - using NativeType = VkPhysicalDeviceShaderExpectAssumeFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderExpectAssumeFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderExpectAssumeFeatures( Bool32 shaderExpectAssume_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderExpectAssume{ shaderExpectAssume_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderExpectAssumeFeatures( PhysicalDeviceShaderExpectAssumeFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderExpectAssumeFeatures( VkPhysicalDeviceShaderExpectAssumeFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderExpectAssumeFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderExpectAssumeFeatures & operator=( PhysicalDeviceShaderExpectAssumeFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderExpectAssumeFeatures & operator=( VkPhysicalDeviceShaderExpectAssumeFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderExpectAssumeFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderExpectAssumeFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderExpectAssumeFeatures & setShaderExpectAssume( Bool32 shaderExpectAssume_ ) & VULKAN_HPP_NOEXCEPT - { - shaderExpectAssume = shaderExpectAssume_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderExpectAssumeFeatures && setShaderExpectAssume( Bool32 shaderExpectAssume_ ) && VULKAN_HPP_NOEXCEPT - { - shaderExpectAssume = shaderExpectAssume_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderExpectAssumeFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderExpectAssumeFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderExpectAssumeFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderExpectAssumeFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderExpectAssume ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderExpectAssumeFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderExpectAssumeFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderExpectAssume == rhs.shaderExpectAssume ); -# endif - } - - bool operator!=( PhysicalDeviceShaderExpectAssumeFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderExpectAssumeFeatures; - void * pNext = {}; - Bool32 shaderExpectAssume = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderExpectAssumeFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderExpectAssumeFeatures; - }; - - using PhysicalDeviceShaderExpectAssumeFeaturesKHR = PhysicalDeviceShaderExpectAssumeFeatures; - - // wrapper struct for struct VkPhysicalDeviceShaderFloat16Int8Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFloat16Int8Features.html - struct PhysicalDeviceShaderFloat16Int8Features - { - using NativeType = VkPhysicalDeviceShaderFloat16Int8Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFloat16Int8Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderFloat16Int8Features( Bool32 shaderFloat16_ = {}, Bool32 shaderInt8_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderFloat16{ shaderFloat16_ } - , shaderInt8{ shaderInt8_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat16Int8Features( PhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderFloat16Int8Features( VkPhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderFloat16Int8Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderFloat16Int8Features & operator=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderFloat16Int8Features & operator=( VkPhysicalDeviceShaderFloat16Int8Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features & setShaderFloat16( Bool32 shaderFloat16_ ) & VULKAN_HPP_NOEXCEPT - { - shaderFloat16 = shaderFloat16_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features && setShaderFloat16( Bool32 shaderFloat16_ ) && VULKAN_HPP_NOEXCEPT - { - shaderFloat16 = shaderFloat16_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features & setShaderInt8( Bool32 shaderInt8_ ) & VULKAN_HPP_NOEXCEPT - { - shaderInt8 = shaderInt8_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat16Int8Features && setShaderInt8( Bool32 shaderInt8_ ) && VULKAN_HPP_NOEXCEPT - { - shaderInt8 = shaderInt8_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderFloat16Int8Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFloat16Int8Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFloat16Int8Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFloat16Int8Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderFloat16, shaderInt8 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderFloat16Int8Features const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat16 == rhs.shaderFloat16 ) && ( shaderInt8 == rhs.shaderInt8 ); -# endif - } - - bool operator!=( PhysicalDeviceShaderFloat16Int8Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderFloat16Int8Features; - void * pNext = {}; - Bool32 shaderFloat16 = {}; - Bool32 shaderInt8 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderFloat16Int8Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderFloat16Int8Features; - }; - - using PhysicalDeviceFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; - using PhysicalDeviceShaderFloat16Int8FeaturesKHR = PhysicalDeviceShaderFloat16Int8Features; - - // wrapper struct for struct VkPhysicalDeviceShaderFloat8FeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFloat8FeaturesEXT.html - struct PhysicalDeviceShaderFloat8FeaturesEXT - { - using NativeType = VkPhysicalDeviceShaderFloat8FeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFloat8FeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat8FeaturesEXT( Bool32 shaderFloat8_ = {}, - Bool32 shaderFloat8CooperativeMatrix_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderFloat8{ shaderFloat8_ } - , shaderFloat8CooperativeMatrix{ shaderFloat8CooperativeMatrix_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloat8FeaturesEXT( PhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderFloat8FeaturesEXT( VkPhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderFloat8FeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderFloat8FeaturesEXT & operator=( PhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderFloat8FeaturesEXT & operator=( VkPhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT & setShaderFloat8( Bool32 shaderFloat8_ ) & VULKAN_HPP_NOEXCEPT - { - shaderFloat8 = shaderFloat8_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT && setShaderFloat8( Bool32 shaderFloat8_ ) && VULKAN_HPP_NOEXCEPT - { - shaderFloat8 = shaderFloat8_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT & setShaderFloat8CooperativeMatrix( Bool32 shaderFloat8CooperativeMatrix_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderFloat8CooperativeMatrix = shaderFloat8CooperativeMatrix_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloat8FeaturesEXT && setShaderFloat8CooperativeMatrix( Bool32 shaderFloat8CooperativeMatrix_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderFloat8CooperativeMatrix = shaderFloat8CooperativeMatrix_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderFloat8FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFloat8FeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFloat8FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFloat8FeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderFloat8, shaderFloat8CooperativeMatrix ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderFloat8FeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloat8 == rhs.shaderFloat8 ) && - ( shaderFloat8CooperativeMatrix == rhs.shaderFloat8CooperativeMatrix ); -# endif - } - - bool operator!=( PhysicalDeviceShaderFloat8FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderFloat8FeaturesEXT; - void * pNext = {}; - Bool32 shaderFloat8 = {}; - Bool32 shaderFloat8CooperativeMatrix = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderFloat8FeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderFloat8FeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderFloatControls2Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFloatControls2Features.html - struct PhysicalDeviceShaderFloatControls2Features - { - using NativeType = VkPhysicalDeviceShaderFloatControls2Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFloatControls2Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloatControls2Features( Bool32 shaderFloatControls2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderFloatControls2{ shaderFloatControls2_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFloatControls2Features( PhysicalDeviceShaderFloatControls2Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderFloatControls2Features( VkPhysicalDeviceShaderFloatControls2Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderFloatControls2Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderFloatControls2Features & operator=( PhysicalDeviceShaderFloatControls2Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderFloatControls2Features & operator=( VkPhysicalDeviceShaderFloatControls2Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloatControls2Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloatControls2Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloatControls2Features & setShaderFloatControls2( Bool32 shaderFloatControls2_ ) & VULKAN_HPP_NOEXCEPT - { - shaderFloatControls2 = shaderFloatControls2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFloatControls2Features && setShaderFloatControls2( Bool32 shaderFloatControls2_ ) && VULKAN_HPP_NOEXCEPT - { - shaderFloatControls2 = shaderFloatControls2_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderFloatControls2Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFloatControls2Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFloatControls2Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFloatControls2Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderFloatControls2 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderFloatControls2Features const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderFloatControls2Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFloatControls2 == rhs.shaderFloatControls2 ); -# endif - } - - bool operator!=( PhysicalDeviceShaderFloatControls2Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderFloatControls2Features; - void * pNext = {}; - Bool32 shaderFloatControls2 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderFloatControls2Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderFloatControls2Features; - }; - - using PhysicalDeviceShaderFloatControls2FeaturesKHR = PhysicalDeviceShaderFloatControls2Features; - - // wrapper struct for struct VkPhysicalDeviceShaderFmaFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderFmaFeaturesKHR.html - struct PhysicalDeviceShaderFmaFeaturesKHR - { - using NativeType = VkPhysicalDeviceShaderFmaFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderFmaFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFmaFeaturesKHR( Bool32 shaderFmaFloat16_ = {}, - Bool32 shaderFmaFloat32_ = {}, - Bool32 shaderFmaFloat64_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderFmaFloat16{ shaderFmaFloat16_ } - , shaderFmaFloat32{ shaderFmaFloat32_ } - , shaderFmaFloat64{ shaderFmaFloat64_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderFmaFeaturesKHR( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderFmaFeaturesKHR( VkPhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderFmaFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderFmaFeaturesKHR & operator=( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderFmaFeaturesKHR & operator=( VkPhysicalDeviceShaderFmaFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat16( Bool32 shaderFmaFloat16_ ) & VULKAN_HPP_NOEXCEPT - { - shaderFmaFloat16 = shaderFmaFloat16_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR && setShaderFmaFloat16( Bool32 shaderFmaFloat16_ ) && VULKAN_HPP_NOEXCEPT - { - shaderFmaFloat16 = shaderFmaFloat16_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat32( Bool32 shaderFmaFloat32_ ) & VULKAN_HPP_NOEXCEPT - { - shaderFmaFloat32 = shaderFmaFloat32_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR && setShaderFmaFloat32( Bool32 shaderFmaFloat32_ ) && VULKAN_HPP_NOEXCEPT - { - shaderFmaFloat32 = shaderFmaFloat32_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR & setShaderFmaFloat64( Bool32 shaderFmaFloat64_ ) & VULKAN_HPP_NOEXCEPT - { - shaderFmaFloat64 = shaderFmaFloat64_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderFmaFeaturesKHR && setShaderFmaFloat64( Bool32 shaderFmaFloat64_ ) && VULKAN_HPP_NOEXCEPT - { - shaderFmaFloat64 = shaderFmaFloat64_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderFmaFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFmaFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFmaFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderFmaFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderFmaFloat16, shaderFmaFloat32, shaderFmaFloat64 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderFmaFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderFmaFloat16 == rhs.shaderFmaFloat16 ) && ( shaderFmaFloat32 == rhs.shaderFmaFloat32 ) && - ( shaderFmaFloat64 == rhs.shaderFmaFloat64 ); -# endif - } - - bool operator!=( PhysicalDeviceShaderFmaFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderFmaFeaturesKHR; - void * pNext = {}; - Bool32 shaderFmaFloat16 = {}; - Bool32 shaderFmaFloat32 = {}; - Bool32 shaderFmaFloat64 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderFmaFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderFmaFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.html - struct PhysicalDeviceShaderImageAtomicInt64FeaturesEXT - { - using NativeType = VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageAtomicInt64FeaturesEXT( Bool32 shaderImageInt64Atomics_ = {}, - Bool32 sparseImageInt64Atomics_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderImageInt64Atomics{ shaderImageInt64Atomics_ } - , sparseImageInt64Atomics{ sparseImageInt64Atomics_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderImageAtomicInt64FeaturesEXT( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderImageAtomicInt64FeaturesEXT( VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderImageAtomicInt64FeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderImageAtomicInt64FeaturesEXT & operator=( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderImageAtomicInt64FeaturesEXT & operator=( VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT & setShaderImageInt64Atomics( Bool32 shaderImageInt64Atomics_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderImageInt64Atomics = shaderImageInt64Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT && setShaderImageInt64Atomics( Bool32 shaderImageInt64Atomics_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderImageInt64Atomics = shaderImageInt64Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT & setSparseImageInt64Atomics( Bool32 sparseImageInt64Atomics_ ) & - VULKAN_HPP_NOEXCEPT - { - sparseImageInt64Atomics = sparseImageInt64Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageAtomicInt64FeaturesEXT && setSparseImageInt64Atomics( Bool32 sparseImageInt64Atomics_ ) && - VULKAN_HPP_NOEXCEPT - { - sparseImageInt64Atomics = sparseImageInt64Atomics_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderImageInt64Atomics, sparseImageInt64Atomics ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderImageInt64Atomics == rhs.shaderImageInt64Atomics ) && - ( sparseImageInt64Atomics == rhs.sparseImageInt64Atomics ); -# endif - } - - bool operator!=( PhysicalDeviceShaderImageAtomicInt64FeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT; - void * pNext = {}; - Bool32 shaderImageInt64Atomics = {}; - Bool32 sparseImageInt64Atomics = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderImageAtomicInt64FeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderImageFootprintFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderImageFootprintFeaturesNV.html - struct PhysicalDeviceShaderImageFootprintFeaturesNV - { - using NativeType = VkPhysicalDeviceShaderImageFootprintFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( Bool32 imageFootprint_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageFootprint{ imageFootprint_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderImageFootprintFeaturesNV( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderImageFootprintFeaturesNV( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderImageFootprintFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderImageFootprintFeaturesNV & operator=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderImageFootprintFeaturesNV & operator=( VkPhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageFootprintFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageFootprintFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageFootprintFeaturesNV & setImageFootprint( Bool32 imageFootprint_ ) & VULKAN_HPP_NOEXCEPT - { - imageFootprint = imageFootprint_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderImageFootprintFeaturesNV && setImageFootprint( Bool32 imageFootprint_ ) && VULKAN_HPP_NOEXCEPT - { - imageFootprint = imageFootprint_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderImageFootprintFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderImageFootprintFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderImageFootprintFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageFootprint ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderImageFootprintFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageFootprint == rhs.imageFootprint ); -# endif - } - - bool operator!=( PhysicalDeviceShaderImageFootprintFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV; - void * pNext = {}; - Bool32 imageFootprint = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderImageFootprintFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderImageFootprintFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderIntegerDotProductFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderIntegerDotProductFeatures.html - struct PhysicalDeviceShaderIntegerDotProductFeatures - { - using NativeType = VkPhysicalDeviceShaderIntegerDotProductFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderIntegerDotProductFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerDotProductFeatures( Bool32 shaderIntegerDotProduct_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderIntegerDotProduct{ shaderIntegerDotProduct_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderIntegerDotProductFeatures( PhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderIntegerDotProductFeatures( VkPhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderIntegerDotProductFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderIntegerDotProductFeatures & operator=( PhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderIntegerDotProductFeatures & operator=( VkPhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductFeatures & setShaderIntegerDotProduct( Bool32 shaderIntegerDotProduct_ ) & VULKAN_HPP_NOEXCEPT - { - shaderIntegerDotProduct = shaderIntegerDotProduct_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerDotProductFeatures && setShaderIntegerDotProduct( Bool32 shaderIntegerDotProduct_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderIntegerDotProduct = shaderIntegerDotProduct_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderIntegerDotProductFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderIntegerDotProductFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderIntegerDotProductFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderIntegerDotProductFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderIntegerDotProduct ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderIntegerDotProductFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderIntegerDotProduct == rhs.shaderIntegerDotProduct ); -# endif - } - - bool operator!=( PhysicalDeviceShaderIntegerDotProductFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderIntegerDotProductFeatures; - void * pNext = {}; - Bool32 shaderIntegerDotProduct = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderIntegerDotProductFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderIntegerDotProductFeatures; - }; - - using PhysicalDeviceShaderIntegerDotProductFeaturesKHR = PhysicalDeviceShaderIntegerDotProductFeatures; - - // wrapper struct for struct VkPhysicalDeviceShaderIntegerDotProductProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderIntegerDotProductProperties.html - struct PhysicalDeviceShaderIntegerDotProductProperties - { - using NativeType = VkPhysicalDeviceShaderIntegerDotProductProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderIntegerDotProductProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderIntegerDotProductProperties( Bool32 integerDotProduct8BitUnsignedAccelerated_ = {}, - Bool32 integerDotProduct8BitSignedAccelerated_ = {}, - Bool32 integerDotProduct8BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProduct4x8BitPackedUnsignedAccelerated_ = {}, - Bool32 integerDotProduct4x8BitPackedSignedAccelerated_ = {}, - Bool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated_ = {}, - Bool32 integerDotProduct16BitUnsignedAccelerated_ = {}, - Bool32 integerDotProduct16BitSignedAccelerated_ = {}, - Bool32 integerDotProduct16BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProduct32BitUnsignedAccelerated_ = {}, - Bool32 integerDotProduct32BitSignedAccelerated_ = {}, - Bool32 integerDotProduct32BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProduct64BitUnsignedAccelerated_ = {}, - Bool32 integerDotProduct64BitSignedAccelerated_ = {}, - Bool32 integerDotProduct64BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , integerDotProduct8BitUnsignedAccelerated{ integerDotProduct8BitUnsignedAccelerated_ } - , integerDotProduct8BitSignedAccelerated{ integerDotProduct8BitSignedAccelerated_ } - , integerDotProduct8BitMixedSignednessAccelerated{ integerDotProduct8BitMixedSignednessAccelerated_ } - , integerDotProduct4x8BitPackedUnsignedAccelerated{ integerDotProduct4x8BitPackedUnsignedAccelerated_ } - , integerDotProduct4x8BitPackedSignedAccelerated{ integerDotProduct4x8BitPackedSignedAccelerated_ } - , integerDotProduct4x8BitPackedMixedSignednessAccelerated{ integerDotProduct4x8BitPackedMixedSignednessAccelerated_ } - , integerDotProduct16BitUnsignedAccelerated{ integerDotProduct16BitUnsignedAccelerated_ } - , integerDotProduct16BitSignedAccelerated{ integerDotProduct16BitSignedAccelerated_ } - , integerDotProduct16BitMixedSignednessAccelerated{ integerDotProduct16BitMixedSignednessAccelerated_ } - , integerDotProduct32BitUnsignedAccelerated{ integerDotProduct32BitUnsignedAccelerated_ } - , integerDotProduct32BitSignedAccelerated{ integerDotProduct32BitSignedAccelerated_ } - , integerDotProduct32BitMixedSignednessAccelerated{ integerDotProduct32BitMixedSignednessAccelerated_ } - , integerDotProduct64BitUnsignedAccelerated{ integerDotProduct64BitUnsignedAccelerated_ } - , integerDotProduct64BitSignedAccelerated{ integerDotProduct64BitSignedAccelerated_ } - , integerDotProduct64BitMixedSignednessAccelerated{ integerDotProduct64BitMixedSignednessAccelerated_ } - , integerDotProductAccumulatingSaturating8BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating8BitUnsignedAccelerated_ } - , integerDotProductAccumulatingSaturating8BitSignedAccelerated{ integerDotProductAccumulatingSaturating8BitSignedAccelerated_ } - , integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated_ } - , integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated_ } - , integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated_ } - , integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated_ } - , integerDotProductAccumulatingSaturating16BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating16BitUnsignedAccelerated_ } - , integerDotProductAccumulatingSaturating16BitSignedAccelerated{ integerDotProductAccumulatingSaturating16BitSignedAccelerated_ } - , integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated_ } - , integerDotProductAccumulatingSaturating32BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating32BitUnsignedAccelerated_ } - , integerDotProductAccumulatingSaturating32BitSignedAccelerated{ integerDotProductAccumulatingSaturating32BitSignedAccelerated_ } - , integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated_ } - , integerDotProductAccumulatingSaturating64BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating64BitUnsignedAccelerated_ } - , integerDotProductAccumulatingSaturating64BitSignedAccelerated{ integerDotProductAccumulatingSaturating64BitSignedAccelerated_ } - , integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderIntegerDotProductProperties( PhysicalDeviceShaderIntegerDotProductProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderIntegerDotProductProperties( VkPhysicalDeviceShaderIntegerDotProductProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderIntegerDotProductProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderIntegerDotProductProperties & operator=( PhysicalDeviceShaderIntegerDotProductProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderIntegerDotProductProperties & operator=( VkPhysicalDeviceShaderIntegerDotProductProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShaderIntegerDotProductProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderIntegerDotProductProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderIntegerDotProductProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderIntegerDotProductProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - integerDotProduct8BitUnsignedAccelerated, - integerDotProduct8BitSignedAccelerated, - integerDotProduct8BitMixedSignednessAccelerated, - integerDotProduct4x8BitPackedUnsignedAccelerated, - integerDotProduct4x8BitPackedSignedAccelerated, - integerDotProduct4x8BitPackedMixedSignednessAccelerated, - integerDotProduct16BitUnsignedAccelerated, - integerDotProduct16BitSignedAccelerated, - integerDotProduct16BitMixedSignednessAccelerated, - integerDotProduct32BitUnsignedAccelerated, - integerDotProduct32BitSignedAccelerated, - integerDotProduct32BitMixedSignednessAccelerated, - integerDotProduct64BitUnsignedAccelerated, - integerDotProduct64BitSignedAccelerated, - integerDotProduct64BitMixedSignednessAccelerated, - integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, - integerDotProductAccumulatingSaturating8BitSignedAccelerated, - integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, - integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, - integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, - integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, - integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, - integerDotProductAccumulatingSaturating16BitSignedAccelerated, - integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, - integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, - integerDotProductAccumulatingSaturating32BitSignedAccelerated, - integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, - integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, - integerDotProductAccumulatingSaturating64BitSignedAccelerated, - integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderIntegerDotProductProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderIntegerDotProductProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( integerDotProduct8BitUnsignedAccelerated == rhs.integerDotProduct8BitUnsignedAccelerated ) && - ( integerDotProduct8BitSignedAccelerated == rhs.integerDotProduct8BitSignedAccelerated ) && - ( integerDotProduct8BitMixedSignednessAccelerated == rhs.integerDotProduct8BitMixedSignednessAccelerated ) && - ( integerDotProduct4x8BitPackedUnsignedAccelerated == rhs.integerDotProduct4x8BitPackedUnsignedAccelerated ) && - ( integerDotProduct4x8BitPackedSignedAccelerated == rhs.integerDotProduct4x8BitPackedSignedAccelerated ) && - ( integerDotProduct4x8BitPackedMixedSignednessAccelerated == rhs.integerDotProduct4x8BitPackedMixedSignednessAccelerated ) && - ( integerDotProduct16BitUnsignedAccelerated == rhs.integerDotProduct16BitUnsignedAccelerated ) && - ( integerDotProduct16BitSignedAccelerated == rhs.integerDotProduct16BitSignedAccelerated ) && - ( integerDotProduct16BitMixedSignednessAccelerated == rhs.integerDotProduct16BitMixedSignednessAccelerated ) && - ( integerDotProduct32BitUnsignedAccelerated == rhs.integerDotProduct32BitUnsignedAccelerated ) && - ( integerDotProduct32BitSignedAccelerated == rhs.integerDotProduct32BitSignedAccelerated ) && - ( integerDotProduct32BitMixedSignednessAccelerated == rhs.integerDotProduct32BitMixedSignednessAccelerated ) && - ( integerDotProduct64BitUnsignedAccelerated == rhs.integerDotProduct64BitUnsignedAccelerated ) && - ( integerDotProduct64BitSignedAccelerated == rhs.integerDotProduct64BitSignedAccelerated ) && - ( integerDotProduct64BitMixedSignednessAccelerated == rhs.integerDotProduct64BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating8BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating8BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating8BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated == - rhs.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated == - rhs.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating16BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating16BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating16BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating32BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating32BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating32BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating64BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating64BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating64BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ); -# endif - } - - bool operator!=( PhysicalDeviceShaderIntegerDotProductProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderIntegerDotProductProperties; - void * pNext = {}; - Bool32 integerDotProduct8BitUnsignedAccelerated = {}; - Bool32 integerDotProduct8BitSignedAccelerated = {}; - Bool32 integerDotProduct8BitMixedSignednessAccelerated = {}; - Bool32 integerDotProduct4x8BitPackedUnsignedAccelerated = {}; - Bool32 integerDotProduct4x8BitPackedSignedAccelerated = {}; - Bool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated = {}; - Bool32 integerDotProduct16BitUnsignedAccelerated = {}; - Bool32 integerDotProduct16BitSignedAccelerated = {}; - Bool32 integerDotProduct16BitMixedSignednessAccelerated = {}; - Bool32 integerDotProduct32BitUnsignedAccelerated = {}; - Bool32 integerDotProduct32BitSignedAccelerated = {}; - Bool32 integerDotProduct32BitMixedSignednessAccelerated = {}; - Bool32 integerDotProduct64BitUnsignedAccelerated = {}; - Bool32 integerDotProduct64BitSignedAccelerated = {}; - Bool32 integerDotProduct64BitMixedSignednessAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderIntegerDotProductProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderIntegerDotProductProperties; - }; - - using PhysicalDeviceShaderIntegerDotProductPropertiesKHR = PhysicalDeviceShaderIntegerDotProductProperties; - - // wrapper struct for struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.html - struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL - { - using NativeType = VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( Bool32 shaderIntegerFunctions2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderIntegerFunctions2{ shaderIntegerFunctions2_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & - operator=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & operator=( VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL & setShaderIntegerFunctions2( Bool32 shaderIntegerFunctions2_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderIntegerFunctions2 = shaderIntegerFunctions2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL && setShaderIntegerFunctions2( Bool32 shaderIntegerFunctions2_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderIntegerFunctions2 = shaderIntegerFunctions2_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderIntegerFunctions2 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderIntegerFunctions2 == rhs.shaderIntegerFunctions2 ); -# endif - } - - bool operator!=( PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - void * pNext = {}; - Bool32 shaderIntegerFunctions2 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderLongVectorFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderLongVectorFeaturesEXT.html - struct PhysicalDeviceShaderLongVectorFeaturesEXT - { - using NativeType = VkPhysicalDeviceShaderLongVectorFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderLongVectorFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorFeaturesEXT( Bool32 longVector_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , longVector{ longVector_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorFeaturesEXT( PhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderLongVectorFeaturesEXT( VkPhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderLongVectorFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderLongVectorFeaturesEXT & operator=( PhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderLongVectorFeaturesEXT & operator=( VkPhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT & setLongVector( Bool32 longVector_ ) & VULKAN_HPP_NOEXCEPT - { - longVector = longVector_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderLongVectorFeaturesEXT && setLongVector( Bool32 longVector_ ) && VULKAN_HPP_NOEXCEPT - { - longVector = longVector_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderLongVectorFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderLongVectorFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderLongVectorFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderLongVectorFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, longVector ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderLongVectorFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( longVector == rhs.longVector ); -# endif - } - - bool operator!=( PhysicalDeviceShaderLongVectorFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderLongVectorFeaturesEXT; - void * pNext = {}; - Bool32 longVector = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderLongVectorFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderLongVectorFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderLongVectorPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderLongVectorPropertiesEXT.html - struct PhysicalDeviceShaderLongVectorPropertiesEXT - { - using NativeType = VkPhysicalDeviceShaderLongVectorPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderLongVectorPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorPropertiesEXT( uint32_t maxVectorComponents_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxVectorComponents{ maxVectorComponents_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderLongVectorPropertiesEXT( PhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderLongVectorPropertiesEXT( VkPhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderLongVectorPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderLongVectorPropertiesEXT & operator=( PhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderLongVectorPropertiesEXT & operator=( VkPhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShaderLongVectorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderLongVectorPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderLongVectorPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderLongVectorPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxVectorComponents ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderLongVectorPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVectorComponents == rhs.maxVectorComponents ); -# endif - } - - bool operator!=( PhysicalDeviceShaderLongVectorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderLongVectorPropertiesEXT; - void * pNext = {}; - uint32_t maxVectorComponents = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderLongVectorPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderLongVectorPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.html - struct PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR - { - using NativeType = VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( Bool32 shaderMaximalReconvergence_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderMaximalReconvergence{ shaderMaximalReconvergence_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR & - operator=( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR & operator=( VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR & setShaderMaximalReconvergence( Bool32 shaderMaximalReconvergence_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderMaximalReconvergence = shaderMaximalReconvergence_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR && setShaderMaximalReconvergence( Bool32 shaderMaximalReconvergence_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderMaximalReconvergence = shaderMaximalReconvergence_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderMaximalReconvergence ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderMaximalReconvergence == rhs.shaderMaximalReconvergence ); -# endif - } - - bool operator!=( PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; - void * pNext = {}; - Bool32 shaderMaximalReconvergence = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.html - struct PhysicalDeviceShaderModuleIdentifierFeaturesEXT - { - using NativeType = VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderModuleIdentifierFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderModuleIdentifierFeaturesEXT( Bool32 shaderModuleIdentifier_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderModuleIdentifier{ shaderModuleIdentifier_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderModuleIdentifierFeaturesEXT( PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderModuleIdentifierFeaturesEXT( VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderModuleIdentifierFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderModuleIdentifierFeaturesEXT & operator=( PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderModuleIdentifierFeaturesEXT & operator=( VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderModuleIdentifierFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderModuleIdentifierFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderModuleIdentifierFeaturesEXT & setShaderModuleIdentifier( Bool32 shaderModuleIdentifier_ ) & VULKAN_HPP_NOEXCEPT - { - shaderModuleIdentifier = shaderModuleIdentifier_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderModuleIdentifierFeaturesEXT && setShaderModuleIdentifier( Bool32 shaderModuleIdentifier_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderModuleIdentifier = shaderModuleIdentifier_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderModuleIdentifier ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderModuleIdentifier == rhs.shaderModuleIdentifier ); -# endif - } - - bool operator!=( PhysicalDeviceShaderModuleIdentifierFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderModuleIdentifierFeaturesEXT; - void * pNext = {}; - Bool32 shaderModuleIdentifier = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderModuleIdentifierFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderModuleIdentifierFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.html - struct PhysicalDeviceShaderModuleIdentifierPropertiesEXT - { - using NativeType = VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - PhysicalDeviceShaderModuleIdentifierPropertiesEXT( std::array const & shaderModuleIdentifierAlgorithmUUID_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderModuleIdentifierAlgorithmUUID{ shaderModuleIdentifierAlgorithmUUID_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - PhysicalDeviceShaderModuleIdentifierPropertiesEXT( PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderModuleIdentifierPropertiesEXT( VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderModuleIdentifierPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderModuleIdentifierPropertiesEXT & - operator=( PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderModuleIdentifierPropertiesEXT & operator=( VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderModuleIdentifierAlgorithmUUID ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderModuleIdentifierAlgorithmUUID == rhs.shaderModuleIdentifierAlgorithmUUID ); -# endif - } - - bool operator!=( PhysicalDeviceShaderModuleIdentifierPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT; - void * pNext = {}; - ArrayWrapper1D shaderModuleIdentifierAlgorithmUUID = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderModuleIdentifierPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderModuleIdentifierPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderObjectFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderObjectFeaturesEXT.html - struct PhysicalDeviceShaderObjectFeaturesEXT - { - using NativeType = VkPhysicalDeviceShaderObjectFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderObjectFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderObjectFeaturesEXT( Bool32 shaderObject_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderObject{ shaderObject_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderObjectFeaturesEXT( PhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderObjectFeaturesEXT( VkPhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderObjectFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderObjectFeaturesEXT & operator=( PhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderObjectFeaturesEXT & operator=( VkPhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectFeaturesEXT & setShaderObject( Bool32 shaderObject_ ) & VULKAN_HPP_NOEXCEPT - { - shaderObject = shaderObject_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectFeaturesEXT && setShaderObject( Bool32 shaderObject_ ) && VULKAN_HPP_NOEXCEPT - { - shaderObject = shaderObject_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderObjectFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderObjectFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderObjectFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderObjectFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderObject ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderObjectFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderObjectFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderObject == rhs.shaderObject ); -# endif - } - - bool operator!=( PhysicalDeviceShaderObjectFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderObjectFeaturesEXT; - void * pNext = {}; - Bool32 shaderObject = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderObjectFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderObjectFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderObjectPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderObjectPropertiesEXT.html - struct PhysicalDeviceShaderObjectPropertiesEXT - { - using NativeType = VkPhysicalDeviceShaderObjectPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderObjectPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectPropertiesEXT( std::array const & shaderBinaryUUID_ = {}, - uint32_t shaderBinaryVersion_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderBinaryUUID{ shaderBinaryUUID_ } - , shaderBinaryVersion{ shaderBinaryVersion_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectPropertiesEXT( PhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderObjectPropertiesEXT( VkPhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderObjectPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderObjectPropertiesEXT & operator=( PhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderObjectPropertiesEXT & operator=( VkPhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShaderObjectPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderObjectPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderObjectPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderObjectPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderBinaryUUID, shaderBinaryVersion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderObjectPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderObjectPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderBinaryUUID == rhs.shaderBinaryUUID ) && - ( shaderBinaryVersion == rhs.shaderBinaryVersion ); -# endif - } - - bool operator!=( PhysicalDeviceShaderObjectPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderObjectPropertiesEXT; - void * pNext = {}; - ArrayWrapper1D shaderBinaryUUID = {}; - uint32_t shaderBinaryVersion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderObjectPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderObjectPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderQuadControlFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderQuadControlFeaturesKHR.html - struct PhysicalDeviceShaderQuadControlFeaturesKHR - { - using NativeType = VkPhysicalDeviceShaderQuadControlFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderQuadControlFeaturesKHR( Bool32 shaderQuadControl_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderQuadControl{ shaderQuadControl_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderQuadControlFeaturesKHR( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderQuadControlFeaturesKHR( VkPhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderQuadControlFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderQuadControlFeaturesKHR & operator=( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderQuadControlFeaturesKHR & operator=( VkPhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderQuadControlFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderQuadControlFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderQuadControlFeaturesKHR & setShaderQuadControl( Bool32 shaderQuadControl_ ) & VULKAN_HPP_NOEXCEPT - { - shaderQuadControl = shaderQuadControl_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderQuadControlFeaturesKHR && setShaderQuadControl( Bool32 shaderQuadControl_ ) && VULKAN_HPP_NOEXCEPT - { - shaderQuadControl = shaderQuadControl_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderQuadControlFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderQuadControlFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderQuadControlFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderQuadControlFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderQuadControl ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderQuadControlFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderQuadControl == rhs.shaderQuadControl ); -# endif - } - - bool operator!=( PhysicalDeviceShaderQuadControlFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR; - void * pNext = {}; - Bool32 shaderQuadControl = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderQuadControlFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderQuadControlFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.html - struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR - { - using NativeType = VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR( Bool32 shaderRelaxedExtendedInstruction_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderRelaxedExtendedInstruction{ shaderRelaxedExtendedInstruction_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR( PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR( VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR( - *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR & - operator=( PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR & - operator=( VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR & - setShaderRelaxedExtendedInstruction( Bool32 shaderRelaxedExtendedInstruction_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderRelaxedExtendedInstruction = shaderRelaxedExtendedInstruction_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR && - setShaderRelaxedExtendedInstruction( Bool32 shaderRelaxedExtendedInstruction_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderRelaxedExtendedInstruction = shaderRelaxedExtendedInstruction_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderRelaxedExtendedInstruction ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderRelaxedExtendedInstruction == rhs.shaderRelaxedExtendedInstruction ); -# endif - } - - bool operator!=( PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; - void * pNext = {}; - Bool32 shaderRelaxedExtendedInstruction = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.html - struct PhysicalDeviceShaderReplicatedCompositesFeaturesEXT - { - using NativeType = VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderReplicatedCompositesFeaturesEXT( Bool32 shaderReplicatedComposites_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderReplicatedComposites{ shaderReplicatedComposites_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderReplicatedCompositesFeaturesEXT( PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderReplicatedCompositesFeaturesEXT( VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderReplicatedCompositesFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderReplicatedCompositesFeaturesEXT & - operator=( PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderReplicatedCompositesFeaturesEXT & operator=( VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderReplicatedCompositesFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderReplicatedCompositesFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderReplicatedCompositesFeaturesEXT & setShaderReplicatedComposites( Bool32 shaderReplicatedComposites_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderReplicatedComposites = shaderReplicatedComposites_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderReplicatedCompositesFeaturesEXT && setShaderReplicatedComposites( Bool32 shaderReplicatedComposites_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderReplicatedComposites = shaderReplicatedComposites_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderReplicatedComposites ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderReplicatedComposites == rhs.shaderReplicatedComposites ); -# endif - } - - bool operator!=( PhysicalDeviceShaderReplicatedCompositesFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT; - void * pNext = {}; - Bool32 shaderReplicatedComposites = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderReplicatedCompositesFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderReplicatedCompositesFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.html - struct PhysicalDeviceShaderSMBuiltinsFeaturesNV - { - using NativeType = VkPhysicalDeviceShaderSMBuiltinsFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( Bool32 shaderSMBuiltins_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderSMBuiltins{ shaderSMBuiltins_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsFeaturesNV( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderSMBuiltinsFeaturesNV( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderSMBuiltinsFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderSMBuiltinsFeaturesNV & operator=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderSMBuiltinsFeaturesNV & operator=( VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSMBuiltinsFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSMBuiltinsFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSMBuiltinsFeaturesNV & setShaderSMBuiltins( Bool32 shaderSMBuiltins_ ) & VULKAN_HPP_NOEXCEPT - { - shaderSMBuiltins = shaderSMBuiltins_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSMBuiltinsFeaturesNV && setShaderSMBuiltins( Bool32 shaderSMBuiltins_ ) && VULKAN_HPP_NOEXCEPT - { - shaderSMBuiltins = shaderSMBuiltins_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderSMBuiltins ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMBuiltins == rhs.shaderSMBuiltins ); -# endif - } - - bool operator!=( PhysicalDeviceShaderSMBuiltinsFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV; - void * pNext = {}; - Bool32 shaderSMBuiltins = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSMBuiltinsFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSMBuiltinsFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.html - struct PhysicalDeviceShaderSMBuiltinsPropertiesNV - { - using NativeType = VkPhysicalDeviceShaderSMBuiltinsPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderSMBuiltinsPropertiesNV( uint32_t shaderSMCount_ = {}, uint32_t shaderWarpsPerSM_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderSMCount{ shaderSMCount_ } - , shaderWarpsPerSM{ shaderWarpsPerSM_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSMBuiltinsPropertiesNV( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderSMBuiltinsPropertiesNV( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderSMBuiltinsPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderSMBuiltinsPropertiesNV & operator=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderSMBuiltinsPropertiesNV & operator=( VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderSMCount, shaderWarpsPerSM ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSMCount == rhs.shaderSMCount ) && ( shaderWarpsPerSM == rhs.shaderWarpsPerSM ); -# endif - } - - bool operator!=( PhysicalDeviceShaderSMBuiltinsPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV; - void * pNext = {}; - uint32_t shaderSMCount = {}; - uint32_t shaderWarpsPerSM = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSMBuiltinsPropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.html - struct PhysicalDeviceShaderSubgroupExtendedTypesFeatures - { - using NativeType = VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupExtendedTypesFeatures( Bool32 shaderSubgroupExtendedTypes_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderSubgroupExtendedTypes{ shaderSubgroupExtendedTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderSubgroupExtendedTypesFeatures( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderSubgroupExtendedTypesFeatures( VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderSubgroupExtendedTypesFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderSubgroupExtendedTypesFeatures & - operator=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderSubgroupExtendedTypesFeatures & operator=( VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupExtendedTypesFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupExtendedTypesFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupExtendedTypesFeatures & setShaderSubgroupExtendedTypes( Bool32 shaderSubgroupExtendedTypes_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupExtendedTypesFeatures && setShaderSubgroupExtendedTypes( Bool32 shaderSubgroupExtendedTypes_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderSubgroupExtendedTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes ); -# endif - } - - bool operator!=( PhysicalDeviceShaderSubgroupExtendedTypesFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures; - void * pNext = {}; - Bool32 shaderSubgroupExtendedTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; - }; - - using PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = PhysicalDeviceShaderSubgroupExtendedTypesFeatures; - - // wrapper struct for struct VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT.html - struct PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT - { - using NativeType = VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT( Bool32 shaderSubgroupPartitioned_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderSubgroupPartitioned{ shaderSubgroupPartitioned_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT( PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT( VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT & - operator=( PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT & operator=( VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT & setShaderSubgroupPartitioned( Bool32 shaderSubgroupPartitioned_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSubgroupPartitioned = shaderSubgroupPartitioned_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT && setShaderSubgroupPartitioned( Bool32 shaderSubgroupPartitioned_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSubgroupPartitioned = shaderSubgroupPartitioned_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderSubgroupPartitioned ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupPartitioned == rhs.shaderSubgroupPartitioned ); -# endif - } - - bool operator!=( PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; - void * pNext = {}; - Bool32 shaderSubgroupPartitioned = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderSubgroupRotateFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupRotateFeatures.html - struct PhysicalDeviceShaderSubgroupRotateFeatures - { - using NativeType = VkPhysicalDeviceShaderSubgroupRotateFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSubgroupRotateFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupRotateFeatures( Bool32 shaderSubgroupRotate_ = {}, - Bool32 shaderSubgroupRotateClustered_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderSubgroupRotate{ shaderSubgroupRotate_ } - , shaderSubgroupRotateClustered{ shaderSubgroupRotateClustered_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupRotateFeatures( PhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderSubgroupRotateFeatures( VkPhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderSubgroupRotateFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderSubgroupRotateFeatures & operator=( PhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderSubgroupRotateFeatures & operator=( VkPhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures & setShaderSubgroupRotate( Bool32 shaderSubgroupRotate_ ) & VULKAN_HPP_NOEXCEPT - { - shaderSubgroupRotate = shaderSubgroupRotate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures && setShaderSubgroupRotate( Bool32 shaderSubgroupRotate_ ) && VULKAN_HPP_NOEXCEPT - { - shaderSubgroupRotate = shaderSubgroupRotate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures & setShaderSubgroupRotateClustered( Bool32 shaderSubgroupRotateClustered_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSubgroupRotateClustered = shaderSubgroupRotateClustered_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupRotateFeatures && setShaderSubgroupRotateClustered( Bool32 shaderSubgroupRotateClustered_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSubgroupRotateClustered = shaderSubgroupRotateClustered_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderSubgroupRotateFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupRotateFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupRotateFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupRotateFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderSubgroupRotate, shaderSubgroupRotateClustered ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderSubgroupRotateFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupRotate == rhs.shaderSubgroupRotate ) && - ( shaderSubgroupRotateClustered == rhs.shaderSubgroupRotateClustered ); -# endif - } - - bool operator!=( PhysicalDeviceShaderSubgroupRotateFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupRotateFeatures; - void * pNext = {}; - Bool32 shaderSubgroupRotate = {}; - Bool32 shaderSubgroupRotateClustered = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSubgroupRotateFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSubgroupRotateFeatures; - }; - - using PhysicalDeviceShaderSubgroupRotateFeaturesKHR = PhysicalDeviceShaderSubgroupRotateFeatures; - - // wrapper struct for struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.html - struct PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR - { - using NativeType = VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( Bool32 shaderSubgroupUniformControlFlow_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderSubgroupUniformControlFlow{ shaderSubgroupUniformControlFlow_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR( - *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR & - operator=( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR & - operator=( VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR & - setShaderSubgroupUniformControlFlow( Bool32 shaderSubgroupUniformControlFlow_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSubgroupUniformControlFlow = shaderSubgroupUniformControlFlow_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR && - setShaderSubgroupUniformControlFlow( Bool32 shaderSubgroupUniformControlFlow_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSubgroupUniformControlFlow = shaderSubgroupUniformControlFlow_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderSubgroupUniformControlFlow ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderSubgroupUniformControlFlow == rhs.shaderSubgroupUniformControlFlow ); -# endif - } - - bool operator!=( PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; - void * pNext = {}; - Bool32 shaderSubgroupUniformControlFlow = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderTerminateInvocationFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderTerminateInvocationFeatures.html - struct PhysicalDeviceShaderTerminateInvocationFeatures - { - using NativeType = VkPhysicalDeviceShaderTerminateInvocationFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderTerminateInvocationFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTerminateInvocationFeatures( Bool32 shaderTerminateInvocation_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderTerminateInvocation{ shaderTerminateInvocation_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderTerminateInvocationFeatures( PhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderTerminateInvocationFeatures( VkPhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderTerminateInvocationFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderTerminateInvocationFeatures & operator=( PhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderTerminateInvocationFeatures & operator=( VkPhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTerminateInvocationFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTerminateInvocationFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTerminateInvocationFeatures & setShaderTerminateInvocation( Bool32 shaderTerminateInvocation_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderTerminateInvocation = shaderTerminateInvocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTerminateInvocationFeatures && setShaderTerminateInvocation( Bool32 shaderTerminateInvocation_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderTerminateInvocation = shaderTerminateInvocation_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderTerminateInvocationFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderTerminateInvocationFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderTerminateInvocationFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderTerminateInvocationFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderTerminateInvocation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderTerminateInvocationFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderTerminateInvocation == rhs.shaderTerminateInvocation ); -# endif - } - - bool operator!=( PhysicalDeviceShaderTerminateInvocationFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderTerminateInvocationFeatures; - void * pNext = {}; - Bool32 shaderTerminateInvocation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderTerminateInvocationFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderTerminateInvocationFeatures; - }; - - using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures; - - // wrapper struct for struct VkPhysicalDeviceShaderTileImageFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderTileImageFeaturesEXT.html - struct PhysicalDeviceShaderTileImageFeaturesEXT - { - using NativeType = VkPhysicalDeviceShaderTileImageFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImageFeaturesEXT( Bool32 shaderTileImageColorReadAccess_ = {}, - Bool32 shaderTileImageDepthReadAccess_ = {}, - Bool32 shaderTileImageStencilReadAccess_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderTileImageColorReadAccess{ shaderTileImageColorReadAccess_ } - , shaderTileImageDepthReadAccess{ shaderTileImageDepthReadAccess_ } - , shaderTileImageStencilReadAccess{ shaderTileImageStencilReadAccess_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImageFeaturesEXT( PhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderTileImageFeaturesEXT( VkPhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderTileImageFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderTileImageFeaturesEXT & operator=( PhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderTileImageFeaturesEXT & operator=( VkPhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & setShaderTileImageColorReadAccess( Bool32 shaderTileImageColorReadAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderTileImageColorReadAccess = shaderTileImageColorReadAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT && setShaderTileImageColorReadAccess( Bool32 shaderTileImageColorReadAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderTileImageColorReadAccess = shaderTileImageColorReadAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & setShaderTileImageDepthReadAccess( Bool32 shaderTileImageDepthReadAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderTileImageDepthReadAccess = shaderTileImageDepthReadAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT && setShaderTileImageDepthReadAccess( Bool32 shaderTileImageDepthReadAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderTileImageDepthReadAccess = shaderTileImageDepthReadAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & setShaderTileImageStencilReadAccess( Bool32 shaderTileImageStencilReadAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderTileImageStencilReadAccess = shaderTileImageStencilReadAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT && setShaderTileImageStencilReadAccess( Bool32 shaderTileImageStencilReadAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderTileImageStencilReadAccess = shaderTileImageStencilReadAccess_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderTileImageFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderTileImageFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderTileImageFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderTileImageFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderTileImageColorReadAccess, shaderTileImageDepthReadAccess, shaderTileImageStencilReadAccess ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderTileImageFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderTileImageColorReadAccess == rhs.shaderTileImageColorReadAccess ) && - ( shaderTileImageDepthReadAccess == rhs.shaderTileImageDepthReadAccess ) && - ( shaderTileImageStencilReadAccess == rhs.shaderTileImageStencilReadAccess ); -# endif - } - - bool operator!=( PhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT; - void * pNext = {}; - Bool32 shaderTileImageColorReadAccess = {}; - Bool32 shaderTileImageDepthReadAccess = {}; - Bool32 shaderTileImageStencilReadAccess = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderTileImageFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderTileImageFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderTileImagePropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderTileImagePropertiesEXT.html - struct PhysicalDeviceShaderTileImagePropertiesEXT - { - using NativeType = VkPhysicalDeviceShaderTileImagePropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImagePropertiesEXT( Bool32 shaderTileImageCoherentReadAccelerated_ = {}, - Bool32 shaderTileImageReadSampleFromPixelRateInvocation_ = {}, - Bool32 shaderTileImageReadFromHelperInvocation_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderTileImageCoherentReadAccelerated{ shaderTileImageCoherentReadAccelerated_ } - , shaderTileImageReadSampleFromPixelRateInvocation{ shaderTileImageReadSampleFromPixelRateInvocation_ } - , shaderTileImageReadFromHelperInvocation{ shaderTileImageReadFromHelperInvocation_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImagePropertiesEXT( PhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderTileImagePropertiesEXT( VkPhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderTileImagePropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderTileImagePropertiesEXT & operator=( PhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderTileImagePropertiesEXT & operator=( VkPhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShaderTileImagePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderTileImagePropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderTileImagePropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderTileImagePropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, shaderTileImageCoherentReadAccelerated, shaderTileImageReadSampleFromPixelRateInvocation, shaderTileImageReadFromHelperInvocation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderTileImagePropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderTileImageCoherentReadAccelerated == rhs.shaderTileImageCoherentReadAccelerated ) && - ( shaderTileImageReadSampleFromPixelRateInvocation == rhs.shaderTileImageReadSampleFromPixelRateInvocation ) && - ( shaderTileImageReadFromHelperInvocation == rhs.shaderTileImageReadFromHelperInvocation ); -# endif - } - - bool operator!=( PhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT; - void * pNext = {}; - Bool32 shaderTileImageCoherentReadAccelerated = {}; - Bool32 shaderTileImageReadSampleFromPixelRateInvocation = {}; - Bool32 shaderTileImageReadFromHelperInvocation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderTileImagePropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderTileImagePropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT.html - struct PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT - { - using NativeType = VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT( Bool32 shaderUniformBufferUnsizedArray_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderUniformBufferUnsizedArray{ shaderUniformBufferUnsizedArray_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT( PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT( VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT & - operator=( PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT & - operator=( VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT & - setShaderUniformBufferUnsizedArray( Bool32 shaderUniformBufferUnsizedArray_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderUniformBufferUnsizedArray = shaderUniformBufferUnsizedArray_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT && - setShaderUniformBufferUnsizedArray( Bool32 shaderUniformBufferUnsizedArray_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderUniformBufferUnsizedArray = shaderUniformBufferUnsizedArray_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderUniformBufferUnsizedArray ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderUniformBufferUnsizedArray == rhs.shaderUniformBufferUnsizedArray ); -# endif - } - - bool operator!=( PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; - void * pNext = {}; - Bool32 shaderUniformBufferUnsizedArray = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShaderUntypedPointersFeaturesKHR.html - struct PhysicalDeviceShaderUntypedPointersFeaturesKHR - { - using NativeType = VkPhysicalDeviceShaderUntypedPointersFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderUntypedPointersFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderUntypedPointersFeaturesKHR( Bool32 shaderUntypedPointers_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderUntypedPointers{ shaderUntypedPointers_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceShaderUntypedPointersFeaturesKHR( PhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShaderUntypedPointersFeaturesKHR( VkPhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShaderUntypedPointersFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShaderUntypedPointersFeaturesKHR & operator=( PhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShaderUntypedPointersFeaturesKHR & operator=( VkPhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUntypedPointersFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUntypedPointersFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUntypedPointersFeaturesKHR & setShaderUntypedPointers( Bool32 shaderUntypedPointers_ ) & VULKAN_HPP_NOEXCEPT - { - shaderUntypedPointers = shaderUntypedPointers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderUntypedPointersFeaturesKHR && setShaderUntypedPointers( Bool32 shaderUntypedPointers_ ) && VULKAN_HPP_NOEXCEPT - { - shaderUntypedPointers = shaderUntypedPointers_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShaderUntypedPointersFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderUntypedPointersFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderUntypedPointersFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderUntypedPointers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShaderUntypedPointersFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderUntypedPointers == rhs.shaderUntypedPointers ); -# endif - } - - bool operator!=( PhysicalDeviceShaderUntypedPointersFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShaderUntypedPointersFeaturesKHR; - void * pNext = {}; - Bool32 shaderUntypedPointers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShaderUntypedPointersFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShaderUntypedPointersFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceShadingRateImageFeaturesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShadingRateImageFeaturesNV.html - struct PhysicalDeviceShadingRateImageFeaturesNV - { - using NativeType = VkPhysicalDeviceShadingRateImageFeaturesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( Bool32 shadingRateImage_ = {}, - Bool32 shadingRateCoarseSampleOrder_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shadingRateImage{ shadingRateImage_ } - , shadingRateCoarseSampleOrder{ shadingRateCoarseSampleOrder_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImageFeaturesNV( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShadingRateImageFeaturesNV( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShadingRateImageFeaturesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShadingRateImageFeaturesNV & operator=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShadingRateImageFeaturesNV & operator=( VkPhysicalDeviceShadingRateImageFeaturesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateImage( Bool32 shadingRateImage_ ) & VULKAN_HPP_NOEXCEPT - { - shadingRateImage = shadingRateImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV && setShadingRateImage( Bool32 shadingRateImage_ ) && VULKAN_HPP_NOEXCEPT - { - shadingRateImage = shadingRateImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV & setShadingRateCoarseSampleOrder( Bool32 shadingRateCoarseSampleOrder_ ) & - VULKAN_HPP_NOEXCEPT - { - shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShadingRateImageFeaturesNV && setShadingRateCoarseSampleOrder( Bool32 shadingRateCoarseSampleOrder_ ) && - VULKAN_HPP_NOEXCEPT - { - shadingRateCoarseSampleOrder = shadingRateCoarseSampleOrder_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceShadingRateImageFeaturesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShadingRateImageFeaturesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShadingRateImageFeaturesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShadingRateImageFeaturesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shadingRateImage, shadingRateCoarseSampleOrder ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShadingRateImageFeaturesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImage == rhs.shadingRateImage ) && - ( shadingRateCoarseSampleOrder == rhs.shadingRateCoarseSampleOrder ); -# endif - } - - bool operator!=( PhysicalDeviceShadingRateImageFeaturesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShadingRateImageFeaturesNV; - void * pNext = {}; - Bool32 shadingRateImage = {}; - Bool32 shadingRateCoarseSampleOrder = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShadingRateImageFeaturesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShadingRateImageFeaturesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceShadingRateImagePropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceShadingRateImagePropertiesNV.html - struct PhysicalDeviceShadingRateImagePropertiesNV - { - using NativeType = VkPhysicalDeviceShadingRateImagePropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImagePropertiesNV( Extent2D shadingRateTexelSize_ = {}, - uint32_t shadingRatePaletteSize_ = {}, - uint32_t shadingRateMaxCoarseSamples_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shadingRateTexelSize{ shadingRateTexelSize_ } - , shadingRatePaletteSize{ shadingRatePaletteSize_ } - , shadingRateMaxCoarseSamples{ shadingRateMaxCoarseSamples_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceShadingRateImagePropertiesNV( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceShadingRateImagePropertiesNV( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceShadingRateImagePropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceShadingRateImagePropertiesNV & operator=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceShadingRateImagePropertiesNV & operator=( VkPhysicalDeviceShadingRateImagePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceShadingRateImagePropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShadingRateImagePropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShadingRateImagePropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceShadingRateImagePropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shadingRateTexelSize, shadingRatePaletteSize, shadingRateMaxCoarseSamples ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceShadingRateImagePropertiesNV const & ) const = default; -#else - bool operator==( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateTexelSize == rhs.shadingRateTexelSize ) && - ( shadingRatePaletteSize == rhs.shadingRatePaletteSize ) && ( shadingRateMaxCoarseSamples == rhs.shadingRateMaxCoarseSamples ); -# endif - } - - bool operator!=( PhysicalDeviceShadingRateImagePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceShadingRateImagePropertiesNV; - void * pNext = {}; - Extent2D shadingRateTexelSize = {}; - uint32_t shadingRatePaletteSize = {}; - uint32_t shadingRateMaxCoarseSamples = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceShadingRateImagePropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceShadingRateImagePropertiesNV; - }; - - // wrapper struct for struct VkPhysicalDeviceSparseImageFormatInfo2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSparseImageFormatInfo2.html - struct PhysicalDeviceSparseImageFormatInfo2 - { - using NativeType = VkPhysicalDeviceSparseImageFormatInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( Format format_ = Format::eUndefined, - ImageType type_ = ImageType::e1D, - SampleCountFlagBits samples_ = SampleCountFlagBits::e1, - ImageUsageFlags usage_ = {}, - ImageTiling tiling_ = ImageTiling::eOptimal, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , format{ format_ } - , type{ type_ } - , samples{ samples_ } - , usage{ usage_ } - , tiling{ tiling_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSparseImageFormatInfo2( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSparseImageFormatInfo2( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSparseImageFormatInfo2( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSparseImageFormatInfo2 & operator=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSparseImageFormatInfo2 & operator=( VkPhysicalDeviceSparseImageFormatInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setType( ImageType type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setType( ImageType type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setSamples( SampleCountFlagBits samples_ ) & VULKAN_HPP_NOEXCEPT - { - samples = samples_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setSamples( SampleCountFlagBits samples_ ) && VULKAN_HPP_NOEXCEPT - { - samples = samples_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setUsage( ImageUsageFlags usage_ ) & VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setUsage( ImageUsageFlags usage_ ) && VULKAN_HPP_NOEXCEPT - { - usage = usage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 & setTiling( ImageTiling tiling_ ) & VULKAN_HPP_NOEXCEPT - { - tiling = tiling_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSparseImageFormatInfo2 && setTiling( ImageTiling tiling_ ) && VULKAN_HPP_NOEXCEPT - { - tiling = tiling_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceSparseImageFormatInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSparseImageFormatInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSparseImageFormatInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSparseImageFormatInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, format, type, samples, usage, tiling ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSparseImageFormatInfo2 const & ) const = default; -#else - bool operator==( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( type == rhs.type ) && ( samples == rhs.samples ) && - ( usage == rhs.usage ) && ( tiling == rhs.tiling ); -# endif - } - - bool operator!=( PhysicalDeviceSparseImageFormatInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSparseImageFormatInfo2; - const void * pNext = {}; - Format format = Format::eUndefined; - ImageType type = ImageType::e1D; - SampleCountFlagBits samples = SampleCountFlagBits::e1; - ImageUsageFlags usage = {}; - ImageTiling tiling = ImageTiling::eOptimal; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSparseImageFormatInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSparseImageFormatInfo2; - }; - - using PhysicalDeviceSparseImageFormatInfo2KHR = PhysicalDeviceSparseImageFormatInfo2; - - // wrapper struct for struct VkPhysicalDeviceSubgroupProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubgroupProperties.html - struct PhysicalDeviceSubgroupProperties - { - using NativeType = VkPhysicalDeviceSubgroupProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupProperties( uint32_t subgroupSize_ = {}, - ShaderStageFlags supportedStages_ = {}, - SubgroupFeatureFlags supportedOperations_ = {}, - Bool32 quadOperationsInAllStages_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , subgroupSize{ subgroupSize_ } - , supportedStages{ supportedStages_ } - , supportedOperations{ supportedOperations_ } - , quadOperationsInAllStages{ quadOperationsInAllStages_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupProperties( PhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSubgroupProperties( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSubgroupProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSubgroupProperties & operator=( PhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSubgroupProperties & operator=( VkPhysicalDeviceSubgroupProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceSubgroupProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubgroupProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubgroupProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubgroupProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, subgroupSize, supportedStages, supportedOperations, quadOperationsInAllStages ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSubgroupProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSize == rhs.subgroupSize ) && ( supportedStages == rhs.supportedStages ) && - ( supportedOperations == rhs.supportedOperations ) && ( quadOperationsInAllStages == rhs.quadOperationsInAllStages ); -# endif - } - - bool operator!=( PhysicalDeviceSubgroupProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSubgroupProperties; - void * pNext = {}; - uint32_t subgroupSize = {}; - ShaderStageFlags supportedStages = {}; - SubgroupFeatureFlags supportedOperations = {}; - Bool32 quadOperationsInAllStages = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSubgroupProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSubgroupProperties; - }; - - // wrapper struct for struct VkPhysicalDeviceSubgroupSizeControlFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubgroupSizeControlFeatures.html - struct PhysicalDeviceSubgroupSizeControlFeatures - { - using NativeType = VkPhysicalDeviceSubgroupSizeControlFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupSizeControlFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeatures( Bool32 subgroupSizeControl_ = {}, - Bool32 computeFullSubgroups_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , subgroupSizeControl{ subgroupSizeControl_ } - , computeFullSubgroups{ computeFullSubgroups_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlFeatures( PhysicalDeviceSubgroupSizeControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSubgroupSizeControlFeatures( VkPhysicalDeviceSubgroupSizeControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSubgroupSizeControlFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSubgroupSizeControlFeatures & operator=( PhysicalDeviceSubgroupSizeControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSubgroupSizeControlFeatures & operator=( VkPhysicalDeviceSubgroupSizeControlFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures & setSubgroupSizeControl( Bool32 subgroupSizeControl_ ) & VULKAN_HPP_NOEXCEPT - { - subgroupSizeControl = subgroupSizeControl_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures && setSubgroupSizeControl( Bool32 subgroupSizeControl_ ) && VULKAN_HPP_NOEXCEPT - { - subgroupSizeControl = subgroupSizeControl_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures & setComputeFullSubgroups( Bool32 computeFullSubgroups_ ) & VULKAN_HPP_NOEXCEPT - { - computeFullSubgroups = computeFullSubgroups_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubgroupSizeControlFeatures && setComputeFullSubgroups( Bool32 computeFullSubgroups_ ) && VULKAN_HPP_NOEXCEPT - { - computeFullSubgroups = computeFullSubgroups_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceSubgroupSizeControlFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubgroupSizeControlFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubgroupSizeControlFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubgroupSizeControlFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, subgroupSizeControl, computeFullSubgroups ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSubgroupSizeControlFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceSubgroupSizeControlFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subgroupSizeControl == rhs.subgroupSizeControl ) && - ( computeFullSubgroups == rhs.computeFullSubgroups ); -# endif - } - - bool operator!=( PhysicalDeviceSubgroupSizeControlFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlFeatures; - void * pNext = {}; - Bool32 subgroupSizeControl = {}; - Bool32 computeFullSubgroups = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSubgroupSizeControlFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSubgroupSizeControlFeatures; - }; - - using PhysicalDeviceSubgroupSizeControlFeaturesEXT = PhysicalDeviceSubgroupSizeControlFeatures; - - // wrapper struct for struct VkPhysicalDeviceSubgroupSizeControlProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubgroupSizeControlProperties.html - struct PhysicalDeviceSubgroupSizeControlProperties - { - using NativeType = VkPhysicalDeviceSubgroupSizeControlProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubgroupSizeControlProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlProperties( uint32_t minSubgroupSize_ = {}, - uint32_t maxSubgroupSize_ = {}, - uint32_t maxComputeWorkgroupSubgroups_ = {}, - ShaderStageFlags requiredSubgroupSizeStages_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minSubgroupSize{ minSubgroupSize_ } - , maxSubgroupSize{ maxSubgroupSize_ } - , maxComputeWorkgroupSubgroups{ maxComputeWorkgroupSubgroups_ } - , requiredSubgroupSizeStages{ requiredSubgroupSizeStages_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubgroupSizeControlProperties( PhysicalDeviceSubgroupSizeControlProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSubgroupSizeControlProperties( VkPhysicalDeviceSubgroupSizeControlProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSubgroupSizeControlProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSubgroupSizeControlProperties & operator=( PhysicalDeviceSubgroupSizeControlProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSubgroupSizeControlProperties & operator=( VkPhysicalDeviceSubgroupSizeControlProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceSubgroupSizeControlProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubgroupSizeControlProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubgroupSizeControlProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubgroupSizeControlProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minSubgroupSize, maxSubgroupSize, maxComputeWorkgroupSubgroups, requiredSubgroupSizeStages ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSubgroupSizeControlProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceSubgroupSizeControlProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) && ( maxSubgroupSize == rhs.maxSubgroupSize ) && - ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups ) && ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages ); -# endif - } - - bool operator!=( PhysicalDeviceSubgroupSizeControlProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSubgroupSizeControlProperties; - void * pNext = {}; - uint32_t minSubgroupSize = {}; - uint32_t maxSubgroupSize = {}; - uint32_t maxComputeWorkgroupSubgroups = {}; - ShaderStageFlags requiredSubgroupSizeStages = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSubgroupSizeControlProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSubgroupSizeControlProperties; - }; - - using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties; - - // wrapper struct for struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.html - struct PhysicalDeviceSubpassMergeFeedbackFeaturesEXT - { - using NativeType = VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubpassMergeFeedbackFeaturesEXT( Bool32 subpassMergeFeedback_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , subpassMergeFeedback{ subpassMergeFeedback_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceSubpassMergeFeedbackFeaturesEXT( PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSubpassMergeFeedbackFeaturesEXT( VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSubpassMergeFeedbackFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSubpassMergeFeedbackFeaturesEXT & operator=( PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSubpassMergeFeedbackFeaturesEXT & operator=( VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassMergeFeedbackFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassMergeFeedbackFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassMergeFeedbackFeaturesEXT & setSubpassMergeFeedback( Bool32 subpassMergeFeedback_ ) & VULKAN_HPP_NOEXCEPT - { - subpassMergeFeedback = subpassMergeFeedback_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassMergeFeedbackFeaturesEXT && setSubpassMergeFeedback( Bool32 subpassMergeFeedback_ ) && VULKAN_HPP_NOEXCEPT - { - subpassMergeFeedback = subpassMergeFeedback_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, subpassMergeFeedback ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassMergeFeedback == rhs.subpassMergeFeedback ); -# endif - } - - bool operator!=( PhysicalDeviceSubpassMergeFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT; - void * pNext = {}; - Bool32 subpassMergeFeedback = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSubpassMergeFeedbackFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSubpassMergeFeedbackFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.html - struct PhysicalDeviceSubpassShadingFeaturesHUAWEI - { - using NativeType = VkPhysicalDeviceSubpassShadingFeaturesHUAWEI; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubpassShadingFeaturesHUAWEI; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubpassShadingFeaturesHUAWEI( Bool32 subpassShading_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , subpassShading{ subpassShading_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubpassShadingFeaturesHUAWEI( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSubpassShadingFeaturesHUAWEI( VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSubpassShadingFeaturesHUAWEI( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSubpassShadingFeaturesHUAWEI & operator=( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSubpassShadingFeaturesHUAWEI & operator=( VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassShadingFeaturesHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassShadingFeaturesHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassShadingFeaturesHUAWEI & setSubpassShading( Bool32 subpassShading_ ) & VULKAN_HPP_NOEXCEPT - { - subpassShading = subpassShading_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSubpassShadingFeaturesHUAWEI && setSubpassShading( Bool32 subpassShading_ ) && VULKAN_HPP_NOEXCEPT - { - subpassShading = subpassShading_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, subpassShading ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & ) const = default; -#else - bool operator==( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassShading == rhs.subpassShading ); -# endif - } - - bool operator!=( PhysicalDeviceSubpassShadingFeaturesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSubpassShadingFeaturesHUAWEI; - void * pNext = {}; - Bool32 subpassShading = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSubpassShadingFeaturesHUAWEI; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSubpassShadingFeaturesHUAWEI; - }; - - // wrapper struct for struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.html - struct PhysicalDeviceSubpassShadingPropertiesHUAWEI - { - using NativeType = VkPhysicalDeviceSubpassShadingPropertiesHUAWEI; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSubpassShadingPropertiesHUAWEI; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubpassShadingPropertiesHUAWEI( uint32_t maxSubpassShadingWorkgroupSizeAspectRatio_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxSubpassShadingWorkgroupSizeAspectRatio{ maxSubpassShadingWorkgroupSizeAspectRatio_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSubpassShadingPropertiesHUAWEI( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSubpassShadingPropertiesHUAWEI( VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSubpassShadingPropertiesHUAWEI( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSubpassShadingPropertiesHUAWEI & operator=( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSubpassShadingPropertiesHUAWEI & operator=( VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxSubpassShadingWorkgroupSizeAspectRatio ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & ) const = default; -#else - bool operator==( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxSubpassShadingWorkgroupSizeAspectRatio == rhs.maxSubpassShadingWorkgroupSizeAspectRatio ); -# endif - } - - bool operator!=( PhysicalDeviceSubpassShadingPropertiesHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSubpassShadingPropertiesHUAWEI; - void * pNext = {}; - uint32_t maxSubpassShadingWorkgroupSizeAspectRatio = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSubpassShadingPropertiesHUAWEI; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSubpassShadingPropertiesHUAWEI; - }; - - // wrapper struct for struct VkPhysicalDeviceSurfaceInfo2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSurfaceInfo2KHR.html - struct PhysicalDeviceSurfaceInfo2KHR - { - using NativeType = VkPhysicalDeviceSurfaceInfo2KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( SurfaceKHR surface_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , surface{ surface_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSurfaceInfo2KHR( PhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSurfaceInfo2KHR( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSurfaceInfo2KHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSurfaceInfo2KHR & operator=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSurfaceInfo2KHR & operator=( VkPhysicalDeviceSurfaceInfo2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSurfaceInfo2KHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSurfaceInfo2KHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSurfaceInfo2KHR & setSurface( SurfaceKHR surface_ ) & VULKAN_HPP_NOEXCEPT - { - surface = surface_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSurfaceInfo2KHR && setSurface( SurfaceKHR surface_ ) && VULKAN_HPP_NOEXCEPT - { - surface = surface_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceSurfaceInfo2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSurfaceInfo2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSurfaceInfo2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSurfaceInfo2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, surface ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSurfaceInfo2KHR const & ) const = default; -#else - bool operator==( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surface == rhs.surface ); -# endif - } - - bool operator!=( PhysicalDeviceSurfaceInfo2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSurfaceInfo2KHR; - const void * pNext = {}; - SurfaceKHR surface = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSurfaceInfo2KHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSurfaceInfo2KHR; - }; - - // wrapper struct for struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR.html - struct PhysicalDeviceSwapchainMaintenance1FeaturesKHR - { - using NativeType = VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSwapchainMaintenance1FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSwapchainMaintenance1FeaturesKHR( Bool32 swapchainMaintenance1_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchainMaintenance1{ swapchainMaintenance1_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceSwapchainMaintenance1FeaturesKHR( PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSwapchainMaintenance1FeaturesKHR( VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSwapchainMaintenance1FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSwapchainMaintenance1FeaturesKHR & operator=( PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSwapchainMaintenance1FeaturesKHR & operator=( VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSwapchainMaintenance1FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSwapchainMaintenance1FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSwapchainMaintenance1FeaturesKHR & setSwapchainMaintenance1( Bool32 swapchainMaintenance1_ ) & VULKAN_HPP_NOEXCEPT - { - swapchainMaintenance1 = swapchainMaintenance1_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSwapchainMaintenance1FeaturesKHR && setSwapchainMaintenance1( Bool32 swapchainMaintenance1_ ) && VULKAN_HPP_NOEXCEPT - { - swapchainMaintenance1 = swapchainMaintenance1_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchainMaintenance1 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainMaintenance1 == rhs.swapchainMaintenance1 ); -# endif - } - - bool operator!=( PhysicalDeviceSwapchainMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSwapchainMaintenance1FeaturesKHR; - void * pNext = {}; - Bool32 swapchainMaintenance1 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSwapchainMaintenance1FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSwapchainMaintenance1FeaturesKHR; - }; - - using PhysicalDeviceSwapchainMaintenance1FeaturesEXT = PhysicalDeviceSwapchainMaintenance1FeaturesKHR; - - // wrapper struct for struct VkPhysicalDeviceSynchronization2Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceSynchronization2Features.html - struct PhysicalDeviceSynchronization2Features - { - using NativeType = VkPhysicalDeviceSynchronization2Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceSynchronization2Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceSynchronization2Features( Bool32 synchronization2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , synchronization2{ synchronization2_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceSynchronization2Features( PhysicalDeviceSynchronization2Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceSynchronization2Features( VkPhysicalDeviceSynchronization2Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceSynchronization2Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceSynchronization2Features & operator=( PhysicalDeviceSynchronization2Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceSynchronization2Features & operator=( VkPhysicalDeviceSynchronization2Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSynchronization2Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSynchronization2Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSynchronization2Features & setSynchronization2( Bool32 synchronization2_ ) & VULKAN_HPP_NOEXCEPT - { - synchronization2 = synchronization2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceSynchronization2Features && setSynchronization2( Bool32 synchronization2_ ) && VULKAN_HPP_NOEXCEPT - { - synchronization2 = synchronization2_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceSynchronization2Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSynchronization2Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSynchronization2Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceSynchronization2Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, synchronization2 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceSynchronization2Features const & ) const = default; -#else - bool operator==( PhysicalDeviceSynchronization2Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( synchronization2 == rhs.synchronization2 ); -# endif - } - - bool operator!=( PhysicalDeviceSynchronization2Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceSynchronization2Features; - void * pNext = {}; - Bool32 synchronization2 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceSynchronization2Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceSynchronization2Features; - }; - - using PhysicalDeviceSynchronization2FeaturesKHR = PhysicalDeviceSynchronization2Features; - - // wrapper struct for struct VkPhysicalDeviceTensorFeaturesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTensorFeaturesARM.html - struct PhysicalDeviceTensorFeaturesARM - { - using NativeType = VkPhysicalDeviceTensorFeaturesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTensorFeaturesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTensorFeaturesARM( Bool32 tensorNonPacked_ = {}, - Bool32 shaderTensorAccess_ = {}, - Bool32 shaderStorageTensorArrayDynamicIndexing_ = {}, - Bool32 shaderStorageTensorArrayNonUniformIndexing_ = {}, - Bool32 descriptorBindingStorageTensorUpdateAfterBind_ = {}, - Bool32 tensors_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensorNonPacked{ tensorNonPacked_ } - , shaderTensorAccess{ shaderTensorAccess_ } - , shaderStorageTensorArrayDynamicIndexing{ shaderStorageTensorArrayDynamicIndexing_ } - , shaderStorageTensorArrayNonUniformIndexing{ shaderStorageTensorArrayNonUniformIndexing_ } - , descriptorBindingStorageTensorUpdateAfterBind{ descriptorBindingStorageTensorUpdateAfterBind_ } - , tensors{ tensors_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTensorFeaturesARM( PhysicalDeviceTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTensorFeaturesARM( VkPhysicalDeviceTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTensorFeaturesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTensorFeaturesARM & operator=( PhysicalDeviceTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTensorFeaturesARM & operator=( VkPhysicalDeviceTensorFeaturesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & setTensorNonPacked( Bool32 tensorNonPacked_ ) & VULKAN_HPP_NOEXCEPT - { - tensorNonPacked = tensorNonPacked_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && setTensorNonPacked( Bool32 tensorNonPacked_ ) && VULKAN_HPP_NOEXCEPT - { - tensorNonPacked = tensorNonPacked_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & setShaderTensorAccess( Bool32 shaderTensorAccess_ ) & VULKAN_HPP_NOEXCEPT - { - shaderTensorAccess = shaderTensorAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && setShaderTensorAccess( Bool32 shaderTensorAccess_ ) && VULKAN_HPP_NOEXCEPT - { - shaderTensorAccess = shaderTensorAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & setShaderStorageTensorArrayDynamicIndexing( Bool32 shaderStorageTensorArrayDynamicIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageTensorArrayDynamicIndexing = shaderStorageTensorArrayDynamicIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && setShaderStorageTensorArrayDynamicIndexing( Bool32 shaderStorageTensorArrayDynamicIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageTensorArrayDynamicIndexing = shaderStorageTensorArrayDynamicIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & - setShaderStorageTensorArrayNonUniformIndexing( Bool32 shaderStorageTensorArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageTensorArrayNonUniformIndexing = shaderStorageTensorArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && - setShaderStorageTensorArrayNonUniformIndexing( Bool32 shaderStorageTensorArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageTensorArrayNonUniformIndexing = shaderStorageTensorArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & - setDescriptorBindingStorageTensorUpdateAfterBind( Bool32 descriptorBindingStorageTensorUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageTensorUpdateAfterBind = descriptorBindingStorageTensorUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && - setDescriptorBindingStorageTensorUpdateAfterBind( Bool32 descriptorBindingStorageTensorUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageTensorUpdateAfterBind = descriptorBindingStorageTensorUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM & setTensors( Bool32 tensors_ ) & VULKAN_HPP_NOEXCEPT - { - tensors = tensors_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTensorFeaturesARM && setTensors( Bool32 tensors_ ) && VULKAN_HPP_NOEXCEPT - { - tensors = tensors_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceTensorFeaturesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTensorFeaturesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTensorFeaturesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTensorFeaturesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - tensorNonPacked, - shaderTensorAccess, - shaderStorageTensorArrayDynamicIndexing, - shaderStorageTensorArrayNonUniformIndexing, - descriptorBindingStorageTensorUpdateAfterBind, - tensors ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTensorFeaturesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceTensorFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorNonPacked == rhs.tensorNonPacked ) && - ( shaderTensorAccess == rhs.shaderTensorAccess ) && ( shaderStorageTensorArrayDynamicIndexing == rhs.shaderStorageTensorArrayDynamicIndexing ) && - ( shaderStorageTensorArrayNonUniformIndexing == rhs.shaderStorageTensorArrayNonUniformIndexing ) && - ( descriptorBindingStorageTensorUpdateAfterBind == rhs.descriptorBindingStorageTensorUpdateAfterBind ) && ( tensors == rhs.tensors ); -# endif - } - - bool operator!=( PhysicalDeviceTensorFeaturesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTensorFeaturesARM; - void * pNext = {}; - Bool32 tensorNonPacked = {}; - Bool32 shaderTensorAccess = {}; - Bool32 shaderStorageTensorArrayDynamicIndexing = {}; - Bool32 shaderStorageTensorArrayNonUniformIndexing = {}; - Bool32 descriptorBindingStorageTensorUpdateAfterBind = {}; - Bool32 tensors = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTensorFeaturesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTensorFeaturesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceTensorPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTensorPropertiesARM.html - struct PhysicalDeviceTensorPropertiesARM - { - using NativeType = VkPhysicalDeviceTensorPropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTensorPropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTensorPropertiesARM( uint32_t maxTensorDimensionCount_ = {}, - uint64_t maxTensorElements_ = {}, - uint64_t maxPerDimensionTensorElements_ = {}, - int64_t maxTensorStride_ = {}, - uint64_t maxTensorSize_ = {}, - uint32_t maxTensorShaderAccessArrayLength_ = {}, - uint32_t maxTensorShaderAccessSize_ = {}, - uint32_t maxDescriptorSetStorageTensors_ = {}, - uint32_t maxPerStageDescriptorSetStorageTensors_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindStorageTensors_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors_ = {}, - Bool32 shaderStorageTensorArrayNonUniformIndexingNative_ = {}, - ShaderStageFlags shaderTensorSupportedStages_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxTensorDimensionCount{ maxTensorDimensionCount_ } - , maxTensorElements{ maxTensorElements_ } - , maxPerDimensionTensorElements{ maxPerDimensionTensorElements_ } - , maxTensorStride{ maxTensorStride_ } - , maxTensorSize{ maxTensorSize_ } - , maxTensorShaderAccessArrayLength{ maxTensorShaderAccessArrayLength_ } - , maxTensorShaderAccessSize{ maxTensorShaderAccessSize_ } - , maxDescriptorSetStorageTensors{ maxDescriptorSetStorageTensors_ } - , maxPerStageDescriptorSetStorageTensors{ maxPerStageDescriptorSetStorageTensors_ } - , maxDescriptorSetUpdateAfterBindStorageTensors{ maxDescriptorSetUpdateAfterBindStorageTensors_ } - , maxPerStageDescriptorUpdateAfterBindStorageTensors{ maxPerStageDescriptorUpdateAfterBindStorageTensors_ } - , shaderStorageTensorArrayNonUniformIndexingNative{ shaderStorageTensorArrayNonUniformIndexingNative_ } - , shaderTensorSupportedStages{ shaderTensorSupportedStages_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTensorPropertiesARM( PhysicalDeviceTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTensorPropertiesARM( VkPhysicalDeviceTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTensorPropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTensorPropertiesARM & operator=( PhysicalDeviceTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTensorPropertiesARM & operator=( VkPhysicalDeviceTensorPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceTensorPropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTensorPropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTensorPropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTensorPropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - maxTensorDimensionCount, - maxTensorElements, - maxPerDimensionTensorElements, - maxTensorStride, - maxTensorSize, - maxTensorShaderAccessArrayLength, - maxTensorShaderAccessSize, - maxDescriptorSetStorageTensors, - maxPerStageDescriptorSetStorageTensors, - maxDescriptorSetUpdateAfterBindStorageTensors, - maxPerStageDescriptorUpdateAfterBindStorageTensors, - shaderStorageTensorArrayNonUniformIndexingNative, - shaderTensorSupportedStages ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTensorPropertiesARM const & ) const = default; -#else - bool operator==( PhysicalDeviceTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTensorDimensionCount == rhs.maxTensorDimensionCount ) && - ( maxTensorElements == rhs.maxTensorElements ) && ( maxPerDimensionTensorElements == rhs.maxPerDimensionTensorElements ) && - ( maxTensorStride == rhs.maxTensorStride ) && ( maxTensorSize == rhs.maxTensorSize ) && - ( maxTensorShaderAccessArrayLength == rhs.maxTensorShaderAccessArrayLength ) && ( maxTensorShaderAccessSize == rhs.maxTensorShaderAccessSize ) && - ( maxDescriptorSetStorageTensors == rhs.maxDescriptorSetStorageTensors ) && - ( maxPerStageDescriptorSetStorageTensors == rhs.maxPerStageDescriptorSetStorageTensors ) && - ( maxDescriptorSetUpdateAfterBindStorageTensors == rhs.maxDescriptorSetUpdateAfterBindStorageTensors ) && - ( maxPerStageDescriptorUpdateAfterBindStorageTensors == rhs.maxPerStageDescriptorUpdateAfterBindStorageTensors ) && - ( shaderStorageTensorArrayNonUniformIndexingNative == rhs.shaderStorageTensorArrayNonUniformIndexingNative ) && - ( shaderTensorSupportedStages == rhs.shaderTensorSupportedStages ); -# endif - } - - bool operator!=( PhysicalDeviceTensorPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTensorPropertiesARM; - void * pNext = {}; - uint32_t maxTensorDimensionCount = {}; - uint64_t maxTensorElements = {}; - uint64_t maxPerDimensionTensorElements = {}; - int64_t maxTensorStride = {}; - uint64_t maxTensorSize = {}; - uint32_t maxTensorShaderAccessArrayLength = {}; - uint32_t maxTensorShaderAccessSize = {}; - uint32_t maxDescriptorSetStorageTensors = {}; - uint32_t maxPerStageDescriptorSetStorageTensors = {}; - uint32_t maxDescriptorSetUpdateAfterBindStorageTensors = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors = {}; - Bool32 shaderStorageTensorArrayNonUniformIndexingNative = {}; - ShaderStageFlags shaderTensorSupportedStages = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTensorPropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTensorPropertiesARM; - }; - - // wrapper struct for struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.html - struct PhysicalDeviceTexelBufferAlignmentFeaturesEXT - { - using NativeType = VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentFeaturesEXT( Bool32 texelBufferAlignment_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , texelBufferAlignment{ texelBufferAlignment_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceTexelBufferAlignmentFeaturesEXT( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTexelBufferAlignmentFeaturesEXT( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTexelBufferAlignmentFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTexelBufferAlignmentFeaturesEXT & operator=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTexelBufferAlignmentFeaturesEXT & operator=( VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTexelBufferAlignmentFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTexelBufferAlignmentFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTexelBufferAlignmentFeaturesEXT & setTexelBufferAlignment( Bool32 texelBufferAlignment_ ) & VULKAN_HPP_NOEXCEPT - { - texelBufferAlignment = texelBufferAlignment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTexelBufferAlignmentFeaturesEXT && setTexelBufferAlignment( Bool32 texelBufferAlignment_ ) && VULKAN_HPP_NOEXCEPT - { - texelBufferAlignment = texelBufferAlignment_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, texelBufferAlignment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( texelBufferAlignment == rhs.texelBufferAlignment ); -# endif - } - - bool operator!=( PhysicalDeviceTexelBufferAlignmentFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT; - void * pNext = {}; - Bool32 texelBufferAlignment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceTexelBufferAlignmentProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTexelBufferAlignmentProperties.html - struct PhysicalDeviceTexelBufferAlignmentProperties - { - using NativeType = VkPhysicalDeviceTexelBufferAlignmentProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTexelBufferAlignmentProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentProperties( DeviceSize storageTexelBufferOffsetAlignmentBytes_ = {}, - Bool32 storageTexelBufferOffsetSingleTexelAlignment_ = {}, - DeviceSize uniformTexelBufferOffsetAlignmentBytes_ = {}, - Bool32 uniformTexelBufferOffsetSingleTexelAlignment_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , storageTexelBufferOffsetAlignmentBytes{ storageTexelBufferOffsetAlignmentBytes_ } - , storageTexelBufferOffsetSingleTexelAlignment{ storageTexelBufferOffsetSingleTexelAlignment_ } - , uniformTexelBufferOffsetAlignmentBytes{ uniformTexelBufferOffsetAlignmentBytes_ } - , uniformTexelBufferOffsetSingleTexelAlignment{ uniformTexelBufferOffsetSingleTexelAlignment_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTexelBufferAlignmentProperties( PhysicalDeviceTexelBufferAlignmentProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTexelBufferAlignmentProperties( VkPhysicalDeviceTexelBufferAlignmentProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTexelBufferAlignmentProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTexelBufferAlignmentProperties & operator=( PhysicalDeviceTexelBufferAlignmentProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTexelBufferAlignmentProperties & operator=( VkPhysicalDeviceTexelBufferAlignmentProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceTexelBufferAlignmentProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTexelBufferAlignmentProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTexelBufferAlignmentProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTexelBufferAlignmentProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - storageTexelBufferOffsetAlignmentBytes, - storageTexelBufferOffsetSingleTexelAlignment, - uniformTexelBufferOffsetAlignmentBytes, - uniformTexelBufferOffsetSingleTexelAlignment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTexelBufferAlignmentProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceTexelBufferAlignmentProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes ) && - ( storageTexelBufferOffsetSingleTexelAlignment == rhs.storageTexelBufferOffsetSingleTexelAlignment ) && - ( uniformTexelBufferOffsetAlignmentBytes == rhs.uniformTexelBufferOffsetAlignmentBytes ) && - ( uniformTexelBufferOffsetSingleTexelAlignment == rhs.uniformTexelBufferOffsetSingleTexelAlignment ); -# endif - } - - bool operator!=( PhysicalDeviceTexelBufferAlignmentProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTexelBufferAlignmentProperties; - void * pNext = {}; - DeviceSize storageTexelBufferOffsetAlignmentBytes = {}; - Bool32 storageTexelBufferOffsetSingleTexelAlignment = {}; - DeviceSize uniformTexelBufferOffsetAlignmentBytes = {}; - Bool32 uniformTexelBufferOffsetSingleTexelAlignment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTexelBufferAlignmentProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTexelBufferAlignmentProperties; - }; - - using PhysicalDeviceTexelBufferAlignmentPropertiesEXT = PhysicalDeviceTexelBufferAlignmentProperties; - - // wrapper struct for struct VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT.html - struct PhysicalDeviceTextureCompressionASTC3DFeaturesEXT - { - using NativeType = VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( Bool32 textureCompressionASTC_3D_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , textureCompressionASTC_3D{ textureCompressionASTC_3D_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTextureCompressionASTC3DFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTextureCompressionASTC3DFeaturesEXT & - operator=( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTextureCompressionASTC3DFeaturesEXT & operator=( VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT & setTextureCompressionASTC_3D( Bool32 textureCompressionASTC_3D_ ) & - VULKAN_HPP_NOEXCEPT - { - textureCompressionASTC_3D = textureCompressionASTC_3D_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTC3DFeaturesEXT && setTextureCompressionASTC_3D( Bool32 textureCompressionASTC_3D_ ) && - VULKAN_HPP_NOEXCEPT - { - textureCompressionASTC_3D = textureCompressionASTC_3D_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, textureCompressionASTC_3D ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( textureCompressionASTC_3D == rhs.textureCompressionASTC_3D ); -# endif - } - - bool operator!=( PhysicalDeviceTextureCompressionASTC3DFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT; - void * pNext = {}; - Bool32 textureCompressionASTC_3D = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTextureCompressionASTC3DFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTextureCompressionASTC3DFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTextureCompressionASTCHDRFeatures.html - struct PhysicalDeviceTextureCompressionASTCHDRFeatures - { - using NativeType = VkPhysicalDeviceTextureCompressionASTCHDRFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTextureCompressionASTCHDRFeatures( Bool32 textureCompressionASTC_HDR_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , textureCompressionASTC_HDR{ textureCompressionASTC_HDR_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceTextureCompressionASTCHDRFeatures( PhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTextureCompressionASTCHDRFeatures( VkPhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTextureCompressionASTCHDRFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTextureCompressionASTCHDRFeatures & operator=( PhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTextureCompressionASTCHDRFeatures & operator=( VkPhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTCHDRFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTCHDRFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTCHDRFeatures & setTextureCompressionASTC_HDR( Bool32 textureCompressionASTC_HDR_ ) & - VULKAN_HPP_NOEXCEPT - { - textureCompressionASTC_HDR = textureCompressionASTC_HDR_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTextureCompressionASTCHDRFeatures && setTextureCompressionASTC_HDR( Bool32 textureCompressionASTC_HDR_ ) && - VULKAN_HPP_NOEXCEPT - { - textureCompressionASTC_HDR = textureCompressionASTC_HDR_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceTextureCompressionASTCHDRFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTextureCompressionASTCHDRFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTextureCompressionASTCHDRFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTextureCompressionASTCHDRFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, textureCompressionASTC_HDR ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTextureCompressionASTCHDRFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR ); -# endif - } - - bool operator!=( PhysicalDeviceTextureCompressionASTCHDRFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeatures; - void * pNext = {}; - Bool32 textureCompressionASTC_HDR = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTextureCompressionASTCHDRFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTextureCompressionASTCHDRFeatures; - }; - - using PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = PhysicalDeviceTextureCompressionASTCHDRFeatures; - - // wrapper struct for struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.html - struct PhysicalDeviceTileMemoryHeapFeaturesQCOM - { - using NativeType = VkPhysicalDeviceTileMemoryHeapFeaturesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapFeaturesQCOM( Bool32 tileMemoryHeap_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tileMemoryHeap{ tileMemoryHeap_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapFeaturesQCOM( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTileMemoryHeapFeaturesQCOM( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTileMemoryHeapFeaturesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTileMemoryHeapFeaturesQCOM & operator=( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTileMemoryHeapFeaturesQCOM & operator=( VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM & setTileMemoryHeap( Bool32 tileMemoryHeap_ ) & VULKAN_HPP_NOEXCEPT - { - tileMemoryHeap = tileMemoryHeap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapFeaturesQCOM && setTileMemoryHeap( Bool32 tileMemoryHeap_ ) && VULKAN_HPP_NOEXCEPT - { - tileMemoryHeap = tileMemoryHeap_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tileMemoryHeap ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tileMemoryHeap == rhs.tileMemoryHeap ); -# endif - } - - bool operator!=( PhysicalDeviceTileMemoryHeapFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM; - void * pNext = {}; - Bool32 tileMemoryHeap = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTileMemoryHeapFeaturesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTileMemoryHeapFeaturesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileMemoryHeapPropertiesQCOM.html - struct PhysicalDeviceTileMemoryHeapPropertiesQCOM - { - using NativeType = VkPhysicalDeviceTileMemoryHeapPropertiesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapPropertiesQCOM( Bool32 queueSubmitBoundary_ = {}, - Bool32 tileBufferTransfers_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , queueSubmitBoundary{ queueSubmitBoundary_ } - , tileBufferTransfers{ tileBufferTransfers_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTileMemoryHeapPropertiesQCOM( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTileMemoryHeapPropertiesQCOM( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTileMemoryHeapPropertiesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTileMemoryHeapPropertiesQCOM & operator=( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTileMemoryHeapPropertiesQCOM & operator=( VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM & setQueueSubmitBoundary( Bool32 queueSubmitBoundary_ ) & VULKAN_HPP_NOEXCEPT - { - queueSubmitBoundary = queueSubmitBoundary_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM && setQueueSubmitBoundary( Bool32 queueSubmitBoundary_ ) && VULKAN_HPP_NOEXCEPT - { - queueSubmitBoundary = queueSubmitBoundary_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM & setTileBufferTransfers( Bool32 tileBufferTransfers_ ) & VULKAN_HPP_NOEXCEPT - { - tileBufferTransfers = tileBufferTransfers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileMemoryHeapPropertiesQCOM && setTileBufferTransfers( Bool32 tileBufferTransfers_ ) && VULKAN_HPP_NOEXCEPT - { - tileBufferTransfers = tileBufferTransfers_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, queueSubmitBoundary, tileBufferTransfers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueSubmitBoundary == rhs.queueSubmitBoundary ) && - ( tileBufferTransfers == rhs.tileBufferTransfers ); -# endif - } - - bool operator!=( PhysicalDeviceTileMemoryHeapPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM; - void * pNext = {}; - Bool32 queueSubmitBoundary = {}; - Bool32 tileBufferTransfers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTileMemoryHeapPropertiesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTileMemoryHeapPropertiesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceTilePropertiesFeaturesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTilePropertiesFeaturesQCOM.html - struct PhysicalDeviceTilePropertiesFeaturesQCOM - { - using NativeType = VkPhysicalDeviceTilePropertiesFeaturesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTilePropertiesFeaturesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTilePropertiesFeaturesQCOM( Bool32 tileProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tileProperties{ tileProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTilePropertiesFeaturesQCOM( PhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTilePropertiesFeaturesQCOM( VkPhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTilePropertiesFeaturesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTilePropertiesFeaturesQCOM & operator=( PhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTilePropertiesFeaturesQCOM & operator=( VkPhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTilePropertiesFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTilePropertiesFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTilePropertiesFeaturesQCOM & setTileProperties( Bool32 tileProperties_ ) & VULKAN_HPP_NOEXCEPT - { - tileProperties = tileProperties_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTilePropertiesFeaturesQCOM && setTileProperties( Bool32 tileProperties_ ) && VULKAN_HPP_NOEXCEPT - { - tileProperties = tileProperties_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceTilePropertiesFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTilePropertiesFeaturesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTilePropertiesFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTilePropertiesFeaturesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tileProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTilePropertiesFeaturesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tileProperties == rhs.tileProperties ); -# endif - } - - bool operator!=( PhysicalDeviceTilePropertiesFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTilePropertiesFeaturesQCOM; - void * pNext = {}; - Bool32 tileProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTilePropertiesFeaturesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTilePropertiesFeaturesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceTileShadingFeaturesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileShadingFeaturesQCOM.html - struct PhysicalDeviceTileShadingFeaturesQCOM - { - using NativeType = VkPhysicalDeviceTileShadingFeaturesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileShadingFeaturesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingFeaturesQCOM( Bool32 tileShading_ = {}, - Bool32 tileShadingFragmentStage_ = {}, - Bool32 tileShadingColorAttachments_ = {}, - Bool32 tileShadingDepthAttachments_ = {}, - Bool32 tileShadingStencilAttachments_ = {}, - Bool32 tileShadingInputAttachments_ = {}, - Bool32 tileShadingSampledAttachments_ = {}, - Bool32 tileShadingPerTileDraw_ = {}, - Bool32 tileShadingPerTileDispatch_ = {}, - Bool32 tileShadingDispatchTile_ = {}, - Bool32 tileShadingApron_ = {}, - Bool32 tileShadingAnisotropicApron_ = {}, - Bool32 tileShadingAtomicOps_ = {}, - Bool32 tileShadingImageProcessing_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tileShading{ tileShading_ } - , tileShadingFragmentStage{ tileShadingFragmentStage_ } - , tileShadingColorAttachments{ tileShadingColorAttachments_ } - , tileShadingDepthAttachments{ tileShadingDepthAttachments_ } - , tileShadingStencilAttachments{ tileShadingStencilAttachments_ } - , tileShadingInputAttachments{ tileShadingInputAttachments_ } - , tileShadingSampledAttachments{ tileShadingSampledAttachments_ } - , tileShadingPerTileDraw{ tileShadingPerTileDraw_ } - , tileShadingPerTileDispatch{ tileShadingPerTileDispatch_ } - , tileShadingDispatchTile{ tileShadingDispatchTile_ } - , tileShadingApron{ tileShadingApron_ } - , tileShadingAnisotropicApron{ tileShadingAnisotropicApron_ } - , tileShadingAtomicOps{ tileShadingAtomicOps_ } - , tileShadingImageProcessing{ tileShadingImageProcessing_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingFeaturesQCOM( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTileShadingFeaturesQCOM( VkPhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTileShadingFeaturesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTileShadingFeaturesQCOM & operator=( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTileShadingFeaturesQCOM & operator=( VkPhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShading( Bool32 tileShading_ ) & VULKAN_HPP_NOEXCEPT - { - tileShading = tileShading_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShading( Bool32 tileShading_ ) && VULKAN_HPP_NOEXCEPT - { - tileShading = tileShading_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingFragmentStage( Bool32 tileShadingFragmentStage_ ) & VULKAN_HPP_NOEXCEPT - { - tileShadingFragmentStage = tileShadingFragmentStage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingFragmentStage( Bool32 tileShadingFragmentStage_ ) && VULKAN_HPP_NOEXCEPT - { - tileShadingFragmentStage = tileShadingFragmentStage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingColorAttachments( Bool32 tileShadingColorAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - tileShadingColorAttachments = tileShadingColorAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingColorAttachments( Bool32 tileShadingColorAttachments_ ) && - VULKAN_HPP_NOEXCEPT - { - tileShadingColorAttachments = tileShadingColorAttachments_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingDepthAttachments( Bool32 tileShadingDepthAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - tileShadingDepthAttachments = tileShadingDepthAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingDepthAttachments( Bool32 tileShadingDepthAttachments_ ) && - VULKAN_HPP_NOEXCEPT - { - tileShadingDepthAttachments = tileShadingDepthAttachments_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingStencilAttachments( Bool32 tileShadingStencilAttachments_ ) & - VULKAN_HPP_NOEXCEPT - { - tileShadingStencilAttachments = tileShadingStencilAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingStencilAttachments( Bool32 tileShadingStencilAttachments_ ) && - VULKAN_HPP_NOEXCEPT - { - tileShadingStencilAttachments = tileShadingStencilAttachments_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingInputAttachments( Bool32 tileShadingInputAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - tileShadingInputAttachments = tileShadingInputAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingInputAttachments( Bool32 tileShadingInputAttachments_ ) && - VULKAN_HPP_NOEXCEPT - { - tileShadingInputAttachments = tileShadingInputAttachments_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingSampledAttachments( Bool32 tileShadingSampledAttachments_ ) & - VULKAN_HPP_NOEXCEPT - { - tileShadingSampledAttachments = tileShadingSampledAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingSampledAttachments( Bool32 tileShadingSampledAttachments_ ) && - VULKAN_HPP_NOEXCEPT - { - tileShadingSampledAttachments = tileShadingSampledAttachments_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingPerTileDraw( Bool32 tileShadingPerTileDraw_ ) & VULKAN_HPP_NOEXCEPT - { - tileShadingPerTileDraw = tileShadingPerTileDraw_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingPerTileDraw( Bool32 tileShadingPerTileDraw_ ) && VULKAN_HPP_NOEXCEPT - { - tileShadingPerTileDraw = tileShadingPerTileDraw_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingPerTileDispatch( Bool32 tileShadingPerTileDispatch_ ) & VULKAN_HPP_NOEXCEPT - { - tileShadingPerTileDispatch = tileShadingPerTileDispatch_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingPerTileDispatch( Bool32 tileShadingPerTileDispatch_ ) && VULKAN_HPP_NOEXCEPT - { - tileShadingPerTileDispatch = tileShadingPerTileDispatch_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingDispatchTile( Bool32 tileShadingDispatchTile_ ) & VULKAN_HPP_NOEXCEPT - { - tileShadingDispatchTile = tileShadingDispatchTile_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingDispatchTile( Bool32 tileShadingDispatchTile_ ) && VULKAN_HPP_NOEXCEPT - { - tileShadingDispatchTile = tileShadingDispatchTile_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingApron( Bool32 tileShadingApron_ ) & VULKAN_HPP_NOEXCEPT - { - tileShadingApron = tileShadingApron_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingApron( Bool32 tileShadingApron_ ) && VULKAN_HPP_NOEXCEPT - { - tileShadingApron = tileShadingApron_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingAnisotropicApron( Bool32 tileShadingAnisotropicApron_ ) & VULKAN_HPP_NOEXCEPT - { - tileShadingAnisotropicApron = tileShadingAnisotropicApron_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingAnisotropicApron( Bool32 tileShadingAnisotropicApron_ ) && - VULKAN_HPP_NOEXCEPT - { - tileShadingAnisotropicApron = tileShadingAnisotropicApron_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingAtomicOps( Bool32 tileShadingAtomicOps_ ) & VULKAN_HPP_NOEXCEPT - { - tileShadingAtomicOps = tileShadingAtomicOps_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingAtomicOps( Bool32 tileShadingAtomicOps_ ) && VULKAN_HPP_NOEXCEPT - { - tileShadingAtomicOps = tileShadingAtomicOps_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingImageProcessing( Bool32 tileShadingImageProcessing_ ) & VULKAN_HPP_NOEXCEPT - { - tileShadingImageProcessing = tileShadingImageProcessing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM && setTileShadingImageProcessing( Bool32 tileShadingImageProcessing_ ) && VULKAN_HPP_NOEXCEPT - { - tileShadingImageProcessing = tileShadingImageProcessing_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceTileShadingFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileShadingFeaturesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileShadingFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileShadingFeaturesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - tileShading, - tileShadingFragmentStage, - tileShadingColorAttachments, - tileShadingDepthAttachments, - tileShadingStencilAttachments, - tileShadingInputAttachments, - tileShadingSampledAttachments, - tileShadingPerTileDraw, - tileShadingPerTileDispatch, - tileShadingDispatchTile, - tileShadingApron, - tileShadingAnisotropicApron, - tileShadingAtomicOps, - tileShadingImageProcessing ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTileShadingFeaturesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tileShading == rhs.tileShading ) && - ( tileShadingFragmentStage == rhs.tileShadingFragmentStage ) && ( tileShadingColorAttachments == rhs.tileShadingColorAttachments ) && - ( tileShadingDepthAttachments == rhs.tileShadingDepthAttachments ) && ( tileShadingStencilAttachments == rhs.tileShadingStencilAttachments ) && - ( tileShadingInputAttachments == rhs.tileShadingInputAttachments ) && ( tileShadingSampledAttachments == rhs.tileShadingSampledAttachments ) && - ( tileShadingPerTileDraw == rhs.tileShadingPerTileDraw ) && ( tileShadingPerTileDispatch == rhs.tileShadingPerTileDispatch ) && - ( tileShadingDispatchTile == rhs.tileShadingDispatchTile ) && ( tileShadingApron == rhs.tileShadingApron ) && - ( tileShadingAnisotropicApron == rhs.tileShadingAnisotropicApron ) && ( tileShadingAtomicOps == rhs.tileShadingAtomicOps ) && - ( tileShadingImageProcessing == rhs.tileShadingImageProcessing ); -# endif - } - - bool operator!=( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTileShadingFeaturesQCOM; - void * pNext = {}; - Bool32 tileShading = {}; - Bool32 tileShadingFragmentStage = {}; - Bool32 tileShadingColorAttachments = {}; - Bool32 tileShadingDepthAttachments = {}; - Bool32 tileShadingStencilAttachments = {}; - Bool32 tileShadingInputAttachments = {}; - Bool32 tileShadingSampledAttachments = {}; - Bool32 tileShadingPerTileDraw = {}; - Bool32 tileShadingPerTileDispatch = {}; - Bool32 tileShadingDispatchTile = {}; - Bool32 tileShadingApron = {}; - Bool32 tileShadingAnisotropicApron = {}; - Bool32 tileShadingAtomicOps = {}; - Bool32 tileShadingImageProcessing = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTileShadingFeaturesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTileShadingFeaturesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceTileShadingPropertiesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileShadingPropertiesQCOM.html - struct PhysicalDeviceTileShadingPropertiesQCOM - { - using NativeType = VkPhysicalDeviceTileShadingPropertiesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileShadingPropertiesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingPropertiesQCOM( uint32_t maxApronSize_ = {}, - Bool32 preferNonCoherent_ = {}, - Extent2D tileGranularity_ = {}, - Extent2D maxTileShadingRate_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxApronSize{ maxApronSize_ } - , preferNonCoherent{ preferNonCoherent_ } - , tileGranularity{ tileGranularity_ } - , maxTileShadingRate{ maxTileShadingRate_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingPropertiesQCOM( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTileShadingPropertiesQCOM( VkPhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTileShadingPropertiesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTileShadingPropertiesQCOM & operator=( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTileShadingPropertiesQCOM & operator=( VkPhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceTileShadingPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileShadingPropertiesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileShadingPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTileShadingPropertiesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxApronSize, preferNonCoherent, tileGranularity, maxTileShadingRate ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTileShadingPropertiesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxApronSize == rhs.maxApronSize ) && ( preferNonCoherent == rhs.preferNonCoherent ) && - ( tileGranularity == rhs.tileGranularity ) && ( maxTileShadingRate == rhs.maxTileShadingRate ); -# endif - } - - bool operator!=( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTileShadingPropertiesQCOM; - void * pNext = {}; - uint32_t maxApronSize = {}; - Bool32 preferNonCoherent = {}; - Extent2D tileGranularity = {}; - Extent2D maxTileShadingRate = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTileShadingPropertiesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTileShadingPropertiesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceTimelineSemaphoreFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html - struct PhysicalDeviceTimelineSemaphoreFeatures - { - using NativeType = VkPhysicalDeviceTimelineSemaphoreFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTimelineSemaphoreFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeatures( Bool32 timelineSemaphore_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , timelineSemaphore{ timelineSemaphore_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreFeatures( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTimelineSemaphoreFeatures( VkPhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTimelineSemaphoreFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTimelineSemaphoreFeatures & operator=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTimelineSemaphoreFeatures & operator=( VkPhysicalDeviceTimelineSemaphoreFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTimelineSemaphoreFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTimelineSemaphoreFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTimelineSemaphoreFeatures & setTimelineSemaphore( Bool32 timelineSemaphore_ ) & VULKAN_HPP_NOEXCEPT - { - timelineSemaphore = timelineSemaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTimelineSemaphoreFeatures && setTimelineSemaphore( Bool32 timelineSemaphore_ ) && VULKAN_HPP_NOEXCEPT - { - timelineSemaphore = timelineSemaphore_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceTimelineSemaphoreFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTimelineSemaphoreFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTimelineSemaphoreFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTimelineSemaphoreFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, timelineSemaphore ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTimelineSemaphoreFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timelineSemaphore == rhs.timelineSemaphore ); -# endif - } - - bool operator!=( PhysicalDeviceTimelineSemaphoreFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreFeatures; - void * pNext = {}; - Bool32 timelineSemaphore = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTimelineSemaphoreFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTimelineSemaphoreFeatures; - }; - - using PhysicalDeviceTimelineSemaphoreFeaturesKHR = PhysicalDeviceTimelineSemaphoreFeatures; - - // wrapper struct for struct VkPhysicalDeviceTimelineSemaphoreProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTimelineSemaphoreProperties.html - struct PhysicalDeviceTimelineSemaphoreProperties - { - using NativeType = VkPhysicalDeviceTimelineSemaphoreProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTimelineSemaphoreProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreProperties( uint64_t maxTimelineSemaphoreValueDifference_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxTimelineSemaphoreValueDifference{ maxTimelineSemaphoreValueDifference_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTimelineSemaphoreProperties( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTimelineSemaphoreProperties( VkPhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTimelineSemaphoreProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTimelineSemaphoreProperties & operator=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTimelineSemaphoreProperties & operator=( VkPhysicalDeviceTimelineSemaphoreProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceTimelineSemaphoreProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTimelineSemaphoreProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTimelineSemaphoreProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTimelineSemaphoreProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxTimelineSemaphoreValueDifference ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTimelineSemaphoreProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ); -# endif - } - - bool operator!=( PhysicalDeviceTimelineSemaphoreProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTimelineSemaphoreProperties; - void * pNext = {}; - uint64_t maxTimelineSemaphoreValueDifference = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTimelineSemaphoreProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTimelineSemaphoreProperties; - }; - - using PhysicalDeviceTimelineSemaphorePropertiesKHR = PhysicalDeviceTimelineSemaphoreProperties; - - // wrapper struct for struct VkPhysicalDeviceToolProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceToolProperties.html - struct PhysicalDeviceToolProperties - { - using NativeType = VkPhysicalDeviceToolProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceToolProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceToolProperties( std::array const & name_ = {}, - std::array const & version_ = {}, - ToolPurposeFlags purposes_ = {}, - std::array const & description_ = {}, - std::array const & layer_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , name{ name_ } - , version{ version_ } - , purposes{ purposes_ } - , description{ description_ } - , layer{ layer_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceToolProperties( PhysicalDeviceToolProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceToolProperties( VkPhysicalDeviceToolProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceToolProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceToolProperties & operator=( PhysicalDeviceToolProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceToolProperties & operator=( VkPhysicalDeviceToolProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceToolProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceToolProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceToolProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceToolProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &, - ToolPurposeFlags const &, - ArrayWrapper1D const &, - ArrayWrapper1D const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, name, version, purposes, description, layer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PhysicalDeviceToolProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = strcmp( version, rhs.version ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = purposes <=> rhs.purposes; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = strcmp( layer, rhs.layer ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( PhysicalDeviceToolProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( strcmp( name, rhs.name ) == 0 ) && ( strcmp( version, rhs.version ) == 0 ) && - ( purposes == rhs.purposes ) && ( strcmp( description, rhs.description ) == 0 ) && ( strcmp( layer, rhs.layer ) == 0 ); - } - - bool operator!=( PhysicalDeviceToolProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::ePhysicalDeviceToolProperties; - void * pNext = {}; - ArrayWrapper1D name = {}; - ArrayWrapper1D version = {}; - ToolPurposeFlags purposes = {}; - ArrayWrapper1D description = {}; - ArrayWrapper1D layer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceToolProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceToolProperties; - }; - - using PhysicalDeviceToolPropertiesEXT = PhysicalDeviceToolProperties; - - // wrapper struct for struct VkPhysicalDeviceTransformFeedbackFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTransformFeedbackFeaturesEXT.html - struct PhysicalDeviceTransformFeedbackFeaturesEXT - { - using NativeType = VkPhysicalDeviceTransformFeedbackFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PhysicalDeviceTransformFeedbackFeaturesEXT( Bool32 transformFeedback_ = {}, Bool32 geometryStreams_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , transformFeedback{ transformFeedback_ } - , geometryStreams{ geometryStreams_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackFeaturesEXT( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTransformFeedbackFeaturesEXT( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTransformFeedbackFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTransformFeedbackFeaturesEXT & operator=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTransformFeedbackFeaturesEXT & operator=( VkPhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT & setTransformFeedback( Bool32 transformFeedback_ ) & VULKAN_HPP_NOEXCEPT - { - transformFeedback = transformFeedback_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT && setTransformFeedback( Bool32 transformFeedback_ ) && VULKAN_HPP_NOEXCEPT - { - transformFeedback = transformFeedback_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT & setGeometryStreams( Bool32 geometryStreams_ ) & VULKAN_HPP_NOEXCEPT - { - geometryStreams = geometryStreams_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTransformFeedbackFeaturesEXT && setGeometryStreams( Bool32 geometryStreams_ ) && VULKAN_HPP_NOEXCEPT - { - geometryStreams = geometryStreams_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTransformFeedbackFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTransformFeedbackFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTransformFeedbackFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, transformFeedback, geometryStreams ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTransformFeedbackFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transformFeedback == rhs.transformFeedback ) && ( geometryStreams == rhs.geometryStreams ); -# endif - } - - bool operator!=( PhysicalDeviceTransformFeedbackFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT; - void * pNext = {}; - Bool32 transformFeedback = {}; - Bool32 geometryStreams = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTransformFeedbackFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTransformFeedbackFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceTransformFeedbackPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTransformFeedbackPropertiesEXT.html - struct PhysicalDeviceTransformFeedbackPropertiesEXT - { - using NativeType = VkPhysicalDeviceTransformFeedbackPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackPropertiesEXT( uint32_t maxTransformFeedbackStreams_ = {}, - uint32_t maxTransformFeedbackBuffers_ = {}, - DeviceSize maxTransformFeedbackBufferSize_ = {}, - uint32_t maxTransformFeedbackStreamDataSize_ = {}, - uint32_t maxTransformFeedbackBufferDataSize_ = {}, - uint32_t maxTransformFeedbackBufferDataStride_ = {}, - Bool32 transformFeedbackQueries_ = {}, - Bool32 transformFeedbackStreamsLinesTriangles_ = {}, - Bool32 transformFeedbackRasterizationStreamSelect_ = {}, - Bool32 transformFeedbackDraw_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxTransformFeedbackStreams{ maxTransformFeedbackStreams_ } - , maxTransformFeedbackBuffers{ maxTransformFeedbackBuffers_ } - , maxTransformFeedbackBufferSize{ maxTransformFeedbackBufferSize_ } - , maxTransformFeedbackStreamDataSize{ maxTransformFeedbackStreamDataSize_ } - , maxTransformFeedbackBufferDataSize{ maxTransformFeedbackBufferDataSize_ } - , maxTransformFeedbackBufferDataStride{ maxTransformFeedbackBufferDataStride_ } - , transformFeedbackQueries{ transformFeedbackQueries_ } - , transformFeedbackStreamsLinesTriangles{ transformFeedbackStreamsLinesTriangles_ } - , transformFeedbackRasterizationStreamSelect{ transformFeedbackRasterizationStreamSelect_ } - , transformFeedbackDraw{ transformFeedbackDraw_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceTransformFeedbackPropertiesEXT( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceTransformFeedbackPropertiesEXT( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceTransformFeedbackPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceTransformFeedbackPropertiesEXT & operator=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceTransformFeedbackPropertiesEXT & operator=( VkPhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTransformFeedbackPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTransformFeedbackPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceTransformFeedbackPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - maxTransformFeedbackStreams, - maxTransformFeedbackBuffers, - maxTransformFeedbackBufferSize, - maxTransformFeedbackStreamDataSize, - maxTransformFeedbackBufferDataSize, - maxTransformFeedbackBufferDataStride, - transformFeedbackQueries, - transformFeedbackStreamsLinesTriangles, - transformFeedbackRasterizationStreamSelect, - transformFeedbackDraw ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceTransformFeedbackPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxTransformFeedbackStreams == rhs.maxTransformFeedbackStreams ) && - ( maxTransformFeedbackBuffers == rhs.maxTransformFeedbackBuffers ) && ( maxTransformFeedbackBufferSize == rhs.maxTransformFeedbackBufferSize ) && - ( maxTransformFeedbackStreamDataSize == rhs.maxTransformFeedbackStreamDataSize ) && - ( maxTransformFeedbackBufferDataSize == rhs.maxTransformFeedbackBufferDataSize ) && - ( maxTransformFeedbackBufferDataStride == rhs.maxTransformFeedbackBufferDataStride ) && - ( transformFeedbackQueries == rhs.transformFeedbackQueries ) && - ( transformFeedbackStreamsLinesTriangles == rhs.transformFeedbackStreamsLinesTriangles ) && - ( transformFeedbackRasterizationStreamSelect == rhs.transformFeedbackRasterizationStreamSelect ) && - ( transformFeedbackDraw == rhs.transformFeedbackDraw ); -# endif - } - - bool operator!=( PhysicalDeviceTransformFeedbackPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT; - void * pNext = {}; - uint32_t maxTransformFeedbackStreams = {}; - uint32_t maxTransformFeedbackBuffers = {}; - DeviceSize maxTransformFeedbackBufferSize = {}; - uint32_t maxTransformFeedbackStreamDataSize = {}; - uint32_t maxTransformFeedbackBufferDataSize = {}; - uint32_t maxTransformFeedbackBufferDataStride = {}; - Bool32 transformFeedbackQueries = {}; - Bool32 transformFeedbackStreamsLinesTriangles = {}; - Bool32 transformFeedbackRasterizationStreamSelect = {}; - Bool32 transformFeedbackDraw = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceTransformFeedbackPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceTransformFeedbackPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR.html - struct PhysicalDeviceUnifiedImageLayoutsFeaturesKHR - { - using NativeType = VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceUnifiedImageLayoutsFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceUnifiedImageLayoutsFeaturesKHR( Bool32 unifiedImageLayouts_ = {}, - Bool32 unifiedImageLayoutsVideo_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , unifiedImageLayouts{ unifiedImageLayouts_ } - , unifiedImageLayoutsVideo{ unifiedImageLayoutsVideo_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceUnifiedImageLayoutsFeaturesKHR( PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceUnifiedImageLayoutsFeaturesKHR( VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceUnifiedImageLayoutsFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceUnifiedImageLayoutsFeaturesKHR & operator=( PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceUnifiedImageLayoutsFeaturesKHR & operator=( VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR & setUnifiedImageLayouts( Bool32 unifiedImageLayouts_ ) & VULKAN_HPP_NOEXCEPT - { - unifiedImageLayouts = unifiedImageLayouts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR && setUnifiedImageLayouts( Bool32 unifiedImageLayouts_ ) && VULKAN_HPP_NOEXCEPT - { - unifiedImageLayouts = unifiedImageLayouts_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR & setUnifiedImageLayoutsVideo( Bool32 unifiedImageLayoutsVideo_ ) & VULKAN_HPP_NOEXCEPT - { - unifiedImageLayoutsVideo = unifiedImageLayoutsVideo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUnifiedImageLayoutsFeaturesKHR && setUnifiedImageLayoutsVideo( Bool32 unifiedImageLayoutsVideo_ ) && - VULKAN_HPP_NOEXCEPT - { - unifiedImageLayoutsVideo = unifiedImageLayoutsVideo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, unifiedImageLayouts, unifiedImageLayoutsVideo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( unifiedImageLayouts == rhs.unifiedImageLayouts ) && - ( unifiedImageLayoutsVideo == rhs.unifiedImageLayoutsVideo ); -# endif - } - - bool operator!=( PhysicalDeviceUnifiedImageLayoutsFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceUnifiedImageLayoutsFeaturesKHR; - void * pNext = {}; - Bool32 unifiedImageLayouts = {}; - Bool32 unifiedImageLayoutsVideo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceUnifiedImageLayoutsFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceUnifiedImageLayoutsFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceUniformBufferStandardLayoutFeatures.html - struct PhysicalDeviceUniformBufferStandardLayoutFeatures - { - using NativeType = VkPhysicalDeviceUniformBufferStandardLayoutFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceUniformBufferStandardLayoutFeatures( Bool32 uniformBufferStandardLayout_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , uniformBufferStandardLayout{ uniformBufferStandardLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceUniformBufferStandardLayoutFeatures( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceUniformBufferStandardLayoutFeatures( VkPhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceUniformBufferStandardLayoutFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceUniformBufferStandardLayoutFeatures & - operator=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceUniformBufferStandardLayoutFeatures & operator=( VkPhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUniformBufferStandardLayoutFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUniformBufferStandardLayoutFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUniformBufferStandardLayoutFeatures & setUniformBufferStandardLayout( Bool32 uniformBufferStandardLayout_ ) & - VULKAN_HPP_NOEXCEPT - { - uniformBufferStandardLayout = uniformBufferStandardLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceUniformBufferStandardLayoutFeatures && setUniformBufferStandardLayout( Bool32 uniformBufferStandardLayout_ ) && - VULKAN_HPP_NOEXCEPT - { - uniformBufferStandardLayout = uniformBufferStandardLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceUniformBufferStandardLayoutFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, uniformBufferStandardLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceUniformBufferStandardLayoutFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ); -# endif - } - - bool operator!=( PhysicalDeviceUniformBufferStandardLayoutFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures; - void * pNext = {}; - Bool32 uniformBufferStandardLayout = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceUniformBufferStandardLayoutFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceUniformBufferStandardLayoutFeatures; - }; - - using PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = PhysicalDeviceUniformBufferStandardLayoutFeatures; - - // wrapper struct for struct VkPhysicalDeviceVariablePointersFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVariablePointersFeatures.html - struct PhysicalDeviceVariablePointersFeatures - { - using NativeType = VkPhysicalDeviceVariablePointersFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVariablePointersFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( Bool32 variablePointersStorageBuffer_ = {}, - Bool32 variablePointers_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , variablePointersStorageBuffer{ variablePointersStorageBuffer_ } - , variablePointers{ variablePointers_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVariablePointersFeatures( PhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVariablePointersFeatures( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVariablePointersFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVariablePointersFeatures & operator=( PhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVariablePointersFeatures & operator=( VkPhysicalDeviceVariablePointersFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures & setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) & - VULKAN_HPP_NOEXCEPT - { - variablePointersStorageBuffer = variablePointersStorageBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures && setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) && - VULKAN_HPP_NOEXCEPT - { - variablePointersStorageBuffer = variablePointersStorageBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures & setVariablePointers( Bool32 variablePointers_ ) & VULKAN_HPP_NOEXCEPT - { - variablePointers = variablePointers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVariablePointersFeatures && setVariablePointers( Bool32 variablePointers_ ) && VULKAN_HPP_NOEXCEPT - { - variablePointers = variablePointers_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVariablePointersFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVariablePointersFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVariablePointersFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVariablePointersFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, variablePointersStorageBuffer, variablePointers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVariablePointersFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) && - ( variablePointers == rhs.variablePointers ); -# endif - } - - bool operator!=( PhysicalDeviceVariablePointersFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVariablePointersFeatures; - void * pNext = {}; - Bool32 variablePointersStorageBuffer = {}; - Bool32 variablePointers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVariablePointersFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVariablePointersFeatures; - }; - - using PhysicalDeviceVariablePointerFeatures = PhysicalDeviceVariablePointersFeatures; - using PhysicalDeviceVariablePointerFeaturesKHR = PhysicalDeviceVariablePointersFeatures; - using PhysicalDeviceVariablePointersFeaturesKHR = PhysicalDeviceVariablePointersFeatures; - - // wrapper struct for struct VkPhysicalDeviceVertexAttributeDivisorFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorFeatures.html - struct PhysicalDeviceVertexAttributeDivisorFeatures - { - using NativeType = VkPhysicalDeviceVertexAttributeDivisorFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeatures( Bool32 vertexAttributeInstanceRateDivisor_ = {}, - Bool32 vertexAttributeInstanceRateZeroDivisor_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vertexAttributeInstanceRateDivisor{ vertexAttributeInstanceRateDivisor_ } - , vertexAttributeInstanceRateZeroDivisor{ vertexAttributeInstanceRateZeroDivisor_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorFeatures( PhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVertexAttributeDivisorFeatures( VkPhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVertexAttributeDivisorFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVertexAttributeDivisorFeatures & operator=( PhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVertexAttributeDivisorFeatures & operator=( VkPhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures & setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures && - setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures & - setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeDivisorFeatures && - setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVertexAttributeDivisorFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeDivisorFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeDivisorFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeDivisorFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, vertexAttributeInstanceRateDivisor, vertexAttributeInstanceRateZeroDivisor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVertexAttributeDivisorFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) && - ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor ); -# endif - } - - bool operator!=( PhysicalDeviceVertexAttributeDivisorFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorFeatures; - void * pNext = {}; - Bool32 vertexAttributeInstanceRateDivisor = {}; - Bool32 vertexAttributeInstanceRateZeroDivisor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVertexAttributeDivisorFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVertexAttributeDivisorFeatures; - }; - - using PhysicalDeviceVertexAttributeDivisorFeaturesEXT = PhysicalDeviceVertexAttributeDivisorFeatures; - using PhysicalDeviceVertexAttributeDivisorFeaturesKHR = PhysicalDeviceVertexAttributeDivisorFeatures; - - // wrapper struct for struct VkPhysicalDeviceVertexAttributeDivisorProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorProperties.html - struct PhysicalDeviceVertexAttributeDivisorProperties - { - using NativeType = VkPhysicalDeviceVertexAttributeDivisorProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeDivisorProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorProperties( uint32_t maxVertexAttribDivisor_ = {}, - Bool32 supportsNonZeroFirstInstance_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxVertexAttribDivisor{ maxVertexAttribDivisor_ } - , supportsNonZeroFirstInstance{ supportsNonZeroFirstInstance_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceVertexAttributeDivisorProperties( PhysicalDeviceVertexAttributeDivisorProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVertexAttributeDivisorProperties( VkPhysicalDeviceVertexAttributeDivisorProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVertexAttributeDivisorProperties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVertexAttributeDivisorProperties & operator=( PhysicalDeviceVertexAttributeDivisorProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVertexAttributeDivisorProperties & operator=( VkPhysicalDeviceVertexAttributeDivisorProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceVertexAttributeDivisorProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeDivisorProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeDivisorProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeDivisorProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxVertexAttribDivisor, supportsNonZeroFirstInstance ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVertexAttributeDivisorProperties const & ) const = default; -#else - bool operator==( PhysicalDeviceVertexAttributeDivisorProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ) && - ( supportsNonZeroFirstInstance == rhs.supportsNonZeroFirstInstance ); -# endif - } - - bool operator!=( PhysicalDeviceVertexAttributeDivisorProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorProperties; - void * pNext = {}; - uint32_t maxVertexAttribDivisor = {}; - Bool32 supportsNonZeroFirstInstance = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVertexAttributeDivisorProperties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVertexAttributeDivisorProperties; - }; - - using PhysicalDeviceVertexAttributeDivisorPropertiesKHR = PhysicalDeviceVertexAttributeDivisorProperties; - - // wrapper struct for struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.html - struct PhysicalDeviceVertexAttributeDivisorPropertiesEXT - { - using NativeType = VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeDivisorPropertiesEXT( uint32_t maxVertexAttribDivisor_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxVertexAttribDivisor{ maxVertexAttribDivisor_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceVertexAttributeDivisorPropertiesEXT( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVertexAttributeDivisorPropertiesEXT( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVertexAttributeDivisorPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVertexAttributeDivisorPropertiesEXT & - operator=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVertexAttributeDivisorPropertiesEXT & operator=( VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxVertexAttribDivisor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ); -# endif - } - - bool operator!=( PhysicalDeviceVertexAttributeDivisorPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT; - void * pNext = {}; - uint32_t maxVertexAttribDivisor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVertexAttributeDivisorPropertiesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.html - struct PhysicalDeviceVertexAttributeRobustnessFeaturesEXT - { - using NativeType = VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexAttributeRobustnessFeaturesEXT( Bool32 vertexAttributeRobustness_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vertexAttributeRobustness{ vertexAttributeRobustness_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceVertexAttributeRobustnessFeaturesEXT( PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVertexAttributeRobustnessFeaturesEXT( VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVertexAttributeRobustnessFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVertexAttributeRobustnessFeaturesEXT & - operator=( PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVertexAttributeRobustnessFeaturesEXT & operator=( VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeRobustnessFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeRobustnessFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeRobustnessFeaturesEXT & setVertexAttributeRobustness( Bool32 vertexAttributeRobustness_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexAttributeRobustness = vertexAttributeRobustness_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexAttributeRobustnessFeaturesEXT && setVertexAttributeRobustness( Bool32 vertexAttributeRobustness_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexAttributeRobustness = vertexAttributeRobustness_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, vertexAttributeRobustness ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexAttributeRobustness == rhs.vertexAttributeRobustness ); -# endif - } - - bool operator!=( PhysicalDeviceVertexAttributeRobustnessFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT; - void * pNext = {}; - Bool32 vertexAttributeRobustness = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVertexAttributeRobustnessFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVertexAttributeRobustnessFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.html - struct PhysicalDeviceVertexInputDynamicStateFeaturesEXT - { - using NativeType = VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVertexInputDynamicStateFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVertexInputDynamicStateFeaturesEXT( Bool32 vertexInputDynamicState_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vertexInputDynamicState{ vertexInputDynamicState_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceVertexInputDynamicStateFeaturesEXT( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVertexInputDynamicStateFeaturesEXT( VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVertexInputDynamicStateFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVertexInputDynamicStateFeaturesEXT & operator=( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVertexInputDynamicStateFeaturesEXT & operator=( VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexInputDynamicStateFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexInputDynamicStateFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexInputDynamicStateFeaturesEXT & setVertexInputDynamicState( Bool32 vertexInputDynamicState_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexInputDynamicState = vertexInputDynamicState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVertexInputDynamicStateFeaturesEXT && setVertexInputDynamicState( Bool32 vertexInputDynamicState_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexInputDynamicState = vertexInputDynamicState_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, vertexInputDynamicState ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexInputDynamicState == rhs.vertexInputDynamicState ); -# endif - } - - bool operator!=( PhysicalDeviceVertexInputDynamicStateFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVertexInputDynamicStateFeaturesEXT; - void * pNext = {}; - Bool32 vertexInputDynamicState = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVertexInputDynamicStateFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVertexInputDynamicStateFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoDecodeVP9FeaturesKHR.html - struct PhysicalDeviceVideoDecodeVP9FeaturesKHR - { - using NativeType = VkPhysicalDeviceVideoDecodeVP9FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoDecodeVp9FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoDecodeVP9FeaturesKHR( Bool32 videoDecodeVP9_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoDecodeVP9{ videoDecodeVP9_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoDecodeVP9FeaturesKHR( PhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVideoDecodeVP9FeaturesKHR( VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVideoDecodeVP9FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVideoDecodeVP9FeaturesKHR & operator=( PhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVideoDecodeVP9FeaturesKHR & operator=( VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoDecodeVP9FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoDecodeVP9FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoDecodeVP9FeaturesKHR & setVideoDecodeVP9( Bool32 videoDecodeVP9_ ) & VULKAN_HPP_NOEXCEPT - { - videoDecodeVP9 = videoDecodeVP9_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoDecodeVP9FeaturesKHR && setVideoDecodeVP9( Bool32 videoDecodeVP9_ ) && VULKAN_HPP_NOEXCEPT - { - videoDecodeVP9 = videoDecodeVP9_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoDecodeVP9FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoDecodeVP9FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoDecodeVP9 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVideoDecodeVP9FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoDecodeVP9 == rhs.videoDecodeVP9 ); -# endif - } - - bool operator!=( PhysicalDeviceVideoDecodeVP9FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVideoDecodeVp9FeaturesKHR; - void * pNext = {}; - Bool32 videoDecodeVP9 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVideoDecodeVP9FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVideoDecodeVP9FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.html - struct PhysicalDeviceVideoEncodeAV1FeaturesKHR - { - using NativeType = VkPhysicalDeviceVideoEncodeAV1FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeAv1FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeAV1FeaturesKHR( Bool32 videoEncodeAV1_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoEncodeAV1{ videoEncodeAV1_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeAV1FeaturesKHR( PhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVideoEncodeAV1FeaturesKHR( VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVideoEncodeAV1FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVideoEncodeAV1FeaturesKHR & operator=( PhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVideoEncodeAV1FeaturesKHR & operator=( VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeAV1FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeAV1FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeAV1FeaturesKHR & setVideoEncodeAV1( Bool32 videoEncodeAV1_ ) & VULKAN_HPP_NOEXCEPT - { - videoEncodeAV1 = videoEncodeAV1_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeAV1FeaturesKHR && setVideoEncodeAV1( Bool32 videoEncodeAV1_ ) && VULKAN_HPP_NOEXCEPT - { - videoEncodeAV1 = videoEncodeAV1_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeAV1FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeAV1FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoEncodeAV1 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVideoEncodeAV1FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoEncodeAV1 == rhs.videoEncodeAV1 ); -# endif - } - - bool operator!=( PhysicalDeviceVideoEncodeAV1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVideoEncodeAv1FeaturesKHR; - void * pNext = {}; - Bool32 videoEncodeAV1 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVideoEncodeAV1FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVideoEncodeAV1FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR.html - struct PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR - { - using NativeType = VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR( Bool32 videoEncodeIntraRefresh_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoEncodeIntraRefresh{ videoEncodeIntraRefresh_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR( PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR( VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR & operator=( PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR & operator=( VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR & setVideoEncodeIntraRefresh( Bool32 videoEncodeIntraRefresh_ ) & - VULKAN_HPP_NOEXCEPT - { - videoEncodeIntraRefresh = videoEncodeIntraRefresh_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR && setVideoEncodeIntraRefresh( Bool32 videoEncodeIntraRefresh_ ) && - VULKAN_HPP_NOEXCEPT - { - videoEncodeIntraRefresh = videoEncodeIntraRefresh_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoEncodeIntraRefresh ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoEncodeIntraRefresh == rhs.videoEncodeIntraRefresh ); -# endif - } - - bool operator!=( PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; - void * pNext = {}; - Bool32 videoEncodeIntraRefresh = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR; - }; - - // wrapper struct for struct VkVideoProfileInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoProfileInfoKHR.html - struct VideoProfileInfoKHR - { - using NativeType = VkVideoProfileInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoProfileInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR( VideoCodecOperationFlagBitsKHR videoCodecOperation_ = VideoCodecOperationFlagBitsKHR::eNone, - VideoChromaSubsamplingFlagsKHR chromaSubsampling_ = {}, - VideoComponentBitDepthFlagsKHR lumaBitDepth_ = {}, - VideoComponentBitDepthFlagsKHR chromaBitDepth_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoCodecOperation{ videoCodecOperation_ } - , chromaSubsampling{ chromaSubsampling_ } - , lumaBitDepth{ lumaBitDepth_ } - , chromaBitDepth{ chromaBitDepth_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoProfileInfoKHR( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoProfileInfoKHR( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoProfileInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoProfileInfoKHR & operator=( VideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoProfileInfoKHR & operator=( VkVideoProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setVideoCodecOperation( VideoCodecOperationFlagBitsKHR videoCodecOperation_ ) & VULKAN_HPP_NOEXCEPT - { - videoCodecOperation = videoCodecOperation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR && setVideoCodecOperation( VideoCodecOperationFlagBitsKHR videoCodecOperation_ ) && VULKAN_HPP_NOEXCEPT - { - videoCodecOperation = videoCodecOperation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setChromaSubsampling( VideoChromaSubsamplingFlagsKHR chromaSubsampling_ ) & VULKAN_HPP_NOEXCEPT - { - chromaSubsampling = chromaSubsampling_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR && setChromaSubsampling( VideoChromaSubsamplingFlagsKHR chromaSubsampling_ ) && VULKAN_HPP_NOEXCEPT - { - chromaSubsampling = chromaSubsampling_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setLumaBitDepth( VideoComponentBitDepthFlagsKHR lumaBitDepth_ ) & VULKAN_HPP_NOEXCEPT - { - lumaBitDepth = lumaBitDepth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR && setLumaBitDepth( VideoComponentBitDepthFlagsKHR lumaBitDepth_ ) && VULKAN_HPP_NOEXCEPT - { - lumaBitDepth = lumaBitDepth_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR & setChromaBitDepth( VideoComponentBitDepthFlagsKHR chromaBitDepth_ ) & VULKAN_HPP_NOEXCEPT - { - chromaBitDepth = chromaBitDepth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileInfoKHR && setChromaBitDepth( VideoComponentBitDepthFlagsKHR chromaBitDepth_ ) && VULKAN_HPP_NOEXCEPT - { - chromaBitDepth = chromaBitDepth_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoProfileInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoProfileInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoCodecOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoProfileInfoKHR const & ) const = default; -#else - bool operator==( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperation == rhs.videoCodecOperation ) && - ( chromaSubsampling == rhs.chromaSubsampling ) && ( lumaBitDepth == rhs.lumaBitDepth ) && ( chromaBitDepth == rhs.chromaBitDepth ); -# endif - } - - bool operator!=( VideoProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoProfileInfoKHR; - const void * pNext = {}; - VideoCodecOperationFlagBitsKHR videoCodecOperation = VideoCodecOperationFlagBitsKHR::eNone; - VideoChromaSubsamplingFlagsKHR chromaSubsampling = {}; - VideoComponentBitDepthFlagsKHR lumaBitDepth = {}; - VideoComponentBitDepthFlagsKHR chromaBitDepth = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoProfileInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoProfileInfoKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR.html - struct PhysicalDeviceVideoEncodeQualityLevelInfoKHR - { - using NativeType = VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeQualityLevelInfoKHR( const VideoProfileInfoKHR * pVideoProfile_ = {}, - uint32_t qualityLevel_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pVideoProfile{ pVideoProfile_ } - , qualityLevel{ qualityLevel_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeQualityLevelInfoKHR( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVideoEncodeQualityLevelInfoKHR( VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVideoEncodeQualityLevelInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVideoEncodeQualityLevelInfoKHR & operator=( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVideoEncodeQualityLevelInfoKHR & operator=( VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR & setPVideoProfile( const VideoProfileInfoKHR * pVideoProfile_ ) & VULKAN_HPP_NOEXCEPT - { - pVideoProfile = pVideoProfile_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR && setPVideoProfile( const VideoProfileInfoKHR * pVideoProfile_ ) && - VULKAN_HPP_NOEXCEPT - { - pVideoProfile = pVideoProfile_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR & setQualityLevel( uint32_t qualityLevel_ ) & VULKAN_HPP_NOEXCEPT - { - qualityLevel = qualityLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQualityLevelInfoKHR && setQualityLevel( uint32_t qualityLevel_ ) && VULKAN_HPP_NOEXCEPT - { - qualityLevel = qualityLevel_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pVideoProfile, qualityLevel ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pVideoProfile == rhs.pVideoProfile ) && ( qualityLevel == rhs.qualityLevel ); -# endif - } - - bool operator!=( PhysicalDeviceVideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR; - const void * pNext = {}; - const VideoProfileInfoKHR * pVideoProfile = {}; - uint32_t qualityLevel = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVideoEncodeQualityLevelInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVideoEncodeQualityLevelInfoKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.html - struct PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR - { - using NativeType = VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR( Bool32 videoEncodeQuantizationMap_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoEncodeQuantizationMap{ videoEncodeQuantizationMap_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR( PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR( VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR & - operator=( PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR & operator=( VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR & setVideoEncodeQuantizationMap( Bool32 videoEncodeQuantizationMap_ ) & - VULKAN_HPP_NOEXCEPT - { - videoEncodeQuantizationMap = videoEncodeQuantizationMap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR && setVideoEncodeQuantizationMap( Bool32 videoEncodeQuantizationMap_ ) && - VULKAN_HPP_NOEXCEPT - { - videoEncodeQuantizationMap = videoEncodeQuantizationMap_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoEncodeQuantizationMap ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoEncodeQuantizationMap == rhs.videoEncodeQuantizationMap ); -# endif - } - - bool operator!=( PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; - void * pNext = {}; - Bool32 videoEncodeQuantizationMap = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE.html - struct PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE - { - using NativeType = VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( Bool32 videoEncodeRgbConversion_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoEncodeRgbConversion{ videoEncodeRgbConversion_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE & - operator=( PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE & operator=( VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE & setVideoEncodeRgbConversion( Bool32 videoEncodeRgbConversion_ ) & - VULKAN_HPP_NOEXCEPT - { - videoEncodeRgbConversion = videoEncodeRgbConversion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE && setVideoEncodeRgbConversion( Bool32 videoEncodeRgbConversion_ ) && - VULKAN_HPP_NOEXCEPT - { - videoEncodeRgbConversion = videoEncodeRgbConversion_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoEncodeRgbConversion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & ) const = default; -#else - bool operator==( PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoEncodeRgbConversion == rhs.videoEncodeRgbConversion ); -# endif - } - - bool operator!=( PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; - void * pNext = {}; - Bool32 videoEncodeRgbConversion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE; - }; - - // wrapper struct for struct VkPhysicalDeviceVideoFormatInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoFormatInfoKHR.html - struct PhysicalDeviceVideoFormatInfoKHR - { - using NativeType = VkPhysicalDeviceVideoFormatInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoFormatInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoFormatInfoKHR( ImageUsageFlags imageUsage_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageUsage{ imageUsage_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoFormatInfoKHR( PhysicalDeviceVideoFormatInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVideoFormatInfoKHR( VkPhysicalDeviceVideoFormatInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVideoFormatInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVideoFormatInfoKHR & operator=( PhysicalDeviceVideoFormatInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVideoFormatInfoKHR & operator=( VkPhysicalDeviceVideoFormatInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoFormatInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoFormatInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoFormatInfoKHR & setImageUsage( ImageUsageFlags imageUsage_ ) & VULKAN_HPP_NOEXCEPT - { - imageUsage = imageUsage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoFormatInfoKHR && setImageUsage( ImageUsageFlags imageUsage_ ) && VULKAN_HPP_NOEXCEPT - { - imageUsage = imageUsage_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVideoFormatInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoFormatInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoFormatInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoFormatInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageUsage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVideoFormatInfoKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageUsage == rhs.imageUsage ); -# endif - } - - bool operator!=( PhysicalDeviceVideoFormatInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVideoFormatInfoKHR; - const void * pNext = {}; - ImageUsageFlags imageUsage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVideoFormatInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVideoFormatInfoKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoMaintenance1FeaturesKHR.html - struct PhysicalDeviceVideoMaintenance1FeaturesKHR - { - using NativeType = VkPhysicalDeviceVideoMaintenance1FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoMaintenance1FeaturesKHR( Bool32 videoMaintenance1_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoMaintenance1{ videoMaintenance1_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoMaintenance1FeaturesKHR( PhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVideoMaintenance1FeaturesKHR( VkPhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVideoMaintenance1FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVideoMaintenance1FeaturesKHR & operator=( PhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVideoMaintenance1FeaturesKHR & operator=( VkPhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance1FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance1FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance1FeaturesKHR & setVideoMaintenance1( Bool32 videoMaintenance1_ ) & VULKAN_HPP_NOEXCEPT - { - videoMaintenance1 = videoMaintenance1_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance1FeaturesKHR && setVideoMaintenance1( Bool32 videoMaintenance1_ ) && VULKAN_HPP_NOEXCEPT - { - videoMaintenance1 = videoMaintenance1_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVideoMaintenance1FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoMaintenance1FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoMaintenance1FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoMaintenance1FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoMaintenance1 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVideoMaintenance1FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoMaintenance1 == rhs.videoMaintenance1 ); -# endif - } - - bool operator!=( PhysicalDeviceVideoMaintenance1FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR; - void * pNext = {}; - Bool32 videoMaintenance1 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVideoMaintenance1FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVideoMaintenance1FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVideoMaintenance2FeaturesKHR.html - struct PhysicalDeviceVideoMaintenance2FeaturesKHR - { - using NativeType = VkPhysicalDeviceVideoMaintenance2FeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVideoMaintenance2FeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoMaintenance2FeaturesKHR( Bool32 videoMaintenance2_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoMaintenance2{ videoMaintenance2_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVideoMaintenance2FeaturesKHR( PhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVideoMaintenance2FeaturesKHR( VkPhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVideoMaintenance2FeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVideoMaintenance2FeaturesKHR & operator=( PhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVideoMaintenance2FeaturesKHR & operator=( VkPhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance2FeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance2FeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance2FeaturesKHR & setVideoMaintenance2( Bool32 videoMaintenance2_ ) & VULKAN_HPP_NOEXCEPT - { - videoMaintenance2 = videoMaintenance2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVideoMaintenance2FeaturesKHR && setVideoMaintenance2( Bool32 videoMaintenance2_ ) && VULKAN_HPP_NOEXCEPT - { - videoMaintenance2 = videoMaintenance2_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVideoMaintenance2FeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoMaintenance2FeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoMaintenance2FeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVideoMaintenance2FeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoMaintenance2 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVideoMaintenance2FeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoMaintenance2 == rhs.videoMaintenance2 ); -# endif - } - - bool operator!=( PhysicalDeviceVideoMaintenance2FeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVideoMaintenance2FeaturesKHR; - void * pNext = {}; - Bool32 videoMaintenance2 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVideoMaintenance2FeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVideoMaintenance2FeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceVulkan11Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan11Features.html - struct PhysicalDeviceVulkan11Features - { - using NativeType = VkPhysicalDeviceVulkan11Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan11Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan11Features( Bool32 storageBuffer16BitAccess_ = {}, - Bool32 uniformAndStorageBuffer16BitAccess_ = {}, - Bool32 storagePushConstant16_ = {}, - Bool32 storageInputOutput16_ = {}, - Bool32 multiview_ = {}, - Bool32 multiviewGeometryShader_ = {}, - Bool32 multiviewTessellationShader_ = {}, - Bool32 variablePointersStorageBuffer_ = {}, - Bool32 variablePointers_ = {}, - Bool32 protectedMemory_ = {}, - Bool32 samplerYcbcrConversion_ = {}, - Bool32 shaderDrawParameters_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , storageBuffer16BitAccess{ storageBuffer16BitAccess_ } - , uniformAndStorageBuffer16BitAccess{ uniformAndStorageBuffer16BitAccess_ } - , storagePushConstant16{ storagePushConstant16_ } - , storageInputOutput16{ storageInputOutput16_ } - , multiview{ multiview_ } - , multiviewGeometryShader{ multiviewGeometryShader_ } - , multiviewTessellationShader{ multiviewTessellationShader_ } - , variablePointersStorageBuffer{ variablePointersStorageBuffer_ } - , variablePointers{ variablePointers_ } - , protectedMemory{ protectedMemory_ } - , samplerYcbcrConversion{ samplerYcbcrConversion_ } - , shaderDrawParameters{ shaderDrawParameters_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan11Features( PhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVulkan11Features( VkPhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVulkan11Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVulkan11Features & operator=( PhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVulkan11Features & operator=( VkPhysicalDeviceVulkan11Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) & VULKAN_HPP_NOEXCEPT - { - storageBuffer16BitAccess = storageBuffer16BitAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setStorageBuffer16BitAccess( Bool32 storageBuffer16BitAccess_ ) && VULKAN_HPP_NOEXCEPT - { - storageBuffer16BitAccess = storageBuffer16BitAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setUniformAndStorageBuffer16BitAccess( Bool32 uniformAndStorageBuffer16BitAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - uniformAndStorageBuffer16BitAccess = uniformAndStorageBuffer16BitAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setStoragePushConstant16( Bool32 storagePushConstant16_ ) & VULKAN_HPP_NOEXCEPT - { - storagePushConstant16 = storagePushConstant16_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setStoragePushConstant16( Bool32 storagePushConstant16_ ) && VULKAN_HPP_NOEXCEPT - { - storagePushConstant16 = storagePushConstant16_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setStorageInputOutput16( Bool32 storageInputOutput16_ ) & VULKAN_HPP_NOEXCEPT - { - storageInputOutput16 = storageInputOutput16_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setStorageInputOutput16( Bool32 storageInputOutput16_ ) && VULKAN_HPP_NOEXCEPT - { - storageInputOutput16 = storageInputOutput16_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setMultiview( Bool32 multiview_ ) & VULKAN_HPP_NOEXCEPT - { - multiview = multiview_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setMultiview( Bool32 multiview_ ) && VULKAN_HPP_NOEXCEPT - { - multiview = multiview_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ ) & VULKAN_HPP_NOEXCEPT - { - multiviewGeometryShader = multiviewGeometryShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setMultiviewGeometryShader( Bool32 multiviewGeometryShader_ ) && VULKAN_HPP_NOEXCEPT - { - multiviewGeometryShader = multiviewGeometryShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ ) & VULKAN_HPP_NOEXCEPT - { - multiviewTessellationShader = multiviewTessellationShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setMultiviewTessellationShader( Bool32 multiviewTessellationShader_ ) && VULKAN_HPP_NOEXCEPT - { - multiviewTessellationShader = multiviewTessellationShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - variablePointersStorageBuffer = variablePointersStorageBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setVariablePointersStorageBuffer( Bool32 variablePointersStorageBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - variablePointersStorageBuffer = variablePointersStorageBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setVariablePointers( Bool32 variablePointers_ ) & VULKAN_HPP_NOEXCEPT - { - variablePointers = variablePointers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setVariablePointers( Bool32 variablePointers_ ) && VULKAN_HPP_NOEXCEPT - { - variablePointers = variablePointers_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setProtectedMemory( Bool32 protectedMemory_ ) & VULKAN_HPP_NOEXCEPT - { - protectedMemory = protectedMemory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setProtectedMemory( Bool32 protectedMemory_ ) && VULKAN_HPP_NOEXCEPT - { - protectedMemory = protectedMemory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ ) & VULKAN_HPP_NOEXCEPT - { - samplerYcbcrConversion = samplerYcbcrConversion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setSamplerYcbcrConversion( Bool32 samplerYcbcrConversion_ ) && VULKAN_HPP_NOEXCEPT - { - samplerYcbcrConversion = samplerYcbcrConversion_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features & setShaderDrawParameters( Bool32 shaderDrawParameters_ ) & VULKAN_HPP_NOEXCEPT - { - shaderDrawParameters = shaderDrawParameters_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Features && setShaderDrawParameters( Bool32 shaderDrawParameters_ ) && VULKAN_HPP_NOEXCEPT - { - shaderDrawParameters = shaderDrawParameters_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVulkan11Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan11Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan11Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan11Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - storageBuffer16BitAccess, - uniformAndStorageBuffer16BitAccess, - storagePushConstant16, - storageInputOutput16, - multiview, - multiviewGeometryShader, - multiviewTessellationShader, - variablePointersStorageBuffer, - variablePointers, - protectedMemory, - samplerYcbcrConversion, - shaderDrawParameters ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVulkan11Features const & ) const = default; -#else - bool operator==( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffer16BitAccess == rhs.storageBuffer16BitAccess ) && - ( uniformAndStorageBuffer16BitAccess == rhs.uniformAndStorageBuffer16BitAccess ) && ( storagePushConstant16 == rhs.storagePushConstant16 ) && - ( storageInputOutput16 == rhs.storageInputOutput16 ) && ( multiview == rhs.multiview ) && - ( multiviewGeometryShader == rhs.multiviewGeometryShader ) && ( multiviewTessellationShader == rhs.multiviewTessellationShader ) && - ( variablePointersStorageBuffer == rhs.variablePointersStorageBuffer ) && ( variablePointers == rhs.variablePointers ) && - ( protectedMemory == rhs.protectedMemory ) && ( samplerYcbcrConversion == rhs.samplerYcbcrConversion ) && - ( shaderDrawParameters == rhs.shaderDrawParameters ); -# endif - } - - bool operator!=( PhysicalDeviceVulkan11Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVulkan11Features; - void * pNext = {}; - Bool32 storageBuffer16BitAccess = {}; - Bool32 uniformAndStorageBuffer16BitAccess = {}; - Bool32 storagePushConstant16 = {}; - Bool32 storageInputOutput16 = {}; - Bool32 multiview = {}; - Bool32 multiviewGeometryShader = {}; - Bool32 multiviewTessellationShader = {}; - Bool32 variablePointersStorageBuffer = {}; - Bool32 variablePointers = {}; - Bool32 protectedMemory = {}; - Bool32 samplerYcbcrConversion = {}; - Bool32 shaderDrawParameters = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan11Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan11Features; - }; - - // wrapper struct for struct VkPhysicalDeviceVulkan11Properties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan11Properties.html - struct PhysicalDeviceVulkan11Properties - { - using NativeType = VkPhysicalDeviceVulkan11Properties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan11Properties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Properties( std::array const & deviceUUID_ = {}, - std::array const & driverUUID_ = {}, - std::array const & deviceLUID_ = {}, - uint32_t deviceNodeMask_ = {}, - Bool32 deviceLUIDValid_ = {}, - uint32_t subgroupSize_ = {}, - ShaderStageFlags subgroupSupportedStages_ = {}, - SubgroupFeatureFlags subgroupSupportedOperations_ = {}, - Bool32 subgroupQuadOperationsInAllStages_ = {}, - PointClippingBehavior pointClippingBehavior_ = PointClippingBehavior::eAllClipPlanes, - uint32_t maxMultiviewViewCount_ = {}, - uint32_t maxMultiviewInstanceIndex_ = {}, - Bool32 protectedNoFault_ = {}, - uint32_t maxPerSetDescriptors_ = {}, - DeviceSize maxMemoryAllocationSize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , deviceUUID{ deviceUUID_ } - , driverUUID{ driverUUID_ } - , deviceLUID{ deviceLUID_ } - , deviceNodeMask{ deviceNodeMask_ } - , deviceLUIDValid{ deviceLUIDValid_ } - , subgroupSize{ subgroupSize_ } - , subgroupSupportedStages{ subgroupSupportedStages_ } - , subgroupSupportedOperations{ subgroupSupportedOperations_ } - , subgroupQuadOperationsInAllStages{ subgroupQuadOperationsInAllStages_ } - , pointClippingBehavior{ pointClippingBehavior_ } - , maxMultiviewViewCount{ maxMultiviewViewCount_ } - , maxMultiviewInstanceIndex{ maxMultiviewInstanceIndex_ } - , protectedNoFault{ protectedNoFault_ } - , maxPerSetDescriptors{ maxPerSetDescriptors_ } - , maxMemoryAllocationSize{ maxMemoryAllocationSize_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan11Properties( PhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVulkan11Properties( VkPhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVulkan11Properties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVulkan11Properties & operator=( PhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVulkan11Properties & operator=( VkPhysicalDeviceVulkan11Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceVulkan11Properties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan11Properties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan11Properties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan11Properties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &, - ArrayWrapper1D const &, - uint32_t const &, - Bool32 const &, - uint32_t const &, - ShaderStageFlags const &, - SubgroupFeatureFlags const &, - Bool32 const &, - PointClippingBehavior const &, - uint32_t const &, - uint32_t const &, - Bool32 const &, - uint32_t const &, - DeviceSize const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - deviceUUID, - driverUUID, - deviceLUID, - deviceNodeMask, - deviceLUIDValid, - subgroupSize, - subgroupSupportedStages, - subgroupSupportedOperations, - subgroupQuadOperationsInAllStages, - pointClippingBehavior, - maxMultiviewViewCount, - maxMultiviewInstanceIndex, - protectedNoFault, - maxPerSetDescriptors, - maxMemoryAllocationSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVulkan11Properties const & ) const = default; -#else - bool operator==( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceUUID == rhs.deviceUUID ) && ( driverUUID == rhs.driverUUID ) && - ( deviceLUID == rhs.deviceLUID ) && ( deviceNodeMask == rhs.deviceNodeMask ) && ( deviceLUIDValid == rhs.deviceLUIDValid ) && - ( subgroupSize == rhs.subgroupSize ) && ( subgroupSupportedStages == rhs.subgroupSupportedStages ) && - ( subgroupSupportedOperations == rhs.subgroupSupportedOperations ) && - ( subgroupQuadOperationsInAllStages == rhs.subgroupQuadOperationsInAllStages ) && ( pointClippingBehavior == rhs.pointClippingBehavior ) && - ( maxMultiviewViewCount == rhs.maxMultiviewViewCount ) && ( maxMultiviewInstanceIndex == rhs.maxMultiviewInstanceIndex ) && - ( protectedNoFault == rhs.protectedNoFault ) && ( maxPerSetDescriptors == rhs.maxPerSetDescriptors ) && - ( maxMemoryAllocationSize == rhs.maxMemoryAllocationSize ); -# endif - } - - bool operator!=( PhysicalDeviceVulkan11Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVulkan11Properties; - void * pNext = {}; - ArrayWrapper1D deviceUUID = {}; - ArrayWrapper1D driverUUID = {}; - ArrayWrapper1D deviceLUID = {}; - uint32_t deviceNodeMask = {}; - Bool32 deviceLUIDValid = {}; - uint32_t subgroupSize = {}; - ShaderStageFlags subgroupSupportedStages = {}; - SubgroupFeatureFlags subgroupSupportedOperations = {}; - Bool32 subgroupQuadOperationsInAllStages = {}; - PointClippingBehavior pointClippingBehavior = PointClippingBehavior::eAllClipPlanes; - uint32_t maxMultiviewViewCount = {}; - uint32_t maxMultiviewInstanceIndex = {}; - Bool32 protectedNoFault = {}; - uint32_t maxPerSetDescriptors = {}; - DeviceSize maxMemoryAllocationSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan11Properties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan11Properties; - }; - - // wrapper struct for struct VkPhysicalDeviceVulkan12Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan12Features.html - struct PhysicalDeviceVulkan12Features - { - using NativeType = VkPhysicalDeviceVulkan12Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan12Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan12Features( Bool32 samplerMirrorClampToEdge_ = {}, - Bool32 drawIndirectCount_ = {}, - Bool32 storageBuffer8BitAccess_ = {}, - Bool32 uniformAndStorageBuffer8BitAccess_ = {}, - Bool32 storagePushConstant8_ = {}, - Bool32 shaderBufferInt64Atomics_ = {}, - Bool32 shaderSharedInt64Atomics_ = {}, - Bool32 shaderFloat16_ = {}, - Bool32 shaderInt8_ = {}, - Bool32 descriptorIndexing_ = {}, - Bool32 shaderInputAttachmentArrayDynamicIndexing_ = {}, - Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ = {}, - Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ = {}, - Bool32 shaderUniformBufferArrayNonUniformIndexing_ = {}, - Bool32 shaderSampledImageArrayNonUniformIndexing_ = {}, - Bool32 shaderStorageBufferArrayNonUniformIndexing_ = {}, - Bool32 shaderStorageImageArrayNonUniformIndexing_ = {}, - Bool32 shaderInputAttachmentArrayNonUniformIndexing_ = {}, - Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ = {}, - Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ = {}, - Bool32 descriptorBindingUniformBufferUpdateAfterBind_ = {}, - Bool32 descriptorBindingSampledImageUpdateAfterBind_ = {}, - Bool32 descriptorBindingStorageImageUpdateAfterBind_ = {}, - Bool32 descriptorBindingStorageBufferUpdateAfterBind_ = {}, - Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ = {}, - Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ = {}, - Bool32 descriptorBindingUpdateUnusedWhilePending_ = {}, - Bool32 descriptorBindingPartiallyBound_ = {}, - Bool32 descriptorBindingVariableDescriptorCount_ = {}, - Bool32 runtimeDescriptorArray_ = {}, - Bool32 samplerFilterMinmax_ = {}, - Bool32 scalarBlockLayout_ = {}, - Bool32 imagelessFramebuffer_ = {}, - Bool32 uniformBufferStandardLayout_ = {}, - Bool32 shaderSubgroupExtendedTypes_ = {}, - Bool32 separateDepthStencilLayouts_ = {}, - Bool32 hostQueryReset_ = {}, - Bool32 timelineSemaphore_ = {}, - Bool32 bufferDeviceAddress_ = {}, - Bool32 bufferDeviceAddressCaptureReplay_ = {}, - Bool32 bufferDeviceAddressMultiDevice_ = {}, - Bool32 vulkanMemoryModel_ = {}, - Bool32 vulkanMemoryModelDeviceScope_ = {}, - Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = {}, - Bool32 shaderOutputViewportIndex_ = {}, - Bool32 shaderOutputLayer_ = {}, - Bool32 subgroupBroadcastDynamicId_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , samplerMirrorClampToEdge{ samplerMirrorClampToEdge_ } - , drawIndirectCount{ drawIndirectCount_ } - , storageBuffer8BitAccess{ storageBuffer8BitAccess_ } - , uniformAndStorageBuffer8BitAccess{ uniformAndStorageBuffer8BitAccess_ } - , storagePushConstant8{ storagePushConstant8_ } - , shaderBufferInt64Atomics{ shaderBufferInt64Atomics_ } - , shaderSharedInt64Atomics{ shaderSharedInt64Atomics_ } - , shaderFloat16{ shaderFloat16_ } - , shaderInt8{ shaderInt8_ } - , descriptorIndexing{ descriptorIndexing_ } - , shaderInputAttachmentArrayDynamicIndexing{ shaderInputAttachmentArrayDynamicIndexing_ } - , shaderUniformTexelBufferArrayDynamicIndexing{ shaderUniformTexelBufferArrayDynamicIndexing_ } - , shaderStorageTexelBufferArrayDynamicIndexing{ shaderStorageTexelBufferArrayDynamicIndexing_ } - , shaderUniformBufferArrayNonUniformIndexing{ shaderUniformBufferArrayNonUniformIndexing_ } - , shaderSampledImageArrayNonUniformIndexing{ shaderSampledImageArrayNonUniformIndexing_ } - , shaderStorageBufferArrayNonUniformIndexing{ shaderStorageBufferArrayNonUniformIndexing_ } - , shaderStorageImageArrayNonUniformIndexing{ shaderStorageImageArrayNonUniformIndexing_ } - , shaderInputAttachmentArrayNonUniformIndexing{ shaderInputAttachmentArrayNonUniformIndexing_ } - , shaderUniformTexelBufferArrayNonUniformIndexing{ shaderUniformTexelBufferArrayNonUniformIndexing_ } - , shaderStorageTexelBufferArrayNonUniformIndexing{ shaderStorageTexelBufferArrayNonUniformIndexing_ } - , descriptorBindingUniformBufferUpdateAfterBind{ descriptorBindingUniformBufferUpdateAfterBind_ } - , descriptorBindingSampledImageUpdateAfterBind{ descriptorBindingSampledImageUpdateAfterBind_ } - , descriptorBindingStorageImageUpdateAfterBind{ descriptorBindingStorageImageUpdateAfterBind_ } - , descriptorBindingStorageBufferUpdateAfterBind{ descriptorBindingStorageBufferUpdateAfterBind_ } - , descriptorBindingUniformTexelBufferUpdateAfterBind{ descriptorBindingUniformTexelBufferUpdateAfterBind_ } - , descriptorBindingStorageTexelBufferUpdateAfterBind{ descriptorBindingStorageTexelBufferUpdateAfterBind_ } - , descriptorBindingUpdateUnusedWhilePending{ descriptorBindingUpdateUnusedWhilePending_ } - , descriptorBindingPartiallyBound{ descriptorBindingPartiallyBound_ } - , descriptorBindingVariableDescriptorCount{ descriptorBindingVariableDescriptorCount_ } - , runtimeDescriptorArray{ runtimeDescriptorArray_ } - , samplerFilterMinmax{ samplerFilterMinmax_ } - , scalarBlockLayout{ scalarBlockLayout_ } - , imagelessFramebuffer{ imagelessFramebuffer_ } - , uniformBufferStandardLayout{ uniformBufferStandardLayout_ } - , shaderSubgroupExtendedTypes{ shaderSubgroupExtendedTypes_ } - , separateDepthStencilLayouts{ separateDepthStencilLayouts_ } - , hostQueryReset{ hostQueryReset_ } - , timelineSemaphore{ timelineSemaphore_ } - , bufferDeviceAddress{ bufferDeviceAddress_ } - , bufferDeviceAddressCaptureReplay{ bufferDeviceAddressCaptureReplay_ } - , bufferDeviceAddressMultiDevice{ bufferDeviceAddressMultiDevice_ } - , vulkanMemoryModel{ vulkanMemoryModel_ } - , vulkanMemoryModelDeviceScope{ vulkanMemoryModelDeviceScope_ } - , vulkanMemoryModelAvailabilityVisibilityChains{ vulkanMemoryModelAvailabilityVisibilityChains_ } - , shaderOutputViewportIndex{ shaderOutputViewportIndex_ } - , shaderOutputLayer{ shaderOutputLayer_ } - , subgroupBroadcastDynamicId{ subgroupBroadcastDynamicId_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan12Features( PhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVulkan12Features( VkPhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVulkan12Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVulkan12Features & operator=( PhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVulkan12Features & operator=( VkPhysicalDeviceVulkan12Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setSamplerMirrorClampToEdge( Bool32 samplerMirrorClampToEdge_ ) & VULKAN_HPP_NOEXCEPT - { - samplerMirrorClampToEdge = samplerMirrorClampToEdge_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setSamplerMirrorClampToEdge( Bool32 samplerMirrorClampToEdge_ ) && VULKAN_HPP_NOEXCEPT - { - samplerMirrorClampToEdge = samplerMirrorClampToEdge_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setDrawIndirectCount( Bool32 drawIndirectCount_ ) & VULKAN_HPP_NOEXCEPT - { - drawIndirectCount = drawIndirectCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setDrawIndirectCount( Bool32 drawIndirectCount_ ) && VULKAN_HPP_NOEXCEPT - { - drawIndirectCount = drawIndirectCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ ) & VULKAN_HPP_NOEXCEPT - { - storageBuffer8BitAccess = storageBuffer8BitAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setStorageBuffer8BitAccess( Bool32 storageBuffer8BitAccess_ ) && VULKAN_HPP_NOEXCEPT - { - storageBuffer8BitAccess = storageBuffer8BitAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setUniformAndStorageBuffer8BitAccess( Bool32 uniformAndStorageBuffer8BitAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - uniformAndStorageBuffer8BitAccess = uniformAndStorageBuffer8BitAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setStoragePushConstant8( Bool32 storagePushConstant8_ ) & VULKAN_HPP_NOEXCEPT - { - storagePushConstant8 = storagePushConstant8_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setStoragePushConstant8( Bool32 storagePushConstant8_ ) && VULKAN_HPP_NOEXCEPT - { - storagePushConstant8 = storagePushConstant8_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ ) & VULKAN_HPP_NOEXCEPT - { - shaderBufferInt64Atomics = shaderBufferInt64Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderBufferInt64Atomics( Bool32 shaderBufferInt64Atomics_ ) && VULKAN_HPP_NOEXCEPT - { - shaderBufferInt64Atomics = shaderBufferInt64Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ ) & VULKAN_HPP_NOEXCEPT - { - shaderSharedInt64Atomics = shaderSharedInt64Atomics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderSharedInt64Atomics( Bool32 shaderSharedInt64Atomics_ ) && VULKAN_HPP_NOEXCEPT - { - shaderSharedInt64Atomics = shaderSharedInt64Atomics_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderFloat16( Bool32 shaderFloat16_ ) & VULKAN_HPP_NOEXCEPT - { - shaderFloat16 = shaderFloat16_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderFloat16( Bool32 shaderFloat16_ ) && VULKAN_HPP_NOEXCEPT - { - shaderFloat16 = shaderFloat16_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderInt8( Bool32 shaderInt8_ ) & VULKAN_HPP_NOEXCEPT - { - shaderInt8 = shaderInt8_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderInt8( Bool32 shaderInt8_ ) && VULKAN_HPP_NOEXCEPT - { - shaderInt8 = shaderInt8_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setDescriptorIndexing( Bool32 descriptorIndexing_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorIndexing = descriptorIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setDescriptorIndexing( Bool32 descriptorIndexing_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorIndexing = descriptorIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setShaderInputAttachmentArrayDynamicIndexing( Bool32 shaderInputAttachmentArrayDynamicIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderInputAttachmentArrayDynamicIndexing = shaderInputAttachmentArrayDynamicIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setShaderUniformTexelBufferArrayDynamicIndexing( Bool32 shaderUniformTexelBufferArrayDynamicIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderUniformTexelBufferArrayDynamicIndexing = shaderUniformTexelBufferArrayDynamicIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setShaderStorageTexelBufferArrayDynamicIndexing( Bool32 shaderStorageTexelBufferArrayDynamicIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageTexelBufferArrayDynamicIndexing = shaderStorageTexelBufferArrayDynamicIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setShaderUniformBufferArrayNonUniformIndexing( Bool32 shaderUniformBufferArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderUniformBufferArrayNonUniformIndexing = shaderUniformBufferArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setShaderSampledImageArrayNonUniformIndexing( Bool32 shaderSampledImageArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderSampledImageArrayNonUniformIndexing = shaderSampledImageArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setShaderStorageBufferArrayNonUniformIndexing( Bool32 shaderStorageBufferArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageBufferArrayNonUniformIndexing = shaderStorageBufferArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setShaderStorageImageArrayNonUniformIndexing( Bool32 shaderStorageImageArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageImageArrayNonUniformIndexing = shaderStorageImageArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setShaderInputAttachmentArrayNonUniformIndexing( Bool32 shaderInputAttachmentArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderInputAttachmentArrayNonUniformIndexing = shaderInputAttachmentArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setShaderUniformTexelBufferArrayNonUniformIndexing( Bool32 shaderUniformTexelBufferArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderUniformTexelBufferArrayNonUniformIndexing = shaderUniformTexelBufferArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setShaderStorageTexelBufferArrayNonUniformIndexing( Bool32 shaderStorageTexelBufferArrayNonUniformIndexing_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderStorageTexelBufferArrayNonUniformIndexing = shaderStorageTexelBufferArrayNonUniformIndexing_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setDescriptorBindingUniformBufferUpdateAfterBind( Bool32 descriptorBindingUniformBufferUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUniformBufferUpdateAfterBind = descriptorBindingUniformBufferUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setDescriptorBindingSampledImageUpdateAfterBind( Bool32 descriptorBindingSampledImageUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingSampledImageUpdateAfterBind = descriptorBindingSampledImageUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setDescriptorBindingStorageImageUpdateAfterBind( Bool32 descriptorBindingStorageImageUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageImageUpdateAfterBind = descriptorBindingStorageImageUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setDescriptorBindingStorageBufferUpdateAfterBind( Bool32 descriptorBindingStorageBufferUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageBufferUpdateAfterBind = descriptorBindingStorageBufferUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setDescriptorBindingUniformTexelBufferUpdateAfterBind( Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUniformTexelBufferUpdateAfterBind = descriptorBindingUniformTexelBufferUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setDescriptorBindingStorageTexelBufferUpdateAfterBind( Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingStorageTexelBufferUpdateAfterBind = descriptorBindingStorageTexelBufferUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setDescriptorBindingUpdateUnusedWhilePending( Bool32 descriptorBindingUpdateUnusedWhilePending_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingUpdateUnusedWhilePending = descriptorBindingUpdateUnusedWhilePending_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setDescriptorBindingPartiallyBound( Bool32 descriptorBindingPartiallyBound_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingPartiallyBound = descriptorBindingPartiallyBound_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setDescriptorBindingVariableDescriptorCount( Bool32 descriptorBindingVariableDescriptorCount_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingVariableDescriptorCount = descriptorBindingVariableDescriptorCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ ) & VULKAN_HPP_NOEXCEPT - { - runtimeDescriptorArray = runtimeDescriptorArray_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setRuntimeDescriptorArray( Bool32 runtimeDescriptorArray_ ) && VULKAN_HPP_NOEXCEPT - { - runtimeDescriptorArray = runtimeDescriptorArray_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setSamplerFilterMinmax( Bool32 samplerFilterMinmax_ ) & VULKAN_HPP_NOEXCEPT - { - samplerFilterMinmax = samplerFilterMinmax_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setSamplerFilterMinmax( Bool32 samplerFilterMinmax_ ) && VULKAN_HPP_NOEXCEPT - { - samplerFilterMinmax = samplerFilterMinmax_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setScalarBlockLayout( Bool32 scalarBlockLayout_ ) & VULKAN_HPP_NOEXCEPT - { - scalarBlockLayout = scalarBlockLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setScalarBlockLayout( Bool32 scalarBlockLayout_ ) && VULKAN_HPP_NOEXCEPT - { - scalarBlockLayout = scalarBlockLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setImagelessFramebuffer( Bool32 imagelessFramebuffer_ ) & VULKAN_HPP_NOEXCEPT - { - imagelessFramebuffer = imagelessFramebuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setImagelessFramebuffer( Bool32 imagelessFramebuffer_ ) && VULKAN_HPP_NOEXCEPT - { - imagelessFramebuffer = imagelessFramebuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setUniformBufferStandardLayout( Bool32 uniformBufferStandardLayout_ ) & VULKAN_HPP_NOEXCEPT - { - uniformBufferStandardLayout = uniformBufferStandardLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setUniformBufferStandardLayout( Bool32 uniformBufferStandardLayout_ ) && VULKAN_HPP_NOEXCEPT - { - uniformBufferStandardLayout = uniformBufferStandardLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderSubgroupExtendedTypes( Bool32 shaderSubgroupExtendedTypes_ ) & VULKAN_HPP_NOEXCEPT - { - shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderSubgroupExtendedTypes( Bool32 shaderSubgroupExtendedTypes_ ) && VULKAN_HPP_NOEXCEPT - { - shaderSubgroupExtendedTypes = shaderSubgroupExtendedTypes_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setSeparateDepthStencilLayouts( Bool32 separateDepthStencilLayouts_ ) & VULKAN_HPP_NOEXCEPT - { - separateDepthStencilLayouts = separateDepthStencilLayouts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setSeparateDepthStencilLayouts( Bool32 separateDepthStencilLayouts_ ) && VULKAN_HPP_NOEXCEPT - { - separateDepthStencilLayouts = separateDepthStencilLayouts_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setHostQueryReset( Bool32 hostQueryReset_ ) & VULKAN_HPP_NOEXCEPT - { - hostQueryReset = hostQueryReset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setHostQueryReset( Bool32 hostQueryReset_ ) && VULKAN_HPP_NOEXCEPT - { - hostQueryReset = hostQueryReset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setTimelineSemaphore( Bool32 timelineSemaphore_ ) & VULKAN_HPP_NOEXCEPT - { - timelineSemaphore = timelineSemaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setTimelineSemaphore( Bool32 timelineSemaphore_ ) && VULKAN_HPP_NOEXCEPT - { - timelineSemaphore = timelineSemaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) & VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddress = bufferDeviceAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setBufferDeviceAddress( Bool32 bufferDeviceAddress_ ) && VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddress = bufferDeviceAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) & - VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setBufferDeviceAddressCaptureReplay( Bool32 bufferDeviceAddressCaptureReplay_ ) && - VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressCaptureReplay = bufferDeviceAddressCaptureReplay_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) & VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setBufferDeviceAddressMultiDevice( Bool32 bufferDeviceAddressMultiDevice_ ) && VULKAN_HPP_NOEXCEPT - { - bufferDeviceAddressMultiDevice = bufferDeviceAddressMultiDevice_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setVulkanMemoryModel( Bool32 vulkanMemoryModel_ ) & VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModel = vulkanMemoryModel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setVulkanMemoryModel( Bool32 vulkanMemoryModel_ ) && VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModel = vulkanMemoryModel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setVulkanMemoryModelDeviceScope( Bool32 vulkanMemoryModelDeviceScope_ ) & VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setVulkanMemoryModelDeviceScope( Bool32 vulkanMemoryModelDeviceScope_ ) && VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & - setVulkanMemoryModelAvailabilityVisibilityChains( Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ ) & - VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && - setVulkanMemoryModelAvailabilityVisibilityChains( Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ ) && - VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderOutputViewportIndex( Bool32 shaderOutputViewportIndex_ ) & VULKAN_HPP_NOEXCEPT - { - shaderOutputViewportIndex = shaderOutputViewportIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderOutputViewportIndex( Bool32 shaderOutputViewportIndex_ ) && VULKAN_HPP_NOEXCEPT - { - shaderOutputViewportIndex = shaderOutputViewportIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setShaderOutputLayer( Bool32 shaderOutputLayer_ ) & VULKAN_HPP_NOEXCEPT - { - shaderOutputLayer = shaderOutputLayer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setShaderOutputLayer( Bool32 shaderOutputLayer_ ) && VULKAN_HPP_NOEXCEPT - { - shaderOutputLayer = shaderOutputLayer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features & setSubgroupBroadcastDynamicId( Bool32 subgroupBroadcastDynamicId_ ) & VULKAN_HPP_NOEXCEPT - { - subgroupBroadcastDynamicId = subgroupBroadcastDynamicId_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Features && setSubgroupBroadcastDynamicId( Bool32 subgroupBroadcastDynamicId_ ) && VULKAN_HPP_NOEXCEPT - { - subgroupBroadcastDynamicId = subgroupBroadcastDynamicId_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVulkan12Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan12Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan12Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan12Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - samplerMirrorClampToEdge, - drawIndirectCount, - storageBuffer8BitAccess, - uniformAndStorageBuffer8BitAccess, - storagePushConstant8, - shaderBufferInt64Atomics, - shaderSharedInt64Atomics, - shaderFloat16, - shaderInt8, - descriptorIndexing, - shaderInputAttachmentArrayDynamicIndexing, - shaderUniformTexelBufferArrayDynamicIndexing, - shaderStorageTexelBufferArrayDynamicIndexing, - shaderUniformBufferArrayNonUniformIndexing, - shaderSampledImageArrayNonUniformIndexing, - shaderStorageBufferArrayNonUniformIndexing, - shaderStorageImageArrayNonUniformIndexing, - shaderInputAttachmentArrayNonUniformIndexing, - shaderUniformTexelBufferArrayNonUniformIndexing, - shaderStorageTexelBufferArrayNonUniformIndexing, - descriptorBindingUniformBufferUpdateAfterBind, - descriptorBindingSampledImageUpdateAfterBind, - descriptorBindingStorageImageUpdateAfterBind, - descriptorBindingStorageBufferUpdateAfterBind, - descriptorBindingUniformTexelBufferUpdateAfterBind, - descriptorBindingStorageTexelBufferUpdateAfterBind, - descriptorBindingUpdateUnusedWhilePending, - descriptorBindingPartiallyBound, - descriptorBindingVariableDescriptorCount, - runtimeDescriptorArray, - samplerFilterMinmax, - scalarBlockLayout, - imagelessFramebuffer, - uniformBufferStandardLayout, - shaderSubgroupExtendedTypes, - separateDepthStencilLayouts, - hostQueryReset, - timelineSemaphore, - bufferDeviceAddress, - bufferDeviceAddressCaptureReplay, - bufferDeviceAddressMultiDevice, - vulkanMemoryModel, - vulkanMemoryModelDeviceScope, - vulkanMemoryModelAvailabilityVisibilityChains, - shaderOutputViewportIndex, - shaderOutputLayer, - subgroupBroadcastDynamicId ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVulkan12Features const & ) const = default; -#else - bool operator==( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( samplerMirrorClampToEdge == rhs.samplerMirrorClampToEdge ) && - ( drawIndirectCount == rhs.drawIndirectCount ) && ( storageBuffer8BitAccess == rhs.storageBuffer8BitAccess ) && - ( uniformAndStorageBuffer8BitAccess == rhs.uniformAndStorageBuffer8BitAccess ) && ( storagePushConstant8 == rhs.storagePushConstant8 ) && - ( shaderBufferInt64Atomics == rhs.shaderBufferInt64Atomics ) && ( shaderSharedInt64Atomics == rhs.shaderSharedInt64Atomics ) && - ( shaderFloat16 == rhs.shaderFloat16 ) && ( shaderInt8 == rhs.shaderInt8 ) && ( descriptorIndexing == rhs.descriptorIndexing ) && - ( shaderInputAttachmentArrayDynamicIndexing == rhs.shaderInputAttachmentArrayDynamicIndexing ) && - ( shaderUniformTexelBufferArrayDynamicIndexing == rhs.shaderUniformTexelBufferArrayDynamicIndexing ) && - ( shaderStorageTexelBufferArrayDynamicIndexing == rhs.shaderStorageTexelBufferArrayDynamicIndexing ) && - ( shaderUniformBufferArrayNonUniformIndexing == rhs.shaderUniformBufferArrayNonUniformIndexing ) && - ( shaderSampledImageArrayNonUniformIndexing == rhs.shaderSampledImageArrayNonUniformIndexing ) && - ( shaderStorageBufferArrayNonUniformIndexing == rhs.shaderStorageBufferArrayNonUniformIndexing ) && - ( shaderStorageImageArrayNonUniformIndexing == rhs.shaderStorageImageArrayNonUniformIndexing ) && - ( shaderInputAttachmentArrayNonUniformIndexing == rhs.shaderInputAttachmentArrayNonUniformIndexing ) && - ( shaderUniformTexelBufferArrayNonUniformIndexing == rhs.shaderUniformTexelBufferArrayNonUniformIndexing ) && - ( shaderStorageTexelBufferArrayNonUniformIndexing == rhs.shaderStorageTexelBufferArrayNonUniformIndexing ) && - ( descriptorBindingUniformBufferUpdateAfterBind == rhs.descriptorBindingUniformBufferUpdateAfterBind ) && - ( descriptorBindingSampledImageUpdateAfterBind == rhs.descriptorBindingSampledImageUpdateAfterBind ) && - ( descriptorBindingStorageImageUpdateAfterBind == rhs.descriptorBindingStorageImageUpdateAfterBind ) && - ( descriptorBindingStorageBufferUpdateAfterBind == rhs.descriptorBindingStorageBufferUpdateAfterBind ) && - ( descriptorBindingUniformTexelBufferUpdateAfterBind == rhs.descriptorBindingUniformTexelBufferUpdateAfterBind ) && - ( descriptorBindingStorageTexelBufferUpdateAfterBind == rhs.descriptorBindingStorageTexelBufferUpdateAfterBind ) && - ( descriptorBindingUpdateUnusedWhilePending == rhs.descriptorBindingUpdateUnusedWhilePending ) && - ( descriptorBindingPartiallyBound == rhs.descriptorBindingPartiallyBound ) && - ( descriptorBindingVariableDescriptorCount == rhs.descriptorBindingVariableDescriptorCount ) && - ( runtimeDescriptorArray == rhs.runtimeDescriptorArray ) && ( samplerFilterMinmax == rhs.samplerFilterMinmax ) && - ( scalarBlockLayout == rhs.scalarBlockLayout ) && ( imagelessFramebuffer == rhs.imagelessFramebuffer ) && - ( uniformBufferStandardLayout == rhs.uniformBufferStandardLayout ) && ( shaderSubgroupExtendedTypes == rhs.shaderSubgroupExtendedTypes ) && - ( separateDepthStencilLayouts == rhs.separateDepthStencilLayouts ) && ( hostQueryReset == rhs.hostQueryReset ) && - ( timelineSemaphore == rhs.timelineSemaphore ) && ( bufferDeviceAddress == rhs.bufferDeviceAddress ) && - ( bufferDeviceAddressCaptureReplay == rhs.bufferDeviceAddressCaptureReplay ) && - ( bufferDeviceAddressMultiDevice == rhs.bufferDeviceAddressMultiDevice ) && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) && - ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) && - ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ) && - ( shaderOutputViewportIndex == rhs.shaderOutputViewportIndex ) && ( shaderOutputLayer == rhs.shaderOutputLayer ) && - ( subgroupBroadcastDynamicId == rhs.subgroupBroadcastDynamicId ); -# endif - } - - bool operator!=( PhysicalDeviceVulkan12Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVulkan12Features; - void * pNext = {}; - Bool32 samplerMirrorClampToEdge = {}; - Bool32 drawIndirectCount = {}; - Bool32 storageBuffer8BitAccess = {}; - Bool32 uniformAndStorageBuffer8BitAccess = {}; - Bool32 storagePushConstant8 = {}; - Bool32 shaderBufferInt64Atomics = {}; - Bool32 shaderSharedInt64Atomics = {}; - Bool32 shaderFloat16 = {}; - Bool32 shaderInt8 = {}; - Bool32 descriptorIndexing = {}; - Bool32 shaderInputAttachmentArrayDynamicIndexing = {}; - Bool32 shaderUniformTexelBufferArrayDynamicIndexing = {}; - Bool32 shaderStorageTexelBufferArrayDynamicIndexing = {}; - Bool32 shaderUniformBufferArrayNonUniformIndexing = {}; - Bool32 shaderSampledImageArrayNonUniformIndexing = {}; - Bool32 shaderStorageBufferArrayNonUniformIndexing = {}; - Bool32 shaderStorageImageArrayNonUniformIndexing = {}; - Bool32 shaderInputAttachmentArrayNonUniformIndexing = {}; - Bool32 shaderUniformTexelBufferArrayNonUniformIndexing = {}; - Bool32 shaderStorageTexelBufferArrayNonUniformIndexing = {}; - Bool32 descriptorBindingUniformBufferUpdateAfterBind = {}; - Bool32 descriptorBindingSampledImageUpdateAfterBind = {}; - Bool32 descriptorBindingStorageImageUpdateAfterBind = {}; - Bool32 descriptorBindingStorageBufferUpdateAfterBind = {}; - Bool32 descriptorBindingUniformTexelBufferUpdateAfterBind = {}; - Bool32 descriptorBindingStorageTexelBufferUpdateAfterBind = {}; - Bool32 descriptorBindingUpdateUnusedWhilePending = {}; - Bool32 descriptorBindingPartiallyBound = {}; - Bool32 descriptorBindingVariableDescriptorCount = {}; - Bool32 runtimeDescriptorArray = {}; - Bool32 samplerFilterMinmax = {}; - Bool32 scalarBlockLayout = {}; - Bool32 imagelessFramebuffer = {}; - Bool32 uniformBufferStandardLayout = {}; - Bool32 shaderSubgroupExtendedTypes = {}; - Bool32 separateDepthStencilLayouts = {}; - Bool32 hostQueryReset = {}; - Bool32 timelineSemaphore = {}; - Bool32 bufferDeviceAddress = {}; - Bool32 bufferDeviceAddressCaptureReplay = {}; - Bool32 bufferDeviceAddressMultiDevice = {}; - Bool32 vulkanMemoryModel = {}; - Bool32 vulkanMemoryModelDeviceScope = {}; - Bool32 vulkanMemoryModelAvailabilityVisibilityChains = {}; - Bool32 shaderOutputViewportIndex = {}; - Bool32 shaderOutputLayer = {}; - Bool32 subgroupBroadcastDynamicId = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan12Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan12Features; - }; - - // wrapper struct for struct VkPhysicalDeviceVulkan12Properties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan12Properties.html - struct PhysicalDeviceVulkan12Properties - { - using NativeType = VkPhysicalDeviceVulkan12Properties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan12Properties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - PhysicalDeviceVulkan12Properties( DriverId driverID_ = DriverId::eAmdProprietary, - std::array const & driverName_ = {}, - std::array const & driverInfo_ = {}, - ConformanceVersion conformanceVersion_ = {}, - ShaderFloatControlsIndependence denormBehaviorIndependence_ = ShaderFloatControlsIndependence::e32BitOnly, - ShaderFloatControlsIndependence roundingModeIndependence_ = ShaderFloatControlsIndependence::e32BitOnly, - Bool32 shaderSignedZeroInfNanPreserveFloat16_ = {}, - Bool32 shaderSignedZeroInfNanPreserveFloat32_ = {}, - Bool32 shaderSignedZeroInfNanPreserveFloat64_ = {}, - Bool32 shaderDenormPreserveFloat16_ = {}, - Bool32 shaderDenormPreserveFloat32_ = {}, - Bool32 shaderDenormPreserveFloat64_ = {}, - Bool32 shaderDenormFlushToZeroFloat16_ = {}, - Bool32 shaderDenormFlushToZeroFloat32_ = {}, - Bool32 shaderDenormFlushToZeroFloat64_ = {}, - Bool32 shaderRoundingModeRTEFloat16_ = {}, - Bool32 shaderRoundingModeRTEFloat32_ = {}, - Bool32 shaderRoundingModeRTEFloat64_ = {}, - Bool32 shaderRoundingModeRTZFloat16_ = {}, - Bool32 shaderRoundingModeRTZFloat32_ = {}, - Bool32 shaderRoundingModeRTZFloat64_ = {}, - uint32_t maxUpdateAfterBindDescriptorsInAllPools_ = {}, - Bool32 shaderUniformBufferArrayNonUniformIndexingNative_ = {}, - Bool32 shaderSampledImageArrayNonUniformIndexingNative_ = {}, - Bool32 shaderStorageBufferArrayNonUniformIndexingNative_ = {}, - Bool32 shaderStorageImageArrayNonUniformIndexingNative_ = {}, - Bool32 shaderInputAttachmentArrayNonUniformIndexingNative_ = {}, - Bool32 robustBufferAccessUpdateAfterBind_ = {}, - Bool32 quadDivergentImplicitLod_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments_ = {}, - uint32_t maxPerStageUpdateAfterBindResources_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindSamplers_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindSampledImages_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindStorageImages_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments_ = {}, - ResolveModeFlags supportedDepthResolveModes_ = {}, - ResolveModeFlags supportedStencilResolveModes_ = {}, - Bool32 independentResolveNone_ = {}, - Bool32 independentResolve_ = {}, - Bool32 filterMinmaxSingleComponentFormats_ = {}, - Bool32 filterMinmaxImageComponentMapping_ = {}, - uint64_t maxTimelineSemaphoreValueDifference_ = {}, - SampleCountFlags framebufferIntegerColorSampleCounts_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , driverID{ driverID_ } - , driverName{ driverName_ } - , driverInfo{ driverInfo_ } - , conformanceVersion{ conformanceVersion_ } - , denormBehaviorIndependence{ denormBehaviorIndependence_ } - , roundingModeIndependence{ roundingModeIndependence_ } - , shaderSignedZeroInfNanPreserveFloat16{ shaderSignedZeroInfNanPreserveFloat16_ } - , shaderSignedZeroInfNanPreserveFloat32{ shaderSignedZeroInfNanPreserveFloat32_ } - , shaderSignedZeroInfNanPreserveFloat64{ shaderSignedZeroInfNanPreserveFloat64_ } - , shaderDenormPreserveFloat16{ shaderDenormPreserveFloat16_ } - , shaderDenormPreserveFloat32{ shaderDenormPreserveFloat32_ } - , shaderDenormPreserveFloat64{ shaderDenormPreserveFloat64_ } - , shaderDenormFlushToZeroFloat16{ shaderDenormFlushToZeroFloat16_ } - , shaderDenormFlushToZeroFloat32{ shaderDenormFlushToZeroFloat32_ } - , shaderDenormFlushToZeroFloat64{ shaderDenormFlushToZeroFloat64_ } - , shaderRoundingModeRTEFloat16{ shaderRoundingModeRTEFloat16_ } - , shaderRoundingModeRTEFloat32{ shaderRoundingModeRTEFloat32_ } - , shaderRoundingModeRTEFloat64{ shaderRoundingModeRTEFloat64_ } - , shaderRoundingModeRTZFloat16{ shaderRoundingModeRTZFloat16_ } - , shaderRoundingModeRTZFloat32{ shaderRoundingModeRTZFloat32_ } - , shaderRoundingModeRTZFloat64{ shaderRoundingModeRTZFloat64_ } - , maxUpdateAfterBindDescriptorsInAllPools{ maxUpdateAfterBindDescriptorsInAllPools_ } - , shaderUniformBufferArrayNonUniformIndexingNative{ shaderUniformBufferArrayNonUniformIndexingNative_ } - , shaderSampledImageArrayNonUniformIndexingNative{ shaderSampledImageArrayNonUniformIndexingNative_ } - , shaderStorageBufferArrayNonUniformIndexingNative{ shaderStorageBufferArrayNonUniformIndexingNative_ } - , shaderStorageImageArrayNonUniformIndexingNative{ shaderStorageImageArrayNonUniformIndexingNative_ } - , shaderInputAttachmentArrayNonUniformIndexingNative{ shaderInputAttachmentArrayNonUniformIndexingNative_ } - , robustBufferAccessUpdateAfterBind{ robustBufferAccessUpdateAfterBind_ } - , quadDivergentImplicitLod{ quadDivergentImplicitLod_ } - , maxPerStageDescriptorUpdateAfterBindSamplers{ maxPerStageDescriptorUpdateAfterBindSamplers_ } - , maxPerStageDescriptorUpdateAfterBindUniformBuffers{ maxPerStageDescriptorUpdateAfterBindUniformBuffers_ } - , maxPerStageDescriptorUpdateAfterBindStorageBuffers{ maxPerStageDescriptorUpdateAfterBindStorageBuffers_ } - , maxPerStageDescriptorUpdateAfterBindSampledImages{ maxPerStageDescriptorUpdateAfterBindSampledImages_ } - , maxPerStageDescriptorUpdateAfterBindStorageImages{ maxPerStageDescriptorUpdateAfterBindStorageImages_ } - , maxPerStageDescriptorUpdateAfterBindInputAttachments{ maxPerStageDescriptorUpdateAfterBindInputAttachments_ } - , maxPerStageUpdateAfterBindResources{ maxPerStageUpdateAfterBindResources_ } - , maxDescriptorSetUpdateAfterBindSamplers{ maxDescriptorSetUpdateAfterBindSamplers_ } - , maxDescriptorSetUpdateAfterBindUniformBuffers{ maxDescriptorSetUpdateAfterBindUniformBuffers_ } - , maxDescriptorSetUpdateAfterBindUniformBuffersDynamic{ maxDescriptorSetUpdateAfterBindUniformBuffersDynamic_ } - , maxDescriptorSetUpdateAfterBindStorageBuffers{ maxDescriptorSetUpdateAfterBindStorageBuffers_ } - , maxDescriptorSetUpdateAfterBindStorageBuffersDynamic{ maxDescriptorSetUpdateAfterBindStorageBuffersDynamic_ } - , maxDescriptorSetUpdateAfterBindSampledImages{ maxDescriptorSetUpdateAfterBindSampledImages_ } - , maxDescriptorSetUpdateAfterBindStorageImages{ maxDescriptorSetUpdateAfterBindStorageImages_ } - , maxDescriptorSetUpdateAfterBindInputAttachments{ maxDescriptorSetUpdateAfterBindInputAttachments_ } - , supportedDepthResolveModes{ supportedDepthResolveModes_ } - , supportedStencilResolveModes{ supportedStencilResolveModes_ } - , independentResolveNone{ independentResolveNone_ } - , independentResolve{ independentResolve_ } - , filterMinmaxSingleComponentFormats{ filterMinmaxSingleComponentFormats_ } - , filterMinmaxImageComponentMapping{ filterMinmaxImageComponentMapping_ } - , maxTimelineSemaphoreValueDifference{ maxTimelineSemaphoreValueDifference_ } - , framebufferIntegerColorSampleCounts{ framebufferIntegerColorSampleCounts_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan12Properties( PhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVulkan12Properties( VkPhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVulkan12Properties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVulkan12Properties & operator=( PhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVulkan12Properties & operator=( VkPhysicalDeviceVulkan12Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceVulkan12Properties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan12Properties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan12Properties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan12Properties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &, - ConformanceVersion const &, - ShaderFloatControlsIndependence const &, - ShaderFloatControlsIndependence const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - uint32_t const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - uint32_t const &, - ResolveModeFlags const &, - ResolveModeFlags const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - Bool32 const &, - uint64_t const &, - SampleCountFlags const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - driverID, - driverName, - driverInfo, - conformanceVersion, - denormBehaviorIndependence, - roundingModeIndependence, - shaderSignedZeroInfNanPreserveFloat16, - shaderSignedZeroInfNanPreserveFloat32, - shaderSignedZeroInfNanPreserveFloat64, - shaderDenormPreserveFloat16, - shaderDenormPreserveFloat32, - shaderDenormPreserveFloat64, - shaderDenormFlushToZeroFloat16, - shaderDenormFlushToZeroFloat32, - shaderDenormFlushToZeroFloat64, - shaderRoundingModeRTEFloat16, - shaderRoundingModeRTEFloat32, - shaderRoundingModeRTEFloat64, - shaderRoundingModeRTZFloat16, - shaderRoundingModeRTZFloat32, - shaderRoundingModeRTZFloat64, - maxUpdateAfterBindDescriptorsInAllPools, - shaderUniformBufferArrayNonUniformIndexingNative, - shaderSampledImageArrayNonUniformIndexingNative, - shaderStorageBufferArrayNonUniformIndexingNative, - shaderStorageImageArrayNonUniformIndexingNative, - shaderInputAttachmentArrayNonUniformIndexingNative, - robustBufferAccessUpdateAfterBind, - quadDivergentImplicitLod, - maxPerStageDescriptorUpdateAfterBindSamplers, - maxPerStageDescriptorUpdateAfterBindUniformBuffers, - maxPerStageDescriptorUpdateAfterBindStorageBuffers, - maxPerStageDescriptorUpdateAfterBindSampledImages, - maxPerStageDescriptorUpdateAfterBindStorageImages, - maxPerStageDescriptorUpdateAfterBindInputAttachments, - maxPerStageUpdateAfterBindResources, - maxDescriptorSetUpdateAfterBindSamplers, - maxDescriptorSetUpdateAfterBindUniformBuffers, - maxDescriptorSetUpdateAfterBindUniformBuffersDynamic, - maxDescriptorSetUpdateAfterBindStorageBuffers, - maxDescriptorSetUpdateAfterBindStorageBuffersDynamic, - maxDescriptorSetUpdateAfterBindSampledImages, - maxDescriptorSetUpdateAfterBindStorageImages, - maxDescriptorSetUpdateAfterBindInputAttachments, - supportedDepthResolveModes, - supportedStencilResolveModes, - independentResolveNone, - independentResolve, - filterMinmaxSingleComponentFormats, - filterMinmaxImageComponentMapping, - maxTimelineSemaphoreValueDifference, - framebufferIntegerColorSampleCounts ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = driverID <=> rhs.driverID; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( driverName, rhs.driverName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = strcmp( driverInfo, rhs.driverInfo ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = conformanceVersion <=> rhs.conformanceVersion; cmp != 0 ) - return cmp; - if ( auto cmp = denormBehaviorIndependence <=> rhs.denormBehaviorIndependence; cmp != 0 ) - return cmp; - if ( auto cmp = roundingModeIndependence <=> rhs.roundingModeIndependence; cmp != 0 ) - return cmp; - if ( auto cmp = shaderSignedZeroInfNanPreserveFloat16 <=> rhs.shaderSignedZeroInfNanPreserveFloat16; cmp != 0 ) - return cmp; - if ( auto cmp = shaderSignedZeroInfNanPreserveFloat32 <=> rhs.shaderSignedZeroInfNanPreserveFloat32; cmp != 0 ) - return cmp; - if ( auto cmp = shaderSignedZeroInfNanPreserveFloat64 <=> rhs.shaderSignedZeroInfNanPreserveFloat64; cmp != 0 ) - return cmp; - if ( auto cmp = shaderDenormPreserveFloat16 <=> rhs.shaderDenormPreserveFloat16; cmp != 0 ) - return cmp; - if ( auto cmp = shaderDenormPreserveFloat32 <=> rhs.shaderDenormPreserveFloat32; cmp != 0 ) - return cmp; - if ( auto cmp = shaderDenormPreserveFloat64 <=> rhs.shaderDenormPreserveFloat64; cmp != 0 ) - return cmp; - if ( auto cmp = shaderDenormFlushToZeroFloat16 <=> rhs.shaderDenormFlushToZeroFloat16; cmp != 0 ) - return cmp; - if ( auto cmp = shaderDenormFlushToZeroFloat32 <=> rhs.shaderDenormFlushToZeroFloat32; cmp != 0 ) - return cmp; - if ( auto cmp = shaderDenormFlushToZeroFloat64 <=> rhs.shaderDenormFlushToZeroFloat64; cmp != 0 ) - return cmp; - if ( auto cmp = shaderRoundingModeRTEFloat16 <=> rhs.shaderRoundingModeRTEFloat16; cmp != 0 ) - return cmp; - if ( auto cmp = shaderRoundingModeRTEFloat32 <=> rhs.shaderRoundingModeRTEFloat32; cmp != 0 ) - return cmp; - if ( auto cmp = shaderRoundingModeRTEFloat64 <=> rhs.shaderRoundingModeRTEFloat64; cmp != 0 ) - return cmp; - if ( auto cmp = shaderRoundingModeRTZFloat16 <=> rhs.shaderRoundingModeRTZFloat16; cmp != 0 ) - return cmp; - if ( auto cmp = shaderRoundingModeRTZFloat32 <=> rhs.shaderRoundingModeRTZFloat32; cmp != 0 ) - return cmp; - if ( auto cmp = shaderRoundingModeRTZFloat64 <=> rhs.shaderRoundingModeRTZFloat64; cmp != 0 ) - return cmp; - if ( auto cmp = maxUpdateAfterBindDescriptorsInAllPools <=> rhs.maxUpdateAfterBindDescriptorsInAllPools; cmp != 0 ) - return cmp; - if ( auto cmp = shaderUniformBufferArrayNonUniformIndexingNative <=> rhs.shaderUniformBufferArrayNonUniformIndexingNative; cmp != 0 ) - return cmp; - if ( auto cmp = shaderSampledImageArrayNonUniformIndexingNative <=> rhs.shaderSampledImageArrayNonUniformIndexingNative; cmp != 0 ) - return cmp; - if ( auto cmp = shaderStorageBufferArrayNonUniformIndexingNative <=> rhs.shaderStorageBufferArrayNonUniformIndexingNative; cmp != 0 ) - return cmp; - if ( auto cmp = shaderStorageImageArrayNonUniformIndexingNative <=> rhs.shaderStorageImageArrayNonUniformIndexingNative; cmp != 0 ) - return cmp; - if ( auto cmp = shaderInputAttachmentArrayNonUniformIndexingNative <=> rhs.shaderInputAttachmentArrayNonUniformIndexingNative; cmp != 0 ) - return cmp; - if ( auto cmp = robustBufferAccessUpdateAfterBind <=> rhs.robustBufferAccessUpdateAfterBind; cmp != 0 ) - return cmp; - if ( auto cmp = quadDivergentImplicitLod <=> rhs.quadDivergentImplicitLod; cmp != 0 ) - return cmp; - if ( auto cmp = maxPerStageDescriptorUpdateAfterBindSamplers <=> rhs.maxPerStageDescriptorUpdateAfterBindSamplers; cmp != 0 ) - return cmp; - if ( auto cmp = maxPerStageDescriptorUpdateAfterBindUniformBuffers <=> rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers; cmp != 0 ) - return cmp; - if ( auto cmp = maxPerStageDescriptorUpdateAfterBindStorageBuffers <=> rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers; cmp != 0 ) - return cmp; - if ( auto cmp = maxPerStageDescriptorUpdateAfterBindSampledImages <=> rhs.maxPerStageDescriptorUpdateAfterBindSampledImages; cmp != 0 ) - return cmp; - if ( auto cmp = maxPerStageDescriptorUpdateAfterBindStorageImages <=> rhs.maxPerStageDescriptorUpdateAfterBindStorageImages; cmp != 0 ) - return cmp; - if ( auto cmp = maxPerStageDescriptorUpdateAfterBindInputAttachments <=> rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments; cmp != 0 ) - return cmp; - if ( auto cmp = maxPerStageUpdateAfterBindResources <=> rhs.maxPerStageUpdateAfterBindResources; cmp != 0 ) - return cmp; - if ( auto cmp = maxDescriptorSetUpdateAfterBindSamplers <=> rhs.maxDescriptorSetUpdateAfterBindSamplers; cmp != 0 ) - return cmp; - if ( auto cmp = maxDescriptorSetUpdateAfterBindUniformBuffers <=> rhs.maxDescriptorSetUpdateAfterBindUniformBuffers; cmp != 0 ) - return cmp; - if ( auto cmp = maxDescriptorSetUpdateAfterBindUniformBuffersDynamic <=> rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; cmp != 0 ) - return cmp; - if ( auto cmp = maxDescriptorSetUpdateAfterBindStorageBuffers <=> rhs.maxDescriptorSetUpdateAfterBindStorageBuffers; cmp != 0 ) - return cmp; - if ( auto cmp = maxDescriptorSetUpdateAfterBindStorageBuffersDynamic <=> rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; cmp != 0 ) - return cmp; - if ( auto cmp = maxDescriptorSetUpdateAfterBindSampledImages <=> rhs.maxDescriptorSetUpdateAfterBindSampledImages; cmp != 0 ) - return cmp; - if ( auto cmp = maxDescriptorSetUpdateAfterBindStorageImages <=> rhs.maxDescriptorSetUpdateAfterBindStorageImages; cmp != 0 ) - return cmp; - if ( auto cmp = maxDescriptorSetUpdateAfterBindInputAttachments <=> rhs.maxDescriptorSetUpdateAfterBindInputAttachments; cmp != 0 ) - return cmp; - if ( auto cmp = supportedDepthResolveModes <=> rhs.supportedDepthResolveModes; cmp != 0 ) - return cmp; - if ( auto cmp = supportedStencilResolveModes <=> rhs.supportedStencilResolveModes; cmp != 0 ) - return cmp; - if ( auto cmp = independentResolveNone <=> rhs.independentResolveNone; cmp != 0 ) - return cmp; - if ( auto cmp = independentResolve <=> rhs.independentResolve; cmp != 0 ) - return cmp; - if ( auto cmp = filterMinmaxSingleComponentFormats <=> rhs.filterMinmaxSingleComponentFormats; cmp != 0 ) - return cmp; - if ( auto cmp = filterMinmaxImageComponentMapping <=> rhs.filterMinmaxImageComponentMapping; cmp != 0 ) - return cmp; - if ( auto cmp = maxTimelineSemaphoreValueDifference <=> rhs.maxTimelineSemaphoreValueDifference; cmp != 0 ) - return cmp; - if ( auto cmp = framebufferIntegerColorSampleCounts <=> rhs.framebufferIntegerColorSampleCounts; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( driverID == rhs.driverID ) && ( strcmp( driverName, rhs.driverName ) == 0 ) && - ( strcmp( driverInfo, rhs.driverInfo ) == 0 ) && ( conformanceVersion == rhs.conformanceVersion ) && - ( denormBehaviorIndependence == rhs.denormBehaviorIndependence ) && ( roundingModeIndependence == rhs.roundingModeIndependence ) && - ( shaderSignedZeroInfNanPreserveFloat16 == rhs.shaderSignedZeroInfNanPreserveFloat16 ) && - ( shaderSignedZeroInfNanPreserveFloat32 == rhs.shaderSignedZeroInfNanPreserveFloat32 ) && - ( shaderSignedZeroInfNanPreserveFloat64 == rhs.shaderSignedZeroInfNanPreserveFloat64 ) && - ( shaderDenormPreserveFloat16 == rhs.shaderDenormPreserveFloat16 ) && ( shaderDenormPreserveFloat32 == rhs.shaderDenormPreserveFloat32 ) && - ( shaderDenormPreserveFloat64 == rhs.shaderDenormPreserveFloat64 ) && ( shaderDenormFlushToZeroFloat16 == rhs.shaderDenormFlushToZeroFloat16 ) && - ( shaderDenormFlushToZeroFloat32 == rhs.shaderDenormFlushToZeroFloat32 ) && - ( shaderDenormFlushToZeroFloat64 == rhs.shaderDenormFlushToZeroFloat64 ) && ( shaderRoundingModeRTEFloat16 == rhs.shaderRoundingModeRTEFloat16 ) && - ( shaderRoundingModeRTEFloat32 == rhs.shaderRoundingModeRTEFloat32 ) && ( shaderRoundingModeRTEFloat64 == rhs.shaderRoundingModeRTEFloat64 ) && - ( shaderRoundingModeRTZFloat16 == rhs.shaderRoundingModeRTZFloat16 ) && ( shaderRoundingModeRTZFloat32 == rhs.shaderRoundingModeRTZFloat32 ) && - ( shaderRoundingModeRTZFloat64 == rhs.shaderRoundingModeRTZFloat64 ) && - ( maxUpdateAfterBindDescriptorsInAllPools == rhs.maxUpdateAfterBindDescriptorsInAllPools ) && - ( shaderUniformBufferArrayNonUniformIndexingNative == rhs.shaderUniformBufferArrayNonUniformIndexingNative ) && - ( shaderSampledImageArrayNonUniformIndexingNative == rhs.shaderSampledImageArrayNonUniformIndexingNative ) && - ( shaderStorageBufferArrayNonUniformIndexingNative == rhs.shaderStorageBufferArrayNonUniformIndexingNative ) && - ( shaderStorageImageArrayNonUniformIndexingNative == rhs.shaderStorageImageArrayNonUniformIndexingNative ) && - ( shaderInputAttachmentArrayNonUniformIndexingNative == rhs.shaderInputAttachmentArrayNonUniformIndexingNative ) && - ( robustBufferAccessUpdateAfterBind == rhs.robustBufferAccessUpdateAfterBind ) && ( quadDivergentImplicitLod == rhs.quadDivergentImplicitLod ) && - ( maxPerStageDescriptorUpdateAfterBindSamplers == rhs.maxPerStageDescriptorUpdateAfterBindSamplers ) && - ( maxPerStageDescriptorUpdateAfterBindUniformBuffers == rhs.maxPerStageDescriptorUpdateAfterBindUniformBuffers ) && - ( maxPerStageDescriptorUpdateAfterBindStorageBuffers == rhs.maxPerStageDescriptorUpdateAfterBindStorageBuffers ) && - ( maxPerStageDescriptorUpdateAfterBindSampledImages == rhs.maxPerStageDescriptorUpdateAfterBindSampledImages ) && - ( maxPerStageDescriptorUpdateAfterBindStorageImages == rhs.maxPerStageDescriptorUpdateAfterBindStorageImages ) && - ( maxPerStageDescriptorUpdateAfterBindInputAttachments == rhs.maxPerStageDescriptorUpdateAfterBindInputAttachments ) && - ( maxPerStageUpdateAfterBindResources == rhs.maxPerStageUpdateAfterBindResources ) && - ( maxDescriptorSetUpdateAfterBindSamplers == rhs.maxDescriptorSetUpdateAfterBindSamplers ) && - ( maxDescriptorSetUpdateAfterBindUniformBuffers == rhs.maxDescriptorSetUpdateAfterBindUniformBuffers ) && - ( maxDescriptorSetUpdateAfterBindUniformBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindUniformBuffersDynamic ) && - ( maxDescriptorSetUpdateAfterBindStorageBuffers == rhs.maxDescriptorSetUpdateAfterBindStorageBuffers ) && - ( maxDescriptorSetUpdateAfterBindStorageBuffersDynamic == rhs.maxDescriptorSetUpdateAfterBindStorageBuffersDynamic ) && - ( maxDescriptorSetUpdateAfterBindSampledImages == rhs.maxDescriptorSetUpdateAfterBindSampledImages ) && - ( maxDescriptorSetUpdateAfterBindStorageImages == rhs.maxDescriptorSetUpdateAfterBindStorageImages ) && - ( maxDescriptorSetUpdateAfterBindInputAttachments == rhs.maxDescriptorSetUpdateAfterBindInputAttachments ) && - ( supportedDepthResolveModes == rhs.supportedDepthResolveModes ) && ( supportedStencilResolveModes == rhs.supportedStencilResolveModes ) && - ( independentResolveNone == rhs.independentResolveNone ) && ( independentResolve == rhs.independentResolve ) && - ( filterMinmaxSingleComponentFormats == rhs.filterMinmaxSingleComponentFormats ) && - ( filterMinmaxImageComponentMapping == rhs.filterMinmaxImageComponentMapping ) && - ( maxTimelineSemaphoreValueDifference == rhs.maxTimelineSemaphoreValueDifference ) && - ( framebufferIntegerColorSampleCounts == rhs.framebufferIntegerColorSampleCounts ); - } - - bool operator!=( PhysicalDeviceVulkan12Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::ePhysicalDeviceVulkan12Properties; - void * pNext = {}; - DriverId driverID = DriverId::eAmdProprietary; - ArrayWrapper1D driverName = {}; - ArrayWrapper1D driverInfo = {}; - ConformanceVersion conformanceVersion = {}; - ShaderFloatControlsIndependence denormBehaviorIndependence = ShaderFloatControlsIndependence::e32BitOnly; - ShaderFloatControlsIndependence roundingModeIndependence = ShaderFloatControlsIndependence::e32BitOnly; - Bool32 shaderSignedZeroInfNanPreserveFloat16 = {}; - Bool32 shaderSignedZeroInfNanPreserveFloat32 = {}; - Bool32 shaderSignedZeroInfNanPreserveFloat64 = {}; - Bool32 shaderDenormPreserveFloat16 = {}; - Bool32 shaderDenormPreserveFloat32 = {}; - Bool32 shaderDenormPreserveFloat64 = {}; - Bool32 shaderDenormFlushToZeroFloat16 = {}; - Bool32 shaderDenormFlushToZeroFloat32 = {}; - Bool32 shaderDenormFlushToZeroFloat64 = {}; - Bool32 shaderRoundingModeRTEFloat16 = {}; - Bool32 shaderRoundingModeRTEFloat32 = {}; - Bool32 shaderRoundingModeRTEFloat64 = {}; - Bool32 shaderRoundingModeRTZFloat16 = {}; - Bool32 shaderRoundingModeRTZFloat32 = {}; - Bool32 shaderRoundingModeRTZFloat64 = {}; - uint32_t maxUpdateAfterBindDescriptorsInAllPools = {}; - Bool32 shaderUniformBufferArrayNonUniformIndexingNative = {}; - Bool32 shaderSampledImageArrayNonUniformIndexingNative = {}; - Bool32 shaderStorageBufferArrayNonUniformIndexingNative = {}; - Bool32 shaderStorageImageArrayNonUniformIndexingNative = {}; - Bool32 shaderInputAttachmentArrayNonUniformIndexingNative = {}; - Bool32 robustBufferAccessUpdateAfterBind = {}; - Bool32 quadDivergentImplicitLod = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments = {}; - uint32_t maxPerStageUpdateAfterBindResources = {}; - uint32_t maxDescriptorSetUpdateAfterBindSamplers = {}; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers = {}; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = {}; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers = {}; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = {}; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages = {}; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages = {}; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments = {}; - ResolveModeFlags supportedDepthResolveModes = {}; - ResolveModeFlags supportedStencilResolveModes = {}; - Bool32 independentResolveNone = {}; - Bool32 independentResolve = {}; - Bool32 filterMinmaxSingleComponentFormats = {}; - Bool32 filterMinmaxImageComponentMapping = {}; - uint64_t maxTimelineSemaphoreValueDifference = {}; - SampleCountFlags framebufferIntegerColorSampleCounts = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan12Properties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan12Properties; - }; - - // wrapper struct for struct VkPhysicalDeviceVulkan13Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan13Features.html - struct PhysicalDeviceVulkan13Features - { - using NativeType = VkPhysicalDeviceVulkan13Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan13Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan13Features( Bool32 robustImageAccess_ = {}, - Bool32 inlineUniformBlock_ = {}, - Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ = {}, - Bool32 pipelineCreationCacheControl_ = {}, - Bool32 privateData_ = {}, - Bool32 shaderDemoteToHelperInvocation_ = {}, - Bool32 shaderTerminateInvocation_ = {}, - Bool32 subgroupSizeControl_ = {}, - Bool32 computeFullSubgroups_ = {}, - Bool32 synchronization2_ = {}, - Bool32 textureCompressionASTC_HDR_ = {}, - Bool32 shaderZeroInitializeWorkgroupMemory_ = {}, - Bool32 dynamicRendering_ = {}, - Bool32 shaderIntegerDotProduct_ = {}, - Bool32 maintenance4_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , robustImageAccess{ robustImageAccess_ } - , inlineUniformBlock{ inlineUniformBlock_ } - , descriptorBindingInlineUniformBlockUpdateAfterBind{ descriptorBindingInlineUniformBlockUpdateAfterBind_ } - , pipelineCreationCacheControl{ pipelineCreationCacheControl_ } - , privateData{ privateData_ } - , shaderDemoteToHelperInvocation{ shaderDemoteToHelperInvocation_ } - , shaderTerminateInvocation{ shaderTerminateInvocation_ } - , subgroupSizeControl{ subgroupSizeControl_ } - , computeFullSubgroups{ computeFullSubgroups_ } - , synchronization2{ synchronization2_ } - , textureCompressionASTC_HDR{ textureCompressionASTC_HDR_ } - , shaderZeroInitializeWorkgroupMemory{ shaderZeroInitializeWorkgroupMemory_ } - , dynamicRendering{ dynamicRendering_ } - , shaderIntegerDotProduct{ shaderIntegerDotProduct_ } - , maintenance4{ maintenance4_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan13Features( PhysicalDeviceVulkan13Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVulkan13Features( VkPhysicalDeviceVulkan13Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVulkan13Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVulkan13Features & operator=( PhysicalDeviceVulkan13Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVulkan13Features & operator=( VkPhysicalDeviceVulkan13Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setRobustImageAccess( Bool32 robustImageAccess_ ) & VULKAN_HPP_NOEXCEPT - { - robustImageAccess = robustImageAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setRobustImageAccess( Bool32 robustImageAccess_ ) && VULKAN_HPP_NOEXCEPT - { - robustImageAccess = robustImageAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setInlineUniformBlock( Bool32 inlineUniformBlock_ ) & VULKAN_HPP_NOEXCEPT - { - inlineUniformBlock = inlineUniformBlock_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setInlineUniformBlock( Bool32 inlineUniformBlock_ ) && VULKAN_HPP_NOEXCEPT - { - inlineUniformBlock = inlineUniformBlock_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & - setDescriptorBindingInlineUniformBlockUpdateAfterBind( Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && - setDescriptorBindingInlineUniformBlockUpdateAfterBind( Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorBindingInlineUniformBlockUpdateAfterBind = descriptorBindingInlineUniformBlockUpdateAfterBind_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setPipelineCreationCacheControl( Bool32 pipelineCreationCacheControl_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineCreationCacheControl = pipelineCreationCacheControl_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setPipelineCreationCacheControl( Bool32 pipelineCreationCacheControl_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineCreationCacheControl = pipelineCreationCacheControl_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setPrivateData( Bool32 privateData_ ) & VULKAN_HPP_NOEXCEPT - { - privateData = privateData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setPrivateData( Bool32 privateData_ ) && VULKAN_HPP_NOEXCEPT - { - privateData = privateData_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setShaderDemoteToHelperInvocation( Bool32 shaderDemoteToHelperInvocation_ ) & VULKAN_HPP_NOEXCEPT - { - shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setShaderDemoteToHelperInvocation( Bool32 shaderDemoteToHelperInvocation_ ) && VULKAN_HPP_NOEXCEPT - { - shaderDemoteToHelperInvocation = shaderDemoteToHelperInvocation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setShaderTerminateInvocation( Bool32 shaderTerminateInvocation_ ) & VULKAN_HPP_NOEXCEPT - { - shaderTerminateInvocation = shaderTerminateInvocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setShaderTerminateInvocation( Bool32 shaderTerminateInvocation_ ) && VULKAN_HPP_NOEXCEPT - { - shaderTerminateInvocation = shaderTerminateInvocation_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setSubgroupSizeControl( Bool32 subgroupSizeControl_ ) & VULKAN_HPP_NOEXCEPT - { - subgroupSizeControl = subgroupSizeControl_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setSubgroupSizeControl( Bool32 subgroupSizeControl_ ) && VULKAN_HPP_NOEXCEPT - { - subgroupSizeControl = subgroupSizeControl_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setComputeFullSubgroups( Bool32 computeFullSubgroups_ ) & VULKAN_HPP_NOEXCEPT - { - computeFullSubgroups = computeFullSubgroups_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setComputeFullSubgroups( Bool32 computeFullSubgroups_ ) && VULKAN_HPP_NOEXCEPT - { - computeFullSubgroups = computeFullSubgroups_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setSynchronization2( Bool32 synchronization2_ ) & VULKAN_HPP_NOEXCEPT - { - synchronization2 = synchronization2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setSynchronization2( Bool32 synchronization2_ ) && VULKAN_HPP_NOEXCEPT - { - synchronization2 = synchronization2_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setTextureCompressionASTC_HDR( Bool32 textureCompressionASTC_HDR_ ) & VULKAN_HPP_NOEXCEPT - { - textureCompressionASTC_HDR = textureCompressionASTC_HDR_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setTextureCompressionASTC_HDR( Bool32 textureCompressionASTC_HDR_ ) && VULKAN_HPP_NOEXCEPT - { - textureCompressionASTC_HDR = textureCompressionASTC_HDR_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setShaderZeroInitializeWorkgroupMemory( Bool32 shaderZeroInitializeWorkgroupMemory_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderZeroInitializeWorkgroupMemory = shaderZeroInitializeWorkgroupMemory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setShaderZeroInitializeWorkgroupMemory( Bool32 shaderZeroInitializeWorkgroupMemory_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderZeroInitializeWorkgroupMemory = shaderZeroInitializeWorkgroupMemory_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setDynamicRendering( Bool32 dynamicRendering_ ) & VULKAN_HPP_NOEXCEPT - { - dynamicRendering = dynamicRendering_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setDynamicRendering( Bool32 dynamicRendering_ ) && VULKAN_HPP_NOEXCEPT - { - dynamicRendering = dynamicRendering_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setShaderIntegerDotProduct( Bool32 shaderIntegerDotProduct_ ) & VULKAN_HPP_NOEXCEPT - { - shaderIntegerDotProduct = shaderIntegerDotProduct_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setShaderIntegerDotProduct( Bool32 shaderIntegerDotProduct_ ) && VULKAN_HPP_NOEXCEPT - { - shaderIntegerDotProduct = shaderIntegerDotProduct_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features & setMaintenance4( Bool32 maintenance4_ ) & VULKAN_HPP_NOEXCEPT - { - maintenance4 = maintenance4_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan13Features && setMaintenance4( Bool32 maintenance4_ ) && VULKAN_HPP_NOEXCEPT - { - maintenance4 = maintenance4_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVulkan13Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan13Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan13Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan13Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - robustImageAccess, - inlineUniformBlock, - descriptorBindingInlineUniformBlockUpdateAfterBind, - pipelineCreationCacheControl, - privateData, - shaderDemoteToHelperInvocation, - shaderTerminateInvocation, - subgroupSizeControl, - computeFullSubgroups, - synchronization2, - textureCompressionASTC_HDR, - shaderZeroInitializeWorkgroupMemory, - dynamicRendering, - shaderIntegerDotProduct, - maintenance4 ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVulkan13Features const & ) const = default; -#else - bool operator==( PhysicalDeviceVulkan13Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( robustImageAccess == rhs.robustImageAccess ) && - ( inlineUniformBlock == rhs.inlineUniformBlock ) && - ( descriptorBindingInlineUniformBlockUpdateAfterBind == rhs.descriptorBindingInlineUniformBlockUpdateAfterBind ) && - ( pipelineCreationCacheControl == rhs.pipelineCreationCacheControl ) && ( privateData == rhs.privateData ) && - ( shaderDemoteToHelperInvocation == rhs.shaderDemoteToHelperInvocation ) && ( shaderTerminateInvocation == rhs.shaderTerminateInvocation ) && - ( subgroupSizeControl == rhs.subgroupSizeControl ) && ( computeFullSubgroups == rhs.computeFullSubgroups ) && - ( synchronization2 == rhs.synchronization2 ) && ( textureCompressionASTC_HDR == rhs.textureCompressionASTC_HDR ) && - ( shaderZeroInitializeWorkgroupMemory == rhs.shaderZeroInitializeWorkgroupMemory ) && ( dynamicRendering == rhs.dynamicRendering ) && - ( shaderIntegerDotProduct == rhs.shaderIntegerDotProduct ) && ( maintenance4 == rhs.maintenance4 ); -# endif - } - - bool operator!=( PhysicalDeviceVulkan13Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVulkan13Features; - void * pNext = {}; - Bool32 robustImageAccess = {}; - Bool32 inlineUniformBlock = {}; - Bool32 descriptorBindingInlineUniformBlockUpdateAfterBind = {}; - Bool32 pipelineCreationCacheControl = {}; - Bool32 privateData = {}; - Bool32 shaderDemoteToHelperInvocation = {}; - Bool32 shaderTerminateInvocation = {}; - Bool32 subgroupSizeControl = {}; - Bool32 computeFullSubgroups = {}; - Bool32 synchronization2 = {}; - Bool32 textureCompressionASTC_HDR = {}; - Bool32 shaderZeroInitializeWorkgroupMemory = {}; - Bool32 dynamicRendering = {}; - Bool32 shaderIntegerDotProduct = {}; - Bool32 maintenance4 = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan13Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan13Features; - }; - - // wrapper struct for struct VkPhysicalDeviceVulkan13Properties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan13Properties.html - struct PhysicalDeviceVulkan13Properties - { - using NativeType = VkPhysicalDeviceVulkan13Properties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan13Properties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan13Properties( uint32_t minSubgroupSize_ = {}, - uint32_t maxSubgroupSize_ = {}, - uint32_t maxComputeWorkgroupSubgroups_ = {}, - ShaderStageFlags requiredSubgroupSizeStages_ = {}, - uint32_t maxInlineUniformBlockSize_ = {}, - uint32_t maxPerStageDescriptorInlineUniformBlocks_ = {}, - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ = {}, - uint32_t maxDescriptorSetInlineUniformBlocks_ = {}, - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ = {}, - uint32_t maxInlineUniformTotalSize_ = {}, - Bool32 integerDotProduct8BitUnsignedAccelerated_ = {}, - Bool32 integerDotProduct8BitSignedAccelerated_ = {}, - Bool32 integerDotProduct8BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProduct4x8BitPackedUnsignedAccelerated_ = {}, - Bool32 integerDotProduct4x8BitPackedSignedAccelerated_ = {}, - Bool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated_ = {}, - Bool32 integerDotProduct16BitUnsignedAccelerated_ = {}, - Bool32 integerDotProduct16BitSignedAccelerated_ = {}, - Bool32 integerDotProduct16BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProduct32BitUnsignedAccelerated_ = {}, - Bool32 integerDotProduct32BitSignedAccelerated_ = {}, - Bool32 integerDotProduct32BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProduct64BitUnsignedAccelerated_ = {}, - Bool32 integerDotProduct64BitSignedAccelerated_ = {}, - Bool32 integerDotProduct64BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated_ = {}, - Bool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated_ = {}, - DeviceSize storageTexelBufferOffsetAlignmentBytes_ = {}, - Bool32 storageTexelBufferOffsetSingleTexelAlignment_ = {}, - DeviceSize uniformTexelBufferOffsetAlignmentBytes_ = {}, - Bool32 uniformTexelBufferOffsetSingleTexelAlignment_ = {}, - DeviceSize maxBufferSize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minSubgroupSize{ minSubgroupSize_ } - , maxSubgroupSize{ maxSubgroupSize_ } - , maxComputeWorkgroupSubgroups{ maxComputeWorkgroupSubgroups_ } - , requiredSubgroupSizeStages{ requiredSubgroupSizeStages_ } - , maxInlineUniformBlockSize{ maxInlineUniformBlockSize_ } - , maxPerStageDescriptorInlineUniformBlocks{ maxPerStageDescriptorInlineUniformBlocks_ } - , maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks{ maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks_ } - , maxDescriptorSetInlineUniformBlocks{ maxDescriptorSetInlineUniformBlocks_ } - , maxDescriptorSetUpdateAfterBindInlineUniformBlocks{ maxDescriptorSetUpdateAfterBindInlineUniformBlocks_ } - , maxInlineUniformTotalSize{ maxInlineUniformTotalSize_ } - , integerDotProduct8BitUnsignedAccelerated{ integerDotProduct8BitUnsignedAccelerated_ } - , integerDotProduct8BitSignedAccelerated{ integerDotProduct8BitSignedAccelerated_ } - , integerDotProduct8BitMixedSignednessAccelerated{ integerDotProduct8BitMixedSignednessAccelerated_ } - , integerDotProduct4x8BitPackedUnsignedAccelerated{ integerDotProduct4x8BitPackedUnsignedAccelerated_ } - , integerDotProduct4x8BitPackedSignedAccelerated{ integerDotProduct4x8BitPackedSignedAccelerated_ } - , integerDotProduct4x8BitPackedMixedSignednessAccelerated{ integerDotProduct4x8BitPackedMixedSignednessAccelerated_ } - , integerDotProduct16BitUnsignedAccelerated{ integerDotProduct16BitUnsignedAccelerated_ } - , integerDotProduct16BitSignedAccelerated{ integerDotProduct16BitSignedAccelerated_ } - , integerDotProduct16BitMixedSignednessAccelerated{ integerDotProduct16BitMixedSignednessAccelerated_ } - , integerDotProduct32BitUnsignedAccelerated{ integerDotProduct32BitUnsignedAccelerated_ } - , integerDotProduct32BitSignedAccelerated{ integerDotProduct32BitSignedAccelerated_ } - , integerDotProduct32BitMixedSignednessAccelerated{ integerDotProduct32BitMixedSignednessAccelerated_ } - , integerDotProduct64BitUnsignedAccelerated{ integerDotProduct64BitUnsignedAccelerated_ } - , integerDotProduct64BitSignedAccelerated{ integerDotProduct64BitSignedAccelerated_ } - , integerDotProduct64BitMixedSignednessAccelerated{ integerDotProduct64BitMixedSignednessAccelerated_ } - , integerDotProductAccumulatingSaturating8BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating8BitUnsignedAccelerated_ } - , integerDotProductAccumulatingSaturating8BitSignedAccelerated{ integerDotProductAccumulatingSaturating8BitSignedAccelerated_ } - , integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated_ } - , integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated_ } - , integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated_ } - , integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated_ } - , integerDotProductAccumulatingSaturating16BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating16BitUnsignedAccelerated_ } - , integerDotProductAccumulatingSaturating16BitSignedAccelerated{ integerDotProductAccumulatingSaturating16BitSignedAccelerated_ } - , integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated_ } - , integerDotProductAccumulatingSaturating32BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating32BitUnsignedAccelerated_ } - , integerDotProductAccumulatingSaturating32BitSignedAccelerated{ integerDotProductAccumulatingSaturating32BitSignedAccelerated_ } - , integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated_ } - , integerDotProductAccumulatingSaturating64BitUnsignedAccelerated{ integerDotProductAccumulatingSaturating64BitUnsignedAccelerated_ } - , integerDotProductAccumulatingSaturating64BitSignedAccelerated{ integerDotProductAccumulatingSaturating64BitSignedAccelerated_ } - , integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated{ integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated_ } - , storageTexelBufferOffsetAlignmentBytes{ storageTexelBufferOffsetAlignmentBytes_ } - , storageTexelBufferOffsetSingleTexelAlignment{ storageTexelBufferOffsetSingleTexelAlignment_ } - , uniformTexelBufferOffsetAlignmentBytes{ uniformTexelBufferOffsetAlignmentBytes_ } - , uniformTexelBufferOffsetSingleTexelAlignment{ uniformTexelBufferOffsetSingleTexelAlignment_ } - , maxBufferSize{ maxBufferSize_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan13Properties( PhysicalDeviceVulkan13Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVulkan13Properties( VkPhysicalDeviceVulkan13Properties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVulkan13Properties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVulkan13Properties & operator=( PhysicalDeviceVulkan13Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVulkan13Properties & operator=( VkPhysicalDeviceVulkan13Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceVulkan13Properties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan13Properties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan13Properties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan13Properties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - minSubgroupSize, - maxSubgroupSize, - maxComputeWorkgroupSubgroups, - requiredSubgroupSizeStages, - maxInlineUniformBlockSize, - maxPerStageDescriptorInlineUniformBlocks, - maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks, - maxDescriptorSetInlineUniformBlocks, - maxDescriptorSetUpdateAfterBindInlineUniformBlocks, - maxInlineUniformTotalSize, - integerDotProduct8BitUnsignedAccelerated, - integerDotProduct8BitSignedAccelerated, - integerDotProduct8BitMixedSignednessAccelerated, - integerDotProduct4x8BitPackedUnsignedAccelerated, - integerDotProduct4x8BitPackedSignedAccelerated, - integerDotProduct4x8BitPackedMixedSignednessAccelerated, - integerDotProduct16BitUnsignedAccelerated, - integerDotProduct16BitSignedAccelerated, - integerDotProduct16BitMixedSignednessAccelerated, - integerDotProduct32BitUnsignedAccelerated, - integerDotProduct32BitSignedAccelerated, - integerDotProduct32BitMixedSignednessAccelerated, - integerDotProduct64BitUnsignedAccelerated, - integerDotProduct64BitSignedAccelerated, - integerDotProduct64BitMixedSignednessAccelerated, - integerDotProductAccumulatingSaturating8BitUnsignedAccelerated, - integerDotProductAccumulatingSaturating8BitSignedAccelerated, - integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated, - integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated, - integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated, - integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated, - integerDotProductAccumulatingSaturating16BitUnsignedAccelerated, - integerDotProductAccumulatingSaturating16BitSignedAccelerated, - integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated, - integerDotProductAccumulatingSaturating32BitUnsignedAccelerated, - integerDotProductAccumulatingSaturating32BitSignedAccelerated, - integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated, - integerDotProductAccumulatingSaturating64BitUnsignedAccelerated, - integerDotProductAccumulatingSaturating64BitSignedAccelerated, - integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated, - storageTexelBufferOffsetAlignmentBytes, - storageTexelBufferOffsetSingleTexelAlignment, - uniformTexelBufferOffsetAlignmentBytes, - uniformTexelBufferOffsetSingleTexelAlignment, - maxBufferSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVulkan13Properties const & ) const = default; -#else - bool operator==( PhysicalDeviceVulkan13Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minSubgroupSize == rhs.minSubgroupSize ) && ( maxSubgroupSize == rhs.maxSubgroupSize ) && - ( maxComputeWorkgroupSubgroups == rhs.maxComputeWorkgroupSubgroups ) && ( requiredSubgroupSizeStages == rhs.requiredSubgroupSizeStages ) && - ( maxInlineUniformBlockSize == rhs.maxInlineUniformBlockSize ) && - ( maxPerStageDescriptorInlineUniformBlocks == rhs.maxPerStageDescriptorInlineUniformBlocks ) && - ( maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks == rhs.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks ) && - ( maxDescriptorSetInlineUniformBlocks == rhs.maxDescriptorSetInlineUniformBlocks ) && - ( maxDescriptorSetUpdateAfterBindInlineUniformBlocks == rhs.maxDescriptorSetUpdateAfterBindInlineUniformBlocks ) && - ( maxInlineUniformTotalSize == rhs.maxInlineUniformTotalSize ) && - ( integerDotProduct8BitUnsignedAccelerated == rhs.integerDotProduct8BitUnsignedAccelerated ) && - ( integerDotProduct8BitSignedAccelerated == rhs.integerDotProduct8BitSignedAccelerated ) && - ( integerDotProduct8BitMixedSignednessAccelerated == rhs.integerDotProduct8BitMixedSignednessAccelerated ) && - ( integerDotProduct4x8BitPackedUnsignedAccelerated == rhs.integerDotProduct4x8BitPackedUnsignedAccelerated ) && - ( integerDotProduct4x8BitPackedSignedAccelerated == rhs.integerDotProduct4x8BitPackedSignedAccelerated ) && - ( integerDotProduct4x8BitPackedMixedSignednessAccelerated == rhs.integerDotProduct4x8BitPackedMixedSignednessAccelerated ) && - ( integerDotProduct16BitUnsignedAccelerated == rhs.integerDotProduct16BitUnsignedAccelerated ) && - ( integerDotProduct16BitSignedAccelerated == rhs.integerDotProduct16BitSignedAccelerated ) && - ( integerDotProduct16BitMixedSignednessAccelerated == rhs.integerDotProduct16BitMixedSignednessAccelerated ) && - ( integerDotProduct32BitUnsignedAccelerated == rhs.integerDotProduct32BitUnsignedAccelerated ) && - ( integerDotProduct32BitSignedAccelerated == rhs.integerDotProduct32BitSignedAccelerated ) && - ( integerDotProduct32BitMixedSignednessAccelerated == rhs.integerDotProduct32BitMixedSignednessAccelerated ) && - ( integerDotProduct64BitUnsignedAccelerated == rhs.integerDotProduct64BitUnsignedAccelerated ) && - ( integerDotProduct64BitSignedAccelerated == rhs.integerDotProduct64BitSignedAccelerated ) && - ( integerDotProduct64BitMixedSignednessAccelerated == rhs.integerDotProduct64BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating8BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating8BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating8BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating8BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated == - rhs.integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated == - rhs.integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating16BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating16BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating16BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating16BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating32BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating32BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating32BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating32BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated ) && - ( integerDotProductAccumulatingSaturating64BitUnsignedAccelerated == rhs.integerDotProductAccumulatingSaturating64BitUnsignedAccelerated ) && - ( integerDotProductAccumulatingSaturating64BitSignedAccelerated == rhs.integerDotProductAccumulatingSaturating64BitSignedAccelerated ) && - ( integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated == - rhs.integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated ) && - ( storageTexelBufferOffsetAlignmentBytes == rhs.storageTexelBufferOffsetAlignmentBytes ) && - ( storageTexelBufferOffsetSingleTexelAlignment == rhs.storageTexelBufferOffsetSingleTexelAlignment ) && - ( uniformTexelBufferOffsetAlignmentBytes == rhs.uniformTexelBufferOffsetAlignmentBytes ) && - ( uniformTexelBufferOffsetSingleTexelAlignment == rhs.uniformTexelBufferOffsetSingleTexelAlignment ) && ( maxBufferSize == rhs.maxBufferSize ); -# endif - } - - bool operator!=( PhysicalDeviceVulkan13Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVulkan13Properties; - void * pNext = {}; - uint32_t minSubgroupSize = {}; - uint32_t maxSubgroupSize = {}; - uint32_t maxComputeWorkgroupSubgroups = {}; - ShaderStageFlags requiredSubgroupSizeStages = {}; - uint32_t maxInlineUniformBlockSize = {}; - uint32_t maxPerStageDescriptorInlineUniformBlocks = {}; - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = {}; - uint32_t maxDescriptorSetInlineUniformBlocks = {}; - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks = {}; - uint32_t maxInlineUniformTotalSize = {}; - Bool32 integerDotProduct8BitUnsignedAccelerated = {}; - Bool32 integerDotProduct8BitSignedAccelerated = {}; - Bool32 integerDotProduct8BitMixedSignednessAccelerated = {}; - Bool32 integerDotProduct4x8BitPackedUnsignedAccelerated = {}; - Bool32 integerDotProduct4x8BitPackedSignedAccelerated = {}; - Bool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated = {}; - Bool32 integerDotProduct16BitUnsignedAccelerated = {}; - Bool32 integerDotProduct16BitSignedAccelerated = {}; - Bool32 integerDotProduct16BitMixedSignednessAccelerated = {}; - Bool32 integerDotProduct32BitUnsignedAccelerated = {}; - Bool32 integerDotProduct32BitSignedAccelerated = {}; - Bool32 integerDotProduct32BitMixedSignednessAccelerated = {}; - Bool32 integerDotProduct64BitUnsignedAccelerated = {}; - Bool32 integerDotProduct64BitSignedAccelerated = {}; - Bool32 integerDotProduct64BitMixedSignednessAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated = {}; - Bool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = {}; - DeviceSize storageTexelBufferOffsetAlignmentBytes = {}; - Bool32 storageTexelBufferOffsetSingleTexelAlignment = {}; - DeviceSize uniformTexelBufferOffsetAlignmentBytes = {}; - Bool32 uniformTexelBufferOffsetSingleTexelAlignment = {}; - DeviceSize maxBufferSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan13Properties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan13Properties; - }; - - // wrapper struct for struct VkPhysicalDeviceVulkan14Features, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan14Features.html - struct PhysicalDeviceVulkan14Features - { - using NativeType = VkPhysicalDeviceVulkan14Features; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan14Features; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan14Features( Bool32 globalPriorityQuery_ = {}, - Bool32 shaderSubgroupRotate_ = {}, - Bool32 shaderSubgroupRotateClustered_ = {}, - Bool32 shaderFloatControls2_ = {}, - Bool32 shaderExpectAssume_ = {}, - Bool32 rectangularLines_ = {}, - Bool32 bresenhamLines_ = {}, - Bool32 smoothLines_ = {}, - Bool32 stippledRectangularLines_ = {}, - Bool32 stippledBresenhamLines_ = {}, - Bool32 stippledSmoothLines_ = {}, - Bool32 vertexAttributeInstanceRateDivisor_ = {}, - Bool32 vertexAttributeInstanceRateZeroDivisor_ = {}, - Bool32 indexTypeUint8_ = {}, - Bool32 dynamicRenderingLocalRead_ = {}, - Bool32 maintenance5_ = {}, - Bool32 maintenance6_ = {}, - Bool32 pipelineProtectedAccess_ = {}, - Bool32 pipelineRobustness_ = {}, - Bool32 hostImageCopy_ = {}, - Bool32 pushDescriptor_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , globalPriorityQuery{ globalPriorityQuery_ } - , shaderSubgroupRotate{ shaderSubgroupRotate_ } - , shaderSubgroupRotateClustered{ shaderSubgroupRotateClustered_ } - , shaderFloatControls2{ shaderFloatControls2_ } - , shaderExpectAssume{ shaderExpectAssume_ } - , rectangularLines{ rectangularLines_ } - , bresenhamLines{ bresenhamLines_ } - , smoothLines{ smoothLines_ } - , stippledRectangularLines{ stippledRectangularLines_ } - , stippledBresenhamLines{ stippledBresenhamLines_ } - , stippledSmoothLines{ stippledSmoothLines_ } - , vertexAttributeInstanceRateDivisor{ vertexAttributeInstanceRateDivisor_ } - , vertexAttributeInstanceRateZeroDivisor{ vertexAttributeInstanceRateZeroDivisor_ } - , indexTypeUint8{ indexTypeUint8_ } - , dynamicRenderingLocalRead{ dynamicRenderingLocalRead_ } - , maintenance5{ maintenance5_ } - , maintenance6{ maintenance6_ } - , pipelineProtectedAccess{ pipelineProtectedAccess_ } - , pipelineRobustness{ pipelineRobustness_ } - , hostImageCopy{ hostImageCopy_ } - , pushDescriptor{ pushDescriptor_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkan14Features( PhysicalDeviceVulkan14Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVulkan14Features( VkPhysicalDeviceVulkan14Features const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVulkan14Features( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVulkan14Features & operator=( PhysicalDeviceVulkan14Features const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVulkan14Features & operator=( VkPhysicalDeviceVulkan14Features const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setGlobalPriorityQuery( Bool32 globalPriorityQuery_ ) & VULKAN_HPP_NOEXCEPT - { - globalPriorityQuery = globalPriorityQuery_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setGlobalPriorityQuery( Bool32 globalPriorityQuery_ ) && VULKAN_HPP_NOEXCEPT - { - globalPriorityQuery = globalPriorityQuery_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setShaderSubgroupRotate( Bool32 shaderSubgroupRotate_ ) & VULKAN_HPP_NOEXCEPT - { - shaderSubgroupRotate = shaderSubgroupRotate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setShaderSubgroupRotate( Bool32 shaderSubgroupRotate_ ) && VULKAN_HPP_NOEXCEPT - { - shaderSubgroupRotate = shaderSubgroupRotate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setShaderSubgroupRotateClustered( Bool32 shaderSubgroupRotateClustered_ ) & VULKAN_HPP_NOEXCEPT - { - shaderSubgroupRotateClustered = shaderSubgroupRotateClustered_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setShaderSubgroupRotateClustered( Bool32 shaderSubgroupRotateClustered_ ) && VULKAN_HPP_NOEXCEPT - { - shaderSubgroupRotateClustered = shaderSubgroupRotateClustered_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setShaderFloatControls2( Bool32 shaderFloatControls2_ ) & VULKAN_HPP_NOEXCEPT - { - shaderFloatControls2 = shaderFloatControls2_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setShaderFloatControls2( Bool32 shaderFloatControls2_ ) && VULKAN_HPP_NOEXCEPT - { - shaderFloatControls2 = shaderFloatControls2_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setShaderExpectAssume( Bool32 shaderExpectAssume_ ) & VULKAN_HPP_NOEXCEPT - { - shaderExpectAssume = shaderExpectAssume_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setShaderExpectAssume( Bool32 shaderExpectAssume_ ) && VULKAN_HPP_NOEXCEPT - { - shaderExpectAssume = shaderExpectAssume_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setRectangularLines( Bool32 rectangularLines_ ) & VULKAN_HPP_NOEXCEPT - { - rectangularLines = rectangularLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setRectangularLines( Bool32 rectangularLines_ ) && VULKAN_HPP_NOEXCEPT - { - rectangularLines = rectangularLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setBresenhamLines( Bool32 bresenhamLines_ ) & VULKAN_HPP_NOEXCEPT - { - bresenhamLines = bresenhamLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setBresenhamLines( Bool32 bresenhamLines_ ) && VULKAN_HPP_NOEXCEPT - { - bresenhamLines = bresenhamLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setSmoothLines( Bool32 smoothLines_ ) & VULKAN_HPP_NOEXCEPT - { - smoothLines = smoothLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setSmoothLines( Bool32 smoothLines_ ) && VULKAN_HPP_NOEXCEPT - { - smoothLines = smoothLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setStippledRectangularLines( Bool32 stippledRectangularLines_ ) & VULKAN_HPP_NOEXCEPT - { - stippledRectangularLines = stippledRectangularLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setStippledRectangularLines( Bool32 stippledRectangularLines_ ) && VULKAN_HPP_NOEXCEPT - { - stippledRectangularLines = stippledRectangularLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setStippledBresenhamLines( Bool32 stippledBresenhamLines_ ) & VULKAN_HPP_NOEXCEPT - { - stippledBresenhamLines = stippledBresenhamLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setStippledBresenhamLines( Bool32 stippledBresenhamLines_ ) && VULKAN_HPP_NOEXCEPT - { - stippledBresenhamLines = stippledBresenhamLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setStippledSmoothLines( Bool32 stippledSmoothLines_ ) & VULKAN_HPP_NOEXCEPT - { - stippledSmoothLines = stippledSmoothLines_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setStippledSmoothLines( Bool32 stippledSmoothLines_ ) && VULKAN_HPP_NOEXCEPT - { - stippledSmoothLines = stippledSmoothLines_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setVertexAttributeInstanceRateDivisor( Bool32 vertexAttributeInstanceRateDivisor_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexAttributeInstanceRateDivisor = vertexAttributeInstanceRateDivisor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setVertexAttributeInstanceRateZeroDivisor( Bool32 vertexAttributeInstanceRateZeroDivisor_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexAttributeInstanceRateZeroDivisor = vertexAttributeInstanceRateZeroDivisor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setIndexTypeUint8( Bool32 indexTypeUint8_ ) & VULKAN_HPP_NOEXCEPT - { - indexTypeUint8 = indexTypeUint8_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setIndexTypeUint8( Bool32 indexTypeUint8_ ) && VULKAN_HPP_NOEXCEPT - { - indexTypeUint8 = indexTypeUint8_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setDynamicRenderingLocalRead( Bool32 dynamicRenderingLocalRead_ ) & VULKAN_HPP_NOEXCEPT - { - dynamicRenderingLocalRead = dynamicRenderingLocalRead_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setDynamicRenderingLocalRead( Bool32 dynamicRenderingLocalRead_ ) && VULKAN_HPP_NOEXCEPT - { - dynamicRenderingLocalRead = dynamicRenderingLocalRead_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setMaintenance5( Bool32 maintenance5_ ) & VULKAN_HPP_NOEXCEPT - { - maintenance5 = maintenance5_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setMaintenance5( Bool32 maintenance5_ ) && VULKAN_HPP_NOEXCEPT - { - maintenance5 = maintenance5_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setMaintenance6( Bool32 maintenance6_ ) & VULKAN_HPP_NOEXCEPT - { - maintenance6 = maintenance6_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setMaintenance6( Bool32 maintenance6_ ) && VULKAN_HPP_NOEXCEPT - { - maintenance6 = maintenance6_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setPipelineProtectedAccess( Bool32 pipelineProtectedAccess_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineProtectedAccess = pipelineProtectedAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setPipelineProtectedAccess( Bool32 pipelineProtectedAccess_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineProtectedAccess = pipelineProtectedAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setPipelineRobustness( Bool32 pipelineRobustness_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineRobustness = pipelineRobustness_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setPipelineRobustness( Bool32 pipelineRobustness_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineRobustness = pipelineRobustness_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setHostImageCopy( Bool32 hostImageCopy_ ) & VULKAN_HPP_NOEXCEPT - { - hostImageCopy = hostImageCopy_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setHostImageCopy( Bool32 hostImageCopy_ ) && VULKAN_HPP_NOEXCEPT - { - hostImageCopy = hostImageCopy_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features & setPushDescriptor( Bool32 pushDescriptor_ ) & VULKAN_HPP_NOEXCEPT - { - pushDescriptor = pushDescriptor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Features && setPushDescriptor( Bool32 pushDescriptor_ ) && VULKAN_HPP_NOEXCEPT - { - pushDescriptor = pushDescriptor_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVulkan14Features const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan14Features &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan14Features const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan14Features *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - globalPriorityQuery, - shaderSubgroupRotate, - shaderSubgroupRotateClustered, - shaderFloatControls2, - shaderExpectAssume, - rectangularLines, - bresenhamLines, - smoothLines, - stippledRectangularLines, - stippledBresenhamLines, - stippledSmoothLines, - vertexAttributeInstanceRateDivisor, - vertexAttributeInstanceRateZeroDivisor, - indexTypeUint8, - dynamicRenderingLocalRead, - maintenance5, - maintenance6, - pipelineProtectedAccess, - pipelineRobustness, - hostImageCopy, - pushDescriptor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVulkan14Features const & ) const = default; -#else - bool operator==( PhysicalDeviceVulkan14Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( globalPriorityQuery == rhs.globalPriorityQuery ) && - ( shaderSubgroupRotate == rhs.shaderSubgroupRotate ) && ( shaderSubgroupRotateClustered == rhs.shaderSubgroupRotateClustered ) && - ( shaderFloatControls2 == rhs.shaderFloatControls2 ) && ( shaderExpectAssume == rhs.shaderExpectAssume ) && - ( rectangularLines == rhs.rectangularLines ) && ( bresenhamLines == rhs.bresenhamLines ) && ( smoothLines == rhs.smoothLines ) && - ( stippledRectangularLines == rhs.stippledRectangularLines ) && ( stippledBresenhamLines == rhs.stippledBresenhamLines ) && - ( stippledSmoothLines == rhs.stippledSmoothLines ) && ( vertexAttributeInstanceRateDivisor == rhs.vertexAttributeInstanceRateDivisor ) && - ( vertexAttributeInstanceRateZeroDivisor == rhs.vertexAttributeInstanceRateZeroDivisor ) && ( indexTypeUint8 == rhs.indexTypeUint8 ) && - ( dynamicRenderingLocalRead == rhs.dynamicRenderingLocalRead ) && ( maintenance5 == rhs.maintenance5 ) && ( maintenance6 == rhs.maintenance6 ) && - ( pipelineProtectedAccess == rhs.pipelineProtectedAccess ) && ( pipelineRobustness == rhs.pipelineRobustness ) && - ( hostImageCopy == rhs.hostImageCopy ) && ( pushDescriptor == rhs.pushDescriptor ); -# endif - } - - bool operator!=( PhysicalDeviceVulkan14Features const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVulkan14Features; - void * pNext = {}; - Bool32 globalPriorityQuery = {}; - Bool32 shaderSubgroupRotate = {}; - Bool32 shaderSubgroupRotateClustered = {}; - Bool32 shaderFloatControls2 = {}; - Bool32 shaderExpectAssume = {}; - Bool32 rectangularLines = {}; - Bool32 bresenhamLines = {}; - Bool32 smoothLines = {}; - Bool32 stippledRectangularLines = {}; - Bool32 stippledBresenhamLines = {}; - Bool32 stippledSmoothLines = {}; - Bool32 vertexAttributeInstanceRateDivisor = {}; - Bool32 vertexAttributeInstanceRateZeroDivisor = {}; - Bool32 indexTypeUint8 = {}; - Bool32 dynamicRenderingLocalRead = {}; - Bool32 maintenance5 = {}; - Bool32 maintenance6 = {}; - Bool32 pipelineProtectedAccess = {}; - Bool32 pipelineRobustness = {}; - Bool32 hostImageCopy = {}; - Bool32 pushDescriptor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan14Features; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan14Features; - }; - - // wrapper struct for struct VkPhysicalDeviceVulkan14Properties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkan14Properties.html - struct PhysicalDeviceVulkan14Properties - { - using NativeType = VkPhysicalDeviceVulkan14Properties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkan14Properties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - PhysicalDeviceVulkan14Properties( uint32_t lineSubPixelPrecisionBits_ = {}, - uint32_t maxVertexAttribDivisor_ = {}, - Bool32 supportsNonZeroFirstInstance_ = {}, - uint32_t maxPushDescriptors_ = {}, - Bool32 dynamicRenderingLocalReadDepthStencilAttachments_ = {}, - Bool32 dynamicRenderingLocalReadMultisampledAttachments_ = {}, - Bool32 earlyFragmentMultisampleCoverageAfterSampleCounting_ = {}, - Bool32 earlyFragmentSampleMaskTestBeforeSampleCounting_ = {}, - Bool32 depthStencilSwizzleOneSupport_ = {}, - Bool32 polygonModePointSize_ = {}, - Bool32 nonStrictSinglePixelWideLinesUseParallelogram_ = {}, - Bool32 nonStrictWideLinesUseParallelogram_ = {}, - Bool32 blockTexelViewCompatibleMultipleLayers_ = {}, - uint32_t maxCombinedImageSamplerDescriptorCount_ = {}, - Bool32 fragmentShadingRateClampCombinerInputs_ = {}, - PipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, - PipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, - PipelineRobustnessBufferBehavior defaultRobustnessVertexInputs_ = PipelineRobustnessBufferBehavior::eDeviceDefault, - PipelineRobustnessImageBehavior defaultRobustnessImages_ = PipelineRobustnessImageBehavior::eDeviceDefault, - uint32_t copySrcLayoutCount_ = {}, - ImageLayout * pCopySrcLayouts_ = {}, - uint32_t copyDstLayoutCount_ = {}, - ImageLayout * pCopyDstLayouts_ = {}, - std::array const & optimalTilingLayoutUUID_ = {}, - Bool32 identicalMemoryTypeRequirements_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , lineSubPixelPrecisionBits{ lineSubPixelPrecisionBits_ } - , maxVertexAttribDivisor{ maxVertexAttribDivisor_ } - , supportsNonZeroFirstInstance{ supportsNonZeroFirstInstance_ } - , maxPushDescriptors{ maxPushDescriptors_ } - , dynamicRenderingLocalReadDepthStencilAttachments{ dynamicRenderingLocalReadDepthStencilAttachments_ } - , dynamicRenderingLocalReadMultisampledAttachments{ dynamicRenderingLocalReadMultisampledAttachments_ } - , earlyFragmentMultisampleCoverageAfterSampleCounting{ earlyFragmentMultisampleCoverageAfterSampleCounting_ } - , earlyFragmentSampleMaskTestBeforeSampleCounting{ earlyFragmentSampleMaskTestBeforeSampleCounting_ } - , depthStencilSwizzleOneSupport{ depthStencilSwizzleOneSupport_ } - , polygonModePointSize{ polygonModePointSize_ } - , nonStrictSinglePixelWideLinesUseParallelogram{ nonStrictSinglePixelWideLinesUseParallelogram_ } - , nonStrictWideLinesUseParallelogram{ nonStrictWideLinesUseParallelogram_ } - , blockTexelViewCompatibleMultipleLayers{ blockTexelViewCompatibleMultipleLayers_ } - , maxCombinedImageSamplerDescriptorCount{ maxCombinedImageSamplerDescriptorCount_ } - , fragmentShadingRateClampCombinerInputs{ fragmentShadingRateClampCombinerInputs_ } - , defaultRobustnessStorageBuffers{ defaultRobustnessStorageBuffers_ } - , defaultRobustnessUniformBuffers{ defaultRobustnessUniformBuffers_ } - , defaultRobustnessVertexInputs{ defaultRobustnessVertexInputs_ } - , defaultRobustnessImages{ defaultRobustnessImages_ } - , copySrcLayoutCount{ copySrcLayoutCount_ } - , pCopySrcLayouts{ pCopySrcLayouts_ } - , copyDstLayoutCount{ copyDstLayoutCount_ } - , pCopyDstLayouts{ pCopyDstLayouts_ } - , optimalTilingLayoutUUID{ optimalTilingLayoutUUID_ } - , identicalMemoryTypeRequirements{ identicalMemoryTypeRequirements_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkan14Properties( PhysicalDeviceVulkan14Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVulkan14Properties( VkPhysicalDeviceVulkan14Properties const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVulkan14Properties( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVulkan14Properties & operator=( PhysicalDeviceVulkan14Properties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVulkan14Properties & operator=( VkPhysicalDeviceVulkan14Properties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPhysicalDeviceVulkan14Properties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan14Properties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan14Properties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkan14Properties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - Bool32 const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - lineSubPixelPrecisionBits, - maxVertexAttribDivisor, - supportsNonZeroFirstInstance, - maxPushDescriptors, - dynamicRenderingLocalReadDepthStencilAttachments, - dynamicRenderingLocalReadMultisampledAttachments, - earlyFragmentMultisampleCoverageAfterSampleCounting, - earlyFragmentSampleMaskTestBeforeSampleCounting, - depthStencilSwizzleOneSupport, - polygonModePointSize, - nonStrictSinglePixelWideLinesUseParallelogram, - nonStrictWideLinesUseParallelogram, - blockTexelViewCompatibleMultipleLayers, - maxCombinedImageSamplerDescriptorCount, - fragmentShadingRateClampCombinerInputs, - defaultRobustnessStorageBuffers, - defaultRobustnessUniformBuffers, - defaultRobustnessVertexInputs, - defaultRobustnessImages, - copySrcLayoutCount, - pCopySrcLayouts, - copyDstLayoutCount, - pCopyDstLayouts, - optimalTilingLayoutUUID, - identicalMemoryTypeRequirements ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVulkan14Properties const & ) const = default; -#else - bool operator==( PhysicalDeviceVulkan14Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lineSubPixelPrecisionBits == rhs.lineSubPixelPrecisionBits ) && - ( maxVertexAttribDivisor == rhs.maxVertexAttribDivisor ) && ( supportsNonZeroFirstInstance == rhs.supportsNonZeroFirstInstance ) && - ( maxPushDescriptors == rhs.maxPushDescriptors ) && - ( dynamicRenderingLocalReadDepthStencilAttachments == rhs.dynamicRenderingLocalReadDepthStencilAttachments ) && - ( dynamicRenderingLocalReadMultisampledAttachments == rhs.dynamicRenderingLocalReadMultisampledAttachments ) && - ( earlyFragmentMultisampleCoverageAfterSampleCounting == rhs.earlyFragmentMultisampleCoverageAfterSampleCounting ) && - ( earlyFragmentSampleMaskTestBeforeSampleCounting == rhs.earlyFragmentSampleMaskTestBeforeSampleCounting ) && - ( depthStencilSwizzleOneSupport == rhs.depthStencilSwizzleOneSupport ) && ( polygonModePointSize == rhs.polygonModePointSize ) && - ( nonStrictSinglePixelWideLinesUseParallelogram == rhs.nonStrictSinglePixelWideLinesUseParallelogram ) && - ( nonStrictWideLinesUseParallelogram == rhs.nonStrictWideLinesUseParallelogram ) && - ( blockTexelViewCompatibleMultipleLayers == rhs.blockTexelViewCompatibleMultipleLayers ) && - ( maxCombinedImageSamplerDescriptorCount == rhs.maxCombinedImageSamplerDescriptorCount ) && - ( fragmentShadingRateClampCombinerInputs == rhs.fragmentShadingRateClampCombinerInputs ) && - ( defaultRobustnessStorageBuffers == rhs.defaultRobustnessStorageBuffers ) && - ( defaultRobustnessUniformBuffers == rhs.defaultRobustnessUniformBuffers ) && - ( defaultRobustnessVertexInputs == rhs.defaultRobustnessVertexInputs ) && ( defaultRobustnessImages == rhs.defaultRobustnessImages ) && - ( copySrcLayoutCount == rhs.copySrcLayoutCount ) && ( pCopySrcLayouts == rhs.pCopySrcLayouts ) && - ( copyDstLayoutCount == rhs.copyDstLayoutCount ) && ( pCopyDstLayouts == rhs.pCopyDstLayouts ) && - ( optimalTilingLayoutUUID == rhs.optimalTilingLayoutUUID ) && ( identicalMemoryTypeRequirements == rhs.identicalMemoryTypeRequirements ); -# endif - } - - bool operator!=( PhysicalDeviceVulkan14Properties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVulkan14Properties; - void * pNext = {}; - uint32_t lineSubPixelPrecisionBits = {}; - uint32_t maxVertexAttribDivisor = {}; - Bool32 supportsNonZeroFirstInstance = {}; - uint32_t maxPushDescriptors = {}; - Bool32 dynamicRenderingLocalReadDepthStencilAttachments = {}; - Bool32 dynamicRenderingLocalReadMultisampledAttachments = {}; - Bool32 earlyFragmentMultisampleCoverageAfterSampleCounting = {}; - Bool32 earlyFragmentSampleMaskTestBeforeSampleCounting = {}; - Bool32 depthStencilSwizzleOneSupport = {}; - Bool32 polygonModePointSize = {}; - Bool32 nonStrictSinglePixelWideLinesUseParallelogram = {}; - Bool32 nonStrictWideLinesUseParallelogram = {}; - Bool32 blockTexelViewCompatibleMultipleLayers = {}; - uint32_t maxCombinedImageSamplerDescriptorCount = {}; - Bool32 fragmentShadingRateClampCombinerInputs = {}; - PipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; - PipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; - PipelineRobustnessBufferBehavior defaultRobustnessVertexInputs = PipelineRobustnessBufferBehavior::eDeviceDefault; - PipelineRobustnessImageBehavior defaultRobustnessImages = PipelineRobustnessImageBehavior::eDeviceDefault; - uint32_t copySrcLayoutCount = {}; - ImageLayout * pCopySrcLayouts = {}; - uint32_t copyDstLayoutCount = {}; - ImageLayout * pCopyDstLayouts = {}; - ArrayWrapper1D optimalTilingLayoutUUID = {}; - Bool32 identicalMemoryTypeRequirements = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan14Properties; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVulkan14Properties; - }; - - // wrapper struct for struct VkPhysicalDeviceVulkanMemoryModelFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceVulkanMemoryModelFeatures.html - struct PhysicalDeviceVulkanMemoryModelFeatures - { - using NativeType = VkPhysicalDeviceVulkanMemoryModelFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceVulkanMemoryModelFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeatures( Bool32 vulkanMemoryModel_ = {}, - Bool32 vulkanMemoryModelDeviceScope_ = {}, - Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vulkanMemoryModel{ vulkanMemoryModel_ } - , vulkanMemoryModelDeviceScope{ vulkanMemoryModelDeviceScope_ } - , vulkanMemoryModelAvailabilityVisibilityChains{ vulkanMemoryModelAvailabilityVisibilityChains_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceVulkanMemoryModelFeatures( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceVulkanMemoryModelFeatures( VkPhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceVulkanMemoryModelFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceVulkanMemoryModelFeatures & operator=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceVulkanMemoryModelFeatures & operator=( VkPhysicalDeviceVulkanMemoryModelFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures & setVulkanMemoryModel( Bool32 vulkanMemoryModel_ ) & VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModel = vulkanMemoryModel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures && setVulkanMemoryModel( Bool32 vulkanMemoryModel_ ) && VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModel = vulkanMemoryModel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures & setVulkanMemoryModelDeviceScope( Bool32 vulkanMemoryModelDeviceScope_ ) & - VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures && setVulkanMemoryModelDeviceScope( Bool32 vulkanMemoryModelDeviceScope_ ) && - VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModelDeviceScope = vulkanMemoryModelDeviceScope_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures & - setVulkanMemoryModelAvailabilityVisibilityChains( Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ ) & - VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceVulkanMemoryModelFeatures && - setVulkanMemoryModelAvailabilityVisibilityChains( Bool32 vulkanMemoryModelAvailabilityVisibilityChains_ ) && - VULKAN_HPP_NOEXCEPT - { - vulkanMemoryModelAvailabilityVisibilityChains = vulkanMemoryModelAvailabilityVisibilityChains_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceVulkanMemoryModelFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkanMemoryModelFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkanMemoryModelFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceVulkanMemoryModelFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, vulkanMemoryModel, vulkanMemoryModelDeviceScope, vulkanMemoryModelAvailabilityVisibilityChains ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceVulkanMemoryModelFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vulkanMemoryModel == rhs.vulkanMemoryModel ) && - ( vulkanMemoryModelDeviceScope == rhs.vulkanMemoryModelDeviceScope ) && - ( vulkanMemoryModelAvailabilityVisibilityChains == rhs.vulkanMemoryModelAvailabilityVisibilityChains ); -# endif - } - - bool operator!=( PhysicalDeviceVulkanMemoryModelFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceVulkanMemoryModelFeatures; - void * pNext = {}; - Bool32 vulkanMemoryModel = {}; - Bool32 vulkanMemoryModelDeviceScope = {}; - Bool32 vulkanMemoryModelAvailabilityVisibilityChains = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceVulkanMemoryModelFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceVulkanMemoryModelFeatures; - }; - - using PhysicalDeviceVulkanMemoryModelFeaturesKHR = PhysicalDeviceVulkanMemoryModelFeatures; - - // wrapper struct for struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.html - struct PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR - { - using NativeType = VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( Bool32 workgroupMemoryExplicitLayout_ = {}, - Bool32 workgroupMemoryExplicitLayoutScalarBlockLayout_ = {}, - Bool32 workgroupMemoryExplicitLayout8BitAccess_ = {}, - Bool32 workgroupMemoryExplicitLayout16BitAccess_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , workgroupMemoryExplicitLayout{ workgroupMemoryExplicitLayout_ } - , workgroupMemoryExplicitLayoutScalarBlockLayout{ workgroupMemoryExplicitLayoutScalarBlockLayout_ } - , workgroupMemoryExplicitLayout8BitAccess{ workgroupMemoryExplicitLayout8BitAccess_ } - , workgroupMemoryExplicitLayout16BitAccess{ workgroupMemoryExplicitLayout16BitAccess_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & - operator=( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & - operator=( VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & setWorkgroupMemoryExplicitLayout( Bool32 workgroupMemoryExplicitLayout_ ) & - VULKAN_HPP_NOEXCEPT - { - workgroupMemoryExplicitLayout = workgroupMemoryExplicitLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR && - setWorkgroupMemoryExplicitLayout( Bool32 workgroupMemoryExplicitLayout_ ) && - VULKAN_HPP_NOEXCEPT - { - workgroupMemoryExplicitLayout = workgroupMemoryExplicitLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & - setWorkgroupMemoryExplicitLayoutScalarBlockLayout( Bool32 workgroupMemoryExplicitLayoutScalarBlockLayout_ ) & - VULKAN_HPP_NOEXCEPT - { - workgroupMemoryExplicitLayoutScalarBlockLayout = workgroupMemoryExplicitLayoutScalarBlockLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR && - setWorkgroupMemoryExplicitLayoutScalarBlockLayout( Bool32 workgroupMemoryExplicitLayoutScalarBlockLayout_ ) && - VULKAN_HPP_NOEXCEPT - { - workgroupMemoryExplicitLayoutScalarBlockLayout = workgroupMemoryExplicitLayoutScalarBlockLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & - setWorkgroupMemoryExplicitLayout8BitAccess( Bool32 workgroupMemoryExplicitLayout8BitAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - workgroupMemoryExplicitLayout8BitAccess = workgroupMemoryExplicitLayout8BitAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR && - setWorkgroupMemoryExplicitLayout8BitAccess( Bool32 workgroupMemoryExplicitLayout8BitAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - workgroupMemoryExplicitLayout8BitAccess = workgroupMemoryExplicitLayout8BitAccess_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR & - setWorkgroupMemoryExplicitLayout16BitAccess( Bool32 workgroupMemoryExplicitLayout16BitAccess_ ) & - VULKAN_HPP_NOEXCEPT - { - workgroupMemoryExplicitLayout16BitAccess = workgroupMemoryExplicitLayout16BitAccess_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR && - setWorkgroupMemoryExplicitLayout16BitAccess( Bool32 workgroupMemoryExplicitLayout16BitAccess_ ) && - VULKAN_HPP_NOEXCEPT - { - workgroupMemoryExplicitLayout16BitAccess = workgroupMemoryExplicitLayout16BitAccess_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - workgroupMemoryExplicitLayout, - workgroupMemoryExplicitLayoutScalarBlockLayout, - workgroupMemoryExplicitLayout8BitAccess, - workgroupMemoryExplicitLayout16BitAccess ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & ) const = default; -#else - bool operator==( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( workgroupMemoryExplicitLayout == rhs.workgroupMemoryExplicitLayout ) && - ( workgroupMemoryExplicitLayoutScalarBlockLayout == rhs.workgroupMemoryExplicitLayoutScalarBlockLayout ) && - ( workgroupMemoryExplicitLayout8BitAccess == rhs.workgroupMemoryExplicitLayout8BitAccess ) && - ( workgroupMemoryExplicitLayout16BitAccess == rhs.workgroupMemoryExplicitLayout16BitAccess ); -# endif - } - - bool operator!=( PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; - void * pNext = {}; - Bool32 workgroupMemoryExplicitLayout = {}; - Bool32 workgroupMemoryExplicitLayoutScalarBlockLayout = {}; - Bool32 workgroupMemoryExplicitLayout8BitAccess = {}; - Bool32 workgroupMemoryExplicitLayout16BitAccess = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; - }; - - // wrapper struct for struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.html - struct PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT - { - using NativeType = VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT( Bool32 ycbcr2plane444Formats_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , ycbcr2plane444Formats{ ycbcr2plane444Formats_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT( VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT & operator=( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT & operator=( VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT & setYcbcr2plane444Formats( Bool32 ycbcr2plane444Formats_ ) & VULKAN_HPP_NOEXCEPT - { - ycbcr2plane444Formats = ycbcr2plane444Formats_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT && setYcbcr2plane444Formats( Bool32 ycbcr2plane444Formats_ ) && VULKAN_HPP_NOEXCEPT - { - ycbcr2plane444Formats = ycbcr2plane444Formats_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, ycbcr2plane444Formats ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcr2plane444Formats == rhs.ycbcr2plane444Formats ); -# endif - } - - bool operator!=( PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; - void * pNext = {}; - Bool32 ycbcr2plane444Formats = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.html - struct PhysicalDeviceYcbcrDegammaFeaturesQCOM - { - using NativeType = VkPhysicalDeviceYcbcrDegammaFeaturesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceYcbcrDegammaFeaturesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrDegammaFeaturesQCOM( Bool32 ycbcrDegamma_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , ycbcrDegamma{ ycbcrDegamma_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrDegammaFeaturesQCOM( PhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceYcbcrDegammaFeaturesQCOM( VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceYcbcrDegammaFeaturesQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceYcbcrDegammaFeaturesQCOM & operator=( PhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceYcbcrDegammaFeaturesQCOM & operator=( VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrDegammaFeaturesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrDegammaFeaturesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrDegammaFeaturesQCOM & setYcbcrDegamma( Bool32 ycbcrDegamma_ ) & VULKAN_HPP_NOEXCEPT - { - ycbcrDegamma = ycbcrDegamma_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrDegammaFeaturesQCOM && setYcbcrDegamma( Bool32 ycbcrDegamma_ ) && VULKAN_HPP_NOEXCEPT - { - ycbcrDegamma = ycbcrDegamma_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceYcbcrDegammaFeaturesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceYcbcrDegammaFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, ycbcrDegamma ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceYcbcrDegammaFeaturesQCOM const & ) const = default; -#else - bool operator==( PhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrDegamma == rhs.ycbcrDegamma ); -# endif - } - - bool operator!=( PhysicalDeviceYcbcrDegammaFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceYcbcrDegammaFeaturesQCOM; - void * pNext = {}; - Bool32 ycbcrDegamma = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceYcbcrDegammaFeaturesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceYcbcrDegammaFeaturesQCOM; - }; - - // wrapper struct for struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.html - struct PhysicalDeviceYcbcrImageArraysFeaturesEXT - { - using NativeType = VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( Bool32 ycbcrImageArrays_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , ycbcrImageArrays{ ycbcrImageArrays_ } - { - } - - VULKAN_HPP_CONSTEXPR PhysicalDeviceYcbcrImageArraysFeaturesEXT( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceYcbcrImageArraysFeaturesEXT( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceYcbcrImageArraysFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceYcbcrImageArraysFeaturesEXT & operator=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceYcbcrImageArraysFeaturesEXT & operator=( VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrImageArraysFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrImageArraysFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrImageArraysFeaturesEXT & setYcbcrImageArrays( Bool32 ycbcrImageArrays_ ) & VULKAN_HPP_NOEXCEPT - { - ycbcrImageArrays = ycbcrImageArrays_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceYcbcrImageArraysFeaturesEXT && setYcbcrImageArrays( Bool32 ycbcrImageArrays_ ) && VULKAN_HPP_NOEXCEPT - { - ycbcrImageArrays = ycbcrImageArrays_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, ycbcrImageArrays ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ycbcrImageArrays == rhs.ycbcrImageArrays ); -# endif - } - - bool operator!=( PhysicalDeviceYcbcrImageArraysFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT; - void * pNext = {}; - Bool32 ycbcrImageArrays = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceYcbcrImageArraysFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT.html - struct PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT - { - using NativeType = VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( Bool32 zeroInitializeDeviceMemory_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , zeroInitializeDeviceMemory{ zeroInitializeDeviceMemory_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & - operator=( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & operator=( VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT & setZeroInitializeDeviceMemory( Bool32 zeroInitializeDeviceMemory_ ) & - VULKAN_HPP_NOEXCEPT - { - zeroInitializeDeviceMemory = zeroInitializeDeviceMemory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT && setZeroInitializeDeviceMemory( Bool32 zeroInitializeDeviceMemory_ ) && - VULKAN_HPP_NOEXCEPT - { - zeroInitializeDeviceMemory = zeroInitializeDeviceMemory_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, zeroInitializeDeviceMemory ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & ) const = default; -#else - bool operator==( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( zeroInitializeDeviceMemory == rhs.zeroInitializeDeviceMemory ); -# endif - } - - bool operator!=( PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; - void * pNext = {}; - Bool32 zeroInitializeDeviceMemory = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT; - }; - - // wrapper struct for struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.html - struct PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures - { - using NativeType = VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( Bool32 shaderZeroInitializeWorkgroupMemory_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shaderZeroInitializeWorkgroupMemory{ shaderZeroInitializeWorkgroupMemory_ } - { - } - - VULKAN_HPP_CONSTEXPR - PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - : PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures( *reinterpret_cast( &rhs ) ) - { - } - - PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures & - operator=( PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures & operator=( VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures & - setShaderZeroInitializeWorkgroupMemory( Bool32 shaderZeroInitializeWorkgroupMemory_ ) & - VULKAN_HPP_NOEXCEPT - { - shaderZeroInitializeWorkgroupMemory = shaderZeroInitializeWorkgroupMemory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures && - setShaderZeroInitializeWorkgroupMemory( Bool32 shaderZeroInitializeWorkgroupMemory_ ) && - VULKAN_HPP_NOEXCEPT - { - shaderZeroInitializeWorkgroupMemory = shaderZeroInitializeWorkgroupMemory_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shaderZeroInitializeWorkgroupMemory ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & ) const = default; -#else - bool operator==( PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shaderZeroInitializeWorkgroupMemory == rhs.shaderZeroInitializeWorkgroupMemory ); -# endif - } - - bool operator!=( PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - void * pNext = {}; - Bool32 shaderZeroInitializeWorkgroupMemory = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - }; -#endif - - template <> - struct CppType - { - using Type = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - }; - - using PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - - // wrapper struct for struct VkPipelineBinaryKeyKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryKeyKHR.html - struct PipelineBinaryKeyKHR - { - using NativeType = VkPipelineBinaryKeyKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineBinaryKeyKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR( uint32_t keySize_ = {}, - std::array const & key_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , keySize{ keySize_ } - , key{ key_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR( PipelineBinaryKeyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineBinaryKeyKHR( VkPipelineBinaryKeyKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineBinaryKeyKHR( *reinterpret_cast( &rhs ) ) - { - } - - PipelineBinaryKeyKHR & operator=( PipelineBinaryKeyKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineBinaryKeyKHR & operator=( VkPipelineBinaryKeyKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR & setKeySize( uint32_t keySize_ ) & VULKAN_HPP_NOEXCEPT - { - keySize = keySize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR && setKeySize( uint32_t keySize_ ) && VULKAN_HPP_NOEXCEPT - { - keySize = keySize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR & setKey( std::array key_ ) & VULKAN_HPP_NOEXCEPT - { - key = key_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeyKHR && setKey( std::array key_ ) && VULKAN_HPP_NOEXCEPT - { - key = key_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineBinaryKeyKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryKeyKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryKeyKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineBinaryKeyKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, keySize, key ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineBinaryKeyKHR const & ) const = default; -#else - bool operator==( PipelineBinaryKeyKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( keySize == rhs.keySize ) && ( key == rhs.key ); -# endif - } - - bool operator!=( PipelineBinaryKeyKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineBinaryKeyKHR; - void * pNext = {}; - uint32_t keySize = {}; - ArrayWrapper1D key = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineBinaryKeyKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineBinaryKeyKHR; - }; - - // wrapper struct for struct VkPipelineBinaryDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryDataKHR.html - struct PipelineBinaryDataKHR - { - using NativeType = VkPipelineBinaryDataKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineBinaryDataKHR( size_t dataSize_ = {}, void * pData_ = {} ) VULKAN_HPP_NOEXCEPT - : dataSize{ dataSize_ } - , pData{ pData_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineBinaryDataKHR( PipelineBinaryDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineBinaryDataKHR( VkPipelineBinaryDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineBinaryDataKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - PipelineBinaryDataKHR( ArrayProxyNoTemporaries const & data_ ) : dataSize( data_.size() * sizeof( T ) ), pData( data_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineBinaryDataKHR & operator=( PipelineBinaryDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineBinaryDataKHR & operator=( VkPipelineBinaryDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataKHR & setDataSize( size_t dataSize_ ) & VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataKHR && setDataSize( size_t dataSize_ ) && VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataKHR & setPData( void * pData_ ) & VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataKHR && setPData( void * pData_ ) && VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - PipelineBinaryDataKHR & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT - { - dataSize = data_.size() * sizeof( T ); - pData = data_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineBinaryDataKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryDataKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryDataKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineBinaryDataKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( dataSize, pData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineBinaryDataKHR const & ) const = default; -#else - bool operator==( PipelineBinaryDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); -# endif - } - - bool operator!=( PipelineBinaryDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - size_t dataSize = {}; - void * pData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineBinaryDataKHR; - }; -#endif - - // wrapper struct for struct VkPipelineBinaryKeysAndDataKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryKeysAndDataKHR.html - struct PipelineBinaryKeysAndDataKHR - { - using NativeType = VkPipelineBinaryKeysAndDataKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR( uint32_t binaryCount_ = {}, - const PipelineBinaryKeyKHR * pPipelineBinaryKeys_ = {}, - const PipelineBinaryDataKHR * pPipelineBinaryData_ = {} ) VULKAN_HPP_NOEXCEPT - : binaryCount{ binaryCount_ } - , pPipelineBinaryKeys{ pPipelineBinaryKeys_ } - , pPipelineBinaryData{ pPipelineBinaryData_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR( PipelineBinaryKeysAndDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineBinaryKeysAndDataKHR( VkPipelineBinaryKeysAndDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineBinaryKeysAndDataKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineBinaryKeysAndDataKHR( ArrayProxyNoTemporaries const & pipelineBinaryKeys_, - ArrayProxyNoTemporaries const & pipelineBinaryData_ = {} ) - : binaryCount( static_cast( pipelineBinaryKeys_.size() ) ) - , pPipelineBinaryKeys( pipelineBinaryKeys_.data() ) - , pPipelineBinaryData( pipelineBinaryData_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( pipelineBinaryKeys_.size() == pipelineBinaryData_.size() ); -# else - if ( pipelineBinaryKeys_.size() != pipelineBinaryData_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::PipelineBinaryKeysAndDataKHR::PipelineBinaryKeysAndDataKHR: pipelineBinaryKeys_.size() != pipelineBinaryData_.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineBinaryKeysAndDataKHR & operator=( PipelineBinaryKeysAndDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineBinaryKeysAndDataKHR & operator=( VkPipelineBinaryKeysAndDataKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR & setBinaryCount( uint32_t binaryCount_ ) & VULKAN_HPP_NOEXCEPT - { - binaryCount = binaryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR && setBinaryCount( uint32_t binaryCount_ ) && VULKAN_HPP_NOEXCEPT - { - binaryCount = binaryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR & setPPipelineBinaryKeys( const PipelineBinaryKeyKHR * pPipelineBinaryKeys_ ) & VULKAN_HPP_NOEXCEPT - { - pPipelineBinaryKeys = pPipelineBinaryKeys_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR && setPPipelineBinaryKeys( const PipelineBinaryKeyKHR * pPipelineBinaryKeys_ ) && VULKAN_HPP_NOEXCEPT - { - pPipelineBinaryKeys = pPipelineBinaryKeys_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineBinaryKeysAndDataKHR & setPipelineBinaryKeys( ArrayProxyNoTemporaries const & pipelineBinaryKeys_ ) VULKAN_HPP_NOEXCEPT - { - binaryCount = static_cast( pipelineBinaryKeys_.size() ); - pPipelineBinaryKeys = pipelineBinaryKeys_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR & setPPipelineBinaryData( const PipelineBinaryDataKHR * pPipelineBinaryData_ ) & VULKAN_HPP_NOEXCEPT - { - pPipelineBinaryData = pPipelineBinaryData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryKeysAndDataKHR && setPPipelineBinaryData( const PipelineBinaryDataKHR * pPipelineBinaryData_ ) && VULKAN_HPP_NOEXCEPT - { - pPipelineBinaryData = pPipelineBinaryData_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineBinaryKeysAndDataKHR & setPipelineBinaryData( ArrayProxyNoTemporaries const & pipelineBinaryData_ ) VULKAN_HPP_NOEXCEPT - { - binaryCount = static_cast( pipelineBinaryData_.size() ); - pPipelineBinaryData = pipelineBinaryData_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineBinaryKeysAndDataKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryKeysAndDataKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryKeysAndDataKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineBinaryKeysAndDataKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( binaryCount, pPipelineBinaryKeys, pPipelineBinaryData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineBinaryKeysAndDataKHR const & ) const = default; -#else - bool operator==( PipelineBinaryKeysAndDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( binaryCount == rhs.binaryCount ) && ( pPipelineBinaryKeys == rhs.pPipelineBinaryKeys ) && ( pPipelineBinaryData == rhs.pPipelineBinaryData ); -# endif - } - - bool operator!=( PipelineBinaryKeysAndDataKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t binaryCount = {}; - const PipelineBinaryKeyKHR * pPipelineBinaryKeys = {}; - const PipelineBinaryDataKHR * pPipelineBinaryData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineBinaryKeysAndDataKHR; - }; -#endif - - // wrapper struct for struct VkPipelineCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateInfoKHR.html - struct PipelineCreateInfoKHR - { - using NativeType = VkPipelineCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineCreateInfoKHR( void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} - - VULKAN_HPP_CONSTEXPR PipelineCreateInfoKHR( PipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineCreateInfoKHR( VkPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - PipelineCreateInfoKHR & operator=( PipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineCreateInfoKHR & operator=( VkPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCreateInfoKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCreateInfoKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineCreateInfoKHR const & ) const = default; -#else - bool operator==( PipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); -# endif - } - - bool operator!=( PipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineCreateInfoKHR; - void * pNext = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineCreateInfoKHR; - }; - - // wrapper struct for struct VkPipelineBinaryCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryCreateInfoKHR.html - struct PipelineBinaryCreateInfoKHR - { - using NativeType = VkPipelineBinaryCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineBinaryCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR( const PipelineBinaryKeysAndDataKHR * pKeysAndDataInfo_ = {}, - Pipeline pipeline_ = {}, - const PipelineCreateInfoKHR * pPipelineCreateInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pKeysAndDataInfo{ pKeysAndDataInfo_ } - , pipeline{ pipeline_ } - , pPipelineCreateInfo{ pPipelineCreateInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR( PipelineBinaryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineBinaryCreateInfoKHR( VkPipelineBinaryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineBinaryCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - PipelineBinaryCreateInfoKHR & operator=( PipelineBinaryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineBinaryCreateInfoKHR & operator=( VkPipelineBinaryCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR & setPKeysAndDataInfo( const PipelineBinaryKeysAndDataKHR * pKeysAndDataInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pKeysAndDataInfo = pKeysAndDataInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR && setPKeysAndDataInfo( const PipelineBinaryKeysAndDataKHR * pKeysAndDataInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pKeysAndDataInfo = pKeysAndDataInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR & setPPipelineCreateInfo( const PipelineCreateInfoKHR * pPipelineCreateInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pPipelineCreateInfo = pPipelineCreateInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryCreateInfoKHR && setPPipelineCreateInfo( const PipelineCreateInfoKHR * pPipelineCreateInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pPipelineCreateInfo = pPipelineCreateInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineBinaryCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineBinaryCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pKeysAndDataInfo, pipeline, pPipelineCreateInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineBinaryCreateInfoKHR const & ) const = default; -#else - bool operator==( PipelineBinaryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pKeysAndDataInfo == rhs.pKeysAndDataInfo ) && ( pipeline == rhs.pipeline ) && - ( pPipelineCreateInfo == rhs.pPipelineCreateInfo ); -# endif - } - - bool operator!=( PipelineBinaryCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineBinaryCreateInfoKHR; - const void * pNext = {}; - const PipelineBinaryKeysAndDataKHR * pKeysAndDataInfo = {}; - Pipeline pipeline = {}; - const PipelineCreateInfoKHR * pPipelineCreateInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineBinaryCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineBinaryCreateInfoKHR; - }; - - // wrapper struct for struct VkPipelineBinaryDataInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryDataInfoKHR.html - struct PipelineBinaryDataInfoKHR - { - using NativeType = VkPipelineBinaryDataInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineBinaryDataInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineBinaryDataInfoKHR( PipelineBinaryKHR pipelineBinary_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineBinary{ pipelineBinary_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineBinaryDataInfoKHR( PipelineBinaryDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineBinaryDataInfoKHR( VkPipelineBinaryDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineBinaryDataInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - PipelineBinaryDataInfoKHR & operator=( PipelineBinaryDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineBinaryDataInfoKHR & operator=( VkPipelineBinaryDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataInfoKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataInfoKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataInfoKHR & setPipelineBinary( PipelineBinaryKHR pipelineBinary_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineBinary = pipelineBinary_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryDataInfoKHR && setPipelineBinary( PipelineBinaryKHR pipelineBinary_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineBinary = pipelineBinary_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineBinaryDataInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryDataInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryDataInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineBinaryDataInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineBinary ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineBinaryDataInfoKHR const & ) const = default; -#else - bool operator==( PipelineBinaryDataInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBinary == rhs.pipelineBinary ); -# endif - } - - bool operator!=( PipelineBinaryDataInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineBinaryDataInfoKHR; - void * pNext = {}; - PipelineBinaryKHR pipelineBinary = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineBinaryDataInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineBinaryDataInfoKHR; - }; - - // wrapper struct for struct VkPipelineBinaryHandlesInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryHandlesInfoKHR.html - struct PipelineBinaryHandlesInfoKHR - { - using NativeType = VkPipelineBinaryHandlesInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineBinaryHandlesInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineBinaryHandlesInfoKHR( uint32_t pipelineBinaryCount_ = {}, - PipelineBinaryKHR * pPipelineBinaries_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineBinaryCount{ pipelineBinaryCount_ } - , pPipelineBinaries{ pPipelineBinaries_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineBinaryHandlesInfoKHR( PipelineBinaryHandlesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineBinaryHandlesInfoKHR( VkPipelineBinaryHandlesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineBinaryHandlesInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineBinaryHandlesInfoKHR( ArrayProxyNoTemporaries const & pipelineBinaries_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), pipelineBinaryCount( static_cast( pipelineBinaries_.size() ) ), pPipelineBinaries( pipelineBinaries_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineBinaryHandlesInfoKHR & operator=( PipelineBinaryHandlesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineBinaryHandlesInfoKHR & operator=( VkPipelineBinaryHandlesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR & setPipelineBinaryCount( uint32_t pipelineBinaryCount_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineBinaryCount = pipelineBinaryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR && setPipelineBinaryCount( uint32_t pipelineBinaryCount_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineBinaryCount = pipelineBinaryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR & setPPipelineBinaries( PipelineBinaryKHR * pPipelineBinaries_ ) & VULKAN_HPP_NOEXCEPT - { - pPipelineBinaries = pPipelineBinaries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryHandlesInfoKHR && setPPipelineBinaries( PipelineBinaryKHR * pPipelineBinaries_ ) && VULKAN_HPP_NOEXCEPT - { - pPipelineBinaries = pPipelineBinaries_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineBinaryHandlesInfoKHR & setPipelineBinaries( ArrayProxyNoTemporaries const & pipelineBinaries_ ) VULKAN_HPP_NOEXCEPT - { - pipelineBinaryCount = static_cast( pipelineBinaries_.size() ); - pPipelineBinaries = pipelineBinaries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineBinaryHandlesInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryHandlesInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryHandlesInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineBinaryHandlesInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineBinaryCount, pPipelineBinaries ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineBinaryHandlesInfoKHR const & ) const = default; -#else - bool operator==( PipelineBinaryHandlesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBinaryCount == rhs.pipelineBinaryCount ) && - ( pPipelineBinaries == rhs.pPipelineBinaries ); -# endif - } - - bool operator!=( PipelineBinaryHandlesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineBinaryHandlesInfoKHR; - const void * pNext = {}; - uint32_t pipelineBinaryCount = {}; - PipelineBinaryKHR * pPipelineBinaries = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineBinaryHandlesInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineBinaryHandlesInfoKHR; - }; - - // wrapper struct for struct VkPipelineBinaryInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineBinaryInfoKHR.html - struct PipelineBinaryInfoKHR - { - using NativeType = VkPipelineBinaryInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineBinaryInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PipelineBinaryInfoKHR( uint32_t binaryCount_ = {}, const PipelineBinaryKHR * pPipelineBinaries_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , binaryCount{ binaryCount_ } - , pPipelineBinaries{ pPipelineBinaries_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineBinaryInfoKHR( PipelineBinaryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineBinaryInfoKHR( VkPipelineBinaryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineBinaryInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineBinaryInfoKHR( ArrayProxyNoTemporaries const & pipelineBinaries_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), binaryCount( static_cast( pipelineBinaries_.size() ) ), pPipelineBinaries( pipelineBinaries_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineBinaryInfoKHR & operator=( PipelineBinaryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineBinaryInfoKHR & operator=( VkPipelineBinaryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR & setBinaryCount( uint32_t binaryCount_ ) & VULKAN_HPP_NOEXCEPT - { - binaryCount = binaryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR && setBinaryCount( uint32_t binaryCount_ ) && VULKAN_HPP_NOEXCEPT - { - binaryCount = binaryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR & setPPipelineBinaries( const PipelineBinaryKHR * pPipelineBinaries_ ) & VULKAN_HPP_NOEXCEPT - { - pPipelineBinaries = pPipelineBinaries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineBinaryInfoKHR && setPPipelineBinaries( const PipelineBinaryKHR * pPipelineBinaries_ ) && VULKAN_HPP_NOEXCEPT - { - pPipelineBinaries = pPipelineBinaries_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineBinaryInfoKHR & setPipelineBinaries( ArrayProxyNoTemporaries const & pipelineBinaries_ ) VULKAN_HPP_NOEXCEPT - { - binaryCount = static_cast( pipelineBinaries_.size() ); - pPipelineBinaries = pipelineBinaries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineBinaryInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineBinaryInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineBinaryInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, binaryCount, pPipelineBinaries ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineBinaryInfoKHR const & ) const = default; -#else - bool operator==( PipelineBinaryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( binaryCount == rhs.binaryCount ) && ( pPipelineBinaries == rhs.pPipelineBinaries ); -# endif - } - - bool operator!=( PipelineBinaryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineBinaryInfoKHR; - const void * pNext = {}; - uint32_t binaryCount = {}; - const PipelineBinaryKHR * pPipelineBinaries = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineBinaryInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineBinaryInfoKHR; - }; - - // wrapper struct for struct VkPipelineCacheCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheCreateInfo.html - struct PipelineCacheCreateInfo - { - using NativeType = VkPipelineCacheCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCacheCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_ = {}, - size_t initialDataSize_ = {}, - const void * pInitialData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , initialDataSize{ initialDataSize_ } - , pInitialData{ pInitialData_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineCacheCreateInfo( PipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineCacheCreateInfo( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineCacheCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - PipelineCacheCreateInfo( PipelineCacheCreateFlags flags_, ArrayProxyNoTemporaries const & initialData_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), flags( flags_ ), initialDataSize( initialData_.size() * sizeof( T ) ), pInitialData( initialData_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineCacheCreateInfo & operator=( PipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineCacheCreateInfo & operator=( VkPipelineCacheCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo & setFlags( PipelineCacheCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo && setFlags( PipelineCacheCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo & setInitialDataSize( size_t initialDataSize_ ) & VULKAN_HPP_NOEXCEPT - { - initialDataSize = initialDataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo && setInitialDataSize( size_t initialDataSize_ ) && VULKAN_HPP_NOEXCEPT - { - initialDataSize = initialDataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo & setPInitialData( const void * pInitialData_ ) & VULKAN_HPP_NOEXCEPT - { - pInitialData = pInitialData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheCreateInfo && setPInitialData( const void * pInitialData_ ) && VULKAN_HPP_NOEXCEPT - { - pInitialData = pInitialData_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - PipelineCacheCreateInfo & setInitialData( ArrayProxyNoTemporaries const & initialData_ ) VULKAN_HPP_NOEXCEPT - { - initialDataSize = initialData_.size() * sizeof( T ); - pInitialData = initialData_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineCacheCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCacheCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCacheCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineCacheCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, initialDataSize, pInitialData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineCacheCreateInfo const & ) const = default; -#else - bool operator==( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( initialDataSize == rhs.initialDataSize ) && - ( pInitialData == rhs.pInitialData ); -# endif - } - - bool operator!=( PipelineCacheCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineCacheCreateInfo; - const void * pNext = {}; - PipelineCacheCreateFlags flags = {}; - size_t initialDataSize = {}; - const void * pInitialData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineCacheCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineCacheCreateInfo; - }; - - // wrapper struct for struct VkPipelineCacheHeaderVersionDataGraphQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersionDataGraphQCOM.html - struct PipelineCacheHeaderVersionDataGraphQCOM - { - using NativeType = VkPipelineCacheHeaderVersionDataGraphQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM( - uint32_t headerSize_ = {}, - PipelineCacheHeaderVersion headerVersion_ = PipelineCacheHeaderVersion::eOne, - DataGraphModelCacheTypeQCOM cacheType_ = DataGraphModelCacheTypeQCOM::eGenericBinary, - uint32_t cacheVersion_ = {}, - std::array const & toolchainVersion_ = {} ) VULKAN_HPP_NOEXCEPT - : headerSize{ headerSize_ } - , headerVersion{ headerVersion_ } - , cacheType{ cacheType_ } - , cacheVersion{ cacheVersion_ } - , toolchainVersion{ toolchainVersion_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineCacheHeaderVersionDataGraphQCOM( VkPipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineCacheHeaderVersionDataGraphQCOM( *reinterpret_cast( &rhs ) ) - { - } - - PipelineCacheHeaderVersionDataGraphQCOM & operator=( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineCacheHeaderVersionDataGraphQCOM & operator=( VkPipelineCacheHeaderVersionDataGraphQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setHeaderSize( uint32_t headerSize_ ) & VULKAN_HPP_NOEXCEPT - { - headerSize = headerSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM && setHeaderSize( uint32_t headerSize_ ) && VULKAN_HPP_NOEXCEPT - { - headerSize = headerSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setHeaderVersion( PipelineCacheHeaderVersion headerVersion_ ) & VULKAN_HPP_NOEXCEPT - { - headerVersion = headerVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM && setHeaderVersion( PipelineCacheHeaderVersion headerVersion_ ) && VULKAN_HPP_NOEXCEPT - { - headerVersion = headerVersion_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setCacheType( DataGraphModelCacheTypeQCOM cacheType_ ) & VULKAN_HPP_NOEXCEPT - { - cacheType = cacheType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM && setCacheType( DataGraphModelCacheTypeQCOM cacheType_ ) && VULKAN_HPP_NOEXCEPT - { - cacheType = cacheType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & setCacheVersion( uint32_t cacheVersion_ ) & VULKAN_HPP_NOEXCEPT - { - cacheVersion = cacheVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM && setCacheVersion( uint32_t cacheVersion_ ) && VULKAN_HPP_NOEXCEPT - { - cacheVersion = cacheVersion_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM & - setToolchainVersion( std::array toolchainVersion_ ) & - VULKAN_HPP_NOEXCEPT - { - toolchainVersion = toolchainVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionDataGraphQCOM && - setToolchainVersion( std::array toolchainVersion_ ) && - VULKAN_HPP_NOEXCEPT - { - toolchainVersion = toolchainVersion_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineCacheHeaderVersionDataGraphQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCacheHeaderVersionDataGraphQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCacheHeaderVersionDataGraphQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineCacheHeaderVersionDataGraphQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( headerSize, headerVersion, cacheType, cacheVersion, toolchainVersion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineCacheHeaderVersionDataGraphQCOM const & ) const = default; -#else - bool operator==( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && ( cacheType == rhs.cacheType ) && - ( cacheVersion == rhs.cacheVersion ) && ( toolchainVersion == rhs.toolchainVersion ); -# endif - } - - bool operator!=( PipelineCacheHeaderVersionDataGraphQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t headerSize = {}; - PipelineCacheHeaderVersion headerVersion = PipelineCacheHeaderVersion::eOne; - DataGraphModelCacheTypeQCOM cacheType = DataGraphModelCacheTypeQCOM::eGenericBinary; - uint32_t cacheVersion = {}; - ArrayWrapper1D toolchainVersion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineCacheHeaderVersionDataGraphQCOM; - }; -#endif - - // wrapper struct for struct VkPipelineCacheHeaderVersionOne, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCacheHeaderVersionOne.html - struct PipelineCacheHeaderVersionOne - { - using NativeType = VkPipelineCacheHeaderVersionOne; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne( uint32_t headerSize_ = {}, - PipelineCacheHeaderVersion headerVersion_ = PipelineCacheHeaderVersion::eOne, - uint32_t vendorID_ = {}, - uint32_t deviceID_ = {}, - std::array const & pipelineCacheUUID_ = {} ) VULKAN_HPP_NOEXCEPT - : headerSize{ headerSize_ } - , headerVersion{ headerVersion_ } - , vendorID{ vendorID_ } - , deviceID{ deviceID_ } - , pipelineCacheUUID{ pipelineCacheUUID_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne( PipelineCacheHeaderVersionOne const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineCacheHeaderVersionOne( VkPipelineCacheHeaderVersionOne const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineCacheHeaderVersionOne( *reinterpret_cast( &rhs ) ) - { - } - - PipelineCacheHeaderVersionOne & operator=( PipelineCacheHeaderVersionOne const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineCacheHeaderVersionOne & operator=( VkPipelineCacheHeaderVersionOne const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne & setHeaderSize( uint32_t headerSize_ ) & VULKAN_HPP_NOEXCEPT - { - headerSize = headerSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne && setHeaderSize( uint32_t headerSize_ ) && VULKAN_HPP_NOEXCEPT - { - headerSize = headerSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne & setHeaderVersion( PipelineCacheHeaderVersion headerVersion_ ) & VULKAN_HPP_NOEXCEPT - { - headerVersion = headerVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne && setHeaderVersion( PipelineCacheHeaderVersion headerVersion_ ) && VULKAN_HPP_NOEXCEPT - { - headerVersion = headerVersion_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne & setVendorID( uint32_t vendorID_ ) & VULKAN_HPP_NOEXCEPT - { - vendorID = vendorID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne && setVendorID( uint32_t vendorID_ ) && VULKAN_HPP_NOEXCEPT - { - vendorID = vendorID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne & setDeviceID( uint32_t deviceID_ ) & VULKAN_HPP_NOEXCEPT - { - deviceID = deviceID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne && setDeviceID( uint32_t deviceID_ ) && VULKAN_HPP_NOEXCEPT - { - deviceID = deviceID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne & setPipelineCacheUUID( std::array pipelineCacheUUID_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineCacheUUID = pipelineCacheUUID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCacheHeaderVersionOne && setPipelineCacheUUID( std::array pipelineCacheUUID_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineCacheUUID = pipelineCacheUUID_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineCacheHeaderVersionOne const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCacheHeaderVersionOne &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCacheHeaderVersionOne const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineCacheHeaderVersionOne *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( headerSize, headerVersion, vendorID, deviceID, pipelineCacheUUID ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineCacheHeaderVersionOne const & ) const = default; -#else - bool operator==( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( headerSize == rhs.headerSize ) && ( headerVersion == rhs.headerVersion ) && ( vendorID == rhs.vendorID ) && ( deviceID == rhs.deviceID ) && - ( pipelineCacheUUID == rhs.pipelineCacheUUID ); -# endif - } - - bool operator!=( PipelineCacheHeaderVersionOne const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t headerSize = {}; - PipelineCacheHeaderVersion headerVersion = PipelineCacheHeaderVersion::eOne; - uint32_t vendorID = {}; - uint32_t deviceID = {}; - ArrayWrapper1D pipelineCacheUUID = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineCacheHeaderVersionOne; - }; -#endif - - // wrapper struct for struct VkPipelineColorBlendAdvancedStateCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorBlendAdvancedStateCreateInfoEXT.html - struct PipelineColorBlendAdvancedStateCreateInfoEXT - { - using NativeType = VkPipelineColorBlendAdvancedStateCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( Bool32 srcPremultiplied_ = {}, - Bool32 dstPremultiplied_ = {}, - BlendOverlapEXT blendOverlap_ = BlendOverlapEXT::eUncorrelated, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcPremultiplied{ srcPremultiplied_ } - , dstPremultiplied{ dstPremultiplied_ } - , blendOverlap{ blendOverlap_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineColorBlendAdvancedStateCreateInfoEXT( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineColorBlendAdvancedStateCreateInfoEXT( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineColorBlendAdvancedStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - PipelineColorBlendAdvancedStateCreateInfoEXT & operator=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineColorBlendAdvancedStateCreateInfoEXT & operator=( VkPipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT & setSrcPremultiplied( Bool32 srcPremultiplied_ ) & VULKAN_HPP_NOEXCEPT - { - srcPremultiplied = srcPremultiplied_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT && setSrcPremultiplied( Bool32 srcPremultiplied_ ) && VULKAN_HPP_NOEXCEPT - { - srcPremultiplied = srcPremultiplied_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT & setDstPremultiplied( Bool32 dstPremultiplied_ ) & VULKAN_HPP_NOEXCEPT - { - dstPremultiplied = dstPremultiplied_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT && setDstPremultiplied( Bool32 dstPremultiplied_ ) && VULKAN_HPP_NOEXCEPT - { - dstPremultiplied = dstPremultiplied_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT & setBlendOverlap( BlendOverlapEXT blendOverlap_ ) & VULKAN_HPP_NOEXCEPT - { - blendOverlap = blendOverlap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorBlendAdvancedStateCreateInfoEXT && setBlendOverlap( BlendOverlapEXT blendOverlap_ ) && VULKAN_HPP_NOEXCEPT - { - blendOverlap = blendOverlap_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineColorBlendAdvancedStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineColorBlendAdvancedStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineColorBlendAdvancedStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcPremultiplied, dstPremultiplied, blendOverlap ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineColorBlendAdvancedStateCreateInfoEXT const & ) const = default; -#else - bool operator==( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcPremultiplied == rhs.srcPremultiplied ) && ( dstPremultiplied == rhs.dstPremultiplied ) && - ( blendOverlap == rhs.blendOverlap ); -# endif - } - - bool operator!=( PipelineColorBlendAdvancedStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT; - const void * pNext = {}; - Bool32 srcPremultiplied = {}; - Bool32 dstPremultiplied = {}; - BlendOverlapEXT blendOverlap = BlendOverlapEXT::eUncorrelated; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineColorBlendAdvancedStateCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineColorBlendAdvancedStateCreateInfoEXT; - }; - - // wrapper struct for struct VkPipelineColorWriteCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineColorWriteCreateInfoEXT.html - struct PipelineColorWriteCreateInfoEXT - { - using NativeType = VkPipelineColorWriteCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineColorWriteCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineColorWriteCreateInfoEXT( uint32_t attachmentCount_ = {}, - const Bool32 * pColorWriteEnables_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , attachmentCount{ attachmentCount_ } - , pColorWriteEnables{ pColorWriteEnables_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineColorWriteCreateInfoEXT( PipelineColorWriteCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineColorWriteCreateInfoEXT( VkPipelineColorWriteCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineColorWriteCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineColorWriteCreateInfoEXT( ArrayProxyNoTemporaries const & colorWriteEnables_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), attachmentCount( static_cast( colorWriteEnables_.size() ) ), pColorWriteEnables( colorWriteEnables_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineColorWriteCreateInfoEXT & operator=( PipelineColorWriteCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineColorWriteCreateInfoEXT & operator=( VkPipelineColorWriteCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT & setPColorWriteEnables( const Bool32 * pColorWriteEnables_ ) & VULKAN_HPP_NOEXCEPT - { - pColorWriteEnables = pColorWriteEnables_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineColorWriteCreateInfoEXT && setPColorWriteEnables( const Bool32 * pColorWriteEnables_ ) && VULKAN_HPP_NOEXCEPT - { - pColorWriteEnables = pColorWriteEnables_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineColorWriteCreateInfoEXT & setColorWriteEnables( ArrayProxyNoTemporaries const & colorWriteEnables_ ) VULKAN_HPP_NOEXCEPT - { - attachmentCount = static_cast( colorWriteEnables_.size() ); - pColorWriteEnables = colorWriteEnables_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineColorWriteCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineColorWriteCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineColorWriteCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineColorWriteCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, attachmentCount, pColorWriteEnables ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineColorWriteCreateInfoEXT const & ) const = default; -#else - bool operator==( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && ( pColorWriteEnables == rhs.pColorWriteEnables ); -# endif - } - - bool operator!=( PipelineColorWriteCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineColorWriteCreateInfoEXT; - const void * pNext = {}; - uint32_t attachmentCount = {}; - const Bool32 * pColorWriteEnables = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineColorWriteCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineColorWriteCreateInfoEXT; - }; - - // wrapper struct for struct VkPipelineCompilerControlCreateInfoAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCompilerControlCreateInfoAMD.html - struct PipelineCompilerControlCreateInfoAMD - { - using NativeType = VkPipelineCompilerControlCreateInfoAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCompilerControlCreateInfoAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( PipelineCompilerControlFlagsAMD compilerControlFlags_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , compilerControlFlags{ compilerControlFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineCompilerControlCreateInfoAMD( PipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineCompilerControlCreateInfoAMD( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineCompilerControlCreateInfoAMD( *reinterpret_cast( &rhs ) ) - { - } - - PipelineCompilerControlCreateInfoAMD & operator=( PipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineCompilerControlCreateInfoAMD & operator=( VkPipelineCompilerControlCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCompilerControlCreateInfoAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCompilerControlCreateInfoAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCompilerControlCreateInfoAMD & setCompilerControlFlags( PipelineCompilerControlFlagsAMD compilerControlFlags_ ) & - VULKAN_HPP_NOEXCEPT - { - compilerControlFlags = compilerControlFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCompilerControlCreateInfoAMD && setCompilerControlFlags( PipelineCompilerControlFlagsAMD compilerControlFlags_ ) && - VULKAN_HPP_NOEXCEPT - { - compilerControlFlags = compilerControlFlags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineCompilerControlCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCompilerControlCreateInfoAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCompilerControlCreateInfoAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineCompilerControlCreateInfoAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, compilerControlFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineCompilerControlCreateInfoAMD const & ) const = default; -#else - bool operator==( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compilerControlFlags == rhs.compilerControlFlags ); -# endif - } - - bool operator!=( PipelineCompilerControlCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineCompilerControlCreateInfoAMD; - const void * pNext = {}; - PipelineCompilerControlFlagsAMD compilerControlFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineCompilerControlCreateInfoAMD; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineCompilerControlCreateInfoAMD; - }; - - // wrapper struct for struct VkPipelineCoverageModulationStateCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageModulationStateCreateInfoNV.html - struct PipelineCoverageModulationStateCreateInfoNV - { - using NativeType = VkPipelineCoverageModulationStateCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_ = {}, - CoverageModulationModeNV coverageModulationMode_ = CoverageModulationModeNV::eNone, - Bool32 coverageModulationTableEnable_ = {}, - uint32_t coverageModulationTableCount_ = {}, - const float * pCoverageModulationTable_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , coverageModulationMode{ coverageModulationMode_ } - , coverageModulationTableEnable{ coverageModulationTableEnable_ } - , coverageModulationTableCount{ coverageModulationTableCount_ } - , pCoverageModulationTable{ pCoverageModulationTable_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineCoverageModulationStateCreateInfoNV( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineCoverageModulationStateCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineCoverageModulationStateCreateInfoNV( PipelineCoverageModulationStateCreateFlagsNV flags_, - CoverageModulationModeNV coverageModulationMode_, - Bool32 coverageModulationTableEnable_, - ArrayProxyNoTemporaries const & coverageModulationTable_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , coverageModulationMode( coverageModulationMode_ ) - , coverageModulationTableEnable( coverageModulationTableEnable_ ) - , coverageModulationTableCount( static_cast( coverageModulationTable_.size() ) ) - , pCoverageModulationTable( coverageModulationTable_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineCoverageModulationStateCreateInfoNV & operator=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineCoverageModulationStateCreateInfoNV & operator=( VkPipelineCoverageModulationStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setFlags( PipelineCoverageModulationStateCreateFlagsNV flags_ ) && - VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ ) & - VULKAN_HPP_NOEXCEPT - { - coverageModulationMode = coverageModulationMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setCoverageModulationMode( CoverageModulationModeNV coverageModulationMode_ ) && - VULKAN_HPP_NOEXCEPT - { - coverageModulationMode = coverageModulationMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - coverageModulationTableEnable = coverageModulationTableEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setCoverageModulationTableEnable( Bool32 coverageModulationTableEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - coverageModulationTableEnable = coverageModulationTableEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ ) & - VULKAN_HPP_NOEXCEPT - { - coverageModulationTableCount = coverageModulationTableCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setCoverageModulationTableCount( uint32_t coverageModulationTableCount_ ) && - VULKAN_HPP_NOEXCEPT - { - coverageModulationTableCount = coverageModulationTableCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV & setPCoverageModulationTable( const float * pCoverageModulationTable_ ) & - VULKAN_HPP_NOEXCEPT - { - pCoverageModulationTable = pCoverageModulationTable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageModulationStateCreateInfoNV && setPCoverageModulationTable( const float * pCoverageModulationTable_ ) && - VULKAN_HPP_NOEXCEPT - { - pCoverageModulationTable = pCoverageModulationTable_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineCoverageModulationStateCreateInfoNV & - setCoverageModulationTable( ArrayProxyNoTemporaries const & coverageModulationTable_ ) VULKAN_HPP_NOEXCEPT - { - coverageModulationTableCount = static_cast( coverageModulationTable_.size() ); - pCoverageModulationTable = coverageModulationTable_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineCoverageModulationStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCoverageModulationStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCoverageModulationStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineCoverageModulationStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, coverageModulationMode, coverageModulationTableEnable, coverageModulationTableCount, pCoverageModulationTable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineCoverageModulationStateCreateInfoNV const & ) const = default; -#else - bool operator==( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( coverageModulationMode == rhs.coverageModulationMode ) && - ( coverageModulationTableEnable == rhs.coverageModulationTableEnable ) && ( coverageModulationTableCount == rhs.coverageModulationTableCount ) && - ( pCoverageModulationTable == rhs.pCoverageModulationTable ); -# endif - } - - bool operator!=( PipelineCoverageModulationStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineCoverageModulationStateCreateInfoNV; - const void * pNext = {}; - PipelineCoverageModulationStateCreateFlagsNV flags = {}; - CoverageModulationModeNV coverageModulationMode = CoverageModulationModeNV::eNone; - Bool32 coverageModulationTableEnable = {}; - uint32_t coverageModulationTableCount = {}; - const float * pCoverageModulationTable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineCoverageModulationStateCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineCoverageModulationStateCreateInfoNV; - }; - - // wrapper struct for struct VkPipelineCoverageReductionStateCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageReductionStateCreateInfoNV.html - struct PipelineCoverageReductionStateCreateInfoNV - { - using NativeType = VkPipelineCoverageReductionStateCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageReductionStateCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( PipelineCoverageReductionStateCreateFlagsNV flags_ = {}, - CoverageReductionModeNV coverageReductionMode_ = CoverageReductionModeNV::eMerge, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , coverageReductionMode{ coverageReductionMode_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineCoverageReductionStateCreateInfoNV( PipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineCoverageReductionStateCreateInfoNV( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineCoverageReductionStateCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - PipelineCoverageReductionStateCreateInfoNV & operator=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineCoverageReductionStateCreateInfoNV & operator=( VkPipelineCoverageReductionStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV & setFlags( PipelineCoverageReductionStateCreateFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV && setFlags( PipelineCoverageReductionStateCreateFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV & setCoverageReductionMode( CoverageReductionModeNV coverageReductionMode_ ) & - VULKAN_HPP_NOEXCEPT - { - coverageReductionMode = coverageReductionMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageReductionStateCreateInfoNV && setCoverageReductionMode( CoverageReductionModeNV coverageReductionMode_ ) && - VULKAN_HPP_NOEXCEPT - { - coverageReductionMode = coverageReductionMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineCoverageReductionStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCoverageReductionStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCoverageReductionStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineCoverageReductionStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, coverageReductionMode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineCoverageReductionStateCreateInfoNV const & ) const = default; -#else - bool operator==( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( coverageReductionMode == rhs.coverageReductionMode ); -# endif - } - - bool operator!=( PipelineCoverageReductionStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineCoverageReductionStateCreateInfoNV; - const void * pNext = {}; - PipelineCoverageReductionStateCreateFlagsNV flags = {}; - CoverageReductionModeNV coverageReductionMode = CoverageReductionModeNV::eMerge; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineCoverageReductionStateCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineCoverageReductionStateCreateInfoNV; - }; - - // wrapper struct for struct VkPipelineCoverageToColorStateCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCoverageToColorStateCreateInfoNV.html - struct PipelineCoverageToColorStateCreateInfoNV - { - using NativeType = VkPipelineCoverageToColorStateCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateFlagsNV flags_ = {}, - Bool32 coverageToColorEnable_ = {}, - uint32_t coverageToColorLocation_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , coverageToColorEnable{ coverageToColorEnable_ } - , coverageToColorLocation{ coverageToColorLocation_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineCoverageToColorStateCreateInfoNV( PipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineCoverageToColorStateCreateInfoNV( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineCoverageToColorStateCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - PipelineCoverageToColorStateCreateInfoNV & operator=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineCoverageToColorStateCreateInfoNV & operator=( VkPipelineCoverageToColorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV & setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV && setFlags( PipelineCoverageToColorStateCreateFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorEnable( Bool32 coverageToColorEnable_ ) & VULKAN_HPP_NOEXCEPT - { - coverageToColorEnable = coverageToColorEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV && setCoverageToColorEnable( Bool32 coverageToColorEnable_ ) && VULKAN_HPP_NOEXCEPT - { - coverageToColorEnable = coverageToColorEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV & setCoverageToColorLocation( uint32_t coverageToColorLocation_ ) & VULKAN_HPP_NOEXCEPT - { - coverageToColorLocation = coverageToColorLocation_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCoverageToColorStateCreateInfoNV && setCoverageToColorLocation( uint32_t coverageToColorLocation_ ) && VULKAN_HPP_NOEXCEPT - { - coverageToColorLocation = coverageToColorLocation_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineCoverageToColorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCoverageToColorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCoverageToColorStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineCoverageToColorStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, coverageToColorEnable, coverageToColorLocation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineCoverageToColorStateCreateInfoNV const & ) const = default; -#else - bool operator==( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( coverageToColorEnable == rhs.coverageToColorEnable ) && - ( coverageToColorLocation == rhs.coverageToColorLocation ); -# endif - } - - bool operator!=( PipelineCoverageToColorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineCoverageToColorStateCreateInfoNV; - const void * pNext = {}; - PipelineCoverageToColorStateCreateFlagsNV flags = {}; - Bool32 coverageToColorEnable = {}; - uint32_t coverageToColorLocation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineCoverageToColorStateCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineCoverageToColorStateCreateInfoNV; - }; - - // wrapper struct for struct VkPipelineCreateFlags2CreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreateFlags2CreateInfo.html - struct PipelineCreateFlags2CreateInfo - { - using NativeType = VkPipelineCreateFlags2CreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCreateFlags2CreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineCreateFlags2CreateInfo( PipelineCreateFlags2 flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineCreateFlags2CreateInfo( PipelineCreateFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineCreateFlags2CreateInfo( VkPipelineCreateFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineCreateFlags2CreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PipelineCreateFlags2CreateInfo & operator=( PipelineCreateFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineCreateFlags2CreateInfo & operator=( VkPipelineCreateFlags2CreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCreateFlags2CreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCreateFlags2CreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCreateFlags2CreateInfo & setFlags( PipelineCreateFlags2 flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCreateFlags2CreateInfo && setFlags( PipelineCreateFlags2 flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineCreateFlags2CreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCreateFlags2CreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCreateFlags2CreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineCreateFlags2CreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineCreateFlags2CreateInfo const & ) const = default; -#else - bool operator==( PipelineCreateFlags2CreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( PipelineCreateFlags2CreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineCreateFlags2CreateInfo; - const void * pNext = {}; - PipelineCreateFlags2 flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineCreateFlags2CreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineCreateFlags2CreateInfo; - }; - - using PipelineCreateFlags2CreateInfoKHR = PipelineCreateFlags2CreateInfo; - - // wrapper struct for struct VkPipelineCreationFeedback, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreationFeedback.html - struct PipelineCreationFeedback - { - using NativeType = VkPipelineCreationFeedback; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineCreationFeedback( PipelineCreationFeedbackFlags flags_ = {}, uint64_t duration_ = {} ) VULKAN_HPP_NOEXCEPT - : flags{ flags_ } - , duration{ duration_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineCreationFeedback( PipelineCreationFeedback const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineCreationFeedback( VkPipelineCreationFeedback const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineCreationFeedback( *reinterpret_cast( &rhs ) ) - { - } - - PipelineCreationFeedback & operator=( PipelineCreationFeedback const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineCreationFeedback & operator=( VkPipelineCreationFeedback const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPipelineCreationFeedback const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCreationFeedback &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCreationFeedback const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineCreationFeedback *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( flags, duration ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineCreationFeedback const & ) const = default; -#else - bool operator==( PipelineCreationFeedback const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( flags == rhs.flags ) && ( duration == rhs.duration ); -# endif - } - - bool operator!=( PipelineCreationFeedback const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - PipelineCreationFeedbackFlags flags = {}; - uint64_t duration = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineCreationFeedback; - }; -#endif - using PipelineCreationFeedbackEXT = PipelineCreationFeedback; - - // wrapper struct for struct VkPipelineCreationFeedbackCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineCreationFeedbackCreateInfo.html - struct PipelineCreationFeedbackCreateInfo - { - using NativeType = VkPipelineCreationFeedbackCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineCreationFeedbackCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfo( PipelineCreationFeedback * pPipelineCreationFeedback_ = {}, - uint32_t pipelineStageCreationFeedbackCount_ = {}, - PipelineCreationFeedback * pPipelineStageCreationFeedbacks_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pPipelineCreationFeedback{ pPipelineCreationFeedback_ } - , pipelineStageCreationFeedbackCount{ pipelineStageCreationFeedbackCount_ } - , pPipelineStageCreationFeedbacks{ pPipelineStageCreationFeedbacks_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineCreationFeedbackCreateInfo( PipelineCreationFeedbackCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineCreationFeedbackCreateInfo( VkPipelineCreationFeedbackCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineCreationFeedbackCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineCreationFeedbackCreateInfo( PipelineCreationFeedback * pPipelineCreationFeedback_, - ArrayProxyNoTemporaries const & pipelineStageCreationFeedbacks_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , pPipelineCreationFeedback( pPipelineCreationFeedback_ ) - , pipelineStageCreationFeedbackCount( static_cast( pipelineStageCreationFeedbacks_.size() ) ) - , pPipelineStageCreationFeedbacks( pipelineStageCreationFeedbacks_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineCreationFeedbackCreateInfo & operator=( PipelineCreationFeedbackCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineCreationFeedbackCreateInfo & operator=( VkPipelineCreationFeedbackCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo & setPPipelineCreationFeedback( PipelineCreationFeedback * pPipelineCreationFeedback_ ) & - VULKAN_HPP_NOEXCEPT - { - pPipelineCreationFeedback = pPipelineCreationFeedback_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo && setPPipelineCreationFeedback( PipelineCreationFeedback * pPipelineCreationFeedback_ ) && - VULKAN_HPP_NOEXCEPT - { - pPipelineCreationFeedback = pPipelineCreationFeedback_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo & setPipelineStageCreationFeedbackCount( uint32_t pipelineStageCreationFeedbackCount_ ) & - VULKAN_HPP_NOEXCEPT - { - pipelineStageCreationFeedbackCount = pipelineStageCreationFeedbackCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo && setPipelineStageCreationFeedbackCount( uint32_t pipelineStageCreationFeedbackCount_ ) && - VULKAN_HPP_NOEXCEPT - { - pipelineStageCreationFeedbackCount = pipelineStageCreationFeedbackCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo & - setPPipelineStageCreationFeedbacks( PipelineCreationFeedback * pPipelineStageCreationFeedbacks_ ) & - VULKAN_HPP_NOEXCEPT - { - pPipelineStageCreationFeedbacks = pPipelineStageCreationFeedbacks_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineCreationFeedbackCreateInfo && - setPPipelineStageCreationFeedbacks( PipelineCreationFeedback * pPipelineStageCreationFeedbacks_ ) && - VULKAN_HPP_NOEXCEPT - { - pPipelineStageCreationFeedbacks = pPipelineStageCreationFeedbacks_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineCreationFeedbackCreateInfo & - setPipelineStageCreationFeedbacks( ArrayProxyNoTemporaries const & pipelineStageCreationFeedbacks_ ) VULKAN_HPP_NOEXCEPT - { - pipelineStageCreationFeedbackCount = static_cast( pipelineStageCreationFeedbacks_.size() ); - pPipelineStageCreationFeedbacks = pipelineStageCreationFeedbacks_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineCreationFeedbackCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCreationFeedbackCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineCreationFeedbackCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineCreationFeedbackCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pPipelineCreationFeedback, pipelineStageCreationFeedbackCount, pPipelineStageCreationFeedbacks ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineCreationFeedbackCreateInfo const & ) const = default; -#else - bool operator==( PipelineCreationFeedbackCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pPipelineCreationFeedback == rhs.pPipelineCreationFeedback ) && - ( pipelineStageCreationFeedbackCount == rhs.pipelineStageCreationFeedbackCount ) && - ( pPipelineStageCreationFeedbacks == rhs.pPipelineStageCreationFeedbacks ); -# endif - } - - bool operator!=( PipelineCreationFeedbackCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineCreationFeedbackCreateInfo; - const void * pNext = {}; - PipelineCreationFeedback * pPipelineCreationFeedback = {}; - uint32_t pipelineStageCreationFeedbackCount = {}; - PipelineCreationFeedback * pPipelineStageCreationFeedbacks = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineCreationFeedbackCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineCreationFeedbackCreateInfo; - }; - - using PipelineCreationFeedbackCreateInfoEXT = PipelineCreationFeedbackCreateInfo; - - // wrapper struct for struct VkPipelineDiscardRectangleStateCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineDiscardRectangleStateCreateInfoEXT.html - struct PipelineDiscardRectangleStateCreateInfoEXT - { - using NativeType = VkPipelineDiscardRectangleStateCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_ = {}, - DiscardRectangleModeEXT discardRectangleMode_ = DiscardRectangleModeEXT::eInclusive, - uint32_t discardRectangleCount_ = {}, - const Rect2D * pDiscardRectangles_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , discardRectangleMode{ discardRectangleMode_ } - , discardRectangleCount{ discardRectangleCount_ } - , pDiscardRectangles{ pDiscardRectangles_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineDiscardRectangleStateCreateInfoEXT( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineDiscardRectangleStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineDiscardRectangleStateCreateInfoEXT( PipelineDiscardRectangleStateCreateFlagsEXT flags_, - DiscardRectangleModeEXT discardRectangleMode_, - ArrayProxyNoTemporaries const & discardRectangles_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , discardRectangleMode( discardRectangleMode_ ) - , discardRectangleCount( static_cast( discardRectangles_.size() ) ) - , pDiscardRectangles( discardRectangles_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineDiscardRectangleStateCreateInfoEXT & operator=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineDiscardRectangleStateCreateInfoEXT & operator=( VkPipelineDiscardRectangleStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT & setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT && setFlags( PipelineDiscardRectangleStateCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ ) & - VULKAN_HPP_NOEXCEPT - { - discardRectangleMode = discardRectangleMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT && setDiscardRectangleMode( DiscardRectangleModeEXT discardRectangleMode_ ) && - VULKAN_HPP_NOEXCEPT - { - discardRectangleMode = discardRectangleMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangleCount( uint32_t discardRectangleCount_ ) & VULKAN_HPP_NOEXCEPT - { - discardRectangleCount = discardRectangleCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT && setDiscardRectangleCount( uint32_t discardRectangleCount_ ) && VULKAN_HPP_NOEXCEPT - { - discardRectangleCount = discardRectangleCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT & setPDiscardRectangles( const Rect2D * pDiscardRectangles_ ) & VULKAN_HPP_NOEXCEPT - { - pDiscardRectangles = pDiscardRectangles_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineDiscardRectangleStateCreateInfoEXT && setPDiscardRectangles( const Rect2D * pDiscardRectangles_ ) && VULKAN_HPP_NOEXCEPT - { - pDiscardRectangles = pDiscardRectangles_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineDiscardRectangleStateCreateInfoEXT & setDiscardRectangles( ArrayProxyNoTemporaries const & discardRectangles_ ) VULKAN_HPP_NOEXCEPT - { - discardRectangleCount = static_cast( discardRectangles_.size() ); - pDiscardRectangles = discardRectangles_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineDiscardRectangleStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineDiscardRectangleStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineDiscardRectangleStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineDiscardRectangleStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, discardRectangleMode, discardRectangleCount, pDiscardRectangles ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineDiscardRectangleStateCreateInfoEXT const & ) const = default; -#else - bool operator==( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( discardRectangleMode == rhs.discardRectangleMode ) && - ( discardRectangleCount == rhs.discardRectangleCount ) && ( pDiscardRectangles == rhs.pDiscardRectangles ); -# endif - } - - bool operator!=( PipelineDiscardRectangleStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineDiscardRectangleStateCreateInfoEXT; - const void * pNext = {}; - PipelineDiscardRectangleStateCreateFlagsEXT flags = {}; - DiscardRectangleModeEXT discardRectangleMode = DiscardRectangleModeEXT::eInclusive; - uint32_t discardRectangleCount = {}; - const Rect2D * pDiscardRectangles = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineDiscardRectangleStateCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineDiscardRectangleStateCreateInfoEXT; - }; - - // wrapper struct for struct VkPipelineExecutableInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineExecutableInfoKHR.html - struct PipelineExecutableInfoKHR - { - using NativeType = VkPipelineExecutableInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( Pipeline pipeline_ = {}, uint32_t executableIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipeline{ pipeline_ } - , executableIndex{ executableIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineExecutableInfoKHR( PipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineExecutableInfoKHR( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineExecutableInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - PipelineExecutableInfoKHR & operator=( PipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineExecutableInfoKHR & operator=( VkPipelineExecutableInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR & setExecutableIndex( uint32_t executableIndex_ ) & VULKAN_HPP_NOEXCEPT - { - executableIndex = executableIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInfoKHR && setExecutableIndex( uint32_t executableIndex_ ) && VULKAN_HPP_NOEXCEPT - { - executableIndex = executableIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineExecutableInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineExecutableInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineExecutableInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineExecutableInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipeline, executableIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineExecutableInfoKHR const & ) const = default; -#else - bool operator==( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ) && ( executableIndex == rhs.executableIndex ); -# endif - } - - bool operator!=( PipelineExecutableInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineExecutableInfoKHR; - const void * pNext = {}; - Pipeline pipeline = {}; - uint32_t executableIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineExecutableInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineExecutableInfoKHR; - }; - - // wrapper struct for struct VkPipelineExecutableInternalRepresentationKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineExecutableInternalRepresentationKHR.html - struct PipelineExecutableInternalRepresentationKHR - { - using NativeType = VkPipelineExecutableInternalRepresentationKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableInternalRepresentationKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableInternalRepresentationKHR( std::array const & name_ = {}, - std::array const & description_ = {}, - Bool32 isText_ = {}, - size_t dataSize_ = {}, - void * pData_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , name{ name_ } - , description{ description_ } - , isText{ isText_ } - , dataSize{ dataSize_ } - , pData{ pData_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - PipelineExecutableInternalRepresentationKHR( PipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineExecutableInternalRepresentationKHR( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineExecutableInternalRepresentationKHR( *reinterpret_cast( &rhs ) ) - { - } - - PipelineExecutableInternalRepresentationKHR & operator=( PipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineExecutableInternalRepresentationKHR & operator=( VkPipelineExecutableInternalRepresentationKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPipelineExecutableInternalRepresentationKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineExecutableInternalRepresentationKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineExecutableInternalRepresentationKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineExecutableInternalRepresentationKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &, - Bool32 const &, - size_t const &, - void * const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, name, description, isText, dataSize, pData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = isText <=> rhs.isText; cmp != 0 ) - return cmp; - if ( auto cmp = dataSize <=> rhs.dataSize; cmp != 0 ) - return cmp; - if ( auto cmp = pData <=> rhs.pData; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( strcmp( name, rhs.name ) == 0 ) && ( strcmp( description, rhs.description ) == 0 ) && - ( isText == rhs.isText ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); - } - - bool operator!=( PipelineExecutableInternalRepresentationKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::ePipelineExecutableInternalRepresentationKHR; - void * pNext = {}; - ArrayWrapper1D name = {}; - ArrayWrapper1D description = {}; - Bool32 isText = {}; - size_t dataSize = {}; - void * pData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineExecutableInternalRepresentationKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineExecutableInternalRepresentationKHR; - }; - - // wrapper struct for struct VkPipelineExecutablePropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineExecutablePropertiesKHR.html - struct PipelineExecutablePropertiesKHR - { - using NativeType = VkPipelineExecutablePropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutablePropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelineExecutablePropertiesKHR( ShaderStageFlags stages_ = {}, - std::array const & name_ = {}, - std::array const & description_ = {}, - uint32_t subgroupSize_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stages{ stages_ } - , name{ name_ } - , description{ description_ } - , subgroupSize{ subgroupSize_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutablePropertiesKHR( PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineExecutablePropertiesKHR( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineExecutablePropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - PipelineExecutablePropertiesKHR & operator=( PipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineExecutablePropertiesKHR & operator=( VkPipelineExecutablePropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPipelineExecutablePropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineExecutablePropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineExecutablePropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineExecutablePropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &, - uint32_t const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stages, name, description, subgroupSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = stages <=> rhs.stages; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( name, rhs.name ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = subgroupSize <=> rhs.subgroupSize; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stages == rhs.stages ) && ( strcmp( name, rhs.name ) == 0 ) && - ( strcmp( description, rhs.description ) == 0 ) && ( subgroupSize == rhs.subgroupSize ); - } - - bool operator!=( PipelineExecutablePropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::ePipelineExecutablePropertiesKHR; - void * pNext = {}; - ShaderStageFlags stages = {}; - ArrayWrapper1D name = {}; - ArrayWrapper1D description = {}; - uint32_t subgroupSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineExecutablePropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineExecutablePropertiesKHR; - }; - - union PipelineExecutableStatisticValueKHR - { - using NativeType = VkPipelineExecutableStatisticValueKHR; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR( Bool32 b32_ = {} ) : b32( b32_ ) {} - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR( int64_t i64_ ) : i64( i64_ ) {} - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR( uint64_t u64_ ) : u64( u64_ ) {} - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR( double f64_ ) : f64( f64_ ) {} -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR & setB32( Bool32 b32_ ) & VULKAN_HPP_NOEXCEPT - { - b32 = b32_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR && setB32( Bool32 b32_ ) && VULKAN_HPP_NOEXCEPT - { - b32 = b32_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR & setI64( int64_t i64_ ) & VULKAN_HPP_NOEXCEPT - { - i64 = i64_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR && setI64( int64_t i64_ ) && VULKAN_HPP_NOEXCEPT - { - i64 = i64_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR & setU64( uint64_t u64_ ) & VULKAN_HPP_NOEXCEPT - { - u64 = u64_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR && setU64( uint64_t u64_ ) && VULKAN_HPP_NOEXCEPT - { - u64 = u64_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR & setF64( double f64_ ) & VULKAN_HPP_NOEXCEPT - { - f64 = f64_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticValueKHR && setF64( double f64_ ) && VULKAN_HPP_NOEXCEPT - { - f64 = f64_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineExecutableStatisticValueKHR const &() const - { - return *reinterpret_cast( this ); - } - - operator VkPipelineExecutableStatisticValueKHR &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - Bool32 b32; - int64_t i64; - uint64_t u64; - double f64; -#else - VkBool32 b32; - int64_t i64; - uint64_t u64; - double f64; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineExecutableStatisticValueKHR; - }; -#endif - - // wrapper struct for struct VkPipelineExecutableStatisticKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineExecutableStatisticKHR.html - struct PipelineExecutableStatisticKHR - { - using NativeType = VkPipelineExecutableStatisticKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineExecutableStatisticKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticKHR( std::array const & name_ = {}, - std::array const & description_ = {}, - PipelineExecutableStatisticFormatKHR format_ = PipelineExecutableStatisticFormatKHR::eBool32, - PipelineExecutableStatisticValueKHR value_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , name{ name_ } - , description{ description_ } - , format{ format_ } - , value{ value_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PipelineExecutableStatisticKHR( PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineExecutableStatisticKHR( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineExecutableStatisticKHR( *reinterpret_cast( &rhs ) ) - { - } - - PipelineExecutableStatisticKHR & operator=( PipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineExecutableStatisticKHR & operator=( VkPipelineExecutableStatisticKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPipelineExecutableStatisticKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineExecutableStatisticKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineExecutableStatisticKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineExecutableStatisticKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - ArrayWrapper1D const &, - PipelineExecutableStatisticFormatKHR const &, - PipelineExecutableStatisticValueKHR const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, name, description, format, value ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineExecutableStatisticKHR; - void * pNext = {}; - ArrayWrapper1D name = {}; - ArrayWrapper1D description = {}; - PipelineExecutableStatisticFormatKHR format = PipelineExecutableStatisticFormatKHR::eBool32; - PipelineExecutableStatisticValueKHR value = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineExecutableStatisticKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineExecutableStatisticKHR; - }; - - // wrapper struct for struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineFragmentDensityMapLayeredCreateInfoVALVE.html - struct PipelineFragmentDensityMapLayeredCreateInfoVALVE - { - using NativeType = VkPipelineFragmentDensityMapLayeredCreateInfoVALVE; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineFragmentDensityMapLayeredCreateInfoVALVE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineFragmentDensityMapLayeredCreateInfoVALVE( uint32_t maxFragmentDensityMapLayers_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxFragmentDensityMapLayers{ maxFragmentDensityMapLayers_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineFragmentDensityMapLayeredCreateInfoVALVE( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineFragmentDensityMapLayeredCreateInfoVALVE( VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineFragmentDensityMapLayeredCreateInfoVALVE( *reinterpret_cast( &rhs ) ) - { - } - - PipelineFragmentDensityMapLayeredCreateInfoVALVE & operator=( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineFragmentDensityMapLayeredCreateInfoVALVE & operator=( VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentDensityMapLayeredCreateInfoVALVE & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentDensityMapLayeredCreateInfoVALVE && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentDensityMapLayeredCreateInfoVALVE & setMaxFragmentDensityMapLayers( uint32_t maxFragmentDensityMapLayers_ ) & - VULKAN_HPP_NOEXCEPT - { - maxFragmentDensityMapLayers = maxFragmentDensityMapLayers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentDensityMapLayeredCreateInfoVALVE && setMaxFragmentDensityMapLayers( uint32_t maxFragmentDensityMapLayers_ ) && - VULKAN_HPP_NOEXCEPT - { - maxFragmentDensityMapLayers = maxFragmentDensityMapLayers_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxFragmentDensityMapLayers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & ) const = default; -#else - bool operator==( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxFragmentDensityMapLayers == rhs.maxFragmentDensityMapLayers ); -# endif - } - - bool operator!=( PipelineFragmentDensityMapLayeredCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineFragmentDensityMapLayeredCreateInfoVALVE; - const void * pNext = {}; - uint32_t maxFragmentDensityMapLayers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineFragmentDensityMapLayeredCreateInfoVALVE; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineFragmentDensityMapLayeredCreateInfoVALVE; - }; - - // wrapper struct for struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineFragmentShadingRateEnumStateCreateInfoNV.html - struct PipelineFragmentShadingRateEnumStateCreateInfoNV - { - using NativeType = VkPipelineFragmentShadingRateEnumStateCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineFragmentShadingRateEnumStateCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV( - FragmentShadingRateTypeNV shadingRateType_ = FragmentShadingRateTypeNV::eFragmentSize, - FragmentShadingRateNV shadingRate_ = FragmentShadingRateNV::e1InvocationPerPixel, - std::array const & combinerOps_ = { { FragmentShadingRateCombinerOpKHR::eKeep, - FragmentShadingRateCombinerOpKHR::eKeep } }, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shadingRateType{ shadingRateType_ } - , shadingRate{ shadingRate_ } - , combinerOps{ combinerOps_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - PipelineFragmentShadingRateEnumStateCreateInfoNV( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineFragmentShadingRateEnumStateCreateInfoNV( VkPipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineFragmentShadingRateEnumStateCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - PipelineFragmentShadingRateEnumStateCreateInfoNV & operator=( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineFragmentShadingRateEnumStateCreateInfoNV & operator=( VkPipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV & setShadingRateType( FragmentShadingRateTypeNV shadingRateType_ ) & - VULKAN_HPP_NOEXCEPT - { - shadingRateType = shadingRateType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV && setShadingRateType( FragmentShadingRateTypeNV shadingRateType_ ) && - VULKAN_HPP_NOEXCEPT - { - shadingRateType = shadingRateType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV & setShadingRate( FragmentShadingRateNV shadingRate_ ) & VULKAN_HPP_NOEXCEPT - { - shadingRate = shadingRate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV && setShadingRate( FragmentShadingRateNV shadingRate_ ) && VULKAN_HPP_NOEXCEPT - { - shadingRate = shadingRate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV & setCombinerOps( std::array combinerOps_ ) & - VULKAN_HPP_NOEXCEPT - { - combinerOps = combinerOps_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateEnumStateCreateInfoNV && - setCombinerOps( std::array combinerOps_ ) && - VULKAN_HPP_NOEXCEPT - { - combinerOps = combinerOps_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineFragmentShadingRateEnumStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shadingRateType, shadingRate, combinerOps ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineFragmentShadingRateEnumStateCreateInfoNV const & ) const = default; -#else - bool operator==( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateType == rhs.shadingRateType ) && ( shadingRate == rhs.shadingRate ) && - ( combinerOps == rhs.combinerOps ); -# endif - } - - bool operator!=( PipelineFragmentShadingRateEnumStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineFragmentShadingRateEnumStateCreateInfoNV; - const void * pNext = {}; - FragmentShadingRateTypeNV shadingRateType = FragmentShadingRateTypeNV::eFragmentSize; - FragmentShadingRateNV shadingRate = FragmentShadingRateNV::e1InvocationPerPixel; - ArrayWrapper1D combinerOps = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineFragmentShadingRateEnumStateCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineFragmentShadingRateEnumStateCreateInfoNV; - }; - - // wrapper struct for struct VkPipelineFragmentShadingRateStateCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineFragmentShadingRateStateCreateInfoKHR.html - struct PipelineFragmentShadingRateStateCreateInfoKHR - { - using NativeType = VkPipelineFragmentShadingRateStateCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineFragmentShadingRateStateCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR( - Extent2D fragmentSize_ = {}, - std::array const & combinerOps_ = { { FragmentShadingRateCombinerOpKHR::eKeep, - FragmentShadingRateCombinerOpKHR::eKeep } }, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fragmentSize{ fragmentSize_ } - , combinerOps{ combinerOps_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 - PipelineFragmentShadingRateStateCreateInfoKHR( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineFragmentShadingRateStateCreateInfoKHR( VkPipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineFragmentShadingRateStateCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - PipelineFragmentShadingRateStateCreateInfoKHR & operator=( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineFragmentShadingRateStateCreateInfoKHR & operator=( VkPipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR & setFragmentSize( Extent2D const & fragmentSize_ ) & VULKAN_HPP_NOEXCEPT - { - fragmentSize = fragmentSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR && setFragmentSize( Extent2D const & fragmentSize_ ) && VULKAN_HPP_NOEXCEPT - { - fragmentSize = fragmentSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR & setCombinerOps( std::array combinerOps_ ) & - VULKAN_HPP_NOEXCEPT - { - combinerOps = combinerOps_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineFragmentShadingRateStateCreateInfoKHR && setCombinerOps( std::array combinerOps_ ) && - VULKAN_HPP_NOEXCEPT - { - combinerOps = combinerOps_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineFragmentShadingRateStateCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineFragmentShadingRateStateCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineFragmentShadingRateStateCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineFragmentShadingRateStateCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fragmentSize, combinerOps ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineFragmentShadingRateStateCreateInfoKHR const & ) const = default; -#else - bool operator==( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentSize == rhs.fragmentSize ) && ( combinerOps == rhs.combinerOps ); -# endif - } - - bool operator!=( PipelineFragmentShadingRateStateCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineFragmentShadingRateStateCreateInfoKHR; - const void * pNext = {}; - Extent2D fragmentSize = {}; - ArrayWrapper1D combinerOps = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineFragmentShadingRateStateCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineFragmentShadingRateStateCreateInfoKHR; - }; - - // wrapper struct for struct VkPipelineIndirectDeviceAddressInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineIndirectDeviceAddressInfoNV.html - struct PipelineIndirectDeviceAddressInfoNV - { - using NativeType = VkPipelineIndirectDeviceAddressInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineIndirectDeviceAddressInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineIndirectDeviceAddressInfoNV( PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, - Pipeline pipeline_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineBindPoint{ pipelineBindPoint_ } - , pipeline{ pipeline_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineIndirectDeviceAddressInfoNV( PipelineIndirectDeviceAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineIndirectDeviceAddressInfoNV( VkPipelineIndirectDeviceAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineIndirectDeviceAddressInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - PipelineIndirectDeviceAddressInfoNV & operator=( PipelineIndirectDeviceAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineIndirectDeviceAddressInfoNV & operator=( VkPipelineIndirectDeviceAddressInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineIndirectDeviceAddressInfoNV && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineIndirectDeviceAddressInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineIndirectDeviceAddressInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineIndirectDeviceAddressInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineIndirectDeviceAddressInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineBindPoint, pipeline ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineIndirectDeviceAddressInfoNV const & ) const = default; -#else - bool operator==( PipelineIndirectDeviceAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( pipeline == rhs.pipeline ); -# endif - } - - bool operator!=( PipelineIndirectDeviceAddressInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineIndirectDeviceAddressInfoNV; - const void * pNext = {}; - PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; - Pipeline pipeline = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineIndirectDeviceAddressInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineIndirectDeviceAddressInfoNV; - }; - - // wrapper struct for struct VkPipelineInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineInfoKHR.html - struct PipelineInfoKHR - { - using NativeType = VkPipelineInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineInfoKHR( Pipeline pipeline_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipeline{ pipeline_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineInfoKHR( PipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineInfoKHR( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PipelineInfoKHR( *reinterpret_cast( &rhs ) ) {} - - PipelineInfoKHR & operator=( PipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineInfoKHR & operator=( VkPipelineInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineInfoKHR & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineInfoKHR && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipeline ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineInfoKHR const & ) const = default; -#else - bool operator==( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ); -# endif - } - - bool operator!=( PipelineInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineInfoKHR; - const void * pNext = {}; - Pipeline pipeline = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineInfoKHR; - }; - - using PipelineInfoEXT = PipelineInfoKHR; - - // wrapper struct for struct VkPipelineLayoutCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineLayoutCreateInfo.html - struct PipelineLayoutCreateInfo - { - using NativeType = VkPipelineLayoutCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineLayoutCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_ = {}, - uint32_t setLayoutCount_ = {}, - const DescriptorSetLayout * pSetLayouts_ = {}, - uint32_t pushConstantRangeCount_ = {}, - const PushConstantRange * pPushConstantRanges_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , setLayoutCount{ setLayoutCount_ } - , pSetLayouts{ pSetLayouts_ } - , pushConstantRangeCount{ pushConstantRangeCount_ } - , pPushConstantRanges{ pPushConstantRanges_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineLayoutCreateInfo( PipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineLayoutCreateInfo( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineLayoutCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineLayoutCreateInfo( PipelineLayoutCreateFlags flags_, - ArrayProxyNoTemporaries const & setLayouts_, - ArrayProxyNoTemporaries const & pushConstantRanges_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , setLayoutCount( static_cast( setLayouts_.size() ) ) - , pSetLayouts( setLayouts_.data() ) - , pushConstantRangeCount( static_cast( pushConstantRanges_.size() ) ) - , pPushConstantRanges( pushConstantRanges_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineLayoutCreateInfo & operator=( PipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineLayoutCreateInfo & operator=( VkPipelineLayoutCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setFlags( PipelineLayoutCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setFlags( PipelineLayoutCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setSetLayoutCount( uint32_t setLayoutCount_ ) & VULKAN_HPP_NOEXCEPT - { - setLayoutCount = setLayoutCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setSetLayoutCount( uint32_t setLayoutCount_ ) && VULKAN_HPP_NOEXCEPT - { - setLayoutCount = setLayoutCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) & VULKAN_HPP_NOEXCEPT - { - pSetLayouts = pSetLayouts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) && VULKAN_HPP_NOEXCEPT - { - pSetLayouts = pSetLayouts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineLayoutCreateInfo & setSetLayouts( ArrayProxyNoTemporaries const & setLayouts_ ) VULKAN_HPP_NOEXCEPT - { - setLayoutCount = static_cast( setLayouts_.size() ); - pSetLayouts = setLayouts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) & VULKAN_HPP_NOEXCEPT - { - pushConstantRangeCount = pushConstantRangeCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) && VULKAN_HPP_NOEXCEPT - { - pushConstantRangeCount = pushConstantRangeCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo & setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) & VULKAN_HPP_NOEXCEPT - { - pPushConstantRanges = pPushConstantRanges_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineLayoutCreateInfo && setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) && VULKAN_HPP_NOEXCEPT - { - pPushConstantRanges = pPushConstantRanges_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineLayoutCreateInfo & setPushConstantRanges( ArrayProxyNoTemporaries const & pushConstantRanges_ ) VULKAN_HPP_NOEXCEPT - { - pushConstantRangeCount = static_cast( pushConstantRanges_.size() ); - pPushConstantRanges = pushConstantRanges_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineLayoutCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineLayoutCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineLayoutCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineLayoutCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, setLayoutCount, pSetLayouts, pushConstantRangeCount, pPushConstantRanges ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineLayoutCreateInfo const & ) const = default; -#else - bool operator==( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( setLayoutCount == rhs.setLayoutCount ) && - ( pSetLayouts == rhs.pSetLayouts ) && ( pushConstantRangeCount == rhs.pushConstantRangeCount ) && - ( pPushConstantRanges == rhs.pPushConstantRanges ); -# endif - } - - bool operator!=( PipelineLayoutCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineLayoutCreateInfo; - const void * pNext = {}; - PipelineLayoutCreateFlags flags = {}; - uint32_t setLayoutCount = {}; - const DescriptorSetLayout * pSetLayouts = {}; - uint32_t pushConstantRangeCount = {}; - const PushConstantRange * pPushConstantRanges = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineLayoutCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineLayoutCreateInfo; - }; - - // wrapper struct for struct VkPipelinePropertiesIdentifierEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelinePropertiesIdentifierEXT.html - struct PipelinePropertiesIdentifierEXT - { - using NativeType = VkPipelinePropertiesIdentifierEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelinePropertiesIdentifierEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 PipelinePropertiesIdentifierEXT( std::array const & pipelineIdentifier_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipelineIdentifier{ pipelineIdentifier_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 PipelinePropertiesIdentifierEXT( PipelinePropertiesIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelinePropertiesIdentifierEXT( VkPipelinePropertiesIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelinePropertiesIdentifierEXT( *reinterpret_cast( &rhs ) ) - { - } - - PipelinePropertiesIdentifierEXT & operator=( PipelinePropertiesIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelinePropertiesIdentifierEXT & operator=( VkPipelinePropertiesIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPipelinePropertiesIdentifierEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelinePropertiesIdentifierEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelinePropertiesIdentifierEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelinePropertiesIdentifierEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipelineIdentifier ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelinePropertiesIdentifierEXT const & ) const = default; -#else - bool operator==( PipelinePropertiesIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipelineIdentifier == rhs.pipelineIdentifier ); -# endif - } - - bool operator!=( PipelinePropertiesIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelinePropertiesIdentifierEXT; - void * pNext = {}; - ArrayWrapper1D pipelineIdentifier = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelinePropertiesIdentifierEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelinePropertiesIdentifierEXT; - }; - - // wrapper struct for struct VkPipelineRasterizationConservativeStateCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationConservativeStateCreateInfoEXT.html - struct PipelineRasterizationConservativeStateCreateInfoEXT - { - using NativeType = VkPipelineRasterizationConservativeStateCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineRasterizationConservativeStateCreateInfoEXT( - PipelineRasterizationConservativeStateCreateFlagsEXT flags_ = {}, - ConservativeRasterizationModeEXT conservativeRasterizationMode_ = ConservativeRasterizationModeEXT::eDisabled, - float extraPrimitiveOverestimationSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , conservativeRasterizationMode{ conservativeRasterizationMode_ } - , extraPrimitiveOverestimationSize{ extraPrimitiveOverestimationSize_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineRasterizationConservativeStateCreateInfoEXT( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineRasterizationConservativeStateCreateInfoEXT( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineRasterizationConservativeStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - PipelineRasterizationConservativeStateCreateInfoEXT & - operator=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineRasterizationConservativeStateCreateInfoEXT & operator=( VkPipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT & setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ ) & - VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT && setFlags( PipelineRasterizationConservativeStateCreateFlagsEXT flags_ ) && - VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT & - setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ ) & - VULKAN_HPP_NOEXCEPT - { - conservativeRasterizationMode = conservativeRasterizationMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT && - setConservativeRasterizationMode( ConservativeRasterizationModeEXT conservativeRasterizationMode_ ) && - VULKAN_HPP_NOEXCEPT - { - conservativeRasterizationMode = conservativeRasterizationMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT & - setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ ) & - VULKAN_HPP_NOEXCEPT - { - extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationConservativeStateCreateInfoEXT && - setExtraPrimitiveOverestimationSize( float extraPrimitiveOverestimationSize_ ) && - VULKAN_HPP_NOEXCEPT - { - extraPrimitiveOverestimationSize = extraPrimitiveOverestimationSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineRasterizationConservativeStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationConservativeStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationConservativeStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineRasterizationConservativeStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, conservativeRasterizationMode, extraPrimitiveOverestimationSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineRasterizationConservativeStateCreateInfoEXT const & ) const = default; -#else - bool operator==( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( conservativeRasterizationMode == rhs.conservativeRasterizationMode ) && - ( extraPrimitiveOverestimationSize == rhs.extraPrimitiveOverestimationSize ); -# endif - } - - bool operator!=( PipelineRasterizationConservativeStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT; - const void * pNext = {}; - PipelineRasterizationConservativeStateCreateFlagsEXT flags = {}; - ConservativeRasterizationModeEXT conservativeRasterizationMode = ConservativeRasterizationModeEXT::eDisabled; - float extraPrimitiveOverestimationSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineRasterizationConservativeStateCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineRasterizationConservativeStateCreateInfoEXT; - }; - - // wrapper struct for struct VkPipelineRasterizationDepthClipStateCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationDepthClipStateCreateInfoEXT.html - struct PipelineRasterizationDepthClipStateCreateInfoEXT - { - using NativeType = VkPipelineRasterizationDepthClipStateCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineRasterizationDepthClipStateCreateInfoEXT( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ = {}, - Bool32 depthClipEnable_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , depthClipEnable{ depthClipEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineRasterizationDepthClipStateCreateInfoEXT( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineRasterizationDepthClipStateCreateInfoEXT( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineRasterizationDepthClipStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - PipelineRasterizationDepthClipStateCreateInfoEXT & operator=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineRasterizationDepthClipStateCreateInfoEXT & operator=( VkPipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT & setFlags( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ ) & - VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT && setFlags( PipelineRasterizationDepthClipStateCreateFlagsEXT flags_ ) && - VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT & setDepthClipEnable( Bool32 depthClipEnable_ ) & VULKAN_HPP_NOEXCEPT - { - depthClipEnable = depthClipEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationDepthClipStateCreateInfoEXT && setDepthClipEnable( Bool32 depthClipEnable_ ) && VULKAN_HPP_NOEXCEPT - { - depthClipEnable = depthClipEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationDepthClipStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationDepthClipStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineRasterizationDepthClipStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, depthClipEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineRasterizationDepthClipStateCreateInfoEXT const & ) const = default; -#else - bool operator==( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( depthClipEnable == rhs.depthClipEnable ); -# endif - } - - bool operator!=( PipelineRasterizationDepthClipStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT; - const void * pNext = {}; - PipelineRasterizationDepthClipStateCreateFlagsEXT flags = {}; - Bool32 depthClipEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineRasterizationDepthClipStateCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineRasterizationDepthClipStateCreateInfoEXT; - }; - - // wrapper struct for struct VkPipelineRasterizationLineStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationLineStateCreateInfo.html - struct PipelineRasterizationLineStateCreateInfo - { - using NativeType = VkPipelineRasterizationLineStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationLineStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfo( LineRasterizationMode lineRasterizationMode_ = LineRasterizationMode::eDefault, - Bool32 stippledLineEnable_ = {}, - uint32_t lineStippleFactor_ = {}, - uint16_t lineStipplePattern_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , lineRasterizationMode{ lineRasterizationMode_ } - , stippledLineEnable{ stippledLineEnable_ } - , lineStippleFactor{ lineStippleFactor_ } - , lineStipplePattern{ lineStipplePattern_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineRasterizationLineStateCreateInfo( PipelineRasterizationLineStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineRasterizationLineStateCreateInfo( VkPipelineRasterizationLineStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineRasterizationLineStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PipelineRasterizationLineStateCreateInfo & operator=( PipelineRasterizationLineStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineRasterizationLineStateCreateInfo & operator=( VkPipelineRasterizationLineStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo & setLineRasterizationMode( LineRasterizationMode lineRasterizationMode_ ) & - VULKAN_HPP_NOEXCEPT - { - lineRasterizationMode = lineRasterizationMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo && setLineRasterizationMode( LineRasterizationMode lineRasterizationMode_ ) && - VULKAN_HPP_NOEXCEPT - { - lineRasterizationMode = lineRasterizationMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo & setStippledLineEnable( Bool32 stippledLineEnable_ ) & VULKAN_HPP_NOEXCEPT - { - stippledLineEnable = stippledLineEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo && setStippledLineEnable( Bool32 stippledLineEnable_ ) && VULKAN_HPP_NOEXCEPT - { - stippledLineEnable = stippledLineEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo & setLineStippleFactor( uint32_t lineStippleFactor_ ) & VULKAN_HPP_NOEXCEPT - { - lineStippleFactor = lineStippleFactor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo && setLineStippleFactor( uint32_t lineStippleFactor_ ) && VULKAN_HPP_NOEXCEPT - { - lineStippleFactor = lineStippleFactor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo & setLineStipplePattern( uint16_t lineStipplePattern_ ) & VULKAN_HPP_NOEXCEPT - { - lineStipplePattern = lineStipplePattern_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationLineStateCreateInfo && setLineStipplePattern( uint16_t lineStipplePattern_ ) && VULKAN_HPP_NOEXCEPT - { - lineStipplePattern = lineStipplePattern_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineRasterizationLineStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationLineStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationLineStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineRasterizationLineStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, lineRasterizationMode, stippledLineEnable, lineStippleFactor, lineStipplePattern ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineRasterizationLineStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineRasterizationLineStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( lineRasterizationMode == rhs.lineRasterizationMode ) && - ( stippledLineEnable == rhs.stippledLineEnable ) && ( lineStippleFactor == rhs.lineStippleFactor ) && - ( lineStipplePattern == rhs.lineStipplePattern ); -# endif - } - - bool operator!=( PipelineRasterizationLineStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineRasterizationLineStateCreateInfo; - const void * pNext = {}; - LineRasterizationMode lineRasterizationMode = LineRasterizationMode::eDefault; - Bool32 stippledLineEnable = {}; - uint32_t lineStippleFactor = {}; - uint16_t lineStipplePattern = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineRasterizationLineStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineRasterizationLineStateCreateInfo; - }; - - using PipelineRasterizationLineStateCreateInfoEXT = PipelineRasterizationLineStateCreateInfo; - using PipelineRasterizationLineStateCreateInfoKHR = PipelineRasterizationLineStateCreateInfo; - - // wrapper struct for struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.html - struct PipelineRasterizationProvokingVertexStateCreateInfoEXT - { - using NativeType = VkPipelineRasterizationProvokingVertexStateCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationProvokingVertexStateCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PipelineRasterizationProvokingVertexStateCreateInfoEXT( ProvokingVertexModeEXT provokingVertexMode_ = ProvokingVertexModeEXT::eFirstVertex, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , provokingVertexMode{ provokingVertexMode_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineRasterizationProvokingVertexStateCreateInfoEXT( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - PipelineRasterizationProvokingVertexStateCreateInfoEXT( VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineRasterizationProvokingVertexStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - PipelineRasterizationProvokingVertexStateCreateInfoEXT & - operator=( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineRasterizationProvokingVertexStateCreateInfoEXT & - operator=( VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationProvokingVertexStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationProvokingVertexStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationProvokingVertexStateCreateInfoEXT & setProvokingVertexMode( ProvokingVertexModeEXT provokingVertexMode_ ) & - VULKAN_HPP_NOEXCEPT - { - provokingVertexMode = provokingVertexMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationProvokingVertexStateCreateInfoEXT && setProvokingVertexMode( ProvokingVertexModeEXT provokingVertexMode_ ) && - VULKAN_HPP_NOEXCEPT - { - provokingVertexMode = provokingVertexMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, provokingVertexMode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & ) const = default; -#else - bool operator==( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( provokingVertexMode == rhs.provokingVertexMode ); -# endif - } - - bool operator!=( PipelineRasterizationProvokingVertexStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineRasterizationProvokingVertexStateCreateInfoEXT; - const void * pNext = {}; - ProvokingVertexModeEXT provokingVertexMode = ProvokingVertexModeEXT::eFirstVertex; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineRasterizationProvokingVertexStateCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineRasterizationProvokingVertexStateCreateInfoEXT; - }; - - // wrapper struct for struct VkPipelineRasterizationStateRasterizationOrderAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateRasterizationOrderAMD.html - struct PipelineRasterizationStateRasterizationOrderAMD - { - using NativeType = VkPipelineRasterizationStateRasterizationOrderAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineRasterizationStateRasterizationOrderAMD( RasterizationOrderAMD rasterizationOrder_ = RasterizationOrderAMD::eStrict, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rasterizationOrder{ rasterizationOrder_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineRasterizationStateRasterizationOrderAMD( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineRasterizationStateRasterizationOrderAMD( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineRasterizationStateRasterizationOrderAMD( *reinterpret_cast( &rhs ) ) - { - } - - PipelineRasterizationStateRasterizationOrderAMD & operator=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineRasterizationStateRasterizationOrderAMD & operator=( VkPipelineRasterizationStateRasterizationOrderAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateRasterizationOrderAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateRasterizationOrderAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateRasterizationOrderAMD & setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ ) & - VULKAN_HPP_NOEXCEPT - { - rasterizationOrder = rasterizationOrder_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateRasterizationOrderAMD && setRasterizationOrder( RasterizationOrderAMD rasterizationOrder_ ) && - VULKAN_HPP_NOEXCEPT - { - rasterizationOrder = rasterizationOrder_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineRasterizationStateRasterizationOrderAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationStateRasterizationOrderAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationStateRasterizationOrderAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineRasterizationStateRasterizationOrderAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rasterizationOrder ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineRasterizationStateRasterizationOrderAMD const & ) const = default; -#else - bool operator==( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rasterizationOrder == rhs.rasterizationOrder ); -# endif - } - - bool operator!=( PipelineRasterizationStateRasterizationOrderAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineRasterizationStateRasterizationOrderAMD; - const void * pNext = {}; - RasterizationOrderAMD rasterizationOrder = RasterizationOrderAMD::eStrict; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineRasterizationStateRasterizationOrderAMD; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineRasterizationStateRasterizationOrderAMD; - }; - - // wrapper struct for struct VkPipelineRasterizationStateStreamCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRasterizationStateStreamCreateInfoEXT.html - struct PipelineRasterizationStateStreamCreateInfoEXT - { - using NativeType = VkPipelineRasterizationStateStreamCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateFlagsEXT flags_ = {}, - uint32_t rasterizationStream_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , rasterizationStream{ rasterizationStream_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineRasterizationStateStreamCreateInfoEXT( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineRasterizationStateStreamCreateInfoEXT( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineRasterizationStateStreamCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - PipelineRasterizationStateStreamCreateInfoEXT & operator=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineRasterizationStateStreamCreateInfoEXT & operator=( VkPipelineRasterizationStateStreamCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT & setFlags( PipelineRasterizationStateStreamCreateFlagsEXT flags_ ) & - VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT && setFlags( PipelineRasterizationStateStreamCreateFlagsEXT flags_ ) && - VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT & setRasterizationStream( uint32_t rasterizationStream_ ) & VULKAN_HPP_NOEXCEPT - { - rasterizationStream = rasterizationStream_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRasterizationStateStreamCreateInfoEXT && setRasterizationStream( uint32_t rasterizationStream_ ) && VULKAN_HPP_NOEXCEPT - { - rasterizationStream = rasterizationStream_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineRasterizationStateStreamCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationStateStreamCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRasterizationStateStreamCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineRasterizationStateStreamCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, rasterizationStream ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineRasterizationStateStreamCreateInfoEXT const & ) const = default; -#else - bool operator==( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rasterizationStream == rhs.rasterizationStream ); -# endif - } - - bool operator!=( PipelineRasterizationStateStreamCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineRasterizationStateStreamCreateInfoEXT; - const void * pNext = {}; - PipelineRasterizationStateStreamCreateFlagsEXT flags = {}; - uint32_t rasterizationStream = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineRasterizationStateStreamCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineRasterizationStateStreamCreateInfoEXT; - }; - - // wrapper struct for struct VkPipelineRenderingCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRenderingCreateInfo.html - struct PipelineRenderingCreateInfo - { - using NativeType = VkPipelineRenderingCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRenderingCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineRenderingCreateInfo( uint32_t viewMask_ = {}, - uint32_t colorAttachmentCount_ = {}, - const Format * pColorAttachmentFormats_ = {}, - Format depthAttachmentFormat_ = Format::eUndefined, - Format stencilAttachmentFormat_ = Format::eUndefined, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , viewMask{ viewMask_ } - , colorAttachmentCount{ colorAttachmentCount_ } - , pColorAttachmentFormats{ pColorAttachmentFormats_ } - , depthAttachmentFormat{ depthAttachmentFormat_ } - , stencilAttachmentFormat{ stencilAttachmentFormat_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineRenderingCreateInfo( PipelineRenderingCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineRenderingCreateInfo( VkPipelineRenderingCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineRenderingCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineRenderingCreateInfo( uint32_t viewMask_, - ArrayProxyNoTemporaries const & colorAttachmentFormats_, - Format depthAttachmentFormat_ = Format::eUndefined, - Format stencilAttachmentFormat_ = Format::eUndefined, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , viewMask( viewMask_ ) - , colorAttachmentCount( static_cast( colorAttachmentFormats_.size() ) ) - , pColorAttachmentFormats( colorAttachmentFormats_.data() ) - , depthAttachmentFormat( depthAttachmentFormat_ ) - , stencilAttachmentFormat( stencilAttachmentFormat_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineRenderingCreateInfo & operator=( PipelineRenderingCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineRenderingCreateInfo & operator=( VkPipelineRenderingCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setViewMask( uint32_t viewMask_ ) & VULKAN_HPP_NOEXCEPT - { - viewMask = viewMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setViewMask( uint32_t viewMask_ ) && VULKAN_HPP_NOEXCEPT - { - viewMask = viewMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) & VULKAN_HPP_NOEXCEPT - { - pColorAttachmentFormats = pColorAttachmentFormats_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) && VULKAN_HPP_NOEXCEPT - { - pColorAttachmentFormats = pColorAttachmentFormats_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineRenderingCreateInfo & setColorAttachmentFormats( ArrayProxyNoTemporaries const & colorAttachmentFormats_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( colorAttachmentFormats_.size() ); - pColorAttachmentFormats = colorAttachmentFormats_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setDepthAttachmentFormat( Format depthAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT - { - depthAttachmentFormat = depthAttachmentFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setDepthAttachmentFormat( Format depthAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT - { - depthAttachmentFormat = depthAttachmentFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo & setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT - { - stencilAttachmentFormat = stencilAttachmentFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRenderingCreateInfo && setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT - { - stencilAttachmentFormat = stencilAttachmentFormat_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineRenderingCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRenderingCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRenderingCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineRenderingCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, viewMask, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineRenderingCreateInfo const & ) const = default; -#else - bool operator==( PipelineRenderingCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && - ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ); -# endif - } - - bool operator!=( PipelineRenderingCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineRenderingCreateInfo; - const void * pNext = {}; - uint32_t viewMask = {}; - uint32_t colorAttachmentCount = {}; - const Format * pColorAttachmentFormats = {}; - Format depthAttachmentFormat = Format::eUndefined; - Format stencilAttachmentFormat = Format::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineRenderingCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineRenderingCreateInfo; - }; - - using PipelineRenderingCreateInfoKHR = PipelineRenderingCreateInfo; - - // wrapper struct for struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRepresentativeFragmentTestStateCreateInfoNV.html - struct PipelineRepresentativeFragmentTestStateCreateInfoNV - { - using NativeType = VkPipelineRepresentativeFragmentTestStateCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineRepresentativeFragmentTestStateCreateInfoNV( Bool32 representativeFragmentTestEnable_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , representativeFragmentTestEnable{ representativeFragmentTestEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineRepresentativeFragmentTestStateCreateInfoNV( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineRepresentativeFragmentTestStateCreateInfoNV( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineRepresentativeFragmentTestStateCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - PipelineRepresentativeFragmentTestStateCreateInfoNV & - operator=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineRepresentativeFragmentTestStateCreateInfoNV & operator=( VkPipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineRepresentativeFragmentTestStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRepresentativeFragmentTestStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRepresentativeFragmentTestStateCreateInfoNV & - setRepresentativeFragmentTestEnable( Bool32 representativeFragmentTestEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - representativeFragmentTestEnable = representativeFragmentTestEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRepresentativeFragmentTestStateCreateInfoNV && - setRepresentativeFragmentTestEnable( Bool32 representativeFragmentTestEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - representativeFragmentTestEnable = representativeFragmentTestEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineRepresentativeFragmentTestStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, representativeFragmentTestEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineRepresentativeFragmentTestStateCreateInfoNV const & ) const = default; -#else - bool operator==( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( representativeFragmentTestEnable == rhs.representativeFragmentTestEnable ); -# endif - } - - bool operator!=( PipelineRepresentativeFragmentTestStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV; - const void * pNext = {}; - Bool32 representativeFragmentTestEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineRepresentativeFragmentTestStateCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineRepresentativeFragmentTestStateCreateInfoNV; - }; - - // wrapper struct for struct VkPipelineRobustnessCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineRobustnessCreateInfo.html - struct PipelineRobustnessCreateInfo - { - using NativeType = VkPipelineRobustnessCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineRobustnessCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineRobustnessCreateInfo( PipelineRobustnessBufferBehavior storageBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, - PipelineRobustnessBufferBehavior uniformBuffers_ = PipelineRobustnessBufferBehavior::eDeviceDefault, - PipelineRobustnessBufferBehavior vertexInputs_ = PipelineRobustnessBufferBehavior::eDeviceDefault, - PipelineRobustnessImageBehavior images_ = PipelineRobustnessImageBehavior::eDeviceDefault, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , storageBuffers{ storageBuffers_ } - , uniformBuffers{ uniformBuffers_ } - , vertexInputs{ vertexInputs_ } - , images{ images_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineRobustnessCreateInfo( PipelineRobustnessCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineRobustnessCreateInfo( VkPipelineRobustnessCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineRobustnessCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PipelineRobustnessCreateInfo & operator=( PipelineRobustnessCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineRobustnessCreateInfo & operator=( VkPipelineRobustnessCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo & setStorageBuffers( PipelineRobustnessBufferBehavior storageBuffers_ ) & VULKAN_HPP_NOEXCEPT - { - storageBuffers = storageBuffers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo && setStorageBuffers( PipelineRobustnessBufferBehavior storageBuffers_ ) && VULKAN_HPP_NOEXCEPT - { - storageBuffers = storageBuffers_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo & setUniformBuffers( PipelineRobustnessBufferBehavior uniformBuffers_ ) & VULKAN_HPP_NOEXCEPT - { - uniformBuffers = uniformBuffers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo && setUniformBuffers( PipelineRobustnessBufferBehavior uniformBuffers_ ) && VULKAN_HPP_NOEXCEPT - { - uniformBuffers = uniformBuffers_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo & setVertexInputs( PipelineRobustnessBufferBehavior vertexInputs_ ) & VULKAN_HPP_NOEXCEPT - { - vertexInputs = vertexInputs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo && setVertexInputs( PipelineRobustnessBufferBehavior vertexInputs_ ) && VULKAN_HPP_NOEXCEPT - { - vertexInputs = vertexInputs_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo & setImages( PipelineRobustnessImageBehavior images_ ) & VULKAN_HPP_NOEXCEPT - { - images = images_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineRobustnessCreateInfo && setImages( PipelineRobustnessImageBehavior images_ ) && VULKAN_HPP_NOEXCEPT - { - images = images_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineRobustnessCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRobustnessCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineRobustnessCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineRobustnessCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, storageBuffers, uniformBuffers, vertexInputs, images ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineRobustnessCreateInfo const & ) const = default; -#else - bool operator==( PipelineRobustnessCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( storageBuffers == rhs.storageBuffers ) && ( uniformBuffers == rhs.uniformBuffers ) && - ( vertexInputs == rhs.vertexInputs ) && ( images == rhs.images ); -# endif - } - - bool operator!=( PipelineRobustnessCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineRobustnessCreateInfo; - const void * pNext = {}; - PipelineRobustnessBufferBehavior storageBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; - PipelineRobustnessBufferBehavior uniformBuffers = PipelineRobustnessBufferBehavior::eDeviceDefault; - PipelineRobustnessBufferBehavior vertexInputs = PipelineRobustnessBufferBehavior::eDeviceDefault; - PipelineRobustnessImageBehavior images = PipelineRobustnessImageBehavior::eDeviceDefault; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineRobustnessCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineRobustnessCreateInfo; - }; - - using PipelineRobustnessCreateInfoEXT = PipelineRobustnessCreateInfo; - - // wrapper struct for struct VkPipelineSampleLocationsStateCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineSampleLocationsStateCreateInfoEXT.html - struct PipelineSampleLocationsStateCreateInfoEXT - { - using NativeType = VkPipelineSampleLocationsStateCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( Bool32 sampleLocationsEnable_ = {}, - SampleLocationsInfoEXT sampleLocationsInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , sampleLocationsEnable{ sampleLocationsEnable_ } - , sampleLocationsInfo{ sampleLocationsInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineSampleLocationsStateCreateInfoEXT( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineSampleLocationsStateCreateInfoEXT( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineSampleLocationsStateCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - PipelineSampleLocationsStateCreateInfoEXT & operator=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineSampleLocationsStateCreateInfoEXT & operator=( VkPipelineSampleLocationsStateCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsEnable( Bool32 sampleLocationsEnable_ ) & VULKAN_HPP_NOEXCEPT - { - sampleLocationsEnable = sampleLocationsEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT && setSampleLocationsEnable( Bool32 sampleLocationsEnable_ ) && VULKAN_HPP_NOEXCEPT - { - sampleLocationsEnable = sampleLocationsEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT & setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - sampleLocationsInfo = sampleLocationsInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineSampleLocationsStateCreateInfoEXT && setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - sampleLocationsInfo = sampleLocationsInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineSampleLocationsStateCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineSampleLocationsStateCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineSampleLocationsStateCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineSampleLocationsStateCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, sampleLocationsEnable, sampleLocationsInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineSampleLocationsStateCreateInfoEXT const & ) const = default; -#else - bool operator==( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleLocationsEnable == rhs.sampleLocationsEnable ) && - ( sampleLocationsInfo == rhs.sampleLocationsInfo ); -# endif - } - - bool operator!=( PipelineSampleLocationsStateCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineSampleLocationsStateCreateInfoEXT; - const void * pNext = {}; - Bool32 sampleLocationsEnable = {}; - SampleLocationsInfoEXT sampleLocationsInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineSampleLocationsStateCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineSampleLocationsStateCreateInfoEXT; - }; - - // wrapper struct for struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageModuleIdentifierCreateInfoEXT.html - struct PipelineShaderStageModuleIdentifierCreateInfoEXT - { - using NativeType = VkPipelineShaderStageModuleIdentifierCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineShaderStageModuleIdentifierCreateInfoEXT( uint32_t identifierSize_ = {}, - const uint8_t * pIdentifier_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , identifierSize{ identifierSize_ } - , pIdentifier{ pIdentifier_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineShaderStageModuleIdentifierCreateInfoEXT( PipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineShaderStageModuleIdentifierCreateInfoEXT( VkPipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineShaderStageModuleIdentifierCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineShaderStageModuleIdentifierCreateInfoEXT( ArrayProxyNoTemporaries const & identifier_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), identifierSize( static_cast( identifier_.size() ) ), pIdentifier( identifier_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineShaderStageModuleIdentifierCreateInfoEXT & operator=( PipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineShaderStageModuleIdentifierCreateInfoEXT & operator=( VkPipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT & setIdentifierSize( uint32_t identifierSize_ ) & VULKAN_HPP_NOEXCEPT - { - identifierSize = identifierSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT && setIdentifierSize( uint32_t identifierSize_ ) && VULKAN_HPP_NOEXCEPT - { - identifierSize = identifierSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT & setPIdentifier( const uint8_t * pIdentifier_ ) & VULKAN_HPP_NOEXCEPT - { - pIdentifier = pIdentifier_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageModuleIdentifierCreateInfoEXT && setPIdentifier( const uint8_t * pIdentifier_ ) && VULKAN_HPP_NOEXCEPT - { - pIdentifier = pIdentifier_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineShaderStageModuleIdentifierCreateInfoEXT & setIdentifier( ArrayProxyNoTemporaries const & identifier_ ) VULKAN_HPP_NOEXCEPT - { - identifierSize = static_cast( identifier_.size() ); - pIdentifier = identifier_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineShaderStageModuleIdentifierCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineShaderStageModuleIdentifierCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineShaderStageModuleIdentifierCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineShaderStageModuleIdentifierCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, identifierSize, pIdentifier ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineShaderStageModuleIdentifierCreateInfoEXT const & ) const = default; -#else - bool operator==( PipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( identifierSize == rhs.identifierSize ) && ( pIdentifier == rhs.pIdentifier ); -# endif - } - - bool operator!=( PipelineShaderStageModuleIdentifierCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT; - const void * pNext = {}; - uint32_t identifierSize = {}; - const uint8_t * pIdentifier = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineShaderStageModuleIdentifierCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineShaderStageModuleIdentifierCreateInfoEXT; - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkPipelineShaderStageNodeCreateInfoAMDX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageNodeCreateInfoAMDX.html - struct PipelineShaderStageNodeCreateInfoAMDX - { - using NativeType = VkPipelineShaderStageNodeCreateInfoAMDX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageNodeCreateInfoAMDX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PipelineShaderStageNodeCreateInfoAMDX( const char * pName_ = {}, uint32_t index_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pName{ pName_ } - , index{ index_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineShaderStageNodeCreateInfoAMDX( PipelineShaderStageNodeCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineShaderStageNodeCreateInfoAMDX( VkPipelineShaderStageNodeCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineShaderStageNodeCreateInfoAMDX( *reinterpret_cast( &rhs ) ) - { - } - - PipelineShaderStageNodeCreateInfoAMDX & operator=( PipelineShaderStageNodeCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineShaderStageNodeCreateInfoAMDX & operator=( VkPipelineShaderStageNodeCreateInfoAMDX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT - { - index = index_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageNodeCreateInfoAMDX && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT - { - index = index_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineShaderStageNodeCreateInfoAMDX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineShaderStageNodeCreateInfoAMDX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineShaderStageNodeCreateInfoAMDX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineShaderStageNodeCreateInfoAMDX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pName, index ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PipelineShaderStageNodeCreateInfoAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( pName != rhs.pName ) - if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = index <=> rhs.index; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -# endif - - bool operator==( PipelineShaderStageNodeCreateInfoAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( index == rhs.index ); - } - - bool operator!=( PipelineShaderStageNodeCreateInfoAMDX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::ePipelineShaderStageNodeCreateInfoAMDX; - const void * pNext = {}; - const char * pName = {}; - uint32_t index = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineShaderStageNodeCreateInfoAMDX; - }; -# endif - - template <> - struct CppType - { - using Type = PipelineShaderStageNodeCreateInfoAMDX; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.html - struct PipelineShaderStageRequiredSubgroupSizeCreateInfo - { - using NativeType = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineShaderStageRequiredSubgroupSizeCreateInfo( uint32_t requiredSubgroupSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , requiredSubgroupSize{ requiredSubgroupSize_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineShaderStageRequiredSubgroupSizeCreateInfo( PipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineShaderStageRequiredSubgroupSizeCreateInfo( VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineShaderStageRequiredSubgroupSizeCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PipelineShaderStageRequiredSubgroupSizeCreateInfo & - operator=( PipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineShaderStageRequiredSubgroupSizeCreateInfo & operator=( VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageRequiredSubgroupSizeCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageRequiredSubgroupSizeCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageRequiredSubgroupSizeCreateInfo & setRequiredSubgroupSize( uint32_t requiredSubgroupSize_ ) & VULKAN_HPP_NOEXCEPT - { - requiredSubgroupSize = requiredSubgroupSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineShaderStageRequiredSubgroupSizeCreateInfo && setRequiredSubgroupSize( uint32_t requiredSubgroupSize_ ) && - VULKAN_HPP_NOEXCEPT - { - requiredSubgroupSize = requiredSubgroupSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, requiredSubgroupSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineShaderStageRequiredSubgroupSizeCreateInfo const & ) const = default; -#else - bool operator==( PipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( requiredSubgroupSize == rhs.requiredSubgroupSize ); -# endif - } - - bool operator!=( PipelineShaderStageRequiredSubgroupSizeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfo; - const void * pNext = {}; - uint32_t requiredSubgroupSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfo; - }; - - using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; - using ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; - - // wrapper struct for struct VkPipelineTessellationDomainOriginStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineTessellationDomainOriginStateCreateInfo.html - struct PipelineTessellationDomainOriginStateCreateInfo - { - using NativeType = VkPipelineTessellationDomainOriginStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineTessellationDomainOriginStateCreateInfo( TessellationDomainOrigin domainOrigin_ = TessellationDomainOrigin::eUpperLeft, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , domainOrigin{ domainOrigin_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineTessellationDomainOriginStateCreateInfo( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineTessellationDomainOriginStateCreateInfo( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineTessellationDomainOriginStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PipelineTessellationDomainOriginStateCreateInfo & operator=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineTessellationDomainOriginStateCreateInfo & operator=( VkPipelineTessellationDomainOriginStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineTessellationDomainOriginStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineTessellationDomainOriginStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineTessellationDomainOriginStateCreateInfo & setDomainOrigin( TessellationDomainOrigin domainOrigin_ ) & VULKAN_HPP_NOEXCEPT - { - domainOrigin = domainOrigin_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineTessellationDomainOriginStateCreateInfo && setDomainOrigin( TessellationDomainOrigin domainOrigin_ ) && VULKAN_HPP_NOEXCEPT - { - domainOrigin = domainOrigin_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineTessellationDomainOriginStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineTessellationDomainOriginStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineTessellationDomainOriginStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineTessellationDomainOriginStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, domainOrigin ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineTessellationDomainOriginStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( domainOrigin == rhs.domainOrigin ); -# endif - } - - bool operator!=( PipelineTessellationDomainOriginStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineTessellationDomainOriginStateCreateInfo; - const void * pNext = {}; - TessellationDomainOrigin domainOrigin = TessellationDomainOrigin::eUpperLeft; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineTessellationDomainOriginStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineTessellationDomainOriginStateCreateInfo; - }; - - using PipelineTessellationDomainOriginStateCreateInfoKHR = PipelineTessellationDomainOriginStateCreateInfo; - - // wrapper struct for struct VkVertexInputBindingDivisorDescription, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputBindingDivisorDescription.html - struct VertexInputBindingDivisorDescription - { - using NativeType = VkVertexInputBindingDivisorDescription; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VertexInputBindingDivisorDescription( uint32_t binding_ = {}, uint32_t divisor_ = {} ) VULKAN_HPP_NOEXCEPT - : binding{ binding_ } - , divisor{ divisor_ } - { - } - - VULKAN_HPP_CONSTEXPR VertexInputBindingDivisorDescription( VertexInputBindingDivisorDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VertexInputBindingDivisorDescription( VkVertexInputBindingDivisorDescription const & rhs ) VULKAN_HPP_NOEXCEPT - : VertexInputBindingDivisorDescription( *reinterpret_cast( &rhs ) ) - { - } - - VertexInputBindingDivisorDescription & operator=( VertexInputBindingDivisorDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VertexInputBindingDivisorDescription & operator=( VkVertexInputBindingDivisorDescription const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDivisorDescription & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDivisorDescription && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDivisorDescription & setDivisor( uint32_t divisor_ ) & VULKAN_HPP_NOEXCEPT - { - divisor = divisor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDivisorDescription && setDivisor( uint32_t divisor_ ) && VULKAN_HPP_NOEXCEPT - { - divisor = divisor_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVertexInputBindingDivisorDescription const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVertexInputBindingDivisorDescription &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVertexInputBindingDivisorDescription const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVertexInputBindingDivisorDescription *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( binding, divisor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VertexInputBindingDivisorDescription const & ) const = default; -#else - bool operator==( VertexInputBindingDivisorDescription const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( binding == rhs.binding ) && ( divisor == rhs.divisor ); -# endif - } - - bool operator!=( VertexInputBindingDivisorDescription const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t binding = {}; - uint32_t divisor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VertexInputBindingDivisorDescription; - }; -#endif - using VertexInputBindingDivisorDescriptionEXT = VertexInputBindingDivisorDescription; - using VertexInputBindingDivisorDescriptionKHR = VertexInputBindingDivisorDescription; - - // wrapper struct for struct VkPipelineVertexInputDivisorStateCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineVertexInputDivisorStateCreateInfo.html - struct PipelineVertexInputDivisorStateCreateInfo - { - using NativeType = VkPipelineVertexInputDivisorStateCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineVertexInputDivisorStateCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfo( uint32_t vertexBindingDivisorCount_ = {}, - const VertexInputBindingDivisorDescription * pVertexBindingDivisors_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , vertexBindingDivisorCount{ vertexBindingDivisorCount_ } - , pVertexBindingDivisors{ pVertexBindingDivisors_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineVertexInputDivisorStateCreateInfo( PipelineVertexInputDivisorStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineVertexInputDivisorStateCreateInfo( VkPipelineVertexInputDivisorStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineVertexInputDivisorStateCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineVertexInputDivisorStateCreateInfo( ArrayProxyNoTemporaries const & vertexBindingDivisors_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , vertexBindingDivisorCount( static_cast( vertexBindingDivisors_.size() ) ) - , pVertexBindingDivisors( vertexBindingDivisors_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineVertexInputDivisorStateCreateInfo & operator=( PipelineVertexInputDivisorStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineVertexInputDivisorStateCreateInfo & operator=( VkPipelineVertexInputDivisorStateCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo & setVertexBindingDivisorCount( uint32_t vertexBindingDivisorCount_ ) & - VULKAN_HPP_NOEXCEPT - { - vertexBindingDivisorCount = vertexBindingDivisorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo && setVertexBindingDivisorCount( uint32_t vertexBindingDivisorCount_ ) && - VULKAN_HPP_NOEXCEPT - { - vertexBindingDivisorCount = vertexBindingDivisorCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo & - setPVertexBindingDivisors( const VertexInputBindingDivisorDescription * pVertexBindingDivisors_ ) & - VULKAN_HPP_NOEXCEPT - { - pVertexBindingDivisors = pVertexBindingDivisors_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineVertexInputDivisorStateCreateInfo && - setPVertexBindingDivisors( const VertexInputBindingDivisorDescription * pVertexBindingDivisors_ ) && - VULKAN_HPP_NOEXCEPT - { - pVertexBindingDivisors = pVertexBindingDivisors_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineVertexInputDivisorStateCreateInfo & - setVertexBindingDivisors( ArrayProxyNoTemporaries const & vertexBindingDivisors_ ) VULKAN_HPP_NOEXCEPT - { - vertexBindingDivisorCount = static_cast( vertexBindingDivisors_.size() ); - pVertexBindingDivisors = vertexBindingDivisors_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineVertexInputDivisorStateCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineVertexInputDivisorStateCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineVertexInputDivisorStateCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineVertexInputDivisorStateCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, vertexBindingDivisorCount, pVertexBindingDivisors ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineVertexInputDivisorStateCreateInfo const & ) const = default; -#else - bool operator==( PipelineVertexInputDivisorStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( vertexBindingDivisorCount == rhs.vertexBindingDivisorCount ) && - ( pVertexBindingDivisors == rhs.pVertexBindingDivisors ); -# endif - } - - bool operator!=( PipelineVertexInputDivisorStateCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineVertexInputDivisorStateCreateInfo; - const void * pNext = {}; - uint32_t vertexBindingDivisorCount = {}; - const VertexInputBindingDivisorDescription * pVertexBindingDivisors = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineVertexInputDivisorStateCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineVertexInputDivisorStateCreateInfo; - }; - - using PipelineVertexInputDivisorStateCreateInfoEXT = PipelineVertexInputDivisorStateCreateInfo; - using PipelineVertexInputDivisorStateCreateInfoKHR = PipelineVertexInputDivisorStateCreateInfo; - - // wrapper struct for struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.html - struct PipelineViewportCoarseSampleOrderStateCreateInfoNV - { - using NativeType = VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineViewportCoarseSampleOrderStateCreateInfoNV( CoarseSampleOrderTypeNV sampleOrderType_ = CoarseSampleOrderTypeNV::eDefault, - uint32_t customSampleOrderCount_ = {}, - const CoarseSampleOrderCustomNV * pCustomSampleOrders_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , sampleOrderType{ sampleOrderType_ } - , customSampleOrderCount{ customSampleOrderCount_ } - , pCustomSampleOrders{ pCustomSampleOrders_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineViewportCoarseSampleOrderStateCreateInfoNV( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineViewportCoarseSampleOrderStateCreateInfoNV( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineViewportCoarseSampleOrderStateCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportCoarseSampleOrderStateCreateInfoNV( CoarseSampleOrderTypeNV sampleOrderType_, - ArrayProxyNoTemporaries const & customSampleOrders_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , sampleOrderType( sampleOrderType_ ) - , customSampleOrderCount( static_cast( customSampleOrders_.size() ) ) - , pCustomSampleOrders( customSampleOrders_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineViewportCoarseSampleOrderStateCreateInfoNV & - operator=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineViewportCoarseSampleOrderStateCreateInfoNV & operator=( VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV & setSampleOrderType( CoarseSampleOrderTypeNV sampleOrderType_ ) & - VULKAN_HPP_NOEXCEPT - { - sampleOrderType = sampleOrderType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV && setSampleOrderType( CoarseSampleOrderTypeNV sampleOrderType_ ) && - VULKAN_HPP_NOEXCEPT - { - sampleOrderType = sampleOrderType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV & setCustomSampleOrderCount( uint32_t customSampleOrderCount_ ) & - VULKAN_HPP_NOEXCEPT - { - customSampleOrderCount = customSampleOrderCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV && setCustomSampleOrderCount( uint32_t customSampleOrderCount_ ) && - VULKAN_HPP_NOEXCEPT - { - customSampleOrderCount = customSampleOrderCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV & - setPCustomSampleOrders( const CoarseSampleOrderCustomNV * pCustomSampleOrders_ ) & - VULKAN_HPP_NOEXCEPT - { - pCustomSampleOrders = pCustomSampleOrders_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportCoarseSampleOrderStateCreateInfoNV && - setPCustomSampleOrders( const CoarseSampleOrderCustomNV * pCustomSampleOrders_ ) && - VULKAN_HPP_NOEXCEPT - { - pCustomSampleOrders = pCustomSampleOrders_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportCoarseSampleOrderStateCreateInfoNV & - setCustomSampleOrders( ArrayProxyNoTemporaries const & customSampleOrders_ ) VULKAN_HPP_NOEXCEPT - { - customSampleOrderCount = static_cast( customSampleOrders_.size() ); - pCustomSampleOrders = customSampleOrders_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, sampleOrderType, customSampleOrderCount, pCustomSampleOrders ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & ) const = default; -#else - bool operator==( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampleOrderType == rhs.sampleOrderType ) && - ( customSampleOrderCount == rhs.customSampleOrderCount ) && ( pCustomSampleOrders == rhs.pCustomSampleOrders ); -# endif - } - - bool operator!=( PipelineViewportCoarseSampleOrderStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV; - const void * pNext = {}; - CoarseSampleOrderTypeNV sampleOrderType = CoarseSampleOrderTypeNV::eDefault; - uint32_t customSampleOrderCount = {}; - const CoarseSampleOrderCustomNV * pCustomSampleOrders = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineViewportCoarseSampleOrderStateCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineViewportCoarseSampleOrderStateCreateInfoNV; - }; - - // wrapper struct for struct VkPipelineViewportDepthClampControlCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportDepthClampControlCreateInfoEXT.html - struct PipelineViewportDepthClampControlCreateInfoEXT - { - using NativeType = VkPipelineViewportDepthClampControlCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportDepthClampControlCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineViewportDepthClampControlCreateInfoEXT( DepthClampModeEXT depthClampMode_ = DepthClampModeEXT::eViewportRange, - const DepthClampRangeEXT * pDepthClampRange_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , depthClampMode{ depthClampMode_ } - , pDepthClampRange{ pDepthClampRange_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineViewportDepthClampControlCreateInfoEXT( PipelineViewportDepthClampControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineViewportDepthClampControlCreateInfoEXT( VkPipelineViewportDepthClampControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineViewportDepthClampControlCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - PipelineViewportDepthClampControlCreateInfoEXT & operator=( PipelineViewportDepthClampControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineViewportDepthClampControlCreateInfoEXT & operator=( VkPipelineViewportDepthClampControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT & setDepthClampMode( DepthClampModeEXT depthClampMode_ ) & VULKAN_HPP_NOEXCEPT - { - depthClampMode = depthClampMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT && setDepthClampMode( DepthClampModeEXT depthClampMode_ ) && VULKAN_HPP_NOEXCEPT - { - depthClampMode = depthClampMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT & setPDepthClampRange( const DepthClampRangeEXT * pDepthClampRange_ ) & - VULKAN_HPP_NOEXCEPT - { - pDepthClampRange = pDepthClampRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClampControlCreateInfoEXT && setPDepthClampRange( const DepthClampRangeEXT * pDepthClampRange_ ) && - VULKAN_HPP_NOEXCEPT - { - pDepthClampRange = pDepthClampRange_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineViewportDepthClampControlCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportDepthClampControlCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportDepthClampControlCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineViewportDepthClampControlCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, depthClampMode, pDepthClampRange ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineViewportDepthClampControlCreateInfoEXT const & ) const = default; -#else - bool operator==( PipelineViewportDepthClampControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthClampMode == rhs.depthClampMode ) && ( pDepthClampRange == rhs.pDepthClampRange ); -# endif - } - - bool operator!=( PipelineViewportDepthClampControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineViewportDepthClampControlCreateInfoEXT; - const void * pNext = {}; - DepthClampModeEXT depthClampMode = DepthClampModeEXT::eViewportRange; - const DepthClampRangeEXT * pDepthClampRange = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineViewportDepthClampControlCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineViewportDepthClampControlCreateInfoEXT; - }; - - // wrapper struct for struct VkPipelineViewportDepthClipControlCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportDepthClipControlCreateInfoEXT.html - struct PipelineViewportDepthClipControlCreateInfoEXT - { - using NativeType = VkPipelineViewportDepthClipControlCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportDepthClipControlCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineViewportDepthClipControlCreateInfoEXT( Bool32 negativeOneToOne_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , negativeOneToOne{ negativeOneToOne_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineViewportDepthClipControlCreateInfoEXT( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineViewportDepthClipControlCreateInfoEXT( VkPipelineViewportDepthClipControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineViewportDepthClipControlCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - PipelineViewportDepthClipControlCreateInfoEXT & operator=( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineViewportDepthClipControlCreateInfoEXT & operator=( VkPipelineViewportDepthClipControlCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClipControlCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClipControlCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClipControlCreateInfoEXT & setNegativeOneToOne( Bool32 negativeOneToOne_ ) & VULKAN_HPP_NOEXCEPT - { - negativeOneToOne = negativeOneToOne_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportDepthClipControlCreateInfoEXT && setNegativeOneToOne( Bool32 negativeOneToOne_ ) && VULKAN_HPP_NOEXCEPT - { - negativeOneToOne = negativeOneToOne_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineViewportDepthClipControlCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportDepthClipControlCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportDepthClipControlCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineViewportDepthClipControlCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, negativeOneToOne ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineViewportDepthClipControlCreateInfoEXT const & ) const = default; -#else - bool operator==( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( negativeOneToOne == rhs.negativeOneToOne ); -# endif - } - - bool operator!=( PipelineViewportDepthClipControlCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineViewportDepthClipControlCreateInfoEXT; - const void * pNext = {}; - Bool32 negativeOneToOne = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineViewportDepthClipControlCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineViewportDepthClipControlCreateInfoEXT; - }; - - // wrapper struct for struct VkPipelineViewportExclusiveScissorStateCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportExclusiveScissorStateCreateInfoNV.html - struct PipelineViewportExclusiveScissorStateCreateInfoNV - { - using NativeType = VkPipelineViewportExclusiveScissorStateCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineViewportExclusiveScissorStateCreateInfoNV( uint32_t exclusiveScissorCount_ = {}, - const Rect2D * pExclusiveScissors_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , exclusiveScissorCount{ exclusiveScissorCount_ } - , pExclusiveScissors{ pExclusiveScissors_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineViewportExclusiveScissorStateCreateInfoNV( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineViewportExclusiveScissorStateCreateInfoNV( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineViewportExclusiveScissorStateCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportExclusiveScissorStateCreateInfoNV( ArrayProxyNoTemporaries const & exclusiveScissors_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), exclusiveScissorCount( static_cast( exclusiveScissors_.size() ) ), pExclusiveScissors( exclusiveScissors_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineViewportExclusiveScissorStateCreateInfoNV & - operator=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineViewportExclusiveScissorStateCreateInfoNV & operator=( VkPipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV & setExclusiveScissorCount( uint32_t exclusiveScissorCount_ ) & - VULKAN_HPP_NOEXCEPT - { - exclusiveScissorCount = exclusiveScissorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV && setExclusiveScissorCount( uint32_t exclusiveScissorCount_ ) && - VULKAN_HPP_NOEXCEPT - { - exclusiveScissorCount = exclusiveScissorCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV & setPExclusiveScissors( const Rect2D * pExclusiveScissors_ ) & - VULKAN_HPP_NOEXCEPT - { - pExclusiveScissors = pExclusiveScissors_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportExclusiveScissorStateCreateInfoNV && setPExclusiveScissors( const Rect2D * pExclusiveScissors_ ) && - VULKAN_HPP_NOEXCEPT - { - pExclusiveScissors = pExclusiveScissors_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportExclusiveScissorStateCreateInfoNV & - setExclusiveScissors( ArrayProxyNoTemporaries const & exclusiveScissors_ ) VULKAN_HPP_NOEXCEPT - { - exclusiveScissorCount = static_cast( exclusiveScissors_.size() ); - pExclusiveScissors = exclusiveScissors_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportExclusiveScissorStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportExclusiveScissorStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineViewportExclusiveScissorStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, exclusiveScissorCount, pExclusiveScissors ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineViewportExclusiveScissorStateCreateInfoNV const & ) const = default; -#else - bool operator==( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( exclusiveScissorCount == rhs.exclusiveScissorCount ) && - ( pExclusiveScissors == rhs.pExclusiveScissors ); -# endif - } - - bool operator!=( PipelineViewportExclusiveScissorStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV; - const void * pNext = {}; - uint32_t exclusiveScissorCount = {}; - const Rect2D * pExclusiveScissors = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineViewportExclusiveScissorStateCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineViewportExclusiveScissorStateCreateInfoNV; - }; - - // wrapper struct for struct VkShadingRatePaletteNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShadingRatePaletteNV.html - struct ShadingRatePaletteNV - { - using NativeType = VkShadingRatePaletteNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ShadingRatePaletteNV( uint32_t shadingRatePaletteEntryCount_ = {}, - const ShadingRatePaletteEntryNV * pShadingRatePaletteEntries_ = {} ) VULKAN_HPP_NOEXCEPT - : shadingRatePaletteEntryCount{ shadingRatePaletteEntryCount_ } - , pShadingRatePaletteEntries{ pShadingRatePaletteEntries_ } - { - } - - VULKAN_HPP_CONSTEXPR ShadingRatePaletteNV( ShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ShadingRatePaletteNV( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT - : ShadingRatePaletteNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ShadingRatePaletteNV( ArrayProxyNoTemporaries const & shadingRatePaletteEntries_ ) - : shadingRatePaletteEntryCount( static_cast( shadingRatePaletteEntries_.size() ) ) - , pShadingRatePaletteEntries( shadingRatePaletteEntries_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ShadingRatePaletteNV & operator=( ShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ShadingRatePaletteNV & operator=( VkShadingRatePaletteNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ShadingRatePaletteNV & setShadingRatePaletteEntryCount( uint32_t shadingRatePaletteEntryCount_ ) & VULKAN_HPP_NOEXCEPT - { - shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShadingRatePaletteNV && setShadingRatePaletteEntryCount( uint32_t shadingRatePaletteEntryCount_ ) && VULKAN_HPP_NOEXCEPT - { - shadingRatePaletteEntryCount = shadingRatePaletteEntryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShadingRatePaletteNV & setPShadingRatePaletteEntries( const ShadingRatePaletteEntryNV * pShadingRatePaletteEntries_ ) & - VULKAN_HPP_NOEXCEPT - { - pShadingRatePaletteEntries = pShadingRatePaletteEntries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShadingRatePaletteNV && setPShadingRatePaletteEntries( const ShadingRatePaletteEntryNV * pShadingRatePaletteEntries_ ) && - VULKAN_HPP_NOEXCEPT - { - pShadingRatePaletteEntries = pShadingRatePaletteEntries_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ShadingRatePaletteNV & - setShadingRatePaletteEntries( ArrayProxyNoTemporaries const & shadingRatePaletteEntries_ ) VULKAN_HPP_NOEXCEPT - { - shadingRatePaletteEntryCount = static_cast( shadingRatePaletteEntries_.size() ); - pShadingRatePaletteEntries = shadingRatePaletteEntries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkShadingRatePaletteNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShadingRatePaletteNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShadingRatePaletteNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkShadingRatePaletteNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( shadingRatePaletteEntryCount, pShadingRatePaletteEntries ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ShadingRatePaletteNV const & ) const = default; -#else - bool operator==( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( shadingRatePaletteEntryCount == rhs.shadingRatePaletteEntryCount ) && ( pShadingRatePaletteEntries == rhs.pShadingRatePaletteEntries ); -# endif - } - - bool operator!=( ShadingRatePaletteNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t shadingRatePaletteEntryCount = {}; - const ShadingRatePaletteEntryNV * pShadingRatePaletteEntries = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ShadingRatePaletteNV; - }; -#endif - - // wrapper struct for struct VkPipelineViewportShadingRateImageStateCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportShadingRateImageStateCreateInfoNV.html - struct PipelineViewportShadingRateImageStateCreateInfoNV - { - using NativeType = VkPipelineViewportShadingRateImageStateCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineViewportShadingRateImageStateCreateInfoNV( Bool32 shadingRateImageEnable_ = {}, - uint32_t viewportCount_ = {}, - const ShadingRatePaletteNV * pShadingRatePalettes_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , shadingRateImageEnable{ shadingRateImageEnable_ } - , viewportCount{ viewportCount_ } - , pShadingRatePalettes{ pShadingRatePalettes_ } - { - } - - VULKAN_HPP_CONSTEXPR - PipelineViewportShadingRateImageStateCreateInfoNV( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineViewportShadingRateImageStateCreateInfoNV( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineViewportShadingRateImageStateCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportShadingRateImageStateCreateInfoNV( Bool32 shadingRateImageEnable_, - ArrayProxyNoTemporaries const & shadingRatePalettes_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , shadingRateImageEnable( shadingRateImageEnable_ ) - , viewportCount( static_cast( shadingRatePalettes_.size() ) ) - , pShadingRatePalettes( shadingRatePalettes_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineViewportShadingRateImageStateCreateInfoNV & - operator=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineViewportShadingRateImageStateCreateInfoNV & operator=( VkPipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV & setShadingRateImageEnable( Bool32 shadingRateImageEnable_ ) & - VULKAN_HPP_NOEXCEPT - { - shadingRateImageEnable = shadingRateImageEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV && setShadingRateImageEnable( Bool32 shadingRateImageEnable_ ) && - VULKAN_HPP_NOEXCEPT - { - shadingRateImageEnable = shadingRateImageEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV & setViewportCount( uint32_t viewportCount_ ) & VULKAN_HPP_NOEXCEPT - { - viewportCount = viewportCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV && setViewportCount( uint32_t viewportCount_ ) && VULKAN_HPP_NOEXCEPT - { - viewportCount = viewportCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV & setPShadingRatePalettes( const ShadingRatePaletteNV * pShadingRatePalettes_ ) & - VULKAN_HPP_NOEXCEPT - { - pShadingRatePalettes = pShadingRatePalettes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportShadingRateImageStateCreateInfoNV && - setPShadingRatePalettes( const ShadingRatePaletteNV * pShadingRatePalettes_ ) && - VULKAN_HPP_NOEXCEPT - { - pShadingRatePalettes = pShadingRatePalettes_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportShadingRateImageStateCreateInfoNV & - setShadingRatePalettes( ArrayProxyNoTemporaries const & shadingRatePalettes_ ) VULKAN_HPP_NOEXCEPT - { - viewportCount = static_cast( shadingRatePalettes_.size() ); - pShadingRatePalettes = shadingRatePalettes_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineViewportShadingRateImageStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportShadingRateImageStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportShadingRateImageStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineViewportShadingRateImageStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, shadingRateImageEnable, viewportCount, pShadingRatePalettes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineViewportShadingRateImageStateCreateInfoNV const & ) const = default; -#else - bool operator==( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( shadingRateImageEnable == rhs.shadingRateImageEnable ) && - ( viewportCount == rhs.viewportCount ) && ( pShadingRatePalettes == rhs.pShadingRatePalettes ); -# endif - } - - bool operator!=( PipelineViewportShadingRateImageStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV; - const void * pNext = {}; - Bool32 shadingRateImageEnable = {}; - uint32_t viewportCount = {}; - const ShadingRatePaletteNV * pShadingRatePalettes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineViewportShadingRateImageStateCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineViewportShadingRateImageStateCreateInfoNV; - }; - - // wrapper struct for struct VkViewportSwizzleNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViewportSwizzleNV.html - struct ViewportSwizzleNV - { - using NativeType = VkViewportSwizzleNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ViewportSwizzleNV( ViewportCoordinateSwizzleNV x_ = ViewportCoordinateSwizzleNV::ePositiveX, - ViewportCoordinateSwizzleNV y_ = ViewportCoordinateSwizzleNV::ePositiveX, - ViewportCoordinateSwizzleNV z_ = ViewportCoordinateSwizzleNV::ePositiveX, - ViewportCoordinateSwizzleNV w_ = ViewportCoordinateSwizzleNV::ePositiveX ) VULKAN_HPP_NOEXCEPT - : x{ x_ } - , y{ y_ } - , z{ z_ } - , w{ w_ } - { - } - - VULKAN_HPP_CONSTEXPR ViewportSwizzleNV( ViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ViewportSwizzleNV( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT : ViewportSwizzleNV( *reinterpret_cast( &rhs ) ) {} - - ViewportSwizzleNV & operator=( ViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ViewportSwizzleNV & operator=( VkViewportSwizzleNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV & setX( ViewportCoordinateSwizzleNV x_ ) & VULKAN_HPP_NOEXCEPT - { - x = x_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV && setX( ViewportCoordinateSwizzleNV x_ ) && VULKAN_HPP_NOEXCEPT - { - x = x_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV & setY( ViewportCoordinateSwizzleNV y_ ) & VULKAN_HPP_NOEXCEPT - { - y = y_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV && setY( ViewportCoordinateSwizzleNV y_ ) && VULKAN_HPP_NOEXCEPT - { - y = y_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV & setZ( ViewportCoordinateSwizzleNV z_ ) & VULKAN_HPP_NOEXCEPT - { - z = z_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV && setZ( ViewportCoordinateSwizzleNV z_ ) && VULKAN_HPP_NOEXCEPT - { - z = z_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV & setW( ViewportCoordinateSwizzleNV w_ ) & VULKAN_HPP_NOEXCEPT - { - w = w_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ViewportSwizzleNV && setW( ViewportCoordinateSwizzleNV w_ ) && VULKAN_HPP_NOEXCEPT - { - w = w_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkViewportSwizzleNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkViewportSwizzleNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkViewportSwizzleNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkViewportSwizzleNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( x, y, z, w ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ViewportSwizzleNV const & ) const = default; -#else - bool operator==( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( x == rhs.x ) && ( y == rhs.y ) && ( z == rhs.z ) && ( w == rhs.w ); -# endif - } - - bool operator!=( ViewportSwizzleNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ViewportCoordinateSwizzleNV x = ViewportCoordinateSwizzleNV::ePositiveX; - ViewportCoordinateSwizzleNV y = ViewportCoordinateSwizzleNV::ePositiveX; - ViewportCoordinateSwizzleNV z = ViewportCoordinateSwizzleNV::ePositiveX; - ViewportCoordinateSwizzleNV w = ViewportCoordinateSwizzleNV::ePositiveX; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ViewportSwizzleNV; - }; -#endif - - // wrapper struct for struct VkPipelineViewportSwizzleStateCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportSwizzleStateCreateInfoNV.html - struct PipelineViewportSwizzleStateCreateInfoNV - { - using NativeType = VkPipelineViewportSwizzleStateCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_ = {}, - uint32_t viewportCount_ = {}, - const ViewportSwizzleNV * pViewportSwizzles_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , viewportCount{ viewportCount_ } - , pViewportSwizzles{ pViewportSwizzles_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineViewportSwizzleStateCreateInfoNV( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineViewportSwizzleStateCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportSwizzleStateCreateInfoNV( PipelineViewportSwizzleStateCreateFlagsNV flags_, - ArrayProxyNoTemporaries const & viewportSwizzles_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), flags( flags_ ), viewportCount( static_cast( viewportSwizzles_.size() ) ), pViewportSwizzles( viewportSwizzles_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineViewportSwizzleStateCreateInfoNV & operator=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineViewportSwizzleStateCreateInfoNV & operator=( VkPipelineViewportSwizzleStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV & setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV && setFlags( PipelineViewportSwizzleStateCreateFlagsNV flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV & setViewportCount( uint32_t viewportCount_ ) & VULKAN_HPP_NOEXCEPT - { - viewportCount = viewportCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV && setViewportCount( uint32_t viewportCount_ ) && VULKAN_HPP_NOEXCEPT - { - viewportCount = viewportCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV & setPViewportSwizzles( const ViewportSwizzleNV * pViewportSwizzles_ ) & - VULKAN_HPP_NOEXCEPT - { - pViewportSwizzles = pViewportSwizzles_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportSwizzleStateCreateInfoNV && setPViewportSwizzles( const ViewportSwizzleNV * pViewportSwizzles_ ) && - VULKAN_HPP_NOEXCEPT - { - pViewportSwizzles = pViewportSwizzles_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportSwizzleStateCreateInfoNV & - setViewportSwizzles( ArrayProxyNoTemporaries const & viewportSwizzles_ ) VULKAN_HPP_NOEXCEPT - { - viewportCount = static_cast( viewportSwizzles_.size() ); - pViewportSwizzles = viewportSwizzles_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineViewportSwizzleStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportSwizzleStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportSwizzleStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineViewportSwizzleStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, viewportCount, pViewportSwizzles ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineViewportSwizzleStateCreateInfoNV const & ) const = default; -#else - bool operator==( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( viewportCount == rhs.viewportCount ) && - ( pViewportSwizzles == rhs.pViewportSwizzles ); -# endif - } - - bool operator!=( PipelineViewportSwizzleStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineViewportSwizzleStateCreateInfoNV; - const void * pNext = {}; - PipelineViewportSwizzleStateCreateFlagsNV flags = {}; - uint32_t viewportCount = {}; - const ViewportSwizzleNV * pViewportSwizzles = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineViewportSwizzleStateCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineViewportSwizzleStateCreateInfoNV; - }; - - // wrapper struct for struct VkViewportWScalingNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViewportWScalingNV.html - struct ViewportWScalingNV - { - using NativeType = VkViewportWScalingNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ViewportWScalingNV( float xcoeff_ = {}, float ycoeff_ = {} ) VULKAN_HPP_NOEXCEPT - : xcoeff{ xcoeff_ } - , ycoeff{ ycoeff_ } - { - } - - VULKAN_HPP_CONSTEXPR ViewportWScalingNV( ViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ViewportWScalingNV( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT : ViewportWScalingNV( *reinterpret_cast( &rhs ) ) {} - - ViewportWScalingNV & operator=( ViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ViewportWScalingNV & operator=( VkViewportWScalingNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ViewportWScalingNV & setXcoeff( float xcoeff_ ) & VULKAN_HPP_NOEXCEPT - { - xcoeff = xcoeff_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ViewportWScalingNV && setXcoeff( float xcoeff_ ) && VULKAN_HPP_NOEXCEPT - { - xcoeff = xcoeff_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ViewportWScalingNV & setYcoeff( float ycoeff_ ) & VULKAN_HPP_NOEXCEPT - { - ycoeff = ycoeff_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ViewportWScalingNV && setYcoeff( float ycoeff_ ) && VULKAN_HPP_NOEXCEPT - { - ycoeff = ycoeff_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkViewportWScalingNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkViewportWScalingNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkViewportWScalingNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkViewportWScalingNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( xcoeff, ycoeff ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ViewportWScalingNV const & ) const = default; -#else - bool operator==( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( xcoeff == rhs.xcoeff ) && ( ycoeff == rhs.ycoeff ); -# endif - } - - bool operator!=( ViewportWScalingNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - float xcoeff = {}; - float ycoeff = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ViewportWScalingNV; - }; -#endif - - // wrapper struct for struct VkPipelineViewportWScalingStateCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPipelineViewportWScalingStateCreateInfoNV.html - struct PipelineViewportWScalingStateCreateInfoNV - { - using NativeType = VkPipelineViewportWScalingStateCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_ = {}, - uint32_t viewportCount_ = {}, - const ViewportWScalingNV * pViewportWScalings_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , viewportWScalingEnable{ viewportWScalingEnable_ } - , viewportCount{ viewportCount_ } - , pViewportWScalings{ pViewportWScalings_ } - { - } - - VULKAN_HPP_CONSTEXPR PipelineViewportWScalingStateCreateInfoNV( PipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PipelineViewportWScalingStateCreateInfoNV( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PipelineViewportWScalingStateCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportWScalingStateCreateInfoNV( Bool32 viewportWScalingEnable_, - ArrayProxyNoTemporaries const & viewportWScalings_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , viewportWScalingEnable( viewportWScalingEnable_ ) - , viewportCount( static_cast( viewportWScalings_.size() ) ) - , pViewportWScalings( viewportWScalings_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PipelineViewportWScalingStateCreateInfoNV & operator=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PipelineViewportWScalingStateCreateInfoNV & operator=( VkPipelineViewportWScalingStateCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV & setViewportWScalingEnable( Bool32 viewportWScalingEnable_ ) & VULKAN_HPP_NOEXCEPT - { - viewportWScalingEnable = viewportWScalingEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV && setViewportWScalingEnable( Bool32 viewportWScalingEnable_ ) && VULKAN_HPP_NOEXCEPT - { - viewportWScalingEnable = viewportWScalingEnable_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV & setViewportCount( uint32_t viewportCount_ ) & VULKAN_HPP_NOEXCEPT - { - viewportCount = viewportCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV && setViewportCount( uint32_t viewportCount_ ) && VULKAN_HPP_NOEXCEPT - { - viewportCount = viewportCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV & setPViewportWScalings( const ViewportWScalingNV * pViewportWScalings_ ) & - VULKAN_HPP_NOEXCEPT - { - pViewportWScalings = pViewportWScalings_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PipelineViewportWScalingStateCreateInfoNV && setPViewportWScalings( const ViewportWScalingNV * pViewportWScalings_ ) && - VULKAN_HPP_NOEXCEPT - { - pViewportWScalings = pViewportWScalings_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PipelineViewportWScalingStateCreateInfoNV & - setViewportWScalings( ArrayProxyNoTemporaries const & viewportWScalings_ ) VULKAN_HPP_NOEXCEPT - { - viewportCount = static_cast( viewportWScalings_.size() ); - pViewportWScalings = viewportWScalings_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPipelineViewportWScalingStateCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportWScalingStateCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPipelineViewportWScalingStateCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPipelineViewportWScalingStateCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, viewportWScalingEnable, viewportCount, pViewportWScalings ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PipelineViewportWScalingStateCreateInfoNV const & ) const = default; -#else - bool operator==( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewportWScalingEnable == rhs.viewportWScalingEnable ) && - ( viewportCount == rhs.viewportCount ) && ( pViewportWScalings == rhs.pViewportWScalings ); -# endif - } - - bool operator!=( PipelineViewportWScalingStateCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePipelineViewportWScalingStateCreateInfoNV; - const void * pNext = {}; - Bool32 viewportWScalingEnable = {}; - uint32_t viewportCount = {}; - const ViewportWScalingNV * pViewportWScalings = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PipelineViewportWScalingStateCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PipelineViewportWScalingStateCreateInfoNV; - }; - -#if defined( VK_USE_PLATFORM_GGP ) - // wrapper struct for struct VkPresentFrameTokenGGP, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentFrameTokenGGP.html - struct PresentFrameTokenGGP - { - using NativeType = VkPresentFrameTokenGGP; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentFrameTokenGGP; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( GgpFrameToken frameToken_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , frameToken{ frameToken_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentFrameTokenGGP( PresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentFrameTokenGGP( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT - : PresentFrameTokenGGP( *reinterpret_cast( &rhs ) ) - { - } - - PresentFrameTokenGGP & operator=( PresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentFrameTokenGGP & operator=( VkPresentFrameTokenGGP const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PresentFrameTokenGGP & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentFrameTokenGGP && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentFrameTokenGGP & setFrameToken( GgpFrameToken frameToken_ ) & VULKAN_HPP_NOEXCEPT - { - frameToken = frameToken_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentFrameTokenGGP && setFrameToken( GgpFrameToken frameToken_ ) && VULKAN_HPP_NOEXCEPT - { - frameToken = frameToken_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPresentFrameTokenGGP const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentFrameTokenGGP &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentFrameTokenGGP const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentFrameTokenGGP *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, frameToken ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &frameToken, &rhs.frameToken, sizeof( GgpFrameToken ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -# endif - - bool operator==( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &frameToken, &rhs.frameToken, sizeof( GgpFrameToken ) ) == 0 ); - } - - bool operator!=( PresentFrameTokenGGP const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::ePresentFrameTokenGGP; - const void * pNext = {}; - GgpFrameToken frameToken = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentFrameTokenGGP; - }; -# endif - - template <> - struct CppType - { - using Type = PresentFrameTokenGGP; - }; -#endif /*VK_USE_PLATFORM_GGP*/ - - // wrapper struct for struct VkPresentId2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentId2KHR.html - struct PresentId2KHR - { - using NativeType = VkPresentId2KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentId2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PresentId2KHR( uint32_t swapchainCount_ = {}, const uint64_t * pPresentIds_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchainCount{ swapchainCount_ } - , pPresentIds{ pPresentIds_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentId2KHR( PresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentId2KHR( VkPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentId2KHR( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentId2KHR( ArrayProxyNoTemporaries const & presentIds_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), swapchainCount( static_cast( presentIds_.size() ) ), pPresentIds( presentIds_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PresentId2KHR & operator=( PresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentId2KHR & operator=( VkPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PresentId2KHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentId2KHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentId2KHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentId2KHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentId2KHR & setPPresentIds( const uint64_t * pPresentIds_ ) & VULKAN_HPP_NOEXCEPT - { - pPresentIds = pPresentIds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentId2KHR && setPPresentIds( const uint64_t * pPresentIds_ ) && VULKAN_HPP_NOEXCEPT - { - pPresentIds = pPresentIds_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentId2KHR & setPresentIds( ArrayProxyNoTemporaries const & presentIds_ ) VULKAN_HPP_NOEXCEPT - { - swapchainCount = static_cast( presentIds_.size() ); - pPresentIds = presentIds_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPresentId2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentId2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentId2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentId2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchainCount, pPresentIds ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentId2KHR const & ) const = default; -#else - bool operator==( PresentId2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pPresentIds == rhs.pPresentIds ); -# endif - } - - bool operator!=( PresentId2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePresentId2KHR; - const void * pNext = {}; - uint32_t swapchainCount = {}; - const uint64_t * pPresentIds = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentId2KHR; - }; -#endif - - template <> - struct CppType - { - using Type = PresentId2KHR; - }; - - // wrapper struct for struct VkPresentIdKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentIdKHR.html - struct PresentIdKHR - { - using NativeType = VkPresentIdKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentIdKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PresentIdKHR( uint32_t swapchainCount_ = {}, const uint64_t * pPresentIds_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchainCount{ swapchainCount_ } - , pPresentIds{ pPresentIds_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentIdKHR( PresentIdKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentIdKHR( VkPresentIdKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentIdKHR( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentIdKHR( ArrayProxyNoTemporaries const & presentIds_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), swapchainCount( static_cast( presentIds_.size() ) ), pPresentIds( presentIds_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PresentIdKHR & operator=( PresentIdKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentIdKHR & operator=( VkPresentIdKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PresentIdKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentIdKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentIdKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentIdKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentIdKHR & setPPresentIds( const uint64_t * pPresentIds_ ) & VULKAN_HPP_NOEXCEPT - { - pPresentIds = pPresentIds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentIdKHR && setPPresentIds( const uint64_t * pPresentIds_ ) && VULKAN_HPP_NOEXCEPT - { - pPresentIds = pPresentIds_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentIdKHR & setPresentIds( ArrayProxyNoTemporaries const & presentIds_ ) VULKAN_HPP_NOEXCEPT - { - swapchainCount = static_cast( presentIds_.size() ); - pPresentIds = presentIds_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPresentIdKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentIdKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentIdKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentIdKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchainCount, pPresentIds ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentIdKHR const & ) const = default; -#else - bool operator==( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pPresentIds == rhs.pPresentIds ); -# endif - } - - bool operator!=( PresentIdKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePresentIdKHR; - const void * pNext = {}; - uint32_t swapchainCount = {}; - const uint64_t * pPresentIds = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentIdKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PresentIdKHR; - }; - - // wrapper struct for struct VkPresentInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentInfoKHR.html - struct PresentInfoKHR - { - using NativeType = VkPresentInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PresentInfoKHR( uint32_t waitSemaphoreCount_ = {}, - const Semaphore * pWaitSemaphores_ = {}, - uint32_t swapchainCount_ = {}, - const SwapchainKHR * pSwapchains_ = {}, - const uint32_t * pImageIndices_ = {}, - Result * pResults_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , waitSemaphoreCount{ waitSemaphoreCount_ } - , pWaitSemaphores{ pWaitSemaphores_ } - , swapchainCount{ swapchainCount_ } - , pSwapchains{ pSwapchains_ } - , pImageIndices{ pImageIndices_ } - , pResults{ pResults_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentInfoKHR( PresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentInfoKHR( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentInfoKHR( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentInfoKHR( ArrayProxyNoTemporaries const & waitSemaphores_, - ArrayProxyNoTemporaries const & swapchains_ = {}, - ArrayProxyNoTemporaries const & imageIndices_ = {}, - ArrayProxyNoTemporaries const & results_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , waitSemaphoreCount( static_cast( waitSemaphores_.size() ) ) - , pWaitSemaphores( waitSemaphores_.data() ) - , swapchainCount( static_cast( swapchains_.size() ) ) - , pSwapchains( swapchains_.data() ) - , pImageIndices( imageIndices_.data() ) - , pResults( results_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( swapchains_.size() == imageIndices_.size() ); - VULKAN_HPP_ASSERT( results_.empty() || ( swapchains_.size() == results_.size() ) ); - VULKAN_HPP_ASSERT( results_.empty() || ( imageIndices_.size() == results_.size() ) ); -# else - if ( swapchains_.size() != imageIndices_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::PresentInfoKHR::PresentInfoKHR: swapchains_.size() != imageIndices_.size()" ); - } - if ( !results_.empty() && ( swapchains_.size() != results_.size() ) ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::PresentInfoKHR::PresentInfoKHR: !results_.empty() && ( swapchains_.size() != results_.size() )" ); - } - if ( !results_.empty() && ( imageIndices_.size() != results_.size() ) ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::PresentInfoKHR::PresentInfoKHR: !results_.empty() && ( imageIndices_.size() != results_.size() )" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PresentInfoKHR & operator=( PresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentInfoKHR & operator=( VkPresentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = waitSemaphoreCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) & VULKAN_HPP_NOEXCEPT - { - pWaitSemaphores = pWaitSemaphores_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) && VULKAN_HPP_NOEXCEPT - { - pWaitSemaphores = pWaitSemaphores_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentInfoKHR & setWaitSemaphores( ArrayProxyNoTemporaries const & waitSemaphores_ ) VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = static_cast( waitSemaphores_.size() ); - pWaitSemaphores = waitSemaphores_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setPSwapchains( const SwapchainKHR * pSwapchains_ ) & VULKAN_HPP_NOEXCEPT - { - pSwapchains = pSwapchains_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setPSwapchains( const SwapchainKHR * pSwapchains_ ) && VULKAN_HPP_NOEXCEPT - { - pSwapchains = pSwapchains_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentInfoKHR & setSwapchains( ArrayProxyNoTemporaries const & swapchains_ ) VULKAN_HPP_NOEXCEPT - { - swapchainCount = static_cast( swapchains_.size() ); - pSwapchains = swapchains_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setPImageIndices( const uint32_t * pImageIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pImageIndices = pImageIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setPImageIndices( const uint32_t * pImageIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pImageIndices = pImageIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentInfoKHR & setImageIndices( ArrayProxyNoTemporaries const & imageIndices_ ) VULKAN_HPP_NOEXCEPT - { - swapchainCount = static_cast( imageIndices_.size() ); - pImageIndices = imageIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR & setPResults( Result * pResults_ ) & VULKAN_HPP_NOEXCEPT - { - pResults = pResults_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentInfoKHR && setPResults( Result * pResults_ ) && VULKAN_HPP_NOEXCEPT - { - pResults = pResults_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentInfoKHR & setResults( ArrayProxyNoTemporaries const & results_ ) VULKAN_HPP_NOEXCEPT - { - swapchainCount = static_cast( results_.size() ); - pResults = results_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPresentInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, waitSemaphoreCount, pWaitSemaphores, swapchainCount, pSwapchains, pImageIndices, pResults ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentInfoKHR const & ) const = default; -#else - bool operator==( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && - ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( swapchainCount == rhs.swapchainCount ) && ( pSwapchains == rhs.pSwapchains ) && - ( pImageIndices == rhs.pImageIndices ) && ( pResults == rhs.pResults ); -# endif - } - - bool operator!=( PresentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePresentInfoKHR; - const void * pNext = {}; - uint32_t waitSemaphoreCount = {}; - const Semaphore * pWaitSemaphores = {}; - uint32_t swapchainCount = {}; - const SwapchainKHR * pSwapchains = {}; - const uint32_t * pImageIndices = {}; - Result * pResults = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PresentInfoKHR; - }; - - // wrapper struct for struct VkRectLayerKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRectLayerKHR.html - struct RectLayerKHR - { - using NativeType = VkRectLayerKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RectLayerKHR( Offset2D offset_ = {}, Extent2D extent_ = {}, uint32_t layer_ = {} ) VULKAN_HPP_NOEXCEPT - : offset{ offset_ } - , extent{ extent_ } - , layer{ layer_ } - { - } - - VULKAN_HPP_CONSTEXPR RectLayerKHR( RectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RectLayerKHR( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT : RectLayerKHR( *reinterpret_cast( &rhs ) ) {} - - explicit RectLayerKHR( Rect2D const & rect2D, uint32_t layer_ = {} ) : offset( rect2D.offset ), extent( rect2D.extent ), layer( layer_ ) {} - - RectLayerKHR & operator=( RectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RectLayerKHR & operator=( VkRectLayerKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RectLayerKHR & setOffset( Offset2D const & offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RectLayerKHR && setOffset( Offset2D const & offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RectLayerKHR & setExtent( Extent2D const & extent_ ) & VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RectLayerKHR && setExtent( Extent2D const & extent_ ) && VULKAN_HPP_NOEXCEPT - { - extent = extent_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RectLayerKHR & setLayer( uint32_t layer_ ) & VULKAN_HPP_NOEXCEPT - { - layer = layer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RectLayerKHR && setLayer( uint32_t layer_ ) && VULKAN_HPP_NOEXCEPT - { - layer = layer_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRectLayerKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRectLayerKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRectLayerKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRectLayerKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( offset, extent, layer ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RectLayerKHR const & ) const = default; -#else - bool operator==( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( offset == rhs.offset ) && ( extent == rhs.extent ) && ( layer == rhs.layer ); -# endif - } - - bool operator!=( RectLayerKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Offset2D offset = {}; - Extent2D extent = {}; - uint32_t layer = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RectLayerKHR; - }; -#endif - - // wrapper struct for struct VkPresentRegionKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentRegionKHR.html - struct PresentRegionKHR - { - using NativeType = VkPresentRegionKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PresentRegionKHR( uint32_t rectangleCount_ = {}, const RectLayerKHR * pRectangles_ = {} ) VULKAN_HPP_NOEXCEPT - : rectangleCount{ rectangleCount_ } - , pRectangles{ pRectangles_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentRegionKHR( PresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentRegionKHR( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentRegionKHR( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentRegionKHR( ArrayProxyNoTemporaries const & rectangles_ ) - : rectangleCount( static_cast( rectangles_.size() ) ), pRectangles( rectangles_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PresentRegionKHR & operator=( PresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentRegionKHR & operator=( VkPresentRegionKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PresentRegionKHR & setRectangleCount( uint32_t rectangleCount_ ) & VULKAN_HPP_NOEXCEPT - { - rectangleCount = rectangleCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentRegionKHR && setRectangleCount( uint32_t rectangleCount_ ) && VULKAN_HPP_NOEXCEPT - { - rectangleCount = rectangleCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentRegionKHR & setPRectangles( const RectLayerKHR * pRectangles_ ) & VULKAN_HPP_NOEXCEPT - { - pRectangles = pRectangles_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentRegionKHR && setPRectangles( const RectLayerKHR * pRectangles_ ) && VULKAN_HPP_NOEXCEPT - { - pRectangles = pRectangles_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentRegionKHR & setRectangles( ArrayProxyNoTemporaries const & rectangles_ ) VULKAN_HPP_NOEXCEPT - { - rectangleCount = static_cast( rectangles_.size() ); - pRectangles = rectangles_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPresentRegionKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentRegionKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentRegionKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentRegionKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( rectangleCount, pRectangles ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentRegionKHR const & ) const = default; -#else - bool operator==( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( rectangleCount == rhs.rectangleCount ) && ( pRectangles == rhs.pRectangles ); -# endif - } - - bool operator!=( PresentRegionKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t rectangleCount = {}; - const RectLayerKHR * pRectangles = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentRegionKHR; - }; -#endif - - // wrapper struct for struct VkPresentRegionsKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentRegionsKHR.html - struct PresentRegionsKHR - { - using NativeType = VkPresentRegionsKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentRegionsKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PresentRegionsKHR( uint32_t swapchainCount_ = {}, const PresentRegionKHR * pRegions_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchainCount{ swapchainCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentRegionsKHR( PresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentRegionsKHR( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentRegionsKHR( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentRegionsKHR( ArrayProxyNoTemporaries const & regions_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), swapchainCount( static_cast( regions_.size() ) ), pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PresentRegionsKHR & operator=( PresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentRegionsKHR & operator=( VkPresentRegionsKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR & setPRegions( const PresentRegionKHR * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentRegionsKHR && setPRegions( const PresentRegionKHR * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentRegionsKHR & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - swapchainCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPresentRegionsKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentRegionsKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentRegionsKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentRegionsKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchainCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentRegionsKHR const & ) const = default; -#else - bool operator==( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( PresentRegionsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePresentRegionsKHR; - const void * pNext = {}; - uint32_t swapchainCount = {}; - const PresentRegionKHR * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentRegionsKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PresentRegionsKHR; - }; - - // wrapper struct for struct VkPresentTimeGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimeGOOGLE.html - struct PresentTimeGOOGLE - { - using NativeType = VkPresentTimeGOOGLE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PresentTimeGOOGLE( uint32_t presentID_ = {}, uint64_t desiredPresentTime_ = {} ) VULKAN_HPP_NOEXCEPT - : presentID{ presentID_ } - , desiredPresentTime{ desiredPresentTime_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentTimeGOOGLE( PresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentTimeGOOGLE( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT : PresentTimeGOOGLE( *reinterpret_cast( &rhs ) ) {} - - PresentTimeGOOGLE & operator=( PresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentTimeGOOGLE & operator=( VkPresentTimeGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PresentTimeGOOGLE & setPresentID( uint32_t presentID_ ) & VULKAN_HPP_NOEXCEPT - { - presentID = presentID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimeGOOGLE && setPresentID( uint32_t presentID_ ) && VULKAN_HPP_NOEXCEPT - { - presentID = presentID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimeGOOGLE & setDesiredPresentTime( uint64_t desiredPresentTime_ ) & VULKAN_HPP_NOEXCEPT - { - desiredPresentTime = desiredPresentTime_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimeGOOGLE && setDesiredPresentTime( uint64_t desiredPresentTime_ ) && VULKAN_HPP_NOEXCEPT - { - desiredPresentTime = desiredPresentTime_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPresentTimeGOOGLE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentTimeGOOGLE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentTimeGOOGLE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentTimeGOOGLE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( presentID, desiredPresentTime ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentTimeGOOGLE const & ) const = default; -#else - bool operator==( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( presentID == rhs.presentID ) && ( desiredPresentTime == rhs.desiredPresentTime ); -# endif - } - - bool operator!=( PresentTimeGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t presentID = {}; - uint64_t desiredPresentTime = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentTimeGOOGLE; - }; -#endif - - // wrapper struct for struct VkPresentTimesInfoGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimesInfoGOOGLE.html - struct PresentTimesInfoGOOGLE - { - using NativeType = VkPresentTimesInfoGOOGLE; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimesInfoGOOGLE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PresentTimesInfoGOOGLE( uint32_t swapchainCount_ = {}, const PresentTimeGOOGLE * pTimes_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchainCount{ swapchainCount_ } - , pTimes{ pTimes_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentTimesInfoGOOGLE( PresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentTimesInfoGOOGLE( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - : PresentTimesInfoGOOGLE( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentTimesInfoGOOGLE( ArrayProxyNoTemporaries const & times_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), swapchainCount( static_cast( times_.size() ) ), pTimes( times_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PresentTimesInfoGOOGLE & operator=( PresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentTimesInfoGOOGLE & operator=( VkPresentTimesInfoGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE & setPTimes( const PresentTimeGOOGLE * pTimes_ ) & VULKAN_HPP_NOEXCEPT - { - pTimes = pTimes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimesInfoGOOGLE && setPTimes( const PresentTimeGOOGLE * pTimes_ ) && VULKAN_HPP_NOEXCEPT - { - pTimes = pTimes_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentTimesInfoGOOGLE & setTimes( ArrayProxyNoTemporaries const & times_ ) VULKAN_HPP_NOEXCEPT - { - swapchainCount = static_cast( times_.size() ); - pTimes = times_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPresentTimesInfoGOOGLE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentTimesInfoGOOGLE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentTimesInfoGOOGLE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentTimesInfoGOOGLE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchainCount, pTimes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentTimesInfoGOOGLE const & ) const = default; -#else - bool operator==( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pTimes == rhs.pTimes ); -# endif - } - - bool operator!=( PresentTimesInfoGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePresentTimesInfoGOOGLE; - const void * pNext = {}; - uint32_t swapchainCount = {}; - const PresentTimeGOOGLE * pTimes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentTimesInfoGOOGLE; - }; -#endif - - template <> - struct CppType - { - using Type = PresentTimesInfoGOOGLE; - }; - - // wrapper struct for struct VkPresentTimingInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingInfoEXT.html - struct PresentTimingInfoEXT - { - using NativeType = VkPresentTimingInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimingInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PresentTimingInfoEXT( PresentTimingInfoFlagsEXT flags_ = {}, - uint64_t targetTime_ = {}, - uint64_t timeDomainId_ = {}, - PresentStageFlagsEXT presentStageQueries_ = {}, - PresentStageFlagsEXT targetTimeDomainPresentStage_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , targetTime{ targetTime_ } - , timeDomainId{ timeDomainId_ } - , presentStageQueries{ presentStageQueries_ } - , targetTimeDomainPresentStage{ targetTimeDomainPresentStage_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentTimingInfoEXT( PresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentTimingInfoEXT( VkPresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PresentTimingInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - PresentTimingInfoEXT & operator=( PresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentTimingInfoEXT & operator=( VkPresentTimingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setFlags( PresentTimingInfoFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setFlags( PresentTimingInfoFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setTargetTime( uint64_t targetTime_ ) & VULKAN_HPP_NOEXCEPT - { - targetTime = targetTime_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setTargetTime( uint64_t targetTime_ ) && VULKAN_HPP_NOEXCEPT - { - targetTime = targetTime_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setTimeDomainId( uint64_t timeDomainId_ ) & VULKAN_HPP_NOEXCEPT - { - timeDomainId = timeDomainId_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setTimeDomainId( uint64_t timeDomainId_ ) && VULKAN_HPP_NOEXCEPT - { - timeDomainId = timeDomainId_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setPresentStageQueries( PresentStageFlagsEXT presentStageQueries_ ) & VULKAN_HPP_NOEXCEPT - { - presentStageQueries = presentStageQueries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setPresentStageQueries( PresentStageFlagsEXT presentStageQueries_ ) && VULKAN_HPP_NOEXCEPT - { - presentStageQueries = presentStageQueries_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT & setTargetTimeDomainPresentStage( PresentStageFlagsEXT targetTimeDomainPresentStage_ ) & VULKAN_HPP_NOEXCEPT - { - targetTimeDomainPresentStage = targetTimeDomainPresentStage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingInfoEXT && setTargetTimeDomainPresentStage( PresentStageFlagsEXT targetTimeDomainPresentStage_ ) && VULKAN_HPP_NOEXCEPT - { - targetTimeDomainPresentStage = targetTimeDomainPresentStage_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPresentTimingInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentTimingInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentTimingInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentTimingInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, targetTime, timeDomainId, presentStageQueries, targetTimeDomainPresentStage ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentTimingInfoEXT const & ) const = default; -#else - bool operator==( PresentTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( targetTime == rhs.targetTime ) && - ( timeDomainId == rhs.timeDomainId ) && ( presentStageQueries == rhs.presentStageQueries ) && - ( targetTimeDomainPresentStage == rhs.targetTimeDomainPresentStage ); -# endif - } - - bool operator!=( PresentTimingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePresentTimingInfoEXT; - const void * pNext = {}; - PresentTimingInfoFlagsEXT flags = {}; - uint64_t targetTime = {}; - uint64_t timeDomainId = {}; - PresentStageFlagsEXT presentStageQueries = {}; - PresentStageFlagsEXT targetTimeDomainPresentStage = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentTimingInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PresentTimingInfoEXT; - }; - - // wrapper struct for struct VkPresentTimingSurfaceCapabilitiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingSurfaceCapabilitiesEXT.html - struct PresentTimingSurfaceCapabilitiesEXT - { - using NativeType = VkPresentTimingSurfaceCapabilitiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimingSurfaceCapabilitiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PresentTimingSurfaceCapabilitiesEXT( Bool32 presentTimingSupported_ = {}, - Bool32 presentAtAbsoluteTimeSupported_ = {}, - Bool32 presentAtRelativeTimeSupported_ = {}, - PresentStageFlagsEXT presentStageQueries_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentTimingSupported{ presentTimingSupported_ } - , presentAtAbsoluteTimeSupported{ presentAtAbsoluteTimeSupported_ } - , presentAtRelativeTimeSupported{ presentAtRelativeTimeSupported_ } - , presentStageQueries{ presentStageQueries_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentTimingSurfaceCapabilitiesEXT( PresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentTimingSurfaceCapabilitiesEXT( VkPresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PresentTimingSurfaceCapabilitiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - PresentTimingSurfaceCapabilitiesEXT & operator=( PresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentTimingSurfaceCapabilitiesEXT & operator=( VkPresentTimingSurfaceCapabilitiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkPresentTimingSurfaceCapabilitiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentTimingSurfaceCapabilitiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentTimingSurfaceCapabilitiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentTimingSurfaceCapabilitiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentTimingSupported, presentAtAbsoluteTimeSupported, presentAtRelativeTimeSupported, presentStageQueries ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentTimingSurfaceCapabilitiesEXT const & ) const = default; -#else - bool operator==( PresentTimingSurfaceCapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentTimingSupported == rhs.presentTimingSupported ) && - ( presentAtAbsoluteTimeSupported == rhs.presentAtAbsoluteTimeSupported ) && - ( presentAtRelativeTimeSupported == rhs.presentAtRelativeTimeSupported ) && ( presentStageQueries == rhs.presentStageQueries ); -# endif - } - - bool operator!=( PresentTimingSurfaceCapabilitiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePresentTimingSurfaceCapabilitiesEXT; - void * pNext = {}; - Bool32 presentTimingSupported = {}; - Bool32 presentAtAbsoluteTimeSupported = {}; - Bool32 presentAtRelativeTimeSupported = {}; - PresentStageFlagsEXT presentStageQueries = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentTimingSurfaceCapabilitiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PresentTimingSurfaceCapabilitiesEXT; - }; - - // wrapper struct for struct VkPresentTimingsInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentTimingsInfoEXT.html - struct PresentTimingsInfoEXT - { - using NativeType = VkPresentTimingsInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentTimingsInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - PresentTimingsInfoEXT( uint32_t swapchainCount_ = {}, const PresentTimingInfoEXT * pTimingInfos_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchainCount{ swapchainCount_ } - , pTimingInfos{ pTimingInfos_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentTimingsInfoEXT( PresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentTimingsInfoEXT( VkPresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : PresentTimingsInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentTimingsInfoEXT( ArrayProxyNoTemporaries const & timingInfos_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), swapchainCount( static_cast( timingInfos_.size() ) ), pTimingInfos( timingInfos_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PresentTimingsInfoEXT & operator=( PresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentTimingsInfoEXT & operator=( VkPresentTimingsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT & setPTimingInfos( const PresentTimingInfoEXT * pTimingInfos_ ) & VULKAN_HPP_NOEXCEPT - { - pTimingInfos = pTimingInfos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentTimingsInfoEXT && setPTimingInfos( const PresentTimingInfoEXT * pTimingInfos_ ) && VULKAN_HPP_NOEXCEPT - { - pTimingInfos = pTimingInfos_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PresentTimingsInfoEXT & setTimingInfos( ArrayProxyNoTemporaries const & timingInfos_ ) VULKAN_HPP_NOEXCEPT - { - swapchainCount = static_cast( timingInfos_.size() ); - pTimingInfos = timingInfos_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPresentTimingsInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentTimingsInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentTimingsInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentTimingsInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchainCount, pTimingInfos ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentTimingsInfoEXT const & ) const = default; -#else - bool operator==( PresentTimingsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pTimingInfos == rhs.pTimingInfos ); -# endif - } - - bool operator!=( PresentTimingsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePresentTimingsInfoEXT; - const void * pNext = {}; - uint32_t swapchainCount = {}; - const PresentTimingInfoEXT * pTimingInfos = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentTimingsInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PresentTimingsInfoEXT; - }; - - // wrapper struct for struct VkPresentWait2InfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPresentWait2InfoKHR.html - struct PresentWait2InfoKHR - { - using NativeType = VkPresentWait2InfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePresentWait2InfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PresentWait2InfoKHR( uint64_t presentId_ = {}, uint64_t timeout_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentId{ presentId_ } - , timeout{ timeout_ } - { - } - - VULKAN_HPP_CONSTEXPR PresentWait2InfoKHR( PresentWait2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PresentWait2InfoKHR( VkPresentWait2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : PresentWait2InfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - PresentWait2InfoKHR & operator=( PresentWait2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PresentWait2InfoKHR & operator=( VkPresentWait2InfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR & setPresentId( uint64_t presentId_ ) & VULKAN_HPP_NOEXCEPT - { - presentId = presentId_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR && setPresentId( uint64_t presentId_ ) && VULKAN_HPP_NOEXCEPT - { - presentId = presentId_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR & setTimeout( uint64_t timeout_ ) & VULKAN_HPP_NOEXCEPT - { - timeout = timeout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PresentWait2InfoKHR && setTimeout( uint64_t timeout_ ) && VULKAN_HPP_NOEXCEPT - { - timeout = timeout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPresentWait2InfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentWait2InfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPresentWait2InfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPresentWait2InfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentId, timeout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PresentWait2InfoKHR const & ) const = default; -#else - bool operator==( PresentWait2InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId == rhs.presentId ) && ( timeout == rhs.timeout ); -# endif - } - - bool operator!=( PresentWait2InfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePresentWait2InfoKHR; - const void * pNext = {}; - uint64_t presentId = {}; - uint64_t timeout = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PresentWait2InfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = PresentWait2InfoKHR; - }; - - // wrapper struct for struct VkPrivateDataSlotCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPrivateDataSlotCreateInfo.html - struct PrivateDataSlotCreateInfo - { - using NativeType = VkPrivateDataSlotCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePrivateDataSlotCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PrivateDataSlotCreateInfo( PrivateDataSlotCreateFlags flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR PrivateDataSlotCreateInfo( PrivateDataSlotCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PrivateDataSlotCreateInfo( VkPrivateDataSlotCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PrivateDataSlotCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PrivateDataSlotCreateInfo & operator=( PrivateDataSlotCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PrivateDataSlotCreateInfo & operator=( VkPrivateDataSlotCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PrivateDataSlotCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PrivateDataSlotCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PrivateDataSlotCreateInfo & setFlags( PrivateDataSlotCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PrivateDataSlotCreateInfo && setFlags( PrivateDataSlotCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPrivateDataSlotCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPrivateDataSlotCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPrivateDataSlotCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPrivateDataSlotCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PrivateDataSlotCreateInfo const & ) const = default; -#else - bool operator==( PrivateDataSlotCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( PrivateDataSlotCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePrivateDataSlotCreateInfo; - const void * pNext = {}; - PrivateDataSlotCreateFlags flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PrivateDataSlotCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PrivateDataSlotCreateInfo; - }; - - using PrivateDataSlotCreateInfoEXT = PrivateDataSlotCreateInfo; - - // wrapper struct for struct VkProtectedSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkProtectedSubmitInfo.html - struct ProtectedSubmitInfo - { - using NativeType = VkProtectedSubmitInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eProtectedSubmitInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( Bool32 protectedSubmit_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , protectedSubmit{ protectedSubmit_ } - { - } - - VULKAN_HPP_CONSTEXPR ProtectedSubmitInfo( ProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ProtectedSubmitInfo( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT : ProtectedSubmitInfo( *reinterpret_cast( &rhs ) ) - { - } - - ProtectedSubmitInfo & operator=( ProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ProtectedSubmitInfo & operator=( VkProtectedSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ProtectedSubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ProtectedSubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ProtectedSubmitInfo & setProtectedSubmit( Bool32 protectedSubmit_ ) & VULKAN_HPP_NOEXCEPT - { - protectedSubmit = protectedSubmit_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ProtectedSubmitInfo && setProtectedSubmit( Bool32 protectedSubmit_ ) && VULKAN_HPP_NOEXCEPT - { - protectedSubmit = protectedSubmit_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkProtectedSubmitInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkProtectedSubmitInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkProtectedSubmitInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkProtectedSubmitInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, protectedSubmit ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ProtectedSubmitInfo const & ) const = default; -#else - bool operator==( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( protectedSubmit == rhs.protectedSubmit ); -# endif - } - - bool operator!=( ProtectedSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eProtectedSubmitInfo; - const void * pNext = {}; - Bool32 protectedSubmit = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ProtectedSubmitInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ProtectedSubmitInfo; - }; - - // wrapper struct for struct VkPushConstantBankInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushConstantBankInfoNV.html - struct PushConstantBankInfoNV - { - using NativeType = VkPushConstantBankInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePushConstantBankInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PushConstantBankInfoNV( uint32_t bank_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , bank{ bank_ } - { - } - - VULKAN_HPP_CONSTEXPR PushConstantBankInfoNV( PushConstantBankInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PushConstantBankInfoNV( VkPushConstantBankInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : PushConstantBankInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - PushConstantBankInfoNV & operator=( PushConstantBankInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PushConstantBankInfoNV & operator=( VkPushConstantBankInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PushConstantBankInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantBankInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantBankInfoNV & setBank( uint32_t bank_ ) & VULKAN_HPP_NOEXCEPT - { - bank = bank_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantBankInfoNV && setBank( uint32_t bank_ ) && VULKAN_HPP_NOEXCEPT - { - bank = bank_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPushConstantBankInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushConstantBankInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushConstantBankInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPushConstantBankInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, bank ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PushConstantBankInfoNV const & ) const = default; -#else - bool operator==( PushConstantBankInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( bank == rhs.bank ); -# endif - } - - bool operator!=( PushConstantBankInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePushConstantBankInfoNV; - const void * pNext = {}; - uint32_t bank = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PushConstantBankInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = PushConstantBankInfoNV; - }; - - // wrapper struct for struct VkPushConstantsInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushConstantsInfo.html - struct PushConstantsInfo - { - using NativeType = VkPushConstantsInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePushConstantsInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PushConstantsInfo( PipelineLayout layout_ = {}, - ShaderStageFlags stageFlags_ = {}, - uint32_t offset_ = {}, - uint32_t size_ = {}, - const void * pValues_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , layout{ layout_ } - , stageFlags{ stageFlags_ } - , offset{ offset_ } - , size{ size_ } - , pValues{ pValues_ } - { - } - - VULKAN_HPP_CONSTEXPR PushConstantsInfo( PushConstantsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PushConstantsInfo( VkPushConstantsInfo const & rhs ) VULKAN_HPP_NOEXCEPT : PushConstantsInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - PushConstantsInfo( - PipelineLayout layout_, ShaderStageFlags stageFlags_, uint32_t offset_, ArrayProxyNoTemporaries const & values_, const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , layout( layout_ ) - , stageFlags( stageFlags_ ) - , offset( offset_ ) - , size( static_cast( values_.size() * sizeof( T ) ) ) - , pValues( values_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PushConstantsInfo & operator=( PushConstantsInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PushConstantsInfo & operator=( VkPushConstantsInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setSize( uint32_t size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setSize( uint32_t size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo & setPValues( const void * pValues_ ) & VULKAN_HPP_NOEXCEPT - { - pValues = pValues_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushConstantsInfo && setPValues( const void * pValues_ ) && VULKAN_HPP_NOEXCEPT - { - pValues = pValues_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - PushConstantsInfo & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT - { - size = static_cast( values_.size() * sizeof( T ) ); - pValues = values_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPushConstantsInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushConstantsInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushConstantsInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPushConstantsInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, layout, stageFlags, offset, size, pValues ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PushConstantsInfo const & ) const = default; -#else - bool operator==( PushConstantsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( layout == rhs.layout ) && ( stageFlags == rhs.stageFlags ) && ( offset == rhs.offset ) && - ( size == rhs.size ) && ( pValues == rhs.pValues ); -# endif - } - - bool operator!=( PushConstantsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePushConstantsInfo; - const void * pNext = {}; - PipelineLayout layout = {}; - ShaderStageFlags stageFlags = {}; - uint32_t offset = {}; - uint32_t size = {}; - const void * pValues = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PushConstantsInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PushConstantsInfo; - }; - - using PushConstantsInfoKHR = PushConstantsInfo; - - // wrapper struct for struct VkPushDataInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushDataInfoEXT.html - struct PushDataInfoEXT - { - using NativeType = VkPushDataInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePushDataInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PushDataInfoEXT( uint32_t offset_ = {}, HostAddressRangeConstEXT data_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , offset{ offset_ } - , data{ data_ } - { - } - - VULKAN_HPP_CONSTEXPR PushDataInfoEXT( PushDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PushDataInfoEXT( VkPushDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : PushDataInfoEXT( *reinterpret_cast( &rhs ) ) {} - - PushDataInfoEXT & operator=( PushDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PushDataInfoEXT & operator=( VkPushDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT & setData( HostAddressRangeConstEXT const & data_ ) & VULKAN_HPP_NOEXCEPT - { - data = data_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDataInfoEXT && setData( HostAddressRangeConstEXT const & data_ ) && VULKAN_HPP_NOEXCEPT - { - data = data_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPushDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushDataInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPushDataInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, offset, data ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PushDataInfoEXT const & ) const = default; -#else - bool operator==( PushDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( offset == rhs.offset ) && ( data == rhs.data ); -# endif - } - - bool operator!=( PushDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePushDataInfoEXT; - const void * pNext = {}; - uint32_t offset = {}; - HostAddressRangeConstEXT data = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PushDataInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = PushDataInfoEXT; - }; - - // wrapper struct for struct VkWriteDescriptorSet, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSet.html - struct WriteDescriptorSet - { - using NativeType = VkWriteDescriptorSet; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSet; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR WriteDescriptorSet( DescriptorSet dstSet_ = {}, - uint32_t dstBinding_ = {}, - uint32_t dstArrayElement_ = {}, - uint32_t descriptorCount_ = {}, - DescriptorType descriptorType_ = DescriptorType::eSampler, - const DescriptorImageInfo * pImageInfo_ = {}, - const DescriptorBufferInfo * pBufferInfo_ = {}, - const BufferView * pTexelBufferView_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dstSet{ dstSet_ } - , dstBinding{ dstBinding_ } - , dstArrayElement{ dstArrayElement_ } - , descriptorCount{ descriptorCount_ } - , descriptorType{ descriptorType_ } - , pImageInfo{ pImageInfo_ } - , pBufferInfo{ pBufferInfo_ } - , pTexelBufferView{ pTexelBufferView_ } - { - } - - VULKAN_HPP_CONSTEXPR WriteDescriptorSet( WriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - WriteDescriptorSet( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT : WriteDescriptorSet( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSet( DescriptorSet dstSet_, - uint32_t dstBinding_, - uint32_t dstArrayElement_, - DescriptorType descriptorType_, - ArrayProxyNoTemporaries const & imageInfo_, - ArrayProxyNoTemporaries const & bufferInfo_ = {}, - ArrayProxyNoTemporaries const & texelBufferView_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , dstSet( dstSet_ ) - , dstBinding( dstBinding_ ) - , dstArrayElement( dstArrayElement_ ) - , descriptorCount( static_cast( !imageInfo_.empty() ? imageInfo_.size() - : !bufferInfo_.empty() ? bufferInfo_.size() - : texelBufferView_.size() ) ) - , descriptorType( descriptorType_ ) - , pImageInfo( imageInfo_.data() ) - , pBufferInfo( bufferInfo_.data() ) - , pTexelBufferView( texelBufferView_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( ( !imageInfo_.empty() + !bufferInfo_.empty() + !texelBufferView_.empty() ) <= 1 ); -# else - if ( 1 < ( !imageInfo_.empty() + !bufferInfo_.empty() + !texelBufferView_.empty() ) ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::WriteDescriptorSet::WriteDescriptorSet: 1 < ( !imageInfo_.empty() + !bufferInfo_.empty() + !texelBufferView_.empty() )" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - WriteDescriptorSet & operator=( WriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - WriteDescriptorSet & operator=( VkWriteDescriptorSet const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setDstSet( DescriptorSet dstSet_ ) & VULKAN_HPP_NOEXCEPT - { - dstSet = dstSet_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setDstSet( DescriptorSet dstSet_ ) && VULKAN_HPP_NOEXCEPT - { - dstSet = dstSet_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setDstBinding( uint32_t dstBinding_ ) & VULKAN_HPP_NOEXCEPT - { - dstBinding = dstBinding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setDstBinding( uint32_t dstBinding_ ) && VULKAN_HPP_NOEXCEPT - { - dstBinding = dstBinding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setDstArrayElement( uint32_t dstArrayElement_ ) & VULKAN_HPP_NOEXCEPT - { - dstArrayElement = dstArrayElement_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setDstArrayElement( uint32_t dstArrayElement_ ) && VULKAN_HPP_NOEXCEPT - { - dstArrayElement = dstArrayElement_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setDescriptorCount( uint32_t descriptorCount_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorCount = descriptorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setDescriptorCount( uint32_t descriptorCount_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorCount = descriptorCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setDescriptorType( DescriptorType descriptorType_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorType = descriptorType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setDescriptorType( DescriptorType descriptorType_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorType = descriptorType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setPImageInfo( const DescriptorImageInfo * pImageInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pImageInfo = pImageInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setPImageInfo( const DescriptorImageInfo * pImageInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pImageInfo = pImageInfo_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSet & setImageInfo( ArrayProxyNoTemporaries const & imageInfo_ ) VULKAN_HPP_NOEXCEPT - { - descriptorCount = static_cast( imageInfo_.size() ); - pImageInfo = imageInfo_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setPBufferInfo( const DescriptorBufferInfo * pBufferInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pBufferInfo = pBufferInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setPBufferInfo( const DescriptorBufferInfo * pBufferInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pBufferInfo = pBufferInfo_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSet & setBufferInfo( ArrayProxyNoTemporaries const & bufferInfo_ ) VULKAN_HPP_NOEXCEPT - { - descriptorCount = static_cast( bufferInfo_.size() ); - pBufferInfo = bufferInfo_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet & setPTexelBufferView( const BufferView * pTexelBufferView_ ) & VULKAN_HPP_NOEXCEPT - { - pTexelBufferView = pTexelBufferView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSet && setPTexelBufferView( const BufferView * pTexelBufferView_ ) && VULKAN_HPP_NOEXCEPT - { - pTexelBufferView = pTexelBufferView_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSet & setTexelBufferView( ArrayProxyNoTemporaries const & texelBufferView_ ) VULKAN_HPP_NOEXCEPT - { - descriptorCount = static_cast( texelBufferView_.size() ); - pTexelBufferView = texelBufferView_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWriteDescriptorSet const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSet &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSet const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWriteDescriptorSet *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dstSet, dstBinding, dstArrayElement, descriptorCount, descriptorType, pImageInfo, pBufferInfo, pTexelBufferView ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( WriteDescriptorSet const & ) const = default; -#else - bool operator==( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dstSet == rhs.dstSet ) && ( dstBinding == rhs.dstBinding ) && - ( dstArrayElement == rhs.dstArrayElement ) && ( descriptorCount == rhs.descriptorCount ) && ( descriptorType == rhs.descriptorType ) && - ( pImageInfo == rhs.pImageInfo ) && ( pBufferInfo == rhs.pBufferInfo ) && ( pTexelBufferView == rhs.pTexelBufferView ); -# endif - } - - bool operator!=( WriteDescriptorSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eWriteDescriptorSet; - const void * pNext = {}; - DescriptorSet dstSet = {}; - uint32_t dstBinding = {}; - uint32_t dstArrayElement = {}; - uint32_t descriptorCount = {}; - DescriptorType descriptorType = DescriptorType::eSampler; - const DescriptorImageInfo * pImageInfo = {}; - const DescriptorBufferInfo * pBufferInfo = {}; - const BufferView * pTexelBufferView = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = WriteDescriptorSet; - }; -#endif - - template <> - struct CppType - { - using Type = WriteDescriptorSet; - }; - - // wrapper struct for struct VkPushDescriptorSetInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushDescriptorSetInfo.html - struct PushDescriptorSetInfo - { - using NativeType = VkPushDescriptorSetInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePushDescriptorSetInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PushDescriptorSetInfo( ShaderStageFlags stageFlags_ = {}, - PipelineLayout layout_ = {}, - uint32_t set_ = {}, - uint32_t descriptorWriteCount_ = {}, - const WriteDescriptorSet * pDescriptorWrites_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stageFlags{ stageFlags_ } - , layout{ layout_ } - , set{ set_ } - , descriptorWriteCount{ descriptorWriteCount_ } - , pDescriptorWrites{ pDescriptorWrites_ } - { - } - - VULKAN_HPP_CONSTEXPR PushDescriptorSetInfo( PushDescriptorSetInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PushDescriptorSetInfo( VkPushDescriptorSetInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PushDescriptorSetInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PushDescriptorSetInfo( ShaderStageFlags stageFlags_, - PipelineLayout layout_, - uint32_t set_, - ArrayProxyNoTemporaries const & descriptorWrites_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , stageFlags( stageFlags_ ) - , layout( layout_ ) - , set( set_ ) - , descriptorWriteCount( static_cast( descriptorWrites_.size() ) ) - , pDescriptorWrites( descriptorWrites_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - PushDescriptorSetInfo & operator=( PushDescriptorSetInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PushDescriptorSetInfo & operator=( VkPushDescriptorSetInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT - { - set = set_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT - { - set = set_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setDescriptorWriteCount( uint32_t descriptorWriteCount_ ) & VULKAN_HPP_NOEXCEPT - { - descriptorWriteCount = descriptorWriteCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setDescriptorWriteCount( uint32_t descriptorWriteCount_ ) && VULKAN_HPP_NOEXCEPT - { - descriptorWriteCount = descriptorWriteCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo & setPDescriptorWrites( const WriteDescriptorSet * pDescriptorWrites_ ) & VULKAN_HPP_NOEXCEPT - { - pDescriptorWrites = pDescriptorWrites_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetInfo && setPDescriptorWrites( const WriteDescriptorSet * pDescriptorWrites_ ) && VULKAN_HPP_NOEXCEPT - { - pDescriptorWrites = pDescriptorWrites_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - PushDescriptorSetInfo & setDescriptorWrites( ArrayProxyNoTemporaries const & descriptorWrites_ ) VULKAN_HPP_NOEXCEPT - { - descriptorWriteCount = static_cast( descriptorWrites_.size() ); - pDescriptorWrites = descriptorWrites_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPushDescriptorSetInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushDescriptorSetInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushDescriptorSetInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPushDescriptorSetInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stageFlags, layout, set, descriptorWriteCount, pDescriptorWrites ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PushDescriptorSetInfo const & ) const = default; -#else - bool operator==( PushDescriptorSetInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( set == rhs.set ) && - ( descriptorWriteCount == rhs.descriptorWriteCount ) && ( pDescriptorWrites == rhs.pDescriptorWrites ); -# endif - } - - bool operator!=( PushDescriptorSetInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePushDescriptorSetInfo; - const void * pNext = {}; - ShaderStageFlags stageFlags = {}; - PipelineLayout layout = {}; - uint32_t set = {}; - uint32_t descriptorWriteCount = {}; - const WriteDescriptorSet * pDescriptorWrites = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PushDescriptorSetInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PushDescriptorSetInfo; - }; - - using PushDescriptorSetInfoKHR = PushDescriptorSetInfo; - - // wrapper struct for struct VkPushDescriptorSetWithTemplateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPushDescriptorSetWithTemplateInfo.html - struct PushDescriptorSetWithTemplateInfo - { - using NativeType = VkPushDescriptorSetWithTemplateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePushDescriptorSetWithTemplateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR PushDescriptorSetWithTemplateInfo( DescriptorUpdateTemplate descriptorUpdateTemplate_ = {}, - PipelineLayout layout_ = {}, - uint32_t set_ = {}, - const void * pData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , descriptorUpdateTemplate{ descriptorUpdateTemplate_ } - , layout{ layout_ } - , set{ set_ } - , pData{ pData_ } - { - } - - VULKAN_HPP_CONSTEXPR PushDescriptorSetWithTemplateInfo( PushDescriptorSetWithTemplateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - PushDescriptorSetWithTemplateInfo( VkPushDescriptorSetWithTemplateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : PushDescriptorSetWithTemplateInfo( *reinterpret_cast( &rhs ) ) - { - } - - PushDescriptorSetWithTemplateInfo & operator=( PushDescriptorSetWithTemplateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - PushDescriptorSetWithTemplateInfo & operator=( VkPushDescriptorSetWithTemplateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo & setDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate_ ) & - VULKAN_HPP_NOEXCEPT - { - descriptorUpdateTemplate = descriptorUpdateTemplate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo && setDescriptorUpdateTemplate( DescriptorUpdateTemplate descriptorUpdateTemplate_ ) && - VULKAN_HPP_NOEXCEPT - { - descriptorUpdateTemplate = descriptorUpdateTemplate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo & setSet( uint32_t set_ ) & VULKAN_HPP_NOEXCEPT - { - set = set_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo && setSet( uint32_t set_ ) && VULKAN_HPP_NOEXCEPT - { - set = set_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo & setPData( const void * pData_ ) & VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 PushDescriptorSetWithTemplateInfo && setPData( const void * pData_ ) && VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkPushDescriptorSetWithTemplateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushDescriptorSetWithTemplateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkPushDescriptorSetWithTemplateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkPushDescriptorSetWithTemplateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, descriptorUpdateTemplate, layout, set, pData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( PushDescriptorSetWithTemplateInfo const & ) const = default; -#else - bool operator==( PushDescriptorSetWithTemplateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( descriptorUpdateTemplate == rhs.descriptorUpdateTemplate ) && ( layout == rhs.layout ) && - ( set == rhs.set ) && ( pData == rhs.pData ); -# endif - } - - bool operator!=( PushDescriptorSetWithTemplateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::ePushDescriptorSetWithTemplateInfo; - const void * pNext = {}; - DescriptorUpdateTemplate descriptorUpdateTemplate = {}; - PipelineLayout layout = {}; - uint32_t set = {}; - const void * pData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = PushDescriptorSetWithTemplateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = PushDescriptorSetWithTemplateInfo; - }; - - using PushDescriptorSetWithTemplateInfoKHR = PushDescriptorSetWithTemplateInfo; - - // wrapper struct for struct VkQueryLowLatencySupportNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryLowLatencySupportNV.html - struct QueryLowLatencySupportNV - { - using NativeType = VkQueryLowLatencySupportNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryLowLatencySupportNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueryLowLatencySupportNV( void * pQueriedLowLatencyData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pQueriedLowLatencyData{ pQueriedLowLatencyData_ } - { - } - - VULKAN_HPP_CONSTEXPR QueryLowLatencySupportNV( QueryLowLatencySupportNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueryLowLatencySupportNV( VkQueryLowLatencySupportNV const & rhs ) VULKAN_HPP_NOEXCEPT - : QueryLowLatencySupportNV( *reinterpret_cast( &rhs ) ) - { - } - - QueryLowLatencySupportNV & operator=( QueryLowLatencySupportNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueryLowLatencySupportNV & operator=( VkQueryLowLatencySupportNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 QueryLowLatencySupportNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryLowLatencySupportNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 QueryLowLatencySupportNV & setPQueriedLowLatencyData( void * pQueriedLowLatencyData_ ) & VULKAN_HPP_NOEXCEPT - { - pQueriedLowLatencyData = pQueriedLowLatencyData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryLowLatencySupportNV && setPQueriedLowLatencyData( void * pQueriedLowLatencyData_ ) && VULKAN_HPP_NOEXCEPT - { - pQueriedLowLatencyData = pQueriedLowLatencyData_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkQueryLowLatencySupportNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueryLowLatencySupportNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueryLowLatencySupportNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueryLowLatencySupportNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pQueriedLowLatencyData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueryLowLatencySupportNV const & ) const = default; -#else - bool operator==( QueryLowLatencySupportNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pQueriedLowLatencyData == rhs.pQueriedLowLatencyData ); -# endif - } - - bool operator!=( QueryLowLatencySupportNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueryLowLatencySupportNV; - const void * pNext = {}; - void * pQueriedLowLatencyData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueryLowLatencySupportNV; - }; -#endif - - template <> - struct CppType - { - using Type = QueryLowLatencySupportNV; - }; - - // wrapper struct for struct VkQueryPoolCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolCreateInfo.html - struct QueryPoolCreateInfo - { - using NativeType = VkQueryPoolCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( QueryPoolCreateFlags flags_ = {}, - QueryType queryType_ = QueryType::eOcclusion, - uint32_t queryCount_ = {}, - QueryPipelineStatisticFlags pipelineStatistics_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , queryType{ queryType_ } - , queryCount{ queryCount_ } - , pipelineStatistics{ pipelineStatistics_ } - { - } - - VULKAN_HPP_CONSTEXPR QueryPoolCreateInfo( QueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueryPoolCreateInfo( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : QueryPoolCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - QueryPoolCreateInfo & operator=( QueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueryPoolCreateInfo & operator=( VkQueryPoolCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo & setFlags( QueryPoolCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo && setFlags( QueryPoolCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo & setQueryType( QueryType queryType_ ) & VULKAN_HPP_NOEXCEPT - { - queryType = queryType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo && setQueryType( QueryType queryType_ ) && VULKAN_HPP_NOEXCEPT - { - queryType = queryType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo & setQueryCount( uint32_t queryCount_ ) & VULKAN_HPP_NOEXCEPT - { - queryCount = queryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo && setQueryCount( uint32_t queryCount_ ) && VULKAN_HPP_NOEXCEPT - { - queryCount = queryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo & setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineStatistics = pipelineStatistics_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolCreateInfo && setPipelineStatistics( QueryPipelineStatisticFlags pipelineStatistics_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineStatistics = pipelineStatistics_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkQueryPoolCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueryPoolCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueryPoolCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueryPoolCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, queryType, queryCount, pipelineStatistics ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueryPoolCreateInfo const & ) const = default; -#else - bool operator==( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( queryType == rhs.queryType ) && ( queryCount == rhs.queryCount ) && - ( pipelineStatistics == rhs.pipelineStatistics ); -# endif - } - - bool operator!=( QueryPoolCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueryPoolCreateInfo; - const void * pNext = {}; - QueryPoolCreateFlags flags = {}; - QueryType queryType = QueryType::eOcclusion; - uint32_t queryCount = {}; - QueryPipelineStatisticFlags pipelineStatistics = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueryPoolCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = QueryPoolCreateInfo; - }; - - // wrapper struct for struct VkQueryPoolPerformanceCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolPerformanceCreateInfoKHR.html - struct QueryPoolPerformanceCreateInfoKHR - { - using NativeType = VkQueryPoolPerformanceCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolPerformanceCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueryPoolPerformanceCreateInfoKHR( uint32_t queueFamilyIndex_ = {}, - uint32_t counterIndexCount_ = {}, - const uint32_t * pCounterIndices_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , queueFamilyIndex{ queueFamilyIndex_ } - , counterIndexCount{ counterIndexCount_ } - , pCounterIndices{ pCounterIndices_ } - { - } - - VULKAN_HPP_CONSTEXPR QueryPoolPerformanceCreateInfoKHR( QueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueryPoolPerformanceCreateInfoKHR( VkQueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : QueryPoolPerformanceCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - QueryPoolPerformanceCreateInfoKHR( uint32_t queueFamilyIndex_, - ArrayProxyNoTemporaries const & counterIndices_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , queueFamilyIndex( queueFamilyIndex_ ) - , counterIndexCount( static_cast( counterIndices_.size() ) ) - , pCounterIndices( counterIndices_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - QueryPoolPerformanceCreateInfoKHR & operator=( QueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueryPoolPerformanceCreateInfoKHR & operator=( VkQueryPoolPerformanceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR & setCounterIndexCount( uint32_t counterIndexCount_ ) & VULKAN_HPP_NOEXCEPT - { - counterIndexCount = counterIndexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR && setCounterIndexCount( uint32_t counterIndexCount_ ) && VULKAN_HPP_NOEXCEPT - { - counterIndexCount = counterIndexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR & setPCounterIndices( const uint32_t * pCounterIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pCounterIndices = pCounterIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceCreateInfoKHR && setPCounterIndices( const uint32_t * pCounterIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pCounterIndices = pCounterIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - QueryPoolPerformanceCreateInfoKHR & setCounterIndices( ArrayProxyNoTemporaries const & counterIndices_ ) VULKAN_HPP_NOEXCEPT - { - counterIndexCount = static_cast( counterIndices_.size() ); - pCounterIndices = counterIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkQueryPoolPerformanceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueryPoolPerformanceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueryPoolPerformanceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueryPoolPerformanceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, queueFamilyIndex, counterIndexCount, pCounterIndices ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueryPoolPerformanceCreateInfoKHR const & ) const = default; -#else - bool operator==( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && - ( counterIndexCount == rhs.counterIndexCount ) && ( pCounterIndices == rhs.pCounterIndices ); -# endif - } - - bool operator!=( QueryPoolPerformanceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueryPoolPerformanceCreateInfoKHR; - const void * pNext = {}; - uint32_t queueFamilyIndex = {}; - uint32_t counterIndexCount = {}; - const uint32_t * pCounterIndices = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueryPoolPerformanceCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = QueryPoolPerformanceCreateInfoKHR; - }; - - // wrapper struct for struct VkQueryPoolPerformanceQueryCreateInfoINTEL, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolPerformanceQueryCreateInfoINTEL.html - struct QueryPoolPerformanceQueryCreateInfoINTEL - { - using NativeType = VkQueryPoolPerformanceQueryCreateInfoINTEL; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - QueryPoolPerformanceQueryCreateInfoINTEL( QueryPoolSamplingModeINTEL performanceCountersSampling_ = QueryPoolSamplingModeINTEL::eManual, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , performanceCountersSampling{ performanceCountersSampling_ } - { - } - - VULKAN_HPP_CONSTEXPR QueryPoolPerformanceQueryCreateInfoINTEL( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueryPoolPerformanceQueryCreateInfoINTEL( VkQueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - : QueryPoolPerformanceQueryCreateInfoINTEL( *reinterpret_cast( &rhs ) ) - { - } - - QueryPoolPerformanceQueryCreateInfoINTEL & operator=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueryPoolPerformanceQueryCreateInfoINTEL & operator=( VkQueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceQueryCreateInfoINTEL & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceQueryCreateInfoINTEL && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceQueryCreateInfoINTEL & - setPerformanceCountersSampling( QueryPoolSamplingModeINTEL performanceCountersSampling_ ) & - VULKAN_HPP_NOEXCEPT - { - performanceCountersSampling = performanceCountersSampling_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolPerformanceQueryCreateInfoINTEL && - setPerformanceCountersSampling( QueryPoolSamplingModeINTEL performanceCountersSampling_ ) && - VULKAN_HPP_NOEXCEPT - { - performanceCountersSampling = performanceCountersSampling_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkQueryPoolPerformanceQueryCreateInfoINTEL const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueryPoolPerformanceQueryCreateInfoINTEL &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueryPoolPerformanceQueryCreateInfoINTEL const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueryPoolPerformanceQueryCreateInfoINTEL *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, performanceCountersSampling ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueryPoolPerformanceQueryCreateInfoINTEL const & ) const = default; -#else - bool operator==( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( performanceCountersSampling == rhs.performanceCountersSampling ); -# endif - } - - bool operator!=( QueryPoolPerformanceQueryCreateInfoINTEL const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL; - const void * pNext = {}; - QueryPoolSamplingModeINTEL performanceCountersSampling = QueryPoolSamplingModeINTEL::eManual; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueryPoolPerformanceQueryCreateInfoINTEL; - }; -#endif - - template <> - struct CppType - { - using Type = QueryPoolPerformanceQueryCreateInfoINTEL; - }; - - using QueryPoolCreateInfoINTEL = QueryPoolPerformanceQueryCreateInfoINTEL; - - // wrapper struct for struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueryPoolVideoEncodeFeedbackCreateInfoKHR.html - struct QueryPoolVideoEncodeFeedbackCreateInfoKHR - { - using NativeType = VkQueryPoolVideoEncodeFeedbackCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueryPoolVideoEncodeFeedbackCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueryPoolVideoEncodeFeedbackCreateInfoKHR( VideoEncodeFeedbackFlagsKHR encodeFeedbackFlags_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , encodeFeedbackFlags{ encodeFeedbackFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR QueryPoolVideoEncodeFeedbackCreateInfoKHR( QueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueryPoolVideoEncodeFeedbackCreateInfoKHR( VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : QueryPoolVideoEncodeFeedbackCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - QueryPoolVideoEncodeFeedbackCreateInfoKHR & operator=( QueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueryPoolVideoEncodeFeedbackCreateInfoKHR & operator=( VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 QueryPoolVideoEncodeFeedbackCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolVideoEncodeFeedbackCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolVideoEncodeFeedbackCreateInfoKHR & setEncodeFeedbackFlags( VideoEncodeFeedbackFlagsKHR encodeFeedbackFlags_ ) & - VULKAN_HPP_NOEXCEPT - { - encodeFeedbackFlags = encodeFeedbackFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 QueryPoolVideoEncodeFeedbackCreateInfoKHR && setEncodeFeedbackFlags( VideoEncodeFeedbackFlagsKHR encodeFeedbackFlags_ ) && - VULKAN_HPP_NOEXCEPT - { - encodeFeedbackFlags = encodeFeedbackFlags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueryPoolVideoEncodeFeedbackCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueryPoolVideoEncodeFeedbackCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, encodeFeedbackFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueryPoolVideoEncodeFeedbackCreateInfoKHR const & ) const = default; -#else - bool operator==( QueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( encodeFeedbackFlags == rhs.encodeFeedbackFlags ); -# endif - } - - bool operator!=( QueryPoolVideoEncodeFeedbackCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueryPoolVideoEncodeFeedbackCreateInfoKHR; - const void * pNext = {}; - VideoEncodeFeedbackFlagsKHR encodeFeedbackFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueryPoolVideoEncodeFeedbackCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = QueryPoolVideoEncodeFeedbackCreateInfoKHR; - }; - - // wrapper struct for struct VkQueueFamilyCheckpointProperties2NV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyCheckpointProperties2NV.html - struct QueueFamilyCheckpointProperties2NV - { - using NativeType = VkQueueFamilyCheckpointProperties2NV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyCheckpointProperties2NV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointProperties2NV( PipelineStageFlags2 checkpointExecutionStageMask_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , checkpointExecutionStageMask{ checkpointExecutionStageMask_ } - { - } - - VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointProperties2NV( QueueFamilyCheckpointProperties2NV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueueFamilyCheckpointProperties2NV( VkQueueFamilyCheckpointProperties2NV const & rhs ) VULKAN_HPP_NOEXCEPT - : QueueFamilyCheckpointProperties2NV( *reinterpret_cast( &rhs ) ) - { - } - - QueueFamilyCheckpointProperties2NV & operator=( QueueFamilyCheckpointProperties2NV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueueFamilyCheckpointProperties2NV & operator=( VkQueueFamilyCheckpointProperties2NV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkQueueFamilyCheckpointProperties2NV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyCheckpointProperties2NV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyCheckpointProperties2NV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueueFamilyCheckpointProperties2NV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, checkpointExecutionStageMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueueFamilyCheckpointProperties2NV const & ) const = default; -#else - bool operator==( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask ); -# endif - } - - bool operator!=( QueueFamilyCheckpointProperties2NV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueueFamilyCheckpointProperties2NV; - void * pNext = {}; - PipelineStageFlags2 checkpointExecutionStageMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueueFamilyCheckpointProperties2NV; - }; -#endif - - template <> - struct CppType - { - using Type = QueueFamilyCheckpointProperties2NV; - }; - - // wrapper struct for struct VkQueueFamilyCheckpointPropertiesNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyCheckpointPropertiesNV.html - struct QueueFamilyCheckpointPropertiesNV - { - using NativeType = VkQueueFamilyCheckpointPropertiesNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyCheckpointPropertiesNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointPropertiesNV( PipelineStageFlags checkpointExecutionStageMask_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , checkpointExecutionStageMask{ checkpointExecutionStageMask_ } - { - } - - VULKAN_HPP_CONSTEXPR QueueFamilyCheckpointPropertiesNV( QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueueFamilyCheckpointPropertiesNV( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - : QueueFamilyCheckpointPropertiesNV( *reinterpret_cast( &rhs ) ) - { - } - - QueueFamilyCheckpointPropertiesNV & operator=( QueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueueFamilyCheckpointPropertiesNV & operator=( VkQueueFamilyCheckpointPropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkQueueFamilyCheckpointPropertiesNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyCheckpointPropertiesNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyCheckpointPropertiesNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueueFamilyCheckpointPropertiesNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, checkpointExecutionStageMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueueFamilyCheckpointPropertiesNV const & ) const = default; -#else - bool operator==( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( checkpointExecutionStageMask == rhs.checkpointExecutionStageMask ); -# endif - } - - bool operator!=( QueueFamilyCheckpointPropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueueFamilyCheckpointPropertiesNV; - void * pNext = {}; - PipelineStageFlags checkpointExecutionStageMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueueFamilyCheckpointPropertiesNV; - }; -#endif - - template <> - struct CppType - { - using Type = QueueFamilyCheckpointPropertiesNV; - }; - - // wrapper struct for struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyDataGraphProcessingEnginePropertiesARM.html - struct QueueFamilyDataGraphProcessingEnginePropertiesARM - { - using NativeType = VkQueueFamilyDataGraphProcessingEnginePropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyDataGraphProcessingEnginePropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueueFamilyDataGraphProcessingEnginePropertiesARM( ExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes_ = {}, - ExternalMemoryHandleTypeFlags foreignMemoryHandleTypes_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , foreignSemaphoreHandleTypes{ foreignSemaphoreHandleTypes_ } - , foreignMemoryHandleTypes{ foreignMemoryHandleTypes_ } - { - } - - VULKAN_HPP_CONSTEXPR - QueueFamilyDataGraphProcessingEnginePropertiesARM( QueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueueFamilyDataGraphProcessingEnginePropertiesARM( VkQueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : QueueFamilyDataGraphProcessingEnginePropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - QueueFamilyDataGraphProcessingEnginePropertiesARM & - operator=( QueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueueFamilyDataGraphProcessingEnginePropertiesARM & operator=( VkQueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkQueueFamilyDataGraphProcessingEnginePropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyDataGraphProcessingEnginePropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyDataGraphProcessingEnginePropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueueFamilyDataGraphProcessingEnginePropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, foreignSemaphoreHandleTypes, foreignMemoryHandleTypes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueueFamilyDataGraphProcessingEnginePropertiesARM const & ) const = default; -#else - bool operator==( QueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( foreignSemaphoreHandleTypes == rhs.foreignSemaphoreHandleTypes ) && - ( foreignMemoryHandleTypes == rhs.foreignMemoryHandleTypes ); -# endif - } - - bool operator!=( QueueFamilyDataGraphProcessingEnginePropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueueFamilyDataGraphProcessingEnginePropertiesARM; - void * pNext = {}; - ExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes = {}; - ExternalMemoryHandleTypeFlags foreignMemoryHandleTypes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueueFamilyDataGraphProcessingEnginePropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = QueueFamilyDataGraphProcessingEnginePropertiesARM; - }; - - // wrapper struct for struct VkQueueFamilyDataGraphPropertiesARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyDataGraphPropertiesARM.html - struct QueueFamilyDataGraphPropertiesARM - { - using NativeType = VkQueueFamilyDataGraphPropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyDataGraphPropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 QueueFamilyDataGraphPropertiesARM( PhysicalDeviceDataGraphProcessingEngineARM engine_ = {}, - PhysicalDeviceDataGraphOperationSupportARM operation_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , engine{ engine_ } - , operation{ operation_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 QueueFamilyDataGraphPropertiesARM( QueueFamilyDataGraphPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueueFamilyDataGraphPropertiesARM( VkQueueFamilyDataGraphPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : QueueFamilyDataGraphPropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - QueueFamilyDataGraphPropertiesARM & operator=( QueueFamilyDataGraphPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueueFamilyDataGraphPropertiesARM & operator=( VkQueueFamilyDataGraphPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkQueueFamilyDataGraphPropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyDataGraphPropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyDataGraphPropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueueFamilyDataGraphPropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, engine, operation ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueueFamilyDataGraphPropertiesARM const & ) const = default; -#else - bool operator==( QueueFamilyDataGraphPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( engine == rhs.engine ) && ( operation == rhs.operation ); -# endif - } - - bool operator!=( QueueFamilyDataGraphPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueueFamilyDataGraphPropertiesARM; - void * pNext = {}; - PhysicalDeviceDataGraphProcessingEngineARM engine = {}; - PhysicalDeviceDataGraphOperationSupportARM operation = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueueFamilyDataGraphPropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = QueueFamilyDataGraphPropertiesARM; - }; - - // wrapper struct for struct VkQueueFamilyGlobalPriorityProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyGlobalPriorityProperties.html - struct QueueFamilyGlobalPriorityProperties - { - using NativeType = VkQueueFamilyGlobalPriorityProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyGlobalPriorityProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 - QueueFamilyGlobalPriorityProperties( uint32_t priorityCount_ = {}, - std::array const & priorities_ = { { QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow, - QueueGlobalPriority::eLow } }, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , priorityCount{ priorityCount_ } - , priorities{ priorities_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 QueueFamilyGlobalPriorityProperties( QueueFamilyGlobalPriorityProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueueFamilyGlobalPriorityProperties( VkQueueFamilyGlobalPriorityProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : QueueFamilyGlobalPriorityProperties( *reinterpret_cast( &rhs ) ) - { - } - - QueueFamilyGlobalPriorityProperties & operator=( QueueFamilyGlobalPriorityProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueueFamilyGlobalPriorityProperties & operator=( VkQueueFamilyGlobalPriorityProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkQueueFamilyGlobalPriorityProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyGlobalPriorityProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyGlobalPriorityProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueueFamilyGlobalPriorityProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, priorityCount, priorities ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( QueueFamilyGlobalPriorityProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = priorityCount <=> rhs.priorityCount; cmp != 0 ) - return cmp; - for ( size_t i = 0; i < priorityCount; ++i ) - { - if ( auto cmp = priorities[i] <=> rhs.priorities[i]; cmp != 0 ) - return cmp; - } - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( QueueFamilyGlobalPriorityProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( priorityCount == rhs.priorityCount ) && - ( memcmp( priorities, rhs.priorities, priorityCount * sizeof( QueueGlobalPriority ) ) == 0 ); - } - - bool operator!=( QueueFamilyGlobalPriorityProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eQueueFamilyGlobalPriorityProperties; - void * pNext = {}; - uint32_t priorityCount = {}; - ArrayWrapper1D priorities = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueueFamilyGlobalPriorityProperties; - }; -#endif - - template <> - struct CppType - { - using Type = QueueFamilyGlobalPriorityProperties; - }; - - using QueueFamilyGlobalPriorityPropertiesEXT = QueueFamilyGlobalPriorityProperties; - using QueueFamilyGlobalPriorityPropertiesKHR = QueueFamilyGlobalPriorityProperties; - - // wrapper struct for struct VkQueueFamilyOwnershipTransferPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyOwnershipTransferPropertiesKHR.html - struct QueueFamilyOwnershipTransferPropertiesKHR - { - using NativeType = VkQueueFamilyOwnershipTransferPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyOwnershipTransferPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueueFamilyOwnershipTransferPropertiesKHR( uint32_t optimalImageTransferToQueueFamilies_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , optimalImageTransferToQueueFamilies{ optimalImageTransferToQueueFamilies_ } - { - } - - VULKAN_HPP_CONSTEXPR QueueFamilyOwnershipTransferPropertiesKHR( QueueFamilyOwnershipTransferPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueueFamilyOwnershipTransferPropertiesKHR( VkQueueFamilyOwnershipTransferPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : QueueFamilyOwnershipTransferPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - QueueFamilyOwnershipTransferPropertiesKHR & operator=( QueueFamilyOwnershipTransferPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueueFamilyOwnershipTransferPropertiesKHR & operator=( VkQueueFamilyOwnershipTransferPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkQueueFamilyOwnershipTransferPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyOwnershipTransferPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyOwnershipTransferPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueueFamilyOwnershipTransferPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, optimalImageTransferToQueueFamilies ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueueFamilyOwnershipTransferPropertiesKHR const & ) const = default; -#else - bool operator==( QueueFamilyOwnershipTransferPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( optimalImageTransferToQueueFamilies == rhs.optimalImageTransferToQueueFamilies ); -# endif - } - - bool operator!=( QueueFamilyOwnershipTransferPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueueFamilyOwnershipTransferPropertiesKHR; - void * pNext = {}; - uint32_t optimalImageTransferToQueueFamilies = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueueFamilyOwnershipTransferPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = QueueFamilyOwnershipTransferPropertiesKHR; - }; - - // wrapper struct for struct VkQueueFamilyProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyProperties.html - struct QueueFamilyProperties - { - using NativeType = VkQueueFamilyProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueueFamilyProperties( QueueFlags queueFlags_ = {}, - uint32_t queueCount_ = {}, - uint32_t timestampValidBits_ = {}, - Extent3D minImageTransferGranularity_ = {} ) VULKAN_HPP_NOEXCEPT - : queueFlags{ queueFlags_ } - , queueCount{ queueCount_ } - , timestampValidBits{ timestampValidBits_ } - , minImageTransferGranularity{ minImageTransferGranularity_ } - { - } - - VULKAN_HPP_CONSTEXPR QueueFamilyProperties( QueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueueFamilyProperties( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : QueueFamilyProperties( *reinterpret_cast( &rhs ) ) - { - } - - QueueFamilyProperties & operator=( QueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueueFamilyProperties & operator=( VkQueueFamilyProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkQueueFamilyProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueueFamilyProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( queueFlags, queueCount, timestampValidBits, minImageTransferGranularity ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueueFamilyProperties const & ) const = default; -#else - bool operator==( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( queueFlags == rhs.queueFlags ) && ( queueCount == rhs.queueCount ) && ( timestampValidBits == rhs.timestampValidBits ) && - ( minImageTransferGranularity == rhs.minImageTransferGranularity ); -# endif - } - - bool operator!=( QueueFamilyProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - QueueFlags queueFlags = {}; - uint32_t queueCount = {}; - uint32_t timestampValidBits = {}; - Extent3D minImageTransferGranularity = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueueFamilyProperties; - }; -#endif - - // wrapper struct for struct VkQueueFamilyProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyProperties2.html - struct QueueFamilyProperties2 - { - using NativeType = VkQueueFamilyProperties2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyProperties2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueueFamilyProperties2( QueueFamilyProperties queueFamilyProperties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , queueFamilyProperties{ queueFamilyProperties_ } - { - } - - VULKAN_HPP_CONSTEXPR QueueFamilyProperties2( QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueueFamilyProperties2( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : QueueFamilyProperties2( *reinterpret_cast( &rhs ) ) - { - } - - QueueFamilyProperties2 & operator=( QueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueueFamilyProperties2 & operator=( VkQueueFamilyProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkQueueFamilyProperties2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyProperties2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyProperties2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueueFamilyProperties2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, queueFamilyProperties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueueFamilyProperties2 const & ) const = default; -#else - bool operator==( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyProperties == rhs.queueFamilyProperties ); -# endif - } - - bool operator!=( QueueFamilyProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueueFamilyProperties2; - void * pNext = {}; - QueueFamilyProperties queueFamilyProperties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueueFamilyProperties2; - }; -#endif - - template <> - struct CppType - { - using Type = QueueFamilyProperties2; - }; - - using QueueFamilyProperties2KHR = QueueFamilyProperties2; - - // wrapper struct for struct VkQueueFamilyQueryResultStatusPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyQueryResultStatusPropertiesKHR.html - struct QueueFamilyQueryResultStatusPropertiesKHR - { - using NativeType = VkQueueFamilyQueryResultStatusPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyQueryResultStatusPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueueFamilyQueryResultStatusPropertiesKHR( Bool32 queryResultStatusSupport_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , queryResultStatusSupport{ queryResultStatusSupport_ } - { - } - - VULKAN_HPP_CONSTEXPR QueueFamilyQueryResultStatusPropertiesKHR( QueueFamilyQueryResultStatusPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueueFamilyQueryResultStatusPropertiesKHR( VkQueueFamilyQueryResultStatusPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : QueueFamilyQueryResultStatusPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - QueueFamilyQueryResultStatusPropertiesKHR & operator=( QueueFamilyQueryResultStatusPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueueFamilyQueryResultStatusPropertiesKHR & operator=( VkQueueFamilyQueryResultStatusPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkQueueFamilyQueryResultStatusPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyQueryResultStatusPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyQueryResultStatusPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueueFamilyQueryResultStatusPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, queryResultStatusSupport ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueueFamilyQueryResultStatusPropertiesKHR const & ) const = default; -#else - bool operator==( QueueFamilyQueryResultStatusPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queryResultStatusSupport == rhs.queryResultStatusSupport ); -# endif - } - - bool operator!=( QueueFamilyQueryResultStatusPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueueFamilyQueryResultStatusPropertiesKHR; - void * pNext = {}; - Bool32 queryResultStatusSupport = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueueFamilyQueryResultStatusPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = QueueFamilyQueryResultStatusPropertiesKHR; - }; - - // wrapper struct for struct VkQueueFamilyVideoPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkQueueFamilyVideoPropertiesKHR.html - struct QueueFamilyVideoPropertiesKHR - { - using NativeType = VkQueueFamilyVideoPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eQueueFamilyVideoPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR QueueFamilyVideoPropertiesKHR( VideoCodecOperationFlagsKHR videoCodecOperations_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoCodecOperations{ videoCodecOperations_ } - { - } - - VULKAN_HPP_CONSTEXPR QueueFamilyVideoPropertiesKHR( QueueFamilyVideoPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - QueueFamilyVideoPropertiesKHR( VkQueueFamilyVideoPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : QueueFamilyVideoPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - QueueFamilyVideoPropertiesKHR & operator=( QueueFamilyVideoPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - QueueFamilyVideoPropertiesKHR & operator=( VkQueueFamilyVideoPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkQueueFamilyVideoPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyVideoPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkQueueFamilyVideoPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkQueueFamilyVideoPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoCodecOperations ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( QueueFamilyVideoPropertiesKHR const & ) const = default; -#else - bool operator==( QueueFamilyVideoPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoCodecOperations == rhs.videoCodecOperations ); -# endif - } - - bool operator!=( QueueFamilyVideoPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eQueueFamilyVideoPropertiesKHR; - void * pNext = {}; - VideoCodecOperationFlagsKHR videoCodecOperations = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = QueueFamilyVideoPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = QueueFamilyVideoPropertiesKHR; - }; - - // wrapper struct for struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV.html - struct RayTracingPipelineClusterAccelerationStructureCreateInfoNV - { - using NativeType = VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineClusterAccelerationStructureCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RayTracingPipelineClusterAccelerationStructureCreateInfoNV( Bool32 allowClusterAccelerationStructure_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , allowClusterAccelerationStructure{ allowClusterAccelerationStructure_ } - { - } - - VULKAN_HPP_CONSTEXPR RayTracingPipelineClusterAccelerationStructureCreateInfoNV( RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - RayTracingPipelineClusterAccelerationStructureCreateInfoNV( VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : RayTracingPipelineClusterAccelerationStructureCreateInfoNV( - *reinterpret_cast( &rhs ) ) - { - } - - RayTracingPipelineClusterAccelerationStructureCreateInfoNV & - operator=( RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RayTracingPipelineClusterAccelerationStructureCreateInfoNV & - operator=( VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineClusterAccelerationStructureCreateInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineClusterAccelerationStructureCreateInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineClusterAccelerationStructureCreateInfoNV & - setAllowClusterAccelerationStructure( Bool32 allowClusterAccelerationStructure_ ) & - VULKAN_HPP_NOEXCEPT - { - allowClusterAccelerationStructure = allowClusterAccelerationStructure_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineClusterAccelerationStructureCreateInfoNV && - setAllowClusterAccelerationStructure( Bool32 allowClusterAccelerationStructure_ ) && - VULKAN_HPP_NOEXCEPT - { - allowClusterAccelerationStructure = allowClusterAccelerationStructure_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, allowClusterAccelerationStructure ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & ) const = default; -#else - bool operator==( RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allowClusterAccelerationStructure == rhs.allowClusterAccelerationStructure ); -# endif - } - - bool operator!=( RayTracingPipelineClusterAccelerationStructureCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRayTracingPipelineClusterAccelerationStructureCreateInfoNV; - void * pNext = {}; - Bool32 allowClusterAccelerationStructure = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RayTracingPipelineClusterAccelerationStructureCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = RayTracingPipelineClusterAccelerationStructureCreateInfoNV; - }; - - // wrapper struct for struct VkRayTracingShaderGroupCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingShaderGroupCreateInfoKHR.html - struct RayTracingShaderGroupCreateInfoKHR - { - using NativeType = VkRayTracingShaderGroupCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingShaderGroupCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoKHR( RayTracingShaderGroupTypeKHR type_ = RayTracingShaderGroupTypeKHR::eGeneral, - uint32_t generalShader_ = ShaderUnusedKHR, - uint32_t closestHitShader_ = ShaderUnusedKHR, - uint32_t anyHitShader_ = ShaderUnusedKHR, - uint32_t intersectionShader_ = ShaderUnusedKHR, - const void * pShaderGroupCaptureReplayHandle_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , generalShader{ generalShader_ } - , closestHitShader{ closestHitShader_ } - , anyHitShader{ anyHitShader_ } - , intersectionShader{ intersectionShader_ } - , pShaderGroupCaptureReplayHandle{ pShaderGroupCaptureReplayHandle_ } - { - } - - VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoKHR( RayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RayTracingShaderGroupCreateInfoKHR( VkRayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : RayTracingShaderGroupCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - RayTracingShaderGroupCreateInfoKHR & operator=( RayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RayTracingShaderGroupCreateInfoKHR & operator=( VkRayTracingShaderGroupCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setType( RayTracingShaderGroupTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setType( RayTracingShaderGroupTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setGeneralShader( uint32_t generalShader_ ) & VULKAN_HPP_NOEXCEPT - { - generalShader = generalShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setGeneralShader( uint32_t generalShader_ ) && VULKAN_HPP_NOEXCEPT - { - generalShader = generalShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setClosestHitShader( uint32_t closestHitShader_ ) & VULKAN_HPP_NOEXCEPT - { - closestHitShader = closestHitShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setClosestHitShader( uint32_t closestHitShader_ ) && VULKAN_HPP_NOEXCEPT - { - closestHitShader = closestHitShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setAnyHitShader( uint32_t anyHitShader_ ) & VULKAN_HPP_NOEXCEPT - { - anyHitShader = anyHitShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setAnyHitShader( uint32_t anyHitShader_ ) && VULKAN_HPP_NOEXCEPT - { - anyHitShader = anyHitShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setIntersectionShader( uint32_t intersectionShader_ ) & VULKAN_HPP_NOEXCEPT - { - intersectionShader = intersectionShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setIntersectionShader( uint32_t intersectionShader_ ) && VULKAN_HPP_NOEXCEPT - { - intersectionShader = intersectionShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR & setPShaderGroupCaptureReplayHandle( const void * pShaderGroupCaptureReplayHandle_ ) & - VULKAN_HPP_NOEXCEPT - { - pShaderGroupCaptureReplayHandle = pShaderGroupCaptureReplayHandle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoKHR && setPShaderGroupCaptureReplayHandle( const void * pShaderGroupCaptureReplayHandle_ ) && - VULKAN_HPP_NOEXCEPT - { - pShaderGroupCaptureReplayHandle = pShaderGroupCaptureReplayHandle_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRayTracingShaderGroupCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingShaderGroupCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingShaderGroupCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRayTracingShaderGroupCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader, pShaderGroupCaptureReplayHandle ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RayTracingShaderGroupCreateInfoKHR const & ) const = default; -#else - bool operator==( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( generalShader == rhs.generalShader ) && - ( closestHitShader == rhs.closestHitShader ) && ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ) && - ( pShaderGroupCaptureReplayHandle == rhs.pShaderGroupCaptureReplayHandle ); -# endif - } - - bool operator!=( RayTracingShaderGroupCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoKHR; - const void * pNext = {}; - RayTracingShaderGroupTypeKHR type = RayTracingShaderGroupTypeKHR::eGeneral; - uint32_t generalShader = ShaderUnusedKHR; - uint32_t closestHitShader = ShaderUnusedKHR; - uint32_t anyHitShader = ShaderUnusedKHR; - uint32_t intersectionShader = ShaderUnusedKHR; - const void * pShaderGroupCaptureReplayHandle = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RayTracingShaderGroupCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = RayTracingShaderGroupCreateInfoKHR; - }; - - // wrapper struct for struct VkRayTracingPipelineInterfaceCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingPipelineInterfaceCreateInfoKHR.html - struct RayTracingPipelineInterfaceCreateInfoKHR - { - using NativeType = VkRayTracingPipelineInterfaceCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineInterfaceCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RayTracingPipelineInterfaceCreateInfoKHR( uint32_t maxPipelineRayPayloadSize_ = {}, - uint32_t maxPipelineRayHitAttributeSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxPipelineRayPayloadSize{ maxPipelineRayPayloadSize_ } - , maxPipelineRayHitAttributeSize{ maxPipelineRayHitAttributeSize_ } - { - } - - VULKAN_HPP_CONSTEXPR RayTracingPipelineInterfaceCreateInfoKHR( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RayTracingPipelineInterfaceCreateInfoKHR( VkRayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : RayTracingPipelineInterfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - RayTracingPipelineInterfaceCreateInfoKHR & operator=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RayTracingPipelineInterfaceCreateInfoKHR & operator=( VkRayTracingPipelineInterfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR & setMaxPipelineRayPayloadSize( uint32_t maxPipelineRayPayloadSize_ ) & VULKAN_HPP_NOEXCEPT - { - maxPipelineRayPayloadSize = maxPipelineRayPayloadSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR && setMaxPipelineRayPayloadSize( uint32_t maxPipelineRayPayloadSize_ ) && - VULKAN_HPP_NOEXCEPT - { - maxPipelineRayPayloadSize = maxPipelineRayPayloadSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR & setMaxPipelineRayHitAttributeSize( uint32_t maxPipelineRayHitAttributeSize_ ) & - VULKAN_HPP_NOEXCEPT - { - maxPipelineRayHitAttributeSize = maxPipelineRayHitAttributeSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineInterfaceCreateInfoKHR && setMaxPipelineRayHitAttributeSize( uint32_t maxPipelineRayHitAttributeSize_ ) && - VULKAN_HPP_NOEXCEPT - { - maxPipelineRayHitAttributeSize = maxPipelineRayHitAttributeSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRayTracingPipelineInterfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingPipelineInterfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingPipelineInterfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRayTracingPipelineInterfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxPipelineRayPayloadSize, maxPipelineRayHitAttributeSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RayTracingPipelineInterfaceCreateInfoKHR const & ) const = default; -#else - bool operator==( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxPipelineRayPayloadSize == rhs.maxPipelineRayPayloadSize ) && - ( maxPipelineRayHitAttributeSize == rhs.maxPipelineRayHitAttributeSize ); -# endif - } - - bool operator!=( RayTracingPipelineInterfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRayTracingPipelineInterfaceCreateInfoKHR; - const void * pNext = {}; - uint32_t maxPipelineRayPayloadSize = {}; - uint32_t maxPipelineRayHitAttributeSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RayTracingPipelineInterfaceCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = RayTracingPipelineInterfaceCreateInfoKHR; - }; - - // wrapper struct for struct VkRayTracingPipelineCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingPipelineCreateInfoKHR.html - struct RayTracingPipelineCreateInfoKHR - { - using NativeType = VkRayTracingPipelineCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoKHR( PipelineCreateFlags flags_ = {}, - uint32_t stageCount_ = {}, - const PipelineShaderStageCreateInfo * pStages_ = {}, - uint32_t groupCount_ = {}, - const RayTracingShaderGroupCreateInfoKHR * pGroups_ = {}, - uint32_t maxPipelineRayRecursionDepth_ = {}, - const PipelineLibraryCreateInfoKHR * pLibraryInfo_ = {}, - const RayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface_ = {}, - const PipelineDynamicStateCreateInfo * pDynamicState_ = {}, - PipelineLayout layout_ = {}, - Pipeline basePipelineHandle_ = {}, - int32_t basePipelineIndex_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , stageCount{ stageCount_ } - , pStages{ pStages_ } - , groupCount{ groupCount_ } - , pGroups{ pGroups_ } - , maxPipelineRayRecursionDepth{ maxPipelineRayRecursionDepth_ } - , pLibraryInfo{ pLibraryInfo_ } - , pLibraryInterface{ pLibraryInterface_ } - , pDynamicState{ pDynamicState_ } - , layout{ layout_ } - , basePipelineHandle{ basePipelineHandle_ } - , basePipelineIndex{ basePipelineIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoKHR( RayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RayTracingPipelineCreateInfoKHR( VkRayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : RayTracingPipelineCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RayTracingPipelineCreateInfoKHR( PipelineCreateFlags flags_, - ArrayProxyNoTemporaries const & stages_, - ArrayProxyNoTemporaries const & groups_ = {}, - uint32_t maxPipelineRayRecursionDepth_ = {}, - const PipelineLibraryCreateInfoKHR * pLibraryInfo_ = {}, - const RayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface_ = {}, - const PipelineDynamicStateCreateInfo * pDynamicState_ = {}, - PipelineLayout layout_ = {}, - Pipeline basePipelineHandle_ = {}, - int32_t basePipelineIndex_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , stageCount( static_cast( stages_.size() ) ) - , pStages( stages_.data() ) - , groupCount( static_cast( groups_.size() ) ) - , pGroups( groups_.data() ) - , maxPipelineRayRecursionDepth( maxPipelineRayRecursionDepth_ ) - , pLibraryInfo( pLibraryInfo_ ) - , pLibraryInterface( pLibraryInterface_ ) - , pDynamicState( pDynamicState_ ) - , layout( layout_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RayTracingPipelineCreateInfoKHR & operator=( RayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RayTracingPipelineCreateInfoKHR & operator=( VkRayTracingPipelineCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setFlags( PipelineCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setFlags( PipelineCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setStageCount( uint32_t stageCount_ ) & VULKAN_HPP_NOEXCEPT - { - stageCount = stageCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setStageCount( uint32_t stageCount_ ) && VULKAN_HPP_NOEXCEPT - { - stageCount = stageCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPStages( const PipelineShaderStageCreateInfo * pStages_ ) & VULKAN_HPP_NOEXCEPT - { - pStages = pStages_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPStages( const PipelineShaderStageCreateInfo * pStages_ ) && VULKAN_HPP_NOEXCEPT - { - pStages = pStages_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RayTracingPipelineCreateInfoKHR & setStages( ArrayProxyNoTemporaries const & stages_ ) VULKAN_HPP_NOEXCEPT - { - stageCount = static_cast( stages_.size() ); - pStages = stages_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setGroupCount( uint32_t groupCount_ ) & VULKAN_HPP_NOEXCEPT - { - groupCount = groupCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setGroupCount( uint32_t groupCount_ ) && VULKAN_HPP_NOEXCEPT - { - groupCount = groupCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPGroups( const RayTracingShaderGroupCreateInfoKHR * pGroups_ ) & VULKAN_HPP_NOEXCEPT - { - pGroups = pGroups_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPGroups( const RayTracingShaderGroupCreateInfoKHR * pGroups_ ) && VULKAN_HPP_NOEXCEPT - { - pGroups = pGroups_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RayTracingPipelineCreateInfoKHR & setGroups( ArrayProxyNoTemporaries const & groups_ ) VULKAN_HPP_NOEXCEPT - { - groupCount = static_cast( groups_.size() ); - pGroups = groups_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setMaxPipelineRayRecursionDepth( uint32_t maxPipelineRayRecursionDepth_ ) & VULKAN_HPP_NOEXCEPT - { - maxPipelineRayRecursionDepth = maxPipelineRayRecursionDepth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setMaxPipelineRayRecursionDepth( uint32_t maxPipelineRayRecursionDepth_ ) && VULKAN_HPP_NOEXCEPT - { - maxPipelineRayRecursionDepth = maxPipelineRayRecursionDepth_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPLibraryInfo( const PipelineLibraryCreateInfoKHR * pLibraryInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pLibraryInfo = pLibraryInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPLibraryInfo( const PipelineLibraryCreateInfoKHR * pLibraryInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pLibraryInfo = pLibraryInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPLibraryInterface( const RayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface_ ) & - VULKAN_HPP_NOEXCEPT - { - pLibraryInterface = pLibraryInterface_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPLibraryInterface( const RayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface_ ) && - VULKAN_HPP_NOEXCEPT - { - pLibraryInterface = pLibraryInterface_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setPDynamicState( const PipelineDynamicStateCreateInfo * pDynamicState_ ) & VULKAN_HPP_NOEXCEPT - { - pDynamicState = pDynamicState_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setPDynamicState( const PipelineDynamicStateCreateInfo * pDynamicState_ ) && VULKAN_HPP_NOEXCEPT - { - pDynamicState = pDynamicState_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setBasePipelineHandle( Pipeline basePipelineHandle_ ) & VULKAN_HPP_NOEXCEPT - { - basePipelineHandle = basePipelineHandle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setBasePipelineHandle( Pipeline basePipelineHandle_ ) && VULKAN_HPP_NOEXCEPT - { - basePipelineHandle = basePipelineHandle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR & setBasePipelineIndex( int32_t basePipelineIndex_ ) & VULKAN_HPP_NOEXCEPT - { - basePipelineIndex = basePipelineIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoKHR && setBasePipelineIndex( int32_t basePipelineIndex_ ) && VULKAN_HPP_NOEXCEPT - { - basePipelineIndex = basePipelineIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRayTracingPipelineCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingPipelineCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingPipelineCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRayTracingPipelineCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - stageCount, - pStages, - groupCount, - pGroups, - maxPipelineRayRecursionDepth, - pLibraryInfo, - pLibraryInterface, - pDynamicState, - layout, - basePipelineHandle, - basePipelineIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RayTracingPipelineCreateInfoKHR const & ) const = default; -#else - bool operator==( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && - ( groupCount == rhs.groupCount ) && ( pGroups == rhs.pGroups ) && ( maxPipelineRayRecursionDepth == rhs.maxPipelineRayRecursionDepth ) && - ( pLibraryInfo == rhs.pLibraryInfo ) && ( pLibraryInterface == rhs.pLibraryInterface ) && ( pDynamicState == rhs.pDynamicState ) && - ( layout == rhs.layout ) && ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex ); -# endif - } - - bool operator!=( RayTracingPipelineCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRayTracingPipelineCreateInfoKHR; - const void * pNext = {}; - PipelineCreateFlags flags = {}; - uint32_t stageCount = {}; - const PipelineShaderStageCreateInfo * pStages = {}; - uint32_t groupCount = {}; - const RayTracingShaderGroupCreateInfoKHR * pGroups = {}; - uint32_t maxPipelineRayRecursionDepth = {}; - const PipelineLibraryCreateInfoKHR * pLibraryInfo = {}; - const RayTracingPipelineInterfaceCreateInfoKHR * pLibraryInterface = {}; - const PipelineDynamicStateCreateInfo * pDynamicState = {}; - PipelineLayout layout = {}; - Pipeline basePipelineHandle = {}; - int32_t basePipelineIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RayTracingPipelineCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = RayTracingPipelineCreateInfoKHR; - }; - - // wrapper struct for struct VkRayTracingShaderGroupCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingShaderGroupCreateInfoNV.html - struct RayTracingShaderGroupCreateInfoNV - { - using NativeType = VkRayTracingShaderGroupCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingShaderGroupCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupTypeKHR type_ = RayTracingShaderGroupTypeKHR::eGeneral, - uint32_t generalShader_ = ShaderUnusedNV, - uint32_t closestHitShader_ = ShaderUnusedNV, - uint32_t anyHitShader_ = ShaderUnusedNV, - uint32_t intersectionShader_ = ShaderUnusedNV, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , generalShader{ generalShader_ } - , closestHitShader{ closestHitShader_ } - , anyHitShader{ anyHitShader_ } - , intersectionShader{ intersectionShader_ } - { - } - - VULKAN_HPP_CONSTEXPR RayTracingShaderGroupCreateInfoNV( RayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RayTracingShaderGroupCreateInfoNV( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : RayTracingShaderGroupCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - RayTracingShaderGroupCreateInfoNV & operator=( RayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RayTracingShaderGroupCreateInfoNV & operator=( VkRayTracingShaderGroupCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setType( RayTracingShaderGroupTypeKHR type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setType( RayTracingShaderGroupTypeKHR type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setGeneralShader( uint32_t generalShader_ ) & VULKAN_HPP_NOEXCEPT - { - generalShader = generalShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setGeneralShader( uint32_t generalShader_ ) && VULKAN_HPP_NOEXCEPT - { - generalShader = generalShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setClosestHitShader( uint32_t closestHitShader_ ) & VULKAN_HPP_NOEXCEPT - { - closestHitShader = closestHitShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setClosestHitShader( uint32_t closestHitShader_ ) && VULKAN_HPP_NOEXCEPT - { - closestHitShader = closestHitShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setAnyHitShader( uint32_t anyHitShader_ ) & VULKAN_HPP_NOEXCEPT - { - anyHitShader = anyHitShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setAnyHitShader( uint32_t anyHitShader_ ) && VULKAN_HPP_NOEXCEPT - { - anyHitShader = anyHitShader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV & setIntersectionShader( uint32_t intersectionShader_ ) & VULKAN_HPP_NOEXCEPT - { - intersectionShader = intersectionShader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingShaderGroupCreateInfoNV && setIntersectionShader( uint32_t intersectionShader_ ) && VULKAN_HPP_NOEXCEPT - { - intersectionShader = intersectionShader_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRayTracingShaderGroupCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingShaderGroupCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingShaderGroupCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRayTracingShaderGroupCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, type, generalShader, closestHitShader, anyHitShader, intersectionShader ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RayTracingShaderGroupCreateInfoNV const & ) const = default; -#else - bool operator==( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( type == rhs.type ) && ( generalShader == rhs.generalShader ) && - ( closestHitShader == rhs.closestHitShader ) && ( anyHitShader == rhs.anyHitShader ) && ( intersectionShader == rhs.intersectionShader ); -# endif - } - - bool operator!=( RayTracingShaderGroupCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRayTracingShaderGroupCreateInfoNV; - const void * pNext = {}; - RayTracingShaderGroupTypeKHR type = RayTracingShaderGroupTypeKHR::eGeneral; - uint32_t generalShader = ShaderUnusedNV; - uint32_t closestHitShader = ShaderUnusedNV; - uint32_t anyHitShader = ShaderUnusedNV; - uint32_t intersectionShader = ShaderUnusedNV; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RayTracingShaderGroupCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = RayTracingShaderGroupCreateInfoNV; - }; - - // wrapper struct for struct VkRayTracingPipelineCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRayTracingPipelineCreateInfoNV.html - struct RayTracingPipelineCreateInfoNV - { - using NativeType = VkRayTracingPipelineCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRayTracingPipelineCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( PipelineCreateFlags flags_ = {}, - uint32_t stageCount_ = {}, - const PipelineShaderStageCreateInfo * pStages_ = {}, - uint32_t groupCount_ = {}, - const RayTracingShaderGroupCreateInfoNV * pGroups_ = {}, - uint32_t maxRecursionDepth_ = {}, - PipelineLayout layout_ = {}, - Pipeline basePipelineHandle_ = {}, - int32_t basePipelineIndex_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , stageCount{ stageCount_ } - , pStages{ pStages_ } - , groupCount{ groupCount_ } - , pGroups{ pGroups_ } - , maxRecursionDepth{ maxRecursionDepth_ } - , layout{ layout_ } - , basePipelineHandle{ basePipelineHandle_ } - , basePipelineIndex{ basePipelineIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR RayTracingPipelineCreateInfoNV( RayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RayTracingPipelineCreateInfoNV( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : RayTracingPipelineCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RayTracingPipelineCreateInfoNV( PipelineCreateFlags flags_, - ArrayProxyNoTemporaries const & stages_, - ArrayProxyNoTemporaries const & groups_ = {}, - uint32_t maxRecursionDepth_ = {}, - PipelineLayout layout_ = {}, - Pipeline basePipelineHandle_ = {}, - int32_t basePipelineIndex_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , stageCount( static_cast( stages_.size() ) ) - , pStages( stages_.data() ) - , groupCount( static_cast( groups_.size() ) ) - , pGroups( groups_.data() ) - , maxRecursionDepth( maxRecursionDepth_ ) - , layout( layout_ ) - , basePipelineHandle( basePipelineHandle_ ) - , basePipelineIndex( basePipelineIndex_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RayTracingPipelineCreateInfoNV & operator=( RayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RayTracingPipelineCreateInfoNV & operator=( VkRayTracingPipelineCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setFlags( PipelineCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setFlags( PipelineCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setStageCount( uint32_t stageCount_ ) & VULKAN_HPP_NOEXCEPT - { - stageCount = stageCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setStageCount( uint32_t stageCount_ ) && VULKAN_HPP_NOEXCEPT - { - stageCount = stageCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setPStages( const PipelineShaderStageCreateInfo * pStages_ ) & VULKAN_HPP_NOEXCEPT - { - pStages = pStages_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setPStages( const PipelineShaderStageCreateInfo * pStages_ ) && VULKAN_HPP_NOEXCEPT - { - pStages = pStages_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RayTracingPipelineCreateInfoNV & setStages( ArrayProxyNoTemporaries const & stages_ ) VULKAN_HPP_NOEXCEPT - { - stageCount = static_cast( stages_.size() ); - pStages = stages_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setGroupCount( uint32_t groupCount_ ) & VULKAN_HPP_NOEXCEPT - { - groupCount = groupCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setGroupCount( uint32_t groupCount_ ) && VULKAN_HPP_NOEXCEPT - { - groupCount = groupCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setPGroups( const RayTracingShaderGroupCreateInfoNV * pGroups_ ) & VULKAN_HPP_NOEXCEPT - { - pGroups = pGroups_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setPGroups( const RayTracingShaderGroupCreateInfoNV * pGroups_ ) && VULKAN_HPP_NOEXCEPT - { - pGroups = pGroups_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RayTracingPipelineCreateInfoNV & setGroups( ArrayProxyNoTemporaries const & groups_ ) VULKAN_HPP_NOEXCEPT - { - groupCount = static_cast( groups_.size() ); - pGroups = groups_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setMaxRecursionDepth( uint32_t maxRecursionDepth_ ) & VULKAN_HPP_NOEXCEPT - { - maxRecursionDepth = maxRecursionDepth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setMaxRecursionDepth( uint32_t maxRecursionDepth_ ) && VULKAN_HPP_NOEXCEPT - { - maxRecursionDepth = maxRecursionDepth_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setBasePipelineHandle( Pipeline basePipelineHandle_ ) & VULKAN_HPP_NOEXCEPT - { - basePipelineHandle = basePipelineHandle_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setBasePipelineHandle( Pipeline basePipelineHandle_ ) && VULKAN_HPP_NOEXCEPT - { - basePipelineHandle = basePipelineHandle_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV & setBasePipelineIndex( int32_t basePipelineIndex_ ) & VULKAN_HPP_NOEXCEPT - { - basePipelineIndex = basePipelineIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RayTracingPipelineCreateInfoNV && setBasePipelineIndex( int32_t basePipelineIndex_ ) && VULKAN_HPP_NOEXCEPT - { - basePipelineIndex = basePipelineIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRayTracingPipelineCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingPipelineCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRayTracingPipelineCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRayTracingPipelineCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, stageCount, pStages, groupCount, pGroups, maxRecursionDepth, layout, basePipelineHandle, basePipelineIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RayTracingPipelineCreateInfoNV const & ) const = default; -#else - bool operator==( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stageCount == rhs.stageCount ) && ( pStages == rhs.pStages ) && - ( groupCount == rhs.groupCount ) && ( pGroups == rhs.pGroups ) && ( maxRecursionDepth == rhs.maxRecursionDepth ) && ( layout == rhs.layout ) && - ( basePipelineHandle == rhs.basePipelineHandle ) && ( basePipelineIndex == rhs.basePipelineIndex ); -# endif - } - - bool operator!=( RayTracingPipelineCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRayTracingPipelineCreateInfoNV; - const void * pNext = {}; - PipelineCreateFlags flags = {}; - uint32_t stageCount = {}; - const PipelineShaderStageCreateInfo * pStages = {}; - uint32_t groupCount = {}; - const RayTracingShaderGroupCreateInfoNV * pGroups = {}; - uint32_t maxRecursionDepth = {}; - PipelineLayout layout = {}; - Pipeline basePipelineHandle = {}; - int32_t basePipelineIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RayTracingPipelineCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = RayTracingPipelineCreateInfoNV; - }; - - // wrapper struct for struct VkRefreshCycleDurationGOOGLE, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRefreshCycleDurationGOOGLE.html - struct RefreshCycleDurationGOOGLE - { - using NativeType = VkRefreshCycleDurationGOOGLE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RefreshCycleDurationGOOGLE( uint64_t refreshDuration_ = {} ) VULKAN_HPP_NOEXCEPT : refreshDuration{ refreshDuration_ } {} - - VULKAN_HPP_CONSTEXPR RefreshCycleDurationGOOGLE( RefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RefreshCycleDurationGOOGLE( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - : RefreshCycleDurationGOOGLE( *reinterpret_cast( &rhs ) ) - { - } - - RefreshCycleDurationGOOGLE & operator=( RefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RefreshCycleDurationGOOGLE & operator=( VkRefreshCycleDurationGOOGLE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkRefreshCycleDurationGOOGLE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRefreshCycleDurationGOOGLE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRefreshCycleDurationGOOGLE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRefreshCycleDurationGOOGLE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( refreshDuration ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RefreshCycleDurationGOOGLE const & ) const = default; -#else - bool operator==( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( refreshDuration == rhs.refreshDuration ); -# endif - } - - bool operator!=( RefreshCycleDurationGOOGLE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint64_t refreshDuration = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RefreshCycleDurationGOOGLE; - }; -#endif - - // wrapper struct for struct VkReleaseCapturedPipelineDataInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkReleaseCapturedPipelineDataInfoKHR.html - struct ReleaseCapturedPipelineDataInfoKHR - { - using NativeType = VkReleaseCapturedPipelineDataInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eReleaseCapturedPipelineDataInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ReleaseCapturedPipelineDataInfoKHR( Pipeline pipeline_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pipeline{ pipeline_ } - { - } - - VULKAN_HPP_CONSTEXPR ReleaseCapturedPipelineDataInfoKHR( ReleaseCapturedPipelineDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ReleaseCapturedPipelineDataInfoKHR( VkReleaseCapturedPipelineDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ReleaseCapturedPipelineDataInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ReleaseCapturedPipelineDataInfoKHR & operator=( ReleaseCapturedPipelineDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ReleaseCapturedPipelineDataInfoKHR & operator=( VkReleaseCapturedPipelineDataInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ReleaseCapturedPipelineDataInfoKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ReleaseCapturedPipelineDataInfoKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ReleaseCapturedPipelineDataInfoKHR & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ReleaseCapturedPipelineDataInfoKHR && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkReleaseCapturedPipelineDataInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkReleaseCapturedPipelineDataInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkReleaseCapturedPipelineDataInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkReleaseCapturedPipelineDataInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pipeline ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ReleaseCapturedPipelineDataInfoKHR const & ) const = default; -#else - bool operator==( ReleaseCapturedPipelineDataInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pipeline == rhs.pipeline ); -# endif - } - - bool operator!=( ReleaseCapturedPipelineDataInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eReleaseCapturedPipelineDataInfoKHR; - void * pNext = {}; - Pipeline pipeline = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ReleaseCapturedPipelineDataInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = ReleaseCapturedPipelineDataInfoKHR; - }; - - // wrapper struct for struct VkReleaseSwapchainImagesInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkReleaseSwapchainImagesInfoKHR.html - struct ReleaseSwapchainImagesInfoKHR - { - using NativeType = VkReleaseSwapchainImagesInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eReleaseSwapchainImagesInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ReleaseSwapchainImagesInfoKHR( SwapchainKHR swapchain_ = {}, - uint32_t imageIndexCount_ = {}, - const uint32_t * pImageIndices_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchain{ swapchain_ } - , imageIndexCount{ imageIndexCount_ } - , pImageIndices{ pImageIndices_ } - { - } - - VULKAN_HPP_CONSTEXPR ReleaseSwapchainImagesInfoKHR( ReleaseSwapchainImagesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ReleaseSwapchainImagesInfoKHR( VkReleaseSwapchainImagesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ReleaseSwapchainImagesInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ReleaseSwapchainImagesInfoKHR( SwapchainKHR swapchain_, ArrayProxyNoTemporaries const & imageIndices_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), swapchain( swapchain_ ), imageIndexCount( static_cast( imageIndices_.size() ) ), pImageIndices( imageIndices_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ReleaseSwapchainImagesInfoKHR & operator=( ReleaseSwapchainImagesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ReleaseSwapchainImagesInfoKHR & operator=( VkReleaseSwapchainImagesInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR & setImageIndexCount( uint32_t imageIndexCount_ ) & VULKAN_HPP_NOEXCEPT - { - imageIndexCount = imageIndexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR && setImageIndexCount( uint32_t imageIndexCount_ ) && VULKAN_HPP_NOEXCEPT - { - imageIndexCount = imageIndexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR & setPImageIndices( const uint32_t * pImageIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pImageIndices = pImageIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ReleaseSwapchainImagesInfoKHR && setPImageIndices( const uint32_t * pImageIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pImageIndices = pImageIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ReleaseSwapchainImagesInfoKHR & setImageIndices( ArrayProxyNoTemporaries const & imageIndices_ ) VULKAN_HPP_NOEXCEPT - { - imageIndexCount = static_cast( imageIndices_.size() ); - pImageIndices = imageIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkReleaseSwapchainImagesInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkReleaseSwapchainImagesInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkReleaseSwapchainImagesInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkReleaseSwapchainImagesInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchain, imageIndexCount, pImageIndices ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ReleaseSwapchainImagesInfoKHR const & ) const = default; -#else - bool operator==( ReleaseSwapchainImagesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( imageIndexCount == rhs.imageIndexCount ) && - ( pImageIndices == rhs.pImageIndices ); -# endif - } - - bool operator!=( ReleaseSwapchainImagesInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eReleaseSwapchainImagesInfoKHR; - const void * pNext = {}; - SwapchainKHR swapchain = {}; - uint32_t imageIndexCount = {}; - const uint32_t * pImageIndices = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ReleaseSwapchainImagesInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = ReleaseSwapchainImagesInfoKHR; - }; - - using ReleaseSwapchainImagesInfoEXT = ReleaseSwapchainImagesInfoKHR; - - // wrapper struct for struct VkRenderPassAttachmentBeginInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassAttachmentBeginInfo.html - struct RenderPassAttachmentBeginInfo - { - using NativeType = VkRenderPassAttachmentBeginInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassAttachmentBeginInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - RenderPassAttachmentBeginInfo( uint32_t attachmentCount_ = {}, const ImageView * pAttachments_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , attachmentCount{ attachmentCount_ } - , pAttachments{ pAttachments_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassAttachmentBeginInfo( RenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassAttachmentBeginInfo( VkRenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassAttachmentBeginInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassAttachmentBeginInfo( ArrayProxyNoTemporaries const & attachments_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), attachmentCount( static_cast( attachments_.size() ) ), pAttachments( attachments_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderPassAttachmentBeginInfo & operator=( RenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassAttachmentBeginInfo & operator=( VkRenderPassAttachmentBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo & setPAttachments( const ImageView * pAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pAttachments = pAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassAttachmentBeginInfo && setPAttachments( const ImageView * pAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pAttachments = pAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassAttachmentBeginInfo & setAttachments( ArrayProxyNoTemporaries const & attachments_ ) VULKAN_HPP_NOEXCEPT - { - attachmentCount = static_cast( attachments_.size() ); - pAttachments = attachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassAttachmentBeginInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassAttachmentBeginInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassAttachmentBeginInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassAttachmentBeginInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, attachmentCount, pAttachments ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassAttachmentBeginInfo const & ) const = default; -#else - bool operator==( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentCount == rhs.attachmentCount ) && ( pAttachments == rhs.pAttachments ); -# endif - } - - bool operator!=( RenderPassAttachmentBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassAttachmentBeginInfo; - const void * pNext = {}; - uint32_t attachmentCount = {}; - const ImageView * pAttachments = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassAttachmentBeginInfo; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassAttachmentBeginInfo; - }; - - using RenderPassAttachmentBeginInfoKHR = RenderPassAttachmentBeginInfo; - - // wrapper struct for struct VkRenderPassBeginInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassBeginInfo.html - struct RenderPassBeginInfo - { - using NativeType = VkRenderPassBeginInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassBeginInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo( RenderPass renderPass_ = {}, - Framebuffer framebuffer_ = {}, - Rect2D renderArea_ = {}, - uint32_t clearValueCount_ = {}, - const ClearValue * pClearValues_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , renderPass{ renderPass_ } - , framebuffer{ framebuffer_ } - , renderArea{ renderArea_ } - , clearValueCount{ clearValueCount_ } - , pClearValues{ pClearValues_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo( RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassBeginInfo( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT : RenderPassBeginInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassBeginInfo( RenderPass renderPass_, - Framebuffer framebuffer_, - Rect2D renderArea_, - ArrayProxyNoTemporaries const & clearValues_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , renderPass( renderPass_ ) - , framebuffer( framebuffer_ ) - , renderArea( renderArea_ ) - , clearValueCount( static_cast( clearValues_.size() ) ) - , pClearValues( clearValues_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderPassBeginInfo & operator=( RenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassBeginInfo & operator=( VkRenderPassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setRenderPass( RenderPass renderPass_ ) & VULKAN_HPP_NOEXCEPT - { - renderPass = renderPass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setRenderPass( RenderPass renderPass_ ) && VULKAN_HPP_NOEXCEPT - { - renderPass = renderPass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setFramebuffer( Framebuffer framebuffer_ ) & VULKAN_HPP_NOEXCEPT - { - framebuffer = framebuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setFramebuffer( Framebuffer framebuffer_ ) && VULKAN_HPP_NOEXCEPT - { - framebuffer = framebuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setRenderArea( Rect2D const & renderArea_ ) & VULKAN_HPP_NOEXCEPT - { - renderArea = renderArea_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setRenderArea( Rect2D const & renderArea_ ) && VULKAN_HPP_NOEXCEPT - { - renderArea = renderArea_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setClearValueCount( uint32_t clearValueCount_ ) & VULKAN_HPP_NOEXCEPT - { - clearValueCount = clearValueCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setClearValueCount( uint32_t clearValueCount_ ) && VULKAN_HPP_NOEXCEPT - { - clearValueCount = clearValueCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo & setPClearValues( const ClearValue * pClearValues_ ) & VULKAN_HPP_NOEXCEPT - { - pClearValues = pClearValues_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassBeginInfo && setPClearValues( const ClearValue * pClearValues_ ) && VULKAN_HPP_NOEXCEPT - { - pClearValues = pClearValues_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassBeginInfo & setClearValues( ArrayProxyNoTemporaries const & clearValues_ ) VULKAN_HPP_NOEXCEPT - { - clearValueCount = static_cast( clearValues_.size() ); - pClearValues = clearValues_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassBeginInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassBeginInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassBeginInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassBeginInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, renderPass, framebuffer, renderArea, clearValueCount, pClearValues ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassBeginInfo const & ) const = default; -#else - bool operator==( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && ( framebuffer == rhs.framebuffer ) && - ( renderArea == rhs.renderArea ) && ( clearValueCount == rhs.clearValueCount ) && ( pClearValues == rhs.pClearValues ); -# endif - } - - bool operator!=( RenderPassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassBeginInfo; - const void * pNext = {}; - RenderPass renderPass = {}; - Framebuffer framebuffer = {}; - Rect2D renderArea = {}; - uint32_t clearValueCount = {}; - const ClearValue * pClearValues = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassBeginInfo; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassBeginInfo; - }; - - // wrapper struct for struct VkSubpassDescription, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescription.html - struct SubpassDescription - { - using NativeType = VkSubpassDescription; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubpassDescription( SubpassDescriptionFlags flags_ = {}, - PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, - uint32_t inputAttachmentCount_ = {}, - const AttachmentReference * pInputAttachments_ = {}, - uint32_t colorAttachmentCount_ = {}, - const AttachmentReference * pColorAttachments_ = {}, - const AttachmentReference * pResolveAttachments_ = {}, - const AttachmentReference * pDepthStencilAttachment_ = {}, - uint32_t preserveAttachmentCount_ = {}, - const uint32_t * pPreserveAttachments_ = {} ) VULKAN_HPP_NOEXCEPT - : flags{ flags_ } - , pipelineBindPoint{ pipelineBindPoint_ } - , inputAttachmentCount{ inputAttachmentCount_ } - , pInputAttachments{ pInputAttachments_ } - , colorAttachmentCount{ colorAttachmentCount_ } - , pColorAttachments{ pColorAttachments_ } - , pResolveAttachments{ pResolveAttachments_ } - , pDepthStencilAttachment{ pDepthStencilAttachment_ } - , preserveAttachmentCount{ preserveAttachmentCount_ } - , pPreserveAttachments{ pPreserveAttachments_ } - { - } - - VULKAN_HPP_CONSTEXPR SubpassDescription( SubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubpassDescription( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassDescription( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubpassDescription( SubpassDescriptionFlags flags_, - PipelineBindPoint pipelineBindPoint_, - ArrayProxyNoTemporaries const & inputAttachments_, - ArrayProxyNoTemporaries const & colorAttachments_ = {}, - ArrayProxyNoTemporaries const & resolveAttachments_ = {}, - const AttachmentReference * pDepthStencilAttachment_ = {}, - ArrayProxyNoTemporaries const & preserveAttachments_ = {} ) - : flags( flags_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , inputAttachmentCount( static_cast( inputAttachments_.size() ) ) - , pInputAttachments( inputAttachments_.data() ) - , colorAttachmentCount( static_cast( colorAttachments_.size() ) ) - , pColorAttachments( colorAttachments_.data() ) - , pResolveAttachments( resolveAttachments_.data() ) - , pDepthStencilAttachment( pDepthStencilAttachment_ ) - , preserveAttachmentCount( static_cast( preserveAttachments_.size() ) ) - , pPreserveAttachments( preserveAttachments_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( resolveAttachments_.empty() || ( colorAttachments_.size() == resolveAttachments_.size() ) ); -# else - if ( !resolveAttachments_.empty() && ( colorAttachments_.size() != resolveAttachments_.size() ) ) - { - throw LogicError( - VULKAN_HPP_NAMESPACE_STRING - "::SubpassDescription::SubpassDescription: !resolveAttachments_.empty() && ( colorAttachments_.size() != resolveAttachments_.size() )" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SubpassDescription & operator=( SubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubpassDescription & operator=( VkSubpassDescription const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setFlags( SubpassDescriptionFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setFlags( SubpassDescriptionFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setInputAttachmentCount( uint32_t inputAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - inputAttachmentCount = inputAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setInputAttachmentCount( uint32_t inputAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - inputAttachmentCount = inputAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPInputAttachments( const AttachmentReference * pInputAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pInputAttachments = pInputAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPInputAttachments( const AttachmentReference * pInputAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pInputAttachments = pInputAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubpassDescription & setInputAttachments( ArrayProxyNoTemporaries const & inputAttachments_ ) VULKAN_HPP_NOEXCEPT - { - inputAttachmentCount = static_cast( inputAttachments_.size() ); - pInputAttachments = inputAttachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPColorAttachments( const AttachmentReference * pColorAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pColorAttachments = pColorAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPColorAttachments( const AttachmentReference * pColorAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pColorAttachments = pColorAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubpassDescription & setColorAttachments( ArrayProxyNoTemporaries const & colorAttachments_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( colorAttachments_.size() ); - pColorAttachments = colorAttachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPResolveAttachments( const AttachmentReference * pResolveAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pResolveAttachments = pResolveAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPResolveAttachments( const AttachmentReference * pResolveAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pResolveAttachments = pResolveAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubpassDescription & setResolveAttachments( ArrayProxyNoTemporaries const & resolveAttachments_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( resolveAttachments_.size() ); - pResolveAttachments = resolveAttachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPDepthStencilAttachment( const AttachmentReference * pDepthStencilAttachment_ ) & VULKAN_HPP_NOEXCEPT - { - pDepthStencilAttachment = pDepthStencilAttachment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPDepthStencilAttachment( const AttachmentReference * pDepthStencilAttachment_ ) && VULKAN_HPP_NOEXCEPT - { - pDepthStencilAttachment = pDepthStencilAttachment_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - preserveAttachmentCount = preserveAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - preserveAttachmentCount = preserveAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription & setPPreserveAttachments( const uint32_t * pPreserveAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pPreserveAttachments = pPreserveAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription && setPPreserveAttachments( const uint32_t * pPreserveAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pPreserveAttachments = pPreserveAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubpassDescription & setPreserveAttachments( ArrayProxyNoTemporaries const & preserveAttachments_ ) VULKAN_HPP_NOEXCEPT - { - preserveAttachmentCount = static_cast( preserveAttachments_.size() ); - pPreserveAttachments = preserveAttachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubpassDescription const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassDescription &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassDescription const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubpassDescription *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( flags, - pipelineBindPoint, - inputAttachmentCount, - pInputAttachments, - colorAttachmentCount, - pColorAttachments, - pResolveAttachments, - pDepthStencilAttachment, - preserveAttachmentCount, - pPreserveAttachments ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubpassDescription const & ) const = default; -#else - bool operator==( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && ( inputAttachmentCount == rhs.inputAttachmentCount ) && - ( pInputAttachments == rhs.pInputAttachments ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachments == rhs.pColorAttachments ) && ( pResolveAttachments == rhs.pResolveAttachments ) && - ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) && ( preserveAttachmentCount == rhs.preserveAttachmentCount ) && - ( pPreserveAttachments == rhs.pPreserveAttachments ); -# endif - } - - bool operator!=( SubpassDescription const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - SubpassDescriptionFlags flags = {}; - PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; - uint32_t inputAttachmentCount = {}; - const AttachmentReference * pInputAttachments = {}; - uint32_t colorAttachmentCount = {}; - const AttachmentReference * pColorAttachments = {}; - const AttachmentReference * pResolveAttachments = {}; - const AttachmentReference * pDepthStencilAttachment = {}; - uint32_t preserveAttachmentCount = {}; - const uint32_t * pPreserveAttachments = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubpassDescription; - }; -#endif - - // wrapper struct for struct VkSubpassDependency, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDependency.html - struct SubpassDependency - { - using NativeType = VkSubpassDependency; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubpassDependency( uint32_t srcSubpass_ = {}, - uint32_t dstSubpass_ = {}, - PipelineStageFlags srcStageMask_ = {}, - PipelineStageFlags dstStageMask_ = {}, - AccessFlags srcAccessMask_ = {}, - AccessFlags dstAccessMask_ = {}, - DependencyFlags dependencyFlags_ = {} ) VULKAN_HPP_NOEXCEPT - : srcSubpass{ srcSubpass_ } - , dstSubpass{ dstSubpass_ } - , srcStageMask{ srcStageMask_ } - , dstStageMask{ dstStageMask_ } - , srcAccessMask{ srcAccessMask_ } - , dstAccessMask{ dstAccessMask_ } - , dependencyFlags{ dependencyFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR SubpassDependency( SubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubpassDependency( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassDependency( *reinterpret_cast( &rhs ) ) {} - - SubpassDependency & operator=( SubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubpassDependency & operator=( VkSubpassDependency const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setSrcSubpass( uint32_t srcSubpass_ ) & VULKAN_HPP_NOEXCEPT - { - srcSubpass = srcSubpass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setSrcSubpass( uint32_t srcSubpass_ ) && VULKAN_HPP_NOEXCEPT - { - srcSubpass = srcSubpass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setDstSubpass( uint32_t dstSubpass_ ) & VULKAN_HPP_NOEXCEPT - { - dstSubpass = dstSubpass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setDstSubpass( uint32_t dstSubpass_ ) && VULKAN_HPP_NOEXCEPT - { - dstSubpass = dstSubpass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setSrcStageMask( PipelineStageFlags srcStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setSrcStageMask( PipelineStageFlags srcStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setDstStageMask( PipelineStageFlags dstStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setDstStageMask( PipelineStageFlags dstStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setSrcAccessMask( AccessFlags srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setSrcAccessMask( AccessFlags srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setDstAccessMask( AccessFlags dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setDstAccessMask( AccessFlags dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency & setDependencyFlags( DependencyFlags dependencyFlags_ ) & VULKAN_HPP_NOEXCEPT - { - dependencyFlags = dependencyFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency && setDependencyFlags( DependencyFlags dependencyFlags_ ) && VULKAN_HPP_NOEXCEPT - { - dependencyFlags = dependencyFlags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubpassDependency const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassDependency &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassDependency const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubpassDependency *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( srcSubpass, dstSubpass, srcStageMask, dstStageMask, srcAccessMask, dstAccessMask, dependencyFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubpassDependency const & ) const = default; -#else - bool operator==( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( srcSubpass == rhs.srcSubpass ) && ( dstSubpass == rhs.dstSubpass ) && ( srcStageMask == rhs.srcStageMask ) && - ( dstStageMask == rhs.dstStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && ( dstAccessMask == rhs.dstAccessMask ) && - ( dependencyFlags == rhs.dependencyFlags ); -# endif - } - - bool operator!=( SubpassDependency const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t srcSubpass = {}; - uint32_t dstSubpass = {}; - PipelineStageFlags srcStageMask = {}; - PipelineStageFlags dstStageMask = {}; - AccessFlags srcAccessMask = {}; - AccessFlags dstAccessMask = {}; - DependencyFlags dependencyFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubpassDependency; - }; -#endif - - // wrapper struct for struct VkRenderPassCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateInfo.html - struct RenderPassCreateInfo - { - using NativeType = VkRenderPassCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( RenderPassCreateFlags flags_ = {}, - uint32_t attachmentCount_ = {}, - const AttachmentDescription * pAttachments_ = {}, - uint32_t subpassCount_ = {}, - const SubpassDescription * pSubpasses_ = {}, - uint32_t dependencyCount_ = {}, - const SubpassDependency * pDependencies_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , attachmentCount{ attachmentCount_ } - , pAttachments{ pAttachments_ } - , subpassCount{ subpassCount_ } - , pSubpasses{ pSubpasses_ } - , dependencyCount{ dependencyCount_ } - , pDependencies{ pDependencies_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassCreateInfo( RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassCreateInfo( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassCreateInfo( RenderPassCreateFlags flags_, - ArrayProxyNoTemporaries const & attachments_, - ArrayProxyNoTemporaries const & subpasses_ = {}, - ArrayProxyNoTemporaries const & dependencies_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , attachmentCount( static_cast( attachments_.size() ) ) - , pAttachments( attachments_.data() ) - , subpassCount( static_cast( subpasses_.size() ) ) - , pSubpasses( subpasses_.data() ) - , dependencyCount( static_cast( dependencies_.size() ) ) - , pDependencies( dependencies_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderPassCreateInfo & operator=( RenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassCreateInfo & operator=( VkRenderPassCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setFlags( RenderPassCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setFlags( RenderPassCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setPAttachments( const AttachmentDescription * pAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pAttachments = pAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setPAttachments( const AttachmentDescription * pAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pAttachments = pAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassCreateInfo & setAttachments( ArrayProxyNoTemporaries const & attachments_ ) VULKAN_HPP_NOEXCEPT - { - attachmentCount = static_cast( attachments_.size() ); - pAttachments = attachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setSubpassCount( uint32_t subpassCount_ ) & VULKAN_HPP_NOEXCEPT - { - subpassCount = subpassCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setSubpassCount( uint32_t subpassCount_ ) && VULKAN_HPP_NOEXCEPT - { - subpassCount = subpassCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setPSubpasses( const SubpassDescription * pSubpasses_ ) & VULKAN_HPP_NOEXCEPT - { - pSubpasses = pSubpasses_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setPSubpasses( const SubpassDescription * pSubpasses_ ) && VULKAN_HPP_NOEXCEPT - { - pSubpasses = pSubpasses_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassCreateInfo & setSubpasses( ArrayProxyNoTemporaries const & subpasses_ ) VULKAN_HPP_NOEXCEPT - { - subpassCount = static_cast( subpasses_.size() ); - pSubpasses = subpasses_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setDependencyCount( uint32_t dependencyCount_ ) & VULKAN_HPP_NOEXCEPT - { - dependencyCount = dependencyCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setDependencyCount( uint32_t dependencyCount_ ) && VULKAN_HPP_NOEXCEPT - { - dependencyCount = dependencyCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo & setPDependencies( const SubpassDependency * pDependencies_ ) & VULKAN_HPP_NOEXCEPT - { - pDependencies = pDependencies_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo && setPDependencies( const SubpassDependency * pDependencies_ ) && VULKAN_HPP_NOEXCEPT - { - pDependencies = pDependencies_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassCreateInfo & setDependencies( ArrayProxyNoTemporaries const & dependencies_ ) VULKAN_HPP_NOEXCEPT - { - dependencyCount = static_cast( dependencies_.size() ); - pDependencies = dependencies_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, attachmentCount, pAttachments, subpassCount, pSubpasses, dependencyCount, pDependencies ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassCreateInfo const & ) const = default; -#else - bool operator==( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( attachmentCount == rhs.attachmentCount ) && - ( pAttachments == rhs.pAttachments ) && ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) && - ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies ); -# endif - } - - bool operator!=( RenderPassCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassCreateInfo; - const void * pNext = {}; - RenderPassCreateFlags flags = {}; - uint32_t attachmentCount = {}; - const AttachmentDescription * pAttachments = {}; - uint32_t subpassCount = {}; - const SubpassDescription * pSubpasses = {}; - uint32_t dependencyCount = {}; - const SubpassDependency * pDependencies = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassCreateInfo; - }; - - // wrapper struct for struct VkSubpassDescription2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescription2.html - struct SubpassDescription2 - { - using NativeType = VkSubpassDescription2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDescription2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubpassDescription2( SubpassDescriptionFlags flags_ = {}, - PipelineBindPoint pipelineBindPoint_ = PipelineBindPoint::eGraphics, - uint32_t viewMask_ = {}, - uint32_t inputAttachmentCount_ = {}, - const AttachmentReference2 * pInputAttachments_ = {}, - uint32_t colorAttachmentCount_ = {}, - const AttachmentReference2 * pColorAttachments_ = {}, - const AttachmentReference2 * pResolveAttachments_ = {}, - const AttachmentReference2 * pDepthStencilAttachment_ = {}, - uint32_t preserveAttachmentCount_ = {}, - const uint32_t * pPreserveAttachments_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , pipelineBindPoint{ pipelineBindPoint_ } - , viewMask{ viewMask_ } - , inputAttachmentCount{ inputAttachmentCount_ } - , pInputAttachments{ pInputAttachments_ } - , colorAttachmentCount{ colorAttachmentCount_ } - , pColorAttachments{ pColorAttachments_ } - , pResolveAttachments{ pResolveAttachments_ } - , pDepthStencilAttachment{ pDepthStencilAttachment_ } - , preserveAttachmentCount{ preserveAttachmentCount_ } - , pPreserveAttachments{ pPreserveAttachments_ } - { - } - - VULKAN_HPP_CONSTEXPR SubpassDescription2( SubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubpassDescription2( VkSubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassDescription2( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubpassDescription2( SubpassDescriptionFlags flags_, - PipelineBindPoint pipelineBindPoint_, - uint32_t viewMask_, - ArrayProxyNoTemporaries const & inputAttachments_, - ArrayProxyNoTemporaries const & colorAttachments_ = {}, - ArrayProxyNoTemporaries const & resolveAttachments_ = {}, - const AttachmentReference2 * pDepthStencilAttachment_ = {}, - ArrayProxyNoTemporaries const & preserveAttachments_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , pipelineBindPoint( pipelineBindPoint_ ) - , viewMask( viewMask_ ) - , inputAttachmentCount( static_cast( inputAttachments_.size() ) ) - , pInputAttachments( inputAttachments_.data() ) - , colorAttachmentCount( static_cast( colorAttachments_.size() ) ) - , pColorAttachments( colorAttachments_.data() ) - , pResolveAttachments( resolveAttachments_.data() ) - , pDepthStencilAttachment( pDepthStencilAttachment_ ) - , preserveAttachmentCount( static_cast( preserveAttachments_.size() ) ) - , pPreserveAttachments( preserveAttachments_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( resolveAttachments_.empty() || ( colorAttachments_.size() == resolveAttachments_.size() ) ); -# else - if ( !resolveAttachments_.empty() && ( colorAttachments_.size() != resolveAttachments_.size() ) ) - { - throw LogicError( - VULKAN_HPP_NAMESPACE_STRING - "::SubpassDescription2::SubpassDescription2: !resolveAttachments_.empty() && ( colorAttachments_.size() != resolveAttachments_.size() )" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SubpassDescription2 & operator=( SubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubpassDescription2 & operator=( VkSubpassDescription2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setFlags( SubpassDescriptionFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setFlags( SubpassDescriptionFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) & VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPipelineBindPoint( PipelineBindPoint pipelineBindPoint_ ) && VULKAN_HPP_NOEXCEPT - { - pipelineBindPoint = pipelineBindPoint_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setViewMask( uint32_t viewMask_ ) & VULKAN_HPP_NOEXCEPT - { - viewMask = viewMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setViewMask( uint32_t viewMask_ ) && VULKAN_HPP_NOEXCEPT - { - viewMask = viewMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setInputAttachmentCount( uint32_t inputAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - inputAttachmentCount = inputAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setInputAttachmentCount( uint32_t inputAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - inputAttachmentCount = inputAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPInputAttachments( const AttachmentReference2 * pInputAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pInputAttachments = pInputAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPInputAttachments( const AttachmentReference2 * pInputAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pInputAttachments = pInputAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubpassDescription2 & setInputAttachments( ArrayProxyNoTemporaries const & inputAttachments_ ) VULKAN_HPP_NOEXCEPT - { - inputAttachmentCount = static_cast( inputAttachments_.size() ); - pInputAttachments = inputAttachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPColorAttachments( const AttachmentReference2 * pColorAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pColorAttachments = pColorAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPColorAttachments( const AttachmentReference2 * pColorAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pColorAttachments = pColorAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubpassDescription2 & setColorAttachments( ArrayProxyNoTemporaries const & colorAttachments_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( colorAttachments_.size() ); - pColorAttachments = colorAttachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPResolveAttachments( const AttachmentReference2 * pResolveAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pResolveAttachments = pResolveAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPResolveAttachments( const AttachmentReference2 * pResolveAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pResolveAttachments = pResolveAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubpassDescription2 & setResolveAttachments( ArrayProxyNoTemporaries const & resolveAttachments_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( resolveAttachments_.size() ); - pResolveAttachments = resolveAttachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPDepthStencilAttachment( const AttachmentReference2 * pDepthStencilAttachment_ ) & VULKAN_HPP_NOEXCEPT - { - pDepthStencilAttachment = pDepthStencilAttachment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPDepthStencilAttachment( const AttachmentReference2 * pDepthStencilAttachment_ ) && VULKAN_HPP_NOEXCEPT - { - pDepthStencilAttachment = pDepthStencilAttachment_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - preserveAttachmentCount = preserveAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPreserveAttachmentCount( uint32_t preserveAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - preserveAttachmentCount = preserveAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 & setPPreserveAttachments( const uint32_t * pPreserveAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pPreserveAttachments = pPreserveAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescription2 && setPPreserveAttachments( const uint32_t * pPreserveAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pPreserveAttachments = pPreserveAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubpassDescription2 & setPreserveAttachments( ArrayProxyNoTemporaries const & preserveAttachments_ ) VULKAN_HPP_NOEXCEPT - { - preserveAttachmentCount = static_cast( preserveAttachments_.size() ); - pPreserveAttachments = preserveAttachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubpassDescription2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassDescription2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassDescription2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubpassDescription2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - pipelineBindPoint, - viewMask, - inputAttachmentCount, - pInputAttachments, - colorAttachmentCount, - pColorAttachments, - pResolveAttachments, - pDepthStencilAttachment, - preserveAttachmentCount, - pPreserveAttachments ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubpassDescription2 const & ) const = default; -#else - bool operator==( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( pipelineBindPoint == rhs.pipelineBindPoint ) && - ( viewMask == rhs.viewMask ) && ( inputAttachmentCount == rhs.inputAttachmentCount ) && ( pInputAttachments == rhs.pInputAttachments ) && - ( colorAttachmentCount == rhs.colorAttachmentCount ) && ( pColorAttachments == rhs.pColorAttachments ) && - ( pResolveAttachments == rhs.pResolveAttachments ) && ( pDepthStencilAttachment == rhs.pDepthStencilAttachment ) && - ( preserveAttachmentCount == rhs.preserveAttachmentCount ) && ( pPreserveAttachments == rhs.pPreserveAttachments ); -# endif - } - - bool operator!=( SubpassDescription2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubpassDescription2; - const void * pNext = {}; - SubpassDescriptionFlags flags = {}; - PipelineBindPoint pipelineBindPoint = PipelineBindPoint::eGraphics; - uint32_t viewMask = {}; - uint32_t inputAttachmentCount = {}; - const AttachmentReference2 * pInputAttachments = {}; - uint32_t colorAttachmentCount = {}; - const AttachmentReference2 * pColorAttachments = {}; - const AttachmentReference2 * pResolveAttachments = {}; - const AttachmentReference2 * pDepthStencilAttachment = {}; - uint32_t preserveAttachmentCount = {}; - const uint32_t * pPreserveAttachments = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubpassDescription2; - }; -#endif - - template <> - struct CppType - { - using Type = SubpassDescription2; - }; - - using SubpassDescription2KHR = SubpassDescription2; - - // wrapper struct for struct VkSubpassDependency2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDependency2.html - struct SubpassDependency2 - { - using NativeType = VkSubpassDependency2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDependency2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubpassDependency2( uint32_t srcSubpass_ = {}, - uint32_t dstSubpass_ = {}, - PipelineStageFlags srcStageMask_ = {}, - PipelineStageFlags dstStageMask_ = {}, - AccessFlags srcAccessMask_ = {}, - AccessFlags dstAccessMask_ = {}, - DependencyFlags dependencyFlags_ = {}, - int32_t viewOffset_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcSubpass{ srcSubpass_ } - , dstSubpass{ dstSubpass_ } - , srcStageMask{ srcStageMask_ } - , dstStageMask{ dstStageMask_ } - , srcAccessMask{ srcAccessMask_ } - , dstAccessMask{ dstAccessMask_ } - , dependencyFlags{ dependencyFlags_ } - , viewOffset{ viewOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR SubpassDependency2( SubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubpassDependency2( VkSubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassDependency2( *reinterpret_cast( &rhs ) ) {} - - SubpassDependency2 & operator=( SubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubpassDependency2 & operator=( VkSubpassDependency2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setSrcSubpass( uint32_t srcSubpass_ ) & VULKAN_HPP_NOEXCEPT - { - srcSubpass = srcSubpass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setSrcSubpass( uint32_t srcSubpass_ ) && VULKAN_HPP_NOEXCEPT - { - srcSubpass = srcSubpass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setDstSubpass( uint32_t dstSubpass_ ) & VULKAN_HPP_NOEXCEPT - { - dstSubpass = dstSubpass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setDstSubpass( uint32_t dstSubpass_ ) && VULKAN_HPP_NOEXCEPT - { - dstSubpass = dstSubpass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setSrcStageMask( PipelineStageFlags srcStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setSrcStageMask( PipelineStageFlags srcStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setDstStageMask( PipelineStageFlags dstStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setDstStageMask( PipelineStageFlags dstStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setSrcAccessMask( AccessFlags srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setSrcAccessMask( AccessFlags srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setDstAccessMask( AccessFlags dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setDstAccessMask( AccessFlags dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setDependencyFlags( DependencyFlags dependencyFlags_ ) & VULKAN_HPP_NOEXCEPT - { - dependencyFlags = dependencyFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setDependencyFlags( DependencyFlags dependencyFlags_ ) && VULKAN_HPP_NOEXCEPT - { - dependencyFlags = dependencyFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 & setViewOffset( int32_t viewOffset_ ) & VULKAN_HPP_NOEXCEPT - { - viewOffset = viewOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDependency2 && setViewOffset( int32_t viewOffset_ ) && VULKAN_HPP_NOEXCEPT - { - viewOffset = viewOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubpassDependency2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassDependency2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassDependency2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubpassDependency2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcSubpass, dstSubpass, srcStageMask, dstStageMask, srcAccessMask, dstAccessMask, dependencyFlags, viewOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubpassDependency2 const & ) const = default; -#else - bool operator==( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcSubpass == rhs.srcSubpass ) && ( dstSubpass == rhs.dstSubpass ) && - ( srcStageMask == rhs.srcStageMask ) && ( dstStageMask == rhs.dstStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && - ( dstAccessMask == rhs.dstAccessMask ) && ( dependencyFlags == rhs.dependencyFlags ) && ( viewOffset == rhs.viewOffset ); -# endif - } - - bool operator!=( SubpassDependency2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubpassDependency2; - const void * pNext = {}; - uint32_t srcSubpass = {}; - uint32_t dstSubpass = {}; - PipelineStageFlags srcStageMask = {}; - PipelineStageFlags dstStageMask = {}; - AccessFlags srcAccessMask = {}; - AccessFlags dstAccessMask = {}; - DependencyFlags dependencyFlags = {}; - int32_t viewOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubpassDependency2; - }; -#endif - - template <> - struct CppType - { - using Type = SubpassDependency2; - }; - - using SubpassDependency2KHR = SubpassDependency2; - - // wrapper struct for struct VkRenderPassCreateInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreateInfo2.html - struct RenderPassCreateInfo2 - { - using NativeType = VkRenderPassCreateInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreateInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2( RenderPassCreateFlags flags_ = {}, - uint32_t attachmentCount_ = {}, - const AttachmentDescription2 * pAttachments_ = {}, - uint32_t subpassCount_ = {}, - const SubpassDescription2 * pSubpasses_ = {}, - uint32_t dependencyCount_ = {}, - const SubpassDependency2 * pDependencies_ = {}, - uint32_t correlatedViewMaskCount_ = {}, - const uint32_t * pCorrelatedViewMasks_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , attachmentCount{ attachmentCount_ } - , pAttachments{ pAttachments_ } - , subpassCount{ subpassCount_ } - , pSubpasses{ pSubpasses_ } - , dependencyCount{ dependencyCount_ } - , pDependencies{ pDependencies_ } - , correlatedViewMaskCount{ correlatedViewMaskCount_ } - , pCorrelatedViewMasks{ pCorrelatedViewMasks_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassCreateInfo2( RenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassCreateInfo2( VkRenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassCreateInfo2( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassCreateInfo2( RenderPassCreateFlags flags_, - ArrayProxyNoTemporaries const & attachments_, - ArrayProxyNoTemporaries const & subpasses_ = {}, - ArrayProxyNoTemporaries const & dependencies_ = {}, - ArrayProxyNoTemporaries const & correlatedViewMasks_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , attachmentCount( static_cast( attachments_.size() ) ) - , pAttachments( attachments_.data() ) - , subpassCount( static_cast( subpasses_.size() ) ) - , pSubpasses( subpasses_.data() ) - , dependencyCount( static_cast( dependencies_.size() ) ) - , pDependencies( dependencies_.data() ) - , correlatedViewMaskCount( static_cast( correlatedViewMasks_.size() ) ) - , pCorrelatedViewMasks( correlatedViewMasks_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderPassCreateInfo2 & operator=( RenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassCreateInfo2 & operator=( VkRenderPassCreateInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setFlags( RenderPassCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setFlags( RenderPassCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setAttachmentCount( uint32_t attachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setAttachmentCount( uint32_t attachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - attachmentCount = attachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setPAttachments( const AttachmentDescription2 * pAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pAttachments = pAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setPAttachments( const AttachmentDescription2 * pAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pAttachments = pAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassCreateInfo2 & setAttachments( ArrayProxyNoTemporaries const & attachments_ ) VULKAN_HPP_NOEXCEPT - { - attachmentCount = static_cast( attachments_.size() ); - pAttachments = attachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setSubpassCount( uint32_t subpassCount_ ) & VULKAN_HPP_NOEXCEPT - { - subpassCount = subpassCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setSubpassCount( uint32_t subpassCount_ ) && VULKAN_HPP_NOEXCEPT - { - subpassCount = subpassCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setPSubpasses( const SubpassDescription2 * pSubpasses_ ) & VULKAN_HPP_NOEXCEPT - { - pSubpasses = pSubpasses_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setPSubpasses( const SubpassDescription2 * pSubpasses_ ) && VULKAN_HPP_NOEXCEPT - { - pSubpasses = pSubpasses_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassCreateInfo2 & setSubpasses( ArrayProxyNoTemporaries const & subpasses_ ) VULKAN_HPP_NOEXCEPT - { - subpassCount = static_cast( subpasses_.size() ); - pSubpasses = subpasses_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setDependencyCount( uint32_t dependencyCount_ ) & VULKAN_HPP_NOEXCEPT - { - dependencyCount = dependencyCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setDependencyCount( uint32_t dependencyCount_ ) && VULKAN_HPP_NOEXCEPT - { - dependencyCount = dependencyCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setPDependencies( const SubpassDependency2 * pDependencies_ ) & VULKAN_HPP_NOEXCEPT - { - pDependencies = pDependencies_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setPDependencies( const SubpassDependency2 * pDependencies_ ) && VULKAN_HPP_NOEXCEPT - { - pDependencies = pDependencies_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassCreateInfo2 & setDependencies( ArrayProxyNoTemporaries const & dependencies_ ) VULKAN_HPP_NOEXCEPT - { - dependencyCount = static_cast( dependencies_.size() ); - pDependencies = dependencies_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setCorrelatedViewMaskCount( uint32_t correlatedViewMaskCount_ ) & VULKAN_HPP_NOEXCEPT - { - correlatedViewMaskCount = correlatedViewMaskCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setCorrelatedViewMaskCount( uint32_t correlatedViewMaskCount_ ) && VULKAN_HPP_NOEXCEPT - { - correlatedViewMaskCount = correlatedViewMaskCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 & setPCorrelatedViewMasks( const uint32_t * pCorrelatedViewMasks_ ) & VULKAN_HPP_NOEXCEPT - { - pCorrelatedViewMasks = pCorrelatedViewMasks_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreateInfo2 && setPCorrelatedViewMasks( const uint32_t * pCorrelatedViewMasks_ ) && VULKAN_HPP_NOEXCEPT - { - pCorrelatedViewMasks = pCorrelatedViewMasks_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassCreateInfo2 & setCorrelatedViewMasks( ArrayProxyNoTemporaries const & correlatedViewMasks_ ) VULKAN_HPP_NOEXCEPT - { - correlatedViewMaskCount = static_cast( correlatedViewMasks_.size() ); - pCorrelatedViewMasks = correlatedViewMasks_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassCreateInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassCreateInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassCreateInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassCreateInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - attachmentCount, - pAttachments, - subpassCount, - pSubpasses, - dependencyCount, - pDependencies, - correlatedViewMaskCount, - pCorrelatedViewMasks ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassCreateInfo2 const & ) const = default; -#else - bool operator==( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( attachmentCount == rhs.attachmentCount ) && - ( pAttachments == rhs.pAttachments ) && ( subpassCount == rhs.subpassCount ) && ( pSubpasses == rhs.pSubpasses ) && - ( dependencyCount == rhs.dependencyCount ) && ( pDependencies == rhs.pDependencies ) && - ( correlatedViewMaskCount == rhs.correlatedViewMaskCount ) && ( pCorrelatedViewMasks == rhs.pCorrelatedViewMasks ); -# endif - } - - bool operator!=( RenderPassCreateInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassCreateInfo2; - const void * pNext = {}; - RenderPassCreateFlags flags = {}; - uint32_t attachmentCount = {}; - const AttachmentDescription2 * pAttachments = {}; - uint32_t subpassCount = {}; - const SubpassDescription2 * pSubpasses = {}; - uint32_t dependencyCount = {}; - const SubpassDependency2 * pDependencies = {}; - uint32_t correlatedViewMaskCount = {}; - const uint32_t * pCorrelatedViewMasks = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassCreateInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassCreateInfo2; - }; - - using RenderPassCreateInfo2KHR = RenderPassCreateInfo2; - - // wrapper struct for struct VkRenderPassCreationControlEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreationControlEXT.html - struct RenderPassCreationControlEXT - { - using NativeType = VkRenderPassCreationControlEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreationControlEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassCreationControlEXT( Bool32 disallowMerging_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , disallowMerging{ disallowMerging_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassCreationControlEXT( RenderPassCreationControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassCreationControlEXT( VkRenderPassCreationControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassCreationControlEXT( *reinterpret_cast( &rhs ) ) - { - } - - RenderPassCreationControlEXT & operator=( RenderPassCreationControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassCreationControlEXT & operator=( VkRenderPassCreationControlEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassCreationControlEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreationControlEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreationControlEXT & setDisallowMerging( Bool32 disallowMerging_ ) & VULKAN_HPP_NOEXCEPT - { - disallowMerging = disallowMerging_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreationControlEXT && setDisallowMerging( Bool32 disallowMerging_ ) && VULKAN_HPP_NOEXCEPT - { - disallowMerging = disallowMerging_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassCreationControlEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassCreationControlEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassCreationControlEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassCreationControlEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, disallowMerging ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassCreationControlEXT const & ) const = default; -#else - bool operator==( RenderPassCreationControlEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( disallowMerging == rhs.disallowMerging ); -# endif - } - - bool operator!=( RenderPassCreationControlEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassCreationControlEXT; - const void * pNext = {}; - Bool32 disallowMerging = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassCreationControlEXT; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassCreationControlEXT; - }; - - // wrapper struct for struct VkRenderPassCreationFeedbackInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreationFeedbackInfoEXT.html - struct RenderPassCreationFeedbackInfoEXT - { - using NativeType = VkRenderPassCreationFeedbackInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassCreationFeedbackInfoEXT( uint32_t postMergeSubpassCount_ = {} ) VULKAN_HPP_NOEXCEPT - : postMergeSubpassCount{ postMergeSubpassCount_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassCreationFeedbackInfoEXT( RenderPassCreationFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassCreationFeedbackInfoEXT( VkRenderPassCreationFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassCreationFeedbackInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - RenderPassCreationFeedbackInfoEXT & operator=( RenderPassCreationFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassCreationFeedbackInfoEXT & operator=( VkRenderPassCreationFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkRenderPassCreationFeedbackInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassCreationFeedbackInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassCreationFeedbackInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassCreationFeedbackInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( postMergeSubpassCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassCreationFeedbackInfoEXT const & ) const = default; -#else - bool operator==( RenderPassCreationFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( postMergeSubpassCount == rhs.postMergeSubpassCount ); -# endif - } - - bool operator!=( RenderPassCreationFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t postMergeSubpassCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassCreationFeedbackInfoEXT; - }; -#endif - - // wrapper struct for struct VkRenderPassCreationFeedbackCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassCreationFeedbackCreateInfoEXT.html - struct RenderPassCreationFeedbackCreateInfoEXT - { - using NativeType = VkRenderPassCreationFeedbackCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassCreationFeedbackCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassCreationFeedbackCreateInfoEXT( RenderPassCreationFeedbackInfoEXT * pRenderPassFeedback_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pRenderPassFeedback{ pRenderPassFeedback_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassCreationFeedbackCreateInfoEXT( RenderPassCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassCreationFeedbackCreateInfoEXT( VkRenderPassCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassCreationFeedbackCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - RenderPassCreationFeedbackCreateInfoEXT & operator=( RenderPassCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassCreationFeedbackCreateInfoEXT & operator=( VkRenderPassCreationFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassCreationFeedbackCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreationFeedbackCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreationFeedbackCreateInfoEXT & setPRenderPassFeedback( RenderPassCreationFeedbackInfoEXT * pRenderPassFeedback_ ) & - VULKAN_HPP_NOEXCEPT - { - pRenderPassFeedback = pRenderPassFeedback_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassCreationFeedbackCreateInfoEXT && setPRenderPassFeedback( RenderPassCreationFeedbackInfoEXT * pRenderPassFeedback_ ) && - VULKAN_HPP_NOEXCEPT - { - pRenderPassFeedback = pRenderPassFeedback_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassCreationFeedbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassCreationFeedbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassCreationFeedbackCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassCreationFeedbackCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pRenderPassFeedback ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassCreationFeedbackCreateInfoEXT const & ) const = default; -#else - bool operator==( RenderPassCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pRenderPassFeedback == rhs.pRenderPassFeedback ); -# endif - } - - bool operator!=( RenderPassCreationFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassCreationFeedbackCreateInfoEXT; - const void * pNext = {}; - RenderPassCreationFeedbackInfoEXT * pRenderPassFeedback = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassCreationFeedbackCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassCreationFeedbackCreateInfoEXT; - }; - - // wrapper struct for struct VkRenderPassFragmentDensityMapCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassFragmentDensityMapCreateInfoEXT.html - struct RenderPassFragmentDensityMapCreateInfoEXT - { - using NativeType = VkRenderPassFragmentDensityMapCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( AttachmentReference fragmentDensityMapAttachment_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fragmentDensityMapAttachment{ fragmentDensityMapAttachment_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapCreateInfoEXT( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassFragmentDensityMapCreateInfoEXT( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassFragmentDensityMapCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - RenderPassFragmentDensityMapCreateInfoEXT & operator=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassFragmentDensityMapCreateInfoEXT & operator=( VkRenderPassFragmentDensityMapCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapCreateInfoEXT & - setFragmentDensityMapAttachment( AttachmentReference const & fragmentDensityMapAttachment_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapAttachment = fragmentDensityMapAttachment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapCreateInfoEXT && - setFragmentDensityMapAttachment( AttachmentReference const & fragmentDensityMapAttachment_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentDensityMapAttachment = fragmentDensityMapAttachment_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassFragmentDensityMapCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassFragmentDensityMapCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassFragmentDensityMapCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassFragmentDensityMapCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fragmentDensityMapAttachment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassFragmentDensityMapCreateInfoEXT const & ) const = default; -#else - bool operator==( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityMapAttachment == rhs.fragmentDensityMapAttachment ); -# endif - } - - bool operator!=( RenderPassFragmentDensityMapCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassFragmentDensityMapCreateInfoEXT; - const void * pNext = {}; - AttachmentReference fragmentDensityMapAttachment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassFragmentDensityMapCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassFragmentDensityMapCreateInfoEXT; - }; - - // wrapper struct for struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassFragmentDensityMapOffsetEndInfoEXT.html - struct RenderPassFragmentDensityMapOffsetEndInfoEXT - { - using NativeType = VkRenderPassFragmentDensityMapOffsetEndInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapOffsetEndInfoEXT( uint32_t fragmentDensityOffsetCount_ = {}, - const Offset2D * pFragmentDensityOffsets_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fragmentDensityOffsetCount{ fragmentDensityOffsetCount_ } - , pFragmentDensityOffsets{ pFragmentDensityOffsets_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassFragmentDensityMapOffsetEndInfoEXT( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassFragmentDensityMapOffsetEndInfoEXT( VkRenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassFragmentDensityMapOffsetEndInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassFragmentDensityMapOffsetEndInfoEXT( ArrayProxyNoTemporaries const & fragmentDensityOffsets_, const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , fragmentDensityOffsetCount( static_cast( fragmentDensityOffsets_.size() ) ) - , pFragmentDensityOffsets( fragmentDensityOffsets_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderPassFragmentDensityMapOffsetEndInfoEXT & operator=( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassFragmentDensityMapOffsetEndInfoEXT & operator=( VkRenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT & setFragmentDensityOffsetCount( uint32_t fragmentDensityOffsetCount_ ) & - VULKAN_HPP_NOEXCEPT - { - fragmentDensityOffsetCount = fragmentDensityOffsetCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT && setFragmentDensityOffsetCount( uint32_t fragmentDensityOffsetCount_ ) && - VULKAN_HPP_NOEXCEPT - { - fragmentDensityOffsetCount = fragmentDensityOffsetCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT & setPFragmentDensityOffsets( const Offset2D * pFragmentDensityOffsets_ ) & - VULKAN_HPP_NOEXCEPT - { - pFragmentDensityOffsets = pFragmentDensityOffsets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassFragmentDensityMapOffsetEndInfoEXT && setPFragmentDensityOffsets( const Offset2D * pFragmentDensityOffsets_ ) && - VULKAN_HPP_NOEXCEPT - { - pFragmentDensityOffsets = pFragmentDensityOffsets_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassFragmentDensityMapOffsetEndInfoEXT & - setFragmentDensityOffsets( ArrayProxyNoTemporaries const & fragmentDensityOffsets_ ) VULKAN_HPP_NOEXCEPT - { - fragmentDensityOffsetCount = static_cast( fragmentDensityOffsets_.size() ); - pFragmentDensityOffsets = fragmentDensityOffsets_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassFragmentDensityMapOffsetEndInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fragmentDensityOffsetCount, pFragmentDensityOffsets ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassFragmentDensityMapOffsetEndInfoEXT const & ) const = default; -#else - bool operator==( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fragmentDensityOffsetCount == rhs.fragmentDensityOffsetCount ) && - ( pFragmentDensityOffsets == rhs.pFragmentDensityOffsets ); -# endif - } - - bool operator!=( RenderPassFragmentDensityMapOffsetEndInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT; - const void * pNext = {}; - uint32_t fragmentDensityOffsetCount = {}; - const Offset2D * pFragmentDensityOffsets = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassFragmentDensityMapOffsetEndInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassFragmentDensityMapOffsetEndInfoEXT; - }; - - using SubpassFragmentDensityMapOffsetEndInfoQCOM = RenderPassFragmentDensityMapOffsetEndInfoEXT; - - // wrapper struct for struct VkRenderPassInputAttachmentAspectCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassInputAttachmentAspectCreateInfo.html - struct RenderPassInputAttachmentAspectCreateInfo - { - using NativeType = VkRenderPassInputAttachmentAspectCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( uint32_t aspectReferenceCount_ = {}, - const InputAttachmentAspectReference * pAspectReferences_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , aspectReferenceCount{ aspectReferenceCount_ } - , pAspectReferences{ pAspectReferences_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassInputAttachmentAspectCreateInfo( RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassInputAttachmentAspectCreateInfo( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassInputAttachmentAspectCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassInputAttachmentAspectCreateInfo( ArrayProxyNoTemporaries const & aspectReferences_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), aspectReferenceCount( static_cast( aspectReferences_.size() ) ), pAspectReferences( aspectReferences_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderPassInputAttachmentAspectCreateInfo & operator=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassInputAttachmentAspectCreateInfo & operator=( VkRenderPassInputAttachmentAspectCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo & setAspectReferenceCount( uint32_t aspectReferenceCount_ ) & VULKAN_HPP_NOEXCEPT - { - aspectReferenceCount = aspectReferenceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo && setAspectReferenceCount( uint32_t aspectReferenceCount_ ) && VULKAN_HPP_NOEXCEPT - { - aspectReferenceCount = aspectReferenceCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo & setPAspectReferences( const InputAttachmentAspectReference * pAspectReferences_ ) & - VULKAN_HPP_NOEXCEPT - { - pAspectReferences = pAspectReferences_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassInputAttachmentAspectCreateInfo && setPAspectReferences( const InputAttachmentAspectReference * pAspectReferences_ ) && - VULKAN_HPP_NOEXCEPT - { - pAspectReferences = pAspectReferences_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassInputAttachmentAspectCreateInfo & - setAspectReferences( ArrayProxyNoTemporaries const & aspectReferences_ ) VULKAN_HPP_NOEXCEPT - { - aspectReferenceCount = static_cast( aspectReferences_.size() ); - pAspectReferences = aspectReferences_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassInputAttachmentAspectCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassInputAttachmentAspectCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassInputAttachmentAspectCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassInputAttachmentAspectCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, aspectReferenceCount, pAspectReferences ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassInputAttachmentAspectCreateInfo const & ) const = default; -#else - bool operator==( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( aspectReferenceCount == rhs.aspectReferenceCount ) && - ( pAspectReferences == rhs.pAspectReferences ); -# endif - } - - bool operator!=( RenderPassInputAttachmentAspectCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassInputAttachmentAspectCreateInfo; - const void * pNext = {}; - uint32_t aspectReferenceCount = {}; - const InputAttachmentAspectReference * pAspectReferences = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassInputAttachmentAspectCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassInputAttachmentAspectCreateInfo; - }; - - using RenderPassInputAttachmentAspectCreateInfoKHR = RenderPassInputAttachmentAspectCreateInfo; - - // wrapper struct for struct VkRenderPassMultiviewCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassMultiviewCreateInfo.html - struct RenderPassMultiviewCreateInfo - { - using NativeType = VkRenderPassMultiviewCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassMultiviewCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( uint32_t subpassCount_ = {}, - const uint32_t * pViewMasks_ = {}, - uint32_t dependencyCount_ = {}, - const int32_t * pViewOffsets_ = {}, - uint32_t correlationMaskCount_ = {}, - const uint32_t * pCorrelationMasks_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , subpassCount{ subpassCount_ } - , pViewMasks{ pViewMasks_ } - , dependencyCount{ dependencyCount_ } - , pViewOffsets{ pViewOffsets_ } - , correlationMaskCount{ correlationMaskCount_ } - , pCorrelationMasks{ pCorrelationMasks_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassMultiviewCreateInfo( RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassMultiviewCreateInfo( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassMultiviewCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassMultiviewCreateInfo( ArrayProxyNoTemporaries const & viewMasks_, - ArrayProxyNoTemporaries const & viewOffsets_ = {}, - ArrayProxyNoTemporaries const & correlationMasks_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , subpassCount( static_cast( viewMasks_.size() ) ) - , pViewMasks( viewMasks_.data() ) - , dependencyCount( static_cast( viewOffsets_.size() ) ) - , pViewOffsets( viewOffsets_.data() ) - , correlationMaskCount( static_cast( correlationMasks_.size() ) ) - , pCorrelationMasks( correlationMasks_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderPassMultiviewCreateInfo & operator=( RenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassMultiviewCreateInfo & operator=( VkRenderPassMultiviewCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setSubpassCount( uint32_t subpassCount_ ) & VULKAN_HPP_NOEXCEPT - { - subpassCount = subpassCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setSubpassCount( uint32_t subpassCount_ ) && VULKAN_HPP_NOEXCEPT - { - subpassCount = subpassCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setPViewMasks( const uint32_t * pViewMasks_ ) & VULKAN_HPP_NOEXCEPT - { - pViewMasks = pViewMasks_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setPViewMasks( const uint32_t * pViewMasks_ ) && VULKAN_HPP_NOEXCEPT - { - pViewMasks = pViewMasks_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassMultiviewCreateInfo & setViewMasks( ArrayProxyNoTemporaries const & viewMasks_ ) VULKAN_HPP_NOEXCEPT - { - subpassCount = static_cast( viewMasks_.size() ); - pViewMasks = viewMasks_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setDependencyCount( uint32_t dependencyCount_ ) & VULKAN_HPP_NOEXCEPT - { - dependencyCount = dependencyCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setDependencyCount( uint32_t dependencyCount_ ) && VULKAN_HPP_NOEXCEPT - { - dependencyCount = dependencyCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setPViewOffsets( const int32_t * pViewOffsets_ ) & VULKAN_HPP_NOEXCEPT - { - pViewOffsets = pViewOffsets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setPViewOffsets( const int32_t * pViewOffsets_ ) && VULKAN_HPP_NOEXCEPT - { - pViewOffsets = pViewOffsets_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassMultiviewCreateInfo & setViewOffsets( ArrayProxyNoTemporaries const & viewOffsets_ ) VULKAN_HPP_NOEXCEPT - { - dependencyCount = static_cast( viewOffsets_.size() ); - pViewOffsets = viewOffsets_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setCorrelationMaskCount( uint32_t correlationMaskCount_ ) & VULKAN_HPP_NOEXCEPT - { - correlationMaskCount = correlationMaskCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setCorrelationMaskCount( uint32_t correlationMaskCount_ ) && VULKAN_HPP_NOEXCEPT - { - correlationMaskCount = correlationMaskCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo & setPCorrelationMasks( const uint32_t * pCorrelationMasks_ ) & VULKAN_HPP_NOEXCEPT - { - pCorrelationMasks = pCorrelationMasks_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassMultiviewCreateInfo && setPCorrelationMasks( const uint32_t * pCorrelationMasks_ ) && VULKAN_HPP_NOEXCEPT - { - pCorrelationMasks = pCorrelationMasks_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassMultiviewCreateInfo & setCorrelationMasks( ArrayProxyNoTemporaries const & correlationMasks_ ) VULKAN_HPP_NOEXCEPT - { - correlationMaskCount = static_cast( correlationMasks_.size() ); - pCorrelationMasks = correlationMasks_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassMultiviewCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassMultiviewCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassMultiviewCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassMultiviewCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, subpassCount, pViewMasks, dependencyCount, pViewOffsets, correlationMaskCount, pCorrelationMasks ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassMultiviewCreateInfo const & ) const = default; -#else - bool operator==( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subpassCount == rhs.subpassCount ) && ( pViewMasks == rhs.pViewMasks ) && - ( dependencyCount == rhs.dependencyCount ) && ( pViewOffsets == rhs.pViewOffsets ) && ( correlationMaskCount == rhs.correlationMaskCount ) && - ( pCorrelationMasks == rhs.pCorrelationMasks ); -# endif - } - - bool operator!=( RenderPassMultiviewCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassMultiviewCreateInfo; - const void * pNext = {}; - uint32_t subpassCount = {}; - const uint32_t * pViewMasks = {}; - uint32_t dependencyCount = {}; - const int32_t * pViewOffsets = {}; - uint32_t correlationMaskCount = {}; - const uint32_t * pCorrelationMasks = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassMultiviewCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassMultiviewCreateInfo; - }; - - using RenderPassMultiviewCreateInfoKHR = RenderPassMultiviewCreateInfo; - - // wrapper struct for struct VkRenderPassPerformanceCountersByRegionBeginInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassPerformanceCountersByRegionBeginInfoARM.html - struct RenderPassPerformanceCountersByRegionBeginInfoARM - { - using NativeType = VkRenderPassPerformanceCountersByRegionBeginInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassPerformanceCountersByRegionBeginInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassPerformanceCountersByRegionBeginInfoARM( uint32_t counterAddressCount_ = {}, - const DeviceAddress * pCounterAddresses_ = {}, - Bool32 serializeRegions_ = {}, - uint32_t counterIndexCount_ = {}, - uint32_t * pCounterIndices_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , counterAddressCount{ counterAddressCount_ } - , pCounterAddresses{ pCounterAddresses_ } - , serializeRegions{ serializeRegions_ } - , counterIndexCount{ counterIndexCount_ } - , pCounterIndices{ pCounterIndices_ } - { - } - - VULKAN_HPP_CONSTEXPR - RenderPassPerformanceCountersByRegionBeginInfoARM( RenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassPerformanceCountersByRegionBeginInfoARM( VkRenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassPerformanceCountersByRegionBeginInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - RenderPassPerformanceCountersByRegionBeginInfoARM & - operator=( RenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassPerformanceCountersByRegionBeginInfoARM & operator=( VkRenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setCounterAddressCount( uint32_t counterAddressCount_ ) & VULKAN_HPP_NOEXCEPT - { - counterAddressCount = counterAddressCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setCounterAddressCount( uint32_t counterAddressCount_ ) && VULKAN_HPP_NOEXCEPT - { - counterAddressCount = counterAddressCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setPCounterAddresses( const DeviceAddress * pCounterAddresses_ ) & - VULKAN_HPP_NOEXCEPT - { - pCounterAddresses = pCounterAddresses_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setPCounterAddresses( const DeviceAddress * pCounterAddresses_ ) && - VULKAN_HPP_NOEXCEPT - { - pCounterAddresses = pCounterAddresses_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setSerializeRegions( Bool32 serializeRegions_ ) & VULKAN_HPP_NOEXCEPT - { - serializeRegions = serializeRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setSerializeRegions( Bool32 serializeRegions_ ) && VULKAN_HPP_NOEXCEPT - { - serializeRegions = serializeRegions_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setCounterIndexCount( uint32_t counterIndexCount_ ) & VULKAN_HPP_NOEXCEPT - { - counterIndexCount = counterIndexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setCounterIndexCount( uint32_t counterIndexCount_ ) && VULKAN_HPP_NOEXCEPT - { - counterIndexCount = counterIndexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM & setPCounterIndices( uint32_t * pCounterIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pCounterIndices = pCounterIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassPerformanceCountersByRegionBeginInfoARM && setPCounterIndices( uint32_t * pCounterIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pCounterIndices = pCounterIndices_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassPerformanceCountersByRegionBeginInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassPerformanceCountersByRegionBeginInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassPerformanceCountersByRegionBeginInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassPerformanceCountersByRegionBeginInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, counterAddressCount, pCounterAddresses, serializeRegions, counterIndexCount, pCounterIndices ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassPerformanceCountersByRegionBeginInfoARM const & ) const = default; -#else - bool operator==( RenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( counterAddressCount == rhs.counterAddressCount ) && - ( pCounterAddresses == rhs.pCounterAddresses ) && ( serializeRegions == rhs.serializeRegions ) && ( counterIndexCount == rhs.counterIndexCount ) && - ( pCounterIndices == rhs.pCounterIndices ); -# endif - } - - bool operator!=( RenderPassPerformanceCountersByRegionBeginInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassPerformanceCountersByRegionBeginInfoARM; - void * pNext = {}; - uint32_t counterAddressCount = {}; - const DeviceAddress * pCounterAddresses = {}; - Bool32 serializeRegions = {}; - uint32_t counterIndexCount = {}; - uint32_t * pCounterIndices = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassPerformanceCountersByRegionBeginInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassPerformanceCountersByRegionBeginInfoARM; - }; - - // wrapper struct for struct VkSubpassSampleLocationsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassSampleLocationsEXT.html - struct SubpassSampleLocationsEXT - { - using NativeType = VkSubpassSampleLocationsEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( uint32_t subpassIndex_ = {}, SampleLocationsInfoEXT sampleLocationsInfo_ = {} ) VULKAN_HPP_NOEXCEPT - : subpassIndex{ subpassIndex_ } - , sampleLocationsInfo{ sampleLocationsInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR SubpassSampleLocationsEXT( SubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubpassSampleLocationsEXT( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SubpassSampleLocationsEXT( *reinterpret_cast( &rhs ) ) - { - } - - SubpassSampleLocationsEXT & operator=( SubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubpassSampleLocationsEXT & operator=( VkSubpassSampleLocationsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubpassSampleLocationsEXT & setSubpassIndex( uint32_t subpassIndex_ ) & VULKAN_HPP_NOEXCEPT - { - subpassIndex = subpassIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassSampleLocationsEXT && setSubpassIndex( uint32_t subpassIndex_ ) && VULKAN_HPP_NOEXCEPT - { - subpassIndex = subpassIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassSampleLocationsEXT & setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) & VULKAN_HPP_NOEXCEPT - { - sampleLocationsInfo = sampleLocationsInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassSampleLocationsEXT && setSampleLocationsInfo( SampleLocationsInfoEXT const & sampleLocationsInfo_ ) && VULKAN_HPP_NOEXCEPT - { - sampleLocationsInfo = sampleLocationsInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubpassSampleLocationsEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassSampleLocationsEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassSampleLocationsEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubpassSampleLocationsEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( subpassIndex, sampleLocationsInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubpassSampleLocationsEXT const & ) const = default; -#else - bool operator==( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( subpassIndex == rhs.subpassIndex ) && ( sampleLocationsInfo == rhs.sampleLocationsInfo ); -# endif - } - - bool operator!=( SubpassSampleLocationsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t subpassIndex = {}; - SampleLocationsInfoEXT sampleLocationsInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubpassSampleLocationsEXT; - }; -#endif - - // wrapper struct for struct VkRenderPassSampleLocationsBeginInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassSampleLocationsBeginInfoEXT.html - struct RenderPassSampleLocationsBeginInfoEXT - { - using NativeType = VkRenderPassSampleLocationsBeginInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( uint32_t attachmentInitialSampleLocationsCount_ = {}, - const AttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations_ = {}, - uint32_t postSubpassSampleLocationsCount_ = {}, - const SubpassSampleLocationsEXT * pPostSubpassSampleLocations_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , attachmentInitialSampleLocationsCount{ attachmentInitialSampleLocationsCount_ } - , pAttachmentInitialSampleLocations{ pAttachmentInitialSampleLocations_ } - , postSubpassSampleLocationsCount{ postSubpassSampleLocationsCount_ } - , pPostSubpassSampleLocations{ pPostSubpassSampleLocations_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassSampleLocationsBeginInfoEXT( RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassSampleLocationsBeginInfoEXT( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassSampleLocationsBeginInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassSampleLocationsBeginInfoEXT( ArrayProxyNoTemporaries const & attachmentInitialSampleLocations_, - ArrayProxyNoTemporaries const & postSubpassSampleLocations_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , attachmentInitialSampleLocationsCount( static_cast( attachmentInitialSampleLocations_.size() ) ) - , pAttachmentInitialSampleLocations( attachmentInitialSampleLocations_.data() ) - , postSubpassSampleLocationsCount( static_cast( postSubpassSampleLocations_.size() ) ) - , pPostSubpassSampleLocations( postSubpassSampleLocations_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderPassSampleLocationsBeginInfoEXT & operator=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassSampleLocationsBeginInfoEXT & operator=( VkRenderPassSampleLocationsBeginInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT & - setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ ) & - VULKAN_HPP_NOEXCEPT - { - attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT && - setAttachmentInitialSampleLocationsCount( uint32_t attachmentInitialSampleLocationsCount_ ) && - VULKAN_HPP_NOEXCEPT - { - attachmentInitialSampleLocationsCount = attachmentInitialSampleLocationsCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT & - setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations_ ) & - VULKAN_HPP_NOEXCEPT - { - pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT && - setPAttachmentInitialSampleLocations( const AttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations_ ) && - VULKAN_HPP_NOEXCEPT - { - pAttachmentInitialSampleLocations = pAttachmentInitialSampleLocations_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassSampleLocationsBeginInfoEXT & setAttachmentInitialSampleLocations( - ArrayProxyNoTemporaries const & attachmentInitialSampleLocations_ ) VULKAN_HPP_NOEXCEPT - { - attachmentInitialSampleLocationsCount = static_cast( attachmentInitialSampleLocations_.size() ); - pAttachmentInitialSampleLocations = attachmentInitialSampleLocations_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT & setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ ) & - VULKAN_HPP_NOEXCEPT - { - postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT && setPostSubpassSampleLocationsCount( uint32_t postSubpassSampleLocationsCount_ ) && - VULKAN_HPP_NOEXCEPT - { - postSubpassSampleLocationsCount = postSubpassSampleLocationsCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT & - setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT * pPostSubpassSampleLocations_ ) & - VULKAN_HPP_NOEXCEPT - { - pPostSubpassSampleLocations = pPostSubpassSampleLocations_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSampleLocationsBeginInfoEXT && - setPPostSubpassSampleLocations( const SubpassSampleLocationsEXT * pPostSubpassSampleLocations_ ) && - VULKAN_HPP_NOEXCEPT - { - pPostSubpassSampleLocations = pPostSubpassSampleLocations_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassSampleLocationsBeginInfoEXT & - setPostSubpassSampleLocations( ArrayProxyNoTemporaries const & postSubpassSampleLocations_ ) VULKAN_HPP_NOEXCEPT - { - postSubpassSampleLocationsCount = static_cast( postSubpassSampleLocations_.size() ); - pPostSubpassSampleLocations = postSubpassSampleLocations_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassSampleLocationsBeginInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassSampleLocationsBeginInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassSampleLocationsBeginInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassSampleLocationsBeginInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, attachmentInitialSampleLocationsCount, pAttachmentInitialSampleLocations, postSubpassSampleLocationsCount, pPostSubpassSampleLocations ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassSampleLocationsBeginInfoEXT const & ) const = default; -#else - bool operator==( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( attachmentInitialSampleLocationsCount == rhs.attachmentInitialSampleLocationsCount ) && - ( pAttachmentInitialSampleLocations == rhs.pAttachmentInitialSampleLocations ) && - ( postSubpassSampleLocationsCount == rhs.postSubpassSampleLocationsCount ) && ( pPostSubpassSampleLocations == rhs.pPostSubpassSampleLocations ); -# endif - } - - bool operator!=( RenderPassSampleLocationsBeginInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassSampleLocationsBeginInfoEXT; - const void * pNext = {}; - uint32_t attachmentInitialSampleLocationsCount = {}; - const AttachmentSampleLocationsEXT * pAttachmentInitialSampleLocations = {}; - uint32_t postSubpassSampleLocationsCount = {}; - const SubpassSampleLocationsEXT * pPostSubpassSampleLocations = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassSampleLocationsBeginInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassSampleLocationsBeginInfoEXT; - }; - - // wrapper struct for struct VkRenderPassStripeInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassStripeInfoARM.html - struct RenderPassStripeInfoARM - { - using NativeType = VkRenderPassStripeInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassStripeInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassStripeInfoARM( Rect2D stripeArea_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stripeArea{ stripeArea_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassStripeInfoARM( RenderPassStripeInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassStripeInfoARM( VkRenderPassStripeInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassStripeInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - RenderPassStripeInfoARM & operator=( RenderPassStripeInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassStripeInfoARM & operator=( VkRenderPassStripeInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeInfoARM & setStripeArea( Rect2D const & stripeArea_ ) & VULKAN_HPP_NOEXCEPT - { - stripeArea = stripeArea_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeInfoARM && setStripeArea( Rect2D const & stripeArea_ ) && VULKAN_HPP_NOEXCEPT - { - stripeArea = stripeArea_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassStripeInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassStripeInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassStripeInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassStripeInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stripeArea ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassStripeInfoARM const & ) const = default; -#else - bool operator==( RenderPassStripeInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stripeArea == rhs.stripeArea ); -# endif - } - - bool operator!=( RenderPassStripeInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassStripeInfoARM; - const void * pNext = {}; - Rect2D stripeArea = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassStripeInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassStripeInfoARM; - }; - - // wrapper struct for struct VkRenderPassStripeBeginInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassStripeBeginInfoARM.html - struct RenderPassStripeBeginInfoARM - { - using NativeType = VkRenderPassStripeBeginInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassStripeBeginInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassStripeBeginInfoARM( uint32_t stripeInfoCount_ = {}, - const RenderPassStripeInfoARM * pStripeInfos_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stripeInfoCount{ stripeInfoCount_ } - , pStripeInfos{ pStripeInfos_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassStripeBeginInfoARM( RenderPassStripeBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassStripeBeginInfoARM( VkRenderPassStripeBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassStripeBeginInfoARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassStripeBeginInfoARM( ArrayProxyNoTemporaries const & stripeInfos_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), stripeInfoCount( static_cast( stripeInfos_.size() ) ), pStripeInfos( stripeInfos_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderPassStripeBeginInfoARM & operator=( RenderPassStripeBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassStripeBeginInfoARM & operator=( VkRenderPassStripeBeginInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM & setStripeInfoCount( uint32_t stripeInfoCount_ ) & VULKAN_HPP_NOEXCEPT - { - stripeInfoCount = stripeInfoCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM && setStripeInfoCount( uint32_t stripeInfoCount_ ) && VULKAN_HPP_NOEXCEPT - { - stripeInfoCount = stripeInfoCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM & setPStripeInfos( const RenderPassStripeInfoARM * pStripeInfos_ ) & VULKAN_HPP_NOEXCEPT - { - pStripeInfos = pStripeInfos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeBeginInfoARM && setPStripeInfos( const RenderPassStripeInfoARM * pStripeInfos_ ) && VULKAN_HPP_NOEXCEPT - { - pStripeInfos = pStripeInfos_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassStripeBeginInfoARM & setStripeInfos( ArrayProxyNoTemporaries const & stripeInfos_ ) VULKAN_HPP_NOEXCEPT - { - stripeInfoCount = static_cast( stripeInfos_.size() ); - pStripeInfos = stripeInfos_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassStripeBeginInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassStripeBeginInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassStripeBeginInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassStripeBeginInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stripeInfoCount, pStripeInfos ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassStripeBeginInfoARM const & ) const = default; -#else - bool operator==( RenderPassStripeBeginInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stripeInfoCount == rhs.stripeInfoCount ) && ( pStripeInfos == rhs.pStripeInfos ); -# endif - } - - bool operator!=( RenderPassStripeBeginInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassStripeBeginInfoARM; - const void * pNext = {}; - uint32_t stripeInfoCount = {}; - const RenderPassStripeInfoARM * pStripeInfos = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassStripeBeginInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassStripeBeginInfoARM; - }; - - // wrapper struct for struct VkSemaphoreSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreSubmitInfo.html - struct SemaphoreSubmitInfo - { - using NativeType = VkSemaphoreSubmitInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreSubmitInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SemaphoreSubmitInfo( Semaphore semaphore_ = {}, - uint64_t value_ = {}, - PipelineStageFlags2 stageMask_ = {}, - uint32_t deviceIndex_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , semaphore{ semaphore_ } - , value{ value_ } - , stageMask{ stageMask_ } - , deviceIndex{ deviceIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR SemaphoreSubmitInfo( SemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SemaphoreSubmitInfo( VkSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SemaphoreSubmitInfo( *reinterpret_cast( &rhs ) ) - { - } - - SemaphoreSubmitInfo & operator=( SemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SemaphoreSubmitInfo & operator=( VkSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo & setValue( uint64_t value_ ) & VULKAN_HPP_NOEXCEPT - { - value = value_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo && setValue( uint64_t value_ ) && VULKAN_HPP_NOEXCEPT - { - value = value_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo & setStageMask( PipelineStageFlags2 stageMask_ ) & VULKAN_HPP_NOEXCEPT - { - stageMask = stageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo && setStageMask( PipelineStageFlags2 stageMask_ ) && VULKAN_HPP_NOEXCEPT - { - stageMask = stageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo & setDeviceIndex( uint32_t deviceIndex_ ) & VULKAN_HPP_NOEXCEPT - { - deviceIndex = deviceIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSubmitInfo && setDeviceIndex( uint32_t deviceIndex_ ) && VULKAN_HPP_NOEXCEPT - { - deviceIndex = deviceIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSemaphoreSubmitInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreSubmitInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreSubmitInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSemaphoreSubmitInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, semaphore, value, stageMask, deviceIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SemaphoreSubmitInfo const & ) const = default; -#else - bool operator==( SemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( value == rhs.value ) && ( stageMask == rhs.stageMask ) && - ( deviceIndex == rhs.deviceIndex ); -# endif - } - - bool operator!=( SemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSemaphoreSubmitInfo; - const void * pNext = {}; - Semaphore semaphore = {}; - uint64_t value = {}; - PipelineStageFlags2 stageMask = {}; - uint32_t deviceIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SemaphoreSubmitInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SemaphoreSubmitInfo; - }; - - using SemaphoreSubmitInfoKHR = SemaphoreSubmitInfo; - - // wrapper struct for struct VkRenderPassStripeSubmitInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassStripeSubmitInfoARM.html - struct RenderPassStripeSubmitInfoARM - { - using NativeType = VkRenderPassStripeSubmitInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassStripeSubmitInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassStripeSubmitInfoARM( uint32_t stripeSemaphoreInfoCount_ = {}, - const SemaphoreSubmitInfo * pStripeSemaphoreInfos_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stripeSemaphoreInfoCount{ stripeSemaphoreInfoCount_ } - , pStripeSemaphoreInfos{ pStripeSemaphoreInfos_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassStripeSubmitInfoARM( RenderPassStripeSubmitInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassStripeSubmitInfoARM( VkRenderPassStripeSubmitInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassStripeSubmitInfoARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassStripeSubmitInfoARM( ArrayProxyNoTemporaries const & stripeSemaphoreInfos_, const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , stripeSemaphoreInfoCount( static_cast( stripeSemaphoreInfos_.size() ) ) - , pStripeSemaphoreInfos( stripeSemaphoreInfos_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderPassStripeSubmitInfoARM & operator=( RenderPassStripeSubmitInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassStripeSubmitInfoARM & operator=( VkRenderPassStripeSubmitInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM & setStripeSemaphoreInfoCount( uint32_t stripeSemaphoreInfoCount_ ) & VULKAN_HPP_NOEXCEPT - { - stripeSemaphoreInfoCount = stripeSemaphoreInfoCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM && setStripeSemaphoreInfoCount( uint32_t stripeSemaphoreInfoCount_ ) && VULKAN_HPP_NOEXCEPT - { - stripeSemaphoreInfoCount = stripeSemaphoreInfoCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM & setPStripeSemaphoreInfos( const SemaphoreSubmitInfo * pStripeSemaphoreInfos_ ) & VULKAN_HPP_NOEXCEPT - { - pStripeSemaphoreInfos = pStripeSemaphoreInfos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassStripeSubmitInfoARM && setPStripeSemaphoreInfos( const SemaphoreSubmitInfo * pStripeSemaphoreInfos_ ) && - VULKAN_HPP_NOEXCEPT - { - pStripeSemaphoreInfos = pStripeSemaphoreInfos_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderPassStripeSubmitInfoARM & - setStripeSemaphoreInfos( ArrayProxyNoTemporaries const & stripeSemaphoreInfos_ ) VULKAN_HPP_NOEXCEPT - { - stripeSemaphoreInfoCount = static_cast( stripeSemaphoreInfos_.size() ); - pStripeSemaphoreInfos = stripeSemaphoreInfos_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassStripeSubmitInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassStripeSubmitInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassStripeSubmitInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassStripeSubmitInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stripeSemaphoreInfoCount, pStripeSemaphoreInfos ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassStripeSubmitInfoARM const & ) const = default; -#else - bool operator==( RenderPassStripeSubmitInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stripeSemaphoreInfoCount == rhs.stripeSemaphoreInfoCount ) && - ( pStripeSemaphoreInfos == rhs.pStripeSemaphoreInfos ); -# endif - } - - bool operator!=( RenderPassStripeSubmitInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassStripeSubmitInfoARM; - const void * pNext = {}; - uint32_t stripeSemaphoreInfoCount = {}; - const SemaphoreSubmitInfo * pStripeSemaphoreInfos = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassStripeSubmitInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassStripeSubmitInfoARM; - }; - - // wrapper struct for struct VkRenderPassSubpassFeedbackInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassSubpassFeedbackInfoEXT.html - struct RenderPassSubpassFeedbackInfoEXT - { - using NativeType = VkRenderPassSubpassFeedbackInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackInfoEXT( SubpassMergeStatusEXT subpassMergeStatus_ = SubpassMergeStatusEXT::eMerged, - std::array const & description_ = {}, - uint32_t postMergeIndex_ = {} ) VULKAN_HPP_NOEXCEPT - : subpassMergeStatus{ subpassMergeStatus_ } - , description{ description_ } - , postMergeIndex{ postMergeIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackInfoEXT( RenderPassSubpassFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassSubpassFeedbackInfoEXT( VkRenderPassSubpassFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassSubpassFeedbackInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - RenderPassSubpassFeedbackInfoEXT & operator=( RenderPassSubpassFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassSubpassFeedbackInfoEXT & operator=( VkRenderPassSubpassFeedbackInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkRenderPassSubpassFeedbackInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassSubpassFeedbackInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassSubpassFeedbackInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassSubpassFeedbackInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, uint32_t const &> reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( subpassMergeStatus, description, postMergeIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( RenderPassSubpassFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = subpassMergeStatus <=> rhs.subpassMergeStatus; cmp != 0 ) - return cmp; - if ( auto cmp = strcmp( description, rhs.description ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = postMergeIndex <=> rhs.postMergeIndex; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( RenderPassSubpassFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( subpassMergeStatus == rhs.subpassMergeStatus ) && ( strcmp( description, rhs.description ) == 0 ) && ( postMergeIndex == rhs.postMergeIndex ); - } - - bool operator!=( RenderPassSubpassFeedbackInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - SubpassMergeStatusEXT subpassMergeStatus = SubpassMergeStatusEXT::eMerged; - ArrayWrapper1D description = {}; - uint32_t postMergeIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassSubpassFeedbackInfoEXT; - }; -#endif - - // wrapper struct for struct VkRenderPassSubpassFeedbackCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassSubpassFeedbackCreateInfoEXT.html - struct RenderPassSubpassFeedbackCreateInfoEXT - { - using NativeType = VkRenderPassSubpassFeedbackCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassSubpassFeedbackCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT( RenderPassSubpassFeedbackInfoEXT * pSubpassFeedback_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pSubpassFeedback{ pSubpassFeedback_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT( RenderPassSubpassFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassSubpassFeedbackCreateInfoEXT( VkRenderPassSubpassFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassSubpassFeedbackCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - RenderPassSubpassFeedbackCreateInfoEXT & operator=( RenderPassSubpassFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassSubpassFeedbackCreateInfoEXT & operator=( VkRenderPassSubpassFeedbackCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT & setPSubpassFeedback( RenderPassSubpassFeedbackInfoEXT * pSubpassFeedback_ ) & - VULKAN_HPP_NOEXCEPT - { - pSubpassFeedback = pSubpassFeedback_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassSubpassFeedbackCreateInfoEXT && setPSubpassFeedback( RenderPassSubpassFeedbackInfoEXT * pSubpassFeedback_ ) && - VULKAN_HPP_NOEXCEPT - { - pSubpassFeedback = pSubpassFeedback_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassSubpassFeedbackCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassSubpassFeedbackCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassSubpassFeedbackCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassSubpassFeedbackCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pSubpassFeedback ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassSubpassFeedbackCreateInfoEXT const & ) const = default; -#else - bool operator==( RenderPassSubpassFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pSubpassFeedback == rhs.pSubpassFeedback ); -# endif - } - - bool operator!=( RenderPassSubpassFeedbackCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassSubpassFeedbackCreateInfoEXT; - const void * pNext = {}; - RenderPassSubpassFeedbackInfoEXT * pSubpassFeedback = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassSubpassFeedbackCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassSubpassFeedbackCreateInfoEXT; - }; - - // wrapper struct for struct VkRenderPassTileShadingCreateInfoQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassTileShadingCreateInfoQCOM.html - struct RenderPassTileShadingCreateInfoQCOM - { - using NativeType = VkRenderPassTileShadingCreateInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassTileShadingCreateInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassTileShadingCreateInfoQCOM( TileShadingRenderPassFlagsQCOM flags_ = {}, - Extent2D tileApronSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , tileApronSize{ tileApronSize_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassTileShadingCreateInfoQCOM( RenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassTileShadingCreateInfoQCOM( VkRenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassTileShadingCreateInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - RenderPassTileShadingCreateInfoQCOM & operator=( RenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassTileShadingCreateInfoQCOM & operator=( VkRenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM & setFlags( TileShadingRenderPassFlagsQCOM flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM && setFlags( TileShadingRenderPassFlagsQCOM flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM & setTileApronSize( Extent2D const & tileApronSize_ ) & VULKAN_HPP_NOEXCEPT - { - tileApronSize = tileApronSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM && setTileApronSize( Extent2D const & tileApronSize_ ) && VULKAN_HPP_NOEXCEPT - { - tileApronSize = tileApronSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassTileShadingCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassTileShadingCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassTileShadingCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassTileShadingCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, tileApronSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassTileShadingCreateInfoQCOM const & ) const = default; -#else - bool operator==( RenderPassTileShadingCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( tileApronSize == rhs.tileApronSize ); -# endif - } - - bool operator!=( RenderPassTileShadingCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassTileShadingCreateInfoQCOM; - const void * pNext = {}; - TileShadingRenderPassFlagsQCOM flags = {}; - Extent2D tileApronSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassTileShadingCreateInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassTileShadingCreateInfoQCOM; - }; - - // wrapper struct for struct VkRenderPassTransformBeginInfoQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassTransformBeginInfoQCOM.html - struct RenderPassTransformBeginInfoQCOM - { - using NativeType = VkRenderPassTransformBeginInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassTransformBeginInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderPassTransformBeginInfoQCOM( SurfaceTransformFlagBitsKHR transform_ = SurfaceTransformFlagBitsKHR::eIdentity, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , transform{ transform_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderPassTransformBeginInfoQCOM( RenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderPassTransformBeginInfoQCOM( VkRenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderPassTransformBeginInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - RenderPassTransformBeginInfoQCOM & operator=( RenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderPassTransformBeginInfoQCOM & operator=( VkRenderPassTransformBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderPassTransformBeginInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassTransformBeginInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassTransformBeginInfoQCOM & setTransform( SurfaceTransformFlagBitsKHR transform_ ) & VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderPassTransformBeginInfoQCOM && setTransform( SurfaceTransformFlagBitsKHR transform_ ) && VULKAN_HPP_NOEXCEPT - { - transform = transform_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderPassTransformBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassTransformBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderPassTransformBeginInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderPassTransformBeginInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, transform ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderPassTransformBeginInfoQCOM const & ) const = default; -#else - bool operator==( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( transform == rhs.transform ); -# endif - } - - bool operator!=( RenderPassTransformBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderPassTransformBeginInfoQCOM; - const void * pNext = {}; - SurfaceTransformFlagBitsKHR transform = SurfaceTransformFlagBitsKHR::eIdentity; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderPassTransformBeginInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = RenderPassTransformBeginInfoQCOM; - }; - - // wrapper struct for struct VkRenderingAreaInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAreaInfo.html - struct RenderingAreaInfo - { - using NativeType = VkRenderingAreaInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingAreaInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderingAreaInfo( uint32_t viewMask_ = {}, - uint32_t colorAttachmentCount_ = {}, - const Format * pColorAttachmentFormats_ = {}, - Format depthAttachmentFormat_ = Format::eUndefined, - Format stencilAttachmentFormat_ = Format::eUndefined, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , viewMask{ viewMask_ } - , colorAttachmentCount{ colorAttachmentCount_ } - , pColorAttachmentFormats{ pColorAttachmentFormats_ } - , depthAttachmentFormat{ depthAttachmentFormat_ } - , stencilAttachmentFormat{ stencilAttachmentFormat_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderingAreaInfo( RenderingAreaInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderingAreaInfo( VkRenderingAreaInfo const & rhs ) VULKAN_HPP_NOEXCEPT : RenderingAreaInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderingAreaInfo( uint32_t viewMask_, - ArrayProxyNoTemporaries const & colorAttachmentFormats_, - Format depthAttachmentFormat_ = Format::eUndefined, - Format stencilAttachmentFormat_ = Format::eUndefined, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , viewMask( viewMask_ ) - , colorAttachmentCount( static_cast( colorAttachmentFormats_.size() ) ) - , pColorAttachmentFormats( colorAttachmentFormats_.data() ) - , depthAttachmentFormat( depthAttachmentFormat_ ) - , stencilAttachmentFormat( stencilAttachmentFormat_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderingAreaInfo & operator=( RenderingAreaInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderingAreaInfo & operator=( VkRenderingAreaInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setViewMask( uint32_t viewMask_ ) & VULKAN_HPP_NOEXCEPT - { - viewMask = viewMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setViewMask( uint32_t viewMask_ ) && VULKAN_HPP_NOEXCEPT - { - viewMask = viewMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) & VULKAN_HPP_NOEXCEPT - { - pColorAttachmentFormats = pColorAttachmentFormats_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setPColorAttachmentFormats( const Format * pColorAttachmentFormats_ ) && VULKAN_HPP_NOEXCEPT - { - pColorAttachmentFormats = pColorAttachmentFormats_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderingAreaInfo & setColorAttachmentFormats( ArrayProxyNoTemporaries const & colorAttachmentFormats_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( colorAttachmentFormats_.size() ); - pColorAttachmentFormats = colorAttachmentFormats_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setDepthAttachmentFormat( Format depthAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT - { - depthAttachmentFormat = depthAttachmentFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setDepthAttachmentFormat( Format depthAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT - { - depthAttachmentFormat = depthAttachmentFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo & setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) & VULKAN_HPP_NOEXCEPT - { - stencilAttachmentFormat = stencilAttachmentFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAreaInfo && setStencilAttachmentFormat( Format stencilAttachmentFormat_ ) && VULKAN_HPP_NOEXCEPT - { - stencilAttachmentFormat = stencilAttachmentFormat_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderingAreaInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingAreaInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingAreaInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderingAreaInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, viewMask, colorAttachmentCount, pColorAttachmentFormats, depthAttachmentFormat, stencilAttachmentFormat ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderingAreaInfo const & ) const = default; -#else - bool operator==( RenderingAreaInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachmentFormats == rhs.pColorAttachmentFormats ) && ( depthAttachmentFormat == rhs.depthAttachmentFormat ) && - ( stencilAttachmentFormat == rhs.stencilAttachmentFormat ); -# endif - } - - bool operator!=( RenderingAreaInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderingAreaInfo; - const void * pNext = {}; - uint32_t viewMask = {}; - uint32_t colorAttachmentCount = {}; - const Format * pColorAttachmentFormats = {}; - Format depthAttachmentFormat = Format::eUndefined; - Format stencilAttachmentFormat = Format::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderingAreaInfo; - }; -#endif - - template <> - struct CppType - { - using Type = RenderingAreaInfo; - }; - - using RenderingAreaInfoKHR = RenderingAreaInfo; - - // wrapper struct for struct VkRenderingAttachmentFlagsInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentFlagsInfoKHR.html - struct RenderingAttachmentFlagsInfoKHR - { - using NativeType = VkRenderingAttachmentFlagsInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingAttachmentFlagsInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderingAttachmentFlagsInfoKHR( RenderingAttachmentFlagsKHR flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderingAttachmentFlagsInfoKHR( RenderingAttachmentFlagsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderingAttachmentFlagsInfoKHR( VkRenderingAttachmentFlagsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderingAttachmentFlagsInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - RenderingAttachmentFlagsInfoKHR & operator=( RenderingAttachmentFlagsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderingAttachmentFlagsInfoKHR & operator=( VkRenderingAttachmentFlagsInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentFlagsInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentFlagsInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentFlagsInfoKHR & setFlags( RenderingAttachmentFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentFlagsInfoKHR && setFlags( RenderingAttachmentFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderingAttachmentFlagsInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingAttachmentFlagsInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingAttachmentFlagsInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderingAttachmentFlagsInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderingAttachmentFlagsInfoKHR const & ) const = default; -#else - bool operator==( RenderingAttachmentFlagsInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( RenderingAttachmentFlagsInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderingAttachmentFlagsInfoKHR; - const void * pNext = {}; - RenderingAttachmentFlagsKHR flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderingAttachmentFlagsInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = RenderingAttachmentFlagsInfoKHR; - }; - - // wrapper struct for struct VkRenderingAttachmentInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentInfo.html - struct RenderingAttachmentInfo - { - using NativeType = VkRenderingAttachmentInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingAttachmentInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo( ImageView imageView_ = {}, - ImageLayout imageLayout_ = ImageLayout::eUndefined, - ResolveModeFlagBits resolveMode_ = ResolveModeFlagBits::eNone, - ImageView resolveImageView_ = {}, - ImageLayout resolveImageLayout_ = ImageLayout::eUndefined, - AttachmentLoadOp loadOp_ = AttachmentLoadOp::eLoad, - AttachmentStoreOp storeOp_ = AttachmentStoreOp::eStore, - ClearValue clearValue_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageView{ imageView_ } - , imageLayout{ imageLayout_ } - , resolveMode{ resolveMode_ } - , resolveImageView{ resolveImageView_ } - , resolveImageLayout{ resolveImageLayout_ } - , loadOp{ loadOp_ } - , storeOp{ storeOp_ } - , clearValue{ clearValue_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo( RenderingAttachmentInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderingAttachmentInfo( VkRenderingAttachmentInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderingAttachmentInfo( *reinterpret_cast( &rhs ) ) - { - } - - RenderingAttachmentInfo & operator=( RenderingAttachmentInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderingAttachmentInfo & operator=( VkRenderingAttachmentInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setImageLayout( ImageLayout imageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - imageLayout = imageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setImageLayout( ImageLayout imageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - imageLayout = imageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setResolveMode( ResolveModeFlagBits resolveMode_ ) & VULKAN_HPP_NOEXCEPT - { - resolveMode = resolveMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setResolveMode( ResolveModeFlagBits resolveMode_ ) && VULKAN_HPP_NOEXCEPT - { - resolveMode = resolveMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setResolveImageView( ImageView resolveImageView_ ) & VULKAN_HPP_NOEXCEPT - { - resolveImageView = resolveImageView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setResolveImageView( ImageView resolveImageView_ ) && VULKAN_HPP_NOEXCEPT - { - resolveImageView = resolveImageView_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setResolveImageLayout( ImageLayout resolveImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - resolveImageLayout = resolveImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setResolveImageLayout( ImageLayout resolveImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - resolveImageLayout = resolveImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setLoadOp( AttachmentLoadOp loadOp_ ) & VULKAN_HPP_NOEXCEPT - { - loadOp = loadOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setLoadOp( AttachmentLoadOp loadOp_ ) && VULKAN_HPP_NOEXCEPT - { - loadOp = loadOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setStoreOp( AttachmentStoreOp storeOp_ ) & VULKAN_HPP_NOEXCEPT - { - storeOp = storeOp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setStoreOp( AttachmentStoreOp storeOp_ ) && VULKAN_HPP_NOEXCEPT - { - storeOp = storeOp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo & setClearValue( ClearValue const & clearValue_ ) & VULKAN_HPP_NOEXCEPT - { - clearValue = clearValue_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentInfo && setClearValue( ClearValue const & clearValue_ ) && VULKAN_HPP_NOEXCEPT - { - clearValue = clearValue_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderingAttachmentInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingAttachmentInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingAttachmentInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderingAttachmentInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageView, imageLayout, resolveMode, resolveImageView, resolveImageLayout, loadOp, storeOp, clearValue ); - } -#endif - - public: - StructureType sType = StructureType::eRenderingAttachmentInfo; - const void * pNext = {}; - ImageView imageView = {}; - ImageLayout imageLayout = ImageLayout::eUndefined; - ResolveModeFlagBits resolveMode = ResolveModeFlagBits::eNone; - ImageView resolveImageView = {}; - ImageLayout resolveImageLayout = ImageLayout::eUndefined; - AttachmentLoadOp loadOp = AttachmentLoadOp::eLoad; - AttachmentStoreOp storeOp = AttachmentStoreOp::eStore; - ClearValue clearValue = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderingAttachmentInfo; - }; -#endif - - template <> - struct CppType - { - using Type = RenderingAttachmentInfo; - }; - - using RenderingAttachmentInfoKHR = RenderingAttachmentInfo; - - // wrapper struct for struct VkRenderingAttachmentLocationInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingAttachmentLocationInfo.html - struct RenderingAttachmentLocationInfo - { - using NativeType = VkRenderingAttachmentLocationInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingAttachmentLocationInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderingAttachmentLocationInfo( uint32_t colorAttachmentCount_ = {}, - const uint32_t * pColorAttachmentLocations_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , colorAttachmentCount{ colorAttachmentCount_ } - , pColorAttachmentLocations{ pColorAttachmentLocations_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderingAttachmentLocationInfo( RenderingAttachmentLocationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderingAttachmentLocationInfo( VkRenderingAttachmentLocationInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderingAttachmentLocationInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderingAttachmentLocationInfo( ArrayProxyNoTemporaries const & colorAttachmentLocations_, const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , colorAttachmentCount( static_cast( colorAttachmentLocations_.size() ) ) - , pColorAttachmentLocations( colorAttachmentLocations_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderingAttachmentLocationInfo & operator=( RenderingAttachmentLocationInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderingAttachmentLocationInfo & operator=( VkRenderingAttachmentLocationInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo & setPColorAttachmentLocations( const uint32_t * pColorAttachmentLocations_ ) & VULKAN_HPP_NOEXCEPT - { - pColorAttachmentLocations = pColorAttachmentLocations_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingAttachmentLocationInfo && setPColorAttachmentLocations( const uint32_t * pColorAttachmentLocations_ ) && - VULKAN_HPP_NOEXCEPT - { - pColorAttachmentLocations = pColorAttachmentLocations_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderingAttachmentLocationInfo & - setColorAttachmentLocations( ArrayProxyNoTemporaries const & colorAttachmentLocations_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( colorAttachmentLocations_.size() ); - pColorAttachmentLocations = colorAttachmentLocations_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderingAttachmentLocationInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingAttachmentLocationInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingAttachmentLocationInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderingAttachmentLocationInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentLocations ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderingAttachmentLocationInfo const & ) const = default; -#else - bool operator==( RenderingAttachmentLocationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachmentLocations == rhs.pColorAttachmentLocations ); -# endif - } - - bool operator!=( RenderingAttachmentLocationInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderingAttachmentLocationInfo; - const void * pNext = {}; - uint32_t colorAttachmentCount = {}; - const uint32_t * pColorAttachmentLocations = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderingAttachmentLocationInfo; - }; -#endif - - template <> - struct CppType - { - using Type = RenderingAttachmentLocationInfo; - }; - - using RenderingAttachmentLocationInfoKHR = RenderingAttachmentLocationInfo; - - // wrapper struct for struct VkRenderingEndInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingEndInfoKHR.html - struct RenderingEndInfoKHR - { - using NativeType = VkRenderingEndInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingEndInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderingEndInfoKHR( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} - - VULKAN_HPP_CONSTEXPR RenderingEndInfoKHR( RenderingEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderingEndInfoKHR( VkRenderingEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : RenderingEndInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - RenderingEndInfoKHR & operator=( RenderingEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderingEndInfoKHR & operator=( VkRenderingEndInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderingEndInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingEndInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderingEndInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingEndInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingEndInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderingEndInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderingEndInfoKHR const & ) const = default; -#else - bool operator==( RenderingEndInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); -# endif - } - - bool operator!=( RenderingEndInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderingEndInfoKHR; - const void * pNext = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderingEndInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = RenderingEndInfoKHR; - }; - - using RenderingEndInfoEXT = RenderingEndInfoKHR; - - // wrapper struct for struct VkRenderingFragmentDensityMapAttachmentInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFragmentDensityMapAttachmentInfoEXT.html - struct RenderingFragmentDensityMapAttachmentInfoEXT - { - using NativeType = VkRenderingFragmentDensityMapAttachmentInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingFragmentDensityMapAttachmentInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderingFragmentDensityMapAttachmentInfoEXT( ImageView imageView_ = {}, - ImageLayout imageLayout_ = ImageLayout::eUndefined, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageView{ imageView_ } - , imageLayout{ imageLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderingFragmentDensityMapAttachmentInfoEXT( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderingFragmentDensityMapAttachmentInfoEXT( VkRenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderingFragmentDensityMapAttachmentInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - RenderingFragmentDensityMapAttachmentInfoEXT & operator=( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderingFragmentDensityMapAttachmentInfoEXT & operator=( VkRenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT & setImageLayout( ImageLayout imageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - imageLayout = imageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentDensityMapAttachmentInfoEXT && setImageLayout( ImageLayout imageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - imageLayout = imageLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderingFragmentDensityMapAttachmentInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingFragmentDensityMapAttachmentInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingFragmentDensityMapAttachmentInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderingFragmentDensityMapAttachmentInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageView, imageLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderingFragmentDensityMapAttachmentInfoEXT const & ) const = default; -#else - bool operator==( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout ); -# endif - } - - bool operator!=( RenderingFragmentDensityMapAttachmentInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderingFragmentDensityMapAttachmentInfoEXT; - const void * pNext = {}; - ImageView imageView = {}; - ImageLayout imageLayout = ImageLayout::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderingFragmentDensityMapAttachmentInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = RenderingFragmentDensityMapAttachmentInfoEXT; - }; - - // wrapper struct for struct VkRenderingFragmentShadingRateAttachmentInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingFragmentShadingRateAttachmentInfoKHR.html - struct RenderingFragmentShadingRateAttachmentInfoKHR - { - using NativeType = VkRenderingFragmentShadingRateAttachmentInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingFragmentShadingRateAttachmentInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderingFragmentShadingRateAttachmentInfoKHR( ImageView imageView_ = {}, - ImageLayout imageLayout_ = ImageLayout::eUndefined, - Extent2D shadingRateAttachmentTexelSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , imageView{ imageView_ } - , imageLayout{ imageLayout_ } - , shadingRateAttachmentTexelSize{ shadingRateAttachmentTexelSize_ } - { - } - - VULKAN_HPP_CONSTEXPR - RenderingFragmentShadingRateAttachmentInfoKHR( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderingFragmentShadingRateAttachmentInfoKHR( VkRenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderingFragmentShadingRateAttachmentInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - RenderingFragmentShadingRateAttachmentInfoKHR & operator=( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderingFragmentShadingRateAttachmentInfoKHR & operator=( VkRenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR & setImageView( ImageView imageView_ ) & VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR && setImageView( ImageView imageView_ ) && VULKAN_HPP_NOEXCEPT - { - imageView = imageView_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR & setImageLayout( ImageLayout imageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - imageLayout = imageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR && setImageLayout( ImageLayout imageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - imageLayout = imageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR & - setShadingRateAttachmentTexelSize( Extent2D const & shadingRateAttachmentTexelSize_ ) & - VULKAN_HPP_NOEXCEPT - { - shadingRateAttachmentTexelSize = shadingRateAttachmentTexelSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingFragmentShadingRateAttachmentInfoKHR && - setShadingRateAttachmentTexelSize( Extent2D const & shadingRateAttachmentTexelSize_ ) && - VULKAN_HPP_NOEXCEPT - { - shadingRateAttachmentTexelSize = shadingRateAttachmentTexelSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderingFragmentShadingRateAttachmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingFragmentShadingRateAttachmentInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingFragmentShadingRateAttachmentInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderingFragmentShadingRateAttachmentInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, imageView, imageLayout, shadingRateAttachmentTexelSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderingFragmentShadingRateAttachmentInfoKHR const & ) const = default; -#else - bool operator==( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( imageView == rhs.imageView ) && ( imageLayout == rhs.imageLayout ) && - ( shadingRateAttachmentTexelSize == rhs.shadingRateAttachmentTexelSize ); -# endif - } - - bool operator!=( RenderingFragmentShadingRateAttachmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderingFragmentShadingRateAttachmentInfoKHR; - const void * pNext = {}; - ImageView imageView = {}; - ImageLayout imageLayout = ImageLayout::eUndefined; - Extent2D shadingRateAttachmentTexelSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderingFragmentShadingRateAttachmentInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = RenderingFragmentShadingRateAttachmentInfoKHR; - }; - - // wrapper struct for struct VkRenderingInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingInfo.html - struct RenderingInfo - { - using NativeType = VkRenderingInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 RenderingInfo( RenderingFlags flags_ = {}, - Rect2D renderArea_ = {}, - uint32_t layerCount_ = {}, - uint32_t viewMask_ = {}, - uint32_t colorAttachmentCount_ = {}, - const RenderingAttachmentInfo * pColorAttachments_ = {}, - const RenderingAttachmentInfo * pDepthAttachment_ = {}, - const RenderingAttachmentInfo * pStencilAttachment_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , renderArea{ renderArea_ } - , layerCount{ layerCount_ } - , viewMask{ viewMask_ } - , colorAttachmentCount{ colorAttachmentCount_ } - , pColorAttachments{ pColorAttachments_ } - , pDepthAttachment{ pDepthAttachment_ } - , pStencilAttachment{ pStencilAttachment_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo( RenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderingInfo( VkRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT : RenderingInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderingInfo( RenderingFlags flags_, - Rect2D renderArea_, - uint32_t layerCount_, - uint32_t viewMask_, - ArrayProxyNoTemporaries const & colorAttachments_, - const RenderingAttachmentInfo * pDepthAttachment_ = {}, - const RenderingAttachmentInfo * pStencilAttachment_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , renderArea( renderArea_ ) - , layerCount( layerCount_ ) - , viewMask( viewMask_ ) - , colorAttachmentCount( static_cast( colorAttachments_.size() ) ) - , pColorAttachments( colorAttachments_.data() ) - , pDepthAttachment( pDepthAttachment_ ) - , pStencilAttachment( pStencilAttachment_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderingInfo & operator=( RenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderingInfo & operator=( VkRenderingInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setFlags( RenderingFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setFlags( RenderingFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setRenderArea( Rect2D const & renderArea_ ) & VULKAN_HPP_NOEXCEPT - { - renderArea = renderArea_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setRenderArea( Rect2D const & renderArea_ ) && VULKAN_HPP_NOEXCEPT - { - renderArea = renderArea_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setViewMask( uint32_t viewMask_ ) & VULKAN_HPP_NOEXCEPT - { - viewMask = viewMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setViewMask( uint32_t viewMask_ ) && VULKAN_HPP_NOEXCEPT - { - viewMask = viewMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setPColorAttachments( const RenderingAttachmentInfo * pColorAttachments_ ) & VULKAN_HPP_NOEXCEPT - { - pColorAttachments = pColorAttachments_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setPColorAttachments( const RenderingAttachmentInfo * pColorAttachments_ ) && VULKAN_HPP_NOEXCEPT - { - pColorAttachments = pColorAttachments_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderingInfo & setColorAttachments( ArrayProxyNoTemporaries const & colorAttachments_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( colorAttachments_.size() ); - pColorAttachments = colorAttachments_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setPDepthAttachment( const RenderingAttachmentInfo * pDepthAttachment_ ) & VULKAN_HPP_NOEXCEPT - { - pDepthAttachment = pDepthAttachment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setPDepthAttachment( const RenderingAttachmentInfo * pDepthAttachment_ ) && VULKAN_HPP_NOEXCEPT - { - pDepthAttachment = pDepthAttachment_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo & setPStencilAttachment( const RenderingAttachmentInfo * pStencilAttachment_ ) & VULKAN_HPP_NOEXCEPT - { - pStencilAttachment = pStencilAttachment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInfo && setPStencilAttachment( const RenderingAttachmentInfo * pStencilAttachment_ ) && VULKAN_HPP_NOEXCEPT - { - pStencilAttachment = pStencilAttachment_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderingInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderingInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, renderArea, layerCount, viewMask, colorAttachmentCount, pColorAttachments, pDepthAttachment, pStencilAttachment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderingInfo const & ) const = default; -#else - bool operator==( RenderingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( renderArea == rhs.renderArea ) && - ( layerCount == rhs.layerCount ) && ( viewMask == rhs.viewMask ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachments == rhs.pColorAttachments ) && ( pDepthAttachment == rhs.pDepthAttachment ) && ( pStencilAttachment == rhs.pStencilAttachment ); -# endif - } - - bool operator!=( RenderingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderingInfo; - const void * pNext = {}; - RenderingFlags flags = {}; - Rect2D renderArea = {}; - uint32_t layerCount = {}; - uint32_t viewMask = {}; - uint32_t colorAttachmentCount = {}; - const RenderingAttachmentInfo * pColorAttachments = {}; - const RenderingAttachmentInfo * pDepthAttachment = {}; - const RenderingAttachmentInfo * pStencilAttachment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderingInfo; - }; -#endif - - template <> - struct CppType - { - using Type = RenderingInfo; - }; - - using RenderingInfoKHR = RenderingInfo; - - // wrapper struct for struct VkRenderingInputAttachmentIndexInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderingInputAttachmentIndexInfo.html - struct RenderingInputAttachmentIndexInfo - { - using NativeType = VkRenderingInputAttachmentIndexInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderingInputAttachmentIndexInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR RenderingInputAttachmentIndexInfo( uint32_t colorAttachmentCount_ = {}, - const uint32_t * pColorAttachmentInputIndices_ = {}, - const uint32_t * pDepthInputAttachmentIndex_ = {}, - const uint32_t * pStencilInputAttachmentIndex_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , colorAttachmentCount{ colorAttachmentCount_ } - , pColorAttachmentInputIndices{ pColorAttachmentInputIndices_ } - , pDepthInputAttachmentIndex{ pDepthInputAttachmentIndex_ } - , pStencilInputAttachmentIndex{ pStencilInputAttachmentIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR RenderingInputAttachmentIndexInfo( RenderingInputAttachmentIndexInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - RenderingInputAttachmentIndexInfo( VkRenderingInputAttachmentIndexInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : RenderingInputAttachmentIndexInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderingInputAttachmentIndexInfo( ArrayProxyNoTemporaries const & colorAttachmentInputIndices_, - const uint32_t * pDepthInputAttachmentIndex_ = {}, - const uint32_t * pStencilInputAttachmentIndex_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , colorAttachmentCount( static_cast( colorAttachmentInputIndices_.size() ) ) - , pColorAttachmentInputIndices( colorAttachmentInputIndices_.data() ) - , pDepthInputAttachmentIndex( pDepthInputAttachmentIndex_ ) - , pStencilInputAttachmentIndex( pStencilInputAttachmentIndex_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - RenderingInputAttachmentIndexInfo & operator=( RenderingInputAttachmentIndexInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - RenderingInputAttachmentIndexInfo & operator=( VkRenderingInputAttachmentIndexInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo & setColorAttachmentCount( uint32_t colorAttachmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo && setColorAttachmentCount( uint32_t colorAttachmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = colorAttachmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo & setPColorAttachmentInputIndices( const uint32_t * pColorAttachmentInputIndices_ ) & - VULKAN_HPP_NOEXCEPT - { - pColorAttachmentInputIndices = pColorAttachmentInputIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo && setPColorAttachmentInputIndices( const uint32_t * pColorAttachmentInputIndices_ ) && - VULKAN_HPP_NOEXCEPT - { - pColorAttachmentInputIndices = pColorAttachmentInputIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - RenderingInputAttachmentIndexInfo & - setColorAttachmentInputIndices( ArrayProxyNoTemporaries const & colorAttachmentInputIndices_ ) VULKAN_HPP_NOEXCEPT - { - colorAttachmentCount = static_cast( colorAttachmentInputIndices_.size() ); - pColorAttachmentInputIndices = colorAttachmentInputIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo & setPDepthInputAttachmentIndex( const uint32_t * pDepthInputAttachmentIndex_ ) & - VULKAN_HPP_NOEXCEPT - { - pDepthInputAttachmentIndex = pDepthInputAttachmentIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo && setPDepthInputAttachmentIndex( const uint32_t * pDepthInputAttachmentIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - pDepthInputAttachmentIndex = pDepthInputAttachmentIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo & setPStencilInputAttachmentIndex( const uint32_t * pStencilInputAttachmentIndex_ ) & - VULKAN_HPP_NOEXCEPT - { - pStencilInputAttachmentIndex = pStencilInputAttachmentIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 RenderingInputAttachmentIndexInfo && setPStencilInputAttachmentIndex( const uint32_t * pStencilInputAttachmentIndex_ ) && - VULKAN_HPP_NOEXCEPT - { - pStencilInputAttachmentIndex = pStencilInputAttachmentIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkRenderingInputAttachmentIndexInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingInputAttachmentIndexInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkRenderingInputAttachmentIndexInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkRenderingInputAttachmentIndexInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, colorAttachmentCount, pColorAttachmentInputIndices, pDepthInputAttachmentIndex, pStencilInputAttachmentIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( RenderingInputAttachmentIndexInfo const & ) const = default; -#else - bool operator==( RenderingInputAttachmentIndexInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( colorAttachmentCount == rhs.colorAttachmentCount ) && - ( pColorAttachmentInputIndices == rhs.pColorAttachmentInputIndices ) && ( pDepthInputAttachmentIndex == rhs.pDepthInputAttachmentIndex ) && - ( pStencilInputAttachmentIndex == rhs.pStencilInputAttachmentIndex ); -# endif - } - - bool operator!=( RenderingInputAttachmentIndexInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eRenderingInputAttachmentIndexInfo; - const void * pNext = {}; - uint32_t colorAttachmentCount = {}; - const uint32_t * pColorAttachmentInputIndices = {}; - const uint32_t * pDepthInputAttachmentIndex = {}; - const uint32_t * pStencilInputAttachmentIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = RenderingInputAttachmentIndexInfo; - }; -#endif - - template <> - struct CppType - { - using Type = RenderingInputAttachmentIndexInfo; - }; - - using RenderingInputAttachmentIndexInfoKHR = RenderingInputAttachmentIndexInfo; - - // wrapper struct for struct VkResolveImageInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveImageInfo2.html - struct ResolveImageInfo2 - { - using NativeType = VkResolveImageInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eResolveImageInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ResolveImageInfo2( Image srcImage_ = {}, - ImageLayout srcImageLayout_ = ImageLayout::eUndefined, - Image dstImage_ = {}, - ImageLayout dstImageLayout_ = ImageLayout::eUndefined, - uint32_t regionCount_ = {}, - const ImageResolve2 * pRegions_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcImage{ srcImage_ } - , srcImageLayout{ srcImageLayout_ } - , dstImage{ dstImage_ } - , dstImageLayout{ dstImageLayout_ } - , regionCount{ regionCount_ } - , pRegions{ pRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR ResolveImageInfo2( ResolveImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ResolveImageInfo2( VkResolveImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : ResolveImageInfo2( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ResolveImageInfo2( Image srcImage_, - ImageLayout srcImageLayout_, - Image dstImage_, - ImageLayout dstImageLayout_, - ArrayProxyNoTemporaries const & regions_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , srcImage( srcImage_ ) - , srcImageLayout( srcImageLayout_ ) - , dstImage( dstImage_ ) - , dstImageLayout( dstImageLayout_ ) - , regionCount( static_cast( regions_.size() ) ) - , pRegions( regions_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ResolveImageInfo2 & operator=( ResolveImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ResolveImageInfo2 & operator=( VkResolveImageInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setSrcImage( Image srcImage_ ) & VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setSrcImage( Image srcImage_ ) && VULKAN_HPP_NOEXCEPT - { - srcImage = srcImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setSrcImageLayout( ImageLayout srcImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setSrcImageLayout( ImageLayout srcImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - srcImageLayout = srcImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setDstImage( Image dstImage_ ) & VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setDstImage( Image dstImage_ ) && VULKAN_HPP_NOEXCEPT - { - dstImage = dstImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setDstImageLayout( ImageLayout dstImageLayout_ ) & VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setDstImageLayout( ImageLayout dstImageLayout_ ) && VULKAN_HPP_NOEXCEPT - { - dstImageLayout = dstImageLayout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setRegionCount( uint32_t regionCount_ ) & VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setRegionCount( uint32_t regionCount_ ) && VULKAN_HPP_NOEXCEPT - { - regionCount = regionCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 & setPRegions( const ImageResolve2 * pRegions_ ) & VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageInfo2 && setPRegions( const ImageResolve2 * pRegions_ ) && VULKAN_HPP_NOEXCEPT - { - pRegions = pRegions_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ResolveImageInfo2 & setRegions( ArrayProxyNoTemporaries const & regions_ ) VULKAN_HPP_NOEXCEPT - { - regionCount = static_cast( regions_.size() ); - pRegions = regions_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkResolveImageInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkResolveImageInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkResolveImageInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkResolveImageInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ResolveImageInfo2 const & ) const = default; -#else - bool operator==( ResolveImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcImage == rhs.srcImage ) && ( srcImageLayout == rhs.srcImageLayout ) && - ( dstImage == rhs.dstImage ) && ( dstImageLayout == rhs.dstImageLayout ) && ( regionCount == rhs.regionCount ) && ( pRegions == rhs.pRegions ); -# endif - } - - bool operator!=( ResolveImageInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eResolveImageInfo2; - const void * pNext = {}; - Image srcImage = {}; - ImageLayout srcImageLayout = ImageLayout::eUndefined; - Image dstImage = {}; - ImageLayout dstImageLayout = ImageLayout::eUndefined; - uint32_t regionCount = {}; - const ImageResolve2 * pRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ResolveImageInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = ResolveImageInfo2; - }; - - using ResolveImageInfo2KHR = ResolveImageInfo2; - - // wrapper struct for struct VkResolveImageModeInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResolveImageModeInfoKHR.html - struct ResolveImageModeInfoKHR - { - using NativeType = VkResolveImageModeInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eResolveImageModeInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ResolveImageModeInfoKHR( ResolveImageFlagsKHR flags_ = {}, - ResolveModeFlagBits resolveMode_ = ResolveModeFlagBits::eNone, - ResolveModeFlagBits stencilResolveMode_ = ResolveModeFlagBits::eNone, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , resolveMode{ resolveMode_ } - , stencilResolveMode{ stencilResolveMode_ } - { - } - - VULKAN_HPP_CONSTEXPR ResolveImageModeInfoKHR( ResolveImageModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ResolveImageModeInfoKHR( VkResolveImageModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : ResolveImageModeInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - ResolveImageModeInfoKHR & operator=( ResolveImageModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ResolveImageModeInfoKHR & operator=( VkResolveImageModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR & setFlags( ResolveImageFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR && setFlags( ResolveImageFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR & setResolveMode( ResolveModeFlagBits resolveMode_ ) & VULKAN_HPP_NOEXCEPT - { - resolveMode = resolveMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR && setResolveMode( ResolveModeFlagBits resolveMode_ ) && VULKAN_HPP_NOEXCEPT - { - resolveMode = resolveMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR & setStencilResolveMode( ResolveModeFlagBits stencilResolveMode_ ) & VULKAN_HPP_NOEXCEPT - { - stencilResolveMode = stencilResolveMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResolveImageModeInfoKHR && setStencilResolveMode( ResolveModeFlagBits stencilResolveMode_ ) && VULKAN_HPP_NOEXCEPT - { - stencilResolveMode = stencilResolveMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkResolveImageModeInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkResolveImageModeInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkResolveImageModeInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkResolveImageModeInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, resolveMode, stencilResolveMode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ResolveImageModeInfoKHR const & ) const = default; -#else - bool operator==( ResolveImageModeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( resolveMode == rhs.resolveMode ) && - ( stencilResolveMode == rhs.stencilResolveMode ); -# endif - } - - bool operator!=( ResolveImageModeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eResolveImageModeInfoKHR; - const void * pNext = {}; - ResolveImageFlagsKHR flags = {}; - ResolveModeFlagBits resolveMode = ResolveModeFlagBits::eNone; - ResolveModeFlagBits stencilResolveMode = ResolveModeFlagBits::eNone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ResolveImageModeInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = ResolveImageModeInfoKHR; - }; - - // wrapper struct for struct VkTexelBufferDescriptorInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTexelBufferDescriptorInfoEXT.html - struct TexelBufferDescriptorInfoEXT - { - using NativeType = VkTexelBufferDescriptorInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTexelBufferDescriptorInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TexelBufferDescriptorInfoEXT( Format format_ = Format::eUndefined, - DeviceAddressRangeEXT addressRange_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , format{ format_ } - , addressRange{ addressRange_ } - { - } - - VULKAN_HPP_CONSTEXPR TexelBufferDescriptorInfoEXT( TexelBufferDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TexelBufferDescriptorInfoEXT( VkTexelBufferDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : TexelBufferDescriptorInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - TexelBufferDescriptorInfoEXT & operator=( TexelBufferDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TexelBufferDescriptorInfoEXT & operator=( VkTexelBufferDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT & setAddressRange( DeviceAddressRangeEXT const & addressRange_ ) & VULKAN_HPP_NOEXCEPT - { - addressRange = addressRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TexelBufferDescriptorInfoEXT && setAddressRange( DeviceAddressRangeEXT const & addressRange_ ) && VULKAN_HPP_NOEXCEPT - { - addressRange = addressRange_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTexelBufferDescriptorInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTexelBufferDescriptorInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTexelBufferDescriptorInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTexelBufferDescriptorInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, format, addressRange ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TexelBufferDescriptorInfoEXT const & ) const = default; -#else - bool operator==( TexelBufferDescriptorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( addressRange == rhs.addressRange ); -# endif - } - - bool operator!=( TexelBufferDescriptorInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTexelBufferDescriptorInfoEXT; - const void * pNext = {}; - Format format = Format::eUndefined; - DeviceAddressRangeEXT addressRange = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TexelBufferDescriptorInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = TexelBufferDescriptorInfoEXT; - }; - - // wrapper struct for struct VkTensorViewCreateInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCreateInfoARM.html - struct TensorViewCreateInfoARM - { - using NativeType = VkTensorViewCreateInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorViewCreateInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TensorViewCreateInfoARM( TensorViewCreateFlagsARM flags_ = {}, - TensorARM tensor_ = {}, - Format format_ = Format::eUndefined, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , tensor{ tensor_ } - , format{ format_ } - { - } - - VULKAN_HPP_CONSTEXPR TensorViewCreateInfoARM( TensorViewCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TensorViewCreateInfoARM( VkTensorViewCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : TensorViewCreateInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - TensorViewCreateInfoARM & operator=( TensorViewCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TensorViewCreateInfoARM & operator=( VkTensorViewCreateInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM & setFlags( TensorViewCreateFlagsARM flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM && setFlags( TensorViewCreateFlagsARM flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorViewCreateInfoARM && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTensorViewCreateInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorViewCreateInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorViewCreateInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTensorViewCreateInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, tensor, format ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TensorViewCreateInfoARM const & ) const = default; -#else - bool operator==( TensorViewCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( tensor == rhs.tensor ) && ( format == rhs.format ); -# endif - } - - bool operator!=( TensorViewCreateInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTensorViewCreateInfoARM; - const void * pNext = {}; - TensorViewCreateFlagsARM flags = {}; - TensorARM tensor = {}; - Format format = Format::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TensorViewCreateInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = TensorViewCreateInfoARM; - }; - - union ResourceDescriptorDataEXT - { - using NativeType = VkResourceDescriptorDataEXT; -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_UNION_CONSTRUCTORS ) - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT( const ImageDescriptorInfoEXT * pImage_ = {} ) : pImage( pImage_ ) {} - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT( const TexelBufferDescriptorInfoEXT * pTexelBuffer_ ) : pTexelBuffer( pTexelBuffer_ ) {} - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT( const DeviceAddressRangeEXT * pAddressRange_ ) : pAddressRange( pAddressRange_ ) {} - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT( const TensorViewCreateInfoARM * pTensorARM_ ) : pTensorARM( pTensorARM_ ) {} -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_UNION_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT & setPImage( const ImageDescriptorInfoEXT * pImage_ ) & VULKAN_HPP_NOEXCEPT - { - pImage = pImage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT && setPImage( const ImageDescriptorInfoEXT * pImage_ ) && VULKAN_HPP_NOEXCEPT - { - pImage = pImage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT & setPTexelBuffer( const TexelBufferDescriptorInfoEXT * pTexelBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - pTexelBuffer = pTexelBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT && setPTexelBuffer( const TexelBufferDescriptorInfoEXT * pTexelBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - pTexelBuffer = pTexelBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT & setPAddressRange( const DeviceAddressRangeEXT * pAddressRange_ ) & VULKAN_HPP_NOEXCEPT - { - pAddressRange = pAddressRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT && setPAddressRange( const DeviceAddressRangeEXT * pAddressRange_ ) && VULKAN_HPP_NOEXCEPT - { - pAddressRange = pAddressRange_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT & setPTensorARM( const TensorViewCreateInfoARM * pTensorARM_ ) & VULKAN_HPP_NOEXCEPT - { - pTensorARM = pTensorARM_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorDataEXT && setPTensorARM( const TensorViewCreateInfoARM * pTensorARM_ ) && VULKAN_HPP_NOEXCEPT - { - pTensorARM = pTensorARM_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkResourceDescriptorDataEXT const &() const - { - return *reinterpret_cast( this ); - } - - operator VkResourceDescriptorDataEXT &() - { - return *reinterpret_cast( this ); - } - -#ifdef VULKAN_HPP_HAS_UNRESTRICTED_UNIONS - const ImageDescriptorInfoEXT * pImage; - const TexelBufferDescriptorInfoEXT * pTexelBuffer; - const DeviceAddressRangeEXT * pAddressRange; - const TensorViewCreateInfoARM * pTensorARM; -#else - const VkImageDescriptorInfoEXT * pImage; - const VkTexelBufferDescriptorInfoEXT * pTexelBuffer; - const VkDeviceAddressRangeEXT * pAddressRange; - const VkTensorViewCreateInfoARM * pTensorARM; -#endif /*VULKAN_HPP_HAS_UNRESTRICTED_UNIONS*/ - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ResourceDescriptorDataEXT; - }; -#endif - - // wrapper struct for struct VkResourceDescriptorInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkResourceDescriptorInfoEXT.html - struct ResourceDescriptorInfoEXT - { - using NativeType = VkResourceDescriptorInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eResourceDescriptorInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT( DescriptorType type_ = DescriptorType::eSampler, - ResourceDescriptorDataEXT data_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , type{ type_ } - , data{ data_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT( ResourceDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ResourceDescriptorInfoEXT( VkResourceDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ResourceDescriptorInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ResourceDescriptorInfoEXT & operator=( ResourceDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ResourceDescriptorInfoEXT & operator=( VkResourceDescriptorInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT & setType( DescriptorType type_ ) & VULKAN_HPP_NOEXCEPT - { - type = type_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT && setType( DescriptorType type_ ) && VULKAN_HPP_NOEXCEPT - { - type = type_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT & setData( ResourceDescriptorDataEXT const & data_ ) & VULKAN_HPP_NOEXCEPT - { - data = data_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ResourceDescriptorInfoEXT && setData( ResourceDescriptorDataEXT const & data_ ) && VULKAN_HPP_NOEXCEPT - { - data = data_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkResourceDescriptorInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkResourceDescriptorInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkResourceDescriptorInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkResourceDescriptorInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, type, data ); - } -#endif - - public: - StructureType sType = StructureType::eResourceDescriptorInfoEXT; - const void * pNext = {}; - DescriptorType type = DescriptorType::eSampler; - ResourceDescriptorDataEXT data = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ResourceDescriptorInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ResourceDescriptorInfoEXT; - }; - - // wrapper struct for struct VkSamplerBlockMatchWindowCreateInfoQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerBlockMatchWindowCreateInfoQCOM.html - struct SamplerBlockMatchWindowCreateInfoQCOM - { - using NativeType = VkSamplerBlockMatchWindowCreateInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerBlockMatchWindowCreateInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SamplerBlockMatchWindowCreateInfoQCOM( Extent2D windowExtent_ = {}, - BlockMatchWindowCompareModeQCOM windowCompareMode_ = BlockMatchWindowCompareModeQCOM::eMin, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , windowExtent{ windowExtent_ } - , windowCompareMode{ windowCompareMode_ } - { - } - - VULKAN_HPP_CONSTEXPR SamplerBlockMatchWindowCreateInfoQCOM( SamplerBlockMatchWindowCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerBlockMatchWindowCreateInfoQCOM( VkSamplerBlockMatchWindowCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : SamplerBlockMatchWindowCreateInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - SamplerBlockMatchWindowCreateInfoQCOM & operator=( SamplerBlockMatchWindowCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerBlockMatchWindowCreateInfoQCOM & operator=( VkSamplerBlockMatchWindowCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM & setWindowExtent( Extent2D const & windowExtent_ ) & VULKAN_HPP_NOEXCEPT - { - windowExtent = windowExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM && setWindowExtent( Extent2D const & windowExtent_ ) && VULKAN_HPP_NOEXCEPT - { - windowExtent = windowExtent_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM & setWindowCompareMode( BlockMatchWindowCompareModeQCOM windowCompareMode_ ) & - VULKAN_HPP_NOEXCEPT - { - windowCompareMode = windowCompareMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerBlockMatchWindowCreateInfoQCOM && setWindowCompareMode( BlockMatchWindowCompareModeQCOM windowCompareMode_ ) && - VULKAN_HPP_NOEXCEPT - { - windowCompareMode = windowCompareMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSamplerBlockMatchWindowCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerBlockMatchWindowCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerBlockMatchWindowCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerBlockMatchWindowCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, windowExtent, windowCompareMode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SamplerBlockMatchWindowCreateInfoQCOM const & ) const = default; -#else - bool operator==( SamplerBlockMatchWindowCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( windowExtent == rhs.windowExtent ) && ( windowCompareMode == rhs.windowCompareMode ); -# endif - } - - bool operator!=( SamplerBlockMatchWindowCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerBlockMatchWindowCreateInfoQCOM; - const void * pNext = {}; - Extent2D windowExtent = {}; - BlockMatchWindowCompareModeQCOM windowCompareMode = BlockMatchWindowCompareModeQCOM::eMin; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerBlockMatchWindowCreateInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerBlockMatchWindowCreateInfoQCOM; - }; - - // wrapper struct for struct VkSamplerBorderColorComponentMappingCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerBorderColorComponentMappingCreateInfoEXT.html - struct SamplerBorderColorComponentMappingCreateInfoEXT - { - using NativeType = VkSamplerBorderColorComponentMappingCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - SamplerBorderColorComponentMappingCreateInfoEXT( ComponentMapping components_ = {}, Bool32 srgb_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , components{ components_ } - , srgb{ srgb_ } - { - } - - VULKAN_HPP_CONSTEXPR - SamplerBorderColorComponentMappingCreateInfoEXT( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerBorderColorComponentMappingCreateInfoEXT( VkSamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SamplerBorderColorComponentMappingCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - SamplerBorderColorComponentMappingCreateInfoEXT & operator=( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerBorderColorComponentMappingCreateInfoEXT & operator=( VkSamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT & setComponents( ComponentMapping const & components_ ) & VULKAN_HPP_NOEXCEPT - { - components = components_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT && setComponents( ComponentMapping const & components_ ) && VULKAN_HPP_NOEXCEPT - { - components = components_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT & setSrgb( Bool32 srgb_ ) & VULKAN_HPP_NOEXCEPT - { - srgb = srgb_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerBorderColorComponentMappingCreateInfoEXT && setSrgb( Bool32 srgb_ ) && VULKAN_HPP_NOEXCEPT - { - srgb = srgb_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSamplerBorderColorComponentMappingCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerBorderColorComponentMappingCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerBorderColorComponentMappingCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerBorderColorComponentMappingCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, components, srgb ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SamplerBorderColorComponentMappingCreateInfoEXT const & ) const = default; -#else - bool operator==( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( components == rhs.components ) && ( srgb == rhs.srgb ); -# endif - } - - bool operator!=( SamplerBorderColorComponentMappingCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT; - const void * pNext = {}; - ComponentMapping components = {}; - Bool32 srgb = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerBorderColorComponentMappingCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerBorderColorComponentMappingCreateInfoEXT; - }; - - // wrapper struct for struct VkSamplerCaptureDescriptorDataInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCaptureDescriptorDataInfoEXT.html - struct SamplerCaptureDescriptorDataInfoEXT - { - using NativeType = VkSamplerCaptureDescriptorDataInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCaptureDescriptorDataInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SamplerCaptureDescriptorDataInfoEXT( Sampler sampler_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , sampler{ sampler_ } - { - } - - VULKAN_HPP_CONSTEXPR SamplerCaptureDescriptorDataInfoEXT( SamplerCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerCaptureDescriptorDataInfoEXT( VkSamplerCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SamplerCaptureDescriptorDataInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - SamplerCaptureDescriptorDataInfoEXT & operator=( SamplerCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerCaptureDescriptorDataInfoEXT & operator=( VkSamplerCaptureDescriptorDataInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SamplerCaptureDescriptorDataInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCaptureDescriptorDataInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCaptureDescriptorDataInfoEXT & setSampler( Sampler sampler_ ) & VULKAN_HPP_NOEXCEPT - { - sampler = sampler_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCaptureDescriptorDataInfoEXT && setSampler( Sampler sampler_ ) && VULKAN_HPP_NOEXCEPT - { - sampler = sampler_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSamplerCaptureDescriptorDataInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerCaptureDescriptorDataInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerCaptureDescriptorDataInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerCaptureDescriptorDataInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, sampler ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SamplerCaptureDescriptorDataInfoEXT const & ) const = default; -#else - bool operator==( SamplerCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sampler == rhs.sampler ); -# endif - } - - bool operator!=( SamplerCaptureDescriptorDataInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerCaptureDescriptorDataInfoEXT; - const void * pNext = {}; - Sampler sampler = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerCaptureDescriptorDataInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerCaptureDescriptorDataInfoEXT; - }; - - // wrapper struct for struct VkSamplerCubicWeightsCreateInfoQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCubicWeightsCreateInfoQCOM.html - struct SamplerCubicWeightsCreateInfoQCOM - { - using NativeType = VkSamplerCubicWeightsCreateInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCubicWeightsCreateInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SamplerCubicWeightsCreateInfoQCOM( CubicFilterWeightsQCOM cubicWeights_ = CubicFilterWeightsQCOM::eCatmullRom, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , cubicWeights{ cubicWeights_ } - { - } - - VULKAN_HPP_CONSTEXPR SamplerCubicWeightsCreateInfoQCOM( SamplerCubicWeightsCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerCubicWeightsCreateInfoQCOM( VkSamplerCubicWeightsCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : SamplerCubicWeightsCreateInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - SamplerCubicWeightsCreateInfoQCOM & operator=( SamplerCubicWeightsCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerCubicWeightsCreateInfoQCOM & operator=( VkSamplerCubicWeightsCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SamplerCubicWeightsCreateInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCubicWeightsCreateInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCubicWeightsCreateInfoQCOM & setCubicWeights( CubicFilterWeightsQCOM cubicWeights_ ) & VULKAN_HPP_NOEXCEPT - { - cubicWeights = cubicWeights_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCubicWeightsCreateInfoQCOM && setCubicWeights( CubicFilterWeightsQCOM cubicWeights_ ) && VULKAN_HPP_NOEXCEPT - { - cubicWeights = cubicWeights_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSamplerCubicWeightsCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerCubicWeightsCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerCubicWeightsCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerCubicWeightsCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, cubicWeights ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SamplerCubicWeightsCreateInfoQCOM const & ) const = default; -#else - bool operator==( SamplerCubicWeightsCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( cubicWeights == rhs.cubicWeights ); -# endif - } - - bool operator!=( SamplerCubicWeightsCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerCubicWeightsCreateInfoQCOM; - const void * pNext = {}; - CubicFilterWeightsQCOM cubicWeights = CubicFilterWeightsQCOM::eCatmullRom; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerCubicWeightsCreateInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerCubicWeightsCreateInfoQCOM; - }; - - // wrapper struct for struct VkSamplerCustomBorderColorCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCustomBorderColorCreateInfoEXT.html - struct SamplerCustomBorderColorCreateInfoEXT - { - using NativeType = VkSamplerCustomBorderColorCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCustomBorderColorCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT( ClearColorValue customBorderColor_ = {}, - Format format_ = Format::eUndefined, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , customBorderColor{ customBorderColor_ } - , format{ format_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT( SamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerCustomBorderColorCreateInfoEXT( VkSamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SamplerCustomBorderColorCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - SamplerCustomBorderColorCreateInfoEXT & operator=( SamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerCustomBorderColorCreateInfoEXT & operator=( VkSamplerCustomBorderColorCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT & setCustomBorderColor( ClearColorValue const & customBorderColor_ ) & VULKAN_HPP_NOEXCEPT - { - customBorderColor = customBorderColor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT && setCustomBorderColor( ClearColorValue const & customBorderColor_ ) && VULKAN_HPP_NOEXCEPT - { - customBorderColor = customBorderColor_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorCreateInfoEXT && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSamplerCustomBorderColorCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerCustomBorderColorCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerCustomBorderColorCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerCustomBorderColorCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, customBorderColor, format ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerCustomBorderColorCreateInfoEXT; - const void * pNext = {}; - ClearColorValue customBorderColor = {}; - Format format = Format::eUndefined; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerCustomBorderColorCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerCustomBorderColorCreateInfoEXT; - }; - - // wrapper struct for struct VkSamplerCustomBorderColorIndexCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerCustomBorderColorIndexCreateInfoEXT.html - struct SamplerCustomBorderColorIndexCreateInfoEXT - { - using NativeType = VkSamplerCustomBorderColorIndexCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerCustomBorderColorIndexCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SamplerCustomBorderColorIndexCreateInfoEXT( uint32_t index_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , index{ index_ } - { - } - - VULKAN_HPP_CONSTEXPR SamplerCustomBorderColorIndexCreateInfoEXT( SamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerCustomBorderColorIndexCreateInfoEXT( VkSamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SamplerCustomBorderColorIndexCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - SamplerCustomBorderColorIndexCreateInfoEXT & operator=( SamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerCustomBorderColorIndexCreateInfoEXT & operator=( VkSamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorIndexCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorIndexCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorIndexCreateInfoEXT & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT - { - index = index_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerCustomBorderColorIndexCreateInfoEXT && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT - { - index = index_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSamplerCustomBorderColorIndexCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerCustomBorderColorIndexCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerCustomBorderColorIndexCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerCustomBorderColorIndexCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, index ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SamplerCustomBorderColorIndexCreateInfoEXT const & ) const = default; -#else - bool operator==( SamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( index == rhs.index ); -# endif - } - - bool operator!=( SamplerCustomBorderColorIndexCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerCustomBorderColorIndexCreateInfoEXT; - const void * pNext = {}; - uint32_t index = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerCustomBorderColorIndexCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerCustomBorderColorIndexCreateInfoEXT; - }; - - // wrapper struct for struct VkSamplerReductionModeCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerReductionModeCreateInfo.html - struct SamplerReductionModeCreateInfo - { - using NativeType = VkSamplerReductionModeCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerReductionModeCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfo( SamplerReductionMode reductionMode_ = SamplerReductionMode::eWeightedAverage, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , reductionMode{ reductionMode_ } - { - } - - VULKAN_HPP_CONSTEXPR SamplerReductionModeCreateInfo( SamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerReductionModeCreateInfo( VkSamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : SamplerReductionModeCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - SamplerReductionModeCreateInfo & operator=( SamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerReductionModeCreateInfo & operator=( VkSamplerReductionModeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SamplerReductionModeCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerReductionModeCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerReductionModeCreateInfo & setReductionMode( SamplerReductionMode reductionMode_ ) & VULKAN_HPP_NOEXCEPT - { - reductionMode = reductionMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerReductionModeCreateInfo && setReductionMode( SamplerReductionMode reductionMode_ ) && VULKAN_HPP_NOEXCEPT - { - reductionMode = reductionMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSamplerReductionModeCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerReductionModeCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerReductionModeCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerReductionModeCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, reductionMode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SamplerReductionModeCreateInfo const & ) const = default; -#else - bool operator==( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reductionMode == rhs.reductionMode ); -# endif - } - - bool operator!=( SamplerReductionModeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerReductionModeCreateInfo; - const void * pNext = {}; - SamplerReductionMode reductionMode = SamplerReductionMode::eWeightedAverage; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerReductionModeCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerReductionModeCreateInfo; - }; - - using SamplerReductionModeCreateInfoEXT = SamplerReductionModeCreateInfo; - - // wrapper struct for struct VkSamplerYcbcrConversionCreateInfo, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionCreateInfo.html - struct SamplerYcbcrConversionCreateInfo - { - using NativeType = VkSamplerYcbcrConversionCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( Format format_ = Format::eUndefined, - SamplerYcbcrModelConversion ycbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, - SamplerYcbcrRange ycbcrRange_ = SamplerYcbcrRange::eItuFull, - ComponentMapping components_ = {}, - ChromaLocation xChromaOffset_ = ChromaLocation::eCositedEven, - ChromaLocation yChromaOffset_ = ChromaLocation::eCositedEven, - Filter chromaFilter_ = Filter::eNearest, - Bool32 forceExplicitReconstruction_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , format{ format_ } - , ycbcrModel{ ycbcrModel_ } - , ycbcrRange{ ycbcrRange_ } - , components{ components_ } - , xChromaOffset{ xChromaOffset_ } - , yChromaOffset{ yChromaOffset_ } - , chromaFilter{ chromaFilter_ } - , forceExplicitReconstruction{ forceExplicitReconstruction_ } - { - } - - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionCreateInfo( SamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerYcbcrConversionCreateInfo( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : SamplerYcbcrConversionCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - SamplerYcbcrConversionCreateInfo & operator=( SamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerYcbcrConversionCreateInfo & operator=( VkSamplerYcbcrConversionCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ ) & VULKAN_HPP_NOEXCEPT - { - ycbcrModel = ycbcrModel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setYcbcrModel( SamplerYcbcrModelConversion ycbcrModel_ ) && VULKAN_HPP_NOEXCEPT - { - ycbcrModel = ycbcrModel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setYcbcrRange( SamplerYcbcrRange ycbcrRange_ ) & VULKAN_HPP_NOEXCEPT - { - ycbcrRange = ycbcrRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setYcbcrRange( SamplerYcbcrRange ycbcrRange_ ) && VULKAN_HPP_NOEXCEPT - { - ycbcrRange = ycbcrRange_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setComponents( ComponentMapping const & components_ ) & VULKAN_HPP_NOEXCEPT - { - components = components_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setComponents( ComponentMapping const & components_ ) && VULKAN_HPP_NOEXCEPT - { - components = components_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setXChromaOffset( ChromaLocation xChromaOffset_ ) & VULKAN_HPP_NOEXCEPT - { - xChromaOffset = xChromaOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setXChromaOffset( ChromaLocation xChromaOffset_ ) && VULKAN_HPP_NOEXCEPT - { - xChromaOffset = xChromaOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setYChromaOffset( ChromaLocation yChromaOffset_ ) & VULKAN_HPP_NOEXCEPT - { - yChromaOffset = yChromaOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setYChromaOffset( ChromaLocation yChromaOffset_ ) && VULKAN_HPP_NOEXCEPT - { - yChromaOffset = yChromaOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setChromaFilter( Filter chromaFilter_ ) & VULKAN_HPP_NOEXCEPT - { - chromaFilter = chromaFilter_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setChromaFilter( Filter chromaFilter_ ) && VULKAN_HPP_NOEXCEPT - { - chromaFilter = chromaFilter_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo & setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ ) & VULKAN_HPP_NOEXCEPT - { - forceExplicitReconstruction = forceExplicitReconstruction_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionCreateInfo && setForceExplicitReconstruction( Bool32 forceExplicitReconstruction_ ) && VULKAN_HPP_NOEXCEPT - { - forceExplicitReconstruction = forceExplicitReconstruction_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSamplerYcbcrConversionCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, format, ycbcrModel, ycbcrRange, components, xChromaOffset, yChromaOffset, chromaFilter, forceExplicitReconstruction ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SamplerYcbcrConversionCreateInfo const & ) const = default; -#else - bool operator==( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( ycbcrModel == rhs.ycbcrModel ) && - ( ycbcrRange == rhs.ycbcrRange ) && ( components == rhs.components ) && ( xChromaOffset == rhs.xChromaOffset ) && - ( yChromaOffset == rhs.yChromaOffset ) && ( chromaFilter == rhs.chromaFilter ) && - ( forceExplicitReconstruction == rhs.forceExplicitReconstruction ); -# endif - } - - bool operator!=( SamplerYcbcrConversionCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerYcbcrConversionCreateInfo; - const void * pNext = {}; - Format format = Format::eUndefined; - SamplerYcbcrModelConversion ycbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; - SamplerYcbcrRange ycbcrRange = SamplerYcbcrRange::eItuFull; - ComponentMapping components = {}; - ChromaLocation xChromaOffset = ChromaLocation::eCositedEven; - ChromaLocation yChromaOffset = ChromaLocation::eCositedEven; - Filter chromaFilter = Filter::eNearest; - Bool32 forceExplicitReconstruction = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerYcbcrConversionCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerYcbcrConversionCreateInfo; - }; - - using SamplerYcbcrConversionCreateInfoKHR = SamplerYcbcrConversionCreateInfo; - - // wrapper struct for struct VkSamplerYcbcrConversionImageFormatProperties, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionImageFormatProperties.html - struct SamplerYcbcrConversionImageFormatProperties - { - using NativeType = VkSamplerYcbcrConversionImageFormatProperties; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionImageFormatProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionImageFormatProperties( uint32_t combinedImageSamplerDescriptorCount_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , combinedImageSamplerDescriptorCount{ combinedImageSamplerDescriptorCount_ } - { - } - - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionImageFormatProperties( SamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerYcbcrConversionImageFormatProperties( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : SamplerYcbcrConversionImageFormatProperties( *reinterpret_cast( &rhs ) ) - { - } - - SamplerYcbcrConversionImageFormatProperties & operator=( SamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerYcbcrConversionImageFormatProperties & operator=( VkSamplerYcbcrConversionImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSamplerYcbcrConversionImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionImageFormatProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionImageFormatProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionImageFormatProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, combinedImageSamplerDescriptorCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SamplerYcbcrConversionImageFormatProperties const & ) const = default; -#else - bool operator==( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( combinedImageSamplerDescriptorCount == rhs.combinedImageSamplerDescriptorCount ); -# endif - } - - bool operator!=( SamplerYcbcrConversionImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerYcbcrConversionImageFormatProperties; - void * pNext = {}; - uint32_t combinedImageSamplerDescriptorCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerYcbcrConversionImageFormatProperties; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerYcbcrConversionImageFormatProperties; - }; - - using SamplerYcbcrConversionImageFormatPropertiesKHR = SamplerYcbcrConversionImageFormatProperties; - - // wrapper struct for struct VkSamplerYcbcrConversionInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionInfo.html - struct SamplerYcbcrConversionInfo - { - using NativeType = VkSamplerYcbcrConversionInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( SamplerYcbcrConversion conversion_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , conversion{ conversion_ } - { - } - - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionInfo( SamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerYcbcrConversionInfo( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : SamplerYcbcrConversionInfo( *reinterpret_cast( &rhs ) ) - { - } - - SamplerYcbcrConversionInfo & operator=( SamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerYcbcrConversionInfo & operator=( VkSamplerYcbcrConversionInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionInfo & setConversion( SamplerYcbcrConversion conversion_ ) & VULKAN_HPP_NOEXCEPT - { - conversion = conversion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionInfo && setConversion( SamplerYcbcrConversion conversion_ ) && VULKAN_HPP_NOEXCEPT - { - conversion = conversion_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSamplerYcbcrConversionInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, conversion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SamplerYcbcrConversionInfo const & ) const = default; -#else - bool operator==( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( conversion == rhs.conversion ); -# endif - } - - bool operator!=( SamplerYcbcrConversionInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerYcbcrConversionInfo; - const void * pNext = {}; - SamplerYcbcrConversion conversion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerYcbcrConversionInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerYcbcrConversionInfo; - }; - - using SamplerYcbcrConversionInfoKHR = SamplerYcbcrConversionInfo; - - // wrapper struct for struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.html - struct SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM - { - using NativeType = VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM( Bool32 enableYDegamma_ = {}, - Bool32 enableCbCrDegamma_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , enableYDegamma{ enableYDegamma_ } - , enableCbCrDegamma{ enableCbCrDegamma_ } - { - } - - VULKAN_HPP_CONSTEXPR - SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM( SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM( VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM & operator=( SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM & operator=( VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM & setEnableYDegamma( Bool32 enableYDegamma_ ) & VULKAN_HPP_NOEXCEPT - { - enableYDegamma = enableYDegamma_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM && setEnableYDegamma( Bool32 enableYDegamma_ ) && VULKAN_HPP_NOEXCEPT - { - enableYDegamma = enableYDegamma_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM & setEnableCbCrDegamma( Bool32 enableCbCrDegamma_ ) & VULKAN_HPP_NOEXCEPT - { - enableCbCrDegamma = enableCbCrDegamma_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM && setEnableCbCrDegamma( Bool32 enableCbCrDegamma_ ) && VULKAN_HPP_NOEXCEPT - { - enableCbCrDegamma = enableCbCrDegamma_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, enableYDegamma, enableCbCrDegamma ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & ) const = default; -#else - bool operator==( SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( enableYDegamma == rhs.enableYDegamma ) && ( enableCbCrDegamma == rhs.enableCbCrDegamma ); -# endif - } - - bool operator!=( SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; - void * pNext = {}; - Bool32 enableYDegamma = {}; - Bool32 enableCbCrDegamma = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; - }; - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - // wrapper struct for struct VkScreenBufferFormatPropertiesQNX, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkScreenBufferFormatPropertiesQNX.html - struct ScreenBufferFormatPropertiesQNX - { - using NativeType = VkScreenBufferFormatPropertiesQNX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eScreenBufferFormatPropertiesQNX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ScreenBufferFormatPropertiesQNX( Format format_ = Format::eUndefined, - uint64_t externalFormat_ = {}, - uint64_t screenUsage_ = {}, - FormatFeatureFlags formatFeatures_ = {}, - ComponentMapping samplerYcbcrConversionComponents_ = {}, - SamplerYcbcrModelConversion suggestedYcbcrModel_ = SamplerYcbcrModelConversion::eRgbIdentity, - SamplerYcbcrRange suggestedYcbcrRange_ = SamplerYcbcrRange::eItuFull, - ChromaLocation suggestedXChromaOffset_ = ChromaLocation::eCositedEven, - ChromaLocation suggestedYChromaOffset_ = ChromaLocation::eCositedEven, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , format{ format_ } - , externalFormat{ externalFormat_ } - , screenUsage{ screenUsage_ } - , formatFeatures{ formatFeatures_ } - , samplerYcbcrConversionComponents{ samplerYcbcrConversionComponents_ } - , suggestedYcbcrModel{ suggestedYcbcrModel_ } - , suggestedYcbcrRange{ suggestedYcbcrRange_ } - , suggestedXChromaOffset{ suggestedXChromaOffset_ } - , suggestedYChromaOffset{ suggestedYChromaOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR ScreenBufferFormatPropertiesQNX( ScreenBufferFormatPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ScreenBufferFormatPropertiesQNX( VkScreenBufferFormatPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT - : ScreenBufferFormatPropertiesQNX( *reinterpret_cast( &rhs ) ) - { - } - - ScreenBufferFormatPropertiesQNX & operator=( ScreenBufferFormatPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ScreenBufferFormatPropertiesQNX & operator=( VkScreenBufferFormatPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkScreenBufferFormatPropertiesQNX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkScreenBufferFormatPropertiesQNX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkScreenBufferFormatPropertiesQNX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkScreenBufferFormatPropertiesQNX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - format, - externalFormat, - screenUsage, - formatFeatures, - samplerYcbcrConversionComponents, - suggestedYcbcrModel, - suggestedYcbcrRange, - suggestedXChromaOffset, - suggestedYChromaOffset ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ScreenBufferFormatPropertiesQNX const & ) const = default; -# else - bool operator==( ScreenBufferFormatPropertiesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( externalFormat == rhs.externalFormat ) && - ( screenUsage == rhs.screenUsage ) && ( formatFeatures == rhs.formatFeatures ) && - ( samplerYcbcrConversionComponents == rhs.samplerYcbcrConversionComponents ) && ( suggestedYcbcrModel == rhs.suggestedYcbcrModel ) && - ( suggestedYcbcrRange == rhs.suggestedYcbcrRange ) && ( suggestedXChromaOffset == rhs.suggestedXChromaOffset ) && - ( suggestedYChromaOffset == rhs.suggestedYChromaOffset ); -# endif - } - - bool operator!=( ScreenBufferFormatPropertiesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eScreenBufferFormatPropertiesQNX; - void * pNext = {}; - Format format = Format::eUndefined; - uint64_t externalFormat = {}; - uint64_t screenUsage = {}; - FormatFeatureFlags formatFeatures = {}; - ComponentMapping samplerYcbcrConversionComponents = {}; - SamplerYcbcrModelConversion suggestedYcbcrModel = SamplerYcbcrModelConversion::eRgbIdentity; - SamplerYcbcrRange suggestedYcbcrRange = SamplerYcbcrRange::eItuFull; - ChromaLocation suggestedXChromaOffset = ChromaLocation::eCositedEven; - ChromaLocation suggestedYChromaOffset = ChromaLocation::eCositedEven; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ScreenBufferFormatPropertiesQNX; - }; -# endif - - template <> - struct CppType - { - using Type = ScreenBufferFormatPropertiesQNX; - }; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - // wrapper struct for struct VkScreenBufferPropertiesQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkScreenBufferPropertiesQNX.html - struct ScreenBufferPropertiesQNX - { - using NativeType = VkScreenBufferPropertiesQNX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eScreenBufferPropertiesQNX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - ScreenBufferPropertiesQNX( DeviceSize allocationSize_ = {}, uint32_t memoryTypeBits_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , allocationSize{ allocationSize_ } - , memoryTypeBits{ memoryTypeBits_ } - { - } - - VULKAN_HPP_CONSTEXPR ScreenBufferPropertiesQNX( ScreenBufferPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ScreenBufferPropertiesQNX( VkScreenBufferPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT - : ScreenBufferPropertiesQNX( *reinterpret_cast( &rhs ) ) - { - } - - ScreenBufferPropertiesQNX & operator=( ScreenBufferPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ScreenBufferPropertiesQNX & operator=( VkScreenBufferPropertiesQNX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkScreenBufferPropertiesQNX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkScreenBufferPropertiesQNX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkScreenBufferPropertiesQNX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkScreenBufferPropertiesQNX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, allocationSize, memoryTypeBits ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ScreenBufferPropertiesQNX const & ) const = default; -# else - bool operator==( ScreenBufferPropertiesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( allocationSize == rhs.allocationSize ) && ( memoryTypeBits == rhs.memoryTypeBits ); -# endif - } - - bool operator!=( ScreenBufferPropertiesQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eScreenBufferPropertiesQNX; - void * pNext = {}; - DeviceSize allocationSize = {}; - uint32_t memoryTypeBits = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ScreenBufferPropertiesQNX; - }; -# endif - - template <> - struct CppType - { - using Type = ScreenBufferPropertiesQNX; - }; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - // wrapper struct for struct VkScreenSurfaceCreateInfoQNX, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkScreenSurfaceCreateInfoQNX.html - struct ScreenSurfaceCreateInfoQNX - { - using NativeType = VkScreenSurfaceCreateInfoQNX; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eScreenSurfaceCreateInfoQNX; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ScreenSurfaceCreateInfoQNX( ScreenSurfaceCreateFlagsQNX flags_ = {}, - struct _screen_context * context_ = {}, - struct _screen_window * window_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , context{ context_ } - , window{ window_ } - { - } - - VULKAN_HPP_CONSTEXPR ScreenSurfaceCreateInfoQNX( ScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ScreenSurfaceCreateInfoQNX( VkScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT - : ScreenSurfaceCreateInfoQNX( *reinterpret_cast( &rhs ) ) - { - } - - ScreenSurfaceCreateInfoQNX & operator=( ScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ScreenSurfaceCreateInfoQNX & operator=( VkScreenSurfaceCreateInfoQNX const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX & setFlags( ScreenSurfaceCreateFlagsQNX flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX && setFlags( ScreenSurfaceCreateFlagsQNX flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX & setContext( struct _screen_context * context_ ) & VULKAN_HPP_NOEXCEPT - { - context = context_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX && setContext( struct _screen_context * context_ ) && VULKAN_HPP_NOEXCEPT - { - context = context_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX & setWindow( struct _screen_window * window_ ) & VULKAN_HPP_NOEXCEPT - { - window = window_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ScreenSurfaceCreateInfoQNX && setWindow( struct _screen_window * window_ ) && VULKAN_HPP_NOEXCEPT - { - window = window_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkScreenSurfaceCreateInfoQNX const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkScreenSurfaceCreateInfoQNX &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkScreenSurfaceCreateInfoQNX const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkScreenSurfaceCreateInfoQNX *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, context, window ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ScreenSurfaceCreateInfoQNX const & ) const = default; -# else - bool operator==( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( context == rhs.context ) && ( window == rhs.window ); -# endif - } - - bool operator!=( ScreenSurfaceCreateInfoQNX const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eScreenSurfaceCreateInfoQNX; - const void * pNext = {}; - ScreenSurfaceCreateFlagsQNX flags = {}; - struct _screen_context * context = {}; - struct _screen_window * window = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ScreenSurfaceCreateInfoQNX; - }; -# endif - - template <> - struct CppType - { - using Type = ScreenSurfaceCreateInfoQNX; - }; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - // wrapper struct for struct VkSemaphoreCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreCreateInfo.html - struct SemaphoreCreateInfo - { - using NativeType = VkSemaphoreCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( SemaphoreCreateFlags flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR SemaphoreCreateInfo( SemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SemaphoreCreateInfo( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SemaphoreCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - SemaphoreCreateInfo & operator=( SemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SemaphoreCreateInfo & operator=( VkSemaphoreCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SemaphoreCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreCreateInfo & setFlags( SemaphoreCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreCreateInfo && setFlags( SemaphoreCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSemaphoreCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSemaphoreCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SemaphoreCreateInfo const & ) const = default; -#else - bool operator==( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( SemaphoreCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSemaphoreCreateInfo; - const void * pNext = {}; - SemaphoreCreateFlags flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SemaphoreCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SemaphoreCreateInfo; - }; - - // wrapper struct for struct VkSemaphoreGetFdInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreGetFdInfoKHR.html - struct SemaphoreGetFdInfoKHR - { - using NativeType = VkSemaphoreGetFdInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetFdInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( Semaphore semaphore_ = {}, - ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , semaphore{ semaphore_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR SemaphoreGetFdInfoKHR( SemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SemaphoreGetFdInfoKHR( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SemaphoreGetFdInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - SemaphoreGetFdInfoKHR & operator=( SemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SemaphoreGetFdInfoKHR & operator=( VkSemaphoreGetFdInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetFdInfoKHR && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSemaphoreGetFdInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreGetFdInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreGetFdInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSemaphoreGetFdInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, semaphore, handleType ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SemaphoreGetFdInfoKHR const & ) const = default; -#else - bool operator==( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( SemaphoreGetFdInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSemaphoreGetFdInfoKHR; - const void * pNext = {}; - Semaphore semaphore = {}; - ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SemaphoreGetFdInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = SemaphoreGetFdInfoKHR; - }; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkSemaphoreGetWin32HandleInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreGetWin32HandleInfoKHR.html - struct SemaphoreGetWin32HandleInfoKHR - { - using NativeType = VkSemaphoreGetWin32HandleInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetWin32HandleInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( Semaphore semaphore_ = {}, - ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , semaphore{ semaphore_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR SemaphoreGetWin32HandleInfoKHR( SemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SemaphoreGetWin32HandleInfoKHR( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SemaphoreGetWin32HandleInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - SemaphoreGetWin32HandleInfoKHR & operator=( SemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SemaphoreGetWin32HandleInfoKHR & operator=( VkSemaphoreGetWin32HandleInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetWin32HandleInfoKHR && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSemaphoreGetWin32HandleInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreGetWin32HandleInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreGetWin32HandleInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSemaphoreGetWin32HandleInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, semaphore, handleType ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SemaphoreGetWin32HandleInfoKHR const & ) const = default; -# else - bool operator==( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( SemaphoreGetWin32HandleInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eSemaphoreGetWin32HandleInfoKHR; - const void * pNext = {}; - Semaphore semaphore = {}; - ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SemaphoreGetWin32HandleInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = SemaphoreGetWin32HandleInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - // wrapper struct for struct VkSemaphoreGetZirconHandleInfoFUCHSIA, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreGetZirconHandleInfoFUCHSIA.html - struct SemaphoreGetZirconHandleInfoFUCHSIA - { - using NativeType = VkSemaphoreGetZirconHandleInfoFUCHSIA; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SemaphoreGetZirconHandleInfoFUCHSIA( Semaphore semaphore_ = {}, - ExternalSemaphoreHandleTypeFlagBits handleType_ = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , semaphore{ semaphore_ } - , handleType{ handleType_ } - { - } - - VULKAN_HPP_CONSTEXPR SemaphoreGetZirconHandleInfoFUCHSIA( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SemaphoreGetZirconHandleInfoFUCHSIA( VkSemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - : SemaphoreGetZirconHandleInfoFUCHSIA( *reinterpret_cast( &rhs ) ) - { - } - - SemaphoreGetZirconHandleInfoFUCHSIA & operator=( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SemaphoreGetZirconHandleInfoFUCHSIA & operator=( VkSemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA & setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) & VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreGetZirconHandleInfoFUCHSIA && setHandleType( ExternalSemaphoreHandleTypeFlagBits handleType_ ) && VULKAN_HPP_NOEXCEPT - { - handleType = handleType_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSemaphoreGetZirconHandleInfoFUCHSIA const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreGetZirconHandleInfoFUCHSIA &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreGetZirconHandleInfoFUCHSIA const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSemaphoreGetZirconHandleInfoFUCHSIA *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, semaphore, handleType ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SemaphoreGetZirconHandleInfoFUCHSIA const & ) const = default; -# else - bool operator==( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( handleType == rhs.handleType ); -# endif - } - - bool operator!=( SemaphoreGetZirconHandleInfoFUCHSIA const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA; - const void * pNext = {}; - Semaphore semaphore = {}; - ExternalSemaphoreHandleTypeFlagBits handleType = ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SemaphoreGetZirconHandleInfoFUCHSIA; - }; -# endif - - template <> - struct CppType - { - using Type = SemaphoreGetZirconHandleInfoFUCHSIA; - }; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - // wrapper struct for struct VkSemaphoreSignalInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreSignalInfo.html - struct SemaphoreSignalInfo - { - using NativeType = VkSemaphoreSignalInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreSignalInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SemaphoreSignalInfo( Semaphore semaphore_ = {}, uint64_t value_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , semaphore{ semaphore_ } - , value{ value_ } - { - } - - VULKAN_HPP_CONSTEXPR SemaphoreSignalInfo( SemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SemaphoreSignalInfo( VkSemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SemaphoreSignalInfo( *reinterpret_cast( &rhs ) ) - { - } - - SemaphoreSignalInfo & operator=( SemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SemaphoreSignalInfo & operator=( VkSemaphoreSignalInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo & setSemaphore( Semaphore semaphore_ ) & VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo && setSemaphore( Semaphore semaphore_ ) && VULKAN_HPP_NOEXCEPT - { - semaphore = semaphore_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo & setValue( uint64_t value_ ) & VULKAN_HPP_NOEXCEPT - { - value = value_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreSignalInfo && setValue( uint64_t value_ ) && VULKAN_HPP_NOEXCEPT - { - value = value_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSemaphoreSignalInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreSignalInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreSignalInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSemaphoreSignalInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, semaphore, value ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SemaphoreSignalInfo const & ) const = default; -#else - bool operator==( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphore == rhs.semaphore ) && ( value == rhs.value ); -# endif - } - - bool operator!=( SemaphoreSignalInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSemaphoreSignalInfo; - const void * pNext = {}; - Semaphore semaphore = {}; - uint64_t value = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SemaphoreSignalInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SemaphoreSignalInfo; - }; - - using SemaphoreSignalInfoKHR = SemaphoreSignalInfo; - - // wrapper struct for struct VkSemaphoreTypeCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreTypeCreateInfo.html - struct SemaphoreTypeCreateInfo - { - using NativeType = VkSemaphoreTypeCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreTypeCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfo( SemaphoreType semaphoreType_ = SemaphoreType::eBinary, - uint64_t initialValue_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , semaphoreType{ semaphoreType_ } - , initialValue{ initialValue_ } - { - } - - VULKAN_HPP_CONSTEXPR SemaphoreTypeCreateInfo( SemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SemaphoreTypeCreateInfo( VkSemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : SemaphoreTypeCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - - SemaphoreTypeCreateInfo & operator=( SemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SemaphoreTypeCreateInfo & operator=( VkSemaphoreTypeCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo & setSemaphoreType( SemaphoreType semaphoreType_ ) & VULKAN_HPP_NOEXCEPT - { - semaphoreType = semaphoreType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo && setSemaphoreType( SemaphoreType semaphoreType_ ) && VULKAN_HPP_NOEXCEPT - { - semaphoreType = semaphoreType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo & setInitialValue( uint64_t initialValue_ ) & VULKAN_HPP_NOEXCEPT - { - initialValue = initialValue_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreTypeCreateInfo && setInitialValue( uint64_t initialValue_ ) && VULKAN_HPP_NOEXCEPT - { - initialValue = initialValue_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSemaphoreTypeCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreTypeCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreTypeCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSemaphoreTypeCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, semaphoreType, initialValue ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SemaphoreTypeCreateInfo const & ) const = default; -#else - bool operator==( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( semaphoreType == rhs.semaphoreType ) && ( initialValue == rhs.initialValue ); -# endif - } - - bool operator!=( SemaphoreTypeCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSemaphoreTypeCreateInfo; - const void * pNext = {}; - SemaphoreType semaphoreType = SemaphoreType::eBinary; - uint64_t initialValue = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SemaphoreTypeCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SemaphoreTypeCreateInfo; - }; - - using SemaphoreTypeCreateInfoKHR = SemaphoreTypeCreateInfo; - - // wrapper struct for struct VkSemaphoreWaitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSemaphoreWaitInfo.html - struct SemaphoreWaitInfo - { - using NativeType = VkSemaphoreWaitInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSemaphoreWaitInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SemaphoreWaitInfo( SemaphoreWaitFlags flags_ = {}, - uint32_t semaphoreCount_ = {}, - const Semaphore * pSemaphores_ = {}, - const uint64_t * pValues_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , semaphoreCount{ semaphoreCount_ } - , pSemaphores{ pSemaphores_ } - , pValues{ pValues_ } - { - } - - VULKAN_HPP_CONSTEXPR SemaphoreWaitInfo( SemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SemaphoreWaitInfo( VkSemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SemaphoreWaitInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SemaphoreWaitInfo( SemaphoreWaitFlags flags_, - ArrayProxyNoTemporaries const & semaphores_, - ArrayProxyNoTemporaries const & values_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , semaphoreCount( static_cast( semaphores_.size() ) ) - , pSemaphores( semaphores_.data() ) - , pValues( values_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( semaphores_.size() == values_.size() ); -# else - if ( semaphores_.size() != values_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::SemaphoreWaitInfo::SemaphoreWaitInfo: semaphores_.size() != values_.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SemaphoreWaitInfo & operator=( SemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SemaphoreWaitInfo & operator=( VkSemaphoreWaitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo & setFlags( SemaphoreWaitFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo && setFlags( SemaphoreWaitFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo & setSemaphoreCount( uint32_t semaphoreCount_ ) & VULKAN_HPP_NOEXCEPT - { - semaphoreCount = semaphoreCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo && setSemaphoreCount( uint32_t semaphoreCount_ ) && VULKAN_HPP_NOEXCEPT - { - semaphoreCount = semaphoreCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo & setPSemaphores( const Semaphore * pSemaphores_ ) & VULKAN_HPP_NOEXCEPT - { - pSemaphores = pSemaphores_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo && setPSemaphores( const Semaphore * pSemaphores_ ) && VULKAN_HPP_NOEXCEPT - { - pSemaphores = pSemaphores_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SemaphoreWaitInfo & setSemaphores( ArrayProxyNoTemporaries const & semaphores_ ) VULKAN_HPP_NOEXCEPT - { - semaphoreCount = static_cast( semaphores_.size() ); - pSemaphores = semaphores_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo & setPValues( const uint64_t * pValues_ ) & VULKAN_HPP_NOEXCEPT - { - pValues = pValues_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SemaphoreWaitInfo && setPValues( const uint64_t * pValues_ ) && VULKAN_HPP_NOEXCEPT - { - pValues = pValues_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SemaphoreWaitInfo & setValues( ArrayProxyNoTemporaries const & values_ ) VULKAN_HPP_NOEXCEPT - { - semaphoreCount = static_cast( values_.size() ); - pValues = values_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSemaphoreWaitInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreWaitInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSemaphoreWaitInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSemaphoreWaitInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, semaphoreCount, pSemaphores, pValues ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SemaphoreWaitInfo const & ) const = default; -#else - bool operator==( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( semaphoreCount == rhs.semaphoreCount ) && - ( pSemaphores == rhs.pSemaphores ) && ( pValues == rhs.pValues ); -# endif - } - - bool operator!=( SemaphoreWaitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSemaphoreWaitInfo; - const void * pNext = {}; - SemaphoreWaitFlags flags = {}; - uint32_t semaphoreCount = {}; - const Semaphore * pSemaphores = {}; - const uint64_t * pValues = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SemaphoreWaitInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SemaphoreWaitInfo; - }; - - using SemaphoreWaitInfoKHR = SemaphoreWaitInfo; - - // wrapper struct for struct VkSetDescriptorBufferOffsetsInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSetDescriptorBufferOffsetsInfoEXT.html - struct SetDescriptorBufferOffsetsInfoEXT - { - using NativeType = VkSetDescriptorBufferOffsetsInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSetDescriptorBufferOffsetsInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SetDescriptorBufferOffsetsInfoEXT( ShaderStageFlags stageFlags_ = {}, - PipelineLayout layout_ = {}, - uint32_t firstSet_ = {}, - uint32_t setCount_ = {}, - const uint32_t * pBufferIndices_ = {}, - const DeviceSize * pOffsets_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stageFlags{ stageFlags_ } - , layout{ layout_ } - , firstSet{ firstSet_ } - , setCount{ setCount_ } - , pBufferIndices{ pBufferIndices_ } - , pOffsets{ pOffsets_ } - { - } - - VULKAN_HPP_CONSTEXPR SetDescriptorBufferOffsetsInfoEXT( SetDescriptorBufferOffsetsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SetDescriptorBufferOffsetsInfoEXT( VkSetDescriptorBufferOffsetsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SetDescriptorBufferOffsetsInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SetDescriptorBufferOffsetsInfoEXT( ShaderStageFlags stageFlags_, - PipelineLayout layout_, - uint32_t firstSet_, - ArrayProxyNoTemporaries const & bufferIndices_, - ArrayProxyNoTemporaries const & offsets_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , stageFlags( stageFlags_ ) - , layout( layout_ ) - , firstSet( firstSet_ ) - , setCount( static_cast( bufferIndices_.size() ) ) - , pBufferIndices( bufferIndices_.data() ) - , pOffsets( offsets_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( bufferIndices_.size() == offsets_.size() ); -# else - if ( bufferIndices_.size() != offsets_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::SetDescriptorBufferOffsetsInfoEXT::SetDescriptorBufferOffsetsInfoEXT: bufferIndices_.size() != offsets_.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SetDescriptorBufferOffsetsInfoEXT & operator=( SetDescriptorBufferOffsetsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SetDescriptorBufferOffsetsInfoEXT & operator=( VkSetDescriptorBufferOffsetsInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setStageFlags( ShaderStageFlags stageFlags_ ) & VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setStageFlags( ShaderStageFlags stageFlags_ ) && VULKAN_HPP_NOEXCEPT - { - stageFlags = stageFlags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setLayout( PipelineLayout layout_ ) & VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setLayout( PipelineLayout layout_ ) && VULKAN_HPP_NOEXCEPT - { - layout = layout_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setFirstSet( uint32_t firstSet_ ) & VULKAN_HPP_NOEXCEPT - { - firstSet = firstSet_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setFirstSet( uint32_t firstSet_ ) && VULKAN_HPP_NOEXCEPT - { - firstSet = firstSet_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setSetCount( uint32_t setCount_ ) & VULKAN_HPP_NOEXCEPT - { - setCount = setCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setSetCount( uint32_t setCount_ ) && VULKAN_HPP_NOEXCEPT - { - setCount = setCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setPBufferIndices( const uint32_t * pBufferIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pBufferIndices = pBufferIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setPBufferIndices( const uint32_t * pBufferIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pBufferIndices = pBufferIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SetDescriptorBufferOffsetsInfoEXT & setBufferIndices( ArrayProxyNoTemporaries const & bufferIndices_ ) VULKAN_HPP_NOEXCEPT - { - setCount = static_cast( bufferIndices_.size() ); - pBufferIndices = bufferIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT & setPOffsets( const DeviceSize * pOffsets_ ) & VULKAN_HPP_NOEXCEPT - { - pOffsets = pOffsets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetDescriptorBufferOffsetsInfoEXT && setPOffsets( const DeviceSize * pOffsets_ ) && VULKAN_HPP_NOEXCEPT - { - pOffsets = pOffsets_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SetDescriptorBufferOffsetsInfoEXT & setOffsets( ArrayProxyNoTemporaries const & offsets_ ) VULKAN_HPP_NOEXCEPT - { - setCount = static_cast( offsets_.size() ); - pOffsets = offsets_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSetDescriptorBufferOffsetsInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSetDescriptorBufferOffsetsInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSetDescriptorBufferOffsetsInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSetDescriptorBufferOffsetsInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stageFlags, layout, firstSet, setCount, pBufferIndices, pOffsets ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SetDescriptorBufferOffsetsInfoEXT const & ) const = default; -#else - bool operator==( SetDescriptorBufferOffsetsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stageFlags == rhs.stageFlags ) && ( layout == rhs.layout ) && ( firstSet == rhs.firstSet ) && - ( setCount == rhs.setCount ) && ( pBufferIndices == rhs.pBufferIndices ) && ( pOffsets == rhs.pOffsets ); -# endif - } - - bool operator!=( SetDescriptorBufferOffsetsInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSetDescriptorBufferOffsetsInfoEXT; - const void * pNext = {}; - ShaderStageFlags stageFlags = {}; - PipelineLayout layout = {}; - uint32_t firstSet = {}; - uint32_t setCount = {}; - const uint32_t * pBufferIndices = {}; - const DeviceSize * pOffsets = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SetDescriptorBufferOffsetsInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SetDescriptorBufferOffsetsInfoEXT; - }; - - // wrapper struct for struct VkSetLatencyMarkerInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSetLatencyMarkerInfoNV.html - struct SetLatencyMarkerInfoNV - { - using NativeType = VkSetLatencyMarkerInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSetLatencyMarkerInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SetLatencyMarkerInfoNV( uint64_t presentID_ = {}, - LatencyMarkerNV marker_ = LatencyMarkerNV::eSimulationStart, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentID{ presentID_ } - , marker{ marker_ } - { - } - - VULKAN_HPP_CONSTEXPR SetLatencyMarkerInfoNV( SetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SetLatencyMarkerInfoNV( VkSetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : SetLatencyMarkerInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - SetLatencyMarkerInfoNV & operator=( SetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SetLatencyMarkerInfoNV & operator=( VkSetLatencyMarkerInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV & setPresentID( uint64_t presentID_ ) & VULKAN_HPP_NOEXCEPT - { - presentID = presentID_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV && setPresentID( uint64_t presentID_ ) && VULKAN_HPP_NOEXCEPT - { - presentID = presentID_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV & setMarker( LatencyMarkerNV marker_ ) & VULKAN_HPP_NOEXCEPT - { - marker = marker_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetLatencyMarkerInfoNV && setMarker( LatencyMarkerNV marker_ ) && VULKAN_HPP_NOEXCEPT - { - marker = marker_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSetLatencyMarkerInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSetLatencyMarkerInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSetLatencyMarkerInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSetLatencyMarkerInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentID, marker ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SetLatencyMarkerInfoNV const & ) const = default; -#else - bool operator==( SetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentID == rhs.presentID ) && ( marker == rhs.marker ); -# endif - } - - bool operator!=( SetLatencyMarkerInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSetLatencyMarkerInfoNV; - const void * pNext = {}; - uint64_t presentID = {}; - LatencyMarkerNV marker = LatencyMarkerNV::eSimulationStart; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SetLatencyMarkerInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = SetLatencyMarkerInfoNV; - }; - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - // wrapper struct for struct VkSetPresentConfigNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSetPresentConfigNV.html - struct SetPresentConfigNV - { - using NativeType = VkSetPresentConfigNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSetPresentConfigNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - SetPresentConfigNV( uint32_t numFramesPerBatch_ = {}, uint32_t presentConfigFeedback_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , numFramesPerBatch{ numFramesPerBatch_ } - , presentConfigFeedback{ presentConfigFeedback_ } - { - } - - VULKAN_HPP_CONSTEXPR SetPresentConfigNV( SetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SetPresentConfigNV( VkSetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT : SetPresentConfigNV( *reinterpret_cast( &rhs ) ) {} - - SetPresentConfigNV & operator=( SetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SetPresentConfigNV & operator=( VkSetPresentConfigNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV & setNumFramesPerBatch( uint32_t numFramesPerBatch_ ) & VULKAN_HPP_NOEXCEPT - { - numFramesPerBatch = numFramesPerBatch_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV && setNumFramesPerBatch( uint32_t numFramesPerBatch_ ) && VULKAN_HPP_NOEXCEPT - { - numFramesPerBatch = numFramesPerBatch_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV & setPresentConfigFeedback( uint32_t presentConfigFeedback_ ) & VULKAN_HPP_NOEXCEPT - { - presentConfigFeedback = presentConfigFeedback_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetPresentConfigNV && setPresentConfigFeedback( uint32_t presentConfigFeedback_ ) && VULKAN_HPP_NOEXCEPT - { - presentConfigFeedback = presentConfigFeedback_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSetPresentConfigNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSetPresentConfigNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSetPresentConfigNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSetPresentConfigNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, numFramesPerBatch, presentConfigFeedback ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SetPresentConfigNV const & ) const = default; -# else - bool operator==( SetPresentConfigNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( numFramesPerBatch == rhs.numFramesPerBatch ) && - ( presentConfigFeedback == rhs.presentConfigFeedback ); -# endif - } - - bool operator!=( SetPresentConfigNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eSetPresentConfigNV; - const void * pNext = {}; - uint32_t numFramesPerBatch = {}; - uint32_t presentConfigFeedback = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SetPresentConfigNV; - }; -# endif - - template <> - struct CppType - { - using Type = SetPresentConfigNV; - }; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - // wrapper struct for struct VkSetStateFlagsIndirectCommandNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSetStateFlagsIndirectCommandNV.html - struct SetStateFlagsIndirectCommandNV - { - using NativeType = VkSetStateFlagsIndirectCommandNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SetStateFlagsIndirectCommandNV( uint32_t data_ = {} ) VULKAN_HPP_NOEXCEPT : data{ data_ } {} - - VULKAN_HPP_CONSTEXPR SetStateFlagsIndirectCommandNV( SetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SetStateFlagsIndirectCommandNV( VkSetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - : SetStateFlagsIndirectCommandNV( *reinterpret_cast( &rhs ) ) - { - } - - SetStateFlagsIndirectCommandNV & operator=( SetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SetStateFlagsIndirectCommandNV & operator=( VkSetStateFlagsIndirectCommandNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SetStateFlagsIndirectCommandNV & setData( uint32_t data_ ) & VULKAN_HPP_NOEXCEPT - { - data = data_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SetStateFlagsIndirectCommandNV && setData( uint32_t data_ ) && VULKAN_HPP_NOEXCEPT - { - data = data_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSetStateFlagsIndirectCommandNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSetStateFlagsIndirectCommandNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSetStateFlagsIndirectCommandNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSetStateFlagsIndirectCommandNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( data ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SetStateFlagsIndirectCommandNV const & ) const = default; -#else - bool operator==( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( data == rhs.data ); -# endif - } - - bool operator!=( SetStateFlagsIndirectCommandNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t data = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SetStateFlagsIndirectCommandNV; - }; -#endif - - // wrapper struct for struct VkShaderCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderCreateInfoEXT.html - struct ShaderCreateInfoEXT - { - using NativeType = VkShaderCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ShaderCreateInfoEXT( ShaderCreateFlagsEXT flags_ = {}, - ShaderStageFlagBits stage_ = ShaderStageFlagBits::eVertex, - ShaderStageFlags nextStage_ = {}, - ShaderCodeTypeEXT codeType_ = ShaderCodeTypeEXT::eBinary, - size_t codeSize_ = {}, - const void * pCode_ = {}, - const char * pName_ = {}, - uint32_t setLayoutCount_ = {}, - const DescriptorSetLayout * pSetLayouts_ = {}, - uint32_t pushConstantRangeCount_ = {}, - const PushConstantRange * pPushConstantRanges_ = {}, - const SpecializationInfo * pSpecializationInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , stage{ stage_ } - , nextStage{ nextStage_ } - , codeType{ codeType_ } - , codeSize{ codeSize_ } - , pCode{ pCode_ } - , pName{ pName_ } - , setLayoutCount{ setLayoutCount_ } - , pSetLayouts{ pSetLayouts_ } - , pushConstantRangeCount{ pushConstantRangeCount_ } - , pPushConstantRanges{ pPushConstantRanges_ } - , pSpecializationInfo{ pSpecializationInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR ShaderCreateInfoEXT( ShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ShaderCreateInfoEXT( VkShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : ShaderCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - ShaderCreateInfoEXT( ShaderCreateFlagsEXT flags_, - ShaderStageFlagBits stage_, - ShaderStageFlags nextStage_, - ShaderCodeTypeEXT codeType_, - ArrayProxyNoTemporaries const & code_, - const char * pName_ = {}, - ArrayProxyNoTemporaries const & setLayouts_ = {}, - ArrayProxyNoTemporaries const & pushConstantRanges_ = {}, - const SpecializationInfo * pSpecializationInfo_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , stage( stage_ ) - , nextStage( nextStage_ ) - , codeType( codeType_ ) - , codeSize( code_.size() * sizeof( T ) ) - , pCode( code_.data() ) - , pName( pName_ ) - , setLayoutCount( static_cast( setLayouts_.size() ) ) - , pSetLayouts( setLayouts_.data() ) - , pushConstantRangeCount( static_cast( pushConstantRanges_.size() ) ) - , pPushConstantRanges( pushConstantRanges_.data() ) - , pSpecializationInfo( pSpecializationInfo_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ShaderCreateInfoEXT & operator=( ShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ShaderCreateInfoEXT & operator=( VkShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setFlags( ShaderCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setFlags( ShaderCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setStage( ShaderStageFlagBits stage_ ) & VULKAN_HPP_NOEXCEPT - { - stage = stage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setStage( ShaderStageFlagBits stage_ ) && VULKAN_HPP_NOEXCEPT - { - stage = stage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setNextStage( ShaderStageFlags nextStage_ ) & VULKAN_HPP_NOEXCEPT - { - nextStage = nextStage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setNextStage( ShaderStageFlags nextStage_ ) && VULKAN_HPP_NOEXCEPT - { - nextStage = nextStage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setCodeType( ShaderCodeTypeEXT codeType_ ) & VULKAN_HPP_NOEXCEPT - { - codeType = codeType_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setCodeType( ShaderCodeTypeEXT codeType_ ) && VULKAN_HPP_NOEXCEPT - { - codeType = codeType_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setCodeSize( size_t codeSize_ ) & VULKAN_HPP_NOEXCEPT - { - codeSize = codeSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setCodeSize( size_t codeSize_ ) && VULKAN_HPP_NOEXCEPT - { - codeSize = codeSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPCode( const void * pCode_ ) & VULKAN_HPP_NOEXCEPT - { - pCode = pCode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPCode( const void * pCode_ ) && VULKAN_HPP_NOEXCEPT - { - pCode = pCode_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - ShaderCreateInfoEXT & setCode( ArrayProxyNoTemporaries const & code_ ) VULKAN_HPP_NOEXCEPT - { - codeSize = code_.size() * sizeof( T ); - pCode = code_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPName( const char * pName_ ) & VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPName( const char * pName_ ) && VULKAN_HPP_NOEXCEPT - { - pName = pName_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setSetLayoutCount( uint32_t setLayoutCount_ ) & VULKAN_HPP_NOEXCEPT - { - setLayoutCount = setLayoutCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setSetLayoutCount( uint32_t setLayoutCount_ ) && VULKAN_HPP_NOEXCEPT - { - setLayoutCount = setLayoutCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) & VULKAN_HPP_NOEXCEPT - { - pSetLayouts = pSetLayouts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPSetLayouts( const DescriptorSetLayout * pSetLayouts_ ) && VULKAN_HPP_NOEXCEPT - { - pSetLayouts = pSetLayouts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ShaderCreateInfoEXT & setSetLayouts( ArrayProxyNoTemporaries const & setLayouts_ ) VULKAN_HPP_NOEXCEPT - { - setLayoutCount = static_cast( setLayouts_.size() ); - pSetLayouts = setLayouts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) & VULKAN_HPP_NOEXCEPT - { - pushConstantRangeCount = pushConstantRangeCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) && VULKAN_HPP_NOEXCEPT - { - pushConstantRangeCount = pushConstantRangeCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) & VULKAN_HPP_NOEXCEPT - { - pPushConstantRanges = pPushConstantRanges_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPPushConstantRanges( const PushConstantRange * pPushConstantRanges_ ) && VULKAN_HPP_NOEXCEPT - { - pPushConstantRanges = pPushConstantRanges_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ShaderCreateInfoEXT & setPushConstantRanges( ArrayProxyNoTemporaries const & pushConstantRanges_ ) VULKAN_HPP_NOEXCEPT - { - pushConstantRangeCount = static_cast( pushConstantRanges_.size() ); - pPushConstantRanges = pushConstantRanges_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pSpecializationInfo = pSpecializationInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT && setPSpecializationInfo( const SpecializationInfo * pSpecializationInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pSpecializationInfo = pSpecializationInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkShaderCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkShaderCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - stage, - nextStage, - codeType, - codeSize, - pCode, - pName, - setLayoutCount, - pSetLayouts, - pushConstantRangeCount, - pPushConstantRanges, - pSpecializationInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( ShaderCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = stage <=> rhs.stage; cmp != 0 ) - return cmp; - if ( auto cmp = nextStage <=> rhs.nextStage; cmp != 0 ) - return cmp; - if ( auto cmp = codeType <=> rhs.codeType; cmp != 0 ) - return cmp; - if ( auto cmp = codeSize <=> rhs.codeSize; cmp != 0 ) - return cmp; - if ( auto cmp = pCode <=> rhs.pCode; cmp != 0 ) - return cmp; - if ( pName != rhs.pName ) - if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = setLayoutCount <=> rhs.setLayoutCount; cmp != 0 ) - return cmp; - if ( auto cmp = pSetLayouts <=> rhs.pSetLayouts; cmp != 0 ) - return cmp; - if ( auto cmp = pushConstantRangeCount <=> rhs.pushConstantRangeCount; cmp != 0 ) - return cmp; - if ( auto cmp = pPushConstantRanges <=> rhs.pPushConstantRanges; cmp != 0 ) - return cmp; - if ( auto cmp = pSpecializationInfo <=> rhs.pSpecializationInfo; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( ShaderCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( nextStage == rhs.nextStage ) && - ( codeType == rhs.codeType ) && ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode ) && - ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( setLayoutCount == rhs.setLayoutCount ) && - ( pSetLayouts == rhs.pSetLayouts ) && ( pushConstantRangeCount == rhs.pushConstantRangeCount ) && - ( pPushConstantRanges == rhs.pPushConstantRanges ) && ( pSpecializationInfo == rhs.pSpecializationInfo ); - } - - bool operator!=( ShaderCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eShaderCreateInfoEXT; - const void * pNext = {}; - ShaderCreateFlagsEXT flags = {}; - ShaderStageFlagBits stage = ShaderStageFlagBits::eVertex; - ShaderStageFlags nextStage = {}; - ShaderCodeTypeEXT codeType = ShaderCodeTypeEXT::eBinary; - size_t codeSize = {}; - const void * pCode = {}; - const char * pName = {}; - uint32_t setLayoutCount = {}; - const DescriptorSetLayout * pSetLayouts = {}; - uint32_t pushConstantRangeCount = {}; - const PushConstantRange * pPushConstantRanges = {}; - const SpecializationInfo * pSpecializationInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ShaderCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ShaderCreateInfoEXT; - }; - - // wrapper struct for struct VkShaderDescriptorSetAndBindingMappingInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderDescriptorSetAndBindingMappingInfoEXT.html - struct ShaderDescriptorSetAndBindingMappingInfoEXT - { - using NativeType = VkShaderDescriptorSetAndBindingMappingInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderDescriptorSetAndBindingMappingInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ShaderDescriptorSetAndBindingMappingInfoEXT( uint32_t mappingCount_ = {}, - const DescriptorSetAndBindingMappingEXT * pMappings_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , mappingCount{ mappingCount_ } - , pMappings{ pMappings_ } - { - } - - VULKAN_HPP_CONSTEXPR ShaderDescriptorSetAndBindingMappingInfoEXT( ShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ShaderDescriptorSetAndBindingMappingInfoEXT( VkShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ShaderDescriptorSetAndBindingMappingInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ShaderDescriptorSetAndBindingMappingInfoEXT( ArrayProxyNoTemporaries const & mappings_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), mappingCount( static_cast( mappings_.size() ) ), pMappings( mappings_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ShaderDescriptorSetAndBindingMappingInfoEXT & operator=( ShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ShaderDescriptorSetAndBindingMappingInfoEXT & operator=( VkShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT & setMappingCount( uint32_t mappingCount_ ) & VULKAN_HPP_NOEXCEPT - { - mappingCount = mappingCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT && setMappingCount( uint32_t mappingCount_ ) && VULKAN_HPP_NOEXCEPT - { - mappingCount = mappingCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT & setPMappings( const DescriptorSetAndBindingMappingEXT * pMappings_ ) & - VULKAN_HPP_NOEXCEPT - { - pMappings = pMappings_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderDescriptorSetAndBindingMappingInfoEXT && setPMappings( const DescriptorSetAndBindingMappingEXT * pMappings_ ) && - VULKAN_HPP_NOEXCEPT - { - pMappings = pMappings_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ShaderDescriptorSetAndBindingMappingInfoEXT & - setMappings( ArrayProxyNoTemporaries const & mappings_ ) VULKAN_HPP_NOEXCEPT - { - mappingCount = static_cast( mappings_.size() ); - pMappings = mappings_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkShaderDescriptorSetAndBindingMappingInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderDescriptorSetAndBindingMappingInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderDescriptorSetAndBindingMappingInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkShaderDescriptorSetAndBindingMappingInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, mappingCount, pMappings ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ShaderDescriptorSetAndBindingMappingInfoEXT const & ) const = default; -#else - bool operator==( ShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( mappingCount == rhs.mappingCount ) && ( pMappings == rhs.pMappings ); -# endif - } - - bool operator!=( ShaderDescriptorSetAndBindingMappingInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eShaderDescriptorSetAndBindingMappingInfoEXT; - const void * pNext = {}; - uint32_t mappingCount = {}; - const DescriptorSetAndBindingMappingEXT * pMappings = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ShaderDescriptorSetAndBindingMappingInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ShaderDescriptorSetAndBindingMappingInfoEXT; - }; - - // wrapper struct for struct VkShaderModuleCreateInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleCreateInfo.html - struct ShaderModuleCreateInfo - { - using NativeType = VkShaderModuleCreateInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderModuleCreateInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_ = {}, - size_t codeSize_ = {}, - const uint32_t * pCode_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , codeSize{ codeSize_ } - , pCode{ pCode_ } - { - } - - VULKAN_HPP_CONSTEXPR ShaderModuleCreateInfo( ShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ShaderModuleCreateInfo( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : ShaderModuleCreateInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ShaderModuleCreateInfo( ShaderModuleCreateFlags flags_, ArrayProxyNoTemporaries const & code_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), flags( flags_ ), codeSize( code_.size() * 4 ), pCode( code_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ShaderModuleCreateInfo & operator=( ShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ShaderModuleCreateInfo & operator=( VkShaderModuleCreateInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo & setFlags( ShaderModuleCreateFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo && setFlags( ShaderModuleCreateFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo & setCodeSize( size_t codeSize_ ) & VULKAN_HPP_NOEXCEPT - { - codeSize = codeSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo && setCodeSize( size_t codeSize_ ) && VULKAN_HPP_NOEXCEPT - { - codeSize = codeSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo & setPCode( const uint32_t * pCode_ ) & VULKAN_HPP_NOEXCEPT - { - pCode = pCode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderModuleCreateInfo && setPCode( const uint32_t * pCode_ ) && VULKAN_HPP_NOEXCEPT - { - pCode = pCode_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ShaderModuleCreateInfo & setCode( ArrayProxyNoTemporaries const & code_ ) VULKAN_HPP_NOEXCEPT - { - codeSize = code_.size() * 4; - pCode = code_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkShaderModuleCreateInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderModuleCreateInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderModuleCreateInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkShaderModuleCreateInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, codeSize, pCode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ShaderModuleCreateInfo const & ) const = default; -#else - bool operator==( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode ); -# endif - } - - bool operator!=( ShaderModuleCreateInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eShaderModuleCreateInfo; - const void * pNext = {}; - ShaderModuleCreateFlags flags = {}; - size_t codeSize = {}; - const uint32_t * pCode = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ShaderModuleCreateInfo; - }; -#endif - - template <> - struct CppType - { - using Type = ShaderModuleCreateInfo; - }; - - // wrapper struct for struct VkShaderModuleIdentifierEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleIdentifierEXT.html - struct ShaderModuleIdentifierEXT - { - using NativeType = VkShaderModuleIdentifierEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderModuleIdentifierEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 ShaderModuleIdentifierEXT( uint32_t identifierSize_ = {}, - std::array const & identifier_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , identifierSize{ identifierSize_ } - , identifier{ identifier_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 ShaderModuleIdentifierEXT( ShaderModuleIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ShaderModuleIdentifierEXT( VkShaderModuleIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ShaderModuleIdentifierEXT( *reinterpret_cast( &rhs ) ) - { - } - - ShaderModuleIdentifierEXT & operator=( ShaderModuleIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ShaderModuleIdentifierEXT & operator=( VkShaderModuleIdentifierEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkShaderModuleIdentifierEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderModuleIdentifierEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderModuleIdentifierEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkShaderModuleIdentifierEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, identifierSize, identifier ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( ShaderModuleIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = identifierSize <=> rhs.identifierSize; cmp != 0 ) - return cmp; - for ( size_t i = 0; i < identifierSize; ++i ) - { - if ( auto cmp = identifier[i] <=> rhs.identifier[i]; cmp != 0 ) - return cmp; - } - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( ShaderModuleIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( identifierSize == rhs.identifierSize ) && - ( memcmp( identifier, rhs.identifier, identifierSize * sizeof( uint8_t ) ) == 0 ); - } - - bool operator!=( ShaderModuleIdentifierEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eShaderModuleIdentifierEXT; - void * pNext = {}; - uint32_t identifierSize = {}; - ArrayWrapper1D identifier = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ShaderModuleIdentifierEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ShaderModuleIdentifierEXT; - }; - - // wrapper struct for struct VkShaderModuleValidationCacheCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderModuleValidationCacheCreateInfoEXT.html - struct ShaderModuleValidationCacheCreateInfoEXT - { - using NativeType = VkShaderModuleValidationCacheCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( ValidationCacheEXT validationCache_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , validationCache{ validationCache_ } - { - } - - VULKAN_HPP_CONSTEXPR ShaderModuleValidationCacheCreateInfoEXT( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ShaderModuleValidationCacheCreateInfoEXT( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ShaderModuleValidationCacheCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - ShaderModuleValidationCacheCreateInfoEXT & operator=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ShaderModuleValidationCacheCreateInfoEXT & operator=( VkShaderModuleValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ShaderModuleValidationCacheCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderModuleValidationCacheCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ShaderModuleValidationCacheCreateInfoEXT & setValidationCache( ValidationCacheEXT validationCache_ ) & VULKAN_HPP_NOEXCEPT - { - validationCache = validationCache_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ShaderModuleValidationCacheCreateInfoEXT && setValidationCache( ValidationCacheEXT validationCache_ ) && VULKAN_HPP_NOEXCEPT - { - validationCache = validationCache_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkShaderModuleValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderModuleValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderModuleValidationCacheCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkShaderModuleValidationCacheCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, validationCache ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ShaderModuleValidationCacheCreateInfoEXT const & ) const = default; -#else - bool operator==( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( validationCache == rhs.validationCache ); -# endif - } - - bool operator!=( ShaderModuleValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eShaderModuleValidationCacheCreateInfoEXT; - const void * pNext = {}; - ValidationCacheEXT validationCache = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ShaderModuleValidationCacheCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ShaderModuleValidationCacheCreateInfoEXT; - }; - - // wrapper struct for struct VkShaderResourceUsageAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderResourceUsageAMD.html - struct ShaderResourceUsageAMD - { - using NativeType = VkShaderResourceUsageAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ShaderResourceUsageAMD( uint32_t numUsedVgprs_ = {}, - uint32_t numUsedSgprs_ = {}, - uint32_t ldsSizePerLocalWorkGroup_ = {}, - size_t ldsUsageSizeInBytes_ = {}, - size_t scratchMemUsageInBytes_ = {} ) VULKAN_HPP_NOEXCEPT - : numUsedVgprs{ numUsedVgprs_ } - , numUsedSgprs{ numUsedSgprs_ } - , ldsSizePerLocalWorkGroup{ ldsSizePerLocalWorkGroup_ } - , ldsUsageSizeInBytes{ ldsUsageSizeInBytes_ } - , scratchMemUsageInBytes{ scratchMemUsageInBytes_ } - { - } - - VULKAN_HPP_CONSTEXPR ShaderResourceUsageAMD( ShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ShaderResourceUsageAMD( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : ShaderResourceUsageAMD( *reinterpret_cast( &rhs ) ) - { - } - - ShaderResourceUsageAMD & operator=( ShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ShaderResourceUsageAMD & operator=( VkShaderResourceUsageAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkShaderResourceUsageAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderResourceUsageAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderResourceUsageAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkShaderResourceUsageAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( numUsedVgprs, numUsedSgprs, ldsSizePerLocalWorkGroup, ldsUsageSizeInBytes, scratchMemUsageInBytes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ShaderResourceUsageAMD const & ) const = default; -#else - bool operator==( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( numUsedVgprs == rhs.numUsedVgprs ) && ( numUsedSgprs == rhs.numUsedSgprs ) && ( ldsSizePerLocalWorkGroup == rhs.ldsSizePerLocalWorkGroup ) && - ( ldsUsageSizeInBytes == rhs.ldsUsageSizeInBytes ) && ( scratchMemUsageInBytes == rhs.scratchMemUsageInBytes ); -# endif - } - - bool operator!=( ShaderResourceUsageAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t numUsedVgprs = {}; - uint32_t numUsedSgprs = {}; - uint32_t ldsSizePerLocalWorkGroup = {}; - size_t ldsUsageSizeInBytes = {}; - size_t scratchMemUsageInBytes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ShaderResourceUsageAMD; - }; -#endif - - // wrapper struct for struct VkShaderStatisticsInfoAMD, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkShaderStatisticsInfoAMD.html - struct ShaderStatisticsInfoAMD - { - using NativeType = VkShaderStatisticsInfoAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 ShaderStatisticsInfoAMD( ShaderStageFlags shaderStageMask_ = {}, - ShaderResourceUsageAMD resourceUsage_ = {}, - uint32_t numPhysicalVgprs_ = {}, - uint32_t numPhysicalSgprs_ = {}, - uint32_t numAvailableVgprs_ = {}, - uint32_t numAvailableSgprs_ = {}, - std::array const & computeWorkGroupSize_ = {} ) VULKAN_HPP_NOEXCEPT - : shaderStageMask{ shaderStageMask_ } - , resourceUsage{ resourceUsage_ } - , numPhysicalVgprs{ numPhysicalVgprs_ } - , numPhysicalSgprs{ numPhysicalSgprs_ } - , numAvailableVgprs{ numAvailableVgprs_ } - , numAvailableSgprs{ numAvailableSgprs_ } - , computeWorkGroupSize{ computeWorkGroupSize_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 ShaderStatisticsInfoAMD( ShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ShaderStatisticsInfoAMD( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : ShaderStatisticsInfoAMD( *reinterpret_cast( &rhs ) ) - { - } - - ShaderStatisticsInfoAMD & operator=( ShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ShaderStatisticsInfoAMD & operator=( VkShaderStatisticsInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkShaderStatisticsInfoAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderStatisticsInfoAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkShaderStatisticsInfoAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkShaderStatisticsInfoAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( shaderStageMask, resourceUsage, numPhysicalVgprs, numPhysicalSgprs, numAvailableVgprs, numAvailableSgprs, computeWorkGroupSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ShaderStatisticsInfoAMD const & ) const = default; -#else - bool operator==( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( shaderStageMask == rhs.shaderStageMask ) && ( resourceUsage == rhs.resourceUsage ) && ( numPhysicalVgprs == rhs.numPhysicalVgprs ) && - ( numPhysicalSgprs == rhs.numPhysicalSgprs ) && ( numAvailableVgprs == rhs.numAvailableVgprs ) && ( numAvailableSgprs == rhs.numAvailableSgprs ) && - ( computeWorkGroupSize == rhs.computeWorkGroupSize ); -# endif - } - - bool operator!=( ShaderStatisticsInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ShaderStageFlags shaderStageMask = {}; - ShaderResourceUsageAMD resourceUsage = {}; - uint32_t numPhysicalVgprs = {}; - uint32_t numPhysicalSgprs = {}; - uint32_t numAvailableVgprs = {}; - uint32_t numAvailableSgprs = {}; - ArrayWrapper1D computeWorkGroupSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ShaderStatisticsInfoAMD; - }; -#endif - - // wrapper struct for struct VkSharedPresentSurfaceCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSharedPresentSurfaceCapabilitiesKHR.html - struct SharedPresentSurfaceCapabilitiesKHR - { - using NativeType = VkSharedPresentSurfaceCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SharedPresentSurfaceCapabilitiesKHR( ImageUsageFlags sharedPresentSupportedUsageFlags_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , sharedPresentSupportedUsageFlags{ sharedPresentSupportedUsageFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR SharedPresentSurfaceCapabilitiesKHR( SharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SharedPresentSurfaceCapabilitiesKHR( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SharedPresentSurfaceCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - SharedPresentSurfaceCapabilitiesKHR & operator=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SharedPresentSurfaceCapabilitiesKHR & operator=( VkSharedPresentSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSharedPresentSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSharedPresentSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSharedPresentSurfaceCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSharedPresentSurfaceCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, sharedPresentSupportedUsageFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SharedPresentSurfaceCapabilitiesKHR const & ) const = default; -#else - bool operator==( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( sharedPresentSupportedUsageFlags == rhs.sharedPresentSupportedUsageFlags ); -# endif - } - - bool operator!=( SharedPresentSurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSharedPresentSurfaceCapabilitiesKHR; - void * pNext = {}; - ImageUsageFlags sharedPresentSupportedUsageFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SharedPresentSurfaceCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = SharedPresentSurfaceCapabilitiesKHR; - }; - - // wrapper struct for struct VkSparseImageFormatProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageFormatProperties.html - struct SparseImageFormatProperties - { - using NativeType = VkSparseImageFormatProperties; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - SparseImageFormatProperties( ImageAspectFlags aspectMask_ = {}, Extent3D imageGranularity_ = {}, SparseImageFormatFlags flags_ = {} ) VULKAN_HPP_NOEXCEPT - : aspectMask{ aspectMask_ } - , imageGranularity{ imageGranularity_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR SparseImageFormatProperties( SparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SparseImageFormatProperties( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - : SparseImageFormatProperties( *reinterpret_cast( &rhs ) ) - { - } - - SparseImageFormatProperties & operator=( SparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SparseImageFormatProperties & operator=( VkSparseImageFormatProperties const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSparseImageFormatProperties const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageFormatProperties &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageFormatProperties const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSparseImageFormatProperties *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( aspectMask, imageGranularity, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SparseImageFormatProperties const & ) const = default; -#else - bool operator==( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( aspectMask == rhs.aspectMask ) && ( imageGranularity == rhs.imageGranularity ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( SparseImageFormatProperties const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - ImageAspectFlags aspectMask = {}; - Extent3D imageGranularity = {}; - SparseImageFormatFlags flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SparseImageFormatProperties; - }; -#endif - - // wrapper struct for struct VkSparseImageFormatProperties2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageFormatProperties2.html - struct SparseImageFormatProperties2 - { - using NativeType = VkSparseImageFormatProperties2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSparseImageFormatProperties2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SparseImageFormatProperties2( SparseImageFormatProperties properties_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , properties{ properties_ } - { - } - - VULKAN_HPP_CONSTEXPR SparseImageFormatProperties2( SparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SparseImageFormatProperties2( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - : SparseImageFormatProperties2( *reinterpret_cast( &rhs ) ) - { - } - - SparseImageFormatProperties2 & operator=( SparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SparseImageFormatProperties2 & operator=( VkSparseImageFormatProperties2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSparseImageFormatProperties2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageFormatProperties2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageFormatProperties2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSparseImageFormatProperties2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, properties ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SparseImageFormatProperties2 const & ) const = default; -#else - bool operator==( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( properties == rhs.properties ); -# endif - } - - bool operator!=( SparseImageFormatProperties2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSparseImageFormatProperties2; - void * pNext = {}; - SparseImageFormatProperties properties = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SparseImageFormatProperties2; - }; -#endif - - template <> - struct CppType - { - using Type = SparseImageFormatProperties2; - }; - - using SparseImageFormatProperties2KHR = SparseImageFormatProperties2; - - // wrapper struct for struct VkSparseImageMemoryRequirements, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageMemoryRequirements.html - struct SparseImageMemoryRequirements - { - using NativeType = VkSparseImageMemoryRequirements; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements( SparseImageFormatProperties formatProperties_ = {}, - uint32_t imageMipTailFirstLod_ = {}, - DeviceSize imageMipTailSize_ = {}, - DeviceSize imageMipTailOffset_ = {}, - DeviceSize imageMipTailStride_ = {} ) VULKAN_HPP_NOEXCEPT - : formatProperties{ formatProperties_ } - , imageMipTailFirstLod{ imageMipTailFirstLod_ } - , imageMipTailSize{ imageMipTailSize_ } - , imageMipTailOffset{ imageMipTailOffset_ } - , imageMipTailStride{ imageMipTailStride_ } - { - } - - VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements( SparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SparseImageMemoryRequirements( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - : SparseImageMemoryRequirements( *reinterpret_cast( &rhs ) ) - { - } - - SparseImageMemoryRequirements & operator=( SparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SparseImageMemoryRequirements & operator=( VkSparseImageMemoryRequirements const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSparseImageMemoryRequirements const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageMemoryRequirements &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageMemoryRequirements const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSparseImageMemoryRequirements *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( formatProperties, imageMipTailFirstLod, imageMipTailSize, imageMipTailOffset, imageMipTailStride ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SparseImageMemoryRequirements const & ) const = default; -#else - bool operator==( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( formatProperties == rhs.formatProperties ) && ( imageMipTailFirstLod == rhs.imageMipTailFirstLod ) && - ( imageMipTailSize == rhs.imageMipTailSize ) && ( imageMipTailOffset == rhs.imageMipTailOffset ) && - ( imageMipTailStride == rhs.imageMipTailStride ); -# endif - } - - bool operator!=( SparseImageMemoryRequirements const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - SparseImageFormatProperties formatProperties = {}; - uint32_t imageMipTailFirstLod = {}; - DeviceSize imageMipTailSize = {}; - DeviceSize imageMipTailOffset = {}; - DeviceSize imageMipTailStride = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SparseImageMemoryRequirements; - }; -#endif - - // wrapper struct for struct VkSparseImageMemoryRequirements2, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSparseImageMemoryRequirements2.html - struct SparseImageMemoryRequirements2 - { - using NativeType = VkSparseImageMemoryRequirements2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSparseImageMemoryRequirements2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements2( SparseImageMemoryRequirements memoryRequirements_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryRequirements{ memoryRequirements_ } - { - } - - VULKAN_HPP_CONSTEXPR SparseImageMemoryRequirements2( SparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SparseImageMemoryRequirements2( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - : SparseImageMemoryRequirements2( *reinterpret_cast( &rhs ) ) - { - } - - SparseImageMemoryRequirements2 & operator=( SparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SparseImageMemoryRequirements2 & operator=( VkSparseImageMemoryRequirements2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSparseImageMemoryRequirements2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageMemoryRequirements2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSparseImageMemoryRequirements2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSparseImageMemoryRequirements2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryRequirements ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SparseImageMemoryRequirements2 const & ) const = default; -#else - bool operator==( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryRequirements == rhs.memoryRequirements ); -# endif - } - - bool operator!=( SparseImageMemoryRequirements2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSparseImageMemoryRequirements2; - void * pNext = {}; - SparseImageMemoryRequirements memoryRequirements = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SparseImageMemoryRequirements2; - }; -#endif - - template <> - struct CppType - { - using Type = SparseImageMemoryRequirements2; - }; - - using SparseImageMemoryRequirements2KHR = SparseImageMemoryRequirements2; - -#if defined( VK_USE_PLATFORM_GGP ) - // wrapper struct for struct VkStreamDescriptorSurfaceCreateInfoGGP, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkStreamDescriptorSurfaceCreateInfoGGP.html - struct StreamDescriptorSurfaceCreateInfoGGP - { - using NativeType = VkStreamDescriptorSurfaceCreateInfoGGP; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( StreamDescriptorSurfaceCreateFlagsGGP flags_ = {}, - GgpStreamDescriptor streamDescriptor_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , streamDescriptor{ streamDescriptor_ } - { - } - - VULKAN_HPP_CONSTEXPR StreamDescriptorSurfaceCreateInfoGGP( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - StreamDescriptorSurfaceCreateInfoGGP( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT - : StreamDescriptorSurfaceCreateInfoGGP( *reinterpret_cast( &rhs ) ) - { - } - - StreamDescriptorSurfaceCreateInfoGGP & operator=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - StreamDescriptorSurfaceCreateInfoGGP & operator=( VkStreamDescriptorSurfaceCreateInfoGGP const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP & setFlags( StreamDescriptorSurfaceCreateFlagsGGP flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP && setFlags( StreamDescriptorSurfaceCreateFlagsGGP flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP & setStreamDescriptor( GgpStreamDescriptor streamDescriptor_ ) & VULKAN_HPP_NOEXCEPT - { - streamDescriptor = streamDescriptor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 StreamDescriptorSurfaceCreateInfoGGP && setStreamDescriptor( GgpStreamDescriptor streamDescriptor_ ) && VULKAN_HPP_NOEXCEPT - { - streamDescriptor = streamDescriptor_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkStreamDescriptorSurfaceCreateInfoGGP const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStreamDescriptorSurfaceCreateInfoGGP &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkStreamDescriptorSurfaceCreateInfoGGP const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkStreamDescriptorSurfaceCreateInfoGGP *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, streamDescriptor ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &streamDescriptor, &rhs.streamDescriptor, sizeof( GgpStreamDescriptor ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -# endif - - bool operator==( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( memcmp( &streamDescriptor, &rhs.streamDescriptor, sizeof( GgpStreamDescriptor ) ) == 0 ); - } - - bool operator!=( StreamDescriptorSurfaceCreateInfoGGP const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eStreamDescriptorSurfaceCreateInfoGGP; - const void * pNext = {}; - StreamDescriptorSurfaceCreateFlagsGGP flags = {}; - GgpStreamDescriptor streamDescriptor = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = StreamDescriptorSurfaceCreateInfoGGP; - }; -# endif - - template <> - struct CppType - { - using Type = StreamDescriptorSurfaceCreateInfoGGP; - }; -#endif /*VK_USE_PLATFORM_GGP*/ - - // wrapper struct for struct VkSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitInfo.html - struct SubmitInfo - { - using NativeType = VkSubmitInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubmitInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubmitInfo( uint32_t waitSemaphoreCount_ = {}, - const Semaphore * pWaitSemaphores_ = {}, - const PipelineStageFlags * pWaitDstStageMask_ = {}, - uint32_t commandBufferCount_ = {}, - const CommandBuffer * pCommandBuffers_ = {}, - uint32_t signalSemaphoreCount_ = {}, - const Semaphore * pSignalSemaphores_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , waitSemaphoreCount{ waitSemaphoreCount_ } - , pWaitSemaphores{ pWaitSemaphores_ } - , pWaitDstStageMask{ pWaitDstStageMask_ } - , commandBufferCount{ commandBufferCount_ } - , pCommandBuffers{ pCommandBuffers_ } - , signalSemaphoreCount{ signalSemaphoreCount_ } - , pSignalSemaphores{ pSignalSemaphores_ } - { - } - - VULKAN_HPP_CONSTEXPR SubmitInfo( SubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubmitInfo( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SubmitInfo( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubmitInfo( ArrayProxyNoTemporaries const & waitSemaphores_, - ArrayProxyNoTemporaries const & waitDstStageMask_ = {}, - ArrayProxyNoTemporaries const & commandBuffers_ = {}, - ArrayProxyNoTemporaries const & signalSemaphores_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , waitSemaphoreCount( static_cast( waitSemaphores_.size() ) ) - , pWaitSemaphores( waitSemaphores_.data() ) - , pWaitDstStageMask( waitDstStageMask_.data() ) - , commandBufferCount( static_cast( commandBuffers_.size() ) ) - , pCommandBuffers( commandBuffers_.data() ) - , signalSemaphoreCount( static_cast( signalSemaphores_.size() ) ) - , pSignalSemaphores( signalSemaphores_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( waitSemaphores_.size() == waitDstStageMask_.size() ); -# else - if ( waitSemaphores_.size() != waitDstStageMask_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::SubmitInfo::SubmitInfo: waitSemaphores_.size() != waitDstStageMask_.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SubmitInfo & operator=( SubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubmitInfo & operator=( VkSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = waitSemaphoreCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setWaitSemaphoreCount( uint32_t waitSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = waitSemaphoreCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) & VULKAN_HPP_NOEXCEPT - { - pWaitSemaphores = pWaitSemaphores_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setPWaitSemaphores( const Semaphore * pWaitSemaphores_ ) && VULKAN_HPP_NOEXCEPT - { - pWaitSemaphores = pWaitSemaphores_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubmitInfo & setWaitSemaphores( ArrayProxyNoTemporaries const & waitSemaphores_ ) VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = static_cast( waitSemaphores_.size() ); - pWaitSemaphores = waitSemaphores_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setPWaitDstStageMask( const PipelineStageFlags * pWaitDstStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - pWaitDstStageMask = pWaitDstStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setPWaitDstStageMask( const PipelineStageFlags * pWaitDstStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - pWaitDstStageMask = pWaitDstStageMask_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubmitInfo & setWaitDstStageMask( ArrayProxyNoTemporaries const & waitDstStageMask_ ) VULKAN_HPP_NOEXCEPT - { - waitSemaphoreCount = static_cast( waitDstStageMask_.size() ); - pWaitDstStageMask = waitDstStageMask_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setCommandBufferCount( uint32_t commandBufferCount_ ) & VULKAN_HPP_NOEXCEPT - { - commandBufferCount = commandBufferCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setCommandBufferCount( uint32_t commandBufferCount_ ) && VULKAN_HPP_NOEXCEPT - { - commandBufferCount = commandBufferCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setPCommandBuffers( const CommandBuffer * pCommandBuffers_ ) & VULKAN_HPP_NOEXCEPT - { - pCommandBuffers = pCommandBuffers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setPCommandBuffers( const CommandBuffer * pCommandBuffers_ ) && VULKAN_HPP_NOEXCEPT - { - pCommandBuffers = pCommandBuffers_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubmitInfo & setCommandBuffers( ArrayProxyNoTemporaries const & commandBuffers_ ) VULKAN_HPP_NOEXCEPT - { - commandBufferCount = static_cast( commandBuffers_.size() ); - pCommandBuffers = commandBuffers_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) & VULKAN_HPP_NOEXCEPT - { - signalSemaphoreCount = signalSemaphoreCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setSignalSemaphoreCount( uint32_t signalSemaphoreCount_ ) && VULKAN_HPP_NOEXCEPT - { - signalSemaphoreCount = signalSemaphoreCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo & setPSignalSemaphores( const Semaphore * pSignalSemaphores_ ) & VULKAN_HPP_NOEXCEPT - { - pSignalSemaphores = pSignalSemaphores_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo && setPSignalSemaphores( const Semaphore * pSignalSemaphores_ ) && VULKAN_HPP_NOEXCEPT - { - pSignalSemaphores = pSignalSemaphores_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubmitInfo & setSignalSemaphores( ArrayProxyNoTemporaries const & signalSemaphores_ ) VULKAN_HPP_NOEXCEPT - { - signalSemaphoreCount = static_cast( signalSemaphores_.size() ); - pSignalSemaphores = signalSemaphores_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubmitInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubmitInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubmitInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubmitInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, waitSemaphoreCount, pWaitSemaphores, pWaitDstStageMask, commandBufferCount, pCommandBuffers, signalSemaphoreCount, pSignalSemaphores ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubmitInfo const & ) const = default; -#else - bool operator==( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreCount == rhs.waitSemaphoreCount ) && - ( pWaitSemaphores == rhs.pWaitSemaphores ) && ( pWaitDstStageMask == rhs.pWaitDstStageMask ) && ( commandBufferCount == rhs.commandBufferCount ) && - ( pCommandBuffers == rhs.pCommandBuffers ) && ( signalSemaphoreCount == rhs.signalSemaphoreCount ) && - ( pSignalSemaphores == rhs.pSignalSemaphores ); -# endif - } - - bool operator!=( SubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubmitInfo; - const void * pNext = {}; - uint32_t waitSemaphoreCount = {}; - const Semaphore * pWaitSemaphores = {}; - const PipelineStageFlags * pWaitDstStageMask = {}; - uint32_t commandBufferCount = {}; - const CommandBuffer * pCommandBuffers = {}; - uint32_t signalSemaphoreCount = {}; - const Semaphore * pSignalSemaphores = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubmitInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SubmitInfo; - }; - - // wrapper struct for struct VkSubmitInfo2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitInfo2.html - struct SubmitInfo2 - { - using NativeType = VkSubmitInfo2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubmitInfo2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubmitInfo2( SubmitFlags flags_ = {}, - uint32_t waitSemaphoreInfoCount_ = {}, - const SemaphoreSubmitInfo * pWaitSemaphoreInfos_ = {}, - uint32_t commandBufferInfoCount_ = {}, - const CommandBufferSubmitInfo * pCommandBufferInfos_ = {}, - uint32_t signalSemaphoreInfoCount_ = {}, - const SemaphoreSubmitInfo * pSignalSemaphoreInfos_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , waitSemaphoreInfoCount{ waitSemaphoreInfoCount_ } - , pWaitSemaphoreInfos{ pWaitSemaphoreInfos_ } - , commandBufferInfoCount{ commandBufferInfoCount_ } - , pCommandBufferInfos{ pCommandBufferInfos_ } - , signalSemaphoreInfoCount{ signalSemaphoreInfoCount_ } - , pSignalSemaphoreInfos{ pSignalSemaphoreInfos_ } - { - } - - VULKAN_HPP_CONSTEXPR SubmitInfo2( SubmitInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubmitInfo2( VkSubmitInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT : SubmitInfo2( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubmitInfo2( SubmitFlags flags_, - ArrayProxyNoTemporaries const & waitSemaphoreInfos_, - ArrayProxyNoTemporaries const & commandBufferInfos_ = {}, - ArrayProxyNoTemporaries const & signalSemaphoreInfos_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , waitSemaphoreInfoCount( static_cast( waitSemaphoreInfos_.size() ) ) - , pWaitSemaphoreInfos( waitSemaphoreInfos_.data() ) - , commandBufferInfoCount( static_cast( commandBufferInfos_.size() ) ) - , pCommandBufferInfos( commandBufferInfos_.data() ) - , signalSemaphoreInfoCount( static_cast( signalSemaphoreInfos_.size() ) ) - , pSignalSemaphoreInfos( signalSemaphoreInfos_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SubmitInfo2 & operator=( SubmitInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubmitInfo2 & operator=( VkSubmitInfo2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setFlags( SubmitFlags flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setFlags( SubmitFlags flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setWaitSemaphoreInfoCount( uint32_t waitSemaphoreInfoCount_ ) & VULKAN_HPP_NOEXCEPT - { - waitSemaphoreInfoCount = waitSemaphoreInfoCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setWaitSemaphoreInfoCount( uint32_t waitSemaphoreInfoCount_ ) && VULKAN_HPP_NOEXCEPT - { - waitSemaphoreInfoCount = waitSemaphoreInfoCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setPWaitSemaphoreInfos( const SemaphoreSubmitInfo * pWaitSemaphoreInfos_ ) & VULKAN_HPP_NOEXCEPT - { - pWaitSemaphoreInfos = pWaitSemaphoreInfos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setPWaitSemaphoreInfos( const SemaphoreSubmitInfo * pWaitSemaphoreInfos_ ) && VULKAN_HPP_NOEXCEPT - { - pWaitSemaphoreInfos = pWaitSemaphoreInfos_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubmitInfo2 & setWaitSemaphoreInfos( ArrayProxyNoTemporaries const & waitSemaphoreInfos_ ) VULKAN_HPP_NOEXCEPT - { - waitSemaphoreInfoCount = static_cast( waitSemaphoreInfos_.size() ); - pWaitSemaphoreInfos = waitSemaphoreInfos_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setCommandBufferInfoCount( uint32_t commandBufferInfoCount_ ) & VULKAN_HPP_NOEXCEPT - { - commandBufferInfoCount = commandBufferInfoCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setCommandBufferInfoCount( uint32_t commandBufferInfoCount_ ) && VULKAN_HPP_NOEXCEPT - { - commandBufferInfoCount = commandBufferInfoCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setPCommandBufferInfos( const CommandBufferSubmitInfo * pCommandBufferInfos_ ) & VULKAN_HPP_NOEXCEPT - { - pCommandBufferInfos = pCommandBufferInfos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setPCommandBufferInfos( const CommandBufferSubmitInfo * pCommandBufferInfos_ ) && VULKAN_HPP_NOEXCEPT - { - pCommandBufferInfos = pCommandBufferInfos_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubmitInfo2 & setCommandBufferInfos( ArrayProxyNoTemporaries const & commandBufferInfos_ ) VULKAN_HPP_NOEXCEPT - { - commandBufferInfoCount = static_cast( commandBufferInfos_.size() ); - pCommandBufferInfos = commandBufferInfos_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setSignalSemaphoreInfoCount( uint32_t signalSemaphoreInfoCount_ ) & VULKAN_HPP_NOEXCEPT - { - signalSemaphoreInfoCount = signalSemaphoreInfoCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setSignalSemaphoreInfoCount( uint32_t signalSemaphoreInfoCount_ ) && VULKAN_HPP_NOEXCEPT - { - signalSemaphoreInfoCount = signalSemaphoreInfoCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 & setPSignalSemaphoreInfos( const SemaphoreSubmitInfo * pSignalSemaphoreInfos_ ) & VULKAN_HPP_NOEXCEPT - { - pSignalSemaphoreInfos = pSignalSemaphoreInfos_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubmitInfo2 && setPSignalSemaphoreInfos( const SemaphoreSubmitInfo * pSignalSemaphoreInfos_ ) && VULKAN_HPP_NOEXCEPT - { - pSignalSemaphoreInfos = pSignalSemaphoreInfos_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SubmitInfo2 & setSignalSemaphoreInfos( ArrayProxyNoTemporaries const & signalSemaphoreInfos_ ) VULKAN_HPP_NOEXCEPT - { - signalSemaphoreInfoCount = static_cast( signalSemaphoreInfos_.size() ); - pSignalSemaphoreInfos = signalSemaphoreInfos_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubmitInfo2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubmitInfo2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubmitInfo2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubmitInfo2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - waitSemaphoreInfoCount, - pWaitSemaphoreInfos, - commandBufferInfoCount, - pCommandBufferInfos, - signalSemaphoreInfoCount, - pSignalSemaphoreInfos ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubmitInfo2 const & ) const = default; -#else - bool operator==( SubmitInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( waitSemaphoreInfoCount == rhs.waitSemaphoreInfoCount ) && - ( pWaitSemaphoreInfos == rhs.pWaitSemaphoreInfos ) && ( commandBufferInfoCount == rhs.commandBufferInfoCount ) && - ( pCommandBufferInfos == rhs.pCommandBufferInfos ) && ( signalSemaphoreInfoCount == rhs.signalSemaphoreInfoCount ) && - ( pSignalSemaphoreInfos == rhs.pSignalSemaphoreInfos ); -# endif - } - - bool operator!=( SubmitInfo2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubmitInfo2; - const void * pNext = {}; - SubmitFlags flags = {}; - uint32_t waitSemaphoreInfoCount = {}; - const SemaphoreSubmitInfo * pWaitSemaphoreInfos = {}; - uint32_t commandBufferInfoCount = {}; - const CommandBufferSubmitInfo * pCommandBufferInfos = {}; - uint32_t signalSemaphoreInfoCount = {}; - const SemaphoreSubmitInfo * pSignalSemaphoreInfos = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubmitInfo2; - }; -#endif - - template <> - struct CppType - { - using Type = SubmitInfo2; - }; - - using SubmitInfo2KHR = SubmitInfo2; - - // wrapper struct for struct VkSubpassBeginInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassBeginInfo.html - struct SubpassBeginInfo - { - using NativeType = VkSubpassBeginInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassBeginInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubpassBeginInfo( SubpassContents contents_ = SubpassContents::eInline, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , contents{ contents_ } - { - } - - VULKAN_HPP_CONSTEXPR SubpassBeginInfo( SubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubpassBeginInfo( VkSubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassBeginInfo( *reinterpret_cast( &rhs ) ) {} - - SubpassBeginInfo & operator=( SubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubpassBeginInfo & operator=( VkSubpassBeginInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubpassBeginInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassBeginInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassBeginInfo & setContents( SubpassContents contents_ ) & VULKAN_HPP_NOEXCEPT - { - contents = contents_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassBeginInfo && setContents( SubpassContents contents_ ) && VULKAN_HPP_NOEXCEPT - { - contents = contents_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubpassBeginInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassBeginInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassBeginInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubpassBeginInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, contents ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubpassBeginInfo const & ) const = default; -#else - bool operator==( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( contents == rhs.contents ); -# endif - } - - bool operator!=( SubpassBeginInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubpassBeginInfo; - const void * pNext = {}; - SubpassContents contents = SubpassContents::eInline; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubpassBeginInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SubpassBeginInfo; - }; - - using SubpassBeginInfoKHR = SubpassBeginInfo; - - // wrapper struct for struct VkSubpassDescriptionDepthStencilResolve, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassDescriptionDepthStencilResolve.html - struct SubpassDescriptionDepthStencilResolve - { - using NativeType = VkSubpassDescriptionDepthStencilResolve; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassDescriptionDepthStencilResolve; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolve( ResolveModeFlagBits depthResolveMode_ = ResolveModeFlagBits::eNone, - ResolveModeFlagBits stencilResolveMode_ = ResolveModeFlagBits::eNone, - const AttachmentReference2 * pDepthStencilResolveAttachment_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , depthResolveMode{ depthResolveMode_ } - , stencilResolveMode{ stencilResolveMode_ } - , pDepthStencilResolveAttachment{ pDepthStencilResolveAttachment_ } - { - } - - VULKAN_HPP_CONSTEXPR SubpassDescriptionDepthStencilResolve( SubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubpassDescriptionDepthStencilResolve( VkSubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT - : SubpassDescriptionDepthStencilResolve( *reinterpret_cast( &rhs ) ) - { - } - - SubpassDescriptionDepthStencilResolve & operator=( SubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubpassDescriptionDepthStencilResolve & operator=( VkSubpassDescriptionDepthStencilResolve const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve & setDepthResolveMode( ResolveModeFlagBits depthResolveMode_ ) & VULKAN_HPP_NOEXCEPT - { - depthResolveMode = depthResolveMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve && setDepthResolveMode( ResolveModeFlagBits depthResolveMode_ ) && VULKAN_HPP_NOEXCEPT - { - depthResolveMode = depthResolveMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve & setStencilResolveMode( ResolveModeFlagBits stencilResolveMode_ ) & VULKAN_HPP_NOEXCEPT - { - stencilResolveMode = stencilResolveMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve && setStencilResolveMode( ResolveModeFlagBits stencilResolveMode_ ) && VULKAN_HPP_NOEXCEPT - { - stencilResolveMode = stencilResolveMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve & - setPDepthStencilResolveAttachment( const AttachmentReference2 * pDepthStencilResolveAttachment_ ) & - VULKAN_HPP_NOEXCEPT - { - pDepthStencilResolveAttachment = pDepthStencilResolveAttachment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassDescriptionDepthStencilResolve && - setPDepthStencilResolveAttachment( const AttachmentReference2 * pDepthStencilResolveAttachment_ ) && - VULKAN_HPP_NOEXCEPT - { - pDepthStencilResolveAttachment = pDepthStencilResolveAttachment_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubpassDescriptionDepthStencilResolve const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassDescriptionDepthStencilResolve &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassDescriptionDepthStencilResolve const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubpassDescriptionDepthStencilResolve *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, depthResolveMode, stencilResolveMode, pDepthStencilResolveAttachment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubpassDescriptionDepthStencilResolve const & ) const = default; -#else - bool operator==( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( depthResolveMode == rhs.depthResolveMode ) && - ( stencilResolveMode == rhs.stencilResolveMode ) && ( pDepthStencilResolveAttachment == rhs.pDepthStencilResolveAttachment ); -# endif - } - - bool operator!=( SubpassDescriptionDepthStencilResolve const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubpassDescriptionDepthStencilResolve; - const void * pNext = {}; - ResolveModeFlagBits depthResolveMode = ResolveModeFlagBits::eNone; - ResolveModeFlagBits stencilResolveMode = ResolveModeFlagBits::eNone; - const AttachmentReference2 * pDepthStencilResolveAttachment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubpassDescriptionDepthStencilResolve; - }; -#endif - - template <> - struct CppType - { - using Type = SubpassDescriptionDepthStencilResolve; - }; - - using SubpassDescriptionDepthStencilResolveKHR = SubpassDescriptionDepthStencilResolve; - - // wrapper struct for struct VkSubpassEndInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassEndInfo.html - struct SubpassEndInfo - { - using NativeType = VkSubpassEndInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassEndInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubpassEndInfo( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} - - VULKAN_HPP_CONSTEXPR SubpassEndInfo( SubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubpassEndInfo( VkSubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT : SubpassEndInfo( *reinterpret_cast( &rhs ) ) {} - - SubpassEndInfo & operator=( SubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubpassEndInfo & operator=( VkSubpassEndInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubpassEndInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassEndInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubpassEndInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassEndInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassEndInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubpassEndInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubpassEndInfo const & ) const = default; -#else - bool operator==( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); -# endif - } - - bool operator!=( SubpassEndInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubpassEndInfo; - const void * pNext = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubpassEndInfo; - }; -#endif - - template <> - struct CppType - { - using Type = SubpassEndInfo; - }; - - using SubpassEndInfoKHR = SubpassEndInfo; - - // wrapper struct for struct VkSubpassResolvePerformanceQueryEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassResolvePerformanceQueryEXT.html - struct SubpassResolvePerformanceQueryEXT - { - using NativeType = VkSubpassResolvePerformanceQueryEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassResolvePerformanceQueryEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubpassResolvePerformanceQueryEXT( Bool32 optimal_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , optimal{ optimal_ } - { - } - - VULKAN_HPP_CONSTEXPR SubpassResolvePerformanceQueryEXT( SubpassResolvePerformanceQueryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubpassResolvePerformanceQueryEXT( VkSubpassResolvePerformanceQueryEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SubpassResolvePerformanceQueryEXT( *reinterpret_cast( &rhs ) ) - { - } - - SubpassResolvePerformanceQueryEXT & operator=( SubpassResolvePerformanceQueryEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubpassResolvePerformanceQueryEXT & operator=( VkSubpassResolvePerformanceQueryEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSubpassResolvePerformanceQueryEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassResolvePerformanceQueryEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassResolvePerformanceQueryEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubpassResolvePerformanceQueryEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, optimal ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubpassResolvePerformanceQueryEXT const & ) const = default; -#else - bool operator==( SubpassResolvePerformanceQueryEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( optimal == rhs.optimal ); -# endif - } - - bool operator!=( SubpassResolvePerformanceQueryEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubpassResolvePerformanceQueryEXT; - void * pNext = {}; - Bool32 optimal = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubpassResolvePerformanceQueryEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SubpassResolvePerformanceQueryEXT; - }; - - // wrapper struct for struct VkSubpassShadingPipelineCreateInfoHUAWEI, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubpassShadingPipelineCreateInfoHUAWEI.html - struct SubpassShadingPipelineCreateInfoHUAWEI - { - using NativeType = VkSubpassShadingPipelineCreateInfoHUAWEI; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubpassShadingPipelineCreateInfoHUAWEI; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - SubpassShadingPipelineCreateInfoHUAWEI( RenderPass renderPass_ = {}, uint32_t subpass_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , renderPass{ renderPass_ } - , subpass{ subpass_ } - { - } - - VULKAN_HPP_CONSTEXPR SubpassShadingPipelineCreateInfoHUAWEI( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubpassShadingPipelineCreateInfoHUAWEI( VkSubpassShadingPipelineCreateInfoHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - : SubpassShadingPipelineCreateInfoHUAWEI( *reinterpret_cast( &rhs ) ) - { - } - - SubpassShadingPipelineCreateInfoHUAWEI & operator=( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubpassShadingPipelineCreateInfoHUAWEI & operator=( VkSubpassShadingPipelineCreateInfoHUAWEI const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI & setRenderPass( RenderPass renderPass_ ) & VULKAN_HPP_NOEXCEPT - { - renderPass = renderPass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI && setRenderPass( RenderPass renderPass_ ) && VULKAN_HPP_NOEXCEPT - { - renderPass = renderPass_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI & setSubpass( uint32_t subpass_ ) & VULKAN_HPP_NOEXCEPT - { - subpass = subpass_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubpassShadingPipelineCreateInfoHUAWEI && setSubpass( uint32_t subpass_ ) && VULKAN_HPP_NOEXCEPT - { - subpass = subpass_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubpassShadingPipelineCreateInfoHUAWEI const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassShadingPipelineCreateInfoHUAWEI &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubpassShadingPipelineCreateInfoHUAWEI const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubpassShadingPipelineCreateInfoHUAWEI *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, renderPass, subpass ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubpassShadingPipelineCreateInfoHUAWEI const & ) const = default; -#else - bool operator==( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( renderPass == rhs.renderPass ) && ( subpass == rhs.subpass ); -# endif - } - - bool operator!=( SubpassShadingPipelineCreateInfoHUAWEI const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubpassShadingPipelineCreateInfoHUAWEI; - void * pNext = {}; - RenderPass renderPass = {}; - uint32_t subpass = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubpassShadingPipelineCreateInfoHUAWEI; - }; -#endif - - template <> - struct CppType - { - using Type = SubpassShadingPipelineCreateInfoHUAWEI; - }; - - // wrapper struct for struct VkSubresourceHostMemcpySize, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubresourceHostMemcpySize.html - struct SubresourceHostMemcpySize - { - using NativeType = VkSubresourceHostMemcpySize; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubresourceHostMemcpySize; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubresourceHostMemcpySize( DeviceSize size_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR SubresourceHostMemcpySize( SubresourceHostMemcpySize const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubresourceHostMemcpySize( VkSubresourceHostMemcpySize const & rhs ) VULKAN_HPP_NOEXCEPT - : SubresourceHostMemcpySize( *reinterpret_cast( &rhs ) ) - { - } - - SubresourceHostMemcpySize & operator=( SubresourceHostMemcpySize const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubresourceHostMemcpySize & operator=( VkSubresourceHostMemcpySize const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSubresourceHostMemcpySize const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubresourceHostMemcpySize &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubresourceHostMemcpySize const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubresourceHostMemcpySize *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubresourceHostMemcpySize const & ) const = default; -#else - bool operator==( SubresourceHostMemcpySize const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( size == rhs.size ); -# endif - } - - bool operator!=( SubresourceHostMemcpySize const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubresourceHostMemcpySize; - void * pNext = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubresourceHostMemcpySize; - }; -#endif - - template <> - struct CppType - { - using Type = SubresourceHostMemcpySize; - }; - - using SubresourceHostMemcpySizeEXT = SubresourceHostMemcpySize; - - // wrapper struct for struct VkSubresourceLayout2, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubresourceLayout2.html - struct SubresourceLayout2 - { - using NativeType = VkSubresourceLayout2; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubresourceLayout2; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubresourceLayout2( SubresourceLayout subresourceLayout_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , subresourceLayout{ subresourceLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR SubresourceLayout2( SubresourceLayout2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubresourceLayout2( VkSubresourceLayout2 const & rhs ) VULKAN_HPP_NOEXCEPT : SubresourceLayout2( *reinterpret_cast( &rhs ) ) {} - - SubresourceLayout2 & operator=( SubresourceLayout2 const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubresourceLayout2 & operator=( VkSubresourceLayout2 const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSubresourceLayout2 const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubresourceLayout2 &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubresourceLayout2 const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubresourceLayout2 *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, subresourceLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubresourceLayout2 const & ) const = default; -#else - bool operator==( SubresourceLayout2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subresourceLayout == rhs.subresourceLayout ); -# endif - } - - bool operator!=( SubresourceLayout2 const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubresourceLayout2; - void * pNext = {}; - SubresourceLayout subresourceLayout = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubresourceLayout2; - }; -#endif - - template <> - struct CppType - { - using Type = SubresourceLayout2; - }; - - using SubresourceLayout2EXT = SubresourceLayout2; - using SubresourceLayout2KHR = SubresourceLayout2; - - // wrapper struct for struct VkSubsampledImageFormatPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubsampledImageFormatPropertiesEXT.html - struct SubsampledImageFormatPropertiesEXT - { - using NativeType = VkSubsampledImageFormatPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSubsampledImageFormatPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SubsampledImageFormatPropertiesEXT( uint32_t subsampledImageDescriptorCount_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , subsampledImageDescriptorCount{ subsampledImageDescriptorCount_ } - { - } - - VULKAN_HPP_CONSTEXPR SubsampledImageFormatPropertiesEXT( SubsampledImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SubsampledImageFormatPropertiesEXT( VkSubsampledImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SubsampledImageFormatPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - SubsampledImageFormatPropertiesEXT & operator=( SubsampledImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SubsampledImageFormatPropertiesEXT & operator=( VkSubsampledImageFormatPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SubsampledImageFormatPropertiesEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubsampledImageFormatPropertiesEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SubsampledImageFormatPropertiesEXT & setSubsampledImageDescriptorCount( uint32_t subsampledImageDescriptorCount_ ) & - VULKAN_HPP_NOEXCEPT - { - subsampledImageDescriptorCount = subsampledImageDescriptorCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SubsampledImageFormatPropertiesEXT && setSubsampledImageDescriptorCount( uint32_t subsampledImageDescriptorCount_ ) && - VULKAN_HPP_NOEXCEPT - { - subsampledImageDescriptorCount = subsampledImageDescriptorCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSubsampledImageFormatPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubsampledImageFormatPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSubsampledImageFormatPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSubsampledImageFormatPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, subsampledImageDescriptorCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SubsampledImageFormatPropertiesEXT const & ) const = default; -#else - bool operator==( SubsampledImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( subsampledImageDescriptorCount == rhs.subsampledImageDescriptorCount ); -# endif - } - - bool operator!=( SubsampledImageFormatPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSubsampledImageFormatPropertiesEXT; - const void * pNext = {}; - uint32_t subsampledImageDescriptorCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SubsampledImageFormatPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SubsampledImageFormatPropertiesEXT; - }; - - // wrapper struct for struct VkSurfaceCapabilities2EXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilities2EXT.html - struct SurfaceCapabilities2EXT - { - using NativeType = VkSurfaceCapabilities2EXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilities2EXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceCapabilities2EXT( uint32_t minImageCount_ = {}, - uint32_t maxImageCount_ = {}, - Extent2D currentExtent_ = {}, - Extent2D minImageExtent_ = {}, - Extent2D maxImageExtent_ = {}, - uint32_t maxImageArrayLayers_ = {}, - SurfaceTransformFlagsKHR supportedTransforms_ = {}, - SurfaceTransformFlagBitsKHR currentTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, - CompositeAlphaFlagsKHR supportedCompositeAlpha_ = {}, - ImageUsageFlags supportedUsageFlags_ = {}, - SurfaceCounterFlagsEXT supportedSurfaceCounters_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minImageCount{ minImageCount_ } - , maxImageCount{ maxImageCount_ } - , currentExtent{ currentExtent_ } - , minImageExtent{ minImageExtent_ } - , maxImageExtent{ maxImageExtent_ } - , maxImageArrayLayers{ maxImageArrayLayers_ } - , supportedTransforms{ supportedTransforms_ } - , currentTransform{ currentTransform_ } - , supportedCompositeAlpha{ supportedCompositeAlpha_ } - , supportedUsageFlags{ supportedUsageFlags_ } - , supportedSurfaceCounters{ supportedSurfaceCounters_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceCapabilities2EXT( SurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceCapabilities2EXT( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfaceCapabilities2EXT( *reinterpret_cast( &rhs ) ) - { - } - - SurfaceCapabilities2EXT & operator=( SurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceCapabilities2EXT & operator=( VkSurfaceCapabilities2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSurfaceCapabilities2EXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilities2EXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilities2EXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceCapabilities2EXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - minImageCount, - maxImageCount, - currentExtent, - minImageExtent, - maxImageExtent, - maxImageArrayLayers, - supportedTransforms, - currentTransform, - supportedCompositeAlpha, - supportedUsageFlags, - supportedSurfaceCounters ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceCapabilities2EXT const & ) const = default; -#else - bool operator==( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minImageCount == rhs.minImageCount ) && ( maxImageCount == rhs.maxImageCount ) && - ( currentExtent == rhs.currentExtent ) && ( minImageExtent == rhs.minImageExtent ) && ( maxImageExtent == rhs.maxImageExtent ) && - ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && ( supportedTransforms == rhs.supportedTransforms ) && - ( currentTransform == rhs.currentTransform ) && ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) && - ( supportedUsageFlags == rhs.supportedUsageFlags ) && ( supportedSurfaceCounters == rhs.supportedSurfaceCounters ); -# endif - } - - bool operator!=( SurfaceCapabilities2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSurfaceCapabilities2EXT; - void * pNext = {}; - uint32_t minImageCount = {}; - uint32_t maxImageCount = {}; - Extent2D currentExtent = {}; - Extent2D minImageExtent = {}; - Extent2D maxImageExtent = {}; - uint32_t maxImageArrayLayers = {}; - SurfaceTransformFlagsKHR supportedTransforms = {}; - SurfaceTransformFlagBitsKHR currentTransform = SurfaceTransformFlagBitsKHR::eIdentity; - CompositeAlphaFlagsKHR supportedCompositeAlpha = {}; - ImageUsageFlags supportedUsageFlags = {}; - SurfaceCounterFlagsEXT supportedSurfaceCounters = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceCapabilities2EXT; - }; -#endif - - template <> - struct CppType - { - using Type = SurfaceCapabilities2EXT; - }; - - // wrapper struct for struct VkSurfaceCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesKHR.html - struct SurfaceCapabilitiesKHR - { - using NativeType = VkSurfaceCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesKHR( uint32_t minImageCount_ = {}, - uint32_t maxImageCount_ = {}, - Extent2D currentExtent_ = {}, - Extent2D minImageExtent_ = {}, - Extent2D maxImageExtent_ = {}, - uint32_t maxImageArrayLayers_ = {}, - SurfaceTransformFlagsKHR supportedTransforms_ = {}, - SurfaceTransformFlagBitsKHR currentTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, - CompositeAlphaFlagsKHR supportedCompositeAlpha_ = {}, - ImageUsageFlags supportedUsageFlags_ = {} ) VULKAN_HPP_NOEXCEPT - : minImageCount{ minImageCount_ } - , maxImageCount{ maxImageCount_ } - , currentExtent{ currentExtent_ } - , minImageExtent{ minImageExtent_ } - , maxImageExtent{ maxImageExtent_ } - , maxImageArrayLayers{ maxImageArrayLayers_ } - , supportedTransforms{ supportedTransforms_ } - , currentTransform{ currentTransform_ } - , supportedCompositeAlpha{ supportedCompositeAlpha_ } - , supportedUsageFlags{ supportedUsageFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesKHR( SurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceCapabilitiesKHR( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfaceCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - SurfaceCapabilitiesKHR & operator=( SurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceCapabilitiesKHR & operator=( VkSurfaceCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSurfaceCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( minImageCount, - maxImageCount, - currentExtent, - minImageExtent, - maxImageExtent, - maxImageArrayLayers, - supportedTransforms, - currentTransform, - supportedCompositeAlpha, - supportedUsageFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceCapabilitiesKHR const & ) const = default; -#else - bool operator==( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( minImageCount == rhs.minImageCount ) && ( maxImageCount == rhs.maxImageCount ) && ( currentExtent == rhs.currentExtent ) && - ( minImageExtent == rhs.minImageExtent ) && ( maxImageExtent == rhs.maxImageExtent ) && ( maxImageArrayLayers == rhs.maxImageArrayLayers ) && - ( supportedTransforms == rhs.supportedTransforms ) && ( currentTransform == rhs.currentTransform ) && - ( supportedCompositeAlpha == rhs.supportedCompositeAlpha ) && ( supportedUsageFlags == rhs.supportedUsageFlags ); -# endif - } - - bool operator!=( SurfaceCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t minImageCount = {}; - uint32_t maxImageCount = {}; - Extent2D currentExtent = {}; - Extent2D minImageExtent = {}; - Extent2D maxImageExtent = {}; - uint32_t maxImageArrayLayers = {}; - SurfaceTransformFlagsKHR supportedTransforms = {}; - SurfaceTransformFlagBitsKHR currentTransform = SurfaceTransformFlagBitsKHR::eIdentity; - CompositeAlphaFlagsKHR supportedCompositeAlpha = {}; - ImageUsageFlags supportedUsageFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceCapabilitiesKHR; - }; -#endif - - // wrapper struct for struct VkSurfaceCapabilities2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilities2KHR.html - struct SurfaceCapabilities2KHR - { - using NativeType = VkSurfaceCapabilities2KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilities2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceCapabilities2KHR( SurfaceCapabilitiesKHR surfaceCapabilities_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , surfaceCapabilities{ surfaceCapabilities_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceCapabilities2KHR( SurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceCapabilities2KHR( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfaceCapabilities2KHR( *reinterpret_cast( &rhs ) ) - { - } - - SurfaceCapabilities2KHR & operator=( SurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceCapabilities2KHR & operator=( VkSurfaceCapabilities2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSurfaceCapabilities2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilities2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilities2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceCapabilities2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, surfaceCapabilities ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceCapabilities2KHR const & ) const = default; -#else - bool operator==( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCapabilities == rhs.surfaceCapabilities ); -# endif - } - - bool operator!=( SurfaceCapabilities2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSurfaceCapabilities2KHR; - void * pNext = {}; - SurfaceCapabilitiesKHR surfaceCapabilities = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceCapabilities2KHR; - }; -#endif - - template <> - struct CppType - { - using Type = SurfaceCapabilities2KHR; - }; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkSurfaceCapabilitiesFullScreenExclusiveEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesFullScreenExclusiveEXT.html - struct SurfaceCapabilitiesFullScreenExclusiveEXT - { - using NativeType = VkSurfaceCapabilitiesFullScreenExclusiveEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( Bool32 fullScreenExclusiveSupported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fullScreenExclusiveSupported{ fullScreenExclusiveSupported_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesFullScreenExclusiveEXT( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceCapabilitiesFullScreenExclusiveEXT( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfaceCapabilitiesFullScreenExclusiveEXT( *reinterpret_cast( &rhs ) ) - { - } - - SurfaceCapabilitiesFullScreenExclusiveEXT & operator=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceCapabilitiesFullScreenExclusiveEXT & operator=( VkSurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesFullScreenExclusiveEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesFullScreenExclusiveEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesFullScreenExclusiveEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fullScreenExclusiveSupported ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceCapabilitiesFullScreenExclusiveEXT const & ) const = default; -# else - bool operator==( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusiveSupported == rhs.fullScreenExclusiveSupported ); -# endif - } - - bool operator!=( SurfaceCapabilitiesFullScreenExclusiveEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT; - void * pNext = {}; - Bool32 fullScreenExclusiveSupported = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceCapabilitiesFullScreenExclusiveEXT; - }; -# endif - - template <> - struct CppType - { - using Type = SurfaceCapabilitiesFullScreenExclusiveEXT; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - // wrapper struct for struct VkSurfaceCapabilitiesPresentBarrierNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesPresentBarrierNV.html - struct SurfaceCapabilitiesPresentBarrierNV - { - using NativeType = VkSurfaceCapabilitiesPresentBarrierNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilitiesPresentBarrierNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentBarrierNV( Bool32 presentBarrierSupported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentBarrierSupported{ presentBarrierSupported_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentBarrierNV( SurfaceCapabilitiesPresentBarrierNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceCapabilitiesPresentBarrierNV( VkSurfaceCapabilitiesPresentBarrierNV const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfaceCapabilitiesPresentBarrierNV( *reinterpret_cast( &rhs ) ) - { - } - - SurfaceCapabilitiesPresentBarrierNV & operator=( SurfaceCapabilitiesPresentBarrierNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceCapabilitiesPresentBarrierNV & operator=( VkSurfaceCapabilitiesPresentBarrierNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSurfaceCapabilitiesPresentBarrierNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesPresentBarrierNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesPresentBarrierNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesPresentBarrierNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentBarrierSupported ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceCapabilitiesPresentBarrierNV const & ) const = default; -#else - bool operator==( SurfaceCapabilitiesPresentBarrierNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentBarrierSupported == rhs.presentBarrierSupported ); -# endif - } - - bool operator!=( SurfaceCapabilitiesPresentBarrierNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSurfaceCapabilitiesPresentBarrierNV; - void * pNext = {}; - Bool32 presentBarrierSupported = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceCapabilitiesPresentBarrierNV; - }; -#endif - - template <> - struct CppType - { - using Type = SurfaceCapabilitiesPresentBarrierNV; - }; - - // wrapper struct for struct VkSurfaceCapabilitiesPresentId2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesPresentId2KHR.html - struct SurfaceCapabilitiesPresentId2KHR - { - using NativeType = VkSurfaceCapabilitiesPresentId2KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilitiesPresentId2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentId2KHR( Bool32 presentId2Supported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentId2Supported{ presentId2Supported_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentId2KHR( SurfaceCapabilitiesPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceCapabilitiesPresentId2KHR( VkSurfaceCapabilitiesPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfaceCapabilitiesPresentId2KHR( *reinterpret_cast( &rhs ) ) - { - } - - SurfaceCapabilitiesPresentId2KHR & operator=( SurfaceCapabilitiesPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceCapabilitiesPresentId2KHR & operator=( VkSurfaceCapabilitiesPresentId2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentId2KHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentId2KHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentId2KHR & setPresentId2Supported( Bool32 presentId2Supported_ ) & VULKAN_HPP_NOEXCEPT - { - presentId2Supported = presentId2Supported_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentId2KHR && setPresentId2Supported( Bool32 presentId2Supported_ ) && VULKAN_HPP_NOEXCEPT - { - presentId2Supported = presentId2Supported_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSurfaceCapabilitiesPresentId2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesPresentId2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesPresentId2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesPresentId2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentId2Supported ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceCapabilitiesPresentId2KHR const & ) const = default; -#else - bool operator==( SurfaceCapabilitiesPresentId2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentId2Supported == rhs.presentId2Supported ); -# endif - } - - bool operator!=( SurfaceCapabilitiesPresentId2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSurfaceCapabilitiesPresentId2KHR; - void * pNext = {}; - Bool32 presentId2Supported = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceCapabilitiesPresentId2KHR; - }; -#endif - - template <> - struct CppType - { - using Type = SurfaceCapabilitiesPresentId2KHR; - }; - - // wrapper struct for struct VkSurfaceCapabilitiesPresentWait2KHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCapabilitiesPresentWait2KHR.html - struct SurfaceCapabilitiesPresentWait2KHR - { - using NativeType = VkSurfaceCapabilitiesPresentWait2KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCapabilitiesPresentWait2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentWait2KHR( Bool32 presentWait2Supported_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentWait2Supported{ presentWait2Supported_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceCapabilitiesPresentWait2KHR( SurfaceCapabilitiesPresentWait2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceCapabilitiesPresentWait2KHR( VkSurfaceCapabilitiesPresentWait2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfaceCapabilitiesPresentWait2KHR( *reinterpret_cast( &rhs ) ) - { - } - - SurfaceCapabilitiesPresentWait2KHR & operator=( SurfaceCapabilitiesPresentWait2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceCapabilitiesPresentWait2KHR & operator=( VkSurfaceCapabilitiesPresentWait2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentWait2KHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentWait2KHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentWait2KHR & setPresentWait2Supported( Bool32 presentWait2Supported_ ) & VULKAN_HPP_NOEXCEPT - { - presentWait2Supported = presentWait2Supported_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceCapabilitiesPresentWait2KHR && setPresentWait2Supported( Bool32 presentWait2Supported_ ) && VULKAN_HPP_NOEXCEPT - { - presentWait2Supported = presentWait2Supported_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSurfaceCapabilitiesPresentWait2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesPresentWait2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesPresentWait2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceCapabilitiesPresentWait2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentWait2Supported ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceCapabilitiesPresentWait2KHR const & ) const = default; -#else - bool operator==( SurfaceCapabilitiesPresentWait2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentWait2Supported == rhs.presentWait2Supported ); -# endif - } - - bool operator!=( SurfaceCapabilitiesPresentWait2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSurfaceCapabilitiesPresentWait2KHR; - void * pNext = {}; - Bool32 presentWait2Supported = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceCapabilitiesPresentWait2KHR; - }; -#endif - - template <> - struct CppType - { - using Type = SurfaceCapabilitiesPresentWait2KHR; - }; - -#if defined( VK_USE_PLATFORM_OHOS ) - // wrapper struct for struct VkSurfaceCreateInfoOHOS, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceCreateInfoOHOS.html - struct SurfaceCreateInfoOHOS - { - using NativeType = VkSurfaceCreateInfoOHOS; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceCreateInfoOHOS; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - SurfaceCreateInfoOHOS( SurfaceCreateFlagsOHOS flags_ = {}, OHNativeWindow * window_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , window{ window_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceCreateInfoOHOS( SurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceCreateInfoOHOS( VkSurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfaceCreateInfoOHOS( *reinterpret_cast( &rhs ) ) - { - } - - SurfaceCreateInfoOHOS & operator=( SurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceCreateInfoOHOS & operator=( VkSurfaceCreateInfoOHOS const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS & setFlags( SurfaceCreateFlagsOHOS flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS && setFlags( SurfaceCreateFlagsOHOS flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS & setWindow( OHNativeWindow * window_ ) & VULKAN_HPP_NOEXCEPT - { - window = window_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceCreateInfoOHOS && setWindow( OHNativeWindow * window_ ) && VULKAN_HPP_NOEXCEPT - { - window = window_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSurfaceCreateInfoOHOS const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCreateInfoOHOS &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceCreateInfoOHOS const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceCreateInfoOHOS *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, window ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceCreateInfoOHOS const & ) const = default; -# else - bool operator==( SurfaceCreateInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); -# endif - } - - bool operator!=( SurfaceCreateInfoOHOS const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eSurfaceCreateInfoOHOS; - const void * pNext = {}; - SurfaceCreateFlagsOHOS flags = {}; - OHNativeWindow * window = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceCreateInfoOHOS; - }; -# endif - - template <> - struct CppType - { - using Type = SurfaceCreateInfoOHOS; - }; -#endif /*VK_USE_PLATFORM_OHOS*/ - - // wrapper struct for struct VkSurfaceFormatKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceFormatKHR.html - struct SurfaceFormatKHR - { - using NativeType = VkSurfaceFormatKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceFormatKHR( Format format_ = Format::eUndefined, ColorSpaceKHR colorSpace_ = ColorSpaceKHR::eSrgbNonlinear ) VULKAN_HPP_NOEXCEPT - : format{ format_ } - , colorSpace{ colorSpace_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceFormatKHR( SurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceFormatKHR( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT : SurfaceFormatKHR( *reinterpret_cast( &rhs ) ) {} - - SurfaceFormatKHR & operator=( SurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceFormatKHR & operator=( VkSurfaceFormatKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSurfaceFormatKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceFormatKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceFormatKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceFormatKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( format, colorSpace ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceFormatKHR const & ) const = default; -#else - bool operator==( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( format == rhs.format ) && ( colorSpace == rhs.colorSpace ); -# endif - } - - bool operator!=( SurfaceFormatKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - Format format = Format::eUndefined; - ColorSpaceKHR colorSpace = ColorSpaceKHR::eSrgbNonlinear; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceFormatKHR; - }; -#endif - - // wrapper struct for struct VkSurfaceFormat2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceFormat2KHR.html - struct SurfaceFormat2KHR - { - using NativeType = VkSurfaceFormat2KHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFormat2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceFormat2KHR( SurfaceFormatKHR surfaceFormat_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , surfaceFormat{ surfaceFormat_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceFormat2KHR( SurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceFormat2KHR( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT : SurfaceFormat2KHR( *reinterpret_cast( &rhs ) ) {} - - SurfaceFormat2KHR & operator=( SurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceFormat2KHR & operator=( VkSurfaceFormat2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSurfaceFormat2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceFormat2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceFormat2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceFormat2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, surfaceFormat ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceFormat2KHR const & ) const = default; -#else - bool operator==( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceFormat == rhs.surfaceFormat ); -# endif - } - - bool operator!=( SurfaceFormat2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSurfaceFormat2KHR; - void * pNext = {}; - SurfaceFormatKHR surfaceFormat = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceFormat2KHR; - }; -#endif - - template <> - struct CppType - { - using Type = SurfaceFormat2KHR; - }; - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkSurfaceFullScreenExclusiveInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceFullScreenExclusiveInfoEXT.html - struct SurfaceFullScreenExclusiveInfoEXT - { - using NativeType = VkSurfaceFullScreenExclusiveInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( FullScreenExclusiveEXT fullScreenExclusive_ = FullScreenExclusiveEXT::eDefault, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , fullScreenExclusive{ fullScreenExclusive_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveInfoEXT( SurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceFullScreenExclusiveInfoEXT( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfaceFullScreenExclusiveInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - SurfaceFullScreenExclusiveInfoEXT & operator=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceFullScreenExclusiveInfoEXT & operator=( VkSurfaceFullScreenExclusiveInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveInfoEXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveInfoEXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveInfoEXT & setFullScreenExclusive( FullScreenExclusiveEXT fullScreenExclusive_ ) & VULKAN_HPP_NOEXCEPT - { - fullScreenExclusive = fullScreenExclusive_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveInfoEXT && setFullScreenExclusive( FullScreenExclusiveEXT fullScreenExclusive_ ) && VULKAN_HPP_NOEXCEPT - { - fullScreenExclusive = fullScreenExclusive_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSurfaceFullScreenExclusiveInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceFullScreenExclusiveInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceFullScreenExclusiveInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceFullScreenExclusiveInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, fullScreenExclusive ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceFullScreenExclusiveInfoEXT const & ) const = default; -# else - bool operator==( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( fullScreenExclusive == rhs.fullScreenExclusive ); -# endif - } - - bool operator!=( SurfaceFullScreenExclusiveInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eSurfaceFullScreenExclusiveInfoEXT; - void * pNext = {}; - FullScreenExclusiveEXT fullScreenExclusive = FullScreenExclusiveEXT::eDefault; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceFullScreenExclusiveInfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = SurfaceFullScreenExclusiveInfoEXT; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkSurfaceFullScreenExclusiveWin32InfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceFullScreenExclusiveWin32InfoEXT.html - struct SurfaceFullScreenExclusiveWin32InfoEXT - { - using NativeType = VkSurfaceFullScreenExclusiveWin32InfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( HMONITOR hmonitor_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , hmonitor{ hmonitor_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceFullScreenExclusiveWin32InfoEXT( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceFullScreenExclusiveWin32InfoEXT( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfaceFullScreenExclusiveWin32InfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - SurfaceFullScreenExclusiveWin32InfoEXT & operator=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceFullScreenExclusiveWin32InfoEXT & operator=( VkSurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveWin32InfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveWin32InfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveWin32InfoEXT & setHmonitor( HMONITOR hmonitor_ ) & VULKAN_HPP_NOEXCEPT - { - hmonitor = hmonitor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfaceFullScreenExclusiveWin32InfoEXT && setHmonitor( HMONITOR hmonitor_ ) && VULKAN_HPP_NOEXCEPT - { - hmonitor = hmonitor_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSurfaceFullScreenExclusiveWin32InfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceFullScreenExclusiveWin32InfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceFullScreenExclusiveWin32InfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceFullScreenExclusiveWin32InfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, hmonitor ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceFullScreenExclusiveWin32InfoEXT const & ) const = default; -# else - bool operator==( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hmonitor == rhs.hmonitor ); -# endif - } - - bool operator!=( SurfaceFullScreenExclusiveWin32InfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT; - const void * pNext = {}; - HMONITOR hmonitor = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceFullScreenExclusiveWin32InfoEXT; - }; -# endif - - template <> - struct CppType - { - using Type = SurfaceFullScreenExclusiveWin32InfoEXT; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - // wrapper struct for struct VkSurfacePresentModeCompatibilityKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfacePresentModeCompatibilityKHR.html - struct SurfacePresentModeCompatibilityKHR - { - using NativeType = VkSurfacePresentModeCompatibilityKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfacePresentModeCompatibilityKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - SurfacePresentModeCompatibilityKHR( uint32_t presentModeCount_ = {}, PresentModeKHR * pPresentModes_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentModeCount{ presentModeCount_ } - , pPresentModes{ pPresentModes_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfacePresentModeCompatibilityKHR( SurfacePresentModeCompatibilityKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfacePresentModeCompatibilityKHR( VkSurfacePresentModeCompatibilityKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfacePresentModeCompatibilityKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SurfacePresentModeCompatibilityKHR( ArrayProxyNoTemporaries const & presentModes_, void * pNext_ = nullptr ) - : pNext( pNext_ ), presentModeCount( static_cast( presentModes_.size() ) ), pPresentModes( presentModes_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SurfacePresentModeCompatibilityKHR & operator=( SurfacePresentModeCompatibilityKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfacePresentModeCompatibilityKHR & operator=( VkSurfacePresentModeCompatibilityKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR & setPresentModeCount( uint32_t presentModeCount_ ) & VULKAN_HPP_NOEXCEPT - { - presentModeCount = presentModeCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR && setPresentModeCount( uint32_t presentModeCount_ ) && VULKAN_HPP_NOEXCEPT - { - presentModeCount = presentModeCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR & setPPresentModes( PresentModeKHR * pPresentModes_ ) & VULKAN_HPP_NOEXCEPT - { - pPresentModes = pPresentModes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeCompatibilityKHR && setPPresentModes( PresentModeKHR * pPresentModes_ ) && VULKAN_HPP_NOEXCEPT - { - pPresentModes = pPresentModes_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SurfacePresentModeCompatibilityKHR & setPresentModes( ArrayProxyNoTemporaries const & presentModes_ ) VULKAN_HPP_NOEXCEPT - { - presentModeCount = static_cast( presentModes_.size() ); - pPresentModes = presentModes_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSurfacePresentModeCompatibilityKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfacePresentModeCompatibilityKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfacePresentModeCompatibilityKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfacePresentModeCompatibilityKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentModeCount, pPresentModes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfacePresentModeCompatibilityKHR const & ) const = default; -#else - bool operator==( SurfacePresentModeCompatibilityKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeCount == rhs.presentModeCount ) && ( pPresentModes == rhs.pPresentModes ); -# endif - } - - bool operator!=( SurfacePresentModeCompatibilityKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSurfacePresentModeCompatibilityKHR; - void * pNext = {}; - uint32_t presentModeCount = {}; - PresentModeKHR * pPresentModes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfacePresentModeCompatibilityKHR; - }; -#endif - - template <> - struct CppType - { - using Type = SurfacePresentModeCompatibilityKHR; - }; - - using SurfacePresentModeCompatibilityEXT = SurfacePresentModeCompatibilityKHR; - - // wrapper struct for struct VkSurfacePresentModeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfacePresentModeKHR.html - struct SurfacePresentModeKHR - { - using NativeType = VkSurfacePresentModeKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfacePresentModeKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfacePresentModeKHR( PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentMode{ presentMode_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfacePresentModeKHR( SurfacePresentModeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfacePresentModeKHR( VkSurfacePresentModeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfacePresentModeKHR( *reinterpret_cast( &rhs ) ) - { - } - - SurfacePresentModeKHR & operator=( SurfacePresentModeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfacePresentModeKHR & operator=( VkSurfacePresentModeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeKHR & setPresentMode( PresentModeKHR presentMode_ ) & VULKAN_HPP_NOEXCEPT - { - presentMode = presentMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentModeKHR && setPresentMode( PresentModeKHR presentMode_ ) && VULKAN_HPP_NOEXCEPT - { - presentMode = presentMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSurfacePresentModeKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfacePresentModeKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfacePresentModeKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfacePresentModeKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentMode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfacePresentModeKHR const & ) const = default; -#else - bool operator==( SurfacePresentModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentMode == rhs.presentMode ); -# endif - } - - bool operator!=( SurfacePresentModeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSurfacePresentModeKHR; - void * pNext = {}; - PresentModeKHR presentMode = PresentModeKHR::eImmediate; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfacePresentModeKHR; - }; -#endif - - template <> - struct CppType - { - using Type = SurfacePresentModeKHR; - }; - - using SurfacePresentModeEXT = SurfacePresentModeKHR; - - // wrapper struct for struct VkSurfacePresentScalingCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfacePresentScalingCapabilitiesKHR.html - struct SurfacePresentScalingCapabilitiesKHR - { - using NativeType = VkSurfacePresentScalingCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfacePresentScalingCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfacePresentScalingCapabilitiesKHR( PresentScalingFlagsKHR supportedPresentScaling_ = {}, - PresentGravityFlagsKHR supportedPresentGravityX_ = {}, - PresentGravityFlagsKHR supportedPresentGravityY_ = {}, - Extent2D minScaledImageExtent_ = {}, - Extent2D maxScaledImageExtent_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , supportedPresentScaling{ supportedPresentScaling_ } - , supportedPresentGravityX{ supportedPresentGravityX_ } - , supportedPresentGravityY{ supportedPresentGravityY_ } - , minScaledImageExtent{ minScaledImageExtent_ } - , maxScaledImageExtent{ maxScaledImageExtent_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfacePresentScalingCapabilitiesKHR( SurfacePresentScalingCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfacePresentScalingCapabilitiesKHR( VkSurfacePresentScalingCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfacePresentScalingCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - SurfacePresentScalingCapabilitiesKHR & operator=( SurfacePresentScalingCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfacePresentScalingCapabilitiesKHR & operator=( VkSurfacePresentScalingCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setSupportedPresentScaling( PresentScalingFlagsKHR supportedPresentScaling_ ) & - VULKAN_HPP_NOEXCEPT - { - supportedPresentScaling = supportedPresentScaling_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setSupportedPresentScaling( PresentScalingFlagsKHR supportedPresentScaling_ ) && - VULKAN_HPP_NOEXCEPT - { - supportedPresentScaling = supportedPresentScaling_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setSupportedPresentGravityX( PresentGravityFlagsKHR supportedPresentGravityX_ ) & - VULKAN_HPP_NOEXCEPT - { - supportedPresentGravityX = supportedPresentGravityX_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setSupportedPresentGravityX( PresentGravityFlagsKHR supportedPresentGravityX_ ) && - VULKAN_HPP_NOEXCEPT - { - supportedPresentGravityX = supportedPresentGravityX_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setSupportedPresentGravityY( PresentGravityFlagsKHR supportedPresentGravityY_ ) & - VULKAN_HPP_NOEXCEPT - { - supportedPresentGravityY = supportedPresentGravityY_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setSupportedPresentGravityY( PresentGravityFlagsKHR supportedPresentGravityY_ ) && - VULKAN_HPP_NOEXCEPT - { - supportedPresentGravityY = supportedPresentGravityY_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setMinScaledImageExtent( Extent2D const & minScaledImageExtent_ ) & VULKAN_HPP_NOEXCEPT - { - minScaledImageExtent = minScaledImageExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setMinScaledImageExtent( Extent2D const & minScaledImageExtent_ ) && VULKAN_HPP_NOEXCEPT - { - minScaledImageExtent = minScaledImageExtent_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR & setMaxScaledImageExtent( Extent2D const & maxScaledImageExtent_ ) & VULKAN_HPP_NOEXCEPT - { - maxScaledImageExtent = maxScaledImageExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SurfacePresentScalingCapabilitiesKHR && setMaxScaledImageExtent( Extent2D const & maxScaledImageExtent_ ) && VULKAN_HPP_NOEXCEPT - { - maxScaledImageExtent = maxScaledImageExtent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSurfacePresentScalingCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfacePresentScalingCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfacePresentScalingCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfacePresentScalingCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, supportedPresentScaling, supportedPresentGravityX, supportedPresentGravityY, minScaledImageExtent, maxScaledImageExtent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfacePresentScalingCapabilitiesKHR const & ) const = default; -#else - bool operator==( SurfacePresentScalingCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportedPresentScaling == rhs.supportedPresentScaling ) && - ( supportedPresentGravityX == rhs.supportedPresentGravityX ) && ( supportedPresentGravityY == rhs.supportedPresentGravityY ) && - ( minScaledImageExtent == rhs.minScaledImageExtent ) && ( maxScaledImageExtent == rhs.maxScaledImageExtent ); -# endif - } - - bool operator!=( SurfacePresentScalingCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSurfacePresentScalingCapabilitiesKHR; - void * pNext = {}; - PresentScalingFlagsKHR supportedPresentScaling = {}; - PresentGravityFlagsKHR supportedPresentGravityX = {}; - PresentGravityFlagsKHR supportedPresentGravityY = {}; - Extent2D minScaledImageExtent = {}; - Extent2D maxScaledImageExtent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfacePresentScalingCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = SurfacePresentScalingCapabilitiesKHR; - }; - - using SurfacePresentScalingCapabilitiesEXT = SurfacePresentScalingCapabilitiesKHR; - - // wrapper struct for struct VkSurfaceProtectedCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSurfaceProtectedCapabilitiesKHR.html - struct SurfaceProtectedCapabilitiesKHR - { - using NativeType = VkSurfaceProtectedCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSurfaceProtectedCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( Bool32 supportsProtected_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , supportsProtected{ supportsProtected_ } - { - } - - VULKAN_HPP_CONSTEXPR SurfaceProtectedCapabilitiesKHR( SurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SurfaceProtectedCapabilitiesKHR( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SurfaceProtectedCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - SurfaceProtectedCapabilitiesKHR & operator=( SurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SurfaceProtectedCapabilitiesKHR & operator=( VkSurfaceProtectedCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSurfaceProtectedCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceProtectedCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSurfaceProtectedCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSurfaceProtectedCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, supportsProtected ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SurfaceProtectedCapabilitiesKHR const & ) const = default; -#else - bool operator==( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsProtected == rhs.supportsProtected ); -# endif - } - - bool operator!=( SurfaceProtectedCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSurfaceProtectedCapabilitiesKHR; - void * pNext = {}; - Bool32 supportsProtected = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SurfaceProtectedCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = SurfaceProtectedCapabilitiesKHR; - }; - - // wrapper struct for struct VkSwapchainCalibratedTimestampInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCalibratedTimestampInfoEXT.html - struct SwapchainCalibratedTimestampInfoEXT - { - using NativeType = VkSwapchainCalibratedTimestampInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCalibratedTimestampInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SwapchainCalibratedTimestampInfoEXT( SwapchainKHR swapchain_ = {}, - PresentStageFlagsEXT presentStage_ = {}, - uint64_t timeDomainId_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchain{ swapchain_ } - , presentStage{ presentStage_ } - , timeDomainId{ timeDomainId_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainCalibratedTimestampInfoEXT( SwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainCalibratedTimestampInfoEXT( VkSwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainCalibratedTimestampInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - SwapchainCalibratedTimestampInfoEXT & operator=( SwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainCalibratedTimestampInfoEXT & operator=( VkSwapchainCalibratedTimestampInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setSwapchain( SwapchainKHR swapchain_ ) & VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT && setSwapchain( SwapchainKHR swapchain_ ) && VULKAN_HPP_NOEXCEPT - { - swapchain = swapchain_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setPresentStage( PresentStageFlagsEXT presentStage_ ) & VULKAN_HPP_NOEXCEPT - { - presentStage = presentStage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT && setPresentStage( PresentStageFlagsEXT presentStage_ ) && VULKAN_HPP_NOEXCEPT - { - presentStage = presentStage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT & setTimeDomainId( uint64_t timeDomainId_ ) & VULKAN_HPP_NOEXCEPT - { - timeDomainId = timeDomainId_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCalibratedTimestampInfoEXT && setTimeDomainId( uint64_t timeDomainId_ ) && VULKAN_HPP_NOEXCEPT - { - timeDomainId = timeDomainId_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSwapchainCalibratedTimestampInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainCalibratedTimestampInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainCalibratedTimestampInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainCalibratedTimestampInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchain, presentStage, timeDomainId ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainCalibratedTimestampInfoEXT const & ) const = default; -#else - bool operator==( SwapchainCalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchain == rhs.swapchain ) && ( presentStage == rhs.presentStage ) && - ( timeDomainId == rhs.timeDomainId ); -# endif - } - - bool operator!=( SwapchainCalibratedTimestampInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainCalibratedTimestampInfoEXT; - const void * pNext = {}; - SwapchainKHR swapchain = {}; - PresentStageFlagsEXT presentStage = {}; - uint64_t timeDomainId = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainCalibratedTimestampInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainCalibratedTimestampInfoEXT; - }; - - // wrapper struct for struct VkSwapchainCounterCreateInfoEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCounterCreateInfoEXT.html - struct SwapchainCounterCreateInfoEXT - { - using NativeType = VkSwapchainCounterCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCounterCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( SurfaceCounterFlagsEXT surfaceCounters_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , surfaceCounters{ surfaceCounters_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainCounterCreateInfoEXT( SwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainCounterCreateInfoEXT( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainCounterCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - - SwapchainCounterCreateInfoEXT & operator=( SwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainCounterCreateInfoEXT & operator=( VkSwapchainCounterCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SwapchainCounterCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCounterCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCounterCreateInfoEXT & setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ ) & VULKAN_HPP_NOEXCEPT - { - surfaceCounters = surfaceCounters_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCounterCreateInfoEXT && setSurfaceCounters( SurfaceCounterFlagsEXT surfaceCounters_ ) && VULKAN_HPP_NOEXCEPT - { - surfaceCounters = surfaceCounters_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSwapchainCounterCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainCounterCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainCounterCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainCounterCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, surfaceCounters ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainCounterCreateInfoEXT const & ) const = default; -#else - bool operator==( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( surfaceCounters == rhs.surfaceCounters ); -# endif - } - - bool operator!=( SwapchainCounterCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainCounterCreateInfoEXT; - const void * pNext = {}; - SurfaceCounterFlagsEXT surfaceCounters = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainCounterCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainCounterCreateInfoEXT; - }; - - // wrapper struct for struct VkSwapchainCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainCreateInfoKHR.html - struct SwapchainCreateInfoKHR - { - using NativeType = VkSwapchainCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_ = {}, - SurfaceKHR surface_ = {}, - uint32_t minImageCount_ = {}, - Format imageFormat_ = Format::eUndefined, - ColorSpaceKHR imageColorSpace_ = ColorSpaceKHR::eSrgbNonlinear, - Extent2D imageExtent_ = {}, - uint32_t imageArrayLayers_ = {}, - ImageUsageFlags imageUsage_ = {}, - SharingMode imageSharingMode_ = SharingMode::eExclusive, - uint32_t queueFamilyIndexCount_ = {}, - const uint32_t * pQueueFamilyIndices_ = {}, - SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, - CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque, - PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, - Bool32 clipped_ = {}, - SwapchainKHR oldSwapchain_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , surface{ surface_ } - , minImageCount{ minImageCount_ } - , imageFormat{ imageFormat_ } - , imageColorSpace{ imageColorSpace_ } - , imageExtent{ imageExtent_ } - , imageArrayLayers{ imageArrayLayers_ } - , imageUsage{ imageUsage_ } - , imageSharingMode{ imageSharingMode_ } - , queueFamilyIndexCount{ queueFamilyIndexCount_ } - , pQueueFamilyIndices{ pQueueFamilyIndices_ } - , preTransform{ preTransform_ } - , compositeAlpha{ compositeAlpha_ } - , presentMode{ presentMode_ } - , clipped{ clipped_ } - , oldSwapchain{ oldSwapchain_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainCreateInfoKHR( SwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainCreateInfoKHR( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SwapchainCreateInfoKHR( SwapchainCreateFlagsKHR flags_, - SurfaceKHR surface_, - uint32_t minImageCount_, - Format imageFormat_, - ColorSpaceKHR imageColorSpace_, - Extent2D imageExtent_, - uint32_t imageArrayLayers_, - ImageUsageFlags imageUsage_, - SharingMode imageSharingMode_, - ArrayProxyNoTemporaries const & queueFamilyIndices_, - SurfaceTransformFlagBitsKHR preTransform_ = SurfaceTransformFlagBitsKHR::eIdentity, - CompositeAlphaFlagBitsKHR compositeAlpha_ = CompositeAlphaFlagBitsKHR::eOpaque, - PresentModeKHR presentMode_ = PresentModeKHR::eImmediate, - Bool32 clipped_ = {}, - SwapchainKHR oldSwapchain_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , surface( surface_ ) - , minImageCount( minImageCount_ ) - , imageFormat( imageFormat_ ) - , imageColorSpace( imageColorSpace_ ) - , imageExtent( imageExtent_ ) - , imageArrayLayers( imageArrayLayers_ ) - , imageUsage( imageUsage_ ) - , imageSharingMode( imageSharingMode_ ) - , queueFamilyIndexCount( static_cast( queueFamilyIndices_.size() ) ) - , pQueueFamilyIndices( queueFamilyIndices_.data() ) - , preTransform( preTransform_ ) - , compositeAlpha( compositeAlpha_ ) - , presentMode( presentMode_ ) - , clipped( clipped_ ) - , oldSwapchain( oldSwapchain_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SwapchainCreateInfoKHR & operator=( SwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainCreateInfoKHR & operator=( VkSwapchainCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setFlags( SwapchainCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setFlags( SwapchainCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setSurface( SurfaceKHR surface_ ) & VULKAN_HPP_NOEXCEPT - { - surface = surface_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setSurface( SurfaceKHR surface_ ) && VULKAN_HPP_NOEXCEPT - { - surface = surface_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setMinImageCount( uint32_t minImageCount_ ) & VULKAN_HPP_NOEXCEPT - { - minImageCount = minImageCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setMinImageCount( uint32_t minImageCount_ ) && VULKAN_HPP_NOEXCEPT - { - minImageCount = minImageCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageFormat( Format imageFormat_ ) & VULKAN_HPP_NOEXCEPT - { - imageFormat = imageFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageFormat( Format imageFormat_ ) && VULKAN_HPP_NOEXCEPT - { - imageFormat = imageFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageColorSpace( ColorSpaceKHR imageColorSpace_ ) & VULKAN_HPP_NOEXCEPT - { - imageColorSpace = imageColorSpace_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageColorSpace( ColorSpaceKHR imageColorSpace_ ) && VULKAN_HPP_NOEXCEPT - { - imageColorSpace = imageColorSpace_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageExtent( Extent2D const & imageExtent_ ) & VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageExtent( Extent2D const & imageExtent_ ) && VULKAN_HPP_NOEXCEPT - { - imageExtent = imageExtent_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageArrayLayers( uint32_t imageArrayLayers_ ) & VULKAN_HPP_NOEXCEPT - { - imageArrayLayers = imageArrayLayers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageArrayLayers( uint32_t imageArrayLayers_ ) && VULKAN_HPP_NOEXCEPT - { - imageArrayLayers = imageArrayLayers_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageUsage( ImageUsageFlags imageUsage_ ) & VULKAN_HPP_NOEXCEPT - { - imageUsage = imageUsage_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageUsage( ImageUsageFlags imageUsage_ ) && VULKAN_HPP_NOEXCEPT - { - imageUsage = imageUsage_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setImageSharingMode( SharingMode imageSharingMode_ ) & VULKAN_HPP_NOEXCEPT - { - imageSharingMode = imageSharingMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setImageSharingMode( SharingMode imageSharingMode_ ) && VULKAN_HPP_NOEXCEPT - { - imageSharingMode = imageSharingMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) & VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setQueueFamilyIndexCount( uint32_t queueFamilyIndexCount_ ) && VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = queueFamilyIndexCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) & VULKAN_HPP_NOEXCEPT - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setPQueueFamilyIndices( const uint32_t * pQueueFamilyIndices_ ) && VULKAN_HPP_NOEXCEPT - { - pQueueFamilyIndices = pQueueFamilyIndices_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SwapchainCreateInfoKHR & setQueueFamilyIndices( ArrayProxyNoTemporaries const & queueFamilyIndices_ ) VULKAN_HPP_NOEXCEPT - { - queueFamilyIndexCount = static_cast( queueFamilyIndices_.size() ); - pQueueFamilyIndices = queueFamilyIndices_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ ) & VULKAN_HPP_NOEXCEPT - { - preTransform = preTransform_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setPreTransform( SurfaceTransformFlagBitsKHR preTransform_ ) && VULKAN_HPP_NOEXCEPT - { - preTransform = preTransform_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ ) & VULKAN_HPP_NOEXCEPT - { - compositeAlpha = compositeAlpha_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setCompositeAlpha( CompositeAlphaFlagBitsKHR compositeAlpha_ ) && VULKAN_HPP_NOEXCEPT - { - compositeAlpha = compositeAlpha_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setPresentMode( PresentModeKHR presentMode_ ) & VULKAN_HPP_NOEXCEPT - { - presentMode = presentMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setPresentMode( PresentModeKHR presentMode_ ) && VULKAN_HPP_NOEXCEPT - { - presentMode = presentMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setClipped( Bool32 clipped_ ) & VULKAN_HPP_NOEXCEPT - { - clipped = clipped_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setClipped( Bool32 clipped_ ) && VULKAN_HPP_NOEXCEPT - { - clipped = clipped_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR & setOldSwapchain( SwapchainKHR oldSwapchain_ ) & VULKAN_HPP_NOEXCEPT - { - oldSwapchain = oldSwapchain_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainCreateInfoKHR && setOldSwapchain( SwapchainKHR oldSwapchain_ ) && VULKAN_HPP_NOEXCEPT - { - oldSwapchain = oldSwapchain_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSwapchainCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - surface, - minImageCount, - imageFormat, - imageColorSpace, - imageExtent, - imageArrayLayers, - imageUsage, - imageSharingMode, - queueFamilyIndexCount, - pQueueFamilyIndices, - preTransform, - compositeAlpha, - presentMode, - clipped, - oldSwapchain ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainCreateInfoKHR const & ) const = default; -#else - bool operator==( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( surface == rhs.surface ) && - ( minImageCount == rhs.minImageCount ) && ( imageFormat == rhs.imageFormat ) && ( imageColorSpace == rhs.imageColorSpace ) && - ( imageExtent == rhs.imageExtent ) && ( imageArrayLayers == rhs.imageArrayLayers ) && ( imageUsage == rhs.imageUsage ) && - ( imageSharingMode == rhs.imageSharingMode ) && ( queueFamilyIndexCount == rhs.queueFamilyIndexCount ) && - ( pQueueFamilyIndices == rhs.pQueueFamilyIndices ) && ( preTransform == rhs.preTransform ) && ( compositeAlpha == rhs.compositeAlpha ) && - ( presentMode == rhs.presentMode ) && ( clipped == rhs.clipped ) && ( oldSwapchain == rhs.oldSwapchain ); -# endif - } - - bool operator!=( SwapchainCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainCreateInfoKHR; - const void * pNext = {}; - SwapchainCreateFlagsKHR flags = {}; - SurfaceKHR surface = {}; - uint32_t minImageCount = {}; - Format imageFormat = Format::eUndefined; - ColorSpaceKHR imageColorSpace = ColorSpaceKHR::eSrgbNonlinear; - Extent2D imageExtent = {}; - uint32_t imageArrayLayers = {}; - ImageUsageFlags imageUsage = {}; - SharingMode imageSharingMode = SharingMode::eExclusive; - uint32_t queueFamilyIndexCount = {}; - const uint32_t * pQueueFamilyIndices = {}; - SurfaceTransformFlagBitsKHR preTransform = SurfaceTransformFlagBitsKHR::eIdentity; - CompositeAlphaFlagBitsKHR compositeAlpha = CompositeAlphaFlagBitsKHR::eOpaque; - PresentModeKHR presentMode = PresentModeKHR::eImmediate; - Bool32 clipped = {}; - SwapchainKHR oldSwapchain = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainCreateInfoKHR; - }; - - // wrapper struct for struct VkSwapchainDisplayNativeHdrCreateInfoAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainDisplayNativeHdrCreateInfoAMD.html - struct SwapchainDisplayNativeHdrCreateInfoAMD - { - using NativeType = VkSwapchainDisplayNativeHdrCreateInfoAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( Bool32 localDimmingEnable_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , localDimmingEnable{ localDimmingEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainDisplayNativeHdrCreateInfoAMD( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainDisplayNativeHdrCreateInfoAMD( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainDisplayNativeHdrCreateInfoAMD( *reinterpret_cast( &rhs ) ) - { - } - - SwapchainDisplayNativeHdrCreateInfoAMD & operator=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainDisplayNativeHdrCreateInfoAMD & operator=( VkSwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SwapchainDisplayNativeHdrCreateInfoAMD & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainDisplayNativeHdrCreateInfoAMD && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainDisplayNativeHdrCreateInfoAMD & setLocalDimmingEnable( Bool32 localDimmingEnable_ ) & VULKAN_HPP_NOEXCEPT - { - localDimmingEnable = localDimmingEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainDisplayNativeHdrCreateInfoAMD && setLocalDimmingEnable( Bool32 localDimmingEnable_ ) && VULKAN_HPP_NOEXCEPT - { - localDimmingEnable = localDimmingEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSwapchainDisplayNativeHdrCreateInfoAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainDisplayNativeHdrCreateInfoAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainDisplayNativeHdrCreateInfoAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainDisplayNativeHdrCreateInfoAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, localDimmingEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainDisplayNativeHdrCreateInfoAMD const & ) const = default; -#else - bool operator==( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( localDimmingEnable == rhs.localDimmingEnable ); -# endif - } - - bool operator!=( SwapchainDisplayNativeHdrCreateInfoAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD; - const void * pNext = {}; - Bool32 localDimmingEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainDisplayNativeHdrCreateInfoAMD; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainDisplayNativeHdrCreateInfoAMD; - }; - - // wrapper struct for struct VkSwapchainLatencyCreateInfoNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainLatencyCreateInfoNV.html - struct SwapchainLatencyCreateInfoNV - { - using NativeType = VkSwapchainLatencyCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainLatencyCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SwapchainLatencyCreateInfoNV( Bool32 latencyModeEnable_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , latencyModeEnable{ latencyModeEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainLatencyCreateInfoNV( SwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainLatencyCreateInfoNV( VkSwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainLatencyCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - SwapchainLatencyCreateInfoNV & operator=( SwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainLatencyCreateInfoNV & operator=( VkSwapchainLatencyCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SwapchainLatencyCreateInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainLatencyCreateInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainLatencyCreateInfoNV & setLatencyModeEnable( Bool32 latencyModeEnable_ ) & VULKAN_HPP_NOEXCEPT - { - latencyModeEnable = latencyModeEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainLatencyCreateInfoNV && setLatencyModeEnable( Bool32 latencyModeEnable_ ) && VULKAN_HPP_NOEXCEPT - { - latencyModeEnable = latencyModeEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSwapchainLatencyCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainLatencyCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainLatencyCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainLatencyCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, latencyModeEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainLatencyCreateInfoNV const & ) const = default; -#else - bool operator==( SwapchainLatencyCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( latencyModeEnable == rhs.latencyModeEnable ); -# endif - } - - bool operator!=( SwapchainLatencyCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainLatencyCreateInfoNV; - const void * pNext = {}; - Bool32 latencyModeEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainLatencyCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainLatencyCreateInfoNV; - }; - - // wrapper struct for struct VkSwapchainPresentBarrierCreateInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainPresentBarrierCreateInfoNV.html - struct SwapchainPresentBarrierCreateInfoNV - { - using NativeType = VkSwapchainPresentBarrierCreateInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainPresentBarrierCreateInfoNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SwapchainPresentBarrierCreateInfoNV( Bool32 presentBarrierEnable_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentBarrierEnable{ presentBarrierEnable_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainPresentBarrierCreateInfoNV( SwapchainPresentBarrierCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainPresentBarrierCreateInfoNV( VkSwapchainPresentBarrierCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainPresentBarrierCreateInfoNV( *reinterpret_cast( &rhs ) ) - { - } - - SwapchainPresentBarrierCreateInfoNV & operator=( SwapchainPresentBarrierCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainPresentBarrierCreateInfoNV & operator=( VkSwapchainPresentBarrierCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentBarrierCreateInfoNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentBarrierCreateInfoNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentBarrierCreateInfoNV & setPresentBarrierEnable( Bool32 presentBarrierEnable_ ) & VULKAN_HPP_NOEXCEPT - { - presentBarrierEnable = presentBarrierEnable_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentBarrierCreateInfoNV && setPresentBarrierEnable( Bool32 presentBarrierEnable_ ) && VULKAN_HPP_NOEXCEPT - { - presentBarrierEnable = presentBarrierEnable_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSwapchainPresentBarrierCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainPresentBarrierCreateInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainPresentBarrierCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainPresentBarrierCreateInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentBarrierEnable ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainPresentBarrierCreateInfoNV const & ) const = default; -#else - bool operator==( SwapchainPresentBarrierCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentBarrierEnable == rhs.presentBarrierEnable ); -# endif - } - - bool operator!=( SwapchainPresentBarrierCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainPresentBarrierCreateInfoNV; - void * pNext = {}; - Bool32 presentBarrierEnable = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainPresentBarrierCreateInfoNV; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainPresentBarrierCreateInfoNV; - }; - - // wrapper struct for struct VkSwapchainPresentFenceInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainPresentFenceInfoKHR.html - struct SwapchainPresentFenceInfoKHR - { - using NativeType = VkSwapchainPresentFenceInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainPresentFenceInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - SwapchainPresentFenceInfoKHR( uint32_t swapchainCount_ = {}, const Fence * pFences_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchainCount{ swapchainCount_ } - , pFences{ pFences_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainPresentFenceInfoKHR( SwapchainPresentFenceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainPresentFenceInfoKHR( VkSwapchainPresentFenceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainPresentFenceInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SwapchainPresentFenceInfoKHR( ArrayProxyNoTemporaries const & fences_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), swapchainCount( static_cast( fences_.size() ) ), pFences( fences_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SwapchainPresentFenceInfoKHR & operator=( SwapchainPresentFenceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainPresentFenceInfoKHR & operator=( VkSwapchainPresentFenceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR & setPFences( const Fence * pFences_ ) & VULKAN_HPP_NOEXCEPT - { - pFences = pFences_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentFenceInfoKHR && setPFences( const Fence * pFences_ ) && VULKAN_HPP_NOEXCEPT - { - pFences = pFences_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SwapchainPresentFenceInfoKHR & setFences( ArrayProxyNoTemporaries const & fences_ ) VULKAN_HPP_NOEXCEPT - { - swapchainCount = static_cast( fences_.size() ); - pFences = fences_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSwapchainPresentFenceInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainPresentFenceInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainPresentFenceInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainPresentFenceInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchainCount, pFences ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainPresentFenceInfoKHR const & ) const = default; -#else - bool operator==( SwapchainPresentFenceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pFences == rhs.pFences ); -# endif - } - - bool operator!=( SwapchainPresentFenceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainPresentFenceInfoKHR; - const void * pNext = {}; - uint32_t swapchainCount = {}; - const Fence * pFences = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainPresentFenceInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainPresentFenceInfoKHR; - }; - - using SwapchainPresentFenceInfoEXT = SwapchainPresentFenceInfoKHR; - - // wrapper struct for struct VkSwapchainPresentModeInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainPresentModeInfoKHR.html - struct SwapchainPresentModeInfoKHR - { - using NativeType = VkSwapchainPresentModeInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainPresentModeInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SwapchainPresentModeInfoKHR( uint32_t swapchainCount_ = {}, - const PresentModeKHR * pPresentModes_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , swapchainCount{ swapchainCount_ } - , pPresentModes{ pPresentModes_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainPresentModeInfoKHR( SwapchainPresentModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainPresentModeInfoKHR( VkSwapchainPresentModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainPresentModeInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SwapchainPresentModeInfoKHR( ArrayProxyNoTemporaries const & presentModes_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), swapchainCount( static_cast( presentModes_.size() ) ), pPresentModes( presentModes_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SwapchainPresentModeInfoKHR & operator=( SwapchainPresentModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainPresentModeInfoKHR & operator=( VkSwapchainPresentModeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR & setSwapchainCount( uint32_t swapchainCount_ ) & VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR && setSwapchainCount( uint32_t swapchainCount_ ) && VULKAN_HPP_NOEXCEPT - { - swapchainCount = swapchainCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR & setPPresentModes( const PresentModeKHR * pPresentModes_ ) & VULKAN_HPP_NOEXCEPT - { - pPresentModes = pPresentModes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModeInfoKHR && setPPresentModes( const PresentModeKHR * pPresentModes_ ) && VULKAN_HPP_NOEXCEPT - { - pPresentModes = pPresentModes_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SwapchainPresentModeInfoKHR & setPresentModes( ArrayProxyNoTemporaries const & presentModes_ ) VULKAN_HPP_NOEXCEPT - { - swapchainCount = static_cast( presentModes_.size() ); - pPresentModes = presentModes_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSwapchainPresentModeInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainPresentModeInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainPresentModeInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainPresentModeInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, swapchainCount, pPresentModes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainPresentModeInfoKHR const & ) const = default; -#else - bool operator==( SwapchainPresentModeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( swapchainCount == rhs.swapchainCount ) && ( pPresentModes == rhs.pPresentModes ); -# endif - } - - bool operator!=( SwapchainPresentModeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainPresentModeInfoKHR; - const void * pNext = {}; - uint32_t swapchainCount = {}; - const PresentModeKHR * pPresentModes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainPresentModeInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainPresentModeInfoKHR; - }; - - using SwapchainPresentModeInfoEXT = SwapchainPresentModeInfoKHR; - - // wrapper struct for struct VkSwapchainPresentModesCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainPresentModesCreateInfoKHR.html - struct SwapchainPresentModesCreateInfoKHR - { - using NativeType = VkSwapchainPresentModesCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainPresentModesCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SwapchainPresentModesCreateInfoKHR( uint32_t presentModeCount_ = {}, - const PresentModeKHR * pPresentModes_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , presentModeCount{ presentModeCount_ } - , pPresentModes{ pPresentModes_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainPresentModesCreateInfoKHR( SwapchainPresentModesCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainPresentModesCreateInfoKHR( VkSwapchainPresentModesCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainPresentModesCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SwapchainPresentModesCreateInfoKHR( ArrayProxyNoTemporaries const & presentModes_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), presentModeCount( static_cast( presentModes_.size() ) ), pPresentModes( presentModes_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - SwapchainPresentModesCreateInfoKHR & operator=( SwapchainPresentModesCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainPresentModesCreateInfoKHR & operator=( VkSwapchainPresentModesCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR & setPresentModeCount( uint32_t presentModeCount_ ) & VULKAN_HPP_NOEXCEPT - { - presentModeCount = presentModeCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR && setPresentModeCount( uint32_t presentModeCount_ ) && VULKAN_HPP_NOEXCEPT - { - presentModeCount = presentModeCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR & setPPresentModes( const PresentModeKHR * pPresentModes_ ) & VULKAN_HPP_NOEXCEPT - { - pPresentModes = pPresentModes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentModesCreateInfoKHR && setPPresentModes( const PresentModeKHR * pPresentModes_ ) && VULKAN_HPP_NOEXCEPT - { - pPresentModes = pPresentModes_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - SwapchainPresentModesCreateInfoKHR & setPresentModes( ArrayProxyNoTemporaries const & presentModes_ ) VULKAN_HPP_NOEXCEPT - { - presentModeCount = static_cast( presentModes_.size() ); - pPresentModes = presentModes_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSwapchainPresentModesCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainPresentModesCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainPresentModesCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainPresentModesCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, presentModeCount, pPresentModes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainPresentModesCreateInfoKHR const & ) const = default; -#else - bool operator==( SwapchainPresentModesCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( presentModeCount == rhs.presentModeCount ) && ( pPresentModes == rhs.pPresentModes ); -# endif - } - - bool operator!=( SwapchainPresentModesCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainPresentModesCreateInfoKHR; - const void * pNext = {}; - uint32_t presentModeCount = {}; - const PresentModeKHR * pPresentModes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainPresentModesCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainPresentModesCreateInfoKHR; - }; - - using SwapchainPresentModesCreateInfoEXT = SwapchainPresentModesCreateInfoKHR; - - // wrapper struct for struct VkSwapchainPresentScalingCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainPresentScalingCreateInfoKHR.html - struct SwapchainPresentScalingCreateInfoKHR - { - using NativeType = VkSwapchainPresentScalingCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainPresentScalingCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SwapchainPresentScalingCreateInfoKHR( PresentScalingFlagsKHR scalingBehavior_ = {}, - PresentGravityFlagsKHR presentGravityX_ = {}, - PresentGravityFlagsKHR presentGravityY_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , scalingBehavior{ scalingBehavior_ } - , presentGravityX{ presentGravityX_ } - , presentGravityY{ presentGravityY_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainPresentScalingCreateInfoKHR( SwapchainPresentScalingCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainPresentScalingCreateInfoKHR( VkSwapchainPresentScalingCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainPresentScalingCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - SwapchainPresentScalingCreateInfoKHR & operator=( SwapchainPresentScalingCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainPresentScalingCreateInfoKHR & operator=( VkSwapchainPresentScalingCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR & setScalingBehavior( PresentScalingFlagsKHR scalingBehavior_ ) & VULKAN_HPP_NOEXCEPT - { - scalingBehavior = scalingBehavior_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR && setScalingBehavior( PresentScalingFlagsKHR scalingBehavior_ ) && VULKAN_HPP_NOEXCEPT - { - scalingBehavior = scalingBehavior_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR & setPresentGravityX( PresentGravityFlagsKHR presentGravityX_ ) & VULKAN_HPP_NOEXCEPT - { - presentGravityX = presentGravityX_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR && setPresentGravityX( PresentGravityFlagsKHR presentGravityX_ ) && VULKAN_HPP_NOEXCEPT - { - presentGravityX = presentGravityX_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR & setPresentGravityY( PresentGravityFlagsKHR presentGravityY_ ) & VULKAN_HPP_NOEXCEPT - { - presentGravityY = presentGravityY_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 SwapchainPresentScalingCreateInfoKHR && setPresentGravityY( PresentGravityFlagsKHR presentGravityY_ ) && VULKAN_HPP_NOEXCEPT - { - presentGravityY = presentGravityY_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkSwapchainPresentScalingCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainPresentScalingCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainPresentScalingCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainPresentScalingCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, scalingBehavior, presentGravityX, presentGravityY ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainPresentScalingCreateInfoKHR const & ) const = default; -#else - bool operator==( SwapchainPresentScalingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( scalingBehavior == rhs.scalingBehavior ) && ( presentGravityX == rhs.presentGravityX ) && - ( presentGravityY == rhs.presentGravityY ); -# endif - } - - bool operator!=( SwapchainPresentScalingCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainPresentScalingCreateInfoKHR; - const void * pNext = {}; - PresentScalingFlagsKHR scalingBehavior = {}; - PresentGravityFlagsKHR presentGravityX = {}; - PresentGravityFlagsKHR presentGravityY = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainPresentScalingCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainPresentScalingCreateInfoKHR; - }; - - using SwapchainPresentScalingCreateInfoEXT = SwapchainPresentScalingCreateInfoKHR; - - // wrapper struct for struct VkSwapchainTimeDomainPropertiesEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainTimeDomainPropertiesEXT.html - struct SwapchainTimeDomainPropertiesEXT - { - using NativeType = VkSwapchainTimeDomainPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainTimeDomainPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR SwapchainTimeDomainPropertiesEXT( uint32_t timeDomainCount_ = {}, - TimeDomainKHR * pTimeDomains_ = {}, - uint64_t * pTimeDomainIds_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , timeDomainCount{ timeDomainCount_ } - , pTimeDomains{ pTimeDomains_ } - , pTimeDomainIds{ pTimeDomainIds_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainTimeDomainPropertiesEXT( SwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainTimeDomainPropertiesEXT( VkSwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainTimeDomainPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - SwapchainTimeDomainPropertiesEXT & operator=( SwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainTimeDomainPropertiesEXT & operator=( VkSwapchainTimeDomainPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSwapchainTimeDomainPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainTimeDomainPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainTimeDomainPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainTimeDomainPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, timeDomainCount, pTimeDomains, pTimeDomainIds ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainTimeDomainPropertiesEXT const & ) const = default; -#else - bool operator==( SwapchainTimeDomainPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( timeDomainCount == rhs.timeDomainCount ) && ( pTimeDomains == rhs.pTimeDomains ) && - ( pTimeDomainIds == rhs.pTimeDomainIds ); -# endif - } - - bool operator!=( SwapchainTimeDomainPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainTimeDomainPropertiesEXT; - void * pNext = {}; - uint32_t timeDomainCount = {}; - TimeDomainKHR * pTimeDomains = {}; - uint64_t * pTimeDomainIds = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainTimeDomainPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainTimeDomainPropertiesEXT; - }; - - // wrapper struct for struct VkSwapchainTimingPropertiesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSwapchainTimingPropertiesEXT.html - struct SwapchainTimingPropertiesEXT - { - using NativeType = VkSwapchainTimingPropertiesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eSwapchainTimingPropertiesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - SwapchainTimingPropertiesEXT( uint64_t refreshDuration_ = {}, uint64_t refreshInterval_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , refreshDuration{ refreshDuration_ } - , refreshInterval{ refreshInterval_ } - { - } - - VULKAN_HPP_CONSTEXPR SwapchainTimingPropertiesEXT( SwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - SwapchainTimingPropertiesEXT( VkSwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : SwapchainTimingPropertiesEXT( *reinterpret_cast( &rhs ) ) - { - } - - SwapchainTimingPropertiesEXT & operator=( SwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - SwapchainTimingPropertiesEXT & operator=( VkSwapchainTimingPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkSwapchainTimingPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainTimingPropertiesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkSwapchainTimingPropertiesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkSwapchainTimingPropertiesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, refreshDuration, refreshInterval ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( SwapchainTimingPropertiesEXT const & ) const = default; -#else - bool operator==( SwapchainTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( refreshDuration == rhs.refreshDuration ) && ( refreshInterval == rhs.refreshInterval ); -# endif - } - - bool operator!=( SwapchainTimingPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eSwapchainTimingPropertiesEXT; - void * pNext = {}; - uint64_t refreshDuration = {}; - uint64_t refreshInterval = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = SwapchainTimingPropertiesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = SwapchainTimingPropertiesEXT; - }; - - // wrapper struct for struct VkTensorCaptureDescriptorDataInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorCaptureDescriptorDataInfoARM.html - struct TensorCaptureDescriptorDataInfoARM - { - using NativeType = VkTensorCaptureDescriptorDataInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorCaptureDescriptorDataInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TensorCaptureDescriptorDataInfoARM( TensorARM tensor_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensor{ tensor_ } - { - } - - VULKAN_HPP_CONSTEXPR TensorCaptureDescriptorDataInfoARM( TensorCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TensorCaptureDescriptorDataInfoARM( VkTensorCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : TensorCaptureDescriptorDataInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - TensorCaptureDescriptorDataInfoARM & operator=( TensorCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TensorCaptureDescriptorDataInfoARM & operator=( VkTensorCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TensorCaptureDescriptorDataInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCaptureDescriptorDataInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorCaptureDescriptorDataInfoARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorCaptureDescriptorDataInfoARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTensorCaptureDescriptorDataInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorCaptureDescriptorDataInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorCaptureDescriptorDataInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTensorCaptureDescriptorDataInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tensor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TensorCaptureDescriptorDataInfoARM const & ) const = default; -#else - bool operator==( TensorCaptureDescriptorDataInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensor == rhs.tensor ); -# endif - } - - bool operator!=( TensorCaptureDescriptorDataInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTensorCaptureDescriptorDataInfoARM; - const void * pNext = {}; - TensorARM tensor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TensorCaptureDescriptorDataInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = TensorCaptureDescriptorDataInfoARM; - }; - - // wrapper struct for struct VkTensorMemoryBarrierARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorMemoryBarrierARM.html - struct TensorMemoryBarrierARM - { - using NativeType = VkTensorMemoryBarrierARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorMemoryBarrierARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TensorMemoryBarrierARM( PipelineStageFlags2 srcStageMask_ = {}, - AccessFlags2 srcAccessMask_ = {}, - PipelineStageFlags2 dstStageMask_ = {}, - AccessFlags2 dstAccessMask_ = {}, - uint32_t srcQueueFamilyIndex_ = {}, - uint32_t dstQueueFamilyIndex_ = {}, - TensorARM tensor_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , srcStageMask{ srcStageMask_ } - , srcAccessMask{ srcAccessMask_ } - , dstStageMask{ dstStageMask_ } - , dstAccessMask{ dstAccessMask_ } - , srcQueueFamilyIndex{ srcQueueFamilyIndex_ } - , dstQueueFamilyIndex{ dstQueueFamilyIndex_ } - , tensor{ tensor_ } - { - } - - VULKAN_HPP_CONSTEXPR TensorMemoryBarrierARM( TensorMemoryBarrierARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TensorMemoryBarrierARM( VkTensorMemoryBarrierARM const & rhs ) VULKAN_HPP_NOEXCEPT - : TensorMemoryBarrierARM( *reinterpret_cast( &rhs ) ) - { - } - - TensorMemoryBarrierARM & operator=( TensorMemoryBarrierARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TensorMemoryBarrierARM & operator=( VkTensorMemoryBarrierARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setSrcStageMask( PipelineStageFlags2 srcStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcStageMask = srcStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setSrcAccessMask( AccessFlags2 srcAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setSrcAccessMask( AccessFlags2 srcAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - srcAccessMask = srcAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setDstStageMask( PipelineStageFlags2 dstStageMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setDstStageMask( PipelineStageFlags2 dstStageMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstStageMask = dstStageMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setDstAccessMask( AccessFlags2 dstAccessMask_ ) & VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setDstAccessMask( AccessFlags2 dstAccessMask_ ) && VULKAN_HPP_NOEXCEPT - { - dstAccessMask = dstAccessMask_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setSrcQueueFamilyIndex( uint32_t srcQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - srcQueueFamilyIndex = srcQueueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setDstQueueFamilyIndex( uint32_t dstQueueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - dstQueueFamilyIndex = dstQueueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryBarrierARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTensorMemoryBarrierARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorMemoryBarrierARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorMemoryBarrierARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTensorMemoryBarrierARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, srcStageMask, srcAccessMask, dstStageMask, dstAccessMask, srcQueueFamilyIndex, dstQueueFamilyIndex, tensor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TensorMemoryBarrierARM const & ) const = default; -#else - bool operator==( TensorMemoryBarrierARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( srcStageMask == rhs.srcStageMask ) && ( srcAccessMask == rhs.srcAccessMask ) && - ( dstStageMask == rhs.dstStageMask ) && ( dstAccessMask == rhs.dstAccessMask ) && ( srcQueueFamilyIndex == rhs.srcQueueFamilyIndex ) && - ( dstQueueFamilyIndex == rhs.dstQueueFamilyIndex ) && ( tensor == rhs.tensor ); -# endif - } - - bool operator!=( TensorMemoryBarrierARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTensorMemoryBarrierARM; - const void * pNext = {}; - PipelineStageFlags2 srcStageMask = {}; - AccessFlags2 srcAccessMask = {}; - PipelineStageFlags2 dstStageMask = {}; - AccessFlags2 dstAccessMask = {}; - uint32_t srcQueueFamilyIndex = {}; - uint32_t dstQueueFamilyIndex = {}; - TensorARM tensor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TensorMemoryBarrierARM; - }; -#endif - - template <> - struct CppType - { - using Type = TensorMemoryBarrierARM; - }; - - // wrapper struct for struct VkTensorDependencyInfoARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorDependencyInfoARM.html - struct TensorDependencyInfoARM - { - using NativeType = VkTensorDependencyInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorDependencyInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TensorDependencyInfoARM( uint32_t tensorMemoryBarrierCount_ = {}, - const TensorMemoryBarrierARM * pTensorMemoryBarriers_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensorMemoryBarrierCount{ tensorMemoryBarrierCount_ } - , pTensorMemoryBarriers{ pTensorMemoryBarriers_ } - { - } - - VULKAN_HPP_CONSTEXPR TensorDependencyInfoARM( TensorDependencyInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TensorDependencyInfoARM( VkTensorDependencyInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : TensorDependencyInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - TensorDependencyInfoARM & operator=( TensorDependencyInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TensorDependencyInfoARM & operator=( VkTensorDependencyInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM & setTensorMemoryBarrierCount( uint32_t tensorMemoryBarrierCount_ ) & VULKAN_HPP_NOEXCEPT - { - tensorMemoryBarrierCount = tensorMemoryBarrierCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM && setTensorMemoryBarrierCount( uint32_t tensorMemoryBarrierCount_ ) && VULKAN_HPP_NOEXCEPT - { - tensorMemoryBarrierCount = tensorMemoryBarrierCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM & setPTensorMemoryBarriers( const TensorMemoryBarrierARM * pTensorMemoryBarriers_ ) & VULKAN_HPP_NOEXCEPT - { - pTensorMemoryBarriers = pTensorMemoryBarriers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorDependencyInfoARM && setPTensorMemoryBarriers( const TensorMemoryBarrierARM * pTensorMemoryBarriers_ ) && VULKAN_HPP_NOEXCEPT - { - pTensorMemoryBarriers = pTensorMemoryBarriers_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTensorDependencyInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorDependencyInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorDependencyInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTensorDependencyInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tensorMemoryBarrierCount, pTensorMemoryBarriers ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TensorDependencyInfoARM const & ) const = default; -#else - bool operator==( TensorDependencyInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorMemoryBarrierCount == rhs.tensorMemoryBarrierCount ) && - ( pTensorMemoryBarriers == rhs.pTensorMemoryBarriers ); -# endif - } - - bool operator!=( TensorDependencyInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTensorDependencyInfoARM; - const void * pNext = {}; - uint32_t tensorMemoryBarrierCount = {}; - const TensorMemoryBarrierARM * pTensorMemoryBarriers = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TensorDependencyInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = TensorDependencyInfoARM; - }; - - // wrapper struct for struct VkTensorFormatPropertiesARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorFormatPropertiesARM.html - struct TensorFormatPropertiesARM - { - using NativeType = VkTensorFormatPropertiesARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorFormatPropertiesARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TensorFormatPropertiesARM( FormatFeatureFlags2 optimalTilingTensorFeatures_ = {}, - FormatFeatureFlags2 linearTilingTensorFeatures_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , optimalTilingTensorFeatures{ optimalTilingTensorFeatures_ } - , linearTilingTensorFeatures{ linearTilingTensorFeatures_ } - { - } - - VULKAN_HPP_CONSTEXPR TensorFormatPropertiesARM( TensorFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TensorFormatPropertiesARM( VkTensorFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - : TensorFormatPropertiesARM( *reinterpret_cast( &rhs ) ) - { - } - - TensorFormatPropertiesARM & operator=( TensorFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TensorFormatPropertiesARM & operator=( VkTensorFormatPropertiesARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkTensorFormatPropertiesARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorFormatPropertiesARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorFormatPropertiesARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTensorFormatPropertiesARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, optimalTilingTensorFeatures, linearTilingTensorFeatures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TensorFormatPropertiesARM const & ) const = default; -#else - bool operator==( TensorFormatPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( optimalTilingTensorFeatures == rhs.optimalTilingTensorFeatures ) && - ( linearTilingTensorFeatures == rhs.linearTilingTensorFeatures ); -# endif - } - - bool operator!=( TensorFormatPropertiesARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTensorFormatPropertiesARM; - void * pNext = {}; - FormatFeatureFlags2 optimalTilingTensorFeatures = {}; - FormatFeatureFlags2 linearTilingTensorFeatures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TensorFormatPropertiesARM; - }; -#endif - - template <> - struct CppType - { - using Type = TensorFormatPropertiesARM; - }; - - // wrapper struct for struct VkTensorMemoryRequirementsInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorMemoryRequirementsInfoARM.html - struct TensorMemoryRequirementsInfoARM - { - using NativeType = VkTensorMemoryRequirementsInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorMemoryRequirementsInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TensorMemoryRequirementsInfoARM( TensorARM tensor_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensor{ tensor_ } - { - } - - VULKAN_HPP_CONSTEXPR TensorMemoryRequirementsInfoARM( TensorMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TensorMemoryRequirementsInfoARM( VkTensorMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : TensorMemoryRequirementsInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - TensorMemoryRequirementsInfoARM & operator=( TensorMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TensorMemoryRequirementsInfoARM & operator=( VkTensorMemoryRequirementsInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TensorMemoryRequirementsInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryRequirementsInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryRequirementsInfoARM & setTensor( TensorARM tensor_ ) & VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorMemoryRequirementsInfoARM && setTensor( TensorARM tensor_ ) && VULKAN_HPP_NOEXCEPT - { - tensor = tensor_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTensorMemoryRequirementsInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorMemoryRequirementsInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorMemoryRequirementsInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTensorMemoryRequirementsInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tensor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TensorMemoryRequirementsInfoARM const & ) const = default; -#else - bool operator==( TensorMemoryRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensor == rhs.tensor ); -# endif - } - - bool operator!=( TensorMemoryRequirementsInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTensorMemoryRequirementsInfoARM; - const void * pNext = {}; - TensorARM tensor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TensorMemoryRequirementsInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = TensorMemoryRequirementsInfoARM; - }; - - // wrapper struct for struct VkTensorViewCaptureDescriptorDataInfoARM, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTensorViewCaptureDescriptorDataInfoARM.html - struct TensorViewCaptureDescriptorDataInfoARM - { - using NativeType = VkTensorViewCaptureDescriptorDataInfoARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTensorViewCaptureDescriptorDataInfoARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TensorViewCaptureDescriptorDataInfoARM( TensorViewARM tensorView_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensorView{ tensorView_ } - { - } - - VULKAN_HPP_CONSTEXPR TensorViewCaptureDescriptorDataInfoARM( TensorViewCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TensorViewCaptureDescriptorDataInfoARM( VkTensorViewCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - : TensorViewCaptureDescriptorDataInfoARM( *reinterpret_cast( &rhs ) ) - { - } - - TensorViewCaptureDescriptorDataInfoARM & operator=( TensorViewCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TensorViewCaptureDescriptorDataInfoARM & operator=( VkTensorViewCaptureDescriptorDataInfoARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TensorViewCaptureDescriptorDataInfoARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorViewCaptureDescriptorDataInfoARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TensorViewCaptureDescriptorDataInfoARM & setTensorView( TensorViewARM tensorView_ ) & VULKAN_HPP_NOEXCEPT - { - tensorView = tensorView_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TensorViewCaptureDescriptorDataInfoARM && setTensorView( TensorViewARM tensorView_ ) && VULKAN_HPP_NOEXCEPT - { - tensorView = tensorView_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTensorViewCaptureDescriptorDataInfoARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorViewCaptureDescriptorDataInfoARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTensorViewCaptureDescriptorDataInfoARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTensorViewCaptureDescriptorDataInfoARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tensorView ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TensorViewCaptureDescriptorDataInfoARM const & ) const = default; -#else - bool operator==( TensorViewCaptureDescriptorDataInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorView == rhs.tensorView ); -# endif - } - - bool operator!=( TensorViewCaptureDescriptorDataInfoARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTensorViewCaptureDescriptorDataInfoARM; - const void * pNext = {}; - TensorViewARM tensorView = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TensorViewCaptureDescriptorDataInfoARM; - }; -#endif - - template <> - struct CppType - { - using Type = TensorViewCaptureDescriptorDataInfoARM; - }; - - // wrapper struct for struct VkTextureLODGatherFormatPropertiesAMD, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTextureLODGatherFormatPropertiesAMD.html - struct TextureLODGatherFormatPropertiesAMD - { - using NativeType = VkTextureLODGatherFormatPropertiesAMD; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTextureLodGatherFormatPropertiesAMD; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TextureLODGatherFormatPropertiesAMD( Bool32 supportsTextureGatherLODBiasAMD_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , supportsTextureGatherLODBiasAMD{ supportsTextureGatherLODBiasAMD_ } - { - } - - VULKAN_HPP_CONSTEXPR TextureLODGatherFormatPropertiesAMD( TextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TextureLODGatherFormatPropertiesAMD( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - : TextureLODGatherFormatPropertiesAMD( *reinterpret_cast( &rhs ) ) - { - } - - TextureLODGatherFormatPropertiesAMD & operator=( TextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TextureLODGatherFormatPropertiesAMD & operator=( VkTextureLODGatherFormatPropertiesAMD const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkTextureLODGatherFormatPropertiesAMD const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTextureLODGatherFormatPropertiesAMD &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTextureLODGatherFormatPropertiesAMD const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTextureLODGatherFormatPropertiesAMD *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, supportsTextureGatherLODBiasAMD ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TextureLODGatherFormatPropertiesAMD const & ) const = default; -#else - bool operator==( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( supportsTextureGatherLODBiasAMD == rhs.supportsTextureGatherLODBiasAMD ); -# endif - } - - bool operator!=( TextureLODGatherFormatPropertiesAMD const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTextureLodGatherFormatPropertiesAMD; - void * pNext = {}; - Bool32 supportsTextureGatherLODBiasAMD = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TextureLODGatherFormatPropertiesAMD; - }; -#endif - - template <> - struct CppType - { - using Type = TextureLODGatherFormatPropertiesAMD; - }; - - // wrapper struct for struct VkTileMemoryBindInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemoryBindInfoQCOM.html - struct TileMemoryBindInfoQCOM - { - using NativeType = VkTileMemoryBindInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemoryBindInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TileMemoryBindInfoQCOM( DeviceMemory memory_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memory{ memory_ } - { - } - - VULKAN_HPP_CONSTEXPR TileMemoryBindInfoQCOM( TileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TileMemoryBindInfoQCOM( VkTileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : TileMemoryBindInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - TileMemoryBindInfoQCOM & operator=( TileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TileMemoryBindInfoQCOM & operator=( VkTileMemoryBindInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM & setMemory( DeviceMemory memory_ ) & VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TileMemoryBindInfoQCOM && setMemory( DeviceMemory memory_ ) && VULKAN_HPP_NOEXCEPT - { - memory = memory_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTileMemoryBindInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTileMemoryBindInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTileMemoryBindInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTileMemoryBindInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memory ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TileMemoryBindInfoQCOM const & ) const = default; -#else - bool operator==( TileMemoryBindInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memory == rhs.memory ); -# endif - } - - bool operator!=( TileMemoryBindInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTileMemoryBindInfoQCOM; - const void * pNext = {}; - DeviceMemory memory = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TileMemoryBindInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = TileMemoryBindInfoQCOM; - }; - - // wrapper struct for struct VkTileMemoryRequirementsQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemoryRequirementsQCOM.html - struct TileMemoryRequirementsQCOM - { - using NativeType = VkTileMemoryRequirementsQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemoryRequirementsQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TileMemoryRequirementsQCOM( DeviceSize size_ = {}, DeviceSize alignment_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , size{ size_ } - , alignment{ alignment_ } - { - } - - VULKAN_HPP_CONSTEXPR TileMemoryRequirementsQCOM( TileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TileMemoryRequirementsQCOM( VkTileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : TileMemoryRequirementsQCOM( *reinterpret_cast( &rhs ) ) - { - } - - TileMemoryRequirementsQCOM & operator=( TileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TileMemoryRequirementsQCOM & operator=( VkTileMemoryRequirementsQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM & setAlignment( DeviceSize alignment_ ) & VULKAN_HPP_NOEXCEPT - { - alignment = alignment_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TileMemoryRequirementsQCOM && setAlignment( DeviceSize alignment_ ) && VULKAN_HPP_NOEXCEPT - { - alignment = alignment_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTileMemoryRequirementsQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTileMemoryRequirementsQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTileMemoryRequirementsQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTileMemoryRequirementsQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, size, alignment ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TileMemoryRequirementsQCOM const & ) const = default; -#else - bool operator==( TileMemoryRequirementsQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( size == rhs.size ) && ( alignment == rhs.alignment ); -# endif - } - - bool operator!=( TileMemoryRequirementsQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTileMemoryRequirementsQCOM; - void * pNext = {}; - DeviceSize size = {}; - DeviceSize alignment = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TileMemoryRequirementsQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = TileMemoryRequirementsQCOM; - }; - - // wrapper struct for struct VkTileMemorySizeInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileMemorySizeInfoQCOM.html - struct TileMemorySizeInfoQCOM - { - using NativeType = VkTileMemorySizeInfoQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTileMemorySizeInfoQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TileMemorySizeInfoQCOM( DeviceSize size_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , size{ size_ } - { - } - - VULKAN_HPP_CONSTEXPR TileMemorySizeInfoQCOM( TileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TileMemorySizeInfoQCOM( VkTileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - : TileMemorySizeInfoQCOM( *reinterpret_cast( &rhs ) ) - { - } - - TileMemorySizeInfoQCOM & operator=( TileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TileMemorySizeInfoQCOM & operator=( VkTileMemorySizeInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM & setSize( DeviceSize size_ ) & VULKAN_HPP_NOEXCEPT - { - size = size_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TileMemorySizeInfoQCOM && setSize( DeviceSize size_ ) && VULKAN_HPP_NOEXCEPT - { - size = size_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTileMemorySizeInfoQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTileMemorySizeInfoQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTileMemorySizeInfoQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTileMemorySizeInfoQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, size ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TileMemorySizeInfoQCOM const & ) const = default; -#else - bool operator==( TileMemorySizeInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( size == rhs.size ); -# endif - } - - bool operator!=( TileMemorySizeInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTileMemorySizeInfoQCOM; - const void * pNext = {}; - DeviceSize size = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TileMemorySizeInfoQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = TileMemorySizeInfoQCOM; - }; - - // wrapper struct for struct VkTilePropertiesQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTilePropertiesQCOM.html - struct TilePropertiesQCOM - { - using NativeType = VkTilePropertiesQCOM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTilePropertiesQCOM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - TilePropertiesQCOM( Extent3D tileSize_ = {}, Extent2D apronSize_ = {}, Offset2D origin_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tileSize{ tileSize_ } - , apronSize{ apronSize_ } - , origin{ origin_ } - { - } - - VULKAN_HPP_CONSTEXPR TilePropertiesQCOM( TilePropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TilePropertiesQCOM( VkTilePropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT : TilePropertiesQCOM( *reinterpret_cast( &rhs ) ) {} - - TilePropertiesQCOM & operator=( TilePropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TilePropertiesQCOM & operator=( VkTilePropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM & setTileSize( Extent3D const & tileSize_ ) & VULKAN_HPP_NOEXCEPT - { - tileSize = tileSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM && setTileSize( Extent3D const & tileSize_ ) && VULKAN_HPP_NOEXCEPT - { - tileSize = tileSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM & setApronSize( Extent2D const & apronSize_ ) & VULKAN_HPP_NOEXCEPT - { - apronSize = apronSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM && setApronSize( Extent2D const & apronSize_ ) && VULKAN_HPP_NOEXCEPT - { - apronSize = apronSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM & setOrigin( Offset2D const & origin_ ) & VULKAN_HPP_NOEXCEPT - { - origin = origin_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TilePropertiesQCOM && setOrigin( Offset2D const & origin_ ) && VULKAN_HPP_NOEXCEPT - { - origin = origin_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTilePropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTilePropertiesQCOM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTilePropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTilePropertiesQCOM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tileSize, apronSize, origin ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TilePropertiesQCOM const & ) const = default; -#else - bool operator==( TilePropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tileSize == rhs.tileSize ) && ( apronSize == rhs.apronSize ) && ( origin == rhs.origin ); -# endif - } - - bool operator!=( TilePropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTilePropertiesQCOM; - void * pNext = {}; - Extent3D tileSize = {}; - Extent2D apronSize = {}; - Offset2D origin = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TilePropertiesQCOM; - }; -#endif - - template <> - struct CppType - { - using Type = TilePropertiesQCOM; - }; - - // wrapper struct for struct VkTimelineSemaphoreSubmitInfo, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTimelineSemaphoreSubmitInfo.html - struct TimelineSemaphoreSubmitInfo - { - using NativeType = VkTimelineSemaphoreSubmitInfo; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eTimelineSemaphoreSubmitInfo; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfo( uint32_t waitSemaphoreValueCount_ = {}, - const uint64_t * pWaitSemaphoreValues_ = {}, - uint32_t signalSemaphoreValueCount_ = {}, - const uint64_t * pSignalSemaphoreValues_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , waitSemaphoreValueCount{ waitSemaphoreValueCount_ } - , pWaitSemaphoreValues{ pWaitSemaphoreValues_ } - , signalSemaphoreValueCount{ signalSemaphoreValueCount_ } - , pSignalSemaphoreValues{ pSignalSemaphoreValues_ } - { - } - - VULKAN_HPP_CONSTEXPR TimelineSemaphoreSubmitInfo( TimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TimelineSemaphoreSubmitInfo( VkTimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - : TimelineSemaphoreSubmitInfo( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TimelineSemaphoreSubmitInfo( ArrayProxyNoTemporaries const & waitSemaphoreValues_, - ArrayProxyNoTemporaries const & signalSemaphoreValues_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , waitSemaphoreValueCount( static_cast( waitSemaphoreValues_.size() ) ) - , pWaitSemaphoreValues( waitSemaphoreValues_.data() ) - , signalSemaphoreValueCount( static_cast( signalSemaphoreValues_.size() ) ) - , pSignalSemaphoreValues( signalSemaphoreValues_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - TimelineSemaphoreSubmitInfo & operator=( TimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TimelineSemaphoreSubmitInfo & operator=( VkTimelineSemaphoreSubmitInfo const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo & setWaitSemaphoreValueCount( uint32_t waitSemaphoreValueCount_ ) & VULKAN_HPP_NOEXCEPT - { - waitSemaphoreValueCount = waitSemaphoreValueCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo && setWaitSemaphoreValueCount( uint32_t waitSemaphoreValueCount_ ) && VULKAN_HPP_NOEXCEPT - { - waitSemaphoreValueCount = waitSemaphoreValueCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo & setPWaitSemaphoreValues( const uint64_t * pWaitSemaphoreValues_ ) & VULKAN_HPP_NOEXCEPT - { - pWaitSemaphoreValues = pWaitSemaphoreValues_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo && setPWaitSemaphoreValues( const uint64_t * pWaitSemaphoreValues_ ) && VULKAN_HPP_NOEXCEPT - { - pWaitSemaphoreValues = pWaitSemaphoreValues_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TimelineSemaphoreSubmitInfo & setWaitSemaphoreValues( ArrayProxyNoTemporaries const & waitSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT - { - waitSemaphoreValueCount = static_cast( waitSemaphoreValues_.size() ); - pWaitSemaphoreValues = waitSemaphoreValues_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo & setSignalSemaphoreValueCount( uint32_t signalSemaphoreValueCount_ ) & VULKAN_HPP_NOEXCEPT - { - signalSemaphoreValueCount = signalSemaphoreValueCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo && setSignalSemaphoreValueCount( uint32_t signalSemaphoreValueCount_ ) && VULKAN_HPP_NOEXCEPT - { - signalSemaphoreValueCount = signalSemaphoreValueCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo & setPSignalSemaphoreValues( const uint64_t * pSignalSemaphoreValues_ ) & VULKAN_HPP_NOEXCEPT - { - pSignalSemaphoreValues = pSignalSemaphoreValues_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TimelineSemaphoreSubmitInfo && setPSignalSemaphoreValues( const uint64_t * pSignalSemaphoreValues_ ) && VULKAN_HPP_NOEXCEPT - { - pSignalSemaphoreValues = pSignalSemaphoreValues_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - TimelineSemaphoreSubmitInfo & setSignalSemaphoreValues( ArrayProxyNoTemporaries const & signalSemaphoreValues_ ) VULKAN_HPP_NOEXCEPT - { - signalSemaphoreValueCount = static_cast( signalSemaphoreValues_.size() ); - pSignalSemaphoreValues = signalSemaphoreValues_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTimelineSemaphoreSubmitInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTimelineSemaphoreSubmitInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTimelineSemaphoreSubmitInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTimelineSemaphoreSubmitInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, waitSemaphoreValueCount, pWaitSemaphoreValues, signalSemaphoreValueCount, pSignalSemaphoreValues ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TimelineSemaphoreSubmitInfo const & ) const = default; -#else - bool operator==( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( waitSemaphoreValueCount == rhs.waitSemaphoreValueCount ) && - ( pWaitSemaphoreValues == rhs.pWaitSemaphoreValues ) && ( signalSemaphoreValueCount == rhs.signalSemaphoreValueCount ) && - ( pSignalSemaphoreValues == rhs.pSignalSemaphoreValues ); -# endif - } - - bool operator!=( TimelineSemaphoreSubmitInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eTimelineSemaphoreSubmitInfo; - const void * pNext = {}; - uint32_t waitSemaphoreValueCount = {}; - const uint64_t * pWaitSemaphoreValues = {}; - uint32_t signalSemaphoreValueCount = {}; - const uint64_t * pSignalSemaphoreValues = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TimelineSemaphoreSubmitInfo; - }; -#endif - - template <> - struct CppType - { - using Type = TimelineSemaphoreSubmitInfo; - }; - - using TimelineSemaphoreSubmitInfoKHR = TimelineSemaphoreSubmitInfo; - - // wrapper struct for struct VkTraceRaysIndirectCommand2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTraceRaysIndirectCommand2KHR.html - struct TraceRaysIndirectCommand2KHR - { - using NativeType = VkTraceRaysIndirectCommand2KHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommand2KHR( DeviceAddress raygenShaderRecordAddress_ = {}, - DeviceSize raygenShaderRecordSize_ = {}, - DeviceAddress missShaderBindingTableAddress_ = {}, - DeviceSize missShaderBindingTableSize_ = {}, - DeviceSize missShaderBindingTableStride_ = {}, - DeviceAddress hitShaderBindingTableAddress_ = {}, - DeviceSize hitShaderBindingTableSize_ = {}, - DeviceSize hitShaderBindingTableStride_ = {}, - DeviceAddress callableShaderBindingTableAddress_ = {}, - DeviceSize callableShaderBindingTableSize_ = {}, - DeviceSize callableShaderBindingTableStride_ = {}, - uint32_t width_ = {}, - uint32_t height_ = {}, - uint32_t depth_ = {} ) VULKAN_HPP_NOEXCEPT - : raygenShaderRecordAddress{ raygenShaderRecordAddress_ } - , raygenShaderRecordSize{ raygenShaderRecordSize_ } - , missShaderBindingTableAddress{ missShaderBindingTableAddress_ } - , missShaderBindingTableSize{ missShaderBindingTableSize_ } - , missShaderBindingTableStride{ missShaderBindingTableStride_ } - , hitShaderBindingTableAddress{ hitShaderBindingTableAddress_ } - , hitShaderBindingTableSize{ hitShaderBindingTableSize_ } - , hitShaderBindingTableStride{ hitShaderBindingTableStride_ } - , callableShaderBindingTableAddress{ callableShaderBindingTableAddress_ } - , callableShaderBindingTableSize{ callableShaderBindingTableSize_ } - , callableShaderBindingTableStride{ callableShaderBindingTableStride_ } - , width{ width_ } - , height{ height_ } - , depth{ depth_ } - { - } - - VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommand2KHR( TraceRaysIndirectCommand2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TraceRaysIndirectCommand2KHR( VkTraceRaysIndirectCommand2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - : TraceRaysIndirectCommand2KHR( *reinterpret_cast( &rhs ) ) - { - } - - TraceRaysIndirectCommand2KHR & operator=( TraceRaysIndirectCommand2KHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TraceRaysIndirectCommand2KHR & operator=( VkTraceRaysIndirectCommand2KHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setRaygenShaderRecordAddress( DeviceAddress raygenShaderRecordAddress_ ) & VULKAN_HPP_NOEXCEPT - { - raygenShaderRecordAddress = raygenShaderRecordAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setRaygenShaderRecordAddress( DeviceAddress raygenShaderRecordAddress_ ) && VULKAN_HPP_NOEXCEPT - { - raygenShaderRecordAddress = raygenShaderRecordAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setRaygenShaderRecordSize( DeviceSize raygenShaderRecordSize_ ) & VULKAN_HPP_NOEXCEPT - { - raygenShaderRecordSize = raygenShaderRecordSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setRaygenShaderRecordSize( DeviceSize raygenShaderRecordSize_ ) && VULKAN_HPP_NOEXCEPT - { - raygenShaderRecordSize = raygenShaderRecordSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setMissShaderBindingTableAddress( DeviceAddress missShaderBindingTableAddress_ ) & - VULKAN_HPP_NOEXCEPT - { - missShaderBindingTableAddress = missShaderBindingTableAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setMissShaderBindingTableAddress( DeviceAddress missShaderBindingTableAddress_ ) && - VULKAN_HPP_NOEXCEPT - { - missShaderBindingTableAddress = missShaderBindingTableAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setMissShaderBindingTableSize( DeviceSize missShaderBindingTableSize_ ) & VULKAN_HPP_NOEXCEPT - { - missShaderBindingTableSize = missShaderBindingTableSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setMissShaderBindingTableSize( DeviceSize missShaderBindingTableSize_ ) && VULKAN_HPP_NOEXCEPT - { - missShaderBindingTableSize = missShaderBindingTableSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setMissShaderBindingTableStride( DeviceSize missShaderBindingTableStride_ ) & VULKAN_HPP_NOEXCEPT - { - missShaderBindingTableStride = missShaderBindingTableStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setMissShaderBindingTableStride( DeviceSize missShaderBindingTableStride_ ) && VULKAN_HPP_NOEXCEPT - { - missShaderBindingTableStride = missShaderBindingTableStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setHitShaderBindingTableAddress( DeviceAddress hitShaderBindingTableAddress_ ) & VULKAN_HPP_NOEXCEPT - { - hitShaderBindingTableAddress = hitShaderBindingTableAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setHitShaderBindingTableAddress( DeviceAddress hitShaderBindingTableAddress_ ) && - VULKAN_HPP_NOEXCEPT - { - hitShaderBindingTableAddress = hitShaderBindingTableAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setHitShaderBindingTableSize( DeviceSize hitShaderBindingTableSize_ ) & VULKAN_HPP_NOEXCEPT - { - hitShaderBindingTableSize = hitShaderBindingTableSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setHitShaderBindingTableSize( DeviceSize hitShaderBindingTableSize_ ) && VULKAN_HPP_NOEXCEPT - { - hitShaderBindingTableSize = hitShaderBindingTableSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setHitShaderBindingTableStride( DeviceSize hitShaderBindingTableStride_ ) & VULKAN_HPP_NOEXCEPT - { - hitShaderBindingTableStride = hitShaderBindingTableStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setHitShaderBindingTableStride( DeviceSize hitShaderBindingTableStride_ ) && VULKAN_HPP_NOEXCEPT - { - hitShaderBindingTableStride = hitShaderBindingTableStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setCallableShaderBindingTableAddress( DeviceAddress callableShaderBindingTableAddress_ ) & - VULKAN_HPP_NOEXCEPT - { - callableShaderBindingTableAddress = callableShaderBindingTableAddress_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setCallableShaderBindingTableAddress( DeviceAddress callableShaderBindingTableAddress_ ) && - VULKAN_HPP_NOEXCEPT - { - callableShaderBindingTableAddress = callableShaderBindingTableAddress_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setCallableShaderBindingTableSize( DeviceSize callableShaderBindingTableSize_ ) & VULKAN_HPP_NOEXCEPT - { - callableShaderBindingTableSize = callableShaderBindingTableSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setCallableShaderBindingTableSize( DeviceSize callableShaderBindingTableSize_ ) && - VULKAN_HPP_NOEXCEPT - { - callableShaderBindingTableSize = callableShaderBindingTableSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setCallableShaderBindingTableStride( DeviceSize callableShaderBindingTableStride_ ) & - VULKAN_HPP_NOEXCEPT - { - callableShaderBindingTableStride = callableShaderBindingTableStride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setCallableShaderBindingTableStride( DeviceSize callableShaderBindingTableStride_ ) && - VULKAN_HPP_NOEXCEPT - { - callableShaderBindingTableStride = callableShaderBindingTableStride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT - { - width = width_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT - { - width = width_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT - { - height = height_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT - { - height = height_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR & setDepth( uint32_t depth_ ) & VULKAN_HPP_NOEXCEPT - { - depth = depth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommand2KHR && setDepth( uint32_t depth_ ) && VULKAN_HPP_NOEXCEPT - { - depth = depth_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTraceRaysIndirectCommand2KHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTraceRaysIndirectCommand2KHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTraceRaysIndirectCommand2KHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTraceRaysIndirectCommand2KHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( raygenShaderRecordAddress, - raygenShaderRecordSize, - missShaderBindingTableAddress, - missShaderBindingTableSize, - missShaderBindingTableStride, - hitShaderBindingTableAddress, - hitShaderBindingTableSize, - hitShaderBindingTableStride, - callableShaderBindingTableAddress, - callableShaderBindingTableSize, - callableShaderBindingTableStride, - width, - height, - depth ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TraceRaysIndirectCommand2KHR const & ) const = default; -#else - bool operator==( TraceRaysIndirectCommand2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( raygenShaderRecordAddress == rhs.raygenShaderRecordAddress ) && ( raygenShaderRecordSize == rhs.raygenShaderRecordSize ) && - ( missShaderBindingTableAddress == rhs.missShaderBindingTableAddress ) && ( missShaderBindingTableSize == rhs.missShaderBindingTableSize ) && - ( missShaderBindingTableStride == rhs.missShaderBindingTableStride ) && ( hitShaderBindingTableAddress == rhs.hitShaderBindingTableAddress ) && - ( hitShaderBindingTableSize == rhs.hitShaderBindingTableSize ) && ( hitShaderBindingTableStride == rhs.hitShaderBindingTableStride ) && - ( callableShaderBindingTableAddress == rhs.callableShaderBindingTableAddress ) && - ( callableShaderBindingTableSize == rhs.callableShaderBindingTableSize ) && - ( callableShaderBindingTableStride == rhs.callableShaderBindingTableStride ) && ( width == rhs.width ) && ( height == rhs.height ) && - ( depth == rhs.depth ); -# endif - } - - bool operator!=( TraceRaysIndirectCommand2KHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - DeviceAddress raygenShaderRecordAddress = {}; - DeviceSize raygenShaderRecordSize = {}; - DeviceAddress missShaderBindingTableAddress = {}; - DeviceSize missShaderBindingTableSize = {}; - DeviceSize missShaderBindingTableStride = {}; - DeviceAddress hitShaderBindingTableAddress = {}; - DeviceSize hitShaderBindingTableSize = {}; - DeviceSize hitShaderBindingTableStride = {}; - DeviceAddress callableShaderBindingTableAddress = {}; - DeviceSize callableShaderBindingTableSize = {}; - DeviceSize callableShaderBindingTableStride = {}; - uint32_t width = {}; - uint32_t height = {}; - uint32_t depth = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TraceRaysIndirectCommand2KHR; - }; -#endif - - // wrapper struct for struct VkTraceRaysIndirectCommandKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkTraceRaysIndirectCommandKHR.html - struct TraceRaysIndirectCommandKHR - { - using NativeType = VkTraceRaysIndirectCommandKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommandKHR( uint32_t width_ = {}, uint32_t height_ = {}, uint32_t depth_ = {} ) VULKAN_HPP_NOEXCEPT - : width{ width_ } - , height{ height_ } - , depth{ depth_ } - { - } - - VULKAN_HPP_CONSTEXPR TraceRaysIndirectCommandKHR( TraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - TraceRaysIndirectCommandKHR( VkTraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : TraceRaysIndirectCommandKHR( *reinterpret_cast( &rhs ) ) - { - } - - explicit TraceRaysIndirectCommandKHR( Extent2D const & extent2D, uint32_t depth_ = {} ) - : width( extent2D.width ), height( extent2D.height ), depth( depth_ ) - { - } - - TraceRaysIndirectCommandKHR & operator=( TraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - TraceRaysIndirectCommandKHR & operator=( VkTraceRaysIndirectCommandKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR & setWidth( uint32_t width_ ) & VULKAN_HPP_NOEXCEPT - { - width = width_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR && setWidth( uint32_t width_ ) && VULKAN_HPP_NOEXCEPT - { - width = width_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR & setHeight( uint32_t height_ ) & VULKAN_HPP_NOEXCEPT - { - height = height_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR && setHeight( uint32_t height_ ) && VULKAN_HPP_NOEXCEPT - { - height = height_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR & setDepth( uint32_t depth_ ) & VULKAN_HPP_NOEXCEPT - { - depth = depth_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 TraceRaysIndirectCommandKHR && setDepth( uint32_t depth_ ) && VULKAN_HPP_NOEXCEPT - { - depth = depth_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkTraceRaysIndirectCommandKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTraceRaysIndirectCommandKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkTraceRaysIndirectCommandKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkTraceRaysIndirectCommandKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( width, height, depth ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( TraceRaysIndirectCommandKHR const & ) const = default; -#else - bool operator==( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( width == rhs.width ) && ( height == rhs.height ) && ( depth == rhs.depth ); -# endif - } - - bool operator!=( TraceRaysIndirectCommandKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t width = {}; - uint32_t height = {}; - uint32_t depth = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = TraceRaysIndirectCommandKHR; - }; -#endif - - // wrapper struct for struct VkValidationCacheCreateInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationCacheCreateInfoEXT.html - struct ValidationCacheCreateInfoEXT - { - using NativeType = VkValidationCacheCreateInfoEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationCacheCreateInfoEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_ = {}, - size_t initialDataSize_ = {}, - const void * pInitialData_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , initialDataSize{ initialDataSize_ } - , pInitialData{ pInitialData_ } - { - } - - VULKAN_HPP_CONSTEXPR ValidationCacheCreateInfoEXT( ValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ValidationCacheCreateInfoEXT( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ValidationCacheCreateInfoEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - ValidationCacheCreateInfoEXT( ValidationCacheCreateFlagsEXT flags_, ArrayProxyNoTemporaries const & initialData_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), flags( flags_ ), initialDataSize( initialData_.size() * sizeof( T ) ), pInitialData( initialData_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ValidationCacheCreateInfoEXT & operator=( ValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ValidationCacheCreateInfoEXT & operator=( VkValidationCacheCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT & setFlags( ValidationCacheCreateFlagsEXT flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT && setFlags( ValidationCacheCreateFlagsEXT flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT & setInitialDataSize( size_t initialDataSize_ ) & VULKAN_HPP_NOEXCEPT - { - initialDataSize = initialDataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT && setInitialDataSize( size_t initialDataSize_ ) && VULKAN_HPP_NOEXCEPT - { - initialDataSize = initialDataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT & setPInitialData( const void * pInitialData_ ) & VULKAN_HPP_NOEXCEPT - { - pInitialData = pInitialData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationCacheCreateInfoEXT && setPInitialData( const void * pInitialData_ ) && VULKAN_HPP_NOEXCEPT - { - pInitialData = pInitialData_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - ValidationCacheCreateInfoEXT & setInitialData( ArrayProxyNoTemporaries const & initialData_ ) VULKAN_HPP_NOEXCEPT - { - initialDataSize = initialData_.size() * sizeof( T ); - pInitialData = initialData_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkValidationCacheCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkValidationCacheCreateInfoEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkValidationCacheCreateInfoEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkValidationCacheCreateInfoEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, initialDataSize, pInitialData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ValidationCacheCreateInfoEXT const & ) const = default; -#else - bool operator==( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( initialDataSize == rhs.initialDataSize ) && - ( pInitialData == rhs.pInitialData ); -# endif - } - - bool operator!=( ValidationCacheCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eValidationCacheCreateInfoEXT; - const void * pNext = {}; - ValidationCacheCreateFlagsEXT flags = {}; - size_t initialDataSize = {}; - const void * pInitialData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ValidationCacheCreateInfoEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ValidationCacheCreateInfoEXT; - }; - - // wrapper struct for struct VkValidationFeaturesEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationFeaturesEXT.html - struct ValidationFeaturesEXT - { - using NativeType = VkValidationFeaturesEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationFeaturesEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( uint32_t enabledValidationFeatureCount_ = {}, - const ValidationFeatureEnableEXT * pEnabledValidationFeatures_ = {}, - uint32_t disabledValidationFeatureCount_ = {}, - const ValidationFeatureDisableEXT * pDisabledValidationFeatures_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , enabledValidationFeatureCount{ enabledValidationFeatureCount_ } - , pEnabledValidationFeatures{ pEnabledValidationFeatures_ } - , disabledValidationFeatureCount{ disabledValidationFeatureCount_ } - , pDisabledValidationFeatures{ pDisabledValidationFeatures_ } - { - } - - VULKAN_HPP_CONSTEXPR ValidationFeaturesEXT( ValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ValidationFeaturesEXT( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : ValidationFeaturesEXT( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ValidationFeaturesEXT( ArrayProxyNoTemporaries const & enabledValidationFeatures_, - ArrayProxyNoTemporaries const & disabledValidationFeatures_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , enabledValidationFeatureCount( static_cast( enabledValidationFeatures_.size() ) ) - , pEnabledValidationFeatures( enabledValidationFeatures_.data() ) - , disabledValidationFeatureCount( static_cast( disabledValidationFeatures_.size() ) ) - , pDisabledValidationFeatures( disabledValidationFeatures_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ValidationFeaturesEXT & operator=( ValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ValidationFeaturesEXT & operator=( VkValidationFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT & setEnabledValidationFeatureCount( uint32_t enabledValidationFeatureCount_ ) & VULKAN_HPP_NOEXCEPT - { - enabledValidationFeatureCount = enabledValidationFeatureCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT && setEnabledValidationFeatureCount( uint32_t enabledValidationFeatureCount_ ) && VULKAN_HPP_NOEXCEPT - { - enabledValidationFeatureCount = enabledValidationFeatureCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT & setPEnabledValidationFeatures( const ValidationFeatureEnableEXT * pEnabledValidationFeatures_ ) & - VULKAN_HPP_NOEXCEPT - { - pEnabledValidationFeatures = pEnabledValidationFeatures_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT && setPEnabledValidationFeatures( const ValidationFeatureEnableEXT * pEnabledValidationFeatures_ ) && - VULKAN_HPP_NOEXCEPT - { - pEnabledValidationFeatures = pEnabledValidationFeatures_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ValidationFeaturesEXT & - setEnabledValidationFeatures( ArrayProxyNoTemporaries const & enabledValidationFeatures_ ) VULKAN_HPP_NOEXCEPT - { - enabledValidationFeatureCount = static_cast( enabledValidationFeatures_.size() ); - pEnabledValidationFeatures = enabledValidationFeatures_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT & setDisabledValidationFeatureCount( uint32_t disabledValidationFeatureCount_ ) & VULKAN_HPP_NOEXCEPT - { - disabledValidationFeatureCount = disabledValidationFeatureCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT && setDisabledValidationFeatureCount( uint32_t disabledValidationFeatureCount_ ) && VULKAN_HPP_NOEXCEPT - { - disabledValidationFeatureCount = disabledValidationFeatureCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT & setPDisabledValidationFeatures( const ValidationFeatureDisableEXT * pDisabledValidationFeatures_ ) & - VULKAN_HPP_NOEXCEPT - { - pDisabledValidationFeatures = pDisabledValidationFeatures_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFeaturesEXT && setPDisabledValidationFeatures( const ValidationFeatureDisableEXT * pDisabledValidationFeatures_ ) && - VULKAN_HPP_NOEXCEPT - { - pDisabledValidationFeatures = pDisabledValidationFeatures_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ValidationFeaturesEXT & - setDisabledValidationFeatures( ArrayProxyNoTemporaries const & disabledValidationFeatures_ ) VULKAN_HPP_NOEXCEPT - { - disabledValidationFeatureCount = static_cast( disabledValidationFeatures_.size() ); - pDisabledValidationFeatures = disabledValidationFeatures_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkValidationFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkValidationFeaturesEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkValidationFeaturesEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkValidationFeaturesEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, enabledValidationFeatureCount, pEnabledValidationFeatures, disabledValidationFeatureCount, pDisabledValidationFeatures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ValidationFeaturesEXT const & ) const = default; -#else - bool operator==( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( enabledValidationFeatureCount == rhs.enabledValidationFeatureCount ) && - ( pEnabledValidationFeatures == rhs.pEnabledValidationFeatures ) && ( disabledValidationFeatureCount == rhs.disabledValidationFeatureCount ) && - ( pDisabledValidationFeatures == rhs.pDisabledValidationFeatures ); -# endif - } - - bool operator!=( ValidationFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eValidationFeaturesEXT; - const void * pNext = {}; - uint32_t enabledValidationFeatureCount = {}; - const ValidationFeatureEnableEXT * pEnabledValidationFeatures = {}; - uint32_t disabledValidationFeatureCount = {}; - const ValidationFeatureDisableEXT * pDisabledValidationFeatures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ValidationFeaturesEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ValidationFeaturesEXT; - }; - - // wrapper struct for struct VkValidationFlagsEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkValidationFlagsEXT.html - struct ValidationFlagsEXT - { - using NativeType = VkValidationFlagsEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eValidationFlagsEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( uint32_t disabledValidationCheckCount_ = {}, - const ValidationCheckEXT * pDisabledValidationChecks_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , disabledValidationCheckCount{ disabledValidationCheckCount_ } - , pDisabledValidationChecks{ pDisabledValidationChecks_ } - { - } - - VULKAN_HPP_CONSTEXPR ValidationFlagsEXT( ValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ValidationFlagsEXT( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT : ValidationFlagsEXT( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ValidationFlagsEXT( ArrayProxyNoTemporaries const & disabledValidationChecks_, const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , disabledValidationCheckCount( static_cast( disabledValidationChecks_.size() ) ) - , pDisabledValidationChecks( disabledValidationChecks_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - ValidationFlagsEXT & operator=( ValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ValidationFlagsEXT & operator=( VkValidationFlagsEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT & setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ ) & VULKAN_HPP_NOEXCEPT - { - disabledValidationCheckCount = disabledValidationCheckCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT && setDisabledValidationCheckCount( uint32_t disabledValidationCheckCount_ ) && VULKAN_HPP_NOEXCEPT - { - disabledValidationCheckCount = disabledValidationCheckCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT & setPDisabledValidationChecks( const ValidationCheckEXT * pDisabledValidationChecks_ ) & VULKAN_HPP_NOEXCEPT - { - pDisabledValidationChecks = pDisabledValidationChecks_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ValidationFlagsEXT && setPDisabledValidationChecks( const ValidationCheckEXT * pDisabledValidationChecks_ ) && VULKAN_HPP_NOEXCEPT - { - pDisabledValidationChecks = pDisabledValidationChecks_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - ValidationFlagsEXT & setDisabledValidationChecks( ArrayProxyNoTemporaries const & disabledValidationChecks_ ) VULKAN_HPP_NOEXCEPT - { - disabledValidationCheckCount = static_cast( disabledValidationChecks_.size() ); - pDisabledValidationChecks = disabledValidationChecks_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkValidationFlagsEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkValidationFlagsEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkValidationFlagsEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkValidationFlagsEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, disabledValidationCheckCount, pDisabledValidationChecks ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ValidationFlagsEXT const & ) const = default; -#else - bool operator==( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( disabledValidationCheckCount == rhs.disabledValidationCheckCount ) && - ( pDisabledValidationChecks == rhs.pDisabledValidationChecks ); -# endif - } - - bool operator!=( ValidationFlagsEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eValidationFlagsEXT; - const void * pNext = {}; - uint32_t disabledValidationCheckCount = {}; - const ValidationCheckEXT * pDisabledValidationChecks = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ValidationFlagsEXT; - }; -#endif - - template <> - struct CppType - { - using Type = ValidationFlagsEXT; - }; - - // wrapper struct for struct VkVertexInputAttributeDescription2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputAttributeDescription2EXT.html - struct VertexInputAttributeDescription2EXT - { - using NativeType = VkVertexInputAttributeDescription2EXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVertexInputAttributeDescription2EXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription2EXT( - uint32_t location_ = {}, uint32_t binding_ = {}, Format format_ = Format::eUndefined, uint32_t offset_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , location{ location_ } - , binding{ binding_ } - , format{ format_ } - , offset{ offset_ } - { - } - - VULKAN_HPP_CONSTEXPR VertexInputAttributeDescription2EXT( VertexInputAttributeDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VertexInputAttributeDescription2EXT( VkVertexInputAttributeDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VertexInputAttributeDescription2EXT( *reinterpret_cast( &rhs ) ) - { - } - - VertexInputAttributeDescription2EXT & operator=( VertexInputAttributeDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VertexInputAttributeDescription2EXT & operator=( VkVertexInputAttributeDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT & setLocation( uint32_t location_ ) & VULKAN_HPP_NOEXCEPT - { - location = location_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT && setLocation( uint32_t location_ ) && VULKAN_HPP_NOEXCEPT - { - location = location_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT & setFormat( Format format_ ) & VULKAN_HPP_NOEXCEPT - { - format = format_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT && setFormat( Format format_ ) && VULKAN_HPP_NOEXCEPT - { - format = format_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT & setOffset( uint32_t offset_ ) & VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputAttributeDescription2EXT && setOffset( uint32_t offset_ ) && VULKAN_HPP_NOEXCEPT - { - offset = offset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVertexInputAttributeDescription2EXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVertexInputAttributeDescription2EXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVertexInputAttributeDescription2EXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVertexInputAttributeDescription2EXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, location, binding, format, offset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VertexInputAttributeDescription2EXT const & ) const = default; -#else - bool operator==( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( location == rhs.location ) && ( binding == rhs.binding ) && ( format == rhs.format ) && - ( offset == rhs.offset ); -# endif - } - - bool operator!=( VertexInputAttributeDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVertexInputAttributeDescription2EXT; - void * pNext = {}; - uint32_t location = {}; - uint32_t binding = {}; - Format format = Format::eUndefined; - uint32_t offset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VertexInputAttributeDescription2EXT; - }; -#endif - - template <> - struct CppType - { - using Type = VertexInputAttributeDescription2EXT; - }; - - // wrapper struct for struct VkVertexInputBindingDescription2EXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVertexInputBindingDescription2EXT.html - struct VertexInputBindingDescription2EXT - { - using NativeType = VkVertexInputBindingDescription2EXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVertexInputBindingDescription2EXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VertexInputBindingDescription2EXT( uint32_t binding_ = {}, - uint32_t stride_ = {}, - VertexInputRate inputRate_ = VertexInputRate::eVertex, - uint32_t divisor_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , binding{ binding_ } - , stride{ stride_ } - , inputRate{ inputRate_ } - , divisor{ divisor_ } - { - } - - VULKAN_HPP_CONSTEXPR VertexInputBindingDescription2EXT( VertexInputBindingDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VertexInputBindingDescription2EXT( VkVertexInputBindingDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - : VertexInputBindingDescription2EXT( *reinterpret_cast( &rhs ) ) - { - } - - VertexInputBindingDescription2EXT & operator=( VertexInputBindingDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VertexInputBindingDescription2EXT & operator=( VkVertexInputBindingDescription2EXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT & setBinding( uint32_t binding_ ) & VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT && setBinding( uint32_t binding_ ) && VULKAN_HPP_NOEXCEPT - { - binding = binding_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT & setStride( uint32_t stride_ ) & VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT && setStride( uint32_t stride_ ) && VULKAN_HPP_NOEXCEPT - { - stride = stride_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT & setInputRate( VertexInputRate inputRate_ ) & VULKAN_HPP_NOEXCEPT - { - inputRate = inputRate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT && setInputRate( VertexInputRate inputRate_ ) && VULKAN_HPP_NOEXCEPT - { - inputRate = inputRate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT & setDivisor( uint32_t divisor_ ) & VULKAN_HPP_NOEXCEPT - { - divisor = divisor_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VertexInputBindingDescription2EXT && setDivisor( uint32_t divisor_ ) && VULKAN_HPP_NOEXCEPT - { - divisor = divisor_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVertexInputBindingDescription2EXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVertexInputBindingDescription2EXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVertexInputBindingDescription2EXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVertexInputBindingDescription2EXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, binding, stride, inputRate, divisor ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VertexInputBindingDescription2EXT const & ) const = default; -#else - bool operator==( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( binding == rhs.binding ) && ( stride == rhs.stride ) && ( inputRate == rhs.inputRate ) && - ( divisor == rhs.divisor ); -# endif - } - - bool operator!=( VertexInputBindingDescription2EXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVertexInputBindingDescription2EXT; - void * pNext = {}; - uint32_t binding = {}; - uint32_t stride = {}; - VertexInputRate inputRate = VertexInputRate::eVertex; - uint32_t divisor = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VertexInputBindingDescription2EXT; - }; -#endif - - template <> - struct CppType - { - using Type = VertexInputBindingDescription2EXT; - }; - -#if defined( VK_USE_PLATFORM_VI_NN ) - // wrapper struct for struct VkViSurfaceCreateInfoNN, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkViSurfaceCreateInfoNN.html - struct ViSurfaceCreateInfoNN - { - using NativeType = VkViSurfaceCreateInfoNN; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eViSurfaceCreateInfoNN; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( ViSurfaceCreateFlagsNN flags_ = {}, void * window_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , window{ window_ } - { - } - - VULKAN_HPP_CONSTEXPR ViSurfaceCreateInfoNN( ViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - ViSurfaceCreateInfoNN( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT - : ViSurfaceCreateInfoNN( *reinterpret_cast( &rhs ) ) - { - } - - ViSurfaceCreateInfoNN & operator=( ViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - ViSurfaceCreateInfoNN & operator=( VkViSurfaceCreateInfoNN const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN & setFlags( ViSurfaceCreateFlagsNN flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN && setFlags( ViSurfaceCreateFlagsNN flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN & setWindow( void * window_ ) & VULKAN_HPP_NOEXCEPT - { - window = window_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 ViSurfaceCreateInfoNN && setWindow( void * window_ ) && VULKAN_HPP_NOEXCEPT - { - window = window_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkViSurfaceCreateInfoNN const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkViSurfaceCreateInfoNN &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkViSurfaceCreateInfoNN const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkViSurfaceCreateInfoNN *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, window ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( ViSurfaceCreateInfoNN const & ) const = default; -# else - bool operator==( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( window == rhs.window ); -# endif - } - - bool operator!=( ViSurfaceCreateInfoNN const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eViSurfaceCreateInfoNN; - const void * pNext = {}; - ViSurfaceCreateFlagsNN flags = {}; - void * window = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = ViSurfaceCreateInfoNN; - }; -# endif - - template <> - struct CppType - { - using Type = ViSurfaceCreateInfoNN; - }; -#endif /*VK_USE_PLATFORM_VI_NN*/ - - // wrapper struct for struct VkVideoPictureResourceInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoPictureResourceInfoKHR.html - struct VideoPictureResourceInfoKHR - { - using NativeType = VkVideoPictureResourceInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoPictureResourceInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoPictureResourceInfoKHR( Offset2D codedOffset_ = {}, - Extent2D codedExtent_ = {}, - uint32_t baseArrayLayer_ = {}, - ImageView imageViewBinding_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , codedOffset{ codedOffset_ } - , codedExtent{ codedExtent_ } - , baseArrayLayer{ baseArrayLayer_ } - , imageViewBinding{ imageViewBinding_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoPictureResourceInfoKHR( VideoPictureResourceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoPictureResourceInfoKHR( VkVideoPictureResourceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoPictureResourceInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoPictureResourceInfoKHR & operator=( VideoPictureResourceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoPictureResourceInfoKHR & operator=( VkVideoPictureResourceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR & setCodedOffset( Offset2D const & codedOffset_ ) & VULKAN_HPP_NOEXCEPT - { - codedOffset = codedOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR && setCodedOffset( Offset2D const & codedOffset_ ) && VULKAN_HPP_NOEXCEPT - { - codedOffset = codedOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR & setCodedExtent( Extent2D const & codedExtent_ ) & VULKAN_HPP_NOEXCEPT - { - codedExtent = codedExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR && setCodedExtent( Extent2D const & codedExtent_ ) && VULKAN_HPP_NOEXCEPT - { - codedExtent = codedExtent_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR & setBaseArrayLayer( uint32_t baseArrayLayer_ ) & VULKAN_HPP_NOEXCEPT - { - baseArrayLayer = baseArrayLayer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR && setBaseArrayLayer( uint32_t baseArrayLayer_ ) && VULKAN_HPP_NOEXCEPT - { - baseArrayLayer = baseArrayLayer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR & setImageViewBinding( ImageView imageViewBinding_ ) & VULKAN_HPP_NOEXCEPT - { - imageViewBinding = imageViewBinding_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoPictureResourceInfoKHR && setImageViewBinding( ImageView imageViewBinding_ ) && VULKAN_HPP_NOEXCEPT - { - imageViewBinding = imageViewBinding_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoPictureResourceInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoPictureResourceInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoPictureResourceInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoPictureResourceInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, codedOffset, codedExtent, baseArrayLayer, imageViewBinding ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoPictureResourceInfoKHR const & ) const = default; -#else - bool operator==( VideoPictureResourceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( codedOffset == rhs.codedOffset ) && ( codedExtent == rhs.codedExtent ) && - ( baseArrayLayer == rhs.baseArrayLayer ) && ( imageViewBinding == rhs.imageViewBinding ); -# endif - } - - bool operator!=( VideoPictureResourceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoPictureResourceInfoKHR; - const void * pNext = {}; - Offset2D codedOffset = {}; - Extent2D codedExtent = {}; - uint32_t baseArrayLayer = {}; - ImageView imageViewBinding = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoPictureResourceInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoPictureResourceInfoKHR; - }; - - // wrapper struct for struct VkVideoReferenceSlotInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoReferenceSlotInfoKHR.html - struct VideoReferenceSlotInfoKHR - { - using NativeType = VkVideoReferenceSlotInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoReferenceSlotInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoReferenceSlotInfoKHR( int32_t slotIndex_ = {}, - const VideoPictureResourceInfoKHR * pPictureResource_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , slotIndex{ slotIndex_ } - , pPictureResource{ pPictureResource_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoReferenceSlotInfoKHR( VideoReferenceSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoReferenceSlotInfoKHR( VkVideoReferenceSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoReferenceSlotInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoReferenceSlotInfoKHR & operator=( VideoReferenceSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoReferenceSlotInfoKHR & operator=( VkVideoReferenceSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR & setSlotIndex( int32_t slotIndex_ ) & VULKAN_HPP_NOEXCEPT - { - slotIndex = slotIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR && setSlotIndex( int32_t slotIndex_ ) && VULKAN_HPP_NOEXCEPT - { - slotIndex = slotIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR & setPPictureResource( const VideoPictureResourceInfoKHR * pPictureResource_ ) & VULKAN_HPP_NOEXCEPT - { - pPictureResource = pPictureResource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoReferenceSlotInfoKHR && setPPictureResource( const VideoPictureResourceInfoKHR * pPictureResource_ ) && VULKAN_HPP_NOEXCEPT - { - pPictureResource = pPictureResource_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoReferenceSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoReferenceSlotInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoReferenceSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoReferenceSlotInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, slotIndex, pPictureResource ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoReferenceSlotInfoKHR const & ) const = default; -#else - bool operator==( VideoReferenceSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( slotIndex == rhs.slotIndex ) && ( pPictureResource == rhs.pPictureResource ); -# endif - } - - bool operator!=( VideoReferenceSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoReferenceSlotInfoKHR; - const void * pNext = {}; - int32_t slotIndex = {}; - const VideoPictureResourceInfoKHR * pPictureResource = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoReferenceSlotInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoReferenceSlotInfoKHR; - }; - - // wrapper struct for struct VkVideoBeginCodingInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoBeginCodingInfoKHR.html - struct VideoBeginCodingInfoKHR - { - using NativeType = VkVideoBeginCodingInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoBeginCodingInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoBeginCodingInfoKHR( VideoBeginCodingFlagsKHR flags_ = {}, - VideoSessionKHR videoSession_ = {}, - VideoSessionParametersKHR videoSessionParameters_ = {}, - uint32_t referenceSlotCount_ = {}, - const VideoReferenceSlotInfoKHR * pReferenceSlots_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , videoSession{ videoSession_ } - , videoSessionParameters{ videoSessionParameters_ } - , referenceSlotCount{ referenceSlotCount_ } - , pReferenceSlots{ pReferenceSlots_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoBeginCodingInfoKHR( VideoBeginCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoBeginCodingInfoKHR( VkVideoBeginCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoBeginCodingInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoBeginCodingInfoKHR( VideoBeginCodingFlagsKHR flags_, - VideoSessionKHR videoSession_, - VideoSessionParametersKHR videoSessionParameters_, - ArrayProxyNoTemporaries const & referenceSlots_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , videoSession( videoSession_ ) - , videoSessionParameters( videoSessionParameters_ ) - , referenceSlotCount( static_cast( referenceSlots_.size() ) ) - , pReferenceSlots( referenceSlots_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoBeginCodingInfoKHR & operator=( VideoBeginCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoBeginCodingInfoKHR & operator=( VkVideoBeginCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setFlags( VideoBeginCodingFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setFlags( VideoBeginCodingFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setVideoSession( VideoSessionKHR videoSession_ ) & VULKAN_HPP_NOEXCEPT - { - videoSession = videoSession_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setVideoSession( VideoSessionKHR videoSession_ ) && VULKAN_HPP_NOEXCEPT - { - videoSession = videoSession_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setVideoSessionParameters( VideoSessionParametersKHR videoSessionParameters_ ) & VULKAN_HPP_NOEXCEPT - { - videoSessionParameters = videoSessionParameters_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setVideoSessionParameters( VideoSessionParametersKHR videoSessionParameters_ ) && VULKAN_HPP_NOEXCEPT - { - videoSessionParameters = videoSessionParameters_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setReferenceSlotCount( uint32_t referenceSlotCount_ ) & VULKAN_HPP_NOEXCEPT - { - referenceSlotCount = referenceSlotCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setReferenceSlotCount( uint32_t referenceSlotCount_ ) && VULKAN_HPP_NOEXCEPT - { - referenceSlotCount = referenceSlotCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR & setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) & VULKAN_HPP_NOEXCEPT - { - pReferenceSlots = pReferenceSlots_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoBeginCodingInfoKHR && setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) && VULKAN_HPP_NOEXCEPT - { - pReferenceSlots = pReferenceSlots_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoBeginCodingInfoKHR & setReferenceSlots( ArrayProxyNoTemporaries const & referenceSlots_ ) VULKAN_HPP_NOEXCEPT - { - referenceSlotCount = static_cast( referenceSlots_.size() ); - pReferenceSlots = referenceSlots_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoBeginCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoBeginCodingInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoBeginCodingInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoBeginCodingInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, videoSession, videoSessionParameters, referenceSlotCount, pReferenceSlots ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoBeginCodingInfoKHR const & ) const = default; -#else - bool operator==( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( videoSession == rhs.videoSession ) && - ( videoSessionParameters == rhs.videoSessionParameters ) && ( referenceSlotCount == rhs.referenceSlotCount ) && - ( pReferenceSlots == rhs.pReferenceSlots ); -# endif - } - - bool operator!=( VideoBeginCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoBeginCodingInfoKHR; - const void * pNext = {}; - VideoBeginCodingFlagsKHR flags = {}; - VideoSessionKHR videoSession = {}; - VideoSessionParametersKHR videoSessionParameters = {}; - uint32_t referenceSlotCount = {}; - const VideoReferenceSlotInfoKHR * pReferenceSlots = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoBeginCodingInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoBeginCodingInfoKHR; - }; - - // wrapper struct for struct VkVideoCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCapabilitiesKHR.html - struct VideoCapabilitiesKHR - { - using NativeType = VkVideoCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 VideoCapabilitiesKHR( VideoCapabilityFlagsKHR flags_ = {}, - DeviceSize minBitstreamBufferOffsetAlignment_ = {}, - DeviceSize minBitstreamBufferSizeAlignment_ = {}, - Extent2D pictureAccessGranularity_ = {}, - Extent2D minCodedExtent_ = {}, - Extent2D maxCodedExtent_ = {}, - uint32_t maxDpbSlots_ = {}, - uint32_t maxActiveReferencePictures_ = {}, - ExtensionProperties stdHeaderVersion_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , minBitstreamBufferOffsetAlignment{ minBitstreamBufferOffsetAlignment_ } - , minBitstreamBufferSizeAlignment{ minBitstreamBufferSizeAlignment_ } - , pictureAccessGranularity{ pictureAccessGranularity_ } - , minCodedExtent{ minCodedExtent_ } - , maxCodedExtent{ maxCodedExtent_ } - , maxDpbSlots{ maxDpbSlots_ } - , maxActiveReferencePictures{ maxActiveReferencePictures_ } - , stdHeaderVersion{ stdHeaderVersion_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 VideoCapabilitiesKHR( VideoCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoCapabilitiesKHR( VkVideoCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoCapabilitiesKHR & operator=( VideoCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoCapabilitiesKHR & operator=( VkVideoCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - minBitstreamBufferOffsetAlignment, - minBitstreamBufferSizeAlignment, - pictureAccessGranularity, - minCodedExtent, - maxCodedExtent, - maxDpbSlots, - maxActiveReferencePictures, - stdHeaderVersion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoCapabilitiesKHR const & ) const = default; -#else - bool operator==( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( minBitstreamBufferOffsetAlignment == rhs.minBitstreamBufferOffsetAlignment ) && - ( minBitstreamBufferSizeAlignment == rhs.minBitstreamBufferSizeAlignment ) && ( pictureAccessGranularity == rhs.pictureAccessGranularity ) && - ( minCodedExtent == rhs.minCodedExtent ) && ( maxCodedExtent == rhs.maxCodedExtent ) && ( maxDpbSlots == rhs.maxDpbSlots ) && - ( maxActiveReferencePictures == rhs.maxActiveReferencePictures ) && ( stdHeaderVersion == rhs.stdHeaderVersion ); -# endif - } - - bool operator!=( VideoCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoCapabilitiesKHR; - void * pNext = {}; - VideoCapabilityFlagsKHR flags = {}; - DeviceSize minBitstreamBufferOffsetAlignment = {}; - DeviceSize minBitstreamBufferSizeAlignment = {}; - Extent2D pictureAccessGranularity = {}; - Extent2D minCodedExtent = {}; - Extent2D maxCodedExtent = {}; - uint32_t maxDpbSlots = {}; - uint32_t maxActiveReferencePictures = {}; - ExtensionProperties stdHeaderVersion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoCapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoCodingControlInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoCodingControlInfoKHR.html - struct VideoCodingControlInfoKHR - { - using NativeType = VkVideoCodingControlInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoCodingControlInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoCodingControlInfoKHR( VideoCodingControlFlagsKHR flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoCodingControlInfoKHR( VideoCodingControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoCodingControlInfoKHR( VkVideoCodingControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoCodingControlInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoCodingControlInfoKHR & operator=( VideoCodingControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoCodingControlInfoKHR & operator=( VkVideoCodingControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoCodingControlInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoCodingControlInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoCodingControlInfoKHR & setFlags( VideoCodingControlFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoCodingControlInfoKHR && setFlags( VideoCodingControlFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoCodingControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoCodingControlInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoCodingControlInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoCodingControlInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoCodingControlInfoKHR const & ) const = default; -#else - bool operator==( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( VideoCodingControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoCodingControlInfoKHR; - const void * pNext = {}; - VideoCodingControlFlagsKHR flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoCodingControlInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoCodingControlInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeAV1CapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1CapabilitiesKHR.html - struct VideoDecodeAV1CapabilitiesKHR - { - using NativeType = VkVideoDecodeAV1CapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1CapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeAV1CapabilitiesKHR( StdVideoAV1Level maxLevel_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxLevel{ maxLevel_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeAV1CapabilitiesKHR( VideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeAV1CapabilitiesKHR( VkVideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeAV1CapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeAV1CapabilitiesKHR & operator=( VideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeAV1CapabilitiesKHR & operator=( VkVideoDecodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoDecodeAV1CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxLevel ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ) == 0 ); - } - - bool operator!=( VideoDecodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoDecodeAv1CapabilitiesKHR; - void * pNext = {}; - StdVideoAV1Level maxLevel = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeAV1CapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeAV1CapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoDecodeAV1DpbSlotInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1DpbSlotInfoKHR.html - struct VideoDecodeAV1DpbSlotInfoKHR - { - using NativeType = VkVideoDecodeAV1DpbSlotInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1DpbSlotInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeAV1DpbSlotInfoKHR( const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdReferenceInfo{ pStdReferenceInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeAV1DpbSlotInfoKHR( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeAV1DpbSlotInfoKHR( VkVideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeAV1DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeAV1DpbSlotInfoKHR & operator=( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeAV1DpbSlotInfoKHR & operator=( VkVideoDecodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeAV1DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdReferenceInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeAV1DpbSlotInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); -# endif - } - - bool operator!=( VideoDecodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeAv1DpbSlotInfoKHR; - const void * pNext = {}; - const StdVideoDecodeAV1ReferenceInfo * pStdReferenceInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeAV1DpbSlotInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeAV1DpbSlotInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeAV1InlineSessionParametersInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1InlineSessionParametersInfoKHR.html - struct VideoDecodeAV1InlineSessionParametersInfoKHR - { - using NativeType = VkVideoDecodeAV1InlineSessionParametersInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeAV1InlineSessionParametersInfoKHR( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdSequenceHeader{ pStdSequenceHeader_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeAV1InlineSessionParametersInfoKHR( VideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeAV1InlineSessionParametersInfoKHR( VkVideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeAV1InlineSessionParametersInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeAV1InlineSessionParametersInfoKHR & operator=( VideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeAV1InlineSessionParametersInfoKHR & operator=( VkVideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1InlineSessionParametersInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1InlineSessionParametersInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1InlineSessionParametersInfoKHR & setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdSequenceHeader = pStdSequenceHeader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1InlineSessionParametersInfoKHR && setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdSequenceHeader = pStdSequenceHeader_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeAV1InlineSessionParametersInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1InlineSessionParametersInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1InlineSessionParametersInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1InlineSessionParametersInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdSequenceHeader ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeAV1InlineSessionParametersInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdSequenceHeader == rhs.pStdSequenceHeader ); -# endif - } - - bool operator!=( VideoDecodeAV1InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR; - const void * pNext = {}; - const StdVideoAV1SequenceHeader * pStdSequenceHeader = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeAV1InlineSessionParametersInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeAV1InlineSessionParametersInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeAV1PictureInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1PictureInfoKHR.html - struct VideoDecodeAV1PictureInfoKHR - { - using NativeType = VkVideoDecodeAV1PictureInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1PictureInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_ = {}, - std::array const & referenceNameSlotIndices_ = {}, - uint32_t frameHeaderOffset_ = {}, - uint32_t tileCount_ = {}, - const uint32_t * pTileOffsets_ = {}, - const uint32_t * pTileSizes_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdPictureInfo{ pStdPictureInfo_ } - , referenceNameSlotIndices{ referenceNameSlotIndices_ } - , frameHeaderOffset{ frameHeaderOffset_ } - , tileCount{ tileCount_ } - , pTileOffsets{ pTileOffsets_ } - , pTileSizes{ pTileSizes_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR( VideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeAV1PictureInfoKHR( VkVideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeAV1PictureInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeAV1PictureInfoKHR( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_, - std::array const & referenceNameSlotIndices_, - uint32_t frameHeaderOffset_, - ArrayProxyNoTemporaries const & tileOffsets_, - ArrayProxyNoTemporaries const & tileSizes_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , pStdPictureInfo( pStdPictureInfo_ ) - , referenceNameSlotIndices( referenceNameSlotIndices_ ) - , frameHeaderOffset( frameHeaderOffset_ ) - , tileCount( static_cast( tileOffsets_.size() ) ) - , pTileOffsets( tileOffsets_.data() ) - , pTileSizes( tileSizes_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( tileOffsets_.size() == tileSizes_.size() ); -# else - if ( tileOffsets_.size() != tileSizes_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::VideoDecodeAV1PictureInfoKHR::VideoDecodeAV1PictureInfoKHR: tileOffsets_.size() != tileSizes_.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoDecodeAV1PictureInfoKHR & operator=( VideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeAV1PictureInfoKHR & operator=( VkVideoDecodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPStdPictureInfo( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setPStdPictureInfo( const StdVideoDecodeAV1PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & - setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) & - VULKAN_HPP_NOEXCEPT - { - referenceNameSlotIndices = referenceNameSlotIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && - setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) && - VULKAN_HPP_NOEXCEPT - { - referenceNameSlotIndices = referenceNameSlotIndices_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setFrameHeaderOffset( uint32_t frameHeaderOffset_ ) & VULKAN_HPP_NOEXCEPT - { - frameHeaderOffset = frameHeaderOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setFrameHeaderOffset( uint32_t frameHeaderOffset_ ) && VULKAN_HPP_NOEXCEPT - { - frameHeaderOffset = frameHeaderOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setTileCount( uint32_t tileCount_ ) & VULKAN_HPP_NOEXCEPT - { - tileCount = tileCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setTileCount( uint32_t tileCount_ ) && VULKAN_HPP_NOEXCEPT - { - tileCount = tileCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPTileOffsets( const uint32_t * pTileOffsets_ ) & VULKAN_HPP_NOEXCEPT - { - pTileOffsets = pTileOffsets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setPTileOffsets( const uint32_t * pTileOffsets_ ) && VULKAN_HPP_NOEXCEPT - { - pTileOffsets = pTileOffsets_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeAV1PictureInfoKHR & setTileOffsets( ArrayProxyNoTemporaries const & tileOffsets_ ) VULKAN_HPP_NOEXCEPT - { - tileCount = static_cast( tileOffsets_.size() ); - pTileOffsets = tileOffsets_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR & setPTileSizes( const uint32_t * pTileSizes_ ) & VULKAN_HPP_NOEXCEPT - { - pTileSizes = pTileSizes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1PictureInfoKHR && setPTileSizes( const uint32_t * pTileSizes_ ) && VULKAN_HPP_NOEXCEPT - { - pTileSizes = pTileSizes_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeAV1PictureInfoKHR & setTileSizes( ArrayProxyNoTemporaries const & tileSizes_ ) VULKAN_HPP_NOEXCEPT - { - tileCount = static_cast( tileSizes_.size() ); - pTileSizes = tileSizes_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeAV1PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1PictureInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1PictureInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - uint32_t const &, - uint32_t const &, - const uint32_t * const &, - const uint32_t * const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdPictureInfo, referenceNameSlotIndices, frameHeaderOffset, tileCount, pTileOffsets, pTileSizes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeAV1PictureInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && - ( referenceNameSlotIndices == rhs.referenceNameSlotIndices ) && ( frameHeaderOffset == rhs.frameHeaderOffset ) && ( tileCount == rhs.tileCount ) && - ( pTileOffsets == rhs.pTileOffsets ) && ( pTileSizes == rhs.pTileSizes ); -# endif - } - - bool operator!=( VideoDecodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeAv1PictureInfoKHR; - const void * pNext = {}; - const StdVideoDecodeAV1PictureInfo * pStdPictureInfo = {}; - ArrayWrapper1D referenceNameSlotIndices = {}; - uint32_t frameHeaderOffset = {}; - uint32_t tileCount = {}; - const uint32_t * pTileOffsets = {}; - const uint32_t * pTileSizes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeAV1PictureInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeAV1PictureInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeAV1ProfileInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1ProfileInfoKHR.html - struct VideoDecodeAV1ProfileInfoKHR - { - using NativeType = VkVideoDecodeAV1ProfileInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1ProfileInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoDecodeAV1ProfileInfoKHR( StdVideoAV1Profile stdProfile_ = {}, Bool32 filmGrainSupport_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stdProfile{ stdProfile_ } - , filmGrainSupport{ filmGrainSupport_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeAV1ProfileInfoKHR( VideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeAV1ProfileInfoKHR( VkVideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeAV1ProfileInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeAV1ProfileInfoKHR & operator=( VideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeAV1ProfileInfoKHR & operator=( VkVideoDecodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setStdProfile( StdVideoAV1Profile stdProfile_ ) & VULKAN_HPP_NOEXCEPT - { - stdProfile = stdProfile_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR && setStdProfile( StdVideoAV1Profile stdProfile_ ) && VULKAN_HPP_NOEXCEPT - { - stdProfile = stdProfile_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR & setFilmGrainSupport( Bool32 filmGrainSupport_ ) & VULKAN_HPP_NOEXCEPT - { - filmGrainSupport = filmGrainSupport_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1ProfileInfoKHR && setFilmGrainSupport( Bool32 filmGrainSupport_ ) && VULKAN_HPP_NOEXCEPT - { - filmGrainSupport = filmGrainSupport_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeAV1ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stdProfile, filmGrainSupport ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = filmGrainSupport <=> rhs.filmGrainSupport; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ) == 0 ) && - ( filmGrainSupport == rhs.filmGrainSupport ); - } - - bool operator!=( VideoDecodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoDecodeAv1ProfileInfoKHR; - const void * pNext = {}; - StdVideoAV1Profile stdProfile = {}; - Bool32 filmGrainSupport = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeAV1ProfileInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeAV1ProfileInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeAV1SessionParametersCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeAV1SessionParametersCreateInfoKHR.html - struct VideoDecodeAV1SessionParametersCreateInfoKHR - { - using NativeType = VkVideoDecodeAV1SessionParametersCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeAV1SessionParametersCreateInfoKHR( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdSequenceHeader{ pStdSequenceHeader_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeAV1SessionParametersCreateInfoKHR( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeAV1SessionParametersCreateInfoKHR( VkVideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeAV1SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeAV1SessionParametersCreateInfoKHR & operator=( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeAV1SessionParametersCreateInfoKHR & operator=( VkVideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR & setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdSequenceHeader = pStdSequenceHeader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeAV1SessionParametersCreateInfoKHR && setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdSequenceHeader = pStdSequenceHeader_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeAV1SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeAV1SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdSequenceHeader ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeAV1SessionParametersCreateInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdSequenceHeader == rhs.pStdSequenceHeader ); -# endif - } - - bool operator!=( VideoDecodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR; - const void * pNext = {}; - const StdVideoAV1SequenceHeader * pStdSequenceHeader = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeAV1SessionParametersCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeAV1SessionParametersCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeCapabilitiesKHR.html - struct VideoDecodeCapabilitiesKHR - { - using NativeType = VkVideoDecodeCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeCapabilitiesKHR( VideoDecodeCapabilityFlagsKHR flags_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeCapabilitiesKHR( VideoDecodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeCapabilitiesKHR( VkVideoDecodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeCapabilitiesKHR & operator=( VideoDecodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeCapabilitiesKHR & operator=( VkVideoDecodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoDecodeCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeCapabilitiesKHR const & ) const = default; -#else - bool operator==( VideoDecodeCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( VideoDecodeCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeCapabilitiesKHR; - void * pNext = {}; - VideoDecodeCapabilityFlagsKHR flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeCapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoDecodeH264CapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264CapabilitiesKHR.html - struct VideoDecodeH264CapabilitiesKHR - { - using NativeType = VkVideoDecodeH264CapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264CapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH264CapabilitiesKHR( StdVideoH264LevelIdc maxLevelIdc_ = {}, - Offset2D fieldOffsetGranularity_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxLevelIdc{ maxLevelIdc_ } - , fieldOffsetGranularity{ fieldOffsetGranularity_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeH264CapabilitiesKHR( VideoDecodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH264CapabilitiesKHR( VkVideoDecodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH264CapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeH264CapabilitiesKHR & operator=( VideoDecodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH264CapabilitiesKHR & operator=( VkVideoDecodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoDecodeH264CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH264CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxLevelIdc, fieldOffsetGranularity ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoDecodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = fieldOffsetGranularity <=> rhs.fieldOffsetGranularity; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoDecodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ) == 0 ) && - ( fieldOffsetGranularity == rhs.fieldOffsetGranularity ); - } - - bool operator!=( VideoDecodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoDecodeH264CapabilitiesKHR; - void * pNext = {}; - StdVideoH264LevelIdc maxLevelIdc = {}; - Offset2D fieldOffsetGranularity = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH264CapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH264CapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoDecodeH264DpbSlotInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264DpbSlotInfoKHR.html - struct VideoDecodeH264DpbSlotInfoKHR - { - using NativeType = VkVideoDecodeH264DpbSlotInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264DpbSlotInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH264DpbSlotInfoKHR( const StdVideoDecodeH264ReferenceInfo * pStdReferenceInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdReferenceInfo{ pStdReferenceInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeH264DpbSlotInfoKHR( VideoDecodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH264DpbSlotInfoKHR( VkVideoDecodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH264DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeH264DpbSlotInfoKHR & operator=( VideoDecodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH264DpbSlotInfoKHR & operator=( VkVideoDecodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoDecodeH264ReferenceInfo * pStdReferenceInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoDecodeH264ReferenceInfo * pStdReferenceInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH264DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH264DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdReferenceInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeH264DpbSlotInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeH264DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); -# endif - } - - bool operator!=( VideoDecodeH264DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeH264DpbSlotInfoKHR; - const void * pNext = {}; - const StdVideoDecodeH264ReferenceInfo * pStdReferenceInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH264DpbSlotInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH264DpbSlotInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeH264InlineSessionParametersInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264InlineSessionParametersInfoKHR.html - struct VideoDecodeH264InlineSessionParametersInfoKHR - { - using NativeType = VkVideoDecodeH264InlineSessionParametersInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH264InlineSessionParametersInfoKHR( const StdVideoH264SequenceParameterSet * pStdSPS_ = {}, - const StdVideoH264PictureParameterSet * pStdPPS_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdSPS{ pStdSPS_ } - , pStdPPS{ pStdPPS_ } - { - } - - VULKAN_HPP_CONSTEXPR - VideoDecodeH264InlineSessionParametersInfoKHR( VideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH264InlineSessionParametersInfoKHR( VkVideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH264InlineSessionParametersInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeH264InlineSessionParametersInfoKHR & operator=( VideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH264InlineSessionParametersInfoKHR & operator=( VkVideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR & setPStdSPS( const StdVideoH264SequenceParameterSet * pStdSPS_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdSPS = pStdSPS_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR && setPStdSPS( const StdVideoH264SequenceParameterSet * pStdSPS_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdSPS = pStdSPS_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR & setPStdPPS( const StdVideoH264PictureParameterSet * pStdPPS_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPPS = pStdPPS_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264InlineSessionParametersInfoKHR && setPStdPPS( const StdVideoH264PictureParameterSet * pStdPPS_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdPPS = pStdPPS_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH264InlineSessionParametersInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264InlineSessionParametersInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264InlineSessionParametersInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH264InlineSessionParametersInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdSPS, pStdPPS ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeH264InlineSessionParametersInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdSPS == rhs.pStdSPS ) && ( pStdPPS == rhs.pStdPPS ); -# endif - } - - bool operator!=( VideoDecodeH264InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR; - const void * pNext = {}; - const StdVideoH264SequenceParameterSet * pStdSPS = {}; - const StdVideoH264PictureParameterSet * pStdPPS = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH264InlineSessionParametersInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH264InlineSessionParametersInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeH264PictureInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264PictureInfoKHR.html - struct VideoDecodeH264PictureInfoKHR - { - using NativeType = VkVideoDecodeH264PictureInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264PictureInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureInfoKHR( const StdVideoDecodeH264PictureInfo * pStdPictureInfo_ = {}, - uint32_t sliceCount_ = {}, - const uint32_t * pSliceOffsets_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdPictureInfo{ pStdPictureInfo_ } - , sliceCount{ sliceCount_ } - , pSliceOffsets{ pSliceOffsets_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeH264PictureInfoKHR( VideoDecodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH264PictureInfoKHR( VkVideoDecodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH264PictureInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeH264PictureInfoKHR( const StdVideoDecodeH264PictureInfo * pStdPictureInfo_, - ArrayProxyNoTemporaries const & sliceOffsets_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ), pStdPictureInfo( pStdPictureInfo_ ), sliceCount( static_cast( sliceOffsets_.size() ) ), pSliceOffsets( sliceOffsets_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoDecodeH264PictureInfoKHR & operator=( VideoDecodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH264PictureInfoKHR & operator=( VkVideoDecodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR & setPStdPictureInfo( const StdVideoDecodeH264PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR && setPStdPictureInfo( const StdVideoDecodeH264PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR & setSliceCount( uint32_t sliceCount_ ) & VULKAN_HPP_NOEXCEPT - { - sliceCount = sliceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR && setSliceCount( uint32_t sliceCount_ ) && VULKAN_HPP_NOEXCEPT - { - sliceCount = sliceCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR & setPSliceOffsets( const uint32_t * pSliceOffsets_ ) & VULKAN_HPP_NOEXCEPT - { - pSliceOffsets = pSliceOffsets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264PictureInfoKHR && setPSliceOffsets( const uint32_t * pSliceOffsets_ ) && VULKAN_HPP_NOEXCEPT - { - pSliceOffsets = pSliceOffsets_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeH264PictureInfoKHR & setSliceOffsets( ArrayProxyNoTemporaries const & sliceOffsets_ ) VULKAN_HPP_NOEXCEPT - { - sliceCount = static_cast( sliceOffsets_.size() ); - pSliceOffsets = sliceOffsets_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH264PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264PictureInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH264PictureInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdPictureInfo, sliceCount, pSliceOffsets ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeH264PictureInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeH264PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( sliceCount == rhs.sliceCount ) && - ( pSliceOffsets == rhs.pSliceOffsets ); -# endif - } - - bool operator!=( VideoDecodeH264PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeH264PictureInfoKHR; - const void * pNext = {}; - const StdVideoDecodeH264PictureInfo * pStdPictureInfo = {}; - uint32_t sliceCount = {}; - const uint32_t * pSliceOffsets = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH264PictureInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH264PictureInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeH264ProfileInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264ProfileInfoKHR.html - struct VideoDecodeH264ProfileInfoKHR - { - using NativeType = VkVideoDecodeH264ProfileInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264ProfileInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoDecodeH264ProfileInfoKHR( StdVideoH264ProfileIdc stdProfileIdc_ = {}, - VideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout_ = VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stdProfileIdc{ stdProfileIdc_ } - , pictureLayout{ pictureLayout_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeH264ProfileInfoKHR( VideoDecodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH264ProfileInfoKHR( VkVideoDecodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH264ProfileInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeH264ProfileInfoKHR & operator=( VideoDecodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH264ProfileInfoKHR & operator=( VkVideoDecodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR & setStdProfileIdc( StdVideoH264ProfileIdc stdProfileIdc_ ) & VULKAN_HPP_NOEXCEPT - { - stdProfileIdc = stdProfileIdc_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR && setStdProfileIdc( StdVideoH264ProfileIdc stdProfileIdc_ ) && VULKAN_HPP_NOEXCEPT - { - stdProfileIdc = stdProfileIdc_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR & setPictureLayout( VideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout_ ) & VULKAN_HPP_NOEXCEPT - { - pictureLayout = pictureLayout_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264ProfileInfoKHR && setPictureLayout( VideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout_ ) && VULKAN_HPP_NOEXCEPT - { - pictureLayout = pictureLayout_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH264ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH264ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stdProfileIdc, pictureLayout ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoDecodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = pictureLayout <=> rhs.pictureLayout; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoDecodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ) && - ( pictureLayout == rhs.pictureLayout ); - } - - bool operator!=( VideoDecodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoDecodeH264ProfileInfoKHR; - const void * pNext = {}; - StdVideoH264ProfileIdc stdProfileIdc = {}; - VideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout = VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH264ProfileInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH264ProfileInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeH264SessionParametersAddInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264SessionParametersAddInfoKHR.html - struct VideoDecodeH264SessionParametersAddInfoKHR - { - using NativeType = VkVideoDecodeH264SessionParametersAddInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264SessionParametersAddInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH264SessionParametersAddInfoKHR( uint32_t stdSPSCount_ = {}, - const StdVideoH264SequenceParameterSet * pStdSPSs_ = {}, - uint32_t stdPPSCount_ = {}, - const StdVideoH264PictureParameterSet * pStdPPSs_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stdSPSCount{ stdSPSCount_ } - , pStdSPSs{ pStdSPSs_ } - , stdPPSCount{ stdPPSCount_ } - , pStdPPSs{ pStdPPSs_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeH264SessionParametersAddInfoKHR( VideoDecodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH264SessionParametersAddInfoKHR( VkVideoDecodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH264SessionParametersAddInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeH264SessionParametersAddInfoKHR( ArrayProxyNoTemporaries const & stdSPSs_, - ArrayProxyNoTemporaries const & stdPPSs_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , stdSPSCount( static_cast( stdSPSs_.size() ) ) - , pStdSPSs( stdSPSs_.data() ) - , stdPPSCount( static_cast( stdPPSs_.size() ) ) - , pStdPPSs( stdPPSs_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoDecodeH264SessionParametersAddInfoKHR & operator=( VideoDecodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH264SessionParametersAddInfoKHR & operator=( VkVideoDecodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR & setStdSPSCount( uint32_t stdSPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - stdSPSCount = stdSPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR && setStdSPSCount( uint32_t stdSPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - stdSPSCount = stdSPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR & setPStdSPSs( const StdVideoH264SequenceParameterSet * pStdSPSs_ ) & VULKAN_HPP_NOEXCEPT - { - pStdSPSs = pStdSPSs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR && setPStdSPSs( const StdVideoH264SequenceParameterSet * pStdSPSs_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdSPSs = pStdSPSs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeH264SessionParametersAddInfoKHR & - setStdSPSs( ArrayProxyNoTemporaries const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT - { - stdSPSCount = static_cast( stdSPSs_.size() ); - pStdSPSs = stdSPSs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR & setStdPPSCount( uint32_t stdPPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - stdPPSCount = stdPPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR && setStdPPSCount( uint32_t stdPPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - stdPPSCount = stdPPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR & setPStdPPSs( const StdVideoH264PictureParameterSet * pStdPPSs_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPPSs = pStdPPSs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersAddInfoKHR && setPStdPPSs( const StdVideoH264PictureParameterSet * pStdPPSs_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdPPSs = pStdPPSs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeH264SessionParametersAddInfoKHR & - setStdPPSs( ArrayProxyNoTemporaries const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT - { - stdPPSCount = static_cast( stdPPSs_.size() ); - pStdPPSs = stdPPSs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH264SessionParametersAddInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264SessionParametersAddInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264SessionParametersAddInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH264SessionParametersAddInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeH264SessionParametersAddInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeH264SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && - ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs ); -# endif - } - - bool operator!=( VideoDecodeH264SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeH264SessionParametersAddInfoKHR; - const void * pNext = {}; - uint32_t stdSPSCount = {}; - const StdVideoH264SequenceParameterSet * pStdSPSs = {}; - uint32_t stdPPSCount = {}; - const StdVideoH264PictureParameterSet * pStdPPSs = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH264SessionParametersAddInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH264SessionParametersAddInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeH264SessionParametersCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH264SessionParametersCreateInfoKHR.html - struct VideoDecodeH264SessionParametersCreateInfoKHR - { - using NativeType = VkVideoDecodeH264SessionParametersCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH264SessionParametersCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH264SessionParametersCreateInfoKHR( uint32_t maxStdSPSCount_ = {}, - uint32_t maxStdPPSCount_ = {}, - const VideoDecodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxStdSPSCount{ maxStdSPSCount_ } - , maxStdPPSCount{ maxStdPPSCount_ } - , pParametersAddInfo{ pParametersAddInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR - VideoDecodeH264SessionParametersCreateInfoKHR( VideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH264SessionParametersCreateInfoKHR( VkVideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH264SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeH264SessionParametersCreateInfoKHR & operator=( VideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH264SessionParametersCreateInfoKHR & operator=( VkVideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxStdSPSCount = maxStdSPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR && setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxStdSPSCount = maxStdSPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxStdPPSCount = maxStdPPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR && setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxStdPPSCount = maxStdPPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR & - setPParametersAddInfo( const VideoDecodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pParametersAddInfo = pParametersAddInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH264SessionParametersCreateInfoKHR && - setPParametersAddInfo( const VideoDecodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pParametersAddInfo = pParametersAddInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH264SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH264SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH264SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeH264SessionParametersCreateInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && ( maxStdPPSCount == rhs.maxStdPPSCount ) && - ( pParametersAddInfo == rhs.pParametersAddInfo ); -# endif - } - - bool operator!=( VideoDecodeH264SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeH264SessionParametersCreateInfoKHR; - const void * pNext = {}; - uint32_t maxStdSPSCount = {}; - uint32_t maxStdPPSCount = {}; - const VideoDecodeH264SessionParametersAddInfoKHR * pParametersAddInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH264SessionParametersCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH264SessionParametersCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeH265CapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265CapabilitiesKHR.html - struct VideoDecodeH265CapabilitiesKHR - { - using NativeType = VkVideoDecodeH265CapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265CapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH265CapabilitiesKHR( StdVideoH265LevelIdc maxLevelIdc_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxLevelIdc{ maxLevelIdc_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeH265CapabilitiesKHR( VideoDecodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH265CapabilitiesKHR( VkVideoDecodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH265CapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeH265CapabilitiesKHR & operator=( VideoDecodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH265CapabilitiesKHR & operator=( VkVideoDecodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoDecodeH265CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH265CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxLevelIdc ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoDecodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoDecodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ) == 0 ); - } - - bool operator!=( VideoDecodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoDecodeH265CapabilitiesKHR; - void * pNext = {}; - StdVideoH265LevelIdc maxLevelIdc = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH265CapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH265CapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoDecodeH265DpbSlotInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265DpbSlotInfoKHR.html - struct VideoDecodeH265DpbSlotInfoKHR - { - using NativeType = VkVideoDecodeH265DpbSlotInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265DpbSlotInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH265DpbSlotInfoKHR( const StdVideoDecodeH265ReferenceInfo * pStdReferenceInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdReferenceInfo{ pStdReferenceInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeH265DpbSlotInfoKHR( VideoDecodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH265DpbSlotInfoKHR( VkVideoDecodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH265DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeH265DpbSlotInfoKHR & operator=( VideoDecodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH265DpbSlotInfoKHR & operator=( VkVideoDecodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoDecodeH265ReferenceInfo * pStdReferenceInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoDecodeH265ReferenceInfo * pStdReferenceInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH265DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH265DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdReferenceInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeH265DpbSlotInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeH265DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); -# endif - } - - bool operator!=( VideoDecodeH265DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeH265DpbSlotInfoKHR; - const void * pNext = {}; - const StdVideoDecodeH265ReferenceInfo * pStdReferenceInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH265DpbSlotInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH265DpbSlotInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeH265InlineSessionParametersInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265InlineSessionParametersInfoKHR.html - struct VideoDecodeH265InlineSessionParametersInfoKHR - { - using NativeType = VkVideoDecodeH265InlineSessionParametersInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH265InlineSessionParametersInfoKHR( const StdVideoH265VideoParameterSet * pStdVPS_ = {}, - const StdVideoH265SequenceParameterSet * pStdSPS_ = {}, - const StdVideoH265PictureParameterSet * pStdPPS_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdVPS{ pStdVPS_ } - , pStdSPS{ pStdSPS_ } - , pStdPPS{ pStdPPS_ } - { - } - - VULKAN_HPP_CONSTEXPR - VideoDecodeH265InlineSessionParametersInfoKHR( VideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH265InlineSessionParametersInfoKHR( VkVideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH265InlineSessionParametersInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeH265InlineSessionParametersInfoKHR & operator=( VideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH265InlineSessionParametersInfoKHR & operator=( VkVideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPStdVPS( const StdVideoH265VideoParameterSet * pStdVPS_ ) & VULKAN_HPP_NOEXCEPT - { - pStdVPS = pStdVPS_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR && setPStdVPS( const StdVideoH265VideoParameterSet * pStdVPS_ ) && VULKAN_HPP_NOEXCEPT - { - pStdVPS = pStdVPS_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPStdSPS( const StdVideoH265SequenceParameterSet * pStdSPS_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdSPS = pStdSPS_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR && setPStdSPS( const StdVideoH265SequenceParameterSet * pStdSPS_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdSPS = pStdSPS_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR & setPStdPPS( const StdVideoH265PictureParameterSet * pStdPPS_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPPS = pStdPPS_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265InlineSessionParametersInfoKHR && setPStdPPS( const StdVideoH265PictureParameterSet * pStdPPS_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdPPS = pStdPPS_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH265InlineSessionParametersInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265InlineSessionParametersInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265InlineSessionParametersInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH265InlineSessionParametersInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdVPS, pStdSPS, pStdPPS ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeH265InlineSessionParametersInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdVPS == rhs.pStdVPS ) && ( pStdSPS == rhs.pStdSPS ) && ( pStdPPS == rhs.pStdPPS ); -# endif - } - - bool operator!=( VideoDecodeH265InlineSessionParametersInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR; - const void * pNext = {}; - const StdVideoH265VideoParameterSet * pStdVPS = {}; - const StdVideoH265SequenceParameterSet * pStdSPS = {}; - const StdVideoH265PictureParameterSet * pStdPPS = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH265InlineSessionParametersInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH265InlineSessionParametersInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeH265PictureInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265PictureInfoKHR.html - struct VideoDecodeH265PictureInfoKHR - { - using NativeType = VkVideoDecodeH265PictureInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265PictureInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH265PictureInfoKHR( const StdVideoDecodeH265PictureInfo * pStdPictureInfo_ = {}, - uint32_t sliceSegmentCount_ = {}, - const uint32_t * pSliceSegmentOffsets_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdPictureInfo{ pStdPictureInfo_ } - , sliceSegmentCount{ sliceSegmentCount_ } - , pSliceSegmentOffsets{ pSliceSegmentOffsets_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeH265PictureInfoKHR( VideoDecodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH265PictureInfoKHR( VkVideoDecodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH265PictureInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeH265PictureInfoKHR( const StdVideoDecodeH265PictureInfo * pStdPictureInfo_, - ArrayProxyNoTemporaries const & sliceSegmentOffsets_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , pStdPictureInfo( pStdPictureInfo_ ) - , sliceSegmentCount( static_cast( sliceSegmentOffsets_.size() ) ) - , pSliceSegmentOffsets( sliceSegmentOffsets_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoDecodeH265PictureInfoKHR & operator=( VideoDecodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH265PictureInfoKHR & operator=( VkVideoDecodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR & setPStdPictureInfo( const StdVideoDecodeH265PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR && setPStdPictureInfo( const StdVideoDecodeH265PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR & setSliceSegmentCount( uint32_t sliceSegmentCount_ ) & VULKAN_HPP_NOEXCEPT - { - sliceSegmentCount = sliceSegmentCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR && setSliceSegmentCount( uint32_t sliceSegmentCount_ ) && VULKAN_HPP_NOEXCEPT - { - sliceSegmentCount = sliceSegmentCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR & setPSliceSegmentOffsets( const uint32_t * pSliceSegmentOffsets_ ) & VULKAN_HPP_NOEXCEPT - { - pSliceSegmentOffsets = pSliceSegmentOffsets_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265PictureInfoKHR && setPSliceSegmentOffsets( const uint32_t * pSliceSegmentOffsets_ ) && VULKAN_HPP_NOEXCEPT - { - pSliceSegmentOffsets = pSliceSegmentOffsets_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeH265PictureInfoKHR & setSliceSegmentOffsets( ArrayProxyNoTemporaries const & sliceSegmentOffsets_ ) VULKAN_HPP_NOEXCEPT - { - sliceSegmentCount = static_cast( sliceSegmentOffsets_.size() ); - pSliceSegmentOffsets = sliceSegmentOffsets_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH265PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265PictureInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH265PictureInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdPictureInfo, sliceSegmentCount, pSliceSegmentOffsets ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeH265PictureInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeH265PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( sliceSegmentCount == rhs.sliceSegmentCount ) && - ( pSliceSegmentOffsets == rhs.pSliceSegmentOffsets ); -# endif - } - - bool operator!=( VideoDecodeH265PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeH265PictureInfoKHR; - const void * pNext = {}; - const StdVideoDecodeH265PictureInfo * pStdPictureInfo = {}; - uint32_t sliceSegmentCount = {}; - const uint32_t * pSliceSegmentOffsets = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH265PictureInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH265PictureInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeH265ProfileInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265ProfileInfoKHR.html - struct VideoDecodeH265ProfileInfoKHR - { - using NativeType = VkVideoDecodeH265ProfileInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265ProfileInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH265ProfileInfoKHR( StdVideoH265ProfileIdc stdProfileIdc_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stdProfileIdc{ stdProfileIdc_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeH265ProfileInfoKHR( VideoDecodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH265ProfileInfoKHR( VkVideoDecodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH265ProfileInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeH265ProfileInfoKHR & operator=( VideoDecodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH265ProfileInfoKHR & operator=( VkVideoDecodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265ProfileInfoKHR & setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) & VULKAN_HPP_NOEXCEPT - { - stdProfileIdc = stdProfileIdc_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265ProfileInfoKHR && setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) && VULKAN_HPP_NOEXCEPT - { - stdProfileIdc = stdProfileIdc_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH265ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH265ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stdProfileIdc ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoDecodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoDecodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); - } - - bool operator!=( VideoDecodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoDecodeH265ProfileInfoKHR; - const void * pNext = {}; - StdVideoH265ProfileIdc stdProfileIdc = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH265ProfileInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH265ProfileInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeH265SessionParametersAddInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265SessionParametersAddInfoKHR.html - struct VideoDecodeH265SessionParametersAddInfoKHR - { - using NativeType = VkVideoDecodeH265SessionParametersAddInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265SessionParametersAddInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH265SessionParametersAddInfoKHR( uint32_t stdVPSCount_ = {}, - const StdVideoH265VideoParameterSet * pStdVPSs_ = {}, - uint32_t stdSPSCount_ = {}, - const StdVideoH265SequenceParameterSet * pStdSPSs_ = {}, - uint32_t stdPPSCount_ = {}, - const StdVideoH265PictureParameterSet * pStdPPSs_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stdVPSCount{ stdVPSCount_ } - , pStdVPSs{ pStdVPSs_ } - , stdSPSCount{ stdSPSCount_ } - , pStdSPSs{ pStdSPSs_ } - , stdPPSCount{ stdPPSCount_ } - , pStdPPSs{ pStdPPSs_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeH265SessionParametersAddInfoKHR( VideoDecodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH265SessionParametersAddInfoKHR( VkVideoDecodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH265SessionParametersAddInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeH265SessionParametersAddInfoKHR( ArrayProxyNoTemporaries const & stdVPSs_, - ArrayProxyNoTemporaries const & stdSPSs_ = {}, - ArrayProxyNoTemporaries const & stdPPSs_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , stdVPSCount( static_cast( stdVPSs_.size() ) ) - , pStdVPSs( stdVPSs_.data() ) - , stdSPSCount( static_cast( stdSPSs_.size() ) ) - , pStdSPSs( stdSPSs_.data() ) - , stdPPSCount( static_cast( stdPPSs_.size() ) ) - , pStdPPSs( stdPPSs_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoDecodeH265SessionParametersAddInfoKHR & operator=( VideoDecodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH265SessionParametersAddInfoKHR & operator=( VkVideoDecodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setStdVPSCount( uint32_t stdVPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - stdVPSCount = stdVPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setStdVPSCount( uint32_t stdVPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - stdVPSCount = stdVPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) & VULKAN_HPP_NOEXCEPT - { - pStdVPSs = pStdVPSs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) && VULKAN_HPP_NOEXCEPT - { - pStdVPSs = pStdVPSs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeH265SessionParametersAddInfoKHR & setStdVPSs( ArrayProxyNoTemporaries const & stdVPSs_ ) VULKAN_HPP_NOEXCEPT - { - stdVPSCount = static_cast( stdVPSs_.size() ); - pStdVPSs = stdVPSs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setStdSPSCount( uint32_t stdSPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - stdSPSCount = stdSPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setStdSPSCount( uint32_t stdSPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - stdSPSCount = stdSPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) & VULKAN_HPP_NOEXCEPT - { - pStdSPSs = pStdSPSs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdSPSs = pStdSPSs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeH265SessionParametersAddInfoKHR & - setStdSPSs( ArrayProxyNoTemporaries const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT - { - stdSPSCount = static_cast( stdSPSs_.size() ); - pStdSPSs = stdSPSs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setStdPPSCount( uint32_t stdPPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - stdPPSCount = stdPPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setStdPPSCount( uint32_t stdPPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - stdPPSCount = stdPPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR & setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPPSs = pStdPPSs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersAddInfoKHR && setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdPPSs = pStdPPSs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeH265SessionParametersAddInfoKHR & - setStdPPSs( ArrayProxyNoTemporaries const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT - { - stdPPSCount = static_cast( stdPPSs_.size() ); - pStdPPSs = stdPPSs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH265SessionParametersAddInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265SessionParametersAddInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265SessionParametersAddInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH265SessionParametersAddInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stdVPSCount, pStdVPSs, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeH265SessionParametersAddInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeH265SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdVPSCount == rhs.stdVPSCount ) && ( pStdVPSs == rhs.pStdVPSs ) && - ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs ); -# endif - } - - bool operator!=( VideoDecodeH265SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeH265SessionParametersAddInfoKHR; - const void * pNext = {}; - uint32_t stdVPSCount = {}; - const StdVideoH265VideoParameterSet * pStdVPSs = {}; - uint32_t stdSPSCount = {}; - const StdVideoH265SequenceParameterSet * pStdSPSs = {}; - uint32_t stdPPSCount = {}; - const StdVideoH265PictureParameterSet * pStdPPSs = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH265SessionParametersAddInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH265SessionParametersAddInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeH265SessionParametersCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeH265SessionParametersCreateInfoKHR.html - struct VideoDecodeH265SessionParametersCreateInfoKHR - { - using NativeType = VkVideoDecodeH265SessionParametersCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeH265SessionParametersCreateInfoKHR( uint32_t maxStdVPSCount_ = {}, - uint32_t maxStdSPSCount_ = {}, - uint32_t maxStdPPSCount_ = {}, - const VideoDecodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxStdVPSCount{ maxStdVPSCount_ } - , maxStdSPSCount{ maxStdSPSCount_ } - , maxStdPPSCount{ maxStdPPSCount_ } - , pParametersAddInfo{ pParametersAddInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR - VideoDecodeH265SessionParametersCreateInfoKHR( VideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeH265SessionParametersCreateInfoKHR( VkVideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeH265SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeH265SessionParametersCreateInfoKHR & operator=( VideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeH265SessionParametersCreateInfoKHR & operator=( VkVideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR & setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxStdVPSCount = maxStdVPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR && setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxStdVPSCount = maxStdVPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxStdSPSCount = maxStdSPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR && setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxStdSPSCount = maxStdSPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxStdPPSCount = maxStdPPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR && setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxStdPPSCount = maxStdPPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR & - setPParametersAddInfo( const VideoDecodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pParametersAddInfo = pParametersAddInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeH265SessionParametersCreateInfoKHR && - setPParametersAddInfo( const VideoDecodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pParametersAddInfo = pParametersAddInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeH265SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeH265SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeH265SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxStdVPSCount, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeH265SessionParametersCreateInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdVPSCount == rhs.maxStdVPSCount ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && - ( maxStdPPSCount == rhs.maxStdPPSCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); -# endif - } - - bool operator!=( VideoDecodeH265SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR; - const void * pNext = {}; - uint32_t maxStdVPSCount = {}; - uint32_t maxStdSPSCount = {}; - uint32_t maxStdPPSCount = {}; - const VideoDecodeH265SessionParametersAddInfoKHR * pParametersAddInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeH265SessionParametersCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeH265SessionParametersCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeInfoKHR.html - struct VideoDecodeInfoKHR - { - using NativeType = VkVideoDecodeInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeInfoKHR( VideoDecodeFlagsKHR flags_ = {}, - Buffer srcBuffer_ = {}, - DeviceSize srcBufferOffset_ = {}, - DeviceSize srcBufferRange_ = {}, - VideoPictureResourceInfoKHR dstPictureResource_ = {}, - const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ = {}, - uint32_t referenceSlotCount_ = {}, - const VideoReferenceSlotInfoKHR * pReferenceSlots_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , srcBuffer{ srcBuffer_ } - , srcBufferOffset{ srcBufferOffset_ } - , srcBufferRange{ srcBufferRange_ } - , dstPictureResource{ dstPictureResource_ } - , pSetupReferenceSlot{ pSetupReferenceSlot_ } - , referenceSlotCount{ referenceSlotCount_ } - , pReferenceSlots{ pReferenceSlots_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeInfoKHR( VideoDecodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeInfoKHR( VkVideoDecodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoDecodeInfoKHR( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeInfoKHR( VideoDecodeFlagsKHR flags_, - Buffer srcBuffer_, - DeviceSize srcBufferOffset_, - DeviceSize srcBufferRange_, - VideoPictureResourceInfoKHR dstPictureResource_, - const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_, - ArrayProxyNoTemporaries const & referenceSlots_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , srcBuffer( srcBuffer_ ) - , srcBufferOffset( srcBufferOffset_ ) - , srcBufferRange( srcBufferRange_ ) - , dstPictureResource( dstPictureResource_ ) - , pSetupReferenceSlot( pSetupReferenceSlot_ ) - , referenceSlotCount( static_cast( referenceSlots_.size() ) ) - , pReferenceSlots( referenceSlots_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoDecodeInfoKHR & operator=( VideoDecodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeInfoKHR & operator=( VkVideoDecodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setFlags( VideoDecodeFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setFlags( VideoDecodeFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setSrcBuffer( Buffer srcBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - srcBuffer = srcBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setSrcBuffer( Buffer srcBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - srcBuffer = srcBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setSrcBufferOffset( DeviceSize srcBufferOffset_ ) & VULKAN_HPP_NOEXCEPT - { - srcBufferOffset = srcBufferOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setSrcBufferOffset( DeviceSize srcBufferOffset_ ) && VULKAN_HPP_NOEXCEPT - { - srcBufferOffset = srcBufferOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setSrcBufferRange( DeviceSize srcBufferRange_ ) & VULKAN_HPP_NOEXCEPT - { - srcBufferRange = srcBufferRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setSrcBufferRange( DeviceSize srcBufferRange_ ) && VULKAN_HPP_NOEXCEPT - { - srcBufferRange = srcBufferRange_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setDstPictureResource( VideoPictureResourceInfoKHR const & dstPictureResource_ ) & VULKAN_HPP_NOEXCEPT - { - dstPictureResource = dstPictureResource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setDstPictureResource( VideoPictureResourceInfoKHR const & dstPictureResource_ ) && VULKAN_HPP_NOEXCEPT - { - dstPictureResource = dstPictureResource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setPSetupReferenceSlot( const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) & VULKAN_HPP_NOEXCEPT - { - pSetupReferenceSlot = pSetupReferenceSlot_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setPSetupReferenceSlot( const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) && VULKAN_HPP_NOEXCEPT - { - pSetupReferenceSlot = pSetupReferenceSlot_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setReferenceSlotCount( uint32_t referenceSlotCount_ ) & VULKAN_HPP_NOEXCEPT - { - referenceSlotCount = referenceSlotCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setReferenceSlotCount( uint32_t referenceSlotCount_ ) && VULKAN_HPP_NOEXCEPT - { - referenceSlotCount = referenceSlotCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR & setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) & VULKAN_HPP_NOEXCEPT - { - pReferenceSlots = pReferenceSlots_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeInfoKHR && setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) && VULKAN_HPP_NOEXCEPT - { - pReferenceSlots = pReferenceSlots_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoDecodeInfoKHR & setReferenceSlots( ArrayProxyNoTemporaries const & referenceSlots_ ) VULKAN_HPP_NOEXCEPT - { - referenceSlotCount = static_cast( referenceSlots_.size() ); - pReferenceSlots = referenceSlots_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( - sType, pNext, flags, srcBuffer, srcBufferOffset, srcBufferRange, dstPictureResource, pSetupReferenceSlot, referenceSlotCount, pReferenceSlots ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( srcBuffer == rhs.srcBuffer ) && - ( srcBufferOffset == rhs.srcBufferOffset ) && ( srcBufferRange == rhs.srcBufferRange ) && ( dstPictureResource == rhs.dstPictureResource ) && - ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) && - ( pReferenceSlots == rhs.pReferenceSlots ); -# endif - } - - bool operator!=( VideoDecodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeInfoKHR; - const void * pNext = {}; - VideoDecodeFlagsKHR flags = {}; - Buffer srcBuffer = {}; - DeviceSize srcBufferOffset = {}; - DeviceSize srcBufferRange = {}; - VideoPictureResourceInfoKHR dstPictureResource = {}; - const VideoReferenceSlotInfoKHR * pSetupReferenceSlot = {}; - uint32_t referenceSlotCount = {}; - const VideoReferenceSlotInfoKHR * pReferenceSlots = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeUsageInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeUsageInfoKHR.html - struct VideoDecodeUsageInfoKHR - { - using NativeType = VkVideoDecodeUsageInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeUsageInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeUsageInfoKHR( VideoDecodeUsageFlagsKHR videoUsageHints_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoUsageHints{ videoUsageHints_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeUsageInfoKHR( VideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeUsageInfoKHR( VkVideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeUsageInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeUsageInfoKHR & operator=( VideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeUsageInfoKHR & operator=( VkVideoDecodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeUsageInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeUsageInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeUsageInfoKHR & setVideoUsageHints( VideoDecodeUsageFlagsKHR videoUsageHints_ ) & VULKAN_HPP_NOEXCEPT - { - videoUsageHints = videoUsageHints_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeUsageInfoKHR && setVideoUsageHints( VideoDecodeUsageFlagsKHR videoUsageHints_ ) && VULKAN_HPP_NOEXCEPT - { - videoUsageHints = videoUsageHints_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeUsageInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeUsageInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeUsageInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeUsageInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoUsageHints ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeUsageInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeUsageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoUsageHints == rhs.videoUsageHints ); -# endif - } - - bool operator!=( VideoDecodeUsageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeUsageInfoKHR; - const void * pNext = {}; - VideoDecodeUsageFlagsKHR videoUsageHints = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeUsageInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeUsageInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeVP9CapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeVP9CapabilitiesKHR.html - struct VideoDecodeVP9CapabilitiesKHR - { - using NativeType = VkVideoDecodeVP9CapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeVp9CapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeVP9CapabilitiesKHR( StdVideoVP9Level maxLevel_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxLevel{ maxLevel_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeVP9CapabilitiesKHR( VideoDecodeVP9CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeVP9CapabilitiesKHR( VkVideoDecodeVP9CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeVP9CapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeVP9CapabilitiesKHR & operator=( VideoDecodeVP9CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeVP9CapabilitiesKHR & operator=( VkVideoDecodeVP9CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoDecodeVP9CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeVP9CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeVP9CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeVP9CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxLevel ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoDecodeVP9CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoVP9Level ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoDecodeVP9CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoVP9Level ) ) == 0 ); - } - - bool operator!=( VideoDecodeVP9CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoDecodeVp9CapabilitiesKHR; - void * pNext = {}; - StdVideoVP9Level maxLevel = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeVP9CapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeVP9CapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoDecodeVP9PictureInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeVP9PictureInfoKHR.html - struct VideoDecodeVP9PictureInfoKHR - { - using NativeType = VkVideoDecodeVP9PictureInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeVp9PictureInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR( const StdVideoDecodeVP9PictureInfo * pStdPictureInfo_ = {}, - std::array const & referenceNameSlotIndices_ = {}, - uint32_t uncompressedHeaderOffset_ = {}, - uint32_t compressedHeaderOffset_ = {}, - uint32_t tilesOffset_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdPictureInfo{ pStdPictureInfo_ } - , referenceNameSlotIndices{ referenceNameSlotIndices_ } - , uncompressedHeaderOffset{ uncompressedHeaderOffset_ } - , compressedHeaderOffset{ compressedHeaderOffset_ } - , tilesOffset{ tilesOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR( VideoDecodeVP9PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeVP9PictureInfoKHR( VkVideoDecodeVP9PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeVP9PictureInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeVP9PictureInfoKHR & operator=( VideoDecodeVP9PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeVP9PictureInfoKHR & operator=( VkVideoDecodeVP9PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & setPStdPictureInfo( const StdVideoDecodeVP9PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && setPStdPictureInfo( const StdVideoDecodeVP9PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & - setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) & - VULKAN_HPP_NOEXCEPT - { - referenceNameSlotIndices = referenceNameSlotIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && - setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) && - VULKAN_HPP_NOEXCEPT - { - referenceNameSlotIndices = referenceNameSlotIndices_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & setUncompressedHeaderOffset( uint32_t uncompressedHeaderOffset_ ) & VULKAN_HPP_NOEXCEPT - { - uncompressedHeaderOffset = uncompressedHeaderOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && setUncompressedHeaderOffset( uint32_t uncompressedHeaderOffset_ ) && VULKAN_HPP_NOEXCEPT - { - uncompressedHeaderOffset = uncompressedHeaderOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & setCompressedHeaderOffset( uint32_t compressedHeaderOffset_ ) & VULKAN_HPP_NOEXCEPT - { - compressedHeaderOffset = compressedHeaderOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && setCompressedHeaderOffset( uint32_t compressedHeaderOffset_ ) && VULKAN_HPP_NOEXCEPT - { - compressedHeaderOffset = compressedHeaderOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR & setTilesOffset( uint32_t tilesOffset_ ) & VULKAN_HPP_NOEXCEPT - { - tilesOffset = tilesOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9PictureInfoKHR && setTilesOffset( uint32_t tilesOffset_ ) && VULKAN_HPP_NOEXCEPT - { - tilesOffset = tilesOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeVP9PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeVP9PictureInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeVP9PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeVP9PictureInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - uint32_t const &, - uint32_t const &, - uint32_t const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdPictureInfo, referenceNameSlotIndices, uncompressedHeaderOffset, compressedHeaderOffset, tilesOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoDecodeVP9PictureInfoKHR const & ) const = default; -#else - bool operator==( VideoDecodeVP9PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && - ( referenceNameSlotIndices == rhs.referenceNameSlotIndices ) && ( uncompressedHeaderOffset == rhs.uncompressedHeaderOffset ) && - ( compressedHeaderOffset == rhs.compressedHeaderOffset ) && ( tilesOffset == rhs.tilesOffset ); -# endif - } - - bool operator!=( VideoDecodeVP9PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoDecodeVp9PictureInfoKHR; - const void * pNext = {}; - const StdVideoDecodeVP9PictureInfo * pStdPictureInfo = {}; - ArrayWrapper1D referenceNameSlotIndices = {}; - uint32_t uncompressedHeaderOffset = {}; - uint32_t compressedHeaderOffset = {}; - uint32_t tilesOffset = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeVP9PictureInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeVP9PictureInfoKHR; - }; - - // wrapper struct for struct VkVideoDecodeVP9ProfileInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoDecodeVP9ProfileInfoKHR.html - struct VideoDecodeVP9ProfileInfoKHR - { - using NativeType = VkVideoDecodeVP9ProfileInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoDecodeVp9ProfileInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoDecodeVP9ProfileInfoKHR( StdVideoVP9Profile stdProfile_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stdProfile{ stdProfile_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoDecodeVP9ProfileInfoKHR( VideoDecodeVP9ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoDecodeVP9ProfileInfoKHR( VkVideoDecodeVP9ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoDecodeVP9ProfileInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoDecodeVP9ProfileInfoKHR & operator=( VideoDecodeVP9ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoDecodeVP9ProfileInfoKHR & operator=( VkVideoDecodeVP9ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9ProfileInfoKHR & setStdProfile( StdVideoVP9Profile stdProfile_ ) & VULKAN_HPP_NOEXCEPT - { - stdProfile = stdProfile_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoDecodeVP9ProfileInfoKHR && setStdProfile( StdVideoVP9Profile stdProfile_ ) && VULKAN_HPP_NOEXCEPT - { - stdProfile = stdProfile_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoDecodeVP9ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeVP9ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoDecodeVP9ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoDecodeVP9ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stdProfile ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoDecodeVP9ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoVP9Profile ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoDecodeVP9ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoVP9Profile ) ) == 0 ); - } - - bool operator!=( VideoDecodeVP9ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoDecodeVp9ProfileInfoKHR; - const void * pNext = {}; - StdVideoVP9Profile stdProfile = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoDecodeVP9ProfileInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoDecodeVP9ProfileInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeAV1CapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1CapabilitiesKHR.html - struct VideoEncodeAV1CapabilitiesKHR - { - using NativeType = VkVideoEncodeAV1CapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1CapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeAV1CapabilitiesKHR( VideoEncodeAV1CapabilityFlagsKHR flags_ = {}, - StdVideoAV1Level maxLevel_ = {}, - Extent2D codedPictureAlignment_ = {}, - Extent2D maxTiles_ = {}, - Extent2D minTileSize_ = {}, - Extent2D maxTileSize_ = {}, - VideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes_ = {}, - uint32_t maxSingleReferenceCount_ = {}, - uint32_t singleReferenceNameMask_ = {}, - uint32_t maxUnidirectionalCompoundReferenceCount_ = {}, - uint32_t maxUnidirectionalCompoundGroup1ReferenceCount_ = {}, - uint32_t unidirectionalCompoundReferenceNameMask_ = {}, - uint32_t maxBidirectionalCompoundReferenceCount_ = {}, - uint32_t maxBidirectionalCompoundGroup1ReferenceCount_ = {}, - uint32_t maxBidirectionalCompoundGroup2ReferenceCount_ = {}, - uint32_t bidirectionalCompoundReferenceNameMask_ = {}, - uint32_t maxTemporalLayerCount_ = {}, - uint32_t maxSpatialLayerCount_ = {}, - uint32_t maxOperatingPoints_ = {}, - uint32_t minQIndex_ = {}, - uint32_t maxQIndex_ = {}, - Bool32 prefersGopRemainingFrames_ = {}, - Bool32 requiresGopRemainingFrames_ = {}, - VideoEncodeAV1StdFlagsKHR stdSyntaxFlags_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , maxLevel{ maxLevel_ } - , codedPictureAlignment{ codedPictureAlignment_ } - , maxTiles{ maxTiles_ } - , minTileSize{ minTileSize_ } - , maxTileSize{ maxTileSize_ } - , superblockSizes{ superblockSizes_ } - , maxSingleReferenceCount{ maxSingleReferenceCount_ } - , singleReferenceNameMask{ singleReferenceNameMask_ } - , maxUnidirectionalCompoundReferenceCount{ maxUnidirectionalCompoundReferenceCount_ } - , maxUnidirectionalCompoundGroup1ReferenceCount{ maxUnidirectionalCompoundGroup1ReferenceCount_ } - , unidirectionalCompoundReferenceNameMask{ unidirectionalCompoundReferenceNameMask_ } - , maxBidirectionalCompoundReferenceCount{ maxBidirectionalCompoundReferenceCount_ } - , maxBidirectionalCompoundGroup1ReferenceCount{ maxBidirectionalCompoundGroup1ReferenceCount_ } - , maxBidirectionalCompoundGroup2ReferenceCount{ maxBidirectionalCompoundGroup2ReferenceCount_ } - , bidirectionalCompoundReferenceNameMask{ bidirectionalCompoundReferenceNameMask_ } - , maxTemporalLayerCount{ maxTemporalLayerCount_ } - , maxSpatialLayerCount{ maxSpatialLayerCount_ } - , maxOperatingPoints{ maxOperatingPoints_ } - , minQIndex{ minQIndex_ } - , maxQIndex{ maxQIndex_ } - , prefersGopRemainingFrames{ prefersGopRemainingFrames_ } - , requiresGopRemainingFrames{ requiresGopRemainingFrames_ } - , stdSyntaxFlags{ stdSyntaxFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1CapabilitiesKHR( VideoEncodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1CapabilitiesKHR( VkVideoEncodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1CapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1CapabilitiesKHR & operator=( VideoEncodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1CapabilitiesKHR & operator=( VkVideoEncodeAV1CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeAV1CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - maxLevel, - codedPictureAlignment, - maxTiles, - minTileSize, - maxTileSize, - superblockSizes, - maxSingleReferenceCount, - singleReferenceNameMask, - maxUnidirectionalCompoundReferenceCount, - maxUnidirectionalCompoundGroup1ReferenceCount, - unidirectionalCompoundReferenceNameMask, - maxBidirectionalCompoundReferenceCount, - maxBidirectionalCompoundGroup1ReferenceCount, - maxBidirectionalCompoundGroup2ReferenceCount, - bidirectionalCompoundReferenceNameMask, - maxTemporalLayerCount, - maxSpatialLayerCount, - maxOperatingPoints, - minQIndex, - maxQIndex, - prefersGopRemainingFrames, - requiresGopRemainingFrames, - stdSyntaxFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoEncodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = codedPictureAlignment <=> rhs.codedPictureAlignment; cmp != 0 ) - return cmp; - if ( auto cmp = maxTiles <=> rhs.maxTiles; cmp != 0 ) - return cmp; - if ( auto cmp = minTileSize <=> rhs.minTileSize; cmp != 0 ) - return cmp; - if ( auto cmp = maxTileSize <=> rhs.maxTileSize; cmp != 0 ) - return cmp; - if ( auto cmp = superblockSizes <=> rhs.superblockSizes; cmp != 0 ) - return cmp; - if ( auto cmp = maxSingleReferenceCount <=> rhs.maxSingleReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = singleReferenceNameMask <=> rhs.singleReferenceNameMask; cmp != 0 ) - return cmp; - if ( auto cmp = maxUnidirectionalCompoundReferenceCount <=> rhs.maxUnidirectionalCompoundReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxUnidirectionalCompoundGroup1ReferenceCount <=> rhs.maxUnidirectionalCompoundGroup1ReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = unidirectionalCompoundReferenceNameMask <=> rhs.unidirectionalCompoundReferenceNameMask; cmp != 0 ) - return cmp; - if ( auto cmp = maxBidirectionalCompoundReferenceCount <=> rhs.maxBidirectionalCompoundReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxBidirectionalCompoundGroup1ReferenceCount <=> rhs.maxBidirectionalCompoundGroup1ReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxBidirectionalCompoundGroup2ReferenceCount <=> rhs.maxBidirectionalCompoundGroup2ReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = bidirectionalCompoundReferenceNameMask <=> rhs.bidirectionalCompoundReferenceNameMask; cmp != 0 ) - return cmp; - if ( auto cmp = maxTemporalLayerCount <=> rhs.maxTemporalLayerCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxSpatialLayerCount <=> rhs.maxSpatialLayerCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxOperatingPoints <=> rhs.maxOperatingPoints; cmp != 0 ) - return cmp; - if ( auto cmp = minQIndex <=> rhs.minQIndex; cmp != 0 ) - return cmp; - if ( auto cmp = maxQIndex <=> rhs.maxQIndex; cmp != 0 ) - return cmp; - if ( auto cmp = prefersGopRemainingFrames <=> rhs.prefersGopRemainingFrames; cmp != 0 ) - return cmp; - if ( auto cmp = requiresGopRemainingFrames <=> rhs.requiresGopRemainingFrames; cmp != 0 ) - return cmp; - if ( auto cmp = stdSyntaxFlags <=> rhs.stdSyntaxFlags; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoEncodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ) == 0 ) && ( codedPictureAlignment == rhs.codedPictureAlignment ) && - ( maxTiles == rhs.maxTiles ) && ( minTileSize == rhs.minTileSize ) && ( maxTileSize == rhs.maxTileSize ) && - ( superblockSizes == rhs.superblockSizes ) && ( maxSingleReferenceCount == rhs.maxSingleReferenceCount ) && - ( singleReferenceNameMask == rhs.singleReferenceNameMask ) && - ( maxUnidirectionalCompoundReferenceCount == rhs.maxUnidirectionalCompoundReferenceCount ) && - ( maxUnidirectionalCompoundGroup1ReferenceCount == rhs.maxUnidirectionalCompoundGroup1ReferenceCount ) && - ( unidirectionalCompoundReferenceNameMask == rhs.unidirectionalCompoundReferenceNameMask ) && - ( maxBidirectionalCompoundReferenceCount == rhs.maxBidirectionalCompoundReferenceCount ) && - ( maxBidirectionalCompoundGroup1ReferenceCount == rhs.maxBidirectionalCompoundGroup1ReferenceCount ) && - ( maxBidirectionalCompoundGroup2ReferenceCount == rhs.maxBidirectionalCompoundGroup2ReferenceCount ) && - ( bidirectionalCompoundReferenceNameMask == rhs.bidirectionalCompoundReferenceNameMask ) && - ( maxTemporalLayerCount == rhs.maxTemporalLayerCount ) && ( maxSpatialLayerCount == rhs.maxSpatialLayerCount ) && - ( maxOperatingPoints == rhs.maxOperatingPoints ) && ( minQIndex == rhs.minQIndex ) && ( maxQIndex == rhs.maxQIndex ) && - ( prefersGopRemainingFrames == rhs.prefersGopRemainingFrames ) && ( requiresGopRemainingFrames == rhs.requiresGopRemainingFrames ) && - ( stdSyntaxFlags == rhs.stdSyntaxFlags ); - } - - bool operator!=( VideoEncodeAV1CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoEncodeAv1CapabilitiesKHR; - void * pNext = {}; - VideoEncodeAV1CapabilityFlagsKHR flags = {}; - StdVideoAV1Level maxLevel = {}; - Extent2D codedPictureAlignment = {}; - Extent2D maxTiles = {}; - Extent2D minTileSize = {}; - Extent2D maxTileSize = {}; - VideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes = {}; - uint32_t maxSingleReferenceCount = {}; - uint32_t singleReferenceNameMask = {}; - uint32_t maxUnidirectionalCompoundReferenceCount = {}; - uint32_t maxUnidirectionalCompoundGroup1ReferenceCount = {}; - uint32_t unidirectionalCompoundReferenceNameMask = {}; - uint32_t maxBidirectionalCompoundReferenceCount = {}; - uint32_t maxBidirectionalCompoundGroup1ReferenceCount = {}; - uint32_t maxBidirectionalCompoundGroup2ReferenceCount = {}; - uint32_t bidirectionalCompoundReferenceNameMask = {}; - uint32_t maxTemporalLayerCount = {}; - uint32_t maxSpatialLayerCount = {}; - uint32_t maxOperatingPoints = {}; - uint32_t minQIndex = {}; - uint32_t maxQIndex = {}; - Bool32 prefersGopRemainingFrames = {}; - Bool32 requiresGopRemainingFrames = {}; - VideoEncodeAV1StdFlagsKHR stdSyntaxFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1CapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeAV1CapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeAV1DpbSlotInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1DpbSlotInfoKHR.html - struct VideoEncodeAV1DpbSlotInfoKHR - { - using NativeType = VkVideoEncodeAV1DpbSlotInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1DpbSlotInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeAV1DpbSlotInfoKHR( const StdVideoEncodeAV1ReferenceInfo * pStdReferenceInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdReferenceInfo{ pStdReferenceInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1DpbSlotInfoKHR( VideoEncodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1DpbSlotInfoKHR( VkVideoEncodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1DpbSlotInfoKHR & operator=( VideoEncodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1DpbSlotInfoKHR & operator=( VkVideoEncodeAV1DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoEncodeAV1ReferenceInfo * pStdReferenceInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoEncodeAV1ReferenceInfo * pStdReferenceInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeAV1DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdReferenceInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeAV1DpbSlotInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); -# endif - } - - bool operator!=( VideoEncodeAV1DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeAv1DpbSlotInfoKHR; - const void * pNext = {}; - const StdVideoEncodeAV1ReferenceInfo * pStdReferenceInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1DpbSlotInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeAV1DpbSlotInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeAV1FrameSizeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1FrameSizeKHR.html - struct VideoEncodeAV1FrameSizeKHR - { - using NativeType = VkVideoEncodeAV1FrameSizeKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoEncodeAV1FrameSizeKHR( uint32_t intraFrameSize_ = {}, uint32_t predictiveFrameSize_ = {}, uint32_t bipredictiveFrameSize_ = {} ) VULKAN_HPP_NOEXCEPT - : intraFrameSize{ intraFrameSize_ } - , predictiveFrameSize{ predictiveFrameSize_ } - , bipredictiveFrameSize{ bipredictiveFrameSize_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1FrameSizeKHR( VideoEncodeAV1FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1FrameSizeKHR( VkVideoEncodeAV1FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1FrameSizeKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1FrameSizeKHR & operator=( VideoEncodeAV1FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1FrameSizeKHR & operator=( VkVideoEncodeAV1FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR & setIntraFrameSize( uint32_t intraFrameSize_ ) & VULKAN_HPP_NOEXCEPT - { - intraFrameSize = intraFrameSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR && setIntraFrameSize( uint32_t intraFrameSize_ ) && VULKAN_HPP_NOEXCEPT - { - intraFrameSize = intraFrameSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR & setPredictiveFrameSize( uint32_t predictiveFrameSize_ ) & VULKAN_HPP_NOEXCEPT - { - predictiveFrameSize = predictiveFrameSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR && setPredictiveFrameSize( uint32_t predictiveFrameSize_ ) && VULKAN_HPP_NOEXCEPT - { - predictiveFrameSize = predictiveFrameSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR & setBipredictiveFrameSize( uint32_t bipredictiveFrameSize_ ) & VULKAN_HPP_NOEXCEPT - { - bipredictiveFrameSize = bipredictiveFrameSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1FrameSizeKHR && setBipredictiveFrameSize( uint32_t bipredictiveFrameSize_ ) && VULKAN_HPP_NOEXCEPT - { - bipredictiveFrameSize = bipredictiveFrameSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeAV1FrameSizeKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1FrameSizeKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1FrameSizeKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1FrameSizeKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( intraFrameSize, predictiveFrameSize, bipredictiveFrameSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeAV1FrameSizeKHR const & ) const = default; -#else - bool operator==( VideoEncodeAV1FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( intraFrameSize == rhs.intraFrameSize ) && ( predictiveFrameSize == rhs.predictiveFrameSize ) && - ( bipredictiveFrameSize == rhs.bipredictiveFrameSize ); -# endif - } - - bool operator!=( VideoEncodeAV1FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t intraFrameSize = {}; - uint32_t predictiveFrameSize = {}; - uint32_t bipredictiveFrameSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1FrameSizeKHR; - }; -#endif - - // wrapper struct for struct VkVideoEncodeAV1GopRemainingFrameInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1GopRemainingFrameInfoKHR.html - struct VideoEncodeAV1GopRemainingFrameInfoKHR - { - using NativeType = VkVideoEncodeAV1GopRemainingFrameInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1GopRemainingFrameInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeAV1GopRemainingFrameInfoKHR( Bool32 useGopRemainingFrames_ = {}, - uint32_t gopRemainingIntra_ = {}, - uint32_t gopRemainingPredictive_ = {}, - uint32_t gopRemainingBipredictive_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , useGopRemainingFrames{ useGopRemainingFrames_ } - , gopRemainingIntra{ gopRemainingIntra_ } - , gopRemainingPredictive{ gopRemainingPredictive_ } - , gopRemainingBipredictive{ gopRemainingBipredictive_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1GopRemainingFrameInfoKHR( VideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1GopRemainingFrameInfoKHR( VkVideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1GopRemainingFrameInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1GopRemainingFrameInfoKHR & operator=( VideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1GopRemainingFrameInfoKHR & operator=( VkVideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR & setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) & VULKAN_HPP_NOEXCEPT - { - useGopRemainingFrames = useGopRemainingFrames_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR && setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) && VULKAN_HPP_NOEXCEPT - { - useGopRemainingFrames = useGopRemainingFrames_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR & setGopRemainingIntra( uint32_t gopRemainingIntra_ ) & VULKAN_HPP_NOEXCEPT - { - gopRemainingIntra = gopRemainingIntra_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR && setGopRemainingIntra( uint32_t gopRemainingIntra_ ) && VULKAN_HPP_NOEXCEPT - { - gopRemainingIntra = gopRemainingIntra_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR & setGopRemainingPredictive( uint32_t gopRemainingPredictive_ ) & VULKAN_HPP_NOEXCEPT - { - gopRemainingPredictive = gopRemainingPredictive_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR && setGopRemainingPredictive( uint32_t gopRemainingPredictive_ ) && VULKAN_HPP_NOEXCEPT - { - gopRemainingPredictive = gopRemainingPredictive_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR & setGopRemainingBipredictive( uint32_t gopRemainingBipredictive_ ) & VULKAN_HPP_NOEXCEPT - { - gopRemainingBipredictive = gopRemainingBipredictive_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1GopRemainingFrameInfoKHR && setGopRemainingBipredictive( uint32_t gopRemainingBipredictive_ ) && VULKAN_HPP_NOEXCEPT - { - gopRemainingBipredictive = gopRemainingBipredictive_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeAV1GopRemainingFrameInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1GopRemainingFrameInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1GopRemainingFrameInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1GopRemainingFrameInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, useGopRemainingFrames, gopRemainingIntra, gopRemainingPredictive, gopRemainingBipredictive ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeAV1GopRemainingFrameInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) && - ( gopRemainingIntra == rhs.gopRemainingIntra ) && ( gopRemainingPredictive == rhs.gopRemainingPredictive ) && - ( gopRemainingBipredictive == rhs.gopRemainingBipredictive ); -# endif - } - - bool operator!=( VideoEncodeAV1GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeAv1GopRemainingFrameInfoKHR; - const void * pNext = {}; - Bool32 useGopRemainingFrames = {}; - uint32_t gopRemainingIntra = {}; - uint32_t gopRemainingPredictive = {}; - uint32_t gopRemainingBipredictive = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1GopRemainingFrameInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeAV1GopRemainingFrameInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeAV1PictureInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1PictureInfoKHR.html - struct VideoEncodeAV1PictureInfoKHR - { - using NativeType = VkVideoEncodeAV1PictureInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1PictureInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR( VideoEncodeAV1PredictionModeKHR predictionMode_ = VideoEncodeAV1PredictionModeKHR::eIntraOnly, - VideoEncodeAV1RateControlGroupKHR rateControlGroup_ = VideoEncodeAV1RateControlGroupKHR::eIntra, - uint32_t constantQIndex_ = {}, - const StdVideoEncodeAV1PictureInfo * pStdPictureInfo_ = {}, - std::array const & referenceNameSlotIndices_ = {}, - Bool32 primaryReferenceCdfOnly_ = {}, - Bool32 generateObuExtensionHeader_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , predictionMode{ predictionMode_ } - , rateControlGroup{ rateControlGroup_ } - , constantQIndex{ constantQIndex_ } - , pStdPictureInfo{ pStdPictureInfo_ } - , referenceNameSlotIndices{ referenceNameSlotIndices_ } - , primaryReferenceCdfOnly{ primaryReferenceCdfOnly_ } - , generateObuExtensionHeader{ generateObuExtensionHeader_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR( VideoEncodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1PictureInfoKHR( VkVideoEncodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1PictureInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1PictureInfoKHR & operator=( VideoEncodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1PictureInfoKHR & operator=( VkVideoEncodeAV1PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setPredictionMode( VideoEncodeAV1PredictionModeKHR predictionMode_ ) & VULKAN_HPP_NOEXCEPT - { - predictionMode = predictionMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setPredictionMode( VideoEncodeAV1PredictionModeKHR predictionMode_ ) && VULKAN_HPP_NOEXCEPT - { - predictionMode = predictionMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setRateControlGroup( VideoEncodeAV1RateControlGroupKHR rateControlGroup_ ) & VULKAN_HPP_NOEXCEPT - { - rateControlGroup = rateControlGroup_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setRateControlGroup( VideoEncodeAV1RateControlGroupKHR rateControlGroup_ ) && VULKAN_HPP_NOEXCEPT - { - rateControlGroup = rateControlGroup_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setConstantQIndex( uint32_t constantQIndex_ ) & VULKAN_HPP_NOEXCEPT - { - constantQIndex = constantQIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setConstantQIndex( uint32_t constantQIndex_ ) && VULKAN_HPP_NOEXCEPT - { - constantQIndex = constantQIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setPStdPictureInfo( const StdVideoEncodeAV1PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setPStdPictureInfo( const StdVideoEncodeAV1PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & - setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) & - VULKAN_HPP_NOEXCEPT - { - referenceNameSlotIndices = referenceNameSlotIndices_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && - setReferenceNameSlotIndices( std::array referenceNameSlotIndices_ ) && - VULKAN_HPP_NOEXCEPT - { - referenceNameSlotIndices = referenceNameSlotIndices_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setPrimaryReferenceCdfOnly( Bool32 primaryReferenceCdfOnly_ ) & VULKAN_HPP_NOEXCEPT - { - primaryReferenceCdfOnly = primaryReferenceCdfOnly_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setPrimaryReferenceCdfOnly( Bool32 primaryReferenceCdfOnly_ ) && VULKAN_HPP_NOEXCEPT - { - primaryReferenceCdfOnly = primaryReferenceCdfOnly_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR & setGenerateObuExtensionHeader( Bool32 generateObuExtensionHeader_ ) & VULKAN_HPP_NOEXCEPT - { - generateObuExtensionHeader = generateObuExtensionHeader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1PictureInfoKHR && setGenerateObuExtensionHeader( Bool32 generateObuExtensionHeader_ ) && VULKAN_HPP_NOEXCEPT - { - generateObuExtensionHeader = generateObuExtensionHeader_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeAV1PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1PictureInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1PictureInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple const &, - Bool32 const &, - Bool32 const &> - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - predictionMode, - rateControlGroup, - constantQIndex, - pStdPictureInfo, - referenceNameSlotIndices, - primaryReferenceCdfOnly, - generateObuExtensionHeader ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeAV1PictureInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( predictionMode == rhs.predictionMode ) && ( rateControlGroup == rhs.rateControlGroup ) && - ( constantQIndex == rhs.constantQIndex ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && - ( referenceNameSlotIndices == rhs.referenceNameSlotIndices ) && ( primaryReferenceCdfOnly == rhs.primaryReferenceCdfOnly ) && - ( generateObuExtensionHeader == rhs.generateObuExtensionHeader ); -# endif - } - - bool operator!=( VideoEncodeAV1PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeAv1PictureInfoKHR; - const void * pNext = {}; - VideoEncodeAV1PredictionModeKHR predictionMode = VideoEncodeAV1PredictionModeKHR::eIntraOnly; - VideoEncodeAV1RateControlGroupKHR rateControlGroup = VideoEncodeAV1RateControlGroupKHR::eIntra; - uint32_t constantQIndex = {}; - const StdVideoEncodeAV1PictureInfo * pStdPictureInfo = {}; - ArrayWrapper1D referenceNameSlotIndices = {}; - Bool32 primaryReferenceCdfOnly = {}; - Bool32 generateObuExtensionHeader = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1PictureInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeAV1PictureInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeAV1ProfileInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1ProfileInfoKHR.html - struct VideoEncodeAV1ProfileInfoKHR - { - using NativeType = VkVideoEncodeAV1ProfileInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1ProfileInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeAV1ProfileInfoKHR( StdVideoAV1Profile stdProfile_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stdProfile{ stdProfile_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1ProfileInfoKHR( VideoEncodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1ProfileInfoKHR( VkVideoEncodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1ProfileInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1ProfileInfoKHR & operator=( VideoEncodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1ProfileInfoKHR & operator=( VkVideoEncodeAV1ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1ProfileInfoKHR & setStdProfile( StdVideoAV1Profile stdProfile_ ) & VULKAN_HPP_NOEXCEPT - { - stdProfile = stdProfile_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1ProfileInfoKHR && setStdProfile( StdVideoAV1Profile stdProfile_ ) && VULKAN_HPP_NOEXCEPT - { - stdProfile = stdProfile_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeAV1ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stdProfile ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoEncodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoEncodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfile, &rhs.stdProfile, sizeof( StdVideoAV1Profile ) ) == 0 ); - } - - bool operator!=( VideoEncodeAV1ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoEncodeAv1ProfileInfoKHR; - const void * pNext = {}; - StdVideoAV1Profile stdProfile = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1ProfileInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeAV1ProfileInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeAV1QIndexKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1QIndexKHR.html - struct VideoEncodeAV1QIndexKHR - { - using NativeType = VkVideoEncodeAV1QIndexKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoEncodeAV1QIndexKHR( uint32_t intraQIndex_ = {}, uint32_t predictiveQIndex_ = {}, uint32_t bipredictiveQIndex_ = {} ) VULKAN_HPP_NOEXCEPT - : intraQIndex{ intraQIndex_ } - , predictiveQIndex{ predictiveQIndex_ } - , bipredictiveQIndex{ bipredictiveQIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1QIndexKHR( VideoEncodeAV1QIndexKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1QIndexKHR( VkVideoEncodeAV1QIndexKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1QIndexKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1QIndexKHR & operator=( VideoEncodeAV1QIndexKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1QIndexKHR & operator=( VkVideoEncodeAV1QIndexKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR & setIntraQIndex( uint32_t intraQIndex_ ) & VULKAN_HPP_NOEXCEPT - { - intraQIndex = intraQIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR && setIntraQIndex( uint32_t intraQIndex_ ) && VULKAN_HPP_NOEXCEPT - { - intraQIndex = intraQIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR & setPredictiveQIndex( uint32_t predictiveQIndex_ ) & VULKAN_HPP_NOEXCEPT - { - predictiveQIndex = predictiveQIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR && setPredictiveQIndex( uint32_t predictiveQIndex_ ) && VULKAN_HPP_NOEXCEPT - { - predictiveQIndex = predictiveQIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR & setBipredictiveQIndex( uint32_t bipredictiveQIndex_ ) & VULKAN_HPP_NOEXCEPT - { - bipredictiveQIndex = bipredictiveQIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1QIndexKHR && setBipredictiveQIndex( uint32_t bipredictiveQIndex_ ) && VULKAN_HPP_NOEXCEPT - { - bipredictiveQIndex = bipredictiveQIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeAV1QIndexKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1QIndexKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1QIndexKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1QIndexKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( intraQIndex, predictiveQIndex, bipredictiveQIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeAV1QIndexKHR const & ) const = default; -#else - bool operator==( VideoEncodeAV1QIndexKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( intraQIndex == rhs.intraQIndex ) && ( predictiveQIndex == rhs.predictiveQIndex ) && ( bipredictiveQIndex == rhs.bipredictiveQIndex ); -# endif - } - - bool operator!=( VideoEncodeAV1QIndexKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t intraQIndex = {}; - uint32_t predictiveQIndex = {}; - uint32_t bipredictiveQIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1QIndexKHR; - }; -#endif - - // wrapper struct for struct VkVideoEncodeAV1QualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1QualityLevelPropertiesKHR.html - struct VideoEncodeAV1QualityLevelPropertiesKHR - { - using NativeType = VkVideoEncodeAV1QualityLevelPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1QualityLevelPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeAV1QualityLevelPropertiesKHR( VideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags_ = {}, - uint32_t preferredGopFrameCount_ = {}, - uint32_t preferredKeyFramePeriod_ = {}, - uint32_t preferredConsecutiveBipredictiveFrameCount_ = {}, - uint32_t preferredTemporalLayerCount_ = {}, - VideoEncodeAV1QIndexKHR preferredConstantQIndex_ = {}, - uint32_t preferredMaxSingleReferenceCount_ = {}, - uint32_t preferredSingleReferenceNameMask_ = {}, - uint32_t preferredMaxUnidirectionalCompoundReferenceCount_ = {}, - uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount_ = {}, - uint32_t preferredUnidirectionalCompoundReferenceNameMask_ = {}, - uint32_t preferredMaxBidirectionalCompoundReferenceCount_ = {}, - uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount_ = {}, - uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount_ = {}, - uint32_t preferredBidirectionalCompoundReferenceNameMask_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , preferredRateControlFlags{ preferredRateControlFlags_ } - , preferredGopFrameCount{ preferredGopFrameCount_ } - , preferredKeyFramePeriod{ preferredKeyFramePeriod_ } - , preferredConsecutiveBipredictiveFrameCount{ preferredConsecutiveBipredictiveFrameCount_ } - , preferredTemporalLayerCount{ preferredTemporalLayerCount_ } - , preferredConstantQIndex{ preferredConstantQIndex_ } - , preferredMaxSingleReferenceCount{ preferredMaxSingleReferenceCount_ } - , preferredSingleReferenceNameMask{ preferredSingleReferenceNameMask_ } - , preferredMaxUnidirectionalCompoundReferenceCount{ preferredMaxUnidirectionalCompoundReferenceCount_ } - , preferredMaxUnidirectionalCompoundGroup1ReferenceCount{ preferredMaxUnidirectionalCompoundGroup1ReferenceCount_ } - , preferredUnidirectionalCompoundReferenceNameMask{ preferredUnidirectionalCompoundReferenceNameMask_ } - , preferredMaxBidirectionalCompoundReferenceCount{ preferredMaxBidirectionalCompoundReferenceCount_ } - , preferredMaxBidirectionalCompoundGroup1ReferenceCount{ preferredMaxBidirectionalCompoundGroup1ReferenceCount_ } - , preferredMaxBidirectionalCompoundGroup2ReferenceCount{ preferredMaxBidirectionalCompoundGroup2ReferenceCount_ } - , preferredBidirectionalCompoundReferenceNameMask{ preferredBidirectionalCompoundReferenceNameMask_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1QualityLevelPropertiesKHR( VideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1QualityLevelPropertiesKHR( VkVideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1QualityLevelPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1QualityLevelPropertiesKHR & operator=( VideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1QualityLevelPropertiesKHR & operator=( VkVideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeAV1QualityLevelPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1QualityLevelPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1QualityLevelPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1QualityLevelPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - preferredRateControlFlags, - preferredGopFrameCount, - preferredKeyFramePeriod, - preferredConsecutiveBipredictiveFrameCount, - preferredTemporalLayerCount, - preferredConstantQIndex, - preferredMaxSingleReferenceCount, - preferredSingleReferenceNameMask, - preferredMaxUnidirectionalCompoundReferenceCount, - preferredMaxUnidirectionalCompoundGroup1ReferenceCount, - preferredUnidirectionalCompoundReferenceNameMask, - preferredMaxBidirectionalCompoundReferenceCount, - preferredMaxBidirectionalCompoundGroup1ReferenceCount, - preferredMaxBidirectionalCompoundGroup2ReferenceCount, - preferredBidirectionalCompoundReferenceNameMask ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeAV1QualityLevelPropertiesKHR const & ) const = default; -#else - bool operator==( VideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) && - ( preferredGopFrameCount == rhs.preferredGopFrameCount ) && ( preferredKeyFramePeriod == rhs.preferredKeyFramePeriod ) && - ( preferredConsecutiveBipredictiveFrameCount == rhs.preferredConsecutiveBipredictiveFrameCount ) && - ( preferredTemporalLayerCount == rhs.preferredTemporalLayerCount ) && ( preferredConstantQIndex == rhs.preferredConstantQIndex ) && - ( preferredMaxSingleReferenceCount == rhs.preferredMaxSingleReferenceCount ) && - ( preferredSingleReferenceNameMask == rhs.preferredSingleReferenceNameMask ) && - ( preferredMaxUnidirectionalCompoundReferenceCount == rhs.preferredMaxUnidirectionalCompoundReferenceCount ) && - ( preferredMaxUnidirectionalCompoundGroup1ReferenceCount == rhs.preferredMaxUnidirectionalCompoundGroup1ReferenceCount ) && - ( preferredUnidirectionalCompoundReferenceNameMask == rhs.preferredUnidirectionalCompoundReferenceNameMask ) && - ( preferredMaxBidirectionalCompoundReferenceCount == rhs.preferredMaxBidirectionalCompoundReferenceCount ) && - ( preferredMaxBidirectionalCompoundGroup1ReferenceCount == rhs.preferredMaxBidirectionalCompoundGroup1ReferenceCount ) && - ( preferredMaxBidirectionalCompoundGroup2ReferenceCount == rhs.preferredMaxBidirectionalCompoundGroup2ReferenceCount ) && - ( preferredBidirectionalCompoundReferenceNameMask == rhs.preferredBidirectionalCompoundReferenceNameMask ); -# endif - } - - bool operator!=( VideoEncodeAV1QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeAv1QualityLevelPropertiesKHR; - void * pNext = {}; - VideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags = {}; - uint32_t preferredGopFrameCount = {}; - uint32_t preferredKeyFramePeriod = {}; - uint32_t preferredConsecutiveBipredictiveFrameCount = {}; - uint32_t preferredTemporalLayerCount = {}; - VideoEncodeAV1QIndexKHR preferredConstantQIndex = {}; - uint32_t preferredMaxSingleReferenceCount = {}; - uint32_t preferredSingleReferenceNameMask = {}; - uint32_t preferredMaxUnidirectionalCompoundReferenceCount = {}; - uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount = {}; - uint32_t preferredUnidirectionalCompoundReferenceNameMask = {}; - uint32_t preferredMaxBidirectionalCompoundReferenceCount = {}; - uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount = {}; - uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount = {}; - uint32_t preferredBidirectionalCompoundReferenceNameMask = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1QualityLevelPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeAV1QualityLevelPropertiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1QuantizationMapCapabilitiesKHR.html - struct VideoEncodeAV1QuantizationMapCapabilitiesKHR - { - using NativeType = VkVideoEncodeAV1QuantizationMapCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1QuantizationMapCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoEncodeAV1QuantizationMapCapabilitiesKHR( int32_t minQIndexDelta_ = {}, int32_t maxQIndexDelta_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minQIndexDelta{ minQIndexDelta_ } - , maxQIndexDelta{ maxQIndexDelta_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1QuantizationMapCapabilitiesKHR( VideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1QuantizationMapCapabilitiesKHR( VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1QuantizationMapCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1QuantizationMapCapabilitiesKHR & operator=( VideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1QuantizationMapCapabilitiesKHR & operator=( VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1QuantizationMapCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1QuantizationMapCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minQIndexDelta, maxQIndexDelta ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeAV1QuantizationMapCapabilitiesKHR const & ) const = default; -#else - bool operator==( VideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minQIndexDelta == rhs.minQIndexDelta ) && ( maxQIndexDelta == rhs.maxQIndexDelta ); -# endif - } - - bool operator!=( VideoEncodeAV1QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeAv1QuantizationMapCapabilitiesKHR; - void * pNext = {}; - int32_t minQIndexDelta = {}; - int32_t maxQIndexDelta = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1QuantizationMapCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeAV1QuantizationMapCapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeAV1RateControlInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlInfoKHR.html - struct VideoEncodeAV1RateControlInfoKHR - { - using NativeType = VkVideoEncodeAV1RateControlInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1RateControlInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeAV1RateControlInfoKHR( VideoEncodeAV1RateControlFlagsKHR flags_ = {}, - uint32_t gopFrameCount_ = {}, - uint32_t keyFramePeriod_ = {}, - uint32_t consecutiveBipredictiveFrameCount_ = {}, - uint32_t temporalLayerCount_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , gopFrameCount{ gopFrameCount_ } - , keyFramePeriod{ keyFramePeriod_ } - , consecutiveBipredictiveFrameCount{ consecutiveBipredictiveFrameCount_ } - , temporalLayerCount{ temporalLayerCount_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1RateControlInfoKHR( VideoEncodeAV1RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1RateControlInfoKHR( VkVideoEncodeAV1RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1RateControlInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1RateControlInfoKHR & operator=( VideoEncodeAV1RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1RateControlInfoKHR & operator=( VkVideoEncodeAV1RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setFlags( VideoEncodeAV1RateControlFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setFlags( VideoEncodeAV1RateControlFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setGopFrameCount( uint32_t gopFrameCount_ ) & VULKAN_HPP_NOEXCEPT - { - gopFrameCount = gopFrameCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setGopFrameCount( uint32_t gopFrameCount_ ) && VULKAN_HPP_NOEXCEPT - { - gopFrameCount = gopFrameCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setKeyFramePeriod( uint32_t keyFramePeriod_ ) & VULKAN_HPP_NOEXCEPT - { - keyFramePeriod = keyFramePeriod_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setKeyFramePeriod( uint32_t keyFramePeriod_ ) && VULKAN_HPP_NOEXCEPT - { - keyFramePeriod = keyFramePeriod_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setConsecutiveBipredictiveFrameCount( uint32_t consecutiveBipredictiveFrameCount_ ) & - VULKAN_HPP_NOEXCEPT - { - consecutiveBipredictiveFrameCount = consecutiveBipredictiveFrameCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setConsecutiveBipredictiveFrameCount( uint32_t consecutiveBipredictiveFrameCount_ ) && - VULKAN_HPP_NOEXCEPT - { - consecutiveBipredictiveFrameCount = consecutiveBipredictiveFrameCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR & setTemporalLayerCount( uint32_t temporalLayerCount_ ) & VULKAN_HPP_NOEXCEPT - { - temporalLayerCount = temporalLayerCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlInfoKHR && setTemporalLayerCount( uint32_t temporalLayerCount_ ) && VULKAN_HPP_NOEXCEPT - { - temporalLayerCount = temporalLayerCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeAV1RateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1RateControlInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1RateControlInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1RateControlInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, gopFrameCount, keyFramePeriod, consecutiveBipredictiveFrameCount, temporalLayerCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeAV1RateControlInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeAV1RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) && - ( keyFramePeriod == rhs.keyFramePeriod ) && ( consecutiveBipredictiveFrameCount == rhs.consecutiveBipredictiveFrameCount ) && - ( temporalLayerCount == rhs.temporalLayerCount ); -# endif - } - - bool operator!=( VideoEncodeAV1RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeAv1RateControlInfoKHR; - const void * pNext = {}; - VideoEncodeAV1RateControlFlagsKHR flags = {}; - uint32_t gopFrameCount = {}; - uint32_t keyFramePeriod = {}; - uint32_t consecutiveBipredictiveFrameCount = {}; - uint32_t temporalLayerCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1RateControlInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeAV1RateControlInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeAV1RateControlLayerInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1RateControlLayerInfoKHR.html - struct VideoEncodeAV1RateControlLayerInfoKHR - { - using NativeType = VkVideoEncodeAV1RateControlLayerInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1RateControlLayerInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeAV1RateControlLayerInfoKHR( Bool32 useMinQIndex_ = {}, - VideoEncodeAV1QIndexKHR minQIndex_ = {}, - Bool32 useMaxQIndex_ = {}, - VideoEncodeAV1QIndexKHR maxQIndex_ = {}, - Bool32 useMaxFrameSize_ = {}, - VideoEncodeAV1FrameSizeKHR maxFrameSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , useMinQIndex{ useMinQIndex_ } - , minQIndex{ minQIndex_ } - , useMaxQIndex{ useMaxQIndex_ } - , maxQIndex{ maxQIndex_ } - , useMaxFrameSize{ useMaxFrameSize_ } - , maxFrameSize{ maxFrameSize_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1RateControlLayerInfoKHR( VideoEncodeAV1RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1RateControlLayerInfoKHR( VkVideoEncodeAV1RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1RateControlLayerInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1RateControlLayerInfoKHR & operator=( VideoEncodeAV1RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1RateControlLayerInfoKHR & operator=( VkVideoEncodeAV1RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setUseMinQIndex( Bool32 useMinQIndex_ ) & VULKAN_HPP_NOEXCEPT - { - useMinQIndex = useMinQIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setUseMinQIndex( Bool32 useMinQIndex_ ) && VULKAN_HPP_NOEXCEPT - { - useMinQIndex = useMinQIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setMinQIndex( VideoEncodeAV1QIndexKHR const & minQIndex_ ) & VULKAN_HPP_NOEXCEPT - { - minQIndex = minQIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setMinQIndex( VideoEncodeAV1QIndexKHR const & minQIndex_ ) && VULKAN_HPP_NOEXCEPT - { - minQIndex = minQIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setUseMaxQIndex( Bool32 useMaxQIndex_ ) & VULKAN_HPP_NOEXCEPT - { - useMaxQIndex = useMaxQIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setUseMaxQIndex( Bool32 useMaxQIndex_ ) && VULKAN_HPP_NOEXCEPT - { - useMaxQIndex = useMaxQIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setMaxQIndex( VideoEncodeAV1QIndexKHR const & maxQIndex_ ) & VULKAN_HPP_NOEXCEPT - { - maxQIndex = maxQIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setMaxQIndex( VideoEncodeAV1QIndexKHR const & maxQIndex_ ) && VULKAN_HPP_NOEXCEPT - { - maxQIndex = maxQIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) & VULKAN_HPP_NOEXCEPT - { - useMaxFrameSize = useMaxFrameSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) && VULKAN_HPP_NOEXCEPT - { - useMaxFrameSize = useMaxFrameSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR & setMaxFrameSize( VideoEncodeAV1FrameSizeKHR const & maxFrameSize_ ) & VULKAN_HPP_NOEXCEPT - { - maxFrameSize = maxFrameSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1RateControlLayerInfoKHR && setMaxFrameSize( VideoEncodeAV1FrameSizeKHR const & maxFrameSize_ ) && VULKAN_HPP_NOEXCEPT - { - maxFrameSize = maxFrameSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeAV1RateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1RateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1RateControlLayerInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1RateControlLayerInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, useMinQIndex, minQIndex, useMaxQIndex, maxQIndex, useMaxFrameSize, maxFrameSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeAV1RateControlLayerInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeAV1RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQIndex == rhs.useMinQIndex ) && ( minQIndex == rhs.minQIndex ) && - ( useMaxQIndex == rhs.useMaxQIndex ) && ( maxQIndex == rhs.maxQIndex ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && - ( maxFrameSize == rhs.maxFrameSize ); -# endif - } - - bool operator!=( VideoEncodeAV1RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeAv1RateControlLayerInfoKHR; - const void * pNext = {}; - Bool32 useMinQIndex = {}; - VideoEncodeAV1QIndexKHR minQIndex = {}; - Bool32 useMaxQIndex = {}; - VideoEncodeAV1QIndexKHR maxQIndex = {}; - Bool32 useMaxFrameSize = {}; - VideoEncodeAV1FrameSizeKHR maxFrameSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1RateControlLayerInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeAV1RateControlLayerInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeAV1SessionCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1SessionCreateInfoKHR.html - struct VideoEncodeAV1SessionCreateInfoKHR - { - using NativeType = VkVideoEncodeAV1SessionCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1SessionCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoEncodeAV1SessionCreateInfoKHR( Bool32 useMaxLevel_ = {}, StdVideoAV1Level maxLevel_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , useMaxLevel{ useMaxLevel_ } - , maxLevel{ maxLevel_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1SessionCreateInfoKHR( VideoEncodeAV1SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1SessionCreateInfoKHR( VkVideoEncodeAV1SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1SessionCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeAV1SessionCreateInfoKHR & operator=( VideoEncodeAV1SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1SessionCreateInfoKHR & operator=( VkVideoEncodeAV1SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR & setUseMaxLevel( Bool32 useMaxLevel_ ) & VULKAN_HPP_NOEXCEPT - { - useMaxLevel = useMaxLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR && setUseMaxLevel( Bool32 useMaxLevel_ ) && VULKAN_HPP_NOEXCEPT - { - useMaxLevel = useMaxLevel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR & setMaxLevel( StdVideoAV1Level maxLevel_ ) & VULKAN_HPP_NOEXCEPT - { - maxLevel = maxLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionCreateInfoKHR && setMaxLevel( StdVideoAV1Level maxLevel_ ) && VULKAN_HPP_NOEXCEPT - { - maxLevel = maxLevel_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeAV1SessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1SessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1SessionCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1SessionCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, useMaxLevel, maxLevel ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoEncodeAV1SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = useMaxLevel <=> rhs.useMaxLevel; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoEncodeAV1SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevel == rhs.useMaxLevel ) && - ( memcmp( &maxLevel, &rhs.maxLevel, sizeof( StdVideoAV1Level ) ) == 0 ); - } - - bool operator!=( VideoEncodeAV1SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoEncodeAv1SessionCreateInfoKHR; - const void * pNext = {}; - Bool32 useMaxLevel = {}; - StdVideoAV1Level maxLevel = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1SessionCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeAV1SessionCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeAV1SessionParametersCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeAV1SessionParametersCreateInfoKHR.html - struct VideoEncodeAV1SessionParametersCreateInfoKHR - { - using NativeType = VkVideoEncodeAV1SessionParametersCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeAv1SessionParametersCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeAV1SessionParametersCreateInfoKHR( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ = {}, - const StdVideoEncodeAV1DecoderModelInfo * pStdDecoderModelInfo_ = {}, - uint32_t stdOperatingPointCount_ = {}, - const StdVideoEncodeAV1OperatingPointInfo * pStdOperatingPoints_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdSequenceHeader{ pStdSequenceHeader_ } - , pStdDecoderModelInfo{ pStdDecoderModelInfo_ } - , stdOperatingPointCount{ stdOperatingPointCount_ } - , pStdOperatingPoints{ pStdOperatingPoints_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeAV1SessionParametersCreateInfoKHR( VideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeAV1SessionParametersCreateInfoKHR( VkVideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeAV1SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeAV1SessionParametersCreateInfoKHR( const StdVideoAV1SequenceHeader * pStdSequenceHeader_, - const StdVideoEncodeAV1DecoderModelInfo * pStdDecoderModelInfo_, - ArrayProxyNoTemporaries const & stdOperatingPoints_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , pStdSequenceHeader( pStdSequenceHeader_ ) - , pStdDecoderModelInfo( pStdDecoderModelInfo_ ) - , stdOperatingPointCount( static_cast( stdOperatingPoints_.size() ) ) - , pStdOperatingPoints( stdOperatingPoints_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoEncodeAV1SessionParametersCreateInfoKHR & operator=( VideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeAV1SessionParametersCreateInfoKHR & operator=( VkVideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR & setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdSequenceHeader = pStdSequenceHeader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR && setPStdSequenceHeader( const StdVideoAV1SequenceHeader * pStdSequenceHeader_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdSequenceHeader = pStdSequenceHeader_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR & - setPStdDecoderModelInfo( const StdVideoEncodeAV1DecoderModelInfo * pStdDecoderModelInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdDecoderModelInfo = pStdDecoderModelInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR && - setPStdDecoderModelInfo( const StdVideoEncodeAV1DecoderModelInfo * pStdDecoderModelInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdDecoderModelInfo = pStdDecoderModelInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR & setStdOperatingPointCount( uint32_t stdOperatingPointCount_ ) & VULKAN_HPP_NOEXCEPT - { - stdOperatingPointCount = stdOperatingPointCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR && setStdOperatingPointCount( uint32_t stdOperatingPointCount_ ) && VULKAN_HPP_NOEXCEPT - { - stdOperatingPointCount = stdOperatingPointCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR & - setPStdOperatingPoints( const StdVideoEncodeAV1OperatingPointInfo * pStdOperatingPoints_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdOperatingPoints = pStdOperatingPoints_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeAV1SessionParametersCreateInfoKHR && - setPStdOperatingPoints( const StdVideoEncodeAV1OperatingPointInfo * pStdOperatingPoints_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdOperatingPoints = pStdOperatingPoints_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeAV1SessionParametersCreateInfoKHR & - setStdOperatingPoints( ArrayProxyNoTemporaries const & stdOperatingPoints_ ) VULKAN_HPP_NOEXCEPT - { - stdOperatingPointCount = static_cast( stdOperatingPoints_.size() ); - pStdOperatingPoints = stdOperatingPoints_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeAV1SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeAV1SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdSequenceHeader, pStdDecoderModelInfo, stdOperatingPointCount, pStdOperatingPoints ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeAV1SessionParametersCreateInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdSequenceHeader == rhs.pStdSequenceHeader ) && - ( pStdDecoderModelInfo == rhs.pStdDecoderModelInfo ) && ( stdOperatingPointCount == rhs.stdOperatingPointCount ) && - ( pStdOperatingPoints == rhs.pStdOperatingPoints ); -# endif - } - - bool operator!=( VideoEncodeAV1SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeAv1SessionParametersCreateInfoKHR; - const void * pNext = {}; - const StdVideoAV1SequenceHeader * pStdSequenceHeader = {}; - const StdVideoEncodeAV1DecoderModelInfo * pStdDecoderModelInfo = {}; - uint32_t stdOperatingPointCount = {}; - const StdVideoEncodeAV1OperatingPointInfo * pStdOperatingPoints = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeAV1SessionParametersCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeAV1SessionParametersCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeCapabilitiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeCapabilitiesKHR.html - struct VideoEncodeCapabilitiesKHR - { - using NativeType = VkVideoEncodeCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeCapabilitiesKHR( VideoEncodeCapabilityFlagsKHR flags_ = {}, - VideoEncodeRateControlModeFlagsKHR rateControlModes_ = {}, - uint32_t maxRateControlLayers_ = {}, - uint64_t maxBitrate_ = {}, - uint32_t maxQualityLevels_ = {}, - Extent2D encodeInputPictureGranularity_ = {}, - VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , rateControlModes{ rateControlModes_ } - , maxRateControlLayers{ maxRateControlLayers_ } - , maxBitrate{ maxBitrate_ } - , maxQualityLevels{ maxQualityLevels_ } - , encodeInputPictureGranularity{ encodeInputPictureGranularity_ } - , supportedEncodeFeedbackFlags{ supportedEncodeFeedbackFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeCapabilitiesKHR( VideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeCapabilitiesKHR( VkVideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeCapabilitiesKHR & operator=( VideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeCapabilitiesKHR & operator=( VkVideoEncodeCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - rateControlModes, - maxRateControlLayers, - maxBitrate, - maxQualityLevels, - encodeInputPictureGranularity, - supportedEncodeFeedbackFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeCapabilitiesKHR const & ) const = default; -#else - bool operator==( VideoEncodeCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlModes == rhs.rateControlModes ) && - ( maxRateControlLayers == rhs.maxRateControlLayers ) && ( maxBitrate == rhs.maxBitrate ) && ( maxQualityLevels == rhs.maxQualityLevels ) && - ( encodeInputPictureGranularity == rhs.encodeInputPictureGranularity ) && ( supportedEncodeFeedbackFlags == rhs.supportedEncodeFeedbackFlags ); -# endif - } - - bool operator!=( VideoEncodeCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeCapabilitiesKHR; - void * pNext = {}; - VideoEncodeCapabilityFlagsKHR flags = {}; - VideoEncodeRateControlModeFlagsKHR rateControlModes = {}; - uint32_t maxRateControlLayers = {}; - uint64_t maxBitrate = {}; - uint32_t maxQualityLevels = {}; - Extent2D encodeInputPictureGranularity = {}; - VideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeCapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264CapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264CapabilitiesKHR.html - struct VideoEncodeH264CapabilitiesKHR - { - using NativeType = VkVideoEncodeH264CapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264CapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesKHR( VideoEncodeH264CapabilityFlagsKHR flags_ = {}, - StdVideoH264LevelIdc maxLevelIdc_ = {}, - uint32_t maxSliceCount_ = {}, - uint32_t maxPPictureL0ReferenceCount_ = {}, - uint32_t maxBPictureL0ReferenceCount_ = {}, - uint32_t maxL1ReferenceCount_ = {}, - uint32_t maxTemporalLayerCount_ = {}, - Bool32 expectDyadicTemporalLayerPattern_ = {}, - int32_t minQp_ = {}, - int32_t maxQp_ = {}, - Bool32 prefersGopRemainingFrames_ = {}, - Bool32 requiresGopRemainingFrames_ = {}, - VideoEncodeH264StdFlagsKHR stdSyntaxFlags_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , maxLevelIdc{ maxLevelIdc_ } - , maxSliceCount{ maxSliceCount_ } - , maxPPictureL0ReferenceCount{ maxPPictureL0ReferenceCount_ } - , maxBPictureL0ReferenceCount{ maxBPictureL0ReferenceCount_ } - , maxL1ReferenceCount{ maxL1ReferenceCount_ } - , maxTemporalLayerCount{ maxTemporalLayerCount_ } - , expectDyadicTemporalLayerPattern{ expectDyadicTemporalLayerPattern_ } - , minQp{ minQp_ } - , maxQp{ maxQp_ } - , prefersGopRemainingFrames{ prefersGopRemainingFrames_ } - , requiresGopRemainingFrames{ requiresGopRemainingFrames_ } - , stdSyntaxFlags{ stdSyntaxFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264CapabilitiesKHR( VideoEncodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264CapabilitiesKHR( VkVideoEncodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264CapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264CapabilitiesKHR & operator=( VideoEncodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264CapabilitiesKHR & operator=( VkVideoEncodeH264CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeH264CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - maxLevelIdc, - maxSliceCount, - maxPPictureL0ReferenceCount, - maxBPictureL0ReferenceCount, - maxL1ReferenceCount, - maxTemporalLayerCount, - expectDyadicTemporalLayerPattern, - minQp, - maxQp, - prefersGopRemainingFrames, - requiresGopRemainingFrames, - stdSyntaxFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoEncodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = maxSliceCount <=> rhs.maxSliceCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxPPictureL0ReferenceCount <=> rhs.maxPPictureL0ReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxBPictureL0ReferenceCount <=> rhs.maxBPictureL0ReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxL1ReferenceCount <=> rhs.maxL1ReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxTemporalLayerCount <=> rhs.maxTemporalLayerCount; cmp != 0 ) - return cmp; - if ( auto cmp = expectDyadicTemporalLayerPattern <=> rhs.expectDyadicTemporalLayerPattern; cmp != 0 ) - return cmp; - if ( auto cmp = minQp <=> rhs.minQp; cmp != 0 ) - return cmp; - if ( auto cmp = maxQp <=> rhs.maxQp; cmp != 0 ) - return cmp; - if ( auto cmp = prefersGopRemainingFrames <=> rhs.prefersGopRemainingFrames; cmp != 0 ) - return cmp; - if ( auto cmp = requiresGopRemainingFrames <=> rhs.requiresGopRemainingFrames; cmp != 0 ) - return cmp; - if ( auto cmp = stdSyntaxFlags <=> rhs.stdSyntaxFlags; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoEncodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ) == 0 ) && ( maxSliceCount == rhs.maxSliceCount ) && - ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) && ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) && - ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) && ( maxTemporalLayerCount == rhs.maxTemporalLayerCount ) && - ( expectDyadicTemporalLayerPattern == rhs.expectDyadicTemporalLayerPattern ) && ( minQp == rhs.minQp ) && ( maxQp == rhs.maxQp ) && - ( prefersGopRemainingFrames == rhs.prefersGopRemainingFrames ) && ( requiresGopRemainingFrames == rhs.requiresGopRemainingFrames ) && - ( stdSyntaxFlags == rhs.stdSyntaxFlags ); - } - - bool operator!=( VideoEncodeH264CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoEncodeH264CapabilitiesKHR; - void * pNext = {}; - VideoEncodeH264CapabilityFlagsKHR flags = {}; - StdVideoH264LevelIdc maxLevelIdc = {}; - uint32_t maxSliceCount = {}; - uint32_t maxPPictureL0ReferenceCount = {}; - uint32_t maxBPictureL0ReferenceCount = {}; - uint32_t maxL1ReferenceCount = {}; - uint32_t maxTemporalLayerCount = {}; - Bool32 expectDyadicTemporalLayerPattern = {}; - int32_t minQp = {}; - int32_t maxQp = {}; - Bool32 prefersGopRemainingFrames = {}; - Bool32 requiresGopRemainingFrames = {}; - VideoEncodeH264StdFlagsKHR stdSyntaxFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264CapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264CapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264DpbSlotInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264DpbSlotInfoKHR.html - struct VideoEncodeH264DpbSlotInfoKHR - { - using NativeType = VkVideoEncodeH264DpbSlotInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264DpbSlotInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264DpbSlotInfoKHR( const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdReferenceInfo{ pStdReferenceInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264DpbSlotInfoKHR( VideoEncodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264DpbSlotInfoKHR( VkVideoEncodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264DpbSlotInfoKHR & operator=( VideoEncodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264DpbSlotInfoKHR & operator=( VkVideoEncodeH264DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdReferenceInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264DpbSlotInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); -# endif - } - - bool operator!=( VideoEncodeH264DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264DpbSlotInfoKHR; - const void * pNext = {}; - const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264DpbSlotInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264DpbSlotInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264FrameSizeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264FrameSizeKHR.html - struct VideoEncodeH264FrameSizeKHR - { - using NativeType = VkVideoEncodeH264FrameSizeKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264FrameSizeKHR( uint32_t frameISize_ = {}, uint32_t framePSize_ = {}, uint32_t frameBSize_ = {} ) VULKAN_HPP_NOEXCEPT - : frameISize{ frameISize_ } - , framePSize{ framePSize_ } - , frameBSize{ frameBSize_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264FrameSizeKHR( VideoEncodeH264FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264FrameSizeKHR( VkVideoEncodeH264FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264FrameSizeKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264FrameSizeKHR & operator=( VideoEncodeH264FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264FrameSizeKHR & operator=( VkVideoEncodeH264FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR & setFrameISize( uint32_t frameISize_ ) & VULKAN_HPP_NOEXCEPT - { - frameISize = frameISize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR && setFrameISize( uint32_t frameISize_ ) && VULKAN_HPP_NOEXCEPT - { - frameISize = frameISize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR & setFramePSize( uint32_t framePSize_ ) & VULKAN_HPP_NOEXCEPT - { - framePSize = framePSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR && setFramePSize( uint32_t framePSize_ ) && VULKAN_HPP_NOEXCEPT - { - framePSize = framePSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR & setFrameBSize( uint32_t frameBSize_ ) & VULKAN_HPP_NOEXCEPT - { - frameBSize = frameBSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264FrameSizeKHR && setFrameBSize( uint32_t frameBSize_ ) && VULKAN_HPP_NOEXCEPT - { - frameBSize = frameBSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264FrameSizeKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264FrameSizeKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264FrameSizeKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264FrameSizeKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( frameISize, framePSize, frameBSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264FrameSizeKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize ); -# endif - } - - bool operator!=( VideoEncodeH264FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t frameISize = {}; - uint32_t framePSize = {}; - uint32_t frameBSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264FrameSizeKHR; - }; -#endif - - // wrapper struct for struct VkVideoEncodeH264GopRemainingFrameInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264GopRemainingFrameInfoKHR.html - struct VideoEncodeH264GopRemainingFrameInfoKHR - { - using NativeType = VkVideoEncodeH264GopRemainingFrameInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264GopRemainingFrameInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264GopRemainingFrameInfoKHR( Bool32 useGopRemainingFrames_ = {}, - uint32_t gopRemainingI_ = {}, - uint32_t gopRemainingP_ = {}, - uint32_t gopRemainingB_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , useGopRemainingFrames{ useGopRemainingFrames_ } - , gopRemainingI{ gopRemainingI_ } - , gopRemainingP{ gopRemainingP_ } - , gopRemainingB{ gopRemainingB_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264GopRemainingFrameInfoKHR( VideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264GopRemainingFrameInfoKHR( VkVideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264GopRemainingFrameInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264GopRemainingFrameInfoKHR & operator=( VideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264GopRemainingFrameInfoKHR & operator=( VkVideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR & setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) & VULKAN_HPP_NOEXCEPT - { - useGopRemainingFrames = useGopRemainingFrames_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR && setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) && VULKAN_HPP_NOEXCEPT - { - useGopRemainingFrames = useGopRemainingFrames_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR & setGopRemainingI( uint32_t gopRemainingI_ ) & VULKAN_HPP_NOEXCEPT - { - gopRemainingI = gopRemainingI_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR && setGopRemainingI( uint32_t gopRemainingI_ ) && VULKAN_HPP_NOEXCEPT - { - gopRemainingI = gopRemainingI_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR & setGopRemainingP( uint32_t gopRemainingP_ ) & VULKAN_HPP_NOEXCEPT - { - gopRemainingP = gopRemainingP_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR && setGopRemainingP( uint32_t gopRemainingP_ ) && VULKAN_HPP_NOEXCEPT - { - gopRemainingP = gopRemainingP_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR & setGopRemainingB( uint32_t gopRemainingB_ ) & VULKAN_HPP_NOEXCEPT - { - gopRemainingB = gopRemainingB_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264GopRemainingFrameInfoKHR && setGopRemainingB( uint32_t gopRemainingB_ ) && VULKAN_HPP_NOEXCEPT - { - gopRemainingB = gopRemainingB_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264GopRemainingFrameInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264GopRemainingFrameInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264GopRemainingFrameInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264GopRemainingFrameInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, useGopRemainingFrames, gopRemainingI, gopRemainingP, gopRemainingB ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264GopRemainingFrameInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) && - ( gopRemainingI == rhs.gopRemainingI ) && ( gopRemainingP == rhs.gopRemainingP ) && ( gopRemainingB == rhs.gopRemainingB ); -# endif - } - - bool operator!=( VideoEncodeH264GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264GopRemainingFrameInfoKHR; - const void * pNext = {}; - Bool32 useGopRemainingFrames = {}; - uint32_t gopRemainingI = {}; - uint32_t gopRemainingP = {}; - uint32_t gopRemainingB = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264GopRemainingFrameInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264GopRemainingFrameInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264NaluSliceInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264NaluSliceInfoKHR.html - struct VideoEncodeH264NaluSliceInfoKHR - { - using NativeType = VkVideoEncodeH264NaluSliceInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264NaluSliceInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264NaluSliceInfoKHR( int32_t constantQp_ = {}, - const StdVideoEncodeH264SliceHeader * pStdSliceHeader_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , constantQp{ constantQp_ } - , pStdSliceHeader{ pStdSliceHeader_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264NaluSliceInfoKHR( VideoEncodeH264NaluSliceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264NaluSliceInfoKHR( VkVideoEncodeH264NaluSliceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264NaluSliceInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264NaluSliceInfoKHR & operator=( VideoEncodeH264NaluSliceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264NaluSliceInfoKHR & operator=( VkVideoEncodeH264NaluSliceInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR & setConstantQp( int32_t constantQp_ ) & VULKAN_HPP_NOEXCEPT - { - constantQp = constantQp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR && setConstantQp( int32_t constantQp_ ) && VULKAN_HPP_NOEXCEPT - { - constantQp = constantQp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR & setPStdSliceHeader( const StdVideoEncodeH264SliceHeader * pStdSliceHeader_ ) & VULKAN_HPP_NOEXCEPT - { - pStdSliceHeader = pStdSliceHeader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264NaluSliceInfoKHR && setPStdSliceHeader( const StdVideoEncodeH264SliceHeader * pStdSliceHeader_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdSliceHeader = pStdSliceHeader_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264NaluSliceInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264NaluSliceInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264NaluSliceInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264NaluSliceInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, constantQp, pStdSliceHeader ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264NaluSliceInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264NaluSliceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantQp == rhs.constantQp ) && ( pStdSliceHeader == rhs.pStdSliceHeader ); -# endif - } - - bool operator!=( VideoEncodeH264NaluSliceInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264NaluSliceInfoKHR; - const void * pNext = {}; - int32_t constantQp = {}; - const StdVideoEncodeH264SliceHeader * pStdSliceHeader = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264NaluSliceInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264NaluSliceInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264PictureInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264PictureInfoKHR.html - struct VideoEncodeH264PictureInfoKHR - { - using NativeType = VkVideoEncodeH264PictureInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264PictureInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264PictureInfoKHR( uint32_t naluSliceEntryCount_ = {}, - const VideoEncodeH264NaluSliceInfoKHR * pNaluSliceEntries_ = {}, - const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {}, - Bool32 generatePrefixNalu_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , naluSliceEntryCount{ naluSliceEntryCount_ } - , pNaluSliceEntries{ pNaluSliceEntries_ } - , pStdPictureInfo{ pStdPictureInfo_ } - , generatePrefixNalu{ generatePrefixNalu_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264PictureInfoKHR( VideoEncodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264PictureInfoKHR( VkVideoEncodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264PictureInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264PictureInfoKHR( ArrayProxyNoTemporaries const & naluSliceEntries_, - const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ = {}, - Bool32 generatePrefixNalu_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , naluSliceEntryCount( static_cast( naluSliceEntries_.size() ) ) - , pNaluSliceEntries( naluSliceEntries_.data() ) - , pStdPictureInfo( pStdPictureInfo_ ) - , generatePrefixNalu( generatePrefixNalu_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoEncodeH264PictureInfoKHR & operator=( VideoEncodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264PictureInfoKHR & operator=( VkVideoEncodeH264PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR & setNaluSliceEntryCount( uint32_t naluSliceEntryCount_ ) & VULKAN_HPP_NOEXCEPT - { - naluSliceEntryCount = naluSliceEntryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR && setNaluSliceEntryCount( uint32_t naluSliceEntryCount_ ) && VULKAN_HPP_NOEXCEPT - { - naluSliceEntryCount = naluSliceEntryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR & setPNaluSliceEntries( const VideoEncodeH264NaluSliceInfoKHR * pNaluSliceEntries_ ) & - VULKAN_HPP_NOEXCEPT - { - pNaluSliceEntries = pNaluSliceEntries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR && setPNaluSliceEntries( const VideoEncodeH264NaluSliceInfoKHR * pNaluSliceEntries_ ) && - VULKAN_HPP_NOEXCEPT - { - pNaluSliceEntries = pNaluSliceEntries_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264PictureInfoKHR & - setNaluSliceEntries( ArrayProxyNoTemporaries const & naluSliceEntries_ ) VULKAN_HPP_NOEXCEPT - { - naluSliceEntryCount = static_cast( naluSliceEntries_.size() ); - pNaluSliceEntries = naluSliceEntries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR & setPStdPictureInfo( const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR && setPStdPictureInfo( const StdVideoEncodeH264PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR & setGeneratePrefixNalu( Bool32 generatePrefixNalu_ ) & VULKAN_HPP_NOEXCEPT - { - generatePrefixNalu = generatePrefixNalu_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264PictureInfoKHR && setGeneratePrefixNalu( Bool32 generatePrefixNalu_ ) && VULKAN_HPP_NOEXCEPT - { - generatePrefixNalu = generatePrefixNalu_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264PictureInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264PictureInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, naluSliceEntryCount, pNaluSliceEntries, pStdPictureInfo, generatePrefixNalu ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264PictureInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( naluSliceEntryCount == rhs.naluSliceEntryCount ) && - ( pNaluSliceEntries == rhs.pNaluSliceEntries ) && ( pStdPictureInfo == rhs.pStdPictureInfo ) && ( generatePrefixNalu == rhs.generatePrefixNalu ); -# endif - } - - bool operator!=( VideoEncodeH264PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264PictureInfoKHR; - const void * pNext = {}; - uint32_t naluSliceEntryCount = {}; - const VideoEncodeH264NaluSliceInfoKHR * pNaluSliceEntries = {}; - const StdVideoEncodeH264PictureInfo * pStdPictureInfo = {}; - Bool32 generatePrefixNalu = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264PictureInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264PictureInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264ProfileInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264ProfileInfoKHR.html - struct VideoEncodeH264ProfileInfoKHR - { - using NativeType = VkVideoEncodeH264ProfileInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264ProfileInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264ProfileInfoKHR( StdVideoH264ProfileIdc stdProfileIdc_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stdProfileIdc{ stdProfileIdc_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264ProfileInfoKHR( VideoEncodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264ProfileInfoKHR( VkVideoEncodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264ProfileInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264ProfileInfoKHR & operator=( VideoEncodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264ProfileInfoKHR & operator=( VkVideoEncodeH264ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ProfileInfoKHR & setStdProfileIdc( StdVideoH264ProfileIdc stdProfileIdc_ ) & VULKAN_HPP_NOEXCEPT - { - stdProfileIdc = stdProfileIdc_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264ProfileInfoKHR && setStdProfileIdc( StdVideoH264ProfileIdc stdProfileIdc_ ) && VULKAN_HPP_NOEXCEPT - { - stdProfileIdc = stdProfileIdc_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stdProfileIdc ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoEncodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoEncodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH264ProfileIdc ) ) == 0 ); - } - - bool operator!=( VideoEncodeH264ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoEncodeH264ProfileInfoKHR; - const void * pNext = {}; - StdVideoH264ProfileIdc stdProfileIdc = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264ProfileInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264ProfileInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264QpKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264QpKHR.html - struct VideoEncodeH264QpKHR - { - using NativeType = VkVideoEncodeH264QpKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264QpKHR( int32_t qpI_ = {}, int32_t qpP_ = {}, int32_t qpB_ = {} ) VULKAN_HPP_NOEXCEPT - : qpI{ qpI_ } - , qpP{ qpP_ } - , qpB{ qpB_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264QpKHR( VideoEncodeH264QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264QpKHR( VkVideoEncodeH264QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264QpKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264QpKHR & operator=( VideoEncodeH264QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264QpKHR & operator=( VkVideoEncodeH264QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR & setQpI( int32_t qpI_ ) & VULKAN_HPP_NOEXCEPT - { - qpI = qpI_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR && setQpI( int32_t qpI_ ) && VULKAN_HPP_NOEXCEPT - { - qpI = qpI_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR & setQpP( int32_t qpP_ ) & VULKAN_HPP_NOEXCEPT - { - qpP = qpP_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR && setQpP( int32_t qpP_ ) && VULKAN_HPP_NOEXCEPT - { - qpP = qpP_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR & setQpB( int32_t qpB_ ) & VULKAN_HPP_NOEXCEPT - { - qpB = qpB_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264QpKHR && setQpB( int32_t qpB_ ) && VULKAN_HPP_NOEXCEPT - { - qpB = qpB_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264QpKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264QpKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264QpKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264QpKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( qpI, qpP, qpB ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264QpKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264QpKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); -# endif - } - - bool operator!=( VideoEncodeH264QpKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - int32_t qpI = {}; - int32_t qpP = {}; - int32_t qpB = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264QpKHR; - }; -#endif - - // wrapper struct for struct VkVideoEncodeH264QualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264QualityLevelPropertiesKHR.html - struct VideoEncodeH264QualityLevelPropertiesKHR - { - using NativeType = VkVideoEncodeH264QualityLevelPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264QualityLevelPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264QualityLevelPropertiesKHR( VideoEncodeH264RateControlFlagsKHR preferredRateControlFlags_ = {}, - uint32_t preferredGopFrameCount_ = {}, - uint32_t preferredIdrPeriod_ = {}, - uint32_t preferredConsecutiveBFrameCount_ = {}, - uint32_t preferredTemporalLayerCount_ = {}, - VideoEncodeH264QpKHR preferredConstantQp_ = {}, - uint32_t preferredMaxL0ReferenceCount_ = {}, - uint32_t preferredMaxL1ReferenceCount_ = {}, - Bool32 preferredStdEntropyCodingModeFlag_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , preferredRateControlFlags{ preferredRateControlFlags_ } - , preferredGopFrameCount{ preferredGopFrameCount_ } - , preferredIdrPeriod{ preferredIdrPeriod_ } - , preferredConsecutiveBFrameCount{ preferredConsecutiveBFrameCount_ } - , preferredTemporalLayerCount{ preferredTemporalLayerCount_ } - , preferredConstantQp{ preferredConstantQp_ } - , preferredMaxL0ReferenceCount{ preferredMaxL0ReferenceCount_ } - , preferredMaxL1ReferenceCount{ preferredMaxL1ReferenceCount_ } - , preferredStdEntropyCodingModeFlag{ preferredStdEntropyCodingModeFlag_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264QualityLevelPropertiesKHR( VideoEncodeH264QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264QualityLevelPropertiesKHR( VkVideoEncodeH264QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264QualityLevelPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264QualityLevelPropertiesKHR & operator=( VideoEncodeH264QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264QualityLevelPropertiesKHR & operator=( VkVideoEncodeH264QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeH264QualityLevelPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264QualityLevelPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264QualityLevelPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264QualityLevelPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - preferredRateControlFlags, - preferredGopFrameCount, - preferredIdrPeriod, - preferredConsecutiveBFrameCount, - preferredTemporalLayerCount, - preferredConstantQp, - preferredMaxL0ReferenceCount, - preferredMaxL1ReferenceCount, - preferredStdEntropyCodingModeFlag ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264QualityLevelPropertiesKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) && - ( preferredGopFrameCount == rhs.preferredGopFrameCount ) && ( preferredIdrPeriod == rhs.preferredIdrPeriod ) && - ( preferredConsecutiveBFrameCount == rhs.preferredConsecutiveBFrameCount ) && ( preferredTemporalLayerCount == rhs.preferredTemporalLayerCount ) && - ( preferredConstantQp == rhs.preferredConstantQp ) && ( preferredMaxL0ReferenceCount == rhs.preferredMaxL0ReferenceCount ) && - ( preferredMaxL1ReferenceCount == rhs.preferredMaxL1ReferenceCount ) && - ( preferredStdEntropyCodingModeFlag == rhs.preferredStdEntropyCodingModeFlag ); -# endif - } - - bool operator!=( VideoEncodeH264QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264QualityLevelPropertiesKHR; - void * pNext = {}; - VideoEncodeH264RateControlFlagsKHR preferredRateControlFlags = {}; - uint32_t preferredGopFrameCount = {}; - uint32_t preferredIdrPeriod = {}; - uint32_t preferredConsecutiveBFrameCount = {}; - uint32_t preferredTemporalLayerCount = {}; - VideoEncodeH264QpKHR preferredConstantQp = {}; - uint32_t preferredMaxL0ReferenceCount = {}; - uint32_t preferredMaxL1ReferenceCount = {}; - Bool32 preferredStdEntropyCodingModeFlag = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264QualityLevelPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264QualityLevelPropertiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264QuantizationMapCapabilitiesKHR.html - struct VideoEncodeH264QuantizationMapCapabilitiesKHR - { - using NativeType = VkVideoEncodeH264QuantizationMapCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264QuantizationMapCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoEncodeH264QuantizationMapCapabilitiesKHR( int32_t minQpDelta_ = {}, int32_t maxQpDelta_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minQpDelta{ minQpDelta_ } - , maxQpDelta{ maxQpDelta_ } - { - } - - VULKAN_HPP_CONSTEXPR - VideoEncodeH264QuantizationMapCapabilitiesKHR( VideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264QuantizationMapCapabilitiesKHR( VkVideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264QuantizationMapCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264QuantizationMapCapabilitiesKHR & operator=( VideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264QuantizationMapCapabilitiesKHR & operator=( VkVideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeH264QuantizationMapCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264QuantizationMapCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264QuantizationMapCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264QuantizationMapCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minQpDelta, maxQpDelta ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264QuantizationMapCapabilitiesKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minQpDelta == rhs.minQpDelta ) && ( maxQpDelta == rhs.maxQpDelta ); -# endif - } - - bool operator!=( VideoEncodeH264QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264QuantizationMapCapabilitiesKHR; - void * pNext = {}; - int32_t minQpDelta = {}; - int32_t maxQpDelta = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264QuantizationMapCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264QuantizationMapCapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264RateControlInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlInfoKHR.html - struct VideoEncodeH264RateControlInfoKHR - { - using NativeType = VkVideoEncodeH264RateControlInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264RateControlInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoKHR( VideoEncodeH264RateControlFlagsKHR flags_ = {}, - uint32_t gopFrameCount_ = {}, - uint32_t idrPeriod_ = {}, - uint32_t consecutiveBFrameCount_ = {}, - uint32_t temporalLayerCount_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , gopFrameCount{ gopFrameCount_ } - , idrPeriod{ idrPeriod_ } - , consecutiveBFrameCount{ consecutiveBFrameCount_ } - , temporalLayerCount{ temporalLayerCount_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlInfoKHR( VideoEncodeH264RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264RateControlInfoKHR( VkVideoEncodeH264RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264RateControlInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264RateControlInfoKHR & operator=( VideoEncodeH264RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264RateControlInfoKHR & operator=( VkVideoEncodeH264RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setFlags( VideoEncodeH264RateControlFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setFlags( VideoEncodeH264RateControlFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setGopFrameCount( uint32_t gopFrameCount_ ) & VULKAN_HPP_NOEXCEPT - { - gopFrameCount = gopFrameCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setGopFrameCount( uint32_t gopFrameCount_ ) && VULKAN_HPP_NOEXCEPT - { - gopFrameCount = gopFrameCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setIdrPeriod( uint32_t idrPeriod_ ) & VULKAN_HPP_NOEXCEPT - { - idrPeriod = idrPeriod_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setIdrPeriod( uint32_t idrPeriod_ ) && VULKAN_HPP_NOEXCEPT - { - idrPeriod = idrPeriod_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) & VULKAN_HPP_NOEXCEPT - { - consecutiveBFrameCount = consecutiveBFrameCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) && VULKAN_HPP_NOEXCEPT - { - consecutiveBFrameCount = consecutiveBFrameCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR & setTemporalLayerCount( uint32_t temporalLayerCount_ ) & VULKAN_HPP_NOEXCEPT - { - temporalLayerCount = temporalLayerCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlInfoKHR && setTemporalLayerCount( uint32_t temporalLayerCount_ ) && VULKAN_HPP_NOEXCEPT - { - temporalLayerCount = temporalLayerCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264RateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264RateControlInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264RateControlInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264RateControlInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, gopFrameCount, idrPeriod, consecutiveBFrameCount, temporalLayerCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264RateControlInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) && - ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( temporalLayerCount == rhs.temporalLayerCount ); -# endif - } - - bool operator!=( VideoEncodeH264RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264RateControlInfoKHR; - const void * pNext = {}; - VideoEncodeH264RateControlFlagsKHR flags = {}; - uint32_t gopFrameCount = {}; - uint32_t idrPeriod = {}; - uint32_t consecutiveBFrameCount = {}; - uint32_t temporalLayerCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264RateControlInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264RateControlInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264RateControlLayerInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264RateControlLayerInfoKHR.html - struct VideoEncodeH264RateControlLayerInfoKHR - { - using NativeType = VkVideoEncodeH264RateControlLayerInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264RateControlLayerInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlLayerInfoKHR( Bool32 useMinQp_ = {}, - VideoEncodeH264QpKHR minQp_ = {}, - Bool32 useMaxQp_ = {}, - VideoEncodeH264QpKHR maxQp_ = {}, - Bool32 useMaxFrameSize_ = {}, - VideoEncodeH264FrameSizeKHR maxFrameSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , useMinQp{ useMinQp_ } - , minQp{ minQp_ } - , useMaxQp{ useMaxQp_ } - , maxQp{ maxQp_ } - , useMaxFrameSize{ useMaxFrameSize_ } - , maxFrameSize{ maxFrameSize_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264RateControlLayerInfoKHR( VideoEncodeH264RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264RateControlLayerInfoKHR( VkVideoEncodeH264RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264RateControlLayerInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264RateControlLayerInfoKHR & operator=( VideoEncodeH264RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264RateControlLayerInfoKHR & operator=( VkVideoEncodeH264RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setUseMinQp( Bool32 useMinQp_ ) & VULKAN_HPP_NOEXCEPT - { - useMinQp = useMinQp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setUseMinQp( Bool32 useMinQp_ ) && VULKAN_HPP_NOEXCEPT - { - useMinQp = useMinQp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setMinQp( VideoEncodeH264QpKHR const & minQp_ ) & VULKAN_HPP_NOEXCEPT - { - minQp = minQp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setMinQp( VideoEncodeH264QpKHR const & minQp_ ) && VULKAN_HPP_NOEXCEPT - { - minQp = minQp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setUseMaxQp( Bool32 useMaxQp_ ) & VULKAN_HPP_NOEXCEPT - { - useMaxQp = useMaxQp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setUseMaxQp( Bool32 useMaxQp_ ) && VULKAN_HPP_NOEXCEPT - { - useMaxQp = useMaxQp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setMaxQp( VideoEncodeH264QpKHR const & maxQp_ ) & VULKAN_HPP_NOEXCEPT - { - maxQp = maxQp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setMaxQp( VideoEncodeH264QpKHR const & maxQp_ ) && VULKAN_HPP_NOEXCEPT - { - maxQp = maxQp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) & VULKAN_HPP_NOEXCEPT - { - useMaxFrameSize = useMaxFrameSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) && VULKAN_HPP_NOEXCEPT - { - useMaxFrameSize = useMaxFrameSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR & setMaxFrameSize( VideoEncodeH264FrameSizeKHR const & maxFrameSize_ ) & VULKAN_HPP_NOEXCEPT - { - maxFrameSize = maxFrameSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264RateControlLayerInfoKHR && setMaxFrameSize( VideoEncodeH264FrameSizeKHR const & maxFrameSize_ ) && - VULKAN_HPP_NOEXCEPT - { - maxFrameSize = maxFrameSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264RateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264RateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264RateControlLayerInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264RateControlLayerInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264RateControlLayerInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && - ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && ( maxFrameSize == rhs.maxFrameSize ); -# endif - } - - bool operator!=( VideoEncodeH264RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264RateControlLayerInfoKHR; - const void * pNext = {}; - Bool32 useMinQp = {}; - VideoEncodeH264QpKHR minQp = {}; - Bool32 useMaxQp = {}; - VideoEncodeH264QpKHR maxQp = {}; - Bool32 useMaxFrameSize = {}; - VideoEncodeH264FrameSizeKHR maxFrameSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264RateControlLayerInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264RateControlLayerInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264SessionCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionCreateInfoKHR.html - struct VideoEncodeH264SessionCreateInfoKHR - { - using NativeType = VkVideoEncodeH264SessionCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionCreateInfoKHR( Bool32 useMaxLevelIdc_ = {}, - StdVideoH264LevelIdc maxLevelIdc_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , useMaxLevelIdc{ useMaxLevelIdc_ } - , maxLevelIdc{ maxLevelIdc_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionCreateInfoKHR( VideoEncodeH264SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264SessionCreateInfoKHR( VkVideoEncodeH264SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264SessionCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264SessionCreateInfoKHR & operator=( VideoEncodeH264SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264SessionCreateInfoKHR & operator=( VkVideoEncodeH264SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR & setUseMaxLevelIdc( Bool32 useMaxLevelIdc_ ) & VULKAN_HPP_NOEXCEPT - { - useMaxLevelIdc = useMaxLevelIdc_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR && setUseMaxLevelIdc( Bool32 useMaxLevelIdc_ ) && VULKAN_HPP_NOEXCEPT - { - useMaxLevelIdc = useMaxLevelIdc_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR & setMaxLevelIdc( StdVideoH264LevelIdc maxLevelIdc_ ) & VULKAN_HPP_NOEXCEPT - { - maxLevelIdc = maxLevelIdc_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionCreateInfoKHR && setMaxLevelIdc( StdVideoH264LevelIdc maxLevelIdc_ ) && VULKAN_HPP_NOEXCEPT - { - maxLevelIdc = maxLevelIdc_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264SessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, useMaxLevelIdc, maxLevelIdc ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoEncodeH264SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = useMaxLevelIdc <=> rhs.useMaxLevelIdc; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoEncodeH264SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevelIdc == rhs.useMaxLevelIdc ) && - ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH264LevelIdc ) ) == 0 ); - } - - bool operator!=( VideoEncodeH264SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoEncodeH264SessionCreateInfoKHR; - const void * pNext = {}; - Bool32 useMaxLevelIdc = {}; - StdVideoH264LevelIdc maxLevelIdc = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264SessionCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264SessionCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264SessionParametersAddInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersAddInfoKHR.html - struct VideoEncodeH264SessionParametersAddInfoKHR - { - using NativeType = VkVideoEncodeH264SessionParametersAddInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersAddInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersAddInfoKHR( uint32_t stdSPSCount_ = {}, - const StdVideoH264SequenceParameterSet * pStdSPSs_ = {}, - uint32_t stdPPSCount_ = {}, - const StdVideoH264PictureParameterSet * pStdPPSs_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stdSPSCount{ stdSPSCount_ } - , pStdSPSs{ pStdSPSs_ } - , stdPPSCount{ stdPPSCount_ } - , pStdPPSs{ pStdPPSs_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersAddInfoKHR( VideoEncodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264SessionParametersAddInfoKHR( VkVideoEncodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264SessionParametersAddInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264SessionParametersAddInfoKHR( ArrayProxyNoTemporaries const & stdSPSs_, - ArrayProxyNoTemporaries const & stdPPSs_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , stdSPSCount( static_cast( stdSPSs_.size() ) ) - , pStdSPSs( stdSPSs_.data() ) - , stdPPSCount( static_cast( stdPPSs_.size() ) ) - , pStdPPSs( stdPPSs_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoEncodeH264SessionParametersAddInfoKHR & operator=( VideoEncodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264SessionParametersAddInfoKHR & operator=( VkVideoEncodeH264SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR & setStdSPSCount( uint32_t stdSPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - stdSPSCount = stdSPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR && setStdSPSCount( uint32_t stdSPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - stdSPSCount = stdSPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR & setPStdSPSs( const StdVideoH264SequenceParameterSet * pStdSPSs_ ) & VULKAN_HPP_NOEXCEPT - { - pStdSPSs = pStdSPSs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR && setPStdSPSs( const StdVideoH264SequenceParameterSet * pStdSPSs_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdSPSs = pStdSPSs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264SessionParametersAddInfoKHR & - setStdSPSs( ArrayProxyNoTemporaries const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT - { - stdSPSCount = static_cast( stdSPSs_.size() ); - pStdSPSs = stdSPSs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR & setStdPPSCount( uint32_t stdPPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - stdPPSCount = stdPPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR && setStdPPSCount( uint32_t stdPPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - stdPPSCount = stdPPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR & setPStdPPSs( const StdVideoH264PictureParameterSet * pStdPPSs_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPPSs = pStdPPSs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersAddInfoKHR && setPStdPPSs( const StdVideoH264PictureParameterSet * pStdPPSs_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdPPSs = pStdPPSs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH264SessionParametersAddInfoKHR & - setStdPPSs( ArrayProxyNoTemporaries const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT - { - stdPPSCount = static_cast( stdPPSs_.size() ); - pStdPPSs = stdPPSs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264SessionParametersAddInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersAddInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersAddInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersAddInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264SessionParametersAddInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && - ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs ); -# endif - } - - bool operator!=( VideoEncodeH264SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264SessionParametersAddInfoKHR; - const void * pNext = {}; - uint32_t stdSPSCount = {}; - const StdVideoH264SequenceParameterSet * pStdSPSs = {}; - uint32_t stdPPSCount = {}; - const StdVideoH264PictureParameterSet * pStdPPSs = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264SessionParametersAddInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264SessionParametersAddInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264SessionParametersCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersCreateInfoKHR.html - struct VideoEncodeH264SessionParametersCreateInfoKHR - { - using NativeType = VkVideoEncodeH264SessionParametersCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersCreateInfoKHR( uint32_t maxStdSPSCount_ = {}, - uint32_t maxStdPPSCount_ = {}, - const VideoEncodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxStdSPSCount{ maxStdSPSCount_ } - , maxStdPPSCount{ maxStdPPSCount_ } - , pParametersAddInfo{ pParametersAddInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR - VideoEncodeH264SessionParametersCreateInfoKHR( VideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264SessionParametersCreateInfoKHR( VkVideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264SessionParametersCreateInfoKHR & operator=( VideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264SessionParametersCreateInfoKHR & operator=( VkVideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxStdSPSCount = maxStdSPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR && setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxStdSPSCount = maxStdSPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxStdPPSCount = maxStdPPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR && setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxStdPPSCount = maxStdPPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR & - setPParametersAddInfo( const VideoEncodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pParametersAddInfo = pParametersAddInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersCreateInfoKHR && - setPParametersAddInfo( const VideoEncodeH264SessionParametersAddInfoKHR * pParametersAddInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pParametersAddInfo = pParametersAddInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264SessionParametersCreateInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && ( maxStdPPSCount == rhs.maxStdPPSCount ) && - ( pParametersAddInfo == rhs.pParametersAddInfo ); -# endif - } - - bool operator!=( VideoEncodeH264SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264SessionParametersCreateInfoKHR; - const void * pNext = {}; - uint32_t maxStdSPSCount = {}; - uint32_t maxStdPPSCount = {}; - const VideoEncodeH264SessionParametersAddInfoKHR * pParametersAddInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264SessionParametersCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264SessionParametersCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersFeedbackInfoKHR.html - struct VideoEncodeH264SessionParametersFeedbackInfoKHR - { - using NativeType = VkVideoEncodeH264SessionParametersFeedbackInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersFeedbackInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersFeedbackInfoKHR( Bool32 hasStdSPSOverrides_ = {}, - Bool32 hasStdPPSOverrides_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , hasStdSPSOverrides{ hasStdSPSOverrides_ } - , hasStdPPSOverrides{ hasStdPPSOverrides_ } - { - } - - VULKAN_HPP_CONSTEXPR - VideoEncodeH264SessionParametersFeedbackInfoKHR( VideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264SessionParametersFeedbackInfoKHR( VkVideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264SessionParametersFeedbackInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264SessionParametersFeedbackInfoKHR & operator=( VideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264SessionParametersFeedbackInfoKHR & operator=( VkVideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeH264SessionParametersFeedbackInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersFeedbackInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersFeedbackInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersFeedbackInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, hasStdSPSOverrides, hasStdPPSOverrides ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264SessionParametersFeedbackInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasStdSPSOverrides == rhs.hasStdSPSOverrides ) && - ( hasStdPPSOverrides == rhs.hasStdPPSOverrides ); -# endif - } - - bool operator!=( VideoEncodeH264SessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264SessionParametersFeedbackInfoKHR; - void * pNext = {}; - Bool32 hasStdSPSOverrides = {}; - Bool32 hasStdPPSOverrides = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264SessionParametersFeedbackInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264SessionParametersFeedbackInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH264SessionParametersGetInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH264SessionParametersGetInfoKHR.html - struct VideoEncodeH264SessionParametersGetInfoKHR - { - using NativeType = VkVideoEncodeH264SessionParametersGetInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH264SessionParametersGetInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersGetInfoKHR( - Bool32 writeStdSPS_ = {}, Bool32 writeStdPPS_ = {}, uint32_t stdSPSId_ = {}, uint32_t stdPPSId_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , writeStdSPS{ writeStdSPS_ } - , writeStdPPS{ writeStdPPS_ } - , stdSPSId{ stdSPSId_ } - , stdPPSId{ stdPPSId_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH264SessionParametersGetInfoKHR( VideoEncodeH264SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH264SessionParametersGetInfoKHR( VkVideoEncodeH264SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH264SessionParametersGetInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH264SessionParametersGetInfoKHR & operator=( VideoEncodeH264SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH264SessionParametersGetInfoKHR & operator=( VkVideoEncodeH264SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR & setWriteStdSPS( Bool32 writeStdSPS_ ) & VULKAN_HPP_NOEXCEPT - { - writeStdSPS = writeStdSPS_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR && setWriteStdSPS( Bool32 writeStdSPS_ ) && VULKAN_HPP_NOEXCEPT - { - writeStdSPS = writeStdSPS_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR & setWriteStdPPS( Bool32 writeStdPPS_ ) & VULKAN_HPP_NOEXCEPT - { - writeStdPPS = writeStdPPS_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR && setWriteStdPPS( Bool32 writeStdPPS_ ) && VULKAN_HPP_NOEXCEPT - { - writeStdPPS = writeStdPPS_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR & setStdSPSId( uint32_t stdSPSId_ ) & VULKAN_HPP_NOEXCEPT - { - stdSPSId = stdSPSId_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR && setStdSPSId( uint32_t stdSPSId_ ) && VULKAN_HPP_NOEXCEPT - { - stdSPSId = stdSPSId_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR & setStdPPSId( uint32_t stdPPSId_ ) & VULKAN_HPP_NOEXCEPT - { - stdPPSId = stdPPSId_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH264SessionParametersGetInfoKHR && setStdPPSId( uint32_t stdPPSId_ ) && VULKAN_HPP_NOEXCEPT - { - stdPPSId = stdPPSId_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH264SessionParametersGetInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersGetInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersGetInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH264SessionParametersGetInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, writeStdSPS, writeStdPPS, stdSPSId, stdPPSId ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH264SessionParametersGetInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH264SessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( writeStdSPS == rhs.writeStdSPS ) && ( writeStdPPS == rhs.writeStdPPS ) && - ( stdSPSId == rhs.stdSPSId ) && ( stdPPSId == rhs.stdPPSId ); -# endif - } - - bool operator!=( VideoEncodeH264SessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH264SessionParametersGetInfoKHR; - const void * pNext = {}; - Bool32 writeStdSPS = {}; - Bool32 writeStdPPS = {}; - uint32_t stdSPSId = {}; - uint32_t stdPPSId = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH264SessionParametersGetInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH264SessionParametersGetInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265CapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265CapabilitiesKHR.html - struct VideoEncodeH265CapabilitiesKHR - { - using NativeType = VkVideoEncodeH265CapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265CapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesKHR( VideoEncodeH265CapabilityFlagsKHR flags_ = {}, - StdVideoH265LevelIdc maxLevelIdc_ = {}, - uint32_t maxSliceSegmentCount_ = {}, - Extent2D maxTiles_ = {}, - VideoEncodeH265CtbSizeFlagsKHR ctbSizes_ = {}, - VideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes_ = {}, - uint32_t maxPPictureL0ReferenceCount_ = {}, - uint32_t maxBPictureL0ReferenceCount_ = {}, - uint32_t maxL1ReferenceCount_ = {}, - uint32_t maxSubLayerCount_ = {}, - Bool32 expectDyadicTemporalSubLayerPattern_ = {}, - int32_t minQp_ = {}, - int32_t maxQp_ = {}, - Bool32 prefersGopRemainingFrames_ = {}, - Bool32 requiresGopRemainingFrames_ = {}, - VideoEncodeH265StdFlagsKHR stdSyntaxFlags_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , maxLevelIdc{ maxLevelIdc_ } - , maxSliceSegmentCount{ maxSliceSegmentCount_ } - , maxTiles{ maxTiles_ } - , ctbSizes{ ctbSizes_ } - , transformBlockSizes{ transformBlockSizes_ } - , maxPPictureL0ReferenceCount{ maxPPictureL0ReferenceCount_ } - , maxBPictureL0ReferenceCount{ maxBPictureL0ReferenceCount_ } - , maxL1ReferenceCount{ maxL1ReferenceCount_ } - , maxSubLayerCount{ maxSubLayerCount_ } - , expectDyadicTemporalSubLayerPattern{ expectDyadicTemporalSubLayerPattern_ } - , minQp{ minQp_ } - , maxQp{ maxQp_ } - , prefersGopRemainingFrames{ prefersGopRemainingFrames_ } - , requiresGopRemainingFrames{ requiresGopRemainingFrames_ } - , stdSyntaxFlags{ stdSyntaxFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265CapabilitiesKHR( VideoEncodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265CapabilitiesKHR( VkVideoEncodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265CapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265CapabilitiesKHR & operator=( VideoEncodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265CapabilitiesKHR & operator=( VkVideoEncodeH265CapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeH265CapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265CapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265CapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265CapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - maxLevelIdc, - maxSliceSegmentCount, - maxTiles, - ctbSizes, - transformBlockSizes, - maxPPictureL0ReferenceCount, - maxBPictureL0ReferenceCount, - maxL1ReferenceCount, - maxSubLayerCount, - expectDyadicTemporalSubLayerPattern, - minQp, - maxQp, - prefersGopRemainingFrames, - requiresGopRemainingFrames, - stdSyntaxFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoEncodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - if ( auto cmp = maxSliceSegmentCount <=> rhs.maxSliceSegmentCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxTiles <=> rhs.maxTiles; cmp != 0 ) - return cmp; - if ( auto cmp = ctbSizes <=> rhs.ctbSizes; cmp != 0 ) - return cmp; - if ( auto cmp = transformBlockSizes <=> rhs.transformBlockSizes; cmp != 0 ) - return cmp; - if ( auto cmp = maxPPictureL0ReferenceCount <=> rhs.maxPPictureL0ReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxBPictureL0ReferenceCount <=> rhs.maxBPictureL0ReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxL1ReferenceCount <=> rhs.maxL1ReferenceCount; cmp != 0 ) - return cmp; - if ( auto cmp = maxSubLayerCount <=> rhs.maxSubLayerCount; cmp != 0 ) - return cmp; - if ( auto cmp = expectDyadicTemporalSubLayerPattern <=> rhs.expectDyadicTemporalSubLayerPattern; cmp != 0 ) - return cmp; - if ( auto cmp = minQp <=> rhs.minQp; cmp != 0 ) - return cmp; - if ( auto cmp = maxQp <=> rhs.maxQp; cmp != 0 ) - return cmp; - if ( auto cmp = prefersGopRemainingFrames <=> rhs.prefersGopRemainingFrames; cmp != 0 ) - return cmp; - if ( auto cmp = requiresGopRemainingFrames <=> rhs.requiresGopRemainingFrames; cmp != 0 ) - return cmp; - if ( auto cmp = stdSyntaxFlags <=> rhs.stdSyntaxFlags; cmp != 0 ) - return cmp; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoEncodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ) == 0 ) && ( maxSliceSegmentCount == rhs.maxSliceSegmentCount ) && - ( maxTiles == rhs.maxTiles ) && ( ctbSizes == rhs.ctbSizes ) && ( transformBlockSizes == rhs.transformBlockSizes ) && - ( maxPPictureL0ReferenceCount == rhs.maxPPictureL0ReferenceCount ) && ( maxBPictureL0ReferenceCount == rhs.maxBPictureL0ReferenceCount ) && - ( maxL1ReferenceCount == rhs.maxL1ReferenceCount ) && ( maxSubLayerCount == rhs.maxSubLayerCount ) && - ( expectDyadicTemporalSubLayerPattern == rhs.expectDyadicTemporalSubLayerPattern ) && ( minQp == rhs.minQp ) && ( maxQp == rhs.maxQp ) && - ( prefersGopRemainingFrames == rhs.prefersGopRemainingFrames ) && ( requiresGopRemainingFrames == rhs.requiresGopRemainingFrames ) && - ( stdSyntaxFlags == rhs.stdSyntaxFlags ); - } - - bool operator!=( VideoEncodeH265CapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoEncodeH265CapabilitiesKHR; - void * pNext = {}; - VideoEncodeH265CapabilityFlagsKHR flags = {}; - StdVideoH265LevelIdc maxLevelIdc = {}; - uint32_t maxSliceSegmentCount = {}; - Extent2D maxTiles = {}; - VideoEncodeH265CtbSizeFlagsKHR ctbSizes = {}; - VideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes = {}; - uint32_t maxPPictureL0ReferenceCount = {}; - uint32_t maxBPictureL0ReferenceCount = {}; - uint32_t maxL1ReferenceCount = {}; - uint32_t maxSubLayerCount = {}; - Bool32 expectDyadicTemporalSubLayerPattern = {}; - int32_t minQp = {}; - int32_t maxQp = {}; - Bool32 prefersGopRemainingFrames = {}; - Bool32 requiresGopRemainingFrames = {}; - VideoEncodeH265StdFlagsKHR stdSyntaxFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265CapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265CapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265DpbSlotInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265DpbSlotInfoKHR.html - struct VideoEncodeH265DpbSlotInfoKHR - { - using NativeType = VkVideoEncodeH265DpbSlotInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265DpbSlotInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265DpbSlotInfoKHR( const StdVideoEncodeH265ReferenceInfo * pStdReferenceInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , pStdReferenceInfo{ pStdReferenceInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265DpbSlotInfoKHR( VideoEncodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265DpbSlotInfoKHR( VkVideoEncodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265DpbSlotInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265DpbSlotInfoKHR & operator=( VideoEncodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265DpbSlotInfoKHR & operator=( VkVideoEncodeH265DpbSlotInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265DpbSlotInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265DpbSlotInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265DpbSlotInfoKHR & setPStdReferenceInfo( const StdVideoEncodeH265ReferenceInfo * pStdReferenceInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265DpbSlotInfoKHR && setPStdReferenceInfo( const StdVideoEncodeH265ReferenceInfo * pStdReferenceInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdReferenceInfo = pStdReferenceInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265DpbSlotInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265DpbSlotInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265DpbSlotInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265DpbSlotInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, pStdReferenceInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265DpbSlotInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( pStdReferenceInfo == rhs.pStdReferenceInfo ); -# endif - } - - bool operator!=( VideoEncodeH265DpbSlotInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265DpbSlotInfoKHR; - const void * pNext = {}; - const StdVideoEncodeH265ReferenceInfo * pStdReferenceInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265DpbSlotInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265DpbSlotInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265FrameSizeKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265FrameSizeKHR.html - struct VideoEncodeH265FrameSizeKHR - { - using NativeType = VkVideoEncodeH265FrameSizeKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265FrameSizeKHR( uint32_t frameISize_ = {}, uint32_t framePSize_ = {}, uint32_t frameBSize_ = {} ) VULKAN_HPP_NOEXCEPT - : frameISize{ frameISize_ } - , framePSize{ framePSize_ } - , frameBSize{ frameBSize_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265FrameSizeKHR( VideoEncodeH265FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265FrameSizeKHR( VkVideoEncodeH265FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265FrameSizeKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265FrameSizeKHR & operator=( VideoEncodeH265FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265FrameSizeKHR & operator=( VkVideoEncodeH265FrameSizeKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR & setFrameISize( uint32_t frameISize_ ) & VULKAN_HPP_NOEXCEPT - { - frameISize = frameISize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR && setFrameISize( uint32_t frameISize_ ) && VULKAN_HPP_NOEXCEPT - { - frameISize = frameISize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR & setFramePSize( uint32_t framePSize_ ) & VULKAN_HPP_NOEXCEPT - { - framePSize = framePSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR && setFramePSize( uint32_t framePSize_ ) && VULKAN_HPP_NOEXCEPT - { - framePSize = framePSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR & setFrameBSize( uint32_t frameBSize_ ) & VULKAN_HPP_NOEXCEPT - { - frameBSize = frameBSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265FrameSizeKHR && setFrameBSize( uint32_t frameBSize_ ) && VULKAN_HPP_NOEXCEPT - { - frameBSize = frameBSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265FrameSizeKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265FrameSizeKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265FrameSizeKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265FrameSizeKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( frameISize, framePSize, frameBSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265FrameSizeKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( frameISize == rhs.frameISize ) && ( framePSize == rhs.framePSize ) && ( frameBSize == rhs.frameBSize ); -# endif - } - - bool operator!=( VideoEncodeH265FrameSizeKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - uint32_t frameISize = {}; - uint32_t framePSize = {}; - uint32_t frameBSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265FrameSizeKHR; - }; -#endif - - // wrapper struct for struct VkVideoEncodeH265GopRemainingFrameInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265GopRemainingFrameInfoKHR.html - struct VideoEncodeH265GopRemainingFrameInfoKHR - { - using NativeType = VkVideoEncodeH265GopRemainingFrameInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265GopRemainingFrameInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265GopRemainingFrameInfoKHR( Bool32 useGopRemainingFrames_ = {}, - uint32_t gopRemainingI_ = {}, - uint32_t gopRemainingP_ = {}, - uint32_t gopRemainingB_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , useGopRemainingFrames{ useGopRemainingFrames_ } - , gopRemainingI{ gopRemainingI_ } - , gopRemainingP{ gopRemainingP_ } - , gopRemainingB{ gopRemainingB_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265GopRemainingFrameInfoKHR( VideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265GopRemainingFrameInfoKHR( VkVideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265GopRemainingFrameInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265GopRemainingFrameInfoKHR & operator=( VideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265GopRemainingFrameInfoKHR & operator=( VkVideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR & setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) & VULKAN_HPP_NOEXCEPT - { - useGopRemainingFrames = useGopRemainingFrames_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR && setUseGopRemainingFrames( Bool32 useGopRemainingFrames_ ) && VULKAN_HPP_NOEXCEPT - { - useGopRemainingFrames = useGopRemainingFrames_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR & setGopRemainingI( uint32_t gopRemainingI_ ) & VULKAN_HPP_NOEXCEPT - { - gopRemainingI = gopRemainingI_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR && setGopRemainingI( uint32_t gopRemainingI_ ) && VULKAN_HPP_NOEXCEPT - { - gopRemainingI = gopRemainingI_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR & setGopRemainingP( uint32_t gopRemainingP_ ) & VULKAN_HPP_NOEXCEPT - { - gopRemainingP = gopRemainingP_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR && setGopRemainingP( uint32_t gopRemainingP_ ) && VULKAN_HPP_NOEXCEPT - { - gopRemainingP = gopRemainingP_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR & setGopRemainingB( uint32_t gopRemainingB_ ) & VULKAN_HPP_NOEXCEPT - { - gopRemainingB = gopRemainingB_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265GopRemainingFrameInfoKHR && setGopRemainingB( uint32_t gopRemainingB_ ) && VULKAN_HPP_NOEXCEPT - { - gopRemainingB = gopRemainingB_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265GopRemainingFrameInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265GopRemainingFrameInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265GopRemainingFrameInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265GopRemainingFrameInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, useGopRemainingFrames, gopRemainingI, gopRemainingP, gopRemainingB ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265GopRemainingFrameInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useGopRemainingFrames == rhs.useGopRemainingFrames ) && - ( gopRemainingI == rhs.gopRemainingI ) && ( gopRemainingP == rhs.gopRemainingP ) && ( gopRemainingB == rhs.gopRemainingB ); -# endif - } - - bool operator!=( VideoEncodeH265GopRemainingFrameInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265GopRemainingFrameInfoKHR; - const void * pNext = {}; - Bool32 useGopRemainingFrames = {}; - uint32_t gopRemainingI = {}; - uint32_t gopRemainingP = {}; - uint32_t gopRemainingB = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265GopRemainingFrameInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265GopRemainingFrameInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265NaluSliceSegmentInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265NaluSliceSegmentInfoKHR.html - struct VideoEncodeH265NaluSliceSegmentInfoKHR - { - using NativeType = VkVideoEncodeH265NaluSliceSegmentInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoKHR( int32_t constantQp_ = {}, - const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , constantQp{ constantQp_ } - , pStdSliceSegmentHeader{ pStdSliceSegmentHeader_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265NaluSliceSegmentInfoKHR( VideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265NaluSliceSegmentInfoKHR( VkVideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265NaluSliceSegmentInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265NaluSliceSegmentInfoKHR & operator=( VideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265NaluSliceSegmentInfoKHR & operator=( VkVideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR & setConstantQp( int32_t constantQp_ ) & VULKAN_HPP_NOEXCEPT - { - constantQp = constantQp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR && setConstantQp( int32_t constantQp_ ) && VULKAN_HPP_NOEXCEPT - { - constantQp = constantQp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR & - setPStdSliceSegmentHeader( const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ ) & - VULKAN_HPP_NOEXCEPT - { - pStdSliceSegmentHeader = pStdSliceSegmentHeader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265NaluSliceSegmentInfoKHR && - setPStdSliceSegmentHeader( const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdSliceSegmentHeader = pStdSliceSegmentHeader_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265NaluSliceSegmentInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265NaluSliceSegmentInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265NaluSliceSegmentInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265NaluSliceSegmentInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, constantQp, pStdSliceSegmentHeader ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265NaluSliceSegmentInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( constantQp == rhs.constantQp ) && ( pStdSliceSegmentHeader == rhs.pStdSliceSegmentHeader ); -# endif - } - - bool operator!=( VideoEncodeH265NaluSliceSegmentInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265NaluSliceSegmentInfoKHR; - const void * pNext = {}; - int32_t constantQp = {}; - const StdVideoEncodeH265SliceSegmentHeader * pStdSliceSegmentHeader = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265NaluSliceSegmentInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265NaluSliceSegmentInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265PictureInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265PictureInfoKHR.html - struct VideoEncodeH265PictureInfoKHR - { - using NativeType = VkVideoEncodeH265PictureInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265PictureInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265PictureInfoKHR( uint32_t naluSliceSegmentEntryCount_ = {}, - const VideoEncodeH265NaluSliceSegmentInfoKHR * pNaluSliceSegmentEntries_ = {}, - const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , naluSliceSegmentEntryCount{ naluSliceSegmentEntryCount_ } - , pNaluSliceSegmentEntries{ pNaluSliceSegmentEntries_ } - , pStdPictureInfo{ pStdPictureInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265PictureInfoKHR( VideoEncodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265PictureInfoKHR( VkVideoEncodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265PictureInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265PictureInfoKHR( ArrayProxyNoTemporaries const & naluSliceSegmentEntries_, - const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , naluSliceSegmentEntryCount( static_cast( naluSliceSegmentEntries_.size() ) ) - , pNaluSliceSegmentEntries( naluSliceSegmentEntries_.data() ) - , pStdPictureInfo( pStdPictureInfo_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoEncodeH265PictureInfoKHR & operator=( VideoEncodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265PictureInfoKHR & operator=( VkVideoEncodeH265PictureInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR & setNaluSliceSegmentEntryCount( uint32_t naluSliceSegmentEntryCount_ ) & VULKAN_HPP_NOEXCEPT - { - naluSliceSegmentEntryCount = naluSliceSegmentEntryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR && setNaluSliceSegmentEntryCount( uint32_t naluSliceSegmentEntryCount_ ) && VULKAN_HPP_NOEXCEPT - { - naluSliceSegmentEntryCount = naluSliceSegmentEntryCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR & - setPNaluSliceSegmentEntries( const VideoEncodeH265NaluSliceSegmentInfoKHR * pNaluSliceSegmentEntries_ ) & - VULKAN_HPP_NOEXCEPT - { - pNaluSliceSegmentEntries = pNaluSliceSegmentEntries_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR && - setPNaluSliceSegmentEntries( const VideoEncodeH265NaluSliceSegmentInfoKHR * pNaluSliceSegmentEntries_ ) && - VULKAN_HPP_NOEXCEPT - { - pNaluSliceSegmentEntries = pNaluSliceSegmentEntries_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265PictureInfoKHR & - setNaluSliceSegmentEntries( ArrayProxyNoTemporaries const & naluSliceSegmentEntries_ ) VULKAN_HPP_NOEXCEPT - { - naluSliceSegmentEntryCount = static_cast( naluSliceSegmentEntries_.size() ); - pNaluSliceSegmentEntries = naluSliceSegmentEntries_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR & setPStdPictureInfo( const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265PictureInfoKHR && setPStdPictureInfo( const StdVideoEncodeH265PictureInfo * pStdPictureInfo_ ) && VULKAN_HPP_NOEXCEPT - { - pStdPictureInfo = pStdPictureInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265PictureInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265PictureInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265PictureInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265PictureInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, naluSliceSegmentEntryCount, pNaluSliceSegmentEntries, pStdPictureInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265PictureInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( naluSliceSegmentEntryCount == rhs.naluSliceSegmentEntryCount ) && - ( pNaluSliceSegmentEntries == rhs.pNaluSliceSegmentEntries ) && ( pStdPictureInfo == rhs.pStdPictureInfo ); -# endif - } - - bool operator!=( VideoEncodeH265PictureInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265PictureInfoKHR; - const void * pNext = {}; - uint32_t naluSliceSegmentEntryCount = {}; - const VideoEncodeH265NaluSliceSegmentInfoKHR * pNaluSliceSegmentEntries = {}; - const StdVideoEncodeH265PictureInfo * pStdPictureInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265PictureInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265PictureInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265ProfileInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265ProfileInfoKHR.html - struct VideoEncodeH265ProfileInfoKHR - { - using NativeType = VkVideoEncodeH265ProfileInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265ProfileInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoKHR( StdVideoH265ProfileIdc stdProfileIdc_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stdProfileIdc{ stdProfileIdc_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265ProfileInfoKHR( VideoEncodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265ProfileInfoKHR( VkVideoEncodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265ProfileInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265ProfileInfoKHR & operator=( VideoEncodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265ProfileInfoKHR & operator=( VkVideoEncodeH265ProfileInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoKHR & setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) & VULKAN_HPP_NOEXCEPT - { - stdProfileIdc = stdProfileIdc_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265ProfileInfoKHR && setStdProfileIdc( StdVideoH265ProfileIdc stdProfileIdc_ ) && VULKAN_HPP_NOEXCEPT - { - stdProfileIdc = stdProfileIdc_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265ProfileInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265ProfileInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265ProfileInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265ProfileInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stdProfileIdc ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoEncodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoEncodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memcmp( &stdProfileIdc, &rhs.stdProfileIdc, sizeof( StdVideoH265ProfileIdc ) ) == 0 ); - } - - bool operator!=( VideoEncodeH265ProfileInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoEncodeH265ProfileInfoKHR; - const void * pNext = {}; - StdVideoH265ProfileIdc stdProfileIdc = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265ProfileInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265ProfileInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265QpKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265QpKHR.html - struct VideoEncodeH265QpKHR - { - using NativeType = VkVideoEncodeH265QpKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265QpKHR( int32_t qpI_ = {}, int32_t qpP_ = {}, int32_t qpB_ = {} ) VULKAN_HPP_NOEXCEPT - : qpI{ qpI_ } - , qpP{ qpP_ } - , qpB{ qpB_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265QpKHR( VideoEncodeH265QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265QpKHR( VkVideoEncodeH265QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265QpKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265QpKHR & operator=( VideoEncodeH265QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265QpKHR & operator=( VkVideoEncodeH265QpKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR & setQpI( int32_t qpI_ ) & VULKAN_HPP_NOEXCEPT - { - qpI = qpI_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR && setQpI( int32_t qpI_ ) && VULKAN_HPP_NOEXCEPT - { - qpI = qpI_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR & setQpP( int32_t qpP_ ) & VULKAN_HPP_NOEXCEPT - { - qpP = qpP_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR && setQpP( int32_t qpP_ ) && VULKAN_HPP_NOEXCEPT - { - qpP = qpP_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR & setQpB( int32_t qpB_ ) & VULKAN_HPP_NOEXCEPT - { - qpB = qpB_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265QpKHR && setQpB( int32_t qpB_ ) && VULKAN_HPP_NOEXCEPT - { - qpB = qpB_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265QpKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265QpKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265QpKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265QpKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( qpI, qpP, qpB ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265QpKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265QpKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( qpI == rhs.qpI ) && ( qpP == rhs.qpP ) && ( qpB == rhs.qpB ); -# endif - } - - bool operator!=( VideoEncodeH265QpKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - int32_t qpI = {}; - int32_t qpP = {}; - int32_t qpB = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265QpKHR; - }; -#endif - - // wrapper struct for struct VkVideoEncodeH265QualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265QualityLevelPropertiesKHR.html - struct VideoEncodeH265QualityLevelPropertiesKHR - { - using NativeType = VkVideoEncodeH265QualityLevelPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265QualityLevelPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265QualityLevelPropertiesKHR( VideoEncodeH265RateControlFlagsKHR preferredRateControlFlags_ = {}, - uint32_t preferredGopFrameCount_ = {}, - uint32_t preferredIdrPeriod_ = {}, - uint32_t preferredConsecutiveBFrameCount_ = {}, - uint32_t preferredSubLayerCount_ = {}, - VideoEncodeH265QpKHR preferredConstantQp_ = {}, - uint32_t preferredMaxL0ReferenceCount_ = {}, - uint32_t preferredMaxL1ReferenceCount_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , preferredRateControlFlags{ preferredRateControlFlags_ } - , preferredGopFrameCount{ preferredGopFrameCount_ } - , preferredIdrPeriod{ preferredIdrPeriod_ } - , preferredConsecutiveBFrameCount{ preferredConsecutiveBFrameCount_ } - , preferredSubLayerCount{ preferredSubLayerCount_ } - , preferredConstantQp{ preferredConstantQp_ } - , preferredMaxL0ReferenceCount{ preferredMaxL0ReferenceCount_ } - , preferredMaxL1ReferenceCount{ preferredMaxL1ReferenceCount_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265QualityLevelPropertiesKHR( VideoEncodeH265QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265QualityLevelPropertiesKHR( VkVideoEncodeH265QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265QualityLevelPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265QualityLevelPropertiesKHR & operator=( VideoEncodeH265QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265QualityLevelPropertiesKHR & operator=( VkVideoEncodeH265QualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeH265QualityLevelPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265QualityLevelPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265QualityLevelPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265QualityLevelPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - preferredRateControlFlags, - preferredGopFrameCount, - preferredIdrPeriod, - preferredConsecutiveBFrameCount, - preferredSubLayerCount, - preferredConstantQp, - preferredMaxL0ReferenceCount, - preferredMaxL1ReferenceCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265QualityLevelPropertiesKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlFlags == rhs.preferredRateControlFlags ) && - ( preferredGopFrameCount == rhs.preferredGopFrameCount ) && ( preferredIdrPeriod == rhs.preferredIdrPeriod ) && - ( preferredConsecutiveBFrameCount == rhs.preferredConsecutiveBFrameCount ) && ( preferredSubLayerCount == rhs.preferredSubLayerCount ) && - ( preferredConstantQp == rhs.preferredConstantQp ) && ( preferredMaxL0ReferenceCount == rhs.preferredMaxL0ReferenceCount ) && - ( preferredMaxL1ReferenceCount == rhs.preferredMaxL1ReferenceCount ); -# endif - } - - bool operator!=( VideoEncodeH265QualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265QualityLevelPropertiesKHR; - void * pNext = {}; - VideoEncodeH265RateControlFlagsKHR preferredRateControlFlags = {}; - uint32_t preferredGopFrameCount = {}; - uint32_t preferredIdrPeriod = {}; - uint32_t preferredConsecutiveBFrameCount = {}; - uint32_t preferredSubLayerCount = {}; - VideoEncodeH265QpKHR preferredConstantQp = {}; - uint32_t preferredMaxL0ReferenceCount = {}; - uint32_t preferredMaxL1ReferenceCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265QualityLevelPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265QualityLevelPropertiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265QuantizationMapCapabilitiesKHR.html - struct VideoEncodeH265QuantizationMapCapabilitiesKHR - { - using NativeType = VkVideoEncodeH265QuantizationMapCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265QuantizationMapCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoEncodeH265QuantizationMapCapabilitiesKHR( int32_t minQpDelta_ = {}, int32_t maxQpDelta_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , minQpDelta{ minQpDelta_ } - , maxQpDelta{ maxQpDelta_ } - { - } - - VULKAN_HPP_CONSTEXPR - VideoEncodeH265QuantizationMapCapabilitiesKHR( VideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265QuantizationMapCapabilitiesKHR( VkVideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265QuantizationMapCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265QuantizationMapCapabilitiesKHR & operator=( VideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265QuantizationMapCapabilitiesKHR & operator=( VkVideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeH265QuantizationMapCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265QuantizationMapCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265QuantizationMapCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265QuantizationMapCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, minQpDelta, maxQpDelta ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265QuantizationMapCapabilitiesKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( minQpDelta == rhs.minQpDelta ) && ( maxQpDelta == rhs.maxQpDelta ); -# endif - } - - bool operator!=( VideoEncodeH265QuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265QuantizationMapCapabilitiesKHR; - void * pNext = {}; - int32_t minQpDelta = {}; - int32_t maxQpDelta = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265QuantizationMapCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265QuantizationMapCapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265RateControlInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlInfoKHR.html - struct VideoEncodeH265RateControlInfoKHR - { - using NativeType = VkVideoEncodeH265RateControlInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoKHR( VideoEncodeH265RateControlFlagsKHR flags_ = {}, - uint32_t gopFrameCount_ = {}, - uint32_t idrPeriod_ = {}, - uint32_t consecutiveBFrameCount_ = {}, - uint32_t subLayerCount_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , gopFrameCount{ gopFrameCount_ } - , idrPeriod{ idrPeriod_ } - , consecutiveBFrameCount{ consecutiveBFrameCount_ } - , subLayerCount{ subLayerCount_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlInfoKHR( VideoEncodeH265RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265RateControlInfoKHR( VkVideoEncodeH265RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265RateControlInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265RateControlInfoKHR & operator=( VideoEncodeH265RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265RateControlInfoKHR & operator=( VkVideoEncodeH265RateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setFlags( VideoEncodeH265RateControlFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setFlags( VideoEncodeH265RateControlFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setGopFrameCount( uint32_t gopFrameCount_ ) & VULKAN_HPP_NOEXCEPT - { - gopFrameCount = gopFrameCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setGopFrameCount( uint32_t gopFrameCount_ ) && VULKAN_HPP_NOEXCEPT - { - gopFrameCount = gopFrameCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setIdrPeriod( uint32_t idrPeriod_ ) & VULKAN_HPP_NOEXCEPT - { - idrPeriod = idrPeriod_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setIdrPeriod( uint32_t idrPeriod_ ) && VULKAN_HPP_NOEXCEPT - { - idrPeriod = idrPeriod_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) & VULKAN_HPP_NOEXCEPT - { - consecutiveBFrameCount = consecutiveBFrameCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setConsecutiveBFrameCount( uint32_t consecutiveBFrameCount_ ) && VULKAN_HPP_NOEXCEPT - { - consecutiveBFrameCount = consecutiveBFrameCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR & setSubLayerCount( uint32_t subLayerCount_ ) & VULKAN_HPP_NOEXCEPT - { - subLayerCount = subLayerCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlInfoKHR && setSubLayerCount( uint32_t subLayerCount_ ) && VULKAN_HPP_NOEXCEPT - { - subLayerCount = subLayerCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265RateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265RateControlInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265RateControlInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265RateControlInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, gopFrameCount, idrPeriod, consecutiveBFrameCount, subLayerCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265RateControlInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( gopFrameCount == rhs.gopFrameCount ) && - ( idrPeriod == rhs.idrPeriod ) && ( consecutiveBFrameCount == rhs.consecutiveBFrameCount ) && ( subLayerCount == rhs.subLayerCount ); -# endif - } - - bool operator!=( VideoEncodeH265RateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265RateControlInfoKHR; - const void * pNext = {}; - VideoEncodeH265RateControlFlagsKHR flags = {}; - uint32_t gopFrameCount = {}; - uint32_t idrPeriod = {}; - uint32_t consecutiveBFrameCount = {}; - uint32_t subLayerCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265RateControlInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265RateControlInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265RateControlLayerInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265RateControlLayerInfoKHR.html - struct VideoEncodeH265RateControlLayerInfoKHR - { - using NativeType = VkVideoEncodeH265RateControlLayerInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265RateControlLayerInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoKHR( Bool32 useMinQp_ = {}, - VideoEncodeH265QpKHR minQp_ = {}, - Bool32 useMaxQp_ = {}, - VideoEncodeH265QpKHR maxQp_ = {}, - Bool32 useMaxFrameSize_ = {}, - VideoEncodeH265FrameSizeKHR maxFrameSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , useMinQp{ useMinQp_ } - , minQp{ minQp_ } - , useMaxQp{ useMaxQp_ } - , maxQp{ maxQp_ } - , useMaxFrameSize{ useMaxFrameSize_ } - , maxFrameSize{ maxFrameSize_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265RateControlLayerInfoKHR( VideoEncodeH265RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265RateControlLayerInfoKHR( VkVideoEncodeH265RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265RateControlLayerInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265RateControlLayerInfoKHR & operator=( VideoEncodeH265RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265RateControlLayerInfoKHR & operator=( VkVideoEncodeH265RateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setUseMinQp( Bool32 useMinQp_ ) & VULKAN_HPP_NOEXCEPT - { - useMinQp = useMinQp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setUseMinQp( Bool32 useMinQp_ ) && VULKAN_HPP_NOEXCEPT - { - useMinQp = useMinQp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setMinQp( VideoEncodeH265QpKHR const & minQp_ ) & VULKAN_HPP_NOEXCEPT - { - minQp = minQp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setMinQp( VideoEncodeH265QpKHR const & minQp_ ) && VULKAN_HPP_NOEXCEPT - { - minQp = minQp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setUseMaxQp( Bool32 useMaxQp_ ) & VULKAN_HPP_NOEXCEPT - { - useMaxQp = useMaxQp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setUseMaxQp( Bool32 useMaxQp_ ) && VULKAN_HPP_NOEXCEPT - { - useMaxQp = useMaxQp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setMaxQp( VideoEncodeH265QpKHR const & maxQp_ ) & VULKAN_HPP_NOEXCEPT - { - maxQp = maxQp_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setMaxQp( VideoEncodeH265QpKHR const & maxQp_ ) && VULKAN_HPP_NOEXCEPT - { - maxQp = maxQp_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) & VULKAN_HPP_NOEXCEPT - { - useMaxFrameSize = useMaxFrameSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setUseMaxFrameSize( Bool32 useMaxFrameSize_ ) && VULKAN_HPP_NOEXCEPT - { - useMaxFrameSize = useMaxFrameSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR & setMaxFrameSize( VideoEncodeH265FrameSizeKHR const & maxFrameSize_ ) & VULKAN_HPP_NOEXCEPT - { - maxFrameSize = maxFrameSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265RateControlLayerInfoKHR && setMaxFrameSize( VideoEncodeH265FrameSizeKHR const & maxFrameSize_ ) && - VULKAN_HPP_NOEXCEPT - { - maxFrameSize = maxFrameSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265RateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265RateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265RateControlLayerInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265RateControlLayerInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, useMinQp, minQp, useMaxQp, maxQp, useMaxFrameSize, maxFrameSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265RateControlLayerInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMinQp == rhs.useMinQp ) && ( minQp == rhs.minQp ) && ( useMaxQp == rhs.useMaxQp ) && - ( maxQp == rhs.maxQp ) && ( useMaxFrameSize == rhs.useMaxFrameSize ) && ( maxFrameSize == rhs.maxFrameSize ); -# endif - } - - bool operator!=( VideoEncodeH265RateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265RateControlLayerInfoKHR; - const void * pNext = {}; - Bool32 useMinQp = {}; - VideoEncodeH265QpKHR minQp = {}; - Bool32 useMaxQp = {}; - VideoEncodeH265QpKHR maxQp = {}; - Bool32 useMaxFrameSize = {}; - VideoEncodeH265FrameSizeKHR maxFrameSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265RateControlLayerInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265RateControlLayerInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265SessionCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionCreateInfoKHR.html - struct VideoEncodeH265SessionCreateInfoKHR - { - using NativeType = VkVideoEncodeH265SessionCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionCreateInfoKHR( Bool32 useMaxLevelIdc_ = {}, - StdVideoH265LevelIdc maxLevelIdc_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , useMaxLevelIdc{ useMaxLevelIdc_ } - , maxLevelIdc{ maxLevelIdc_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionCreateInfoKHR( VideoEncodeH265SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265SessionCreateInfoKHR( VkVideoEncodeH265SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265SessionCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265SessionCreateInfoKHR & operator=( VideoEncodeH265SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265SessionCreateInfoKHR & operator=( VkVideoEncodeH265SessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR & setUseMaxLevelIdc( Bool32 useMaxLevelIdc_ ) & VULKAN_HPP_NOEXCEPT - { - useMaxLevelIdc = useMaxLevelIdc_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR && setUseMaxLevelIdc( Bool32 useMaxLevelIdc_ ) && VULKAN_HPP_NOEXCEPT - { - useMaxLevelIdc = useMaxLevelIdc_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR & setMaxLevelIdc( StdVideoH265LevelIdc maxLevelIdc_ ) & VULKAN_HPP_NOEXCEPT - { - maxLevelIdc = maxLevelIdc_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionCreateInfoKHR && setMaxLevelIdc( StdVideoH265LevelIdc maxLevelIdc_ ) && VULKAN_HPP_NOEXCEPT - { - maxLevelIdc = maxLevelIdc_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265SessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, useMaxLevelIdc, maxLevelIdc ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( VideoEncodeH265SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = useMaxLevelIdc <=> rhs.useMaxLevelIdc; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -#endif - - bool operator==( VideoEncodeH265SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( useMaxLevelIdc == rhs.useMaxLevelIdc ) && - ( memcmp( &maxLevelIdc, &rhs.maxLevelIdc, sizeof( StdVideoH265LevelIdc ) ) == 0 ); - } - - bool operator!=( VideoEncodeH265SessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eVideoEncodeH265SessionCreateInfoKHR; - const void * pNext = {}; - Bool32 useMaxLevelIdc = {}; - StdVideoH265LevelIdc maxLevelIdc = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265SessionCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265SessionCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265SessionParametersAddInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersAddInfoKHR.html - struct VideoEncodeH265SessionParametersAddInfoKHR - { - using NativeType = VkVideoEncodeH265SessionParametersAddInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersAddInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoKHR( uint32_t stdVPSCount_ = {}, - const StdVideoH265VideoParameterSet * pStdVPSs_ = {}, - uint32_t stdSPSCount_ = {}, - const StdVideoH265SequenceParameterSet * pStdSPSs_ = {}, - uint32_t stdPPSCount_ = {}, - const StdVideoH265PictureParameterSet * pStdPPSs_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , stdVPSCount{ stdVPSCount_ } - , pStdVPSs{ pStdVPSs_ } - , stdSPSCount{ stdSPSCount_ } - , pStdSPSs{ pStdSPSs_ } - , stdPPSCount{ stdPPSCount_ } - , pStdPPSs{ pStdPPSs_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersAddInfoKHR( VideoEncodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265SessionParametersAddInfoKHR( VkVideoEncodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265SessionParametersAddInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265SessionParametersAddInfoKHR( ArrayProxyNoTemporaries const & stdVPSs_, - ArrayProxyNoTemporaries const & stdSPSs_ = {}, - ArrayProxyNoTemporaries const & stdPPSs_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , stdVPSCount( static_cast( stdVPSs_.size() ) ) - , pStdVPSs( stdVPSs_.data() ) - , stdSPSCount( static_cast( stdSPSs_.size() ) ) - , pStdSPSs( stdSPSs_.data() ) - , stdPPSCount( static_cast( stdPPSs_.size() ) ) - , pStdPPSs( stdPPSs_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoEncodeH265SessionParametersAddInfoKHR & operator=( VideoEncodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265SessionParametersAddInfoKHR & operator=( VkVideoEncodeH265SessionParametersAddInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setStdVPSCount( uint32_t stdVPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - stdVPSCount = stdVPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setStdVPSCount( uint32_t stdVPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - stdVPSCount = stdVPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) & VULKAN_HPP_NOEXCEPT - { - pStdVPSs = pStdVPSs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setPStdVPSs( const StdVideoH265VideoParameterSet * pStdVPSs_ ) && VULKAN_HPP_NOEXCEPT - { - pStdVPSs = pStdVPSs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265SessionParametersAddInfoKHR & setStdVPSs( ArrayProxyNoTemporaries const & stdVPSs_ ) VULKAN_HPP_NOEXCEPT - { - stdVPSCount = static_cast( stdVPSs_.size() ); - pStdVPSs = stdVPSs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setStdSPSCount( uint32_t stdSPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - stdSPSCount = stdSPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setStdSPSCount( uint32_t stdSPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - stdSPSCount = stdSPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) & VULKAN_HPP_NOEXCEPT - { - pStdSPSs = pStdSPSs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setPStdSPSs( const StdVideoH265SequenceParameterSet * pStdSPSs_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdSPSs = pStdSPSs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265SessionParametersAddInfoKHR & - setStdSPSs( ArrayProxyNoTemporaries const & stdSPSs_ ) VULKAN_HPP_NOEXCEPT - { - stdSPSCount = static_cast( stdSPSs_.size() ); - pStdSPSs = stdSPSs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setStdPPSCount( uint32_t stdPPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - stdPPSCount = stdPPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setStdPPSCount( uint32_t stdPPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - stdPPSCount = stdPPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR & setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) & VULKAN_HPP_NOEXCEPT - { - pStdPPSs = pStdPPSs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersAddInfoKHR && setPStdPPSs( const StdVideoH265PictureParameterSet * pStdPPSs_ ) && - VULKAN_HPP_NOEXCEPT - { - pStdPPSs = pStdPPSs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeH265SessionParametersAddInfoKHR & - setStdPPSs( ArrayProxyNoTemporaries const & stdPPSs_ ) VULKAN_HPP_NOEXCEPT - { - stdPPSCount = static_cast( stdPPSs_.size() ); - pStdPPSs = stdPPSs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265SessionParametersAddInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersAddInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersAddInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersAddInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, stdVPSCount, pStdVPSs, stdSPSCount, pStdSPSs, stdPPSCount, pStdPPSs ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265SessionParametersAddInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( stdVPSCount == rhs.stdVPSCount ) && ( pStdVPSs == rhs.pStdVPSs ) && - ( stdSPSCount == rhs.stdSPSCount ) && ( pStdSPSs == rhs.pStdSPSs ) && ( stdPPSCount == rhs.stdPPSCount ) && ( pStdPPSs == rhs.pStdPPSs ); -# endif - } - - bool operator!=( VideoEncodeH265SessionParametersAddInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265SessionParametersAddInfoKHR; - const void * pNext = {}; - uint32_t stdVPSCount = {}; - const StdVideoH265VideoParameterSet * pStdVPSs = {}; - uint32_t stdSPSCount = {}; - const StdVideoH265SequenceParameterSet * pStdSPSs = {}; - uint32_t stdPPSCount = {}; - const StdVideoH265PictureParameterSet * pStdPPSs = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265SessionParametersAddInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265SessionParametersAddInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265SessionParametersCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersCreateInfoKHR.html - struct VideoEncodeH265SessionParametersCreateInfoKHR - { - using NativeType = VkVideoEncodeH265SessionParametersCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersCreateInfoKHR( uint32_t maxStdVPSCount_ = {}, - uint32_t maxStdSPSCount_ = {}, - uint32_t maxStdPPSCount_ = {}, - const VideoEncodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxStdVPSCount{ maxStdVPSCount_ } - , maxStdSPSCount{ maxStdSPSCount_ } - , maxStdPPSCount{ maxStdPPSCount_ } - , pParametersAddInfo{ pParametersAddInfo_ } - { - } - - VULKAN_HPP_CONSTEXPR - VideoEncodeH265SessionParametersCreateInfoKHR( VideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265SessionParametersCreateInfoKHR( VkVideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265SessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265SessionParametersCreateInfoKHR & operator=( VideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265SessionParametersCreateInfoKHR & operator=( VkVideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR & setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxStdVPSCount = maxStdVPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR && setMaxStdVPSCount( uint32_t maxStdVPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxStdVPSCount = maxStdVPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR & setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxStdSPSCount = maxStdSPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR && setMaxStdSPSCount( uint32_t maxStdSPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxStdSPSCount = maxStdSPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR & setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) & VULKAN_HPP_NOEXCEPT - { - maxStdPPSCount = maxStdPPSCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR && setMaxStdPPSCount( uint32_t maxStdPPSCount_ ) && VULKAN_HPP_NOEXCEPT - { - maxStdPPSCount = maxStdPPSCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR & - setPParametersAddInfo( const VideoEncodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ ) & - VULKAN_HPP_NOEXCEPT - { - pParametersAddInfo = pParametersAddInfo_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersCreateInfoKHR && - setPParametersAddInfo( const VideoEncodeH265SessionParametersAddInfoKHR * pParametersAddInfo_ ) && - VULKAN_HPP_NOEXCEPT - { - pParametersAddInfo = pParametersAddInfo_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265SessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxStdVPSCount, maxStdSPSCount, maxStdPPSCount, pParametersAddInfo ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265SessionParametersCreateInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxStdVPSCount == rhs.maxStdVPSCount ) && ( maxStdSPSCount == rhs.maxStdSPSCount ) && - ( maxStdPPSCount == rhs.maxStdPPSCount ) && ( pParametersAddInfo == rhs.pParametersAddInfo ); -# endif - } - - bool operator!=( VideoEncodeH265SessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265SessionParametersCreateInfoKHR; - const void * pNext = {}; - uint32_t maxStdVPSCount = {}; - uint32_t maxStdSPSCount = {}; - uint32_t maxStdPPSCount = {}; - const VideoEncodeH265SessionParametersAddInfoKHR * pParametersAddInfo = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265SessionParametersCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265SessionParametersCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersFeedbackInfoKHR.html - struct VideoEncodeH265SessionParametersFeedbackInfoKHR - { - using NativeType = VkVideoEncodeH265SessionParametersFeedbackInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersFeedbackInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersFeedbackInfoKHR( Bool32 hasStdVPSOverrides_ = {}, - Bool32 hasStdSPSOverrides_ = {}, - Bool32 hasStdPPSOverrides_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , hasStdVPSOverrides{ hasStdVPSOverrides_ } - , hasStdSPSOverrides{ hasStdSPSOverrides_ } - , hasStdPPSOverrides{ hasStdPPSOverrides_ } - { - } - - VULKAN_HPP_CONSTEXPR - VideoEncodeH265SessionParametersFeedbackInfoKHR( VideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265SessionParametersFeedbackInfoKHR( VkVideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265SessionParametersFeedbackInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265SessionParametersFeedbackInfoKHR & operator=( VideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265SessionParametersFeedbackInfoKHR & operator=( VkVideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeH265SessionParametersFeedbackInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersFeedbackInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersFeedbackInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersFeedbackInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, hasStdVPSOverrides, hasStdSPSOverrides, hasStdPPSOverrides ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265SessionParametersFeedbackInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasStdVPSOverrides == rhs.hasStdVPSOverrides ) && - ( hasStdSPSOverrides == rhs.hasStdSPSOverrides ) && ( hasStdPPSOverrides == rhs.hasStdPPSOverrides ); -# endif - } - - bool operator!=( VideoEncodeH265SessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265SessionParametersFeedbackInfoKHR; - void * pNext = {}; - Bool32 hasStdVPSOverrides = {}; - Bool32 hasStdSPSOverrides = {}; - Bool32 hasStdPPSOverrides = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265SessionParametersFeedbackInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265SessionParametersFeedbackInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeH265SessionParametersGetInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeH265SessionParametersGetInfoKHR.html - struct VideoEncodeH265SessionParametersGetInfoKHR - { - using NativeType = VkVideoEncodeH265SessionParametersGetInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeH265SessionParametersGetInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersGetInfoKHR( Bool32 writeStdVPS_ = {}, - Bool32 writeStdSPS_ = {}, - Bool32 writeStdPPS_ = {}, - uint32_t stdVPSId_ = {}, - uint32_t stdSPSId_ = {}, - uint32_t stdPPSId_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , writeStdVPS{ writeStdVPS_ } - , writeStdSPS{ writeStdSPS_ } - , writeStdPPS{ writeStdPPS_ } - , stdVPSId{ stdVPSId_ } - , stdSPSId{ stdSPSId_ } - , stdPPSId{ stdPPSId_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeH265SessionParametersGetInfoKHR( VideoEncodeH265SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeH265SessionParametersGetInfoKHR( VkVideoEncodeH265SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeH265SessionParametersGetInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeH265SessionParametersGetInfoKHR & operator=( VideoEncodeH265SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeH265SessionParametersGetInfoKHR & operator=( VkVideoEncodeH265SessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setWriteStdVPS( Bool32 writeStdVPS_ ) & VULKAN_HPP_NOEXCEPT - { - writeStdVPS = writeStdVPS_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setWriteStdVPS( Bool32 writeStdVPS_ ) && VULKAN_HPP_NOEXCEPT - { - writeStdVPS = writeStdVPS_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setWriteStdSPS( Bool32 writeStdSPS_ ) & VULKAN_HPP_NOEXCEPT - { - writeStdSPS = writeStdSPS_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setWriteStdSPS( Bool32 writeStdSPS_ ) && VULKAN_HPP_NOEXCEPT - { - writeStdSPS = writeStdSPS_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setWriteStdPPS( Bool32 writeStdPPS_ ) & VULKAN_HPP_NOEXCEPT - { - writeStdPPS = writeStdPPS_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setWriteStdPPS( Bool32 writeStdPPS_ ) && VULKAN_HPP_NOEXCEPT - { - writeStdPPS = writeStdPPS_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setStdVPSId( uint32_t stdVPSId_ ) & VULKAN_HPP_NOEXCEPT - { - stdVPSId = stdVPSId_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setStdVPSId( uint32_t stdVPSId_ ) && VULKAN_HPP_NOEXCEPT - { - stdVPSId = stdVPSId_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setStdSPSId( uint32_t stdSPSId_ ) & VULKAN_HPP_NOEXCEPT - { - stdSPSId = stdSPSId_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setStdSPSId( uint32_t stdSPSId_ ) && VULKAN_HPP_NOEXCEPT - { - stdSPSId = stdSPSId_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR & setStdPPSId( uint32_t stdPPSId_ ) & VULKAN_HPP_NOEXCEPT - { - stdPPSId = stdPPSId_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeH265SessionParametersGetInfoKHR && setStdPPSId( uint32_t stdPPSId_ ) && VULKAN_HPP_NOEXCEPT - { - stdPPSId = stdPPSId_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeH265SessionParametersGetInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersGetInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersGetInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeH265SessionParametersGetInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, writeStdVPS, writeStdSPS, writeStdPPS, stdVPSId, stdSPSId, stdPPSId ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeH265SessionParametersGetInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeH265SessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( writeStdVPS == rhs.writeStdVPS ) && ( writeStdSPS == rhs.writeStdSPS ) && - ( writeStdPPS == rhs.writeStdPPS ) && ( stdVPSId == rhs.stdVPSId ) && ( stdSPSId == rhs.stdSPSId ) && ( stdPPSId == rhs.stdPPSId ); -# endif - } - - bool operator!=( VideoEncodeH265SessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeH265SessionParametersGetInfoKHR; - const void * pNext = {}; - Bool32 writeStdVPS = {}; - Bool32 writeStdSPS = {}; - Bool32 writeStdPPS = {}; - uint32_t stdVPSId = {}; - uint32_t stdSPSId = {}; - uint32_t stdPPSId = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeH265SessionParametersGetInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeH265SessionParametersGetInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeInfoKHR.html - struct VideoEncodeInfoKHR - { - using NativeType = VkVideoEncodeInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VideoEncodeFlagsKHR flags_ = {}, - Buffer dstBuffer_ = {}, - DeviceSize dstBufferOffset_ = {}, - DeviceSize dstBufferRange_ = {}, - VideoPictureResourceInfoKHR srcPictureResource_ = {}, - const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ = {}, - uint32_t referenceSlotCount_ = {}, - const VideoReferenceSlotInfoKHR * pReferenceSlots_ = {}, - uint32_t precedingExternallyEncodedBytes_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , dstBuffer{ dstBuffer_ } - , dstBufferOffset{ dstBufferOffset_ } - , dstBufferRange{ dstBufferRange_ } - , srcPictureResource{ srcPictureResource_ } - , pSetupReferenceSlot{ pSetupReferenceSlot_ } - , referenceSlotCount{ referenceSlotCount_ } - , pReferenceSlots{ pReferenceSlots_ } - , precedingExternallyEncodedBytes{ precedingExternallyEncodedBytes_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeInfoKHR( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeInfoKHR( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT : VideoEncodeInfoKHR( *reinterpret_cast( &rhs ) ) {} - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeInfoKHR( VideoEncodeFlagsKHR flags_, - Buffer dstBuffer_, - DeviceSize dstBufferOffset_, - DeviceSize dstBufferRange_, - VideoPictureResourceInfoKHR srcPictureResource_, - const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_, - ArrayProxyNoTemporaries const & referenceSlots_, - uint32_t precedingExternallyEncodedBytes_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , dstBuffer( dstBuffer_ ) - , dstBufferOffset( dstBufferOffset_ ) - , dstBufferRange( dstBufferRange_ ) - , srcPictureResource( srcPictureResource_ ) - , pSetupReferenceSlot( pSetupReferenceSlot_ ) - , referenceSlotCount( static_cast( referenceSlots_.size() ) ) - , pReferenceSlots( referenceSlots_.data() ) - , precedingExternallyEncodedBytes( precedingExternallyEncodedBytes_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoEncodeInfoKHR & operator=( VideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeInfoKHR & operator=( VkVideoEncodeInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setFlags( VideoEncodeFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setFlags( VideoEncodeFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBuffer( Buffer dstBuffer_ ) & VULKAN_HPP_NOEXCEPT - { - dstBuffer = dstBuffer_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setDstBuffer( Buffer dstBuffer_ ) && VULKAN_HPP_NOEXCEPT - { - dstBuffer = dstBuffer_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferOffset( DeviceSize dstBufferOffset_ ) & VULKAN_HPP_NOEXCEPT - { - dstBufferOffset = dstBufferOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setDstBufferOffset( DeviceSize dstBufferOffset_ ) && VULKAN_HPP_NOEXCEPT - { - dstBufferOffset = dstBufferOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setDstBufferRange( DeviceSize dstBufferRange_ ) & VULKAN_HPP_NOEXCEPT - { - dstBufferRange = dstBufferRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setDstBufferRange( DeviceSize dstBufferRange_ ) && VULKAN_HPP_NOEXCEPT - { - dstBufferRange = dstBufferRange_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setSrcPictureResource( VideoPictureResourceInfoKHR const & srcPictureResource_ ) & VULKAN_HPP_NOEXCEPT - { - srcPictureResource = srcPictureResource_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setSrcPictureResource( VideoPictureResourceInfoKHR const & srcPictureResource_ ) && VULKAN_HPP_NOEXCEPT - { - srcPictureResource = srcPictureResource_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPSetupReferenceSlot( const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) & VULKAN_HPP_NOEXCEPT - { - pSetupReferenceSlot = pSetupReferenceSlot_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setPSetupReferenceSlot( const VideoReferenceSlotInfoKHR * pSetupReferenceSlot_ ) && VULKAN_HPP_NOEXCEPT - { - pSetupReferenceSlot = pSetupReferenceSlot_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setReferenceSlotCount( uint32_t referenceSlotCount_ ) & VULKAN_HPP_NOEXCEPT - { - referenceSlotCount = referenceSlotCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setReferenceSlotCount( uint32_t referenceSlotCount_ ) && VULKAN_HPP_NOEXCEPT - { - referenceSlotCount = referenceSlotCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) & VULKAN_HPP_NOEXCEPT - { - pReferenceSlots = pReferenceSlots_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setPReferenceSlots( const VideoReferenceSlotInfoKHR * pReferenceSlots_ ) && VULKAN_HPP_NOEXCEPT - { - pReferenceSlots = pReferenceSlots_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeInfoKHR & setReferenceSlots( ArrayProxyNoTemporaries const & referenceSlots_ ) VULKAN_HPP_NOEXCEPT - { - referenceSlotCount = static_cast( referenceSlots_.size() ); - pReferenceSlots = referenceSlots_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR & setPrecedingExternallyEncodedBytes( uint32_t precedingExternallyEncodedBytes_ ) & VULKAN_HPP_NOEXCEPT - { - precedingExternallyEncodedBytes = precedingExternallyEncodedBytes_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeInfoKHR && setPrecedingExternallyEncodedBytes( uint32_t precedingExternallyEncodedBytes_ ) && VULKAN_HPP_NOEXCEPT - { - precedingExternallyEncodedBytes = precedingExternallyEncodedBytes_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - flags, - dstBuffer, - dstBufferOffset, - dstBufferRange, - srcPictureResource, - pSetupReferenceSlot, - referenceSlotCount, - pReferenceSlots, - precedingExternallyEncodedBytes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dstBuffer == rhs.dstBuffer ) && - ( dstBufferOffset == rhs.dstBufferOffset ) && ( dstBufferRange == rhs.dstBufferRange ) && ( srcPictureResource == rhs.srcPictureResource ) && - ( pSetupReferenceSlot == rhs.pSetupReferenceSlot ) && ( referenceSlotCount == rhs.referenceSlotCount ) && - ( pReferenceSlots == rhs.pReferenceSlots ) && ( precedingExternallyEncodedBytes == rhs.precedingExternallyEncodedBytes ); -# endif - } - - bool operator!=( VideoEncodeInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeInfoKHR; - const void * pNext = {}; - VideoEncodeFlagsKHR flags = {}; - Buffer dstBuffer = {}; - DeviceSize dstBufferOffset = {}; - DeviceSize dstBufferRange = {}; - VideoPictureResourceInfoKHR srcPictureResource = {}; - const VideoReferenceSlotInfoKHR * pSetupReferenceSlot = {}; - uint32_t referenceSlotCount = {}; - const VideoReferenceSlotInfoKHR * pReferenceSlots = {}; - uint32_t precedingExternallyEncodedBytes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeIntraRefreshCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeIntraRefreshCapabilitiesKHR.html - struct VideoEncodeIntraRefreshCapabilitiesKHR - { - using NativeType = VkVideoEncodeIntraRefreshCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeIntraRefreshCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeIntraRefreshCapabilitiesKHR( VideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes_ = {}, - uint32_t maxIntraRefreshCycleDuration_ = {}, - uint32_t maxIntraRefreshActiveReferencePictures_ = {}, - Bool32 partitionIndependentIntraRefreshRegions_ = {}, - Bool32 nonRectangularIntraRefreshRegions_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , intraRefreshModes{ intraRefreshModes_ } - , maxIntraRefreshCycleDuration{ maxIntraRefreshCycleDuration_ } - , maxIntraRefreshActiveReferencePictures{ maxIntraRefreshActiveReferencePictures_ } - , partitionIndependentIntraRefreshRegions{ partitionIndependentIntraRefreshRegions_ } - , nonRectangularIntraRefreshRegions{ nonRectangularIntraRefreshRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeIntraRefreshCapabilitiesKHR( VideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeIntraRefreshCapabilitiesKHR( VkVideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeIntraRefreshCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeIntraRefreshCapabilitiesKHR & operator=( VideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeIntraRefreshCapabilitiesKHR & operator=( VkVideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeIntraRefreshCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeIntraRefreshCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeIntraRefreshCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeIntraRefreshCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - intraRefreshModes, - maxIntraRefreshCycleDuration, - maxIntraRefreshActiveReferencePictures, - partitionIndependentIntraRefreshRegions, - nonRectangularIntraRefreshRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeIntraRefreshCapabilitiesKHR const & ) const = default; -#else - bool operator==( VideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( intraRefreshModes == rhs.intraRefreshModes ) && - ( maxIntraRefreshCycleDuration == rhs.maxIntraRefreshCycleDuration ) && - ( maxIntraRefreshActiveReferencePictures == rhs.maxIntraRefreshActiveReferencePictures ) && - ( partitionIndependentIntraRefreshRegions == rhs.partitionIndependentIntraRefreshRegions ) && - ( nonRectangularIntraRefreshRegions == rhs.nonRectangularIntraRefreshRegions ); -# endif - } - - bool operator!=( VideoEncodeIntraRefreshCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeIntraRefreshCapabilitiesKHR; - void * pNext = {}; - VideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes = {}; - uint32_t maxIntraRefreshCycleDuration = {}; - uint32_t maxIntraRefreshActiveReferencePictures = {}; - Bool32 partitionIndependentIntraRefreshRegions = {}; - Bool32 nonRectangularIntraRefreshRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeIntraRefreshCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeIntraRefreshCapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeIntraRefreshInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeIntraRefreshInfoKHR.html - struct VideoEncodeIntraRefreshInfoKHR - { - using NativeType = VkVideoEncodeIntraRefreshInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeIntraRefreshInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeIntraRefreshInfoKHR( uint32_t intraRefreshCycleDuration_ = {}, - uint32_t intraRefreshIndex_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , intraRefreshCycleDuration{ intraRefreshCycleDuration_ } - , intraRefreshIndex{ intraRefreshIndex_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeIntraRefreshInfoKHR( VideoEncodeIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeIntraRefreshInfoKHR( VkVideoEncodeIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeIntraRefreshInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeIntraRefreshInfoKHR & operator=( VideoEncodeIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeIntraRefreshInfoKHR & operator=( VkVideoEncodeIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR & setIntraRefreshCycleDuration( uint32_t intraRefreshCycleDuration_ ) & VULKAN_HPP_NOEXCEPT - { - intraRefreshCycleDuration = intraRefreshCycleDuration_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR && setIntraRefreshCycleDuration( uint32_t intraRefreshCycleDuration_ ) && VULKAN_HPP_NOEXCEPT - { - intraRefreshCycleDuration = intraRefreshCycleDuration_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR & setIntraRefreshIndex( uint32_t intraRefreshIndex_ ) & VULKAN_HPP_NOEXCEPT - { - intraRefreshIndex = intraRefreshIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeIntraRefreshInfoKHR && setIntraRefreshIndex( uint32_t intraRefreshIndex_ ) && VULKAN_HPP_NOEXCEPT - { - intraRefreshIndex = intraRefreshIndex_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeIntraRefreshInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeIntraRefreshInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeIntraRefreshInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeIntraRefreshInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, intraRefreshCycleDuration, intraRefreshIndex ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeIntraRefreshInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeIntraRefreshInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( intraRefreshCycleDuration == rhs.intraRefreshCycleDuration ) && - ( intraRefreshIndex == rhs.intraRefreshIndex ); -# endif - } - - bool operator!=( VideoEncodeIntraRefreshInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeIntraRefreshInfoKHR; - const void * pNext = {}; - uint32_t intraRefreshCycleDuration = {}; - uint32_t intraRefreshIndex = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeIntraRefreshInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeIntraRefreshInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeProfileRgbConversionInfoVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeProfileRgbConversionInfoVALVE.html - struct VideoEncodeProfileRgbConversionInfoVALVE - { - using NativeType = VkVideoEncodeProfileRgbConversionInfoVALVE; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeProfileRgbConversionInfoVALVE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeProfileRgbConversionInfoVALVE( Bool32 performEncodeRgbConversion_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , performEncodeRgbConversion{ performEncodeRgbConversion_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeProfileRgbConversionInfoVALVE( VideoEncodeProfileRgbConversionInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeProfileRgbConversionInfoVALVE( VkVideoEncodeProfileRgbConversionInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeProfileRgbConversionInfoVALVE( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeProfileRgbConversionInfoVALVE & operator=( VideoEncodeProfileRgbConversionInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeProfileRgbConversionInfoVALVE & operator=( VkVideoEncodeProfileRgbConversionInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeProfileRgbConversionInfoVALVE & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeProfileRgbConversionInfoVALVE && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeProfileRgbConversionInfoVALVE & setPerformEncodeRgbConversion( Bool32 performEncodeRgbConversion_ ) & VULKAN_HPP_NOEXCEPT - { - performEncodeRgbConversion = performEncodeRgbConversion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeProfileRgbConversionInfoVALVE && setPerformEncodeRgbConversion( Bool32 performEncodeRgbConversion_ ) && - VULKAN_HPP_NOEXCEPT - { - performEncodeRgbConversion = performEncodeRgbConversion_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeProfileRgbConversionInfoVALVE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeProfileRgbConversionInfoVALVE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeProfileRgbConversionInfoVALVE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeProfileRgbConversionInfoVALVE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, performEncodeRgbConversion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeProfileRgbConversionInfoVALVE const & ) const = default; -#else - bool operator==( VideoEncodeProfileRgbConversionInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( performEncodeRgbConversion == rhs.performEncodeRgbConversion ); -# endif - } - - bool operator!=( VideoEncodeProfileRgbConversionInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeProfileRgbConversionInfoVALVE; - const void * pNext = {}; - Bool32 performEncodeRgbConversion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeProfileRgbConversionInfoVALVE; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeProfileRgbConversionInfoVALVE; - }; - - // wrapper struct for struct VkVideoEncodeQualityLevelInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeQualityLevelInfoKHR.html - struct VideoEncodeQualityLevelInfoKHR - { - using NativeType = VkVideoEncodeQualityLevelInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQualityLevelInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelInfoKHR( uint32_t qualityLevel_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , qualityLevel{ qualityLevel_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelInfoKHR( VideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeQualityLevelInfoKHR( VkVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeQualityLevelInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeQualityLevelInfoKHR & operator=( VideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeQualityLevelInfoKHR & operator=( VkVideoEncodeQualityLevelInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR & setQualityLevel( uint32_t qualityLevel_ ) & VULKAN_HPP_NOEXCEPT - { - qualityLevel = qualityLevel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQualityLevelInfoKHR && setQualityLevel( uint32_t qualityLevel_ ) && VULKAN_HPP_NOEXCEPT - { - qualityLevel = qualityLevel_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeQualityLevelInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeQualityLevelInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeQualityLevelInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeQualityLevelInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, qualityLevel ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeQualityLevelInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( qualityLevel == rhs.qualityLevel ); -# endif - } - - bool operator!=( VideoEncodeQualityLevelInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeQualityLevelInfoKHR; - const void * pNext = {}; - uint32_t qualityLevel = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeQualityLevelInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeQualityLevelInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeQualityLevelPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeQualityLevelPropertiesKHR.html - struct VideoEncodeQualityLevelPropertiesKHR - { - using NativeType = VkVideoEncodeQualityLevelPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQualityLevelPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoEncodeQualityLevelPropertiesKHR( VideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode_ = VideoEncodeRateControlModeFlagBitsKHR::eDefault, - uint32_t preferredRateControlLayerCount_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , preferredRateControlMode{ preferredRateControlMode_ } - , preferredRateControlLayerCount{ preferredRateControlLayerCount_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeQualityLevelPropertiesKHR( VideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeQualityLevelPropertiesKHR( VkVideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeQualityLevelPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeQualityLevelPropertiesKHR & operator=( VideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeQualityLevelPropertiesKHR & operator=( VkVideoEncodeQualityLevelPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeQualityLevelPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeQualityLevelPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeQualityLevelPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeQualityLevelPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, preferredRateControlMode, preferredRateControlLayerCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeQualityLevelPropertiesKHR const & ) const = default; -#else - bool operator==( VideoEncodeQualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredRateControlMode == rhs.preferredRateControlMode ) && - ( preferredRateControlLayerCount == rhs.preferredRateControlLayerCount ); -# endif - } - - bool operator!=( VideoEncodeQualityLevelPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeQualityLevelPropertiesKHR; - void * pNext = {}; - VideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode = VideoEncodeRateControlModeFlagBitsKHR::eDefault; - uint32_t preferredRateControlLayerCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeQualityLevelPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeQualityLevelPropertiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeQuantizationMapCapabilitiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeQuantizationMapCapabilitiesKHR.html - struct VideoEncodeQuantizationMapCapabilitiesKHR - { - using NativeType = VkVideoEncodeQuantizationMapCapabilitiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQuantizationMapCapabilitiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapCapabilitiesKHR( Extent2D maxQuantizationMapExtent_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , maxQuantizationMapExtent{ maxQuantizationMapExtent_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapCapabilitiesKHR( VideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeQuantizationMapCapabilitiesKHR( VkVideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeQuantizationMapCapabilitiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeQuantizationMapCapabilitiesKHR & operator=( VideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeQuantizationMapCapabilitiesKHR & operator=( VkVideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeQuantizationMapCapabilitiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeQuantizationMapCapabilitiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeQuantizationMapCapabilitiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeQuantizationMapCapabilitiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, maxQuantizationMapExtent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeQuantizationMapCapabilitiesKHR const & ) const = default; -#else - bool operator==( VideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxQuantizationMapExtent == rhs.maxQuantizationMapExtent ); -# endif - } - - bool operator!=( VideoEncodeQuantizationMapCapabilitiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeQuantizationMapCapabilitiesKHR; - void * pNext = {}; - Extent2D maxQuantizationMapExtent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeQuantizationMapCapabilitiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeQuantizationMapCapabilitiesKHR; - }; - - // wrapper struct for struct VkVideoEncodeQuantizationMapInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeQuantizationMapInfoKHR.html - struct VideoEncodeQuantizationMapInfoKHR - { - using NativeType = VkVideoEncodeQuantizationMapInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQuantizationMapInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapInfoKHR( ImageView quantizationMap_ = {}, - Extent2D quantizationMapExtent_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , quantizationMap{ quantizationMap_ } - , quantizationMapExtent{ quantizationMapExtent_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapInfoKHR( VideoEncodeQuantizationMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeQuantizationMapInfoKHR( VkVideoEncodeQuantizationMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeQuantizationMapInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeQuantizationMapInfoKHR & operator=( VideoEncodeQuantizationMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeQuantizationMapInfoKHR & operator=( VkVideoEncodeQuantizationMapInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR & setQuantizationMap( ImageView quantizationMap_ ) & VULKAN_HPP_NOEXCEPT - { - quantizationMap = quantizationMap_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR && setQuantizationMap( ImageView quantizationMap_ ) && VULKAN_HPP_NOEXCEPT - { - quantizationMap = quantizationMap_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR & setQuantizationMapExtent( Extent2D const & quantizationMapExtent_ ) & VULKAN_HPP_NOEXCEPT - { - quantizationMapExtent = quantizationMapExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapInfoKHR && setQuantizationMapExtent( Extent2D const & quantizationMapExtent_ ) && VULKAN_HPP_NOEXCEPT - { - quantizationMapExtent = quantizationMapExtent_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeQuantizationMapInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeQuantizationMapInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeQuantizationMapInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeQuantizationMapInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, quantizationMap, quantizationMapExtent ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeQuantizationMapInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeQuantizationMapInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( quantizationMap == rhs.quantizationMap ) && - ( quantizationMapExtent == rhs.quantizationMapExtent ); -# endif - } - - bool operator!=( VideoEncodeQuantizationMapInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeQuantizationMapInfoKHR; - const void * pNext = {}; - ImageView quantizationMap = {}; - Extent2D quantizationMapExtent = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeQuantizationMapInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeQuantizationMapInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR.html - struct VideoEncodeQuantizationMapSessionParametersCreateInfoKHR - { - using NativeType = VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeQuantizationMapSessionParametersCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapSessionParametersCreateInfoKHR( Extent2D quantizationMapTexelSize_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , quantizationMapTexelSize{ quantizationMapTexelSize_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeQuantizationMapSessionParametersCreateInfoKHR( VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) - VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeQuantizationMapSessionParametersCreateInfoKHR( VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeQuantizationMapSessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeQuantizationMapSessionParametersCreateInfoKHR & - operator=( VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeQuantizationMapSessionParametersCreateInfoKHR & - operator=( VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapSessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapSessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapSessionParametersCreateInfoKHR & - setQuantizationMapTexelSize( Extent2D const & quantizationMapTexelSize_ ) & - VULKAN_HPP_NOEXCEPT - { - quantizationMapTexelSize = quantizationMapTexelSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeQuantizationMapSessionParametersCreateInfoKHR && - setQuantizationMapTexelSize( Extent2D const & quantizationMapTexelSize_ ) && - VULKAN_HPP_NOEXCEPT - { - quantizationMapTexelSize = quantizationMapTexelSize_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, quantizationMapTexelSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( quantizationMapTexelSize == rhs.quantizationMapTexelSize ); -# endif - } - - bool operator!=( VideoEncodeQuantizationMapSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeQuantizationMapSessionParametersCreateInfoKHR; - const void * pNext = {}; - Extent2D quantizationMapTexelSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeQuantizationMapSessionParametersCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeQuantizationMapSessionParametersCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeRateControlLayerInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlLayerInfoKHR.html - struct VideoEncodeRateControlLayerInfoKHR - { - using NativeType = VkVideoEncodeRateControlLayerInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlLayerInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( uint64_t averageBitrate_ = {}, - uint64_t maxBitrate_ = {}, - uint32_t frameRateNumerator_ = {}, - uint32_t frameRateDenominator_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , averageBitrate{ averageBitrate_ } - , maxBitrate{ maxBitrate_ } - , frameRateNumerator{ frameRateNumerator_ } - , frameRateDenominator{ frameRateDenominator_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeRateControlLayerInfoKHR( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeRateControlLayerInfoKHR( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeRateControlLayerInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeRateControlLayerInfoKHR & operator=( VideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeRateControlLayerInfoKHR & operator=( VkVideoEncodeRateControlLayerInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setAverageBitrate( uint64_t averageBitrate_ ) & VULKAN_HPP_NOEXCEPT - { - averageBitrate = averageBitrate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR && setAverageBitrate( uint64_t averageBitrate_ ) && VULKAN_HPP_NOEXCEPT - { - averageBitrate = averageBitrate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setMaxBitrate( uint64_t maxBitrate_ ) & VULKAN_HPP_NOEXCEPT - { - maxBitrate = maxBitrate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR && setMaxBitrate( uint64_t maxBitrate_ ) && VULKAN_HPP_NOEXCEPT - { - maxBitrate = maxBitrate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateNumerator( uint32_t frameRateNumerator_ ) & VULKAN_HPP_NOEXCEPT - { - frameRateNumerator = frameRateNumerator_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR && setFrameRateNumerator( uint32_t frameRateNumerator_ ) && VULKAN_HPP_NOEXCEPT - { - frameRateNumerator = frameRateNumerator_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR & setFrameRateDenominator( uint32_t frameRateDenominator_ ) & VULKAN_HPP_NOEXCEPT - { - frameRateDenominator = frameRateDenominator_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlLayerInfoKHR && setFrameRateDenominator( uint32_t frameRateDenominator_ ) && VULKAN_HPP_NOEXCEPT - { - frameRateDenominator = frameRateDenominator_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeRateControlLayerInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeRateControlLayerInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeRateControlLayerInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeRateControlLayerInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, averageBitrate, maxBitrate, frameRateNumerator, frameRateDenominator ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeRateControlLayerInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( averageBitrate == rhs.averageBitrate ) && ( maxBitrate == rhs.maxBitrate ) && - ( frameRateNumerator == rhs.frameRateNumerator ) && ( frameRateDenominator == rhs.frameRateDenominator ); -# endif - } - - bool operator!=( VideoEncodeRateControlLayerInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeRateControlLayerInfoKHR; - const void * pNext = {}; - uint64_t averageBitrate = {}; - uint64_t maxBitrate = {}; - uint32_t frameRateNumerator = {}; - uint32_t frameRateDenominator = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeRateControlLayerInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeRateControlLayerInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeRateControlInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRateControlInfoKHR.html - struct VideoEncodeRateControlInfoKHR - { - using NativeType = VkVideoEncodeRateControlInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRateControlInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoEncodeRateControlInfoKHR( VideoEncodeRateControlFlagsKHR flags_ = {}, - VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ = VideoEncodeRateControlModeFlagBitsKHR::eDefault, - uint32_t layerCount_ = {}, - const VideoEncodeRateControlLayerInfoKHR * pLayers_ = {}, - uint32_t virtualBufferSizeInMs_ = {}, - uint32_t initialVirtualBufferSizeInMs_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , rateControlMode{ rateControlMode_ } - , layerCount{ layerCount_ } - , pLayers{ pLayers_ } - , virtualBufferSizeInMs{ virtualBufferSizeInMs_ } - , initialVirtualBufferSizeInMs{ initialVirtualBufferSizeInMs_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeRateControlInfoKHR( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeRateControlInfoKHR( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeRateControlInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeRateControlInfoKHR( VideoEncodeRateControlFlagsKHR flags_, - VideoEncodeRateControlModeFlagBitsKHR rateControlMode_, - ArrayProxyNoTemporaries const & layers_, - uint32_t virtualBufferSizeInMs_ = {}, - uint32_t initialVirtualBufferSizeInMs_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , flags( flags_ ) - , rateControlMode( rateControlMode_ ) - , layerCount( static_cast( layers_.size() ) ) - , pLayers( layers_.data() ) - , virtualBufferSizeInMs( virtualBufferSizeInMs_ ) - , initialVirtualBufferSizeInMs( initialVirtualBufferSizeInMs_ ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoEncodeRateControlInfoKHR & operator=( VideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeRateControlInfoKHR & operator=( VkVideoEncodeRateControlInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setFlags( VideoEncodeRateControlFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setFlags( VideoEncodeRateControlFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setRateControlMode( VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ ) & VULKAN_HPP_NOEXCEPT - { - rateControlMode = rateControlMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setRateControlMode( VideoEncodeRateControlModeFlagBitsKHR rateControlMode_ ) && VULKAN_HPP_NOEXCEPT - { - rateControlMode = rateControlMode_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setLayerCount( uint32_t layerCount_ ) & VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setLayerCount( uint32_t layerCount_ ) && VULKAN_HPP_NOEXCEPT - { - layerCount = layerCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setPLayers( const VideoEncodeRateControlLayerInfoKHR * pLayers_ ) & VULKAN_HPP_NOEXCEPT - { - pLayers = pLayers_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setPLayers( const VideoEncodeRateControlLayerInfoKHR * pLayers_ ) && VULKAN_HPP_NOEXCEPT - { - pLayers = pLayers_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoEncodeRateControlInfoKHR & setLayers( ArrayProxyNoTemporaries const & layers_ ) VULKAN_HPP_NOEXCEPT - { - layerCount = static_cast( layers_.size() ); - pLayers = layers_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setVirtualBufferSizeInMs( uint32_t virtualBufferSizeInMs_ ) & VULKAN_HPP_NOEXCEPT - { - virtualBufferSizeInMs = virtualBufferSizeInMs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setVirtualBufferSizeInMs( uint32_t virtualBufferSizeInMs_ ) && VULKAN_HPP_NOEXCEPT - { - virtualBufferSizeInMs = virtualBufferSizeInMs_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR & setInitialVirtualBufferSizeInMs( uint32_t initialVirtualBufferSizeInMs_ ) & VULKAN_HPP_NOEXCEPT - { - initialVirtualBufferSizeInMs = initialVirtualBufferSizeInMs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeRateControlInfoKHR && setInitialVirtualBufferSizeInMs( uint32_t initialVirtualBufferSizeInMs_ ) && VULKAN_HPP_NOEXCEPT - { - initialVirtualBufferSizeInMs = initialVirtualBufferSizeInMs_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeRateControlInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeRateControlInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeRateControlInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeRateControlInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, rateControlMode, layerCount, pLayers, virtualBufferSizeInMs, initialVirtualBufferSizeInMs ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeRateControlInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( rateControlMode == rhs.rateControlMode ) && - ( layerCount == rhs.layerCount ) && ( pLayers == rhs.pLayers ) && ( virtualBufferSizeInMs == rhs.virtualBufferSizeInMs ) && - ( initialVirtualBufferSizeInMs == rhs.initialVirtualBufferSizeInMs ); -# endif - } - - bool operator!=( VideoEncodeRateControlInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeRateControlInfoKHR; - const void * pNext = {}; - VideoEncodeRateControlFlagsKHR flags = {}; - VideoEncodeRateControlModeFlagBitsKHR rateControlMode = VideoEncodeRateControlModeFlagBitsKHR::eDefault; - uint32_t layerCount = {}; - const VideoEncodeRateControlLayerInfoKHR * pLayers = {}; - uint32_t virtualBufferSizeInMs = {}; - uint32_t initialVirtualBufferSizeInMs = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeRateControlInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeRateControlInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeRgbConversionCapabilitiesVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeRgbConversionCapabilitiesVALVE.html - struct VideoEncodeRgbConversionCapabilitiesVALVE - { - using NativeType = VkVideoEncodeRgbConversionCapabilitiesVALVE; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeRgbConversionCapabilitiesVALVE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeRgbConversionCapabilitiesVALVE( VideoEncodeRgbModelConversionFlagsVALVE rgbModels_ = {}, - VideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges_ = {}, - VideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets_ = {}, - VideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rgbModels{ rgbModels_ } - , rgbRanges{ rgbRanges_ } - , xChromaOffsets{ xChromaOffsets_ } - , yChromaOffsets{ yChromaOffsets_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeRgbConversionCapabilitiesVALVE( VideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeRgbConversionCapabilitiesVALVE( VkVideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeRgbConversionCapabilitiesVALVE( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeRgbConversionCapabilitiesVALVE & operator=( VideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeRgbConversionCapabilitiesVALVE & operator=( VkVideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeRgbConversionCapabilitiesVALVE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeRgbConversionCapabilitiesVALVE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeRgbConversionCapabilitiesVALVE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeRgbConversionCapabilitiesVALVE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rgbModels, rgbRanges, xChromaOffsets, yChromaOffsets ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeRgbConversionCapabilitiesVALVE const & ) const = default; -#else - bool operator==( VideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rgbModels == rhs.rgbModels ) && ( rgbRanges == rhs.rgbRanges ) && - ( xChromaOffsets == rhs.xChromaOffsets ) && ( yChromaOffsets == rhs.yChromaOffsets ); -# endif - } - - bool operator!=( VideoEncodeRgbConversionCapabilitiesVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeRgbConversionCapabilitiesVALVE; - void * pNext = {}; - VideoEncodeRgbModelConversionFlagsVALVE rgbModels = {}; - VideoEncodeRgbRangeCompressionFlagsVALVE rgbRanges = {}; - VideoEncodeRgbChromaOffsetFlagsVALVE xChromaOffsets = {}; - VideoEncodeRgbChromaOffsetFlagsVALVE yChromaOffsets = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeRgbConversionCapabilitiesVALVE; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeRgbConversionCapabilitiesVALVE; - }; - - // wrapper struct for struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeSessionIntraRefreshCreateInfoKHR.html - struct VideoEncodeSessionIntraRefreshCreateInfoKHR - { - using NativeType = VkVideoEncodeSessionIntraRefreshCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionIntraRefreshCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoEncodeSessionIntraRefreshCreateInfoKHR( VideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode_ = VideoEncodeIntraRefreshModeFlagBitsKHR::eNone, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , intraRefreshMode{ intraRefreshMode_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeSessionIntraRefreshCreateInfoKHR( VideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeSessionIntraRefreshCreateInfoKHR( VkVideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeSessionIntraRefreshCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeSessionIntraRefreshCreateInfoKHR & operator=( VideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeSessionIntraRefreshCreateInfoKHR & operator=( VkVideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionIntraRefreshCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionIntraRefreshCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionIntraRefreshCreateInfoKHR & setIntraRefreshMode( VideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode_ ) & - VULKAN_HPP_NOEXCEPT - { - intraRefreshMode = intraRefreshMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionIntraRefreshCreateInfoKHR && setIntraRefreshMode( VideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode_ ) && - VULKAN_HPP_NOEXCEPT - { - intraRefreshMode = intraRefreshMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeSessionIntraRefreshCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionIntraRefreshCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionIntraRefreshCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionIntraRefreshCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, intraRefreshMode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeSessionIntraRefreshCreateInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( intraRefreshMode == rhs.intraRefreshMode ); -# endif - } - - bool operator!=( VideoEncodeSessionIntraRefreshCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeSessionIntraRefreshCreateInfoKHR; - const void * pNext = {}; - VideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode = VideoEncodeIntraRefreshModeFlagBitsKHR::eNone; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeSessionIntraRefreshCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeSessionIntraRefreshCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeSessionParametersFeedbackInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeSessionParametersFeedbackInfoKHR.html - struct VideoEncodeSessionParametersFeedbackInfoKHR - { - using NativeType = VkVideoEncodeSessionParametersFeedbackInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersFeedbackInfoKHR( Bool32 hasOverrides_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , hasOverrides{ hasOverrides_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersFeedbackInfoKHR( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeSessionParametersFeedbackInfoKHR( VkVideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeSessionParametersFeedbackInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeSessionParametersFeedbackInfoKHR & operator=( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeSessionParametersFeedbackInfoKHR & operator=( VkVideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoEncodeSessionParametersFeedbackInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionParametersFeedbackInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionParametersFeedbackInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionParametersFeedbackInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, hasOverrides ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeSessionParametersFeedbackInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( hasOverrides == rhs.hasOverrides ); -# endif - } - - bool operator!=( VideoEncodeSessionParametersFeedbackInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR; - void * pNext = {}; - Bool32 hasOverrides = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeSessionParametersFeedbackInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeSessionParametersFeedbackInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeSessionParametersGetInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeSessionParametersGetInfoKHR.html - struct VideoEncodeSessionParametersGetInfoKHR - { - using NativeType = VkVideoEncodeSessionParametersGetInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionParametersGetInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersGetInfoKHR( VideoSessionParametersKHR videoSessionParameters_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoSessionParameters{ videoSessionParameters_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeSessionParametersGetInfoKHR( VideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeSessionParametersGetInfoKHR( VkVideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeSessionParametersGetInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeSessionParametersGetInfoKHR & operator=( VideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeSessionParametersGetInfoKHR & operator=( VkVideoEncodeSessionParametersGetInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR & setVideoSessionParameters( VideoSessionParametersKHR videoSessionParameters_ ) & - VULKAN_HPP_NOEXCEPT - { - videoSessionParameters = videoSessionParameters_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionParametersGetInfoKHR && setVideoSessionParameters( VideoSessionParametersKHR videoSessionParameters_ ) && - VULKAN_HPP_NOEXCEPT - { - videoSessionParameters = videoSessionParameters_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeSessionParametersGetInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionParametersGetInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionParametersGetInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionParametersGetInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoSessionParameters ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeSessionParametersGetInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeSessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoSessionParameters == rhs.videoSessionParameters ); -# endif - } - - bool operator!=( VideoEncodeSessionParametersGetInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeSessionParametersGetInfoKHR; - const void * pNext = {}; - VideoSessionParametersKHR videoSessionParameters = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeSessionParametersGetInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeSessionParametersGetInfoKHR; - }; - - // wrapper struct for struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeSessionRgbConversionCreateInfoVALVE.html - struct VideoEncodeSessionRgbConversionCreateInfoVALVE - { - using NativeType = VkVideoEncodeSessionRgbConversionCreateInfoVALVE; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeSessionRgbConversionCreateInfoVALVE; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeSessionRgbConversionCreateInfoVALVE( - VideoEncodeRgbModelConversionFlagBitsVALVE rgbModel_ = VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity, - VideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange_ = VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange, - VideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset_ = VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven, - VideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset_ = VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , rgbModel{ rgbModel_ } - , rgbRange{ rgbRange_ } - , xChromaOffset{ xChromaOffset_ } - , yChromaOffset{ yChromaOffset_ } - { - } - - VULKAN_HPP_CONSTEXPR - VideoEncodeSessionRgbConversionCreateInfoVALVE( VideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeSessionRgbConversionCreateInfoVALVE( VkVideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeSessionRgbConversionCreateInfoVALVE( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeSessionRgbConversionCreateInfoVALVE & operator=( VideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeSessionRgbConversionCreateInfoVALVE & operator=( VkVideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE & setRgbModel( VideoEncodeRgbModelConversionFlagBitsVALVE rgbModel_ ) & - VULKAN_HPP_NOEXCEPT - { - rgbModel = rgbModel_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE && setRgbModel( VideoEncodeRgbModelConversionFlagBitsVALVE rgbModel_ ) && - VULKAN_HPP_NOEXCEPT - { - rgbModel = rgbModel_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE & setRgbRange( VideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange_ ) & - VULKAN_HPP_NOEXCEPT - { - rgbRange = rgbRange_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE && setRgbRange( VideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange_ ) && - VULKAN_HPP_NOEXCEPT - { - rgbRange = rgbRange_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE & setXChromaOffset( VideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset_ ) & - VULKAN_HPP_NOEXCEPT - { - xChromaOffset = xChromaOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE && setXChromaOffset( VideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset_ ) && - VULKAN_HPP_NOEXCEPT - { - xChromaOffset = xChromaOffset_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE & setYChromaOffset( VideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset_ ) & - VULKAN_HPP_NOEXCEPT - { - yChromaOffset = yChromaOffset_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeSessionRgbConversionCreateInfoVALVE && setYChromaOffset( VideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset_ ) && - VULKAN_HPP_NOEXCEPT - { - yChromaOffset = yChromaOffset_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeSessionRgbConversionCreateInfoVALVE const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionRgbConversionCreateInfoVALVE &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionRgbConversionCreateInfoVALVE const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeSessionRgbConversionCreateInfoVALVE *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, rgbModel, rgbRange, xChromaOffset, yChromaOffset ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeSessionRgbConversionCreateInfoVALVE const & ) const = default; -#else - bool operator==( VideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( rgbModel == rhs.rgbModel ) && ( rgbRange == rhs.rgbRange ) && - ( xChromaOffset == rhs.xChromaOffset ) && ( yChromaOffset == rhs.yChromaOffset ); -# endif - } - - bool operator!=( VideoEncodeSessionRgbConversionCreateInfoVALVE const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeSessionRgbConversionCreateInfoVALVE; - const void * pNext = {}; - VideoEncodeRgbModelConversionFlagBitsVALVE rgbModel = VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity; - VideoEncodeRgbRangeCompressionFlagBitsVALVE rgbRange = VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange; - VideoEncodeRgbChromaOffsetFlagBitsVALVE xChromaOffset = VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven; - VideoEncodeRgbChromaOffsetFlagBitsVALVE yChromaOffset = VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeSessionRgbConversionCreateInfoVALVE; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeSessionRgbConversionCreateInfoVALVE; - }; - - // wrapper struct for struct VkVideoEncodeUsageInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEncodeUsageInfoKHR.html - struct VideoEncodeUsageInfoKHR - { - using NativeType = VkVideoEncodeUsageInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEncodeUsageInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEncodeUsageInfoKHR( VideoEncodeUsageFlagsKHR videoUsageHints_ = {}, - VideoEncodeContentFlagsKHR videoContentHints_ = {}, - VideoEncodeTuningModeKHR tuningMode_ = VideoEncodeTuningModeKHR::eDefault, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , videoUsageHints{ videoUsageHints_ } - , videoContentHints{ videoContentHints_ } - , tuningMode{ tuningMode_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEncodeUsageInfoKHR( VideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEncodeUsageInfoKHR( VkVideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEncodeUsageInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEncodeUsageInfoKHR & operator=( VideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEncodeUsageInfoKHR & operator=( VkVideoEncodeUsageInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR & setVideoUsageHints( VideoEncodeUsageFlagsKHR videoUsageHints_ ) & VULKAN_HPP_NOEXCEPT - { - videoUsageHints = videoUsageHints_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR && setVideoUsageHints( VideoEncodeUsageFlagsKHR videoUsageHints_ ) && VULKAN_HPP_NOEXCEPT - { - videoUsageHints = videoUsageHints_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR & setVideoContentHints( VideoEncodeContentFlagsKHR videoContentHints_ ) & VULKAN_HPP_NOEXCEPT - { - videoContentHints = videoContentHints_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR && setVideoContentHints( VideoEncodeContentFlagsKHR videoContentHints_ ) && VULKAN_HPP_NOEXCEPT - { - videoContentHints = videoContentHints_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR & setTuningMode( VideoEncodeTuningModeKHR tuningMode_ ) & VULKAN_HPP_NOEXCEPT - { - tuningMode = tuningMode_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEncodeUsageInfoKHR && setTuningMode( VideoEncodeTuningModeKHR tuningMode_ ) && VULKAN_HPP_NOEXCEPT - { - tuningMode = tuningMode_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEncodeUsageInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeUsageInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEncodeUsageInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEncodeUsageInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std:: - tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, videoUsageHints, videoContentHints, tuningMode ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEncodeUsageInfoKHR const & ) const = default; -#else - bool operator==( VideoEncodeUsageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( videoUsageHints == rhs.videoUsageHints ) && ( videoContentHints == rhs.videoContentHints ) && - ( tuningMode == rhs.tuningMode ); -# endif - } - - bool operator!=( VideoEncodeUsageInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEncodeUsageInfoKHR; - const void * pNext = {}; - VideoEncodeUsageFlagsKHR videoUsageHints = {}; - VideoEncodeContentFlagsKHR videoContentHints = {}; - VideoEncodeTuningModeKHR tuningMode = VideoEncodeTuningModeKHR::eDefault; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEncodeUsageInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEncodeUsageInfoKHR; - }; - - // wrapper struct for struct VkVideoEndCodingInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoEndCodingInfoKHR.html - struct VideoEndCodingInfoKHR - { - using NativeType = VkVideoEndCodingInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoEndCodingInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoEndCodingInfoKHR( VideoEndCodingFlagsKHR flags_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoEndCodingInfoKHR( VideoEndCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoEndCodingInfoKHR( VkVideoEndCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoEndCodingInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoEndCodingInfoKHR & operator=( VideoEndCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoEndCodingInfoKHR & operator=( VkVideoEndCodingInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoEndCodingInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEndCodingInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoEndCodingInfoKHR & setFlags( VideoEndCodingFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoEndCodingInfoKHR && setFlags( VideoEndCodingFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoEndCodingInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEndCodingInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoEndCodingInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoEndCodingInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoEndCodingInfoKHR const & ) const = default; -#else - bool operator==( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ); -# endif - } - - bool operator!=( VideoEndCodingInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoEndCodingInfoKHR; - const void * pNext = {}; - VideoEndCodingFlagsKHR flags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoEndCodingInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoEndCodingInfoKHR; - }; - - // wrapper struct for struct VkVideoFormatAV1QuantizationMapPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoFormatAV1QuantizationMapPropertiesKHR.html - struct VideoFormatAV1QuantizationMapPropertiesKHR - { - using NativeType = VkVideoFormatAV1QuantizationMapPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoFormatAv1QuantizationMapPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoFormatAV1QuantizationMapPropertiesKHR( VideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , compatibleSuperblockSizes{ compatibleSuperblockSizes_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoFormatAV1QuantizationMapPropertiesKHR( VideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoFormatAV1QuantizationMapPropertiesKHR( VkVideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoFormatAV1QuantizationMapPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoFormatAV1QuantizationMapPropertiesKHR & operator=( VideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoFormatAV1QuantizationMapPropertiesKHR & operator=( VkVideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoFormatAV1QuantizationMapPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoFormatAV1QuantizationMapPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoFormatAV1QuantizationMapPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoFormatAV1QuantizationMapPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, compatibleSuperblockSizes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoFormatAV1QuantizationMapPropertiesKHR const & ) const = default; -#else - bool operator==( VideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compatibleSuperblockSizes == rhs.compatibleSuperblockSizes ); -# endif - } - - bool operator!=( VideoFormatAV1QuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoFormatAv1QuantizationMapPropertiesKHR; - void * pNext = {}; - VideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoFormatAV1QuantizationMapPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoFormatAV1QuantizationMapPropertiesKHR; - }; - - // wrapper struct for struct VkVideoFormatH265QuantizationMapPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoFormatH265QuantizationMapPropertiesKHR.html - struct VideoFormatH265QuantizationMapPropertiesKHR - { - using NativeType = VkVideoFormatH265QuantizationMapPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoFormatH265QuantizationMapPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoFormatH265QuantizationMapPropertiesKHR( VideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , compatibleCtbSizes{ compatibleCtbSizes_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoFormatH265QuantizationMapPropertiesKHR( VideoFormatH265QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoFormatH265QuantizationMapPropertiesKHR( VkVideoFormatH265QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoFormatH265QuantizationMapPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoFormatH265QuantizationMapPropertiesKHR & operator=( VideoFormatH265QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoFormatH265QuantizationMapPropertiesKHR & operator=( VkVideoFormatH265QuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoFormatH265QuantizationMapPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoFormatH265QuantizationMapPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoFormatH265QuantizationMapPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoFormatH265QuantizationMapPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, compatibleCtbSizes ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoFormatH265QuantizationMapPropertiesKHR const & ) const = default; -#else - bool operator==( VideoFormatH265QuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( compatibleCtbSizes == rhs.compatibleCtbSizes ); -# endif - } - - bool operator!=( VideoFormatH265QuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoFormatH265QuantizationMapPropertiesKHR; - void * pNext = {}; - VideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoFormatH265QuantizationMapPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoFormatH265QuantizationMapPropertiesKHR; - }; - - // wrapper struct for struct VkVideoFormatPropertiesKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoFormatPropertiesKHR.html - struct VideoFormatPropertiesKHR - { - using NativeType = VkVideoFormatPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoFormatPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoFormatPropertiesKHR( Format format_ = Format::eUndefined, - ComponentMapping componentMapping_ = {}, - ImageCreateFlags imageCreateFlags_ = {}, - ImageType imageType_ = ImageType::e1D, - ImageTiling imageTiling_ = ImageTiling::eOptimal, - ImageUsageFlags imageUsageFlags_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , format{ format_ } - , componentMapping{ componentMapping_ } - , imageCreateFlags{ imageCreateFlags_ } - , imageType{ imageType_ } - , imageTiling{ imageTiling_ } - , imageUsageFlags{ imageUsageFlags_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoFormatPropertiesKHR( VideoFormatPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoFormatPropertiesKHR( VkVideoFormatPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoFormatPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoFormatPropertiesKHR & operator=( VideoFormatPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoFormatPropertiesKHR & operator=( VkVideoFormatPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoFormatPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoFormatPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoFormatPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoFormatPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, format, componentMapping, imageCreateFlags, imageType, imageTiling, imageUsageFlags ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoFormatPropertiesKHR const & ) const = default; -#else - bool operator==( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( format == rhs.format ) && ( componentMapping == rhs.componentMapping ) && - ( imageCreateFlags == rhs.imageCreateFlags ) && ( imageType == rhs.imageType ) && ( imageTiling == rhs.imageTiling ) && - ( imageUsageFlags == rhs.imageUsageFlags ); -# endif - } - - bool operator!=( VideoFormatPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoFormatPropertiesKHR; - void * pNext = {}; - Format format = Format::eUndefined; - ComponentMapping componentMapping = {}; - ImageCreateFlags imageCreateFlags = {}; - ImageType imageType = ImageType::e1D; - ImageTiling imageTiling = ImageTiling::eOptimal; - ImageUsageFlags imageUsageFlags = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoFormatPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoFormatPropertiesKHR; - }; - - // wrapper struct for struct VkVideoFormatQuantizationMapPropertiesKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoFormatQuantizationMapPropertiesKHR.html - struct VideoFormatQuantizationMapPropertiesKHR - { - using NativeType = VkVideoFormatQuantizationMapPropertiesKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoFormatQuantizationMapPropertiesKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoFormatQuantizationMapPropertiesKHR( Extent2D quantizationMapTexelSize_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , quantizationMapTexelSize{ quantizationMapTexelSize_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoFormatQuantizationMapPropertiesKHR( VideoFormatQuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoFormatQuantizationMapPropertiesKHR( VkVideoFormatQuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoFormatQuantizationMapPropertiesKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoFormatQuantizationMapPropertiesKHR & operator=( VideoFormatQuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoFormatQuantizationMapPropertiesKHR & operator=( VkVideoFormatQuantizationMapPropertiesKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoFormatQuantizationMapPropertiesKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoFormatQuantizationMapPropertiesKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoFormatQuantizationMapPropertiesKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoFormatQuantizationMapPropertiesKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, quantizationMapTexelSize ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoFormatQuantizationMapPropertiesKHR const & ) const = default; -#else - bool operator==( VideoFormatQuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( quantizationMapTexelSize == rhs.quantizationMapTexelSize ); -# endif - } - - bool operator!=( VideoFormatQuantizationMapPropertiesKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoFormatQuantizationMapPropertiesKHR; - void * pNext = {}; - Extent2D quantizationMapTexelSize = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoFormatQuantizationMapPropertiesKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoFormatQuantizationMapPropertiesKHR; - }; - - // wrapper struct for struct VkVideoInlineQueryInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoInlineQueryInfoKHR.html - struct VideoInlineQueryInfoKHR - { - using NativeType = VkVideoInlineQueryInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoInlineQueryInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoInlineQueryInfoKHR( QueryPool queryPool_ = {}, - uint32_t firstQuery_ = {}, - uint32_t queryCount_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , queryPool{ queryPool_ } - , firstQuery{ firstQuery_ } - , queryCount{ queryCount_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoInlineQueryInfoKHR( VideoInlineQueryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoInlineQueryInfoKHR( VkVideoInlineQueryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoInlineQueryInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoInlineQueryInfoKHR & operator=( VideoInlineQueryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoInlineQueryInfoKHR & operator=( VkVideoInlineQueryInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR & setQueryPool( QueryPool queryPool_ ) & VULKAN_HPP_NOEXCEPT - { - queryPool = queryPool_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR && setQueryPool( QueryPool queryPool_ ) && VULKAN_HPP_NOEXCEPT - { - queryPool = queryPool_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR & setFirstQuery( uint32_t firstQuery_ ) & VULKAN_HPP_NOEXCEPT - { - firstQuery = firstQuery_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR && setFirstQuery( uint32_t firstQuery_ ) && VULKAN_HPP_NOEXCEPT - { - firstQuery = firstQuery_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR & setQueryCount( uint32_t queryCount_ ) & VULKAN_HPP_NOEXCEPT - { - queryCount = queryCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoInlineQueryInfoKHR && setQueryCount( uint32_t queryCount_ ) && VULKAN_HPP_NOEXCEPT - { - queryCount = queryCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoInlineQueryInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoInlineQueryInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoInlineQueryInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoInlineQueryInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, queryPool, firstQuery, queryCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoInlineQueryInfoKHR const & ) const = default; -#else - bool operator==( VideoInlineQueryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queryPool == rhs.queryPool ) && ( firstQuery == rhs.firstQuery ) && - ( queryCount == rhs.queryCount ); -# endif - } - - bool operator!=( VideoInlineQueryInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoInlineQueryInfoKHR; - const void * pNext = {}; - QueryPool queryPool = {}; - uint32_t firstQuery = {}; - uint32_t queryCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoInlineQueryInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoInlineQueryInfoKHR; - }; - - // wrapper struct for struct VkVideoProfileListInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoProfileListInfoKHR.html - struct VideoProfileListInfoKHR - { - using NativeType = VkVideoProfileListInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoProfileListInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - VideoProfileListInfoKHR( uint32_t profileCount_ = {}, const VideoProfileInfoKHR * pProfiles_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , profileCount{ profileCount_ } - , pProfiles{ pProfiles_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoProfileListInfoKHR( VideoProfileListInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoProfileListInfoKHR( VkVideoProfileListInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoProfileListInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoProfileListInfoKHR( ArrayProxyNoTemporaries const & profiles_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), profileCount( static_cast( profiles_.size() ) ), pProfiles( profiles_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VideoProfileListInfoKHR & operator=( VideoProfileListInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoProfileListInfoKHR & operator=( VkVideoProfileListInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR & setProfileCount( uint32_t profileCount_ ) & VULKAN_HPP_NOEXCEPT - { - profileCount = profileCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR && setProfileCount( uint32_t profileCount_ ) && VULKAN_HPP_NOEXCEPT - { - profileCount = profileCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR & setPProfiles( const VideoProfileInfoKHR * pProfiles_ ) & VULKAN_HPP_NOEXCEPT - { - pProfiles = pProfiles_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoProfileListInfoKHR && setPProfiles( const VideoProfileInfoKHR * pProfiles_ ) && VULKAN_HPP_NOEXCEPT - { - pProfiles = pProfiles_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - VideoProfileListInfoKHR & setProfiles( ArrayProxyNoTemporaries const & profiles_ ) VULKAN_HPP_NOEXCEPT - { - profileCount = static_cast( profiles_.size() ); - pProfiles = profiles_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoProfileListInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoProfileListInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoProfileListInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoProfileListInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, profileCount, pProfiles ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoProfileListInfoKHR const & ) const = default; -#else - bool operator==( VideoProfileListInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( profileCount == rhs.profileCount ) && ( pProfiles == rhs.pProfiles ); -# endif - } - - bool operator!=( VideoProfileListInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoProfileListInfoKHR; - const void * pNext = {}; - uint32_t profileCount = {}; - const VideoProfileInfoKHR * pProfiles = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoProfileListInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoProfileListInfoKHR; - }; - - // wrapper struct for struct VkVideoReferenceIntraRefreshInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoReferenceIntraRefreshInfoKHR.html - struct VideoReferenceIntraRefreshInfoKHR - { - using NativeType = VkVideoReferenceIntraRefreshInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoReferenceIntraRefreshInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoReferenceIntraRefreshInfoKHR( uint32_t dirtyIntraRefreshRegions_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dirtyIntraRefreshRegions{ dirtyIntraRefreshRegions_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoReferenceIntraRefreshInfoKHR( VideoReferenceIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoReferenceIntraRefreshInfoKHR( VkVideoReferenceIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoReferenceIntraRefreshInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoReferenceIntraRefreshInfoKHR & operator=( VideoReferenceIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoReferenceIntraRefreshInfoKHR & operator=( VkVideoReferenceIntraRefreshInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoReferenceIntraRefreshInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoReferenceIntraRefreshInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoReferenceIntraRefreshInfoKHR & setDirtyIntraRefreshRegions( uint32_t dirtyIntraRefreshRegions_ ) & VULKAN_HPP_NOEXCEPT - { - dirtyIntraRefreshRegions = dirtyIntraRefreshRegions_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoReferenceIntraRefreshInfoKHR && setDirtyIntraRefreshRegions( uint32_t dirtyIntraRefreshRegions_ ) && VULKAN_HPP_NOEXCEPT - { - dirtyIntraRefreshRegions = dirtyIntraRefreshRegions_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoReferenceIntraRefreshInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoReferenceIntraRefreshInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoReferenceIntraRefreshInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoReferenceIntraRefreshInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dirtyIntraRefreshRegions ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoReferenceIntraRefreshInfoKHR const & ) const = default; -#else - bool operator==( VideoReferenceIntraRefreshInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dirtyIntraRefreshRegions == rhs.dirtyIntraRefreshRegions ); -# endif - } - - bool operator!=( VideoReferenceIntraRefreshInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoReferenceIntraRefreshInfoKHR; - const void * pNext = {}; - uint32_t dirtyIntraRefreshRegions = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoReferenceIntraRefreshInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoReferenceIntraRefreshInfoKHR; - }; - - // wrapper struct for struct VkVideoSessionCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionCreateInfoKHR.html - struct VideoSessionCreateInfoKHR - { - using NativeType = VkVideoSessionCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoSessionCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR( uint32_t queueFamilyIndex_ = {}, - VideoSessionCreateFlagsKHR flags_ = {}, - const VideoProfileInfoKHR * pVideoProfile_ = {}, - Format pictureFormat_ = Format::eUndefined, - Extent2D maxCodedExtent_ = {}, - Format referencePictureFormat_ = Format::eUndefined, - uint32_t maxDpbSlots_ = {}, - uint32_t maxActiveReferencePictures_ = {}, - const ExtensionProperties * pStdHeaderVersion_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , queueFamilyIndex{ queueFamilyIndex_ } - , flags{ flags_ } - , pVideoProfile{ pVideoProfile_ } - , pictureFormat{ pictureFormat_ } - , maxCodedExtent{ maxCodedExtent_ } - , referencePictureFormat{ referencePictureFormat_ } - , maxDpbSlots{ maxDpbSlots_ } - , maxActiveReferencePictures{ maxActiveReferencePictures_ } - , pStdHeaderVersion{ pStdHeaderVersion_ } - { - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR( VideoSessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoSessionCreateInfoKHR( VkVideoSessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoSessionCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoSessionCreateInfoKHR & operator=( VideoSessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoSessionCreateInfoKHR & operator=( VkVideoSessionCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) & VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setQueueFamilyIndex( uint32_t queueFamilyIndex_ ) && VULKAN_HPP_NOEXCEPT - { - queueFamilyIndex = queueFamilyIndex_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setFlags( VideoSessionCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setFlags( VideoSessionCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setPVideoProfile( const VideoProfileInfoKHR * pVideoProfile_ ) & VULKAN_HPP_NOEXCEPT - { - pVideoProfile = pVideoProfile_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setPVideoProfile( const VideoProfileInfoKHR * pVideoProfile_ ) && VULKAN_HPP_NOEXCEPT - { - pVideoProfile = pVideoProfile_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setPictureFormat( Format pictureFormat_ ) & VULKAN_HPP_NOEXCEPT - { - pictureFormat = pictureFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setPictureFormat( Format pictureFormat_ ) && VULKAN_HPP_NOEXCEPT - { - pictureFormat = pictureFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setMaxCodedExtent( Extent2D const & maxCodedExtent_ ) & VULKAN_HPP_NOEXCEPT - { - maxCodedExtent = maxCodedExtent_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setMaxCodedExtent( Extent2D const & maxCodedExtent_ ) && VULKAN_HPP_NOEXCEPT - { - maxCodedExtent = maxCodedExtent_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setReferencePictureFormat( Format referencePictureFormat_ ) & VULKAN_HPP_NOEXCEPT - { - referencePictureFormat = referencePictureFormat_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setReferencePictureFormat( Format referencePictureFormat_ ) && VULKAN_HPP_NOEXCEPT - { - referencePictureFormat = referencePictureFormat_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setMaxDpbSlots( uint32_t maxDpbSlots_ ) & VULKAN_HPP_NOEXCEPT - { - maxDpbSlots = maxDpbSlots_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setMaxDpbSlots( uint32_t maxDpbSlots_ ) && VULKAN_HPP_NOEXCEPT - { - maxDpbSlots = maxDpbSlots_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setMaxActiveReferencePictures( uint32_t maxActiveReferencePictures_ ) & VULKAN_HPP_NOEXCEPT - { - maxActiveReferencePictures = maxActiveReferencePictures_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setMaxActiveReferencePictures( uint32_t maxActiveReferencePictures_ ) && VULKAN_HPP_NOEXCEPT - { - maxActiveReferencePictures = maxActiveReferencePictures_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR & setPStdHeaderVersion( const ExtensionProperties * pStdHeaderVersion_ ) & VULKAN_HPP_NOEXCEPT - { - pStdHeaderVersion = pStdHeaderVersion_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionCreateInfoKHR && setPStdHeaderVersion( const ExtensionProperties * pStdHeaderVersion_ ) && VULKAN_HPP_NOEXCEPT - { - pStdHeaderVersion = pStdHeaderVersion_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoSessionCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoSessionCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoSessionCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoSessionCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, - pNext, - queueFamilyIndex, - flags, - pVideoProfile, - pictureFormat, - maxCodedExtent, - referencePictureFormat, - maxDpbSlots, - maxActiveReferencePictures, - pStdHeaderVersion ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoSessionCreateInfoKHR const & ) const = default; -#else - bool operator==( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( queueFamilyIndex == rhs.queueFamilyIndex ) && ( flags == rhs.flags ) && - ( pVideoProfile == rhs.pVideoProfile ) && ( pictureFormat == rhs.pictureFormat ) && ( maxCodedExtent == rhs.maxCodedExtent ) && - ( referencePictureFormat == rhs.referencePictureFormat ) && ( maxDpbSlots == rhs.maxDpbSlots ) && - ( maxActiveReferencePictures == rhs.maxActiveReferencePictures ) && ( pStdHeaderVersion == rhs.pStdHeaderVersion ); -# endif - } - - bool operator!=( VideoSessionCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoSessionCreateInfoKHR; - const void * pNext = {}; - uint32_t queueFamilyIndex = {}; - VideoSessionCreateFlagsKHR flags = {}; - const VideoProfileInfoKHR * pVideoProfile = {}; - Format pictureFormat = Format::eUndefined; - Extent2D maxCodedExtent = {}; - Format referencePictureFormat = Format::eUndefined; - uint32_t maxDpbSlots = {}; - uint32_t maxActiveReferencePictures = {}; - const ExtensionProperties * pStdHeaderVersion = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoSessionCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoSessionCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoSessionMemoryRequirementsKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionMemoryRequirementsKHR.html - struct VideoSessionMemoryRequirementsKHR - { - using NativeType = VkVideoSessionMemoryRequirementsKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoSessionMemoryRequirementsKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoSessionMemoryRequirementsKHR( uint32_t memoryBindIndex_ = {}, - MemoryRequirements memoryRequirements_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , memoryBindIndex{ memoryBindIndex_ } - , memoryRequirements{ memoryRequirements_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoSessionMemoryRequirementsKHR( VideoSessionMemoryRequirementsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoSessionMemoryRequirementsKHR( VkVideoSessionMemoryRequirementsKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoSessionMemoryRequirementsKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoSessionMemoryRequirementsKHR & operator=( VideoSessionMemoryRequirementsKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoSessionMemoryRequirementsKHR & operator=( VkVideoSessionMemoryRequirementsKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - - operator VkVideoSessionMemoryRequirementsKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoSessionMemoryRequirementsKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoSessionMemoryRequirementsKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoSessionMemoryRequirementsKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, memoryBindIndex, memoryRequirements ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoSessionMemoryRequirementsKHR const & ) const = default; -#else - bool operator==( VideoSessionMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( memoryBindIndex == rhs.memoryBindIndex ) && ( memoryRequirements == rhs.memoryRequirements ); -# endif - } - - bool operator!=( VideoSessionMemoryRequirementsKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoSessionMemoryRequirementsKHR; - void * pNext = {}; - uint32_t memoryBindIndex = {}; - MemoryRequirements memoryRequirements = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoSessionMemoryRequirementsKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoSessionMemoryRequirementsKHR; - }; - - // wrapper struct for struct VkVideoSessionParametersCreateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersCreateInfoKHR.html - struct VideoSessionParametersCreateInfoKHR - { - using NativeType = VkVideoSessionParametersCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoSessionParametersCreateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoSessionParametersCreateInfoKHR( VideoSessionParametersCreateFlagsKHR flags_ = {}, - VideoSessionParametersKHR videoSessionParametersTemplate_ = {}, - VideoSessionKHR videoSession_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , videoSessionParametersTemplate{ videoSessionParametersTemplate_ } - , videoSession{ videoSession_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoSessionParametersCreateInfoKHR( VideoSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoSessionParametersCreateInfoKHR( VkVideoSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoSessionParametersCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoSessionParametersCreateInfoKHR & operator=( VideoSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoSessionParametersCreateInfoKHR & operator=( VkVideoSessionParametersCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR & setFlags( VideoSessionParametersCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR && setFlags( VideoSessionParametersCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR & - setVideoSessionParametersTemplate( VideoSessionParametersKHR videoSessionParametersTemplate_ ) & - VULKAN_HPP_NOEXCEPT - { - videoSessionParametersTemplate = videoSessionParametersTemplate_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR && - setVideoSessionParametersTemplate( VideoSessionParametersKHR videoSessionParametersTemplate_ ) && - VULKAN_HPP_NOEXCEPT - { - videoSessionParametersTemplate = videoSessionParametersTemplate_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR & setVideoSession( VideoSessionKHR videoSession_ ) & VULKAN_HPP_NOEXCEPT - { - videoSession = videoSession_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersCreateInfoKHR && setVideoSession( VideoSessionKHR videoSession_ ) && VULKAN_HPP_NOEXCEPT - { - videoSession = videoSession_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoSessionParametersCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoSessionParametersCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoSessionParametersCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoSessionParametersCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, videoSessionParametersTemplate, videoSession ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoSessionParametersCreateInfoKHR const & ) const = default; -#else - bool operator==( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && - ( videoSessionParametersTemplate == rhs.videoSessionParametersTemplate ) && ( videoSession == rhs.videoSession ); -# endif - } - - bool operator!=( VideoSessionParametersCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoSessionParametersCreateInfoKHR; - const void * pNext = {}; - VideoSessionParametersCreateFlagsKHR flags = {}; - VideoSessionParametersKHR videoSessionParametersTemplate = {}; - VideoSessionKHR videoSession = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoSessionParametersCreateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoSessionParametersCreateInfoKHR; - }; - - // wrapper struct for struct VkVideoSessionParametersUpdateInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkVideoSessionParametersUpdateInfoKHR.html - struct VideoSessionParametersUpdateInfoKHR - { - using NativeType = VkVideoSessionParametersUpdateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eVideoSessionParametersUpdateInfoKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR VideoSessionParametersUpdateInfoKHR( uint32_t updateSequenceCount_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , updateSequenceCount{ updateSequenceCount_ } - { - } - - VULKAN_HPP_CONSTEXPR VideoSessionParametersUpdateInfoKHR( VideoSessionParametersUpdateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - VideoSessionParametersUpdateInfoKHR( VkVideoSessionParametersUpdateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : VideoSessionParametersUpdateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - VideoSessionParametersUpdateInfoKHR & operator=( VideoSessionParametersUpdateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - VideoSessionParametersUpdateInfoKHR & operator=( VkVideoSessionParametersUpdateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersUpdateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersUpdateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersUpdateInfoKHR & setUpdateSequenceCount( uint32_t updateSequenceCount_ ) & VULKAN_HPP_NOEXCEPT - { - updateSequenceCount = updateSequenceCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 VideoSessionParametersUpdateInfoKHR && setUpdateSequenceCount( uint32_t updateSequenceCount_ ) && VULKAN_HPP_NOEXCEPT - { - updateSequenceCount = updateSequenceCount_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkVideoSessionParametersUpdateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoSessionParametersUpdateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkVideoSessionParametersUpdateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkVideoSessionParametersUpdateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, updateSequenceCount ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( VideoSessionParametersUpdateInfoKHR const & ) const = default; -#else - bool operator==( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( updateSequenceCount == rhs.updateSequenceCount ); -# endif - } - - bool operator!=( VideoSessionParametersUpdateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eVideoSessionParametersUpdateInfoKHR; - const void * pNext = {}; - uint32_t updateSequenceCount = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = VideoSessionParametersUpdateInfoKHR; - }; -#endif - - template <> - struct CppType - { - using Type = VideoSessionParametersUpdateInfoKHR; - }; - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - // wrapper struct for struct VkWaylandSurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWaylandSurfaceCreateInfoKHR.html - struct WaylandSurfaceCreateInfoKHR - { - using NativeType = VkWaylandSurfaceCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWaylandSurfaceCreateInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateFlagsKHR flags_ = {}, - struct wl_display * display_ = {}, - struct wl_surface * surface_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , display{ display_ } - , surface{ surface_ } - { - } - - VULKAN_HPP_CONSTEXPR WaylandSurfaceCreateInfoKHR( WaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - WaylandSurfaceCreateInfoKHR( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : WaylandSurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - WaylandSurfaceCreateInfoKHR & operator=( WaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - WaylandSurfaceCreateInfoKHR & operator=( VkWaylandSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR & setFlags( WaylandSurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR && setFlags( WaylandSurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR & setDisplay( struct wl_display * display_ ) & VULKAN_HPP_NOEXCEPT - { - display = display_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR && setDisplay( struct wl_display * display_ ) && VULKAN_HPP_NOEXCEPT - { - display = display_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR & setSurface( struct wl_surface * surface_ ) & VULKAN_HPP_NOEXCEPT - { - surface = surface_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WaylandSurfaceCreateInfoKHR && setSurface( struct wl_surface * surface_ ) && VULKAN_HPP_NOEXCEPT - { - surface = surface_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWaylandSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWaylandSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWaylandSurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWaylandSurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, display, surface ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( WaylandSurfaceCreateInfoKHR const & ) const = default; -# else - bool operator==( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( display == rhs.display ) && ( surface == rhs.surface ); -# endif - } - - bool operator!=( WaylandSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eWaylandSurfaceCreateInfoKHR; - const void * pNext = {}; - WaylandSurfaceCreateFlagsKHR flags = {}; - struct wl_display * display = {}; - struct wl_surface * surface = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = WaylandSurfaceCreateInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = WaylandSurfaceCreateInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkWin32KeyedMutexAcquireReleaseInfoKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWin32KeyedMutexAcquireReleaseInfoKHR.html - struct Win32KeyedMutexAcquireReleaseInfoKHR - { - using NativeType = VkWin32KeyedMutexAcquireReleaseInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( uint32_t acquireCount_ = {}, - const DeviceMemory * pAcquireSyncs_ = {}, - const uint64_t * pAcquireKeys_ = {}, - const uint32_t * pAcquireTimeouts_ = {}, - uint32_t releaseCount_ = {}, - const DeviceMemory * pReleaseSyncs_ = {}, - const uint64_t * pReleaseKeys_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , acquireCount{ acquireCount_ } - , pAcquireSyncs{ pAcquireSyncs_ } - , pAcquireKeys{ pAcquireKeys_ } - , pAcquireTimeouts{ pAcquireTimeouts_ } - , releaseCount{ releaseCount_ } - , pReleaseSyncs{ pReleaseSyncs_ } - , pReleaseKeys{ pReleaseKeys_ } - { - } - - VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoKHR( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - Win32KeyedMutexAcquireReleaseInfoKHR( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : Win32KeyedMutexAcquireReleaseInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoKHR( ArrayProxyNoTemporaries const & acquireSyncs_, - ArrayProxyNoTemporaries const & acquireKeys_ = {}, - ArrayProxyNoTemporaries const & acquireTimeouts_ = {}, - ArrayProxyNoTemporaries const & releaseSyncs_ = {}, - ArrayProxyNoTemporaries const & releaseKeys_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , acquireCount( static_cast( acquireSyncs_.size() ) ) - , pAcquireSyncs( acquireSyncs_.data() ) - , pAcquireKeys( acquireKeys_.data() ) - , pAcquireTimeouts( acquireTimeouts_.data() ) - , releaseCount( static_cast( releaseSyncs_.size() ) ) - , pReleaseSyncs( releaseSyncs_.data() ) - , pReleaseKeys( releaseKeys_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( acquireSyncs_.size() == acquireKeys_.size() ); - VULKAN_HPP_ASSERT( acquireSyncs_.size() == acquireTimeouts_.size() ); - VULKAN_HPP_ASSERT( acquireKeys_.size() == acquireTimeouts_.size() ); -# else - if ( acquireSyncs_.size() != acquireKeys_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::Win32KeyedMutexAcquireReleaseInfoKHR::Win32KeyedMutexAcquireReleaseInfoKHR: acquireSyncs_.size() != acquireKeys_.size()" ); - } - if ( acquireSyncs_.size() != acquireTimeouts_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::Win32KeyedMutexAcquireReleaseInfoKHR::Win32KeyedMutexAcquireReleaseInfoKHR: acquireSyncs_.size() != acquireTimeouts_.size()" ); - } - if ( acquireKeys_.size() != acquireTimeouts_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::Win32KeyedMutexAcquireReleaseInfoKHR::Win32KeyedMutexAcquireReleaseInfoKHR: acquireKeys_.size() != acquireTimeouts_.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( releaseSyncs_.size() == releaseKeys_.size() ); -# else - if ( releaseSyncs_.size() != releaseKeys_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::Win32KeyedMutexAcquireReleaseInfoKHR::Win32KeyedMutexAcquireReleaseInfoKHR: releaseSyncs_.size() != releaseKeys_.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Win32KeyedMutexAcquireReleaseInfoKHR & operator=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - Win32KeyedMutexAcquireReleaseInfoKHR & operator=( VkWin32KeyedMutexAcquireReleaseInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireCount( uint32_t acquireCount_ ) & VULKAN_HPP_NOEXCEPT - { - acquireCount = acquireCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setAcquireCount( uint32_t acquireCount_ ) && VULKAN_HPP_NOEXCEPT - { - acquireCount = acquireCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireSyncs( const DeviceMemory * pAcquireSyncs_ ) & VULKAN_HPP_NOEXCEPT - { - pAcquireSyncs = pAcquireSyncs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPAcquireSyncs( const DeviceMemory * pAcquireSyncs_ ) && VULKAN_HPP_NOEXCEPT - { - pAcquireSyncs = pAcquireSyncs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireSyncs( ArrayProxyNoTemporaries const & acquireSyncs_ ) VULKAN_HPP_NOEXCEPT - { - acquireCount = static_cast( acquireSyncs_.size() ); - pAcquireSyncs = acquireSyncs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireKeys( const uint64_t * pAcquireKeys_ ) & VULKAN_HPP_NOEXCEPT - { - pAcquireKeys = pAcquireKeys_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPAcquireKeys( const uint64_t * pAcquireKeys_ ) && VULKAN_HPP_NOEXCEPT - { - pAcquireKeys = pAcquireKeys_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireKeys( ArrayProxyNoTemporaries const & acquireKeys_ ) VULKAN_HPP_NOEXCEPT - { - acquireCount = static_cast( acquireKeys_.size() ); - pAcquireKeys = acquireKeys_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPAcquireTimeouts( const uint32_t * pAcquireTimeouts_ ) & VULKAN_HPP_NOEXCEPT - { - pAcquireTimeouts = pAcquireTimeouts_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPAcquireTimeouts( const uint32_t * pAcquireTimeouts_ ) && VULKAN_HPP_NOEXCEPT - { - pAcquireTimeouts = pAcquireTimeouts_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoKHR & setAcquireTimeouts( ArrayProxyNoTemporaries const & acquireTimeouts_ ) VULKAN_HPP_NOEXCEPT - { - acquireCount = static_cast( acquireTimeouts_.size() ); - pAcquireTimeouts = acquireTimeouts_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setReleaseCount( uint32_t releaseCount_ ) & VULKAN_HPP_NOEXCEPT - { - releaseCount = releaseCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setReleaseCount( uint32_t releaseCount_ ) && VULKAN_HPP_NOEXCEPT - { - releaseCount = releaseCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPReleaseSyncs( const DeviceMemory * pReleaseSyncs_ ) & VULKAN_HPP_NOEXCEPT - { - pReleaseSyncs = pReleaseSyncs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPReleaseSyncs( const DeviceMemory * pReleaseSyncs_ ) && VULKAN_HPP_NOEXCEPT - { - pReleaseSyncs = pReleaseSyncs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoKHR & setReleaseSyncs( ArrayProxyNoTemporaries const & releaseSyncs_ ) VULKAN_HPP_NOEXCEPT - { - releaseCount = static_cast( releaseSyncs_.size() ); - pReleaseSyncs = releaseSyncs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR & setPReleaseKeys( const uint64_t * pReleaseKeys_ ) & VULKAN_HPP_NOEXCEPT - { - pReleaseKeys = pReleaseKeys_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoKHR && setPReleaseKeys( const uint64_t * pReleaseKeys_ ) && VULKAN_HPP_NOEXCEPT - { - pReleaseKeys = pReleaseKeys_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoKHR & setReleaseKeys( ArrayProxyNoTemporaries const & releaseKeys_ ) VULKAN_HPP_NOEXCEPT - { - releaseCount = static_cast( releaseKeys_.size() ); - pReleaseKeys = releaseKeys_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWin32KeyedMutexAcquireReleaseInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWin32KeyedMutexAcquireReleaseInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWin32KeyedMutexAcquireReleaseInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWin32KeyedMutexAcquireReleaseInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, acquireCount, pAcquireSyncs, pAcquireKeys, pAcquireTimeouts, releaseCount, pReleaseSyncs, pReleaseKeys ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( Win32KeyedMutexAcquireReleaseInfoKHR const & ) const = default; -# else - bool operator==( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) && ( pAcquireSyncs == rhs.pAcquireSyncs ) && - ( pAcquireKeys == rhs.pAcquireKeys ) && ( pAcquireTimeouts == rhs.pAcquireTimeouts ) && ( releaseCount == rhs.releaseCount ) && - ( pReleaseSyncs == rhs.pReleaseSyncs ) && ( pReleaseKeys == rhs.pReleaseKeys ); -# endif - } - - bool operator!=( Win32KeyedMutexAcquireReleaseInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR; - const void * pNext = {}; - uint32_t acquireCount = {}; - const DeviceMemory * pAcquireSyncs = {}; - const uint64_t * pAcquireKeys = {}; - const uint32_t * pAcquireTimeouts = {}; - uint32_t releaseCount = {}; - const DeviceMemory * pReleaseSyncs = {}; - const uint64_t * pReleaseKeys = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = Win32KeyedMutexAcquireReleaseInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = Win32KeyedMutexAcquireReleaseInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkWin32KeyedMutexAcquireReleaseInfoNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWin32KeyedMutexAcquireReleaseInfoNV.html - struct Win32KeyedMutexAcquireReleaseInfoNV - { - using NativeType = VkWin32KeyedMutexAcquireReleaseInfoNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( uint32_t acquireCount_ = {}, - const DeviceMemory * pAcquireSyncs_ = {}, - const uint64_t * pAcquireKeys_ = {}, - const uint32_t * pAcquireTimeoutMilliseconds_ = {}, - uint32_t releaseCount_ = {}, - const DeviceMemory * pReleaseSyncs_ = {}, - const uint64_t * pReleaseKeys_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , acquireCount{ acquireCount_ } - , pAcquireSyncs{ pAcquireSyncs_ } - , pAcquireKeys{ pAcquireKeys_ } - , pAcquireTimeoutMilliseconds{ pAcquireTimeoutMilliseconds_ } - , releaseCount{ releaseCount_ } - , pReleaseSyncs{ pReleaseSyncs_ } - , pReleaseKeys{ pReleaseKeys_ } - { - } - - VULKAN_HPP_CONSTEXPR Win32KeyedMutexAcquireReleaseInfoNV( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - Win32KeyedMutexAcquireReleaseInfoNV( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - : Win32KeyedMutexAcquireReleaseInfoNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoNV( ArrayProxyNoTemporaries const & acquireSyncs_, - ArrayProxyNoTemporaries const & acquireKeys_ = {}, - ArrayProxyNoTemporaries const & acquireTimeoutMilliseconds_ = {}, - ArrayProxyNoTemporaries const & releaseSyncs_ = {}, - ArrayProxyNoTemporaries const & releaseKeys_ = {}, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , acquireCount( static_cast( acquireSyncs_.size() ) ) - , pAcquireSyncs( acquireSyncs_.data() ) - , pAcquireKeys( acquireKeys_.data() ) - , pAcquireTimeoutMilliseconds( acquireTimeoutMilliseconds_.data() ) - , releaseCount( static_cast( releaseSyncs_.size() ) ) - , pReleaseSyncs( releaseSyncs_.data() ) - , pReleaseKeys( releaseKeys_.data() ) - { -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( acquireSyncs_.size() == acquireKeys_.size() ); - VULKAN_HPP_ASSERT( acquireSyncs_.size() == acquireTimeoutMilliseconds_.size() ); - VULKAN_HPP_ASSERT( acquireKeys_.size() == acquireTimeoutMilliseconds_.size() ); -# else - if ( acquireSyncs_.size() != acquireKeys_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::Win32KeyedMutexAcquireReleaseInfoNV::Win32KeyedMutexAcquireReleaseInfoNV: acquireSyncs_.size() != acquireKeys_.size()" ); - } - if ( acquireSyncs_.size() != acquireTimeoutMilliseconds_.size() ) - { - throw LogicError( - VULKAN_HPP_NAMESPACE_STRING - "::Win32KeyedMutexAcquireReleaseInfoNV::Win32KeyedMutexAcquireReleaseInfoNV: acquireSyncs_.size() != acquireTimeoutMilliseconds_.size()" ); - } - if ( acquireKeys_.size() != acquireTimeoutMilliseconds_.size() ) - { - throw LogicError( - VULKAN_HPP_NAMESPACE_STRING - "::Win32KeyedMutexAcquireReleaseInfoNV::Win32KeyedMutexAcquireReleaseInfoNV: acquireKeys_.size() != acquireTimeoutMilliseconds_.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - -# ifdef VULKAN_HPP_NO_EXCEPTIONS - VULKAN_HPP_ASSERT( releaseSyncs_.size() == releaseKeys_.size() ); -# else - if ( releaseSyncs_.size() != releaseKeys_.size() ) - { - throw LogicError( VULKAN_HPP_NAMESPACE_STRING - "::Win32KeyedMutexAcquireReleaseInfoNV::Win32KeyedMutexAcquireReleaseInfoNV: releaseSyncs_.size() != releaseKeys_.size()" ); - } -# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - Win32KeyedMutexAcquireReleaseInfoNV & operator=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - Win32KeyedMutexAcquireReleaseInfoNV & operator=( VkWin32KeyedMutexAcquireReleaseInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setAcquireCount( uint32_t acquireCount_ ) & VULKAN_HPP_NOEXCEPT - { - acquireCount = acquireCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setAcquireCount( uint32_t acquireCount_ ) && VULKAN_HPP_NOEXCEPT - { - acquireCount = acquireCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireSyncs( const DeviceMemory * pAcquireSyncs_ ) & VULKAN_HPP_NOEXCEPT - { - pAcquireSyncs = pAcquireSyncs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPAcquireSyncs( const DeviceMemory * pAcquireSyncs_ ) && VULKAN_HPP_NOEXCEPT - { - pAcquireSyncs = pAcquireSyncs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoNV & setAcquireSyncs( ArrayProxyNoTemporaries const & acquireSyncs_ ) VULKAN_HPP_NOEXCEPT - { - acquireCount = static_cast( acquireSyncs_.size() ); - pAcquireSyncs = acquireSyncs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireKeys( const uint64_t * pAcquireKeys_ ) & VULKAN_HPP_NOEXCEPT - { - pAcquireKeys = pAcquireKeys_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPAcquireKeys( const uint64_t * pAcquireKeys_ ) && VULKAN_HPP_NOEXCEPT - { - pAcquireKeys = pAcquireKeys_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoNV & setAcquireKeys( ArrayProxyNoTemporaries const & acquireKeys_ ) VULKAN_HPP_NOEXCEPT - { - acquireCount = static_cast( acquireKeys_.size() ); - pAcquireKeys = acquireKeys_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPAcquireTimeoutMilliseconds( const uint32_t * pAcquireTimeoutMilliseconds_ ) & - VULKAN_HPP_NOEXCEPT - { - pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPAcquireTimeoutMilliseconds( const uint32_t * pAcquireTimeoutMilliseconds_ ) && - VULKAN_HPP_NOEXCEPT - { - pAcquireTimeoutMilliseconds = pAcquireTimeoutMilliseconds_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoNV & - setAcquireTimeoutMilliseconds( ArrayProxyNoTemporaries const & acquireTimeoutMilliseconds_ ) VULKAN_HPP_NOEXCEPT - { - acquireCount = static_cast( acquireTimeoutMilliseconds_.size() ); - pAcquireTimeoutMilliseconds = acquireTimeoutMilliseconds_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setReleaseCount( uint32_t releaseCount_ ) & VULKAN_HPP_NOEXCEPT - { - releaseCount = releaseCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setReleaseCount( uint32_t releaseCount_ ) && VULKAN_HPP_NOEXCEPT - { - releaseCount = releaseCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPReleaseSyncs( const DeviceMemory * pReleaseSyncs_ ) & VULKAN_HPP_NOEXCEPT - { - pReleaseSyncs = pReleaseSyncs_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPReleaseSyncs( const DeviceMemory * pReleaseSyncs_ ) && VULKAN_HPP_NOEXCEPT - { - pReleaseSyncs = pReleaseSyncs_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoNV & setReleaseSyncs( ArrayProxyNoTemporaries const & releaseSyncs_ ) VULKAN_HPP_NOEXCEPT - { - releaseCount = static_cast( releaseSyncs_.size() ); - pReleaseSyncs = releaseSyncs_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV & setPReleaseKeys( const uint64_t * pReleaseKeys_ ) & VULKAN_HPP_NOEXCEPT - { - pReleaseKeys = pReleaseKeys_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32KeyedMutexAcquireReleaseInfoNV && setPReleaseKeys( const uint64_t * pReleaseKeys_ ) && VULKAN_HPP_NOEXCEPT - { - pReleaseKeys = pReleaseKeys_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - Win32KeyedMutexAcquireReleaseInfoNV & setReleaseKeys( ArrayProxyNoTemporaries const & releaseKeys_ ) VULKAN_HPP_NOEXCEPT - { - releaseCount = static_cast( releaseKeys_.size() ); - pReleaseKeys = releaseKeys_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWin32KeyedMutexAcquireReleaseInfoNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWin32KeyedMutexAcquireReleaseInfoNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWin32KeyedMutexAcquireReleaseInfoNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWin32KeyedMutexAcquireReleaseInfoNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, acquireCount, pAcquireSyncs, pAcquireKeys, pAcquireTimeoutMilliseconds, releaseCount, pReleaseSyncs, pReleaseKeys ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( Win32KeyedMutexAcquireReleaseInfoNV const & ) const = default; -# else - bool operator==( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( acquireCount == rhs.acquireCount ) && ( pAcquireSyncs == rhs.pAcquireSyncs ) && - ( pAcquireKeys == rhs.pAcquireKeys ) && ( pAcquireTimeoutMilliseconds == rhs.pAcquireTimeoutMilliseconds ) && - ( releaseCount == rhs.releaseCount ) && ( pReleaseSyncs == rhs.pReleaseSyncs ) && ( pReleaseKeys == rhs.pReleaseKeys ); -# endif - } - - bool operator!=( Win32KeyedMutexAcquireReleaseInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eWin32KeyedMutexAcquireReleaseInfoNV; - const void * pNext = {}; - uint32_t acquireCount = {}; - const DeviceMemory * pAcquireSyncs = {}; - const uint64_t * pAcquireKeys = {}; - const uint32_t * pAcquireTimeoutMilliseconds = {}; - uint32_t releaseCount = {}; - const DeviceMemory * pReleaseSyncs = {}; - const uint64_t * pReleaseKeys = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = Win32KeyedMutexAcquireReleaseInfoNV; - }; -# endif - - template <> - struct CppType - { - using Type = Win32KeyedMutexAcquireReleaseInfoNV; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - // wrapper struct for struct VkWin32SurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWin32SurfaceCreateInfoKHR.html - struct Win32SurfaceCreateInfoKHR - { - using NativeType = VkWin32SurfaceCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWin32SurfaceCreateInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( Win32SurfaceCreateFlagsKHR flags_ = {}, - HINSTANCE hinstance_ = {}, - HWND hwnd_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , hinstance{ hinstance_ } - , hwnd{ hwnd_ } - { - } - - VULKAN_HPP_CONSTEXPR Win32SurfaceCreateInfoKHR( Win32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - Win32SurfaceCreateInfoKHR( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : Win32SurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - Win32SurfaceCreateInfoKHR & operator=( Win32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - Win32SurfaceCreateInfoKHR & operator=( VkWin32SurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR & setFlags( Win32SurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR && setFlags( Win32SurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR & setHinstance( HINSTANCE hinstance_ ) & VULKAN_HPP_NOEXCEPT - { - hinstance = hinstance_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR && setHinstance( HINSTANCE hinstance_ ) && VULKAN_HPP_NOEXCEPT - { - hinstance = hinstance_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR & setHwnd( HWND hwnd_ ) & VULKAN_HPP_NOEXCEPT - { - hwnd = hwnd_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 Win32SurfaceCreateInfoKHR && setHwnd( HWND hwnd_ ) && VULKAN_HPP_NOEXCEPT - { - hwnd = hwnd_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWin32SurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWin32SurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWin32SurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWin32SurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, hinstance, hwnd ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( Win32SurfaceCreateInfoKHR const & ) const = default; -# else - bool operator==( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( hinstance == rhs.hinstance ) && ( hwnd == rhs.hwnd ); -# endif - } - - bool operator!=( Win32SurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -# endif - - public: - StructureType sType = StructureType::eWin32SurfaceCreateInfoKHR; - const void * pNext = {}; - Win32SurfaceCreateFlagsKHR flags = {}; - HINSTANCE hinstance = {}; - HWND hwnd = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = Win32SurfaceCreateInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = Win32SurfaceCreateInfoKHR; - }; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - // wrapper struct for struct VkWriteDescriptorSetAccelerationStructureKHR, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSetAccelerationStructureKHR.html - struct WriteDescriptorSetAccelerationStructureKHR - { - using NativeType = VkWriteDescriptorSetAccelerationStructureKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetAccelerationStructureKHR; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureKHR( uint32_t accelerationStructureCount_ = {}, - const AccelerationStructureKHR * pAccelerationStructures_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , accelerationStructureCount{ accelerationStructureCount_ } - , pAccelerationStructures{ pAccelerationStructures_ } - { - } - - VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureKHR( WriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - WriteDescriptorSetAccelerationStructureKHR( VkWriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : WriteDescriptorSetAccelerationStructureKHR( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSetAccelerationStructureKHR( ArrayProxyNoTemporaries const & accelerationStructures_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , accelerationStructureCount( static_cast( accelerationStructures_.size() ) ) - , pAccelerationStructures( accelerationStructures_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - WriteDescriptorSetAccelerationStructureKHR & operator=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - WriteDescriptorSetAccelerationStructureKHR & operator=( VkWriteDescriptorSetAccelerationStructureKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR & setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructureCount = accelerationStructureCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR && setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructureCount = accelerationStructureCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR & - setPAccelerationStructures( const AccelerationStructureKHR * pAccelerationStructures_ ) & - VULKAN_HPP_NOEXCEPT - { - pAccelerationStructures = pAccelerationStructures_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureKHR && - setPAccelerationStructures( const AccelerationStructureKHR * pAccelerationStructures_ ) && - VULKAN_HPP_NOEXCEPT - { - pAccelerationStructures = pAccelerationStructures_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSetAccelerationStructureKHR & - setAccelerationStructures( ArrayProxyNoTemporaries const & accelerationStructures_ ) VULKAN_HPP_NOEXCEPT - { - accelerationStructureCount = static_cast( accelerationStructures_.size() ); - pAccelerationStructures = accelerationStructures_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWriteDescriptorSetAccelerationStructureKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetAccelerationStructureKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetAccelerationStructureKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetAccelerationStructureKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( WriteDescriptorSetAccelerationStructureKHR const & ) const = default; -#else - bool operator==( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureCount == rhs.accelerationStructureCount ) && - ( pAccelerationStructures == rhs.pAccelerationStructures ); -# endif - } - - bool operator!=( WriteDescriptorSetAccelerationStructureKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureKHR; - const void * pNext = {}; - uint32_t accelerationStructureCount = {}; - const AccelerationStructureKHR * pAccelerationStructures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = WriteDescriptorSetAccelerationStructureKHR; - }; -#endif - - template <> - struct CppType - { - using Type = WriteDescriptorSetAccelerationStructureKHR; - }; - - // wrapper struct for struct VkWriteDescriptorSetAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSetAccelerationStructureNV.html - struct WriteDescriptorSetAccelerationStructureNV - { - using NativeType = VkWriteDescriptorSetAccelerationStructureNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetAccelerationStructureNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( uint32_t accelerationStructureCount_ = {}, - const AccelerationStructureNV * pAccelerationStructures_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , accelerationStructureCount{ accelerationStructureCount_ } - , pAccelerationStructures{ pAccelerationStructures_ } - { - } - - VULKAN_HPP_CONSTEXPR WriteDescriptorSetAccelerationStructureNV( WriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - WriteDescriptorSetAccelerationStructureNV( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT - : WriteDescriptorSetAccelerationStructureNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSetAccelerationStructureNV( ArrayProxyNoTemporaries const & accelerationStructures_, - const void * pNext_ = nullptr ) - : pNext( pNext_ ) - , accelerationStructureCount( static_cast( accelerationStructures_.size() ) ) - , pAccelerationStructures( accelerationStructures_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - WriteDescriptorSetAccelerationStructureNV & operator=( WriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - WriteDescriptorSetAccelerationStructureNV & operator=( VkWriteDescriptorSetAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV & setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructureCount = accelerationStructureCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV && setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructureCount = accelerationStructureCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV & setPAccelerationStructures( const AccelerationStructureNV * pAccelerationStructures_ ) & - VULKAN_HPP_NOEXCEPT - { - pAccelerationStructures = pAccelerationStructures_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetAccelerationStructureNV && - setPAccelerationStructures( const AccelerationStructureNV * pAccelerationStructures_ ) && - VULKAN_HPP_NOEXCEPT - { - pAccelerationStructures = pAccelerationStructures_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSetAccelerationStructureNV & - setAccelerationStructures( ArrayProxyNoTemporaries const & accelerationStructures_ ) VULKAN_HPP_NOEXCEPT - { - accelerationStructureCount = static_cast( accelerationStructures_.size() ); - pAccelerationStructures = accelerationStructures_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWriteDescriptorSetAccelerationStructureNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetAccelerationStructureNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetAccelerationStructureNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetAccelerationStructureNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( WriteDescriptorSetAccelerationStructureNV const & ) const = default; -#else - bool operator==( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureCount == rhs.accelerationStructureCount ) && - ( pAccelerationStructures == rhs.pAccelerationStructures ); -# endif - } - - bool operator!=( WriteDescriptorSetAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eWriteDescriptorSetAccelerationStructureNV; - const void * pNext = {}; - uint32_t accelerationStructureCount = {}; - const AccelerationStructureNV * pAccelerationStructures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = WriteDescriptorSetAccelerationStructureNV; - }; -#endif - - template <> - struct CppType - { - using Type = WriteDescriptorSetAccelerationStructureNV; - }; - - // wrapper struct for struct VkWriteDescriptorSetInlineUniformBlock, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSetInlineUniformBlock.html - struct WriteDescriptorSetInlineUniformBlock - { - using NativeType = VkWriteDescriptorSetInlineUniformBlock; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetInlineUniformBlock; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - WriteDescriptorSetInlineUniformBlock( uint32_t dataSize_ = {}, const void * pData_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , dataSize{ dataSize_ } - , pData{ pData_ } - { - } - - VULKAN_HPP_CONSTEXPR WriteDescriptorSetInlineUniformBlock( WriteDescriptorSetInlineUniformBlock const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - WriteDescriptorSetInlineUniformBlock( VkWriteDescriptorSetInlineUniformBlock const & rhs ) VULKAN_HPP_NOEXCEPT - : WriteDescriptorSetInlineUniformBlock( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - WriteDescriptorSetInlineUniformBlock( ArrayProxyNoTemporaries const & data_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), dataSize( static_cast( data_.size() * sizeof( T ) ) ), pData( data_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - WriteDescriptorSetInlineUniformBlock & operator=( WriteDescriptorSetInlineUniformBlock const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - WriteDescriptorSetInlineUniformBlock & operator=( VkWriteDescriptorSetInlineUniformBlock const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock & setDataSize( uint32_t dataSize_ ) & VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock && setDataSize( uint32_t dataSize_ ) && VULKAN_HPP_NOEXCEPT - { - dataSize = dataSize_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock & setPData( const void * pData_ ) & VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetInlineUniformBlock && setPData( const void * pData_ ) && VULKAN_HPP_NOEXCEPT - { - pData = pData_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - template - WriteDescriptorSetInlineUniformBlock & setData( ArrayProxyNoTemporaries const & data_ ) VULKAN_HPP_NOEXCEPT - { - dataSize = static_cast( data_.size() * sizeof( T ) ); - pData = data_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWriteDescriptorSetInlineUniformBlock const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetInlineUniformBlock &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetInlineUniformBlock const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetInlineUniformBlock *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, dataSize, pData ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( WriteDescriptorSetInlineUniformBlock const & ) const = default; -#else - bool operator==( WriteDescriptorSetInlineUniformBlock const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( dataSize == rhs.dataSize ) && ( pData == rhs.pData ); -# endif - } - - bool operator!=( WriteDescriptorSetInlineUniformBlock const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eWriteDescriptorSetInlineUniformBlock; - const void * pNext = {}; - uint32_t dataSize = {}; - const void * pData = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = WriteDescriptorSetInlineUniformBlock; - }; -#endif - - template <> - struct CppType - { - using Type = WriteDescriptorSetInlineUniformBlock; - }; - - using WriteDescriptorSetInlineUniformBlockEXT = WriteDescriptorSetInlineUniformBlock; - - // wrapper struct for struct VkWriteDescriptorSetPartitionedAccelerationStructureNV, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSetPartitionedAccelerationStructureNV.html - struct WriteDescriptorSetPartitionedAccelerationStructureNV - { - using NativeType = VkWriteDescriptorSetPartitionedAccelerationStructureNV; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetPartitionedAccelerationStructureNV; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR WriteDescriptorSetPartitionedAccelerationStructureNV( uint32_t accelerationStructureCount_ = {}, - const DeviceAddress * pAccelerationStructures_ = {}, - void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , accelerationStructureCount{ accelerationStructureCount_ } - , pAccelerationStructures{ pAccelerationStructures_ } - { - } - - VULKAN_HPP_CONSTEXPR - WriteDescriptorSetPartitionedAccelerationStructureNV( WriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - WriteDescriptorSetPartitionedAccelerationStructureNV( VkWriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT - : WriteDescriptorSetPartitionedAccelerationStructureNV( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSetPartitionedAccelerationStructureNV( ArrayProxyNoTemporaries const & accelerationStructures_, - void * pNext_ = nullptr ) - : pNext( pNext_ ) - , accelerationStructureCount( static_cast( accelerationStructures_.size() ) ) - , pAccelerationStructures( accelerationStructures_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - WriteDescriptorSetPartitionedAccelerationStructureNV & - operator=( WriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - WriteDescriptorSetPartitionedAccelerationStructureNV & operator=( VkWriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV & setPNext( void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV && setPNext( void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV & setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) & - VULKAN_HPP_NOEXCEPT - { - accelerationStructureCount = accelerationStructureCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV && setAccelerationStructureCount( uint32_t accelerationStructureCount_ ) && - VULKAN_HPP_NOEXCEPT - { - accelerationStructureCount = accelerationStructureCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV & - setPAccelerationStructures( const DeviceAddress * pAccelerationStructures_ ) & - VULKAN_HPP_NOEXCEPT - { - pAccelerationStructures = pAccelerationStructures_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetPartitionedAccelerationStructureNV && - setPAccelerationStructures( const DeviceAddress * pAccelerationStructures_ ) && - VULKAN_HPP_NOEXCEPT - { - pAccelerationStructures = pAccelerationStructures_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSetPartitionedAccelerationStructureNV & - setAccelerationStructures( ArrayProxyNoTemporaries const & accelerationStructures_ ) VULKAN_HPP_NOEXCEPT - { - accelerationStructureCount = static_cast( accelerationStructures_.size() ); - pAccelerationStructures = accelerationStructures_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWriteDescriptorSetPartitionedAccelerationStructureNV const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetPartitionedAccelerationStructureNV &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetPartitionedAccelerationStructureNV const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetPartitionedAccelerationStructureNV *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, accelerationStructureCount, pAccelerationStructures ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( WriteDescriptorSetPartitionedAccelerationStructureNV const & ) const = default; -#else - bool operator==( WriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( accelerationStructureCount == rhs.accelerationStructureCount ) && - ( pAccelerationStructures == rhs.pAccelerationStructures ); -# endif - } - - bool operator!=( WriteDescriptorSetPartitionedAccelerationStructureNV const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eWriteDescriptorSetPartitionedAccelerationStructureNV; - void * pNext = {}; - uint32_t accelerationStructureCount = {}; - const DeviceAddress * pAccelerationStructures = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = WriteDescriptorSetPartitionedAccelerationStructureNV; - }; -#endif - - template <> - struct CppType - { - using Type = WriteDescriptorSetPartitionedAccelerationStructureNV; - }; - - // wrapper struct for struct VkWriteDescriptorSetTensorARM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteDescriptorSetTensorARM.html - struct WriteDescriptorSetTensorARM - { - using NativeType = VkWriteDescriptorSetTensorARM; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteDescriptorSetTensorARM; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - WriteDescriptorSetTensorARM( uint32_t tensorViewCount_ = {}, const TensorViewARM * pTensorViews_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , tensorViewCount{ tensorViewCount_ } - , pTensorViews{ pTensorViews_ } - { - } - - VULKAN_HPP_CONSTEXPR WriteDescriptorSetTensorARM( WriteDescriptorSetTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - WriteDescriptorSetTensorARM( VkWriteDescriptorSetTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT - : WriteDescriptorSetTensorARM( *reinterpret_cast( &rhs ) ) - { - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSetTensorARM( ArrayProxyNoTemporaries const & tensorViews_, const void * pNext_ = nullptr ) - : pNext( pNext_ ), tensorViewCount( static_cast( tensorViews_.size() ) ), pTensorViews( tensorViews_.data() ) - { - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ - - WriteDescriptorSetTensorARM & operator=( WriteDescriptorSetTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - WriteDescriptorSetTensorARM & operator=( VkWriteDescriptorSetTensorARM const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM & setTensorViewCount( uint32_t tensorViewCount_ ) & VULKAN_HPP_NOEXCEPT - { - tensorViewCount = tensorViewCount_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM && setTensorViewCount( uint32_t tensorViewCount_ ) && VULKAN_HPP_NOEXCEPT - { - tensorViewCount = tensorViewCount_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM & setPTensorViews( const TensorViewARM * pTensorViews_ ) & VULKAN_HPP_NOEXCEPT - { - pTensorViews = pTensorViews_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteDescriptorSetTensorARM && setPTensorViews( const TensorViewARM * pTensorViews_ ) && VULKAN_HPP_NOEXCEPT - { - pTensorViews = pTensorViews_; - return std::move( *this ); - } - -# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) - WriteDescriptorSetTensorARM & setTensorViews( ArrayProxyNoTemporaries const & tensorViews_ ) VULKAN_HPP_NOEXCEPT - { - tensorViewCount = static_cast( tensorViews_.size() ); - pTensorViews = tensorViews_.data(); - return *this; - } -# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWriteDescriptorSetTensorARM const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetTensorARM &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetTensorARM const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWriteDescriptorSetTensorARM *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, tensorViewCount, pTensorViews ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( WriteDescriptorSetTensorARM const & ) const = default; -#else - bool operator==( WriteDescriptorSetTensorARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tensorViewCount == rhs.tensorViewCount ) && ( pTensorViews == rhs.pTensorViews ); -# endif - } - - bool operator!=( WriteDescriptorSetTensorARM const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eWriteDescriptorSetTensorARM; - const void * pNext = {}; - uint32_t tensorViewCount = {}; - const TensorViewARM * pTensorViews = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = WriteDescriptorSetTensorARM; - }; -#endif - - template <> - struct CppType - { - using Type = WriteDescriptorSetTensorARM; - }; - - // wrapper struct for struct VkWriteIndirectExecutionSetPipelineEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteIndirectExecutionSetPipelineEXT.html - struct WriteIndirectExecutionSetPipelineEXT - { - using NativeType = VkWriteIndirectExecutionSetPipelineEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteIndirectExecutionSetPipelineEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR - WriteIndirectExecutionSetPipelineEXT( uint32_t index_ = {}, Pipeline pipeline_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , index{ index_ } - , pipeline{ pipeline_ } - { - } - - VULKAN_HPP_CONSTEXPR WriteIndirectExecutionSetPipelineEXT( WriteIndirectExecutionSetPipelineEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - WriteIndirectExecutionSetPipelineEXT( VkWriteIndirectExecutionSetPipelineEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : WriteIndirectExecutionSetPipelineEXT( *reinterpret_cast( &rhs ) ) - { - } - - WriteIndirectExecutionSetPipelineEXT & operator=( WriteIndirectExecutionSetPipelineEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - WriteIndirectExecutionSetPipelineEXT & operator=( VkWriteIndirectExecutionSetPipelineEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT - { - index = index_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT - { - index = index_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT & setPipeline( Pipeline pipeline_ ) & VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetPipelineEXT && setPipeline( Pipeline pipeline_ ) && VULKAN_HPP_NOEXCEPT - { - pipeline = pipeline_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWriteIndirectExecutionSetPipelineEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteIndirectExecutionSetPipelineEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteIndirectExecutionSetPipelineEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWriteIndirectExecutionSetPipelineEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, index, pipeline ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( WriteIndirectExecutionSetPipelineEXT const & ) const = default; -#else - bool operator==( WriteIndirectExecutionSetPipelineEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( index == rhs.index ) && ( pipeline == rhs.pipeline ); -# endif - } - - bool operator!=( WriteIndirectExecutionSetPipelineEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eWriteIndirectExecutionSetPipelineEXT; - const void * pNext = {}; - uint32_t index = {}; - Pipeline pipeline = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = WriteIndirectExecutionSetPipelineEXT; - }; -#endif - - template <> - struct CppType - { - using Type = WriteIndirectExecutionSetPipelineEXT; - }; - - // wrapper struct for struct VkWriteIndirectExecutionSetShaderEXT, see - // https://registry.khronos.org/vulkan/specs/latest/man/html/VkWriteIndirectExecutionSetShaderEXT.html - struct WriteIndirectExecutionSetShaderEXT - { - using NativeType = VkWriteIndirectExecutionSetShaderEXT; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eWriteIndirectExecutionSetShaderEXT; - -#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR WriteIndirectExecutionSetShaderEXT( uint32_t index_ = {}, ShaderEXT shader_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , index{ index_ } - , shader{ shader_ } - { - } - - VULKAN_HPP_CONSTEXPR WriteIndirectExecutionSetShaderEXT( WriteIndirectExecutionSetShaderEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - WriteIndirectExecutionSetShaderEXT( VkWriteIndirectExecutionSetShaderEXT const & rhs ) VULKAN_HPP_NOEXCEPT - : WriteIndirectExecutionSetShaderEXT( *reinterpret_cast( &rhs ) ) - { - } - - WriteIndirectExecutionSetShaderEXT & operator=( WriteIndirectExecutionSetShaderEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; -#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - WriteIndirectExecutionSetShaderEXT & operator=( VkWriteIndirectExecutionSetShaderEXT const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT & setIndex( uint32_t index_ ) & VULKAN_HPP_NOEXCEPT - { - index = index_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT && setIndex( uint32_t index_ ) && VULKAN_HPP_NOEXCEPT - { - index = index_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT & setShader( ShaderEXT shader_ ) & VULKAN_HPP_NOEXCEPT - { - shader = shader_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 WriteIndirectExecutionSetShaderEXT && setShader( ShaderEXT shader_ ) && VULKAN_HPP_NOEXCEPT - { - shader = shader_; - return std::move( *this ); - } -#endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkWriteIndirectExecutionSetShaderEXT const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteIndirectExecutionSetShaderEXT &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkWriteIndirectExecutionSetShaderEXT const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkWriteIndirectExecutionSetShaderEXT *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -#if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, index, shader ); - } -#endif - -#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - auto operator<=>( WriteIndirectExecutionSetShaderEXT const & ) const = default; -#else - bool operator==( WriteIndirectExecutionSetShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { -# if defined( VULKAN_HPP_USE_REFLECT ) - return this->reflect() == rhs.reflect(); -# else - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( index == rhs.index ) && ( shader == rhs.shader ); -# endif - } - - bool operator!=( WriteIndirectExecutionSetShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } -#endif - - public: - StructureType sType = StructureType::eWriteIndirectExecutionSetShaderEXT; - const void * pNext = {}; - uint32_t index = {}; - ShaderEXT shader = {}; - }; - -#if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = WriteIndirectExecutionSetShaderEXT; - }; -#endif - - template <> - struct CppType - { - using Type = WriteIndirectExecutionSetShaderEXT; - }; - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - // wrapper struct for struct VkXcbSurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXcbSurfaceCreateInfoKHR.html - struct XcbSurfaceCreateInfoKHR - { - using NativeType = VkXcbSurfaceCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eXcbSurfaceCreateInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( XcbSurfaceCreateFlagsKHR flags_ = {}, - xcb_connection_t * connection_ = {}, - xcb_window_t window_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , connection{ connection_ } - , window{ window_ } - { - } - - VULKAN_HPP_CONSTEXPR XcbSurfaceCreateInfoKHR( XcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - XcbSurfaceCreateInfoKHR( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : XcbSurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - XcbSurfaceCreateInfoKHR & operator=( XcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - XcbSurfaceCreateInfoKHR & operator=( VkXcbSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR & setFlags( XcbSurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR && setFlags( XcbSurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR & setConnection( xcb_connection_t * connection_ ) & VULKAN_HPP_NOEXCEPT - { - connection = connection_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR && setConnection( xcb_connection_t * connection_ ) && VULKAN_HPP_NOEXCEPT - { - connection = connection_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR & setWindow( xcb_window_t window_ ) & VULKAN_HPP_NOEXCEPT - { - window = window_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 XcbSurfaceCreateInfoKHR && setWindow( xcb_window_t window_ ) && VULKAN_HPP_NOEXCEPT - { - window = window_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkXcbSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkXcbSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkXcbSurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkXcbSurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, connection, window ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = connection <=> rhs.connection; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &window, &rhs.window, sizeof( xcb_window_t ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -# endif - - bool operator==( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( connection == rhs.connection ) && - ( memcmp( &window, &rhs.window, sizeof( xcb_window_t ) ) == 0 ); - } - - bool operator!=( XcbSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eXcbSurfaceCreateInfoKHR; - const void * pNext = {}; - XcbSurfaceCreateFlagsKHR flags = {}; - xcb_connection_t * connection = {}; - xcb_window_t window = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = XcbSurfaceCreateInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = XcbSurfaceCreateInfoKHR; - }; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - // wrapper struct for struct VkXlibSurfaceCreateInfoKHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkXlibSurfaceCreateInfoKHR.html - struct XlibSurfaceCreateInfoKHR - { - using NativeType = VkXlibSurfaceCreateInfoKHR; - - static const bool allowDuplicate = false; - static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eXlibSurfaceCreateInfoKHR; - -# if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) - VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( XlibSurfaceCreateFlagsKHR flags_ = {}, - Display * dpy_ = {}, - Window window_ = {}, - const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT - : pNext{ pNext_ } - , flags{ flags_ } - , dpy{ dpy_ } - , window{ window_ } - { - } - - VULKAN_HPP_CONSTEXPR XlibSurfaceCreateInfoKHR( XlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; - - XlibSurfaceCreateInfoKHR( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - : XlibSurfaceCreateInfoKHR( *reinterpret_cast( &rhs ) ) - { - } - - XlibSurfaceCreateInfoKHR & operator=( XlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT = default; -# endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ - - XlibSurfaceCreateInfoKHR & operator=( VkXlibSurfaceCreateInfoKHR const & rhs ) VULKAN_HPP_NOEXCEPT - { - *this = *reinterpret_cast( &rhs ); - return *this; - } - -# if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) - VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR & setPNext( const void * pNext_ ) & VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR && setPNext( const void * pNext_ ) && VULKAN_HPP_NOEXCEPT - { - pNext = pNext_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR & setFlags( XlibSurfaceCreateFlagsKHR flags_ ) & VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR && setFlags( XlibSurfaceCreateFlagsKHR flags_ ) && VULKAN_HPP_NOEXCEPT - { - flags = flags_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR & setDpy( Display * dpy_ ) & VULKAN_HPP_NOEXCEPT - { - dpy = dpy_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR && setDpy( Display * dpy_ ) && VULKAN_HPP_NOEXCEPT - { - dpy = dpy_; - return std::move( *this ); - } - - VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR & setWindow( Window window_ ) & VULKAN_HPP_NOEXCEPT - { - window = window_; - return *this; - } - - VULKAN_HPP_CONSTEXPR_14 XlibSurfaceCreateInfoKHR && setWindow( Window window_ ) && VULKAN_HPP_NOEXCEPT - { - window = window_; - return std::move( *this ); - } -# endif /*VULKAN_HPP_NO_SETTERS*/ - - operator VkXlibSurfaceCreateInfoKHR const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkXlibSurfaceCreateInfoKHR &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator VkXlibSurfaceCreateInfoKHR const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator VkXlibSurfaceCreateInfoKHR *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - -# if defined( VULKAN_HPP_USE_REFLECT ) - std::tuple - reflect() const VULKAN_HPP_NOEXCEPT - { - return std::tie( sType, pNext, flags, dpy, window ); - } -# endif - -# if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) - std::strong_ordering operator<=>( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) - return cmp; - if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) - return cmp; - if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) - return cmp; - if ( auto cmp = dpy <=> rhs.dpy; cmp != 0 ) - return cmp; - if ( auto cmp = memcmp( &window, &rhs.window, sizeof( Window ) ); cmp != 0 ) - return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; - - return std::strong_ordering::equivalent; - } -# endif - - bool operator==( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( dpy == rhs.dpy ) && - ( memcmp( &window, &rhs.window, sizeof( Window ) ) == 0 ); - } - - bool operator!=( XlibSurfaceCreateInfoKHR const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - StructureType sType = StructureType::eXlibSurfaceCreateInfoKHR; - const void * pNext = {}; - XlibSurfaceCreateFlagsKHR flags = {}; - Display * dpy = {}; - Window window = {}; - }; - -# if 20 <= VULKAN_HPP_CPP_VERSION - template <> - struct CppType - { - using Type = XlibSurfaceCreateInfoKHR; - }; -# endif - - template <> - struct CppType - { - using Type = XlibSurfaceCreateInfoKHR; - }; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -} // namespace VULKAN_HPP_NAMESPACE -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_to_string.hpp b/lib/vulkan-headers/include/vulkan/vulkan_to_string.hpp deleted file mode 100644 index c14d520fa3a..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_to_string.hpp +++ /dev/null @@ -1,11091 +0,0 @@ -// Copyright 2015-2026 The Khronos Group Inc. -// -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_TO_STRING_HPP -#define VULKAN_TO_STRING_HPP - -#if !defined( VULKAN_HPP_CXX_MODULE ) -# include -#endif - -// ignore warnings on using deprecated enum values in this header -#if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wdeprecated-declarations" -#elif defined( _MSC_VER ) -# pragma warning( push ) -# pragma warning( disable : 4996 ) -#endif - -#if !defined( VULKAN_HPP_CXX_MODULE ) -# if defined( __cpp_lib_format ) -# include // std::format -# else -# include // std::stringstream -# endif -#endif - -namespace VULKAN_HPP_NAMESPACE -{ - - //========================== - //=== BITMASKs to_string === - //========================== - - //=== VK_VERSION_1_0 === - - VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags value ) - { - std::string result = "{"; - if ( value & FormatFeatureFlagBits::eSampledImage ) - result += " SampledImage |"; - if ( value & FormatFeatureFlagBits::eStorageImage ) - result += " StorageImage |"; - if ( value & FormatFeatureFlagBits::eStorageImageAtomic ) - result += " StorageImageAtomic |"; - if ( value & FormatFeatureFlagBits::eUniformTexelBuffer ) - result += " UniformTexelBuffer |"; - if ( value & FormatFeatureFlagBits::eStorageTexelBuffer ) - result += " StorageTexelBuffer |"; - if ( value & FormatFeatureFlagBits::eStorageTexelBufferAtomic ) - result += " StorageTexelBufferAtomic |"; - if ( value & FormatFeatureFlagBits::eVertexBuffer ) - result += " VertexBuffer |"; - if ( value & FormatFeatureFlagBits::eColorAttachment ) - result += " ColorAttachment |"; - if ( value & FormatFeatureFlagBits::eColorAttachmentBlend ) - result += " ColorAttachmentBlend |"; - if ( value & FormatFeatureFlagBits::eDepthStencilAttachment ) - result += " DepthStencilAttachment |"; - if ( value & FormatFeatureFlagBits::eBlitSrc ) - result += " BlitSrc |"; - if ( value & FormatFeatureFlagBits::eBlitDst ) - result += " BlitDst |"; - if ( value & FormatFeatureFlagBits::eSampledImageFilterLinear ) - result += " SampledImageFilterLinear |"; - if ( value & FormatFeatureFlagBits::eTransferSrc ) - result += " TransferSrc |"; - if ( value & FormatFeatureFlagBits::eTransferDst ) - result += " TransferDst |"; - if ( value & FormatFeatureFlagBits::eMidpointChromaSamples ) - result += " MidpointChromaSamples |"; - if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter ) - result += " SampledImageYcbcrConversionLinearFilter |"; - if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter ) - result += " SampledImageYcbcrConversionSeparateReconstructionFilter |"; - if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit ) - result += " SampledImageYcbcrConversionChromaReconstructionExplicit |"; - if ( value & FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable ) - result += " SampledImageYcbcrConversionChromaReconstructionExplicitForceable |"; - if ( value & FormatFeatureFlagBits::eDisjoint ) - result += " Disjoint |"; - if ( value & FormatFeatureFlagBits::eCositedChromaSamples ) - result += " CositedChromaSamples |"; - if ( value & FormatFeatureFlagBits::eSampledImageFilterMinmax ) - result += " SampledImageFilterMinmax |"; - if ( value & FormatFeatureFlagBits::eVideoDecodeOutputKHR ) - result += " VideoDecodeOutputKHR |"; - if ( value & FormatFeatureFlagBits::eVideoDecodeDpbKHR ) - result += " VideoDecodeDpbKHR |"; - if ( value & FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR ) - result += " AccelerationStructureVertexBufferKHR |"; - if ( value & FormatFeatureFlagBits::eSampledImageFilterCubicEXT ) - result += " SampledImageFilterCubicEXT |"; - if ( value & FormatFeatureFlagBits::eFragmentDensityMapEXT ) - result += " FragmentDensityMapEXT |"; - if ( value & FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR ) - result += " FragmentShadingRateAttachmentKHR |"; - if ( value & FormatFeatureFlagBits::eVideoEncodeInputKHR ) - result += " VideoEncodeInputKHR |"; - if ( value & FormatFeatureFlagBits::eVideoEncodeDpbKHR ) - result += " VideoEncodeDpbKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ImageCreateFlags value ) - { - std::string result = "{"; - if ( value & ImageCreateFlagBits::eSparseBinding ) - result += " SparseBinding |"; - if ( value & ImageCreateFlagBits::eSparseResidency ) - result += " SparseResidency |"; - if ( value & ImageCreateFlagBits::eSparseAliased ) - result += " SparseAliased |"; - if ( value & ImageCreateFlagBits::eMutableFormat ) - result += " MutableFormat |"; - if ( value & ImageCreateFlagBits::eCubeCompatible ) - result += " CubeCompatible |"; - if ( value & ImageCreateFlagBits::eAlias ) - result += " Alias |"; - if ( value & ImageCreateFlagBits::eSplitInstanceBindRegions ) - result += " SplitInstanceBindRegions |"; - if ( value & ImageCreateFlagBits::e2DArrayCompatible ) - result += " 2DArrayCompatible |"; - if ( value & ImageCreateFlagBits::eBlockTexelViewCompatible ) - result += " BlockTexelViewCompatible |"; - if ( value & ImageCreateFlagBits::eExtendedUsage ) - result += " ExtendedUsage |"; - if ( value & ImageCreateFlagBits::eProtected ) - result += " Protected |"; - if ( value & ImageCreateFlagBits::eDisjoint ) - result += " Disjoint |"; - if ( value & ImageCreateFlagBits::eCornerSampledNV ) - result += " CornerSampledNV |"; - if ( value & ImageCreateFlagBits::eDescriptorHeapCaptureReplayEXT ) - result += " DescriptorHeapCaptureReplayEXT |"; - if ( value & ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT ) - result += " SampleLocationsCompatibleDepthEXT |"; - if ( value & ImageCreateFlagBits::eSubsampledEXT ) - result += " SubsampledEXT |"; - if ( value & ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT ) - result += " MultisampledRenderToSingleSampledEXT |"; - if ( value & ImageCreateFlagBits::e2DViewCompatibleEXT ) - result += " 2DViewCompatibleEXT |"; - if ( value & ImageCreateFlagBits::eVideoProfileIndependentKHR ) - result += " VideoProfileIndependentKHR |"; - if ( value & ImageCreateFlagBits::eFragmentDensityMapOffsetEXT ) - result += " FragmentDensityMapOffsetEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ImageUsageFlags value ) - { - std::string result = "{"; - if ( value & ImageUsageFlagBits::eTransferSrc ) - result += " TransferSrc |"; - if ( value & ImageUsageFlagBits::eTransferDst ) - result += " TransferDst |"; - if ( value & ImageUsageFlagBits::eSampled ) - result += " Sampled |"; - if ( value & ImageUsageFlagBits::eStorage ) - result += " Storage |"; - if ( value & ImageUsageFlagBits::eColorAttachment ) - result += " ColorAttachment |"; - if ( value & ImageUsageFlagBits::eDepthStencilAttachment ) - result += " DepthStencilAttachment |"; - if ( value & ImageUsageFlagBits::eTransientAttachment ) - result += " TransientAttachment |"; - if ( value & ImageUsageFlagBits::eInputAttachment ) - result += " InputAttachment |"; - if ( value & ImageUsageFlagBits::eHostTransfer ) - result += " HostTransfer |"; - if ( value & ImageUsageFlagBits::eVideoDecodeDstKHR ) - result += " VideoDecodeDstKHR |"; - if ( value & ImageUsageFlagBits::eVideoDecodeSrcKHR ) - result += " VideoDecodeSrcKHR |"; - if ( value & ImageUsageFlagBits::eVideoDecodeDpbKHR ) - result += " VideoDecodeDpbKHR |"; - if ( value & ImageUsageFlagBits::eFragmentDensityMapEXT ) - result += " FragmentDensityMapEXT |"; - if ( value & ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR ) - result += " FragmentShadingRateAttachmentKHR |"; - if ( value & ImageUsageFlagBits::eVideoEncodeDstKHR ) - result += " VideoEncodeDstKHR |"; - if ( value & ImageUsageFlagBits::eVideoEncodeSrcKHR ) - result += " VideoEncodeSrcKHR |"; - if ( value & ImageUsageFlagBits::eVideoEncodeDpbKHR ) - result += " VideoEncodeDpbKHR |"; - if ( value & ImageUsageFlagBits::eAttachmentFeedbackLoopEXT ) - result += " AttachmentFeedbackLoopEXT |"; - if ( value & ImageUsageFlagBits::eInvocationMaskHUAWEI ) - result += " InvocationMaskHUAWEI |"; - if ( value & ImageUsageFlagBits::eSampleWeightQCOM ) - result += " SampleWeightQCOM |"; - if ( value & ImageUsageFlagBits::eSampleBlockMatchQCOM ) - result += " SampleBlockMatchQCOM |"; - if ( value & ImageUsageFlagBits::eTensorAliasingARM ) - result += " TensorAliasingARM |"; - if ( value & ImageUsageFlagBits::eTileMemoryQCOM ) - result += " TileMemoryQCOM |"; - if ( value & ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR ) - result += " VideoEncodeQuantizationDeltaMapKHR |"; - if ( value & ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR ) - result += " VideoEncodeEmphasisMapKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( InstanceCreateFlags value ) - { - std::string result = "{"; - if ( value & InstanceCreateFlagBits::eEnumeratePortabilityKHR ) - result += " EnumeratePortabilityKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( MemoryHeapFlags value ) - { - std::string result = "{"; - if ( value & MemoryHeapFlagBits::eDeviceLocal ) - result += " DeviceLocal |"; - if ( value & MemoryHeapFlagBits::eMultiInstance ) - result += " MultiInstance |"; - if ( value & MemoryHeapFlagBits::eTileMemoryQCOM ) - result += " TileMemoryQCOM |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( MemoryPropertyFlags value ) - { - std::string result = "{"; - if ( value & MemoryPropertyFlagBits::eDeviceLocal ) - result += " DeviceLocal |"; - if ( value & MemoryPropertyFlagBits::eHostVisible ) - result += " HostVisible |"; - if ( value & MemoryPropertyFlagBits::eHostCoherent ) - result += " HostCoherent |"; - if ( value & MemoryPropertyFlagBits::eHostCached ) - result += " HostCached |"; - if ( value & MemoryPropertyFlagBits::eLazilyAllocated ) - result += " LazilyAllocated |"; - if ( value & MemoryPropertyFlagBits::eProtected ) - result += " Protected |"; - if ( value & MemoryPropertyFlagBits::eDeviceCoherentAMD ) - result += " DeviceCoherentAMD |"; - if ( value & MemoryPropertyFlagBits::eDeviceUncachedAMD ) - result += " DeviceUncachedAMD |"; - if ( value & MemoryPropertyFlagBits::eRdmaCapableNV ) - result += " RdmaCapableNV |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( QueueFlags value ) - { - std::string result = "{"; - if ( value & QueueFlagBits::eGraphics ) - result += " Graphics |"; - if ( value & QueueFlagBits::eCompute ) - result += " Compute |"; - if ( value & QueueFlagBits::eTransfer ) - result += " Transfer |"; - if ( value & QueueFlagBits::eSparseBinding ) - result += " SparseBinding |"; - if ( value & QueueFlagBits::eProtected ) - result += " Protected |"; - if ( value & QueueFlagBits::eVideoDecodeKHR ) - result += " VideoDecodeKHR |"; - if ( value & QueueFlagBits::eVideoEncodeKHR ) - result += " VideoEncodeKHR |"; - if ( value & QueueFlagBits::eOpticalFlowNV ) - result += " OpticalFlowNV |"; - if ( value & QueueFlagBits::eDataGraphARM ) - result += " DataGraphARM |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( SampleCountFlags value ) - { - std::string result = "{"; - if ( value & SampleCountFlagBits::e1 ) - result += " 1 |"; - if ( value & SampleCountFlagBits::e2 ) - result += " 2 |"; - if ( value & SampleCountFlagBits::e4 ) - result += " 4 |"; - if ( value & SampleCountFlagBits::e8 ) - result += " 8 |"; - if ( value & SampleCountFlagBits::e16 ) - result += " 16 |"; - if ( value & SampleCountFlagBits::e32 ) - result += " 32 |"; - if ( value & SampleCountFlagBits::e64 ) - result += " 64 |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( DeviceQueueCreateFlags value ) - { - std::string result = "{"; - if ( value & DeviceQueueCreateFlagBits::eProtected ) - result += " Protected |"; - if ( value & DeviceQueueCreateFlagBits::eInternallySynchronizedKHR ) - result += " InternallySynchronizedKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags value ) - { - std::string result = "{"; - if ( value & PipelineStageFlagBits::eTopOfPipe ) - result += " TopOfPipe |"; - if ( value & PipelineStageFlagBits::eDrawIndirect ) - result += " DrawIndirect |"; - if ( value & PipelineStageFlagBits::eVertexInput ) - result += " VertexInput |"; - if ( value & PipelineStageFlagBits::eVertexShader ) - result += " VertexShader |"; - if ( value & PipelineStageFlagBits::eTessellationControlShader ) - result += " TessellationControlShader |"; - if ( value & PipelineStageFlagBits::eTessellationEvaluationShader ) - result += " TessellationEvaluationShader |"; - if ( value & PipelineStageFlagBits::eGeometryShader ) - result += " GeometryShader |"; - if ( value & PipelineStageFlagBits::eFragmentShader ) - result += " FragmentShader |"; - if ( value & PipelineStageFlagBits::eEarlyFragmentTests ) - result += " EarlyFragmentTests |"; - if ( value & PipelineStageFlagBits::eLateFragmentTests ) - result += " LateFragmentTests |"; - if ( value & PipelineStageFlagBits::eColorAttachmentOutput ) - result += " ColorAttachmentOutput |"; - if ( value & PipelineStageFlagBits::eComputeShader ) - result += " ComputeShader |"; - if ( value & PipelineStageFlagBits::eTransfer ) - result += " Transfer |"; - if ( value & PipelineStageFlagBits::eBottomOfPipe ) - result += " BottomOfPipe |"; - if ( value & PipelineStageFlagBits::eHost ) - result += " Host |"; - if ( value & PipelineStageFlagBits::eAllGraphics ) - result += " AllGraphics |"; - if ( value & PipelineStageFlagBits::eAllCommands ) - result += " AllCommands |"; - if ( value & PipelineStageFlagBits::eTransformFeedbackEXT ) - result += " TransformFeedbackEXT |"; - if ( value & PipelineStageFlagBits::eConditionalRenderingEXT ) - result += " ConditionalRenderingEXT |"; - if ( value & PipelineStageFlagBits::eAccelerationStructureBuildKHR ) - result += " AccelerationStructureBuildKHR |"; - if ( value & PipelineStageFlagBits::eRayTracingShaderKHR ) - result += " RayTracingShaderKHR |"; - if ( value & PipelineStageFlagBits::eFragmentDensityProcessEXT ) - result += " FragmentDensityProcessEXT |"; - if ( value & PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR ) - result += " FragmentShadingRateAttachmentKHR |"; - if ( value & PipelineStageFlagBits::eTaskShaderEXT ) - result += " TaskShaderEXT |"; - if ( value & PipelineStageFlagBits::eMeshShaderEXT ) - result += " MeshShaderEXT |"; - if ( value & PipelineStageFlagBits::eCommandPreprocessEXT ) - result += " CommandPreprocessEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "None"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( MemoryMapFlags value ) - { - std::string result = "{"; - if ( value & MemoryMapFlagBits::ePlacedEXT ) - result += " PlacedEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ImageAspectFlags value ) - { - std::string result = "{"; - if ( value & ImageAspectFlagBits::eColor ) - result += " Color |"; - if ( value & ImageAspectFlagBits::eDepth ) - result += " Depth |"; - if ( value & ImageAspectFlagBits::eStencil ) - result += " Stencil |"; - if ( value & ImageAspectFlagBits::eMetadata ) - result += " Metadata |"; - if ( value & ImageAspectFlagBits::ePlane0 ) - result += " Plane0 |"; - if ( value & ImageAspectFlagBits::ePlane1 ) - result += " Plane1 |"; - if ( value & ImageAspectFlagBits::ePlane2 ) - result += " Plane2 |"; - if ( value & ImageAspectFlagBits::eMemoryPlane0EXT ) - result += " MemoryPlane0EXT |"; - if ( value & ImageAspectFlagBits::eMemoryPlane1EXT ) - result += " MemoryPlane1EXT |"; - if ( value & ImageAspectFlagBits::eMemoryPlane2EXT ) - result += " MemoryPlane2EXT |"; - if ( value & ImageAspectFlagBits::eMemoryPlane3EXT ) - result += " MemoryPlane3EXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "None"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( SparseImageFormatFlags value ) - { - std::string result = "{"; - if ( value & SparseImageFormatFlagBits::eSingleMiptail ) - result += " SingleMiptail |"; - if ( value & SparseImageFormatFlagBits::eAlignedMipSize ) - result += " AlignedMipSize |"; - if ( value & SparseImageFormatFlagBits::eNonstandardBlockSize ) - result += " NonstandardBlockSize |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( SparseMemoryBindFlags value ) - { - std::string result = "{"; - if ( value & SparseMemoryBindFlagBits::eMetadata ) - result += " Metadata |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( FenceCreateFlags value ) - { - std::string result = "{"; - if ( value & FenceCreateFlagBits::eSignaled ) - result += " Signaled |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( QueryPoolCreateFlags value ) - { - std::string result = "{"; - if ( value & QueryPoolCreateFlagBits::eResetKHR ) - result += " ResetKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( QueryResultFlags value ) - { - std::string result = "{"; - if ( value & QueryResultFlagBits::e64 ) - result += " 64 |"; - if ( value & QueryResultFlagBits::eWait ) - result += " Wait |"; - if ( value & QueryResultFlagBits::eWithAvailability ) - result += " WithAvailability |"; - if ( value & QueryResultFlagBits::ePartial ) - result += " Partial |"; - if ( value & QueryResultFlagBits::eWithStatusKHR ) - result += " WithStatusKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( BufferCreateFlags value ) - { - std::string result = "{"; - if ( value & BufferCreateFlagBits::eSparseBinding ) - result += " SparseBinding |"; - if ( value & BufferCreateFlagBits::eSparseResidency ) - result += " SparseResidency |"; - if ( value & BufferCreateFlagBits::eSparseAliased ) - result += " SparseAliased |"; - if ( value & BufferCreateFlagBits::eProtected ) - result += " Protected |"; - if ( value & BufferCreateFlagBits::eDeviceAddressCaptureReplay ) - result += " DeviceAddressCaptureReplay |"; - if ( value & BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT ) - result += " DescriptorBufferCaptureReplayEXT |"; - if ( value & BufferCreateFlagBits::eVideoProfileIndependentKHR ) - result += " VideoProfileIndependentKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags value ) - { - std::string result = "{"; - if ( value & BufferUsageFlagBits::eTransferSrc ) - result += " TransferSrc |"; - if ( value & BufferUsageFlagBits::eTransferDst ) - result += " TransferDst |"; - if ( value & BufferUsageFlagBits::eUniformTexelBuffer ) - result += " UniformTexelBuffer |"; - if ( value & BufferUsageFlagBits::eStorageTexelBuffer ) - result += " StorageTexelBuffer |"; - if ( value & BufferUsageFlagBits::eUniformBuffer ) - result += " UniformBuffer |"; - if ( value & BufferUsageFlagBits::eStorageBuffer ) - result += " StorageBuffer |"; - if ( value & BufferUsageFlagBits::eIndexBuffer ) - result += " IndexBuffer |"; - if ( value & BufferUsageFlagBits::eVertexBuffer ) - result += " VertexBuffer |"; - if ( value & BufferUsageFlagBits::eIndirectBuffer ) - result += " IndirectBuffer |"; - if ( value & BufferUsageFlagBits::eShaderDeviceAddress ) - result += " ShaderDeviceAddress |"; - if ( value & BufferUsageFlagBits::eVideoDecodeSrcKHR ) - result += " VideoDecodeSrcKHR |"; - if ( value & BufferUsageFlagBits::eVideoDecodeDstKHR ) - result += " VideoDecodeDstKHR |"; - if ( value & BufferUsageFlagBits::eTransformFeedbackBufferEXT ) - result += " TransformFeedbackBufferEXT |"; - if ( value & BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT ) - result += " TransformFeedbackCounterBufferEXT |"; - if ( value & BufferUsageFlagBits::eConditionalRenderingEXT ) - result += " ConditionalRenderingEXT |"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & BufferUsageFlagBits::eExecutionGraphScratchAMDX ) - result += " ExecutionGraphScratchAMDX |"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - if ( value & BufferUsageFlagBits::eDescriptorHeapEXT ) - result += " DescriptorHeapEXT |"; - if ( value & BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR ) - result += " AccelerationStructureBuildInputReadOnlyKHR |"; - if ( value & BufferUsageFlagBits::eAccelerationStructureStorageKHR ) - result += " AccelerationStructureStorageKHR |"; - if ( value & BufferUsageFlagBits::eShaderBindingTableKHR ) - result += " ShaderBindingTableKHR |"; - if ( value & BufferUsageFlagBits::eVideoEncodeDstKHR ) - result += " VideoEncodeDstKHR |"; - if ( value & BufferUsageFlagBits::eVideoEncodeSrcKHR ) - result += " VideoEncodeSrcKHR |"; - if ( value & BufferUsageFlagBits::eSamplerDescriptorBufferEXT ) - result += " SamplerDescriptorBufferEXT |"; - if ( value & BufferUsageFlagBits::eResourceDescriptorBufferEXT ) - result += " ResourceDescriptorBufferEXT |"; - if ( value & BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT ) - result += " PushDescriptorsDescriptorBufferEXT |"; - if ( value & BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT ) - result += " MicromapBuildInputReadOnlyEXT |"; - if ( value & BufferUsageFlagBits::eMicromapStorageEXT ) - result += " MicromapStorageEXT |"; - if ( value & BufferUsageFlagBits::eTileMemoryQCOM ) - result += " TileMemoryQCOM |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ImageViewCreateFlags value ) - { - std::string result = "{"; - if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT ) - result += " FragmentDensityMapDynamicEXT |"; - if ( value & ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT ) - result += " DescriptorBufferCaptureReplayEXT |"; - if ( value & ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT ) - result += " FragmentDensityMapDeferredEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( AccessFlags value ) - { - std::string result = "{"; - if ( value & AccessFlagBits::eIndirectCommandRead ) - result += " IndirectCommandRead |"; - if ( value & AccessFlagBits::eIndexRead ) - result += " IndexRead |"; - if ( value & AccessFlagBits::eVertexAttributeRead ) - result += " VertexAttributeRead |"; - if ( value & AccessFlagBits::eUniformRead ) - result += " UniformRead |"; - if ( value & AccessFlagBits::eInputAttachmentRead ) - result += " InputAttachmentRead |"; - if ( value & AccessFlagBits::eShaderRead ) - result += " ShaderRead |"; - if ( value & AccessFlagBits::eShaderWrite ) - result += " ShaderWrite |"; - if ( value & AccessFlagBits::eColorAttachmentRead ) - result += " ColorAttachmentRead |"; - if ( value & AccessFlagBits::eColorAttachmentWrite ) - result += " ColorAttachmentWrite |"; - if ( value & AccessFlagBits::eDepthStencilAttachmentRead ) - result += " DepthStencilAttachmentRead |"; - if ( value & AccessFlagBits::eDepthStencilAttachmentWrite ) - result += " DepthStencilAttachmentWrite |"; - if ( value & AccessFlagBits::eTransferRead ) - result += " TransferRead |"; - if ( value & AccessFlagBits::eTransferWrite ) - result += " TransferWrite |"; - if ( value & AccessFlagBits::eHostRead ) - result += " HostRead |"; - if ( value & AccessFlagBits::eHostWrite ) - result += " HostWrite |"; - if ( value & AccessFlagBits::eMemoryRead ) - result += " MemoryRead |"; - if ( value & AccessFlagBits::eMemoryWrite ) - result += " MemoryWrite |"; - if ( value & AccessFlagBits::eTransformFeedbackWriteEXT ) - result += " TransformFeedbackWriteEXT |"; - if ( value & AccessFlagBits::eTransformFeedbackCounterReadEXT ) - result += " TransformFeedbackCounterReadEXT |"; - if ( value & AccessFlagBits::eTransformFeedbackCounterWriteEXT ) - result += " TransformFeedbackCounterWriteEXT |"; - if ( value & AccessFlagBits::eConditionalRenderingReadEXT ) - result += " ConditionalRenderingReadEXT |"; - if ( value & AccessFlagBits::eColorAttachmentReadNoncoherentEXT ) - result += " ColorAttachmentReadNoncoherentEXT |"; - if ( value & AccessFlagBits::eAccelerationStructureReadKHR ) - result += " AccelerationStructureReadKHR |"; - if ( value & AccessFlagBits::eAccelerationStructureWriteKHR ) - result += " AccelerationStructureWriteKHR |"; - if ( value & AccessFlagBits::eFragmentDensityMapReadEXT ) - result += " FragmentDensityMapReadEXT |"; - if ( value & AccessFlagBits::eFragmentShadingRateAttachmentReadKHR ) - result += " FragmentShadingRateAttachmentReadKHR |"; - if ( value & AccessFlagBits::eCommandPreprocessReadEXT ) - result += " CommandPreprocessReadEXT |"; - if ( value & AccessFlagBits::eCommandPreprocessWriteEXT ) - result += " CommandPreprocessWriteEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "None"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( DependencyFlags value ) - { - std::string result = "{"; - if ( value & DependencyFlagBits::eByRegion ) - result += " ByRegion |"; - if ( value & DependencyFlagBits::eDeviceGroup ) - result += " DeviceGroup |"; - if ( value & DependencyFlagBits::eViewLocal ) - result += " ViewLocal |"; - if ( value & DependencyFlagBits::eFeedbackLoopEXT ) - result += " FeedbackLoopEXT |"; - if ( value & DependencyFlagBits::eQueueFamilyOwnershipTransferUseAllStagesKHR ) - result += " QueueFamilyOwnershipTransferUseAllStagesKHR |"; - if ( value & DependencyFlagBits::eAsymmetricEventKHR ) - result += " AsymmetricEventKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( CommandPoolCreateFlags value ) - { - std::string result = "{"; - if ( value & CommandPoolCreateFlagBits::eTransient ) - result += " Transient |"; - if ( value & CommandPoolCreateFlagBits::eResetCommandBuffer ) - result += " ResetCommandBuffer |"; - if ( value & CommandPoolCreateFlagBits::eProtected ) - result += " Protected |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( CommandPoolResetFlags value ) - { - std::string result = "{"; - if ( value & CommandPoolResetFlagBits::eReleaseResources ) - result += " ReleaseResources |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( CommandBufferResetFlags value ) - { - std::string result = "{"; - if ( value & CommandBufferResetFlagBits::eReleaseResources ) - result += " ReleaseResources |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( CommandBufferUsageFlags value ) - { - std::string result = "{"; - if ( value & CommandBufferUsageFlagBits::eOneTimeSubmit ) - result += " OneTimeSubmit |"; - if ( value & CommandBufferUsageFlagBits::eRenderPassContinue ) - result += " RenderPassContinue |"; - if ( value & CommandBufferUsageFlagBits::eSimultaneousUse ) - result += " SimultaneousUse |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( QueryControlFlags value ) - { - std::string result = "{"; - if ( value & QueryControlFlagBits::ePrecise ) - result += " Precise |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( EventCreateFlags value ) - { - std::string result = "{"; - if ( value & EventCreateFlagBits::eDeviceOnly ) - result += " DeviceOnly |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferViewCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderModuleCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( PipelineCacheCreateFlags value ) - { - std::string result = "{"; - if ( value & PipelineCacheCreateFlagBits::eExternallySynchronized ) - result += " ExternallySynchronized |"; - if ( value & PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR ) - result += " InternallySynchronizedMergeKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags value ) - { - std::string result = "{"; - if ( value & PipelineCreateFlagBits::eDisableOptimization ) - result += " DisableOptimization |"; - if ( value & PipelineCreateFlagBits::eAllowDerivatives ) - result += " AllowDerivatives |"; - if ( value & PipelineCreateFlagBits::eDerivative ) - result += " Derivative |"; - if ( value & PipelineCreateFlagBits::eDispatchBase ) - result += " DispatchBase |"; - if ( value & PipelineCreateFlagBits::eViewIndexFromDeviceIndex ) - result += " ViewIndexFromDeviceIndex |"; - if ( value & PipelineCreateFlagBits::eFailOnPipelineCompileRequired ) - result += " FailOnPipelineCompileRequired |"; - if ( value & PipelineCreateFlagBits::eEarlyReturnOnFailure ) - result += " EarlyReturnOnFailure |"; - if ( value & PipelineCreateFlagBits::eNoProtectedAccess ) - result += " NoProtectedAccess |"; - if ( value & PipelineCreateFlagBits::eProtectedAccessOnly ) - result += " ProtectedAccessOnly |"; - if ( value & PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR ) - result += " RayTracingNoNullAnyHitShadersKHR |"; - if ( value & PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR ) - result += " RayTracingNoNullClosestHitShadersKHR |"; - if ( value & PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR ) - result += " RayTracingNoNullMissShadersKHR |"; - if ( value & PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR ) - result += " RayTracingNoNullIntersectionShadersKHR |"; - if ( value & PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR ) - result += " RayTracingSkipTrianglesKHR |"; - if ( value & PipelineCreateFlagBits::eRayTracingSkipAabbsKHR ) - result += " RayTracingSkipAabbsKHR |"; - if ( value & PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR ) - result += " RayTracingShaderGroupHandleCaptureReplayKHR |"; - if ( value & PipelineCreateFlagBits::eDeferCompileNV ) - result += " DeferCompileNV |"; - if ( value & PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT ) - result += " RenderingFragmentDensityMapAttachmentEXT |"; - if ( value & PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR ) - result += " RenderingFragmentShadingRateAttachmentKHR |"; - if ( value & PipelineCreateFlagBits::eCaptureStatisticsKHR ) - result += " CaptureStatisticsKHR |"; - if ( value & PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR ) - result += " CaptureInternalRepresentationsKHR |"; - if ( value & PipelineCreateFlagBits::eIndirectBindableNV ) - result += " IndirectBindableNV |"; - if ( value & PipelineCreateFlagBits::eLibraryKHR ) - result += " LibraryKHR |"; - if ( value & PipelineCreateFlagBits::eDescriptorBufferEXT ) - result += " DescriptorBufferEXT |"; - if ( value & PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT ) - result += " RetainLinkTimeOptimizationInfoEXT |"; - if ( value & PipelineCreateFlagBits::eLinkTimeOptimizationEXT ) - result += " LinkTimeOptimizationEXT |"; - if ( value & PipelineCreateFlagBits::eRayTracingAllowMotionNV ) - result += " RayTracingAllowMotionNV |"; - if ( value & PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT ) - result += " ColorAttachmentFeedbackLoopEXT |"; - if ( value & PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT ) - result += " DepthStencilAttachmentFeedbackLoopEXT |"; - if ( value & PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT ) - result += " RayTracingOpacityMicromapEXT |"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV ) - result += " RayTracingDisplacementMicromapNV |"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( PipelineLayoutCreateFlags value ) - { - std::string result = "{"; - if ( value & PipelineLayoutCreateFlagBits::eIndependentSetsEXT ) - result += " IndependentSetsEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( PipelineShaderStageCreateFlags value ) - { - std::string result = "{"; - if ( value & PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize ) - result += " AllowVaryingSubgroupSize |"; - if ( value & PipelineShaderStageCreateFlagBits::eRequireFullSubgroups ) - result += " RequireFullSubgroups |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ShaderStageFlags value ) - { - std::string result = "{"; - if ( value & ShaderStageFlagBits::eVertex ) - result += " Vertex |"; - if ( value & ShaderStageFlagBits::eTessellationControl ) - result += " TessellationControl |"; - if ( value & ShaderStageFlagBits::eTessellationEvaluation ) - result += " TessellationEvaluation |"; - if ( value & ShaderStageFlagBits::eGeometry ) - result += " Geometry |"; - if ( value & ShaderStageFlagBits::eFragment ) - result += " Fragment |"; - if ( value & ShaderStageFlagBits::eCompute ) - result += " Compute |"; - if ( value & ShaderStageFlagBits::eRaygenKHR ) - result += " RaygenKHR |"; - if ( value & ShaderStageFlagBits::eAnyHitKHR ) - result += " AnyHitKHR |"; - if ( value & ShaderStageFlagBits::eClosestHitKHR ) - result += " ClosestHitKHR |"; - if ( value & ShaderStageFlagBits::eMissKHR ) - result += " MissKHR |"; - if ( value & ShaderStageFlagBits::eIntersectionKHR ) - result += " IntersectionKHR |"; - if ( value & ShaderStageFlagBits::eCallableKHR ) - result += " CallableKHR |"; - if ( value & ShaderStageFlagBits::eTaskEXT ) - result += " TaskEXT |"; - if ( value & ShaderStageFlagBits::eMeshEXT ) - result += " MeshEXT |"; - if ( value & ShaderStageFlagBits::eSubpassShadingHUAWEI ) - result += " SubpassShadingHUAWEI |"; - if ( value & ShaderStageFlagBits::eClusterCullingHUAWEI ) - result += " ClusterCullingHUAWEI |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( SamplerCreateFlags value ) - { - std::string result = "{"; - if ( value & SamplerCreateFlagBits::eSubsampledEXT ) - result += " SubsampledEXT |"; - if ( value & SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT ) - result += " SubsampledCoarseReconstructionEXT |"; - if ( value & SamplerCreateFlagBits::eDescriptorBufferCaptureReplayEXT ) - result += " DescriptorBufferCaptureReplayEXT |"; - if ( value & SamplerCreateFlagBits::eNonSeamlessCubeMapEXT ) - result += " NonSeamlessCubeMapEXT |"; - if ( value & SamplerCreateFlagBits::eImageProcessingQCOM ) - result += " ImageProcessingQCOM |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( DescriptorPoolCreateFlags value ) - { - std::string result = "{"; - if ( value & DescriptorPoolCreateFlagBits::eFreeDescriptorSet ) - result += " FreeDescriptorSet |"; - if ( value & DescriptorPoolCreateFlagBits::eUpdateAfterBind ) - result += " UpdateAfterBind |"; - if ( value & DescriptorPoolCreateFlagBits::eHostOnlyEXT ) - result += " HostOnlyEXT |"; - if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV ) - result += " AllowOverallocationSetsNV |"; - if ( value & DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV ) - result += " AllowOverallocationPoolsNV |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorPoolResetFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( DescriptorSetLayoutCreateFlags value ) - { - std::string result = "{"; - if ( value & DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool ) - result += " UpdateAfterBindPool |"; - if ( value & DescriptorSetLayoutCreateFlagBits::ePushDescriptor ) - result += " PushDescriptor |"; - if ( value & DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT ) - result += " DescriptorBufferEXT |"; - if ( value & DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT ) - result += " EmbeddedImmutableSamplersEXT |"; - if ( value & DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV ) - result += " IndirectBindableNV |"; - if ( value & DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT ) - result += " HostOnlyPoolEXT |"; - if ( value & DescriptorSetLayoutCreateFlagBits::ePerStageNV ) - result += " PerStageNV |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( QueryPipelineStatisticFlags value ) - { - std::string result = "{"; - if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyVertices ) - result += " InputAssemblyVertices |"; - if ( value & QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives ) - result += " InputAssemblyPrimitives |"; - if ( value & QueryPipelineStatisticFlagBits::eVertexShaderInvocations ) - result += " VertexShaderInvocations |"; - if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderInvocations ) - result += " GeometryShaderInvocations |"; - if ( value & QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives ) - result += " GeometryShaderPrimitives |"; - if ( value & QueryPipelineStatisticFlagBits::eClippingInvocations ) - result += " ClippingInvocations |"; - if ( value & QueryPipelineStatisticFlagBits::eClippingPrimitives ) - result += " ClippingPrimitives |"; - if ( value & QueryPipelineStatisticFlagBits::eFragmentShaderInvocations ) - result += " FragmentShaderInvocations |"; - if ( value & QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches ) - result += " TessellationControlShaderPatches |"; - if ( value & QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations ) - result += " TessellationEvaluationShaderInvocations |"; - if ( value & QueryPipelineStatisticFlagBits::eComputeShaderInvocations ) - result += " ComputeShaderInvocations |"; - if ( value & QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT ) - result += " TaskShaderInvocationsEXT |"; - if ( value & QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT ) - result += " MeshShaderInvocationsEXT |"; - if ( value & QueryPipelineStatisticFlagBits::eClusterCullingShaderInvocationsHUAWEI ) - result += " ClusterCullingShaderInvocationsHUAWEI |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ColorComponentFlags value ) - { - std::string result = "{"; - if ( value & ColorComponentFlagBits::eR ) - result += " R |"; - if ( value & ColorComponentFlagBits::eG ) - result += " G |"; - if ( value & ColorComponentFlagBits::eB ) - result += " B |"; - if ( value & ColorComponentFlagBits::eA ) - result += " A |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( CullModeFlags value ) - { - std::string result = "{"; - if ( value & CullModeFlagBits::eFront ) - result += " Front |"; - if ( value & CullModeFlagBits::eBack ) - result += " Back |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "None"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( PipelineColorBlendStateCreateFlags value ) - { - std::string result = "{"; - if ( value & PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT ) - result += " RasterizationOrderAttachmentAccessEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( PipelineDepthStencilStateCreateFlags value ) - { - std::string result = "{"; - if ( value & PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT ) - result += " RasterizationOrderAttachmentDepthAccessEXT |"; - if ( value & PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT ) - result += " RasterizationOrderAttachmentStencilAccessEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDynamicStateCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineInputAssemblyStateCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineMultisampleStateCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineTessellationStateCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineVertexInputStateCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportStateCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( AttachmentDescriptionFlags value ) - { - std::string result = "{"; - if ( value & AttachmentDescriptionFlagBits::eMayAlias ) - result += " MayAlias |"; - if ( value & AttachmentDescriptionFlagBits::eResolveSkipTransferFunctionKHR ) - result += " ResolveSkipTransferFunctionKHR |"; - if ( value & AttachmentDescriptionFlagBits::eResolveEnableTransferFunctionKHR ) - result += " ResolveEnableTransferFunctionKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( FramebufferCreateFlags value ) - { - std::string result = "{"; - if ( value & FramebufferCreateFlagBits::eImageless ) - result += " Imageless |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( RenderPassCreateFlags value ) - { - std::string result = "{"; - if ( value & RenderPassCreateFlagBits::eTransformQCOM ) - result += " TransformQCOM |"; - if ( value & RenderPassCreateFlagBits::ePerLayerFragmentDensityVALVE ) - result += " PerLayerFragmentDensityVALVE |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( SubpassDescriptionFlags value ) - { - std::string result = "{"; - if ( value & SubpassDescriptionFlagBits::ePerViewAttributesNVX ) - result += " PerViewAttributesNVX |"; - if ( value & SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX ) - result += " PerViewPositionXOnlyNVX |"; - if ( value & SubpassDescriptionFlagBits::eTileShadingApronQCOM ) - result += " TileShadingApronQCOM |"; - if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT ) - result += " RasterizationOrderAttachmentColorAccessEXT |"; - if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT ) - result += " RasterizationOrderAttachmentDepthAccessEXT |"; - if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT ) - result += " RasterizationOrderAttachmentStencilAccessEXT |"; - if ( value & SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT ) - result += " EnableLegacyDitheringEXT |"; - if ( value & SubpassDescriptionFlagBits::eFragmentRegionEXT ) - result += " FragmentRegionEXT |"; - if ( value & SubpassDescriptionFlagBits::eCustomResolveEXT ) - result += " CustomResolveEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( StencilFaceFlags value ) - { - std::string result = "{"; - if ( value & StencilFaceFlagBits::eFront ) - result += " Front |"; - if ( value & StencilFaceFlagBits::eBack ) - result += " Back |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_VERSION_1_1 === - - VULKAN_HPP_INLINE std::string to_string( PeerMemoryFeatureFlags value ) - { - std::string result = "{"; - if ( value & PeerMemoryFeatureFlagBits::eCopySrc ) - result += " CopySrc |"; - if ( value & PeerMemoryFeatureFlagBits::eCopyDst ) - result += " CopyDst |"; - if ( value & PeerMemoryFeatureFlagBits::eGenericSrc ) - result += " GenericSrc |"; - if ( value & PeerMemoryFeatureFlagBits::eGenericDst ) - result += " GenericDst |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( MemoryAllocateFlags value ) - { - std::string result = "{"; - if ( value & MemoryAllocateFlagBits::eDeviceMask ) - result += " DeviceMask |"; - if ( value & MemoryAllocateFlagBits::eDeviceAddress ) - result += " DeviceAddress |"; - if ( value & MemoryAllocateFlagBits::eDeviceAddressCaptureReplay ) - result += " DeviceAddressCaptureReplay |"; - if ( value & MemoryAllocateFlagBits::eZeroInitializeEXT ) - result += " ZeroInitializeEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolTrimFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlags value ) - { - std::string result = "{"; - if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueFd ) - result += " OpaqueFd |"; - if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 ) - result += " OpaqueWin32 |"; - if ( value & ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt ) - result += " OpaqueWin32Kmt |"; - if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11Texture ) - result += " D3D11Texture |"; - if ( value & ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt ) - result += " D3D11TextureKmt |"; - if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Heap ) - result += " D3D12Heap |"; - if ( value & ExternalMemoryHandleTypeFlagBits::eD3D12Resource ) - result += " D3D12Resource |"; - if ( value & ExternalMemoryHandleTypeFlagBits::eDmaBufEXT ) - result += " DmaBufEXT |"; -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - if ( value & ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID ) - result += " AndroidHardwareBufferANDROID |"; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - if ( value & ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT ) - result += " HostAllocationEXT |"; - if ( value & ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT ) - result += " HostMappedForeignMemoryEXT |"; -#if defined( VK_USE_PLATFORM_FUCHSIA ) - if ( value & ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA ) - result += " ZirconVmoFUCHSIA |"; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - if ( value & ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV ) - result += " RdmaAddressNV |"; -#if defined( VK_USE_PLATFORM_OHOS ) - if ( value & ExternalMemoryHandleTypeFlagBits::eOhNativeBufferOHOS ) - result += " OhNativeBufferOHOS |"; -#endif /*VK_USE_PLATFORM_OHOS*/ -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - if ( value & ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX ) - result += " ScreenBufferQNX |"; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ -#if defined( VK_USE_PLATFORM_METAL_EXT ) - if ( value & ExternalMemoryHandleTypeFlagBits::eMtlbufferEXT ) - result += " MtlbufferEXT |"; - if ( value & ExternalMemoryHandleTypeFlagBits::eMtltextureEXT ) - result += " MtltextureEXT |"; - if ( value & ExternalMemoryHandleTypeFlagBits::eMtlheapEXT ) - result += " MtlheapEXT |"; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlags value ) - { - std::string result = "{"; - if ( value & ExternalMemoryFeatureFlagBits::eDedicatedOnly ) - result += " DedicatedOnly |"; - if ( value & ExternalMemoryFeatureFlagBits::eExportable ) - result += " Exportable |"; - if ( value & ExternalMemoryFeatureFlagBits::eImportable ) - result += " Importable |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ExternalFenceHandleTypeFlags value ) - { - std::string result = "{"; - if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueFd ) - result += " OpaqueFd |"; - if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32 ) - result += " OpaqueWin32 |"; - if ( value & ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt ) - result += " OpaqueWin32Kmt |"; - if ( value & ExternalFenceHandleTypeFlagBits::eSyncFd ) - result += " SyncFd |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ExternalFenceFeatureFlags value ) - { - std::string result = "{"; - if ( value & ExternalFenceFeatureFlagBits::eExportable ) - result += " Exportable |"; - if ( value & ExternalFenceFeatureFlagBits::eImportable ) - result += " Importable |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( FenceImportFlags value ) - { - std::string result = "{"; - if ( value & FenceImportFlagBits::eTemporary ) - result += " Temporary |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( SemaphoreImportFlags value ) - { - std::string result = "{"; - if ( value & SemaphoreImportFlagBits::eTemporary ) - result += " Temporary |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreHandleTypeFlags value ) - { - std::string result = "{"; - if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd ) - result += " OpaqueFd |"; - if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 ) - result += " OpaqueWin32 |"; - if ( value & ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt ) - result += " OpaqueWin32Kmt |"; - if ( value & ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence ) - result += " D3D12Fence |"; - if ( value & ExternalSemaphoreHandleTypeFlagBits::eSyncFd ) - result += " SyncFd |"; -#if defined( VK_USE_PLATFORM_FUCHSIA ) - if ( value & ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA ) - result += " ZirconEventFUCHSIA |"; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ExternalSemaphoreFeatureFlags value ) - { - std::string result = "{"; - if ( value & ExternalSemaphoreFeatureFlagBits::eExportable ) - result += " Exportable |"; - if ( value & ExternalSemaphoreFeatureFlagBits::eImportable ) - result += " Importable |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( SubgroupFeatureFlags value ) - { - std::string result = "{"; - if ( value & SubgroupFeatureFlagBits::eBasic ) - result += " Basic |"; - if ( value & SubgroupFeatureFlagBits::eVote ) - result += " Vote |"; - if ( value & SubgroupFeatureFlagBits::eArithmetic ) - result += " Arithmetic |"; - if ( value & SubgroupFeatureFlagBits::eBallot ) - result += " Ballot |"; - if ( value & SubgroupFeatureFlagBits::eShuffle ) - result += " Shuffle |"; - if ( value & SubgroupFeatureFlagBits::eShuffleRelative ) - result += " ShuffleRelative |"; - if ( value & SubgroupFeatureFlagBits::eClustered ) - result += " Clustered |"; - if ( value & SubgroupFeatureFlagBits::eQuad ) - result += " Quad |"; - if ( value & SubgroupFeatureFlagBits::eRotate ) - result += " Rotate |"; - if ( value & SubgroupFeatureFlagBits::eRotateClustered ) - result += " RotateClustered |"; - if ( value & SubgroupFeatureFlagBits::ePartitionedEXT ) - result += " PartitionedEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorUpdateTemplateCreateFlags ) - { - return "{}"; - } - - //=== VK_VERSION_1_2 === - - VULKAN_HPP_INLINE std::string to_string( SemaphoreWaitFlags value ) - { - std::string result = "{"; - if ( value & SemaphoreWaitFlagBits::eAny ) - result += " Any |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( DescriptorBindingFlags value ) - { - std::string result = "{"; - if ( value & DescriptorBindingFlagBits::eUpdateAfterBind ) - result += " UpdateAfterBind |"; - if ( value & DescriptorBindingFlagBits::eUpdateUnusedWhilePending ) - result += " UpdateUnusedWhilePending |"; - if ( value & DescriptorBindingFlagBits::ePartiallyBound ) - result += " PartiallyBound |"; - if ( value & DescriptorBindingFlagBits::eVariableDescriptorCount ) - result += " VariableDescriptorCount |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ResolveModeFlags value ) - { - std::string result = "{"; - if ( value & ResolveModeFlagBits::eSampleZero ) - result += " SampleZero |"; - if ( value & ResolveModeFlagBits::eAverage ) - result += " Average |"; - if ( value & ResolveModeFlagBits::eMin ) - result += " Min |"; - if ( value & ResolveModeFlagBits::eMax ) - result += " Max |"; -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - if ( value & ResolveModeFlagBits::eExternalFormatDownsampleANDROID ) - result += " ExternalFormatDownsampleANDROID |"; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - if ( value & ResolveModeFlagBits::eCustomEXT ) - result += " CustomEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "None"; - return result; - } - - //=== VK_VERSION_1_3 === - - VULKAN_HPP_INLINE std::string to_string( ToolPurposeFlags value ) - { - std::string result = "{"; - if ( value & ToolPurposeFlagBits::eValidation ) - result += " Validation |"; - if ( value & ToolPurposeFlagBits::eProfiling ) - result += " Profiling |"; - if ( value & ToolPurposeFlagBits::eTracing ) - result += " Tracing |"; - if ( value & ToolPurposeFlagBits::eAdditionalFeatures ) - result += " AdditionalFeatures |"; - if ( value & ToolPurposeFlagBits::eModifyingFeatures ) - result += " ModifyingFeatures |"; - if ( value & ToolPurposeFlagBits::eDebugReportingEXT ) - result += " DebugReportingEXT |"; - if ( value & ToolPurposeFlagBits::eDebugMarkersEXT ) - result += " DebugMarkersEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlags ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( PipelineStageFlags2 value ) - { - std::string result = "{"; - if ( value & PipelineStageFlagBits2::eTopOfPipe ) - result += " TopOfPipe |"; - if ( value & PipelineStageFlagBits2::eDrawIndirect ) - result += " DrawIndirect |"; - if ( value & PipelineStageFlagBits2::eVertexInput ) - result += " VertexInput |"; - if ( value & PipelineStageFlagBits2::eVertexShader ) - result += " VertexShader |"; - if ( value & PipelineStageFlagBits2::eTessellationControlShader ) - result += " TessellationControlShader |"; - if ( value & PipelineStageFlagBits2::eTessellationEvaluationShader ) - result += " TessellationEvaluationShader |"; - if ( value & PipelineStageFlagBits2::eGeometryShader ) - result += " GeometryShader |"; - if ( value & PipelineStageFlagBits2::eFragmentShader ) - result += " FragmentShader |"; - if ( value & PipelineStageFlagBits2::eEarlyFragmentTests ) - result += " EarlyFragmentTests |"; - if ( value & PipelineStageFlagBits2::eLateFragmentTests ) - result += " LateFragmentTests |"; - if ( value & PipelineStageFlagBits2::eColorAttachmentOutput ) - result += " ColorAttachmentOutput |"; - if ( value & PipelineStageFlagBits2::eComputeShader ) - result += " ComputeShader |"; - if ( value & PipelineStageFlagBits2::eAllTransfer ) - result += " AllTransfer |"; - if ( value & PipelineStageFlagBits2::eBottomOfPipe ) - result += " BottomOfPipe |"; - if ( value & PipelineStageFlagBits2::eHost ) - result += " Host |"; - if ( value & PipelineStageFlagBits2::eAllGraphics ) - result += " AllGraphics |"; - if ( value & PipelineStageFlagBits2::eAllCommands ) - result += " AllCommands |"; - if ( value & PipelineStageFlagBits2::eCopy ) - result += " Copy |"; - if ( value & PipelineStageFlagBits2::eResolve ) - result += " Resolve |"; - if ( value & PipelineStageFlagBits2::eBlit ) - result += " Blit |"; - if ( value & PipelineStageFlagBits2::eClear ) - result += " Clear |"; - if ( value & PipelineStageFlagBits2::eIndexInput ) - result += " IndexInput |"; - if ( value & PipelineStageFlagBits2::eVertexAttributeInput ) - result += " VertexAttributeInput |"; - if ( value & PipelineStageFlagBits2::ePreRasterizationShaders ) - result += " PreRasterizationShaders |"; - if ( value & PipelineStageFlagBits2::eVideoDecodeKHR ) - result += " VideoDecodeKHR |"; - if ( value & PipelineStageFlagBits2::eVideoEncodeKHR ) - result += " VideoEncodeKHR |"; - if ( value & PipelineStageFlagBits2::eTransformFeedbackEXT ) - result += " TransformFeedbackEXT |"; - if ( value & PipelineStageFlagBits2::eConditionalRenderingEXT ) - result += " ConditionalRenderingEXT |"; - if ( value & PipelineStageFlagBits2::eCommandPreprocessEXT ) - result += " CommandPreprocessEXT |"; - if ( value & PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR ) - result += " FragmentShadingRateAttachmentKHR |"; - if ( value & PipelineStageFlagBits2::eAccelerationStructureBuildKHR ) - result += " AccelerationStructureBuildKHR |"; - if ( value & PipelineStageFlagBits2::eRayTracingShaderKHR ) - result += " RayTracingShaderKHR |"; - if ( value & PipelineStageFlagBits2::eFragmentDensityProcessEXT ) - result += " FragmentDensityProcessEXT |"; - if ( value & PipelineStageFlagBits2::eTaskShaderEXT ) - result += " TaskShaderEXT |"; - if ( value & PipelineStageFlagBits2::eMeshShaderEXT ) - result += " MeshShaderEXT |"; - if ( value & PipelineStageFlagBits2::eSubpassShaderHUAWEI ) - result += " SubpassShaderHUAWEI |"; - if ( value & PipelineStageFlagBits2::eInvocationMaskHUAWEI ) - result += " InvocationMaskHUAWEI |"; - if ( value & PipelineStageFlagBits2::eAccelerationStructureCopyKHR ) - result += " AccelerationStructureCopyKHR |"; - if ( value & PipelineStageFlagBits2::eMicromapBuildEXT ) - result += " MicromapBuildEXT |"; - if ( value & PipelineStageFlagBits2::eClusterCullingShaderHUAWEI ) - result += " ClusterCullingShaderHUAWEI |"; - if ( value & PipelineStageFlagBits2::eOpticalFlowNV ) - result += " OpticalFlowNV |"; - if ( value & PipelineStageFlagBits2::eConvertCooperativeVectorMatrixNV ) - result += " ConvertCooperativeVectorMatrixNV |"; - if ( value & PipelineStageFlagBits2::eDataGraphARM ) - result += " DataGraphARM |"; - if ( value & PipelineStageFlagBits2::eCopyIndirectKHR ) - result += " CopyIndirectKHR |"; - if ( value & PipelineStageFlagBits2::eMemoryDecompressionEXT ) - result += " MemoryDecompressionEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "None"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( AccessFlags2 value ) - { - std::string result = "{"; - if ( value & AccessFlagBits2::eIndirectCommandRead ) - result += " IndirectCommandRead |"; - if ( value & AccessFlagBits2::eIndexRead ) - result += " IndexRead |"; - if ( value & AccessFlagBits2::eVertexAttributeRead ) - result += " VertexAttributeRead |"; - if ( value & AccessFlagBits2::eUniformRead ) - result += " UniformRead |"; - if ( value & AccessFlagBits2::eInputAttachmentRead ) - result += " InputAttachmentRead |"; - if ( value & AccessFlagBits2::eShaderRead ) - result += " ShaderRead |"; - if ( value & AccessFlagBits2::eShaderWrite ) - result += " ShaderWrite |"; - if ( value & AccessFlagBits2::eColorAttachmentRead ) - result += " ColorAttachmentRead |"; - if ( value & AccessFlagBits2::eColorAttachmentWrite ) - result += " ColorAttachmentWrite |"; - if ( value & AccessFlagBits2::eDepthStencilAttachmentRead ) - result += " DepthStencilAttachmentRead |"; - if ( value & AccessFlagBits2::eDepthStencilAttachmentWrite ) - result += " DepthStencilAttachmentWrite |"; - if ( value & AccessFlagBits2::eTransferRead ) - result += " TransferRead |"; - if ( value & AccessFlagBits2::eTransferWrite ) - result += " TransferWrite |"; - if ( value & AccessFlagBits2::eHostRead ) - result += " HostRead |"; - if ( value & AccessFlagBits2::eHostWrite ) - result += " HostWrite |"; - if ( value & AccessFlagBits2::eMemoryRead ) - result += " MemoryRead |"; - if ( value & AccessFlagBits2::eMemoryWrite ) - result += " MemoryWrite |"; - if ( value & AccessFlagBits2::eShaderSampledRead ) - result += " ShaderSampledRead |"; - if ( value & AccessFlagBits2::eShaderStorageRead ) - result += " ShaderStorageRead |"; - if ( value & AccessFlagBits2::eShaderStorageWrite ) - result += " ShaderStorageWrite |"; - if ( value & AccessFlagBits2::eVideoDecodeReadKHR ) - result += " VideoDecodeReadKHR |"; - if ( value & AccessFlagBits2::eVideoDecodeWriteKHR ) - result += " VideoDecodeWriteKHR |"; - if ( value & AccessFlagBits2::eSamplerHeapReadEXT ) - result += " SamplerHeapReadEXT |"; - if ( value & AccessFlagBits2::eResourceHeapReadEXT ) - result += " ResourceHeapReadEXT |"; - if ( value & AccessFlagBits2::eVideoEncodeReadKHR ) - result += " VideoEncodeReadKHR |"; - if ( value & AccessFlagBits2::eVideoEncodeWriteKHR ) - result += " VideoEncodeWriteKHR |"; - if ( value & AccessFlagBits2::eShaderTileAttachmentReadQCOM ) - result += " ShaderTileAttachmentReadQCOM |"; - if ( value & AccessFlagBits2::eShaderTileAttachmentWriteQCOM ) - result += " ShaderTileAttachmentWriteQCOM |"; - if ( value & AccessFlagBits2::eTransformFeedbackWriteEXT ) - result += " TransformFeedbackWriteEXT |"; - if ( value & AccessFlagBits2::eTransformFeedbackCounterReadEXT ) - result += " TransformFeedbackCounterReadEXT |"; - if ( value & AccessFlagBits2::eTransformFeedbackCounterWriteEXT ) - result += " TransformFeedbackCounterWriteEXT |"; - if ( value & AccessFlagBits2::eConditionalRenderingReadEXT ) - result += " ConditionalRenderingReadEXT |"; - if ( value & AccessFlagBits2::eCommandPreprocessReadEXT ) - result += " CommandPreprocessReadEXT |"; - if ( value & AccessFlagBits2::eCommandPreprocessWriteEXT ) - result += " CommandPreprocessWriteEXT |"; - if ( value & AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR ) - result += " FragmentShadingRateAttachmentReadKHR |"; - if ( value & AccessFlagBits2::eAccelerationStructureReadKHR ) - result += " AccelerationStructureReadKHR |"; - if ( value & AccessFlagBits2::eAccelerationStructureWriteKHR ) - result += " AccelerationStructureWriteKHR |"; - if ( value & AccessFlagBits2::eFragmentDensityMapReadEXT ) - result += " FragmentDensityMapReadEXT |"; - if ( value & AccessFlagBits2::eColorAttachmentReadNoncoherentEXT ) - result += " ColorAttachmentReadNoncoherentEXT |"; - if ( value & AccessFlagBits2::eDescriptorBufferReadEXT ) - result += " DescriptorBufferReadEXT |"; - if ( value & AccessFlagBits2::eInvocationMaskReadHUAWEI ) - result += " InvocationMaskReadHUAWEI |"; - if ( value & AccessFlagBits2::eShaderBindingTableReadKHR ) - result += " ShaderBindingTableReadKHR |"; - if ( value & AccessFlagBits2::eMicromapReadEXT ) - result += " MicromapReadEXT |"; - if ( value & AccessFlagBits2::eMicromapWriteEXT ) - result += " MicromapWriteEXT |"; - if ( value & AccessFlagBits2::eOpticalFlowReadNV ) - result += " OpticalFlowReadNV |"; - if ( value & AccessFlagBits2::eOpticalFlowWriteNV ) - result += " OpticalFlowWriteNV |"; - if ( value & AccessFlagBits2::eDataGraphReadARM ) - result += " DataGraphReadARM |"; - if ( value & AccessFlagBits2::eDataGraphWriteARM ) - result += " DataGraphWriteARM |"; - if ( value & AccessFlagBits2::eMemoryDecompressionReadEXT ) - result += " MemoryDecompressionReadEXT |"; - if ( value & AccessFlagBits2::eMemoryDecompressionWriteEXT ) - result += " MemoryDecompressionWriteEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "None"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( SubmitFlags value ) - { - std::string result = "{"; - if ( value & SubmitFlagBits::eProtected ) - result += " Protected |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( FormatFeatureFlags2 value ) - { - std::string result = "{"; - if ( value & FormatFeatureFlagBits2::eSampledImage ) - result += " SampledImage |"; - if ( value & FormatFeatureFlagBits2::eStorageImage ) - result += " StorageImage |"; - if ( value & FormatFeatureFlagBits2::eStorageImageAtomic ) - result += " StorageImageAtomic |"; - if ( value & FormatFeatureFlagBits2::eUniformTexelBuffer ) - result += " UniformTexelBuffer |"; - if ( value & FormatFeatureFlagBits2::eStorageTexelBuffer ) - result += " StorageTexelBuffer |"; - if ( value & FormatFeatureFlagBits2::eStorageTexelBufferAtomic ) - result += " StorageTexelBufferAtomic |"; - if ( value & FormatFeatureFlagBits2::eVertexBuffer ) - result += " VertexBuffer |"; - if ( value & FormatFeatureFlagBits2::eColorAttachment ) - result += " ColorAttachment |"; - if ( value & FormatFeatureFlagBits2::eColorAttachmentBlend ) - result += " ColorAttachmentBlend |"; - if ( value & FormatFeatureFlagBits2::eDepthStencilAttachment ) - result += " DepthStencilAttachment |"; - if ( value & FormatFeatureFlagBits2::eBlitSrc ) - result += " BlitSrc |"; - if ( value & FormatFeatureFlagBits2::eBlitDst ) - result += " BlitDst |"; - if ( value & FormatFeatureFlagBits2::eSampledImageFilterLinear ) - result += " SampledImageFilterLinear |"; - if ( value & FormatFeatureFlagBits2::eTransferSrc ) - result += " TransferSrc |"; - if ( value & FormatFeatureFlagBits2::eTransferDst ) - result += " TransferDst |"; - if ( value & FormatFeatureFlagBits2::eSampledImageFilterMinmax ) - result += " SampledImageFilterMinmax |"; - if ( value & FormatFeatureFlagBits2::eMidpointChromaSamples ) - result += " MidpointChromaSamples |"; - if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter ) - result += " SampledImageYcbcrConversionLinearFilter |"; - if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter ) - result += " SampledImageYcbcrConversionSeparateReconstructionFilter |"; - if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit ) - result += " SampledImageYcbcrConversionChromaReconstructionExplicit |"; - if ( value & FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable ) - result += " SampledImageYcbcrConversionChromaReconstructionExplicitForceable |"; - if ( value & FormatFeatureFlagBits2::eDisjoint ) - result += " Disjoint |"; - if ( value & FormatFeatureFlagBits2::eCositedChromaSamples ) - result += " CositedChromaSamples |"; - if ( value & FormatFeatureFlagBits2::eStorageReadWithoutFormat ) - result += " StorageReadWithoutFormat |"; - if ( value & FormatFeatureFlagBits2::eStorageWriteWithoutFormat ) - result += " StorageWriteWithoutFormat |"; - if ( value & FormatFeatureFlagBits2::eSampledImageDepthComparison ) - result += " SampledImageDepthComparison |"; - if ( value & FormatFeatureFlagBits2::eSampledImageFilterCubic ) - result += " SampledImageFilterCubic |"; - if ( value & FormatFeatureFlagBits2::eHostImageTransfer ) - result += " HostImageTransfer |"; - if ( value & FormatFeatureFlagBits2::eVideoDecodeOutputKHR ) - result += " VideoDecodeOutputKHR |"; - if ( value & FormatFeatureFlagBits2::eVideoDecodeDpbKHR ) - result += " VideoDecodeDpbKHR |"; - if ( value & FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR ) - result += " AccelerationStructureVertexBufferKHR |"; - if ( value & FormatFeatureFlagBits2::eFragmentDensityMapEXT ) - result += " FragmentDensityMapEXT |"; - if ( value & FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR ) - result += " FragmentShadingRateAttachmentKHR |"; - if ( value & FormatFeatureFlagBits2::eVideoEncodeInputKHR ) - result += " VideoEncodeInputKHR |"; - if ( value & FormatFeatureFlagBits2::eVideoEncodeDpbKHR ) - result += " VideoEncodeDpbKHR |"; - if ( value & FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV ) - result += " AccelerationStructureRadiusBufferNV |"; - if ( value & FormatFeatureFlagBits2::eLinearColorAttachmentNV ) - result += " LinearColorAttachmentNV |"; - if ( value & FormatFeatureFlagBits2::eWeightImageQCOM ) - result += " WeightImageQCOM |"; - if ( value & FormatFeatureFlagBits2::eWeightSampledImageQCOM ) - result += " WeightSampledImageQCOM |"; - if ( value & FormatFeatureFlagBits2::eBlockMatchingQCOM ) - result += " BlockMatchingQCOM |"; - if ( value & FormatFeatureFlagBits2::eBoxFilterSampledQCOM ) - result += " BoxFilterSampledQCOM |"; - if ( value & FormatFeatureFlagBits2::eTensorShaderARM ) - result += " TensorShaderARM |"; - if ( value & FormatFeatureFlagBits2::eTensorImageAliasingARM ) - result += " TensorImageAliasingARM |"; - if ( value & FormatFeatureFlagBits2::eOpticalFlowImageNV ) - result += " OpticalFlowImageNV |"; - if ( value & FormatFeatureFlagBits2::eOpticalFlowVectorNV ) - result += " OpticalFlowVectorNV |"; - if ( value & FormatFeatureFlagBits2::eOpticalFlowCostNV ) - result += " OpticalFlowCostNV |"; - if ( value & FormatFeatureFlagBits2::eTensorDataGraphARM ) - result += " TensorDataGraphARM |"; - if ( value & FormatFeatureFlagBits2::eCopyImageIndirectDstKHR ) - result += " CopyImageIndirectDstKHR |"; - if ( value & FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR ) - result += " VideoEncodeQuantizationDeltaMapKHR |"; - if ( value & FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR ) - result += " VideoEncodeEmphasisMapKHR |"; - if ( value & FormatFeatureFlagBits2::eDepthCopyOnComputeQueueKHR ) - result += " DepthCopyOnComputeQueueKHR |"; - if ( value & FormatFeatureFlagBits2::eDepthCopyOnTransferQueueKHR ) - result += " DepthCopyOnTransferQueueKHR |"; - if ( value & FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR ) - result += " StencilCopyOnComputeQueueKHR |"; - if ( value & FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR ) - result += " StencilCopyOnTransferQueueKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( PipelineCreationFeedbackFlags value ) - { - std::string result = "{"; - if ( value & PipelineCreationFeedbackFlagBits::eValid ) - result += " Valid |"; - if ( value & PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit ) - result += " ApplicationPipelineCacheHit |"; - if ( value & PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration ) - result += " BasePipelineAcceleration |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( RenderingFlags value ) - { - std::string result = "{"; - if ( value & RenderingFlagBits::eContentsSecondaryCommandBuffers ) - result += " ContentsSecondaryCommandBuffers |"; - if ( value & RenderingFlagBits::eSuspending ) - result += " Suspending |"; - if ( value & RenderingFlagBits::eResuming ) - result += " Resuming |"; - if ( value & RenderingFlagBits::eEnableLegacyDitheringEXT ) - result += " EnableLegacyDitheringEXT |"; - if ( value & RenderingFlagBits::eContentsInlineKHR ) - result += " ContentsInlineKHR |"; - if ( value & RenderingFlagBits::ePerLayerFragmentDensityVALVE ) - result += " PerLayerFragmentDensityVALVE |"; - if ( value & RenderingFlagBits::eFragmentRegionEXT ) - result += " FragmentRegionEXT |"; - if ( value & RenderingFlagBits::eCustomResolveEXT ) - result += " CustomResolveEXT |"; - if ( value & RenderingFlagBits::eLocalReadConcurrentAccessControlKHR ) - result += " LocalReadConcurrentAccessControlKHR |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_VERSION_1_4 === - - VULKAN_HPP_INLINE std::string to_string( MemoryUnmapFlags value ) - { - std::string result = "{"; - if ( value & MemoryUnmapFlagBits::eReserveEXT ) - result += " ReserveEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( BufferUsageFlags2 value ) - { - std::string result = "{"; - if ( value & BufferUsageFlagBits2::eTransferSrc ) - result += " TransferSrc |"; - if ( value & BufferUsageFlagBits2::eTransferDst ) - result += " TransferDst |"; - if ( value & BufferUsageFlagBits2::eUniformTexelBuffer ) - result += " UniformTexelBuffer |"; - if ( value & BufferUsageFlagBits2::eStorageTexelBuffer ) - result += " StorageTexelBuffer |"; - if ( value & BufferUsageFlagBits2::eUniformBuffer ) - result += " UniformBuffer |"; - if ( value & BufferUsageFlagBits2::eStorageBuffer ) - result += " StorageBuffer |"; - if ( value & BufferUsageFlagBits2::eIndexBuffer ) - result += " IndexBuffer |"; - if ( value & BufferUsageFlagBits2::eVertexBuffer ) - result += " VertexBuffer |"; - if ( value & BufferUsageFlagBits2::eIndirectBuffer ) - result += " IndirectBuffer |"; - if ( value & BufferUsageFlagBits2::eShaderDeviceAddress ) - result += " ShaderDeviceAddress |"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & BufferUsageFlagBits2::eExecutionGraphScratchAMDX ) - result += " ExecutionGraphScratchAMDX |"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - if ( value & BufferUsageFlagBits2::eDescriptorHeapEXT ) - result += " DescriptorHeapEXT |"; - if ( value & BufferUsageFlagBits2::eConditionalRenderingEXT ) - result += " ConditionalRenderingEXT |"; - if ( value & BufferUsageFlagBits2::eShaderBindingTableKHR ) - result += " ShaderBindingTableKHR |"; - if ( value & BufferUsageFlagBits2::eTransformFeedbackBufferEXT ) - result += " TransformFeedbackBufferEXT |"; - if ( value & BufferUsageFlagBits2::eTransformFeedbackCounterBufferEXT ) - result += " TransformFeedbackCounterBufferEXT |"; - if ( value & BufferUsageFlagBits2::eVideoDecodeSrcKHR ) - result += " VideoDecodeSrcKHR |"; - if ( value & BufferUsageFlagBits2::eVideoDecodeDstKHR ) - result += " VideoDecodeDstKHR |"; - if ( value & BufferUsageFlagBits2::eVideoEncodeDstKHR ) - result += " VideoEncodeDstKHR |"; - if ( value & BufferUsageFlagBits2::eVideoEncodeSrcKHR ) - result += " VideoEncodeSrcKHR |"; - if ( value & BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR ) - result += " AccelerationStructureBuildInputReadOnlyKHR |"; - if ( value & BufferUsageFlagBits2::eAccelerationStructureStorageKHR ) - result += " AccelerationStructureStorageKHR |"; - if ( value & BufferUsageFlagBits2::eSamplerDescriptorBufferEXT ) - result += " SamplerDescriptorBufferEXT |"; - if ( value & BufferUsageFlagBits2::eResourceDescriptorBufferEXT ) - result += " ResourceDescriptorBufferEXT |"; - if ( value & BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT ) - result += " PushDescriptorsDescriptorBufferEXT |"; - if ( value & BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT ) - result += " MicromapBuildInputReadOnlyEXT |"; - if ( value & BufferUsageFlagBits2::eMicromapStorageEXT ) - result += " MicromapStorageEXT |"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & BufferUsageFlagBits2::eCompressedDataDgf1AMDX ) - result += " CompressedDataDgf1AMDX |"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - if ( value & BufferUsageFlagBits2::eDataGraphForeignDescriptorARM ) - result += " DataGraphForeignDescriptorARM |"; - if ( value & BufferUsageFlagBits2::eTileMemoryQCOM ) - result += " TileMemoryQCOM |"; - if ( value & BufferUsageFlagBits2::eMemoryDecompressionEXT ) - result += " MemoryDecompressionEXT |"; - if ( value & BufferUsageFlagBits2::ePreprocessBufferEXT ) - result += " PreprocessBufferEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( HostImageCopyFlags value ) - { - std::string result = "{"; - if ( value & HostImageCopyFlagBits::eMemcpy ) - result += " Memcpy |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( PipelineCreateFlags2 value ) - { - std::string result = "{"; - if ( value & PipelineCreateFlagBits2::eDisableOptimization ) - result += " DisableOptimization |"; - if ( value & PipelineCreateFlagBits2::eAllowDerivatives ) - result += " AllowDerivatives |"; - if ( value & PipelineCreateFlagBits2::eDerivative ) - result += " Derivative |"; - if ( value & PipelineCreateFlagBits2::eViewIndexFromDeviceIndex ) - result += " ViewIndexFromDeviceIndex |"; - if ( value & PipelineCreateFlagBits2::eDispatchBase ) - result += " DispatchBase |"; - if ( value & PipelineCreateFlagBits2::eFailOnPipelineCompileRequired ) - result += " FailOnPipelineCompileRequired |"; - if ( value & PipelineCreateFlagBits2::eEarlyReturnOnFailure ) - result += " EarlyReturnOnFailure |"; - if ( value & PipelineCreateFlagBits2::eNoProtectedAccess ) - result += " NoProtectedAccess |"; - if ( value & PipelineCreateFlagBits2::eProtectedAccessOnly ) - result += " ProtectedAccessOnly |"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & PipelineCreateFlagBits2::eExecutionGraphAMDX ) - result += " ExecutionGraphAMDX |"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - if ( value & PipelineCreateFlagBits2::eDescriptorHeapEXT ) - result += " DescriptorHeapEXT |"; - if ( value & PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV ) - result += " RayTracingAllowSpheresAndLinearSweptSpheresNV |"; - if ( value & PipelineCreateFlagBits2::eEnableLegacyDitheringEXT ) - result += " EnableLegacyDitheringEXT |"; - if ( value & PipelineCreateFlagBits2::eDeferCompileNV ) - result += " DeferCompileNV |"; - if ( value & PipelineCreateFlagBits2::eCaptureStatisticsKHR ) - result += " CaptureStatisticsKHR |"; - if ( value & PipelineCreateFlagBits2::eCaptureInternalRepresentationsKHR ) - result += " CaptureInternalRepresentationsKHR |"; - if ( value & PipelineCreateFlagBits2::eLinkTimeOptimizationEXT ) - result += " LinkTimeOptimizationEXT |"; - if ( value & PipelineCreateFlagBits2::eRetainLinkTimeOptimizationInfoEXT ) - result += " RetainLinkTimeOptimizationInfoEXT |"; - if ( value & PipelineCreateFlagBits2::eLibraryKHR ) - result += " LibraryKHR |"; - if ( value & PipelineCreateFlagBits2::eRayTracingSkipTrianglesKHR ) - result += " RayTracingSkipTrianglesKHR |"; - if ( value & PipelineCreateFlagBits2::eRayTracingSkipAabbsKHR ) - result += " RayTracingSkipAabbsKHR |"; - if ( value & PipelineCreateFlagBits2::eRayTracingNoNullAnyHitShadersKHR ) - result += " RayTracingNoNullAnyHitShadersKHR |"; - if ( value & PipelineCreateFlagBits2::eRayTracingNoNullClosestHitShadersKHR ) - result += " RayTracingNoNullClosestHitShadersKHR |"; - if ( value & PipelineCreateFlagBits2::eRayTracingNoNullMissShadersKHR ) - result += " RayTracingNoNullMissShadersKHR |"; - if ( value & PipelineCreateFlagBits2::eRayTracingNoNullIntersectionShadersKHR ) - result += " RayTracingNoNullIntersectionShadersKHR |"; - if ( value & PipelineCreateFlagBits2::eRayTracingShaderGroupHandleCaptureReplayKHR ) - result += " RayTracingShaderGroupHandleCaptureReplayKHR |"; - if ( value & PipelineCreateFlagBits2::eIndirectBindableNV ) - result += " IndirectBindableNV |"; - if ( value & PipelineCreateFlagBits2::eRayTracingAllowMotionNV ) - result += " RayTracingAllowMotionNV |"; - if ( value & PipelineCreateFlagBits2::eRenderingFragmentShadingRateAttachmentKHR ) - result += " RenderingFragmentShadingRateAttachmentKHR |"; - if ( value & PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT ) - result += " RenderingFragmentDensityMapAttachmentEXT |"; - if ( value & PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT ) - result += " RayTracingOpacityMicromapEXT |"; - if ( value & PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT ) - result += " ColorAttachmentFeedbackLoopEXT |"; - if ( value & PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT ) - result += " DepthStencilAttachmentFeedbackLoopEXT |"; - if ( value & PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV ) - result += " RayTracingDisplacementMicromapNV |"; - if ( value & PipelineCreateFlagBits2::eDescriptorBufferEXT ) - result += " DescriptorBufferEXT |"; - if ( value & PipelineCreateFlagBits2::eDisallowOpacityMicromapARM ) - result += " DisallowOpacityMicromapARM |"; - if ( value & PipelineCreateFlagBits2::eCaptureDataKHR ) - result += " CaptureDataKHR |"; - if ( value & PipelineCreateFlagBits2::eIndirectBindableEXT ) - result += " IndirectBindableEXT |"; - if ( value & PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE ) - result += " PerLayerFragmentDensityVALVE |"; - if ( value & PipelineCreateFlagBits2::e64BitIndexingEXT ) - result += " 64BitIndexingEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_KHR_surface === - - VULKAN_HPP_INLINE std::string to_string( CompositeAlphaFlagsKHR value ) - { - std::string result = "{"; - if ( value & CompositeAlphaFlagBitsKHR::eOpaque ) - result += " Opaque |"; - if ( value & CompositeAlphaFlagBitsKHR::ePreMultiplied ) - result += " PreMultiplied |"; - if ( value & CompositeAlphaFlagBitsKHR::ePostMultiplied ) - result += " PostMultiplied |"; - if ( value & CompositeAlphaFlagBitsKHR::eInherit ) - result += " Inherit |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_KHR_swapchain === - - VULKAN_HPP_INLINE std::string to_string( SwapchainCreateFlagsKHR value ) - { - std::string result = "{"; - if ( value & SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions ) - result += " SplitInstanceBindRegions |"; - if ( value & SwapchainCreateFlagBitsKHR::eProtected ) - result += " Protected |"; - if ( value & SwapchainCreateFlagBitsKHR::eMutableFormat ) - result += " MutableFormat |"; - if ( value & SwapchainCreateFlagBitsKHR::ePresentTimingEXT ) - result += " PresentTimingEXT |"; - if ( value & SwapchainCreateFlagBitsKHR::ePresentId2 ) - result += " PresentId2 |"; - if ( value & SwapchainCreateFlagBitsKHR::ePresentWait2 ) - result += " PresentWait2 |"; - if ( value & SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocation ) - result += " DeferredMemoryAllocation |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( DeviceGroupPresentModeFlagsKHR value ) - { - std::string result = "{"; - if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocal ) - result += " Local |"; - if ( value & DeviceGroupPresentModeFlagBitsKHR::eRemote ) - result += " Remote |"; - if ( value & DeviceGroupPresentModeFlagBitsKHR::eSum ) - result += " Sum |"; - if ( value & DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice ) - result += " LocalMultiDevice |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_KHR_display === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayModeCreateFlagsKHR ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( DisplayPlaneAlphaFlagsKHR value ) - { - std::string result = "{"; - if ( value & DisplayPlaneAlphaFlagBitsKHR::eOpaque ) - result += " Opaque |"; - if ( value & DisplayPlaneAlphaFlagBitsKHR::eGlobal ) - result += " Global |"; - if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixel ) - result += " PerPixel |"; - if ( value & DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied ) - result += " PerPixelPremultiplied |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplaySurfaceCreateFlagsKHR ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( SurfaceTransformFlagsKHR value ) - { - std::string result = "{"; - if ( value & SurfaceTransformFlagBitsKHR::eIdentity ) - result += " Identity |"; - if ( value & SurfaceTransformFlagBitsKHR::eRotate90 ) - result += " Rotate90 |"; - if ( value & SurfaceTransformFlagBitsKHR::eRotate180 ) - result += " Rotate180 |"; - if ( value & SurfaceTransformFlagBitsKHR::eRotate270 ) - result += " Rotate270 |"; - if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirror ) - result += " HorizontalMirror |"; - if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 ) - result += " HorizontalMirrorRotate90 |"; - if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180 ) - result += " HorizontalMirrorRotate180 |"; - if ( value & SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270 ) - result += " HorizontalMirrorRotate270 |"; - if ( value & SurfaceTransformFlagBitsKHR::eInherit ) - result += " Inherit |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XlibSurfaceCreateFlagsKHR ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XcbSurfaceCreateFlagsKHR ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( WaylandSurfaceCreateFlagsKHR ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AndroidSurfaceCreateFlagsKHR ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Win32SurfaceCreateFlagsKHR ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - - VULKAN_HPP_INLINE std::string to_string( DebugReportFlagsEXT value ) - { - std::string result = "{"; - if ( value & DebugReportFlagBitsEXT::eInformation ) - result += " Information |"; - if ( value & DebugReportFlagBitsEXT::eWarning ) - result += " Warning |"; - if ( value & DebugReportFlagBitsEXT::ePerformanceWarning ) - result += " PerformanceWarning |"; - if ( value & DebugReportFlagBitsEXT::eError ) - result += " Error |"; - if ( value & DebugReportFlagBitsEXT::eDebug ) - result += " Debug |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_KHR_video_queue === - - VULKAN_HPP_INLINE std::string to_string( VideoCodecOperationFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoCodecOperationFlagBitsKHR::eEncodeH264 ) - result += " EncodeH264 |"; - if ( value & VideoCodecOperationFlagBitsKHR::eEncodeH265 ) - result += " EncodeH265 |"; - if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH264 ) - result += " DecodeH264 |"; - if ( value & VideoCodecOperationFlagBitsKHR::eDecodeH265 ) - result += " DecodeH265 |"; - if ( value & VideoCodecOperationFlagBitsKHR::eDecodeAv1 ) - result += " DecodeAv1 |"; - if ( value & VideoCodecOperationFlagBitsKHR::eEncodeAv1 ) - result += " EncodeAv1 |"; - if ( value & VideoCodecOperationFlagBitsKHR::eDecodeVp9 ) - result += " DecodeVp9 |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "None"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoChromaSubsamplingFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoChromaSubsamplingFlagBitsKHR::eMonochrome ) - result += " Monochrome |"; - if ( value & VideoChromaSubsamplingFlagBitsKHR::e420 ) - result += " 420 |"; - if ( value & VideoChromaSubsamplingFlagBitsKHR::e422 ) - result += " 422 |"; - if ( value & VideoChromaSubsamplingFlagBitsKHR::e444 ) - result += " 444 |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "Invalid"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoComponentBitDepthFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoComponentBitDepthFlagBitsKHR::e8 ) - result += " 8 |"; - if ( value & VideoComponentBitDepthFlagBitsKHR::e10 ) - result += " 10 |"; - if ( value & VideoComponentBitDepthFlagBitsKHR::e12 ) - result += " 12 |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "Invalid"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoCapabilityFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoCapabilityFlagBitsKHR::eProtectedContent ) - result += " ProtectedContent |"; - if ( value & VideoCapabilityFlagBitsKHR::eSeparateReferenceImages ) - result += " SeparateReferenceImages |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoSessionCreateFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoSessionCreateFlagBitsKHR::eProtectedContent ) - result += " ProtectedContent |"; - if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations ) - result += " AllowEncodeParameterOptimizations |"; - if ( value & VideoSessionCreateFlagBitsKHR::eInlineQueries ) - result += " InlineQueries |"; - if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap ) - result += " AllowEncodeQuantizationDeltaMap |"; - if ( value & VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap ) - result += " AllowEncodeEmphasisMap |"; - if ( value & VideoSessionCreateFlagBitsKHR::eInlineSessionParameters ) - result += " InlineSessionParameters |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoSessionParametersCreateFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible ) - result += " QuantizationMapCompatible |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoBeginCodingFlagsKHR ) - { - return "{}"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEndCodingFlagsKHR ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( VideoCodingControlFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoCodingControlFlagBitsKHR::eReset ) - result += " Reset |"; - if ( value & VideoCodingControlFlagBitsKHR::eEncodeRateControl ) - result += " EncodeRateControl |"; - if ( value & VideoCodingControlFlagBitsKHR::eEncodeQualityLevel ) - result += " EncodeQualityLevel |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_KHR_video_decode_queue === - - VULKAN_HPP_INLINE std::string to_string( VideoDecodeCapabilityFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide ) - result += " DpbAndOutputCoincide |"; - if ( value & VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct ) - result += " DpbAndOutputDistinct |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoDecodeUsageFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoDecodeUsageFlagBitsKHR::eTranscoding ) - result += " Transcoding |"; - if ( value & VideoDecodeUsageFlagBitsKHR::eOffline ) - result += " Offline |"; - if ( value & VideoDecodeUsageFlagBitsKHR::eStreaming ) - result += " Streaming |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "Default"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeFlagsKHR ) - { - return "{}"; - } - - //=== VK_EXT_transform_feedback === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateStreamCreateFlagsEXT ) - { - return "{}"; - } - - //=== VK_KHR_video_encode_h264 === - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264CapabilityFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eHrdCompliance ) - result += " HrdCompliance |"; - if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePredictionWeightTableGenerated ) - result += " PredictionWeightTableGenerated |"; - if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eRowUnalignedSlice ) - result += " RowUnalignedSlice |"; - if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eDifferentSliceType ) - result += " DifferentSliceType |"; - if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL0List ) - result += " BFrameInL0List |"; - if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL1List ) - result += " BFrameInL1List |"; - if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp ) - result += " PerPictureTypeMinMaxQp |"; - if ( value & VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp ) - result += " PerSliceConstantQp |"; - if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu ) - result += " GeneratePrefixNalu |"; - if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eBPictureIntraRefresh ) - result += " BPictureIntraRefresh |"; - if ( value & VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound ) - result += " MbQpDiffWraparound |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264StdFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eSeparateColorPlaneFlagSet ) - result += " SeparateColorPlaneFlagSet |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eQpprimeYZeroTransformBypassFlagSet ) - result += " QpprimeYZeroTransformBypassFlagSet |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eScalingMatrixPresentFlagSet ) - result += " ScalingMatrixPresentFlagSet |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eChromaQpIndexOffset ) - result += " ChromaQpIndexOffset |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eSecondChromaQpIndexOffset ) - result += " SecondChromaQpIndexOffset |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::ePicInitQpMinus26 ) - result += " PicInitQpMinus26 |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedPredFlagSet ) - result += " WeightedPredFlagSet |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcExplicit ) - result += " WeightedBipredIdcExplicit |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcImplicit ) - result += " WeightedBipredIdcImplicit |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eTransform8X8ModeFlagSet ) - result += " Transform8X8ModeFlagSet |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eDirectSpatialMvPredFlagUnset ) - result += " DirectSpatialMvPredFlagUnset |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagUnset ) - result += " EntropyCodingModeFlagUnset |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagSet ) - result += " EntropyCodingModeFlagSet |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eDirect8X8InferenceFlagUnset ) - result += " Direct8X8InferenceFlagUnset |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eConstrainedIntraPredFlagSet ) - result += " ConstrainedIntraPredFlagSet |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterDisabled ) - result += " DeblockingFilterDisabled |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterEnabled ) - result += " DeblockingFilterEnabled |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterPartial ) - result += " DeblockingFilterPartial |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eSliceQpDelta ) - result += " SliceQpDelta |"; - if ( value & VideoEncodeH264StdFlagBitsKHR::eDifferentSliceQpDelta ) - result += " DifferentSliceQpDelta |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH264RateControlFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeH264RateControlFlagBitsKHR::eAttemptHrdCompliance ) - result += " AttemptHrdCompliance |"; - if ( value & VideoEncodeH264RateControlFlagBitsKHR::eRegularGop ) - result += " RegularGop |"; - if ( value & VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternFlat ) - result += " ReferencePatternFlat |"; - if ( value & VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternDyadic ) - result += " ReferencePatternDyadic |"; - if ( value & VideoEncodeH264RateControlFlagBitsKHR::eTemporalLayerPatternDyadic ) - result += " TemporalLayerPatternDyadic |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_KHR_video_encode_h265 === - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CapabilityFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eHrdCompliance ) - result += " HrdCompliance |"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePredictionWeightTableGenerated ) - result += " PredictionWeightTableGenerated |"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eRowUnalignedSliceSegment ) - result += " RowUnalignedSliceSegment |"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eDifferentSliceSegmentType ) - result += " DifferentSliceSegmentType |"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL0List ) - result += " BFrameInL0List |"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL1List ) - result += " BFrameInL1List |"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp ) - result += " PerPictureTypeMinMaxQp |"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::ePerSliceSegmentConstantQp ) - result += " PerSliceSegmentConstantQp |"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eMultipleTilesPerSliceSegment ) - result += " MultipleTilesPerSliceSegment |"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile ) - result += " MultipleSliceSegmentsPerTile |"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eBPictureIntraRefresh ) - result += " BPictureIntraRefresh |"; - if ( value & VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound ) - result += " CuQpDiffWraparound |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265StdFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eSeparateColorPlaneFlagSet ) - result += " SeparateColorPlaneFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eSampleAdaptiveOffsetEnabledFlagSet ) - result += " SampleAdaptiveOffsetEnabledFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eScalingListDataPresentFlagSet ) - result += " ScalingListDataPresentFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::ePcmEnabledFlagSet ) - result += " PcmEnabledFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eSpsTemporalMvpEnabledFlagSet ) - result += " SpsTemporalMvpEnabledFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eInitQpMinus26 ) - result += " InitQpMinus26 |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eWeightedPredFlagSet ) - result += " WeightedPredFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eWeightedBipredFlagSet ) - result += " WeightedBipredFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eLog2ParallelMergeLevelMinus2 ) - result += " Log2ParallelMergeLevelMinus2 |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eSignDataHidingEnabledFlagSet ) - result += " SignDataHidingEnabledFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagSet ) - result += " TransformSkipEnabledFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagUnset ) - result += " TransformSkipEnabledFlagUnset |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::ePpsSliceChromaQpOffsetsPresentFlagSet ) - result += " PpsSliceChromaQpOffsetsPresentFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eTransquantBypassEnabledFlagSet ) - result += " TransquantBypassEnabledFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eConstrainedIntraPredFlagSet ) - result += " ConstrainedIntraPredFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eEntropyCodingSyncEnabledFlagSet ) - result += " EntropyCodingSyncEnabledFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eDeblockingFilterOverrideEnabledFlagSet ) - result += " DeblockingFilterOverrideEnabledFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentsEnabledFlagSet ) - result += " DependentSliceSegmentsEnabledFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentFlagSet ) - result += " DependentSliceSegmentFlagSet |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eSliceQpDelta ) - result += " SliceQpDelta |"; - if ( value & VideoEncodeH265StdFlagBitsKHR::eDifferentSliceQpDelta ) - result += " DifferentSliceQpDelta |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265CtbSizeFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e16 ) - result += " 16 |"; - if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e32 ) - result += " 32 |"; - if ( value & VideoEncodeH265CtbSizeFlagBitsKHR::e64 ) - result += " 64 |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265TransformBlockSizeFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e4 ) - result += " 4 |"; - if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e8 ) - result += " 8 |"; - if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e16 ) - result += " 16 |"; - if ( value & VideoEncodeH265TransformBlockSizeFlagBitsKHR::e32 ) - result += " 32 |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeH265RateControlFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeH265RateControlFlagBitsKHR::eAttemptHrdCompliance ) - result += " AttemptHrdCompliance |"; - if ( value & VideoEncodeH265RateControlFlagBitsKHR::eRegularGop ) - result += " RegularGop |"; - if ( value & VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternFlat ) - result += " ReferencePatternFlat |"; - if ( value & VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternDyadic ) - result += " ReferencePatternDyadic |"; - if ( value & VideoEncodeH265RateControlFlagBitsKHR::eTemporalSubLayerPatternDyadic ) - result += " TemporalSubLayerPatternDyadic |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_KHR_video_decode_h264 === - - VULKAN_HPP_INLINE std::string to_string( VideoDecodeH264PictureLayoutFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines ) - result += " InterlacedInterleavedLines |"; - if ( value & VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes ) - result += " InterlacedSeparatePlanes |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "Progressive"; - return result; - } - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StreamDescriptorSurfaceCreateFlagsGGP ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - - VULKAN_HPP_INLINE std::string to_string( ExternalMemoryHandleTypeFlagsNV value ) - { - std::string result = "{"; - if ( value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 ) - result += " OpaqueWin32 |"; - if ( value & ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt ) - result += " OpaqueWin32Kmt |"; - if ( value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image ) - result += " D3D11Image |"; - if ( value & ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt ) - result += " D3D11ImageKmt |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ExternalMemoryFeatureFlagsNV value ) - { - std::string result = "{"; - if ( value & ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly ) - result += " DedicatedOnly |"; - if ( value & ExternalMemoryFeatureFlagBitsNV::eExportable ) - result += " Exportable |"; - if ( value & ExternalMemoryFeatureFlagBitsNV::eImportable ) - result += " Importable |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ViSurfaceCreateFlagsNN ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_EXT_conditional_rendering === - - VULKAN_HPP_INLINE std::string to_string( ConditionalRenderingFlagsEXT value ) - { - std::string result = "{"; - if ( value & ConditionalRenderingFlagBitsEXT::eInverted ) - result += " Inverted |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_EXT_display_surface_counter === - - VULKAN_HPP_INLINE std::string to_string( SurfaceCounterFlagsEXT value ) - { - std::string result = "{"; - if ( value & SurfaceCounterFlagBitsEXT::eVblank ) - result += " Vblank |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_NV_viewport_swizzle === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportSwizzleStateCreateFlagsNV ) - { - return "{}"; - } - - //=== VK_EXT_discard_rectangles === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDiscardRectangleStateCreateFlagsEXT ) - { - return "{}"; - } - - //=== VK_EXT_conservative_rasterization === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationConservativeStateCreateFlagsEXT ) - { - return "{}"; - } - - //=== VK_EXT_depth_clip_enable === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationDepthClipStateCreateFlagsEXT ) - { - return "{}"; - } - - //=== VK_KHR_performance_query === - - VULKAN_HPP_INLINE std::string to_string( PerformanceCounterDescriptionFlagsKHR value ) - { - std::string result = "{"; - if ( value & PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting ) - result += " PerformanceImpacting |"; - if ( value & PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted ) - result += " ConcurrentlyImpacted |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AcquireProfilingLockFlagsKHR ) - { - return "{}"; - } - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IOSSurfaceCreateFlagsMVK ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MacOSSurfaceCreateFlagsMVK ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - - VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageSeverityFlagsEXT value ) - { - std::string result = "{"; - if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eVerbose ) - result += " Verbose |"; - if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eInfo ) - result += " Info |"; - if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eWarning ) - result += " Warning |"; - if ( value & DebugUtilsMessageSeverityFlagBitsEXT::eError ) - result += " Error |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( DebugUtilsMessageTypeFlagsEXT value ) - { - std::string result = "{"; - if ( value & DebugUtilsMessageTypeFlagBitsEXT::eGeneral ) - result += " General |"; - if ( value & DebugUtilsMessageTypeFlagBitsEXT::eValidation ) - result += " Validation |"; - if ( value & DebugUtilsMessageTypeFlagBitsEXT::ePerformance ) - result += " Performance |"; - if ( value & DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding ) - result += " DeviceAddressBinding |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCallbackDataFlagsEXT ) - { - return "{}"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCreateFlagsEXT ) - { - return "{}"; - } - - //=== VK_EXT_descriptor_heap === - - VULKAN_HPP_INLINE std::string to_string( SpirvResourceTypeFlagsEXT value ) - { - std::string result = "{"; - if ( value & SpirvResourceTypeFlagBitsEXT::eSampler ) - result += " Sampler |"; - if ( value & SpirvResourceTypeFlagBitsEXT::eSampledImage ) - result += " SampledImage |"; - if ( value & SpirvResourceTypeFlagBitsEXT::eReadOnlyImage ) - result += " ReadOnlyImage |"; - if ( value & SpirvResourceTypeFlagBitsEXT::eReadWriteImage ) - result += " ReadWriteImage |"; - if ( value & SpirvResourceTypeFlagBitsEXT::eCombinedSampledImage ) - result += " CombinedSampledImage |"; - if ( value & SpirvResourceTypeFlagBitsEXT::eUniformBuffer ) - result += " UniformBuffer |"; - if ( value & SpirvResourceTypeFlagBitsEXT::eReadOnlyStorageBuffer ) - result += " ReadOnlyStorageBuffer |"; - if ( value & SpirvResourceTypeFlagBitsEXT::eReadWriteStorageBuffer ) - result += " ReadWriteStorageBuffer |"; - if ( value & SpirvResourceTypeFlagBitsEXT::eAccelerationStructure ) - result += " AccelerationStructure |"; - if ( value & SpirvResourceTypeFlagBitsEXT::eTensorARM ) - result += " TensorARM |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( TensorViewCreateFlagsARM value ) - { - std::string result = "{"; - if ( value & TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay ) - result += " DescriptorBufferCaptureReplay |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_NV_fragment_coverage_to_color === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageToColorStateCreateFlagsNV ) - { - return "{}"; - } - - //=== VK_KHR_acceleration_structure === - - VULKAN_HPP_INLINE std::string to_string( GeometryFlagsKHR value ) - { - std::string result = "{"; - if ( value & GeometryFlagBitsKHR::eOpaque ) - result += " Opaque |"; - if ( value & GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation ) - result += " NoDuplicateAnyHitInvocation |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( GeometryInstanceFlagsKHR value ) - { - std::string result = "{"; - if ( value & GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable ) - result += " TriangleFacingCullDisable |"; - if ( value & GeometryInstanceFlagBitsKHR::eTriangleFlipFacing ) - result += " TriangleFlipFacing |"; - if ( value & GeometryInstanceFlagBitsKHR::eForceOpaque ) - result += " ForceOpaque |"; - if ( value & GeometryInstanceFlagBitsKHR::eForceNoOpaque ) - result += " ForceNoOpaque |"; - if ( value & GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT ) - result += " ForceOpacityMicromap2StateEXT |"; - if ( value & GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT ) - result += " DisableOpacityMicromapsEXT |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( BuildAccelerationStructureFlagsKHR value ) - { - std::string result = "{"; - if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowUpdate ) - result += " AllowUpdate |"; - if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowCompaction ) - result += " AllowCompaction |"; - if ( value & BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace ) - result += " PreferFastTrace |"; - if ( value & BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild ) - result += " PreferFastBuild |"; - if ( value & BuildAccelerationStructureFlagBitsKHR::eLowMemory ) - result += " LowMemory |"; - if ( value & BuildAccelerationStructureFlagBitsKHR::eMotionNV ) - result += " MotionNV |"; - if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT ) - result += " AllowOpacityMicromapUpdateEXT |"; - if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT ) - result += " AllowDisableOpacityMicromapsEXT |"; - if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT ) - result += " AllowOpacityMicromapDataUpdateEXT |"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV ) - result += " AllowDisplacementMicromapUpdateNV |"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess ) - result += " AllowDataAccess |"; - if ( value & BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV ) - result += " AllowClusterOpacityMicromapsNV |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( AccelerationStructureCreateFlagsKHR value ) - { - std::string result = "{"; - if ( value & AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay ) - result += " DeviceAddressCaptureReplay |"; - if ( value & AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT ) - result += " DescriptorBufferCaptureReplayEXT |"; - if ( value & AccelerationStructureCreateFlagBitsKHR::eMotionNV ) - result += " MotionNV |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_NV_framebuffer_mixed_samples === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageModulationStateCreateFlagsNV ) - { - return "{}"; - } - - //=== VK_EXT_validation_cache === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCacheCreateFlagsEXT ) - { - return "{}"; - } - - //=== VK_AMD_pipeline_compiler_control === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCompilerControlFlagsAMD ) - { - return "{}"; - } - - //=== VK_EXT_present_timing === - - VULKAN_HPP_INLINE std::string to_string( PresentStageFlagsEXT value ) - { - std::string result = "{"; - if ( value & PresentStageFlagBitsEXT::eQueueOperationsEnd ) - result += " QueueOperationsEnd |"; - if ( value & PresentStageFlagBitsEXT::eRequestDequeued ) - result += " RequestDequeued |"; - if ( value & PresentStageFlagBitsEXT::eImageFirstPixelOut ) - result += " ImageFirstPixelOut |"; - if ( value & PresentStageFlagBitsEXT::eImageFirstPixelVisible ) - result += " ImageFirstPixelVisible |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( PresentTimingInfoFlagsEXT value ) - { - std::string result = "{"; - if ( value & PresentTimingInfoFlagBitsEXT::ePresentAtRelativeTime ) - result += " PresentAtRelativeTime |"; - if ( value & PresentTimingInfoFlagBitsEXT::ePresentAtNearestRefreshCycle ) - result += " PresentAtNearestRefreshCycle |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( PastPresentationTimingFlagsEXT value ) - { - std::string result = "{"; - if ( value & PastPresentationTimingFlagBitsEXT::eAllowPartialResults ) - result += " AllowPartialResults |"; - if ( value & PastPresentationTimingFlagBitsEXT::eAllowOutOfOrderResults ) - result += " AllowOutOfOrderResults |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImagePipeSurfaceCreateFlagsFUCHSIA ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MetalSurfaceCreateFlagsEXT ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_AMD_shader_core_properties2 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCorePropertiesFlagsAMD ) - { - return "{}"; - } - - //=== VK_NV_coverage_reduction_mode === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageReductionStateCreateFlagsNV ) - { - return "{}"; - } - - //=== VK_EXT_headless_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( HeadlessSurfaceCreateFlagsEXT ) - { - return "{}"; - } - - //=== VK_NV_device_generated_commands === - - VULKAN_HPP_INLINE std::string to_string( IndirectStateFlagsNV value ) - { - std::string result = "{"; - if ( value & IndirectStateFlagBitsNV::eFlagFrontface ) - result += " FlagFrontface |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsNV value ) - { - std::string result = "{"; - if ( value & IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess ) - result += " ExplicitPreprocess |"; - if ( value & IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences ) - result += " IndexedSequences |"; - if ( value & IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences ) - result += " UnorderedSequences |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_EXT_device_memory_report === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceMemoryReportFlagsEXT ) - { - return "{}"; - } - - //=== VK_KHR_video_encode_queue === - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeFlagBitsKHR::eIntraRefresh ) - result += " IntraRefresh |"; - if ( value & VideoEncodeFlagBitsKHR::eWithQuantizationDeltaMap ) - result += " WithQuantizationDeltaMap |"; - if ( value & VideoEncodeFlagBitsKHR::eWithEmphasisMap ) - result += " WithEmphasisMap |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeCapabilityFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes ) - result += " PrecedingExternallyEncodedBytes |"; - if ( value & VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection ) - result += " InsufficientBitstreamBufferRangeDetection |"; - if ( value & VideoEncodeCapabilityFlagBitsKHR::eQuantizationDeltaMap ) - result += " QuantizationDeltaMap |"; - if ( value & VideoEncodeCapabilityFlagBitsKHR::eEmphasisMap ) - result += " EmphasisMap |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeFeedbackFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset ) - result += " BitstreamBufferOffset |"; - if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten ) - result += " BitstreamBytesWritten |"; - if ( value & VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides ) - result += " BitstreamHasOverrides |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeUsageFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeUsageFlagBitsKHR::eTranscoding ) - result += " Transcoding |"; - if ( value & VideoEncodeUsageFlagBitsKHR::eStreaming ) - result += " Streaming |"; - if ( value & VideoEncodeUsageFlagBitsKHR::eRecording ) - result += " Recording |"; - if ( value & VideoEncodeUsageFlagBitsKHR::eConferencing ) - result += " Conferencing |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "Default"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeContentFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeContentFlagBitsKHR::eCamera ) - result += " Camera |"; - if ( value & VideoEncodeContentFlagBitsKHR::eDesktop ) - result += " Desktop |"; - if ( value & VideoEncodeContentFlagBitsKHR::eRendered ) - result += " Rendered |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "Default"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRateControlFlagsKHR ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeRateControlModeFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeRateControlModeFlagBitsKHR::eDisabled ) - result += " Disabled |"; - if ( value & VideoEncodeRateControlModeFlagBitsKHR::eCbr ) - result += " Cbr |"; - if ( value & VideoEncodeRateControlModeFlagBitsKHR::eVbr ) - result += " Vbr |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "Default"; - return result; - } - - //=== VK_NV_device_diagnostics_config === - - VULKAN_HPP_INLINE std::string to_string( DeviceDiagnosticsConfigFlagsNV value ) - { - std::string result = "{"; - if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo ) - result += " EnableShaderDebugInfo |"; - if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking ) - result += " EnableResourceTracking |"; - if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints ) - result += " EnableAutomaticCheckpoints |"; - if ( value & DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting ) - result += " EnableShaderErrorReporting |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_QCOM_tile_shading === - - VULKAN_HPP_INLINE std::string to_string( TileShadingRenderPassFlagsQCOM value ) - { - std::string result = "{"; - if ( value & TileShadingRenderPassFlagBitsQCOM::eEnable ) - result += " Enable |"; - if ( value & TileShadingRenderPassFlagBitsQCOM::ePerTileExecution ) - result += " PerTileExecution |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - - VULKAN_HPP_INLINE std::string to_string( ExportMetalObjectTypeFlagsEXT value ) - { - std::string result = "{"; - if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalDevice ) - result += " MetalDevice |"; - if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue ) - result += " MetalCommandQueue |"; - if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer ) - result += " MetalBuffer |"; - if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalTexture ) - result += " MetalTexture |"; - if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface ) - result += " MetalIosurface |"; - if ( value & ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent ) - result += " MetalSharedEvent |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_graphics_pipeline_library === - - VULKAN_HPP_INLINE std::string to_string( GraphicsPipelineLibraryFlagsEXT value ) - { - std::string result = "{"; - if ( value & GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface ) - result += " VertexInputInterface |"; - if ( value & GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders ) - result += " PreRasterizationShaders |"; - if ( value & GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader ) - result += " FragmentShader |"; - if ( value & GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface ) - result += " FragmentOutputInterface |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_NV_ray_tracing_motion_blur === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInfoFlagsNV ) - { - return "{}"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInstanceFlagsNV ) - { - return "{}"; - } - - //=== VK_EXT_image_compression_control === - - VULKAN_HPP_INLINE std::string to_string( ImageCompressionFlagsEXT value ) - { - std::string result = "{"; - if ( value & ImageCompressionFlagBitsEXT::eFixedRateDefault ) - result += " FixedRateDefault |"; - if ( value & ImageCompressionFlagBitsEXT::eFixedRateExplicit ) - result += " FixedRateExplicit |"; - if ( value & ImageCompressionFlagBitsEXT::eDisabled ) - result += " Disabled |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "Default"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ImageCompressionFixedRateFlagsEXT value ) - { - std::string result = "{"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e1Bpc ) - result += " 1Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e2Bpc ) - result += " 2Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e3Bpc ) - result += " 3Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e4Bpc ) - result += " 4Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e5Bpc ) - result += " 5Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e6Bpc ) - result += " 6Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e7Bpc ) - result += " 7Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e8Bpc ) - result += " 8Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e9Bpc ) - result += " 9Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e10Bpc ) - result += " 10Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e11Bpc ) - result += " 11Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e12Bpc ) - result += " 12Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e13Bpc ) - result += " 13Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e14Bpc ) - result += " 14Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e15Bpc ) - result += " 15Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e16Bpc ) - result += " 16Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e17Bpc ) - result += " 17Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e18Bpc ) - result += " 18Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e19Bpc ) - result += " 19Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e20Bpc ) - result += " 20Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e21Bpc ) - result += " 21Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e22Bpc ) - result += " 22Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e23Bpc ) - result += " 23Bpc |"; - if ( value & ImageCompressionFixedRateFlagBitsEXT::e24Bpc ) - result += " 24Bpc |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "None"; - return result; - } - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectFBSurfaceCreateFlagsEXT ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_device_address_binding_report === - - VULKAN_HPP_INLINE std::string to_string( DeviceAddressBindingFlagsEXT value ) - { - std::string result = "{"; - if ( value & DeviceAddressBindingFlagBitsEXT::eInternalObject ) - result += " InternalObject |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageFormatConstraintsFlagsFUCHSIA ) - { - return "{}"; - } - - VULKAN_HPP_INLINE std::string to_string( ImageConstraintsInfoFlagsFUCHSIA value ) - { - std::string result = "{"; - if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely ) - result += " CpuReadRarely |"; - if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften ) - result += " CpuReadOften |"; - if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely ) - result += " CpuWriteRarely |"; - if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften ) - result += " CpuWriteOften |"; - if ( value & ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional ) - result += " ProtectedOptional |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_EXT_frame_boundary === - - VULKAN_HPP_INLINE std::string to_string( FrameBoundaryFlagsEXT value ) - { - std::string result = "{"; - if ( value & FrameBoundaryFlagBitsEXT::eFrameEnd ) - result += " FrameEnd |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ScreenSurfaceCreateFlagsQNX ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_VALVE_video_encode_rgb_conversion === - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbModelConversionFlagsVALVE value ) - { - std::string result = "{"; - if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity ) - result += " RgbIdentity |"; - if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcrIdentity ) - result += " YcbcrIdentity |"; - if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr709 ) - result += " Ycbcr709 |"; - if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr601 ) - result += " Ycbcr601 |"; - if ( value & VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr2020 ) - result += " Ycbcr2020 |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbRangeCompressionFlagsVALVE value ) - { - std::string result = "{"; - if ( value & VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange ) - result += " FullRange |"; - if ( value & VideoEncodeRgbRangeCompressionFlagBitsVALVE::eNarrowRange ) - result += " NarrowRange |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeRgbChromaOffsetFlagsVALVE value ) - { - std::string result = "{"; - if ( value & VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven ) - result += " CositedEven |"; - if ( value & VideoEncodeRgbChromaOffsetFlagBitsVALVE::eMidpoint ) - result += " Midpoint |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_EXT_opacity_micromap === - - VULKAN_HPP_INLINE std::string to_string( BuildMicromapFlagsEXT value ) - { - std::string result = "{"; - if ( value & BuildMicromapFlagBitsEXT::ePreferFastTrace ) - result += " PreferFastTrace |"; - if ( value & BuildMicromapFlagBitsEXT::ePreferFastBuild ) - result += " PreferFastBuild |"; - if ( value & BuildMicromapFlagBitsEXT::eAllowCompaction ) - result += " AllowCompaction |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( MicromapCreateFlagsEXT value ) - { - std::string result = "{"; - if ( value & MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay ) - result += " DeviceAddressCaptureReplay |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_ARM_scheduling_controls === - - VULKAN_HPP_INLINE std::string to_string( PhysicalDeviceSchedulingControlsFlagsARM value ) - { - std::string result = "{"; - if ( value & PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount ) - result += " ShaderCoreCount |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_LUNARG_direct_driver_loading === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectDriverLoadingFlagsLUNARG ) - { - return "{}"; - } - - //=== VK_ARM_tensors === - - VULKAN_HPP_INLINE std::string to_string( TensorCreateFlagsARM value ) - { - std::string result = "{"; - if ( value & TensorCreateFlagBitsARM::eMutableFormat ) - result += " MutableFormat |"; - if ( value & TensorCreateFlagBitsARM::eProtected ) - result += " Protected |"; - if ( value & TensorCreateFlagBitsARM::eDescriptorHeapCaptureReplay ) - result += " DescriptorHeapCaptureReplay |"; - if ( value & TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay ) - result += " DescriptorBufferCaptureReplay |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( TensorUsageFlagsARM value ) - { - std::string result = "{"; - if ( value & TensorUsageFlagBitsARM::eShader ) - result += " Shader |"; - if ( value & TensorUsageFlagBitsARM::eTransferSrc ) - result += " TransferSrc |"; - if ( value & TensorUsageFlagBitsARM::eTransferDst ) - result += " TransferDst |"; - if ( value & TensorUsageFlagBitsARM::eImageAliasing ) - result += " ImageAliasing |"; - if ( value & TensorUsageFlagBitsARM::eDataGraph ) - result += " DataGraph |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_NV_optical_flow === - - VULKAN_HPP_INLINE std::string to_string( OpticalFlowUsageFlagsNV value ) - { - std::string result = "{"; - if ( value & OpticalFlowUsageFlagBitsNV::eInput ) - result += " Input |"; - if ( value & OpticalFlowUsageFlagBitsNV::eOutput ) - result += " Output |"; - if ( value & OpticalFlowUsageFlagBitsNV::eHint ) - result += " Hint |"; - if ( value & OpticalFlowUsageFlagBitsNV::eCost ) - result += " Cost |"; - if ( value & OpticalFlowUsageFlagBitsNV::eGlobalFlow ) - result += " GlobalFlow |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "Unknown"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( OpticalFlowGridSizeFlagsNV value ) - { - std::string result = "{"; - if ( value & OpticalFlowGridSizeFlagBitsNV::e1X1 ) - result += " 1X1 |"; - if ( value & OpticalFlowGridSizeFlagBitsNV::e2X2 ) - result += " 2X2 |"; - if ( value & OpticalFlowGridSizeFlagBitsNV::e4X4 ) - result += " 4X4 |"; - if ( value & OpticalFlowGridSizeFlagBitsNV::e8X8 ) - result += " 8X8 |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "Unknown"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( OpticalFlowSessionCreateFlagsNV value ) - { - std::string result = "{"; - if ( value & OpticalFlowSessionCreateFlagBitsNV::eEnableHint ) - result += " EnableHint |"; - if ( value & OpticalFlowSessionCreateFlagBitsNV::eEnableCost ) - result += " EnableCost |"; - if ( value & OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow ) - result += " EnableGlobalFlow |"; - if ( value & OpticalFlowSessionCreateFlagBitsNV::eAllowRegions ) - result += " AllowRegions |"; - if ( value & OpticalFlowSessionCreateFlagBitsNV::eBothDirections ) - result += " BothDirections |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( OpticalFlowExecuteFlagsNV value ) - { - std::string result = "{"; - if ( value & OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints ) - result += " DisableTemporalHints |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_EXT_shader_object === - - VULKAN_HPP_INLINE std::string to_string( ShaderCreateFlagsEXT value ) - { - std::string result = "{"; - if ( value & ShaderCreateFlagBitsEXT::eLinkStage ) - result += " LinkStage |"; - if ( value & ShaderCreateFlagBitsEXT::eDescriptorHeap ) - result += " DescriptorHeap |"; - if ( value & ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize ) - result += " AllowVaryingSubgroupSize |"; - if ( value & ShaderCreateFlagBitsEXT::eRequireFullSubgroups ) - result += " RequireFullSubgroups |"; - if ( value & ShaderCreateFlagBitsEXT::eNoTaskShader ) - result += " NoTaskShader |"; - if ( value & ShaderCreateFlagBitsEXT::eDispatchBase ) - result += " DispatchBase |"; - if ( value & ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment ) - result += " FragmentShadingRateAttachment |"; - if ( value & ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment ) - result += " FragmentDensityMapAttachment |"; - if ( value & ShaderCreateFlagBitsEXT::eIndirectBindable ) - result += " IndirectBindable |"; - if ( value & ShaderCreateFlagBitsEXT::e64BitIndexing ) - result += " 64BitIndexing |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_KHR_surface_maintenance1 === - - VULKAN_HPP_INLINE std::string to_string( PresentScalingFlagsKHR value ) - { - std::string result = "{"; - if ( value & PresentScalingFlagBitsKHR::eOneToOne ) - result += " OneToOne |"; - if ( value & PresentScalingFlagBitsKHR::eAspectRatioStretch ) - result += " AspectRatioStretch |"; - if ( value & PresentScalingFlagBitsKHR::eStretch ) - result += " Stretch |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( PresentGravityFlagsKHR value ) - { - std::string result = "{"; - if ( value & PresentGravityFlagBitsKHR::eMin ) - result += " Min |"; - if ( value & PresentGravityFlagBitsKHR::eMax ) - result += " Max |"; - if ( value & PresentGravityFlagBitsKHR::eCentered ) - result += " Centered |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_ARM_data_graph === - - VULKAN_HPP_INLINE std::string to_string( DataGraphPipelineSessionCreateFlagsARM value ) - { - std::string result = "{"; - if ( value & DataGraphPipelineSessionCreateFlagBitsARM::eProtected ) - result += " Protected |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineDispatchFlagsARM ) - { - return "{}"; - } - - //=== VK_KHR_video_encode_av1 === - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1CapabilityFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::ePerRateControlGroupMinMaxQIndex ) - result += " PerRateControlGroupMinMaxQIndex |"; - if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eGenerateObuExtensionHeader ) - result += " GenerateObuExtensionHeader |"; - if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::ePrimaryReferenceCdfOnly ) - result += " PrimaryReferenceCdfOnly |"; - if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eFrameSizeOverride ) - result += " FrameSizeOverride |"; - if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eMotionVectorScaling ) - result += " MotionVectorScaling |"; - if ( value & VideoEncodeAV1CapabilityFlagBitsKHR::eCompoundPredictionIntraRefresh ) - result += " CompoundPredictionIntraRefresh |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1StdFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeAV1StdFlagBitsKHR::eUniformTileSpacingFlagSet ) - result += " UniformTileSpacingFlagSet |"; - if ( value & VideoEncodeAV1StdFlagBitsKHR::eSkipModePresentUnset ) - result += " SkipModePresentUnset |"; - if ( value & VideoEncodeAV1StdFlagBitsKHR::ePrimaryRefFrame ) - result += " PrimaryRefFrame |"; - if ( value & VideoEncodeAV1StdFlagBitsKHR::eDeltaQ ) - result += " DeltaQ |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1SuperblockSizeFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeAV1SuperblockSizeFlagBitsKHR::e64 ) - result += " 64 |"; - if ( value & VideoEncodeAV1SuperblockSizeFlagBitsKHR::e128 ) - result += " 128 |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeAV1RateControlFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eRegularGop ) - result += " RegularGop |"; - if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eTemporalLayerPatternDyadic ) - result += " TemporalLayerPatternDyadic |"; - if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternFlat ) - result += " ReferencePatternFlat |"; - if ( value & VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternDyadic ) - result += " ReferencePatternDyadic |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_KHR_copy_memory_indirect === - - VULKAN_HPP_INLINE std::string to_string( AddressCopyFlagsKHR value ) - { - std::string result = "{"; - if ( value & AddressCopyFlagBitsKHR::eDeviceLocal ) - result += " DeviceLocal |"; - if ( value & AddressCopyFlagBitsKHR::eSparse ) - result += " Sparse |"; - if ( value & AddressCopyFlagBitsKHR::eProtected ) - result += " Protected |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_EXT_memory_decompression === - - VULKAN_HPP_INLINE std::string to_string( MemoryDecompressionMethodFlagsEXT value ) - { - std::string result = "{"; - if ( value & MemoryDecompressionMethodFlagBitsEXT::eGdeflate10 ) - result += " Gdeflate10 |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_KHR_video_encode_intra_refresh === - - VULKAN_HPP_INLINE std::string to_string( VideoEncodeIntraRefreshModeFlagsKHR value ) - { - std::string result = "{"; - if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::ePerPicturePartition ) - result += " PerPicturePartition |"; - if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockBased ) - result += " BlockBased |"; - if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockRowBased ) - result += " BlockRowBased |"; - if ( value & VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockColumnBased ) - result += " BlockColumnBased |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "None"; - return result; - } - - //=== VK_NV_cluster_acceleration_structure === - - VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureClusterFlagsNV value ) - { - std::string result = "{"; - if ( value & ClusterAccelerationStructureClusterFlagBitsNV::eAllowDisableOpacityMicromaps ) - result += " AllowDisableOpacityMicromaps |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureGeometryFlagsNV value ) - { - std::string result = "{"; - if ( value & ClusterAccelerationStructureGeometryFlagBitsNV::eCullDisable ) - result += " CullDisable |"; - if ( value & ClusterAccelerationStructureGeometryFlagBitsNV::eNoDuplicateAnyhitInvocation ) - result += " NoDuplicateAnyhitInvocation |"; - if ( value & ClusterAccelerationStructureGeometryFlagBitsNV::eOpaque ) - result += " Opaque |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureAddressResolutionFlagsNV value ) - { - std::string result = "{"; - if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstImplicitData ) - result += " IndirectedDstImplicitData |"; - if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedScratchData ) - result += " IndirectedScratchData |"; - if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstAddressArray ) - result += " IndirectedDstAddressArray |"; - if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstSizesArray ) - result += " IndirectedDstSizesArray |"; - if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosArray ) - result += " IndirectedSrcInfosArray |"; - if ( value & ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosCount ) - result += " IndirectedSrcInfosCount |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "None"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ClusterAccelerationStructureIndexFormatFlagsNV value ) - { - std::string result = "{"; - if ( value & ClusterAccelerationStructureIndexFormatFlagBitsNV::e8 ) - result += " 8 |"; - if ( value & ClusterAccelerationStructureIndexFormatFlagBitsNV::e16 ) - result += " 16 |"; - if ( value & ClusterAccelerationStructureIndexFormatFlagBitsNV::e32 ) - result += " 32 |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_NV_partitioned_acceleration_structure === - - VULKAN_HPP_INLINE std::string to_string( PartitionedAccelerationStructureInstanceFlagsNV value ) - { - std::string result = "{"; - if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFacingCullDisable ) - result += " FlagTriangleFacingCullDisable |"; - if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFlipFacing ) - result += " FlagTriangleFlipFacing |"; - if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceOpaque ) - result += " FlagForceOpaque |"; - if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceNoOpaque ) - result += " FlagForceNoOpaque |"; - if ( value & PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagEnableExplicitBoundingBox ) - result += " FlagEnableExplicitBoundingBox |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_EXT_device_generated_commands === - - VULKAN_HPP_INLINE std::string to_string( IndirectCommandsLayoutUsageFlagsEXT value ) - { - std::string result = "{"; - if ( value & IndirectCommandsLayoutUsageFlagBitsEXT::eExplicitPreprocess ) - result += " ExplicitPreprocess |"; - if ( value & IndirectCommandsLayoutUsageFlagBitsEXT::eUnorderedSequences ) - result += " UnorderedSequences |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( IndirectCommandsInputModeFlagsEXT value ) - { - std::string result = "{"; - if ( value & IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer ) - result += " VulkanIndexBuffer |"; - if ( value & IndirectCommandsInputModeFlagBitsEXT::eDxgiIndexBuffer ) - result += " DxgiIndexBuffer |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //=== VK_KHR_maintenance8 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlags3KHR ) - { - return "None"; - } - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceCreateFlagsOHOS ) - { - return "{}"; - } -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_ARM_performance_counters_by_region === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagsARM ) - { - return "{}"; - } - - //=== VK_KHR_maintenance10 === - - VULKAN_HPP_INLINE std::string to_string( RenderingAttachmentFlagsKHR value ) - { - std::string result = "{"; - if ( value & RenderingAttachmentFlagBitsKHR::eInputAttachmentFeedback ) - result += " InputAttachmentFeedback |"; - if ( value & RenderingAttachmentFlagBitsKHR::eResolveSkipTransferFunction ) - result += " ResolveSkipTransferFunction |"; - if ( value & RenderingAttachmentFlagBitsKHR::eResolveEnableTransferFunction ) - result += " ResolveEnableTransferFunction |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - VULKAN_HPP_INLINE std::string to_string( ResolveImageFlagsKHR value ) - { - std::string result = "{"; - if ( value & ResolveImageFlagBitsKHR::eSkipTransferFunction ) - result += " SkipTransferFunction |"; - if ( value & ResolveImageFlagBitsKHR::eEnableTransferFunction ) - result += " EnableTransferFunction |"; - - if ( result.size() > 1 ) - result.back() = '}'; - else - result = "{}"; - return result; - } - - //======================= - //=== ENUMs to_string === - //======================= - - VULKAN_HPP_INLINE std::string toHexString( uint32_t value ) - { -#if __cpp_lib_format - return std::format( "{:x}", value ); -#else - std::stringstream stream; - stream << std::hex << value; - return stream.str(); -#endif - } - - //=== VK_VERSION_1_0 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Result value ) - { - switch ( value ) - { - case Result::eSuccess : return "Success"; - case Result::eNotReady : return "NotReady"; - case Result::eTimeout : return "Timeout"; - case Result::eEventSet : return "EventSet"; - case Result::eEventReset : return "EventReset"; - case Result::eIncomplete : return "Incomplete"; - case Result::eErrorOutOfHostMemory : return "ErrorOutOfHostMemory"; - case Result::eErrorOutOfDeviceMemory : return "ErrorOutOfDeviceMemory"; - case Result::eErrorInitializationFailed : return "ErrorInitializationFailed"; - case Result::eErrorDeviceLost : return "ErrorDeviceLost"; - case Result::eErrorMemoryMapFailed : return "ErrorMemoryMapFailed"; - case Result::eErrorLayerNotPresent : return "ErrorLayerNotPresent"; - case Result::eErrorExtensionNotPresent : return "ErrorExtensionNotPresent"; - case Result::eErrorFeatureNotPresent : return "ErrorFeatureNotPresent"; - case Result::eErrorIncompatibleDriver : return "ErrorIncompatibleDriver"; - case Result::eErrorTooManyObjects : return "ErrorTooManyObjects"; - case Result::eErrorFormatNotSupported : return "ErrorFormatNotSupported"; - case Result::eErrorFragmentedPool : return "ErrorFragmentedPool"; - case Result::eErrorUnknown : return "ErrorUnknown"; - case Result::eErrorValidationFailed : return "ErrorValidationFailed"; - case Result::eErrorOutOfPoolMemory : return "ErrorOutOfPoolMemory"; - case Result::eErrorInvalidExternalHandle : return "ErrorInvalidExternalHandle"; - case Result::eErrorInvalidOpaqueCaptureAddress : return "ErrorInvalidOpaqueCaptureAddress"; - case Result::eErrorFragmentation : return "ErrorFragmentation"; - case Result::ePipelineCompileRequired : return "PipelineCompileRequired"; - case Result::eErrorNotPermitted : return "ErrorNotPermitted"; - case Result::eErrorSurfaceLostKHR : return "ErrorSurfaceLostKHR"; - case Result::eErrorNativeWindowInUseKHR : return "ErrorNativeWindowInUseKHR"; - case Result::eSuboptimalKHR : return "SuboptimalKHR"; - case Result::eErrorOutOfDateKHR : return "ErrorOutOfDateKHR"; - case Result::eErrorIncompatibleDisplayKHR : return "ErrorIncompatibleDisplayKHR"; - case Result::eErrorInvalidShaderNV : return "ErrorInvalidShaderNV"; - case Result::eErrorImageUsageNotSupportedKHR : return "ErrorImageUsageNotSupportedKHR"; - case Result::eErrorVideoPictureLayoutNotSupportedKHR : return "ErrorVideoPictureLayoutNotSupportedKHR"; - case Result::eErrorVideoProfileOperationNotSupportedKHR : return "ErrorVideoProfileOperationNotSupportedKHR"; - case Result::eErrorVideoProfileFormatNotSupportedKHR : return "ErrorVideoProfileFormatNotSupportedKHR"; - case Result::eErrorVideoProfileCodecNotSupportedKHR : return "ErrorVideoProfileCodecNotSupportedKHR"; - case Result::eErrorVideoStdVersionNotSupportedKHR : return "ErrorVideoStdVersionNotSupportedKHR"; - case Result::eErrorInvalidDrmFormatModifierPlaneLayoutEXT: return "ErrorInvalidDrmFormatModifierPlaneLayoutEXT"; - case Result::eErrorPresentTimingQueueFullEXT : return "ErrorPresentTimingQueueFullEXT"; -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - case Result::eErrorFullScreenExclusiveModeLostEXT: return "ErrorFullScreenExclusiveModeLostEXT"; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - case Result::eThreadIdleKHR : return "ThreadIdleKHR"; - case Result::eThreadDoneKHR : return "ThreadDoneKHR"; - case Result::eOperationDeferredKHR : return "OperationDeferredKHR"; - case Result::eOperationNotDeferredKHR : return "OperationNotDeferredKHR"; - case Result::eErrorInvalidVideoStdParametersKHR: return "ErrorInvalidVideoStdParametersKHR"; - case Result::eErrorCompressionExhaustedEXT : return "ErrorCompressionExhaustedEXT"; - case Result::eIncompatibleShaderBinaryEXT : return "IncompatibleShaderBinaryEXT"; - case Result::ePipelineBinaryMissingKHR : return "PipelineBinaryMissingKHR"; - case Result::eErrorNotEnoughSpaceKHR : return "ErrorNotEnoughSpaceKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StructureType value ) - { - switch ( value ) - { - case StructureType::eApplicationInfo : return "ApplicationInfo"; - case StructureType::eInstanceCreateInfo : return "InstanceCreateInfo"; - case StructureType::eDeviceQueueCreateInfo : return "DeviceQueueCreateInfo"; - case StructureType::eDeviceCreateInfo : return "DeviceCreateInfo"; - case StructureType::eSubmitInfo : return "SubmitInfo"; - case StructureType::eMemoryAllocateInfo : return "MemoryAllocateInfo"; - case StructureType::eMappedMemoryRange : return "MappedMemoryRange"; - case StructureType::eBindSparseInfo : return "BindSparseInfo"; - case StructureType::eFenceCreateInfo : return "FenceCreateInfo"; - case StructureType::eSemaphoreCreateInfo : return "SemaphoreCreateInfo"; - case StructureType::eEventCreateInfo : return "EventCreateInfo"; - case StructureType::eQueryPoolCreateInfo : return "QueryPoolCreateInfo"; - case StructureType::eBufferCreateInfo : return "BufferCreateInfo"; - case StructureType::eBufferViewCreateInfo : return "BufferViewCreateInfo"; - case StructureType::eImageCreateInfo : return "ImageCreateInfo"; - case StructureType::eImageViewCreateInfo : return "ImageViewCreateInfo"; - case StructureType::eShaderModuleCreateInfo : return "ShaderModuleCreateInfo"; - case StructureType::ePipelineCacheCreateInfo : return "PipelineCacheCreateInfo"; - case StructureType::ePipelineShaderStageCreateInfo : return "PipelineShaderStageCreateInfo"; - case StructureType::ePipelineVertexInputStateCreateInfo : return "PipelineVertexInputStateCreateInfo"; - case StructureType::ePipelineInputAssemblyStateCreateInfo : return "PipelineInputAssemblyStateCreateInfo"; - case StructureType::ePipelineTessellationStateCreateInfo : return "PipelineTessellationStateCreateInfo"; - case StructureType::ePipelineViewportStateCreateInfo : return "PipelineViewportStateCreateInfo"; - case StructureType::ePipelineRasterizationStateCreateInfo : return "PipelineRasterizationStateCreateInfo"; - case StructureType::ePipelineMultisampleStateCreateInfo : return "PipelineMultisampleStateCreateInfo"; - case StructureType::ePipelineDepthStencilStateCreateInfo : return "PipelineDepthStencilStateCreateInfo"; - case StructureType::ePipelineColorBlendStateCreateInfo : return "PipelineColorBlendStateCreateInfo"; - case StructureType::ePipelineDynamicStateCreateInfo : return "PipelineDynamicStateCreateInfo"; - case StructureType::eGraphicsPipelineCreateInfo : return "GraphicsPipelineCreateInfo"; - case StructureType::eComputePipelineCreateInfo : return "ComputePipelineCreateInfo"; - case StructureType::ePipelineLayoutCreateInfo : return "PipelineLayoutCreateInfo"; - case StructureType::eSamplerCreateInfo : return "SamplerCreateInfo"; - case StructureType::eDescriptorSetLayoutCreateInfo : return "DescriptorSetLayoutCreateInfo"; - case StructureType::eDescriptorPoolCreateInfo : return "DescriptorPoolCreateInfo"; - case StructureType::eDescriptorSetAllocateInfo : return "DescriptorSetAllocateInfo"; - case StructureType::eWriteDescriptorSet : return "WriteDescriptorSet"; - case StructureType::eCopyDescriptorSet : return "CopyDescriptorSet"; - case StructureType::eFramebufferCreateInfo : return "FramebufferCreateInfo"; - case StructureType::eRenderPassCreateInfo : return "RenderPassCreateInfo"; - case StructureType::eCommandPoolCreateInfo : return "CommandPoolCreateInfo"; - case StructureType::eCommandBufferAllocateInfo : return "CommandBufferAllocateInfo"; - case StructureType::eCommandBufferInheritanceInfo : return "CommandBufferInheritanceInfo"; - case StructureType::eCommandBufferBeginInfo : return "CommandBufferBeginInfo"; - case StructureType::eRenderPassBeginInfo : return "RenderPassBeginInfo"; - case StructureType::eBufferMemoryBarrier : return "BufferMemoryBarrier"; - case StructureType::eImageMemoryBarrier : return "ImageMemoryBarrier"; - case StructureType::eMemoryBarrier : return "MemoryBarrier"; - case StructureType::eLoaderInstanceCreateInfo : return "LoaderInstanceCreateInfo"; - case StructureType::eLoaderDeviceCreateInfo : return "LoaderDeviceCreateInfo"; - case StructureType::eBindBufferMemoryInfo : return "BindBufferMemoryInfo"; - case StructureType::eBindImageMemoryInfo : return "BindImageMemoryInfo"; - case StructureType::eMemoryDedicatedRequirements : return "MemoryDedicatedRequirements"; - case StructureType::eMemoryDedicatedAllocateInfo : return "MemoryDedicatedAllocateInfo"; - case StructureType::eMemoryAllocateFlagsInfo : return "MemoryAllocateFlagsInfo"; - case StructureType::eDeviceGroupCommandBufferBeginInfo : return "DeviceGroupCommandBufferBeginInfo"; - case StructureType::eDeviceGroupSubmitInfo : return "DeviceGroupSubmitInfo"; - case StructureType::eDeviceGroupBindSparseInfo : return "DeviceGroupBindSparseInfo"; - case StructureType::eBindBufferMemoryDeviceGroupInfo : return "BindBufferMemoryDeviceGroupInfo"; - case StructureType::eBindImageMemoryDeviceGroupInfo : return "BindImageMemoryDeviceGroupInfo"; - case StructureType::ePhysicalDeviceGroupProperties : return "PhysicalDeviceGroupProperties"; - case StructureType::eDeviceGroupDeviceCreateInfo : return "DeviceGroupDeviceCreateInfo"; - case StructureType::eBufferMemoryRequirementsInfo2 : return "BufferMemoryRequirementsInfo2"; - case StructureType::eImageMemoryRequirementsInfo2 : return "ImageMemoryRequirementsInfo2"; - case StructureType::eImageSparseMemoryRequirementsInfo2 : return "ImageSparseMemoryRequirementsInfo2"; - case StructureType::eMemoryRequirements2 : return "MemoryRequirements2"; - case StructureType::eSparseImageMemoryRequirements2 : return "SparseImageMemoryRequirements2"; - case StructureType::ePhysicalDeviceFeatures2 : return "PhysicalDeviceFeatures2"; - case StructureType::ePhysicalDeviceProperties2 : return "PhysicalDeviceProperties2"; - case StructureType::eFormatProperties2 : return "FormatProperties2"; - case StructureType::eImageFormatProperties2 : return "ImageFormatProperties2"; - case StructureType::ePhysicalDeviceImageFormatInfo2 : return "PhysicalDeviceImageFormatInfo2"; - case StructureType::eQueueFamilyProperties2 : return "QueueFamilyProperties2"; - case StructureType::ePhysicalDeviceMemoryProperties2 : return "PhysicalDeviceMemoryProperties2"; - case StructureType::eSparseImageFormatProperties2 : return "SparseImageFormatProperties2"; - case StructureType::ePhysicalDeviceSparseImageFormatInfo2 : return "PhysicalDeviceSparseImageFormatInfo2"; - case StructureType::eImageViewUsageCreateInfo : return "ImageViewUsageCreateInfo"; - case StructureType::eProtectedSubmitInfo : return "ProtectedSubmitInfo"; - case StructureType::ePhysicalDeviceProtectedMemoryFeatures : return "PhysicalDeviceProtectedMemoryFeatures"; - case StructureType::ePhysicalDeviceProtectedMemoryProperties : return "PhysicalDeviceProtectedMemoryProperties"; - case StructureType::eDeviceQueueInfo2 : return "DeviceQueueInfo2"; - case StructureType::ePhysicalDeviceExternalImageFormatInfo : return "PhysicalDeviceExternalImageFormatInfo"; - case StructureType::eExternalImageFormatProperties : return "ExternalImageFormatProperties"; - case StructureType::ePhysicalDeviceExternalBufferInfo : return "PhysicalDeviceExternalBufferInfo"; - case StructureType::eExternalBufferProperties : return "ExternalBufferProperties"; - case StructureType::ePhysicalDeviceIdProperties : return "PhysicalDeviceIdProperties"; - case StructureType::eExternalMemoryBufferCreateInfo : return "ExternalMemoryBufferCreateInfo"; - case StructureType::eExternalMemoryImageCreateInfo : return "ExternalMemoryImageCreateInfo"; - case StructureType::eExportMemoryAllocateInfo : return "ExportMemoryAllocateInfo"; - case StructureType::ePhysicalDeviceExternalFenceInfo : return "PhysicalDeviceExternalFenceInfo"; - case StructureType::eExternalFenceProperties : return "ExternalFenceProperties"; - case StructureType::eExportFenceCreateInfo : return "ExportFenceCreateInfo"; - case StructureType::eExportSemaphoreCreateInfo : return "ExportSemaphoreCreateInfo"; - case StructureType::ePhysicalDeviceExternalSemaphoreInfo : return "PhysicalDeviceExternalSemaphoreInfo"; - case StructureType::eExternalSemaphoreProperties : return "ExternalSemaphoreProperties"; - case StructureType::ePhysicalDeviceSubgroupProperties : return "PhysicalDeviceSubgroupProperties"; - case StructureType::ePhysicalDevice16BitStorageFeatures : return "PhysicalDevice16BitStorageFeatures"; - case StructureType::ePhysicalDeviceVariablePointersFeatures : return "PhysicalDeviceVariablePointersFeatures"; - case StructureType::eDescriptorUpdateTemplateCreateInfo : return "DescriptorUpdateTemplateCreateInfo"; - case StructureType::ePhysicalDeviceMaintenance3Properties : return "PhysicalDeviceMaintenance3Properties"; - case StructureType::eDescriptorSetLayoutSupport : return "DescriptorSetLayoutSupport"; - case StructureType::eSamplerYcbcrConversionCreateInfo : return "SamplerYcbcrConversionCreateInfo"; - case StructureType::eSamplerYcbcrConversionInfo : return "SamplerYcbcrConversionInfo"; - case StructureType::eBindImagePlaneMemoryInfo : return "BindImagePlaneMemoryInfo"; - case StructureType::eImagePlaneMemoryRequirementsInfo : return "ImagePlaneMemoryRequirementsInfo"; - case StructureType::ePhysicalDeviceSamplerYcbcrConversionFeatures : return "PhysicalDeviceSamplerYcbcrConversionFeatures"; - case StructureType::eSamplerYcbcrConversionImageFormatProperties : return "SamplerYcbcrConversionImageFormatProperties"; - case StructureType::eDeviceGroupRenderPassBeginInfo : return "DeviceGroupRenderPassBeginInfo"; - case StructureType::ePhysicalDevicePointClippingProperties : return "PhysicalDevicePointClippingProperties"; - case StructureType::eRenderPassInputAttachmentAspectCreateInfo : return "RenderPassInputAttachmentAspectCreateInfo"; - case StructureType::ePipelineTessellationDomainOriginStateCreateInfo : return "PipelineTessellationDomainOriginStateCreateInfo"; - case StructureType::eRenderPassMultiviewCreateInfo : return "RenderPassMultiviewCreateInfo"; - case StructureType::ePhysicalDeviceMultiviewFeatures : return "PhysicalDeviceMultiviewFeatures"; - case StructureType::ePhysicalDeviceMultiviewProperties : return "PhysicalDeviceMultiviewProperties"; - case StructureType::ePhysicalDeviceShaderDrawParametersFeatures : return "PhysicalDeviceShaderDrawParametersFeatures"; - case StructureType::ePhysicalDeviceVulkan11Features : return "PhysicalDeviceVulkan11Features"; - case StructureType::ePhysicalDeviceVulkan11Properties : return "PhysicalDeviceVulkan11Properties"; - case StructureType::ePhysicalDeviceVulkan12Features : return "PhysicalDeviceVulkan12Features"; - case StructureType::ePhysicalDeviceVulkan12Properties : return "PhysicalDeviceVulkan12Properties"; - case StructureType::eImageFormatListCreateInfo : return "ImageFormatListCreateInfo"; - case StructureType::ePhysicalDeviceDriverProperties : return "PhysicalDeviceDriverProperties"; - case StructureType::ePhysicalDeviceVulkanMemoryModelFeatures : return "PhysicalDeviceVulkanMemoryModelFeatures"; - case StructureType::ePhysicalDeviceHostQueryResetFeatures : return "PhysicalDeviceHostQueryResetFeatures"; - case StructureType::ePhysicalDeviceTimelineSemaphoreFeatures : return "PhysicalDeviceTimelineSemaphoreFeatures"; - case StructureType::ePhysicalDeviceTimelineSemaphoreProperties : return "PhysicalDeviceTimelineSemaphoreProperties"; - case StructureType::eSemaphoreTypeCreateInfo : return "SemaphoreTypeCreateInfo"; - case StructureType::eTimelineSemaphoreSubmitInfo : return "TimelineSemaphoreSubmitInfo"; - case StructureType::eSemaphoreWaitInfo : return "SemaphoreWaitInfo"; - case StructureType::eSemaphoreSignalInfo : return "SemaphoreSignalInfo"; - case StructureType::ePhysicalDeviceBufferDeviceAddressFeatures : return "PhysicalDeviceBufferDeviceAddressFeatures"; - case StructureType::eBufferDeviceAddressInfo : return "BufferDeviceAddressInfo"; - case StructureType::eBufferOpaqueCaptureAddressCreateInfo : return "BufferOpaqueCaptureAddressCreateInfo"; - case StructureType::eMemoryOpaqueCaptureAddressAllocateInfo : return "MemoryOpaqueCaptureAddressAllocateInfo"; - case StructureType::eDeviceMemoryOpaqueCaptureAddressInfo : return "DeviceMemoryOpaqueCaptureAddressInfo"; - case StructureType::ePhysicalDevice8BitStorageFeatures : return "PhysicalDevice8BitStorageFeatures"; - case StructureType::ePhysicalDeviceShaderAtomicInt64Features : return "PhysicalDeviceShaderAtomicInt64Features"; - case StructureType::ePhysicalDeviceShaderFloat16Int8Features : return "PhysicalDeviceShaderFloat16Int8Features"; - case StructureType::ePhysicalDeviceFloatControlsProperties : return "PhysicalDeviceFloatControlsProperties"; - case StructureType::eDescriptorSetLayoutBindingFlagsCreateInfo : return "DescriptorSetLayoutBindingFlagsCreateInfo"; - case StructureType::ePhysicalDeviceDescriptorIndexingFeatures : return "PhysicalDeviceDescriptorIndexingFeatures"; - case StructureType::ePhysicalDeviceDescriptorIndexingProperties : return "PhysicalDeviceDescriptorIndexingProperties"; - case StructureType::eDescriptorSetVariableDescriptorCountAllocateInfo : return "DescriptorSetVariableDescriptorCountAllocateInfo"; - case StructureType::eDescriptorSetVariableDescriptorCountLayoutSupport : return "DescriptorSetVariableDescriptorCountLayoutSupport"; - case StructureType::ePhysicalDeviceScalarBlockLayoutFeatures : return "PhysicalDeviceScalarBlockLayoutFeatures"; - case StructureType::ePhysicalDeviceSamplerFilterMinmaxProperties : return "PhysicalDeviceSamplerFilterMinmaxProperties"; - case StructureType::eSamplerReductionModeCreateInfo : return "SamplerReductionModeCreateInfo"; - case StructureType::ePhysicalDeviceUniformBufferStandardLayoutFeatures : return "PhysicalDeviceUniformBufferStandardLayoutFeatures"; - case StructureType::ePhysicalDeviceShaderSubgroupExtendedTypesFeatures : return "PhysicalDeviceShaderSubgroupExtendedTypesFeatures"; - case StructureType::eAttachmentDescription2 : return "AttachmentDescription2"; - case StructureType::eAttachmentReference2 : return "AttachmentReference2"; - case StructureType::eSubpassDescription2 : return "SubpassDescription2"; - case StructureType::eSubpassDependency2 : return "SubpassDependency2"; - case StructureType::eRenderPassCreateInfo2 : return "RenderPassCreateInfo2"; - case StructureType::eSubpassBeginInfo : return "SubpassBeginInfo"; - case StructureType::eSubpassEndInfo : return "SubpassEndInfo"; - case StructureType::ePhysicalDeviceDepthStencilResolveProperties : return "PhysicalDeviceDepthStencilResolveProperties"; - case StructureType::eSubpassDescriptionDepthStencilResolve : return "SubpassDescriptionDepthStencilResolve"; - case StructureType::eImageStencilUsageCreateInfo : return "ImageStencilUsageCreateInfo"; - case StructureType::ePhysicalDeviceImagelessFramebufferFeatures : return "PhysicalDeviceImagelessFramebufferFeatures"; - case StructureType::eFramebufferAttachmentsCreateInfo : return "FramebufferAttachmentsCreateInfo"; - case StructureType::eFramebufferAttachmentImageInfo : return "FramebufferAttachmentImageInfo"; - case StructureType::eRenderPassAttachmentBeginInfo : return "RenderPassAttachmentBeginInfo"; - case StructureType::ePhysicalDeviceSeparateDepthStencilLayoutsFeatures : return "PhysicalDeviceSeparateDepthStencilLayoutsFeatures"; - case StructureType::eAttachmentReferenceStencilLayout : return "AttachmentReferenceStencilLayout"; - case StructureType::eAttachmentDescriptionStencilLayout : return "AttachmentDescriptionStencilLayout"; - case StructureType::ePhysicalDeviceVulkan13Features : return "PhysicalDeviceVulkan13Features"; - case StructureType::ePhysicalDeviceVulkan13Properties : return "PhysicalDeviceVulkan13Properties"; - case StructureType::ePhysicalDeviceToolProperties : return "PhysicalDeviceToolProperties"; - case StructureType::ePhysicalDevicePrivateDataFeatures : return "PhysicalDevicePrivateDataFeatures"; - case StructureType::eDevicePrivateDataCreateInfo : return "DevicePrivateDataCreateInfo"; - case StructureType::ePrivateDataSlotCreateInfo : return "PrivateDataSlotCreateInfo"; - case StructureType::eMemoryBarrier2 : return "MemoryBarrier2"; - case StructureType::eBufferMemoryBarrier2 : return "BufferMemoryBarrier2"; - case StructureType::eImageMemoryBarrier2 : return "ImageMemoryBarrier2"; - case StructureType::eDependencyInfo : return "DependencyInfo"; - case StructureType::eSubmitInfo2 : return "SubmitInfo2"; - case StructureType::eSemaphoreSubmitInfo : return "SemaphoreSubmitInfo"; - case StructureType::eCommandBufferSubmitInfo : return "CommandBufferSubmitInfo"; - case StructureType::ePhysicalDeviceSynchronization2Features : return "PhysicalDeviceSynchronization2Features"; - case StructureType::eCopyBufferInfo2 : return "CopyBufferInfo2"; - case StructureType::eCopyImageInfo2 : return "CopyImageInfo2"; - case StructureType::eCopyBufferToImageInfo2 : return "CopyBufferToImageInfo2"; - case StructureType::eCopyImageToBufferInfo2 : return "CopyImageToBufferInfo2"; - case StructureType::eBufferCopy2 : return "BufferCopy2"; - case StructureType::eImageCopy2 : return "ImageCopy2"; - case StructureType::eBufferImageCopy2 : return "BufferImageCopy2"; - case StructureType::ePhysicalDeviceTextureCompressionAstcHdrFeatures : return "PhysicalDeviceTextureCompressionAstcHdrFeatures"; - case StructureType::eFormatProperties3 : return "FormatProperties3"; - case StructureType::ePhysicalDeviceMaintenance4Features : return "PhysicalDeviceMaintenance4Features"; - case StructureType::ePhysicalDeviceMaintenance4Properties : return "PhysicalDeviceMaintenance4Properties"; - case StructureType::eDeviceBufferMemoryRequirements : return "DeviceBufferMemoryRequirements"; - case StructureType::eDeviceImageMemoryRequirements : return "DeviceImageMemoryRequirements"; - case StructureType::ePipelineCreationFeedbackCreateInfo : return "PipelineCreationFeedbackCreateInfo"; - case StructureType::ePhysicalDeviceShaderTerminateInvocationFeatures : return "PhysicalDeviceShaderTerminateInvocationFeatures"; - case StructureType::ePhysicalDeviceShaderDemoteToHelperInvocationFeatures: return "PhysicalDeviceShaderDemoteToHelperInvocationFeatures"; - case StructureType::ePhysicalDevicePipelineCreationCacheControlFeatures : return "PhysicalDevicePipelineCreationCacheControlFeatures"; - case StructureType::ePhysicalDeviceZeroInitializeWorkgroupMemoryFeatures : return "PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures"; - case StructureType::ePhysicalDeviceImageRobustnessFeatures : return "PhysicalDeviceImageRobustnessFeatures"; - case StructureType::ePhysicalDeviceSubgroupSizeControlProperties : return "PhysicalDeviceSubgroupSizeControlProperties"; - case StructureType::ePipelineShaderStageRequiredSubgroupSizeCreateInfo : return "PipelineShaderStageRequiredSubgroupSizeCreateInfo"; - case StructureType::ePhysicalDeviceSubgroupSizeControlFeatures : return "PhysicalDeviceSubgroupSizeControlFeatures"; - case StructureType::ePhysicalDeviceInlineUniformBlockFeatures : return "PhysicalDeviceInlineUniformBlockFeatures"; - case StructureType::ePhysicalDeviceInlineUniformBlockProperties : return "PhysicalDeviceInlineUniformBlockProperties"; - case StructureType::eWriteDescriptorSetInlineUniformBlock : return "WriteDescriptorSetInlineUniformBlock"; - case StructureType::eDescriptorPoolInlineUniformBlockCreateInfo : return "DescriptorPoolInlineUniformBlockCreateInfo"; - case StructureType::ePhysicalDeviceShaderIntegerDotProductFeatures : return "PhysicalDeviceShaderIntegerDotProductFeatures"; - case StructureType::ePhysicalDeviceShaderIntegerDotProductProperties : return "PhysicalDeviceShaderIntegerDotProductProperties"; - case StructureType::ePhysicalDeviceTexelBufferAlignmentProperties : return "PhysicalDeviceTexelBufferAlignmentProperties"; - case StructureType::eBlitImageInfo2 : return "BlitImageInfo2"; - case StructureType::eResolveImageInfo2 : return "ResolveImageInfo2"; - case StructureType::eImageBlit2 : return "ImageBlit2"; - case StructureType::eImageResolve2 : return "ImageResolve2"; - case StructureType::eRenderingInfo : return "RenderingInfo"; - case StructureType::eRenderingAttachmentInfo : return "RenderingAttachmentInfo"; - case StructureType::ePipelineRenderingCreateInfo : return "PipelineRenderingCreateInfo"; - case StructureType::ePhysicalDeviceDynamicRenderingFeatures : return "PhysicalDeviceDynamicRenderingFeatures"; - case StructureType::eCommandBufferInheritanceRenderingInfo : return "CommandBufferInheritanceRenderingInfo"; - case StructureType::ePhysicalDeviceVulkan14Features : return "PhysicalDeviceVulkan14Features"; - case StructureType::ePhysicalDeviceVulkan14Properties : return "PhysicalDeviceVulkan14Properties"; - case StructureType::eDeviceQueueGlobalPriorityCreateInfo : return "DeviceQueueGlobalPriorityCreateInfo"; - case StructureType::ePhysicalDeviceGlobalPriorityQueryFeatures : return "PhysicalDeviceGlobalPriorityQueryFeatures"; - case StructureType::eQueueFamilyGlobalPriorityProperties : return "QueueFamilyGlobalPriorityProperties"; - case StructureType::ePhysicalDeviceIndexTypeUint8Features : return "PhysicalDeviceIndexTypeUint8Features"; - case StructureType::eMemoryMapInfo : return "MemoryMapInfo"; - case StructureType::eMemoryUnmapInfo : return "MemoryUnmapInfo"; - case StructureType::ePhysicalDeviceMaintenance5Features : return "PhysicalDeviceMaintenance5Features"; - case StructureType::ePhysicalDeviceMaintenance5Properties : return "PhysicalDeviceMaintenance5Properties"; - case StructureType::eDeviceImageSubresourceInfo : return "DeviceImageSubresourceInfo"; - case StructureType::eSubresourceLayout2 : return "SubresourceLayout2"; - case StructureType::eImageSubresource2 : return "ImageSubresource2"; - case StructureType::eBufferUsageFlags2CreateInfo : return "BufferUsageFlags2CreateInfo"; - case StructureType::ePhysicalDeviceMaintenance6Features : return "PhysicalDeviceMaintenance6Features"; - case StructureType::ePhysicalDeviceMaintenance6Properties : return "PhysicalDeviceMaintenance6Properties"; - case StructureType::eBindMemoryStatus : return "BindMemoryStatus"; - case StructureType::ePhysicalDeviceHostImageCopyFeatures : return "PhysicalDeviceHostImageCopyFeatures"; - case StructureType::ePhysicalDeviceHostImageCopyProperties : return "PhysicalDeviceHostImageCopyProperties"; - case StructureType::eMemoryToImageCopy : return "MemoryToImageCopy"; - case StructureType::eImageToMemoryCopy : return "ImageToMemoryCopy"; - case StructureType::eCopyImageToMemoryInfo : return "CopyImageToMemoryInfo"; - case StructureType::eCopyMemoryToImageInfo : return "CopyMemoryToImageInfo"; - case StructureType::eHostImageLayoutTransitionInfo : return "HostImageLayoutTransitionInfo"; - case StructureType::eCopyImageToImageInfo : return "CopyImageToImageInfo"; - case StructureType::eSubresourceHostMemcpySize : return "SubresourceHostMemcpySize"; - case StructureType::eHostImageCopyDevicePerformanceQuery : return "HostImageCopyDevicePerformanceQuery"; - case StructureType::ePhysicalDeviceShaderSubgroupRotateFeatures : return "PhysicalDeviceShaderSubgroupRotateFeatures"; - case StructureType::ePhysicalDeviceShaderFloatControls2Features : return "PhysicalDeviceShaderFloatControls2Features"; - case StructureType::ePhysicalDeviceShaderExpectAssumeFeatures : return "PhysicalDeviceShaderExpectAssumeFeatures"; - case StructureType::ePipelineCreateFlags2CreateInfo : return "PipelineCreateFlags2CreateInfo"; - case StructureType::ePhysicalDevicePushDescriptorProperties : return "PhysicalDevicePushDescriptorProperties"; - case StructureType::eBindDescriptorSetsInfo : return "BindDescriptorSetsInfo"; - case StructureType::ePushConstantsInfo : return "PushConstantsInfo"; - case StructureType::ePushDescriptorSetInfo : return "PushDescriptorSetInfo"; - case StructureType::ePushDescriptorSetWithTemplateInfo : return "PushDescriptorSetWithTemplateInfo"; - case StructureType::ePhysicalDevicePipelineProtectedAccessFeatures : return "PhysicalDevicePipelineProtectedAccessFeatures"; - case StructureType::ePipelineRobustnessCreateInfo : return "PipelineRobustnessCreateInfo"; - case StructureType::ePhysicalDevicePipelineRobustnessFeatures : return "PhysicalDevicePipelineRobustnessFeatures"; - case StructureType::ePhysicalDevicePipelineRobustnessProperties : return "PhysicalDevicePipelineRobustnessProperties"; - case StructureType::ePhysicalDeviceLineRasterizationFeatures : return "PhysicalDeviceLineRasterizationFeatures"; - case StructureType::ePipelineRasterizationLineStateCreateInfo : return "PipelineRasterizationLineStateCreateInfo"; - case StructureType::ePhysicalDeviceLineRasterizationProperties : return "PhysicalDeviceLineRasterizationProperties"; - case StructureType::ePhysicalDeviceVertexAttributeDivisorProperties : return "PhysicalDeviceVertexAttributeDivisorProperties"; - case StructureType::ePipelineVertexInputDivisorStateCreateInfo : return "PipelineVertexInputDivisorStateCreateInfo"; - case StructureType::ePhysicalDeviceVertexAttributeDivisorFeatures : return "PhysicalDeviceVertexAttributeDivisorFeatures"; - case StructureType::eRenderingAreaInfo : return "RenderingAreaInfo"; - case StructureType::ePhysicalDeviceDynamicRenderingLocalReadFeatures : return "PhysicalDeviceDynamicRenderingLocalReadFeatures"; - case StructureType::eRenderingAttachmentLocationInfo : return "RenderingAttachmentLocationInfo"; - case StructureType::eRenderingInputAttachmentIndexInfo : return "RenderingInputAttachmentIndexInfo"; - case StructureType::eSwapchainCreateInfoKHR : return "SwapchainCreateInfoKHR"; - case StructureType::ePresentInfoKHR : return "PresentInfoKHR"; - case StructureType::eDeviceGroupPresentCapabilitiesKHR : return "DeviceGroupPresentCapabilitiesKHR"; - case StructureType::eImageSwapchainCreateInfoKHR : return "ImageSwapchainCreateInfoKHR"; - case StructureType::eBindImageMemorySwapchainInfoKHR : return "BindImageMemorySwapchainInfoKHR"; - case StructureType::eAcquireNextImageInfoKHR : return "AcquireNextImageInfoKHR"; - case StructureType::eDeviceGroupPresentInfoKHR : return "DeviceGroupPresentInfoKHR"; - case StructureType::eDeviceGroupSwapchainCreateInfoKHR : return "DeviceGroupSwapchainCreateInfoKHR"; - case StructureType::eDisplayModeCreateInfoKHR : return "DisplayModeCreateInfoKHR"; - case StructureType::eDisplaySurfaceCreateInfoKHR : return "DisplaySurfaceCreateInfoKHR"; - case StructureType::eDisplayPresentInfoKHR : return "DisplayPresentInfoKHR"; -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - case StructureType::eXlibSurfaceCreateInfoKHR: return "XlibSurfaceCreateInfoKHR"; -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ -#if defined( VK_USE_PLATFORM_XCB_KHR ) - case StructureType::eXcbSurfaceCreateInfoKHR: return "XcbSurfaceCreateInfoKHR"; -#endif /*VK_USE_PLATFORM_XCB_KHR*/ -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - case StructureType::eWaylandSurfaceCreateInfoKHR: return "WaylandSurfaceCreateInfoKHR"; -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - case StructureType::eAndroidSurfaceCreateInfoKHR: return "AndroidSurfaceCreateInfoKHR"; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - case StructureType::eWin32SurfaceCreateInfoKHR: return "Win32SurfaceCreateInfoKHR"; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - case StructureType::eDebugReportCallbackCreateInfoEXT : return "DebugReportCallbackCreateInfoEXT"; - case StructureType::ePipelineRasterizationStateRasterizationOrderAMD: return "PipelineRasterizationStateRasterizationOrderAMD"; - case StructureType::eDebugMarkerObjectNameInfoEXT : return "DebugMarkerObjectNameInfoEXT"; - case StructureType::eDebugMarkerObjectTagInfoEXT : return "DebugMarkerObjectTagInfoEXT"; - case StructureType::eDebugMarkerMarkerInfoEXT : return "DebugMarkerMarkerInfoEXT"; - case StructureType::eVideoProfileInfoKHR : return "VideoProfileInfoKHR"; - case StructureType::eVideoCapabilitiesKHR : return "VideoCapabilitiesKHR"; - case StructureType::eVideoPictureResourceInfoKHR : return "VideoPictureResourceInfoKHR"; - case StructureType::eVideoSessionMemoryRequirementsKHR : return "VideoSessionMemoryRequirementsKHR"; - case StructureType::eBindVideoSessionMemoryInfoKHR : return "BindVideoSessionMemoryInfoKHR"; - case StructureType::eVideoSessionCreateInfoKHR : return "VideoSessionCreateInfoKHR"; - case StructureType::eVideoSessionParametersCreateInfoKHR : return "VideoSessionParametersCreateInfoKHR"; - case StructureType::eVideoSessionParametersUpdateInfoKHR : return "VideoSessionParametersUpdateInfoKHR"; - case StructureType::eVideoBeginCodingInfoKHR : return "VideoBeginCodingInfoKHR"; - case StructureType::eVideoEndCodingInfoKHR : return "VideoEndCodingInfoKHR"; - case StructureType::eVideoCodingControlInfoKHR : return "VideoCodingControlInfoKHR"; - case StructureType::eVideoReferenceSlotInfoKHR : return "VideoReferenceSlotInfoKHR"; - case StructureType::eQueueFamilyVideoPropertiesKHR : return "QueueFamilyVideoPropertiesKHR"; - case StructureType::eVideoProfileListInfoKHR : return "VideoProfileListInfoKHR"; - case StructureType::ePhysicalDeviceVideoFormatInfoKHR : return "PhysicalDeviceVideoFormatInfoKHR"; - case StructureType::eVideoFormatPropertiesKHR : return "VideoFormatPropertiesKHR"; - case StructureType::eQueueFamilyQueryResultStatusPropertiesKHR : return "QueueFamilyQueryResultStatusPropertiesKHR"; - case StructureType::eVideoDecodeInfoKHR : return "VideoDecodeInfoKHR"; - case StructureType::eVideoDecodeCapabilitiesKHR : return "VideoDecodeCapabilitiesKHR"; - case StructureType::eVideoDecodeUsageInfoKHR : return "VideoDecodeUsageInfoKHR"; - case StructureType::eDedicatedAllocationImageCreateInfoNV : return "DedicatedAllocationImageCreateInfoNV"; - case StructureType::eDedicatedAllocationBufferCreateInfoNV : return "DedicatedAllocationBufferCreateInfoNV"; - case StructureType::eDedicatedAllocationMemoryAllocateInfoNV : return "DedicatedAllocationMemoryAllocateInfoNV"; - case StructureType::ePhysicalDeviceTransformFeedbackFeaturesEXT : return "PhysicalDeviceTransformFeedbackFeaturesEXT"; - case StructureType::ePhysicalDeviceTransformFeedbackPropertiesEXT : return "PhysicalDeviceTransformFeedbackPropertiesEXT"; - case StructureType::ePipelineRasterizationStateStreamCreateInfoEXT : return "PipelineRasterizationStateStreamCreateInfoEXT"; - case StructureType::eCuModuleCreateInfoNVX : return "CuModuleCreateInfoNVX"; - case StructureType::eCuFunctionCreateInfoNVX : return "CuFunctionCreateInfoNVX"; - case StructureType::eCuLaunchInfoNVX : return "CuLaunchInfoNVX"; - case StructureType::eCuModuleTexturingModeCreateInfoNVX : return "CuModuleTexturingModeCreateInfoNVX"; - case StructureType::eImageViewHandleInfoNVX : return "ImageViewHandleInfoNVX"; - case StructureType::eImageViewAddressPropertiesNVX : return "ImageViewAddressPropertiesNVX"; - case StructureType::eVideoEncodeH264CapabilitiesKHR : return "VideoEncodeH264CapabilitiesKHR"; - case StructureType::eVideoEncodeH264SessionParametersCreateInfoKHR : return "VideoEncodeH264SessionParametersCreateInfoKHR"; - case StructureType::eVideoEncodeH264SessionParametersAddInfoKHR : return "VideoEncodeH264SessionParametersAddInfoKHR"; - case StructureType::eVideoEncodeH264PictureInfoKHR : return "VideoEncodeH264PictureInfoKHR"; - case StructureType::eVideoEncodeH264DpbSlotInfoKHR : return "VideoEncodeH264DpbSlotInfoKHR"; - case StructureType::eVideoEncodeH264NaluSliceInfoKHR : return "VideoEncodeH264NaluSliceInfoKHR"; - case StructureType::eVideoEncodeH264GopRemainingFrameInfoKHR : return "VideoEncodeH264GopRemainingFrameInfoKHR"; - case StructureType::eVideoEncodeH264ProfileInfoKHR : return "VideoEncodeH264ProfileInfoKHR"; - case StructureType::eVideoEncodeH264RateControlInfoKHR : return "VideoEncodeH264RateControlInfoKHR"; - case StructureType::eVideoEncodeH264RateControlLayerInfoKHR : return "VideoEncodeH264RateControlLayerInfoKHR"; - case StructureType::eVideoEncodeH264SessionCreateInfoKHR : return "VideoEncodeH264SessionCreateInfoKHR"; - case StructureType::eVideoEncodeH264QualityLevelPropertiesKHR : return "VideoEncodeH264QualityLevelPropertiesKHR"; - case StructureType::eVideoEncodeH264SessionParametersGetInfoKHR : return "VideoEncodeH264SessionParametersGetInfoKHR"; - case StructureType::eVideoEncodeH264SessionParametersFeedbackInfoKHR: return "VideoEncodeH264SessionParametersFeedbackInfoKHR"; - case StructureType::eVideoEncodeH265CapabilitiesKHR : return "VideoEncodeH265CapabilitiesKHR"; - case StructureType::eVideoEncodeH265SessionParametersCreateInfoKHR : return "VideoEncodeH265SessionParametersCreateInfoKHR"; - case StructureType::eVideoEncodeH265SessionParametersAddInfoKHR : return "VideoEncodeH265SessionParametersAddInfoKHR"; - case StructureType::eVideoEncodeH265PictureInfoKHR : return "VideoEncodeH265PictureInfoKHR"; - case StructureType::eVideoEncodeH265DpbSlotInfoKHR : return "VideoEncodeH265DpbSlotInfoKHR"; - case StructureType::eVideoEncodeH265NaluSliceSegmentInfoKHR : return "VideoEncodeH265NaluSliceSegmentInfoKHR"; - case StructureType::eVideoEncodeH265GopRemainingFrameInfoKHR : return "VideoEncodeH265GopRemainingFrameInfoKHR"; - case StructureType::eVideoEncodeH265ProfileInfoKHR : return "VideoEncodeH265ProfileInfoKHR"; - case StructureType::eVideoEncodeH265RateControlInfoKHR : return "VideoEncodeH265RateControlInfoKHR"; - case StructureType::eVideoEncodeH265RateControlLayerInfoKHR : return "VideoEncodeH265RateControlLayerInfoKHR"; - case StructureType::eVideoEncodeH265SessionCreateInfoKHR : return "VideoEncodeH265SessionCreateInfoKHR"; - case StructureType::eVideoEncodeH265QualityLevelPropertiesKHR : return "VideoEncodeH265QualityLevelPropertiesKHR"; - case StructureType::eVideoEncodeH265SessionParametersGetInfoKHR : return "VideoEncodeH265SessionParametersGetInfoKHR"; - case StructureType::eVideoEncodeH265SessionParametersFeedbackInfoKHR: return "VideoEncodeH265SessionParametersFeedbackInfoKHR"; - case StructureType::eVideoDecodeH264CapabilitiesKHR : return "VideoDecodeH264CapabilitiesKHR"; - case StructureType::eVideoDecodeH264PictureInfoKHR : return "VideoDecodeH264PictureInfoKHR"; - case StructureType::eVideoDecodeH264ProfileInfoKHR : return "VideoDecodeH264ProfileInfoKHR"; - case StructureType::eVideoDecodeH264SessionParametersCreateInfoKHR : return "VideoDecodeH264SessionParametersCreateInfoKHR"; - case StructureType::eVideoDecodeH264SessionParametersAddInfoKHR : return "VideoDecodeH264SessionParametersAddInfoKHR"; - case StructureType::eVideoDecodeH264DpbSlotInfoKHR : return "VideoDecodeH264DpbSlotInfoKHR"; - case StructureType::eTextureLodGatherFormatPropertiesAMD : return "TextureLodGatherFormatPropertiesAMD"; -#if defined( VK_USE_PLATFORM_GGP ) - case StructureType::eStreamDescriptorSurfaceCreateInfoGGP: return "StreamDescriptorSurfaceCreateInfoGGP"; -#endif /*VK_USE_PLATFORM_GGP*/ - case StructureType::ePhysicalDeviceCornerSampledImageFeaturesNV: return "PhysicalDeviceCornerSampledImageFeaturesNV"; - case StructureType::eExternalMemoryImageCreateInfoNV : return "ExternalMemoryImageCreateInfoNV"; - case StructureType::eExportMemoryAllocateInfoNV : return "ExportMemoryAllocateInfoNV"; -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - case StructureType::eImportMemoryWin32HandleInfoNV : return "ImportMemoryWin32HandleInfoNV"; - case StructureType::eExportMemoryWin32HandleInfoNV : return "ExportMemoryWin32HandleInfoNV"; - case StructureType::eWin32KeyedMutexAcquireReleaseInfoNV: return "Win32KeyedMutexAcquireReleaseInfoNV"; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - case StructureType::eValidationFlagsEXT: return "ValidationFlagsEXT"; -#if defined( VK_USE_PLATFORM_VI_NN ) - case StructureType::eViSurfaceCreateInfoNN: return "ViSurfaceCreateInfoNN"; -#endif /*VK_USE_PLATFORM_VI_NN*/ - case StructureType::eImageViewAstcDecodeModeEXT : return "ImageViewAstcDecodeModeEXT"; - case StructureType::ePhysicalDeviceAstcDecodeFeaturesEXT: return "PhysicalDeviceAstcDecodeFeaturesEXT"; -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - case StructureType::eImportMemoryWin32HandleInfoKHR: return "ImportMemoryWin32HandleInfoKHR"; - case StructureType::eExportMemoryWin32HandleInfoKHR: return "ExportMemoryWin32HandleInfoKHR"; - case StructureType::eMemoryWin32HandlePropertiesKHR: return "MemoryWin32HandlePropertiesKHR"; - case StructureType::eMemoryGetWin32HandleInfoKHR : return "MemoryGetWin32HandleInfoKHR"; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - case StructureType::eImportMemoryFdInfoKHR: return "ImportMemoryFdInfoKHR"; - case StructureType::eMemoryFdPropertiesKHR: return "MemoryFdPropertiesKHR"; - case StructureType::eMemoryGetFdInfoKHR : return "MemoryGetFdInfoKHR"; -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - case StructureType::eWin32KeyedMutexAcquireReleaseInfoKHR: return "Win32KeyedMutexAcquireReleaseInfoKHR"; - case StructureType::eImportSemaphoreWin32HandleInfoKHR : return "ImportSemaphoreWin32HandleInfoKHR"; - case StructureType::eExportSemaphoreWin32HandleInfoKHR : return "ExportSemaphoreWin32HandleInfoKHR"; - case StructureType::eD3D12FenceSubmitInfoKHR : return "D3D12FenceSubmitInfoKHR"; - case StructureType::eSemaphoreGetWin32HandleInfoKHR : return "SemaphoreGetWin32HandleInfoKHR"; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - case StructureType::eImportSemaphoreFdInfoKHR : return "ImportSemaphoreFdInfoKHR"; - case StructureType::eSemaphoreGetFdInfoKHR : return "SemaphoreGetFdInfoKHR"; - case StructureType::eCommandBufferInheritanceConditionalRenderingInfoEXT : return "CommandBufferInheritanceConditionalRenderingInfoEXT"; - case StructureType::ePhysicalDeviceConditionalRenderingFeaturesEXT : return "PhysicalDeviceConditionalRenderingFeaturesEXT"; - case StructureType::eConditionalRenderingBeginInfoEXT : return "ConditionalRenderingBeginInfoEXT"; - case StructureType::ePresentRegionsKHR : return "PresentRegionsKHR"; - case StructureType::ePipelineViewportWScalingStateCreateInfoNV : return "PipelineViewportWScalingStateCreateInfoNV"; - case StructureType::eSurfaceCapabilities2EXT : return "SurfaceCapabilities2EXT"; - case StructureType::eDisplayPowerInfoEXT : return "DisplayPowerInfoEXT"; - case StructureType::eDeviceEventInfoEXT : return "DeviceEventInfoEXT"; - case StructureType::eDisplayEventInfoEXT : return "DisplayEventInfoEXT"; - case StructureType::eSwapchainCounterCreateInfoEXT : return "SwapchainCounterCreateInfoEXT"; - case StructureType::ePresentTimesInfoGOOGLE : return "PresentTimesInfoGOOGLE"; - case StructureType::ePhysicalDeviceMultiviewPerViewAttributesPropertiesNVX: return "PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX"; - case StructureType::eMultiviewPerViewAttributesInfoNVX : return "MultiviewPerViewAttributesInfoNVX"; - case StructureType::ePipelineViewportSwizzleStateCreateInfoNV : return "PipelineViewportSwizzleStateCreateInfoNV"; - case StructureType::ePhysicalDeviceDiscardRectanglePropertiesEXT : return "PhysicalDeviceDiscardRectanglePropertiesEXT"; - case StructureType::ePipelineDiscardRectangleStateCreateInfoEXT : return "PipelineDiscardRectangleStateCreateInfoEXT"; - case StructureType::ePhysicalDeviceConservativeRasterizationPropertiesEXT : return "PhysicalDeviceConservativeRasterizationPropertiesEXT"; - case StructureType::ePipelineRasterizationConservativeStateCreateInfoEXT : return "PipelineRasterizationConservativeStateCreateInfoEXT"; - case StructureType::ePhysicalDeviceDepthClipEnableFeaturesEXT : return "PhysicalDeviceDepthClipEnableFeaturesEXT"; - case StructureType::ePipelineRasterizationDepthClipStateCreateInfoEXT : return "PipelineRasterizationDepthClipStateCreateInfoEXT"; - case StructureType::eHdrMetadataEXT : return "HdrMetadataEXT"; - case StructureType::ePhysicalDeviceRelaxedLineRasterizationFeaturesIMG : return "PhysicalDeviceRelaxedLineRasterizationFeaturesIMG"; - case StructureType::eSharedPresentSurfaceCapabilitiesKHR : return "SharedPresentSurfaceCapabilitiesKHR"; -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - case StructureType::eImportFenceWin32HandleInfoKHR: return "ImportFenceWin32HandleInfoKHR"; - case StructureType::eExportFenceWin32HandleInfoKHR: return "ExportFenceWin32HandleInfoKHR"; - case StructureType::eFenceGetWin32HandleInfoKHR : return "FenceGetWin32HandleInfoKHR"; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - case StructureType::eImportFenceFdInfoKHR : return "ImportFenceFdInfoKHR"; - case StructureType::eFenceGetFdInfoKHR : return "FenceGetFdInfoKHR"; - case StructureType::ePhysicalDevicePerformanceQueryFeaturesKHR : return "PhysicalDevicePerformanceQueryFeaturesKHR"; - case StructureType::ePhysicalDevicePerformanceQueryPropertiesKHR: return "PhysicalDevicePerformanceQueryPropertiesKHR"; - case StructureType::eQueryPoolPerformanceCreateInfoKHR : return "QueryPoolPerformanceCreateInfoKHR"; - case StructureType::ePerformanceQuerySubmitInfoKHR : return "PerformanceQuerySubmitInfoKHR"; - case StructureType::eAcquireProfilingLockInfoKHR : return "AcquireProfilingLockInfoKHR"; - case StructureType::ePerformanceCounterKHR : return "PerformanceCounterKHR"; - case StructureType::ePerformanceCounterDescriptionKHR : return "PerformanceCounterDescriptionKHR"; - case StructureType::ePhysicalDeviceSurfaceInfo2KHR : return "PhysicalDeviceSurfaceInfo2KHR"; - case StructureType::eSurfaceCapabilities2KHR : return "SurfaceCapabilities2KHR"; - case StructureType::eSurfaceFormat2KHR : return "SurfaceFormat2KHR"; - case StructureType::eDisplayProperties2KHR : return "DisplayProperties2KHR"; - case StructureType::eDisplayPlaneProperties2KHR : return "DisplayPlaneProperties2KHR"; - case StructureType::eDisplayModeProperties2KHR : return "DisplayModeProperties2KHR"; - case StructureType::eDisplayPlaneInfo2KHR : return "DisplayPlaneInfo2KHR"; - case StructureType::eDisplayPlaneCapabilities2KHR : return "DisplayPlaneCapabilities2KHR"; -#if defined( VK_USE_PLATFORM_IOS_MVK ) - case StructureType::eIosSurfaceCreateInfoMVK: return "IosSurfaceCreateInfoMVK"; -#endif /*VK_USE_PLATFORM_IOS_MVK*/ -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - case StructureType::eMacosSurfaceCreateInfoMVK: return "MacosSurfaceCreateInfoMVK"; -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - case StructureType::eDebugUtilsObjectNameInfoEXT : return "DebugUtilsObjectNameInfoEXT"; - case StructureType::eDebugUtilsObjectTagInfoEXT : return "DebugUtilsObjectTagInfoEXT"; - case StructureType::eDebugUtilsLabelEXT : return "DebugUtilsLabelEXT"; - case StructureType::eDebugUtilsMessengerCallbackDataEXT: return "DebugUtilsMessengerCallbackDataEXT"; - case StructureType::eDebugUtilsMessengerCreateInfoEXT : return "DebugUtilsMessengerCreateInfoEXT"; -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - case StructureType::eAndroidHardwareBufferUsageANDROID : return "AndroidHardwareBufferUsageANDROID"; - case StructureType::eAndroidHardwareBufferPropertiesANDROID : return "AndroidHardwareBufferPropertiesANDROID"; - case StructureType::eAndroidHardwareBufferFormatPropertiesANDROID : return "AndroidHardwareBufferFormatPropertiesANDROID"; - case StructureType::eImportAndroidHardwareBufferInfoANDROID : return "ImportAndroidHardwareBufferInfoANDROID"; - case StructureType::eMemoryGetAndroidHardwareBufferInfoANDROID : return "MemoryGetAndroidHardwareBufferInfoANDROID"; - case StructureType::eExternalFormatANDROID : return "ExternalFormatANDROID"; - case StructureType::eAndroidHardwareBufferFormatProperties2ANDROID: return "AndroidHardwareBufferFormatProperties2ANDROID"; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case StructureType::ePhysicalDeviceShaderEnqueueFeaturesAMDX : return "PhysicalDeviceShaderEnqueueFeaturesAMDX"; - case StructureType::ePhysicalDeviceShaderEnqueuePropertiesAMDX: return "PhysicalDeviceShaderEnqueuePropertiesAMDX"; - case StructureType::eExecutionGraphPipelineScratchSizeAMDX : return "ExecutionGraphPipelineScratchSizeAMDX"; - case StructureType::eExecutionGraphPipelineCreateInfoAMDX : return "ExecutionGraphPipelineCreateInfoAMDX"; - case StructureType::ePipelineShaderStageNodeCreateInfoAMDX : return "PipelineShaderStageNodeCreateInfoAMDX"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case StructureType::eTexelBufferDescriptorInfoEXT : return "TexelBufferDescriptorInfoEXT"; - case StructureType::eImageDescriptorInfoEXT : return "ImageDescriptorInfoEXT"; - case StructureType::eResourceDescriptorInfoEXT : return "ResourceDescriptorInfoEXT"; - case StructureType::eBindHeapInfoEXT : return "BindHeapInfoEXT"; - case StructureType::ePushDataInfoEXT : return "PushDataInfoEXT"; - case StructureType::eDescriptorSetAndBindingMappingEXT : return "DescriptorSetAndBindingMappingEXT"; - case StructureType::eShaderDescriptorSetAndBindingMappingInfoEXT : return "ShaderDescriptorSetAndBindingMappingInfoEXT"; - case StructureType::eOpaqueCaptureDataCreateInfoEXT : return "OpaqueCaptureDataCreateInfoEXT"; - case StructureType::ePhysicalDeviceDescriptorHeapPropertiesEXT : return "PhysicalDeviceDescriptorHeapPropertiesEXT"; - case StructureType::ePhysicalDeviceDescriptorHeapFeaturesEXT : return "PhysicalDeviceDescriptorHeapFeaturesEXT"; - case StructureType::eCommandBufferInheritanceDescriptorHeapInfoEXT : return "CommandBufferInheritanceDescriptorHeapInfoEXT"; - case StructureType::eSamplerCustomBorderColorIndexCreateInfoEXT : return "SamplerCustomBorderColorIndexCreateInfoEXT"; - case StructureType::eIndirectCommandsLayoutPushDataTokenNV : return "IndirectCommandsLayoutPushDataTokenNV"; - case StructureType::eSubsampledImageFormatPropertiesEXT : return "SubsampledImageFormatPropertiesEXT"; - case StructureType::ePhysicalDeviceDescriptorHeapTensorPropertiesARM : return "PhysicalDeviceDescriptorHeapTensorPropertiesARM"; - case StructureType::eAttachmentSampleCountInfoAMD : return "AttachmentSampleCountInfoAMD"; - case StructureType::ePhysicalDeviceShaderBfloat16FeaturesKHR : return "PhysicalDeviceShaderBfloat16FeaturesKHR"; - case StructureType::eSampleLocationsInfoEXT : return "SampleLocationsInfoEXT"; - case StructureType::eRenderPassSampleLocationsBeginInfoEXT : return "RenderPassSampleLocationsBeginInfoEXT"; - case StructureType::ePipelineSampleLocationsStateCreateInfoEXT : return "PipelineSampleLocationsStateCreateInfoEXT"; - case StructureType::ePhysicalDeviceSampleLocationsPropertiesEXT : return "PhysicalDeviceSampleLocationsPropertiesEXT"; - case StructureType::eMultisamplePropertiesEXT : return "MultisamplePropertiesEXT"; - case StructureType::ePhysicalDeviceBlendOperationAdvancedFeaturesEXT : return "PhysicalDeviceBlendOperationAdvancedFeaturesEXT"; - case StructureType::ePhysicalDeviceBlendOperationAdvancedPropertiesEXT: return "PhysicalDeviceBlendOperationAdvancedPropertiesEXT"; - case StructureType::ePipelineColorBlendAdvancedStateCreateInfoEXT : return "PipelineColorBlendAdvancedStateCreateInfoEXT"; - case StructureType::ePipelineCoverageToColorStateCreateInfoNV : return "PipelineCoverageToColorStateCreateInfoNV"; - case StructureType::eWriteDescriptorSetAccelerationStructureKHR : return "WriteDescriptorSetAccelerationStructureKHR"; - case StructureType::eAccelerationStructureBuildGeometryInfoKHR : return "AccelerationStructureBuildGeometryInfoKHR"; - case StructureType::eAccelerationStructureDeviceAddressInfoKHR : return "AccelerationStructureDeviceAddressInfoKHR"; - case StructureType::eAccelerationStructureGeometryAabbsDataKHR : return "AccelerationStructureGeometryAabbsDataKHR"; - case StructureType::eAccelerationStructureGeometryInstancesDataKHR : return "AccelerationStructureGeometryInstancesDataKHR"; - case StructureType::eAccelerationStructureGeometryTrianglesDataKHR : return "AccelerationStructureGeometryTrianglesDataKHR"; - case StructureType::eAccelerationStructureGeometryKHR : return "AccelerationStructureGeometryKHR"; - case StructureType::eAccelerationStructureVersionInfoKHR : return "AccelerationStructureVersionInfoKHR"; - case StructureType::eCopyAccelerationStructureInfoKHR : return "CopyAccelerationStructureInfoKHR"; - case StructureType::eCopyAccelerationStructureToMemoryInfoKHR : return "CopyAccelerationStructureToMemoryInfoKHR"; - case StructureType::eCopyMemoryToAccelerationStructureInfoKHR : return "CopyMemoryToAccelerationStructureInfoKHR"; - case StructureType::ePhysicalDeviceAccelerationStructureFeaturesKHR : return "PhysicalDeviceAccelerationStructureFeaturesKHR"; - case StructureType::ePhysicalDeviceAccelerationStructurePropertiesKHR : return "PhysicalDeviceAccelerationStructurePropertiesKHR"; - case StructureType::eAccelerationStructureCreateInfoKHR : return "AccelerationStructureCreateInfoKHR"; - case StructureType::eAccelerationStructureBuildSizesInfoKHR : return "AccelerationStructureBuildSizesInfoKHR"; - case StructureType::ePhysicalDeviceRayTracingPipelineFeaturesKHR : return "PhysicalDeviceRayTracingPipelineFeaturesKHR"; - case StructureType::ePhysicalDeviceRayTracingPipelinePropertiesKHR : return "PhysicalDeviceRayTracingPipelinePropertiesKHR"; - case StructureType::eRayTracingPipelineCreateInfoKHR : return "RayTracingPipelineCreateInfoKHR"; - case StructureType::eRayTracingShaderGroupCreateInfoKHR : return "RayTracingShaderGroupCreateInfoKHR"; - case StructureType::eRayTracingPipelineInterfaceCreateInfoKHR : return "RayTracingPipelineInterfaceCreateInfoKHR"; - case StructureType::ePhysicalDeviceRayQueryFeaturesKHR : return "PhysicalDeviceRayQueryFeaturesKHR"; - case StructureType::ePipelineCoverageModulationStateCreateInfoNV : return "PipelineCoverageModulationStateCreateInfoNV"; - case StructureType::ePhysicalDeviceShaderSmBuiltinsFeaturesNV : return "PhysicalDeviceShaderSmBuiltinsFeaturesNV"; - case StructureType::ePhysicalDeviceShaderSmBuiltinsPropertiesNV : return "PhysicalDeviceShaderSmBuiltinsPropertiesNV"; - case StructureType::eDrmFormatModifierPropertiesListEXT : return "DrmFormatModifierPropertiesListEXT"; - case StructureType::ePhysicalDeviceImageDrmFormatModifierInfoEXT : return "PhysicalDeviceImageDrmFormatModifierInfoEXT"; - case StructureType::eImageDrmFormatModifierListCreateInfoEXT : return "ImageDrmFormatModifierListCreateInfoEXT"; - case StructureType::eImageDrmFormatModifierExplicitCreateInfoEXT : return "ImageDrmFormatModifierExplicitCreateInfoEXT"; - case StructureType::eImageDrmFormatModifierPropertiesEXT : return "ImageDrmFormatModifierPropertiesEXT"; - case StructureType::eDrmFormatModifierPropertiesList2EXT : return "DrmFormatModifierPropertiesList2EXT"; - case StructureType::eValidationCacheCreateInfoEXT : return "ValidationCacheCreateInfoEXT"; - case StructureType::eShaderModuleValidationCacheCreateInfoEXT : return "ShaderModuleValidationCacheCreateInfoEXT"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case StructureType::ePhysicalDevicePortabilitySubsetFeaturesKHR : return "PhysicalDevicePortabilitySubsetFeaturesKHR"; - case StructureType::ePhysicalDevicePortabilitySubsetPropertiesKHR: return "PhysicalDevicePortabilitySubsetPropertiesKHR"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case StructureType::ePipelineViewportShadingRateImageStateCreateInfoNV : return "PipelineViewportShadingRateImageStateCreateInfoNV"; - case StructureType::ePhysicalDeviceShadingRateImageFeaturesNV : return "PhysicalDeviceShadingRateImageFeaturesNV"; - case StructureType::ePhysicalDeviceShadingRateImagePropertiesNV : return "PhysicalDeviceShadingRateImagePropertiesNV"; - case StructureType::ePipelineViewportCoarseSampleOrderStateCreateInfoNV : return "PipelineViewportCoarseSampleOrderStateCreateInfoNV"; - case StructureType::eRayTracingPipelineCreateInfoNV : return "RayTracingPipelineCreateInfoNV"; - case StructureType::eAccelerationStructureCreateInfoNV : return "AccelerationStructureCreateInfoNV"; - case StructureType::eGeometryNV : return "GeometryNV"; - case StructureType::eGeometryTrianglesNV : return "GeometryTrianglesNV"; - case StructureType::eGeometryAabbNV : return "GeometryAabbNV"; - case StructureType::eBindAccelerationStructureMemoryInfoNV : return "BindAccelerationStructureMemoryInfoNV"; - case StructureType::eWriteDescriptorSetAccelerationStructureNV : return "WriteDescriptorSetAccelerationStructureNV"; - case StructureType::eAccelerationStructureMemoryRequirementsInfoNV : return "AccelerationStructureMemoryRequirementsInfoNV"; - case StructureType::ePhysicalDeviceRayTracingPropertiesNV : return "PhysicalDeviceRayTracingPropertiesNV"; - case StructureType::eRayTracingShaderGroupCreateInfoNV : return "RayTracingShaderGroupCreateInfoNV"; - case StructureType::eAccelerationStructureInfoNV : return "AccelerationStructureInfoNV"; - case StructureType::ePhysicalDeviceRepresentativeFragmentTestFeaturesNV : return "PhysicalDeviceRepresentativeFragmentTestFeaturesNV"; - case StructureType::ePipelineRepresentativeFragmentTestStateCreateInfoNV: return "PipelineRepresentativeFragmentTestStateCreateInfoNV"; - case StructureType::ePhysicalDeviceImageViewImageFormatInfoEXT : return "PhysicalDeviceImageViewImageFormatInfoEXT"; - case StructureType::eFilterCubicImageViewImageFormatPropertiesEXT : return "FilterCubicImageViewImageFormatPropertiesEXT"; - case StructureType::eImportMemoryHostPointerInfoEXT : return "ImportMemoryHostPointerInfoEXT"; - case StructureType::eMemoryHostPointerPropertiesEXT : return "MemoryHostPointerPropertiesEXT"; - case StructureType::ePhysicalDeviceExternalMemoryHostPropertiesEXT : return "PhysicalDeviceExternalMemoryHostPropertiesEXT"; - case StructureType::ePhysicalDeviceShaderClockFeaturesKHR : return "PhysicalDeviceShaderClockFeaturesKHR"; - case StructureType::ePipelineCompilerControlCreateInfoAMD : return "PipelineCompilerControlCreateInfoAMD"; - case StructureType::ePhysicalDeviceShaderCorePropertiesAMD : return "PhysicalDeviceShaderCorePropertiesAMD"; - case StructureType::eVideoDecodeH265CapabilitiesKHR : return "VideoDecodeH265CapabilitiesKHR"; - case StructureType::eVideoDecodeH265SessionParametersCreateInfoKHR : return "VideoDecodeH265SessionParametersCreateInfoKHR"; - case StructureType::eVideoDecodeH265SessionParametersAddInfoKHR : return "VideoDecodeH265SessionParametersAddInfoKHR"; - case StructureType::eVideoDecodeH265ProfileInfoKHR : return "VideoDecodeH265ProfileInfoKHR"; - case StructureType::eVideoDecodeH265PictureInfoKHR : return "VideoDecodeH265PictureInfoKHR"; - case StructureType::eVideoDecodeH265DpbSlotInfoKHR : return "VideoDecodeH265DpbSlotInfoKHR"; - case StructureType::eDeviceMemoryOverallocationCreateInfoAMD : return "DeviceMemoryOverallocationCreateInfoAMD"; - case StructureType::ePhysicalDeviceVertexAttributeDivisorPropertiesEXT : return "PhysicalDeviceVertexAttributeDivisorPropertiesEXT"; -#if defined( VK_USE_PLATFORM_GGP ) - case StructureType::ePresentFrameTokenGGP: return "PresentFrameTokenGGP"; -#endif /*VK_USE_PLATFORM_GGP*/ - case StructureType::ePhysicalDeviceMeshShaderFeaturesNV : return "PhysicalDeviceMeshShaderFeaturesNV"; - case StructureType::ePhysicalDeviceMeshShaderPropertiesNV : return "PhysicalDeviceMeshShaderPropertiesNV"; - case StructureType::ePhysicalDeviceShaderImageFootprintFeaturesNV : return "PhysicalDeviceShaderImageFootprintFeaturesNV"; - case StructureType::ePipelineViewportExclusiveScissorStateCreateInfoNV : return "PipelineViewportExclusiveScissorStateCreateInfoNV"; - case StructureType::ePhysicalDeviceExclusiveScissorFeaturesNV : return "PhysicalDeviceExclusiveScissorFeaturesNV"; - case StructureType::eCheckpointDataNV : return "CheckpointDataNV"; - case StructureType::eQueueFamilyCheckpointPropertiesNV : return "QueueFamilyCheckpointPropertiesNV"; - case StructureType::eQueueFamilyCheckpointProperties2NV : return "QueueFamilyCheckpointProperties2NV"; - case StructureType::eCheckpointData2NV : return "CheckpointData2NV"; - case StructureType::ePhysicalDevicePresentTimingFeaturesEXT : return "PhysicalDevicePresentTimingFeaturesEXT"; - case StructureType::eSwapchainTimingPropertiesEXT : return "SwapchainTimingPropertiesEXT"; - case StructureType::eSwapchainTimeDomainPropertiesEXT : return "SwapchainTimeDomainPropertiesEXT"; - case StructureType::ePresentTimingsInfoEXT : return "PresentTimingsInfoEXT"; - case StructureType::ePresentTimingInfoEXT : return "PresentTimingInfoEXT"; - case StructureType::ePastPresentationTimingInfoEXT : return "PastPresentationTimingInfoEXT"; - case StructureType::ePastPresentationTimingPropertiesEXT : return "PastPresentationTimingPropertiesEXT"; - case StructureType::ePastPresentationTimingEXT : return "PastPresentationTimingEXT"; - case StructureType::ePresentTimingSurfaceCapabilitiesEXT : return "PresentTimingSurfaceCapabilitiesEXT"; - case StructureType::eSwapchainCalibratedTimestampInfoEXT : return "SwapchainCalibratedTimestampInfoEXT"; - case StructureType::ePhysicalDeviceShaderIntegerFunctions2FeaturesINTEL: return "PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL"; - case StructureType::eQueryPoolPerformanceQueryCreateInfoINTEL : return "QueryPoolPerformanceQueryCreateInfoINTEL"; - case StructureType::eInitializePerformanceApiInfoINTEL : return "InitializePerformanceApiInfoINTEL"; - case StructureType::ePerformanceMarkerInfoINTEL : return "PerformanceMarkerInfoINTEL"; - case StructureType::ePerformanceStreamMarkerInfoINTEL : return "PerformanceStreamMarkerInfoINTEL"; - case StructureType::ePerformanceOverrideInfoINTEL : return "PerformanceOverrideInfoINTEL"; - case StructureType::ePerformanceConfigurationAcquireInfoINTEL : return "PerformanceConfigurationAcquireInfoINTEL"; - case StructureType::ePhysicalDevicePciBusInfoPropertiesEXT : return "PhysicalDevicePciBusInfoPropertiesEXT"; - case StructureType::eDisplayNativeHdrSurfaceCapabilitiesAMD : return "DisplayNativeHdrSurfaceCapabilitiesAMD"; - case StructureType::eSwapchainDisplayNativeHdrCreateInfoAMD : return "SwapchainDisplayNativeHdrCreateInfoAMD"; -#if defined( VK_USE_PLATFORM_FUCHSIA ) - case StructureType::eImagepipeSurfaceCreateInfoFUCHSIA: return "ImagepipeSurfaceCreateInfoFUCHSIA"; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ -#if defined( VK_USE_PLATFORM_METAL_EXT ) - case StructureType::eMetalSurfaceCreateInfoEXT: return "MetalSurfaceCreateInfoEXT"; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - case StructureType::ePhysicalDeviceFragmentDensityMapFeaturesEXT : return "PhysicalDeviceFragmentDensityMapFeaturesEXT"; - case StructureType::ePhysicalDeviceFragmentDensityMapPropertiesEXT : return "PhysicalDeviceFragmentDensityMapPropertiesEXT"; - case StructureType::eRenderPassFragmentDensityMapCreateInfoEXT : return "RenderPassFragmentDensityMapCreateInfoEXT"; - case StructureType::eRenderingFragmentDensityMapAttachmentInfoEXT : return "RenderingFragmentDensityMapAttachmentInfoEXT"; - case StructureType::eFragmentShadingRateAttachmentInfoKHR : return "FragmentShadingRateAttachmentInfoKHR"; - case StructureType::ePipelineFragmentShadingRateStateCreateInfoKHR : return "PipelineFragmentShadingRateStateCreateInfoKHR"; - case StructureType::ePhysicalDeviceFragmentShadingRatePropertiesKHR : return "PhysicalDeviceFragmentShadingRatePropertiesKHR"; - case StructureType::ePhysicalDeviceFragmentShadingRateFeaturesKHR : return "PhysicalDeviceFragmentShadingRateFeaturesKHR"; - case StructureType::ePhysicalDeviceFragmentShadingRateKHR : return "PhysicalDeviceFragmentShadingRateKHR"; - case StructureType::eRenderingFragmentShadingRateAttachmentInfoKHR : return "RenderingFragmentShadingRateAttachmentInfoKHR"; - case StructureType::ePhysicalDeviceShaderCoreProperties2AMD : return "PhysicalDeviceShaderCoreProperties2AMD"; - case StructureType::ePhysicalDeviceCoherentMemoryFeaturesAMD : return "PhysicalDeviceCoherentMemoryFeaturesAMD"; - case StructureType::ePhysicalDeviceShaderImageAtomicInt64FeaturesEXT : return "PhysicalDeviceShaderImageAtomicInt64FeaturesEXT"; - case StructureType::ePhysicalDeviceShaderQuadControlFeaturesKHR : return "PhysicalDeviceShaderQuadControlFeaturesKHR"; - case StructureType::ePhysicalDeviceMemoryBudgetPropertiesEXT : return "PhysicalDeviceMemoryBudgetPropertiesEXT"; - case StructureType::ePhysicalDeviceMemoryPriorityFeaturesEXT : return "PhysicalDeviceMemoryPriorityFeaturesEXT"; - case StructureType::eMemoryPriorityAllocateInfoEXT : return "MemoryPriorityAllocateInfoEXT"; - case StructureType::eSurfaceProtectedCapabilitiesKHR : return "SurfaceProtectedCapabilitiesKHR"; - case StructureType::ePhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV: return "PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV"; - case StructureType::ePhysicalDeviceBufferDeviceAddressFeaturesEXT : return "PhysicalDeviceBufferDeviceAddressFeaturesEXT"; - case StructureType::eBufferDeviceAddressCreateInfoEXT : return "BufferDeviceAddressCreateInfoEXT"; - case StructureType::eValidationFeaturesEXT : return "ValidationFeaturesEXT"; - case StructureType::ePhysicalDevicePresentWaitFeaturesKHR : return "PhysicalDevicePresentWaitFeaturesKHR"; - case StructureType::ePhysicalDeviceCooperativeMatrixFeaturesNV : return "PhysicalDeviceCooperativeMatrixFeaturesNV"; - case StructureType::eCooperativeMatrixPropertiesNV : return "CooperativeMatrixPropertiesNV"; - case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesNV : return "PhysicalDeviceCooperativeMatrixPropertiesNV"; - case StructureType::ePhysicalDeviceCoverageReductionModeFeaturesNV : return "PhysicalDeviceCoverageReductionModeFeaturesNV"; - case StructureType::ePipelineCoverageReductionStateCreateInfoNV : return "PipelineCoverageReductionStateCreateInfoNV"; - case StructureType::eFramebufferMixedSamplesCombinationNV : return "FramebufferMixedSamplesCombinationNV"; - case StructureType::ePhysicalDeviceFragmentShaderInterlockFeaturesEXT : return "PhysicalDeviceFragmentShaderInterlockFeaturesEXT"; - case StructureType::ePhysicalDeviceYcbcrImageArraysFeaturesEXT : return "PhysicalDeviceYcbcrImageArraysFeaturesEXT"; - case StructureType::ePhysicalDeviceProvokingVertexFeaturesEXT : return "PhysicalDeviceProvokingVertexFeaturesEXT"; - case StructureType::ePipelineRasterizationProvokingVertexStateCreateInfoEXT : return "PipelineRasterizationProvokingVertexStateCreateInfoEXT"; - case StructureType::ePhysicalDeviceProvokingVertexPropertiesEXT : return "PhysicalDeviceProvokingVertexPropertiesEXT"; -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - case StructureType::eSurfaceFullScreenExclusiveInfoEXT : return "SurfaceFullScreenExclusiveInfoEXT"; - case StructureType::eSurfaceCapabilitiesFullScreenExclusiveEXT: return "SurfaceCapabilitiesFullScreenExclusiveEXT"; - case StructureType::eSurfaceFullScreenExclusiveWin32InfoEXT : return "SurfaceFullScreenExclusiveWin32InfoEXT"; -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - case StructureType::eHeadlessSurfaceCreateInfoEXT : return "HeadlessSurfaceCreateInfoEXT"; - case StructureType::ePhysicalDeviceShaderAtomicFloatFeaturesEXT : return "PhysicalDeviceShaderAtomicFloatFeaturesEXT"; - case StructureType::ePhysicalDeviceExtendedDynamicStateFeaturesEXT : return "PhysicalDeviceExtendedDynamicStateFeaturesEXT"; - case StructureType::ePhysicalDevicePipelineExecutablePropertiesFeaturesKHR: return "PhysicalDevicePipelineExecutablePropertiesFeaturesKHR"; - case StructureType::ePipelineInfoKHR : return "PipelineInfoKHR"; - case StructureType::ePipelineExecutablePropertiesKHR : return "PipelineExecutablePropertiesKHR"; - case StructureType::ePipelineExecutableInfoKHR : return "PipelineExecutableInfoKHR"; - case StructureType::ePipelineExecutableStatisticKHR : return "PipelineExecutableStatisticKHR"; - case StructureType::ePipelineExecutableInternalRepresentationKHR : return "PipelineExecutableInternalRepresentationKHR"; - case StructureType::ePhysicalDeviceMapMemoryPlacedFeaturesEXT : return "PhysicalDeviceMapMemoryPlacedFeaturesEXT"; - case StructureType::ePhysicalDeviceMapMemoryPlacedPropertiesEXT : return "PhysicalDeviceMapMemoryPlacedPropertiesEXT"; - case StructureType::eMemoryMapPlacedInfoEXT : return "MemoryMapPlacedInfoEXT"; - case StructureType::ePhysicalDeviceShaderAtomicFloat2FeaturesEXT : return "PhysicalDeviceShaderAtomicFloat2FeaturesEXT"; - case StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesNV : return "PhysicalDeviceDeviceGeneratedCommandsPropertiesNV"; - case StructureType::eGraphicsShaderGroupCreateInfoNV : return "GraphicsShaderGroupCreateInfoNV"; - case StructureType::eGraphicsPipelineShaderGroupsCreateInfoNV : return "GraphicsPipelineShaderGroupsCreateInfoNV"; - case StructureType::eIndirectCommandsLayoutTokenNV : return "IndirectCommandsLayoutTokenNV"; - case StructureType::eIndirectCommandsLayoutCreateInfoNV : return "IndirectCommandsLayoutCreateInfoNV"; - case StructureType::eGeneratedCommandsInfoNV : return "GeneratedCommandsInfoNV"; - case StructureType::eGeneratedCommandsMemoryRequirementsInfoNV : return "GeneratedCommandsMemoryRequirementsInfoNV"; - case StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesNV : return "PhysicalDeviceDeviceGeneratedCommandsFeaturesNV"; - case StructureType::ePhysicalDeviceInheritedViewportScissorFeaturesNV : return "PhysicalDeviceInheritedViewportScissorFeaturesNV"; - case StructureType::eCommandBufferInheritanceViewportScissorInfoNV : return "CommandBufferInheritanceViewportScissorInfoNV"; - case StructureType::ePhysicalDeviceTexelBufferAlignmentFeaturesEXT : return "PhysicalDeviceTexelBufferAlignmentFeaturesEXT"; - case StructureType::eCommandBufferInheritanceRenderPassTransformInfoQCOM : return "CommandBufferInheritanceRenderPassTransformInfoQCOM"; - case StructureType::eRenderPassTransformBeginInfoQCOM : return "RenderPassTransformBeginInfoQCOM"; - case StructureType::ePhysicalDeviceDepthBiasControlFeaturesEXT : return "PhysicalDeviceDepthBiasControlFeaturesEXT"; - case StructureType::eDepthBiasInfoEXT : return "DepthBiasInfoEXT"; - case StructureType::eDepthBiasRepresentationInfoEXT : return "DepthBiasRepresentationInfoEXT"; - case StructureType::ePhysicalDeviceDeviceMemoryReportFeaturesEXT : return "PhysicalDeviceDeviceMemoryReportFeaturesEXT"; - case StructureType::eDeviceDeviceMemoryReportCreateInfoEXT : return "DeviceDeviceMemoryReportCreateInfoEXT"; - case StructureType::eDeviceMemoryReportCallbackDataEXT : return "DeviceMemoryReportCallbackDataEXT"; - case StructureType::eSamplerCustomBorderColorCreateInfoEXT : return "SamplerCustomBorderColorCreateInfoEXT"; - case StructureType::ePhysicalDeviceCustomBorderColorPropertiesEXT : return "PhysicalDeviceCustomBorderColorPropertiesEXT"; - case StructureType::ePhysicalDeviceCustomBorderColorFeaturesEXT : return "PhysicalDeviceCustomBorderColorFeaturesEXT"; - case StructureType::ePhysicalDeviceTextureCompressionAstc3DFeaturesEXT : return "PhysicalDeviceTextureCompressionAstc3DFeaturesEXT"; - case StructureType::ePipelineLibraryCreateInfoKHR : return "PipelineLibraryCreateInfoKHR"; - case StructureType::ePhysicalDevicePresentBarrierFeaturesNV : return "PhysicalDevicePresentBarrierFeaturesNV"; - case StructureType::eSurfaceCapabilitiesPresentBarrierNV : return "SurfaceCapabilitiesPresentBarrierNV"; - case StructureType::eSwapchainPresentBarrierCreateInfoNV : return "SwapchainPresentBarrierCreateInfoNV"; - case StructureType::ePresentIdKHR : return "PresentIdKHR"; - case StructureType::ePhysicalDevicePresentIdFeaturesKHR : return "PhysicalDevicePresentIdFeaturesKHR"; - case StructureType::eVideoEncodeInfoKHR : return "VideoEncodeInfoKHR"; - case StructureType::eVideoEncodeRateControlInfoKHR : return "VideoEncodeRateControlInfoKHR"; - case StructureType::eVideoEncodeRateControlLayerInfoKHR : return "VideoEncodeRateControlLayerInfoKHR"; - case StructureType::eVideoEncodeCapabilitiesKHR : return "VideoEncodeCapabilitiesKHR"; - case StructureType::eVideoEncodeUsageInfoKHR : return "VideoEncodeUsageInfoKHR"; - case StructureType::eQueryPoolVideoEncodeFeedbackCreateInfoKHR : return "QueryPoolVideoEncodeFeedbackCreateInfoKHR"; - case StructureType::ePhysicalDeviceVideoEncodeQualityLevelInfoKHR : return "PhysicalDeviceVideoEncodeQualityLevelInfoKHR"; - case StructureType::eVideoEncodeQualityLevelPropertiesKHR : return "VideoEncodeQualityLevelPropertiesKHR"; - case StructureType::eVideoEncodeQualityLevelInfoKHR : return "VideoEncodeQualityLevelInfoKHR"; - case StructureType::eVideoEncodeSessionParametersGetInfoKHR : return "VideoEncodeSessionParametersGetInfoKHR"; - case StructureType::eVideoEncodeSessionParametersFeedbackInfoKHR : return "VideoEncodeSessionParametersFeedbackInfoKHR"; - case StructureType::ePhysicalDeviceDiagnosticsConfigFeaturesNV : return "PhysicalDeviceDiagnosticsConfigFeaturesNV"; - case StructureType::eDeviceDiagnosticsConfigCreateInfoNV : return "DeviceDiagnosticsConfigCreateInfoNV"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case StructureType::eCudaModuleCreateInfoNV : return "CudaModuleCreateInfoNV"; - case StructureType::eCudaFunctionCreateInfoNV : return "CudaFunctionCreateInfoNV"; - case StructureType::eCudaLaunchInfoNV : return "CudaLaunchInfoNV"; - case StructureType::ePhysicalDeviceCudaKernelLaunchFeaturesNV : return "PhysicalDeviceCudaKernelLaunchFeaturesNV"; - case StructureType::ePhysicalDeviceCudaKernelLaunchPropertiesNV: return "PhysicalDeviceCudaKernelLaunchPropertiesNV"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case StructureType::ePhysicalDeviceTileShadingFeaturesQCOM : return "PhysicalDeviceTileShadingFeaturesQCOM"; - case StructureType::ePhysicalDeviceTileShadingPropertiesQCOM: return "PhysicalDeviceTileShadingPropertiesQCOM"; - case StructureType::eRenderPassTileShadingCreateInfoQCOM : return "RenderPassTileShadingCreateInfoQCOM"; - case StructureType::ePerTileBeginInfoQCOM : return "PerTileBeginInfoQCOM"; - case StructureType::ePerTileEndInfoQCOM : return "PerTileEndInfoQCOM"; - case StructureType::eDispatchTileInfoQCOM : return "DispatchTileInfoQCOM"; - case StructureType::eQueryLowLatencySupportNV : return "QueryLowLatencySupportNV"; -#if defined( VK_USE_PLATFORM_METAL_EXT ) - case StructureType::eExportMetalObjectCreateInfoEXT: return "ExportMetalObjectCreateInfoEXT"; - case StructureType::eExportMetalObjectsInfoEXT : return "ExportMetalObjectsInfoEXT"; - case StructureType::eExportMetalDeviceInfoEXT : return "ExportMetalDeviceInfoEXT"; - case StructureType::eExportMetalCommandQueueInfoEXT: return "ExportMetalCommandQueueInfoEXT"; - case StructureType::eExportMetalBufferInfoEXT : return "ExportMetalBufferInfoEXT"; - case StructureType::eImportMetalBufferInfoEXT : return "ImportMetalBufferInfoEXT"; - case StructureType::eExportMetalTextureInfoEXT : return "ExportMetalTextureInfoEXT"; - case StructureType::eImportMetalTextureInfoEXT : return "ImportMetalTextureInfoEXT"; - case StructureType::eExportMetalIoSurfaceInfoEXT : return "ExportMetalIoSurfaceInfoEXT"; - case StructureType::eImportMetalIoSurfaceInfoEXT : return "ImportMetalIoSurfaceInfoEXT"; - case StructureType::eExportMetalSharedEventInfoEXT : return "ExportMetalSharedEventInfoEXT"; - case StructureType::eImportMetalSharedEventInfoEXT : return "ImportMetalSharedEventInfoEXT"; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - case StructureType::ePhysicalDeviceDescriptorBufferPropertiesEXT : return "PhysicalDeviceDescriptorBufferPropertiesEXT"; - case StructureType::ePhysicalDeviceDescriptorBufferDensityMapPropertiesEXT : return "PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT"; - case StructureType::ePhysicalDeviceDescriptorBufferFeaturesEXT : return "PhysicalDeviceDescriptorBufferFeaturesEXT"; - case StructureType::eDescriptorAddressInfoEXT : return "DescriptorAddressInfoEXT"; - case StructureType::eDescriptorGetInfoEXT : return "DescriptorGetInfoEXT"; - case StructureType::eBufferCaptureDescriptorDataInfoEXT : return "BufferCaptureDescriptorDataInfoEXT"; - case StructureType::eImageCaptureDescriptorDataInfoEXT : return "ImageCaptureDescriptorDataInfoEXT"; - case StructureType::eImageViewCaptureDescriptorDataInfoEXT : return "ImageViewCaptureDescriptorDataInfoEXT"; - case StructureType::eSamplerCaptureDescriptorDataInfoEXT : return "SamplerCaptureDescriptorDataInfoEXT"; - case StructureType::eOpaqueCaptureDescriptorDataCreateInfoEXT : return "OpaqueCaptureDescriptorDataCreateInfoEXT"; - case StructureType::eDescriptorBufferBindingInfoEXT : return "DescriptorBufferBindingInfoEXT"; - case StructureType::eDescriptorBufferBindingPushDescriptorBufferHandleEXT : return "DescriptorBufferBindingPushDescriptorBufferHandleEXT"; - case StructureType::eAccelerationStructureCaptureDescriptorDataInfoEXT : return "AccelerationStructureCaptureDescriptorDataInfoEXT"; - case StructureType::ePhysicalDeviceGraphicsPipelineLibraryFeaturesEXT : return "PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT"; - case StructureType::ePhysicalDeviceGraphicsPipelineLibraryPropertiesEXT : return "PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT"; - case StructureType::eGraphicsPipelineLibraryCreateInfoEXT : return "GraphicsPipelineLibraryCreateInfoEXT"; - case StructureType::ePhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD : return "PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD"; - case StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR : return "PhysicalDeviceFragmentShaderBarycentricFeaturesKHR"; - case StructureType::ePhysicalDeviceFragmentShaderBarycentricPropertiesKHR : return "PhysicalDeviceFragmentShaderBarycentricPropertiesKHR"; - case StructureType::ePhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR: return "PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR"; - case StructureType::ePhysicalDeviceFragmentShadingRateEnumsPropertiesNV : return "PhysicalDeviceFragmentShadingRateEnumsPropertiesNV"; - case StructureType::ePhysicalDeviceFragmentShadingRateEnumsFeaturesNV : return "PhysicalDeviceFragmentShadingRateEnumsFeaturesNV"; - case StructureType::ePipelineFragmentShadingRateEnumStateCreateInfoNV : return "PipelineFragmentShadingRateEnumStateCreateInfoNV"; - case StructureType::eAccelerationStructureGeometryMotionTrianglesDataNV : return "AccelerationStructureGeometryMotionTrianglesDataNV"; - case StructureType::ePhysicalDeviceRayTracingMotionBlurFeaturesNV : return "PhysicalDeviceRayTracingMotionBlurFeaturesNV"; - case StructureType::eAccelerationStructureMotionInfoNV : return "AccelerationStructureMotionInfoNV"; - case StructureType::ePhysicalDeviceMeshShaderFeaturesEXT : return "PhysicalDeviceMeshShaderFeaturesEXT"; - case StructureType::ePhysicalDeviceMeshShaderPropertiesEXT : return "PhysicalDeviceMeshShaderPropertiesEXT"; - case StructureType::ePhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT : return "PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT"; - case StructureType::ePhysicalDeviceFragmentDensityMap2FeaturesEXT : return "PhysicalDeviceFragmentDensityMap2FeaturesEXT"; - case StructureType::ePhysicalDeviceFragmentDensityMap2PropertiesEXT : return "PhysicalDeviceFragmentDensityMap2PropertiesEXT"; - case StructureType::eCopyCommandTransformInfoQCOM : return "CopyCommandTransformInfoQCOM"; - case StructureType::ePhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR : return "PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR"; - case StructureType::ePhysicalDeviceImageCompressionControlFeaturesEXT : return "PhysicalDeviceImageCompressionControlFeaturesEXT"; - case StructureType::eImageCompressionControlEXT : return "ImageCompressionControlEXT"; - case StructureType::eImageCompressionPropertiesEXT : return "ImageCompressionPropertiesEXT"; - case StructureType::ePhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT : return "PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT"; - case StructureType::ePhysicalDevice4444FormatsFeaturesEXT : return "PhysicalDevice4444FormatsFeaturesEXT"; - case StructureType::ePhysicalDeviceFaultFeaturesEXT : return "PhysicalDeviceFaultFeaturesEXT"; - case StructureType::eDeviceFaultCountsEXT : return "DeviceFaultCountsEXT"; - case StructureType::eDeviceFaultInfoEXT : return "DeviceFaultInfoEXT"; - case StructureType::ePhysicalDeviceRgba10X6FormatsFeaturesEXT : return "PhysicalDeviceRgba10X6FormatsFeaturesEXT"; -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - case StructureType::eDirectfbSurfaceCreateInfoEXT: return "DirectfbSurfaceCreateInfoEXT"; -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - case StructureType::ePhysicalDeviceVertexInputDynamicStateFeaturesEXT : return "PhysicalDeviceVertexInputDynamicStateFeaturesEXT"; - case StructureType::eVertexInputBindingDescription2EXT : return "VertexInputBindingDescription2EXT"; - case StructureType::eVertexInputAttributeDescription2EXT : return "VertexInputAttributeDescription2EXT"; - case StructureType::ePhysicalDeviceDrmPropertiesEXT : return "PhysicalDeviceDrmPropertiesEXT"; - case StructureType::ePhysicalDeviceAddressBindingReportFeaturesEXT : return "PhysicalDeviceAddressBindingReportFeaturesEXT"; - case StructureType::eDeviceAddressBindingCallbackDataEXT : return "DeviceAddressBindingCallbackDataEXT"; - case StructureType::ePhysicalDeviceDepthClipControlFeaturesEXT : return "PhysicalDeviceDepthClipControlFeaturesEXT"; - case StructureType::ePipelineViewportDepthClipControlCreateInfoEXT : return "PipelineViewportDepthClipControlCreateInfoEXT"; - case StructureType::ePhysicalDevicePrimitiveTopologyListRestartFeaturesEXT: return "PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT"; -#if defined( VK_USE_PLATFORM_FUCHSIA ) - case StructureType::eImportMemoryZirconHandleInfoFUCHSIA : return "ImportMemoryZirconHandleInfoFUCHSIA"; - case StructureType::eMemoryZirconHandlePropertiesFUCHSIA : return "MemoryZirconHandlePropertiesFUCHSIA"; - case StructureType::eMemoryGetZirconHandleInfoFUCHSIA : return "MemoryGetZirconHandleInfoFUCHSIA"; - case StructureType::eImportSemaphoreZirconHandleInfoFUCHSIA : return "ImportSemaphoreZirconHandleInfoFUCHSIA"; - case StructureType::eSemaphoreGetZirconHandleInfoFUCHSIA : return "SemaphoreGetZirconHandleInfoFUCHSIA"; - case StructureType::eBufferCollectionCreateInfoFUCHSIA : return "BufferCollectionCreateInfoFUCHSIA"; - case StructureType::eImportMemoryBufferCollectionFUCHSIA : return "ImportMemoryBufferCollectionFUCHSIA"; - case StructureType::eBufferCollectionImageCreateInfoFUCHSIA : return "BufferCollectionImageCreateInfoFUCHSIA"; - case StructureType::eBufferCollectionPropertiesFUCHSIA : return "BufferCollectionPropertiesFUCHSIA"; - case StructureType::eBufferConstraintsInfoFUCHSIA : return "BufferConstraintsInfoFUCHSIA"; - case StructureType::eBufferCollectionBufferCreateInfoFUCHSIA: return "BufferCollectionBufferCreateInfoFUCHSIA"; - case StructureType::eImageConstraintsInfoFUCHSIA : return "ImageConstraintsInfoFUCHSIA"; - case StructureType::eImageFormatConstraintsInfoFUCHSIA : return "ImageFormatConstraintsInfoFUCHSIA"; - case StructureType::eSysmemColorSpaceFUCHSIA : return "SysmemColorSpaceFUCHSIA"; - case StructureType::eBufferCollectionConstraintsInfoFUCHSIA : return "BufferCollectionConstraintsInfoFUCHSIA"; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - case StructureType::eSubpassShadingPipelineCreateInfoHUAWEI : return "SubpassShadingPipelineCreateInfoHUAWEI"; - case StructureType::ePhysicalDeviceSubpassShadingFeaturesHUAWEI : return "PhysicalDeviceSubpassShadingFeaturesHUAWEI"; - case StructureType::ePhysicalDeviceSubpassShadingPropertiesHUAWEI : return "PhysicalDeviceSubpassShadingPropertiesHUAWEI"; - case StructureType::ePhysicalDeviceInvocationMaskFeaturesHUAWEI : return "PhysicalDeviceInvocationMaskFeaturesHUAWEI"; - case StructureType::eMemoryGetRemoteAddressInfoNV : return "MemoryGetRemoteAddressInfoNV"; - case StructureType::ePhysicalDeviceExternalMemoryRdmaFeaturesNV : return "PhysicalDeviceExternalMemoryRdmaFeaturesNV"; - case StructureType::ePipelinePropertiesIdentifierEXT : return "PipelinePropertiesIdentifierEXT"; - case StructureType::ePhysicalDevicePipelinePropertiesFeaturesEXT : return "PhysicalDevicePipelinePropertiesFeaturesEXT"; - case StructureType::ePhysicalDeviceFrameBoundaryFeaturesEXT : return "PhysicalDeviceFrameBoundaryFeaturesEXT"; - case StructureType::eFrameBoundaryEXT : return "FrameBoundaryEXT"; - case StructureType::ePhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT: return "PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT"; - case StructureType::eSubpassResolvePerformanceQueryEXT : return "SubpassResolvePerformanceQueryEXT"; - case StructureType::eMultisampledRenderToSingleSampledInfoEXT : return "MultisampledRenderToSingleSampledInfoEXT"; - case StructureType::ePhysicalDeviceExtendedDynamicState2FeaturesEXT : return "PhysicalDeviceExtendedDynamicState2FeaturesEXT"; -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - case StructureType::eScreenSurfaceCreateInfoQNX: return "ScreenSurfaceCreateInfoQNX"; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - case StructureType::ePhysicalDeviceColorWriteEnableFeaturesEXT : return "PhysicalDeviceColorWriteEnableFeaturesEXT"; - case StructureType::ePipelineColorWriteCreateInfoEXT : return "PipelineColorWriteCreateInfoEXT"; - case StructureType::ePhysicalDevicePrimitivesGeneratedQueryFeaturesEXT : return "PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT"; - case StructureType::ePhysicalDeviceRayTracingMaintenance1FeaturesKHR : return "PhysicalDeviceRayTracingMaintenance1FeaturesKHR"; - case StructureType::ePhysicalDeviceShaderUntypedPointersFeaturesKHR : return "PhysicalDeviceShaderUntypedPointersFeaturesKHR"; - case StructureType::ePhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE: return "PhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE"; - case StructureType::eVideoEncodeRgbConversionCapabilitiesVALVE : return "VideoEncodeRgbConversionCapabilitiesVALVE"; - case StructureType::eVideoEncodeProfileRgbConversionInfoVALVE : return "VideoEncodeProfileRgbConversionInfoVALVE"; - case StructureType::eVideoEncodeSessionRgbConversionCreateInfoVALVE : return "VideoEncodeSessionRgbConversionCreateInfoVALVE"; - case StructureType::ePhysicalDeviceImageViewMinLodFeaturesEXT : return "PhysicalDeviceImageViewMinLodFeaturesEXT"; - case StructureType::eImageViewMinLodCreateInfoEXT : return "ImageViewMinLodCreateInfoEXT"; - case StructureType::ePhysicalDeviceMultiDrawFeaturesEXT : return "PhysicalDeviceMultiDrawFeaturesEXT"; - case StructureType::ePhysicalDeviceMultiDrawPropertiesEXT : return "PhysicalDeviceMultiDrawPropertiesEXT"; - case StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT : return "PhysicalDeviceImage2DViewOf3DFeaturesEXT"; - case StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT : return "PhysicalDeviceShaderTileImageFeaturesEXT"; - case StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT : return "PhysicalDeviceShaderTileImagePropertiesEXT"; - case StructureType::eMicromapBuildInfoEXT : return "MicromapBuildInfoEXT"; - case StructureType::eMicromapVersionInfoEXT : return "MicromapVersionInfoEXT"; - case StructureType::eCopyMicromapInfoEXT : return "CopyMicromapInfoEXT"; - case StructureType::eCopyMicromapToMemoryInfoEXT : return "CopyMicromapToMemoryInfoEXT"; - case StructureType::eCopyMemoryToMicromapInfoEXT : return "CopyMemoryToMicromapInfoEXT"; - case StructureType::ePhysicalDeviceOpacityMicromapFeaturesEXT : return "PhysicalDeviceOpacityMicromapFeaturesEXT"; - case StructureType::ePhysicalDeviceOpacityMicromapPropertiesEXT : return "PhysicalDeviceOpacityMicromapPropertiesEXT"; - case StructureType::eMicromapCreateInfoEXT : return "MicromapCreateInfoEXT"; - case StructureType::eMicromapBuildSizesInfoEXT : return "MicromapBuildSizesInfoEXT"; - case StructureType::eAccelerationStructureTrianglesOpacityMicromapEXT : return "AccelerationStructureTrianglesOpacityMicromapEXT"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case StructureType::ePhysicalDeviceDisplacementMicromapFeaturesNV : return "PhysicalDeviceDisplacementMicromapFeaturesNV"; - case StructureType::ePhysicalDeviceDisplacementMicromapPropertiesNV : return "PhysicalDeviceDisplacementMicromapPropertiesNV"; - case StructureType::eAccelerationStructureTrianglesDisplacementMicromapNV: return "AccelerationStructureTrianglesDisplacementMicromapNV"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case StructureType::ePhysicalDeviceClusterCullingShaderFeaturesHUAWEI : return "PhysicalDeviceClusterCullingShaderFeaturesHUAWEI"; - case StructureType::ePhysicalDeviceClusterCullingShaderPropertiesHUAWEI : return "PhysicalDeviceClusterCullingShaderPropertiesHUAWEI"; - case StructureType::ePhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI : return "PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI"; - case StructureType::ePhysicalDeviceBorderColorSwizzleFeaturesEXT : return "PhysicalDeviceBorderColorSwizzleFeaturesEXT"; - case StructureType::eSamplerBorderColorComponentMappingCreateInfoEXT : return "SamplerBorderColorComponentMappingCreateInfoEXT"; - case StructureType::ePhysicalDevicePageableDeviceLocalMemoryFeaturesEXT : return "PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT"; - case StructureType::ePhysicalDeviceShaderCorePropertiesARM : return "PhysicalDeviceShaderCorePropertiesARM"; - case StructureType::eDeviceQueueShaderCoreControlCreateInfoARM : return "DeviceQueueShaderCoreControlCreateInfoARM"; - case StructureType::ePhysicalDeviceSchedulingControlsFeaturesARM : return "PhysicalDeviceSchedulingControlsFeaturesARM"; - case StructureType::ePhysicalDeviceSchedulingControlsPropertiesARM : return "PhysicalDeviceSchedulingControlsPropertiesARM"; - case StructureType::ePhysicalDeviceImageSlicedViewOf3DFeaturesEXT : return "PhysicalDeviceImageSlicedViewOf3DFeaturesEXT"; - case StructureType::eImageViewSlicedCreateInfoEXT : return "ImageViewSlicedCreateInfoEXT"; - case StructureType::ePhysicalDeviceDescriptorSetHostMappingFeaturesVALVE : return "PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE"; - case StructureType::eDescriptorSetBindingReferenceVALVE : return "DescriptorSetBindingReferenceVALVE"; - case StructureType::eDescriptorSetLayoutHostMappingInfoVALVE : return "DescriptorSetLayoutHostMappingInfoVALVE"; - case StructureType::ePhysicalDeviceNonSeamlessCubeMapFeaturesEXT : return "PhysicalDeviceNonSeamlessCubeMapFeaturesEXT"; - case StructureType::ePhysicalDeviceRenderPassStripedFeaturesARM : return "PhysicalDeviceRenderPassStripedFeaturesARM"; - case StructureType::ePhysicalDeviceRenderPassStripedPropertiesARM : return "PhysicalDeviceRenderPassStripedPropertiesARM"; - case StructureType::eRenderPassStripeBeginInfoARM : return "RenderPassStripeBeginInfoARM"; - case StructureType::eRenderPassStripeInfoARM : return "RenderPassStripeInfoARM"; - case StructureType::eRenderPassStripeSubmitInfoARM : return "RenderPassStripeSubmitInfoARM"; - case StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesNV : return "PhysicalDeviceCopyMemoryIndirectFeaturesNV"; - case StructureType::ePhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV : return "PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV"; - case StructureType::eComputePipelineIndirectBufferInfoNV : return "ComputePipelineIndirectBufferInfoNV"; - case StructureType::ePipelineIndirectDeviceAddressInfoNV : return "PipelineIndirectDeviceAddressInfoNV"; - case StructureType::ePhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV : return "PhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV"; - case StructureType::eAccelerationStructureGeometryLinearSweptSpheresDataNV : return "AccelerationStructureGeometryLinearSweptSpheresDataNV"; - case StructureType::eAccelerationStructureGeometrySpheresDataNV : return "AccelerationStructureGeometrySpheresDataNV"; - case StructureType::ePhysicalDeviceLinearColorAttachmentFeaturesNV : return "PhysicalDeviceLinearColorAttachmentFeaturesNV"; - case StructureType::ePhysicalDeviceShaderMaximalReconvergenceFeaturesKHR : return "PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR"; - case StructureType::ePhysicalDeviceImageCompressionControlSwapchainFeaturesEXT: return "PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT"; - case StructureType::ePhysicalDeviceImageProcessingFeaturesQCOM : return "PhysicalDeviceImageProcessingFeaturesQCOM"; - case StructureType::ePhysicalDeviceImageProcessingPropertiesQCOM : return "PhysicalDeviceImageProcessingPropertiesQCOM"; - case StructureType::eImageViewSampleWeightCreateInfoQCOM : return "ImageViewSampleWeightCreateInfoQCOM"; - case StructureType::ePhysicalDeviceNestedCommandBufferFeaturesEXT : return "PhysicalDeviceNestedCommandBufferFeaturesEXT"; - case StructureType::ePhysicalDeviceNestedCommandBufferPropertiesEXT : return "PhysicalDeviceNestedCommandBufferPropertiesEXT"; -#if defined( VK_USE_PLATFORM_OHOS ) - case StructureType::eNativeBufferUsageOHOS : return "NativeBufferUsageOHOS"; - case StructureType::eNativeBufferPropertiesOHOS : return "NativeBufferPropertiesOHOS"; - case StructureType::eNativeBufferFormatPropertiesOHOS: return "NativeBufferFormatPropertiesOHOS"; - case StructureType::eImportNativeBufferInfoOHOS : return "ImportNativeBufferInfoOHOS"; - case StructureType::eMemoryGetNativeBufferInfoOHOS : return "MemoryGetNativeBufferInfoOHOS"; - case StructureType::eExternalFormatOHOS : return "ExternalFormatOHOS"; -#endif /*VK_USE_PLATFORM_OHOS*/ - case StructureType::eExternalMemoryAcquireUnmodifiedEXT : return "ExternalMemoryAcquireUnmodifiedEXT"; - case StructureType::ePhysicalDeviceExtendedDynamicState3FeaturesEXT : return "PhysicalDeviceExtendedDynamicState3FeaturesEXT"; - case StructureType::ePhysicalDeviceExtendedDynamicState3PropertiesEXT : return "PhysicalDeviceExtendedDynamicState3PropertiesEXT"; - case StructureType::ePhysicalDeviceSubpassMergeFeedbackFeaturesEXT : return "PhysicalDeviceSubpassMergeFeedbackFeaturesEXT"; - case StructureType::eRenderPassCreationControlEXT : return "RenderPassCreationControlEXT"; - case StructureType::eRenderPassCreationFeedbackCreateInfoEXT : return "RenderPassCreationFeedbackCreateInfoEXT"; - case StructureType::eRenderPassSubpassFeedbackCreateInfoEXT : return "RenderPassSubpassFeedbackCreateInfoEXT"; - case StructureType::eDirectDriverLoadingInfoLUNARG : return "DirectDriverLoadingInfoLUNARG"; - case StructureType::eDirectDriverLoadingListLUNARG : return "DirectDriverLoadingListLUNARG"; - case StructureType::eTensorCreateInfoARM : return "TensorCreateInfoARM"; - case StructureType::eTensorViewCreateInfoARM : return "TensorViewCreateInfoARM"; - case StructureType::eBindTensorMemoryInfoARM : return "BindTensorMemoryInfoARM"; - case StructureType::eWriteDescriptorSetTensorARM : return "WriteDescriptorSetTensorARM"; - case StructureType::ePhysicalDeviceTensorPropertiesARM : return "PhysicalDeviceTensorPropertiesARM"; - case StructureType::eTensorFormatPropertiesARM : return "TensorFormatPropertiesARM"; - case StructureType::eTensorDescriptionARM : return "TensorDescriptionARM"; - case StructureType::eTensorMemoryRequirementsInfoARM : return "TensorMemoryRequirementsInfoARM"; - case StructureType::eTensorMemoryBarrierARM : return "TensorMemoryBarrierARM"; - case StructureType::ePhysicalDeviceTensorFeaturesARM : return "PhysicalDeviceTensorFeaturesARM"; - case StructureType::eDeviceTensorMemoryRequirementsARM : return "DeviceTensorMemoryRequirementsARM"; - case StructureType::eCopyTensorInfoARM : return "CopyTensorInfoARM"; - case StructureType::eTensorCopyARM : return "TensorCopyARM"; - case StructureType::eTensorDependencyInfoARM : return "TensorDependencyInfoARM"; - case StructureType::eMemoryDedicatedAllocateInfoTensorARM : return "MemoryDedicatedAllocateInfoTensorARM"; - case StructureType::ePhysicalDeviceExternalTensorInfoARM : return "PhysicalDeviceExternalTensorInfoARM"; - case StructureType::eExternalTensorPropertiesARM : return "ExternalTensorPropertiesARM"; - case StructureType::eExternalMemoryTensorCreateInfoARM : return "ExternalMemoryTensorCreateInfoARM"; - case StructureType::ePhysicalDeviceDescriptorBufferTensorFeaturesARM : return "PhysicalDeviceDescriptorBufferTensorFeaturesARM"; - case StructureType::ePhysicalDeviceDescriptorBufferTensorPropertiesARM : return "PhysicalDeviceDescriptorBufferTensorPropertiesARM"; - case StructureType::eDescriptorGetTensorInfoARM : return "DescriptorGetTensorInfoARM"; - case StructureType::eTensorCaptureDescriptorDataInfoARM : return "TensorCaptureDescriptorDataInfoARM"; - case StructureType::eTensorViewCaptureDescriptorDataInfoARM : return "TensorViewCaptureDescriptorDataInfoARM"; - case StructureType::eFrameBoundaryTensorsARM : return "FrameBoundaryTensorsARM"; - case StructureType::ePhysicalDeviceShaderModuleIdentifierFeaturesEXT : return "PhysicalDeviceShaderModuleIdentifierFeaturesEXT"; - case StructureType::ePhysicalDeviceShaderModuleIdentifierPropertiesEXT : return "PhysicalDeviceShaderModuleIdentifierPropertiesEXT"; - case StructureType::ePipelineShaderStageModuleIdentifierCreateInfoEXT : return "PipelineShaderStageModuleIdentifierCreateInfoEXT"; - case StructureType::eShaderModuleIdentifierEXT : return "ShaderModuleIdentifierEXT"; - case StructureType::ePhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT: return "PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT"; - case StructureType::ePhysicalDeviceOpticalFlowFeaturesNV : return "PhysicalDeviceOpticalFlowFeaturesNV"; - case StructureType::ePhysicalDeviceOpticalFlowPropertiesNV : return "PhysicalDeviceOpticalFlowPropertiesNV"; - case StructureType::eOpticalFlowImageFormatInfoNV : return "OpticalFlowImageFormatInfoNV"; - case StructureType::eOpticalFlowImageFormatPropertiesNV : return "OpticalFlowImageFormatPropertiesNV"; - case StructureType::eOpticalFlowSessionCreateInfoNV : return "OpticalFlowSessionCreateInfoNV"; - case StructureType::eOpticalFlowExecuteInfoNV : return "OpticalFlowExecuteInfoNV"; - case StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV : return "OpticalFlowSessionCreatePrivateDataInfoNV"; - case StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT : return "PhysicalDeviceLegacyDitheringFeaturesEXT"; -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - case StructureType::ePhysicalDeviceExternalFormatResolveFeaturesANDROID : return "PhysicalDeviceExternalFormatResolveFeaturesANDROID"; - case StructureType::ePhysicalDeviceExternalFormatResolvePropertiesANDROID: return "PhysicalDeviceExternalFormatResolvePropertiesANDROID"; - case StructureType::eAndroidHardwareBufferFormatResolvePropertiesANDROID : return "AndroidHardwareBufferFormatResolvePropertiesANDROID"; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - case StructureType::ePhysicalDeviceAntiLagFeaturesAMD: return "PhysicalDeviceAntiLagFeaturesAMD"; - case StructureType::eAntiLagDataAMD : return "AntiLagDataAMD"; - case StructureType::eAntiLagPresentationInfoAMD : return "AntiLagPresentationInfoAMD"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case StructureType::ePhysicalDeviceDenseGeometryFormatFeaturesAMDX : return "PhysicalDeviceDenseGeometryFormatFeaturesAMDX"; - case StructureType::eAccelerationStructureDenseGeometryFormatTrianglesDataAMDX: return "AccelerationStructureDenseGeometryFormatTrianglesDataAMDX"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case StructureType::eSurfaceCapabilitiesPresentId2KHR : return "SurfaceCapabilitiesPresentId2KHR"; - case StructureType::ePresentId2KHR : return "PresentId2KHR"; - case StructureType::ePhysicalDevicePresentId2FeaturesKHR : return "PhysicalDevicePresentId2FeaturesKHR"; - case StructureType::eSurfaceCapabilitiesPresentWait2KHR : return "SurfaceCapabilitiesPresentWait2KHR"; - case StructureType::ePhysicalDevicePresentWait2FeaturesKHR : return "PhysicalDevicePresentWait2FeaturesKHR"; - case StructureType::ePresentWait2InfoKHR : return "PresentWait2InfoKHR"; - case StructureType::ePhysicalDeviceRayTracingPositionFetchFeaturesKHR : return "PhysicalDeviceRayTracingPositionFetchFeaturesKHR"; - case StructureType::ePhysicalDeviceShaderObjectFeaturesEXT : return "PhysicalDeviceShaderObjectFeaturesEXT"; - case StructureType::ePhysicalDeviceShaderObjectPropertiesEXT : return "PhysicalDeviceShaderObjectPropertiesEXT"; - case StructureType::eShaderCreateInfoEXT : return "ShaderCreateInfoEXT"; - case StructureType::ePhysicalDevicePipelineBinaryFeaturesKHR : return "PhysicalDevicePipelineBinaryFeaturesKHR"; - case StructureType::ePipelineBinaryCreateInfoKHR : return "PipelineBinaryCreateInfoKHR"; - case StructureType::ePipelineBinaryInfoKHR : return "PipelineBinaryInfoKHR"; - case StructureType::ePipelineBinaryKeyKHR : return "PipelineBinaryKeyKHR"; - case StructureType::ePhysicalDevicePipelineBinaryPropertiesKHR : return "PhysicalDevicePipelineBinaryPropertiesKHR"; - case StructureType::eReleaseCapturedPipelineDataInfoKHR : return "ReleaseCapturedPipelineDataInfoKHR"; - case StructureType::ePipelineBinaryDataInfoKHR : return "PipelineBinaryDataInfoKHR"; - case StructureType::ePipelineCreateInfoKHR : return "PipelineCreateInfoKHR"; - case StructureType::eDevicePipelineBinaryInternalCacheControlKHR : return "DevicePipelineBinaryInternalCacheControlKHR"; - case StructureType::ePipelineBinaryHandlesInfoKHR : return "PipelineBinaryHandlesInfoKHR"; - case StructureType::ePhysicalDeviceTilePropertiesFeaturesQCOM : return "PhysicalDeviceTilePropertiesFeaturesQCOM"; - case StructureType::eTilePropertiesQCOM : return "TilePropertiesQCOM"; - case StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC : return "PhysicalDeviceAmigoProfilingFeaturesSEC"; - case StructureType::eAmigoProfilingSubmitInfoSEC : return "AmigoProfilingSubmitInfoSEC"; - case StructureType::eSurfacePresentModeKHR : return "SurfacePresentModeKHR"; - case StructureType::eSurfacePresentScalingCapabilitiesKHR : return "SurfacePresentScalingCapabilitiesKHR"; - case StructureType::eSurfacePresentModeCompatibilityKHR : return "SurfacePresentModeCompatibilityKHR"; - case StructureType::ePhysicalDeviceSwapchainMaintenance1FeaturesKHR : return "PhysicalDeviceSwapchainMaintenance1FeaturesKHR"; - case StructureType::eSwapchainPresentFenceInfoKHR : return "SwapchainPresentFenceInfoKHR"; - case StructureType::eSwapchainPresentModesCreateInfoKHR : return "SwapchainPresentModesCreateInfoKHR"; - case StructureType::eSwapchainPresentModeInfoKHR : return "SwapchainPresentModeInfoKHR"; - case StructureType::eSwapchainPresentScalingCreateInfoKHR : return "SwapchainPresentScalingCreateInfoKHR"; - case StructureType::eReleaseSwapchainImagesInfoKHR : return "ReleaseSwapchainImagesInfoKHR"; - case StructureType::ePhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM : return "PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM"; - case StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesNV : return "PhysicalDeviceRayTracingInvocationReorderFeaturesNV"; - case StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesNV : return "PhysicalDeviceRayTracingInvocationReorderPropertiesNV"; - case StructureType::ePhysicalDeviceCooperativeVectorFeaturesNV : return "PhysicalDeviceCooperativeVectorFeaturesNV"; - case StructureType::ePhysicalDeviceCooperativeVectorPropertiesNV : return "PhysicalDeviceCooperativeVectorPropertiesNV"; - case StructureType::eCooperativeVectorPropertiesNV : return "CooperativeVectorPropertiesNV"; - case StructureType::eConvertCooperativeVectorMatrixInfoNV : return "ConvertCooperativeVectorMatrixInfoNV"; - case StructureType::ePhysicalDeviceExtendedSparseAddressSpaceFeaturesNV : return "PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV"; - case StructureType::ePhysicalDeviceExtendedSparseAddressSpacePropertiesNV : return "PhysicalDeviceExtendedSparseAddressSpacePropertiesNV"; - case StructureType::ePhysicalDeviceMutableDescriptorTypeFeaturesEXT : return "PhysicalDeviceMutableDescriptorTypeFeaturesEXT"; - case StructureType::eMutableDescriptorTypeCreateInfoEXT : return "MutableDescriptorTypeCreateInfoEXT"; - case StructureType::ePhysicalDeviceLegacyVertexAttributesFeaturesEXT : return "PhysicalDeviceLegacyVertexAttributesFeaturesEXT"; - case StructureType::ePhysicalDeviceLegacyVertexAttributesPropertiesEXT : return "PhysicalDeviceLegacyVertexAttributesPropertiesEXT"; - case StructureType::eLayerSettingsCreateInfoEXT : return "LayerSettingsCreateInfoEXT"; - case StructureType::ePhysicalDeviceShaderCoreBuiltinsFeaturesARM : return "PhysicalDeviceShaderCoreBuiltinsFeaturesARM"; - case StructureType::ePhysicalDeviceShaderCoreBuiltinsPropertiesARM : return "PhysicalDeviceShaderCoreBuiltinsPropertiesARM"; - case StructureType::ePhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT : return "PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT"; - case StructureType::ePhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT : return "PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT"; - case StructureType::ePhysicalDeviceInternallySynchronizedQueuesFeaturesKHR : return "PhysicalDeviceInternallySynchronizedQueuesFeaturesKHR"; - case StructureType::eLatencySleepModeInfoNV : return "LatencySleepModeInfoNV"; - case StructureType::eLatencySleepInfoNV : return "LatencySleepInfoNV"; - case StructureType::eSetLatencyMarkerInfoNV : return "SetLatencyMarkerInfoNV"; - case StructureType::eGetLatencyMarkerInfoNV : return "GetLatencyMarkerInfoNV"; - case StructureType::eLatencyTimingsFrameReportNV : return "LatencyTimingsFrameReportNV"; - case StructureType::eLatencySubmissionPresentIdNV : return "LatencySubmissionPresentIdNV"; - case StructureType::eOutOfBandQueueTypeInfoNV : return "OutOfBandQueueTypeInfoNV"; - case StructureType::eSwapchainLatencyCreateInfoNV : return "SwapchainLatencyCreateInfoNV"; - case StructureType::eLatencySurfaceCapabilitiesNV : return "LatencySurfaceCapabilitiesNV"; - case StructureType::ePhysicalDeviceCooperativeMatrixFeaturesKHR : return "PhysicalDeviceCooperativeMatrixFeaturesKHR"; - case StructureType::eCooperativeMatrixPropertiesKHR : return "CooperativeMatrixPropertiesKHR"; - case StructureType::ePhysicalDeviceCooperativeMatrixPropertiesKHR : return "PhysicalDeviceCooperativeMatrixPropertiesKHR"; - case StructureType::eDataGraphPipelineCreateInfoARM : return "DataGraphPipelineCreateInfoARM"; - case StructureType::eDataGraphPipelineSessionCreateInfoARM : return "DataGraphPipelineSessionCreateInfoARM"; - case StructureType::eDataGraphPipelineResourceInfoARM : return "DataGraphPipelineResourceInfoARM"; - case StructureType::eDataGraphPipelineConstantARM : return "DataGraphPipelineConstantARM"; - case StructureType::eDataGraphPipelineSessionMemoryRequirementsInfoARM : return "DataGraphPipelineSessionMemoryRequirementsInfoARM"; - case StructureType::eBindDataGraphPipelineSessionMemoryInfoARM : return "BindDataGraphPipelineSessionMemoryInfoARM"; - case StructureType::ePhysicalDeviceDataGraphFeaturesARM : return "PhysicalDeviceDataGraphFeaturesARM"; - case StructureType::eDataGraphPipelineShaderModuleCreateInfoARM : return "DataGraphPipelineShaderModuleCreateInfoARM"; - case StructureType::eDataGraphPipelinePropertyQueryResultARM : return "DataGraphPipelinePropertyQueryResultARM"; - case StructureType::eDataGraphPipelineInfoARM : return "DataGraphPipelineInfoARM"; - case StructureType::eDataGraphPipelineCompilerControlCreateInfoARM : return "DataGraphPipelineCompilerControlCreateInfoARM"; - case StructureType::eDataGraphPipelineSessionBindPointRequirementsInfoARM : return "DataGraphPipelineSessionBindPointRequirementsInfoARM"; - case StructureType::eDataGraphPipelineSessionBindPointRequirementARM : return "DataGraphPipelineSessionBindPointRequirementARM"; - case StructureType::eDataGraphPipelineIdentifierCreateInfoARM : return "DataGraphPipelineIdentifierCreateInfoARM"; - case StructureType::eDataGraphPipelineDispatchInfoARM : return "DataGraphPipelineDispatchInfoARM"; - case StructureType::eDataGraphProcessingEngineCreateInfoARM : return "DataGraphProcessingEngineCreateInfoARM"; - case StructureType::eQueueFamilyDataGraphProcessingEnginePropertiesARM : return "QueueFamilyDataGraphProcessingEnginePropertiesARM"; - case StructureType::eQueueFamilyDataGraphPropertiesARM : return "QueueFamilyDataGraphPropertiesARM"; - case StructureType::ePhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM : return "PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM"; - case StructureType::eDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM: return "DataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM"; - case StructureType::ePhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM : return "PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM"; - case StructureType::eMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM : return "MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM"; - case StructureType::ePhysicalDeviceComputeShaderDerivativesFeaturesKHR : return "PhysicalDeviceComputeShaderDerivativesFeaturesKHR"; - case StructureType::ePhysicalDeviceComputeShaderDerivativesPropertiesKHR : return "PhysicalDeviceComputeShaderDerivativesPropertiesKHR"; - case StructureType::eVideoDecodeAv1CapabilitiesKHR : return "VideoDecodeAv1CapabilitiesKHR"; - case StructureType::eVideoDecodeAv1PictureInfoKHR : return "VideoDecodeAv1PictureInfoKHR"; - case StructureType::eVideoDecodeAv1ProfileInfoKHR : return "VideoDecodeAv1ProfileInfoKHR"; - case StructureType::eVideoDecodeAv1SessionParametersCreateInfoKHR : return "VideoDecodeAv1SessionParametersCreateInfoKHR"; - case StructureType::eVideoDecodeAv1DpbSlotInfoKHR : return "VideoDecodeAv1DpbSlotInfoKHR"; - case StructureType::eVideoEncodeAv1CapabilitiesKHR : return "VideoEncodeAv1CapabilitiesKHR"; - case StructureType::eVideoEncodeAv1SessionParametersCreateInfoKHR : return "VideoEncodeAv1SessionParametersCreateInfoKHR"; - case StructureType::eVideoEncodeAv1PictureInfoKHR : return "VideoEncodeAv1PictureInfoKHR"; - case StructureType::eVideoEncodeAv1DpbSlotInfoKHR : return "VideoEncodeAv1DpbSlotInfoKHR"; - case StructureType::ePhysicalDeviceVideoEncodeAv1FeaturesKHR : return "PhysicalDeviceVideoEncodeAv1FeaturesKHR"; - case StructureType::eVideoEncodeAv1ProfileInfoKHR : return "VideoEncodeAv1ProfileInfoKHR"; - case StructureType::eVideoEncodeAv1RateControlInfoKHR : return "VideoEncodeAv1RateControlInfoKHR"; - case StructureType::eVideoEncodeAv1RateControlLayerInfoKHR : return "VideoEncodeAv1RateControlLayerInfoKHR"; - case StructureType::eVideoEncodeAv1QualityLevelPropertiesKHR : return "VideoEncodeAv1QualityLevelPropertiesKHR"; - case StructureType::eVideoEncodeAv1SessionCreateInfoKHR : return "VideoEncodeAv1SessionCreateInfoKHR"; - case StructureType::eVideoEncodeAv1GopRemainingFrameInfoKHR : return "VideoEncodeAv1GopRemainingFrameInfoKHR"; - case StructureType::ePhysicalDeviceVideoDecodeVp9FeaturesKHR : return "PhysicalDeviceVideoDecodeVp9FeaturesKHR"; - case StructureType::eVideoDecodeVp9CapabilitiesKHR : return "VideoDecodeVp9CapabilitiesKHR"; - case StructureType::eVideoDecodeVp9PictureInfoKHR : return "VideoDecodeVp9PictureInfoKHR"; - case StructureType::eVideoDecodeVp9ProfileInfoKHR : return "VideoDecodeVp9ProfileInfoKHR"; - case StructureType::ePhysicalDeviceVideoMaintenance1FeaturesKHR : return "PhysicalDeviceVideoMaintenance1FeaturesKHR"; - case StructureType::eVideoInlineQueryInfoKHR : return "VideoInlineQueryInfoKHR"; - case StructureType::ePhysicalDevicePerStageDescriptorSetFeaturesNV : return "PhysicalDevicePerStageDescriptorSetFeaturesNV"; - case StructureType::ePhysicalDeviceImageProcessing2FeaturesQCOM : return "PhysicalDeviceImageProcessing2FeaturesQCOM"; - case StructureType::ePhysicalDeviceImageProcessing2PropertiesQCOM : return "PhysicalDeviceImageProcessing2PropertiesQCOM"; - case StructureType::eSamplerBlockMatchWindowCreateInfoQCOM : return "SamplerBlockMatchWindowCreateInfoQCOM"; - case StructureType::eSamplerCubicWeightsCreateInfoQCOM : return "SamplerCubicWeightsCreateInfoQCOM"; - case StructureType::ePhysicalDeviceCubicWeightsFeaturesQCOM : return "PhysicalDeviceCubicWeightsFeaturesQCOM"; - case StructureType::eBlitImageCubicWeightsInfoQCOM : return "BlitImageCubicWeightsInfoQCOM"; - case StructureType::ePhysicalDeviceYcbcrDegammaFeaturesQCOM : return "PhysicalDeviceYcbcrDegammaFeaturesQCOM"; - case StructureType::eSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM : return "SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM"; - case StructureType::ePhysicalDeviceCubicClampFeaturesQCOM : return "PhysicalDeviceCubicClampFeaturesQCOM"; - case StructureType::ePhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT : return "PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT"; - case StructureType::ePhysicalDeviceUnifiedImageLayoutsFeaturesKHR : return "PhysicalDeviceUnifiedImageLayoutsFeaturesKHR"; - case StructureType::eAttachmentFeedbackLoopInfoEXT : return "AttachmentFeedbackLoopInfoEXT"; -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - case StructureType::eScreenBufferPropertiesQNX : return "ScreenBufferPropertiesQNX"; - case StructureType::eScreenBufferFormatPropertiesQNX : return "ScreenBufferFormatPropertiesQNX"; - case StructureType::eImportScreenBufferInfoQNX : return "ImportScreenBufferInfoQNX"; - case StructureType::eExternalFormatQNX : return "ExternalFormatQNX"; - case StructureType::ePhysicalDeviceExternalMemoryScreenBufferFeaturesQNX: return "PhysicalDeviceExternalMemoryScreenBufferFeaturesQNX"; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - case StructureType::ePhysicalDeviceLayeredDriverPropertiesMSFT : return "PhysicalDeviceLayeredDriverPropertiesMSFT"; - case StructureType::eCalibratedTimestampInfoKHR : return "CalibratedTimestampInfoKHR"; - case StructureType::eSetDescriptorBufferOffsetsInfoEXT : return "SetDescriptorBufferOffsetsInfoEXT"; - case StructureType::eBindDescriptorBufferEmbeddedSamplersInfoEXT : return "BindDescriptorBufferEmbeddedSamplersInfoEXT"; - case StructureType::ePhysicalDeviceDescriptorPoolOverallocationFeaturesNV : return "PhysicalDeviceDescriptorPoolOverallocationFeaturesNV"; - case StructureType::ePhysicalDeviceTileMemoryHeapFeaturesQCOM : return "PhysicalDeviceTileMemoryHeapFeaturesQCOM"; - case StructureType::ePhysicalDeviceTileMemoryHeapPropertiesQCOM : return "PhysicalDeviceTileMemoryHeapPropertiesQCOM"; - case StructureType::eTileMemoryRequirementsQCOM : return "TileMemoryRequirementsQCOM"; - case StructureType::eTileMemoryBindInfoQCOM : return "TileMemoryBindInfoQCOM"; - case StructureType::eTileMemorySizeInfoQCOM : return "TileMemorySizeInfoQCOM"; - case StructureType::ePhysicalDeviceCopyMemoryIndirectFeaturesKHR : return "PhysicalDeviceCopyMemoryIndirectFeaturesKHR"; - case StructureType::ePhysicalDeviceCopyMemoryIndirectPropertiesKHR : return "PhysicalDeviceCopyMemoryIndirectPropertiesKHR"; - case StructureType::eCopyMemoryIndirectInfoKHR : return "CopyMemoryIndirectInfoKHR"; - case StructureType::eCopyMemoryToImageIndirectInfoKHR : return "CopyMemoryToImageIndirectInfoKHR"; - case StructureType::ePhysicalDeviceMemoryDecompressionFeaturesEXT : return "PhysicalDeviceMemoryDecompressionFeaturesEXT"; - case StructureType::ePhysicalDeviceMemoryDecompressionPropertiesEXT : return "PhysicalDeviceMemoryDecompressionPropertiesEXT"; - case StructureType::eDecompressMemoryInfoEXT : return "DecompressMemoryInfoEXT"; - case StructureType::eDisplaySurfaceStereoCreateInfoNV : return "DisplaySurfaceStereoCreateInfoNV"; - case StructureType::eDisplayModeStereoPropertiesNV : return "DisplayModeStereoPropertiesNV"; - case StructureType::eVideoEncodeIntraRefreshCapabilitiesKHR : return "VideoEncodeIntraRefreshCapabilitiesKHR"; - case StructureType::eVideoEncodeSessionIntraRefreshCreateInfoKHR : return "VideoEncodeSessionIntraRefreshCreateInfoKHR"; - case StructureType::eVideoEncodeIntraRefreshInfoKHR : return "VideoEncodeIntraRefreshInfoKHR"; - case StructureType::eVideoReferenceIntraRefreshInfoKHR : return "VideoReferenceIntraRefreshInfoKHR"; - case StructureType::ePhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR : return "PhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR"; - case StructureType::eVideoEncodeQuantizationMapCapabilitiesKHR : return "VideoEncodeQuantizationMapCapabilitiesKHR"; - case StructureType::eVideoFormatQuantizationMapPropertiesKHR : return "VideoFormatQuantizationMapPropertiesKHR"; - case StructureType::eVideoEncodeQuantizationMapInfoKHR : return "VideoEncodeQuantizationMapInfoKHR"; - case StructureType::eVideoEncodeQuantizationMapSessionParametersCreateInfoKHR : return "VideoEncodeQuantizationMapSessionParametersCreateInfoKHR"; - case StructureType::ePhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR : return "PhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR"; - case StructureType::eVideoEncodeH264QuantizationMapCapabilitiesKHR : return "VideoEncodeH264QuantizationMapCapabilitiesKHR"; - case StructureType::eVideoEncodeH265QuantizationMapCapabilitiesKHR : return "VideoEncodeH265QuantizationMapCapabilitiesKHR"; - case StructureType::eVideoFormatH265QuantizationMapPropertiesKHR : return "VideoFormatH265QuantizationMapPropertiesKHR"; - case StructureType::eVideoEncodeAv1QuantizationMapCapabilitiesKHR : return "VideoEncodeAv1QuantizationMapCapabilitiesKHR"; - case StructureType::eVideoFormatAv1QuantizationMapPropertiesKHR : return "VideoFormatAv1QuantizationMapPropertiesKHR"; - case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV : return "PhysicalDeviceRawAccessChainsFeaturesNV"; - case StructureType::eExternalComputeQueueDeviceCreateInfoNV : return "ExternalComputeQueueDeviceCreateInfoNV"; - case StructureType::eExternalComputeQueueCreateInfoNV : return "ExternalComputeQueueCreateInfoNV"; - case StructureType::eExternalComputeQueueDataParamsNV : return "ExternalComputeQueueDataParamsNV"; - case StructureType::ePhysicalDeviceExternalComputeQueuePropertiesNV : return "PhysicalDeviceExternalComputeQueuePropertiesNV"; - case StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR : return "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR"; - case StructureType::ePhysicalDeviceCommandBufferInheritanceFeaturesNV : return "PhysicalDeviceCommandBufferInheritanceFeaturesNV"; - case StructureType::ePhysicalDeviceMaintenance7FeaturesKHR : return "PhysicalDeviceMaintenance7FeaturesKHR"; - case StructureType::ePhysicalDeviceMaintenance7PropertiesKHR : return "PhysicalDeviceMaintenance7PropertiesKHR"; - case StructureType::ePhysicalDeviceLayeredApiPropertiesListKHR : return "PhysicalDeviceLayeredApiPropertiesListKHR"; - case StructureType::ePhysicalDeviceLayeredApiPropertiesKHR : return "PhysicalDeviceLayeredApiPropertiesKHR"; - case StructureType::ePhysicalDeviceLayeredApiVulkanPropertiesKHR : return "PhysicalDeviceLayeredApiVulkanPropertiesKHR"; - case StructureType::ePhysicalDeviceShaderAtomicFloat16VectorFeaturesNV : return "PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV"; - case StructureType::ePhysicalDeviceShaderReplicatedCompositesFeaturesEXT : return "PhysicalDeviceShaderReplicatedCompositesFeaturesEXT"; - case StructureType::ePhysicalDeviceShaderFloat8FeaturesEXT : return "PhysicalDeviceShaderFloat8FeaturesEXT"; - case StructureType::ePhysicalDeviceRayTracingValidationFeaturesNV : return "PhysicalDeviceRayTracingValidationFeaturesNV"; - case StructureType::ePhysicalDeviceClusterAccelerationStructureFeaturesNV : return "PhysicalDeviceClusterAccelerationStructureFeaturesNV"; - case StructureType::ePhysicalDeviceClusterAccelerationStructurePropertiesNV : return "PhysicalDeviceClusterAccelerationStructurePropertiesNV"; - case StructureType::eClusterAccelerationStructureClustersBottomLevelInputNV : return "ClusterAccelerationStructureClustersBottomLevelInputNV"; - case StructureType::eClusterAccelerationStructureTriangleClusterInputNV : return "ClusterAccelerationStructureTriangleClusterInputNV"; - case StructureType::eClusterAccelerationStructureMoveObjectsInputNV : return "ClusterAccelerationStructureMoveObjectsInputNV"; - case StructureType::eClusterAccelerationStructureInputInfoNV : return "ClusterAccelerationStructureInputInfoNV"; - case StructureType::eClusterAccelerationStructureCommandsInfoNV : return "ClusterAccelerationStructureCommandsInfoNV"; - case StructureType::eRayTracingPipelineClusterAccelerationStructureCreateInfoNV: return "RayTracingPipelineClusterAccelerationStructureCreateInfoNV"; - case StructureType::ePhysicalDevicePartitionedAccelerationStructureFeaturesNV : return "PhysicalDevicePartitionedAccelerationStructureFeaturesNV"; - case StructureType::ePhysicalDevicePartitionedAccelerationStructurePropertiesNV: return "PhysicalDevicePartitionedAccelerationStructurePropertiesNV"; - case StructureType::eWriteDescriptorSetPartitionedAccelerationStructureNV : return "WriteDescriptorSetPartitionedAccelerationStructureNV"; - case StructureType::ePartitionedAccelerationStructureInstancesInputNV : return "PartitionedAccelerationStructureInstancesInputNV"; - case StructureType::eBuildPartitionedAccelerationStructureInfoNV : return "BuildPartitionedAccelerationStructureInfoNV"; - case StructureType::ePartitionedAccelerationStructureFlagsNV : return "PartitionedAccelerationStructureFlagsNV"; - case StructureType::ePhysicalDeviceDeviceGeneratedCommandsFeaturesEXT : return "PhysicalDeviceDeviceGeneratedCommandsFeaturesEXT"; - case StructureType::ePhysicalDeviceDeviceGeneratedCommandsPropertiesEXT : return "PhysicalDeviceDeviceGeneratedCommandsPropertiesEXT"; - case StructureType::eGeneratedCommandsMemoryRequirementsInfoEXT : return "GeneratedCommandsMemoryRequirementsInfoEXT"; - case StructureType::eIndirectExecutionSetCreateInfoEXT : return "IndirectExecutionSetCreateInfoEXT"; - case StructureType::eGeneratedCommandsInfoEXT : return "GeneratedCommandsInfoEXT"; - case StructureType::eIndirectCommandsLayoutCreateInfoEXT : return "IndirectCommandsLayoutCreateInfoEXT"; - case StructureType::eIndirectCommandsLayoutTokenEXT : return "IndirectCommandsLayoutTokenEXT"; - case StructureType::eWriteIndirectExecutionSetPipelineEXT : return "WriteIndirectExecutionSetPipelineEXT"; - case StructureType::eWriteIndirectExecutionSetShaderEXT : return "WriteIndirectExecutionSetShaderEXT"; - case StructureType::eIndirectExecutionSetPipelineInfoEXT : return "IndirectExecutionSetPipelineInfoEXT"; - case StructureType::eIndirectExecutionSetShaderInfoEXT : return "IndirectExecutionSetShaderInfoEXT"; - case StructureType::eIndirectExecutionSetShaderLayoutInfoEXT : return "IndirectExecutionSetShaderLayoutInfoEXT"; - case StructureType::eGeneratedCommandsPipelineInfoEXT : return "GeneratedCommandsPipelineInfoEXT"; - case StructureType::eGeneratedCommandsShaderInfoEXT : return "GeneratedCommandsShaderInfoEXT"; - case StructureType::ePhysicalDeviceMaintenance8FeaturesKHR : return "PhysicalDeviceMaintenance8FeaturesKHR"; - case StructureType::eMemoryBarrierAccessFlags3KHR : return "MemoryBarrierAccessFlags3KHR"; - case StructureType::ePhysicalDeviceImageAlignmentControlFeaturesMESA : return "PhysicalDeviceImageAlignmentControlFeaturesMESA"; - case StructureType::ePhysicalDeviceImageAlignmentControlPropertiesMESA : return "PhysicalDeviceImageAlignmentControlPropertiesMESA"; - case StructureType::eImageAlignmentControlCreateInfoMESA : return "ImageAlignmentControlCreateInfoMESA"; - case StructureType::ePhysicalDeviceShaderFmaFeaturesKHR : return "PhysicalDeviceShaderFmaFeaturesKHR"; - case StructureType::ePushConstantBankInfoNV : return "PushConstantBankInfoNV"; - case StructureType::ePhysicalDevicePushConstantBankFeaturesNV : return "PhysicalDevicePushConstantBankFeaturesNV"; - case StructureType::ePhysicalDevicePushConstantBankPropertiesNV : return "PhysicalDevicePushConstantBankPropertiesNV"; - case StructureType::ePhysicalDeviceRayTracingInvocationReorderFeaturesEXT : return "PhysicalDeviceRayTracingInvocationReorderFeaturesEXT"; - case StructureType::ePhysicalDeviceRayTracingInvocationReorderPropertiesEXT : return "PhysicalDeviceRayTracingInvocationReorderPropertiesEXT"; - case StructureType::ePhysicalDeviceDepthClampControlFeaturesEXT : return "PhysicalDeviceDepthClampControlFeaturesEXT"; - case StructureType::ePipelineViewportDepthClampControlCreateInfoEXT : return "PipelineViewportDepthClampControlCreateInfoEXT"; - case StructureType::ePhysicalDeviceMaintenance9FeaturesKHR : return "PhysicalDeviceMaintenance9FeaturesKHR"; - case StructureType::ePhysicalDeviceMaintenance9PropertiesKHR : return "PhysicalDeviceMaintenance9PropertiesKHR"; - case StructureType::eQueueFamilyOwnershipTransferPropertiesKHR : return "QueueFamilyOwnershipTransferPropertiesKHR"; - case StructureType::ePhysicalDeviceVideoMaintenance2FeaturesKHR : return "PhysicalDeviceVideoMaintenance2FeaturesKHR"; - case StructureType::eVideoDecodeH264InlineSessionParametersInfoKHR : return "VideoDecodeH264InlineSessionParametersInfoKHR"; - case StructureType::eVideoDecodeH265InlineSessionParametersInfoKHR : return "VideoDecodeH265InlineSessionParametersInfoKHR"; - case StructureType::eVideoDecodeAv1InlineSessionParametersInfoKHR : return "VideoDecodeAv1InlineSessionParametersInfoKHR"; -#if defined( VK_USE_PLATFORM_OHOS ) - case StructureType::eSurfaceCreateInfoOHOS: return "SurfaceCreateInfoOHOS"; -#endif /*VK_USE_PLATFORM_OHOS*/ - case StructureType::ePhysicalDeviceHdrVividFeaturesHUAWEI : return "PhysicalDeviceHdrVividFeaturesHUAWEI"; - case StructureType::eHdrVividDynamicMetadataHUAWEI : return "HdrVividDynamicMetadataHUAWEI"; - case StructureType::ePhysicalDeviceCooperativeMatrix2FeaturesNV : return "PhysicalDeviceCooperativeMatrix2FeaturesNV"; - case StructureType::eCooperativeMatrixFlexibleDimensionsPropertiesNV : return "CooperativeMatrixFlexibleDimensionsPropertiesNV"; - case StructureType::ePhysicalDeviceCooperativeMatrix2PropertiesNV : return "PhysicalDeviceCooperativeMatrix2PropertiesNV"; - case StructureType::ePhysicalDevicePipelineOpacityMicromapFeaturesARM: return "PhysicalDevicePipelineOpacityMicromapFeaturesARM"; -#if defined( VK_USE_PLATFORM_METAL_EXT ) - case StructureType::eImportMemoryMetalHandleInfoEXT: return "ImportMemoryMetalHandleInfoEXT"; - case StructureType::eMemoryMetalHandlePropertiesEXT: return "MemoryMetalHandlePropertiesEXT"; - case StructureType::eMemoryGetMetalHandleInfoEXT : return "MemoryGetMetalHandleInfoEXT"; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - case StructureType::ePhysicalDeviceDepthClampZeroOneFeaturesKHR : return "PhysicalDeviceDepthClampZeroOneFeaturesKHR"; - case StructureType::ePhysicalDevicePerformanceCountersByRegionFeaturesARM : return "PhysicalDevicePerformanceCountersByRegionFeaturesARM"; - case StructureType::ePhysicalDevicePerformanceCountersByRegionPropertiesARM: return "PhysicalDevicePerformanceCountersByRegionPropertiesARM"; - case StructureType::ePerformanceCounterARM : return "PerformanceCounterARM"; - case StructureType::ePerformanceCounterDescriptionARM : return "PerformanceCounterDescriptionARM"; - case StructureType::eRenderPassPerformanceCountersByRegionBeginInfoARM : return "RenderPassPerformanceCountersByRegionBeginInfoARM"; - case StructureType::ePhysicalDeviceVertexAttributeRobustnessFeaturesEXT : return "PhysicalDeviceVertexAttributeRobustnessFeaturesEXT"; - case StructureType::ePhysicalDeviceFormatPackFeaturesARM : return "PhysicalDeviceFormatPackFeaturesARM"; - case StructureType::ePhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE : return "PhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE"; - case StructureType::ePhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE: return "PhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE"; - case StructureType::ePipelineFragmentDensityMapLayeredCreateInfoVALVE : return "PipelineFragmentDensityMapLayeredCreateInfoVALVE"; - case StructureType::ePhysicalDeviceRobustness2FeaturesKHR : return "PhysicalDeviceRobustness2FeaturesKHR"; - case StructureType::ePhysicalDeviceRobustness2PropertiesKHR : return "PhysicalDeviceRobustness2PropertiesKHR"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case StructureType::eSetPresentConfigNV : return "SetPresentConfigNV"; - case StructureType::ePhysicalDevicePresentMeteringFeaturesNV: return "PhysicalDevicePresentMeteringFeaturesNV"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case StructureType::ePhysicalDeviceFragmentDensityMapOffsetFeaturesEXT : return "PhysicalDeviceFragmentDensityMapOffsetFeaturesEXT"; - case StructureType::ePhysicalDeviceFragmentDensityMapOffsetPropertiesEXT : return "PhysicalDeviceFragmentDensityMapOffsetPropertiesEXT"; - case StructureType::eRenderPassFragmentDensityMapOffsetEndInfoEXT : return "RenderPassFragmentDensityMapOffsetEndInfoEXT"; - case StructureType::ePhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT : return "PhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT"; - case StructureType::ePhysicalDevicePresentModeFifoLatestReadyFeaturesKHR : return "PhysicalDevicePresentModeFifoLatestReadyFeaturesKHR"; - case StructureType::ePhysicalDeviceShader64BitIndexingFeaturesEXT : return "PhysicalDeviceShader64BitIndexingFeaturesEXT"; - case StructureType::ePhysicalDeviceCustomResolveFeaturesEXT : return "PhysicalDeviceCustomResolveFeaturesEXT"; - case StructureType::eBeginCustomResolveInfoEXT : return "BeginCustomResolveInfoEXT"; - case StructureType::eCustomResolveCreateInfoEXT : return "CustomResolveCreateInfoEXT"; - case StructureType::ePhysicalDeviceDataGraphModelFeaturesQCOM : return "PhysicalDeviceDataGraphModelFeaturesQCOM"; - case StructureType::eDataGraphPipelineBuiltinModelCreateInfoQCOM : return "DataGraphPipelineBuiltinModelCreateInfoQCOM"; - case StructureType::ePhysicalDeviceMaintenance10FeaturesKHR : return "PhysicalDeviceMaintenance10FeaturesKHR"; - case StructureType::ePhysicalDeviceMaintenance10PropertiesKHR : return "PhysicalDeviceMaintenance10PropertiesKHR"; - case StructureType::eRenderingAttachmentFlagsInfoKHR : return "RenderingAttachmentFlagsInfoKHR"; - case StructureType::eRenderingEndInfoKHR : return "RenderingEndInfoKHR"; - case StructureType::eResolveImageModeInfoKHR : return "ResolveImageModeInfoKHR"; - case StructureType::ePhysicalDeviceShaderLongVectorFeaturesEXT : return "PhysicalDeviceShaderLongVectorFeaturesEXT"; - case StructureType::ePhysicalDeviceShaderLongVectorPropertiesEXT : return "PhysicalDeviceShaderLongVectorPropertiesEXT"; - case StructureType::ePhysicalDevicePipelineCacheIncrementalModeFeaturesSEC : return "PhysicalDevicePipelineCacheIncrementalModeFeaturesSEC"; - case StructureType::ePhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT: return "PhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT"; - case StructureType::eComputeOccupancyPriorityParametersNV : return "ComputeOccupancyPriorityParametersNV"; - case StructureType::ePhysicalDeviceComputeOccupancyPriorityFeaturesNV : return "PhysicalDeviceComputeOccupancyPriorityFeaturesNV"; - case StructureType::ePhysicalDeviceShaderSubgroupPartitionedFeaturesEXT : return "PhysicalDeviceShaderSubgroupPartitionedFeaturesEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ObjectType value ) - { - switch ( value ) - { - case ObjectType::eUnknown : return "Unknown"; - case ObjectType::eInstance : return "Instance"; - case ObjectType::ePhysicalDevice : return "PhysicalDevice"; - case ObjectType::eDevice : return "Device"; - case ObjectType::eQueue : return "Queue"; - case ObjectType::eSemaphore : return "Semaphore"; - case ObjectType::eCommandBuffer : return "CommandBuffer"; - case ObjectType::eFence : return "Fence"; - case ObjectType::eDeviceMemory : return "DeviceMemory"; - case ObjectType::eBuffer : return "Buffer"; - case ObjectType::eImage : return "Image"; - case ObjectType::eEvent : return "Event"; - case ObjectType::eQueryPool : return "QueryPool"; - case ObjectType::eBufferView : return "BufferView"; - case ObjectType::eImageView : return "ImageView"; - case ObjectType::eShaderModule : return "ShaderModule"; - case ObjectType::ePipelineCache : return "PipelineCache"; - case ObjectType::ePipelineLayout : return "PipelineLayout"; - case ObjectType::eRenderPass : return "RenderPass"; - case ObjectType::ePipeline : return "Pipeline"; - case ObjectType::eDescriptorSetLayout : return "DescriptorSetLayout"; - case ObjectType::eSampler : return "Sampler"; - case ObjectType::eDescriptorPool : return "DescriptorPool"; - case ObjectType::eDescriptorSet : return "DescriptorSet"; - case ObjectType::eFramebuffer : return "Framebuffer"; - case ObjectType::eCommandPool : return "CommandPool"; - case ObjectType::eDescriptorUpdateTemplate : return "DescriptorUpdateTemplate"; - case ObjectType::eSamplerYcbcrConversion : return "SamplerYcbcrConversion"; - case ObjectType::ePrivateDataSlot : return "PrivateDataSlot"; - case ObjectType::eSurfaceKHR : return "SurfaceKHR"; - case ObjectType::eSwapchainKHR : return "SwapchainKHR"; - case ObjectType::eDisplayKHR : return "DisplayKHR"; - case ObjectType::eDisplayModeKHR : return "DisplayModeKHR"; - case ObjectType::eDebugReportCallbackEXT : return "DebugReportCallbackEXT"; - case ObjectType::eVideoSessionKHR : return "VideoSessionKHR"; - case ObjectType::eVideoSessionParametersKHR : return "VideoSessionParametersKHR"; - case ObjectType::eCuModuleNVX : return "CuModuleNVX"; - case ObjectType::eCuFunctionNVX : return "CuFunctionNVX"; - case ObjectType::eDebugUtilsMessengerEXT : return "DebugUtilsMessengerEXT"; - case ObjectType::eAccelerationStructureKHR : return "AccelerationStructureKHR"; - case ObjectType::eValidationCacheEXT : return "ValidationCacheEXT"; - case ObjectType::eAccelerationStructureNV : return "AccelerationStructureNV"; - case ObjectType::ePerformanceConfigurationINTEL: return "PerformanceConfigurationINTEL"; - case ObjectType::eDeferredOperationKHR : return "DeferredOperationKHR"; - case ObjectType::eIndirectCommandsLayoutNV : return "IndirectCommandsLayoutNV"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case ObjectType::eCudaModuleNV : return "CudaModuleNV"; - case ObjectType::eCudaFunctionNV: return "CudaFunctionNV"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ -#if defined( VK_USE_PLATFORM_FUCHSIA ) - case ObjectType::eBufferCollectionFUCHSIA: return "BufferCollectionFUCHSIA"; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - case ObjectType::eMicromapEXT : return "MicromapEXT"; - case ObjectType::eTensorARM : return "TensorARM"; - case ObjectType::eTensorViewARM : return "TensorViewARM"; - case ObjectType::eOpticalFlowSessionNV : return "OpticalFlowSessionNV"; - case ObjectType::eShaderEXT : return "ShaderEXT"; - case ObjectType::ePipelineBinaryKHR : return "PipelineBinaryKHR"; - case ObjectType::eDataGraphPipelineSessionARM: return "DataGraphPipelineSessionARM"; - case ObjectType::eExternalComputeQueueNV : return "ExternalComputeQueueNV"; - case ObjectType::eIndirectCommandsLayoutEXT : return "IndirectCommandsLayoutEXT"; - case ObjectType::eIndirectExecutionSetEXT : return "IndirectExecutionSetEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VendorId value ) - { - switch ( value ) - { - case VendorId::eKhronos : return "Khronos"; - case VendorId::eVIV : return "VIV"; - case VendorId::eVSI : return "VSI"; - case VendorId::eKazan : return "Kazan"; - case VendorId::eCodeplay: return "Codeplay"; - case VendorId::eMESA : return "MESA"; - case VendorId::ePocl : return "Pocl"; - case VendorId::eMobileye: return "Mobileye"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Format value ) - { - switch ( value ) - { - case Format::eUndefined : return "Undefined"; - case Format::eR4G4UnormPack8 : return "R4G4UnormPack8"; - case Format::eR4G4B4A4UnormPack16 : return "R4G4B4A4UnormPack16"; - case Format::eB4G4R4A4UnormPack16 : return "B4G4R4A4UnormPack16"; - case Format::eR5G6B5UnormPack16 : return "R5G6B5UnormPack16"; - case Format::eB5G6R5UnormPack16 : return "B5G6R5UnormPack16"; - case Format::eR5G5B5A1UnormPack16 : return "R5G5B5A1UnormPack16"; - case Format::eB5G5R5A1UnormPack16 : return "B5G5R5A1UnormPack16"; - case Format::eA1R5G5B5UnormPack16 : return "A1R5G5B5UnormPack16"; - case Format::eR8Unorm : return "R8Unorm"; - case Format::eR8Snorm : return "R8Snorm"; - case Format::eR8Uscaled : return "R8Uscaled"; - case Format::eR8Sscaled : return "R8Sscaled"; - case Format::eR8Uint : return "R8Uint"; - case Format::eR8Sint : return "R8Sint"; - case Format::eR8Srgb : return "R8Srgb"; - case Format::eR8G8Unorm : return "R8G8Unorm"; - case Format::eR8G8Snorm : return "R8G8Snorm"; - case Format::eR8G8Uscaled : return "R8G8Uscaled"; - case Format::eR8G8Sscaled : return "R8G8Sscaled"; - case Format::eR8G8Uint : return "R8G8Uint"; - case Format::eR8G8Sint : return "R8G8Sint"; - case Format::eR8G8Srgb : return "R8G8Srgb"; - case Format::eR8G8B8Unorm : return "R8G8B8Unorm"; - case Format::eR8G8B8Snorm : return "R8G8B8Snorm"; - case Format::eR8G8B8Uscaled : return "R8G8B8Uscaled"; - case Format::eR8G8B8Sscaled : return "R8G8B8Sscaled"; - case Format::eR8G8B8Uint : return "R8G8B8Uint"; - case Format::eR8G8B8Sint : return "R8G8B8Sint"; - case Format::eR8G8B8Srgb : return "R8G8B8Srgb"; - case Format::eB8G8R8Unorm : return "B8G8R8Unorm"; - case Format::eB8G8R8Snorm : return "B8G8R8Snorm"; - case Format::eB8G8R8Uscaled : return "B8G8R8Uscaled"; - case Format::eB8G8R8Sscaled : return "B8G8R8Sscaled"; - case Format::eB8G8R8Uint : return "B8G8R8Uint"; - case Format::eB8G8R8Sint : return "B8G8R8Sint"; - case Format::eB8G8R8Srgb : return "B8G8R8Srgb"; - case Format::eR8G8B8A8Unorm : return "R8G8B8A8Unorm"; - case Format::eR8G8B8A8Snorm : return "R8G8B8A8Snorm"; - case Format::eR8G8B8A8Uscaled : return "R8G8B8A8Uscaled"; - case Format::eR8G8B8A8Sscaled : return "R8G8B8A8Sscaled"; - case Format::eR8G8B8A8Uint : return "R8G8B8A8Uint"; - case Format::eR8G8B8A8Sint : return "R8G8B8A8Sint"; - case Format::eR8G8B8A8Srgb : return "R8G8B8A8Srgb"; - case Format::eB8G8R8A8Unorm : return "B8G8R8A8Unorm"; - case Format::eB8G8R8A8Snorm : return "B8G8R8A8Snorm"; - case Format::eB8G8R8A8Uscaled : return "B8G8R8A8Uscaled"; - case Format::eB8G8R8A8Sscaled : return "B8G8R8A8Sscaled"; - case Format::eB8G8R8A8Uint : return "B8G8R8A8Uint"; - case Format::eB8G8R8A8Sint : return "B8G8R8A8Sint"; - case Format::eB8G8R8A8Srgb : return "B8G8R8A8Srgb"; - case Format::eA8B8G8R8UnormPack32 : return "A8B8G8R8UnormPack32"; - case Format::eA8B8G8R8SnormPack32 : return "A8B8G8R8SnormPack32"; - case Format::eA8B8G8R8UscaledPack32 : return "A8B8G8R8UscaledPack32"; - case Format::eA8B8G8R8SscaledPack32 : return "A8B8G8R8SscaledPack32"; - case Format::eA8B8G8R8UintPack32 : return "A8B8G8R8UintPack32"; - case Format::eA8B8G8R8SintPack32 : return "A8B8G8R8SintPack32"; - case Format::eA8B8G8R8SrgbPack32 : return "A8B8G8R8SrgbPack32"; - case Format::eA2R10G10B10UnormPack32 : return "A2R10G10B10UnormPack32"; - case Format::eA2R10G10B10SnormPack32 : return "A2R10G10B10SnormPack32"; - case Format::eA2R10G10B10UscaledPack32 : return "A2R10G10B10UscaledPack32"; - case Format::eA2R10G10B10SscaledPack32 : return "A2R10G10B10SscaledPack32"; - case Format::eA2R10G10B10UintPack32 : return "A2R10G10B10UintPack32"; - case Format::eA2R10G10B10SintPack32 : return "A2R10G10B10SintPack32"; - case Format::eA2B10G10R10UnormPack32 : return "A2B10G10R10UnormPack32"; - case Format::eA2B10G10R10SnormPack32 : return "A2B10G10R10SnormPack32"; - case Format::eA2B10G10R10UscaledPack32 : return "A2B10G10R10UscaledPack32"; - case Format::eA2B10G10R10SscaledPack32 : return "A2B10G10R10SscaledPack32"; - case Format::eA2B10G10R10UintPack32 : return "A2B10G10R10UintPack32"; - case Format::eA2B10G10R10SintPack32 : return "A2B10G10R10SintPack32"; - case Format::eR16Unorm : return "R16Unorm"; - case Format::eR16Snorm : return "R16Snorm"; - case Format::eR16Uscaled : return "R16Uscaled"; - case Format::eR16Sscaled : return "R16Sscaled"; - case Format::eR16Uint : return "R16Uint"; - case Format::eR16Sint : return "R16Sint"; - case Format::eR16Sfloat : return "R16Sfloat"; - case Format::eR16G16Unorm : return "R16G16Unorm"; - case Format::eR16G16Snorm : return "R16G16Snorm"; - case Format::eR16G16Uscaled : return "R16G16Uscaled"; - case Format::eR16G16Sscaled : return "R16G16Sscaled"; - case Format::eR16G16Uint : return "R16G16Uint"; - case Format::eR16G16Sint : return "R16G16Sint"; - case Format::eR16G16Sfloat : return "R16G16Sfloat"; - case Format::eR16G16B16Unorm : return "R16G16B16Unorm"; - case Format::eR16G16B16Snorm : return "R16G16B16Snorm"; - case Format::eR16G16B16Uscaled : return "R16G16B16Uscaled"; - case Format::eR16G16B16Sscaled : return "R16G16B16Sscaled"; - case Format::eR16G16B16Uint : return "R16G16B16Uint"; - case Format::eR16G16B16Sint : return "R16G16B16Sint"; - case Format::eR16G16B16Sfloat : return "R16G16B16Sfloat"; - case Format::eR16G16B16A16Unorm : return "R16G16B16A16Unorm"; - case Format::eR16G16B16A16Snorm : return "R16G16B16A16Snorm"; - case Format::eR16G16B16A16Uscaled : return "R16G16B16A16Uscaled"; - case Format::eR16G16B16A16Sscaled : return "R16G16B16A16Sscaled"; - case Format::eR16G16B16A16Uint : return "R16G16B16A16Uint"; - case Format::eR16G16B16A16Sint : return "R16G16B16A16Sint"; - case Format::eR16G16B16A16Sfloat : return "R16G16B16A16Sfloat"; - case Format::eR32Uint : return "R32Uint"; - case Format::eR32Sint : return "R32Sint"; - case Format::eR32Sfloat : return "R32Sfloat"; - case Format::eR32G32Uint : return "R32G32Uint"; - case Format::eR32G32Sint : return "R32G32Sint"; - case Format::eR32G32Sfloat : return "R32G32Sfloat"; - case Format::eR32G32B32Uint : return "R32G32B32Uint"; - case Format::eR32G32B32Sint : return "R32G32B32Sint"; - case Format::eR32G32B32Sfloat : return "R32G32B32Sfloat"; - case Format::eR32G32B32A32Uint : return "R32G32B32A32Uint"; - case Format::eR32G32B32A32Sint : return "R32G32B32A32Sint"; - case Format::eR32G32B32A32Sfloat : return "R32G32B32A32Sfloat"; - case Format::eR64Uint : return "R64Uint"; - case Format::eR64Sint : return "R64Sint"; - case Format::eR64Sfloat : return "R64Sfloat"; - case Format::eR64G64Uint : return "R64G64Uint"; - case Format::eR64G64Sint : return "R64G64Sint"; - case Format::eR64G64Sfloat : return "R64G64Sfloat"; - case Format::eR64G64B64Uint : return "R64G64B64Uint"; - case Format::eR64G64B64Sint : return "R64G64B64Sint"; - case Format::eR64G64B64Sfloat : return "R64G64B64Sfloat"; - case Format::eR64G64B64A64Uint : return "R64G64B64A64Uint"; - case Format::eR64G64B64A64Sint : return "R64G64B64A64Sint"; - case Format::eR64G64B64A64Sfloat : return "R64G64B64A64Sfloat"; - case Format::eB10G11R11UfloatPack32 : return "B10G11R11UfloatPack32"; - case Format::eE5B9G9R9UfloatPack32 : return "E5B9G9R9UfloatPack32"; - case Format::eD16Unorm : return "D16Unorm"; - case Format::eX8D24UnormPack32 : return "X8D24UnormPack32"; - case Format::eD32Sfloat : return "D32Sfloat"; - case Format::eS8Uint : return "S8Uint"; - case Format::eD16UnormS8Uint : return "D16UnormS8Uint"; - case Format::eD24UnormS8Uint : return "D24UnormS8Uint"; - case Format::eD32SfloatS8Uint : return "D32SfloatS8Uint"; - case Format::eBc1RgbUnormBlock : return "Bc1RgbUnormBlock"; - case Format::eBc1RgbSrgbBlock : return "Bc1RgbSrgbBlock"; - case Format::eBc1RgbaUnormBlock : return "Bc1RgbaUnormBlock"; - case Format::eBc1RgbaSrgbBlock : return "Bc1RgbaSrgbBlock"; - case Format::eBc2UnormBlock : return "Bc2UnormBlock"; - case Format::eBc2SrgbBlock : return "Bc2SrgbBlock"; - case Format::eBc3UnormBlock : return "Bc3UnormBlock"; - case Format::eBc3SrgbBlock : return "Bc3SrgbBlock"; - case Format::eBc4UnormBlock : return "Bc4UnormBlock"; - case Format::eBc4SnormBlock : return "Bc4SnormBlock"; - case Format::eBc5UnormBlock : return "Bc5UnormBlock"; - case Format::eBc5SnormBlock : return "Bc5SnormBlock"; - case Format::eBc6HUfloatBlock : return "Bc6HUfloatBlock"; - case Format::eBc6HSfloatBlock : return "Bc6HSfloatBlock"; - case Format::eBc7UnormBlock : return "Bc7UnormBlock"; - case Format::eBc7SrgbBlock : return "Bc7SrgbBlock"; - case Format::eEtc2R8G8B8UnormBlock : return "Etc2R8G8B8UnormBlock"; - case Format::eEtc2R8G8B8SrgbBlock : return "Etc2R8G8B8SrgbBlock"; - case Format::eEtc2R8G8B8A1UnormBlock : return "Etc2R8G8B8A1UnormBlock"; - case Format::eEtc2R8G8B8A1SrgbBlock : return "Etc2R8G8B8A1SrgbBlock"; - case Format::eEtc2R8G8B8A8UnormBlock : return "Etc2R8G8B8A8UnormBlock"; - case Format::eEtc2R8G8B8A8SrgbBlock : return "Etc2R8G8B8A8SrgbBlock"; - case Format::eEacR11UnormBlock : return "EacR11UnormBlock"; - case Format::eEacR11SnormBlock : return "EacR11SnormBlock"; - case Format::eEacR11G11UnormBlock : return "EacR11G11UnormBlock"; - case Format::eEacR11G11SnormBlock : return "EacR11G11SnormBlock"; - case Format::eAstc4x4UnormBlock : return "Astc4x4UnormBlock"; - case Format::eAstc4x4SrgbBlock : return "Astc4x4SrgbBlock"; - case Format::eAstc5x4UnormBlock : return "Astc5x4UnormBlock"; - case Format::eAstc5x4SrgbBlock : return "Astc5x4SrgbBlock"; - case Format::eAstc5x5UnormBlock : return "Astc5x5UnormBlock"; - case Format::eAstc5x5SrgbBlock : return "Astc5x5SrgbBlock"; - case Format::eAstc6x5UnormBlock : return "Astc6x5UnormBlock"; - case Format::eAstc6x5SrgbBlock : return "Astc6x5SrgbBlock"; - case Format::eAstc6x6UnormBlock : return "Astc6x6UnormBlock"; - case Format::eAstc6x6SrgbBlock : return "Astc6x6SrgbBlock"; - case Format::eAstc8x5UnormBlock : return "Astc8x5UnormBlock"; - case Format::eAstc8x5SrgbBlock : return "Astc8x5SrgbBlock"; - case Format::eAstc8x6UnormBlock : return "Astc8x6UnormBlock"; - case Format::eAstc8x6SrgbBlock : return "Astc8x6SrgbBlock"; - case Format::eAstc8x8UnormBlock : return "Astc8x8UnormBlock"; - case Format::eAstc8x8SrgbBlock : return "Astc8x8SrgbBlock"; - case Format::eAstc10x5UnormBlock : return "Astc10x5UnormBlock"; - case Format::eAstc10x5SrgbBlock : return "Astc10x5SrgbBlock"; - case Format::eAstc10x6UnormBlock : return "Astc10x6UnormBlock"; - case Format::eAstc10x6SrgbBlock : return "Astc10x6SrgbBlock"; - case Format::eAstc10x8UnormBlock : return "Astc10x8UnormBlock"; - case Format::eAstc10x8SrgbBlock : return "Astc10x8SrgbBlock"; - case Format::eAstc10x10UnormBlock : return "Astc10x10UnormBlock"; - case Format::eAstc10x10SrgbBlock : return "Astc10x10SrgbBlock"; - case Format::eAstc12x10UnormBlock : return "Astc12x10UnormBlock"; - case Format::eAstc12x10SrgbBlock : return "Astc12x10SrgbBlock"; - case Format::eAstc12x12UnormBlock : return "Astc12x12UnormBlock"; - case Format::eAstc12x12SrgbBlock : return "Astc12x12SrgbBlock"; - case Format::eG8B8G8R8422Unorm : return "G8B8G8R8422Unorm"; - case Format::eB8G8R8G8422Unorm : return "B8G8R8G8422Unorm"; - case Format::eG8B8R83Plane420Unorm : return "G8B8R83Plane420Unorm"; - case Format::eG8B8R82Plane420Unorm : return "G8B8R82Plane420Unorm"; - case Format::eG8B8R83Plane422Unorm : return "G8B8R83Plane422Unorm"; - case Format::eG8B8R82Plane422Unorm : return "G8B8R82Plane422Unorm"; - case Format::eG8B8R83Plane444Unorm : return "G8B8R83Plane444Unorm"; - case Format::eR10X6UnormPack16 : return "R10X6UnormPack16"; - case Format::eR10X6G10X6Unorm2Pack16 : return "R10X6G10X6Unorm2Pack16"; - case Format::eR10X6G10X6B10X6A10X6Unorm4Pack16 : return "R10X6G10X6B10X6A10X6Unorm4Pack16"; - case Format::eG10X6B10X6G10X6R10X6422Unorm4Pack16 : return "G10X6B10X6G10X6R10X6422Unorm4Pack16"; - case Format::eB10X6G10X6R10X6G10X6422Unorm4Pack16 : return "B10X6G10X6R10X6G10X6422Unorm4Pack16"; - case Format::eG10X6B10X6R10X63Plane420Unorm3Pack16 : return "G10X6B10X6R10X63Plane420Unorm3Pack16"; - case Format::eG10X6B10X6R10X62Plane420Unorm3Pack16 : return "G10X6B10X6R10X62Plane420Unorm3Pack16"; - case Format::eG10X6B10X6R10X63Plane422Unorm3Pack16 : return "G10X6B10X6R10X63Plane422Unorm3Pack16"; - case Format::eG10X6B10X6R10X62Plane422Unorm3Pack16 : return "G10X6B10X6R10X62Plane422Unorm3Pack16"; - case Format::eG10X6B10X6R10X63Plane444Unorm3Pack16 : return "G10X6B10X6R10X63Plane444Unorm3Pack16"; - case Format::eR12X4UnormPack16 : return "R12X4UnormPack16"; - case Format::eR12X4G12X4Unorm2Pack16 : return "R12X4G12X4Unorm2Pack16"; - case Format::eR12X4G12X4B12X4A12X4Unorm4Pack16 : return "R12X4G12X4B12X4A12X4Unorm4Pack16"; - case Format::eG12X4B12X4G12X4R12X4422Unorm4Pack16 : return "G12X4B12X4G12X4R12X4422Unorm4Pack16"; - case Format::eB12X4G12X4R12X4G12X4422Unorm4Pack16 : return "B12X4G12X4R12X4G12X4422Unorm4Pack16"; - case Format::eG12X4B12X4R12X43Plane420Unorm3Pack16 : return "G12X4B12X4R12X43Plane420Unorm3Pack16"; - case Format::eG12X4B12X4R12X42Plane420Unorm3Pack16 : return "G12X4B12X4R12X42Plane420Unorm3Pack16"; - case Format::eG12X4B12X4R12X43Plane422Unorm3Pack16 : return "G12X4B12X4R12X43Plane422Unorm3Pack16"; - case Format::eG12X4B12X4R12X42Plane422Unorm3Pack16 : return "G12X4B12X4R12X42Plane422Unorm3Pack16"; - case Format::eG12X4B12X4R12X43Plane444Unorm3Pack16 : return "G12X4B12X4R12X43Plane444Unorm3Pack16"; - case Format::eG16B16G16R16422Unorm : return "G16B16G16R16422Unorm"; - case Format::eB16G16R16G16422Unorm : return "B16G16R16G16422Unorm"; - case Format::eG16B16R163Plane420Unorm : return "G16B16R163Plane420Unorm"; - case Format::eG16B16R162Plane420Unorm : return "G16B16R162Plane420Unorm"; - case Format::eG16B16R163Plane422Unorm : return "G16B16R163Plane422Unorm"; - case Format::eG16B16R162Plane422Unorm : return "G16B16R162Plane422Unorm"; - case Format::eG16B16R163Plane444Unorm : return "G16B16R163Plane444Unorm"; - case Format::eG8B8R82Plane444Unorm : return "G8B8R82Plane444Unorm"; - case Format::eG10X6B10X6R10X62Plane444Unorm3Pack16 : return "G10X6B10X6R10X62Plane444Unorm3Pack16"; - case Format::eG12X4B12X4R12X42Plane444Unorm3Pack16 : return "G12X4B12X4R12X42Plane444Unorm3Pack16"; - case Format::eG16B16R162Plane444Unorm : return "G16B16R162Plane444Unorm"; - case Format::eA4R4G4B4UnormPack16 : return "A4R4G4B4UnormPack16"; - case Format::eA4B4G4R4UnormPack16 : return "A4B4G4R4UnormPack16"; - case Format::eAstc4x4SfloatBlock : return "Astc4x4SfloatBlock"; - case Format::eAstc5x4SfloatBlock : return "Astc5x4SfloatBlock"; - case Format::eAstc5x5SfloatBlock : return "Astc5x5SfloatBlock"; - case Format::eAstc6x5SfloatBlock : return "Astc6x5SfloatBlock"; - case Format::eAstc6x6SfloatBlock : return "Astc6x6SfloatBlock"; - case Format::eAstc8x5SfloatBlock : return "Astc8x5SfloatBlock"; - case Format::eAstc8x6SfloatBlock : return "Astc8x6SfloatBlock"; - case Format::eAstc8x8SfloatBlock : return "Astc8x8SfloatBlock"; - case Format::eAstc10x5SfloatBlock : return "Astc10x5SfloatBlock"; - case Format::eAstc10x6SfloatBlock : return "Astc10x6SfloatBlock"; - case Format::eAstc10x8SfloatBlock : return "Astc10x8SfloatBlock"; - case Format::eAstc10x10SfloatBlock : return "Astc10x10SfloatBlock"; - case Format::eAstc12x10SfloatBlock : return "Astc12x10SfloatBlock"; - case Format::eAstc12x12SfloatBlock : return "Astc12x12SfloatBlock"; - case Format::eA1B5G5R5UnormPack16 : return "A1B5G5R5UnormPack16"; - case Format::eA8Unorm : return "A8Unorm"; - case Format::ePvrtc12BppUnormBlockIMG : return "Pvrtc12BppUnormBlockIMG"; - case Format::ePvrtc14BppUnormBlockIMG : return "Pvrtc14BppUnormBlockIMG"; - case Format::ePvrtc22BppUnormBlockIMG : return "Pvrtc22BppUnormBlockIMG"; - case Format::ePvrtc24BppUnormBlockIMG : return "Pvrtc24BppUnormBlockIMG"; - case Format::ePvrtc12BppSrgbBlockIMG : return "Pvrtc12BppSrgbBlockIMG"; - case Format::ePvrtc14BppSrgbBlockIMG : return "Pvrtc14BppSrgbBlockIMG"; - case Format::ePvrtc22BppSrgbBlockIMG : return "Pvrtc22BppSrgbBlockIMG"; - case Format::ePvrtc24BppSrgbBlockIMG : return "Pvrtc24BppSrgbBlockIMG"; - case Format::eAstc3x3x3UnormBlockEXT : return "Astc3x3x3UnormBlockEXT"; - case Format::eAstc3x3x3SrgbBlockEXT : return "Astc3x3x3SrgbBlockEXT"; - case Format::eAstc3x3x3SfloatBlockEXT : return "Astc3x3x3SfloatBlockEXT"; - case Format::eAstc4x3x3UnormBlockEXT : return "Astc4x3x3UnormBlockEXT"; - case Format::eAstc4x3x3SrgbBlockEXT : return "Astc4x3x3SrgbBlockEXT"; - case Format::eAstc4x3x3SfloatBlockEXT : return "Astc4x3x3SfloatBlockEXT"; - case Format::eAstc4x4x3UnormBlockEXT : return "Astc4x4x3UnormBlockEXT"; - case Format::eAstc4x4x3SrgbBlockEXT : return "Astc4x4x3SrgbBlockEXT"; - case Format::eAstc4x4x3SfloatBlockEXT : return "Astc4x4x3SfloatBlockEXT"; - case Format::eAstc4x4x4UnormBlockEXT : return "Astc4x4x4UnormBlockEXT"; - case Format::eAstc4x4x4SrgbBlockEXT : return "Astc4x4x4SrgbBlockEXT"; - case Format::eAstc4x4x4SfloatBlockEXT : return "Astc4x4x4SfloatBlockEXT"; - case Format::eAstc5x4x4UnormBlockEXT : return "Astc5x4x4UnormBlockEXT"; - case Format::eAstc5x4x4SrgbBlockEXT : return "Astc5x4x4SrgbBlockEXT"; - case Format::eAstc5x4x4SfloatBlockEXT : return "Astc5x4x4SfloatBlockEXT"; - case Format::eAstc5x5x4UnormBlockEXT : return "Astc5x5x4UnormBlockEXT"; - case Format::eAstc5x5x4SrgbBlockEXT : return "Astc5x5x4SrgbBlockEXT"; - case Format::eAstc5x5x4SfloatBlockEXT : return "Astc5x5x4SfloatBlockEXT"; - case Format::eAstc5x5x5UnormBlockEXT : return "Astc5x5x5UnormBlockEXT"; - case Format::eAstc5x5x5SrgbBlockEXT : return "Astc5x5x5SrgbBlockEXT"; - case Format::eAstc5x5x5SfloatBlockEXT : return "Astc5x5x5SfloatBlockEXT"; - case Format::eAstc6x5x5UnormBlockEXT : return "Astc6x5x5UnormBlockEXT"; - case Format::eAstc6x5x5SrgbBlockEXT : return "Astc6x5x5SrgbBlockEXT"; - case Format::eAstc6x5x5SfloatBlockEXT : return "Astc6x5x5SfloatBlockEXT"; - case Format::eAstc6x6x5UnormBlockEXT : return "Astc6x6x5UnormBlockEXT"; - case Format::eAstc6x6x5SrgbBlockEXT : return "Astc6x6x5SrgbBlockEXT"; - case Format::eAstc6x6x5SfloatBlockEXT : return "Astc6x6x5SfloatBlockEXT"; - case Format::eAstc6x6x6UnormBlockEXT : return "Astc6x6x6UnormBlockEXT"; - case Format::eAstc6x6x6SrgbBlockEXT : return "Astc6x6x6SrgbBlockEXT"; - case Format::eAstc6x6x6SfloatBlockEXT : return "Astc6x6x6SfloatBlockEXT"; - case Format::eR8BoolARM : return "R8BoolARM"; - case Format::eR16G16Sfixed5NV : return "R16G16Sfixed5NV"; - case Format::eR10X6UintPack16ARM : return "R10X6UintPack16ARM"; - case Format::eR10X6G10X6Uint2Pack16ARM : return "R10X6G10X6Uint2Pack16ARM"; - case Format::eR10X6G10X6B10X6A10X6Uint4Pack16ARM : return "R10X6G10X6B10X6A10X6Uint4Pack16ARM"; - case Format::eR12X4UintPack16ARM : return "R12X4UintPack16ARM"; - case Format::eR12X4G12X4Uint2Pack16ARM : return "R12X4G12X4Uint2Pack16ARM"; - case Format::eR12X4G12X4B12X4A12X4Uint4Pack16ARM : return "R12X4G12X4B12X4A12X4Uint4Pack16ARM"; - case Format::eR14X2UintPack16ARM : return "R14X2UintPack16ARM"; - case Format::eR14X2G14X2Uint2Pack16ARM : return "R14X2G14X2Uint2Pack16ARM"; - case Format::eR14X2G14X2B14X2A14X2Uint4Pack16ARM : return "R14X2G14X2B14X2A14X2Uint4Pack16ARM"; - case Format::eR14X2UnormPack16ARM : return "R14X2UnormPack16ARM"; - case Format::eR14X2G14X2Unorm2Pack16ARM : return "R14X2G14X2Unorm2Pack16ARM"; - case Format::eR14X2G14X2B14X2A14X2Unorm4Pack16ARM : return "R14X2G14X2B14X2A14X2Unorm4Pack16ARM"; - case Format::eG14X2B14X2R14X22Plane420Unorm3Pack16ARM: return "G14X2B14X2R14X22Plane420Unorm3Pack16ARM"; - case Format::eG14X2B14X2R14X22Plane422Unorm3Pack16ARM: return "G14X2B14X2R14X22Plane422Unorm3Pack16ARM"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FormatFeatureFlagBits value ) - { - switch ( value ) - { - case FormatFeatureFlagBits::eSampledImage : return "SampledImage"; - case FormatFeatureFlagBits::eStorageImage : return "StorageImage"; - case FormatFeatureFlagBits::eStorageImageAtomic : return "StorageImageAtomic"; - case FormatFeatureFlagBits::eUniformTexelBuffer : return "UniformTexelBuffer"; - case FormatFeatureFlagBits::eStorageTexelBuffer : return "StorageTexelBuffer"; - case FormatFeatureFlagBits::eStorageTexelBufferAtomic : return "StorageTexelBufferAtomic"; - case FormatFeatureFlagBits::eVertexBuffer : return "VertexBuffer"; - case FormatFeatureFlagBits::eColorAttachment : return "ColorAttachment"; - case FormatFeatureFlagBits::eColorAttachmentBlend : return "ColorAttachmentBlend"; - case FormatFeatureFlagBits::eDepthStencilAttachment : return "DepthStencilAttachment"; - case FormatFeatureFlagBits::eBlitSrc : return "BlitSrc"; - case FormatFeatureFlagBits::eBlitDst : return "BlitDst"; - case FormatFeatureFlagBits::eSampledImageFilterLinear : return "SampledImageFilterLinear"; - case FormatFeatureFlagBits::eTransferSrc : return "TransferSrc"; - case FormatFeatureFlagBits::eTransferDst : return "TransferDst"; - case FormatFeatureFlagBits::eMidpointChromaSamples : return "MidpointChromaSamples"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionLinearFilter : return "SampledImageYcbcrConversionLinearFilter"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionSeparateReconstructionFilter: return "SampledImageYcbcrConversionSeparateReconstructionFilter"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicit: return "SampledImageYcbcrConversionChromaReconstructionExplicit"; - case FormatFeatureFlagBits::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable: - return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable"; - case FormatFeatureFlagBits::eDisjoint : return "Disjoint"; - case FormatFeatureFlagBits::eCositedChromaSamples : return "CositedChromaSamples"; - case FormatFeatureFlagBits::eSampledImageFilterMinmax : return "SampledImageFilterMinmax"; - case FormatFeatureFlagBits::eVideoDecodeOutputKHR : return "VideoDecodeOutputKHR"; - case FormatFeatureFlagBits::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR"; - case FormatFeatureFlagBits::eAccelerationStructureVertexBufferKHR: return "AccelerationStructureVertexBufferKHR"; - case FormatFeatureFlagBits::eSampledImageFilterCubicEXT : return "SampledImageFilterCubicEXT"; - case FormatFeatureFlagBits::eFragmentDensityMapEXT : return "FragmentDensityMapEXT"; - case FormatFeatureFlagBits::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR"; - case FormatFeatureFlagBits::eVideoEncodeInputKHR : return "VideoEncodeInputKHR"; - case FormatFeatureFlagBits::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageCreateFlagBits value ) - { - switch ( value ) - { - case ImageCreateFlagBits::eSparseBinding : return "SparseBinding"; - case ImageCreateFlagBits::eSparseResidency : return "SparseResidency"; - case ImageCreateFlagBits::eSparseAliased : return "SparseAliased"; - case ImageCreateFlagBits::eMutableFormat : return "MutableFormat"; - case ImageCreateFlagBits::eCubeCompatible : return "CubeCompatible"; - case ImageCreateFlagBits::eAlias : return "Alias"; - case ImageCreateFlagBits::eSplitInstanceBindRegions : return "SplitInstanceBindRegions"; - case ImageCreateFlagBits::e2DArrayCompatible : return "2DArrayCompatible"; - case ImageCreateFlagBits::eBlockTexelViewCompatible : return "BlockTexelViewCompatible"; - case ImageCreateFlagBits::eExtendedUsage : return "ExtendedUsage"; - case ImageCreateFlagBits::eProtected : return "Protected"; - case ImageCreateFlagBits::eDisjoint : return "Disjoint"; - case ImageCreateFlagBits::eCornerSampledNV : return "CornerSampledNV"; - case ImageCreateFlagBits::eDescriptorHeapCaptureReplayEXT : return "DescriptorHeapCaptureReplayEXT"; - case ImageCreateFlagBits::eSampleLocationsCompatibleDepthEXT : return "SampleLocationsCompatibleDepthEXT"; - case ImageCreateFlagBits::eSubsampledEXT : return "SubsampledEXT"; - case ImageCreateFlagBits::eMultisampledRenderToSingleSampledEXT: return "MultisampledRenderToSingleSampledEXT"; - case ImageCreateFlagBits::e2DViewCompatibleEXT : return "2DViewCompatibleEXT"; - case ImageCreateFlagBits::eVideoProfileIndependentKHR : return "VideoProfileIndependentKHR"; - case ImageCreateFlagBits::eFragmentDensityMapOffsetEXT : return "FragmentDensityMapOffsetEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageTiling value ) - { - switch ( value ) - { - case ImageTiling::eOptimal : return "Optimal"; - case ImageTiling::eLinear : return "Linear"; - case ImageTiling::eDrmFormatModifierEXT: return "DrmFormatModifierEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageType value ) - { - switch ( value ) - { - case ImageType::e1D: return "1D"; - case ImageType::e2D: return "2D"; - case ImageType::e3D: return "3D"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageUsageFlagBits value ) - { - switch ( value ) - { - case ImageUsageFlagBits::eTransferSrc : return "TransferSrc"; - case ImageUsageFlagBits::eTransferDst : return "TransferDst"; - case ImageUsageFlagBits::eSampled : return "Sampled"; - case ImageUsageFlagBits::eStorage : return "Storage"; - case ImageUsageFlagBits::eColorAttachment : return "ColorAttachment"; - case ImageUsageFlagBits::eDepthStencilAttachment : return "DepthStencilAttachment"; - case ImageUsageFlagBits::eTransientAttachment : return "TransientAttachment"; - case ImageUsageFlagBits::eInputAttachment : return "InputAttachment"; - case ImageUsageFlagBits::eHostTransfer : return "HostTransfer"; - case ImageUsageFlagBits::eVideoDecodeDstKHR : return "VideoDecodeDstKHR"; - case ImageUsageFlagBits::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR"; - case ImageUsageFlagBits::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR"; - case ImageUsageFlagBits::eFragmentDensityMapEXT : return "FragmentDensityMapEXT"; - case ImageUsageFlagBits::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR"; - case ImageUsageFlagBits::eVideoEncodeDstKHR : return "VideoEncodeDstKHR"; - case ImageUsageFlagBits::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR"; - case ImageUsageFlagBits::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR"; - case ImageUsageFlagBits::eAttachmentFeedbackLoopEXT : return "AttachmentFeedbackLoopEXT"; - case ImageUsageFlagBits::eInvocationMaskHUAWEI : return "InvocationMaskHUAWEI"; - case ImageUsageFlagBits::eSampleWeightQCOM : return "SampleWeightQCOM"; - case ImageUsageFlagBits::eSampleBlockMatchQCOM : return "SampleBlockMatchQCOM"; - case ImageUsageFlagBits::eTensorAliasingARM : return "TensorAliasingARM"; - case ImageUsageFlagBits::eTileMemoryQCOM : return "TileMemoryQCOM"; - case ImageUsageFlagBits::eVideoEncodeQuantizationDeltaMapKHR: return "VideoEncodeQuantizationDeltaMapKHR"; - case ImageUsageFlagBits::eVideoEncodeEmphasisMapKHR : return "VideoEncodeEmphasisMapKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( InstanceCreateFlagBits value ) - { - switch ( value ) - { - case InstanceCreateFlagBits::eEnumeratePortabilityKHR: return "EnumeratePortabilityKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( InternalAllocationType value ) - { - switch ( value ) - { - case InternalAllocationType::eExecutable: return "Executable"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryHeapFlagBits value ) - { - switch ( value ) - { - case MemoryHeapFlagBits::eDeviceLocal : return "DeviceLocal"; - case MemoryHeapFlagBits::eMultiInstance : return "MultiInstance"; - case MemoryHeapFlagBits::eTileMemoryQCOM: return "TileMemoryQCOM"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryPropertyFlagBits value ) - { - switch ( value ) - { - case MemoryPropertyFlagBits::eDeviceLocal : return "DeviceLocal"; - case MemoryPropertyFlagBits::eHostVisible : return "HostVisible"; - case MemoryPropertyFlagBits::eHostCoherent : return "HostCoherent"; - case MemoryPropertyFlagBits::eHostCached : return "HostCached"; - case MemoryPropertyFlagBits::eLazilyAllocated : return "LazilyAllocated"; - case MemoryPropertyFlagBits::eProtected : return "Protected"; - case MemoryPropertyFlagBits::eDeviceCoherentAMD: return "DeviceCoherentAMD"; - case MemoryPropertyFlagBits::eDeviceUncachedAMD: return "DeviceUncachedAMD"; - case MemoryPropertyFlagBits::eRdmaCapableNV : return "RdmaCapableNV"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceType value ) - { - switch ( value ) - { - case PhysicalDeviceType::eOther : return "Other"; - case PhysicalDeviceType::eIntegratedGpu: return "IntegratedGpu"; - case PhysicalDeviceType::eDiscreteGpu : return "DiscreteGpu"; - case PhysicalDeviceType::eVirtualGpu : return "VirtualGpu"; - case PhysicalDeviceType::eCpu : return "Cpu"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueueFlagBits value ) - { - switch ( value ) - { - case QueueFlagBits::eGraphics : return "Graphics"; - case QueueFlagBits::eCompute : return "Compute"; - case QueueFlagBits::eTransfer : return "Transfer"; - case QueueFlagBits::eSparseBinding : return "SparseBinding"; - case QueueFlagBits::eProtected : return "Protected"; - case QueueFlagBits::eVideoDecodeKHR: return "VideoDecodeKHR"; - case QueueFlagBits::eVideoEncodeKHR: return "VideoEncodeKHR"; - case QueueFlagBits::eOpticalFlowNV : return "OpticalFlowNV"; - case QueueFlagBits::eDataGraphARM : return "DataGraphARM"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SampleCountFlagBits value ) - { - switch ( value ) - { - case SampleCountFlagBits::e1 : return "1"; - case SampleCountFlagBits::e2 : return "2"; - case SampleCountFlagBits::e4 : return "4"; - case SampleCountFlagBits::e8 : return "8"; - case SampleCountFlagBits::e16: return "16"; - case SampleCountFlagBits::e32: return "32"; - case SampleCountFlagBits::e64: return "64"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SystemAllocationScope value ) - { - switch ( value ) - { - case SystemAllocationScope::eCommand : return "Command"; - case SystemAllocationScope::eObject : return "Object"; - case SystemAllocationScope::eCache : return "Cache"; - case SystemAllocationScope::eDevice : return "Device"; - case SystemAllocationScope::eInstance: return "Instance"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceQueueCreateFlagBits value ) - { - switch ( value ) - { - case DeviceQueueCreateFlagBits::eProtected : return "Protected"; - case DeviceQueueCreateFlagBits::eInternallySynchronizedKHR: return "InternallySynchronizedKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineStageFlagBits value ) - { - switch ( value ) - { - case PipelineStageFlagBits::eTopOfPipe : return "TopOfPipe"; - case PipelineStageFlagBits::eDrawIndirect : return "DrawIndirect"; - case PipelineStageFlagBits::eVertexInput : return "VertexInput"; - case PipelineStageFlagBits::eVertexShader : return "VertexShader"; - case PipelineStageFlagBits::eTessellationControlShader : return "TessellationControlShader"; - case PipelineStageFlagBits::eTessellationEvaluationShader : return "TessellationEvaluationShader"; - case PipelineStageFlagBits::eGeometryShader : return "GeometryShader"; - case PipelineStageFlagBits::eFragmentShader : return "FragmentShader"; - case PipelineStageFlagBits::eEarlyFragmentTests : return "EarlyFragmentTests"; - case PipelineStageFlagBits::eLateFragmentTests : return "LateFragmentTests"; - case PipelineStageFlagBits::eColorAttachmentOutput : return "ColorAttachmentOutput"; - case PipelineStageFlagBits::eComputeShader : return "ComputeShader"; - case PipelineStageFlagBits::eTransfer : return "Transfer"; - case PipelineStageFlagBits::eBottomOfPipe : return "BottomOfPipe"; - case PipelineStageFlagBits::eHost : return "Host"; - case PipelineStageFlagBits::eAllGraphics : return "AllGraphics"; - case PipelineStageFlagBits::eAllCommands : return "AllCommands"; - case PipelineStageFlagBits::eNone : return "None"; - case PipelineStageFlagBits::eTransformFeedbackEXT : return "TransformFeedbackEXT"; - case PipelineStageFlagBits::eConditionalRenderingEXT : return "ConditionalRenderingEXT"; - case PipelineStageFlagBits::eAccelerationStructureBuildKHR : return "AccelerationStructureBuildKHR"; - case PipelineStageFlagBits::eRayTracingShaderKHR : return "RayTracingShaderKHR"; - case PipelineStageFlagBits::eFragmentDensityProcessEXT : return "FragmentDensityProcessEXT"; - case PipelineStageFlagBits::eFragmentShadingRateAttachmentKHR: return "FragmentShadingRateAttachmentKHR"; - case PipelineStageFlagBits::eTaskShaderEXT : return "TaskShaderEXT"; - case PipelineStageFlagBits::eMeshShaderEXT : return "MeshShaderEXT"; - case PipelineStageFlagBits::eCommandPreprocessEXT : return "CommandPreprocessEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryMapFlagBits value ) - { - switch ( value ) - { - case MemoryMapFlagBits::ePlacedEXT: return "PlacedEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageAspectFlagBits value ) - { - switch ( value ) - { - case ImageAspectFlagBits::eColor : return "Color"; - case ImageAspectFlagBits::eDepth : return "Depth"; - case ImageAspectFlagBits::eStencil : return "Stencil"; - case ImageAspectFlagBits::eMetadata : return "Metadata"; - case ImageAspectFlagBits::ePlane0 : return "Plane0"; - case ImageAspectFlagBits::ePlane1 : return "Plane1"; - case ImageAspectFlagBits::ePlane2 : return "Plane2"; - case ImageAspectFlagBits::eNone : return "None"; - case ImageAspectFlagBits::eMemoryPlane0EXT: return "MemoryPlane0EXT"; - case ImageAspectFlagBits::eMemoryPlane1EXT: return "MemoryPlane1EXT"; - case ImageAspectFlagBits::eMemoryPlane2EXT: return "MemoryPlane2EXT"; - case ImageAspectFlagBits::eMemoryPlane3EXT: return "MemoryPlane3EXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SparseImageFormatFlagBits value ) - { - switch ( value ) - { - case SparseImageFormatFlagBits::eSingleMiptail : return "SingleMiptail"; - case SparseImageFormatFlagBits::eAlignedMipSize : return "AlignedMipSize"; - case SparseImageFormatFlagBits::eNonstandardBlockSize: return "NonstandardBlockSize"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SparseMemoryBindFlagBits value ) - { - switch ( value ) - { - case SparseMemoryBindFlagBits::eMetadata: return "Metadata"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FenceCreateFlagBits value ) - { - switch ( value ) - { - case FenceCreateFlagBits::eSignaled: return "Signaled"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryPoolCreateFlagBits value ) - { - switch ( value ) - { - case QueryPoolCreateFlagBits::eResetKHR: return "ResetKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryResultFlagBits value ) - { - switch ( value ) - { - case QueryResultFlagBits::e64 : return "64"; - case QueryResultFlagBits::eWait : return "Wait"; - case QueryResultFlagBits::eWithAvailability: return "WithAvailability"; - case QueryResultFlagBits::ePartial : return "Partial"; - case QueryResultFlagBits::eWithStatusKHR : return "WithStatusKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryType value ) - { - switch ( value ) - { - case QueryType::eOcclusion : return "Occlusion"; - case QueryType::ePipelineStatistics : return "PipelineStatistics"; - case QueryType::eTimestamp : return "Timestamp"; - case QueryType::eResultStatusOnlyKHR : return "ResultStatusOnlyKHR"; - case QueryType::eTransformFeedbackStreamEXT : return "TransformFeedbackStreamEXT"; - case QueryType::ePerformanceQueryKHR : return "PerformanceQueryKHR"; - case QueryType::eAccelerationStructureCompactedSizeKHR : return "AccelerationStructureCompactedSizeKHR"; - case QueryType::eAccelerationStructureSerializationSizeKHR : return "AccelerationStructureSerializationSizeKHR"; - case QueryType::eAccelerationStructureCompactedSizeNV : return "AccelerationStructureCompactedSizeNV"; - case QueryType::ePerformanceQueryINTEL : return "PerformanceQueryINTEL"; - case QueryType::eVideoEncodeFeedbackKHR : return "VideoEncodeFeedbackKHR"; - case QueryType::eMeshPrimitivesGeneratedEXT : return "MeshPrimitivesGeneratedEXT"; - case QueryType::ePrimitivesGeneratedEXT : return "PrimitivesGeneratedEXT"; - case QueryType::eAccelerationStructureSerializationBottomLevelPointersKHR: return "AccelerationStructureSerializationBottomLevelPointersKHR"; - case QueryType::eAccelerationStructureSizeKHR : return "AccelerationStructureSizeKHR"; - case QueryType::eMicromapSerializationSizeEXT : return "MicromapSerializationSizeEXT"; - case QueryType::eMicromapCompactedSizeEXT : return "MicromapCompactedSizeEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferCreateFlagBits value ) - { - switch ( value ) - { - case BufferCreateFlagBits::eSparseBinding : return "SparseBinding"; - case BufferCreateFlagBits::eSparseResidency : return "SparseResidency"; - case BufferCreateFlagBits::eSparseAliased : return "SparseAliased"; - case BufferCreateFlagBits::eProtected : return "Protected"; - case BufferCreateFlagBits::eDeviceAddressCaptureReplay : return "DeviceAddressCaptureReplay"; - case BufferCreateFlagBits::eDescriptorBufferCaptureReplayEXT: return "DescriptorBufferCaptureReplayEXT"; - case BufferCreateFlagBits::eVideoProfileIndependentKHR : return "VideoProfileIndependentKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferUsageFlagBits value ) - { - switch ( value ) - { - case BufferUsageFlagBits::eTransferSrc : return "TransferSrc"; - case BufferUsageFlagBits::eTransferDst : return "TransferDst"; - case BufferUsageFlagBits::eUniformTexelBuffer : return "UniformTexelBuffer"; - case BufferUsageFlagBits::eStorageTexelBuffer : return "StorageTexelBuffer"; - case BufferUsageFlagBits::eUniformBuffer : return "UniformBuffer"; - case BufferUsageFlagBits::eStorageBuffer : return "StorageBuffer"; - case BufferUsageFlagBits::eIndexBuffer : return "IndexBuffer"; - case BufferUsageFlagBits::eVertexBuffer : return "VertexBuffer"; - case BufferUsageFlagBits::eIndirectBuffer : return "IndirectBuffer"; - case BufferUsageFlagBits::eShaderDeviceAddress : return "ShaderDeviceAddress"; - case BufferUsageFlagBits::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR"; - case BufferUsageFlagBits::eVideoDecodeDstKHR : return "VideoDecodeDstKHR"; - case BufferUsageFlagBits::eTransformFeedbackBufferEXT : return "TransformFeedbackBufferEXT"; - case BufferUsageFlagBits::eTransformFeedbackCounterBufferEXT: return "TransformFeedbackCounterBufferEXT"; - case BufferUsageFlagBits::eConditionalRenderingEXT : return "ConditionalRenderingEXT"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case BufferUsageFlagBits::eExecutionGraphScratchAMDX: return "ExecutionGraphScratchAMDX"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case BufferUsageFlagBits::eDescriptorHeapEXT : return "DescriptorHeapEXT"; - case BufferUsageFlagBits::eAccelerationStructureBuildInputReadOnlyKHR: return "AccelerationStructureBuildInputReadOnlyKHR"; - case BufferUsageFlagBits::eAccelerationStructureStorageKHR : return "AccelerationStructureStorageKHR"; - case BufferUsageFlagBits::eShaderBindingTableKHR : return "ShaderBindingTableKHR"; - case BufferUsageFlagBits::eVideoEncodeDstKHR : return "VideoEncodeDstKHR"; - case BufferUsageFlagBits::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR"; - case BufferUsageFlagBits::eSamplerDescriptorBufferEXT : return "SamplerDescriptorBufferEXT"; - case BufferUsageFlagBits::eResourceDescriptorBufferEXT : return "ResourceDescriptorBufferEXT"; - case BufferUsageFlagBits::ePushDescriptorsDescriptorBufferEXT : return "PushDescriptorsDescriptorBufferEXT"; - case BufferUsageFlagBits::eMicromapBuildInputReadOnlyEXT : return "MicromapBuildInputReadOnlyEXT"; - case BufferUsageFlagBits::eMicromapStorageEXT : return "MicromapStorageEXT"; - case BufferUsageFlagBits::eTileMemoryQCOM : return "TileMemoryQCOM"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SharingMode value ) - { - switch ( value ) - { - case SharingMode::eExclusive : return "Exclusive"; - case SharingMode::eConcurrent: return "Concurrent"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageLayout value ) - { - switch ( value ) - { - case ImageLayout::eUndefined : return "Undefined"; - case ImageLayout::eGeneral : return "General"; - case ImageLayout::eColorAttachmentOptimal : return "ColorAttachmentOptimal"; - case ImageLayout::eDepthStencilAttachmentOptimal : return "DepthStencilAttachmentOptimal"; - case ImageLayout::eDepthStencilReadOnlyOptimal : return "DepthStencilReadOnlyOptimal"; - case ImageLayout::eShaderReadOnlyOptimal : return "ShaderReadOnlyOptimal"; - case ImageLayout::eTransferSrcOptimal : return "TransferSrcOptimal"; - case ImageLayout::eTransferDstOptimal : return "TransferDstOptimal"; - case ImageLayout::ePreinitialized : return "Preinitialized"; - case ImageLayout::eDepthReadOnlyStencilAttachmentOptimal : return "DepthReadOnlyStencilAttachmentOptimal"; - case ImageLayout::eDepthAttachmentStencilReadOnlyOptimal : return "DepthAttachmentStencilReadOnlyOptimal"; - case ImageLayout::eDepthAttachmentOptimal : return "DepthAttachmentOptimal"; - case ImageLayout::eDepthReadOnlyOptimal : return "DepthReadOnlyOptimal"; - case ImageLayout::eStencilAttachmentOptimal : return "StencilAttachmentOptimal"; - case ImageLayout::eStencilReadOnlyOptimal : return "StencilReadOnlyOptimal"; - case ImageLayout::eReadOnlyOptimal : return "ReadOnlyOptimal"; - case ImageLayout::eAttachmentOptimal : return "AttachmentOptimal"; - case ImageLayout::eRenderingLocalRead : return "RenderingLocalRead"; - case ImageLayout::ePresentSrcKHR : return "PresentSrcKHR"; - case ImageLayout::eVideoDecodeDstKHR : return "VideoDecodeDstKHR"; - case ImageLayout::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR"; - case ImageLayout::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR"; - case ImageLayout::eSharedPresentKHR : return "SharedPresentKHR"; - case ImageLayout::eFragmentDensityMapOptimalEXT : return "FragmentDensityMapOptimalEXT"; - case ImageLayout::eFragmentShadingRateAttachmentOptimalKHR: return "FragmentShadingRateAttachmentOptimalKHR"; - case ImageLayout::eVideoEncodeDstKHR : return "VideoEncodeDstKHR"; - case ImageLayout::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR"; - case ImageLayout::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR"; - case ImageLayout::eAttachmentFeedbackLoopOptimalEXT : return "AttachmentFeedbackLoopOptimalEXT"; - case ImageLayout::eTensorAliasingARM : return "TensorAliasingARM"; - case ImageLayout::eVideoEncodeQuantizationMapKHR : return "VideoEncodeQuantizationMapKHR"; - case ImageLayout::eZeroInitializedEXT : return "ZeroInitializedEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ComponentSwizzle value ) - { - switch ( value ) - { - case ComponentSwizzle::eIdentity: return "Identity"; - case ComponentSwizzle::eZero : return "Zero"; - case ComponentSwizzle::eOne : return "One"; - case ComponentSwizzle::eR : return "R"; - case ComponentSwizzle::eG : return "G"; - case ComponentSwizzle::eB : return "B"; - case ComponentSwizzle::eA : return "A"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageViewCreateFlagBits value ) - { - switch ( value ) - { - case ImageViewCreateFlagBits::eFragmentDensityMapDynamicEXT : return "FragmentDensityMapDynamicEXT"; - case ImageViewCreateFlagBits::eDescriptorBufferCaptureReplayEXT: return "DescriptorBufferCaptureReplayEXT"; - case ImageViewCreateFlagBits::eFragmentDensityMapDeferredEXT : return "FragmentDensityMapDeferredEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageViewType value ) - { - switch ( value ) - { - case ImageViewType::e1D : return "1D"; - case ImageViewType::e2D : return "2D"; - case ImageViewType::e3D : return "3D"; - case ImageViewType::eCube : return "Cube"; - case ImageViewType::e1DArray : return "1DArray"; - case ImageViewType::e2DArray : return "2DArray"; - case ImageViewType::eCubeArray: return "CubeArray"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlagBits value ) - { - switch ( value ) - { - case AccessFlagBits::eIndirectCommandRead : return "IndirectCommandRead"; - case AccessFlagBits::eIndexRead : return "IndexRead"; - case AccessFlagBits::eVertexAttributeRead : return "VertexAttributeRead"; - case AccessFlagBits::eUniformRead : return "UniformRead"; - case AccessFlagBits::eInputAttachmentRead : return "InputAttachmentRead"; - case AccessFlagBits::eShaderRead : return "ShaderRead"; - case AccessFlagBits::eShaderWrite : return "ShaderWrite"; - case AccessFlagBits::eColorAttachmentRead : return "ColorAttachmentRead"; - case AccessFlagBits::eColorAttachmentWrite : return "ColorAttachmentWrite"; - case AccessFlagBits::eDepthStencilAttachmentRead : return "DepthStencilAttachmentRead"; - case AccessFlagBits::eDepthStencilAttachmentWrite : return "DepthStencilAttachmentWrite"; - case AccessFlagBits::eTransferRead : return "TransferRead"; - case AccessFlagBits::eTransferWrite : return "TransferWrite"; - case AccessFlagBits::eHostRead : return "HostRead"; - case AccessFlagBits::eHostWrite : return "HostWrite"; - case AccessFlagBits::eMemoryRead : return "MemoryRead"; - case AccessFlagBits::eMemoryWrite : return "MemoryWrite"; - case AccessFlagBits::eNone : return "None"; - case AccessFlagBits::eTransformFeedbackWriteEXT : return "TransformFeedbackWriteEXT"; - case AccessFlagBits::eTransformFeedbackCounterReadEXT : return "TransformFeedbackCounterReadEXT"; - case AccessFlagBits::eTransformFeedbackCounterWriteEXT : return "TransformFeedbackCounterWriteEXT"; - case AccessFlagBits::eConditionalRenderingReadEXT : return "ConditionalRenderingReadEXT"; - case AccessFlagBits::eColorAttachmentReadNoncoherentEXT : return "ColorAttachmentReadNoncoherentEXT"; - case AccessFlagBits::eAccelerationStructureReadKHR : return "AccelerationStructureReadKHR"; - case AccessFlagBits::eAccelerationStructureWriteKHR : return "AccelerationStructureWriteKHR"; - case AccessFlagBits::eFragmentDensityMapReadEXT : return "FragmentDensityMapReadEXT"; - case AccessFlagBits::eFragmentShadingRateAttachmentReadKHR: return "FragmentShadingRateAttachmentReadKHR"; - case AccessFlagBits::eCommandPreprocessReadEXT : return "CommandPreprocessReadEXT"; - case AccessFlagBits::eCommandPreprocessWriteEXT : return "CommandPreprocessWriteEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DependencyFlagBits value ) - { - switch ( value ) - { - case DependencyFlagBits::eByRegion : return "ByRegion"; - case DependencyFlagBits::eDeviceGroup : return "DeviceGroup"; - case DependencyFlagBits::eViewLocal : return "ViewLocal"; - case DependencyFlagBits::eFeedbackLoopEXT : return "FeedbackLoopEXT"; - case DependencyFlagBits::eQueueFamilyOwnershipTransferUseAllStagesKHR: return "QueueFamilyOwnershipTransferUseAllStagesKHR"; - case DependencyFlagBits::eAsymmetricEventKHR : return "AsymmetricEventKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolCreateFlagBits value ) - { - switch ( value ) - { - case CommandPoolCreateFlagBits::eTransient : return "Transient"; - case CommandPoolCreateFlagBits::eResetCommandBuffer: return "ResetCommandBuffer"; - case CommandPoolCreateFlagBits::eProtected : return "Protected"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolResetFlagBits value ) - { - switch ( value ) - { - case CommandPoolResetFlagBits::eReleaseResources: return "ReleaseResources"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandBufferLevel value ) - { - switch ( value ) - { - case CommandBufferLevel::ePrimary : return "Primary"; - case CommandBufferLevel::eSecondary: return "Secondary"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandBufferResetFlagBits value ) - { - switch ( value ) - { - case CommandBufferResetFlagBits::eReleaseResources: return "ReleaseResources"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandBufferUsageFlagBits value ) - { - switch ( value ) - { - case CommandBufferUsageFlagBits::eOneTimeSubmit : return "OneTimeSubmit"; - case CommandBufferUsageFlagBits::eRenderPassContinue: return "RenderPassContinue"; - case CommandBufferUsageFlagBits::eSimultaneousUse : return "SimultaneousUse"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryControlFlagBits value ) - { - switch ( value ) - { - case QueryControlFlagBits::ePrecise: return "Precise"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndexType value ) - { - switch ( value ) - { - case IndexType::eUint16 : return "Uint16"; - case IndexType::eUint32 : return "Uint32"; - case IndexType::eUint8 : return "Uint8"; - case IndexType::eNoneKHR: return "NoneKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCacheHeaderVersion value ) - { - switch ( value ) - { - case PipelineCacheHeaderVersion::eOne : return "One"; - case PipelineCacheHeaderVersion::eDataGraphQCOM: return "DataGraphQCOM"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( EventCreateFlagBits value ) - { - switch ( value ) - { - case EventCreateFlagBits::eDeviceOnly: return "DeviceOnly"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferViewCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderModuleCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCacheCreateFlagBits value ) - { - switch ( value ) - { - case PipelineCacheCreateFlagBits::eExternallySynchronized : return "ExternallySynchronized"; - case PipelineCacheCreateFlagBits::eInternallySynchronizedMergeKHR: return "InternallySynchronizedMergeKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCreateFlagBits value ) - { - switch ( value ) - { - case PipelineCreateFlagBits::eDisableOptimization : return "DisableOptimization"; - case PipelineCreateFlagBits::eAllowDerivatives : return "AllowDerivatives"; - case PipelineCreateFlagBits::eDerivative : return "Derivative"; - case PipelineCreateFlagBits::eDispatchBase : return "DispatchBase"; - case PipelineCreateFlagBits::eViewIndexFromDeviceIndex : return "ViewIndexFromDeviceIndex"; - case PipelineCreateFlagBits::eFailOnPipelineCompileRequired : return "FailOnPipelineCompileRequired"; - case PipelineCreateFlagBits::eEarlyReturnOnFailure : return "EarlyReturnOnFailure"; - case PipelineCreateFlagBits::eNoProtectedAccess : return "NoProtectedAccess"; - case PipelineCreateFlagBits::eProtectedAccessOnly : return "ProtectedAccessOnly"; - case PipelineCreateFlagBits::eRayTracingNoNullAnyHitShadersKHR : return "RayTracingNoNullAnyHitShadersKHR"; - case PipelineCreateFlagBits::eRayTracingNoNullClosestHitShadersKHR : return "RayTracingNoNullClosestHitShadersKHR"; - case PipelineCreateFlagBits::eRayTracingNoNullMissShadersKHR : return "RayTracingNoNullMissShadersKHR"; - case PipelineCreateFlagBits::eRayTracingNoNullIntersectionShadersKHR : return "RayTracingNoNullIntersectionShadersKHR"; - case PipelineCreateFlagBits::eRayTracingSkipTrianglesKHR : return "RayTracingSkipTrianglesKHR"; - case PipelineCreateFlagBits::eRayTracingSkipAabbsKHR : return "RayTracingSkipAabbsKHR"; - case PipelineCreateFlagBits::eRayTracingShaderGroupHandleCaptureReplayKHR: return "RayTracingShaderGroupHandleCaptureReplayKHR"; - case PipelineCreateFlagBits::eDeferCompileNV : return "DeferCompileNV"; - case PipelineCreateFlagBits::eRenderingFragmentDensityMapAttachmentEXT : return "RenderingFragmentDensityMapAttachmentEXT"; - case PipelineCreateFlagBits::eRenderingFragmentShadingRateAttachmentKHR : return "RenderingFragmentShadingRateAttachmentKHR"; - case PipelineCreateFlagBits::eCaptureStatisticsKHR : return "CaptureStatisticsKHR"; - case PipelineCreateFlagBits::eCaptureInternalRepresentationsKHR : return "CaptureInternalRepresentationsKHR"; - case PipelineCreateFlagBits::eIndirectBindableNV : return "IndirectBindableNV"; - case PipelineCreateFlagBits::eLibraryKHR : return "LibraryKHR"; - case PipelineCreateFlagBits::eDescriptorBufferEXT : return "DescriptorBufferEXT"; - case PipelineCreateFlagBits::eRetainLinkTimeOptimizationInfoEXT : return "RetainLinkTimeOptimizationInfoEXT"; - case PipelineCreateFlagBits::eLinkTimeOptimizationEXT : return "LinkTimeOptimizationEXT"; - case PipelineCreateFlagBits::eRayTracingAllowMotionNV : return "RayTracingAllowMotionNV"; - case PipelineCreateFlagBits::eColorAttachmentFeedbackLoopEXT : return "ColorAttachmentFeedbackLoopEXT"; - case PipelineCreateFlagBits::eDepthStencilAttachmentFeedbackLoopEXT : return "DepthStencilAttachmentFeedbackLoopEXT"; - case PipelineCreateFlagBits::eRayTracingOpacityMicromapEXT : return "RayTracingOpacityMicromapEXT"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case PipelineCreateFlagBits::eRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineShaderStageCreateFlagBits value ) - { - switch ( value ) - { - case PipelineShaderStageCreateFlagBits::eAllowVaryingSubgroupSize: return "AllowVaryingSubgroupSize"; - case PipelineShaderStageCreateFlagBits::eRequireFullSubgroups : return "RequireFullSubgroups"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderStageFlagBits value ) - { - switch ( value ) - { - case ShaderStageFlagBits::eVertex : return "Vertex"; - case ShaderStageFlagBits::eTessellationControl : return "TessellationControl"; - case ShaderStageFlagBits::eTessellationEvaluation: return "TessellationEvaluation"; - case ShaderStageFlagBits::eGeometry : return "Geometry"; - case ShaderStageFlagBits::eFragment : return "Fragment"; - case ShaderStageFlagBits::eCompute : return "Compute"; - case ShaderStageFlagBits::eAllGraphics : return "AllGraphics"; - case ShaderStageFlagBits::eAll : return "All"; - case ShaderStageFlagBits::eRaygenKHR : return "RaygenKHR"; - case ShaderStageFlagBits::eAnyHitKHR : return "AnyHitKHR"; - case ShaderStageFlagBits::eClosestHitKHR : return "ClosestHitKHR"; - case ShaderStageFlagBits::eMissKHR : return "MissKHR"; - case ShaderStageFlagBits::eIntersectionKHR : return "IntersectionKHR"; - case ShaderStageFlagBits::eCallableKHR : return "CallableKHR"; - case ShaderStageFlagBits::eTaskEXT : return "TaskEXT"; - case ShaderStageFlagBits::eMeshEXT : return "MeshEXT"; - case ShaderStageFlagBits::eSubpassShadingHUAWEI : return "SubpassShadingHUAWEI"; - case ShaderStageFlagBits::eClusterCullingHUAWEI : return "ClusterCullingHUAWEI"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineLayoutCreateFlagBits value ) - { - switch ( value ) - { - case PipelineLayoutCreateFlagBits::eIndependentSetsEXT: return "IndependentSetsEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BorderColor value ) - { - switch ( value ) - { - case BorderColor::eFloatTransparentBlack: return "FloatTransparentBlack"; - case BorderColor::eIntTransparentBlack : return "IntTransparentBlack"; - case BorderColor::eFloatOpaqueBlack : return "FloatOpaqueBlack"; - case BorderColor::eIntOpaqueBlack : return "IntOpaqueBlack"; - case BorderColor::eFloatOpaqueWhite : return "FloatOpaqueWhite"; - case BorderColor::eIntOpaqueWhite : return "IntOpaqueWhite"; - case BorderColor::eFloatCustomEXT : return "FloatCustomEXT"; - case BorderColor::eIntCustomEXT : return "IntCustomEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Filter value ) - { - switch ( value ) - { - case Filter::eNearest : return "Nearest"; - case Filter::eLinear : return "Linear"; - case Filter::eCubicEXT: return "CubicEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerAddressMode value ) - { - switch ( value ) - { - case SamplerAddressMode::eRepeat : return "Repeat"; - case SamplerAddressMode::eMirroredRepeat : return "MirroredRepeat"; - case SamplerAddressMode::eClampToEdge : return "ClampToEdge"; - case SamplerAddressMode::eClampToBorder : return "ClampToBorder"; - case SamplerAddressMode::eMirrorClampToEdge: return "MirrorClampToEdge"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerCreateFlagBits value ) - { - switch ( value ) - { - case SamplerCreateFlagBits::eSubsampledEXT : return "SubsampledEXT"; - case SamplerCreateFlagBits::eSubsampledCoarseReconstructionEXT: return "SubsampledCoarseReconstructionEXT"; - case SamplerCreateFlagBits::eDescriptorBufferCaptureReplayEXT : return "DescriptorBufferCaptureReplayEXT"; - case SamplerCreateFlagBits::eNonSeamlessCubeMapEXT : return "NonSeamlessCubeMapEXT"; - case SamplerCreateFlagBits::eImageProcessingQCOM : return "ImageProcessingQCOM"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerMipmapMode value ) - { - switch ( value ) - { - case SamplerMipmapMode::eNearest: return "Nearest"; - case SamplerMipmapMode::eLinear : return "Linear"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorPoolCreateFlagBits value ) - { - switch ( value ) - { - case DescriptorPoolCreateFlagBits::eFreeDescriptorSet : return "FreeDescriptorSet"; - case DescriptorPoolCreateFlagBits::eUpdateAfterBind : return "UpdateAfterBind"; - case DescriptorPoolCreateFlagBits::eHostOnlyEXT : return "HostOnlyEXT"; - case DescriptorPoolCreateFlagBits::eAllowOverallocationSetsNV : return "AllowOverallocationSetsNV"; - case DescriptorPoolCreateFlagBits::eAllowOverallocationPoolsNV: return "AllowOverallocationPoolsNV"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorSetLayoutCreateFlagBits value ) - { - switch ( value ) - { - case DescriptorSetLayoutCreateFlagBits::eUpdateAfterBindPool : return "UpdateAfterBindPool"; - case DescriptorSetLayoutCreateFlagBits::ePushDescriptor : return "PushDescriptor"; - case DescriptorSetLayoutCreateFlagBits::eDescriptorBufferEXT : return "DescriptorBufferEXT"; - case DescriptorSetLayoutCreateFlagBits::eEmbeddedImmutableSamplersEXT: return "EmbeddedImmutableSamplersEXT"; - case DescriptorSetLayoutCreateFlagBits::eIndirectBindableNV : return "IndirectBindableNV"; - case DescriptorSetLayoutCreateFlagBits::eHostOnlyPoolEXT : return "HostOnlyPoolEXT"; - case DescriptorSetLayoutCreateFlagBits::ePerStageNV : return "PerStageNV"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorType value ) - { - switch ( value ) - { - case DescriptorType::eSampler : return "Sampler"; - case DescriptorType::eCombinedImageSampler : return "CombinedImageSampler"; - case DescriptorType::eSampledImage : return "SampledImage"; - case DescriptorType::eStorageImage : return "StorageImage"; - case DescriptorType::eUniformTexelBuffer : return "UniformTexelBuffer"; - case DescriptorType::eStorageTexelBuffer : return "StorageTexelBuffer"; - case DescriptorType::eUniformBuffer : return "UniformBuffer"; - case DescriptorType::eStorageBuffer : return "StorageBuffer"; - case DescriptorType::eUniformBufferDynamic : return "UniformBufferDynamic"; - case DescriptorType::eStorageBufferDynamic : return "StorageBufferDynamic"; - case DescriptorType::eInputAttachment : return "InputAttachment"; - case DescriptorType::eInlineUniformBlock : return "InlineUniformBlock"; - case DescriptorType::eAccelerationStructureKHR : return "AccelerationStructureKHR"; - case DescriptorType::eAccelerationStructureNV : return "AccelerationStructureNV"; - case DescriptorType::eSampleWeightImageQCOM : return "SampleWeightImageQCOM"; - case DescriptorType::eBlockMatchImageQCOM : return "BlockMatchImageQCOM"; - case DescriptorType::eTensorARM : return "TensorARM"; - case DescriptorType::eMutableEXT : return "MutableEXT"; - case DescriptorType::ePartitionedAccelerationStructureNV: return "PartitionedAccelerationStructureNV"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorPoolResetFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryPipelineStatisticFlagBits value ) - { - switch ( value ) - { - case QueryPipelineStatisticFlagBits::eInputAssemblyVertices : return "InputAssemblyVertices"; - case QueryPipelineStatisticFlagBits::eInputAssemblyPrimitives : return "InputAssemblyPrimitives"; - case QueryPipelineStatisticFlagBits::eVertexShaderInvocations : return "VertexShaderInvocations"; - case QueryPipelineStatisticFlagBits::eGeometryShaderInvocations : return "GeometryShaderInvocations"; - case QueryPipelineStatisticFlagBits::eGeometryShaderPrimitives : return "GeometryShaderPrimitives"; - case QueryPipelineStatisticFlagBits::eClippingInvocations : return "ClippingInvocations"; - case QueryPipelineStatisticFlagBits::eClippingPrimitives : return "ClippingPrimitives"; - case QueryPipelineStatisticFlagBits::eFragmentShaderInvocations : return "FragmentShaderInvocations"; - case QueryPipelineStatisticFlagBits::eTessellationControlShaderPatches : return "TessellationControlShaderPatches"; - case QueryPipelineStatisticFlagBits::eTessellationEvaluationShaderInvocations: return "TessellationEvaluationShaderInvocations"; - case QueryPipelineStatisticFlagBits::eComputeShaderInvocations : return "ComputeShaderInvocations"; - case QueryPipelineStatisticFlagBits::eTaskShaderInvocationsEXT : return "TaskShaderInvocationsEXT"; - case QueryPipelineStatisticFlagBits::eMeshShaderInvocationsEXT : return "MeshShaderInvocationsEXT"; - case QueryPipelineStatisticFlagBits::eClusterCullingShaderInvocationsHUAWEI : return "ClusterCullingShaderInvocationsHUAWEI"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineBindPoint value ) - { - switch ( value ) - { - case PipelineBindPoint::eGraphics: return "Graphics"; - case PipelineBindPoint::eCompute : return "Compute"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case PipelineBindPoint::eExecutionGraphAMDX: return "ExecutionGraphAMDX"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case PipelineBindPoint::eRayTracingKHR : return "RayTracingKHR"; - case PipelineBindPoint::eSubpassShadingHUAWEI: return "SubpassShadingHUAWEI"; - case PipelineBindPoint::eDataGraphARM : return "DataGraphARM"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlendFactor value ) - { - switch ( value ) - { - case BlendFactor::eZero : return "Zero"; - case BlendFactor::eOne : return "One"; - case BlendFactor::eSrcColor : return "SrcColor"; - case BlendFactor::eOneMinusSrcColor : return "OneMinusSrcColor"; - case BlendFactor::eDstColor : return "DstColor"; - case BlendFactor::eOneMinusDstColor : return "OneMinusDstColor"; - case BlendFactor::eSrcAlpha : return "SrcAlpha"; - case BlendFactor::eOneMinusSrcAlpha : return "OneMinusSrcAlpha"; - case BlendFactor::eDstAlpha : return "DstAlpha"; - case BlendFactor::eOneMinusDstAlpha : return "OneMinusDstAlpha"; - case BlendFactor::eConstantColor : return "ConstantColor"; - case BlendFactor::eOneMinusConstantColor: return "OneMinusConstantColor"; - case BlendFactor::eConstantAlpha : return "ConstantAlpha"; - case BlendFactor::eOneMinusConstantAlpha: return "OneMinusConstantAlpha"; - case BlendFactor::eSrcAlphaSaturate : return "SrcAlphaSaturate"; - case BlendFactor::eSrc1Color : return "Src1Color"; - case BlendFactor::eOneMinusSrc1Color : return "OneMinusSrc1Color"; - case BlendFactor::eSrc1Alpha : return "Src1Alpha"; - case BlendFactor::eOneMinusSrc1Alpha : return "OneMinusSrc1Alpha"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlendOp value ) - { - switch ( value ) - { - case BlendOp::eAdd : return "Add"; - case BlendOp::eSubtract : return "Subtract"; - case BlendOp::eReverseSubtract : return "ReverseSubtract"; - case BlendOp::eMin : return "Min"; - case BlendOp::eMax : return "Max"; - case BlendOp::eZeroEXT : return "ZeroEXT"; - case BlendOp::eSrcEXT : return "SrcEXT"; - case BlendOp::eDstEXT : return "DstEXT"; - case BlendOp::eSrcOverEXT : return "SrcOverEXT"; - case BlendOp::eDstOverEXT : return "DstOverEXT"; - case BlendOp::eSrcInEXT : return "SrcInEXT"; - case BlendOp::eDstInEXT : return "DstInEXT"; - case BlendOp::eSrcOutEXT : return "SrcOutEXT"; - case BlendOp::eDstOutEXT : return "DstOutEXT"; - case BlendOp::eSrcAtopEXT : return "SrcAtopEXT"; - case BlendOp::eDstAtopEXT : return "DstAtopEXT"; - case BlendOp::eXorEXT : return "XorEXT"; - case BlendOp::eMultiplyEXT : return "MultiplyEXT"; - case BlendOp::eScreenEXT : return "ScreenEXT"; - case BlendOp::eOverlayEXT : return "OverlayEXT"; - case BlendOp::eDarkenEXT : return "DarkenEXT"; - case BlendOp::eLightenEXT : return "LightenEXT"; - case BlendOp::eColordodgeEXT : return "ColordodgeEXT"; - case BlendOp::eColorburnEXT : return "ColorburnEXT"; - case BlendOp::eHardlightEXT : return "HardlightEXT"; - case BlendOp::eSoftlightEXT : return "SoftlightEXT"; - case BlendOp::eDifferenceEXT : return "DifferenceEXT"; - case BlendOp::eExclusionEXT : return "ExclusionEXT"; - case BlendOp::eInvertEXT : return "InvertEXT"; - case BlendOp::eInvertRgbEXT : return "InvertRgbEXT"; - case BlendOp::eLineardodgeEXT : return "LineardodgeEXT"; - case BlendOp::eLinearburnEXT : return "LinearburnEXT"; - case BlendOp::eVividlightEXT : return "VividlightEXT"; - case BlendOp::eLinearlightEXT : return "LinearlightEXT"; - case BlendOp::ePinlightEXT : return "PinlightEXT"; - case BlendOp::eHardmixEXT : return "HardmixEXT"; - case BlendOp::eHslHueEXT : return "HslHueEXT"; - case BlendOp::eHslSaturationEXT : return "HslSaturationEXT"; - case BlendOp::eHslColorEXT : return "HslColorEXT"; - case BlendOp::eHslLuminosityEXT : return "HslLuminosityEXT"; - case BlendOp::ePlusEXT : return "PlusEXT"; - case BlendOp::ePlusClampedEXT : return "PlusClampedEXT"; - case BlendOp::ePlusClampedAlphaEXT: return "PlusClampedAlphaEXT"; - case BlendOp::ePlusDarkerEXT : return "PlusDarkerEXT"; - case BlendOp::eMinusEXT : return "MinusEXT"; - case BlendOp::eMinusClampedEXT : return "MinusClampedEXT"; - case BlendOp::eContrastEXT : return "ContrastEXT"; - case BlendOp::eInvertOvgEXT : return "InvertOvgEXT"; - case BlendOp::eRedEXT : return "RedEXT"; - case BlendOp::eGreenEXT : return "GreenEXT"; - case BlendOp::eBlueEXT : return "BlueEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ColorComponentFlagBits value ) - { - switch ( value ) - { - case ColorComponentFlagBits::eR: return "R"; - case ColorComponentFlagBits::eG: return "G"; - case ColorComponentFlagBits::eB: return "B"; - case ColorComponentFlagBits::eA: return "A"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CompareOp value ) - { - switch ( value ) - { - case CompareOp::eNever : return "Never"; - case CompareOp::eLess : return "Less"; - case CompareOp::eEqual : return "Equal"; - case CompareOp::eLessOrEqual : return "LessOrEqual"; - case CompareOp::eGreater : return "Greater"; - case CompareOp::eNotEqual : return "NotEqual"; - case CompareOp::eGreaterOrEqual: return "GreaterOrEqual"; - case CompareOp::eAlways : return "Always"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CullModeFlagBits value ) - { - switch ( value ) - { - case CullModeFlagBits::eNone : return "None"; - case CullModeFlagBits::eFront : return "Front"; - case CullModeFlagBits::eBack : return "Back"; - case CullModeFlagBits::eFrontAndBack: return "FrontAndBack"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DynamicState value ) - { - switch ( value ) - { - case DynamicState::eViewport : return "Viewport"; - case DynamicState::eScissor : return "Scissor"; - case DynamicState::eLineWidth : return "LineWidth"; - case DynamicState::eDepthBias : return "DepthBias"; - case DynamicState::eBlendConstants : return "BlendConstants"; - case DynamicState::eDepthBounds : return "DepthBounds"; - case DynamicState::eStencilCompareMask : return "StencilCompareMask"; - case DynamicState::eStencilWriteMask : return "StencilWriteMask"; - case DynamicState::eStencilReference : return "StencilReference"; - case DynamicState::eCullMode : return "CullMode"; - case DynamicState::eFrontFace : return "FrontFace"; - case DynamicState::ePrimitiveTopology : return "PrimitiveTopology"; - case DynamicState::eViewportWithCount : return "ViewportWithCount"; - case DynamicState::eScissorWithCount : return "ScissorWithCount"; - case DynamicState::eVertexInputBindingStride : return "VertexInputBindingStride"; - case DynamicState::eDepthTestEnable : return "DepthTestEnable"; - case DynamicState::eDepthWriteEnable : return "DepthWriteEnable"; - case DynamicState::eDepthCompareOp : return "DepthCompareOp"; - case DynamicState::eDepthBoundsTestEnable : return "DepthBoundsTestEnable"; - case DynamicState::eStencilTestEnable : return "StencilTestEnable"; - case DynamicState::eStencilOp : return "StencilOp"; - case DynamicState::eRasterizerDiscardEnable : return "RasterizerDiscardEnable"; - case DynamicState::eDepthBiasEnable : return "DepthBiasEnable"; - case DynamicState::ePrimitiveRestartEnable : return "PrimitiveRestartEnable"; - case DynamicState::eLineStipple : return "LineStipple"; - case DynamicState::eViewportWScalingNV : return "ViewportWScalingNV"; - case DynamicState::eDiscardRectangleEXT : return "DiscardRectangleEXT"; - case DynamicState::eDiscardRectangleEnableEXT : return "DiscardRectangleEnableEXT"; - case DynamicState::eDiscardRectangleModeEXT : return "DiscardRectangleModeEXT"; - case DynamicState::eSampleLocationsEXT : return "SampleLocationsEXT"; - case DynamicState::eRayTracingPipelineStackSizeKHR : return "RayTracingPipelineStackSizeKHR"; - case DynamicState::eViewportShadingRatePaletteNV : return "ViewportShadingRatePaletteNV"; - case DynamicState::eViewportCoarseSampleOrderNV : return "ViewportCoarseSampleOrderNV"; - case DynamicState::eExclusiveScissorEnableNV : return "ExclusiveScissorEnableNV"; - case DynamicState::eExclusiveScissorNV : return "ExclusiveScissorNV"; - case DynamicState::eFragmentShadingRateKHR : return "FragmentShadingRateKHR"; - case DynamicState::eVertexInputEXT : return "VertexInputEXT"; - case DynamicState::ePatchControlPointsEXT : return "PatchControlPointsEXT"; - case DynamicState::eLogicOpEXT : return "LogicOpEXT"; - case DynamicState::eColorWriteEnableEXT : return "ColorWriteEnableEXT"; - case DynamicState::eDepthClampEnableEXT : return "DepthClampEnableEXT"; - case DynamicState::ePolygonModeEXT : return "PolygonModeEXT"; - case DynamicState::eRasterizationSamplesEXT : return "RasterizationSamplesEXT"; - case DynamicState::eSampleMaskEXT : return "SampleMaskEXT"; - case DynamicState::eAlphaToCoverageEnableEXT : return "AlphaToCoverageEnableEXT"; - case DynamicState::eAlphaToOneEnableEXT : return "AlphaToOneEnableEXT"; - case DynamicState::eLogicOpEnableEXT : return "LogicOpEnableEXT"; - case DynamicState::eColorBlendEnableEXT : return "ColorBlendEnableEXT"; - case DynamicState::eColorBlendEquationEXT : return "ColorBlendEquationEXT"; - case DynamicState::eColorWriteMaskEXT : return "ColorWriteMaskEXT"; - case DynamicState::eTessellationDomainOriginEXT : return "TessellationDomainOriginEXT"; - case DynamicState::eRasterizationStreamEXT : return "RasterizationStreamEXT"; - case DynamicState::eConservativeRasterizationModeEXT : return "ConservativeRasterizationModeEXT"; - case DynamicState::eExtraPrimitiveOverestimationSizeEXT: return "ExtraPrimitiveOverestimationSizeEXT"; - case DynamicState::eDepthClipEnableEXT : return "DepthClipEnableEXT"; - case DynamicState::eSampleLocationsEnableEXT : return "SampleLocationsEnableEXT"; - case DynamicState::eColorBlendAdvancedEXT : return "ColorBlendAdvancedEXT"; - case DynamicState::eProvokingVertexModeEXT : return "ProvokingVertexModeEXT"; - case DynamicState::eLineRasterizationModeEXT : return "LineRasterizationModeEXT"; - case DynamicState::eLineStippleEnableEXT : return "LineStippleEnableEXT"; - case DynamicState::eDepthClipNegativeOneToOneEXT : return "DepthClipNegativeOneToOneEXT"; - case DynamicState::eViewportWScalingEnableNV : return "ViewportWScalingEnableNV"; - case DynamicState::eViewportSwizzleNV : return "ViewportSwizzleNV"; - case DynamicState::eCoverageToColorEnableNV : return "CoverageToColorEnableNV"; - case DynamicState::eCoverageToColorLocationNV : return "CoverageToColorLocationNV"; - case DynamicState::eCoverageModulationModeNV : return "CoverageModulationModeNV"; - case DynamicState::eCoverageModulationTableEnableNV : return "CoverageModulationTableEnableNV"; - case DynamicState::eCoverageModulationTableNV : return "CoverageModulationTableNV"; - case DynamicState::eShadingRateImageEnableNV : return "ShadingRateImageEnableNV"; - case DynamicState::eRepresentativeFragmentTestEnableNV : return "RepresentativeFragmentTestEnableNV"; - case DynamicState::eCoverageReductionModeNV : return "CoverageReductionModeNV"; - case DynamicState::eAttachmentFeedbackLoopEnableEXT : return "AttachmentFeedbackLoopEnableEXT"; - case DynamicState::eDepthClampRangeEXT : return "DepthClampRangeEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FrontFace value ) - { - switch ( value ) - { - case FrontFace::eCounterClockwise: return "CounterClockwise"; - case FrontFace::eClockwise : return "Clockwise"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LogicOp value ) - { - switch ( value ) - { - case LogicOp::eClear : return "Clear"; - case LogicOp::eAnd : return "And"; - case LogicOp::eAndReverse : return "AndReverse"; - case LogicOp::eCopy : return "Copy"; - case LogicOp::eAndInverted : return "AndInverted"; - case LogicOp::eNoOp : return "NoOp"; - case LogicOp::eXor : return "Xor"; - case LogicOp::eOr : return "Or"; - case LogicOp::eNor : return "Nor"; - case LogicOp::eEquivalent : return "Equivalent"; - case LogicOp::eInvert : return "Invert"; - case LogicOp::eOrReverse : return "OrReverse"; - case LogicOp::eCopyInverted: return "CopyInverted"; - case LogicOp::eOrInverted : return "OrInverted"; - case LogicOp::eNand : return "Nand"; - case LogicOp::eSet : return "Set"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PolygonMode value ) - { - switch ( value ) - { - case PolygonMode::eFill : return "Fill"; - case PolygonMode::eLine : return "Line"; - case PolygonMode::ePoint : return "Point"; - case PolygonMode::eFillRectangleNV: return "FillRectangleNV"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrimitiveTopology value ) - { - switch ( value ) - { - case PrimitiveTopology::ePointList : return "PointList"; - case PrimitiveTopology::eLineList : return "LineList"; - case PrimitiveTopology::eLineStrip : return "LineStrip"; - case PrimitiveTopology::eTriangleList : return "TriangleList"; - case PrimitiveTopology::eTriangleStrip : return "TriangleStrip"; - case PrimitiveTopology::eTriangleFan : return "TriangleFan"; - case PrimitiveTopology::eLineListWithAdjacency : return "LineListWithAdjacency"; - case PrimitiveTopology::eLineStripWithAdjacency : return "LineStripWithAdjacency"; - case PrimitiveTopology::eTriangleListWithAdjacency : return "TriangleListWithAdjacency"; - case PrimitiveTopology::eTriangleStripWithAdjacency: return "TriangleStripWithAdjacency"; - case PrimitiveTopology::ePatchList : return "PatchList"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StencilOp value ) - { - switch ( value ) - { - case StencilOp::eKeep : return "Keep"; - case StencilOp::eZero : return "Zero"; - case StencilOp::eReplace : return "Replace"; - case StencilOp::eIncrementAndClamp: return "IncrementAndClamp"; - case StencilOp::eDecrementAndClamp: return "DecrementAndClamp"; - case StencilOp::eInvert : return "Invert"; - case StencilOp::eIncrementAndWrap : return "IncrementAndWrap"; - case StencilOp::eDecrementAndWrap : return "DecrementAndWrap"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VertexInputRate value ) - { - switch ( value ) - { - case VertexInputRate::eVertex : return "Vertex"; - case VertexInputRate::eInstance: return "Instance"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineColorBlendStateCreateFlagBits value ) - { - switch ( value ) - { - case PipelineColorBlendStateCreateFlagBits::eRasterizationOrderAttachmentAccessEXT: return "RasterizationOrderAttachmentAccessEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDepthStencilStateCreateFlagBits value ) - { - switch ( value ) - { - case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentDepthAccessEXT : return "RasterizationOrderAttachmentDepthAccessEXT"; - case PipelineDepthStencilStateCreateFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDynamicStateCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineInputAssemblyStateCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineMultisampleStateCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineTessellationStateCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineVertexInputStateCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportStateCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AttachmentDescriptionFlagBits value ) - { - switch ( value ) - { - case AttachmentDescriptionFlagBits::eMayAlias : return "MayAlias"; - case AttachmentDescriptionFlagBits::eResolveSkipTransferFunctionKHR : return "ResolveSkipTransferFunctionKHR"; - case AttachmentDescriptionFlagBits::eResolveEnableTransferFunctionKHR: return "ResolveEnableTransferFunctionKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AttachmentLoadOp value ) - { - switch ( value ) - { - case AttachmentLoadOp::eLoad : return "Load"; - case AttachmentLoadOp::eClear : return "Clear"; - case AttachmentLoadOp::eDontCare: return "DontCare"; - case AttachmentLoadOp::eNone : return "None"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AttachmentStoreOp value ) - { - switch ( value ) - { - case AttachmentStoreOp::eStore : return "Store"; - case AttachmentStoreOp::eDontCare: return "DontCare"; - case AttachmentStoreOp::eNone : return "None"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FramebufferCreateFlagBits value ) - { - switch ( value ) - { - case FramebufferCreateFlagBits::eImageless: return "Imageless"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderPassCreateFlagBits value ) - { - switch ( value ) - { - case RenderPassCreateFlagBits::eTransformQCOM : return "TransformQCOM"; - case RenderPassCreateFlagBits::ePerLayerFragmentDensityVALVE: return "PerLayerFragmentDensityVALVE"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubpassDescriptionFlagBits value ) - { - switch ( value ) - { - case SubpassDescriptionFlagBits::ePerViewAttributesNVX : return "PerViewAttributesNVX"; - case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX : return "PerViewPositionXOnlyNVX"; - case SubpassDescriptionFlagBits::eTileShadingApronQCOM : return "TileShadingApronQCOM"; - case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT : return "RasterizationOrderAttachmentColorAccessEXT"; - case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT : return "RasterizationOrderAttachmentDepthAccessEXT"; - case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT"; - case SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT : return "EnableLegacyDitheringEXT"; - case SubpassDescriptionFlagBits::eFragmentRegionEXT : return "FragmentRegionEXT"; - case SubpassDescriptionFlagBits::eCustomResolveEXT : return "CustomResolveEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StencilFaceFlagBits value ) - { - switch ( value ) - { - case StencilFaceFlagBits::eFront : return "Front"; - case StencilFaceFlagBits::eBack : return "Back"; - case StencilFaceFlagBits::eFrontAndBack: return "FrontAndBack"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubpassContents value ) - { - switch ( value ) - { - case SubpassContents::eInline : return "Inline"; - case SubpassContents::eSecondaryCommandBuffers : return "SecondaryCommandBuffers"; - case SubpassContents::eInlineAndSecondaryCommandBuffersKHR: return "InlineAndSecondaryCommandBuffersKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_VERSION_1_1 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PeerMemoryFeatureFlagBits value ) - { - switch ( value ) - { - case PeerMemoryFeatureFlagBits::eCopySrc : return "CopySrc"; - case PeerMemoryFeatureFlagBits::eCopyDst : return "CopyDst"; - case PeerMemoryFeatureFlagBits::eGenericSrc: return "GenericSrc"; - case PeerMemoryFeatureFlagBits::eGenericDst: return "GenericDst"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryAllocateFlagBits value ) - { - switch ( value ) - { - case MemoryAllocateFlagBits::eDeviceMask : return "DeviceMask"; - case MemoryAllocateFlagBits::eDeviceAddress : return "DeviceAddress"; - case MemoryAllocateFlagBits::eDeviceAddressCaptureReplay: return "DeviceAddressCaptureReplay"; - case MemoryAllocateFlagBits::eZeroInitializeEXT : return "ZeroInitializeEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CommandPoolTrimFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryHandleTypeFlagBits value ) - { - switch ( value ) - { - case ExternalMemoryHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd"; - case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32"; - case ExternalMemoryHandleTypeFlagBits::eOpaqueWin32Kmt : return "OpaqueWin32Kmt"; - case ExternalMemoryHandleTypeFlagBits::eD3D11Texture : return "D3D11Texture"; - case ExternalMemoryHandleTypeFlagBits::eD3D11TextureKmt: return "D3D11TextureKmt"; - case ExternalMemoryHandleTypeFlagBits::eD3D12Heap : return "D3D12Heap"; - case ExternalMemoryHandleTypeFlagBits::eD3D12Resource : return "D3D12Resource"; - case ExternalMemoryHandleTypeFlagBits::eDmaBufEXT : return "DmaBufEXT"; -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - case ExternalMemoryHandleTypeFlagBits::eAndroidHardwareBufferANDROID: return "AndroidHardwareBufferANDROID"; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - case ExternalMemoryHandleTypeFlagBits::eHostAllocationEXT : return "HostAllocationEXT"; - case ExternalMemoryHandleTypeFlagBits::eHostMappedForeignMemoryEXT: return "HostMappedForeignMemoryEXT"; -#if defined( VK_USE_PLATFORM_FUCHSIA ) - case ExternalMemoryHandleTypeFlagBits::eZirconVmoFUCHSIA: return "ZirconVmoFUCHSIA"; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - case ExternalMemoryHandleTypeFlagBits::eRdmaAddressNV: return "RdmaAddressNV"; -#if defined( VK_USE_PLATFORM_OHOS ) - case ExternalMemoryHandleTypeFlagBits::eOhNativeBufferOHOS: return "OhNativeBufferOHOS"; -#endif /*VK_USE_PLATFORM_OHOS*/ -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - case ExternalMemoryHandleTypeFlagBits::eScreenBufferQNX: return "ScreenBufferQNX"; -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ -#if defined( VK_USE_PLATFORM_METAL_EXT ) - case ExternalMemoryHandleTypeFlagBits::eMtlbufferEXT : return "MtlbufferEXT"; - case ExternalMemoryHandleTypeFlagBits::eMtltextureEXT: return "MtltextureEXT"; - case ExternalMemoryHandleTypeFlagBits::eMtlheapEXT : return "MtlheapEXT"; -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryFeatureFlagBits value ) - { - switch ( value ) - { - case ExternalMemoryFeatureFlagBits::eDedicatedOnly: return "DedicatedOnly"; - case ExternalMemoryFeatureFlagBits::eExportable : return "Exportable"; - case ExternalMemoryFeatureFlagBits::eImportable : return "Importable"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalFenceHandleTypeFlagBits value ) - { - switch ( value ) - { - case ExternalFenceHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd"; - case ExternalFenceHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32"; - case ExternalFenceHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalFenceHandleTypeFlagBits::eSyncFd : return "SyncFd"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalFenceFeatureFlagBits value ) - { - switch ( value ) - { - case ExternalFenceFeatureFlagBits::eExportable: return "Exportable"; - case ExternalFenceFeatureFlagBits::eImportable: return "Importable"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FenceImportFlagBits value ) - { - switch ( value ) - { - case FenceImportFlagBits::eTemporary: return "Temporary"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreImportFlagBits value ) - { - switch ( value ) - { - case SemaphoreImportFlagBits::eTemporary: return "Temporary"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalSemaphoreHandleTypeFlagBits value ) - { - switch ( value ) - { - case ExternalSemaphoreHandleTypeFlagBits::eOpaqueFd : return "OpaqueFd"; - case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32 : return "OpaqueWin32"; - case ExternalSemaphoreHandleTypeFlagBits::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalSemaphoreHandleTypeFlagBits::eD3D12Fence : return "D3D12Fence"; - case ExternalSemaphoreHandleTypeFlagBits::eSyncFd : return "SyncFd"; -#if defined( VK_USE_PLATFORM_FUCHSIA ) - case ExternalSemaphoreHandleTypeFlagBits::eZirconEventFUCHSIA: return "ZirconEventFUCHSIA"; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalSemaphoreFeatureFlagBits value ) - { - switch ( value ) - { - case ExternalSemaphoreFeatureFlagBits::eExportable: return "Exportable"; - case ExternalSemaphoreFeatureFlagBits::eImportable: return "Importable"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubgroupFeatureFlagBits value ) - { - switch ( value ) - { - case SubgroupFeatureFlagBits::eBasic : return "Basic"; - case SubgroupFeatureFlagBits::eVote : return "Vote"; - case SubgroupFeatureFlagBits::eArithmetic : return "Arithmetic"; - case SubgroupFeatureFlagBits::eBallot : return "Ballot"; - case SubgroupFeatureFlagBits::eShuffle : return "Shuffle"; - case SubgroupFeatureFlagBits::eShuffleRelative: return "ShuffleRelative"; - case SubgroupFeatureFlagBits::eClustered : return "Clustered"; - case SubgroupFeatureFlagBits::eQuad : return "Quad"; - case SubgroupFeatureFlagBits::eRotate : return "Rotate"; - case SubgroupFeatureFlagBits::eRotateClustered: return "RotateClustered"; - case SubgroupFeatureFlagBits::ePartitionedEXT : return "PartitionedEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorUpdateTemplateType value ) - { - switch ( value ) - { - case DescriptorUpdateTemplateType::eDescriptorSet : return "DescriptorSet"; - case DescriptorUpdateTemplateType::ePushDescriptors: return "PushDescriptors"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorUpdateTemplateCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerYcbcrModelConversion value ) - { - switch ( value ) - { - case SamplerYcbcrModelConversion::eRgbIdentity : return "RgbIdentity"; - case SamplerYcbcrModelConversion::eYcbcrIdentity: return "YcbcrIdentity"; - case SamplerYcbcrModelConversion::eYcbcr709 : return "Ycbcr709"; - case SamplerYcbcrModelConversion::eYcbcr601 : return "Ycbcr601"; - case SamplerYcbcrModelConversion::eYcbcr2020 : return "Ycbcr2020"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerYcbcrRange value ) - { - switch ( value ) - { - case SamplerYcbcrRange::eItuFull : return "ItuFull"; - case SamplerYcbcrRange::eItuNarrow: return "ItuNarrow"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ChromaLocation value ) - { - switch ( value ) - { - case ChromaLocation::eCositedEven: return "CositedEven"; - case ChromaLocation::eMidpoint : return "Midpoint"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PointClippingBehavior value ) - { - switch ( value ) - { - case PointClippingBehavior::eAllClipPlanes : return "AllClipPlanes"; - case PointClippingBehavior::eUserClipPlanesOnly: return "UserClipPlanesOnly"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TessellationDomainOrigin value ) - { - switch ( value ) - { - case TessellationDomainOrigin::eUpperLeft: return "UpperLeft"; - case TessellationDomainOrigin::eLowerLeft: return "LowerLeft"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_VERSION_1_2 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DriverId value ) - { - switch ( value ) - { - case DriverId::eAmdProprietary : return "AmdProprietary"; - case DriverId::eAmdOpenSource : return "AmdOpenSource"; - case DriverId::eMesaRadv : return "MesaRadv"; - case DriverId::eNvidiaProprietary : return "NvidiaProprietary"; - case DriverId::eIntelProprietaryWindows : return "IntelProprietaryWindows"; - case DriverId::eIntelOpenSourceMESA : return "IntelOpenSourceMESA"; - case DriverId::eImaginationProprietary : return "ImaginationProprietary"; - case DriverId::eQualcommProprietary : return "QualcommProprietary"; - case DriverId::eArmProprietary : return "ArmProprietary"; - case DriverId::eGoogleSwiftshader : return "GoogleSwiftshader"; - case DriverId::eGgpProprietary : return "GgpProprietary"; - case DriverId::eBroadcomProprietary : return "BroadcomProprietary"; - case DriverId::eMesaLlvmpipe : return "MesaLlvmpipe"; - case DriverId::eMoltenvk : return "Moltenvk"; - case DriverId::eCoreaviProprietary : return "CoreaviProprietary"; - case DriverId::eJuiceProprietary : return "JuiceProprietary"; - case DriverId::eVerisiliconProprietary : return "VerisiliconProprietary"; - case DriverId::eMesaTurnip : return "MesaTurnip"; - case DriverId::eMesaV3Dv : return "MesaV3Dv"; - case DriverId::eMesaPanvk : return "MesaPanvk"; - case DriverId::eSamsungProprietary : return "SamsungProprietary"; - case DriverId::eMesaVenus : return "MesaVenus"; - case DriverId::eMesaDozen : return "MesaDozen"; - case DriverId::eMesaNvk : return "MesaNvk"; - case DriverId::eImaginationOpenSourceMESA: return "ImaginationOpenSourceMESA"; - case DriverId::eMesaHoneykrisp : return "MesaHoneykrisp"; - case DriverId::eVulkanScEmulationOnVulkan: return "VulkanScEmulationOnVulkan"; - case DriverId::eMesaKosmickrisp : return "MesaKosmickrisp"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreType value ) - { - switch ( value ) - { - case SemaphoreType::eBinary : return "Binary"; - case SemaphoreType::eTimeline: return "Timeline"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SemaphoreWaitFlagBits value ) - { - switch ( value ) - { - case SemaphoreWaitFlagBits::eAny: return "Any"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderFloatControlsIndependence value ) - { - switch ( value ) - { - case ShaderFloatControlsIndependence::e32BitOnly: return "32BitOnly"; - case ShaderFloatControlsIndependence::eAll : return "All"; - case ShaderFloatControlsIndependence::eNone : return "None"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorBindingFlagBits value ) - { - switch ( value ) - { - case DescriptorBindingFlagBits::eUpdateAfterBind : return "UpdateAfterBind"; - case DescriptorBindingFlagBits::eUpdateUnusedWhilePending: return "UpdateUnusedWhilePending"; - case DescriptorBindingFlagBits::ePartiallyBound : return "PartiallyBound"; - case DescriptorBindingFlagBits::eVariableDescriptorCount : return "VariableDescriptorCount"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SamplerReductionMode value ) - { - switch ( value ) - { - case SamplerReductionMode::eWeightedAverage : return "WeightedAverage"; - case SamplerReductionMode::eMin : return "Min"; - case SamplerReductionMode::eMax : return "Max"; - case SamplerReductionMode::eWeightedAverageRangeclampQCOM: return "WeightedAverageRangeclampQCOM"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ResolveModeFlagBits value ) - { - switch ( value ) - { - case ResolveModeFlagBits::eNone : return "None"; - case ResolveModeFlagBits::eSampleZero: return "SampleZero"; - case ResolveModeFlagBits::eAverage : return "Average"; - case ResolveModeFlagBits::eMin : return "Min"; - case ResolveModeFlagBits::eMax : return "Max"; -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - case ResolveModeFlagBits::eExternalFormatDownsampleANDROID: return "ExternalFormatDownsampleANDROID"; -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - case ResolveModeFlagBits::eCustomEXT: return "CustomEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_VERSION_1_3 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ToolPurposeFlagBits value ) - { - switch ( value ) - { - case ToolPurposeFlagBits::eValidation : return "Validation"; - case ToolPurposeFlagBits::eProfiling : return "Profiling"; - case ToolPurposeFlagBits::eTracing : return "Tracing"; - case ToolPurposeFlagBits::eAdditionalFeatures: return "AdditionalFeatures"; - case ToolPurposeFlagBits::eModifyingFeatures : return "ModifyingFeatures"; - case ToolPurposeFlagBits::eDebugReportingEXT : return "DebugReportingEXT"; - case ToolPurposeFlagBits::eDebugMarkersEXT : return "DebugMarkersEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PrivateDataSlotCreateFlagBits ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineStageFlagBits2 value ) - { - switch ( value ) - { - case PipelineStageFlagBits2::eNone : return "None"; - case PipelineStageFlagBits2::eTopOfPipe : return "TopOfPipe"; - case PipelineStageFlagBits2::eDrawIndirect : return "DrawIndirect"; - case PipelineStageFlagBits2::eVertexInput : return "VertexInput"; - case PipelineStageFlagBits2::eVertexShader : return "VertexShader"; - case PipelineStageFlagBits2::eTessellationControlShader : return "TessellationControlShader"; - case PipelineStageFlagBits2::eTessellationEvaluationShader : return "TessellationEvaluationShader"; - case PipelineStageFlagBits2::eGeometryShader : return "GeometryShader"; - case PipelineStageFlagBits2::eFragmentShader : return "FragmentShader"; - case PipelineStageFlagBits2::eEarlyFragmentTests : return "EarlyFragmentTests"; - case PipelineStageFlagBits2::eLateFragmentTests : return "LateFragmentTests"; - case PipelineStageFlagBits2::eColorAttachmentOutput : return "ColorAttachmentOutput"; - case PipelineStageFlagBits2::eComputeShader : return "ComputeShader"; - case PipelineStageFlagBits2::eAllTransfer : return "AllTransfer"; - case PipelineStageFlagBits2::eBottomOfPipe : return "BottomOfPipe"; - case PipelineStageFlagBits2::eHost : return "Host"; - case PipelineStageFlagBits2::eAllGraphics : return "AllGraphics"; - case PipelineStageFlagBits2::eAllCommands : return "AllCommands"; - case PipelineStageFlagBits2::eCopy : return "Copy"; - case PipelineStageFlagBits2::eResolve : return "Resolve"; - case PipelineStageFlagBits2::eBlit : return "Blit"; - case PipelineStageFlagBits2::eClear : return "Clear"; - case PipelineStageFlagBits2::eIndexInput : return "IndexInput"; - case PipelineStageFlagBits2::eVertexAttributeInput : return "VertexAttributeInput"; - case PipelineStageFlagBits2::ePreRasterizationShaders : return "PreRasterizationShaders"; - case PipelineStageFlagBits2::eVideoDecodeKHR : return "VideoDecodeKHR"; - case PipelineStageFlagBits2::eVideoEncodeKHR : return "VideoEncodeKHR"; - case PipelineStageFlagBits2::eTransformFeedbackEXT : return "TransformFeedbackEXT"; - case PipelineStageFlagBits2::eConditionalRenderingEXT : return "ConditionalRenderingEXT"; - case PipelineStageFlagBits2::eCommandPreprocessEXT : return "CommandPreprocessEXT"; - case PipelineStageFlagBits2::eFragmentShadingRateAttachmentKHR: return "FragmentShadingRateAttachmentKHR"; - case PipelineStageFlagBits2::eAccelerationStructureBuildKHR : return "AccelerationStructureBuildKHR"; - case PipelineStageFlagBits2::eRayTracingShaderKHR : return "RayTracingShaderKHR"; - case PipelineStageFlagBits2::eFragmentDensityProcessEXT : return "FragmentDensityProcessEXT"; - case PipelineStageFlagBits2::eTaskShaderEXT : return "TaskShaderEXT"; - case PipelineStageFlagBits2::eMeshShaderEXT : return "MeshShaderEXT"; - case PipelineStageFlagBits2::eSubpassShaderHUAWEI : return "SubpassShaderHUAWEI"; - case PipelineStageFlagBits2::eInvocationMaskHUAWEI : return "InvocationMaskHUAWEI"; - case PipelineStageFlagBits2::eAccelerationStructureCopyKHR : return "AccelerationStructureCopyKHR"; - case PipelineStageFlagBits2::eMicromapBuildEXT : return "MicromapBuildEXT"; - case PipelineStageFlagBits2::eClusterCullingShaderHUAWEI : return "ClusterCullingShaderHUAWEI"; - case PipelineStageFlagBits2::eOpticalFlowNV : return "OpticalFlowNV"; - case PipelineStageFlagBits2::eConvertCooperativeVectorMatrixNV: return "ConvertCooperativeVectorMatrixNV"; - case PipelineStageFlagBits2::eDataGraphARM : return "DataGraphARM"; - case PipelineStageFlagBits2::eCopyIndirectKHR : return "CopyIndirectKHR"; - case PipelineStageFlagBits2::eMemoryDecompressionEXT : return "MemoryDecompressionEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlagBits2 value ) - { - switch ( value ) - { - case AccessFlagBits2::eNone : return "None"; - case AccessFlagBits2::eIndirectCommandRead : return "IndirectCommandRead"; - case AccessFlagBits2::eIndexRead : return "IndexRead"; - case AccessFlagBits2::eVertexAttributeRead : return "VertexAttributeRead"; - case AccessFlagBits2::eUniformRead : return "UniformRead"; - case AccessFlagBits2::eInputAttachmentRead : return "InputAttachmentRead"; - case AccessFlagBits2::eShaderRead : return "ShaderRead"; - case AccessFlagBits2::eShaderWrite : return "ShaderWrite"; - case AccessFlagBits2::eColorAttachmentRead : return "ColorAttachmentRead"; - case AccessFlagBits2::eColorAttachmentWrite : return "ColorAttachmentWrite"; - case AccessFlagBits2::eDepthStencilAttachmentRead : return "DepthStencilAttachmentRead"; - case AccessFlagBits2::eDepthStencilAttachmentWrite : return "DepthStencilAttachmentWrite"; - case AccessFlagBits2::eTransferRead : return "TransferRead"; - case AccessFlagBits2::eTransferWrite : return "TransferWrite"; - case AccessFlagBits2::eHostRead : return "HostRead"; - case AccessFlagBits2::eHostWrite : return "HostWrite"; - case AccessFlagBits2::eMemoryRead : return "MemoryRead"; - case AccessFlagBits2::eMemoryWrite : return "MemoryWrite"; - case AccessFlagBits2::eShaderSampledRead : return "ShaderSampledRead"; - case AccessFlagBits2::eShaderStorageRead : return "ShaderStorageRead"; - case AccessFlagBits2::eShaderStorageWrite : return "ShaderStorageWrite"; - case AccessFlagBits2::eVideoDecodeReadKHR : return "VideoDecodeReadKHR"; - case AccessFlagBits2::eVideoDecodeWriteKHR : return "VideoDecodeWriteKHR"; - case AccessFlagBits2::eSamplerHeapReadEXT : return "SamplerHeapReadEXT"; - case AccessFlagBits2::eResourceHeapReadEXT : return "ResourceHeapReadEXT"; - case AccessFlagBits2::eVideoEncodeReadKHR : return "VideoEncodeReadKHR"; - case AccessFlagBits2::eVideoEncodeWriteKHR : return "VideoEncodeWriteKHR"; - case AccessFlagBits2::eShaderTileAttachmentReadQCOM : return "ShaderTileAttachmentReadQCOM"; - case AccessFlagBits2::eShaderTileAttachmentWriteQCOM : return "ShaderTileAttachmentWriteQCOM"; - case AccessFlagBits2::eTransformFeedbackWriteEXT : return "TransformFeedbackWriteEXT"; - case AccessFlagBits2::eTransformFeedbackCounterReadEXT : return "TransformFeedbackCounterReadEXT"; - case AccessFlagBits2::eTransformFeedbackCounterWriteEXT : return "TransformFeedbackCounterWriteEXT"; - case AccessFlagBits2::eConditionalRenderingReadEXT : return "ConditionalRenderingReadEXT"; - case AccessFlagBits2::eCommandPreprocessReadEXT : return "CommandPreprocessReadEXT"; - case AccessFlagBits2::eCommandPreprocessWriteEXT : return "CommandPreprocessWriteEXT"; - case AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR: return "FragmentShadingRateAttachmentReadKHR"; - case AccessFlagBits2::eAccelerationStructureReadKHR : return "AccelerationStructureReadKHR"; - case AccessFlagBits2::eAccelerationStructureWriteKHR : return "AccelerationStructureWriteKHR"; - case AccessFlagBits2::eFragmentDensityMapReadEXT : return "FragmentDensityMapReadEXT"; - case AccessFlagBits2::eColorAttachmentReadNoncoherentEXT : return "ColorAttachmentReadNoncoherentEXT"; - case AccessFlagBits2::eDescriptorBufferReadEXT : return "DescriptorBufferReadEXT"; - case AccessFlagBits2::eInvocationMaskReadHUAWEI : return "InvocationMaskReadHUAWEI"; - case AccessFlagBits2::eShaderBindingTableReadKHR : return "ShaderBindingTableReadKHR"; - case AccessFlagBits2::eMicromapReadEXT : return "MicromapReadEXT"; - case AccessFlagBits2::eMicromapWriteEXT : return "MicromapWriteEXT"; - case AccessFlagBits2::eOpticalFlowReadNV : return "OpticalFlowReadNV"; - case AccessFlagBits2::eOpticalFlowWriteNV : return "OpticalFlowWriteNV"; - case AccessFlagBits2::eDataGraphReadARM : return "DataGraphReadARM"; - case AccessFlagBits2::eDataGraphWriteARM : return "DataGraphWriteARM"; - case AccessFlagBits2::eMemoryDecompressionReadEXT : return "MemoryDecompressionReadEXT"; - case AccessFlagBits2::eMemoryDecompressionWriteEXT : return "MemoryDecompressionWriteEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubmitFlagBits value ) - { - switch ( value ) - { - case SubmitFlagBits::eProtected: return "Protected"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FormatFeatureFlagBits2 value ) - { - switch ( value ) - { - case FormatFeatureFlagBits2::eSampledImage : return "SampledImage"; - case FormatFeatureFlagBits2::eStorageImage : return "StorageImage"; - case FormatFeatureFlagBits2::eStorageImageAtomic : return "StorageImageAtomic"; - case FormatFeatureFlagBits2::eUniformTexelBuffer : return "UniformTexelBuffer"; - case FormatFeatureFlagBits2::eStorageTexelBuffer : return "StorageTexelBuffer"; - case FormatFeatureFlagBits2::eStorageTexelBufferAtomic : return "StorageTexelBufferAtomic"; - case FormatFeatureFlagBits2::eVertexBuffer : return "VertexBuffer"; - case FormatFeatureFlagBits2::eColorAttachment : return "ColorAttachment"; - case FormatFeatureFlagBits2::eColorAttachmentBlend : return "ColorAttachmentBlend"; - case FormatFeatureFlagBits2::eDepthStencilAttachment : return "DepthStencilAttachment"; - case FormatFeatureFlagBits2::eBlitSrc : return "BlitSrc"; - case FormatFeatureFlagBits2::eBlitDst : return "BlitDst"; - case FormatFeatureFlagBits2::eSampledImageFilterLinear : return "SampledImageFilterLinear"; - case FormatFeatureFlagBits2::eTransferSrc : return "TransferSrc"; - case FormatFeatureFlagBits2::eTransferDst : return "TransferDst"; - case FormatFeatureFlagBits2::eSampledImageFilterMinmax : return "SampledImageFilterMinmax"; - case FormatFeatureFlagBits2::eMidpointChromaSamples : return "MidpointChromaSamples"; - case FormatFeatureFlagBits2::eSampledImageYcbcrConversionLinearFilter : return "SampledImageYcbcrConversionLinearFilter"; - case FormatFeatureFlagBits2::eSampledImageYcbcrConversionSeparateReconstructionFilter: return "SampledImageYcbcrConversionSeparateReconstructionFilter"; - case FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicit: return "SampledImageYcbcrConversionChromaReconstructionExplicit"; - case FormatFeatureFlagBits2::eSampledImageYcbcrConversionChromaReconstructionExplicitForceable: - return "SampledImageYcbcrConversionChromaReconstructionExplicitForceable"; - case FormatFeatureFlagBits2::eDisjoint : return "Disjoint"; - case FormatFeatureFlagBits2::eCositedChromaSamples : return "CositedChromaSamples"; - case FormatFeatureFlagBits2::eStorageReadWithoutFormat : return "StorageReadWithoutFormat"; - case FormatFeatureFlagBits2::eStorageWriteWithoutFormat : return "StorageWriteWithoutFormat"; - case FormatFeatureFlagBits2::eSampledImageDepthComparison : return "SampledImageDepthComparison"; - case FormatFeatureFlagBits2::eSampledImageFilterCubic : return "SampledImageFilterCubic"; - case FormatFeatureFlagBits2::eHostImageTransfer : return "HostImageTransfer"; - case FormatFeatureFlagBits2::eVideoDecodeOutputKHR : return "VideoDecodeOutputKHR"; - case FormatFeatureFlagBits2::eVideoDecodeDpbKHR : return "VideoDecodeDpbKHR"; - case FormatFeatureFlagBits2::eAccelerationStructureVertexBufferKHR: return "AccelerationStructureVertexBufferKHR"; - case FormatFeatureFlagBits2::eFragmentDensityMapEXT : return "FragmentDensityMapEXT"; - case FormatFeatureFlagBits2::eFragmentShadingRateAttachmentKHR : return "FragmentShadingRateAttachmentKHR"; - case FormatFeatureFlagBits2::eVideoEncodeInputKHR : return "VideoEncodeInputKHR"; - case FormatFeatureFlagBits2::eVideoEncodeDpbKHR : return "VideoEncodeDpbKHR"; - case FormatFeatureFlagBits2::eAccelerationStructureRadiusBufferNV : return "AccelerationStructureRadiusBufferNV"; - case FormatFeatureFlagBits2::eLinearColorAttachmentNV : return "LinearColorAttachmentNV"; - case FormatFeatureFlagBits2::eWeightImageQCOM : return "WeightImageQCOM"; - case FormatFeatureFlagBits2::eWeightSampledImageQCOM : return "WeightSampledImageQCOM"; - case FormatFeatureFlagBits2::eBlockMatchingQCOM : return "BlockMatchingQCOM"; - case FormatFeatureFlagBits2::eBoxFilterSampledQCOM : return "BoxFilterSampledQCOM"; - case FormatFeatureFlagBits2::eTensorShaderARM : return "TensorShaderARM"; - case FormatFeatureFlagBits2::eTensorImageAliasingARM : return "TensorImageAliasingARM"; - case FormatFeatureFlagBits2::eOpticalFlowImageNV : return "OpticalFlowImageNV"; - case FormatFeatureFlagBits2::eOpticalFlowVectorNV : return "OpticalFlowVectorNV"; - case FormatFeatureFlagBits2::eOpticalFlowCostNV : return "OpticalFlowCostNV"; - case FormatFeatureFlagBits2::eTensorDataGraphARM : return "TensorDataGraphARM"; - case FormatFeatureFlagBits2::eCopyImageIndirectDstKHR : return "CopyImageIndirectDstKHR"; - case FormatFeatureFlagBits2::eVideoEncodeQuantizationDeltaMapKHR : return "VideoEncodeQuantizationDeltaMapKHR"; - case FormatFeatureFlagBits2::eVideoEncodeEmphasisMapKHR : return "VideoEncodeEmphasisMapKHR"; - case FormatFeatureFlagBits2::eDepthCopyOnComputeQueueKHR : return "DepthCopyOnComputeQueueKHR"; - case FormatFeatureFlagBits2::eDepthCopyOnTransferQueueKHR : return "DepthCopyOnTransferQueueKHR"; - case FormatFeatureFlagBits2::eStencilCopyOnComputeQueueKHR : return "StencilCopyOnComputeQueueKHR"; - case FormatFeatureFlagBits2::eStencilCopyOnTransferQueueKHR : return "StencilCopyOnTransferQueueKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCreationFeedbackFlagBits value ) - { - switch ( value ) - { - case PipelineCreationFeedbackFlagBits::eValid : return "Valid"; - case PipelineCreationFeedbackFlagBits::eApplicationPipelineCacheHit: return "ApplicationPipelineCacheHit"; - case PipelineCreationFeedbackFlagBits::eBasePipelineAcceleration : return "BasePipelineAcceleration"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderingFlagBits value ) - { - switch ( value ) - { - case RenderingFlagBits::eContentsSecondaryCommandBuffers : return "ContentsSecondaryCommandBuffers"; - case RenderingFlagBits::eSuspending : return "Suspending"; - case RenderingFlagBits::eResuming : return "Resuming"; - case RenderingFlagBits::eEnableLegacyDitheringEXT : return "EnableLegacyDitheringEXT"; - case RenderingFlagBits::eContentsInlineKHR : return "ContentsInlineKHR"; - case RenderingFlagBits::ePerLayerFragmentDensityVALVE : return "PerLayerFragmentDensityVALVE"; - case RenderingFlagBits::eFragmentRegionEXT : return "FragmentRegionEXT"; - case RenderingFlagBits::eCustomResolveEXT : return "CustomResolveEXT"; - case RenderingFlagBits::eLocalReadConcurrentAccessControlKHR: return "LocalReadConcurrentAccessControlKHR"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_VERSION_1_4 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueueGlobalPriority value ) - { - switch ( value ) - { - case QueueGlobalPriority::eLow : return "Low"; - case QueueGlobalPriority::eMedium : return "Medium"; - case QueueGlobalPriority::eHigh : return "High"; - case QueueGlobalPriority::eRealtime: return "Realtime"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryUnmapFlagBits value ) - { - switch ( value ) - { - case MemoryUnmapFlagBits::eReserveEXT: return "ReserveEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BufferUsageFlagBits2 value ) - { - switch ( value ) - { - case BufferUsageFlagBits2::eTransferSrc : return "TransferSrc"; - case BufferUsageFlagBits2::eTransferDst : return "TransferDst"; - case BufferUsageFlagBits2::eUniformTexelBuffer : return "UniformTexelBuffer"; - case BufferUsageFlagBits2::eStorageTexelBuffer : return "StorageTexelBuffer"; - case BufferUsageFlagBits2::eUniformBuffer : return "UniformBuffer"; - case BufferUsageFlagBits2::eStorageBuffer : return "StorageBuffer"; - case BufferUsageFlagBits2::eIndexBuffer : return "IndexBuffer"; - case BufferUsageFlagBits2::eVertexBuffer : return "VertexBuffer"; - case BufferUsageFlagBits2::eIndirectBuffer : return "IndirectBuffer"; - case BufferUsageFlagBits2::eShaderDeviceAddress: return "ShaderDeviceAddress"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case BufferUsageFlagBits2::eExecutionGraphScratchAMDX: return "ExecutionGraphScratchAMDX"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case BufferUsageFlagBits2::eDescriptorHeapEXT : return "DescriptorHeapEXT"; - case BufferUsageFlagBits2::eConditionalRenderingEXT : return "ConditionalRenderingEXT"; - case BufferUsageFlagBits2::eShaderBindingTableKHR : return "ShaderBindingTableKHR"; - case BufferUsageFlagBits2::eTransformFeedbackBufferEXT : return "TransformFeedbackBufferEXT"; - case BufferUsageFlagBits2::eTransformFeedbackCounterBufferEXT : return "TransformFeedbackCounterBufferEXT"; - case BufferUsageFlagBits2::eVideoDecodeSrcKHR : return "VideoDecodeSrcKHR"; - case BufferUsageFlagBits2::eVideoDecodeDstKHR : return "VideoDecodeDstKHR"; - case BufferUsageFlagBits2::eVideoEncodeDstKHR : return "VideoEncodeDstKHR"; - case BufferUsageFlagBits2::eVideoEncodeSrcKHR : return "VideoEncodeSrcKHR"; - case BufferUsageFlagBits2::eAccelerationStructureBuildInputReadOnlyKHR: return "AccelerationStructureBuildInputReadOnlyKHR"; - case BufferUsageFlagBits2::eAccelerationStructureStorageKHR : return "AccelerationStructureStorageKHR"; - case BufferUsageFlagBits2::eSamplerDescriptorBufferEXT : return "SamplerDescriptorBufferEXT"; - case BufferUsageFlagBits2::eResourceDescriptorBufferEXT : return "ResourceDescriptorBufferEXT"; - case BufferUsageFlagBits2::ePushDescriptorsDescriptorBufferEXT : return "PushDescriptorsDescriptorBufferEXT"; - case BufferUsageFlagBits2::eMicromapBuildInputReadOnlyEXT : return "MicromapBuildInputReadOnlyEXT"; - case BufferUsageFlagBits2::eMicromapStorageEXT : return "MicromapStorageEXT"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case BufferUsageFlagBits2::eCompressedDataDgf1AMDX: return "CompressedDataDgf1AMDX"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case BufferUsageFlagBits2::eDataGraphForeignDescriptorARM: return "DataGraphForeignDescriptorARM"; - case BufferUsageFlagBits2::eTileMemoryQCOM : return "TileMemoryQCOM"; - case BufferUsageFlagBits2::eMemoryDecompressionEXT : return "MemoryDecompressionEXT"; - case BufferUsageFlagBits2::ePreprocessBufferEXT : return "PreprocessBufferEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( HostImageCopyFlagBits value ) - { - switch ( value ) - { - case HostImageCopyFlagBits::eMemcpy: return "Memcpy"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCreateFlagBits2 value ) - { - switch ( value ) - { - case PipelineCreateFlagBits2::eDisableOptimization : return "DisableOptimization"; - case PipelineCreateFlagBits2::eAllowDerivatives : return "AllowDerivatives"; - case PipelineCreateFlagBits2::eDerivative : return "Derivative"; - case PipelineCreateFlagBits2::eViewIndexFromDeviceIndex : return "ViewIndexFromDeviceIndex"; - case PipelineCreateFlagBits2::eDispatchBase : return "DispatchBase"; - case PipelineCreateFlagBits2::eFailOnPipelineCompileRequired: return "FailOnPipelineCompileRequired"; - case PipelineCreateFlagBits2::eEarlyReturnOnFailure : return "EarlyReturnOnFailure"; - case PipelineCreateFlagBits2::eNoProtectedAccess : return "NoProtectedAccess"; - case PipelineCreateFlagBits2::eProtectedAccessOnly : return "ProtectedAccessOnly"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case PipelineCreateFlagBits2::eExecutionGraphAMDX: return "ExecutionGraphAMDX"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case PipelineCreateFlagBits2::eDescriptorHeapEXT : return "DescriptorHeapEXT"; - case PipelineCreateFlagBits2::eRayTracingAllowSpheresAndLinearSweptSpheresNV: return "RayTracingAllowSpheresAndLinearSweptSpheresNV"; - case PipelineCreateFlagBits2::eEnableLegacyDitheringEXT : return "EnableLegacyDitheringEXT"; - case PipelineCreateFlagBits2::eDeferCompileNV : return "DeferCompileNV"; - case PipelineCreateFlagBits2::eCaptureStatisticsKHR : return "CaptureStatisticsKHR"; - case PipelineCreateFlagBits2::eCaptureInternalRepresentationsKHR : return "CaptureInternalRepresentationsKHR"; - case PipelineCreateFlagBits2::eLinkTimeOptimizationEXT : return "LinkTimeOptimizationEXT"; - case PipelineCreateFlagBits2::eRetainLinkTimeOptimizationInfoEXT : return "RetainLinkTimeOptimizationInfoEXT"; - case PipelineCreateFlagBits2::eLibraryKHR : return "LibraryKHR"; - case PipelineCreateFlagBits2::eRayTracingSkipTrianglesKHR : return "RayTracingSkipTrianglesKHR"; - case PipelineCreateFlagBits2::eRayTracingSkipAabbsKHR : return "RayTracingSkipAabbsKHR"; - case PipelineCreateFlagBits2::eRayTracingNoNullAnyHitShadersKHR : return "RayTracingNoNullAnyHitShadersKHR"; - case PipelineCreateFlagBits2::eRayTracingNoNullClosestHitShadersKHR : return "RayTracingNoNullClosestHitShadersKHR"; - case PipelineCreateFlagBits2::eRayTracingNoNullMissShadersKHR : return "RayTracingNoNullMissShadersKHR"; - case PipelineCreateFlagBits2::eRayTracingNoNullIntersectionShadersKHR : return "RayTracingNoNullIntersectionShadersKHR"; - case PipelineCreateFlagBits2::eRayTracingShaderGroupHandleCaptureReplayKHR : return "RayTracingShaderGroupHandleCaptureReplayKHR"; - case PipelineCreateFlagBits2::eIndirectBindableNV : return "IndirectBindableNV"; - case PipelineCreateFlagBits2::eRayTracingAllowMotionNV : return "RayTracingAllowMotionNV"; - case PipelineCreateFlagBits2::eRenderingFragmentShadingRateAttachmentKHR : return "RenderingFragmentShadingRateAttachmentKHR"; - case PipelineCreateFlagBits2::eRenderingFragmentDensityMapAttachmentEXT : return "RenderingFragmentDensityMapAttachmentEXT"; - case PipelineCreateFlagBits2::eRayTracingOpacityMicromapEXT : return "RayTracingOpacityMicromapEXT"; - case PipelineCreateFlagBits2::eColorAttachmentFeedbackLoopEXT : return "ColorAttachmentFeedbackLoopEXT"; - case PipelineCreateFlagBits2::eDepthStencilAttachmentFeedbackLoopEXT : return "DepthStencilAttachmentFeedbackLoopEXT"; - case PipelineCreateFlagBits2::eRayTracingDisplacementMicromapNV : return "RayTracingDisplacementMicromapNV"; - case PipelineCreateFlagBits2::eDescriptorBufferEXT : return "DescriptorBufferEXT"; - case PipelineCreateFlagBits2::eDisallowOpacityMicromapARM : return "DisallowOpacityMicromapARM"; - case PipelineCreateFlagBits2::eCaptureDataKHR : return "CaptureDataKHR"; - case PipelineCreateFlagBits2::eIndirectBindableEXT : return "IndirectBindableEXT"; - case PipelineCreateFlagBits2::ePerLayerFragmentDensityVALVE : return "PerLayerFragmentDensityVALVE"; - case PipelineCreateFlagBits2::e64BitIndexingEXT : return "64BitIndexingEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRobustnessBufferBehavior value ) - { - switch ( value ) - { - case PipelineRobustnessBufferBehavior::eDeviceDefault : return "DeviceDefault"; - case PipelineRobustnessBufferBehavior::eDisabled : return "Disabled"; - case PipelineRobustnessBufferBehavior::eRobustBufferAccess : return "RobustBufferAccess"; - case PipelineRobustnessBufferBehavior::eRobustBufferAccess2: return "RobustBufferAccess2"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRobustnessImageBehavior value ) - { - switch ( value ) - { - case PipelineRobustnessImageBehavior::eDeviceDefault : return "DeviceDefault"; - case PipelineRobustnessImageBehavior::eDisabled : return "Disabled"; - case PipelineRobustnessImageBehavior::eRobustImageAccess : return "RobustImageAccess"; - case PipelineRobustnessImageBehavior::eRobustImageAccess2: return "RobustImageAccess2"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LineRasterizationMode value ) - { - switch ( value ) - { - case LineRasterizationMode::eDefault : return "Default"; - case LineRasterizationMode::eRectangular : return "Rectangular"; - case LineRasterizationMode::eBresenham : return "Bresenham"; - case LineRasterizationMode::eRectangularSmooth: return "RectangularSmooth"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceTransformFlagBitsKHR value ) - { - switch ( value ) - { - case SurfaceTransformFlagBitsKHR::eIdentity : return "Identity"; - case SurfaceTransformFlagBitsKHR::eRotate90 : return "Rotate90"; - case SurfaceTransformFlagBitsKHR::eRotate180 : return "Rotate180"; - case SurfaceTransformFlagBitsKHR::eRotate270 : return "Rotate270"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirror : return "HorizontalMirror"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate90 : return "HorizontalMirrorRotate90"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate180: return "HorizontalMirrorRotate180"; - case SurfaceTransformFlagBitsKHR::eHorizontalMirrorRotate270: return "HorizontalMirrorRotate270"; - case SurfaceTransformFlagBitsKHR::eInherit : return "Inherit"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentModeKHR value ) - { - switch ( value ) - { - case PresentModeKHR::eImmediate : return "Immediate"; - case PresentModeKHR::eMailbox : return "Mailbox"; - case PresentModeKHR::eFifo : return "Fifo"; - case PresentModeKHR::eFifoRelaxed : return "FifoRelaxed"; - case PresentModeKHR::eSharedDemandRefresh : return "SharedDemandRefresh"; - case PresentModeKHR::eSharedContinuousRefresh: return "SharedContinuousRefresh"; - case PresentModeKHR::eFifoLatestReady : return "FifoLatestReady"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ColorSpaceKHR value ) - { - switch ( value ) - { - case ColorSpaceKHR::eSrgbNonlinear : return "SrgbNonlinear"; - case ColorSpaceKHR::eDisplayP3NonlinearEXT : return "DisplayP3NonlinearEXT"; - case ColorSpaceKHR::eExtendedSrgbLinearEXT : return "ExtendedSrgbLinearEXT"; - case ColorSpaceKHR::eDisplayP3LinearEXT : return "DisplayP3LinearEXT"; - case ColorSpaceKHR::eDciP3NonlinearEXT : return "DciP3NonlinearEXT"; - case ColorSpaceKHR::eBt709LinearEXT : return "Bt709LinearEXT"; - case ColorSpaceKHR::eBt709NonlinearEXT : return "Bt709NonlinearEXT"; - case ColorSpaceKHR::eBt2020LinearEXT : return "Bt2020LinearEXT"; - case ColorSpaceKHR::eHdr10St2084EXT : return "Hdr10St2084EXT"; - case ColorSpaceKHR::eDolbyvisionEXT : return "DolbyvisionEXT"; - case ColorSpaceKHR::eHdr10HlgEXT : return "Hdr10HlgEXT"; - case ColorSpaceKHR::eAdobergbLinearEXT : return "AdobergbLinearEXT"; - case ColorSpaceKHR::eAdobergbNonlinearEXT : return "AdobergbNonlinearEXT"; - case ColorSpaceKHR::ePassThroughEXT : return "PassThroughEXT"; - case ColorSpaceKHR::eExtendedSrgbNonlinearEXT: return "ExtendedSrgbNonlinearEXT"; - case ColorSpaceKHR::eDisplayNativeAMD : return "DisplayNativeAMD"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CompositeAlphaFlagBitsKHR value ) - { - switch ( value ) - { - case CompositeAlphaFlagBitsKHR::eOpaque : return "Opaque"; - case CompositeAlphaFlagBitsKHR::ePreMultiplied : return "PreMultiplied"; - case CompositeAlphaFlagBitsKHR::ePostMultiplied: return "PostMultiplied"; - case CompositeAlphaFlagBitsKHR::eInherit : return "Inherit"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_swapchain === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SwapchainCreateFlagBitsKHR value ) - { - switch ( value ) - { - case SwapchainCreateFlagBitsKHR::eSplitInstanceBindRegions: return "SplitInstanceBindRegions"; - case SwapchainCreateFlagBitsKHR::eProtected : return "Protected"; - case SwapchainCreateFlagBitsKHR::eMutableFormat : return "MutableFormat"; - case SwapchainCreateFlagBitsKHR::ePresentTimingEXT : return "PresentTimingEXT"; - case SwapchainCreateFlagBitsKHR::ePresentId2 : return "PresentId2"; - case SwapchainCreateFlagBitsKHR::ePresentWait2 : return "PresentWait2"; - case SwapchainCreateFlagBitsKHR::eDeferredMemoryAllocation: return "DeferredMemoryAllocation"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceGroupPresentModeFlagBitsKHR value ) - { - switch ( value ) - { - case DeviceGroupPresentModeFlagBitsKHR::eLocal : return "Local"; - case DeviceGroupPresentModeFlagBitsKHR::eRemote : return "Remote"; - case DeviceGroupPresentModeFlagBitsKHR::eSum : return "Sum"; - case DeviceGroupPresentModeFlagBitsKHR::eLocalMultiDevice: return "LocalMultiDevice"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_display === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayPlaneAlphaFlagBitsKHR value ) - { - switch ( value ) - { - case DisplayPlaneAlphaFlagBitsKHR::eOpaque : return "Opaque"; - case DisplayPlaneAlphaFlagBitsKHR::eGlobal : return "Global"; - case DisplayPlaneAlphaFlagBitsKHR::ePerPixel : return "PerPixel"; - case DisplayPlaneAlphaFlagBitsKHR::ePerPixelPremultiplied: return "PerPixelPremultiplied"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayModeCreateFlagBitsKHR ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplaySurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } - -#if defined( VK_USE_PLATFORM_XLIB_KHR ) - //=== VK_KHR_xlib_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XlibSurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_XLIB_KHR*/ - -#if defined( VK_USE_PLATFORM_XCB_KHR ) - //=== VK_KHR_xcb_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( XcbSurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_XCB_KHR*/ - -#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) - //=== VK_KHR_wayland_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( WaylandSurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ - -#if defined( VK_USE_PLATFORM_ANDROID_KHR ) - //=== VK_KHR_android_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AndroidSurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_KHR_win32_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( Win32SurfaceCreateFlagBitsKHR ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_debug_report === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugReportFlagBitsEXT value ) - { - switch ( value ) - { - case DebugReportFlagBitsEXT::eInformation : return "Information"; - case DebugReportFlagBitsEXT::eWarning : return "Warning"; - case DebugReportFlagBitsEXT::ePerformanceWarning: return "PerformanceWarning"; - case DebugReportFlagBitsEXT::eError : return "Error"; - case DebugReportFlagBitsEXT::eDebug : return "Debug"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugReportObjectTypeEXT value ) - { - switch ( value ) - { - case DebugReportObjectTypeEXT::eUnknown : return "Unknown"; - case DebugReportObjectTypeEXT::eInstance : return "Instance"; - case DebugReportObjectTypeEXT::ePhysicalDevice : return "PhysicalDevice"; - case DebugReportObjectTypeEXT::eDevice : return "Device"; - case DebugReportObjectTypeEXT::eQueue : return "Queue"; - case DebugReportObjectTypeEXT::eSemaphore : return "Semaphore"; - case DebugReportObjectTypeEXT::eCommandBuffer : return "CommandBuffer"; - case DebugReportObjectTypeEXT::eFence : return "Fence"; - case DebugReportObjectTypeEXT::eDeviceMemory : return "DeviceMemory"; - case DebugReportObjectTypeEXT::eBuffer : return "Buffer"; - case DebugReportObjectTypeEXT::eImage : return "Image"; - case DebugReportObjectTypeEXT::eEvent : return "Event"; - case DebugReportObjectTypeEXT::eQueryPool : return "QueryPool"; - case DebugReportObjectTypeEXT::eBufferView : return "BufferView"; - case DebugReportObjectTypeEXT::eImageView : return "ImageView"; - case DebugReportObjectTypeEXT::eShaderModule : return "ShaderModule"; - case DebugReportObjectTypeEXT::ePipelineCache : return "PipelineCache"; - case DebugReportObjectTypeEXT::ePipelineLayout : return "PipelineLayout"; - case DebugReportObjectTypeEXT::eRenderPass : return "RenderPass"; - case DebugReportObjectTypeEXT::ePipeline : return "Pipeline"; - case DebugReportObjectTypeEXT::eDescriptorSetLayout : return "DescriptorSetLayout"; - case DebugReportObjectTypeEXT::eSampler : return "Sampler"; - case DebugReportObjectTypeEXT::eDescriptorPool : return "DescriptorPool"; - case DebugReportObjectTypeEXT::eDescriptorSet : return "DescriptorSet"; - case DebugReportObjectTypeEXT::eFramebuffer : return "Framebuffer"; - case DebugReportObjectTypeEXT::eCommandPool : return "CommandPool"; - case DebugReportObjectTypeEXT::eSurfaceKHR : return "SurfaceKHR"; - case DebugReportObjectTypeEXT::eSwapchainKHR : return "SwapchainKHR"; - case DebugReportObjectTypeEXT::eDebugReportCallbackEXT : return "DebugReportCallbackEXT"; - case DebugReportObjectTypeEXT::eDisplayKHR : return "DisplayKHR"; - case DebugReportObjectTypeEXT::eDisplayModeKHR : return "DisplayModeKHR"; - case DebugReportObjectTypeEXT::eValidationCacheEXT : return "ValidationCacheEXT"; - case DebugReportObjectTypeEXT::eSamplerYcbcrConversion : return "SamplerYcbcrConversion"; - case DebugReportObjectTypeEXT::eDescriptorUpdateTemplate: return "DescriptorUpdateTemplate"; - case DebugReportObjectTypeEXT::eCuModuleNVX : return "CuModuleNVX"; - case DebugReportObjectTypeEXT::eCuFunctionNVX : return "CuFunctionNVX"; - case DebugReportObjectTypeEXT::eAccelerationStructureKHR: return "AccelerationStructureKHR"; - case DebugReportObjectTypeEXT::eAccelerationStructureNV : return "AccelerationStructureNV"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case DebugReportObjectTypeEXT::eCudaModuleNV : return "CudaModuleNV"; - case DebugReportObjectTypeEXT::eCudaFunctionNV: return "CudaFunctionNV"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ -#if defined( VK_USE_PLATFORM_FUCHSIA ) - case DebugReportObjectTypeEXT::eBufferCollectionFUCHSIA: return "BufferCollectionFUCHSIA"; -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_AMD_rasterization_order === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RasterizationOrderAMD value ) - { - switch ( value ) - { - case RasterizationOrderAMD::eStrict : return "Strict"; - case RasterizationOrderAMD::eRelaxed: return "Relaxed"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_video_queue === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoCodecOperationFlagBitsKHR value ) - { - switch ( value ) - { - case VideoCodecOperationFlagBitsKHR::eNone : return "None"; - case VideoCodecOperationFlagBitsKHR::eEncodeH264: return "EncodeH264"; - case VideoCodecOperationFlagBitsKHR::eEncodeH265: return "EncodeH265"; - case VideoCodecOperationFlagBitsKHR::eDecodeH264: return "DecodeH264"; - case VideoCodecOperationFlagBitsKHR::eDecodeH265: return "DecodeH265"; - case VideoCodecOperationFlagBitsKHR::eDecodeAv1 : return "DecodeAv1"; - case VideoCodecOperationFlagBitsKHR::eEncodeAv1 : return "EncodeAv1"; - case VideoCodecOperationFlagBitsKHR::eDecodeVp9 : return "DecodeVp9"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoChromaSubsamplingFlagBitsKHR value ) - { - switch ( value ) - { - case VideoChromaSubsamplingFlagBitsKHR::eInvalid : return "Invalid"; - case VideoChromaSubsamplingFlagBitsKHR::eMonochrome: return "Monochrome"; - case VideoChromaSubsamplingFlagBitsKHR::e420 : return "420"; - case VideoChromaSubsamplingFlagBitsKHR::e422 : return "422"; - case VideoChromaSubsamplingFlagBitsKHR::e444 : return "444"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoComponentBitDepthFlagBitsKHR value ) - { - switch ( value ) - { - case VideoComponentBitDepthFlagBitsKHR::eInvalid: return "Invalid"; - case VideoComponentBitDepthFlagBitsKHR::e8 : return "8"; - case VideoComponentBitDepthFlagBitsKHR::e10 : return "10"; - case VideoComponentBitDepthFlagBitsKHR::e12 : return "12"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoCapabilityFlagBitsKHR value ) - { - switch ( value ) - { - case VideoCapabilityFlagBitsKHR::eProtectedContent : return "ProtectedContent"; - case VideoCapabilityFlagBitsKHR::eSeparateReferenceImages: return "SeparateReferenceImages"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoSessionCreateFlagBitsKHR value ) - { - switch ( value ) - { - case VideoSessionCreateFlagBitsKHR::eProtectedContent : return "ProtectedContent"; - case VideoSessionCreateFlagBitsKHR::eAllowEncodeParameterOptimizations: return "AllowEncodeParameterOptimizations"; - case VideoSessionCreateFlagBitsKHR::eInlineQueries : return "InlineQueries"; - case VideoSessionCreateFlagBitsKHR::eAllowEncodeQuantizationDeltaMap : return "AllowEncodeQuantizationDeltaMap"; - case VideoSessionCreateFlagBitsKHR::eAllowEncodeEmphasisMap : return "AllowEncodeEmphasisMap"; - case VideoSessionCreateFlagBitsKHR::eInlineSessionParameters : return "InlineSessionParameters"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoCodingControlFlagBitsKHR value ) - { - switch ( value ) - { - case VideoCodingControlFlagBitsKHR::eReset : return "Reset"; - case VideoCodingControlFlagBitsKHR::eEncodeRateControl : return "EncodeRateControl"; - case VideoCodingControlFlagBitsKHR::eEncodeQualityLevel: return "EncodeQualityLevel"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryResultStatusKHR value ) - { - switch ( value ) - { - case QueryResultStatusKHR::eError : return "Error"; - case QueryResultStatusKHR::eNotReady : return "NotReady"; - case QueryResultStatusKHR::eComplete : return "Complete"; - case QueryResultStatusKHR::eInsufficientBitstreamBufferRange: return "InsufficientBitstreamBufferRange"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoSessionParametersCreateFlagBitsKHR value ) - { - switch ( value ) - { - case VideoSessionParametersCreateFlagBitsKHR::eQuantizationMapCompatible: return "QuantizationMapCompatible"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoBeginCodingFlagBitsKHR ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEndCodingFlagBitsKHR ) - { - return "(void)"; - } - - //=== VK_KHR_video_decode_queue === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeCapabilityFlagBitsKHR value ) - { - switch ( value ) - { - case VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputCoincide: return "DpbAndOutputCoincide"; - case VideoDecodeCapabilityFlagBitsKHR::eDpbAndOutputDistinct: return "DpbAndOutputDistinct"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeUsageFlagBitsKHR value ) - { - switch ( value ) - { - case VideoDecodeUsageFlagBitsKHR::eDefault : return "Default"; - case VideoDecodeUsageFlagBitsKHR::eTranscoding: return "Transcoding"; - case VideoDecodeUsageFlagBitsKHR::eOffline : return "Offline"; - case VideoDecodeUsageFlagBitsKHR::eStreaming : return "Streaming"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeFlagBitsKHR ) - { - return "(void)"; - } - - //=== VK_EXT_transform_feedback === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationStateStreamCreateFlagBitsEXT ) - { - return "(void)"; - } - - //=== VK_KHR_video_encode_h264 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH264CapabilityFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeH264CapabilityFlagBitsKHR::eHrdCompliance : return "HrdCompliance"; - case VideoEncodeH264CapabilityFlagBitsKHR::ePredictionWeightTableGenerated: return "PredictionWeightTableGenerated"; - case VideoEncodeH264CapabilityFlagBitsKHR::eRowUnalignedSlice : return "RowUnalignedSlice"; - case VideoEncodeH264CapabilityFlagBitsKHR::eDifferentSliceType : return "DifferentSliceType"; - case VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL0List : return "BFrameInL0List"; - case VideoEncodeH264CapabilityFlagBitsKHR::eBFrameInL1List : return "BFrameInL1List"; - case VideoEncodeH264CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp : return "PerPictureTypeMinMaxQp"; - case VideoEncodeH264CapabilityFlagBitsKHR::ePerSliceConstantQp : return "PerSliceConstantQp"; - case VideoEncodeH264CapabilityFlagBitsKHR::eGeneratePrefixNalu : return "GeneratePrefixNalu"; - case VideoEncodeH264CapabilityFlagBitsKHR::eBPictureIntraRefresh : return "BPictureIntraRefresh"; - case VideoEncodeH264CapabilityFlagBitsKHR::eMbQpDiffWraparound : return "MbQpDiffWraparound"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH264StdFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeH264StdFlagBitsKHR::eSeparateColorPlaneFlagSet : return "SeparateColorPlaneFlagSet"; - case VideoEncodeH264StdFlagBitsKHR::eQpprimeYZeroTransformBypassFlagSet: return "QpprimeYZeroTransformBypassFlagSet"; - case VideoEncodeH264StdFlagBitsKHR::eScalingMatrixPresentFlagSet : return "ScalingMatrixPresentFlagSet"; - case VideoEncodeH264StdFlagBitsKHR::eChromaQpIndexOffset : return "ChromaQpIndexOffset"; - case VideoEncodeH264StdFlagBitsKHR::eSecondChromaQpIndexOffset : return "SecondChromaQpIndexOffset"; - case VideoEncodeH264StdFlagBitsKHR::ePicInitQpMinus26 : return "PicInitQpMinus26"; - case VideoEncodeH264StdFlagBitsKHR::eWeightedPredFlagSet : return "WeightedPredFlagSet"; - case VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcExplicit : return "WeightedBipredIdcExplicit"; - case VideoEncodeH264StdFlagBitsKHR::eWeightedBipredIdcImplicit : return "WeightedBipredIdcImplicit"; - case VideoEncodeH264StdFlagBitsKHR::eTransform8X8ModeFlagSet : return "Transform8X8ModeFlagSet"; - case VideoEncodeH264StdFlagBitsKHR::eDirectSpatialMvPredFlagUnset : return "DirectSpatialMvPredFlagUnset"; - case VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagUnset : return "EntropyCodingModeFlagUnset"; - case VideoEncodeH264StdFlagBitsKHR::eEntropyCodingModeFlagSet : return "EntropyCodingModeFlagSet"; - case VideoEncodeH264StdFlagBitsKHR::eDirect8X8InferenceFlagUnset : return "Direct8X8InferenceFlagUnset"; - case VideoEncodeH264StdFlagBitsKHR::eConstrainedIntraPredFlagSet : return "ConstrainedIntraPredFlagSet"; - case VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterDisabled : return "DeblockingFilterDisabled"; - case VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterEnabled : return "DeblockingFilterEnabled"; - case VideoEncodeH264StdFlagBitsKHR::eDeblockingFilterPartial : return "DeblockingFilterPartial"; - case VideoEncodeH264StdFlagBitsKHR::eSliceQpDelta : return "SliceQpDelta"; - case VideoEncodeH264StdFlagBitsKHR::eDifferentSliceQpDelta : return "DifferentSliceQpDelta"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH264RateControlFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeH264RateControlFlagBitsKHR::eAttemptHrdCompliance : return "AttemptHrdCompliance"; - case VideoEncodeH264RateControlFlagBitsKHR::eRegularGop : return "RegularGop"; - case VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternFlat : return "ReferencePatternFlat"; - case VideoEncodeH264RateControlFlagBitsKHR::eReferencePatternDyadic : return "ReferencePatternDyadic"; - case VideoEncodeH264RateControlFlagBitsKHR::eTemporalLayerPatternDyadic: return "TemporalLayerPatternDyadic"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_video_encode_h265 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265CapabilityFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeH265CapabilityFlagBitsKHR::eHrdCompliance : return "HrdCompliance"; - case VideoEncodeH265CapabilityFlagBitsKHR::ePredictionWeightTableGenerated: return "PredictionWeightTableGenerated"; - case VideoEncodeH265CapabilityFlagBitsKHR::eRowUnalignedSliceSegment : return "RowUnalignedSliceSegment"; - case VideoEncodeH265CapabilityFlagBitsKHR::eDifferentSliceSegmentType : return "DifferentSliceSegmentType"; - case VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL0List : return "BFrameInL0List"; - case VideoEncodeH265CapabilityFlagBitsKHR::eBFrameInL1List : return "BFrameInL1List"; - case VideoEncodeH265CapabilityFlagBitsKHR::ePerPictureTypeMinMaxQp : return "PerPictureTypeMinMaxQp"; - case VideoEncodeH265CapabilityFlagBitsKHR::ePerSliceSegmentConstantQp : return "PerSliceSegmentConstantQp"; - case VideoEncodeH265CapabilityFlagBitsKHR::eMultipleTilesPerSliceSegment : return "MultipleTilesPerSliceSegment"; - case VideoEncodeH265CapabilityFlagBitsKHR::eMultipleSliceSegmentsPerTile : return "MultipleSliceSegmentsPerTile"; - case VideoEncodeH265CapabilityFlagBitsKHR::eBPictureIntraRefresh : return "BPictureIntraRefresh"; - case VideoEncodeH265CapabilityFlagBitsKHR::eCuQpDiffWraparound : return "CuQpDiffWraparound"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265StdFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeH265StdFlagBitsKHR::eSeparateColorPlaneFlagSet : return "SeparateColorPlaneFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eSampleAdaptiveOffsetEnabledFlagSet : return "SampleAdaptiveOffsetEnabledFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eScalingListDataPresentFlagSet : return "ScalingListDataPresentFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::ePcmEnabledFlagSet : return "PcmEnabledFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eSpsTemporalMvpEnabledFlagSet : return "SpsTemporalMvpEnabledFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eInitQpMinus26 : return "InitQpMinus26"; - case VideoEncodeH265StdFlagBitsKHR::eWeightedPredFlagSet : return "WeightedPredFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eWeightedBipredFlagSet : return "WeightedBipredFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eLog2ParallelMergeLevelMinus2 : return "Log2ParallelMergeLevelMinus2"; - case VideoEncodeH265StdFlagBitsKHR::eSignDataHidingEnabledFlagSet : return "SignDataHidingEnabledFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagSet : return "TransformSkipEnabledFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eTransformSkipEnabledFlagUnset : return "TransformSkipEnabledFlagUnset"; - case VideoEncodeH265StdFlagBitsKHR::ePpsSliceChromaQpOffsetsPresentFlagSet : return "PpsSliceChromaQpOffsetsPresentFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eTransquantBypassEnabledFlagSet : return "TransquantBypassEnabledFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eConstrainedIntraPredFlagSet : return "ConstrainedIntraPredFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eEntropyCodingSyncEnabledFlagSet : return "EntropyCodingSyncEnabledFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eDeblockingFilterOverrideEnabledFlagSet: return "DeblockingFilterOverrideEnabledFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentsEnabledFlagSet : return "DependentSliceSegmentsEnabledFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eDependentSliceSegmentFlagSet : return "DependentSliceSegmentFlagSet"; - case VideoEncodeH265StdFlagBitsKHR::eSliceQpDelta : return "SliceQpDelta"; - case VideoEncodeH265StdFlagBitsKHR::eDifferentSliceQpDelta : return "DifferentSliceQpDelta"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265CtbSizeFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeH265CtbSizeFlagBitsKHR::e16: return "16"; - case VideoEncodeH265CtbSizeFlagBitsKHR::e32: return "32"; - case VideoEncodeH265CtbSizeFlagBitsKHR::e64: return "64"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265TransformBlockSizeFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e4 : return "4"; - case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e8 : return "8"; - case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e16: return "16"; - case VideoEncodeH265TransformBlockSizeFlagBitsKHR::e32: return "32"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeH265RateControlFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeH265RateControlFlagBitsKHR::eAttemptHrdCompliance : return "AttemptHrdCompliance"; - case VideoEncodeH265RateControlFlagBitsKHR::eRegularGop : return "RegularGop"; - case VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternFlat : return "ReferencePatternFlat"; - case VideoEncodeH265RateControlFlagBitsKHR::eReferencePatternDyadic : return "ReferencePatternDyadic"; - case VideoEncodeH265RateControlFlagBitsKHR::eTemporalSubLayerPatternDyadic: return "TemporalSubLayerPatternDyadic"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_video_decode_h264 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoDecodeH264PictureLayoutFlagBitsKHR value ) - { - switch ( value ) - { - case VideoDecodeH264PictureLayoutFlagBitsKHR::eProgressive : return "Progressive"; - case VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedInterleavedLines: return "InterlacedInterleavedLines"; - case VideoDecodeH264PictureLayoutFlagBitsKHR::eInterlacedSeparatePlanes : return "InterlacedSeparatePlanes"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_AMD_shader_info === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderInfoTypeAMD value ) - { - switch ( value ) - { - case ShaderInfoTypeAMD::eStatistics : return "Statistics"; - case ShaderInfoTypeAMD::eBinary : return "Binary"; - case ShaderInfoTypeAMD::eDisassembly: return "Disassembly"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -#if defined( VK_USE_PLATFORM_GGP ) - //=== VK_GGP_stream_descriptor_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( StreamDescriptorSurfaceCreateFlagBitsGGP ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_GGP*/ - - //=== VK_NV_external_memory_capabilities === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryHandleTypeFlagBitsNV value ) - { - switch ( value ) - { - case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32 : return "OpaqueWin32"; - case ExternalMemoryHandleTypeFlagBitsNV::eOpaqueWin32Kmt: return "OpaqueWin32Kmt"; - case ExternalMemoryHandleTypeFlagBitsNV::eD3D11Image : return "D3D11Image"; - case ExternalMemoryHandleTypeFlagBitsNV::eD3D11ImageKmt : return "D3D11ImageKmt"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExternalMemoryFeatureFlagBitsNV value ) - { - switch ( value ) - { - case ExternalMemoryFeatureFlagBitsNV::eDedicatedOnly: return "DedicatedOnly"; - case ExternalMemoryFeatureFlagBitsNV::eExportable : return "Exportable"; - case ExternalMemoryFeatureFlagBitsNV::eImportable : return "Importable"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_validation_flags === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCheckEXT value ) - { - switch ( value ) - { - case ValidationCheckEXT::eAll : return "All"; - case ValidationCheckEXT::eShaders: return "Shaders"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -#if defined( VK_USE_PLATFORM_VI_NN ) - //=== VK_NN_vi_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ViSurfaceCreateFlagBitsNN ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_VI_NN*/ - - //=== VK_EXT_conditional_rendering === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ConditionalRenderingFlagBitsEXT value ) - { - switch ( value ) - { - case ConditionalRenderingFlagBitsEXT::eInverted: return "Inverted"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_display_surface_counter === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceCounterFlagBitsEXT value ) - { - switch ( value ) - { - case SurfaceCounterFlagBitsEXT::eVblank: return "Vblank"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_display_control === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayPowerStateEXT value ) - { - switch ( value ) - { - case DisplayPowerStateEXT::eOff : return "Off"; - case DisplayPowerStateEXT::eSuspend: return "Suspend"; - case DisplayPowerStateEXT::eOn : return "On"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceEventTypeEXT value ) - { - switch ( value ) - { - case DeviceEventTypeEXT::eDisplayHotplug: return "DisplayHotplug"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplayEventTypeEXT value ) - { - switch ( value ) - { - case DisplayEventTypeEXT::eFirstPixelOut: return "FirstPixelOut"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_viewport_swizzle === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ViewportCoordinateSwizzleNV value ) - { - switch ( value ) - { - case ViewportCoordinateSwizzleNV::ePositiveX: return "PositiveX"; - case ViewportCoordinateSwizzleNV::eNegativeX: return "NegativeX"; - case ViewportCoordinateSwizzleNV::ePositiveY: return "PositiveY"; - case ViewportCoordinateSwizzleNV::eNegativeY: return "NegativeY"; - case ViewportCoordinateSwizzleNV::ePositiveZ: return "PositiveZ"; - case ViewportCoordinateSwizzleNV::eNegativeZ: return "NegativeZ"; - case ViewportCoordinateSwizzleNV::ePositiveW: return "PositiveW"; - case ViewportCoordinateSwizzleNV::eNegativeW: return "NegativeW"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineViewportSwizzleStateCreateFlagBitsNV ) - { - return "(void)"; - } - - //=== VK_EXT_discard_rectangles === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DiscardRectangleModeEXT value ) - { - switch ( value ) - { - case DiscardRectangleModeEXT::eInclusive: return "Inclusive"; - case DiscardRectangleModeEXT::eExclusive: return "Exclusive"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineDiscardRectangleStateCreateFlagBitsEXT ) - { - return "(void)"; - } - - //=== VK_EXT_conservative_rasterization === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ConservativeRasterizationModeEXT value ) - { - switch ( value ) - { - case ConservativeRasterizationModeEXT::eDisabled : return "Disabled"; - case ConservativeRasterizationModeEXT::eOverestimate : return "Overestimate"; - case ConservativeRasterizationModeEXT::eUnderestimate: return "Underestimate"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationConservativeStateCreateFlagBitsEXT ) - { - return "(void)"; - } - - //=== VK_EXT_depth_clip_enable === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineRasterizationDepthClipStateCreateFlagBitsEXT ) - { - return "(void)"; - } - - //=== VK_KHR_performance_query === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagBitsKHR value ) - { - switch ( value ) - { - case PerformanceCounterDescriptionFlagBitsKHR::ePerformanceImpacting: return "PerformanceImpacting"; - case PerformanceCounterDescriptionFlagBitsKHR::eConcurrentlyImpacted: return "ConcurrentlyImpacted"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterScopeKHR value ) - { - switch ( value ) - { - case PerformanceCounterScopeKHR::eCommandBuffer: return "CommandBuffer"; - case PerformanceCounterScopeKHR::eRenderPass : return "RenderPass"; - case PerformanceCounterScopeKHR::eCommand : return "Command"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterStorageKHR value ) - { - switch ( value ) - { - case PerformanceCounterStorageKHR::eInt32 : return "Int32"; - case PerformanceCounterStorageKHR::eInt64 : return "Int64"; - case PerformanceCounterStorageKHR::eUint32 : return "Uint32"; - case PerformanceCounterStorageKHR::eUint64 : return "Uint64"; - case PerformanceCounterStorageKHR::eFloat32: return "Float32"; - case PerformanceCounterStorageKHR::eFloat64: return "Float64"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterUnitKHR value ) - { - switch ( value ) - { - case PerformanceCounterUnitKHR::eGeneric : return "Generic"; - case PerformanceCounterUnitKHR::ePercentage : return "Percentage"; - case PerformanceCounterUnitKHR::eNanoseconds : return "Nanoseconds"; - case PerformanceCounterUnitKHR::eBytes : return "Bytes"; - case PerformanceCounterUnitKHR::eBytesPerSecond: return "BytesPerSecond"; - case PerformanceCounterUnitKHR::eKelvin : return "Kelvin"; - case PerformanceCounterUnitKHR::eWatts : return "Watts"; - case PerformanceCounterUnitKHR::eVolts : return "Volts"; - case PerformanceCounterUnitKHR::eAmps : return "Amps"; - case PerformanceCounterUnitKHR::eHertz : return "Hertz"; - case PerformanceCounterUnitKHR::eCycles : return "Cycles"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AcquireProfilingLockFlagBitsKHR ) - { - return "(void)"; - } - -#if defined( VK_USE_PLATFORM_IOS_MVK ) - //=== VK_MVK_ios_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IOSSurfaceCreateFlagBitsMVK ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_IOS_MVK*/ - -#if defined( VK_USE_PLATFORM_MACOS_MVK ) - //=== VK_MVK_macos_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MacOSSurfaceCreateFlagBitsMVK ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_MACOS_MVK*/ - - //=== VK_EXT_debug_utils === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessageSeverityFlagBitsEXT value ) - { - switch ( value ) - { - case DebugUtilsMessageSeverityFlagBitsEXT::eVerbose: return "Verbose"; - case DebugUtilsMessageSeverityFlagBitsEXT::eInfo : return "Info"; - case DebugUtilsMessageSeverityFlagBitsEXT::eWarning: return "Warning"; - case DebugUtilsMessageSeverityFlagBitsEXT::eError : return "Error"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessageTypeFlagBitsEXT value ) - { - switch ( value ) - { - case DebugUtilsMessageTypeFlagBitsEXT::eGeneral : return "General"; - case DebugUtilsMessageTypeFlagBitsEXT::eValidation : return "Validation"; - case DebugUtilsMessageTypeFlagBitsEXT::ePerformance : return "Performance"; - case DebugUtilsMessageTypeFlagBitsEXT::eDeviceAddressBinding: return "DeviceAddressBinding"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCallbackDataFlagBitsEXT ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DebugUtilsMessengerCreateFlagBitsEXT ) - { - return "(void)"; - } - - //=== VK_EXT_descriptor_heap === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DescriptorMappingSourceEXT value ) - { - switch ( value ) - { - case DescriptorMappingSourceEXT::eHeapWithConstantOffset : return "HeapWithConstantOffset"; - case DescriptorMappingSourceEXT::eHeapWithPushIndex : return "HeapWithPushIndex"; - case DescriptorMappingSourceEXT::eHeapWithIndirectIndex : return "HeapWithIndirectIndex"; - case DescriptorMappingSourceEXT::eHeapWithIndirectIndexArray: return "HeapWithIndirectIndexArray"; - case DescriptorMappingSourceEXT::eResourceHeapData : return "ResourceHeapData"; - case DescriptorMappingSourceEXT::ePushData : return "PushData"; - case DescriptorMappingSourceEXT::ePushAddress : return "PushAddress"; - case DescriptorMappingSourceEXT::eIndirectAddress : return "IndirectAddress"; - case DescriptorMappingSourceEXT::eHeapWithShaderRecordIndex : return "HeapWithShaderRecordIndex"; - case DescriptorMappingSourceEXT::eShaderRecordData : return "ShaderRecordData"; - case DescriptorMappingSourceEXT::eShaderRecordAddress : return "ShaderRecordAddress"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SpirvResourceTypeFlagBitsEXT value ) - { - switch ( value ) - { - case SpirvResourceTypeFlagBitsEXT::eAll : return "All"; - case SpirvResourceTypeFlagBitsEXT::eSampler : return "Sampler"; - case SpirvResourceTypeFlagBitsEXT::eSampledImage : return "SampledImage"; - case SpirvResourceTypeFlagBitsEXT::eReadOnlyImage : return "ReadOnlyImage"; - case SpirvResourceTypeFlagBitsEXT::eReadWriteImage : return "ReadWriteImage"; - case SpirvResourceTypeFlagBitsEXT::eCombinedSampledImage : return "CombinedSampledImage"; - case SpirvResourceTypeFlagBitsEXT::eUniformBuffer : return "UniformBuffer"; - case SpirvResourceTypeFlagBitsEXT::eReadOnlyStorageBuffer : return "ReadOnlyStorageBuffer"; - case SpirvResourceTypeFlagBitsEXT::eReadWriteStorageBuffer: return "ReadWriteStorageBuffer"; - case SpirvResourceTypeFlagBitsEXT::eAccelerationStructure : return "AccelerationStructure"; - case SpirvResourceTypeFlagBitsEXT::eTensorARM : return "TensorARM"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorViewCreateFlagBitsARM value ) - { - switch ( value ) - { - case TensorViewCreateFlagBitsARM::eDescriptorBufferCaptureReplay: return "DescriptorBufferCaptureReplay"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_blend_operation_advanced === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlendOverlapEXT value ) - { - switch ( value ) - { - case BlendOverlapEXT::eUncorrelated: return "Uncorrelated"; - case BlendOverlapEXT::eDisjoint : return "Disjoint"; - case BlendOverlapEXT::eConjoint : return "Conjoint"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_fragment_coverage_to_color === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageToColorStateCreateFlagBitsNV ) - { - return "(void)"; - } - - //=== VK_KHR_acceleration_structure === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureTypeKHR value ) - { - switch ( value ) - { - case AccelerationStructureTypeKHR::eTopLevel : return "TopLevel"; - case AccelerationStructureTypeKHR::eBottomLevel: return "BottomLevel"; - case AccelerationStructureTypeKHR::eGeneric : return "Generic"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureBuildTypeKHR value ) - { - switch ( value ) - { - case AccelerationStructureBuildTypeKHR::eHost : return "Host"; - case AccelerationStructureBuildTypeKHR::eDevice : return "Device"; - case AccelerationStructureBuildTypeKHR::eHostOrDevice: return "HostOrDevice"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GeometryFlagBitsKHR value ) - { - switch ( value ) - { - case GeometryFlagBitsKHR::eOpaque : return "Opaque"; - case GeometryFlagBitsKHR::eNoDuplicateAnyHitInvocation: return "NoDuplicateAnyHitInvocation"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GeometryInstanceFlagBitsKHR value ) - { - switch ( value ) - { - case GeometryInstanceFlagBitsKHR::eTriangleFacingCullDisable : return "TriangleFacingCullDisable"; - case GeometryInstanceFlagBitsKHR::eTriangleFlipFacing : return "TriangleFlipFacing"; - case GeometryInstanceFlagBitsKHR::eForceOpaque : return "ForceOpaque"; - case GeometryInstanceFlagBitsKHR::eForceNoOpaque : return "ForceNoOpaque"; - case GeometryInstanceFlagBitsKHR::eForceOpacityMicromap2StateEXT: return "ForceOpacityMicromap2StateEXT"; - case GeometryInstanceFlagBitsKHR::eDisableOpacityMicromapsEXT : return "DisableOpacityMicromapsEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildAccelerationStructureFlagBitsKHR value ) - { - switch ( value ) - { - case BuildAccelerationStructureFlagBitsKHR::eAllowUpdate : return "AllowUpdate"; - case BuildAccelerationStructureFlagBitsKHR::eAllowCompaction : return "AllowCompaction"; - case BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace : return "PreferFastTrace"; - case BuildAccelerationStructureFlagBitsKHR::ePreferFastBuild : return "PreferFastBuild"; - case BuildAccelerationStructureFlagBitsKHR::eLowMemory : return "LowMemory"; - case BuildAccelerationStructureFlagBitsKHR::eMotionNV : return "MotionNV"; - case BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapUpdateEXT : return "AllowOpacityMicromapUpdateEXT"; - case BuildAccelerationStructureFlagBitsKHR::eAllowDisableOpacityMicromapsEXT : return "AllowDisableOpacityMicromapsEXT"; - case BuildAccelerationStructureFlagBitsKHR::eAllowOpacityMicromapDataUpdateEXT: return "AllowOpacityMicromapDataUpdateEXT"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case BuildAccelerationStructureFlagBitsKHR::eAllowDisplacementMicromapUpdateNV: return "AllowDisplacementMicromapUpdateNV"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - case BuildAccelerationStructureFlagBitsKHR::eAllowDataAccess : return "AllowDataAccess"; - case BuildAccelerationStructureFlagBitsKHR::eAllowClusterOpacityMicromapsNV: return "AllowClusterOpacityMicromapsNV"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CopyAccelerationStructureModeKHR value ) - { - switch ( value ) - { - case CopyAccelerationStructureModeKHR::eClone : return "Clone"; - case CopyAccelerationStructureModeKHR::eCompact : return "Compact"; - case CopyAccelerationStructureModeKHR::eSerialize : return "Serialize"; - case CopyAccelerationStructureModeKHR::eDeserialize: return "Deserialize"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GeometryTypeKHR value ) - { - switch ( value ) - { - case GeometryTypeKHR::eTriangles : return "Triangles"; - case GeometryTypeKHR::eAabbs : return "Aabbs"; - case GeometryTypeKHR::eInstances : return "Instances"; - case GeometryTypeKHR::eSpheresNV : return "SpheresNV"; - case GeometryTypeKHR::eLinearSweptSpheresNV: return "LinearSweptSpheresNV"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case GeometryTypeKHR::eDenseGeometryFormatTrianglesAMDX: return "DenseGeometryFormatTrianglesAMDX"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureCompatibilityKHR value ) - { - switch ( value ) - { - case AccelerationStructureCompatibilityKHR::eCompatible : return "Compatible"; - case AccelerationStructureCompatibilityKHR::eIncompatible: return "Incompatible"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureCreateFlagBitsKHR value ) - { - switch ( value ) - { - case AccelerationStructureCreateFlagBitsKHR::eDeviceAddressCaptureReplay : return "DeviceAddressCaptureReplay"; - case AccelerationStructureCreateFlagBitsKHR::eDescriptorBufferCaptureReplayEXT: return "DescriptorBufferCaptureReplayEXT"; - case AccelerationStructureCreateFlagBitsKHR::eMotionNV : return "MotionNV"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildAccelerationStructureModeKHR value ) - { - switch ( value ) - { - case BuildAccelerationStructureModeKHR::eBuild : return "Build"; - case BuildAccelerationStructureModeKHR::eUpdate: return "Update"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_ray_tracing_pipeline === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingShaderGroupTypeKHR value ) - { - switch ( value ) - { - case RayTracingShaderGroupTypeKHR::eGeneral : return "General"; - case RayTracingShaderGroupTypeKHR::eTrianglesHitGroup : return "TrianglesHitGroup"; - case RayTracingShaderGroupTypeKHR::eProceduralHitGroup: return "ProceduralHitGroup"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderGroupShaderKHR value ) - { - switch ( value ) - { - case ShaderGroupShaderKHR::eGeneral : return "General"; - case ShaderGroupShaderKHR::eClosestHit : return "ClosestHit"; - case ShaderGroupShaderKHR::eAnyHit : return "AnyHit"; - case ShaderGroupShaderKHR::eIntersection: return "Intersection"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_framebuffer_mixed_samples === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CoverageModulationModeNV value ) - { - switch ( value ) - { - case CoverageModulationModeNV::eNone : return "None"; - case CoverageModulationModeNV::eRgb : return "Rgb"; - case CoverageModulationModeNV::eAlpha: return "Alpha"; - case CoverageModulationModeNV::eRgba : return "Rgba"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageModulationStateCreateFlagBitsNV ) - { - return "(void)"; - } - - //=== VK_EXT_validation_cache === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCacheHeaderVersionEXT value ) - { - switch ( value ) - { - case ValidationCacheHeaderVersionEXT::eOne: return "One"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationCacheCreateFlagBitsEXT ) - { - return "(void)"; - } - - //=== VK_NV_shading_rate_image === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShadingRatePaletteEntryNV value ) - { - switch ( value ) - { - case ShadingRatePaletteEntryNV::eNoInvocations : return "NoInvocations"; - case ShadingRatePaletteEntryNV::e16InvocationsPerPixel : return "16InvocationsPerPixel"; - case ShadingRatePaletteEntryNV::e8InvocationsPerPixel : return "8InvocationsPerPixel"; - case ShadingRatePaletteEntryNV::e4InvocationsPerPixel : return "4InvocationsPerPixel"; - case ShadingRatePaletteEntryNV::e2InvocationsPerPixel : return "2InvocationsPerPixel"; - case ShadingRatePaletteEntryNV::e1InvocationPerPixel : return "1InvocationPerPixel"; - case ShadingRatePaletteEntryNV::e1InvocationPer2X1Pixels: return "1InvocationPer2X1Pixels"; - case ShadingRatePaletteEntryNV::e1InvocationPer1X2Pixels: return "1InvocationPer1X2Pixels"; - case ShadingRatePaletteEntryNV::e1InvocationPer2X2Pixels: return "1InvocationPer2X2Pixels"; - case ShadingRatePaletteEntryNV::e1InvocationPer4X2Pixels: return "1InvocationPer4X2Pixels"; - case ShadingRatePaletteEntryNV::e1InvocationPer2X4Pixels: return "1InvocationPer2X4Pixels"; - case ShadingRatePaletteEntryNV::e1InvocationPer4X4Pixels: return "1InvocationPer4X4Pixels"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CoarseSampleOrderTypeNV value ) - { - switch ( value ) - { - case CoarseSampleOrderTypeNV::eDefault : return "Default"; - case CoarseSampleOrderTypeNV::eCustom : return "Custom"; - case CoarseSampleOrderTypeNV::ePixelMajor : return "PixelMajor"; - case CoarseSampleOrderTypeNV::eSampleMajor: return "SampleMajor"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_ray_tracing === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMemoryRequirementsTypeNV value ) - { - switch ( value ) - { - case AccelerationStructureMemoryRequirementsTypeNV::eObject : return "Object"; - case AccelerationStructureMemoryRequirementsTypeNV::eBuildScratch : return "BuildScratch"; - case AccelerationStructureMemoryRequirementsTypeNV::eUpdateScratch: return "UpdateScratch"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_AMD_pipeline_compiler_control === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCompilerControlFlagBitsAMD ) - { - return "(void)"; - } - - //=== VK_AMD_memory_overallocation_behavior === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryOverallocationBehaviorAMD value ) - { - switch ( value ) - { - case MemoryOverallocationBehaviorAMD::eDefault : return "Default"; - case MemoryOverallocationBehaviorAMD::eAllowed : return "Allowed"; - case MemoryOverallocationBehaviorAMD::eDisallowed: return "Disallowed"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_present_timing === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentStageFlagBitsEXT value ) - { - switch ( value ) - { - case PresentStageFlagBitsEXT::eQueueOperationsEnd : return "QueueOperationsEnd"; - case PresentStageFlagBitsEXT::eRequestDequeued : return "RequestDequeued"; - case PresentStageFlagBitsEXT::eImageFirstPixelOut : return "ImageFirstPixelOut"; - case PresentStageFlagBitsEXT::eImageFirstPixelVisible: return "ImageFirstPixelVisible"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentTimingInfoFlagBitsEXT value ) - { - switch ( value ) - { - case PresentTimingInfoFlagBitsEXT::ePresentAtRelativeTime : return "PresentAtRelativeTime"; - case PresentTimingInfoFlagBitsEXT::ePresentAtNearestRefreshCycle: return "PresentAtNearestRefreshCycle"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PastPresentationTimingFlagBitsEXT value ) - { - switch ( value ) - { - case PastPresentationTimingFlagBitsEXT::eAllowPartialResults : return "AllowPartialResults"; - case PastPresentationTimingFlagBitsEXT::eAllowOutOfOrderResults: return "AllowOutOfOrderResults"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_INTEL_performance_query === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceConfigurationTypeINTEL value ) - { - switch ( value ) - { - case PerformanceConfigurationTypeINTEL::eCommandQueueMetricsDiscoveryActivated: return "CommandQueueMetricsDiscoveryActivated"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( QueryPoolSamplingModeINTEL value ) - { - switch ( value ) - { - case QueryPoolSamplingModeINTEL::eManual: return "Manual"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceOverrideTypeINTEL value ) - { - switch ( value ) - { - case PerformanceOverrideTypeINTEL::eNullHardware : return "NullHardware"; - case PerformanceOverrideTypeINTEL::eFlushGpuCaches: return "FlushGpuCaches"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceParameterTypeINTEL value ) - { - switch ( value ) - { - case PerformanceParameterTypeINTEL::eHwCountersSupported : return "HwCountersSupported"; - case PerformanceParameterTypeINTEL::eStreamMarkerValidBits: return "StreamMarkerValidBits"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceValueTypeINTEL value ) - { - switch ( value ) - { - case PerformanceValueTypeINTEL::eUint32: return "Uint32"; - case PerformanceValueTypeINTEL::eUint64: return "Uint64"; - case PerformanceValueTypeINTEL::eFloat : return "Float"; - case PerformanceValueTypeINTEL::eBool : return "Bool"; - case PerformanceValueTypeINTEL::eString: return "String"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_imagepipe_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImagePipeSurfaceCreateFlagBitsFUCHSIA ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MetalSurfaceCreateFlagBitsEXT ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_KHR_fragment_shading_rate === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FragmentShadingRateCombinerOpKHR value ) - { - switch ( value ) - { - case FragmentShadingRateCombinerOpKHR::eKeep : return "Keep"; - case FragmentShadingRateCombinerOpKHR::eReplace: return "Replace"; - case FragmentShadingRateCombinerOpKHR::eMin : return "Min"; - case FragmentShadingRateCombinerOpKHR::eMax : return "Max"; - case FragmentShadingRateCombinerOpKHR::eMul : return "Mul"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_AMD_shader_core_properties2 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCorePropertiesFlagBitsAMD ) - { - return "(void)"; - } - - //=== VK_EXT_validation_features === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationFeatureEnableEXT value ) - { - switch ( value ) - { - case ValidationFeatureEnableEXT::eGpuAssisted : return "GpuAssisted"; - case ValidationFeatureEnableEXT::eGpuAssistedReserveBindingSlot: return "GpuAssistedReserveBindingSlot"; - case ValidationFeatureEnableEXT::eBestPractices : return "BestPractices"; - case ValidationFeatureEnableEXT::eDebugPrintf : return "DebugPrintf"; - case ValidationFeatureEnableEXT::eSynchronizationValidation : return "SynchronizationValidation"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ValidationFeatureDisableEXT value ) - { - switch ( value ) - { - case ValidationFeatureDisableEXT::eAll : return "All"; - case ValidationFeatureDisableEXT::eShaders : return "Shaders"; - case ValidationFeatureDisableEXT::eThreadSafety : return "ThreadSafety"; - case ValidationFeatureDisableEXT::eApiParameters : return "ApiParameters"; - case ValidationFeatureDisableEXT::eObjectLifetimes : return "ObjectLifetimes"; - case ValidationFeatureDisableEXT::eCoreChecks : return "CoreChecks"; - case ValidationFeatureDisableEXT::eUniqueHandles : return "UniqueHandles"; - case ValidationFeatureDisableEXT::eShaderValidationCache: return "ShaderValidationCache"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_coverage_reduction_mode === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CoverageReductionModeNV value ) - { - switch ( value ) - { - case CoverageReductionModeNV::eMerge : return "Merge"; - case CoverageReductionModeNV::eTruncate: return "Truncate"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineCoverageReductionStateCreateFlagBitsNV ) - { - return "(void)"; - } - - //=== VK_EXT_provoking_vertex === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ProvokingVertexModeEXT value ) - { - switch ( value ) - { - case ProvokingVertexModeEXT::eFirstVertex: return "FirstVertex"; - case ProvokingVertexModeEXT::eLastVertex : return "LastVertex"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -#if defined( VK_USE_PLATFORM_WIN32_KHR ) - //=== VK_EXT_full_screen_exclusive === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FullScreenExclusiveEXT value ) - { - switch ( value ) - { - case FullScreenExclusiveEXT::eDefault : return "Default"; - case FullScreenExclusiveEXT::eAllowed : return "Allowed"; - case FullScreenExclusiveEXT::eDisallowed : return "Disallowed"; - case FullScreenExclusiveEXT::eApplicationControlled: return "ApplicationControlled"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } -#endif /*VK_USE_PLATFORM_WIN32_KHR*/ - - //=== VK_EXT_headless_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( HeadlessSurfaceCreateFlagBitsEXT ) - { - return "(void)"; - } - - //=== VK_KHR_pipeline_executable_properties === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PipelineExecutableStatisticFormatKHR value ) - { - switch ( value ) - { - case PipelineExecutableStatisticFormatKHR::eBool32 : return "Bool32"; - case PipelineExecutableStatisticFormatKHR::eInt64 : return "Int64"; - case PipelineExecutableStatisticFormatKHR::eUint64 : return "Uint64"; - case PipelineExecutableStatisticFormatKHR::eFloat64: return "Float64"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_device_generated_commands === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectStateFlagBitsNV value ) - { - switch ( value ) - { - case IndirectStateFlagBitsNV::eFlagFrontface: return "FlagFrontface"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsTokenTypeNV value ) - { - switch ( value ) - { - case IndirectCommandsTokenTypeNV::eShaderGroup : return "ShaderGroup"; - case IndirectCommandsTokenTypeNV::eStateFlags : return "StateFlags"; - case IndirectCommandsTokenTypeNV::eIndexBuffer : return "IndexBuffer"; - case IndirectCommandsTokenTypeNV::eVertexBuffer : return "VertexBuffer"; - case IndirectCommandsTokenTypeNV::ePushConstant : return "PushConstant"; - case IndirectCommandsTokenTypeNV::eDrawIndexed : return "DrawIndexed"; - case IndirectCommandsTokenTypeNV::eDraw : return "Draw"; - case IndirectCommandsTokenTypeNV::eDrawTasks : return "DrawTasks"; - case IndirectCommandsTokenTypeNV::ePushData : return "PushData"; - case IndirectCommandsTokenTypeNV::eDrawMeshTasks: return "DrawMeshTasks"; - case IndirectCommandsTokenTypeNV::ePipeline : return "Pipeline"; - case IndirectCommandsTokenTypeNV::eDispatch : return "Dispatch"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsLayoutUsageFlagBitsNV value ) - { - switch ( value ) - { - case IndirectCommandsLayoutUsageFlagBitsNV::eExplicitPreprocess: return "ExplicitPreprocess"; - case IndirectCommandsLayoutUsageFlagBitsNV::eIndexedSequences : return "IndexedSequences"; - case IndirectCommandsLayoutUsageFlagBitsNV::eUnorderedSequences: return "UnorderedSequences"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_depth_bias_control === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DepthBiasRepresentationEXT value ) - { - switch ( value ) - { - case DepthBiasRepresentationEXT::eLeastRepresentableValueFormat : return "LeastRepresentableValueFormat"; - case DepthBiasRepresentationEXT::eLeastRepresentableValueForceUnorm: return "LeastRepresentableValueForceUnorm"; - case DepthBiasRepresentationEXT::eFloat : return "Float"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_device_memory_report === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceMemoryReportEventTypeEXT value ) - { - switch ( value ) - { - case DeviceMemoryReportEventTypeEXT::eAllocate : return "Allocate"; - case DeviceMemoryReportEventTypeEXT::eFree : return "Free"; - case DeviceMemoryReportEventTypeEXT::eImport : return "Import"; - case DeviceMemoryReportEventTypeEXT::eUnimport : return "Unimport"; - case DeviceMemoryReportEventTypeEXT::eAllocationFailed: return "AllocationFailed"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceMemoryReportFlagBitsEXT ) - { - return "(void)"; - } - - //=== VK_KHR_video_encode_queue === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeCapabilityFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeCapabilityFlagBitsKHR::ePrecedingExternallyEncodedBytes : return "PrecedingExternallyEncodedBytes"; - case VideoEncodeCapabilityFlagBitsKHR::eInsufficientBitstreamBufferRangeDetection: return "InsufficientBitstreamBufferRangeDetection"; - case VideoEncodeCapabilityFlagBitsKHR::eQuantizationDeltaMap : return "QuantizationDeltaMap"; - case VideoEncodeCapabilityFlagBitsKHR::eEmphasisMap : return "EmphasisMap"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeFeedbackFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeFeedbackFlagBitsKHR::eBitstreamBufferOffset: return "BitstreamBufferOffset"; - case VideoEncodeFeedbackFlagBitsKHR::eBitstreamBytesWritten: return "BitstreamBytesWritten"; - case VideoEncodeFeedbackFlagBitsKHR::eBitstreamHasOverrides: return "BitstreamHasOverrides"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeUsageFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeUsageFlagBitsKHR::eDefault : return "Default"; - case VideoEncodeUsageFlagBitsKHR::eTranscoding : return "Transcoding"; - case VideoEncodeUsageFlagBitsKHR::eStreaming : return "Streaming"; - case VideoEncodeUsageFlagBitsKHR::eRecording : return "Recording"; - case VideoEncodeUsageFlagBitsKHR::eConferencing: return "Conferencing"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeContentFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeContentFlagBitsKHR::eDefault : return "Default"; - case VideoEncodeContentFlagBitsKHR::eCamera : return "Camera"; - case VideoEncodeContentFlagBitsKHR::eDesktop : return "Desktop"; - case VideoEncodeContentFlagBitsKHR::eRendered: return "Rendered"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeTuningModeKHR value ) - { - switch ( value ) - { - case VideoEncodeTuningModeKHR::eDefault : return "Default"; - case VideoEncodeTuningModeKHR::eHighQuality : return "HighQuality"; - case VideoEncodeTuningModeKHR::eLowLatency : return "LowLatency"; - case VideoEncodeTuningModeKHR::eUltraLowLatency: return "UltraLowLatency"; - case VideoEncodeTuningModeKHR::eLossless : return "Lossless"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRateControlModeFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeRateControlModeFlagBitsKHR::eDefault : return "Default"; - case VideoEncodeRateControlModeFlagBitsKHR::eDisabled: return "Disabled"; - case VideoEncodeRateControlModeFlagBitsKHR::eCbr : return "Cbr"; - case VideoEncodeRateControlModeFlagBitsKHR::eVbr : return "Vbr"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeFlagBitsKHR::eIntraRefresh : return "IntraRefresh"; - case VideoEncodeFlagBitsKHR::eWithQuantizationDeltaMap: return "WithQuantizationDeltaMap"; - case VideoEncodeFlagBitsKHR::eWithEmphasisMap : return "WithEmphasisMap"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRateControlFlagBitsKHR ) - { - return "(void)"; - } - - //=== VK_NV_device_diagnostics_config === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceDiagnosticsConfigFlagBitsNV value ) - { - switch ( value ) - { - case DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderDebugInfo : return "EnableShaderDebugInfo"; - case DeviceDiagnosticsConfigFlagBitsNV::eEnableResourceTracking : return "EnableResourceTracking"; - case DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints: return "EnableAutomaticCheckpoints"; - case DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting: return "EnableShaderErrorReporting"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_QCOM_tile_shading === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TileShadingRenderPassFlagBitsQCOM value ) - { - switch ( value ) - { - case TileShadingRenderPassFlagBitsQCOM::eEnable : return "Enable"; - case TileShadingRenderPassFlagBitsQCOM::ePerTileExecution: return "PerTileExecution"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -#if defined( VK_USE_PLATFORM_METAL_EXT ) - //=== VK_EXT_metal_objects === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ExportMetalObjectTypeFlagBitsEXT value ) - { - switch ( value ) - { - case ExportMetalObjectTypeFlagBitsEXT::eMetalDevice : return "MetalDevice"; - case ExportMetalObjectTypeFlagBitsEXT::eMetalCommandQueue: return "MetalCommandQueue"; - case ExportMetalObjectTypeFlagBitsEXT::eMetalBuffer : return "MetalBuffer"; - case ExportMetalObjectTypeFlagBitsEXT::eMetalTexture : return "MetalTexture"; - case ExportMetalObjectTypeFlagBitsEXT::eMetalIosurface : return "MetalIosurface"; - case ExportMetalObjectTypeFlagBitsEXT::eMetalSharedEvent : return "MetalSharedEvent"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } -#endif /*VK_USE_PLATFORM_METAL_EXT*/ - - //=== VK_EXT_graphics_pipeline_library === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( GraphicsPipelineLibraryFlagBitsEXT value ) - { - switch ( value ) - { - case GraphicsPipelineLibraryFlagBitsEXT::eVertexInputInterface : return "VertexInputInterface"; - case GraphicsPipelineLibraryFlagBitsEXT::ePreRasterizationShaders: return "PreRasterizationShaders"; - case GraphicsPipelineLibraryFlagBitsEXT::eFragmentShader : return "FragmentShader"; - case GraphicsPipelineLibraryFlagBitsEXT::eFragmentOutputInterface: return "FragmentOutputInterface"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_fragment_shading_rate_enums === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FragmentShadingRateNV value ) - { - switch ( value ) - { - case FragmentShadingRateNV::e1InvocationPerPixel : return "1InvocationPerPixel"; - case FragmentShadingRateNV::e1InvocationPer1X2Pixels: return "1InvocationPer1X2Pixels"; - case FragmentShadingRateNV::e1InvocationPer2X1Pixels: return "1InvocationPer2X1Pixels"; - case FragmentShadingRateNV::e1InvocationPer2X2Pixels: return "1InvocationPer2X2Pixels"; - case FragmentShadingRateNV::e1InvocationPer2X4Pixels: return "1InvocationPer2X4Pixels"; - case FragmentShadingRateNV::e1InvocationPer4X2Pixels: return "1InvocationPer4X2Pixels"; - case FragmentShadingRateNV::e1InvocationPer4X4Pixels: return "1InvocationPer4X4Pixels"; - case FragmentShadingRateNV::e2InvocationsPerPixel : return "2InvocationsPerPixel"; - case FragmentShadingRateNV::e4InvocationsPerPixel : return "4InvocationsPerPixel"; - case FragmentShadingRateNV::e8InvocationsPerPixel : return "8InvocationsPerPixel"; - case FragmentShadingRateNV::e16InvocationsPerPixel : return "16InvocationsPerPixel"; - case FragmentShadingRateNV::eNoInvocations : return "NoInvocations"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FragmentShadingRateTypeNV value ) - { - switch ( value ) - { - case FragmentShadingRateTypeNV::eFragmentSize: return "FragmentSize"; - case FragmentShadingRateTypeNV::eEnums : return "Enums"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_ray_tracing_motion_blur === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInstanceTypeNV value ) - { - switch ( value ) - { - case AccelerationStructureMotionInstanceTypeNV::eStatic : return "Static"; - case AccelerationStructureMotionInstanceTypeNV::eMatrixMotion: return "MatrixMotion"; - case AccelerationStructureMotionInstanceTypeNV::eSrtMotion : return "SrtMotion"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInfoFlagBitsNV ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccelerationStructureMotionInstanceFlagBitsNV ) - { - return "(void)"; - } - - //=== VK_EXT_image_compression_control === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageCompressionFlagBitsEXT value ) - { - switch ( value ) - { - case ImageCompressionFlagBitsEXT::eDefault : return "Default"; - case ImageCompressionFlagBitsEXT::eFixedRateDefault : return "FixedRateDefault"; - case ImageCompressionFlagBitsEXT::eFixedRateExplicit: return "FixedRateExplicit"; - case ImageCompressionFlagBitsEXT::eDisabled : return "Disabled"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageCompressionFixedRateFlagBitsEXT value ) - { - switch ( value ) - { - case ImageCompressionFixedRateFlagBitsEXT::eNone : return "None"; - case ImageCompressionFixedRateFlagBitsEXT::e1Bpc : return "1Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e2Bpc : return "2Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e3Bpc : return "3Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e4Bpc : return "4Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e5Bpc : return "5Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e6Bpc : return "6Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e7Bpc : return "7Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e8Bpc : return "8Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e9Bpc : return "9Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e10Bpc: return "10Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e11Bpc: return "11Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e12Bpc: return "12Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e13Bpc: return "13Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e14Bpc: return "14Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e15Bpc: return "15Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e16Bpc: return "16Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e17Bpc: return "17Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e18Bpc: return "18Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e19Bpc: return "19Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e20Bpc: return "20Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e21Bpc: return "21Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e22Bpc: return "22Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e23Bpc: return "23Bpc"; - case ImageCompressionFixedRateFlagBitsEXT::e24Bpc: return "24Bpc"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_device_fault === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceFaultAddressTypeEXT value ) - { - switch ( value ) - { - case DeviceFaultAddressTypeEXT::eNone : return "None"; - case DeviceFaultAddressTypeEXT::eReadInvalid : return "ReadInvalid"; - case DeviceFaultAddressTypeEXT::eWriteInvalid : return "WriteInvalid"; - case DeviceFaultAddressTypeEXT::eExecuteInvalid : return "ExecuteInvalid"; - case DeviceFaultAddressTypeEXT::eInstructionPointerUnknown: return "InstructionPointerUnknown"; - case DeviceFaultAddressTypeEXT::eInstructionPointerInvalid: return "InstructionPointerInvalid"; - case DeviceFaultAddressTypeEXT::eInstructionPointerFault : return "InstructionPointerFault"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceFaultVendorBinaryHeaderVersionEXT value ) - { - switch ( value ) - { - case DeviceFaultVendorBinaryHeaderVersionEXT::eOne: return "One"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) - //=== VK_EXT_directfb_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectFBSurfaceCreateFlagBitsEXT ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ - - //=== VK_EXT_device_address_binding_report === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceAddressBindingFlagBitsEXT value ) - { - switch ( value ) - { - case DeviceAddressBindingFlagBitsEXT::eInternalObject: return "InternalObject"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DeviceAddressBindingTypeEXT value ) - { - switch ( value ) - { - case DeviceAddressBindingTypeEXT::eBind : return "Bind"; - case DeviceAddressBindingTypeEXT::eUnbind: return "Unbind"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -#if defined( VK_USE_PLATFORM_FUCHSIA ) - //=== VK_FUCHSIA_buffer_collection === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageConstraintsInfoFlagBitsFUCHSIA value ) - { - switch ( value ) - { - case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadRarely : return "CpuReadRarely"; - case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuReadOften : return "CpuReadOften"; - case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteRarely : return "CpuWriteRarely"; - case ImageConstraintsInfoFlagBitsFUCHSIA::eCpuWriteOften : return "CpuWriteOften"; - case ImageConstraintsInfoFlagBitsFUCHSIA::eProtectedOptional: return "ProtectedOptional"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ImageFormatConstraintsFlagBitsFUCHSIA ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_FUCHSIA*/ - - //=== VK_EXT_frame_boundary === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( FrameBoundaryFlagBitsEXT value ) - { - switch ( value ) - { - case FrameBoundaryFlagBitsEXT::eFrameEnd: return "FrameEnd"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -#if defined( VK_USE_PLATFORM_SCREEN_QNX ) - //=== VK_QNX_screen_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ScreenSurfaceCreateFlagBitsQNX ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ - - //=== VK_VALVE_video_encode_rgb_conversion === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbModelConversionFlagBitsVALVE value ) - { - switch ( value ) - { - case VideoEncodeRgbModelConversionFlagBitsVALVE::eRgbIdentity : return "RgbIdentity"; - case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcrIdentity: return "YcbcrIdentity"; - case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr709 : return "Ycbcr709"; - case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr601 : return "Ycbcr601"; - case VideoEncodeRgbModelConversionFlagBitsVALVE::eYcbcr2020 : return "Ycbcr2020"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbRangeCompressionFlagBitsVALVE value ) - { - switch ( value ) - { - case VideoEncodeRgbRangeCompressionFlagBitsVALVE::eFullRange : return "FullRange"; - case VideoEncodeRgbRangeCompressionFlagBitsVALVE::eNarrowRange: return "NarrowRange"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeRgbChromaOffsetFlagBitsVALVE value ) - { - switch ( value ) - { - case VideoEncodeRgbChromaOffsetFlagBitsVALVE::eCositedEven: return "CositedEven"; - case VideoEncodeRgbChromaOffsetFlagBitsVALVE::eMidpoint : return "Midpoint"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_opacity_micromap === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MicromapTypeEXT value ) - { - switch ( value ) - { - case MicromapTypeEXT::eOpacityMicromap: return "OpacityMicromap"; -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - case MicromapTypeEXT::eDisplacementMicromapNV: return "DisplacementMicromapNV"; -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - default: return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildMicromapFlagBitsEXT value ) - { - switch ( value ) - { - case BuildMicromapFlagBitsEXT::ePreferFastTrace: return "PreferFastTrace"; - case BuildMicromapFlagBitsEXT::ePreferFastBuild: return "PreferFastBuild"; - case BuildMicromapFlagBitsEXT::eAllowCompaction: return "AllowCompaction"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CopyMicromapModeEXT value ) - { - switch ( value ) - { - case CopyMicromapModeEXT::eClone : return "Clone"; - case CopyMicromapModeEXT::eSerialize : return "Serialize"; - case CopyMicromapModeEXT::eDeserialize: return "Deserialize"; - case CopyMicromapModeEXT::eCompact : return "Compact"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MicromapCreateFlagBitsEXT value ) - { - switch ( value ) - { - case MicromapCreateFlagBitsEXT::eDeviceAddressCaptureReplay: return "DeviceAddressCaptureReplay"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BuildMicromapModeEXT value ) - { - switch ( value ) - { - case BuildMicromapModeEXT::eBuild: return "Build"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpacityMicromapFormatEXT value ) - { - switch ( value ) - { - case OpacityMicromapFormatEXT::e2State: return "2State"; - case OpacityMicromapFormatEXT::e4State: return "4State"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpacityMicromapSpecialIndexEXT value ) - { - switch ( value ) - { - case OpacityMicromapSpecialIndexEXT::eFullyTransparent : return "FullyTransparent"; - case OpacityMicromapSpecialIndexEXT::eFullyOpaque : return "FullyOpaque"; - case OpacityMicromapSpecialIndexEXT::eFullyUnknownTransparent : return "FullyUnknownTransparent"; - case OpacityMicromapSpecialIndexEXT::eFullyUnknownOpaque : return "FullyUnknownOpaque"; - case OpacityMicromapSpecialIndexEXT::eClusterGeometryDisableOpacityMicromapNV: return "ClusterGeometryDisableOpacityMicromapNV"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_NV_displacement_micromap === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplacementMicromapFormatNV value ) - { - switch ( value ) - { - case DisplacementMicromapFormatNV::e64Triangles64Bytes : return "64Triangles64Bytes"; - case DisplacementMicromapFormatNV::e256Triangles128Bytes : return "256Triangles128Bytes"; - case DisplacementMicromapFormatNV::e1024Triangles128Bytes: return "1024Triangles128Bytes"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_ARM_scheduling_controls === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceSchedulingControlsFlagBitsARM value ) - { - switch ( value ) - { - case PhysicalDeviceSchedulingControlsFlagBitsARM::eShaderCoreCount: return "ShaderCoreCount"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_ray_tracing_linear_swept_spheres === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingLssIndexingModeNV value ) - { - switch ( value ) - { - case RayTracingLssIndexingModeNV::eList : return "List"; - case RayTracingLssIndexingModeNV::eSuccessive: return "Successive"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingLssPrimitiveEndCapsModeNV value ) - { - switch ( value ) - { - case RayTracingLssPrimitiveEndCapsModeNV::eNone : return "None"; - case RayTracingLssPrimitiveEndCapsModeNV::eChained: return "Chained"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_subpass_merge_feedback === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SubpassMergeStatusEXT value ) - { - switch ( value ) - { - case SubpassMergeStatusEXT::eMerged : return "Merged"; - case SubpassMergeStatusEXT::eDisallowed : return "Disallowed"; - case SubpassMergeStatusEXT::eNotMergedSideEffects : return "NotMergedSideEffects"; - case SubpassMergeStatusEXT::eNotMergedSamplesMismatch : return "NotMergedSamplesMismatch"; - case SubpassMergeStatusEXT::eNotMergedViewsMismatch : return "NotMergedViewsMismatch"; - case SubpassMergeStatusEXT::eNotMergedAliasing : return "NotMergedAliasing"; - case SubpassMergeStatusEXT::eNotMergedDependencies : return "NotMergedDependencies"; - case SubpassMergeStatusEXT::eNotMergedIncompatibleInputAttachment: return "NotMergedIncompatibleInputAttachment"; - case SubpassMergeStatusEXT::eNotMergedTooManyAttachments : return "NotMergedTooManyAttachments"; - case SubpassMergeStatusEXT::eNotMergedInsufficientStorage : return "NotMergedInsufficientStorage"; - case SubpassMergeStatusEXT::eNotMergedDepthStencilCount : return "NotMergedDepthStencilCount"; - case SubpassMergeStatusEXT::eNotMergedResolveAttachmentReuse : return "NotMergedResolveAttachmentReuse"; - case SubpassMergeStatusEXT::eNotMergedSingleSubpass : return "NotMergedSingleSubpass"; - case SubpassMergeStatusEXT::eNotMergedUnspecified : return "NotMergedUnspecified"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_LUNARG_direct_driver_loading === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectDriverLoadingModeLUNARG value ) - { - switch ( value ) - { - case DirectDriverLoadingModeLUNARG::eExclusive: return "Exclusive"; - case DirectDriverLoadingModeLUNARG::eInclusive: return "Inclusive"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DirectDriverLoadingFlagBitsLUNARG ) - { - return "(void)"; - } - - //=== VK_ARM_tensors === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorCreateFlagBitsARM value ) - { - switch ( value ) - { - case TensorCreateFlagBitsARM::eMutableFormat : return "MutableFormat"; - case TensorCreateFlagBitsARM::eProtected : return "Protected"; - case TensorCreateFlagBitsARM::eDescriptorHeapCaptureReplay : return "DescriptorHeapCaptureReplay"; - case TensorCreateFlagBitsARM::eDescriptorBufferCaptureReplay: return "DescriptorBufferCaptureReplay"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorUsageFlagBitsARM value ) - { - switch ( value ) - { - case TensorUsageFlagBitsARM::eShader : return "Shader"; - case TensorUsageFlagBitsARM::eTransferSrc : return "TransferSrc"; - case TensorUsageFlagBitsARM::eTransferDst : return "TransferDst"; - case TensorUsageFlagBitsARM::eImageAliasing: return "ImageAliasing"; - case TensorUsageFlagBitsARM::eDataGraph : return "DataGraph"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TensorTilingARM value ) - { - switch ( value ) - { - case TensorTilingARM::eOptimal: return "Optimal"; - case TensorTilingARM::eLinear : return "Linear"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_optical_flow === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowUsageFlagBitsNV value ) - { - switch ( value ) - { - case OpticalFlowUsageFlagBitsNV::eUnknown : return "Unknown"; - case OpticalFlowUsageFlagBitsNV::eInput : return "Input"; - case OpticalFlowUsageFlagBitsNV::eOutput : return "Output"; - case OpticalFlowUsageFlagBitsNV::eHint : return "Hint"; - case OpticalFlowUsageFlagBitsNV::eCost : return "Cost"; - case OpticalFlowUsageFlagBitsNV::eGlobalFlow: return "GlobalFlow"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowGridSizeFlagBitsNV value ) - { - switch ( value ) - { - case OpticalFlowGridSizeFlagBitsNV::eUnknown: return "Unknown"; - case OpticalFlowGridSizeFlagBitsNV::e1X1 : return "1X1"; - case OpticalFlowGridSizeFlagBitsNV::e2X2 : return "2X2"; - case OpticalFlowGridSizeFlagBitsNV::e4X4 : return "4X4"; - case OpticalFlowGridSizeFlagBitsNV::e8X8 : return "8X8"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowPerformanceLevelNV value ) - { - switch ( value ) - { - case OpticalFlowPerformanceLevelNV::eUnknown: return "Unknown"; - case OpticalFlowPerformanceLevelNV::eSlow : return "Slow"; - case OpticalFlowPerformanceLevelNV::eMedium : return "Medium"; - case OpticalFlowPerformanceLevelNV::eFast : return "Fast"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowSessionBindingPointNV value ) - { - switch ( value ) - { - case OpticalFlowSessionBindingPointNV::eUnknown : return "Unknown"; - case OpticalFlowSessionBindingPointNV::eInput : return "Input"; - case OpticalFlowSessionBindingPointNV::eReference : return "Reference"; - case OpticalFlowSessionBindingPointNV::eHint : return "Hint"; - case OpticalFlowSessionBindingPointNV::eFlowVector : return "FlowVector"; - case OpticalFlowSessionBindingPointNV::eBackwardFlowVector: return "BackwardFlowVector"; - case OpticalFlowSessionBindingPointNV::eCost : return "Cost"; - case OpticalFlowSessionBindingPointNV::eBackwardCost : return "BackwardCost"; - case OpticalFlowSessionBindingPointNV::eGlobalFlow : return "GlobalFlow"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowSessionCreateFlagBitsNV value ) - { - switch ( value ) - { - case OpticalFlowSessionCreateFlagBitsNV::eEnableHint : return "EnableHint"; - case OpticalFlowSessionCreateFlagBitsNV::eEnableCost : return "EnableCost"; - case OpticalFlowSessionCreateFlagBitsNV::eEnableGlobalFlow: return "EnableGlobalFlow"; - case OpticalFlowSessionCreateFlagBitsNV::eAllowRegions : return "AllowRegions"; - case OpticalFlowSessionCreateFlagBitsNV::eBothDirections : return "BothDirections"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OpticalFlowExecuteFlagBitsNV value ) - { - switch ( value ) - { - case OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints: return "DisableTemporalHints"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_AMD_anti_lag === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AntiLagModeAMD value ) - { - switch ( value ) - { - case AntiLagModeAMD::eDriverControl: return "DriverControl"; - case AntiLagModeAMD::eOn : return "On"; - case AntiLagModeAMD::eOff : return "Off"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AntiLagStageAMD value ) - { - switch ( value ) - { - case AntiLagStageAMD::eInput : return "Input"; - case AntiLagStageAMD::ePresent: return "Present"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -#if defined( VK_ENABLE_BETA_EXTENSIONS ) - //=== VK_AMDX_dense_geometry_format === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CompressedTriangleFormatAMDX value ) - { - switch ( value ) - { - case CompressedTriangleFormatAMDX::eDgf1: return "Dgf1"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } -#endif /*VK_ENABLE_BETA_EXTENSIONS*/ - - //=== VK_EXT_shader_object === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCreateFlagBitsEXT value ) - { - switch ( value ) - { - case ShaderCreateFlagBitsEXT::eLinkStage : return "LinkStage"; - case ShaderCreateFlagBitsEXT::eDescriptorHeap : return "DescriptorHeap"; - case ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize : return "AllowVaryingSubgroupSize"; - case ShaderCreateFlagBitsEXT::eRequireFullSubgroups : return "RequireFullSubgroups"; - case ShaderCreateFlagBitsEXT::eNoTaskShader : return "NoTaskShader"; - case ShaderCreateFlagBitsEXT::eDispatchBase : return "DispatchBase"; - case ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment: return "FragmentShadingRateAttachment"; - case ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment : return "FragmentDensityMapAttachment"; - case ShaderCreateFlagBitsEXT::eIndirectBindable : return "IndirectBindable"; - case ShaderCreateFlagBitsEXT::e64BitIndexing : return "64BitIndexing"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ShaderCodeTypeEXT value ) - { - switch ( value ) - { - case ShaderCodeTypeEXT::eBinary: return "Binary"; - case ShaderCodeTypeEXT::eSpirv : return "Spirv"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_surface_maintenance1 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentScalingFlagBitsKHR value ) - { - switch ( value ) - { - case PresentScalingFlagBitsKHR::eOneToOne : return "OneToOne"; - case PresentScalingFlagBitsKHR::eAspectRatioStretch: return "AspectRatioStretch"; - case PresentScalingFlagBitsKHR::eStretch : return "Stretch"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PresentGravityFlagBitsKHR value ) - { - switch ( value ) - { - case PresentGravityFlagBitsKHR::eMin : return "Min"; - case PresentGravityFlagBitsKHR::eMax : return "Max"; - case PresentGravityFlagBitsKHR::eCentered: return "Centered"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_cooperative_vector === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CooperativeVectorMatrixLayoutNV value ) - { - switch ( value ) - { - case CooperativeVectorMatrixLayoutNV::eRowMajor : return "RowMajor"; - case CooperativeVectorMatrixLayoutNV::eColumnMajor : return "ColumnMajor"; - case CooperativeVectorMatrixLayoutNV::eInferencingOptimal: return "InferencingOptimal"; - case CooperativeVectorMatrixLayoutNV::eTrainingOptimal : return "TrainingOptimal"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ComponentTypeKHR value ) - { - switch ( value ) - { - case ComponentTypeKHR::eFloat16 : return "Float16"; - case ComponentTypeKHR::eFloat32 : return "Float32"; - case ComponentTypeKHR::eFloat64 : return "Float64"; - case ComponentTypeKHR::eSint8 : return "Sint8"; - case ComponentTypeKHR::eSint16 : return "Sint16"; - case ComponentTypeKHR::eSint32 : return "Sint32"; - case ComponentTypeKHR::eSint64 : return "Sint64"; - case ComponentTypeKHR::eUint8 : return "Uint8"; - case ComponentTypeKHR::eUint16 : return "Uint16"; - case ComponentTypeKHR::eUint32 : return "Uint32"; - case ComponentTypeKHR::eUint64 : return "Uint64"; - case ComponentTypeKHR::eBfloat16 : return "Bfloat16"; - case ComponentTypeKHR::eSint8PackedNV: return "Sint8PackedNV"; - case ComponentTypeKHR::eUint8PackedNV: return "Uint8PackedNV"; - case ComponentTypeKHR::eFloat8E4M3EXT: return "Float8E4M3EXT"; - case ComponentTypeKHR::eFloat8E5M2EXT: return "Float8E5M2EXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_layer_settings === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LayerSettingTypeEXT value ) - { - switch ( value ) - { - case LayerSettingTypeEXT::eBool32 : return "Bool32"; - case LayerSettingTypeEXT::eInt32 : return "Int32"; - case LayerSettingTypeEXT::eInt64 : return "Int64"; - case LayerSettingTypeEXT::eUint32 : return "Uint32"; - case LayerSettingTypeEXT::eUint64 : return "Uint64"; - case LayerSettingTypeEXT::eFloat32: return "Float32"; - case LayerSettingTypeEXT::eFloat64: return "Float64"; - case LayerSettingTypeEXT::eString : return "String"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_low_latency2 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LatencyMarkerNV value ) - { - switch ( value ) - { - case LatencyMarkerNV::eSimulationStart : return "SimulationStart"; - case LatencyMarkerNV::eSimulationEnd : return "SimulationEnd"; - case LatencyMarkerNV::eRendersubmitStart : return "RendersubmitStart"; - case LatencyMarkerNV::eRendersubmitEnd : return "RendersubmitEnd"; - case LatencyMarkerNV::ePresentStart : return "PresentStart"; - case LatencyMarkerNV::ePresentEnd : return "PresentEnd"; - case LatencyMarkerNV::eInputSample : return "InputSample"; - case LatencyMarkerNV::eTriggerFlash : return "TriggerFlash"; - case LatencyMarkerNV::eOutOfBandRendersubmitStart: return "OutOfBandRendersubmitStart"; - case LatencyMarkerNV::eOutOfBandRendersubmitEnd : return "OutOfBandRendersubmitEnd"; - case LatencyMarkerNV::eOutOfBandPresentStart : return "OutOfBandPresentStart"; - case LatencyMarkerNV::eOutOfBandPresentEnd : return "OutOfBandPresentEnd"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( OutOfBandQueueTypeNV value ) - { - switch ( value ) - { - case OutOfBandQueueTypeNV::eRender : return "Render"; - case OutOfBandQueueTypeNV::ePresent: return "Present"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_cooperative_matrix === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ScopeKHR value ) - { - switch ( value ) - { - case ScopeKHR::eDevice : return "Device"; - case ScopeKHR::eWorkgroup : return "Workgroup"; - case ScopeKHR::eSubgroup : return "Subgroup"; - case ScopeKHR::eQueueFamily: return "QueueFamily"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_ARM_data_graph === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineSessionBindPointARM value ) - { - switch ( value ) - { - case DataGraphPipelineSessionBindPointARM::eTransient: return "Transient"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineSessionBindPointTypeARM value ) - { - switch ( value ) - { - case DataGraphPipelineSessionBindPointTypeARM::eMemory: return "Memory"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineSessionCreateFlagBitsARM value ) - { - switch ( value ) - { - case DataGraphPipelineSessionCreateFlagBitsARM::eProtected: return "Protected"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelinePropertyARM value ) - { - switch ( value ) - { - case DataGraphPipelinePropertyARM::eCreationLog: return "CreationLog"; - case DataGraphPipelinePropertyARM::eIdentifier : return "Identifier"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphPipelineDispatchFlagBitsARM ) - { - return "(void)"; - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceDataGraphProcessingEngineTypeARM value ) - { - switch ( value ) - { - case PhysicalDeviceDataGraphProcessingEngineTypeARM::eDefault : return "Default"; - case PhysicalDeviceDataGraphProcessingEngineTypeARM::eNeuralQCOM : return "NeuralQCOM"; - case PhysicalDeviceDataGraphProcessingEngineTypeARM::eComputeQCOM: return "ComputeQCOM"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceDataGraphOperationTypeARM value ) - { - switch ( value ) - { - case PhysicalDeviceDataGraphOperationTypeARM::eSpirvExtendedInstructionSet: return "SpirvExtendedInstructionSet"; - case PhysicalDeviceDataGraphOperationTypeARM::eNeuralModelQCOM : return "NeuralModelQCOM"; - case PhysicalDeviceDataGraphOperationTypeARM::eBuiltinModelQCOM : return "BuiltinModelQCOM"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_video_encode_av1 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1PredictionModeKHR value ) - { - switch ( value ) - { - case VideoEncodeAV1PredictionModeKHR::eIntraOnly : return "IntraOnly"; - case VideoEncodeAV1PredictionModeKHR::eSingleReference : return "SingleReference"; - case VideoEncodeAV1PredictionModeKHR::eUnidirectionalCompound: return "UnidirectionalCompound"; - case VideoEncodeAV1PredictionModeKHR::eBidirectionalCompound : return "BidirectionalCompound"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1RateControlGroupKHR value ) - { - switch ( value ) - { - case VideoEncodeAV1RateControlGroupKHR::eIntra : return "Intra"; - case VideoEncodeAV1RateControlGroupKHR::ePredictive : return "Predictive"; - case VideoEncodeAV1RateControlGroupKHR::eBipredictive: return "Bipredictive"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1CapabilityFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeAV1CapabilityFlagBitsKHR::ePerRateControlGroupMinMaxQIndex: return "PerRateControlGroupMinMaxQIndex"; - case VideoEncodeAV1CapabilityFlagBitsKHR::eGenerateObuExtensionHeader : return "GenerateObuExtensionHeader"; - case VideoEncodeAV1CapabilityFlagBitsKHR::ePrimaryReferenceCdfOnly : return "PrimaryReferenceCdfOnly"; - case VideoEncodeAV1CapabilityFlagBitsKHR::eFrameSizeOverride : return "FrameSizeOverride"; - case VideoEncodeAV1CapabilityFlagBitsKHR::eMotionVectorScaling : return "MotionVectorScaling"; - case VideoEncodeAV1CapabilityFlagBitsKHR::eCompoundPredictionIntraRefresh : return "CompoundPredictionIntraRefresh"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1StdFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeAV1StdFlagBitsKHR::eUniformTileSpacingFlagSet: return "UniformTileSpacingFlagSet"; - case VideoEncodeAV1StdFlagBitsKHR::eSkipModePresentUnset : return "SkipModePresentUnset"; - case VideoEncodeAV1StdFlagBitsKHR::ePrimaryRefFrame : return "PrimaryRefFrame"; - case VideoEncodeAV1StdFlagBitsKHR::eDeltaQ : return "DeltaQ"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1SuperblockSizeFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeAV1SuperblockSizeFlagBitsKHR::e64 : return "64"; - case VideoEncodeAV1SuperblockSizeFlagBitsKHR::e128: return "128"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeAV1RateControlFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeAV1RateControlFlagBitsKHR::eRegularGop : return "RegularGop"; - case VideoEncodeAV1RateControlFlagBitsKHR::eTemporalLayerPatternDyadic: return "TemporalLayerPatternDyadic"; - case VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternFlat : return "ReferencePatternFlat"; - case VideoEncodeAV1RateControlFlagBitsKHR::eReferencePatternDyadic : return "ReferencePatternDyadic"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_QCOM_image_processing2 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( BlockMatchWindowCompareModeQCOM value ) - { - switch ( value ) - { - case BlockMatchWindowCompareModeQCOM::eMin: return "Min"; - case BlockMatchWindowCompareModeQCOM::eMax: return "Max"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_QCOM_filter_cubic_weights === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( CubicFilterWeightsQCOM value ) - { - switch ( value ) - { - case CubicFilterWeightsQCOM::eCatmullRom : return "CatmullRom"; - case CubicFilterWeightsQCOM::eZeroTangentCardinal: return "ZeroTangentCardinal"; - case CubicFilterWeightsQCOM::eBSpline : return "BSpline"; - case CubicFilterWeightsQCOM::eMitchellNetravali : return "MitchellNetravali"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_MSFT_layered_driver === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( LayeredDriverUnderlyingApiMSFT value ) - { - switch ( value ) - { - case LayeredDriverUnderlyingApiMSFT::eNone : return "None"; - case LayeredDriverUnderlyingApiMSFT::eD3D12: return "D3D12"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_calibrated_timestamps === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TimeDomainKHR value ) - { - switch ( value ) - { - case TimeDomainKHR::eDevice : return "Device"; - case TimeDomainKHR::eClockMonotonic : return "ClockMonotonic"; - case TimeDomainKHR::eClockMonotonicRaw : return "ClockMonotonicRaw"; - case TimeDomainKHR::eQueryPerformanceCounter: return "QueryPerformanceCounter"; - case TimeDomainKHR::ePresentStageLocalEXT : return "PresentStageLocalEXT"; - case TimeDomainKHR::eSwapchainLocalEXT : return "SwapchainLocalEXT"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_copy_memory_indirect === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AddressCopyFlagBitsKHR value ) - { - switch ( value ) - { - case AddressCopyFlagBitsKHR::eDeviceLocal: return "DeviceLocal"; - case AddressCopyFlagBitsKHR::eSparse : return "Sparse"; - case AddressCopyFlagBitsKHR::eProtected : return "Protected"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_memory_decompression === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( MemoryDecompressionMethodFlagBitsEXT value ) - { - switch ( value ) - { - case MemoryDecompressionMethodFlagBitsEXT::eGdeflate10: return "Gdeflate10"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_display_stereo === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DisplaySurfaceStereoTypeNV value ) - { - switch ( value ) - { - case DisplaySurfaceStereoTypeNV::eNone : return "None"; - case DisplaySurfaceStereoTypeNV::eOnboardDin : return "OnboardDin"; - case DisplaySurfaceStereoTypeNV::eHdmi3D : return "Hdmi3D"; - case DisplaySurfaceStereoTypeNV::eInbandDisplayport: return "InbandDisplayport"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_video_encode_intra_refresh === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( VideoEncodeIntraRefreshModeFlagBitsKHR value ) - { - switch ( value ) - { - case VideoEncodeIntraRefreshModeFlagBitsKHR::eNone : return "None"; - case VideoEncodeIntraRefreshModeFlagBitsKHR::ePerPicturePartition: return "PerPicturePartition"; - case VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockBased : return "BlockBased"; - case VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockRowBased : return "BlockRowBased"; - case VideoEncodeIntraRefreshModeFlagBitsKHR::eBlockColumnBased : return "BlockColumnBased"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_maintenance7 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PhysicalDeviceLayeredApiKHR value ) - { - switch ( value ) - { - case PhysicalDeviceLayeredApiKHR::eVulkan : return "Vulkan"; - case PhysicalDeviceLayeredApiKHR::eD3D12 : return "D3D12"; - case PhysicalDeviceLayeredApiKHR::eMetal : return "Metal"; - case PhysicalDeviceLayeredApiKHR::eOpengl : return "Opengl"; - case PhysicalDeviceLayeredApiKHR::eOpengles: return "Opengles"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_cluster_acceleration_structure === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureClusterFlagBitsNV value ) - { - switch ( value ) - { - case ClusterAccelerationStructureClusterFlagBitsNV::eAllowDisableOpacityMicromaps: return "AllowDisableOpacityMicromaps"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureGeometryFlagBitsNV value ) - { - switch ( value ) - { - case ClusterAccelerationStructureGeometryFlagBitsNV::eCullDisable : return "CullDisable"; - case ClusterAccelerationStructureGeometryFlagBitsNV::eNoDuplicateAnyhitInvocation: return "NoDuplicateAnyhitInvocation"; - case ClusterAccelerationStructureGeometryFlagBitsNV::eOpaque : return "Opaque"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureAddressResolutionFlagBitsNV value ) - { - switch ( value ) - { - case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eNone : return "None"; - case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstImplicitData: return "IndirectedDstImplicitData"; - case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedScratchData : return "IndirectedScratchData"; - case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstAddressArray: return "IndirectedDstAddressArray"; - case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedDstSizesArray : return "IndirectedDstSizesArray"; - case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosArray : return "IndirectedSrcInfosArray"; - case ClusterAccelerationStructureAddressResolutionFlagBitsNV::eIndirectedSrcInfosCount : return "IndirectedSrcInfosCount"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureIndexFormatFlagBitsNV value ) - { - switch ( value ) - { - case ClusterAccelerationStructureIndexFormatFlagBitsNV::e8 : return "8"; - case ClusterAccelerationStructureIndexFormatFlagBitsNV::e16: return "16"; - case ClusterAccelerationStructureIndexFormatFlagBitsNV::e32: return "32"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureTypeNV value ) - { - switch ( value ) - { - case ClusterAccelerationStructureTypeNV::eClustersBottomLevel : return "ClustersBottomLevel"; - case ClusterAccelerationStructureTypeNV::eTriangleCluster : return "TriangleCluster"; - case ClusterAccelerationStructureTypeNV::eTriangleClusterTemplate: return "TriangleClusterTemplate"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureOpTypeNV value ) - { - switch ( value ) - { - case ClusterAccelerationStructureOpTypeNV::eMoveObjects : return "MoveObjects"; - case ClusterAccelerationStructureOpTypeNV::eBuildClustersBottomLevel : return "BuildClustersBottomLevel"; - case ClusterAccelerationStructureOpTypeNV::eBuildTriangleCluster : return "BuildTriangleCluster"; - case ClusterAccelerationStructureOpTypeNV::eBuildTriangleClusterTemplate: return "BuildTriangleClusterTemplate"; - case ClusterAccelerationStructureOpTypeNV::eInstantiateTriangleCluster : return "InstantiateTriangleCluster"; - case ClusterAccelerationStructureOpTypeNV::eGetClusterTemplateIndices : return "GetClusterTemplateIndices"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ClusterAccelerationStructureOpModeNV value ) - { - switch ( value ) - { - case ClusterAccelerationStructureOpModeNV::eImplicitDestinations: return "ImplicitDestinations"; - case ClusterAccelerationStructureOpModeNV::eExplicitDestinations: return "ExplicitDestinations"; - case ClusterAccelerationStructureOpModeNV::eComputeSizes : return "ComputeSizes"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_NV_partitioned_acceleration_structure === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PartitionedAccelerationStructureOpTypeNV value ) - { - switch ( value ) - { - case PartitionedAccelerationStructureOpTypeNV::eWriteInstance : return "WriteInstance"; - case PartitionedAccelerationStructureOpTypeNV::eUpdateInstance : return "UpdateInstance"; - case PartitionedAccelerationStructureOpTypeNV::eWritePartitionTranslation: return "WritePartitionTranslation"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PartitionedAccelerationStructureInstanceFlagBitsNV value ) - { - switch ( value ) - { - case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFacingCullDisable: return "FlagTriangleFacingCullDisable"; - case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagTriangleFlipFacing : return "FlagTriangleFlipFacing"; - case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceOpaque : return "FlagForceOpaque"; - case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagForceNoOpaque : return "FlagForceNoOpaque"; - case PartitionedAccelerationStructureInstanceFlagBitsNV::eFlagEnableExplicitBoundingBox: return "FlagEnableExplicitBoundingBox"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_device_generated_commands === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsTokenTypeEXT value ) - { - switch ( value ) - { - case IndirectCommandsTokenTypeEXT::eExecutionSet : return "ExecutionSet"; - case IndirectCommandsTokenTypeEXT::ePushConstant : return "PushConstant"; - case IndirectCommandsTokenTypeEXT::eSequenceIndex : return "SequenceIndex"; - case IndirectCommandsTokenTypeEXT::eIndexBuffer : return "IndexBuffer"; - case IndirectCommandsTokenTypeEXT::eVertexBuffer : return "VertexBuffer"; - case IndirectCommandsTokenTypeEXT::eDrawIndexed : return "DrawIndexed"; - case IndirectCommandsTokenTypeEXT::eDraw : return "Draw"; - case IndirectCommandsTokenTypeEXT::eDrawIndexedCount : return "DrawIndexedCount"; - case IndirectCommandsTokenTypeEXT::eDrawCount : return "DrawCount"; - case IndirectCommandsTokenTypeEXT::eDispatch : return "Dispatch"; - case IndirectCommandsTokenTypeEXT::ePushData : return "PushData"; - case IndirectCommandsTokenTypeEXT::ePushDataSequenceIndex: return "PushDataSequenceIndex"; - case IndirectCommandsTokenTypeEXT::eDrawMeshTasksNV : return "DrawMeshTasksNV"; - case IndirectCommandsTokenTypeEXT::eDrawMeshTasksCountNV : return "DrawMeshTasksCountNV"; - case IndirectCommandsTokenTypeEXT::eDrawMeshTasks : return "DrawMeshTasks"; - case IndirectCommandsTokenTypeEXT::eDrawMeshTasksCount : return "DrawMeshTasksCount"; - case IndirectCommandsTokenTypeEXT::eTraceRays2 : return "TraceRays2"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectExecutionSetInfoTypeEXT value ) - { - switch ( value ) - { - case IndirectExecutionSetInfoTypeEXT::ePipelines : return "Pipelines"; - case IndirectExecutionSetInfoTypeEXT::eShaderObjects: return "ShaderObjects"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsLayoutUsageFlagBitsEXT value ) - { - switch ( value ) - { - case IndirectCommandsLayoutUsageFlagBitsEXT::eExplicitPreprocess: return "ExplicitPreprocess"; - case IndirectCommandsLayoutUsageFlagBitsEXT::eUnorderedSequences: return "UnorderedSequences"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( IndirectCommandsInputModeFlagBitsEXT value ) - { - switch ( value ) - { - case IndirectCommandsInputModeFlagBitsEXT::eVulkanIndexBuffer: return "VulkanIndexBuffer"; - case IndirectCommandsInputModeFlagBitsEXT::eDxgiIndexBuffer : return "DxgiIndexBuffer"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_maintenance8 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( AccessFlagBits3KHR value ) - { - switch ( value ) - { - case AccessFlagBits3KHR::eNone: return "None"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_ray_tracing_invocation_reorder === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RayTracingInvocationReorderModeEXT value ) - { - switch ( value ) - { - case RayTracingInvocationReorderModeEXT::eNone : return "None"; - case RayTracingInvocationReorderModeEXT::eReorder: return "Reorder"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_EXT_depth_clamp_control === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DepthClampModeEXT value ) - { - switch ( value ) - { - case DepthClampModeEXT::eViewportRange : return "ViewportRange"; - case DepthClampModeEXT::eUserDefinedRange: return "UserDefinedRange"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_maintenance9 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DefaultVertexAttributeValueKHR value ) - { - switch ( value ) - { - case DefaultVertexAttributeValueKHR::eZeroZeroZeroZero: return "ZeroZeroZeroZero"; - case DefaultVertexAttributeValueKHR::eZeroZeroZeroOne : return "ZeroZeroZeroOne"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -#if defined( VK_USE_PLATFORM_OHOS ) - //=== VK_OHOS_surface === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( SurfaceCreateFlagBitsOHOS ) - { - return "(void)"; - } -#endif /*VK_USE_PLATFORM_OHOS*/ - - //=== VK_ARM_performance_counters_by_region === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( PerformanceCounterDescriptionFlagBitsARM ) - { - return "(void)"; - } - - //=== VK_QCOM_data_graph_model === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( DataGraphModelCacheTypeQCOM value ) - { - switch ( value ) - { - case DataGraphModelCacheTypeQCOM::eGenericBinary: return "GenericBinary"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - //=== VK_KHR_maintenance10 === - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( RenderingAttachmentFlagBitsKHR value ) - { - switch ( value ) - { - case RenderingAttachmentFlagBitsKHR::eInputAttachmentFeedback : return "InputAttachmentFeedback"; - case RenderingAttachmentFlagBitsKHR::eResolveSkipTransferFunction : return "ResolveSkipTransferFunction"; - case RenderingAttachmentFlagBitsKHR::eResolveEnableTransferFunction: return "ResolveEnableTransferFunction"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - - VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( ResolveImageFlagBitsKHR value ) - { - switch ( value ) - { - case ResolveImageFlagBitsKHR::eSkipTransferFunction : return "SkipTransferFunction"; - case ResolveImageFlagBitsKHR::eEnableTransferFunction: return "EnableTransferFunction"; - default : return "invalid ( " + toHexString( static_cast( value ) ) + " )"; - } - } - -} // namespace VULKAN_HPP_NAMESPACE - -#if defined( __clang__ ) || defined( __GNUC__ ) -# pragma GCC diagnostic pop -#elif defined( _MSC_VER ) -# pragma warning( pop ) -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_vi.h b/lib/vulkan-headers/include/vulkan/vulkan_vi.h deleted file mode 100644 index 97d1a3c5f9e..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_vi.h +++ /dev/null @@ -1,50 +0,0 @@ -#ifndef VULKAN_VI_H_ -#define VULKAN_VI_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_NN_vi_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_NN_vi_surface 1 -#define VK_NN_VI_SURFACE_SPEC_VERSION 1 -#define VK_NN_VI_SURFACE_EXTENSION_NAME "VK_NN_vi_surface" -typedef VkFlags VkViSurfaceCreateFlagsNN; -typedef struct VkViSurfaceCreateInfoNN { - VkStructureType sType; - const void* pNext; - VkViSurfaceCreateFlagsNN flags; - void* window; -} VkViSurfaceCreateInfoNN; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateViSurfaceNN)(VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( - VkInstance instance, - const VkViSurfaceCreateInfoNN* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_video.cppm b/lib/vulkan-headers/include/vulkan/vulkan_video.cppm deleted file mode 100644 index 7702ef27f43..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_video.cppm +++ /dev/null @@ -1,324 +0,0 @@ -// Copyright 2021-2026 The Khronos Group Inc. -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -module; - -#define VULKAN_HPP_CXX_MODULE 1 - -#include - -#if !defined( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) -# define VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING \ - "\n\tThe Vulkan-Hpp C++ named module is experimental. It is subject to change without prior notice.\n" \ - "\tTo silence this warning, define the VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING macro.\n" \ - "\tFor feedback, go to: https://github.com/KhronosGroup/Vulkan-Hpp/issues" - -VULKAN_HPP_COMPILE_WARNING( VULKAN_HPP_CXX_MODULE_EXPERIMENTAL_WARNING ) -#endif - -#include - -export module vulkan:video; - -export namespace VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE -{ - - //================= - //=== CONSTANTs === - //================= - -#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) - //=== vulkan_video_codec_h264std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CpbCntListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxChromaPlanes; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MaxNumListRef; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NoReferencePicture; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList4X4NumLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingList8X8NumLists; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) - //=== vulkan_video_codec_h264std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCountListSize; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) - //=== vulkan_video_codec_h265std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileColsListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaQpOffsetTileRowsListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265CpbCntListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxChromaPlanes; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDeltaPoc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxDpbSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermPics; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxLongTermRefPicsSps; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxNumListRef; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265MaxShortTermRefPicSets; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265NoReferencePicture; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteCompEntriesListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteComponentsListSize; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList16X16NumLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList32X32NumLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList4X4NumLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumElements; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingList8X8NumLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SublayersListSize; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ ) - //=== vulkan_video_codec_h265std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265RefPicSetListSize; -#endif - -#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) - //=== vulkan_video_codec_vp9std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9LoopFilterAdjustments; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxRefFrames; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationPredProb; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegmentationTreeProbs; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9MaxSegments; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9NumRefFrames; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9RefsPerFrame; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Vp9SegLvlMax; -#endif - -#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) - //=== vulkan_video_codec_av1std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1GlobalMotionParams; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1LoopFilterAdjustments; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxCdefFilterStrengths; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxLoopFilterStrengths; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCbPoints; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumCrPoints; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPlanes; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosChroma; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumPosLuma; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxNumYPoints; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxSegments; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileCols; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1MaxTileRows; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1NumRefFrames; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1PrimaryRefNone; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1RefsPerFrame; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SegLvlMax; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectIntegerMv; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SelectScreenContentTools; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1SkipModeFrames; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::Av1TotalRefsPerFrame; -#endif - - //============= - //=== ENUMs === - //============= - -#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) - //=== vulkan_video_codec_h264std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264NonVclNaluType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) - //=== vulkan_video_codec_h264std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264FieldOrderCount; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) - //=== vulkan_video_codec_h265std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType; -#endif - -#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) - //=== vulkan_video_codec_vp9std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Level; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ReferenceName; -#endif - -#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) - //=== vulkan_video_codec_av1std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameRestorationType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Level; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ReferenceName; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode; -#endif - - //=============== - //=== STRUCTS === - //=============== - -#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) - //=== vulkan_video_codec_h264std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureParameterSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) - //=== vulkan_video_codec_h264std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ ) - //=== vulkan_video_codec_h264std_encode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeader; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) - //=== vulkan_video_codec_h265std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureParameterSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VideoParameterSet; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ ) - //=== vulkan_video_codec_h265std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ ) - //=== vulkan_video_codec_h265std_encode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeader; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags; -#endif - -#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) - //=== vulkan_video_codec_vp9std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags; -#endif - -#if defined( VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ ) - //=== vulkan_video_codec_vp9std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags; -#endif - -#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) - //=== vulkan_video_codec_av1std === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeader; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags; -#endif - -#if defined( VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ ) - //=== vulkan_video_codec_av1std_decode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags; -#endif - -#if defined( VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ ) - //=== vulkan_video_codec_av1std_encode === - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1DecoderModelInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfo; - using VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags; -#endif - -} // namespace VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE diff --git a/lib/vulkan-headers/include/vulkan/vulkan_video.hpp b/lib/vulkan-headers/include/vulkan/vulkan_video.hpp deleted file mode 100644 index a513d86b80b..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_video.hpp +++ /dev/null @@ -1,5529 +0,0 @@ -// Copyright 2021-2026 The Khronos Group Inc. -// SPDX-License-Identifier: Apache-2.0 OR MIT -// - -// This header is generated from the Khronos Vulkan XML API Registry. - -#ifndef VULKAN_VIDEO_HPP -#define VULKAN_VIDEO_HPP - -// here, we consider include files to be available when __has_include is not defined -#if !defined( __has_include ) -# define __has_include( x ) true -# define has_include_was_not_defined -#endif - -// clang-format off -#include -// clang-format on - -#if __has_include( ) -# include -#endif -#if __has_include( ) -# include -#endif -#if __has_include( ) -# include -#endif -#if __has_include( ) -# include -#endif -#if __has_include( ) -# include -#endif -#if __has_include( ) -# include -#endif -#if __has_include( ) -# include -#endif -#if __has_include( ) -# include -#endif -#if __has_include( ) -# include -#endif -#if __has_include( ) -# include -#endif -#if __has_include( ) -# include -#endif -#if __has_include( ) -# include -#endif - -#if !defined( VULKAN_HPP_VIDEO_NAMESPACE ) -# define VULKAN_HPP_VIDEO_NAMESPACE video -#endif - -namespace VULKAN_HPP_NAMESPACE -{ - namespace VULKAN_HPP_VIDEO_NAMESPACE - { - - //================= - //=== CONSTANTs === - //================= - -#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) - //=== vulkan_video_codec_h264std === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264CpbCntListSize = 32; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264MaxChromaPlanes = 2; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264MaxNumListRef = 32; - VULKAN_HPP_CONSTEXPR_INLINE uint8_t H264NoReferencePicture = 0xFF; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList4X4NumElements = 16; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList4X4NumLists = 6; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList8X8NumElements = 64; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H264ScalingList8X8NumLists = 6; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) - //=== vulkan_video_codec_h264std_decode === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t DecodeH264FieldOrderCountListSize = 2; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) - //=== vulkan_video_codec_h265std === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetListSize = 6; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetTileColsListSize = 19; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ChromaQpOffsetTileRowsListSize = 21; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265CpbCntListSize = 32; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxChromaPlanes = 2; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxDeltaPoc = 48; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxDpbSize = 16; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxLongTermPics = 16; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxLongTermRefPicsSps = 32; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxNumListRef = 15; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265MaxShortTermRefPicSets = 64; - VULKAN_HPP_CONSTEXPR_INLINE uint8_t H265NoReferencePicture = 0xFF; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265PredictorPaletteComponentsListSize = 3; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265PredictorPaletteCompEntriesListSize = 128; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList16X16NumElements = 64; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList16X16NumLists = 6; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList32X32NumElements = 64; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList32X32NumLists = 2; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList4X4NumElements = 16; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList4X4NumLists = 6; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList8X8NumElements = 64; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265ScalingList8X8NumLists = 6; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t H265SublayersListSize = 7; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ ) - //=== vulkan_video_codec_h265std_decode === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t DecodeH265RefPicSetListSize = 8; -#endif - -#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) - //=== vulkan_video_codec_vp9std === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9LoopFilterAdjustments = 2; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxRefFrames = 4; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegmentationPredProb = 3; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegmentationTreeProbs = 7; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9MaxSegments = 8; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9NumRefFrames = 8; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9RefsPerFrame = 3; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Vp9SegLvlMax = 4; -#endif - -#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) - //=== vulkan_video_codec_av1std === - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1GlobalMotionParams = 6; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1LoopFilterAdjustments = 2; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxCdefFilterStrengths = 8; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxLoopFilterStrengths = 4; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumCbPoints = 10; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumCrPoints = 10; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPlanes = 3; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPosChroma = 25; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumPosLuma = 24; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxNumYPoints = 14; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxSegments = 8; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxTileCols = 64; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1MaxTileRows = 64; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1NumRefFrames = 8; - VULKAN_HPP_CONSTEXPR_INLINE uint8_t Av1PrimaryRefNone = 7; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1RefsPerFrame = 7; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SegLvlMax = 8; - VULKAN_HPP_CONSTEXPR_INLINE uint8_t Av1SelectIntegerMv = 2; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SelectScreenContentTools = 2; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1SkipModeFrames = 2; - VULKAN_HPP_CONSTEXPR_INLINE uint32_t Av1TotalRefsPerFrame = 8; -#endif - - //============= - //=== ENUMs === - //============= - -#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) - //=== vulkan_video_codec_h264std === - - enum class H264ChromaFormatIdc - { - eMonochrome = STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME, - e420 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_420, - e422 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_422, - e444 = STD_VIDEO_H264_CHROMA_FORMAT_IDC_444, - eInvalid = STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID - }; - - enum class H264ProfileIdc - { - eBaseline = STD_VIDEO_H264_PROFILE_IDC_BASELINE, - eMain = STD_VIDEO_H264_PROFILE_IDC_MAIN, - eHigh = STD_VIDEO_H264_PROFILE_IDC_HIGH, - eHigh444Predictive = STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE, - eInvalid = STD_VIDEO_H264_PROFILE_IDC_INVALID - }; - - enum class H264LevelIdc - { - e1_0 = STD_VIDEO_H264_LEVEL_IDC_1_0, - e1_1 = STD_VIDEO_H264_LEVEL_IDC_1_1, - e1_2 = STD_VIDEO_H264_LEVEL_IDC_1_2, - e1_3 = STD_VIDEO_H264_LEVEL_IDC_1_3, - e2_0 = STD_VIDEO_H264_LEVEL_IDC_2_0, - e2_1 = STD_VIDEO_H264_LEVEL_IDC_2_1, - e2_2 = STD_VIDEO_H264_LEVEL_IDC_2_2, - e3_0 = STD_VIDEO_H264_LEVEL_IDC_3_0, - e3_1 = STD_VIDEO_H264_LEVEL_IDC_3_1, - e3_2 = STD_VIDEO_H264_LEVEL_IDC_3_2, - e4_0 = STD_VIDEO_H264_LEVEL_IDC_4_0, - e4_1 = STD_VIDEO_H264_LEVEL_IDC_4_1, - e4_2 = STD_VIDEO_H264_LEVEL_IDC_4_2, - e5_0 = STD_VIDEO_H264_LEVEL_IDC_5_0, - e5_1 = STD_VIDEO_H264_LEVEL_IDC_5_1, - e5_2 = STD_VIDEO_H264_LEVEL_IDC_5_2, - e6_0 = STD_VIDEO_H264_LEVEL_IDC_6_0, - e6_1 = STD_VIDEO_H264_LEVEL_IDC_6_1, - e6_2 = STD_VIDEO_H264_LEVEL_IDC_6_2, - eInvalid = STD_VIDEO_H264_LEVEL_IDC_INVALID - }; - - enum class H264PocType - { - e0 = STD_VIDEO_H264_POC_TYPE_0, - e1 = STD_VIDEO_H264_POC_TYPE_1, - e2 = STD_VIDEO_H264_POC_TYPE_2, - eInvalid = STD_VIDEO_H264_POC_TYPE_INVALID - }; - - enum class H264AspectRatioIdc - { - eUnspecified = STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED, - eSquare = STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE, - e12_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11, - e10_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11, - e16_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11, - e40_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33, - e24_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11, - e20_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11, - e32_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11, - e80_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33, - e18_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11, - e15_11 = STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11, - e64_33 = STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33, - e160_99 = STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99, - e4_3 = STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3, - e3_2 = STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2, - e2_1 = STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1, - eExtendedSar = STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR, - eInvalid = STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID - }; - - enum class H264WeightedBipredIdc - { - eDefault = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT, - eExplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT, - eImplicit = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT, - eInvalid = STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID - }; - - enum class H264ModificationOfPicNumsIdc - { - eShortTermSubtract = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT, - eShortTermAdd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD, - eLongTerm = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM, - eEnd = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END, - eInvalid = STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID - }; - - enum class H264MemMgmtControlOp - { - eEnd = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END, - eUnmarkShortTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM, - eUnmarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM, - eMarkLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM, - eSetMaxLongTermIndex = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX, - eUnmarkAll = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL, - eMarkCurrentAsLongTerm = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM, - eInvalid = STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID - }; - - enum class H264CabacInitIdc - { - e0 = STD_VIDEO_H264_CABAC_INIT_IDC_0, - e1 = STD_VIDEO_H264_CABAC_INIT_IDC_1, - e2 = STD_VIDEO_H264_CABAC_INIT_IDC_2, - eInvalid = STD_VIDEO_H264_CABAC_INIT_IDC_INVALID - }; - - enum class H264DisableDeblockingFilterIdc - { - eDisabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED, - eEnabled = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED, - ePartial = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL, - eInvalid = STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID - }; - - enum class H264SliceType - { - eP = STD_VIDEO_H264_SLICE_TYPE_P, - eB = STD_VIDEO_H264_SLICE_TYPE_B, - eI = STD_VIDEO_H264_SLICE_TYPE_I, - eInvalid = STD_VIDEO_H264_SLICE_TYPE_INVALID - }; - - enum class H264PictureType - { - eP = STD_VIDEO_H264_PICTURE_TYPE_P, - eB = STD_VIDEO_H264_PICTURE_TYPE_B, - eI = STD_VIDEO_H264_PICTURE_TYPE_I, - eIdr = STD_VIDEO_H264_PICTURE_TYPE_IDR, - eInvalid = STD_VIDEO_H264_PICTURE_TYPE_INVALID - }; - - enum class H264NonVclNaluType - { - eSps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS, - ePps = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS, - eAud = STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD, - ePrefix = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX, - eEndOfSequence = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE, - eEndOfStream = STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM, - ePrecoded = STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED, - eInvalid = STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) - //=== vulkan_video_codec_h264std_decode === - - enum class DecodeH264FieldOrderCount - { - eTop = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP, - eBottom = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM, - eInvalid = STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) - //=== vulkan_video_codec_h265std === - - enum class H265ChromaFormatIdc - { - eMonochrome = STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME, - e420 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_420, - e422 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_422, - e444 = STD_VIDEO_H265_CHROMA_FORMAT_IDC_444, - eInvalid = STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID - }; - - enum class H265ProfileIdc - { - eMain = STD_VIDEO_H265_PROFILE_IDC_MAIN, - eMain10 = STD_VIDEO_H265_PROFILE_IDC_MAIN_10, - eMainStillPicture = STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE, - eFormatRangeExtensions = STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS, - eSccExtensions = STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS, - eInvalid = STD_VIDEO_H265_PROFILE_IDC_INVALID - }; - - enum class H265LevelIdc - { - e1_0 = STD_VIDEO_H265_LEVEL_IDC_1_0, - e2_0 = STD_VIDEO_H265_LEVEL_IDC_2_0, - e2_1 = STD_VIDEO_H265_LEVEL_IDC_2_1, - e3_0 = STD_VIDEO_H265_LEVEL_IDC_3_0, - e3_1 = STD_VIDEO_H265_LEVEL_IDC_3_1, - e4_0 = STD_VIDEO_H265_LEVEL_IDC_4_0, - e4_1 = STD_VIDEO_H265_LEVEL_IDC_4_1, - e5_0 = STD_VIDEO_H265_LEVEL_IDC_5_0, - e5_1 = STD_VIDEO_H265_LEVEL_IDC_5_1, - e5_2 = STD_VIDEO_H265_LEVEL_IDC_5_2, - e6_0 = STD_VIDEO_H265_LEVEL_IDC_6_0, - e6_1 = STD_VIDEO_H265_LEVEL_IDC_6_1, - e6_2 = STD_VIDEO_H265_LEVEL_IDC_6_2, - eInvalid = STD_VIDEO_H265_LEVEL_IDC_INVALID - }; - - enum class H265SliceType - { - eB = STD_VIDEO_H265_SLICE_TYPE_B, - eP = STD_VIDEO_H265_SLICE_TYPE_P, - eI = STD_VIDEO_H265_SLICE_TYPE_I, - eInvalid = STD_VIDEO_H265_SLICE_TYPE_INVALID - }; - - enum class H265PictureType - { - eP = STD_VIDEO_H265_PICTURE_TYPE_P, - eB = STD_VIDEO_H265_PICTURE_TYPE_B, - eI = STD_VIDEO_H265_PICTURE_TYPE_I, - eIdr = STD_VIDEO_H265_PICTURE_TYPE_IDR, - eInvalid = STD_VIDEO_H265_PICTURE_TYPE_INVALID - }; - - enum class H265AspectRatioIdc - { - eUnspecified = STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED, - eSquare = STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE, - e12_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11, - e10_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11, - e16_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11, - e40_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33, - e24_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11, - e20_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11, - e32_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11, - e80_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33, - e18_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11, - e15_11 = STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11, - e64_33 = STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33, - e160_99 = STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99, - e4_3 = STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3, - e3_2 = STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2, - e2_1 = STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1, - eExtendedSar = STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR, - eInvalid = STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) - //=== vulkan_video_codec_vp9std === - - enum class VP9Profile - { - e0 = STD_VIDEO_VP9_PROFILE_0, - e1 = STD_VIDEO_VP9_PROFILE_1, - e2 = STD_VIDEO_VP9_PROFILE_2, - e3 = STD_VIDEO_VP9_PROFILE_3, - eInvalid = STD_VIDEO_VP9_PROFILE_INVALID - }; - - enum class VP9Level - { - e1_0 = STD_VIDEO_VP9_LEVEL_1_0, - e1_1 = STD_VIDEO_VP9_LEVEL_1_1, - e2_0 = STD_VIDEO_VP9_LEVEL_2_0, - e2_1 = STD_VIDEO_VP9_LEVEL_2_1, - e3_0 = STD_VIDEO_VP9_LEVEL_3_0, - e3_1 = STD_VIDEO_VP9_LEVEL_3_1, - e4_0 = STD_VIDEO_VP9_LEVEL_4_0, - e4_1 = STD_VIDEO_VP9_LEVEL_4_1, - e5_0 = STD_VIDEO_VP9_LEVEL_5_0, - e5_1 = STD_VIDEO_VP9_LEVEL_5_1, - e5_2 = STD_VIDEO_VP9_LEVEL_5_2, - e6_0 = STD_VIDEO_VP9_LEVEL_6_0, - e6_1 = STD_VIDEO_VP9_LEVEL_6_1, - e6_2 = STD_VIDEO_VP9_LEVEL_6_2, - eInvalid = STD_VIDEO_VP9_LEVEL_INVALID - }; - - enum class VP9FrameType - { - eKey = STD_VIDEO_VP9_FRAME_TYPE_KEY, - eNonKey = STD_VIDEO_VP9_FRAME_TYPE_NON_KEY, - eInvalid = STD_VIDEO_VP9_FRAME_TYPE_INVALID - }; - - enum class VP9ReferenceName - { - eIntraFrame = STD_VIDEO_VP9_REFERENCE_NAME_INTRA_FRAME, - eLastFrame = STD_VIDEO_VP9_REFERENCE_NAME_LAST_FRAME, - eGoldenFrame = STD_VIDEO_VP9_REFERENCE_NAME_GOLDEN_FRAME, - eAltrefFrame = STD_VIDEO_VP9_REFERENCE_NAME_ALTREF_FRAME, - eInvalid = STD_VIDEO_VP9_REFERENCE_NAME_INVALID - }; - - enum class VP9InterpolationFilter - { - eEighttap = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP, - eEighttapSmooth = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH, - eEighttapSharp = STD_VIDEO_VP9_INTERPOLATION_FILTER_EIGHTTAP_SHARP, - eBilinear = STD_VIDEO_VP9_INTERPOLATION_FILTER_BILINEAR, - eSwitchable = STD_VIDEO_VP9_INTERPOLATION_FILTER_SWITCHABLE, - eInvalid = STD_VIDEO_VP9_INTERPOLATION_FILTER_INVALID - }; - - enum class VP9ColorSpace - { - eUnknown = STD_VIDEO_VP9_COLOR_SPACE_UNKNOWN, - eBt601 = STD_VIDEO_VP9_COLOR_SPACE_BT_601, - eBt709 = STD_VIDEO_VP9_COLOR_SPACE_BT_709, - eSmpte170 = STD_VIDEO_VP9_COLOR_SPACE_SMPTE_170, - eSmpte240 = STD_VIDEO_VP9_COLOR_SPACE_SMPTE_240, - eBt2020 = STD_VIDEO_VP9_COLOR_SPACE_BT_2020, - eReserved = STD_VIDEO_VP9_COLOR_SPACE_RESERVED, - eRgb = STD_VIDEO_VP9_COLOR_SPACE_RGB, - eInvalid = STD_VIDEO_VP9_COLOR_SPACE_INVALID - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) - //=== vulkan_video_codec_av1std === - - enum class AV1Profile - { - eMain = STD_VIDEO_AV1_PROFILE_MAIN, - eHigh = STD_VIDEO_AV1_PROFILE_HIGH, - eProfessional = STD_VIDEO_AV1_PROFILE_PROFESSIONAL, - eInvalid = STD_VIDEO_AV1_PROFILE_INVALID - }; - - enum class AV1Level - { - e2_0 = STD_VIDEO_AV1_LEVEL_2_0, - e2_1 = STD_VIDEO_AV1_LEVEL_2_1, - e2_2 = STD_VIDEO_AV1_LEVEL_2_2, - e2_3 = STD_VIDEO_AV1_LEVEL_2_3, - e3_0 = STD_VIDEO_AV1_LEVEL_3_0, - e3_1 = STD_VIDEO_AV1_LEVEL_3_1, - e3_2 = STD_VIDEO_AV1_LEVEL_3_2, - e3_3 = STD_VIDEO_AV1_LEVEL_3_3, - e4_0 = STD_VIDEO_AV1_LEVEL_4_0, - e4_1 = STD_VIDEO_AV1_LEVEL_4_1, - e4_2 = STD_VIDEO_AV1_LEVEL_4_2, - e4_3 = STD_VIDEO_AV1_LEVEL_4_3, - e5_0 = STD_VIDEO_AV1_LEVEL_5_0, - e5_1 = STD_VIDEO_AV1_LEVEL_5_1, - e5_2 = STD_VIDEO_AV1_LEVEL_5_2, - e5_3 = STD_VIDEO_AV1_LEVEL_5_3, - e6_0 = STD_VIDEO_AV1_LEVEL_6_0, - e6_1 = STD_VIDEO_AV1_LEVEL_6_1, - e6_2 = STD_VIDEO_AV1_LEVEL_6_2, - e6_3 = STD_VIDEO_AV1_LEVEL_6_3, - e7_0 = STD_VIDEO_AV1_LEVEL_7_0, - e7_1 = STD_VIDEO_AV1_LEVEL_7_1, - e7_2 = STD_VIDEO_AV1_LEVEL_7_2, - e7_3 = STD_VIDEO_AV1_LEVEL_7_3, - eInvalid = STD_VIDEO_AV1_LEVEL_INVALID - }; - - enum class AV1FrameType - { - eKey = STD_VIDEO_AV1_FRAME_TYPE_KEY, - eInter = STD_VIDEO_AV1_FRAME_TYPE_INTER, - eIntraOnly = STD_VIDEO_AV1_FRAME_TYPE_INTRA_ONLY, - eSwitch = STD_VIDEO_AV1_FRAME_TYPE_SWITCH, - eInvalid = STD_VIDEO_AV1_FRAME_TYPE_INVALID - }; - - enum class AV1ReferenceName - { - eIntraFrame = STD_VIDEO_AV1_REFERENCE_NAME_INTRA_FRAME, - eLastFrame = STD_VIDEO_AV1_REFERENCE_NAME_LAST_FRAME, - eLast2Frame = STD_VIDEO_AV1_REFERENCE_NAME_LAST2_FRAME, - eLast3Frame = STD_VIDEO_AV1_REFERENCE_NAME_LAST3_FRAME, - eGoldenFrame = STD_VIDEO_AV1_REFERENCE_NAME_GOLDEN_FRAME, - eBwdrefFrame = STD_VIDEO_AV1_REFERENCE_NAME_BWDREF_FRAME, - eAltref2Frame = STD_VIDEO_AV1_REFERENCE_NAME_ALTREF2_FRAME, - eAltrefFrame = STD_VIDEO_AV1_REFERENCE_NAME_ALTREF_FRAME, - eInvalid = STD_VIDEO_AV1_REFERENCE_NAME_INVALID - }; - - enum class AV1InterpolationFilter - { - eEighttap = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP, - eEighttapSmooth = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH, - eEighttapSharp = STD_VIDEO_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP, - eBilinear = STD_VIDEO_AV1_INTERPOLATION_FILTER_BILINEAR, - eSwitchable = STD_VIDEO_AV1_INTERPOLATION_FILTER_SWITCHABLE, - eInvalid = STD_VIDEO_AV1_INTERPOLATION_FILTER_INVALID - }; - - enum class AV1TxMode - { - eOnly4X4 = STD_VIDEO_AV1_TX_MODE_ONLY_4X4, - eLargest = STD_VIDEO_AV1_TX_MODE_LARGEST, - eSelect = STD_VIDEO_AV1_TX_MODE_SELECT, - eInvalid = STD_VIDEO_AV1_TX_MODE_INVALID - }; - - enum class AV1FrameRestorationType - { - eNone = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_NONE, - eWiener = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_WIENER, - eSgrproj = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SGRPROJ, - eSwitchable = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_SWITCHABLE, - eInvalid = STD_VIDEO_AV1_FRAME_RESTORATION_TYPE_INVALID - }; - - enum class AV1ColorPrimaries - { - eBt709 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_709, - eUnspecified = STD_VIDEO_AV1_COLOR_PRIMARIES_UNSPECIFIED, - eBtUnspecified VULKAN_HPP_DEPRECATED_17( "eBtUnspecified is deprecated, eUnspecified should be used instead." ) = - STD_VIDEO_AV1_COLOR_PRIMARIES_BT_UNSPECIFIED, - eBt470M = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_M, - eBt470BG = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_470_B_G, - eBt601 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_601, - eSmpte240 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_240, - eGenericFilm = STD_VIDEO_AV1_COLOR_PRIMARIES_GENERIC_FILM, - eBt2020 = STD_VIDEO_AV1_COLOR_PRIMARIES_BT_2020, - eXyz = STD_VIDEO_AV1_COLOR_PRIMARIES_XYZ, - eSmpte431 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_431, - eSmpte432 = STD_VIDEO_AV1_COLOR_PRIMARIES_SMPTE_432, - eEbu3213 = STD_VIDEO_AV1_COLOR_PRIMARIES_EBU_3213, - eInvalid = STD_VIDEO_AV1_COLOR_PRIMARIES_INVALID - }; - - enum class AV1TransferCharacteristics - { - eReserved0 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_0, - eBt709 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_709, - eUnspecified = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_UNSPECIFIED, - eReserved3 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_RESERVED_3, - eBt470M = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_M, - eBt470BG = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_470_B_G, - eBt601 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_601, - eSmpte240 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_240, - eLinear = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LINEAR, - eLog100 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100, - eLog100Sqrt10 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_LOG_100_SQRT10, - eIec61966 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_IEC_61966, - eBt1361 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_1361, - eSrgb = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SRGB, - eBt2020_10Bit = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_10_BIT, - eBt2020_12Bit = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_BT_2020_12_BIT, - eSmpte2084 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_2084, - eSmpte428 = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_SMPTE_428, - eHlg = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_HLG, - eInvalid = STD_VIDEO_AV1_TRANSFER_CHARACTERISTICS_INVALID - }; - - enum class AV1MatrixCoefficients - { - eIdentity = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_IDENTITY, - eBt709 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_709, - eUnspecified = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_UNSPECIFIED, - eReserved3 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_RESERVED_3, - eFcc = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_FCC, - eBt470BG = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_470_B_G, - eBt601 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_601, - eSmpte240 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_240, - eSmpteYcgco = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_YCGCO, - eBt2020Ncl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_NCL, - eBt2020Cl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_BT_2020_CL, - eSmpte2085 = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_SMPTE_2085, - eChromatNcl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_NCL, - eChromatCl = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_CHROMAT_CL, - eIctcp = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_ICTCP, - eInvalid = STD_VIDEO_AV1_MATRIX_COEFFICIENTS_INVALID - }; - - enum class AV1ChromaSamplePosition - { - eUnknown = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_UNKNOWN, - eVertical = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_VERTICAL, - eColocated = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_COLOCATED, - eReserved = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_RESERVED, - eInvalid = STD_VIDEO_AV1_CHROMA_SAMPLE_POSITION_INVALID - }; -#endif - - //=============== - //=== STRUCTS === - //=============== - -#if defined( VULKAN_VIDEO_CODEC_H264STD_H_ ) - //=== vulkan_video_codec_h264std === - - struct H264SpsVuiFlags - { - using NativeType = StdVideoH264SpsVuiFlags; - - operator StdVideoH264SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264SpsVuiFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264SpsVuiFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH264SpsVuiFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && - ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && - ( video_full_range_flag == rhs.video_full_range_flag ) && ( color_description_present_flag == rhs.color_description_present_flag ) && - ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) && - ( fixed_frame_rate_flag == rhs.fixed_frame_rate_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && - ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) && - ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ); - } - - bool operator!=( H264SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t aspect_ratio_info_present_flag : 1; - uint32_t overscan_info_present_flag : 1; - uint32_t overscan_appropriate_flag : 1; - uint32_t video_signal_type_present_flag : 1; - uint32_t video_full_range_flag : 1; - uint32_t color_description_present_flag : 1; - uint32_t chroma_loc_info_present_flag : 1; - uint32_t timing_info_present_flag : 1; - uint32_t fixed_frame_rate_flag : 1; - uint32_t bitstream_restriction_flag : 1; - uint32_t nal_hrd_parameters_present_flag : 1; - uint32_t vcl_hrd_parameters_present_flag : 1; - }; - - struct H264HrdParameters - { - using NativeType = StdVideoH264HrdParameters; - - operator StdVideoH264HrdParameters const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264HrdParameters &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264HrdParameters const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH264HrdParameters *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && ( cpb_size_scale == rhs.cpb_size_scale ) && - ( reserved1 == rhs.reserved1 ) && ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && - ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && ( cbr_flag == rhs.cbr_flag ) && - ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && - ( cpb_removal_delay_length_minus1 == rhs.cpb_removal_delay_length_minus1 ) && - ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( time_offset_length == rhs.time_offset_length ); - } - - bool operator!=( H264HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint8_t cpb_cnt_minus1 = {}; - uint8_t bit_rate_scale = {}; - uint8_t cpb_size_scale = {}; - uint8_t reserved1 = {}; - ArrayWrapper1D bit_rate_value_minus1 = {}; - ArrayWrapper1D cpb_size_value_minus1 = {}; - ArrayWrapper1D cbr_flag = {}; - uint32_t initial_cpb_removal_delay_length_minus1 = {}; - uint32_t cpb_removal_delay_length_minus1 = {}; - uint32_t dpb_output_delay_length_minus1 = {}; - uint32_t time_offset_length = {}; - }; - - struct H264SequenceParameterSetVui - { - using NativeType = StdVideoH264SequenceParameterSetVui; - - operator StdVideoH264SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264SequenceParameterSetVui const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH264SequenceParameterSetVui *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && - ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && - ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coefficients == rhs.matrix_coefficients ) && - ( num_units_in_tick == rhs.num_units_in_tick ) && ( time_scale == rhs.time_scale ) && ( max_num_reorder_frames == rhs.max_num_reorder_frames ) && - ( max_dec_frame_buffering == rhs.max_dec_frame_buffering ) && ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && - ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && - ( pHrdParameters == rhs.pHrdParameters ); - } - - bool operator!=( H264SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsVuiFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc aspect_ratio_idc = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264AspectRatioIdc::eUnspecified; - uint16_t sar_width = {}; - uint16_t sar_height = {}; - uint8_t video_format = {}; - uint8_t colour_primaries = {}; - uint8_t transfer_characteristics = {}; - uint8_t matrix_coefficients = {}; - uint32_t num_units_in_tick = {}; - uint32_t time_scale = {}; - uint8_t max_num_reorder_frames = {}; - uint8_t max_dec_frame_buffering = {}; - uint8_t chroma_sample_loc_type_top_field = {}; - uint8_t chroma_sample_loc_type_bottom_field = {}; - uint32_t reserved1 = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264HrdParameters * pHrdParameters = {}; - }; - - struct H264SpsFlags - { - using NativeType = StdVideoH264SpsFlags; - - operator StdVideoH264SpsFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264SpsFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264SpsFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH264SpsFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( constraint_set0_flag == rhs.constraint_set0_flag ) && ( constraint_set1_flag == rhs.constraint_set1_flag ) && - ( constraint_set2_flag == rhs.constraint_set2_flag ) && ( constraint_set3_flag == rhs.constraint_set3_flag ) && - ( constraint_set4_flag == rhs.constraint_set4_flag ) && ( constraint_set5_flag == rhs.constraint_set5_flag ) && - ( direct_8x8_inference_flag == rhs.direct_8x8_inference_flag ) && ( mb_adaptive_frame_field_flag == rhs.mb_adaptive_frame_field_flag ) && - ( frame_mbs_only_flag == rhs.frame_mbs_only_flag ) && ( delta_pic_order_always_zero_flag == rhs.delta_pic_order_always_zero_flag ) && - ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && - ( gaps_in_frame_num_value_allowed_flag == rhs.gaps_in_frame_num_value_allowed_flag ) && - ( qpprime_y_zero_transform_bypass_flag == rhs.qpprime_y_zero_transform_bypass_flag ) && ( frame_cropping_flag == rhs.frame_cropping_flag ) && - ( seq_scaling_matrix_present_flag == rhs.seq_scaling_matrix_present_flag ) && ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ); - } - - bool operator!=( H264SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t constraint_set0_flag : 1; - uint32_t constraint_set1_flag : 1; - uint32_t constraint_set2_flag : 1; - uint32_t constraint_set3_flag : 1; - uint32_t constraint_set4_flag : 1; - uint32_t constraint_set5_flag : 1; - uint32_t direct_8x8_inference_flag : 1; - uint32_t mb_adaptive_frame_field_flag : 1; - uint32_t frame_mbs_only_flag : 1; - uint32_t delta_pic_order_always_zero_flag : 1; - uint32_t separate_colour_plane_flag : 1; - uint32_t gaps_in_frame_num_value_allowed_flag : 1; - uint32_t qpprime_y_zero_transform_bypass_flag : 1; - uint32_t frame_cropping_flag : 1; - uint32_t seq_scaling_matrix_present_flag : 1; - uint32_t vui_parameters_present_flag : 1; - }; - - struct H264ScalingLists - { - using NativeType = StdVideoH264ScalingLists; - - operator StdVideoH264ScalingLists const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264ScalingLists &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264ScalingLists const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH264ScalingLists *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( scaling_list_present_mask == rhs.scaling_list_present_mask ) && ( use_default_scaling_matrix_mask == rhs.use_default_scaling_matrix_mask ) && - ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ); - } - - bool operator!=( H264ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint16_t scaling_list_present_mask = {}; - uint16_t use_default_scaling_matrix_mask = {}; - ArrayWrapper2D ScalingList4x4 = {}; - ArrayWrapper2D ScalingList8x8 = {}; - }; - - struct H264SequenceParameterSet - { - using NativeType = StdVideoH264SequenceParameterSet; - - operator StdVideoH264SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264SequenceParameterSet &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264SequenceParameterSet const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH264SequenceParameterSet *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( profile_idc == rhs.profile_idc ) && ( level_idc == rhs.level_idc ) && - ( chroma_format_idc == rhs.chroma_format_idc ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && - ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && - ( log2_max_frame_num_minus4 == rhs.log2_max_frame_num_minus4 ) && ( pic_order_cnt_type == rhs.pic_order_cnt_type ) && - ( offset_for_non_ref_pic == rhs.offset_for_non_ref_pic ) && ( offset_for_top_to_bottom_field == rhs.offset_for_top_to_bottom_field ) && - ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && - ( num_ref_frames_in_pic_order_cnt_cycle == rhs.num_ref_frames_in_pic_order_cnt_cycle ) && ( max_num_ref_frames == rhs.max_num_ref_frames ) && - ( reserved1 == rhs.reserved1 ) && ( pic_width_in_mbs_minus1 == rhs.pic_width_in_mbs_minus1 ) && - ( pic_height_in_map_units_minus1 == rhs.pic_height_in_map_units_minus1 ) && ( frame_crop_left_offset == rhs.frame_crop_left_offset ) && - ( frame_crop_right_offset == rhs.frame_crop_right_offset ) && ( frame_crop_top_offset == rhs.frame_crop_top_offset ) && - ( frame_crop_bottom_offset == rhs.frame_crop_bottom_offset ) && ( reserved2 == rhs.reserved2 ) && - ( pOffsetForRefFrame == rhs.pOffsetForRefFrame ) && ( pScalingLists == rhs.pScalingLists ) && - ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ); - } - - bool operator!=( H264SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SpsFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc profile_idc = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ProfileIdc::eBaseline; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264LevelIdc::e1_0; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc chroma_format_idc = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ChromaFormatIdc::eMonochrome; - uint8_t seq_parameter_set_id = {}; - uint8_t bit_depth_luma_minus8 = {}; - uint8_t bit_depth_chroma_minus8 = {}; - uint8_t log2_max_frame_num_minus4 = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType pic_order_cnt_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PocType::e0; - int32_t offset_for_non_ref_pic = {}; - int32_t offset_for_top_to_bottom_field = {}; - uint8_t log2_max_pic_order_cnt_lsb_minus4 = {}; - uint8_t num_ref_frames_in_pic_order_cnt_cycle = {}; - uint8_t max_num_ref_frames = {}; - uint8_t reserved1 = {}; - uint32_t pic_width_in_mbs_minus1 = {}; - uint32_t pic_height_in_map_units_minus1 = {}; - uint32_t frame_crop_left_offset = {}; - uint32_t frame_crop_right_offset = {}; - uint32_t frame_crop_top_offset = {}; - uint32_t frame_crop_bottom_offset = {}; - uint32_t reserved2 = {}; - const int32_t * pOffsetForRefFrame = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SequenceParameterSetVui * pSequenceParameterSetVui = {}; - }; - - struct H264PpsFlags - { - using NativeType = StdVideoH264PpsFlags; - - operator StdVideoH264PpsFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264PpsFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264PpsFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH264PpsFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( transform_8x8_mode_flag == rhs.transform_8x8_mode_flag ) && ( redundant_pic_cnt_present_flag == rhs.redundant_pic_cnt_present_flag ) && - ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && - ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && ( weighted_pred_flag == rhs.weighted_pred_flag ) && - ( bottom_field_pic_order_in_frame_present_flag == rhs.bottom_field_pic_order_in_frame_present_flag ) && - ( entropy_coding_mode_flag == rhs.entropy_coding_mode_flag ) && ( pic_scaling_matrix_present_flag == rhs.pic_scaling_matrix_present_flag ); - } - - bool operator!=( H264PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t transform_8x8_mode_flag : 1; - uint32_t redundant_pic_cnt_present_flag : 1; - uint32_t constrained_intra_pred_flag : 1; - uint32_t deblocking_filter_control_present_flag : 1; - uint32_t weighted_pred_flag : 1; - uint32_t bottom_field_pic_order_in_frame_present_flag : 1; - uint32_t entropy_coding_mode_flag : 1; - uint32_t pic_scaling_matrix_present_flag : 1; - }; - - struct H264PictureParameterSet - { - using NativeType = StdVideoH264PictureParameterSet; - - operator StdVideoH264PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264PictureParameterSet &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH264PictureParameterSet const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH264PictureParameterSet *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && - ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && - ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( weighted_bipred_idc == rhs.weighted_bipred_idc ) && - ( pic_init_qp_minus26 == rhs.pic_init_qp_minus26 ) && ( pic_init_qs_minus26 == rhs.pic_init_qs_minus26 ) && - ( chroma_qp_index_offset == rhs.chroma_qp_index_offset ) && ( second_chroma_qp_index_offset == rhs.second_chroma_qp_index_offset ) && - ( pScalingLists == rhs.pScalingLists ); - } - - bool operator!=( H264PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PpsFlags flags = {}; - uint8_t seq_parameter_set_id = {}; - uint8_t pic_parameter_set_id = {}; - uint8_t num_ref_idx_l0_default_active_minus1 = {}; - uint8_t num_ref_idx_l1_default_active_minus1 = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc weighted_bipred_idc = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264WeightedBipredIdc::eDefault; - int8_t pic_init_qp_minus26 = {}; - int8_t pic_init_qs_minus26 = {}; - int8_t chroma_qp_index_offset = {}; - int8_t second_chroma_qp_index_offset = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ScalingLists * pScalingLists = {}; - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H264STD_DECODE_H_ ) - //=== vulkan_video_codec_h264std_decode === - - struct DecodeH264PictureInfoFlags - { - using NativeType = StdVideoDecodeH264PictureInfoFlags; - - operator StdVideoDecodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH264PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeH264PictureInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( field_pic_flag == rhs.field_pic_flag ) && ( is_intra == rhs.is_intra ) && ( IdrPicFlag == rhs.IdrPicFlag ) && - ( bottom_field_flag == rhs.bottom_field_flag ) && ( is_reference == rhs.is_reference ) && - ( complementary_field_pair == rhs.complementary_field_pair ); - } - - bool operator!=( DecodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t field_pic_flag : 1; - uint32_t is_intra : 1; - uint32_t IdrPicFlag : 1; - uint32_t bottom_field_flag : 1; - uint32_t is_reference : 1; - uint32_t complementary_field_pair : 1; - }; - - struct DecodeH264PictureInfo - { - using NativeType = StdVideoDecodeH264PictureInfo; - - operator StdVideoDecodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH264PictureInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeH264PictureInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && - ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( frame_num == rhs.frame_num ) && ( idr_pic_id == rhs.idr_pic_id ) && - ( PicOrderCnt == rhs.PicOrderCnt ); - } - - bool operator!=( DecodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264PictureInfoFlags flags = {}; - uint8_t seq_parameter_set_id = {}; - uint8_t pic_parameter_set_id = {}; - uint8_t reserved1 = {}; - uint8_t reserved2 = {}; - uint16_t frame_num = {}; - uint16_t idr_pic_id = {}; - ArrayWrapper1D PicOrderCnt = {}; - }; - - struct DecodeH264ReferenceInfoFlags - { - using NativeType = StdVideoDecodeH264ReferenceInfoFlags; - - operator StdVideoDecodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH264ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeH264ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( top_field_flag == rhs.top_field_flag ) && ( bottom_field_flag == rhs.bottom_field_flag ) && - ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( is_non_existing == rhs.is_non_existing ); - } - - bool operator!=( DecodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t top_field_flag : 1; - uint32_t bottom_field_flag : 1; - uint32_t used_for_long_term_reference : 1; - uint32_t is_non_existing : 1; - }; - - struct DecodeH264ReferenceInfo - { - using NativeType = StdVideoDecodeH264ReferenceInfo; - - operator StdVideoDecodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH264ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeH264ReferenceInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( FrameNum == rhs.FrameNum ) && ( reserved == rhs.reserved ) && ( PicOrderCnt == rhs.PicOrderCnt ); - } - - bool operator!=( DecodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH264ReferenceInfoFlags flags = {}; - uint16_t FrameNum = {}; - uint16_t reserved = {}; - ArrayWrapper1D PicOrderCnt = {}; - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H264STD_ENCODE_H_ ) - //=== vulkan_video_codec_h264std_encode === - - struct EncodeH264WeightTableFlags - { - using NativeType = StdVideoEncodeH264WeightTableFlags; - - operator StdVideoEncodeH264WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264WeightTableFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264WeightTableFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264WeightTableFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && - ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); - } - - bool operator!=( EncodeH264WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t luma_weight_l0_flag = {}; - uint32_t chroma_weight_l0_flag = {}; - uint32_t luma_weight_l1_flag = {}; - uint32_t chroma_weight_l1_flag = {}; - }; - - struct EncodeH264WeightTable - { - using NativeType = StdVideoEncodeH264WeightTable; - - operator StdVideoEncodeH264WeightTable const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264WeightTable &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264WeightTable const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264WeightTable *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && - ( chroma_log2_weight_denom == rhs.chroma_log2_weight_denom ) && ( luma_weight_l0 == rhs.luma_weight_l0 ) && - ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( chroma_weight_l0 == rhs.chroma_weight_l0 ) && ( chroma_offset_l0 == rhs.chroma_offset_l0 ) && - ( luma_weight_l1 == rhs.luma_weight_l1 ) && ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( chroma_weight_l1 == rhs.chroma_weight_l1 ) && - ( chroma_offset_l1 == rhs.chroma_offset_l1 ); - } - - bool operator!=( EncodeH264WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTableFlags flags = {}; - uint8_t luma_log2_weight_denom = {}; - uint8_t chroma_log2_weight_denom = {}; - ArrayWrapper1D luma_weight_l0 = {}; - ArrayWrapper1D luma_offset_l0 = {}; - ArrayWrapper2D chroma_weight_l0 = {}; - ArrayWrapper2D chroma_offset_l0 = {}; - ArrayWrapper1D luma_weight_l1 = {}; - ArrayWrapper1D luma_offset_l1 = {}; - ArrayWrapper2D chroma_weight_l1 = {}; - ArrayWrapper2D chroma_offset_l1 = {}; - }; - - struct EncodeH264SliceHeaderFlags - { - using NativeType = StdVideoEncodeH264SliceHeaderFlags; - - operator StdVideoEncodeH264SliceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264SliceHeaderFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264SliceHeaderFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264SliceHeaderFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( direct_spatial_mv_pred_flag == rhs.direct_spatial_mv_pred_flag ) && - ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && ( reserved == rhs.reserved ); - } - - bool operator!=( EncodeH264SliceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t direct_spatial_mv_pred_flag : 1; - uint32_t num_ref_idx_active_override_flag : 1; - uint32_t reserved : 30; - }; - - struct EncodeH264PictureInfoFlags - { - using NativeType = StdVideoEncodeH264PictureInfoFlags; - - operator StdVideoEncodeH264PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264PictureInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264PictureInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( IdrPicFlag == rhs.IdrPicFlag ) && ( is_reference == rhs.is_reference ) && - ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && ( long_term_reference_flag == rhs.long_term_reference_flag ) && - ( adaptive_ref_pic_marking_mode_flag == rhs.adaptive_ref_pic_marking_mode_flag ) && ( reserved == rhs.reserved ); - } - - bool operator!=( EncodeH264PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t IdrPicFlag : 1; - uint32_t is_reference : 1; - uint32_t no_output_of_prior_pics_flag : 1; - uint32_t long_term_reference_flag : 1; - uint32_t adaptive_ref_pic_marking_mode_flag : 1; - uint32_t reserved : 27; - }; - - struct EncodeH264ReferenceInfoFlags - { - using NativeType = StdVideoEncodeH264ReferenceInfoFlags; - - operator StdVideoEncodeH264ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( reserved == rhs.reserved ); - } - - bool operator!=( EncodeH264ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t used_for_long_term_reference : 1; - uint32_t reserved : 31; - }; - - struct EncodeH264ReferenceListsInfoFlags - { - using NativeType = StdVideoEncodeH264ReferenceListsInfoFlags; - - operator StdVideoEncodeH264ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceListsInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceListsInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && - ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); - } - - bool operator!=( EncodeH264ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t ref_pic_list_modification_flag_l0 : 1; - uint32_t ref_pic_list_modification_flag_l1 : 1; - uint32_t reserved : 30; - }; - - struct EncodeH264RefListModEntry - { - using NativeType = StdVideoEncodeH264RefListModEntry; - - operator StdVideoEncodeH264RefListModEntry const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264RefListModEntry &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264RefListModEntry const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264RefListModEntry *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( modification_of_pic_nums_idc == rhs.modification_of_pic_nums_idc ) && ( abs_diff_pic_num_minus1 == rhs.abs_diff_pic_num_minus1 ) && - ( long_term_pic_num == rhs.long_term_pic_num ); - } - - bool operator!=( EncodeH264RefListModEntry const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc modification_of_pic_nums_idc = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264ModificationOfPicNumsIdc::eShortTermSubtract; - uint16_t abs_diff_pic_num_minus1 = {}; - uint16_t long_term_pic_num = {}; - }; - - struct EncodeH264RefPicMarkingEntry - { - using NativeType = StdVideoEncodeH264RefPicMarkingEntry; - - operator StdVideoEncodeH264RefPicMarkingEntry const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264RefPicMarkingEntry &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264RefPicMarkingEntry const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264RefPicMarkingEntry *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( memory_management_control_operation == rhs.memory_management_control_operation ) && - ( difference_of_pic_nums_minus1 == rhs.difference_of_pic_nums_minus1 ) && ( long_term_pic_num == rhs.long_term_pic_num ) && - ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( max_long_term_frame_idx_plus1 == rhs.max_long_term_frame_idx_plus1 ); - } - - bool operator!=( EncodeH264RefPicMarkingEntry const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp memory_management_control_operation = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264MemMgmtControlOp::eEnd; - uint16_t difference_of_pic_nums_minus1 = {}; - uint16_t long_term_pic_num = {}; - uint16_t long_term_frame_idx = {}; - uint16_t max_long_term_frame_idx_plus1 = {}; - }; - - struct EncodeH264ReferenceListsInfo - { - using NativeType = StdVideoEncodeH264ReferenceListsInfo; - - operator StdVideoEncodeH264ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceListsInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceListsInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && - ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && - ( RefPicList1 == rhs.RefPicList1 ) && ( refList0ModOpCount == rhs.refList0ModOpCount ) && ( refList1ModOpCount == rhs.refList1ModOpCount ) && - ( refPicMarkingOpCount == rhs.refPicMarkingOpCount ) && ( reserved1 == rhs.reserved1 ) && - ( pRefList0ModOperations == rhs.pRefList0ModOperations ) && ( pRefList1ModOperations == rhs.pRefList1ModOperations ) && - ( pRefPicMarkingOperations == rhs.pRefPicMarkingOperations ); - } - - bool operator!=( EncodeH264ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfoFlags flags = {}; - uint8_t num_ref_idx_l0_active_minus1 = {}; - uint8_t num_ref_idx_l1_active_minus1 = {}; - ArrayWrapper1D RefPicList0 = {}; - ArrayWrapper1D RefPicList1 = {}; - uint8_t refList0ModOpCount = {}; - uint8_t refList1ModOpCount = {}; - uint8_t refPicMarkingOpCount = {}; - ArrayWrapper1D reserved1 = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList0ModOperations = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefListModEntry * pRefList1ModOperations = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264RefPicMarkingEntry * pRefPicMarkingOperations = {}; - }; - - struct EncodeH264PictureInfo - { - using NativeType = StdVideoEncodeH264PictureInfo; - - operator StdVideoEncodeH264PictureInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264PictureInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264PictureInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264PictureInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( seq_parameter_set_id == rhs.seq_parameter_set_id ) && ( pic_parameter_set_id == rhs.pic_parameter_set_id ) && - ( idr_pic_id == rhs.idr_pic_id ) && ( primary_pic_type == rhs.primary_pic_type ) && ( frame_num == rhs.frame_num ) && - ( PicOrderCnt == rhs.PicOrderCnt ) && ( temporal_id == rhs.temporal_id ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ); - } - - bool operator!=( EncodeH264PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264PictureInfoFlags flags = {}; - uint8_t seq_parameter_set_id = {}; - uint8_t pic_parameter_set_id = {}; - uint16_t idr_pic_id = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP; - uint32_t frame_num = {}; - int32_t PicOrderCnt = {}; - uint8_t temporal_id = {}; - ArrayWrapper1D reserved1 = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceListsInfo * pRefLists = {}; - }; - - struct EncodeH264ReferenceInfo - { - using NativeType = StdVideoEncodeH264ReferenceInfo; - - operator StdVideoEncodeH264ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264ReferenceInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( primary_pic_type == rhs.primary_pic_type ) && ( FrameNum == rhs.FrameNum ) && ( PicOrderCnt == rhs.PicOrderCnt ) && - ( long_term_pic_num == rhs.long_term_pic_num ) && ( long_term_frame_idx == rhs.long_term_frame_idx ) && ( temporal_id == rhs.temporal_id ); - } - - bool operator!=( EncodeH264ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264ReferenceInfoFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType primary_pic_type = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264PictureType::eP; - uint32_t FrameNum = {}; - int32_t PicOrderCnt = {}; - uint16_t long_term_pic_num = {}; - uint16_t long_term_frame_idx = {}; - uint8_t temporal_id = {}; - }; - - struct EncodeH264SliceHeader - { - using NativeType = StdVideoEncodeH264SliceHeader; - - operator StdVideoEncodeH264SliceHeader const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264SliceHeader &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH264SliceHeader const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH264SliceHeader *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( first_mb_in_slice == rhs.first_mb_in_slice ) && ( slice_type == rhs.slice_type ) && - ( slice_alpha_c0_offset_div2 == rhs.slice_alpha_c0_offset_div2 ) && ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && - ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && ( cabac_init_idc == rhs.cabac_init_idc ) && - ( disable_deblocking_filter_idc == rhs.disable_deblocking_filter_idc ) && ( pWeightTable == rhs.pWeightTable ); - } - - bool operator!=( EncodeH264SliceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264SliceHeaderFlags flags = {}; - uint32_t first_mb_in_slice = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264SliceType::eP; - int8_t slice_alpha_c0_offset_div2 = {}; - int8_t slice_beta_offset_div2 = {}; - int8_t slice_qp_delta = {}; - uint8_t reserved1 = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc cabac_init_idc = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264CabacInitIdc::e0; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc disable_deblocking_filter_idc = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H264DisableDeblockingFilterIdc::eDisabled; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH264WeightTable * pWeightTable = {}; - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_H_ ) - //=== vulkan_video_codec_h265std === - - struct H265DecPicBufMgr - { - using NativeType = StdVideoH265DecPicBufMgr; - - operator StdVideoH265DecPicBufMgr const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265DecPicBufMgr &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265DecPicBufMgr const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265DecPicBufMgr *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( max_latency_increase_plus1 == rhs.max_latency_increase_plus1 ) && ( max_dec_pic_buffering_minus1 == rhs.max_dec_pic_buffering_minus1 ) && - ( max_num_reorder_pics == rhs.max_num_reorder_pics ); - } - - bool operator!=( H265DecPicBufMgr const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - ArrayWrapper1D max_latency_increase_plus1 = {}; - ArrayWrapper1D max_dec_pic_buffering_minus1 = {}; - ArrayWrapper1D max_num_reorder_pics = {}; - }; - - struct H265SubLayerHrdParameters - { - using NativeType = StdVideoH265SubLayerHrdParameters; - - operator StdVideoH265SubLayerHrdParameters const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265SubLayerHrdParameters &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265SubLayerHrdParameters const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265SubLayerHrdParameters *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( bit_rate_value_minus1 == rhs.bit_rate_value_minus1 ) && ( cpb_size_value_minus1 == rhs.cpb_size_value_minus1 ) && - ( cpb_size_du_value_minus1 == rhs.cpb_size_du_value_minus1 ) && ( bit_rate_du_value_minus1 == rhs.bit_rate_du_value_minus1 ) && - ( cbr_flag == rhs.cbr_flag ); - } - - bool operator!=( H265SubLayerHrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - ArrayWrapper1D bit_rate_value_minus1 = {}; - ArrayWrapper1D cpb_size_value_minus1 = {}; - ArrayWrapper1D cpb_size_du_value_minus1 = {}; - ArrayWrapper1D bit_rate_du_value_minus1 = {}; - uint32_t cbr_flag = {}; - }; - - struct H265HrdFlags - { - using NativeType = StdVideoH265HrdFlags; - - operator StdVideoH265HrdFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265HrdFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265HrdFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265HrdFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( nal_hrd_parameters_present_flag == rhs.nal_hrd_parameters_present_flag ) && - ( vcl_hrd_parameters_present_flag == rhs.vcl_hrd_parameters_present_flag ) && - ( sub_pic_hrd_params_present_flag == rhs.sub_pic_hrd_params_present_flag ) && - ( sub_pic_cpb_params_in_pic_timing_sei_flag == rhs.sub_pic_cpb_params_in_pic_timing_sei_flag ) && - ( fixed_pic_rate_general_flag == rhs.fixed_pic_rate_general_flag ) && ( fixed_pic_rate_within_cvs_flag == rhs.fixed_pic_rate_within_cvs_flag ) && - ( low_delay_hrd_flag == rhs.low_delay_hrd_flag ); - } - - bool operator!=( H265HrdFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t nal_hrd_parameters_present_flag : 1; - uint32_t vcl_hrd_parameters_present_flag : 1; - uint32_t sub_pic_hrd_params_present_flag : 1; - uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; - uint32_t fixed_pic_rate_general_flag : 8; - uint32_t fixed_pic_rate_within_cvs_flag : 8; - uint32_t low_delay_hrd_flag : 8; - }; - - struct H265HrdParameters - { - using NativeType = StdVideoH265HrdParameters; - - operator StdVideoH265HrdParameters const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265HrdParameters &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265HrdParameters const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265HrdParameters *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( tick_divisor_minus2 == rhs.tick_divisor_minus2 ) && - ( du_cpb_removal_delay_increment_length_minus1 == rhs.du_cpb_removal_delay_increment_length_minus1 ) && - ( dpb_output_delay_du_length_minus1 == rhs.dpb_output_delay_du_length_minus1 ) && ( bit_rate_scale == rhs.bit_rate_scale ) && - ( cpb_size_scale == rhs.cpb_size_scale ) && ( cpb_size_du_scale == rhs.cpb_size_du_scale ) && - ( initial_cpb_removal_delay_length_minus1 == rhs.initial_cpb_removal_delay_length_minus1 ) && - ( au_cpb_removal_delay_length_minus1 == rhs.au_cpb_removal_delay_length_minus1 ) && - ( dpb_output_delay_length_minus1 == rhs.dpb_output_delay_length_minus1 ) && ( cpb_cnt_minus1 == rhs.cpb_cnt_minus1 ) && - ( elemental_duration_in_tc_minus1 == rhs.elemental_duration_in_tc_minus1 ) && ( reserved == rhs.reserved ) && - ( pSubLayerHrdParametersNal == rhs.pSubLayerHrdParametersNal ) && ( pSubLayerHrdParametersVcl == rhs.pSubLayerHrdParametersVcl ); - } - - bool operator!=( H265HrdParameters const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdFlags flags = {}; - uint8_t tick_divisor_minus2 = {}; - uint8_t du_cpb_removal_delay_increment_length_minus1 = {}; - uint8_t dpb_output_delay_du_length_minus1 = {}; - uint8_t bit_rate_scale = {}; - uint8_t cpb_size_scale = {}; - uint8_t cpb_size_du_scale = {}; - uint8_t initial_cpb_removal_delay_length_minus1 = {}; - uint8_t au_cpb_removal_delay_length_minus1 = {}; - uint8_t dpb_output_delay_length_minus1 = {}; - ArrayWrapper1D cpb_cnt_minus1 = {}; - ArrayWrapper1D elemental_duration_in_tc_minus1 = {}; - ArrayWrapper1D reserved = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersNal = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SubLayerHrdParameters * pSubLayerHrdParametersVcl = {}; - }; - - struct H265VpsFlags - { - using NativeType = StdVideoH265VpsFlags; - - operator StdVideoH265VpsFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265VpsFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265VpsFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265VpsFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( vps_temporal_id_nesting_flag == rhs.vps_temporal_id_nesting_flag ) && - ( vps_sub_layer_ordering_info_present_flag == rhs.vps_sub_layer_ordering_info_present_flag ) && - ( vps_timing_info_present_flag == rhs.vps_timing_info_present_flag ) && - ( vps_poc_proportional_to_timing_flag == rhs.vps_poc_proportional_to_timing_flag ); - } - - bool operator!=( H265VpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t vps_temporal_id_nesting_flag : 1; - uint32_t vps_sub_layer_ordering_info_present_flag : 1; - uint32_t vps_timing_info_present_flag : 1; - uint32_t vps_poc_proportional_to_timing_flag : 1; - }; - - struct H265ProfileTierLevelFlags - { - using NativeType = StdVideoH265ProfileTierLevelFlags; - - operator StdVideoH265ProfileTierLevelFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265ProfileTierLevelFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265ProfileTierLevelFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265ProfileTierLevelFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( general_tier_flag == rhs.general_tier_flag ) && ( general_progressive_source_flag == rhs.general_progressive_source_flag ) && - ( general_interlaced_source_flag == rhs.general_interlaced_source_flag ) && - ( general_non_packed_constraint_flag == rhs.general_non_packed_constraint_flag ) && - ( general_frame_only_constraint_flag == rhs.general_frame_only_constraint_flag ); - } - - bool operator!=( H265ProfileTierLevelFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t general_tier_flag : 1; - uint32_t general_progressive_source_flag : 1; - uint32_t general_interlaced_source_flag : 1; - uint32_t general_non_packed_constraint_flag : 1; - uint32_t general_frame_only_constraint_flag : 1; - }; - - struct H265ProfileTierLevel - { - using NativeType = StdVideoH265ProfileTierLevel; - - operator StdVideoH265ProfileTierLevel const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265ProfileTierLevel &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265ProfileTierLevel const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265ProfileTierLevel *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( general_profile_idc == rhs.general_profile_idc ) && ( general_level_idc == rhs.general_level_idc ); - } - - bool operator!=( H265ProfileTierLevel const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevelFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc general_profile_idc = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileIdc::eMain; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc general_level_idc = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LevelIdc::e1_0; - }; - - struct H265VideoParameterSet - { - using NativeType = StdVideoH265VideoParameterSet; - - operator StdVideoH265VideoParameterSet const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265VideoParameterSet &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265VideoParameterSet const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265VideoParameterSet *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( vps_video_parameter_set_id == rhs.vps_video_parameter_set_id ) && - ( vps_max_sub_layers_minus1 == rhs.vps_max_sub_layers_minus1 ) && ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && - ( vps_num_units_in_tick == rhs.vps_num_units_in_tick ) && ( vps_time_scale == rhs.vps_time_scale ) && - ( vps_num_ticks_poc_diff_one_minus1 == rhs.vps_num_ticks_poc_diff_one_minus1 ) && ( reserved3 == rhs.reserved3 ) && - ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pHrdParameters == rhs.pHrdParameters ) && ( pProfileTierLevel == rhs.pProfileTierLevel ); - } - - bool operator!=( H265VideoParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265VpsFlags flags = {}; - uint8_t vps_video_parameter_set_id = {}; - uint8_t vps_max_sub_layers_minus1 = {}; - uint8_t reserved1 = {}; - uint8_t reserved2 = {}; - uint32_t vps_num_units_in_tick = {}; - uint32_t vps_time_scale = {}; - uint32_t vps_num_ticks_poc_diff_one_minus1 = {}; - uint32_t reserved3 = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {}; - }; - - struct H265ScalingLists - { - using NativeType = StdVideoH265ScalingLists; - - operator StdVideoH265ScalingLists const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265ScalingLists &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265ScalingLists const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265ScalingLists *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( ScalingList4x4 == rhs.ScalingList4x4 ) && ( ScalingList8x8 == rhs.ScalingList8x8 ) && ( ScalingList16x16 == rhs.ScalingList16x16 ) && - ( ScalingList32x32 == rhs.ScalingList32x32 ) && ( ScalingListDCCoef16x16 == rhs.ScalingListDCCoef16x16 ) && - ( ScalingListDCCoef32x32 == rhs.ScalingListDCCoef32x32 ); - } - - bool operator!=( H265ScalingLists const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - ArrayWrapper2D ScalingList4x4 = {}; - ArrayWrapper2D ScalingList8x8 = {}; - ArrayWrapper2D ScalingList16x16 = {}; - ArrayWrapper2D ScalingList32x32 = {}; - ArrayWrapper1D ScalingListDCCoef16x16 = {}; - ArrayWrapper1D ScalingListDCCoef32x32 = {}; - }; - - struct H265SpsVuiFlags - { - using NativeType = StdVideoH265SpsVuiFlags; - - operator StdVideoH265SpsVuiFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265SpsVuiFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265SpsVuiFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265SpsVuiFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( aspect_ratio_info_present_flag == rhs.aspect_ratio_info_present_flag ) && ( overscan_info_present_flag == rhs.overscan_info_present_flag ) && - ( overscan_appropriate_flag == rhs.overscan_appropriate_flag ) && ( video_signal_type_present_flag == rhs.video_signal_type_present_flag ) && - ( video_full_range_flag == rhs.video_full_range_flag ) && ( colour_description_present_flag == rhs.colour_description_present_flag ) && - ( chroma_loc_info_present_flag == rhs.chroma_loc_info_present_flag ) && - ( neutral_chroma_indication_flag == rhs.neutral_chroma_indication_flag ) && ( field_seq_flag == rhs.field_seq_flag ) && - ( frame_field_info_present_flag == rhs.frame_field_info_present_flag ) && ( default_display_window_flag == rhs.default_display_window_flag ) && - ( vui_timing_info_present_flag == rhs.vui_timing_info_present_flag ) && - ( vui_poc_proportional_to_timing_flag == rhs.vui_poc_proportional_to_timing_flag ) && - ( vui_hrd_parameters_present_flag == rhs.vui_hrd_parameters_present_flag ) && ( bitstream_restriction_flag == rhs.bitstream_restriction_flag ) && - ( tiles_fixed_structure_flag == rhs.tiles_fixed_structure_flag ) && - ( motion_vectors_over_pic_boundaries_flag == rhs.motion_vectors_over_pic_boundaries_flag ) && - ( restricted_ref_pic_lists_flag == rhs.restricted_ref_pic_lists_flag ); - } - - bool operator!=( H265SpsVuiFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t aspect_ratio_info_present_flag : 1; - uint32_t overscan_info_present_flag : 1; - uint32_t overscan_appropriate_flag : 1; - uint32_t video_signal_type_present_flag : 1; - uint32_t video_full_range_flag : 1; - uint32_t colour_description_present_flag : 1; - uint32_t chroma_loc_info_present_flag : 1; - uint32_t neutral_chroma_indication_flag : 1; - uint32_t field_seq_flag : 1; - uint32_t frame_field_info_present_flag : 1; - uint32_t default_display_window_flag : 1; - uint32_t vui_timing_info_present_flag : 1; - uint32_t vui_poc_proportional_to_timing_flag : 1; - uint32_t vui_hrd_parameters_present_flag : 1; - uint32_t bitstream_restriction_flag : 1; - uint32_t tiles_fixed_structure_flag : 1; - uint32_t motion_vectors_over_pic_boundaries_flag : 1; - uint32_t restricted_ref_pic_lists_flag : 1; - }; - - struct H265SequenceParameterSetVui - { - using NativeType = StdVideoH265SequenceParameterSetVui; - - operator StdVideoH265SequenceParameterSetVui const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265SequenceParameterSetVui &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265SequenceParameterSetVui const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265SequenceParameterSetVui *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( aspect_ratio_idc == rhs.aspect_ratio_idc ) && ( sar_width == rhs.sar_width ) && ( sar_height == rhs.sar_height ) && - ( video_format == rhs.video_format ) && ( colour_primaries == rhs.colour_primaries ) && - ( transfer_characteristics == rhs.transfer_characteristics ) && ( matrix_coeffs == rhs.matrix_coeffs ) && - ( chroma_sample_loc_type_top_field == rhs.chroma_sample_loc_type_top_field ) && - ( chroma_sample_loc_type_bottom_field == rhs.chroma_sample_loc_type_bottom_field ) && ( reserved1 == rhs.reserved1 ) && - ( reserved2 == rhs.reserved2 ) && ( def_disp_win_left_offset == rhs.def_disp_win_left_offset ) && - ( def_disp_win_right_offset == rhs.def_disp_win_right_offset ) && ( def_disp_win_top_offset == rhs.def_disp_win_top_offset ) && - ( def_disp_win_bottom_offset == rhs.def_disp_win_bottom_offset ) && ( vui_num_units_in_tick == rhs.vui_num_units_in_tick ) && - ( vui_time_scale == rhs.vui_time_scale ) && ( vui_num_ticks_poc_diff_one_minus1 == rhs.vui_num_ticks_poc_diff_one_minus1 ) && - ( min_spatial_segmentation_idc == rhs.min_spatial_segmentation_idc ) && ( reserved3 == rhs.reserved3 ) && - ( max_bytes_per_pic_denom == rhs.max_bytes_per_pic_denom ) && ( max_bits_per_min_cu_denom == rhs.max_bits_per_min_cu_denom ) && - ( log2_max_mv_length_horizontal == rhs.log2_max_mv_length_horizontal ) && ( log2_max_mv_length_vertical == rhs.log2_max_mv_length_vertical ) && - ( pHrdParameters == rhs.pHrdParameters ); - } - - bool operator!=( H265SequenceParameterSetVui const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsVuiFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc aspect_ratio_idc = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265AspectRatioIdc::eUnspecified; - uint16_t sar_width = {}; - uint16_t sar_height = {}; - uint8_t video_format = {}; - uint8_t colour_primaries = {}; - uint8_t transfer_characteristics = {}; - uint8_t matrix_coeffs = {}; - uint8_t chroma_sample_loc_type_top_field = {}; - uint8_t chroma_sample_loc_type_bottom_field = {}; - uint8_t reserved1 = {}; - uint8_t reserved2 = {}; - uint16_t def_disp_win_left_offset = {}; - uint16_t def_disp_win_right_offset = {}; - uint16_t def_disp_win_top_offset = {}; - uint16_t def_disp_win_bottom_offset = {}; - uint32_t vui_num_units_in_tick = {}; - uint32_t vui_time_scale = {}; - uint32_t vui_num_ticks_poc_diff_one_minus1 = {}; - uint16_t min_spatial_segmentation_idc = {}; - uint16_t reserved3 = {}; - uint8_t max_bytes_per_pic_denom = {}; - uint8_t max_bits_per_min_cu_denom = {}; - uint8_t log2_max_mv_length_horizontal = {}; - uint8_t log2_max_mv_length_vertical = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265HrdParameters * pHrdParameters = {}; - }; - - struct H265PredictorPaletteEntries - { - using NativeType = StdVideoH265PredictorPaletteEntries; - - operator StdVideoH265PredictorPaletteEntries const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265PredictorPaletteEntries &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265PredictorPaletteEntries const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265PredictorPaletteEntries *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( PredictorPaletteEntries == rhs.PredictorPaletteEntries ); - } - - bool operator!=( H265PredictorPaletteEntries const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - ArrayWrapper2D - PredictorPaletteEntries = {}; - }; - - struct H265SpsFlags - { - using NativeType = StdVideoH265SpsFlags; - - operator StdVideoH265SpsFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265SpsFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265SpsFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265SpsFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( sps_temporal_id_nesting_flag == rhs.sps_temporal_id_nesting_flag ) && ( separate_colour_plane_flag == rhs.separate_colour_plane_flag ) && - ( conformance_window_flag == rhs.conformance_window_flag ) && - ( sps_sub_layer_ordering_info_present_flag == rhs.sps_sub_layer_ordering_info_present_flag ) && - ( scaling_list_enabled_flag == rhs.scaling_list_enabled_flag ) && - ( sps_scaling_list_data_present_flag == rhs.sps_scaling_list_data_present_flag ) && ( amp_enabled_flag == rhs.amp_enabled_flag ) && - ( sample_adaptive_offset_enabled_flag == rhs.sample_adaptive_offset_enabled_flag ) && ( pcm_enabled_flag == rhs.pcm_enabled_flag ) && - ( pcm_loop_filter_disabled_flag == rhs.pcm_loop_filter_disabled_flag ) && - ( long_term_ref_pics_present_flag == rhs.long_term_ref_pics_present_flag ) && - ( sps_temporal_mvp_enabled_flag == rhs.sps_temporal_mvp_enabled_flag ) && - ( strong_intra_smoothing_enabled_flag == rhs.strong_intra_smoothing_enabled_flag ) && - ( vui_parameters_present_flag == rhs.vui_parameters_present_flag ) && ( sps_extension_present_flag == rhs.sps_extension_present_flag ) && - ( sps_range_extension_flag == rhs.sps_range_extension_flag ) && - ( transform_skip_rotation_enabled_flag == rhs.transform_skip_rotation_enabled_flag ) && - ( transform_skip_context_enabled_flag == rhs.transform_skip_context_enabled_flag ) && - ( implicit_rdpcm_enabled_flag == rhs.implicit_rdpcm_enabled_flag ) && ( explicit_rdpcm_enabled_flag == rhs.explicit_rdpcm_enabled_flag ) && - ( extended_precision_processing_flag == rhs.extended_precision_processing_flag ) && - ( intra_smoothing_disabled_flag == rhs.intra_smoothing_disabled_flag ) && - ( high_precision_offsets_enabled_flag == rhs.high_precision_offsets_enabled_flag ) && - ( persistent_rice_adaptation_enabled_flag == rhs.persistent_rice_adaptation_enabled_flag ) && - ( cabac_bypass_alignment_enabled_flag == rhs.cabac_bypass_alignment_enabled_flag ) && ( sps_scc_extension_flag == rhs.sps_scc_extension_flag ) && - ( sps_curr_pic_ref_enabled_flag == rhs.sps_curr_pic_ref_enabled_flag ) && ( palette_mode_enabled_flag == rhs.palette_mode_enabled_flag ) && - ( sps_palette_predictor_initializers_present_flag == rhs.sps_palette_predictor_initializers_present_flag ) && - ( intra_boundary_filtering_disabled_flag == rhs.intra_boundary_filtering_disabled_flag ); - } - - bool operator!=( H265SpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t sps_temporal_id_nesting_flag : 1; - uint32_t separate_colour_plane_flag : 1; - uint32_t conformance_window_flag : 1; - uint32_t sps_sub_layer_ordering_info_present_flag : 1; - uint32_t scaling_list_enabled_flag : 1; - uint32_t sps_scaling_list_data_present_flag : 1; - uint32_t amp_enabled_flag : 1; - uint32_t sample_adaptive_offset_enabled_flag : 1; - uint32_t pcm_enabled_flag : 1; - uint32_t pcm_loop_filter_disabled_flag : 1; - uint32_t long_term_ref_pics_present_flag : 1; - uint32_t sps_temporal_mvp_enabled_flag : 1; - uint32_t strong_intra_smoothing_enabled_flag : 1; - uint32_t vui_parameters_present_flag : 1; - uint32_t sps_extension_present_flag : 1; - uint32_t sps_range_extension_flag : 1; - uint32_t transform_skip_rotation_enabled_flag : 1; - uint32_t transform_skip_context_enabled_flag : 1; - uint32_t implicit_rdpcm_enabled_flag : 1; - uint32_t explicit_rdpcm_enabled_flag : 1; - uint32_t extended_precision_processing_flag : 1; - uint32_t intra_smoothing_disabled_flag : 1; - uint32_t high_precision_offsets_enabled_flag : 1; - uint32_t persistent_rice_adaptation_enabled_flag : 1; - uint32_t cabac_bypass_alignment_enabled_flag : 1; - uint32_t sps_scc_extension_flag : 1; - uint32_t sps_curr_pic_ref_enabled_flag : 1; - uint32_t palette_mode_enabled_flag : 1; - uint32_t sps_palette_predictor_initializers_present_flag : 1; - uint32_t intra_boundary_filtering_disabled_flag : 1; - }; - - struct H265ShortTermRefPicSetFlags - { - using NativeType = StdVideoH265ShortTermRefPicSetFlags; - - operator StdVideoH265ShortTermRefPicSetFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265ShortTermRefPicSetFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265ShortTermRefPicSetFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265ShortTermRefPicSetFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( inter_ref_pic_set_prediction_flag == rhs.inter_ref_pic_set_prediction_flag ) && ( delta_rps_sign == rhs.delta_rps_sign ); - } - - bool operator!=( H265ShortTermRefPicSetFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t inter_ref_pic_set_prediction_flag : 1; - uint32_t delta_rps_sign : 1; - }; - - struct H265ShortTermRefPicSet - { - using NativeType = StdVideoH265ShortTermRefPicSet; - - operator StdVideoH265ShortTermRefPicSet const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265ShortTermRefPicSet &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265ShortTermRefPicSet const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265ShortTermRefPicSet *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( delta_idx_minus1 == rhs.delta_idx_minus1 ) && ( use_delta_flag == rhs.use_delta_flag ) && - ( abs_delta_rps_minus1 == rhs.abs_delta_rps_minus1 ) && ( used_by_curr_pic_flag == rhs.used_by_curr_pic_flag ) && - ( used_by_curr_pic_s0_flag == rhs.used_by_curr_pic_s0_flag ) && ( used_by_curr_pic_s1_flag == rhs.used_by_curr_pic_s1_flag ) && - ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( reserved3 == rhs.reserved3 ) && - ( num_negative_pics == rhs.num_negative_pics ) && ( num_positive_pics == rhs.num_positive_pics ) && - ( delta_poc_s0_minus1 == rhs.delta_poc_s0_minus1 ) && ( delta_poc_s1_minus1 == rhs.delta_poc_s1_minus1 ); - } - - bool operator!=( H265ShortTermRefPicSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSetFlags flags = {}; - uint32_t delta_idx_minus1 = {}; - uint16_t use_delta_flag = {}; - uint16_t abs_delta_rps_minus1 = {}; - uint16_t used_by_curr_pic_flag = {}; - uint16_t used_by_curr_pic_s0_flag = {}; - uint16_t used_by_curr_pic_s1_flag = {}; - uint16_t reserved1 = {}; - uint8_t reserved2 = {}; - uint8_t reserved3 = {}; - uint8_t num_negative_pics = {}; - uint8_t num_positive_pics = {}; - ArrayWrapper1D delta_poc_s0_minus1 = {}; - ArrayWrapper1D delta_poc_s1_minus1 = {}; - }; - - struct H265LongTermRefPicsSps - { - using NativeType = StdVideoH265LongTermRefPicsSps; - - operator StdVideoH265LongTermRefPicsSps const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265LongTermRefPicsSps &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265LongTermRefPicsSps const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265LongTermRefPicsSps *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( used_by_curr_pic_lt_sps_flag == rhs.used_by_curr_pic_lt_sps_flag ) && ( lt_ref_pic_poc_lsb_sps == rhs.lt_ref_pic_poc_lsb_sps ); - } - - bool operator!=( H265LongTermRefPicsSps const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t used_by_curr_pic_lt_sps_flag = {}; - ArrayWrapper1D lt_ref_pic_poc_lsb_sps = {}; - }; - - struct H265SequenceParameterSet - { - using NativeType = StdVideoH265SequenceParameterSet; - - operator StdVideoH265SequenceParameterSet const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265SequenceParameterSet &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265SequenceParameterSet const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265SequenceParameterSet *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( chroma_format_idc == rhs.chroma_format_idc ) && ( pic_width_in_luma_samples == rhs.pic_width_in_luma_samples ) && - ( pic_height_in_luma_samples == rhs.pic_height_in_luma_samples ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && - ( sps_max_sub_layers_minus1 == rhs.sps_max_sub_layers_minus1 ) && ( sps_seq_parameter_set_id == rhs.sps_seq_parameter_set_id ) && - ( bit_depth_luma_minus8 == rhs.bit_depth_luma_minus8 ) && ( bit_depth_chroma_minus8 == rhs.bit_depth_chroma_minus8 ) && - ( log2_max_pic_order_cnt_lsb_minus4 == rhs.log2_max_pic_order_cnt_lsb_minus4 ) && - ( log2_min_luma_coding_block_size_minus3 == rhs.log2_min_luma_coding_block_size_minus3 ) && - ( log2_diff_max_min_luma_coding_block_size == rhs.log2_diff_max_min_luma_coding_block_size ) && - ( log2_min_luma_transform_block_size_minus2 == rhs.log2_min_luma_transform_block_size_minus2 ) && - ( log2_diff_max_min_luma_transform_block_size == rhs.log2_diff_max_min_luma_transform_block_size ) && - ( max_transform_hierarchy_depth_inter == rhs.max_transform_hierarchy_depth_inter ) && - ( max_transform_hierarchy_depth_intra == rhs.max_transform_hierarchy_depth_intra ) && - ( num_short_term_ref_pic_sets == rhs.num_short_term_ref_pic_sets ) && ( num_long_term_ref_pics_sps == rhs.num_long_term_ref_pics_sps ) && - ( pcm_sample_bit_depth_luma_minus1 == rhs.pcm_sample_bit_depth_luma_minus1 ) && - ( pcm_sample_bit_depth_chroma_minus1 == rhs.pcm_sample_bit_depth_chroma_minus1 ) && - ( log2_min_pcm_luma_coding_block_size_minus3 == rhs.log2_min_pcm_luma_coding_block_size_minus3 ) && - ( log2_diff_max_min_pcm_luma_coding_block_size == rhs.log2_diff_max_min_pcm_luma_coding_block_size ) && ( reserved1 == rhs.reserved1 ) && - ( reserved2 == rhs.reserved2 ) && ( palette_max_size == rhs.palette_max_size ) && - ( delta_palette_max_predictor_size == rhs.delta_palette_max_predictor_size ) && - ( motion_vector_resolution_control_idc == rhs.motion_vector_resolution_control_idc ) && - ( sps_num_palette_predictor_initializers_minus1 == rhs.sps_num_palette_predictor_initializers_minus1 ) && - ( conf_win_left_offset == rhs.conf_win_left_offset ) && ( conf_win_right_offset == rhs.conf_win_right_offset ) && - ( conf_win_top_offset == rhs.conf_win_top_offset ) && ( conf_win_bottom_offset == rhs.conf_win_bottom_offset ) && - ( pProfileTierLevel == rhs.pProfileTierLevel ) && ( pDecPicBufMgr == rhs.pDecPicBufMgr ) && ( pScalingLists == rhs.pScalingLists ) && - ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPicsSps == rhs.pLongTermRefPicsSps ) && - ( pSequenceParameterSetVui == rhs.pSequenceParameterSetVui ) && ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); - } - - bool operator!=( H265SequenceParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SpsFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc chroma_format_idc = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ChromaFormatIdc::eMonochrome; - uint32_t pic_width_in_luma_samples = {}; - uint32_t pic_height_in_luma_samples = {}; - uint8_t sps_video_parameter_set_id = {}; - uint8_t sps_max_sub_layers_minus1 = {}; - uint8_t sps_seq_parameter_set_id = {}; - uint8_t bit_depth_luma_minus8 = {}; - uint8_t bit_depth_chroma_minus8 = {}; - uint8_t log2_max_pic_order_cnt_lsb_minus4 = {}; - uint8_t log2_min_luma_coding_block_size_minus3 = {}; - uint8_t log2_diff_max_min_luma_coding_block_size = {}; - uint8_t log2_min_luma_transform_block_size_minus2 = {}; - uint8_t log2_diff_max_min_luma_transform_block_size = {}; - uint8_t max_transform_hierarchy_depth_inter = {}; - uint8_t max_transform_hierarchy_depth_intra = {}; - uint8_t num_short_term_ref_pic_sets = {}; - uint8_t num_long_term_ref_pics_sps = {}; - uint8_t pcm_sample_bit_depth_luma_minus1 = {}; - uint8_t pcm_sample_bit_depth_chroma_minus1 = {}; - uint8_t log2_min_pcm_luma_coding_block_size_minus3 = {}; - uint8_t log2_diff_max_min_pcm_luma_coding_block_size = {}; - uint8_t reserved1 = {}; - uint8_t reserved2 = {}; - uint8_t palette_max_size = {}; - uint8_t delta_palette_max_predictor_size = {}; - uint8_t motion_vector_resolution_control_idc = {}; - uint8_t sps_num_palette_predictor_initializers_minus1 = {}; - uint32_t conf_win_left_offset = {}; - uint32_t conf_win_right_offset = {}; - uint32_t conf_win_top_offset = {}; - uint32_t conf_win_bottom_offset = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ProfileTierLevel * pProfileTierLevel = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265DecPicBufMgr * pDecPicBufMgr = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265LongTermRefPicsSps * pLongTermRefPicsSps = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SequenceParameterSetVui * pSequenceParameterSetVui = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {}; - }; - - struct H265PpsFlags - { - using NativeType = StdVideoH265PpsFlags; - - operator StdVideoH265PpsFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265PpsFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265PpsFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265PpsFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( dependent_slice_segments_enabled_flag == rhs.dependent_slice_segments_enabled_flag ) && - ( output_flag_present_flag == rhs.output_flag_present_flag ) && ( sign_data_hiding_enabled_flag == rhs.sign_data_hiding_enabled_flag ) && - ( cabac_init_present_flag == rhs.cabac_init_present_flag ) && ( constrained_intra_pred_flag == rhs.constrained_intra_pred_flag ) && - ( transform_skip_enabled_flag == rhs.transform_skip_enabled_flag ) && ( cu_qp_delta_enabled_flag == rhs.cu_qp_delta_enabled_flag ) && - ( pps_slice_chroma_qp_offsets_present_flag == rhs.pps_slice_chroma_qp_offsets_present_flag ) && - ( weighted_pred_flag == rhs.weighted_pred_flag ) && ( weighted_bipred_flag == rhs.weighted_bipred_flag ) && - ( transquant_bypass_enabled_flag == rhs.transquant_bypass_enabled_flag ) && ( tiles_enabled_flag == rhs.tiles_enabled_flag ) && - ( entropy_coding_sync_enabled_flag == rhs.entropy_coding_sync_enabled_flag ) && ( uniform_spacing_flag == rhs.uniform_spacing_flag ) && - ( loop_filter_across_tiles_enabled_flag == rhs.loop_filter_across_tiles_enabled_flag ) && - ( pps_loop_filter_across_slices_enabled_flag == rhs.pps_loop_filter_across_slices_enabled_flag ) && - ( deblocking_filter_control_present_flag == rhs.deblocking_filter_control_present_flag ) && - ( deblocking_filter_override_enabled_flag == rhs.deblocking_filter_override_enabled_flag ) && - ( pps_deblocking_filter_disabled_flag == rhs.pps_deblocking_filter_disabled_flag ) && - ( pps_scaling_list_data_present_flag == rhs.pps_scaling_list_data_present_flag ) && - ( lists_modification_present_flag == rhs.lists_modification_present_flag ) && - ( slice_segment_header_extension_present_flag == rhs.slice_segment_header_extension_present_flag ) && - ( pps_extension_present_flag == rhs.pps_extension_present_flag ) && - ( cross_component_prediction_enabled_flag == rhs.cross_component_prediction_enabled_flag ) && - ( chroma_qp_offset_list_enabled_flag == rhs.chroma_qp_offset_list_enabled_flag ) && - ( pps_curr_pic_ref_enabled_flag == rhs.pps_curr_pic_ref_enabled_flag ) && - ( residual_adaptive_colour_transform_enabled_flag == rhs.residual_adaptive_colour_transform_enabled_flag ) && - ( pps_slice_act_qp_offsets_present_flag == rhs.pps_slice_act_qp_offsets_present_flag ) && - ( pps_palette_predictor_initializers_present_flag == rhs.pps_palette_predictor_initializers_present_flag ) && - ( monochrome_palette_flag == rhs.monochrome_palette_flag ) && ( pps_range_extension_flag == rhs.pps_range_extension_flag ); - } - - bool operator!=( H265PpsFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t dependent_slice_segments_enabled_flag : 1; - uint32_t output_flag_present_flag : 1; - uint32_t sign_data_hiding_enabled_flag : 1; - uint32_t cabac_init_present_flag : 1; - uint32_t constrained_intra_pred_flag : 1; - uint32_t transform_skip_enabled_flag : 1; - uint32_t cu_qp_delta_enabled_flag : 1; - uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; - uint32_t weighted_pred_flag : 1; - uint32_t weighted_bipred_flag : 1; - uint32_t transquant_bypass_enabled_flag : 1; - uint32_t tiles_enabled_flag : 1; - uint32_t entropy_coding_sync_enabled_flag : 1; - uint32_t uniform_spacing_flag : 1; - uint32_t loop_filter_across_tiles_enabled_flag : 1; - uint32_t pps_loop_filter_across_slices_enabled_flag : 1; - uint32_t deblocking_filter_control_present_flag : 1; - uint32_t deblocking_filter_override_enabled_flag : 1; - uint32_t pps_deblocking_filter_disabled_flag : 1; - uint32_t pps_scaling_list_data_present_flag : 1; - uint32_t lists_modification_present_flag : 1; - uint32_t slice_segment_header_extension_present_flag : 1; - uint32_t pps_extension_present_flag : 1; - uint32_t cross_component_prediction_enabled_flag : 1; - uint32_t chroma_qp_offset_list_enabled_flag : 1; - uint32_t pps_curr_pic_ref_enabled_flag : 1; - uint32_t residual_adaptive_colour_transform_enabled_flag : 1; - uint32_t pps_slice_act_qp_offsets_present_flag : 1; - uint32_t pps_palette_predictor_initializers_present_flag : 1; - uint32_t monochrome_palette_flag : 1; - uint32_t pps_range_extension_flag : 1; - }; - - struct H265PictureParameterSet - { - using NativeType = StdVideoH265PictureParameterSet; - - operator StdVideoH265PictureParameterSet const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265PictureParameterSet &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoH265PictureParameterSet const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoH265PictureParameterSet *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && - ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && - ( num_extra_slice_header_bits == rhs.num_extra_slice_header_bits ) && - ( num_ref_idx_l0_default_active_minus1 == rhs.num_ref_idx_l0_default_active_minus1 ) && - ( num_ref_idx_l1_default_active_minus1 == rhs.num_ref_idx_l1_default_active_minus1 ) && ( init_qp_minus26 == rhs.init_qp_minus26 ) && - ( diff_cu_qp_delta_depth == rhs.diff_cu_qp_delta_depth ) && ( pps_cb_qp_offset == rhs.pps_cb_qp_offset ) && - ( pps_cr_qp_offset == rhs.pps_cr_qp_offset ) && ( pps_beta_offset_div2 == rhs.pps_beta_offset_div2 ) && - ( pps_tc_offset_div2 == rhs.pps_tc_offset_div2 ) && ( log2_parallel_merge_level_minus2 == rhs.log2_parallel_merge_level_minus2 ) && - ( log2_max_transform_skip_block_size_minus2 == rhs.log2_max_transform_skip_block_size_minus2 ) && - ( diff_cu_chroma_qp_offset_depth == rhs.diff_cu_chroma_qp_offset_depth ) && - ( chroma_qp_offset_list_len_minus1 == rhs.chroma_qp_offset_list_len_minus1 ) && ( cb_qp_offset_list == rhs.cb_qp_offset_list ) && - ( cr_qp_offset_list == rhs.cr_qp_offset_list ) && ( log2_sao_offset_scale_luma == rhs.log2_sao_offset_scale_luma ) && - ( log2_sao_offset_scale_chroma == rhs.log2_sao_offset_scale_chroma ) && ( pps_act_y_qp_offset_plus5 == rhs.pps_act_y_qp_offset_plus5 ) && - ( pps_act_cb_qp_offset_plus5 == rhs.pps_act_cb_qp_offset_plus5 ) && ( pps_act_cr_qp_offset_plus3 == rhs.pps_act_cr_qp_offset_plus3 ) && - ( pps_num_palette_predictor_initializers == rhs.pps_num_palette_predictor_initializers ) && - ( luma_bit_depth_entry_minus8 == rhs.luma_bit_depth_entry_minus8 ) && ( chroma_bit_depth_entry_minus8 == rhs.chroma_bit_depth_entry_minus8 ) && - ( num_tile_columns_minus1 == rhs.num_tile_columns_minus1 ) && ( num_tile_rows_minus1 == rhs.num_tile_rows_minus1 ) && - ( reserved1 == rhs.reserved1 ) && ( reserved2 == rhs.reserved2 ) && ( column_width_minus1 == rhs.column_width_minus1 ) && - ( row_height_minus1 == rhs.row_height_minus1 ) && ( reserved3 == rhs.reserved3 ) && ( pScalingLists == rhs.pScalingLists ) && - ( pPredictorPaletteEntries == rhs.pPredictorPaletteEntries ); - } - - bool operator!=( H265PictureParameterSet const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PpsFlags flags = {}; - uint8_t pps_pic_parameter_set_id = {}; - uint8_t pps_seq_parameter_set_id = {}; - uint8_t sps_video_parameter_set_id = {}; - uint8_t num_extra_slice_header_bits = {}; - uint8_t num_ref_idx_l0_default_active_minus1 = {}; - uint8_t num_ref_idx_l1_default_active_minus1 = {}; - int8_t init_qp_minus26 = {}; - uint8_t diff_cu_qp_delta_depth = {}; - int8_t pps_cb_qp_offset = {}; - int8_t pps_cr_qp_offset = {}; - int8_t pps_beta_offset_div2 = {}; - int8_t pps_tc_offset_div2 = {}; - uint8_t log2_parallel_merge_level_minus2 = {}; - uint8_t log2_max_transform_skip_block_size_minus2 = {}; - uint8_t diff_cu_chroma_qp_offset_depth = {}; - uint8_t chroma_qp_offset_list_len_minus1 = {}; - ArrayWrapper1D cb_qp_offset_list = {}; - ArrayWrapper1D cr_qp_offset_list = {}; - uint8_t log2_sao_offset_scale_luma = {}; - uint8_t log2_sao_offset_scale_chroma = {}; - int8_t pps_act_y_qp_offset_plus5 = {}; - int8_t pps_act_cb_qp_offset_plus5 = {}; - int8_t pps_act_cr_qp_offset_plus3 = {}; - uint8_t pps_num_palette_predictor_initializers = {}; - uint8_t luma_bit_depth_entry_minus8 = {}; - uint8_t chroma_bit_depth_entry_minus8 = {}; - uint8_t num_tile_columns_minus1 = {}; - uint8_t num_tile_rows_minus1 = {}; - uint8_t reserved1 = {}; - uint8_t reserved2 = {}; - ArrayWrapper1D column_width_minus1 = {}; - ArrayWrapper1D row_height_minus1 = {}; - uint32_t reserved3 = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ScalingLists * pScalingLists = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PredictorPaletteEntries * pPredictorPaletteEntries = {}; - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_DECODE_H_ ) - //=== vulkan_video_codec_h265std_decode === - - struct DecodeH265PictureInfoFlags - { - using NativeType = StdVideoDecodeH265PictureInfoFlags; - - operator StdVideoDecodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH265PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeH265PictureInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( IrapPicFlag == rhs.IrapPicFlag ) && ( IdrPicFlag == rhs.IdrPicFlag ) && ( IsReference == rhs.IsReference ) && - ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ); - } - - bool operator!=( DecodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t IrapPicFlag : 1; - uint32_t IdrPicFlag : 1; - uint32_t IsReference : 1; - uint32_t short_term_ref_pic_set_sps_flag : 1; - }; - - struct DecodeH265PictureInfo - { - using NativeType = StdVideoDecodeH265PictureInfo; - - operator StdVideoDecodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH265PictureInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeH265PictureInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && - ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && - ( NumDeltaPocsOfRefRpsIdx == rhs.NumDeltaPocsOfRefRpsIdx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && - ( NumBitsForSTRefPicSetInSlice == rhs.NumBitsForSTRefPicSetInSlice ) && ( reserved == rhs.reserved ) && - ( RefPicSetStCurrBefore == rhs.RefPicSetStCurrBefore ) && ( RefPicSetStCurrAfter == rhs.RefPicSetStCurrAfter ) && - ( RefPicSetLtCurr == rhs.RefPicSetLtCurr ); - } - - bool operator!=( DecodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265PictureInfoFlags flags = {}; - uint8_t sps_video_parameter_set_id = {}; - uint8_t pps_seq_parameter_set_id = {}; - uint8_t pps_pic_parameter_set_id = {}; - uint8_t NumDeltaPocsOfRefRpsIdx = {}; - int32_t PicOrderCntVal = {}; - uint16_t NumBitsForSTRefPicSetInSlice = {}; - uint16_t reserved = {}; - ArrayWrapper1D RefPicSetStCurrBefore = {}; - ArrayWrapper1D RefPicSetStCurrAfter = {}; - ArrayWrapper1D RefPicSetLtCurr = {}; - }; - - struct DecodeH265ReferenceInfoFlags - { - using NativeType = StdVideoDecodeH265ReferenceInfoFlags; - - operator StdVideoDecodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH265ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeH265ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ); - } - - bool operator!=( DecodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t used_for_long_term_reference : 1; - uint32_t unused_for_reference : 1; - }; - - struct DecodeH265ReferenceInfo - { - using NativeType = StdVideoDecodeH265ReferenceInfo; - - operator StdVideoDecodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeH265ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeH265ReferenceInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( PicOrderCntVal == rhs.PicOrderCntVal ); - } - - bool operator!=( DecodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeH265ReferenceInfoFlags flags = {}; - int32_t PicOrderCntVal = {}; - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_H265STD_ENCODE_H_ ) - //=== vulkan_video_codec_h265std_encode === - - struct EncodeH265WeightTableFlags - { - using NativeType = StdVideoEncodeH265WeightTableFlags; - - operator StdVideoEncodeH265WeightTableFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265WeightTableFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265WeightTableFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH265WeightTableFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( luma_weight_l0_flag == rhs.luma_weight_l0_flag ) && ( chroma_weight_l0_flag == rhs.chroma_weight_l0_flag ) && - ( luma_weight_l1_flag == rhs.luma_weight_l1_flag ) && ( chroma_weight_l1_flag == rhs.chroma_weight_l1_flag ); - } - - bool operator!=( EncodeH265WeightTableFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint16_t luma_weight_l0_flag = {}; - uint16_t chroma_weight_l0_flag = {}; - uint16_t luma_weight_l1_flag = {}; - uint16_t chroma_weight_l1_flag = {}; - }; - - struct EncodeH265WeightTable - { - using NativeType = StdVideoEncodeH265WeightTable; - - operator StdVideoEncodeH265WeightTable const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265WeightTable &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265WeightTable const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH265WeightTable *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( luma_log2_weight_denom == rhs.luma_log2_weight_denom ) && - ( delta_chroma_log2_weight_denom == rhs.delta_chroma_log2_weight_denom ) && ( delta_luma_weight_l0 == rhs.delta_luma_weight_l0 ) && - ( luma_offset_l0 == rhs.luma_offset_l0 ) && ( delta_chroma_weight_l0 == rhs.delta_chroma_weight_l0 ) && - ( delta_chroma_offset_l0 == rhs.delta_chroma_offset_l0 ) && ( delta_luma_weight_l1 == rhs.delta_luma_weight_l1 ) && - ( luma_offset_l1 == rhs.luma_offset_l1 ) && ( delta_chroma_weight_l1 == rhs.delta_chroma_weight_l1 ) && - ( delta_chroma_offset_l1 == rhs.delta_chroma_offset_l1 ); - } - - bool operator!=( EncodeH265WeightTable const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTableFlags flags = {}; - uint8_t luma_log2_weight_denom = {}; - int8_t delta_chroma_log2_weight_denom = {}; - ArrayWrapper1D delta_luma_weight_l0 = {}; - ArrayWrapper1D luma_offset_l0 = {}; - ArrayWrapper2D delta_chroma_weight_l0 = {}; - ArrayWrapper2D delta_chroma_offset_l0 = {}; - ArrayWrapper1D delta_luma_weight_l1 = {}; - ArrayWrapper1D luma_offset_l1 = {}; - ArrayWrapper2D delta_chroma_weight_l1 = {}; - ArrayWrapper2D delta_chroma_offset_l1 = {}; - }; - - struct EncodeH265SliceSegmentHeaderFlags - { - using NativeType = StdVideoEncodeH265SliceSegmentHeaderFlags; - - operator StdVideoEncodeH265SliceSegmentHeaderFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265SliceSegmentHeaderFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265SliceSegmentHeaderFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH265SliceSegmentHeaderFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( first_slice_segment_in_pic_flag == rhs.first_slice_segment_in_pic_flag ) && - ( dependent_slice_segment_flag == rhs.dependent_slice_segment_flag ) && ( slice_sao_luma_flag == rhs.slice_sao_luma_flag ) && - ( slice_sao_chroma_flag == rhs.slice_sao_chroma_flag ) && ( num_ref_idx_active_override_flag == rhs.num_ref_idx_active_override_flag ) && - ( mvd_l1_zero_flag == rhs.mvd_l1_zero_flag ) && ( cabac_init_flag == rhs.cabac_init_flag ) && - ( cu_chroma_qp_offset_enabled_flag == rhs.cu_chroma_qp_offset_enabled_flag ) && - ( deblocking_filter_override_flag == rhs.deblocking_filter_override_flag ) && - ( slice_deblocking_filter_disabled_flag == rhs.slice_deblocking_filter_disabled_flag ) && - ( collocated_from_l0_flag == rhs.collocated_from_l0_flag ) && - ( slice_loop_filter_across_slices_enabled_flag == rhs.slice_loop_filter_across_slices_enabled_flag ) && ( reserved == rhs.reserved ); - } - - bool operator!=( EncodeH265SliceSegmentHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t first_slice_segment_in_pic_flag : 1; - uint32_t dependent_slice_segment_flag : 1; - uint32_t slice_sao_luma_flag : 1; - uint32_t slice_sao_chroma_flag : 1; - uint32_t num_ref_idx_active_override_flag : 1; - uint32_t mvd_l1_zero_flag : 1; - uint32_t cabac_init_flag : 1; - uint32_t cu_chroma_qp_offset_enabled_flag : 1; - uint32_t deblocking_filter_override_flag : 1; - uint32_t slice_deblocking_filter_disabled_flag : 1; - uint32_t collocated_from_l0_flag : 1; - uint32_t slice_loop_filter_across_slices_enabled_flag : 1; - uint32_t reserved : 20; - }; - - struct EncodeH265SliceSegmentHeader - { - using NativeType = StdVideoEncodeH265SliceSegmentHeader; - - operator StdVideoEncodeH265SliceSegmentHeader const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265SliceSegmentHeader &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265SliceSegmentHeader const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH265SliceSegmentHeader *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( slice_type == rhs.slice_type ) && ( slice_segment_address == rhs.slice_segment_address ) && - ( collocated_ref_idx == rhs.collocated_ref_idx ) && ( MaxNumMergeCand == rhs.MaxNumMergeCand ) && - ( slice_cb_qp_offset == rhs.slice_cb_qp_offset ) && ( slice_cr_qp_offset == rhs.slice_cr_qp_offset ) && - ( slice_beta_offset_div2 == rhs.slice_beta_offset_div2 ) && ( slice_tc_offset_div2 == rhs.slice_tc_offset_div2 ) && - ( slice_act_y_qp_offset == rhs.slice_act_y_qp_offset ) && ( slice_act_cb_qp_offset == rhs.slice_act_cb_qp_offset ) && - ( slice_act_cr_qp_offset == rhs.slice_act_cr_qp_offset ) && ( slice_qp_delta == rhs.slice_qp_delta ) && ( reserved1 == rhs.reserved1 ) && - ( pWeightTable == rhs.pWeightTable ); - } - - bool operator!=( EncodeH265SliceSegmentHeader const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265SliceSegmentHeaderFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType slice_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265SliceType::eB; - uint32_t slice_segment_address = {}; - uint8_t collocated_ref_idx = {}; - uint8_t MaxNumMergeCand = {}; - int8_t slice_cb_qp_offset = {}; - int8_t slice_cr_qp_offset = {}; - int8_t slice_beta_offset_div2 = {}; - int8_t slice_tc_offset_div2 = {}; - int8_t slice_act_y_qp_offset = {}; - int8_t slice_act_cb_qp_offset = {}; - int8_t slice_act_cr_qp_offset = {}; - int8_t slice_qp_delta = {}; - uint16_t reserved1 = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265WeightTable * pWeightTable = {}; - }; - - struct EncodeH265ReferenceListsInfoFlags - { - using NativeType = StdVideoEncodeH265ReferenceListsInfoFlags; - - operator StdVideoEncodeH265ReferenceListsInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceListsInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceListsInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceListsInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( ref_pic_list_modification_flag_l0 == rhs.ref_pic_list_modification_flag_l0 ) && - ( ref_pic_list_modification_flag_l1 == rhs.ref_pic_list_modification_flag_l1 ) && ( reserved == rhs.reserved ); - } - - bool operator!=( EncodeH265ReferenceListsInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t ref_pic_list_modification_flag_l0 : 1; - uint32_t ref_pic_list_modification_flag_l1 : 1; - uint32_t reserved : 30; - }; - - struct EncodeH265ReferenceListsInfo - { - using NativeType = StdVideoEncodeH265ReferenceListsInfo; - - operator StdVideoEncodeH265ReferenceListsInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceListsInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceListsInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceListsInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( num_ref_idx_l0_active_minus1 == rhs.num_ref_idx_l0_active_minus1 ) && - ( num_ref_idx_l1_active_minus1 == rhs.num_ref_idx_l1_active_minus1 ) && ( RefPicList0 == rhs.RefPicList0 ) && - ( RefPicList1 == rhs.RefPicList1 ) && ( list_entry_l0 == rhs.list_entry_l0 ) && ( list_entry_l1 == rhs.list_entry_l1 ); - } - - bool operator!=( EncodeH265ReferenceListsInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfoFlags flags = {}; - uint8_t num_ref_idx_l0_active_minus1 = {}; - uint8_t num_ref_idx_l1_active_minus1 = {}; - ArrayWrapper1D RefPicList0 = {}; - ArrayWrapper1D RefPicList1 = {}; - ArrayWrapper1D list_entry_l0 = {}; - ArrayWrapper1D list_entry_l1 = {}; - }; - - struct EncodeH265PictureInfoFlags - { - using NativeType = StdVideoEncodeH265PictureInfoFlags; - - operator StdVideoEncodeH265PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265PictureInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH265PictureInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( is_reference == rhs.is_reference ) && ( IrapPicFlag == rhs.IrapPicFlag ) && - ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( discardable_flag == rhs.discardable_flag ) && - ( cross_layer_bla_flag == rhs.cross_layer_bla_flag ) && ( pic_output_flag == rhs.pic_output_flag ) && - ( no_output_of_prior_pics_flag == rhs.no_output_of_prior_pics_flag ) && - ( short_term_ref_pic_set_sps_flag == rhs.short_term_ref_pic_set_sps_flag ) && - ( slice_temporal_mvp_enabled_flag == rhs.slice_temporal_mvp_enabled_flag ) && ( reserved == rhs.reserved ); - } - - bool operator!=( EncodeH265PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t is_reference : 1; - uint32_t IrapPicFlag : 1; - uint32_t used_for_long_term_reference : 1; - uint32_t discardable_flag : 1; - uint32_t cross_layer_bla_flag : 1; - uint32_t pic_output_flag : 1; - uint32_t no_output_of_prior_pics_flag : 1; - uint32_t short_term_ref_pic_set_sps_flag : 1; - uint32_t slice_temporal_mvp_enabled_flag : 1; - uint32_t reserved : 23; - }; - - struct EncodeH265LongTermRefPics - { - using NativeType = StdVideoEncodeH265LongTermRefPics; - - operator StdVideoEncodeH265LongTermRefPics const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265LongTermRefPics &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265LongTermRefPics const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH265LongTermRefPics *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( num_long_term_sps == rhs.num_long_term_sps ) && ( num_long_term_pics == rhs.num_long_term_pics ) && ( lt_idx_sps == rhs.lt_idx_sps ) && - ( poc_lsb_lt == rhs.poc_lsb_lt ) && ( used_by_curr_pic_lt_flag == rhs.used_by_curr_pic_lt_flag ) && - ( delta_poc_msb_present_flag == rhs.delta_poc_msb_present_flag ) && ( delta_poc_msb_cycle_lt == rhs.delta_poc_msb_cycle_lt ); - } - - bool operator!=( EncodeH265LongTermRefPics const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint8_t num_long_term_sps = {}; - uint8_t num_long_term_pics = {}; - ArrayWrapper1D lt_idx_sps = {}; - ArrayWrapper1D poc_lsb_lt = {}; - uint16_t used_by_curr_pic_lt_flag = {}; - ArrayWrapper1D delta_poc_msb_present_flag = {}; - ArrayWrapper1D delta_poc_msb_cycle_lt = {}; - }; - - struct EncodeH265PictureInfo - { - using NativeType = StdVideoEncodeH265PictureInfo; - - operator StdVideoEncodeH265PictureInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265PictureInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265PictureInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH265PictureInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( sps_video_parameter_set_id == rhs.sps_video_parameter_set_id ) && - ( pps_seq_parameter_set_id == rhs.pps_seq_parameter_set_id ) && ( pps_pic_parameter_set_id == rhs.pps_pic_parameter_set_id ) && - ( short_term_ref_pic_set_idx == rhs.short_term_ref_pic_set_idx ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && - ( TemporalId == rhs.TemporalId ) && ( reserved1 == rhs.reserved1 ) && ( pRefLists == rhs.pRefLists ) && - ( pShortTermRefPicSet == rhs.pShortTermRefPicSet ) && ( pLongTermRefPics == rhs.pLongTermRefPics ); - } - - bool operator!=( EncodeH265PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265PictureInfoFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP; - uint8_t sps_video_parameter_set_id = {}; - uint8_t pps_seq_parameter_set_id = {}; - uint8_t pps_pic_parameter_set_id = {}; - uint8_t short_term_ref_pic_set_idx = {}; - int32_t PicOrderCntVal = {}; - uint8_t TemporalId = {}; - ArrayWrapper1D reserved1 = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceListsInfo * pRefLists = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265ShortTermRefPicSet * pShortTermRefPicSet = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265LongTermRefPics * pLongTermRefPics = {}; - }; - - struct EncodeH265ReferenceInfoFlags - { - using NativeType = StdVideoEncodeH265ReferenceInfoFlags; - - operator StdVideoEncodeH265ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( used_for_long_term_reference == rhs.used_for_long_term_reference ) && ( unused_for_reference == rhs.unused_for_reference ) && - ( reserved == rhs.reserved ); - } - - bool operator!=( EncodeH265ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t used_for_long_term_reference : 1; - uint32_t unused_for_reference : 1; - uint32_t reserved : 30; - }; - - struct EncodeH265ReferenceInfo - { - using NativeType = StdVideoEncodeH265ReferenceInfo; - - operator StdVideoEncodeH265ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeH265ReferenceInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( pic_type == rhs.pic_type ) && ( PicOrderCntVal == rhs.PicOrderCntVal ) && ( TemporalId == rhs.TemporalId ); - } - - bool operator!=( EncodeH265ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeH265ReferenceInfoFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType pic_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::H265PictureType::eP; - int32_t PicOrderCntVal = {}; - uint8_t TemporalId = {}; - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_VP9STD_H_ ) - //=== vulkan_video_codec_vp9std === - - struct VP9ColorConfigFlags - { - using NativeType = StdVideoVP9ColorConfigFlags; - - operator StdVideoVP9ColorConfigFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9ColorConfigFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9ColorConfigFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoVP9ColorConfigFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( VP9ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( color_range == rhs.color_range ) && ( reserved == rhs.reserved ); - } - - bool operator!=( VP9ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t color_range : 1; - uint32_t reserved : 31; - }; - - struct VP9ColorConfig - { - using NativeType = StdVideoVP9ColorConfig; - - operator StdVideoVP9ColorConfig const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9ColorConfig &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9ColorConfig const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoVP9ColorConfig *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) && - ( reserved1 == rhs.reserved1 ) && ( color_space == rhs.color_space ); - } - - bool operator!=( VP9ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfigFlags flags = {}; - uint8_t BitDepth = {}; - uint8_t subsampling_x = {}; - uint8_t subsampling_y = {}; - uint8_t reserved1 = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace color_space = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorSpace::eUnknown; - }; - - struct VP9LoopFilterFlags - { - using NativeType = StdVideoVP9LoopFilterFlags; - - operator StdVideoVP9LoopFilterFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9LoopFilterFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9LoopFilterFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoVP9LoopFilterFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( VP9LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) && - ( reserved == rhs.reserved ); - } - - bool operator!=( VP9LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t loop_filter_delta_enabled : 1; - uint32_t loop_filter_delta_update : 1; - uint32_t reserved : 30; - }; - - struct VP9LoopFilter - { - using NativeType = StdVideoVP9LoopFilter; - - operator StdVideoVP9LoopFilter const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9LoopFilter &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9LoopFilter const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoVP9LoopFilter *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) && - ( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) && - ( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas ); - } - - bool operator!=( VP9LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilterFlags flags = {}; - uint8_t loop_filter_level = {}; - uint8_t loop_filter_sharpness = {}; - uint8_t update_ref_delta = {}; - ArrayWrapper1D loop_filter_ref_deltas = {}; - uint8_t update_mode_delta = {}; - ArrayWrapper1D loop_filter_mode_deltas = {}; - }; - - struct VP9SegmentationFlags - { - using NativeType = StdVideoVP9SegmentationFlags; - - operator StdVideoVP9SegmentationFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9SegmentationFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9SegmentationFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoVP9SegmentationFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( VP9SegmentationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( segmentation_update_map == rhs.segmentation_update_map ) && ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && - ( segmentation_update_data == rhs.segmentation_update_data ) && ( segmentation_abs_or_delta_update == rhs.segmentation_abs_or_delta_update ) && - ( reserved == rhs.reserved ); - } - - bool operator!=( VP9SegmentationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t segmentation_update_map : 1; - uint32_t segmentation_temporal_update : 1; - uint32_t segmentation_update_data : 1; - uint32_t segmentation_abs_or_delta_update : 1; - uint32_t reserved : 28; - }; - - struct VP9Segmentation - { - using NativeType = StdVideoVP9Segmentation; - - operator StdVideoVP9Segmentation const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9Segmentation &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoVP9Segmentation const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoVP9Segmentation *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( segmentation_tree_probs == rhs.segmentation_tree_probs ) && - ( segmentation_pred_prob == rhs.segmentation_pred_prob ) && ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData ); - } - - bool operator!=( VP9Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9SegmentationFlags flags = {}; - ArrayWrapper1D segmentation_tree_probs = {}; - ArrayWrapper1D segmentation_pred_prob = {}; - ArrayWrapper1D FeatureEnabled = {}; - ArrayWrapper2D FeatureData = {}; - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_VP9STD_DECODE_H_ ) - //=== vulkan_video_codec_vp9std_decode === - - struct DecodeVP9PictureInfoFlags - { - using NativeType = StdVideoDecodeVP9PictureInfoFlags; - - operator StdVideoDecodeVP9PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeVP9PictureInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeVP9PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeVP9PictureInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( error_resilient_mode == rhs.error_resilient_mode ) && ( intra_only == rhs.intra_only ) && - ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && ( refresh_frame_context == rhs.refresh_frame_context ) && - ( frame_parallel_decoding_mode == rhs.frame_parallel_decoding_mode ) && ( segmentation_enabled == rhs.segmentation_enabled ) && - ( show_frame == rhs.show_frame ) && ( UsePrevFrameMvs == rhs.UsePrevFrameMvs ) && ( reserved == rhs.reserved ); - } - - bool operator!=( DecodeVP9PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t error_resilient_mode : 1; - uint32_t intra_only : 1; - uint32_t allow_high_precision_mv : 1; - uint32_t refresh_frame_context : 1; - uint32_t frame_parallel_decoding_mode : 1; - uint32_t segmentation_enabled : 1; - uint32_t show_frame : 1; - uint32_t UsePrevFrameMvs : 1; - uint32_t reserved : 24; - }; - - struct DecodeVP9PictureInfo - { - using NativeType = StdVideoDecodeVP9PictureInfo; - - operator StdVideoDecodeVP9PictureInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeVP9PictureInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeVP9PictureInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeVP9PictureInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeVP9PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( profile == rhs.profile ) && ( frame_type == rhs.frame_type ) && ( frame_context_idx == rhs.frame_context_idx ) && - ( reset_frame_context == rhs.reset_frame_context ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) && - ( ref_frame_sign_bias_mask == rhs.ref_frame_sign_bias_mask ) && ( interpolation_filter == rhs.interpolation_filter ) && - ( base_q_idx == rhs.base_q_idx ) && ( delta_q_y_dc == rhs.delta_q_y_dc ) && ( delta_q_uv_dc == rhs.delta_q_uv_dc ) && - ( delta_q_uv_ac == rhs.delta_q_uv_ac ) && ( tile_cols_log2 == rhs.tile_cols_log2 ) && ( tile_rows_log2 == rhs.tile_rows_log2 ) && - ( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pLoopFilter == rhs.pLoopFilter ) && - ( pSegmentation == rhs.pSegmentation ); - } - - bool operator!=( DecodeVP9PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeVP9PictureInfoFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile profile = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Profile::e0; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9FrameType::eKey; - uint8_t frame_context_idx = {}; - uint8_t reset_frame_context = {}; - uint8_t refresh_frame_flags = {}; - uint8_t ref_frame_sign_bias_mask = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter interpolation_filter = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9InterpolationFilter::eEighttap; - uint8_t base_q_idx = {}; - int8_t delta_q_y_dc = {}; - int8_t delta_q_uv_dc = {}; - int8_t delta_q_uv_ac = {}; - uint8_t tile_cols_log2 = {}; - uint8_t tile_rows_log2 = {}; - ArrayWrapper1D reserved1 = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9ColorConfig * pColorConfig = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9LoopFilter * pLoopFilter = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::VP9Segmentation * pSegmentation = {}; - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_AV1STD_H_ ) - //=== vulkan_video_codec_av1std === - - struct AV1ColorConfigFlags - { - using NativeType = StdVideoAV1ColorConfigFlags; - - operator StdVideoAV1ColorConfigFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1ColorConfigFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1ColorConfigFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1ColorConfigFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( mono_chrome == rhs.mono_chrome ) && ( color_range == rhs.color_range ) && ( separate_uv_delta_q == rhs.separate_uv_delta_q ) && - ( color_description_present_flag == rhs.color_description_present_flag ) && ( reserved == rhs.reserved ); - } - - bool operator!=( AV1ColorConfigFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t mono_chrome : 1; - uint32_t color_range : 1; - uint32_t separate_uv_delta_q : 1; - uint32_t color_description_present_flag : 1; - uint32_t reserved : 28; - }; - - struct AV1ColorConfig - { - using NativeType = StdVideoAV1ColorConfig; - - operator StdVideoAV1ColorConfig const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1ColorConfig &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1ColorConfig const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1ColorConfig *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( BitDepth == rhs.BitDepth ) && ( subsampling_x == rhs.subsampling_x ) && ( subsampling_y == rhs.subsampling_y ) && - ( reserved1 == rhs.reserved1 ) && ( color_primaries == rhs.color_primaries ) && ( transfer_characteristics == rhs.transfer_characteristics ) && - ( matrix_coefficients == rhs.matrix_coefficients ) && ( chroma_sample_position == rhs.chroma_sample_position ); - } - - bool operator!=( AV1ColorConfig const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfigFlags flags = {}; - uint8_t BitDepth = {}; - uint8_t subsampling_x = {}; - uint8_t subsampling_y = {}; - uint8_t reserved1 = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries color_primaries = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorPrimaries::eBt709; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics transfer_characteristics = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TransferCharacteristics::eReserved0; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients matrix_coefficients = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1MatrixCoefficients::eIdentity; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition chroma_sample_position = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ChromaSamplePosition::eUnknown; - }; - - struct AV1TimingInfoFlags - { - using NativeType = StdVideoAV1TimingInfoFlags; - - operator StdVideoAV1TimingInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1TimingInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1TimingInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1TimingInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1TimingInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( equal_picture_interval == rhs.equal_picture_interval ) && ( reserved == rhs.reserved ); - } - - bool operator!=( AV1TimingInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t equal_picture_interval : 1; - uint32_t reserved : 31; - }; - - struct AV1TimingInfo - { - using NativeType = StdVideoAV1TimingInfo; - - operator StdVideoAV1TimingInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1TimingInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1TimingInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1TimingInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( num_units_in_display_tick == rhs.num_units_in_display_tick ) && ( time_scale == rhs.time_scale ) && - ( num_ticks_per_picture_minus_1 == rhs.num_ticks_per_picture_minus_1 ); - } - - bool operator!=( AV1TimingInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfoFlags flags = {}; - uint32_t num_units_in_display_tick = {}; - uint32_t time_scale = {}; - uint32_t num_ticks_per_picture_minus_1 = {}; - }; - - struct AV1LoopFilterFlags - { - using NativeType = StdVideoAV1LoopFilterFlags; - - operator StdVideoAV1LoopFilterFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1LoopFilterFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1LoopFilterFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1LoopFilterFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( loop_filter_delta_enabled == rhs.loop_filter_delta_enabled ) && ( loop_filter_delta_update == rhs.loop_filter_delta_update ) && - ( reserved == rhs.reserved ); - } - - bool operator!=( AV1LoopFilterFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t loop_filter_delta_enabled : 1; - uint32_t loop_filter_delta_update : 1; - uint32_t reserved : 30; - }; - - struct AV1LoopFilter - { - using NativeType = StdVideoAV1LoopFilter; - - operator StdVideoAV1LoopFilter const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1LoopFilter &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1LoopFilter const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1LoopFilter *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( loop_filter_level == rhs.loop_filter_level ) && ( loop_filter_sharpness == rhs.loop_filter_sharpness ) && - ( update_ref_delta == rhs.update_ref_delta ) && ( loop_filter_ref_deltas == rhs.loop_filter_ref_deltas ) && - ( update_mode_delta == rhs.update_mode_delta ) && ( loop_filter_mode_deltas == rhs.loop_filter_mode_deltas ); - } - - bool operator!=( AV1LoopFilter const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilterFlags flags = {}; - ArrayWrapper1D loop_filter_level = {}; - uint8_t loop_filter_sharpness = {}; - uint8_t update_ref_delta = {}; - ArrayWrapper1D loop_filter_ref_deltas = {}; - uint8_t update_mode_delta = {}; - ArrayWrapper1D loop_filter_mode_deltas = {}; - }; - - struct AV1QuantizationFlags - { - using NativeType = StdVideoAV1QuantizationFlags; - - operator StdVideoAV1QuantizationFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1QuantizationFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1QuantizationFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1QuantizationFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1QuantizationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( using_qmatrix == rhs.using_qmatrix ) && ( diff_uv_delta == rhs.diff_uv_delta ) && ( reserved == rhs.reserved ); - } - - bool operator!=( AV1QuantizationFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t using_qmatrix : 1; - uint32_t diff_uv_delta : 1; - uint32_t reserved : 30; - }; - - struct AV1Quantization - { - using NativeType = StdVideoAV1Quantization; - - operator StdVideoAV1Quantization const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1Quantization &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1Quantization const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1Quantization *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( base_q_idx == rhs.base_q_idx ) && ( DeltaQYDc == rhs.DeltaQYDc ) && ( DeltaQUDc == rhs.DeltaQUDc ) && - ( DeltaQUAc == rhs.DeltaQUAc ) && ( DeltaQVDc == rhs.DeltaQVDc ) && ( DeltaQVAc == rhs.DeltaQVAc ) && ( qm_y == rhs.qm_y ) && - ( qm_u == rhs.qm_u ) && ( qm_v == rhs.qm_v ); - } - - bool operator!=( AV1Quantization const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1QuantizationFlags flags = {}; - uint8_t base_q_idx = {}; - int8_t DeltaQYDc = {}; - int8_t DeltaQUDc = {}; - int8_t DeltaQUAc = {}; - int8_t DeltaQVDc = {}; - int8_t DeltaQVAc = {}; - uint8_t qm_y = {}; - uint8_t qm_u = {}; - uint8_t qm_v = {}; - }; - - struct AV1Segmentation - { - using NativeType = StdVideoAV1Segmentation; - - operator StdVideoAV1Segmentation const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1Segmentation &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1Segmentation const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1Segmentation *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( FeatureEnabled == rhs.FeatureEnabled ) && ( FeatureData == rhs.FeatureData ); - } - - bool operator!=( AV1Segmentation const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - ArrayWrapper1D FeatureEnabled = {}; - ArrayWrapper2D FeatureData = {}; - }; - - struct AV1TileInfoFlags - { - using NativeType = StdVideoAV1TileInfoFlags; - - operator StdVideoAV1TileInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1TileInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1TileInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1TileInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1TileInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( uniform_tile_spacing_flag == rhs.uniform_tile_spacing_flag ) && ( reserved == rhs.reserved ); - } - - bool operator!=( AV1TileInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t uniform_tile_spacing_flag : 1; - uint32_t reserved : 31; - }; - - struct AV1TileInfo - { - using NativeType = StdVideoAV1TileInfo; - - operator StdVideoAV1TileInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1TileInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1TileInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1TileInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( TileCols == rhs.TileCols ) && ( TileRows == rhs.TileRows ) && - ( context_update_tile_id == rhs.context_update_tile_id ) && ( tile_size_bytes_minus_1 == rhs.tile_size_bytes_minus_1 ) && - ( reserved1 == rhs.reserved1 ) && ( pMiColStarts == rhs.pMiColStarts ) && ( pMiRowStarts == rhs.pMiRowStarts ) && - ( pWidthInSbsMinus1 == rhs.pWidthInSbsMinus1 ) && ( pHeightInSbsMinus1 == rhs.pHeightInSbsMinus1 ); - } - - bool operator!=( AV1TileInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfoFlags flags = {}; - uint8_t TileCols = {}; - uint8_t TileRows = {}; - uint16_t context_update_tile_id = {}; - uint8_t tile_size_bytes_minus_1 = {}; - ArrayWrapper1D reserved1 = {}; - const uint16_t * pMiColStarts = {}; - const uint16_t * pMiRowStarts = {}; - const uint16_t * pWidthInSbsMinus1 = {}; - const uint16_t * pHeightInSbsMinus1 = {}; - }; - - struct AV1CDEF - { - using NativeType = StdVideoAV1CDEF; - - operator StdVideoAV1CDEF const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1CDEF &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1CDEF const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1CDEF *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( cdef_damping_minus_3 == rhs.cdef_damping_minus_3 ) && ( cdef_bits == rhs.cdef_bits ) && ( cdef_y_pri_strength == rhs.cdef_y_pri_strength ) && - ( cdef_y_sec_strength == rhs.cdef_y_sec_strength ) && ( cdef_uv_pri_strength == rhs.cdef_uv_pri_strength ) && - ( cdef_uv_sec_strength == rhs.cdef_uv_sec_strength ); - } - - bool operator!=( AV1CDEF const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint8_t cdef_damping_minus_3 = {}; - uint8_t cdef_bits = {}; - ArrayWrapper1D cdef_y_pri_strength = {}; - ArrayWrapper1D cdef_y_sec_strength = {}; - ArrayWrapper1D cdef_uv_pri_strength = {}; - ArrayWrapper1D cdef_uv_sec_strength = {}; - }; - - struct AV1LoopRestoration - { - using NativeType = StdVideoAV1LoopRestoration; - - operator StdVideoAV1LoopRestoration const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1LoopRestoration &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1LoopRestoration const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1LoopRestoration *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1LoopRestoration const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( FrameRestorationType == rhs.FrameRestorationType ) && ( LoopRestorationSize == rhs.LoopRestorationSize ); - } - - bool operator!=( AV1LoopRestoration const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - ArrayWrapper1D FrameRestorationType = {}; - ArrayWrapper1D LoopRestorationSize = {}; - }; - - struct AV1GlobalMotion - { - using NativeType = StdVideoAV1GlobalMotion; - - operator StdVideoAV1GlobalMotion const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1GlobalMotion &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1GlobalMotion const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1GlobalMotion *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1GlobalMotion const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( GmType == rhs.GmType ) && ( gm_params == rhs.gm_params ); - } - - bool operator!=( AV1GlobalMotion const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - ArrayWrapper1D GmType = {}; - ArrayWrapper2D gm_params = {}; - }; - - struct AV1FilmGrainFlags - { - using NativeType = StdVideoAV1FilmGrainFlags; - - operator StdVideoAV1FilmGrainFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1FilmGrainFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1FilmGrainFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1FilmGrainFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( chroma_scaling_from_luma == rhs.chroma_scaling_from_luma ) && ( overlap_flag == rhs.overlap_flag ) && - ( clip_to_restricted_range == rhs.clip_to_restricted_range ) && ( update_grain == rhs.update_grain ) && ( reserved == rhs.reserved ); - } - - bool operator!=( AV1FilmGrainFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t chroma_scaling_from_luma : 1; - uint32_t overlap_flag : 1; - uint32_t clip_to_restricted_range : 1; - uint32_t update_grain : 1; - uint32_t reserved : 28; - }; - - struct AV1FilmGrain - { - using NativeType = StdVideoAV1FilmGrain; - - operator StdVideoAV1FilmGrain const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1FilmGrain &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1FilmGrain const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1FilmGrain *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( grain_scaling_minus_8 == rhs.grain_scaling_minus_8 ) && ( ar_coeff_lag == rhs.ar_coeff_lag ) && - ( ar_coeff_shift_minus_6 == rhs.ar_coeff_shift_minus_6 ) && ( grain_scale_shift == rhs.grain_scale_shift ) && ( grain_seed == rhs.grain_seed ) && - ( film_grain_params_ref_idx == rhs.film_grain_params_ref_idx ) && ( num_y_points == rhs.num_y_points ) && - ( point_y_value == rhs.point_y_value ) && ( point_y_scaling == rhs.point_y_scaling ) && ( num_cb_points == rhs.num_cb_points ) && - ( point_cb_value == rhs.point_cb_value ) && ( point_cb_scaling == rhs.point_cb_scaling ) && ( num_cr_points == rhs.num_cr_points ) && - ( point_cr_value == rhs.point_cr_value ) && ( point_cr_scaling == rhs.point_cr_scaling ) && - ( ar_coeffs_y_plus_128 == rhs.ar_coeffs_y_plus_128 ) && ( ar_coeffs_cb_plus_128 == rhs.ar_coeffs_cb_plus_128 ) && - ( ar_coeffs_cr_plus_128 == rhs.ar_coeffs_cr_plus_128 ) && ( cb_mult == rhs.cb_mult ) && ( cb_luma_mult == rhs.cb_luma_mult ) && - ( cb_offset == rhs.cb_offset ) && ( cr_mult == rhs.cr_mult ) && ( cr_luma_mult == rhs.cr_luma_mult ) && ( cr_offset == rhs.cr_offset ); - } - - bool operator!=( AV1FilmGrain const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrainFlags flags = {}; - uint8_t grain_scaling_minus_8 = {}; - uint8_t ar_coeff_lag = {}; - uint8_t ar_coeff_shift_minus_6 = {}; - uint8_t grain_scale_shift = {}; - uint16_t grain_seed = {}; - uint8_t film_grain_params_ref_idx = {}; - uint8_t num_y_points = {}; - ArrayWrapper1D point_y_value = {}; - ArrayWrapper1D point_y_scaling = {}; - uint8_t num_cb_points = {}; - ArrayWrapper1D point_cb_value = {}; - ArrayWrapper1D point_cb_scaling = {}; - uint8_t num_cr_points = {}; - ArrayWrapper1D point_cr_value = {}; - ArrayWrapper1D point_cr_scaling = {}; - ArrayWrapper1D ar_coeffs_y_plus_128 = {}; - ArrayWrapper1D ar_coeffs_cb_plus_128 = {}; - ArrayWrapper1D ar_coeffs_cr_plus_128 = {}; - uint8_t cb_mult = {}; - uint8_t cb_luma_mult = {}; - uint16_t cb_offset = {}; - uint8_t cr_mult = {}; - uint8_t cr_luma_mult = {}; - uint16_t cr_offset = {}; - }; - - struct AV1SequenceHeaderFlags - { - using NativeType = StdVideoAV1SequenceHeaderFlags; - - operator StdVideoAV1SequenceHeaderFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1SequenceHeaderFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1SequenceHeaderFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1SequenceHeaderFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( still_picture == rhs.still_picture ) && ( reduced_still_picture_header == rhs.reduced_still_picture_header ) && - ( use_128x128_superblock == rhs.use_128x128_superblock ) && ( enable_filter_intra == rhs.enable_filter_intra ) && - ( enable_intra_edge_filter == rhs.enable_intra_edge_filter ) && ( enable_interintra_compound == rhs.enable_interintra_compound ) && - ( enable_masked_compound == rhs.enable_masked_compound ) && ( enable_warped_motion == rhs.enable_warped_motion ) && - ( enable_dual_filter == rhs.enable_dual_filter ) && ( enable_order_hint == rhs.enable_order_hint ) && - ( enable_jnt_comp == rhs.enable_jnt_comp ) && ( enable_ref_frame_mvs == rhs.enable_ref_frame_mvs ) && - ( frame_id_numbers_present_flag == rhs.frame_id_numbers_present_flag ) && ( enable_superres == rhs.enable_superres ) && - ( enable_cdef == rhs.enable_cdef ) && ( enable_restoration == rhs.enable_restoration ) && - ( film_grain_params_present == rhs.film_grain_params_present ) && ( timing_info_present_flag == rhs.timing_info_present_flag ) && - ( initial_display_delay_present_flag == rhs.initial_display_delay_present_flag ) && ( reserved == rhs.reserved ); - } - - bool operator!=( AV1SequenceHeaderFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t still_picture : 1; - uint32_t reduced_still_picture_header : 1; - uint32_t use_128x128_superblock : 1; - uint32_t enable_filter_intra : 1; - uint32_t enable_intra_edge_filter : 1; - uint32_t enable_interintra_compound : 1; - uint32_t enable_masked_compound : 1; - uint32_t enable_warped_motion : 1; - uint32_t enable_dual_filter : 1; - uint32_t enable_order_hint : 1; - uint32_t enable_jnt_comp : 1; - uint32_t enable_ref_frame_mvs : 1; - uint32_t frame_id_numbers_present_flag : 1; - uint32_t enable_superres : 1; - uint32_t enable_cdef : 1; - uint32_t enable_restoration : 1; - uint32_t film_grain_params_present : 1; - uint32_t timing_info_present_flag : 1; - uint32_t initial_display_delay_present_flag : 1; - uint32_t reserved : 13; - }; - - struct AV1SequenceHeader - { - using NativeType = StdVideoAV1SequenceHeader; - - operator StdVideoAV1SequenceHeader const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1SequenceHeader &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoAV1SequenceHeader const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoAV1SequenceHeader *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( seq_profile == rhs.seq_profile ) && ( frame_width_bits_minus_1 == rhs.frame_width_bits_minus_1 ) && - ( frame_height_bits_minus_1 == rhs.frame_height_bits_minus_1 ) && ( max_frame_width_minus_1 == rhs.max_frame_width_minus_1 ) && - ( max_frame_height_minus_1 == rhs.max_frame_height_minus_1 ) && ( delta_frame_id_length_minus_2 == rhs.delta_frame_id_length_minus_2 ) && - ( additional_frame_id_length_minus_1 == rhs.additional_frame_id_length_minus_1 ) && ( order_hint_bits_minus_1 == rhs.order_hint_bits_minus_1 ) && - ( seq_force_integer_mv == rhs.seq_force_integer_mv ) && ( seq_force_screen_content_tools == rhs.seq_force_screen_content_tools ) && - ( reserved1 == rhs.reserved1 ) && ( pColorConfig == rhs.pColorConfig ) && ( pTimingInfo == rhs.pTimingInfo ); - } - - bool operator!=( AV1SequenceHeader const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1SequenceHeaderFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile seq_profile = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Profile::eMain; - uint8_t frame_width_bits_minus_1 = {}; - uint8_t frame_height_bits_minus_1 = {}; - uint16_t max_frame_width_minus_1 = {}; - uint16_t max_frame_height_minus_1 = {}; - uint8_t delta_frame_id_length_minus_2 = {}; - uint8_t additional_frame_id_length_minus_1 = {}; - uint8_t order_hint_bits_minus_1 = {}; - uint8_t seq_force_integer_mv = {}; - uint8_t seq_force_screen_content_tools = {}; - ArrayWrapper1D reserved1 = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1ColorConfig * pColorConfig = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TimingInfo * pTimingInfo = {}; - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_AV1STD_DECODE_H_ ) - //=== vulkan_video_codec_av1std_decode === - - struct DecodeAV1PictureInfoFlags - { - using NativeType = StdVideoDecodeAV1PictureInfoFlags; - - operator StdVideoDecodeAV1PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1PictureInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1PictureInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) && - ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) && - ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) && - ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) && - ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) && - ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && - ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) && - ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) && - ( reduced_tx_set == rhs.reduced_tx_set ) && ( reference_select == rhs.reference_select ) && ( skip_mode_present == rhs.skip_mode_present ) && - ( delta_q_present == rhs.delta_q_present ) && ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) && - ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) && - ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) && - ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( apply_grain == rhs.apply_grain ) && ( reserved == rhs.reserved ); - } - - bool operator!=( DecodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t error_resilient_mode : 1; - uint32_t disable_cdf_update : 1; - uint32_t use_superres : 1; - uint32_t render_and_frame_size_different : 1; - uint32_t allow_screen_content_tools : 1; - uint32_t is_filter_switchable : 1; - uint32_t force_integer_mv : 1; - uint32_t frame_size_override_flag : 1; - uint32_t buffer_removal_time_present_flag : 1; - uint32_t allow_intrabc : 1; - uint32_t frame_refs_short_signaling : 1; - uint32_t allow_high_precision_mv : 1; - uint32_t is_motion_mode_switchable : 1; - uint32_t use_ref_frame_mvs : 1; - uint32_t disable_frame_end_update_cdf : 1; - uint32_t allow_warped_motion : 1; - uint32_t reduced_tx_set : 1; - uint32_t reference_select : 1; - uint32_t skip_mode_present : 1; - uint32_t delta_q_present : 1; - uint32_t delta_lf_present : 1; - uint32_t delta_lf_multi : 1; - uint32_t segmentation_enabled : 1; - uint32_t segmentation_update_map : 1; - uint32_t segmentation_temporal_update : 1; - uint32_t segmentation_update_data : 1; - uint32_t UsesLr : 1; - uint32_t usesChromaLr : 1; - uint32_t apply_grain : 1; - uint32_t reserved : 3; - }; - - struct DecodeAV1PictureInfo - { - using NativeType = StdVideoDecodeAV1PictureInfo; - - operator StdVideoDecodeAV1PictureInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1PictureInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1PictureInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1PictureInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( current_frame_id == rhs.current_frame_id ) && ( OrderHint == rhs.OrderHint ) && - ( primary_ref_frame == rhs.primary_ref_frame ) && ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( reserved1 == rhs.reserved1 ) && - ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) && - ( delta_lf_res == rhs.delta_lf_res ) && ( SkipModeFrame == rhs.SkipModeFrame ) && ( coded_denom == rhs.coded_denom ) && - ( reserved2 == rhs.reserved2 ) && ( OrderHints == rhs.OrderHints ) && ( expectedFrameId == rhs.expectedFrameId ) && - ( pTileInfo == rhs.pTileInfo ) && ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && - ( pLoopFilter == rhs.pLoopFilter ) && ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && - ( pGlobalMotion == rhs.pGlobalMotion ) && ( pFilmGrain == rhs.pFilmGrain ); - } - - bool operator!=( DecodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1PictureInfoFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey; - uint32_t current_frame_id = {}; - uint8_t OrderHint = {}; - uint8_t primary_ref_frame = {}; - uint8_t refresh_frame_flags = {}; - uint8_t reserved1 = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter interpolation_filter = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter::eEighttap; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4; - uint8_t delta_q_res = {}; - uint8_t delta_lf_res = {}; - ArrayWrapper1D SkipModeFrame = {}; - uint8_t coded_denom = {}; - ArrayWrapper1D reserved2 = {}; - ArrayWrapper1D OrderHints = {}; - ArrayWrapper1D expectedFrameId = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter * pLoopFilter = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF * pCDEF = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration * pLoopRestoration = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion * pGlobalMotion = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FilmGrain * pFilmGrain = {}; - }; - - struct DecodeAV1ReferenceInfoFlags - { - using NativeType = StdVideoDecodeAV1ReferenceInfoFlags; - - operator StdVideoDecodeAV1ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) && - ( reserved == rhs.reserved ); - } - - bool operator!=( DecodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t disable_frame_end_update_cdf : 1; - uint32_t segmentation_enabled : 1; - uint32_t reserved : 30; - }; - - struct DecodeAV1ReferenceInfo - { - using NativeType = StdVideoDecodeAV1ReferenceInfo; - - operator StdVideoDecodeAV1ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1ReferenceInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoDecodeAV1ReferenceInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( RefFrameSignBias == rhs.RefFrameSignBias ) && ( OrderHint == rhs.OrderHint ) && - ( SavedOrderHints == rhs.SavedOrderHints ); - } - - bool operator!=( DecodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::DecodeAV1ReferenceInfoFlags flags = {}; - uint8_t frame_type = {}; - uint8_t RefFrameSignBias = {}; - uint8_t OrderHint = {}; - ArrayWrapper1D SavedOrderHints = {}; - }; -#endif - -#if defined( VULKAN_VIDEO_CODEC_AV1STD_ENCODE_H_ ) - //=== vulkan_video_codec_av1std_encode === - - struct EncodeAV1DecoderModelInfo - { - using NativeType = StdVideoEncodeAV1DecoderModelInfo; - - operator StdVideoEncodeAV1DecoderModelInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1DecoderModelInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1DecoderModelInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1DecoderModelInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( buffer_delay_length_minus_1 == rhs.buffer_delay_length_minus_1 ) && - ( buffer_removal_time_length_minus_1 == rhs.buffer_removal_time_length_minus_1 ) && - ( frame_presentation_time_length_minus_1 == rhs.frame_presentation_time_length_minus_1 ) && ( reserved1 == rhs.reserved1 ) && - ( num_units_in_decoding_tick == rhs.num_units_in_decoding_tick ); - } - - bool operator!=( EncodeAV1DecoderModelInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint8_t buffer_delay_length_minus_1 = {}; - uint8_t buffer_removal_time_length_minus_1 = {}; - uint8_t frame_presentation_time_length_minus_1 = {}; - uint8_t reserved1 = {}; - uint32_t num_units_in_decoding_tick = {}; - }; - - struct EncodeAV1ExtensionHeader - { - using NativeType = StdVideoEncodeAV1ExtensionHeader; - - operator StdVideoEncodeAV1ExtensionHeader const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1ExtensionHeader &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1ExtensionHeader const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1ExtensionHeader *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( temporal_id == rhs.temporal_id ) && ( spatial_id == rhs.spatial_id ); - } - - bool operator!=( EncodeAV1ExtensionHeader const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint8_t temporal_id = {}; - uint8_t spatial_id = {}; - }; - - struct EncodeAV1OperatingPointInfoFlags - { - using NativeType = StdVideoEncodeAV1OperatingPointInfoFlags; - - operator StdVideoEncodeAV1OperatingPointInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1OperatingPointInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1OperatingPointInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1OperatingPointInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( decoder_model_present_for_this_op == rhs.decoder_model_present_for_this_op ) && ( low_delay_mode_flag == rhs.low_delay_mode_flag ) && - ( initial_display_delay_present_for_this_op == rhs.initial_display_delay_present_for_this_op ) && ( reserved == rhs.reserved ); - } - - bool operator!=( EncodeAV1OperatingPointInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t decoder_model_present_for_this_op : 1; - uint32_t low_delay_mode_flag : 1; - uint32_t initial_display_delay_present_for_this_op : 1; - uint32_t reserved : 29; - }; - - struct EncodeAV1OperatingPointInfo - { - using NativeType = StdVideoEncodeAV1OperatingPointInfo; - - operator StdVideoEncodeAV1OperatingPointInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1OperatingPointInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1OperatingPointInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1OperatingPointInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( operating_point_idc == rhs.operating_point_idc ) && ( seq_level_idx == rhs.seq_level_idx ) && - ( seq_tier == rhs.seq_tier ) && ( decoder_buffer_delay == rhs.decoder_buffer_delay ) && ( encoder_buffer_delay == rhs.encoder_buffer_delay ) && - ( initial_display_delay_minus_1 == rhs.initial_display_delay_minus_1 ); - } - - bool operator!=( EncodeAV1OperatingPointInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1OperatingPointInfoFlags flags = {}; - uint16_t operating_point_idc = {}; - uint8_t seq_level_idx = {}; - uint8_t seq_tier = {}; - uint32_t decoder_buffer_delay = {}; - uint32_t encoder_buffer_delay = {}; - uint8_t initial_display_delay_minus_1 = {}; - }; - - struct EncodeAV1PictureInfoFlags - { - using NativeType = StdVideoEncodeAV1PictureInfoFlags; - - operator StdVideoEncodeAV1PictureInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1PictureInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1PictureInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1PictureInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( error_resilient_mode == rhs.error_resilient_mode ) && ( disable_cdf_update == rhs.disable_cdf_update ) && - ( use_superres == rhs.use_superres ) && ( render_and_frame_size_different == rhs.render_and_frame_size_different ) && - ( allow_screen_content_tools == rhs.allow_screen_content_tools ) && ( is_filter_switchable == rhs.is_filter_switchable ) && - ( force_integer_mv == rhs.force_integer_mv ) && ( frame_size_override_flag == rhs.frame_size_override_flag ) && - ( buffer_removal_time_present_flag == rhs.buffer_removal_time_present_flag ) && ( allow_intrabc == rhs.allow_intrabc ) && - ( frame_refs_short_signaling == rhs.frame_refs_short_signaling ) && ( allow_high_precision_mv == rhs.allow_high_precision_mv ) && - ( is_motion_mode_switchable == rhs.is_motion_mode_switchable ) && ( use_ref_frame_mvs == rhs.use_ref_frame_mvs ) && - ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( allow_warped_motion == rhs.allow_warped_motion ) && - ( reduced_tx_set == rhs.reduced_tx_set ) && ( skip_mode_present == rhs.skip_mode_present ) && ( delta_q_present == rhs.delta_q_present ) && - ( delta_lf_present == rhs.delta_lf_present ) && ( delta_lf_multi == rhs.delta_lf_multi ) && - ( segmentation_enabled == rhs.segmentation_enabled ) && ( segmentation_update_map == rhs.segmentation_update_map ) && - ( segmentation_temporal_update == rhs.segmentation_temporal_update ) && ( segmentation_update_data == rhs.segmentation_update_data ) && - ( UsesLr == rhs.UsesLr ) && ( usesChromaLr == rhs.usesChromaLr ) && ( show_frame == rhs.show_frame ) && - ( showable_frame == rhs.showable_frame ) && ( reserved == rhs.reserved ); - } - - bool operator!=( EncodeAV1PictureInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t error_resilient_mode : 1; - uint32_t disable_cdf_update : 1; - uint32_t use_superres : 1; - uint32_t render_and_frame_size_different : 1; - uint32_t allow_screen_content_tools : 1; - uint32_t is_filter_switchable : 1; - uint32_t force_integer_mv : 1; - uint32_t frame_size_override_flag : 1; - uint32_t buffer_removal_time_present_flag : 1; - uint32_t allow_intrabc : 1; - uint32_t frame_refs_short_signaling : 1; - uint32_t allow_high_precision_mv : 1; - uint32_t is_motion_mode_switchable : 1; - uint32_t use_ref_frame_mvs : 1; - uint32_t disable_frame_end_update_cdf : 1; - uint32_t allow_warped_motion : 1; - uint32_t reduced_tx_set : 1; - uint32_t skip_mode_present : 1; - uint32_t delta_q_present : 1; - uint32_t delta_lf_present : 1; - uint32_t delta_lf_multi : 1; - uint32_t segmentation_enabled : 1; - uint32_t segmentation_update_map : 1; - uint32_t segmentation_temporal_update : 1; - uint32_t segmentation_update_data : 1; - uint32_t UsesLr : 1; - uint32_t usesChromaLr : 1; - uint32_t show_frame : 1; - uint32_t showable_frame : 1; - uint32_t reserved : 3; - }; - - struct EncodeAV1PictureInfo - { - using NativeType = StdVideoEncodeAV1PictureInfo; - - operator StdVideoEncodeAV1PictureInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1PictureInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1PictureInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1PictureInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( frame_type == rhs.frame_type ) && ( frame_presentation_time == rhs.frame_presentation_time ) && - ( current_frame_id == rhs.current_frame_id ) && ( order_hint == rhs.order_hint ) && ( primary_ref_frame == rhs.primary_ref_frame ) && - ( refresh_frame_flags == rhs.refresh_frame_flags ) && ( coded_denom == rhs.coded_denom ) && - ( render_width_minus_1 == rhs.render_width_minus_1 ) && ( render_height_minus_1 == rhs.render_height_minus_1 ) && - ( interpolation_filter == rhs.interpolation_filter ) && ( TxMode == rhs.TxMode ) && ( delta_q_res == rhs.delta_q_res ) && - ( delta_lf_res == rhs.delta_lf_res ) && ( ref_order_hint == rhs.ref_order_hint ) && ( ref_frame_idx == rhs.ref_frame_idx ) && - ( reserved1 == rhs.reserved1 ) && ( delta_frame_id_minus_1 == rhs.delta_frame_id_minus_1 ) && ( pTileInfo == rhs.pTileInfo ) && - ( pQuantization == rhs.pQuantization ) && ( pSegmentation == rhs.pSegmentation ) && ( pLoopFilter == rhs.pLoopFilter ) && - ( pCDEF == rhs.pCDEF ) && ( pLoopRestoration == rhs.pLoopRestoration ) && ( pGlobalMotion == rhs.pGlobalMotion ) && - ( pExtensionHeader == rhs.pExtensionHeader ) && ( pBufferRemovalTimes == rhs.pBufferRemovalTimes ); - } - - bool operator!=( EncodeAV1PictureInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1PictureInfoFlags flags = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey; - uint32_t frame_presentation_time = {}; - uint32_t current_frame_id = {}; - uint8_t order_hint = {}; - uint8_t primary_ref_frame = {}; - uint8_t refresh_frame_flags = {}; - uint8_t coded_denom = {}; - uint16_t render_width_minus_1 = {}; - uint16_t render_height_minus_1 = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter interpolation_filter = - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1InterpolationFilter::eEighttap; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode TxMode = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TxMode::eOnly4X4; - uint8_t delta_q_res = {}; - uint8_t delta_lf_res = {}; - ArrayWrapper1D ref_order_hint = {}; - ArrayWrapper1D ref_frame_idx = {}; - ArrayWrapper1D reserved1 = {}; - ArrayWrapper1D delta_frame_id_minus_1 = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1TileInfo * pTileInfo = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Quantization * pQuantization = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1Segmentation * pSegmentation = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopFilter * pLoopFilter = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1CDEF * pCDEF = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1LoopRestoration * pLoopRestoration = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1GlobalMotion * pGlobalMotion = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {}; - const uint32_t * pBufferRemovalTimes = {}; - }; - - struct EncodeAV1ReferenceInfoFlags - { - using NativeType = StdVideoEncodeAV1ReferenceInfoFlags; - - operator StdVideoEncodeAV1ReferenceInfoFlags const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1ReferenceInfoFlags &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1ReferenceInfoFlags const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1ReferenceInfoFlags *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( disable_frame_end_update_cdf == rhs.disable_frame_end_update_cdf ) && ( segmentation_enabled == rhs.segmentation_enabled ) && - ( reserved == rhs.reserved ); - } - - bool operator!=( EncodeAV1ReferenceInfoFlags const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - uint32_t disable_frame_end_update_cdf : 1; - uint32_t segmentation_enabled : 1; - uint32_t reserved : 30; - }; - - struct EncodeAV1ReferenceInfo - { - using NativeType = StdVideoEncodeAV1ReferenceInfo; - - operator StdVideoEncodeAV1ReferenceInfo const &() const VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1ReferenceInfo &() VULKAN_HPP_NOEXCEPT - { - return *reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1ReferenceInfo const *() const VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - operator StdVideoEncodeAV1ReferenceInfo *() VULKAN_HPP_NOEXCEPT - { - return reinterpret_cast( this ); - } - - bool operator==( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return ( flags == rhs.flags ) && ( RefFrameId == rhs.RefFrameId ) && ( frame_type == rhs.frame_type ) && ( OrderHint == rhs.OrderHint ) && - ( reserved1 == rhs.reserved1 ) && ( pExtensionHeader == rhs.pExtensionHeader ); - } - - bool operator!=( EncodeAV1ReferenceInfo const & rhs ) const VULKAN_HPP_NOEXCEPT - { - return !operator==( rhs ); - } - - public: - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ReferenceInfoFlags flags = {}; - uint32_t RefFrameId = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType frame_type = VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::AV1FrameType::eKey; - uint8_t OrderHint = {}; - ArrayWrapper1D reserved1 = {}; - const VULKAN_HPP_NAMESPACE::VULKAN_HPP_VIDEO_NAMESPACE::EncodeAV1ExtensionHeader * pExtensionHeader = {}; - }; -#endif - - } // namespace VULKAN_HPP_VIDEO_NAMESPACE -} // namespace VULKAN_HPP_NAMESPACE - -#if defined( has_include_was_not_defined ) -# undef has_include_was_not_defined -# undef __has_include -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_wayland.h b/lib/vulkan-headers/include/vulkan/vulkan_wayland.h deleted file mode 100644 index 41025db43b2..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_wayland.h +++ /dev/null @@ -1,59 +0,0 @@ -#ifndef VULKAN_WAYLAND_H_ -#define VULKAN_WAYLAND_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_KHR_wayland_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_wayland_surface 1 -#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 6 -#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface" -typedef VkFlags VkWaylandSurfaceCreateFlagsKHR; -typedef struct VkWaylandSurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkWaylandSurfaceCreateFlagsKHR flags; - struct wl_display* display; - struct wl_surface* surface; -} VkWaylandSurfaceCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( - VkInstance instance, - const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct wl_display* display); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_win32.h b/lib/vulkan-headers/include/vulkan/vulkan_win32.h deleted file mode 100644 index 5c7e8bd6d7e..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_win32.h +++ /dev/null @@ -1,372 +0,0 @@ -#ifndef VULKAN_WIN32_H_ -#define VULKAN_WIN32_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_KHR_win32_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_win32_surface 1 -#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 6 -#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface" -typedef VkFlags VkWin32SurfaceCreateFlagsKHR; -typedef struct VkWin32SurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkWin32SurfaceCreateFlagsKHR flags; - HINSTANCE hinstance; - HWND hwnd; -} VkWin32SurfaceCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( - VkInstance instance, - const VkWin32SurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex); -#endif -#endif - - -// VK_KHR_external_memory_win32 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_memory_win32 1 -#define VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_KHR_external_memory_win32" -typedef struct VkImportMemoryWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; -} VkImportMemoryWin32HandleInfoKHR; - -typedef struct VkExportMemoryWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; -} VkExportMemoryWin32HandleInfoKHR; - -typedef struct VkMemoryWin32HandlePropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryWin32HandlePropertiesKHR; - -typedef struct VkMemoryGetWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkMemoryGetWin32HandleInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleKHR)(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandlePropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleKHR( - VkDevice device, - const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandlePropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - HANDLE handle, - VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); -#endif -#endif - - -// VK_KHR_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_win32_keyed_mutex 1 -#define VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION 1 -#define VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_KHR_win32_keyed_mutex" -typedef struct VkWin32KeyedMutexAcquireReleaseInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t acquireCount; - const VkDeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeouts; - uint32_t releaseCount; - const VkDeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; -} VkWin32KeyedMutexAcquireReleaseInfoKHR; - - - -// VK_KHR_external_semaphore_win32 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_semaphore_win32 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME "VK_KHR_external_semaphore_win32" -typedef struct VkImportSemaphoreWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkSemaphoreImportFlags flags; - VkExternalSemaphoreHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; -} VkImportSemaphoreWin32HandleInfoKHR; - -typedef struct VkExportSemaphoreWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; -} VkExportSemaphoreWin32HandleInfoKHR; - -typedef struct VkD3D12FenceSubmitInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreValuesCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValuesCount; - const uint64_t* pSignalSemaphoreValues; -} VkD3D12FenceSubmitInfoKHR; - -typedef struct VkSemaphoreGetWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkSemaphoreGetWin32HandleInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreWin32HandleKHR)(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreWin32HandleKHR)(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreWin32HandleKHR( - VkDevice device, - const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreWin32HandleKHR( - VkDevice device, - const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle); -#endif -#endif - - -// VK_KHR_external_fence_win32 is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_external_fence_win32 1 -#define VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION 1 -#define VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME "VK_KHR_external_fence_win32" -typedef struct VkImportFenceWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkFenceImportFlags flags; - VkExternalFenceHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; -} VkImportFenceWin32HandleInfoKHR; - -typedef struct VkExportFenceWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; - LPCWSTR name; -} VkExportFenceWin32HandleInfoKHR; - -typedef struct VkFenceGetWin32HandleInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkExternalFenceHandleTypeFlagBits handleType; -} VkFenceGetWin32HandleInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkImportFenceWin32HandleKHR)(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); -typedef VkResult (VKAPI_PTR *PFN_vkGetFenceWin32HandleKHR)(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceWin32HandleKHR( - VkDevice device, - const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceWin32HandleKHR( - VkDevice device, - const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle); -#endif -#endif - - -// VK_NV_external_memory_win32 is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_external_memory_win32 1 -#define VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION 1 -#define VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME "VK_NV_external_memory_win32" -typedef struct VkImportMemoryWin32HandleInfoNV { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsNV handleType; - HANDLE handle; -} VkImportMemoryWin32HandleInfoNV; - -typedef struct VkExportMemoryWin32HandleInfoNV { - VkStructureType sType; - const void* pNext; - const SECURITY_ATTRIBUTES* pAttributes; - DWORD dwAccess; -} VkExportMemoryWin32HandleInfoNV; - -typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryWin32HandleNV)(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV( - VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagsNV handleType, - HANDLE* pHandle); -#endif -#endif - - -// VK_NV_win32_keyed_mutex is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_win32_keyed_mutex 1 -#define VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION 2 -#define VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME "VK_NV_win32_keyed_mutex" -typedef struct VkWin32KeyedMutexAcquireReleaseInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t acquireCount; - const VkDeviceMemory* pAcquireSyncs; - const uint64_t* pAcquireKeys; - const uint32_t* pAcquireTimeoutMilliseconds; - uint32_t releaseCount; - const VkDeviceMemory* pReleaseSyncs; - const uint64_t* pReleaseKeys; -} VkWin32KeyedMutexAcquireReleaseInfoNV; - - - -// VK_EXT_full_screen_exclusive is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_full_screen_exclusive 1 -#define VK_EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION 4 -#define VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME "VK_EXT_full_screen_exclusive" - -typedef enum VkFullScreenExclusiveEXT { - VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT = 0, - VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT = 1, - VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT = 2, - VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT = 3, - VK_FULL_SCREEN_EXCLUSIVE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkFullScreenExclusiveEXT; -typedef struct VkSurfaceFullScreenExclusiveInfoEXT { - VkStructureType sType; - void* pNext; - VkFullScreenExclusiveEXT fullScreenExclusive; -} VkSurfaceFullScreenExclusiveInfoEXT; - -typedef struct VkSurfaceCapabilitiesFullScreenExclusiveEXT { - VkStructureType sType; - void* pNext; - VkBool32 fullScreenExclusiveSupported; -} VkSurfaceCapabilitiesFullScreenExclusiveEXT; - -typedef struct VkSurfaceFullScreenExclusiveWin32InfoEXT { - VkStructureType sType; - const void* pNext; - HMONITOR hmonitor; -} VkSurfaceFullScreenExclusiveWin32InfoEXT; - -typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); -typedef VkResult (VKAPI_PTR *PFN_vkAcquireFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain); -typedef VkResult (VKAPI_PTR *PFN_vkReleaseFullScreenExclusiveModeEXT)(VkDevice device, VkSwapchainKHR swapchain); -typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModes2EXT)(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModes2EXT( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireFullScreenExclusiveModeEXT( - VkDevice device, - VkSwapchainKHR swapchain); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkReleaseFullScreenExclusiveModeEXT( - VkDevice device, - VkSwapchainKHR swapchain); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModes2EXT( - VkDevice device, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkDeviceGroupPresentModeFlagsKHR* pModes); -#endif -#endif - - -// VK_NV_acquire_winrt_display is a preprocessor guard. Do not pass it to API calls. -#define VK_NV_acquire_winrt_display 1 -#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1 -#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display" -typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); -typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - uint32_t deviceRelativeId, - VkDisplayKHR* pDisplay); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_xcb.h b/lib/vulkan-headers/include/vulkan/vulkan_xcb.h deleted file mode 100644 index 473f8c2887a..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_xcb.h +++ /dev/null @@ -1,60 +0,0 @@ -#ifndef VULKAN_XCB_H_ -#define VULKAN_XCB_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_KHR_xcb_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_xcb_surface 1 -#define VK_KHR_XCB_SURFACE_SPEC_VERSION 6 -#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface" -typedef VkFlags VkXcbSurfaceCreateFlagsKHR; -typedef struct VkXcbSurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkXcbSurfaceCreateFlagsKHR flags; - xcb_connection_t* connection; - xcb_window_t window; -} VkXcbSurfaceCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( - VkInstance instance, - const VkXcbSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - xcb_connection_t* connection, - xcb_visualid_t visual_id); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_xlib.h b/lib/vulkan-headers/include/vulkan/vulkan_xlib.h deleted file mode 100644 index dfd107c3e2f..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_xlib.h +++ /dev/null @@ -1,60 +0,0 @@ -#ifndef VULKAN_XLIB_H_ -#define VULKAN_XLIB_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_KHR_xlib_surface is a preprocessor guard. Do not pass it to API calls. -#define VK_KHR_xlib_surface 1 -#define VK_KHR_XLIB_SURFACE_SPEC_VERSION 6 -#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface" -typedef VkFlags VkXlibSurfaceCreateFlagsKHR; -typedef struct VkXlibSurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkXlibSurfaceCreateFlagsKHR flags; - Display* dpy; - Window window; -} VkXlibSurfaceCreateInfoKHR; - -typedef VkResult (VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -typedef VkBool32 (VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( - VkInstance instance, - const VkXlibSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - Display* dpy, - VisualID visualID); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/lib/vulkan-headers/include/vulkan/vulkan_xlib_xrandr.h b/lib/vulkan-headers/include/vulkan/vulkan_xlib_xrandr.h deleted file mode 100644 index a272e246ceb..00000000000 --- a/lib/vulkan-headers/include/vulkan/vulkan_xlib_xrandr.h +++ /dev/null @@ -1,50 +0,0 @@ -#ifndef VULKAN_XLIB_XRANDR_H_ -#define VULKAN_XLIB_XRANDR_H_ 1 - -/* -** Copyright 2015-2026 The Khronos Group Inc. -** -** SPDX-License-Identifier: Apache-2.0 -*/ - -/* -** This header is generated from the Khronos Vulkan XML API Registry. -** -*/ - - -#ifdef __cplusplus -extern "C" { -#endif - - - -// VK_EXT_acquire_xlib_display is a preprocessor guard. Do not pass it to API calls. -#define VK_EXT_acquire_xlib_display 1 -#define VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION 1 -#define VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_xlib_display" -typedef VkResult (VKAPI_PTR *PFN_vkAcquireXlibDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display); -typedef VkResult (VKAPI_PTR *PFN_vkGetRandROutputDisplayEXT)(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay); - -#ifndef VK_NO_PROTOTYPES -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - VkDisplayKHR display); -#endif - -#ifndef VK_ONLY_EXPORTED_PROTOTYPES -VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - RROutput rrOutput, - VkDisplayKHR* pDisplay); -#endif -#endif - -#ifdef __cplusplus -} -#endif - -#endif From 0ca0a004fc7845697a3e62698cd017df709fdd8a Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Wed, 22 Jul 2026 21:42:46 -0300 Subject: [PATCH 08/15] force use prebuilt vulkan --- CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index c0b28bb4e20..2acc82dbc3c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -54,6 +54,7 @@ if (ANDROID) set(USING_PREBUILT_LIBS ON FORCE) set(SDL2_USE_PRECOMPILED ON FORCE) set(OPENAL_USE_PRECOMPILED ON FORCE) + set(USING_PREBUILT_VULKAN ON FORCE) endif() # Check if the external modules exists From 2d64531757ac7579e3609957760527dee8c292a6 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Wed, 22 Jul 2026 23:46:00 -0300 Subject: [PATCH 09/15] fix vulkan inverted screen --- code/graphics/vulkan/VulkanRendererSetup.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/code/graphics/vulkan/VulkanRendererSetup.cpp b/code/graphics/vulkan/VulkanRendererSetup.cpp index 20877bcb434..5081d2b2676 100644 --- a/code/graphics/vulkan/VulkanRendererSetup.cpp +++ b/code/graphics/vulkan/VulkanRendererSetup.cpp @@ -1049,7 +1049,13 @@ bool VulkanRenderer::createSwapChain(const PhysicalDeviceValues& deviceValues, v createInfo.imageSharingMode = vk::SharingMode::eExclusive; } - createInfo.preTransform = deviceValues.surfaceCapabilities.currentTransform; + auto supported = deviceValues.surfaceCapabilities.supportedTransforms; + if (supported & vk::SurfaceTransformFlagBitsKHR::eIdentity) { + createInfo.preTransform = vk::SurfaceTransformFlagBitsKHR::eIdentity; + } + else { + createInfo.preTransform = deviceValues.surfaceCapabilities.currentTransform; + } createInfo.compositeAlpha = vk::CompositeAlphaFlagBitsKHR::eOpaque; createInfo.presentMode = choosePresentMode(deviceValues); createInfo.clipped = true; From 6f96a61009220ed8a49002d2974568c8c12d8b2f Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Fri, 24 Jul 2026 22:44:00 -0300 Subject: [PATCH 10/15] fix find sdl3 precompiled android --- CMakeLists.txt | 1 + lib/SDL3.cmake | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 2acc82dbc3c..2ec3f4fc376 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -53,6 +53,7 @@ if (ANDROID) set(FSO_BUILD_INCLUDED_LIBS ON FORCE) set(USING_PREBUILT_LIBS ON FORCE) set(SDL2_USE_PRECOMPILED ON FORCE) + set(SDL3_USE_PRECOMPILED ON FORCE) set(OPENAL_USE_PRECOMPILED ON FORCE) set(USING_PREBUILT_VULKAN ON FORCE) endif() diff --git a/lib/SDL3.cmake b/lib/SDL3.cmake index 3ba8b542c5e..1f5c1e042a6 100644 --- a/lib/SDL3.cmake +++ b/lib/SDL3.cmake @@ -66,7 +66,7 @@ else() message(STATUS "Using pre-built SDL3 library.") unset(SDL3_LOCATION CACHE) - find_library(SDL3_LOCATION NAMES SDL3 SDL3-3.0 PATHS "${SDL3_ROOT_DIR}/lib" NO_DEFAULT_PATH) + find_library(SDL3_LOCATION NAMES SDL3 SDL3-3.0 PATHS "${SDL3_ROOT_DIR}/lib" NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) get_filename_component(FULL_LIB_PATH "${SDL3_LOCATION}" REALPATH) ADD_IMPORTED_LIB(sdl3 "${SDL3_ROOT_DIR}/include" "${FULL_LIB_PATH}") From f53a954b0ca9434b90eb3155e4e1b17b82f74e4f Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Fri, 24 Jul 2026 23:39:56 -0300 Subject: [PATCH 11/15] Update CMakeLists.txt --- CMakeLists.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 2ec3f4fc376..60218129093 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -52,7 +52,6 @@ if (ANDROID) add_definitions(-DPLATFORM_ANDROID) set(FSO_BUILD_INCLUDED_LIBS ON FORCE) set(USING_PREBUILT_LIBS ON FORCE) - set(SDL2_USE_PRECOMPILED ON FORCE) set(SDL3_USE_PRECOMPILED ON FORCE) set(OPENAL_USE_PRECOMPILED ON FORCE) set(USING_PREBUILT_VULKAN ON FORCE) From c85b28a30d3d0b7f3d640971690728f2942a20b4 Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Fri, 24 Jul 2026 23:45:22 -0300 Subject: [PATCH 12/15] replace sdl2 android function names for sdl3 versions --- code/external_dll/externalcode.h | 2 +- code/osapi/osapi.cpp | 12 ++++++------ code/sound/speech_android.cpp | 22 +++++++++++----------- 3 files changed, 18 insertions(+), 18 deletions(-) diff --git a/code/external_dll/externalcode.h b/code/external_dll/externalcode.h index 6fb3c41fbf4..1f6ddee84dd 100644 --- a/code/external_dll/externalcode.h +++ b/code/external_dll/externalcode.h @@ -31,7 +31,7 @@ class SCP_ExternalCode #ifdef __ANDROID__ if (m_library == NULL) { - auto android_path = SDL_AndroidGetInternalStoragePath(); + auto android_path = SDL_GetAndroidInternalStoragePath(); if (android_path != nullptr) { SCP_string android_full_path = android_path; if (android_full_path.back() != DIR_SEPARATOR_CHAR) { diff --git a/code/osapi/osapi.cpp b/code/osapi/osapi.cpp index ef9614cc2ad..15090546d7d 100644 --- a/code/osapi/osapi.cpp +++ b/code/osapi/osapi.cpp @@ -906,8 +906,8 @@ static jmethodID android_get_static_method(JNIEnv* e, jclass cls, const char* na void os_set_flags_string(const char* json) { //Get the JNI Environment pointer and current Activity instance via SDL - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); - jobject activity = (jobject)SDL_AndroidGetActivity(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); + jobject activity = (jobject)SDL_GetAndroidActivity(); if (env && activity) { // Locate the Java class (FlagsActivity / GameActivity on KnossosNET) @@ -939,8 +939,8 @@ SCP_string os_get_working_folder_path() SCP_string wfp{}; //Get the JNI Environment pointer and current Activity instance via SDL - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); - jobject activity = (jobject)SDL_AndroidGetActivity(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); + jobject activity = (jobject)SDL_GetAndroidActivity(); if (env && activity) { // Locate the Java class (GameActivity on KnossosNET) @@ -991,8 +991,8 @@ SCP_string os_get_working_folder_path() void os_touch_overlay_toggle(bool status) { //Get the JNI Environment pointer and current Activity instance via SDL - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); - jobject activity = (jobject)SDL_AndroidGetActivity(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); + jobject activity = (jobject)SDL_GetAndroidActivity(); if (env && activity) { // Locate the Java class (GameActivity on KnossosNET) diff --git a/code/sound/speech_android.cpp b/code/sound/speech_android.cpp index 6a5a2b5e0c9..d95d133a36b 100644 --- a/code/sound/speech_android.cpp +++ b/code/sound/speech_android.cpp @@ -41,8 +41,8 @@ bool speech_init() mprintf(("Speech : Try to init TTSManager on GameActivity...\n")); // Get the JNI Environment pointer and current Activity instance via SDL - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); - jobject activity = (jobject)SDL_AndroidGetActivity(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); + jobject activity = (jobject)SDL_GetAndroidActivity(); if (env == nullptr) { mprintf(("Speech : Unable to get JNI environment!\n")); @@ -101,7 +101,7 @@ bool speech_play(const SCP_string& text) return false; } - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); if (env == nullptr) { mprintf(("Speech : Unable to get JNI environment!\n")); return false; @@ -123,7 +123,7 @@ bool speech_stop() if (!Speech_init) return false; - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); if (env == nullptr) { mprintf(("Speech : Unable to get JNI environment!\n")); return false; @@ -137,7 +137,7 @@ bool speech_pause() if (!Speech_init) return false; - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); if (env == nullptr) { mprintf(("Speech : Unable to get JNI environment!\n")); return false; @@ -151,7 +151,7 @@ bool speech_resume() if (!Speech_init) return false; - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); if (env == nullptr) { mprintf(("Speech : Unable to get JNI environment!\n")); return false; @@ -165,7 +165,7 @@ bool speech_is_speaking() if (!Speech_init) return false; - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); if (env == nullptr) { mprintf(("Speech : Unable to get JNI environment!\n")); return false; @@ -179,7 +179,7 @@ void speech_deinit() if (!Speech_init) return; - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); if (env != nullptr) { env->CallStaticVoidMethod(j_game_class, tts_shutdown); env->DeleteGlobalRef(j_game_class); @@ -217,7 +217,7 @@ bool speech_set_rate(float rate_percent) else if(rate_percent < 50.0) rate_percent = 50.0; - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); if (env == nullptr) { mprintf(("Speech : Unable to get JNI environment!\n")); return false; @@ -233,7 +233,7 @@ bool speech_set_voice(int voice) if (!Speech_init) return false; - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); if (env == nullptr) { mprintf(("Speech : Unable to get JNI environment!\n")); return false; @@ -263,7 +263,7 @@ SCP_vector> speech_enumerate_voices() if (!Speech_init) return voices; - JNIEnv* env = (JNIEnv*)SDL_AndroidGetJNIEnv(); + JNIEnv* env = (JNIEnv*)SDL_GetAndroidJNIEnv(); if (env == nullptr) { mprintf(("Speech : Unable to get JNI environment!\n")); return voices; From b381b7de7fc56c50586be348293a9fa1f67ffaea Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 25 Jul 2026 00:01:32 -0300 Subject: [PATCH 13/15] change sdl includes in osapi --- code/osapi/osapi.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/code/osapi/osapi.cpp b/code/osapi/osapi.cpp index 15090546d7d..6d813336985 100644 --- a/code/osapi/osapi.cpp +++ b/code/osapi/osapi.cpp @@ -29,8 +29,8 @@ #endif #ifdef __ANDROID__ -#include -#include +#include "SDL_system.h" +#include "SDL.h" #include #include "options/Option.h" #endif From 8ddb264dc5f60b219e4b119059ddc79efcd3a10e Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 25 Jul 2026 00:20:02 -0300 Subject: [PATCH 14/15] fix sdl3 includes, again --- code/osapi/osapi.cpp | 4 ++-- code/sound/speech_android.cpp | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/code/osapi/osapi.cpp b/code/osapi/osapi.cpp index 6d813336985..012d8a1afcb 100644 --- a/code/osapi/osapi.cpp +++ b/code/osapi/osapi.cpp @@ -29,8 +29,8 @@ #endif #ifdef __ANDROID__ -#include "SDL_system.h" -#include "SDL.h" +#include +#include #include #include "options/Option.h" #endif diff --git a/code/sound/speech_android.cpp b/code/sound/speech_android.cpp index d95d133a36b..2f68d4d4fff 100644 --- a/code/sound/speech_android.cpp +++ b/code/sound/speech_android.cpp @@ -4,8 +4,8 @@ #include "utils/unicode.h" #include "speech.h" #include -#include "SDL.h" -#include "SDL_system.h" +#include +#include bool Speech_init = false; static jclass j_game_class = nullptr; From a2fe9dba3bb8cb09cc39e9c91e6ecd4cd134cd2f Mon Sep 17 00:00:00 2001 From: Salvador Cipolla Date: Sat, 25 Jul 2026 00:32:40 -0300 Subject: [PATCH 15/15] rename function to sdl3 name --- code/osapi/osapi.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/code/osapi/osapi.cpp b/code/osapi/osapi.cpp index 012d8a1afcb..3556c030c93 100644 --- a/code/osapi/osapi.cpp +++ b/code/osapi/osapi.cpp @@ -973,7 +973,7 @@ SCP_string os_get_working_folder_path() if (wfp.empty()) { mprintf(("Couldn't get working folder path from Java class, reverting to SDL default.\n")); // Fallback to app space on internal storage - const char* fallbackPath = SDL_AndroidGetExternalStoragePath(); + const char* fallbackPath = SDL_GetAndroidExternalStoragePath(); if (fallbackPath) { wfp = SCP_string(fallbackPath); wfp += "/files/";